diff --git a/collects/mrdemo/keymap.ss b/collects/mrdemo/keymap.ss
new file mode 100644
index 0000000..496ebf2
--- /dev/null
+++ b/collects/mrdemo/keymap.ss
@@ -0,0 +1,16 @@
+; We'll use the same function as both a keyboard and mouse event
+;  handler. If it's a mouse event, we only want to insert something
+;  on the button-down part
+(define insert-star
+  (lambda (edit event)
+    (if (or (not (is-a? event wx:mouse-event%))
+	    (send event button-down?))
+	(send edit insert "*"))
+    #t))
+
+(let ((kmap (send mred:console-edit get-keymap)))
+	(send kmap add-key-function "insert-star" insert-star)	
+	(send kmap add-mouse-function "insert-star" insert-star)	
+	(send kmap map-function "c:." "insert-star")
+	(send kmap map-function "ESC;rightbutton" "insert-star"))
+
diff --git a/collects/mrdemo/load.ss b/collects/mrdemo/load.ss
new file mode 100644
index 0000000..2132b5d
--- /dev/null
+++ b/collects/mrdemo/load.ss
@@ -0,0 +1,2 @@
+
+(load "demo.ss")
diff --git a/collects/mrdemo/mines.mre b/collects/mrdemo/mines.mre
new file mode 100644
index 0000000..3609e91
Binary files /dev/null and b/collects/mrdemo/mines.mre differ
diff --git a/collects/mrdemo/mines.ss b/collects/mrdemo/mines.ss
new file mode 100644
index 0000000..db3d30f
--- /dev/null
+++ b/collects/mrdemo/mines.ss
@@ -0,0 +1,379 @@
+
+(require-library "macro.ss")
+
+(define TILE-HW 24)
+(define WIDTH 16)
+(define HEIGHT 16)
+(define BOMB-COUNT 30)
+
+; Temporary
+(define FRDW 12)
+(define FRDH 39)
+(define PANEL-HEIGHT 50)
+(define TIME-WIDTH 600)
+(define COUNT-WIDTH 600)
+
+(define DIGIT-COLOR-NAMES
+  ; 0th is background; 8th is foreground
+  (vector "LIGHT GREY" "BLUE" "GREEN" "RED" "PURPLE" "ORANGE" "YELLOW" "BROWN" "BLACK"))
+
+(define DIGIT-COLORS
+  (build-vector 9 (lambda (i)
+		    (send wx:the-colour-database find-colour 
+			  (vector-ref DIGIT-COLOR-NAMES i)))))
+
+(define BG-COLOR (vector-ref DIGIT-COLORS 0))
+(define FG-COLOR (vector-ref DIGIT-COLORS 8))
+(define EXPLODE-COLOR (send wx:the-colour-database find-colour "RED"))
+
+(define BG-PEN (send wx:the-pen-list find-or-create-pen BG-COLOR 1 wx:const-solid))
+(define FG-PEN (send wx:the-pen-list find-or-create-pen FG-COLOR 1 wx:const-solid))
+
+(define step-while
+  (opt-lambda (first test until step f [accum void] [init (void)])
+    (let loop ([n first][a init])
+      (if (test n until)
+	  (loop (step n) (accum a (f n)))
+	  a))))
+
+(define tile:plain%
+  (class null ()
+    (private
+      [state 'covered]
+      [neighbor-bomb-count 0])
+    (public
+      [set-state
+       (lambda (newstate)
+	 (set! state newstate))]
+      [get-state
+       (lambda ()
+	 state)]
+      [set-neighbor-bomb-count
+       (lambda (c)
+	 (set! neighbor-bomb-count c))]
+      [get-neighbor-bomb-count
+       (lambda ()
+	 neighbor-bomb-count)]
+      [draw-text-tile
+       (lambda (dc x y w h hilite? border? str color)
+	 (if border?
+	     (send dc set-pen FG-PEN)
+	     (send dc set-pen BG-PEN))
+	 (send dc draw-rectangle x y w h)
+	 (when hilite?
+	   (send dc draw-rectangle 
+		 (add1 x) (add1 y) 
+		 (- w 2) (- h 2)))
+	 (when str
+	   (if color
+	       (send dc set-text-foreground color)
+	       (send dc set-text-foreground FG-COLOR))
+	   (let ([tw (box 0)][th (box 0)])
+	     (send dc get-text-extent str tw th)
+	     (send dc draw-text str 
+		   (+ x (/ (- w (unbox tw)) 2))
+		   (+ y (/ (- h (unbox th)) 2))))))]
+      [draw
+       (lambda (dc x y w h hilite?)
+	 (case state
+	   [(covered) (draw-text-tile dc x y w h hilite? #t #f #f)]
+	   [(flagged) (draw-text-tile dc x y w h hilite? #t "X" #f)]
+	   [(semi-flagged) (draw-text-tile dc x y w h hilite? #t "?" #f)]
+	   [(uncovered) (draw-text-tile 
+			 dc x y w h #f #f
+			 (if (zero? neighbor-bomb-count)
+			     #f
+			     (number->string neighbor-bomb-count))
+			 (vector-ref DIGIT-COLORS neighbor-bomb-count))]))])))
+
+(define tile:bomb%
+  (class tile:plain% ()
+    (inherit get-state draw-text-tile)
+    (rename [super-draw draw])
+    (private
+      [explode-source? #f])
+    (public
+      [set-explode-source
+       (lambda (s?)
+	 (set! explode-source? s?))]
+      [draw
+       (lambda (dc x y w h hilite?)
+	 (if (eq? (get-state) 'uncovered)
+	     (draw-text-tile dc x y w h #f #f "*"
+			     (and explode-source? EXPLODE-COLOR))
+	     (super-draw dc x y w h hilite?)))])
+    (sequence
+      (super-init))))
+
+(define (get-tile b x y)
+  (vector-ref (vector-ref b x) y))
+
+(define (set-tile! b x y t)
+  (vector-set! (vector-ref b x) y t))
+
+(define (do-surrounding b x y accum start default f)
+  (step-while -1 <= 1 add1
+	      (lambda (dx)
+		(step-while -1 <= 1 add1
+			   (lambda (dy)
+			     (if (and (not (and (zero? dx) (zero? dy)))
+				      (< -1 (+ x dx) WIDTH)
+				      (< -1 (+ y dy) HEIGHT))
+				 (f dx dy)
+				 default))
+			   accum start))
+	      accum start))
+
+(define (is-bomb? x)
+  (is-a? x tile:bomb%))
+
+(define (count-surrounding-bombs b x y)
+  (do-surrounding 
+   b x y + 0 0
+   (lambda (dx dy)
+     (if (is-bomb? (get-tile b (+ x dx) (+ y dy)))
+	 1
+	 0))))
+
+(define (for-each-tile b f)
+  (step-while 0 < WIDTH add1
+	      (lambda (x)
+		(step-while 0 < HEIGHT add1
+			    (lambda (y)
+			      (f (get-tile b x y) x y))))))
+
+(define (make-board)
+  (let ([b (build-vector WIDTH
+			 (lambda (i)
+			   (build-vector HEIGHT
+					 (lambda (j)
+					   (make-object tile:plain%)))))])
+    (let loop ([n BOMB-COUNT])
+      (unless (zero? n)
+	(let rloop ()
+	  (let* ([x (random WIDTH)]
+		 [y (random HEIGHT)]
+		 [t (get-tile b x y)])
+	    (if (is-a? t tile:bomb%)
+		(rloop)
+		(begin
+		  (set-tile! b x y (make-object tile:bomb%))
+		  (loop (sub1 n))))))))
+    (for-each-tile b (lambda (t x y)
+		       (send t
+			     set-neighbor-bomb-count
+			     (count-surrounding-bombs b x y))))
+    b))
+
+(define f (make-object mred:frame% null "Minesweeper"))
+(define vpanel (make-object mred:vertical-panel% f))
+
+(define ms:canvas%
+  (class mred:canvas% args
+    (inherit get-dc clear 
+	     set-min-width set-min-height 
+	     stretchable-in-x stretchable-in-y)
+    (private
+      [panel (make-object mred:horizontal-panel% vpanel)])
+    (sequence
+      (send panel stretchable-in-y #f))
+    (private
+      [lspace (make-object mred:vertical-panel% panel)]
+      [time (make-object mred:message% panel "Time: 00000")]
+      [lmspace (make-object mred:vertical-panel% panel)]
+      [button (make-object mred:button% panel (lambda (b e) (reset)) "Reset")]
+      [rmspace (make-object mred:vertical-panel% panel)]
+      [count (make-object mred:message% panel "Count: 000")]
+      [rspace (make-object mred:vertical-panel% panel)]
+
+      [set-time
+       (lambda (t)
+	 (send time set-label (string-append "Time: " (number->string t))))]
+      [set-count
+       (lambda (c)
+	 (send count set-label (string-append "Bombs: " (number->string c))))]
+      
+      [clicking #f]
+      [clicking-x 0]
+      [clicking-y 0]
+      [ready? #t]
+      [start-time #f]
+      [elapsed-time 0]
+      [timer #f]
+      [bomb-count BOMB-COUNT]
+      [cover-count (* HEIGHT WIDTH)]
+      [board null])
+    (public
+      (stop-timer
+       (lambda ()
+	 (when timer
+	   (send timer stop)
+	   (set! timer #f))))
+      (start-timer
+       (lambda ()
+	 (set! start-time (current-seconds))
+	 (set! timer
+	       (make-object
+		(class-asi wx:timer%
+		  (public
+		    [notify
+		     (lambda ()
+		       (let ([e (- (current-seconds) start-time)])
+			 (when (> e elapsed-time)
+			   (set! elapsed-time e)
+			   (set-time e))))]))))
+	 (send timer start 100 #f)))
+      (end-of-game
+       (lambda (win?)
+	 (stop-timer)
+	 (set! ready? #f)
+	 (set! start-time #f)
+	 (unless win?
+	   (show-all-bombs))
+	 (set-count BOMB-COUNT)))
+      (explode
+       (lambda ()
+	 (end-of-game #f)))
+      (win
+       (lambda ()
+	 (end-of-game #t)))
+      (reset
+       (lambda ()
+	 (stop-timer)
+	 (set! ready? #t)
+	 (set! start-time #f)
+	 (set! elapsed-time 0)
+	 (set! cover-count (* HEIGHT WIDTH))
+	 (clear)
+	 (set-time 0)
+	 (set! bomb-count BOMB-COUNT)
+	 (set-count BOMB-COUNT)
+	 (set! board (make-board))
+	 (on-paint)))
+      (show-all-bombs
+       (lambda ()
+	 (for-each-tile board
+			(lambda (t x y)
+			  (when (is-bomb? t)
+			    (change-state t (send t get-state) 'uncovered #f)
+			    (paint-one t x y))))))
+      (autoclick-surrounding 
+       (lambda (x y)
+	 (do-surrounding 
+	  board x y void (void) (void)
+	  (lambda (dx dy)
+	    (let* ([x2 (+ x dx)]
+		   [y2 (+ y dy)]
+		   [t (get-tile board x2 y2)]
+		   [state (send t get-state)]
+		   [nc (send t get-neighbor-bomb-count)])
+	      (unless (eq? state 'uncovered)
+		(change-state t state 'uncovered #t)
+		(paint-one t x2 y2)
+		(when (zero? nc)
+		  (autoclick-surrounding x2 y2))))))))
+      (change-state
+       (lambda (t old-state new-state update-count?)
+	 (send t set-state new-state)
+	 (when (and update-count? (not (eq? new-state old-state)))
+	   (when (eq? new-state 'uncovered)
+	     (set! cover-count (sub1 cover-count)))
+	   (when (eq? old-state 'uncovered)
+	     (set! cover-count (add1 cover-count)))
+	   (when (eq? new-state 'flagged)
+	     (set! bomb-count (sub1 bomb-count))
+	     (set-count bomb-count))
+	   (when (eq? old-state 'flagged)
+	     (set! bomb-count (add1 bomb-count))
+	     (set-count bomb-count)))))
+      (do-select
+       (lambda (x y flag?)
+	 (let* ([t (get-tile board x y)]
+		[state (send t get-state)]
+		[new-state
+		 (case state
+		   [(covered)
+		    (if flag? 'flagged 'uncovered)]
+		   [(flagged)
+		    (if flag? 'semi-flagged state)]
+		   [(semi-flagged)
+		    (if flag? 'covered 'uncovered)]
+		   [else state])]
+		[nc (send t get-neighbor-bomb-count)]
+		[new-uncover? (and (eq? new-state 'uncovered)
+				   (not (eq? state 'uncovered)))]
+		[bomb? (is-bomb? t)])
+	   (change-state t state new-state #t)
+	   (when (and new-uncover? bomb?)
+	     (send t set-explode-source #t))
+	   (paint-one t x y)
+	   (when new-uncover?
+	     (if bomb?
+		 (explode)
+		 (begin
+		   (when (zero? nc)
+		     (autoclick-surrounding x y))))
+	     (when (and ready? (= cover-count BOMB-COUNT))
+	       (win))))))
+      (on-event
+       (lambda (e)
+	 (when ready?
+	   (unless start-time
+	     (when (send e button-down?)
+	       (start-timer)))
+	   (let* ([x (quotient (inexact->exact (floor (send e get-x))) TILE-HW)]
+		  [y (quotient (inexact->exact (floor (send e get-y))) TILE-HW)]
+		  [t (if (and (< -1 x WIDTH)
+			      (< -1 y HEIGHT))
+			 (get-tile board x y)
+			 #f)])
+	     (cond
+	       [(and clicking (or (not (eq? t clicking))
+				  (not (or (send e button-up?)
+					   (send e dragging?)))))
+		(let ([old clicking])
+		  (set! clicking #f)
+		  (paint-one old clicking-x clicking-y))]
+	       [(and t
+		     (not (eq? (send t get-state) 'uncovered))
+		     (or (send e button-down?)
+			 (and (send e dragging?)
+			      (= x clicking-x)
+			      (= y clicking-y))))
+		(set! clicking t)
+		(set! clicking-x x)
+		(set! clicking-y y)
+		(paint-one t x y)]
+	       [(send e button-down?) ; click not on a tile
+		(set! clicking-x -1)]
+	       [(and clicking (send e button-up?))
+		(set! clicking #f)
+		(do-select x y (send e button-up? 3))]
+	       [else 'ok])))))
+      (paint-one
+       (lambda (t x y)
+	 (let ([xloc (* x TILE-HW)]
+	       [yloc (* y TILE-HW)])
+	   (send t draw dc xloc yloc TILE-HW TILE-HW
+		 (eq? t clicking)))))
+      (on-paint
+       (lambda ()
+	 (for-each-tile board (lambda (t x y)
+				(paint-one t x y))))))
+    (sequence
+      (apply super-init args)
+      (set-min-width (* TILE-HW WIDTH))
+      (set-min-height (* TILE-HW HEIGHT))
+      (stretchable-in-x #f)
+      (stretchable-in-y #f))
+    (private
+      [dc (get-dc)])
+    (sequence
+      (reset)
+      (send dc set-text-background BG-COLOR)
+      (send dc set-brush (send wx:the-brush-list find-or-create-brush 
+			       BG-COLOR wx:const-solid)))))
+
+(define c (make-object ms:canvas% vpanel))
+
+(send f show #t)
diff --git a/collects/mrdemo/morph.mre b/collects/mrdemo/morph.mre
new file mode 100644
index 0000000..6dc9fae
Binary files /dev/null and b/collects/mrdemo/morph.mre differ
diff --git a/collects/mrdemo/morph.ss b/collects/mrdemo/morph.ss
new file mode 100644
index 0000000..6de97a5
--- /dev/null
+++ b/collects/mrdemo/morph.ss
@@ -0,0 +1 @@
+(load-relative (build-path "morph" "load.ss"))
diff --git a/collects/mrdemo/morph/2darray.ss b/collects/mrdemo/morph/2darray.ss
new file mode 100644
index 0000000..da8bc7c
--- /dev/null
+++ b/collects/mrdemo/morph/2darray.ss
@@ -0,0 +1,57 @@
+(define 2d-vector%
+  (make-class ()
+    (private
+     [default? #f]
+     [default (void)]
+     [vec (void)]
+     [found-error
+      (lambda (x w h)
+	(error '2d-vector% "~s out of bounds: ~s ~s; array size ~sx~s"
+	       x w h width height))]
+     [index (lambda (w h) (+ (* h width) w))])
+    (public
+     [height (void)]
+     [width (void)]
+     [set-default
+      (lambda (d)
+	(set! default? #t)
+	(set! default d))]
+     [no-default (lambda () (set! default? #f))]
+     [straighten (lambda () vec)]
+     [bend (lambda (list)
+	     (when (not (list? list))
+	       (error '2d-vector%
+		      "bend expected a list, found: ~s" list))
+	     (when (not (= (length list) (* height width)))
+	       (error '2d-vector%
+		      (string-append "attempted to bend a list of length ~s,"
+				     " should have length ~s")
+		      (length list) (* height width)))
+	     (set! vec (list->vector list)))]
+     [update (lambda (w h v)
+	       (let ([w (floor w)]
+		     [h (floor h)])
+		 (debug-print 2d-vector% 'width width 'height height w h
+			      'index (index w h))
+		 (if (and (<= 0 w) (< w width) (<= 0 h) (< h height))
+		     (vector-set! vec (index w h) v)
+		     (found-error 'update w h))))]
+     [lookup (lambda (w h)
+	       (let ([w (floor w)]
+		     [h (floor h)])
+		 (debug-print 2d-vector% 'width width 'height height w h
+			      'index (index w h))
+		 (if (and (<= 0 w) (< w width) (<= 0 h) (< h height))
+		     (vector-ref vec (index w h))
+		     (if default?
+			 default
+			 (found-error 'lookup w h)))))])
+    (lambda (w h v)
+      (if (and (integer? w) (integer? h))
+	  (begin 
+	    (set! width w)
+	    (set! height h)
+	    (set! vec (make-vector (* w h) v)))
+	  (error '2d-vector%
+		 "received w = ~s and h = ~s; both must should be integral" 
+		 w h)))))
\ No newline at end of file
diff --git a/collects/mrdemo/morph/coord.ss b/collects/mrdemo/morph/coord.ss
new file mode 100644
index 0000000..1b33a3b
--- /dev/null
+++ b/collects/mrdemo/morph/coord.ss
@@ -0,0 +1,96 @@
+;;; this file sets up coordinates 
+
+;; bary represents just a three tuple of coordinates, not necessarily
+;; with respect to some triangle.
+(define-struct bary (a b c))
+(define show-bary
+  (let ([shorten (lambda (x) (/ (floor (* x 100)) 100))])
+    (lambda (p)
+      (printf "#<str:bary ~s ~s ~s>"
+	      (shorten (bary-a p))
+	      (shorten (bary-b p))
+	      (shorten (bary-c p))))))
+
+(define-struct posn (x y))
+(define show-posn 
+  (let ([shorten (lambda (x) (/ (floor (* x 10)) 10))])
+    (lambda (p)
+      (printf "#<str:posn ~s ~s>"
+	      (shorten (posn-x p))
+	      (shorten (posn-y p))))))
+
+(define-struct tri (a b c area))
+(define build-tri
+  (lambda (a b c)
+    (make-tri a b c (find-area a b c))))
+
+(define posn-minus
+  (lambda (p q)
+    (make-posn (- (posn-x p) (posn-x q))
+	       (- (posn-y p) (posn-y q)))))
+
+(define bary-minus
+  (lambda (p1 p2)
+    (make-bary (- (bary-a p1) (bary-a p2))
+	       (- (bary-b p1) (bary-b p2))
+	       (- (bary-c p1) (bary-c p2)))))
+
+(define square (lambda (x) (* x x)))
+
+(define norm
+  (lambda (b)
+    (+ (square (bary-a b))
+       (square (bary-b b))
+       (square (bary-c a)))))
+
+(define find-area
+  (let ([helper
+	 (lambda (p q)
+	   (let ([sroot (- (* (posn-y p) (posn-x q))
+			   (* (posn-x p) (posn-y q)))])
+	     (/ (abs sroot) 2)))])
+    (lambda (p1 p2 p3)
+      (helper (posn-minus p1 p2) (posn-minus p1 p3)))))
+
+(define find-barycentric
+  (lambda (p1 p2 p3 p)
+    (find-barycentric-area (build-tri p1 p2 p3) p)))
+
+(define find-barycentric-area
+  (lambda (tri p)
+    (let* ([p1 (tri-a tri)]
+	   [p2 (tri-b tri)]
+	   [p3 (tri-c tri)]
+	   [area (tri-area tri)]
+	   [little-area/big-area
+	    (lambda (p q)
+	      (let ([sroot (- (* (posn-y p) (posn-x q))
+			      (* (posn-x p) (posn-y q)))])
+		(/ sroot area 2)))]
+	   [p1-p (posn-minus p1 p)]
+	   [p2-p (posn-minus p2 p)]
+	   [p3-p (posn-minus p3 p)])
+      (make-bary (little-area/big-area p2-p p3-p)
+		 (little-area/big-area p3-p p1-p)
+		 (little-area/big-area p1-p p2-p)))))
+
+(define find-euclid
+  (lambda (tri b)
+    (let ([p1 (tri-a tri)]
+	  [p2 (tri-b tri)]
+	  [p3 (tri-c tri)]
+	  [a (bary-a b)]
+	  [b (bary-b b)]
+	  [c (bary-c b)])
+      (make-posn (+ (* a (posn-x p1))
+		    (* b (posn-x p2))
+		    (* c (posn-x p3)))
+		 (+ (* a (posn-y p1))
+		    (* b (posn-y p2))
+		    (* c (posn-y p3)))))))
+
+(define distance-sq
+  (lambda (p q)
+    (let ([x-delta (- (posn-x p) (posn-x q))]
+	  [y-delta (- (posn-y p) (posn-y q))])
+      (+ (* x-delta x-delta) (* y-delta y-delta)))))
diff --git a/collects/mrdemo/morph/debug.ss b/collects/mrdemo/morph/debug.ss
new file mode 100644
index 0000000..a092cfd
--- /dev/null
+++ b/collects/mrdemo/morph/debug.ss
@@ -0,0 +1,57 @@
+(define debug-on? (lambda (type) #f))
+
+(define debug-on? (lambda (type) #t))
+
+(define debug-on?
+  (lambda (type)
+    (case type
+      [(2d-vector%) #f]
+      [(engine) #t]
+      [(graph) #f]
+      [(main) #t]
+      [(mesh%) #t]
+      [(pager%) #t]
+      [else #t])))
+
+(defmacro debug-print (type . args)
+  (if (debug-on? type)
+      `(begin
+	 (display (quote ,type))
+	 (display ": ")
+	 (debug-print-function ,@args))
+      '(void)))
+
+(define debug-print-function
+  (letrec ([debug-print-one
+	    (lambda (x)
+		(cond
+		 [(list? x) (debug-print-list x)]
+		 [(pair? x) (display "(")
+			    (debug-print-one (car x))
+			    (display " . ")
+			    (debug-print-one (cdr x))
+			    (display ")")]
+		 [(posn? x) (show-posn x)]
+		 [(bary? x) (show-bary x)]
+;		 [(3vector? x) (show-3vector x)]
+;		 [(intersection? x) (show-intersection x)]
+		 [else (display x)]))]
+	   [debug-print-list-innards
+	    (lambda (list)
+	      (cond
+	       [(null? list) (void)]
+	       [(null? (cdr list)) (debug-print-one (car list))]
+	       [else (debug-print-one (car list))
+		     (display " ")
+		     (debug-print-list-innards (cdr list))]))]
+	   [debug-print-list
+	    (lambda (x)
+	      (display "(")
+	      (debug-print-list-innards x)
+	      (display ")"))])
+    (lambda args
+      (debug-print-list-innards args)
+      (newline)
+      (flush-output)
+      (void))))
+
diff --git a/collects/mrdemo/morph/engine.ss b/collects/mrdemo/morph/engine.ss
new file mode 100644
index 0000000..8cc5a7b
--- /dev/null
+++ b/collects/mrdemo/morph/engine.ss
@@ -0,0 +1,154 @@
+
+;; a mesh is a graph of the connectivities of the points. 
+(define-struct mesh (index children))
+
+;; an image is a 2d array of color values, all of which are between
+;; one and zero.
+
+
+;; input:
+;; src-verticies: the positions in the mesh where the
+;;                verticies are in the src image.
+;; src-img: the source image
+;; dest-verticies: the positions in the mesh where the
+;;                 verticies are in the dest image.
+;; src-img: the destination image
+;; w: a constant between zero and one indicating how far the morph between
+;;    the images. 
+;; 
+;; It returns a function which computes the color value for the pixel
+;; x and y, which should be a number between one and zero.
+
+
+
+(define engine-simple
+  (lambda (mesh src-lookup dest-lookup w)
+    (lambda (x y)
+      (let ([scale-pt (+ (* w (src-lookup x y))
+			 (* (- 1 w) (dest-lookup x y)))]
+	    [x (- (/ (random 101) 400) 1/8)])
+	(max 0 (min 1 (+ scale-pt x)))))))
+
+(define ormap-count 'uhoh)
+
+(define ormap-debug
+  (lambda (f list)
+    (letrec ([helper
+	      (lambda (i l)
+		(cond
+		 [(null? l) (set! ormap-count 'not-there)
+			    #f]
+		 [else (let ([w (f (car l))])
+			 (if w
+			     (begin
+			       (set! ormap-count (cons i w))
+			       w)
+			     (helper (1+ i) (cdr l))))]))])
+      (helper 1 list))))
+
+(define engine
+  (lambda (mesh src-lookup dest-lookup w)
+    (let* ([tmp-triangles (build-triangles w mesh)]
+	   [triangles (cons (car tmp-triangles) tmp-triangles)]
+	   [1-w (- 1 w)])
+      (lambda (x y)
+	(let* ([bc-tri (ormap (point-in-triangle? (make-posn x y)) triangles)])
+	  (if bc-tri
+	      (let* ([bc (car bc-tri)]
+		     [triangle-triple (cdr bc-tri)]
+		     [to-p (find-euclid (triangles-to triangle-triple) bc)]
+		     [to-x (posn-x to-p)]
+		     [to-y (posn-y to-p)]
+		     [from-p (find-euclid (triangles-from triangle-triple) bc)]
+		     [from-x (posn-x from-p)]
+		     [from-y (posn-y from-p)])
+		(set-car! triangles triangle-triple)
+		(values (+ (* w from-x) (* 1-w to-x))
+			(+ (* w from-y) (* 1-w to-y))
+			(+ (* w (src-lookup from-x from-y))
+			   (* 1-w (dest-lookup to-x to-y)))))
+	      (values x
+		      y
+		      (begin '(/ (+ (src-lookup x y) (dest-lookup x y)) 2)
+			     1))))))))
+
+'(define engine engine-simple)
+
+(define get-points
+  (lambda (node)
+    (let ([value (graph:value node)])
+      (values (car value) (cdr value)))))
+
+;; this returns either #f or a pair, the triangle and the barycentric
+;; coordinates of (x,y) with respect to that triangle.
+(define point-in-triangle?
+  (lambda (posn)
+    (lambda (triangle-triple)
+      (let* ([intermediate-triangle (triangles-intermediate triangle-triple)]
+	     [bary (find-barycentric-area intermediate-triangle posn)])
+	(if (and (<= 0 (bary-a bary))
+		 (<= 0 (bary-b bary))
+		 (<= 0 (bary-c bary)))
+	    (cons bary triangle-triple)
+	    #f)))))
+
+;; This maps over a list pairwise, e.g.
+;; (for-each-pairwise (list 1 2 3) f)
+;; =
+;; (begin (f 1 2) (f 2 3) (f 3 1))
+
+(define for-each-pairwise
+  (lambda (l f)
+    (cond
+     [(<= (length l) 1) (void)]
+     [(= 2 (length l)) (f (first l) (second l))]
+     [else (letrec ([first-ele (car l)]
+		    [helper 
+		     (lambda (l)
+		       (cond 
+			[(null? (cdr l)) (begin '(f (first l) first-ele)
+						(void))]
+			[else (f (first l) (second l))
+			      (helper (cdr l))]))])
+	     (helper l))])))
+
+(define-struct triangles (from intermediate to))
+
+(define build-triangles
+  (lambda (w mesh)
+    (let* ([triangles null]
+	   [1-w (- 1 w)]
+	   [combine
+	    (lambda (p q)
+	      (make-posn (+ (* w (posn-x p)) (* 1-w (posn-x q)))
+			 (+ (* w (posn-y p)) (* 1-w (posn-y q)))))])
+      (graph:traverse
+       mesh
+       (lambda (node)
+	 (let-values ([(left right) (get-points node)])
+	   (let ([children (graph:children node)])
+	     (when (= (length children) 3)
+	       (let ([one (first children)]
+		     [two (second children)]
+		     [three (third children)])
+		 (let-values ([(left-one right-one) (get-points one)]
+			      [(left-two right-two) (get-points two)]
+			      [(left-three right-three) (get-points three)])
+		   (let* ([int (combine left right)]
+			  [int-one (combine left-one right-one)]
+			  [int-two (combine left-two right-two)]
+			  [int-three (combine left-three right-three)]
+			  [left-tri1 (build-tri left left-one left-two)]
+			  [int-tri1 (build-tri int int-one int-two)]
+			  [right-tri1 (build-tri right right-one right-two)]
+			  [left-tri2 (build-tri left left-three left-one)]
+			  [int-tri2 (build-tri int int-three int-one)]
+			  [right-tri2 (build-tri right right-three right-one)])
+		     (set! triangles
+			   (list*
+			    (make-triangles left-tri1 int-tri1 right-tri1)
+			    (make-triangles left-tri2 int-tri2 right-tri2)
+			    triangles))))))))))
+      (if (null? triangles)
+	  (error 'build-triangles "empty mesh")
+	  triangles))))
diff --git a/collects/mrdemo/morph/load.ss b/collects/mrdemo/morph/load.ss
new file mode 100644
index 0000000..368ffe1
--- /dev/null
+++ b/collects/mrdemo/morph/load.ss
@@ -0,0 +1,15 @@
+(for-each (lambda (x)
+	    (printf "loading ~s...~n" x)
+	    (flush-output)
+	    (load-relative x))
+	  '("setup.ss"
+	    "debug.ss"
+	    "2darray.ss"
+	    "coord.ss"
+	    "mesh.ss"
+	    "utils.ss"
+	    "ui.ss"
+	    "pager.ss"
+	    "engine.ss"
+	    "main.ss"))
+(printf "done loading~n")
diff --git a/collects/mrdemo/morph/main.ss b/collects/mrdemo/morph/main.ss
new file mode 100644
index 0000000..a6a9688
--- /dev/null
+++ b/collects/mrdemo/morph/main.ss
@@ -0,0 +1,76 @@
+(define main
+  (lambda (mesh src-mem-dc dest-mem-dc src-2dvec dest-2dvec total)
+    (letrec* ([width (max (ivar src-2dvec width) (ivar dest-2dvec width))]
+	      [dummy-name-width width]
+	      [height (max (ivar src-2dvec height) (ivar dest-2dvec height))]
+
+	      [src-lookup (ivar src-2dvec lookup)]
+	      [dest-lookup (ivar dest-2dvec lookup)]
+
+	      [build-w
+	       (lambda (w)
+		 (debug-print main "building image percent" w)
+		 (let* ([new-point (engine mesh
+					   src-lookup
+					   dest-lookup
+					   w)]
+			[memory-dc (make-object wx:memory-dc%)]
+			[set-pixel (ivar memory-dc set-pixel)]
+			[bitmap (make-object wx:bitmap% width height)]
+			[scale (1- num-colors)])
+		   (send memory-dc select-object bitmap)
+		   (send memory-dc begin-set-pixel)
+		   (let loop ([x width] [y height])
+		     (let-values ([(draw-x draw-y color) (new-point x y)])
+		       (set-pixel draw-x draw-y 
+				  (vector-ref colors
+					      (floor (* color
+							scale))))
+		       (cond
+			[(and (zero? y) (zero? x)) (void)]
+			[(zero? x) (begin (when (= 0 (modulo y 15))
+					    (debug-print main 'y y))
+					  (loop width (1- y)))]
+			[else (loop (1- x) y)])))
+		   (send memory-dc end-set-pixel)
+		   memory-dc))]
+
+	      [memory-dcs1
+	       '(list->vector
+		(reverse
+		 (cons dest-mem-dc
+		       (let loop ([i 1])
+			 (if (= i (- total 1)) (list src-mem-dc)
+			     (cons (build-w (/ i (1- total)))
+				   (loop (1+ i))))))))]
+
+	      [memory-dcs2
+	       '(list->vector
+		 (let loop ([i total])
+		   (if (zero? i)
+		       (list (build-w (/ i (1- total))))
+		       (cons (build-w (/ i (1- total)))
+			     (loop (1- i))))))]
+
+	      [sub-pager%
+	       (make-class pager%
+		 (public
+		  [width dummy-name-width]
+		  [picture-height height]
+		  [memory-dcs
+		   (list->vector
+		    (reverse
+		     (cons dest-mem-dc
+			   (let loop ([i 1])
+			     (if (= i (- total 1)) (list src-mem-dc)
+				 (cons (build-w (/ i (1- total)))
+				       (loop (1+ i))))))))])
+		 (lambda ()
+		   (super-init)))])
+      '(debug-print main memory-dcs)
+      (send src-2dvec set-default 1)
+      (send dest-2dvec set-default 1)
+      (mred:show-busy-cursor
+       (lambda ()
+	 (make-object sub-pager%))))))
+
diff --git a/collects/mrdemo/morph/mesh.ss b/collects/mrdemo/morph/mesh.ss
new file mode 100644
index 0000000..4285ef6
--- /dev/null
+++ b/collects/mrdemo/morph/mesh.ss
@@ -0,0 +1,138 @@
+;; graph:node takes a value to be stored on a node and creates a new node.
+;; graph:edge takes two edges and joins them
+;; graph:value takes a node and returns it's value
+
+(define-values (graph:node
+		graph:edge
+		graph:value
+		graph:children
+		graph:parents
+		graph:connections
+		graph:traverse
+		graph:fprintf
+		graph:read
+		graph:id
+		find-closest)
+  (local
+    [(define counter 0)
+     
+     (define-struct node (value children parents visited? id))
+     
+     (define graph:id node-id)
+     
+     (define graph:node
+       (lambda (value)
+	 (make-node value null null #f
+		    (begin0 counter
+			    (set! counter (add1 counter))))))
+     ; from n1 to n2. n1 is n2's parent
+     (define graph:edge
+       (lambda (n1 n2)
+	 (set-node-children! n1 (cons n2 (node-children n1)))
+	 (set-node-parents! n2 (cons n1 (node-parents n2)))))
+     (define graph:value node-value)
+     (define graph:children node-children)
+     (define graph:parents node-parents)
+     (define graph:connections (lambda (x)
+				 (append (graph:parents x)
+					 (graph:children x))))
+     (define graph:traverse
+       (lambda (node f)
+	 (unless (node? node)
+	   (error 'graph:traverse "expected a node, found ~s" node))
+	 (letrec ([to-reset null]
+		  [helper
+		   (lambda (node)
+		     (when (not (node-visited? node))
+		       (f node)
+		       (set! to-reset (cons node to-reset))
+		       (set-node-visited?! node #t)
+		       (for-each helper (node-children node))))])
+	   (helper node)
+	   (for-each (lambda (node)
+		       (set-node-visited?! node #f))
+		     to-reset))))
+     
+     (define graph:fprintf
+       (lambda (port node fprintf-node-value)
+	 (unless (node? node)
+	   (error 'graph:fprintf "expected a node, found ~s" node))
+	 (let ([min (node-id node)] [max (node-id node)])
+	   (graph:traverse
+	    node (lambda (x)
+		   (when (< max (node-id x))
+		     (set! max (node-id x)))
+		   (when (< (node-id x) min)
+		     (set! min (node-id x)))))
+	   (fprintf port "~s ; min~n~s ; max~n; nodes~n" min max))
+	 (graph:traverse
+	  node
+	  (lambda (node)
+	    (fprintf port "~s	~s	~s	" (node-id node)
+		     (map node-id (node-children node))
+		     (map node-id (node-parents node)))
+	    (fprintf-node-value port (node-value node))
+	    (fprintf port "~n")))
+	 (fprintf port "~s~n" 'double-check)
+	 (fprintf port "~s~n" (node-id node))))
+     
+     (define graph:read
+       (opt-lambda (read-value [port (current-input-port)])
+	 (let* ([min (read port)]
+		[max (read port)]
+		[v (tabulate (add1 (- max min)) (lambda (x)
+						(graph:node x)))])
+	   (let loop ([i (- max min)])
+	     (when (<= 0 i)
+	       (let* ([index (- (read port) min)]
+		      [node (vector-ref v index)]
+		      [chili (lambda (i) (vector-ref v (- i min)))]
+		      [children (read port)]
+		      [parents (read port)])
+		 (set-node-children! node (map chili children))
+		 (set-node-parents! node (map chili parents))
+		 (set-node-value! node (read-value port))
+		 (debug-print graph (+ index min) 'children children
+			      'parents parents
+			      'node node))
+	       (loop (sub1 i))))
+	   (when (not (eq? 'double-check (read port)))
+	     (error 'graph:read "input corrupted"))
+	   (let ([node-count (read port)])
+	     (debug-print graph 'important-node node-count
+			  'min min
+			  (vector-ref v (- node-count min)))
+	     (vector-ref v (- node-count min))))))
+     
+     (define find-closest
+       (lambda (node x y node-value-get)
+	 (let* ([mouse-posn (make-posn x y)]
+		[closest node]
+		[value (graph:value node)]
+		[posn (node-value-get value)]
+		[current-dist-sq (distance-sq mouse-posn posn)])
+	   (graph:traverse node
+			   (lambda (node)
+			     (let* ([value (graph:value node)]
+				    [this-posn (node-value-get value)]
+				    [this-dist-sq
+				     (distance-sq mouse-posn this-posn)])
+			       (when (< this-dist-sq current-dist-sq)
+				 (set! posn this-posn)
+				 (set! current-dist-sq this-dist-sq)
+				 (set! closest node)))))
+	   closest)))]
+         
+
+
+     (values graph:node
+	     graph:edge
+	     graph:value
+	     graph:children
+	     graph:parents
+	     graph:connections
+	     graph:traverse
+	     graph:fprintf
+	     graph:read
+	     graph:id
+	     find-closest)))
\ No newline at end of file
diff --git a/collects/mrdemo/morph/pager.ss b/collects/mrdemo/morph/pager.ss
new file mode 100644
index 0000000..3251990
--- /dev/null
+++ b/collects/mrdemo/morph/pager.ss
@@ -0,0 +1,120 @@
+(define pager%
+  (make-class ()
+    (public
+     [x-pos 650]
+     [y-pos 60]
+     [width 300]
+     [picture-height 300]
+     [slider-height 50]
+     [button-width 30]
+     [slider-width (- width button-width)]
+     [memory-dcs (vector)]
+     [save-images
+      (lambda (fn)
+	(let loop ([i (1- (vector-length memory-dcs))])
+	  (when (<= 0 i)
+	    (let* ([this-name (string-append
+			       fn (number->string (1+ i)) ".pgm")]
+		   [port (open-output-file this-name 'replace)]
+		   [memory-dc (vector-ref memory-dcs i)]
+		   [get-pixel (ivar memory-dc get-pixel)]
+		   [color (make-object wx:colour% "white")]
+		   [get-colors (ivar color get)]
+		   [bgreen (box 0)]
+		   [bred (box 0)]
+		   [bblue (box 0)])
+	      (debug-print pager% 'writing 'image this-name)
+	      (fprintf port
+		       "P2~n# Robby's Morpher via MrEd~n~s ~s~n255~n"
+		       width picture-height)
+	      (let loop ([x 0] [y 0])
+		(if (get-pixel x y color)
+		    (get-colors bred bgreen bblue)
+		    (set-box! bgreen 255))
+		(fprintf port "~s" (unbox bgreen))
+		(fprintf port (if (= x width) "~n" " "))
+		(cond [(and (= x (1- width)) (= y (1- picture-height))) (void)]
+		      [(= x (1- width)) (loop 0 (1+ y))]
+		      [else (loop (1+ x) y)]))
+	      (debug-print pager% 'wrote this-name)
+	      (close-output-port port))
+	    (loop (1- i)))))]
+     [frame%
+      (make-class mred:menu-frame%
+	(rename [super-make-menu-bar make-menu-bar])
+	(inherit make-menu show)
+	(public
+	 [make-menu-bar
+	  (lambda ()
+	    (let ([bar (super-make-menu-bar)]
+		  [file-menu (make-menu)])
+	      (send file-menu append-item "Save"
+		    (lambda ()
+		      (let ([fn (mred:common-put-file '()
+				 "Please Specify a prefix for the images.")])
+			(debug-print pager% 'fn fn)
+			(when fn
+			  (debug-print pager% 'fn fn)
+			  (save-images fn)))))
+	      (send file-menu append-item "Close" (lambda () (show #f)))
+	      (send bar append file-menu "File")
+	      bar))]))]
+     [frame (make-object frame% '() "Morph")]
+     [panel (ivar frame panel)]
+     [canvas%
+      (make-class mred:canvas%
+	(inherit clear set-background)
+        (public
+	 [w-brush (make-object wx:brush% "white" wx:const-solid)]
+	 [on-paint
+	  (lambda ()
+	    '(send dc destroy-clipping-region)
+	    '(send dc set-clipping-region 0 0 (1+ width) (1+ picture-height))
+	    (set-background w-brush)
+	    (clear)
+	    (when slider
+	      (send dc blit 0 0 width picture-height
+		    (vector-ref memory-dcs (send slider get-value))
+		    0 0 wx:const-copy)))]))]
+     [canvas (make-object canvas% panel)]
+     [s-panel (make-object mred:horizontal-panel% panel)]
+     [slider
+      (let ([show-arg
+	     (lambda (s e)
+	       (send canvas on-paint))])
+	(if (> (vector-length memory-dcs) 1)
+	    (make-object mred:slider% s-panel show-arg ""
+			 0 0 (sub1 (vector-length memory-dcs)) slider-width)
+	    #f))]
+     [button-click
+      (lambda args
+	(mred:show-busy-cursor
+	 (lambda ()
+	   (let ([old-slider-pos (send slider get-value)])
+	     (let loop ([img 0])
+	       (when (< img (vector-length memory-dcs))
+		 (send slider set-value img)
+		 (send canvas on-paint)
+		 (wx:flush-display)
+		 (sleep 0.5)
+		 (loop (1+ img))))
+	     '(send slider set-value old-slider-pos)
+	     (send canvas on-paint)))))]
+     [button
+      (when (> (vector-length memory-dcs) 1)
+	    (make-object mred:button% s-panel button-click "Play"))]
+     [dc (send canvas get-dc)]
+     [shutdown (lambda () (send frame show #f))])
+    (lambda ()
+      (send panel stretchable-in-y #f)
+      (let ([w (box 0)]
+	    [h (box 0)])
+	(send canvas get-client-size w h)
+	(let ([diff (- (send canvas get-width) (unbox w))])
+	  (send canvas user-min-width (+ diff width))
+	  (send canvas user-min-height (+ diff picture-height))))
+      (send canvas stretchable-in-x #f)
+      (send canvas stretchable-in-y #f)
+      (send frame show #t)
+      (send canvas on-paint))))
+
diff --git a/collects/mrdemo/morph/setup.ss b/collects/mrdemo/morph/setup.ss
new file mode 100644
index 0000000..cf6ad68
--- /dev/null
+++ b/collects/mrdemo/morph/setup.ss
@@ -0,0 +1,46 @@
+(print-struct #t)
+(print-graph #t)
+(define last
+  (lambda (x)
+    (cond
+     [(null? x) (error 'last "empty list")]
+     [(null? (cdr x)) (car x)]
+     [else (last (cdr x))])))
+
+(define foldl2
+  (lambda (f init l)
+    (letrec ([helper
+	      (lambda (l sofar)
+		(cond
+		 [(null? l) sofar]
+		 [else (helper (cdr l) (f (car l) sofar))]))])
+      (helper l init))))
+
+(define tabulate
+  (lambda (n f)
+    (letrec ([build (lambda (i)
+		      (cond
+		       [(= i n) null]
+		       [else (cons (f i) (build (1+ i)))]))])
+      (list->vector (build 0)))))
+
+(define vector-for-each
+  (lambda (f v)
+    (let ([size (vector-length v)])
+      (let loop ([n 0])
+	(when (< n size)
+	  (f i (vector-ref v i))
+	  (loop))))))
+
+'(define remove
+  (lambda (list f)
+    (letrec ([helper
+	      (lambda (l)
+		(cond [(null? l) null]
+		      [(f (car l)) (helper (cdr l))]
+		      [else (cons (car l) (helper (cdr l)))]))])
+      (helper list))))
+
+(define-macro package
+  (lambda (x . args)
+    (car 'package)))
diff --git a/collects/mrdemo/morph/ui.ss b/collects/mrdemo/morph/ui.ss
new file mode 100644
index 0000000..729a5ef
--- /dev/null
+++ b/collects/mrdemo/morph/ui.ss
@@ -0,0 +1,407 @@
+(define num-colors 200)
+(define mesh-color (make-object wx:colour% 50 155 50))
+(define mesh-pen (make-object wx:pen% mesh-color 1 wx:const-solid))
+
+(define black-pen (make-object wx:pen% "BLACK" 1 wx:const-solid))
+
+(define colors
+  (tabulate num-colors
+	    (lambda (i)
+	      (make-object wx:colour%
+			   (* 255 (expt (/ i (1- num-colors)) 1/2))
+			   (* 255 (/ i (1- num-colors)))
+			   (* 255 (expt (/ i (1- num-colors)) 1/2))))))
+
+(define mesh%
+  (make-class mred:menu-frame%
+    (rename [super-make-menu-bar make-menu-bar]
+;	    [super-on-paint on-paint]
+	    )
+    (inherit make-menu show panel)
+    (public
+     [mesh #f]
+     
+     [filename #f]
+     [margin 10]
+
+     [on-paint
+      (lambda ()
+	(send left-canvas on-paint)
+	(send right-canvas on-paint))]
+
+     [canvas%
+      (make-class mred:canvas%
+	(inherit set-background get-dc clear get-client-size)
+	(rename [super-on-event on-event])
+	(private
+	 [w-brush (make-object wx:brush% "white" wx:const-solid)])
+        (public
+	 [node-value-get (void)]
+	 [node-value-update (void)]
+	 [memory-dc (make-object wx:memory-dc%)]
+	 [set-memory-dc! (lambda (mdc) (set! memory-dc mdc))]
+	 [draw-line (void)]
+	 [dc (void)]
+	 [on-event
+	  (let* ([dragging-node (void)]
+		 [connections null]
+		 [orig-x (void)]
+		 [orig-y (void)]
+		 [last-x -1]
+		 [last-y -1]
+		 [lines (lambda ()
+			  (for-each
+			   (lambda (x)
+			     (let ([p (node-value-get (graph:value x))])
+			       (draw-line (posn-x p) (posn-y p)
+					  last-x last-y)))
+			   connections))])
+	    (lambda (event)
+	      (cond
+	       [(send event dragging?)
+		(let ([x (send event get-x)]
+		      [y (send event get-y)])
+		  (when (and (not (and (= x last-x)
+				       (= x last-y)))
+			     '(inside-triangles dragging-node x y))
+		    (lines)
+		    (set! last-x x)
+		    (set! last-y y)
+		    (lines)))]
+		[(send event button-down?)
+		 (let ([x (send event get-x)]
+		       [y (send event get-y)])
+		   (send dc set-logical-function wx:const-xor)
+		   (when mesh
+			 (set! dragging-node (find-closest mesh x y node-value-get))
+			 (set! connections (graph:connections dragging-node)))
+		   (set! last-x x)
+		   (set! last-y y)
+		   (set! orig-x x)
+		   (set! orig-y y)
+		   (lines))]
+		[(send event button-up?)
+		 (lines)
+		 (send dc set-logical-function wx:const-copy)
+		 (unless (void? dragging-node)
+			 (node-value-update (graph:value dragging-node)
+					    (make-posn last-x last-y)))
+		 (let* ([posns (cons (make-posn last-x last-y)
+				     (map (lambda (x)
+					    (node-value-get (graph:value x)))
+					  connections))]
+			[box-width (box 0)]
+			[box-height (box 0)]
+			[min-x orig-x]
+			[min-y orig-y]
+			[max-x orig-x]
+			[max-y orig-y])
+		   (for-each (lambda (p)
+			       (let ([x (posn-x p)]
+				     [y (posn-y p)])
+				 (when (< max-x x) (set! max-x x))
+				 (when (< max-y y) (set! max-y y))
+				 (when (< x min-x) (set! min-x x))
+				 (when (< y min-y) (set! min-y y))))
+			     posns)
+		   '(send dc set-clipping-region min-x min-y
+			 (1+ (- max-x min-x))
+			 (1+ (- max-y min-y)))
+		   (on-paint)
+		   (get-client-size box-width box-height)
+		   (send dc set-clipping-region
+			 0 0 (unbox box-width) (unbox box-height)))
+		 (set! dragging-node (void))
+		 (set! connections (void))
+		 (set! orig-x (void))
+		 (set! orig-y (void))
+		 (set! last-x (void))
+		 (set! last-y (void))]
+		[else (super-on-event event)])))]
+	 [on-paint
+	  (lambda ()
+	    (let* ([get-points
+		    (lambda (node)
+		      (let* ([value (graph:value node)]
+			     [p (node-value-get value)])
+			(values (posn-x p)(posn-y p))))]
+		   [traverse
+		    (lambda (node)
+		      (let-values ([(b-x b-y) (get-points node)])
+			(let* ([children (graph:children node)]
+			       [chili
+				(lambda (child)
+				  (let-values ([(e-x e-y) (get-points child)])
+				    (draw-line b-x b-y e-x e-y)))])
+			  (for-each chili children))))]
+		   [dc (get-dc)]
+		   [by (box 0)]
+		   [bx (box 0)])
+	      (get-client-size bx by)
+	      (set-background w-brush)
+	      (clear)
+	      (send dc set-pen black-pen)
+	      (send dc blit 0 0 (unbox bx) (unbox by)
+		    memory-dc 0 0 wx:const-copy)
+	      (when mesh
+		(send dc set-pen mesh-pen)
+		'(send dc set-logical-function wx:const-xor)
+		(graph:traverse mesh traverse)
+		'(send dc set-logical-function wx:const-copy))))])
+	(lambda (get update . args)
+	  (apply super-init args)
+	  (set! dc (get-dc))
+	  (set! draw-line (ivar dc draw-line))
+	  (set! node-value-get get)
+	  (set! node-value-update update)))]
+
+     [left-filename #f]
+     [right-filename #f]
+     [left-2dvec #f]
+     [right-2dvec #f]
+     [left-canvas #f]
+     [right-canvas #f]
+     [default-size 200]
+
+     [canvas-size-diff 0]
+
+     [get-sizes
+      (lambda ()
+	(let* ([left-width (if left-2dvec
+			       (ivar left-2dvec width)
+			       default-size)]
+	       [left-height (if left-2dvec
+				(ivar left-2dvec height)
+				default-size)]
+	       [right-width (if right-2dvec
+				(ivar right-2dvec width)
+				default-size)]
+	       [right-height (if right-2dvec
+				 (ivar right-2dvec height)
+				 default-size)])
+	  (values left-width left-height right-width right-height)))]
+     [resize-panels
+      (lambda ()
+	(let-values ([(left-width left-height right-width right-height)
+		      (get-sizes)])
+	  (send left-canvas user-min-width (+ canvas-size-diff left-width))
+	  (send left-canvas user-min-height (+ canvas-size-diff left-height))
+	  (send right-canvas user-min-width (+ canvas-size-diff right-width))
+	  (send right-canvas user-min-height (+ canvas-size-diff right-height))))]
+     [open
+      (lambda (fn)
+	(mred:show-busy-cursor
+	 (lambda ()
+	   (let* ([port (open-input-file fn)]
+		  [local-mesh #f]
+		  [read-value
+		   (lambda (port)
+		     (let ([left (read port)]
+			   [right (read port)])
+		       (cons (apply make-posn left)
+			     (apply make-posn right))))])
+	     (set! left-filename (read port))
+	     (set! right-filename (read port))
+	     (when (read port)
+		 (set! local-mesh (graph:read read-value port)))
+	     (close-input-port port)
+	     (debug-print mesh% 'read 'file)
+	     (set! left-2dvec (build-image left-filename))
+	     (set! right-2dvec (build-image right-filename))
+	     (debug-print mesh% 'built-2dvecs)
+	     (send left-canvas set-memory-dc! (build-memory-dc left-2dvec))
+	     (send right-canvas set-memory-dc! (build-memory-dc right-2dvec))
+	     (debug-print mesh% 'updated 'canvases)
+	     (set! mesh local-mesh)
+	     (set! filename fn)
+	     (resize-panels)
+	     (on-paint)))))]
+     [save
+      (lambda ()
+	(if filename
+	    (begin
+	      (let ([port (open-output-file filename 'replace)]
+		    [print-value
+		     (lambda (port v)
+		       (let ([left (car v)]
+			     [right (cdr v)])
+			 (fprintf port "~s ~s"
+				  (list (posn-x left) (posn-y left))
+				  (list (posn-x right) (posn-y right)))))])
+		(fprintf port ";;; data req'd to setup a morph~n~n")
+		(fprintf port "~s ; source filename~n" left-filename)
+		(fprintf port "~s ; destination filename~n" right-filename)
+		(fprintf port "~n;; mesh~n")
+		(if mesh
+		    (begin
+		      (fprintf port "#t ; mesh is setup~n")
+		      (graph:fprintf port mesh print-value))
+		    (fprintf port "#f ; mesh is not setup~n"))
+		(close-output-port port)))
+	    (save-as)))]
+     [save-as
+      (lambda ()
+	(let ([fn (mred:common-put-file)])
+	  (when fn
+	    (set! filename fn)
+	    (save))))]
+
+     [make-menu-bar
+      (lambda ()
+	(let ([bar (super-make-menu-bar)]
+	      [file-menu (make-menu)]
+	      [picture-menu (make-menu)]
+	      [mesh-menu (make-menu)]
+	      [morph-menu (make-menu)])
+	  (send file-menu append-item "Open..."
+		(lambda ()
+		  (let ([fn (mred:common-get-file)])
+		    (when fn (open fn)))))
+	  (send file-menu append-item "Save..." save)
+	  (send file-menu append-item "Save As..." save-as)
+	  (send file-menu append-separator)
+	  (send file-menu append-item "Close" (lambda () (show #f)))
+	  (send picture-menu append-item "Select Source Image..."
+		(lambda () 
+		  (let ([fn (mred:common-get-file
+			     '() "Please choose an image.")])
+		    (when fn
+		      (mred:show-busy-cursor
+		       (lambda ()
+			 (set! left-filename fn)
+			 (time (set! left-2dvec (build-image fn)))
+			 (time (send left-canvas set-memory-dc!
+				     (build-memory-dc left-2dvec)))
+			 (set! mesh #f)
+			 (resize-panels)
+			 (on-paint)))))))
+	  (send picture-menu append-item "Select Destination Image..."
+		(lambda ()
+		  (let ([fn (mred:common-get-file
+			     '() "Please choose an image.")])
+		    (when fn
+		      (mred:show-busy-cursor
+		       (lambda ()
+			 (set! right-filename fn)
+			 (set! right-2dvec (build-image fn))
+			 (send right-canvas set-memory-dc!
+			       (build-memory-dc right-2dvec))
+			 (set! mesh #f)
+			 (resize-panels)
+			 (on-paint)))))))
+	  (send picture-menu append-item "Exchange Images"
+		(lambda ()
+		  (let ([left-mdc (ivar left-canvas memory-dc)]
+			[right-mdc (ivar right-canvas memory-dc)]
+			[tmp left-2dvec]
+			[exchange
+			 (lambda (node)
+			   (let* ([value (graph:value node)]
+				  [left (car value)])
+			     (set-car! value (cdr value))
+			     (set-cdr! value left)))])
+		    (set! left-2dvec right-2dvec)
+		    (set! right-2dvec tmp)
+		    (send right-canvas set-memory-dc! left-mdc)
+		    (send left-canvas set-memory-dc! right-mdc)
+		    (graph:traverse mesh exchange)
+		    (resize-panels)
+		    (on-paint))))
+	  (send mesh-menu append-item "Fresh Mesh..."
+		(lambda ()
+		  (fresh-mesh (get-number-from-user
+			       "How large should the mesh be?"
+			       "Mesh Size" "5"))
+		  (on-paint)))
+	  (send morph-menu append-item "Morph..."
+		(lambda () (morph (get-number-from-user
+				   "How many steps in the morph?"
+				   "Morph Size" "3"))))
+	  (send bar append file-menu "File")
+	  (send bar append picture-menu "Images")
+	  (send bar append mesh-menu "Mesh")
+	  (send bar append morph-menu "Morph")
+	  bar))]
+     [morph
+      (lambda (steps)
+	(if (and left-2dvec right-2dvec mesh)
+	    (main mesh (ivar left-canvas memory-dc)
+		  (ivar right-canvas memory-dc)
+		  left-2dvec right-2dvec steps)
+	    (wx:message-box "Please choose images and mesh.")))]
+     [fresh-mesh
+      (lambda (n)
+	(let-values ([(left-width left-height right-width right-height)
+		      (get-sizes)])
+	  (let* ([nodes
+		  (let loop ([row (1- n)] [column (1- n)])
+		    (let ([row-percent (/ row (1- n))]
+			  [column-percent (/ column (1- n))])
+		      (cons 
+		       (graph:node
+			(cons (make-posn (* left-width row-percent)
+					 (* left-height column-percent))
+			      (make-posn (* right-width row-percent)
+					 (* right-height column-percent))))
+		       (cond
+			[(and (= row 0) (= column 0)) null]
+			[(= row 0) (loop (1- n) (1- column))]
+			[else (loop (1- row) column)]))))]
+		 [2dvec (make-object 2d-vector% n n 0)]
+		 [lookup (ivar 2dvec lookup)]
+		 [update (ivar 2dvec update)])
+	    (send 2dvec bend (reverse nodes))
+
+	    (if (< 2 n)
+		(begin
+		  '(graph:edge (lookup 0 (1- n)) (lookup 1 (1- n)))
+		  (let loop ([x (- n 2)] [y (- n 2)])
+		    (graph:edge (lookup x y) (lookup x (1+ y)))
+		    (graph:edge (lookup x y) (lookup (1+ x) y))
+		    (graph:edge (lookup x y) (lookup (1+ x) (1+ y)))
+		    (cond [(and (= x 0) (= y 0)) (void)]
+			  [(= x 0) (loop (- n 2) (1- y))]
+			  [else (loop (1- x) y)]))
+		  (let loop ([i (- n 2)])
+		    (when (<= 0 i)
+		      (graph:edge (lookup (1- n) i) (lookup (1- n) (1+ i)))
+		      (graph:edge (lookup i (1- n)) (lookup (1+ i) (1- n)))
+		      (loop (1- i)))))
+		(begin
+		  (graph:edge (lookup 0 0) (lookup 0 1))
+		  (graph:edge (lookup 0 0) (lookup 1 0))
+		  (graph:edge (lookup 0 0) (lookup 1 1))
+		  (graph:edge (lookup 1 0) (lookup 1 1))
+		  (graph:edge (lookup 0 1) (lookup 1 1))))
+
+	    (set! mesh (lookup 0 0)))))])
+
+    (lambda ()
+      (super-init '() "Mesh Construction")
+      (send panel stretchable-in-x #f)
+      (send panel stretchable-in-y #f)
+      (let ([p (make-object mred:horizontal-panel% panel)]
+	    [init
+	     (lambda (c)
+	       (send c user-min-height default-size)
+	       (send c user-min-width default-size)
+	       (send c stretchable-in-x #f)
+	       (send c stretchable-in-y #f))])
+	(send p stretchable-in-x #f)
+	(send p stretchable-in-y #f)
+	(set! left-canvas (make-object canvas% car set-car! p))
+	(init left-canvas)
+	(set! right-canvas (make-object canvas% cdr set-cdr! p))
+	(init right-canvas))
+      (let ([w (box 0)]
+	    [h (box 0)])
+	(send right-canvas get-client-size w h)
+	(set! canvas-size-diff (- (send right-canvas get-width) (unbox w))))
+      (show #t))))
+
+(define mesh
+  (begin (when (defined? 'mesh)
+	   (send mesh show #f))
+	 (make-object mesh%)))
+'(send mesh open "/home/robby/class/graphics/lab5/test/rd.morph")
+'(send mesh morph 3)
diff --git a/collects/mrdemo/morph/utils.ss b/collects/mrdemo/morph/utils.ss
new file mode 100644
index 0000000..f2ce7c9
--- /dev/null
+++ b/collects/mrdemo/morph/utils.ss
@@ -0,0 +1,114 @@
+(define build-pgm-image
+  (lambda (filename)
+    (let* ([comment #\#]
+	   [coords
+	    (call-with-input-file
+	     filename
+	     (lambda (p)
+	       (let ([tmp null])
+		 (let loop ([line (read-line p)])
+		   (unless (eof-object? line)
+		     (unless (char=? comment (string-ref line 0))
+		       (let ([sp (open-input-string line)])
+			 (let loop ([object (read sp)])
+			   (unless (eof-object? object)
+			     (set! tmp (cons object tmp))
+			     (loop (read sp))))))
+		     (loop (read-line p))))
+		 (reverse tmp))))])
+      (when (< (length coords) 4)
+	(error 'build-image "found less than four numbers in file: ~s"
+	       filename))
+      (let* ([tag (first coords)]
+	     [width (second coords)]
+	     [height (third coords)]
+	     [top-value (exact->inexact (fourth coords))]
+	     [data (list-tail coords 4)]
+	     [2dvec (make-object 2d-vector% width height top-value)]
+	     [normalized-data 
+	      (map (lambda (x) (/ x top-value))
+			      data)])
+	(when (not (= (* width height) (length data)))
+	  (error 'build-image
+		 "data sizes incorrect in file ~s, found ~s expected ~s"
+		 filename (length data) (* width height)))
+	(send 2dvec bend normalized-data)			      
+	2dvec))))
+
+(define build-image
+  (lambda (filename)
+    (let ([error
+	   (lambda ()
+	     (error 'build-image "The file \"~a\" could not be loaded." 
+		    filename)
+	     #f)])
+      (if (regexp-match "\\.gif" filename)
+	  (let ([b (make-object wx:bitmap% filename wx:const-bitmap-type-gif)])
+	    (if (send b ok?)
+		(let ([m (make-object wx:memory-dc%)])
+		  (send m select-object b)
+		  (if (send m ok?)
+		      (let* ([w (send b get-width)]
+			     [h (send b get-height)]
+			     [2dvec (make-object 2d-vector% w h 255)]
+			     [update (ivar 2dvec update)]
+			     [c (make-object wx:colour%)]
+			     [r (ivar c red)]
+			     [g (ivar c green)]
+			     [b (ivar c blue)])
+			(let iloop ([i (sub1 w)])
+			  (let jloop ([j (sub1 h)])
+			    (send m get-pixel i j c)
+			    (let ([r (exact->inexact (r))]
+				  [g (exact->inexact (g))]
+				  [b (exact->inexact (b))])
+			      (update i j (/ (sqrt (/ (+ (* r r) (* g g) (* b b)) 3)) 255)))
+			    (unless (zero? j)
+				    (jloop (sub1 j))))
+			  (unless (zero? i)
+				  (iloop (sub1 i))))
+			2dvec)
+		      (error)))
+		(error)))
+	  (build-pgm-image filename)))))
+
+(define build-memory-dc
+  (lambda (2dvec)
+    (let* ([memory-dc (make-object wx:memory-dc%)]
+	   [set-pixel (ivar memory-dc set-pixel)]
+	   [lookup (ivar 2dvec lookup)]
+	   [width (ivar 2dvec width)]
+	   [height (ivar 2dvec height)]
+	   [bitmap (make-object wx:bitmap% width height)]
+	   [scale (1- num-colors)])
+      (send memory-dc select-object bitmap)
+      (send memory-dc begin-set-pixel)
+      (let loop ([x (1- width)] [y (1- height)])
+	(let* ([l (lookup x y)])
+	  (set-pixel x y (vector-ref colors (floor (* scale l)))))
+	(cond
+	 [(and (zero? y) (zero? x)) (void)]
+	 [(zero? x) (loop (1- width) (1- y))]
+	 [else (loop (1- x) y)]))
+      (send memory-dc end-set-pixel)
+      memory-dc)))
+
+(define get-number-from-user
+  (lambda (message title default)
+    (let* ([input (wx:get-text-from-user message title default)]
+	   [read-in
+	    (read-string
+	     input
+	     (lambda (debug string . rest)
+	       (wx:message-box 
+		(string-append
+		 string
+		 (apply
+		  string-append
+		  (map expr->string rest))))
+	       (apply reg-error debug string rest)))])
+      (if (and (number? read-in)
+	       (positive? read-in)
+	       (integer? read-in))
+	  read-in
+	  (wx:message-box "Expected a positive integer")))))
diff --git a/collects/mrdemo/ncad.mre b/collects/mrdemo/ncad.mre
new file mode 100644
index 0000000..bc95574
Binary files /dev/null and b/collects/mrdemo/ncad.mre differ
diff --git a/collects/mrdemo/ncad02x.ss b/collects/mrdemo/ncad02x.ss
new file mode 100644
index 0000000..823f83a
--- /dev/null
+++ b/collects/mrdemo/ncad02x.ss
@@ -0,0 +1,1395 @@
+;;   ncad02c.scm - Scheme code for NanoCAD version 0.2
+;;   Copyright (C) 1996 Will Ware
+;;   Modified by Matthew Flatt for MrEd 43
+;;   
+;;   This program is free software; you can redistribute it and/or
+;;   modify it under the terms of the GNU General Public License
+;;   as published by the Free Software Foundation; either version 2
+;;   of the License, or (at your option) any later version.
+;;   
+;;   This program is distributed in the hope that it will be useful,
+;;   but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;   GNU General Public License for more details.
+;;   
+;;   You should have received a copy of the GNU General Public License
+;;   along with this program; if not, write to the Free Software
+;;   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+;;
+;;   I can be reached via email at <wware@world.std.com>.
+
+;; ******************************************************************
+;; DATA STRUCTURES
+
+;; An atom (in the chemistry sense) is list with an integer (an index
+;; into the "Periodic" table, followed by a 3-vector of position
+;; information in angstroms.
+
+;; The force list is just a list of force vectors, one for each
+;; atom.  Forces are in tens of nanojoules (attojoules per
+;; angstrom). When I get around to implementing a velocity list, it
+;; will also just be a list of vectors, but I don't know what I'll
+;; use for units.
+
+;; A bond is a three-integer list. The first integer is the order of the
+;; bond (1, 2, or 3), and the second and third integers are indices into
+;; the atom list.
+
+;; A "Periodic" table entry is a list with five elements: an atom for the
+;; name of the element, three double-precision-reals for evdw, rvdw, and
+;; atomic mass, and an integer for the Official MM2 Type (to stay
+;; compliant with tables in 'Nanosystems').
+
+;; An MM2 term is a list starting with an atom (LENGTH, ANGLE, TORSION, or
+;; VDW) followed by some integers, which are indices into the atom list.
+
+;; The atom list, bond list, "periodic" table, and term list are respectively
+;; lists of all these things.
+
+(define ncad@
+  (unit/sig ()
+    (import mred:wx^ (mred : mred^))
+    
+    (define ncad:stand-alone #f)
+    (define (error-msg txt) ())  ;; redefined in GUI
+    (define (entering fcn) ())
+    
+    (define atom-list ())
+    (define bond-list ())
+    (define term-list ())
+    (define force-list ())
+    
+    ;; ******************************************************************
+    ;; Empirical coefficients
+    
+    (define periodic-table
+      '(("C" 0.357 1.9 19.925 1)         ;; sp3
+	("C" 0.357 1.94 19.925 2)        ;; sp2 alkene
+	("C" 0.357 1.94 19.925 3)        ;; sp2 carbonyl
+	("C" 0.357 1.94 19.925 4)        ;; sp acetylene
+	("H" 0.382 1.5 1.674 5)          ;; hydrocarbon
+	("O" 0.406 1.74 26.565 6)        ;; C-O-[HC]
+	("O" 0.536 1.74 26.565 7)        ;; O carbonyl
+	("N" 0.447 1.82 23.251 8)        ;; sp3
+	("F" 0.634 1.65 31.545 11)       ;; flouride
+	("Cl" 1.95 2.03 38.064 12)       ;; chloride
+	("Br" 2.599 2.18 131.038 13)     ;; bromide
+	("I" 3.444 2.32 210.709 14)      ;; iodide
+	("S" 1.641 2.11 53.087 15)       ;; sulfide
+	("Si" 1.137 2.25 46.454 19)      ;; silane
+	("LP" 0.13 1.2 0.0 20)           ;; lone pair
+	("H" 0.292 1.2 1.674 21)         ;; alcohol
+	("C" 0.357 1.9 19.925 22)        ;; cyclopropane
+	("P" 1.641 2.11 51.464 25)))     ;; phosphide
+    
+    (define (lookup-helper compare-func result-func default-result the-list)
+      (cond ((null? the-list) default-result)
+	    ((compare-func (car the-list)) (result-func (car the-list)))
+	    (else (lookup-helper compare-func result-func default-result
+				 (cdr the-list)))))
+    
+    ;; A length-coefficient entry is two MM2 atom types, followed by a
+    ;; k_s value, followed by an r0 value.
+    
+    (define length-coefficients
+      '((1 5 460 1.113)
+	(1 1 440 1.523)
+	(2 2 960 1.337)
+	(4 4 1560 1.212)
+	(1 6 536 1.402)
+	(1 8 510 1.438)
+	(3 7 1080 1.208)
+	(1 11 510 1.392)
+	(1 12 323 1.795)
+	(1 13 230 1.949)
+	(1 14 220 2.149)
+	(8 20 610 0.6)
+	(8 8 560 1.381)
+	(6 20 460 0.6)
+	(6 21 460 0.942)
+	(6 6 781 1.470)
+	(1 19 297 1.880)
+	(1 25 291 1.856)
+	(1 15 321.3 1.815)
+	(19 19 185 2.332)
+	(22 22 440 1.501)))
+    
+    (define (lookup-length-coeffs m n)
+      (lookup-helper
+       (lambda (x) (or (and (= m (car x))
+			    (= n (cadr x)))
+		       (and (= n (car x))
+			    (= m (cadr x)))))
+       (lambda (x) (cddr x))
+       '(400 1.3)
+       length-coefficients))
+    
+    ;; An angle-coefficient entry is three MM2 atoms types, followed by
+    ;; a k_th value, followed by a th0 value.
+    
+    (define angle-coefficients
+      '((1 1 1 0.45 1.911)
+	(1 1 5 0.36 1.909)
+	(5 1 5 0.32 1.909)
+	(1 1 11 0.65 1.911)
+	(11 1 11 1.07 1.869)
+	(1 2 1 0.45 2.046)
+	(2 1 2 0.45 1.911)
+	(1 2 2 0.55 2.119)
+	(2 2 5 0.36 2.094)
+	(2 2 2 0.43 2.094)
+	(1 4 4 0.2 3.142)
+	(1 3 7 0.46 2.138)
+	(1 6 1 0.77 1.864)
+	(1 8 1 0.63 1.88)
+	(1 1 6 0.57 1.911)
+	(1 6 20 0.35 1.835)
+	(1 8 20 0.5 1.906)
+	(20 6 20 0.24 2.286)
+	(19 19 19 0.35 1.943)
+	(19 1 19 0.4 2.016)
+	(1 19 1 0.48 1.934)
+	(12 1 12 1.08 1.95)
+	(1 1 15 0.55 1.902)
+	(1 15 1 0.72 1.902)
+	(4 4 5 0.4 3.142)
+	(7 3 1 0.4 3.142)
+	(7 3 2 0.4 3.142)
+	(7 3 3 0.4 3.142)
+	(5 8 5 1.1 1.85)))
+    
+    (define (lookup-angle-coeffs m n p)
+      (lookup-helper
+       (lambda (x) (or (and (= m (car x))
+			    (= n (cadr x))
+			    (= p (caddr x)))
+		       (and (= p (car x))
+			    (= n (cadr x))
+			    (= m (caddr x)))))
+       (lambda (x) (cdddr x))
+       '(0.4 2.094)
+       angle-coefficients))
+    
+    ;; An torsion-coefficient entry is four MM2 atoms types, followed by
+    ;; three values for v1, v2, and v3 respectively.
+    
+    (define torsion-coefficients
+      '((1 1 1 1 1.39 1.88 0.65)
+	(1 1 1 5 0.0 0.0 1.85)
+	(5 1 1 5 0.0 0.0 1.65)
+	(1 1 1 11 0.0 -0.6 6.46)
+	(1 2 2 1 -0.69 69.47 0.0)
+	(2 2 2 2 -6.46 55.58 0.0)
+	(5 2 2 5 0.0 104.21 0.0)))
+    
+    (define (lookup-torsion-coeffs m n p q)
+      (lookup-helper
+       (lambda (x) (or (and (= m (car x))
+			    (= n (cadr x))
+			    (= p (caddr x))
+			    (= q (cadddr x)))
+		       (and (= q (car x))
+			    (= p (cadr x))
+			    (= n (caddr x))
+			    (= m (cadddr x)))))
+       (lambda (x) (cddddr x))
+       '(0.0 0.0 0.0)
+       torsion-coefficients))
+    
+    ;; ******************************************************************
+    ;; Geometric fun with vectors
+    
+    (define (vplus v1 v2)
+      (vector (+ (vector-ref v1 0) (vector-ref v2 0))
+	      (+ (vector-ref v1 1) (vector-ref v2 1))
+	      (+ (vector-ref v1 2) (vector-ref v2 2))))
+    
+    (define (vdiff v1 v2)
+      (vector (- (vector-ref v1 0) (vector-ref v2 0))
+	      (- (vector-ref v1 1) (vector-ref v2 1))
+	      (- (vector-ref v1 2) (vector-ref v2 2))))
+    
+    (define (dot-product v1 v2)
+      (+ (* (vector-ref v1 0) (vector-ref v2 0))
+	 (* (vector-ref v1 1) (vector-ref v2 1))
+	 (* (vector-ref v1 2) (vector-ref v2 2))))
+    
+    (define (cross-product v1 v2)
+      (vector (- (* (vector-ref v1 1) (vector-ref v2 2))
+		 (* (vector-ref v1 2) (vector-ref v2 1)))
+	      (- (* (vector-ref v1 2) (vector-ref v2 0))
+		 (* (vector-ref v1 0) (vector-ref v2 2)))
+	      (- (* (vector-ref v1 0) (vector-ref v2 1))
+		 (* (vector-ref v1 1) (vector-ref v2 0)))))
+    
+    (define (vlen v)
+      (sqrt (dot-product v v)))
+    
+    (define (vscale v x)
+      (vector (* (vector-ref v 0) x)
+	      (* (vector-ref v 1) x)
+	      (* (vector-ref v 2) x)))
+    
+    ;; find the component of v1 perpendicular to v2
+    (define (perpendicular-component v1 v2)
+      (vdiff v1 (vscale v2 (/ (dot-product v1 v2) (dot-product v2 v2)))))
+    
+    (define (safe-acos z)
+      (if (> z 1.0) (set! z 1.0))
+      (if (< z -1.0) (set! z -1.0))
+      (acos z))
+    
+    (define (v-angle v1 v2)
+      (safe-acos (/ (dot-product v1 v2) (* (vlen v1) (vlen v2)))))
+    
+    (define (i-length v1 v2)
+      (vlen (vdiff v1 v2)))
+    
+    (define (i-angle v1 v2 v3)
+      (v-angle (vdiff v1 v2) (vdiff v3 v2)))
+    
+    (define (i-torsion v1 v2 v3 v4)
+      (let ((p (vdiff v1 v2))
+	    (q (vdiff v2 v3))
+	    (r (vdiff v4 v3)))
+	(v-angle (perpendicular-component p q)
+		 (perpendicular-component r q))))
+    
+    ;; ******************************************************************
+    ;; Forces computed by energy terms
+    
+    (define (do-to-all-atoms f)
+      (define (helper f n lst)
+	(cond ((null? lst) ())
+	      (else (cons (apply f (list n (car lst)))
+			  (helper f (+ n 1) (cdr lst))))))
+      (set! atom-list
+	    (helper f 0 atom-list)))
+    
+    (define (mm2-type a)
+      (cadddr (cdr (list-ref periodic-table a))))
+    
+    (define (add-comp v n x)
+      (vector-set! v n (+ (vector-ref v n) x)))
+    
+    (define (sub-add-to-force L n vsrc)
+      (cond ((null? L) ())
+	    ((= n 0)
+	     (let ((v (car L)))
+	       (cons (vector (+ (vector-ref v 0) (vector-ref vsrc 0))
+			     (+ (vector-ref v 1) (vector-ref vsrc 1))
+			     (+ (vector-ref v 2) (vector-ref vsrc 2)))
+		     (cdr L))))
+	    (else (cons (car L)
+			(sub-add-to-force (cdr L) (- n 1) vsrc)))))
+    
+    (define (add-to-force n v)
+      (set! force-list
+	    (sub-add-to-force force-list n v)))
+    
+    (define (length-force m n)
+      (entering "length-force")
+      (let* ((ma (list-ref atom-list m))  ;; members of atom-list
+	     (na (list-ref atom-list n))
+	     (coeffs
+	      (lookup-length-coeffs
+	       (mm2-type (car ma))
+	       (mm2-type (car na))))
+	     (ks (* 0.01 (car coeffs)))
+	     (r0 (cadr coeffs))
+	     (rd (vdiff (cadr ma) (cadr na)))
+	     (r (sqrt (dot-product rd rd)))
+	     (du-dr (* ks (- r r0)))
+	     (mult (/ (- du-dr) r)))
+	(add-to-force m (vscale rd mult))
+	(add-to-force n (vscale rd (- mult)))))
+    
+    ;; OK, for angles it gets a bit trickier. Let the atom positions be vectors
+    ;; r1, r2, r3, with r2 the vertex. Define the following:
+    ;; L1 = -dotproduct(r1-r2,r3-r2) * (r1-r2) + dotproduct(r1-r2,r1-r2) * (r3-r2)
+    ;; L3 = -dotproduct(r1-r2,r3-r2) * (r3-r2) + dotproduct(r3-r2,r3-r2) * (r1-r2)
+    ;; m1 = L1/|L1|, m3 = L3/|L3|
+    ;; Potential energy is given by U = f(theta), force on atom 1 is
+    ;; f1 = -m1 * dU/dm1 = (-m1/|r1-r2|) * dU/dtheta
+    ;; Likewise f3 = (-m3/|r3-r2|) * dU/dtheta
+    ;; Conservation: f2 = -f1-f3
+    
+    (define (angle-force m n p)
+      (entering "angle-force")
+      (let* ((ma (list-ref atom-list m))  ;; members of atom-list
+	     (na (list-ref atom-list n))
+	     (pa (list-ref atom-list p))
+	     (coeffs
+	      (lookup-angle-coeffs
+	       (mm2-type (car ma))
+	       (mm2-type (car na))
+	       (mm2-type (car pa))))
+	     (kth (car coeffs))
+	     (th0 (cadr coeffs))
+	     (th (i-angle (cadr ma) (cadr na) (cadr pa)))
+	     (tdif (- th th0))
+	     (du-dth (* kth (* tdif (+ 1 (* 1.508 tdif tdif)))))
+	     (r1r2 (vdiff (cadr ma) (cadr na)))
+	     (r3r2 (vdiff (cadr pa) (cadr na)))
+	     (L1 (vdiff (vscale r3r2 (dot-product r1r2 r1r2))
+			(vscale r1r2 (dot-product r1r2 r3r2))))
+	     (f1 (vscale L1 (/ du-dth (* (vlen L1) (vlen r1r2)))))
+	     (L3 (vdiff (vscale r1r2 (dot-product r3r2 r3r2))
+			(vscale r3r2 (dot-product r1r2 r3r2))))
+	     (f3 (vscale L3 (/ du-dth (* (vlen L3) (vlen r3r2)))))
+	     (f2 (vscale (vplus f1 f3) -1.0)))
+	(add-to-force m f1)
+	(add-to-force n f2)
+	(add-to-force p f3)))
+    
+    ;; To think about torsions, think of the projection of the whole thing into
+    ;; the plane perpendicular to the torqued bond.
+    
+    ;; Actually, torsions appear to contribute a negligible amount of force
+    ;; compared even to van der Waals, but they require this atrociously complex
+    ;; calculation. I'm thinking about just not bothering to compute them at all.
+    ;; I think the math here is correct, just woefully inefficient.
+    
+    (define use-torsion-forces #f)
+    
+    (define (torsion-force m n p q)
+      (entering "torsion-force")
+      (if use-torsion-forces
+	  (let* ((ma (list-ref atom-list m))
+		 (na (list-ref atom-list n))
+		 (pa (list-ref atom-list p))
+		 (qa (list-ref atom-list q))
+		 (coeffs
+		  (lookup-torsion-coeffs
+		   (mm2-type (car ma))
+		   (mm2-type (car na))
+		   (mm2-type (car pa))
+		   (mm2-type (car qa))))
+		 (v1 (car coeffs))
+		 (v2 (cadr coeffs))
+		 (v3 (caddr coeffs))
+		 (pv (vdiff (cadr ma) (cadr na)))
+		 (qv (vdiff (cadr pa) (cadr na)))
+		 (rv (vdiff (cadr qa) (cadr pa)))
+		 (pp (dot-product pv pv))
+		 (qq (dot-product qv qv))
+		 (rr (dot-product rv rv))
+		 (pq (dot-product pv qv))
+		 (qr (dot-product qv rv))
+		 (alpha (sqrt (/ (* pq pq) qq)))
+		 (beta (sqrt (* qq qq)))
+		 (gamma (sqrt (/ (* qr qr) qq)))
+		 (vm1 (cross-product qv pv))
+		 (vq1 (cross-product rv qv))
+		 (vm2 (vscale vm1 (/ 1.0 (* (vlen vm1)))))
+		 (vq2 (vscale vq1 (/ 1.0 (* (vlen vq1)))))
+		 (w (safe-acos (dot-product vm2 vq2)))
+		 (du-dw (* -0.0005 (+ (* v1 (sin w))
+				      (* -2 v2 (sin (* 2 w)))
+				      (* 3 v3 (sin (* 3 w))))))
+		 (fm (vscale vm2 (/ du-dw
+				    (sqrt (- pp (/ (* pq pq) qq))))))
+		 (fq (vscale vq2 (/ du-dw
+				    (sqrt (- rr (/ (* qr qr) qq)))))))
+	    (add-to-force m fm)
+	    (add-to-force q fq)
+	    (add-to-force p
+			  (vdiff (vscale fm (/ alpha beta))
+				 (vscale fq (/ (+ gamma beta) beta))))
+	    (add-to-force n
+			  (vdiff (vscale fq (/ gamma beta))
+				 (vscale fm (/ (+ alpha beta) beta)))))))
+    
+    ;; vdw is similar to length force
+    ;; du/dr = 6*evdw*[(r/rvdw)^-7 - (r/rvdw)^-13]
+    ;; Don't forget the factor of 0.001
+    
+    (define use-vdw-forces #t)
+    
+    (define (vdw-force m n)
+      (entering "vdw-force")
+      (if use-vdw-forces
+	  (let* ((ma (list-ref atom-list m))  ;; members of atom-list
+		 (na (list-ref atom-list n))
+		 (evdw (* 0.5 (+ (cadr (list-ref periodic-table (car ma)))
+				 (cadr (list-ref periodic-table (car na))))))
+		 (rvdw (+ (caddr (list-ref periodic-table (car ma)))
+			  (caddr (list-ref periodic-table (car na)))))
+		 (rd (vdiff (cadr ma) (cadr na)))
+		 (r (sqrt (dot-product rd rd)))
+		 (rsq_recip (/ (* rvdw rvdw) (dot-product rd rd))) ;; (r/rvdw)^-2
+		 (r_recip (sqrt rsq_recip))
+		 (r6 (* rsq_recip rsq_recip rsq_recip))    ;; (r/rvdw)^-6
+		 (du-dr (* 0.006 evdw r_recip r6 (- 1 (* 2 r6))))
+		 (mult (/ (- du-dr) r)))
+	    (add-to-force m (vscale rd mult))
+	    (add-to-force n (vscale rd (- mult))))))
+    
+    (define need-to-resetup-terms #t)
+    
+    (define (compute-forces)
+      (entering "compute-forces")
+      (if need-to-resetup-terms
+	  (let ()
+	    (setup-terms)
+	    (set! need-to-resetup-terms #f)))
+      ;; first set all forces to zero, one force vector for each atom
+      (set! force-list
+	    (map (lambda (atm)
+		   (vector 0.0 0.0 0.0))
+		 atom-list))
+      ;; next figure out contributions for each energy term
+      (do ((L term-list (cdr L)))
+	((null? L) ())
+	(case (caar L)
+	  ((length) (apply length-force (cdar L)))
+	  ((angle) (apply angle-force (cdar L)))
+	  ((torsion) (apply torsion-force (cdar L)))
+	  ((vdw) (apply vdw-force (cdar L))))))
+    
+    ;; ******************************************************************
+    ;; Building up a term list from an atom list and bond list
+    
+    (define (other-end bond atm)
+      (cond ((= atm (cadr bond)) (caddr bond))
+	    ((= atm (caddr bond)) (cadr bond))
+	    (else #f)))
+    
+    (define whine-about-bond-count #f)
+    
+    (define (count-bonds n expected)
+      (do ((dbonds 0)
+	   (tbonds 0)
+	   (sbonds 0)
+	   (bond ())
+	   (L bond-list (cdr L)))
+	((null? L) (let ((nb (+ sbonds (* 2 dbonds) (* 3 tbonds))))
+		     (if (not (= expected nb))
+			 (set! whine-about-bond-count #t))
+		     (list sbonds dbonds tbonds)))
+	(set! bond (car L))
+	(if (or (= n (cadr bond)) (= n (caddr bond)))
+	    (case (car bond)
+	      ((1) (set! sbonds (+ sbonds 1)))
+	      ((2) (set! dbonds (+ dbonds 1)))
+	      (else (set! tbonds (+ tbonds 1)))))))
+    
+    (define (setup-terms)
+      ;; for each atom, figure out what element it's supposed to be,
+      ;; count its bonds, verify against valence, and reassign its
+      ;; periodic table index according to hybridization
+      (do-to-all-atoms
+       (lambda (n atm)
+	 (let ((b ()))
+	   (case (car atm)
+	     ;; carbon
+	     ((0 1 2 3) (set! b (count-bonds n 4))
+	      (if (= (caddr b) 1)
+		  (cons 3 (cdr atm))
+		  (if (= (cadr b) 2)
+		      (cons 2 (cdr atm))
+		      (if (= (cadr b) 1)
+			  (cons 1 (cdr atm))
+			  (cons 0 (cdr atm))))))
+	     ;; hydrogen
+	     ((4) (set! b (count-bonds n 1))
+		atm)
+	     ;; oxygen
+	     ((5 6) (set! b (count-bonds n 2))
+	      (if (= (cadr b) 1)
+		  (cons 6 (cdr atm))
+		  (cons 5 (cdr atm))))
+	     ;; nitrogen
+	     (else (count-bonds n 3)
+		   atm)))))
+      (set! term-list ())
+      ;; tally up length terms
+      (do ((BL bond-list (cdr BL)))
+	((null? BL) ())
+	(set! term-list
+	      (cons (list 'length (cadar BL) (caddar BL)) term-list)))
+      ;; tally up angle terms
+      (do ((AL atom-list (cdr AL))
+	   (x 0 (+ x 1)))
+	((null? AL) ())
+	(do ((BL bond-list (cdr BL)))
+	  ((null? BL) ())
+	  (let ((y (other-end (car BL) x)))
+	    (if y
+		(do ((B2L bond-list (cdr B2L)))
+		  ((null? B2L) ())
+		  (let ((z (other-end (car B2L) y)))
+		    (if (and z (> z x))
+			(set! term-list
+			      (cons (list 'angle x y z) term-list)))))))))
+      ;; tally up the torsion terms
+      (do ((AL atom-list (cdr AL))
+	   (w 0 (+ w 1)))
+	((null? AL) ())
+	(do ((BL bond-list (cdr BL)))
+	  ((null? BL) ())
+	  (let ((x (other-end (car BL) w)))
+	    (if x
+		(do ((B2L bond-list (cdr B2L)))
+		  ((null? B2L) ())
+		  (let ((y (other-end (car B2L) x)))
+		    (if (and y (not (= w y)))
+			(do ((B3L bond-list (cdr B3L)))
+			  ((null? B3L) ())
+			  (let ((z (other-end (car B3L) y)))
+			    (if (and z (not (= z x)) (> z w))
+				(set! term-list
+				      (cons (list 'torsion w x y z)
+					    term-list))))))))))))
+      ;; tally up the van der Waals terms (unbonded atom pairs)
+      (do ((AL atom-list (cdr AL))
+	   (x 0 (+ x 1)))
+	((null? AL) ())
+	(do ((A2L (cdr AL) (cdr A2L))
+	     (y (+ x 1) (+ y 1))
+	     (flag #t))
+	  ((null? A2L) ())
+	  (set! flag #t)
+	  (do ((BL bond-list (cdr BL)))
+	    ((null? BL) ())
+	    (let ((p (other-end (car BL) x)))
+	      (if (and p (= p y))
+		  (let ()
+		    (set! flag #f)
+		    (set! BL '(4))))))
+	  (if flag
+	      (set! term-list
+		    (cons (list 'vdw x y)
+			  term-list))))))
+    
+    ;; ******************************************************************
+    ;; Rotations and Centering
+    
+    (define (center-structure)
+      (if (> (length atom-list) 0)
+	  (let ((cog (vector 0.0 0.0 0.0))  ;; center of gravity
+		(num-atoms 0))
+	    (do ((L atom-list (cdr L)))
+	      ((null? L) ())
+	      (vector-set! cog 0
+			   (+ (vector-ref cog 0)
+			      (vector-ref (cadar L) 0)))
+	      (vector-set! cog 1
+			   (+ (vector-ref cog 1)
+			      (vector-ref (cadar L) 1)))
+	      (vector-set! cog 2
+			   (+ (vector-ref cog 2)
+			      (vector-ref (cadar L) 2)))
+	      (set! num-atoms (+ num-atoms 1)))
+	    (vector-set! cog 0
+			 (/ (vector-ref cog 0) num-atoms))
+	    (vector-set! cog 1
+			 (/ (vector-ref cog 1) num-atoms))
+	    (vector-set! cog 2
+			 (/ (vector-ref cog 2) num-atoms))
+	    (do ((L atom-list (cdr L)))
+	      ((null? L) ())
+	      (vector-set! (cadar L) 0
+			   (- (vector-ref (cadar L) 0) (vector-ref cog 0)))
+	      (vector-set! (cadar L) 1
+			   (- (vector-ref (cadar L) 1) (vector-ref cog 1)))
+	      (vector-set! (cadar L) 2
+			   (- (vector-ref (cadar L) 2) (vector-ref cog 2)))))))
+    
+    (define (rotate-all-atoms-x-axis theta)
+      (let ((ct (cos theta))
+	    (st (sin theta))
+	    (temp 0.0))
+	(do ((L atom-list (cdr L)))
+	  ((null? L) ())
+	  (set! temp (- (* ct (vector-ref (cadar L) 1))
+			(* st (vector-ref (cadar L) 2))))
+	  (vector-set! (cadar L) 2
+		       (+ (* ct (vector-ref (cadar L) 2))
+			  (* st (vector-ref (cadar L) 1))))
+	  (vector-set! (cadar L) 1 temp))))
+    
+    (define (rotate-all-atoms-y-axis theta)
+      (let ((ct (cos theta))
+	    (st (sin theta))
+	    (temp 0.0))
+	(do ((L atom-list (cdr L)))
+	  ((null? L) ())
+	  (set! temp (+ (* ct (vector-ref (cadar L) 0))
+			(* st (vector-ref (cadar L) 2))))
+	  (vector-set! (cadar L) 2
+		       (- (* ct (vector-ref (cadar L) 2))
+			  (* st (vector-ref (cadar L) 0))))
+	  (vector-set! (cadar L) 0 temp))))
+    
+    (define negligible-angle-sq 0.00001)
+    
+    (define (rotate-structure xt yt)
+      (if (> (* xt xt) negligible-angle-sq)
+	  (rotate-all-atoms-y-axis xt))
+      (if (> (* yt yt) negligible-angle-sq)
+	  (rotate-all-atoms-x-axis yt)))
+    
+    (define (set-atom-position n x y z)
+      (do ((L atom-list (cdr L))
+	   (got-it #f))
+	((cond ((null? L) #t)
+	       ((= n 0) (vector-set! (cadar L) 0 x)
+		(vector-set! (cadar L) 1 y)
+		(vector-set! (cadar L) 2 z)
+		; (set! n-ok #t)
+		#t)
+	       (else #f))
+	 got-it)
+	(set! n (- n 1))))
+    
+    (define (get-atom-position n x y z)
+      (do ((L atom-list (cdr L))
+	   (return-value #f))
+	((cond ((null? L) #t)
+	       ((= n 0) (set! return-value (cadar L))
+		#t)
+	       (else #f))
+	 return-value)
+	(set! n (- n 1))))
+    
+    
+    ;; ******************************************************************
+    ;; Conversion, screen coordinates <=> angstroms
+    
+    (define scale-factor 25.0)
+    
+    (define (set-scale-factor x) (set! scale-factor x))
+    (define (su2a x) (/ x scale-factor))
+    (define (a2su x) (* x scale-factor))
+    
+    ;; ******************************************************************
+    ;; Add/delete/select atoms and bonds
+    
+    (define (remove-from-list L n)
+      (cond ((null? L) ())
+	    ((= n 0) (cdr L))
+	    (else (cons (car L)
+			(remove-from-list (cdr L) (- n 1))))))
+    
+    (define (remove-from-list-if-test L test)
+      (cond ((null? L) ())
+	    ((apply test (list (car L)))
+	     (remove-from-list-if-test (cdr L) test))
+	    (else (cons (car L)
+			(remove-from-list-if-test (cdr L) test)))))
+    
+    (define (add-bond m n order)
+      (if (not (= m n))
+	  (let ()
+	    (define need-to-resetup-terms #t)
+	    (delete-bond m n)
+	    (set! bond-list (cons (list order m n) bond-list)))))
+    
+    (define (delete-bond m n)
+      (set! need-to-resetup-terms #t)
+      (set! bond-list
+	    (remove-from-list-if-test
+	     bond-list
+	     (lambda (bond) (or (and (= m (cadr bond))
+				     (= n (caddr bond)))
+				(and (= n (cadr bond))
+				     (= m (caddr bond))))))))
+    
+    (define (add-atom x y e)
+      (set! need-to-resetup-terms #t)
+      (set! atom-list
+	    (append
+	     atom-list
+	     (list
+	      (list e (vector (su2a x) (su2a y) 0.0)))))
+      (set! force-list
+	    (append
+	     force-list
+	     (list
+	      (vector 0.0 0.0 0.0)))))
+    
+    (define (delete-atom n)
+      (set! need-to-resetup-terms #t)
+      (set! atom-list (remove-from-list atom-list n))
+      (set! force-list (remove-from-list force-list n))
+      (set! bond-list (remove-from-list-if-test
+		       bond-list
+		       (lambda (bond) (or (= n (cadr bond))
+					  (= n (caddr bond))))))
+      (set! bond-list
+	    (map
+	     (lambda (bond)
+	       (if (> (cadr bond) n)
+		   (set! bond (list (car bond)
+				    (- (cadr bond) 1)
+				    (caddr bond))))
+	       (if (> (caddr bond) n)
+		   (set! bond (list (car bond)
+				    (cadr bond)
+				    (- (caddr bond) 1))))
+	       bond)
+	     bond-list)))
+    
+    (define (select-atom x y)
+      (set! x (su2a x))
+      (set! y (su2a y))
+      (do ((n #f)
+	   (i 0 (+ i 1))
+	   (p 0.0)
+	   (sq-dist 0.0)
+	   (min-sq-dist 0.0)
+	   (L atom-list (cdr L)))
+	((null? L) n)
+	(set! p (- x (vector-ref (cadar L) 0)))
+	(set! sq-dist (* p p))
+	(set! p (- y (vector-ref (cadar L) 1)))
+	(set! sq-dist (+ sq-dist (* p p)))
+	(if (or (not n) (< sq-dist min-sq-dist))
+	    (let ()
+	      (set! min-sq-dist sq-dist)
+	      (set! n i)))))
+    
+    (define (move-atom n x y)
+      (define (move-helper n x y lst)
+	(cond ((null? lst) ())
+	      ((= n 0) (cons
+			(let ((atm (car lst)))
+			  (list (car atm)
+				(vector (su2a x)
+					(su2a y)
+					(vector-ref (cadr atm) 2))))
+			(cdr lst)))
+	      (else (cons (car lst)
+			  (move-helper (- n 1) x y (cdr lst))))))
+      (set! atom-list
+	    (move-helper n x y atom-list)))
+    
+    ;; ******************************************************************
+    ;; Drawing lists
+    
+    ;; For wireframe drawing lists, we want only to return an unordered list
+    ;; of bonds, and we can throw away information about bond order. This
+    ;; should be very quick, so we can draw wireframes while rotating a
+    ;; molecule smoothly.
+    
+    (define (wireframe-drawing-list)
+      (entering "wireframe-drawing-list")
+      (do ((L bond-list (cdr L))
+	   (drawing-list ())
+	   (m 0)
+	   (n 0))
+	((null? L) drawing-list)
+	(set! m (cadar L))
+	(set! n (caddar L))
+	(set! drawing-list
+	      (cons
+	       (list (a2su (vector-ref (cadr (list-ref atom-list m)) 0))
+		     (a2su (vector-ref (cadr (list-ref atom-list m)) 1))
+		     (a2su (vector-ref (cadr (list-ref atom-list n)) 0))
+		     (a2su (vector-ref (cadr (list-ref atom-list n)) 1)))
+	       drawing-list))))
+    
+    ;; To create detailed drawing lists, we want to specify an order in which
+    ;; things are drawn, with the most-positive-z-value things drawn first, and
+    ;; the more-negative-z-value things drawn on top of them (the Painter's
+    ;; algorithm) for crude depth rendering. To do this we use a data structure,
+    ;; a list of lists, each inner list containing a boolean, an integer, and a
+    ;; z-value. The boolean tells whether this object is in the atom list or the
+    ;; bond list, the integer indexes into that list, and the z value represents
+    ;; either an atomic nucleus or the midpoint of a bond.
+    
+    (define (bubble-1 criterion lst)
+      (cond ((not (pair? lst)) lst)
+	    ((null? (cdr lst)) lst)
+	    (else (let ((a (car lst))
+			(b (cadr lst)))
+		    (if (apply criterion (list a b))
+			(cons a (bubble-1 criterion (cdr lst)))
+			(cons b (bubble-1 criterion (cons a (cddr lst)))))))))
+    
+    (define (bubble-sort criterion lst)
+      (cond ((null? lst) ())
+	    (else (set! lst (reverse (bubble-1 criterion (reverse lst))))
+		  (cons (car lst)
+			(bubble-sort criterion (cdr lst))))))
+    
+    (define (detailed-drawing-list)
+      (entering "detailed-drawing-list")
+      (let ((DL ()))
+	(do ((L bond-list (cdr L))
+	     (i 0 (+ i 1)))
+	  ((null? L) ())
+	  (set! DL
+		(cons
+		 (list
+		  #f i
+		  (* 0.5
+		     (+ (vector-ref (cadr (list-ref atom-list (cadar L))) 2)
+			(vector-ref (cadr (list-ref atom-list (caddar L))) 2))))
+		 DL)))
+	(do ((L atom-list (cdr L))
+	     (i 0 (+ i 1)))
+	  ((null? L) ())
+	  (set! DL (cons (list #t i (vector-ref (cadar L) 2))
+			 DL)))
+	(set! DL
+	      (bubble-sort (lambda (x y)
+			     (> (caddr x) (caddr y)))
+			   DL))
+	(map (lambda (widget)
+	       (if (car widget)
+		   (let* ((atm (list-ref atom-list (cadr widget)))
+			  (atm-pos (cadr atm))
+			  (atm-force (list-ref force-list (cadr widget))))
+		     (list #t
+			   (a2su (vector-ref atm-pos 0))
+			   (a2su (vector-ref atm-pos 1))
+			   (car atm)
+			   (* 0.05 (a2su (vector-ref atm-force 0)))
+			   (* 0.05 (a2su (vector-ref atm-force 1)))))
+		   (let* ((bnd (list-ref bond-list (cadr widget)))
+			  (pos1 (cadr (list-ref atom-list (cadr bnd))))
+			  (pos2 (cadr (list-ref atom-list (caddr bnd)))))
+		     (list #f
+			   (a2su (vector-ref pos1 0))
+			   (a2su (vector-ref pos1 1))
+			   (a2su (vector-ref pos2 0))
+			   (a2su (vector-ref pos2 1))
+			   (car bnd)))))
+	     DL)))
+    
+    ;; ******************************************************************
+    ;; Loading and saving structures
+    
+    (define (get-structure)
+      (list (map (lambda (z)
+		   (list (car z)
+			 (vector-ref (cadr z) 0)
+			 (vector-ref (cadr z) 1)
+			 (vector-ref (cadr z) 2)))
+		 atom-list)
+	    bond-list))
+    
+    (define (set-structure s)
+      (set! atom-list (map (lambda (z)
+			     (list (car z)
+				   (vector (cadr z) (caddr z) (cadddr z))))
+			   (car s)))
+      (set! bond-list (cadr s)))
+    
+    ;; ******************************************************************
+    ;; Potential energy minimization
+    
+    ;; We compute force vectors, and then scale them until to be displacement
+    ;; vectors, where the largest displacement has a magnitude equal to
+    ;; emin-factor (which is in angstroms).
+    
+    ;; currently, these represent angstroms
+    (define fast-emin-factor 0.2)
+    (define stable-emin-factor 0.01)
+    
+    (define emin-factor stable-emin-factor)
+    
+    (define (emin-step)
+      (entering "emin-sub-step")
+      (set! whine-about-bond-count #f)
+      (setup-terms)
+      (do ((i 0 (+ i 1)))
+	((= i 25) ())
+	(compute-forces)
+	(do-to-all-atoms
+	 (lambda (n atm)
+	   (let ((f (list-ref force-list n)))
+	     (list (car atm)
+		   (vplus (cadr atm)
+			  (vscale f (/ emin-factor (vlen f)))))))))
+      (update-display #t #f)
+      (if whine-about-bond-count
+	  (error-msg "Mismatch between bonds and valences")))
+    
+    
+    
+    ;; ******************************************************************
+    ;; ******************************************************************
+    ;;                        THE REST IS GUI CODE
+    ;; ******************************************************************
+    ;; ******************************************************************
+    
+    (define center-x #f)
+    (define center-y #f)
+    (define start-mouse ())
+    (define selected-atom 0)
+    (define current-element 0)
+    (define bond-order 1)
+    (define atom-drawing-radius 10)
+    (define draw-force-vectors #f)
+    (define current-mouse-button #f)
+    
+    (define (select-an-atom x y)
+      (set! selected-atom
+	    (select-atom (- x center-x)
+			 (- y center-y))))
+    
+    (define (rotate-press x y)
+      (center-structure)
+      (set! start-mouse (list x y)))
+    
+    (define (rotate-drag x y)
+      (rotate-structure
+       (* 0.01 (- x (car start-mouse)))
+       (* -0.01 (- y (cadr start-mouse))))
+      (set! start-mouse (list x y))
+      (update-display #f #t))
+    
+    (define (rotate-release x y)
+      (update-display #t #t))
+    
+    (define (move-drag x y)
+      (move-atom selected-atom
+		 (- x center-x)
+		 (- y center-y))
+      (update-display #t #t))
+    
+    (define (addatom-press x y)
+      (let ((x1 (- x center-x))
+	    (y1 (- y center-y)))
+	(add-atom (- x center-x)
+		  (- y center-y)
+		  current-element)
+	(update-display #t #f)))
+    
+    (define (deleteatom-press x y)
+      (select-an-atom x y)
+      (delete-atom selected-atom)
+      (update-display #t #f))
+    
+    (define (deletebond-release x y)
+      (let ((n selected-atom))
+	(select-an-atom x y)
+	(delete-bond n selected-atom)
+	(update-display #t #f)))
+    
+    (define (addbond-release x y)
+      (let ((n selected-atom))
+	(select-an-atom x y)
+	(if (not (= n selected-atom))
+	    (add-bond n selected-atom bond-order))
+	(update-display #t #f)))
+    
+    (define (do-nothing x y) ())
+    
+    (define press-function rotate-press)
+    (define drag-function rotate-drag)
+    (define release-function rotate-release)
+    
+    ;; For now, pay attention only to the left mouse button
+    
+    (define (press-function-b x y)
+      (if (eq? current-mouse-button 1)
+	  (press-function x y)))
+    
+    (define (drag-function-b x y)
+      (if (eq? current-mouse-button 1)
+	  (drag-function x y)))
+    
+    (define (release-function-b x y)
+      (if (eq? current-mouse-button 1)
+	  (release-function x y)))
+    
+    
+    (define my-frame% mred:frame%)
+    
+    (define my-canvas%
+      (make-class mred:canvas%
+		  (private
+		    (which-button 0))
+		  (rename [super-on-paint on-paint])
+		  (public
+		    (on-paint
+		     (lambda ()
+		       (update-display #t #f)
+		       (super-on-paint)))
+		    (on-event
+		     (lambda (event)
+		       (let ((which-button
+			      (cond ((send event button? 1) 1)
+				    ((send event button? 2) 2)
+				    (else 3)))
+			     (x (send event get-x))
+			     (y (send event get-y)))
+			 (cond ((send event button-down? -1)
+				(set! current-mouse-button which-button)
+				(press-function-b x y))
+			       ((send event button-up? -1)
+				(release-function-b x y)
+				(set! current-mouse-button #f))
+			       ((and current-mouse-button
+				     (send event dragging?))
+				(drag-function-b x y))
+			       (else #f))))))))
+    
+    (define this-session ())
+    
+    (define (update-display full-blown smooth)
+      (update-session full-blown
+		      smooth
+		      (send (ivar this-session canvas) get-width)
+		      (send (ivar this-session canvas) get-height)
+		      (ivar this-session canvas-dc)
+		      (ivar this-session atom-color)
+		      (ivar this-session select-pen)))
+    
+    (define session%
+      (class () ()
+	(sequence
+	  (set! this-session this))
+	(public
+	  (FRAME-WIDTH 500)
+	  (PANEL-HEIGHT 200)
+	  (CANVAS-HEIGHT 300)
+	  (a-frame
+	   (make-object my-frame%
+			'() ; No parent frame
+			"NanoCAD v0.2" ; The frame's title
+			-1 -1 ; Use the default position
+			FRAME-WIDTH (+ PANEL-HEIGHT CANVAS-HEIGHT)))
+	  (main-panel
+	   (make-object mred:vertical-panel% a-frame))
+	  (b-panel
+	   (make-object mred:horizontal-panel% main-panel))
+	  (c-panel
+	   (make-object mred:horizontal-panel% main-panel))
+	  (rb-panel
+	   (let ([p (make-object mred:horizontal-panel% main-panel)])
+	     (send p set-label-position wx:const-vertical)
+	     p))
+	  (canvas
+	   (make-object my-canvas% main-panel))
+	  (canvas-dc
+	   (send canvas get-dc)))
+	
+	(private
+	  (internal-update
+	   (lambda (full-blown)
+	     (update-session full-blown
+			     #f
+			     (send canvas get-width)
+			     (send canvas get-height)
+			     canvas-dc
+			     atom-color
+			     select-pen)))
+	  (carbon-brush
+	   (make-object wx:brush% "BLACK" wx:const-solid))
+	  (hydrogen-brush
+	   (make-object wx:brush% "WHITE" wx:const-solid))
+	  (oxygen-brush
+	   (make-object wx:brush% "RED" wx:const-solid))
+	  (nitrogen-brush
+	   (make-object wx:brush% "BLUE" wx:const-solid))
+	  
+	  (normal-pen
+	   (make-object wx:pen% "BLACK" 1 wx:const-solid))
+	  (double-bond-pen
+	   (make-object wx:pen% "BLACK" 3 wx:const-solid))
+	  (triple-bond-pen
+	   (make-object wx:pen% "BLACK" 5 wx:const-solid))
+	  (force-vector-pen
+	   (make-object wx:pen% "RED" 1 wx:const-solid))
+	  
+	  (load-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (let ((file-name (wx:file-selector "")))
+			    (if (not (null? file-name))
+				(let ((inf (open-input-file file-name)))
+				  (set-structure (read inf))
+				  (close-input-port inf)
+				  (set! need-to-resetup-terms #t)
+				  (internal-update #t)))))
+			"Load"))
+	  (save-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (let ((file-name (wx:file-selector "")))
+			    (if (not (null? file-name))
+				(let ()
+				  (delete-file file-name)
+				  (let ((outf (open-output-file file-name))
+					(s (get-structure)))
+				    (fprintf outf "((~%")
+				    (map (lambda (atm)
+					   (fprintf outf "  ~s~%" atm))
+					 (car s))
+				    (fprintf outf " )~% (~%")
+				    (map (lambda (atm)
+					   (fprintf outf "  ~s~%" atm))
+					 (cadr s))
+				    (fprintf outf "))~%")
+				    (close-output-port outf)
+				    (internal-update #t))))))
+			"Save"))
+	  (save-xyz-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (let ((file-name (wx:file-selector "")))
+			    (if (not (null? file-name))
+				(let ()
+				  (delete-file file-name)
+				  (let ((outf (open-output-file file-name)))
+				    (fprintf outf "~a~%Gray Goo~%"
+					     (length atom-list))
+				    (do ((L atom-list (cdr L)))
+				      ((null? L) ())
+				      (fprintf outf "~a ~a ~a ~a~%"
+					       (car
+						(list-ref periodic-table
+							  (caar L)))
+					       (vector-ref (cadar L) 0)
+					       (vector-ref (cadar L) 1)
+					       (- (vector-ref (cadar L) 2))))
+				    (close-output-port outf)
+				    (internal-update #t))))))
+			"SaveXYZ"))
+	  (clear-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (set! atom-list ())
+			  (set! bond-list ())
+			  (set! term-list ())
+			  (internal-update #t))
+			"Clear"))
+	  (emin-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (emin-step))
+			"Emin"))
+	  (quit-button
+	   (make-object mred:button%
+			b-panel
+			(lambda (self event)
+			  (send canvas-dc end-drawing)
+			  (send a-frame show #f))
+			"Quit")))
+	(private
+	  (show-forces-checkbox
+	   (make-object mred:check-box%
+			c-panel
+			(lambda (self event)
+			  (set! draw-force-vectors (send event checked?))
+			  (internal-update #t))
+			"Show Force Vectors"))
+	  (use-torsion-checkbox
+	   (make-object mred:check-box%
+			c-panel
+			(lambda (self event)
+			  (set! use-torsion-forces (send event checked?)))
+			"Use Torsion Forces"))
+	  (use-vdw-checkbox
+	   (make-object mred:check-box%
+			c-panel
+			(lambda (self event)
+			  (set! use-vdw-forces (send event checked?)))
+			"Use VDW Forces")))
+	(public
+	  (select-pen
+	   (lambda (dc n)
+	     (case n
+	       ((0) (send dc set-pen normal-pen))
+	       ((1) (send dc set-pen force-vector-pen))
+	       ((2) (send dc set-pen double-bond-pen))
+	       ((3) (send dc set-pen triple-bond-pen)))))
+	  (atom-color
+	   (lambda (dc element)
+	     (case element
+	       ((0 1 2 3) (send dc set-brush carbon-brush))
+	       ((4)         (send dc set-brush hydrogen-brush))
+	       ((5 6)     (send dc set-brush oxygen-brush))
+	       (else      (send dc set-brush nitrogen-brush))))))
+	(private
+	  (rb-sub-panel%
+	   (class mred:panel% args
+	     (inherit set-label-position)
+	     (sequence
+	       (apply super-init args)
+	       (set-label-position wx:const-vertical))))
+	  (set-mode
+	   (lambda (n)
+	     (case n
+	       ((0) (set! press-function rotate-press)
+		  (set! drag-function rotate-drag)
+		  (set! release-function rotate-release))
+	       ((1) (set! press-function select-an-atom)
+		  (set! drag-function move-drag)
+		  (set! release-function do-nothing))
+	       ((2) (set! press-function addatom-press)
+		  (set! drag-function do-nothing)
+		  (set! release-function do-nothing))
+	       ((3) (set! press-function deleteatom-press)
+		  (set! drag-function do-nothing)
+		  (set! release-function do-nothing))
+	       ((4) (set! press-function select-an-atom)
+		  (set! drag-function do-nothing)
+		  (set! release-function addbond-release))
+	       ((5) (set! press-function select-an-atom)
+		  (set! drag-function do-nothing)
+		  (set! release-function deletebond-release)))))
+	  (mode-selector
+	   (make-object mred:radio-box%
+			(make-object rb-sub-panel% rb-panel)
+			(lambda (self event)
+			  (let ((n (send event get-command-int)))
+			    (set-mode n)))
+			"Tool"
+			-1 -1 -1 -1
+			(list "Rotate" "MoveAtom" "AddAtom" "DeleteAtom"
+			      "AddBond" "DeleteBond")))
+	  (element-selector
+	   (make-object mred:radio-box%
+			(make-object rb-sub-panel% rb-panel)
+			(lambda (self event)
+			  (send mode-selector set-selection 2)
+			  (set-mode 2)
+			  (let ((n (send event get-command-int)))
+			    (case n
+			      ((0) (set! current-element 0))
+			      ((1) (set! current-element 4))
+			      ((2) (set! current-element 5))
+			      (else (set! current-element 7)))))
+			"Atom"
+			-1 -1 -1 -1
+			(list "Carbon" "Hydrogen" "Oxygen" "Nitrogen")))
+	  (bond-order-selector
+	   (make-object mred:radio-box%
+			(make-object rb-sub-panel% rb-panel)
+			(lambda (self event)
+			  (send mode-selector set-selection 4)
+			  (set-mode 4)
+			  (let ((n (send event get-command-int)))
+			    (set! bond-order (+ n 1))))
+			"Bond"
+			-1 -1 -1 -1
+			(list "Single" "Double" "Triple")))
+	  (zoom-factor
+	   (make-object mred:radio-box%
+			(make-object rb-sub-panel% rb-panel)
+			(lambda (self event)
+			  (let ((n (send event get-command-int)))
+			    (case n
+			      ((0) (set-scale-factor 10.0))
+			      ((1) (set-scale-factor 25.0))
+			      ((2) (set-scale-factor 50.0))
+			      (else (set-scale-factor 100.0))))
+			  (set! atom-drawing-radius (* 0.6 scale-factor))
+			  (internal-update #t))
+			"Zoom"
+			-1 -1 -1 -1
+			(list "10" "25" "50" "100")))
+	  (emin-convergence
+	   (make-object mred:radio-box%
+			(make-object rb-sub-panel% rb-panel)
+			(lambda (self event)
+			  (let ((n (send event get-command-int)))
+			    (case n
+			      ((0) (set! emin-factor stable-emin-factor))
+			      (else (set! emin-factor fast-emin-factor)))))
+			"Emin"
+			-1 -1 -1 -1
+			(list "Stable" "Fast"))))
+	(sequence
+	  (send main-panel border 0)
+	  (for-each
+	   (lambda (panel)
+	     (send panel stretchable-in-y #f)
+	     (send panel border 0))
+	   (list b-panel c-panel rb-panel))
+	  (set! error-msg
+		(lambda (txt)
+		  (send canvas-dc draw-text txt 10 10)))
+	  (set-scale-factor 25.0)
+	  (send zoom-factor set-selection 1)
+	  (send use-vdw-checkbox set-value #t)
+	  (send a-frame show #t))))
+    
+    (define offscreen-dc (make-object wx:memory-dc%))
+    (define offscreen-dc-width -1)
+    (define offscreen-dc-height -1)
+    
+    (define (update-session full-blown
+			    smooth
+			    canvas-width
+			    canvas-height
+			    canvas-dc
+			    atom-color
+			    select-pen)
+      (when (and smooth (not (and (= canvas-width offscreen-dc-width)
+				  (= canvas-height offscreen-dc-height))))
+	(let ([bm (make-object wx:bitmap% canvas-width canvas-height)])
+	  (send offscreen-dc select-object bm)
+	  (set! offscreen-dc-width canvas-width)
+	  (set! offscreen-dc-height canvas-height)))
+      (let ([draw-dc (if (and smooth (send offscreen-dc ok?)) offscreen-dc canvas-dc)])
+	(set! center-x (* 0.5 canvas-width))
+	(set! center-y (* 0.5 canvas-height))
+	(send draw-dc clear)
+	(if (or #t full-blown)
+	    (let ((DL ())
+		  (minus-half-radius (* -0.5 atom-drawing-radius)))
+	      (if draw-force-vectors (compute-forces))
+	      (if (< (length force-list) (length atom-list))
+		  (set! force-list
+			(map (lambda (atm)
+			       (vector 0.0 0.0 0.0))
+			     atom-list)))
+	      (set! DL (detailed-drawing-list))
+	      (map (lambda (z)
+		     (if (car z)
+			 (let ()  ;; for atoms, let's do both circles and forces
+			   (atom-color draw-dc (cadddr z))
+			   (send draw-dc draw-ellipse
+				 (+ (cadr z) center-x minus-half-radius)
+				 (+ (caddr z) center-y minus-half-radius)
+				 atom-drawing-radius atom-drawing-radius)
+			   (if draw-force-vectors
+			       (let ()
+				 (select-pen draw-dc 1)
+				 (send draw-dc draw-line
+				       (+ (cadr z) center-x)
+				       (+ (caddr z) center-y)
+				       (+ (cadr z) (cadr (cdddr z)) center-x)
+				       (+ (caddr z) (caddr (cdddr z)) center-y))
+				 (select-pen draw-dc 0))))
+			 (let ()
+			   (case (cadddr (cddr z))
+			     ((1) (select-pen draw-dc 0))
+			     ((2) (select-pen draw-dc 2))
+			     (else (select-pen draw-dc 3)))
+			   (send draw-dc draw-line
+				 (+ (cadr z) center-x)
+				 (+ (caddr z) center-y)
+				 (+ (cadddr z) center-x)
+				 (+ (cadddr (cdr z)) center-y))
+			   (select-pen draw-dc 0))))
+		   DL))
+	    (map (lambda (z)
+		   (send draw-dc draw-line
+			 (+ (car z) center-x)
+			 (+ (cadr z) center-y)
+			 (+ (caddr z) center-x)
+			 (+ (cadddr z) center-y)))
+		 (wireframe-drawing-list)))
+	(if smooth
+	    (send canvas-dc blit 0 0 canvas-width canvas-height offscreen-dc 0 0))))
+    
+    (make-object session%)))
+
+(define (ncad:go)
+  (invoke-unit/sig ncad@ mred:wx^ (mred : mred^)))
+
+
+
diff --git a/collects/mrdemo/phone.mre b/collects/mrdemo/phone.mre
new file mode 100644
index 0000000..45e47be
Binary files /dev/null and b/collects/mrdemo/phone.mre differ
diff --git a/collects/mrdemo/phone.ss b/collects/mrdemo/phone.ss
new file mode 100644
index 0000000..da4fced
--- /dev/null
+++ b/collects/mrdemo/phone.ss
@@ -0,0 +1,163 @@
+
+(define lookup-number
+  (let ([phonebook '(("Mr. Bumpy" "555-BUMP" "555-SNOT")
+		     ("Squishington" "555-SQSH" "555-BOWL")
+		     ("Miss Molly" "555-MOLL" "555-COMF"))])
+    (lambda (name home?)
+      (sleep 2) ; artificial database delay
+      (let loop ([pb phonebook])
+	(cond
+	 [(null? pb) #f]
+	 [(regexp-match name (caar pb))
+	  ((if home? cadar caddar) pb)]
+	 [else (loop (cdr pb))])))))
+
+(define a-frame 
+  (make-object mred:frame% 
+	       null ; No parent frame 
+	       "Phone Book")) ; The frame's title 
+
+(define a-panel 
+  (make-object mred:vertical-panel% 
+	       a-frame)) ; Panel is in a-frame 
+
+(define h-panel 
+  (make-object mred:horizontal-panel% 
+	       a-panel)) ; Panel is in a-frame 
+
+(define name-text  
+  (make-object mred:text%  
+	       h-panel  
+	       (lambda (self event) (refresh-number-info)) 
+	       "Name"  ; label
+	       ""))    ; initial value
+(define quit-button 
+  (make-object mred:button% 
+	       h-panel 
+	       (lambda (self event)  
+		 (send a-frame show #f)) 
+	       "Quit")) ; Button label
+
+(define number-selector 
+  (make-object mred:radio-box% 
+	       a-panel 
+	       (lambda (self event) (refresh-number-info)) 
+	       "" ; No label 
+	       -1 -1 -1 -1  ; Default position and size 
+	       (list "Home Number" "Office Number")))
+
+(define number-text 
+  (make-object mred:text% 
+	       a-panel 
+	       (lambda (self event) #f) ; No event-handling 
+	       "Number" 
+	       "(Unknown)"))
+(send number-text set-editable #f)
+
+;; First revision: unthreaded
+
+(define refresh-number-info 
+  (lambda () 
+    (let* ([name (send name-text get-value)] 
+	   [home? (zero? (send number-selector get-selection))] 
+	   [number (lookup-number name home?)] 
+	   [number-string (if number 
+			      number 
+			      "(Unknown)")]) 
+      (send number-text set-value number-string))))
+
+;; Second revision: threaded
+
+(define refresh-number-info
+  (let ([adj-cancel-sema (make-semaphore 1)]
+	[previous-cancel (box #f)])
+    (lambda ()
+      (let ([this-cancel (box #f)])
+	(semaphore-wait adj-cancel-sema)
+	(set-box! previous-cancel #t)
+	(set! previous-cancel this-cancel)
+	(semaphore-post adj-cancel-sema)
+	(thread
+	 (lambda ()
+	   (send number-text set-value "(Searching...)")
+	   (let* ([name (send name-text get-value)]
+		  [home? (zero? (send number-selector get-selection))]
+		  [number (lookup-number name home?)] ; May take a while...
+		  [number-string (if number
+				     number
+				     "(Unknown)")])
+	     (semaphore-wait adj-cancel-sema)
+	     (unless (unbox this-cancel)
+		     (send number-text set-value number-string))
+	     (semaphore-post adj-cancel-sema))))))))
+
+;; Make a class:
+
+(define pb-session%
+  (class null ()
+    (public
+      [refresh-number-info
+       (let ([adj-cancel-sema (make-semaphore 1)]
+	     [previous-cancel (box #f)])
+	 (lambda ()
+	   (let ([this-cancel (box #f)])
+	     (semaphore-wait adj-cancel-sema)
+	     (set-box! previous-cancel #t)
+	     (set! previous-cancel this-cancel)
+	     (semaphore-post adj-cancel-sema)
+	     (thread
+	      (lambda ()
+		(send number-text set-value "(Searching...)")
+		(let* ([name (send name-text get-value)]
+		       [home? (zero? (send number-selector get-selection))]
+		       [number (lookup-number name home?)] ; May take a while...
+		       [number-string (if number
+					  number
+					  "(Unknown)")])
+		  (semaphore-wait adj-cancel-sema)
+		  (unless (unbox this-cancel)
+			  (send number-text set-value number-string))
+		  (semaphore-post adj-cancel-sema)))))))])
+    (public
+      (a-frame (make-object mred:frame% null "Phonebook"))
+      (a-panel (make-object mred:vertical-panel% a-frame)))
+    (private
+      (h-panel (make-object mred:horizontal-panel% a-panel))
+      (name-text (make-object mred:text% h-panel
+			      (lambda (self event) (refresh-number-info))
+			      "Name" ""))
+      (quit-button (make-object mred:button% h-panel
+				(lambda (self event) (send a-frame show #f))
+				"Quit"))
+      (number-selector (make-object mred:radio-box% a-panel
+				    (lambda (self event) (refresh-number-info))
+				    "" -1 -1 -1 -1 (list "Home Number" "Office Number")))
+      (number-text (make-object mred:text% a-panel
+				(lambda (self event) #f)
+				"Number" "(Unknown)")))
+    (sequence
+      (send a-frame show #t)
+      (send number-text set-editable #f))))
+
+
+
+(define pb-counted-session%
+  (class pb-session% ()
+    (inherit a-frame a-panel) ; We need to access the panel object...
+    (rename [basic-refresh-number-info refresh-number-info]) ; and old refresh
+    (private [search-counter 0]) ; Counter value
+    (public
+      [refresh-number-info ; Increment the counter and call old refresh
+       (lambda ()
+         (set! search-counter (add1 search-counter))
+         (send counter-text set-value (number->string search-counter))
+         (basic-refresh-number-info))])
+    (sequence
+      (super-init))  ; Do base class initialization
+    (private
+     (counter-text (make-object mred:text% a-panel
+				(lambda (self event) #f)
+				"Number of Searches Started"
+				"0")))
+    (sequence
+     (send counter-text set-editable #f))))
diff --git a/collects/mrdemo/sig.ss b/collects/mrdemo/sig.ss
new file mode 100644
index 0000000..e248986
--- /dev/null
+++ b/collects/mrdemo/sig.ss
@@ -0,0 +1 @@
+(require-library "sig.ss" "system")
diff --git a/collects/mrdemo/toyproof.mre b/collects/mrdemo/toyproof.mre
new file mode 100644
index 0000000..2e9e9ce
Binary files /dev/null and b/collects/mrdemo/toyproof.mre differ
diff --git a/collects/mrdemo/toyproof.ss b/collects/mrdemo/toyproof.ss
new file mode 100644
index 0000000..785a7ed
--- /dev/null
+++ b/collects/mrdemo/toyproof.ss
@@ -0,0 +1,377 @@
+;; Toy proof checkers implemented with MrEd and units
+;; Kathi Fisler
+;; September 3, 1996
+
+;; This code demonstrates the combined use of MrEd and units to
+;; implement a collection of simple proof checkers.
+
+;; Proof Checker Architecture:
+;;
+;; A proof checker consists of two main components: a list of
+;; operations supported by the checker and the interface through which
+;; the user invokes the checker.  Each of these components is
+;; implemented as a unit in the code below.
+;;
+;; The "operations" unit, (signature prover-core^) provides a list
+;; containing the names of the operations, a list containing the
+;; operations corresponding to the names, and a default operation.
+;;
+;; The "interface" unit (signature interface^) is a compound unit with
+;; subunits corresponding to the various pieces of the interface.
+;; Subunits exist for how the user inputs data to the checker, how the
+;; checker displays results to the user, how the user selects from
+;; among the possible operations, how the user instructs the checker
+;; to check the current data against the selected operation, and how
+;; the user exits the checker.  The interface unit combines these
+;; subunits into a main interface and provides a function
+;; (create-interface) that can be invoked to create a checker with the
+;; specified interface components and the specified operations from
+;; the operations unit.
+
+;; The Collection of Checkers
+;;
+;; Each of the implemented checkers contains three objects into which
+;; the user can enter data and one object through which the checker
+;; displays results.  Two operations units are provided:
+;; proof-core-calculator@ and proof-core-tester@.  The former computes
+;; simple arithmetic functions over the three inputs and the latter
+;; tests boolean-valued relationships between the three inputs.  The
+;; checker displays the values returned by either type of operation.
+;;
+;; Two types of interfaces are possible: one in which the operations
+;; are selected through radio boxes and the other in which the
+;; operations are selected through menu options.
+;;
+;; Three checkers are defined explicitly at the end of the code:
+;; make-calculator/radio, make-checker/radio, and make-checker/menu,
+;; each taking the appropriate combination of the described interface
+;; and operations units.
+
+;;;;; The Implementation ;;;;;
+
+(require-library "trigger.ss")
+
+;;;;; Signature Definitions ;;;;;
+
+(define-signature prover-core^
+  (proof-rule-names proof-rule-checkers default-rule-checker))
+
+(define-signature num-entry-interface^
+  (create-num-entry-interface get-numbers))
+
+(define-signature result-display-interface^
+  (create-result-display-interface show-result))
+
+(define-signature rule-select-interface^
+  (create-rule-select-interface
+   current-proof-rule set-current-proof-rule))
+
+(define-signature compute-interface^
+  (create-compute-interface))
+
+(define-signature quit-interface^
+  (create-quit-interface))
+
+(define-signature main-interface^
+  (create-interface quit-prover))
+
+(define-signature interface^
+  ((open main-interface^)))
+
+;;;;; Compound Unit Definitions ;;;;;
+
+(define interface@
+  (lambda (numentry resdisplay ruleselect compute quit main)
+    (compound-unit/sig
+     (import (MRED : mred^) (CORE : prover-core^))
+     (link
+      (NUMENTRY : num-entry-interface^ (numentry MRED))
+      (RESDISPLAY : result-display-interface^ (resdisplay MRED))
+      (RULESELECT : rule-select-interface^ (ruleselect CORE MRED))
+      (COMPUTE : compute-interface^ (compute RESDISPLAY RULESELECT
+				      NUMENTRY MRED))
+      (QUIT : quit-interface^ (quit MAIN MRED))
+      (MAIN : main-interface^ (main NUMENTRY RESDISPLAY
+				    RULESELECT COMPUTE QUIT MRED))
+      )
+     (export (open MAIN)))))
+
+(define prover@
+  (lambda (core interface)
+    (compound-unit/sig
+     (import (MRED : mred^))
+     (link
+      (CORE : prover-core^ (core))
+      (INTERFACE : interface^ (interface MRED CORE)))
+     (export (open INTERFACE)))))
+
+;;;;; Primitive Unit Definitions ;;;;;
+
+;;;;;;;; Interface Units ;;;;;;;;
+
+(define main-interface-no-menus@
+  (unit/sig main-interface^
+    (import num-entry-interface^ result-display-interface^
+	    rule-select-interface^ compute-interface^
+	    quit-interface^ (mred : mred^))
+    (define outer-frame
+      (make-object mred:frame% `() "Toy Prover"))
+    (define v-panel
+      (make-object mred:vertical-panel% outer-frame))
+    (define upper-hpanel
+      (make-object mred:horizontal-panel% v-panel))
+    (define lower-hpanel
+      (make-object mred:horizontal-panel% v-panel))
+    (define create-interface
+      (lambda ()
+	(create-num-entry-interface upper-hpanel)
+	(create-result-display-interface lower-hpanel)
+	(create-compute-interface upper-hpanel)
+	(create-quit-interface upper-hpanel outer-frame)
+	(create-rule-select-interface lower-hpanel)
+	(send outer-frame show #t)))
+    (define quit-prover
+      (lambda ()
+	(send outer-frame show #f)))
+    ))
+
+(define main-interface-menus@
+  (unit/sig main-interface^
+    (import num-entry-interface^ result-display-interface^
+	    rule-select-interface^ compute-interface^
+	    quit-interface^ (mred : mred^))
+    (define myframe%
+      (class mred:standard-menus-frame% args
+	     (rename [super-make-menu-bar make-menu-bar])
+	     (public
+	      [make-menu-bar
+	       (lambda ()
+		 (let ([mb (super-make-menu-bar)])
+		   (create-rule-select-interface mb)
+		   mb))]
+	      [panel% mred:vertical-panel%]
+	      )
+	     (sequence (apply super-init args))))
+    (define outer-frame
+      (make-object myframe% null "Toy Prover"))
+    (define v-panel (ivar outer-frame panel))
+    (define upper-hpanel
+      (make-object mred:horizontal-panel% v-panel))
+    (define lower-hpanel
+      (make-object mred:horizontal-panel% v-panel))
+    (define create-interface
+      (lambda ()
+	(create-num-entry-interface upper-hpanel)
+	(create-result-display-interface lower-hpanel)
+	(create-compute-interface upper-hpanel)
+	(create-quit-interface upper-hpanel outer-frame)
+	(send outer-frame show #t)))
+    (define quit-prover
+      (lambda ()
+	(send outer-frame show #f)))
+    ))
+
+(define num-entry-interface-3text@
+  (unit/sig num-entry-interface^
+    (import (mred : mred^))
+
+    (define num1 (void))
+    (define num2 (void))
+    (define num3 (void))
+
+    (define create-num-entry-interface
+      (lambda (panel)
+	(set! num1
+	  (make-object mred:text% panel (lambda (self event) #f)
+		       "" ""))
+	(set! num2
+	  (make-object mred:text% panel (lambda (self event) #f)
+		       "" ""))
+	(set! num3
+	  (make-object mred:text% panel (lambda (self event) #f)
+		       "" ""))))
+    
+    (define get-numbers
+      (lambda () 
+	(map string->number
+	     (list (send num1 get-value) 
+		   (send num2 get-value)
+		   (send num3 get-value)))))
+    ))
+
+(define result-display-interface-text@
+  (unit/sig result-display-interface^
+    (import (mred : mred^))
+    
+    (define resdisplay (void))
+
+    (define create-result-display-interface
+      (lambda (panel)
+	(set! resdisplay
+	  (make-object mred:text% panel (lambda (self event) #f) "Result"))
+	))
+    
+    (define show-result
+      (lambda (res)
+	(send resdisplay set-value
+	      (cond ((string? res) res)
+		    ((number? res) (number->string res))
+		    ((boolean? res) (if res "True" "False"))
+		    (error "Argument of Unknown Type")))))
+    ))
+
+(define rule-select-interface-radio@
+  (unit/sig rule-select-interface^
+    (import prover-core^ (mred : mred^))
+    
+    (define current-proof-rule default-rule-checker)
+    
+    (define set-current-proof-rule
+      (lambda (rule)
+	(set! current-proof-rule rule)))
+    
+    (define create-rule-select-interface
+      (lambda (panel)
+	(make-object mred:radio-box%
+		     panel
+		     (lambda (self event)
+		       (set-current-proof-rule
+			(list-ref proof-rule-checkers
+				  (send self get-selection))))
+		     "" -1 -1 -1 -1
+		     proof-rule-names)))
+    ))
+
+(define rule-select-interface-menus@
+  (unit/sig rule-select-interface^
+	    (import prover-core^ (mred : mred^))
+	    (define current-proof-rule default-rule-checker)
+	    
+	    (define set-current-proof-rule
+	      (lambda (rule)
+		(set! current-proof-rule rule)))
+    
+	    (define create-rule-select-interface
+	      (lambda (mb)
+		(let ([rules-menu (make-object mred:menu%)])
+		  (map
+		   (lambda (name checker)
+		     (send rules-menu append-item name
+			   (lambda ()
+			     (set-current-proof-rule checker))))
+		   proof-rule-names
+		   proof-rule-checkers)
+		  (send mb append rules-menu "Rules"))))
+	    ))
+
+(define compute-interface-button@
+  (unit/sig compute-interface^
+    (import result-display-interface^ rule-select-interface^
+      num-entry-interface^ (mred : mred^))
+    (define create-compute-interface
+      (lambda (panel)
+	(make-object mred:button%
+		     panel
+		     (lambda (self event)
+		       (show-result 
+			(apply current-proof-rule (get-numbers))))
+		     "Apply Rule")))))
+
+(define quit-interface-button@
+  (unit/sig quit-interface^
+    (import main-interface^ (mred : mred^))
+    (define create-quit-interface
+      (lambda (panel outer-frame)
+	(make-object mred:button% 
+		     panel
+		     (lambda (self event) (quit-prover))
+		     "Quit")))))
+
+;;;;;;;; Prover Core Units ;;;;;;;;
+
+(define proof-core-calculator@
+  (unit/sig prover-core^
+    (import)
+    (define-struct proof-rule (name checker))
+
+    (define proof-rules
+      (list
+	(make-proof-rule "Add" +)
+	(make-proof-rule "Mult" *)
+	(make-proof-rule "Max" max)))
+
+    (define proof-rule-names (map proof-rule-name proof-rules))
+    (define proof-rule-checkers (map proof-rule-checker proof-rules))
+    (define default-rule-checker (car proof-rule-checkers))))
+
+(define proof-core-tester@
+  (unit/sig prover-core^
+    (import)
+    (define-struct proof-rule (name checker))
+    
+    (define square
+      (lambda (num)
+	(* num num)))
+    
+    (define proof-rules
+      (list
+       (make-proof-rule "Test Add"
+			(lambda (num-1 num-2 num-3)
+			  (= num-3 (+ num-1 num-2))))
+       (make-proof-rule "Test Mult"
+			(lambda (num-1 num-2 num-3)
+			  (= num-3 (* num-1 num-2))))
+       (make-proof-rule "Test Increasing"
+			(lambda (num-1 num-2 num-3)
+			  (and (< num-1 num-2)
+			       (< num-2 num-3))))
+       (make-proof-rule "Test Triangle"
+			(lambda (num-1 num-2 num-3)
+			  (= (square num-3)
+			     (+ (square num-1) (square num-2)))))
+	))
+
+    (define proof-rule-names (map proof-rule-name proof-rules))
+    (define proof-rule-checkers (map proof-rule-checker proof-rules))
+    (define default-rule-checker (car proof-rule-checkers))))
+
+;;;;; Creating Provers ;;;;;
+
+(define make-calculator/radio
+  (lambda ()
+    (invoke-open-unit/sig
+     (prover@ proof-core-calculator@
+	    (interface@ num-entry-interface-3text@
+		      result-display-interface-text@
+		      rule-select-interface-radio@
+		      compute-interface-button@
+		      quit-interface-button@ 
+		      main-interface-no-menus@))
+     #f (mred : mred^))
+    (create-interface)))
+
+(define make-checker/radio
+  (lambda ()
+    (invoke-open-unit/sig
+     (prover@ proof-core-tester@
+	    (interface@ num-entry-interface-3text@
+		      result-display-interface-text@
+		      rule-select-interface-radio@
+		      compute-interface-button@
+		      quit-interface-button@ 
+		      main-interface-no-menus@))
+     #f (mred : mred^))
+    (create-interface)))
+
+(define make-checker/menu
+  (lambda ()
+    (invoke-open-unit/sig
+     (prover@ proof-core-tester@
+	    (interface@ num-entry-interface-3text@
+		      result-display-interface-text@
+		      rule-select-interface-menus@
+		      compute-interface-button@
+		      quit-interface-button@ 
+		      main-interface-menus@))
+     #f (mred : mred^))
+    (create-interface)))
diff --git a/collects/mrdemo/turtles.mre b/collects/mrdemo/turtles.mre
new file mode 100644
index 0000000..223d64d
Binary files /dev/null and b/collects/mrdemo/turtles.mre differ
diff --git a/collects/mrdemo/turtles.ss b/collects/mrdemo/turtles.ss
new file mode 100644
index 0000000..47d8a27
--- /dev/null
+++ b/collects/mrdemo/turtles.ss
@@ -0,0 +1,5 @@
+
+(require-library "turtle.ss" "graphics")
+(require-library "turex.ss" "graphics")
+
+(turtles)
diff --git a/collects/mrspidey/Gui/Tframe.ss b/collects/mrspidey/Gui/Tframe.ss
new file mode 100644
index 0000000..fdcb46e
--- /dev/null
+++ b/collects/mrspidey/Gui/Tframe.ss
@@ -0,0 +1,343 @@
+;; Tframe.ss - creates MrSpidey frames
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+; Global variable to record the most-recently created frame
+(define tf (void))
+
+(define shake-it-repetitions 25)
+
+(define spidey:frame%
+  (class 
+    (mred:make-searchable-frame% mred:simple-menu-frame%)
+    (arg-main arg-filename summary-edit . init-locs)
+
+    (inherit show get-canvas ;; get-canvas%
+      make-menu create-status-line set-status-text
+      get-position get-size set-icon panel
+      set-title file-menu set-title-prefix
+      set-size)
+
+    ;; ----------
+
+    (rename
+      [super-on-close on-close]
+      [super-make-menu-bar make-menu-bar])
+
+    ;; ----------
+      
+    (public
+
+      [get-edit (lambda () program-edit)]
+      [auto-set-wrap #f]
+      [edit% flow-arrow:media-edit%]    
+      [get-canvas% (lambda () mred:wrapping-canvas%)]
+      [on-close
+        (lambda ignored
+          (send main on-frame-close filename)
+          (send this show #f)
+          (remq-callback-sdl-alg-changed! flush-type-cache)
+          (super-on-close))]
+
+      [set-show-mode
+        (lambda (which)
+          (pretty-debug-gui `(set-show-mode ,which))
+          (unless (eq? which canvas-show-mode)
+            (set! canvas-show-mode which)
+            (send summary-canvas stretchable-in-y (eq? which 'summary))
+            (send panel change-children
+              (lambda (ignore)
+                (filter
+                  (lambda (x) x)
+                  (list 
+                    (and (or (eq? which 'program) (eq? which 'both))
+                      program-canvas)
+                    (and (or (eq? which 'summary) (eq? which 'both))
+                      summary-canvas)))))))]
+
+      ;; ---------- Set up the menus
+      [file-menu:new #f]
+      [file-menu:open #f]
+      [file-menu:revert #f]
+      [file-menu:save #f]
+      [file-menu:save-as #f]
+      ;;[file-menu:print #f]
+      ;;[file-menu:between-print-and-close (lambda args (void))]
+      [file-menu:between-save-and-print (lambda args (void))]
+
+      [edit-menu:undo #f]   
+      [edit-menu:redo #f]
+      [edit-menu:cut #f]
+      [edit-menu:paste #f]
+      [edit-menu:delete #f]
+      ;;[edit-menu:find #f]
+      [edit-menu:replace #f]
+      [edit-menu:between-replace-and-preferences (lambda args (void))]
+
+      [file-menu:close on-close]
+      [file-menu:between-open-and-save
+        (lambda (file-menu)
+          (send file-menu
+            append-item
+            "Open ..."
+            (lambda () (send main open-analyzed-file-choice)))
+          (send file-menu
+            append-item
+            "Open All"
+            (lambda () (wrap-busy-cursor (lambda () (send main open-all #t)))))
+          (send file-menu
+            append-item
+            "Load All"
+            (lambda () (wrap-busy-cursor (lambda () (send main open-all #f)))))
+          (send file-menu
+            append-item
+            "Reanalyze"
+            (lambda () (wrap-busy-cursor (lambda () (send main reanalyze)))))
+          (send file-menu append-separator))]
+      [file-menu:between-close-and-quit
+        (lambda (file-menu)
+          (send file-menu
+            append-item
+            "Close All"
+            ;;(format "Close ~a" st:name)
+            (lambda () 
+              (wrap-busy-cursor 
+                (lambda () 
+                  (send main close-all-frames))))))]
+
+      [flush-type-cache (lambda () (void))]
+
+      [calc-show
+        (lambda ()
+          (set-show-mode 'program)
+          (when (and 
+                  summary-canvas
+                  ;; Show summary only if some real content
+                  (> (send summary-edit last-line) 3))
+            ;;(printf "Summary-edit size ~s~n" (send summary-edit last-line))
+            (set-show-mode 'both)))]
+
+      [make-menu-bar
+        (lambda ()
+          (let ([menu-bar (super-make-menu-bar)])
+            (let ([show-menu (make-menu)])
+              (send menu-bar append show-menu "Show")
+              (set! init-show-menu
+                (lambda ()
+                  (send show-menu
+                    append-check-set
+                    (list 
+                      (cons "Program Only" 'program)
+                      (cons "Summary Only" 'summary)
+                      (cons "Both"         'both))
+                    set-show-mode
+                    (case canvas-show-mode
+                      [(program) 0]
+                      [(summary) 1]
+                      [(both) 2]
+                      [else 0]))))
+                          
+              '(send show-menu append-separator)
+              '(send show-menu
+                 append-check-set
+                 (map (lambda (mode) (cons (mode-name mode) mode))
+                   modes)
+                 set-display-mode))
+
+            (let ([clear-menu (make-menu)])
+              (send menu-bar append clear-menu "Clear")
+              (send* clear-menu
+                (append-item 
+                  "Arrows+Types" 
+                  (lambda () 
+                    (wrap-busy-cursor 
+                      (lambda () 
+                        (send* program-edit 
+                          (delete-arrows)
+                          (delete-types))))
+                    "Removes both types and arrows from the window"))
+                (append-item
+                  "Arrows" 
+                  (lambda () 
+                    (wrap-busy-cursor 
+                      (lambda () 
+                        (send program-edit delete-arrows))))
+                  "Removes all arrows from the window")
+                (append-item
+                  "Types" 
+                  (lambda () 
+                    (wrap-busy-cursor 
+                      (lambda () 
+                        (send program-edit delete-types))))
+                  "Removes all types from the window"))
+              (unless st:restricted
+                (send clear-menu append-item
+                  "Shake Buffer" 
+                  (lambda () (for i 0 shake-it-repetitions (shake-it)))
+                  "Sends random inputs to buffer")
+                (send clear-menu append-item
+                  "Rewrite Buffer" 
+                  (lambda () 
+                    (wrap-busy-cursor 
+                      (lambda () 
+                        (set-display-mode display-mode))))
+                  "Removes all types and arrows from the window")))    
+
+            (let ([filter-menu (make-menu)])
+              (send menu-bar append filter-menu "Filter")
+              (send filter-menu
+                append-check-set
+                (analysis-get-filters)
+                analysis-set-arrow-filter!)
+              (analysis-set-arrow-filter! #f))
+
+            
+
+            menu-bar))]
+
+      [init-show-menu #f]
+      )
+    
+    ;; ----------
+
+    (public
+      [main arg-main]                   ; parent containing the global state
+      program-canvas
+      program-edit
+      summary-canvas                    ; or #f if no summary
+      [filename arg-filename]
+
+      [canvas-show-mode 'none]          ; 'program, 'summary, or 'both
+      [display-mode  (car modes)]       ; which display mode
+
+      [set-display-mode
+        (lambda (which)
+          (set! display-mode which)
+          (pretty-debug-gui `(set-display-mode ,display-mode ,filename))
+          ;; Call main to create a new edit buffer,
+          ;; and to load and annotate file
+          (set! program-edit 
+            (send main annotated-edit display-mode filename program-canvas))
+          (send program-canvas set-media program-edit))]
+
+      [focus-def
+        (lambda (pos)
+          (unless (memq display-mode '(program both))
+            (set-show-mode 'both))
+          (let* ( [real-pos (send program-edit real-start-position pos)]
+                  [end (mred:scheme-forward-match 
+                         program-edit real-pos 
+                         (send program-edit last-position))])
+            (thread
+              (lambda ()
+                (sleep)
+                (send program-canvas set-focus)
+                (send program-edit
+                  set-position-bias-scroll -1 real-pos end)))))]
+
+      [shake-it
+        (lambda ()
+          (send program-edit shake-it))]
+
+      ;; ----------
+
+      )
+	
+    (sequence 
+      (pretty-debug-gui
+        `(Tframe ,arg-main ,arg-filename ,summary-edit ,@init-locs))
+      (match init-locs
+        [(w h x y) 
+          (pretty-debug-gui `(send this set-size ,(+ x 15) ,(+ y 15) ,w ,h))
+          (set-size x y w h)]
+        [() (void)])
+      (pretty-debug-gui `(Tframe super-init))
+      (let ([t (format "~a: ~a" 
+                 st:name (file-name-from-path arg-filename))]) 
+        (super-init t)
+        (pretty-debug-gui `(Tframe super-init done))
+        (set-title-prefix t)))
+
+    	
+    ;; ---------------------------------------------------------
+
+    (sequence
+      (set! flush-type-cache
+        (lambda ()
+          (pretty-debug-gui '(Tframe flush-type-cache))
+          (unless (void? program-edit) 
+            (send program-edit flush-type-cache))))
+
+      (add-callback-sdl-alg-changed! flush-type-cache)
+
+      (pretty-debug-gui
+        `(Tframe ,arg-main ,arg-filename ,summary-edit ,@init-locs))
+      (set! tf this)
+
+      ;; ------------------------------------------------------------
+      ;; build the canvases
+
+      (pretty-debug-gui '(setting summary-canvas))
+      (set! summary-canvas
+        (and summary-edit
+          (let ([c 
+                  ;(make-object (get-canvas%) panel)
+                  (make-object (class-asi mred:one-line-canvas%
+                                 (public
+                                   [lines 5]
+                                   [style-flags 0]))
+                    panel) 
+                  ])
+            ;;(send c set-lines 2)
+            (send c set-media summary-edit)
+            c)))
+      (assert (is-a? summary-canvas mred:connections-media-canvas%))
+      (pretty-debug-gui '(setting program-canvas))
+      (set! program-canvas (get-canvas))
+      (set-display-mode (car modes))
+      (pretty-debug-gui '(done setting canvases))
+
+      ;; ------------------------------------------------------------
+      ;; install the icon
+      
+      '(let ([icon (make-object wx:icon% 
+                     (build-absolute-path 
+                       (collection-path "mrspidey") ; MATTHEW: got rid of plt-home
+                       "icon.gif")
+                     wx:const-bitmap-type-gif
+                     )])
+         (when (send icon ok?) (set-icon icon)))
+
+      ;; ------------------------------------------------------------
+      ;; status help line 
+
+      ;;(unless (eq? mred:platform 'macintosh)
+      ;;  (create-status-line))
+
+      ;;(set-status-text 
+      ;; "Mouse: Left-type/parents  Midde-Ancestors  Right-Close")
+
+      ;; ------------------------------------------------------------
+
+      ;;(set-display-mode display-mode)
+      (calc-show)
+      (init-show-menu)
+      (show #t)
+      
+      )))
+
+
diff --git a/collects/mrspidey/Gui/annotat.ss b/collects/mrspidey/Gui/annotat.ss
new file mode 100644
index 0000000..3aaeae1
--- /dev/null
+++ b/collects/mrspidey/Gui/annotat.ss
@@ -0,0 +1,1073 @@
+; annotat.ss
+; Defines flow-arrow:media-edit%, type-annotation% and flow-arrow%
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; Constants concerning positioning
+;; Global so easy to modify
+       
+(define arrow-start-dx   2)
+(define arrow-start-dy   12)
+(define arrow-end-dx     2)
+(define arrow-end-dy     12)
+(define arrow-delta     7)
+
+(define jump-start-dx   -15)
+(define jump-start-dy   25)
+(define jump-end-dx     -25)
+(define jump-end-dy     25)
+
+(define offset-menu-exp-y  20)
+(define offset-menu-snip-y 25)
+
+(define offsets-load-menu-src-known  (cons 0 18))
+(define offsets-load-menu-dest-known (cons 0 18))
+(define offsets-load-menu-src-jump   (cons -25 35))
+(define offsets-load-menu-dest-jump  (cons -25 35))
+
+(define SELECT-SHOW-VALUE-SET    0)
+(define SELECT-CLOSE-VALUE-SET   1)
+(define SELECT-PARENTS      2)
+(define SELECT-ANCESTORS    3)
+(define SELECT-PATH-SOURCE  4)
+(define SELECT-CHILDREN     5)
+(define SELECT-DESCENDANTS  6)
+(define SELECT-COPY-VALUE-SET    7)
+(define SELECT-CLOSE-MENU   8)
+(define SELECT-RECOMPUTE-VALUE-SET   11)
+
+(define LOAD-NONLOCAL-FILE  9)
+(define ZOOM-TO-FILE  10)
+
+;; ------------------------------------------------------------
+
+(define highlight
+  (lambda (edit src-pos)
+    ;;(pretty-debug-gui `(highlight ,src-pos))
+    (let* ([src-end (send edit match-paren-forward src-pos)])
+      ;;(send edit set-position src-pos src-end)
+      (send (send edit get-frame) show #t)
+      (send edit relocate-set-position src-pos)
+      (send edit relocate-flash-on src-pos src-end)
+)))
+
+;; ------------------------------------------------------------
+;; The brushes, pens for drawing arrows
+
+(define arrow-brush.pen
+  (cons
+   (make-object wx:brush% (get-resource-maybe "arrow-color" "BLUE")
+                wx:const-solid)
+   (make-object wx:pen% (get-resource-maybe "arrow-color" "BLUE") 
+                1 wx:const-solid)))
+
+(define nosrc-arrow-brush.pen 
+  (cons
+   (make-object wx:brush% (get-resource-maybe "nosource-arrow-color" "RED") 
+                wx:const-solid)
+   (make-object wx:pen% (get-resource-maybe "nosource-arrow-color" "RED") 
+                1 wx:const-solid)))
+
+(define nodest-arrow-brush.pen
+  (cons
+   (make-object wx:brush% (get-resource-maybe "nodest-arrow-color" "RED") 
+                wx:const-solid)  
+   (make-object wx:pen% (get-resource-maybe "nodest-arrow-color" "RED") 
+                1 wx:const-solid)))
+
+;; ------------------------------------------------------------
+
+(define flow-report-on #t)
+
+(define (generic-flow-report msg)
+  (when flow-report-on
+    (wx:message-box 
+      msg "Error"
+      (bitwise-ior wx:const-ok wx:const-icon-exclamation))))
+
+(define (generic-flow-report-filter msg)
+  (generic-flow-report
+    (format "~a~a!" 
+      msg
+      (if (analysis-filter-on?)
+        (format " with values matching filter '~a'" (analysis-filter-on?))
+        ""))))
+
+(define (report-no-parents)
+  (generic-flow-report-filter "No parents"))
+
+(define (report-no-children)
+  (generic-flow-report-filter "No children"))
+
+(define (report-no-ancestors)
+  (generic-flow-report-filter "No ancestors"))
+
+(define (report-no-descendants)
+  (generic-flow-report-filter "No descendants"))
+
+(define (report-type-does-not-contain-filter)
+  (generic-flow-report 
+    (if (analysis-filter-on?)
+      (format "Expression has no values matching filter '~a'!"  
+        (analysis-filter-on?))
+      "Expression has no values!")))
+
+(define (report-no-path-to-source)
+  (generic-flow-report 
+    (if (analysis-filter-on?)
+      (format "No path to source for values matching filter '~a'!"  
+        (analysis-filter-on?))
+      "No path to source!")))
+
+(define lookup-ftype
+  (lambda (ftype)
+    (pretty-debug-gui `(lookup-ftype ,(FlowType->pretty ftype)))
+    (assert (FlowType? ftype) 'lookup-ftype ftype)
+    (let ([r (FlowType-type-annotation ftype)])
+      (pretty-debug-gui `(lookup-ftype-returning ,r))
+      (assert r 'lookup-ftype 'r= r ftype)
+      r)))
+
+;; ======================================================================
+;; Edit class with flow arrows
+;; sets mode to scheme mode
+
+(define wx:const-break-special 8)
+
+(define flow-arrow:media-edit%
+  (class arrow:media-edit% (margin arg-main arg-canvas)
+    (inherit 
+      edit-sequence last-position change-style 
+      find-wordbreak set-mode set-wordbreak-map
+      relocate-change-style
+      real-start-position
+      last-line position-line line-start-position frame-pos->source-pos
+      draw-arrows add-arrow delete-arrow
+      margin-length
+      get-keymap get-frame relocate-set-position
+      get-start-position get-end-position)
+
+    (public
+
+      main
+      canvas
+
+      [list-type-annotations '()]
+      [list-check-annotations '()]
+
+      ;; ----------
+      ;; dynamic allocation of jump positions
+
+      [vec-free-jump-posns '()]
+      [jump-posn-free?
+        (lambda (i)
+          (and 
+            (>= i 0) 
+            (< i (vector-length vec-free-jump-posns))
+            (vector-ref vec-free-jump-posns i)))]
+      [alloc-jump-posn
+        ;; input and output in terms of relocate positions
+        ;; not absolute positions
+        (lambda (posn)
+          (let ([line (position-line (real-start-position posn))])
+            (unless (vector? vec-free-jump-posns)
+              (set! vec-free-jump-posns (make-vector (last-line) #t)))
+            (let* ([free-line
+                     (recur loop ([i 0])
+                       (cond
+                         [(= i (vector-length vec-free-jump-posns)) 
+                           (mrspidey:error "Out of jump points")]
+                         [(jump-posn-free? (+ line i)) (+ line i)]
+                         [(jump-posn-free? (- line i)) (- line i)]
+                         [else (loop (add1 i))]))]
+                    [_ (vector-set! vec-free-jump-posns free-line #f)]
+                    [start (line-start-position free-line)]
+                    [src (frame-pos->source-pos (+ margin-length start))])
+              (pretty-debug-gui 
+                `(alloc-jump-posn ,posn ,line ,free-line ,start ,src))
+              (values
+                src
+                (lambda ()
+                  (assert (not (vector-ref vec-free-jump-posns free-line)) 
+                    'free-jump-posn free-line)
+                  (vector-set! vec-free-jump-posns free-line #t))))))]
+
+      ;; ----------
+
+      [add-flow-arrow-part
+        (lambda ( src-posn  src-clickback 
+                  dest-posn dest-clickback
+                  brush.pen )
+          (pretty-debug-gui 
+            `(add-flow-arrow-part ,src-posn ,dest-posn))
+          (assert 
+            (and 
+              (or (number? src-posn) (eq? src-posn 'jump))
+              (or (number? dest-posn) (eq? dest-posn 'jump))
+              (or (number? src-posn) (number? dest-posn)))
+            'add-flow-arrow-part
+            src-posn dest-posn)
+          (let*-vals
+            ([(src-posn free-src start-dx start-dy)
+               (if (number? src-posn)
+                 (values 
+                   src-posn (lambda () (void))
+                   arrow-start-dx arrow-start-dy)
+                 (let*-vals ([(p free) (alloc-jump-posn dest-posn)])
+                   (values 
+                     p free
+                     jump-start-dx jump-start-dy)))]
+              [(dest-posn free-dest end-dx end-dy)
+                (if (number? dest-posn)
+                  (values 
+                    dest-posn (lambda () (void))
+                    arrow-end-dx arrow-end-dy)
+                  (let*-vals ([(p free) (alloc-jump-posn src-posn)])
+                    (values 
+                      p free
+                      jump-end-dx jump-end-dy)))]
+              [arrow 
+                (add-arrow
+                  src-posn start-dx start-dy
+                  dest-posn end-dx end-dy
+                  arrow-delta 
+                  (car brush.pen)
+                  (cdr brush.pen)
+                  (dest-clickback dest-posn)
+                  (src-clickback src-posn))])
+            (lambda () (free-src) (free-dest) (delete-arrow arrow))))]
+
+      ;; ----- shake it
+      [shake-it
+        (lambda ()
+          (fluid-let ([flow-report-on #f])
+
+            (let* ([n (random (length list-type-annotations))]
+                    [ta (nth list-type-annotations n)])
+              (printf "(send ta show-type-refresh)~n")
+              (send ta show-type-refresh)
+
+              (printf "(send ta copy-type-to-clipboard)~n")
+              (send ta copy-type-to-clipboard)
+
+              (printf "(send ta delete-type-refresh)~n")
+              (send ta delete-type-refresh)
+
+              (printf "(send ta parents-refresh)~n")
+              (send ta parents-refresh)
+              (delete-arrows)
+
+              (printf "(send ta ancestors-refresh)~n")
+              (send ta ancestors-refresh)
+              (delete-arrows)
+
+              (printf "(send ta shortest-path-source-refresh)~n")
+              (send ta shortest-path-source-refresh)
+              (delete-arrows)
+
+              (printf "(send ta children-refresh)~n")
+              (send ta children-refresh)
+              (delete-arrows)
+
+              (printf "(send ta descendants-refresh)~n")
+              (send ta descendants-refresh)
+              (delete-arrows))))]
+
+      [send-ftype
+        (lambda (ftype method . args)
+          (pretty-debug-gui `(send-ftype ,(FlowType->pretty ftype)))
+          (assert (symbol? method) 'send-ftype ftype method args)
+          (apply (uq-ivar (lookup-ftype ftype) method) args))]
+
+      [flush-type-cache
+        (lambda ()
+          (for-each 
+            (lambda (obj) (send obj flush-type))
+            list-type-annotations))]
+
+      [delete-types
+        (lambda ()
+          (edit-sequence
+            (lambda ()
+              (for-each
+                (lambda (obj) (send obj delete-type))
+                list-type-annotations))))]
+
+      [delete-arrows
+        (lambda ()
+          (send main delete-arrows))]
+
+      [add-type-annotation
+        (match-lambda
+          [($ type-annotation start end-first finish ftype)
+            '(pretty-debug-gui `(type-annotation 
+                                  ,(zodiac:location-offset start)
+                                  ,(zodiac:location-offset end-first)
+                                  ,(zodiac:location-offset finish)))
+            (let ([obj (make-object type-annotation% 
+                         this
+                         (zodiac:location-offset start)
+                         (zodiac:location-offset end-first)
+                         (add1 (zodiac:location-offset finish))
+                         ftype)])
+              (set-FlowType-type-annotation! ftype obj)
+              (set! list-type-annotations (cons obj list-type-annotations)))])]
+
+      [highlight
+        (lambda (start-pos name delta)
+          (cond
+            [(string=? name "(")
+              (let* ( [real-start (real-start-position start-pos)]
+                      [rparen (mred:scheme-forward-match 
+                                this real-start (last-position))])
+                (change-style delta real-start (add1 real-start))
+                (if (number? rparen)
+                  (change-style delta (sub1 rparen) rparen)
+                  (printf "Can't match paren from ~s ~s~n" start-pos rparen)))]
+            [else
+              (let* ([endbox (box (real-start-position start-pos))]
+                      [_ (find-wordbreak '() endbox wx:const-break-special)]
+                      [startbox (box (unbox endbox))]
+                      [_ (find-wordbreak startbox '() wx:const-break-special)])
+                '(pretty-debug-gui `(highlight start-pos ,start-pos endbox ,endbox
+                                      startbox ,startbox))
+                (change-style delta (unbox startbox) (unbox endbox)))]))]
+
+      [add-check-annotation
+        (match-lambda
+          [(and annotation ($ check-annotation start name num))
+            (set! list-check-annotations 
+              (cons annotation list-check-annotations))
+            (highlight (zodiac:location-offset start) name check-delta)])]
+
+      [add-uncheck-annotation
+        (match-lambda
+          [($ uncheck-annotation start name)
+            (highlight (zodiac:location-offset start) name uncheck-delta)])]
+
+      [next-check-annotation
+        (lambda ()
+          (next-check-annotation-list
+            (get-end-position) < list-check-annotations 0))]
+
+      [prev-check-annotation
+        (lambda ()
+          (next-check-annotation-list 
+            (get-start-position) > (reverse list-check-annotations) 
+            (last-position)))]
+
+      [next-check-annotation-list
+        (lambda (start cmp list-annotations wrap)
+          ;(pretty-print `(start ,start cmp ,cmp wrap ,wrap))
+          (or
+            (ormap
+              (match-lambda
+                [($ check-annotation start-ann)
+                  ;(pretty-print `(loop start ,start start-ann ,(zodiac:location-offset start-ann) ,(real-start-position (zodiac:location-offset start-ann))))
+                  (if (cmp start 
+                        (real-start-position
+                          (zodiac:location-offset start-ann)))
+                    ;; after current start
+                    (begin
+                      (relocate-set-position
+                        (zodiac:location-offset start-ann))
+                      #t)
+                    #f)])
+              list-annotations)
+            (if wrap
+              (next-check-annotation-list wrap cmp list-annotations #f)
+              (wx:bell))))]
+      )
+
+    (sequence
+      (set! main arg-main)
+      (set! canvas arg-canvas)
+      (super-init margin)
+      (let ([wb (make-object wx:media-wordbreak-map%)])
+        (for i 0 256
+             (unless (or (char-whitespace? (integer->char i))
+                         (memv (integer->char i) '(#\( #\) #\;)))
+               (send wb set-map i
+                     (+ (send wb get-map i) wx:const-break-special))))
+        (set-wordbreak-map wb))
+      ;;(set-mode (make-object mred:scheme-mode%))
+      (let ([keymap (get-keymap)])
+        (send keymap add-key-function 
+          "next-check-annotation"
+          (lambda (edit event)
+            (send edit next-check-annotation)))
+        (send keymap map-function "tab" "next-check-annotation")
+
+        (send keymap add-key-function 
+          "prev-check-annotation"
+          (lambda (edit event)
+            (send edit prev-check-annotation)))
+        (send keymap map-function "s:tab" "prev-check-annotation")
+        (send keymap map-function "a:tab" "prev-check-annotation"))
+
+      )))
+
+;; ------------------------------------------------------------
+;; A hyperlink object
+
+(define cur-he #f)
+(define te #f)
+
+(define type-annotation% 
+  (class null (arg-edit start-arg end-first finish-arg ftype-arg)
+    (public
+
+      edit             ;; flow-arrow:media-edit%
+      start-pos 
+      type-pos
+      ftype
+
+      [type #f]
+      [type-snip #f]
+      [src->arrows '()]  ;; Maps ftype of source to the arrow
+      [dest->arrows '()] ;; ditto
+
+      ;; ----- communication with arrows
+      [add-source-arrow
+       (lambda (src arrow)
+         (set! src->arrows (cons (cons src arrow) src->arrows)))]
+      [add-dest-arrow
+       (lambda (dest arrow)
+         (set! dest->arrows (cons (cons dest arrow) dest->arrows)))]
+
+      [remove-source-arrow
+       (lambda (arrow)
+         (set! src->arrows 
+             (filter-map
+              (lambda (src.arrow)
+                (if (eq? (cdr src.arrow) arrow) #f src.arrow))
+              src->arrows)))]
+      [remove-dest-arrow
+       (lambda (arrow)
+         (set! dest->arrows 
+             (filter-map
+              (lambda (dest.arrow)
+                (if (eq? (cdr dest.arrow) arrow) #f dest.arrow))
+              dest->arrows)))]
+      [remove-arrows
+        (for-each
+          (lambda (arrow) (send arrow delete))
+          (append (map cdr src->arrows) (map cdr dest->arrows)))]
+
+      [file-visable?
+        (lambda (filename)
+          (send (ivar edit main) filename->frame filename))]
+
+
+      ;; ----- Arrows
+      [add-flow-arrow
+       (lambda (src dest)
+         (pretty-debug-gui
+           `(type-annotation%:add-flow-arrow
+              ,(FlowType->pretty src) ,(FlowType->pretty dest)))
+         (send (ivar edit main) add-flow-arrow src dest))]
+
+      ;; ------ Parents, ancestors
+      [shortest-path-source-refresh
+       (lambda ()
+         ;; Show shortest path to a source
+         (let ([path (analysis-shortest-path ftype file-visable?)])
+           ;; Returns list of ancestor Tvar-nums, last element is ()
+           (cond
+             [(eq? path #f)
+               (report-type-does-not-contain-filter)]
+             [(null? path)
+               (report-no-path-to-source)]
+             [else
+               (send edit edit-sequence
+                 (lambda ()
+                   (show-path path)
+                   (send (ivar edit main) draw-arrows)))])))]
+      [show-path
+       (lambda (path)
+         (unless (null? path)
+           (let ([parent (car path)])
+             (unless (null? parent)
+               (add-flow-arrow parent ftype)
+               (send edit send-ftype parent 'show-path (cdr path))))))]
+
+      [calc-parents
+       (lambda ()
+         (analysis-parents ftype  file-visable?))]
+
+      [add-parent-arrows
+       (lambda ()
+         (for-each (lambda (p) (add-flow-arrow p ftype)) (calc-parents)))]
+
+      [parents-refresh
+       (lambda ()
+         ;; (pretty-print `(parents-refresh debugging ,debugging))
+         (pretty-debug-gui `(parents-refresh ,ftype ,type-snip))
+         (if (null? (calc-parents))
+             (report-no-parents)
+             (send edit edit-sequence
+                   (lambda ()
+                     (add-parent-arrows)
+                     (send (ivar edit main) draw-arrows)))))]
+
+      [ancestors-refresh
+       (lambda ()
+         (let ([arrows (analysis-ancestors ftype file-visable?)])
+           (if (null? arrows)
+             (report-no-ancestors)
+             (send edit edit-sequence
+               (lambda ()
+                 (for-each 
+                   (lambda (arrow) (apply add-flow-arrow arrow))
+                   arrows)
+                 (send (ivar edit main) draw-arrows))))))]
+
+      ;; ------ Children, descendants
+
+      [calc-children
+       (lambda () (analysis-children ftype file-visable?))]
+
+      [add-child-arrows
+       (lambda ()
+         (for-each (lambda (p) (add-flow-arrow ftype p)) (calc-children)))]
+
+      [children-refresh
+       (lambda ()
+         (pretty-debug-gui `(children ,ftype ,type-snip))
+         (if (null? (calc-children))
+             (report-no-children)
+             (send edit edit-sequence
+                   (lambda ()
+                     (add-child-arrows)
+                     (send (ivar edit main) draw-arrows)))))]
+
+      [descendants-refresh
+       (lambda ()
+         (let ([arrows (analysis-descendants ftype file-visable?)])
+           (if (null? arrows)
+             (report-no-descendants)
+             (send edit edit-sequence
+               (lambda ()
+                 (for-each 
+                   (lambda (arrow) (apply add-flow-arrow arrow))
+                   arrows)
+                 (send (ivar edit main) draw-arrows))))))]
+
+      ;; ------ Type stuff
+
+      [flush-type (lambda () (set! type #f))]
+      [calc-type
+       (lambda ()
+         (unless type
+             (assert (FlowType? ftype) 'type-annotation% ftype)
+             (set! type (analysis-callback ftype)))
+         type)]
+     
+      ;; ------ This snip stuff
+      [delete-type-refresh
+       (lambda ()
+         (when type-snip
+           (send edit edit-sequence delete-type)))]
+      [delete-type
+       (lambda ()
+         (when type-snip
+           (send edit relocate-delete-snip type-pos)
+           (set! type-snip #f)
+
+           ))]
+      [arrow-zoom (lambda () (highlight))]
+      [current-focus (lambda () (highlight))]
+      [highlight
+       (lambda () 
+         (set! te edit)
+         (let* ( [frame (send edit get-frame)]
+                 [frame (send (ivar edit main) filename->frame
+                          (send edit get-filename))])
+           (assert (is-a? frame wx:frame%) 'highlight frame)
+           (send frame show #t)
+           (send edit relocate-set-position start-pos)
+           (send edit relocate-flash-on start-pos type-pos #f #t 50000)))]
+
+      [get-start-pos  (lambda () start-pos)]
+      [get-type-pos (lambda () type-pos)]
+
+      [move-before-snip
+       (lambda ()
+         (pretty-debug-gui `(move-before-snip))
+         (send edit relocate-set-position start-pos)
+         (send edit set-caret-owner '()))]
+
+      [show-type
+       (lambda ()
+         (unless type-snip
+             
+           (let* ([type (calc-type)]
+                   [_ (set! type-snip (make-object mred:media-snip%))]
+                   [snip-edit (make-object mred:searching-edit%)]
+                   [_ (send type-snip set-media snip-edit)])
+
+             (dynamic-wind
+              (lambda ()
+                (send snip-edit begin-edit-sequence))
+              (lambda ()
+                ;; put type in the box
+                (send snip-edit insert type) 
+                ;; delete newline
+                (send snip-edit delete)
+                ;; set style
+                (send snip-edit change-style base-delta 
+                      0 (string-length type))
+                (send snip-edit change-style type-delta 0 (string-length type))
+                ;; add clickback
+                (send snip-edit set-clickback 
+                      0 (string-length type)
+                      (lambda ignore
+                        (popup-type/arrow-menu type-pos offset-menu-snip-y))
+                      '()
+                      #t))
+              (lambda ()
+                (send snip-edit end-edit-sequence)
+                (send snip-edit lock #t))))
+                        
+           (send edit edit-sequence
+                 (lambda ()
+                   (send edit relocate-insert-snip type-snip type-pos)
+                   (send edit relocate-change-style normal-delta 
+                         type-pos (add1 type-pos))))))]
+
+      [show-type-refresh
+       (lambda ()
+         (send edit edit-sequence
+               (lambda ()
+                 (show-type)
+                 ;;(highlight)
+                 )))]
+
+      [copy-type-to-clipboard
+       (lambda ()
+         (let* ([snip-edit (send type-snip get-this-media)])
+           (send snip-edit copy #f 0 0 (send snip-edit last-position))))]
+
+      ;; ---------- Making the popup menus
+      [popup-type/arrow-menu
+        (lambda (where offset-menu)
+          ;; where is source text position for menu
+          (let ([menu (make-object wx:menu% '() menu-callback)]
+                 [xb (box 0)]
+                 [yb (box 0)])
+            (if type-snip
+              (send menu append
+                SELECT-CLOSE-VALUE-SET
+                "Close Value Set"
+                "Close this value set invariant box")
+              (send menu append
+                SELECT-SHOW-VALUE-SET "Show Value Set"
+                "Show the expressions value set invariant"))
+            (send* menu
+              (append-separator)
+              (append SELECT-PARENTS "Parents"
+                "Show the immediate sources of this type")
+              (append SELECT-ANCESTORS "Ancestors"
+                "Show all sources of this type")
+              (append SELECT-PATH-SOURCE "Path to Source"
+                "Show shortest path to a source constructor expression")
+              (append-separator)
+              (append SELECT-CHILDREN "Children"
+                "Show the immediate expressions to which this type may flow")
+              (append SELECT-DESCENDANTS "Descendants"
+                "Show all expressions to which this type may flow")
+              (append-separator))
+            (when type-snip
+              (send menu append
+                SELECT-COPY-VALUE-SET
+                "Copy Value Set" 
+                "Copy the value set invariant to the clipboard")
+              (send menu append
+                SELECT-RECOMPUTE-VALUE-SET
+                "Recompute Value Set" 
+                "Recompute the expressions value set invariant"))
+            (send menu append SELECT-CLOSE-MENU "Close Menu")    
+       
+            ;; Get global location of expr
+            (send edit position-location 
+              (send edit real-start-position where)
+              xb yb)
+            (pretty-debug-gui 
+              `(source-pos ,where 
+                 frame-pos ,(send edit real-start-position where)))
+
+            (pretty-debug-gui `(position-location returns ,xb ,yb))
+            ;; Convert to local location
+            (send edit local-to-global xb yb)
+            (pretty-debug-gui `(local-to-global returns ,xb ,yb))
+            (send (ivar edit canvas) popup-menu menu 
+              (unbox xb) (+ (unbox yb) offset-menu))))]
+
+      [menu-callback 
+        (lambda (menu command)
+          (set! cur-he this)
+          (move-before-snip)
+          (let ([arg (send command get-command-int)])
+            (pretty-debug-gui `(command ,arg))
+            (wrap-busy-cursor
+              (lambda ()
+                (cond 
+                  [(= arg SELECT-SHOW-VALUE-SET)   (show-type-refresh)]
+                  [(= arg SELECT-CLOSE-VALUE-SET)  (delete-type-refresh)]
+                  [(= arg SELECT-RECOMPUTE-VALUE-SET)
+                    (delete-type-refresh)
+                    (show-type-refresh)]
+                  [(= arg SELECT-COPY-VALUE-SET)   (copy-type-to-clipboard)]
+                  [(= arg SELECT-PARENTS)     (parents-refresh)]
+                  [(= arg SELECT-ANCESTORS)   (ancestors-refresh)]
+                  [(= arg SELECT-PATH-SOURCE) (shortest-path-source-refresh)]
+                  [(= arg SELECT-CHILDREN)    (children-refresh)]
+                  [(= arg SELECT-DESCENDANTS) (descendants-refresh)]
+                  [(= arg SELECT-CLOSE-MENU)  (void)])))))]
+      )
+
+    (sequence
+
+      (unless (FlowType? ftype-arg)
+        (pretty-debug-gui `(bad-ftype ,ftype-arg ,(FlowType? ftype-arg))))
+      (assert (FlowType? ftype-arg) 'type-annotation-init1 ftype-arg)
+      (set! edit arg-edit)
+      
+      (set! start-pos start-arg)
+      (set! type-pos finish-arg)
+      (set! ftype ftype-arg)
+      (assert (FlowType? ftype) 'type-annotation-init ftype ftype-arg)
+
+      (send edit relocate-change-style type-link-delta start-arg end-first)
+      (send edit relocate-set-clickback start-arg end-first 
+            (lambda ignore
+              (popup-type/arrow-menu start-arg offset-menu-exp-y))
+            '()
+            #t))))
+
+;; ------------------------------------------------------------
+
+(define last-arrow-popup (void))
+
+(define flow-arrow%
+  (class null (arg-main arg-src arg-dest)
+    (public
+
+      src                               ; points to type-annotation% object
+      dest     
+      main
+      delete-arrow-thunks 
+
+      ;; Deletion
+      [delete-local
+        (lambda ()
+          ;; tell endpoints we're dead
+          (let ( [src-ta  (lookup-ftype src)]
+                 [dest-ta (lookup-ftype dest)])
+            (when (is-a? src-ta type-annotation%)
+              (send src-ta remove-dest-arrow this))
+            (when (is-a? dest-ta type-annotation%)
+              (send dest-ta remove-source-arrow this)))
+          ;; delete
+          (assert (list? delete-arrow-thunks) 1 delete-arrow-thunks)
+          (for-each (lambda (th) (th)) delete-arrow-thunks)
+          )]
+      [delete
+        (lambda () 
+          (send main delete-arrow this))]
+      [delete-refresh
+        (lambda ()
+          (pretty-debug-gui '(delete-refresh))
+          (delete)
+          (send main draw-arrows))]
+
+      ;; ----------
+
+      [update
+        ;; Change if necy due to loaded file
+        (lambda ()
+          (let ( [src-ta  (lookup-ftype src)]
+                 [dest-ta (lookup-ftype dest)])
+            (pretty-debug-gui `(flow-arrow%:update ,src-ta ,dest-ta))
+            (when (and 
+                    (string? src-ta)
+                    (send main filename->frame src-ta))
+              ;; file loaded, so delete this arrow + show parents of dest
+              (delete)
+              (send dest-ta add-parent-arrows))
+            (when (and 
+                    (string? dest-ta)
+                    (send main filename->frame dest-ta))
+              ;; file loaded, so delete this arrow + show children of src
+              (delete)
+              (send src-ta add-child-arrows))))]
+
+      ;; ----------
+
+      [popup-load-menu
+        (lambda (edit offsets where direction filename)
+          ;; direction is "parent" or "child"
+          (assert (not (send main filename->edit filename)))
+          (let* ( [menu-callback 
+                    (lambda (menu command)
+                      (wrap-busy-cursor
+                        (lambda ()
+                          (send main add-frame 
+                            (send main filename->fileinfo filename)
+                            #t))))]
+                  [menu (make-object wx:menu% '() menu-callback)]
+                  [xb (box 0)]
+                  [yb (box 0)])
+            (send menu append
+              LOAD-NONLOCAL-FILE
+              (format "Load ~s containing ~a"
+                (file-name-from-path filename) direction))
+       
+            ;; Get global location of expr
+            (send edit position-location 
+              (send edit real-start-position where)
+              xb yb)
+            (send edit local-to-global xb yb)
+            (pretty-debug-gui `(local-to-global returns ,xb ,yb))
+
+            (send (ivar edit canvas) popup-menu menu 
+              (+ (unbox xb) (car offsets))
+              (+ (unbox yb) (cdr offsets)))))]
+
+      [popup-zoom-menu
+        (lambda (edit offsets where to direction)
+
+          ;; direction is "parent" or "child"
+          (let* ( [menu-callback 
+                    (lambda (menu command)
+                      (wrap-busy-cursor
+                        (lambda ()
+                          (send to arrow-zoom))))]
+                  [menu (make-object wx:menu% '() menu-callback)]
+                  [xb (box 0)]
+                  [yb (box 0)])
+            (set! last-arrow-popup
+              (lambda () 
+                (send this popup-zoom-menu edit offsets where to direction)))
+            (send menu append
+              ZOOM-TO-FILE
+              (format "Zoom to ~a in ~s" 
+                direction
+                (file-name-from-path
+                  (send (ivar to edit) get-filename))))
+       
+            ;; Get global location of expr
+            (send edit position-location 
+              (send edit real-start-position where)
+              xb yb)
+            (send edit local-to-global xb yb)
+            (pretty-debug-gui `(local-to-global returns ,xb ,yb))
+
+            (send (ivar edit canvas) popup-menu menu 
+              (+ (unbox xb) (car offsets))
+              (+ (unbox yb) (cdr offsets)))))]
+      )
+
+    (sequence
+      (assert (is-a? arg-main MrSpidey%))
+      (assert (FlowType? arg-src) arg-src)
+      (assert (FlowType? arg-dest) arg-dest)
+      (pretty-debug-gui 
+        `(flow-arrow% ,arg-main 
+           ,(FlowType->pretty arg-src) ,(FlowType->pretty arg-dest)))
+      (set! main arg-main)
+      (set! src arg-src)
+      (set! dest arg-dest)
+
+      ;; 4 cases for arrow
+      ;; local - simple case
+      ;; source-half - just show arrow coming in from edge
+      ;; sink-half - just show arrow going to edge
+      ;; both-halves - show incoming and outgoing arrows in resp edits
+
+      (let* ( [src-ta  (lookup-ftype src)]
+              [dest-ta (lookup-ftype dest)])
+
+        (when (or 
+                (and 
+                  (is-a? src-ta type-annotation%)
+                  (assq dest-ta (ivar src-ta dest->arrows)))
+                (and 
+                  (is-a? dest-ta type-annotation%)
+                  (assq src-ta (ivar dest-ta src->arrows))))
+
+          ;; Arrow already there
+          (raise (make-exn:flow-arrow-exists)))
+
+        ;; Not already there - first tell endpoints we're here
+        (when (is-a? src-ta type-annotation%)
+          (send src-ta  add-dest-arrow   dest-ta this))
+        (when (is-a? dest-ta type-annotation%)
+          (send dest-ta add-source-arrow src-ta  this))
+
+        (pretty-debug-gui
+          `(src-ta ,src-ta
+             dest-ta ,dest-ta
+             srctadest->arrows 
+             ,(and 
+                (is-a? src-ta type-annotation%)
+                (map car (ivar src-ta dest->arrows)))
+             desttasrc->arrows 
+             ,(and 
+                (is-a? dest-ta type-annotation%)
+                (map car (ivar dest-ta src->arrows)))))            
+          
+        (let* 
+          (
+            [ta->edit-or-false
+              (lambda (ta)
+                (cond
+                  [(string? ta) 
+                    ;; If ftype is from .za file,
+                    ;; corresponding edit should not exist yet
+                    (assert (not (send main filename->edit ta)))
+                    #f]
+                  [(is-a? ta type-annotation%)
+                    ;; Is a type-annotation
+                    (ivar ta edit)]))]
+            [src-edit  (ta->edit-or-false src-ta)]
+            [dest-edit (ta->edit-or-false dest-ta)])
+          
+          (set! delete-arrow-thunks
+            (cond
+              [(and src-edit (not dest-edit))
+                ;; sink-half arrow
+                (let* ( [clickback-where
+                          (lambda (offsets)
+                            (lambda (where)
+                              (lambda (event) 
+                                (cond
+                                  [(send event button-down? 1)
+                                    (popup-load-menu
+                                      src-edit offsets where 
+                                      "child" dest-ta)]
+                                  [(send event button-down? 3) 
+                                    (delete-refresh)
+                                    #t]
+                                  [else #f]))))])
+                  (list
+                    (send src-edit add-flow-arrow-part
+                      (send src-ta get-start-pos) 
+                      (clickback-where offsets-load-menu-src-known)
+                      'jump 
+                      (clickback-where offsets-load-menu-dest-jump)
+                      nodest-arrow-brush.pen)))]
+
+              [(and dest-edit (not src-edit))
+                ;; sink-half arrow
+                (let* ( [clickback-where
+                          (lambda (offsets)
+                            (lambda (where)
+                              (lambda (event) 
+                                (cond
+                                  [(send event button-down? 1)
+                                    (popup-load-menu
+                                      dest-edit offsets where
+                                      "parent" src-ta)]
+                                  [(send event button-down? 3) 
+                                    (delete-refresh)
+                                    #t]
+                                  [else #f]))))])
+                  (list
+                    (send dest-edit add-flow-arrow-part
+                      'jump 
+                      (clickback-where offsets-load-menu-src-jump)
+                      (send dest-ta get-start-pos) 
+                      (clickback-where offsets-load-menu-dest-known)
+                      nosrc-arrow-brush.pen)))]
+
+              [(and src-edit dest-edit)
+                ;; local or non-local arrow
+                (let* ( [clickback-zoom
+                          (lambda (to)
+                            (lambda (posn)
+                              (lambda (event) 
+                                (cond
+                                  [(send event button-down? 1)
+                                    (send to arrow-zoom)]
+                                  [(send event button-down? 3) 
+                                    (delete-refresh)
+                                    #t]
+                                  [else #f]))))])
+
+                  (cond
+                    [(eq? src-edit dest-edit)
+                      ;; local arrow
+                      (list 
+                        (send src-edit add-flow-arrow-part
+                          (send src-ta get-start-pos)
+                          (clickback-zoom dest-ta)
+                          (send dest-ta get-start-pos)
+                          (clickback-zoom src-ta)
+                          arrow-brush.pen))]
+
+                    [else
+                      ;; non-local arrow
+                      (let* 
+                        ( [src-posn (send src-ta get-start-pos)]
+                          [dest-posn (send dest-ta get-start-pos)]
+                          [clickback-where
+                            (lambda (edit offsets to direction)
+                              (lambda (where)
+                                (lambda (event) 
+                                  (cond
+                                    [(send event button-down? 1)
+                                      (popup-zoom-menu
+                                        edit offsets where to direction)]
+                                    [(send event button-down? 3) 
+                                      (delete-refresh)
+                                      #t]
+                                    [else #f]))))])
+                        (list
+                          (send src-edit add-flow-arrow-part
+                            src-posn
+                            (clickback-where 
+                              src-edit 
+                              offsets-load-menu-src-known
+                              dest-ta "child")
+                            'jump
+                            (clickback-where 
+                              src-edit 
+                              offsets-load-menu-dest-jump
+                              dest-ta "child")
+                            arrow-brush.pen)
+                          (send dest-edit add-flow-arrow-part
+                            'jump
+                            (clickback-where 
+                              dest-edit 
+                              offsets-load-menu-src-jump
+                              src-ta "parent")
+                            dest-posn 
+                            (clickback-where 
+                              dest-edit 
+                              offsets-load-menu-dest-known
+                              src-ta "parent")
+                            arrow-brush.pen)))]))]
+              [else
+                (assert #f 'flow-arrow% src-edit dest-edit)]
+              ))
+          (assert (list? delete-arrow-thunks) 2 delete-arrow-thunks)          
+          )))))
+
+;; ======================================================================
+
+
diff --git a/collects/mrspidey/Gui/arrow.ss b/collects/mrspidey/Gui/arrow.ss
new file mode 100644
index 0000000..41b01db
--- /dev/null
+++ b/collects/mrspidey/Gui/arrow.ss
@@ -0,0 +1,137 @@
+; arrow.ss
+; defines arrow:media-edit%, an extention of graphics:media-edit% with arrows
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define arrow:media-edit%
+  (let* ([pi (* 2 (asin 1))]
+         [arrow-head-angle (/ pi 8)]
+         [cos-angle (cos arrow-head-angle)]
+         [sin-angle (sin arrow-head-angle)]
+         [arrow-head-size 10]
+         [arrow-root-radius 3.5]
+         [cursor-arrow (make-object wx:cursor% wx:const-cursor-arrow)])
+
+    (class-asi graphics:media-edit%
+      (inherit delete-graphic draw-graphics add-graphic set-cursor)
+      (public
+        [delete-arrow (lambda (arrow) (delete-graphic arrow))]
+        [draw-arrows  (lambda () (draw-graphics))]
+        [add-arrow
+         (lambda (start-pos start-dx start-dy 
+                   end-pos end-dx end-dy
+                   delta brush pen
+                   clickback-head clickback-root)
+           (pretty-debug-gui (list 'add-arrow 
+                               start-pos start-dx start-dy
+                               end-pos end-dx end-dy
+                               delta clickback-head clickback-root))
+           (add-graphic 
+            (list start-pos end-pos)
+            (match-lambda
+             [((start-x . start-y) (end-x . end-y))
+               (pretty-debug-gui
+                 `(locs ,start-x ,start-y ,end-x ,end-y
+                    ,start-dx ,start-dy ,end-dx ,end-dy))
+              (let* 
+                  ([start-x (+ start-x start-dx)]
+                   [start-y (+ start-y start-dy)]
+                   [end-x   (+ end-x end-dx)]
+                   [end-y   (+ end-y end-dy)]
+                   [ofs-x   (- start-x end-x)]
+                   [ofs-y   (- start-y end-y)]
+                   [len     (sqrt (+ (* ofs-x ofs-x) (* ofs-y ofs-y)))]
+                   [ofs-x   (/ ofs-x len)]
+                   [ofs-y   (/ ofs-y len)]
+                   [head-x  (* ofs-x arrow-head-size)]
+                   [head-y  (* ofs-y arrow-head-size)]
+                   [end-x   (+ end-x (* ofs-x delta))]
+                   [end-y   (+ end-y (* ofs-y delta))]
+                   [pt1     (make-object wx:point% end-x end-y)]
+                   [pt2     (make-object 
+                             wx:point%
+                             (+ end-x (* cos-angle head-x) 
+                                (* sin-angle head-y))
+                             (+ end-y (- (* sin-angle head-x))
+                                (* cos-angle head-y)))]
+                   [pt3     (make-object 
+                             wx:point%
+                             (+ end-x (* cos-angle head-x)
+                                (- (* sin-angle head-y)))
+                             (+ end-y (* sin-angle head-x)
+                                (* cos-angle head-y)))]
+                   [pts (list pt1 pt2 pt3)]
+                   [draw-fn
+                    (lambda (dc dx dy)
+                      '(pretty-debug-gui
+                        (list 'draw-line (+ start-x dx) (+ start-y dy)
+                              (+ end-x dx) (+ end-y dy)))
+                      (let ([old-brush (send dc get-brush)]
+                            [old-pen   (send dc get-pen)]
+                            [old-logfn (send dc get-logical-function)])
+                        (send dc set-brush brush)
+                        (send dc set-pen pen)
+                        ;; (send dc set-logical-function wx:const-or)
+                        (send dc draw-line
+                              (+ start-x dx) (+ start-y dy)
+                              (+ end-x dx) (+ end-y dy))
+                        (send dc draw-polygon pts dx dy)
+                        (send dc draw-ellipse 
+                              (- (+ start-x dx) arrow-root-radius)
+                              (- (+ start-y dy) arrow-root-radius)
+                              (* 2 arrow-root-radius)
+                              (* 2 arrow-root-radius))
+                        (send dc set-brush old-brush)
+                        (send dc set-pen old-pen)                    
+                        (send dc set-logical-function old-logfn)))]
+                   [on-head?
+                    (lambda (x y)
+                      (let*
+                          ([xs (map (lambda (pt) (send pt get-x)) pts)]
+                           [ys (map (lambda (pt) (send pt get-y)) pts)]
+                           [min-x (apply min xs)]
+                           [min-y (apply min ys)]
+                           [max-x (apply max xs)]
+                           [max-y (apply max ys)])
+                        (and (>= x min-x)
+                             (<= x max-x)
+                             (>= y min-y)
+                             (<= y max-y))))]
+                   [on-root?
+                    (lambda (x y)
+                      (and (>= x (- start-x arrow-root-radius))
+                           (<= x (+ start-x arrow-root-radius))
+                           (>= y (- start-y arrow-root-radius))
+                           (<= y (+ start-y arrow-root-radius))))]
+                   [event-fn
+                    (lambda (event x y)
+                      (cond
+                       [(on-head? x y)
+                        (set-cursor cursor-arrow)
+                        (clickback-head event)]
+                       [(on-root? x y)
+                        (set-cursor cursor-arrow)
+                        (clickback-root event)]
+                       [else 
+                         ;; Back to default cursor
+                         ;; (set-cursor '())
+                        #f]))])
+
+                ;; Return draw-thunk and event function
+                (cons draw-fn event-fn))])))]))))
+
+;; ----------------------------------------
diff --git a/collects/mrspidey/Gui/deltas.ss b/collects/mrspidey/Gui/deltas.ss
new file mode 100644
index 0000000..dd4db2b
--- /dev/null
+++ b/collects/mrspidey/Gui/deltas.ss
@@ -0,0 +1,108 @@
+; deltas.ss
+; Loads configuration from .Xresources
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; Given a resource name, this returns a style delta corresponding to the 
+;; attributes of the file or the default if there are none.
+
+(define (get-resource-maybe s2 default)
+  (let ([val-box (box default)])
+    (wx:get-resource 
+     (if (wx:colour-display?) "mrspidey" "mrspidey-bw")
+     s2 
+     val-box)
+    (unbox val-box)))
+
+(define delta-eval-namespace (make-namespace))
+(parameterize ([current-namespace delta-eval-namespace])
+    (invoke-open-unit/sig wx@ wx))
+
+(define delta-add-string! 
+  (lambda (delta string)
+  (let ([p (open-input-string string)])
+    (recur loop ()
+      (let ([e (read p)])
+        (unless (eof-object? e)
+          (apply (uq-ivar delta (car e)) (eval `(list ,@(cdr e)) delta-eval-namespace))
+          (loop)))))))
+
+(define set-resource-delta
+  (lambda (name default-string default-string-bw delta)
+    (delta-add-string! delta 
+                       (if (wx:colour-display?) 
+                           default-string 
+                           default-string-bw))
+    (delta-add-string! delta (get-resource-maybe name ""))))
+
+(define make-resource-delta
+  (lambda (name default-string default-string-bw)
+    (let ([delta (make-object wx:style-delta% 
+                              wx:const-change-alignment wx:const-align-top)])
+      '(set-resource-delta "base-delta"
+                          "(set-delta wx:const-change-normal) \
+                           (set-delta wx:const-change-family wx:const-modern) \
+                           (set-alignment-on wx:const-align-top) "
+                          "(set-delta wx:const-change-normal) \
+                           (set-delta wx:const-change-family wx:const-modern) \
+                           (set-alignment-on wx:const-align-top)"
+                          delta)
+      (set-resource-delta name default-string default-string-bw delta)
+      delta)))
+
+;; ----------------------------------------------------------------------
+;; These deltas are defined when the application starts, either from defaults
+;; or from resources, their names and their strings agree.
+
+(define base-delta
+  (make-resource-delta "base-delta" 
+                       "(set-delta wx:const-change-normal) \
+                           (set-delta wx:const-change-family wx:const-modern) \
+                           (set-alignment-on wx:const-align-top) "
+                          "(set-delta wx:const-change-normal) \
+                           (set-delta wx:const-change-family wx:const-modern) \
+                           (set-alignment-on wx:const-align-top)"))
+
+(define normal-delta
+  (make-resource-delta "normal-delta"
+                       "" ""))
+
+(define type-link-delta 
+  (make-resource-delta "type-link-delta"
+                       "(set-delta wx:const-change-bold)"
+                       "(set-delta wx:const-change-bold)"))
+(define type-delta
+  (make-resource-delta "type-link-delta"
+                       ""
+                       ""))
+
+(define check-delta 
+  (make-resource-delta "check-delta"
+                       "(set-delta-foreground \"RED\")"
+                       "(set-delta wx:const-change-underline 1)"))
+(define uncheck-delta
+  (make-resource-delta "uncheck-delta"
+                       "(set-delta-foreground \"FORESTGREEN\")"
+                       ""))
+
+(define check-link-delta
+  (make-resource-delta "check-link-delta" 
+                       "(set-delta-foreground \"BLUE\") \
+                        (set-delta wx:const-change-underline 1)"
+                       "(set-delta wx:const-change-underline 1)"))
+
+;; ----------------------------------------------------------------------
diff --git a/collects/mrspidey/Gui/dyn-edit.ss b/collects/mrspidey/Gui/dyn-edit.ss
new file mode 100644
index 0000000..a91b54d
--- /dev/null
+++ b/collects/mrspidey/Gui/dyn-edit.ss
@@ -0,0 +1,193 @@
+; dyn-edit
+;
+; Defines spidey:dynamic+margin-edit%, a subclass of spidey:static-edit%
+; with an insert-line method that also inserts a margin
+; and it handles adding and deleting snips
+; while still allowing static positions in the buffer
+;
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define spidey:dynamic+margin-edit%
+  (class spidey:static-edit% (arg-margin . init-args)
+    (inherit 
+      set-auto-set-wrap
+      load-file last-position position-line
+      lock get-style-list 
+      begin-edit-sequence end-edit-sequence edit-sequence
+      
+      change-style
+      set-clickback
+      flash-on
+      set-position
+      scroll-to-position
+      get-text
+      insert
+      delete
+      set-tabs
+      )
+
+    (public
+      ;; ----------
+      margin 
+      margin-length
+      ;[margin "  "]
+      ;[margin-length 2]
+
+      ;; keeps a list of all the snips in their source-locations
+      [sniplist ()]
+
+      [insert-line
+        (lambda (s)
+          (insert margin)
+          (insert s)
+          (insert (string #\newline)))]
+
+      ;; ----------
+
+      [account-for-margin
+        (lambda (pos) 
+          (recur loop ([try pos])
+            ;;(pretty-debug-gui `(accout-for-margin ,pos ,try))
+            (let ([better
+                    (+ pos 
+                      (* margin-length (add1 (position-line (+ try 0)))))])
+              (if (= better try)
+                try
+                (loop better)))))]
+      [real-start-position
+        (lambda (pos)
+          (account-for-margin
+            (let loop ([l sniplist])
+              (cond
+                [(null? l) pos]
+                [(> pos (car l)) (add1 (loop (cdr l)))]
+                [else (loop (cdr l))]))))]
+      [real-end-position
+        (lambda (pos)
+          (account-for-margin
+            (let loop ([l sniplist])
+              (cond
+                [(null? l) pos]
+                [(>= pos (car l)) (add1 (loop (cdr l)))]
+                [else (loop (cdr l))]))))]
+      [old-real-end-position
+        (lambda (pos)
+          (let ([pos pos])
+            (let loop ([l sniplist][pos pos])
+              (cond
+                [(null? l) (account-for-margin pos)]
+                [(>= pos (car l))  
+                  (loop (cdr l) (add1 pos))]
+                [else (loop (cdr l) pos)]))))]
+      [frame-pos->source-pos
+        (lambda (pos)
+          (assert (number? pos) 'frame-pos->source-pos)
+          (let ([pos (- pos (* margin-length (add1 (position-line pos))))])
+            (let loop ([l sniplist])
+              (cond
+                [(null? l) pos]
+                [(> pos (car l))
+                  (sub1 (loop (cdr l)))]
+                [else (loop (cdr l))]))))]
+
+      ;; ----------
+
+      [relocate-change-style
+        (lambda (delta src-start src-end)
+          (let ([s (real-start-position src-start)]
+                 [e (real-end-position src-end)])
+            (pretty-debug-gui `(change-style ,src-start ,src-end ,s ,e))
+            (change-style delta s e)))]
+			
+      [relocate-set-clickback
+        (lambda (src-start src-end . args)
+          (apply set-clickback
+            (real-start-position src-start)
+            (real-end-position src-end)
+            args))]
+      [relocate-flash-on
+        (lambda (src-start src-end a b c)
+          (flash-on (real-start-position src-start)
+            (real-end-position src-end) a b c))]
+      [relocate-scroll-to-position
+        (lambda (pos)
+          (let ([real-pos (real-start-position pos)])
+            '(pretty-print `(scroll-to-position ,pos ,real-pos))
+            (set-position real-pos)
+            (scroll-to-position real-pos)))]
+      ;;
+      ;; watch this function......
+      [relocate-set-position
+        (opt-lambda
+          (pos [end -1][eol #f][scroll #t])
+          (let ([end (if (= end -1) -1 (real-end-position end))])
+            (set-position (real-start-position pos) end
+              eol scroll)))]
+      [match-paren-forward
+        (lambda (source-start)
+          (frame-pos->source-pos (mred:scheme-forward-match
+                                   this (real-start-position source-start)
+                                   (last-position))))]
+	       
+      [relocate-get-text
+        (opt-lambda ([start -1][end -1][flat #f])
+          (get-text (real-start-position start)
+            (real-end-position end) flat))]
+      [select-snip
+        (lambda (pos snip)
+          (edit-sequence
+            (lambda ()
+              (send (send snip get-this-media) own-caret #f)
+              (set-position 
+                (real-end-position pos) (real-start-position pos)))))]
+      [relocate-insert-snip
+        (lambda (snip pos)
+          ;;(lock #f)
+          (when (member pos sniplist)
+            (error "Cannot put two snips in the same position~n"))
+          (let ([real-pos (real-start-position pos)])
+            (set! sniplist (cons pos sniplist))
+            (insert snip real-pos))
+          ;;(lock #t)
+          )]
+      [relocate-delete-snip
+        (lambda (pos)
+          (unless (member pos sniplist)
+            (error  "Cannot remove snip from ~s" pos))
+          (set! sniplist (remv pos sniplist))
+          (let ([pos (real-start-position pos)])
+            (delete pos (add1 pos))))]
+      )
+
+    (sequence
+      (apply super-init init-args)
+      (set! margin arg-margin)
+      (set! margin-length (string-length margin))
+
+      (set-auto-set-wrap #f)
+      ;; set-tabs doesn't work right past list of specified tabs
+      ;; so specify all tabs to column 200
+      (set-tabs 
+        (recur loop ([p margin-length])
+          (if (< p 200) 
+            (cons p (loop (+ p 8)))
+            '()))
+        8
+        #f)
+      )))
+
diff --git a/collects/mrspidey/Gui/graphics.ss b/collects/mrspidey/Gui/graphics.ss
new file mode 100644
index 0000000..47c7728
--- /dev/null
+++ b/collects/mrspidey/Gui/graphics.ss
@@ -0,0 +1,147 @@
+; graphics.ss
+; Defines graphics:media-edit%, a subclass of spidey:dynamic+margin-edit%
+; with facilities for graphics on top of text
+;
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-structure (graphic pos* locs->thunks draw-fn click-fn))
+
+(define graphics:media-edit%
+  (class spidey:dynamic+margin-edit% args
+    (inherit set-cursor)
+    (rename
+      [super-after-insert after-insert]
+      [super-after-delete after-delete]
+      [super-on-paint on-paint]
+      [super-on-event on-event]
+      [super-resized resized]
+      [super-size-cache-invalid size-cache-invalid])
+
+    (public
+      [graphics-list ()]
+      [pos->locs
+       (lambda (pos)
+         (let* ([xb (box 0)]
+                [yb (box 0)]
+                [real-pos (send this real-start-position pos)] )
+           (send this position-location real-pos xb yb #t)
+           (pretty-debug-gui 
+             `(pos->locs ,pos ,real-pos ,(unbox xb) ,(unbox yb)))
+           (cons (unbox xb) (unbox yb))))]
+      [calc-graphic-thunks!
+       (lambda (graphic)
+         (match-let*
+             ([locs (map pos->locs (graphic-pos* graphic))]
+              [locs->thunks (graphic-locs->thunks graphic)]
+              [(draw-fn . click-fn) (locs->thunks locs)])
+           (set-graphic-draw-fn! graphic draw-fn)
+           (set-graphic-click-fn! graphic click-fn)))]
+      [recalc-graphics
+       (lambda ()
+         '(pretty-debug-gui `(recalc-graphics ,@graphics-list))
+         (for-each calc-graphic-thunks! graphics-list))]
+      [add-graphic
+       (lambda (pos* locs->thunks)
+         (pretty-debug-gui (list 'add-graphic pos* locs->thunks))
+         (let ([graphic (make-graphic pos* locs->thunks 0 0)])
+           (calc-graphic-thunks! graphic)
+           (set! graphics-list (cons graphic graphics-list))
+           graphic))]
+      [delete-graphic
+       (lambda (graphic)
+         '(pretty-debug-gui `(delete-graphic ,graphic))
+         (set! graphics-list (remv graphic graphics-list)))]
+      [draw-graphics
+       (lambda ()
+         (let ([admin (send this get-admin)])
+           (pretty-debug-gui `(draw-graphics))
+           (send this invalidate-bitmap-cache)
+
+           ;; Kludge to get redrawing right
+           ;;(send super before-insert 0 1)
+           ;;(send super after-insert 0 1)
+
+           '(unless (null? admin)
+              (send admin needs-update 0 0 100000 100000))
+           '(pretty-debug-gui `(draw-graphics-done))))]
+
+      ;; overwritten methods
+      [resized
+       (lambda (snip redraw-now)
+         '(pretty-debug-gui `(resized ,snip ,redraw-now))
+         (super-resized snip redraw-now)
+         (recalc-graphics)
+         (when redraw-now (draw-graphics)))]
+
+      [after-delete
+       (lambda (start len)
+         '(pretty-debug-gui `(after-delete ,start ,len))
+         (super-after-delete start len)
+         (recalc-graphics)
+         (draw-graphics))]
+
+      [after-insert
+       (lambda (start len)
+         '(pretty-debug-gui `(after-insert ,start ,len))
+         (super-after-insert start len)
+         (recalc-graphics)
+         (draw-graphics))]
+      [size-cache-invalid
+        (lambda ()
+          (super-size-cache-invalid)
+          (recalc-graphics))]          
+
+      [on-paint
+       (lambda (before dc left top right bottom dx dy draw-caret)
+         (super-on-paint
+          before dc left top right bottom 
+          dx dy draw-caret)
+         (unless before 
+             '(pretty-debug-gui `(on-paint))
+           (for-each
+            (match-lambda
+             [($ graphic pos* locs->thunks draw-fn click-fn)
+              '(pretty-debug-gui (list 'on-paint-graphic pos*))
+              (draw-fn dc dx dy)])
+            graphics-list)))]
+
+      [on-event
+       (lambda (event)
+         (set-cursor '())
+         (let* ([admin (send this get-admin)]
+                [root-x (box 0)]
+                [root-y (box 0)])
+           (send admin get-dc root-x root-y)
+           (let ([actual-x (+ (send event get-x) (unbox root-x))]
+                 [actual-y (+ (send event get-y) (unbox root-y))])
+
+             ;; Now try to find a clickback to handle it
+             (let loop ([graphics graphics-list])
+               (match graphics
+                 [() (super-on-event event)]
+                 [(($ graphic _ _ _ click-fn) . rest-graphics) 
+                  (or (click-fn event actual-x actual-y)
+                      ;; Otherwise try next graphic
+                      (loop rest-graphics))])))))]
+      ) 
+    (sequence
+      ;;(pretty-debug-gui `(init graphic:media-edit% ,@init))
+      (apply super-init args)
+      )))
+
+;; ----------------------------------------
diff --git a/collects/mrspidey/Gui/load.ss b/collects/mrspidey/Gui/load.ss
new file mode 100644
index 0000000..d1f282e
--- /dev/null
+++ b/collects/mrspidey/Gui/load.ss
@@ -0,0 +1,29 @@
+;; load.ss - loads gui files
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(load-relative "deltas.ss")
+(load-relative "statedit.ss")
+(load-relative "dyn-edit.ss")
+(load-relative "graphics.ss")
+(load-relative "arrow.ss")
+(load-relative "annotat.ss")
+;(load-relative "paramenu.ss")
+;(load-relative "option.ss")
+(load-relative "prefs.ss")
+(load-relative "Tframe.ss")
+(load-relative "main.ss")
diff --git a/collects/mrspidey/Gui/loadu.ss b/collects/mrspidey/Gui/loadu.ss
new file mode 100644
index 0000000..a805d74
--- /dev/null
+++ b/collects/mrspidey/Gui/loadu.ss
@@ -0,0 +1,42 @@
+;; loadu.ss - loads graphic files into a unit
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey-gui^ (spidey))
+
+(define mrspidey-gui@
+  (unit/sig mrspidey-gui^
+    (import
+      [wx : wx^]
+      [mred : mred^]
+      mzlib:unprefixed-core^
+      mrspidey:sba^
+      mrspidey:interaction^)
+
+    (include "deltas.ss")
+    (include "statedit.ss")
+    (include "dyn-edit.ss")
+    (include "graphics.ss")
+    (include "arrow.ss")
+    (include "annotat.ss")
+    ;(include "paramenu.ss")
+    ;(include "option.ss")
+    (include "prefs.ss")
+    (include "Tframe.ss")
+    (include "main.ss")
+
+    ))
diff --git a/collects/mrspidey/Gui/main.ss b/collects/mrspidey/Gui/main.ss
new file mode 100644
index 0000000..15377cb
--- /dev/null
+++ b/collects/mrspidey/Gui/main.ss
@@ -0,0 +1,553 @@
+; main.ss
+; Defines main MrSpidey class
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-structure (fileinfo filename frame thunk-port annotations))
+;; annotations may also be (-> zodiac:parsed)
+
+(define NUM-EXTRA-LINES 20)
+
+(define-struct exn:flow-arrow-exists ())
+
+(define (wrap-busy-cursor thunk)
+  (dynamic-wind
+    (lambda () (wx:begin-busy-cursor))
+    thunk
+    (lambda () (wx:end-busy-cursor))))
+
+; ----------------------------------------------------------------------
+(define tm (void))
+
+(define MrSpidey%
+  (class null ()
+
+    (public 
+
+      [fileinfo* '()]
+      [multiple-files
+        (lambda ()
+          (not (= (length fileinfo*) 1)))]
+      ;; ------------------------------
+      ;; Progress frame
+
+      [progress-frame 'progress-frame]
+      [progress-canvas 'progress-canvas]
+      [progress-edit 'progress-edit]
+
+      [init-progress-frame!
+       (lambda ()
+         (pretty-debug-gui `(init-progress-frame))
+         (let* ( [f (parameterize
+                      ([wx:current-eventspace (wx:make-eventspace)])
+                      (make-object mred:frame% '() 
+                        (format "~a Progress" st:name)))]
+                 [p (make-object mred:vertical-panel% f)]
+                 [c (make-object mred:wrapping-canvas% p)]
+                 [ph (make-object mred:horizontal-panel% p)]
+                 [_ (send ph stretchable-in-y #f)]
+                 [_ (make-object mred:horizontal-panel% ph)]
+                 [b (make-object mred:button% ph 
+                      (lambda _ (send f show #f))
+                      "Hide")]
+                 [e (make-object mred:media-edit%)])
+           (set! progress-frame f)
+           (set! progress-canvas c)
+           (set! progress-edit e)
+           (send p add-child c)
+           ;;(send c set-media e)
+           (send progress-frame set-size -1 -1 400 200);; ht was 130
+           (send progress-frame show #f)))]
+
+      [new-progress-frame!
+       (lambda ()
+         (pretty-debug-gui `(new-progress-frame))
+         (set! progress-edit (make-object mred:media-edit%))
+         (send progress-edit lock #t)
+         (send progress-canvas set-media progress-edit)
+         (send progress-frame show #t)
+         (send progress-frame iconize #f)
+         (pretty-debug-gui `(new-progress-frame-done)))]
+
+      [with-progress-frame
+       (lambda (thunk)
+           (let*
+               ( [old-progress-handler (mrspidey:progress-handler)]
+                 [current '()]
+
+                 [current-start-time 0]
+                 [width 6]
+                 [total-width 18])
+             (letrec
+                 ([insert-numbers
+                    (lambda (n)
+                      (send progress-edit insert
+                        (format "~a    ~ams" 
+                          (padl 
+                            (if (eq? n 'done) "" (format "~a" n))
+                             width)
+                          (padl (- (current-process-milliseconds) 
+                                  (current-gc-milliseconds)
+                                  current-start-time)
+                            width))
+                        (send progress-edit last-position)))]
+                   [f (match-lambda*
+                      [((? string? name) line)
+                       (if (equal? name current)
+                         (let ([end (send progress-edit last-position)])
+                           (send progress-edit delete 
+                             (- end total-width) end)
+                           (insert-numbers line))
+                         (begin
+                           (f 'fresh-line)
+                           (set! current name)
+                           (set! current-start-time
+                             (- (current-process-milliseconds) 
+                               (current-gc-milliseconds)))
+                           (send progress-edit insert 
+                             (padr name 30))
+                           (insert-numbers line)))]
+                      [((? string? str)) 
+                       (f 'fresh-line)
+                       (send progress-edit insert str)
+                       (f #\newline)]
+                      [(#\newline)
+                       (send progress-edit  insert (format "~n"))
+                       (set! current '())]
+                      [('fresh-line)
+                       (unless (null? current) (f #\newline))])]
+                  [g (lambda args
+                       (send progress-edit lock #f)
+                       (apply f args)
+                       (send progress-edit lock #t))])
+               (parameterize 
+                 ([mrspidey:progress-handler 
+                    (lambda args
+                      ;;(apply old-progress-handler args)
+                      (apply g args)
+                      (wx:flush-display))])
+                 (send progress-frame show #t)
+                 (begin0 
+                   (thunk)
+                   (mrspidey:progress
+                     "=Done======================================"))))))]
+
+      ;; ------------------------------
+
+      [filename->fileinfo
+       (lambda (file)
+         (pretty-debug-gui `(filename->fileinfo ,file))
+         (or
+           (ormap
+             (match-lambda
+               [(and fi ($ fileinfo filename frame))
+                 (and (string? file)
+                   (string=? filename file)
+                   fi)])
+             fileinfo*)
+           (assert #f 'filename->fileinfo file)))]
+
+      [filename->frame
+       (lambda (file)
+         (let ([x (filename->fileinfo file)])
+           (and x (fileinfo-frame x))))]
+
+      [filename->edit
+       (lambda (file)
+         (let ([x (filename->frame file)])
+           (and x (ivar x program-edit))))]
+
+      [for-each-frame
+       (lambda (f)
+         (for-each
+          (match-lambda
+           [($ fileinfo filename frame)
+            (when frame (f frame))])
+          fileinfo*))]
+
+      [focus-def
+       (lambda (loc)
+         (assert (zodiac:location? loc) 'focus-def loc)
+         (let* ([file (zodiac:location-file loc)]
+                [frame (filename->frame file)])
+           (if frame
+               (send frame focus-def (zodiac:location-offset loc))
+               (wx:message-box
+                (format "File ~s is not loaded" (file-name-from-path file))
+                "Error"
+                (bitwise-ior wx:const-ok)))))]
+
+      ;; ------------------------------
+
+      [open-analyzed-file-choice
+        (lambda ()
+          (let ([choice
+                  (wx:get-single-choice
+                    "Select referenced unit file to open"
+                    "Open Unit"
+                    (sort string<? (map fileinfo-filename fileinfo*))
+                    '() -1 -1 #t 500 300)])
+            (when (string? choice)
+              (open-fileinfo (filename->fileinfo choice) #t))))]
+
+      [open-fileinfo
+       (match-lambda*
+        [((and fi ($ fileinfo filename frame)) show)
+         (if frame
+             (when show
+               (send frame show #t)
+               (send frame iconize #f))
+             (add-frame fi show))])]
+
+      [open-all
+       (lambda (show) 
+         (for-each 
+           (lambda (fi) (open-fileinfo fi show))
+           fileinfo*))]
+
+      [add-frame
+       (match-lambda*
+        [( (and fi ($ fileinfo filename frame thunk-port thunk-expression))
+           show
+           . first-frame-locs)
+         (pretty-debug-gui
+           `(add-no-show-frame ,filename ,fi ,@first-frame-locs))
+         (assert (not frame))
+         (let ([summary-edit (make-object mred:media-edit%)])
+           (initialize-summary summary-edit)
+           (pretty-debug-gui `(summary-initialized))
+           (parameterize
+            ([mrspidey:add-summary-handler (add-summary summary-edit)])
+            (with-progress-frame
+             (lambda ()
+               (pretty-debug-gui '(progress-frame-initialized))
+               (mrspidey:progress
+                 "===========================================")
+               '(mrspidey:progress 
+                  (format "Analyzing ~a" (file-name-from-path filename)))
+               (let* ([annotations 
+                        (calc-annotations (thunk-expression))]
+                      [_ (set-fileinfo-annotations! fi annotations)]
+                      [_ (pretty-debug-gui `(calling-Tframe ,filename))]
+                      [frame (apply make-object spidey:frame% 
+                               ;; only use margin
+                               this 
+                               filename summary-edit 
+                               first-frame-locs)])
+                 (pretty-debug-gui `(Have-Tframe ,filename))
+                 (when show (send frame show #t))
+                 (unless show (send frame show #t) (send frame show #f))
+                 (set-fileinfo-frame! fi frame)
+                 (update-arrows)
+                 )))))])]
+
+      [initialize-summary
+        (lambda (edit)
+          (let* ([delta (make-object wx:style-delta%
+                          wx:const-change-family
+                          wx:const-decorative)]
+                  [click-delta (make-object wx:style-delta%)])
+            (send delta set-delta wx:const-change-size 10)
+            (send click-delta copy delta)
+            (send click-delta set-delta-foreground "BLUE")
+            (send click-delta set-delta wx:const-change-underline 1)
+
+            (let ( [insert
+                     (lambda (s)
+                       (let ([before (send edit get-end-position)])
+                         (send edit insert s)
+                         (let ([after (send edit get-end-position)])
+                           (values before after))))])
+              (let*-values
+                ( [(s1 e1) (insert "Welcome to ")]
+                  [(s2 e2) (insert "MrSpidey")]
+                  [(s3 e3) (insert (format ", version ~a." (mred:version)))]
+                  [(s4 e4) (insert (format "~n"))])
+                (send edit change-style delta s1 e1)
+                (send edit change-style click-delta s2 e2)
+                (send edit change-style delta s3 e3)
+                (send edit set-clickback s2 e2
+		  (lambda args
+                    (make-object mred:hyper-view-frame% 
+                      (string-append 
+                        "file:"
+                        (build-path
+			  (collection-path "mrspidey") ; MATTHEW: got rid of plt-home
+                          "about.html"))))
+                  click-delta)))))]
+
+      [local-record-analyzed-file
+        (lambda (filename thunk-port thunk-expression)
+          (pretty-debug-gui
+            `(local-record-analyzed-file ,filename 
+               ,thunk-port
+               ,thunk-expression))
+          (set! fileinfo*
+            (append fileinfo*
+              (list (make-fileinfo filename #f 
+                      thunk-port 
+                      thunk-expression)))))]
+
+      ;; ------------------------------
+
+      [add-summary
+       (lambda (summary-edit)
+         (lambda line
+           (send summary-edit lock #f)
+           (match line
+             [(str loc word-ofs)
+               (cond
+                 [(zodiac:zodiac? loc)
+                   ((add-summary summary-edit) str 
+                     (zodiac:zodiac-start loc) word-ofs)]
+                 [(zodiac:location? loc)
+                   (let* ( [click (lambda ignore (focus-def loc))]
+                           [init-pos-box (box 0)]
+                           [_ (send summary-edit get-position init-pos-box)]
+                           [_ (send summary-edit insert str)]
+                           [_ (send summary-edit insert 
+                                (format " in file ~s line ~s"
+                                  (file-name-from-path
+                                    (zodiac:location-file loc))
+                                  (zodiac:location-line loc)))]
+                           [_ (send summary-edit insert #\newline)]
+                           ;; Find start and end of word
+                           [end (unbox init-pos-box)]
+                           [_ 
+                             (for i 0 (add1 word-ofs)
+                               (set! end (mred:scheme-forward-match 
+                                           summary-edit end 
+                                           (send summary-edit last-position))))]
+                           [start (mred:scheme-backward-match summary-edit end 0)])
+             
+                     '(pretty-debug-gui 
+                        `(send summary-edit change-style check-link-delta
+                           ,(send check-link-delta get-underlined-on)
+                           ,start ,end))
+                     ;; Paranoia - check have proper locations
+                     (if (and start end)
+                       (begin
+                         (send summary-edit set-clickback start end click)
+                         (send summary-edit change-style check-link-delta 
+                           start end))
+                       ;; Error
+                       (pretty-print 
+                         `(Error: annotate-summary 
+                            ,str ,loc ,word-ofs ,start ,end))))]
+                 [else
+                   (begin
+                     (printf 
+                       "Bad location in main:add-summary-handler ~s~n"
+                       loc)
+                     (mrspidey:add-summary str))])]
+             [(str)
+              (send summary-edit insert str) 
+              (send summary-edit insert #\newline)]
+             [x (printf "add-summary, can't handle ~s~n" x)])
+           (send summary-edit lock #t)))]
+
+      ;; ------------------------------
+
+      [on-frame-close
+       (lambda (filename)
+         (void))]
+
+      [close-all-frames
+       (lambda ()
+         (send progress-frame show #f)
+         (close-all-frames-except-progress)
+         )]
+
+      [close-all-frames-except-progress
+       (lambda ()
+         (for-each-frame (lambda (frame) (send frame on-close)))
+         )]
+
+      ;; ------------------------------
+      
+      [annotated-edit
+        (lambda (mode filename canvas)
+          ;; create edit buffer, load file and add annotations
+          (pretty-debug-gui `(annotate-edit ,mode ,filename))
+          (match (filename->fileinfo filename)
+            [($ fileinfo filename frame thunk-port annotations)
+              (let* ( [port (thunk-port)]
+                      [edit (make-object 
+                              (mode-edit-class mode)
+                              (if (multiple-files) "  " "")
+                              this canvas)])
+                (send edit set-filename filename)
+                (send edit edit-sequence
+                  (lambda ()
+                    (pretty-debug-gui "loading!")
+                    (let ([s (format "Loading   ~a: "
+                               (file-name-from-path filename))])
+                      (recur loop ([n 1])
+                        (when (zero? (modulo n 50))
+                          (mrspidey:progress s n))
+                        (let ([r (read-line port)])
+                          ;;(pretty-debug-gui `(inserting ,r))
+                          (if (eof-object? r)
+                            (mrspidey:progress s (sub1 n))
+                            (begin
+                              (send edit insert-line r)
+                              (loop (add1 n))))))
+                      (when (multiple-files)
+                        (for i 0 NUM-EXTRA-LINES (send edit insert-line ""))))
+                    (close-input-port port)
+                    (pretty-debug-gui `(last-line ,(send edit last-line)))
+                    (send edit change-style base-delta 
+                      0 (send edit last-position))
+
+                    (pretty-debug-gui "annotating!")
+                    (annotate! filename edit mode annotations)
+
+                    (send edit set-position 0)
+                    (pretty-debug-gui `(annotate-buffer done))))
+
+                edit)]))]
+
+      [annotate!
+        (lambda (filename edit mode annotations)
+          (let ([s (format "Annotating ~a:" (file-name-from-path filename))])
+            (mrspidey:progress s '...)
+            (pretty-debug-gui `(annotate! ,filename ,edit ,mode ,annotations))
+            (let ([annotation-fn-list (mode-annotation-fn-list mode)])
+              (for-each
+                (lambda (annotation-fn annotations)
+                  (when annotation-fn
+                    (for-each
+                      (let ([fn (uq-ivar edit annotation-fn)])
+                        (match-lambda
+                          [(and annotation ($ annotation loc))
+                            (when (string=? (zodiac:location-file loc)
+                                    filename)
+                              ;; Call the method named func to annotate etc.
+                              (fn annotation))]))
+                      annotations)))
+                annotation-fn-list 
+                (vector->list annotations)))
+            (mrspidey:progress s 'done)))]
+      
+      ;; ------------------------------
+
+      [shake-it
+       '(lambda ()
+          (let* ([n (random (vector-length fileinfo*))]
+                 [fi (vector-ref fileinfo* n)]
+                 [frame (fileinfo-frame fi)])
+            (send frame shake-it)))]
+
+      ;; ------------------------------
+      ;; Arrows
+
+      [list-flow-arrows '()]
+      [add-flow-arrow 
+        (lambda (src dest)
+          (assert (and (FlowType? src) (FlowType? dest)))
+          (pretty-debug-gui
+            `(main:add-flow-arrow
+               ,(FlowType->pretty src) ,(FlowType->pretty dest)))
+          (with-handlers
+            ([exn:flow-arrow-exists? (lambda (exn) (void))])
+            (let ([flow-arrow (make-object flow-arrow% this src dest)])
+              (when flow-arrow
+                (set! list-flow-arrows (cons flow-arrow list-flow-arrows))))))]
+      [draw-arrows
+        (lambda ()
+          (pretty-debug-gui `(main:draw-arrows))
+          (for-each-frame
+            (lambda (frame)
+              (send (ivar frame program-edit) draw-arrows))))]
+      [update-arrows
+        (lambda ()
+          (pretty-debug-gui `(main:update-arrows))
+          (for-each 
+            (lambda (arrow) (send arrow update))
+            list-flow-arrows)
+          (draw-arrows))]
+      [delete-arrow
+        (lambda (arrow)
+          (send arrow delete-local)
+          (set! list-flow-arrows (remv arrow list-flow-arrows)))]
+      [delete-arrow-refresh
+        (lambda (arrow)
+          (delete-arrow arrow)
+          (draw-arrows))]
+      [delete-arrows
+        (lambda ()
+          (for-each 
+            (lambda (arrow) (send arrow delete-local))
+            list-flow-arrows)
+          (set! list-flow-arrows '())
+          (draw-arrows))]
+
+      ;; ------------------------------
+
+      [reanalyze 'reanalyze]
+
+      [run-mrspidey
+
+       (lambda (file . first-frame-locs)
+         
+         (pretty-debug-gui `(run-mrspidey ,file))
+         (set! reanalyze 
+             (lambda () (apply run-mrspidey file first-frame-locs)))
+
+         (close-all-frames-except-progress)
+         (pretty-debug-gui `(frames-closed))
+         (set! fileinfo* '())
+         (new-progress-frame!)
+
+         (let ([file (normalize-path (normalize-path file))])
+           ;; Following calls record-anlyzed-file
+           (st:analyze-and-make-annotations file)
+           (apply add-frame (filename->fileinfo file) #t first-frame-locs)
+
+           ))])
+
+    ;; ----------------------------------------------------------------------
+
+    (sequence
+      (set! tm this)
+      (record-analyzed-file-hook local-record-analyzed-file)
+      (init-progress-frame!))))
+
+(define spidey (make-object MrSpidey%))
+
+;; ----------------------------------------------------------------------
+;; mode says for each set of annotations,
+;; either #f or fn to handle annotation.
+
+(define-const-structure (mode name edit-class annotation-fn-list))
+
+(define modes
+  (list 
+    (make-mode
+      "Types and Checks" 
+      flow-arrow:media-edit%
+      (list 
+        'add-type-annotation 
+        'add-check-annotation
+        'add-uncheck-annotation))
+    (make-mode "Normal"
+      spidey:static-edit%
+      (list #f #f #f))))
+
+;; ----------------------------------------------------------------------
+
+
diff --git a/collects/mrspidey/Gui/prefs.ss b/collects/mrspidey/Gui/prefs.ss
new file mode 100644
index 0000000..f1b5a88
--- /dev/null
+++ b/collects/mrspidey/Gui/prefs.ss
@@ -0,0 +1,330 @@
+;; prefs.ss - loads preferences
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define parameter-radio-boxes
+  (lambda (name param sym p major-dim direction)
+    (mred:set-preference-default sym (param) 
+      (lambda (x)
+        (with-handlers ((exn? (lambda (exn) #f)))
+          (param x)
+          #t)))
+    (param (mred:get-preference sym))
+    (let* ([o
+             (make-object
+               mred:radio-box% p 
+               (lambda (bx event)
+                 ;;(printf "~s~n" (param '?))
+                 (match
+                   (list-ref (param '?)
+                     (send event get-command-int))
+                   [(tag . _) 
+                     (param tag)
+                     (mred:set-preference sym tag)]))
+               name 
+               -1 -1 -1 -1 
+               (map cadr (param '?))
+               major-dim
+               direction)]
+            [pairs
+              (map
+                (match-lambda [(tag name . _) (cons name tag)])
+                (param '?))]
+            [default-ndx
+              (recur loop ([n 0][pairs pairs])
+                (cond 
+                  [(null? pairs)
+                    (error 'make-parameter-menu 
+                      "Can't find para in pairs ~s" (param))]
+                  [(equal? (param) (cdar pairs)) n]
+                  [else (loop (add1 n) (cdr pairs))]))])
+      (send o stretchable-in-x #t)
+      (send o set-selection default-ndx)
+      o
+      )))
+
+(define parameter-check-box
+  (lambda (name param sym p)
+    (mred:set-preference-default sym (param) 
+      (lambda (x)
+        (with-handlers ((exn? (lambda (exn) #f)))
+          (param x)
+          #t)))
+    (param (mred:get-preference sym))
+    (let* ( [hp (make-object mred:horizontal-panel% p)]
+            [o
+              (make-object
+                mred:check-box% hp 
+                (lambda (bx event)
+                  ;;(printf "~s~n" (param '?))
+                  (match
+                    (list-ref (param '?)
+                      (send event get-command-int))
+                    [(tag . _) 
+                      (param tag)
+                      (mred:set-preference sym tag)]))
+                name 
+                -1 -1 -1 -1)]
+            [_ (make-object mred:horizontal-panel% hp)])
+      (send o set-value (param))
+      o
+      )))
+
+;; ======================================================================
+;; MrSpidey Type Display
+
+(define callbacks-sdl-alg-changed '())
+
+(define (add-callback-sdl-alg-changed! fn)
+  (set! callbacks-sdl-alg-changed (cons fn callbacks-sdl-alg-changed)))
+
+(define (remq-callback-sdl-alg-changed! fn)
+  (set! callbacks-sdl-alg-changed (remq fn callbacks-sdl-alg-changed)))
+
+(define (sdl-alg-changed)
+  (for-each 
+    (lambda (f) (f)) 
+    callbacks-sdl-alg-changed))
+
+(define (param-ctrls-sdl-alg param)
+  (lambda args
+    (sdl-alg-changed)
+    (apply param args)))
+
+;; ======================================================================
+
+(mred:set-preference-default 'st:const-merge-size (st:const-merge-size) 
+  (lambda (x)
+    (with-handlers ((exn? (lambda (exn) #f)))
+      (st:const-merge-size x)
+      #t)))
+(st:const-merge-size (mred:get-preference 'st:const-merge-size))
+
+(define mrspidey-mk-analysis-pref-panel
+  (lambda (panel)
+    (let*
+      ( [p (make-object mred:vertical-panel% panel)]
+        
+        [vp (make-object mred:vertical-panel% p -1 -1 -1 -1)]
+        [_ (parameter-check-box
+             "Accurate constant types"
+             st:constants 'st:constants
+             vp)]
+        [g (make-object mred:slider% vp 
+             (lambda (slider event)
+               (st:const-merge-size (send event get-command-int))
+               (mred:set-preference 'st:const-merge-size 
+                 (send event get-command-int)))
+             "Constant merge size"
+             (st:const-merge-size)
+             1 100 
+             100)]
+        [_ (send g enable #t)]
+        [_ (parameter-check-box
+             "If splitting"
+             st:if-split 'st:if-split
+             vp)]
+        [_ (parameter-check-box
+             "Flow sensitivity"
+             st:flow-sensitive 'st:flow-sensitive
+             vp)]
+        [_ (parameter-check-box
+             "Accurate analysis of numeric operations"
+             st:numops 'st:numops
+             vp)]
+        [_2 (parameter-radio-boxes
+              "Polymorphism:"
+              st:polymorphism
+              'st:polymorphism
+              p 0 wx:const-horizontal)]
+
+        [vp (make-object mred:vertical-panel% p -1 -1 -1 -1)]
+        [vphp (make-object mred:horizontal-panel% vp)]
+        [_0 (make-object mred:message% vphp
+              "Polymorphism simplification algorithms:")]
+        [vphphp (make-object mred:horizontal-panel% vphp)]
+        [_1 (parameter-radio-boxes
+              "        "
+              st:constraint-simplification-poly
+              'st:constraint-simplification-poly
+              vp 0 wx:const-vertical)]
+
+        [_ (parameter-radio-boxes
+             "Save .za files in:"
+             st:save-za-in
+             'st:save-za-in
+             p
+             0 wx:const-horizontal)]
+        )
+        
+      p)))
+
+(mred:add-preference-panel
+  "MrSpidey Analysis"
+  mrspidey-mk-analysis-pref-panel)
+
+(mrspidey-mk-analysis-pref-panel
+  (make-object mred:horizontal-panel%
+    (make-object mred:frame% '() "dummy")))
+
+;; ======================================================================
+
+;(mred:set-preference-default 'st:sdl-size-k (st:sdl-size-k))
+;(st:sdl-size-k (mred:get-preference 'st:sdl-size-k))
+
+(define (indented-vertical-radio-box p name param sym)
+  (let*
+    ( [vp (make-object mred:vertical-panel% p -1 -1 -1 -1)]
+      [vphp1 (make-object mred:horizontal-panel% vp)]
+      [_0 (make-object mred:message% vphp1 name)]
+      [vphp2 (make-object mred:horizontal-panel% vp)]
+      [spc (make-object mred:horizontal-panel% vphp2)]
+      [_ (send spc user-min-width 20)]
+      [_ (send spc stretchable-in-x #f)]
+      [radio-box
+        (parameter-radio-boxes
+          '()
+          param sym
+          vphp2 0 wx:const-vertical)]
+      [_ (send radio-box stretchable-in-x #t)]
+      [_ (make-object mred:horizontal-panel% vphp2)])
+    (void)))
+
+(define mrspidey-mk-type-display-prefs-panel
+  (lambda (panel)
+    (let*
+      ( [p (make-object mred:vertical-panel% panel )])
+
+      (let* 
+        (
+          [sdl-fo-container-panel
+            (make-object mred:horizontal-panel% p)]
+          [sdl-fo-sub-panel
+            (make-object mred:horizontal-panel% p)]
+          [spc (make-object mred:horizontal-panel% sdl-fo-sub-panel)]
+          [_ (send spc user-min-width 20)]
+          [_ (send spc stretchable-in-x #f)]
+          [sdl-fo-sub-sub-panel
+            (make-object mred:vertical-panel% sdl-fo-sub-panel)]
+          [see-ivars-panel
+            (parameter-check-box
+              "Show instance variables"
+              (param-ctrls-sdl-alg st:sdl-fo-ivars)
+              'st:sdl-fo-ivars
+              sdl-fo-sub-sub-panel)]
+          [see-struct-fields-panel
+            (parameter-check-box
+              "Show structure fields"
+              (param-ctrls-sdl-alg st:sdl-fo-struct-fields)
+              'st:sdl-fo-struct-fields
+              sdl-fo-sub-sub-panel)] 
+          [_ (parameter-radio-boxes
+                "Show types as:"
+               (match-lambda*
+                 [('?) (st:sdl-fo '?)]
+                 [() (st:sdl-fo)]
+                 [(x)
+                   (sdl-alg-changed)
+                   (let ([enable-sub-controls (eq? x 'basic-types)])
+                     (for-each
+                       (lambda (control)
+                         (send control enable enable-sub-controls))
+                       (list 
+                         see-ivars-panel
+                         see-struct-fields-panel)))
+                   (st:sdl-fo x)])
+               'st:sdl-fo
+                sdl-fo-container-panel
+               0 wx:const-horizontal)])
+        (void))
+        
+      (indented-vertical-radio-box p 
+        "Constraint simplification algorithms:" 
+        (param-ctrls-sdl-alg st:sdl-constraint-simplification)
+        'st:sdl-constraint-simplification)
+
+      (parameter-radio-boxes
+        "Type naming:"
+        (param-ctrls-sdl-alg st:naming-strategy)
+        'st:naming-strategy
+        p 0 wx:const-horizontal)
+      (parameter-radio-boxes
+        "Primitive types:"
+        (param-ctrls-sdl-alg st:primitive-types)
+        'st:primitive-types
+        p 0 wx:const-horizontal)
+
+      (let* 
+        (
+          [st:expand-output-type-container-panel
+            (make-object mred:horizontal-panel% p)]
+          [st:expand-output-type-sub-panel
+            (make-object mred:horizontal-panel% p)]
+          [spc (make-object mred:horizontal-panel% 
+                 st:expand-output-type-sub-panel)]
+          [_ (send spc user-min-width 20)]
+          [_ (send spc stretchable-in-x #f)]
+          [sdl-tidy-object
+            (parameter-check-box
+              "Uses equivalences that make types tidy"
+              (param-ctrls-sdl-alg st:sdl-tidy)
+              'st:sdl-tidy
+              st:expand-output-type-sub-panel)] 
+          [_ (parameter-check-box
+               "Use equivalences to simplify types"
+               (match-lambda*
+                 [('?) (st:expand-output-type '?)]
+                 [() (st:expand-output-type)]
+                 [(x)
+                   (sdl-alg-changed)
+                   (send sdl-tidy-object enable x)
+                   (st:expand-output-type x)])
+               'st:expand-output-type
+               st:expand-output-type-container-panel)])
+        (void))
+
+      p)))
+
+(mred:add-preference-panel
+  "MrSpidey Type Display"
+  mrspidey-mk-type-display-prefs-panel)
+
+(mrspidey-mk-type-display-prefs-panel
+  (make-object mred:horizontal-panel%
+    (make-object mred:frame% '() "dummy")))
+
+;; ======================================================================
+
+'(define (make-parameter-menu parameter)
+   (let* ([pairs
+            (map
+              (match-lambda [(tag name . _) (cons name tag)])
+              (parameter '?))]
+           [default-ndx
+             (recur loop ([n 0][pairs pairs])
+               (cond 
+                 [(null? pairs)
+                   (error 'make-parameter-menu "Can't find para in pairs")]
+                 [(equal? (parameter) (cdar pairs)) n]
+                 [else (loop (add1 n) (cdr pairs))]))])
+     (let ([menu (make-object mred:menu%)])
+       (send menu append-check-set pairs parameter default-ndx)
+       ;;(parameter (cdar pairs))
+       menu)))
+
+
+
diff --git a/collects/mrspidey/Gui/progress.ss b/collects/mrspidey/Gui/progress.ss
new file mode 100644
index 0000000..37806d8
--- /dev/null
+++ b/collects/mrspidey/Gui/progress.ss
@@ -0,0 +1,168 @@
+; progress.ss - not used
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define progress-box%
+  (class mred:frame% (title arg-bar-names . top-left-loc)
+
+    (inherit show set-size)
+
+    (public
+     num-bars
+     bar-names
+     bar-fractions
+     the-canvas 
+     [top-margin   12]
+     [bot-margin   24]
+     [right-margin 20]
+     [left-margin  10]
+     [middle-margin 20]
+     [bar-length  150]
+     [line-spacing 8]
+     [barname-width  58]
+     [barname-height 12]
+     [bar-margin     2]
+     [solid-brush (make-object wx:brush% "DARKGREEN" wx:const-solid)]
+     [trans-brush (make-object wx:brush% "DARKGREEN" wx:const-transparent)]
+     [border-pen  (make-object wx:pen% "BLACK" 1 wx:const-solid)]
+     [in-pen      (make-object wx:pen% "DARKGREEN" 1 wx:const-solid)]
+
+     [mark-progress
+      (lambda (bar-num fraction)
+        (vector-set! bar-fractions bar-num fraction)
+        (send the-canvas on-paint))]
+     )
+
+    (sequence
+      
+      (super-init '() title -1 -1 200 200)
+
+      (set! num-bars (length arg-bar-names))
+      (set! bar-names (list->vector arg-bar-names))
+      (set! bar-fractions (make-vector num-bars 0))
+
+      (set! the-canvas
+          (make-object 
+           (class wx:canvas% args
+             (inherit get-dc)
+             (public
+               [on-paint
+                (lambda ()
+                  (let ([the-dc (send the-canvas get-dc)])
+                    ;; Draw the text
+                    (for i 0 num-bars
+                         '(pretty-print
+                           `(send the-dc draw-text
+                                  ,(vector-ref bar-names i)
+                                  ,left-margin
+                                  ,(+ top-margin 
+                                      (* (+ barname-height line-spacing) i))))
+                         (send the-dc draw-text
+                               (vector-ref bar-names i)
+                               left-margin
+                               (+ top-margin
+                                  (* (+ barname-height line-spacing) i))))
+
+                    ; Draw the bar borders
+                    (send the-dc set-pen border-pen)
+                    (send the-dc set-brush trans-brush)
+                    (for i 0 num-bars
+                         '(pretty-print `(send the-dc draw-rectangle
+                                              ,(+ left-margin barname-width middle-margin)
+                                              ,(+ top-margin 
+                                                  (* (+ barname-height line-spacing) i))
+                                              ,(+ (* bar-length 1) (* 2 bar-margin))
+                                              ,barname-height))
+                         (send the-dc draw-rectangle
+                               (+ left-margin barname-width middle-margin)
+                               (+ top-margin 
+                                  (* (+ barname-height line-spacing) i))
+                               (+ (* bar-length 1) (* 2 bar-margin))
+                               barname-height))
+
+                    ;; Draw the bars
+                    (send the-dc set-pen in-pen)
+                    (send the-dc set-brush solid-brush)
+                    (for i 0 num-bars
+                         (unless (zero? (vector-ref bar-fractions i))
+                           '(pretty-print `(send the-dc draw-rectangle
+                                 ,(+ left-margin barname-width middle-margin
+                                    bar-margin)
+                                 ,(+ top-margin 
+                                    (* (+ barname-height line-spacing) i)
+                                    bar-margin)
+                                 ,(vector-ref bar-fractions i)
+                                 ,(* bar-length (vector-ref bar-fractions i))
+                                 ,(- barname-height (* 2 bar-margin))))
+                           (send the-dc draw-rectangle
+                                 (+ left-margin barname-width middle-margin
+                                    bar-margin)
+                                 (+ top-margin 
+                                    (* (+ barname-height line-spacing) i)
+                                    bar-margin)
+                                 (* bar-length (vector-ref bar-fractions i))
+                                 (- barname-height (* 2 bar-margin)))))
+                    )
+                  (wx:flush-display))])
+
+             (sequence
+               (apply super-init args)
+               (let ([the-dc (get-dc)])
+                 (send the-dc set-font
+                       (make-object wx:font% 12 wx:const-modern 
+                                    wx:const-normal wx:const-normal #f))
+                 )))
+
+             this))
+
+      '(let* ([sizes 
+               (map 
+                (lambda (name)
+                  (let ([wb (box 0)]
+                        [hb (box 0)])
+                    (printf ".") (flush-output)
+                    (send (send the-canvas get-dc) get-text-extent name wb hb)
+                    (printf ".") (flush-output)
+                    (cons (unbox wb) (unbox hb))))
+                arg-bar-names)])
+
+         (pretty-print `(sizes ,sizes))
+         (set! barname-width  (apply max (map car sizes)))
+         (set! barname-height (apply max (map cdr sizes))))
+        
+      ;; Set the frame size + position
+      (let ([w (+ left-margin barname-width middle-margin 
+                  bar-length (* 2 bar-margin) right-margin)]
+            [h (+ top-margin
+                  (* (+ barname-height line-spacing) num-bars)
+                  bot-margin)])
+        (match top-left-loc
+          [(x y) (set-size (- x w) y w h)]
+          [() (void)])
+      (set-size w h))
+      ;; We're ready
+      (show #t)
+      (wx:flush-display)
+      (wx:yield)
+      )))
+         
+'(begin
+  (define p (make-object progress-box% "title" '("bar-name-1" "bar-name-2")))
+  (send p mark-progress 0 0.3)
+  (send p mark-progress 1 0.6)
+  )
+
diff --git a/collects/mrspidey/Gui/statedit.ss b/collects/mrspidey/Gui/statedit.ss
new file mode 100644
index 0000000..241fefb
--- /dev/null
+++ b/collects/mrspidey/Gui/statedit.ss
@@ -0,0 +1,72 @@
+; statedit.ss
+; Defines spidey:static-edit%, a subclass of mred:media-edit%
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define spidey:static-edit%
+  (class mred:searching-edit% init-args
+    (inherit 
+      insert delete flash-on flash-off get-text
+      set-clickback change-style lock
+      set-position load-file
+      get-keymap scroll-to-position
+      last-position get-style-list
+      set-mode
+      begin-edit-sequence end-edit-sequence
+      )
+
+    (public
+      [begin-edit-sequence-and-unlock
+        (lambda ()
+          (wx:begin-busy-cursor)
+          (lock #f)
+          (begin-edit-sequence))]
+      [end-edit-sequence-and-lock
+        (lambda ()
+          (end-edit-sequence)
+          (lock #t)        
+          (wx:end-busy-cursor))]
+      [edit-sequence
+        (lambda (thunk)
+          (dynamic-wind
+            begin-edit-sequence-and-unlock
+            thunk
+            end-edit-sequence-and-lock))]
+      [match-paren-forward
+        (lambda (source-start)
+          (mred:scheme-forward-match
+            this source-start (last-position)))]
+      )
+	      
+    (sequence
+		
+      (apply super-init init-args)
+
+      (set-mode (make-object mred:scheme-mode%))
+      ;; disable paste for errant right mouse clicks
+      (let ([ k (get-keymap)])
+        (send k add-mouse-function "nothing" (lambda l (void)))
+        (send k map-function "middlebutton" "nothing")
+        (send k map-function "rightbutton" "nothing"))
+
+      ;; make snips go down instead of up
+      ;; oops - can't do this :-(
+      '(let ([stan (send (get-style-list) find-named-style "Standard")])
+         (when stan (send stan set-delta normal-delta)))
+
+      (lock #t)
+      )))
diff --git a/collects/mrspidey/Gui/test-gui.ss b/collects/mrspidey/Gui/test-gui.ss
new file mode 100644
index 0000000..0dc9a27
--- /dev/null
+++ b/collects/mrspidey/Gui/test-gui.ss
@@ -0,0 +1,23 @@
+;; test-gui.ss
+;; ----------------------------------------------------------------------
+
+(define test-gui-shake-reps 25)
+
+(define (shake-test-files) test-files)
+
+;; ----------------------------------------------------------------------
+
+(define (test-gui-file f)
+  (printf "FILE: ~s~n" f)
+  (let* ([ftd (list f (lambda () (open-input-file f)) #t)]
+         [ftd* (list ftd)])
+    (send spidey do-and-show-analysis ftd*)
+    (for i 0  test-gui-shake-reps
+         (printf "Iteration ~s/~s~n" i  test-gui-shake-reps)
+         (send spidey shake-it))
+    (send spidey close-all-frames)))
+
+(define (test-gui)
+  (for-each test-gui-file (shake-test-files)))
+
+
diff --git a/collects/mrspidey/Sba/atenv.ss b/collects/mrspidey/Sba/atenv.ss
new file mode 100644
index 0000000..e530826
--- /dev/null
+++ b/collects/mrspidey/Sba/atenv.ss
@@ -0,0 +1,307 @@
+;; atenv.ss
+;; Section for handling environment
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-const-typed-structure
+  atenv ( (: immut     (listof (cons zodiac:binding FlowType)))
+          (: notcap    (listof (cons zodiac:binding mutable-binding)))
+          (: cap       (listof (cons zodiac:binding mutable-binding)))
+          (: flushed   (listof (cons zodiac:binding mutable-binding)))
+          (: unflushed (listof (cons zodiac:binding mutable-binding)))
+          (: both      (listof (cons zodiac:binding mutable-binding)))))
+
+(define-const-typed-structure 
+  mutable-binding ( (: current FlowType)
+                    (: at-transfer Tvar)
+                    (: flushed bool)))
+
+;; ----------------------------------------------------------------------
+
+(define atenv:empty (make-atenv '() '() '() '() '() '()))
+
+(define (atenv:extend-mutated env name ftype tvar)
+  (pretty-debug-atenv `(atenv:extend-mutated ,(atenv->pretty env)))
+  (assert (zodiac:binding? name) 'atenv:extend name)
+  (let ([ftype (link-parsed-ftype! name ftype)])
+    (match env
+      [($ atenv i n c f u b)
+        (make-atenv 
+          i
+          (extend-env n name 
+            (make-mutable-binding 
+              ftype tvar
+              #f))
+          c f u b)])))
+
+(define (atenv:extend env name ftype)
+  (pretty-debug-atenv `(atenv:extend ,(atenv->pretty env)))
+  (assert (zodiac:binding? name) 'atenv:extend name)
+  (let ([ftype (link-parsed-ftype! name ftype)])
+    (match env
+      [($ atenv i n c f u b)
+        (if (zodiac:binding-mutated name)
+          (make-atenv 
+            i
+            (extend-env n name 
+              (make-mutable-binding 
+                ftype 
+                (mk-Tvar 'mut-var
+                  ;;(symbol-append 'mut-var- (zodiac:binding-var name))
+                  )
+                #f))
+            c f u b)
+          (make-atenv
+            (extend-env i name ftype)
+            n c f u b))])))
+
+(define (atenv:extend* env names ftypes)
+  (foldr2 (lambda (name ftype env) (atenv:extend env name ftype))
+          env names ftypes))
+
+(define (atenv:extend-voids env names)
+  (atenv:extend* env names (map (lambda (x) (mk-tvar-void)) names)))
+
+(define (atenv:extend-undefineds env names)
+  (atenv:extend* env names (map (lambda (x) (mk-tvar-undefined)) names)))
+
+(define (atenv:lookup env name)
+  (pretty-debug-atenv `(atenv:lookup ,(atenv->pretty env)))
+  (if (zodiac:binding-mutated name)
+    (match (or 
+             (lookup-or-#f (atenv-notcap env)    name)
+             (lookup-or-#f (atenv-cap env)       name)
+             (lookup-or-#f (atenv-flushed env)   name)
+             (lookup-or-#f (atenv-unflushed env) name)
+             (lookup-or-#f (atenv-both env)      name))
+      [($ mutable-binding cur) cur]
+      [x x])
+    (lookup-or-#f (atenv-immut env) name)))
+
+(define (atenv:change-binding env name ftype)
+  (pretty-debug-atenv
+    `(->atenv:change-binding
+       ,(zodiac:binding-var name) ,(FlowType->pretty ftype)
+       ,(atenv->pretty env)))
+  (match env
+    [($ atenv i n c f u b)
+      (let/cc k
+        (let* 
+          ([err
+             (lambda ()
+               (pretty-debug-atenv
+                 `(atenv:change-binding
+                    ,(zodiac:binding-var name)
+                    ,(map zodiac:binding-var (map car env))))
+               (mrspidey:warning
+                 (format "Unbound variable ~s" (zodiac:binding-var name))
+                 (zodiac:zodiac-start name)
+                 2)
+               (k env))]
+            [result-env
+              (if (zodiac:binding-mutated name)
+                (let ([chg-fn
+                        (match-lambda
+                          [($ mutable-binding cur at-transfer)
+                            (make-mutable-binding ftype at-transfer #f)])])
+                  (if (lookup-or-#f n name)
+                    (make-atenv
+                      i
+                      (env:change-binding n name chg-fn err)
+                      c f u b)
+                    ;; Must be in one of c f u b
+                    ;; Lift out to captured
+                    (if (lookup-or-#f c name)
+                      (make-atenv
+                        i n
+                        (env:change-binding c name chg-fn err)
+                        f u b)
+                      (let*-vals
+                        ([(bind f u b)
+                           (cond
+                             [(lookup-or-#f f name)
+                               (let*-vals ([(bind f) (env:remove f name)])
+                                 (values bind f u b))]
+                             [(lookup-or-#f u name)
+                               (let*-vals ([(bind u) (env:remove u name)])
+                                 (values bind f u b))]
+                             [(lookup-or-#f b name)
+                               (let*-vals ([(bind b) (env:remove b name)])
+                                 (values bind f u b))]
+                             [else (err)])])
+                        (make-atenv
+                          i n
+                          (extend-env c name (chg-fn bind))
+                          f u b)))))
+                (make-atenv 
+                  (env:change-binding i name (lambda (old) ftype) err)
+                  n c f u b))])
+          (pretty-debug-atenv
+            `(->atenv:change-binding-returns ,(atenv->pretty result-env)))
+          result-env))]))
+
+(define (atenv:change-bindings env bindings ftypes)
+  (foldr2
+   (lambda (binding ftype env)
+     (atenv:change-binding env binding ftype))
+   env bindings ftypes))
+
+;; ------------------------------
+
+(define (atenv:capture-locs env bindings)
+  (pretty-debug-atenv 
+    `(atenv:capture-locs ,(atenv->pretty env) ,(map zodiac:binding-var bindings)))
+  (match env
+    [($ atenv i n c f u b)
+      (recur loop ([n n][n-ok '()][c c])
+        (if (null? n)
+          (make-atenv i n-ok c f u b)
+          (if (and 
+                (memq (caar n) bindings)
+                ;; ### KLUDGE FOR DECENT, BUT POSSIBLY WRONG, POLYMORPHISM
+                (not (poly-atype? (FlowType->Atype 
+                                    (mutable-binding-current (cdar n))))))
+            (loop (cdr n) n-ok (cons (car n) c))
+            (loop (cdr n) (cons (car n) n-ok) c))))]))
+
+(define (atenv:unflush env)
+  (pretty-debug-atenv `(atenv:unflush ,(atenv->pretty env)))
+  (match env
+    [($ atenv i n c f u b)
+      (let ([upd
+              (match-lambda
+                [(name . ($ mutable-binding cur trans))
+                  (cons name (make-mutable-binding trans trans #t))])])
+        (make-atenv
+          i n '() '()
+          (append (map upd c) u)
+          (append (map upd f) b)))]))
+
+(define (atenv:flush! env)
+  (pretty-debug-atenv `(atenv:flush! ,(atenv->pretty env)))
+  (match env
+    [($ atenv i n c f u b)
+      (let ([upd
+              (match-lambda
+                [(name . (and bind ($ mutable-binding cur trans flushed)))
+                  (unless flushed
+                    (new-edge! (FlowType->Tvar cur) trans)
+                    (set-mutable-binding-flushed! bind #t))])])
+        (for-each upd c)
+        (for-each upd u)
+        (make-atenv i n '() (append c f) '() (append u b)))]))
+
+(define (atenv->pretty env)
+  (match env
+    [($ atenv i n c f u b)
+      (let ([p (match-lambda
+                 [(name . ($ mutable-binding cur trans))
+                   (list (zodiac:binding-var name) 
+                     (list
+                       (FlowType->pretty cur)
+                       (FlowType->pretty trans)))])])
+              
+        (list
+          (map (match-lambda
+                 [(name . ftype)
+                   (list 
+                     (zodiac:binding-var name) 
+                     (FlowType->pretty ftype))])
+            i)
+          (map p n) 
+          (map p c)
+          (map p f)
+          (map p u)
+          (map p b)))]))
+
+(define (atenv:domain env)
+  (match env
+    [($ atenv i n c f u b)
+      (map car (append i n c f u b))]))
+
+(define (atenv:ok? e)
+  (and
+    (atenv? e)
+    (match e
+      [($ atenv i n c f u b)
+        (and
+          (list? i)
+          (andmap
+            (match-lambda
+              [(($ zodiac:binding) . ($ FlowType)) #t]
+              [_ #f])
+            i)
+          (andmap
+            (lambda (n)
+              (and
+                (list? n)
+                (andmap
+                  (match-lambda
+                    [(($ zodiac:binding) . ($ mutable-binding)) #t]
+                    [_ #f])
+                  n)))
+            (list n c f u b)))])))
+
+'(defmacro check-atenv-fn-ok (fn)
+  (let ( [old-fn (gensym)])
+    `(begin
+       (define ,old-fn ,fn)
+       (define ,fn
+         (let ([env-ok atenv:ok?])
+           (lambda (env . rest)
+             ;;(printf "Entering ~s~n" (quote ,fn))
+             (unless (env-ok env)
+               (pretty-print env)
+               (error (quote ,fn) "Bad env on entry"))
+             (let ([r (apply ,old-fn env rest)])
+               ;;(printf "exiting ~s~n" (quote ,fn))
+               (unless (env-ok env)
+                 (error (quote ,fn) "Bad env on exit"))
+               r)))))))
+
+;(check-atenv-fn-ok atenv:extend)
+;(check-atenv-fn-ok atenv:extend*)
+;(check-atenv-fn-ok atenv:extend-voids)
+;(check-atenv-fn-ok atenv:change-binding)
+;(check-atenv-fn-ok atenv:change-bindings)
+;(check-atenv-fn-ok atenv:capture-locs)
+;(check-atenv-fn-ok atenv:unflush)
+;(check-atenv-fn-ok atenv:flush!)
+
+;; ======================================================================
+
+(define (link-parsed-ftype! parsed ftype)
+  (assert (FlowType? ftype) 'link-parsed-ftype! ftype)
+  (if need-label-types
+    (let ([nu-ftype
+            (if (and need-explanation (FlowType-expr ftype))
+              (copy-ftype ftype)
+              ftype)])
+      (pretty-debug-object 
+        `(link-parsed-ftype! 
+           ,(zodiac:stripper parsed)
+           ,(zodiac:location-offset (zodiac:zodiac-start parsed))
+           ,(FlowType-name ftype)))
+      (zodiac:set-parsed-ftype! parsed nu-ftype)
+      (set-FlowType-expr! nu-ftype #t) ;parsed
+      nu-ftype)
+    ftype))
+
+;; ======================================================================
+
+
+
diff --git a/collects/mrspidey/Sba/atlunit.ss b/collects/mrspidey/Sba/atlunit.ss
new file mode 100644
index 0000000..7301ddd
--- /dev/null
+++ b/collects/mrspidey/Sba/atlunit.ss
@@ -0,0 +1,765 @@
+;; atlunit.ss
+;; Handles annotated lazy units - units, cmpd-units and reference-units
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; The structures ...
+
+(define-const-typed-structure
+  (atlunit-unit struct:atlunit)
+  ((: env (listof (cons zodiac:binding FlowType)))
+   (: exp zodiac:unit-form)))
+
+(define (create-atlunit-unit env exp)
+  (make-atlunit-unit #f env exp))
+
+;; -----
+
+(define-const-typed-structure
+  (atlunit-cmpd struct:atlunit)
+  ((: cmpd-unit zodiac:compound-unit-form)
+   (: times (listof num))
+   (: ftype* (listof FlowType))))
+
+(define (create-atlunit-cmpd cmpd-unit time* ftype*)
+  (make-atlunit-cmpd #f cmpd-unit time* ftype*))
+
+;; -----
+
+(define-const-typed-structure
+  (atlunit-reference struct:atlunit)
+  ((: exp zodiac:sexp)))
+
+(define (create-atlunit-reference exp)
+  (assert (zodiac:reference-unit-form? exp))
+  (make-atlunit-reference #f exp))
+
+;; ----------------------------------------------------------------------
+;; (: partial-import-list 
+;;    (union false (listof (cons (union FlowType false) time))))
+
+(define (pretty-partial-import-list pil)
+  (and pil
+    (map (match-lambda
+           [(ftype . itime)
+             (cons (and ftype (FlowType->pretty ftype)) itime)])
+      pil)))
+
+;; ----------------------------------------------------------------------
+
+(define (apply-unit unit partial-import-list)
+  (: unit FlowType)
+  ;; returns (union atunit Tvar)
+  (match (FlowType->Atype unit)
+    [(? atlunit? atlunit) (apply-atlunit atlunit partial-import-list)]
+    [($ atunit imports exports result expr)
+      (let ([imports
+              (cond
+                [(eq? partial-import-list #f) imports]
+                [(= (length imports) (length partial-import-list))
+                  (map (match-lambda*
+                         [((sym . tvars) (ftype . _))
+                           (if ftype
+                             (begin
+                               (for-each 
+                                 (lambda (tvar)
+                                   (new-edge! (FlowType->Tvar ftype) tvar)) 
+                                 tvars)
+                               (list sym))
+                             (cons sym tvars))])
+                    imports partial-import-list)]
+                [else
+                  (let ([msg (format "Unit takes ~s imports, given ~s"
+                               (length imports) (length partial-import-list))])
+                    (if (zodiac:parsed? expr)
+                      (mrspidey:warning msg expr 0)
+                      (mrspidey:warning msg)))
+                  imports])])
+        (make-atunit imports exports result expr))]
+    [(? Tvar? tvar-u)
+      (for-each-with-n
+        (match-lambda*
+          [((ftype . _) n)
+            (new-con! tvar-u
+              (create-con (get-unit-import-template n)
+                0 (FlowType->Tvar ftype) #f))])
+        partial-import-list)
+      tvar-u]))
+
+;; ----------------------------------------------------------------------
+
+(define (atlunit->atunit atlunit) 
+  ;; returns atunit
+  (apply-atlunit atlunit #f))
+
+(define gatlunit (void))
+
+(define (apply-atlunit atlunit partial-import-list)
+  (: partial-import-list (listof (cons (union FlowType false) num)))
+  ;; (returns atunit)
+  (set! gatlunit atlunit)
+  (match atlunit
+    [(and atlunit ($ atlunit ui))
+      (assert (or (eq? ui #f) (atunit? ui)))
+      (when (and ui partial-import-list)
+        (pretty-debug-unit `(ui ,ui partial-import-list ,partial-import-list))
+        (mrspidey:error 
+          "Annotated lazy unit invoked more than once"
+          (match atlunit
+            [($ atlunit-unit _ _ exp) exp]
+            [($ atlunit-cmpd _ exp) exp]
+            [($ atlunit-reference _ exp) exp])))
+      (or ui
+        (let* ( [fn
+                  (cond
+                    [(atlunit-unit? atlunit)  apply-atlunit-unit]
+                    [(atlunit-cmpd? atlunit)  apply-atlunit-cmpd]
+                    [(atlunit-reference? atlunit) apply-atlunit-reference]
+                    [else (mrspidey:internal-error
+                            'apply-atlunit->atunit "Not a lazy unit")])]
+                [ui (fn atlunit partial-import-list)])
+          (set-atlunit-ui! atlunit ui)
+          ui))]))
+
+;; ----------------------------------------------------------------------
+
+(define (apply-atlunit-unit atlunit partial-import-list)
+  (match atlunit
+    [($ atlunit-unit _ env 
+        (and unit-exp ($ zodiac:unit-form _ s _ _ imports exports body)))
+     (pretty-debug-unit
+      `(apply-atlunit-unit
+        ,(zodiac:stripper unit-exp)
+        ,(and partial-import-list
+              (map FlowType->pretty (map car partial-import-list))))
+      7)
+
+     (let*-vals
+       ( [free-names (zodiac:free-vars-defs body)]
+         [free-names2 (setdiff2 free-names imports)]
+         [init-env (get-default-bindings free-names2)]
+         [env1 (cond
+                 [(eq? partial-import-list #f) init-env]
+                 [(not (= (length imports) (length partial-import-list)))
+                   (mrspidey:error 
+                     (format 
+                       "Bad number of imports for unit, expected ~s, given ~s"
+                       (length imports)
+                       (length partial-import-list)))]
+                 [else (foldr2
+                         (lambda (name ftype env)
+                           (if ftype
+                             (atenv:extend env name ftype)
+                             env))
+                         init-env
+                         imports
+                         (map car partial-import-list))])]
+         [(env2 refs result) (traverse-defs body env1)]
+         ;;[_ (pretty-print `(env2 ,(atenv->pretty env2)))]
+         [env3 (atenv:unflush (atenv:flush! env2))]
+         ;;[_ (pretty-print `(env3 ,(atenv->pretty env2)))]
+         [exports 
+           (map 
+             (match-lambda
+               [(lvr . z-sym)
+                 (let* ( [binding (zodiac:varref-binding lvr)]
+                         [ftype (atenv:lookup env3 binding)]
+                         [_ (assert (FlowType? ftype) 'atlunit-unit->atunit 
+                              binding)]
+                         [ftype (link-parsed-ftype! lvr ftype)])
+                   (cons (zodiac:read-object z-sym) ftype))])
+             exports)]
+         [imports
+           (map (lambda (name)
+                  (cons (zodiac:binding-var name)
+                    (filter-map
+                      (match-lambda
+                        [(name2 . tvar)
+                          (and (eq? name name2) tvar)])
+                      refs)))
+             imports)])
+       (make-atunit imports exports result unit-exp))]))
+
+;; ----------------------------------------------------------------------
+
+(define (apply-atlunit-cmpd atlunit partial-import-list)
+  (match atlunit
+    [($ atlunit-cmpd _
+       (and cmpd-unit
+         ($ zodiac:compound-unit-form _ start _ _ 
+           import-bindings links exports))
+       times ftype*)
+      (: import-bindings (listof zodiac:lexical-binding))
+      (: links
+        (listof (list sym zodiac:parsed (listof (cons (union sym #f) sym)))))
+      (: times (listof num))
+      (: ftype* (listof FlowType))
+      (: exports (listof (list sym sym sym)))
+    
+      (pretty-debug-unit
+        `(apply-atlunit-cmpd
+           ,(map zodiac:binding-orig-name import-bindings)
+           ,(zodiac:stripper cmpd-unit)
+           ,(map FlowType->pretty ftype*)
+           ,exports
+           ,(and partial-import-list
+              (map FlowType->pretty (map car partial-import-list)))))
+
+      (letrec*
+        ( [time-N (zodiac-time cmpd-unit)]
+          [saved-refs '()]              ; forward refs and refs to some imports
+          [imports (map zodiac:binding-orig-name import-bindings)]
+          [import-env 
+            (cond
+              [(eq? partial-import-list #f) '()]
+              [(not (= (length imports) (length partial-import-list)))
+                (mrspidey:warning 
+                  (format "Compound-unit requires ~s imports, given ~s"
+                    (length imports) (length partial-import-list))
+                  start 0)
+                '()]
+              [else 
+                (map
+                  (lambda (import-binding import ftype-time)
+                    (let* ( [ftype (car ftype-time)]
+                            [_ (assert (FlowType? ftype) 'atlunit-3 ftype)]
+                            [ftype (link-parsed-ftype! import-binding ftype)]
+                            [ftype-time (cons ftype (cdr ftype-time))])
+                      (cons import ftype-time)))
+                  import-bindings
+                  imports
+                  partial-import-list)])]
+          [import-refs (make-vector (length imports) '())]
+          [access-import
+            (lambda (sym)
+              (match (lookup-or-fail import-env sym (lambda () (cons #f 0)))
+                [(ftype . itime)
+                  (values
+                    (or ftype
+                      (let ([tvar (mk-Tvar 'get-export)]
+                             [n (index imports sym)])
+                        (if n 
+                          (vector-set! import-refs n
+                            (cons tvar (vector-ref import-refs n)))
+                          (mrspidey:warning
+                            (format
+                              "Symbol ~s not in import list of compound-unit" 
+                              sym)
+                            (zodiac:zodiac-start cmpd-unit) 7))
+                        tvar))
+                    (max time-N itime))]))]
+          ;; alist of tags and function to access exports
+          [tag->access (list (cons #f access-import))]
+          [tag.sym->ftype.time
+            (lambda (tag sym)
+              (assert (or (not tag) (symbol? tag)) tag 'tag.sym->ftype.time2)
+              (assert (symbol? sym) sym 'tag.sym->ftype.time2)
+              (match (lookup-or-#f tag->access tag)
+                [(? procedure? access) (access sym)]
+                [#f (let ([tvar (mk-Tvar 'forward-get-export)])
+                      (set! saved-refs (cons (list tag sym tvar) saved-refs))
+                      (values tvar time-N))]))]
+          [last-invoked-unit #f]
+          [_ 
+            (for-each
+              (lambda (link time-U ftype)
+                (match-let*
+                  ( [(tag _ . i*) link]
+                    ;; [_ (pretty-print `(i* ,i* tag ,tag link ,link))]
+                    ;; tag is not a zodiac:parsed, so cant hang type off it
+                    ;; [ftype (link-parsed-ftype! tag ftype)]
+                    [tag (zodiac:read-object tag)]
+                    ;; Figure out imports
+                    [import-ftype.times
+                      (map 
+                        (lambda (i)
+                          (let*-vals
+                            ([(tag sym)
+                               (match i
+                                 [(tag . sym) 
+                                   (values
+                                     (zodiac:read-object tag)
+                                     (zodiac:read-object sym))]
+                                 [($ zodiac:lexical-varref)
+                                   (values #f 
+                                     (zodiac:binding-orig-name
+                                       (zodiac:varref-binding i)))])]
+                              [_ (assert (or (not tag) (symbol? tag)) 1)]
+                              [(ftype itime) (tag.sym->ftype.time tag sym)]
+                              ;;#[ftype (link-parsed-ftype! i ftype)]
+                              )
+                            (cons ftype itime)))
+                        i*)]
+                    [time-export (apply max time-N time-U
+                                   (map cdr import-ftype.times))]
+                    [_ (pretty-debug-unit
+                         `(apply-atlunit-cmpd 
+                            invoking ,tag ,ftype ,import-ftype.times))]
+                    [invoked-unit (apply-unit ftype import-ftype.times)]
+                    [_ (pretty-debug-unit
+                         `(apply-atlunit-cmpd result tag ,tag ,invoked-unit))]
+                    [_ (set! last-invoked-unit invoked-unit)]
+                    [access-exports
+                      (match invoked-unit
+                        [($ atunit imports exports)
+                          (lambda (sym)
+                            (match (lookup-or-#f exports sym)
+                              [#f (mrspidey:warning
+                                    (format 
+                                      "Exported var ~s not in unit tagged ~s in compound-unit" 
+                                      sym tag)
+                                    cmpd-unit 9)
+                                (values (mk-tvar-void) 0)]
+                              [ftype (values ftype time-export)]))]
+                        [(? Tvar? tvar-u)
+                          (lambda (sym)
+                            (let ([tvar (mk-Tvar 'get-export)])
+                              (new-con! tvar-u 
+                                (create-con (get-unit-export-template sym)
+                                  0 tvar #t))
+                              (values tvar time-export)))])])
+
+                  (set! tag->access (cons (cons tag access-exports) tag->access))
+                  (set! saved-refs
+                    (filter
+                      (match-lambda
+                        [(tag2 sym tvar)
+                          (if (eq? tag tag2)
+                            (let-values ([(ftype _) (access-exports sym)])
+                              (new-edge! (FlowType->Tvar ftype) tvar)
+                              #f)
+                            #t)])
+                      saved-refs))))
+              links times ftype*)]
+
+          [unit-imports (map cons imports (vector->list import-refs))]
+          [unit-exports 
+            (map 
+              (match-lambda
+                [(and export (tag id . e-id))
+                  (let*-vals
+                    ([(ftype _) 
+                       (tag.sym->ftype.time 
+                         (zodiac:read-object tag)
+                         (zodiac:read-object id))]
+                      ;;#[ftype (link-parsed-ftype! export ftype)]
+                      )
+                    (cons (zodiac:read-object e-id) ftype))])
+              exports)]
+          [result
+            (match last-invoked-unit
+              [#f (wrap-value (mk-tvar-void))]
+              [($ atunit _ _ result) result]
+              [(? Tvar? tvar-u)
+                (let ([tvar (mk-Tvar 'cmpd-unit-result)])
+                  (new-con! tvar-u (create-con template-unit 0 tvar #t))
+                  tvar)])])
+
+        (make-atunit unit-imports
+          unit-exports
+          result
+          cmpd-unit))]))
+
+;; ----------------------------------------------------------------------
+(define regenerating-ftype (void))
+
+(define (apply-atlunit-reference atlunit partial-import-list)
+  (match atlunit
+    [($ atlunit-reference _ 
+       (and N ($ zodiac:reference-unit-form _ _ _ _ file kind)))
+
+      (pretty-debug-unit 
+        `(apply-atlunit-reference
+           ,(zodiac:location-line (zodiac:zodiac-start N))
+           pil ,(pretty-partial-import-list partial-import-list)))
+
+        (let*-vals
+          ( [_ (unless (zodiac:string? file)
+                 (mrspidey:error
+                   "reference-unit requires a string argument, given ~s"
+                   file))]
+            [file (zodiac:read-object file)]
+            [path+file
+              (if (relative-path? file)
+                (build-path (current-directory) file)
+                file)]
+            [file-directory (path-only path+file)]
+            [(_ file _) (split-path path+file)]
+            [za (regexp-replace ".ss$" file ".za")]
+            [_ (when (eq? za file) 
+                 (mrspidey:error
+                   (format "Invalid extension on ~s, requires .ss"
+                     file)))]
+            [t-N (zodiac-time* N)]
+            [za (case (st:save-za-in)
+                  [(source-directory)
+                    (build-path file-directory za)]
+                  [(tmp-directory) 
+                    (build-path 
+                      (wx:find-path 'temp-dir)
+                      (file-name-from-path za))])]
+            [t-za (file-modify-seconds za)]
+            
+            ;; restrict imports to prims, closed schemas, and atstructs
+            [partial-import-list-restricted
+              (and partial-import-list
+                (map
+                  (match-lambda
+                    [(ftype . itime)
+                      (cons
+                        (and (fo-FlowType? ftype)
+                          (match (fo-FlowType-def ftype)
+                            [(or ($ schema _ _ ()) (? atprim?) (? atstruct?))
+                              ftype]
+                            [_ #f]))
+                        itime)])
+                  partial-import-list))]
+            [_ (pretty-debug-unit 
+                 `(pil-restricted 
+                    ,(pretty-partial-import-list
+                       partial-import-list-restricted)))]
+
+            [port-for-included-unit
+              (lambda ()
+                (dynamic-let ([current-directory file-directory])
+                  (open-code-file file)))]
+
+            [traverse-included-unit
+              ;; (zodiac:parsed -> (union atunit atlunit))
+              (lambda ()
+                (let*-vals
+                  ([_ (mrspidey:progress 
+                        (format "Analyzing referenced unit ~a" file))]
+                    [_ (extend-file-time-cache! path+file t-N)]
+                    [exps (zodiac:read* (port-for-included-unit) path+file)]
+                    [(parsed-exps free-names) 
+                      (dynamic-let
+                        ([current-directory file-directory])
+                        (my-scheme-expand-program exps))]
+                    [_ (unless (= (length parsed-exps) 1)
+                         (mrspidey:error 
+                           (format
+                             "reference-unit file ~s not a single exp" 
+                             path+file)))]
+                    [parsed-exp (car parsed-exps)]
+                    [_ (pretty-debug
+                         `(traverse-included-unit
+                            ,(zodiac:stripper parsed-exp)))]
+                    [gtr global-tref-env]
+                    [gtd global-tdef-env]
+                    [gtb global-tbang-env]
+                    [init-env (get-default-bindings free-names)]
+                    [(ftype env refs) (traverse-exp parsed-exp init-env)]
+                    [ftype (extract-1st-value ftype)]
+                    [ftype 
+                      (case kind
+                        [(exp) ftype]
+                        [(imp) (create-fo-FlowType
+                                 (apply-unit ftype
+                                   partial-import-list-restricted))])]
+                    [savable-ftype (make-savable-ftype ftype)]
+                    [atunit (FlowType->Atype savable-ftype)]
+                    [_ (unless (atunit? atunit)
+                         (mrspidey:error 
+                           (format 
+                             "reference-unit file did not produce an annotated unit ~s"
+                             atunit)
+                           N))]
+                    [nu-tref (get-prefix global-tref-env gtr)]
+                    [nu-tdef (get-prefix global-tdef-env gtd)]
+                    [nu-tbang (get-prefix global-tbang-env gtb)]
+                    )
+                  (init-global-tenv! gtr gtd gtb)
+                  (pretty-debug-unit `(nu-tbang ,nu-tbang))
+                  (for-each 
+                    (match-lambda 
+                      [(binding . _)
+                        (mrspidey:warning 
+                          (format
+                            "Unit refs imported var ~s of enclosing unit"
+                            (zodiac:binding-orig-name binding)))])
+                    refs) 
+                  (values
+                    exps parsed-exp
+                    savable-ftype nu-tref nu-tdef nu-tbang)))]
+
+            [l-start list-ftype]
+            [(ftype tref tdef tbang regenerate)
+              (if (and (st:unit-read-za) t-za (< t-N t-za))
+
+                ;; ------
+                ;; Just load from the file for delta-min
+                (let*-vals
+                  ( [s (format "Loading ~a" (file-name-from-path za))]
+                    [_ (mrspidey:progress s '...)]
+                    [(delta-min tref tdef tbang) (read-za za)]
+                    [_ (mrspidey:progress s 'done)])
+
+                  (values delta-min tref tdef tbang traverse-included-unit))
+
+                ;; ------
+                ;; Regenerate
+                (let*-vals 
+                  ( [separate-S
+                      (and 
+                        (st:unit-separate-S)
+                        (not (memq (st:unit-simplify) '(none nonempty))))]
+                    [s "Saving kernel state:"]
+                    [kernel-state 
+                      (when separate-S 
+                        (begin
+                          (mrspidey:progress s '...)
+                          (begin0
+                            (save-kernel-state)
+                            (init-kernel!)
+                            (mrspidey:progress s 'done))))]
+                    [l2 list-ftype]
+                    [(exps parsed-exp ftype nu-tref nu-tdef nu-tbang)
+                      ;; we don't consider indirectly included files
+                      ;; to be included
+                      (parameterize ([record-analyzed-file-hook
+                                       (lambda (filename . _)
+                                         (void))])
+                        (traverse-included-unit))]
+                    [l1 list-ftype]
+                    ;;[_ (close-constraints (filter Tvar? (get-prefix l1 l2)))]
+                    [E (append 
+                         (savable-ftype-external-vars ftype)
+                         (map cdr nu-tref)
+                         (map cdr nu-tdef)
+                         (map cdr nu-tbang))]
+                    [_ (pretty-debug-unit
+                         `(external vars 
+                            ,(map FlowType-name E)
+                            ,(FlowType-name ftype)
+                            ,(map FlowType-name 
+                               (savable-ftype-external-vars ftype))
+                            ,(map FlowType-name (map cdr nu-tref))
+                            ,(map FlowType-name (map cdr nu-tdef))
+                            ,(map FlowType-name (map cdr nu-tbang))))]
+
+                    ;;[_ (show-stat-small)]
+                    ;; Restore state
+                    [s "Restoring kernel state"]
+                    [new-kernel-state
+                      (when separate-S 
+                        (mrspidey:progress s '...)
+                        (begin0
+                          (save-kernel-state)
+                          (restore-kernel-state! kernel-state)
+                          (mrspidey:progress s 'done)))]
+
+                    [s "Simplifying constraints"]
+                    [_ (mrspidey:progress s '...)]
+                    [l3 list-ftype]
+                    [(list-tvar tvar->nu) 
+                      (minimize-constraints-&-compare
+                        (st:unit-simplify) E E l1 l2)]
+                    [_ (mrspidey:progress s 'done)]
+
+                    ;; debugging test
+                    [_ '(mrspidey:progress "debugging-test" '...)]
+                    [_ '(check-unreachable
+                         (get-prefix l1 l2)
+                         (get-prefix list-ftype l3))]
+                    [_ '(really-check-kernel-ok)]
+                    [_ '(mrspidey:progress "debugging-test" 'done)]
+
+
+                    [ftype2 (update-ftype ftype tvar->nu)]
+                    [upd-binding 
+                      (match-lambda
+                        [(sym . tvar) (cons sym (tvar->nu tvar))])]
+                    [upd-tref (map upd-binding nu-tref)]
+                    [upd-tdef (map upd-binding nu-tdef)]
+                    [upd-tbang (map upd-binding nu-tbang)])
+
+                  (when separate-S
+                    (when (st:zero-old-constraint-sets)
+                      (free-kernel-state! new-kernel-state))
+                    (when (st:zero-old-asts)
+                      (zodiac:zero! exps)
+                      (zodiac:zero! parsed-exp)))
+                  ;;(show-stat-small)
+
+                  ;; Stuff to save in list-tvar, ftype2, 
+                  ;; upd-tref, upd-tdef, upd-tbang
+
+                  (when (st:unit-write-za)
+                    (write-za
+                      za list-tvar ftype2
+                      upd-tref upd-tdef upd-tbang))
+
+                  (values ftype2 upd-tref upd-tdef upd-tbang
+                    (if separate-S
+                      traverse-included-unit
+                      (lambda () 
+                        (values 
+                          exps parsed-exp
+                          ftype nu-tref nu-tdef nu-tbang))))))]
+            [_ (ok-ftype ftype)]
+            [l-end list-ftype]
+            [_
+              ;; Mark new ftypes as from .za file
+              (for-each
+                (lambda (ftype)
+                  (set-FlowType-type-annotation! ftype path+file))
+                (get-prefix l-end l-start))]
+            [atunit (apply-unit ftype partial-import-list)])
+
+          (pretty-debug-unit `(tbang ,tbang))
+                  
+          (begin
+            (for-each (match-lambda [(s . t) (add-global-tref! s t)]) tref)
+            (for-each (match-lambda [(s . t) (add-global-tdef! s t)]) tdef)
+            (for-each (match-lambda [(s . t) (add-global-tbang! s t)]) tbang))
+
+          (ok-ftype ftype)
+
+          (record-analyzed-file 
+            path+file
+            (lambda () (port-for-included-unit))
+            (lambda ()
+              (set! regenerating-ftype ftype)
+              (ok-ftype ftype)
+              
+              (let*-vals 
+                ( [s (format "Regenerating included unit ~a" 
+                       (file-name-from-path file))]
+                  [_ (mrspidey:progress s)]
+                  [(exps parsed-exp ftype2 tref2 tdef2 tbang2) 
+                    ((lambda () (regenerate)))])
+                (ok-ftype ftype)
+                (flow-d! ftype2 ftype)
+                (flow-e! tdef2 tdef)
+                (flow-e! tbang2 tbang)
+                (flow-e! tref tref2)
+                (list parsed-exp))))
+
+          (unless (atunit? atunit)
+            (mrspidey:error 
+              (format
+                "reference-unit file did not produce an annotated unit ~s" 
+                atunit)))
+
+          atunit)]))
+ 
+;; ----------------------------------------------------------------------
+
+(define (make-savable-ftype ftype)
+  ;; Converts an ftype to a "savable" ftype
+  ;; ie a tvar, a closed schema, a primitive, an atstruct
+  ;; or an atunit with savable exports and result
+  ;; atvalues could also be made savable, if there is any need
+  (if (Tvar? ftype)
+      ftype
+      (match (fo-FlowType-def ftype)
+        [($ schema tvar tvar* '()) ftype]
+        [($ atunit imports exports result exp)
+         (create-fo-FlowType
+          (make-atunit imports
+                       (map (match-lambda
+                             [(sym . ftype) 
+                              (cons sym (make-savable-ftype ftype))])
+                            exports)
+                       (make-savable-ftype result)
+                       exp))]
+        [(and atlunit ($ atlunit)) 
+         (make-savable-ftype (create-fo-FlowType (atlunit->atunit atlunit)))]
+        [(and pi ($ atprim name type)) ftype]
+        [(? atstruct?) ftype]
+        [_ (FlowType->Tvar ftype)])))
+
+;; --------------------
+        
+(define (savable-ftype-external-vars ftype)
+  (if (Tvar? ftype)
+      (list ftype)
+      (match (fo-FlowType-def ftype)
+        [($ schema tvar tvar* '()) (list tvar)]
+        [($ atprim) '()]
+        [($ atunit imports exports result exp)
+         (apply append 
+                (append (map cdr imports)
+                        (map savable-ftype-external-vars (map cdr exports))
+                        (list (savable-ftype-external-vars result))))]
+        [($ atstruct) '()]
+        [x (mrspidey:internal-error 'savable-ftype-external-vars
+                                    "Bad Atype ~s" x)])))
+
+;; --------------------
+
+(define (update-ftype ftype tvar->nu)
+  ;; Creates a copy of ftype with new type variables
+  (if (Tvar? ftype)
+      (tvar->nu ftype)
+      (create-fo-FlowType
+       (match (fo-FlowType-def ftype)
+         [($ schema tvar tvar* '())
+          (make-schema (tvar->nu tvar) (filter-map tvar->nu tvar*) '())]
+         [(? atprim? atprim) atprim]
+         [($ atunit imports exports result exp)
+          (make-atunit
+           (map (match-lambda
+                 [(sym . tvar*) (cons sym (map tvar->nu tvar*))])
+                imports)
+           (map (match-lambda
+                 [(sym . ftype) 
+                  (cons sym (update-ftype ftype tvar->nu))])
+                exports)
+            (update-ftype result tvar->nu)
+            exp)]
+         [(? atstruct? atstruct) atstruct]))))
+
+;; --------------------
+        
+(define (flow-d! ftype2 ftype)
+  (let ([E2 (savable-ftype-external-vars ftype2)]
+        [E  (savable-ftype-external-vars ftype)])
+    (pretty-debug-unit
+      `(E ,(map FlowType-name E) E2 ,(map FlowType-name E2)))
+    (unless (= (length E) (length E2))
+      (mrspidey:error
+        (format "The .za file is incompatible, and may be of date (~s ~s)"
+          (length E) (length E2))))
+    (for-each new-bidir-edge! E E2)))
+
+;; --------------------
+
+(define (ok-ftype ftype)
+  (pretty-debug-unit `(ok-ftype ,(FlowType-name ftype)))
+  (let ([E  (savable-ftype-external-vars ftype)])
+    (pretty-debug-unit `(E ,(map FlowType-name E)))
+    (for-each
+      (lambda (tvar)
+        (assert (list? (FlowType-arrowto tvar)) 
+          'ok-ftype (FlowType-num ftype)))
+      E)))
+
+;; --------------------
+        
+(define (flow-e! env env2)
+    (assert (= (length env) (length env2)) 'flow-e! env env2)
+    (for-each new-bidir-edge! (map cdr env) (map cdr env2)))
+
+;; ----------------------------------------------------------------------
+
+;(trace apply-unit)
+;(trace apply-atlunit)
+;(trace apply-atlunit-unit)
+;(trace apply-atlunit-cmpd)
+;(trace apply-atlunit-reference)
+;(trace atlunit->atunit)
diff --git a/collects/mrspidey/Sba/atype.ss b/collects/mrspidey/Sba/atype.ss
new file mode 100644
index 0000000..ff89dc2
--- /dev/null
+++ b/collects/mrspidey/Sba/atype.ss
@@ -0,0 +1,343 @@
+;; atype.ss - handles annotated types
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; ----------------------------------------------------------------------
+;; FlowType      - expr, edgeto, edgefrom, type-annotation
+;; Tvar          - sub-structure of FlowType, is type variable
+;; fo-FlowType   - FlowType with def field containing fo-Atype
+;; fo-Atype      - atprim etc, see below
+;; Atype         - Tvar or fo-Atype
+;; ----------------------------------------------------------------------
+
+(define-const-typed-structure (fo-FlowType struct:FlowType)
+  ( (: def fo-Atype)
+    (: tvar Tvar)))
+
+(define (FlowType->Atype ftype)
+  (cond
+    [(Tvar? ftype) ftype]
+    [(fo-FlowType? ftype) (fo-FlowType-def ftype)]
+    [else
+      (mrspidey:internal-error 'FlowType->Atype "Bad ftype ~s" ftype)]))
+
+(define (create-fo-FlowType fo-atype)
+  (assert (fo-Atype? fo-atype) 'create-fo-FlowType fo-atype)
+  (if (and 
+        (not (st:use-fo-ftype))
+        (or
+          (atconst? fo-atype)
+          (and (atvalues? fo-atype)
+            (andmap Tvar? (atvalues-values fo-atype)))))
+    (Atype->Tvar fo-atype)
+    (add-FlowType! 
+      (make-fo-FlowType num-ftype #f '() '() #f '() #f fo-atype #f))))
+  
+;; ----------
+
+(define-type fo-Atype
+  (union atconst schema atprim atthunk atstruct atvalues
+         atunit atlunit))
+
+(define (fo-Atype? x)
+  (or (atconst? x) 
+      (schema? x)
+      (atprim? x)
+      (atthunk? x)
+      (atstruct? x)
+      (atvalues? x)
+      (atunit? x)
+      (atlunit? x)))
+
+(define (poly-atype? x)
+  (or (schema? x)
+      (atthunk? x)))
+
+;; --------------------
+;; atconst
+
+(define-const-typed-structure
+  atconst ((: c (union num bool))))
+
+;; --------------------
+;; schema
+
+(define-const-typed-structure
+  schema ((: tvar Tvar)
+          (: tvar* (listof Tvar))
+          (: edges (listof (cons Tvar Tvar)))))
+
+;; --------------------
+;; atprim
+
+(define-const-typed-structure
+  atprim ((: sym sym)
+           (: type sexp)
+           (: domain-filters (listof filter))
+           predicate-fn
+           attrs
+           orig-type
+           ))
+
+;; filter-domains is a list of filters for various args,
+;; if no error raised
+;; inj-predicate is a fn : list-tvar x list-tvar x tvar x bool -> Tvar 
+;; used for (if (pred ... x ...) ...)
+
+;; --------------------
+;; atthunk
+
+(define-const-typed-structure
+  atthunk ((: thunk (-> FlowType))))
+
+;; --------------------
+;; atstruct
+
+(define-const-typed-structure
+  atstruct ((: struct:sym sym)
+            (: super-constructors (listof sym))
+            parent-gen-args
+            parent-match-args
+            parent-field-types
+            parent-list-mutable))
+
+;; ----------------------------------------------------------------------
+;; atvalues
+
+(define-const-typed-structure
+  atvalues ((: values (listof FlowType))))
+
+(define (wrap-value x) 
+  (let* ([ftype (cond 
+                  [(FlowType? x) x]
+                  [(fo-Atype? x) (create-fo-FlowType x)]
+                  [else (mrspidey:internal-error 
+                          'wrap-value "Bad x ~s" x)])]
+          [ftype (if (or (FlowType-expr ftype)
+                         (FlowType-values-ftype ftype))
+                   (copy-ftype ftype)
+                   ftype)]
+          [r (create-fo-FlowType (make-atvalues (list ftype)))])
+    (set-FlowType-values-ftype! ftype r)
+    (pretty-debug-atype
+      `(wrap-value ,(FlowType-name ftype) ,(FlowType-name r)))
+    r))
+
+(define (extract-1st-value ftype)
+  (car (multiple-value-components ftype 1)))
+
+(define (multiple-value-components ftype n)
+  ;; returns list of n value components
+  (assert (integer? n) 'multiple-value-components)
+  (cond
+   [(zero? n) '()]
+   [(fo-FlowType? ftype)
+    (match (fo-FlowType-def ftype)
+      [($ atvalues l) 
+       (recur loop ([n n][l l])
+         (cond [(zero? n) '()]
+               [(null? l) (cons (mk-tvar-empty) (loop (sub1 n) '()))]
+               [else (let* ( [a (car l)]
+                             [b (copy-ftype a) ])
+                       ;(if (FlowType-expr a) (copy-ftype a) a)
+                       (when need-explanation (add-FlowType-arrow! ftype b))
+                       (cons b (loop (sub1 n) (cdr l))))]))]
+      [_ #f])]
+   [else
+     (let ( [tvar-mv (FlowType->Tvar ftype)]
+            [tvar (mk-Tvar 'get-mvalues)])
+       (new-con! tvar-mv (create-con template-mvalues 0 tvar #t))
+       (recur loop ([tvar tvar][n n])
+         (let ([a (mk-Tvar 'car-value)])
+           (new-con! tvar (make-con-car a))
+           (when need-explanation (add-FlowType-arrow! tvar-mv a))
+           (cons a
+             (if (= n 1)
+               '()
+               (let ([d (mk-Tvar 'cdr-value)])
+                 (new-con! tvar (make-con-cdr d))
+                 (loop d (sub1 n))))))))]))
+
+;; ----------------------------------------------------------------------
+;; Annotated (lazy) unit types
+
+(define-const-typed-structure
+  atunit
+  ((: imports (listof (cons sym (listof Tvar))))
+   (: exports (listof (cons sym FlowType)))
+   (: result FlowType)
+   (: expr zodiac:parsed)))
+
+(define-const-typed-structure
+  atlunit ((! ui (union false atunit))))
+
+;; ----------------------------------------------------------------------
+
+;; (: FlowType->Tvar (FlowType -> Tvar))
+
+(define (FlowType->Tvar ftype)
+  (let ([tvar
+          (cond
+            [(Tvar? ftype) ftype]
+            [(fo-FlowType? ftype)
+              (or (fo-FlowType-tvar ftype)
+                (let ([tvar (Atype->Tvar (fo-FlowType-def ftype))])
+                  (when need-explanation (add-FlowType-arrow! ftype tvar))
+                  ;(set-fo-FlowType-tvar! ftype tvar)
+                  tvar))]
+            [else
+              (mrspidey:internal-error 'FlowType->Tvar "Bad FlowType ~s" ftype)])])
+    (pretty-debug-atype
+      `(FlowType->Tvar ,(FlowType-name ftype) ,(Tvar-name tvar)))
+    tvar
+))
+
+(define Atype->Tvar 
+  (lambda (atype)
+    (let ([tvar
+            (match atype
+              [(? Tvar? tvar) tvar]
+              [($ atconst c)
+                (let ([tvar (mk-Tvar 'atconst->tvar)])
+                  (new-AV! tvar (traverse-const-exact c))
+                  tvar)]
+              [($ atstruct) (mk-tvar-void)]
+              [($ atthunk thunk) (thunk)]
+              [(and pi ($ atprim name type))
+                (let ([tvar (mk-Tvar name)])
+                  (tschema->con type tvar name pi)
+                  tvar)]
+              [($ schema tvar tvar* edges)
+                (copy-constraint-set tvar tvar* edges)]
+              [($ atunit imports exports result)
+                (pretty-debug-atype
+                  `(Atype->Tvar (atunit ,imports ,exports ,result)))
+                (let ([tvar-u (mk-Tvar 'inst-unit)])
+                  (for-each-with-n
+                    (lambda (import n)
+                      (map (lambda (tvar)
+                             (new-AV! tvar-u
+                               (create-AV (get-unit-import-template n)
+                                 '() (vector) (vector tvar))))
+                        (cdr import)))
+                    imports)
+                  (for-each
+                    (match-lambda
+                      [(sym . ftype)
+                        (new-AV! tvar-u
+                          (create-AV (get-unit-export-template sym)
+                            '() (vector (FlowType->Tvar ftype)) (vector)))])
+                    exports)
+                  (new-AV! tvar-u
+                    (create-AV template-unit '() 
+                      (vector (FlowType->Tvar result)) 
+                      (vector)))
+                  tvar-u)]
+              [(and atlunit ($ atlunit))
+                (Atype->Tvar (atlunit->atunit atlunit))]
+              [($ atvalues ftype*)
+                (let ([tvar-list
+                        (foldr
+                          (lambda (ftype tvar-rest)
+                            (let* ([tvar (mk-Tvar 'atvalues->tvar)])
+                              (new-AV! tvar 
+                                (make-AV-cons (FlowType->Tvar ftype)
+                                  tvar-rest))
+                              tvar))
+                          (mk-tvar-nil)
+                          ftype*)]
+                       [tvar (mk-Tvar 'atvalues->values)])
+                  (new-AV! tvar 
+                    (create-AV template-mvalues '() 
+                      (vector tvar-list) (vector)))
+                  tvar)]
+              [x (mrspidey:internal-error 'Atype->Tvar "Bad Atype ~s" x)])])
+      (pretty-debug-atype
+        `(atype->tvar ,(Atype->pretty atype) ,(Tvar-name tvar)))
+      tvar)))
+
+;; ----------------------------------------------------------------------
+
+(define FlowType->pretty
+  (lambda (ftype)
+    (cond
+     [(Tvar? ftype) (Tvar-name ftype)]
+     [(fo-FlowType? ftype)
+       (Atype->pretty (fo-FlowType-def ftype))])))
+
+(define Atype->pretty
+  (match-lambda
+    [($ atconst c) `(const ,c)]
+    [($ atthunk thunk) 'thunk]
+    [(and pi ($ atprim name _ _ _ attrs type)) `(prim ,name ,type)]
+    [($ schema tvar tvar* edges) 
+      `(schema ,(Tvar-name tvar) ,(map Tvar-name tvar*))]
+    [($ atunit imports exports result)
+      `(atunit 
+         (imports ,@(map (match-lambda
+                           [(sym . tvar*)
+                             (cons sym (map Tvar-name tvar*))])
+                      imports))
+         (exports ,@(map (match-lambda
+                           [(sym . ftype)
+                             (list sym (FlowType->pretty ftype))])
+                      exports))
+         (result ,(FlowType->pretty result)))]
+    [($ atlunit thunk) `(lazy-unit)]
+    [($ atstruct A B C D E F) (list 'struct: A B C D E F)]
+    [($ atvalues ftype*) `(values ,@(map FlowType->pretty ftype*))]
+    [x
+      (mrspidey:internal-error 'Atype->pretty "Bad fo-Atype ~s" x)]))
+
+(define FlowType->SDL
+  (lambda (ftype)
+    (pretty-debug-sdl2
+      `(FlowType->SDL ,(FlowType-name ftype) ,(FlowType->pretty ftype)))
+    (cond
+     [(Tvar? ftype) (Tvar->SDL ftype)]
+     [(fo-FlowType? ftype)
+      (match (fo-FlowType-def ftype)
+        [($ atconst c) `(const ,c)]
+        [($ atthunk thunk) `(thunk ,(Tvar->SDL (thunk)))]
+        [($ atprim name _ _ _ _ type) `(prim ,type)]
+        [($ schema tvar tvar* edges) `(schema ,(Tvar->SDL tvar))]
+        [(and def ($ atunit imports exports result))
+         `(unit ,(Tvar->SDL (FlowType->Tvar ftype)))]
+        [(and ($ atlunit thunk) lui)
+         `(lazy ,(FlowType->SDL (create-fo-FlowType (atlunit->atunit lui))))]
+        [($ atstruct) 'struct:]
+        [($ atvalues (ftype)) (FlowType->SDL ftype)]
+        [($ atvalues ftype*) `(values ,@(map FlowType->SDL ftype*))]
+        [x (mrspidey:internal-error 'FlowType->SDL "Bad fo-Atype ~s" x)])]
+     [else (mrspidey:internal-error 'FlowType->SDL "Bad ftype ~s" ftype)])))
+
+(define (copy-ftype ftype)
+  (cond
+    [(Tvar? ftype)
+      (let ([tvar (mk-Tvar 'copy)])
+        (new-edge! ftype tvar)
+        tvar)]
+    [(fo-FlowType? ftype)
+      (let ([nu-ftype (create-fo-FlowType (fo-FlowType-def ftype))])
+        (when need-explanation (add-FlowType-arrow! ftype nu-ftype))
+        nu-ftype)]
+    [else (mrspidey:internal-error 'link-parsed-ftype!
+            "Bad ftype ~s, maybe old language" ftype)]))
+
+;; ----------------------------------------------------------------------
+
+
diff --git a/collects/mrspidey/Sba/checks.ss b/collects/mrspidey/Sba/checks.ss
new file mode 100644
index 0000000..c66453e
--- /dev/null
+++ b/collects/mrspidey/Sba/checks.ss
@@ -0,0 +1,716 @@
+;; smart-checks.ss - identifies unsafe operations
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+
+;;-------------------------------------------
+
+(define-struct annotation (loc))
+(define-struct (check-annotation struct:annotation) (text num rest))
+(define-struct (uncheck-annotation struct:annotation) (text))
+(define-struct (type-annotation struct:annotation) (end-first finish FlowType))
+
+;; ------------------------------
+
+(define check-annotations   '())        ; store away checks for mred
+(define uncheck-annotations '())        ; store away unchecked prims
+
+;;-------------------------------
+;; Counters
+
+(define prim-count  (void))
+(define lam-count   (void))
+(define prim-apps   (void))
+(define user-apps   (void))
+(define ivar-count  (void))
+(define type-assert-count (void))
+(define type-assert-failed-total (void))
+
+(define prim-checks-def (void))
+(define lam-checks-def  (void))
+(define ap-checks-def   (void))
+(define ivar-checks-def (void))
+(define type-assert-failed-def (void))
+
+(define total-checks (void))
+
+;; --------------------
+
+(define init-counts
+  (lambda ()
+    (set! prim-count (make-counter))
+    (set! lam-count  (make-counter))
+    (set! prim-apps  (make-counter))
+    (set! user-apps  (make-counter))
+    (set! ivar-count  (make-counter))
+    (set! type-assert-count (make-counter))
+    (set! type-assert-failed-total (make-counter))
+    (set! total-checks (make-counter))
+    (reset-counts)))
+
+;; These three count per expression 
+;; need to be reset with every definition traversed.
+
+(define reset-counts
+  (lambda ()
+    (set! prim-checks-def (make-counter))
+    (set! lam-checks-def  (make-counter))
+    (set! ap-checks-def   (make-counter))
+    (set! ivar-checks-def (make-counter))
+    (set! type-assert-failed-def (make-counter))))
+
+ (define make-counter
+   (lambda ()
+     (let ([num 0])
+       (lambda (n)
+         (set! num (+ n num))
+         num))))
+
+;; ----------------------------------------
+
+(define calc-checks
+  (lambda (defs)
+    (mrspidey:add-summary (format "CHECKS:"))
+    (init-counts)
+    (set! check-annotations   '()) 
+    (set! uncheck-annotations '()) 
+    (for-each-with-n
+     (lambda (def n)
+       (mrspidey:zprogress "Checking" (zodiac:zodiac-start def))
+       (match def
+         [($ zodiac:define-values-form _ open _ _ 
+            ($ zodiac:list _ _ _ ($ zodiac:varref _ _ _ _ sym))
+            _)
+          (reset-counts)
+          ((zodiac:compat check-fn) def)
+           ;;(make-check-summary-line sym open)
+           ]
+         [_
+          (reset-counts)
+          ((zodiac:compat check-fn) def)
+          '(make-check-summary-line 
+             (format "<expr> at line ~s" 
+               (zodiac:location-line 
+                 (zodiac:zodiac-start def)))
+             (zodiac:zodiac-start def))
+           ]))
+     defs)
+    (unless (null? defs)
+      (mrspidey:zprogress "Checking" (zodiac:zodiac-finish (rac defs))))
+    (make-check-summary "")
+    (list check-annotations uncheck-annotations)))
+
+;; ----------
+
+(define check-fn
+  (lambda (M unp)
+    (pretty-debug-check `(check-fn ,(zodiac:stripper M)))
+    (match M
+      ;; ivars
+      [($ zodiac:app _ _ _ _
+         ($ zodiac:varref _ open _ _ (and ivar-sym (or '#%uq-ivar 'uq-ivar)))
+         (obj-exp ivar-arg))
+        (=> fail)
+        (pretty-debug-check `(ivar ,ivar-sym))
+
+        ;; Check the ivar is ok
+        (let*-vals
+          ( [ftype (zodiac:parsed-ftype obj-exp)]
+            [ftype (and ftype (extract-1st-value ftype))]
+            [(tvars-ivarset-ok? set-tvar-ivarset-ok!) 
+              (alloc-Tvar-field)])
+          (letrec
+            ([check-ivarset-ok?
+               (lambda (tvar sym)
+                 (pretty-debug-check `(check-ivarset-ok? ,(Tvar-name tvar)))
+                 (set-tvar-ivarset-ok! tvar #t)
+                 (andmap
+                   (match-lambda
+                     [($ AV _ (? (lambda (t) (eq? t template-ivarset)))
+                        misc fields+)
+                       (assert (list? misc) 'ivar-check)
+                       (or 
+                         (memq sym misc)
+                         (let ([parent (vector-ref fields+ 0)])
+                           (and (not (null? (get-Tvar-objs parent)))
+                             (check-ivarset-ok? parent sym)))
+                         (begin
+                           (pretty-debug-check
+                             `(ivar-failure ,sym ,misc ,(Tvar-name tvar)))
+                           #f)
+                         )]
+                     [_ #t])
+                   (get-Tvar-objs tvar)))])
+            (if 
+              (match ivar-arg
+                [($ zodiac:quote-form _ _ _ _ ($ zodiac:symbol _ _ _ sym))
+                  (and (Tvar? ftype) (check-ivarset-ok? ftype sym))]
+                [_ #f])
+              (begin
+                (ivar-count 1)
+                (add-uncheck! open (symbol->string ivar-sym)))
+              (begin
+                (ivar-count 1)
+                (ivar-checks-def 1)
+                (mrspidey:add-summary "ivar check" open 0)
+                (add-check! open (symbol->string ivar-sym))))))
+
+        ;; Check the primitive application - NOT!
+        '(match ivar-arg
+           [($ zodiac:quote-form _ _ _ _ ($ zodiac:symbol _ open _ sym))
+             (let* ([ftype (zodiac:parsed-ftype M)])
+               (when ftype
+                 (let ([ftype (extract-1st-value ftype)])
+                   (when (Tvar? ftype)
+                     (pretty-debug-check '(ivar-tvar))
+                     (match (get-Tvar-objs ftype)
+                       [(($ AV _ (? (lambda (t) (eq? t template-lam)))
+                           (and pi ($ atprim name type))))
+                         (pretty-debug-check '(ivar-lam-AV))
+                         (case (check-prim pi (zodiac:parsed-ftype M))
+                           [(#t)
+                             (prim-count 1)
+                             (add-uncheck! open (symbol->string sym))]
+                           [(#f)
+                             (prim-count 1)
+                             (mrspidey:add-summary "Method check" open 0)
+                             (prim-checks-def 1)
+                             (add-check! open (symbol->string sym) ftype)
+                             (pretty-debug `(CHECK-fo-prim ,(zodiac:stripper M)))
+                             (zodiac:set-parsed-check! ivar-arg #t)]
+                           [(not-function-type) 
+                             (pretty-debug-check '(ivar-not-fn-type))]
+                           [(not-function-AV) (printf "ivar:not-function-AV~n")])]
+                       [_ (void)])))))]
+           [_ (void)])
+        (fail)]
+      [($ zodiac:app _ _ _ _ fn args)
+        (unless (atprim? (zodiac:parsed-atprim fn))
+          (check-ap M))
+        #f]
+      [($ zodiac:case-lambda-form) 
+       (check-lambda M)
+       #f]
+      [($ zodiac:top-level-varref)
+       (if (zodiac:parsed-atprim M)
+           (check-ho-prim M)
+           ;; Otherwise should do bound? check, but don't
+           (void))
+       #f]
+      [($ zodiac::-form)
+       (check-type-assertion M)
+       #f]
+      [_ #f])))
+
+;;-------------------------------------------
+
+(define (parsed-Tvar x) 
+  ;;(pretty-print `(parsed-Tvar ,(zodiac:stripper x)))
+  (if (zodiac:parsed-ftype x)
+    (let* ( [ftype (zodiac:parsed-ftype x)]
+            [tvar (FlowType->Tvar ftype)])
+      (pretty-debug-check
+        `(parsed-Tvar ,(zodiac:stripper x) ,(FlowType-name ftype) 
+           ,(Tvar-name tvar)))
+      tvar)
+    (mk-tvar-empty)))
+
+(define check-ap
+  (match-lambda
+    [(and app ($ zodiac:app _ open _ _ fun args))
+      (pretty-debug-check
+        `(check-ap,(zodiac:stripper fun) ,(zodiac:parsed-ftype fun)))
+      (let ([ftype-fn (zodiac:parsed-ftype fun)]) 
+        (match (and (FlowType? ftype-fn) (FlowType->Atype ftype-fn))
+          [($ atprim) (prim-apps 1)]
+          [_ (user-apps 1)]))
+      (let ([tvar (parsed-Tvar fun)])
+        (unless 
+          (or
+            (st:all-checks)
+            (Tvar-in-type? tvar 
+              '(mvalues (cons (lambda _ _) (nil)))
+              '()
+              (lambda (a)
+                (mrspidey:error 'check-ap 
+                  "Reference to unbound type var ~s" a))))
+          ;; Check the application
+          (ap-checks-def 1)
+          (mrspidey:add-summary "Application check" open 0)
+          (add-check! open "(" tvar)
+          (pretty-debug `(CHECK-ap ,(zodiac:stripper app)))
+          (zodiac:set-parsed-check! app #t)))]))
+
+(define check-lambda
+  (match-lambda
+    [(and lam ($ zodiac:case-lambda-form _ open _ _ arglists bodies))
+      (pretty-debug-check `(check-lam ,(zodiac:stripper lam)))
+      ;; put arity check on lambda 
+      (lam-count 1)
+      (let* ( [tvar (parsed-Tvar lam)]
+              [tvar (extract-1st-value tvar)])
+        (match (get-Tvar-objs tvar)
+          [(($ AV _ (? (lambda (t) (eq? t template-lam))) misc _ #(domain))
+             . _) 
+            ;; rest may be other AV-lam's for this case-lambda
+            (let* ([arglist->ilist
+                     (match-lambda
+                       [($ zodiac:sym-arglist)
+                         '_]
+                       [($ zodiac:list-arglist vars) 
+                         (map (lambda (_) '_) vars)]
+                       [($ zodiac:ilist-arglist vars)
+                         (recur loop ([vars vars])
+                           (match vars
+                             [(x) '_]
+                             [(a . b) `(_ . ,(loop b))]))])]
+                    [type
+                      (recur loop ([ilists (map arglist->ilist arglists)])
+                        (pretty-debug-check `(ilists ,ilists))
+                        (if (memq '_ ilists)
+                          '_
+                          (let ( [nils 
+                                   (filter null? ilists)]
+                                 [non-nils
+                                   (filter 
+                                     (lambda (x) (not (null? x)))
+                                     ilists)])
+                            (cond
+                              [(null? non-nils)
+                                'nil]
+                              [(null? nils) 
+                                `(cons _ ,(loop (map cdr non-nils)))]
+                              [else
+                                `(union
+                                   nil
+                                   (cons _ ,(loop (map cdr non-nils))))]))))])
+              (pretty-debug-check `(type ,type))
+                    
+              (when
+                (or
+                  (st:all-checks)
+                  (not (Tvar-in-type? 
+                         domain (expand-input-type type) '()
+                         (lambda (a)
+                           (mrspidey:internal-error 'check-lambda
+                             "unbound tvar")))))
+                ;; Check it
+                (lam-checks-def 1)
+                (mrspidey:add-summary "Arity check" open 0)
+                (add-check! open "lambda" domain)
+                (zodiac:set-parsed-check! lam #t)))]
+          [_;; never analyzed
+            (void)]))]))
+
+(define (check-ho-prim M)
+  ;; name : name-structure of prim
+  ;; open: source location for primitive
+  ;; returns correct primitive and either 1 or 0
+
+  (pretty-debug-check `(check-ho-prim ,(zodiac:stripper M)))
+
+  (match-let*
+    ( [($ zodiac:varref _ open _ _ sym) M]
+      [(and atprim ($ atprim sym tschema _ _ _)) (zodiac:parsed-atprim M)])
+
+    (match (parsed-Tvar M)
+      [(? Tvar? tvar)
+
+        (case (check-prim atprim tvar)
+          [(#t)
+            (prim-count 1)
+            (add-uncheck! open (symbol->string sym))]
+          [(#f)
+            (prim-count 1)
+            (mrspidey:add-summary (format "~s check" sym) open 0)
+            (prim-checks-def 1)
+            (add-check! open (symbol->string sym) tvar)
+            (pretty-debug `(CHECK-fo-prim ,(zodiac:stripper M)))
+            (zodiac:set-parsed-check! M #t)]
+          [(not-function-type) (void)]
+          [(not-function-AV) 
+            ;(printf "check-hoo-prim: not-function-AV~n")
+            (void)])])))
+
+;; ----------------------------------------------------------------------
+
+(define (check-prim atprim tvar)
+
+  (pretty-debug-check `(check-prim ,atprim ,(Tvar-name tvar) ))
+
+  (match (get-Tvar-objs (extract-1st-value tvar))
+    [(($ AV _ template misc _ #(domain))) 
+      (check-prim-domain atprim domain)]
+    [_ 'not-function-AV]))
+
+(define (check-prim-domain atprim domain)
+  (pretty-debug-check `(check-prim-domain ,atprim ,(Tvar-name domain) ))
+  (match-let*
+    ( [($ atprim sym tschema _ _ _) atprim]
+      [schemas (match tschema
+                 [('case-> . schemas) schemas]
+                 [schema (list schema)])])
+
+    (ormap
+      (lambda (schema)
+
+        (let-values ([(forall type) (split-schema schema)])
+          (match type
+            [('lambda expected-domain _)
+              (pretty-debug-check `(check-prim domain ,(Tvar-name domain)))
+              (if (and 
+                    (Tvar-in-type? 
+                      domain expected-domain forall
+                      (lambda (a)
+                        (mrspidey:warning
+                          (format
+                            "Reference to unbound type var ~s in domain of ho primitive ~s" 
+                            a sym))
+                        (lambda (AV) #f)))
+                    (not (st:all-checks)))
+                #t
+                (begin
+                  (pretty-debug-check 
+                    `(check-prim-domain failed on ,sym
+                       ,(FlowType-name domain)
+                       ,expected-domain))
+                  #f))]
+            [_
+              ;; Not a primitive function
+              (pretty-debug-check `(Not a prim fn ,type))
+              'not-function-type])))
+
+      schemas)))
+
+;; ----------------------------------------------------------------------
+
+(define check-type-assertion
+  (match-lambda
+   [(and M ($ zodiac::-form _ open _ _ exp type))
+    (pretty-debug-check `(check-type-assertion ,(zodiac:stripper M)))
+    (type-assert-count 1)
+    (let* ([tvar (extract-1st-value (parsed-Tvar exp))]
+           [in-type?
+            (lambda (type) 
+              (Tvar-in-type? 
+               tvar (expand-input-type type) '()
+               (lambda (a)
+                   (mrspidey:warning
+                     (format "Unbound type variable ~s" a)
+                     open 3)
+                 (lambda (AV) #f))))])
+      (unless 
+          (match type
+            [('exact type) 
+             ;; Can't do exact yet - best is nonempty
+             (and (not (null? (get-Tvar-objs tvar))) (in-type? type))]
+            [_ (in-type? type)])
+        ;; Is bad
+        (type-assert-failed-def 1)
+        (type-assert-failed-total 1)
+        (add-check! open "(")
+        (mrspidey:warning
+         (format "Type assertion ~s failed"
+                 (list ': '... ;;(zodiac:stripper exp)
+                       type))
+         (zodiac:zodiac-start M) 
+         2)))]))
+
+;; ----------------------------------------------------------------------
+
+'(define (Tvar-in-global-type? ftype type where)
+  (Tvar-in-type? 
+   Tvar 
+   (expand-input-type type)
+   (lambda (fv)
+     (lookup-or-fail 
+      global-tdef-env fv
+      (lambda ()
+        (mrspidey:error
+         (format 
+          "Reference to unbound type var ~s in ~a ~s"
+          fv where type)))))))
+
+;; ----------------------------------------------------------------------
+
+(define (add-check! open text . rest)
+  (set! check-annotations 
+      (cons (make-check-annotation open text (total-checks 0) rest)
+            check-annotations))
+  (total-checks 1))
+
+(define (add-uncheck! open text)
+  (set! uncheck-annotations 
+      (cons (make-uncheck-annotation open text) uncheck-annotations)))
+
+(define (show-checks)
+  (for-each
+   (match-lambda
+    [($ annotation ($ zodiac:location l c o f) text)
+     (printf "File: ~s offset ~s text ~s~n"
+             (file-name-from-path f) o text)])
+   check-annotations))
+
+;; ----------------------------------------------------------------------
+
+(define (file-wrapper-start outport)
+  ;; Writes prefix to file
+  ;(fprintf outport ";; Generated by SBA Soft Scheme ~a~%" st:version)
+  (fprintf outport ";; Control string ")
+  (for-each (lambda (x) (fprintf outport" '~a" x)) (mrspidey:control-fn))
+  (fprintf outport "~n~n"))
+
+(define (file-wrapper-end outport)
+  (newline outport)
+  '(for-each (lambda (s) (fprintf outport ";; ~a" s))
+             (reverse summary))
+  (void)
+  )
+
+;; ----------------------------------------------------------------------
+
+'(define (write-soft-file outfile)
+   ;; Writes soft typed file - macro expanded with checks - executable
+   (when (file-exists? outfile) (delete-file outfile))
+   (let ([outport (open-output-file outfile)])
+    
+     (file-wrapper-start outport)
+     (for-each
+      (lambda (def)
+        (pretty-print 
+         ((zodiac:unparse-dynamic-letd
+           (lambda (exp cl-fn)
+             (if (zodiac:parsed-check exp)
+                 (match exp
+                   [($ zodiac:app _ open close back fun args)
+                    `(CHECK-ap ,(cl-fn fun) ,@(map cl-fn args))]
+                   [($ zodiac:lambda-form _  open close back 
+                       args body level)
+                    (let* ([args (map-ilist cl-fn args)])
+                      `(CHECK-lambda ,args ,(cl-fn body)))]
+                   [($ zodiac:lexical-varref
+                       _ open close _
+                       ($ zodiac:bound _ _ _ _ sym) 
+                       Tvar-box)
+                    (symbol-append 'CHECK- sym)])
+                 #f)))
+          def)
+         outport)
+        (newline outport))
+      defs-bind)
+     (file-wrapper-end outport)))      
+
+;; ----------------------------------------------------------------------
+
+'(define (write-annotated-file outfile source-thunk)
+   ;; As source file, but with checks
+   (when (file-exists? outfile) (delete-file outfile))
+   (let* ([inport (source-thunk)]
+          [outport (open-output-file outfile)]
+          [checks (map
+                   (match-lambda
+                    [($ annotation loc)
+                     (cons (zodiac:location-offset loc) rest)])
+                   check-annotations)]
+          [checks (sort
+                   (match-lambda*
+                    [((ofs1 . _) (ofs2 . _)) (< ofs1 ofs2)])
+                   checks)])
+    
+     (file-wrapper-start outport)
+     (recur loop ([pos 0][checks checks])
+       (let ([c (read-char inport)])
+         (unless (eof-object? c)
+           (match checks
+             [(( (? (lambda (p) (= p pos)))
+                 num name . _) 
+               . _) 
+              (let ([to-drop
+                     (match name
+                       ["("
+                        ;; Is an application check
+                        (assert (char=? c #\())
+                        (display (format "(CHECK-ap ~s " num)
+                                 outport)
+                        ""]
+                       ["lambda"
+                           ;; Is a lambda check
+                           (assert (char=? c #\())
+                         (display (format "(CHECK-lambda ~s " num)
+                                  outport)
+                         "lambda"]
+                       [prim
+                        ;; Is a primitive check
+                        (assert (char=? c (string-ref prim 0)))
+                        (display (format "(CHECK-~a ~s)" name num)
+                                 outport)
+                        (substring prim 1 (string-length prim))])])
+                (recur loop2 ([pos (add1 pos)]
+                              [s (string->list to-drop)])
+                  (cond
+                   [(null? s) (loop pos (cdr checks))]
+                   [(char=? (read-char inport) (car s))
+                    (loop2 (add1 pos) (cdr s))]
+                   [else
+                    (error 'write-annotated-file
+                           "File not as expected")])))]
+             [_                       
+              (write-char c outport)
+              (loop (add1 pos) checks)]))))
+    
+     (close-input-port inport)
+     (file-wrapper-end outport)
+     (close-output-port outport)))
+
+;; --------------------
+
+(define make-check-summary-line
+  (lambda (name src)
+    (let ([total (+ (prim-checks-def 0) (lam-checks-def 0) 
+                    (ap-checks-def 0) (type-assert-failed-def 0))])
+      (unless (= 0 total)
+        (let* ((s (format "~a~a " (padr name 19) (padl total 3)))
+               (s (if (< 0 (prim-checks-def 0))
+                      (format "~a (~a prim)" s (prim-checks-def 0))
+                      s))
+               (s (if (< 0 (lam-checks-def 0))
+                      (format "~a (~a lambda)" s (lam-checks-def 0))
+                      s))
+               (s (if (< 0 (ap-checks-def 0))
+                      (format "~a (~a ap)" s (ap-checks-def 0))
+                      s))
+               (s (if (< 0 (type-assert-failed-def 0))
+                      (format "~a (~a type assertions)" 
+                              s (type-assert-failed-def 0))
+                      s)))
+          (mrspidey:add-summary s src 0))))))
+
+;; --------------------
+
+(define make-check-summary
+  (lambda (hdr)
+    (let* ([f (lambda (s) (mrspidey:add-summary s))]
+           [total-possible 
+            (+ (user-apps 0) (prim-count 0) (lam-count 0)
+               (type-assert-count 0))]
+           [percentage
+            (if (= 0 total-possible)
+                0
+                (string->number
+                 (chop-number
+                  (exact->inexact (* (/ (total-checks 0)
+                                        total-possible) 100))
+                  4)))])
+      
+      (f (format "~a~a~a~a" 
+                 hdr
+                 (padr "TOTAL CHECKS:" 19)
+                 (padl (total-checks 0) 3)
+                 (format "  (of ~s possible checks is ~s%)"
+                         total-possible percentage)))
+      
+      (unless (zero? (type-assert-failed-total 0))
+        (f (format "~a~a~a~a" 
+                   hdr
+                   (padr "FAILED ASSERTIONS:" 19)
+                   (padl (type-assert-failed-total 0) 3)
+                   (format "  (of ~s total type assertions)" 
+                           (type-assert-count 0)))))
+      
+      )))
+
+;;----------------------------------------------------------------------
+
+(define (calc-type-annotations defs)
+  (let* ( [type-annotations '()]
+          [locs-done-table-size 2048]
+          [locs-done-mask 2047]
+          [loc->ndx (lambda (loc)
+                      (bitwise-and (zodiac:location-offset loc)
+                        locs-done-mask))]
+          [locs-done-table (make-vector locs-done-table-size '())]
+          [fn 
+            (lambda (exp cl-fn)
+              (match exp
+                [($ zodiac:parsed origin start finish)
+                  (let* ([ftype (zodiac:parsed-ftype exp)]
+                          [end-first (zodiac:determine-end-first-token exp)])
+
+                    (pretty-debug 
+                      `(ftype ,(and (FlowType? ftype) (FlowType-name ftype))
+                         start ,(zodiac:location-offset start)))
+
+                    (when 
+                      (and
+                        (FlowType? ftype)
+                        ;;(memq (zodiac:origin-who origin) '(source reader))
+                        )
+
+                      ;; Don't add type-annotation if something else has this
+                      ;; start location
+                      (let ([ndx (loc->ndx start)])
+                        (when (not (find
+                                     (lambda (l) 
+                                       (= (zodiac:location-offset l)
+                                         (zodiac:location-offset start)))
+                                     (vector-ref locs-done-table ndx)))
+                          ;; Check FlowType points to exp
+                          (assert (or (eq? (FlowType-expr ftype) exp)
+                                    (eq? (FlowType-expr ftype) #t))
+                            'calc-type-annotation ftype
+                            (FlowType-expr ftype) exp)
+                          '(set-FlowType-expr! ftype exp)
+                          (set! type-annotations 
+                            (cons 
+                              (make-type-annotation 
+                                start end-first finish ftype) 
+                              type-annotations))
+                          (vector-set! 
+                            locs-done-table ndx
+                            (cons start (vector-ref locs-done-table ndx)))))))
+                  #f]
+                [_ #f]))])
+
+    (map-with-n
+     (lambda (exp n)
+       (begin
+         (mrspidey:zprogress "Typing" (zodiac:zodiac-start exp))
+         ((zodiac:compat fn) exp)))
+     defs)
+    (unless (null? defs)
+      (mrspidey:zprogress "Typing" (zodiac:zodiac-finish (rac defs))))
+
+    type-annotations))
+
+;; ----------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/collects/mrspidey/Sba/config.ss b/collects/mrspidey/Sba/config.ss
new file mode 100644
index 0000000..6d8237f
--- /dev/null
+++ b/collects/mrspidey/Sba/config.ss
@@ -0,0 +1,312 @@
+;; config.ss
+;; Lots of parameters for analysis
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define st:restricted 
+  (not (string? (current-load-relative-directory))))
+(define st:name    "MrSpidey")
+(define st:version (lambda () "49s1"))
+
+;; ----------------------------------------------------------------------
+;; Front end parameters
+
+(define st:fake-reader      (make-parameter-boolean #f))
+(define st:system-expand    (make-parameter-boolean #f))
+
+;; ----------------------------------------------------------------------
+;; Analysis parameters
+
+(define st:constants        (make-parameter-boolean #f))
+(define st:const-merge-size (make-parameter-integer 7))
+
+(define st:if-split       (make-parameter-boolean #t))
+; If #t, then knowledgeable about if's
+
+(define st:flow-sensitive (make-parameter-boolean #t))
+; If #t, then in (begin (car x) (cdr x)), cdr is never checked
+
+(define st:fo-units         (make-parameter-boolean #t))
+;; If #t, then first-order units treated specially
+
+(define st:lazy-fo-units         (make-parameter-boolean #t))
+;; If #t, then first-order units treated specially
+
+(define st:cache-units      (make-parameter-boolean #t))
+;; If #t, then first-order units treated specially
+
+(define st:whole-program    (make-parameter-boolean #t))
+
+(define st:special-fo-prims (make-parameter-boolean #t))
+(define st:see-void         (make-parameter-boolean #t))
+(define st:cons-mutable     (make-parameter-boolean #t))
+(define st:use-fo-ftype     (make-parameter-boolean #t))
+
+(define need-label-types #t)
+(define need-explanation #t)
+
+(define st:zero-old-constraint-sets (make-parameter-boolean #t))
+(define st:zero-old-asts            (make-parameter-boolean #t))
+
+;; ----------------------------------------------------------------------
+;; Simplification parameters
+
+(define constraint-simplification-list
+  (if st:restricted
+    '( 
+       (none            "No simplification")
+       (nonempty        "Remove empty constraints")
+       (live            "Remove empty and unreachable constraints")
+       (live-few-e      "As above, and also remove epsilon constraints")
+       ((live-few-e dfa-min-glb dfa-min-lub) 
+         "Live, few epsilon, DFA min")
+       )
+    '( 
+       (none            "No simplification")
+       (nonempty        "Remove empty constraints")
+       (nonempty-copy   "Copy nonempty")
+       (live            "Remove empty and unreachable constraints")
+       (live-few-e-L    "Live, few lower epsilon")
+       (live-few-e-U    "Live, few upper epsilon")
+       (live-few-e      "Live, few epsilon")
+       ((live-few-e dfa-min-lub)
+         "Live, few epsilon, DFA min LUB")
+       ((live-few-e dfa-min-glb)
+         "Live, few epsilon, DFA min GLB")
+       ((live-few-e  dfa-min-lub dfa-min-glb) 
+         "Live, few epsilon, DFA min")
+       )))
+
+(define make-constraint-simplification-para
+  (case-lambda
+    [() (make-constraint-simplification-para 'live-few-e)]
+    [(default)
+      (make-parameter-list
+        default
+        constraint-simplification-list
+        (lambda (_) (void))
+        ;; also-ok?
+        (lambda (x)
+          (and (list? x)
+            (andmap 
+              (lambda (y) (member y (map car constraint-simplification-list)))
+              x))))]))
+
+(define st:minimize-respect-assignable-part-of-fields 
+  (make-parameter-boolean #t))
+
+;; ----------------------------------------------------------------------
+;; Polymorphism parameters
+
+(define st:constraint-simplification-poly (make-constraint-simplification-para))
+
+(define st:polymorphism
+  (make-parameter-list 'compress
+                       `((none      "No polymorphism")
+                         (compress  "Simplify constraints")
+                         ;;(copy-con  "") 
+                         (reanalyze "Reanalyze")
+                         )))
+
+;; ----------------------------------------------------------------------
+;; Unit parameters 
+
+(define st:unit-read-za            (make-parameter-boolean #t))
+(define st:unit-write-za           (make-parameter-boolean #t))
+(define st:unit-simplify           
+  (make-constraint-simplification-para 'live-few-e))
+(define st:unit-separate-S         (make-parameter-boolean #t))
+(define st:save-za-in
+  (make-parameter-list
+    'source-directory
+    `( (source-directory "Source file directory" "")
+       (tmp-directory    
+         ,(string-append 
+            (if (defined? 'wx:find-path)
+              (wx:find-path 'temp-dir) " directory"))
+         ""))))
+
+;; ----------------------------------------------------------------------
+;; Type Viewing parameters 
+
+;; --- copying
+
+(define st:sdl-fo
+  (make-parameter-list
+    'basic-types
+    '( (basic-types  "Basic Types"     "ie (1 -> 1)")
+       (type-schemas   "Type Schemas"  "ie (X1 -> X1)"))))
+
+(define st:sdl-fo-ivars (make-parameter-boolean #t))
+(define st:sdl-fo-struct-fields (make-parameter-boolean #t))
+(define st:sdl-fo-depth-limit? (make-parameter-boolean #t))
+(define st:sdl-fo-depth-limit (make-parameter-integer 50))
+(define st:sdl-fo-size-limit? (make-parameter-boolean #t))
+(define st:sdl-fo-size-limit (make-parameter-integer 50))
+
+;; --- simplification
+
+(define st:sdl-constraint-simplification 
+  (make-constraint-simplification-para 'live-few-e))
+
+(define st:show-assignable-part-of-fields 
+  (make-parameter-boolean #f))
+
+;; --- to SDL
+
+(define st:listify-etc (make-parameter-boolean #t))
+
+(define st:sdl-constructor/selector
+  (make-parameter-list 
+    'constructor
+    '((constructor "Show types as constructors" "")
+      (selector    "Show types as selectors"    ""))))
+
+(define st:naming-strategy 
+  (make-parameter-list
+   'multiple
+   (if st:restricted
+       '((recursive "Recursive" "Name types on cycles")
+         (multiple  "Multiple"  "Name types referenced more than once")
+         (nontrivial  "Non-Trivial"  "Name non-trivial types")
+         (all       "All"       "Name all types"))
+       '((recursive "Recursive" "Name types on cycles")
+         (multiple  "Multiple"  "Name types referenced more than once")
+         (nontrivial  "Non-Trivial"  "Name non-trivial types")
+         (all       "All"       "Name all types")))))
+
+(define st:primitive-types 
+  (make-parameter-list
+   'inferred
+   '((prim      "(prim ...)"     "ie (prim car)")
+     (given     "Given types"    "ie ((cons a b) -> a)")
+     (inferred  "Inferred types" "ie ((cons 'a-symbol 4) -> 'a-symbol)"))))
+
+;; --- simplifying SDL
+
+(define st:expand-output-type (make-parameter-boolean #t))
+(define st:sdl-tidy (make-parameter-boolean #t))
+
+;; ---
+
+(define st:pretty-type-width (make-parameter-integer 60))
+
+;; ----------------------------------------------------------------------
+
+(define st:check-kernel (make-parameter-boolean #f))
+(define st:compare-min-algs (make-parameter-boolean #f))
+
+;; ----------------------------------------------------------------------
+;; Checking parameters
+
+(define st:all-checks     (make-parameter-boolean #f))
+
+;; ----------------------------------------------------------------------
+;; control - interface to all parameters
+
+(define mrspidey:control-fn
+  (let ([paras 
+          (begin-elaboration-time
+            (cons 'list
+              (map 
+                (lambda (x) (list 'cons (list 'quote x) x))
+                '(;; --- Analysis time
+                   st:constants 
+                   st:const-merge-size
+                   st:fo-units
+                   st:if-split 
+                   st:flow-sensitive 
+                   st:special-fo-prims
+                   st:system-expand
+                   st:see-void
+                   st:unit-read-za
+                   st:unit-write-za
+                   st:save-za-in
+                   ;; --- Polymorphism
+                   st:polymorphism
+                   st:constraint-simplification-poly
+                   ;;st:library-prims
+                   ;;st:topo-sort
+                   ;; --- Seperate analysis
+                   st:unit-simplify
+                   ;; --- Type viewing
+                   st:sdl-fo
+                   st:sdl-fo-ivars 
+                   st:sdl-fo-struct-fields
+                   st:sdl-fo-depth-limit? 
+                   st:sdl-fo-depth-limit
+                   st:sdl-fo-size-limit?
+                   st:sdl-fo-size-limit
+                   st:sdl-constraint-simplification
+                   st:show-assignable-part-of-fields
+                   st:listify-etc
+                   st:sdl-constructor/selector
+                   st:naming-strategy
+                   st:primitive-types
+                   st:expand-output-type
+                   st:sdl-tidy
+                   st:pretty-type-width
+
+                   ;; --- checking parameters
+                   st:all-checks 
+                   ))))])
+    (match-lambda*
+     [()
+      ;; Return list of all settings
+       (map
+         (match-lambda [(sym . para) (list sym (para))])
+         paras)
+       ]
+     [(para-name)
+      ;; Return one setting
+       (match (assq para-name paras)
+         [(_ . para) (para)]
+         [#f (error 'mrspidey:control "Unknown parameter ~s" para-name)])]
+     [(para-name nu-val)
+       ;; Return one setting
+       (match (assq para-name paras)
+         [(_ . para)
+           (if (memq nu-val (map car (para '?)))
+             (para nu-val)
+             (error 'mrspidey:control "Value ~s invalid for parameter ~s" 
+               nu-val para-name))]
+         [#f
+           (error 'mrspidey:control "Unknown parameter ~s" para-name)])]
+     [_ (error 'mrspidey:control "Bad # arguments")])))
+     
+;======================================================================
+ 
+(when st:restricted
+  ;; . special configuration, if necy
+  (void)
+  )
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/collects/mrspidey/Sba/contain.ss b/collects/mrspidey/Sba/contain.ss
new file mode 100644
index 0000000..c7652a6
--- /dev/null
+++ b/collects/mrspidey/Sba/contain.ss
@@ -0,0 +1,155 @@
+;; contained.ss
+;;
+;; Check if one Tvar is contained in another
+;; Doesn't work for contravariant fields
+;; Not currently used
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; ----------------------------------------------------------------------
+;; NOTE: Tvar2 must be tidy!!!
+
+(define stack '())
+(define fail-stack '())
+
+(define Tvar-containment?
+  (lambda (tvar1 tvar2)
+    (let*-vals 
+      ( [calc-reached
+          (lambda (tvar)
+            (let*-vals 
+              ([(reached? set-reached! get-reached) 
+                 (field->set alloc-Tvar-field)])
+              (recur traverse ([tvar tvar])
+                (unless (reached? tvar)
+                  (set-reached! tvar)
+                  (for-each
+                    (match-lambda
+                      [($ AV _ ($ template _ _ _ ref) _ fields+ field-)
+                        (vector-for-each traverse fields+)])
+                    (get-Tvar-objs tvar))))
+              (get-reached)))]
+        [list-reached-1 (calc-reached tvar1)]
+        [list-reached-2 (calc-reached tvar2)]
+        [num-reached-1 (length list-reached-1)]
+        [(get-num set-num!) (alloc-Tvar-field)]
+        [(get-reached-vec set-reached-vec!) (alloc-Tvar-field)]
+        )
+
+        (for-each-with-n (lambda (tvar n) (set-num! tvar n))
+          list-reached-1)
+
+      (for-each
+        (lambda (tvar) (set-reached-vec! tvar (make-vector num-reached-1 #f)))
+        list-reached-2)
+
+      ;; Tidyness check
+      '(for-each
+        (lambda (tvar) 
+          (let* ([objs (get-Tvar-objs tvar)]
+                 [templates (map AV-template objs)]
+                 [types (map template-type templates)]
+                 [types2 (list->set types)])
+            (unless (= (length types) (length types2))
+              (mrspidey:error
+               (format "Upper bound of containment is not tidy, types are ~s"
+                       types)))))
+        list-reached-2)       
+
+      (begin0
+       (let/cc 
+        fail
+
+        (recur ensure-contained ([tvar1 tvar1][tvar2 tvar2])
+          (fluid-let ([stack (cons (cons tvar1 tvar2) stack)])
+            (let ([n (get-num tvar1)]
+                  [reached (get-reached-vec tvar2)])
+              (unless (vector-ref reached n)
+                ;; Need to search - record true to detect loops
+                (vector-set! reached n #t)
+                (for-each
+                 (match-lambda
+                  [($ AV _ (and template ($ template _ _ ref)) _ fields+)
+                   (or 
+
+                    ;; More than one matching => not tidy => say contained.
+                    (> (count (match-lambda
+                               [($ AV _ template2)
+                                (eq? (template-type template)
+                                     (template-type template2))])
+                              (get-Tvar-objs tvar2))
+                       1)
+
+                    (ormap
+                      (match-lambda
+                        [($ AV _ template2 _ fields2+)
+                          (and          ;(eq? template template2)
+                            (or
+                              (eq? 
+                                (template-type template)
+                                (template-type template2))
+                              (memq
+                                template2 
+                                (template-super-templates template)))
+                            (begin
+                              (for i 0 
+                                (min
+                                  (vector-length fields+)
+                                  (vector-length fields2+))
+                                (ensure-contained 
+                                  (vector-ref fields+ i)
+                                  (vector-ref fields2+ i)))
+                                #t))])
+                      (get-Tvar-objs tvar2))
+
+                    ;; No match
+                    (begin
+                      '(printf
+                         "~s ~s not in ~s ~s~n"
+                         (map (lambda (AV) (template-type (AV-template AV)))
+                           (get-Tvar-objs tvar1))
+                         (Tvar-name tvar1)
+                         (map (lambda (AV) (template-type (AV-template AV)))
+                           (get-Tvar-objs tvar2))
+                         (Tvar-name tvar2))
+                      (set! fail-stack stack)
+                      (fail #f)))])
+                 (get-Tvar-objs tvar1))))))
+
+        ;; Did not fail => succeed
+        #t)
+
+        ))))
+
+'(define (show-fail-stack-sdl)
+   (map
+    (match-lambda
+     [(a . d)
+      (list (Tvar->SDL a)
+            (Tvar->SDL d))])
+    fail-stack))
+
+'(define (show-fail-stack)
+   (for-each
+    (match-lambda
+     [(a . d)
+      (printf "============~n")
+      (show-Tvar a)
+      (show-Tvar d)])
+    fail-stack))
+
+
diff --git a/collects/mrspidey/Sba/contained.ss b/collects/mrspidey/Sba/contained.ss
new file mode 100644
index 0000000..594aca1
--- /dev/null
+++ b/collects/mrspidey/Sba/contained.ss
@@ -0,0 +1,129 @@
+;; contained.ss
+;;
+;; Check if one Tvar is contained in another
+;; Doesn't work for contravariant fields
+;; ----------------------------------------------------------------------
+;; NOTE: Tvar2 must be tidy!!!
+
+(define stack '())
+(define fail-stack '())
+
+(define Tvar-containment?
+  (lambda (tvar1 tvar2)
+    (let*-vals 
+      ( [calc-reached
+          (lambda (tvar)
+            (let*-vals 
+              ([(reached? set-reached! get-reached) 
+                 (field->set alloc-Tvar-field)])
+              (recur traverse ([tvar tvar])
+                (unless (reached? tvar)
+                  (set-reached! tvar)
+                  (for-each
+                    (match-lambda
+                      [($ AV _ ($ template _ _ ref) _ fields)
+                        (for i 0 (vector-length ref)
+                          (traverse 
+                            (vector-ref fields (vector-ref ref i))))])
+                    (get-Tvar-objs tvar))))
+              (get-reached)))]
+        [list-reached-1 (calc-reached tvar1)]
+        [list-reached-2 (calc-reached tvar2)]
+        [num-reached-1 (length list-reached-1)]
+        [(get-num set-num!) (alloc-Tvar-field)]
+        [(get-reached-vec set-reached-vec!) (alloc-Tvar-field)]
+        )
+
+        (for-each-with-n (lambda (tvar n) (set-num! tvar n))
+          list-reached-1)
+
+      (for-each
+        (lambda (tvar) (set-reached-vec! tvar (make-vector num-reached-1 #f)))
+        list-reached-2)
+
+      ;; Tidyness check
+      '(for-each
+        (lambda (tvar) 
+          (let* ([objs (get-Tvar-objs tvar)]
+                 [templates (map AV-template objs)]
+                 [types (map template-type templates)]
+                 [types2 (list->set types)])
+            (unless (= (length types) (length types2))
+              (mrspidey:error
+               (format "Upper bound of containment is not tidy, types are ~s"
+                       types)))))
+        list-reached-2)       
+
+      (begin0
+       (let/cc 
+        fail
+
+        (recur ensure-contained ([tvar1 tvar1][tvar2 tvar2])
+          (fluid-let ([stack (cons (cons tvar1 tvar2) stack)])
+            (let ([n (get-num tvar1)]
+                  [reached (get-reached-vec tvar2)])
+              (unless (vector-ref reached n)
+                ;; Need to search - record true to detect loops
+                (vector-set! reached n #t)
+                (for-each
+                 (match-lambda
+                  [($ AV _ (and template ($ template _ _ ref)) _ fields)
+                   (or 
+
+                    ;; More than one matching => not tidy => say contained.
+                    (> (count (match-lambda
+                               [($ AV _ template2 _ fields2)
+                                (eq? (template-type template)
+                                     (template-type template2))])
+                              (get-Tvar-objs tvar2))
+                       1)
+
+                    (ormap
+                     (match-lambda
+                      [($ AV _ template2 _ fields2)
+                       (and             ;(eq? template template2)
+                        (eq? (template-type template)
+                             (template-type template2))
+                        (begin
+                          (for i 0 (vector-length ref)
+                               (let ([r (vector-ref ref i)])
+                                 (ensure-contained
+                                  (vector-ref fields r)
+                                  (vector-ref fields2 r))))
+                          #t))])
+                     (get-Tvar-objs tvar2))
+                    ;; No match
+                    (begin
+                      (printf
+                       "~s ~s not in ~s ~s~n"
+                       (map (lambda (AV) (template-type (AV-template AV)))
+                            (get-Tvar-objs tvar1))
+                       (Tvar-name tvar1)
+                       (map (lambda (AV) (template-type (AV-template AV)))
+                            (get-Tvar-objs tvar2))
+                       (Tvar-name tvar2))
+                      (set! fail-stack stack)
+                      (fail #f)))])
+                 (get-Tvar-objs tvar1))))))
+
+        ;; Did not fail => succeed
+        #t)
+
+        ))))
+
+'(define (show-fail-stack-sdl)
+   (map
+    (match-lambda
+     [(a . d)
+      (list (Tvar->SDL a)
+            (Tvar->SDL d))])
+    fail-stack))
+
+'(define (show-fail-stack)
+   (for-each
+    (match-lambda
+     [(a . d)
+      (printf "============~n")
+      (show-Tvar a)
+      (show-Tvar d)])
+    fail-stack))
diff --git a/collects/mrspidey/Sba/debug.ss b/collects/mrspidey/Sba/debug.ss
new file mode 100644
index 0000000..008b3da
--- /dev/null
+++ b/collects/mrspidey/Sba/debug.ss
@@ -0,0 +1,37 @@
+;; debugging.ss
+
+(define debugging #f)
+(define debugging-front #f)
+(define debugging-traverse #f)
+(define debugging-object #f)
+(define debugging-unit #f)
+(define debugging-check #f)
+(define debugging-atenv #f)
+(define debugging-atype #f)
+(define debugging-sdl #f)
+(define debugging-sdl2 #f)
+(define debugging-gui #t)
+
+(define debugging-min #f)
+(define debugging-min2 #f)
+(define debugging-few #f)
+(define debugging-gram #f)
+(define debugging-dfa-min #f)
+(define debugging-min-table #f)
+
+(define timing-min #f)
+
+(define pretty-print-debug pretty-print)
+
+(define (set-debug-flag which val)
+  (case which
+    [(general)  (set! debugging val)]
+    [(min)      (set! debugging-min val)]
+    [(front)    (set! debugging-front val)]
+    [(traverse) (set! debugging-traverse val)]))
+
+;(set! debugging #t)
+;(set! debugging-min #t)
+;(set! debugging-gram #t)
+;(set! debugging-min-table #t)
+;(set! timing-min #t)
diff --git a/collects/mrspidey/Sba/devel.ss b/collects/mrspidey/Sba/devel.ss
new file mode 100644
index 0000000..f66431b
--- /dev/null
+++ b/collects/mrspidey/Sba/devel.ss
@@ -0,0 +1,1081 @@
+;; devel.ss
+;; Development helper file
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+;; Timing
+
+(defmacro trace-time args
+  (match args
+    [(fn)
+     (let* ([c (box 0)]
+            [f (gensym)])
+       `(begin
+          (define ,f ,fn)
+          (define ,fn (lambda args
+                        (record-time ,c
+                                     (lambda () (apply ,f args)))))
+          ,c))]))
+
+(define counter-fns
+  '(
+     st:
+     analyze-program
+     zodiac:read*
+     top-level-parse-defs
+     top-level-parse-exp
+     top-level-traverse-defs
+     open-code-file
+     system-expand-port
+     expand-zexp->port
+
+     minimize-constraints
+     find-nonempty-tvars
+     copy-live-constraints
+     copy-live-constraints-noe
+     copy-live-constraints-few-e
+     minimize-constraints-dfa-min
+     minimize-constraints-dfa-min-inv
+     minimize-constraints-dfa-min-1
+     minimize-constraints-dfa-min-2
+
+     copy-constraints-equiv!
+     find-nonempty-nts-rhs-nts
+     calc-live-tvars-nts
+     ;; copy-constraint-set
+     Hopcroft-calc-equivalences
+
+     read-za
+     write-za
+     calc-checks
+
+     calc-productions!                 
+     Tvar-in-type?
+
+     resize-hash-table
+     save-kernel-state
+     restore-kernel-state!
+     free-kernel-state!
+     zodiac:zero!
+
+     ;atenv:extend
+     ;atenv:lookup
+     ;atenv:change-binding
+     ;atenv:capture-locs
+     ;atenv:unflush
+     ;atenv:flush!
+     ;zodiac:free-vars
+
+     ;chema->con
+     initialize-analysis!
+     get-default-bindings
+     ))
+
+(define counter-nonfns
+  '( ;;live-data
+     ))
+
+(define counters
+  (append
+   (map
+    (lambda (fn)
+      (let ([c (cons 0 0)]
+            [f (gensym)])
+        (eval
+         `(begin
+            (define ,f (if (defined? ',fn) ,fn (lambda (x) x)))
+            (define ,fn (lambda args
+                          (record-time ',c
+                                       (lambda () (apply ,f args)))))))
+        (list fn c)))
+    counter-fns)
+   (map
+    (lambda (name)
+      (let ([c (cons 0 0)])
+        (eval `(define ,(symbol-append name '-counter) (quote ,c)))
+        (list name c)))
+    counter-nonfns)))
+
+(define (show-counters)
+  (printf "COUNTERS:~n")
+  (for-each
+   (match-lambda
+    [(f (n . t))
+     (unless (zero? t)
+       (printf "   ~a ~a ~a ms~n" (padr f 35) (padl n 5) (padl t 7)))])
+   counters)
+  (printf "   ~a ~a ~a ms~n" 
+    (padr "ANALYSIS TIME" 35)
+    (padl 1 5)
+    (padl (apply -
+            (map get-counter
+              '(
+                 analyze-program
+                 zodiac:read*
+                 top-level-parse-defs
+                 top-level-parse-exp
+                 open-code-file
+                 expand-zexp->port
+                 initialize-analysis!
+                 get-default-bindings
+                 )))
+      7)))
+
+(define (clear-counters!)
+  (initialize-analysis!)
+  (set! hash-table '())
+  (set! global-defs-parsed '())
+  (set! global-def-env '())
+  ;;((collect-request-handler) (collect-maximum-generation))
+  (for-each
+   (match-lambda
+    [(f c) (set-car! c 0) (set-cdr! c 0)])
+   counters))
+
+(define (get-counter c)
+  (ormap
+   (match-lambda
+    [(f (n . t))
+     (if (eq? f c) t #f)])
+   counters))
+
+;(collect-notify #t)
+
+(define (with-counters f args)
+  (clear-counters!)
+  (apply f args)
+  (show-counters)
+  (show-stats))
+ 
+;; ======================================================================
+;; Setup live-data-counter
+
+'(define base-data-live 0)
+
+'(define my-collect
+  (lambda args
+    (apply #%collect args)
+    ;;(#%collect 4)
+    (set-car! live-data-counter (add1 (car live-data-counter)))
+    (let ([live (truncate (/ (- (bytes-allocated) base-data-live) 1000))])
+      (set-cdr! live-data-counter (max (cdr live-data-counter) live))
+      (when (collect-notify)
+        (printf "GC: HWM ~sK + ~sK~n" 
+                (truncate (/ base-data-live 1000))
+                live)
+        (show-stat-small)))))
+;;(collect-request-handler my-collect)
+
+;; ======================================================================
+;; Compare counters under different strategies
+
+(define (diff-counters th1 th2)
+  (th1)
+  ;;((collect-request-handler) (collect-maximum-generation))
+  (show-stat)
+  (let ([t* (map cdadr counters)])
+    (th2)
+    ;;((collect-request-handler) (collect-maximum-generation))
+    (show-stat)
+    (printf "DIFFERENCE IN TIMES:~n")
+    (for-each
+     (match-lambda*
+      [((f (n . t2)) t)
+       (unless (and (zero? t) (zero? t2))
+         (printf "   ~a ~a vs ~a, extra ~a ms~n" 
+                 (padr f 35) (padl t 7) (padl t2 7) (padl (- t2 t) 7)))])
+     counters t*)))
+
+(define (diff-times files)
+  (diff-counters
+   (lambda ()
+     (dynamic-let ([st:analysis 'sba]) (tsal files)))
+   (lambda ()
+     (dynamic-let ([st:analysis 'za-reanalyze]) (tsal files)))))
+
+(define (diff-times2 files)
+  (diff-counters
+   (lambda ()
+     (dynamic-let ([st:unit-simplify 'live]) (tsal files)))
+   (lambda ()
+     (dynamic-let ([st:unit-simplify 'dfa-min]) (tsal files)))))
+
+;; ======================================================================
+;; Check correctness of seperate analysis
+
+(define ord-types '())
+(define sep-types '())
+
+(define (test-seperate-same files)
+  (dynamic-let 
+   ([st:type-compression '(basic-types . tidy)]
+    [st:primitive-types 'inferred])
+   (let ([def-types
+           (lambda ()
+             (printf "Calculating types ...")
+             (begin0
+              (filter
+               (match-lambda
+                [($ sym-def sym def) (symbol? sym)])
+               global-out-env)
+              (printf " done~n")))])
+     (diff-counters
+      (lambda ()
+        (dynamic-let ([st:analysis 'sba]) 
+                      (tsal files)
+                      (set! ord-types (def-types))))
+      (lambda ()
+        (dynamic-let ([st:analysis 'za-reanalyze])
+                      (tsal files)
+                      (set! sep-types (def-types)))))
+     (printf "Comparing types ... ~n")
+     (unless (= (length ord-types) (length sep-types))
+       (error 'test-seperate-same
+              "Different lengths"))
+     (for-each
+      (match-lambda*
+       [(($ sym-def sym1 def1)
+         ($ sym-def sym2 def2))
+        (unless (eq? sym1 sym2)
+          (error 'test-seperate-same "Different symbols defined"))
+        (unless (and (Tvar? def1) (ftype? def2))
+          (error 'test-seperate-same "Definition not Tvar"))
+        (unless (and (Tvar-containment? def1 def1)
+                     (Tvar-containment? def2 def2))
+          (error 'test-seperate-same "Tvar-containment? bad"))
+        (unless (and (Tvar-containment? def1 def2)
+                     (Tvar-containment? def2 def1))
+          (dynamic-let ([st:type-compression '(first-order . none)])
+                        (printf "Ordinary type~n")
+                        (pretty-print (Tvar->SDL def1))
+                        (printf "Seperate type~n")
+                        (pretty-print (Tvar->SDL def2)))dev
+          (error 'test-seperate-same "Definitions of ~s differ" sym1))])
+      ord-types sep-types)
+     (printf "Types are identical~n"))))
+  
+;; ======================================================================
+;; Results File
+
+(define results-file "/home/cormac/Spidey/results/results")
+
+(define (clear-results)
+  (system (format "\\rm ~s" results-file)))
+
+(define (write-results title size)
+  (let ([p (open-output-file results-file 'append)]
+        [o `(RESULTS
+             ,title
+             (size    ,size)
+             (num-ftype ,num-Atype)
+             (num-AV  ,num-AV)
+             (num-con ,num-con)
+             (num-edge ,num-edge)
+             (num-AV-a ,num-AV-in-Tvar)
+             (entries ,entries-in-table)
+             ,counters
+             ,(mrspidey:control-fn))])
+    (pretty-print o p)
+    (close-output-port p)
+    o))
+
+(define (analyze-and-write-results files)
+  (tsal files)
+  (write-results files (apply + (map calc-AST-size global-defs-parsed))))
+
+;; ======================================================================
+;; Scaling of (st:analysis 'sba)
+
+(define (test-scaling-file files)
+  (printf "TEST-SCALING-FILE ~s~n" files)
+  (dynamic-let 
+   ([st:analysis 'sba])
+   (analyze-and-write-results files)))
+
+(define (test-scaling)
+  (cd "/home/cormac/Spidey")
+  (clear-results)
+  (map test-scaling-file (map list benchmark-files))
+  (test-scaling-file sba-kernel-spj)
+  (test-scaling-file TC-spj)
+  (test-scaling-file t11-spj)
+  (test-scaling-file sba-zodiac-spj)
+  (test-scaling-file sba-small-spj)
+  ;;(test-scaling-file sba-spj)
+  )
+
+(define (test-scaling-sba)
+  ;; Add on extra sba files one-by-one
+  (recur loop ([f '()]
+               [r (append
+                   sba-small-spj
+                   (filter
+                    (lambda (x) (not (member x sba-small-spj)))
+                    sba-spj))])
+    (unless (null? r)
+      (let ([f (append f (list (car r)))])
+        (test-scaling-file f)
+        (loop f (cdr r))))))
+
+(define matlab-scaling-file "/home/cormac/Spidey/results/scaling.m")
+(define get-results-file
+  (case-lambda
+   [() (get-results-file results-file)]
+   [(file)
+    (match-let*
+        ([l '()]
+         [_ (with-input-from-file file
+              (lambda ()
+                (recur loop ()
+                  (let ([x (read)])
+                    (unless (eof-object? x)
+                      (match x
+                        [('quote . _) (void)]
+                        [_ (set! l (append l (list x)))])
+                      (loop))))))]
+         ;; Group l together by filename
+         ;; grouped-l: (listof (listof info))
+         [grouped-l (recur loop ([l l])
+                      (match l
+                        [() '()]
+                        [(('RESULTS files . _) . _)
+                         (let-values
+                             ([(info* rest)
+                               (filter-map-split
+                                (match-lambda
+                                 [(and x ('RESULTS files2 . _))
+                                  (and (equal? files files2) x)])
+                                l)])
+                           (cons (reverse info*) (loop rest)))]))]
+         [name->ndx
+          (lambda (filename)
+            (recur loop ([i 0])
+              (cond
+               [(= i (length wright-files)) 
+                (printf "Warning: not found~n") 
+                i]
+               [(string=? filename (nth wright-files i)) i]
+               [else (loop (add1 i))])))]
+         [grouped-l (sort 
+                     (match-lambda*
+                      [((and a (('RESULTS f1 ('size s1) . _) . _))
+                        (('RESULTS f2 ('size s2) . _) . _))
+                       (< s1 s2)
+                       (< (name->ndx f1) (name->ndx f2))])
+                     grouped-l)]
+         [_ (assert (= (length l) (apply + (map length grouped-l))))]
+         [_ (pretty-print 
+             (map
+              (match-lambda
+               [(('RESULTS files ('size s1) . _) . _)
+                (list files s1)])
+              grouped-l))]
+         [cnth (lambda (n) (lambda (x) (cadr (nth x n))))]
+         [get-counters (lambda (x) (nth x 9))]
+         [get-control  (lambda (x) (nth x 10))]
+         [get-time     
+          (lambda (f)
+            (lambda (x) (cdr (cadr (assq f (get-counters x))))))]
+         [ctrl-eq?
+          (lambda (para val)
+            (lambda (x)
+              (eq? (cadr (assq para (get-control x))) val)))]
+         [select
+          (lambda (pred)
+            (map
+             (lambda (group)
+               (match (filter pred group)
+                 [() #f]
+                 [(x) x]
+                 [m (pretty-print m)
+                    (error 'get-results-file "Multiple matches")]))
+             grouped-l))]
+         [split
+          (lambda (preds)
+            (map select preds))])
+
+      (list l cnth get-counters get-control get-time ctrl-eq?
+            select split))]))
+
+
+(define (scaling->matlab)
+  (system (format "\\rm ~s" matlab-scaling-file))
+  (match-let*
+      ([(l cnth get-counters get-control get-time l-filter-ctrl split)
+        (get-results-file)]
+       [l-p (lambda (p) (select (l-filter-ctrl 'st:analysis p)))]
+       [l-sba (l-p 'sba)]
+       [l-precompress (l-p 'precompress)]
+       [l-za  (l-p 'za-reanalyze)]
+       [l-nc  (l-p 'no-combine)])
+
+      ;;(pretty-print (map cadr l))
+      (with-output-to-file matlab-scaling-file
+        (lambda ()
+          (for-each
+           (match-lambda
+            [(name fn)
+             (printf "~s = [ " name)
+             (for-each (lambda (x) (printf "~s " (if x (fn x) 0)))
+                       l-sba)
+             (add-zeros l-sba)
+             (printf "; ")
+             (for-each (lambda (x) (printf "~s " (fn x)))
+                       l-precompress)             
+             (add-zeros l-precompress)
+             (printf "; ")
+             (for-each (lambda (x) (printf "~s " (fn x)))
+                       l-za)
+             (add-zeros l-za)
+             (printf "; ")
+             (for-each (lambda (x) (printf "~s " (fn x)))
+                       l-nc)
+             (add-zeros l-nc)
+             (printf "]~n")])
+           `((ast_size  ,(cnth 2))
+             (num_Tvar   ,(cnth 3))
+             (num_AV    ,(cnth 4))
+             (num_con   ,(cnth 5))
+             (num_edges ,(cnth 6))
+             (num_AV_a  ,(cnth 7))
+             (entries   ,(cnth 8))
+             (ttl_time      ,(get-time 'seperately-analyze-and-load-files))
+             (local_time    ,(get-time 'sba-analyze-file))
+             (parse_time    ,(get-time 'load-parse-expand))
+             (traverse_time ,(get-time 'traverse-def))
+             (combine_time  ,(get-time 'top-level-combine))
+             (live_data     ,(get-time 'live-data))
+             (min_time      ,(get-time 'minimize-constraints-live))
+             (resize_time   ,(get-time 'resize-hash-table))
+             ))))))
+
+;; ======================================================================
+;; Comparison of st:analysis 'za-reanalyze and #f
+
+(define (compare-analyzes-files files)
+  (let ([size
+         (dynamic-let 
+          ([st:analysis 'sba])
+          (printf "~nCOMPARE-ANALYZES 'sba ~s~n" files)
+          (tsal files)
+          (let ([size (apply + (map calc-AST-size seperate-defs))])
+            (write-results files size)
+            size))])
+    (for-each 
+     (lambda (a)
+       (printf "~nCOMPARE-ANALYZES '~s ~s~n" a files)
+       (dynamic-let 
+        ([st:analysis a])
+        (if (memq a '(precompress za-reanalyze))
+            (for-each (lambda (c)
+                        (dynamic-let
+                         ([st:unit-simplify c])
+                         (tsal files)
+                         (write-results files size)))
+                      '(live-few-e
+                        dfa-min))
+            (begin
+              (tsal files)
+              (write-results files size)))))
+     '(precompress za-reanalyze no-combine))))
+
+(define (compare-analyzes)
+  (cd "/home/cormac/Spidey")
+  (clear-results)
+  (compare-analyzes-files tp-spj)
+  (compare-analyzes-files sba-kernel-spj)
+  (compare-analyzes-files TC-spj)
+  (compare-analyzes-files t11-spj)
+  (compare-analyzes-files sba-zodiac-spj)
+  (compare-analyzes-files sba-small-spj)
+  ;;(test-scaling-file sba-spj)
+  (compare-analyzes-sba)
+  )
+
+(define (compare-analyzes-sba . rest)
+  ;; Add on extra sba files one-by-one
+  (recur loop ([f '()]
+               [r sba-spj]
+               [n (match rest
+                    [() 0]
+                    [(n) n])])
+    (unless (null? r)
+      (let ([f (append f (list (car r)))])
+        (when (<= n 0)
+          (compare-analyzes-files f))
+        (loop f (cdr r) (sub1 n))))))
+
+
+(define matlab-seperate-file "/home/cormac/Spidey/results/seperate.m")
+
+;; ======================================================================
+
+(define (ts file)
+  (seperately-analyze-file-thunk* (files->file-thunk* file) "test/out.za")
+  (read-constraint-set "test/out.za"))
+
+(define (tsal files)
+  (clear-counters!)
+  (seperately-analyze-and-load-files files)
+  (show-counters)
+  (void))
+
+;; ======================================================================
+;; Some benchmarks
+
+(define tp-spj (list "mod/part1.ss" "mod/part2.ss"))
+(define mod-spj (list "mod/mod1.ss" "mod/mod2.ss" "mod/mod3.ss"))
+(define TC-spj (list "mod/TC/env.ss" 
+                     "mod/TC/parse.ss"
+                     "mod/TC/type.ss"
+                     "mod/TC/eval.ss"
+                     "mod/TC/go.ss"
+                     ;;"mod/TC/test.ss"
+                     ))
+(define t11-spj (list "mod/11/FrontEnd.ss"
+                      "mod/11/Registers.ss"
+                      "mod/11/Memory.ss"
+                      "mod/11/Machine.ss"
+                      "mod/11/go.ss"
+                      ))
+
+(define (tp)   (tsal tp-spj))
+(define (mod)  (tsal mod-spj))
+(define (TC)   (tsal TC-spj))
+(define (t11)  (tsal t11-spj))
+
+;; ======================================================================
+;; SBA benchmarks
+
+(define sba-files
+  (list "library"
+        "env"
+        "config"
+        "driver"
+        "sba"
+
+        "zodiac"
+        "compat"
+        "loadexpand"
+        "bind"
+        "traverse"
+        "global-env"
+        "prototype"
+
+        "hash"
+        "kernel"
+
+        "toplevelenv"
+        "templates"
+        "languages-abstract"
+
+        "sdl"
+        "results"
+
+        "calc-checks"
+        "hyper"
+        "seperate"
+
+        "type-con"
+        "contained"
+        "gram"
+        "min"
+        "min2"
+        "dfa-min"
+        ))
+
+(define sba-spj 
+  (map (lambda (s) (string-append "/home/cormac/Spidey/mod/sba/" s ".ss"))
+       sba-files))
+
+(define (sba-spj-until x)
+  (recur loop ([l sba-spj])
+    (cons (car l)
+          (if (substring? x (car l))
+              '()
+              (loop (cdr l))))))
+
+(define sba-small-spj (sba-spj-until "kernel"))
+(define sba-medium-spj (sba-spj-until "calc-checks"))
+
+(define sba-kernel-spj
+  (map (lambda (s) (string-append "/home/cormac/Spidey/mod/sba/" s ".ss"))
+       (list "hash" "kernel" "test-kernel")))
+
+(define sba-zodiac-spj
+  (map (lambda (s) (string-append "/home/cormac/Spidey/mod/sba/" s ".ss"))
+       (list "bind" "compat" "env" "zodiac" "test-zodiac")))
+
+;; ----------------------------------------------------------------------
+
+(define (separate-expt)
+  (st:polymorphism 'compress)
+  (st:type-compression-poly 'live-few-e)
+  (st:library-prims #f)
+  (st:topo-sort #f)
+  (st:use-module #t)
+
+  (for-each
+   (lambda (p)
+     (printf "~n========================================~n")
+     (printf "SIMPL STRATEGY: ~s~n" p)
+     (st:unit-simplify p)
+     (st:analysis 'za-reanalyze)
+     (tsal sba-kernel-spj)
+     (write-results sba-kernel-spj 0)
+     (st:analysis 'za)
+     (for-each
+      (lambda (file)
+        (printf "~n========================================~n")
+        (printf "FILES: ~s~n" file)
+        (system (format "touch ~a" file))
+        (tsal sba-kernel-spj)
+        (write-results file 0))
+      sba-kernel-spj))
+   '(live live-few-e dfa-min-AV)))
+
+(define (tsba) (tsal sba-spj))
+(define (tker) (tsal sba-kernel-spj))
+(define (tzod) (tsal sba-zodiac-spj))
+(define (tker2)
+  (clear-counters!)
+  (initialize-analysis!)
+  (read-constraint-set-to-global-env "~/Spidey/mod/sba/hash.ss")
+  (read-constraint-set-to-global-env "~/Spidey/mod/sba/test-kernel.ss")
+  (hyper (sba-analyze-file (files->file-thunk* "~/Spidey/mod/sba/kernel.ss")))
+  (report-unbound-vars)
+  (show-counters))
+
+;; ======================================================================
+
+(define (test-seperate)
+  (for-each
+   (lambda (thunk)
+     (for-each
+      (lambda (c)
+        (for-each
+         (lambda (b)
+           (st:unit-simplify c)
+           (st:add-hyper-links b)
+           (printf "==============================~n")
+           (printf "Type-compression ~s   Hyper-links ~s~n" c b)
+           (thunk)
+           (show-stat))
+         (list #f )))
+      (list 'live 'dfa-min)))
+   (list ;;(lambda () (tp))
+         (lambda () (TC) (system "ls -l mod/TC*.za"))
+         ;;(lambda () (tsba) (system "ls -l sba/*.za"))
+         )))
+   
+;; ======================================================================
+
+(define (st:tybe . args)
+  (dynamic-let
+   ([st:type-compression '(higher-order . live-few-e)])
+   (pretty-print (apply st:type-fn args)))
+  (dynamic-let
+   ([st:type-compression '(higher-order . dfa-min)])
+   (apply st:type-fn args)))
+
+;; ======================================================================
+
+(define (compare-poly-file file)
+  (printf "~n========================================~nFile: ~s~n" files)
+  (for-each-parameter 
+    st:polymorphism
+    (lambda (p)
+      (printf "~n==============================~nPOLY STRATEGY: ~s~n" p)
+      (if (eq? p 'compress)
+        (for-each-parameter 
+          st:type-compression-poly 
+          (lambda (c)
+            (when (memq c '(live live-few-e))
+              (compare-poly-files-one files))))
+        (compare-poly-file-one file)))))
+
+(define (compare-poly-file-one file)
+  (printf "~n========================================~n")
+  (printf "FILE: ~s~n" file)
+  (printf "POLY STRATEGY: ~s ~s~n" 
+    (st:polymorphism) (st:type-compression-poly))
+  (clear-counters!)
+  (st:analyze files)
+  (show-counters)
+  (show-stat)
+  (let ([size (calc-AST-size defs-ordered)])
+    (write-results files size)))
+
+(define (make-compare-poly-file files)
+  `(dynamic-let 
+    ([st:topo-sort #t]
+     [st:library-prims #t])
+    (begin 
+      ,@(map
+         (lambda (p)
+           `(begin
+              (st:polymorphism (quote ,p))
+              ,(if (eq? p 'compress)
+                   `(begin 
+                      ,@(map
+                         (lambda (c)
+                           `(begin
+                              (st:type-compression-poly (quote ,c))
+                             (compare-poly-file-one ,files)))
+                         '(live live-few-e dfa-min-AV)))
+                   `(compare-poly-file-one ,files))))
+         (map car (st:polymorphism '?))))))
+
+(define (all-compare-poly) (for-each compare-poly-file benchmark-files))
+(define (wright-compare-poly) (for-each compare-poly-file wright-files))
+
+(define wright-ok
+  `(begin ,@(map make-compare-poly-file wright-files)))
+
+(define wright-ok
+  '(begin (dynamic-let ([st:topo-sort #t]
+                      [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/boyer.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/boyer.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/boyer.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/boyer.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/boyer.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/boyer.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/graphs.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/graphs.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/graphs.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/graphs.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/graphs.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/graphs.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/lattice.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/lattice.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/lattice.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/lattice.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/lattice.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/lattice.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/matrix.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/matrix.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/matrix.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/matrix.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/matrix.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/matrix.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/maze.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/maze.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/maze.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/maze.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/maze.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/maze.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/nbody.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/nbody.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/nbody.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/nbody.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/nbody.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/nbody.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/splay.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/splay.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/splay.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/splay.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/splay.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/splay.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/browse.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/browse.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/browse.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/browse.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/browse.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/browse.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/check.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/check.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/check.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/check.scm"))))
+                (begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/check.scm"))
+                (begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/check.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))))
+                '(begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))
+                '(begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin '(begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))))
+                '(begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))
+                '(begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/nucleic-2.scm"))))
+       (dynamic-let ([st:topo-sort #t] [st:library-prims #t])
+         (begin (begin (st:polymorphism 'none)
+                       (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))
+                (begin (st:polymorphism 'compress)
+                       (begin (begin (st:type-compression-poly 'live)
+                                     (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))
+                              (begin (st:type-compression-poly 'live-few-e)
+                                     (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))
+                              (begin (st:type-compression-poly 'dfa-min-AV)
+                                     (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))))
+                '(begin (st:polymorphism 'copy-con)
+                       (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))
+                '(begin (st:polymorphism 'reanalyze)
+                       (compare-poly-file-one "~/Spidey/wright/dynamic.scm"))))))
+
+;; ======================================================================
+
+(define (poly->matlab . files)
+  (match-let*
+      ([f "/home/cormac/papers/popl95/ Spidey/results/poly.m"]
+       [(l cnth get-counters get-control get-time ctrl-eq? select split)
+        (apply get-results-file files)]
+       [l-p (lambda (p) (select (ctrl-eq? 'st:polymorphism p)))]
+       [l-none (l-p 'none)]
+       [l-copy (l-p 'copy-con)]
+       [l-reanalyze (l-p 'reanalyze)]
+       [l-compress-alg
+        (lambda (alg)
+          (select
+           (lambda (x)
+             (and 
+              (eq? (cadr (assq 'st:polymorphism (get-control x))) 'compress)
+              (eq? (cadr (assq 'st:type-compression-poly (get-control x)))
+                   alg)))))]
+       [l-compress-live (l-compress-alg 'live)]
+       [l-compress-live-noe (l-compress-alg 'live-few-e)]
+       [lists (list  l-reanalyze
+                     l-copy 
+                     l-compress-live
+                     l-compress-live-noe
+                     (l-compress-alg 'dfa-min-AV)
+                     l-none)]
+       [show-pairs `((ast_size  ,(cnth 2))
+                     (num_Tvar   ,(cnth 3))
+                     (num_AV    ,(cnth 4))
+                     (num_con   ,(cnth 5))
+                     (num_edges ,(cnth 6))
+                     (num_AV_a  ,(cnth 7))
+                     (entries   ,(cnth 8))
+                     (ttl_time      ,(get-time 'st:analyze))
+                     (local_time    ,(get-time 'sba-analyze-file))
+                     (parse_time    ,(get-time 'load-parse-expand))
+                     (traverse_time ,(get-time 'traverse-def))
+                     (combine_time  ,(get-time 'top-level-combine))
+                     (live_data     ,(get-time 'live-data))
+                     (min_time      ,(get-time 'minimize-constraints))
+                     (resize_time   ,(get-time 'resize-hash-table))
+                     (topo          ,(get-time 'topological-sort))
+                     (inst          ,(get-time 'instantiate-polymorphic-def))
+                     )])
+
+    (if (file-exists? f) (delete-file f))
+
+    ;;(pretty-print (map cadr l))
+
+    (for-each
+         
+     (match-lambda
+      [(name fn)
+       (printf "==============~n~s~n" name)
+       (for i 0 (apply max (map length lists))
+            (printf "~a: " 
+                    (let* ([none (nth l-none i)]
+                           [f (if none (cadr none) "-")])
+                      (if (string? f)
+                          (padr f 30)
+                          f)))
+            (for-each
+             (lambda (l)
+               (let ([x (nth l i)])
+                 (printf "~a " (if x (padl (fn x) 7) "      -"))))
+             lists)
+            (newline))])
+     show-pairs)
+
+    (with-output-to-file f
+      (lambda ()
+        (for-each
+         
+         (match-lambda
+          [(name fn)
+           (printf "~s = [ " name)
+           (for-each
+            (lambda (l)
+              (for-each (lambda (x) (printf "~s " (if x (fn x) 0))) l)
+              (if (eq? l l-none)
+                  (printf "]~n~n")
+                  (printf "; ")))
+            lists)])
+
+         show-pairs)))))
+
+(define (poly->fig . files)
+  (match-let*
+      ([f "/home/cormac/papers/popl97/analysis-times.tex"]
+       [(l cnth get-counters get-control get-time ctrl-eq? select split)
+        (apply get-results-file files)]
+       [l-p (lambda (p) (select (ctrl-eq? 'st:polymorphism p)))]
+       [l-none (l-p 'none)]
+       [l-copy (l-p 'copy-con)]
+       [l-reanalyze (l-p 'reanalyze)]
+       [l-compress-alg
+        (lambda (alg)
+          (select
+           (lambda (x)
+             (and 
+              (eq? (cadr (assq 'st:polymorphism (get-control x))) 'compress)
+              (eq? (cadr (assq 'st:type-compression-poly (get-control x)))
+                   alg)))))]
+       [l-compress-live (l-compress-alg 'live)]
+       [l-compress-live-noe (l-compress-alg 'live-few-e)]
+       [l-compress-dfa (l-compress-alg 'dfa-min-AV)]
+       [lists (list  )]
+       [atime
+        (lambda (x) 
+          (if x 
+              (- ((get-time 'st:analyze) x) 
+                 ((get-time 'load-parse-expand) x))
+              0))]
+       [doit
+        (lambda ()
+          (for-each
+           (lambda (name lines none copy reanalyze live live-noe dfa)
+             (printf "   {\\tt ~a } & ~s & ~ss " 
+                     name lines 
+                     (/ (round (/ (atime none) 10.0)) 100))
+             (for-each
+              (lambda (x)
+                (printf " & ~a " 
+                        (if (zero? (atime x)) 
+                            '*
+                            (/ (round (/ (atime x) (atime none) 0.010))
+                               100))))
+              (list copy reanalyze live live-noe dfa))
+             (printf " \\\\ ~n"))
+           '(lattice browse splay check graph boyer  
+                     matrix maze nbody nucleic)
+           '(215 233 265 281 621 624 744 857 880 3335)
+           l-none
+           l-copy 
+           l-reanalyze
+           l-compress-live
+           l-compress-live-noe
+           l-compress-dfa))]
+       )
+    (pretty-print (map length (list
+                                          l-none
+           l-copy 
+           l-reanalyze
+           l-compress-live
+           l-compress-live-noe
+           l-compress-dfa)))
+
+    (doit)
+    (if (file-exists? f) (delete-file f))
+    (with-output-to-file f doit)))
+;; ======================================================================
+
+(define (fixup x)
+  (let ([y (recur loop ([x x]) 
+             (if (null? x)
+               '()
+               (cons (caddr x) (loop (cddddr x)))))])
+    (apply + y)))
+
+
+
diff --git a/collects/mrspidey/Sba/driver.ss b/collects/mrspidey/Sba/driver.ss
new file mode 100644
index 0000000..b3d321d
--- /dev/null
+++ b/collects/mrspidey/Sba/driver.ss
@@ -0,0 +1,93 @@
+;; driver.ss - driver file for text version
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; ----------------------------------------------------------------------
+
+'(define st:defconstructor add-default-constructor!)
+'(define st:defprim add-default-primitive!)
+'(define st:type-alias default-constructor-alias!)
+'(define (st:deftype name nutype) 
+   (install-input-type-expander!
+    (lambda (type)
+      (if (eq? type name) nutype type))))
+
+(define st:set-debug set-debug-flag)
+
+; ----------------------------------------------------------------------
+
+(define st:analyze
+  (lambda (file)
+    (analyze-program file)
+    (void)))
+
+(define st:
+  (lambda (file)
+    (let ([defs (analyze-program file)])
+      (calc-checks defs)
+      (void))))
+
+
+; ----------------------------------------------------------------------
+
+(define (st:type-fn . args)
+  ;;(when (null? defs-bind)
+  ;;  (error 'st:type "Checking not done yet, use st:"))
+  (let* ([show
+           (lambda (name)
+             (list (zodiac:binding-var name)
+               ':
+               (FlowType->SDL (atenv:lookup global-def-env name))))]
+          [show*
+            (lambda (b*)
+              (map show b*)
+              ;;(for-each (lambda (b) (pretty-print (show b))) b*)
+              )])
+
+    (if (null? args)
+      ;; Show all
+      (show* (atenv:domain global-def-env))
+      ;; Show selectively
+      (show*
+        (filter
+          (lambda (name) (memq (zodiac:binding-var name) args))
+          (atenv:domain global-def-env))))))
+
+;; ----------------------------------------------------------------------
+
+(define st:help
+  (lambda ()
+    ;(printf "Commands for SBA Soft Scheme Version ~a~%" st:version)
+    (printf "  (st:analyze file)          analyze file~n")
+    (printf "  (st:check file)                 type check file~%")
+;    (printf "  (st:write file [output])       type check file and write it~%")
+    (printf "  (st:type [definition ...])     show type of top level defs~n")
+;    (printf "  (st:ltype var)                 show type of internal vars~n")
+;    (printf "  (st:why N)                     prints cause of check N~n")
+    (printf "  (st:control [param [value]])   show or change parameters~n")
+    (printf "  (st:help)                      prints this message~%")))
+
+; ----------------------------------------------------------------------
+;  (st:check    file (output))    type check file
+;  (st:bench    file)             execute type checked file fast
+;  (st:run      file)             execute type checked file
+; ----------------------------------------------------------------------
+
+(st:language 'DrScheme)
+;(st:language 'MrEd)
+
+;(printf "DrScheme selected~n")
diff --git a/collects/mrspidey/Sba/exn-hierarchy.ss b/collects/mrspidey/Sba/exn-hierarchy.ss
new file mode 100644
index 0000000..6bd6691
--- /dev/null
+++ b/collects/mrspidey/Sba/exn-hierarchy.ss
@@ -0,0 +1,105 @@
+(define-struct exn (message debug-info))
+(define-struct (exn:user struct:exn) ())
+(define-struct (exn:syntax struct:exn) (expr))
+(define-struct (exn:variable struct:exn) (id))
+(define-struct (exn:application struct:exn) (value))
+(define-struct (exn:application:non-procedure struct:exn:application) ())
+(define-struct (exn:application:arity struct:exn:application) (expected))
+(define-struct (exn:application:type struct:exn:application) (expected))
+(define-struct (exn:application:range struct:exn:application) ())
+(define-struct (exn:application:range:bounds struct:exn:application:range) (min max))
+(define-struct (exn:application:range:bounds:vector struct:exn:application:range:bounds) ())
+(define-struct (exn:application:range:bounds:string struct:exn:application:range:bounds) ())
+(define-struct (exn:application:range:bounds:struct struct:exn:application:range:bounds) ())
+(define-struct (exn:application:range:list struct:exn:application:range) ())
+(define-struct (exn:application:list-sizes struct:exn:application) ())
+(define-struct (exn:application:map-arity struct:exn:application) (provided))
+(define-struct (exn:application:integer struct:exn:application) ())
+(define-struct (exn:application:list struct:exn:application) ())
+(define-struct (exn:application:math struct:exn:application) ())
+(define-struct (exn:application:math:zero struct:exn:application:math) ())
+(define-struct (exn:application:math:infinity struct:exn:application:math) ())
+(define-struct (exn:application:math:negative struct:exn:application:math) ())
+(define-struct (exn:application:math:radix struct:exn:application:math) ())
+(define-struct (exn:application:mode-conflict struct:exn:application) (filename))
+(define-struct (exn:application:file-position struct:exn:application) ())
+(define-struct (exn:application:fprintf struct:exn:application) ())
+(define-struct (exn:application:fprintf:extra-arguments struct:exn:application:fprintf) (extras))
+(define-struct (exn:application:fprintf:no-argument struct:exn:application:fprintf) ())
+(define-struct (exn:application:fprintf:argument-type struct:exn:application:fprintf) (expected))
+(define-struct (exn:else struct:exn) ())
+(define-struct (exn:struct struct:exn) ())
+(define-struct (exn:struct:struct-type struct:exn:struct) (value))
+(define-struct (exn:object struct:exn) ())
+(define-struct (exn:object:class-type struct:exn:object) (value))
+(define-struct (exn:object:interface-type struct:exn:object) (value))
+(define-struct (exn:object:generic struct:exn:object) (object))
+(define-struct (exn:object:inherit struct:exn:object) (ivar))
+(define-struct (exn:object:implement struct:exn:object) (ivar))
+(define-struct (exn:object:class-ivar struct:exn:object) (class ivar))
+(define-struct (exn:object:interface-ivar struct:exn:object) (interface ivar))
+(define-struct (exn:object:ivar struct:exn:object) (object ivar))
+(define-struct (exn:object:private-class struct:exn:object) (class))
+(define-struct (exn:object:init struct:exn:object) (object class))
+(define-struct (exn:object:init:multiple struct:exn:object:init) ())
+(define-struct (exn:object:init:never struct:exn:object:init) ())
+(define-struct (exn:unit struct:exn) ())
+(define-struct (exn:unit:non-unit struct:exn:unit) (value))
+(define-struct (exn:unit:arity struct:exn:unit) (unit))
+(define-struct (exn:unit:import struct:exn:unit) (in-unit out-unit in-tag out-tag name))
+(define-struct (exn:unit:export struct:exn:unit) (unit tag name))
+(define-struct (exn:unit:invoke struct:exn:unit) ())
+(define-struct (exn:unit:invoke:variable struct:exn:unit:invoke) (name))
+(define-struct (exn:unit:signature struct:exn:unit) ())
+(define-struct (exn:unit:signature:non-signed-unit struct:exn:unit:signature) (value))
+(define-struct (exn:unit:signature:arity struct:exn:unit:signature) (unit))
+(define-struct (exn:unit:signature:match struct:exn:unit:signature) (dest-context src-context variable))
+(define-struct (exn:unit:signature:match:missing struct:exn:unit:signature:match) ())
+(define-struct (exn:unit:signature:match:extra struct:exn:unit:signature:match) ())
+(define-struct (exn:unit:signature:match:kind struct:exn:unit:signature:match) ())
+(define-struct (exn:read struct:exn) (port))
+(define-struct (exn:read:paren struct:exn:read) ())
+(define-struct (exn:read:number struct:exn:read) (input))
+(define-struct (exn:read:char struct:exn:read) (input))
+(define-struct (exn:read:eof struct:exn:read) (expected))
+(define-struct (exn:read:dot struct:exn:read) ())
+(define-struct (exn:read:unsupported struct:exn:read) (input))
+(define-struct (exn:read:vector-length struct:exn:read) (input))
+(define-struct (exn:read:compiled struct:exn:read) ())
+(define-struct (exn:read:graph struct:exn:read) ())
+(define-struct (exn:i/o struct:exn) ())
+(define-struct (exn:i/o:read struct:exn:i/o) (port))
+(define-struct (exn:i/o:write struct:exn:i/o) (port))
+(define-struct (exn:i/o:filesystem struct:exn:i/o) (pathname))
+(define-struct (exn:i/o:filesystem:path struct:exn:i/o:filesystem) ())
+(define-struct (exn:i/o:filesystem:path:username struct:exn:i/o:filesystem:path) ())
+(define-struct (exn:i/o:filesystem:file struct:exn:i/o:filesystem) ())
+(define-struct (exn:i/o:filesystem:directory struct:exn:i/o:filesystem) ())
+(define-struct (exn:i/o:filesystem:collection struct:exn:i/o:filesystem) ())
+(define-struct (exn:i/o:filesystem:file-exists struct:exn:i/o:filesystem) ())
+(define-struct (exn:i/o:port-closed struct:exn:i/o) (port))
+(define-struct (exn:i/o:user-port struct:exn:i/o) (port))
+(define-struct (exn:i/o:tcp struct:exn:i/o) ())
+(define-struct (exn:i/o:tcp:connect struct:exn:i/o:tcp) (address port-id))
+(define-struct (exn:i/o:tcp:listen struct:exn:i/o:tcp) (port-id))
+(define-struct (exn:i/o:tcp:accept struct:exn:i/o:tcp) (listener))
+(define-struct (exn:i/o:tcp:listener-closed struct:exn:i/o:tcp) (listener))
+(define-struct (exn:misc struct:exn) ())
+(define-struct (exn:misc:unsupported struct:exn:misc) ())
+(define-struct (exn:misc:user-break struct:exn:misc) ())
+(define-struct (exn:misc:out-of-memory struct:exn:misc) ())
+(define-struct (exn:misc:parameterization struct:exn:misc) (value))
+(define-struct (exn:misc:defmacro struct:exn:misc) (value))
+(define-struct (exn:misc:expansion-time struct:exn:misc) ())
+(define-struct (exn:misc:constant struct:exn:misc) (id))
+(define-struct (exn:misc:continuation struct:exn:misc) ())
+(define-struct (exn:misc:thread struct:exn:misc) ())
+(define-struct (exn:misc:thread:kill struct:exn:misc:thread) ())
+(define-struct (exn:misc:semaphore struct:exn:misc) ())
+(define-struct (exn:misc:hash-table struct:exn:misc) (key))
+(define-struct (exn:misc:regexp struct:exn:misc) ())
+(define-struct (exn:misc:process struct:exn:misc) ())
+(define-struct (exn:misc:dynamic-extension struct:exn:misc) (name))
+(define-struct (exn:misc:dynamic-extension:open struct:exn:misc:dynamic-extension) ())
+(define-struct (exn:misc:dynamic-extension:version struct:exn:misc:dynamic-extension) ())
+(define-struct (exn:misc:dynamic-extension:initialize struct:exn:misc:dynamic-extension) ())
diff --git a/collects/mrspidey/Sba/expander-boot.ss b/collects/mrspidey/Sba/expander-boot.ss
new file mode 100644
index 0000000..b1220e4
--- /dev/null
+++ b/collects/mrspidey/Sba/expander-boot.ss
@@ -0,0 +1,105 @@
+;; expander-boot.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+(printf "Loading expander-boot.ss~n")
+
+(define __keep-mrspidey-annotations #t)
+(load "~cormac/scheme/mzschemerc.ss")
+(match:set-error-control 'error)
+
+(defmacro assert args '(void))
+(defmacro begin-test-case args  `(begin ,@args))
+;(defmacro type: args `(type:-quote (quote ,args)))
+(defmacro primitive: args `(type: ,@args))
+
+(defmacro include-exp (f) 
+  (let ([p (open-input-file f)])
+    (begin0 
+      (read p)
+      (close-input-port p))))
+
+;; ---------- structures --------------------------------------------------
+;; field = (: sym type) | (! sym type) | sym
+;; field-name = sym
+
+(define (struct-expander-fn struct: const?)
+  (#%let ([make-exn make-exn:syntax]
+          [debug debug-info-handler])
+  (#%lambda body
+     (#%let* ([syntax-error
+               (#%lambda (s)
+                         (#%raise
+                          (make-exn
+                           (#%format "define-struct: ~a" s)
+                           ((debug))
+                           (#%cons 'define-struct body))))]
+              [field->field-name
+               (match-lambda
+                [((or ': '!) sym _) sym]
+                [(? symbol? sym) sym]
+                [x (syntax-error (format "Bad field ~s" x))])]
+              [field-mutable?
+               (match-lambda
+                [('! sym _) #t]
+                [_ (not const?)])]
+              [build-struct-names
+               (#%lambda (name fields)
+                         (#%let ([name (#%symbol->string name)]
+                                 [+ #%string-append])
+                                (#%map #%string->symbol
+                                       (#%append
+                                        (#%list 
+                                         (+ "struct:" name)
+                                         (+ "make-" name)
+                                         (+ name "?"))
+                                        (#%apply
+                                         #%append
+                                         (#%map
+                                          (#%lambda (field) 
+                                                    (let ([f
+                                                           (symbol->string
+                                                            (field->field-name field))])
+                                                      (cons
+                                                       (+ name "-" f)
+                                                       (if (field-mutable? field)
+                                                           (list (+ "set-" name "-" f "!"))
+                                                           '()))))
+                                          fields))))))])
+	    (#%or (#%pair? body)
+		  (syntax-error "empty declaration"))
+	    (#%or (#%= 2 (#%length body))
+		  (syntax-error "wrong number of parts"))
+	    (#%or (#%symbol? (#%car body))
+		  (#%and (#%pair? (#%car body))
+			 (#%symbol? (#%caar body))
+			 (#%pair? (#%cdar body))
+			 (#%null? (#%cddar body)))
+		  (syntax-error "first part must be an identifier or identifier-expression pair"))
+	    (#%or (#%list? (#%cadr body))
+		  (syntax-error "improper field list"))
+	    (#%let* ([name (#%if (#%symbol? (#%car body))
+			      (#%car body)
+			      (#%caar body))]
+		  [fields (#%cadr body)])
+	      `(#%define-values ,(build-struct-names name fields)
+                                (,struct: ,@body)))))))
+
+;(#%define-macro define-const-typed-structure (struct-expander-fn '#%const-typed-structure #t))
+(#%define-macro define-const-typed-structure (struct-expander-fn '#%typed-structure #f))
+(#%define-macro define-typed-structure (struct-expander-fn '#%typed-structure #f))
+
+(printf "expander-boot.ss done~n")
diff --git a/collects/mrspidey/Sba/gram.ss b/collects/mrspidey/Sba/gram.ss
new file mode 100644
index 0000000..e70f0ae
--- /dev/null
+++ b/collects/mrspidey/Sba/gram.ss
@@ -0,0 +1,322 @@
+;; gram.ss
+
+; ======================================================================
+
+(define debugging-gram #f)
+(defmacro pretty-debug-gram args `(when debugging-gram (pretty-print ,@args)))
+
+; ======================================================================
+; VIEWING CONSTRAINTS AS GRAMMARS
+; ======================================================================
+; Non-Terminals
+
+(define-structure (NT AVS type) 
+  ([rhs* '()][prop #f][tag #f][sources #f][num #f][edgefrom '()]))
+
+(define mk-AVS-NTs!
+  (lambda (AVS)
+    (set-AVS-L!  AVS (make-NT AVS 'L ))
+    (set-AVS-U!  AVS (make-NT AVS 'U ))
+    (set-AVS-LI! AVS (make-NT AVS 'LI))
+    (set-AVS-UI! AVS (make-NT AVS 'UI))))
+
+(define same-nt-type?
+  (match-lambda*
+   [(($ NT _ t1) ($ NT _ t2)) (eq? t1 t2)]))
+
+(define nt-chg-AVS
+  (match-lambda*
+   [(f ($ NT x type)) (make-NT (f x) type)]))
+
+(define drop-I
+  (match-lambda
+   [(and nt ($ NT AVS type _))
+    (case type
+      [(or 'L 'U) nt]
+      [LI (AVS-L AVS)]
+      [UI (AVS-U AVS)])]))
+
+(define invert-nt
+  (match-lambda
+   [($ NT AVS 'L)  (AVS-UI AVS)]
+   [($ NT AVS 'LI) (AVS-U  AVS)]
+   [($ NT AVS 'U)  (AVS-LI AVS)]
+   [($ NT AVS 'UI) (AVS-L  AVS)]))
+
+; ======================================================================
+; Right hand side of a production
+
+(define-structure (rhs* grsym misc nts))
+(define (make-rhs grsym nt) (make-rhs* grsym '() (list nt)))
+
+(define-structure (grsym ineq fn sign template field-no))
+;; ineq is '<= or '>=
+;; fn   is 'inj, 'inj-tst or 'ext
+;; sign is #t (monotonic) or #f (antimonotonic)
+;; field-no may be #f
+
+(define (make-grsym->=inj+     t f) (make-grsym '>= 'inj     #t t f))
+(define (make-grsym->=inj-     t f) (make-grsym '>= 'inj     #f t f))
+(define (make-grsym->=inj?     t f) (make-grsym '>= 'inj     '? t f))
+
+(define (make-grsym-<=inj-tst+ t f) (make-grsym '<= 'inj-tst #t t f))
+(define (make-grsym-<=inj-tst- t f) (make-grsym '<= 'inj-tst #f t f))
+
+(define (make-grsym-<=ext+     t f) (make-grsym '<= 'ext     #t t f))
+(define (make-grsym->=ext-     t f) (make-grsym '>= 'ext     #f t f))
+
+(define (make-grsym->=ext+     t f) (make-grsym '>= 'ext     #t t f))
+(define (make-grsym-<=ext-     t f) (make-grsym '<= 'ext     #f t f))
+
+;;(define (make-grsym-filter  filter) (make-grsym '<= 'filter #t filter #f))
+(define (make-grsym-filter  filter) (make-grsym '>= 'filter #t filter #f))
+(define grsym-crossover             '>=crossover)
+   
+;; a grsym can also be '>=epsilon or '<=epsilon
+
+(define grsym-eq?
+  (match-lambda*
+   [(($ grsym i1 f1 s1 t1 n1) ($ grsym i2 f2 s2 t2 n2))
+    (and (eq? i1 i2) (eq? f1 f2) (eq? t1 t2) (eqv? n1 n2))]
+   [(x y) (eq? x y)]))
+
+(define invert-grsym
+  (match-lambda
+   [($ grsym '>= 'inj sign template field-no)
+    (make-grsym '<= 'ext sign template field-no)]
+   [($ grsym '<= 'inj-tst sign template field-no)
+    (make-grsym '>= 'ext sign template field-no)]
+   [($ grsym '>= 'filter #t filter #f)
+    (make-grsym '<= 'unfilter #t filter #f)]
+   ['>=crossover '<=crossover]
+   [(and g ($ grsym))
+    (error 'invert-grsym "Bad grsym ~s" (grsym->rep g))]))
+
+(define grsym-epsilon-or-filter?
+  (match-lambda
+   [(? symbol?) #t]
+   [($ grsym _ 'filter) #t]
+   [_ #f]))
+
+; ======================================================================
+; Parameters for creating grammar
+
+(define-structure 
+  (parameters-grammar 
+   interp-sign                          ; applied to sign of each field
+   prims                                ; #t => treat prims as constants
+   filters                              ; #t => filters are not epsilon edges
+   assignable-fields                    ; #t => assignable fields in grammar
+   structure-opaque                     ; #t => structures are constants
+   ))
+
+; ======================================================================
+;; Prepare for creating grammar
+
+(define (prep-gram!)
+  (for-each mk-AVS-NTs! list-AVS))
+
+; ======================================================================
+;; Initializing the NT fields of an AVS
+
+(define (add-rhs! NT rhs)
+  (pretty-debug-gram
+    (match rhs
+      [($ rhs* grsym _ nts)
+       (assert (list? nts))
+       (list `(add-rhs! ,(nt->sym NT) ,(grsym->rep grsym) 
+                        ,(map nt->sym nts)))]))
+ (set-NT-rhs*! NT (cons rhs (NT-rhs* NT))))
+
+; ----------------------------------------------------------------------
+
+(define (for-each-calc-prods-L L paras fn)
+  (match L
+    [($ NT AVS 'L)
+     (for-each
+      (match-lambda
+       [($ AV _ (and template ($ template _ signs _ _ _ _ structure?))
+           misc fields)
+        (if (or (zero? (vector-length fields))
+                (and structure?
+                     (parameters-grammar-structure-opaque paras)))
+            (fn (make-rhs* (make-grsym '>= 'inj #t template '?) misc '()))
+            (for i 0 (vector-length fields)
+                 (let ([field (vector-ref fields i)]
+                       [interp-sign (parameters-grammar-interp-sign paras)]
+                       [sign (interp-sign (vector-ref signs i))])
+                   (fn (make-rhs*
+                        (make-grsym '>= 'inj (eq? sign '>=inj+) template i)
+                        misc
+                        (case sign
+                          [>=inj+ (list (AVS-L field))]
+                          [>=inj-
+                           (if (or #f ;; mk-assignable-part-fields?
+                                   (eq? template template-lam))
+                               (map AVS-U (AVS-transitive-edgeto field))
+                               '())]))))))])
+      (get-AVS-objs AVS))]))
+
+; ----------------------------------------------------------------------
+
+(define (for-each-calc-prods-U U paras fn)
+  (match U
+    [($ NT AVS 'U)
+     (let ([interp-sign (parameters-grammar-interp-sign paras)])
+       (for-each
+        (match-lambda
+         [($ con _ (and template ($ template type signs)) field-no AVS2 misc)
+          (case (interpret-sign (vector-ref signs field-no))
+            [>=inj+
+             (fn (make-rhs*
+                  (make-grsym-<=inj-tst+ template field-no)
+                  misc
+                  (list (AVS-U AVS2))))]
+            [>=inj-
+             (fn (make-rhs*
+                  (make-grsym-<=inj-tst- template field-no)
+                  misc
+                  (list (AVS-U AVS2))))])]
+         [($ con-filter _ the-filter AVS2)
+          (fn (make-rhs*
+               (make-grsym-filter the-filter)
+               '()
+               (list (AVS-U AVS2))))])
+        (AVS-constraints AVS)))
+     (for-each
+      (lambda (AVS2) (fn (make-rhs* '<=epsilon '() (list (AVS-U AVS2)))))
+      (AVS-transitive-edgeto AVS))]))
+
+; ----------------------------------------------------------------------
+
+(define (for-each-calc-prods nt paras fn)
+  (match nt
+    [($ NT AVS 'L) (for-each-calc-prods-L nt paras fn)]
+    [($ NT AVS 'U) (for-each-calc-prods-U nt paras fn)]))
+
+; ======================================================================
+
+
+
+
+
+
+(define (calc-productions! 
+         live-nts live-nt?
+         mk-L? mk-U? mk-LI? mk-UI?
+         L->LI
+         mk-assignable-part-fields?
+         treat-all-mono)
+
+  ;; live-AVS, crossover-AVS, live-nt and live-nt? 
+  ;;    all come from calc-live-AVS-nt
+  ;; mk-...     : bool -- controls which NTs to produce
+  ;; L->LI, ... : bool -- controls L->LI production rule
+
+  (let ([interpret-sign
+         (if treat-all-mono
+             (lambda (x) '>=inj+)
+             (lambda (x) x))])
+
+    (for-each (lambda (nt) (set-NT-rhs*! nt '()))
+              live-nts)
+
+    ;; ------ Now fill NTs from AV, constraints and edges
+
+    (for-each
+     (lambda (AVS)
+       (pretty-debug-gram `(Prods for AVS ,(name-for-AVS AVS)))
+
+       ;; ------ Invert AV
+       (when (and mk-L? (live-nt? (AVS-L AVS)))
+         (AVs->prods AVS interpret-sign live-nt?))
+
+       ;; ------ Invert constraints
+       (when (and mk-U? (live-nt? (AVS-U AVS)))
+         (for-each
+          (match-lambda
+           [($ con _ (and template ($ template type signs)) field-no AVS2 misc)
+            (case (interpret-sign (vector-ref signs field-no))
+              [>=inj+
+               (add-rhs! (AVS-U AVS)
+                         (make-rhs*
+                          (make-grsym-<=inj-tst+ template field-no)
+                          misc
+                          (filter live-nt? 
+                                  (map AVS-U (AVS-transitive-edgeto AVS2)))))]
+              [>=inj-
+               (add-rhs! (AVS-U AVS)
+                         (make-rhs*
+                          (make-grsym-<=inj-tst- template field-no)
+                          misc
+                          (filter live-nt? (list (AVS-L AVS2)))))])]
+           [($ con-filter _ the-filter AVS2)
+            (add-rhs! (AVS-U AVS)
+                      (make-rhs*
+                       (make-grsym-filter the-filter)
+                       '()
+                       (filter live-nt? 
+                               (map AVS-U (AVS-transitive-edgeto AVS2)))))
+            '(for-each
+              (lambda (to)
+                (when (live-nt? (AVS-L to))
+                  (add-rhs! (AVS-L to)
+                            (make-rhs*
+                             (make-grsym-filter the-filter)
+                             '()
+                             (list (AVS-L AVS))))))
+              (AVS-transitive-edgeto AVS2))
+            ])
+          (AVS-constraints AVS)))
+       )
+     live-AVS)
+
+    ;; ------ Add L->LI productions
+    (when L->LI
+      (for-each
+       (lambda (AVS)
+         (for-each 
+          (lambda (to)
+            (when (and (NT? (AVS-L to)) (live-nt? (AVS-L to)))
+              (add-rhs! (AVS-L to)
+                        (make-rhs* grsym-crossover '() (list (AVS-LI AVS))))))
+          (AVS-transitive-edgeto AVS)))
+       crossover-AVS))
+
+    ;; ------ convert L, U productions into LI, UI productions
+    (pretty-debug '(inverting productions))
+
+    (for-each
+     (lambda (nt)
+       (for-each
+        (match-lambda
+         [($ rhs* grsym misc to-nts)
+          (unless (eq? grsym '<=crossover)
+            (let* ([inv-grsym (invert-grsym grsym)]
+                   [inv-nt (invert-nt nt)]
+                   [inv-rhs (make-rhs* inv-grsym misc (list inv-nt))])
+              (for-each (lambda (to) (add-rhs! (invert-nt to) inv-rhs))
+                        to-nts)))])
+        (NT-rhs* nt)))
+     live-nts)
+
+    (let ([live-nts
+           (apply append
+                  (map
+                   (match-lambda
+                    [($ NT AVS 'L) (list (AVS-L AVS) (AVS-UI AVS))]
+                    [($ NT AVS 'U) (list (AVS-U AVS) (AVS-LI AVS))])
+                   live-nts))])
+
+      ;; Now group together all productions for given NT with given grsym
+      (for-each
+       (lambda (nt)
+         (let ([rhs* (NT-rhs* nt)])
+           (set-NT-rhs*! nt '())
+           (for-each (lambda (rhs) 
+                       (assert (list? (rhs*-nts rhs)))
+                       (add-rhs! nt rhs))
+                     (group-rhs* rhs*))))
+       live-nts)
+
+      (list live-nts))))
diff --git a/collects/mrspidey/Sba/hash.ss b/collects/mrspidey/Sba/hash.ss
new file mode 100644
index 0000000..12c28f1
--- /dev/null
+++ b/collects/mrspidey/Sba/hash.ss
@@ -0,0 +1,147 @@
+;; hash.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-struct hash-table-state 
+  (hash-table-size entries-in-table
+    resize-table-size entry->hash-fn
+    hash-table))
+
+ ;;------------------------------------------------------------
+
+ (define prime1 83)
+ (define prime2 1789)
+ (define default-hash-table-size (* 32 1024)) 
+ (define resize-table-fraction 0.6)
+
+ ;;------------------------------------------------------------
+
+ (define hash-table-size   0)
+ (define entries-in-table  0)
+ (define resize-table-size 0)
+ (define entry->hash-fn    (void))
+ (define hash-table        (void))
+
+ ;;------------------------------------------------------------
+
+ (define (init-hash-table entry->hash size)
+   (set! hash-table-size (if (zero? size) default-hash-table-size size))
+   (set! entries-in-table 0)
+   (set! resize-table-size 
+       (inexact->exact 
+         (round (* hash-table-size resize-table-fraction))))
+   (set! entry->hash-fn entry->hash)
+   (set! hash-table (make-vector hash-table-size '())))
+
+ (define (capture-hash-table-state)
+   (make-hash-table-state hash-table-size entries-in-table
+                          resize-table-size entry->hash-fn
+                          hash-table))
+
+(define restore-hash-table-state!
+   (match-lambda
+    [($ hash-table-state t1 t2 t3 t4 t5)
+     (set! hash-table-size t1)
+     (set! entries-in-table t2)
+     (set! resize-table-size t3)
+     (set! entry->hash-fn t4)
+     (set! hash-table t5)]))
+
+(define free-hash-table-state!
+  (match-lambda
+    [($ hash-table-state t1 t2 t3 t4 t5)
+      (assert (not (eq? t5 hash-table)))
+      (vector-zero! t5)]))
+
+(define (prompt-hash-table-state)
+  (list (capture-hash-table-state)
+    (vector-length hash-table)
+    (recur loop ([i (sub1 (vector-length hash-table))])
+      (if (< i 0)
+        '()
+        (if (null? (vector-ref hash-table i))
+          (loop (sub1 i))
+          (cons (cons i (vector-ref hash-table i)) (loop (sub1 i))))))))
+
+(define unprompt-hash-table-state!
+  (match-lambda
+    [(state vec-size vec-entries)
+      (restore-hash-table-state! state)
+      (for i 0 (vector-length hash-table) (vector-set! hash-table i '()))
+      (for-each
+        (match-lambda
+          [(i . elem) (vector-set! hash-table i elem)])
+        vec-entries)]))
+
+ ;;------------------------------------------------------------
+
+
+ ;; (define (hash-fn n1 n2)
+ ;;  (fxlogand (+ (* n1 prime1) (* n2 prime2)) (sub1 hash-table-size)))
+
+ (define (hash-fn n1 n2)
+   (modulo (+ (* n1 prime1) (* n2 prime2)) hash-table-size))
+
+ (define (hash-fn* n*) (foldl hash-fn 0 n*))
+
+ (define (add-entry h entry)
+   (vector-set! hash-table h (cons entry (vector-ref hash-table h)))
+   (set! entries-in-table (add1 entries-in-table))
+   '(if (zero? (mod entries-in-table 10000))
+        (printf "Entries ~s~n" entries-in-table))
+   (when (>= entries-in-table resize-table-size)
+     (resize-hash-table)))
+
+ (define (resize-hash-table)
+   (set! hash-table-size (* 2 hash-table-size))
+   (let ( [old hash-table]
+          [s (format "Resizing hash table to ~s" hash-table-size)])
+     (mrspidey:progress s '...)
+     (flush-output)
+     (set! hash-table (make-vector hash-table-size '()))
+     (set! resize-table-size 
+         (inexact->exact 
+          (round (* hash-table-size resize-table-fraction))))
+     (for i 0 (vector-length old)
+          (map 
+           (lambda (entry)
+             (let ([h (entry->hash-fn entry)])
+               (vector-set! hash-table h
+                            (cons entry (vector-ref hash-table h)))))
+           (vector-ref old i)))
+     (mrspidey:progress s 'done)
+     ;;(show-stat-small)
+     ))
+
+ (define (hash-table-list h) (vector-ref hash-table h))
+
+ (define (hash-find h ok?)
+   (recur loop ([l (vector-ref hash-table h)])
+     (cond [(null? l) #f]
+           [(ok? (car l)) (car l)]
+           [else (loop (cdr l))])))
+
+ (define (hash-table-info)
+   (list hash-table-size entries-in-table
+         (recur loop ([i 0][c 0])
+           (if (= i hash-table-size) c
+               (let ([l (length (vector-ref hash-table i))])
+                 (loop (add1 i)
+                       (+ c (max 0 (- l 1)))))))))
+
+ ;;------------------------------------------------------------
+
diff --git a/collects/mrspidey/Sba/hyper.ss b/collects/mrspidey/Sba/hyper.ss
new file mode 100644
index 0000000..65c86fa
--- /dev/null
+++ b/collects/mrspidey/Sba/hyper.ss
@@ -0,0 +1,601 @@
+; hyper.ss - interface to GUI
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+
+(define (st:analyze-and-make-annotations filename)
+  (analysis-set-arrow-filter! #f)
+  (record-analyzed-file
+   filename
+   (lambda () (open-code-file filename))
+   (lambda () (analyze-program filename))))
+
+(define (calc-annotations defs)
+  (match-let*
+      ([type-annotations (calc-type-annotations defs)]
+       [(check-annotations uncheck-annotations) (calc-checks defs)]
+       [all-annotations 
+        (vector type-annotations check-annotations uncheck-annotations)])
+    ;;(pretty-debug `(links ,all-annotations))
+    all-annotations))
+	          
+;;----------------------------------------------------------------------
+    
+(define arrow-filter #f)          ; if not #f, then a list of templates
+; only show pred with matching AV
+
+(define (analysis-set-arrow-filter! C)
+  (set! arrow-filter
+      (if C 
+          (map lookup-template (list C))
+          #f)))
+
+(define (analysis-filter-on?)
+  (and arrow-filter (symbol->string (template-type (car arrow-filter)))))
+
+(define (analysis-get-filters)
+  (cons 
+    (cons "No filter" #f)
+    (map 
+      (lambda (C) (cons (symbol->string C) C))
+      (append
+        `( nil num sym str void undefined true false 
+           box cons vec eof iport oport
+           promise unit thread hash-table regexp parameterization semaphore)
+        (filter
+          (lambda (x) x)
+          (hash-table-map
+            constructor-env
+            (lambda (c template)
+              (and
+                (memq template-structure (template-super-templates template))
+                c))))))))
+
+;; ------------------------------
+
+(define (objs-contain-filter? objs)
+  (or 
+    (and
+      (eq? arrow-filter #f)
+      (not (null? objs)))
+    (ormap 
+      (lambda (AV)
+        (memq (AV-template AV) arrow-filter))
+      objs)))
+
+(define (tvar-contain-filter-mvalues? get-Tvar-objs tvar)
+  (or
+    (objs-contain-filter? (get-Tvar-objs tvar))
+    (ormap
+      (match-lambda
+        [($ AV _ (? (eqc? template-mvalues)) _ #(tvar-mvlist))
+          ;;(pretty-debug `(tvar-mvlist ,(Tvar-name tvar-mvlist)))
+          (ormap
+            (match-lambda
+              [($ AV _ (? (eqc? template-cons)) _ #(tvar-car-mvlist _))
+                (objs-contain-filter? (get-Tvar-objs tvar-car-mvlist))]
+              [_ #f])
+            (get-Tvar-objs tvar-mvlist))]
+        [_ #f])
+      (get-Tvar-objs tvar))))
+
+(define (FlowType-contains-filter? ftype)
+  ;(pretty-debug `(FlowType-contains-filter? ,(FlowType-name ftype)))
+  (or
+    (not arrow-filter)
+    (match (FlowType->Atype ftype)
+      [(or (? atconst?) (? atprim?) (? Tvar?))
+        (tvar-contain-filter-mvalues? Tvar-objs (FlowType->Tvar ftype))]
+      [($ atvalues (val1 . _))
+        (FlowType-contains-filter? val1)]
+      ;; other atypes are atschema atthunk, atstruct, atunit, atlunit
+      ;; all are too expensive to convert.
+      [x
+        (pretty-debug  `(FlowType-contains-filter? unhandled-atype x))
+        #f])))
+
+(define (FlowType-orig-objs-contains-filter? ftype)
+  ;;(pretty-debug `(FlowType-orig-contains-filter? ,(FlowType-name ftype)))
+  (match (FlowType->Atype ftype)
+    [(or (? Tvar?))
+      (tvar-contain-filter-mvalues? Tvar-orig-objs (FlowType->Tvar ftype))]
+    [($ atvalues (val1 . _))
+      (FlowType-orig-objs-contains-filter? val1)]
+    ;; other atypes are atschema atthunk, atstruct, atunit, atlunit
+    ;; all are too expensive to convert.
+    [x
+      (pretty-debug  `(FlowType-orig-objs-contains-filter? unhandled-atype x))
+      #f]))
+
+;;----------------------------------------------------------------------
+;; Abstracts over parents and children
+
+(define analysis-walk1
+  (lambda (start in-get-edges file-visable?)
+    (assert (FlowType? start))
+    (pretty-debug `(analysis-walk1 ,(FlowType-name start)))
+    (if (string? (FlowType-type-annotation start))
+      ;; start from .za file, show no edges
+      '()
+      (letrec*
+        ( [traversed '()]               ; list of FlowType's
+          [preds '()]                   ; visable FlowType's
+          [get-edges
+            (lambda (ftype)
+              (let ([r (in-get-edges ftype)])
+                (pretty-debug `(get-edges ,(map FlowType-name (cons ftype r))))
+                r))]
+          [traverse 
+            (lambda (ftype)
+              (pretty-debug `(traverse ,(FlowType-name ftype)))
+              (when 
+                (and
+                  (FlowType-contains-filter? ftype)
+                  (not (memq ftype traversed)))
+                (set! traversed (cons ftype traversed))
+                (let* 
+                  ( [ftype-w/-ta (get-ftype-w/-ta ftype)]
+                    [ta (and ftype-w/-ta 
+                          (FlowType-type-annotation ftype-w/-ta))])
+                  (pretty-debug
+                    `(traverse-ftype-w/-ta 
+                       ,(and ftype-w/-ta (FlowType-name ftype-w/-ta))))
+                 
+                  (cond
+                    [(not ta)
+                      ;; invisable
+                       ;; Go back to parents
+                      (for-each traverse (get-edges ftype))]
+
+                    [(string? ta)
+                      (if (file-visable? ta)
+                        
+                        ;; ftype from .za file, source file is loaded
+                        ;; can follow this edge unless dest is from same file
+                        (for-each
+                          (lambda (ftype2)
+                            (let ([ta2 (FlowType-type-annotation ftype2)])
+                              (unless (and (string? ta2) (string=? ta ta2))
+                                (traverse ftype2))))
+                          (get-edges ftype))
+                        
+                        ;; .za file, source file not loaded
+                        (set! preds (cons ftype-w/-ta preds)))]
+
+                    [(and 
+                       (not (string? ta))
+                       (not (eq? ftype-w/-ta start)))
+
+                      ;; visable
+                      ;; add to preds unless src and dest are single value
+                      (set! preds (cons ftype-w/-ta preds))]
+
+                    [else
+                      ;; Invisable
+                      ;; Go back to parents
+                      (for-each traverse (get-edges ftype))]))))])
+
+        (for-each traverse (get-edges start))
+               
+        (pretty-debug `(traversed ,(map FlowType-name traversed)))
+        (pretty-debug 
+          `(preds ,(map
+                     (lambda (i) (and (FlowType? i) (FlowType-name i)))
+                     preds)))
+        
+        (remq start preds)))))
+
+(define (get-ftype-w/-ta ftype)
+  (if (FlowType-type-annotation ftype)
+      ftype
+      (and (FlowType-values-ftype ftype)
+           (get-ftype-w/-ta (FlowType-values-ftype ftype)))))
+
+(define (single-value-ftype ftype)
+  (let ([r
+          (match (FlowType->Atype ftype)
+            [(? Tvar? tvar)
+                (ormap
+                  (lambda (AV) (not (eq? (AV-template AV) template-mvalues)))
+                  (get-Tvar-objs tvar))]
+            [($ atvalues) #f]
+            [_ #t])])
+    (pretty-debug `(single-value-ftype ,(FlowType-name ftype) ,r))
+    r))
+
+;;----------------------------------------------------------------------
+;; Returns the preds in the Tvar graph of a given ftype
+;; format is a list of Tvars of predecessors that are visable
+
+(define analysis-parents
+  (lambda (ftype file-visable?)
+    (pretty-debug `(analysis-parents ,(FlowType-name ftype) ,(print-struct)))
+    (let ([r (analysis-walk1 ftype get-arrowfrom file-visable?)])
+    (pretty-debug `(analysis-parents-returns ,(map FlowType-name r)))
+      r)))
+
+(define (get-arrowfrom to)
+  (append
+    (if (Tvar? to)
+      (append
+        (get-mvalue-components to)
+        (Tvar-edgefrom to))
+      '())
+    (match (FlowType->Atype to)
+      [($ atvalues ftypes)
+        ftypes]
+      [_ '()])
+    (FlowType-arrowfrom to)))
+
+(define (get-mvalue-components tvar)
+  '(pretty-debug `(get-mvalue-components ,(Tvar-name tvar)))
+  (filter-map
+    (lambda (AV)
+      (if (eq? (AV-template AV) template-mvalues)
+        ;; get-nth
+        (let ( [p (mk-Tvar 'p)]
+               [l (mk-Tvar 'l)])
+          (new-edge! (vector-ref (AV-fields+ AV) 0) p)
+          (new-con! p (make-con-cdr p))
+          (new-con! p (make-con-car l))
+          '(pretty-debug
+             `(get-mvalue-components
+                ,(Tvar-name tvar) ,(Tvar-name p) ,(Tvar-name l)))
+          l)
+        #f))
+    (get-Tvar-objs tvar))) 
+
+;; ----------------------------------------------------------------------
+
+(define analysis-children
+  (lambda (ftype file-visable?)
+    (analysis-walk1
+      ftype
+      FlowType-alledgeto
+      file-visable?)))
+
+(define FlowType-alledgeto
+  (lambda (ftype)
+    (append
+      ;; Direct successors
+      (FlowType-arrowto ftype)
+      (if (FlowType-values-ftype ftype)
+        (list (FlowType-values-ftype ftype))
+        '())
+      ;; For filter successors, make sure some same values
+      (if (Tvar? ftype)
+        (append
+          (Tvar-edgeto ftype)
+          (filter-map
+            (match-lambda
+              [($ con-filter _ _ tvar) tvar]
+              [_ #f])
+            (Tvar-constraints ftype)))
+        '()))))
+
+;;----------------------------------------------------------------------
+;; Returns all ancestor/descendant arrows of a given ftype
+;; as (listof (list from to))
+
+(define analysis-walkn
+  (lambda (ftype get-edges file-visable?)
+    (assert (FlowType? ftype))
+    (pretty-debug `(analysis-walkn ,(FlowType-name ftype)))
+    ;;(error)
+    (let ( [done '()]                   ; list of FlowType's
+           [arrows '()])                ; visable arrows
+      (recur traverse ([ftype ftype])
+        (unless (memq ftype done)
+          (set! done (cons ftype done))
+          (let ([parents (analysis-walk1 ftype get-edges  file-visable?)])
+            (for-each 
+              (lambda (p)
+                (set! arrows (cons (list p ftype) arrows))
+                (traverse p))
+              parents))))
+
+      arrows)))
+
+;;----------------------------------------------------------------------
+;; Returns all ancestor arrows of a given ftype
+;; as (listof (list from to))
+
+(define analysis-ancestors
+  (lambda (ftype file-visable?)
+    (analysis-walkn ftype get-arrowfrom file-visable?)))
+
+(define analysis-descendants
+  (lambda (ftype file-visable?)
+    (map reverse
+      (analysis-walkn ftype FlowType-alledgeto file-visable?))))
+
+;;----------------------------------------------------------------------
+;; Calcs the shortest path to a source FlowType with
+;; orig-objs matching filter via breadth-first search
+;; Returns a list of FlowTypes
+;; or nil if no path to visable source
+;; or #f if ftype does not contain filter
+
+(define analysis-shortest-path
+  (lambda (ftype file-visable?)
+    (assert (FlowType? ftype))
+    (if (FlowType-contains-filter? ftype)
+      (let ([visited (list ftype)])
+        (letrec 
+          ([traverse
+             (lambda (list-paths)
+               (pretty-debug 
+                 `(list-paths
+                    ,(map (lambda (p) (map FlowType-name p)) list-paths)
+                    ,(map FlowType-name visited)))
+               (match list-paths
+                 [() 
+                   ;; No paths -> return the empty path
+                   '()]
+                 [((and path (ftype . rest-path)) . rest-paths)
+                   (pretty-debug 
+                     `(path ,(map FlowType-name path)
+                        rest-paths 
+                        ,(map (lambda (p) (map FlowType-name p)) rest-paths)))
+                   (let* ( [parents1 (analysis-parents ftype file-visable?)]
+                           [parents2
+                             (filter
+                               (lambda (p)
+                                 (if (memq p visited) 
+                                   #f
+                                   (begin
+                                     (set! visited (cons p visited))
+                                     #t)))
+                               parents1)])
+                     (set! visited (cons ftype visited))
+                     (if (and (null? parents2)
+                           (or (null? parents1)
+                             (null? rest-paths)))
+                       ;; either this path has terminated,
+                       ;; or went to cycle and is only one left.
+                       ;; either way, return it
+                       (reverse path)
+                       (traverse
+                         (append rest-paths
+                           (filter-map
+                             (lambda (parent) (cons parent path))
+                             parents2)))))]))])
+
+          (let ([path (traverse
+                        (map list (analysis-parents ftype file-visable?)))])
+
+            (pretty-debug `(traverse-path ,(map FlowType-name path)))
+
+            path)))
+      #f)))
+
+'(define analysis-shortest-path
+  (lambda (ftype file-visable?)
+    (assert (FlowType? ftype))
+    (if (FlowType-contains-filter? ftype)
+      (let ([visited '()])
+        (letrec 
+          ([traverse
+             (lambda (list-paths)
+               (pretty-debug 
+                 `(list-paths
+                    ,(map (lambda (p) (map FlowType-name p)) list-paths)
+                    ,(map FlowType-name visited)))
+               (match list-paths
+                 [() 
+                   ;; No paths -> return the empty path
+                   '()]
+                 [((and path (ftype . rest-path)) . rest-paths)
+                   (pretty-debug 
+                     `(path ,(map FlowType-name path)
+                        rest-paths 
+                        ,(map (lambda (p) (map FlowType-name p)) rest-paths)))
+                   (if (memq ftype visited)
+                     ;; going around a loop
+                     (traverse rest-paths)
+                     (let* ( [parents (analysis-parents ftype file-visable?)])
+                       (set! visited (cons ftype visited))
+                       (if (and (null? parents) (null? rest-paths))
+                         ;; this path has terminated, and is the only one left, 
+                         ;; and hence the longest, so return it
+                         (reverse path)
+                         (traverse
+                           (append rest-paths
+                             (filter-map
+                               (lambda (parent) (cons parent path))
+                               parents))))))]))])
+
+          (let ([path (traverse
+                        (map list (analysis-parents ftype file-visable?)))])
+
+            (pretty-debug `(traverse-path ,(map FlowType-name path)))
+
+            path)))
+      #f)))
+
+
+
+'(define analysis-shortest-path
+  (lambda (ftype file-visable?)
+    (assert (FlowType? ftype))
+    (let ([visited '()])
+      (letrec 
+        ([traverse
+           (lambda (list-paths)
+             (pretty-debug 
+               `(list-paths
+                  ,(map (lambda (p) (map FlowType-name p)) list-paths)
+                  ,(map FlowType-name visited)))
+             (match list-paths
+               [() 
+                 ;; No paths -> return the empty path
+                 '()]
+               [((and path (ftype . rest-path)) . rest-paths)
+                 (if (memq ftype visited)
+
+                   ;; Visited on a shorter path
+                   (traverse rest-paths)
+
+                   (begin
+                     (pretty-print 
+                       `(path ,(map FlowType-name path)
+                          rest-paths 
+                          ,(map (lambda (p) (map FlowType-name p)) rest-paths)))
+                     (set! visited (cons ftype visited))
+                     (cond
+                       [(FlowType-orig-objs-contains-filter? ftype)
+                         ;; Has orig-objs that match the filter 
+                         ;; => return this path
+                         (reverse path)]
+                       [(FlowType-contains-filter? ftype)
+                         ;; Has propogated objs that match the filter
+                         ;; => go back to parent
+                         (let* ([new-paths
+                                  (map 
+                                    (lambda (parent) (cons parent path))
+                                    (get-arrowfrom ftype))])
+                           (pretty-print 
+                             `(rest-paths ,(map (lambda (p) (map FlowType-name p)) rest-paths)
+                                new-paths
+                                ,(map (lambda (p) (map FlowType-name p)) new-paths)))
+                           (traverse (append rest-paths new-paths)))]
+                       [else
+                         ;; This FlowType no good
+                         (traverse rest-paths)])))]))])
+        (let ([path (traverse (list (list ftype)))])
+
+          (pretty-print `(traverse-path ,(map FlowType-name path)))
+          ;; Drop first FlowType - it is us
+          ;; Remove invisable FlowType's
+          ;; NO LONGER Add '() as last tag if last FlowType invisable
+          (assert (or (null? path) (eq? (car path) ftype)))
+          (if (null? path)
+            '()
+            (recur loop ([path (cdr path)])
+              (match path
+                [(ftype . rest)
+                  (cond
+                    [(FlowType-type-annotation ftype) (cons ftype (loop rest))]
+                    [(null? rest) '()]
+                    [else (loop rest)])]
+                [()
+                  ;; No path
+                  '()]))))))))
+
+;; ======================================================================
+;; Returns a string representation of the the type
+      
+(define (FlowType->SDL-text ftype)
+  (let ([type-port (open-output-string)])
+    (dynamic-let
+     ([pretty-print-columns (st:pretty-type-width)])
+     (pretty-print (FlowType->SDL ftype) type-port))
+    (begin0
+     (get-output-string type-port)
+     (close-output-port type-port))))
+      
+(define analysis-callback
+  (lambda (ftype)
+    (assert (FlowType? ftype) 'analysis-callback ftype)
+    (pretty-debug `(analysis-callback ,(FlowType->pretty ftype)))
+    (FlowType->SDL-text ftype)))
+      
+;;----------------------------------------------------------------------
+
+'(define test-hyper
+   (lambda (files)
+     (initialize-analysis!)
+     (match-let* 
+       ([(defs in out) 
+          (sba-analyze-file (files->file-thunk* files))])
+       (set! global-in-env in-env)
+       (set! global-out-env out-env)
+       (report-unbound-vars)
+       (hyper defs)
+       (printf "Testing parents~n")
+       (pretty-print (mapLR analysis-parents list-ftype))
+       (printf "Testing analysis-shortest-path~n")
+       (pretty-print (mapLR analysis-shortest-path list-ftype))
+       (printf "Testing children~n")
+       (pretty-print (mapLR analysis-children list-ftype list-ftype))
+       (void))))
+
+;; (trace analysis-parents analysis-shortest-path analysis-children)
+
+;;----------------------------------------------------------------------
+;; zodiac-based source-correlating pretty-printer
+
+'(define (correlate-pretty-print sexp)
+   (let* ([p (open-output-string)]
+           [_ (pretty-print sexp p)]
+           [s (get-output-string p)]
+           [_ (close-output-port p)]
+           [p (open-input-string p)]
+           [r (zodiac:read p)]
+           [zexp (r)])
+     (values s
+       (recur loop ([sexp sexp][zexp zexp])
+         (match (list sexp zexp)
+           [((? list? sl) ($ zodiac:list _ s f (? list? zl)))
+             (list
+               (zodiac:location-offset s)
+               (zodiac:location-offset f)
+               (map loop sl zl))]
+           [(sexp ($ zodiac:zodiac _ s f))
+             (list
+               (zodiac:location-offset s)
+               (zodiac:location-offset f)
+               sexp)])))))
+
+;; ----------------------------------------------------------------------
+
+'(define analysis-get-pred-filter-list
+   (lambda ()
+     (cons (cons "All sources" #f)
+       (reverse 
+         (map
+           (match-lambda
+             [(con . constructor) (cons (symbol->string con) (list con))])
+           (append constructor-env default-constructor-env))))))
+
+(define analysis-get-param
+  (lambda (param)
+    ((eval param))))
+
+(define analysis-set-param!
+  (lambda (param val)
+    ((eval param) val)))
+
+;; ----------------------------------------------------------------------
+
+;; ----------
+
+'(define (contains-some-same-vals? ftype value-from-ftypes)
+   ;; Returns #t if ftype contains at least some values from
+   ;; each of value-from-ftypes
+   (andmap
+     (lambda (value-from-ftype)
+       (match (list
+                (FlowType->Atype ftype)
+                (FlowType->Atype value-from-ftype))
+         [((? fo-Atype? x) (? fo-Atype? y)) (eq? x y)]
+         [((? Tvar? x) (? Tvar? y))
+           (ormap 
+             (lambda (AV) (memq AV (get-Tvar-objs y)))
+             (get-Tvar-objs x))]
+         [_ #t]))
+     value-from-ftypes))
diff --git a/collects/mrspidey/Sba/kern-aux.ss b/collects/mrspidey/Sba/kern-aux.ss
new file mode 100644
index 0000000..e4747f9
--- /dev/null
+++ b/collects/mrspidey/Sba/kern-aux.ss
@@ -0,0 +1,378 @@
+;; kernel-aux.ss
+;; Helper functions for building constraints
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+;;
+(define (make-constructed-AV-template template . args)
+  (match-let* ( [($ template type num+ num- ref assign) template]
+                [fields+ (make-vector num+)]
+                [fields- (make-vector num-)])
+    (for-each-with-n
+      (lambda (arg n)
+        (if (vector-ref assign n)
+          ;; Mutable - fill next two fields
+          (let ([tvar (mk-Tvar 'mut-field)])
+            (new-edge! arg tvar)
+            (vector-set! fields- (vector-ref assign n) tvar)
+            (when (vector-ref ref n)
+              (vector-set! fields+ (vector-ref ref n) tvar)))
+          ;; Immutable - fill one field
+          (when (vector-ref ref n)
+              (vector-set! fields+ (vector-ref ref n) arg))))
+      args)
+    (create-AV template '() fields+ fields-)))
+
+(define (make-constructed-AV C . args)
+  (apply make-constructed-AV-template (lookup-template C) args))
+
+(define (make-constructed-Tvar C . args)
+  (let ([tvar (mk-Tvar 'constructed-Tvar)]
+        [AV (apply make-constructed-AV C args)])
+    (new-AV! tvar AV)
+    tvar))
+
+;; ----------------------------------------------------------------------
+
+(define (make-AV-cons a d)
+  (if (st:cons-mutable)
+    (let* ( [fields+ (make-vector 2)]
+            [fields- (make-vector 2)])
+      (let ([tvar (mk-Tvar 'mut-field)])
+        (new-edge! a tvar)
+        (vector-set! fields+ 0 tvar)
+        (vector-set! fields- 0 tvar))
+      (let ([tvar (mk-Tvar 'mut-field)])
+        (new-edge! d tvar)
+        (vector-set! fields+ 1 tvar)
+        (vector-set! fields- 1 tvar))
+      (create-AV template-cons '() fields+ fields-))
+    (create-AV template-cons '() (vector a d) (vector))))
+
+
+(define (make-con-car tvar) (create-con template-cons 0 tvar #t))
+(define (make-con-cdr tvar) (create-con template-cons 1 tvar #t))
+(define (make-con-dom tvar) (create-con template-lam 0 tvar #f))
+(define (make-con-rng tvar) (create-con template-lam 0 tvar #t))
+
+(define (make-AV-vec a) 
+  (cond
+    [(lookup-template 'vect)
+      =>
+      (lambda (template-vect)
+        (make-constructed-AV-template template-vect a AV-numb))]
+    [(lookup-template 'vec)
+      =>
+      (lambda (template-vec)
+        (make-constructed-AV-template template-vec a))]))
+
+(define (make-AV-lam dom rng nargs restarg)
+  (create-AV 
+    template-lam 
+    (list 'lam-info nargs restarg)
+    (vector rng) 
+    (vector dom)))
+
+(define AV-nil   (void))
+(define AV-numb  (void))
+(define AV-sym   (void))
+(define AV-str   (void))
+(define AV-char  (void))
+(define AV-true  (void))
+(define AV-false (void))
+(define AV-void  (void))
+(define AV-undefined (void))
+(define AV-top-s (void))
+
+(define (mk-tvar-nil)   (mk-Tvar-init-AV 'nil   AV-nil))
+(define (mk-tvar-numb)  (mk-Tvar-init-AV 'num   AV-numb))
+(define (mk-tvar-sym)   (mk-Tvar-init-AV 'sym   AV-sym))
+(define (mk-tvar-str)   (mk-Tvar-init-AV 'str   AV-str))
+(define (mk-tvar-char)  (mk-Tvar-init-AV 'char  AV-char))
+(define (mk-tvar-true)  (mk-Tvar-init-AV 'true  AV-true))
+(define (mk-tvar-false) (mk-Tvar-init-AV 'false AV-false))
+(define (mk-tvar-empty) (mk-Tvar 'empty))
+(define (mk-tvar-void)
+  (if (st:see-void) 
+    (mk-Tvar-init-AV 'void  AV-void)
+    (mk-Tvar 'void)))
+(define (mk-tvar-undefined) (mk-Tvar-init-AV 'undefined AV-undefined))
+
+(define (init-common-AV!)
+  (unless (template? template-nil)
+    (mrspidey:internal-error
+      "template-nil not a template, language probably not specified"))
+  (set! AV-nil    (make-constructed-AV-template template-nil))
+  (set! AV-numb   (make-constructed-AV-template template-num))
+  (set! AV-sym    (make-constructed-AV-template template-sym))
+  (set! AV-str    (make-constructed-AV-template template-str))
+  (set! AV-char   (make-constructed-AV-template template-char))
+  (set! AV-true   (make-constructed-AV-template template-true))
+  (set! AV-false  (make-constructed-AV-template template-false))
+  (set! AV-void   (make-constructed-AV-template template-void))
+  (set! AV-undefined (make-constructed-AV-template template-undefined))
+  (set! AV-top-s  (make-constructed-AV-template template-top-s))
+  )
+
+;; ======================================================================
+
+(define traverse-simple-const
+  ;; Returns an AV, or #f
+  (match-lambda
+   [(or ($ zodiac:char _ _ _ c) (? char? c))
+    (if (st:constants)
+        (create-AV template-char c (vector) (vector))
+        AV-char)]
+   [(or ($ zodiac:symbol _ _ _ sym) (? symbol? sym))
+    (if (st:constants)
+        (create-AV template-sym sym (vector) (vector))
+        AV-sym)]
+   [(or ($ zodiac:number _ _ _ num) (? number? num))
+    (if (st:constants)
+        (create-AV template-num num (vector) (vector))
+        AV-numb)]
+   [(or ($ zodiac:string _ _ _ str) (? string? str)) AV-str]
+   [(or ($ zodiac:boolean _ _ _ #t) #t) AV-true]
+   [(or ($ zodiac:boolean _ _ _ #f) #f) AV-false]
+   [(or ($ zodiac:list _ _ _ ()) ()) AV-nil]
+   [_ #f]))
+
+(define traverse-const-exact
+  ;; Returns an AV
+  (lambda (V)
+    (or (traverse-simple-const V)
+        (match V
+          [(or ($ zodiac:list _ _ _ l)
+               (? pair? l)
+               (? null? l))
+           (recur loop ([l l])
+             (match l
+               [(a . d)
+                (let ([tvar-a (mk-Tvar 'car)]
+                      [tvar-d (mk-Tvar 'cdr)])
+                  (new-AV! tvar-a (traverse-const-exact a))
+                  (new-AV! tvar-d (loop d))
+                  (make-AV-cons tvar-a tvar-d))]
+               [() AV-nil]
+               [x (traverse-const-exact x)]))]
+          [($ zodiac:improper-list _ _ _ l)
+           (recur loop ([l l])
+             (match l
+               [(x) (traverse-const-exact x)]
+               [(a . d)
+                (let ([tvar-a (mk-Tvar 'car)]
+                      [tvar-d (mk-Tvar 'cdr)])
+                  (new-AV! tvar-a (traverse-const-exact a))
+                  (new-AV! tvar-d (loop d))
+                  (make-AV-cons tvar-a tvar-d))]))]
+          [($ zodiac:vector _ _ _ v)
+           (let ([tvar-e (mk-Tvar 'vec-field)])
+             (for-each
+              (lambda (e) (new-AV! tvar-e (traverse-const-exact e)))
+              v)
+             (make-AV-vec tvar-e))]
+          [(? vector? v)
+           (let ([tvar-e (mk-Tvar 'vec-field)])
+             (for-each
+              (lambda (e) (new-AV! tvar-e (traverse-const-exact e)))
+              (vector->list v))
+             (make-AV-vec tvar-e))]
+          [($ zodiac:box _ _ _ b)
+           (let ([tvar-e (mk-Tvar 'box-field)])
+             (new-AV! tvar-e (traverse-const-exact b))
+             (make-constructed-AV 'box tvar-e))]
+          [(? box? b)
+           (let ([tvar-e (mk-Tvar 'box-field)])
+             (new-AV! tvar-e (traverse-const-exact (unbox b)))
+             (make-constructed-AV 'box tvar-e)) ]
+          [(? void?) 
+            (make-constructed-AV 'void)]
+          [obj (error 'traverse-const-exact "Bad const ~s" obj)]))))
+
+;; ======================================================================
+;; Transitive closure of edgeto
+;; Could use faster algorithm here
+
+(define (Tvar-transitive-edgeto Tvar)
+  (let*-vals ( [(reached? set-reached!) (alloc-Tvar-field)]
+               [edgeto '()])
+    (recur loop ([Tvar Tvar])
+      (unless (reached? Tvar)
+        (set-reached! Tvar #t)
+        (set! edgeto (cons Tvar edgeto))
+        (for-each loop (Tvar-edgeto Tvar))
+        (for-each
+          (match-lambda
+            [($ con-filter _ _ to) (loop to)]
+            [_ (void)])
+          (Tvar-constraints Tvar))))
+    (pretty-debug 
+      `(Tvar-trans-edgeto ,(Tvar-name Tvar) ,(map Tvar-name edgeto)))
+    edgeto))
+
+(define (Tvar-transitive-edgefrom Tvar)
+  (let*-vals ( [(reached? set-reached!) (alloc-Tvar-field)]
+               [edgefrom '()])
+    (recur loop ([Tvar Tvar])
+      (unless (reached? Tvar)
+        (set-reached! Tvar #t)
+        (set! edgefrom (cons Tvar edgefrom))
+        (for-each loop (Tvar-edgefrom Tvar))))
+    (pretty-debug 
+      `(Tvar-trans-edgefrom ,(Tvar-name Tvar) ,(map Tvar-name edgefrom)))
+    edgefrom))
+
+;; ======================================================================
+
+(define (copy-constraint-set tvar tvar* edges)
+  ;; copies all Tvars in list tvar*
+  ;; edges: (listof (cons Tvar Tvar))
+
+  (pretty-debug
+    `(copy-constraint-set ,(Tvar-name (car tvar*)) ,(Tvar-name (rac tvar*))))
+
+  (let*-vals
+    ( [(tvar-nutvar set-tvar-nutvar!) (alloc-Tvar-field)]
+      [(AV-nuAV set-AV-nuAV!) (alloc-AV-field)]
+      [Tvar->nuTvar (lambda (tvar) (or (tvar-nutvar tvar) tvar))]
+      [copy-AV 
+        (lambda (AV)
+          (or 
+            (AV-nuAV AV)
+            (match AV
+              [(and AV ($ AV _ template misc fields+ fields-))
+                (if (or 
+                      (vector-ormap tvar-nutvar fields+)
+                      (vector-ormap tvar-nutvar fields-))
+                  (let* ( [nu-AV (create-AV 
+                                   template misc 
+                                   (vector-map Tvar->nuTvar fields+)
+                                   (vector-map Tvar->nuTvar fields-))])
+                    (set-AV-nuAV! AV nu-AV)
+                    nu-AV)
+                  (begin
+                    (set-AV-nuAV! AV AV)
+                    AV))])))])
+
+    (for-each 
+      (lambda (Tvar) (set-tvar-nutvar! Tvar (mk-Tvar 'copy-constraint-set)))
+      tvar*)
+
+    (for-each 
+      (lambda (source)
+        (let ([dest (Tvar->nuTvar source)])
+          ;; --- AV
+          (for-each
+            (lambda (AV) (new-AV! dest (copy-AV AV)))
+            (Tvar-objs source))
+          ;; --- Constraints
+          (for-each
+            (match-lambda
+              [($ con _ template field-no Tvar sign)
+                (new-con! dest 
+                  (create-con template field-no (Tvar->nuTvar Tvar) sign))]
+              [($ con-filter _ filter Tvar)
+                (new-con! dest
+                  (create-con-filter filter (Tvar->nuTvar Tvar)))])
+            (Tvar-constraints source))
+          ;; --- Edges
+          (for-each
+            (lambda (Tvar2) (new-edge! dest (Tvar->nuTvar Tvar2)))
+            (Tvar-edgeto source))))
+      tvar*)
+
+    (for-each
+      (match-lambda
+        [(from . to)
+          (new-edge! (Tvar->nuTvar from) (Tvar->nuTvar to))])
+      edges)
+
+    (Tvar->nuTvar tvar)))
+
+; ======================================================================
+; Non-Terminals
+
+(define-typed-structure NT (tvar type rhs*))
+
+(define mk-Tvar-NTs!
+  (lambda (Tvar)
+    (set-Tvar-L!  Tvar (make-NT Tvar 'L '()))
+    (set-Tvar-U!  Tvar (make-NT Tvar 'U '()))
+    ))
+
+(define mk-AV-NTs!
+  (lambda (AV)
+    (set-AV-U!  AV (make-NT AV 'U '()))
+    ))
+
+(define (chk-Tvar-L tvar)
+  (or (Tvar-L tvar)
+    (begin
+      (mk-Tvar-NTs! tvar)
+      (Tvar-L tvar))))
+
+(define (chk-Tvar-U tvar)
+  (or (Tvar-U tvar)
+    (begin
+      (mk-Tvar-NTs! tvar)
+      (Tvar-U tvar))))
+
+(define (chk-AV-U AV)
+  (or (AV-U AV)
+    (begin
+      (mk-AV-NTs! AV)
+      (AV-U AV))))
+
+(define (alloc-NT-field)
+  (let* ( [table (make-hash-table)]
+          [get-info
+            (lambda (nt)
+              (hash-table-get table nt (lambda () #f)))]
+          [set-info!
+            (lambda (nt v)
+              (hash-table-put! table nt v))])
+    (values get-info set-info!)))
+
+(define nt->sym
+  (match-lambda
+    [($ NT x type) 
+      (symbol-append type ': 
+        (if (Tvar? x) (Tvar-name x)
+          (symbol-append 'AV ': (AV-num x))))]
+    [x `(BAD-NT!!!! ,x)]))
+
+(define (AV->rep AV) (symbol-append 'AV ': (AV-num AV)))
+
+; ======================================================================
+
+(define select-L
+  (lambda (nt*)
+    (filter-map (match-lambda [($ NT x 'L) x][_ #f]) nt*)))
+
+'(define select-LI
+  (lambda (nt*)
+    (filter-map (match-lambda [($ NT x 'LI) x][_ #f]) nt*)))
+
+(define select-U
+  (lambda (nt*)
+    (filter-map (match-lambda [($ NT x 'U) x][_ #f]) nt*)))
+
+'(define select-UI
+  (lambda (nt*)
+    (filter-map (match-lambda [($ NT x 'UI) x][_ #f]) nt*)))
+
+;; ======================================================================
diff --git a/collects/mrspidey/Sba/kernel.ss b/collects/mrspidey/Sba/kernel.ss
new file mode 100644
index 0000000..62076aa
--- /dev/null
+++ b/collects/mrspidey/Sba/kernel.ss
@@ -0,0 +1,785 @@
+;; kernel.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------=
+;; FlowType == value flow graph node
+
+(define-const-typed-structure
+  FlowType
+  ( (: num num)
+    (! expr (union zodiac:parsed string false symbol))
+    (! arrowto (listof FlowType))
+    (! arrowfrom (listof FlowType))
+    (! type-annotation any) ;; type-annotation% or file.ss (if from .za file)
+    (! proplist (listof (cons sym any)))
+    (! values-ftype (union false FlowType))
+    ))
+
+ (define num-ftype  0)
+ (define list-ftype '())
+ (define num-edge 0)
+
+ (define (init-FlowType!)
+   (set! num-ftype  0)
+   (set! list-ftype '())
+   (set! num-edge 0))
+
+ ;;------------------------------------------------------------
+;; Extension functions
+
+(define (add-FlowType-arrow! from to)
+  (set-FlowType-arrowto! from (cons to (FlowType-arrowto from)))
+  (set-FlowType-arrowfrom! to (cons from (FlowType-arrowfrom to))))
+
+(define (add-FlowType! ftype)
+  (set! num-ftype (add1 num-ftype))
+  (set! list-ftype (cons ftype list-ftype))
+  ftype)
+
+;;------------------------------------------------------------
+;; Property list stuff
+      
+(define (add-FlowType-prop! ftype prop val)
+  (set-FlowType-proplist! ftype 
+                          (cons (cons prop val) (FlowType-proplist ftype))))
+
+(define (get-FlowType-prop ftype prop default)
+  (recur loop ([l (FlowType-proplist ftype)])
+    (match l
+      [() default]
+      [((a . d) . rest)
+       (if (eq? a prop)
+           d
+           (loop rest))]
+      [_ default])))
+
+(define (FlowType-name ftype)
+  (symbol-append (get-FlowType-prop ftype 'symbol 'anon)
+    ':
+    (FlowType-num ftype)))
+
+;; ======================================================================
+;; ======================================================================
+
+(define-typed-structure (Tvar struct:FlowType) 
+  ( (: objs (listof AV))
+    (: orig-objs (listof AV))
+    (: constraints (listof (union con con-filter)))
+    (: leq-top-s bool)
+    (: edgeto (listof Tvar))
+    (: edgefrom (listof Tvar))
+    (: L NT)
+    (: U NT)
+    (: PL NT)
+    (: PU NT)
+    ))
+
+(define-const-typed-structure AV 
+  ((: num num)
+   (: template template)
+   misc
+   (: fields+ (vec Tvar))
+   (: fields- (vec Tvar))
+   (! U NT)
+   (! PU any)
+    wb
+))
+
+(define-const-typed-structure template
+  ( (: type   sym)
+    (: num+ int)
+    (: num- int)
+    (: ref (vec num))
+    (: assign (vec num))
+    (! super-templates (listof template))
+    (: misc-eq? (any -> any))))
+
+ ;; ref and assign are for constructors
+ ;; ref maps a constructor-field to the AV-field+ to get value from
+ ;; assign maps a constructor-field to the AV-field- to add value to,
+ ;; or #f if immutable
+ ;; super-templates field records that eg num is a supertype of apply+
+ ;; misc-eq? is an equality function on the misc field of AVs
+ ;; sym-ndx maps symbols to the index for that symbol
+ ;;  eg. map ivar names
+
+
+ ;; Each elem of AV-fields is an Tvar
+
+(define-const-typed-structure con
+  ( (: num      num)
+    (: template template)
+    (: field-no num)
+    (: tvar     Tvar)
+    (: sign     bool)
+    misc))
+
+(define-const-typed-structure con-filter
+  ((: num    num)
+   (: filter filter)
+   (: tvar    Tvar)))
+
+(define-const-typed-structure filter
+  ((: sign      bool)
+   (: templates (listof template))))
+
+(define (create-filter sign templates)
+  (assert (and (boolean? sign)
+            (list? templates)
+            (andmap template? templates))
+    'create-filter sign templates)
+  (make-filter sign templates))
+
+;; Says whether to include or exclude certain templates
+
+(define-const-typed-structure con-top-s
+  ())
+
+(define con-top-s (make-con-top-s))
+
+(define mt-vector (vector))
+;----------------------------------------------------------------------
+
+ (define num-con  0)  
+ (define num-AV   0)
+ (define num-AV-in-Tvar 0)
+ (define max-constraint-system-size 0)
+ (define (constraint-system-size) (+ num-edge num-con num-AV-in-Tvar))
+
+ (define (SBA-entry->hash entry)
+   (hash-fn (FlowType-num (car entry))
+            (let ([d (cdr entry)])
+              (if (Tvar? d)
+                  (FlowType-num d)
+                  (AV-num d)))))
+
+ (define (init-kernel!)
+   (init-FlowType!)
+   (set! num-con  0)
+   (set! num-AV   0)
+   (set! num-AV-in-Tvar 0)
+   (set! max-constraint-system-size 0)
+   (init-hash-table SBA-entry->hash 0)
+   )
+
+ ;;------------------------------------------------------------
+ ;; Creation functions
+
+ (define (create-AV template misc fields+ fields-) 
+   (assert (and 
+             (template? template)
+             (vector? fields+)
+             (vector? fields-)
+             (vector-andmap Tvar? fields+)
+             (vector-andmap Tvar? fields-))
+           `(create-AV ,template ,misc ,fields+ ,fields-))
+   (let ([AV (make-AV num-AV template misc fields+ fields- #f #f (make-weak-box 1))])
+     (set! num-AV (add1 num-AV))
+     AV))
+
+ (define mk-Tvar-nolist
+   (lambda (sym)
+     (let ([tvar (make-Tvar
+                   ;; FlowType fields
+                   num-ftype #f '() '() #f `((symbol . ,sym)) #f 
+                   ;; Tvar fields
+                   '() '() '() #f '() '()
+                   #f #f #f #f
+                   )])
+       (set! num-ftype (add1 num-ftype))
+       tvar)))
+
+ (define mk-Tvar
+   (lambda (sym)
+     (let ([tvar (mk-Tvar-nolist sym)])
+       (set! list-ftype (cons tvar list-ftype))
+       tvar)))
+
+ (define (create-con template field-no tvar sign) 
+   (create-con-misc template field-no tvar sign '()))
+
+ (define (create-con-misc template field-no tvar sign misc) 
+   (make-con num-con template field-no tvar sign misc))
+
+ (define (create-con-filter filter tvar) 
+   (assert (filter? filter))
+   (make-con-filter num-con filter tvar))
+      
+;; ----------------------------------------------------------------------
+;; Functions for extending graph
+;; the add-* functions extend the data structures, but don't propogate
+;; the check-add-* only adds if item not in data structure, but don't propogate
+;; the extend-* functions also propogate values & constraints appropriately
+;; the new-* functions are normally bound to extend-*, but sometines add-*
+;; ----------------------------------------------------------------------
+
+(define add-edge!
+   (lambda (from to)
+     (assert (and (Tvar? from) (Tvar? to)) 'add-edge! from to)
+     (set-Tvar-edgeto! from (cons to (Tvar-edgeto from)))
+     (set-Tvar-edgefrom! to (cons from (Tvar-edgefrom to)))
+     (set! num-edge (add1 num-edge))
+     (add-entry (hash-fn (FlowType-num from) (FlowType-num to))
+                (cons from to))))
+      
+(define add-AV!
+  (lambda (tvar AV)
+    (set! num-AV-in-Tvar (add1 num-AV-in-Tvar))
+    (set-Tvar-objs! tvar (cons AV (Tvar-objs tvar)))
+    (add-entry (hash-fn (FlowType-num tvar) (AV-num AV))
+      (cons tvar AV))))
+
+(define add-con!
+  (lambda (tvar con)
+    (set! num-con (add1 num-con))
+    (set-Tvar-constraints! tvar (cons con (Tvar-constraints tvar)))))
+
+'(define add-nohash-con! add-con!)
+
+;; ----------------------------------------------------------------------
+;; the check-add-* functions check if a constraint is present,
+;; and if not, add it, but do not propogate
+ 
+(define check-add-edge!
+   (lambda (from to)
+     (assert (and (Tvar? from) (Tvar? to)) 'extend-edge! from to)
+     (unless
+       (or (Tvar-edge? from to) (eq? from to))
+       (add-edge! from to))))
+
+ (define check-add-AV!
+   (lambda (tvar AV)
+     (assert (AV? AV) `(extend-AV! ,tvar ,AV))
+     (set-Tvar-orig-objs! tvar (cons AV (Tvar-orig-objs tvar)))))
+
+ (define check-add-con!
+   (lambda (tvar con)
+     (set! num-con (add1 num-con))
+     (set-Tvar-constraints! tvar (cons con (Tvar-constraints tvar)))
+     (match con
+       [($ con-filter _ _ dest)
+         (set-Tvar-edgefrom! dest (cons tvar (Tvar-edgefrom dest)))]
+       [_ (void)])))
+
+;; ----------------------------------------------------------------------
+;; the extend-* functions also propogate values & constraints appropriately
+ 
+(define extend-edge!
+   (lambda (from to)
+     (assert (and (Tvar? from) (Tvar? to)) 'extend-edge! from to)
+     (unless
+       (or (Tvar-edge? from to) (eq? from to))
+       (add-edge! from to)
+       ;; Propogate all AV's
+       (for-each (lambda (AV) (prop-AV! to AV))
+                 (Tvar-objs from)))))
+
+(define extend-AV!
+  (lambda (tvar AV)
+    (assert (AV? AV) `(extend-AV! ,tvar ,AV))
+    (set-Tvar-orig-objs! tvar (cons AV (Tvar-orig-objs tvar)))
+    (prop-AV! tvar AV)))
+
+(define prop-AV!
+  (lambda (tvar AV)
+    (assert (and (Tvar? tvar) (AV? AV)) `(prop-AV! ,tvar ,AV))
+    (unless (Tvar-AV-mem? tvar AV)
+      (add-AV! tvar AV)
+      ;; Apply all constraints
+      (for-each 
+        (lambda (con) (SBA-constraint tvar con AV))
+        (Tvar-constraints tvar))
+      ;; Propogate
+      (for-each
+        (lambda (to) (prop-AV! to AV))
+        (Tvar-edgeto tvar)))))
+
+ (define extend-con!
+   (lambda (tvar con)
+     (set! num-con (add1 num-con))
+     (set-Tvar-constraints! tvar (cons con (Tvar-constraints tvar)))
+     (match con
+       [($ con-filter _ _ dest)
+         (set-Tvar-edgefrom! dest (cons tvar (Tvar-edgefrom dest)))]
+       [_ (void)])
+     ;; Apply to all AV's
+     (for-each (lambda (AV) (SBA-constraint tvar con AV))
+               (get-Tvar-objs tvar))))
+
+;; ----------------------------------------------------------------------
+;; the new-* functions are normally equiv to extend-*,
+;; but can be set to add-* via a parameter 
+
+(define new-edge! extend-edge!)
+(define new-AV!   extend-AV!)
+(define new-con!  extend-con!)
+
+(define (new-leq-top-s! tvar)
+  ;; tvar <= top-s, is constraint
+  (unless (Tvar-leq-top-s tvar)
+    (set-Tvar-leq-top-s! tvar #t)
+    (new-con! tvar con-top-s)))
+
+(define (new-geq-top-s! tvar)
+  ;; top-s <= tvar, is AV
+  (new-AV! tvar AV-top-s))
+
+;; ----------------------------------------------------------------------
+
+(define keep-S-closed
+  (let ([closed #t])
+    (case-lambda
+      [() closed]
+      [(x)
+        (set! closed x)
+        (if x
+          (begin
+            (set! new-edge! extend-edge!)
+            (set! new-AV! extend-AV!)
+            (set! new-con! extend-con!))
+          (begin
+            (set! new-edge! check-add-edge!)
+            (set! new-AV! check-add-AV!)
+            (set! new-con! check-add-con!)))])))
+    
+(define new-create-AV!
+  (lambda (tvar template misc fields)
+    (new-AV! tvar (create-AV template misc fields))))
+
+(define new-bidir-edge! 
+  (lambda (from to)
+    (new-edge! from to)
+    (new-edge! to from)))
+
+(define new-edge-para
+  (case-lambda
+    [() new-edge!]
+    [(x) (set! new-edge! x)]))
+
+(define (close-constraints tvars)
+  (pretty-debug `(close-constraints ,(map Tvar-name tvars)))
+  (for-each
+    (lambda (tvar)
+      (for-each
+        (lambda (AV)
+          (for-each
+            (lambda (to) (prop-AV! to AV))
+            (Tvar-edgeto tvar))
+          (for-each
+            (lambda (con) (SBA-constraint tvar con AV))
+            (Tvar-constraints tvar)))
+        (get-Tvar-objs tvar)))
+    tvars))
+
+ ;;------------------------------------------------------------
+ ;; Handling constraints
+
+(define gSBA-constraint (void))
+
+(define SBA-constraint
+  (lambda (tvar con AV)
+    (set! gSBA-constraint (list tvar con AV))
+    (match con
+      ;; Regular constraints
+      [($ con _ template field-no tvar-con sign)
+        (match AV
+          [($ AV _ template2 misc fields+ fields-)
+            (when (or 
+                    (eq? template template2)
+                    (memq template (template-super-templates template2)))
+              ;;(pretty-print `(,con ,AV))
+              (if sign
+                (when (< field-no (vector-length fields+))
+                  ;; Propogate field from AV into tvar-con
+                  (new-edge! (vector-ref fields+ field-no) tvar-con))
+                (when (< field-no (vector-length fields-))
+                  ;; Propogate field from tvar-con into AV
+                  (new-edge! tvar-con (vector-ref fields- field-no)))))
+            (when (eq? template2 template-top-s)
+              (if sign
+                (new-geq-top-s! tvar-con)
+                (new-leq-top-s! tvar-con)))])]
+
+      ;; Filter constraints
+      [($ con-filter _ ($ filter bool templates) tvar-con)
+        '(printf "template ~s templates ~s memq ~s bool ~s add ~s~n" 
+           (template-type (AV-template AV))
+           (map template-type templates)
+           (memq (AV-template AV) templates)
+           bool
+           (case (memq (AV-template AV) templates)
+             [#f (not bool)]
+             [else bool]))
+        (let* ( [AV-t (AV-template AV)]
+                [found (ormap
+                         (lambda (t2)
+                           (or 
+                             (eq? AV-t t2)
+                             (memq t2 (template-super-templates AV-t))))
+                         templates)])
+          '(pretty-print-debug
+             `(con-filter found ,found 
+                memq ,(memq AV-t templates)
+                AV-t ,(template-type AV-t)
+                ,(map template-type templates)))
+          (when (or (case found
+                      [(#f) (not bool)]
+                      [else bool])
+                  (eq? AV-t template-top-s))
+            ;; Add AV to tvar-con
+            (prop-AV! tvar-con AV)))]
+      [($ con-top-s)
+        (match AV
+          [($ AV _ template2 misc fields+ fields-)
+            (vector-for-each new-leq-top-s! fields+)
+            (vector-for-each new-geq-top-s! fields-)])])))
+      
+ ;;------------------------------------------------------------
+ ;; Functions/predicates for examining the graph
+
+ (define (Tvar-AV-mem? tvar AV)
+   (hash-find (hash-fn (FlowType-num tvar) (AV-num AV))
+              (lambda (entry) 
+                (and (eq? (car entry) tvar)
+                     (eq? (cdr entry) AV)))))
+
+ (define (Tvar-edge? from to)
+   (hash-find (hash-fn (FlowType-num from) (FlowType-num to))
+              (lambda (entry)
+                (and (eq? (car entry) from)
+                     (eq? (cdr entry) to)))))
+      
+ (define get-Tvar-objs Tvar-objs)
+      
+;; ------------------------------------------------------------
+
+(define (really-check-kernel-ok)
+  (dynamic-let 
+    ([st:check-kernel #t]) 
+    (check-kernel-ok)))
+
+(define check-kernel-ok:tvar #f)
+
+(define (check-kernel-ok)
+  ;; Sanity check
+  (when (st:check-kernel)
+    (assert (= num-ftype (length list-ftype)))
+    (let ([Tvar-edge?
+            (lambda (a b)
+              (or (eq? a b)
+                (Tvar-edge? a b)))])
+
+      (printf "check-kernel-ok: Consistency tests~n")
+      (for-each
+        (lambda (tvar)
+          (when (Tvar? tvar)
+            (assert (= (length (Tvar-objs tvar))
+                      (length (list->set (Tvar-objs tvar)))))
+            (assert (= (length (Tvar-edgeto tvar))
+                      (length (list->set (Tvar-edgeto tvar)))))
+            (assert (= (length (Tvar-constraints tvar))
+                      (length (list->set (Tvar-constraints tvar)))))
+            (for-each (lambda (AV) (assert (Tvar-AV-mem? tvar AV) (Tvar-name tvar)))
+              (Tvar-objs tvar))
+            (for-each (lambda (to) (assert (Tvar-edge? tvar to)))
+              (Tvar-edgeto tvar))))
+        list-ftype)
+   
+      ;; Now check kernel is closed under S
+      (printf "check-kernel-ok: Closure tests~n")
+      (for-each
+        (lambda (tvar)
+          (when (Tvar? tvar)
+            (for-each 
+              (lambda (AV)
+                ;; First check AV prop'd
+                (for-each 
+                  (lambda (to)
+                    (when (Tvar? to)
+                      (assert (Tvar-AV-mem? to AV)
+                        (Tvar-name tvar) (Tvar-name to)
+                        (template-type (AV-template AV)))))
+                  (Tvar-edgeto tvar))
+                ;; Check AV applied to all constraints
+                (for-each
+                  (match-lambda
+                    [($ con _  template field-no tvar-con sign)
+                      (match AV
+                        [($ AV _ template2 misc fields+ fields-)
+                          (when 
+                            (or 
+                              (eq? template template2)
+                              (memq template (template-super-templates template2)))
+                            (if sign
+                              (when (< field-no (vector-length fields+))
+                                ;; Propogate field from AV into tvar-con
+                                (assert
+                                  (Tvar-edge?
+                                    (vector-ref fields+ field-no) tvar-con)
+                                  `(Tvar-edge?
+                                     ,(Tvar-name (vector-ref fields+ field-no))
+                                     ,(Tvar-name tvar-con))
+                                  (Tvar-name tvar) field-no
+                                  (template-type template)))
+                              (when (< field-no (vector-length fields-))
+                                ;; Propogate field from tvar-con into AV
+                                (assert
+                                  (Tvar-edge?
+                                    tvar-con (vector-ref fields- field-no))
+                                  (Tvar-name tvar) 
+                                  field-no
+                                  (Tvar-name tvar-con)
+                                  sign
+                                  (template-type template)))))]
+
+                        [_ 
+                          ;; Constraint does not apply to this AV
+                          (void)])]
+                    [($ con-filter _ ($ filter bool templates) tvar-con)
+                      ;; ignore for now
+                      (void)])
+                  (Tvar-constraints tvar)))
+              (get-Tvar-objs tvar))))
+        (reverse list-ftype))
+
+      ;; Now check all reachable tvars are in list-ftype
+      (printf "check-kernel-ok: list-ftype tests~n")
+      (let*-vals 
+        ( [(get set) (alloc-Tvar-field (lambda () #f))]
+          [ok-tvar? (lambda (tvar)
+                      (unless (get tvar)
+                        (printf
+                          "Tvar ~s reachable from ~s but not in list-ftype ~s~n"
+                          (FlowType-num tvar)
+                          (FlowType-num check-kernel-ok:tvar)
+                          (memq tvar list-ftype))))]
+          [ok-AV? 
+            (match-lambda
+              [($ AV _ _ _ fields+ fields-)
+                (vector-for-each ok-tvar? fields+)
+                (vector-for-each ok-tvar? fields-)])])
+
+        (for-each
+          (lambda (ftype)
+            (when (Tvar? ftype) (set ftype #t)))
+          list-ftype)
+
+        (for-each
+          (lambda (ftype)
+            (when (Tvar? ftype)
+              (set! check-kernel-ok:tvar ftype)
+              (for-each ok-tvar? (Tvar-edgeto ftype))
+              (for-each ok-tvar? (Tvar-edgefrom ftype))
+              (for-each ok-AV?   (Tvar-objs ftype))
+              (for-each ok-AV?   (Tvar-orig-objs ftype))
+              (for-each
+                (match-lambda
+                  [($ con _ _ _ tvar) (ok-tvar? tvar)]
+                  [($ con-filter _ _ tvar) (ok-tvar? tvar)])
+                (Tvar-constraints ftype))))
+          list-ftype))
+
+      )))
+
+(define (check-unreachable ftypes unreachable)
+  (let* ( [check-ok
+            (lambda (ftype) 
+              (when (memq ftype unreachable)
+                (error 'check-unreachable "Ftype ~s in old ~s"
+                  (FlowType-name ftype)
+                  (map FlowType-name unreachable))))])
+    (for-each
+      (lambda (ftype)
+        (when (Tvar? ftype)
+          (for-each check-ok (Tvar-edgeto ftype))
+          (for-each check-ok (Tvar-edgefrom ftype))
+          (for-each
+            (match-lambda
+              [($ AV _ _ _ fields+ fields-)
+                (vector-for-each check-ok fields+)
+                (vector-for-each check-ok fields-)])
+            (Tvar-objs ftype))
+          (for-each
+            (match-lambda
+              [($ con _ _ _ tvar) (check-ok tvar)]
+              [($ con-filter _ _ tvar) (check-ok tvar)])
+            (Tvar-constraints ftype))))
+      ftypes)))
+
+ ;; ------------------------------------------------------------
+
+(define-structure (kernel-state
+                    num-ftype list-ftype num-edge 
+                    num-con num-AV num-AV-in-Tvar 
+                    closed? new-edge! hash-table-state))
+                    
+(define (save-kernel-state)
+  (make-kernel-state
+    num-ftype list-ftype num-edge 
+    num-con num-AV num-AV-in-Tvar 
+    (keep-S-closed) new-edge! 
+    (capture-hash-table-state)))
+
+(define restore-kernel-state!
+  (match-lambda
+    [($ kernel-state
+       saved-num-ftype saved-list-ftype saved-num-edge 
+       saved-num-con saved-num-AV saved-num-AV-in-Tvar 
+       closed? saved-new-edge! 
+       hash-table-state)
+      (let ([old-size (constraint-system-size)])
+        (set! num-ftype saved-num-ftype)
+        (set! list-ftype saved-list-ftype)
+        (set! num-edge saved-num-edge)
+        (set! num-con saved-num-con)
+        (set! num-AV saved-num-AV)
+        (set! num-AV-in-Tvar saved-num-AV-in-Tvar)
+        (keep-S-closed closed?)
+        (set! new-edge! saved-new-edge!)
+        (restore-hash-table-state! hash-table-state)
+
+        (set! max-constraint-system-size
+          (max max-constraint-system-size
+            (+ (constraint-system-size) old-size)))
+        )]))
+
+(define free-kernel-state!
+  (match-lambda
+    [($ kernel-state
+       saved-num-ftype saved-list-ftype saved-num-edge 
+       saved-num-con saved-num-AV saved-num-AV-in-Tvar 
+       closed? saved-new-edge! 
+       hash-table-state)
+
+      (free-hash-table-state! hash-table-state)
+      (for-each 
+        (lambda (ftype)
+          (set-FlowType-expr! ftype 'zerod1!)
+          (set-FlowType-arrowto! ftype 'zerod2!)
+          (set-FlowType-arrowfrom! ftype 'zerod3!)
+          (set-FlowType-type-annotation! ftype 'zerod4!)
+          (set-FlowType-proplist! ftype 'zerod5!)
+          (set-FlowType-values-ftype! ftype 'zerod6!)
+          (when (Tvar? ftype) 
+            (set-Tvar-objs! ftype 'zerod7!)
+            (set-Tvar-orig-objs! ftype 'zerod8!)
+            (set-Tvar-constraints! ftype 'zerod9!)
+            (set-Tvar-edgeto! ftype 'zeroda!)
+            (set-Tvar-edgefrom! ftype 'zerodb!)
+            (set-Tvar-L! ftype 'zerodc!)
+            (set-Tvar-U! ftype 'zerodd!)
+            (set-Tvar-PL! ftype 'zerode!)
+            (set-Tvar-PU! ftype 'zerodf!)))
+        saved-list-ftype)]))
+
+;; ----------------------------------------------------------------------
+
+(define-structure (prompt-kernel-state saved-state prompt-hash-state ftypes))
+
+(define (prompt-kernel-state)
+  (make-prompt-kernel-state
+    (save-kernel-state)
+    (prompt-hash-table-state)
+    (map
+      (lambda (ftype)
+        (list 
+          ftype
+          (match ftype
+            [($ FlowType _ _ arrowto arrowfrom _ _ values-ftype)
+              (list arrowto arrowfrom values-ftype)])
+          (match ftype
+            [($ Tvar _ _ _ _ _ _ _
+               objs orig-objs con edgeto edgefrom)
+              (list objs orig-objs con edgeto edgefrom)]
+            [_ #f])))
+      list-ftype)))
+
+(define unprompt-kernel-state!
+  (match-lambda
+    [($ prompt-kernel-state saved-state prompt-hash-state ftypes)
+      (restore-kernel-state! saved-state)
+      (unprompt-hash-table-state! prompt-hash-state)
+      (for-each
+        (match-lambda
+          [(ftype (arrowto arrowfrom values-ftype) tvar-info)
+            (set-FlowType-arrowto! ftype arrowto)
+            (set-FlowType-arrowfrom! ftype arrowfrom)
+            (set-FlowType-values-ftype! ftype values-ftype)
+            (match tvar-info
+              [#f (void)]
+              [(objs orig-objs con edgeto edgefrom)
+                (set-Tvar-objs! ftype objs)
+                (set-Tvar-orig-objs! ftype orig-objs)
+                (set-Tvar-constraints! ftype con)
+                (set-Tvar-edgeto! ftype edgeto)
+                (set-Tvar-edgefrom! ftype edgefrom)])])
+        ftypes)]))
+
+;; ------------------------------------------------------------
+;; Auxiliary info on Tvars
+
+(define alloc-Tvar-field
+  (case-lambda
+    [(default-fn)
+      (let* ( [table (make-hash-table)]
+              [get-info
+                (lambda (tvar) 
+                  (assert (FlowType? tvar) tvar 'get-info)
+                  (hash-table-get table tvar default-fn))]
+              [set-info!
+                (lambda (tvar v)
+                  (assert (FlowType? tvar) tvar 'set-info!)
+                  (hash-table-put! table tvar v))])
+        (values get-info set-info!))]
+    [() (alloc-Tvar-field (lambda () #f))]))
+
+(define alloc-AV-field
+  (case-lambda
+    [(default-fn)
+      (let* ( [table (make-hash-table)]
+              [get-info
+                (lambda (AV) 
+                  (hash-table-get table AV default-fn))]
+              [set-info!
+                (lambda (AV v)
+                  (hash-table-put! table AV v))])
+        (values get-info set-info!))]
+    [() (alloc-AV-field (lambda () #f))]))
+
+(define (field->set alloc-field)
+  (let*-vals ( [(get-info set-info!) (alloc-field)]
+               [list-obj '()]
+               [in? (lambda (obj) (get-info obj))]
+               [add! (lambda (obj) 
+                       (unless (in? obj)
+                         (set-info! obj #t)
+                         (set! list-obj (cons obj list-obj))))]
+               [get-list (lambda () list-obj)])
+    (values in? add! get-list)))
+
+;; ----------------------------------------------------------------------
+ 
+(define mk-Tvar-init-AV
+  (lambda (sym AV)
+    (let ([r (mk-Tvar sym)])
+      (new-AV! r AV)
+      r)))
+
+(define (Tvar-name tvar) (FlowType-name tvar))
+
+;; ======================================================================
+
diff --git a/collects/mrspidey/Sba/language.ss b/collects/mrspidey/Sba/language.ss
new file mode 100644
index 0000000..5764e87
--- /dev/null
+++ b/collects/mrspidey/Sba/language.ss
@@ -0,0 +1,1482 @@
+;; languages.ss - defines analyzed language
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define-struct language-spec
+  (kernel constructor-env initial-env tdef-env))
+(define language-spec (void))
+
+(define make-expander-namespace (void))
+
+;; ======================================================================
+
+(define
+  st:language
+  (make-parameter-list
+    'none
+    '( (DrScheme  "DrScheme")
+       (MzScheme  "MzScheme")
+       (MrEd      "MrEd")
+       (R4RS      "R4RS")
+       (Chez      "Chez Scheme")
+       (none      "None"))
+    (lambda (scheme)
+      (unless (eq? scheme 'none)
+        (init-default-constructor-env!)
+        (init-input-type-expander!)
+        (init-output-type-expander!)
+        (init-kernel!)
+        (init-common-AV!)
+        (set! make-expander-namespace (lambda () (make-namespace)))
+        (init-expand!)
+        (set! initial-env (make-hash-table))
+        ;; ---
+        (init-R4RS!)
+        (case scheme
+          [(MzScheme)
+            (init-MzScheme-on-R4RS!)]
+          [(MrEd)     (init-MzScheme-on-R4RS!)
+            (init-mzlib!)
+            (init-MrEd-on-MzScheme!)
+            (set! make-expander-namespace (lambda () (make-namespace 'wx)))]
+          [(DrScheme) 
+            (init-MzScheme-on-R4RS!) 
+            (init-mzlib!)
+            (init-DrScheme-on-MzScheme!)
+            (set! make-expander-namespace (lambda () (make-namespace 'wx)))
+            ]
+          [(R4RS)     (void)]
+          [(Chez)     (init-Chez-on-R4RS!)]
+          [(none)     (void)])
+        (when (st:numops) (init-smart-numops!) (init-vectors-w/-length))
+        
+        (when (file-exists? "~/.spideyrc") (language-add-boot-file "~/.spideyrc"))
+        (let ([systemrc (string-append "~/.spidey-" 
+                          (symbol->string scheme)
+                          "-rc")])
+          (when (file-exists? systemrc) (language-add-boot-file systemrc)))
+
+        ;; 
+        ;(printf "Saving language spec ... ")
+        (set! language-spec
+          (make-language-spec
+            (prompt-kernel-state)
+            constructor-env
+            initial-env
+            global-tdef-env))
+        ;(printf "done~n")
+        ))))
+
+;(trace st:language)
+
+;; ----------------------------------------------------------------------
+
+(define (initialize-language!)
+  (mrspidey:progress "Initializing language" '...)
+  (match language-spec
+    [($ language-spec k c i t)
+      (pretty-debug '(initialize-language!))
+      (unprompt-kernel-state! k)
+      (set-constructor-env! c)
+      (set! initial-env i)
+      (init-global-tenv! '() t '())
+      ])
+  (mrspidey:progress "Initializing language" 'done))
+
+;; ----------------------------------------------------------------------
+
+(define st:numops         ;; Default false
+  (let ([value #f])
+    (match-lambda*
+     [() value]
+     [('?) `( (#f "Inaccurate" "")
+              (#t "Accurate" ""))]
+     [(nu)
+       (unless (boolean? nu) (error 'st:numops "Bad parameter"))
+       (unless (eq? value nu)
+         (set! value nu)
+         (when value (st:constants #t))
+         ;; Reprocess the language
+         (st:language (st:language)))
+       value])))
+
+;; ======================================================================
+
+(define initial-env '())
+
+(define (extend-initial-env! sym ftype)
+  (assert (and (symbol? sym) (FlowType? ftype)) 'extend-initial-env)
+  (hash-table-put! initial-env sym ftype)
+  (hash-table-put! initial-env (symbol-append '#% sym) ftype))
+
+(define list-primitives '())
+
+(define (add-default-primitive! name type . attrs)
+  (set! list-primitives (cons (list name type) list-primitives))
+  ;; working w/ default primitive env => use default constructor env
+  (let* ([def (apply primitive->atprim name type attrs)]
+         [ftype (create-fo-FlowType def)])
+    (extend-initial-env! name ftype)))
+
+(define (show-primitives)
+  (let ([l (quicksort list-primitives
+             (lambda (a b)
+               (string<? (symbol->string (car a)) (symbol->string (car b)))))]
+         [file "~/Spidey/doc/prims.tex"])
+    (when (file-exists? file) (delete-file file))
+    (with-output-to-file file
+      (lambda ()
+        (for-each
+          (match-lambda
+            [(name type)
+              (printf "\\scheme|~s| \\> ~n" name)
+              (printf "\\begin{schemedisplay}~n")
+              (parameterize ([pretty-print-columns 60])
+                (pretty-print type))
+              (printf "\\end{schemedisplay}~n")
+              (printf "\\\\~n")])
+          l)))))
+
+(define (add-default-primitives! l)
+  (for-each 
+   (match-lambda
+    [(name 'GLOBAL-TYPE-VARIABLE)
+      '(add-default-tdef! name)]
+    [args (apply add-default-primitive! args)])
+   l))
+
+(define (add-default-tdef! name) (add-global-tdef! name))
+
+;  (let ([Tvar (mk-Tvar (symbol-append 'default-tdef: name))])
+;    (set! default-tdef-env
+;      (cons (cons name Tvar) default-tdef-env))))
+
+;; ======================================================================
+
+(define (get-default-bindings free-names)
+  (recur loop ([env atenv:empty][free-names free-names])
+    (match free-names
+      [() env]
+      [(name . rest)
+        (let ([sym (zodiac:binding-var name)])
+          (match (hash-table-get initial-env sym (lambda () #f))
+            [#f 
+              (mrspidey:warning (format "Free variable ~s" sym))
+              (loop env rest)]
+            [ftype (loop (atenv:extend env name ftype) rest)]))])))
+
+;; ======================================================================
+
+(define (language-add-boot-file filename)
+  (let*-vals
+    ( [filename (normalize-path filename)]
+      [boot-defs (zodiac:read* (open-code-file filename) filename)]
+      [(defs free-names) (my-scheme-expand-program boot-defs)]
+      [env (get-default-bindings free-names)]
+      [(env refs result) (top-level-traverse-defs defs env)])
+    (for-each
+      (match-lambda
+        [($ zodiac:define-values-form _ _ _ _ refs)
+          (for-each
+            (lambda (ref)
+              (let ([var (zodiac:varref-binding ref)])
+                (pretty-debug `(Defining ,(zodiac:binding-var var)))
+                (extend-initial-env!
+                  (zodiac:binding-var var)
+                  (atenv:lookup env var))))
+            refs)]
+        [_ (void)])
+      defs)))
+
+;; ======================================================================
+
+(define (init-R4RS!)
+  ;; Also extends it with void
+
+  (add-constructor! 'vec #t)
+  (add-constructor! 'iport)
+  (add-constructor! 'oport)
+  (add-constructor! 'eof  )
+  (add-constructor! 'box  #t)
+
+  ;; for demos
+  (add-constructor! 'pair #t #t)
+
+  (add-default-primitives!
+    `(
+       ;; for demos
+       (nil            nil)
+       (pair           (forall (a b) (a b -> (pair a b))))
+       (left            (forall (a) ((pair a _) -> a)))
+       (right            (forall (a) ((pair _ a) -> a)))
+
+       ;;(nil            nil)
+
+       ;; booleans
+       (not            (_ -> bool) (predicate* (#t false) (#f false)))
+
+       ;; equivalence predicates
+       (eqv?           (_ _ -> bool))
+       (eq?            (_ _ -> bool))
+       (equal?         (_ _ -> bool))
+
+       ;; pairs and lists
+       (cons           (forall (a b) (a b -> (cons a b))))
+       (car            (forall (a) ((cons a _) -> a)))
+       (cdr            (forall (a) ((cons _ a) -> a)))
+       (caar           (forall (a) ((cons (cons a _) _) -> a)))
+       (cadr           (forall (a) ((cons _ (cons a _)) -> a)))
+       (cdar           (forall (a) ((cons (cons _ a) _) -> a)))
+       (cddr           (forall (a) ((cons _ (cons _ a)) -> a)))
+       (caaar          (forall (a) ((cons (cons (cons a _) _) _) -> a)))
+       (caadr          (forall (a) ((cons _ (cons (cons a _) _)) -> a)))
+       (cadar          (forall (a) ((cons (cons _ (cons a _)) _) -> a)))
+       (caddr          (forall (a) ((cons _ (cons _ (cons a _))) -> a)))
+       (cdaar          (forall (a) ((cons (cons (cons _ a) _) _) -> a)))
+       (cdadr          (forall (a) ((cons _ (cons (cons _ a) _)) -> a)))
+       (cddar          (forall (a) ((cons (cons _ (cons _ a)) _) -> a)))
+       (cdddr          (forall (a) ((cons _ (cons _ (cons _ a))) -> a)))
+       (caaaar         (forall (a) ((cons (cons (cons (cons a _) _) _) _) -> a)))
+       (caaadr         (forall (a) ((cons _ (cons (cons (cons a _) _) _)) -> a)))
+       (caadar         (forall (a) ((cons (cons _ (cons (cons a _) _)) _) -> a)))
+       (caaddr         (forall (a) ((cons _ (cons _ (cons (cons a _) _))) -> a)))
+       (cadaar         (forall (a) ((cons (cons (cons _ (cons a _)) _) _) -> a)))
+       (cadadr         (forall (a) ((cons _ (cons (cons _ (cons a _)) _)) -> a)))
+       (caddar         (forall (a) ((cons (cons _ (cons _ (cons a _))) _) -> a)))
+       (cadddr         (forall (a) ((cons _ (cons _ (cons _ (cons a _)))) -> a)))
+       (cdaaar         (forall (a) ((cons (cons (cons (cons _ a) _) _) _) -> a)))
+       (cdaadr         (forall (a) ((cons _ (cons (cons (cons _ a) _) _)) -> a)))
+       (cdadar         (forall (a) ((cons (cons _ (cons (cons _ a) _)) _) -> a)))
+       (cdaddr         (forall (a) ((cons _ (cons _ (cons (cons _ a) _))) -> a)))
+       (cddaar         (forall (a) ((cons (cons (cons _ (cons _ a)) _) _) -> a)))
+       (cddadr         (forall (a) ((cons _ (cons (cons _ (cons _ a)) _)) -> a)))
+       (cdddar         (forall (a) ((cons (cons _ (cons _ (cons _ a))) _) -> a)))
+       (cddddr         (forall (a) ((cons _ (cons _ (cons _ (cons _ a)))) -> a)))
+
+       (set-car!       (forall (a) ((cons (! a) _) a -> void)))
+       (set-cdr!       (forall (b) ((cons _ (! b)) b -> void)))
+       (list           (case->
+                         (forall (a b c d e) (a b c d e -> (list a b c d e)))
+                         (forall (a b c d) (a b c d -> (list a b c d)))
+                         (forall (a b c) (a b c -> (list a b c)))
+                         (forall (a b) (a b -> (list a b)))
+                         (forall (a) (a -> (list a)))
+                         (forall (a) (a *-> a))))
+       (length         ((listof _) -> num))
+       (append         (case->
+                         (forall (l) (l -> l))
+                         (forall (a l)
+                           ((listof a) l -> 
+                             (MU out (union (cons a out) l))))
+                         (forall (inlist a)
+                           ((arglistof (union inlist (listof a))) 
+                             *-> 
+                             (MU out (union (cons a out) inlist))))))
+       (reverse        (forall (a) ((listof a) -> (listof a))))
+       (list-tail      (forall (a tail)
+                         ((MU l (union nil (cons a (union l tail)))) 
+                           num 
+                           -> (cons a tail))))
+       (list-ref       (forall (a) ((listof a) num -> a)))
+       (memq           (forall (a tail)
+                         (a (MU l (union nil (cons a l) tail)) 
+                           -> (union false (cons a tail)))))
+       (memv           (forall (a tail)
+                         (a (MU l (union nil (cons a l) tail)) 
+                           -> (union false (cons a tail)))))
+       (member         (forall (a tail)
+                         (a (MU l (union nil (cons a l) tail)) 
+                           -> (union false (cons a tail)))))
+       (assq           (forall (a c)
+                         (a (listof (cons a c)) -> 
+                           (union false (cons a c)))))
+       (assv           (forall (a c)
+                         (a (listof (cons a c)) ->
+                           (union false (cons a c)))))
+       (assoc          (forall (a c)
+                         (a (listof (cons a c)) -> 
+                           (union false (cons a c)))))
+
+       ;; symbols
+       (symbol->string (sym -> str))
+       (string->symbol (str -> sym))
+
+       ;; numbers
+       (complex?       (_ -> bool)       (predicate* (#t num) _))
+       (real?          (_ -> bool)       (predicate* (#t num) _))
+       (rational?      (_ -> bool)       (predicate* (#t num) _))
+       (integer?       (_ -> bool)       (predicate* (#t num) _))
+       (exact?         (num -> bool))
+       (inexact?       (num -> bool))
+       (=              ((arg num (arg num (arglistof num))) *-> bool)         )
+       (<              ((arg num (arg num (arglistof num))) *-> bool)         )
+       (>              ((arg num (arg num (arglistof num))) *-> bool)         )
+       (<=             ((arg num (arg num (arglistof num))) *-> bool)         )
+       (>=             ((arg num (arg num (arglistof num))) *-> bool)         )
+       (zero?          (num -> bool))
+       (positive?      (num -> bool))
+       (negative?      (num -> bool))
+       (odd?           (num -> bool))
+       (even?          (num -> bool))
+       (max            ((arg num (arglistof num)) *-> num)                    )
+       (min            ((arg num (arglistof num)) *-> num)                    )
+       (+              ((arglistof num) *-> num)                              )
+       (*              ((arglistof num) *-> num)                              )
+       (-              ((arg num (arglistof num)) *-> num)                    )
+       (/              ((arg num (arglistof num)) *-> num)                    )
+       (abs            (num -> num))
+       (quotient       (num num -> num))
+       (remainder      (num num -> num))
+       (modulo         (num num -> num))
+       (gcd            ((arglistof num) *-> num)                              )
+       (lcm            ((arglistof num) *-> num)                              )
+       (numerator      (num -> num)                                         )
+       (denominator    (num -> num)                                         )
+       (floor          (num -> num)                                         )
+       (ceiling        (num -> num)                                         )
+       (truncate       (num -> num)                                         )
+       (round          (num -> num)                                         )
+       (rationalize    (num num -> num)                                     )
+       (exp            (num -> num)                                         )
+       (log            (num -> num)                                         )
+       (sin            (num -> num)                                         )
+       (cos            (num -> num)                                         )
+       (tan            (num -> num)                                         )
+       (asin           (num -> num)                                         )
+       (acos           (num -> num)                                         )
+       (atan           (num optional num -> num)                            )
+       (sqrt           (num -> num)                                         )
+       (expt           (num num -> num)                                     )
+       (make-rectangular (num num -> num)                                   )
+       (make-polar     (num num -> num)                                     )
+       (real-part      (num -> num)                                         )
+       (imag-part      (num -> num)                                         )
+       (magnitude      (num -> num)                                         )
+       (angle          (num -> num)                                         )
+       (exact->inexact (num -> num)                                         )
+       (inexact->exact (num -> num)                                         )
+       (number->string (num optional num -> str)         )
+       (string->number (str optional num -> num)         )
+
+       ;; characters
+       (char=?         (char char -> bool)                                  )
+       (char<?         (char char -> bool)                                  )
+       (char>?         (char char -> bool)                                  )
+       (char<=?        (char char -> bool)                                  )
+       (char>=?        (char char -> bool)                                  )
+       (char-ci=?      (char char -> bool)                                  )
+       (char-ci<?      (char char -> bool)                                  )
+       (char-ci>?      (char char -> bool)                                  )
+       (char-ci<=?     (char char -> bool)                                  )
+       (char-ci>=?     (char char -> bool)                                  )
+       (char-alphabetic? (char -> bool)                                     )
+       (char-numeric?  (char -> bool)                                       )
+       (char-whitespace? (char -> bool)                                     )
+       (char-upper-case? (char -> bool)                                     )
+       (char-lower-case? (char -> bool)                                     )
+       (char->integer  (char -> num)                                        )
+       (integer->char  (num -> char)                                        )
+       (char-upcase    (char -> char)                                       )
+       (char-downcase  (char -> char)                                       )
+
+       ;; strings
+       (make-string    (num optional char -> str)                           )
+       (string         ((arglistof char) *-> str)                           )
+       (string-length  (str -> num)                                         )
+       (string-ref     (str num -> char)                                    )
+       (string-set!    (str num char -> void)                               )
+       (string=?       (str str -> bool)                                    )
+       (string<?       (str str -> bool)                                    )
+       (string>?       (str str -> bool)                                    )
+       (string<=?      (str str -> bool)                                    )
+       (string>=?      (str str -> bool)                                    )
+       (string-ci=?    (str str -> bool)                                    )
+       (string-ci<?    (str str -> bool)                                    )
+       (string-ci>?    (str str -> bool)                                    )
+       (string-ci<=?   (str str -> bool)                                    )
+       (string-ci>=?   (str str -> bool)                                    )
+       (substring      (str num num -> str)                                 )
+       (string-append  ((arglistof str) *-> str)                            )
+       (string->list   (str -> (listof char))                               )
+       (list->string   ((listof char) -> str)                               )
+       (string-copy    (str -> str)                                         )
+       (string-fill!   (str char -> void)                                   )
+
+       ;; vectors
+       ;; make-vector -- different semantics
+       (make-vector    (case->
+                         (num   -> (vec num))
+                         (forall (a) (num a -> (vec a)))
+                         (forall (a) (num optional a -> (vec (union a num))))))
+       (vector         (forall (a) ((arglistof a) *-> (vec a))))
+       (vector-length  (forall (a) ((vec a) -> num)))
+       (vector-ref     (forall (a) ((vec a) num -> a)))
+       (vector-set!    (forall (a) ((vec (! a)) num a -> void)))
+       (vector->list   (forall (a) ((vec a) -> (listof a))))
+       (list->vector   (forall (a) ((listof a) -> (vec a))))
+       (vector-fill!   (forall (a) ((vec (! a)) a -> void)))
+
+       ;; control features
+       (apply          (case->
+                         (forall (l r)       ((l *->* r)             l ->* r))
+                         (forall (a l r)     ((a l *->* r)     a     l ->* r))
+                         (forall (a b l r)   ((a b l *->* r)   a b   l ->* r))
+                         (forall (a b c l r) ((a b c l *->* r) a b c l ->* r))
+                         (forall (a b c d l r) ((a b c d l *->* r) a b c d l ->* r))
+                         (forall (x r) 
+                           (((MU l (union (cons x l) x)) *->* r) 
+                             x
+                             (arglistof x)
+                             *->* r))))
+       (map            (case->
+                         (forall (a r)
+                           ((a     -> r) (listof a) 
+                             -> (listof r)))
+                         (forall (a b r)
+                           ((a b   -> r) (listof a) (listof b) 
+                             -> (listof r)))
+                         (forall (a b c r) 
+                           ((a b c -> r) (listof a) (listof b) (listof c) 
+                             -> (listof r)))
+                         (forall (x r)
+                           (((arglistof x) *-> r) (listof x) (arglistof (listof x))
+                             *-> (listof r)))))
+
+       (for-each       (case->
+                         (forall (a)
+                           ((a     -> _) (listof a) 
+                             -> void))
+                         (forall (a b)
+                           ((a b   -> _) (listof a) (listof b) 
+                             -> void))
+                         (forall (a b c) 
+                           ((a b c -> _) (listof a) (listof b) (listof c) 
+                             -> void))
+                         (forall (x)
+                           (((arglistof x) *-> _) (listof x) (arglistof (listof x))
+                             *-> void))))
+
+       (force                 (forall (a) ((promise a) -> a)))
+       (make-promise          ((-> a) -> (promise a)))
+       (promise?              (_ -> bool) (predicate promise))
+       (call-with-current-continuation 
+         (forall (a) (((a *-> empty) ->* (mvalues a)) ->* (mvalues a))))
+       (eval           (sexp -> sexp));; --- Not quite right!!!
+
+       ;; input and output
+       (call-with-input-file  (forall (a) (str (iport -> a) -> a)))
+       (call-with-output-file (forall (a) (str (oport -> a) -> a)))
+       (current-input-port    (-> iport)                                    )
+       (current-output-port   (-> oport)                                    )
+       (with-input-from-file  (forall (a) (str (-> a) -> a)))
+       (with-output-to-file   (forall (a) (str (-> a) -> a)))
+       (open-input-file       (str -> iport)                                )
+       (open-output-file      (str -> oport)                                )
+       (close-input-port      (iport -> void)                               )
+       (close-output-port     (oport -> void)                               )
+    
+       (read                  (optional iport -> (union eof sexp)))
+       (read-char             (optional iport -> (union char eof)))
+       (peek-char             (optional iport -> (union char eof)))
+       (char-ready?           (optional iport -> bool))
+       (write                 (optional oport -> void))
+       (display               (_ optional oport -> void))
+       (newline               (optional oport -> void))
+       (write-char            (char optional oport -> void))
+
+       ;; system interface
+       (load           (str -> void)                                          )
+       (transcript-on  (str -> void)                                          )
+       (transcript-off (-> void)                                              )
+
+       ;; predicates
+       (number?        (_ -> bool)         (predicate num))
+       (null?          (_ -> bool)         (predicate nil))
+       (char?          (_ -> bool)         (predicate char))
+       (symbol?        (_ -> bool)         (predicate sym))
+       (string?        (_ -> bool)         (predicate str))
+       (vector?        (_ -> bool)         (predicate vec))
+       (cvector?       (_ -> bool)         (predicate vec))
+       (pair?          (_ -> bool)         (predicate cons))
+       (procedure?     (_ -> bool)         (predicate lambda))
+       (eof-object?    (_ -> bool)         (predicate eof))
+       (input-port?    (_ -> bool)         (predicate iport))
+       (output-port?   (_ -> bool)         (predicate oport))
+       (boolean?       (_ -> bool)         (predicate true false))
+       (list?          (_ -> bool)         (predicate* (#t nil cons) (#f nil)))
+
+       )))
+
+;; ======================================================================
+
+(define (language-add-boxes-etc!)
+  (add-default-primitives!
+   `(
+     (read                  (optional iport -> (union eof sexp)))
+     (box?           (_ -> bool)                       (predicate box))
+     (box            (forall (a) (a -> (box a))))
+     (unbox          (forall (a) ((box a) -> a)))
+     (set-box!       (forall (a) ((box (! a)) a -> void)))
+     (void           (-> void))
+
+     (add1          (num -> num)                                      )
+     (sub1          (num -> num)                                      )
+     (ormap         (case->
+                     (forall (a r)
+                             ((a -> r) (listof a) -> (union false r)))
+                     (forall (a b r)
+                             ((a b -> r) (listof a) (listof b) 
+                              -> (union false r)))
+                     (forall (a b c r)
+                             ((a b c -> r) (listof a) (listof b) (listof c) 
+                              -> (union false r)))
+                     (forall (x r)
+                             (((arglistof x) *-> r) (arglistof (listof x))
+                              *-> (union false r)))))
+     (andmap        (case->
+                     (forall (a r)
+                             ((a -> r) (listof a) -> (union true r)))
+                     (forall (a b r)
+                             ((a b -> r) (listof a) (listof b) 
+                              -> (union true r)))
+                     (forall (a b c r)
+                             ((a b c -> r) (listof a) (listof b) (listof c) 
+                              -> (union true r)))
+                     (forall (x r)
+                             (((arglistof x) *-> r) (arglistof (listof x))
+                              *-> (union true r)))))
+
+     (append!        (forall (p)
+                       ((arglistof
+                          (MU q (union (cons _ q) (cons _ p) (cons _ (! p)))))
+                         *->
+                         p)))
+     (exit          (optional num -> empty))
+     (format        (str _ *-> str))
+     (fprintf       (oport str (arglistof _) *-> void))
+     (getenv        (str -> (union str false)))
+     (list*         (forall (l a)
+                            ((arglistof (union l (listof a))) 
+                             *-> (MU o (union l (cons a o))))))
+     (printf        (str _ *-> void))
+     (putenv        (str str -> bool))
+     (random        (num -> num))
+     (random-seed   (num -> void))
+     (reverse!      
+      (forall 
+       (l p a)
+       ((arglistof (MU l (union p (cons a l) (cons _ (! p))))) *-> p)))
+
+     (pretty-print  (_ optional oport -> void)                        )
+     (gensym        (optional (union sym str) -> sym))
+     (sort          (forall (a) ((a a -> _) (listof a) -> (listof a))))
+
+     (string->uninterned-symbol (str -> sym))
+
+     (remove        (forall (a)
+                            (a (listof a) optional (a a -> bool) 
+                             -> (listof a))))
+     (remq          (forall (a) (a (listof a) -> (listof a))))
+     (remv          (forall (a) (a (listof a) -> (listof a))))
+
+     (dynamic-wind  (forall (b) ((-> _) (-> b) (-> _) -> b)))
+     (call/cc       (forall (a) (((a *-> empty) ->* (mvalues a)) ->* (mvalues a))))
+
+     )))
+
+
+(define (init-Chez-on-R4RS!)
+
+  (language-add-boxes-etc!)
+
+  (add-default-primitives!
+   `(
+     (void           (-> void)                                        )
+
+     ;; Standard Chez Scheme primitives.
+     (make-list     (forall (a) (num a -> (listof a))))
+     (error         (_ str _ *-> empty))
+     (expand-once   (sexp -> sexp)                                    )
+
+     )))
+
+;; ----------------------------------------------------------------------
+
+(define this-directory (current-load-relative-directory))
+
+(define (init-MzScheme-on-R4RS!)
+
+  ;; Syntactic forms unimplemented
+  ;;    define-struct
+  ;;    objects
+  ;;    let/cc, let/rc
+  ;;    eval, comple
+  ;;    begin0
+  ;;    fluid-let
+  ;;    letrec*
+  ;;    make-global-value-list
+  ;;    time, unless
+
+  (language-add-boxes-etc!)
+
+  ;; Could make weight a field of thread
+  (add-constructor! 'thread)
+  (add-constructor! 'hash-table #t #t)
+  (add-constructor! 'weak-box #f)
+  (add-constructor! 'regexp)
+  (add-constructor! 'arity-at-least #f)
+  (add-constructor! 'parameterization)
+  (add-constructor! 'semaphore)
+  (add-constructor! 'type-symbol)
+  (add-constructor! 'namespace)
+  (add-constructor! 'custodian)
+  (add-constructor! 'will-executor)
+  (add-constructor! 'tcp-listener)
+
+  (add-default-primitives!
+    `(
+       ;; MzSchemes f*cked up void :-)
+       (void           (_ *-> void))
+
+       (eof                  eof)
+
+       ;; Organization follows MzScheme Reference Manual
+       ;; --- Programming Constructs
+     
+       ;; Void and Undefined
+       (void?          (_ -> bool) (predicate void))
+
+       ;; Number extensions
+       (bitwise-ior         (num (arglistof num) *-> num))
+       (bitwise-and         (num (arglistof num) *-> num))
+       (bitwise-xor         (num (arglistof num) *-> num))
+       (bitwise-not         (num (arglistof num) *-> num))
+       (arithmetic-shift    (num num -> num))
+
+       ;; --- Semaphores
+
+       (make-semaphore      (num -> semaphore))
+       (semaphore?          (semaphore -> bool)          (predicate semaphore))
+       (semaphore-post      (semaphore -> void))
+       (semaphore-wait      (semaphore -> void))
+       (semaphore-try-wait  (semaphore -> bool))
+       (semaphore-callback  (semaphore (-> _) -> bool))
+       (input-port-post-semaphore  (iport semaphore -> void))
+
+       ;; --- Ports
+       ;; Current ports
+       (current-input-port  (optional iport -> iport))
+       (current-output-port (optional oport -> oport))
+       (current-error-port  (optional oport -> oport))
+
+       (thread-input-port   (-> iport))
+       (thread-output-port  (-> oport))
+       (thread-error-port   (-> iport))
+
+       (open-input-file     (str optional sym -> iport))
+       (open-output-file    (str optional sym optional sym -> oport))
+
+       (call-with-input-file  
+         (forall (a) (str (iport -> a) optional sym              -> a)))
+       (call-with-output-file
+         (forall (a) (str (oport -> a) optional sym optional sym -> a)))
+       (with-input-from-file
+         (forall (a) (str (-> a)       optional sym              -> a)))
+       (with-output-to-file
+         (forall (a) (str (-> a)       optional sym optional sym -> a)))
+
+       ;; String ports
+       (open-input-string   (str -> iport))
+       (open-output-string  (-> oport))
+       (get-output-string   (oport -> str))
+
+       ;; File ports
+       (flush-output        (optional oport -> void))
+       (file-position       ((union iport oport) optional num -> num))
+
+       ;; Custom ports
+       (make-input-port     ((-> char) (-> bool) (-> void) -> iport))
+       (make-output-port    ((str -> void) (-> void) -> oport))
+
+       ;; ---- Filesystem Utilities
+       ;; Files
+       (file-exists?        (str -> bool))
+       (delete-file         (str -> bool))
+       (rename-file         (str str -> bool))
+       (file-modify-seconds (str -> num))
+       (file-or-directory-permissions (str -> (listof sym)))
+
+       ;; Hash Tables - fields are key and value
+       (make-hash-table     (optional sym -> (hash-table empty empty)))
+       (make-hash-table-weak (optional sym -> (hash-table empty empty)))
+       (hash-table?         (_ -> bool)      (predicate hash-table))
+       (hash-table-put!     
+         (forall (k v) ((hash-table (! k) (! v)) k v -> void)))
+       (hash-table-get          
+         (forall (k v r) ((hash-table k v) _ optional (-> r) -> (union v r))))
+       (hash-table-remove!      
+         (forall (k v) ((hash-table _ _) _ -> void)))
+       (hash-table-map          
+         (forall (k v w) ((hash-table k v) (k v -> w) -> (listof w))))
+       (hash-table-for-each     
+         (forall (k v) ((hash-table k v) (k v -> _) -> void)))
+
+       ;; Weak boxes
+       (make-weak-box       (forall (v) (v -> (weak-box (union v false)))))
+       (weak-box?           (_ -> bool) (predicate weak-box))
+       (weak-box-value      (forall (v) ((weak-box v) -> v)))
+
+       ;; Regular expressions
+       (regexp              (str -> regexp))
+       (regexp?             (_ -> bool) (predicate regexp))
+       (regexp-match        ((union str regexp) str 
+                              -> (union false (listof str))))
+       (regexp-match-positions 
+         ((union str regexp) str -> (union false (listof (cons num num)))))
+       (regexp-replace      ((union str regexp) str str -> str))
+       (regexp-replace*     ((union str regexp) str str -> str))
+
+       ;; Global type variables don't work, so analysis of
+       ;; exception handling is unsound here
+
+       ;; Exceptions
+;;     (global:CEH           GLOBAL-TYPE-VARIABLE)
+;;     (global:raised-values GLOBAL-TYPE-VARIABLE);
+;;
+;;     (raise               (global:raised-values -> empty))
+;;     (current-exception-handler
+;;                          (optional (intersect global:CEH
+;;                                               (global:raised-values -> _))
+;;                                    -> global:CEH))
+
+       (raise               (_ -> empty))
+       (current-exception-handler         (optional (empty -> _) -> empty))
+ 
+       (make-exn:else       (_ *-> empty))
+
+       ;; Flow control
+       (call-with-escaping-continuation
+                            (forall (a) (((a *-> empty) ->* (mvalues a)) ->* (mvalues a))))
+        
+       (call/ec             (forall (a) (((a *-> empty) ->* (mvalues a)) ->* (mvalues a))))
+
+       (values              (forall (a) (a *->* (mvalues a))))
+       (call-with-values    (forall (x r) ((list (nil *->* (mvalues x))
+                                             (x *->* (mvalues r)))
+                                            *->* (mvalues r))))
+
+       ;; --------------------
+
+       ;; Arity
+       (arity               ((empty *-> _) -> 
+                              (rec ([r (union num (arity-at-least num))])
+                                (union r (listof r)))))
+       (arity-at-least?     (_ -> bool) (predicate arity-at-least))
+       (arity-at-least-value (forall (v) ((arity-at-least v) -> v)))
+
+       ;; Global and Constant Names
+       (defined?            (sym -> bool))
+
+       ;; Evaluation Handler - no can type :-
+
+       ;; Handlers
+       (current-print       (optional (empty -> void) -> (_ -> void)))
+       (current-prompt-read
+         (optional (-> (union eof sexp)) -> (-> (union eof sexp))))
+       (error              ((union sym str) (arglistof _) *-> empty))
+
+       ;; ### problems with types for handlers
+
+       (error-display-handler  (optional (empty -> void) -> (_ -> void)))
+       (error-escape-handler   (optional (-> _) -> (-> empty)))
+       (exit-handler           (optional (num -> _) -> (num -> empty)))
+
+       ;; User Breaks
+       (user-break-poll-handler (optional (-> bool) -> (-> bool)))
+       (break-enabled          (optional _ -> bool))
+       (dynamic-enable-break   (forall (v) ((-> v) -> v)))
+
+       ;; Compilation
+       (compile-file           ((union str iport) (union str oport) _ -> void))
+
+       ;; Dynamic extensions
+       (load-extension         (str -> void))
+
+       ;; Operating System Processes
+       (system                 (str -> bool))
+       (sytem*                 (str (arglistof str) *-> bool))
+       (process                (str -> 
+                                 (cons iport 
+                                   (cons oport
+                                     (cons num (cons iport nil))))))
+       (process*               (str (arglistof str) *-> 
+                                 (cons iport 
+                                   (cons oport
+                                     (cons num (cons iport nil))))))
+
+       ;; Misc
+       (banner                 (-> str))
+       (gensym                 (optional (union str sym) -> sym))
+       (load/cd                (str -> void))
+       (load-with-cd           (str -> void))
+       (promise?               (_ -> bool) (predicate promise))
+       (read-eval-print-loop   (-> void))
+       (read-line              (optional iport -> (union str eof)))
+       (system-type            (-> sym))
+       (version                (-> str))
+
+       ;; Signature stuff
+       (#%unit-with-signature-unit empty)
+       (#%make-unit-with-signature empty)
+       (#%verify-linkage-signature-match empty)
+
+       ;; --------------------------------------------------------------------
+       ;; the following is structured after the MzScheme ref manual 5.9.97
+
+       ;; ------ basic data extensions
+       ;; ---- procedures
+       ;; -- primitives
+       (primitive?             (_ -> bool) (predicate* (#t lambda) _))
+       (primitive-name         ((empty *->* _) -> sym))
+       (primitive-result-arity? ((empty *->* _) -> num))
+       (primitive-result-arity? ((empty *->* _) -> bool))
+
+       ;; ------ structures 
+       ;; ---- structure utilities
+       (struct?                (_ -> bool) (predicate structure:))
+       (struct-length          (structure: -> num))
+       (struct-type?           (-> bool))
+       (struct-constructor-procedure? (-> bool))
+       (struct-predicate-procedure? (-> bool))
+       (struct-selector-procedure? (-> bool))
+       (struct-setter-procedure? (-> bool))
+
+       ;; ------ classes and objects
+       ;; ---- object utilities
+
+       (object?                (_ -> bool))
+       (class?                 (_ -> bool) (predicate internal-class))
+       (is-a?                  (_ _ -> bool))
+       (make-object
+         (forall (args u o f v)
+           ( (internal-class u o (args *->* _) (! u) (! o) o (! o) (! o) v)
+             args 
+             *->
+             (union o v))))
+       (ivar-in-class?        (_ _ -> bool))
+       (uq-ivar               (forall (i) ((all-ivars i) _ -> i)))
+
+
+
+
+       ;; ------ units
+       (unit/sig->unit         (forall (a) (a -> a)))
+       (unit?                  (_ -> bool))
+
+       ;; ------ threads and namespaces
+       ;; ---- threads
+       (thread              ((-> _) -> thread))
+       ;; -- thread utilities
+       (current-thread         (-> thread))
+       (thread?                (_ -> bool) (predicate thread))
+       (sleep                  (num -> void))
+       (thread-running?        (thread -> bool))
+       (thread-wait            (thread -> void))
+       (kill-thread            (thread -> void))
+       (break-thread           (thread -> void))
+       (thread-weight          (case->
+                                 (thread -> num)
+                                 (thread num -> void)))
+       ;; ---- semaphores
+       (make-semaphore         (optional num -> semaphore))
+       (semaphore?             (_ -> bool) (predicate semaphore))
+       (semaphore-post         (semaphore -> void))
+       (semaphore-wait         (semaphore -> void))
+       (semaphore-try-wait?    (semaphore -> bool))
+       (semaphore-wait/enable-break (semaphore -> void))
+       (semaphore-callback     (semaphore (-> _) -> void))
+       (input-port-post-semaphore (iport semaphore -> void))
+
+       ;; ---- parameterization
+       ;; -- built-in parameters
+       ;; loading
+       (current-load-relative-directory (union str false))
+       ;; -- exceptions
+       (debug-info-handler     (-> (-> void)))
+       ;; libraries
+       (current-library-collections-paths
+         (case->
+           ((listof str) -> void)
+           (-> (listof str))))
+       (require-library-use-compiled (case-> (bool -> void) (-> bool)))
+       ;; parsing
+       (read-case-sensitive    (case-> (-> bool) (bool -> void)))
+       (read-square-bracket-as-paren (case-> (-> bool) (bool -> void)))
+       (read-curly-brace-as-paren (case-> (-> bool) (bool -> void)))
+       (read-accept-box        (case-> (-> bool) (bool -> void)))
+       (read-accept-type-symbol (case-> (-> bool) (bool -> void)))
+       (read-accept-compiled   (case-> (-> bool) (bool -> void)))
+       (read-accept-bar-quote  (case-> (-> bool) (bool -> void)))
+       (read-accept-graph      (case-> (-> bool) (bool -> void)))
+       ;; printing
+       (print-graph            (case-> (-> bool) (bool -> void)))
+       (print-struct           (case-> (-> bool) (bool -> void)))
+       (print-box              (case-> (-> bool) (bool -> void)))
+       
+       ;; -- parameter utilities
+       ;; We should arguably have a separate type for parameter procedures
+       (make-parameter (forall (x i)
+                         (x optional (i -> x) 
+                           -> (optional i -> (union x void)))))
+       (parameter?            (_ -> bool))
+       (parameter-procedure=? (_ _ -> bool))
+
+       ;; -- parameterization utilities
+       (make-parameterization (parameterization -> parameterization))
+       (current-parameterization
+         (case->
+           (parameterization -> void)
+           (-> parameterization)))
+       (parameterization?     (-> bool) (predicate parameterization))
+       (in-parameterization   (forall (param)
+                                (parameterization
+                                  param
+                                  optional _
+                                  -> param)))
+       (with-parameterization (parameterization (-> result) -> result))
+       (with-new-parameterization ((-> result) -> result))
+       (parameterization-branch-handler (-> parameterization))
+
+       ;; ---- custodians
+       (make-custodian         (custodian -> custodian))
+       (custodian-shutdown-all (custodian -> void))
+       (custodian?             (_ -> bool) (predicate custodian))
+       (current-custodian      (case->
+                                 (-> custodian)
+                                 (custodian -> void)))
+
+       ;; ---- namespaces
+       (make-namespace           ((listof sym) *-> namespace))
+       (namespace?               (_ -> bool) (predicate namespace))
+       (current-namespace        (case->
+                                   (-> namespace)
+                                   (namespace -> void)))
+
+       ;; ------ System utilities
+       ;; ---- ports
+       ;; ---- filesystem utilities
+       ;; -- pathnames
+       (build-path          (str (arglistof (union str sym)) *-> str))
+       (absolute-path?      (str -> bool))
+       (relative-path?      (str -> bool))
+       (complete-path?      (str -> bool))
+       (path->complete-path (str -> str))
+       (resolve-path        (str -> str))
+       (expand-path         (str -> str))
+       (normal-case-path    (str -> str))
+
+       (split-path          (str -> (union str sym false)
+                              (union str sym)
+                              bool))
+       (find-executable-path (str str -> str))
+       ;; -- directories
+       (current-directory   (case->
+                              (str -> void)
+                              (-> str)))
+       (current-drive       (-> (union bool str)))
+       (directory-exists?   (str -> bool))
+       (make-directory      (str -> bool))
+       (delete-directory    (str -> bool))
+       (directory-list      (optional str -> (listof str)))
+       (filesystem-root-list (-> (listof str)))
+     
+       ;; ---- networking
+       (tcp-listen          (num optional num -> tcp-listener))
+       (tcp-connect         (str num ->* (mvalues (list iport oport))))
+       (tcp-accept          (tcp-listener ->* (mvalues (list iport oport))))
+       (tcp-accept-ready?   (tcp-listener -> bool))
+       (tcp-close           (tcp-listener -> void))
+       (tcp-listener?       (_ -> bool) (predicate tcp-listener))
+       (tcp-port-send-waiting? (oport -> bool))
+
+       ;; ---- time
+       ;; -- real time
+       (current-seconds     (-> num))
+       ;(seconds->date       (num -> (structure:date num num num num 
+       ;                               num num num num bool)))
+       ;; -- machine time
+       (current-milliseconds(-> num))
+       (current-process-milliseconds(-> num))
+       (current-gc-milliseconds(-> num))
+       ;; -- timing execution
+       (time-apply          (forall (a) ((-> a) -> (list a num num))))
+       
+       ;; ---- operating system processes
+       (system              (str -> bool))
+       (system*             (str (listof str) *-> bool))
+       (execute             (str -> void))
+       (execute*            (str (listof str) *-> void))
+       (process             (str -> (list iport oport num iport (sym -> sym))))
+       (process*            (str (listof str)
+                              *-> (list iport oport num iport (sym -> sym))))
+       
+       
+       ;; ------ memory management
+       ;; ---- will executors
+       (make-will-executor       (-> will-executor))
+       (will-executor?           (_ -> bool) (predicate will-executor))
+       (register-will            (forall (a)
+                                   (a (a ->* _) optional will-executor 
+                                     -> void)))
+       (will-executor-try        (will-executor -> void))
+       (current-will-executor 
+         (case-> (will-executor -> void) (-> will-executor)))
+
+       ;; ---- garbage collection
+       (collect-garbage          (-> void))
+       (dump-memory-stats        (-> void))
+
+       ;; ------ macros
+       ;; ---- expanding macros
+       (syntax?                  (_ -> bool))
+       (macro?                   (_ -> bool))
+       (id-macro?                (_ -> bool))
+
+       ;; ------ support facilities
+       ;; ---- input parsing
+       (type-symbol?             (_ -> bool) (predicate type-symbol))
+       (string->type-symbol      (str -> type-symbol))
+
+
+
+
+       ;; --------------------------------------------------------------------
+       (print                 (_ optional oport -> void))
+       (make-pipe             (->* (mvalues (list iport oport))))
+
+       ;; --------------------------------------------------------------------
+       ;; MzScheme stand-alone definitions
+       (program               str)
+       (argv                  (vec str))
+
+       ))
+
+
+  '(language-add-boot-file 
+     (build-path 
+       (or this-directory 
+         (build-path
+	   (collection-path "mrspidey") ; MATTHEW: got rid of plt-home
+           "Sba"))
+       "exn-hierarchy.ss"))
+  )
+
+
+
+
+;; ======================================================================
+
+(define (init-MrEd-on-MzScheme!)
+  (language-add-boot-file "~/Spidey/wx/all.sig")
+  )
+
+;; ======================================================================
+
+(define (init-mzlib!)
+
+  (constructor-alias! 'null 'nil)
+
+  (add-default-primitives!
+   '(
+     (require-library (str -> void))
+     (=?             ((arg num (arg num (arglistof num))) *-> bool)         )
+     (<?             ((arg num (arg num (arglistof num))) *-> bool)         )
+     (>?             ((arg num (arg num (arglistof num))) *-> bool)         )
+     (<=?            ((arg num (arg num (arglistof num))) *-> bool)         )
+     (>=?            ((arg num (arg num (arglistof num))) *-> bool)         )
+     (1+             (num -> num))                                          
+     (1-             (num -> num))
+
+     (null           nil)
+     (cons?          (_ -> bool) (predicate cons))
+     (gentemp        (-> sym)                                          )
+     (bound?         (sym -> bool))
+     (flush-output-port (optional oport -> void))
+     (real-time      (-> num))
+
+     ;; --- file.ss
+     (build-absolute-path (str (arglistof (union str sym)) -> str))
+     (build-relative-path (str (arglistof (union str sym)) -> str))
+     (explode-path        (str -> (listof str)))
+     (filename-extension  (str -> str))
+     (find-relative-path  (str str -> str))
+     (normalize-path      (str optional str -> str))
+
+     ;; --- function.ss
+     (first         (forall (a) ((cons a _) -> a)))
+     (second        (forall (a) ((cons _ (cons a _)) -> a)))
+     (third         (forall (a) ((cons _ (cons _ (cons a _))) -> a)))
+     (fourth        (forall (a) ((cons _ (cons _ (cons _ (cons a _)))) -> a)))
+     (fifth         (forall (a) ((cons _ (cons _ (cons _ (cons _ (cons a _))))) -> a)))
+     (sixth         (forall (a) ((cons _ (cons _ (cons _ (cons _ (cons _ (cons a _)))))) -> a)))
+     (seventh       (forall (a) ((cons _ (cons _ (cons _ (cons _ (cons _ (cons _ (cons a _))))))) -> a)))
+     (eighth         (forall (a) ((cons _ (cons _ (cons _ (cons _ (cons _ (cons _ (cons _ (cons a _)))))))) -> a)))
+
+     (build-list    (forall (a) (num (num -> a) -> (listof a))))
+     (build-string  (num (num -> char) -> str))
+     (build-vector  (forall (a) (num (num -> a) -> (vec a))))
+     (cons?         (_ -> bool) (predicate cons))
+     (compose       (forall (x y z) ((x ->* y) (y *->* z) -> (x ->* z))))
+       
+     (dynamic-disable-break (forall (v) ((-> v) -> v)))
+     (dynamic-wind/protect-break
+                    (forall (v) ((-> _) (-> v) (-> _) -> v)))
+     
+     (foldl         (case->
+                     (forall (a z) ((a z -> z) z (listof a) -> z))
+                     (forall (a b z) 
+                             ((a b z -> z) z (listof a) (listof b) -> z))
+                     (forall 
+                      (a b c z)
+                      ((a b c z -> z) z (listof a) (listof b) (listof c) -> z))
+                     (forall 
+                      (x z)
+                      (((arglistof x) *-> z) z (listof (arglistof x)) *-> z))))
+     (foldr         (case->
+                     (forall (a z) ((a z -> z) z (listof a) -> z))
+                     (forall (a b z) 
+                             ((a b z -> z) z (listof a) (listof b) -> z))
+                     (forall 
+                      (a b c z)
+                      ((a b c z -> z) z (listof a) (listof b) (listof c) -> z))
+                     (forall
+                      (x z)
+                      (((arglistof x) *-> z) z (listof (arglistof x)) *-> z))))
+     (ignore-errors (forall (x) ((-> x) -> (union x void))))
+     (last-pair     (forall (p l)
+                      ( (MU l (union p (cons _ l))) -> p)))
+     (loop-until    (forall (x)
+                      (x (x -> _) (x -> x) (x -> _) -> void)))
+
+     (identity      (forall (x) (x -> x)))
+     (quicksort     (forall (a) ((listof a) (a a -> _) -> (listof a))))
+     
+     ;; --- pretty.ss
+     (pretty-print  (_ optional oport 
+                       optional num
+                       optional bool
+                       optional bool
+                       optional num
+                       -> void))
+     (pretty-print-columns (optional num -> (union num void)))
+     (pretty-print-depth   (optional num -> (union num void)))
+     ;; NOT pretty-print-handler
+
+     ;; --- strings.ss
+     ;; NOT eval-string
+     (expr->string    (_ -> str))
+     (newline-string  (-> str))
+     (read-string     (str -> sexp))
+     (read-string-all (str -> (listof sexp)))
+      ;;(regexp-match    ((union str regexp) str -> bool))
+     (string-lowercase! (str -> str))
+     (string-uppercase! (str -> str))
+
+     (match:error   (_ optional _ -> empty))
+;     (match:andmap  (case->
+;                     (forall (a r)
+;                             ((a -> r) (listof a) -> (union true r)))
+;                     (forall (a b r)
+;                             ((a b -> r) (listof a) (listof b) 
+;                              -> (union true r)))
+;                     (forall (a b c r)
+;                             ((a b c -> r) (listof a) (listof b) (listof c) 
+;                              -> (union true r)))
+;                     (forall (x r)
+;                             (((arglistof x) *-> r) (arglistof (listof x))
+;                              *-> (union true r)))))
+;     
+     )))
+
+
+(define (init-zmath!)
+  ;; --- zmath.ss
+  (add-default-primitives!
+   `(
+     (conjugate       (num -> num))
+     (cosh            (num -> num))
+     (make-rectangular (num num -> num)                                   )
+     (sinh            (num -> num))
+     (zabs            (num -> num))
+     (zacos           (num -> num))
+     (zasin           (num -> num))
+     (zatan           (num -> num))
+     (zcos            (num -> num))
+     (zexp            (num -> num))
+     (zlog            (num -> num))
+     (zsin            (num -> num))
+     (zsqrt           (num -> num))
+     (ztan            (num -> num))
+     (pi              3.14159)
+     (e               2.71828)
+     )))
+
+;; ======================================================================
+
+(define (init-DrScheme-on-MzScheme!)
+
+  (add-constructor! '2vec #t)
+  (add-constructor! 'viewport)
+  (add-constructor! 'posn #t #t)
+  (add-constructor! 'rgb #t #t #t)
+  (add-constructor! 'mouse-click)
+
+  (add-constructor! 'module #f)
+
+  (add-default-primitives!
+    `(
+       (match:error    (_ -> empty))
+      
+       (make-rs:module  (forall (x) (x -> (module x))))
+
+       ;; Can't do anything smarter, even though b must be a list
+       ;; Need to implement *
+                                        ;(cons           (forall (a b) (a (union b nil (cons _ _))-> (cons a b))))
+                                        ;(set-cdr!       (forall (b) ((cons _ (! b)) b -> void)))
+       (atom?          (_ -> bool)
+         (predicate* (#f cons) (#t cons)))
+       (build-list     (forall (a) (num (num -> a) -> (listof a))))
+       (build-string   (num (num -> char) -> str))
+    
+       ;; Vectors
+       (build-vector   (forall (a) (num (num -> a) -> (vec a))))
+       (tabulate       (forall (a) (num (num -> a) -> (vec a))))
+       (foreach!       (forall 
+                         (v a b)
+                         ((union v (vec a) (vec (! b))) (a num -> b) -> v)))
+       (2vector        (forall (a) ((listof (listof a)) -> (2vec a))))
+       (2make-vector   (num num -> (2vec void)))
+       (2vector-init   (forall (a) (num num (num num -> a) -> (2vec a))))
+       (2vector-ref    (forall (a) ((2vec a) num num -> a)))
+       (2vector-set!   (forall (a) ((2vec (! a)) num num a -> void)))
+       (2foreach!      (forall 
+                         (v a b)
+                         ((union v (2vec a) (2vec (! b))) (a num num -> b) -> v)))
+       (2vector-print  (forall (a) ((2vec a) ((vec a) -> void) -> void)))
+
+       ;; --------------------
+       ;; SIXlib
+       (open-viewport  (str num optional num optional num -> viewport))
+       (open-pixmap    (str num optional num optional num -> viewport))
+       (close-viewport (viewport -> void))
+
+       (make-posn      (forall (x y)
+                         ((union num x) (union num y) -> (posn x y))))
+       (posn-x         (forall (x) ((posn x _) -> x)))
+       (posn-y         (forall (y) ((posn _ y) -> y)))
+       (posn?          ((union (posn _ _) _) -> bool) (predicate posn))
+
+       (get-pixel      (viewport -> ((posn _ _) -> num)))
+
+       (make-rgb       (forall (r g b)
+                         ((union num r) (union num g) (union num b) 
+                           -> (rgb r g b))))
+       (rgb-red        (forall (r) ((rgb r _ _) -> r)))
+       (rgb-green      (forall (g) ((rgb _ g _) -> g)))
+       (rgb-blue       (forall (b) ((rgb _ _ b) -> b)))
+       (rgb?           ((union (rgb _ _ _) _) -> bool)
+         (predicate rgb))
+       (change-color   (num (rgb _ _ _) -> void))
+       (default-display-is-color? (-> bool))
+    
+       ;; --- Drawing ops
+       (draw-viewport  (viewport -> (optional num -> void)))
+       (draw-pixel     (viewport -> ((posn _ _) optional num -> void)))
+       (draw-line      (viewport -> 
+                         ((posn _ _) (posn _ _) optional num -> void)))
+       (draw-string    (viewport -> ((posn _ _) str optional num -> void)))
+       (draw-pixmap    (viewport -> (str (posn _ _) -> void)))
+                              
+       (clear-viewport (viewport -> (-> void)))
+       (clear-pixel    (viewport -> ((posn _ _) -> void)))
+       (clear-line     (viewport -> ((posn _ _) (posn _ _) -> void)))
+       (clear-string   (viewport -> ((posn _ _) str -> void)))
+       (clear-pixmap   (viewport -> (str (posn _ _) -> void)))
+                              
+       (flip-viewport (viewport -> (-> void)))
+       (flip-pixel    (viewport -> ((posn _ _) -> void)))
+       (flip-line     (viewport -> ((posn _ _) (posn _ _) -> void)))
+       (flip-string   (viewport -> ((posn _ _) str -> void)))
+       (flip-pixmap   (viewport -> (str (posn _ _) -> void)))
+                              
+       ;; --- Mouse ops
+       (get-mouse-click      (viewport -> mouse-click))
+       (ready-mouse-click    (viewport -> (union false mouse-click)))
+       (ready-mouse-release  (viewport -> (union false mouse-click)))
+       (query-mouse-posn     (viewport -> (union false (posn num num))))
+       (mouse-click-posn     (mouse-click -> (posn num num)))
+       (left-mouse-click?    (mouse-click -> bool))
+       (middle-mouse-click?  (mouse-click -> bool))
+       (right-mouse-click?   (mouse-click -> bool))
+       (viewport-flush-input (viewport -> void))
+
+       ;; --------------------
+       ;; Module values
+
+       ;; Miscellaneous
+       (rs:major-version num)
+       (rs:minor-version num)
+       (rs:date        str)
+       (rs:banner-lines (str -> void))
+       )))
+
+;; ----------------------------------------------------------------------
+
+(define (init-smart-numops!)
+
+  (st:constants #t)
+
+  (add-constructor! 'apply+  #f)
+  (add-constructor! 'apply-  #f)
+  (add-constructor! 'apply*  #f)
+  (add-constructor! 'apply/  #f)
+
+  ;; The following are binary ops
+  ;; they return the elements of the first set that satisfy the
+  ;; appropriate relation wrt some element of the second set
+  (add-constructor! '= #f #f)
+  (add-constructor! 'not= #f #f)
+  (add-constructor! '< #f #f)
+  (add-constructor! '<= #f #f)
+  (add-constructor! '> #f #f)
+  (add-constructor! '>= #f #f)
+
+  (record-super-constructor! 'num 'apply+)
+  (record-super-constructor! 'num 'apply-)
+  (record-super-constructor! 'num 'apply*)
+  (record-super-constructor! 'num 'apply/)
+
+  (record-super-constructor! 'num '=)
+  (record-super-constructor! 'num 'not=)
+  (record-super-constructor! 'num '<)
+  (record-super-constructor! 'num '<=)
+  (record-super-constructor! 'num '>)
+  (record-super-constructor! 'num '>=)
+
+  (install-output-type-expander!
+   (match-lambda 
+    [('apply+ ('list . t*)) `(+ ,@t*)]
+    [('apply* ('list . t*)) `(* ,@t*)]
+    [('apply- ('list . t*)) `(- ,@t*)]
+    [('apply/ ('list . t*)) `(/ ,@t*)]
+    [('+ t 1)               `(add1 ,t)]
+    [('- t 1)               `(sub1 ,t)]
+    [type type]))
+
+  (let* ([bin-pred
+          (lambda (op) (lambda (x y) 
+                         '(pretty-debug
+                           `(make-constructed-Tvar ,op
+                                                   ,(Tvar-name x)
+                                                   ,(Tvar-name y)))
+                         (make-constructed-Tvar op x y)))]
+         [bin-pred-r
+          (lambda (op) (lambda (x y) ((bin-pred op) y x)))]
+         [comparator-helper-fn
+          (lambda (op reverse-op negation-op negation-reverse-op)
+            ;; eg < > >= <=
+            (lambda (before after Tvar bool)
+              '(printf "before ~s after ~s  Tvar ~s~n" 
+                       (map Tvar-name before)
+                       (map Tvar-name after)
+                       (Tvar-name Tvar))
+              (if bool
+                  (foldl (bin-pred-r op) 
+                         (foldl (bin-pred-r reverse-op) Tvar before)
+                         after)
+                  (match (list before after)
+                    [((arg) ()) ((bin-pred negation-reverse-op) Tvar arg)]
+                    [(() (arg)) ((bin-pred negation-op) Tvar arg)]
+                    [_ Tvar]))))])
+ 
+    (add-default-primitives!
+     `(
+       ;; numbers
+       (+              (forall (a) ((union a (arglistof num)) *-> (apply+ a))))
+       (*              (forall (a) ((union a (arglistof num)) *-> (apply* a))))
+       (-              (forall (a) ((union a (arg num (arglistof num))) 
+                                    *-> (apply- a))))
+       (/              (forall (a)
+                               ((union a (arg num (arglistof num)))
+                                *-> (apply/ a))))
+       (add1           (forall (a) ((union a num) -> (apply+ (list a 1)))))
+       (sub1           (forall (a) ((union a num) -> (apply- (list a 1)))))
+
+       (=              ((arg num (arg num (arglistof num))) *-> bool)
+                       (predicate-fn 
+                        ,(comparator-helper-fn '= '= 'not= 'not=)))
+       (<              ((arg num (arg num (arglistof num))) *-> bool)
+                       (predicate-fn 
+                        ,(comparator-helper-fn '< '> '>= '<=)))
+       (>              ((arg num (arg num (arglistof num))) *-> bool)
+                       (predicate-fn 
+                        ,(comparator-helper-fn '> '< '<= '>=)))
+       (<=             ((arg num (arg num (arglistof num))) *-> bool)
+                       (predicate-fn 
+                        ,(comparator-helper-fn '<= '>= '> '<)))
+       (>=             ((arg num (arg num (arglistof num))) *-> bool)
+                       (predicate-fn 
+                        ,(comparator-helper-fn '>= '<= '< '>)))
+       (zero?          (num -> bool)
+                       (predicate-fn 
+                        ,(lambda (before after Tvar bool)
+                           (let ([Tvar-zero (mk-Tvar 'zero?)])
+                             (new-AV! Tvar-zero (traverse-const-exact 0))
+                             (if bool
+                                 Tvar-zero
+                                 (make-constructed-Tvar 'not= Tvar Tvar-zero))))))
+
+       ))))
+
+;; ----------------------------------------------------------------------
+
+(define (init-vectors-w/-length)
+
+  (add-constructor! 'vect #t #f)
+  (add-default-primitives!
+    `(
+       (make-vector    (case->
+                         (forall (n) ((union num n)  -> (vect void n)))
+                         (forall (a n) ((union num n) a -> (vect a n)))
+                         (forall (a n) ((union num n) optional a -> (vect (union a void) n)))))
+       (vector         (forall (a) ((arglistof a) *-> (vect a num))))
+       (vector-length  (forall (a n) ((vect a n) -> n)))
+       (vector-ref     (forall (a) ((vect a _) num -> a)))
+       (vector-set!    (forall (a) ((vect (! a) _) num a -> void)))
+       (vector->list   (forall (a) ((vect a _) -> (listof a))))
+       (list->vector   (forall (a) ((listof a) -> (vect a num))))
+       (vector-fill!   (forall (a) ((vect (! a) _) a -> void)))
+       (vector?        (_ -> bool)         (predicate vect))
+       (build-vector   (forall (a) ((union num n) (num -> a) -> (vect a n))))
+       (tabulate       (forall (a) ((union num n) (num -> a) -> (vect a n))))
+       (foreach!       (forall 
+                         (v a b)
+                         ((union v (vect a _) (vect (! b) _)) (a num -> b)
+                           -> v)))
+       (2vector-print  (forall (a) ((2vec a) ((vect a _) -> void) -> void)))
+        
+       )))
diff --git a/collects/mrspidey/Sba/languages-abstract.ss b/collects/mrspidey/Sba/languages-abstract.ss
new file mode 100644
index 0000000..f856a83
--- /dev/null
+++ b/collects/mrspidey/Sba/languages-abstract.ss
@@ -0,0 +1,15 @@
+;; ======================================================================
+
+(define (init-R4RS!)
+  ;; Also extends it with void
+
+  (apply add-default-constructor! (type: sym) (type: (listof bool)))
+  (add-default-primitive! (type: (list sym sexp))))
+
+;; ======================================================================
+
+(define (init-Chez-on-R4RS!) (void))
+(define (init-Rice-on-Chez!) (void))
+(define (init-MzScheme-on-R4RS!) (void))
+(define (init-DrScheme-on-MzScheme!) (void))
+(define (init-smart-numops!) (void))
diff --git a/collects/mrspidey/Sba/ldexpand.ss b/collects/mrspidey/Sba/ldexpand.ss
new file mode 100644
index 0000000..c7f1b15
--- /dev/null
+++ b/collects/mrspidey/Sba/ldexpand.ss
@@ -0,0 +1,371 @@
+; ldexpand.ss - loads and macro expands source files
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define (open-code-file filename)
+  (let ([filename (normalize-path filename)]
+         [cd (current-directory)])
+    (dynamic-let 
+      ([current-directory (path-only filename)])
+      (unless (file-exists? filename)
+        (mrspidey:error (format "Can't open file ~s, current directory ~s"
+                          filename (current-directory))))
+      (let* ( [p (open-input-file filename 'text)]
+              [p (system-expand-if-necy p)])
+        p))))
+
+(define (zodiac:read* port filename)
+  (let* ( [default-loc (zodiac:make-location 1 1 0 filename)]                      
+            
+         [reader (if (st:fake-reader)
+                     (fake-zodiac-reader port default-loc)
+                     (zodiac:read port default-loc))]
+         [sexps
+          (recur loop ()
+            (let* ([expr (reader)])
+              (if (or (zodiac:eof? expr) (eof-object? expr))
+                  '()
+                  (begin
+                    (when (zodiac:zodiac? expr)
+                      (mrspidey:zprogress "Reading" 
+                                          (zodiac:zodiac-start expr)))
+                    (cons expr (loop))))))])
+    (unless (null? sexps)
+      (mrspidey:zprogress "Reading" (zodiac:zodiac-finish (rac sexps))))
+    (close-input-port port)
+    (when debugging-front
+      (printf "~n--Loaded file---------------------~n")
+      (for-each (lambda (sexp) (pretty-print (zodiac:stripper sexp))) sexps)
+      (printf "----------------------------------~n"))
+    sexps))
+
+(define mrspidey:zprogress
+  (let ( [cur-phase '()]
+         [cur-line -100]
+         [cur-file ""])
+    (lambda (phase loc)
+      (let ( [file (zodiac:location-file loc)]
+             [line (zodiac:location-line loc)])
+        (unless (and 
+                  (equal? file cur-file)
+                  (eq? phase cur-phase)
+                  ;;(>= line cur-line)
+                  (< line (+ cur-line 10)))
+          (set! cur-phase phase)
+          (set! cur-line line)
+          (set! cur-file file)
+          (mrspidey:progress
+            (format "~a ~a: "
+              (padr phase 10)
+              (file-name-from-path file))
+            line))))))
+
+; ----------------------------------------------------------------------
+
+(define fake-zodiac-reader
+  (case-lambda
+   [(p) (fake-zodiac-reader p (zodiac:make-location 1 1 0 "filename"))]
+   [(p loc)
+    (lambda ()
+      (let ([x (read p)])
+        (recur loop ([x x])
+          (match x
+            [(? string?)  (zodiac:make-string loc loc loc x)]
+            [(? boolean?) (zodiac:make-boolean loc loc loc x)]
+            [(? number?)  (zodiac:make-number loc loc loc x)]
+            [(? symbol?)  (zodiac:make-symbol loc loc loc x x x)]
+            [(? char?)    (zodiac:make-char loc loc loc x)]
+            [(? vector?)  (zodiac:make-vector loc loc loc
+                                              (map loop (vector->list x))
+                                              (vector-length x))]
+            [(? list?)    (zodiac:make-list loc loc loc
+                                            (map loop x)
+                                            (length x)
+                                            'marks)]
+            [(? pair?)    (zodiac:make-improper-list 
+                           loc loc loc
+                           (recur loop2 ([x x])
+                             (match x
+                               [(a . d) (cons (loop a) (loop2 d))]
+                               [r (list (loop r))]))
+                           0
+                           'period 'marks)]
+            [_ (if (eof-object? x)
+                   (zodiac:make-eof loc)
+                   (mrspidey:internal-error 
+                    'fake-zodiac-reader
+                    "Bad object ~s" x))]))))]))
+
+; ----------------------------------------------------------------------
+
+(define (expand-zexp->port exp)
+  (let* ( [exp (zodiac:stripper exp)]
+          [s (format "~s" exp)]
+          [p (open-input-string s)]
+          [p (system-expand-if-necy p)])
+    p))
+
+; ----------------------------------------------------------------------
+
+(define (system-expand-if-necy p)
+  (if (st:system-expand)
+      (system-expand-port p)
+      p))
+
+(define system-macros
+  '(;; --- r4rs
+    case cond do recur rec let* letrec let and or define
+    ;; --- Chez things
+         parameterize fluid-let case-lambda let-values #%let-values
+    ;; --- Rice things
+    match match-lambda match-lambda* match-let match-let*
+    ;; --- My things
+    define-module global assert for 
+    ;; --- Misc
+    defmacro
+    ;; Units w/ signatures
+    define-signature 
+    unit-with-signature unit/sig 
+    compound-unit/sig compound-unit-with-signature
+    invoke-unit/sig invoke-unit-with-signature
+    unit->unit/sig
+    ))
+
+
+(define (expander-eval e)
+  (parameterize ([current-namespace expander-namespace])
+                (eval e)))
+(when (st:system-expand)
+  (expander-eval '(load "/home/cormac/Spidey/Code/Sba/expander-boot.ss")))
+(define (my-expand e) (expander-eval `(expand-defmacro ',e)))
+(define (my-expand-once e) (expander-eval `(expand-defmacro-once ',e)))
+
+(define unchanged-list
+  '( define-constructor
+     define-type
+     primitive:
+     type:))
+
+(define system-expanded-exp (void))
+
+(define (system-expand-exp exp)
+  (set! system-expanded-exp exp)
+  (match exp
+    [((? (lambda (x) (memq x unchanged-list))) . _) 
+     exp]
+    [_ (match (my-expand exp)
+         [(and e ((or '#%define-expansion-time '#%define-macro) . _))
+          (expander-eval e)
+          '(void)]
+         [e e])]))
+
+(define (remove-signature-stuff e)
+  (recur loop ([e e])
+    (match e
+      [('#%make-unit-with-signature x _ _) (loop x)]
+      [('#%verify-signed-compound-sub-units . _) '(void)]
+      [('#%verify-linkage-signature-match . _) '(void)]
+      [('#%unit-with-signature-unit x) x]
+      [('#%invoke-open-unit expr name-specifier . imports)
+        `(#%invoke-unit ,(loop expr) ,@imports)]
+      [('#%invoke-open-unit expr)
+        `(#%invoke-unit ,(loop expr))]
+      [(('#%global-defined-value ('#%quote match:error)) . args)
+        '(error 'match "Match error")]
+      [(a . d) (cons (loop a) (loop d))]
+      [x x])))
+
+(define (system-expand-port p)
+  (pretty-debug `(system-expand-port ,p ,(current-directory)))
+  (let* ([o (open-output-string)])
+    (parameterize 
+      ([pretty-print-depth #f])
+      (recur loop ([p p])
+        (let ([e (read p)])
+          (printf ".") (flush-output)
+          (unless (eof-object? e)
+            (recur process ([e e])
+              (match (system-expand-exp e)
+                [('#%begin . e*)
+                  (for-each process e*)]
+                [e
+                  (let* ([e (remove-signature-stuff e)])
+                    (match e
+                      [((or 'load '#%load '#%load/cd 'load/cd) exp)
+                        (let ([filename (normalize-path (expander-eval exp))])
+                          (unless (file-exists? filename)
+                            (mrspidey:error (format "Can't load ~s" filename)))
+                          (dynamic-let 
+                            ([current-directory 
+                               (if (memq (car e) '(load/cd #%load/cd))
+                                 (path-only filename)
+                                 (current-directory))])
+                            (let* ([p (open-input-file filename 'text)])
+                              (printf "[File:~s " (file-name-from-path filename))
+                              (loop p)
+                              (printf "done]")
+                              (close-input-port p))))]
+                      [('load-recent s) 
+                        (process `(load ,(string-append s ".ss")))]
+                      [(or '(void) (? void?)) (void)]
+                      [e (pretty-print (strip-hash-percent e) o)]))]))
+            (loop p)))))
+    (begin0
+      (open-input-string (get-output-string o))
+      (close-output-port o)
+      (close-input-port p))))
+
+(define (strip-hash-percent expr)
+  (recur loop ([expr expr])
+    (match expr
+      [('|#primitive| prim) prim]
+      [(a . d) (cons (loop a) (loop d))]
+      [(? symbol? x)
+       (let* ([s (symbol->string x)]
+              [l (string-length s)])
+         (if (and (> l 2)
+                  (string=? (substring s 0 2) "#%"))
+             (string->symbol (substring s 2 l))
+             x))]
+      [x x])))
+
+; ----------------------------------------------------------------------
+
+(define expand-file
+  (case-lambda
+    [(infile)
+      (let ([infile (normalize-path infile)])
+        (let ([outfile (regexp-replace ".ss$" infile ".expanded")])
+          (when (eq? outfile infile)  
+            (error 'expand-file "Bad suffix on ~s" infile))
+          (expand-file infile outfile)))]
+    [(infile outfile)
+      (when (file-exists? outfile) (delete-file outfile))
+      (dynamic-let ( [st:system-expand #t]
+                     [current-directory (path-only  (normalize-path infile))])
+        (let* ( [p (open-input-file infile 'text)]
+                [p2 (system-expand-if-necy p)]
+                [p3 (open-output-file outfile 'text)])
+          (printf "~nCopying:")
+          (recur loop ()
+            (let ([e (read p2)])
+              (unless (eof-object? e)
+                (pretty-print e p3)
+                (printf ".") (flush-output)
+                (loop))))
+          (newline)
+          (close-input-port p2)
+          (close-output-port p3)
+          outfile))]))
+
+; ----------------------------------------------------------------------
+
+(define file-time-cache '())
+
+(define (clear-file-time-cache!)
+  (set! file-time-cache '()))
+
+(define (extend-file-time-cache! file n)
+  (set! file-time-cache (cons (cons file n) file-time-cache)))
+
+(define (file-time file)
+  (or (lookup-or-#f file-time-cache file)
+      (let* ([n (file-modify-seconds file)])
+        (unless (number? n) 
+          (error 'file-time "file-modify-seconds failed on ~a" file))
+        (extend-file-time-cache! file n)
+        n)))
+
+(define (zodiac-time x)
+  (let* ([start (zodiac:zodiac-start x)]
+         [file (zodiac:location-file start)])
+    (file-time file)))
+
+(define (zodiac-time* x)
+  ;; ## should be either current time, or file time of any imported file
+  ;; is in right directory
+  (let* ([t (zodiac-time x)]
+          [fn (lambda (exp cl-fn)
+                (match exp
+                  [($ zodiac:reference-unit-form _ _ _ _ file cd)
+                    (let*-vals
+                      ( [_ (unless (zodiac:string? file)
+                             (mrspidey:error
+                               (format "reference-unit requires a string argument, given ~s" file)))]
+                        [file (zodiac:read-object file)]
+                        [file (if (relative-path? file)
+                                (build-path cd file)
+                                file)])
+                      (when (file-exists? file)
+                        (pretty-debug `(zodiac:time* includes ,file))
+                        (set! t (max t (file-time file))))
+                      #f)]
+                  [_ #f]))])
+    ((zodiac:compat fn) x)
+    t))
+
+;; ======================================================================
+
+(define attributes #f)
+(define expander-namespace #f)
+
+(define (init-expand!)
+  (set! attributes (zodiac:make-attributes))
+  (set! expander-namespace (make-expander-namespace)))
+
+;; ----------------------------------------------------------------------
+
+(define g:prog #f)
+
+(define (my-scheme-expand-program defs)
+  ;;(printf "my-scheme-expand-program cd=~s~n" (cd))
+  (let* ( [p (make-parameterization)]
+          [_ (with-parameterization p
+               (lambda () 
+                 (current-namespace 
+                   expander-namespace
+                                        ;(make-expander-namespace)
+                   ) 
+                 (reference-library "core.ss")
+                 (reference-library "macro.ss")
+                 '(reference 
+                    (begin-elaboration-time
+                      (build-path
+                        mred:plt-home-directory "mred" "system" "sig.ss")))
+                 '(eval '(unit/sig () (import  mred^) 1))
+                 ;;(printf "np=~s~n" normalize-path)
+                 ))]
+          ;          [defs2 (zodiac:expand-program
+          ;                   defs attributes zodiac:mrspidey-vocabulary p)]
+          [defs2 (call/nal
+                   zodiac:expand-program/nal
+                   zodiac:expand-program
+                   (expressions: defs)
+                   (attributes: attributes)
+                   (vocabulary:  zodiac:mrspidey-vocabulary))]
+                   ; (parameterization: p))]
+          [defs2 (zodiac:inline-begins defs2)]
+          [_ (zodiac:initialize-mutated defs2)]
+          [free (zodiac:free-vars-defs defs2)])
+    (set! g:prog defs2)
+    ;;(pretty-print defs2)
+    '(when debugging
+       (pretty-print (map zodiac:stripper defs2)))
+    (values defs2 free)))
+
+;; ----------------------------------------------------------------------
+
diff --git a/collects/mrspidey/Sba/lib/env.ss b/collects/mrspidey/Sba/lib/env.ss
new file mode 100644
index 0000000..0efd242
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/env.ss
@@ -0,0 +1,69 @@
+;; env.ss
+;; ----------------------------------------------------------------------
+;; Environments
+
+    (define empty-env '())
+
+    (define lookup-or-fail
+      (lambda (env x fail-thunk)
+	(match (assq x env)
+	  [#f (fail-thunk)]
+	  [(_ . b) b])))
+
+    (define lookup-or-#f
+      (lambda (env x)
+	(match (assq x env)
+	  [#f #f]
+	  [(_ . b) b])))
+
+    (define lookup
+      (lambda (env x)
+	(match (assq x env)
+	  [#f (mrspidey:internal-error 'lookup "no binding for ~a" x)]
+	  [(_ . b) b])))
+
+    (define bound-in-env?
+      (lambda (env x)
+	(match (assq x env)
+	  [#f #f]
+	  [_ #t])))
+
+    (define extend-env
+      (lambda (env x v)
+	(cons (cons x v) env)))
+
+    (define extend-env*
+      (lambda (env xs vs)
+	(append (map cons xs vs) env)))
+
+    (define join-env
+      (lambda (env newenv)
+	(append newenv env)))
+
+    (define bang-env!
+      (lambda (env x nu-v)
+        (let ([binding (assq x env)])
+          (if binding
+              (set-cdr! binding nu-v)
+              (mrspidey:internal-error 'lookup "no binding for ~a" x)))))	
+	
+(define (env:change-binding env x f err)
+  (recur loop ([env env])
+    (if (null? env)
+      (err)
+      (if (eq? x (caar env))
+        (cons (cons x (f (cdar env))) (cdr env))
+        (cons (car env) (loop (cdr env)))))))
+
+(define (env:remove env x)
+  (let* ([bind #f]
+         [env
+           (recur loop ([env env])
+             (if (null? env)
+               '()
+               (if (eq? x (caar env))
+                 (begin
+                   (set! bind (cdar env))
+                   (cdr env))
+                 (cons (car env) (loop (cdr env))))))])
+    (values bind env)))
diff --git a/collects/mrspidey/Sba/lib/lib-list.ss b/collects/mrspidey/Sba/lib/lib-list.ss
new file mode 100644
index 0000000..0288803
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/lib-list.ss
@@ -0,0 +1,247 @@
+;; library-list.ss
+;; ----------------------------------------------------------------------
+
+;; map from left to right
+(define mapLR
+  (lambda (f l)
+    (match l
+      [() '()]
+      [(x . y) (let ([v (f x)]) (cons v (mapLR f y)))]
+      [l (error 'mapLR "Bad list ~s" l)])))
+
+;; map from right to left
+(define mapRL
+  (lambda (f l)
+    (match l
+      [() '()]
+      [(x . y) (let ([v (mapRL f y)]) (cons (f x) v))])))
+
+(define foldl-with-n
+  (lambda (f i l)
+    (recur loop ([l l][acc i][n 0])
+      (match l
+        [() acc]
+        [(x . y) (loop y (f x n acc) (add1 n))]))))
+
+;; fold for a 2-argument function
+;; right operand of f is accumulator
+(define foldr2
+  (lambda (f i l1 l2)
+    (recur loop ([l1 l1][l2 l2])
+      (match (list l1 l2)
+        [(() ()) i]
+        [((x1 . y1) (x2 . y2)) (f x1 x2 (loop y1 y2))]))))
+
+;; filter elements out of a list by a predicate
+(define filter
+  (lambda (p l)
+    (match l
+      [() '()]
+      [(x . y) (if (p x) (cons x (filter p y)) (filter p y))])))
+
+;; filter and map left to right
+(define filter-map
+  (lambda (p l)
+    (match l
+      [() '()]
+      [(x . y)
+       (match (p x)
+         [#f (filter-map p y)]
+         [x (cons x (filter-map p y))])])))
+
+;; filter and map left to right, and return (filtered-list . unfiltered)
+
+(define filter-map-split
+  (lambda (p l)
+    (recur loop ([done-filtered '()][done-unfiltered '()][l l])
+      (match l
+        [() (values done-filtered done-unfiltered)]
+        [(x . y)
+         (match (p x)
+           [#f (loop done-filtered (cons x done-unfiltered) y)]
+           [x  (loop (cons x done-filtered) done-unfiltered y)])]))))
+
+;; last element of a list
+(define rac
+  (lambda (l)
+    (match l
+      [(last) last]
+      [(_ . rest) (rac rest)])))
+
+;; all but the last element of a list
+(define rdc
+  (lambda (l)
+    (match l
+      [(_) '()]
+      [(x . rest) (cons x (rdc rest))])))
+
+;; map left to right over a list, but also pass f a 0-based index
+(define map-with-n
+  (lambda (f l)
+    (recur loop ([l l][n 0])
+      (match l
+        [() '()]
+        [(x . y) (let ([v (f x n)]) (cons v (loop y (+ 1 n))))]
+        [l (error 'map-with-n "Bad list ~s" l)]))))
+
+;; for-each, but also pass f a 0-based index
+(define for-each-with-n
+  (lambda (f l)
+    (recur loop ([l l][n 0])
+      (match l
+        [() '()]
+        [(x . y) (f x n) (loop y (+ 1 n))]))))
+
+;; map on a (possibly improper) list
+(define map-ilist
+  (lambda (f l)
+    (recur loop ([l l])
+      (match l
+        [() '()]
+        [(x . y) (cons (f x) (loop y))]
+        [x (f x)]))))
+
+;; length on a (possibly improper) list
+(define length-ilist
+  (match-lambda
+    [(x . y) (add1 (length-ilist y))]
+    [_ 0]))
+
+(define improper?
+  (match-lambda
+    [(x . y) (improper? y)]
+    [() #f]
+    [_ #t]))
+
+(define (flatten-ilist l)
+  (cond [(null? l) '()]
+        [(pair? l) (cons (car l) (flatten-ilist (cdr l)))]
+        [else (list l)]))
+
+;; map a binary function down 2 lists, left to right
+(define map2
+  (lambda (f a b)
+    (match (cons a b)
+      [(() . ())
+       '()]
+      [((ax . ay) . (bx . by))
+       (let ([v (f ax bx)]) (cons v (map2 f ay by)))]
+      [else (error 'map2 "lists differ in length")])))
+
+; map over a list of lists
+
+(define (mapmap f ll) (map (lambda (l) (map f l)) ll))
+
+;; interate a binary function down 2 lists, left to right
+(define for-each2
+  (lambda (f a b)
+    (match (cons a b)
+      [(() . ())
+       (void)]
+      [((ax . ay) . (bx . by))
+       (f ax bx)
+       (for-each2 f ay by)]
+      [else (error 'for-each2 "lists differ in length")])))
+
+;; andmap for 2 lists
+(define andmap2
+  (lambda (f a b)
+    (match (cons a b)
+      [(() . ())
+       #t]
+      [((ax) . (bx))
+       (f ax bx)]
+      [((ax . ay) . (bx . by))
+       (and (f ax bx) (andmap2 f ay by))]
+      [else (error 'andmap2 "lists differ in length")])))
+
+;; andmap for 2 lists, fail on inequal lengths
+(define andmap2len
+  (lambda (f a b)
+    (match (cons a b)
+      [(() . ()) 
+       #t]
+      [((ax) . (bx))
+       (f ax bx)]
+      [((ax . ay) . (bx . by))
+       (and (f ax bx) (andmap2len f ay by))]
+      [else #f])))
+;(define andmap andmap2)
+
+;; ormap for 2 lists
+(define ormap2
+  (lambda (f a b)
+    (match (cons a b)
+      [(() . ())
+       #f]
+      [((ax) . (bx))
+       (f ax bx)]
+      [((ax . ay) . (bx . by))
+       (or (f ax bx) (ormap2 f ay by))]
+      [else (error 'ormap2 "lists differ in length")])))
+
+;; make a list containing n copies of e
+(define list-n-copies
+  (lambda (n e)
+    (if (zero? n)
+	'()
+	(cons e (list-n-copies (sub1 n) e)))))
+
+(define (count p l)
+  (recur loop ([c 0][l l])
+    (cond
+     [(null? l) c]
+     [(p (car l)) (loop (add1 c) (cdr l))]
+     [else (loop c (cdr l))])))
+
+(define (index l x)
+  (recur loop ([l l][i 0])
+    (cond
+     [(null? l) #f]
+     [(eq? x (car l)) i]
+     [else (loop (cdr l) (add1 i))])))
+
+(define (get-prefix l1 l2)
+    (if (eq? l1 l2)
+        '()
+        (cons (car l1) (get-prefix (cdr l1) l2))))
+
+(define (mklist n)
+  (if (zero? n)
+      '()
+      (cons n (mklist (sub1 n)))))
+
+(define (nth l n)
+  (if (zero? n)
+      (car l)
+      (nth (cdr l) (sub1 n))))
+
+
+; Takes an atom and a list and returns the position of the atom in the list
+(define list-pos
+  (lambda (a l)
+    (recur loop ([l l][i 0])
+      (cond                               
+       [(null? l) #f]
+       [(eqv? a (car l)) i]
+       [else (loop (cdr l) (add1 i))]))))
+
+; Takes an atom and a list and returns the position of the atom in the list
+; uses equal?, returns #f if no match
+(define list-pos-equal
+  (lambda (a l)
+    (recur loop ([l l][n 0])
+      (cond
+       [(null? l) #f]
+       [(equal? a (car l)) n]
+       [else (loop (cdr l) (add1 n))]))))
+
+;; Returns first element in set satisfying a predicate, or #f
+(define (find p l)
+  (recur loop ([l l])
+    (cond
+     [(null? l) #f]
+     [(p (car l)) (car l)]
+     [else (loop (cdr l))])))
+
+
diff --git a/collects/mrspidey/Sba/lib/lib-misc.ss b/collects/mrspidey/Sba/lib/lib-misc.ss
new file mode 100644
index 0000000..737ede6
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/lib-misc.ss
@@ -0,0 +1,150 @@
+; library-misc.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+ (define symbol-append
+   (lambda l
+     (string->symbol
+      (apply string-append (map (lambda (x) (#%format "~a" x)) l)))))
+
+ (define (get-cpu-time str thunk)
+   (match-let
+       ([(t . r) (get&return-cpu-time thunk)])
+     (printf "~a ~ss~n" str (/ t 1000.0))
+     r))
+
+ (define (get&return-cpu-time thunk)
+   (let* ([s1 (- (current-process-milliseconds) (current-gc-milliseconds))]
+          [r  (thunk)]
+          [s2 (- (current-process-milliseconds) (current-gc-milliseconds))]
+          [t (- s2 s1)])
+     (cons t r)))
+
+ (define (make-timer) (cons 0 0))
+ (define (clear-timer! c) (set-car! c 0) (set-cdr! c 0))
+
+ (define (record-time timer thunk)
+   (match-let
+       ([(t . r) (get&return-cpu-time (lambda () (call-with-values thunk list)))])
+     (set-car! timer (add1 (car timer)))
+     (set-cdr! timer (+ t (cdr timer)))
+     (apply #%values r)))
+
+ (define (strip-string s c)
+   ;; Strips leading chars off s, up to and including c
+   (recur loop ([s (string->list s)])
+     (cond
+      [(null? s) ""]
+      [(char=? (car s) c) (list->string (cdr s))]
+      [else (loop (cdr s))])))
+
+ ;; pad on left
+ (define padl
+   (lambda (arg n)
+     (let ((s (format "~a" arg)))
+       (recur loop ((s s))
+         (if (< (string-length s) n)
+             (loop (string-append " " s))
+             s)))))
+
+ ;; pad on right
+ (define padr
+   (lambda (arg n)
+     (let ((s (format "~a" arg)))
+       (recur loop ((s s))
+         (if (< (string-length s) n)
+             (loop (string-append s " "))
+             s)))))
+
+ (define chop-number
+   (lambda (x n)
+     (substring (format "~s00000000000000000000" x) 0 (- n 1))))
+
+ ;; Is the first string a substring of the second string?
+ ;; 
+ (define substring?
+   (lambda (s1 s2)
+     (let ([l1 (string-length s1)][l2 (string-length s2)])
+       (let loop ([i 0])
+         (cond
+          [(>= (+ i l1) l2)  #f]
+          [(string=? (substring s2 i (+ i l1)) s1) #t]
+          [else (loop (add1 i))])))))
+
+                                        ; Returns the part of the string after the last slash
+                                        ;
+ (define get-base-name
+   (lambda (filename)
+     (let ([len (string-length filename)])
+       (let loop ([i 0][fname-start 0])
+         (cond
+          [(= i len) (substring filename fname-start len)]
+          [(char=? (string-ref filename i) #\/)
+           (loop (add1 i) (add1 i))]
+          [else (loop (add1 i) fname-start)])))))
+
+                                        ; removes an object fro a list destructively using eqv?
+                                        ;
+(define remv!
+  (lambda (obj l)
+    (let ([head l])
+      (if (eqv? obj (car l))
+        (if (pair? l)
+          (cdr l)
+          '())
+        (let loop ([l l])
+          (cond
+            [(null? l) head]
+            [(null? (cdr l)) head]
+            [(eqv? obj (cadr l))
+              (if (pair? (cdr l))
+                (set-cdr! l (cddr l))
+                (set-cdr! l '()))
+              head]
+            [ else (loop (cdr l))]))))))
+
+                                        ; takes a string, a position (i) and a char and resturns a substring of the characters
+                                        ; from the position to the char
+                                        ;
+(define (char-find str i  char)
+  (apply string 
+         (let loop ([i i])
+           (if (< i (string-length str))
+               (let ([c (string-ref str i)]) 
+                 (if (char=?  c char)
+                     '()
+                     (cons c (loop (add1 i)))))
+               '()))))
+ ;;
+
+(define (file-newer f1 f2)
+  (let ([s1 (file-modify-seconds f1)]
+        [s2 (file-modify-seconds f2)])
+    (and (number? s1) 
+         (number? s2)
+         (> s1 s2))))
+    
+
+;; curried eq?
+
+(define eqc?
+  (lambda (x)
+    (lambda (y)
+      (eq? x y))))
+
+;; ----------------------------------------------------------------------
+
diff --git a/collects/mrspidey/Sba/lib/lib-para.ss b/collects/mrspidey/Sba/lib/lib-para.ss
new file mode 100644
index 0000000..9a180f8
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/lib-para.ss
@@ -0,0 +1,71 @@
+;; library-paras.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+(define make-parameter-list
+  (case-lambda
+   [(default list-opt)
+    (make-parameter-list default list-opt 
+                         (lambda (x) (void))
+                         (lambda (x) #f))]
+   [(default list-opt call)
+    (make-parameter-list default list-opt call
+                         (lambda (x) #f))]
+   [(default list-opt call also-ok?)
+    (let* ([list-opt
+            (map
+             (match-lambda
+              [(tag (? string? name) (? string? help)) (list tag name help)]
+              [(tag (? string? name)) (list tag name "")]
+              [(or (tag) (tag "") tag) (list tag (format "~a" tag) "")])
+             list-opt)]
+           [list-tag (map car list-opt)])
+                                        ;(assert (memq default list-tag))
+      (let ([current default])
+        (call current)
+        (match-lambda*
+         [() current]
+         [('?) list-opt]
+         [(x)
+          (unless (or (member x list-tag) (also-ok? x))
+            (error 
+              'parameter
+              "Parameter argument ~s is not one of ~s" x list-tag))
+          (set! current x)
+          (call current)])))]))
+
+(define (make-parameter-boolean x)
+  (make-parameter-list x 
+    (list
+      (list #f "Off" "")
+      (list #t "On" ""))))
+
+'(define (make-parameter-integer x)
+  (make-parameter x
+                  (lambda (x)
+                    (unless (integer? x)
+                      (error 'parameter "Must be an integer"))
+                    x)))
+
+(define (make-parameter-integer x)
+  (unless (integer? x) (error 'parameter "Must be an integer"))
+  (case-lambda
+    [() x]
+    [(y)
+      (unless (integer? y) (error 'parameter "Must be an integer"))
+      (set! x y)]))
diff --git a/collects/mrspidey/Sba/lib/lib-set.ss b/collects/mrspidey/Sba/lib/lib-set.ss
new file mode 100644
index 0000000..f2ba51b
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/lib-set.ss
@@ -0,0 +1,111 @@
+;; library-set.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;;
+;; Set operations implemented by lists.
+;; Identity of elements is based on eq?.
+;; These should probably be sped up some day.
+;; ----------------------------------------------------------------------
+
+ (define empty-set '())
+
+ (define empty-set? null?)
+
+ ;; construct a set
+ (define set
+   (lambda l
+     (list->set l)))
+
+ ;; construct a set from a list by removing duplicates
+ (define list->set
+   (match-lambda
+    [() '()]
+    [(x . y) (if (memq x y)
+                 (list->set y)
+                 (cons x (list->set y)))]))
+
+ (define list->set-equal?
+   (match-lambda
+    [() '()]
+    [(x . y) (if (member x y)
+                 (list->set y)
+                 (cons x (list->set y)))]))
+
+ ;; test for membership
+ (define element-of?
+   (lambda (x set)
+     (and (memq x set) #t)))
+
+ (define (set-add x set)
+   (if (memq x set) set (cons x set)))
+
+ (define cardinality length)
+
+ ;; does s2 contain s1?
+ (define set<=
+   (lambda (a b)
+     (and (andmap (lambda (x) (memq x b)) a) #t)))
+
+ ;; are two sets equal? (mutually containing)
+ (define set-eq?
+   (lambda (a b)
+     (and (= (cardinality a) (cardinality b)) (set<= a b))))
+
+ ;; unite two sets
+ (define union2
+   (lambda (a b)
+     (if (null? b)
+         a
+         (foldr (lambda (x b)
+                  (if (memq x b)
+                      b
+                      (cons x b)))
+                b
+                a))))
+
+ ;; unite any number of sets
+ (define union
+   (lambda l
+     (foldr union2 '() l)))
+
+ (define setdiff2
+   (lambda (a b)
+     (if (or (null? a) (null? b))
+         a
+       (if (memq (car a) b)
+         (setdiff2 (cdr a) b)
+         (cons (car a) (setdiff2 (cdr a) b))))))
+
+ (define setdiff
+   (lambda l
+     (if (null? l)
+         '()
+         (setdiff2 (car l) (foldr union2 '() (cdr l))))))
+
+ (define intersect2
+   (lambda (a b)
+     (cond [(or (null? a) (null? b)) '()]
+           [(memq (car b) a) (cons (car b) (intersect2 a (cdr b)))]
+           [else (intersect2 a (cdr b))])))
+
+ (define intersect
+   (lambda l
+     (if (null? l)
+         '()
+         (foldl intersect2 (car l) l))))
+
+
diff --git a/collects/mrspidey/Sba/lib/lib-vec.ss b/collects/mrspidey/Sba/lib/lib-vec.ss
new file mode 100644
index 0000000..4fb6232
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/lib-vec.ss
@@ -0,0 +1,106 @@
+;; library-vec.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+(define (vector-copy v)
+  (let* ( [l (vector-length v)]
+          [w (make-vector l)])
+    (for i 0 l (vector-set! w i (vector-ref v i)))
+  w))
+
+;; vector map
+(define vector-map1
+  (lambda (f v)
+    (let* ([l (vector-length v)]
+           [w (make-vector l)])
+      (for i 0 l
+           (vector-set! w i (f (vector-ref v i))))
+      w)))
+
+(define vector-map2
+  (lambda (f v1 v2)
+    (let* ([l (vector-length v1)]
+           [w (make-vector l)])
+      (assert (= l (vector-length v2)))
+      (for i 0 l
+           (vector-set! w i (f (vector-ref v1 i) (vector-ref v2 i))))
+      w)))
+
+(define vector-map
+  (case-lambda
+   [(f v) (vector-map1 f v)]
+   [(f v1 v2) (vector-map2 f v1 v2)]))
+
+;; for-each over a vector, but also pass f a 0-based index
+(define vector-for-each-with-n
+  (lambda (f v)
+    (for i 0 (vector-length v)
+         (f (vector-ref v i) i))))
+
+(define vector-for-each
+  (case-lambda
+    [(f v)
+      (for i 0 (vector-length v)
+        (f (vector-ref v i)))]
+    [(f v1 v2)
+      (assert (= (vector-length v1) (vector-length v2)) 'vector-for-each)
+      (for i 0 (vector-length v1)
+        (f (vector-ref v1 i) (vector-ref v2 i)))]))
+
+(define (vector-andmap1 f v)
+  (let ([l (vector-length v)])
+    (recur loop ([i 0])
+      (or (= i l)
+          (and (f (vector-ref v i)) (loop (add1 i)))))))
+
+(define (vector-andmap2 f v1 v2)
+  (let ([l (vector-length v1)])
+    (assert (= l (vector-length v2)))
+    (recur loop ([i 0])
+      (or (= i l)
+          (and (f (vector-ref v1 i) (vector-ref v2 i))
+               (loop (add1 i)))))))
+
+(define vector-andmap
+  (match-lambda*
+   [(f v) (vector-andmap1 f v)]
+   [(f v1 v2) (vector-andmap2 f v1 v2)]))
+
+
+(define (vector-ormap1 f v)
+  (let ([l (vector-length v)])
+    (recur loop ([i 0])
+      (and (not (= i l))
+           (or (f (vector-ref v i)) (loop (add1 i)))))))
+
+(define (vector-ormap2 f v1 v2)
+  (let ([l (vector-length v1)])
+    (assert (= l (vector-length v2)))
+    (recur loop ([i 0])
+      (and (not (= i l))
+           (or (f (vector-ref v1 i) (vector-ref v2 i))
+               (loop (add1 i)))))))
+
+(define vector-ormap
+  (match-lambda*
+   [(f v) (vector-ormap1 f v)]
+   [(f v1 v2) (vector-ormap2 f v1 v2)]))
+
+
+(define (vector-zero! p)
+  (for i 0 (vector-length p) (vector-set! p i 'zerod!)))
diff --git a/collects/mrspidey/Sba/lib/main.ss b/collects/mrspidey/Sba/lib/main.ss
new file mode 100644
index 0000000..d88b96a
--- /dev/null
+++ b/collects/mrspidey/Sba/lib/main.ss
@@ -0,0 +1,29 @@
+;; Sba/lib/main.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; elaboration-time context:
+;; mrspidey signatures
+
+(unit/sig mrspidey:library^
+  (import mrspidey:interaction^ mzlib:unprefixed-core^)
+  (include "lib-para.ss")
+  (include "lib-list.ss")
+  (include "lib-vec.ss")
+  (include "lib-set.ss")
+  (include "lib-misc.ss")
+  (include "env.ss"))
diff --git a/collects/mrspidey/Sba/link.ss b/collects/mrspidey/Sba/link.ss
new file mode 100644
index 0000000..b256129
--- /dev/null
+++ b/collects/mrspidey/Sba/link.ss
@@ -0,0 +1,132 @@
+;; link.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define mrspidey:sba@
+  (compound-unit/sig
+    (import
+      (INTERACTION : mrspidey:interaction^)
+      (MZLIB : mzlib:unprefixed-core^)
+      (WX : wx^)
+      )
+    (link
+      [CDL :
+        mrspidey:CDL^ 
+        (mrspidey:CDL@ INTERACTION MZLIB WX)]
+      [ZODIAC :
+        mrspidey:zodiac^
+        (mrspidey:zodiac@ CDL INTERACTION)]        
+      [LOADEXPAND :
+        mrspidey:loadexpand^
+        (mrspidey:loadexpand@ CDL INTERACTION LANGUAGES ZODIAC MZLIB)]
+      [HASH : 
+        mrspidey:hash^
+        (mrspidey:hash@ CDL INTERACTION MZLIB)]
+      [KERNEL :
+        mrspidey:kernel^ 
+        (mrspidey:kernel@ CDL HASH KERNEL-AUX TEMPLATES)]
+      [MIN :
+        mrspidey:min^
+        (mrspidey:all-min@ CDL INTERACTION KERNEL KERNEL-AUX 
+          TEMPLATES MZLIB)]
+      [TEMPLATES :
+        mrspidey:templates^
+        (mrspidey:templates@ CDL INTERACTION KERNEL)]
+      [KERNEL-AUX :
+        mrspidey:kernel-aux^
+        (mrspidey:kernel-aux@ CDL INTERACTION KERNEL TEMPLATES ZODIAC)]
+      [ATYPE :
+        mrspidey:atype^
+        (mrspidey:atype@ CDL INTERACTION KERNEL KERNEL-AUX
+          MIN TYPELANG TEMPLATES
+          TYPE-ENV SDL ATLUNIT MZLIB)]
+      [TYPELANG :
+        mrspidey:typelang^
+        (mrspidey:typelang@ CDL INTERACTION KERNEL KERNEL-AUX
+          TEMPLATES TYPE-ENV ATYPE CONTAINED MZLIB ZODIAC)]
+      [CONTAINED :
+        mrspidey:contained^
+        (mrspidey:contained@ CDL KERNEL SDL)]
+      [TYPE-ENV :
+        mrspidey:type-env^
+        (mrspidey:type-env@ CDL INTERACTION KERNEL KERNEL-AUX
+          TEMPLATES MIN ATYPE ZODIAC)]
+      [SDL :
+        mrspidey:sdl^ 
+        (mrspidey:sdl@ 
+          CDL KERNEL MIN TYPELANG KERNEL-AUX TEMPLATES ATYPE
+          MZLIB)]
+      [LANGUAGES :
+        mrspidey:languages^
+        (mrspidey:languages@ CDL INTERACTION KERNEL
+          TEMPLATES KERNEL-AUX 
+          ATYPE TYPE-ENV TYPELANG ATENV LOADEXPAND TRAVERSE
+          MZLIB ZODIAC )]
+      [ATENV :
+        mrspidey:atenv^
+        (mrspidey:atenv@ CDL INTERACTION KERNEL KERNEL-AUX ATYPE
+          ZODIAC MZLIB)]
+      [TRAVERSE :
+        mrspidey:traverse^
+        (mrspidey:traverse@ CDL INTERACTION KERNEL MIN
+          LOADEXPAND
+          TEMPLATES KERNEL-AUX TYPELANG TYPE-ENV
+          LANGUAGES ATYPE ATLUNIT ATENV
+          ZODIAC MZLIB)]
+      [ATLUNIT :
+        mrspidey:atlunit^
+        (mrspidey:atlunit@ CDL INTERACTION KERNEL KERNEL-AUX
+          MIN LOADEXPAND TYPE-ENV
+          TEMPLATES LANGUAGES ATYPE ATENV TRAVERSE
+          ZA ZODIAC MZLIB WX)]
+      [ZA :
+        mrspidey:za^ 
+        (mrspidey:za@ CDL INTERACTION KERNEL TEMPLATES 
+          TYPE-ENV TYPELANG ATYPE MZLIB)]
+      [PROGRAM :
+        mrspidey:program^
+        (mrspidey:program@ CDL INTERACTION 
+          KERNEL KERNEL-AUX TYPE-ENV
+          LOADEXPAND TRAVERSE
+          TEMPLATES ATENV ATYPE LANGUAGES
+          ZODIAC MZLIB)]
+      [CHECKS :
+        mrspidey:calc-checks^
+        (mrspidey:calc-checks@ CDL INTERACTION LOADEXPAND 
+          KERNEL KERNEL-AUX
+          TYPELANG TEMPLATES ATYPE SDL
+          ZODIAC MZLIB)]
+      [DRIVER :
+        mrspidey:driver^
+        (mrspidey:driver@ CDL INTERACTION KERNEL
+          TEMPLATES TYPELANG TYPE-ENV ATYPE ATENV
+          PROGRAM CHECKS LANGUAGES ZODIAC)]
+      [HYPER :
+        mrspidey:hyper^
+        (mrspidey:hyper@ CDL INTERACTION LOADEXPAND
+          PROGRAM CHECKS TEMPLATES KERNEL KERNEL-AUX ATYPE MZLIB)]
+      )
+    (export 
+      (open DRIVER)
+      (open CDL)
+      (open ATYPE)
+      (open HYPER)
+      (open KERNEL)
+      (open CHECKS)
+      (open LANGUAGES)
+      (unit ZODIAC zodiac))))
+
diff --git a/collects/mrspidey/Sba/load.ss b/collects/mrspidey/Sba/load.ss
new file mode 100644
index 0000000..97fa025
--- /dev/null
+++ b/collects/mrspidey/Sba/load.ss
@@ -0,0 +1,92 @@
+;; Sba/load.ss
+;; Loads analysis, assumes zodiac, ../aux.ss, ../macros.ss already loaded
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(load-relative "sigs.ss")
+
+;; ----------------------------------------------------------------------
+;; Library stuff
+
+(load-relative (build-path "lib" "lib-para.ss"))
+(load-relative (build-path "lib" "lib-list.ss"))
+(load-relative (build-path "lib" "lib-vec.ss"))
+(load-relative (build-path "lib" "lib-set.ss"))
+(load-relative (build-path "lib" "lib-misc.ss"))
+(load-relative (build-path "lib" "env.ss"))
+(load-relative "config.ss")
+(load-relative "debug.ss")
+
+;; ----------------------------------------------------------------------
+;; Extended Zodiac
+
+(load-relative "zod-extra.ss")
+(invoke-open-unit/sig
+ mrspidey:zodiac@ 
+ zodiac
+ mrspidey:CDL^ mrspidey:interaction^)
+
+;; ---------------------------------------------------------------------
+;; Front End Stuff
+
+(load-relative "ldexpand.ss")
+
+;; ======================================================================
+;; Kernel stuff
+
+(load-relative "hash.ss")
+(load-relative "kernel.ss")
+(load-relative (build-path "min" "min.ss"))
+(load-relative (build-path "min" "nonempty.ss"))
+(load-relative (build-path "min" "min-live.ss"))
+(load-relative (build-path "min" "livefewe.ss"))
+(load-relative (build-path "min" "hopcroft.ss"))
+(load-relative (build-path "min" "min-dfa.ss"))
+
+;; ----------------------------------------------------------------------
+;; top level stuff
+
+(load-relative "template.ss")
+(load-relative "kern-aux.ss")
+(load-relative "typelang.ss")
+(load-relative "contain.ss")
+(load-relative "type-env.ss")
+(load-relative "sdl.ss")
+(load-relative "language.ss")
+
+;; ----------------------------------------------------------------------
+;; Traversal
+
+(load-relative "atype.ss")
+(load-relative "atenv.ss")
+(load-relative "atlunit.ss")
+(load-relative "traverse.ss")
+
+;; ----------------------------------------------------------------------
+
+(load-relative "za.ss")
+(load-relative "program.ss")
+(load-relative "checks.ss")
+(load-relative "driver.ss")
+(load-relative "results.ss")
+
+;; ----------------------------------------------------------------------
+
+(define (t) (st: "../test/t.ss"))
+;(load "test-sba.ss")
+;(load "devel.ss")
+;(load "poly.ss")
diff --git a/collects/mrspidey/Sba/loadu.ss b/collects/mrspidey/Sba/loadu.ss
new file mode 100644
index 0000000..b049c39
--- /dev/null
+++ b/collects/mrspidey/Sba/loadu.ss
@@ -0,0 +1,489 @@
+;; sba-unit.ss
+;; Defines all the units in SBA
+;; ----------------------------------------------------------------------
+;; elaboration-time context:
+;; sparams.ss Spidey/Code/macros.ss 
+
+(load-relative "sigs.ss")
+
+;; ----------------------------------------------------------------------
+;; Library
+
+(define mrspidey:library@ 
+  (reference (build-path "lib" "main.ss")))
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey:config@
+  (unit/sig mrspidey:config^
+    (import mrspidey:library^ mzlib:unprefixed-core^ [wx : wx^])
+    (include "config.ss")))
+
+(define mrspidey:debugging@
+  (unit/sig mrspidey:debugging^
+    (import
+      mrspidey:library^
+      mzlib:unprefixed-core^)
+    (include "debug.ss")))
+
+(define mrspidey:CDL@
+  (compound-unit/sig
+    (import 
+      (I : mrspidey:interaction^)
+      (MZLIB : mzlib:unprefixed-core^)
+      (WX : wx^))
+    (link
+      [L :
+        mrspidey:library^
+        (mrspidey:library@ I MZLIB)]
+      [C :
+        mrspidey:config^
+        (mrspidey:config@ L MZLIB WX)]
+      [D : 
+        mrspidey:debugging^
+        (mrspidey:debugging@ L MZLIB)])
+    (export (open C) (open D) (open L))))
+
+;; ---------------------------------------------------------------------
+;; Front End Stuff
+
+(define mrspidey:loadexpand@
+  (unit/sig mrspidey:loadexpand^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:languages^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^)
+    (include "ldexpand.ss")))
+
+;; ======================================================================
+;; Kernel stuff
+
+(define mrspidey:hash@
+  (unit/sig mrspidey:hash^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mzlib:unprefixed-core^)
+    (include "hash.ss")))
+
+(define mrspidey:kernel@
+  (unit/sig mrspidey:kernel^
+    (import
+      mrspidey:CDL^
+      mrspidey:hash^
+      mrspidey:kernel-aux^
+      mrspidey:templates^)
+    (include "kernel.ss")))
+
+;; ----------------------------------------------------------------------
+;; Minimization
+
+(define mrspidey:min-live@
+  (unit/sig
+    mrspidey:min-live^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min^
+      mrspidey:templates^)
+    (include (begin-elaboration-time (build-path "min" "min-live.ss")))))
+
+(define mrspidey:find-nonempty-tvars@
+  (unit/sig
+    mrspidey:find-nonempty-tvars^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min-live^
+      mrspidey:templates^)
+    (include (begin-elaboration-time (build-path "min" "nonempty.ss")))))
+
+(define mrspidey:min-live-few-e@
+  (unit/sig
+    mrspidey:min-live-few-e^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min^
+      mrspidey:min-live^)
+    (include (begin-elaboration-time (build-path "min" "livefewe.ss")))))
+
+(define mrspidey:hopcroft@
+  (unit/sig
+    mrspidey:hopcroft^
+    (import
+      mrspidey:CDL^
+      mzlib:unprefixed-core^
+      mrspidey:min^)
+    (include (begin-elaboration-time (build-path "min" "hopcroft.ss")))))
+
+'(define-signature mrspidey:min-dfa^ (minimize-constraints-dfa-min))
+'(mrspidey:load-unit "min/" min-dfa-old ( mrspidey:CDL^
+                                          mrspidey:kernel^
+                                          mrspidey:kernel-aux^
+                                          mrspidey:min^
+                                          mrspidey:find-nonempty-tvars^
+                                          mrspidey:min-live^
+                                          mrspidey:hopcroft^))
+
+'(define-signature mrspidey:min-dfa-inv^ (minimize-constraints-dfa-min-inv))
+'(mrspidey:load-unit "min/" min-dfa-inv ( mrspidey:CDL^
+                                         mrspidey:kernel^
+                                         mrspidey:kernel-aux^
+                                         mrspidey:min^
+                                         mrspidey:min-live^
+                                         mrspidey:hopcroft^))
+
+'(define-signature mrspidey:min-dfa-strange ( minimize-constraints-dfa-min-1 
+                                             minimize-constraints-dfa-min-2))
+'(mrspidey:load-unit "min/" min-dfa-strange ( mrspidey:CDL^
+                                             mrspidey:kernel^
+                                             mrspidey:kernel-aux^
+                                             mrspidey:min-live^
+                                             mrspidey:hopcroft^))
+
+(define mrspidey:min-dfa-fast@
+  (unit/sig
+    mrspidey:min-dfa-fast^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min^
+      mrspidey:min-live^
+      mrspidey:min-live-few-e^
+      mrspidey:hopcroft^)
+    (include (begin-elaboration-time (build-path "min" "min-dfa.ss")))))
+
+(define mrspidey:min@
+  (unit/sig
+    mrspidey:min^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:find-nonempty-tvars^
+      mrspidey:min-live^
+      mrspidey:min-live-few-e^
+                                        ;mrspidey:min-dfa^
+                                        ;mrspidey:min-dfa-inv^
+                                        ;mrspidey:min-dfa-strange^
+      mrspidey:min-dfa-fast^
+      )
+    (include (begin-elaboration-time (build-path "min" "min.ss")))
+    (define minimize-constraints-dfa-min 1)
+    (define minimize-constraints-dfa-min-inv 1)
+    (define minimize-constraints-dfa-min-1 1)
+    (define minimize-constraints-dfa-min-2 1)
+    (define min-table 1)
+    ))
+
+(define mrspidey:all-min@
+  (compound-unit/sig
+    (import
+      (CDL : mrspidey:CDL^)
+      (INTERACTION : mrspidey:interaction^)
+      (KERNEL : mrspidey:kernel^)
+      (KERNEL-AUX : mrspidey:kernel-aux^)
+      (TEMPLATES : mrspidey:templates^)
+      (MZLIB : mzlib:unprefixed-core^)
+      )
+    (link
+      [MIN : mrspidey:min^ 
+        (mrspidey:min@ CDL INTERACTION KERNEL 
+          FIND LIVE FEW FAST)]
+      [FIND : mrspidey:find-nonempty-tvars^
+        (mrspidey:find-nonempty-tvars@ CDL KERNEL KERNEL-AUX LIVE TEMPLATES)]
+      [LIVE : mrspidey:min-live^
+        (mrspidey:min-live@ CDL KERNEL KERNEL-AUX MIN TEMPLATES)]
+      [FEW : mrspidey:min-live-few-e^
+        (mrspidey:min-live-few-e@ CDL KERNEL KERNEL-AUX MIN LIVE)]
+      [HOPCROFT : mrspidey:hopcroft^
+        (mrspidey:hopcroft@ CDL MZLIB MIN)]
+      ;;[DFA : mrspidey:min-dfa^
+      ;;  (mrspidey:min-dfa@ CDL KERNEL KERNEL-AUX LIVE HOPCROFT)]
+      ;;[INV : mrspidey:min-dfa-inv^
+      ;;  (mrspidey:min-dfa-inv@ CDL KERNEL KERNEL-AUX LIVE HOPCROFT)]
+      ;;[STRANGE : mrspidey:min-dfa-strange^
+      ;;  (mrspidey:min-dfa-strange^@ CDL KERNEL KERNEL-AUX LIVE HOPCROFT)]
+      [FAST : mrspidey:min-dfa-fast^
+        (mrspidey:min-dfa-fast@ CDL KERNEL KERNEL-AUX MIN LIVE FEW HOPCROFT)])
+    (export (open MIN))))
+
+;; ----------------------------------------------------------------------
+;; top level stuff
+
+(define mrspidey:templates@
+  (unit/sig
+    mrspidey:templates^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^)
+    (include "template.ss")))
+
+(define mrspidey:kernel-aux@
+  (unit/sig
+    mrspidey:kernel-aux^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:templates^
+      (zodiac : mrspidey:zodiac^))
+    (include "kern-aux.ss")))
+
+(define mrspidey:typelang@
+  (unit/sig
+    mrspidey:typelang^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:templates^
+      mrspidey:type-env^
+      mrspidey:atype^
+      mrspidey:contained^
+      mzlib:unprefixed-core^
+      (zodiac : mrspidey:zodiac^))
+    (include "typelang.ss")))
+
+(define mrspidey:contained@
+  (unit/sig
+    mrspidey:contained^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:sdl^)
+    (include "contain.ss")))
+
+(define mrspidey:type-env@
+  (unit/sig
+    mrspidey:type-env^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:templates^
+      mrspidey:min^
+      mrspidey:atype^
+      (zodiac : mrspidey:zodiac^))
+    (include "type-env.ss")))
+
+(define mrspidey:sdl@
+  (unit/sig
+    mrspidey:sdl^
+    (import
+      mrspidey:CDL^
+      mrspidey:kernel^
+      mrspidey:min^
+      mrspidey:typelang^
+      mrspidey:kernel-aux^
+      mrspidey:templates^
+      mrspidey:atype^
+      mzlib:unprefixed-core^)
+    (include "sdl.ss")))
+
+(define mrspidey:languages@
+  (unit/sig
+    mrspidey:languages^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:templates^
+      mrspidey:kernel-aux^
+      mrspidey:atype^
+      mrspidey:type-env^
+      mrspidey:typelang^
+      mrspidey:atenv^
+      mrspidey:loadexpand^
+      mrspidey:traverse^
+      mzlib:unprefixed-core^
+      (zodiac : mrspidey:zodiac^))
+    (include "language.ss")))
+
+(define mrspidey:za@
+  (unit/sig
+    mrspidey:za^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:templates^
+      mrspidey:type-env^
+      mrspidey:typelang^
+      mrspidey:atype^
+      mzlib:unprefixed-core^)
+    (include "za.ss")))
+
+;; ----------------------------------------------------------------------
+;; Traversal
+
+(define mrspidey:atype@
+  (unit/sig
+    mrspidey:atype^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min^
+      mrspidey:typelang^
+      mrspidey:templates^
+      mrspidey:type-env^
+      mrspidey:sdl^
+      mrspidey:atlunit^
+      mzlib:unprefixed-core^)
+    (include "atype.ss")))
+
+(define mrspidey:atenv@
+  (unit/sig
+    mrspidey:atenv^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:atype^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^)
+    (include "atenv.ss")))
+
+(define mrspidey:atlunit@
+  (unit/sig
+    mrspidey:atlunit^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:min^
+      mrspidey:loadexpand^
+      mrspidey:type-env^
+      mrspidey:templates^
+      mrspidey:languages^
+      mrspidey:atype^
+      mrspidey:atenv^
+      mrspidey:traverse^
+      mrspidey:za^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^
+      [wx : wx^])
+    (include "atlunit.ss")))
+
+(define mrspidey:traverse@
+  (unit/sig
+    mrspidey:traverse^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:min^
+      mrspidey:loadexpand^
+      mrspidey:templates^
+      mrspidey:kernel-aux^
+      mrspidey:typelang^
+      mrspidey:type-env^
+      mrspidey:languages^
+      mrspidey:atype^
+      mrspidey:atlunit^
+      mrspidey:atenv^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^)
+    (include "traverse.ss")))
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey:program@
+  (unit/sig
+    mrspidey:program^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:type-env^
+      mrspidey:loadexpand^
+      mrspidey:traverse^
+      mrspidey:templates^
+      mrspidey:atenv^
+      mrspidey:atype^
+      mrspidey:languages^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^)
+    (include "program.ss")))
+
+(define mrspidey:calc-checks@
+  (unit/sig
+    mrspidey:calc-checks^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:loadexpand^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:typelang^
+      mrspidey:templates^
+      mrspidey:atype^
+      mrspidey:sdl^
+      (zodiac : mrspidey:zodiac^)
+      mzlib:unprefixed-core^)
+    (include "checks.ss")))
+
+(define mrspidey:driver@
+  (unit/sig
+    mrspidey:driver^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:kernel^
+      mrspidey:templates^
+      mrspidey:typelang^
+      mrspidey:type-env^
+      mrspidey:atype^
+      mrspidey:atenv^
+      mrspidey:program^
+      mrspidey:calc-checks^
+      mrspidey:languages^
+      (zodiac : mrspidey:zodiac^))
+    (include "driver.ss")))
+
+(define mrspidey:hyper@
+  (unit/sig
+    mrspidey:hyper^
+    (import
+      mrspidey:CDL^
+      mrspidey:interaction^
+      mrspidey:loadexpand^
+      mrspidey:program^
+      mrspidey:calc-checks^
+      mrspidey:templates^
+      mrspidey:kernel^
+      mrspidey:kernel-aux^
+      mrspidey:atype^
+      mzlib:unprefixed-core^)
+    (include "hyper.ss")))
+
+(load-relative "zod-extra.ss")
+
+;; ----------------------------------------------------------------------
+;; Put it all together
+
+(load-relative "link.ss")
+
+;; ----------------------------------------------------------------------
+
+
+
+
+
+
+
diff --git a/collects/mrspidey/Sba/make-exn-hierarchy.ss b/collects/mrspidey/Sba/make-exn-hierarchy.ss
new file mode 100644
index 0000000..b4c94d6
--- /dev/null
+++ b/collects/mrspidey/Sba/make-exn-hierarchy.ss
@@ -0,0 +1,35 @@
+
+(define src "/home/mflatt/proj/mred/mzscheme/src/exnsrc.ss")
+(define dest "/home/cormac/plt/mrspidey/Sba/exn-hierarchy.ss")
+(when (file-exists? dest) (delete-file dest))
+
+(with-input-from-file src
+  (lambda ()
+    (let ([x (read)])
+      (with-output-to-file dest
+        (lambda ()
+          (letrec
+            ([trav
+               (lambda (tree parent)
+                 (match tree
+                   [(name fields+strings . subtrees)
+                     (let* ( [fields (filter symbol? fields+strings)]
+                             [s (symbol->string name)]
+                             [name (if (memq (string-ref s 0) '(#\* #\+))
+                                     (string->symbol
+                                       (substring s 1 (string-length s)))
+                                     name)]
+                             [name (if parent (symbol-append parent ': name) name)])
+                       (display 
+                         `(define-struct
+                            ,(if parent 
+                               `(,name ,(symbol-append 'struct: parent))
+                               name)
+                            ,fields))
+                       (newline)
+                       (for-each
+                         (lambda (subtree) (trav subtree name))
+                         subtrees))]
+                   ['- (void)]
+                   [(? string?) (void)]))])
+            (trav x #f)))))))
diff --git a/collects/mrspidey/Sba/min-test.ss b/collects/mrspidey/Sba/min-test.ss
new file mode 100644
index 0000000..630f152
--- /dev/null
+++ b/collects/mrspidey/Sba/min-test.ss
@@ -0,0 +1,1555 @@
+;; min-test.ss
+
+(define debug-nfa #t)
+(define pretty-debug-nfa (lambda (x) (when debug-nfa (pretty-print x))))
+
+(define debug-min #f)
+(define pretty-debug-min (lambda (x) (when debug-nfa (pretty-print x))))
+
+; ======================================================================
+; VIEWING CONSTRAINTS AS GRAMMARS
+; ======================================================================
+; Non-Terminalss
+
+; x is an AVS
+(define-structure (L  x))
+(define-structure (LI x))
+(define-structure (U  x))
+(define-structure (UI x))
+
+(define eq-nt?
+  (match-lambda*
+   [(($ L x1)  ($ L x2))  (eq? x1 x2)]
+   [(($ LI x1) ($ LI x2)) (eq? x1 x2)]
+   [(($ U x1)  ($ U x2))  (eq? x1 x2)]
+   [(($ UI x1) ($ UI x2)) (eq? x1 x2)]
+   [_ #f]))
+
+(define nt?
+  (match-lambda
+   [(or ($ L) ($ U) ($ LI) ($ UI)) #t]
+   [_ #f]))
+
+(define same-nt-type?
+  (match-lambda*
+   [(($ L x1)  ($ L x2))  #t]
+   [(($ LI x1) ($ LI x2)) #t]
+   [(($ U x1)  ($ U x2))  #t]
+   [(($ UI x1) ($ UI x2)) #t]
+   [_ #f]))
+
+(define nt->AVS
+  (match-lambda
+   [($ L x1)  x1]
+   [($ LI x1) x1]
+   [($ U x1)  x1]
+   [($ UI x1) x1]))
+
+(define nt-chg-AVS
+  (match-lambda*
+   [(f ($ L  x)) (make-L  (f x))]
+   [(f ($ LI x)) (make-LI (f x))]
+   [(f ($ U  x)) (make-U  (f x))]
+   [(f ($ UI x)) (make-UI (f x))]))
+
+(define drop-I
+  (match-lambda
+   [(and nt (or ($ L _) ($ U _))) nt]
+   [($ LI x) (make-L x)]
+   [($ UI x) (make-U x)]))
+
+(define mem-nt?
+  (lambda (nt l)
+    (and (not (null? l))
+         (or (eq-nt? nt (car l))
+             (mem-nt? nt (cdr l))))))
+
+(define (set-NT-prop! NT val)
+  (let* ([AVS (nt->AVS NT)]
+         [old (get-AVS-prop AVS 'NT-prop #f)]
+         [old (if old old 
+                  (let ([v (vector #f #f #f #f)])
+                    (add-AVS-prop! AVS 'NT-prop v)
+                    v))])
+    (vector-set!
+     old
+     (match NT
+       [($ L x1)  0] [($ LI x1) 1] [($ U x1)  2] [($ UI x1) 3])
+     val)))
+
+(define (get-NT-prop NT)
+  (let* ([AVS (nt->AVS NT)]
+         [old (get-AVS-prop AVS 'NT-prop #f)]
+         [old (if old old 
+                  (let ([v (vector #f #f #f #f)])
+                    (add-AVS-prop! AVS 'NT-prop v)
+                    v))])
+    (vector-ref
+     old
+     (match NT
+       [($ L x1)  0] [($ LI x1) 1] [($ U x1)  2] [($ UI x1) 3]))))
+
+; ======================================================================
+; Right hand side of a production
+
+(define-structure (rhs* grsym nts))
+(define (make-rhs grsym nt) (make-rhs* grsym (list nt)))
+
+(define-structure (grsym ineq fn sign template field-no))
+;; ineq is '<= or '>=
+;; fn   is 'inj, 'inj-tst or 'ext
+;; sign is #t (monotonic) or #f (antimonotonic)
+;; field-no may be #f
+
+(define (make-grsym->=inj+     t f) (make-grsym '>= 'inj     #t t f))
+(define (make-grsym->=inj-     t f) (make-grsym '>= 'inj     #f t f))
+(define (make-grsym->=inj?     t f) (make-grsym '>= 'inj     '? t f))
+
+(define (make-grsym-<=inj-tst+ t f) (make-grsym '<= 'inj-tst #t t f))
+(define (make-grsym-<=inj-tst- t f) (make-grsym '<= 'inj-tst #f t f))
+
+(define (make-grsym-<=ext+     t f) (make-grsym '<= 'ext     #t t f))
+(define (make-grsym->=ext-     t f) (make-grsym '>= 'ext     #f t f))
+
+(define (make-grsym->=ext+     t f) (make-grsym '>= 'ext     #t t f))
+(define (make-grsym-<=ext-     t f) (make-grsym '<= 'ext     #f t f))
+
+;; a grsym can also be '>=epsilon or '<=epsilon
+
+(define grsym-eq?
+  (match-lambda*
+   [(($ grsym i1 f1 s1 t1 n1) ($ grsym i2 f2 s2 t2 n2))
+    (and (eq? i1 i2) (eq? f1 f2) (eq? t1 t2) (eqv? n1 n2))]
+   [(x y) (eq? x y)]))
+
+; ======================================================================
+;; Initializing the L, ... fields of an AVS
+
+(define (add-AVS-LI! AVS x) (set-AVS-LI! AVS (cons x (AVS-LI AVS))))
+(define (add-AVS-UI! AVS x) (set-AVS-UI! AVS (cons x (AVS-UI AVS))))
+(define (add-AVS-L!  AVS x) (set-AVS-L!  AVS (cons x (AVS-L  AVS))))
+(define (add-AVS-U!  AVS x) (set-AVS-U!  AVS (cons x (AVS-U  AVS))))
+
+(define zeroary-op-AVS (void))
+
+(define (calc-productions! list-AVS use-AVS?
+                           tree zeroary
+                           epsilon-L epsilon-U epsilon-LI epsilon-UI
+                           L->LI U->UI)
+  ;; tree       : bool -- controls if produce RTG or regular grammar
+  ;; epsilon-...: bool -- control epsilon transitions
+  ;; L->LI, ... : bool -- controls L->LI production rule
+
+  (for-each
+   (lambda (AVS)
+     (set-AVS-L!  AVS '())
+     (set-AVS-U!  AVS '())
+     (set-AVS-LI! AVS '())
+     (set-AVS-UI! AVS '())
+     (set-AVS-edgefrom! AVS '()))
+   list-AVS)
+
+  ;; ------ Invert edges
+  (for-each
+   (lambda (AVS)
+     (for-each
+      (lambda (to) (when (use-AVS? to) (add-AVS-edgefrom! to AVS)))
+      (AVS-edgeto AVS)))
+   list-AVS)
+
+  ;; ------ Now make L, etc, from AV, constraints and edges
+  (for-each
+   (lambda (AVS)
+
+     ;; ------ Invert original AV
+     (for-each
+      (match-lambda
+       [($ AV _ (and template ($ template type signs)) misc fields)
+        (let ([l (vector-length fields)])
+          (cond
+           [tree
+            ;; Make rhs
+            (add-AVS-L! AVS
+                        (make-rhs* (make-grsym->=inj? template #f)
+                                   (map
+                                    (lambda (f sign)
+                                      (case sign
+                                        [>=inj+ (make-L f)]
+                                        [>=inj- (make-U f)]))
+                                    (vector->list fields)
+                                    (vector->list signs))))]
+           ;; o/w not tree
+           [(= l 0)
+            ;; Terminal
+            (add-AVS-L! AVS 
+                        (make-rhs* (make-grsym->=inj+ template #f) '()))]
+           [else
+            ;; Non-terminal - return all prods
+            (for i 0 l
+                 (let ([f (vector-ref fields i)])
+                   (when (use-AVS? f)
+                     (case (vector-ref signs i)
+                       [>=inj+
+                        (add-AVS-L! AVS 
+                                    (make-rhs (make-grsym->=inj+ template i) 
+                                              (make-L f)))]
+                       [>=inj-
+                        (add-AVS-L! AVS
+                                    (make-rhs (make-grsym->=inj- template i) 
+                                              (make-U f)))]))))])
+
+          (if (and zeroary (zero? l))
+              ;; Fake a unary op
+              (add-AVS-UI! zeroary-op-AVS
+                           (make-rhs (make-grsym-<=ext+ template 0)
+                                     (make-UI AVS)))
+          
+              (for i 0 l
+                   (let ([f (vector-ref fields i)])
+                     (when (use-AVS? f)
+                       (case (vector-ref signs i)
+                         [>=inj+
+                          (add-AVS-UI! 
+                           f
+                           (make-rhs (make-grsym-<=ext+ template i)
+                                     (make-UI AVS)))]
+                         [>=inj-
+                          (add-AVS-LI!
+                           f
+                           (make-rhs (make-grsym->=ext- template i) 
+                                     (make-UI AVS)))]))))))])
+      (AVS-orig-objs AVS))
+
+     ;; ------ Invert constraints
+     (for-each
+      (match-lambda
+       [($ con _ (and template ($ template type signs)) field-no AVS2)
+        (when (use-AVS? AVS2)
+          (case (vector-ref signs field-no)
+            [>=inj+
+             (add-AVS-U! AVS
+                         (make-rhs (make-grsym-<=inj-tst+ template field-no)
+                                   (make-U AVS2)))
+             (add-AVS-LI! AVS2
+                          (make-rhs (make-grsym->=ext+ template field-no)
+                                    (make-LI AVS)))]
+            [>=inj-
+             (add-AVS-U! AVS
+                         (make-rhs (make-grsym-<=inj-tst- template field-no)
+                                   (make-L AVS2)))
+             (add-AVS-UI! AVS2
+                          (make-rhs (make-grsym-<=ext- template field-no)
+                                    (make-LI AVS)))]))]
+       [($ con-filter _ filter AVS2)
+        (printf "Warning: con-filter~n")])
+      (AVS-constraints AVS))
+
+     (for-each
+      (lambda (to)
+        (when epsilon-L  (add-AVS-L!  to  (make-rhs '>=epsilon (make-L  AVS))))
+        (case epsilon-LI
+          [#t (add-AVS-LI! to  (make-rhs '>=epsilon (make-LI AVS)))]
+          ['concrete
+           (add-AVS-LI! to  (make-rhs '>=concrete-epsilon (make-LI AVS)))])
+        (when epsilon-U  (add-AVS-U!  AVS (make-rhs '<=epsilon (make-U  to))))
+        (when epsilon-UI (add-AVS-UI! AVS (make-rhs '<=epsilon (make-UI to)))))
+      (AVS-edgeto AVS))
+
+     (when L->LI (add-AVS-L! AVS (make-rhs '>=epsilon (make-LI AVS))))
+     (when U->UI (add-AVS-U! AVS (make-rhs '<=epsilon (make-UI AVS))))
+     )
+   list-AVS))
+
+;; ----------------------------------------------------------------------
+;; Restricting the grammer to certain NTs
+
+(define (restrict-nts! list-AVS use-nt?)
+  ;;(display `(restrict-nts! ,(map nt->sym list-nt))) (newline)
+  (let* ([filter-nt
+          (lambda (rhs*)
+            (filter-map
+             (match-lambda
+              [(and rhs ($ rhs* grsym nts))
+               (if (or (null? nts) (ormap use-nt? nts))
+                   rhs
+                   #f)])
+             rhs*))])
+    (for-each 
+     (lambda (AVS)
+       (for-each
+        (match-lambda
+         [(set-AVS-NT! make-NT AVS-NT)
+          (set-AVS-NT! AVS (if (use-nt? (make-NT AVS))
+                               (filter-nt (AVS-NT  AVS))
+                               '()))])
+        (list (list set-AVS-L!  make-L  AVS-L)
+              (list set-AVS-U!  make-U  AVS-U)
+              (list set-AVS-LI! make-LI AVS-LI)
+              (list set-AVS-UI! make-UI AVS-UI))))
+     list-AVS)))
+
+;; ----------------------------------------------------------------------
+;; for-each-prods
+;; For this to work, must have AVS-L etc setup.
+
+(define (for-each-prods f nt)
+  (match nt
+    [($ L  x) (for-each f (AVS-L  x))]
+    [($ U  x) (for-each f (AVS-U  x))]
+    [($ LI x) (for-each f (AVS-LI x))]
+    [($ UI x) (for-each f (AVS-UI x))]))
+
+;; ======================================================================
+
+(define (add-prod nt grsym nt*)
+  (assert (andmap nt? nt*))
+  (let ([rhs (make-rhs* grsym nt*)])
+    (match nt
+      [($ L  x) (add-AVS-L!  x rhs)]
+      [($ LI x) (add-AVS-LI! x rhs)]
+      [($ U  x) (add-AVS-U!  x rhs)]
+      [($ UI x) (add-AVS-UI! x rhs)])))
+
+;; ----------------------------------------------------------------------
+;; Assumes grammar is result of N->D
+;; So is a D-RTG, and only has productions on L,U
+;; not on LI,UI
+
+(define (convert-productions-to-AV-etc! list-AVS)
+  ;;(pretty-print `(cvt-prods ,(map name-for-AVS list-AVS)))
+  (let* ([AVS-empty (mk-AVS-tmp 'empty)]
+         [add-AV-field!
+          (lambda (AVS template field-no AVS2)
+            (or
+             ;; Is the zeroary-op-AVS field
+             (>= field-no (vector-length (template-signs template)))
+             ;; Reuse old AV, if possible
+             (ormap
+              (match-lambda
+               [($ AV _ (? (lambda (t) (eq? t template))) _ fields)
+                (cond
+                 [(eq? (vector-ref fields field-no) AVS-empty)
+                  ;;; empty, fill it
+                  (vector-set! fields field-no AVS2)
+                  #t]
+                 [(eq? (vector-ref fields field-no) AVS2)
+                  ;; Already in there
+                  #t]
+                 [else;; this won't work
+                  #f])]
+               [_ #f])
+              (get-AVS-objs AVS))
+             ;; No AV in there, create and add one
+             (let* ([l (vector-length (template-signs template))]
+                    [fields (make-vector l AVS-empty)])
+               (vector-set! fields field-no AVS2)
+               (add-nohash-orig-AV! 
+                AVS (create-AV-nolist template '() fields)))))])
+
+    ;; Examine each production rule, and convert it.
+    (for-each
+     (lambda (AVS)
+       ;;(pretty-print `(convert-prods AVS ,(AVS-num AVS)))
+       ;; L-AVS
+       (for-each
+        (match-lambda
+         [($ rhs* (or '>=epsilon '>=concrete-epsilon) ((or ($ L x) ($ LI x))))
+          (unless (eq? AVS x) (add-edge! x AVS))]
+         [($ rhs* ($ grsym '>= 'inj sign template field-no) ())
+          (add-nohash-orig-AV! AVS (create-AV-nolist template '() (vector)))]
+         [($ rhs* ($ grsym '>= 'inj sign template #f)
+             ((or ($ L x*) ($ U x*)) ...))
+          (map-with-n (lambda (x n) (add-AV-field! AVS template n x))
+                      x*)]
+         [($ rhs* ($ grsym '>= 'inj sign template field-no)
+             ((or ($ L x) ($ U x))))
+          (add-AV-field! AVS template field-no x)]
+
+         [($ rhs* ($ grsym '>= ext #t template field-no) 
+             ((or ($ LI x) ($ L x))))
+          (add-con! x (create-con template field-no AVS))]
+         [($ rhs* ($ grsym '>= ext #f template field-no)  
+             ((or ($ UI x) ($ U x))))
+          (add-AV-field! x template field-no AVS)]
+
+         [($ rhs* grsym nts)
+          (error 'prod-to-AV "Bad L/LI rhs ~s ~s" 
+                 (grsym->rep grsym) (map nt->sym nts))]
+         [rhs (error 'prod-to-AV "Bad L/LI rhs ~s" rhs)])
+        (append (AVS-L AVS) (AVS-LI AVS)))
+
+       ;; U-AVS
+       (for-each
+        (match-lambda
+         [($ rhs* '<=epsilon ((or ($ U x) ($ UI x))))
+          (unless (eq? AVS x) (add-edge! AVS x))]
+         [($ rhs* ($ grsym '<= 'inj-tst #f template field-no) (($ L x)))
+          (add-con! AVS (create-con template field-no x))]
+         [($ rhs* ($ grsym '<= 'inj-tst #t template field-no) (($ U x)))
+          (add-con! AVS (create-con template field-no x))]
+
+         [($ rhs* ($ grsym '<= 'ext #f template field-no) 
+             ((or ($ L x) ($ LI x))))
+          (add-con! x (create-con template field-no AVS))]
+         [($ rhs* ($ grsym '<= 'ext #t template field-no) 
+             ((or ($ U x) ($ UI x))))
+          (add-AV-field! x template field-no AVS)]
+
+         [($ rhs* grsym nts)
+          (error 'prod-to-AV "Bad U/UI rhs ~s ~s" 
+                 (grsym->rep grsym) (map nt->sym nts))]
+         [rhs (error 'prod-to-AV "Bad U/UI rhs ~s" rhs)])
+        (append (AVS-U AVS) (AVS-UI AVS))))
+       
+     list-AVS)
+
+    ;; Now prop AVs
+    (for-each
+     (lambda (AVS)
+       (for-each (lambda (AV) (prop-AV! AVS AV))
+                 (AVS-orig-objs AVS)))
+     list-AVS)
+
+    ))
+
+; ======================================================================
+; COMPRESSING GRAMMARS
+; ======================================================================
+
+(define (epsilon-close-nt nt)
+  (epsilon-close-nts (list nt)))
+
+(define (epsilon-close-nts nts)
+  (let ([done '()])
+    (letrec ([traverse 
+              (lambda (nt)
+                (unless (mem-nt? nt done)
+                  (set! done (cons nt done))
+                  (for-each-prods
+                   (match-lambda
+                    [($ rhs* (or '>=epsilon '<=epsilon) (nt2))
+                     (traverse nt2)]
+                    [_ (void)])
+                   nt)))])
+      (for-each traverse nts)
+      done)))
+
+; --------------------
+
+(define for-each-prods-joined
+  (lambda (fn nt*)
+    (let* ([rhs* '()])
+      (for-each
+       (lambda (nt)
+         (for-each-prods (lambda (rhs) (set! rhs* (cons rhs rhs*)))
+                         nt))
+       nt*)
+      (recur loop ([rhs* rhs*])
+        (match rhs*
+          [() (void)]
+          [(($ rhs* grsym _) . _)
+           (match-let
+               ([(nt** . rest)
+                 (filter-map-split
+                  (match-lambda
+                   [($ rhs* grsym2 nt*)
+                    (if (grsym-eq? grsym grsym2) nt* #f)])
+                  rhs*)])
+             (fn grsym nt**)
+             (loop rest))])))))
+
+; --------------------
+
+(define (grammar-calc-reached roots)
+  (let ([reached '()]
+        [tag (gensym)])
+    (letrec 
+        ([traverse
+          (lambda (nt)
+            (unless (eq? (get-NT-prop nt) tag)
+              (set-NT-prop! nt tag)
+              (set! reached (cons nt reached))
+              (for-each-prods
+               (match-lambda
+                [($ rhs* _ nt*) 
+                 (for-each traverse nt*)])
+               nt)))])
+      (for-each traverse roots)
+      (list reached (lambda (nt) (eq? (get-NT-prop nt) tag))))))
+
+; --------------------
+
+(define (grammar-calc-nonempty num-NT NT->num num->NT final)
+  (let* ([table (make-vector num-NT '())])
+    ;; entry is #t if nonempty, 
+    ;; or else list of NT to make nonempty if proved nonempty
+    (letrec ([set-nonempty! 
+              (lambda (n)
+                '(pretty-print `(set-nonempty! ,(nt->sym (num->NT n))))
+                (let ([l  (vector-ref table n)])
+                  (vector-set! table n #t)
+                  (when (list? l)
+                    (for-each set-nonempty! l))))]
+             [add-depends
+              (lambda (i j)
+                '(pretty-print `(add-depends ,(nt->sym (num->NT i))
+                                            ,(nt->sym (num->NT j))))
+                (if (list? (vector-ref table j))
+                    (vector-set! table j (cons i (vector-ref table j)))
+                    (set-nonempty! i)))])
+
+      ;; fill out table
+      (for i 0 num-NT
+           (let ([nt (num->NT i)])
+             ;;(pretty-print `(i ,i nt ,(nt->sym nt) ,(mem-nt? nt final)))
+             (if (mem-nt? nt final)
+                 (set-nonempty! i)
+                 ;; Look at prods
+                 (for-each-prods 
+                  (match-lambda
+                   [($ rhs* grsym nt*)
+                    ;;(pretty-print `(-> ,(grsym->rep grsym) ,(nt->sym nt)))
+                    (if (null? nt*)
+                        (set-nonempty! i)
+                        (for-each (lambda (nt) (add-depends i (NT->num nt)))
+                                  nt*))])
+                  nt))))
+
+      ;; return list of nonempty nts, plus membership predicate
+      ;; 
+      (list (filter-map
+             (lambda (x) x)
+             (map-with-n
+              (lambda (entry n)
+                (if (eq? entry #t)
+                    (num->NT n)
+                    #f))
+              (vector->list table)))
+            ;; nonempty-nt?
+            (lambda (nt) (if (and (NT->num nt)
+                                  (eq? (vector-ref table (NT->num nt)) #t))
+                             #t #f))
+            ))))
+
+; ======================================================================
+; COMPRESSING CONSTRAINTS
+; ======================================================================
+
+(define select-L
+  (lambda (nt*)
+    (filter-map (match-lambda [($ L x) x][_ #f]) nt*)))
+
+(define select-LI
+  (lambda (nt*)
+    (filter-map (match-lambda [($ LI x) x][_ #f]) nt*)))
+
+(define select-U
+  (lambda (nt*)
+    (filter-map (match-lambda [($ U x) x][_ #f]) nt*)))
+
+(define select-UI
+  (lambda (nt*)
+    (filter-map (match-lambda [($ UI x) x][_ #f]) nt*)))
+
+; --------------------
+
+(define (epsilon-close-forwards AVS)
+  (let ([done '()])
+    (recur traverse ([AVS AVS])
+      (unless (memq AVS done)
+        (set! done (cons AVS done))
+        (for-each traverse (AVS-edgeto AVS))))
+    done))
+
+(define (epsilon-close-backwards AVS)
+  (let ([done '()])
+    (recur traverse ([AVS AVS])
+      (unless (memq AVS done)
+        (set! done (cons AVS done))
+        (for-each traverse (AVS-edgefrom AVS))))
+    done))
+
+; ======================================================================
+; Could use list-AVS to be more efficient here!
+
+(define calc-NT<->num
+  (lambda (list-nt)
+    (let* ([num-NT 0]
+           [num->NT (make-vector (* 4 (length list-nt)) #f)]
+           [AVS->L-NT  (make-vector num-AVS #f)]
+           [AVS->LI-NT (make-vector num-AVS #f)]
+           [AVS->U-NT  (make-vector num-AVS #f)]
+           [AVS->UI-NT (make-vector num-AVS #f)]
+           [add-NT! (lambda (NT)
+                      (vector-set! num->NT num-NT NT)
+                      (begin0
+                       num-NT
+                       (set! num-NT (add1 num-NT))))])
+      (for-each
+       (lambda (nt)
+         (match nt
+           [($ L  AVS) (vector-set! AVS->L-NT   (AVS-num AVS) (add-NT! nt))]
+           [($ LI AVS) (vector-set! AVS->LI-NT  (AVS-num AVS) (add-NT! nt))]
+           [($ U  AVS) (vector-set! AVS->U-NT   (AVS-num AVS) (add-NT! nt))]
+           [($ UI AVS) (vector-set! AVS->UI-NT  (AVS-num AVS) (add-NT! nt))]))
+       list-nt)
+      (list num-NT
+            (match-lambda 
+             [($ L  x) (vector-ref AVS->L-NT  (AVS-num x))]
+             [($ LI x) (vector-ref AVS->LI-NT (AVS-num x))]
+             [($ U  x) (vector-ref AVS->U-NT  (AVS-num x))]
+             [($ UI x) (vector-ref AVS->UI-NT (AVS-num x))])
+            (lambda (num) (vector-ref num->NT num))))))
+
+; ----------------------------------------------------------------------
+
+(define leq->equiv
+  (lambda (list-e e->num e-leq?)
+    ;; Takes a list of elements in list-e, 
+    ;; with e-leq? a partial order
+    ;; Calculates an equivalence relation
+    (match-let*
+        ([e-eq? (lambda (i j) 
+                   (let ([r (and (e-leq? i j) (e-leq? j i))])
+                     '(when r (printf "~s=~s~n" (nt->sym i) (nt->sym j)))
+                     r))]
+         [AVS-leq? (lambda (x y)
+                     (and (NT-leq? (make-L  x) (make-L  y))
+                          (NT-leq? (make-LI x) (make-LI y))
+                          (NT-leq? (make-U  y) (make-U  x))
+                          (NT-leq? (make-UI y) (make-UI x))))]
+         [AVS->rep-AVS (make-vector num-AVS #f)]
+         [list-rep-AVS '()]
+         [old-AVS->AVS (lambda (old-AVS)
+                         (let ([AVS (vector-ref AVS->rep-AVS 
+                                                (AVS-num old-AVS))])
+                           AVS))]
+         [old-nt->nt (lambda (nt) (nt-chg-AVS old-AVS->AVS nt))]
+         [AV-leq?
+          (match-lambda*
+           [(($ AV _ template1 misc1 fields1) 
+             ($ AV _ template2 misc2 fields2)
+             AVS-leq?)
+            (and (eq? template1 template2)
+                 (eq? misc1 misc2)
+                 (andmap2 AVS-leq?
+                          (vector->list fields1) 
+                          (vector->list fields2)))])])
+
+      ;; Have equivalence relation in AVS-eq?
+      ;; want to create mapping AVS -> new AVS
+      (printf "Calculating AVS -> new AVS~n")
+      (for-each
+       (lambda (AVS)
+         (ormap
+          (lambda (rep)
+            (cond
+             [(eq? AVS rep)
+              ;; This AVS not included in any representative AVS
+              (let ([rep-AVS (mk-AVS-nolist 'eqvcl)])
+                (vector-set! AVS->rep-AVS (AVS-num AVS) rep-AVS)
+                (set! list-rep-AVS (cons (cons AVS rep-AVS) list-rep-AVS))
+                #t)]
+             [(AVS-eq? AVS rep)
+              ;; This NT is equivalent to rep
+              (let ([rep-AVS (vector-ref AVS->rep-AVS (AVS-num rep))])
+                                        ;(assert (eq? rep ))
+                (vector-set! AVS->rep-AVS (AVS-num AVS) rep-AVS)
+                (set! list-rep-AVS (cons (cons AVS rep-AVS) list-rep-AVS)))
+              #t]
+             [else;; continue
+              #f]))
+          list-AVS))
+       list-AVS)
+
+      '(begin
+         (display 
+          `(AVS->rep-AVS 
+            ,(map (lambda (AVS) 
+                    (cons (AVS-num AVS)
+                          (AVS-num (vector-ref AVS->rep-AVS (AVS-num AVS))))) 
+                  list-AVS)))
+         (newline))
+      (printf "Num rep AVS=~s~n" (length list-rep-AVS))
+
+      ;; Now fill in the AV's and constraints in the representative AVS
+      ;; Maybe want to remove duplicate constraints
+      ;; Not removing duplicate AV's from different AVSs in same rep-AVS
+
+      (printf "Copying grammar~n")
+
+      (for-each
+       (match-lambda
+        [(old-AVS . rep-AVS)
+         (for-each
+          (match-lambda
+           [(get-nt set-nt!)
+            (for-each
+             (match-lambda
+              [($ rhs* grsym nt*)
+               (or 
+                ;; Check if already there
+                (ormap (match-lambda
+                        [($ rhs*
+                            (? (lambda (grsym2) (grsym-eq? grsym grsym2)))
+                            (? (lambda (nt2*) (andmap2 eq-nt? nt* nt2*))))
+                         #t]
+                        [_ #f])
+                       (get-nt rep-AVS))
+                ;; Add it
+                (set-nt! rep-AVS
+                         (cons (make-rhs* 
+                                grsym 
+                                (map old-nt->nt nt*))
+                               (get-nt rep-AVS))))])
+             (get-nt old-AVS))])
+          (list (list AVS-L  set-AVS-L!)
+                (list AVS-LI set-AVS-LI!)
+                (list AVS-U  set-AVS-U!)
+                (list AVS-UI set-AVS-UI!)))])
+       list-rep-AVS)
+
+      ;; Done, return mapping
+      old-nt->nt)))
+
+; ----------------------------------------------------------------------
+
+(define apply-equivalence-relation
+  (lambda (list-nt num-NT NT->num num->NT NT-leq?)
+    ;; NT-leq? is ordering on NTs
+    (match-let*
+        ([list-AVS (list->set (map nt->AVS list-nt))]
+         [NT-eq? (lambda (i j) 
+                   (let ([r (and (NT-leq? i j) (NT-leq? j i))])
+                     '(when r (printf "~s=~s~n" (nt->sym i) (nt->sym j)))
+                     r))]
+         [AVS-eq? (lambda (x y)
+                    (let ([r
+                           (and (NT-eq? (make-L  x) (make-L  y))
+                                (NT-eq? (make-LI x) (make-LI y))
+                                (NT-eq? (make-U  x) (make-U  y))
+                                (NT-eq? (make-UI x) (make-UI y)))])
+                      '(when r (printf "~s=~s~n" 
+                                       (name-for-AVS x) (name-for-AVS y)))
+                      r))]
+         [AVS-leq? (lambda (x y)
+                     (and (NT-leq? (make-L  x) (make-L  y))
+                          (NT-leq? (make-LI x) (make-LI y))
+                          (NT-leq? (make-U  y) (make-U  x))
+                          (NT-leq? (make-UI y) (make-UI x))))]
+         [AVS->rep-AVS (make-vector num-AVS #f)]
+         [list-rep-AVS '()]
+         [old-AVS->AVS (lambda (old-AVS)
+                         (let ([AVS (vector-ref AVS->rep-AVS 
+                                                (AVS-num old-AVS))])
+                           AVS))]
+         [old-nt->nt (lambda (nt) (nt-chg-AVS old-AVS->AVS nt))]
+         [AV-leq?
+          (match-lambda*
+           [(($ AV _ template1 misc1 fields1) 
+             ($ AV _ template2 misc2 fields2)
+             AVS-leq?)
+            (and (eq? template1 template2)
+                 (eq? misc1 misc2)
+                 (andmap2 AVS-leq?
+                          (vector->list fields1) 
+                          (vector->list fields2)))])])
+
+      ;; Have equivalence relation in AVS-eq?
+      ;; want to create mapping AVS -> new AVS
+      (printf "Calculating AVS -> new AVS~n")
+      (for-each
+       (lambda (AVS)
+         (ormap
+          (lambda (rep)
+            (cond
+             [(eq? AVS rep)
+              ;; This AVS not included in any representative AVS
+              (let ([rep-AVS (mk-AVS-nolist 'eqvcl)])
+                (vector-set! AVS->rep-AVS (AVS-num AVS) rep-AVS)
+                (set! list-rep-AVS (cons (cons AVS rep-AVS) list-rep-AVS))
+                #t)]
+             [(AVS-eq? AVS rep)
+              ;; This NT is equivalent to rep
+              (let ([rep-AVS (vector-ref AVS->rep-AVS (AVS-num rep))])
+                                        ;(assert (eq? rep ))
+                (vector-set! AVS->rep-AVS (AVS-num AVS) rep-AVS)
+                (set! list-rep-AVS (cons (cons AVS rep-AVS) list-rep-AVS)))
+              #t]
+             [else;; continue
+              #f]))
+          list-AVS))
+       list-AVS)
+
+      '(begin
+         (display 
+          `(AVS->rep-AVS 
+            ,(map (lambda (AVS) 
+                    (cons (AVS-num AVS)
+                          (AVS-num (vector-ref AVS->rep-AVS (AVS-num AVS))))) 
+                  list-AVS)))
+         (newline))
+      (printf "Num rep AVS=~s~n" (length list-rep-AVS))
+
+      ;; Now fill in the AV's and constraints in the representative AVS
+      ;; Maybe want to remove duplicate constraints
+      ;; Not removing duplicate AV's from different AVSs in same rep-AVS
+
+      (printf "Copying grammar~n")
+
+      (for-each
+       (match-lambda
+        [(old-AVS . rep-AVS)
+         (for-each
+          (match-lambda
+           [(get-nt set-nt!)
+            (for-each
+             (match-lambda
+              [($ rhs* grsym nt*)
+               (or 
+                ;; Check if already there
+                (ormap (match-lambda
+                        [($ rhs*
+                            (? (lambda (grsym2) (grsym-eq? grsym grsym2)))
+                            (? (lambda (nt2*) (andmap2 eq-nt? nt* nt2*))))
+                         #t]
+                        [_ #f])
+                       (get-nt rep-AVS))
+                ;; Add it
+                (set-nt! rep-AVS
+                         (cons (make-rhs* 
+                                grsym 
+                                (map old-nt->nt nt*))
+                               (get-nt rep-AVS))))])
+             (get-nt old-AVS))])
+          (list (list AVS-L  set-AVS-L!)
+                (list AVS-LI set-AVS-LI!)
+                (list AVS-U  set-AVS-U!)
+                (list AVS-UI set-AVS-UI!)))])
+       list-rep-AVS)
+
+      ;; Done, return mapping
+      old-nt->nt)))
+
+; ----------------------------------------------------------------------
+
+(define (make-minimization-algorithm table-builder-helper)
+  (lambda (list-nt roots final)
+    (match-let*
+        ([(num-NT NT->num num->NT) (calc-NT<->num list-nt)]
+         [table-leq (make-vector (* num-NT num-NT) (lambda () (void)))]
+         ;; table-leq[x][y] = #f => not(x<=y)
+         ;; otherwise a thunk to perform if not(x<=y)
+         [NT->rep-NT (make-vector num-NT)]
+         [list-rep-NT '()])
+      (letrec
+          ([lookup (lambda (x y) (vector-ref table-leq (+ (* num-NT x) y)))]
+           [set-table-leq!
+            (lambda (x y v) (vector-set! table-leq (+ (* num-NT x) y) v))]
+
+           [record-not-leq
+            (lambda (x y)
+              '(pretty-print 
+                `(record-not-leq ,(nt->sym (num->NT x))
+                                 ,(nt->sym (num->NT y))))
+              (when (not (= x y))
+                (match (lookup x y)
+                  [#f (void)]
+                  [thunk
+                   (set-table-leq! x y #f)
+                   (thunk)])))]
+
+           [record-not-leq-action
+            (lambda (d-p d-q thunk)
+              '(pretty-print 
+                `(record-not-leq-action ,(nt->sym (num->NT d-p))
+                                        ,(nt->sym (num->NT d-q))))
+              (unless (eq? d-p d-q)
+                (match (lookup d-p d-q)
+                  [#f (thunk)]
+                  [entry (set-table-leq! d-p d-q
+                                         (lambda () (thunk) (entry)))])))]
+
+           [epsilon-close (make-vector num-NT #f)]
+           [nt->grsym->fields (make-vector num-NT #f)])
+
+        (printf "Calculating epsilon-close~n")
+        (for i 0 num-NT
+             (vector-set! epsilon-close i 
+                          (epsilon-close-nt (num->NT i))))
+
+        (printf "Calculating (x,c) -> { z* | x ->* y, y->c(z*) }~n")
+        (for i 0 num-NT
+             (let* ([alist '()])
+               (for-each-prods-joined
+                (lambda (grsym nt**)
+                  '(printf "nt ~s grsym ~a nt** ~s~n"
+                          (nt->sym (num->NT i))
+                          (grsym->rep grsym)
+                          nt**)
+                  (set! alist (cons (cons grsym nt**) alist)))
+                (epsilon-close-nt (num->NT i)))
+               (vector-set! nt->grsym->fields i alist)))
+
+        (printf "Marking final NT's as distinct~n")
+        (for-each
+         (lambda (f)
+           (let ([n-f (NT->num f)])
+             (when n-f
+               (for i 0 num-NT
+                    (unless (= n-f i)
+                      (record-not-leq n-f i)
+                      (record-not-leq i n-f))))))
+         final)
+                     
+        (printf "Filling not-leq table, num-NT=~s~n" num-NT)
+        ;; Fill out table-leq
+        (for i 0 num-NT
+             ;;(printf "i ~s ~s~n" i (nt->sym (num->NT i)))
+             (when (zero? (modulo i 25)) (printf ".") (flush-output))
+             (for-each-prods
+              (match-lambda
+               [($ rhs* (or '>=epsilon '<=epsilon) (nt))
+                (for j 0 num-NT
+                     (record-not-leq-action 
+                      (NT->num nt) j
+                      (lambda () (record-not-leq i j))))]
+               [($ rhs* grsym nt*)
+                (for j 0 num-NT
+                     '(printf "i ~s j ~s grsym ~s nt ~s ~s ~n"
+                              (nt->sym (num->NT i))
+                              (nt->sym (num->NT j))
+                              grsym
+                              (map nt->sym nt*)
+                              (map NT->num nt*))
+                     (unless (= i j)
+                       (let* ([nt** (or (ormap
+                                         (match-lambda
+                                          [(grsym2 . nt**)
+                                           (if (grsym-eq? grsym grsym2)
+                                               nt**
+                                               #f)])
+                                         (vector-ref nt->grsym->fields j))
+                                        '())]
+                              [n (length nt**)])
+                         '(printf "i ~s grsym ~a j ~s nt** ~s~n"
+                                 (nt->sym (num->NT i))
+                                 (grsym->rep grsym)
+                                 (nt->sym (num->NT j))
+                                 nt**)
+                         (cond
+                          [(zero? n) (record-not-leq i j)]
+                          [(null? nt*) ; is a terminal
+                           (void)]
+                          [else
+                           (table-builder-helper
+                            i j nt* nt** n NT->num
+                            record-not-leq record-not-leq-action)]))))])
+              (num->NT i)))
+        (newline)
+
+        '(begin
+           (display (map (lambda (x) (if x #t #f)) (vector->list table-leq)))
+           (newline)
+           (for-each 
+            (lambda (nt1)
+              (for-each
+               (lambda (nt2)
+                 (when (and (not (eq? nt1 nt2))
+                            (same-nt-type? nt1 nt2)
+                            (lookup (NT->num nt1) (NT->num nt2)))
+                   (printf "~s <= ~s~n" (nt->sym nt1) (nt->sym nt2))))
+               list-nt))
+            list-nt)
+           (newline))
+      
+        ;; Apply the equivalence relation
+        (printf "Applying the eqv rel~n")
+        (apply-equivalence-relation 
+         list-nt
+         num-NT NT->num num->NT
+         (lambda (i j) 
+           (let ([num-i (NT->num i)]
+                 [num-j (NT->num j)])
+             (cond
+              [(and (not num-i) (not num-j)) #t]
+              [(or  (not num-i) (not num-j)) #f]
+              [else (lookup (NT->num i) (NT->num j))]))))))))
+
+; ----------------------------------------------------------------------
+
+(define (DFA-min list-nt roots final)
+  (printf "Calculating min DFA~n")
+  ((make-minimization-algorithm
+    (lambda (i j nt* nt** n NT->num record-not-leq record-not-leq-action)
+      ;; i -> c(nt*)
+      ;; j -> c(nt*) forall nt* in nt**
+      (for-each
+       (lambda (nt*2)
+         (for-each
+          (lambda (nt nt2)
+            (record-not-leq-action (NT->num nt) (NT->num nt2)
+                                   (lambda () (record-not-leq i j))))
+          nt* nt*2))
+       nt**)))
+   list-nt roots final))
+
+(define (NFA-min list-nt roots final)
+  (printf "Calculating min NFA~n")
+  ((make-minimization-algorithm
+    (lambda (i j nt* nt** n NT->num record-not-leq record-not-leq-action)
+      ;; i -> c(nt*)
+      ;; j -> c(nt*) forall nt* in nt**
+      (recur loop ([nt* nt*][nt** nt**])
+        (unless (null? nt*)
+          (let* ([f (car nt*)]
+                 [f* (map car nt**)]
+                 [c n]
+                 [fn (lambda ()
+                       (set! c (sub1 c))
+                       (when (zero? c) (record-not-leq i j)))])
+            (for-each
+             (lambda (f2)
+               (record-not-leq-action (NT->num f) (NT->num f2) fn))
+             f*)
+            (loop (cdr nt*) (map cdr nt**)))))))
+   list-nt roots final))
+
+(define (RTG-min list-nt roots final)
+  (printf "Calculating min NFA~n")
+  ((make-minimization-algorithm
+    (lambda (i j nt* nt** n NT->num record-not-leq record-not-leq-action)
+      ;; i -> c(nt*)
+      ;; j -> c(nt*) forall nt* in nt**
+      (let ([c n])
+        (for-each
+         (lambda (nt*2)
+           (let ([nt*2-done #f])
+             (for-each
+              (lambda (nt nt2)
+                (record-not-leq-action
+                 (NT->num nt)
+                 (NT->num nt2)
+                 (lambda ()
+                   (unless nt*2-done
+                       (set! nt*2-done #t)
+                     (set! c (sub1 c))
+                     (when (zero? c) (record-not-leq i j))))))
+              nt* nt*2)))
+         nt**))))
+   list-nt roots final))
+
+; ======================================================================;
+; N->D section
+; ======================================================================;
+
+(define (N->D roots final tidy?)
+  ;; n is an old nt
+  ;; d is new nt
+  (printf "Calculating N->D~n")
+  (letrec
+      ([n*->d '()]                      ; Maps set of NFA nts to a DFA nt
+       [n*<=
+        (lambda (n1* n2*)
+          (andmap (lambda (n1) (mem-nt? n1 n2*)) n1*))]        
+       [n*=
+        (lambda (n1* n2*)
+          (and (n*<= n1* n2*) (n*<= n2* n1*)))]
+       [lookup
+        (lambda (n*)
+          (recur loop ([l n*->d])
+            (cond
+             [(null? l) #f]
+             [(n*= n* (caar l)) (cdar l)]
+             [else (loop (cdr l))])))]
+       [AVS->nu-AVS                     ; Use same d for L-AVS and U-AVS
+        (let ([l '()])
+          (lambda (AVS)
+            (match (assq AVS l)
+              [(_ . nuAVS) nuAVS]
+              [#f (let ([nuAVS (mk-AVS-nolist 'dfa-nuAVS)])
+                    (set! l (cons (cons AVS nuAVS) l))
+                    nuAVS)])))]
+       [make-d-for-nt*
+        (match-lambda
+         [(($ L x)) (make-L (AVS->nu-AVS x))] 
+         [(($ U x)) (make-U (AVS->nu-AVS x))] 
+         [(($ L _) ...) (make-L (mk-AVS-nolist 'dfa-L))]
+         [(($ U _) ...) (make-U (mk-AVS-nolist 'dfa-U))])]
+       [count 0]
+       [traverse
+        (lambda (n*)
+          (when (zero? (modulo count 25)) (printf ".") (flush-output))
+          (set! count (add1 count))
+          (let* ([n* (epsilon-close-nts n*)]
+                 [n*-noI (map drop-I n*)])
+            '(pretty-print `(traverse ,(map nt->sym n*)))
+            (or (lookup n*-noI)
+                ;; Need to traverse
+                ;; assume n* epsilon-closed
+                (let* ([d (make-d-for-nt* n*-noI)])
+                  (set! n*->d (cons (cons n*-noI d) n*->d))
+                  (for-each-prods-joined
+                   (lambda (grsym nt**)
+                     (if (and (not tidy?)
+                              (not (null? nt**))
+                              (not (null? (car nt**)))
+                              (not (null? (cdar nt**))))
+                         ;; Don't want to tidy multi-arity constructor
+                         (for-each
+                          (lambda (nt*) 
+                            (add-prod d grsym 
+                                      (map (lambda (nt) (traverse (list nt)))
+                                           nt*)))
+                          nt**)
+                         ;; Yeah, tidy it
+                         (recur loop ([nt** nt**][d* '()])
+                           (match nt**
+                             [(() ...)
+                              ;; All done - add the resulting production
+                              (add-prod d grsym (reverse d*))]
+                             [((nt* . nt**) ...)
+                              ;; nt* is all nts for a particular field
+                              (loop nt** (cons (traverse nt*) d*))]))))
+                   n*)
+                  d))))])
+
+    (for-each (lambda (nt) (traverse (list nt)))
+              roots)
+    (newline)
+
+    '(begin
+      (printf "Table:~n")
+      (pretty-print
+       (map (match-lambda
+             [(n* . d) (cons (map nt->sym n*) (nt->sym d))])
+            n*->d)))
+
+    (printf "Calculating new roots, final~n")
+    ;; Return new roots, and nu final
+    (list
+     ;; new roots
+     (map (lambda (nt) (lookup (map drop-I (epsilon-close-nt nt))))
+          roots)
+     ;; new final
+     (map (lambda (nt)
+            (let* ([nt-noI (drop-I nt)]
+                   [nu-nt (make-d-for-nt* (list nt-noI))])
+              (for-each
+               (match-lambda
+                [(n* . d)
+                 (when (mem-nt? nt-noI n*)
+                   (add-prod d 
+                              (match d
+                                [($ L) '>=epsilon]
+                                [($ U) '<=epsilon])
+                              (list nu-nt)))])
+               n*->d)
+              nu-nt))
+          final))))
+
+;; ======================================================================
+;; A series of composable grammar manipulation stages
+;; Each takes and returns (roots final list-NT list-AVS . rest)
+;; May just return (roots final)
+
+(define (stage-restrict-reached roots final list-NT list-AVS)
+  (printf "Calculating reached~n")
+  (match-let*
+      ([(reached-nt reached-nt?) (grammar-calc-reached roots)])
+    (printf "Restricting NTs~n")
+    (restrict-nts! list-AVS reached-nt?)
+    ;;(display (map nt->sym reached-nt)) (newline)
+    ;;(st:prods)
+    ;;(newline)
+    (list roots final reached-nt list-AVS)))
+
+(define (stage-restrict-nonempty roots final list-NT list-AVS)
+  (match-let*
+      ([_ (printf "Calculating NT<->num~n")]
+       [(num-NT NT->num num->NT) (calc-NT<->num list-NT)]
+       [_ (printf "Calculating nonempty~n")]
+       [(nonempty-nt nonempty-nt?)
+        (grammar-calc-nonempty num-NT NT->num num->NT final)])
+     (printf "Restricting NTs~n")
+     (restrict-nts! list-AVS nonempty-nt?)
+     ;;(display (map nt->sym nonempty-nt)) (newline)
+     ;;(st:prods)
+     ;;(newline)
+     (list roots final nonempty-nt list-AVS)))
+
+(define (stage-N->D roots final list-NT list-AVS)
+  (match-let*
+      ([(nuroots nufinal) (N->D roots final #t)])
+    (list nuroots nufinal)))
+
+(define (stage-N->D-notidy roots final list-NT list-AVS)
+  (match-let*
+      ([(nuroots nufinal) (N->D roots final #f)])
+    (list nuroots nufinal)))
+
+(define (stage-DFA-min roots final list-NT list-AVS)
+  (match-let*
+      ([old-nt->nu-nt (DFA-min list-NT roots final)])
+    (list (map old-nt->nu-nt roots)
+          (map old-nt->nu-nt final))))
+
+(define (stage-NFA-min roots final list-NT list-AVS)
+  (match-let*
+      ([old-nt->nu-nt (NFA-min list-NT roots final)])
+    (list (map old-nt->nu-nt roots)
+          (map old-nt->nu-nt final))))
+
+(define (stage-RTG-min roots final list-NT list-AVS)
+  (match-let*
+      ([old-nt->nu-nt (NFA-min list-NT roots final)])
+    (list (map old-nt->nu-nt roots)
+          (map old-nt->nu-nt final))))
+
+(define (stage-kill-live-AVS roots final list-NT list-AVS)
+  (for-each
+   (lambda (AVS)
+     (set-AVS-edgefrom! AVS '())
+     (set-AVS-edgeto! AVS '())
+     (set-AVS-objs! AVS '())
+     (set-AVS-orig-objs! AVS '())
+     (set-AVS-constraints! AVS '()))
+   list-AVS)
+  (list roots final))
+
+(define (stage-invert-grammar roots final list-NT list-AVS)
+  (convert-productions-to-AV-etc! list-AVS)
+  (calc-productions! list-AVS 
+                     (lambda (AVS) (memq AVS list-AVS))
+                     #t
+                     #t #t #t #t
+                     #f #f)
+  (list (append (map make-LI list-AVS)
+                (map make-UI list-AVS))
+        (map make-UI (select-L roots))))
+  
+(define (stage-nothing roots final list-NT list-AVS)
+  (list roots final))
+
+(define (calc-roots-final-L->R B list-AVS use-AVS?) 
+  (calc-productions! list-AVS use-AVS?
+                     #t #f
+                     #t #t #t #t
+                     #t #f)
+  (list (map make-L B)
+        (append (map make-UI B))))
+
+(define (calc-roots-final-LU->center B list-AVS use-AVS?) 
+  (calc-productions! list-AVS use-AVS?
+                     #t
+                     #t #t #t #t
+                     #t #f)
+  (match-let*
+      ([L-B (map make-L B)]
+       [(reached _) (grammar-calc-reached L-B)]
+       ;[_ (pretty-print `(reached ,(map nt->sym reached)))]
+       [reached-L (select-L reached)]
+       ;[_ (pretty-print `(reached-L ,(map name-for-AVS reached-L)))]
+       [reached-U (select-U reached)]
+       ;[_ (pretty-print `(reached-U ,(map name-for-AVS reached-U)))]
+       [cross-over (intersect reached-L reached-U)]
+       [final (append (map make-L cross-over) 
+                      (map make-U cross-over))])
+    ;(pretty-print `(cross-over ,(map name-for-AVS cross-over)))
+    ;(pretty-print `(final ,(map nt->sym final)))
+    (list L-B final)))
+
+(define (calc-roots-final-center->out B list-AVS use-AVS?) 
+  (set! zeroary-op-AVS (mk-AVS-tmp 'zeroary-op))
+  (calc-productions! list-AVS use-AVS?
+                     #t #t
+                     #t #t #t #t
+                     #f #f)
+  (match-let*
+      ([L-B (map make-L B)]
+       [(reached _) (grammar-calc-reached L-B)]
+       ;[_ (pretty-print `(reached ,(map nt->sym reached)))]
+       [reached-L (select-L reached)]
+       ;[_ (pretty-print `(reached-L ,(map name-for-AVS reached-L)))]
+       [reached-U (select-U reached)]
+       ;[_ (pretty-print `(reached-U ,(map name-for-AVS reached-U)))]
+       [cross-over (intersect reached-L reached-U)]
+       [roots (append (list (make-UI zeroary-op-AVS))
+                      (map make-LI cross-over)
+                      (map make-UI cross-over))]
+       [final (map make-UI B)])
+    ;(pretty-print `(cross-over ,(map name-for-AVS cross-over)))
+    ;(pretty-print `(roots ,(map nt->sym roots)))
+    ;(pretty-print `(final ,(map nt->sym final)))
+    (list roots final)))
+
+(define (calc-roots-final-center->out-concrete-epsilon B list-AVS use-AVS?) 
+  (set! zeroary-op-AVS (mk-AVS-tmp 'zeroary-op))
+  (calc-productions! list-AVS use-AVS?
+                     #t #t
+                     #t #t 'concrete #t
+                     #f #f)
+  (match-let*
+      ([L-B (map make-L B)]
+       [(reached _) (grammar-calc-reached L-B)]
+       ;[_ (pretty-print `(reached ,(map nt->sym reached)))]
+       [reached-L (select-L reached)]
+       ;[_ (pretty-print `(reached-L ,(map name-for-AVS reached-L)))]
+       [reached-U (select-U reached)]
+       ;[_ (pretty-print `(reached-U ,(map name-for-AVS reached-U)))]
+       [cross-over (intersect reached-L reached-U)]
+       [roots (append (list (make-UI zeroary-op-AVS))
+                      (map make-LI cross-over)
+                      (map make-UI cross-over))]
+       [final (map make-UI B)])
+    ;(pretty-print `(cross-over ,(map name-for-AVS cross-over)))
+    ;(pretty-print `(roots ,(map nt->sym roots)))
+    ;(pretty-print `(final ,(map nt->sym final)))
+    (list roots final)))
+
+
+(define (get-AVS-select-L roots final) (select-L roots))
+
+(define (get-AVS-select-LIUI roots final) 
+  (select-UI final))
+
+; ----------------------------------------------------------------------
+
+(define calc-size
+  (lambda (str roots)
+    (match-let*
+        ([(reached-nt reached-nt?) (grammar-calc-reached roots)]
+         [reached-AVS (list->set (map nt->AVS reached-nt))])
+      (printf "==========> ~a: #nt=~s  #AVS=~s~n"
+              str
+              (length reached-nt)
+              (length reached-AVS))
+      ;;(printf "~s~n" (map name-for-AVS list-AVS))
+      (list reached-nt reached-AVS))))
+
+; --------
+
+(define resultshow (void))
+(define resultprod (void))
+
+(define (minimize-constraints list-AVS use-AVS? B strategy)
+
+  (printf "#### STRATEGY: ~s~n" strategy)
+
+  (match-let*
+      ([((calc-roots-final get-AVS) . stages) strategy]
+       [(roots final) ((eval calc-roots-final) B list-AVS use-AVS?)])
+  
+    (recur loop ([roots roots]
+                 [final final]
+                 [rest '()]
+                 [stages stages]
+                 [sizes '()])
+
+      (match stages
+        [() 
+         (match-let*
+             ([(list-NT list-AVS) (calc-size "At end" roots)])
+           (printf "Creating AV, constraints, edges from grammar~n")
+           (convert-productions-to-AV-etc! list-AVS)
+           (set! resultshow (lambda () (for-each show-AVS list-AVS)))
+           (set! resultprod (lambda () (for-each prods-AVS list-AVS)))
+           (list ((eval get-AVS) roots final)
+                 (reverse (cons (list (length list-NT) (length list-AVS))
+                                sizes))))]
+
+        [(stage . rest-stages)
+         (match-let*
+             ([(list-NT list-AVS) 
+               (calc-size (format "Before ~a" stage) roots)])
+           (match (apply (eval stage) roots final list-NT list-AVS rest)
+             [(roots final . _)
+              (loop roots final '() rest-stages
+                    (cons (list (length list-NT) (length list-AVS))
+                          sizes))]))]))))
+
+(define (minimize-all-constraints B stages)
+  (let ([n num-AVS])
+    (minimize-constraints list-AVS
+                          (lambda (AVS) (< (AVS-num AVS) n))
+                          B stages)))
+
+; ======================================================================
+
+(define (st:L files) 
+  (st:analyze files)
+  (calc-productions! list-AVS (lambda (AVS) #t)
+                     #t
+                     #t #t #t #t
+                     #t #f))
+
+(define (test-min-strategy files strategy)
+  (printf "TEST-MIN: ~s~n" files)
+  (st:flow-sensitive #f)
+  (st:if-split #f)
+  (match-let*
+      ([(_ in out) 
+        (parameterize 
+         ([mrspidey:progress-handler (mrspidey:text-progress)]
+          [mrspidey:error-handler    mrspidey:text-error])
+         (time (sba-analyze-a-file-in-out (files->file-thunk* files))))]
+       [io (map cdr (append in out))])
+    (for-each display (reverse summary))
+    (printf "Orig # AVSs: ~s~n" num-AVS)
+    (for-each 
+     (match-lambda
+      [(sym . AVS) 
+       (printf "Def: ~s,  AVS-num=~s~n" sym (AVS-num AVS))
+       (pretty-print (AVS->SDL AVS))])
+     out)
+    (match-let
+        ([(nu-defs . sizes) (time (minimize-all-constraints io strategy))])
+    
+      (printf "~n=========== Summary of final types =========~n")
+      (for-each (lambda (AVS) 
+                  (printf "AVS-num=~s~n" (AVS-num AVS))
+                  (pretty-print (AVS->SDL AVS)))
+                nu-defs)
+      sizes)))
+
+
+(define (test-min files) (test-min-strategy files default-strategy))
+
+; ======================================================================
+
+(define (to) (test-min "test/one.ss"))
+(define (ts) (test-min "test/sum.ss"))
+(define (tt) (test-min "test/test.ss"))
+
+(define test-files
+  (map (lambda (s) (string-append "mod/" s ".ss"))
+       '(
+         "TC-env"
+         "TC-parse"
+         "TC-test"
+         "TC-type"
+         "TC-eval"
+
+         "mod-env"
+         "2-1-env-list"
+         "2-22-p"
+         "2-22-tc2"
+         "mod-TC-typechk"
+         "shaft"
+         "physics"
+         "mod-gauss"
+         ;;"mod-TC-parse"
+         ;;"pcf-parse"
+         )))
+
+;     mod-interp - match
+;     pcf-tc.ss - syntax error
+;     mod-pp - match
+;     "elevator" - match
+;     mod-slatex.ss - too big
+;     mod-TC.ss - too big
+
+; ======================================================================
+
+(define strategy-L->R-NFA-min
+  '((calc-roots-final-L->R get-AVS-select-L)
+    stage-restrict-reached
+    stage-restrict-nonempty
+    ;;stage-kill-live-AVS
+    stage-N->D-notidy
+    stage-NFA-min))
+
+(define strategy-L->R-RTG-min
+  '((calc-roots-final-L->R get-AVS-select-L)
+    stage-restrict-reached
+    stage-restrict-nonempty
+    ;;stage-kill-live-AVS
+    ;;stage-N->D
+    stage-RTG-min))
+
+(define strategy-fast  
+  '((calc-roots-final-center->out-concrete-epsilon get-AVS-select-LIUI)
+    stage-restrict-reached
+    stage-restrict-nonempty
+    ;;stage-kill-live-AVS
+    ;stage-N->D-notidy
+    ;stage-RTG-min
+    stage-DFA-min
+    )) 
+
+(define default-strategy 
+  '((calc-roots-final-L->R get-AVS-select-L)
+    ;;stage-restrict-reached
+    ;;stage-restrict-nonempty
+    ;;stage-kill-live-AVS
+    ;;stage-N->D
+    ;;stage-RTG-min
+    ))
+;(define default-strategy strategy-fast)
+
+(define strategy-options
+  '(((calc-roots-final-L->R get-AVS-select-L)
+     (calc-roots-final-center->out get-AVS-select-LIUI)
+     )
+    stage-restrict-reached
+    stage-restrict-nonempty
+    (stage-N->D stage-N->D-notidy stage-nothing)
+    (stage-RTG-min stage-NFA-min stage-DFA-min stage-nothing)
+    ))
+
+(define strategy-options
+  '(((calc-roots-final-center->out-concrete-epsilon get-AVS-select-LIUI)
+     (calc-roots-final-L->R get-AVS-select-L)
+     (calc-roots-final-center->out get-AVS-select-LIUI)
+     )
+    stage-restrict-reached
+    stage-restrict-nonempty
+    (stage-DFA-min stage-RTG-min stage-NFA-min stage-nothing)
+    ))
+    
+(define test-strategies
+  (recur loop ([opt strategy-options])
+    (match opt
+      [() '(())]
+      [((? pair? opt1) . rest)
+       (let ([rest (loop rest)])
+         (apply append
+                (map (lambda (r)
+                       (map (lambda (o) (cons o r)) opt1))
+                     rest)))]
+      [(x . rest) (map (lambda (r) (cons x r))
+                       (loop rest))])))
+
+; ======================================================================
+
+(define (test-min-files)
+  (mapLR
+   (lambda (file)
+     (printf "============================================================~n")
+     (let ([r (test-min file)])
+       (pretty-print r)
+       r))
+   test-files))
+
+(define (test-min-strategies)
+  (map (lambda (s)
+         (printf "#########################################################~n")
+         (set! default-strategy s)
+         (list s (test-min-files)))
+       test-strategies))
+
+;(trace NFA-min)
+;(trace calc-LI-UI!)
+;(trace make-minimization-algorithm)
+;(trace minimize-constraints)
+;(trace grammar-calc-nonempty)
+
+(define (summarize l)
+  (map
+   (match-lambda
+    [(desc nums)
+     (let ([last-pairs (map (lambda (x) (rac (car x))) nums)])
+       (list desc 
+             (apply + (map car last-pairs))
+             (apply + (map cadr last-pairs))))])
+   l))
diff --git a/collects/mrspidey/Sba/min/hopcroft.ss b/collects/mrspidey/Sba/min/hopcroft.ss
new file mode 100644
index 0000000..8951f77
--- /dev/null
+++ b/collects/mrspidey/Sba/min/hopcroft.ss
@@ -0,0 +1,246 @@
+;; dfa-min.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ======================================================================
+;; CHANGES
+;; 01.11.96: Commented out hack to put all partitions on worklist initially
+;; ======================================================================
+
+(define-typed-structure state-aux (eqvcl prev next touched))
+(define-typed-structure dfa-eqvcl (states count on-worklist touched))
+
+;(define inv-delta-traversal-timer (make-timer))
+;(define Fn-a-timer     (make-timer))
+;(define finish-a-timer (make-timer))
+
+;; ======================================================================
+
+(define (Hopcroft-calc-equivalences States seperate
+                                    inv-delta-traversal
+                                    state-aux set-state-aux! state->rep)
+
+  ;; states must have an aux field with set-state-aux! and state-aux fns
+  ;; seperate is a list of list of States
+  ;; any partition must be included in some element of seperate
+  
+  ;; inv-delta-traversal: P(states) (Sigma P(states) -> void) -> void
+  ;; inv-delta-traversal(X, Fn)
+  ;; => Fn is called with all pairs (a,C) where C = { s | delta(s,sigma) in X}
+
+  (pretty-debug-dfa-min 
+   `(States ,(map state->rep States)))
+  (pretty-debug-dfa-min
+   `(seperate ,(map (lambda (c) (map state->rep c)) seperate)))
+
+  (for-each 
+   (lambda (s) (set-state-aux! s (make-state-aux (void) (void) (void) #f)))
+   States)
+  
+  (for-each
+   (lambda (c)
+     (for-each
+       (lambda (s) (assert (state-aux? (state-aux s)) 1 (state->rep s)))
+       c))
+   seperate)
+
+  (let* 
+      ( [t (lambda (s) 
+          (when timing-min (min-record-progress (cons 'hopcroft s))))]
+        [_ (t 0)]
+        [state-prev  (lambda (s) (state-aux-prev  (state-aux s)))]
+        [state-next  (lambda (s) (state-aux-next  (state-aux s)))]
+        [state-eqvcl (lambda (s) (state-aux-eqvcl (state-aux s)))]
+        [state-touched (lambda (s) (state-aux-touched (state-aux s)))]
+        [set-state-prev! (lambda (s p) (set-state-aux-prev!  (state-aux s) p))]
+        [set-state-next! (lambda (s p) (set-state-aux-next!  (state-aux s) p))]
+        [set-state-eqvcl! (lambda (s p) (set-state-aux-eqvcl! (state-aux s) p))]
+        [set-state-touched! 
+          (lambda (s p) (set-state-aux-touched! (state-aux s) p))]
+
+        [partition '()]
+        [mk-empty-eqvcl 
+          (lambda () 
+            (let ([X (make-dfa-eqvcl '() 0 #f '())])
+              (set! partition (cons X partition))
+              X))]
+
+        [add-to-eqvcl!
+          (lambda (X s)
+            (let ([first (dfa-eqvcl-states X)])
+              (set-state-next! s first)
+              (unless (null? first) (set-state-prev! first s))
+              (set-dfa-eqvcl-states! X s)
+              (set-state-prev! s X)
+              (set-state-eqvcl! s X)
+              (set-dfa-eqvcl-count! X (add1 (dfa-eqvcl-count X)))))]
+        [remove-from-eqvcl!
+          (lambda (X s)
+            (assert (eq? (state-eqvcl s) X))
+            (let ([prev (state-prev s)]
+                   [next (state-next s)])
+              (unless (null? next) (set-state-prev! next prev))
+              (if (dfa-eqvcl? prev)
+                (set-dfa-eqvcl-states! prev next)
+                (set-state-next! prev next))
+              (set-dfa-eqvcl-count! X (sub1 (dfa-eqvcl-count X)))))]
+        [eqvcl->list
+          (lambda (c)
+            (recur loop ([state (dfa-eqvcl-states c)])
+              (if (null? state)
+                '()
+                (cons state (loop (state-next state))))))]
+
+        [worklist '()]
+        [add-to-worklist!
+          (lambda (X)
+            (assert (not (dfa-eqvcl-on-worklist X)))
+            (set! worklist (cons X worklist))
+            (set-dfa-eqvcl-on-worklist! X #t))]
+
+        [split
+          (lambda (generate-split-states)
+
+            ;; Change so each partition totally included or excluded in states
+            ;; See Cliff Click's thesis, page ~40.
+             
+            (pretty-debug-dfa-min `(split))
+ 
+            (let* ([touched '()])
+              (begin0
+                (generate-split-states
+                  (lambda (s)
+                    (pretty-debug-dfa-min
+                      `(add-split ,(state->rep s) ,(state-aux s)))
+                    (assert (state-aux? (state-aux s))
+                      2 (state->rep s) (state-aux s))
+                    (let* ([s-eqvcl (state-eqvcl s)])
+                      (when (null? (dfa-eqvcl-touched s-eqvcl))
+                        (set! touched (cons s-eqvcl touched))
+                        (assert (not (state-touched s))))
+                      (unless (state-touched s)
+                        ;;(assert (not (memq s (dfa-eqvcl-touched s-eqvcl))))
+                        (set-dfa-eqvcl-touched!
+                          s-eqvcl 
+                          (cons s (dfa-eqvcl-touched s-eqvcl)))
+                        (set-state-touched! s #t)))))
+                (for-each
+                  (lambda (Z)    
+
+                    (pretty-debug-dfa-min
+                      `(touched
+                         ,(map state->rep (eqvcl->list Z))
+                         ,(map state->rep (dfa-eqvcl-touched Z))
+                         ,(= (dfa-eqvcl-count Z) 
+                            (length (dfa-eqvcl-touched Z)))))
+                    (if (= (dfa-eqvcl-count Z) 
+                          (length (dfa-eqvcl-touched Z)))
+
+                      ;; No need to change, just clear touched
+                      (for-each (lambda (s) (set-state-touched! s #f))
+                        (dfa-eqvcl-touched Z))
+
+                      ;; Need to make new eqvcl 
+                      (let ([nu (mk-empty-eqvcl)])
+                        ;;(printf ".") (flush-output)
+                        (for-each
+                          (lambda (s) 
+                            (remove-from-eqvcl! Z s)
+                            (set-state-touched! s #f)
+                            (add-to-eqvcl! nu s))
+                          (dfa-eqvcl-touched Z))
+                        (assert (not (null? (dfa-eqvcl-states Z))))
+                        (assert (not (null? (dfa-eqvcl-states nu))))
+                        (cond
+                          [(dfa-eqvcl-on-worklist Z)
+                            (add-to-worklist! nu)]
+                          [(< (dfa-eqvcl-count nu) (dfa-eqvcl-count Z))
+                            (add-to-worklist! nu)
+                            ;; Kludge cause not complete grammar
+                            (add-to-worklist! Z)
+                            ]
+                          [else
+                            (add-to-worklist! Z)
+                            ;; Kludge cause not complete grammar
+                            (add-to-worklist! nu)
+                            ])))
+                    (set-dfa-eqvcl-touched! Z '()))
+                  touched))))])
+
+    (t 1)
+    (let ([base-eqvcl (mk-empty-eqvcl)])
+      (for-each (lambda (s) (add-to-eqvcl! base-eqvcl s))
+                States))
+
+    (t 2)
+    (for-each
+      (lambda (nts) (split (lambda (add-split!) (for-each add-split! nts))))
+      seperate)
+
+    
+    (t 3)
+    ;; ### HACK ###
+    ;; Put all partitions on the worklist 
+    '(for-each
+       (lambda (eqvcl)
+         (unless (dfa-eqvcl-on-worklist eqvcl)
+           (add-to-worklist! eqvcl)))
+       partition)
+    ;; ### END HACK ###
+
+    (t 4)
+    (recur loop ()
+      ;; partition a partition of States union Final
+      ;; All equiv states in same eqvcl
+      ;; If s1,s2 in eqvcl B with si->a.si', and si' in Bi
+      ;; then either B1=B2, or (Bi,a) in worklist for one of i=1,2
+
+      (unless (null? worklist)
+        (let* ([X (car worklist)])
+          (set! worklist (cdr worklist))
+          (set-dfa-eqvcl-on-worklist! X #f)
+          (inv-delta-traversal (eqvcl->list X) split)
+          (loop))))
+    (t 5)
+
+    ;; All done
+    ;; Return mapping from states to representative states,
+    ;; and a mapping from states to a list of equiv states
+    ;; and an equiv predicate on states
+    ;; and a list of representative states
+
+    (values
+     (lambda (s) (dfa-eqvcl-states (state-eqvcl s)))
+     (lambda (s) (eqvcl->list (state-eqvcl s)))
+     (lambda (s1 s2) (eq? (state-eqvcl s1) (state-eqvcl s2)))
+     (filter-map (lambda (X) 
+                   (let ([rep (dfa-eqvcl-states X)])
+                     (if (null? rep) #f rep)))
+                 partition))))
+
+;; ----------------------------------------------------------------------
+;; Prototypical inputs
+
+'(define-type dfa-state (box void))
+'(MrSpidey-test
+  (calc-equivalences (type: (listof dfa-state))
+                     (type: (listof dfa-state))
+                     (type: (_ (-> (list (dfa-state -> void) (-> void)))
+                               -> void))
+                     unbox
+                     set-box!))
+;(trace calc-equivalences)
+
diff --git a/collects/mrspidey/Sba/min/livefewe.ss b/collects/mrspidey/Sba/min/livefewe.ss
new file mode 100644
index 0000000..73160b4
--- /dev/null
+++ b/collects/mrspidey/Sba/min/livefewe.ss
@@ -0,0 +1,215 @@
+;; File: min-live-few-e.ss
+;; Can optimize later when sure only want min-live-few-e-L
+;; ======================================================================
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; CHANGES:
+;;
+;; (null? (Tvar-constraints tvar)) 
+;; -> (andmap con-filter? (Tvar-constraints tvar))
+;;
+;; rhs-nts not filter w/ live-nt?
+;;
+;; ======================================================================
+(define-typed-structure Tvar-class (parent L-unif U-unif children))
+
+;; tvars is binary tree w/ tvar at leaves 
+
+; ======================================================================
+; minimize-constraints-live-few-e
+;
+; Input:  lower : list Tvar
+;         upper : list Tvar
+
+(define (copy-live-constraints-few-e L-unif U-unif)
+  (lambda (lower upper)
+
+    (pretty-debug-few 
+      `(copy-live-constraints-few-e
+         lower ,(map Tvar-name lower)
+         upper ,(map Tvar-name upper)))
+
+    ;; Calc edgefrom
+    ;; Calculate live Tvar and live NT
+    ;; Only use Tvar-orig-objs
+    ;; Flag NTs with non-epsilon edges
+
+    (let*-vals
+      ( [t (lambda (s) 
+             (when timing-min
+               (min-record-progress (cons 'copy-live-constraints-few-e s))))]
+        [_ (t 0)]
+       
+        ;; --- Calc empty and live
+        ;; not empty == reached
+        [(live-nts live-nt? live-tvars live-tvar? _ _ rhs-nts)
+          (calc-live-tvars-nts lower upper #f)]
+        [_ (t 1)]
+        [_ (pretty-debug-few `(live-nts ,(map nt->sym live-nts)))]
+        [_ (pretty-debug-few `(live-tvars ,(map Tvar-name live-tvars)))]
+        [rhs-nts
+          (lambda (nt)
+            (filter (lambda (x) (or (eq? x #t) (live-nt? x))) (rhs-nts nt)))]
+
+        ;; Now unify to equiv classes.
+        ;; Define AV `a' to be L-unifiable iff 
+        ;;     con(a) = 0     and 
+        ;;     #outedge(a)=1  and
+        ;;     # prods for LaU = 1
+        ;;  But aU -> bU is not counted in rhs-nts(aU)
+        ;;     => require rhs-nts(aU) = 0
+        ;;
+        ;; Define AV `b' to be U-unifiable iff
+        ;;     AV(a) = AV(b) for all predecessors a of b
+        ;;     #inedge(b)<=1  and
+        ;;     # prods for LbL = 1
+        ;;
+        ;; If a <= b and either a L-unif or b U-unif, then unify
+
+        ;; Unify to equivalence classes
+        [(tvar-class set-tvar-class!) (alloc-Tvar-field)]
+        [_ (t 3)]
+        [_ (for-each 
+             (lambda (tvar)
+               (pretty-debug-few `(Tvar ,(Tvar-name tvar)))
+               (let* ([pretty-and
+                        (lambda args
+                          (let ([r (andmap (lambda (x) x) args)])
+                            (pretty-debug-few `((and ,@args) ,r))
+                            r))]
+                       [L-u (pretty-and
+                              L-unif
+                              (andmap
+                                (match-lambda
+                                  [($ con _ _ _ tvar) (not (live-tvar? tvar))]
+                                  [($ con-filter) #t])
+                                (Tvar-constraints tvar))
+                              (let ([out 
+                                      (append
+                                        (filter-map
+                                          (match-lambda
+                                            [($ con) #f]
+                                            [($ con-filter _ _ tvar)
+                                              (and (live-tvar? tvar) tvar)])
+                                          (Tvar-constraints tvar))
+                                        (filter live-tvar? 
+                                          (Tvar-edgeto tvar)))])
+                                (or (null? out) (null? (cdr out))))
+                              (let ([nt (Tvar-U tvar)])
+                                (or (not (live-nt? nt))
+                                  (let ([s (rhs-nts nt)])
+                                    (pretty-debug-few
+                                      `(rhs-nts 
+                                         ,(map
+                                            (lambda (nt)
+                                              (or (eq? nt #t) (nt->sym nt)))
+                                            s)))
+                                    (null? s)
+                                    ;;(or (null? s) (null? (cdr s)))
+                                    )))
+                              ; Ignore lower, upper
+                              ; Already counted in rhs-nts
+                              ;(not (memq tvar lower))
+                              ;(not (memq tvar upper))
+                              )]
+                       [U-u 
+                         (let ( [in (Tvar-edgefrom tvar)])
+                           (pretty-and
+                             U-unif
+                             (or (null? in)
+                               (and (null? (cdr in))
+                                 (<= (length (Tvar-objs tvar))
+                                   (length (Tvar-objs (car in))))))
+                             (let ([nt (Tvar-L tvar)])
+                               (or (not (live-nt? nt))
+                                 (let ([s (rhs-nts nt)])
+                                   (pretty-debug-few
+                                     `(rhs-nts 
+                                        ,(map
+                                           (lambda (nt)
+                                             (or (eq? nt #t) (nt->sym nt)))
+                                           s)))
+                                   (or (null? s) (null? (cdr s)))
+                                   )))
+                                        ;(not (memq tvar lower))
+                                        ;(not (memq tvar upper))
+                             ))])
+                   
+                 (set-tvar-class! tvar (make-Tvar-class #f L-u U-u tvar))))
+             live-tvars)]
+        [_ (t 4)]
+        [get-class
+          (lambda (tvar)
+            (recur loop ([c (tvar-class tvar)])
+              (assert (or (Tvar-class? (Tvar-class-parent c))
+                        (eq? #f (Tvar-class-parent c))))
+              (if (Tvar-class-parent c)
+                (loop (Tvar-class-parent c))
+                c)))]
+        [_ (for-each
+             (lambda (b)
+               (for-each
+                 (lambda (a)
+                   (when (live-tvar? a)
+                     (match (get-class a)
+                       [(and cl-a
+                          ($ Tvar-class _ L-unif-a U-unif-a kids-a))
+                         (assert (eq? (Tvar-class-parent cl-a) #f) 
+                           (Tvar-class-parent cl-a))
+                         (match (get-class b)
+                           [(and cl-b 
+                              ($ Tvar-class _ L-unif-b U-unif-b kids-b))
+                             (pretty-debug-few
+                               `(epsilon ,(Tvar-name a)
+                                  ,(Tvar-name b)
+                                  ,L-unif-a
+                                  ,L-unif-b
+                                  ,U-unif-a
+                                  ,U-unif-b))
+                             (when (or L-unif-a U-unif-b)
+                               ;; Unify
+                               (let ([nu-cl
+                                       (make-Tvar-class #f
+                                         (and L-unif-a L-unif-b)
+                                         (and U-unif-a U-unif-b)
+                                         (cons kids-a kids-b))])
+
+                                 (assert (eq? (Tvar-class-parent cl-a) #f) 2)
+                                 (assert (eq? (Tvar-class-parent cl-b) #f))
+                                 (set-Tvar-class-parent! cl-a nu-cl)
+                                 (set-Tvar-class-parent! cl-b nu-cl)
+                                 (assert (eq? (get-class a) (get-class b)))
+                                 ))])])))
+                 (Tvar-edgefrom b)))
+             live-tvars)]
+        [_ (t 4.5)]
+        )
+      ;; --- Have equiv classes, now copy
+      ;; --- return arguments for copy-constraints-equiv!
+      (values
+        (append lower upper live-tvars)
+        live-tvar?
+        live-nts
+        (lambda (tvar)
+          (recur loop ([k (Tvar-class-children (get-class tvar))][a '()])
+            (if (Tvar? k)
+              (cons k a)
+              (loop (car k) (loop (cdr k) a)))))
+        (lambda (AV) (list AV))))))
+
+;; ======================================================================
+
diff --git a/collects/mrspidey/Sba/min/min-dfa.ss b/collects/mrspidey/Sba/min/min-dfa.ss
new file mode 100644
index 0000000..07e28e3
--- /dev/null
+++ b/collects/mrspidey/Sba/min/min-dfa.ss
@@ -0,0 +1,490 @@
+; ======================================================================
+; minimize-constraints-dfa-min-fast
+;
+; Input:  lower : list Tvar
+;         upper : list Tvar
+;
+; see practical.tex
+; ======================================================================
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define (minimize-constraints-dfa-min-fast
+          lower upper 
+          helper-fn)
+
+  (pretty-debug-dfa-min 
+    `(minimize-constraints-dfa-min-fast
+       lower ,(map Tvar-name lower)
+       upper ,(map Tvar-name upper)))
+
+  (let*-vals
+    ([t (lambda (s) 
+          (when timing-min 
+            (min-record-progress 
+              (cons 'minimize-constraints-dfa-min-fast s))))]
+      [_ (t 0)]
+
+      [(live-tvars live-tvar? live-nts tvar->equiv AV->equiv)
+        ((copy-live-constraints-few-e #t #t) lower upper)]
+      [_ (t 1)]
+
+      ;; Figure out representative elements for Tvars,
+      ;; and live AV
+      [(tvar->rep set-tvar-rep!) (alloc-Tvar-field)]
+      [(is-rep? add-rep! get-list-rep) (field->set alloc-Tvar-field)]
+      [(live-AV? set-live-AV! get-live-AVs) (field->set alloc-AV-field)]
+      [_ (for-each
+           (lambda (tvar)
+             (for-each set-live-AV! (get-Tvar-objs tvar))
+             (unless (tvar->rep tvar)
+               (add-rep! tvar)
+               (for-each 
+                 (lambda (eq) (set-tvar-rep! eq tvar))
+                 (tvar->equiv tvar))
+               (assert (tvar->rep tvar))))
+           live-tvars)]
+      [live-AVs (get-live-AVs)]
+      [rep-tvars (get-list-rep)]
+      [_ (t 2)]
+
+      ;; states = rep-tvars + live-AVs + dummy-tvar
+      [dummy-tvar (mk-Tvar 'Grammar-dummy)]
+      [all-states (append rep-tvars (list dummy-tvar) live-AVs)]
+      [state->sym (lambda (state) 
+                    (cond
+                      [(Tvar? state) (Tvar-name state)]
+                      [(AV? state) (AV->rep state)]
+                      [else (error 'state->sym "Bad state ~s" state)]))]
+
+      [grsym-eq?
+        (lambda (g1 g2)
+          ;; (andmap eq? g1 g2)
+          (recur loop ([g1 g1][g2 g2])
+            (if (null? g1)
+              (null? g2)
+              (if (null? g2)
+                #f
+                (and (eq? (car g1) (car g2))
+                  (loop (cdr g1) (cdr g2)))))))]
+
+      ;; mapping from grsyms to numbers
+      [num-grsym 0]
+      [grsym-table '()]
+      [grsym->number
+        (lambda (g1)
+          (or
+            (ormap
+              (match-lambda
+                [(n . g2) (and (grsym-eq? g1 g2) n)]
+                [_ #f])
+              grsym-table)
+            (begin
+              (set! grsym-table (cons (cons num-grsym g1) grsym-table))
+              (begin0
+                num-grsym
+                (set! num-grsym (add1 num-grsym))))))]
+
+      [(tvar-EF-epsilon set-tvar-EF-epsilon!)
+        (alloc-Tvar-field (lambda () '()))]
+      [(tvar-EF set-tvar-EF!)
+        (alloc-Tvar-field (lambda () '()))]
+      [(AV-EF-epsilon set-AV-EF-epsilon!)
+        (alloc-AV-field (lambda () '()))]
+      [(AV-EF set-AV-EF!)
+        (alloc-AV-field (lambda () '()))]
+
+      [add-tvar-EF! 
+        (lambda (tvar g1 s1)
+          (let* ( [tvar (tvar->rep tvar)]
+                  [n1 (grsym->number g1)]
+                  [x (tvar-EF tvar)])
+            (unless (ormap 
+                      (match-lambda [(n2 . s2) (and (= n1 n2) (eq? s1 s2))])
+                      x)
+              (set-tvar-EF! tvar (cons (cons n1 s1) x)))))]
+      [add-AV-EF! 
+        (lambda (AV g1 s1)
+          (let ( [x (AV-EF AV)]
+                 [n1 (grsym->number g1)])
+            (unless (ormap 
+                      (match-lambda [(n2 . s2) (and (= n1 n1) (eq? s1 s2))])
+                      x)
+              (set-AV-EF! AV (cons (cons n1 s1) x)))))]
+      [add-tvar-EF-epsilon!
+        (lambda (tvar s1)
+          (let* ( [tvar (tvar->rep tvar)]
+                  [x (tvar-EF-epsilon tvar)])
+            (unless (memq s1 x)
+              (set-tvar-EF-epsilon! tvar (cons s1 x)))))]
+      [add-AV-EF-epsilon!
+        (lambda (AV s1)
+          (let ([x (AV-EF-epsilon AV)])
+            (unless (memq s1 x)
+              (set-AV-EF-epsilon! AV (cons s1 x)))))]
+      [state-EF-epsilon
+        (lambda (state)
+          (if (AV? state) 
+            (AV-EF-epsilon state)
+            (tvar-EF-epsilon state)))]
+      [state-EF
+        (lambda (state)
+          (if (AV? state) 
+            (AV-EF state)
+            (tvar-EF state)))]
+      [_ (t 2.1)]
+
+      ;; helper-fn sets things up for inv-delta-traversal
+      ;; Sets U field of each state to:
+      ;;     (listof (cons (listof any) state))
+
+      [extra-seperate (helper-fn live-tvars live-tvar? tvar->rep live-AVs
+                        add-tvar-EF! add-tvar-EF-epsilon!
+                        add-AV-EF! add-AV-EF-epsilon!)]
+      [_ (t 3)]
+
+      ;; Show productions
+      [_ (pretty-debug-dfa-min
+           `(productions
+              ,(map 
+                 (lambda (state)
+                   (list (state->sym state)
+                     (map state->sym (state-EF-epsilon state))
+                     (map
+                       (match-lambda [(g . s) (cons g (state->sym s))])
+                       (state-EF state))))
+                 all-states)))]
+
+      ;; Vector of buckets for productions
+      [buckets (make-vector num-grsym '())]
+      [_ (min-record-progress (cons 'num-buckets num-grsym))]
+
+      ;; inv-delta-traversal: 
+      ;;          P(states) x (P(states) -> void) -> void
+      ;; inv-delta-traversal(X, split)
+      ;; => no equiv class partially in X
+      ;; => Call split with each "partition of equiv classes" ...
+      ;; For effeciency, we call split with a "generator" for the set C_a
+      ;; The generator is passed a function add-split!, and then
+      ;; calls add-split! on each state in C_a
+
+      ;; --- Set things up for Hopcrofts Algorithm
+
+      ;; Condition 1, thms hopcroft lub and glb
+      ;; Also, to make up for grammar being "incomplete",
+      ;; seperate states into equiv classes so states in same equiv class
+      ;; have productions on same grammar symbols
+
+      [seperate-grsyms (make-vector num-grsym '())]
+      [seperate-epsilon '()]
+      [_ (for-each
+           (lambda (state)
+             (when (not (null? (state-EF-epsilon state)))
+               (set! seperate-epsilon (cons state seperate-epsilon)))
+             (for-each
+               (match-lambda
+                 [(g . s)
+                   (vector-set! seperate-grsyms g
+                     (cons s (vector-ref seperate-grsyms g)))])
+               (state-EF state)))
+           all-states)]
+      [_ (pretty-debug-dfa-min
+           `(seperate-epsilon ,(map state->sym seperate-epsilon)))]
+      [_ (pretty-debug-dfa-min
+           `(seperate-grsyms 
+              ,(map 
+                 (lambda (s) (map state->sym s))
+                 (vector->list seperate-grsyms))))]
+      [seperate (append
+                  (list rep-tvars)
+                  (list live-AVs)
+                  extra-seperate
+                  ;(map list lower)
+                  ;(map list upper)
+                  (list seperate-epsilon)
+                  (vector->list seperate-grsyms))]
+      [seperate (filter 
+                  (lambda (l) (not (null? l)))
+                  seperate)]
+      [_ (pretty-debug-dfa-min
+           `(seperate ,(map (lambda (s) (map state->sym s)) seperate)))]
+      [_ (t 4)]
+
+      [inv-delta-traversal
+        (lambda (states split)
+          (pretty-debug-dfa-min 
+            `(inv-delta-trav 
+               ,(map (lambda (state)
+                       `(,(state->sym state)
+                          (epsilon 
+                            ,(map state->sym (state-EF-epsilon state)))
+                          ,(map
+                             (match-lambda [(g . s) (cons g (state->sym s))])
+                             (state-EF state))))
+                  states)))
+          ;; Do epsilons
+          (split 
+            (lambda (add-split!)
+              (for-each
+                (lambda (state)
+                  (for-each 
+                    add-split!
+                    (state-EF-epsilon state)))
+                states)))
+
+          ;; Put rest into buckets
+          (let ([bucket-ndxs '()])
+            (for-each
+              (lambda (state)
+                (for-each
+                  (match-lambda
+                    [(n . s)
+                      (let ([old (vector-ref buckets n)])
+                        (vector-set! buckets n (cons s old))
+                        (when (null? old)
+                          (set! bucket-ndxs (cons n bucket-ndxs))))])
+                  (state-EF state)))
+              states)
+            ;; Run thru buckets ...
+            (for-each
+              (lambda (i)
+                (let ([s* (vector-ref buckets i)])
+                  (split (lambda (add-split!) (for-each add-split! s*)))
+                  (vector-set! buckets i '())))
+              bucket-ndxs)))]
+
+      [(state-aux set-state-aux!) (alloc-NT-field)]
+      [(state->rep state->equiv equiv-state? list-rep-states)
+        (Hopcroft-calc-equivalences 
+          all-states
+          seperate
+          inv-delta-traversal
+          state-aux set-state-aux! state->sym)]
+      [_ (t 5)]
+
+      [_ (begin
+           (pretty-debug-dfa-min
+             `(list-rep-state ,(map state->sym list-rep-states)))
+           (pretty-debug-dfa-min
+             `(state->equiv
+                ,(map (lambda (state) 
+                        (map state->sym (state->equiv state)))
+                   list-rep-states))))]
+
+      ;; ----------------------------------------
+      ;; Have equivalence relation on states
+      ;; Combine w/ previous relation on Tvars
+      ;; Convert to equivalence relation on Tvars
+
+      [tvar->equiv
+        (lambda (tvar)
+          (let ([r (apply append (map tvar->equiv (state->equiv tvar)))])
+            (pretty-debug-dfa-min 
+              `(tvar->equiv ,(state->sym tvar) = ,(map state->sym r)))
+            r))]
+
+      [AV->equiv
+        (lambda (x)
+          (pretty-debug-dfa-min `(AV->equiv ,(state->sym x)))
+          (let ([e (state->equiv x)])
+            (pretty-debug-dfa-min 
+              `(AV->equiv ,(state->sym x) = ,(map state->sym e)))
+            e))]
+      [_ (t 6)])
+
+    (copy-constraints-equiv!
+      live-tvars
+      live-tvar?
+      live-nts
+      tvar->equiv
+      AV->equiv)))
+
+;; ======================================================================
+
+(define (minimize-constraints-dfa-min-lub lower upper)
+  (minimize-constraints-dfa-min-fast lower upper 
+
+    ;; helper-fn
+    ;; helper-fn sets things up for inv-delta-traversal
+    ;; Sets U field of each state to:
+    ;;     (listof (cons (listof any) state))
+
+    (lambda (live-tvars live-tvar? tvar->rep live-AVs
+              add-tvar-EF! add-tvar-EF-epsilon!
+              add-AV-EF! add-AV-EF-epsilon!)
+
+      (for-each
+        (lambda (tvar)
+
+          ;; --- Condition 2
+          ;; If [a <= b] => forall a'~a exists b'~b st [a' <= b']
+          (for-each
+            (lambda (from) 
+              (when (live-tvar? from)
+                (add-tvar-EF-epsilon! tvar (tvar->rep from))))
+            (Tvar-edgefrom tvar))
+          (for-each
+            (lambda (AV) (add-tvar-EF-epsilon! tvar AV))
+            (get-Tvar-objs tvar))
+
+          ;; --- Conditions 4 and 5
+          (for-each
+            (match-lambda
+              [($ con _ template field alpha sign)
+                (when (live-tvar? alpha)
+                  (if sign
+                    ;; [rng(tvar) <= alpha]
+                    (add-tvar-EF! alpha
+                      (list 'R4 template field) (tvar->rep tvar))
+                    (when #t ;; (follow-antimono-fields template)
+                      ;; Condition 5
+                      ;; At bottom we put beta (or tvar) in own equiv class
+                      ;; [alpha <= dom(tvar)]
+                      (add-tvar-EF! tvar 
+                        (list 'R5 template field) (tvar->rep alpha)))))]
+              [_ (void)])
+            (Tvar-constraints tvar)))
+        live-tvars)
+
+      (for-each
+        (match-lambda
+          [(and AV ($ AV _ template _ fields+ fields-))
+            ;; --- Condition 3
+            (for i 0 (vector-length fields+)
+              (let ([field (vector-ref fields+ i)])
+                (when (live-tvar? field)
+                  (add-AV-EF! AV
+                    (list 'R3 template i) (tvar->rep field)))))])
+        live-AVs)
+
+      ;; extra partitions
+      (append
+        ;; Put each beta st [alpha <= dom(beta)] in separate equiv class
+        (map list
+          (map tvar->rep
+            (filter
+              (lambda (tvar)
+                (ormap
+                  (match-lambda
+                    [($ con _ template field alpha #f)
+                      (live-tvar? alpha)]
+                    [_ #f])
+                  (Tvar-constraints tvar)))
+              live-tvars)))
+
+        ;; put AVs into equiv class according to templates
+        ;; h maps templates to list of AVs
+        (let ([h (make-hash-table)])
+          (for-each
+            (lambda (AV)
+              (let ([t (AV-template AV)])
+                (hash-table-put! h t
+                  (cons AV (hash-table-get h t (lambda () ()))))))
+            live-AVs)
+          (hash-table-map h
+            (lambda (t AVs) AVs))))
+        
+      )))
+
+;; ======================================================================
+
+(define (minimize-constraints-dfa-min-glb lower upper)
+  (minimize-constraints-dfa-min-fast lower upper 
+
+    ;; helper-fn
+    ;; helper-fn sets things up for inv-delta-traversal
+    ;; Sets U field of each state to:
+    ;;     (listof (cons (listof any) state))
+
+    (lambda (live-tvars live-tvar? tvar->rep live-AVs
+              add-tvar-EF! add-tvar-EF-epsilon!
+              add-AV-EF! add-AV-EF-epsilon!)
+
+        (for-each
+          (lambda (tvar)
+
+            ;; --- Condition 2
+            ;; If [a <= b] => forall b'~b exists a'~a st [a' <= b']
+            (for-each
+              (lambda (from) 
+                (when (live-tvar? from)
+                  (add-tvar-EF-epsilon! from (tvar->rep tvar))))
+              (Tvar-edgefrom tvar))
+            (for-each
+              (lambda (AV) (add-AV-EF-epsilon! AV (tvar->rep tvar)))
+              (get-Tvar-objs tvar))
+
+            ;; --- Condition 4
+            (for-each
+              (match-lambda
+                [($ con _ template field alpha #t)
+                  (when (live-tvar? alpha)
+                    ;; [rng(tvar) <= alpha]
+                    (add-tvar-EF! tvar
+                      (list 'R4 template field) (tvar->rep alpha)))]
+                [_ (void)])
+              (Tvar-constraints tvar)))
+          live-tvars)
+
+        (for-each
+          (match-lambda
+            [(and AV ($ AV _ template _ fields+ fields-))
+              ;; --- Condition 3
+              (for i 0 (vector-length fields+)
+                (let ([field (vector-ref fields+ i)])
+                  (when (live-tvar? field)
+                    (add-tvar-EF! field (list 'R3 template i) AV))))
+              ;; --- Condition 5
+              (when (follow-antimono-fields template)
+                (for i 0 (vector-length fields-)
+                  (let ([field (vector-ref fields- i)])
+                    (when (live-tvar? field)
+                      ;; [dom(AV) <= field]
+                      ;; At bottom we put AV in own equiv class
+                      (add-AV-EF! AV 
+                        (list 'R5 template i) (tvar->rep field))))))])
+          live-AVs)
+
+        ;; Conditions 5,6, thm 1.2
+        ;; extra partitioning
+      (append
+        ;; Conditions 5, thm 1.2
+        (filter-map
+          (match-lambda
+            [(and AV ($ AV _ template _ _ fields-))
+              (and 
+                (follow-antimono-fields template)
+                (> (vector-length fields-) 0)
+                (list AV))])
+          live-AVs)
+        ;; Conditions 6, thm 1.2
+        (let ([h (make-hash-table)])
+          (for-each
+            (match-lambda
+              [(and AV ($ AV _ template))
+                (hash-table-put! h template
+                  (cons AV 
+                    (hash-table-get h template (lambda () '()))))])
+            live-AVs)
+          (hash-table-map h
+            (lambda (template AVs) AVs)))))))
+
+;; ======================================================================
+
+
+
+
diff --git a/collects/mrspidey/Sba/min/min-live.ss b/collects/mrspidey/Sba/min/min-live.ss
new file mode 100644
index 0000000..ec62c11
--- /dev/null
+++ b/collects/mrspidey/Sba/min/min-live.ss
@@ -0,0 +1,580 @@
+; ======================================================================
+; copy-live-constraints
+;
+; Input:  lower : list Tvar
+;         upper : list Tvar
+;
+; Copies live constraints
+; returns list-nu Tvar->nu
+; ======================================================================
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define (copy-live-constraints lower upper)
+
+  (pretty-debug-min 
+    `(copy-live-constraints ,(map Tvar-name lower) ,(map Tvar-name upper)))
+
+  (let*-vals 
+    ( [(live-nts live-nt? live-tvars live-tvar? _ _ _)
+        (calc-live-tvars-nts lower upper #f)])
+
+    (copy-constraints-equiv! 
+      (append lower upper live-tvars)
+      live-tvar? live-nts
+      (lambda (tvar) (list tvar))
+      (lambda (AV) (list AV)))))
+
+; ======================================================================
+
+(define (copy-live-constraints-noe lower upper)
+
+  (pretty-debug-min 
+    `(copy-live-constraints-noe 
+       ,(map Tvar-name lower) ,(map Tvar-name upper)))
+
+  (let*-vals 
+    ( [(live-nts live-nt? live-tvars live-tvar? _ _ _)
+        (calc-live-tvars-nts lower upper #t)]
+      [(get-nu-Tvar set-nu-Tvar!) (alloc-Tvar-field)]
+      [list-nuTvar
+        (map (lambda (Tvar) 
+               (let ([nu (mk-Tvar 'min-live)])
+                 (set-nu-Tvar! Tvar nu)
+                 nu))
+          live-tvars)]
+      [dummy-tvars
+        (copy-constraints-noe! live-tvar? live-nts get-nu-Tvar lower)])
+
+    (values
+      (append dummy-tvars list-nuTvar)
+      get-nu-Tvar)))
+
+;; ======================================================================
+; calc-live-tvars-nts
+;
+; Calculates live Tvars and NTs
+; Input:  lower : list Tvar
+;         upper : list Tvar
+;
+; Uses find-nonempty-nts-rhs-nts to find nonempty nts and sources
+; Walk "forward" in grammar using rhs-nts from crossover and AV-w/-const
+; to calculate live
+;
+; Returns (values live-nts live-nt? live-tvars live-tvar? 
+;          AV-w/-const crossover rhs-nts)
+
+(define (calc-live-tvars-nts lower upper inline-epsilon)
+
+  (pretty-debug-min 
+    `(calc-live-tvars-nts  ,inline-epsilon
+       ,(map Tvar-name lower) ,(map Tvar-name upper)))
+
+  (let*-vals 
+    ( [t (lambda (s) 
+           (when timing-min 
+             (min-record-progress (cons 'calc-live-tvars-nts s))))]
+      [_ (t 0)]
+      [(rhs-nts crossover AV-w/-const) 
+        (find-nonempty-nts-rhs-nts lower upper inline-epsilon)]
+      [_ (t 1)]
+      [(live-nt? set-live-nt! get-live-nts) (field->set alloc-NT-field)]
+      [_ (t 2)]
+        
+      ;; --------------------------------------------------
+      ;; Walk forward from crossover and AV-w/-const, recording nts
+        
+      [_ (letrec ([mark-live
+                    (lambda (nt)
+                      (unless (eq? nt #t)
+                        ;;(pretty-print `(mark-live ,(nt->sym nt)))
+                        (unless (live-nt? nt)
+                          (set-live-nt! nt)
+                          (when (rhs-nts nt)
+                            (for-each mark-live (rhs-nts nt))))))])
+
+           (for-each
+             (lambda (Tvar)
+               (mark-live (Tvar-U Tvar))
+               (mark-live (Tvar-L Tvar)))
+             crossover)
+
+           (for-each 
+             (lambda (AV) (mark-live (AV-U AV)))
+             AV-w/-const)
+
+           (pretty-debug-min `(live-nt ,(map nt->sym (get-live-nts)))))]
+      [_ (t 3)]
+
+      ;; --------------------------------------------------
+      ;; Have in (get-live-nts) all nts that are reached and non-empty
+      ;; Calc live Tvar
+
+      [(live-tvar? set-live-tvar! get-live-tvars) 
+        (field->set alloc-Tvar-field)]
+      [_ (t 4)]
+      [_ (begin
+           (for-each
+             (match-lambda
+               [($ NT tvar) (when (Tvar? tvar) (set-live-tvar! tvar))])
+             (get-live-nts))
+           (for-each set-live-tvar! lower)
+           (for-each set-live-tvar! upper))]
+      [_ (t 5)]
+      [_ (pretty-debug-min `(live-Tvar ,(map Tvar-name (get-live-tvars))))])
+
+    (pretty-debug-min
+      `(calc-live-tvars-nts-results
+         ,(map (lambda (nt)
+                 `(nt-rhs ,(nt->sym nt)
+                    ,(map (lambda (nt) (or (eq? nt #t) (nt->sym nt)))
+                       (rhs-nts nt))))
+            (get-live-nts))))
+
+    (values
+      (get-live-nts) live-nt?
+      (get-live-tvars) live-tvar? 
+      AV-w/-const
+      crossover
+      rhs-nts
+      )))
+
+;; ======================================================================
+
+(define (follow-antimono-fields template)
+  (or 
+    (eq? template template-lam)
+    (eq? template template-unit)
+    (eq? template template-internal-class)
+    (st:minimize-respect-assignable-part-of-fields)))
+
+;; ======================================================================
+; find-nonempty-nts-rhs-nts
+;
+; Calculates non-empty Tvars, NTs.
+; For each non-empty NT, finds all rhs-nts NT' such that NT -> x.NT'
+
+; Input:  lower : (listof Tvar)
+;         upper : (listof Tvar)
+;
+; Returns (values rhs-nts crossover-tvars AV-w/-const)
+;
+; Walks "backwards" in grammer to find nonempty NTs
+; Keeps track of rhs-nts on the way
+;
+; crossover is the set of Tvars tvar such that 
+; both L(tvar_L) and L(tvar_U) are nonempty
+
+;; #### Always looks at assignable fields ...
+
+(define (find-nonempty-nts-rhs-nts lower upper inline-epsilon)
+  (pretty-debug-min
+    `(find-nonempty-tvars-nts-rhs-nts ,inline-epsilon
+       ,(map Tvar-name lower) ,(map Tvar-name upper)))
+
+  (let*-vals ( [(reached-tvar? set-reached-tvar!) (alloc-Tvar-field)]
+               [(reached-AV? set-reached-AV!)     (alloc-AV-field)]
+               [(rhs-nts set-rhs-nts!)            (alloc-NT-field)]
+               [add-rhs-nt! 
+                 (lambda (nt src) (set-rhs-nts! nt (cons src (rhs-nts nt))))]
+               [crossover '()]
+               ;; crossover is set of tvars with tvar_L and tvar_U nonempty
+               [AV-w/-const '()]
+               )
+    (letrec
+      ( [add-crossover! 
+          (lambda (tvar)
+            (set! crossover (cons tvar crossover)))]
+        [walk-AV
+          (lambda (AV src)
+            (pretty-debug-min `(walk-AV ,(AV-num AV) ,(nt->sym src)))
+            (if (reached-AV? AV)
+              (add-rhs-nt! (AV-U AV) src)
+              ;; Walk it
+              (begin
+                (set-reached-AV! AV #t)
+                (mk-AV-NTs! AV)
+                (let ([nt (AV-U AV)])
+                  (set-rhs-nts! nt (list src))
+                  (match AV
+                    [($ AV _ (and template ($ template _ _ _ ref))
+                       misc fields+ fields-)
+                      (when (or 
+                              (zero? (vector-length ref))
+                              ;; the following are lazy
+                              ;; ie (box empty) = empty
+                              ;; but (empty -> empty) != empty
+                              (eq? template template-lam)
+                              (eq? template template-unit)
+                              (eq? template template-internal-class)
+                              (eq? template template-ivarset)
+                              )
+                        (set! AV-w/-const (cons AV AV-w/-const)))
+                      (vector-for-each
+                        (lambda (f) (walk-U f nt))
+                        fields+)
+                      (when (follow-antimono-fields template)
+                        (pretty-debug-min
+                          `(walking-U 
+                             ,(eq? template template-lam)
+                             ,(st:minimize-respect-assignable-part-of-fields)))
+                        (vector-for-each 
+                          (lambda (f) (walk-L f nt))
+                          fields-))])))))]
+        [reach-tvar
+          (lambda (tvar)
+            (unless (reached-tvar? tvar) 
+              (set-reached-tvar! tvar #t)
+              (mk-Tvar-NTs! tvar)))]
+        [walk-U
+          (lambda (tvar src)
+            (let 
+              ([f
+                 (lambda (tvar)
+                   (reach-tvar tvar)
+                   (pretty-debug-min `(walk-U ,(Tvar-name tvar) ,(nt->sym src)))
+                   (let ([nt (Tvar-U tvar)])
+                     (if (rhs-nts nt)
+                       (add-rhs-nt! nt src)
+                       ;; Walk it
+                       (begin
+                         (set-rhs-nts! nt (list src))
+                         (when (rhs-nts (Tvar-L tvar)) (add-crossover! tvar))
+                         (pretty-debug-min `(walk-U ,(Tvar-name tvar)))
+                         (for-each
+                           (lambda (AV) (walk-AV AV nt))
+                           (get-Tvar-objs tvar))
+                         '(unless inline-epsilon
+                            (for-each
+                              (lambda (from)
+                                (walk-U from nt))
+                              (Tvar-edgefrom tvar)))))))])
+
+              '(if inline-epsilon
+                 ;; really want to walk all tvar2 st tvar2_U -> tvar_U
+                 (for-each f (Tvar-transitive-edgefrom tvar))
+                 (f tvar))
+              (f tvar)))]
+
+        [walk-L
+          (lambda (tvar src)
+            (let 
+              ([f (lambda (tvar)
+                    (reach-tvar tvar)
+                    (pretty-debug-min
+                      `(walk-L ,(Tvar-name tvar) ,(nt->sym src)))
+                    (let ([nt (Tvar-L tvar)])
+                      (if (rhs-nts nt)
+                        (add-rhs-nt! nt src)
+                        ;; Walk it
+                        (begin
+                          (set-rhs-nts! nt (list src))
+                          (when (rhs-nts (Tvar-U tvar)) (add-crossover! tvar))
+                          (pretty-debug-min `(walk-L ,(Tvar-name tvar)))
+
+                          (unless inline-epsilon
+                            (for-each
+                              (lambda (to)
+                                ;; Have to_L -> tvar_L
+                                (walk-L to nt))
+                              (Tvar-edgeto tvar)))
+                          (for-each
+                            (match-lambda
+                              [($ con _ _ field-no tvar2 sign misc)
+                                ;; Have tvar2_L -> rng(tvar_L)
+                                ;; or   tvar2_U -> dom(tvar_L)
+                                (if sign
+                                  (walk-L tvar2 nt)
+                                  (walk-U tvar2 nt))]
+                              [($ con-filter _ filter tvar2)
+                                ;; Have tvar2_L -> tvar_L
+                                (unless inline-epsilon (walk-L tvar2 nt))])
+                            (Tvar-constraints tvar))))))])
+              '(if inline-epsilon
+                 ;; really want to walk all tvar2 st tvar2_L -> tvar_L
+                 (for-each f (Tvar-transitive-edgeto tvar))
+                 (f tvar))
+              (f tvar)))])
+
+      (for-each (lambda (tvar) (walk-U tvar #t)) upper)
+      (for-each (lambda (tvar) (walk-L tvar #t)) lower)
+
+      (min-record-progress 'find-nonempty-nts-rhs-nts-done)
+      (: rhs-nts (NT -> (union NT true)))
+
+      (pretty-debug-min
+        `(find-nonempty-nts-rhs-nts-returns
+           ,(map AV-num AV-w/-const)
+           ,(map Tvar-name crossover)))
+
+      (values
+        (lambda (nt) 
+          (let ([r (rhs-nts nt)])
+            (pretty-debug-min
+              `(rhs-nts ,(nt->sym nt)
+                 ,(map (lambda (nt) (or (eq? nt #t) (nt->sym nt))) r)))
+            r))
+        crossover 
+        AV-w/-const))))
+        
+;; ======================================================================
+; copy-constraints!
+; 
+; tvar->equiv and AV->equiv describe an equivalence relation on tvars and AVs
+;
+; Copies the contents of a set of Tvars
+; Takes care not to duplicate AVs
+; returns (values nu-tvars tvar->nu-tvar)
+; live-tvars should include lower and upper, and may contain duplicates
+
+(define (copy-constraints-equiv!
+          live-tvars live-tvar? live-nts 
+          tvar->equiv AV->equiv)
+
+  (pretty-debug-min `(copy-constraints-equiv! ,(map nt->sym live-nts)))
+  (let*-vals 
+    ( [t (lambda (s) 
+           (when timing-min 
+             (min-record-progress (cons 'copy-constraint-equivs! s))))]
+      [_ (t 0)]
+
+      ;; --- Allocate new tvar
+      [(Tvar-nuTvar set-Tvar-nuTvar!) (alloc-Tvar-field)]
+      [list-nu-tvars '()]
+      [_ (for-each
+           (lambda (tvar)
+             (unless (Tvar-nuTvar tvar)
+               (let ([nu (mk-Tvar 'copy-constraints!)])
+                 (set! list-nu-tvars (cons nu list-nu-tvars))
+                 (for-each
+                   (lambda (tvar2) (set-Tvar-nuTvar! tvar2 nu))
+                   (tvar->equiv tvar)))))
+           live-tvars)]
+      [_ (t 1)]
+
+      [Tvar->nuTvar 
+        (lambda (Tvar)
+          (if (live-tvar? Tvar)
+            (let ([nu (Tvar-nuTvar Tvar)])
+              (assert (Tvar? nu) 'Tvar->nuTvar 
+                nu (live-tvar? Tvar) (memq Tvar live-tvars))
+              nu)
+            (let ([dummy (mk-Tvar 'dummy)])
+              (set! list-nu-tvars (cons dummy list-nu-tvars))
+              dummy)))]
+
+      [(AV-nuAV set-AV-nuAV!) (alloc-AV-field)]
+      [copy-AV 
+        (lambda (AV)
+          (or 
+            (AV-nuAV AV)
+            (match AV
+              [(and AV ($ AV _ template misc fields+ fields-))
+                (let* 
+                  ( [nu-fields+ (vector-map Tvar->nuTvar fields+)]
+                    [nu-fields- (vector-map Tvar->nuTvar fields-)]
+                    [nu-AV (create-AV template misc nu-fields+ nu-fields-)])
+                  (set-AV-nuAV! AV nu-AV)
+                  (for-each
+                    (lambda (eq-AV) 
+                      (when (and
+                              (not (AV-nuAV eq-AV))
+                              (eq? (AV-template eq-AV) template)
+                              (vector-andmap2 eq? nu-fields+ 
+                                (vector-map Tvar->nuTvar (AV-fields+ eq-AV)))
+                              '(vector-andmap2 eq? nu-fields-
+                                 (vector-map Tvar->nuTvar (AV-fields- eq-AV))))
+                        (set-AV-nuAV! eq-AV nu-AV)))
+                    (AV->equiv AV))
+                  nu-AV)])))]
+      [_ (t 1.1)])
+
+    (for-each
+      (match-lambda
+        [($ NT source LU)
+          (when (Tvar? source)
+            (let ([dest (Tvar->nuTvar source)])
+              (case LU
+                [(U)
+                  ;; --- AVs
+                  (for-each (lambda (AV) (new-AV! dest (copy-AV AV)))
+                    (Tvar-objs source))]
+                [(L)
+                  ;; --- Constraints
+                  (for-each
+                    (match-lambda
+                      [($ con _ template field-no Tvar sign)
+                        (when (live-tvar? Tvar)
+                          (new-con! dest 
+                            (create-con template field-no 
+                              (Tvar->nuTvar Tvar) sign)))]
+                      [($ con-filter _ filter Tvar)
+                        (when (live-tvar? Tvar)
+                          ;; (new-con! dest
+                          ;;  (create-con-filter filter (Tvar->nuTvar Tvar))
+                          (new-edge! dest (Tvar->nuTvar Tvar)))])
+                    (Tvar-constraints source))
+
+                  ;; --- Edges
+                  (for-each
+                    (lambda (Tvar2)
+                      (when (live-tvar? Tvar2)
+                        (let ([nu (Tvar->nuTvar Tvar2)])
+                          (unless (eq? dest nu)
+                            (new-edge! dest nu)))))
+                    (Tvar-edgeto source))])))])
+      live-nts)
+    (t 2)
+
+    (pretty-debug-min
+      `(copy-constraints-equiv!
+         old->new
+         ,(map 
+            (lambda (tvar) 
+              (list (Tvar-name tvar) (Tvar-name (Tvar-nuTvar tvar))))
+            live-tvars)))
+
+
+    (values list-nu-tvars Tvar-nuTvar))) 
+
+;; ======================================================================
+; copy-constraints-noe!
+; 
+; Copies the contents of a set of Tvars
+; Does closure under epsilon
+; Takes care not to add duplicate AVs
+; But may make many copies of the same AV in different Tvar
+
+(define (copy-constraints-noe! live-tvar? live-nts Tvar-nuTvar lower)
+  (pretty-debug-min
+    `(copy-constraints-noe!
+       live-nts
+       ,(map nt->sym live-nts)
+       lower
+       ,(map Tvar-name lower)
+       conversion
+       ,(map 
+          (lambda (tvar) 
+            (list (Tvar-name tvar) (Tvar-name (Tvar-nuTvar tvar))))
+          (filter Tvar? (map NT-tvar live-nts)))))
+  '(let*-vals
+    ( [(AV-nuAV set-AV-nuAV!) (alloc-AV-field)]
+      [dummy-tvars '()]
+      [mk-dummy-tvar
+        (lambda ()
+          (let ([dummy (mk-Tvar 'dummy)])
+            (set! dummy-tvars (cons dummy dummy-tvars))
+            dummy))]
+      [Tvar->nuTvar 
+        (lambda (Tvar)
+          (if (live-tvar? Tvar)
+            (Tvar-nuTvar Tvar)
+            (mk-dummy-tvar)))]
+      [table '()]
+      [Tvar*->nuTvar
+        (lambda (Tvar*)
+          (let* ( [Tvar* (if (Tvar? Tvar*) (list Tvar*) Tvar*)]
+                  [nu-Tvar* 
+                    (list->set 
+                      (filter-map
+                        (lambda (Tvar)
+                          (if (live-tvar? Tvar) (Tvar->nuTvar Tvar) #f))
+                        Tvar*))])
+            (match nu-Tvar*
+              [() (mk-dummy-tvar)]
+              [(Tvar) Tvar]
+              [_ (or (ormap
+                       (match-lambda
+                         [(Tvar2* . nu) 
+                           (if (set-eq? Tvar2* nu-Tvar*) nu #f)])
+                       table)
+                   (let ([nu (mk-Tvar 'multiple)])
+                     (set! table (cons (cons nu-Tvar* nu) table))
+                     (for-each (lambda (to) (new-edge! nu to)) nu-Tvar*)
+                     nu))])))]
+      [tag-reached-AV (gensym)])
+
+    (for-each
+      (match-lambda
+        [($ NT source LU)
+          (when (Tvar? source)
+            (pretty-debug-min `(copying ,(Tvar-name source)))
+            (let ([dest (Tvar->nuTvar source)])
+              (case LU
+                [(U)
+                  ;; --- AVs
+                  (for-each
+                    (match-lambda
+                      [(and AV 
+                         ($ AV _ 
+                           (and template ($ template _ signs)) misc fields))
+
+                        (pretty-debug-min `(AV ,(Tvar-name dest)
+                                             ,(vector-map Tvar-name fields)))
+
+                        (new-AV! dest
+                          (or (AV-nuAV AV)
+                            (let* ([nu-fields
+                                     (vector-map
+                                       (lambda (sign field)
+                                         (if sign
+                                           (Tvar->nuTvar field)
+                                           (Tvar*->nuTvar 
+                                             (Tvar-transitive-edgeto field))))
+                                       signs fields)]
+                                    [nu-AV (create-AV template misc nu-fields)])
+                              (set-AV-nuAV! AV nu-AV)
+                              nu-AV)))])
+                    (Tvar-objs source))]
+
+                [(L)
+                  ;; --- Constraints
+                  (for-each
+                    (match-lambda
+                      [($ con _ template field-no Tvar)
+                        (for-each
+                          (lambda (Tvar)
+                            (when (live-tvar? Tvar)
+                              (new-con! dest
+                                (create-con template field-no
+                                  (Tvar->nuTvar Tvar)))))
+                          (if (vector-ref (template-signs template) field-no)
+                            (Tvar-transitive-edgeto Tvar)
+                            (list Tvar)
+                            ;;(Tvar-transitive-edgefrom Tvar)
+                            ))]
+                      [($ con-filter _ filter Tvar) 
+                        ;; Was treated as edge
+                        (void)])
+                    (Tvar-constraints source))])))])
+      live-nts)
+
+    (for-each 
+      (lambda (L)
+        (let ([nu-L (Tvar->nuTvar L)])
+          (for-each
+            (lambda (to)
+              (when (live-tvar? to)
+                (let ([nu-to (Tvar->nuTvar to)])
+                  (unless (eq? nu-L nu-to)
+                    (new-edge! nu-L nu-to)))))
+            (Tvar-transitive-edgeto L))))
+      lower)
+
+    (append dummy-tvars (map cdr table))))
+
+;; ======================================================================
diff --git a/collects/mrspidey/Sba/min/min.ss b/collects/mrspidey/Sba/min/min.ss
new file mode 100644
index 0000000..9096ada
--- /dev/null
+++ b/collects/mrspidey/Sba/min/min.ss
@@ -0,0 +1,236 @@
+; min.ss
+; Purpose: Minimize a set of constraints.
+; ======================================================================
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+; minimize-constraints-&-compare
+; minimizes a constraint system
+; Input:  which : 'live or 'dfa-min
+;         lower : list Tvar
+;         upper : list Tvar
+;         l1 ... l2 : ftypes in uncompresssed set of constraints
+
+; Returns (list-ftype Tvar->nuTvar)
+;; ----------------------------------------
+
+(define global-lower (void))
+(define global-upper (void))
+(define global-all-which (void))
+
+(define (minimize-constraints-&-compare all-which lower upper l1 l2)
+  (set! global-lower lower)
+  (set! global-upper upper)
+  (set! global-all-which all-which)
+  (when (st:compare-min-algs)
+    ;; Compare algorithms
+    (let* ( [alg-width 32]
+            [calc-sizes
+             (lambda (rep)
+               (pretty-debug-min2 `(calc-sizes ,(map Tvar-name rep)))
+               (let*-vals
+                 ( [n-f (length rep)]
+                   [AV-added (apply append (map get-Tvar-objs rep))]
+                   [n-AV-added (length AV-added)]
+                   [n-AV (length (list->set AV-added))]
+                   [n-edge (length (apply append (map Tvar-edgeto rep)))]
+                   [n-con (length (apply append (map Tvar-constraints rep)))]
+                   [size (+ n-edge n-con n-AV-added)])
+                 (list size n-f n-AV n-AV-added n-edge n-con)))]
+            [show-sizes
+              (lambda (alg orig-size t size n-f n-AV n-AV-added n-edge n-con)
+                (if (zero? size)
+                  (error 'minimize-constraints-&-compare
+                     "Algorithm ~s returns empty constraint system~n" alg)
+                  (printf 
+                    "~a: ~a ~a ~a ~a ~a ~a ~a ~a~n"
+                    (padr alg alg-width)
+                    (padl
+                      (/ (round (* (exact->inexact (/ orig-size size)) 10)) 10)
+                      6)
+                    (padl size 5)
+                    (padl n-f 5)
+                    (padl n-AV 3)
+                    (padl n-AV-added 5)
+                    (padl n-edge 5)
+                    (padl n-con 4)
+                    (padl t 5))))]
+            [orig-sizes (calc-sizes (filter Tvar? (get-prefix l1 l2)))]
+            [orig-size (car orig-sizes)])
+      '(pretty-debug `(minimize-constraints-&-compare 
+                        ,(map Tvar-name lower) ,(map Tvar-name upper)))
+      (printf "~n~a:  factor  size  Tvar  AV  AV-a  edge  con time~n" 
+        (padr "Algorithm" alg-width))
+      (apply show-sizes "" orig-size 0 orig-sizes)
+      (for-each
+        (lambda (p)
+          (let*-vals
+            ( [thunk 
+                (lambda ()
+                  (let-values
+                    ([(rep _) 
+                       (minimize-constraints p lower upper l1 l2)])
+                    rep))]
+              [(rep t real-t) (time-apply thunk)]
+              [sizes (calc-sizes rep)])
+            (apply show-sizes p orig-size t sizes)))
+        min-algs-to-compare)))
+
+  (minimize-constraints all-which lower upper l1 l2))
+
+;; ----------
+
+(define min-algs-to-compare
+  '(                                    ;(none)
+     (nonempty)
+     (nonempty live)
+     (live)
+     ;(live-no-epsilon)
+     (live-few-e)
+                                        ;(live-few-e-L)
+                                        ;(live-few-e-U)
+     ;(live-no-epsilon dfa-min)
+     ;(live-no-epsilon dfa-min-inv)
+     ;(live-few-e dfa-min)
+     ;(live-few-e dfa-min-inv)
+     ;(live-few-e dfa-min-inv dfa-min)
+     ;(live-few-e dfa-min dfa-min-inv)
+
+     ;(live-no-epsilon dfa-min-1)
+     ;(live-no-epsilon dfa-min-2)
+
+     ;(live-few-e dfa-min-1)
+     ;(live-few-e dfa-min-2)
+     ;(live-few-e dfa-min-1 live-few-e dfa-min-2)
+     ;(live-few-e dfa-min-2 live-few-e dfa-min-1)
+
+     (dfa-min-lub)
+     (dfa-min-glb)
+     (dfa-min-lub dfa-min-glb)
+     (dfa-min-glb dfa-min-lub)
+     (dfa-min-lub dfa-min-glb dfa-min-lub)
+     (dfa-min-glb dfa-min-lub dfa-min-glb)
+     ;(live-few-e dfa-min-1 live-no-epsilon dfa-min-2 live-no-epsilon dfa-min-1)
+     ;(live-few-e dfa-min-2 live-no-epsilon dfa-min-1 live-no-epsilon dfa-min-2)
+                                        ;(live-no-epsilon min-table)
+     ))
+
+;; ----------------------------------------------------------------------
+
+(define min-time-base 0)
+(define min-time-record '())
+(define (min-record-progress what)
+  (set! min-time-record
+    (cons (cons what (current-process-milliseconds)) min-time-record)))
+(define (show-record-progress)
+  (pretty-debug
+    (map (match-lambda
+           [(what . when) (list what (- when min-time-base))])
+      (reverse min-time-record))))
+;; ----------
+
+(define (minimize-constraints all-which lower upper l1 l2)
+  (pretty-debug-min2
+    `(input 
+       all-which ,all-which
+       lower ,(map Tvar-name lower)
+       upper ,(map Tvar-name upper)))
+
+  (set! min-time-record '())
+  (set! min-time-base (current-process-milliseconds))
+  (recur loop ( [which all-which]
+                [lower lower]
+                [upper upper]
+                [Tvar->nuTvar (lambda (x) x)])
+    (match which
+      [(which . (and rest (_ . _)))
+        (let*-vals
+          ([(rep-Tvar1 Tvar->nuTvar1)
+             (minimize-constraints-nocount which lower upper l1 l2)])
+          (loop rest 
+            (map Tvar->nuTvar1 lower)
+            (map Tvar->nuTvar1 upper)
+            (lambda (Tvar) (Tvar->nuTvar1 (Tvar->nuTvar Tvar)))))]
+      [(or (which) (? symbol? which))
+        (let*-vals
+          ([(rep-Tvar Tvar-nuTvar1) 
+             (minimize-constraints-nocount which lower upper l1 l2)])
+
+          (when timing-min (show-record-progress))
+
+          (pretty-debug-min2
+            `(output lower ,(map Tvar-name (map Tvar-nuTvar1 lower))
+               upper ,(map Tvar-name (map Tvar-nuTvar1 upper))))
+
+          (values 
+            rep-Tvar
+            (lambda (Tvar) (Tvar-nuTvar1 (Tvar->nuTvar Tvar)))))])))
+
+;; ----------------------------------------------------------------------
+
+(define (minimize-constraints-nocount which lower upper l1 l2)
+  (pretty-debug-min
+    `(minimize-constraints-nocount which ,which
+       lower ,(map Tvar-name lower)
+       upper ,(map Tvar-name upper)))
+  (check-kernel-ok)
+  (pretty-debug-min `(minimize-constraints-nocount kernel-ok))
+  (let*-values
+    ([(A B)
+       (case which
+         [(none)             (values
+                             (filter Tvar? (get-prefix l1 l2))
+                             (lambda (Tvar) Tvar))]
+         [(nonempty)         (let*-vals
+                             ([(live-tvars _ _) 
+                                (find-nonempty-tvars lower upper)])
+                             (values 
+                               live-tvars                             
+                               (lambda (tvar) tvar)))]
+         [(nonempty-copy)    (copy-nonempty-tvars lower upper)]
+         [(live)             (copy-live-constraints lower upper)]
+         [(live-no-epsilon)  (copy-live-constraints-noe lower upper)]
+
+         [(live-few-e)
+           (call-with-values
+             (lambda () ((copy-live-constraints-few-e #t #t) lower upper))
+             copy-constraints-equiv!)]
+         [(live-few-e-L)
+           (call-with-values
+             (lambda () ((copy-live-constraints-few-e #t #f) lower upper))
+             copy-constraints-equiv!)]
+         [(live-few-e-U)
+           (call-with-values
+             (lambda () ((copy-live-constraints-few-e #f #t) lower upper))
+             copy-constraints-equiv!)]
+         ;[dfa-min          (minimize-constraints-dfa-min lower upper)]
+         ;[dfa-min-inv      (minimize-constraints-dfa-min-inv lower upper)]
+         ;[dfa-min-1        (minimize-constraints-dfa-min-1 lower upper)]
+         ;[dfa-min-2        (minimize-constraints-dfa-min-2 lower upper)]
+         [(dfa-min-lub)      (minimize-constraints-dfa-min-lub lower upper)]
+         [(dfa-min-glb)      (minimize-constraints-dfa-min-glb lower upper)]
+         ;[min-table        (min-table lower upper)]
+         [else (error 'minimize-constraints-nocount "Bad which ~s" which)])])
+    (check-kernel-ok)
+    (pretty-debug-min `(minimize-constraints-nocount kernel-ok2))
+    (min-record-progress 'minimize-constraints-nocount-returning)
+    (values A B)))
+
+;; ======================================================================
+
+
+
+
diff --git a/collects/mrspidey/Sba/min/nonempty.ss b/collects/mrspidey/Sba/min/nonempty.ss
new file mode 100644
index 0000000..3603925
--- /dev/null
+++ b/collects/mrspidey/Sba/min/nonempty.ss
@@ -0,0 +1,105 @@
+; ======================================================================
+; find-nonempty-tvars
+;
+; Input:  lower : (listof Tvar) with non-empty Tvar_L
+;         upper : (listof Tvar) with non-empty Tvar_U
+;
+; Finds non-empty non-terminals
+; returns (listof Tvar)
+; ======================================================================
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define (find-nonempty-tvars lower upper)
+  (pretty-debug-min
+    `(find-nonempty-tvars ,(map Tvar-name lower) ,(map Tvar-name upper)))
+
+  (let*-vals ( [(reached-U? set-reached-U!) (alloc-Tvar-field)]
+               [(reached-L? set-reached-L!) (alloc-Tvar-field)]
+               [(reached-AV set-reached-AV!) (alloc-AV-field)]
+               [num-AV 0]
+               [list-tvar '()])
+    (letrec
+      ( [add-Tvar!
+          (lambda (tvar)
+            (set! list-tvar (cons tvar list-tvar)))]
+        [walk-AV
+          (lambda (AV)
+            (unless (reached-AV AV)
+              ;; Walk it
+              (set-reached-AV! AV #t)
+              (match AV
+                [($ AV _ template _ fields+ fields-)
+                  (vector-for-each walk-U fields+)
+                  (when (follow-antimono-fields template)
+                    (pretty-debug-min
+                      `(walking-U 
+                         ,(eq? template template-lam)
+                         ,(st:minimize-respect-assignable-part-of-fields)))
+                    (vector-for-each walk-U fields-))])))]
+        [walk-U
+          (lambda (tvar)
+            (unless (reached-U? tvar)
+              (unless (reached-L? tvar) (add-Tvar! tvar))
+              (set-reached-U! tvar #t)
+              (pretty-debug-min `(walk-U ,(Tvar-name tvar)))
+              (for-each walk-AV (get-Tvar-objs tvar))
+              (for-each walk-U (Tvar-edgefrom tvar))))]
+        [walk-L
+          (lambda (tvar)
+            (unless (reached-L? tvar)
+              (unless (reached-U? tvar) (add-Tvar! tvar))
+              (set-reached-L! tvar #t)
+              (pretty-debug-min `(walk-L ,(Tvar-name tvar)))
+              ;; Have to_L -> tvar_L
+              (for-each walk-L (Tvar-edgeto tvar))
+
+              (for-each
+                (match-lambda
+                  [($ con _ _ field-no tvar2 sign misc)
+                    ;; Have tvar2_L -> rng(tvar_L)
+                    ;; or   tvar2_U -> dom(tvar_L)
+                    (if sign
+                      (walk-L tvar2)
+                      (walk-U tvar2))]
+                  [($ con-filter _ filter tvar2)
+                    ;; Have tvar2_L -> tvar_L
+                    (walk-L tvar2)])
+                (Tvar-constraints tvar))))])
+      (for-each walk-U upper)
+      (for-each walk-L lower)
+      '(printf "walk-reachable-constraints allocated ~s tvar, ~s AV~n"
+         (length list-tvar) num-AV)
+
+      (values list-tvar reached-L? reached-U?))))
+
+; ======================================================================
+
+(define (copy-nonempty-tvars lower upper)
+  (let*-vals
+    ( [(live-tvars _ _) (find-nonempty-tvars lower upper)]
+      [(tvar-live? set-tvar-live!) (alloc-Tvar-field)])
+    (for-each mk-Tvar-NTs! live-tvars)
+    (for-each (lambda (tvar) (set-tvar-live! tvar #t)) live-tvars)
+    (copy-constraints-equiv! 
+      (append lower upper live-tvars)
+      tvar-live?
+      (append 
+        (map Tvar-L live-tvars)
+        (map Tvar-U live-tvars))
+      (lambda (tvar) (list tvar))
+      (lambda (AV) (list AV)))))
diff --git a/collects/mrspidey/Sba/mod-env3.ss b/collects/mrspidey/Sba/mod-env3.ss
new file mode 100644
index 0000000..2566780
--- /dev/null
+++ b/collects/mrspidey/Sba/mod-env3.ss
@@ -0,0 +1,46 @@
+(let ([gen:477:join-env (void)]
+      [gen:473:extend-env* (void)]
+      [gen:476:extend-env (void)]
+      [gen:474:lookup (void)]
+      [gen:475:empty-env (void)])
+  (begin (set! gen:475:empty-env '())
+         (begin (set! gen:474:lookup
+                  (lambda (gen:493:env gen:492:x)
+                    (let ([gen:494:r (assq gen:492:x gen:493:env)])
+                      (if (eq? gen:494:r '#f)
+                          (error 'lookup '"no binding for ~a" gen:492:x)
+                          (cdr gen:494:r)))))
+                (begin (set! gen:476:extend-env
+                         (lambda (gen:491:env gen:489:x gen:490:v)
+                           (cons (cons gen:489:x gen:490:v) gen:491:env)))
+                       (begin (set! gen:473:extend-env*
+                                (lambda (gen:488:env gen:486:xs gen:487:vs)
+                                  (append (map2 cons gen:486:xs gen:487:vs) gen:488:env)))
+                              (begin (set! gen:477:join-env
+                                       (lambda (gen:485:env gen:484:newenv)
+                                         (append gen:484:newenv gen:485:env)))
+                                     (make-rs:module
+                                       (lambda (gen:478:msg)
+                                         (let ([gen:479:%%tmp gen:478:msg])
+                                           (if (memv gen:479:%%tmp '(empty-env))
+                                               gen:475:empty-env
+                                               (let ([gen:480:%%tmp gen:478:msg])
+                                                 (if (memv gen:480:%%tmp '(lookup))
+                                                     gen:474:lookup
+                                                     (let ([gen:481:%%tmp gen:478:msg])
+                                                       (if (memv gen:481:%%tmp '(extend-env))
+                                                           gen:476:extend-env
+                                                           (let ([gen:482:%%tmp gen:478:msg])
+                                                             (if (memv gen:482:%%tmp '(extend-env*))
+                                                                 gen:473:extend-env*
+                                                                 (let ([gen:483:%%tmp gen:478:msg])
+                                                                   (if (memv gen:483:%%tmp '(join-env))
+                                                                       gen:477:join-env
+                                                                       (error 'import
+                                                                         '"attempting to import ~s~n        from module with signature ~s"
+                                                                         gen:478:msg
+                                                                         '(empty-env
+                                                                            lookup
+                                                                            extend-env
+                                                                            extend-env*
+                                                                            join-env))))))))))))))))))))
diff --git a/collects/mrspidey/Sba/nfa-dfa.ss b/collects/mrspidey/Sba/nfa-dfa.ss
new file mode 100644
index 0000000..fe1543b
--- /dev/null
+++ b/collects/mrspidey/Sba/nfa-dfa.ss
@@ -0,0 +1,59 @@
+; ======================================================================
+;; NFA->DFA
+;; roots: (list nt)
+;; final: (list nt)
+;; returns (list (list AVS) (list AVS))
+
+(define (NFA->DFA for-each-prod roots final)
+  ;; n is an old nt
+  ;; d is new nt
+  (letrec
+      ([n*->d '()]                    ; Maps set of NFA nts to a DFA nt
+       [n*<=
+        (lambda (n1* n2*)
+          (andmap (lambda (n1) (mem-nt? n1 n2*)) n1*))]        
+       [n*=
+        (lambda (n1* n2*)
+          (and (n*<= n1* n2*) (n*<= n2* n1*)))]
+       [lookup
+        (lambda (n*)
+          (recur loop ([l n*->d])
+            (cond
+             [(null? l) #f]
+             [(n*= n* (caar l)) (cdar l)]
+             [else (loop (cdr l))])))]
+       [traverse
+        (lambda (n*)
+          (or (lookup n*)
+              ;; Need to traverse
+              ;; think about epsilon-closure
+              (let* ([rhs* '()]
+                     [_ (for-each
+                         (lambda (n)
+                           (for-each-prod
+                            (lambda (rhs) (set! rhs* (cons rhs rhs*)))
+                            n))
+                         n*)]
+                     [d (mk-AVS-nolist 'dfa)])
+                (set! n*->d (cons (cons n* d) n*->d))
+                (recur loop ([rhs* rhs*])
+                  (match rhs*
+                    [() (void)]
+                    [(($ rhs grsym nt) . _)
+                     ;; Merge all with same grsym 
+                     (match-let* 
+                         ([(nt* . rest) 
+                           (filter-map-split
+                            (match-lambda
+                             [($ rhs grsym2 nt2)
+                              (if (grsym-eq? grsym grsym2)
+                                  nt2
+                                  #f)])
+                            rhs*)])
+                       (add-prod! d (make-rhs grsym (traverse nt*)))
+                       (loop rest))]))
+                d)))])
+    (traverse (list AVS))
+    (list (map (lambda (r) (lookup (list r))) roots)
+          (map (lambda (r) (lookup (list r))) final))))
+
diff --git a/collects/mrspidey/Sba/parser.ss b/collects/mrspidey/Sba/parser.ss
new file mode 100644
index 0000000..d2a0341
--- /dev/null
+++ b/collects/mrspidey/Sba/parser.ss
@@ -0,0 +1,489 @@
+;; parser.ss
+;;
+;; Takes a zodiac:sexp, and an env: sym -> zodiac:bound,
+;; and produces a zodiac:ast and a list of unbound zodiac:bounds
+;; Only handles R4RS primitive syntax
+;; ======================================================================
+
+(define keywords
+  '(begin cond delay if set! set!-values quote begin lambda case-lambda 
+     poly
+     let-values letrec*-values
+     unit compound-unit invoke-unit
+     : type:-quote
+     cache-exp-quote cache-inv-quote
+     struct typed-structure const-typed-structure
+     ))
+
+(define define-keywords
+  '(define-values
+     define-type 
+     define-constructor 
+     ))
+
+;; ----------------------------------------------------------------------
+
+(define (top-level-parse-defs defs)
+  (set! unbound-env '())
+  (let-values ([(defs nuenv) (parse-defs defs empty-env)])
+    (values defs (map cdr unbound-env))))
+
+(define (top-level-parse-exp exp)
+  (set! unbound-env '())
+  (let ([ast (parse exp empty-env)])
+    (values ast (map cdr unbound-env))))
+
+(define unbound-env '())
+
+;; ----------------------------------------------------------------------
+
+(define syntax-error
+  (case-lambda
+   [(exp) (syntax-error exp "Bad syntax")]
+   [(exp s)
+    (mrspidey:error
+     (format "File ~s, Line ~s: ~a ~s" 
+             (file-name-from-path
+              (zodiac:location-file (zodiac:zodiac-start exp)))
+             (zodiac:location-line (zodiac:zodiac-start exp))
+             s (zodiac:stripper exp)))]))
+
+(define syntax-error-no-exp
+  (case-lambda
+   [(exp) (syntax-error-no-exp exp "Bad syntax")]
+   [(exp s)
+    (mrspidey:error
+     (format "File ~s, Line ~s: ~as" 
+             (file-name-from-path
+              (zodiac:location-file (zodiac:zodiac-start exp)))
+             (zodiac:location-line (zodiac:zodiac-start exp))
+             s))]))
+
+(define assert-syn
+  (case-lambda
+   [(exp x) (assert-syn exp x "Bad syntax")]
+   [(exp x s) (unless x (syntax-error exp s))]))
+
+(define parse-body
+  (lambda (o s f body env)
+    (assert (list? body))
+    (recur loop ([rest body])
+      (match rest
+        [(exp) (parse exp env)]
+        [(exp . rest)
+         (zodiac:make-begin-form o s f (box 0)
+                                 (parse exp env)
+                                 (loop rest))]))))
+
+(define do-bindings
+  (lambda (env syms)
+    (assert (list? syms))
+    (let* ([bindings
+            (map 
+             (match-lambda
+              [($ zodiac:symbol o s f sym)
+               (let ([bound (zodiac:make-bound o s f (box 0) sym sym)])
+                 (cons sym bound))]
+              [exp (syntax-error exp "Bad binding syntax")])
+             syms)]
+           [syms (map car bindings)]
+           [bounds (map cdr bindings)]
+           [nuenv (extend-env* env syms bounds)])
+      (values bounds nuenv))))
+
+(define do-bindingss
+  (lambda (env symss)
+    (recur loop ([env env][symss symss][boundss '()])
+      (if (null? symss)
+          (values (reverse boundss) env)
+          (let-values 
+           ([(bounds env) (do-bindings env (car symss))])
+           (loop env (cdr symss) (cons bounds boundss)))))))
+
+(define parse
+  ;; parses an expression
+  (lambda (exp env)
+    (pretty-debug-front `(parse ,(zodiac:stripper exp)))
+    (letrec ([lookup-sym
+              (lambda (sym s f env)
+                (let ([bound
+                        (or (lookup-or-#f env sym)
+                          (lookup-or-#f unbound-env sym)
+                          ;; Add to unbound-env
+                          (let ([n (zodiac:my-create-bound sym s f)])
+                            (set! unbound-env (cons (cons sym n) unbound-env))
+                            n))])
+                  ;;(set-bound-refs! bound (add1 (bound-refs bound)))
+                  bound))]
+             [parse-sym-env
+              (lambda (env)
+                (match-lambda
+                 [($ zodiac:symbol o s f sym)
+                  ;;(printf "ref sym ~s~n" sym)
+                  (zodiac:make-lexical-varref o s f (box 0) 
+                                              sym (lookup-sym sym s f env))]
+                 [exp (syntax-error exp "Expected a variable:")]))]
+             [parse-sym (parse-sym-env env)]
+             [call-void
+              (lambda (o s f)
+                (zodiac:make-app 
+                 o s f (box 0) 
+                 (zodiac:make-lexical-varref o s f (box 0) 
+                                             'void (lookup-sym 'void s f '()))
+                 '()))]
+             [parse-exps
+              (lambda (exps env)
+                (map (lambda (e) (parse e env)) exps))]
+             [handle-args
+              (lambda (args env)
+                (match args
+                  [($ zodiac:list _ _ _ args) (do-bindings env args)]
+                  [($ zodiac:symbol)          
+                   (let-values
+                       ([(bounds nuenv) (do-bindings env (list args))])
+                     (values (car bounds) nuenv))]
+                  [($ zodiac:improper-list _ _ _ l)
+                   (recur loop ([args '()][l l])
+                     (match l
+                       [(arg)
+                        (let-values
+                            ([(bounds nuenv) 
+                              (do-bindings env (cons arg args))])
+                          (values (append (reverse (cdr bounds)) (car bounds))
+                                  nuenv))]
+                       [(arg . rest) (loop (cons arg args) rest)]))]))])
+
+      (pretty-debug-front `(parse ,(zodiac:stripper exp)))
+      (match exp
+        ;; Identifiers
+        [($ zodiac:symbol o s f sym) (parse-sym exp)]
+
+        ;; Scalars, vectors
+        [(or ($ zodiac:scalar o s f) ($ zodiac:vector o s f))
+         (zodiac:make-quote-form o s f (box 0) exp)]
+
+        ;; Special forms
+        [($ zodiac:list o s f 
+            (and l (($ zodiac:symbol _ _ _ sym) . body)))
+         (=> fail)
+         (let ([sym (strip-hash-percent sym)])
+           (cond
+            [(memq sym keywords) 
+             (match (cons sym body)
+               [('cond)
+                (call-void o s f)]
+               [('delay exp)
+                (zodiac:make-delay-form o s f (box 0) (parse exp env))]
+               [('if test then else)
+                (zodiac:make-if-form o s f (box 0) 
+                                     (parse test env)
+                                     (parse then env)
+                                     (parse else env))]
+               [('if test then)
+                (zodiac:make-if-form o s f (box 0) 
+                                     (parse test env)
+                                     (parse then env)
+                                     (call-void o s f))]
+               [(or 
+                  ('set! var exp)
+                  ('set!-values ($ zodiac:list _ _ _ (var)) exp))
+
+                (let ([var (parse-sym var)])
+                  (when (zodiac:lexical-varref? var) 
+                    (zodiac:set-bound-mutated!
+                     (zodiac:lexical-varref-binding var)
+                     #t))
+                  (zodiac:make-set!-form o s f (box 0)
+                                         var (parse exp env)))]
+               [('quote sexp)
+                (assert-syn exp (= (length body) 1))
+                (zodiac:make-quote-form o s f (box 0) sexp)]
+               [('begin . exps)
+                (recur loop ([exps exps])
+                  (match exps
+                    [() (call-void o s f)]
+                    [(exp) (parse exp env)]
+                    [(exp . exps)
+                     (zodiac:make-begin-form o s f (box 0)
+                                             (parse exp env)
+                                             (loop exps))]))]
+               [('lambda args . bodies)
+                (let-values
+                 ([(bounds nuenv) (handle-args args env)])
+                 (zodiac:make-lambda-form o s f (box 0) 
+                                          bounds 
+                                          (parse-body o s f bodies nuenv)))]
+               [('case-lambda . cases)
+                (zodiac:make-case-lambda-form
+                 o s f (box 0)
+                 (mapLR
+                  (match-lambda
+                   [($ zodiac:list _ _ _ (args . body))
+                    (let-values
+                     ([(bounds nuenv) (handle-args args env)])
+                     (cons bounds (parse-body o s f body nuenv)))]
+                   [_ (syntax-error-no-exp exp "Bad case lambda")])
+                  cases))]
+
+               [('let-values
+                 ($ zodiac:list _ _ _
+                    (($ zodiac:list _ _ _ 
+                        (($ zodiac:list _ _ _ varss)
+                         exps))
+                     ...))
+                 . bodies)
+                (let-values
+                 ([(boundss nuenv) (do-bindingss env varss)])
+                 (zodiac:make-let-values-form 
+                  o s f (box 0)
+                  boundss
+                  (parse-exps exps env)
+                  (parse-body o s f  bodies nuenv)))]
+
+               [('letrec*-values
+                 ($ zodiac:list _ _ _
+                    (($ zodiac:list _ _ _ 
+                        (($ zodiac:list _ _ _ varss)
+                         exps))
+                     ...))
+                 . bodies)
+                (let-values
+                 ([(boundss nuenv) (do-bindingss env varss)])
+                  (for-each 
+                    (lambda (name) (zodiac:set-bound-mutated! name #t))
+                    (apply append boundss))
+                 (zodiac:make-letrec-values-form 
+                  o s f (box 0)
+                  boundss
+                  (parse-exps exps nuenv)
+                  (parse-body o s f  bodies nuenv)))]
+
+               ;; ---------------------------------------------------------
+               ;; MzScheme specific code
+
+               ;; --- units ---
+               [('unit ($ zodiac:list _ _ _ 
+                          (($ zodiac:symbol _ _ _ 'import) 
+                           i-ids ...))
+                       ($ zodiac:list _ _ _
+                          (($ zodiac:symbol _ _ _ 'export) 
+                           (or ($ zodiac:list _ _ _ 
+                                  (i-eids
+                                   ($ zodiac:symbol _ _ _ e-eids)))
+                               (and i-eids
+                                    ($ zodiac:symbol _ _ _ e-eids)))
+                           ...))
+                       . body)
+                (let*-vals ([(i-names env1) (do-bindings env i-ids)]
+                            [(defs env2) (parse-defs body env1)]
+                            [e-vars 
+                             (map (parse-sym-env env2) i-eids)]
+                            [exports (map cons e-vars e-eids)])
+                           (zodiac:make-unit-form o s f (box 0)
+                                                  i-names exports defs))]
+
+               ;; --- compound-units ---
+               [('compound-unit
+                 ($ zodiac:list _ _ _ 
+                    (($ zodiac:symbol _ _ _ 'import) 
+                     ($ zodiac:symbol _ _ _ imports) ...))
+                 ($ zodiac:list _ _ _ 
+                    (($ zodiac:symbol _ _ _ 'link) . links))
+                 ($ zodiac:list _ _ _ 
+                    (($ zodiac:symbol _ _ _ 'export) . exports))) 
+                (let*-vals 
+                 ([links
+                   (map
+                    (match-lambda
+                     [($ zodiac:list _ _ _
+                         (($ zodiac:symbol _ _ _ tag)
+                          ($ zodiac:list _ _ _ (exp . imports))))
+                      (list tag
+                            (parse exp env)
+                            (apply append
+                                   (map
+                                    (match-lambda
+                                     [($ zodiac:symbol _ _ _ sym)
+                                      (list (cons #f sym))]
+                                     [($ zodiac:list _ _ _
+                                         (($ zodiac:symbol _ _ _ tag)
+                                          ($ zodiac:symbol _ _ _ syms)
+                                          ...))
+                                      (map (lambda (sym) (cons tag sym))
+                                           syms)]
+                                     [_ (syntax-error exp "Bad link imp")])
+                                    imports)))]
+                     [_ (syntax-error exp "Bad link")])
+                    links)]
+                  [exports
+                   (apply 
+                    append
+                    (map
+                     (match-lambda
+                      [($ zodiac:list _ _ _
+                          (($ zodiac:symbol _ _ _ tag) 
+                           (or ($ zodiac:list _ _ _ 
+                                  (($ zodiac:symbol _ _ _ i-eids)
+                                   ($ zodiac:symbol _ _ _ e-eids)))
+                               (and ($ zodiac:symbol _ _ _ i-eids)
+                                    ($ zodiac:symbol _ _ _ e-eids))) ...))
+                       (map 
+                        (lambda (i-eid e-eid) (list tag i-eid e-eid))
+                        i-eids e-eids)]
+                      [_ (syntax-error exp "Bad link export")])
+                     exports))])
+                 (zodiac:make-compound-unit-form
+                  o s f (box 0) imports links exports))]
+
+               ;; --- invoke-unit ---
+               [('invoke-unit exp . ((and vars ($ zodiac:symbol)) ...))
+                (zodiac:make-invoke-unit-form
+                 o s f (box 0)
+                 (parse exp env) 
+                 (map (lambda (var) (parse-sym var env)) vars))]
+
+               ;; --- structures ---
+               [((or 'struct 'typed-structure 'const-typed-structure) 
+                 first
+                 ($ zodiac:list _ _ _ fields))
+                (let*-vals
+                 ([(tag parent)
+                   (match first
+                     [($ zodiac:symbol _ _ _ tag) (values tag #f)]
+                     [($ zodiac:list _ _ _
+                         (($ zodiac:symbol _ _ _ tag) parent))
+                      (values tag (parse parent env))])]
+                  [fields (map zodiac:stripper fields)])
+                 (zodiac:make-struct-form
+                  o s f (box 0)
+                  tag (eq? sym 'const-typed-structure) parent fields))]
+
+               ;; -------------------------------------------------------
+               ;; MrSpidey specific code
+
+               [('poly exp)
+                (zodiac:make-poly-form 
+                 o s f (box 0) (parse exp env))]
+               [(': exp type)
+                (zodiac:make-:-form o s f (box 0) 
+                                    (parse exp env)
+                                    (zodiac:stripper type))]
+
+               [('type:-quote
+                  ($ zodiac:list _ _ _ 
+                    (($ zodiac:symbol _ _ _ (or 'quote '#%quote))
+                      ($ zodiac:list _ _ _ (type  . attrs)))))
+                 (zodiac:make-type:-form o s f (box 0) 
+                   (zodiac:stripper type)
+                   (map zodiac:stripper attrs))]
+
+               [('st:control para val)
+                (zodiac:make-st:control-form o s f (box 0)
+                                             (zodiac:stripper para)
+                                             (zodiac:stripper val))]
+
+               [((or 'cache-exp-quote 'cache-inv-quote)
+                 ($ zodiac:list _ _ _ 
+                    (($ zodiac:symbol _ _ _ (or 'quote '#%quote)) exp))
+                 ($ zodiac:string _ _ _ za))
+                (when (string=? za (regexp-replace ".za$" za ""))
+                  (syntax-error exp "Cache filename must end in .za"))
+                (zodiac:make-cache-form 
+                 o s f (box 0) exp 
+                 (normalize-path za)
+                 (case sym
+                   [cache-exp-quote 'exp]
+                   [cache-inv-quote 'inv]
+                   [else 
+                    (mrspidey:internal-error 'parser "Bad sym ~s" sym)])
+                 (current-directory))]
+               
+               ;; -------------------------------------------------------
+               [else (syntax-error exp)])]
+            [(memq sym define-keywords) 
+             (syntax-error-no-exp exp "Defines not allowed")]
+            [else (fail)]))]
+
+        ;; Don't handle vectors or improper lists
+        ;; Applications
+              
+        [($ zodiac:list o s f (and l (fn . exps)))
+         (zodiac:make-app o s f (box 0) 
+                          (parse fn env)
+                          (parse-exps exps env))]
+        [($ zodiac:list o s f ())
+         (zodiac:make-quote-form o s f (box 0) '())]
+        [_ (syntax-error exp)]))))
+
+
+
+
+(define (parse-defs defs env)
+  (let*-vals
+    ([varss (mapLR 
+              (match-lambda
+                [($ zodiac:list _ _ _ 
+                   (($ zodiac:symbol _ _ _ '#%define-values)
+                     ($ zodiac:list _ _ _ vars)
+                     exp))
+                  vars]
+                [_ '()])
+              defs)]
+      [(boundss nuenv) (do-bindingss env varss)]
+      [_ (for-each 
+           (lambda (name) (zodiac:set-bound-mutated! name #t))
+           (apply append boundss))]
+      [defs
+        (map
+          (lambda (def bounds)
+            (pretty-debug-front `(parse-def ,(zodiac:stripper def)))
+            (mrspidey:zprogress "Parsing" (zodiac:zodiac-start def))
+            (match def
+              ;; Special forms
+              [($ zodiac:list o s f 
+                 (and l (($ zodiac:symbol _ _ _ sym) . body)))
+                (=> fail)
+                (let ([sym (strip-hash-percent sym)])
+                  (cond
+                    [(not (memq sym define-keywords)) (fail)]
+                    [else
+                      (match (cons sym body)
+
+                        [('define-values ($ zodiac:list _ _ _ vars) exp)
+                          (zodiac:make-define-values-form 
+                            o s f (box 0)
+                            (map 
+                              (match-lambda
+                                [(and bound ($ zodiac:bound o s f _ sym))
+                                  (zodiac:make-lexical-varref o s f (box 0) 
+                                    sym bound)])
+                              bounds)
+                            (parse exp nuenv))]
+
+                        ;; ----------------------------------------------------
+                        ;; MrSpidey specific code
+
+                        [('define-type ($ zodiac:symbol _ _ _ sym) type)
+                          (zodiac:make-define-type-form 
+                            o s f (box 0) 
+                            sym (zodiac:stripper type))]
+
+                        [('define-constructor ($ zodiac:symbol _ _ _ sym) 
+                           . modes)
+                          (let ([modes (map zodiac:stripper modes)])
+                            (assert-syn def (andmap boolean? modes))
+                            (zodiac:make-define-constructor-form o s f (box 0) 
+                              sym modes))]
+
+                        ;; ----------------------------------------------------
+                        [else (fail)])]))]
+
+              [exp (parse exp nuenv)]))
+          defs boundss)])
+    (unless (null? defs)
+      (mrspidey:zprogress "Parsing" (zodiac:zodiac-finish (rac defs))))
+    (values defs nuenv)))
+
+;; ----------------------------------------------------------------------
+
+
diff --git a/collects/mrspidey/Sba/poly.ss b/collects/mrspidey/Sba/poly.ss
new file mode 100644
index 0000000..5aaf828
--- /dev/null
+++ b/collects/mrspidey/Sba/poly.ss
@@ -0,0 +1,626 @@
+;; poly.ss
+;; ----------------------------------------------------------------------
+;; Preprocesses the program
+
+
+;; ----------------------------------------------------------------------
+
+(define debugging-topo #f)
+(defmacro pretty-debug-topo args
+  `(when debugging-topo (pretty-print ,@args)))
+
+; ======================================================================
+
+(define (st:poly file)
+  (st: (topo-file file)))
+  
+; ======================================================================
+
+(define-struct def-info (def out in to from color))
+
+(define (topo-file file)
+  (let ([file (normalize-path file)])
+    (let*-vals 
+      ( [sexps (zodiac:read* (open-code-file file) file)]
+        [(defs free-names)
+          (dynamic-let ([current-directory (path-only file)])
+            (top-level-parse-defs sexps))]
+        [prims-refd (map zodiac:bound-var free-names)]
+        [_ (pretty-debug-topo `(prims-refd ,prims-refd))]
+        [prim-sexps
+          (filter-map
+            (lambda (name)
+              (or
+                (ormap
+                  (match-lambda
+                    [(and d ('define (? (lambda (n) (eq? n name))) _))
+                      (let* ( [p (open-output-string)]
+                              [_ (pretty-print d p)]
+                              [_ (close-output-port p)]
+                              [p (open-input-string (get-output-string p))]
+                              [p (system-expand-if-necy p)]
+                              [d (zodiac:read p 
+                                   (zodiac:make-location 1 1 0 "prim-file"))])
+                        (d))]
+                    [_ #f])
+                  r4rs-prims)
+                (begin
+                  (unless (memq name real-primitives)
+                    (printf "Warning: Bad primitive ~s~n" name))
+                  #f)))
+            prims-refd)]
+        [_ (pretty-debug-topo `(prim-sexps ,(map zodiac:stripper prim-sexps)))]
+        [all-sexps (append prim-sexps sexps)]
+        [(defs free-names)
+          (dynamic-let ([current-directory (path-only file)])
+            (top-level-parse-defs all-sexps))]
+        [def->di
+          (lambda (def)
+            (let ([di (make-def-info def '() '() '() '() #f)])
+              (match def
+                [($ zodiac:define-values-form _ _ _ _ lvrs exp)
+                  (set-def-info-out! di 
+                    (map zodiac:lexical-varref-binding lvrs))
+                  (set-def-info-in! di (zodiac:free-refs exp))]
+                [exp (set-def-info-in! di (zodiac:free-refs exp))])
+              di))]
+        [di* (mapLR def->di defs)]
+        [_ (for-each
+             (lambda (di)
+               (pretty-debug-topo
+                 `(DEF ,(zodiac:stripper (def-info-def di))
+                    ,(map zodiac:bound-var (def-info-out di))
+                    ,(map zodiac:bound-var (def-info-in di)))))
+             di*)]
+
+        [_ (for-each
+             (lambda (di1)
+               (for-each
+                 (lambda (sym)
+                   (for-each
+                     (lambda (di2)
+                       (when (memq sym (def-info-out di2))
+                         (set-def-info-to! di1 
+                           (cons di2 (def-info-to di1)))
+                         (set-def-info-from! di2
+                           (cons di1 (def-info-from di2)))))
+                     di*))
+                 (def-info-in di1)))
+             di*)]
+           [_ (pretty-debug-topo "to/from fields filled")]
+                      
+           [dfs (lambda (di* field-sel)
+                  (for-each (lambda (di) (set-def-info-color! di 'white)) di*)
+                  (let ([done '()])
+                    (letrec ([visit 
+                              (lambda (di)
+                                (when (eq? (def-info-color di) 'white)
+                                  (set-def-info-color! di 'black)
+                                  (for-each visit (field-sel di))
+                                  (set! done (cons di done))))])
+                      (for-each visit di*)
+                      done)))]
+
+           ;; do topological sort. See "Intro to Algs", p. 489
+
+           [di*1 (dfs di* def-info-to)]
+           ;; di*1 contains definitions before references
+           [show-di
+            (lambda (di)
+              `(DEF
+                 ,(map zodiac:bound-var (def-info-out di))
+                 ,(map zodiac:bound-var (def-info-in di))))]
+           [show (lambda (str di*) 
+                   (pretty-debug-topo str)
+                   (pretty-debug-topo (map show-di di*)))]
+           [_ (show "di*1" di*1)]
+           [di*2 (dfs di*1 def-info-from)]
+           [_ (show "di*2" di*2)]
+           
+           ;; Calculate list of strongly connected components
+
+           [_ (for-each (lambda (di) (set-def-info-color! di 'white)) di*)]
+           [sccs
+            (mapLR
+             (lambda (di)
+               (let ([scc '()])
+                 (recur loop ([di di])
+                   (when (eq? (def-info-color di) 'white)
+                     (set-def-info-color! di 'black)                     
+                     (set! scc (cons di scc))
+                     (for-each loop (def-info-to di))))
+                 scc))
+             di*2)]
+           [sccs (filter (lambda (x) (not (null? x))) sccs)]
+
+           [_ (begin
+                (pretty-debug-topo 'SCCS)
+                (for-each (lambda (scc) (show "scc" scc)) sccs))]
+
+           [my-begin 
+            (lambda (first rest)
+              (make-zodiac:begin-form 
+               first rest
+               (zodiac:no-location)(zodiac:no-location) (box #f)))]
+         
+           [value-def?
+            (match-lambda
+             [($ zodiac:define-values-form _ _ _ _ _ exp)
+              (zodiac:value? exp)]
+             [_ #f])]
+           
+           ;; --- Figure out which are polymorphic
+           ;; Go from end up to know if multiple refs for each var
+           ;; A ref inside a polymorphic def counts as multiple refs
+
+           [vars-single-ref '()]
+           [vars-multi-ref '()]
+           [add-multi-ref!
+            (lambda (var)
+                (set! vars-multi-ref (set-add var vars-multi-ref)))]
+           [add-single-ref!
+            (lambda (var)
+              (if (element-of? var vars-single-ref)
+                  (add-multi-ref! var)
+                  (set! vars-single-ref (set-add var vars-single-ref))))]
+
+           [sccs2 ;; include polymorphism flag
+            (mapRL
+             (lambda (scc)
+               (let* ( [values?
+                         (andmap 
+                           (match-lambda 
+                             [($ def-info def out) (value-def? def)])
+                           scc)]
+                       [mutable? 
+                         '(ormap 
+                            (match-lambda
+                              [($ def-info def out)
+                                (ormap (lambda (o) (memq o mutable-syms)) out)])
+                            scc)]
+                       [mutable? #f]
+                       [defs (apply append (map def-info-out scc))]
+                       [refs (apply append (map def-info-in scc))]
+                       [multi-refs
+                         (match defs
+                           [(def) (element-of? def vars-multi-ref)]
+                           [() #f]
+                           [defs #t])]
+                       [poly-flag 
+                         (if (and values? (not mutable?))
+                           (if multi-refs 'poly 'poly1ref)
+                           #f)])
+
+                 (pretty-debug-topo
+                   `( defs  ,(map zodiac:bound-var defs) 
+                      refs ,(map zodiac:bound-var refs)
+                      values? ,values? mutable? ,mutable?
+                      multi-refs ,multi-refs poly-flag ,poly-flag))
+
+                 (if (eq? poly-flag 'poly)
+                   (for-each add-multi-ref! refs)
+                   (for-each add-single-ref! refs))
+
+                 (cons poly-flag scc)))
+             sccs)]
+
+        [_ (pretty-print
+             `(SCCS
+                ,(map
+                   (match-lambda
+                     [(poly . di*)
+                       (let* ( [o (apply append (map def-info-out di*))]
+                               [ov (map zodiac:bound-var o)])
+                         (case poly
+                           [poly (cons '-->POLY ov)]
+                           [poly1ref (cons '-->POLY1REF ov)]
+                           [#f ov]))])
+                   sccs2)))]
+
+        [nu-program
+          ;; Return new program
+          (apply append
+            (map
+              (match-lambda
+                [('poly .
+                   (($ def-info ($ zodiac:define-values-form _ _ _ _ 
+                                  (lvrs) exps))
+                     ...))
+                  (let ([syms
+                          (map (lambda (lvr)
+                                 (zodiac:bound-var 
+                                   (zodiac:lexical-varref-binding lvr)))
+                            lvrs)])
+                    (if (= (length syms) 1)
+                    `((define ,(car syms)
+                        (poly (letrec
+                                ([,(car syms) ,(zodiac:stripper (car exps))])
+                                ,(car syms)))))
+                      `((define-values ,syms
+                          (poly (letrec*-values 
+                                  ([,syms
+                                     (values 
+                                       ,@(map zodiac:stripper exps))])
+                                (values ,@syms)))))))]
+                [(_ . di*)
+                  (map zodiac:stripper (map def-info-def di*))])
+              sccs2))]
+
+        [outfile (regexp-replace ".ss$" file ".poly.ss")]
+        [_ (when (eq? outfile file)  
+             (error 'topo-file "Bad suffix on ~s" file))]
+        [_ (delete-file outfile)]
+        [p3 (open-output-file outfile)])
+
+      (printf "----------PROGRAM----------~n")
+      (for-each
+        (lambda (def)
+          (pretty-debug-topo def)
+          (pretty-print def p3))
+        nu-program)
+      
+      (close-output-port p3)
+      outfile)))
+
+; ======================================================================
+
+(define zodiac:value?
+  (match-lambda
+    [(or
+       ($ zodiac:quote-form)
+       ($ zodiac:lambda-form)
+       ($ zodiac:case-lambda-form)
+       ($ zodiac:lexical-varref)) #t]
+    [($ zodiac:letrec-values-form 
+       _ _ _ _ vars 
+       ((? zodiac:value?) ...)
+       (? zodiac:value?)) #t]
+    [_ #f]))
+
+;; ----------------------------------------------------------------------
+
+(define r4rs-prims
+  `((define caar (lambda (x) (car (car x))))
+    (define cadr (lambda (x) (car (cdr x))))
+    (define cdar (lambda (x) (cdr (car x))))
+    (define cddr (lambda (x) (cdr (cdr x))))
+    (define caaar (lambda (x) (car (car (car x)))))
+    (define caadr (lambda (x) (car (car (cdr x)))))
+    (define cadar (lambda (x) (car (cdr (car x)))))
+    (define caddr (lambda (x) (car (cdr (cdr x)))))
+    (define cdaar (lambda (x) (cdr (car (car x)))))
+    (define cdadr (lambda (x) (cdr (car (cdr x)))))
+    (define cddar (lambda (x) (cdr (cdr (car x)))))
+    (define cdddr (lambda (x) (cdr (cdr (cdr x)))))
+    (define caaaar (lambda (x) (car (car (car (car x))))))
+    (define caaadr (lambda (x) (car (car (car (cdr x))))))
+    (define caadar (lambda (x) (car (car (cdr (car x))))))
+    (define caaddr (lambda (x) (car (car (cdr (cdr x))))))
+    (define cadaar (lambda (x) (car (cdr (car (car x))))))
+    (define cadadr (lambda (x) (car (cdr (car (cdr x))))))
+    (define caddar (lambda (x) (car (cdr (cdr (car x))))))
+    (define cadddr (lambda (x) (car (cdr (cdr (cdr x))))))
+    (define cdaaar (lambda (x) (cdr (car (car (car x))))))
+    (define cdaadr (lambda (x) (cdr (car (car (cdr x))))))
+    (define cdadar (lambda (x) (cdr (car (cdr (car x))))))
+    (define cdaddr (lambda (x) (cdr (car (cdr (cdr x))))))
+    (define cddaar (lambda (x) (cdr (cdr (car (car x))))))
+    (define cddadr (lambda (x) (cdr (cdr (car (cdr x))))))
+    (define cdddar (lambda (x) (cdr (cdr (cdr (car x))))))
+    (define cddddr (lambda (x) (cdr (cdr (cdr (cdr x))))))
+    (define list (lambda a a))
+    (define length
+      (lambda (a)
+        (recur loop ((a a) (len 0))
+          (if (null? a)
+              len
+              (loop (cdr a) (+ 1 len))))))
+    (define append
+      (lambda a
+        (letrec ((app2 (lambda (a b)
+                         (if (null? a)
+                             b
+                             (cons (car a) (app2 (cdr a) b))))))
+          (recur loop ((a a))
+            (cond ((null? a) '())
+                  ((null? (cdr a)) (car a))
+                  (else (app2 (car a) (loop (cdr a)))))))))
+    (define reverse
+      (lambda (a)
+        (recur loop ((a a) (acc '()))
+          (if (null? a)
+              acc
+              (loop (cdr a) (cons (car a) acc))))))
+    (define list-tail
+      (lambda (a n)
+        (if (zero? n)
+            a
+            (list-tail (cdr a) (- n 1)))))
+    (define list-ref
+      (lambda (a n)
+        (if (zero? n)
+            (car a)
+            (list-ref (cdr a) (- n 1)))))
+    (define memq
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((eq? x (car a)) a)
+              (else (memq x (cdr a))))))
+    (define memv
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((eqv? x (car a)) a)
+              (else (memv x (cdr a))))))
+    (define member
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((equal? x (car a)) a)
+              (else (member x (cdr a))))))
+    (define assq
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((eq? x (car (car a))) (car a))
+              (else (assq x (cdr a))))))
+    (define assv
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((eqv? x (car (car a))) (car a))
+              (else (assv x (cdr a))))))
+    (define assoc
+      (lambda (x a)
+        (cond ((null? a) #f)
+              ((equal? x (car (car a))) (car a))
+              (else (assoc x (cdr a))))))
+    (define string->list
+      (lambda (s)
+        (recur loop ((n (- (string-length s) 1)) (acc '()))
+          (if (negative? n)
+              acc
+              (loop (- n 1) (cons (string-ref s n) acc))))))
+;    (define list->string
+;      (lambda (a)
+;        (apply string a)))
+    (define list->string
+      (lambda (a)
+        (letrec ([length
+                  (lambda (a)
+                    (recur loop ((a a) (len 0))
+                      (if (null? a)
+                          len
+                          (loop (cdr a) (+ 1 len)))))])
+          (let ((s (make-string (length a))))
+            (recur loop ((i 0) (a a))
+              (if (null? a)
+                  s
+                  (begin
+                    (string-set! s i (car a))
+                    (loop (+ 1 i) (cdr a)))))))))
+    (define vector->list
+      (lambda (v)
+        (recur loop ((n (- (vector-length v) 1)) (acc '()))
+          (if (negative? n)
+              acc
+              (loop (- n 1) (cons (vector-ref v n) acc))))))
+;    (define list->vector
+;      (lambda (a)
+;        (apply vector a)))
+    (define list->vector
+      (lambda (a)
+        (letrec ([length
+                  (lambda (a)
+                    (recur loop ((a a) (len 0))
+                      (if (null? a)
+                          len
+                          (loop (cdr a) (+ 1 len)))))])
+          (if (null? a)
+              (vector)
+              (let ((v (make-vector (length a) (car a))))
+                (recur loop ((i 1) (a (cdr a)))
+                  (if (null? a)
+                      v
+                      (begin
+                        (vector-set! v i (car a))
+                        (loop (+ 1 i) (cdr a))))))))))
+    (define map
+      (lambda (f a . args)
+        (letrec ((map1 (lambda (f l)
+                         (if (null? l)
+                             '()
+                             (cons (f (car l))
+                                   (map1 f (cdr l))))))
+                 (map2 (lambda (f l1 l2)
+                         (cond ((null? l1)
+                                '())
+                               ((null? l2)
+                                (error 'map "lists differ in length"))
+                               (else
+                                 (cons (f (car l1) (car l2))
+                                       (map2 f (cdr l1) (cdr l2)))))))
+                 (map* (lambda (f l*)
+                         (if (null? (car l*))
+                             '()
+                             (cons (let ((l (map1 car l*)))
+                                     (if (null? l)
+                                         (f)
+                                         (apply f l)))
+                                   (map* f (map1 cdr l*)))))))
+          (cond ((null? args)
+                 (map1 f a))
+                ((null? (cdr args))
+                 (map2 f a (car args)))
+                (else
+                  (map* f (cons a args)))))))
+    (define for-each
+      (lambda (f a . args)
+        (letrec ((map (lambda (f l)
+                         (if (null? l)
+                             '()
+                             (cons (f (car l))
+                                   (map f (cdr l)))))))
+          (letrec ((for-each1 (lambda (f l)
+                                (if (null? l)
+                                    (void)
+                                    (begin
+                                      (f (car l))
+                                      (for-each1 f (cdr l))))))
+                   (for-each2 (lambda (f l1 l2)
+                                (cond ((null? l1)
+                                       (void))
+                                      ((null? l2)
+                                       (error 'for-each "lists differ in length"))
+                                      (else
+                                        (f (car l1) (car l2))
+                                        (for-each2 f (cdr l1) (cdr l2))))))
+                   (for-each* (lambda (f l*)
+                                (if (null? (car l*))
+                                    (void)
+                                    (begin
+                                      (let ((l (map car l*)))
+                                        (if (null? l)
+                                            (f)
+                                            (apply f l)))
+                                      (for-each* f (map cdr l*)))))))
+            (cond ((null? args)
+                   (for-each1 f a))
+                  ((null? (cdr args))
+                   (for-each2 f a (car args)))
+                  (else
+                    (for-each* f (cons a args))))))))
+    (define call-with-input-file
+      (lambda (s f)
+        (let* ((p (open-input-file s))
+               (v (f p)))
+          (close-input-port p)
+          v)))
+    (define call-with-output-file
+      (lambda (s f)
+        (let* ((p (open-output-file s))
+               (v (f p)))
+          (close-output-port p)
+          v)))
+    (define with-input-from-file
+      (lambda (s f)
+        ; no way to switch current input in R4RS Scheme
+        (error 'with-input-from-file "not supported")
+        (f)))
+    (define with-output-to-file
+      (lambda (s f)
+        ; no way to switch current output in R4RS Scheme
+        (error 'with-output-to-file "not supported")
+        (f)))
+    
+    (define make-promise
+      (lambda (thunk)
+        (let ([first #t]
+              [val #f])
+          (lambda ()
+            (cond
+             [(eq? first 'forcing)
+              (error 'force "recursive force")]
+             [(eq? first #t)
+              (set! first 'forcing)
+              (set! val (thunk))
+              (set! first #f)
+              val]
+             [else val])))))
+    (define force (lambda (promise) (promise)))
+    (define make-list
+      (lambda (n val)
+        (recur loop ((n n))
+          (if (< n 1)
+              '()
+              (cons val (loop (- n 1)))))))
+    (define andmap
+      (lambda (f list0 . lists)
+        (if (null? list0)
+            (and)
+            (recur loop ((lists (cons list0 lists)))
+              (if (null? (cdr (car lists)))
+                  (apply f (map car lists))
+                  (and (apply f (map car lists))
+                       (loop (map cdr lists))))))))
+    (define ormap
+      (lambda (f list0 . lists)
+        (if (null? list0)
+            (or)
+            (recur loop ((lists (cons list0 lists)))
+              (if (null? (cdr (car lists)))
+                  (apply f (map car lists))
+                  (or (apply f (map car lists))
+                      (loop (map cdr lists))))))))
+    (define dynamic-wind
+      (lambda (in doit out)
+        (let* ([a (in)]
+               [b (doit)]
+               [c (out)])
+          b)))
+    (define not (lambda (x) (if x #f #t)))
+    (define add1 (lambda (x) (+ x 1)))
+    (define sub1 (lambda (x) (- x 1)))
+    (define equal? 
+      (lambda (x y)
+        (or (eqv? x y)
+            (and (pair? x) (pair? y) 
+                 (equal? (car x) (car y))
+                 (equal? (cdr x) (cdr y)))
+            (and (vector? x) (vector? y)
+                 (= (vector-length x) (vector-length y))
+                 (recur loop ([i (vector-length x)])
+                   (or (zero? i)
+                       (let ([i (- i 1)])
+                         (and (equal? (vector-ref x i) (vector-ref y i))
+                              (loop i)))))))))
+    (define negative? (lambda (x) (< x 0)))
+    (define list? (lambda (x) (or (null? x)
+                                  (and (pair? x) (list? (cdr x))))))
+    (define reverse!
+      (lambda (x)
+        (recur loop ([x x][p '()])
+          (let ([q (cdr x)])
+            (set-cdr! x p)
+            (if (null? q)
+                x
+                (loop q x))))))
+  (define even? (lambda (x) (or (zero? x) (odd? (sub1 x)))))
+  (define odd? (lambda (x) (even? (sub1 x))))
+))
+
+(define real-primitives
+  '(car cdr zero? null? nil null + - * / apply
+        number? cons pair? 
+        < > <= >= = <>
+        vector make-vector vector-length vector-ref vector-set!
+        void error display newline remainder quotient modulo abs expt min 
+        real-part even sqrt cos integer? exact?
+        eq? eqv?
+        call-with-values 
+        boolean? procedure? symbol? gensym
+        set-cdr! set-car! printf random 
+        string-ref symbol->string number->string symbol? char=? 
+        char? string? vector?
+     #%eqv #%void 
+     string->symbol string-append string<? #%global-defined-value
+))
+
+;; ----------------------------------------------------------------------
+
+(define (do-topo-files files)
+  (let* ([file-thunk* (files->file-thunk* files)]
+         [defs1 (load-parse-expand file-thunk*)]
+         [_ (set! defs-expanded defs1)]
+         [defs2 (map bind-def defs1)]
+         [_ (set! defs-bind defs2)]
+         [def (topological-sort defs2)])
+    (zodiac:expr-stripper def)))
+
+(define (test-topo files out)
+  (when (file-exists? out) (delete-file out))
+  (let* ([file-thunk* (files->file-thunk* files)]
+         [defs1 (load-parse-expand file-thunk*)]
+         [_ (set! defs-expanded defs1)]
+         [defs2 (map bind-def defs1)]
+         [_ (set! defs-bind defs2)]
+         [def (topological-sort defs2)])
+    (pretty-print (zodiac:expr-stripper def))))
+
+;; ----------------------------------------------------------------------
diff --git a/collects/mrspidey/Sba/program.ss b/collects/mrspidey/Sba/program.ss
new file mode 100644
index 0000000..3d57558
--- /dev/null
+++ b/collects/mrspidey/Sba/program.ss
@@ -0,0 +1,127 @@
+;; program.ss
+;; Handles cormac's program first-order structure for units
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; Global environment stuff
+
+(define global-def-env '())
+(define global-result (void))
+(define global-defs-parsed (void))
+
+;; ----------------------------------------------------------------------
+
+(define (analyze-program file)
+  ;; file should be normalized
+  (let ([file (normalize-path file)])
+    (pretty-debug `(analyze-program ,file , (path-only (normalize-path file))))
+    (init-constructor-env!)
+    (initialize-language!)
+    (init-expand!)
+    (clear-file-time-cache!)
+    (let*-vals 
+      ( [sexps (zodiac:read* (open-code-file file) file)]
+        [_ (when debugging-front
+             (printf "~n--Loaded program------------------~n")
+             (for-each 
+               (lambda (sexp) (pretty-print-debug (zodiac:stripper sexp)))
+               sexps)
+             (printf "----------------------------------~n"))]
+        [(defs free-names)
+          (parameterize ([current-load-relative-directory (path-only file)])
+            (my-scheme-expand-program sexps))]
+        [_ (set! global-defs-parsed defs)]
+        [_ (when debugging-front
+             (printf "~n--Parsed program------------------~n")
+             (for-each
+               (lambda (def) (pretty-print-debug (zodiac:stripper def)))
+               defs)
+             (printf "----------------------------------~n"))]
+        [init-env (get-default-bindings free-names)])
+
+      (pretty-debug `(init-env ,(atenv->pretty init-env)))
+      ;; Now do analyis 
+
+      (let-values ([(env refs result) (top-level-traverse-defs defs init-env)])
+
+        (pretty-debug '(fixing up envs))
+        (set! global-def-env env)
+        (set! global-result result)
+        ;;(assert (null? refs) refs (map zodiac:binding-var (map car refs)))
+        '(for-each
+           (lambda (ref)
+             (mrspidey:warning 
+               (format "Unbound variable ~s" (zodiac:binding-var (car ref)))))
+           refs)
+
+        ;; --- Fix up type variables
+        ;;(set! global-def-env (append global-def-env global-tdef-env))
+        (report-duplicate-defs global-tdef-env)
+        (report-unbound-vars 
+          (connect-refs-defs global-tref-env global-tdef-env))
+        (connect-bangs-defs global-tbang-env global-tdef-env)
+
+        (when (not (st:whole-program))
+          (put-context-top-s defs env result))
+
+        ;;(show-stat-small)
+
+        defs))))
+
+;; ----------------------------------------------------------------------
+
+(define (put-context-top-s defs env result)
+  (mrspidey:progress "Partial program analysis")
+  ;;(show-stat-small)
+  (when result (new-leq-top-s! (FlowType->Tvar result)))
+  (when (and defs env)
+    (for-each
+      (match-lambda
+        [($ zodiac:define-values-form _ _ _ _ refs)
+          (for-each
+            (lambda (ref)
+              (new-leq-top-s! 
+                (FlowType->Tvar
+                  (atenv:lookup env (zodiac:varref-binding ref)))))
+            refs)]
+        [_ (void)])
+      defs)))
+
+;; ---------------------------------------------------------------------- 
+;; initialize-analysis!
+
+(define (initialize-analysis!)
+  (pretty-debug '(initialize-analysis!))
+  (init-constructor-env!)
+  (let ([old-kernel (save-kernel-state)])
+    (init-kernel!)
+    ;; First free old stuff
+    (when (st:zero-old-constraint-sets) (free-kernel-state! old-kernel)))
+  (init-global-tenv! '() '() '())
+  (init-common-AV!)
+  (pretty-debug '(analysis-initialized)))
+
+;; ======================================================================
+
+(define (show-global)
+  (list 'DEF (atenv->pretty global-def-env)
+        ;;'TDEF (atenv->pretty global-tdef-env)
+    ))
+
+;; ----------------------------------------------------------------------
+
+
+
diff --git a/collects/mrspidey/Sba/results.ss b/collects/mrspidey/Sba/results.ss
new file mode 100644
index 0000000..ac620a5
--- /dev/null
+++ b/collects/mrspidey/Sba/results.ss
@@ -0,0 +1,289 @@
+; results.ss
+; Shows results of set-based analysis
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;--------------------------------------------------------------------
+; Configuration
+
+(define show-val-args #t)
+(define show-elements #t)
+(define show-AV #t)
+(define show-edgeto #t)
+(define show-constraint #t)
+
+;--------------------------------------------------------------------
+; Showing results
+
+(define st:show (lambda l (for-each show-ftype (apply select l))))
+
+(define show-ftype
+                                        ; Show value of ftype
+  (lambda (ftype)
+    (let* ([num (FlowType-num ftype)]
+            [arrowto (FlowType-arrowto ftype)]
+            [arrowfrom (FlowType-arrowfrom ftype)]
+            [var (FlowType-name ftype)]
+            [done #f]
+            [makespaces
+              (lambda (s)
+                (if done
+                  (printf "~a [~a]" (padr "" 20) s)
+                  (begin
+                    (set! done #t)
+                    (printf 
+                      "~a [~a]" 
+                      (padr (symbol->string var) 20)
+                      s))))])
+      (when (not (null? arrowto))
+        (makespaces "arrowto")
+        (for-each
+          (lambda (to) (printf "| ~a " (FlowType-name to)))
+          arrowto)
+        (newline))
+      (when (not (null? arrowfrom))
+        (makespaces "arrowfrom")
+        (for-each
+          (lambda (from) (printf "| ~a " (FlowType-name from)))
+          arrowfrom)
+        (newline))
+      (when (FlowType-type-annotation ftype)
+        (makespaces "visable")
+        (if (string? (FlowType-type-annotation ftype))
+          (display (FlowType-type-annotation ftype)))
+        (newline))
+      (when (FlowType-values-ftype ftype)
+        (makespaces "values-type")
+        (printf "~s~n" (FlowType-name (FlowType-values-ftype ftype))))
+
+      (if (Tvar? ftype)
+        (let* ( [Tvar ftype]
+                [objs (Tvar-objs Tvar)]
+                [constraints (Tvar-constraints Tvar)]
+                [edgeto (Tvar-edgeto Tvar)]
+                [edgefrom (Tvar-edgefrom Tvar)])
+
+          (if (and show-AV (not (null? (get-Tvar-objs Tvar))))
+            (begin
+              (makespaces "AV    ")
+              (begin0
+                (show-sba-objs (get-Tvar-objs Tvar))
+                (newline)))
+            '()) 
+          (if (and show-AV (not (null? (Tvar-orig-objs Tvar))))
+            (begin
+              (makespaces "origAV")
+              (begin0
+                (show-sba-objs (Tvar-orig-objs Tvar))
+                (newline)))
+            '())
+          (if #t
+            (begin
+              (makespaces "num   ")
+              (printf "~s~n" (FlowType-num Tvar)))
+            '())
+          (if (and show-constraint (not (null? (Tvar-constraints Tvar))))
+            (begin
+              (makespaces "constr")
+              ;; Show each constraint
+              (map 
+                (match-lambda 
+                  [($ con num template field-no Tvar sign)
+                    (printf "[~s ~s ~s -> ~s] "
+                      (if (template? template)
+                        (template-type template)
+                        template)
+                      field-no sign
+                      (Tvar-name Tvar))]
+                  [($ con-filter num ($ filter bool templates) Tvar)
+                    (printf "[filter ~s ~s -> ~s] "
+                      (map template-type templates)
+                      bool (Tvar-name Tvar))]
+                  [($ con-top-s)
+                    (printf "[top-s] ")])
+                (Tvar-constraints Tvar))
+              (newline)
+              '())
+            '())
+              
+          (if (and show-edgeto (not (null? edgeto)))
+            (begin
+              (makespaces "edgeto")
+              (map (lambda (to) 
+                     (printf "| ~a " (Tvar-name to)))
+                edgeto)
+              (newline)
+              edgeto)
+            '())
+          (if (and show-edgeto (not (null? edgefrom)))
+            (begin
+              (makespaces "edgefr")
+              (map (lambda (from) 
+                     (printf "| ~a " (Tvar-name from)))
+                edgefrom)
+              (newline)
+              edgefrom)
+            '())
+          (for-each
+            (lambda (name get-nt)
+              (if (and (get-nt Tvar)
+                    (not (null? (get-nt Tvar)))
+                    (not (null? (NT-rhs* (get-nt Tvar)))))
+                (begin
+                  (makespaces name)
+                  (for-each (match-lambda
+                              [($ rhs grsym nt)
+                                (printf "| ~a ~a "
+                                  (grsym->rep grsym)
+                                  (if (null? nt)
+                                    '()
+                                    (nt->sym nt)))])
+                    (NT-rhs* (get-nt Tvar)))
+                  (newline))
+                '()))
+            (list "L     " "U     " "PL    " "PU    "
+              )
+            (list Tvar-L Tvar-U Tvar-PL Tvar-PU
+              )))
+
+        (begin
+          (makespaces "fo-Atype")
+          (printf "~s~n" (FlowType->pretty ftype)))))))
+
+(define show-sba-objs
+  (lambda (objs)
+    (recur loop2 ([objs objs][dep '()])
+      (match objs
+        [()  dep]
+        [(AV . rest)
+          (match-let
+            ([(print-representation . new-dep)
+               (print-rep-AV AV)])
+            (printf "| ~s ~a " (AV-num AV) print-representation)
+            (loop2 rest (append new-dep dep)))]))))
+
+(define print-rep-AV
+  (match-lambda
+    [($ AV _ template misc fields+ fields-)
+      (cons
+        (list
+          (template-type template)
+          misc
+          (map Tvar-name (vector->list fields+))
+          (map Tvar-name (vector->list fields-)))
+        '())]))
+
+; ----------------------------------------------------------------------
+
+(define select
+  (lambda l
+    (if (null? l)
+      list-ftype
+      ;; list of names and nums
+      (apply append
+        (map
+          (lambda (v)
+            (filter-map
+              (lambda (Tvar)
+                (if (or (and (number? v) 
+                          (= (FlowType-num Tvar) v)))
+                  Tvar
+                  #f))
+              list-ftype))
+          l)))))
+
+; ----------------------------------------------------------------------
+
+(define (prods-NT nt)
+  (let ([named #f])
+    (for-each
+      (match-lambda
+        [($ rhs* grsym nt)
+          (printf "~a ->  ~a ~s~n" 
+            (padr (if named 
+                    ""
+                    (begin
+                      (set! named #t)
+                      (symbol->string (nt->sym nt))))
+              20)
+            (padr (grsym->rep grsym) 25)
+            (nt->sym nt))])
+      (NT-rhs* nt))))
+
+(define (prods-Tvar Tvar)
+  ;;(printf "Tvar: ~s~n" (Tvar-name Tvar))
+  (for-each
+    (lambda (nt) 
+      (if (NT? nt) 
+        (prods-NT nt)
+        (unless (null? nt)
+          (printf "Warning: Bad nt ~s~n" nt))))
+    (list (Tvar-L Tvar) (Tvar-LI Tvar) (Tvar-U Tvar) (Tvar-UI AVS))))
+
+(define (st:prods . l) (for-each prods-Tvar (apply select l)))
+
+; ----------------------------------------------------------------------
+
+(define show-stat
+  (lambda ()
+    (printf "STATISTICS:~n")
+    (let*
+      ( [list-ftype (filter Tvar? list-ftype)]
+        [numTvar (length list-ftype)]
+        [avg (lambda (x) (/ (truncate (* (/ x numTvar) 100)) 100.0))]
+        [show (lambda (name f)
+                (let* ([l (map f list-ftype)]
+                        [num (apply + l)]
+                        [avg (avg num)]
+                        [min (apply min l)]
+                        [max (apply max l)])
+                  (printf "   ~a: Total ~s Avg ~s min ~s max ~s~n"
+                    name num avg min max)))])
+      (show "edgeto  " (lambda (Tvar) (length (Tvar-edgeto Tvar))))
+      ;;(show "edgefrom" (lambda (Tvar) (length (Tvar-edgefrom Tvar))))
+      (show "con     " (lambda (Tvar) (length (Tvar-constraints Tvar))))
+      (show "AV      " 
+        (lambda (Tvar)
+          (let ([objs (Tvar-objs Tvar)])
+            (if (Tvar? objs) 0 (length (Tvar-objs Tvar))))))
+      (printf "num-AV  : ~s~n" num-AV)
+      (printf "num-Tvar : ~s~n" num-ftype)
+      (printf "num-AV-a: ~s~n" num-AV-in-Tvar)
+      ;;(printf "Tvar-tmp : ~s~n" counter-Tvar-tmp)
+      (match (hash-table-info)
+        [(size entries clashes)
+          (printf "Hashtbl : size ~s entries ~s clashes ~s~n" 
+            size entries clashes)])
+      )))
+
+(define show-stat-small
+  (lambda ()
+    (printf 
+      "STATS: Size ~s HWM ~s num-Tvar ~s num-AV ~s num-con ~s num-edge ~s num-AV-a ~s~n"
+      (constraint-system-size) 
+      max-constraint-system-size
+      num-ftype num-AV num-con
+      num-edge num-AV-in-Tvar)
+    (constraint-system-size)))
+
+(define (empty-vars)
+  (filter
+    (lambda (Tvar)
+      (if (null? (get-Tvar-objs Tvar))
+        (Tvar-name Tvar)
+        #f))
+    list-ftype))
diff --git a/collects/mrspidey/Sba/sdl.ss b/collects/mrspidey/Sba/sdl.ss
new file mode 100644
index 0000000..ec77eb1
--- /dev/null
+++ b/collects/mrspidey/Sba/sdl.ss
@@ -0,0 +1,804 @@
+;; sdl.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+; ======================================================================
+; Tvar->SDL compresses, calcs prods and creates sdl
+
+;(define Tvar 'dummy-Tvar)
+
+(define sdl-tvar (void))
+
+(define (Tvar->SDL Tvar)
+  (set! sdl-tvar Tvar)
+  (pretty-debug-sdl2 `(Tvar->SDL ,(Tvar-name Tvar)))
+  (let*-vals
+    ( [(Tvar approximated)
+        (if (eq? (st:sdl-fo) 'basic-types)
+          (copy-constraint-fo-w/-limits Tvar)
+          (values Tvar #f))]
+      [_ (pretty-debug-sdl2 `(Tvar->SDL copied ,(Tvar-name Tvar)))]
+      [nuTvar
+        (let*-vals
+          ([(live-Tvar cvt) 
+             (dynamic-let
+               ([st:minimize-respect-assignable-part-of-fields
+                  (st:show-assignable-part-of-fields)])
+               (pretty-debug-sdl2
+                 `(st:minimize-respect-assignable-part-of-fields
+                    ,(st:minimize-respect-assignable-part-of-fields)))
+               (minimize-constraints 
+                 (st:sdl-constraint-simplification)
+                 '() (list Tvar)
+                 list-ftype '()))]
+            [nuTvar (cvt Tvar)])
+          (pretty-debug-sdl2 `(nuTvar ,(Tvar-name nuTvar)))
+          nuTvar)]
+      [sdl (raw-Tvar->SDL nuTvar #f)])
+    (if approximated
+      `(approx ,sdl)
+      sdl)))
+
+;; (define (Tvar->SDL tvar) (Tvar-name tvar))
+
+;; ----------------------------------------------------------------------
+
+(define (copy-constraint-fo-w/-limits tvar)
+
+  (let*-vals
+    ( [mk-tvar-dots  
+        (lambda ()
+          (mk-Tvar-init-AV 'dots
+            (create-AV template-dots '() mt-vector mt-vector)))]
+      [tvar-L-dots (mk-tvar-dots)]
+      [tvar-U-dots (mk-tvar-dots)]
+      [approximated #f]
+      [ref-tvar-L-dots (lambda () (set! approximated #t) tvar-L-dots)]
+      [ref-tvar-U-dots (lambda () tvar-U-dots)]
+      [(tvar-reached? tvar-reached! list-tvar-reached)
+        (field->set alloc-Tvar-field)]
+      [(AV-reached? AV-reached! list-AV-reached)
+        (field->set alloc-AV-field)]
+      [(tvar-nu tvar-nu!) (alloc-Tvar-field)]
+      [(AV-nu AV-nu!)     (alloc-AV-field)]
+      [stack (list tvar)]
+      )
+
+    ;; doesn't do st:sdl-fo-depth-limit or st:sdl-fo-size-limit
+     
+    (recur reach ([tvar tvar])
+      (unless (tvar-reached? tvar)
+        (tvar-reached! tvar)
+        (for-each
+          (match-lambda
+            [(and AV ($ AV _ template _ fields+ fields-))
+              (unless (AV-reached? AV)
+                (AV-reached! AV)
+                (unless
+                  (or 
+                    (and
+                      (not (st:sdl-fo-ivars))
+                      (memq template-all-ivars
+                        (template-super-templates template)))
+                    (and
+                      (not (st:sdl-fo-struct-fields))
+                      (memq template-structure
+                        (template-super-templates template))))
+                  (vector-for-each reach fields+)
+                  (when (eq? template template-lam)
+                    (vector-for-each reach fields-))))])
+          (get-Tvar-objs tvar))))
+
+    (for-each
+      (lambda (tvar) (tvar-nu! tvar (mk-Tvar 'copy-constraint-fo-w/-limits)))
+      (list-tvar-reached))
+    (for-each
+      (match-lambda
+        [(and AV ($ AV _ (? (eqc? template-lam)) misc #(rng) #(dom)))
+          (AV-nu! AV 
+            (create-AV template-lam++ misc
+              (vector-map
+                (lambda (tvar) 
+                  (if (tvar-reached? tvar) (tvar-nu tvar) (ref-tvar-L-dots)))
+                (vector dom rng))
+              (vector)))]
+        [(and AV ($ AV _ template misc fields+ fields-))
+          (AV-nu! AV 
+            (create-AV template misc
+              (vector-map
+                (lambda (tvar) 
+                  (if (tvar-reached? tvar) (tvar-nu tvar) (ref-tvar-L-dots)))
+                fields+)
+              (vector-map
+                (lambda (_) (ref-tvar-U-dots))
+                fields-)))])
+      (list-AV-reached))
+    (for-each
+      (lambda (tvar) 
+        (let ([nu (tvar-nu tvar)])
+          (for-each
+            (lambda (AV)
+              (new-AV! nu (AV-nu AV)))
+            (get-Tvar-objs tvar))))
+      (list-tvar-reached))
+    (assert (tvar-reached? tvar) 'copy-sdl-size-k)
+    (pretty-debug-sdl2
+      `(copy-constraint-fo-w/-limits 
+         src ,(Tvar-name tvar)
+         result ,(Tvar-name (tvar-nu tvar))
+         size ,(length (list-AV-reached)) ,(length (list-tvar-reached))))
+    (values
+      (tvar-nu tvar)
+      approximated)))
+
+;; ----------------------------------------------------------------------
+; raw-Tvar->SDL calcs prods and creates sdl
+;
+; We use that Tvar-L, Tvar-U and AV-U fields for eq?-ness.
+; But by Tvar-L, we really mean prefixes of Tvar-L, etc.
+
+(define (raw-Tvar->SDL tvar mono)
+  ;; All reachable tvars are shown
+  (pretty-debug-sdl2 `(raw-Tvar->SDL ,(Tvar-name tvar)))
+  ;;(find-nonempty-tvars '() (list tvar))
+  (let*-vals
+    ( [mono-convert
+        (if mono
+          (match-lambda
+            [($ NT tvar 'L) (chk-Tvar-U tvar)]
+            [nt nt])
+          (lambda (nt) nt))]
+      [(env-crossover env-named-lfp) 
+        (choose-named-nts (chk-Tvar-U tvar) mono-convert)])
+    (letrec
+      ([sdl-ref
+         (lambda (nt) 
+           (let ([nt (mono-convert nt)])
+             (or (ormap
+                   (match-lambda [(z . Y) (and (eq? nt z) Y)])
+                   env-named-lfp)
+               (mk-sdl nt))))]
+        [mk-sdl
+          (lambda (nt)
+            (let ([sdl (NT->SDL nt sdl-ref #t)])
+              (if (bound-in-env? env-crossover (NT-tvar nt))
+                ((if (eq? (NT-type nt) 'U) absunion absintersect)
+                  sdl
+                  (lookup env-crossover (NT-tvar nt)))
+                sdl)))])
+      (let* ([binds
+               (map
+                 (match-lambda 
+                   [(y . name) (list name (mk-sdl y))])
+                 env-named-lfp)]
+              [body (sdl-ref (chk-Tvar-U tvar))]
+              [result (expand-output-type `(rec ,binds ,body))])
+        result))))
+
+;; ======================================================================
+ 
+(define choose-named-nts
+  ;; Returns (values env-crossover env-named-lfp)
+  ;; env-crossover maps Tvar to Xn
+  ;; env-named-lfp maps NT to Yn
+
+  (lambda (nt mono-convert)
+    (let* ( [traversed '()]
+            [named-lfp '()]
+            [stack '()])
+
+      (letrec
+        ( [traverse-convert
+            (lambda (nt)
+              (let* ( [nt (mono-convert nt)])
+                (unless (memq nt named-lfp)
+                  (let* ( [children '()]
+                          [ref (lambda (nt)
+                                 (set! children (cons nt children))
+                                 'blah)])
+                    (NT->SDL nt ref #f)
+                    (pretty-debug-sdl 
+                      `(traversing ,(nt->sym nt) 
+                         children ,(map nt->sym children)
+                         traversed  ,(map nt->sym traversed)
+                         stack  ,(map nt->sym stack)
+                         ))
+
+                    (let ([trivial 
+                            (or (null? children)
+                              (match nt
+                                [($ NT tvar 'U)
+                                  (and (Tvar? tvar)
+                                    (match (Tvar-objs tvar)
+                                      [() #t]
+                                      [(($ AV _ _ _ fields+)) 
+                                        (zero? (vector-length fields+))]
+                                      [_ #f]))]
+                                [_ #f]))])
+                      (pretty-debug `(trivial ,(nt->sym nt) ,trivial))
+                      (when (case (st:naming-strategy)  
+                              [(recursive) (memq nt stack)]
+                              [(multiple)  (and (memq nt traversed)
+                                             (not trivial))]
+                              [(nontrivial) (not trivial)]
+                              [(all) #t])
+                        ;; Name this element
+                        (pretty-debug-sdl
+                          `(naming ,(nt->sym nt) 
+                             ,(if (memq nt traversed) #t #f)
+                             children ,(map nt->sym children)
+                             ,trivial))
+                        (set! named-lfp (cons nt named-lfp))))
+                  (unless (memq nt traversed)
+                    (set! traversed (cons nt traversed))
+                    ;;(pretty-print '(traversing children))
+                    (let ([oldstk stack])
+                      (set! stack (cons nt stack))
+                      (for-each
+                        traverse-convert 
+                        children)
+                      (set! stack oldstk)))))))])
+        (traverse-convert nt)
+        (pretty-debug-sdl '(Traversed))
+
+        (let* ([crossover
+                 (intersect (select-L traversed) (select-U traversed))]
+                [env-crossover
+                  (map-with-n
+                    (lambda (y n) (cons y (symbol-append 'X (add1 n))))
+                    (reverse crossover))]
+                [env-named-lfp
+                  (map-with-n
+                    (lambda (y n) 
+                      (cons y (symbol-append 'Y (add1 n) ;;(nt->sym y)
+                                )))
+                    named-lfp)])
+
+          (pretty-debug-sdl
+            `(choose-named-nts
+               select-L ,(map Tvar-name (select-L traversed))
+               select-U ,(map (lambda (x) (and (Tvar? x) (Tvar-name x)))
+                           (select-U traversed))
+               crossover ,(map Tvar-name crossover)
+               named-lfp ,(map nt->sym named-lfp)
+               traversed ,(map nt->sym traversed)))
+
+          (values env-crossover env-named-lfp))))))
+
+; ======================================================================
+ 
+(define (NT->SDL nt ref-nt show?)
+  (pretty-debug-sdl `(NT->SDL ,(nt->sym nt) ,show?))
+  (let ([r
+          (match nt
+            [($ NT (? Tvar? tvar) 'U)
+              (when (st:listify-etc)
+                (listify-Tvar! tvar)
+                (boolify-Tvar! tvar)
+                (atomify-Tvar! tvar)
+                (sexpify-Tvar! tvar)
+                (classify-objectify-Tvar! tvar))
+              (absUnion
+                (map
+                  (lambda (AV) (ref-nt (chk-AV-U AV)))
+                  (get-Tvar-objs tvar)))]
+            [($ NT (? Tvar? tvar) 'L)
+              (absintersect
+                (absIntersect
+                  (recur loop ([con* (filter con? (Tvar-constraints tvar))])
+                    (match con*
+                      [() '()]
+                      [(($ con _ (and template ($ template _ _ _ ref assign))
+                          _ _ sign)
+                         . _)
+                        (let*-vals
+                          ([ (i-s-tvar* rest)
+                             (filter-map-split
+                               (match-lambda
+                                 [($ con _ 
+                                    (? (lambda (t) (eq? t template)))
+                                    f tvar s)
+                                   (cons (cons f s) tvar)]
+                                 [_ #f])
+                               con*)]
+                            [ref-i+
+                              (lambda (i)
+                                (absIntersect
+                                  (filter-map
+                                    (match-lambda
+                                      [(j-s . tvar2) 
+                                        (and 
+                                          (equal? (car j-s) i)
+                                          (cdr j-s)
+                                          (ref-nt (chk-Tvar-L tvar2)))])
+                                    i-s-tvar*)))]
+                            [ref-i-
+                              (lambda (i)
+                                (absUnion
+                                  (filter-map
+                                    (match-lambda
+                                      [(j-s . tvar2) 
+                                        (and 
+                                          (equal? (car j-s) i)
+                                          (cdr j-s)
+                                          (ref-nt (chk-Tvar-U tvar2)))])
+                                    i-s-tvar*)))]
+                            [this 
+
+                              (cond
+                                [(eq? template template-lam)
+                                  (list (ref-i- 0) '*->* (ref-i+ 1))]
+                                [(eq? template template-lam++)
+                                  (list (ref-i+ 0) '*->* (ref-i+ 1))]
+                                [(st:show-assignable-part-of-fields)
+                                  (list
+                                    (template-type template)
+                                    (map ref-i+ 
+                                      (filter number? (vector->list ref)))
+                                    (map ref-i-
+                                      (filter number? (vector->list assign))))]
+                                [(and 
+                                   (eq? (vector-length ref) 1)
+                                   (not (vector-ref ref 0)))
+                                  ;; Show single antimono field
+                                  (list (template-type template) (ref-i- 0))]
+                                [else
+                                  ;; Only show ref'able fields
+                                  (cons
+                                    (template-type template)
+                                    (map ref-i+
+                                      (filter number? (vector->list ref))))])])
+
+                          (cons this (loop rest)))])))
+                (absIntersect
+                  (filter-map
+                    (match-lambda
+                      [($ con-filter _ _ tvar2)
+                        (ref-nt (chk-Tvar-L tvar2))]
+                      [_ #f])
+                    (Tvar-constraints tvar)))
+                (absIntersect
+                  (map
+                    (lambda (tvar2) (ref-nt (chk-Tvar-L tvar2)))
+                    (Tvar-edgeto tvar))))]
+
+            [($ NT
+               (and AV ($ AV _ (and template ($ template _ _ _ ref assign)) 
+                         misc fields+ fields-))
+               'U)
+              (let ([ref-i+
+                      (lambda (i)
+                        (ref-nt (chk-Tvar-U (vector-ref fields+ i))))]
+                     [ref-i-
+                       (lambda (i)
+                         (ref-nt (chk-Tvar-L (vector-ref fields- i))))])
+
+                (cond 
+                  [(or 
+                     (eq? template template-lam)
+                     (eq? template template-lam++))
+
+                    (if (and 
+                          (atprim? misc) 
+                          (not (eq? (st:primitive-types) 'inferred)))
+
+                      ;; Is a primitive
+                      (when show?
+                        (case (st:primitive-types)
+                          [(prim) `(prim ,(atprim-sym misc))]
+                          [(given) (atprim-orig-type misc)]))
+
+                      ;; Print as lambda
+                      (let*-vals ( [(dom rng)
+                                     (if (eq? template template-lam)
+                                       (values (ref-i- 0) (ref-i+ 0))
+                                       (values (ref-i+ 0) (ref-i+ 1)))])
+                        (when show?
+                          (match
+                            (match misc
+                              [('lam-info nargs restarg)
+                                (pretty-domain-list dom nargs restarg)]
+                              [_ (pretty-domain-list dom 0 #t)])
+                            [(args ())
+                              (append args (list '->* rng))]
+                            [(args restarg)
+                              (append args (list restarg '*->* rng))]))))]
+
+                  ;; Not a lambda
+                  [(memq (template-type template) '(object class))
+                    (cons 
+                      (template-type template)
+                      (map-with-n
+                        (lambda (ivar-sym n) (list ivar-sym (ref-i+ n)))
+                        misc))]
+
+                  [(st:show-assignable-part-of-fields)
+                    (list
+                      (template-type template)
+                      (map ref-i+ (filter number? (vector->list ref)))
+                      (map ref-i- (filter number? (vector->list assign))))]
+                  [(and 
+                     (eq? (vector-length ref) 1)
+                     (not (vector-ref ref 0)))
+                    (list (template-type template) (ref-i- 0))]
+                  [(and 
+                     (eq? (vector-length ref) 0)
+                     (eq? (vector-length assign) 0)
+                     (st:constants)
+                     (or (number? misc) (symbol? misc) (char? misc)))
+                    (if (symbol? misc) (list 'quote misc) misc)]
+                  [else
+                    (cons 
+                      (template-type template)
+                      (map ref-i+ (filter number? (vector->list ref))))]))])])
+
+    (pretty-debug-sdl `(NT->SDL ,(nt->sym nt) = ,r))
+    r))
+
+;; ----------------------------------------------------------------------
+
+(define (pretty-domain-list dom nargs restarg)
+  (recur loop ([args '()][dom dom][nargs nargs])
+    (match dom
+      [('cons arg restarg)
+       (loop (cons arg args) restarg (sub1 nargs))]
+      [('nil)
+       (list (reverse args) '())]
+      ['_
+       (cond
+        [(> nargs 0)
+         (loop (cons '_ args) '_ (sub1 nargs))]
+        [restarg 
+         (list (reverse args) '_)]
+        [else
+         (list (reverse args) '())])]
+      [dom (list (reverse args) dom)])))
+
+(define (pretty-range-list rng nrngs)
+  (list '() rng))
+
+; ======================================================================
+
+(define template-listof (constructor->template 'listof #f))
+
+(define template-bool (constructor->template 'bool))
+
+(define template-atom (constructor->template 'atom))
+
+(define template-sexp (constructor->template 'sexp))
+
+; ----------------------------------------------------------------------
+
+(define (listify-Tvar! tvar)
+  ;; If Tvar contains (union nil (cons x tvar))
+  ;; then replace by (list x)
+  ;;(pretty-print (get-Tvar-objs tvar))
+  ;; (show-sba-Tvar tvar)
+  (match (get-Tvar-objs tvar)
+    [(or 
+       ( ($ AV _ (? (is-template? 'nil)))
+         ($ AV _ (? (is-template? 'cons)) _ 
+           #(a (? (lambda (d) (eq? d tvar))))))
+       ( ($ AV _ (? (is-template? 'cons)) _ 
+           #(a (? (lambda (d) (eq? d tvar)))))
+         ($ AV _ (? (is-template? 'nil)))))
+      (set-Tvar-objs! tvar '())
+      (new-AV! tvar (create-AV template-listof '() (vector a) (vector)))]
+    [_ (void)]))
+
+(define (boolify-Tvar! tvar)
+  ;; If Tvar contains (union true false)
+  ;; then replace those by bool
+  (let* ([bool-things '(true false)])
+    (when
+      (andmap
+        (lambda (bool-thing)
+          (ormap
+            (lambda (AV) (eq? (template-type (AV-template AV)) bool-thing))
+            (get-Tvar-objs tvar)))
+        bool-things)
+      ;; Do substitution
+      (set-Tvar-objs! tvar
+        (filter
+          (lambda (AV) 
+            (not (memq (template-type (AV-template AV)) bool-things)))
+          (get-Tvar-objs tvar)))
+      (new-AV! tvar (create-AV template-bool '() (vector) (vector))))))
+
+(define (atomify-Tvar! tvar)
+  ;; If Tvar contains (union nil num sym str char bool)
+  ;; then replace those by atom
+  (let* ([atom-things '(nil num sym str char bool)])
+    (when
+      (andmap
+        (lambda (atom-thing)
+          (ormap
+            (lambda (AV) (eq? (template-type (AV-template AV)) atom-thing))
+            (get-Tvar-objs tvar)))
+        atom-things)
+      ;; Do substitution
+      (set-Tvar-objs! tvar
+        (filter
+          (lambda (AV) 
+            (not (memq (template-type (AV-template AV)) atom-things)))
+          (get-Tvar-objs tvar)))
+      (new-AV! tvar (create-AV template-atom '() (vector) (vector))))))
+
+(define (sexpify-Tvar! tvar)
+  ;; If Tvar l contains (union atom (box l) (vec l) (cons l l)), 
+  ;; then replace those by sexp
+  (let* ([sexp-things '(atom box cons vec)])
+    (when
+      (andmap
+        (lambda (sexp-thing)
+          (ormap
+            (match-lambda
+              [($ AV _ ($ template type _ ref) _ fields+)
+                (and (eq? type sexp-thing)
+                  (or (zero? (vector-length fields+))
+                    (eq?  (vector-ref fields+ 0) tvar)))])
+            (get-Tvar-objs tvar)))
+        sexp-things)
+      ;; Do substitution
+      (printf "Do substitution")
+      (set-Tvar-objs! tvar
+        (filter
+          (lambda (AV) 
+            (not (memq (template-type (AV-template AV)) sexp-things)))
+          (get-Tvar-objs tvar)))
+      (new-AV! tvar (create-AV template-sexp '() (vector) (vector))))))
+
+(define (classify-objectify-Tvar! tvar)
+  ;; For each ivarset in tvar,
+  ;; build an object AV 
+
+  (pretty-debug-sdl `(classify-objectify-Tvar! ,(FlowType-name tvar)))
+
+  (letrec
+    ([make-thingy
+       (lambda (tvar-get-ivars tvar-put-thingy name 
+                 ivar-syms parent-ivars)
+         (recur loop ([ivar-syms ivar-syms][parent-ivars parent-ivars])
+           ;; to ivar parents
+           (for-each
+             (match-lambda
+               [($ AV _ 
+                  (? (lambda (t) (eq? t template-ivarset)))
+                  ivar-extra-syms
+                  #(parent-parent-ivars))                
+                 (loop
+                   (append ivar-syms ivar-extra-syms)
+                   parent-parent-ivars)]
+               [_ (void)])
+             (Tvar-objs parent-ivars))
+           ;; make thingy for this
+           (when (or 
+                   (null? (Tvar-objs parent-ivars))
+                   (ormap
+                     (lambda (AV)
+                       (not (eq? (AV-template AV) template-ivarset)))
+                     (Tvar-objs parent-ivars)))
+             (pretty-debug-sdl2 `(all-ivars ,name ,ivar-syms))
+             (let* 
+               ( [ivar-syms (list->set ivar-syms)]
+                 [ivar-syms
+                   (sort 
+                     (lambda (s1 s2)
+                       (string<? 
+                         (symbol->string s1)
+                         (symbol->string s2)))
+                     ivar-syms)]
+                 [n+ (length ivar-syms)]
+                 [template-thingy
+                   (make-template 
+                     name n+ 0
+                     (list->vector
+                       (recur loop ([n 0])
+                         (if (= n n+) '() (cons n (loop (add1 n))))))
+                     (vector)
+                     '()
+                     eq?)]
+                 [fields+
+                   (list->vector
+                     (map
+                       (lambda (ivar-sym)
+                         (let ([tvar-field (mk-Tvar 'object-field)])
+                           (new-con! tvar-get-ivars
+                             (create-con
+                               (get-ivar-template ivar-sym)
+                               0 tvar-field #t))
+                           tvar-field))
+                       ivar-syms))])
+               (pretty-debug-sdl2 `(ivarset ,ivar-syms))
+               (new-AV! tvar-put-thingy
+                 (create-AV template-thingy 
+                   ivar-syms fields+ (vector)))))))])
+
+    (for-each
+      (match-lambda
+        [($ AV _
+           (? (lambda (t) (eq? t template-internal-class)))
+           misc
+           #(_ alpha_o _ _ alpha_v))
+
+          (make-thingy alpha_o tvar 'class '() alpha_v)]
+          
+        [($ AV _ 
+           (? (lambda (t) (eq? t template-ivarset)))
+           ivar-syms
+           #(parent-ivars))
+
+          (make-thingy tvar tvar 'object ivar-syms parent-ivars)]
+
+        [_ (void)])
+      (Tvar-objs tvar))
+
+    ;; Now drop any ivar, ivarset and class from the tvar
+    (set-Tvar-objs! tvar
+      (filter
+        (lambda (AV)
+          (let ([t (AV-template AV)])
+            (not
+              (or
+                (memq template-all-ivars (template-super-templates t))
+                (eq? t template-ivarset)
+                (eq? t template-internal-class)))))
+        (Tvar-objs tvar)))))
+
+; ----------------------------------------------------------------------
+
+'(define (copy-depth-k tvar k)
+  (let*-vals
+    ( [tvar-dots 
+        (mk-Tvar-init-AV 'dots
+          (create-AV template-dots '() mt-vector mt-vector))]
+      [tvar-empty
+        (mk-Tvar 'depth-k-empty)]
+      [(tvar-reached? tvar-reached! list-tvar-reached)
+        (field->set alloc-Tvar-field)]
+      [(AV-reached? AV-reached! list-AV-reached)
+        (field->set alloc-AV-field)]
+      [(tvar-nu tvar-nu!) (alloc-Tvar-field)]
+      [(AV-nu AV-nu!)     (alloc-AV-field)]
+      )
+
+    (recur loop ([tvar tvar][k k])
+      (when
+        (and 
+          (not (zero? k))
+          (not (tvar-reached? tvar)))
+        (tvar-reached! tvar)
+        (for-each
+          (match-lambda
+            [(and AV ($ AV _ _ _ fields+))
+              (AV-reached! AV)
+              (vector-for-each
+                (lambda (tvar2) (loop tvar2 (sub1 k)))
+                fields+)])
+          (get-Tvar-objs tvar))))
+
+    (for-each
+      (lambda (tvar) (tvar-nu! tvar (mk-Tvar 'copy-depth-k)))
+      (list-tvar-reached))
+    (for-each
+      (match-lambda
+        [(and AV ($ AV _ template misc fields+ fields-))
+          (AV-nu! AV 
+            (create-AV template misc
+              (vector-map
+                (lambda (tvar) 
+                  (if (tvar-reached? tvar) (tvar-nu tvar) tvar-dots))
+                fields+)
+              (vector-map
+                (lambda (_) tvar-empty)
+                fields-)))])
+      (list-AV-reached))
+    (for-each
+      (lambda (tvar) 
+        (let ([nu (tvar-nu tvar)])
+          (for-each
+            (lambda (AV)
+              (new-AV! nu (AV-nu AV)))
+            (get-Tvar-objs tvar))))
+      (list-tvar-reached))
+    (pretty-debug-sdl2
+      `(copy-depth-k 
+         src ,(Tvar-name tvar)
+         depth ,k
+         result ,(Tvar-name (tvar-nu tvar))
+         size ,(length (list-AV-reached)) ,(length (list-tvar-reached))))
+    (tvar-nu tvar)))
+
+;; ----------------------------------------------------------------------
+    
+'(define (copy-sdl-size-k tvar k)
+
+   (let*-vals
+     ( [tvar-dots 
+         (mk-Tvar-init-AV 'dots
+           (create-AV template-dots '() mt-vector mt-vector))]
+       [tvar-empty
+         (mk-Tvar 'depth-k-empty)]
+       [(tvar-reached? tvar-reached! list-tvar-reached)
+         (field->set alloc-Tvar-field)]
+       [(AV-reached? AV-reached! list-AV-reached)
+         (field->set alloc-AV-field)]
+       [(tvar-nu tvar-nu!) (alloc-Tvar-field)]
+       [(AV-nu AV-nu!)     (alloc-AV-field)]
+       [stack (list tvar)]
+       )
+
+     (recur loop ()
+       (unless (>= 0 k)
+         (match stack
+           [(tvar . rest)
+             (set! stack rest)
+             (if (tvar-reached? tvar)
+               (loop)
+               (begin
+                 (set! k (sub1 k))
+                 (tvar-reached! tvar)
+                 (for-each
+                   (match-lambda
+                     [(and AV ($ AV _ _ _ fields+))
+                       (unless (AV-reached? AV)
+                         (set! k (sub1 k))
+                         (AV-reached! AV)
+                         (set! stack 
+                           (append stack (reverse (vector->list fields+)))))])
+                   (get-Tvar-objs tvar))
+                 (loop)))]
+           [() (void)])))
+
+     (for-each
+       (lambda (tvar) (tvar-nu! tvar (mk-Tvar 'copy-depth-k)))
+       (list-tvar-reached))
+     (for-each
+       (match-lambda
+         [(and AV ($ AV _ template misc fields+ fields-))
+           (AV-nu! AV 
+             (create-AV template misc
+               (vector-map
+                 (lambda (tvar) 
+                   (if (tvar-reached? tvar) (tvar-nu tvar) tvar-dots))
+                 fields+)
+               (vector-map
+                 (lambda (_) tvar-empty)
+                 fields-)))])
+       (list-AV-reached))
+     (for-each
+       (lambda (tvar) 
+         (let ([nu (tvar-nu tvar)])
+           (for-each
+             (lambda (AV)
+               (new-AV! nu (AV-nu AV)))
+             (get-Tvar-objs tvar))))
+       (list-tvar-reached))
+     (assert (tvar-reached? tvar) 'copy-sdl-size-k k)
+     (pretty-debug-sdl2
+       `(copy-depth-k 
+          src ,(Tvar-name tvar)
+          depth ,k
+          result ,(Tvar-name (tvar-nu tvar))
+          size ,(length (list-AV-reached)) ,(length (list-tvar-reached))))
+     (tvar-nu tvar)))
+
+
+
+;; ----------------------------------------------------------------------
+    
+        
+      
diff --git a/collects/mrspidey/Sba/seperate.ss b/collects/mrspidey/Sba/seperate.ss
new file mode 100644
index 0000000..8955783
--- /dev/null
+++ b/collects/mrspidey/Sba/seperate.ss
@@ -0,0 +1,110 @@
+;; seperate.ss
+;; Handles seperate compilation part
+;; ----------------------------------------------------------------------
+
+(define (seperately-analyze-file file-thunk* out-file)
+  ;; Prepare language
+  (when (eq? (select-language) 'none) (mrspidey:error "No language selected"))
+  (init-input-type-expander!)
+  (init-current-constructor-env!)
+
+  (match-let*
+      ([defs1 (load-parse-expand file-thunk*)]
+       [_ (set! defs-expanded defs1)]
+       [_ (init-kernel!)]
+       [_ (init-misc-analysis)]
+       [((out-env* in-env*) ...) 
+        (map-with-n
+         (lambda (def n)
+           (mrspidey:progress 'analyze (/ (add1 n) (length defs1)))
+           (traverse-def def))
+         defs1)]
+       [instantiate-env*
+        (lambda (env*)
+          (apply append 
+                 (map (lambda (env)
+                        (map
+                         (match-lambda
+                          [(and b (_ . (? AVS? AVS))) b]
+                          [(sym . (? procedure? thunk)) (cons sym (thunk))])
+                         env))
+                      env*)))]
+       [out-env (instantiate-env* out-env*)]
+       [in-env  (instantiate-env* in-env*)]
+       [extract-AVS (lambda (env) (map cdr env))]
+       [AVS-out (extract-AVS out-env)]
+       [AVS-in  (extract-AVS in-env)]
+       [(AVS-live AVS->nu) (minimize-constraints AVS-out AVS-in)]
+       [convert-env
+        (lambda (env) 
+          (map
+           (match-lambda
+            [(sym . AVS) (cons sym (AVS->nu AVS))])
+           env))]
+       [out-env (convert-env out-env)]
+       [in-env  (convert-env in-env)])
+
+    (write-constraint-set out-file AVS-live out-env in-env)))
+
+;; ----------------------------------------------------------------------
+
+(define (write-constraint-set file AVS-live out-env in-env)
+  (let* ([p (open-output-port file)]
+         [disp (lambda (x) (display x p) (newline p))]
+         [tag (gensym)]
+         [rep-constraint
+          (match-lambda
+           [($ con _ ($ template type) field-no ($ AVS num))
+            (list 'con type field-no num)]
+           [($ con-filter _ ($ filter sign (($ template types) ...)) 
+               ($ AVS num))
+            (list 'con-filter sign types num)])])
+
+    ;; --- write AV and AVS's
+    (disp num-AVS)
+    (disp num-AV) 
+    ;; --- write constructor-env
+    (disp constructor-env)
+    ;; --- write AV
+    (for-each
+     (lambda (AVS)
+       (for-each
+        (match-lambda 
+         [(and AV ($ AV num ($ template type) misc fields))
+          (unless (eq? (AV-aux AV) tag)
+            (disp (list 'AV num type misc (map AVS-num fields)))
+            (set-AV-aux! AV tag))])
+        (AVS-orig-objs AVS)))
+     list-AVS)
+    ;; --- write AVS
+    (for-each
+     (match-lambda 
+      [($ AVS num orig-objs _ constraints edgeto)
+       (disp (list `AVS num
+                   (map AVS-num orig-objs)
+                   (map rep-constraint constraints)
+                   (map AVS-num edgeto)))])
+     AVS-live)
+    ;; --- write out-env, in-env
+    (disp `(out-env ,@(map AVS-nu out-env)))
+    (disp `(in-env  ,@(map AVS-nu in-env)))
+    ;; --- all done
+    (close-output-port p)))
+
+;; ----------------------------------------------------------------------
+
+(define (read-constraint-set file)
+  ;; returns AVS-live out-env in-env
+1
+)
+
+;; ----------------------------------------------------------------------
+
+(define (ts file)
+  (parameterize 
+   ([mrspidey:progress-handler (mrspidey:text-progress)]
+    [mrspidey:error-handler    mrspidey:text-error])
+   (seperately-analyze-file (files->file-thunk* file) "test/out.za")))
+
+              
+       
diff --git a/collects/mrspidey/Sba/sigs.ss b/collects/mrspidey/Sba/sigs.ss
new file mode 100644
index 0000000..2bd482d
--- /dev/null
+++ b/collects/mrspidey/Sba/sigs.ss
@@ -0,0 +1,685 @@
+;; sba-sigs.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+(define-signature mzlib:unprefixed-core^
+  ( (open mzlib:pretty-print^)
+    (open mzlib:file^)
+    (open mzlib:function^)
+    (open mzlib:compat^) 
+    (open mzlib:string^)))
+
+(define-signature mrspidey:library-paras^ 
+  (make-parameter-boolean
+   make-parameter-integer
+   make-parameter-list))
+
+(define-signature mrspidey:library-list^
+  (mapLR
+   mapRL
+   foldl-with-n
+   foldr2
+   filter
+   filter-map
+   filter-map-split
+   rac
+   rdc
+   map-with-n
+   for-each-with-n
+   map-ilist
+   length-ilist
+   improper?
+   flatten-ilist
+   map2
+   for-each2
+   andmap2
+   andmap2len
+   ormap2
+   list-n-copies
+   count
+   get-prefix
+   mklist
+   nth
+   list-pos
+   list-pos-equal
+   find
+   index
+))
+
+(define-signature mrspidey:library-vec^
+  ( vector-copy
+    vector-map1
+    vector-map2
+    vector-map
+    vector-for-each-with-n
+    vector-for-each
+    vector-andmap1
+    vector-andmap2
+    vector-andmap
+    vector-ormap1
+    vector-ormap2
+    vector-ormap
+    vector-zero!))
+
+(define-signature mrspidey:library-set^
+  (empty-set
+   empty-set? 
+   set
+   list->set
+   list->set-equal?
+   element-of?
+   cardinality
+   set<=
+   set-eq?
+   union2
+   union
+   setdiff2
+   setdiff
+   intersect2
+   intersect))
+
+(define-signature mrspidey:library-misc^
+  (symbol-append
+    get-cpu-time
+    get&return-cpu-time
+    make-timer
+    clear-timer!
+    record-time
+    strip-string
+    padl
+    padr
+    chop-number
+    substring?
+    char-find
+    file-newer
+    eqc?
+    ))
+
+(define-signature
+  mrspidey:env^
+  ( empty-env lookup-or-fail lookup-or-#f lookup bound-in-env?
+    extend-env extend-env* join-env bang-env!
+    env:change-binding env:remove
+    ))
+
+(define-signature mrspidey:library^
+  ((open mrspidey:library-paras^)
+   (open mrspidey:library-list^)
+   (open mrspidey:library-vec^)
+   (open mrspidey:library-set^)
+   (open mrspidey:library-misc^)
+   (open mrspidey:env^)))
+
+;; ----------------------------------------------------------------------
+
+(define-signature mrspidey:interaction^
+  (mrspidey:error 
+   mrspidey:warning 
+   mrspidey:internal-error
+   mrspidey:add-summary
+   mrspidey:add-summary-handler
+   mrspidey:progress
+   mrspidey:progress-handler
+   record-analyzed-file
+   record-analyzed-file-hook
+    
+))
+
+(define-signature mrspidey:config^
+  ( st:restricted
+    st:name
+    st:version
+
+    st:fake-reader
+    st:system-expand
+
+    st:constants
+    st:const-merge-size
+    st:if-split
+    st:flow-sensitive
+    st:fo-units
+    st:lazy-fo-units
+    st:cache-units
+    st:whole-program
+    st:special-fo-prims
+    st:see-void
+    st:cons-mutable
+    st:use-fo-ftype
+    need-label-types
+    need-explanation
+    st:zero-old-constraint-sets
+    st:zero-old-asts
+
+    st:minimize-respect-assignable-part-of-fields
+
+    st:constraint-simplification-poly
+    st:polymorphism
+
+    st:unit-read-za
+    st:unit-write-za
+    st:unit-simplify
+    st:unit-separate-S
+    st:save-za-in
+
+    ;; --- Type Viewing Parameters
+    st:sdl-fo
+    st:sdl-fo-ivars 
+    st:sdl-fo-struct-fields
+    st:sdl-fo-depth-limit? 
+    st:sdl-fo-depth-limit
+    st:sdl-fo-size-limit?
+    st:sdl-fo-size-limit
+    st:sdl-constraint-simplification
+    st:show-assignable-part-of-fields
+    st:listify-etc
+    st:sdl-constructor/selector
+    st:naming-strategy
+    st:primitive-types
+    st:expand-output-type
+    st:sdl-tidy
+    st:pretty-type-width
+
+    st:check-kernel
+    st:compare-min-algs
+
+    ;; --- Checking Parameters
+    st:all-checks
+ 
+    ;; st:show-filters
+    ;; st:add-hyper-links
+    ;; st:dont-combine-definitions
+    ;; st:structure-opaque
+    ;; st:library-prims
+    ;; st:topo-sort
+
+    mrspidey:control-fn
+
+    ))
+
+(define-signature mrspidey:debugging^
+  (debugging
+    debugging-front
+    debugging-traverse
+    debugging-unit
+    debugging-check
+    debugging-atenv
+    debugging-atype
+    debugging-sdl
+    debugging-sdl2
+    debugging-gui
+
+    debugging-min
+    debugging-min2
+    debugging-few
+    debugging-gram
+    debugging-dfa-min
+    debugging-min-table
+    debugging-object
+
+    timing-min
+
+    pretty-print-debug
+    set-debug-flag
+    ))
+
+(define-signature mrspidey:CDL^
+  ((open mrspidey:config^)
+   (open mrspidey:debugging^)
+   (open mrspidey:library^)))
+
+;; ----------------------------------------------------------------------
+;; Kernel analysis stuff
+
+(define-signature mrspidey:hash^ 
+  ( init-hash-table 
+    hash-fn hash-fn* 
+    add-entry hash-find hash-table-info
+    capture-hash-table-state restore-hash-table-state!
+    prompt-hash-table-state unprompt-hash-table-state!
+    free-hash-table-state!
+    ))
+
+(define-signature
+  mrspidey:kernel^
+  (;; --- Structures
+    (struct FlowType
+      (num expr arrowto arrowfrom type-annotation proplist values-ftype))
+    num-ftype list-ftype num-edge 
+    add-FlowType-arrow! add-FlowType! 
+    add-FlowType-prop! get-FlowType-prop FlowType-name
+
+    (struct Tvar (objs orig-objs constraints edgeto edgefrom L U))
+
+    (struct AV (num template misc fields+ fields- U PU))
+    (struct template
+      (type num+ num- ref assign super-templates misc-eq?))
+    (struct con (num template field-no tvar misc sign))
+    (struct con-filter (num filter tvar))
+    (struct filter (sign templates))
+    create-filter
+    mt-vector
+
+    ;; --- Values
+    num-con    
+    num-AV   
+    num-AV-in-Tvar
+
+    ;; --- Functions
+    init-kernel!
+    create-AV
+    mk-Tvar
+    create-con create-con-misc create-con-filter
+    new-edge! new-bidir-edge! new-edge-para new-AV! new-create-AV! new-con!
+    new-leq-top-s! new-geq-top-s!
+    mk-Tvar-init-AV
+    constraint-system-size
+    get-Tvar-objs
+    add-AV! add-con! add-edge!
+    Tvar-name
+
+    save-kernel-state restore-kernel-state!
+    prompt-kernel-state unprompt-kernel-state!
+    free-kernel-state!
+
+    alloc-Tvar-field alloc-AV-field field->set
+    check-kernel-ok
+    really-check-kernel-ok
+    check-unreachable
+    ))
+
+(define-signature
+  mrspidey:gram^
+  ( ;; --- grsyms
+    (struct grsym (fn mono))
+    (struct grsym-normal (template misc field-no))
+    (struct grsym-misc ())
+    grsym-eq?
+
+    ;; --- rhs
+    (struct rhs (grsym nt))
+    add-rhs!
+
+    calc-productions!
+    ))
+
+;; ----------------------------------------------------------------------
+;; Front end stuff
+
+(define-signature mrspidey:loadexpand^ 
+  (open-code-file
+   zodiac:read*
+   mrspidey:zprogress
+   strip-hash-percent
+   system-expand-if-necy
+    expand-zexp->port
+
+   clear-file-time-cache!
+   extend-file-time-cache!
+   zodiac-time
+   zodiac-time*
+
+    init-expand!
+    my-scheme-expand-program
+))
+
+;;(define-signature mrspidey:parser^ (top-level-parse-defs top-level-parse-exp))
+
+;; ----------------------------------------------------------------------
+
+(define-signature mrspidey:atenv^
+  ( atenv:empty
+    atenv:extend
+    atenv:extend-mutated
+    atenv:extend*
+    atenv:extend-voids
+    atenv:extend-undefineds
+    atenv:lookup
+    atenv:change-binding
+    atenv:change-bindings
+    atenv:capture-locs
+    atenv:unflush
+    atenv:flush!
+    atenv->pretty
+    atenv:domain
+    atenv:ok?
+    link-parsed-ftype!
+    ))
+
+(define-signature mrspidey:traverse^
+  ( top-level-traverse-defs
+    traverse-defs
+    ;;traverse-def
+    traverse-exp
+    ))
+
+(define-signature mrspidey:atype^
+  ((struct fo-FlowType (def))
+   FlowType->Atype
+   create-fo-FlowType
+   fo-Atype? poly-atype?
+
+   (struct atconst (c))
+   (struct schema (tvar tvar* edges))
+   (struct atprim (sym type domain-filters predicate-fn attrs orig-type))
+   (struct atthunk (thunk))
+   (struct atstruct (struct:sym super-constructors 
+                                     parent-gen-args
+                                     parent-match-args
+                                     parent-field-types
+                                     parent-list-mutable))
+   (struct atvalues (values))
+   wrap-value extract-1st-value multiple-value-components
+
+   (struct atunit (imports exports result expr))
+   (struct atlunit (ui))
+
+   FlowType->Tvar
+   Atype->Tvar
+   FlowType->pretty
+   FlowType->SDL
+    copy-ftype
+   ))
+
+(define-signature mrspidey:atlunit^
+  (create-atlunit-unit
+   create-atlunit-cmpd
+   create-atlunit-reference
+
+   apply-unit
+   atlunit->atunit
+   apply-atlunit
+
+   ))
+
+
+(define-signature mrspidey:type-env^
+  (global-tref-env
+   global-tdef-env 
+   global-tbang-env
+
+   add-global-tref!
+   add-global-tdef!
+   add-global-tbang!
+   init-global-tenv!
+
+   connect-bangs-defs
+   report-duplicate-defs
+   connect-refs-defs
+   report-unbound-vars
+   ))
+
+;; ----------------------------------------------------------------------
+;; ???
+
+(define-signature mrspidey:templates^
+  ( constructor->template
+    constructor-env
+    set-constructor-env!
+    extend-constructor-env!
+    add-constructor!
+    constructor-alias!
+    record-super-constructor!
+    record-super-constructor-of-template!
+    record-super-template!
+
+    lam-misc-eq?
+    template-lam
+    template-lam++
+    filter-not-lam
+    template-cons  
+    template-nil   
+    template-num   
+    template-sym   
+    template-str   
+    template-char  
+    template-void 
+    template-undefined
+    template-true  
+    template-false 
+    template-promise 
+    template-unit        
+    template-structure
+    template-mvalues
+    template-internal-class
+    template-all-ivars
+    template-dots
+    ;;template-ivar-box
+    template-top-s
+    template-ivarset
+
+    init-default-constructor-env!
+
+    saved-constructor-env
+    init-constructor-env!
+
+    get-unit-import-template
+    get-unit-export-template
+    get-ivar-template
+   
+    type-constructor?
+    lookup-template
+    lookup-template-or-error
+    is-template?
+    ))
+
+(define-signature mrspidey:kernel-aux^
+  ( make-constructed-AV-template
+    make-constructed-AV
+    make-constructed-Tvar
+
+    make-AV-cons
+    make-con-car
+    make-con-cdr
+    make-con-dom
+    make-con-rng
+                                        ;make-con-arg-car
+                                        ;make-con-arg-cdr
+    make-AV-vec
+    make-AV-lam
+
+    AV-nil   
+    AV-numb  
+    AV-sym   
+    AV-str   
+    AV-char  
+    AV-true  
+    AV-false 
+    AV-void  
+    AV-undefined
+    AV-top-s
+
+    mk-tvar-nil   
+    mk-tvar-numb  
+    mk-tvar-sym   
+    mk-tvar-str   
+    mk-tvar-char  
+    mk-tvar-void  
+    mk-tvar-undefined
+    mk-tvar-true  
+    mk-tvar-false 
+    mk-tvar-empty
+
+    init-common-AV!
+    traverse-simple-const
+    traverse-const-exact
+
+    Tvar-transitive-edgeto
+    copy-constraint-set
+    AV->rep
+
+    ;; --- NTs
+    (struct NT (tvar type rhs*))
+    mk-Tvar-NTs! mk-AV-NTs! 
+    alloc-NT-field
+    nt->sym
+    select-L
+    select-U
+    chk-Tvar-U
+    chk-Tvar-L
+    chk-AV-U
+    ))
+
+(define-signature mrspidey:sdl^
+  (Tvar->SDL))
+
+(define-signature mrspidey:languages^
+  ( st:language 
+    initialize-language!
+    st:numops
+    get-default-bindings
+    make-expander-namespace
+))
+
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey:typelang^
+  ( absUnion absunion absIntersect absintersect
+    init-output-type-expander! install-output-type-expander!
+    init-input-type-expander! 
+    install-input-type-expander!
+    expand-input-type expand-input-type-err expand-output-type
+    typevar?
+
+    type->templates
+    split-schema
+    schema->con
+    tschema->con
+    tschema->con-for-nargs
+    ;;dom+rng-for-nargs
+    Tvar-in-type?
+    primitive->atprim))
+
+(define-signature mrspidey:contained^
+  (Tvar-containment?))
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey:min^
+  ( minimize-constraints-&-compare
+    minimize-constraints
+    min-record-progress))
+
+(define-signature mrspidey:min-live^ 
+  ( copy-live-constraints
+    copy-live-constraints-noe
+    calc-live-tvars-nts
+    copy-constraints-equiv!
+    follow-antimono-fields))
+
+(define-signature mrspidey:find-nonempty-tvars^ 
+  ( copy-nonempty-tvars
+    find-nonempty-tvars))
+
+(define-signature mrspidey:min-live-few-e^ 
+  (copy-live-constraints-few-e))
+
+(define-signature mrspidey:hopcroft^ 
+  (Hopcroft-calc-equivalences))
+
+(define-signature mrspidey:min-dfa-fast^
+  ( minimize-constraints-dfa-min-lub 
+    minimize-constraints-dfa-min-glb))
+
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey:calc-checks^
+  ( calc-checks
+    calc-type-annotations
+    (struct annotation (loc))
+    (struct check-annotation (text num rest))
+    (struct uncheck-annotation (text))
+    (struct type-annotation (end-first finish FlowType))
+    ))
+
+(define-signature mrspidey:za^
+  (read-za write-za))
+
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey:program^
+  (analyze-program global-def-env initialize-analysis!))
+
+(define-signature mrspidey:driver^
+  (st:analyze st: st:type-fn st:help st:set-debug))
+
+;; ----------------------------------------------------------------------
+
+(define-signature
+  mrspidey:zodiac-aux^
+  ( compat compat*
+    ast-size const-size
+    unparse-dynamic-letd
+    stripper
+
+    parsed-ftype set-parsed-ftype!
+    parsed-check set-parsed-check!
+    parsed-atprim set-parsed-atprim!
+    app-tvar-args set-app-tvar-args!
+    binding-refs set-binding-refs! 
+    binding-mutated set-binding-mutated!
+    varref-binding
+    my-create-binding
+
+    lambda-flatten-arglist
+
+    no-location
+    location-inc
+    determine-end-first-token
+
+    parsed-value?
+    free-refs
+    free-vars
+    initialize-mutated
+    free-vars-defs
+    zero!
+    inline-begins
+    ))
+
+(define-signature mrspidey:zodiac^
+  ((open zodiac:system^) (open mrspidey:zodiac-aux^)))
+
+; ----------------------------------------------------------------------
+
+(define-signature mrspidey:hyper^
+  ( analysis-set-arrow-filter!
+    analysis-filter-on?
+    analysis-get-filters
+    analysis-shortest-path
+    analysis-parents
+    analysis-children
+    analysis-ancestors
+    analysis-descendants
+    analysis-callback
+    analysis-get-param
+    analysis-set-param!
+    calc-annotations
+    st:analyze-and-make-annotations
+
+    ))
+
+(define-signature mrspidey:sba^
+  ( (open mrspidey:driver^)
+    (open mrspidey:CDL^)
+    (open mrspidey:atype^)
+    (open mrspidey:hyper^)
+    (open mrspidey:kernel^)
+    (open mrspidey:calc-checks^)
+    (open mrspidey:languages^)
+    (unit zodiac : mrspidey:zodiac^)
+))
+
+; ----------------------------------------------------------------------
diff --git a/collects/mrspidey/Sba/template.ss b/collects/mrspidey/Sba/template.ss
new file mode 100644
index 0000000..b0f442a
--- /dev/null
+++ b/collects/mrspidey/Sba/template.ss
@@ -0,0 +1,303 @@
+;; templates.ss
+;; Handles the constructor environment,
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;;
+;; ======================================================================
+;; Constructor environments: symbol -> template
+;; First a helper function
+
+(define (constructor->template con . modes)
+  (let* ( [n (length modes)]
+          [assign (make-vector n #f)]
+          [ref (make-vector n #f)])
+    (recur loop ([i 0][n 0][modes modes])
+      (match modes
+        [() (make-template con n i ref assign '() eqv?)]
+        [(#t . rest)
+          (vector-set! ref n n)
+          (vector-set! assign n i)
+          (loop (add1 i) (add1 n) rest)]
+        [(#f . rest)
+          (vector-set! ref n n)
+          (vector-set! assign n #f)
+          (loop i (add1 n) rest)]))))
+
+;; ======================================================================
+;; The constructor environment
+
+(define constructor-env (void))
+
+(define (set-constructor-env! c)
+  (set! constructor-env (make-hash-table))
+  (hash-table-for-each c
+    (lambda (key val)
+      (hash-table-put! constructor-env key val))))
+
+(define (extend-constructor-env! template)
+  (let* ( [type (template-type template)]
+          [old (hash-table-get constructor-env type (lambda () #f))])
+    (if old
+      (match (list template old)
+        [( ($ template _ n+1 n-1 ref1 assign1 super1 _) 
+           ($ template _ n+2 n-2 ref2 assign2 super2 _))
+          (unless (and (= n+1 n+2)
+                    (= n-1 n-2)
+                    (equal? assign1 assign2)
+                    (equal? ref1 ref2)
+                    (equal? super1 super2))
+            (pretty-print-debug
+              `( (,n+1 ,n-1 ,ref1 ,assign1 ,(map template-type super1))
+                 (,n+2 ,n-2 ,ref2 ,assign2 ,(map template-type super2))))
+            (mrspidey:error 
+              (format "New definition of template ~s does not match old" 
+                type)))
+          old])
+      (begin
+        (hash-table-put! constructor-env type template)
+        template))))
+
+(define (add-constructor! con . modes)
+  (extend-constructor-env! (apply constructor->template con modes)))
+
+(define (constructor-alias! new-con old-con)
+  (hash-table-put! constructor-env new-con 
+    (lookup-template-or-error old-con)))
+
+(define (record-super-constructor! super-C C)
+  (record-super-constructor-of-template! 
+    super-C (lookup-template-or-error C)))
+
+(define (record-super-constructor-of-template! super-C T)
+  (record-super-template! (lookup-template-or-error super-C) T))
+
+(define (record-super-template! super-T T)
+  (set-template-super-templates! 
+    T
+    (cons super-T (template-super-templates T))))
+
+;; ======================================================================
+;; Default templates
+
+;(define-typed-structure (lam-info nargs restarg))
+
+(define lam-misc-eq?
+  (match-lambda*
+   [(('lam-info nargs1 restarg1) ('lam-info nargs2 restarg2))
+    (and (= nargs1 nargs2) (eqv? restarg1 restarg2))
+    #t]
+   [(x y) (eq? x y)]))
+
+(define template-lam
+  (make-template
+   'lambda
+    1
+    1
+    (vector #f 0)
+    (vector 0 #f)
+    '()
+    lam-misc-eq?))
+
+(define filter-not-lam
+  (create-filter #f (list template-lam)))
+
+(define template-lam++ ;; monotonic in both positions
+  (make-template
+   'lambda
+    2
+    0
+    (vector 0 1)
+    (vector)
+    '()
+    lam-misc-eq?))
+
+;; ----------------------------------------------------------------------
+
+(define template-top-s (void))
+(define template-cons  (void))
+(define template-nil   (void))
+(define template-num   (void))
+(define template-sym   (void))
+(define template-str   (void))
+(define template-char  (void))
+(define template-void  (void))
+(define template-undefined (void))
+(define template-true  (void))
+(define template-false (void))
+(define template-promise (void))
+(define template-unit    (void))
+(define template-structure (void))
+(define template-mvalues (void))
+(define template-internal-class   (void))
+(define template-all-ivars (void))
+(define template-dots   (void))
+(define template-ivarset (void))
+
+(define (init-default-constructor-env!)
+  (pretty-debug ' (init-default-constructor-env!))
+  ;; These are things needed by the analysis
+  (set! constructor-env (make-hash-table))
+  (hash-table-put! constructor-env 'lambda template-lam)
+  (set! template-top-s (add-constructor! 'top-s))
+  (set! template-cons  
+    (if (st:cons-mutable)
+      (add-constructor! 'cons #t #t)
+      (add-constructor! 'cons #f #f)))
+  (set! template-nil   (add-constructor! 'nil  ))
+  (set! template-num   (add-constructor! 'num  ))
+  (set! template-sym   (add-constructor! 'sym  ))
+  (set! template-str   (add-constructor! 'str  ))
+  (set! template-char  (add-constructor! 'char ))
+  (set! template-void  (add-constructor! 'void ))
+  (set! template-undefined (add-constructor! 'undefined))
+  (set! template-true  (add-constructor! 'true ))
+  (set! template-false (add-constructor! 'false))
+  (set! template-promise   (add-constructor! 'promise #f))
+  (set! template-unit      (add-constructor! 'unit-result* #f))
+  (set! template-structure (add-constructor! 'structure:))
+  (set! template-mvalues   (add-constructor! 'mvalues #f))
+  (set! template-internal-class 
+    (extend-constructor-env! 
+      (make-template
+        'internal-class
+        4 4
+        (vector 0  1  2  #f #f  3 #f #f 4)
+        (vector #f #f #f  0  1 #f  2  3 #f)
+        '() eq?)))
+  (set! template-all-ivars
+    (extend-constructor-env!
+      (make-template
+        'all-ivars
+        1
+        0
+        (vector 0)
+        (vector #f)
+        '()
+        eq?)))
+  (set! template-dots   (add-constructor! '...))
+  (set! template-ivarset (add-constructor! 'ivarset #t))
+  )
+
+; ======================================================================
+; The "template-prompt"
+
+(define saved-constructor-env (make-hash-table))
+
+(define (init-constructor-env!)
+  (set! constructor-env saved-constructor-env)
+  (set! unit-import-export-env (vector (make-hash-table) (make-hash-table)))
+  (set! object-ivar-template-env (make-hash-table))
+  )
+
+; ======================================================================
+; Unit templates
+
+(define unit-import-export-env (vector (make-hash-table) (make-hash-table)))
+
+(define (get-unit-import-export-template ndx sym thunk)
+  (hash-table-get
+   (vector-ref unit-import-export-env ndx)
+   sym
+   (lambda ()
+     (let ([template (thunk)])
+       (hash-table-put!
+         (vector-ref unit-import-export-env ndx)
+         sym template)
+       template))))
+
+(define (get-unit-import-template sym)
+  (get-unit-import-export-template 
+   0 sym
+   (lambda ()
+     (extend-constructor-env!
+       (make-template
+         (symbol-append 'unit-import- sym)
+         0
+         1
+         (vector #f)
+         (vector 0)
+         '()
+         eq?)))))
+
+(define (get-unit-export-template sym)
+  (assert (symbol? sym) 'get-unit-export-template)
+  (get-unit-import-export-template 
+   1 sym
+   (lambda ()
+     (extend-constructor-env!
+       (make-template
+         (symbol-append 'unit-export- sym)
+         1
+         0
+         (vector 0)
+         (vector #f)
+         '()
+         eq?)))))
+
+; ======================================================================
+; Object templates
+
+(define object-ivar-template-env (make-hash-table))
+
+(define (get-ivar-template sym)
+  (assert (symbol? sym) 'get-ivar-template sym)
+  (hash-table-get
+    object-ivar-template-env
+    sym
+    (lambda ()
+      (let ([template (make-template
+                        (symbol-append 'ivar- sym)
+                        1
+                        0
+                        (vector 0)
+                        (vector #f)
+                        '()
+                        eq?)])
+        (hash-table-put! object-ivar-template-env sym template)
+        (record-super-template! template-all-ivars template)
+        (extend-constructor-env! template)
+        template))))
+
+;; ======================================================================
+
+(define (type-constructor? C)
+  (if 
+    (hash-table-get constructor-env C (lambda () #f))
+    #t #f))
+
+(define (lookup-template C) 
+  (hash-table-get constructor-env C (lambda () #f)))
+
+(define (lookup-template-or-error C) 
+  (or (lookup-template C)
+    (mrspidey:error (format "Unknown type constructor ~s" C))))
+
+(define is-template?
+  (lambda (name)
+    (lambda (t)
+      (eq? t (lookup-template name)))))
+
+;; ======================================================================
+
+
+
+
+
+
+
+
+
diff --git a/collects/mrspidey/Sba/test-sba.ss b/collects/mrspidey/Sba/test-sba.ss
new file mode 100644
index 0000000..0add528
--- /dev/null
+++ b/collects/mrspidey/Sba/test-sba.ss
@@ -0,0 +1,775 @@
+;; test-suite1.ss
+;; Development helper file
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+;; Testing files:
+
+(define (run-test-suites fn)
+  (letrec ([doit
+             (case-lambda
+               [(s) (doit s 0 #f)]
+               [(s a) (doit s a #f)]
+               [(s a c)
+                 (fn (string-append "~/Spidey/test-suite/" s))
+                 (when a
+                   (unless (= (type-assert-failed-total 0) a)
+                     (error 'run-test-suites "Wrong # failed assertions!")))
+                 (when c
+                   (unless (= (total-checks 0) c)
+                     (error 'run-test-suites "Wrong # checks!")))])])
+
+    ;; --- Core Scheme
+    (doit "testall.ss" 1)
+    (doit "test-const.ss")
+    (doit "test-exprs.ss")
+    (doit "test-if-split.ss")
+    (doit "test-flow.ss")
+    (doit "test-box.ss")
+    (doit "test-user-prims.ss")
+    (doit "test-struct.ss")
+    (doit "test-mvalues.ss")
+    (doit "test-checks.ss" 0 6)
+    (doit "test-no-checks.ss" 0 0)
+
+    ;; --- Objects
+    (doit "test-obj-syntax.ss")
+    (doit "test-obj-simple.ss")
+    (doit "test-obj-thread.ss")
+    (doit "test-obj-derive.ss")
+    (doit "mflatt.ss" 0 3)
+    (doit "../test/trivia/trivia-unit.ss" 0 1)
+
+    ;; --- Units
+    (dynamic-let ([st:system-expand #t])
+      (dynamic-let ([st:fo-units #t]) (doit "test-unit.ss" 0))
+      (dynamic-let ([st:fo-units #f]) (doit "test-unit.ss" 0))
+      ;;(doit  "test-fo-units.ss" 0)
+      )
+    (doit "../test/trivia/trivia-unit.ss" 0 1)
+
+    "MrSpidey passes the test suite :-)"
+    ))
+
+;; ----------------------------------------------------------------------
+
+(define mred-system 
+  '(
+     "autoload.ss"
+     "autosave.ss"
+     "canvas.ss"
+     "connect.ss"
+     "console.ss"
+     "containr.ss"
+     "contfram.ss"
+     "contkids.ss"
+     "contpanl.ss"
+     "cparens.ss"
+     "cppmode.ss"
+     "edframe.ss"
+     "edit.ss"
+     "exit.ss"
+     "exn.ss"
+     "fileutil.ss"
+     "finder.ss"
+     "findstr.ss"
+     "frame.ss"
+     "group.ss"
+     "guiutils.ss"
+     "handler.ss"
+     "html.ss"
+     "hyper.ss"
+     "hypersig.ss"
+     "hyprdial.ss"
+     "hypredit.ss"
+     "hyprfram.ss"
+     "icon.ss"
+     "include.ss"
+     "keys.ss"
+     "link.ss"
+     "macros.ss"
+     "mcache.ss"
+     "menu.ss"
+     "mode.ss"
+     "mrsystem.ss"
+     "noconsle.ss"
+     "panel.ss"
+     "paren.ss"
+     "prefs.ss"
+     "project.ss"
+     "sig.ss"
+     "sparen.ss"
+     "ssmode.ss"
+     "url.ss"
+     "version.ss"
+     ))
+;; ----------------------------------------------------------------------
+
+(define benchmark-files
+  (append
+   (map (lambda (x) (string-append "~/Spidey/benchmarks/" x ".ss"))
+        '(
+          "one"
+          "const"
+          "sum"
+          "qsort"
+          ;; Programs from experiment
+          "gauss"
+          "du"
+          "hanoi"
+          "merge"
+          "np"
+          "tc"
+
+          "taut"
+
+          ;; Misc others
+          "sba"
+          "bignum"
+          ;;"TC"
+          "elev"
+          "dfs-bfs"
+          "checks"
+          "gauss-imp"
+          "gauss-fn"
+          "Cannibals-sba"
+          "mst"
+          ;;"gab-boyer"
+          ;;"nucleic"  -- internal defines, etc
+          ;;"nucleic2" -- internal defines, etc
+          ;;"slatex"   -- too large
+          ))
+
+   (map (lambda (x) (string-append "~/Spidey/wright/" x ".scm"))
+        '(
+          "boyer"
+          "browse"
+          "check"
+          "nbody"
+          "graphs1"
+          "graphs2"
+          "lattice-cormac"
+          ;;"dynamic"
+          ))))
+
+(define test-files 
+  (append
+   (list "~/Spidey/test/sum.ss")
+   (list "~/Spidey/test-suite/testall.ss")
+   ;; Can't use testnumeric as general test 
+   ;; type annotations require accurate numeric constants
+   ;; (list "~/Spidey/test-suite/testnumeric.ss")
+   (map (lambda (x) (string-append "~/Spidey/test/" x ".ss"))
+        '(
+          "defstruct"
+          "defstruct2"))
+   benchmark-files))
+
+'(define test-files 
+   '("~/Spidey/test/one.ss"
+     "~/Spidey/test/sum.ss"
+     "~/Spidey/sba/testall.ss"
+     "~/Spidey/test/du.ss"))
+
+
+;(define test-files '("test/one.ss" "test/test.ss" "test/readlot.ss"))
+
+;; ======================================================================
+;; Helper functions
+
+(define (exec-mzscheme exps)
+  (recur loop ( [s "mzscheme -x -g -a -f /home/cormac/scheme/mzschemerc.ss"]
+                [exps exps])
+    (if (null? exps)
+      (begin
+        (printf "Command: ") (display s) (newline)
+        (system s))
+      (loop 
+        (string-append s (format " -e '~s'" (car exps)))
+        (cdr exps)))))
+
+(define (for-each-parameter para thunk)
+  (for-each
+   (lambda (p) (dynamic-let ([para p]) (thunk p)))
+   (map car (para '?))))
+
+(define (for-each-parameters para-list thunk)
+  (if (null? para-list)
+      (thunk)
+      (for-each-parameter
+       (car para-list)
+       (lambda (x)
+         (for-each-parameters (cdr para-list) thunk)))))
+
+(define (for-each-quoted-parameters para-list thunk)
+  (recur loop ([l para-list][d '()])
+    (match l
+      [()
+       (printf "CONFIGURATION: ~s~n" d)
+       (thunk)]
+      [(p . rest)
+       (for-each-parameter
+        (eval p)
+        (lambda (x) (loop (cdr l) (cons `(,p ,x) d))))])))
+
+(define (smart-for-each-quoted-parameters para-list limit thunk)
+  (for num-chgs 0 (add1 (min limit (length para-list)))
+       ;; Try changing num-chgs parameters
+       (recur loop ([l para-list][d '()][n num-chgs])
+         (match l
+           [()
+            (when (zero? n)
+              ;; run the test
+              (printf "CONFIGURATION: num-chgs=~s ~s~n" num-chgs d)
+              (thunk))]
+           [(p . rest)
+            (let* ([para (eval p)]
+                   [options (map car (para '?))]
+                   [default (car options)])
+              ;; --- First don't change
+              (dynamic-let 
+               ([para default])
+               (loop rest (cons `(,p ,default) d) n))
+              ;; Now change
+              (unless (zero? n)
+                (for-each
+                 (lambda (v) 
+                   (dynamic-let
+                    ([para v]) 
+                    (loop rest (cons `(,p ,v) d) (sub1 n))))
+                 (cdr options))))]))))
+
+(define (for-every-nth f l n)
+  (recur loop ([i (random (inexact->exact n))][l l])
+    (unless (null? l)
+      (if (zero? i)
+        (begin
+          (f (car l))
+          (loop n (cdr l)))
+        (loop (sub1 i) (cdr l))))))
+
+; ======================================================================
+; Check minimization algorithms preserve meaning
+
+(define min-algs-to-check
+  '( none
+     nonempty
+     nonempty-copy
+     live
+     live-few-e
+     ;live-few-e-L
+     ;live-few-e-U
+     ;(live-few-e dfa-min)
+     ;(live-few-e dfa-min-inv)
+     ;(live-few-e dfa-min-inv dfa-min)
+     ;(live-few-e dfa-min dfa-min-inv)
+
+     ;(live-few-e dfa-min-1)
+     ;(live-few-e dfa-min-1)
+     ;(live-few-e dfa-min-2)
+     ;(live-few-e dfa-min-2)
+     ;(live-few-e dfa-min-1 live dfa-min-2)
+     ;(live-few-e dfa-min-2 live dfa-min-1)
+
+     (dfa-min-lub)
+     (dfa-min-glb)
+     (dfa-min-lub dfa-min-glb)
+     (dfa-min-glb dfa-min-lub)
+
+     ;(live-few-e min-table)
+     ))
+
+(define (check-min-ok-file file)
+  (let* 
+    ( [defs (analyze-program file)]
+      [type-annotations (calc-type-annotations defs)]
+      [tvar* (filter Tvar? (map type-annotation-FlowType type-annotations))]
+      ;;[_ (pretty-print `(Tvar* ,(map Tvar-name tvar*)))]
+      [min-algs min-algs-to-check]
+      [p (make-parameter-list 
+           (car min-algs) 
+           (map (lambda (x) (list x "")) min-algs))]
+      [min-con-1
+        (lambda (which Tvar)
+          (let*-vals
+            ([(_ Tvar->nutvar) 
+               (minimize-constraints which '() (list Tvar) '() '())])
+            (Tvar->nutvar Tvar)))])
+
+    (printf "Testing ~s, ~s Tvar~n" file (length tvar*))
+    ;; Compression algorithms don't preserve filters,
+    ;; so turn all filters into edges
+    (for-each
+      (lambda (tvar)
+        (when (Tvar? tvar)
+          (set-Tvar-constraints!
+            tvar
+            (filter
+              (match-lambda
+                [($ con) #t]
+                [($ con-filter _ _ to)
+                  (new-edge! tvar to)
+                  #f])
+              (Tvar-constraints tvar)))))
+      list-ftype)
+
+    (for-each-parameter 
+      p
+      (lambda (v)
+        (printf "Minimization strategy ~s~n" v)
+        (for-each
+          (lambda (Tvar)
+            (printf ".") (flush-output)
+            (let* ( [live-copy (min-con-1 'none Tvar)]
+                    [p-copy    (min-con-1 (p)   Tvar)])
+              (Tvar-equiv?
+                (lambda ()
+                  (printf "Original is:~n")
+                  (pretty-print (Tvar-name Tvar)))
+                "Live copy" live-copy
+                (format "~s p-copy" (p)) p-copy)))
+          tvar*)
+        (newline)))))
+
+(define (Tvar-equiv? fail-thunk name-A A name-B B)
+  (let* ( [c1 (Tvar-containment? A B)]
+          [c2 (Tvar-containment? B A)])
+    (unless (and c1 c2)
+      (fail-thunk)
+      (printf "~a is:~n" name-A) 
+      (pretty-print (Tvar-name A))
+      (printf "~a is:~n" name-B)
+      (pretty-print (Tvar-name B))
+      (if c1
+        (printf "~s is larger!~n" name-B)
+        (printf "~s is smaller!~n" name-B))
+      (error 'Tvar-equiv? "Failure!"))))
+
+(define (check-min-ok-all)
+  (for-each check-min-ok-file benchmark-files))
+
+;; ======================================================================
+
+(define (check-type-file f)
+  (printf "==================================================~n")
+  (printf "File: ~s~n" f)
+  (st: f)
+  (pretty-print (st:type)))
+
+; ======================================================================
+  
+(define (check-SDL-file f)
+  (printf "==================================================~n")
+  (printf "File: ~s~n" f)
+  (st: f)
+  (let* ([l list-ftype])
+    (for-each-parameter
+      st:type-compression
+      (lambda (t)
+          (printf "----------------------------------------~n")
+          (printf "Type compression: ~s~n" t)
+          (for-each
+            (lambda (Tvar) 
+              (when (Tvar? Tvar)
+                (printf "~s~n" (Tvar-name Tvar))
+                (flush-output)
+                (let ([sdl (Tvar->SDL Tvar)])
+                  (void))))
+            l)))))
+
+;; ----------------------------------------------------------------------
+
+(define (check-SDL2-file f)
+  (printf "==================================================~n")
+  (printf "File: ~s~n" f)
+  (st: f)
+  (let* ([l list-ftype]
+         [len (length l)])
+    (smart-for-each-quoted-parameters
+      '(st:type-compression
+         st:primitive-types 
+         st:naming-strategy )
+      2
+      (lambda () 
+        (for-every-nth
+          (lambda (Tvar) 
+            (when (Tvar? Tvar)
+              (printf "~s " (FlowType-num Tvar))
+              (flush-output)
+              (let ([sdl (Tvar->SDL Tvar)])
+                (void))))
+          l 
+          ;; do (* 3 (sqrt len)) cases
+          (truncate (/ len (* 3 (sqrt len)))))
+        (newline)))))
+
+;; ----------------------------------------------------------------------
+
+
+;; ### DOESNT WORK CAUSE LISTIFY ETC
+(define (check-SDL3-file f)
+  (printf "==================================================~n")
+  (printf "File: ~s~n" f)
+  (st: f)
+  (let* ([l list-ftype]
+          [len (length l)])
+    (dynamic-let ([st:primitive-types 'inferred])
+      (smart-for-each-quoted-parameters
+        '(st:type-compression
+           st:naming-strategy )
+        1
+        (lambda () 
+          (for-every-nth
+            (lambda (Tvar) 
+              (when (Tvar? Tvar)
+                (printf "~s " (FlowType-num Tvar))
+                (flush-output)
+                (let*-vals
+                  (;; minimize w/ live
+                    [(_ Tvar->nutvar)
+                      (minimize-constraints 'live '() (list Tvar))]
+                    [tvar-live (Tvar->nutvar Tvar)]
+                    [sdl (dynamic-let
+                           ([st:listify-etc #f])
+                           (Tvar->SDL tvar-live))]
+                    [tvar2 (mk-Tvar 'check-SDL3)])
+                  (pretty-print sdl)
+                  (tschema->con
+                    (expand-input-type sdl)
+                    tvar2 'check-SDL3: '())
+                  (Tvar-equiv? 
+                    (lambda ()
+                      (pretty-print 
+                        `( st:type-compression ,(st:type-compression)
+                           st:naming-strategy ,(st:naming-strategy)
+                           sdl ,sdl)))
+                    "Live" tvar-live
+                    "Regenerated" tvar2))))
+            l
+            ;; do (* 3 (sqrt len)) cases
+            (truncate (/ len (* 3 (sqrt len)))))
+          (newline))))))
+
+;; ======================================================================
+
+(define (acid-test-analysis sub-test)
+  (lambda (f)
+    (smart-for-each-quoted-parameters
+     '(st:constants
+       st:if-split
+       st:flow-sensitive
+       st:numops
+       st:special-fo-prims
+       ;;st:system-expand
+       st:see-void)
+     3
+     (lambda () (sub-test f)))))
+
+(define (acid-acid-test-analysis f)
+  ((acid-test-analysis acid-test-SDL) f))
+
+;; ----------------------------------------------------------------------
+
+(define (all-test-sba-terminates)
+  (for-each acid-test-SDL test-files)
+  (for-each acid-acid-test-analysis test-files))
+
+;; ======================================================================
+
+(define compare-min-file-results (void)) 
+(define (compare-min-file file)
+  (set! compare-min-file-results '())
+  (for-each-parameter
+    st:unit-simplify
+    (lambda (p)
+      (unless (eq? p 'none)
+        (pretty-print `(st:unit-simplify ,p))
+        (let*-vals
+          ( [(_ t real-t) (time-apply (lambda () (st: file)))])
+          (set! compare-min-file-results
+            (cons (list p t) compare-min-file-results))
+          (pretty-print 
+            `(compare-min-file-results ,compare-min-file-results))))))
+  compare-min-file-results)
+
+;; ======================================================================
+;; EXPERIMENT A
+;;
+;; Figure describing Behavior of Constraint Compression Algorithms
+
+(define compress-files
+  (map (lambda (x) (string-append "~/papers/compress/bench/compress/" x ".ss"))
+    '(
+       "t"
+       "map"
+       "reverse2"
+       "substring"
+       "qsortmod"
+       "unify"
+       "hopcroft"
+       "check-mod"
+       "escher"
+       "scanner"
+       )))
+
+(define (fig6-file file)
+  (dynamic-let ( [st:compare-min-algs #t]
+                 [st:unit-read-za #f]
+                 [st:unit-write-za #f]
+                 [st:use-fo-ftype #f]
+                 [st:polymorphism 'compress]
+                 [st:if-split #f]
+                 [st:flow-sensitive #f]
+                 [st:unit-separate-S #f]
+                 )
+    (st:analyze file)))
+
+(define (fig6)
+  (for-each fig6-file compress-files))
+
+;; ======================================================================
+;; EXPERIMENT B
+;;
+;; Polymorphic analysis times
+
+(define wright-files
+  (map (lambda (x) (string-append "~/papers/compress/bench/poly/" x ".ss"))
+    '(
+       "t"
+       "lattice"
+       "browse"
+       "splay"
+       "check"
+       "graphs"
+       "boyer"
+       "matrix"
+       "maze"
+       "nbody"
+       "nucleic-3"
+       ;; "dynamic"
+
+       )))
+
+;(define wright-poly-files 
+;  (map (lambda (file) (regexp-replace ".ss$" file ".poly.ss"))
+;    wright-files))
+
+(define fig7-algs
+  '( (traverse none)
+     (none none)
+     (compress (dfa-min-lub))
+     (compress (dfa-min-glb))
+     (compress live-few-e)
+     (compress live)
+     (compress nonempty)
+     (compress none)
+     ;;(copy-con none)
+     (reanalyze none)))
+
+(define (fig7-file-alg a b file)
+  (dynamic-let ( [st:polymorphism (if (eq? a 'traverse) 'none a)]
+                 [st:type-compression-poly b]
+                 [st:use-fo-ftype #f]
+                 [st:if-split #f]
+                 [st:flow-sensitive #f]
+                 [keep-S-closed (if (eq? a 'traverse) #f (keep-S-closed))])
+    (printf "--------------------------------------------------------~n")
+    (printf "FILE: ~s ANALYSIS ~s~n" file (list a b))
+    (clear-counters!)
+    (set! need-label-types #t)
+    (st: file)
+    (printf "FILE: ~s ANALYSIS ~s~n" file (list a b))
+    (show-counters)
+    (show-stat-small)
+    (list a b (get-counter 'top-level-traverse-defs))))
+
+(define (fig7-file file)
+  (let* ( [file (topo-file file)]
+          [r (map
+               (match-lambda [(a b) (fig7-file-alg a b file)])
+               fig7-algs)])
+    (pretty-print `(RESULTS-FOR ,file ,r))
+    (list file r)))
+
+(define (fig7)
+  (recur loop ([files wright-files][r* '()])
+    (unless (null? files)
+      (let* ( [r (fig7-file (car files))]
+              [r* (append r* (list r))])
+        (pretty-print `(RESULTS-TO-DATE ,r*))
+        (loop (cdr files) r*)))))
+
+(define (fig7s-file file)
+  ;; Spawns nu mzscheme each time
+  (let* ( [file (topo-file file)])
+    (for-each
+      (match-lambda 
+        [(and analyze (a b))
+          (printf "--------------------------------------------------------~n")
+          (printf "FILE: ~s ANALYSIS ~s~n" file analyze)
+          (exec-mzscheme
+            `( (define __NO_DEBUGGING 1)
+               (ST)
+               (set! mrspidey:zprogress (lambda x 1))
+               (fig7-file-alg (quote ,a) (quote ,b) ,file)
+               (exit)))])
+      fig7-algs)))
+
+(define (fig7s)
+  (for-each fig7s-file (cdr wright-files)))
+
+;; ======================================================================
+;; EXPERIMENT C
+;; Test how analysis scales to large programs
+;; Have: 
+;;  analyze-scanner.ss
+;;  analyze-zodiac.ss
+;;  analyze-small.ss  - part of sba analysis
+;;  analyze-no-min.ss - sba except minimization
+;;  analyze.ss        - all of sba
+;;
+;;  analyze-CDL.ss    - usless, units never used
+;;  analyze-min.ss    - useless, units never used
+
+(define (test-scalable-alg alg file)
+  (printf "--------------------------------------------------------~n")
+  (printf "FILE: ~s SIMPLIFICATION ~s~n" file alg)
+  (dynamic-let ( [st:unit-simplify (if (eq? alg 'traverse) 'none alg)]
+                 [st:use-fo-ftype #f]
+                 [st:if-split #f]
+                 [st:flow-sensitive #f]
+                 [keep-S-closed (if (eq? alg 'traverse) #f (keep-S-closed))]
+                 [st:unit-read-za #f]
+                 [st:unit-write-za #f]
+                 [st:unit-separate-S #t])
+    (clear-counters!)
+    (st:analyze file)
+    (printf "FILE: ~s SIMPLIFICATION ~s~n" file alg)
+    (show-counters)
+    (pretty-print (st:control))
+    (show-stat-small)))
+
+(define (bad-alg-for-file? alg file)
+  (cond
+    [(equal? file "analyze-small.ss")
+      ;; none ran to 404M
+      (memq alg '(none nonempty))]
+    [(equal? file "analyze-no-min.ss")
+      (memq alg '(none nonempty))]
+    [(equal? file "analyze.ss")
+      (memq alg '(none nonempty nonempty-copy))]
+    [(equal? file "~/papers/compress/bench/separate/nucleic/nucleic.ss")
+      (memq alg '())]
+    [else #f]))
+
+(define (test-scalable-file file)
+  (for-each
+    (lambda (t)
+      (unless (bad-alg-for-file? t file)
+        (exec-mzscheme 
+          `( (define __NO_DEBUGGING 1)
+             (ST)
+             ;;(expander-eval (quote (defmacro cache-exp (exp za) exp)))
+             ;;(expander-eval (quote (defmacro cache-inv (exp za) exp)))
+             (set! mrspidey:zprogress (lambda x 1))
+             (test-scalable-alg (quote ,t) ,file)
+             (exit)))))
+    '(traverse none nonempty live live-few-e dfa-min-lub dfa-min-glb)))
+
+(define (test-scalable-all)
+  (for-each test-scalable-file
+    '( "analyze-scanner.ss"
+       "analyze-zodiac.ss" 
+       "analyze-small.ss"       
+       "analyze-no-min.ss"
+       "analyze.ss")))
+
+;; ======================================================================
+;; EXPERIMENT D
+;; Test separate analysis
+
+(define (test-separate-analyze alg read-za file)
+  (printf "--------------------------------------------------------~n")
+  (printf "FILE: ~s SIMPLIFICATION ~s ~s~n" file alg read-za)
+  (let ([files '()])
+    (dynamic-let 
+      ( [st:unit-simplify (if (eq? alg 'traverse) 'none alg)]
+        [st:use-fo-ftype #f]
+        [st:if-split #f]
+        [st:flow-sensitive #f]
+        [keep-S-closed (if (eq? alg 'traverse) #f (keep-S-closed))]
+        [st:unit-separate-S #t]
+        [st:unit-read-za read-za]
+        [st:unit-write-za #t]
+        [st:unit-separate-S #t]
+        [record-analyzed-file-hook
+          (lambda (filename . _)
+            (printf "Record-analyzed-file ~s~n" filename)
+            (set! files (cons filename files)))])
+      (clear-counters!)
+      (st:analyze file)
+      (printf "FILE: ~s SIMPLIFICATION ~s ~s~n" file alg read-za)
+      (show-counters)
+      (pretty-print (st:control))
+      (show-stat-small)
+      (printf "ZA FILES:~n")
+      (system
+        (foldr
+          (lambda (file acc)
+            (string-append acc " " (regexp-replace "-source$" file "")))
+          "wc "
+          files)))))
+
+(define (test-separate-alg alg file module-file)
+  (assert (file-exists? module-file))
+  (exec-mzscheme 
+    `( (define __NO_DEBUGGING 1)
+       (ST)
+       ;(set! mrspidey:zprogress (lambda x 1))
+       (test-separate-analyze (quote ,alg) (= 0 1) ,file)
+       (exit)))
+  (system (format "touch ~a" module-file))
+  (exec-mzscheme 
+    `( (define __NO_DEBUGGING 1)
+       (ST)
+       ;(set! mrspidey:zprogress (lambda x 1))
+       (test-separate-analyze (quote ,alg) (= 1 1) ,file)
+       (exit))))
+
+(define (test-separate-file file module-file)
+  (for-each
+    (lambda (t)
+      (unless (bad-alg-for-file? t file)
+        (test-separate-alg t file module-file)))
+    '(none nonempty-copy live live-few-e dfa-min-lub)))
+
+(define (test-separate-all)
+  '(test-separate-file 
+     "~/Spidey/Unit/mod/test-separate.ss"
+     "/home/cormac/Spidey/Unit/mod/test-separate-1.ss")    
+  (test-separate-file "analyze-scanner.ss" "zodiac/scanner-parameters.ss")
+  (test-separate-file "analyze-zodiac.ss"  "zodiac/corelate.ss")
+  (test-separate-file 
+    "~/papers/compress/bench/separate/nucleic/nucleic.ss"
+    "/home/cormac/papers/compress/bench/separate/nucleic/search.ss")
+  (test-separate-file "analyze-small.ss"   "hash.ss")
+  (test-separate-file "analyze-no-min.ss"  "hash.ss")
+  (test-separate-file "analyze.ss"         "hash.ss"))
+
+;; ======================================================================
+       
diff --git a/collects/mrspidey/Sba/testall.ss b/collects/mrspidey/Sba/testall.ss
new file mode 100644
index 0000000..2f34555
--- /dev/null
+++ b/collects/mrspidey/Sba/testall.ss
@@ -0,0 +1,187 @@
+; testall.ss
+; Tries to test all of Teiresias's type inference algorithm
+; and uses type assertions to detect when it fails
+
+; ----------------------------------------------------------------------
+; Constants
+
+(: 1   (exact num))
+(: 'a  (exact sym))
+(: #\a (exact char))
+(: #t  (exact true))
+(: #f  (exact false))
+(: nil (exact nil))
+(: '()  (exact nil))
+(: "Cormac" (exact str))
+(: '(a b c) (exact (listof sym)))
+(: '(a b 1) (exact (listof (union sym num))))
+(: #(1 2 3) (exact (vec num)))
+(: #(1 2 "abc") (exact (vec (union num str))))
+;;;(: #&4      (exact (box num)))
+
+; ----------------------------------------------------------------------
+; misc kinds of exprs
+
+; top-level def
+(define x 'a-symbol)
+(: x (exact sym))
+
+
+; lexical binding -various sorts
+(let ([y 4][z 'a]) 
+  (: y (exact num))
+  (: z (exact sym)))
+(letrec ([y 4][z 'a]) 
+  (: y (exact num))
+  (: z (exact sym)))
+(let* ([y 4][z 'a]) 
+  (: y (exact num))
+  (: z (exact sym)))
+
+; if - one and two armed
+(: (if (read) 1 'a) (exact (union num sym)))
+(: (if (read) 1)    (exact (union num void)))
+
+; set!
+(let ([z 4]) 
+  (set! z 'a) 
+  (: z (exact (union num sym))))
+
+; begin
+(: (begin 'a 1) (exact num))
+
+; now various lambdas and applications
+((lambda (x y) (: x (exact num)) (: y (exact sym))) 
+ 4 'a)
+((lambda x (: x (exact (cons num (cons num nil))))) 1 2)
+(apply (lambda (x) (: x (exact num))) (list 1))
+(apply (lambda x (: x (exact (cons num (cons num nil))))) (cons 1 (cons 2 nil)))
+(: (lambda (x) x) (_ -> _))
+(: ((lambda (x) 'a) 3) (exact sym))
+
+;; Multiple calls, merged returns
+(let ([I (lambda (x) (: x (exact (union num sym))))])
+  (: (I 3) (exact (union num sym)))
+  (: (I 'a) (exact (union num sym))))
+
+; ----------------------------------------------------------------------
+; if-splitting
+
+; (if (pred arg) ...)
+(let ([x (if (read) 1 'a)])
+  (: x (exact (union num sym)))
+  (if (number? x)
+      (: x (exact num))
+      (: x (exact sym))))
+
+; assigned arg
+(let ([x (if (read) 1 'a)])
+  (set! x 2)
+  (if (number? x)
+      (: x (exact (union num sym)))
+      (: x (exact (union num sym)))))
+
+; (if x ...)
+(let ([x (if (read) #t #f)])
+  (if x 
+      (: x (exact true))
+      (: x (exact false))))
+(let ([x (if (read) 5 #f)])
+  (if x 
+      (: x (exact num))
+      (: x (exact false))))
+
+; (if (not x) ...)
+(let ([x (if (read) #t #f)])
+  (if (not x)
+      (: x (exact false))
+      (: x (exact true))))
+(let ([x (if (read) 5 #f)])
+  (if (not x)
+      (: x (exact false))
+      (: x (exact num))))
+
+; (if (not (pred arg)) ...)
+(let ([x (if (read) 1 'a)])
+  (if (not (number? x))
+      (: x (exact sym))
+      (: x (exact num))))
+
+; ----------------------------------------------------------------------
+; Flow sensitive
+
+(let ([x (if 1 (cons 1 2) 'a)])
+  (: x (exact (union (cons num num) sym)))
+  (car x)
+  (: x (exact (cons num num)))
+  (cdr x))
+
+; not on assigned vars
+(let ([x (if (read) (cons 1 2) 'a)])
+  (set! x 'b)
+  (: x (exact (union (cons num num) sym)))
+  (car x)
+  (: x (exact (union (cons num num) sym)))
+  (cdr x))
+
+; ----------------------------------------------------------------------
+; Boxes
+
+(let ([x (: (box 1) (exact (box num)))])
+  (: (unbox x) (exact num)))
+(let ([x (: (box 1) (exact (box (union num sym))))])
+  (set-box! x 'a)
+  (: (unbox x) (exact (union num sym))))
+(let ([x (if (read) (box 'a) #f)])
+  (if (box? x) (: x (exact (box sym)))))
+
+; ----------------------------------------------------------------------
+; User primitives and types
+
+(define-constructor Box #t)
+
+(define-primitive Box? (_ -> bool) (predicate Box))
+(define-primitive Box (a -> (Box a)))
+(define-primitive unBox ((Box a) -> a))
+(define-primitive set-Box! ((Box (! a)) a -> void))
+
+(let ([x (: (Box 1) (exact (Box num)))])
+  (: (unBox x) (exact num)))
+(let ([x (: (Box 1) (exact (Box (union num sym))))])
+  (set-Box! x 'a)
+  (: (unBox x) (exact (union num sym))))
+(let ([x (if (read) (Box 'a) #f)])
+  (if (Box? x) (: x (exact (Box sym)))))
+
+(define-type env (listof (list sym num)))
+(define-primitive mk-env (-> env))
+(: (mk-env) (exact (listof (list sym num))))
+
+; ----------------------------------------------------------------------
+; define-structure
+
+(define-structure (Triple a b c))
+
+(let ([x (: (make-Triple 1 'a #\c) (exact (structure:Triple num sym char)))])
+  (: (Triple-a x) (exact num))
+  (: (Triple-1 x) (exact num)))
+(let ([x (: (make-Triple 1 'a #\c) (exact (structure:Triple (union num sym) sym char)))])
+  (set-Triple-a! x 'a)
+  (: (Triple-a x) (exact (union num sym))))
+(let ([x (if (read) (make-Triple 1 'a #\c) #f)])
+  (if (Triple? x) (: x (exact (structure:Triple num sym char)))))
+
+; ----------------------------------------------------------------------
+; loops
+
+(define Map
+  (lambda (f l)
+    (if (null? l)
+        '()
+        (cons (f (car l)) (Map f (cdr l))))))
+
+(: (Map add1 '(1 2 3)) (exact (listof num)))
+
+; ----------------------------------------------------------------------
+; Could test all the primitives ...
+
diff --git a/collects/mrspidey/Sba/text-interaction.ss b/collects/mrspidey/Sba/text-interaction.ss
new file mode 100644
index 0000000..cf2cca5
--- /dev/null
+++ b/collects/mrspidey/Sba/text-interaction.ss
@@ -0,0 +1,60 @@
+;; text-interaction
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+   (define (mrspidey:error msg . obj-list)
+     (error 'Mrspidey msg))
+   (define mrspidey:warning
+     (case-lambda
+      [(str . _) (printf "Warning: ~a~n" str)]
+      ;[(str loc . _) (printf "Warning: file ~s, line ~s: ~a~n" 
+      ;                       (file-name-from-path (zodiac:location-file loc))
+     ;                        (zodiac:location-line loc)
+       ;                      str)]
+      ))
+   (define mrspidey:internal-error error)
+   (define (mrspidey:add-summary str . _)
+     (printf "~a~n" str))
+   (define mrspidey:progress
+     (let ([current ()]
+           [fresh-line #t])
+       (letrec 
+           ([f (match-lambda*
+                [((? symbol? name) (? number? fraction))
+                 (unless (eq? name current)
+                   (f 'fresh-line)
+                   (set! current name)
+                   (mrspidey:progress-output (format "~s: " name)))
+                 (mrspidey:progress-output ".") 
+                 (flush-output)
+                 (set! fresh-line #f)
+                 (when (= fraction 1) (f #\newline))]
+                [((? string? str)) 
+                 (f 'fresh-line)
+                 (mrspidey:progress-output str)
+                 (when (char=? (string-ref str (sub1 (string-length str)))
+                               #\newline)
+                   (set! fresh-line #t))]
+                [(#\newline)
+                 (mrspidey:progress-output (format "~n"))
+                 (set! fresh-line #t)]
+                [('fresh-line)
+                 (unless fresh-line (f #\newline))])])
+         f)))
+   (define mrspidey:progress-output
+     (lambda (str) (display str) (flush-output)))
diff --git a/collects/mrspidey/Sba/toplevelenv.ss b/collects/mrspidey/Sba/toplevelenv.ss
new file mode 100644
index 0000000..cf08f48
--- /dev/null
+++ b/collects/mrspidey/Sba/toplevelenv.ss
@@ -0,0 +1,212 @@
+;; toplevelenv.ss
+;; Handles the default top level environment
+;;
+;; ======================================================================
+;; Primitive environments: symbol -> priminfo
+;; First a helper fn
+
+(define-structure (priminfo sym type domain-filters predicate-fn))
+
+;; filter-domains is a list of filters for various args,
+;; if no error raised
+
+;; inj-predicate is a fn : list-AVS x list-AVS x AVS x bool -> AVS 
+;; used for (if (pred ... x ...) ...)
+
+(define (primitive->priminfo name type . attrs)
+  (let ([type (expand-type type)])
+    (make-priminfo
+     name 
+     type
+
+     ;; Calculate filter-domains
+     (match type
+       [(domain '->* _)
+        ;; Now walk domain and args
+        (recur loop ([domain domain])
+          (match domain
+            [('cons domain domain-rest)
+             (cons
+              (let ([templates (con-exp->templates domain)])
+                (if templates
+                    (make-filter #t templates)
+                    #f))
+              (loop domain-rest))]
+            [_ '()]))]
+       [_ '()])
+
+     ;; Calculate predicate-fn
+     (foldl
+      (lambda (attr predicate-fn)
+        (let* 
+            ([mk-predicate-fn
+              (lambda (filter-then filter-else)
+                (lambda (b a AVS sign)
+                  (let ([filter (if sign filter-then filter-else)])
+                    (if filter
+                        (let ([nu-AVS (mk-AVS-tmp 'filter)])
+                          (new-con! AVS
+                                    (create-con-filter filter
+                                                       nu-AVS))
+                          nu-AVS)
+                        AVS))))]
+             [get-templates
+              (lambda (C*) (map lookup-template C*))]
+             [nu-fn
+              (match attr
+                [('predicate-fn exp) exp]
+                [('predicate . C*)
+                 (let ([templates (get-templates C*)])
+                   (mk-predicate-fn (make-filter #t templates)
+                                    (make-filter #f templates)))]
+                [('predicate* true-info false-info)
+                 (apply 
+                  mk-predicate-fn
+                  (map
+                   (match-lambda
+                    ['_ #f]
+                    [(bool . C*)
+                     (let ([templates (get-templates C*)])
+                       (make-filter bool templates))]
+                    [_ (error 'predicate* "Bad syntax")])
+                   (list true-info false-info)))]
+                [_ #f])])
+          (if nu-fn
+              ;; compose
+              (lambda (b a AVS sign)
+                (nu-fn b a
+                       (predicate-fn b a AVS sign)
+                       sign))
+              predicate-fn)))
+      (lambda (b a AVS bool) AVS)                 
+      attrs))))
+
+;; ----------------------------------------------------------------------
+;; Now the default environment
+
+(define default-primitive-env (void))
+;; type: symbol -> priminfo
+
+;; ======================================================================
+
+(define output-type-expander (void))
+(define (init-output-type-expander!)
+  (set! output-type-expander (lambda (x) x)))
+
+(define (install-output-type-expander! expander)
+  (let ([old-expander output-type-expander])
+    (set! output-type-expander
+        (lambda (type) 
+          (old-expander (recur loop ([type type])
+                          (let ([t (expander type)])
+                            (if (eq? t type) type (loop t)))))))))
+
+;; ======================================================================
+;; For input-type-expander, recursion is done in expand-type
+
+(define default-input-type-expander (void))
+(define input-type-expander (void))
+
+(define (init-input-type-expander!)
+  (set! input-type-expander default-input-type-expander))
+
+(define (init-empty-input-type-expander!)
+  (set! input-type-expander (lambda (x) x)))
+
+(define (capture-input-type-expander!)
+  (set! default-input-type-expander input-type-expander))
+
+(define (install-input-type-expander! expander)
+  (let ([old-expander input-type-expander])
+    (set! input-type-expander
+        (lambda (type) 
+          ;;(pretty-print `(input-type-expander ,type))
+          (old-expander (expander type))))))
+
+;; ======================================================================
+
+(define (extend-env-w/-define-structure env tag . args)
+  ;; env: sym -> priminfo
+  (let ([add! 
+         (lambda (name type . attrs)
+           (set! env
+               (extend-env env name
+                           (apply primitive->priminfo name type attrs))))]
+        [type (symbol-append 'structure: tag)]
+        [gen-args (map (lambda (_) (gensym)) args)]
+        [gen-arg (gensym)])
+    (apply add-constructor! type (map (lambda (a) #t) args))
+    (add! (symbol-append 'make- tag) `(,@gen-args -> (,type ,@gen-args)))
+    (add! (symbol-append tag '?) `(_ -> bool) `(predicate ,type))
+    (for-each-with-n
+     (lambda (arg n)
+       (let ([type-ref
+              `((,type ,@(map (lambda (a)
+                                (if (eq? a arg) gen-arg '_))
+                              args))
+                -> ,gen-arg)]
+             [type-bang 
+              `((,type ,@(map (lambda (a)
+                                (if (eq? a arg) `(! ,gen-arg) '_))
+                              args))
+                ,gen-arg
+                -> void)])
+         (add! (symbol-append tag '- arg) type-ref)
+         (add! (symbol-append tag '- (add1 n)) type-ref)
+         (add! (symbol-append 'set- tag '- arg '!) type-bang)
+         (add! (symbol-append 'set- tag '- (add1 n) '!) type-bang)))
+     args)
+    env))
+
+;; ======================================================================
+
+(define (add-default-primitive! name type . attrs)
+  ;; working w/ default primitive env => use default constructor env
+  (init-current-constructor-env!)
+  (set! default-primitive-env
+      (extend-env default-primitive-env 
+                  name
+                  (apply primitive->priminfo name type attrs))))
+
+(define (add-default-primitives! l)
+  (for-each 
+   (lambda (args) (apply add-default-primitive! args))
+   l))
+
+(define
+  select-language
+  (make-parameter-list
+   'none
+   '((DrScheme  "DrScheme")
+     (MzScheme  "MzScheme")
+     (R4RS      "R4RS")
+     (Chez      "Chez Scheme")
+     (Rice      "Rice Scheme")
+     (none      "None"))
+   (lambda (scheme)
+     (unless (eq? scheme 'none)
+       (init-default-constructor-env!)
+       (init-empty-input-type-expander!)
+       (init-output-type-expander!)
+       (set! default-primitive-env empty-env)
+       (init-R4RS!)
+       (case scheme
+         [MzScheme (init-MzScheme-on-R4RS!)]
+         [DrScheme (init-MzScheme-on-R4RS!) 
+                   (init-DrScheme-on-MzScheme!)]
+         [R4RS     (void)]
+         [Chez     (init-Chez-on-R4RS!)]
+         [Rice     (init-Chez-on-R4RS!)
+                   (init-Rice-on-Chez!)]
+         [none     (void)])
+       (when (st:numops) (init-smart-numops!))
+       ;; Load .spideyrc file and .spidey-system-rc files
+       (when (file-exists? "~/.spideyrc") (load "~/.spideyrc"))
+       (let ([systemrc (string-append "~/.spidey-" 
+                                      (symbol->string scheme)
+                                      "-rc")])
+         (when (file-exists? systemrc) (load systemrc)))
+       (capture-input-type-expander!)))))
+
+;; ======================================================================
+
diff --git a/collects/mrspidey/Sba/traverse.ss b/collects/mrspidey/Sba/traverse.ss
new file mode 100644
index 0000000..3e54a76
--- /dev/null
+++ b/collects/mrspidey/Sba/traverse.ss
@@ -0,0 +1,1469 @@
+; ASSUME DEFINED VARIABLES NEVER ASSIGNED
+
+; traverse.ss
+; Traverses source program and produces constraints.
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ------------------------------------------------------------
+
+;; Environments are:
+;; (Name -> (or FlowType mutable-binding))
+
+;; ----------------------------------------------------------------------
+
+(define (top-level-traverse-defs defs env)
+  ;;(assert (atenv:ok? env) 'top-level-traverse-defs)
+  (begin0
+    (traverse-defs defs env)
+    (unless (null? defs)
+      (mrspidey:zprogress "Analyzing" (zodiac:zodiac-finish (rac defs))))
+    ))
+
+(define traverse:bad-expr (void))
+
+(define (traverse-defs defs env)
+  ;;(assert (atenv:ok? env) 'traverse-defs)
+  ;; returns (values env refs result)
+  (pretty-debug-traverse `(->traverse-defs))
+  ;; First alloc void for all defines
+  (let* ( [lvrs (apply append
+                  (map (match-lambda
+                         [($ zodiac:define-values-form _ _ _ _ vars) vars]
+                         [_ '()])
+                    defs))]
+          [names (map zodiac:varref-binding lvrs)]
+          [nuenv (atenv:extend-undefineds env names)]
+          ;; bubble define-struct stuff to top
+          [defs 
+            (append
+              (filter
+                (match-lambda
+                  [($ zodiac:define-values-form _ _ _ _ _ 
+                     ($ zodiac:struct-form))
+                    #t]
+                  [_ #f])
+                defs)
+              (filter
+                (match-lambda
+                  [($ zodiac:define-values-form _ _ _ _ _ 
+                     ($ zodiac:struct-form))
+                    #f]
+                  [_ #t])
+                defs))])
+    (recur loop ([defs defs]
+                 [env nuenv]
+                 [refs '()]
+                 [result (wrap-value (mk-tvar-void))])
+      (match defs
+        [() (atenv:flush! env)
+          (values env refs result)]
+        [(first . rest)
+         (let-values
+           ([(env nu-refs result) (traverse-def first env)])
+           (loop rest env (append nu-refs refs) result))]))))
+
+;; ----------------------------------------------------------------------
+
+(define (traverse-def def env)
+  ;; returns (values env refs result) 
+  ;; (: env (listof (cons Name FlowType)))
+  ;; (: refs (listof (cons Name Tvar)))
+  ;; (: result FlowType) -- multiple value list
+
+  (pretty-debug-traverse-small
+   `(->traverse-def
+     ,(zodiac:location-offset (zodiac:zodiac-start def))
+     ,(zodiac:stripper def)))
+
+  (mrspidey:zprogress "Analyzing" (zodiac:zodiac-start def))
+
+  (let* ([tvar-E (mk-Tvar 'def)])
+    (link-parsed-ftype! def tvar-E)
+    (new-AV! tvar-E AV-void)
+    (match def
+      ;; --- define
+      [($ zodiac:define-values-form  _ _ _ _ lvrs exp)
+       (let*-vals ([(ftype env refs) (traverse-exp exp env)]
+                   [ftypes (multiple-value-components ftype (length lvrs))]
+                   [ftypes (map link-parsed-ftype! lvrs ftypes)]
+                   [names (map zodiac:varref-binding lvrs)]
+                   [env (atenv:change-bindings env names ftypes)])
+                  (values env refs (wrap-value (mk-tvar-void))))]
+      ;; --- define-type
+      [($ zodiac:define-type-form _ s _ _ sym type)
+       (let ([tvar (mk-Tvar 'define-type)])
+         (schema->con
+           (expand-input-type-err type def)
+           tvar 'define-type '())
+         (add-global-tdef! sym tvar)
+         (values env '() (wrap-value (mk-tvar-void))))]
+      ;; --- define-constructor
+      [($ zodiac:define-constructor-form _ _ _ _ name modes)
+       (apply add-constructor! name modes)
+       (values env '() (wrap-value (mk-tvar-void)))]
+      ;; --- Exp
+      [exp
+       (let-values ([(result env refs) (traverse-exp exp env)])
+                   (values env refs result))])))
+
+;; ----------------------------------------------------------------------
+
+(define values-trap-pt (void))
+
+(define (traverse-exp E env)
+  (: env (listof (cons Name (or mutable-binding FlowType))))
+
+  ;; returns (values FlowType env refs)
+  ;; (: refs (listof (cons Name Tvar)))
+  ;; FlowType is annotated type for list of results
+
+  (letrec*
+   ([refs '()]
+    [extend-ref! 
+     (lambda (name tvar) (set! refs (cons (cons name tvar) refs)))]
+    [extend-refs!
+     (lambda (refs)
+       (for-each
+        (match-lambda
+         [(name . tvar) (extend-ref! name tvar)])
+        refs))]
+    ;; ---
+    [pattern-match (lambda (tvar-formal tvars-actuals)
+                     (match tvars-actuals
+                       [(? Tvar?) (new-edge! tvar-formal tvars-actuals)]
+                       [(tvar1 . rest)
+                        (let ([tvar-cdr (mk-Tvar 'arg-cdr)])
+                          (new-con! tvar-formal (make-con-car tvar1))
+                          (new-con! tvar-formal (make-con-cdr tvar-cdr))
+                          (pattern-match tvar-cdr rest))]
+                       [() (void)]))]
+    [handle-lambda-form
+     (lambda (args body env1)
+       (: args zodiac:arglist)
+            
+       (let*-vals
+        ( [env2 (atenv:unflush env1)]
+          [tvar-arg (mk-Tvar 'args)]
+          [improper? 
+            (or (zodiac:sym-arglist? args) (zodiac:ilist-arglist? args))]
+          ;;[_ (pretty-print `(improper ,improper? ,args))]
+          [args (zodiac:arglist-vars args)]
+          [env3 
+            (recur loop ([env env2][args args][tvar tvar-arg])
+              (cond
+                [(null? args) env]
+                [(and improper? (null? (cdr args)))
+                  (atenv:extend env (car args) tvar)]
+                [else
+                  (let ( [tvar-car (mk-Tvar 'arg-car)]
+                         [tvar-cdr (mk-Tvar 'arg-cdr)])
+                    (new-con! tvar (make-con-car tvar-car))
+                    (new-con! tvar (make-con-cdr tvar-cdr))
+                    (loop (atenv:extend env (car args) tvar-car)
+                      (cdr args)
+                      tvar-cdr))]))]
+         [(ftype-rv env4) (traverse body env3)]
+         [AV (make-AV-lam tvar-arg (FlowType->Tvar ftype-rv)
+                          (if improper? (sub1 (length args)) (length args))
+                          improper?)]
+         [tvar-E (mk-Tvar 'lam)])
+        (atenv:flush! env4)
+        (new-AV! tvar-E AV)
+        tvar-E))]
+
+     [handle-application
+       (lambda (E env flush?)
+         (match E
+           [($ zodiac:app _ _ _ _ fn args)
+             (set! values-trap-pt "|")
+             (let*-vals 
+               ( [(ftype-fn env1 pi) 
+                   ;; Traverse fn specially if fo prim ref 
+                   ;; don't instantiate yet, wait till have # args
+                   (match fn
+                     [($ zodiac:varref)
+                       (=> fail)
+                       (if (st:special-fo-prims)
+                         (match (atenv:lookup env (zodiac:varref-binding fn))
+                           [#f 
+                             (set! values-trap-pt "A")
+                             (fail)]
+                           [ftype
+                             (set! values-trap-pt "B")
+                             (match (FlowType->Atype ftype)
+                               [(and pi ($ atprim sym tschema))
+                                 (set! values-trap-pt "C")
+                                 (zodiac:set-parsed-atprim! fn pi)
+                                 (let ([tvar-fn (mk-Tvar sym)])
+                                   (tschema->con-for-nargs tschema 
+                                     tvar-fn sym '() (length args))
+                                   (link-parsed-ftype! fn (wrap-value tvar-fn))
+                                   (set! values-trap-pt "D")
+                                   (values tvar-fn env pi))]
+                               [_ 
+                                 (set! values-trap-pt "E")
+                                 (fail)])])
+                         (begin (set! values-trap-pt "F") (fail)))]
+                     [_ 
+                       (set! values-trap-pt "G")
+                       (let-values ([(ftype env) (traverse1 fn env)])
+                         (set! values-trap-pt "H")
+                         (values ftype env #f))])]
+                 [_ (set! values-trap-pt "K")]
+                 [(ftype-arg* env2) (traverse* args env1)]
+                 [ftype-arg* (map extract-1st-value ftype-arg*)]
+                 [env3 (if (and flush? (not pi))
+                         (atenv:unflush (atenv:flush! env2))
+                         env2)]
+
+                 [tvar-fn (FlowType->Tvar ftype-fn)]
+                 [tvar-arg* (map FlowType->Tvar ftype-arg*)]
+                 [tvar-arg
+                   (foldr
+                     (lambda (tvar-arg tvar-rest-args)
+                       (let* ([tvar (mk-Tvar 'arg)])
+                         (new-AV! tvar 
+                           (make-AV-cons tvar-arg tvar-rest-args))
+                         tvar))
+                     (mk-tvar-nil)
+                     tvar-arg*)]
+                 [tvar-E (mk-Tvar 'expr)])
+               ;;(link-parsed-ftype! fn (wrap-value tvar-fn))
+               (pretty-debug-traverse
+                 `(tvar-fn ,(Tvar-name tvar-fn)
+                    tvar-arg ,(Tvar-name tvar-arg)))
+               (zodiac:set-app-tvar-args! E tvar-arg)
+               (new-con! tvar-fn (make-con-dom tvar-arg))
+               (new-con! tvar-fn (make-con-rng tvar-E))
+               (values tvar-E
+                 (if (and (st:flow-sensitive) pi)
+                   (flow-sensitive-env pi args env3)
+                   env3)))]))]
+
+    ;; ---
+    [traverse*
+     (lambda (E* env)
+       ;; Returns (values (listof FlowType) env)
+       (pretty-debug-traverse `(->traverse* ,(length E*)))
+       (match
+           (foldl
+            (match-lambda*
+             [(E (ftype* . env))
+              (let-values ([(ftype nuenv) (traverse E env)])
+                          (cons (cons ftype ftype*) nuenv))])
+            (cons '() env)
+            E*)
+         [(ftype* . env)
+          (pretty-debug-traverse 
+           `(<-traverse* ,(map FlowType->pretty (reverse ftype*))))
+          (values (reverse ftype*) env)]))]
+    ;; ---
+    [made-unit (lambda (atype)
+                 (cond
+                  [(not (st:fo-units))      (Atype->Tvar atype)]
+                  [(not (st:lazy-fo-units)) (atlunit->atunit atype)]
+                  [else                     atype]))]
+    [traverse1 (lambda (E env)
+                 (let*-vals ([(ftype env) (traverse E env)]
+                             [ftype (extract-1st-value ftype)])
+                            (values ftype env)))]
+    [traverse
+     (lambda (E env)
+       ;;(assert (atenv:ok? env) 'traverse)
+
+       (pretty-debug-traverse-small
+        `(->traverse
+           ,(zodiac:location-offset (zodiac:zodiac-start E))
+           ,(zodiac:stripper E)
+           ,(atenv->pretty env)))
+       (let*-vals 
+        ([trav (lambda (E) (traverse E env))]
+         [(result env-result)
+          (match E
+            ;; (: result (union Tvar fo-FlowType fo-Atype))
+
+            [($ zodiac:varref)
+              (let ([name (zodiac:varref-binding E)])
+                (match (atenv:lookup env name)
+                  [#f (let ([tvar (mk-Tvar 'import-var)])
+                        (extend-ref! name tvar)
+                        (values (wrap-value tvar) env))]
+                  [ftype 
+                    ;; Instantiate schemas and atprims here
+                    (let* ( [atype (FlowType->Atype ftype)]
+                            [ftype
+                              (if (or (atprim? atype) (schema? atype))
+                                (FlowType->Tvar ftype)
+                                ftype)])
+                      (when (atprim? atype) 
+                        (zodiac:set-parsed-atprim! E atype))
+                      (values (wrap-value ftype) env))]))]
+
+            [($ zodiac:quote-form _ _ _ _ 
+                (or ($ zodiac:boolean _ _ _ c)
+                    ($ zodiac:number _ _ _ c)))
+             (values (wrap-value (make-atconst c)) env)]
+               
+            [($ zodiac:quote-form _ _ _ _ c)
+             (values (wrap-value (traverse-const c)) env)]
+
+            ;; --- local set!
+            [($ zodiac:set!-form _ _ _ _ lvr exp)
+              (let*-vals ([(ftype env1) (trav exp)]
+                         [ftype (extract-1st-value ftype)]
+                         [ftype (link-parsed-ftype! lvr ftype)]
+                         [name (zodiac:varref-binding lvr)]
+                         [env2 (atenv:change-binding env1 name ftype)])
+                        (values (wrap-value (mk-tvar-void)) env2))]
+
+            [($ zodiac:if-form _ _ _ _ test then else)
+              ;; old version
+              '(let*-vals
+                 ([(ftype env1) (trav test)]
+                   [env2 (atenv:capture-locs env1 
+                           (zodiac:free-vars E (atenv:domain env1)))]
+                   [(env-then env-else) 
+                     (if (st:if-split)
+                       (if-splitting-env test env2)
+                       (values env2 env2))]
+                   [tvar-E (mk-Tvar 'expr)]
+                   [do-branch 
+                     (lambda (exp env)
+                       (let-values ([(ftype env2) (traverse exp env)])
+                         (atenv:flush! env2)
+                         (new-edge! (FlowType->Tvar ftype) tvar-E)))])
+                 (when (or (not (st:if-split))
+                         (match (FlowType->Atype ftype)
+                           [($ atconst #f) #f]
+                           [_ #t]))
+                   (do-branch then env-then))
+                 (when (or (not (st:if-split))
+                         (match (FlowType->Atype ftype)
+                           [($ atconst #f) #t]
+                           [($ atconst _) #f]
+                           [_ #t]))
+                   (do-branch else env-else))
+
+                 (values tvar-E (atenv:unflush env2)))
+
+              ;; new version
+              (let*-vals
+                ( [(ftype env1) (trav test)]
+                  [env-dom (atenv:domain env1)]
+                  [env1 (atenv:capture-locs env1 
+                          (zodiac:free-vars then env-dom))]
+                  [env1 (atenv:capture-locs env1
+                          (zodiac:free-vars else env-dom))]
+                  [(env-then env-else) 
+                    (if (st:if-split)
+                      (if-splitting-env test env1)
+                      (values env1 env1))]
+                  [tvar-E (mk-Tvar 'expr)]
+                  [do-branch 
+                    (lambda (exp env)
+                      (let-values ([(ftype env2) (traverse exp env)])
+                        (new-edge! (FlowType->Tvar ftype) tvar-E)
+                        env2))]
+                  [env-then-done
+                    (and (or (not (st:if-split))
+                           (match (FlowType->Atype ftype)
+                             [($ atconst #f) #f]
+                             [_ #t]))
+                      (do-branch then env-then))]
+                  [env-else-done
+                    (and (or (not (st:if-split))
+                           (match (FlowType->Atype ftype)
+                             [($ atconst #f) #t]
+                             [($ atconst _) #f]
+                             [_ #t]))
+                      (do-branch else env-else))])
+
+                (values tvar-E
+                  (cond
+                    [(and 
+                       (eq? env-then env-then-done)
+                       (eq? env-else env-else-done))
+                      env1]
+                    [(not env-else-done) env-then-done]
+                    [(not env-then-done) env-else-done]
+                    [else
+                      (atenv:flush! env-then-done)
+                      (atenv:flush! env-else-done)
+                      (atenv:unflush env1)])))]
+
+            ;; ### SPECIAL CODE FOR STRUCT-REF
+            [($ zodiac:app _ _ _ _
+               ($ zodiac:varref _ _ _ _ '#%struct-ref)
+               ( struct-exp
+                 ($ zodiac:quote-form _ _ _ _ ($ zodiac:number _ _ _ n))))
+              (assert (and (integer? n) (>= n 0)))
+              ;;(printf "Special struct-ref~n")
+              (let*-vals 
+                ( [(ftype-struct env1) (traverse1 struct-exp env)]
+                  [tvar-struct (FlowType->Tvar ftype-struct)]
+                  [tvar-elem (mk-Tvar 'struct-ref)])
+                (new-con! tvar-struct
+                  (create-con template-structure n tvar-elem #t))
+                (values (wrap-value tvar-elem) env1))]
+
+            ;; ### SPECIAL CODE FOR ivar
+            [($ zodiac:app _ _ _ _
+               (and ref ($ zodiac:varref _ _ _ _ (or '#%uq-ivar 'uq-ivar)))
+               ( obj-exp
+                 (and sym-exp
+                   ($ zodiac:quote-form _ _ _ _ ($ zodiac:symbol _ _ _ sym)))))
+              ;;(printf "Special uq-ivar~n")
+              (let*-vals 
+                ( [(ftype-obj env1) (traverse1 obj-exp env)]
+                  [tvar-obj (FlowType->Tvar ftype-obj)]
+                  [tvar-ivar (mk-Tvar 'ivar-ref)])
+                (new-con! tvar-obj
+                  (create-con (get-ivar-template sym) 0 tvar-ivar #t))
+                ;(trav ref)
+                ;(trav sym-exp)
+                (values (wrap-value tvar-ivar) env1))]
+
+            ;; ### SPECIAL CODE FOR UNIT/SIG
+            [($ zodiac:app _ _ _ _
+               (and ref ($ zodiac:varref _ _ _ _ '#%make-unit-with-signature))
+               (unit-exp _ _))
+              (traverse unit-exp env)]
+            [($ zodiac:app _ _ _ _
+               (and ref 
+                 ($ zodiac:varref _ _ _ _ '#%verify-linkage-signature-match))
+               args)
+              (values (wrap-value (mk-tvar-void)) env)]
+            [($ zodiac:app _ _ _ _
+               (and ref 
+                 ($ zodiac:varref _ _ _ _ '#%unit-with-signature-unit))
+               (unit-exp))
+              (traverse unit-exp env)]
+
+
+            
+            [($ zodiac:app _ _ _ _ fn args)
+              (handle-application E env #t)]
+                       
+            [($ zodiac:letrec*-values-form _ _ _ _ varss exps body)
+             ;; First init each new var
+             (recur loop
+                 ([env (atenv:extend-undefineds env (apply append varss))]
+                  [varss varss]
+                  [exps exps])
+               (if (null? exps)
+                   (traverse body env)
+                   (let*-vals
+                    ([(ftype nuenv) (traverse (car exps) env)]
+                     [vars (car varss)]
+                     [ftypes (multiple-value-components ftype (length vars))]
+                      ;; overwrite void binding
+                     [ftypes (map link-parsed-ftype! vars ftypes)]
+                     [nuenv2 (atenv:change-bindings nuenv vars ftypes)])
+                    (loop nuenv2 (cdr varss) (cdr exps)))))]
+
+            [($ zodiac:let-values-form _ _ _ _ varss exps body)
+             (let*-vals 
+              ([(ftype* nuenv) (traverse* exps env)]
+               [nuenv2
+                (foldr2
+                 (lambda (vars ftype env)
+                   (assert (list? vars) 'let-valeus-form)
+                   (atenv:extend* 
+                    env vars
+                    (multiple-value-components ftype (length vars))))
+                 nuenv varss ftype*)])
+              (traverse body nuenv2))]
+
+            [($ zodiac:case-lambda-form _ _ _ _ args bodies)
+             (let ( [tvar-E (mk-Tvar 'expr)]
+                    [env1 (atenv:capture-locs env 
+                            (zodiac:free-vars E (atenv:domain env)))])
+               (for-each
+                (lambda (args body) 
+                  (new-edge! 
+                    (FlowType->Tvar (handle-lambda-form args body env1))
+                    tvar-E))
+                 args bodies)
+               (values (wrap-value tvar-E) env1))]
+
+            ;;[($ zodiac:delay-form _ _ _ _ expr)
+            ;; (let*-vals
+            ;;  ([env1 (atenv:capture-locs env (zodiac:free-vars E))]
+            ;;   [env2 (atenv:unflush env1)]
+            ;;   [(ftype-expr env3) (traverse1 expr env2)]
+            ;;   [AV (make-constructed-AV-template 
+            ;;        template-promise (FlowType->Tvar ftype-expr))]
+            ;;   [tvar-E (mk-Tvar 'expr)])
+            ;;  (atenv:flush! env3)
+            ;;  (new-AV! tvar-E AV)
+            ;;  (values (wrap-value tvar-E) env1))]
+
+            [($ zodiac:begin-form _ _ _ _ bodies)
+              (recur loop ([env env][bodies bodies])
+                (match bodies
+                  ;;[() (values (wrap-value (mk-tvar-void)) env)]
+                  [(a . d)
+                    (let*-vals ([(ftype nuenv) (traverse a env)])
+                      (if (null? d)
+                        (values ftype nuenv)
+                        (loop nuenv d)))]))]
+            [($ zodiac:begin0-form _ _ _ _ (start . rest))
+              (let*-vals ([(ftype nuenv) (traverse start env)])
+                (recur loop ([env nuenv][rest rest])
+                  (match rest
+                    [() (values ftype env)]
+                    [(a . d)
+                      (let*-vals ([(ftype nuenv) (traverse a env)])
+                        (loop nuenv d))])))]
+
+            ;; --------------------------------------------------------
+            ;; MzScheme special forms
+
+            [($ zodiac:unit-form)
+              (let* ([env1 (atenv:unflush env)])
+                ;; Assume no refs inside unit to imports of enclosing unit
+                (values (wrap-value (made-unit (create-atlunit-unit env1 E))) 
+                  env))]
+
+            [($ zodiac:compound-unit-form _ s _ _ imports links exports)
+             (let*-vals 
+              ([time-E (zodiac-time E)]
+               [exprs (map cadr links)]
+               [(ftype* env) (traverse* exprs env)]
+               [time* (map (lambda (e) (max time-E (zodiac-time* e)))
+                           exprs)]
+               ;; Assume E is closed               
+               [ftype* (mapLR extract-1st-value ftype*)])
+              (values 
+               (wrap-value (made-unit (create-atlunit-cmpd E time* ftype*)))
+               env))]
+
+            ;; ### Doesn't deal in first-order fashion
+            [($ zodiac:invoke-unit-form _ _ _ _ exp vars)
+              (let*-vals ( [(ftype env1) (traverse1 exp env)]
+                           ;;[tvar (FlowType->Tvar ftype)]
+                           [(ftype* env2) (traverse* vars env1)]
+                           [ftypes.times
+                             (map (lambda (f) (cons f (current-seconds)))
+                               ftype*)]
+                           [env1 (atenv:flush! env1)]
+                           [env2 (atenv:unflush env1)]
+                           [atype-U (apply-unit ftype ftypes.times)]
+                           [tvar-E 
+                             (match atype-U
+                               [($ atunit _ _ result) result]
+                               [(? Tvar? tvar-u)
+                                 (let ([tvar (mk-Tvar 'invoke-unit-result)])
+                                   (new-con! tvar-u
+                                     (create-con template-unit 0 tvar #t))
+                                   tvar)])])
+                (values tvar-E env2))]
+
+            ;; --------------------------------------------------------
+            ;; MzScheme special forms
+
+            [($ zodiac:class*/names-form)
+              (handle-class*/names-form E env 
+                traverse traverse* handle-application)]
+
+            ;; --------------------
+
+            [($ zodiac:poly-form _ _ _ _ exp)   
+              (unless (zodiac:parsed-value? exp)
+                (mrspidey:error "poly annotation on non-value" exp))
+              (let*-vals
+                ( [name-for-edge 
+                    (match-lambda
+                      [(f . t) (cons (Tvar-name f) (Tvar-name t))])]
+                  [analyze 
+                    (lambda ()
+                      (let*-vals 
+                        ( [l1 list-ftype]
+                          [base-num num-ftype]
+                          ;; Capture edges from external mono AVSs 
+                          [edges '()]
+                          [orig-new-edge! (new-edge-para)]
+                          [capture-edge! 
+                            (lambda (from to)
+                              (unless (eq? from to)
+                                (if (< (FlowType-num from) base-num)
+                                  ;; Edge from outside constraint set
+                                  (set! edges (cons (cons from to) edges))
+                                  (orig-new-edge! from to))))]
+                          [(env refs tvar)
+                            (dynamic-let
+                              ([new-edge-para capture-edge!])
+                              (let*-vals 
+                                ( [(ftype env refs) (traverse-exp exp env)]
+                                  [ftype1 (extract-1st-value ftype)]
+                                  [tvar (FlowType->Tvar ftype1)])
+                                (values env refs tvar)))]
+                          [l2 list-ftype])
+
+                        (pretty-debug 
+                          `(Poly-def-result 
+                             ,(FlowType-name tvar) 
+                             num-AVS
+                             ,(- (FlowType-num (car l2)) 
+                                (FlowType-num (car l1)))
+                             ,(FlowType-name (car l2))
+                             ,(FlowType-name (car l1))
+                             external-edges
+                             ,(map name-for-edge edges)))
+                        (values env refs tvar l1 l2 edges)))]
+                  [handle-edges! (lambda (edges)
+                                   (for-each 
+                                     (match-lambda 
+                                       [(from . to) (new-edge! from to)])
+                                     edges))]
+                  [(def env)
+                    (case (st:polymorphism)
+                      [(reanalyze)
+                        (mrspidey:error "Reanalyze does not work - env problem")
+                        (make-atthunk
+                          (lambda ()
+                            (let*-vals
+                              ([(env refs tvar l1 l2 edges) (analyze)])
+                              (for-each
+                                (match-lambda
+                                  [(binding . _)
+                                    (mrspidey:warning "Reference to ~s inside poly form with (st:polymorphism 'reanalyze)" exp 3)])
+                                refs)
+                              (handle-edges! edges)
+                              tvar)))]
+                      [(copy-con)
+                        (let*-vals ([(env refs tvar l1 l2 edges) (analyze)])
+                          (extend-refs! refs)
+                          (values
+                            (make-schema tvar
+                              (filter Tvar? (get-prefix l2 l1))
+                              edges)
+                            env))]
+                      [(compress)
+                        (let*-vals
+                          ( [(env refs tvar l1 l2 edges) (analyze)]
+                            [_ (extend-refs! refs)]
+                            ;; Tracked all incoming edges in edges
+                            ;; These correspond to upper bindings
+                            [U-tvar* (list tvar)]
+                            [L-tvar* (map cdr edges)]
+                            [old-num-ftype num-ftype]
+                            [old-num-AV num-AV]
+                            [old-num-edge num-edge]
+                            [old-num-con num-con]
+                            [(rep-tvar tvar->nu) 
+                              (minimize-constraints-&-compare
+                                (st:constraint-simplification-poly)
+                                L-tvar* U-tvar*
+                                l2 l1)]
+                            ;; Update edges to point to the compressed set
+                            [nu-edges
+                              (filter-map
+                                (match-lambda
+                                  [(and edge (from . to))
+                                    (let ([nu-to (tvar->nu to)])
+                                      (if nu-to
+                                        (cons from (tvar->nu to))
+                                        (begin
+                                          '(pretty-debug-traverse
+                                             `(dropping ,(name-for-edge edge)))
+                                          #f)))])
+                                edges)])
+
+                          (when (> (- num-ftype old-num-ftype) 250)
+                            (printf "Poly def AVS ~s AV ~s edge ~s con ~s~n"
+                              (- num-ftype old-num-ftype)
+                              (- num-AV old-num-AV)
+                              (- num-edge old-num-edge)
+                              (- num-con old-num-con)))
+                          
+                          (values
+                            (make-schema (tvar->nu tvar) rep-tvar nu-edges)
+                            env))]
+                      [(none)
+                        (let*-vals ([(env refs tvar l1 l2 edges) (analyze)])
+                          (extend-refs! refs)
+                          (handle-edges! edges)
+                          (values tvar env))])])
+                (values (wrap-value def) env))]
+ 
+            [($ zodiac:struct-form _ s _ _ 
+               ($ zodiac:symbol _ _ _ tag)
+               parent
+               (($ zodiac:symbol _ _ _ fields) ...))
+              (let*-vals
+                ([(parent-ftype env1)
+                   (match parent
+                     [#f (values
+                           (create-fo-FlowType
+                             (make-atstruct 'tag '(structure:) 
+                               '() '() '() '()))
+                           env)]
+                     [exp (traverse1 parent env)])])
+                (match (FlowType->Atype parent-ftype)
+                  [(and atstruct ($ atstruct))
+                    (values (handle-struct-form tag #f atstruct fields)
+                      env)]
+                  [_ 
+                    (pretty-debug-traverse `(FlowType->pretty parent-ftype))
+                    (mrspidey:warning 
+                      (format 
+                        "Expression does not analyze to a first-order struct")
+                      (zodiac:zodiac-start parent)
+                      0)
+                    (values (mk-Tvar 'empty) env)]))]
+
+            ;; --------------------------------------------------------
+            ;; MrSpidey special forms
+
+            [($ zodiac::-form _ _ _ _ exp type)
+             (let*-vals 
+              ([(ftype nuenv) (traverse1 exp env)])
+              (pretty-debug `(:: ,ftype ,nuenv))
+              (match exp
+                [($ zodiac:varref _ _ _ _ sym)
+                  (let ([name (zodiac:varref-binding  exp)])
+                    (if (and (st:flow-sensitive) (Tvar? ftype))
+                      (let* ( [type type]
+                              [type (match type
+                                      [('exact type) type]
+                                      [type type])]
+                              [etype (expand-input-type type)]
+                              [templates (type->templates etype)]
+                              [sym (zodiac:binding-var name)])
+                        (if templates
+                          (let* ( [filter (create-filter #t templates)]
+                                  [nutvar (mk-Tvar sym)])
+                            (new-con! ftype (create-con-filter filter nutvar))
+                            (values (wrap-value nutvar)
+                              (atenv:change-binding nuenv name nutvar)))
+                          (values (wrap-value ftype) nuenv)))
+                      (values (wrap-value ftype) nuenv)))]
+                [_ (values (wrap-value ftype) nuenv)]))]
+
+            [($ zodiac:st:control-form _ _ _ _ para val)
+             (mrspidey:control-fn para val)
+             (values (wrap-value (mk-tvar-void)) env)]
+
+            [($ zodiac:type:-form _ s _ _ type attrs)
+              (let ([type (expand-input-type-err type E)])
+                (values
+                  (wrap-value (apply primitive->atprim 'user type attrs))
+                  env))]
+
+            [($ zodiac:reference-unit-form)
+              (values 
+                (wrap-value (made-unit (create-atlunit-reference E)))
+                env)]
+            
+            [($ zodiac:invoke-open-unit-form)
+              (mrspidey:error 
+                "MrSpidey does not support invoke-open-unit" E)]
+
+            [($ zodiac:define-values-form)
+              (mrspidey:error 
+                "MrSpidey does not support internal defines" E)]
+
+            [E 
+              (set! traverse:bad-expr E)
+              (mrspidey:error "Bad expr in traverse" E)])]
+
+         ;; --------------------
+
+          ;; env-result may contain extra bindings, 
+          ;; but they have no effect
+
+         [_ (: result (union Tvar fo-FlowType fo-Atype))]
+         [_ (pretty-debug-traverse 
+              `(traverse result ,(FlowType->pretty result)))]
+         [ftype (link-parsed-ftype! E result)])
+
+         (pretty-debug-traverse-small
+           `(<-traverse 
+              ,(zodiac:location-offset (zodiac:zodiac-start E))
+              ,(zodiac:stripper E)
+              ,(atenv->pretty env-result)
+              ,(FlowType->pretty ftype)))
+
+        (assert (FlowType? ftype) 'end-traverse ftype)
+        (values ftype env-result)))])
+
+   (let-values ([(ftype env) (traverse E env)])
+               (values ftype env refs))))
+
+;; ----------------------------------------------------------------------
+
+(define (handle-class*/names-form E start-env 
+          traverse traverse* handle-application)
+  (let ([handle-paroptarglist
+          (lambda (env init-arglist tvar-arg)
+            (pretty-debug-object
+              `(handle-paroptarglist ,(atenv->pretty env) 
+                 ,init-arglist
+                 ,(Tvar-name tvar-arg)))
+            ;; Bindings are already in atlist
+            (let*
+              ( [improper? 
+                  (or (zodiac:sym-paroptarglist? init-arglist)
+                    (zodiac:ilist-paroptarglist? init-arglist))]
+                [args (zodiac:paroptarglist-vars init-arglist)]
+                [initialize-arg
+                  (lambda (env arg tvar)
+                    (match arg
+                      [(and bind ($ zodiac:binding))
+                        (atenv:change-binding env bind tvar)]
+                      [((and bind ($ zodiac:binding)) . exp)
+                        (let*-vals
+                          ( [(ftype env) (traverse exp env)]
+                            [ftype (extract-1st-value ftype)])
+                          (new-edge! (FlowType->Tvar ftype) tvar)
+                          (atenv:change-binding env bind tvar))]))])
+              (recur loop ([env env][args args][tvar tvar-arg])
+                (cond
+                  [(null? args) env]
+                  [(and improper? (null? (cdr args)))
+                    (initialize-arg env (car args) tvar)]
+                  [else
+                    (let ( [tvar-car (mk-Tvar 'arg-car)]
+                           [tvar-cdr (mk-Tvar 'arg-cdr)])
+                      (new-con! tvar (make-con-car tvar-car))
+                      (new-con! tvar (make-con-cdr tvar-cdr))
+                      (loop 
+                        (initialize-arg env (car args) tvar-car)
+                        (cdr args)
+                        tvar-cdr))]))))])
+
+  (match E
+    [($ zodiac:class*/names-form _ _ _ _ 
+       this-name 
+       super-init-name
+       super-expr
+       _
+       (and init-arglist ($ zodiac:paroptarglist init-vars))
+       clauses)
+      
+      (pretty-debug-object `(init-arglist ,init-arglist))
+      
+      (let*-vals
+        ( ;; --- Work from top down according to class.dvi
+          ;; --- Traverse super-exprs
+          [(super-ftype env-after-super) (traverse super-expr start-env)]
+          [tvar-super (FlowType->Tvar (extract-1st-value super-ftype))]
+
+          ;; extract portions of tvar-super
+          [f (lambda (sign)
+               (lambda (ndx)
+                 (let ([tvar (mk-Tvar 'class-field)])
+                   (new-con! tvar-super 
+                     (create-con template-internal-class 
+                       ndx tvar sign))
+                   tvar)))]
+          [super-u ((f #t) 0)]
+          [super-o ((f #t) 1)] 
+          [super-i ((f #t) 2)]
+          [super-f ((f #t) 3)]
+          [super-b ((f #f) 0)]
+          [super-a ((f #f) 1)]
+          [super-g ((f #f) 2)]
+          [super-t ((f #f) 3)]
+          [super-v ((f #t) 4)]
+
+          ;; Transfers control just like lambdas, capture it here
+          [captured-env 
+            (atenv:capture-locs env-after-super
+              (zodiac:free-vars E (atenv:domain env-after-super)))]
+          [env (atenv:extend captured-env super-init-name super-i)]
+          [env (atenv:unflush env)]
+
+          [super-init-name?
+            (lambda (var)
+              (and (zodiac:varref? var)
+                (eq? (zodiac:varref-binding var) 
+                  super-init-name)))]                
+          
+          ;; Fields for class
+
+          [this-u (mk-Tvar 'this-u)]
+          [this-o (mk-Tvar 'this-o)]
+          [tvar-args (mk-Tvar 'this-tvar-args)]
+          [this-i (mk-Tvar-init-AV 'this-i
+                    (make-AV-lam tvar-args (mk-tvar-void) 0 #t))]
+          [this-b (mk-Tvar 'this-b)]
+          [this-a (mk-Tvar 'this-a)]
+          [this-f (mk-Tvar 'this-f)]
+          [this-g (mk-Tvar 'this-g)]
+          [this-t (mk-Tvar 'this-t)]
+          [this-v (mk-Tvar 'this-v)]
+          [tvar-class
+            (mk-Tvar-init-AV 'class
+              (create-AV template-internal-class '()
+                (vector this-u this-o this-i this-f this-v)
+                (vector this-b this-a this-g this-t)))]
+
+          ;; Anything not clause dependant
+
+          [_ (new-edge! super-u this-u)]
+          [_ (new-edge! this-t super-t)]
+
+          ;; Now to do the init args and clauses
+
+          ;; --- Build up environment
+          [env (atenv:extend env this-name this-t)]
+          ;; args
+          [env (foldr 
+                 (lambda (var env)
+                   (atenv:extend env 
+                     (if (zodiac:binding? var)
+                       var
+                       (car var))
+                     (mk-Tvar 'init-var)))
+                 env
+                 init-vars)]
+
+          ;; --- helper stuff
+          [tvar-undef (mk-Tvar-init-AV 'delta AV-undefined)]
+          [ivar-put
+            (lambda (to sym tvar)
+              (new-AV! to
+                (create-AV
+                  (get-ivar-template sym)
+                  '() (vector tvar) (vector))))]
+          [ivar-get
+            (lambda (from sym tvar)
+              (new-con! from
+                (create-con
+                  (get-ivar-template sym)
+                  0 tvar #t)))]
+
+          ;; Traverse clauses, alloc a-j etc, extend env 
+          ;; and find super-init call
+
+          [super-init-expr #f]
+          [_ (pretty-debug-object `(calc clause-info))]
+          [clause-info
+            (map-clause
+              (lambda (public? define? override?
+                        export internal expr import)
+                (let* ( [a-j (mk-Tvar 'a-j)]
+                        [b-j (mk-Tvar 'b-j)]
+                        [r-j (mk-Tvar 'r-j)]
+                        [g-j (mk-Tvar 'g-j)])
+                  (match expr
+                    ;; straight application
+                    [($ zodiac:app _ _ _ _ (? super-init-name?) _)
+                      (set! super-init-expr expr)]
+                    ;; apply
+                    [($ zodiac:app _ _ _ _ 
+                       (and fn ($ zodiac:varref _ _ _ _ 'apply))
+                       ((? super-init-name?) . _))
+                      (match (FlowType->Atype 
+                               (atenv:lookup env (zodiac:varref-binding fn)))
+                        [($ atprim 'apply) 
+                          (set! super-init-expr expr)]
+                        [_ (void)])]
+                    [_ (void)])
+                  (when internal
+                    (zodiac:set-binding-mutated! internal #t)
+                    (set! env (atenv:extend-mutated env internal b-j g-j))
+                    (link-parsed-ftype! internal r-j))
+                  (list
+                    public? define? override?
+                    export internal expr import
+                    a-j b-j r-j g-j)))
+              clauses)]
+          [_ (pretty-debug-object `(got clause-info))]
+
+
+          ;; Ok, we have the full environment
+          ;; Handle the argument list
+
+          [env (handle-paroptarglist env init-arglist tvar-args)]
+
+          ;; --- create constraints for each clause
+          [super-init-called #f]
+          [public-templates          '()]
+          [keyw-local-templates      '()]
+          [before-not-flow-templates '()]
+          [after-not-flow-templates  '()]
+
+          [extend-before-not-flow-templates!
+            (lambda (sym)
+              (set! before-not-flow-templates
+                (cons (get-ivar-template sym) 
+                  before-not-flow-templates)))]
+          [extend-after-not-flow-templates!
+            (lambda (sym)
+              (set! after-not-flow-templates
+                (cons (get-ivar-template sym) 
+                  after-not-flow-templates)))]
+
+          [_
+            (for-each
+              (match-lambda
+                [( public? define? override?
+                   export internal expr import
+                   a-j b-j r-j g-j)
+                  (pretty-debug-object
+                    `(clause (,public? ,define? ,override?)
+                       ,export ,internal ,expr ,import
+                       ,(map FlowType->pretty (list a-j b-j r-j g-j))))
+                  (new-edge! a-j b-j)
+                  (when public?
+                    (ivar-put this-u export tvar-undef)
+                    (ivar-put this-o export r-j)
+                    (ivar-get this-b export b-j)
+                    (ivar-get this-a export a-j)
+                    (ivar-get this-g export g-j)
+                    (ivar-put this-f export g-j)
+                    (set! public-templates
+                      (cons (get-ivar-template export) 
+                        public-templates)))
+                  (when (not public?)
+                    (new-edge! tvar-undef b-j)
+                    (new-edge! r-j a-j))
+                  (when (not define?)
+                    (ivar-get super-o import r-j))
+                  (when override?
+                    (extend-after-not-flow-templates! export)
+                    (if (and super-init-expr (not super-init-called))
+                      (begin
+                        ;; super-init will be called after this init
+                        (ivar-put super-b export a-j)
+                        (ivar-put super-a export a-j)
+                        (extend-before-not-flow-templates! export))
+                      (begin
+                        ;; super-init may be called before this init
+                        (ivar-put super-a export b-j))))
+                  (when (and public? (not override?))
+                    (when define?
+                      ;; Prev value hidden, but define super-b, super-a
+                      (ivar-put super-b export tvar-undef)
+                      (let ([t (mk-Tvar 't)])
+                        (ivar-get super-o export t)
+                        (ivar-put super-a export t))
+                      (extend-before-not-flow-templates! export)
+                      (extend-after-not-flow-templates! export)
+                      (set! keyw-local-templates
+                        (cons (get-ivar-template export) 
+                          keyw-local-templates))))
+                  (when define?
+                    (if (eq? expr super-init-expr)
+
+                      (let*-vals
+                        ([(ftype nu-env) (handle-application expr env #f)])
+                        (link-parsed-ftype! expr (wrap-value (mk-tvar-void)))
+                        (pretty-debug-object '(super-init called))
+                        (set! super-init-called #t)
+                        (set! env nu-env)
+                        (new-AV! r-j AV-void)
+
+                        ;; Update env that super-init called
+                        (for-each
+                          (match-lambda
+                            [( _ #f _ _ internal _ import a-j b-j r-j g-j)
+                              (set! env 
+                                (atenv:change-binding env internal a-j))]
+                            [_ (void)])
+                          clause-info))
+                                   
+                      (let*-vals 
+                        ( [(ftype nu-env) (traverse expr env)]
+                          [ftype (extract-1st-value ftype)])
+                        (pretty-debug-atenv 
+                          `(env-before-traverse ,(atenv->pretty env)))
+                        (set! env nu-env)
+                        (pretty-debug-atenv 
+                          `(env-after-traverse ,(atenv->pretty env)))
+                        (new-edge! (FlowType->Tvar ftype) r-j)
+                        (when internal
+                          (set! env
+                            (atenv:change-binding env internal a-j))))))
+
+                  (pretty-debug-atenv 
+                    `(end-clause ,(atenv->pretty env)))
+                  ])
+
+              clause-info)]
+          
+          ;; record ivarset
+          [public-ivars
+            (filter-map
+              (match-lambda
+                [( public? define? override?
+                   export internal expr import
+                   a-j b-j r-j g-j)
+                  (and public? export)])
+              clause-info)]
+          [_ (new-AV! this-v
+               (create-AV 
+                 template-ivarset public-ivars
+                 (vector super-v) mt-vector))]
+
+          [_ (begin
+               (new-con! super-o
+                 (create-con-filter
+                   (create-filter #f public-templates)
+                   this-o))
+               (new-con! super-f
+                 (create-con-filter
+                   (create-filter #f public-templates)
+                   this-f))
+               (new-con! this-b
+                 (create-con-filter
+                   (create-filter #f before-not-flow-templates)
+                   super-b))
+               (new-con! this-a
+                 (create-con-filter
+                   (create-filter #f after-not-flow-templates)
+                   super-a))
+               (new-con! this-g
+                 (create-con-filter
+                   (create-filter #f keyw-local-templates)
+                   super-g)))])
+
+        (pretty-debug-object `(keyw-local-templates ,keyw-local-templates))
+        (pretty-debug-object `(tvar-class ,(FlowType->pretty tvar-class)))
+
+        (atenv:flush! env)
+
+        (values (wrap-value tvar-class) captured-env))])))
+
+;; ----------------------------------------
+
+(define (map-clause fn clauses)
+  (apply append
+    (map
+      (match-lambda
+        [($ zodiac:public-clause exports internals exprs)
+          (map 
+            (lambda (export internal expr)
+              (fn #t #t #t (zodiac:read-object export) internal expr #f))
+            exports internals exprs)]
+        [($ zodiac:private-clause internals exprs)
+          (map 
+            (lambda (internal expr)
+              (fn #f #t #f   #f internal expr #f))
+            internals exprs)]
+        [($ zodiac:inherit-clause internals imports)
+          (map 
+            (lambda (internal import)
+              (fn #t #f #f   
+                (zodiac:read-object import) internal #f 
+                (zodiac:read-object import)))
+            internals imports)]
+        [($ zodiac:rename-clause internals imports)
+          (map 
+            (lambda (internal import)
+              (fn #f #f #f   #f internal #f (zodiac:read-object import)))
+            internals imports)]
+        [($ zodiac:sequence-clause exprs)
+          (map 
+            (lambda (expr)
+              (fn #f #t #f   #f #f expr #f))
+            exprs)])
+      clauses)))
+
+;; ----------------------------------------------------------------------
+
+(define (handle-struct-form tag const atstruct fields)
+  (match atstruct
+    [($ atstruct 
+        parent-struct:sym
+        super-constructors 
+        parent-gen-args
+        parent-match-args
+        parent-field-types
+        parent-list-mutable)
+     (match-let*
+         ([constructor (symbol-append 'structure: tag)]
+          [gen-args (map (lambda (_) (gensym)) fields)]
+          [match-args 
+           (map (lambda (field gen-arg)
+                  (match field
+                    [((or '! ':) _ type) `(intersect ,gen-arg ,type)]
+                    [_ gen-arg]))
+                fields gen-args)]
+          [field-names
+           (map (lambda (field)
+                  (match field
+                    [((or ': '!) (? symbol? name) _) name]
+                    [(? symbol? name) name]
+                    [_ (mrspidey:error
+                        (format "Bad define-typed-structure field ~s" 
+                                field))]))
+                fields)]
+          [list-mutable
+           (map (lambda (field)
+                  (match field
+                    [('! (? symbol? name)) #t]
+                    [_ (not const)]))
+                fields)]
+          [field-types 
+           (map 
+            (match-lambda [((or '! ':) _ type) (expand-input-type type)]
+                          [_ 'top])
+            fields)]
+
+          [all-gen-args (append parent-gen-args gen-args)]
+          [all-match-args (append parent-match-args match-args)]
+          [all-field-types (append parent-field-types field-types)]
+          [all-list-mutable (append parent-list-mutable list-mutable)]
+          [_-parent-args (map (lambda (_) '_) parent-gen-args)]
+
+          [gen-arg (gensym)]
+          [defs `()]
+          [add-def! 
+           (lambda (fo-Atype)
+             (set! defs (cons (create-fo-FlowType fo-Atype) defs)))]
+          [add! 
+           (lambda (type . attrs)
+             (add-def! 
+              (apply primitive->atprim 'define-struct type attrs)))])
+
+       ;; (pretty-print match-args)
+       ;; (pretty-print gen-args)
+
+       (add-def! (make-atstruct
+                  (symbol-append 'struct: tag)
+                  (cons constructor super-constructors)
+                  all-gen-args all-match-args
+                  all-field-types all-list-mutable))
+    
+       (let ([template 
+               (apply constructor->template constructor all-list-mutable)])
+         (for-each 
+           (lambda (sc) (record-super-constructor-of-template! sc template))
+           super-constructors)
+         (extend-constructor-env! template))
+
+       (add! 
+        `(forall ,all-gen-args 
+                 (,@all-match-args -> (,constructor ,@all-gen-args))))
+       (add! `(_ -> bool) `(predicate ,constructor))
+       (for n 0 (length fields)
+            (let* ([gen-arg (list-ref gen-args n)]
+                   [field-name (list-ref field-names n)])
+              (add!
+               `(forall (,gen-arg)
+                        ((,constructor ,@_-parent-args
+                                       ,@(map-with-n
+                                          (lambda (field m) 
+                                            (if (= n m) gen-arg '_))
+                                          fields))
+                         -> ,gen-arg)))
+              (when (list-ref list-mutable n)
+                (add! `(forall (,gen-arg)
+                               ((,constructor ,@_-parent-args
+                                              ,@(map-with-n
+                                                 (lambda (field m)
+                                                   (if (= n m)
+                                                       `(! ,gen-arg)
+                                                       '_))
+                                                 fields))
+                                ,(list-ref match-args n)
+                                -> void))))))
+
+       (create-fo-FlowType (make-atvalues (reverse defs))))]))
+
+;; ======================================================================
+
+(define (zodiac:parsed-1st-ftype exp)
+  (extract-1st-value (zodiac:parsed-ftype exp)))
+
+;; ----------
+
+(define (if-splitting-env test env)
+  ;; Returns (env-true env-false)
+  ;; Assumes test expression already traversed
+  ;; Can't lookup things in env, cause not defined for imported vars
+  (match test
+    ;; arg
+    [($ zodiac:varref _ _ _ _ sym)
+      (let ([arg (zodiac:varref-binding  test)])
+        (match (zodiac:parsed-1st-ftype test)
+          [(? Tvar? tvar)
+            (let* ([tvar-then (mk-Tvar sym)]
+                    [tvar-else (mk-Tvar sym)]
+                    [templates (list (lookup-template 'false))])
+              (new-con! tvar
+                (create-con-filter (create-filter #f templates) tvar-then))
+              (new-con! tvar
+                (create-con-filter (create-filter #t templates) tvar-else))
+              (values (atenv:change-binding env arg tvar-then)
+                (atenv:change-binding env arg tvar-else)))]
+          ;; Annotated type so don't change
+          [_ (values env env)]))]
+        
+    ;; (not (pred? args ...))
+    [($ zodiac:app _ _ _ _ fn (pred-exp))
+     (=> fail)
+     (match (zodiac:parsed-atprim fn)
+       [($ atprim 'not)
+         ;; Use recursive call and reverse
+         (let-values
+             ([(env-true env-false) (if-splitting-env pred-exp env)])
+             (values env-false env-true))]
+       [_ (fail)])]
+
+    ;; (pred? args ...)
+    [($ zodiac:app _ _ _ _ fn args)
+     (=> fail)
+     (match (zodiac:parsed-atprim fn)
+       [($ atprim _ type _ predicate-fn)
+        ;;(pretty-print `(if (pred ,sym ,type ,predicate-fn ...)))
+        (recur loop ([args-before '()]
+                     [args args]
+                     [env-true env]
+                     [env-false env])
+          (match args
+            [() (values env-true env-false)]
+            [((and arg ($ zodiac:varref)) . rest-args)
+              (=> fail)
+              (let ([barg (zodiac:varref-binding arg)])
+                (match (zodiac:parsed-1st-ftype arg)
+                  [(? fo-FlowType?) (fail)]
+                  [(? Tvar? tvar)
+                    (let*
+                      ( [tvars-before (map zodiac:parsed-1st-ftype args-before)]
+                        [tvars-after (map zodiac:parsed-1st-ftype rest-args)]
+                        [tvar-true 
+                          (predicate-fn tvars-before tvars-after tvar #t)]
+                        [tvar-false
+                          (predicate-fn tvars-before tvars-after tvar #f)])
+                      ;;(pretty-print-debug (list tvar-true tvar-false))
+                      (loop (append args-before (list arg))
+                        rest-args
+                        (if tvar-true
+                          (atenv:change-binding env-true barg tvar-true)
+                          env-true)
+                        (if tvar-false
+                          (atenv:change-binding env-false barg tvar-false)
+                          env-false)))]))]
+            [(arg . rest-args)
+             (loop (append args-before (list arg))
+                   rest-args env-true env-false)]))]
+       [_
+        ;; Not a primitive
+        (fail)])]
+
+    [_ (values env env)]))
+
+;; ----------------------------------------------------------------------
+
+(define (flow-sensitive-env pi args env)
+  (match pi
+    [($ atprim _ _ domain-filters)
+     ;; Walk domain-filters and args
+     (recur loop 
+         ([env env]
+          [args args]
+          [domain-filters domain-filters])
+       (match (list args domain-filters)
+         [( ((and arg ($ zodiac:varref _ _ _ _ arg-sym))
+              . args-rest)
+            ((? filter? filter) . filters-rest))
+           (=> fail)
+           (let ([barg (zodiac:varref-binding arg)])
+             (match (FlowType->Tvar (zodiac:parsed-1st-ftype arg))
+               [(? fo-FlowType?)
+                 ;; Assigned, so don't track
+                 (fail)]
+               [(? Tvar? tvar)
+                 ;; Have arg and domain
+                 (let ([nu-tvar (mk-Tvar arg-sym)])
+                   (new-con! tvar (create-con-filter filter nu-tvar))
+                   (loop (atenv:change-binding env barg nu-tvar) 
+                     args-rest filters-rest))]))]
+             
+          [( (_ . args-rest) (_ . filters-rest))
+           (loop env args-rest filters-rest)]
+             
+          [_ env]))]
+     [#f env]))
+
+;; ======================================================================
+;; Constants -> constraints
+;; All fns return Tvar
+
+(define (traverse-const V)
+  ;;(set! gV V)
+  ;;(pretty-print (zodiac:stripper V))
+  ;; Returns nothing
+  (let ([s (zodiac:const-size V)])
+    (if (>= s (st:const-merge-size))
+        (traverse-consts-tidy (list V))
+        (let ([Tvar (mk-Tvar 'traverse-const)])
+          (new-AV! Tvar (traverse-const-exact V))
+          Tvar))))
+
+(define traverse-consts-tidy
+  ;; Takes a list of constants
+  ;; Returns a Tvar
+  (lambda (V*)
+    (match-let*
+      ( [Tvar (mk-Tvar 'traverse-consts-tidy)]
+        [vec-elems
+          (apply append
+            (map
+              (match-lambda
+                [($ zodiac:vector _ _ _ v) v]
+                [(? vector? v) (vector->list v)]
+                [_ '()])
+              V*))]
+        [elems.cdr*
+          (filter-map
+            (match-lambda
+              [(or ($ zodiac:list _ _ _ l)
+                 (? pair? l)
+                 (? null? l))
+                (recur loop ([l l][elems '()])
+                  (cond
+                    [(pair? l) (loop (cdr l) (cons (car l) elems))]
+                    [else (cons elems l)]))]
+              [($ zodiac:improper-list _ _ _ l)
+                (recur loop ([l l][elems '()])
+                  (cond
+                    [(and (pair? l) (null? (cdr l)))
+                      (cons elems (car l))]
+                    [(pair? l)
+                      (loop (cdr l) (cons (car l) elems))]
+                    [else (cons elems l)]))]
+              [_ #f])
+            V*)]
+        [elems (apply append (map car elems.cdr*))]
+        [cdrs (map cdr elems.cdr*)])
+
+      (unless (null? vec-elems)
+        (new-AV! Tvar
+          (make-AV-vec (traverse-consts-tidy vec-elems))))
+      (unless (null? elems)
+        (let* ([tvar-a (traverse-consts-tidy elems)]
+                [tvar-d (traverse-consts-tidy cdrs)]
+                [AV (make-AV-cons tvar-a tvar-d)])
+          (new-AV! tvar-d AV)
+          (new-AV! Tvar AV)))
+      
+      (for-each
+        (lambda (V)
+          (let ([x (traverse-simple-const V)])
+            (when x (new-AV! Tvar x))))
+        V*)
+
+      Tvar)))
+
+;; ======================================================================
+
diff --git a/collects/mrspidey/Sba/type-con.ss b/collects/mrspidey/Sba/type-con.ss
new file mode 100644
index 0000000..0d761fe
--- /dev/null
+++ b/collects/mrspidey/Sba/type-con.ss
@@ -0,0 +1,419 @@
+;; type-con.ss
+;; 
+;; Parses a type to produce a set of constraints
+;; Also tests an AVS for membership in a type
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+(define typevar?
+  (lambda (v)
+    (and (symbol? v)
+         (not (type-constructor? v))
+         (not (memq v '(_ union rec ->*))))))
+
+(define (compat-type-once type cl-fn)
+  (match type
+    [(and c (or (? number?) (? char?) ('quote (? symbol?)))) c]
+    [('rec bind t2)
+     `(rec ,(map (match-lambda [(a t) (list a (cl-fn t))]) bind) 
+           ,(cl-fn t2))]
+    [('forall vars type)
+     `(forall ,vars ,(cl-fn type))]
+    [('case-> . (and types (? list?) (_ . _))) 
+     `(case-> ,@(map cl-fn types))]
+    [('union . (? list? union)) `(union ,@(map cl-fn union))]
+    [(? symbol? a) a]
+    [(arg '->* res) (list (cl-fn arg) '->* (cl-fn res))]
+    ;; check constructors
+    [((? type-constructor? C) . args)
+     `(,C ,@(map (match-lambda
+                  [('! arg) (list '! (cl-fn arg))]
+                  [arg (cl-fn arg)])
+                 args))]
+    [_ #f]))
+
+(define (expand-input-type type)
+  ;; Do rewriting transformations
+  ;;(pretty-print `(expand-type ,type))
+  (let ([t2 (input-type-expander type)])
+    (if (eq? type t2)
+        (or (compat-type-once type expand-input-type)
+            (mrspidey:error 
+             (format "Bad input type ~s" type)))
+        (expand-input-type t2))))
+
+(define (expand-output-type type)
+  ;; Do rewriting transformations
+  ;;(pretty-print `(expand-type ,type))
+  (let* ([type (or (compat-type-once type expand-output-type)
+                   type
+                   (mrspidey:error (format "Bad output type ~s" type)))])
+    (recur fn ([type type])
+      (let ([t2 (output-type-expander type)])
+        (if (eq? type t2)
+            type 
+            (fn t2))))))
+
+;; ----------------------------------------------------------------------
+
+(define (con-exp->templates con-exp)
+  ;; Assumes con-exp already expanded
+  (match con-exp
+    [('union . E*)
+     (let ([T* (map con-exp->templates E*)])
+       (and (andmap (lambda (x) x) T*)
+            (apply append T*)))]
+    [('forall _ type) (con-exp->templates type)]
+    [(_ '->* _) (list template-lam)]
+    [(or (C . _) C)
+     (if (type-constructor? C)
+         (list (lookup-template C))
+         #f)]))
+
+;; ----------------------------------------------------------------------
+
+(define (generic-type->con type prefix forall-env sign)
+  ;; Assumes type->con is already expanded
+  (letrec
+      ([mk-AVS-tmp (lambda () (mk-AVS (symbol-append prefix ':tc)))]
+       [parse-type-generic
+        (lambda (t env sign)
+          ;; sign is #t for +ive, #f for -ive
+          (let ([new-sign-edge!
+                 (lambda (from to)
+                   (if sign
+                       (new-edge! from to)
+                       (new-edge! to from)))]
+                [parse-type 
+                 (lambda (t) 
+                   (parse-type-generic t env sign))])
+            (match t
+
+              ;; Recursive definitions
+              [('rec bind t2)
+               (let* ([a* (map car bind)]
+                      [AVS* (map 
+                             (lambda (a) 
+                               (mk-AVS (symbol-append prefix ': a)))
+                             a*)]
+                      [env  (extend-env* env a* AVS*)])
+                 (for-each
+                  (match-lambda
+                   [(a t)
+                    (new-sign-edge! (parse-type-generic t env sign)
+                                    (lookup env a))])
+                  bind)
+                 (parse-type-generic t2 env sign))]
+
+              ;; Unions
+              [('union . (? list? union))
+               (let ([AVS (mk-AVS-tmp)])
+                 (for-each
+                  (lambda (t)
+                    (new-sign-edge! (parse-type-generic t env sign)
+                                    AVS))
+                  union)
+                 AVS)]
+
+              ;; case->
+              [('case-> . (? list? types)) 
+               (parse-type-generic (rac types) env sign)]
+
+              ;; type variables
+              ['_ (mk-AVS-tmp)]
+              [(? symbol? a)
+               (lookup-or-fail 
+                env a
+                (lambda () 
+                  (lookup-or-fail
+                   forall-env a
+                   (lambda ()
+                     ;; reference type named a
+                     ;; if sign +ive, use this type
+                     ;; if sign -ive, return dummy AVS
+                     (let ([AVS (mk-AVS (symbol-append prefix ': a))])
+                       (set! global-in-type-env 
+                           (cons (list a AVS (box #f)) global-in-type-env))
+                       (if sign
+                           AVS
+                           (mk-AVS (symbol-append prefix ': a))))))))]
+
+              [(arg '->* res)
+               (let ([AVS (mk-AVS-tmp)])
+                 (if sign
+                     ;; make the AV
+                     (new-AV! AVS
+                              (make-AV-lam 
+                               (parse-type-generic arg env #f)
+                               (parse-type-generic res env #t)
+                               0 #t))
+                     ;; extract the various components
+                     (begin
+                       (new-con! AVS 
+                                 (create-con 
+                                  template-lam 0 
+                                  (parse-type-generic arg env #t)))
+                       (new-con! AVS 
+                                 (create-con
+                                  template-lam 1 
+                                  (parse-type-generic res env #f)))))
+                 AVS)]
+
+              ;; constants
+              [(or (? number? c) (? char? c) ('quote (? symbol? c)))
+               (let ([AVS (mk-AVS-tmp)])
+                 (if sign (new-AV! AVS (traverse-const c)))
+                 AVS)]
+
+              ;; check constructors
+              [((? type-constructor? C) . args)
+               (match-let*
+                   ([(and template ($ template type signs ref assign))
+                     (lookup-template C)]
+                    [AVS (mk-AVS-tmp)])
+                 (unless (= (vector-length ref) (length args))
+                   (mrspidey:error
+                    (format "Constructor ~s given ~s arg(s), expected ~s" 
+                            C (length args) (vector-length ref))))
+                 (if sign
+                     ;; make the AV, unless void and (st:see-void) is false
+                     (unless (and (eq? C 'void) (not (st:see-void)))
+                       (new-AV! 
+                        AVS
+                        (apply
+                         make-constructed-AV C 
+                         (map 
+                          (lambda (a)
+                            (parse-type-generic a env sign)) 
+                          args)
+                         ;; DO SOMETHING FOR NULL ARGS
+                         )))
+
+                     ;; extract the various components
+                     ;; need to do unification on mutable fields,
+                     ;; unless pattern matching arg is (! a)
+                     (for-each-with-n
+                      (lambda (arg n)
+                        (match arg
+                          ['_ (void)]
+                          [('! a)
+                           (unless (vector-ref assign n)
+                             (mrspidey:error
+                              "! used on immutable field in type"))
+                           ;; Inject only
+                           (new-con!
+                            AVS
+                            (create-con template (vector-ref assign n)
+                                        (parse-type-generic a env #t)))]
+                          [arg
+                           ;; Extract 
+                           (new-con!
+                            AVS
+                            (create-con template (vector-ref ref n)
+                                        (parse-type-generic arg env #f)))]))
+                      args))
+                 AVS)]
+              [_
+               ;; Didn't match any type
+               (mrspidey:error (format "invalid type syntax ~s" t))])))])
+
+    (let ([AVS (parse-type-generic type empty-env sign)])
+      AVS)))
+
+;; ----------------------------------------------------------------------
+
+(define (type->con type AVS prefix top-misc)
+  ;; Assumes type is already expanded
+  (new-edge! (generic-type->con type prefix empty-env #t) AVS)
+
+  ;; Put top-misc in misc field of each AV
+  (for-each
+   (lambda (AV) (set-AV-misc! AV top-misc))
+   (get-AVS-objs AVS)))
+
+;; ----------------------------------------------------------------------
+
+(define (split-schema type)
+  (match type
+    [('forall vars type)
+     (list
+      (map (lambda (v) (cons v (mk-AVS-tmp v))) vars)
+      type)]
+    [type (list '() type)]))
+
+(define (type-schema->con type AVS prefix top-misc)
+  ;; Assumes type is already expanded
+  (match-let ([(forall-env type) (split-schema type)])
+    (new-edge! (generic-type->con type prefix forall-env #t) AVS)
+
+    ;; Put top-misc in misc field of each AV
+    (for-each
+     (lambda (AV) (set-AV-misc! AV top-misc))
+     (get-AVS-objs AVS))))
+
+;; ----------------------------------------------------------------------
+
+(define (type-schema->con-for-nargs type prefix n)
+  ;; Assumes type is already expanded
+  ;; Puts top-misc in misc field of top AV
+  ;; returns ((AVS-para ...) . AVS-result) if possible
+  ;; otherwise returns #f
+
+  (match-let ([(forall-env type) (split-schema type)])
+    (match (dom+rng-for-nargs type n)
+      [#f #f]
+      [(forall-env para* rng)
+       (recur loop ([para* para*]
+                    [AVS-para* '()])
+         (match para*
+           [()
+            (cons (reverse AVS-para*) 
+                  (generic-type->con rng prefix forall-env #t))]
+           [(para . rest)
+            (let* ([AVS-para (generic-type->con para prefix forall-env #f)])
+              (loop rest (cons AVS-para AVS-para*)))]))])))
+
+;; ----------------------------------------------------------------------
+
+(define (dom+rng-for-nargs type nargs)
+  ;; extracts appropriate type from top-level case->.
+  ;; returns (forall-env (para ...) result) if matching case
+  ;; o/w returns #f
+
+  (let* ([try1 
+          (lambda (type forall)
+            ;; See if type has the right # args
+            (match type
+              [(dom '->* rng)
+               (recur loop ([dom dom][para* '()][n nargs])
+                 (match dom
+                   [('nil) 
+                    (if (zero? n)
+                        (list (map (lambda (v) (cons v (mk-AVS-tmp 'dr)))
+                                   forall)
+                              (reverse para*)
+                              rng)
+                        #f)]
+                   [('cons para rest) (loop rest (cons para para*) (sub1 n))]
+                   [_ #f]))])
+            [_ #f])]
+         [try2
+          (lambda (type forall)
+            (match type
+              [('case-> . types)
+               (ormap (lambda (t) (try1 t forall)) types)]
+              [type (try1 type forall)]))])
+    (match type
+      [('forall vars type) (try2 type vars)]
+      [type (try2 type '())])))
+
+;; ----------------------------------------------------------------------
+
+(define AVS-in-type?
+  (lambda (AVS type)
+    ;; Checks if AVS is contained in the type
+    ;; Assumes type is already expanded
+    
+    (letrec
+        ([visit-alloc (lambda () (make-vector num-AV #f))]
+         [add-visit! 
+          (lambda (v AV)
+            (vector-set! v (AV-num AV) #t))]
+         [visited?
+          (lambda (v AV) 
+            (vector-ref v (AV-num AV)))]
+         [AVS-in-type?
+          (lambda (AVS type env)
+            ;; env maps type vars to AV-membership test function
+            (andmap (lambda (AV) (AV-in-type? AV type env))
+                    (get-AVS-objs AVS)))]
+         [AV-in-type?
+          (lambda (AV type env)
+            ;; env maps type vars to AV-membership test function
+            (match type
+
+              ;; Recursive definitions
+              [('rec bind t2)
+               (let* 
+                   ([a* (map car bind)]
+                    [t* (map cadr bind)]
+                    [envbox (box #f)]
+                    [nuenv
+                     (extend-env*
+                      env a*
+                      (map (lambda (t)
+                             (let ([v (visit-alloc)])
+                               (lambda (AV)
+                                 (or (visited? v AV)
+                                     (begin
+                                       (add-visit! v AV)
+                                       (AV-in-type? AV t (unbox envbox)))))))
+                           t*))])
+                 (set-box! envbox nuenv)
+                 (AV-in-type? AV t2 nuenv))]
+
+              [('case-> . types) (AV-in-type? AV (rac types) env)]
+
+              [('union . (? list? union))
+               (ormap (lambda (type) (AV-in-type? AV type env))
+                      union)]
+              ['_ #t]
+              [(? symbol? a) 
+               ((lookup-or-fail env a (lambda () (lambda (AV) #t)))
+                AV)]
+              [(arg '->* res) (eq? (AV-template AV) template-lam)]
+
+              [(? number? n)
+               (and (eq? (template-type (AV-template AV)) 'num)
+                    (= (AV-misc AV) n))]
+              [(? char? c)
+               (and (eq? (template-type (AV-template AV)) 'char)
+                    (char=? (AV-misc AV) c))]
+              [('quote (? symbol? s))
+               (and (eq? (template-type (AV-template AV)) 'sym)
+                    (eq? (AV-misc AV) s))]
+
+              [((? type-constructor? C) . args)
+               (match-let 
+                   ([(and template ($ template type signs ref assign))
+                     (lookup-template C)])
+                 (cond
+                  [(eq? (AV-template AV) template)
+                   (recur loop ([args args][n 0])
+                     (if (null? args)
+                         #t
+                         (and 
+                          (AVS-in-type? 
+                           (vector-ref (AV-fields AV) (vector-ref ref n))
+                           (match args
+                             [(('! a) . _) a]
+                             [(a . _) a])
+                           env)
+                          (loop (cdr args) (add1 n)))))]
+                  [(memq (AV-template AV) (template-sub-templates template))
+                   #t]
+                  [else #f]))]
+              [_ 
+               ;; Didn't match any type
+               (mrspidey:error (format "Invalid type syntax ~s" type))]))])
+      (AVS-in-type? AVS type empty-env))))
+
+;(trace AVS-in-type?)
+
+
+
diff --git a/collects/mrspidey/Sba/type-env.ss b/collects/mrspidey/Sba/type-env.ss
new file mode 100644
index 0000000..afb6232
--- /dev/null
+++ b/collects/mrspidey/Sba/type-env.ss
@@ -0,0 +1,116 @@
+;; type-env.ss
+;; Handles the type environment (env for type inference)
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; ----------------------------------------------------------------------
+
+;; ======================================================================
+;; Global type env
+
+(define global-tref-env '())
+(define global-tdef-env '())
+(define global-tbang-env '())
+
+(define (add-global-tref! sym tvar)
+  (set! global-tref-env (cons (cons sym tvar) global-tref-env)))
+(define (add-global-tdef! sym tvar)
+  (set! global-tdef-env (cons (cons sym tvar) global-tdef-env)))
+(define (add-global-tbang! sym tvar)
+  (set! global-tbang-env (cons (cons sym tvar) global-tbang-env)))
+(define (init-global-tenv! r d b)
+  (set! global-tref-env r)
+  (set! global-tdef-env d)
+  (set! global-tbang-env b))
+
+;; ----------------------------------------------------------------------
+;; find-matching-def
+
+(define (find-matching-def sym defs)
+  (ormap (match-lambda
+          [(sym2 . def) (and (eq? sym sym2) def)])
+         defs))
+
+;; ----------------------------------------------------------------------
+;; report-duplicate-defs
+;; Report duplicate definitions
+
+(define (report-duplicate-defs env)
+  (pretty-debug `(report-duplicate-defs ,@(map car env)))
+  (recur loop ([env env][dupls '()])
+    (match env
+      [() (void)]
+      [((sym1 . _) . rest)
+       (if (and (find-matching-def sym1 rest)
+                (not (memq sym1 dupls)))
+           (begin
+             (mrspidey:warning
+              (format "Duplicate definition of variable ~s" sym1))
+             (loop rest (cons sym1 dupls)))
+           (loop rest dupls))])))
+
+;;----------------------------------------------------------------------
+;; report-unbound-vars-env
+
+(define report-unbound-vars
+  (case-lambda
+   [(ref-env) (report-unbound-vars ref-env "")]
+   [(ref-env msg)
+    (for-each
+     (match-lambda
+      [(sym . _) 
+        (mrspidey:warning (format "Unbound type variable ~s~a" sym msg))])
+     ref-env)]))
+
+;; ----------------------------------------------------------------------
+;; connect-refs-defs
+;; Connects refs to defs, returns list of unbound refs
+
+(define (connect-refs-defs ref-env def-env)
+  (pretty-debug
+   `(connect-refs-defs ,(map car ref-env) ,(map car def-env)))
+  (filter
+   (match-lambda
+    [(and r (sym . tvar))
+     (match (find-matching-def sym def-env)
+       [#f #t]
+       [ftype
+         (new-edge! (FlowType->Tvar ftype) tvar)
+        #f])])
+   ref-env))
+
+;; ----------------------------------------------------------------------
+;; combine-def-bang
+;; Connects each bang to def, and reports bangs to undefd vars
+
+(define (connect-bangs-defs bang-env def-env)
+  (pretty-debug 
+   `(connect-bangs-defs ,(map car bang-env) ,(map car def-env)))
+  (for-each
+   (match-lambda
+    [(s2 . tvar2)
+     (match (find-matching-def s2 def-env)
+       [#f (mrspidey:warning
+            (format "Assignment to undefined variable ~s" s2))]
+       [tvar1
+         (unless (Tvar? tvar1) 
+           (mrspidey:error "Assignment to annotated type"))
+         (assert (Tvar? tvar2))
+         (new-edge! tvar2 tvar1)])])
+   bang-env))
+
+
+
diff --git a/collects/mrspidey/Sba/typelang.ss b/collects/mrspidey/Sba/typelang.ss
new file mode 100644
index 0000000..68837bc
--- /dev/null
+++ b/collects/mrspidey/Sba/typelang.ss
@@ -0,0 +1,878 @@
+;; typelang.ss
+;; Parses a type to produce a set of constraints
+;; Also tests an Tvar for membership in a type
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+;; type ::= ...
+;; schema ::= type | (forall vars type)
+;; tschema ::= schema | (case-> schema ...) 
+;; lambda types are
+;;      (a b c -> d e f)
+;;      (a b c rest *-> d e f)
+;;      (a b c ->* results)
+;;      (a b c rest *->* results)
+;;      (lambda domain range)
+;; ======================================================================
+; Union, Intersect etc
+
+(define absUnion
+  (lambda (exps)
+    (match 
+        (apply append
+               (map
+                (match-lambda
+                 ['empty '()]
+                 [('union . exps) exps]
+                 [exp (list exp)])
+                ;;(list->set-equal? exps)
+                exps
+                ))
+      [() 'empty]
+      [(e) e]
+      [exps `(union ,@exps)])))
+
+(define absunion (lambda exps (absUnion exps)))
+
+(define absIntersect
+  (lambda (exps)
+    (match 
+        (apply append
+               (map
+                (match-lambda
+                 ['_ '()]
+                 [('intersect . exps) exps]
+                 [exp (list exp)])
+                (list->set-equal? exps)))
+      [() '_]
+      [(e) e]
+      [exps `(intersect ,@exps)])))
+
+(define absintersect (lambda exps (absIntersect exps)))
+
+;; ======================================================================
+
+(define (output-type-constructor? C)
+  (or
+    (memq C '(bool listof list atom sexp values))
+    (type-constructor? C)))
+
+(define (output-type-expander type)
+  (all-output-type-expanders
+    (or
+      (compat-type-once type output-type-expander)
+      type)))
+
+;---
+(define output-type-expanders '())
+
+(define (all-output-type-expanders type)
+  (foldl
+    (lambda (expander type) (expander type))
+    type
+    output-type-expanders))
+
+;---
+
+(define (install-output-type-expander! expander)
+  (set! output-type-expanders (cons expander output-type-expanders)))
+
+(define (init-output-type-expander!)
+  
+  (install-output-type-expander!
+    (match-lambda 
+      [((? output-type-constructor? C)) C]
+      [('cons t 'nil) `(list ,t)]
+      [('cons t ('list . t*)) `(list ,t ,@t*)]
+      [('lambda dom rng) (list dom '*->* rng)]
+      [('unit-result* ('values rng)) `(unit-result ,rng)]
+      [('union X) X]
+      [(? list? t)
+        (=> fail)
+        (match (reverse t)
+          [( ('values x) 
+             (and arrow (or '*->* '->*))
+             . domains)
+            (append (reverse domains) 
+              (list (case arrow
+                      [(*->*) '*->]
+                      [(->*) '->])
+                x))]
+          [_ (fail)])]
+      [(('list . args) '*-> . results) `(,@args -> . ,results)]
+      [(('list . args) '*->* . results) `(,@args ->* . ,results)]
+      [('union . X)
+        (=> fail)
+        (cond
+          [(and (memq 'true X) (memq 'false X))
+            `(union bool ,@(remq 'true (remq 'false X)))]
+          [(and (memq 'bool X)
+             (or (memq 'true X) (memq 'false X)))
+            `(union ,@(remq 'true (remq 'false X)))]
+          [else (fail)])]
+      [(or ('union 'true 'false) ('union 'false 'true)) 'bool]
+      
+      [('mvalues ('list . x)) `(values ,@x)]
+      [('rec () body) body]
+      [(or 
+         ('union 'nil ('cons X ('listof Y)))
+         ('union ('cons X ('listof Y)) 'nil))
+        (=> fail)
+        (if (equal? X Y) `(listof ,Y) (fail))]
+      [('epsilon X) X]
+      [((and combine (or 'union 'intersect)) . parts)
+        (=> fail)
+        (if (not (st:sdl-tidy))
+          (fail)
+          (let ([combine-fn (case combine
+                              [(intersect) absintersect]
+                              [(union) absunion])])
+            (pretty-debug-sdl `(combine ,combine parts ,parts))
+            (apply combine-fn
+              (recur loop ([parts parts])
+                (match parts
+                  [(a . d)
+                    (let ([d (loop d)])
+                      (if (member a d)
+                        d
+                        (match a
+                          [((? output-type-constructor? C) . C-args)
+                            (let*-vals
+                              ( [len-C-args (length C-args)]
+                                [(args* rest)
+                                 (filter-map-split
+                                   (match-lambda
+                                     [(C2 . args)
+                                       (and 
+                                         (eq? C C2)
+                                         (= len-C-args (length args))
+                                         args)]
+                                     [_ #f])
+                                   parts)])
+                              (pretty-debug-sdl `(args* ,args* rest ,rest))
+                              (if (null? (cdr args*))
+                                (cons a d)
+                                (cons (cons C (apply map
+                                                combine-fn
+                                                args*)) 
+                                  rest)))]
+                          [_ (cons a d)])))]
+                  [() '()])))))]
+      [type type]))
+  )
+
+
+
+;; ======================================================================
+;; For input-type-expander, recursion is done in expand-input-type
+
+(define input-type-expander 'input-type-expander)
+
+(define (init-input-type-expander!)
+  (set! input-type-expander (lambda (x) x))
+  (let ([loop (lambda (x) x)])
+    (install-input-type-expander!
+      (match-lambda
+        ['atom      (loop '(union nil num sym str char true false))]
+        ['sexp      (let ([u (gensym)])
+                      (loop `(MU ,u (union atom (box ,u) (cons ,u ,u) (vec ,u)))))]
+        ['bool      (loop '(union false true))]
+        [('arg a b) (loop (list 'cons a b))]
+        ['noarg     (loop 'nil)]
+        ['null      (loop 'nil)]
+        [('arglistof t)
+          (let ((u (gensym)))
+            (loop `(MU ,u (union noarg (arg ,t ,u)))))]
+        [('arglist) (loop 'noarg)]
+        [('arglist t . t*) (loop `(arg ,t (list ,@t*)))]
+        [('listof t)
+          (let ((u (gensym)))
+            (loop `(MU ,u (union nil (cons ,t ,u)))))]
+        [('list) (loop 'nil)]
+        [('list t . t*) (loop `(cons ,t (list ,@t*)))]
+
+        [('MU (? typevar? a) t)
+          (loop `(rec ([,a ,t]) ,a))]
+        [(? type-constructor? C) (loop (list C))]
+        [(? (lambda (t) (and (list? t) (memq '-> t)))
+           t)
+          ;; Make the *-> function
+          (recur loop2 ([wrapper-fn (lambda (x) x)]
+                         [t t])
+            (match t
+              [('-> . results)
+                (loop `(,(wrapper-fn 'noarg) *-> ,@results))]
+              [('optional y . rest)
+                (loop2 (lambda (x) (wrapper-fn `(union noarg (arg ,y ,x))))
+                  rest)]
+              [(y . rest)
+                (loop2 (lambda (x) (wrapper-fn `(arg ,y ,x)))
+                  rest)]))]
+        [(? (lambda (t) (and (list? t) (memq '*-> t)))
+           t)
+          ;; Make the *->* function
+          (recur loop2 ( [wrapper-fn (lambda (x) x)]
+                         [t t])
+            (match t
+              [('*-> . _) (mrspidey:error "*-> type w/o domain")]
+              [(rest '*-> . results)
+                (loop `(,(wrapper-fn rest) 
+                         *->*
+                         (mvalues
+                           ,(foldr (lambda (arg rest) `(cons ,arg ,rest))
+                              '(nil)
+                              results))))]
+              [(y . rest)
+                (loop2 (lambda (x) (wrapper-fn `(arg ,y ,x)))
+                  rest)]))]
+        [(? (lambda (t) (and (list? t) (memq '->* t))) t)
+          (match (reverse t)
+            [(result '->* . domain)
+              `( (list ,@(reverse domain)) *->* ,result)]
+            [_ (mrspidey:error "Bad type ~s" t)])]
+        [(dom '*->* rng) (loop `(lambda ,dom ,rng))]
+        [type type]))))
+
+(define (install-input-type-expander! expander)
+  (let ([old-expander input-type-expander])
+    (set! input-type-expander
+        (lambda (type) 
+          ;;(pretty-print-debug `(input-type-expander ,type))
+          (old-expander (expander type))))))
+
+;; ======================================================================
+
+(define typevar?
+  (lambda (v)
+    (and (symbol? v)
+         (not (output-type-constructor? v))
+         (not (memq v '(_ union rec -> *-> ->* *->*))))))
+
+(define (compat-type-once type cl-fn)
+  (match type
+    [(and c (or (? number?) (? char?) ((or 'quote '#%quote) (? symbol?)))) c]
+    [('rec bind t2)
+      `(rec ,(map (match-lambda [(a t) (list a (cl-fn t))]) bind) 
+         ,(cl-fn t2))]
+    [('forall vars type)
+      `(forall ,vars ,(cl-fn type))]
+    [('case-> . (and types (? list?) (_ . _))) 
+      `(case-> ,@(map cl-fn types))]
+    [('union . (? list? union)) `(union ,@(map cl-fn union))]
+    [('scheme: E) type]
+    [('intersect . (? list? union)) `(intersect ,@(map cl-fn union))]
+    [(? symbol? a) a]
+    [((? (lambda (t) (memq t '(object class))) t) . ivar-types)
+      (cons t
+        (map
+          (match-lambda
+            [(ivar type) (list ivar (cl-fn type))])
+          ivar-types))]
+    ;; check constructors
+    [((? output-type-constructor? C)  . args)
+      `(,C ,@(map (match-lambda
+                    [('! arg) (list '! (cl-fn arg))]
+                    [arg (cl-fn arg)])
+               args))]
+    [(? (lambda (t) 
+          (and (list? t)
+            (or (memq '-> t) (memq '*-> t) (memq '->* t) (memq '*->* t)))) 
+       t)
+      (map cl-fn t)]
+    [_ #f]))
+
+(define (expand-input-type type)
+  ;; Do rewriting transformations
+  ;; (pretty-print-debug `(expand-type ,type))
+  (let ([t2 (input-type-expander type)])
+    (if (eq? type t2)
+        (or (compat-type-once type expand-input-type)
+            (mrspidey:error (format "Invalid type syntax ~s" type)))
+        (expand-input-type t2))))
+
+(define (expand-input-type-err type at)
+  ;; Do rewriting transformations
+  ;; (pretty-print-debug `(expand-type ,type))
+  (let ([t2 (input-type-expander type)])
+    (if (eq? type t2)
+        (or (compat-type-once type 
+              (lambda (type) (expand-input-type-err type at)))
+            (mrspidey:error (format "Invalid type syntax ~s" type) at))
+        (expand-input-type-err t2 at))))
+
+(define (expand-output-type type)
+  ;; Do rewriting transformations
+  (pretty-debug `(expand-output-type ,type))
+  (letrec
+    ([local-expand-output-type
+       (lambda (type)
+         (let* ([type (or (compat-type-once type local-expand-output-type)
+                        type
+                        (mrspidey:error (format "Bad output type ~s" type)))])
+           (let ([t2 (output-type-expander type)])
+             (if (equal? type t2)
+               type 
+               (local-expand-output-type t2)))))])
+    (if (st:expand-output-type)
+      (match (local-expand-output-type type)
+        [('values x) x]
+        [('rec bindings ('values x)) `(rec ,bindings ,x)]
+        [x x])
+      type)))
+
+;; ----------------------------------------------------------------------
+
+(define (type->templates con-exp)
+  ;; Assumes con-exp already expanded
+  (match con-exp
+    [('union . E*)
+     (let* ([T* (map type->templates E*)])
+       (if (andmap (lambda (x) x) T*)
+           (apply union T*)
+           #f))]
+    [('intersect . E*)
+     (let* ([T* (map type->templates E*)]
+            [T* (filter (lambda (x) x) T*)])
+       (apply intersect T*))]
+    [('forall _ type) (type->templates type)]
+    [(or (C . _) C)
+     (if (type-constructor? C)
+         (list (lookup-template C))
+         #f)]))
+
+;; ----------------------------------------------------------------------
+
+(define ( generic-type->con type prefix forall-env sign)
+  ;; Assumes type is already expanded
+  (letrec
+      ([mk-Tvar-tmp (lambda () (mk-Tvar (symbol-append prefix ':tc)))]
+       [parse-type-generic
+        (lambda (t env sign)
+          ;; sign is #t for +ive, #f for -ive
+          ;; (pretty-print-debug `(parse-type-generic ,t ,env ,sign))
+          (let ([new-sign-edge!
+                 (lambda (from to)
+                   (if sign
+                       (new-edge! from to)
+                       (new-edge! to from)))]
+                [parse-type 
+                 (lambda (t) 
+                   (let ([r (parse-type-generic t env sign)])
+                     ;;(pretty-print-debug `(parse-type-generic ,t ,(Tvar-name r)))
+                     r))])
+            (match t
+
+              ;; Recursive definitions
+              [('rec bind t2)
+                (let* ( [a* (map car bind)]
+                        [env env]
+                        [mk-tvar*
+                          (map 
+                            (lambda (a rhs) 
+                              (letrec
+                                ([f (lambda (sign)
+                                      (pretty-debug `(rec ,a ,sign))
+                                      (let* 
+                                        ( [sym (symbol-append prefix ': a)]
+                                          [tvar (mk-Tvar sym)]
+                                          [_ (set! f
+                                               (lambda (sign2)
+                                                 (unless (eq? sign sign2)
+                                                   (mrspidey:error
+                                                     (format "rec-bound variable ~s referenced in covariant and contravariant positions in type ~s" a type)))
+                                                 tvar))]
+                                          [tvar2
+                                            (parse-type-generic rhs env sign)])
+                                        (if sign
+                                          (new-edge! tvar2 tvar)
+                                          (new-edge! tvar tvar2))
+                                        tvar))])
+                                (lambda (sign) (f sign))))
+                            a* (map cadr bind))])
+                  (set! env (extend-env* env a* mk-tvar*))
+                  (parse-type-generic t2 env sign))]
+
+              ;; Unions
+              [('union . (? list? union))
+               (let ([Tvar (mk-Tvar-tmp)])
+                 (for-each
+                  (lambda (t)
+                    (new-sign-edge! (parse-type-generic t env sign) Tvar))
+                  union)
+                 Tvar)]
+
+              ;; Scheme
+              ;[('scheme: E)
+              ;  (assert (eq? sign #t) 'scheme:)
+              ;  (let*-vals
+              ;    ( [p (open-output-string)]
+              ;      [_ '(pretty-print E p)]
+              ;      [p (close-output-port)]
+              ;      [s (get-output-string p)]
+              ;      [p (open-input-string s)]
+              ;      [E ((zodiac:read p))]
+              ;      [defs (my-scheme-expand-program (list E))]
+              ;      [(ftype _ _) (traverse-exp (car defs) atenv:empty)]
+              ;      [tvar (FlowType->Tvar ftype)])
+              ;    tvar)]
+
+              [('intersect . (? list? intersect))
+               (when sign
+                 (mrspidey:error "Intersection in covariant position"))
+               (let ([Tvar (mk-Tvar-tmp)])
+                 (for-each
+                  (lambda (t)
+                    (new-edge! Tvar (parse-type-generic t env sign)))
+                  intersect)
+                 Tvar)]
+
+              ;; type variables
+              ['_ 
+               (when sign 
+                 (mrspidey:error "_ type in covariant position"))
+               (mk-Tvar-tmp)]
+
+              ['empty
+               (unless sign
+                   (mrspidey:error 
+                    (format "empty in contravariant position in ~s" type)))
+               (mk-Tvar-tmp)]
+
+              [(? symbol? a)
+                (cond
+                  [(lookup-or-#f env a) 
+                    => (lambda (mk-tvar) (mk-tvar sign))]
+                  [else
+                    (or
+                      (lookup-or-#f forall-env a)
+                      (let ([Tvar (mk-Tvar a)])
+                        (if sign 
+                          (add-global-tref! a Tvar)
+                          (add-global-tbang! a Tvar))
+                        Tvar))])]
+
+              [('lambda arg res)
+               (let ([Tvar (mk-Tvar-tmp)])
+                 (if sign
+                     ;; make the AV
+                     (new-AV! Tvar
+                              (make-AV-lam 
+                               (parse-type-generic arg env #f)
+                               (parse-type-generic res env #t)
+                               0 #t))
+                     ;; extract the various components
+                     (begin
+                       (new-con! Tvar
+                         (make-con-dom (parse-type-generic arg env #t)))
+                       (new-con! Tvar
+                         (make-con-rng
+                           (parse-type-generic res env #f)))))
+                 Tvar)]
+
+              ;; constants
+              [(or (? number? c) (? char? c) 
+                   ((or 'quote '#%quote) (? symbol? c)))
+               (let ([Tvar (mk-Tvar-tmp)])
+                 (if sign (new-AV! Tvar (traverse-simple-const c)))
+                 Tvar)]
+
+              ;; check constructors
+              [((? type-constructor? C) . args)
+               (match-let*
+                   ([(and template ($ template type n+ n- ref assign))
+                     (lookup-template C)]
+                    [Tvar (mk-Tvar-tmp)])
+                 (unless (= (vector-length ref) (length args))
+                   (mrspidey:error
+                    (format "Constructor ~s given ~s arg(s), expected ~s" 
+                            C (length args) (vector-length ref))))
+                 (if sign
+                     ;; make the AV, unless void and (st:see-void) is false
+                     (unless (and (eq? C 'void) (not (st:see-void)))
+                       (let ([args 
+                              (map 
+                               (lambda (a) (parse-type-generic a env sign)) 
+                               args)])
+                         ;;(pretty-print-debug `(,C ,@(map Tvar-name args)))
+                         (new-AV! 
+                          Tvar
+                          (apply make-constructed-AV C args))))
+                     ;; DO SOMETHING FOR NULL ARGS
+
+                     ;; extract the various components
+                     ;; need to do unification on mutable fields,
+                     ;; unless pattern matching arg is (! a)
+                     (for-each-with-n
+                      (lambda (arg n)
+                        (match arg
+                          [(or '_ 'top)(void)]
+                          [('! a)
+                            (match (vector-ref assign n)
+                              [#f
+                                (mrspidey:error
+                                  "! used on immutable field in type")]
+                              [n
+                                ;; Inject only
+                                (new-con!
+                                  Tvar
+                                  (create-con template n
+                                    (parse-type-generic a env #t) #f))])]
+                          [arg
+                            ;; Extract 
+                            (new-con!
+                              Tvar
+                              (create-con template (vector-ref ref n)
+                                (parse-type-generic arg env #f) #t))]))
+                      args))
+                 Tvar)]
+              [_
+               ;; Didn't match any type
+               (mrspidey:error (format "invalid type syntax ~s" t))])))])
+
+    (let ([Tvar (parse-type-generic type empty-env sign)])
+      Tvar)))
+
+;; ----------------------------------------------------------------------
+
+(define (split-schema type)
+  (match type
+    [('forall vars type)
+     (values vars type)]
+    [type (values '() type)]))
+
+(define (schema->env+type type)
+  (let-values ([(vars type) (split-schema type)])
+    (values
+     (map (lambda (v) (cons v (mk-Tvar v))) vars)
+     type)))
+
+(define (schema->con schema Tvar prefix top-misc)
+  (let-values ([(forall-env type) (schema->env+type schema)])
+
+    (new-edge! (generic-type->con type prefix forall-env #t) Tvar)
+
+    ;; Put top-misc in misc field of each AV
+    (for-each
+     (lambda (AV) (set-AV-misc! AV top-misc))
+     (get-Tvar-objs Tvar))))
+
+;; ----------------------------------------------------------------------
+
+(define (tschema->con tschema Tvar prefix top-misc)
+  (schema->con
+   (match tschema
+     [('case-> . schema*) (rac schema*)]
+     [schema schema])
+   Tvar prefix top-misc))
+
+;; ----------------------------------------------------------------------
+
+(define (tschema->con-for-nargs tschema Tvar prefix top-misc n)
+  ;; Assumes type is already expanded
+
+  (match tschema
+    [('case-> . schema*)
+      (or
+        (ormap
+          (lambda (schema) 
+            (let-values ([(forall-env type) (schema->env+type schema)])
+              (if (function-takes-nargs? type n)
+                (schema->con schema Tvar prefix top-misc)
+                #f)))
+          schema*)
+        (schema->con (rac schema*) Tvar prefix top-misc))]
+    [schema 
+      (schema->con schema Tvar prefix top-misc)]))
+
+;; ----------------------------------------------------------------------
+
+(define (function-takes-nargs? type nargs)
+  (match type
+    [('lambda dom rng)
+      (recur loop ([dom dom][n nargs])
+        (match dom
+          [('nil) (zero? n)]
+          [('cons para rest) (loop rest (sub1 n))]
+          [_ #f]))]
+    [_ #f]))
+ 
+;; ----------------------------------------------------------------------
+
+'(define (Tvar-in-type? ftype type)
+  (let* ([o (old-Tvar-in-type? ftype type)]
+         [Tvar2 (mk-Tvar 'in-type?)]
+         [_ (tschema->con type Tvar 'in-type? '())]
+         [n (Tvar-containment? ftype ftype2)])
+    (unless (eq? o n)
+      (mrspidey:warning
+       (format "Tvar-in-type old ~s new ~s type ~s"     o n type))
+      o)))
+
+(define Tvar-in-type?
+  (lambda (Tvar type forall-vars unbound)
+
+    ;; (pretty-print `(Tvar-in-type? ,(Tvar-name Tvar) ,type ,forall-vars))
+    ;; Checks if Tvar is contained in the type
+    ;; Assumes type is already expanded
+    
+    (letrec
+        ([visit-alloc (lambda () (make-vector num-AV #f))]
+         [add-visit! 
+          (lambda (v AV)
+            (vector-set! v (AV-num AV) #t))]
+         [visited?
+          (lambda (v AV) 
+            (vector-ref v (AV-num AV)))]
+          [Tvar-in-type?
+           (lambda (Tvar type env)
+            ;; env maps type vars to AV-membership test function
+            (andmap (lambda (AV) (AV-in-type? AV type env))
+                    (get-Tvar-objs Tvar)))]
+         [AV-in-type?
+          (lambda (AV type env)
+            ;; env maps type vars to AV-membership test function
+            (match type
+
+              ;; Recursive definitions
+              [('rec bind t2)
+               (let* 
+                   ([a* (map car bind)]
+                    [t* (map cadr bind)]
+                    [envbox (box #f)]
+                    [nuenv
+                     (extend-env*
+                      env a*
+                      (map (lambda (t)
+                             (let ([v (visit-alloc)])
+                               (lambda (AV)
+                                 (or (visited? v AV)
+                                     (begin
+                                       (add-visit! v AV)
+                                       (AV-in-type? AV t (unbox envbox)))))))
+                           t*))])
+                 (set-box! envbox nuenv)
+                 (AV-in-type? AV t2 nuenv))]
+
+              [('case-> . types) (AV-in-type? AV (rac types) env)]
+
+              [('union . (? list? union))
+               (ormap (lambda (type) (AV-in-type? AV type env))
+                      union)]
+              [('intersect . (? list? intersect))
+               (andmap (lambda (type) (AV-in-type? AV type env))
+                       intersect)]
+              ['_ #t]
+              [(? symbol? a) 
+               (let ([fn (or (lookup-or-#f env a)
+                             (and (memq a forall-vars) (lambda (AV) #t))
+                             (let ([type:a a])
+                               (ormap
+                                (match-lambda
+                                 [(sym . Tvar)
+                                  (if (eq? sym type:a)
+                                      (lambda (AV)
+                                        (let ([Tvar-t (mk-Tvar 'in-type?)])
+                                          (new-AV! Tvar-t AV)
+                                          (Tvar-containment? Tvar-t Tvar)))
+                                      #f)])
+                                global-tdef-env))
+                             (unbound a))])
+                 (fn AV))]
+              [('lambda arg res)
+                (and (eq? (AV-template AV) template-lam)
+                  (Tvar-in-type?
+                    (vector-ref (AV-fields+ AV) 0)
+                    res
+                    env))]
+              [(? number? n)
+               (and (eq? (template-type (AV-template AV)) 'num)
+                    (number? (AV-misc AV))
+                    (= (AV-misc AV) n))]
+              [(? char? c)
+               (and (eq? (template-type (AV-template AV)) 'char)
+                    (char=? (AV-misc AV) c))]
+              [((or 'quote '#%quote) (? symbol? s))
+               (and (eq? (template-type (AV-template AV)) 'sym)
+                    (eq? (AV-misc AV) s))]
+
+              [((? type-constructor? C) . args)
+                (match-let 
+                  ([(and template ($ template type n+ n- ref assign))
+                     (lookup-template C)])
+                  (cond
+                    [(or (eq? (AV-template AV) template)
+                       (memq template 
+                         (template-super-templates (AV-template AV)))) 
+                      (recur loop ([args args][n 0])
+                        (if (null? args)
+                          #t
+                          (and 
+                            (or
+                              (not (vector-ref ref n));; Can't reference
+                              (Tvar-in-type? 
+                                (vector-ref (AV-fields+ AV) (vector-ref ref n))
+                                (match args
+                                  [(('! a) . _) a]
+                                  [(a . _) a])
+                                env))
+                            (loop (cdr args) (add1 n)))))]
+                    [else
+                      '(pretty-print-debug
+                         `(fail ,(AV-template AV)
+                            ,C
+                            ,template
+                            ,(template-super-templates (AV-template AV))
+                            ,(memq template 
+                               (template-super-templates (AV-template AV)))))
+                      #f]))]
+              [_ 
+               ;; Didn't match any type
+               (mrspidey:error (format "Invalid type syntax ~s" type))]))])
+      (Tvar-in-type? Tvar type empty-env))))
+
+; ======================================================================
+
+'(define (FV-tschema tschema)
+  ;; returns (FV-ref FV-bang)
+  (let ([FV-ref '()]
+        [FV-bang '()])
+    (letrec 
+        ([FV-type
+          (lambda (type env sign)
+            (match type
+              [('rec bind t2)
+               (let ([env (append (map car bind) env)])
+                 (FV-type* (map cadr bind) env sign)
+                 (FV-type t2 env sing))]
+              [((or 'union 'intersect (? type-constructor?)) . (? list? args))
+               (FV-type* args env sign)]
+              [(or '_ 'empty (? number?) (? char?) 
+                 ((or 'quote '#%quote) (? symbol?)))
+               (void)]
+              [(or (? symbol? a) ('! (? symbol? a)))
+               (if sign
+                   (set! FV-ref (set-add a FV-ref))
+                   (set! FV-bang (set-add a FV-bang)))]
+              [x
+               ;; Didn't match any type
+               (mrspidey:internal-error 'FV-type 
+                                        "invalid type syntax ~s" x)]))]
+         [FV-type*
+          (lambda (types env sign)
+            (for-each (lambda (t) (FV-type t env sign)) types))]
+         [FV-schema
+          (match-lambda
+           [('forall vars type)
+            (setdiff2 (FV-type type) vars)]
+           [type (FV-type type vars #t)])]
+         [FV-tschema
+          (match-lambda
+           [('case-> . schemas)
+            (apply union (map FV-schema schemas))]
+           [schema (FV-schema schema)])])
+      (FV-tschema tschema)
+      (list FV-ref FV-bang))))
+
+; ======================================================================
+
+(define (primitive->atprim name orig-type-schema . attrs)
+  ;;(pretty-debug `(primitive->atprim ,name))
+  (match-let*
+    ( [type-schema (expand-input-type orig-type-schema)]
+      [type (match type-schema
+              [('forall _ type) type]
+              [type type])])
+
+    (make-atprim
+      name 
+      type-schema
+
+      ;; Calculate filter-domains
+      (match type
+        [('lambda domain _)
+          ;; Now walk domain and args
+          (recur loop ([domain domain])
+            (match domain
+              [('cons domain d-rest)
+                (cons
+                  (let ([templates (type->templates domain)])
+                    (if templates
+                      (create-filter #t templates)
+                      #f))
+                  (loop d-rest))]
+              [_ '()]))]
+        [_ '()])
+
+      ;; Calculate predicate-fn
+      (foldl
+        (lambda (attr predicate-fn)
+          (let* 
+            ([mk-predicate-fn
+               (lambda (filter-then filter-else)
+                 (lambda (b a Tvar sign)
+                   '(printf "mk-predicate-fn ~s ~s ~s ~s ~s ~s~n"
+                      filter-then filter-else b a Tvar sign)
+                   (let ([filter (if sign filter-then filter-else)])
+                     (if filter
+                       (let ([nu-Tvar (mk-Tvar 'filter)])
+                         (new-con! Tvar
+                           (create-con-filter filter
+                             nu-Tvar))
+                         nu-Tvar)
+                       Tvar))))]
+              [get-templates
+                (lambda (C*) 
+                  (map
+                    (lambda (C)
+                      (or (lookup-template C)
+                        (mrspidey:error 
+                          (format "Unknown constructor ~s in primitive def" C))))
+                    C*))]
+              [nu-fn
+                (match attr
+                  [('predicate-fn exp) exp]
+                  [('predicate . C*)
+                    (let ([templates (get-templates C*)])
+                      (mk-predicate-fn (create-filter #t templates)
+                        (create-filter #f templates)))]
+                  [('predicate* true-info false-info)
+                    (apply 
+                      mk-predicate-fn
+                      (map
+                        (match-lambda
+                          ['_ #f]
+                          [(bool . C*)
+                            (let ([templates (get-templates C*)])
+                              (create-filter bool templates))]
+                          [_ (error 'predicate* "Bad syntax")])
+                        (list true-info false-info)))]
+                  [_ #f])])
+            (if nu-fn
+              ;; compose
+              (lambda (b a Tvar sign)
+                (nu-fn b a
+                  (predicate-fn b a Tvar sign)
+                  sign))
+              predicate-fn)))
+        (lambda (b a Tvar bool) Tvar)                 
+        attrs)
+     
+      attrs
+      orig-type-schema)))
+
+; ======================================================================
+
+
diff --git a/collects/mrspidey/Sba/za.ss b/collects/mrspidey/Sba/za.ss
new file mode 100644
index 0000000..16dc174
--- /dev/null
+++ b/collects/mrspidey/Sba/za.ss
@@ -0,0 +1,328 @@
+;; za.ss
+;; Reads and writes .za files
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; ======================================================================
+;; za handling stuff
+;; ======================================================================
+
+;; ----------------------------------------------------------------------
+;; read-unit-za
+;; Returns (values ftype tref-env tdef-env tbang-env)
+
+(define (read-za za)
+  (let*-vals
+   ([(Tvar envs lookup-Tvar) (read-constraint-set za)]
+    [cvt-env (match-lambda
+              [(sym num) (cons sym (lookup-Tvar num))])])
+   (match envs
+     [('ftype sexp
+              'tref-env tref-env
+              'tdef-env tdef-env
+              'tbang-env tbang-env)
+      (values
+       (recur sexp->ftype ([sexp sexp])
+         ;;(pretty-print `(sexp->ftype ,sexp))
+         (match sexp
+           [(? number? n) (lookup-Tvar n)]
+           [('schema n n*)
+            (create-fo-FlowType
+             (make-schema (lookup-Tvar n)
+                          (map lookup-Tvar n*)
+                          '()))]
+           [('atunit imports exports result)
+            (create-fo-FlowType
+             (make-atunit (map (match-lambda
+                                [(sym . n*)
+                                 (cons sym (map lookup-Tvar n*))])
+                               imports)
+                          (map (match-lambda
+                                [(sym sexp)
+                                 (cons sym (sexp->ftype sexp))])
+                               exports)
+                          (sexp->ftype result)
+                          #f))]
+           [('atstruct A B C D E F)
+             (create-fo-FlowType (make-atstruct A B C D E F))]
+           [('prim sym type attrs)
+             (create-fo-FlowType (apply primitive->atprim sym type attrs))]
+           [x (mrspidey:internal-error 'read-za 
+                "Bad ftype-sexp in za: ~s" x)]))
+       (map cvt-env tref-env)
+       (map cvt-env tdef-env)
+       (map cvt-env tbang-env))])))
+
+;; ----------------------------------------------------------------------
+;; write-za
+
+(define (write-za za tvar-live ftype tref-env tdef-env tbang-env)
+  (write-constraint-set 
+   za tvar-live
+   (lambda (Tvar->nu-num)
+     (let ([cvt-env
+            (match-lambda
+             [(sym . tvar) (list sym (Tvar->nu-num tvar))])])
+       (list 
+        'ftype
+        (recur ftype->sexp ([ftype ftype])
+          (pretty-debug-unit `(ftype->sexp ,(FlowType->pretty ftype)))
+          (if (Tvar? ftype)
+              (Tvar->nu-num ftype)
+              (match (fo-FlowType-def ftype)
+                [($ schema tvar tvar* '()) 
+                 (list 'schema
+                       (Tvar->nu-num tvar) 
+                       (map Tvar->nu-num tvar*))]
+                [($ atunit imports exports result exp)
+                 (list 'atunit
+                       (map (match-lambda
+                             [(sym . tvar*)
+                              (cons sym (map Tvar->nu-num tvar*))])
+                            imports)
+                       (map (match-lambda
+                             [(sym . ftype)
+                              (list sym (ftype->sexp ftype))])
+                            exports)
+                       (ftype->sexp result))]
+                [($ atstruct A B C D E F) `(atstruct ,A ,B ,C ,D ,E ,F)]
+                [($ atprim sym type _ _ attrs orig-type-schema)
+                  (list 'prim sym orig-type-schema attrs)]
+                [x (mrspidey:internal-error 'ftype->sexp "Bad Atype ~s" x)])))
+
+        'tref-env (map cvt-env tref-env)
+        'tdef-env (map cvt-env tdef-env)      
+        'tbang-env (map cvt-env tbang-env))))))
+
+;; ======================================================================
+
+(define (write-constraint-set file Tvar-live mk-envs)
+  
+  (with-handlers
+    ([void 
+       (lambda (exn) 
+         (when (file-exists? file) (delete-file file))
+         (raise exn))])
+
+    (let*-vals
+      ( [s (format "Saving ~a" (file-name-from-path file))]
+        [_ (mrspidey:progress s '...)]
+        [_ (when (file-exists? file) (delete-file file))]
+        [p (open-output-file file 'text)]
+        [disp (lambda (x) (write x p) (newline p))]
+        [num-Tvar-live (length Tvar-live)]
+        [(get-Tvar-ndx set-Tvar-ndx!) (alloc-Tvar-field)]
+        [Tvar-ndx
+          (lambda (tvar)
+            (let ([ndx (get-Tvar-ndx tvar)])
+              '(unless (number? ndx)
+                 (error 'write-constraint-set::Tvar-ndx
+                   "Tvar ~s not live ~s"
+                   (Tvar-name tvar) (map Tvar-name Tvar-live)))
+              ndx))]
+        [(AV-ndx set-AV-ndx!) (alloc-AV-field)]
+        [num-nu-AV 0])
+
+      ;; --- assign number to each live Tvar
+      (for-each-with-n
+        (lambda (Tvar n)
+          (assert (eq? (Tvar-ndx Tvar) #f))
+          (set-Tvar-ndx! Tvar n))
+        Tvar-live)
+
+      ;; --- write version
+      (disp `(st:version ,(st:version)))
+
+      ;; --- write configuration
+      (pretty-print (mrspidey:control-fn) p)
+
+      ;; --- write num Tvars
+      (disp `(num-Tvar ,num-Tvar-live))
+
+      ;; --- write constructor-env
+      (disp `START-constructor-env)
+      (hash-table-for-each
+        constructor-env
+        (lambda (sym template)
+          (unless 
+            (hash-table-get saved-constructor-env sym (lambda () #f))
+            (match template
+              [($ template type n+ n- ref assign super-templates)
+                (disp (list type n+ n- ref assign 
+                        (map template-type super-templates)))]))))
+        ;; reverse it so defns in file occur before references ???
+      (disp 'END-constructor-env)
+
+      ;; --- write AV
+      (disp `START-AV)
+      (for-each
+        (lambda (Tvar)
+          ;;(pretty-print (Tvar-name Tvar))
+          (for-each
+            (match-lambda 
+              [(and AV ($ AV num ($ template type) misc fields+ fields-))
+                (unless (AV-ndx AV)
+                  (set-AV-ndx! AV num-nu-AV)
+                  (set! num-nu-AV (add1 num-nu-AV))
+                  (disp (list type
+                          (if (or (number? misc) (char? misc) (symbol? misc)
+                                (pair? misc))
+                            misc
+                            '())
+                          (map Tvar-ndx (vector->list fields+))
+                          (map Tvar-ndx (vector->list fields-)))))])
+            (Tvar-objs Tvar)))
+        Tvar-live)
+      (disp 'END-AV)
+
+      ;; --- write Tvar
+      (disp 'START-Tvar)
+      (for-each
+        (lambda (Tvar)
+          (disp 
+            (append (map AV-ndx (Tvar-objs Tvar))
+              (map 
+                (match-lambda
+                  [($ con _ ($ template type) field-no Tvar sign)
+                    (list type field-no (Tvar-ndx Tvar) sign)]
+                  [($ con-filter _ ($ filter sign (($ template types) ...)) 
+                     Tvar)
+                    (list sign types (Tvar-ndx Tvar))])
+                (Tvar-constraints Tvar))
+              (let ([edgeto (Tvar-edgeto Tvar)])
+                (if (null? edgeto)
+                  '()
+                  (cons 'T (map Tvar-ndx edgeto)))))))
+        Tvar-live)
+      (disp 'END-Tvar)
+
+      ;; --- write in-env, out-env
+      (let ([rep-envs (mk-envs Tvar-ndx)])
+        (pretty-print `(envs  ,@rep-envs)  p)
+        ;; --- all done
+        (close-output-port p))
+      (mrspidey:progress s 'done))))
+
+;; ----------------------------------------------------------------------
+
+(define (read-constraint-set file)
+  (match-let*
+    ([p (open-input-file file 'text)]
+      [('st:version save-st:version) (read p)]
+      [configuration (read p)]
+      [('num-Tvar save-num-Tvar) (read p)]
+      [vec-Tvar (make-vector save-num-Tvar #f)]
+      [vec-AV  (void)]
+      [lookup-Tvar
+        (lambda (n)
+          (if (number? n)
+            (vector-ref vec-Tvar n)
+            (let ([Tvar (mk-Tvar 'load-empty)])
+              Tvar)))]
+      [lookup-AV
+        (lambda (n)
+          (let ([AV (vector-ref vec-AV n)])
+            (assert (AV? AV) 'lookup-AV)
+            AV))])
+
+    (unless (equal? save-st:version (st:version))
+      (mrspidey:error ".za file from previous MrSpidey release"))
+
+    (for i 0 save-num-Tvar (vector-set! vec-Tvar i (mk-Tvar 'load)))
+
+    ;; --- constructors
+
+    (match (read p) ['START-constructor-env (void)])
+    (recur loop ()
+      (match (read p)
+        [(type n+ n- ref assign super)
+          (let ([t (make-template type n+ n- ref assign '() eqv?)])
+            (for-each
+              (lambda (s) (record-super-constructor-of-template! s t))
+              (reverse super))
+            (extend-constructor-env! t)
+            (loop))]
+        ['END-constructor-env (void)]))
+
+    ;; --- AV's
+
+    (match (read p) ['START-AV (void)])
+    (set! vec-AV
+      (list->vector
+        (recur loop ()
+          (match (read p)
+            [(C misc tvar-num+* tvar-num-*)
+              (cons 
+                (create-AV (lookup-template C)
+                  misc
+                  (list->vector (map lookup-Tvar tvar-num+*))
+                  (list->vector (map lookup-Tvar tvar-num-*)))
+                (loop))]
+            ['END-AV '()]))))
+
+    ;; --- Tvar's
+
+    (match (read p) ['START-Tvar (void)])
+    (let ([new-AV!  add-AV!]
+           [new-con! add-con!]
+           [new-edge! add-edge!])
+      (recur loop ([n 0])
+        (match (read p)
+          ['END-Tvar (void)]
+          [in 
+            (let ([Tvar (lookup-Tvar n)])
+              (recur loop2 ([in in])
+                (match in
+                  [() (void)]
+                  [((? integer? n) . rest)
+                    (new-AV! Tvar (lookup-AV n))
+                    (loop2 rest)]
+                  [(((? boolean? sign) C* tvar-num) . rest)
+                    (new-con! 
+                      Tvar
+                      (create-con-filter
+                        (create-filter sign (map lookup-template C*))
+                        (lookup-Tvar tvar-num)))
+                    (loop2 rest)]
+                  [((C n tvar-num sign) . rest)
+                    (new-con! 
+                      Tvar
+                      (create-con 
+                        (lookup-template C) n 
+                        (lookup-Tvar tvar-num) sign))
+                    (loop2 rest)]
+                  [('T . edgeto*)
+                    (for-each
+                      (lambda (tvar-num)
+                        (new-edge! Tvar (lookup-Tvar tvar-num)))
+                      edgeto*)])))
+            (loop (add1 n))])))
+
+    ;; --- in-env and out-env
+
+    (match-let*
+      ([('envs  . envs)  (read p)])
+
+      (close-input-port p)
+      
+      (values
+        (vector->list vec-Tvar)
+        envs
+        lookup-Tvar))))
+
+;; ----------------------------------------------------------------------
+
diff --git a/collects/mrspidey/Sba/zod-aux.ss b/collects/mrspidey/Sba/zod-aux.ss
new file mode 100644
index 0000000..423176d
--- /dev/null
+++ b/collects/mrspidey/Sba/zod-aux.ss
@@ -0,0 +1,622 @@
+; zodiac-aux.ss
+; Helper functions for zodiac structures
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+; ----------------------------------------------------------------------
+
+(define compat
+  (lambda (fn)
+    (letrec
+        ([cl-fn
+          (lambda (exp)
+            ;;(pretty-print-debug `(compat ,(stripper exp)))
+            (let ([r (fn exp cl-fn)])
+              (if r
+                  r
+                  (match exp
+                    [($ zodiac:if-form o s f b test then else)
+                     (zodiac:make-if-form o s f b
+                      (cl-fn test) (cl-fn then) (cl-fn else))]
+                    ;;[($ zodiac:lambda-form  o s f b args body)
+                    ;; (let* ([args (map-ilist cl-fn args)])
+                    ;;   (zodiac:make-lambda-form o s f b args (cl-fn body)))]
+
+                    [($ zodiac:case-lambda-form  o s f b arglists bodies)
+                     (zodiac:make-case-lambda-form 
+                      o s f b
+                       (map cl-fn arglists)
+                       (map cl-fn bodies))]
+                    [($ zodiac:arglist vars)
+                      (zodiac:make-arglist (map cl-fn vars))]
+                    [($ zodiac:set!-form o s f b  var val)
+                     (zodiac:make-set!-form o s f b (cl-fn var) (cl-fn val))]
+                    [($ zodiac:begin-form o s f b bodies)
+                     (zodiac:make-begin-form o s f b (map cl-fn bodies))]
+                    [($ zodiac:let-values-form o s f b  varss vals body)
+                     (let ([varss (map (lambda (vars) (map cl-fn vars))
+                                       varss)])
+                       (zodiac:make-let-values-form 
+                        o s f b
+                        varss (map cl-fn vals) (cl-fn body)))]
+                    [($ zodiac:letrec*-values-form o s f b  varss vals body)
+                     (let ([varss (map (lambda (vars) (map cl-fn vars))
+                                       varss)])
+                       (zodiac:make-letrec*-values-form 
+                        o s f b
+                        varss (map cl-fn vals) (cl-fn body)))]
+                    [($ zodiac:define-values-form o s f b vars value)
+                     (zodiac:make-define-values-form o s f b 
+                                                     (map cl-fn vars)
+                                                     (cl-fn value))]
+                    [($ zodiac:poly-form o s f b exp)
+                     (zodiac:make-poly-form o s f b (cl-fn exp))]
+
+                    [($ zodiac:app o s f b fun args)
+                     (zodiac:make-app o s f b
+                                      (cl-fn fun) (map cl-fn args))]
+                    ;;[($ zodiac:delay-form o s f b expr)
+                    ;; (zodiac:make-delay-form o s f b (cl-fn expr))]
+                    
+                    [($ zodiac::-form o s f b exp type)
+                     (zodiac:make-:-form o s f b (cl-fn exp) type)]
+
+                    [($ zodiac:type:-form o s f b type attrs) 
+                      exp]
+
+                    [($ zodiac:unit-form o s f b imports exports body)
+                     (zodiac:make-unit-form o s f b 
+                       (map cl-fn imports)
+                       (map 
+                         (match-lambda
+                           [(varref . sym)
+                             (cons (cl-fn varref) sym)])
+                         exports)
+                       (map cl-fn body))]
+                    [($ zodiac:compound-unit-form o s f b
+                        imports links exports)
+                     ;;(pretty-print-debug `compound-unit)
+                     (zodiac:make-compound-unit-form
+                      o s f b 
+                       (map cl-fn imports)
+                      (map (match-lambda
+                            [(tag exp . imports)
+                              ;;(pretty-print-debug `compound-unit-link)
+                              (list*
+                                tag
+                                (cl-fn exp)
+                                (map 
+                                  (lambda (import)
+                                    (if (zodiac:lexical-varref? import)
+                                      (cl-fn import)
+                                      import))
+                                  imports))])
+                           links)
+                      exports)]
+                    [($ zodiac:reference-unit-form o s f b file kind signed?)
+                      (zodiac:make-reference-unit-form o s f b 
+                        file kind signed?)]
+
+                    [($ zodiac:invoke-unit-form o s f b exp vars)
+                     (zodiac:make-invoke-unit-form 
+                      o s f b 
+                      (cl-fn exp) (map cl-fn vars))]
+
+                    ;; ---------- objects! ----------
+                    [($ zodiac:class*/names-form o s f b
+                       this super-init super-expr interfaces init-vars 
+                       inst-clauses)
+                      (zodiac:make-class*/names-form o s f b
+                        (cl-fn this)
+                        (cl-fn super-init)
+                        (cl-fn super-expr)
+                        interfaces
+                        (cl-fn init-vars)
+                        (map cl-fn inst-clauses))]
+                    [($ zodiac:public-clause exports internals exprs)
+                      (zodiac:make-public-clause 
+                        exports
+                        (map cl-fn internals)
+                        (map cl-fn exprs))]
+                    [($ zodiac:private-clause internals exprs)
+                      (zodiac:make-private-clause 
+                        (map cl-fn internals)
+                        (map cl-fn exprs))]
+                    [($ zodiac:inherit-clause internals imports)
+                      (zodiac:make-inherit-clause 
+                        (map cl-fn internals) imports)]
+                    [($ zodiac:rename-clause internals inheriteds)
+                      (zodiac:make-rename-clause 
+                        (map cl-fn internals)
+                        (map cl-fn inheriteds))]
+                    [($ zodiac:sequence-clause exprs)
+                      (zodiac:make-sequence-clause (map cl-fn exprs))]
+
+                    ;; ---------- sexps ----------
+                    [($ zodiac:list o s f l len marks)
+                     (zodiac:make-list o s f (map cl-fn l) len marks)]
+
+                    [_ exp]))))])
+      cl-fn)))
+
+(define compat*
+  (lambda (fn)
+    (let ([cl-fn (compat fn)])
+      (lambda (exp*) (map cl-fn exp*)))))
+
+; ----------------------------------------------------------------------
+
+(define (ast-size defs)
+  (let* ([size 0]
+         [fn (lambda (x f)
+               (set! size
+                   (+ size
+                      (match x
+                        [($ zodiac:quote-form 0 s f b expr)
+                         (const-size expr)]
+                        [_ 1])))
+               #f)])
+    ((compat* fn) defs)
+    size))
+
+; ----------------------------------------------------------------------
+;; const-size
+;; Gives the size of a zodiac constant
+
+(define const-size
+  (match-lambda
+   [(a . d) (+ 1 (const-size a) (const-size d))]
+   [(or ($ zodiac:list _ _ _ l) ($ zodiac:improper-list _ _ _ l))
+    (const-size l)]
+   [(or (? vector? v) ($ zodiac:vector _ _ _ v))
+    (+ 1 (apply + (map const-size v)))]
+   [else 1]))
+
+; ----------------------------------------------------------------------
+
+(define unparse-dynamic-letd
+  (lambda (fn)
+    (letrec
+        ([cl-fn
+          (lambda  (exp)
+            (let ([r (fn exp cl-fn)])
+              (if r
+                  r
+                  (match exp
+                    [($ zodiac:varref _ _ _ _ sym) sym]
+                    [($ zodiac:binding _ _ _ _ sym) sym]
+                    [($ zodiac:if-form _ _ _ _ test then else)
+                     `(if ,(cl-fn test) ,(cl-fn then) ,(cl-fn else))]
+                    ;;[($ zodiac:lambda-form _ _ _ _ args body)
+                    ;; (let* ([args (map-ilist cl-fn args)])
+                    ;;   `(lambda ,args ,(cl-fn body)))]
+                    [($ zodiac:case-lambda-form _ _ _ _ arglists bodies)
+                     `(case-lambda
+                       ,@(map
+                          (lambda (arglist body)
+                            (list (cl-fn arglist) (cl-fn body)))
+                           arglists bodies))]
+                    [($ zodiac:sym-arglist (var)) (cl-fn var)]
+                    [($ zodiac:list-arglist vars) (map cl-fn vars)]
+                    [($ zodiac:ilist-arglist vars) 
+                      (cons (map cl-fn (rdc vars)) (cl-fn (rac vars)))]
+                    [($ zodiac:set!-form _ _ _ _ var val)
+                     `(set! ,(cl-fn var) ,(cl-fn val))]
+                    [($ zodiac:begin-form _ _ _ _ bodies)
+                      `(begin ,@(map cl-fn bodies))]
+                    [($ zodiac:let-values-form _ _ _ _ varss vals body)
+                     (let ([varss (map (lambda (vars) (map cl-fn vars))
+                                       varss)])
+                       `(let-values ,(map list varss (map cl-fn vals))
+                          ,(cl-fn body)))]
+                    [($ zodiac:letrec*-values-form _ _ _ _ varss vals body)
+                     (let ([varss (map (lambda (vars) (map cl-fn vars))
+                                       varss)])
+                       `(letrec*-values ,(map list varss (map cl-fn vals))
+                          ,(cl-fn body)))]
+                    [($ zodiac:define-values-form _ _ _ _ vars value)
+                     `(define-values ,(map cl-fn vars) ,(cl-fn value))]
+                    [($ zodiac:poly-form _ _ _ _ exp)
+                     `(poly ,(cl-fn exp))]
+                    [($ zodiac:app _ _ _ _ fun args)
+                     `(,(cl-fn fun) ,@(map cl-fn args))]
+                    [($ zodiac:quote-form _ _ _ _ expr)
+                     (list 'quote (cl-fn expr))]
+                    [($ zodiac::-form _ _ _ _ exp type)
+                     (list ': (cl-fn exp) type)]
+                    [($ zodiac:st:control-form o s f b para val)
+                     (list 'st:control para val)]
+
+                    ;; [($ zodiac:unchanged _ _ _ _ expr) (cl-fn expr)]
+                    [($ zodiac:unit-form o s f b imports exports body)
+                     `(unit (import ,@(map cl-fn imports))
+                            (export 
+                             ,@(map (match-lambda 
+                                     [(i . e) (list (cl-fn i) (zodiac:read-object e))])
+                                    exports))
+                            ,@(map cl-fn body))]
+                    [($ zodiac:compound-unit-form _ _ _ _ 
+                        imports links exports)
+                     `(compound-unit
+                       (import ,@(map cl-fn imports))
+                       (link 
+                        ,@(map 
+                            (match-lambda
+                              [(tag exp . imports)
+                                (list tag
+                                  (cons 
+                                    (cl-fn exp) 
+                                    (map (match-lambda
+                                           [(tag . sym) (list tag sym)]
+                                           [(? zodiac:varref? lvr)
+                                             (zodiac:varref-var lvr)])
+                                      imports)))])
+                               links))
+                       (export ,@(map
+                                  (match-lambda
+                                   [(tag i . e) (list tag (list i e))])
+                                  exports)))]
+                    [($ zodiac:invoke-unit-form _ _ _ _ exp)
+                     `(invoke-unit ,(cl-fn exp))]
+                    [($ zodiac:reference-unit-form _ _ _ _ file kind signed?)
+                      (list 
+                        (if signed?
+                          'reference-unit
+                          'reference-unit/sig)
+                        file)]
+                    [($ zodiac:struct-form _ _ _ _ 
+                       ($ zodiac:symbol _ _ _ tag)
+                       parent 
+                       (($ zodiac:symbol _ _ _ fields) ...))
+                     `(struct
+                        ,(if parent (list tag (cl-fn parent)) tag)
+                        ,fields)]
+                    [($ zodiac:string  _ _ _ text) text]
+                    [($ zodiac:boolean _ _ _ text) text]
+                    [($ zodiac:char    _ _ _ text) text]
+                    [($ zodiac:symbol  _ _ _ text) text]
+                    [($ zodiac:number  _ _ _ text) text]
+                    [($ zodiac:list    _ _ _ contents) 
+                     (map cl-fn contents)]
+                    [($ zodiac:improper-list _ _ _ contents)
+                     (map-ilist cl-fn contents)]
+                    [($ zodiac:vector  _ _ _ contents)
+                     (list->vector (map cl-fn contents))]
+                    [($ zodiac:define-type-form _ _ _ _ sym type)
+                     `(define-type ,sym ,type)]
+                    [($ zodiac:define-constructor-form _ _ _ _ sym modes)
+                     `(define-constructor ,sym ,@modes)]
+                    [x x]
+                    ;;[_ (error 'unparse "Bad exp ~s" exp)]
+                    ))))])
+      cl-fn)))
+
+'(define (stripper exp)
+   ((unparse-dynamic-letd (lambda (x cl-fn) #f))
+     exp))
+
+(define (stripper exp)
+  (if (zodiac:parsed? exp)
+    (zodiac:parsed->raw exp)
+    'stripper:not-a-parsed))
+
+; ======================================================================
+;; Routines to add fields to each zodiac structure
+;; mutated and refs fields are only for binding structures
+
+(define (myzodiac:register-client name init-fn)
+  (let*-vals
+    ([(getter setter) (zodiac:register-client name init-fn)])
+    (values
+      (lambda (parsed) (getter (zodiac:parsed-back parsed)))
+      (lambda (parsed val) (setter (zodiac:parsed-back parsed) val)))))
+
+(define-values
+  (parsed-ftype set-parsed-ftype!)
+  (myzodiac:register-client 'ftype (lambda () #f)))
+
+(define-values
+  (parsed-check set-parsed-check!)
+  (myzodiac:register-client 'check (lambda () #f)))
+
+(define-values
+  (parsed-atprim set-parsed-atprim!)
+  (myzodiac:register-client 'atprim (lambda () #f)))
+
+(define-values
+  (app-tvar-args set-app-tvar-args!)
+  (myzodiac:register-client 'app-args (lambda () #f)))
+
+(define-values
+  (binding-refs set-binding-refs!)
+  (myzodiac:register-client 'refs (lambda () 0)))
+
+(define-values
+  (binding-mutated set-binding-mutated!)
+  (myzodiac:register-client 'mutated (lambda () #f)))
+
+;;(trace binding-mutated)
+;;(trace set-binding-mutated!)
+
+;; ----------------------------------------------------------------------
+;; Info on varrefs
+
+(define (get-top-level-varref-binding x) 
+  (let* ( [b (zodiac:top-level-varref/bind-slot x)]
+          [u (unbox b)])
+    (if (zodiac:binding? u)
+      u
+      (let ([u (my-create-binding 
+                 (zodiac:varref-var x)
+                 (zodiac:zodiac-start x)
+                 (zodiac:zodiac-finish x))])
+        (set-box! b u)
+        u))))
+
+(define (varref-binding varref)
+  (match varref
+    [($ zodiac:bound-varref) (zodiac:bound-varref-binding varref)]
+    [($ zodiac:top-level-varref/bind) (get-top-level-varref-binding varref)]
+    [x (error 'varref-backinfo "Bad varref ~s" x)]))
+
+(define my-create-binding
+  (case-lambda
+    [(name) (my-create-binding name (no-location) (no-location))]
+    [(name open close)
+      (zodiac:make-binding
+        (zodiac:make-origin 'non-source 'spidey)
+        open close (zodiac:make-empty-back-box) name name)]))
+
+;; ----------------------------------------------------------------------
+
+(define lambda-flatten-arglist
+  (match-lambda
+   [($ zodiac:list _ _ _ l) l]
+   [($ zodiac:improper-list _ _ _ l x) (append l (list x))]
+   [(? zodiac:binding? b) (list b)]
+   [() '()]
+   [(a . b) (cons a (lambda-flatten-arglist b))]))
+
+; ----------------------------------------------------------------------
+
+(define (no-location) (zodiac:make-location 0 0 0 "no-file"))
+
+(define (location-inc loc)
+  (zodiac:make-location 
+   0 0
+   (add1 (zodiac:location-offset loc))
+   (zodiac:location-file loc)))
+
+(define determine-end-first-token
+  (lambda (object)
+    (cond
+      [(or (zodiac:scalar? object)
+         (zodiac:varref? object)
+         (zodiac:binding?  object)
+         (and (zodiac:quote-form? object)
+           (or
+             (zodiac:boolean? (zodiac:quote-form-expr object))
+             (zodiac:char? (zodiac:quote-form-expr object))
+             (zodiac:symbol? (zodiac:quote-form-expr object))
+             (zodiac:number? (zodiac:quote-form-expr object)))))
+        (location-inc (zodiac:zodiac-finish object))]
+      [(or (zodiac:sequence? object)
+         (zodiac:parsed?     object)
+         (zodiac:app?      object))
+        (location-inc (zodiac:zodiac-start object))]
+      [else (error 'zodiac:determine-end-first-token
+              "shouldn't be here ~s" object)])))
+
+; ----------------------------------------------------------------------
+
+(define parsed-value?
+  (match-lambda
+    [(or
+       ($ zodiac:quote-form)
+       ;;($ zodiac:lambda-form)
+       ($ zodiac:case-lambda-form)
+       ($ zodiac:lexical-varref)) #t]
+    [($ zodiac:letrec*-values-form 
+       _ _ _ _ vars 
+       ((? parsed-value?) ...)
+       (? parsed-value?)) #t]
+    [_ #t]))
+      
+; ----------------------------------------------------------------------
+
+(define free-refs
+  (lambda (exp bindings)
+    (let* ( [hash-bindings (make-hash-table)]
+            [_ (for-each
+                 (lambda (bind) (hash-table-put! hash-bindings bind #t))
+                 bindings)]
+            [refs '()]
+            [fn
+              (lambda (exp cl-fn)
+                (match exp
+                  [($ zodiac:varref)
+                    (let ([bind (varref-binding exp)])
+                      (when 
+                        (hash-table-get hash-bindings bind (lambda () #f))
+                        (set! refs (cons bind refs))))
+                    #f]
+                  [($ zodiac:unit-form) 'do-not-traverse]
+                  [_ #f]))])
+      ((compat fn) exp)
+      refs)))
+               
+(define (free-vars exp bindings) (list->set (free-refs exp bindings)))
+
+;; ----------------------------------------------------------------------
+
+(define (initialize-mutated defs)
+  (let* (;; set binding of mutated variables
+          [_ (for-each
+               (match-lambda
+                 [($ zodiac:define-values-form _ _ _ _ varrefs expr) 
+                   (match expr
+                     ;; kludge - don't consider define-struct variables
+                     ;; to be mutable
+                     [($ zodiac:struct-form) (void)]
+                     [_
+                       (for-each
+                         (lambda (varref) 
+                           (set-binding-mutated!
+                             (get-top-level-varref-binding varref)
+                             #t))
+                         varrefs)])]
+                 [_ (void)])
+               defs)]
+          [free '()]
+          [fn
+            (lambda (def cl-fn)
+              ;;(display `(initialize-mutated ,(stripper def))) (newline)
+              (match def
+                [($ zodiac:letrec*-values-form _ _ _ _ varss)
+                  (for-each 
+                    (lambda (vars)
+                      (for-each
+                        (lambda (var) (set-binding-mutated! var #t))
+                        vars))
+                    varss)
+                  #f]
+                [($ zodiac:set!-form _ _ _ _ var) 
+                  ;;(display `(initialize-mutated! ,(stripper var))) (newline)
+                  (set-binding-mutated! (varref-binding var) #t)
+                  #f]
+                [_ #f]))])
+    ((compat* fn) defs)
+    free))
+
+(define (free-vars-defs defs)
+  (let* ( ;; Put binding on slot field of variables that are defined
+          ;; and set to mutated
+          [_ (for-each
+               (match-lambda
+                 [($ zodiac:define-values-form _ _ _ _ varrefs expr) 
+                   (match expr
+                     ;; kludge - don't consider define-struct variables
+                     ;; to be mutable
+                     [($ zodiac:struct-form) 
+                       (for-each
+                         (lambda (varref) 
+                           (get-top-level-varref-binding varref))
+                         varrefs)]
+                     [_
+                       (for-each
+                         (lambda (varref) 
+                           (set-binding-mutated!
+                             (get-top-level-varref-binding varref)
+                             #t))
+                         varrefs)])]
+                 [_ (void)])
+               defs)]
+          [free '()]
+          [fn
+            (lambda (def cl-fn)
+              ;;(pretty-debug `(get-tlvr ,(stripper def)))
+              (match def
+                [($ zodiac:top-level-varref/bind)
+                  (when
+                    (not 
+                      (zodiac:binding?
+                        (unbox (zodiac:top-level-varref/bind-slot def))))
+                    (set! free 
+                      (cons (get-top-level-varref-binding def) free)))
+                  #f]
+                [($ zodiac:unit-form) 'do-not-traverse]
+                [($ zodiac:letrec*-values-form _ _ _ _ varss)
+                  (for-each 
+                    (lambda (vars)
+                      (for-each
+                        (lambda (var) (set-binding-mutated! var #t))
+                        vars))
+                    varss)
+                  #f]
+                ;; struct-ref in function posn is not a free variable
+                [($ zodiac:app _ _ _ _ 
+                   ($ zodiac:top-level-varref/bind _ _ _ _ 'struct-ref)
+                   args)
+                  (for-each cl-fn args)
+                  #t]
+                [_ #f]))])
+    ((compat* fn) defs)
+    free))
+
+;; ----------------------------------------------------------------------
+
+(define (zero! p)
+  '(let-macro 
+     zerostruct
+     (lambda (name . fields)
+       `(begin
+          ;;(display ',(symbol-append 'zodiac: name))
+          (when (,(symbol-append 'zodiac: name '?) p)
+            ,@(map
+                (lambda (field)
+                  `(begin
+                     ;;(display ',(symbol-append 'zodiac: name '- field))
+                     (zero! 
+                       (begin0
+                         (,(symbol-append 'zodiac: name '- field) p)
+                         (,(symbol-append 'zodiac:set- name '- field '!) p 'zro)))))
+                fields))))
+
+     (zerostruct parsed back)
+     (zerostruct app fun args)
+     (zerostruct varref var)
+     (zerostruct bound-varref binding)
+     (zerostruct binding var orig-name)
+     (zerostruct top-level-varref/bind slot)
+     (zerostruct arglist vars)
+     (zerostruct paroptarglist vars)
+     (zerostruct set!-form var val)
+     (zerostruct begin-form bodies)
+     (zerostruct begin0-form bodies)
+     (zerostruct define-values-form vars val)
+     (zerostruct let-values-form vars vals body)
+     (zerostruct letrec*-values-form vars vals body)
+     (zerostruct if-form test then else)
+     (zerostruct quote-form expr)
+     (zerostruct case-lambda-form args bodies)
+     (zerostruct struct-form type super fields)
+     (zerostruct unit-form imports exports clauses)
+     (zerostruct compound-unit-form imports links exports)
+     (zerostruct invoke-unit-form unit variables)
+     (zerostruct invoke-open-unit-form unit name-specifier variables)
+     (zerostruct class*-form this super-names super-exprs init-vars inst-clauses)
+     (zerostruct public-clause exports internals exprs)
+     (zerostruct private-clause internals exprs)
+     (zerostruct inherit-clause internals imports)
+     (zerostruct rename-clause internals imports)
+     (zerostruct sequence-clause exprs)
+     (when (pair? p)
+       (zero! (begin0 (car p) (set-car! p 'zro)))
+       (zero! (begin0 (cdr p) (set-cdr! p 'zro))))
+
+     ))
+
+;; ----------------------------------------------------------------------
+
+(define (inline-begins defs)
+  (recur loop ([defs defs])
+    (match defs
+      [() '()]
+      [(($ zodiac:begin-form _ _ _ _ bodies) . rest)
+        (append (loop bodies) (loop rest))]
+      [(def . rest)
+        (cons def (loop rest))])))
+
diff --git a/collects/mrspidey/Sba/zod-extra.ss b/collects/mrspidey/Sba/zod-extra.ss
new file mode 100644
index 0000000..abd7286
--- /dev/null
+++ b/collects/mrspidey/Sba/zod-extra.ss
@@ -0,0 +1,75 @@
+; zod-extra.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(define mrspidey:zodiac:parameters@
+  (unit/sig plt:parameters^
+            (import)
+            (define case-sensitive? #t)
+            (define unmatched-cond/case-is-error? #t)
+            (define allow-set!-on-undefined? #t)
+            (define allow-improper-lists? #t)
+            (define check-syntax-level 'advanced)
+            ;(define allow-internal-defines? #f)
+            ))
+
+(define mrspidey:zodiac:interface@
+  (unit/sig zodiac:interface^
+    (import mrspidey:interaction^)
+    (define default-error-handler
+      (lambda (keyword)
+        (lambda (where fmt-spec . args)
+          (apply mrspidey:internal-error
+            keyword fmt-spec args))))
+    (define internal-error
+      (lambda (where fmt-spec . args)
+        (let ([msg 
+                (parameterize ([print-struct #t])
+                  (string-append "Syntax error: " 
+                    (apply format fmt-spec args)))])
+          (if #t                        ;(zodiac:zodiac? where)
+            (mrspidey:error msg where)                    
+            (mrspidey:error msg)))))
+    (define static-error
+      (lambda (where fmt-spec . args)
+        (let ([msg
+                (parameterize ([print-struct #t])
+                  (string-append "Syntax error: " 
+                    (apply format fmt-spec args)))])
+          (if #t                        ;(zodiac:zodiac? where)
+            (mrspidey:error msg where)                    
+            (mrspidey:error msg)))))
+    (define dynamic-error
+      (default-error-handler 'zodiac-run-time))))
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey:zodiac-aux@
+  (unit/sig
+    mrspidey:zodiac-aux^
+    (import
+      mrspidey:CDL^
+      (zodiac : zodiac:system^))
+    (include "zod-aux.ss")))
+
+;; ----------------------------------------------------------------------
+
+(load-relative "zod-link.ss")
+
+
+
+
diff --git a/collects/mrspidey/Sba/zod-link.ss b/collects/mrspidey/Sba/zod-link.ss
new file mode 100644
index 0000000..714c3ef
--- /dev/null
+++ b/collects/mrspidey/Sba/zod-link.ss
@@ -0,0 +1,22 @@
+;; zod-link.ss
+
+(define mrspidey:zodiac@;; mrspidey:zodiac^
+  (compound-unit/sig
+    (import 
+      (CDL : mrspidey:CDL^)
+      (INTERACTION : mrspidey:interaction^))
+    (link
+      [PARAMETERS : 
+        plt:parameters^
+        (mrspidey:zodiac:parameters@)]
+      [INTERFACE : 
+        zodiac:interface^
+        (mrspidey:zodiac:interface@ INTERACTION)]
+      [Z : 
+        zodiac:system^
+        (zodiac:system@ INTERFACE PARAMETERS (CORE pretty-print@) (CORE file@))]
+      [CORE : 
+        mzlib:core^
+        ((reference-library-unit/sig "corer.ss"))]
+      [AUX : mrspidey:zodiac-aux^ (mrspidey:zodiac-aux@ CDL Z)])
+    (export (open Z) (open AUX))))
diff --git a/collects/mrspidey/about.html b/collects/mrspidey/about.html
new file mode 100644
index 0000000..869fb09
--- /dev/null
+++ b/collects/mrspidey/about.html
@@ -0,0 +1,36 @@
+<HTML>
+<HEAD>
+<TITLE>About MrSpidey</TITLE>
+</HEAD>
+
+<body>
+<H1>
+<img align=left src="logo.gif" border=0 alt="[logo]">
+MrSpidey</H1>
+<P>
+MrSpidey version 49s1, Copyright (C) 1995-97 Cormac Flanagan
+<p>
+MrSpidey is an interactive, graphical static debugger for Scheme. For more information, visit the 
+<A HREF="http://www.cs.rice.edu/CS/PLT/packages/mrspidey/index.html"> MrSpidey home page</A>
+<P>
+Thanks to Matthew Flatt and Robby Findler for MrEd, and to Shriram
+Krishnamurthi for his source-correlating macro-expander. Thanks also
+to Stephanie Weirich for work on the first implementation of MrSpidey,
+and to Matthias Felleisen and Corky Cartwright for their feedback and
+help.
+<p>
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 2 as published by the Free Software Foundation.
+<p>
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+<p>
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+
+</body>
diff --git a/collects/mrspidey/drspidey.ss b/collects/mrspidey/drspidey.ss
new file mode 100644
index 0000000..b587576
--- /dev/null
+++ b/collects/mrspidey/drspidey.ss
@@ -0,0 +1,166 @@
+;; drspidey.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; The code to be loaded from DrScheme
+
+;;(printf "loading drspidey.ss (cd ~s)~n" (current-directory))
+
+(reference "pltrc-co.ss")
+(reference "macros.ss")
+
+(begin-elaboration-time
+  (unless (getenv "MREDCOMPILE") 
+    (match:set-error-control 'match)))
+
+
+#| MATTHEW: use require-library instead
+(load/use-compiled
+  (let ([p (build-path (current-load-relative-directory) "Zodiac" "load.ss")])
+    (if (file-exists? p)
+      p
+      (build-path (current-load-relative-directory) 'up "zodiac" "load.ss"))))
+|#
+(require-library "load.ss" "zodiac")
+
+(load/use-compiled (build-path "Sba" "loadu.ss"))
+(load/use-compiled (build-path "Gui" "loadu.ss"))
+
+(define mrspidey:interaction@
+  (unit/sig mrspidey:interaction^
+    (import 
+      [mred : mred^]
+      [zodiac : mrspidey:zodiac^]
+      mzlib:unprefixed-core^)
+    (include "handlers.ss")
+
+    (mrspidey:error-handler
+      (case-lambda
+        [(message object)
+          (unless (zodiac:zodiac? object)
+            (printf "Bad object in mrspidey:error-handler ~s~n" object)
+            ((mrspidey:error-handler) message))
+          (let* ([loc (zodiac:zodiac-start object)])
+            (unless (zodiac:location? loc)
+              (printf "Bad location in mrspidey:error-handler ~s~n" loc)
+              ((mrspidey:error-handler) message))
+            ((mrspidey:error-handler)
+              (format "~a at ~s line ~s, column ~s~n"
+                message
+                (file-name-from-path (zodiac:location-file loc))
+                (zodiac:location-line loc)
+                (zodiac:location-column loc))))]
+        [(message)
+          (mred:message-box
+            (format "~a~n" message)
+            "MrSpidey Error")
+          (raise 'mrspidey-raise)]))
+    ))
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey-tool@
+  (unit/sig ()
+    (import
+      [mred : mred^]
+      mrspidey-gui^
+      mzlib:unprefixed-core^)
+    (mred:add-version-spec 'sd 1)
+    (lambda (frame)
+      (let* ( [edit (ivar frame definitions-edit)]
+              [name (send edit get-filename)])
+        (if (string? name)
+          (when
+            (or (not (send edit modified?))
+              (let ([action (mred:unsaved-warning name "Analyze" #t)])
+                (case action
+                  [(save) (send edit save-file)]
+                  [(continue) #t]
+                  [else #f])))
+            (with-handlers
+              ([ (lambda (x) (eq? x 'mrspidey-raise))
+                 (lambda (x) (void))])
+              (send spidey run-mrspidey (send edit get-filename))))
+          (mred:message-box
+            "MrSpidey can only process programs that are saved to a file"
+            "MrSpidey Error"))))))
+
+;; ----------------------------------------------------------------------
+
+(define tool@
+  (let ( [mrspidey:sba@ mrspidey:sba@]
+         [mrspidey:interaction@ mrspidey:interaction@]
+         [mrspidey-gui@ mrspidey-gui@]
+         [mrspidey-tool@ mrspidey-tool@])
+    (unit/sig ()
+      (import 
+        [WX : wx^]
+        [MRED : mred^]
+        [MZLIB : mzlib:core^]
+        [PCONVERT : mzlib:print-convert^]
+        [DRSCHEME : drscheme:export^]
+        [ZODiac : zodiac:system^])
+
+      (invoke-unit/sig
+        (unit->unit/sig
+          (unit/sig->unit
+            (unit/sig ()
+              (import
+                mzlib:pretty-print^
+                mzlib:file^
+                mzlib:function^
+                mzlib:compat^
+                mzlib:string^)
+              (invoke-unit/sig
+                (unit->unit/sig
+                  (unit/sig->unit
+                    (compound-unit/sig 
+                      (import 
+		        [WX : wx^]
+                        [MZLIB : mzlib:unprefixed-core^]
+                        [MRED : mred^])
+                      (link 
+                        [INTERACTION : mrspidey:interaction^
+                          (mrspidey:interaction@ MRED (SBA zodiac) MZLIB)]
+                        [SBA : mrspidey:sba^
+                          (mrspidey:sba@ INTERACTION MZLIB WX)]
+                        [GUI : mrspidey-gui^
+                          (mrspidey-gui@ WX MRED MZLIB SBA INTERACTION)]
+                        [TOOL : () 
+                          (mrspidey-tool@ MRED GUI MZLIB)])
+                        (export)))
+                  (wx^ mzlib:unprefixed-core^ mred^)
+                  ()
+                  )
+		[WX : wx^]
+                mzlib:unprefixed-core^
+                [MRED : mred^])))
+          (((unit pretty-print@ : mzlib:pretty-print^))
+            ((unit file@ : mzlib:file^))
+            ((unit function@ : mzlib:function^))
+            ((unit compat@ : mzlib:compat^))
+            ((unit string@ : mzlib:string^)))
+          ())
+        (MZLIB : ((unit pretty-print@ : mzlib:pretty-print^)))
+        (MZLIB : ((unit file@ : mzlib:file^)))
+        (MZLIB : ((unit function@ : mzlib:function^)))
+        (MZLIB : ((unit compat@ : mzlib:compat^)))
+        (MZLIB : ((unit string@ : mzlib:string^)))))))
+
+;;(printf "tool@ defined~n")
+
+;; ----------------------------------------------------------------------
diff --git a/collects/mrspidey/handlers.ss b/collects/mrspidey/handlers.ss
new file mode 100644
index 0000000..4c38ad9
--- /dev/null
+++ b/collects/mrspidey/handlers.ss
@@ -0,0 +1,145 @@
+; handlers.ss 
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+;; (printf "Loading handlers.ss~n")
+
+(define mrspidey:error
+  (lambda args
+    (apply (mrspidey:error-handler) args)))
+
+(define mrspidey:error-handler
+  (make-parameter
+    (case-lambda
+      [(message object)
+        (unless (zodiac:zodiac? object)
+          (printf "Bad object in mrspidey:error-handler ~s~n" object)
+          ((mrspidey:error-handler) message))
+        (let* ([loc (zodiac:zodiac-start object)])
+          (unless (zodiac:location? loc)
+            (printf "Bad location in mrspidey:error-handler ~s~n" loc)
+            ((mrspidey:error-handler) message))
+          (error 'MrSpidey "~a"
+            (format "~a at ~s line ~s, column ~s~n"
+              message
+              (file-name-from-path (zodiac:location-file loc))
+              (zodiac:location-line loc)
+              (zodiac:location-column loc))))]
+      [(message)
+        (error 'MrSpidey "~a" (format "~a~n" message))])
+    (lambda (x) x)))
+
+(define mrspidey:internal-error error)
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey:add-summary
+  (lambda line
+    ;; line is: 
+    ;; str
+    ;; str loc word-no
+    (apply (mrspidey:add-summary-handler) line)))
+
+(define mrspidey:add-summary-handler
+  (make-parameter
+    (match-lambda*
+      [(str loc word-no) 
+        (cond
+          [(zodiac:location? loc)
+            (printf "~a at line ~s, file ~s~n" 
+              str 
+              (zodiac:location-line loc)
+              (file-name-from-path (zodiac:location-file loc)))]
+          [(zodiac:zodiac? loc)
+            (mrspidey:add-summary str (zodiac:zodiac-start loc) word-no)]
+          [else
+            (printf "Bad location in mrspidey:add-summary-handler ~s~n" loc)
+            (mrspidey:add-summary str)])]
+      [(str . _) (printf "~a~n" str)])
+    (lambda (x) x)))
+
+(define (mrspidey:warning . line)
+  (apply (mrspidey:warning-handler) line))
+
+(define mrspidey:warning-handler
+  (make-parameter
+   (match-lambda*
+    [(str loc word-no) 
+     (mrspidey:add-summary (format "Warning: ~a" str) loc (add1 word-no))]
+    [(str) 
+     (mrspidey:add-summary (format "Warning: ~a" str))])
+   (lambda (x) x)))
+
+;; ----------------------------------------------------------------------
+
+(define mrspidey:progress
+  (lambda args
+    (apply (mrspidey:progress-handler) args)))
+
+(define default-mrspidey:progress-handler
+  (let ([current ()]
+        [fresh-line #t])
+    (letrec 
+        ([f (match-lambda*
+             [((? string? name) line)
+              (unless (equal? name current)
+                (f 'fresh-line)
+                (set! current name)
+                (mrspidey:progress-output name))
+              (mrspidey:progress-output (format "[~s]" line))
+              (flush-output)
+              (set! fresh-line #f)]
+             [((? string? str)) 
+              (f 'fresh-line)
+              (mrspidey:progress-output str)
+              (f #\newline)]
+             [(#\newline)
+              (mrspidey:progress-output (format "~n"))
+              (set! fresh-line #t)]
+             [('fresh-line)
+              (unless fresh-line (f #\newline))])])
+      f)))
+
+(define mrspidey:progress-handler
+  (make-parameter default-mrspidey:progress-handler (lambda (x) x)))
+
+;; ----------------------------------------------------------------------
+;; Don't really use the following flexibility, but might as well keep.
+
+(define (mrspidey:progress-output  str)
+  ((mrspidey:progress-output-handler) str))
+
+(define mrspidey:progress-output-handler
+  (make-parameter (lambda (str) (display str) (flush-output)) 
+                  (lambda (x) x)))
+
+;; ----------------------------------------------------------------------
+
+(define record-analyzed-file-hook
+  (make-parameter
+   (lambda (filename . _)
+     (printf "Record-analyzed-file ~s~n" filename))
+   (lambda (x) x)))
+
+(define (record-analyzed-file . args)
+  (apply (record-analyzed-file-hook) args))
+
+;; ----------------------------------------------------------------------
+
+;(trace mrspidey:warning)
+;(trace mrspidey:error)
+;(trace mrspidey:internal-error)
diff --git a/collects/mrspidey/logo.gif b/collects/mrspidey/logo.gif
new file mode 100644
index 0000000..36f82e0
Binary files /dev/null and b/collects/mrspidey/logo.gif differ
diff --git a/collects/mrspidey/macros.ss b/collects/mrspidey/macros.ss
new file mode 100644
index 0000000..ffb7564
--- /dev/null
+++ b/collects/mrspidey/macros.ss
@@ -0,0 +1,101 @@
+;; macros.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(reference-library "defstruc.ss")
+
+(eval-at-compile-time
+  (if (defined? '__NO_DEBUGGING)
+    (begin
+      (printf "Debugging off~n")
+      (defmacro pretty-debug args           '(void))
+      (defmacro pretty-debug-traverse args  '(void))
+      (defmacro pretty-debug-object args    '(void))
+      (defmacro pretty-debug-front args     '(void))
+      (defmacro pretty-debug-min args       '(void))
+      (defmacro pretty-debug-min2 args      '(void))
+      (defmacro pretty-debug-check args     '(void))
+      (defmacro pretty-debug-atenv args     '(void))
+      (defmacro pretty-debug-atype args     '(void))
+      (defmacro pretty-debug-few args       '(void))
+      (defmacro pretty-debug-gram args      '(void))
+      (defmacro pretty-debug-sdl args       '(void))
+      (defmacro pretty-debug-sdl2 args      '(void))
+      (defmacro pretty-debug-dfa-min args   '(void))
+      (defmacro pretty-debug-min-table args '(void))
+      (defmacro pretty-debug-traverse-small args '(void))
+      (defmacro pretty-debug-unit args      '(void))
+      (defmacro pretty-debug-gui args       '(void))
+      (defmacro assert args                 '(void))
+    
+      )
+  
+    (begin
+      (defmacro pretty-debug args
+        `(when debugging (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-traverse args
+        `(when debugging-traverse (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-object args
+        `(when debugging-object (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-front args
+        `(when debugging-front (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-min args
+        `(when debugging-min (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-min2 args
+        `(when debugging-min2 (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-check args
+        `(when debugging-check (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-atenv args
+        `(when debugging-atenv (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-atype args
+        `(when debugging-atype (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-few args
+        `(when debugging-few (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-gram args 
+        `(when debugging-gram (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-sdl args
+        `(when debugging-sdl (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-sdl2 args
+        `(when (or debugging-sdl2 debugging-sdl) (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-dfa-min args
+        `(when debugging-dfa-min (pretty-print-debug ,@args)))
+      (defmacro pretty-debug-min-table args
+        `(when debugging-min-table (pretty-print ,@args)))
+      (defmacro pretty-debug-gui args
+        `(when debugging-gui (pretty-print ,@args)))
+
+      (defmacro pretty-debug-traverse-small args
+        `(when debugging-traverse 
+           (dynamic-let ([pretty-print-depth 4]) (pretty-print-debug ,@args))))
+
+      (defmacro pretty-debug-unit args
+        (match args
+          [(arg) `(when debugging-unit (pretty-print-debug ,arg))]
+          [(arg depth)
+            `(when debugging-unit
+               (dynamic-let ([pretty-print-depth ,depth]) (pretty-print-debug ,arg)))]))
+      )))
+
+;; ----------------------------------------------------------------------
+
+
+(defmacro trace-time-lambda args
+  (match args
+    [(timer args . body)
+     `(lambda ,args (record-time ,timer (lambda () ,@body)))]))
+
+;; ----------------------------------------------------------------------
diff --git a/collects/mrspidey/mred.ss b/collects/mrspidey/mred.ss
new file mode 100644
index 0000000..331b195
--- /dev/null
+++ b/collects/mrspidey/mred.ss
@@ -0,0 +1,65 @@
+;; mred.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+; Pulls up MrSpidey without DrScheme
+; Loads all UI and analysis files into MrEd
+;; ----------------------------------------------------------------------
+
+(mred:add-version-spec 's 1)
+
+#| MATTHEW: deleted this
+(define plt-home-directory
+  (let ([plt (getenv "PLTHOME")])
+    (normalize-path
+      (or plt
+        (case (system-type)
+          [(unix) "/usr/local/lib/plt/"]
+          [(windows) "C:\\PLT"]
+          [else (let-values ([(base name dir?)
+			       (split-path (current-directory))])
+		  (if (string? base)
+		    base
+		    (current-directory)))])))))
+|#
+;(reference-library "sparams.ss" "backward")
+
+;; ------------------------------
+
+(load-relative "pltrc-co.ss")
+
+(load-relative "text.ss")
+(load-relative "Sba/hyper.ss")
+(define mrspidey:load-progress 
+  (lambda (str)
+    (printf "Loading ~s~n" str)
+    (flush-output)))
+(load-relative "Gui/load.ss")
+(printf "~nAll loaded~n")
+
+; ----------------------------------------------------------------------
+
+(define T 
+  (lambda (file)
+    (send spidey run-mrspidey file)))
+(define (pacwar) (T "~/Spidey/Unit/Pacwar/main.ss"))
+(define (mred) (T "~/Spidey/Unit/Mred/main.ss"))
+(define (zodiac) (T "~/Spidey/Unit/Zodiac/invoke.ss"))
+
+; ----------------------------------------------------------------------
+
+
+
diff --git a/collects/mrspidey/mrspidey.gif b/collects/mrspidey/mrspidey.gif
new file mode 100644
index 0000000..108d9e3
Binary files /dev/null and b/collects/mrspidey/mrspidey.gif differ
diff --git a/collects/mrspidey/pltrc-co.ss b/collects/mrspidey/pltrc-co.ss
new file mode 100644
index 0000000..829defc
--- /dev/null
+++ b/collects/mrspidey/pltrc-co.ss
@@ -0,0 +1,203 @@
+;; pltrc-co.ss
+;; Stuff that released code needs
+;; ----------------------------------------------------------------------
+
+(define-macro defmacro
+  (lambda (name args . body)
+    `(define-macro ,name (lambda ,args ,@body))))
+
+(define (struct-expander-fn def-str struct:)
+  (#%let ([make-exn make-exn:syntax]
+	 [debug debug-info-handler])
+  (#%lambda body
+     (#%let ([syntax-error
+	      (#%lambda (s)
+		(#%raise
+		 (make-exn
+		  (#%format "~s: ~a" (cons def-str body) s)
+		  ((debug))
+		  (#%cons 'define-struct body))))]
+	     [build-struct-names
+	      (#%lambda (name fields)
+		(#%let ([name (#%symbol->string name)]
+			[fields (#%map #%symbol->string fields)]
+			[+ #%string-append])
+		  (#%map #%string->symbol
+			 (#%append
+			  (#%list 
+			   (+ "struct:" name)
+			   (+ "make-" name)
+			   (+ name "?"))
+			  (#%apply
+			   #%append
+			   (#%map
+			    (#%lambda (f) 
+			       (#%list 
+				(+ name "-" f)
+				(+ "set-" name "-" f "!")))
+			   fields))))))])
+	    (#%or (#%pair? body)
+		  (syntax-error "empty declaration"))
+	    (#%or (#%= 2 (#%length body))
+		  (syntax-error "wrong number of parts"))
+	    (#%or (#%symbol? (#%car body))
+		  (#%and (#%pair? (#%car body))
+			 (#%symbol? (#%caar body))
+			 (#%pair? (#%cdar body))
+			 (#%null? (#%cddar body)))
+		  (syntax-error "first part must be an identifier or identifier-expression pair"))
+	    (#%or (#%list? (#%cadr body))
+		  (syntax-error "improper field list"))
+	    (#%let* ([name (#%if (#%symbol? (#%car body))
+			      (#%car body)
+			      (#%caar body))]
+		  [fields (#%cadr body)]
+                  [fields
+                   (map (lambda (arg)
+                          (match arg
+                            [((or ': '!) field type) field]
+                            [(? symbol? field) field]
+                            [x (syntax-error (format "field name not a identifier at ~s" x))]))
+                        fields)])
+	      `(#%define-values ,(build-struct-names name fields)
+                                (,struct: ,(car body) ,fields)))))))
+
+(#%define-macro define-const-typed-structure
+  (struct-expander-fn ' define-const-typed-structure '#%struct))
+(#%define-macro define-typed-structure
+  (struct-expander-fn 'define-typed-structure  '#%struct))
+
+;; ----------------------------------------------------------------------
+
+(#%define-macro dynamic-let
+  (#%let ([make-exn make-exn:syntax]
+	  [debug debug-info-handler])
+    (#%lambda (params . body)
+     (#%let ([fail
+	      (#%lambda (msg)
+	       (#%raise (make-exn msg ((debug))
+				  (#%list* 'dynamic-let params body))))])
+      (#%if (#%null? body) (fail "dynamic-let: bad syntax (empty body)"))
+      (#%if (#%null? params)
+        `(#%begin ,@body)
+	(#%if (#%or (#%not (#%pair? params))
+		    (#%not (#%pair? (#%car params)))
+		    (#%not (#%pair? (#%cdar params)))
+		    (#%not (#%null? (#%cddar params))))
+	      (fail "dynamic-let: bad syntax")
+	      (#%let ([param (#%caar params)]
+		      [orig (#%gensym)]
+		      [pz (#%gensym)])
+		 `(#%let* ([param ,param]
+                           [,pz (if (parameter? param)
+                                    (#%in-parameterization 
+                                     (#%current-parameterization) ,param #t)
+                                    param)]
+			   [,orig (,pz)])
+		     (#%dynamic-wind
+		        (#%lambda () (,pz ,(#%cadar params)))
+		        (#%lambda () (dynamic-let ,(cdr params) ,@body))
+			(#%lambda () (,pz ,orig)))))))))))
+
+;; ----------------------------------------------------------------------
+
+(define cout 0)
+(define wh-cout (box '()))
+
+(defmacro let*-vals args
+  (match args
+    [(([varss exps] ...) . body)
+      (set! cout (add1 cout))
+      (printf "let*-vals ~s~n" cout)
+      (let* ([varss (map (lambda (vars) 
+                           (map 
+                             (lambda (x) (if (eq? x '_) (gensym) x))
+                             (if (symbol? vars) (list vars) vars)))
+                      varss)]
+              [binds (map list varss exps)])
+        `(begin 
+           (set-box! (global-defined-value 'wh-cout)
+             (cons ,cout (unbox (global-defined-value 'wh-cout))))
+           (let*-values ,binds 
+             (begin            
+               (set-box! (global-defined-value 'wh-cout)
+                 (cdr (unbox (global-defined-value 'wh-cout))))
+               . ,body))))]))
+
+(defmacro let*-vals args
+  (match args
+    [(([varss exps] ...) . body)
+      (let* ([varss (map (lambda (vars) 
+                           (map 
+                             (lambda (x) (if (eq? x '_) (gensym) x))
+                             (if (symbol? vars) (list vars) vars)))
+                      varss)]
+              [binds (map list varss exps)])
+        `(let*-values ,binds . ,body))]))
+
+(defmacro for args
+  (match args
+    [(var base limit . body)
+     (let ([loop (gensym)][l (gensym)])
+       `(let ([,l ,limit])
+          (recur ,loop ([,var ,base])
+                 (when (< ,var ,l)
+                   ,@body
+                   (,loop (add1 ,var))))))]))
+
+(define assert-on (make-parameter #t (lambda (x) x)))
+
+(defmacro assert args
+  (match args     
+    [(exp . rest)
+     (if (assert-on)
+         `(unless ,exp 
+            ,@(apply append
+                     (map (lambda (r) `((display ,r) (newline))) rest))
+            (error 'assert "Assertion failed: ~s" ',exp))
+         `(void))]))
+
+(defmacro eval-at-compile-time args
+  (apply eval args))
+
+;; ----------------------------------------------------------------------
+
+'(unless (defined? '__keep-mrspidey-annotations)
+
+   (defmacro begin-test-case exps '(void))
+   ;;(defmacro define-type exps '(void))
+
+   (defmacro define-typed-structure args
+     (match args
+       [(name.parent fields)
+         `(define-struct 
+            ,name.parent
+            ,(map (match-lambda
+                    [((or ': '!) (? symbol? s) type) s]
+                    [(? symbol? s) s]
+                    [field
+                      (error 'define-typed-structure "Bad field ~s" field)])
+               fields))]
+       [_ (error 'define-typed-structure 
+            "Bad syntax ~s" `(define-typed-structure ,@args))]))
+
+   (defmacro define-const-typed-structure args
+     `(define-typed-structure ,@args))
+
+   (defmacro : args
+     (match args     
+       [(exp type) exp]))
+
+   (defmacro cache-exp args
+     (match args
+       [(exp zafile) exp]))
+
+   (defmacro cache-inv args
+     (match args
+       [(exp zafile) exp]))
+
+   ;; (load "~cormac/scheme/remove-mrspidey-annotations.ss"))
+
+   )
+
+;;----------------------------------------------------------------------
diff --git a/collects/mrspidey/text.ss b/collects/mrspidey/text.ss
new file mode 100644
index 0000000..70e6fc8
--- /dev/null
+++ b/collects/mrspidey/text.ss
@@ -0,0 +1,37 @@
+;; mrspidey-mred.ss
+; ----------------------------------------------------------------------
+; Copyright (C) 1995-97 Cormac Flanagan
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; version 2 as published by the Free Software Foundation.
+; 
+; This program is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, write to the Free Software
+; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+; ----------------------------------------------------------------------
+
+(load-relative "handlers.ss")
+(load-relative "macros.ss")
+
+(load/use-compiled
+  (let ([p (build-path (current-load-relative-directory) "Zodiac" "load.ss")])
+    (if (file-exists? p)
+      p
+      (build-path (current-load-relative-directory) ".." "zodiac" "load.ss"))))
+(load-relative "Sba/load.ss")
+(load-relative "Sba/test-sba.ss")
+;;(load-relative "Sba/devel.ss")
+
+(printf "~nmrspidey-text loaded~n")
+
+;; --- Pull up a default language
+(st:language 'DrScheme)
+
+(define (t) (st: "/home/cormac/Spidey/Test/t.ss"))
+
diff --git a/collects/mzscheme/dynext/compile.ss b/collects/mzscheme/dynext/compile.ss
new file mode 100644
index 0000000..b8b15f2
--- /dev/null
+++ b/collects/mzscheme/dynext/compile.ss
@@ -0,0 +1,4 @@
+
+(require-library "compiles.ss" "mzscheme" "dynext")
+
+(invoke-open-unit/sig (require-library "compiler.ss" "mzscheme" "dynext"))
diff --git a/collects/mzscheme/dynext/compiler.ss b/collects/mzscheme/dynext/compiler.ss
new file mode 100644
index 0000000..076d623
--- /dev/null
+++ b/collects/mzscheme/dynext/compiler.ss
@@ -0,0 +1,105 @@
+
+(unit/sig dynext:compile^ (import)
+
+  (define include-dir (collection-path "mzscheme" "include"))
+
+  (define (get-unix-compile)
+    (or (find-executable-path "gcc" "gcc")
+	(find-executable-path "cc" "cc")))
+
+  (define (get-windows-compile)
+    (or (find-executable-path "cl.exe" "cl.exe")))
+
+  (define current-extension-compiler 
+    (make-parameter 
+     #f 
+     (lambda (v)
+       (when v 
+	     (if (and (string? v) (or (relative-path? v) (absolute-path? v)))
+		 (unless (and (file-exists? v)
+			      (memq 'execute (file-or-directory-permissions v)))
+			 (error 'current-extension-compiler 
+				"compiler not found or not executable: ~s" v))
+		 (raise-type-error 'current-extension-compiler "pathname string or #f" v)))
+       v)))
+
+  (define current-extension-compiler-flags
+    (make-parameter
+     (case (system-type)
+       [(unix) '("-c" "-O2")]
+       [(windows) '("/c" "/O2")]
+       [(macos) '()])
+     (lambda (l)
+       (unless (and (list? l) (andmap string? l))
+	       (raise-type-error 'current-extension-compiler-flags "list of strings" l))
+       l)))
+
+  (define current-make-compile-include-strings
+    (make-parameter
+     (case (system-type)
+       [(unix) (lambda (s) (list (string-append "-I" s)))]
+       [(windows) (lambda (s) (list (string-append "/I" s)))]
+       [(macos) (lambda (s) (list (string-append "-I" s)))])
+     (lambda (p)
+       (unless (procedure-arity-includes? p 1)
+	       (raise-type-error 'current-make-compile-include-strings "procedure of arity 1" p))
+       p)))
+
+  (define current-make-compile-input-strings
+    (make-parameter
+     (lambda (s) (list s))
+     (lambda (p)
+       (unless (procedure-arity-includes? p 1)
+	       (raise-type-error 'current-make-compile-input-strings "procedure of arity 1" p))
+       p)))
+
+  (define current-make-compile-output-strings
+    (make-parameter
+     (case (system-type)
+       [(unix) (lambda (s) (list "-o" s))]
+       [(windows) (lambda (s) (list (string-append "/Fo" s)))]
+       [(macos) (lambda (s) (list "-o" s))])
+     (lambda (p)
+       (unless (procedure-arity-includes? p 1)
+	       (raise-type-error 'current-make-compile-output-strings "procedure of arity 1" p))
+       p)))
+
+  (define-values (my-process* stdio-compile)
+   (let-values ([(p* do-stdio) (require-library "stdio.ss" "mzscheme" "dynext")])
+     (values
+      p*
+      (lambda (start-process quiet?)
+	(do-stdio start-process quiet? (lambda (s) (error 'compile-extension "~a" s)))))))
+
+  (define unix/windows-compile
+    (lambda (quiet? in out includes)
+      (let ([c (or (current-extension-compiler) 
+		   (if (eq? (system-type) 'unix) 
+		       (get-unix-compile) 
+		       (get-windows-compile)))])
+	(if c
+	    (stdio-compile (lambda (quiet?) 
+			     (let ([command (append 
+					     (list c)
+					     (current-extension-compiler-flags)
+					     (apply append 
+						    (map 
+						     (lambda (s) 
+						       ((current-make-compile-include-strings) s)) 
+						     includes))
+					     ((current-make-compile-include-strings) include-dir)
+					     ((current-make-compile-input-strings) in)
+					     ((current-make-compile-output-strings) out))])
+			       (unless quiet? 
+				       (printf "compile-extension: ~a~n" command))
+			       (apply my-process* command)))
+			   quiet?)
+	    (error 'compile-extension "can't find compiler")))))
+
+  (define (macos-compile quiet? input-file output-file)
+    (error 'compile-extension "Not yet supported for MacOS"))
+  
+  (define compile-extension
+    (case (system-type)
+      [(unix windows) unix/windows-compile]
+      [(macos) macos-compile])))
diff --git a/collects/mzscheme/dynext/compiles.ss b/collects/mzscheme/dynext/compiles.ss
new file mode 100644
index 0000000..4572d35
--- /dev/null
+++ b/collects/mzscheme/dynext/compiles.ss
@@ -0,0 +1,8 @@
+
+(define-signature dynext:compile^
+  (compile-extension
+   current-extension-compiler 
+   current-extension-compiler-flags
+   current-make-compile-include-strings
+   current-make-compile-input-strings
+   current-make-compile-output-strings))
diff --git a/collects/mzscheme/dynext/doc.txt b/collects/mzscheme/dynext/doc.txt
new file mode 100644
index 0000000..2a07e67
--- /dev/null
+++ b/collects/mzscheme/dynext/doc.txt
@@ -0,0 +1,74 @@
+compile.ss
+----------
+
+`compile-extension' takes
+   quiet? - Boolean indicating whether command should be echoed to stdout
+   input-file - A .c file
+   output-file - A .o/.obj file
+   includes - A list of include directories; MzScheme's include is
+              added automatically.
+
+Compilation is controlled by a number of parameters:
+
+   current-extension-compiler - compiler executable or #f. Under 
+     Windows, #f looks for cl.exe using the PATH env. variable.
+     Under Unix, #f looks for gcc and then cc.
+
+   current-extension-compiler-flags - list of strings. Under Windows,
+    the default is (list "/c" "/O2"); (list "-c" "-O2") for Unix
+
+   current-make-compile-include-strings - procedure that takes an
+    include dir and returns a list of strings for the command line.
+    Windows: "dir" -> (list "\Idir"); Unix: "dir" -> (list "-Idir")
+
+   current-make-compile-input-strings - procedure that takes an
+    input file and returns a list of strings for the command line.
+    The default is `list'.
+
+   current-make-compile-output-strings - procedure that takes an
+    output file and returns a list of strings for the command line.
+    Windows: "file"->(list "\Fofile"); Unix: "file"->(list "-o" "file")
+
+link.ss
+-------
+
+`link-extension' takes:
+   quiet? - Boolean indicating whether command should be echoed to stdout
+   input-files - A list of .o files
+   output-file - A .so/.dll file
+
+Linking parameters:
+
+   current-extension-linker - linker executable or #f. Under 
+     Windows, #f looks for cl.exe using the PATH env. variable.
+     Under Unix except AIX, #f looks for ld. Under AIX, #f looks
+     for cc.
+
+   current-extension-linker-flags - list of strings. Under Windows,
+     default is (list "/LD"). Unix default varies greatly per-platform.
+
+   current-make-link-input-strings - procedure that takes an
+     input file and returns a list of strings for the command line.
+     The default is `list'.
+
+   current-make-link-output-strings - procedure that takes an
+    output file and returns a list of strings for the command line.
+    Windows: "file"->(list "\Fefile"); Unix: "file"->(list "-o" "file")
+
+   current-standard-link-libraries - list of file paths; For
+    most platforms, the default is 
+     (list (build-path (collection-path "mzscheme" "lib") 
+                       (system-library-subpath)
+                       "mzdyn.o"))
+
+file.ss
+-------
+
+ (make-directory* dir) - makes dir, creating intermediate directoies
+   if necessary. If there is an error, and exception is raised.
+
+ (append-object-suffix s) - appends the platform-standard object
+   file suffix to s
+
+ (append-extension-suffix s) - appends the platform-standard dynamic
+   extension file suffix to s
diff --git a/collects/mzscheme/dynext/dolink.ss b/collects/mzscheme/dynext/dolink.ss
new file mode 100644
index 0000000..f6b1bda
--- /dev/null
+++ b/collects/mzscheme/dynext/dolink.ss
@@ -0,0 +1,35 @@
+
+(require-library "link.ss" "mzscheme" "dynext")
+
+; Parse arguments:
+(define a (vector->list argv))
+
+(define quiet? #f)
+
+(when (and (pair? a) (string=? (car a) "-q"))
+      (set! quiet? #t)
+      (set! a (cdr a)))
+
+(define inputs null)
+(define output #f)
+
+(let loop ([a a])
+  (unless (null? a)
+	  (if (string=? (car a) "-o")
+	      (if (null? (cdr a))
+		  (error 'dynlink "expected a filename after -o")
+		  (if output
+		      (error 'dynlink "multiple output files provided")
+		      (begin 
+			(set! output (cadr a))
+			(loop (cddr a)))))
+	      (begin
+		(set! inputs (append inputs (list (car a))))
+		(loop (cdr a))))))
+
+(when (not output)
+      (error 'dynlink "no output file specified"))
+(when (null? inputs)
+      (error 'dynlink "no input files specified"))
+
+(link-extension quiet? inputs output)
diff --git a/collects/mzscheme/dynext/file.ss b/collects/mzscheme/dynext/file.ss
new file mode 100644
index 0000000..cdd29f3
--- /dev/null
+++ b/collects/mzscheme/dynext/file.ss
@@ -0,0 +1,49 @@
+(define (make-directory* dir)
+  (let-values ([(base name dir?) (split-path dir)])
+    (when (and (string? base)
+	       (not (directory-exists? base)))
+      (make-directory* base))
+    (unless (make-directory dir)
+      (error 'make-directory* "couldn't make directory: ~s" dir))))
+
+(define (append-c-suffix s)
+  (string-append s ".c"))
+
+(define (append-constant-pool-suffix s)
+  (string-append s ".kp"))
+
+(define (append-object-suffix s)
+  (string-append
+   s
+   (case (system-type)
+     [(unix macos) ".o"]
+     [(windows) ".obj"])))
+
+(define (append-extension-suffix s)
+  (string-append
+   s
+   (case (system-type)
+     [(unix macos) ".so"]
+     [(windows) ".dll"])))
+
+(define-values (extract-base-filename/ss
+		extract-base-filename/c
+		extract-base-filename/kp
+		extract-base-filename/o)
+  (let ([mk
+	 (lambda (pat kind)
+	   (letrec ([extract-base-filename
+		     (case-lambda
+		      [(s p)
+		       (let ([m (regexp-match (format "^(.*)\\.(~a)$" pat) s)])
+			 (cond
+			  [m (cadr m)]
+			  [p (error p "not a ~a file: ~a" kind s)]
+			  [else #f]))]
+		      [(s) (extract-base-filename s #f)])])
+	     extract-base-filename))])
+    (values
+     (mk "ss|scm" "Scheme")
+     (mk "c" "C")
+     (mk "kp" "constant pool")
+     (mk "o|obj" "compiled object"))))
diff --git a/collects/mzscheme/dynext/link.ss b/collects/mzscheme/dynext/link.ss
new file mode 100644
index 0000000..bce1c8c
--- /dev/null
+++ b/collects/mzscheme/dynext/link.ss
@@ -0,0 +1,4 @@
+
+(require-library "links.ss" "mzscheme" "dynext")
+
+(invoke-open-unit/sig (require-library "linkr.ss" "mzscheme" "dynext"))
diff --git a/collects/mzscheme/dynext/linkr.ss b/collects/mzscheme/dynext/linkr.ss
new file mode 100644
index 0000000..b784559
--- /dev/null
+++ b/collects/mzscheme/dynext/linkr.ss
@@ -0,0 +1,118 @@
+(unit/sig dynext:link^ (import)
+
+ (define include-dir (collection-path "mzscheme" "include"))
+ 
+  (define current-extension-linker 
+    (make-parameter 
+     #f 
+     (lambda (v)
+       (when v 
+	     (if (and (string? v) (or (relative-path? v) (absolute-path? v)))
+		 (unless (and (file-exists? v)
+			      (memq 'execute (file-or-directory-permissions v)))
+			 (error 'current-extension-linker 
+				"linker not found or not executable: ~s" v))
+		 (raise-type-error 'current-extension-linker "pathname string or #f" v)))
+       v)))
+  
+  (define (get-windows-linker)
+    (or (find-executable-path "cl.exe" "cl.exe")))
+
+  (define (get-unix-linker)
+    (let ([s (case (string->symbol (system-library-subpath))
+	       [(rs6k-aix) "cc"]
+	       [else "ld"])])
+      (find-executable-path s s)))
+
+  (define (get-unix-link-flags)
+    (case (string->symbol (system-library-subpath))
+      [(sparc-solaris) (list "-G")]
+      [(sparc-sunos4) (list "-Bdynamic")]
+      [(i386-freebsd) (list "-Bshareable")]
+      [(rs6k-aix) (let ([version (read (car (process* "/usr/bin/uname" "-v")))])
+		    (list "-bM:SRE"
+			  (format "-bI:~a/mzscheme.exp" include-dir)
+			  (format "-bE:~a/ext.exp" include-dir)
+			  (if (= 3 version)
+			      "-e _nostart"
+			      "-bnoentry")))]
+      [(parisc-hpux) "-b"]
+      [else (list "-shared")]))
+
+  (define current-extension-linker-flags
+    (make-parameter
+     (case (system-type)
+       [(unix) (get-unix-link-flags)]
+       [(windows) (list "/LD")]
+       [(macos) null])
+     (lambda (l)
+       (unless (and (list? l) (andmap string? l))
+	       (raise-type-error 'current-extension-link-flags "list of strings" l))
+       l)))
+ 
+  (define std-library-dir (build-path (collection-path "mzscheme" "lib") (system-library-subpath)))
+  
+  (define-values (my-process* stdio-link)
+   (let-values ([(p* do-stdio) (require-library "stdio.ss" "mzscheme" "dynext")])
+     (values
+      p*
+      (lambda (start-process quiet?)
+	(do-stdio start-process quiet? (lambda (s) (error 'link-extension "~a" s)))))))
+
+  (define current-make-link-input-strings
+    (make-parameter
+     (lambda (s) (list s))
+     (lambda (p)
+       (unless (procedure-arity-includes? p 1)
+	       (raise-type-error 'current-make-link-input-strings "procedure of arity 1" p))
+       p)))
+
+  (define current-make-link-output-strings
+    (make-parameter
+     (case (system-type)
+       [(unix) (lambda (s) (list "-o" s))]
+       [(windows) (lambda (s) (list (string-append "/Fe" s)))]
+       [(macos) (lambda (s) (list "-o" s))])
+     (lambda (p)
+       (unless (procedure-arity-includes? p 1)
+	       (raise-type-error 'current-make-link-output-strings "procedure of arity 1" p))
+       p)))
+
+  (define current-standard-link-libraries
+    (make-parameter
+     (case (system-type)
+       [(unix macos) (list (build-path std-library-dir "mzdyn.o"))]
+       [(windows) (list (build-path  std-library-dir "msvc" "mzdyn.obj")
+			(build-path  std-library-dir "msvc" "mzdyn.exp"))])
+     (lambda (l)
+       (unless (and (list? l) (andmap string? l))
+	       (raise-type-error 'current-standard-link-libraries "list of strings" l))
+       l)))
+
+  (define unix/windows-link
+    (lambda (quiet? in out)
+      (let ([c (or (current-extension-linker) 
+		   (if (eq? (system-type) 'unix) 
+		       (get-unix-linker) 
+		       (get-windows-linker)))])
+	(if c
+	    (stdio-link (lambda (quiet?) 
+			  (let ([command (append (list c)
+						 (current-extension-linker-flags)
+						 (apply append (map (lambda (s) ((current-make-link-input-strings) s)) in))
+						 (current-standard-link-libraries)
+						 ((current-make-link-output-strings) out))])
+			    (unless quiet? 
+				    (printf "link-extension: ~a~n" command))
+			    (apply my-process* command)))
+			quiet?)
+	    (error 'link-extension "can't find linker")))))
+
+  (define (macos-link quiet? input-files output-file)
+   (error 'link-extension "Not yet supported for MacOS"))
+  
+  (define link-extension
+    (case (system-type)
+      [(unix windows) unix/windows-link]
+      [(macos) macos-link])))
+
diff --git a/collects/mzscheme/dynext/links.ss b/collects/mzscheme/dynext/links.ss
new file mode 100644
index 0000000..5d9e0b8
--- /dev/null
+++ b/collects/mzscheme/dynext/links.ss
@@ -0,0 +1,7 @@
+(define-signature dynext:link^
+  (link-extension
+   current-extension-linker
+   current-extension-linker-flags
+   current-make-link-input-strings
+   current-make-link-output-strings
+   current-standard-link-libraries))
diff --git a/collects/mzscheme/dynext/stdio.ss b/collects/mzscheme/dynext/stdio.ss
new file mode 100644
index 0000000..cfd870d
--- /dev/null
+++ b/collects/mzscheme/dynext/stdio.ss
@@ -0,0 +1,49 @@
+
+(values
+ (if (string=? (system-library-subpath) "rs6k-aix")
+     (letrec ([pseudo-process* 
+	       (lambda (c . args)
+		 (if (null? args)
+		     (let ([r (process* "/usr/bin/csh" "-t")])
+		       (display c (cadr r))
+		       (newline (cadr r))
+		       r)
+		     (apply pseudo-process* (string-append c " " (car args)) (cdr args))))])
+	     pseudo-process*)
+     process*)
+ 
+ (lambda (start-process quiet? error)
+   (let* ([l (start-process quiet?)]
+	  [in (car l)]
+	  [out (cadr l)]
+	  [in-error (cadddr l)]
+	  [control (cadddr (cdr l))]
+
+	  [collect-output (box "")]
+	  
+	  [make-collector
+	   (lambda (in dest box)
+	     (thread (lambda () 
+		       (let loop ()
+			 (let ([t (read-line in)])
+			   (unless (eof-object? t)
+				   (unless quiet? (fprintf (dest) "~a~n" t))
+				   (set-box! box (string-append (unbox box) 
+								(string #\newline #\space) t))
+				   (loop)))))))]
+	  [in-thread (make-collector in current-output-port collect-output)]
+	  [in-error-thread (make-collector in-error current-error-port collect-output)])
+
+     (control 'wait)
+
+     (thread-wait in-thread)
+     (thread-wait in-error-thread)
+
+     (close-input-port in)
+     (close-input-port in-error)
+     (close-output-port out)
+
+     (unless (eq? (control 'status) 'done-ok)
+	     (error (if quiet?
+			(unbox collect-output)
+			"command failed"))))))
diff --git a/collects/mzscheme/include/escheme.h b/collects/mzscheme/include/escheme.h
new file mode 100644
index 0000000..f0c442a
--- /dev/null
+++ b/collects/mzscheme/include/escheme.h
@@ -0,0 +1,34 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* This file should be included by MzScheme dynamically-loaded
+   extenstion files */
+
+#ifndef E_SCHEME_H
+#define E_SCHEME_H
+
+#define SCHEME_DIRECT_EMBEDDED 0
+
+#include "scheme.h"
+
+#ifdef CODEFRAGMENT_DYNAMIC_LOAD
+#pragma export on
+#endif
+
+extern Scheme_Object *scheme_initialize(Scheme_Env *global_env);
+
+#ifdef CODEFRAGMENT_DYNAMIC_LOAD
+#pragma export off
+#endif
+
+#endif /* ! E_SCHEME_H */
+
diff --git a/collects/mzscheme/include/ext.exp b/collects/mzscheme/include/ext.exp
new file mode 100644
index 0000000..9a09e43
--- /dev/null
+++ b/collects/mzscheme/include/ext.exp
@@ -0,0 +1,4 @@
+#!
+scheme_initialize_internal
+scheme_initialize
+scheme_reload
diff --git a/collects/mzscheme/include/mzscheme.exp b/collects/mzscheme/include/mzscheme.exp
new file mode 100644
index 0000000..f76967f
--- /dev/null
+++ b/collects/mzscheme/include/mzscheme.exp
@@ -0,0 +1,289 @@
+#!
+scheme_init_jmpup_buf
+scheme_setjmpup_relative
+scheme_longjmpup
+scheme_setjmp
+scheme_longjmp
+scheme_make_config
+scheme_branch_config
+scheme_new_param
+scheme_param_config
+scheme_register_parameter
+scheme_get_env
+scheme_current_process
+scheme_fuel_counter
+scheme_current_process_ptr
+scheme_fuel_counter_ptr
+scheme_make_namespace
+scheme_thread
+scheme_break_thread
+scheme_kill_thread
+scheme_process_block
+scheme_swap_process
+scheme_block_until
+scheme_in_main_thread
+scheme_tls_allocate
+scheme_tls_set
+scheme_tls_get
+scheme_add_namespace_option
+scheme_make_manager
+scheme_add_managed
+scheme_remove_managed
+scheme_close_managed
+scheme_signal_error
+scheme_raise_exn
+scheme_warning
+scheme_wrong_count
+scheme_case_lambda_wrong_count
+scheme_wrong_type
+scheme_wrong_return_arity
+scheme_unbound_global
+scheme_dynamic_wind
+scheme_make_type
+scheme_install_type_reader
+scheme_install_type_writer
+scheme_eof
+scheme_null
+scheme_true
+scheme_false
+scheme_void
+scheme_undefined
+scheme_tail_call_waiting
+scheme_multiple_values
+scheme_eval
+scheme_eval_multi
+scheme_eval_compiled
+scheme_eval_compiled_multi
+_scheme_eval_compiled
+_scheme_eval_compiled_multi
+scheme_apply
+scheme_apply_multi
+scheme_apply_to_list
+scheme_eval_string
+scheme_eval_string_all
+_scheme_apply_known_closed_prim
+_scheme_apply_known_closed_prim_multi
+scheme_values
+scheme_check_one_value
+scheme_tail_apply
+scheme_tail_apply_no_copy
+scheme_tail_apply_to_list
+scheme_tail_eval_expr
+scheme_set_tail_buffer_size
+scheme_force_value
+scheme_do_eval
+GC_malloc
+GC_malloc_atomic
+GC_malloc_stubborn
+GC_malloc_uncollectable
+scheme_malloc_eternal
+scheme_end_stubborn_change
+scheme_calloc
+scheme_strdup
+scheme_strdup_eternal
+scheme_malloc_fail_ok
+scheme_weak_reference
+scheme_weak_reference_indirect
+scheme_add_finalizer
+scheme_add_scheme_finalizer
+scheme_register_finalizer
+scheme_dont_gc_ptr
+scheme_gc_ptr_ok
+scheme_collect_garbage
+scheme_hash_table
+scheme_add_to_table
+scheme_change_in_table
+scheme_lookup_in_table
+scheme_bucket_from_table
+scheme_make_prim
+scheme_make_noneternal_prim
+scheme_make_closed_prim
+scheme_make_prim_w_arity
+scheme_make_folding_prim
+scheme_make_noneternal_prim_w_arity
+scheme_make_closed_prim_w_arity
+scheme_make_folding_closed_prim
+scheme_make_closure
+scheme_make_pair
+scheme_make_string
+scheme_make_sized_string
+scheme_make_string_without_copying
+scheme_alloc_string
+scheme_append_string
+scheme_make_vector
+scheme_make_integer_value
+scheme_make_integer_value_from_unsigned
+scheme_make_double
+scheme_make_float
+scheme_make_char
+scheme_make_promise
+scheme_make_promise_from_thunk
+scheme_make_sema
+scheme_post_sema
+scheme_wait_sema
+scheme_char_constants
+scheme_get_int_val
+scheme_get_unsigned_int_val
+scheme_get_proc_name
+scheme_make_bignum
+scheme_make_bignum_from_unsigned
+scheme_bignum_to_double
+scheme_bignum_from_double
+scheme_bignum_to_float
+scheme_bignum_from_float
+scheme_bignum_to_string
+scheme_read_bignum
+scheme_bignum_normalize
+scheme_double_to_int
+scheme_make_rational
+scheme_rational_to_double
+scheme_rational_from_double
+scheme_rational_to_float
+scheme_rational_from_float
+scheme_rational_normalize
+scheme_rational_numerator
+scheme_rational_denominator
+scheme_make_complex
+scheme_complex_normalize
+scheme_complex_real_part
+scheme_complex_imaginary_part
+scheme_is_exact
+scheme_is_inexact
+scheme_expand
+scheme_compile
+scheme_make_promise_value
+scheme_read
+scheme_write
+scheme_display
+scheme_write_w_max
+scheme_display_w_max
+scheme_write_string
+scheme_write_to_string
+scheme_display_to_string
+scheme_write_to_string_w_max
+scheme_display_to_string_w_max
+scheme_debug_print
+scheme_flush_output
+scheme_format
+scheme_printf
+scheme_getc
+scheme_ungetc
+scheme_char_ready
+scheme_need_wakeup
+scheme_get_chars
+scheme_tell
+scheme_output_tell
+scheme_tell_line
+scheme_close_input_port
+scheme_close_output_port
+scheme_are_all_chars_ready
+scheme_make_port_type
+scheme_make_input_port
+scheme_make_output_port
+scheme_make_file_input_port
+scheme_make_named_file_input_port
+scheme_make_file_output_port
+scheme_make_string_input_port
+scheme_make_sized_string_input_port
+scheme_make_string_output_port
+scheme_get_string_output
+scheme_get_sized_string_output
+scheme_pipe
+scheme_file_exists
+scheme_directory_exists
+scheme_expand_filename
+scheme_getcwd
+scheme_setcwd
+scheme_getdrive
+scheme_split_pathname
+scheme_build_pathname
+scheme_alloc_fdset_array
+scheme_init_fdset_array
+scheme_get_fdset
+scheme_fdzero
+scheme_fdset
+scheme_fdclr
+scheme_fdisset
+scheme_add_global
+scheme_add_global_constant
+scheme_add_global_keyword
+scheme_remove_global
+scheme_remove_global_constant
+scheme_add_global_symbol
+scheme_remove_global_symbol
+scheme_add_global_constant_symbol
+scheme_constant
+scheme_set_keyword
+scheme_make_envunbox
+scheme_lookup_global
+scheme_global_bucket
+scheme_set_global_bucket
+scheme_intern_symbol
+scheme_intern_exact_symbol
+scheme_make_symbol
+scheme_make_exact_symbol
+scheme_symbol_name
+scheme_symbol_name_and_size
+scheme_intern_type_symbol
+scheme_make_type_symbol
+scheme_make_struct_values
+scheme_make_struct_names
+scheme_make_struct_type
+scheme_make_struct_instance
+scheme_is_struct_instance
+scheme_make_class
+scheme_add_method
+scheme_add_method_w_arity
+scheme_made_class
+scheme_make_object
+scheme_make_uninited_object
+scheme_find_ivar
+scheme_is_subclass
+scheme_is_implementation
+scheme_is_interface_extension
+scheme_is_a
+scheme_get_class_name
+scheme_get_interface_name
+scheme_make_class_assembly
+scheme_create_class
+scheme_make_interface_assembly
+scheme_create_interface
+scheme_apply_generic_data
+scheme_get_generic_data
+scheme_invoke_unit
+scheme_assemble_compound_unit
+scheme_make_compound_unit
+scheme_get_unit_name
+scheme_eq
+scheme_eqv
+scheme_equal
+scheme_build_list
+scheme_list_length
+scheme_proper_list_length
+scheme_alloc_list
+scheme_map_1
+scheme_car
+scheme_cdr
+scheme_cadr
+scheme_caddr
+scheme_vector_to_list
+scheme_list_to_vector
+scheme_append
+scheme_box
+scheme_unbox
+scheme_set_box
+scheme_make_weak_box
+scheme_load
+scheme_load_extension
+scheme_register_extension_global
+scheme_get_milliseconds
+scheme_get_process_milliseconds
+scheme_rep
+scheme_banner
+scheme_version
+scheme_check_proc_arity
+scheme_secure_exceptions
+scheme_make_provided_string
+scheme_make_args_string
+scheme_no_dumps
+scheme_system_library_subpath
diff --git a/collects/mzscheme/include/scheme.h b/collects/mzscheme/include/scheme.h
new file mode 100644
index 0000000..ce41434
--- /dev/null
+++ b/collects/mzscheme/include/scheme.h
@@ -0,0 +1,1063 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#ifndef SCHEME_H
+#define SCHEME_H
+
+/* The next line is used and set during installation: */
+#define INCLUDE_WITHOUT_PATHS
+
+#ifdef INCLUDE_WITHOUT_PATHS
+# include "sconfig.h"
+#else
+# include "../sconfig.h"
+#endif
+
+#define AGRESSIVE_ZERO_FOR_GC
+#define AGRESSIVE_ZERO_TB
+
+#if SGC_STD_DEBUGGING
+# ifndef USE_SENORA_GC
+#  define USE_SENORA_GC
+# endif
+# define USE_MEMORY_TRACING 
+#endif
+
+#ifdef USE_SENORA_GC
+# define MUST_REGISTER_GLOBALS
+# undef UNIX_IMAGE_DUMPS
+#endif
+
+#ifdef USE_SINGLE_FLOATS
+# define MZ_USE_SINGLE_FLOATS
+#endif
+
+#include <stdio.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef SCHEME_DIRECT_EMBEDDED
+#define SCHEME_DIRECT_EMBEDDED 1
+#endif
+
+#ifndef MSC_IZE
+# define MSC_IZE(x) x
+#endif
+
+#ifdef SIGSET_IS_SIGNAL
+# define MZ_SIGSET(s, f) signal(s, f)
+#else
+# define MZ_SIGSET(s, f) sigset(s, f)
+#endif
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+typedef short Scheme_Type;
+
+typedef struct Scheme_Bucket
+{
+  Scheme_Type type;
+  void *val;
+  char *key;
+} Scheme_Bucket;
+
+typedef struct Scheme_Hash_Table
+{
+  Scheme_Type type;
+  int size, count, step;
+  Scheme_Bucket **buckets;
+  char has_constants, forever, weak;
+  void (*make_hash_indices)(void *v, int *h1, int *h2);
+  int (*compare)(void *v1, void *v2);
+#ifdef MZ_REAL_THREADS
+  void *mutex;
+#endif
+} Scheme_Hash_Table;
+
+/* Hash tablekey types, used with scheme_hash_table */
+enum {
+  SCHEME_hash_string,
+  SCHEME_hash_ptr,
+  SCHEME_hash_weak_ptr
+};
+
+typedef struct Scheme_Env
+{
+  Scheme_Type type; /* scheme_namespace_type */
+  Scheme_Hash_Table *globals;
+  Scheme_Hash_Table *loaded_libraries;
+  struct Scheme_Object *nonempty_cond; /* hack used when !scheme_allow_cond_auto_else */
+  struct Scheme_Comp_Env *init; /* initial compilation environment */
+} Scheme_Env;
+
+typedef struct Scheme_Object *
+(Scheme_Prim)(int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object *
+(Scheme_Closed_Prim)(void *d, int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object *
+(Scheme_Method_Prim)(struct Scheme_Object *o, 
+		     int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object
+{
+  Scheme_Type type; /* Anything that starts with a type field
+		       can be a Scheme_Object */
+  union
+    {
+      struct { char *string_val; int tag_val; } str_val;
+      struct { void *ptr1, *ptr2; } two_ptr_val;
+      struct { int int1; int int2; } two_int_val;
+      struct { void *ptr; int pint; } ptr_int_val;
+      struct { void *ptr; long pint; } ptr_long_val;
+      struct {
+	Scheme_Closed_Prim *f;
+	void *d; } clsd_prim_val;
+      struct { struct Scheme_Object *car, *cdr; } pair_val;
+      struct { struct Scheme_Env *env; struct Scheme_Object *code; } closure_val;
+      struct { short len; short *vec; } svector_val;
+      struct Scheme_Debugging_Info *debug_val;
+    } u;
+} Scheme_Object;
+
+typedef struct {
+  Scheme_Type type;
+  union {
+    char char_val;
+    Scheme_Object *ptr_value;
+    long int_val;
+    Scheme_Object *ptr_val;
+    Scheme_Prim *prim_val;
+  } u;
+} Scheme_Small_Object;  
+
+typedef struct {
+  Scheme_Type type;
+  double double_val;
+} Scheme_Double;
+
+#ifdef MZ_USE_SINGLE_FLOATS
+typedef struct {
+  Scheme_Type type;
+  float float_val;
+} Scheme_Float;
+#endif
+
+#define SCHEME_PRIM_IS_FOLDING 1
+#define SCHEME_PRIM_IS_PRIMITIVE 2
+#define SCHEME_PRIM_IS_STRUCT_PROC 4
+#define SCHEME_PRIM_IS_STRUCT_SETTER 8
+#define SCHEME_PRIM_IS_PARAMETER 16
+#define SCHEME_PRIM_IS_STRUCT_GETTER 32
+#define SCHEME_PRIM_IS_STRUCT_PRED 64
+#define SCHEME_PRIM_IS_STRUCT_CONSTR 128
+#define SCHEME_PRIM_IS_MULTI_RESULT 256
+#define SCHEME_PRIM_IS_GENERIC 512
+#define SCHEME_PRIM_IS_USER_PARAMETER 1024
+
+typedef struct {
+  Scheme_Type type;
+  short flags; /* keep flags at same place as in closed */
+  Scheme_Prim *prim_val;
+  const char *name;
+  short mina, maxa;
+} Scheme_Primitive_Proc;
+
+typedef struct {
+  Scheme_Primitive_Proc p;
+  short minr, maxr;
+} Scheme_Prim_W_Result_Arity;
+
+typedef struct {
+  Scheme_Type type;
+  short flags; /* keep flags at same place as in unclosed */
+  Scheme_Closed_Prim *prim_val;
+  void *data;
+  const char *name;
+  short mina, maxa; /* mina == -2 => maxa is negated case count and
+		       record is a Scheme_Closed_Case_Primitive_Proc */
+} Scheme_Closed_Primitive_Proc;
+
+typedef struct {
+  Scheme_Closed_Primitive_Proc p;
+  short minr, maxr;
+} Scheme_Closed_Prim_W_Result_Arity;
+
+typedef struct {
+  Scheme_Closed_Primitive_Proc p;
+  short *cases;
+} Scheme_Closed_Case_Primitive_Proc;
+
+#define _scheme_fill_prim_closure(rec, cfunc, dt, nm, amin, amax) \
+  ((rec)->type = scheme_closed_prim_type, \
+   (rec)->prim_val = cfunc, \
+   (rec)->data = (void *)(dt), \
+   (rec)->name = nm, \
+   (rec)->mina = amin, \
+   (rec)->maxa = amax, \
+   rec)
+   
+#define _scheme_fill_prim_case_closure(rec, cfunc, dt, nm, ccount, cses) \
+  ((rec)->p.type = scheme_closed_prim_type, \
+   (rec)->p.prim_val = cfunc, \
+   (rec)->p.data = (void *)(dt), \
+   (rec)->p.name = nm, \
+   (rec)->p.mina = -2, \
+   (rec)->p.maxa = -(ccount), \
+   (rec)->cases = cses, \
+   rec)
+
+typedef struct Scheme_Debugging_Info {
+  Scheme_Object *src;
+} Scheme_Debugging_Info;
+
+typedef struct Scheme_Sema {
+  Scheme_Type type;
+#ifdef MZ_REAL_THREADS
+  void *sema;
+#else
+  long value;  
+#endif
+} Scheme_Sema;
+
+typedef struct Scheme_Symbol {
+  Scheme_Type type;
+  short len;
+  char s[1];
+} Scheme_Symbol;
+
+typedef struct Scheme_Vector {
+  Scheme_Type type;
+  int size;
+  Scheme_Object *els[1];
+} Scheme_Vector;
+
+typedef void Scheme_Close_Manager_Client(Scheme_Object *o, void *data);
+typedef struct Scheme_Manager *Scheme_Manager_Reference;
+
+typedef struct Scheme_Manager {
+  Scheme_Type type;
+  short count, alloc;
+  Scheme_Object ***boxes;
+  Scheme_Manager_Reference **mrefs;
+  Scheme_Close_Manager_Client **closers;
+  void **data;
+
+  /* atomic indirections: */
+  struct Scheme_Manager **parent;
+  struct Scheme_Manager **sibling;
+  struct Scheme_Manager **children;
+} Scheme_Manager;
+
+typedef struct Scheme_Input_Port
+{
+  Scheme_Type type;
+  short closed;
+  Scheme_Object *sub_type;
+  Scheme_Manager_Reference *mref;
+  void *port_data;
+  int (*getc_fun) (struct Scheme_Input_Port *port);
+  int (*char_ready_fun) (struct Scheme_Input_Port *port);
+  void (*close_fun) (struct Scheme_Input_Port *port);
+  void (*need_wakeup_fun)(struct Scheme_Input_Port *, void *);
+  Scheme_Object *read_handler;
+  char *name;
+  char *ungotten;
+  int ungotten_count, ungotten_allocated;
+  long position, lineNumber, charsSinceNewline;
+  int eoffound;
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *sema;
+#endif
+} Scheme_Input_Port;
+
+typedef struct Scheme_Output_Port
+{
+  Scheme_Type type;
+  short closed;
+  Scheme_Object *sub_type;
+  Scheme_Manager_Reference *mref;
+  void *port_data;
+  void (*write_string_fun)(char *str, long len, struct Scheme_Output_Port *);
+  void (*close_fun) (struct Scheme_Output_Port *);
+  long pos;
+  Scheme_Object *display_handler;
+  Scheme_Object *write_handler;
+  Scheme_Object *print_handler;
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *sema;
+#endif
+} Scheme_Output_Port;
+
+typedef struct {
+  Scheme_Type type;
+  struct Scheme_Object *sclass;
+  /* The following fields are only here for instances of classes
+     created with scheme_make_class(): */
+  void *primdata;
+  short primflag;
+  short inited;
+} Scheme_Class_Object;
+
+typedef struct Scheme_Unit {
+  Scheme_Type type;        /* scheme_unit_type */
+  short num_imports;       /* num expected import args */
+  short num_exports;       /* num exported vars */
+  Scheme_Object **exports; /* names of exported */
+  Scheme_Object **export_debug_names; /* internal names; NULL => no debugging */
+  Scheme_Object *(*init_func)(Scheme_Object **boxes, Scheme_Object **anchors,
+			      struct Scheme_Unit *m,
+			      void *debug_request);
+  Scheme_Object *data;
+} Scheme_Unit;
+
+typedef void Scheme_Instance_Init_Proc(Scheme_Object **init_boxes,
+				       Scheme_Object **extract_boxes,
+				       Scheme_Object *super_init,
+				       int argc,
+				       Scheme_Object **argv,
+				       Scheme_Object *instance,
+				       void *data);
+
+/* Like setjmp & longjmp, but you can jmp to a deeper stack position */
+/* Intialize a Scheme_Jumpup_Buf record before using it */
+typedef struct Scheme_Jumpup_Buf {
+  void *stack_from, *stack_copy;
+  long stack_size, stack_max_size;
+  struct Scheme_Jumpup_Buf *cont;
+  jmp_buf buf;
+} Scheme_Jumpup_Buf;
+
+enum {
+  MZCONFIG_ENV,
+  MZCONFIG_INPUT_PORT,
+  MZCONFIG_OUTPUT_PORT,
+  MZCONFIG_ERROR_PORT,
+
+  MZCONFIG_USER_BREAK_POLL_HANDLER,
+  MZCONFIG_ENABLE_BREAK,
+  MZCONFIG_ENABLE_EXCEPTION_BREAK,
+
+  MZCONFIG_ERROR_DISPLAY_HANDLER,
+  MZCONFIG_ERROR_PRINT_VALUE_HANDLER,
+
+  MZCONFIG_EXIT_HANDLER,
+
+  MZCONFIG_EXN_HANDLER,
+  MZCONFIG_DEBUG_INFO_HANDLER,
+
+  MZCONFIG_EVAL_HANDLER,
+  MZCONFIG_LOAD_HANDLER,
+
+  MZCONFIG_PRINT_HANDLER,
+  MZCONFIG_PROMPT_READ_HANDLER,
+
+  MZCONFIG_CAN_READ_GRAPH,
+  MZCONFIG_CAN_READ_COMPILED,
+  MZCONFIG_CAN_READ_BOX,
+  MZCONFIG_CAN_READ_TYPE_SYMBOL,
+  MZCONFIG_CAN_READ_PIPE_QUOTE,
+
+  MZCONFIG_PRINT_GRAPH,
+  MZCONFIG_PRINT_STRUCT,
+  MZCONFIG_PRINT_BOX,
+
+  MZCONFIG_CASE_SENS,
+  MZCONFIG_SQUARE_BRACKETS_ARE_PARENS,
+  MZCONFIG_CURLY_BRACES_ARE_PARENS,
+
+  MZCONFIG_ERROR_PRINT_WIDTH,
+
+  MZCONFIG_CONFIG_BRANCH_HANDLER,
+
+  MZCONFIG_WILL_EXECUTOR,
+
+  MZCONFIG_ALLOW_SET_UNDEFINED,
+  MZCONFIG_COND_AUTO_ELSE,
+
+  MZCONFIG_MANAGER,
+
+  MZCONFIG_REQ_LIB_USE_COMPILED,
+
+  MZCONFIG_LOAD_DIRECTORY,
+
+  MZCONFIG_COLLECTION_PATHS,
+
+  MZCONFIG_PORT_PRINT_HANDLER,
+
+  MZCONFIG_REQUIRE_COLLECTION,
+
+  MZCONFIG_LOAD_EXTENSION_HANDLER,
+
+  __MZCONFIG_BUILTIN_COUNT__
+};
+
+
+typedef struct Scheme_Config {
+  Scheme_Type type;
+  Scheme_Hash_Table *extensions;
+
+  /* For sharing as-yet uncreated parameters: */
+  struct Scheme_Config **parent;
+  struct Scheme_Config **child;
+  struct Scheme_Config **sibling;
+
+  Scheme_Object **configs[1];
+} Scheme_Config;
+
+#define scheme_set_param(c, pos, o) (*((c)->configs[pos]) = o)
+#define scheme_get_param(c, pos) (*((c)->configs[pos]))
+
+typedef struct Scheme_Saved_Stack {
+  Scheme_Object **runstack_start;
+  Scheme_Object **runstack;
+  long runstack_size;
+  struct Scheme_Saved_Stack *prev;
+} Scheme_Saved_Stack;
+
+typedef struct Scheme_Process {
+  Scheme_Type type;
+
+  jmp_buf error_buf;
+  int jumping_to_continuation;
+
+  Scheme_Config *config;
+
+  Scheme_Object **runstack;
+  Scheme_Object **runstack_start;
+  long runstack_size;
+  Scheme_Saved_Stack *runstack_saved;
+  Scheme_Object **runstack_tmp_keep;
+
+  long engine_weight;
+
+  void *stack_start, *stack_end;
+  Scheme_Jumpup_Buf jmpup_buf;
+#if defined(USE_WIN32_THREADS) || defined(SPAWN_NEW_STACK)
+  void *stack_current;
+#ifdef NEW_STACK_VIA_THREAD
+  void *threadinfo;
+#endif
+#endif
+#ifdef USE_WIN32_THREADS
+  void *thread;
+  void *sem;
+#endif
+#ifdef MZ_REAL_THREADS
+  void *thread;
+#endif  
+
+  void *cc_start;
+  long *cc_ok;
+  struct Scheme_Dynamic_Wind *dw;
+
+  struct Scheme_Process *next;
+
+  int running;
+#ifdef ERROR_ON_OVERFLOW
+  int stack_overflow;
+#endif
+
+  float sleep_time; /* blocker has starting sleep time */
+  int block_descriptor;
+  Scheme_Object *blocker; /* semaphore or port */
+  int (*block_check)(Scheme_Object *blocker);
+  void (*block_needs_wakeup)(Scheme_Object *blocker, void *fds);
+  int ran_some;
+
+#ifndef ERROR_ON_OVERFLOW
+  struct Scheme_Overflow *overflow;
+  jmp_buf overflow_buf;
+#endif
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  short wd_inited;
+  short vrefnum;
+  long dirid;
+#else
+  char *working_directory;
+  int wd_len;
+#endif
+
+  struct Scheme_Comp_Env *current_local_env;
+
+  Scheme_Object *error_escape_proc; /* Per-thread paramaterization */
+
+  /* These are used to lock in values during `read': */
+  char quick_can_read_type_symbol;
+  char quick_can_read_compiled;
+  char quick_can_read_pipe_quote;
+  char quick_can_read_box;
+  char quick_can_read_graph;
+  char quick_case_sens;
+  char quick_square_brackets_are_parens;
+  char quick_curly_braces_are_parens;
+
+  /* Used during `display' and `write': */
+  char *print_buffer;
+  long print_position;
+  long print_allocated;
+  long print_maxlen;
+  Scheme_Object *print_port;
+  jmp_buf print_escape;
+
+  char exn_raised;
+  char error_invoked;
+  char err_val_str_invoked;
+
+#ifndef ERROR_ON_OVERFLOW
+  Scheme_Object *(*overflow_k)(void);
+  Scheme_Object *overflow_reply;
+  Scheme_Jumpup_Buf overflow_cont;
+#endif
+
+  Scheme_Object **tail_buffer;
+  int tail_buffer_size;
+
+  union {
+    struct {
+      Scheme_Object *wait_expr;
+    } eval;
+    struct {
+      Scheme_Object *tail_rator;
+      Scheme_Object **tail_rands;
+      int tail_num_rands;
+    } apply;
+    struct {
+      Scheme_Object **array;
+      int count;
+    } multiple;
+    struct {
+      void *p1, *p2, *p3, *p4;
+      long i1, i2;
+    } k;
+  } ku;
+
+  short checking_break;
+  short external_break;
+
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *done_sema;
+  long fuel_counter;
+#define scheme_fuel_counter (scheme_current_process->fuel_counter)
+#define scheme_stack_boundary ((unsigned long)scheme_current_process->stack_end)
+#endif
+
+  Scheme_Object *list_stack;
+  int list_stack_pos;
+
+  long block_start_sleep;
+
+#ifdef AGRESSIVE_ZERO_TB
+  int tail_buffer_set;
+#endif
+
+  void (*on_kill)(struct Scheme_Process *p);
+  void *kill_data;
+
+  void **user_tls;
+  int user_tls_size;
+
+  Scheme_Manager_Reference *mref;
+} Scheme_Process;
+
+/* Type readers & writers for compiled code data */
+typedef Scheme_Object *(*Scheme_Type_Reader)(Scheme_Object *list);
+typedef Scheme_Object *(*Scheme_Type_Writer)(Scheme_Object *obj);
+
+/* This file defines all the built-in types */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "stypes.h"
+#else
+#include "../src/stypes.h"
+#endif
+
+/* This file includes the MZEXN constants */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schexn.h"
+#else
+#include "../src/schexn.h"
+#endif
+
+#if defined(USE_FAR_MZ_FDCALLS) || defined(DETECT_WIN32_CONSOLE_STDIN) || defined(WINDOWS_PROCESSES)
+# define MZ_GET_FDSET(p, n) scheme_get_fdset(p, n)
+#else
+# define MZ_GET_FDSET(p, n) ((void *)(((fd_set *)p) + n))
+#endif
+
+#ifdef USE_FAR_MZ_FDCALLS
+# define MZ_FD_ZERO(p) scheme_fdzero(p)
+# define MZ_FD_SET(n, p) scheme_fdset(p, n)
+# define MZ_FD_CLR(n, p) scheme_fdclr(p, n)
+# define MZ_FD_ISSET(n, p) scheme_fdisset(p, n)
+#else
+# define MZ_FD_ZERO(p) FD_ZERO(p)
+# define MZ_FD_SET(n, p) FD_SET(n, p)
+# define MZ_FD_CLR(n, p) FD_CLR(n, p)
+# define MZ_FD_ISSET(n, p) FD_ISSET(n, p)
+#endif
+
+/* Exploit the fact that these should never be dereferenced: */
+#ifndef FIRST_TWO_BYTES_ARE_LEGAL_ADDRESSES
+# define MZ_EVAL_WAITING_CONSTANT ((Scheme_Object *)0x2)
+# define MZ_APPLY_WAITING_CONSTANT ((Scheme_Object *)0x4)
+# define MZ_MULTIPLE_VALUES_CONSTANT ((Scheme_Object *)0x6)
+#endif
+
+#ifdef MZ_EVAL_WAITING_CONSTANT
+# define SCHEME_EVAL_WAITING MZ_EVAL_WAITING_CONSTANT
+# define SCHEME_TAIL_CALL_WAITING MZ_APPLY_WAITING_CONSTANT
+# define SCHEME_MULTIPLE_VALUES MZ_MULTIPLE_VALUES_CONSTANT
+#else
+# define SCHEME_TAIL_CALL_WAITING scheme_tail_call_waiting
+# define SCHEME_EVAL_WAITING scheme_eval_waiting
+# define SCHEME_MULTIPLE_VALUES scheme_multiple_values
+#endif
+
+#define FAST_NUMBERS /* Force fast numbers */
+
+/* Value-access macros */
+#ifdef FAST_NUMBERS
+#define SCHEME_TYPE(obj)     (SCHEME_INTP(obj)?(Scheme_Type)scheme_integer_type:(obj)->type)
+#define _SCHEME_TYPE(obj) ((obj)->type) /* unsafe version */
+#else
+#define SCHEME_TYPE(obj)     ((obj)->type)
+#define _SCHEME_TYPE SCHEME_TYPE
+#endif
+
+
+#define SCHEME_CHAR_VAL(obj) (((Scheme_Small_Object *)(obj))->u.char_val)
+#ifdef FAST_NUMBERS
+#define SCHEME_INT_VAL(obj)  (((long)(obj))>>1)
+#else
+#define SCHEME_INT_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.int_val)
+#endif
+#define SCHEME_DBL_VAL(obj)  (((Scheme_Double *)(obj))->double_val)
+#ifdef MZ_USE_SINGLE_FLOATS
+# define SCHEME_FLT_VAL(obj)  (((Scheme_Float *)(obj))->float_val)
+# define SCHEME_FLOAT_VAL(obj) (SCHEME_DBLP(obj) ? SCHEME_DBL_VAL(obj) : SCHEME_FLT_VAL(obj))
+#else
+# define SCHEME_FLT_VAL SCHEME_DBL_VAL
+# define SCHEME_FLOAT_VAL SCHEME_DBL_VAL
+#endif
+#define SCHEME_STR_VAL(obj)  ((obj)->u.str_val.string_val)
+#define SCHEME_STRTAG_VAL(obj)  ((obj)->u.str_val.tag_val)
+#define SCHEME_STRLEN_VAL(obj)  ((obj)->u.str_val.tag_val)
+#define SCHEME_SYM_VAL(obj)  (((Scheme_Symbol *)(obj))->s)
+#define SCHEME_SYM_LEN(obj)  (((Scheme_Symbol *)(obj))->len)
+#define SCHEME_TSYM_VAL(obj)  (SCHEME_SYM_VAL(SCHEME_PTR_VAL(obj)))
+#define SCHEME_BOX_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.ptr_val)
+#define SCHEME_PTR_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.ptr_val)
+#define SCHEME_PTR1_VAL(obj) ((obj)->u.two_ptr_val.ptr1)
+#define SCHEME_PTR2_VAL(obj) ((obj)->u.two_ptr_val.ptr2)
+#define SCHEME_IPTR_VAL(obj) ((obj)->u.ptr_int_val.ptr)
+#define SCHEME_LPTR_VAL(obj) ((obj)->u.ptr_long_val.ptr)
+#define SCHEME_INT1_VAL(obj) ((obj)->u.two_int_val.int1)
+#define SCHEME_INT2_VAL(obj) ((obj)->u.two_int_val.int2)
+#define SCHEME_PINT_VAL(obj) ((obj)->u.ptr_int_val.pint)
+#define SCHEME_PLONG_VAL(obj) ((obj)->u.ptr_long_val.pint)
+#define SCHEME_PRIM(obj)     (((Scheme_Primitive_Proc *)(obj))->prim_val)
+#define SCHEME_CLSD_PRIM(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->prim_val)
+#define SCHEME_CLSD_PRIM_DATA(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->data)
+#define SCHEME_CAR(obj)      ((obj)->u.pair_val.car)
+#define SCHEME_CDR(obj)      ((obj)->u.pair_val.cdr)
+#define SCHEME_VEC_SIZE(obj) (((Scheme_Vector *)(obj))->size)
+#define SCHEME_VEC_ELS(obj)  (((Scheme_Vector *)(obj))->els)
+#define SCHEME_VEC_BASE   SCHEME_VEC_ELS
+#define SCHEME_CLOS_ENV(obj) ((obj)->u.closure_val.env)
+#define SCHEME_CLOS_CODE(obj) ((obj)->u.closure_val.code)
+#define SCHEME_DEBUG(obj)    ((obj)->u.debug_val)
+#define SCHEME_OBJ_CLASS(obj) ((Scheme_Object *)((Scheme_Class_Object *)(obj))->sclass)
+#define SCHEME_OBJ_DATA(obj)  (((Scheme_Class_Object *)(obj))->primdata)
+#define SCHEME_OBJ_FLAG(obj)  (((Scheme_Class_Object *)(obj))->primflag)
+#define SCHEME_INPORT_VAL(obj) (((Scheme_Input_Port)(obj))->port_data)
+#define SCHEME_OUTPORT_VAL(obj) (((Scheme_Output_Port)(obj))->port_data)
+#define SCHEME_VAR_BUCKET(obj) ((Scheme_Bucket *)(obj))
+#define SCHEME_ENVBOX_VAL(obj)  (*((Scheme_Object **)(obj)))
+
+#define SCHEME_ASSERT(expr,msg) ((expr) ? 1 : (scheme_signal_error(msg), 0))
+
+#if !SCHEME_DIRECT_EMBEDDED
+#ifdef MZ_REAL_THREADS
+#define scheme_current_process (scheme_get_current_process())
+#else
+#ifdef LINK_EXTENSIONS_BY_TABLE
+#define scheme_current_process (*scheme_current_process_ptr)
+#endif
+#endif
+#endif
+
+#define scheme_eval_wait_expr (scheme_current_process->ku.eval.wait_expr)
+#define scheme_tail_rator (scheme_current_process->ku.apply.tail_rator)
+#define scheme_tail_num_rands (scheme_current_process->ku.apply.tail_num_rands)
+#define scheme_tail_rands (scheme_current_process->ku.apply.tail_rands)
+#define scheme_overflow_k (scheme_current_process->overflow_k)
+#define scheme_overflow_reply (scheme_current_process->overflow_reply)
+#define scheme_overflow_cont (scheme_current_process->overflow_cont)
+
+#define scheme_error_buf (scheme_current_process->error_buf)
+#define scheme_jumping_to_continuation (scheme_current_process->jumping_to_continuation)
+#define scheme_config (scheme_current_process->config)
+
+#define scheme_multiple_count (scheme_current_process->ku.multiple.count)
+#define scheme_multiple_array (scheme_current_process->ku.multiple.array)
+
+#define scheme_setjmpup(b, s) scheme_setjmpup_relative(b, s, NULL)
+
+#ifdef MZ_REAL_THREADS
+#define scheme_do_eval(r,n,e,f) scheme_do_eval_w_process(r,n,e,f,scheme_current_process)
+#else
+#define scheme_do_eval_w_process(r,n,e,f,p) scheme_do_eval(r,n,e,f)
+#endif
+#ifdef MZ_REAL_THREADS
+#define scheme_apply(r,n,a) scheme_apply_wp(r,n,a,scheme_current_process)
+#define scheme_apply_multi(r,n,a) scheme_apply_multi_wp(r,n,a,scheme_current_process)
+#else
+#define scheme_apply_wp(r,n,a,p) scheme_apply(r,n,a)
+#define scheme_apply_multi_wp(r,n,a,p) scheme_apply_multi(r,n,a)
+#endif
+
+#define _scheme_apply(r,n,rs) scheme_do_eval(r,n,rs,1)
+#define _scheme_apply_multi(r,n,rs) scheme_do_eval(r,n,rs,-1)
+#define _scheme_apply_wp(r,n,rs,p) scheme_do_eval_w_process(r,n,rs,1,p)
+#define _scheme_apply_multi_wp(r,n,rs,p) scheme_do_eval_w_process(r,n,rs,-1,p)
+#define _scheme_tail_apply scheme_tail_apply
+#define _scheme_tail_apply_wp scheme_tail_apply_wp
+
+#define _scheme_tail_eval scheme_tail_eval
+#define _scheme_tail_eval_wp scheme_tail_eval_wp
+
+#define _scheme_direct_apply_primitive_multi(prim, argc, argv) \
+    (((Scheme_Primitive_Proc *)prim)->prim_val(argc, argv))
+#define _scheme_direct_apply_primitive(prim, argc, argv) \
+    scheme_check_one_value(_scheme_direct_apply_primitive_multi(prim, argc, argv))
+#define _scheme_direct_apply_closed_primitive_multi(prim, argc, argv) \
+    (((Scheme_Closed_Primitive_Proc *)prim)->prim_val(((Scheme_Closed_Primitive_Proc *)prim)->data, argc, argv))
+#define _scheme_direct_apply_closed_primitive(prim, argc, argv) \
+    scheme_check_one_value(_scheme_direct_apply_closed_primitive_multi(prim, argc, argv))
+
+#define _scheme_force_value(v) ((v == SCHEME_TAIL_CALL_WAITING) ? scheme_force_value(v) : v)
+
+#ifdef AGRESSIVE_ZERO_TB
+#define scheme_tail_apply_buffer_wp(n, p) ((p)->tail_buffer_set = n, (p)->tail_buffer)
+#else
+#define scheme_tail_apply_buffer_wp(n, p) ((p)->tail_buffer)
+#endif
+#define scheme_tail_apply_buffer(n) scheme_tail_apply_buffer_wp(n, scheme_current_process)
+
+#define _scheme_tail_apply_no_copy_wp_tcw(f, n, args, p, tcw) (p->ku.apply.tail_rator = f, p->ku.apply.tail_rands = args, p->ku.apply.tail_num_rands = n, tcw)
+#define _scheme_tail_apply_no_copy_wp(f, n, args, p) _scheme_tail_apply_no_copy_wp_tcw(f, n, args, p, SCHEME_TAIL_CALL_WAITING)
+#define _scheme_tail_apply_no_copy(f, n, args) _scheme_tail_apply_no_copy_wp(f, n, args, scheme_current_process)
+
+#ifndef MZ_REAL_THREADS
+#define scheme_process_block_w_process(t,p) scheme_process_block(t)
+#else
+#define scheme_process_block(t) scheme_process_block_w_process(t,scheme_current_process)
+#endif
+
+#if !SCHEME_DIRECT_EMBEDDED
+#ifndef MZ_REAL_THREADS
+#ifdef LINK_EXTENSIONS_BY_TABLE
+#define scheme_fuel_counter (*scheme_fuel_counter_ptr)
+#endif
+#endif
+#endif
+
+#ifdef MZ_REAL_THREADS
+#define _scheme_check_for_break_wp(penalty, p) \
+   { if (((p)->fuel_counter -= penalty) <= 0) scheme_process_block_w_process(0, p); }
+#else
+#define _scheme_check_for_break_wp(penalty, p) \
+   { if ((scheme_fuel_counter -= penalty) <= 0) scheme_process_block_w_process(0, p); }
+#endif
+#define _scheme_check_for_break(penalty) _scheme_check_for_break_wp(penalty, scheme_current_process)
+
+#if SCHEME_DIRECT_EMBEDDED
+extern Scheme_Object *scheme_eval_waiting;
+#define scheme_tail_eval(obj) \
+ (scheme_eval_wait_expr = obj, SCHEME_EVAL_WAITING)
+#endif
+
+#define scheme_break_waiting(p) (p->external_break)
+
+/* Allocation */
+#define scheme_alloc_object() \
+   ((Scheme_Object *) scheme_malloc_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_small_object() \
+   ((Scheme_Object *) scheme_malloc_tagged(sizeof(Scheme_Small_Object)))
+#define scheme_alloc_stubborn_object() \
+   ((Scheme_Object *) scheme_malloc_stubborn_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_stubborn_small_object() \
+   ((Scheme_Object *) scheme_malloc_stubborn_tagged(sizeof(Scheme_Small_Object)))
+#define scheme_alloc_eternal_object() \
+   ((Scheme_Object *) scheme_malloc_eternal_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_eternal_small_object() \
+   ((Scheme_Object *) scheme_malloc_eternal_tagged(sizeof(Scheme_Small_Object)))
+
+#ifdef SCHEME_NO_GC
+void *scheme_malloc(size_t size);
+#define scheme_malloc_atomic scheme_malloc
+#define scheme_malloc_stubborn scheme_malloc
+#define scheme_malloc_uncollectable scheme_malloc
+#else
+#define scheme_malloc GC_malloc
+#define scheme_malloc_atomic GC_malloc_atomic
+#define scheme_malloc_stubborn GC_malloc_stubborn
+#define scheme_malloc_uncollectable GC_malloc_uncollectable
+#endif
+
+#ifdef USE_MEMORY_TRACING
+#define USE_TAGGED_ALLOCATION
+#define MEMORY_COUNTING_ON
+#endif
+
+#ifdef USE_TAGGED_ALLOCATION
+extern void *scheme_malloc_tagged(size_t);
+extern void *scheme_malloc_atomic_tagged(size_t);
+extern void *scheme_malloc_stubborn_tagged(size_t);
+extern void *scheme_malloc_eternal_tagged(size_t);
+extern void *scheme_malloc_uncollectable_tagged(size_t);
+extern void *scheme_malloc_envunbox(size_t);
+#else
+#define scheme_malloc_tagged scheme_malloc
+#define scheme_malloc_atomic_tagged scheme_malloc_atomic
+#define scheme_malloc_stubborn_tagged scheme_malloc_stubborn
+#define scheme_malloc_eternal_tagged scheme_malloc_eternal
+#define scheme_malloc_uncollectable_tagged scheme_malloc_uncollectable
+#define scheme_malloc_envunbox scheme_malloc
+#endif
+
+#ifdef FAST_NUMBERS
+#define scheme_make_integer(i) ((Scheme_Object *)((((long)i) << 1) | 0x1))
+#else
+#define scheme_make_integer scheme_make_integer_value
+#endif
+#define scheme_make_character(ch) (scheme_char_constants[(unsigned char)(ch)])
+
+#define scheme_new_frame(n) scheme_new_special_frame(n, 0)
+#define scheme_extend_env(f, e) (f->basic.next = e, f)
+#define scheme_next_frame(e) ((e)->basic.next)
+#define scheme_settable_frame(f, s) ((f)->basic.has_set_bang = (s))
+#define scheme_get_frame_settable(f) ((f)->basic.has_set_bang)
+#define scheme_get_binding(f, n) ((f)->values[n])
+
+#define SNF_FOR_TS 0x1
+#define SNF_PIPE_QUOTE 0x2
+#define SNF_NO_PIPE_QUOTE 0x4
+
+#if SCHEME_DIRECT_EMBEDDED
+
+#if defined(_IBMR2)
+extern long scheme_stackbottom;
+#endif
+
+extern int scheme_defining_primitives;
+
+/* These flags must be set before MzScheme is started: */
+extern int scheme_case_sensitive; /* Defaults to 0 */
+extern int scheme_constant_builtins; /* Defaults to 0 */
+extern int scheme_no_keywords; /* Defaults to 0 */
+extern int scheme_allow_set_undefined; /* Defaults to 0 */
+extern int scheme_escape_continuations_only; /* Defaults to 0 */
+extern int scheme_secure_primitive_exn; /* Defaults to 0 */
+extern int scheme_allow_cond_auto_else; /* Defaults to 1 */
+extern int scheme_square_brackets_are_parens; /* Defaults to 1 */
+extern int scheme_curly_braces_are_parens; /* Defaults to 1 */
+extern int scheme_hash_percent_syntax_only; /* Defaults to 0 */
+
+#ifdef MZ_REAL_THREADS
+Scheme_Process *scheme_get_current_process();
+#define scheme_current_process (SCHEME_GET_CURRENT_PROCESS())
+#else
+extern Scheme_Process *scheme_current_process;
+#endif
+extern Scheme_Process *scheme_first_process;
+
+/* Set these global hooks: */
+extern void (*scheme_exit)(int v);
+extern void (*scheme_console_printf)(char *str, ...);
+extern void (*scheme_sleep)(float seconds, void *fds);
+extern void (*scheme_notify_multithread)(int on);
+extern void (*scheme_wakeup_on_input)(void *fds);
+extern int (*scheme_check_for_break)(void);
+#ifdef USE_WIN32_THREADS
+extern void (*scheme_suspend_main_thread)(void);
+int scheme_set_in_main_thread(void);
+void scheme_restore_nonmain_thread(void);
+#endif
+#ifdef MAC_FILE_SYSTEM
+extern long scheme_creator_id;
+#endif
+extern void *(*scheme_get_sema_callback_context)(void);
+
+extern Scheme_Object *(*scheme_make_stdin)(void);
+extern Scheme_Object *(*scheme_make_stdout)(void);
+extern Scheme_Object *(*scheme_make_stderr)(void);
+
+/* Initialization */
+Scheme_Env *scheme_basic_env(void);
+
+void scheme_check_threads(void);
+void *scheme_check_sema_callbacks(int (*)(void *, void*), void *, int check_only);
+void scheme_remove_sema_callbacks(int (*)(void *, void*), void *);
+void scheme_wake_up(void);
+
+/* image dump enabling startup: */
+int scheme_image_main(int argc, char **argv);
+extern int (*scheme_actual_main)(int argc, char **argv);
+
+/* All functions & global constants prototyped here */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemef.h"
+#else
+#include "../src/schemef.h"
+#endif
+
+#else
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+/* Constants and function prototypes as function pointers in a struct: */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemex.h"
+#else
+#include "../src/schemex.h"
+#endif
+
+extern Scheme_Extension_Table *scheme_extension_table;
+
+/* Macro mapping names to record access */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemexm.h"
+#else
+#include "../src/schemexm.h"
+#endif
+
+#else
+
+/* Not LINK_EXTENSIONS_BY_TABLE */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemef.h"
+#else
+#include "../src/schemef.h"
+#endif
+
+#endif
+
+#endif
+
+#ifndef USE_MZ_SETJMP
+#ifdef WIN32_SETJMP_HACK    /* See comment in setjmpup.c */
+#define scheme_longjmp(b, v) \
+    { jmp_buf hack; setjmp(hack); (b)->j_excep = hack->j_excep; \
+      longjmp(b, v); }
+#else
+#define scheme_longjmp(b, v) longjmp(b, v)
+#endif
+#define scheme_setjmp(b) setjmp(b)
+#endif
+
+#define SAME_PTR(a, b) ((a) == (b))
+#define NOT_SAME_PTR(a, b) ((a) != (b))
+
+#define SCHEME_STRUCT_NO_TYPE 0x01
+#define SCHEME_STRUCT_NO_CONSTR 0x02
+#define SCHEME_STRUCT_NO_PRED 0x04
+#define SCHEME_STRUCT_NO_GET 0x08
+#define SCHEME_STRUCT_NO_SET 0x10
+
+#define SAME_OBJ SAME_PTR
+#define NOT_SAME_OBJ NOT_SAME_PTR
+
+#define SAME_TYPE(a, b) ((Scheme_Type)(a) == (Scheme_Type)(b))
+#define NOT_SAME_TYPE(a, b) ((Scheme_Type)(a) != (Scheme_Type)(b))
+
+/* convenience macros */
+#define SCHEME_CHARP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_char_type)
+#ifdef FAST_NUMBERS
+#define SCHEME_INTP(obj)     (((long)obj) & 0x1)
+#else
+#define SCHEME_INTP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_integer_type)
+#endif
+#define SCHEME_DBLP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_double_type)
+#ifdef MZ_USE_SINGLE_FLOATS
+# define SCHEME_FLTP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_float_type)
+# define SCHEME_FLOATP(obj)     (SCHEME_FLTP(obj) || SCHEME_DBLP(obj))
+#else
+# define SCHEME_FLTP SCHEME_DBLP
+# define SCHEME_FLOATP SCHEME_DBLP
+#endif
+#define SCHEME_BIGNUMP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_bignum_type)
+#define SCHEME_RATIONALP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_rational_type)
+#define SCHEME_COMPLEXP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_complex_type)
+#define SCHEME_EXACT_INTEGERP(obj)  (SCHEME_INTP(obj) || (_SCHEME_TYPE(obj) == scheme_bignum_type))
+#define SCHEME_EXACT_REALP(obj)  (SCHEME_INTP(obj) || (_SCHEME_TYPE(obj) == scheme_bignum_type) || (_SCHEME_TYPE(obj) == scheme_rational_type))
+#define SCHEME_REALP(obj)  (SCHEME_INTP(obj) || ((_SCHEME_TYPE(obj) >= scheme_bignum_type) && (_SCHEME_TYPE(obj) <= scheme_double_type)))
+#define SCHEME_NUMBERP(obj)  (SCHEME_INTP(obj) || ((_SCHEME_TYPE(obj) >= scheme_bignum_type) && (_SCHEME_TYPE(obj) <= scheme_complex_type)))
+#define SCHEME_STRINGP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_string_type)
+#define SCHEME_SYMBOLP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_symbol_type)
+#define SCHEME_TSYMBOLP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_type_symbol_type)
+#define SCHEME_BOOLP(obj)    (SAME_OBJ(obj, scheme_true) || SAME_OBJ(obj, scheme_false))
+#define SCHEME_FALSEP(obj)     SAME_OBJ((obj), scheme_false)
+#define SCHEME_TRUEP(obj)     (!SCHEME_FALSEP(obj))
+#define SCHEME_SYNTAXP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_syntax_compiler_type)
+#define SCHEME_PRIMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_prim_type)
+#define SCHEME_CLSD_PRIMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_closed_prim_type)
+#define SCHEME_CONTP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_cont_type)
+#define SCHEME_ECONTP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_escaping_cont_type)
+#define SCHEME_NULLP(obj)    SAME_OBJ(obj, scheme_null)
+#define SCHEME_PAIRP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_pair_type)
+#define SCHEME_LISTP(obj)    (SCHEME_NULLP(obj) || SCHEME_PAIRP(obj))
+#define SCHEME_BOXP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_box_type)
+#define SCHEME_HASHTP(obj) SAME_TYPE(SCHEME_TYPE(obj),scheme_hash_table_type)
+#define SCHEME_VECTORP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_vector_type)
+#define SCHEME_STRUCT_PROCP(obj) (SCHEME_CLSD_PRIMP(obj) && (((Scheme_Closed_Primitive_Proc *)obj)->flags & SCHEME_PRIM_IS_STRUCT_PROC))
+#define SCHEME_GENERICP(obj) (SCHEME_CLSD_PRIMP(obj) && (((Scheme_Closed_Primitive_Proc *)obj)->flags & SCHEME_PRIM_IS_GENERIC))
+#define SCHEME_STRUCTP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_structure_type)
+#define SCHEME_STRUCT_TYPEP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_struct_type_type)
+#define SCHEME_CLOSUREP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_closure_type) || SAME_TYPE(SCHEME_TYPE(obj), scheme_linked_closure_type) || SAME_TYPE(SCHEME_TYPE(obj), scheme_case_closure_type))
+#define SCHEME_PROCP(obj)    (SCHEME_PRIMP(obj) || SCHEME_CLSD_PRIMP(obj) || SCHEME_CLOSUREP(obj) || SCHEME_CONTP(obj) || SCHEME_ECONTP(obj))
+#define SCHEME_INPORTP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_input_port_type)
+#define SCHEME_OUTPORTP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_output_port_type)
+#define SCHEME_EOFP(obj)     SAME_OBJ((obj), scheme_eof)
+#define SCHEME_PROMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_promise_type)
+#define SCHEME_DEBUGP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_debug_handle_type)
+#define SCHEME_PROCESSP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_process_type)
+#define SCHEME_MANAGERP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_manager_type)
+#define SCHEME_SEMAP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_sema_type)
+#define SCHEME_OBJP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+#define SCHEME_CLASSP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_class_type)
+#define SCHEME_INTERFACEP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_interface_type)
+#define SCHEME_VOIDP(obj)     SAME_OBJ((obj), scheme_void)
+#define SCHEME_DIVARP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_delayed_ivar_type)
+#define SCHEME_WEAKP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_weak_box_type)
+#define SCHEME_GENDATAP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_generic_data_type)
+#define SCHEME_UNITP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_unit_type)
+#define SCHEME_CONFIGP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_config_type)
+
+/* other */
+#define SCHEME_CADR(obj)     (SCHEME_CAR (SCHEME_CDR (obj)))
+#define SCHEME_CAAR(obj)     (SCHEME_CAR (SCHEME_CAR (obj)))
+#define SCHEME_CDDR(obj)     (SCHEME_CDR (SCHEME_CDR (obj)))
+#define SCHEME_IPORT_NAME(obj) (((Scheme_Input_Port *)obj)->name)
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* ! SCHEME_H */
+
diff --git a/collects/mzscheme/include/schemef.h b/collects/mzscheme/include/schemef.h
new file mode 100644
index 0000000..173f382
--- /dev/null
+++ b/collects/mzscheme/include/schemef.h
@@ -0,0 +1,558 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* MzScheme function prototypes */
+/* No macros should go in this file; it is used both to
+   prototype functions, and as a parsing source for
+   declaring scheme_extension_table */
+
+/* The scheme_extension_table parser is touchy: don't leave a space
+   between a function name and it's opening parameter parenthesis. */
+
+/* After this START tag, all comments should start & end on same line */
+
+/* START */
+
+/* Call/cc utilities */
+void scheme_init_jmpup_buf(Scheme_Jumpup_Buf *b);
+int scheme_setjmpup_relative(Scheme_Jumpup_Buf *b, void *start, 
+			     Scheme_Jumpup_Buf *cont);
+void scheme_longjmpup(Scheme_Jumpup_Buf *b);
+
+#ifdef USE_MZ_SETJMP
+int scheme_setjmp(jmp_buf b);
+void scheme_longjmp(jmp_buf b, int v);
+#endif
+
+/* Parameters */
+Scheme_Object *scheme_make_config(Scheme_Config *base);
+Scheme_Object *scheme_branch_config(void);
+int scheme_new_param(void);
+
+Scheme_Object *scheme_param_config(char *name, long pos,
+				   int argc, Scheme_Object **argv,
+				   int arity, 
+				   Scheme_Prim *check, char *expected,
+				   int isbool);
+Scheme_Object *scheme_register_parameter(Scheme_Prim *function, char *name, int which);
+Scheme_Env *scheme_get_env(Scheme_Config *config);
+
+/* Processes */
+#ifdef MZ_REAL_THREADS
+Scheme_Process *scheme_get_current_process();
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+extern Scheme_Process *scheme_current_process;
+extern int scheme_fuel_counter;
+#else
+extern Scheme_Process **scheme_current_process_ptr;
+extern int *scheme_fuel_counter_ptr;
+#endif
+#endif
+
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *scheme_make_namespace(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_thread(Scheme_Object *thunk, Scheme_Config *config);
+void scheme_break_thread(Scheme_Process *p);
+void scheme_kill_thread(Scheme_Process *p);
+#endif
+
+#ifndef MZ_REAL_THREADS
+void scheme_process_block(float sleep_time);
+void scheme_swap_process(Scheme_Process *process);
+#else
+void scheme_process_block_w_process(float sleep_time, Scheme_Process *p);
+#endif
+
+int scheme_block_until(int (*f)(Scheme_Object *), void (*fdfd)(Scheme_Object *, void *), void *, float);
+
+int scheme_in_main_thread(void);
+
+int scheme_tls_allocate();
+void scheme_tls_set(int pos, void *v);
+void *scheme_tls_get(int pos);
+
+void scheme_add_namespace_option(Scheme_Object *key, void (*f)(Scheme_Env *));
+
+Scheme_Manager *scheme_make_manager(Scheme_Manager *);
+Scheme_Manager_Reference *scheme_add_managed(Scheme_Manager *m, Scheme_Object *o, 
+					     Scheme_Close_Manager_Client *f, void *data, 
+					     int strong);
+void scheme_remove_managed(Scheme_Manager_Reference *m, Scheme_Object *o);
+void scheme_close_managed(Scheme_Manager *m);
+
+/* error handling */
+void scheme_signal_error(char *msg, ...);
+void scheme_raise_exn(int exnid, ...);
+void scheme_warning(char *msg, ...);
+
+void scheme_wrong_count(const char *name, int minc, int maxc, int argc,
+			Scheme_Object **argv);
+void scheme_case_lambda_wrong_count(const char *name, int argc, 
+				    Scheme_Object **argv, int count, ...);
+void scheme_wrong_type(const char *name, const char *expected, 
+		       int which, int argc,
+		       Scheme_Object **argv);
+void scheme_wrong_return_arity(const char *where, 
+			       int expected, int got,
+			       Scheme_Object **argv,
+			       const char *context_detail, ...);
+void scheme_unbound_global(Scheme_Object *name);
+
+Scheme_Object *scheme_dynamic_wind(void (*pre)(void *),
+				   Scheme_Object *(*act)(void *),
+				   void (*post)(void *), 
+				   Scheme_Object *(*jmp_handler)(void *),
+				   void *data);
+
+/* Types */
+Scheme_Type scheme_make_type(const char *name);
+
+/* Type readers & writers for compiled code data */
+void scheme_install_type_reader(Scheme_Type type, Scheme_Type_Reader f);
+void scheme_install_type_writer(Scheme_Type type, Scheme_Type_Writer f);
+
+/* Constants */
+extern Scheme_Object *scheme_eof;
+extern Scheme_Object *scheme_null;
+extern Scheme_Object *scheme_true;
+extern Scheme_Object *scheme_false;
+extern Scheme_Object *scheme_void;
+extern Scheme_Object *scheme_undefined;
+extern Scheme_Object *scheme_tail_call_waiting;
+extern Scheme_Object *scheme_multiple_values;
+
+/* Basics */
+Scheme_Object *scheme_eval(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *scheme_eval_multi(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *scheme_eval_compiled(Scheme_Object *obj);
+Scheme_Object *scheme_eval_compiled_multi(Scheme_Object *obj);
+Scheme_Object *_scheme_eval_compiled(Scheme_Object *obj);
+Scheme_Object *_scheme_eval_compiled_multi(Scheme_Object *obj);
+#ifndef MZ_REAL_THREADS
+Scheme_Object *scheme_apply(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+Scheme_Object *scheme_apply_multi(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+#else
+Scheme_Object *scheme_apply_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+			       Scheme_Process *p);
+Scheme_Object *scheme_apply_multi_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+				     Scheme_Process *p);
+#endif
+Scheme_Object *scheme_apply_to_list(Scheme_Object *rator, Scheme_Object *argss);
+Scheme_Object *scheme_eval_string(const char *str, Scheme_Env *env);
+Scheme_Object *scheme_eval_string_all(const char *str, Scheme_Env *env, int all);
+
+Scheme_Object *_scheme_apply_known_closed_prim(Scheme_Object *rator, int argc,
+					       Scheme_Object **argv);
+Scheme_Object *_scheme_apply_known_closed_prim_multi(Scheme_Object *rator, int argc,
+						     Scheme_Object **argv);
+
+Scheme_Object *scheme_values(int c, Scheme_Object **v);
+
+Scheme_Object *scheme_check_one_value(Scheme_Object *v);
+
+/* Tail calls - only use these when you're writing new functions/syntax */
+Scheme_Object *scheme_tail_apply(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *scheme_tail_apply_no_copy(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *scheme_tail_apply_to_list(Scheme_Object *f, Scheme_Object *l);
+
+Scheme_Object *scheme_tail_eval_expr(Scheme_Object *obj);
+
+void scheme_set_tail_buffer_size(int s);
+Scheme_Object *scheme_force_value(Scheme_Object *);
+
+/* Internal */
+#ifndef MZ_REAL_THREADS
+Scheme_Object *scheme_do_eval(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val);
+#else
+Scheme_Object *scheme_do_eval_w_process(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val, Scheme_Process *p);
+#endif
+
+/* Allocation */
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+void *GC_malloc(size_t size_in_bytes);
+void *GC_malloc_atomic(size_t size_in_bytes);
+void *GC_malloc_stubborn(size_t size_in_bytes);
+void *GC_malloc_uncollectable(size_t size_in_bytes);
+#endif
+#endif
+
+void *scheme_malloc_eternal(size_t n);
+void scheme_end_stubborn_change(void *p);
+
+void *scheme_calloc(size_t num, size_t size);
+
+char *scheme_strdup(const char *str);
+char *scheme_strdup_eternal(const char *str);
+
+void *scheme_malloc_fail_ok(void *(*f)(size_t), size_t);
+
+void scheme_weak_reference(void **p);
+void scheme_weak_reference_indirect(void **p, void *v);
+void scheme_add_finalizer(void *p, void (*f)(void *p, void *data), void *data);
+void scheme_add_scheme_finalizer(void *p, void (*f)(void *p, void *data), void *data);
+void scheme_register_finalizer(void *p, 
+			       void (*f)(void *p, void *data), void *data,
+			       void (**oldf)(void *p, void *data), 
+			       void **olddata);
+
+void scheme_dont_gc_ptr(void *p);
+void scheme_gc_ptr_ok(void *p);
+
+void scheme_collect_garbage(void);
+
+/* Hash table */
+Scheme_Hash_Table *scheme_hash_table(int size, int type, 
+				      int w_const, int forever);
+void scheme_add_to_table(Scheme_Hash_Table *table, const char *key, void *val, int);
+void scheme_change_in_table(Scheme_Hash_Table *table, const char *key, void *new_val);
+void *scheme_lookup_in_table(Scheme_Hash_Table *table, const char *key);
+Scheme_Bucket *scheme_bucket_from_table(Scheme_Hash_Table *table, const char *key);
+
+/* Constructors */
+Scheme_Object *scheme_make_prim(Scheme_Prim *prim);
+Scheme_Object *scheme_make_noneternal_prim(Scheme_Prim *prim);
+Scheme_Object *scheme_make_closed_prim(Scheme_Closed_Prim *prim, void *data);
+Scheme_Object *scheme_make_prim_w_arity(Scheme_Prim *prim, const char *name,
+					short mina, short maxa);
+Scheme_Object *scheme_make_folding_prim(Scheme_Prim *prim, 
+					const char *name,
+					short mina, short maxa,
+					short functional);
+Scheme_Object *scheme_make_noneternal_prim_w_arity(Scheme_Prim *prim, 
+						   const char *name, 
+						   short mina, short maxa);
+Scheme_Object *scheme_make_closed_prim_w_arity(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa);
+Scheme_Object *scheme_make_folding_closed_prim(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa,
+					       short functional);
+
+Scheme_Object *scheme_make_closure(Scheme_Env *env, Scheme_Object *code);
+Scheme_Object *scheme_make_pair(Scheme_Object *car, Scheme_Object *cdr);
+Scheme_Object *scheme_make_string(const char *chars);
+Scheme_Object *scheme_make_sized_string(char *chars, long len, int copy);
+Scheme_Object *scheme_make_string_without_copying(char *chars);
+Scheme_Object *scheme_alloc_string(int size, char fill);
+Scheme_Object *scheme_append_string(Scheme_Object *, Scheme_Object *);
+Scheme_Object *scheme_make_vector(int size, Scheme_Object *fill);
+Scheme_Object *scheme_make_integer_value(long i);
+Scheme_Object *scheme_make_integer_value_from_unsigned(unsigned long i);
+Scheme_Object *scheme_make_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+Scheme_Object *scheme_make_float(float f);
+#endif
+Scheme_Object *scheme_make_char(char ch);
+Scheme_Object *scheme_make_promise(Scheme_Object *expr, Scheme_Env *env);
+Scheme_Object *scheme_make_promise_from_thunk(Scheme_Object *expr);
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *scheme_make_sema(long v);
+#endif
+void scheme_post_sema(Scheme_Object *o);
+int scheme_wait_sema(Scheme_Object *o, int just_try);
+extern Scheme_Object **scheme_char_constants;
+
+int scheme_get_int_val(Scheme_Object *o, long *v);
+int scheme_get_unsigned_int_val(Scheme_Object *o, unsigned long *v);
+
+const char *scheme_get_proc_name(Scheme_Object *p, int *len, int for_error);
+
+/* Bignums */
+Scheme_Object *scheme_make_bignum(long v);
+Scheme_Object *scheme_make_bignum_from_unsigned(unsigned long v);
+double scheme_bignum_to_double(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_from_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float scheme_bignum_to_float(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_from_float(float d);
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+char *scheme_bignum_to_string(const Scheme_Object *n, int radix);
+Scheme_Object *scheme_read_bignum(const char *str, int radix);
+Scheme_Object *scheme_bignum_normalize(const Scheme_Object *n);
+
+long scheme_double_to_int(const char *where, double d);
+
+/* Rationals */
+Scheme_Object *scheme_make_rational(const Scheme_Object *r, const Scheme_Object *d);
+double scheme_rational_to_double(const Scheme_Object *n);
+Scheme_Object *scheme_rational_from_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float scheme_rational_to_float(const Scheme_Object *n);
+Scheme_Object *scheme_rational_from_float(float d);
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+Scheme_Object *scheme_rational_normalize(const Scheme_Object *n);
+Scheme_Object *scheme_rational_numerator(const Scheme_Object *n);
+Scheme_Object *scheme_rational_denominator(const Scheme_Object *n);
+
+/* Complex */
+Scheme_Object *scheme_make_complex(const Scheme_Object *r, const Scheme_Object *i);
+Scheme_Object *scheme_complex_normalize(const Scheme_Object *n);
+Scheme_Object *scheme_complex_real_part(const Scheme_Object *n);
+Scheme_Object *scheme_complex_imaginary_part(const Scheme_Object *n);
+
+/* Exact/inexact: */
+int scheme_is_exact(Scheme_Object *n);
+int scheme_is_inexact(Scheme_Object *n);
+
+/* Macro and syntax expansion */
+Scheme_Object *scheme_expand(Scheme_Object *form, Scheme_Env *env);
+
+/* Compilation */
+Scheme_Object *scheme_compile(Scheme_Object *form, Scheme_Env *env, int writeable);
+Scheme_Object *scheme_make_promise_value(Scheme_Object *compiled_expr);
+
+/* Ports */
+Scheme_Object *scheme_read(Scheme_Object *port);
+void scheme_write(Scheme_Object *obj, Scheme_Object *port);
+void scheme_display(Scheme_Object *obj, Scheme_Object *port);
+void scheme_write_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void scheme_display_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void scheme_write_string(const char *str, long len, Scheme_Object *port);
+char *scheme_write_to_string(Scheme_Object *obj, long *len);
+char *scheme_display_to_string(Scheme_Object *obj, long *len);
+char *scheme_write_to_string_w_max(Scheme_Object *obj, long *len, long maxl);
+char *scheme_display_to_string_w_max(Scheme_Object *obj, long *len, long maxl);
+void scheme_debug_print(Scheme_Object *obj);
+void scheme_flush_output(Scheme_Object *port);
+
+char *scheme_format(char *format, int flen, int argc, Scheme_Object **argv, int *rlen);
+void scheme_printf(char *format, int flen, int argc, Scheme_Object **argv);
+
+int scheme_getc(Scheme_Object *port);
+void scheme_ungetc(int ch, Scheme_Object *port);
+int scheme_char_ready(Scheme_Object *port);
+void scheme_need_wakeup(Scheme_Object *port, void *fds);
+long scheme_get_chars(Scheme_Object *port, long size, char *buffer);
+long scheme_tell(Scheme_Object *port);
+long scheme_output_tell(Scheme_Object *port);
+long scheme_tell_line(Scheme_Object *port);
+void scheme_close_input_port(Scheme_Object *port);
+void scheme_close_output_port(Scheme_Object *port);
+int scheme_are_all_chars_ready(Scheme_Object *port);
+
+Scheme_Object *scheme_make_port_type(const char *name);
+Scheme_Input_Port *scheme_make_input_port(Scheme_Object *subtype, void *data,
+					  int (*getc_fun)(Scheme_Input_Port*),
+					  int (*char_ready_fun)
+					  (Scheme_Input_Port*),
+					  void (*close_fun)
+					  (Scheme_Input_Port*),
+					  void (*need_wakeup_fun)
+					  (Scheme_Input_Port*, void *),
+					  int must_close);
+Scheme_Output_Port *scheme_make_output_port(Scheme_Object *subtype,
+					    void *data,
+					    void (*write_string_fun)
+					    (char*,long, Scheme_Output_Port*),
+					    void (*close_fun)
+					    (Scheme_Output_Port*),
+					    int must_close);
+
+Scheme_Object *scheme_make_file_input_port(FILE *fp);
+Scheme_Object *scheme_make_named_file_input_port(FILE *fp, const char *filename);
+Scheme_Object *scheme_make_file_output_port(FILE *fp);
+
+Scheme_Object *scheme_make_string_input_port(const char *str);
+Scheme_Object *scheme_make_sized_string_input_port(const char *str, long len);
+Scheme_Object *scheme_make_string_output_port();
+char *scheme_get_string_output(Scheme_Object *);
+char *scheme_get_sized_string_output(Scheme_Object *, int *len);
+
+void scheme_pipe(Scheme_Object **write, Scheme_Object **read);
+
+int scheme_file_exists(char *filename);
+int scheme_directory_exists(char *dirname);
+char *scheme_expand_filename(char* filename, int ilen, char *errorin, int *ex);
+
+char *scheme_getcwd(char *buf, int buflen, int *actlen, int noexn);
+int scheme_setcwd(char *buf, int noexn);
+char *scheme_getdrive(void);
+
+Scheme_Object *scheme_split_pathname(int argc, Scheme_Object **argv);
+Scheme_Object *scheme_build_pathname(int argc, Scheme_Object **argv);
+
+void *scheme_alloc_fdset_array(int count, int permanent);
+void *scheme_init_fdset_array(void *fdarray, int count);
+void *scheme_get_fdset(void *fdarray, int pos);
+void scheme_fdzero(void *fd);
+void scheme_fdset(void *fd, int pos);
+void scheme_fdclr(void *fd, int pos);
+int scheme_fdisset(void *fd, int pos);
+
+/* environment */
+void scheme_add_global(const char *name, Scheme_Object *val, Scheme_Env *env);
+void scheme_add_global_constant(const char *name, Scheme_Object *v, Scheme_Env *env);
+void scheme_add_global_keyword(const char *name, Scheme_Object *v, Scheme_Env *env);
+void scheme_remove_global(const char *name, Scheme_Env *env);
+void scheme_remove_global_constant(const char *name, Scheme_Env *env);
+
+void scheme_add_global_symbol(Scheme_Object *name, Scheme_Object *val, 
+			      Scheme_Env *env);
+void scheme_remove_global_symbol(Scheme_Object *name, Scheme_Env *env);
+void scheme_add_global_constant_symbol(Scheme_Object *name, Scheme_Object *v, Scheme_Env *env);
+
+void scheme_constant(Scheme_Object *sym, Scheme_Env *env);
+void scheme_set_keyword(Scheme_Object *name, Scheme_Env *env);
+
+Scheme_Object *scheme_make_envunbox(Scheme_Object *value);
+
+Scheme_Object *scheme_lookup_global(Scheme_Object *symbol, Scheme_Env *env);
+Scheme_Bucket *scheme_global_bucket(Scheme_Object *symbol, Scheme_Env *env);
+
+void scheme_set_global_bucket(char *proc, Scheme_Bucket *var, Scheme_Object *val,
+			      int set_undef);
+
+/* Symbols */
+Scheme_Object *scheme_intern_symbol(const char *name);
+Scheme_Object *scheme_intern_exact_symbol(const char *name, int len);
+Scheme_Object *scheme_make_symbol(const char *name); /* Make uninterned */
+Scheme_Object *scheme_make_exact_symbol(const char *name, int len); /* Exact case */
+const char *scheme_symbol_name(Scheme_Object *sym);
+const char *scheme_symbol_name_and_size(Scheme_Object *sym, int *l, int flags);
+
+/* Type Symbols */
+Scheme_Object *scheme_intern_type_symbol(Scheme_Object *sym);
+Scheme_Object *scheme_make_type_symbol(Scheme_Object *sym);/*Make uninterned */
+
+/* Structures */
+Scheme_Object **scheme_make_struct_values(Scheme_Object *struct_type,
+					  Scheme_Object **names,
+					  int count, int flags);
+Scheme_Object **scheme_make_struct_names(Scheme_Object *base, 
+					 Scheme_Object *field_names,
+					 int flags, int *count_out);
+Scheme_Object *scheme_make_struct_type(Scheme_Object *base, 
+				       Scheme_Object *parent, 
+				       int num_fields);
+Scheme_Object *scheme_make_struct_instance(Scheme_Object *stype,
+					   int argc,
+					   Scheme_Object **argv);
+int scheme_is_struct_instance(Scheme_Object *type, Scheme_Object *v);
+
+#ifndef NO_OBJECT_SYSTEM
+/* Objects */
+Scheme_Object *scheme_make_class(const char *name, Scheme_Object *sup, 
+				 Scheme_Method_Prim *init, int num_methods);
+void scheme_add_method(Scheme_Object *cl, const char *name, 
+		       Scheme_Method_Prim *f);
+void scheme_add_method_w_arity(Scheme_Object *cl, const char *name, 
+			       Scheme_Method_Prim *f, int mina, int maxa);
+void scheme_made_class(Scheme_Object *cl);
+
+Scheme_Object *scheme_make_object(Scheme_Object *sclass, 
+				  int argc, Scheme_Object **argv);
+Scheme_Object *scheme_make_uninited_object(Scheme_Object *sclass);
+
+Scheme_Object *scheme_find_ivar(Scheme_Object *obj, Scheme_Object *sym, int force);
+
+int scheme_is_subclass(Scheme_Object *sub, Scheme_Object *parent);
+int scheme_is_implementation(Scheme_Object *cl, Scheme_Object *in);
+int scheme_is_interface_extension(Scheme_Object *n1, Scheme_Object *n2);
+int scheme_is_a(Scheme_Object *obj, Scheme_Object *sclass);
+const char *scheme_get_class_name(Scheme_Object *cl, int *len);
+const char *scheme_get_interface_name(Scheme_Object *cl, int *len);
+
+struct Scheme_Class_Assembly *scheme_make_class_assembly(const char *name, int n_interfaces,
+							 int n_public, Scheme_Object **names,
+							 int n_inh, Scheme_Object **inheritd,
+							 int n_ren, Scheme_Object **renames,
+							 int mina, int maxa,
+							 Scheme_Instance_Init_Proc *initproc);
+Scheme_Object *scheme_create_class(struct Scheme_Class_Assembly *a, void *data,
+				   Scheme_Object *super, Scheme_Object **interfaces);
+
+struct Scheme_Interface_Assembly *scheme_make_interface_assembly(const char *name, int n_supers, 
+								 int n_names, 
+								 Scheme_Object **names);
+Scheme_Object *scheme_create_interface(struct Scheme_Interface_Assembly *a,
+				       Scheme_Object **supers);
+
+Scheme_Object *scheme_apply_generic_data(Scheme_Object *gdata, 
+					 Scheme_Object *sobj, int force);
+Scheme_Object *scheme_get_generic_data(Scheme_Object *cl, 
+				       Scheme_Object *name);
+#endif
+
+/* Units */
+Scheme_Object *scheme_invoke_unit(Scheme_Object *functor, int num_ins, 
+				  Scheme_Object **ins, Scheme_Object **anchors,
+				  int open, const char *name, int tail, int multi);
+
+Scheme_Object *scheme_assemble_compound_unit(Scheme_Object *imports,
+					     Scheme_Object *links,
+					     Scheme_Object *exports);
+Scheme_Object *scheme_make_compound_unit(Scheme_Object *data_in, 
+					 Scheme_Object **subs_in);
+
+const char *scheme_get_unit_name(Scheme_Object *cl, int *len);
+
+/* Misc */
+int scheme_eq(Scheme_Object *obj1, Scheme_Object *obj2);
+int scheme_eqv(Scheme_Object *obj1, Scheme_Object *obj2);
+int scheme_equal(Scheme_Object *obj1, Scheme_Object *obj2);
+
+Scheme_Object *scheme_build_list(int argc, Scheme_Object **argv);
+
+int scheme_list_length(Scheme_Object *list);
+int scheme_proper_list_length(Scheme_Object *list);
+
+Scheme_Object *scheme_alloc_list(int size);
+Scheme_Object *scheme_map_1(Scheme_Object *(*f)(Scheme_Object*),
+			    Scheme_Object *l);
+
+Scheme_Object *scheme_car(Scheme_Object *pair);
+Scheme_Object *scheme_cdr(Scheme_Object *pair);
+Scheme_Object *scheme_cadr(Scheme_Object *pair);
+Scheme_Object *scheme_caddr(Scheme_Object *pair);
+
+Scheme_Object *scheme_vector_to_list(Scheme_Object *vec);
+Scheme_Object *scheme_list_to_vector(Scheme_Object *list);
+
+Scheme_Object *scheme_append(Scheme_Object *lstx, Scheme_Object *lsty);
+
+Scheme_Object *scheme_box(Scheme_Object *v);
+Scheme_Object *scheme_unbox(Scheme_Object *obj);
+void scheme_set_box(Scheme_Object *b, Scheme_Object *v);
+
+Scheme_Object *scheme_make_weak_box(Scheme_Object *v);
+
+Scheme_Object *scheme_load(const char *file);
+Scheme_Object *scheme_load_extension(const char *filename, Scheme_Env *env);
+void scheme_register_extension_global(void *ptr, long size);
+
+long scheme_get_milliseconds(void);
+long scheme_get_process_milliseconds(void);
+
+void scheme_rep(void);
+char *scheme_banner(void);
+char *scheme_version(void);
+
+int scheme_check_proc_arity(const char *where, int a,
+			    int which, int argc, Scheme_Object **argv);
+
+void scheme_secure_exceptions(Scheme_Env *env);
+
+char *scheme_make_provided_string(Scheme_Object *o, int count, int *len);
+char *scheme_make_args_string(char *s, int which, int argc, Scheme_Object **argv);
+
+void scheme_no_dumps(char *why);
+
+const char *scheme_system_library_subpath();
diff --git a/collects/mzscheme/include/schemex.h b/collects/mzscheme/include/schemex.h
new file mode 100644
index 0000000..2ac1158
--- /dev/null
+++ b/collects/mzscheme/include/schemex.h
@@ -0,0 +1,468 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* MzScheme function prototypes */
+/* No macros should go in this file; it is used both to
+   prototype functions, and as a parsing source for
+   declaring scheme_extension_table */
+
+/* The scheme_extension_table parser is touchy: don't leave a space
+   between a function name and it's opening parameter parenthesis. */
+
+/* After this START tag, all comments should start & end on same line */
+
+typedef struct {
+/* Call/cc utilities */
+void (*scheme_init_jmpup_buf)(Scheme_Jumpup_Buf *b);
+int (*scheme_setjmpup_relative)(Scheme_Jumpup_Buf *b, void *start, 
+			     Scheme_Jumpup_Buf *cont);
+void (*scheme_longjmpup)(Scheme_Jumpup_Buf *b);
+#ifdef USE_MZ_SETJMP
+int (*scheme_setjmp)(jmp_buf b);
+void (*scheme_longjmp)(jmp_buf b, int v);
+#endif
+/* Parameters */
+Scheme_Object *(*scheme_make_config)(Scheme_Config *base);
+Scheme_Object *(*scheme_branch_config)(void);
+int (*scheme_new_param)(void);
+Scheme_Object *(*scheme_param_config)(char *name, long pos,
+				   int argc, Scheme_Object **argv,
+				   int arity, 
+				   Scheme_Prim *check, char *expected,
+				   int isbool);
+Scheme_Object *(*scheme_register_parameter)(Scheme_Prim *function, char *name, int which);
+Scheme_Env *(*scheme_get_env)(Scheme_Config *config);
+/* Processes */
+#ifdef MZ_REAL_THREADS
+Scheme_Process *(*scheme_get_current_process)();
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+Scheme_Process *scheme_current_process;
+int scheme_fuel_counter;
+#else
+Scheme_Process **scheme_current_process_ptr;
+int *scheme_fuel_counter_ptr;
+#endif
+#endif
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *(*scheme_make_namespace)(int argc, Scheme_Object *argv[]);
+Scheme_Object *(*scheme_thread)(Scheme_Object *thunk, Scheme_Config *config);
+void (*scheme_break_thread)(Scheme_Process *p);
+void (*scheme_kill_thread)(Scheme_Process *p);
+#endif
+#ifndef MZ_REAL_THREADS
+void (*scheme_process_block)(float sleep_time);
+void (*scheme_swap_process)(Scheme_Process *process);
+#else
+void (*scheme_process_block_w_process)(float sleep_time, Scheme_Process *p);
+#endif
+int (*scheme_block_until)(int (*f)(Scheme_Object *), void (*fdfd)(Scheme_Object *, void *), void *, float);
+int (*scheme_in_main_thread)(void);
+int (*scheme_tls_allocate)();
+void (*scheme_tls_set)(int pos, void *v);
+void *(*scheme_tls_get)(int pos);
+void (*scheme_add_namespace_option)(Scheme_Object *key, void (*f)(Scheme_Env *));
+Scheme_Manager *(*scheme_make_manager)(Scheme_Manager *);
+Scheme_Manager_Reference *(*scheme_add_managed)(Scheme_Manager *m, Scheme_Object *o, 
+					     Scheme_Close_Manager_Client *f, void *data, 
+					     int strong);
+void (*scheme_remove_managed)(Scheme_Manager_Reference *m, Scheme_Object *o);
+void (*scheme_close_managed)(Scheme_Manager *m);
+/* error handling */
+void (*scheme_signal_error)(char *msg, ...);
+void (*scheme_raise_exn)(int exnid, ...);
+void (*scheme_warning)(char *msg, ...);
+void (*scheme_wrong_count)(const char *name, int minc, int maxc, int argc,
+			Scheme_Object **argv);
+void (*scheme_case_lambda_wrong_count)(const char *name, int argc, 
+				    Scheme_Object **argv, int count, ...);
+void (*scheme_wrong_type)(const char *name, const char *expected, 
+		       int which, int argc,
+		       Scheme_Object **argv);
+void (*scheme_wrong_return_arity)(const char *where, 
+			       int expected, int got,
+			       Scheme_Object **argv,
+			       const char *context_detail, ...);
+void (*scheme_unbound_global)(Scheme_Object *name);
+Scheme_Object *(*scheme_dynamic_wind)(void (*pre)(void *),
+				   Scheme_Object *(*act)(void *),
+				   void (*post)(void *), 
+				   Scheme_Object *(*jmp_handler)(void *),
+				   void *data);
+/* Types */
+Scheme_Type (*scheme_make_type)(const char *name);
+/* Type readers & writers for compiled code data */
+void (*scheme_install_type_reader)(Scheme_Type type, Scheme_Type_Reader f);
+void (*scheme_install_type_writer)(Scheme_Type type, Scheme_Type_Writer f);
+/* Constants */
+Scheme_Object *scheme_eof;
+Scheme_Object *scheme_null;
+Scheme_Object *scheme_true;
+Scheme_Object *scheme_false;
+Scheme_Object *scheme_void;
+Scheme_Object *scheme_undefined;
+Scheme_Object *scheme_tail_call_waiting;
+Scheme_Object *scheme_multiple_values;
+/* Basics */
+Scheme_Object *(*scheme_eval)(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_multi)(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_compiled)(Scheme_Object *obj);
+Scheme_Object *(*scheme_eval_compiled_multi)(Scheme_Object *obj);
+Scheme_Object *(*_scheme_eval_compiled)(Scheme_Object *obj);
+Scheme_Object *(*_scheme_eval_compiled_multi)(Scheme_Object *obj);
+#ifndef MZ_REAL_THREADS
+Scheme_Object *(*scheme_apply)(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+Scheme_Object *(*scheme_apply_multi)(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+#else
+Scheme_Object *(*scheme_apply_wp)(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+			       Scheme_Process *p);
+Scheme_Object *(*scheme_apply_multi_wp)(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+				     Scheme_Process *p);
+#endif
+Scheme_Object *(*scheme_apply_to_list)(Scheme_Object *rator, Scheme_Object *argss);
+Scheme_Object *(*scheme_eval_string)(const char *str, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_string_all)(const char *str, Scheme_Env *env, int all);
+Scheme_Object *(*_scheme_apply_known_closed_prim)(Scheme_Object *rator, int argc,
+					       Scheme_Object **argv);
+Scheme_Object *(*_scheme_apply_known_closed_prim_multi)(Scheme_Object *rator, int argc,
+						     Scheme_Object **argv);
+Scheme_Object *(*scheme_values)(int c, Scheme_Object **v);
+Scheme_Object *(*scheme_check_one_value)(Scheme_Object *v);
+/* Tail calls - only use these when you're writing new functions/syntax */
+Scheme_Object *(*scheme_tail_apply)(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *(*scheme_tail_apply_no_copy)(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *(*scheme_tail_apply_to_list)(Scheme_Object *f, Scheme_Object *l);
+Scheme_Object *(*scheme_tail_eval_expr)(Scheme_Object *obj);
+void (*scheme_set_tail_buffer_size)(int s);
+Scheme_Object *(*scheme_force_value)(Scheme_Object *);
+/* Internal */
+#ifndef MZ_REAL_THREADS
+Scheme_Object *(*scheme_do_eval)(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val);
+#else
+Scheme_Object *(*scheme_do_eval_w_process)(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val, Scheme_Process *p);
+#endif
+/* Allocation */
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+void *(*GC_malloc)(size_t size_in_bytes);
+void *(*GC_malloc_atomic)(size_t size_in_bytes);
+void *(*GC_malloc_stubborn)(size_t size_in_bytes);
+void *(*GC_malloc_uncollectable)(size_t size_in_bytes);
+#endif
+#endif
+void *(*scheme_malloc_eternal)(size_t n);
+void (*scheme_end_stubborn_change)(void *p);
+void *(*scheme_calloc)(size_t num, size_t size);
+char *(*scheme_strdup)(const char *str);
+char *(*scheme_strdup_eternal)(const char *str);
+void *(*scheme_malloc_fail_ok)(void *(*f)(size_t), size_t);
+void (*scheme_weak_reference)(void **p);
+void (*scheme_weak_reference_indirect)(void **p, void *v);
+void (*scheme_add_finalizer)(void *p, void (*f)(void *p, void *data), void *data);
+void (*scheme_add_scheme_finalizer)(void *p, void (*f)(void *p, void *data), void *data);
+void (*scheme_register_finalizer)(void *p, 
+			       void (*f)(void *p, void *data), void *data,
+			       void (**oldf)(void *p, void *data), 
+			       void **olddata);
+void (*scheme_dont_gc_ptr)(void *p);
+void (*scheme_gc_ptr_ok)(void *p);
+void (*scheme_collect_garbage)(void);
+/* Hash table */
+Scheme_Hash_Table *(*scheme_hash_table)(int size, int type, 
+				      int w_const, int forever);
+void (*scheme_add_to_table)(Scheme_Hash_Table *table, const char *key, void *val, int);
+void (*scheme_change_in_table)(Scheme_Hash_Table *table, const char *key, void *new_val);
+void *(*scheme_lookup_in_table)(Scheme_Hash_Table *table, const char *key);
+Scheme_Bucket *(*scheme_bucket_from_table)(Scheme_Hash_Table *table, const char *key);
+/* Constructors */
+Scheme_Object *(*scheme_make_prim)(Scheme_Prim *prim);
+Scheme_Object *(*scheme_make_noneternal_prim)(Scheme_Prim *prim);
+Scheme_Object *(*scheme_make_closed_prim)(Scheme_Closed_Prim *prim, void *data);
+Scheme_Object *(*scheme_make_prim_w_arity)(Scheme_Prim *prim, const char *name,
+					short mina, short maxa);
+Scheme_Object *(*scheme_make_folding_prim)(Scheme_Prim *prim, 
+					const char *name,
+					short mina, short maxa,
+					short functional);
+Scheme_Object *(*scheme_make_noneternal_prim_w_arity)(Scheme_Prim *prim, 
+						   const char *name, 
+						   short mina, short maxa);
+Scheme_Object *(*scheme_make_closed_prim_w_arity)(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa);
+Scheme_Object *(*scheme_make_folding_closed_prim)(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa,
+					       short functional);
+Scheme_Object *(*scheme_make_closure)(Scheme_Env *env, Scheme_Object *code);
+Scheme_Object *(*scheme_make_pair)(Scheme_Object *car, Scheme_Object *cdr);
+Scheme_Object *(*scheme_make_string)(const char *chars);
+Scheme_Object *(*scheme_make_sized_string)(char *chars, long len, int copy);
+Scheme_Object *(*scheme_make_string_without_copying)(char *chars);
+Scheme_Object *(*scheme_alloc_string)(int size, char fill);
+Scheme_Object *(*scheme_append_string)(Scheme_Object *, Scheme_Object *);
+Scheme_Object *(*scheme_make_vector)(int size, Scheme_Object *fill);
+Scheme_Object *(*scheme_make_integer_value)(long i);
+Scheme_Object *(*scheme_make_integer_value_from_unsigned)(unsigned long i);
+Scheme_Object *(*scheme_make_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+Scheme_Object *(*scheme_make_float)(float f);
+#endif
+Scheme_Object *(*scheme_make_char)(char ch);
+Scheme_Object *(*scheme_make_promise)(Scheme_Object *expr, Scheme_Env *env);
+Scheme_Object *(*scheme_make_promise_from_thunk)(Scheme_Object *expr);
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *(*scheme_make_sema)(long v);
+#endif
+void (*scheme_post_sema)(Scheme_Object *o);
+int (*scheme_wait_sema)(Scheme_Object *o, int just_try);
+Scheme_Object **scheme_char_constants;
+int (*scheme_get_int_val)(Scheme_Object *o, long *v);
+int (*scheme_get_unsigned_int_val)(Scheme_Object *o, unsigned long *v);
+const char *(*scheme_get_proc_name)(Scheme_Object *p, int *len, int for_error);
+/* Bignums */
+Scheme_Object *(*scheme_make_bignum)(long v);
+Scheme_Object *(*scheme_make_bignum_from_unsigned)(unsigned long v);
+double (*scheme_bignum_to_double)(const Scheme_Object *n);
+Scheme_Object *(*scheme_bignum_from_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float (*scheme_bignum_to_float)(const Scheme_Object *n);
+Scheme_Object *(*scheme_bignum_from_float)(float d);
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+char *(*scheme_bignum_to_string)(const Scheme_Object *n, int radix);
+Scheme_Object *(*scheme_read_bignum)(const char *str, int radix);
+Scheme_Object *(*scheme_bignum_normalize)(const Scheme_Object *n);
+long (*scheme_double_to_int)(const char *where, double d);
+/* Rationals */
+Scheme_Object *(*scheme_make_rational)(const Scheme_Object *r, const Scheme_Object *d);
+double (*scheme_rational_to_double)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_from_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float (*scheme_rational_to_float)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_from_float)(float d);
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+Scheme_Object *(*scheme_rational_normalize)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_numerator)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_denominator)(const Scheme_Object *n);
+/* Complex */
+Scheme_Object *(*scheme_make_complex)(const Scheme_Object *r, const Scheme_Object *i);
+Scheme_Object *(*scheme_complex_normalize)(const Scheme_Object *n);
+Scheme_Object *(*scheme_complex_real_part)(const Scheme_Object *n);
+Scheme_Object *(*scheme_complex_imaginary_part)(const Scheme_Object *n);
+/* Exact/inexact: */
+int (*scheme_is_exact)(Scheme_Object *n);
+int (*scheme_is_inexact)(Scheme_Object *n);
+/* Macro and syntax expansion */
+Scheme_Object *(*scheme_expand)(Scheme_Object *form, Scheme_Env *env);
+/* Compilation */
+Scheme_Object *(*scheme_compile)(Scheme_Object *form, Scheme_Env *env, int writeable);
+Scheme_Object *(*scheme_make_promise_value)(Scheme_Object *compiled_expr);
+/* Ports */
+Scheme_Object *(*scheme_read)(Scheme_Object *port);
+void (*scheme_write)(Scheme_Object *obj, Scheme_Object *port);
+void (*scheme_display)(Scheme_Object *obj, Scheme_Object *port);
+void (*scheme_write_w_max)(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void (*scheme_display_w_max)(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void (*scheme_write_string)(const char *str, long len, Scheme_Object *port);
+char *(*scheme_write_to_string)(Scheme_Object *obj, long *len);
+char *(*scheme_display_to_string)(Scheme_Object *obj, long *len);
+char *(*scheme_write_to_string_w_max)(Scheme_Object *obj, long *len, long maxl);
+char *(*scheme_display_to_string_w_max)(Scheme_Object *obj, long *len, long maxl);
+void (*scheme_debug_print)(Scheme_Object *obj);
+void (*scheme_flush_output)(Scheme_Object *port);
+char *(*scheme_format)(char *format, int flen, int argc, Scheme_Object **argv, int *rlen);
+void (*scheme_printf)(char *format, int flen, int argc, Scheme_Object **argv);
+int (*scheme_getc)(Scheme_Object *port);
+void (*scheme_ungetc)(int ch, Scheme_Object *port);
+int (*scheme_char_ready)(Scheme_Object *port);
+void (*scheme_need_wakeup)(Scheme_Object *port, void *fds);
+long (*scheme_get_chars)(Scheme_Object *port, long size, char *buffer);
+long (*scheme_tell)(Scheme_Object *port);
+long (*scheme_output_tell)(Scheme_Object *port);
+long (*scheme_tell_line)(Scheme_Object *port);
+void (*scheme_close_input_port)(Scheme_Object *port);
+void (*scheme_close_output_port)(Scheme_Object *port);
+int (*scheme_are_all_chars_ready)(Scheme_Object *port);
+Scheme_Object *(*scheme_make_port_type)(const char *name);
+Scheme_Input_Port *(*scheme_make_input_port)(Scheme_Object *subtype, void *data,
+					  int (*getc_fun)(Scheme_Input_Port*),
+					  int (*char_ready_fun)
+					  (Scheme_Input_Port*),
+					  void (*close_fun)
+					  (Scheme_Input_Port*),
+					  void (*need_wakeup_fun)
+					  (Scheme_Input_Port*, void *),
+					  int must_close);
+Scheme_Output_Port *(*scheme_make_output_port)(Scheme_Object *subtype,
+					    void *data,
+					    void (*write_string_fun)
+					    (char*,long, Scheme_Output_Port*),
+					    void (*close_fun)
+					    (Scheme_Output_Port*),
+					    int must_close);
+Scheme_Object *(*scheme_make_file_input_port)(FILE *fp);
+Scheme_Object *(*scheme_make_named_file_input_port)(FILE *fp, const char *filename);
+Scheme_Object *(*scheme_make_file_output_port)(FILE *fp);
+Scheme_Object *(*scheme_make_string_input_port)(const char *str);
+Scheme_Object *(*scheme_make_sized_string_input_port)(const char *str, long len);
+Scheme_Object *(*scheme_make_string_output_port)();
+char *(*scheme_get_string_output)(Scheme_Object *);
+char *(*scheme_get_sized_string_output)(Scheme_Object *, int *len);
+void (*scheme_pipe)(Scheme_Object **write, Scheme_Object **read);
+int (*scheme_file_exists)(char *filename);
+int (*scheme_directory_exists)(char *dirname);
+char *(*scheme_expand_filename)(char* filename, int ilen, char *errorin, int *ex);
+char *(*scheme_getcwd)(char *buf, int buflen, int *actlen, int noexn);
+int (*scheme_setcwd)(char *buf, int noexn);
+char *(*scheme_getdrive)(void);
+Scheme_Object *(*scheme_split_pathname)(int argc, Scheme_Object **argv);
+Scheme_Object *(*scheme_build_pathname)(int argc, Scheme_Object **argv);
+void *(*scheme_alloc_fdset_array)(int count, int permanent);
+void *(*scheme_init_fdset_array)(void *fdarray, int count);
+void *(*scheme_get_fdset)(void *fdarray, int pos);
+void (*scheme_fdzero)(void *fd);
+void (*scheme_fdset)(void *fd, int pos);
+void (*scheme_fdclr)(void *fd, int pos);
+int (*scheme_fdisset)(void *fd, int pos);
+/* environment */
+void (*scheme_add_global)(const char *name, Scheme_Object *val, Scheme_Env *env);
+void (*scheme_add_global_constant)(const char *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_add_global_keyword)(const char *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_remove_global)(const char *name, Scheme_Env *env);
+void (*scheme_remove_global_constant)(const char *name, Scheme_Env *env);
+void (*scheme_add_global_symbol)(Scheme_Object *name, Scheme_Object *val, 
+			      Scheme_Env *env);
+void (*scheme_remove_global_symbol)(Scheme_Object *name, Scheme_Env *env);
+void (*scheme_add_global_constant_symbol)(Scheme_Object *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_constant)(Scheme_Object *sym, Scheme_Env *env);
+void (*scheme_set_keyword)(Scheme_Object *name, Scheme_Env *env);
+Scheme_Object *(*scheme_make_envunbox)(Scheme_Object *value);
+Scheme_Object *(*scheme_lookup_global)(Scheme_Object *symbol, Scheme_Env *env);
+Scheme_Bucket *(*scheme_global_bucket)(Scheme_Object *symbol, Scheme_Env *env);
+void (*scheme_set_global_bucket)(char *proc, Scheme_Bucket *var, Scheme_Object *val,
+			      int set_undef);
+/* Symbols */
+Scheme_Object *(*scheme_intern_symbol)(const char *name);
+Scheme_Object *(*scheme_intern_exact_symbol)(const char *name, int len);
+Scheme_Object *(*scheme_make_symbol)(const char *name); /* Make uninterned */
+Scheme_Object *(*scheme_make_exact_symbol)(const char *name, int len); /* Exact case */
+const char *(*scheme_symbol_name)(Scheme_Object *sym);
+const char *(*scheme_symbol_name_and_size)(Scheme_Object *sym, int *l, int flags);
+/* Type Symbols */
+Scheme_Object *(*scheme_intern_type_symbol)(Scheme_Object *sym);
+Scheme_Object *(*scheme_make_type_symbol)(Scheme_Object *sym);/*Make uninterned */
+/* Structures */
+Scheme_Object **(*scheme_make_struct_values)(Scheme_Object *struct_type,
+					  Scheme_Object **names,
+					  int count, int flags);
+Scheme_Object **(*scheme_make_struct_names)(Scheme_Object *base, 
+					 Scheme_Object *field_names,
+					 int flags, int *count_out);
+Scheme_Object *(*scheme_make_struct_type)(Scheme_Object *base, 
+				       Scheme_Object *parent, 
+				       int num_fields);
+Scheme_Object *(*scheme_make_struct_instance)(Scheme_Object *stype,
+					   int argc,
+					   Scheme_Object **argv);
+int (*scheme_is_struct_instance)(Scheme_Object *type, Scheme_Object *v);
+#ifndef NO_OBJECT_SYSTEM
+/* Objects */
+Scheme_Object *(*scheme_make_class)(const char *name, Scheme_Object *sup, 
+				 Scheme_Method_Prim *init, int num_methods);
+void (*scheme_add_method)(Scheme_Object *cl, const char *name, 
+		       Scheme_Method_Prim *f);
+void (*scheme_add_method_w_arity)(Scheme_Object *cl, const char *name, 
+			       Scheme_Method_Prim *f, int mina, int maxa);
+void (*scheme_made_class)(Scheme_Object *cl);
+Scheme_Object *(*scheme_make_object)(Scheme_Object *sclass, 
+				  int argc, Scheme_Object **argv);
+Scheme_Object *(*scheme_make_uninited_object)(Scheme_Object *sclass);
+Scheme_Object *(*scheme_find_ivar)(Scheme_Object *obj, Scheme_Object *sym, int force);
+int (*scheme_is_subclass)(Scheme_Object *sub, Scheme_Object *parent);
+int (*scheme_is_implementation)(Scheme_Object *cl, Scheme_Object *in);
+int (*scheme_is_interface_extension)(Scheme_Object *n1, Scheme_Object *n2);
+int (*scheme_is_a)(Scheme_Object *obj, Scheme_Object *sclass);
+const char *(*scheme_get_class_name)(Scheme_Object *cl, int *len);
+const char *(*scheme_get_interface_name)(Scheme_Object *cl, int *len);
+struct Scheme_Class_Assembly *(*scheme_make_class_assembly)(const char *name, int n_interfaces,
+							 int n_public, Scheme_Object **names,
+							 int n_inh, Scheme_Object **inheritd,
+							 int n_ren, Scheme_Object **renames,
+							 int mina, int maxa,
+							 Scheme_Instance_Init_Proc *initproc);
+Scheme_Object *(*scheme_create_class)(struct Scheme_Class_Assembly *a, void *data,
+				   Scheme_Object *super, Scheme_Object **interfaces);
+struct Scheme_Interface_Assembly *(*scheme_make_interface_assembly)(const char *name, int n_supers, 
+								 int n_names, 
+								 Scheme_Object **names);
+Scheme_Object *(*scheme_create_interface)(struct Scheme_Interface_Assembly *a,
+				       Scheme_Object **supers);
+Scheme_Object *(*scheme_apply_generic_data)(Scheme_Object *gdata, 
+					 Scheme_Object *sobj, int force);
+Scheme_Object *(*scheme_get_generic_data)(Scheme_Object *cl, 
+				       Scheme_Object *name);
+#endif
+/* Units */
+Scheme_Object *(*scheme_invoke_unit)(Scheme_Object *functor, int num_ins, 
+				  Scheme_Object **ins, Scheme_Object **anchors,
+				  int open, const char *name, int tail, int multi);
+Scheme_Object *(*scheme_assemble_compound_unit)(Scheme_Object *imports,
+					     Scheme_Object *links,
+					     Scheme_Object *exports);
+Scheme_Object *(*scheme_make_compound_unit)(Scheme_Object *data_in, 
+					 Scheme_Object **subs_in);
+const char *(*scheme_get_unit_name)(Scheme_Object *cl, int *len);
+/* Misc */
+int (*scheme_eq)(Scheme_Object *obj1, Scheme_Object *obj2);
+int (*scheme_eqv)(Scheme_Object *obj1, Scheme_Object *obj2);
+int (*scheme_equal)(Scheme_Object *obj1, Scheme_Object *obj2);
+Scheme_Object *(*scheme_build_list)(int argc, Scheme_Object **argv);
+int (*scheme_list_length)(Scheme_Object *list);
+int (*scheme_proper_list_length)(Scheme_Object *list);
+Scheme_Object *(*scheme_alloc_list)(int size);
+Scheme_Object *(*scheme_map_1)(Scheme_Object *(*f)(Scheme_Object*),
+			    Scheme_Object *l);
+Scheme_Object *(*scheme_car)(Scheme_Object *pair);
+Scheme_Object *(*scheme_cdr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_cadr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_caddr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_vector_to_list)(Scheme_Object *vec);
+Scheme_Object *(*scheme_list_to_vector)(Scheme_Object *list);
+Scheme_Object *(*scheme_append)(Scheme_Object *lstx, Scheme_Object *lsty);
+Scheme_Object *(*scheme_box)(Scheme_Object *v);
+Scheme_Object *(*scheme_unbox)(Scheme_Object *obj);
+void (*scheme_set_box)(Scheme_Object *b, Scheme_Object *v);
+Scheme_Object *(*scheme_make_weak_box)(Scheme_Object *v);
+Scheme_Object *(*scheme_load)(const char *file);
+Scheme_Object *(*scheme_load_extension)(const char *filename, Scheme_Env *env);
+void (*scheme_register_extension_global)(void *ptr, long size);
+long (*scheme_get_milliseconds)(void);
+long (*scheme_get_process_milliseconds)(void);
+void (*scheme_rep)(void);
+char *(*scheme_banner)(void);
+char *(*scheme_version)(void);
+int (*scheme_check_proc_arity)(const char *where, int a,
+			    int which, int argc, Scheme_Object **argv);
+void (*scheme_secure_exceptions)(Scheme_Env *env);
+char *(*scheme_make_provided_string)(Scheme_Object *o, int count, int *len);
+char *(*scheme_make_args_string)(char *s, int which, int argc, Scheme_Object **argv);
+void (*scheme_no_dumps)(char *why);
+const char *(*scheme_system_library_subpath)();
+#ifndef SCHEME_EX_INLINE
+} Scheme_Extension_Table;
+#endif
diff --git a/collects/mzscheme/include/schemexm.h b/collects/mzscheme/include/schemexm.h
new file mode 100644
index 0000000..903eb5d
--- /dev/null
+++ b/collects/mzscheme/include/schemexm.h
@@ -0,0 +1,332 @@
+#define scheme_init_jmpup_buf (scheme_extension_table->scheme_init_jmpup_buf)
+#define scheme_setjmpup_relative (scheme_extension_table->scheme_setjmpup_relative)
+#define scheme_longjmpup (scheme_extension_table->scheme_longjmpup)
+#ifdef USE_MZ_SETJMP
+#define scheme_setjmp (scheme_extension_table->scheme_setjmp)
+#define scheme_longjmp (scheme_extension_table->scheme_longjmp)
+#endif
+#define scheme_make_config (scheme_extension_table->scheme_make_config)
+#define scheme_branch_config (scheme_extension_table->scheme_branch_config)
+#define scheme_new_param (scheme_extension_table->scheme_new_param)
+#define scheme_param_config (scheme_extension_table->scheme_param_config)
+#define scheme_register_parameter (scheme_extension_table->scheme_register_parameter)
+#define scheme_get_env (scheme_extension_table->scheme_get_env)
+#ifdef MZ_REAL_THREADS
+#define scheme_get_current_process (scheme_extension_table->scheme_get_current_process)
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+#define scheme_current_process (scheme_extension_table->scheme_current_process)
+#define scheme_fuel_counter (scheme_extension_table->scheme_fuel_counter)
+#else
+#define scheme_current_process_ptr (scheme_extension_table->scheme_current_process_ptr)
+#define scheme_fuel_counter_ptr (scheme_extension_table->scheme_fuel_counter_ptr)
+#endif
+#endif
+#ifndef NO_SCHEME_THREADS
+#define scheme_make_namespace (scheme_extension_table->scheme_make_namespace)
+#define scheme_thread (scheme_extension_table->scheme_thread)
+#define scheme_break_thread (scheme_extension_table->scheme_break_thread)
+#define scheme_kill_thread (scheme_extension_table->scheme_kill_thread)
+#endif
+#ifndef MZ_REAL_THREADS
+#define scheme_process_block (scheme_extension_table->scheme_process_block)
+#define scheme_swap_process (scheme_extension_table->scheme_swap_process)
+#else
+#define scheme_process_block_w_process (scheme_extension_table->scheme_process_block_w_process)
+#endif
+#define scheme_block_until (scheme_extension_table->scheme_block_until)
+#define scheme_in_main_thread (scheme_extension_table->scheme_in_main_thread)
+#define scheme_tls_allocate (scheme_extension_table->scheme_tls_allocate)
+#define scheme_tls_set (scheme_extension_table->scheme_tls_set)
+#define scheme_tls_get (scheme_extension_table->scheme_tls_get)
+#define scheme_add_namespace_option (scheme_extension_table->scheme_add_namespace_option)
+#define scheme_make_manager (scheme_extension_table->scheme_make_manager)
+#define scheme_add_managed (scheme_extension_table->scheme_add_managed)
+#define scheme_remove_managed (scheme_extension_table->scheme_remove_managed)
+#define scheme_close_managed (scheme_extension_table->scheme_close_managed)
+#define scheme_signal_error (scheme_extension_table->scheme_signal_error)
+#define scheme_raise_exn (scheme_extension_table->scheme_raise_exn)
+#define scheme_warning (scheme_extension_table->scheme_warning)
+#define scheme_wrong_count (scheme_extension_table->scheme_wrong_count)
+#define scheme_case_lambda_wrong_count (scheme_extension_table->scheme_case_lambda_wrong_count)
+#define scheme_wrong_type (scheme_extension_table->scheme_wrong_type)
+#define scheme_wrong_return_arity (scheme_extension_table->scheme_wrong_return_arity)
+#define scheme_unbound_global (scheme_extension_table->scheme_unbound_global)
+#define scheme_dynamic_wind (scheme_extension_table->scheme_dynamic_wind)
+#define scheme_make_type (scheme_extension_table->scheme_make_type)
+#define scheme_install_type_reader (scheme_extension_table->scheme_install_type_reader)
+#define scheme_install_type_writer (scheme_extension_table->scheme_install_type_writer)
+#define scheme_eof (scheme_extension_table->scheme_eof)
+#define scheme_null (scheme_extension_table->scheme_null)
+#define scheme_true (scheme_extension_table->scheme_true)
+#define scheme_false (scheme_extension_table->scheme_false)
+#define scheme_void (scheme_extension_table->scheme_void)
+#define scheme_undefined (scheme_extension_table->scheme_undefined)
+#define scheme_tail_call_waiting (scheme_extension_table->scheme_tail_call_waiting)
+#define scheme_multiple_values (scheme_extension_table->scheme_multiple_values)
+#define scheme_eval (scheme_extension_table->scheme_eval)
+#define scheme_eval_multi (scheme_extension_table->scheme_eval_multi)
+#define scheme_eval_compiled (scheme_extension_table->scheme_eval_compiled)
+#define scheme_eval_compiled_multi (scheme_extension_table->scheme_eval_compiled_multi)
+#define _scheme_eval_compiled (scheme_extension_table->_scheme_eval_compiled)
+#define _scheme_eval_compiled_multi (scheme_extension_table->_scheme_eval_compiled_multi)
+#ifndef MZ_REAL_THREADS
+#define scheme_apply (scheme_extension_table->scheme_apply)
+#define scheme_apply_multi (scheme_extension_table->scheme_apply_multi)
+#else
+#define scheme_apply_wp (scheme_extension_table->scheme_apply_wp)
+#define scheme_apply_multi_wp (scheme_extension_table->scheme_apply_multi_wp)
+#endif
+#define scheme_apply_to_list (scheme_extension_table->scheme_apply_to_list)
+#define scheme_eval_string (scheme_extension_table->scheme_eval_string)
+#define scheme_eval_string_all (scheme_extension_table->scheme_eval_string_all)
+#define _scheme_apply_known_closed_prim (scheme_extension_table->_scheme_apply_known_closed_prim)
+#define _scheme_apply_known_closed_prim_multi (scheme_extension_table->_scheme_apply_known_closed_prim_multi)
+#define scheme_values (scheme_extension_table->scheme_values)
+#define scheme_check_one_value (scheme_extension_table->scheme_check_one_value)
+#define scheme_tail_apply (scheme_extension_table->scheme_tail_apply)
+#define scheme_tail_apply_no_copy (scheme_extension_table->scheme_tail_apply_no_copy)
+#define scheme_tail_apply_to_list (scheme_extension_table->scheme_tail_apply_to_list)
+#define scheme_tail_eval_expr (scheme_extension_table->scheme_tail_eval_expr)
+#define scheme_set_tail_buffer_size (scheme_extension_table->scheme_set_tail_buffer_size)
+#define scheme_force_value (scheme_extension_table->scheme_force_value)
+#ifndef MZ_REAL_THREADS
+#define scheme_do_eval (scheme_extension_table->scheme_do_eval)
+#else
+#define scheme_do_eval_w_process (scheme_extension_table->scheme_do_eval_w_process)
+#endif
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+#define GC_malloc (scheme_extension_table->GC_malloc)
+#define GC_malloc_atomic (scheme_extension_table->GC_malloc_atomic)
+#define GC_malloc_stubborn (scheme_extension_table->GC_malloc_stubborn)
+#define GC_malloc_uncollectable (scheme_extension_table->GC_malloc_uncollectable)
+#endif
+#endif
+#define scheme_malloc_eternal (scheme_extension_table->scheme_malloc_eternal)
+#define scheme_end_stubborn_change (scheme_extension_table->scheme_end_stubborn_change)
+#define scheme_calloc (scheme_extension_table->scheme_calloc)
+#define scheme_strdup (scheme_extension_table->scheme_strdup)
+#define scheme_strdup_eternal (scheme_extension_table->scheme_strdup_eternal)
+#define scheme_malloc_fail_ok (scheme_extension_table->scheme_malloc_fail_ok)
+#define scheme_weak_reference (scheme_extension_table->scheme_weak_reference)
+#define scheme_weak_reference_indirect (scheme_extension_table->scheme_weak_reference_indirect)
+#define scheme_add_finalizer (scheme_extension_table->scheme_add_finalizer)
+#define scheme_add_scheme_finalizer (scheme_extension_table->scheme_add_scheme_finalizer)
+#define scheme_register_finalizer (scheme_extension_table->scheme_register_finalizer)
+#define scheme_dont_gc_ptr (scheme_extension_table->scheme_dont_gc_ptr)
+#define scheme_gc_ptr_ok (scheme_extension_table->scheme_gc_ptr_ok)
+#define scheme_collect_garbage (scheme_extension_table->scheme_collect_garbage)
+#define scheme_hash_table (scheme_extension_table->scheme_hash_table)
+#define scheme_add_to_table (scheme_extension_table->scheme_add_to_table)
+#define scheme_change_in_table (scheme_extension_table->scheme_change_in_table)
+#define scheme_lookup_in_table (scheme_extension_table->scheme_lookup_in_table)
+#define scheme_bucket_from_table (scheme_extension_table->scheme_bucket_from_table)
+#define scheme_make_prim (scheme_extension_table->scheme_make_prim)
+#define scheme_make_noneternal_prim (scheme_extension_table->scheme_make_noneternal_prim)
+#define scheme_make_closed_prim (scheme_extension_table->scheme_make_closed_prim)
+#define scheme_make_prim_w_arity (scheme_extension_table->scheme_make_prim_w_arity)
+#define scheme_make_folding_prim (scheme_extension_table->scheme_make_folding_prim)
+#define scheme_make_noneternal_prim_w_arity (scheme_extension_table->scheme_make_noneternal_prim_w_arity)
+#define scheme_make_closed_prim_w_arity (scheme_extension_table->scheme_make_closed_prim_w_arity)
+#define scheme_make_folding_closed_prim (scheme_extension_table->scheme_make_folding_closed_prim)
+#define scheme_make_closure (scheme_extension_table->scheme_make_closure)
+#define scheme_make_pair (scheme_extension_table->scheme_make_pair)
+#define scheme_make_string (scheme_extension_table->scheme_make_string)
+#define scheme_make_sized_string (scheme_extension_table->scheme_make_sized_string)
+#define scheme_make_string_without_copying (scheme_extension_table->scheme_make_string_without_copying)
+#define scheme_alloc_string (scheme_extension_table->scheme_alloc_string)
+#define scheme_append_string (scheme_extension_table->scheme_append_string)
+#define scheme_make_vector (scheme_extension_table->scheme_make_vector)
+#define scheme_make_integer_value (scheme_extension_table->scheme_make_integer_value)
+#define scheme_make_integer_value_from_unsigned (scheme_extension_table->scheme_make_integer_value_from_unsigned)
+#define scheme_make_double (scheme_extension_table->scheme_make_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_make_float (scheme_extension_table->scheme_make_float)
+#endif
+#define scheme_make_char (scheme_extension_table->scheme_make_char)
+#define scheme_make_promise (scheme_extension_table->scheme_make_promise)
+#define scheme_make_promise_from_thunk (scheme_extension_table->scheme_make_promise_from_thunk)
+#ifndef NO_SCHEME_THREADS
+#define scheme_make_sema (scheme_extension_table->scheme_make_sema)
+#endif
+#define scheme_post_sema (scheme_extension_table->scheme_post_sema)
+#define scheme_wait_sema (scheme_extension_table->scheme_wait_sema)
+#define scheme_char_constants (scheme_extension_table->scheme_char_constants)
+#define scheme_get_int_val (scheme_extension_table->scheme_get_int_val)
+#define scheme_get_unsigned_int_val (scheme_extension_table->scheme_get_unsigned_int_val)
+#define scheme_get_proc_name (scheme_extension_table->scheme_get_proc_name)
+#define scheme_make_bignum (scheme_extension_table->scheme_make_bignum)
+#define scheme_make_bignum_from_unsigned (scheme_extension_table->scheme_make_bignum_from_unsigned)
+#define scheme_bignum_to_double (scheme_extension_table->scheme_bignum_to_double)
+#define scheme_bignum_from_double (scheme_extension_table->scheme_bignum_from_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_bignum_to_float (scheme_extension_table->scheme_bignum_to_float)
+#define scheme_bignum_from_float (scheme_extension_table->scheme_bignum_from_float)
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+#define scheme_bignum_to_string (scheme_extension_table->scheme_bignum_to_string)
+#define scheme_read_bignum (scheme_extension_table->scheme_read_bignum)
+#define scheme_bignum_normalize (scheme_extension_table->scheme_bignum_normalize)
+#define scheme_double_to_int (scheme_extension_table->scheme_double_to_int)
+#define scheme_make_rational (scheme_extension_table->scheme_make_rational)
+#define scheme_rational_to_double (scheme_extension_table->scheme_rational_to_double)
+#define scheme_rational_from_double (scheme_extension_table->scheme_rational_from_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_rational_to_float (scheme_extension_table->scheme_rational_to_float)
+#define scheme_rational_from_float (scheme_extension_table->scheme_rational_from_float)
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+#define scheme_rational_normalize (scheme_extension_table->scheme_rational_normalize)
+#define scheme_rational_numerator (scheme_extension_table->scheme_rational_numerator)
+#define scheme_rational_denominator (scheme_extension_table->scheme_rational_denominator)
+#define scheme_make_complex (scheme_extension_table->scheme_make_complex)
+#define scheme_complex_normalize (scheme_extension_table->scheme_complex_normalize)
+#define scheme_complex_real_part (scheme_extension_table->scheme_complex_real_part)
+#define scheme_complex_imaginary_part (scheme_extension_table->scheme_complex_imaginary_part)
+#define scheme_is_exact (scheme_extension_table->scheme_is_exact)
+#define scheme_is_inexact (scheme_extension_table->scheme_is_inexact)
+#define scheme_expand (scheme_extension_table->scheme_expand)
+#define scheme_compile (scheme_extension_table->scheme_compile)
+#define scheme_make_promise_value (scheme_extension_table->scheme_make_promise_value)
+#define scheme_read (scheme_extension_table->scheme_read)
+#define scheme_write (scheme_extension_table->scheme_write)
+#define scheme_display (scheme_extension_table->scheme_display)
+#define scheme_write_w_max (scheme_extension_table->scheme_write_w_max)
+#define scheme_display_w_max (scheme_extension_table->scheme_display_w_max)
+#define scheme_write_string (scheme_extension_table->scheme_write_string)
+#define scheme_write_to_string (scheme_extension_table->scheme_write_to_string)
+#define scheme_display_to_string (scheme_extension_table->scheme_display_to_string)
+#define scheme_write_to_string_w_max (scheme_extension_table->scheme_write_to_string_w_max)
+#define scheme_display_to_string_w_max (scheme_extension_table->scheme_display_to_string_w_max)
+#define scheme_debug_print (scheme_extension_table->scheme_debug_print)
+#define scheme_flush_output (scheme_extension_table->scheme_flush_output)
+#define scheme_format (scheme_extension_table->scheme_format)
+#define scheme_printf (scheme_extension_table->scheme_printf)
+#define scheme_getc (scheme_extension_table->scheme_getc)
+#define scheme_ungetc (scheme_extension_table->scheme_ungetc)
+#define scheme_char_ready (scheme_extension_table->scheme_char_ready)
+#define scheme_need_wakeup (scheme_extension_table->scheme_need_wakeup)
+#define scheme_get_chars (scheme_extension_table->scheme_get_chars)
+#define scheme_tell (scheme_extension_table->scheme_tell)
+#define scheme_output_tell (scheme_extension_table->scheme_output_tell)
+#define scheme_tell_line (scheme_extension_table->scheme_tell_line)
+#define scheme_close_input_port (scheme_extension_table->scheme_close_input_port)
+#define scheme_close_output_port (scheme_extension_table->scheme_close_output_port)
+#define scheme_are_all_chars_ready (scheme_extension_table->scheme_are_all_chars_ready)
+#define scheme_make_port_type (scheme_extension_table->scheme_make_port_type)
+#define scheme_make_input_port (scheme_extension_table->scheme_make_input_port)
+#define scheme_make_output_port (scheme_extension_table->scheme_make_output_port)
+#define scheme_make_file_input_port (scheme_extension_table->scheme_make_file_input_port)
+#define scheme_make_named_file_input_port (scheme_extension_table->scheme_make_named_file_input_port)
+#define scheme_make_file_output_port (scheme_extension_table->scheme_make_file_output_port)
+#define scheme_make_string_input_port (scheme_extension_table->scheme_make_string_input_port)
+#define scheme_make_sized_string_input_port (scheme_extension_table->scheme_make_sized_string_input_port)
+#define scheme_make_string_output_port (scheme_extension_table->scheme_make_string_output_port)
+#define scheme_get_string_output (scheme_extension_table->scheme_get_string_output)
+#define scheme_get_sized_string_output (scheme_extension_table->scheme_get_sized_string_output)
+#define scheme_pipe (scheme_extension_table->scheme_pipe)
+#define scheme_file_exists (scheme_extension_table->scheme_file_exists)
+#define scheme_directory_exists (scheme_extension_table->scheme_directory_exists)
+#define scheme_expand_filename (scheme_extension_table->scheme_expand_filename)
+#define scheme_getcwd (scheme_extension_table->scheme_getcwd)
+#define scheme_setcwd (scheme_extension_table->scheme_setcwd)
+#define scheme_getdrive (scheme_extension_table->scheme_getdrive)
+#define scheme_split_pathname (scheme_extension_table->scheme_split_pathname)
+#define scheme_build_pathname (scheme_extension_table->scheme_build_pathname)
+#define scheme_alloc_fdset_array (scheme_extension_table->scheme_alloc_fdset_array)
+#define scheme_init_fdset_array (scheme_extension_table->scheme_init_fdset_array)
+#define scheme_get_fdset (scheme_extension_table->scheme_get_fdset)
+#define scheme_fdzero (scheme_extension_table->scheme_fdzero)
+#define scheme_fdset (scheme_extension_table->scheme_fdset)
+#define scheme_fdclr (scheme_extension_table->scheme_fdclr)
+#define scheme_fdisset (scheme_extension_table->scheme_fdisset)
+#define scheme_add_global (scheme_extension_table->scheme_add_global)
+#define scheme_add_global_constant (scheme_extension_table->scheme_add_global_constant)
+#define scheme_add_global_keyword (scheme_extension_table->scheme_add_global_keyword)
+#define scheme_remove_global (scheme_extension_table->scheme_remove_global)
+#define scheme_remove_global_constant (scheme_extension_table->scheme_remove_global_constant)
+#define scheme_add_global_symbol (scheme_extension_table->scheme_add_global_symbol)
+#define scheme_remove_global_symbol (scheme_extension_table->scheme_remove_global_symbol)
+#define scheme_add_global_constant_symbol (scheme_extension_table->scheme_add_global_constant_symbol)
+#define scheme_constant (scheme_extension_table->scheme_constant)
+#define scheme_set_keyword (scheme_extension_table->scheme_set_keyword)
+#define scheme_make_envunbox (scheme_extension_table->scheme_make_envunbox)
+#define scheme_lookup_global (scheme_extension_table->scheme_lookup_global)
+#define scheme_global_bucket (scheme_extension_table->scheme_global_bucket)
+#define scheme_set_global_bucket (scheme_extension_table->scheme_set_global_bucket)
+#define scheme_intern_symbol (scheme_extension_table->scheme_intern_symbol)
+#define scheme_intern_exact_symbol (scheme_extension_table->scheme_intern_exact_symbol)
+#define scheme_make_symbol (scheme_extension_table->scheme_make_symbol)
+#define scheme_make_exact_symbol (scheme_extension_table->scheme_make_exact_symbol)
+#define scheme_symbol_name (scheme_extension_table->scheme_symbol_name)
+#define scheme_symbol_name_and_size (scheme_extension_table->scheme_symbol_name_and_size)
+#define scheme_intern_type_symbol (scheme_extension_table->scheme_intern_type_symbol)
+#define scheme_make_type_symbol (scheme_extension_table->scheme_make_type_symbol)
+#define scheme_make_struct_values (scheme_extension_table->scheme_make_struct_values)
+#define scheme_make_struct_names (scheme_extension_table->scheme_make_struct_names)
+#define scheme_make_struct_type (scheme_extension_table->scheme_make_struct_type)
+#define scheme_make_struct_instance (scheme_extension_table->scheme_make_struct_instance)
+#define scheme_is_struct_instance (scheme_extension_table->scheme_is_struct_instance)
+#ifndef NO_OBJECT_SYSTEM
+#define scheme_make_class (scheme_extension_table->scheme_make_class)
+#define scheme_add_method (scheme_extension_table->scheme_add_method)
+#define scheme_add_method_w_arity (scheme_extension_table->scheme_add_method_w_arity)
+#define scheme_made_class (scheme_extension_table->scheme_made_class)
+#define scheme_make_object (scheme_extension_table->scheme_make_object)
+#define scheme_make_uninited_object (scheme_extension_table->scheme_make_uninited_object)
+#define scheme_find_ivar (scheme_extension_table->scheme_find_ivar)
+#define scheme_is_subclass (scheme_extension_table->scheme_is_subclass)
+#define scheme_is_implementation (scheme_extension_table->scheme_is_implementation)
+#define scheme_is_interface_extension (scheme_extension_table->scheme_is_interface_extension)
+#define scheme_is_a (scheme_extension_table->scheme_is_a)
+#define scheme_get_class_name (scheme_extension_table->scheme_get_class_name)
+#define scheme_get_interface_name (scheme_extension_table->scheme_get_interface_name)
+#define scheme_make_class_assembly (scheme_extension_table->scheme_make_class_assembly)
+#define scheme_create_class (scheme_extension_table->scheme_create_class)
+#define scheme_make_interface_assembly (scheme_extension_table->scheme_make_interface_assembly)
+#define scheme_create_interface (scheme_extension_table->scheme_create_interface)
+#define scheme_apply_generic_data (scheme_extension_table->scheme_apply_generic_data)
+#define scheme_get_generic_data (scheme_extension_table->scheme_get_generic_data)
+#endif
+#define scheme_invoke_unit (scheme_extension_table->scheme_invoke_unit)
+#define scheme_assemble_compound_unit (scheme_extension_table->scheme_assemble_compound_unit)
+#define scheme_make_compound_unit (scheme_extension_table->scheme_make_compound_unit)
+#define scheme_get_unit_name (scheme_extension_table->scheme_get_unit_name)
+#define scheme_eq (scheme_extension_table->scheme_eq)
+#define scheme_eqv (scheme_extension_table->scheme_eqv)
+#define scheme_equal (scheme_extension_table->scheme_equal)
+#define scheme_build_list (scheme_extension_table->scheme_build_list)
+#define scheme_list_length (scheme_extension_table->scheme_list_length)
+#define scheme_proper_list_length (scheme_extension_table->scheme_proper_list_length)
+#define scheme_alloc_list (scheme_extension_table->scheme_alloc_list)
+#define scheme_map_1 (scheme_extension_table->scheme_map_1)
+#define scheme_car (scheme_extension_table->scheme_car)
+#define scheme_cdr (scheme_extension_table->scheme_cdr)
+#define scheme_cadr (scheme_extension_table->scheme_cadr)
+#define scheme_caddr (scheme_extension_table->scheme_caddr)
+#define scheme_vector_to_list (scheme_extension_table->scheme_vector_to_list)
+#define scheme_list_to_vector (scheme_extension_table->scheme_list_to_vector)
+#define scheme_append (scheme_extension_table->scheme_append)
+#define scheme_box (scheme_extension_table->scheme_box)
+#define scheme_unbox (scheme_extension_table->scheme_unbox)
+#define scheme_set_box (scheme_extension_table->scheme_set_box)
+#define scheme_make_weak_box (scheme_extension_table->scheme_make_weak_box)
+#define scheme_load (scheme_extension_table->scheme_load)
+#define scheme_load_extension (scheme_extension_table->scheme_load_extension)
+#define scheme_register_extension_global (scheme_extension_table->scheme_register_extension_global)
+#define scheme_get_milliseconds (scheme_extension_table->scheme_get_milliseconds)
+#define scheme_get_process_milliseconds (scheme_extension_table->scheme_get_process_milliseconds)
+#define scheme_rep (scheme_extension_table->scheme_rep)
+#define scheme_banner (scheme_extension_table->scheme_banner)
+#define scheme_version (scheme_extension_table->scheme_version)
+#define scheme_check_proc_arity (scheme_extension_table->scheme_check_proc_arity)
+#define scheme_secure_exceptions (scheme_extension_table->scheme_secure_exceptions)
+#define scheme_make_provided_string (scheme_extension_table->scheme_make_provided_string)
+#define scheme_make_args_string (scheme_extension_table->scheme_make_args_string)
+#define scheme_no_dumps (scheme_extension_table->scheme_no_dumps)
+#define scheme_system_library_subpath (scheme_extension_table->scheme_system_library_subpath)
diff --git a/collects/mzscheme/include/schexn.h b/collects/mzscheme/include/schexn.h
new file mode 100644
index 0000000..3453803
--- /dev/null
+++ b/collects/mzscheme/include/schexn.h
@@ -0,0 +1,515 @@
+/* This file was generated by makeexn */
+#ifndef _MZEXN_DEFINES
+#define _MZEXN_DEFINES
+
+enum {
+  MZEXN,
+  MZEXN_USER,
+  MZEXN_SYNTAX,
+  MZEXN_VARIABLE,
+  MZEXN_APPLICATION,
+  MZEXN_APPLICATION_NON_PROCEDURE,
+  MZEXN_APPLICATION_ARITY,
+  MZEXN_APPLICATION_TYPE,
+  MZEXN_APPLICATION_RANGE,
+  MZEXN_APPLICATION_RANGE_BOUNDS,
+  MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR,
+  MZEXN_APPLICATION_RANGE_BOUNDS_STRING,
+  MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT,
+  MZEXN_APPLICATION_RANGE_LIST,
+  MZEXN_APPLICATION_LIST_SIZES,
+  MZEXN_APPLICATION_MAP_ARITY,
+  MZEXN_APPLICATION_INTEGER,
+  MZEXN_APPLICATION_LIST,
+  MZEXN_APPLICATION_MATH,
+  MZEXN_APPLICATION_MATH_ZERO,
+  MZEXN_APPLICATION_MATH_INFINITY,
+  MZEXN_APPLICATION_MATH_NEGATIVE,
+  MZEXN_APPLICATION_MATH_RADIX,
+  MZEXN_APPLICATION_MODE_CONFLICT,
+  MZEXN_APPLICATION_FILE_POSITION,
+  MZEXN_APPLICATION_FPRINTF,
+  MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS,
+  MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT,
+  MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE,
+  MZEXN_ELSE,
+  MZEXN_STRUCT,
+  MZEXN_STRUCT_STRUCT_TYPE,
+  MZEXN_OBJECT,
+  MZEXN_OBJECT_CLASS_TYPE,
+  MZEXN_OBJECT_INTERFACE_TYPE,
+  MZEXN_OBJECT_GENERIC,
+  MZEXN_OBJECT_INHERIT,
+  MZEXN_OBJECT_IMPLEMENT,
+  MZEXN_OBJECT_CLASS_IVAR,
+  MZEXN_OBJECT_INTERFACE_IVAR,
+  MZEXN_OBJECT_IVAR,
+  MZEXN_OBJECT_PRIVATE_CLASS,
+  MZEXN_OBJECT_INIT,
+  MZEXN_OBJECT_INIT_MULTIPLE,
+  MZEXN_OBJECT_INIT_NEVER,
+  MZEXN_UNIT,
+  MZEXN_UNIT_NON_UNIT,
+  MZEXN_UNIT_ARITY,
+  MZEXN_UNIT_IMPORT,
+  MZEXN_UNIT_EXPORT,
+  MZEXN_UNIT_INVOKE,
+  MZEXN_UNIT_INVOKE_VARIABLE,
+  MZEXN_UNIT_SIGNATURE,
+  MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT,
+  MZEXN_UNIT_SIGNATURE_ARITY,
+  MZEXN_UNIT_SIGNATURE_MATCH,
+  MZEXN_UNIT_SIGNATURE_MATCH_MISSING,
+  MZEXN_UNIT_SIGNATURE_MATCH_EXTRA,
+  MZEXN_UNIT_SIGNATURE_MATCH_KIND,
+  MZEXN_READ,
+  MZEXN_READ_PAREN,
+  MZEXN_READ_NUMBER,
+  MZEXN_READ_CHAR,
+  MZEXN_READ_EOF,
+  MZEXN_READ_DOT,
+  MZEXN_READ_UNSUPPORTED,
+  MZEXN_READ_VECTOR_LENGTH,
+  MZEXN_READ_COMPILED,
+  MZEXN_READ_GRAPH,
+  MZEXN_I_O,
+  MZEXN_I_O_READ,
+  MZEXN_I_O_WRITE,
+  MZEXN_I_O_FILESYSTEM,
+  MZEXN_I_O_FILESYSTEM_PATH,
+  MZEXN_I_O_FILESYSTEM_PATH_USERNAME,
+  MZEXN_I_O_FILESYSTEM_FILE,
+  MZEXN_I_O_FILESYSTEM_DIRECTORY,
+  MZEXN_I_O_FILESYSTEM_COLLECTION,
+  MZEXN_I_O_FILESYSTEM_FILE_EXISTS,
+  MZEXN_I_O_PORT_CLOSED,
+  MZEXN_I_O_USER_PORT,
+  MZEXN_I_O_TCP,
+  MZEXN_I_O_TCP_CONNECT,
+  MZEXN_I_O_TCP_LISTEN,
+  MZEXN_I_O_TCP_ACCEPT,
+  MZEXN_I_O_TCP_LISTENER_CLOSED,
+  MZEXN_MISC,
+  MZEXN_MISC_UNSUPPORTED,
+  MZEXN_MISC_USER_BREAK,
+  MZEXN_MISC_OUT_OF_MEMORY,
+  MZEXN_MISC_PARAMETERIZATION,
+  MZEXN_MISC_DEFMACRO,
+  MZEXN_MISC_EXPANSION_TIME,
+  MZEXN_MISC_CONSTANT,
+  MZEXN_MISC_CONTINUATION,
+  MZEXN_MISC_THREAD,
+  MZEXN_MISC_THREAD_KILL,
+  MZEXN_MISC_SEMAPHORE,
+  MZEXN_MISC_HASH_TABLE,
+  MZEXN_MISC_REGEXP,
+  MZEXN_MISC_PROCESS,
+  MZEXN_MISC_DYNAMIC_EXTENSION,
+  MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+  MZEXN_MISC_DYNAMIC_EXTENSION_VERSION,
+  MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE,
+  MZEXN_MISC_IMAGE,
+  MZEXN_OTHER
+};
+
+#endif
+
+#ifdef _MZEXN_TABLE
+
+#define MZEXN_MAXARGS 7
+
+#ifdef GLOBAL_EXN_ARRAY
+static exn_rec exn_table[] = {
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 7, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 }
+};
+#else
+static exn_rec *exn_table;
+#endif
+
+#endif
+
+#ifdef _MZEXN_PRESETUP
+
+#ifndef GLOBAL_EXN_ARRAY
+  exn_table = (exn_rec *)scheme_malloc(sizeof(exn_rec) * MZEXN_OTHER);
+  exn_table[MZEXN].args = 2;
+  exn_table[MZEXN_USER].args = 2;
+  exn_table[MZEXN_SYNTAX].args = 3;
+  exn_table[MZEXN_VARIABLE].args = 3;
+  exn_table[MZEXN_APPLICATION].args = 3;
+  exn_table[MZEXN_APPLICATION_NON_PROCEDURE].args = 3;
+  exn_table[MZEXN_APPLICATION_ARITY].args = 4;
+  exn_table[MZEXN_APPLICATION_TYPE].args = 4;
+  exn_table[MZEXN_APPLICATION_RANGE].args = 3;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_STRING].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_LIST].args = 3;
+  exn_table[MZEXN_APPLICATION_LIST_SIZES].args = 3;
+  exn_table[MZEXN_APPLICATION_MAP_ARITY].args = 4;
+  exn_table[MZEXN_APPLICATION_INTEGER].args = 3;
+  exn_table[MZEXN_APPLICATION_LIST].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_ZERO].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_INFINITY].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_NEGATIVE].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_RADIX].args = 3;
+  exn_table[MZEXN_APPLICATION_MODE_CONFLICT].args = 4;
+  exn_table[MZEXN_APPLICATION_FILE_POSITION].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS].args = 4;
+  exn_table[MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE].args = 4;
+  exn_table[MZEXN_ELSE].args = 2;
+  exn_table[MZEXN_STRUCT].args = 2;
+  exn_table[MZEXN_STRUCT_STRUCT_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT].args = 2;
+  exn_table[MZEXN_OBJECT_CLASS_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT_INTERFACE_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT_GENERIC].args = 3;
+  exn_table[MZEXN_OBJECT_INHERIT].args = 3;
+  exn_table[MZEXN_OBJECT_IMPLEMENT].args = 3;
+  exn_table[MZEXN_OBJECT_CLASS_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_INTERFACE_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_PRIVATE_CLASS].args = 3;
+  exn_table[MZEXN_OBJECT_INIT].args = 4;
+  exn_table[MZEXN_OBJECT_INIT_MULTIPLE].args = 4;
+  exn_table[MZEXN_OBJECT_INIT_NEVER].args = 4;
+  exn_table[MZEXN_UNIT].args = 2;
+  exn_table[MZEXN_UNIT_NON_UNIT].args = 3;
+  exn_table[MZEXN_UNIT_ARITY].args = 3;
+  exn_table[MZEXN_UNIT_IMPORT].args = 7;
+  exn_table[MZEXN_UNIT_EXPORT].args = 5;
+  exn_table[MZEXN_UNIT_INVOKE].args = 2;
+  exn_table[MZEXN_UNIT_INVOKE_VARIABLE].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE].args = 2;
+  exn_table[MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE_ARITY].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_MISSING].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_EXTRA].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_KIND].args = 5;
+  exn_table[MZEXN_READ].args = 3;
+  exn_table[MZEXN_READ_PAREN].args = 3;
+  exn_table[MZEXN_READ_NUMBER].args = 4;
+  exn_table[MZEXN_READ_CHAR].args = 4;
+  exn_table[MZEXN_READ_EOF].args = 4;
+  exn_table[MZEXN_READ_DOT].args = 3;
+  exn_table[MZEXN_READ_UNSUPPORTED].args = 4;
+  exn_table[MZEXN_READ_VECTOR_LENGTH].args = 4;
+  exn_table[MZEXN_READ_COMPILED].args = 3;
+  exn_table[MZEXN_READ_GRAPH].args = 3;
+  exn_table[MZEXN_I_O].args = 2;
+  exn_table[MZEXN_I_O_READ].args = 3;
+  exn_table[MZEXN_I_O_WRITE].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_PATH].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_PATH_USERNAME].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_FILE].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_DIRECTORY].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_COLLECTION].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_FILE_EXISTS].args = 3;
+  exn_table[MZEXN_I_O_PORT_CLOSED].args = 3;
+  exn_table[MZEXN_I_O_USER_PORT].args = 3;
+  exn_table[MZEXN_I_O_TCP].args = 2;
+  exn_table[MZEXN_I_O_TCP_CONNECT].args = 4;
+  exn_table[MZEXN_I_O_TCP_LISTEN].args = 3;
+  exn_table[MZEXN_I_O_TCP_ACCEPT].args = 3;
+  exn_table[MZEXN_I_O_TCP_LISTENER_CLOSED].args = 3;
+  exn_table[MZEXN_MISC].args = 2;
+  exn_table[MZEXN_MISC_UNSUPPORTED].args = 2;
+  exn_table[MZEXN_MISC_USER_BREAK].args = 2;
+  exn_table[MZEXN_MISC_OUT_OF_MEMORY].args = 2;
+  exn_table[MZEXN_MISC_PARAMETERIZATION].args = 3;
+  exn_table[MZEXN_MISC_DEFMACRO].args = 3;
+  exn_table[MZEXN_MISC_EXPANSION_TIME].args = 2;
+  exn_table[MZEXN_MISC_CONSTANT].args = 3;
+  exn_table[MZEXN_MISC_CONTINUATION].args = 2;
+  exn_table[MZEXN_MISC_THREAD].args = 2;
+  exn_table[MZEXN_MISC_THREAD_KILL].args = 2;
+  exn_table[MZEXN_MISC_SEMAPHORE].args = 2;
+  exn_table[MZEXN_MISC_HASH_TABLE].args = 3;
+  exn_table[MZEXN_MISC_REGEXP].args = 2;
+  exn_table[MZEXN_MISC_PROCESS].args = 2;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_OPEN].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_VERSION].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE].args = 3;
+  exn_table[MZEXN_MISC_IMAGE].args = 3;
+#endif
+
+#endif
+
+#ifdef _MZEXN_DECL_FIELDS
+
+static const char *MZEXN_FIELDS[2] = { "message", "debug-info" };
+static const char *MZEXN_SYNTAX_FIELDS[1] = { "expr" };
+static const char *MZEXN_VARIABLE_FIELDS[1] = { "id" };
+static const char *MZEXN_APPLICATION_FIELDS[1] = { "value" };
+static const char *MZEXN_APPLICATION_ARITY_FIELDS[1] = { "expected" };
+static const char *MZEXN_APPLICATION_TYPE_FIELDS[1] = { "expected" };
+static const char *MZEXN_APPLICATION_RANGE_BOUNDS_FIELDS[2] = { "min", "max" };
+static const char *MZEXN_APPLICATION_MAP_ARITY_FIELDS[1] = { "provided" };
+static const char *MZEXN_APPLICATION_MODE_CONFLICT_FIELDS[1] = { "filename" };
+static const char *MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS_FIELDS[1] = { "extras" };
+static const char *MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE_FIELDS[1] = { "expected" };
+static const char *MZEXN_STRUCT_STRUCT_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_CLASS_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_INTERFACE_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_GENERIC_FIELDS[1] = { "object" };
+static const char *MZEXN_OBJECT_INHERIT_FIELDS[1] = { "ivar" };
+static const char *MZEXN_OBJECT_IMPLEMENT_FIELDS[1] = { "ivar" };
+static const char *MZEXN_OBJECT_CLASS_IVAR_FIELDS[2] = { "class", "ivar" };
+static const char *MZEXN_OBJECT_INTERFACE_IVAR_FIELDS[2] = { "interface", "ivar" };
+static const char *MZEXN_OBJECT_IVAR_FIELDS[2] = { "object", "ivar" };
+static const char *MZEXN_OBJECT_PRIVATE_CLASS_FIELDS[1] = { "class" };
+static const char *MZEXN_OBJECT_INIT_FIELDS[2] = { "object", "class" };
+static const char *MZEXN_UNIT_NON_UNIT_FIELDS[1] = { "value" };
+static const char *MZEXN_UNIT_ARITY_FIELDS[1] = { "unit" };
+static const char *MZEXN_UNIT_IMPORT_FIELDS[5] = { "in-unit", "out-unit", "in-tag", "out-tag", "name" };
+static const char *MZEXN_UNIT_EXPORT_FIELDS[3] = { "unit", "tag", "name" };
+static const char *MZEXN_UNIT_INVOKE_VARIABLE_FIELDS[1] = { "name" };
+static const char *MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT_FIELDS[1] = { "value" };
+static const char *MZEXN_UNIT_SIGNATURE_ARITY_FIELDS[1] = { "unit" };
+static const char *MZEXN_UNIT_SIGNATURE_MATCH_FIELDS[3] = { "dest-context", "src-context", "variable" };
+static const char *MZEXN_READ_FIELDS[1] = { "port" };
+static const char *MZEXN_READ_NUMBER_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_CHAR_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_EOF_FIELDS[1] = { "expected" };
+static const char *MZEXN_READ_UNSUPPORTED_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_VECTOR_LENGTH_FIELDS[1] = { "input" };
+static const char *MZEXN_I_O_READ_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_WRITE_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_FILESYSTEM_FIELDS[1] = { "pathname" };
+static const char *MZEXN_I_O_PORT_CLOSED_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_USER_PORT_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_TCP_CONNECT_FIELDS[2] = { "address", "port-id" };
+static const char *MZEXN_I_O_TCP_LISTEN_FIELDS[1] = { "port-id" };
+static const char *MZEXN_I_O_TCP_ACCEPT_FIELDS[1] = { "listener" };
+static const char *MZEXN_I_O_TCP_LISTENER_CLOSED_FIELDS[1] = { "listener" };
+static const char *MZEXN_MISC_PARAMETERIZATION_FIELDS[1] = { "value" };
+static const char *MZEXN_MISC_DEFMACRO_FIELDS[1] = { "value" };
+static const char *MZEXN_MISC_CONSTANT_FIELDS[1] = { "id" };
+static const char *MZEXN_MISC_HASH_TABLE_FIELDS[1] = { "key" };
+static const char *MZEXN_MISC_DYNAMIC_EXTENSION_FIELDS[1] = { "name" };
+static const char *MZEXN_MISC_IMAGE_FIELDS[1] = { "name" };
+
+#endif
+
+#ifdef _MZEXN_SETUP
+
+  SETUP_STRUCT(MZEXN, NULL, "exn", 2, MZEXN_FIELDS)
+  SETUP_STRUCT(MZEXN_USER, EXN_PARENT(MZEXN), "exn:user", 0, NULL)
+  SETUP_STRUCT(MZEXN_SYNTAX, EXN_PARENT(MZEXN), "exn:syntax", 1, MZEXN_SYNTAX_FIELDS)
+  SETUP_STRUCT(MZEXN_VARIABLE, EXN_PARENT(MZEXN), "exn:variable", 1, MZEXN_VARIABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION, EXN_PARENT(MZEXN), "exn:application", 1, MZEXN_APPLICATION_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_NON_PROCEDURE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:non-procedure", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_ARITY, EXN_PARENT(MZEXN_APPLICATION), "exn:application:arity", 1, MZEXN_APPLICATION_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_TYPE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:type", 1, MZEXN_APPLICATION_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:range", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS, EXN_PARENT(MZEXN_APPLICATION_RANGE), "exn:application:range:bounds", 2, MZEXN_APPLICATION_RANGE_BOUNDS_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:vector", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_STRING, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:string", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:struct", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_LIST, EXN_PARENT(MZEXN_APPLICATION_RANGE), "exn:application:range:list", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_LIST_SIZES, EXN_PARENT(MZEXN_APPLICATION), "exn:application:list-sizes", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MAP_ARITY, EXN_PARENT(MZEXN_APPLICATION), "exn:application:map-arity", 1, MZEXN_APPLICATION_MAP_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_INTEGER, EXN_PARENT(MZEXN_APPLICATION), "exn:application:integer", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_LIST, EXN_PARENT(MZEXN_APPLICATION), "exn:application:list", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH, EXN_PARENT(MZEXN_APPLICATION), "exn:application:math", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_ZERO, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:zero", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_INFINITY, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:infinity", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_NEGATIVE, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:negative", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_RADIX, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:radix", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MODE_CONFLICT, EXN_PARENT(MZEXN_APPLICATION), "exn:application:mode-conflict", 1, MZEXN_APPLICATION_MODE_CONFLICT_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_FILE_POSITION, EXN_PARENT(MZEXN_APPLICATION), "exn:application:file-position", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF, EXN_PARENT(MZEXN_APPLICATION), "exn:application:fprintf", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:extra-arguments", 1, MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:no-argument", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:argument-type", 1, MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_ELSE, EXN_PARENT(MZEXN), "exn:else", 0, NULL)
+  SETUP_STRUCT(MZEXN_STRUCT, EXN_PARENT(MZEXN), "exn:struct", 0, NULL)
+  SETUP_STRUCT(MZEXN_STRUCT_STRUCT_TYPE, EXN_PARENT(MZEXN_STRUCT), "exn:struct:struct-type", 1, MZEXN_STRUCT_STRUCT_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT, EXN_PARENT(MZEXN), "exn:object", 0, NULL)
+  SETUP_STRUCT(MZEXN_OBJECT_CLASS_TYPE, EXN_PARENT(MZEXN_OBJECT), "exn:object:class-type", 1, MZEXN_OBJECT_CLASS_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INTERFACE_TYPE, EXN_PARENT(MZEXN_OBJECT), "exn:object:interface-type", 1, MZEXN_OBJECT_INTERFACE_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_GENERIC, EXN_PARENT(MZEXN_OBJECT), "exn:object:generic", 1, MZEXN_OBJECT_GENERIC_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INHERIT, EXN_PARENT(MZEXN_OBJECT), "exn:object:inherit", 1, MZEXN_OBJECT_INHERIT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_IMPLEMENT, EXN_PARENT(MZEXN_OBJECT), "exn:object:implement", 1, MZEXN_OBJECT_IMPLEMENT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_CLASS_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:class-ivar", 2, MZEXN_OBJECT_CLASS_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INTERFACE_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:interface-ivar", 2, MZEXN_OBJECT_INTERFACE_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:ivar", 2, MZEXN_OBJECT_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_PRIVATE_CLASS, EXN_PARENT(MZEXN_OBJECT), "exn:object:private-class", 1, MZEXN_OBJECT_PRIVATE_CLASS_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT, EXN_PARENT(MZEXN_OBJECT), "exn:object:init", 2, MZEXN_OBJECT_INIT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT_MULTIPLE, EXN_PARENT(MZEXN_OBJECT_INIT), "exn:object:init:multiple", 0, NULL)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT_NEVER, EXN_PARENT(MZEXN_OBJECT_INIT), "exn:object:init:never", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT, EXN_PARENT(MZEXN), "exn:unit", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_NON_UNIT, EXN_PARENT(MZEXN_UNIT), "exn:unit:non-unit", 1, MZEXN_UNIT_NON_UNIT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_ARITY, EXN_PARENT(MZEXN_UNIT), "exn:unit:arity", 1, MZEXN_UNIT_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_IMPORT, EXN_PARENT(MZEXN_UNIT), "exn:unit:import", 5, MZEXN_UNIT_IMPORT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_EXPORT, EXN_PARENT(MZEXN_UNIT), "exn:unit:export", 3, MZEXN_UNIT_EXPORT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_INVOKE, EXN_PARENT(MZEXN_UNIT), "exn:unit:invoke", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_INVOKE_VARIABLE, EXN_PARENT(MZEXN_UNIT_INVOKE), "exn:unit:invoke:variable", 1, MZEXN_UNIT_INVOKE_VARIABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE, EXN_PARENT(MZEXN_UNIT), "exn:unit:signature", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:non-signed-unit", 1, MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_ARITY, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:arity", 1, MZEXN_UNIT_SIGNATURE_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:match", 3, MZEXN_UNIT_SIGNATURE_MATCH_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_MISSING, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:missing", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_EXTRA, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:extra", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_KIND, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:kind", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ, EXN_PARENT(MZEXN), "exn:read", 1, MZEXN_READ_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_PAREN, EXN_PARENT(MZEXN_READ), "exn:read:paren", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_NUMBER, EXN_PARENT(MZEXN_READ), "exn:read:number", 1, MZEXN_READ_NUMBER_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_CHAR, EXN_PARENT(MZEXN_READ), "exn:read:char", 1, MZEXN_READ_CHAR_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_EOF, EXN_PARENT(MZEXN_READ), "exn:read:eof", 1, MZEXN_READ_EOF_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_DOT, EXN_PARENT(MZEXN_READ), "exn:read:dot", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_UNSUPPORTED, EXN_PARENT(MZEXN_READ), "exn:read:unsupported", 1, MZEXN_READ_UNSUPPORTED_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_VECTOR_LENGTH, EXN_PARENT(MZEXN_READ), "exn:read:vector-length", 1, MZEXN_READ_VECTOR_LENGTH_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_COMPILED, EXN_PARENT(MZEXN_READ), "exn:read:compiled", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_GRAPH, EXN_PARENT(MZEXN_READ), "exn:read:graph", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O, EXN_PARENT(MZEXN), "exn:i/o", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_READ, EXN_PARENT(MZEXN_I_O), "exn:i/o:read", 1, MZEXN_I_O_READ_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_WRITE, EXN_PARENT(MZEXN_I_O), "exn:i/o:write", 1, MZEXN_I_O_WRITE_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM, EXN_PARENT(MZEXN_I_O), "exn:i/o:filesystem", 1, MZEXN_I_O_FILESYSTEM_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_PATH, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:path", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_PATH_USERNAME, EXN_PARENT(MZEXN_I_O_FILESYSTEM_PATH), "exn:i/o:filesystem:path:username", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_FILE, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:file", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_DIRECTORY, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:directory", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_COLLECTION, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:collection", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_FILE_EXISTS, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:file-exists", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_PORT_CLOSED, EXN_PARENT(MZEXN_I_O), "exn:i/o:port-closed", 1, MZEXN_I_O_PORT_CLOSED_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_USER_PORT, EXN_PARENT(MZEXN_I_O), "exn:i/o:user-port", 1, MZEXN_I_O_USER_PORT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP, EXN_PARENT(MZEXN_I_O), "exn:i/o:tcp", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_TCP_CONNECT, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:connect", 2, MZEXN_I_O_TCP_CONNECT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_LISTEN, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:listen", 1, MZEXN_I_O_TCP_LISTEN_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_ACCEPT, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:accept", 1, MZEXN_I_O_TCP_ACCEPT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_LISTENER_CLOSED, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:listener-closed", 1, MZEXN_I_O_TCP_LISTENER_CLOSED_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC, EXN_PARENT(MZEXN), "exn:misc", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_UNSUPPORTED, EXN_PARENT(MZEXN_MISC), "exn:misc:unsupported", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_USER_BREAK, EXN_PARENT(MZEXN_MISC), "exn:misc:user-break", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_OUT_OF_MEMORY, EXN_PARENT(MZEXN_MISC), "exn:misc:out-of-memory", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_PARAMETERIZATION, EXN_PARENT(MZEXN_MISC), "exn:misc:parameterization", 1, MZEXN_MISC_PARAMETERIZATION_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_DEFMACRO, EXN_PARENT(MZEXN_MISC), "exn:misc:defmacro", 1, MZEXN_MISC_DEFMACRO_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_EXPANSION_TIME, EXN_PARENT(MZEXN_MISC), "exn:misc:expansion-time", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_CONSTANT, EXN_PARENT(MZEXN_MISC), "exn:misc:constant", 1, MZEXN_MISC_CONSTANT_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_CONTINUATION, EXN_PARENT(MZEXN_MISC), "exn:misc:continuation", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_THREAD, EXN_PARENT(MZEXN_MISC), "exn:misc:thread", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_THREAD_KILL, EXN_PARENT(MZEXN_MISC_THREAD), "exn:misc:thread:kill", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_SEMAPHORE, EXN_PARENT(MZEXN_MISC), "exn:misc:semaphore", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_HASH_TABLE, EXN_PARENT(MZEXN_MISC), "exn:misc:hash-table", 1, MZEXN_MISC_HASH_TABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_REGEXP, EXN_PARENT(MZEXN_MISC), "exn:misc:regexp", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_PROCESS, EXN_PARENT(MZEXN_MISC), "exn:misc:process", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION, EXN_PARENT(MZEXN_MISC), "exn:misc:dynamic-extension", 1, MZEXN_MISC_DYNAMIC_EXTENSION_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:open", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_VERSION, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:version", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:initialize", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_IMAGE, EXN_PARENT(MZEXN_MISC), "exn:misc:image", 1, MZEXN_MISC_IMAGE_FIELDS)
+
+#endif
diff --git a/collects/mzscheme/include/sconfig.h b/collects/mzscheme/include/sconfig.h
new file mode 100644
index 0000000..2118a74
--- /dev/null
+++ b/collects/mzscheme/include/sconfig.h
@@ -0,0 +1,962 @@
+
+/* 
+   Configuration for compiling MzScheme
+
+   If you want to set all the flags externally (on the command line
+   with -D or some other compiler-dependent way), then define
+   FLAGS_ALREADY_SET, and this file will be ignored.
+
+   One flag cannot be set in this file: INCLUDE_WITHOUT_PATHS.
+   Define this flag if your compiler doesn't like #include
+   statements with relative paths using ".." and "/". (You will
+   have to #define this for Macintosh CodeWarrior in the project 
+   header.)
+
+   The best flag settings are already provided for some auto-detected
+   architecture/system/compilers. Otherwise, the default settings 
+   are generic Unix.  Send other architecture/system/compiler-specific 
+   info to "plt-bugs@cs.rice.edu".
+*/
+
+#ifndef FLAGS_ALREADY_SET
+
+/*************** (BEGIN PLATFORM-INDEPENDENT OPTIONS) *************/
+
+  /***********************/
+ /* Language Extensions */
+/***********************/
+
+ /* NO_FILE_SYSTEM_UTILS removes most file system utilities. */
+
+ /* NO_OBJECT_SYSTEM removes MzScheme's object system. */
+
+ /* NO_REGEXP_UTILS removes MzScheme's regular expression utilities. */
+
+ /* NO_SCHEME_THREADS removes MzScheme's threads from the Scheme user. */
+
+ /* NO_SCHEME_EXNS removes MzScheme's exception system. */
+
+  /*******************************/
+ /* Evaluator Tuning Parameters */
+/*******************************/
+
+#define SCHEME_STACK_SIZE 5000
+
+ /* SCHEME_STACK_SIZE <X> sets the limit for the internal stack
+    for Scheme variables. */
+
+/**************** (END PLATFORM-INDEPENDENT OPTIONS) **************/
+
+
+
+/******** (BEGIN KNOWN ARCHITECTURE/SYSTEM CONFIGURATIONS) ********/
+
+  /************** SunOS/Solaris with gcc ****************/
+
+#if defined(sun)
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define USE_EXPLICT_FP_FORM_CHECK
+# define POW_HANDLES_INF_CORRECTLY
+
+# include <errno.h>
+# ifdef ECHRNG
+/* Solaris */
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "sparc-solaris"
+#  define DIRENT_NO_NAMLEN
+#  define RAND_NOT_RANDOM
+#  define NO_USLEEP
+#  define USE_ULIMIT
+#  define USE_FCNTL_O_NONBLOCK
+
+#  ifdef SOLARIS_THREADS
+#   define MZ_REAL_THREADS
+#   define MZ_USE_SOLARIS_THREADS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_solaris_init_threads(void);
+void scheme_solaris_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void scheme_solaris_exit_thread();
+void scheme_solaris_break_thread(void *th);
+struct Scheme_Process *scheme_solaris_get_current_process();
+void scheme_solaris_set_current_process(struct Scheme_Process *);
+void *scheme_solaris_make_mutex();
+void scheme_solaris_free_mutex(void *);
+void scheme_solaris_lock_mutex(void *);
+void scheme_solaris_unlock_mutex(void *);
+void *scheme_solaris_make_semaphore(int init);
+void scheme_solaris_free_semaphore(void *);
+int scheme_solaris_semaphore_up(void *);
+int scheme_solaris_semaphore_down_breakable(void *);
+int scheme_solaris_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_solaris_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_solaris_create_thread(f, data, slimit, thp)
+#define SCHEME_EXIT_THREAD() scheme_solaris_exit_thread()
+#define SCHEME_BREAK_THREAD(th) scheme_solaris_break_thread(th)
+#define SCHEME_GET_CURRENT_PROCESS() scheme_solaris_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_solaris_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_solaris_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_solaris_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_solaris_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_solaris_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_solaris_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_solaris_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_solaris_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_solaris_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_solaris_semaphore_try_down(s)
+#  endif
+# else
+/* SunOS4 */
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "sparc-sunos4"
+# define SIGSET_IS_SIGNAL
+# endif
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** RS6000/AIX with gcc or xlc ****************/
+
+# if defined(_IBMR2)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "rs6k-aix"
+
+# include "uconfig.h"
+# undef UNIX_DYNAMIC_LOAD
+# undef USE_FCHDIR
+
+# define STACK_GROWS_DOWN
+# define UNIX_LIMIT_STACK 33554944
+
+# define AIX_DYNAMIC_LOAD
+
+# define SELECT_INCLUDE
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** x86/Linux with gcc ****************/
+
+#if defined(linux)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "i386-linux"
+
+# include "uconfig.h"
+# undef HAS_STANDARD_IOB
+#ifndef __ELF__
+# undef UNIX_DYNAMIC_LOAD
+#endif
+
+# define DIRENT_NO_NAMLEN
+
+# define HAS_LINUX_IOB
+
+# define STACK_GROWS_DOWN
+
+# define USE_IEEE_FP_PREDS
+# define LINUX_CONTROL_387
+# define USE_EXPLICT_FP_FORM_CHECK
+
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** x86/FreeBSD with gcc ****************/
+
+# if defined(__FreeBSD__) && defined(i386)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "i386-freebsd"
+
+# include "uconfig.h"
+# undef HAS_STANDARD_IOB
+
+# define HAS_BSD_IOB
+
+# define STACK_GROWS_DOWN
+
+# define UNDERSCORE_DYNLOAD_SYMBOL_PREFIX
+
+# define USE_IEEE_FP_PREDS
+# define FREEBSD_CONTROL_387
+# define POW_HANDLES_INF_CORRECTLY
+
+# define UNIX_LIMIT_FDSET_SIZE
+
+# define SIGSET_IS_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** SGI/IRIX with SGI cc ****************/
+
+#if  (defined(mips) || defined(__mips)) \
+     && !(defined(ultrix) || defined(__ultrix))
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "mips-irix"
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define DIRENT_NO_NAMLEN
+
+# define BSTRING_INCLUDE
+# define RAND_NOT_RANDOM
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define NO_USLEEP
+# define USE_FCNTL_O_NONBLOCK
+
+#  ifdef MZ_X_THREADS
+#    ifndef MZ_FAKE_THREADS
+#      define MZ_FAKE_THREADS
+#    endif
+#  endif
+
+#  ifndef MZ_FAKE_THREADS
+#    ifdef IRIX_SPROCS
+#      define MZ_REAL_THREADS
+#      define MZ_USE_IRIX_SPROCS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_sproc_init_threads(void);
+void  scheme_sproc_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void  scheme_sproc_exit_thread();
+void  scheme_sproc_break_thread(void *);
+struct Scheme_Process *scheme_sproc_get_current_process();
+void  scheme_sproc_set_current_process(struct Scheme_Process *);
+void *scheme_sproc_make_mutex();
+void  scheme_sproc_free_mutex(void *);
+void scheme_sproc_lock_mutex(void *);
+void scheme_sproc_unlock_mutex(void *);
+void *scheme_sproc_make_semaphore(int init);
+void  scheme_sproc_free_semaphore(void *);
+int   scheme_sproc_semaphore_up(void *);
+int   scheme_sproc_semaphore_down_breakable(void *);
+int   scheme_sproc_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_sproc_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_sproc_create_thread(f, data, slimit, thp)
+#define SCHEME_EXIT_THREAD() scheme_sproc_exit_thread()
+#define SCHEME_BREAK_THREAD(th) scheme_sproc_break_thread(th)
+#define SCHEME_GET_CURRENT_PROCESS() scheme_sproc_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_sproc_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_sproc_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_sproc_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_sproc_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_sproc_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_sproc_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_sproc_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_sproc_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_sproc_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_sproc_semaphore_try_down(s)
+#    endif /* IRIX_SPROCS */
+#  endif /* !MZ_FAKE_THREADS */
+
+#  define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** Ultrix with gcc ****************/
+
+#if defined(ultrix) || defined(__ultrix)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "mips-ultrix"
+
+# include "uconfig.h"
+# undef UNIX_DYNAMIC_LOAD
+# undef USE_FCHDIR
+
+# define DIRENT_NO_NAMLEN
+
+# define STACK_GROWS_DOWN
+
+# define RAND_NOT_RANDOM
+
+# define NO_USLEEP
+# define USE_FCNTL_O_NONBLOCK
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** ALPHA/OSF1 with gcc ****************/
+
+# if defined(__alpha)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "alpha-osf1"
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define RAND_NOT_RANDOM
+
+# define SIXTY_FOUR_BIT_INTEGERS
+
+# define ALPHA_CONTROL_FP
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** HP/UX with gcc ****************/
+
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "parisc-hpux"
+
+# include "uconfig.h"
+
+# undef UNIX_DYNAMIC_LOAD
+# define SHL_DYNAMIC_LOAD
+
+# define STACK_GROWS_UP
+
+# define USE_SYSCALL_GETRUSAGE
+
+# define USE_DIVIDE_MAKE_INFINITY
+# define USE_IEEE_FP_PREDS
+# define USE_EXPLICT_FP_FORM_CHECK
+
+# define USE_ULIMIT
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /********* with Borland C++ or MS Visual C++ ************/
+  /* See the "windows" directory for more MSVC details.   */
+  /* MzScheme is probably no longer Borland-friendly,     */
+  /* since it currently relies on one MSVC-style inline   */
+  /* assembly file. Nevertheless, the old flags and       */
+  /* instructions have been preserved.                    */
+  /*                                                      */
+  /* Old Borland instructions:                            */
+  /*   To compile a standalone MzScheme, first #define    */
+  /*   MZWINCONSOLE.                                      */
+  /*   To compile for Windows95, first #define MZWIN95.   */
+  /*   Windows95 version also works under Windows NT, but */
+  /*   not under Win32s. A Win32s version will also work  */
+  /*   under Windows NT.                                  */
+
+#if (defined(__BORLANDC__) || defined(_MSC_VER)) \
+    && (defined(__WIN32__) || defined(WIN32) || defined(_WIN32))
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "win32\\i386"
+
+# define SYSTEM_TYPE_NAME "windows"
+# define DOS_FILE_SYSTEM
+# if defined(_MSC_VER)
+#  define USE_GETDRIVE
+#  define NO_READDIR
+#  define USE_FINDFIRST
+# else
+#  define USE_GETDISK
+#  define DIRENT_NO_NAMLEN
+# endif
+# define NO_READLINK
+# define MKDIR_NO_MODE_FLAG
+
+# define TIME_SYNTAX
+# define USE_FTIME
+# define GETENV_FUNCTION
+# define DIR_FUNCTION
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+
+# if defined(_MSC_VER)
+#  define WINDOWS_FIND_STACK_BOUNDS
+# else
+#  define USE_STACKAVAIL
+# endif
+
+# if defined(_MSC_VER)
+#  define USE_MZ_SETJMP
+# endif
+# define STACK_SAFETY_MARGIN 20000
+
+# define WINDOWS_DYNAMIC_LOAD
+# define LINK_EXTENSIONS_BY_TABLE
+
+# define IGNORE_BY_CONTROL_387
+# if defined(_MSC_VER)
+#  define NAN_EQUALS_ANYTHING
+# endif
+# define POW_HANDLES_INF_CORRECTLY
+
+# define IO_INCLUDE
+# define RAND_NOT_RANDOM
+# define NO_SLEEP
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define PROCESS_FUNCTION
+# define WINDOWS_PROCESSES
+# define DETECT_WIN32_CONSOLE_STDIN
+
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+# define USE_WINSOCK_TCP
+
+# ifdef WIN32_THREADS
+#  define MZ_REAL_THREADS
+#  define MZ_USE_WIN32_THREADS
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_win32_init_threads(void);
+void scheme_win32_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void scheme_win32_exit_thread();
+void scheme_win32_break_thread(void *th);
+struct Scheme_Process *scheme_win32_get_current_process();
+void scheme_win32_set_current_process(struct Scheme_Process *);
+void *scheme_win32_make_mutex();
+void scheme_win32_free_mutex(void *s);
+void scheme_win32_lock_mutex(void *);
+void scheme_win32_unlock_mutex(void *);
+void *scheme_win32_make_semaphore(int init);
+void scheme_win32_free_semaphore(void *s);
+int scheme_win32_semaphore_up(void *);
+int scheme_win32_semaphore_down_breakable(void *);
+int scheme_win32_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_win32_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_win32_create_thread(f, data, slimit, thp)
+#define SCHEME_BREAK_THREAD(th) scheme_win32_break_thread(th)
+#define SCHEME_EXIT_THREAD() scheme_win32_exit_thread()
+#define SCHEME_GET_CURRENT_PROCESS() scheme_win32_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_win32_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_win32_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_win32_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_win32_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_win32_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_win32_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_win32_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_win32_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_win32_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_win32_semaphore_try_down(s)
+# endif
+
+/* MS Visual C++ likes underscore prefixes */
+#if defined(_MSC_VER)
+# define MSC_IZE(x) _ ## x
+# define DIRECT_INCLUDE
+#endif
+
+#if defined(__BORLANDC__)
+# define DIR_INCLUDE
+#endif
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************ Macintosh with CodeWarrior *************/
+
+#if defined(__MWERKS__)
+
+# if defined(__powerc)
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "ppc-mac"
+# else
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "68k-mac"
+# endif
+
+# define SYSTEM_TYPE_NAME "macos"
+# define MAC_FILE_SYSTEM
+
+#define NO_READDIR
+#define NO_READLINK
+#define USE_MAC_FILE_TOOLBOX
+
+# define MACINTOSH_EVENTS
+# define MACINTOSH_GIVE_TIME
+# define MACINTOSH_SIOUX
+
+# if !defined(__powerc)
+#  define MACINTOSH_SET_STACK
+# else
+#  define CODEFRAGMENT_DYNAMIC_LOAD
+# endif
+
+# ifndef MZSCHEME_IS_CODEFRAGMENT
+#  define LINK_EXTENSIONS_BY_TABLE
+# endif
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+# define MACOS_STACK_LIMIT
+# define STACK_SAFETY_MARGIN 10000
+
+# define TIME_SYNTAX
+# define USE_DIFFTIME
+# define DIR_FUNCTION
+# define TIME_TYPE_IS_UNSIGNED
+
+# define RAND_NOT_RANDOM
+# define NO_SYS_INCLUDE_SUBDIR
+# define NO_USLEEP
+# define UNISTD_INCLUDE
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define USE_MAC_TCP
+
+# define SIGSET_IS_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** DOS with Borland C++ ****************/
+  /*          (Never successfully supported)          */
+
+#if defined(__BORLANDC__) && defined(__MSDOS__)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "dos\\i386"
+
+# define USE_SENORA_GC
+# define DOS_FAR_POINTERS
+# define SMALL_HASH_TABLES
+
+# define SYSTEM_TYPE_NAME "dos"
+# define DOS_FILE_SYSTEM
+# define USE_GETDISK
+# define DIRENT_NO_NAMLEN
+# define NO_READLINK
+# define MKDIR_NO_MODE_FLAG
+
+# define TIME_SYNTAX
+# define USE_FTIME
+# define GETENV_FUNCTION
+# define DIR_FUNCTION
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+# define USE_STACKAVAIL
+# define STACK_SAFETY_MARGIN 15000
+
+# define IGNORE_BY_CONTROL_387
+
+# define DIR_INCLUDE
+# define IO_INCLUDE
+# define RAND_NOT_RANDOM
+# define NO_SLEEP
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+/************** (END KNOWN ARCHITECTURE/SYSTEMS) ****************/
+
+
+/***** (BEGIN CONFIGURATION FLAG DESCRPTIONS AND DEFAULTS) ******/
+
+#ifndef FLAGS_ALREADY_SET
+
+  /*********************/
+ /* Operating System  */
+/*********************/
+
+#define SYSTEM_TYPE_NAME "unix"
+
+  /* SYSTEM_TYPE_NAME must be a string; this will be converted into
+     a symbol for the result of (system-type) */
+
+  /* SCHEME_PLATFORM_LIBRARY_SUBPATH must be a string; if it is 
+     undefined, it is automatically generated into a file named
+     "schsys.h" into the same directory as .o files and #included
+     by string.c. This string is returned by (system-library-subpath) */
+
+  /*********************/
+ /* Language Features */
+/*********************/
+
+#define TIME_SYNTAX
+#define PROCESS_FUNCTION
+#define DIR_FUNCTION
+#define GETENV_FUNCTION
+
+ /* TIME_SYNTAX adds the (time ...) syntax; this may need to be
+     turned off for compilation on some systems.
+    CLOCKS_PER_SEC relates the values returned by clock() to
+     real seconds. (The difference between two clock() calls is
+     devided by this number.) Usually, this is defined in <time.h>;
+     it defaults to 1000000 */
+
+ /* USE_FTIME uses ftime instead of gettimeofday; only for TIME_SYNTAX */
+ 
+ /* USE_DIFFTIME uses time and difftime; only for TIME_SYNTAX */
+
+ /* TIME_TYPE_IS_UNSIGNED converts time_t values as unsigned. */
+
+ /* PROCESS_FUNCTION adds (process ...) and (system ...) functions */
+
+ /* DIR_FUNCTION adds (current-directory ...) function */
+
+ /* GETENV_FUNCTION adds (getenv ...) function */
+
+  /*******************/
+ /*   Filesystem    */
+/*******************/
+
+#define UNIX_FILE_SYSTEM
+#define EXPAND_FILENAME_TILDE
+
+ /* UNIX_FILE_SYSTEM indicates that filenames are as in Unix, with
+    forward slash separators, ".." as the parent directory, "/" 
+    as the root directory, and case-sensitivity */
+
+ /* DOS_FILE_SYSTEM indicates that filenames are as in DOS, with 
+    slash or backward slash separators, ".." as the parent directory, 
+    "X:\", "X:/", "\", or "/" as a root directory (for some letter X),
+    and case insensitivity */
+
+ /* MAC_FILE_SYSTEM indicates that filenames are as on the Macintosh,
+    with colon separators, "" as the parent directory, a volume name 
+    (followed by a colon) as a root directory, and case insensitivity. */
+
+ /* EXPAND_FILENAME_TILDE expands ~ in a filename with a user's home
+     directory. */
+
+ /* NO_STAT_PROC means that there is no stat() function. */
+
+ /* NO_MKDIR means that there is no mkdir() function. */
+
+ /* NO_READLINK means that there is no readlink() function. */
+
+ /* USE_GETDISK uses getdisk() and setdisk() to implement the
+     filesystem-root-list primitive under DOS. */
+
+ /* NO_READDIR means that there is no opendir() and readdir() for
+     implementing directory-list. */
+
+ /* DIRENT_NO_NAMLEN specifies that dirent entries do not have a
+     d_namlen field; this is used only when NO_READDIR is not
+     specified. */
+     
+ /* MKDIR_NO_MODE_FLAG specifies that mkdir() takes only one argument,
+     instead of a directory name and mode flags. */
+
+  /***********************/
+ /*       Ports         */
+/***********************/
+
+/* These are flags about the implementation of char-ready? for FILE*s
+   None of these flags are required, but char-ready? may return
+   spurious #ts if they are set up incorrectly. */
+
+#define HAS_STANDARD_IOB
+#define FILES_HAVE_FDS
+#define USE_UNIX_SOCKETS_TCP
+
+ /* HAS_STANDARD_IOB, HAS_GNU_IOB, HAS_LINUX_IOB, and HAS_BSD_IOB
+     are mutually exclusive; they describe how to read the FILE* 
+     structure to determine if there are available cached characters. */
+
+ /* FILES_HAVE_FDS means that a FILE* is always associated with a
+    file desciptor, which can be select-ed to see if there are
+    pending bytes. Don't use this unless one of the HAS_<X>_IOB
+    flags is used. */
+
+ /* USE_UNIX_SOCKETS_TCP means that the tcp- procedures can be implemented
+    with the standard Unix socket functions. */
+
+ /* USE_WINSOCK_TCP means that the tcp- procedures can be implemented
+    with the Winsock toolbox. */
+
+ /* USE_MAC_TCP means that the tcp- procedures can be implemented
+    with the Mac TCP toolbox. */
+
+ /* DETECT_WIN32_CONSOLE_STDIN notices character reads from console
+    stdin so that char-ready? and blocking reads can be implemented
+    correctly (so that Scheme thredas are not blocked when no input
+    is ready). */
+
+ /* USE_FCNTL_O_NONBLOCK uses O_NONBLOCK instead of FNDELAY for
+    fcntl on Unix TCP sockets. (Posix systems need this flag). */
+
+ /* USE_ULIMIT uses ulimit instead of getdtablesize (Unix). */
+
+ /* USE_DYNAMIC_FDSET_SIZE allocates fd_set records based on the
+    current fd limit instead of relying on the compile-time size
+    of fd_set. [This is not known to be actually helpful anywhere
+    currently, particularly not for FreeBSD.] */
+
+ /* UNIX_LIMIT_FDSET_SIZE insures that the fd limit at start-up is
+    no greater than FD_SETSIZE */
+
+  /***********************/
+ /* Processes & Signals */
+/***********************/
+
+/* These are flags about the implementation of system, process, etc. */
+
+# define UNIX_PROCESSES
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+ /* UNIX_PROCESSES implements the process functions for Unix; uses
+    sigset() to install the signal handler. */
+
+ /* WINDOWS_PROCESSES implements the process functions for Windows. */
+
+ /* SIGSET_IS_SIGNAL uses signal() in place of sigset() for Unix. This 
+    flag is often paired with SIGSET_NEEDS_REINSTALL for traditional
+    Unix systems. */
+
+ /* SIGSET_NEEDS_REINSTALL reinstalls a signal handler when it
+    is called to handle a signal. The expected semantics of sigset()
+    (when this flags is not defined) is that a signal handler is NOT
+    reset to SIG_DFL after a handler is called to handle a signal. */
+
+ /* DONT_IGNORE_FPE_SIGNAL stops MzScheme from ignoring floating-point 
+    exception signals. */
+
+ /* DONT_IGNORE_PIPE_SIGNAL stops MzScheme from ignoring SIGPIPE
+    signals. */
+
+  /**********************/
+ /* Inexact Arithmetic */
+/**********************/
+
+ /* USE_SINGLE_FLOATS turns on support for single-precision
+    floating point numbers. Otherwise, floating point numbers
+    are always represented in double-precision. */
+
+ /* USE_SINGLE_FLOATS_AS_DEFAULT, when used with
+    USE_SINGLE_FLOATS, causes exact->inexact coercions to
+    use single-precision numbers as the result rather
+    than double-precision numbers. */
+
+ /* INEXACT_PRINT_DIGITS "<X>" uses <X> as the number of digits to
+     use for printing floating-points. Defaults to "14". */
+
+ /* USE_INFINITY uses infinity() to get the infinity floating-point
+     constant instead of using HUGE_VAL. */
+
+ /* USE_DIVIDE_MAKE_INFINITY creates +inf.0 by dvividing by zero instead
+    of using HUGE_VAL. */
+
+ /* USE_IEEE_FP_PREDS uses isinf() and isnan() to implement tests for
+    infinity. */
+
+ /* IGNORE_BY_CONTROL_387 turns off floating-point error for
+    Intel '387 with _control87. DONT_IGNORE_PIPE_SIGNAL can be on or
+    off. */
+
+ /* FREEBSD_CONTROL_387 controls the floating-point processor under i386
+    FreeBSD */
+
+ /* LINUX_CONTROL_387 controls the floating-point processor under i386
+    Linux */
+
+ /* APLHA_CONTROL_FP controls the floating-point processor for Alpha
+    OSF1 */
+
+ /* NAN_EQUALS_ANYTHING indicates that the compiler is broken and
+    equality comparisons with +nan.0 always return #t. Currently
+    used for MSVC++ */
+
+ /* USE_EXPLICT_FP_FORM_CHECK circumvents bugs in strtod() under Linux,
+    SunOS/Solaris, and HP/UX by explicit pre-checking the form of the 
+    number and looking for values that are obviously +inf.0 or -inf.0 */
+
+ /* POW_HANDLES_INF_CORRECTLY inidicates that thw pow() library procedure
+    handles +/-inf.0 correctly. Otherwise, code in inserted to specifically
+    check for infinite arguments. */
+
+  /***********************/
+ /* Stack Maniuplations */
+/***********************/
+
+# define DO_STACK_CHECK
+# define UNIX_FIND_STACK_BOUNDS
+# define STACK_SAFETY_MARGIN 50000
+
+ /* STACK_GROWS_UP means that deeper stack values have higher
+     numbered addresses.
+    STACK_GROWS_DOWN means that deeper stack values have lower
+     numbered addresses. This is usually the case (Sparc and
+     Intel platforms, for example, use this).
+    Use only one or none of these. (It's faster if you know which
+     one applies, but it can also be figured it out dynamically.) */
+
+ /* DO_STACK_CHECK checks for stack overflow during execution.
+     Requires either UNIX_FIND_STACK_BOUNDS, USE_STACKAVAIL,
+     MACOS_STACK_LIMIT, or ASSUME_FIXED_STACK_SIZE. */
+
+ /* UNIX_FIND_STACK_BOUNDS figures out the maximum stack position
+     on Unix systems, using getrlimit() and the GC_find_stack_base()
+     defined in the conservative garbage collector.
+    USE_STACKAVIL uses stackavail() function for checking stack
+     overflow; works with Borland C++, maybe other compilers.
+    WINDOWS_FIND_STACK_BOUNDS figures out the maximum stack position
+     under Windows (uses GC_find_stack_base())
+    MACOS_STACK_LIMIT figures out the stack limit on the Mac.
+    ASSUME_FIXED_STACK_SIZE assumes that the main stack size is
+     always FIXED_STACK_SIZE.
+    Use only one of these if DO_STACK_CHECK is used, or none otherwise. */
+
+ /* FIXED_STACK_SIZE <X> sets the stack size to <X> when the
+     ASSUME_FIXED_STACK_SIZE stack-checking mode is on. */
+
+ /* STACK_SAFETY_MARGIN <X> sets the number of bytes that should be
+     available on the stack for "safety" to <X>. Used only if
+     DO_STACK_CHECK is used. STACK_SAFETY_MARGIN defaults to 50000. */
+
+ /* ERROR_ON_OVERFLOW causes MzScheme to produce an error if the
+     stack is overflowed. Normally, it would copy out the current
+     stack and try to continue the computation. Used only if
+     DO_STACK_CHECK is used. */
+
+ /* PROCESS_STACK_SIZE <X> sets the size of the allocated stack when
+     SPAWN_NEW_STACK is used. Stack-checking and copying works on these
+     stacks, so that arbitrary computaions can be performed with any
+     size stack. (Well, it can't be *too* small...) */
+
+ /* UNIX_LIMIT_STACK <X> limits stack usage to <X> bytes. This may
+     be necessary to avoid GC-setup traversal over too much memory
+     (with GC flag HEURISTIC2?). */
+
+  /***********************/
+ /*   Dynamic Loading   */
+/***********************/
+
+#define UNIX_DYNAMIC_LOAD
+
+ /* UNIX_DYNAMIC_LOAD implements dynamic extensions under Unix
+     using dlopen(); you may have to add the -ldl flag in the LIBS 
+     Makefile variable. The library doesn't exist under Linux without 
+     ELF, so it won't work. If you get linker errors about dlopen(), etc., 
+     this flag and the -ldl linker flag are the things to adjust.
+    SHL_DYNAMIC_LOAD implement HP/UX dynamic loading.
+    WINDOWS_DYNAMIC_LOAD implements dynamic extensions under Windows
+     (Thanks to Patrick Barta).
+    CODEFRAGMENT_DYNAMIC_LOAD implements dynamic extensions with
+     MacOS's Code Fragment Manager (thanks to William Ng).
+    Use only one or none of these. */
+
+ /* UNDERSCORE_DYNLOAD_SYMBOL_PREFIX with UNIX_DYNAMIC_LOAD menas that
+    an extra underscore ("_") must be placed in front of the name passed 
+    to dlopen(). */
+
+ /* LINK_EXTENSIONS_BY_TABLE specifies that the MzScheme functions
+    used by an extension must be manually linked via a table of
+    function pointers. Windows dynamic linking uses this method. */
+
+ /* MZSCHEME_IS_CODEFRAGMENT exploits improved CFM linking when
+    MzScheme is itself a shared library instead of embedded in
+    an application */
+
+  /***********************/
+ /*     Heap Images     */
+/***********************/
+
+ /* UNIX_IMAGE_DUMPS turns on image save and restore for Unix systems. 
+     This will only work if the final application is statically linked. 
+     (As an exception, the dynamic-linking library itself can be 
+     dynamically linked. This works because loading an extension in 
+     MzScheme automatically turns off image saving.) */
+
+  /*****************************/
+ /*   Macintosh Standalone    */
+/*****************************/
+
+ /* MACINTOSH_EVENTS checks for a user break on the Mac. This should always
+     be defined for MacOS. */
+
+ /* MACINTOSH_GIVE_TIME lets background processes run when checking for
+     a user break. */
+
+ /* MACINTOSH_SIOUX interfaces with Metrowerks's SIOUX library */
+
+ /* MACINTOSH_SET_STACK sets the stack to be 1/4 of the heap. This should
+     be used for 68k machines, where the stack is not user-configurable. */
+
+  /***********************/
+ /*    Miscellaneous    */
+/***********************/
+
+#define UNISTD_INCLUDE
+#define RAND_NOT_RANDOM
+
+ /* SIXTY_FOUR_BIT_INTEGERS indicates that 'long's are 64-bits wide. */
+
+ /* RAND_NOT_RANDOM uses the function rand() instead of random()
+     for random numbers. Some systems don't have random(). */
+
+ /* NO_USER_BREAK_HANDLER turns off handling of INT signal in main.c */
+
+ /* DIR_INCLUDE if there's a <dir.h> file (mainly for Windows). */
+
+ /* DIRECT_INCLUDE if there's a <direct.h> file (mainly for Windows). */
+
+ /* IO_INCLUDE if there's a <io.h> file (mainly for Windows). */
+
+ /* UNISTD_INCLUDE if there's a <unistd.h> file (mainly for Unix). */
+
+ /* SELECT_INCLUDE if there's a <sys/select.h> file (mainly for Unix) 
+     to be used with FILES_HAVE_FDS. */
+
+ /* BSTRING_INCLUDE if there's a <bstring.h> file (mainly for Unix) 
+     to be used with FILES_HAVE_FDS. */
+
+ /* NO_SYS_INCLUDE_SUBDIR if include files should all be <XXX.h>; no
+     includes of the form <sys/XXX.h>. Mainly used for <sys/stat.h>
+     for MacOS. */
+
+ /* USE_FCHDIR uses fchdir() to improve thread context switches when
+    a small number of threads are active. */
+
+ /* USE_GETRUSAGE uses getrusage() to for timing info; otherwise clock()
+    is used. */
+
+ /* USE_SYSCALL_GETRUSAGE uses syscall() to implement getrusage() for
+    timing info. Used with USE_GETRUSAGE. */
+
+ /* NO_SLEEP means that there is no sleep() function. Used only in
+    standalone MzScheme. */
+
+ /* NO_USLEEP means that there is no usleep() function. Used only in 
+    standalone MzScheme. Used only if NO_SLEEP is undefined. */
+
+ /* WIN32S_HACK uses a special hack to implement threads under Win32s
+    with some compilers. Obsolete. */
+
+#endif  /* FLAGS_ALREADY_SET */
+
+/****** (END CONFIGURATION FLAG DESCRPTIONS AND DEFAULTS) *******/
+
+#endif  /* FLAGS_ALREADY_SET */
diff --git a/collects/mzscheme/include/stypes.h b/collects/mzscheme/include/stypes.h
new file mode 100644
index 0000000..e90fc47
--- /dev/null
+++ b/collects/mzscheme/include/stypes.h
@@ -0,0 +1,116 @@
+
+enum {
+
+  /* compiled object types: (internal) */
+  scheme_variable_type,
+  scheme_local_type, 
+  scheme_local_unbox_type,
+  scheme_syntax_type,
+  scheme_application_type,
+  scheme_sequence_type,
+  scheme_branch_type,
+  scheme_unclosed_procedure_type,
+  scheme_let_value_type,
+  scheme_let_void_type,
+  scheme_letrec_type, /* 10 */
+  scheme_let_one_type,
+
+  _scheme_values_types_, /* All following types are values */
+  
+  /* intermediate compiled: */
+  scheme_compiled_unclosed_procedure_type,
+  scheme_compiled_let_value_type,
+  scheme_compiled_let_void_type,
+  scheme_compiled_syntax_type,
+
+  scheme_quote_compilation_type,
+
+  _scheme_compiled_values_types_,
+
+  /* procedure types */
+  scheme_prim_type, /* 19 */
+  scheme_closed_prim_type, /* 20 */
+  scheme_linked_closure_type,
+  scheme_case_closure_type,
+  scheme_cont_type,
+  scheme_escaping_cont_type,
+
+  /* basic types */
+  scheme_char_type, /* 25 */
+  scheme_integer_type,
+  scheme_bignum_type,
+  scheme_rational_type,
+  scheme_float_type,
+  scheme_double_type, /* 30 */
+  scheme_complex_type,
+  scheme_string_type,
+  scheme_symbol_type,
+  scheme_null_type,
+  scheme_pair_type,
+  scheme_vector_type,
+  scheme_closure_type,
+  scheme_input_port_type,
+  scheme_output_port_type,
+  scheme_eof_type,   /* 40 */
+  scheme_true_type,
+  scheme_false_type, 
+  scheme_void_type,
+  scheme_syntax_compiler_type,
+  scheme_macro_type,
+  scheme_promise_type,
+  scheme_box_type,
+  scheme_process_type,
+  scheme_object_type,
+  scheme_class_type,  /* 50 */
+  scheme_structure_type,
+  scheme_generic_type, 
+  scheme_type_symbol_type, 
+  scheme_sema_type,
+  scheme_hash_table_type,
+  scheme_generic_data_type,
+  scheme_weak_box_type, 
+  scheme_struct_type_type,
+  scheme_id_macro_type,
+  scheme_unit_type,  /* 60 */
+  scheme_exp_time_type,
+  scheme_listener_type,
+  scheme_namespace_type, 
+  scheme_config_type,
+  scheme_defaulting_config_type, 
+  scheme_will_executor_type,
+  scheme_interface_type,
+  scheme_manager_type,
+
+  /* These reserved types will let us add types
+     without forcing recompilation of compiled MzScheme code */
+  scheme_reserved_4_type,
+
+  /* more internal types: */
+  scheme_compilation_top_type, /* 70 */
+
+  scheme_envunbox_type,
+  scheme_eval_waiting_type,
+  scheme_tail_call_waiting_type,
+  scheme_class_data_type,
+  scheme_undefined_type, 
+  scheme_struct_info_type,
+  scheme_multiple_values_type,
+  scheme_reserved_5_type,
+  scheme_placeholder_type,
+  scheme_case_lambda_sequence_type, /* 80 */
+  scheme_begin0_sequence_type,
+
+  scheme_compiled_unit_type,
+  scheme_unit_body_data_type,
+  scheme_unit_body_closure_data_type,
+  scheme_unit_compound_data_type,
+  scheme_invoke_unit_data_type,
+
+  scheme_interface_data_type,
+
+  scheme_svector_type,
+
+  _scheme_last_type_
+};
+
+extern char *scheme_get_type_name(Scheme_Type type);
diff --git a/collects/mzscheme/include/uconfig.h b/collects/mzscheme/include/uconfig.h
new file mode 100644
index 0000000..b7bdf41
--- /dev/null
+++ b/collects/mzscheme/include/uconfig.h
@@ -0,0 +1,31 @@
+
+/* Standard settings for Unix platforms. */
+/* Used by sconfig.h for known architectures. */
+
+#define SYSTEM_TYPE_NAME "unix"
+#define UNIX_FILE_SYSTEM
+
+#define TIME_SYNTAX
+#define PROCESS_FUNCTION
+#define DIR_FUNCTION
+#define GETENV_FUNCTION
+
+#define HAS_STANDARD_IOB
+#define FILES_HAVE_FDS
+#define USE_UNIX_SOCKETS_TCP
+
+#define UNIX_PROCESSES
+
+#define EXPAND_FILENAME_TILDE
+
+#define DO_STACK_CHECK
+#define UNIX_FIND_STACK_BOUNDS
+#define STACK_SAFETY_MARGIN 50000
+
+#define UNIX_DYNAMIC_LOAD
+
+#define UNISTD_INCLUDE
+#define USE_FCHDIR
+
+#define USE_GETRUSAGE
+
diff --git a/collects/readline/mzmake b/collects/readline/mzmake
new file mode 100755
index 0000000..fb77492
--- /dev/null
+++ b/collects/readline/mzmake
@@ -0,0 +1,65 @@
+#!/bin/sh -f
+string=? ; if [ "$PLTHOME" = "" ] ; then
+string=? ;  echo Please define PLTHOME 
+string=? ;  exit -1
+string=? ; fi
+string=? ; exec ${PLTHOME}/bin/mzscheme -qr $0 "$@"
+
+(require-library "make.ss" "make")
+(require-library "link.ss" "mzscheme" "dynext")
+(require-library "compile.ss" "mzscheme" "dynext")
+(require-library "file.ss" "mzscheme" "dynext")
+
+(require-library "functio.ss")
+
+(define header (build-path (collection-path "mzscheme" "include") "scheme.h"))
+
+(define dir (build-path "compiled" "native" (system-library-subpath)))
+(define mzrl.so (build-path dir "mzrl.so"))
+(define mzrl.o (build-path dir "mzrl.o"))
+
+(define (add-flags fp flags)
+  (fp (append (fp) flags)))
+
+(define (files dir regexp)
+  (let loop ([l (directory-list dir)])
+    (cond
+     [(null? l) null]
+     [(regexp-match regexp (car l)) (cons (build-path dir (car l))
+					  (loop (cdr l)))]
+     [else (cdr l)])))
+
+; Compiler flags
+(case (string->symbol (system-library-subpath))
+  [(sparc-solaris i386-linux)
+   (add-flags current-extension-compiler-flags
+	      (list "-I/home/mflatt/proj/readline-2.1"))]
+  [(rs6k-aix)
+   (add-flags current-extension-compiler-flags
+	      (list "-DNEEDS_SELECT_H"))]
+  [else (void)])
+
+; Linker flags
+(case (string->symbol (system-library-subpath))
+  [(sparc-solaris)
+   (add-flags current-extension-linker-flags
+	      (list* "-ltermcap"
+		     (files "/home/mflatt/proj/readline-2.1/solaris/" ".*\\.o")))]
+  [(i386-linux)
+   (add-flags current-extension-linker-flags
+	      (files "/home/mflatt/proj/readline-2.1/linux/" ".*\\.o"))]
+  [else (add-flags current-extension-linker-flags (list "-L/usr/local/lib" "-lreadline"))])
+
+(add-flags current-extension-linker-flags (list "-lcurses"))
+
+(make 
+ ((mzrl.so (mzrl.o dir)
+	   (link-extension #f (list mzrl.o) mzrl.so))
+  
+  (mzrl.o ("mzrl.c" header dir)
+	  (compile-extension #f "mzrl.c" mzrl.o ()))
+  
+  (dir ()
+       (make-directory* dir)))
+
+ argv)
diff --git a/collects/readline/mzrl.c b/collects/readline/mzrl.c
new file mode 100644
index 0000000..00ba79c
--- /dev/null
+++ b/collects/readline/mzrl.c
@@ -0,0 +1,84 @@
+
+#include "escheme.h"
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#ifdef NEEDS_SELECT_H
+# include <sys/select.h>
+#endif
+#include <readline/readline.h>
+
+extern Function *rl_event_hook;
+
+Scheme_Object *do_readline(int argc, Scheme_Object **argv)
+{
+  char *s;
+  Scheme_Object *o;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("readline", "string", 0, argc, argv);
+
+  s = readline(SCHEME_STR_VAL(argv[0]));
+  if (!s)
+    return scheme_eof;
+
+  o = scheme_make_string(s);
+  
+  free(s);
+
+  return o;
+}
+
+Scheme_Object *do_add_history(int argc, Scheme_Object **argv)
+{
+  char *s;
+  Scheme_Object *o;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("add-history", "string", 0, argc, argv);
+  
+  add_history(SCHEME_STR_VAL(argv[0]));
+
+  return scheme_void;
+}
+
+static int check(Scheme_Object *x)
+{
+  fd_set fd;
+  struct timeval time = {0, 0};
+
+  FD_ZERO(&fd);
+  FD_SET(0, &fd);
+  return select(1, &fd, NULL, NULL, &time);
+}
+
+static void set_fd_wait(Scheme_Object *x, void *fd)
+{
+  MZ_FD_SET(0, (fd_set *)fd);
+}
+
+static int block(void)
+{  
+  scheme_block_until(check, set_fd_wait, scheme_void, 0.0);
+  return 0;
+}
+
+Scheme_Object *scheme_reload(Scheme_Env *env)
+{
+  Scheme_Object *a[2];
+
+  a[0] = scheme_make_prim_w_arity(do_readline, "readline", 1, 1);
+  a[1] = scheme_make_prim_w_arity(do_add_history, "add-history", 1, 1);
+  
+  return scheme_values(2, a);
+}
+
+Scheme_Object *scheme_initialize(Scheme_Env *env)
+{
+
+  rl_readline_name = "mzscheme";
+
+  rl_event_hook = block;
+
+  return scheme_reload(env);
+}
diff --git a/collects/readline/pread.ss b/collects/readline/pread.ss
new file mode 100644
index 0000000..1ca6d11
--- /dev/null
+++ b/collects/readline/pread.ss
@@ -0,0 +1,61 @@
+
+(let*-values ([(.history) "~/.mzrl.history"]
+	      [(MAX-HISTORY) 100]
+	      [(readline add-history) (require-library "readline.ss" "readline")]
+	      [(leftovers) null]
+	      [(local-history)
+	       (with-handlers ([void (lambda (exn) null)])
+		 (with-input-from-file .history
+		   (lambda () (read))))]
+	      [(do-readline)
+	       (lambda (p)
+		 (let ([s (readline p)])
+		   (when (string? s)
+			 (add-history s)
+			 (if (= (length local-history) MAX-HISTORY)
+			     (set! local-history (cdr local-history)))
+			 (set! local-history (append local-history (list s))))
+		   s))]
+	      [(save-history)
+	       (lambda ()
+		 (with-handlers ([void void])
+		    (with-output-to-file .history
+		      (lambda () (write local-history))
+		      'truncate)))])
+  (exit-handler (let ([old (exit-handler)])
+		  (lambda (v)
+		    (save-history)
+		    (old v))))
+  (for-each add-history local-history)
+  (let ([prompt-read-using-readline
+	 (lambda (get-prompt)
+	   (if (pair? leftovers)
+	       (begin0
+		(car leftovers)
+		(set! leftovers (cdr leftovers)))
+	       (let big-loop ()
+		 (let loop ([s (do-readline (get-prompt 0))][next-pos 1])
+		   (if (eof-object? s)
+		       (begin
+			 (save-history)
+			 s)
+		       (with-handlers ([exn:read:eof?
+					(lambda (exn)
+					  (loop (string-append 
+						 s
+						 (string #\newline)
+						 (do-readline (get-prompt next-pos)))
+						(add1 next-pos)))])
+				      (let* ([p (open-input-string s)]
+					     [rs (let loop ()
+						   (let ([r (read p)])
+						     (if (eof-object? r)
+							 null
+							 (cons r (loop)))))])
+					(if (null? rs)
+					    (big-loop)
+					    (begin0
+					     (car rs)
+					     (set! leftovers (cdr rs)))))))))))])
+    prompt-read-using-readline))
+
diff --git a/collects/readline/readline.ss b/collects/readline/readline.ss
new file mode 100644
index 0000000..f0362ae
--- /dev/null
+++ b/collects/readline/readline.ss
@@ -0,0 +1,2 @@
+
+(load-relative-extension (build-path "compiled" "native" (system-library-subpath) "mzrl.so"))
diff --git a/collects/readline/rep.ss b/collects/readline/rep.ss
new file mode 100644
index 0000000..ec4c60f
--- /dev/null
+++ b/collects/readline/rep.ss
@@ -0,0 +1,5 @@
+
+(current-prompt-read 
+ (let ([read (require-library "pread.ss" "readline")])
+   (lambda ()
+     (read (lambda (n) (if (zero? n) "> " "  "))))))
diff --git a/collects/tests/mred/README b/collects/tests/mred/README
new file mode 100644
index 0000000..97a628a
--- /dev/null
+++ b/collects/tests/mred/README
@@ -0,0 +1,101 @@
+
+The "item.ss" test (use load/cd) creates a frame to select
+among several types of control-testing frames:
+
+ * Big - Tests basic controls; try everything
+
+ * Medium - Tests sliders & gauges; keep a new Big or
+         Medium frame open while getting a new Medium
+         frame to use the "Enable Previous Frame" test
+
+ * Menu - contains its own test instructions
+
+ * Button, Checkbox, etc. - Test everything, watching for
+         messages in the console
+
+For Big & Medium, verify that hide & disbale work (via the checkboxes
+on the right). Hiding or disabling a panel should hde or disable all
+its contained controls. Disbaling a frame (a "Previous" frame) should
+also disbale all of the contained controls.  When "Null label" is
+used, there should *not* be extra space left where a label might have
+gone.
+
+---------------------------------------------------------------------------
+
+The "draw.ss" test (use load/cd) tests drawing commands. There
+is a checkbox for testing drawing into an intermediate offscreen
+bitmap as well. The drawing area should have the following
+features:
+
+  At the top, "Pen 0 x 0" in a consistent font (i.e., re-painting
+    should not change the font)
+  "Pen 1 x 1" in a possibly different font
+  "Pen 2 x 2" in a bold font (bold version of 1x1 font)
+  
+  the drawings under 0x0 and 1x1 should look the same:
+    TopLeft: h-line should be left-aligned with box below it,
+             but extend 1 extra pixel. v-line similarly should be
+             top-aligned and 1 pixel longer. The lines should not 
+             touch the box - there should be 2 pixels of space.
+    Top: Lines for the rotated L's should join in a sharp corner
+    Second from Top: like top-left, but lines should touch the box
+    Four shape lines: First and second should be exactly the same
+             shape, with the first hollow and the second filled.
+             Third shape and 2x2 shapes are ill-defined.
+    Octagons: two hollow octagons exactly the same shape.
+    Line: actually two lines, but they should form a single
+             unbroken line
+    Images: MrEd logo (b & w)
+            BB logo (color)
+            Down-left arrow (b & w)
+            Down-left arrow - B & W, *not* red
+            Down-left arrow - red with white background
+            BB logo, possibly reddened
+            Down-left arrow - red with *white* background
+
+---------------------------------------------------------------------------
+
+The "imred.ss" test is used to check for memory leaks in a loop
+invoking the mred system. Call the `go' procedure with a list
+of symbol flags:
+  'force not included:
+     Use the current eventspaces; expects mred:run-exit-callbacks
+     to terminate everything properly
+  'force included:
+     Use a new eventspace; don't run mred:run-exit-callbacks and
+     call wx:kill-eventspace instead.
+  'console included:
+     Open a MrEd console
+  'thread included:
+     Spawn a sleeping-and-looping thread during each invocation.
+     Also tests semaphore-callback (because it has to)
+  'eventspace included:
+     Create a new sub-eventspace during each invocation with
+     a wx:frame% shown
+
+---------------------------------------------------------------------------
+
+The "mem.ss" test should be loaded at startup:
+  mred -nu -f tests/mem.ss
+It will create a lot of frames and instance of other objects, 
+reporting memory information along the way. At the end,
+before the last memory dump, objects that are still allocated
+are displayed like this:
+  (frame (1 . 5))
+This means that the frame allocated by thread #1 at cycle 5
+(counting down from some number) hasn't been garbage-collected.
+If there's a few of these lines (less than 10), that's ok.
+A large number of lines indicates a GC problem.
+
+---------------------------------------------------------------------------
+
+The "setup.ss" test is a randomized test of the MrEd classes that tests
+MrEd's stability. Load/cd setup.ss, and then run
+  (init)
+This attempts to create instances of classes using random
+intialization arguments. (init) can be run any number of times. Then
+run
+  (call-all-random) 
+This calls every method of every class (skipping some "dangerous" ones
+that modify the file system) with a random instance and with random
+arguments.
diff --git a/collects/tests/mred/draw.ss b/collects/tests/mred/draw.ss
new file mode 100644
index 0000000..8be648b
--- /dev/null
+++ b/collects/tests/mred/draw.ss
@@ -0,0 +1,346 @@
+
+(define sys-path 
+  (lambda (f)
+    (build-path (collection-path "icons") f)))
+
+(let* ([f (make-object mred:frame% ()
+		       "Graphics Test"
+		       -1 -1 300 350)]
+       [vp (make-object mred:vertical-panel% f)]
+       [hp0 (make-object mred:horizontal-panel% vp)]
+       [hp (make-object mred:horizontal-panel% vp)]
+       [hp2 (make-object mred:horizontal-panel% vp)]
+       [bb (make-object wx:bitmap% (sys-path "bb.gif")
+			wx:const-bitmap-type-gif)]
+       [return (make-object wx:bitmap% (sys-path "return.xbm")
+			    wx:const-bitmap-type-xbm)]
+       [tmp-mdc (make-object wx:memory-dc%)]
+       [use-bitmap? #f]
+       [depth-one? #f])
+  (send hp0 stretchable-in-y #f)
+  (send hp stretchable-in-y #f)
+  (send hp2 stretchable-in-y #f)
+  (let ([canvas
+	 (make-object
+	  (make-class mred:canvas%
+	    (inherit get-dc)
+	    (public
+	     [no-bitmaps? #f]
+	     [set-bitmaps (lambda (on?) (set! no-bitmaps? (not on?)) (on-paint))]
+	     [no-stipples? #f]
+	     [set-stipples (lambda (on?) (set! no-stipples? (not on?)) (on-paint))]
+	     [scale 1]
+	     [set-scale (lambda (s) (set! scale s) (on-paint))]
+	     [offset 0]
+	     [set-offset (lambda (o) (set! offset o) (on-paint))]
+	     [on-paint
+	      (case-lambda
+	       [() (on-paint #f)]
+	       [(ps?)
+		(let* ([can-dc (get-dc)]
+		       [pen0s (make-object wx:pen% "BLACK" 0 wx:const-solid)]
+		 [pen1s (make-object wx:pen% "BLACK" 1 wx:const-solid)]
+		 [pen2s (make-object wx:pen% "BLACK" 2 wx:const-solid)]
+		 [pen0t (make-object wx:pen% "BLACK" 0 wx:const-transparent)]
+		 [pen1t (make-object wx:pen% "BLACK" 1 wx:const-transparent)]
+		 [pen2t (make-object wx:pen% "BLACK" 2 wx:const-transparent)]
+		 [brushs (make-object wx:brush% "BLACK" wx:const-solid)]
+		 [brusht (make-object wx:brush% "BLACK" wx:const-transparent)]
+		 [penr (make-object wx:pen% "RED" 1 wx:const-solid)]
+		 [brushb (make-object wx:brush% "BLUE" wx:const-solid)]
+		 [mem-dc (if use-bitmap?
+			     (make-object wx:memory-dc%)
+			     #f)]
+		 [bm (if use-bitmap?
+			 (make-object wx:bitmap% (* scale 300) (* scale 300)
+				      (if depth-one? 1 -1))
+			 #f)]
+		 [draw-series
+		  (lambda (dc pens pent size x y flevel last?)
+		    (let* ([ofont (send dc get-font)])
+		      (if (positive? flevel)
+			  (send dc set-font
+				(make-object wx:font%
+					     10 wx:const-decorative
+					     wx:const-normal 
+					     (if (> flevel 1)
+						 wx:const-bold
+						 wx:const-normal)
+					     #t)))
+
+		      (send dc set-pen pens)
+		      (send dc set-brush brusht)
+		      
+		      ; Test should overlay this line:
+		      (send dc draw-line 
+			    (+ x 3) (+ y 12)
+			    (+ x 40) (+ y 12))
+
+		      (send dc draw-text (string-append size " Pen")
+			    (+ x 5) (+ y 8))
+		      (send dc set-font ofont)
+		      
+		      (send dc draw-line
+			    (+ x 5) (+ y 27) (+ x 10) (+ 27 y))
+		      (send dc draw-rectangle
+			    (+ x 5) (+ y 30) 5 5)
+		      (send dc draw-line
+			    (+ x 12) (+ y 30) (+ x 12) (+ y 35))
+		      
+		      (send dc draw-line
+			    (+ x 5) (+ y 40) (+ x 10) (+ 40 y))
+		      (send dc draw-rectangle
+			    (+ x 5) (+ y 41) 5 5)
+		      (send dc draw-line
+			    (+ x 10) (+ y 41) (+ x 10) (+ 46 y))
+		      
+		      (send dc draw-line
+			    (+ x 15) (+ y 25) (+ x 20) (+ 25 y))
+		      (send dc draw-line
+			    (+ x 20) (+ y 30) (+ x 20) (+ 25 y))
+		      
+		      (send dc draw-line
+			    (+ x 30) (+ y 25) (+ x 25) (+ 25 y))
+		      (send dc draw-line
+			    (+ x 25) (+ y 30) (+ x 25) (+ 25 y))
+		      
+		      (send dc draw-line
+			    (+ x 35) (+ y 30) (+ x 40) (+ 30 y))
+		      (send dc draw-line
+			    (+ x 40) (+ y 25) (+ x 40) (+ 30 y))
+		      
+		      (send dc draw-line
+			    (+ x 50) (+ y 30) (+ x 45) (+ 30 y))
+		      (send dc draw-line
+			    (+ x 45) (+ y 25) (+ x 45) (+ 30 y))
+
+		      ; Check line thickness with "X"
+		      (send dc draw-line
+			    (+ x 20) (+ y 45) (+ x 40) (+ 39 y))
+		      (send dc draw-line
+			    (+ x 20) (+ y 39) (+ x 40) (+ 45 y))
+		      
+		      (send dc draw-rectangle
+			    (+ x 5) (+ y 50) 10 10)
+		      (send dc draw-rounded-rectangle
+			    (+ x 5) (+ y 65) 10 10 3)
+		      (send dc draw-ellipse
+			    (+ x 5) (+ y 80) 10 10)
+		      
+		      (send dc set-brush brushs)
+		      (send dc draw-rectangle
+			    (+ x 17) (+ y 50) 10 10)
+		      (send dc draw-rounded-rectangle
+			    (+ x 17) (+ y 65) 10 10 3)
+		      (send dc draw-ellipse
+			    (+ x 17) (+ y 80) 10 10)
+		      
+		      (send dc set-pen pent)
+		      (send dc draw-rectangle
+			    (+ x 29) (+ y 50) 10 10)
+		      (send dc draw-rounded-rectangle
+			    (+ x 29) (+ y 65) 10 10 3)
+		      (send dc draw-ellipse
+			    (+ x 29) (+ y 80) 10 10)
+		      
+
+		      (send dc set-pen pens)
+		      (send dc draw-rectangle
+			    (+ x 17) (+ y 95) 10 10)
+		      (send dc set-logical-function wx:const-clear)
+		      (send dc draw-rectangle
+			    (+ x 18) (+ y 96) 8 8)
+		      (send dc set-logical-function wx:const-copy)
+		      
+		      (send dc draw-rectangle
+			    (+ x 29) (+ y 95) 10 10)
+		      (send dc set-logical-function wx:const-clear)
+		      (send dc set-pen pent)
+		      (send dc draw-rectangle
+			    (+ x 30) (+ y 96) 8 8)
+
+		      (send dc set-pen pens)
+		      (send dc draw-rectangle
+			    (+ x 5) (+ y 95) 10 10)
+		      (send dc set-logical-function wx:const-xor)
+		      (send dc draw-rectangle
+			    (+ x 5) (+ y 95) 10 10)
+		      (send dc set-logical-function wx:const-copy)
+		      
+		      (send dc draw-line
+			    (+ x 5) (+ y 110) (+ x 8) (+ y 110))
+		      (send dc draw-line
+			    (+ x 8) (+ y 110) (+ x 11) (+ y 113))
+		      (send dc draw-line
+			    (+ x 11) (+ y 113) (+ x 11) (+ y 116))
+		      (send dc draw-line
+			    (+ x 11) (+ y 116) (+ x 8) (+ y 119))
+		      (send dc draw-line
+			    (+ x 8) (+ y 119) (+ x 5) (+ y 119))
+		      (send dc draw-line
+			    (+ x 5) (+ y 119) (+ x 2) (+ y 116))
+		      (send dc draw-line
+			    (+ x 2) (+ y 116) (+ x 2) (+ y 113))
+		      (send dc draw-line
+			    (+ x 2) (+ y 113) (+ x 5) (+ y 110))
+		      
+		      (send dc draw-lines
+			    (list
+			     (make-object wx:point% 5 95)
+			     (make-object wx:point% 8 95)
+			     (make-object wx:point% 11 98)
+			     (make-object wx:point% 11 101)
+			     (make-object wx:point% 8 104)
+			     (make-object wx:point% 5 104)
+			     (make-object wx:point% 2 101)
+			     (make-object wx:point% 2 98)
+			     (make-object wx:point% 5 95))
+			    (+ x 12) (+ y 15))
+
+		      (send dc draw-line
+			    (+ x 5) (+ y 125) (+ x 10) (+ y 125))
+		      (send dc draw-line
+			    (+ x 11) (+ y 125) (+ x 16) (+ y 125))
+
+		      (send dc set-brush brusht)
+		      (send dc draw-arc 
+			    (+ x 20) (+ y 135)
+			    (+ x 5) (+ y 150)
+			    (+ x 20) (+ y 150))
+		      (send dc draw-arc 
+			    (+ x 35) (+ y 150)
+			    (+ x 20) (+ y 135)
+			    (+ x 20) (+ y 150))
+		      (send dc set-brush brushs)
+		      (send dc draw-arc 
+			    (+ x 60) (+ y 135)
+			    (+ x 36) (+ y 150)
+			    (+ x 60) (+ y 150))		
+		      (send dc set-brush brusht)      
+
+		      (unless (or no-bitmaps? (not last?))
+			      (let ([x 5] [y 165])
+				(send dc draw-icon
+				      (mred:get-icon) x y)
+				(set! x (+ x (send (mred:get-icon) get-width)))
+				(let ([do-one
+				       (lambda (bm mode)
+					 (if (send bm ok?)
+					     (begin
+					       (send tmp-mdc select-object bm)
+					       (let ([h (send bm get-height)]
+						     [w (send bm get-width)])
+						 (send dc blit x y 
+						       w h
+						       tmp-mdc 0 0
+						       mode)
+						 (set! x (+ x w 10)))
+					       (send tmp-mdc select-object null))
+					     (printf "bad bitmap~n")))])
+				  (do-one bb wx:const-copy)
+				  (do-one return wx:const-copy)
+				  (send dc set-pen penr)
+				  (do-one return wx:const-copy)
+				  (do-one return wx:const-colour)
+				  (do-one bb wx:const-colour)
+				  (let ([bg (send dc get-background)])
+				    (send dc set-background brushs)
+				    (do-one return wx:const-colour)
+				    (send dc set-background bg))
+				  (send dc set-pen pens))))
+			      
+		      (unless (or no-stipples? (not last?))
+			      (send dc set-brush brushb)
+			      (send dc draw-rectangle 80 200 100 40)
+			      (when (send return ok?)
+				    (let ([b (make-object wx:brush% "GREEN" wx:const-stipple)])
+				      (send b set-stipple return)
+				      (send dc set-brush b)
+				      (send dc draw-rectangle 85 205 30 30)
+				      (send dc set-brush brushs)
+				      (send b set-style wx:const-opaque-stipple)
+				      (send dc set-brush b)
+				      (send dc draw-rectangle 120 205 30 30)
+				      (send dc set-brush brushs)
+				      (send b set-stipple bb)
+				      (send dc set-brush b)
+				      (send dc draw-rectangle 155 205 20 30)
+				      (send dc set-brush brushs)
+				      (send b set-stipple null))))
+
+		      (if (not (or ps? (eq? dc can-dc)))
+			  (send can-dc blit 0 0 
+				(* scale 300) (* scale 300)
+				mem-dc 0 0 wx:const-copy)))
+
+		    'done)])
+
+		  (send (get-dc) set-user-scale 1 1)
+		  (send (get-dc) set-device-origin 0 0)
+
+		  (let ([dc (if ps?
+				(let ([dc (make-object wx:post-script-dc% null #t)])
+				  (and (send dc ok?) dc))
+				(if (and use-bitmap? (send bm ok?))
+				    (begin
+				      (send mem-dc select-object bm)
+				      mem-dc)
+				    (get-dc)))])
+		    (when dc
+			  (when ps?
+				(send dc start-doc "Draw Test")
+				(send dc start-page))
+
+			  (send dc set-user-scale scale scale)
+			  (send dc set-device-origin offset offset)
+
+			  (send dc clear)
+			  ; check default pen/brush:
+			  (send dc draw-rectangle 0 0 5 5)
+			  (send dc draw-line 0 0 20 6)
+
+			  (draw-series dc pen0s pen0t "0 x 0" 5 0 0 #f)
+			  
+			  (draw-series dc pen1s pen1t "1 x 1" 70 0 1 #f)
+			  
+			  (draw-series dc pen2s pen2t "2 x 2" 135 0 2 #t)
+
+			  (when ps?
+				(send dc end-page)
+				(send dc end-doc))))
+		  
+		  'done)])]))
+	  vp 0 50 300 300)])
+    (make-object mred:radio-box% hp0
+		 (lambda (self event)
+		   (set! use-bitmap? (< 0 (send event get-command-int)))
+		   (set! depth-one? (< 1 (send event get-command-int)))
+		   (send canvas on-paint))
+		 null
+		 -1 -1 -1 -1
+		 '("Canvas" "Pixmap" "Bitmap")
+		 0 wx:const-horizontal)
+    (make-object mred:button% hp
+		 (lambda (self event)
+		   (send canvas on-paint #t))
+		 "PostScript")
+    (make-object mred:check-box% hp
+		 (lambda (self event)
+		   (send canvas set-scale (if (send event checked?) 2 1)))
+		 "*2")
+    (make-object mred:check-box% hp
+		 (lambda (self event)
+		   (send canvas set-offset (if (send event checked?) 10 0)))
+		 "+10")
+    (send (make-object mred:check-box% hp2
+		       (lambda (self event)
+			 (send canvas set-bitmaps (send event checked?)))
+		       "Icons")
+	  set-value #t)
+    (send (make-object mred:check-box% hp2
+		       (lambda (self event)
+			 (send canvas set-stipples (send event checked?)))
+		       "Stipples")
+	  set-value #t))
+
+  (send f show #t))
diff --git a/collects/tests/mred/imred.ss b/collects/tests/mred/imred.ss
new file mode 100644
index 0000000..3b3c283
--- /dev/null
+++ b/collects/tests/mred/imred.ss
@@ -0,0 +1,72 @@
+
+(define make-invokable-unit
+  (lambda (application)
+    (let* ([U
+	    (compound-unit/sig (import)
+	      (link [core : mzlib:core^ (mzlib:core@)]
+		    [trigger : mzlib:trigger^ (mzlib:trigger@)]
+		    [mred : mred^ (mred@ core trigger application)]
+		    [application : mred:application^ (application mred core)])
+	      (export (open mred)
+		      (open application)))])
+      (compound-unit/sig (import)
+	 (link [mred : ((open mred^) (open mred:application^)) (U)])
+	 (export (unit mred))))))
+
+(define (go flags)
+  (define die? #f)
+  (define my-app
+    (unit/sig 
+     mred:application^
+     (import mred^ mzlib:core^)
+     
+     (define app-name "Tester")
+     (define console (if (memq 'console flags)
+			 (make-object console-frame%)
+			 #f))
+     (define eval-string pretty-print@:pretty-print)
+     (when (memq 'thread flags)
+	   (let ([s (make-semaphore 1)]
+		 [s2 (make-semaphore 0)]
+		 [done (make-semaphore 0)])
+	     ; Use of semaphore-callback insures that thread is a child
+	     ; of the eventspace
+	     (semaphore-callback s
+				 (lambda ()
+				   (semaphore-post done)
+				   (thread (lambda ()
+					     (let loop ()
+					       (sleep 1)
+					       (loop))))
+				   (when (begin0
+					  die?
+					  (set! die? (not die?)))
+				       (kill-thread (current-thread))))) ; kills handler thread
+	     ; Add another callback that we know will not get triggered
+	     (semaphore-callback s2 void)
+	     (wx:yield done)))
+     (when (memq 'eventspace flags)
+	   (let ([e (wx:make-eventspace)])
+	     (parameterize ([wx:current-eventspace e])
+		(send (make-object wx:frame% null "Testing" -1 -1 100 100)
+		      show #t))))
+     (unless (memq 'force flags)
+	     (run-exit-callbacks))))
+  
+  (let loop ()
+    (collect-garbage)
+    (collect-garbage)
+    (dump-memory-stats)
+    (let ([e (if (memq 'force flags)
+		 (wx:make-eventspace)
+		 (wx:current-eventspace))])
+      (parameterize ([wx:current-eventspace e])
+	  (invoke-unit/sig
+	   (make-invokable-unit my-app)))
+      (when (memq 'force flags)
+	    (wx:kill-eventspace e)))
+    (loop)))
+
+
+
+   
\ No newline at end of file
diff --git a/collects/tests/mred/item.ss b/collects/tests/mred/item.ss
new file mode 100644
index 0000000..b44212d
--- /dev/null
+++ b/collects/tests/mred/item.ss
@@ -0,0 +1,1167 @@
+
+(define my-txt #f)
+
+(define special-font (send wx:the-font-list find-or-create-font
+			   20 wx:const-decorative 
+			   wx:const-bold wx:const-normal
+			   #f))
+
+(define (make-h&s cp f)
+  (make-object mred:button% cp
+	       (lambda (b e) (send f show #f) (send f show #t))
+	       "Hide and Show"))
+
+(define (add-hide name w cp)
+  (let ([c
+	 (make-object mred:check-box% cp
+		      (lambda (c e) (send w show (send c get-value)))
+		      (format "Show ~a" name))])
+    (send c set-value #t)))
+
+(define (add-disable name w ep)
+  (let ([c
+	 (make-object mred:check-box% ep
+		      (lambda (c e) (send w enable (send c get-value)))
+		      (format "Enable ~a" name))])
+    (send c set-value #t)))
+
+(define (add-disable-radio name w i ep)
+  (let ([c
+	 (make-object mred:check-box% ep
+		      (lambda (c e) (send w enable i (send c get-value)))
+		      (format "Enable ~a" name))])
+    (send c set-value #t)))
+
+(define (add-change-label name w lp orig other)
+  (make-object mred:button% lp
+	       (let ([orig-name (if orig orig (send w get-label))]
+		     [changed? #f])
+		 (lambda (b e)
+		   (if changed?
+		       (unless (null? orig-name)
+			 (send w set-label orig-name))
+		       (send w set-label other))
+		   (set! changed? (not changed?))))
+	       (format "Relabel ~a" name)))
+
+(define (add-focus-note frame panel)
+  (define m (make-object mred:message% panel "focus: ??????????????????????????????"))
+  (send
+   (make-object
+    (class-asi wx:timer%
+      (inherit start)
+      (public
+	[notify
+	 (lambda ()
+	   (when (send frame is-shown?)
+	     (send m set-label
+		   (format "focus: ~s" (mred:test:get-focused-window)))
+	     (start 1000 #t)))])))
+   start 1000 #t))
+
+(define OTHER-LABEL "XXXXXXXXXXXXXXXXXXXXXX")
+
+(define-values (icons-path local-path)
+  (let ([d (current-load-relative-directory)])
+    (values
+     (lambda (n)
+       (build-path (collection-path "icons") n))
+     (lambda (n)
+       (build-path d n)))))
+
+(define popup-test-canvas%
+  (class mred:canvas% (objects names . args)
+    (inherit popup-menu draw-text clear)
+    (public
+      [last-m null]
+      [last-choice #f]
+      [on-paint
+       (lambda ()
+	 (clear)
+	 (draw-text "Left: popup hide state" 0 0)
+	 (draw-text "Right: popup previous" 0 20)
+	 (draw-text (format "Last pick: ~s" last-choice) 0 40))]
+      [on-event
+       (lambda (e)
+	 (if (send e button-down?)
+	     (let ([x (send e get-x)]
+		   [y (send e get-y)]
+		   [m (if (or (null? last-m)
+			      (send e button-down? 1))
+			  (let ([m (make-object mred:menu%
+						"Title"
+						(lambda (m e)
+						  (set! last-choice
+							(send e get-command-int))
+						  (on-paint)))]
+				[id 1])
+			    (for-each
+			     (lambda (obj name)
+			       (send m append
+				     (begin0 id (set! id (add1 id)))
+				     (string-append
+				      name ": "
+				      (if (send obj is-shown?)
+					  "SHOWN"
+					  "<h i d d e n>"))))
+			     objects names)
+			    m)
+			  last-m)])
+	       (set! last-m m)
+	       (popup-menu m x y))))])
+    (sequence
+      (apply super-init args))))
+
+(define prev-frame #f)
+
+(define bitmap%
+  (class wx:bitmap% args
+    (inherit ok?)
+    (sequence
+      (apply super-init args)
+      (unless (ok?)
+	(printf "bitmap failure: ~s~n" args)))))
+
+(define (make-ctls ip cp lp add-testers ep radio-h? label-h? null-label? stretchy?)
+  
+  (define return-bmp 
+    (make-object bitmap% (icons-path "return.xbm")
+		 wx:const-bitmap-type-xbm))
+  (define bb-bmp
+    (make-object bitmap% (icons-path "bb.gif")
+		 wx:const-bitmap-type-gif))
+  (define mred-bmp
+    (make-object bitmap% (icons-path "mred.xbm")
+		 wx:const-bitmap-type-xbm))
+  (define nruter-bmp
+    (make-object bitmap% (local-path "nruter.xbm")
+		 wx:const-bitmap-type-xbm))
+  
+  (define :::dummy:::
+    (when (not label-h?)
+      (send ip set-label-position wx:const-vertical)))
+  
+  (define-values (l il)
+    (let ([p (make-object mred:horizontal-panel% ip)])
+      (send p stretchable-in-x stretchy?)
+      (send p stretchable-in-y stretchy?)
+      
+      (begin
+	(define l (make-object mred:message% p "Me&ssage"))
+	(define il (make-object mred:message% p return-bmp))
+	
+	(add-testers "Message" l)
+	(add-change-label "Message" l lp #f OTHER-LABEL)
+	
+	(add-testers "Image Message" il)
+	(add-change-label "Image Message" il lp return-bmp nruter-bmp)
+	
+	(values l il))))
+  
+  (define b (make-object mred:button% ip void "He&llo"))
+  
+  (define ib (make-object mred:button% ip void bb-bmp))
+  
+  ; (define ib2 (make-object mred:button% ip void return-bmp))
+  
+  (define lb (make-object mred:list-box% ip void 
+			  (if null-label? null "L&ist")
+			  0 -1 -1 -1 -1
+			  '("Apple" "Banana" "Coconut & Donuts")))
+  
+  (define cb (make-object mred:check-box% ip void "C&heck"))
+  
+  (define icb (make-object mred:check-box% ip void mred-bmp))
+  
+  (define rb (make-object mred:radio-box% ip void 
+			  (if null-label? null "R&adio")
+			  -1 -1 -1 -1
+			  '("First" "Dos" "T&rio")
+			  0 (if radio-h?
+				wx:const-horizontal
+				wx:const-vertical)))
+  
+  (define irb (make-object mred:radio-box% ip void 
+			   (if null-label? null "Image Ra&dio")
+			   -1 -1 -1 -1
+			   (list return-bmp nruter-bmp)
+			   0 (if radio-h?
+				 wx:const-horizontal
+				 wx:const-vertical)))
+  
+  (define ch (make-object mred:choice% ip void 
+			  (if null-label? null "Ch&oice")
+			  -1 -1 -1 -1
+			  '("Alpha" "Beta" "Gamma" "Delta & Rest")))
+  
+  (define txt (make-object mred:text% ip void 
+			   (if null-label? null "T&ext")
+			   "initial & starting"
+			   -1 -1 -1 -1))
+  
+  (set! my-txt txt)
+  
+  (add-testers "Button" b)
+  (add-change-label "Button" b lp #f OTHER-LABEL)
+  
+  (add-testers "Image Button" ib)
+  (add-change-label "Image Button" ib lp bb-bmp return-bmp)
+  
+  (add-testers "List" lb)
+  (add-change-label "List" lb lp #f OTHER-LABEL)
+  
+  (add-testers "Checkbox" cb)
+  (add-change-label "Checkbox" cb lp #f OTHER-LABEL)
+  
+  (add-testers "Image Checkbox" icb)
+  (add-change-label "Image Checkbox" icb lp mred-bmp bb-bmp)
+  
+  (add-testers "Radiobox" rb)
+  (add-disable-radio "Radio Item `First'" rb 0 ep)
+  (add-disable-radio "Radio Item `Dos'" rb 1 ep)
+  (add-disable-radio "Radio Item `Trio'" rb 2 ep)
+  (add-change-label "Radiobox" rb lp #f OTHER-LABEL)
+  
+  (add-testers "Image Radiobox" irb)
+  (add-disable-radio "Radio Image Item 1" irb 0 ep)
+  (add-disable-radio "Radio Image Item 2" irb 1 ep)
+  (add-change-label "Image Radiobox" irb lp #f OTHER-LABEL)
+  
+  (add-testers "Choice" ch)
+  (add-change-label "Choice" ch lp #f OTHER-LABEL)
+  
+  (add-testers "Text" txt)
+  (add-change-label "Text" txt lp #f OTHER-LABEL)
+  
+  (make-object popup-test-canvas% 
+	       (list l il 
+		     b ib
+		     lb
+		     cb icb
+		     rb irb
+		     ch
+		     txt)
+	       (list "label" "image label"
+		     "button" "image button"
+		     "list box"
+		     "checkbox" "image checkbox"
+		     "radio box" "image radiobox"
+		     "choice"
+		     "text")
+	       cp))
+
+(define (big-frame h-radio? v-label? null-label? stretchy? special-font?)
+  (define f (make-object mred:frame% null "Tester"))
+  
+  (define hp (make-object mred:horizontal-panel% f))
+  
+  (define ip (make-object mred:vertical-panel% hp))
+  (define cp (make-object mred:vertical-panel% hp))
+  (define ep (make-object mred:vertical-panel% hp))
+  (define lp (make-object mred:vertical-panel% hp))
+  
+  (define (basic-add-testers name w)
+    (add-hide name w cp)
+    (add-disable name w ep))
+  
+  (define add-testers
+    (if stretchy?
+	(lambda (name control)
+	  (send control stretchable-in-x #t)
+	  (send control stretchable-in-y #t)
+	  (basic-add-testers name control))
+	basic-add-testers))
+  
+  (define fp (make-object mred:vertical-panel% ip))
+  
+  (define tp (make-object mred:vertical-panel% fp))
+
+  (make-h&s cp f)
+  
+  (add-testers "Sub-panel" fp)
+  
+  (add-testers "Sub-sub-panel" tp)
+
+  (when special-font?
+    (send tp set-label-font special-font))
+    
+  (make-ctls tp cp lp add-testers ep h-radio? v-label? null-label? stretchy?)
+  
+  (add-focus-note f ep)
+  
+  (send f show #t)
+  (set! prev-frame f)
+  f)
+
+(define (med-frame radio-h? label-h? null-label? stretchy? special-font?)
+  (define f2 (make-object mred:frame% null "Tester2"))
+  
+  (define hp2 (make-object mred:horizontal-panel% f2))
+  
+  (define ip2 (make-object mred:vertical-panel% hp2))
+  (define cp2 (make-object mred:vertical-panel% hp2))
+  (define ep2 (make-object mred:vertical-panel% hp2))
+  (define lp2 (make-object mred:vertical-panel% hp2))
+  
+  (define (basic-add-testers2 name w)
+    (add-hide name w cp2)
+    (add-disable name w ep2))
+  
+  (define add-testers2
+    (if stretchy?
+	(lambda (name control)
+	  (send control stretchable-in-x #t)
+	  (send control stretchable-in-y #t)
+	  (basic-add-testers2 name control))
+	basic-add-testers2))
+  
+  (make-h&s cp2 f2)
+  
+  (add-disable "Previous Tester Frame" prev-frame ep2)
+  
+  (when (not label-h?)
+    (send ip2 set-label-position wx:const-vertical))
+
+  (when special-font?
+    (send ip2 set-label-font special-font))
+  
+  (begin
+    (define sh (make-object mred:slider% ip2
+			    (lambda (s e)
+			      (send gh set-value (send sh get-value)))
+			    (if null-label? null "H S&lider")
+			    5 0 10 -1 -1 -1
+			    wx:const-horizontal))
+    
+    (define sv (make-object mred:slider% ip2 
+			    (lambda (s e)
+			      (send gv set-value (send sv get-value)))
+			    (if null-label? null "V Sl&ider")
+			    5 0 10 -1 -1 -1
+			    wx:const-vertical))
+    
+    (define gh (make-object mred:gauge% ip2
+			    (if null-label? null "H G&auge")
+			    10 -1 -1 -1 -1
+			    wx:const-horizontal))
+    
+    (define gv (make-object mred:gauge% ip2
+			    (if null-label? null "V Ga&uge")
+			    10 -1 -1 -1 -1
+			    wx:const-vertical))
+    
+    (define cmt (make-object mred:canvas-message% ip2
+			     "Howdy"))
+    
+    (define cmi (make-object mred:canvas-message% ip2
+			     (make-object bitmap% (icons-path "bb.gif")
+					  wx:const-bitmap-type-gif)))
+    
+
+    (define txt (make-object mred:media-text% ip2 void 
+			     (if null-label? null "T&ext")
+			     "initial & starting"
+			     -1 -1 -1 -1))
+
+    (add-testers2 "Horiz Slider" sh)
+    (add-testers2 "Vert Slider" sv)
+    (add-testers2 "Horiz Gauge" gh)
+    (add-testers2 "Vert Gauge" gv)
+    (add-testers2 "Text Message" cmt)
+    (add-testers2 "Image Message" cmi)
+    (add-testers2 "Text" txt)
+    
+    (add-change-label "Horiz Slider" sh lp2 #f OTHER-LABEL)
+    (add-change-label "Vert Slider" sv lp2 #f OTHER-LABEL)
+    (add-change-label "Horiz Gauge" gh lp2 #f OTHER-LABEL)
+    (add-change-label "Vert Gauge" gv lp2 #f OTHER-LABEL)
+    (add-change-label "Text" txt lp2 #f OTHER-LABEL)
+    
+    (add-focus-note f2 ep2)
+    
+    (send f2 show #t)
+    (set! prev-frame f2)
+    f2))
+
+; Need: check, check-test, and enable via menubar
+; All operations on Submenus
+(define f%
+  (let-enumerate 
+      ([ADD-APPLE
+	ADD-BANANA
+	ADD-COCONUT
+	DELETE-APPLE
+	DELETE-BANANA
+	DELETE-COCONUT-0
+	DELETE-COCONUT
+	DELETE-COCONUT-2
+	COCONUT-ID
+	DELETE-ONCE
+	APPLE-CHECK-ID])
+    (class mred:menu-frame% args
+      (inherit next-menu-id make-menu)
+      (rename
+	[super-make-menu-bar make-menu-bar]
+	[super-on-menu-command on-menu-command])
+      (private
+	offset
+	menu-bar
+	main-menu
+	apple-menu
+	banana-menu
+	coconut-menu
+	baseball-ids
+	hockey-ids
+	enable-item)
+      (public
+	[make-menu-bar
+	 (lambda ()
+	   (let ([mb (super-make-menu-bar)]
+		 [menu (make-menu)])
+	     (set! offset (next-menu-id))
+	     (set! menu-bar mb)
+	     (set! main-menu menu)
+	     
+	     (send menu append (+ offset ADD-APPLE) "Add Apple" "Adds the Apple menu")
+	     (send menu append (+ offset ADD-BANANA) "Add Banana")
+	     (send menu append (+ offset ADD-COCONUT) "Add Coconut")
+	     (send menu append-item "Append Donut"
+		   (lambda () (send apple-menu append-item "Donut" void)))
+	     (send menu append-separator)
+	     (send menu append (+ offset DELETE-COCONUT-0)
+		   "Delete Coconut")
+	     (send menu append-item "Delete Apple"
+		   (lambda () 
+		     (send menu-bar delete apple-menu)
+		     (set! apple-installed? #f)))
+	     
+	     (send menu append-separator)
+	     (set! enable-item
+		   (send menu append-item "Apple Once Disabled"
+			 (lambda ()
+			   (send apple-menu enable DELETE-ONCE
+				 (not (send menu checked? enable-item))))
+			 null #t))
+	     (send menu append-item "Disable Second"
+		   (lambda () (send menu-bar enable-top 1 #f)))
+	     (send menu append-item "Enable Second"
+		   (lambda () (send menu-bar enable-top 1 #t)))
+	     
+	     (send menu append-separator)
+	     (set! baseball-ids
+		   (send menu append-check-set
+			 (list "Astros" "Braves" "Cardinals")
+			 (lambda (which)
+			   (wx:message-box (format "~s Checked" which)))))
+	     (send menu append-separator)
+	     (set! hockey-ids
+		   (send menu append-check-set
+			 `(("Aeros" . Houston) 
+			   ("Bruins" . Boston)
+			   ("Capitols" . Washington))
+			 (lambda (which)
+			   (wx:message-box (format "~s Checked" which)))))
+	     
+	     (set! apple-menu (make-menu))
+	     (set! banana-menu (make-menu))
+	     (set! coconut-menu (make-menu))
+	     
+	     (send apple-menu append (+ offset DELETE-ONCE)
+		   "Delete Once")
+	     (send apple-menu append (+ offset DELETE-APPLE)
+		   "Delete Apple" "Deletes the Apple menu")
+	     (send apple-menu append (+ offset APPLE-CHECK-ID)
+		   "Checkable" null #t)
+	     
+	     (send banana-menu append (+ offset DELETE-BANANA)
+		   "Delete Banana")
+	     (send coconut-menu append (+ offset DELETE-COCONUT)
+		   "Delete Coconut")
+	     (send coconut-menu append (+ offset DELETE-COCONUT-2)
+		   "Delete Coconut By Position")
+	     
+	     (send mb append menu "Tester")
+	     (send mb append apple-menu "Appul")
+	     (send mb enable-top 1 #f)
+	     (send mb set-label-top 1 "Apple")
+	     mb))]
+	[on-menu-command
+	 (lambda (orig-op)
+	   (let ([op (- orig-op offset)])
+	     (cond
+	       [(= op ADD-APPLE)
+		(send menu-bar append apple-menu "Apple")
+		(set! apple-installed? #t)]
+	       [(= op ADD-BANANA)
+		(send menu-bar append banana-menu "Banana")]
+	       [(= op ADD-COCONUT)
+		(send apple-menu append (+ offset COCONUT-ID)
+		      "Coconut" coconut-menu "Submenu")]
+	       [(= op DELETE-ONCE)
+		(send apple-menu delete (+ offset DELETE-ONCE))]
+	       [(= op DELETE-APPLE)
+		(send menu-bar delete apple-menu)
+		(set! apple-installed? #f)]
+	       [(= op DELETE-BANANA)
+		(send menu-bar delete banana-menu)]
+	       [(or (= op DELETE-COCONUT) (= op DELETE-COCONUT-0))
+		(send apple-menu delete (+ offset COCONUT-ID))]
+	       [(= op DELETE-COCONUT-2)
+		(send apple-menu delete-by-position 3)]
+	       [else
+		(super-on-menu-command orig-op)])))])
+      (sequence (apply super-init args))
+      (public
+	[mfp (make-object mred:vertical-panel% (ivar this panel))]
+	[mc (make-object mred:wrapping-canvas% mfp -1 -1 200 200)]
+	[restp (make-object mred:vertical-panel% mfp)]
+	[mfbp (make-object mred:horizontal-panel% restp)]
+	[lblp (make-object mred:horizontal-panel% restp)]
+	[badp (make-object mred:horizontal-panel% restp)]
+	[e (make-object mred:media-edit%)])
+      (sequence
+	(send restp stretchable-in-y #f)
+	(send mc set-media e)
+	(send e load-file (local-path "steps.txt")))
+      (public
+	[make-test-button
+	 (lambda (name pnl menu id)
+	   (make-object mred:button% pnl 
+			(lambda (b e)
+			  (wx:message-box
+			   (if (send (via menu) checked? id)
+			       "yes"
+			       "no")
+			   "Checked?"))
+			(format "Test ~a" name)))]
+	[make-bad-test
+	 (lambda (method)
+	   (lambda args
+	     (method 777 #t)
+	     (method 777 #f)
+	     (method -1 #t)
+	     (method -1 #f)))]
+	[compare
+	 (lambda (expect v kind)
+	   (unless (or (and (string? expect) (string? v)
+			    (string=? expect v))
+		       (eq? expect v))
+	     (error 'test-compare "~a mistmatch: ~s != ~s" kind expect v)))]
+	[label-test
+	 (lambda (menu id expect)
+	   (let ([v (send menu get-label id)])
+	     (compare expect v "label")))]
+	[top-label-test
+	 (lambda (pos expect)
+	   (let ([v (send menu-bar get-label-top pos)])
+	     (compare expect v "top label")))]
+	[help-string-test
+	 (lambda (menu id expect)
+	   (let ([v (send menu get-help-string id)])
+	     (compare expect v "help string")))]
+	[find-test
+	 (lambda (menu title expect string)
+	   (let ([v (if use-menubar? 
+			(send menu-bar find-menu-item title string)
+			(send menu find-item string))])
+	     (compare expect v (format "label search: ~a" string))))]
+	[tell-ok
+	 (lambda ()
+	   (printf "ok~n"))]
+	[temp-labels? #f]
+	[use-menubar? #f]
+	[apple-installed? #f]
+	[via (lambda (menu) (if use-menubar? menu-bar menu))]
+	[tmp-pick (lambda (a b) (if temp-labels? a b))]
+	[apple-pick (lambda (x a b) (if (and use-menubar? (not apple-installed?))
+					x
+					(tmp-pick a b)))])
+      (sequence
+(make-test-button "Aeros" mfbp main-menu (list-ref hockey-ids 0))
+      (make-test-button "Bruins" mfbp main-menu (list-ref hockey-ids 1))
+      (make-test-button "Capitols" mfbp main-menu (list-ref hockey-ids 2))
+      (make-test-button "Apple Item" mfbp apple-menu APPLE-CHECK-ID)
+      (make-object mred:button% mfbp
+		   (lambda args
+		     (send (via apple-menu) check APPLE-CHECK-ID #t))
+		   "Check in Apple")
+			   
+      (make-object mred:button% lblp 
+		   (lambda args
+		     (label-test (via main-menu) ADD-APPLE (tmp-pick "Apple Adder" "Add Apple"))
+		     (help-string-test (via main-menu) ADD-APPLE (tmp-pick "ADDER" "Adds the Apple menu"))
+		     (label-test (via main-menu) (car baseball-ids) (tmp-pick "'Stros" "Astros"))
+		     (help-string-test (via main-menu) (car baseball-ids) (tmp-pick "Houston" null))
+		     (label-test (via main-menu) (cadr hockey-ids) "Bruins")
+		     (label-test (via apple-menu) DELETE-APPLE (apple-pick null "Apple Deleter" "Delete Apple"))
+		     (help-string-test (via apple-menu) DELETE-APPLE (apple-pick null "DELETER"
+										 "Deletes the Apple menu"))
+		     (label-test (via apple-menu) COCONUT-ID (apple-pick null "Coconut!" "Coconut"))
+		     (help-string-test (via apple-menu) COCONUT-ID (apple-pick null "SUBMENU" "Submenu"))
+		     (label-test (via apple-menu) DELETE-COCONUT (apple-pick null "Coconut Deleter" "Delete Coconut")) ; submenu test
+		     (help-string-test (via apple-menu) DELETE-COCONUT (apple-pick null "CDELETER" null))
+		     (top-label-test 0 (if temp-labels? "Hi" "Tester"))
+		     (top-label-test 1 (if apple-installed? "Apple" null))
+		     (tell-ok))
+		   "Test Labels")
+      (make-object mred:button% lblp
+		   (lambda args
+		     (find-test main-menu (tmp-pick "Hi" "Tester")
+				ADD-APPLE (tmp-pick "Apple Adder" "Add Apple"))
+		     (find-test apple-menu "Apple" (apple-pick -1 DELETE-APPLE DELETE-APPLE)
+				(tmp-pick "Apple Deleter" "Delete Apple"))
+		     (find-test apple-menu "Apple" (apple-pick -1 COCONUT-ID COCONUT-ID)
+				(tmp-pick "Coconut!" "Coconut"))
+		     (find-test apple-menu "Apple" (apple-pick -1 DELETE-COCONUT DELETE-COCONUT)
+				(tmp-pick "Coconut Deleter" "Delete Coconut"))
+		     (tell-ok))
+		   "Find Labels")
+      (make-object mred:button% lblp
+		   (lambda args
+		     (set! temp-labels? (not temp-labels?))
+		     (let ([menu (via main-menu)])
+		       (send menu set-label ADD-APPLE (tmp-pick "Apple Adder" "Add Apple"))
+		       (send menu set-label (car baseball-ids) (tmp-pick "'Stros" "Astros"))
+		       (send apple-menu set-label DELETE-APPLE (tmp-pick "Apple Deleter" "Delete Apple"))
+		       (send apple-menu set-label COCONUT-ID (tmp-pick "Coconut!" "Coconut"))
+		       (send apple-menu set-label DELETE-COCONUT (tmp-pick "Coconut Deleter" "Delete Coconut"))
+		       (send menu set-help-string ADD-APPLE (tmp-pick "ADDER" "Adds the Apple menu"))
+		       (send menu set-help-string (car baseball-ids) (tmp-pick "Houston" null))
+		       (send apple-menu set-help-string DELETE-APPLE (tmp-pick "DELETER" "Deletes the Apple menu"))
+		       (send apple-menu set-help-string COCONUT-ID (tmp-pick "SUBMENU" "Submenu"))
+		       (send apple-menu set-help-string DELETE-COCONUT (tmp-pick "CDELETER" null))
+		       (send menu-bar set-label-top 0 (if temp-labels? "Hi" "Tester"))))
+		   "Toggle Labels")
+      (letrec ([by-bar (make-object mred:check-box% lblp
+				    (lambda args
+				      (set! use-menubar? (send by-bar get-value)))
+				    "Via Menubar")])
+	by-bar)
+
+      (make-test-button "Bad Item" badp apple-menu 777)
+      (make-test-button "Other Bad Item" badp apple-menu -1)
+      (make-object mred:button% badp
+		   (lambda args
+		     (label-test main-menu 777 null)
+		     (label-test main-menu -1 null)
+		     (help-string-test main-menu 777 null)
+		     (help-string-test main-menu -1 null)
+		     (top-label-test -1 null)
+		     (top-label-test 777 null)
+		     (find-test main-menu "No way" -1 "Not in the menus")
+		     (tell-ok))
+		   "Bad Item Labels")
+      (make-object mred:button% badp 
+		   (make-bad-test (ivar main-menu check))
+		   "Check Bad")
+      (make-object mred:button% badp 
+		   (make-bad-test (ivar main-menu enable))
+		   "Enable Bad")
+      (make-object mred:button% badp 
+		   (make-bad-test (lambda (a b) (send main-menu delete a)))
+		   "Delete Bad")
+
+      #f))))
+
+(define (menu-frame)
+  (define mf (make-object f% null "Menu Test"))
+  (set! prev-frame mf)
+  (send mf show #t)
+  mf)
+
+(define (check-callback-event orig got e types silent?)
+  (unless (eq? orig got)
+	  (error "object not the same"))
+  (unless (is-a? e wx:command-event%)
+	  (error "bad event object"))
+  (unless (eq? got (send e get-event-object))
+	  (error "event object mismatch"))
+  (let ([type (send e get-event-type)])
+    (unless (member type types)
+	    (error (format "bad event type: ~a" type))))
+  (unless silent?
+	  (printf "Callback Ok~n")))
+
+(define (button-frame)
+  (define f (make-object mred:frame% null "Button Test"))
+  (define p (make-object mred:vertical-panel% f))
+  (define old-list null)
+  (define commands (list wx:const-event-type-button-command))
+  (define sema (make-semaphore))
+  (define b (make-object mred:button% p
+			 (lambda (bx e)
+			   (semaphore-post sema)
+			   (set! old-list (cons e old-list))
+			   (check-callback-event b bx e commands #f))
+			 "Hit Me"))
+  (define c (make-object mred:button% p
+			 (lambda (c e)
+			   (for-each
+			    (lambda (e)
+			      (check-callback-event b b e commands #t))
+			    old-list)
+			   (printf "All Ok~n"))
+			 "Check"))
+  (define e (make-object mred:button% p
+			 (lambda (c e)
+			   (sleep 1)
+			   (wx:yield) ; try to catch a click, but not a callback
+			   (set! sema (make-semaphore))
+			   (send b enable #f)
+			   (thread (lambda () (wx:yield sema)))
+			   (when (semaphore-wait-multiple (list sema) 0.5)
+				 (printf "un-oh~n"))
+			   (send b enable #t)
+			   (semaphore-post sema))
+			 "Disable Test"))
+  (send f show #t))
+
+(define (checkbox-frame)
+  (define f (make-object mred:frame% null "Checkbox Test"))
+  (define p (make-object mred:vertical-panel% f))
+  (define old-list null)
+  (define commands (list wx:const-event-type-checkbox-command))
+  (define cb (make-object mred:check-box% p
+			  (lambda (cx e)
+			    (set! old-list (cons e old-list))
+			    (unless (eq? (send cb get-value)
+					 (send e checked?))
+				    (error "event checkstate mismatch"))
+			    (check-callback-event cb cx e commands #f))
+			  "On"))
+  (define t (make-object mred:button% p
+			 (lambda (t e)
+			   (let ([on? (send cb get-value)])
+			     (send cb set-value (not on?))))
+			 "Toggle"))
+  (define c (make-object mred:button% p
+			 (lambda (c e)
+			   (for-each
+			    (lambda (e)
+			      (check-callback-event cb cb e commands #t))
+			    old-list)
+			   (printf "All Ok~n"))
+			 "Check"))
+  (send f show #t))
+
+(define (choice-or-list-frame list? list-style empty?)
+  (define f (make-object mred:frame% null "Choice Test"))
+  (define p (make-object mred:vertical-panel% f))
+  (define-values (actual-content actual-user-data)
+    (if empty?
+	(values null null)
+	(values '("Alpha" "Beta" "Gamma")
+		(list null null null))))
+  (define commands 
+    (if list?
+	(list wx:const-event-type-listbox-command)
+	(list wx:const-event-type-choice-command)))
+  (define old-list null)
+  (define callback
+    (lambda (cx e)
+      (when (zero? (send c number))
+	    (error "Callback for empty choice/list"))
+      (set! old-list (cons (list e
+				 (send e get-command-int)
+				 (send e get-command-string))
+			   old-list))
+      (unless (= (send e get-command-int)
+		 (send c get-selection))
+	      (error "event selection value mismatch"))
+      (unless (string=? (send e get-command-string)
+			(send c get-string-selection)
+			(send c get-string (send c get-selection)))
+	      (error "selection string mistmatch"))
+      (check-callback-event c cx e commands #f)))
+  (define c (if list?
+		(make-object mred:list-box% p
+			 callback
+			 "Tester"
+			 list-style
+			 -1 -1 -1 -1
+			 actual-content)
+		(make-object mred:choice% p
+			     callback
+			     "Tester"
+			     -1 -1 -1 -1
+			     actual-content)))
+  (define counter 0)
+  (define append-with-user-data? #f)
+  (define ab (make-object mred:button% p
+			  (lambda (b e)
+			    (set! counter (add1 counter))
+			    (let ([naya (format "Extra ~a" counter)]
+				  [naya-data (box 0)])
+			      (set! actual-content (append actual-content (list naya)))
+			      (set! actual-user-data (append actual-user-data (list naya-data)))
+			      (if (and list? append-with-user-data?)
+				  (send c append naya naya-data)
+				  (begin
+				    (send c append naya)
+				    (when list?
+					  (send c set-client-data 
+						(sub1 (send c number))
+						naya-data))))
+			      (set! append-with-user-data?
+				    (not append-with-user-data?))))
+			  "Append"))
+  (define cdp (make-object mred:horizontal-panel% p))
+  (define rb (make-object mred:button% cdp
+			  (lambda (b e)
+			    (set! actual-content null)
+			    (set! actual-user-data null)
+			    (send c clear))
+			  "Clear"))
+  (define db (if list?
+		 (make-object mred:button% cdp
+			      (lambda (b e)
+				(let ([p (send c get-selection)])
+				  (when (<= 0 p (sub1 (length actual-content)))
+					(send c delete p)
+					(if (zero? p)
+					    (begin
+					      (set! actual-content (cdr actual-content))
+					      (set! actual-user-data (cdr actual-user-data)))
+					    (begin
+					      (set-cdr! (list-tail actual-content (sub1 p)) 
+							(list-tail actual-content (add1 p)))
+					      (set-cdr! (list-tail actual-user-data (sub1 p)) 
+							(list-tail actual-user-data (add1 p))))))))
+			      "Delete")
+		 null))
+  (define (make-selectors method numerical?)
+    (define p2 (make-object mred:horizontal-panel% p))
+    (when numerical?
+	  (make-object mred:button% p2
+		       (lambda (b e)
+			 (method -1))
+		       "Select Bad -1"))
+    (make-object mred:button% p2
+		 (lambda (b e)
+		   (method 0))
+		 "Select First")
+    (make-object mred:button% p2
+		 (lambda (b e)
+		   (method (floor (/ (send c number) 2))))
+		 "Select Middle")
+    (make-object mred:button% p2
+		 (lambda (b e)
+		   (method (sub1 (send c number))))
+		 "Select Last")
+    (make-object mred:button% p2
+		 (lambda (b e)
+		   (method (if numerical?
+			       (send c number)
+			       #f)))
+		 "Select Bad X")
+    #f)
+  (define dummy-1 (make-selectors (ivar c set-selection) #t))
+  (define dummy-2 (make-selectors (lambda (p) 
+				    (if p
+					(when (positive? (length actual-content))
+					      (send c set-string-selection 
+						    (list-ref actual-content p)))
+					(send c set-string-selection "nada")))
+				  #f))
+  (define tb (make-object mred:button% p
+			  (lambda (b e)
+			    (let ([c (send c number)])
+			      (unless (= c (length actual-content))
+				      (error "bad number response")))
+			    (let loop ([n 0][l actual-content][lud actual-user-data])
+			      (unless (null? l)
+				      (let ([s (car l)]
+					    [sud (car lud)]
+					    [sv (send c get-string n)]
+					    [sudv (if list?
+						      (send c get-client-data n)
+						      #f)])
+					(unless (string=? s sv)
+						(error "get-string mismatch"))
+					(unless (or (not list?) (eq? sud sudv))
+						(error "get-user-data mismatch"))
+					(unless (= n (send c find-string s))
+						(error "bad find-string result")))
+				      (loop (add1 n) (cdr l) (cdr lud))))
+			    (unless (and (null? (send c get-string -1))
+					 (null? (send c get-string (send c number))))
+				    (error "out-of-bounds did not return null"))
+			    (unless (= -1 (send c find-string "nada"))
+				    (error "bad find-string result for nada"))
+			    (for-each
+			     (lambda (eis)
+			       (let ([e (car eis)]
+				     [i (cadr eis)]
+				     [s (caddr eis)])
+				 (unless (= (send e get-command-int) i)
+					 (error "event selection value mismatch"))
+				 (unless (string=? (send e get-command-string) s)
+					 (error "selection string mistmatch"))
+				 (check-callback-event c c e commands #t)))
+			     old-list)
+			    (printf "content: ~s~n" actual-content))
+			  "Check"))
+  (send f show #t))
+
+(define (gauge-frame)
+  (define f (make-object mred:frame% null "Gauge Test"))
+  (define p (make-object mred:vertical-panel% f))
+  (define g (make-object mred:gauge% p "Tester" 10))
+  (define (move d name)
+    (make-object mred:button% p
+		 (lambda (c e)
+		   (send g set-value (+ d (send g get-value))))
+		 name))
+  (define (size d name)
+    (make-object mred:button% p
+		 (lambda (c e)
+		   (send g set-range (+ d (send g get-range))))
+		 name))
+  (move 1 "+")
+  (move -1 "-")
+  (size 1 "Bigger")
+  (size -1 "Smaller")
+  (send f show #t))
+
+(define (text-frame mred:text% style)
+  (define (handler get-this)
+    (lambda (c e)
+      (unless (eq? c (get-this))
+	      (printf "callback: bad item: ~a~n" c))
+      (unless (eq? c (send e get-event-object))
+	      (printf "callback: bad item in event: ~a~n" (send e get-event-object)))
+      (let ([t (send e get-event-type)])
+	(cond
+	 [(= t wx:const-event-type-text-command)
+	  (printf "Changed: ~a~n" (send e get-command-string))]
+	 [(= t wx:const-event-type-text-enter-command)
+	  (printf "Return: ~a~n" (send e get-command-string))]
+	 [(= t wx:const-event-type-set-focus)
+	  (printf "Focus in~n")]
+	 [(= t wx:const-event-type-kill-focus)
+	  (printf "Focus out~n")]))))
+
+  (define f (make-object mred:frame% null "Text Test"))
+  (define p (make-object (class-asi mred:vertical-panel%
+			    (public
+			     [on-default-action
+			      (lambda (v)
+				(printf "Panel default action~n"))]))
+			 f))
+  (define t1 (make-object mred:text% p (handler (lambda () t1)) null "This should just fit!"
+			  -1 -1 -1 -1 style))
+  (define t2 (make-object mred:text% p (handler (lambda () t2)) "Another" "This too!"
+			  -1 -1 -1 -1 style))
+  (define junk (send p set-label-position wx:const-vertical))
+  (define t3 (make-object mred:text% p (handler (lambda () t3)) "Catch Returns" "And, yes, this!"
+			  -1 -1 -1 -1 (+ style wx:const-process-enter)))
+  (send t1 stretchable-in-x #f)
+  (send t2 stretchable-in-x #f)
+  (send t3 stretchable-in-x #f)
+  (send f show #t))
+
+(define (canvas-frame flags)
+  (define f (make-object mred:frame% null "Canvas Test"))
+  (define p (make-object mred:vertical-panel% f))
+  (define c% (class mred:canvas% (name p)
+		    (inherit clear draw-text draw-line set-clipping-region
+			     get-scroll-pos get-scroll-range get-scroll-page
+			     get-client-size get-virtual-size)
+		    (public
+		     [on-paint
+		      (lambda ()
+			(let ([s (format "V: p: ~s r: ~s g: ~s H: ~s ~s ~s"
+					 (get-scroll-pos wx:const-vertical)
+					 (get-scroll-range wx:const-vertical)
+					 (get-scroll-page wx:const-vertical)
+					 (get-scroll-pos wx:const-horizontal)
+					 (get-scroll-range wx:const-horizontal)
+					 (get-scroll-page wx:const-horizontal))]
+			      [w (box 0)][w2 (box 0)]
+			      [h (box 0)][h2 (box 0)])
+			  (get-client-size w h)
+			  (get-virtual-size w2 h2)
+			  ; (set-clipping-region 0 0 (unbox w2) (unbox h2))
+			  (clear)
+			  (draw-text name 3 3)
+			  ; (draw-line 3 12 40 12)
+			  (draw-text s 3 15)
+			  (draw-text (format "client: ~s x ~s  virtual: ~s x ~s" 
+					     (unbox w) (unbox h)
+					     (unbox w2) (unbox h2))
+				     3 27)))]
+		     [on-scroll
+		      (lambda (e) (on-paint))])
+		    (sequence
+		      (super-init p -1 -1 -1 -1 flags))))
+  (define c1 (make-object c% "Unmanaged scroll" p))
+  (define c2 (make-object c% "Automanaged scroll" p))
+  (define (reset-scrolls)
+    (let* ([h? (send ck-h get-value)]
+	   [v? (send ck-v get-value)]
+	   [small? (send ck-s get-value)]
+	   [swap? (send ck-w get-value)])
+      (send c1 set-scrollbars (if h? 1 -1) (if v? 1 -1) 10 10 3 3 0 0 swap?)
+      (send c2 set-scrollbars (if h? 25 -1) (if v? 10 -1) (if small? 2 20) (if small? 2 20) 
+	    3 3 0 0 (not swap?))))
+  (define p2 (make-object mred:horizontal-panel% p))
+  (define jumk (send p2 stretchable-in-y #f))
+  (define ck-v (make-object mred:check-box% p2 (lambda (b e) (reset-scrolls)) "Vertical Scroll"))
+  (define ck-h (make-object mred:check-box% p2 (lambda (b e) (reset-scrolls)) "Horizontal Scroll"))
+  (define ck-s (make-object mred:check-box% p2 (lambda (b e) (reset-scrolls)) "Small"))
+  (define ck-w (make-object mred:check-box% p2 (lambda (b e) (reset-scrolls)) "Swap"))
+  (send f show #t))
+
+;----------------------------------------------------------------------
+
+(define selector (make-object mred:frame% null "Test Selector"))
+(define ap (make-object mred:vertical-panel% selector))
+
+; Test timers while we're at it:
+(let ([clockp (make-object mred:horizontal-panel% ap)]
+      [selector selector])
+  (make-object mred:vertical-panel% clockp) ; filler
+  (let ([time (make-object mred:message% clockp "XX:XX:XX")])
+    (make-object
+     (class wx:timer% ()
+	    (inherit start)
+	    (public
+	     [notify
+	      (lambda ()
+		(let* ([now (seconds->date (current-seconds))]
+		       [pad (lambda (pc d)
+			      (let ([s (number->string d)])
+				(if (= 1 (string-length s))
+				    (string-append pc s)
+				    s)))]
+		       [s (format "~a:~a:~a"
+				  (pad " " (let ([h (modulo (date-hour now) 12)])
+					     (if (zero? h)
+						 12
+						 h)))
+				  (pad "0" (date-minute now))
+				  (pad "0" (date-second now)))])
+		  (send time set-label s)
+		  (when (send selector is-shown?)
+			(start 1000 #t))))])
+	    (sequence
+	      (super-init)
+	      (start 1000 #t))))))
+
+(define bp (make-object mred:vertical-panel% ap -1 -1 -1 -1 wx:const-border))
+(define bp1 (make-object mred:horizontal-panel% bp))
+(define bp2 (make-object mred:horizontal-panel% bp))
+(define mp (make-object mred:vertical-panel% ap -1 -1 -1 -1 wx:const-border))
+(define mp1 (make-object mred:horizontal-panel% mp))
+(define mp2 (make-object mred:horizontal-panel% mp))
+
+(send bp1 set-label-position wx:const-vertical)
+(send mp1 set-label-position wx:const-vertical)
+
+(make-object mred:button% ap (lambda (b e) (menu-frame)) "Make Menus Frame")
+(make-object mred:button% ap (lambda (b e) (button-frame)) "Make Button Frame")
+(make-object mred:button% ap (lambda (b e) (checkbox-frame)) "Make Checkbox Frame")
+(define cp (make-object mred:horizontal-panel% ap))
+(send cp stretchable-in-x #f)
+(make-object mred:button% cp (lambda (b e) (choice-or-list-frame #f 0 #f)) "Make Choice Frame")
+(make-object mred:button% cp (lambda (b e) (choice-or-list-frame #f 0 #t)) "Make Empty Choice Frame")
+(define lp (make-object mred:horizontal-panel% ap))
+(send lp stretchable-in-x #f)
+(make-object mred:button% lp (lambda (b e) (choice-or-list-frame #t wx:const-single #f)) "Make List Frame")
+(make-object mred:button% lp (lambda (b e) (choice-or-list-frame #t wx:const-single #t)) "Make Empty List Frame")
+(make-object mred:button% lp (lambda (b e) (choice-or-list-frame #t wx:const-multiple #f)) "Make Multilist Frame")
+(make-object mred:button% ap (lambda (b e) (gauge-frame)) "Make Gauge Frame")
+(define tp (make-object mred:horizontal-panel% ap))
+(send tp stretchable-in-x #f)
+(make-object mred:button% tp (lambda (b e) (text-frame mred:text% 0)) "Make Text Frame")
+(make-object mred:button% tp (lambda (b e) (text-frame mred:media-text% 0)) "Make Media Text Frame")
+(make-object mred:button% tp (lambda (b e) (text-frame mred:multi-text% 0)) "Make Multitext Frame")
+(make-object mred:button% tp (lambda (b e) (text-frame mred:media-multi-text% 0)) "Make Media Multitext Frame")
+(define tp2 (make-object mred:horizontal-panel% ap))
+(send tp2 stretchable-in-x #f)
+(make-object mred:button% tp2 (lambda (b e) (text-frame mred:multi-text% wx:const-hscroll)) "Make Multitext Frame/HScroll")
+(make-object mred:button% tp2 (lambda (b e) (text-frame mred:media-multi-text% wx:const-hscroll)) "Make Media Multitext Frame/HScroll")
+
+(define cnp (make-object mred:horizontal-panel% ap))
+(send cnp stretchable-in-x #f)
+(let ([mkf (lambda (flags name)
+	     (make-object mred:button% cnp 
+			  (lambda (b e) (canvas-frame flags))
+			  (format "Make ~aCanvas Frame" name)))])
+  (mkf (+ wx:const-hscroll wx:const-vscroll) "HV")
+  (mkf wx:const-hscroll "H")
+  (mkf wx:const-vscroll "V")
+  (mkf 0 ""))
+
+(define (choose-next radios)
+  (let loop ([l radios])
+    (let* ([c (car l)]
+	   [rest (cdr l)]
+	   [n (send c number)]
+	   [v (send c get-selection)])
+      (if (< v (sub1 n))
+	  (send c set-selection (add1 v))
+	  (if (null? rest)
+	      (map (lambda (c) (send c set-selection 0)) radios)
+	      (begin
+		(send c set-selection 0)
+		(loop rest)))))))
+
+(define make-next-button
+  (lambda (p l)
+    (make-object mred:button% p
+		 (lambda (b e) (choose-next l))
+		 "Next Configuration")))
+
+(define make-selector-and-runner
+  (lambda (p1 p2 radios? size maker)
+    (define radio-h-radio
+      (if radios?
+	  (make-object mred:radio-box% p1 void "Radio Box Orientation"
+		       -1 -1 -1 -1
+		       '("Vertical" "Horizontal"))
+	  #f))
+    (define label-h-radio
+      (make-object mred:radio-box% p1 void "Label Orientation"
+		   -1 -1 -1 -1
+		   '("Vertical" "Horizontal")))
+    (define label-null-radio
+      (make-object mred:radio-box% p1 void "Optional Labels"
+		   -1 -1 -1 -1
+		   '("Use Label" "No Label")))
+    (define stretchy-radio
+      (make-object mred:radio-box% p1 void "Stretchiness"
+		   -1 -1 -1 -1
+		   '("Normal" "All Stretchy")))
+    (define font-radio
+      (make-object mred:radio-box% p1 void "Font"
+		   -1 -1 -1 -1
+		   '("Normal" "Big")))
+    (define next-button
+      (let ([basic-set (list label-h-radio label-null-radio stretchy-radio font-radio)])
+	(make-next-button p2 
+			  (if radios?
+			      (cons radio-h-radio basic-set)
+			      basic-set))))
+    (define go-button
+      (make-object mred:button% p2
+		   (lambda (b e)
+		     (maker
+		      (if radios?
+			  (positive? (send radio-h-radio get-selection))
+			  #f)
+		      (positive? (send label-h-radio get-selection))
+		      (positive? (send label-null-radio get-selection))
+		      (positive? (send stretchy-radio get-selection))
+		      (positive? (send font-radio get-selection))))
+		   (format "Make ~a Frame" size)))
+    #t))
+
+(make-selector-and-runner bp1 bp2 #t "Big" big-frame)
+(make-selector-and-runner mp1 mp2 #f "Medium" med-frame)
+
+(send selector show #t)
+
+; (define e (make-object wx:key-event% wx:const-event-type-char))
+; (send e set-key-code 65)
+; (send e set-shift-down #t)
diff --git a/collects/tests/mred/mem.ss b/collects/tests/mred/mem.ss
new file mode 100644
index 0000000..7ebc1a1
--- /dev/null
+++ b/collects/tests/mred/mem.ss
@@ -0,0 +1,241 @@
+
+(define source-dir (current-load-relative-directory))
+
+(define num-times 12)
+(define num-threads 1)
+
+(define dump-stats? #t)
+
+(define edit? #t)
+(define insert? #t)
+(define load-file? #f) ; adds a lot of messy objects
+
+(define menus? #t)
+(define atomic? #t)
+(define offscreen? #t)
+(define frame? #t)
+
+(define subwindows? #t)
+
+(define allocated '())
+(define (remember tag v)
+  (set! allocated
+	(cons (cons tag (make-weak-box v))
+	      allocated))
+  v)
+
+(define frame%
+  ; Leave this as the (obsolete) make-class form for macro testing
+  (make-class mred:editor-frame%
+	      (rename [super-show show])
+	      (public
+	       [prim-show (lambda (arg) (super-show arg))]
+	       [show
+		(lambda (x) (void))])))
+
+(when subwindows?
+      (define sub-collect-frame
+	(make-object wx:frame% null "sub-collect" -1 -1 200 200))
+      (define sub-collect-panel
+	(make-object wx:panel% sub-collect-frame 0 0 100 100)))
+
+(send sub-collect-frame show #t)
+
+(define (maker id n)
+  (sleep)
+  (collect-garbage)
+  (collect-garbage)
+  (printf "Thread: ~s Cycle: ~s~n" id n)
+  (dump-object-stats)
+  (if (and dump-stats? (= id 1))
+      (dump-memory-stats))
+  (unless (zero? n)
+    (let ([tag (cons id n)])
+      (let* ([f (if edit? (remember tag (make-object frame%)))]
+	     [c (make-custodian)]
+	     [es (parameterize ([current-custodian c])
+			       (wx:make-eventspace))])
+
+	(parameterize ([wx:current-eventspace es])
+		      (send (remember 
+			     tag
+			     (make-object
+			      (class-asi wx:timer%
+					 (public
+					  [notify void]))))
+			    start 100))
+
+	(when edit?
+	    (remember tag (send f get-edit)))
+
+	(when (and edit? (zero? (modulo n 2)))
+	    (send f prim-show #t)
+		(sleep 0.5))
+
+	(if frame?
+	    (let* ([f (make-object wx:frame% '() "Tester" -1 -1 200 200)]
+		   [p (remember tag (make-object wx:panel% f))])
+	      (remember tag (make-object wx:canvas% f))
+	      (if (zero? (modulo n 3))
+		  (send f show #t))
+	      (remember tag (make-object wx:button% p (lambda args #t) "one"))
+	      (let ([class wx:check-box%])
+		(let loop ([m 10])
+		  (unless (zero? m)
+			  (remember (cons tag m)
+				    (make-object class p (lambda args #t) "another"))
+			  (loop (sub1 m)))))
+	      (send p new-line)
+	      (remember tag (make-object wx:check-box% p (lambda args #t) "check"))
+	      (remember tag (make-object wx:choice% p (lambda args #t) "choice"))
+	      (remember tag (make-object wx:list-box% p (lambda args #t) "list"
+					 wx:const-single -1 -1 -1 -1
+					 '("apple" "banana" "coconut")))
+	      (remember tag (make-object wx:button% p (lambda args #t) "two"))
+	      (send f show #f)))
+
+	(if subwindows?
+	    (let ([p (make-object wx:panel% sub-collect-frame 100 100 50 50)]
+		  [cv (make-object wx:canvas% sub-collect-frame 150 150 50 50)]
+		  [add-objects
+		   (lambda (p tag hide?)
+		     (let ([b (make-object wx:button% p (lambda args #t) "one" 0 0)]
+			   [c (make-object wx:check-box% p (lambda args #t) "check" 0 0)]
+			   [co (make-object wx:choice% p (lambda args #t) "choice" 0 0)]
+			   [cv (make-object wx:canvas% p 0 0 50 50)]
+			   [lb (make-object wx:list-box% p (lambda args #t) "list"
+					    wx:const-single 0 0 -1 -1
+					    '("apple" "banana" "coconut"))])
+		       (when hide?
+			     (send b show #f)
+			     (send c show #f)
+			     (send cv show #f)
+			     (send co show #f)
+			     (send lb show #f))
+		       (remember tag b)
+		       (remember tag c)
+		       (remember tag cv)
+		       (remember tag co)
+		       (remember tag lb)))])
+	      (add-objects sub-collect-panel (cons 'sc1 tag) #t)
+	      (add-objects p (cons 'sc2 tag) #f)
+	      (remember (cons 'sc0 tag) p)
+	      (remember (cons 'sc0 tag) cv)
+	      (send p show #f)
+	      (send cv show #f)))
+	      
+
+	(if (and edit? insert?)
+	    (let ([e (send f get-edit)])
+	      (when load-file?
+		    (send e load-file (build-path source-dir "mem.ss")))
+	      (let loop ([i 20])
+		(send e insert (number->string i))
+		(unless (zero? i)
+			(loop (sub1 i))))
+	      (let ([s (make-object wx:media-snip%)])
+		(send (send s get-this-media) insert "Hello!")
+		(send e insert s))
+	      (send e insert #\newline)
+	      (send e insert "done")
+	      (send e set-modified #f)))
+	
+	(when menus?
+	      (remember tag (make-object wx:menu-bar%))
+	      (remember tag (make-object wx:menu%))
+	      (let ([mb (remember tag (make-object wx:menu-bar%))]
+		    [m (remember tag (make-object wx:menu%))])
+		(send m append 5 "Hi" (remember tag (make-object wx:menu%)))
+		(send mb append m "x"))
+	      
+	      (if edit?
+		  (let ([m (remember tag (make-object mred:menu%))]
+			[m2 (remember tag (make-object mred:menu%))]
+			[mb (send f get-menu-bar)])
+		    (send m append 4 "ok")
+		    (send m2 append 4 "hao")
+		    (send m append 5 "Hi" (remember tag (make-object mred:menu%)))
+		    (send mb append m "Extra")
+		    (send mb append m2 "Other")
+		    (send m delete 5)
+		    (send mb delete m))))
+
+	(when atomic?
+	      (let loop ([m 8])
+		(unless (zero? m)
+			(remember (cons tag m) (make-object wx:point% n m))
+			(remember (cons tag m) (make-object wx:int-point% n m))
+			(remember (cons tag m) (make-object wx:brush%))
+			(remember (cons tag m) (make-object wx:pen%))
+			(loop (sub1 m)))))
+	
+	(when offscreen?
+	      (let ([m (remember tag (make-object wx:memory-dc%))]
+		    [b (remember (cons tag 'u) (make-object wx:bitmap% 100 100))]
+		    [b2 (remember (cons tag 'x) (make-object wx:bitmap% 100 100))])
+		(send m select-object b)))
+	
+	
+	(when edit?
+	      (let ([name (wx:get-temp-file-name "hi")])
+		(send (send f get-edit) save-file name)
+		(send f on-close) 
+		(send f prim-show #f)
+		(delete-file name)))
+
+	(custodian-shutdown-all c)
+
+	(collect-garbage)
+
+	(maker id (sub1 n))))))
+    
+(define (still)
+  (map (lambda (x)
+	 (let ([v (weak-box-value (cdr x))])
+	   (if v
+	       (printf "~s ~s~n" (send v get-class-name) (car x)))))
+       allocated)
+  (void))
+
+(define (xthread f)
+  (f))
+
+(define (stw t n)
+  (thread-weight t (floor (/ (thread-weight t) n))))
+
+(define (do-test)
+  (let ([sema (make-semaphore)])
+  	 (let loop ([n num-threads])
+	   (unless (zero? n)
+		 (thread (lambda () 
+			   (stw (current-thread) n)
+			   (dynamic-wind
+			    void
+			    (lambda () (maker n num-times))
+			    (lambda () (semaphore-post sema)))))
+		 (loop (sub1 n))))
+	(let loop ([n num-threads])
+	  (unless (zero? n)
+	    (wx:yield sema)
+		(loop (sub1 n)))))
+  
+  (collect-garbage)
+  (collect-garbage)
+  (let loop ([n 100]) 
+    (if (zero? n) 0 (sub1 (loop (sub1 n)))))
+  (collect-garbage)
+  (collect-garbage)
+  (still)
+  (when subwindows?
+	(set! sub-collect-frame #f)
+	(set! sub-collect-panel #f))
+  (when dump-stats?
+	(dump-memory-stats)
+	(still)))
+
+(define mred:startup
+  (let ([old-mred:startup mred:startup])
+    (lambda args
+      (send mred:the-frame-group set-empty-callback (lambda () #t))
+      (do-test)
+      (apply old-mred:startup args))))
diff --git a/collects/tests/mred/nruter.xbm b/collects/tests/mred/nruter.xbm
new file mode 100644
index 0000000..9e74923
--- /dev/null
+++ b/collects/tests/mred/nruter.xbm
@@ -0,0 +1,4 @@
+#define nruter_width 6
+#define nruter_height 9
+static char nruter_bits[] = {
+ 0x1e,0x1f,0x03,0x03,0x27,0x3e,0x3c,0x3c,0x3e};
diff --git a/collects/tests/mred/random.ss b/collects/tests/mred/random.ss
new file mode 100644
index 0000000..080d613
--- /dev/null
+++ b/collects/tests/mred/random.ss
@@ -0,0 +1,604 @@
+
+(define example-list%
+  (class '() (parents [filter (lambda (x) (not (void? x)))])
+      (public
+       [items '()]
+       [num-items 0]
+       
+       [parents-count 
+	(if parents
+	    (map (lambda (parent)
+		   (ivar parent count))
+		 parents)
+	    '())]
+       [parents-choose
+	(if parents
+	    (map (lambda (parent)
+		   (ivar parent choose-example))
+		 parents)
+	    '())]
+       [choose-parent-example
+	(lambda (which)
+	  (let loop ([pos which][counts parents-count][chooses parents-choose])
+	    (if (null? counts)
+		(void)
+		(let ([c ((car counts))])
+		  (if (< pos c)
+		      ((car chooses) pos)
+		      (loop (- pos c) (cdr counts) (cdr chooses)))))))]
+
+       [count 
+	(lambda () (+ num-items (apply + (map (lambda (x) (x)) parents-count))))]
+       [set-filter
+	(lambda (f)
+	  (set! filter f))]
+       [add
+	(lambda (x)
+	  (when (filter x)
+		(set! num-items (add1 num-items))
+		(set! items (cons x items))))]
+       [all-examples
+	(lambda ()
+	  (apply append items (map (lambda (p) (send p all-examples)) parents)))]
+       [choose-example
+	(opt-lambda ([which #f])
+	  (let ([n (if which 
+		       which
+		       (let ([c (count)])
+			 (if (zero? c)
+			     0
+			     (random c))))])
+	    (if (< n num-items)
+		(list-ref items n)
+		(choose-parent-example (- n num-items)))))])))
+
+(define boxed-example-list%
+  (class () (null-ok? parent)
+    (public
+     [all-examples
+      (lambda ()
+	(let ([l (map box (send parent all-examples))])
+	  (if null-ok?
+	      (cons '() l)
+	      l)))]
+     [choose-example
+      (opt-lambda ([which #f])
+	(if (and null-ok? (zero? (random 2)))
+	    '()
+	    (let ([ex (send parent choose-example)])
+	      (if (void? ex)
+		  (void)
+		  (box ex)))))])))
+
+(define array-example-list%
+  (class () (parent)
+    (public
+     [all-examples
+      (lambda ()
+	(let ([v1 (cons (send parent choose-example) '())]
+	      [v2 (cons (send parent choose-example) '())])
+	  (set-cdr! v1 v1) ; cycle
+	  (set-cdr! v2 (send parent choose-example)) ; improper
+	  (list v1 v2 (send parent all-examples))))]
+     [choose-example
+      (opt-lambda ([which #f])
+	(let ([ex (send parent choose-example)])
+	  (if (void? ex)
+	      (void)
+	      (if (zero? (random 10))
+		  ; occasionally pick a mean one
+		  (let ([v (cons ex '())])
+		    (if (zero? (random 2))
+			(set-cdr! v v) ; cycle
+			(set-cdr! v (send parent choose-example))) ; improper
+		    v)
+		  (let loop ([count (random 10)])
+		    (cond
+		     [(zero? count) '()]
+		     [(= count 1) (list ex)]
+		     [else
+		      (cons (send parent choose-example) (loop (sub1 count)))]))))))])))
+
+(define-macro define-main 
+  (lambda list
+    (let loop ([l list][rest '()])
+      (if (null? l)
+	  (cons 'begin rest)
+	  (loop (cdr l)
+		(let* ([first (car l)]
+		       [name (if (symbol? first)
+				 first
+				 (car first))]
+		       [strname (symbol->string name)]
+		       [bases (if (symbol? first)
+				  ()
+				  (cdr first))]
+		       [el-name (lambda (s)
+				  (if s
+				      (string->symbol
+				       (string-append
+					(symbol->string s)
+					"-example-list"))
+				      #f))])
+		  (cons
+		   `(define ,(el-name name)
+		      (make-object example-list% (list ,@(map el-name bases))
+				   (lambda (v) (if (null? v)
+						   (error ,name "got null")))))
+		   (if (char=? #\! (string-ref strname (sub1 (string-length strname))))
+		       (let* ([base (substring strname 0 (sub1 (string-length strname)))]
+			      [caret (string->symbol (string-append base "^"))]
+			      [percent (string->symbol (string-append base "%"))])
+			 (list*
+			  `(define ,(el-name caret)
+			     (make-object example-list% (list ,(el-name name))))
+			  `(define ,(el-name percent)
+			     (make-object example-list% (list ,(el-name name))))
+			  `(send ,(el-name caret) add '())
+			  rest))
+		       rest))))))))
+
+(define-main
+  void
+  char
+  ubyte
+  int
+  string
+  bool
+  float
+
+  pathname
+
+  void*
+  istream%
+  ostream%
+
+  wxFunction
+  wxKeyErrorFunction
+  wxKeyFunction
+  wxMouseFunction
+  wxBreakSequenceFunction
+  wxGrabMouseFunction
+  wxGrabKeyFunction
+  wxClickbackFunc
+  wxWordbreakFunc
+
+  (wxObject! wxWindow! wxItem! wxColour! wxList!)
+
+  wxPoint!
+  wxIntPoint!
+
+  wxButton!
+  wxColour!
+  wxFont!
+  wxBrush!
+  wxPen!
+
+  wxFontList!
+  wxPenList!
+  wxBrushList!
+  wxColourDatabase!
+  wxFontNameDirectory!
+
+  wxColourMap!
+  wxCursor!
+  wxIcon!
+  wxBitmap!
+
+  (wxEvent! wxCommandEvent! wxMouseEvent! wxKeyEvent!)
+  wxCommandEvent!
+  wxMouseEvent!
+  wxKeyEvent!
+
+  (wxDC! wxCanvasDC! wxPanelDC! wxMemoryDC! wxPostScriptDC!)
+  wxCanvasDC!
+  wxPanelDC!
+  wxMemoryDC!
+  wxPostScriptDC!
+
+  basePrinterDC!
+  baseMetaFileDC!
+  
+  baseMetaFile!
+
+  (wxWindow! wxFrame! wxCanvas! wxItem!)
+
+  wxFrame!
+  wxTextWindow!
+  (wxCanvas! wxPanel! wxMediaCanvas!)
+  (wxPanel! wxDialogBox!)
+  wxDialogBox!
+  wxMediaCanvas!
+
+  (wxItem! wxButton! wxCheckBox! wxChoice!
+	   wxListBox! wxSlider! wxsGauge! wxText! wxMultiText! 
+	   wxRadioBox! wxMessage! wxGroupBox!)
+  wxButton!
+  wxCheckBox!
+  wxChoice!
+  wxListBox!
+  wxSlider!
+  wxsGauge!
+  wxText!
+  wxMultiText!
+  wxMessage!
+  wxRadioBox!
+  wxGroupBox!
+
+  wxMenu!
+  wxMenuBar!
+
+  wxNode!
+  wxList!
+
+  wxHashTable!
+  wxPathList!
+  wxStringList!
+
+  wxConnection!
+  (wxIPCObject! wxClient! wxServer!)
+  wxClient!
+  wxServer!
+
+  wxTimer!
+  wxTypeTree!
+
+  wxToolBarTool!
+  wxToolBar!
+
+  wxLayoutConstraints!
+
+  wxAddColour!
+  wxMultColour!
+  wxStyleDelta!
+  wxStyle!
+  wxStyleList!
+
+  (wxMediaAdmin! wxCanvasMediaAdmin! wxMediaSnipMediaAdmin!)
+  wxCanvasMediaAdmin!
+  wxMediaSnipMediaAdmin!
+  wxSnipAdmin!
+  
+  (wxMediaBuffer! wxMediaEdit! wxMediaPasteboard!)
+  wxMediaEdit!
+  wxMediaPasteboard!
+
+  (wxSnip! wxTextSnip! wxImageSnip! wxMediaSnip!)
+  (wxTextSnip! wxTabSnip!)
+  wxTabSnip!
+  wxImageSnip!
+  wxMediaSnip!
+
+  wxSnipClass!
+  wxSnipClassList!
+
+  wxBufferData!
+  wxBufferDataClass!
+  wxBufferDataClassList!
+
+  wxKeymap!
+  wxMediaWordbreakMap!
+
+  (wxMediaStreamInBase! wxMediaStreamInStringBase!)
+  (wxMediaStreamOutBase! wxMediaStreamOutStringBase!)
+
+  wxMediaStreamInStringBase!
+  wxMediaStreamOutStringBase!
+
+  wxMediaStreamIn!
+  wxMediaStreamOut!
+  
+  wxClipboard!
+  wxClipboardClient!
+
+  Scheme_Object*)
+
+(send wxBitmap!-example-list set-filter (lambda (bm) (send bm ok?)))
+
+(define-macro define-boxed 
+  (lambda list
+    (let ([make
+	   (lambda (s tag)
+	     (string->symbol
+	      (string-append
+	       (symbol->string s)
+	       tag
+	       "-example-list")))])
+      (let loop ([l list][rest '()])
+	(if (null? l)
+	    (cons 'begin rest)
+	    (loop (cdr l)
+		  (cons `(define ,(make (car l) "*")
+			   (make-object boxed-example-list% #f ,(make (car l) "")))
+			(cons `(define ,(make (car l) "?")
+				 (make-object boxed-example-list% #t ,(make (car l) "")))
+			      rest))))))))
+
+(define-macro define-array 
+  (lambda list
+    (let ([make
+	   (lambda (s tag)
+	     (string->symbol
+	      (string-append
+	       (symbol->string s)
+	       tag
+	       "-example-list")))])
+      (let loop ([l list][rest '()])
+	(if (null? l)
+	    (cons 'begin rest)
+	    (loop (cdr l)
+		  (cons `(define ,(make (car l) "ARRAY")
+			   (make-object array-example-list% ,(make (car l) "")))
+			rest)))))))
+
+(define nstring-example-list (make-object example-list% (list string-example-list)))
+(send nstring-example-list add '())
+
+(define long-example-list int-example-list)
+(define Long-example-list int-example-list)
+(define short-example-list int-example-list)
+(define Bool-example-list int-example-list)
+(define _KEY_TYPE-example-list int-example-list)
+(define uchar-example-list char-example-list)
+(define double-example-list float-example-list)
+(define Double-example-list double-example-list)
+(define cstring-example-list string-example-list)
+(define ustring-example-list string-example-list)
+(define custring-example-list string-example-list)
+(define ncstring-example-list nstring-example-list)
+(define ncustring-example-list nstring-example-list)
+
+(define voidARRAY-example-list (make-object example-list% null))
+(define CAPOFunc-example-list (make-object example-list% null))
+
+(define false-example-list (make-object example-list% '()))
+(send false-example-list add #f)
+
+(define-boxed
+  int
+  string
+  bool
+  ubyte
+  float
+  Double
+  Long
+  long
+  short
+  wxSnip!)
+
+(define Double+-example-list Double*-example-list)
+(define long+-example-list long*-example-list)
+(define Long+-example-list Long*-example-list)
+
+(define wxBitmap*-example-list wxBitmap!-example-list)
+(define wxMenu*-example-list wxMenu!-example-list)
+
+(define-array
+  char
+  string
+  int
+  long
+  float
+  wxBitmap*
+  wxMenu*)
+
+(define int**-example-list 
+  (make-object array-example-list% int*-example-list))
+
+(send* bool-example-list
+       (add #t)
+       (add #f))
+
+(send* int-example-list
+       (add 0) (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0) (add 0)
+       (add -1)
+       (add -2)
+       (add -3)
+       (add -1000)
+       (add 1)
+       (add 2)
+       (add 3)
+       (add 4)
+       (add 5)
+       (add 6)
+       (add 7)
+       (add 8)
+       (add 9)
+       (add 10)
+       (add 16)
+       (add 32)
+       (add 64)
+       (add 128)
+       (add 256)
+       (add 255)
+       (add 1023)
+       (add 1000)
+       (add 5.0))
+
+(send* ubyte-example-list
+       (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0)
+       (add 0) (add 0) (add 0)
+       (add 1)
+       (add 2)
+       (add 3)
+       (add 4)
+       (add 5)
+       (add 6)
+       (add 7)
+       (add 8)
+       (add 9)
+       (add 10)
+       (add 16)
+       (add 32)
+       (add 64)
+       (add 128)
+       (add 255)
+       (add 5))
+
+(send* char-example-list
+       (add #\nul)
+       (add #\a)
+       (add #\1)
+       (add #\newline)
+       (add #\tab)
+       (add #\z)
+       (add #\C))
+
+(send* float-example-list
+       (add 0.)
+       (add 0.)
+       (add 0.)
+       (add -1.)
+       (add -2.)
+       (add -3.)
+       (add -1000.)
+       (add 1.)
+       (add 2.)
+       (add 3.)
+       (add 1000.)
+       (add 5))
+
+(send* string-example-list
+       (add "")
+       (add "hello")
+       (add "system/mred.xbm")
+       (add "system/mred.bmp")
+       (add "mred.gif")
+       (add "goodbye adious see you later zai jian seeya bye-bye"))
+
+(send pathname-example-list add "/tmp/x")
+(define npathname-example-list (make-object example-list% (list string-example-list)))
+(send npathname-example-list add '())
+
+(send wxFunction-example-list add void)
+(send wxKeyErrorFunction-example-list add void)
+(send wxKeyFunction-example-list add void)
+(send wxMouseFunction-example-list add void)
+(send wxClickbackFunc-example-list add void)
+(send wxWordbreakFunc-example-list add void)
+
+(define classinfo (make-hash-table))
+
+(load-relative "tests.ss")
+
+(define (get-args l)
+  (let/ec bad
+	  (let loop ([l l])
+	    (if (null? l)
+		'()
+		(let* ([source (car l)]
+		       [value (send source choose-example #f)])
+		  (if (void? value)
+		      (bad #f)
+		      (cons value (loop (cdr l)))))))))
+
+(define (get-all-args l)
+  (let loop ([l l])
+    (if (null? l)
+	'()
+	(let* ([source (car l)]
+	       [values (send source all-examples)]
+	       [rest (loop (cdr l))])
+	  (if (null? (cdr l))
+	      (list values)
+	      (apply append
+		     (map (lambda (other)
+			    (map (lambda (v) (cons v other)) values))
+			  rest)))))))
+
+(define thread-output-port 
+  (let ([p mred:original-output-port])
+    (lambda ()
+      p)))
+  
+
+(define (apply-args v dest name k)
+  (if v
+      (begin
+	(fprintf (thread-output-port) "~a: ~a" name v)
+	(flush-output (thread-output-port))
+	(with-handlers ((void (lambda (x)
+				(fprintf (thread-output-port)
+					 ": error: ~a~n"
+					 (exn-message x)))))
+		       (send dest add (k v))
+		       (wx:flush-display)
+		       (fprintf (thread-output-port) ": success~n")))
+      (fprintf (thread-output-port) "~a: failure~n" name)))
+
+(define (try-args arg-types dest name k)
+  (apply-args (get-args arg-types) dest name k))
+
+(define (try-all-args arg-types dest name k)
+  (let ([vs (get-all-args arg-types)])
+    (map (lambda (v)
+	   (apply-args v dest name k))
+	 vs)))
+
+(define (create-some cls try)
+  (when (class? cls)
+	(let* ([v (hash-table-get classinfo cls)]
+	       [dest (car v)]
+	       [name (cadr v)]
+	       [creators (caddr v)])
+	  (let loop ([l creators])
+	    (unless (null? l)
+		    (try (car l) dest name
+			 (lambda (v)
+			   (apply make-object cls v)))
+		    (loop (cdr l)))))))
+
+(define (create-all-random)
+  (fprintf (thread-output-port) "creating all randomly...~n")
+  (hash-table-for-each classinfo (lambda (k v)
+				   (create-some k try-args))))
+(define (create-all-exhaust)
+  (fprintf (thread-output-port) "creating all exhaustively...~n")
+  (hash-table-for-each classinfo (lambda (k v)
+				   (create-some k try-all-args))))
+
+(define (try-methods cls try)
+  (let* ([v (hash-table-get classinfo cls)]
+	 [source (car v)]
+	 [use (if source (send source choose-example) #f)]
+	 [name (cadr v)]
+	 [methods (cdddr v)])
+    (if (void? use)
+	(fprintf (thread-output-port) "~s: no examples~n" name)
+	(let loop ([l methods])
+	  (unless (null? l)
+		  (let* ([method (car l)]
+			 [iv (car method)]
+			 [resulttype (cadr method)]
+			 [argtypes (cddr method)])
+		    (try argtypes resulttype (list name iv use)
+			 (lambda (args)
+			   (if use
+			       (apply (uq-ivar use iv) args)
+			       (apply (global-defined-value iv) args)))))
+		  (loop (cdr l)))))))
+
+(define (call-random except)
+  (fprintf (thread-output-port) "calling all except ~a randomly...~n" except)
+  (hash-table-for-each classinfo (lambda (k v)
+				   (unless (member k except)
+					   (try-methods k try-args)))))
+
+(define (call-all-random)
+  (call-random null))
+
+(define (call-all-non-media)
+  (call-random (list wx:media-buffer% wx:media-edit% wx:media-snip% wx:media-pasteboard% 'wxMediaGlobal)))
+
+(define (init)
+  (create-all-random)
+  (create-all-random)
+  (create-all-random)
+  (create-all-random))
+
diff --git a/collects/tests/mred/showkey.ss b/collects/tests/mred/showkey.ss
new file mode 100644
index 0000000..7e76a19
--- /dev/null
+++ b/collects/tests/mred/showkey.ss
@@ -0,0 +1,15 @@
+(let ([c%
+       (class-asi mred:canvas%
+	 (public
+	   [on-char
+	    (lambda (ev)
+	      (printf "code: ~a  meta: ~a alt: ~a  shift: ~a~n" 
+		      (send ev get-key-code)
+		      (send ev get-control-down)
+		      (send ev get-alt-down)
+		      (send ev get-shift-down)))]))])
+  (define f (make-object mred:frame% null "tests" 0 0 100 100))
+  (define p (make-object mred:vertical-panel% f))
+  (define c (make-object c% p))
+  (send f show #t))
+
diff --git a/collects/tests/mred/startup/app-A/info.ss b/collects/tests/mred/startup/app-A/info.ss
new file mode 100644
index 0000000..c4cd810
--- /dev/null
+++ b/collects/tests/mred/startup/app-A/info.ss
@@ -0,0 +1,7 @@
+(lambda (request)
+  (case request
+    [(name) "Startup Test"]
+    [(app-unit-library) "tappinfo.ss"]
+    [(app-sig-library) "tsig.ss"]
+    [(splash-image-path) #f]
+    [else (error 'test-A "Unknown request: ~s" request)]))
diff --git a/collects/tests/mred/startup/app-A/tappinfo.ss b/collects/tests/mred/startup/app-A/tappinfo.ss
new file mode 100644
index 0000000..6133a7c
--- /dev/null
+++ b/collects/tests/mred/startup/app-A/tappinfo.ss
@@ -0,0 +1,3 @@
+(unit/sig ()
+  (import [I : mred:application-imports^])
+  (printf "whee~n"))
\ No newline at end of file
diff --git a/collects/tests/mred/startup/app-A/tsig.ss b/collects/tests/mred/startup/app-A/tsig.ss
new file mode 100644
index 0000000..e69de29
diff --git a/collects/tests/mred/startup/app-a/tapp.ss b/collects/tests/mred/startup/app-a/tapp.ss
new file mode 100644
index 0000000..6133a7c
--- /dev/null
+++ b/collects/tests/mred/startup/app-a/tapp.ss
@@ -0,0 +1,3 @@
+(unit/sig ()
+  (import [I : mred:application-imports^])
+  (printf "whee~n"))
\ No newline at end of file
diff --git a/collects/tests/mred/startup/app-a/tsig.ss b/collects/tests/mred/startup/app-a/tsig.ss
new file mode 100644
index 0000000..e69de29
diff --git a/collects/tests/mred/startup/ee-has-mred.ss b/collects/tests/mred/startup/ee-has-mred.ss
new file mode 100644
index 0000000..2cd5888
--- /dev/null
+++ b/collects/tests/mred/startup/ee-has-mred.ss
@@ -0,0 +1,2 @@
+(when (and (defined? 'mred:frame%) (defined? 'mred:console))
+  (printf "ee~n"))
diff --git a/collects/tests/mred/startup/ee.ss b/collects/tests/mred/startup/ee.ss
new file mode 100644
index 0000000..476d047
--- /dev/null
+++ b/collects/tests/mred/startup/ee.ss
@@ -0,0 +1 @@
+(printf "ee~n")
diff --git a/collects/tests/mred/startup/run.ss b/collects/tests/mred/startup/run.ss
new file mode 100755
index 0000000..bc5033a
--- /dev/null
+++ b/collects/tests/mred/startup/run.ss
@@ -0,0 +1,213 @@
+#!/bin/sh
+
+string=? ; exec /home/scheme/Executables/mzscheme -x -qgr $0 $@
+
+(define arg (if (= 0 (vector-length argv))
+		"-x"
+		(vector-ref argv 0)))
+
+(define plt-collects
+  (cond
+   [(string=? arg "-x") ":"]
+   [(string=? arg "-robby") "/home/robby/plt:"]
+   [else (error 'plt-home "don't recognize ~a~n" arg)]))
+
+(define (print-plt-collects)
+  (printf "PLTCOLLECTS is now ~s~n" (getenv "PLTCOLLECTS")))
+
+;; this takes -x, -robby etc into account
+(define (extend-plt-collects path)
+  (let ([new-collects
+	 (if (char=? (string-ref plt-collects 0) #\:)
+	     (string-append path ":")
+	     (string-append path ":" plt-collects))])
+    (putenv "PLTCOLLECTS" new-collects)
+    (print-plt-collects)))
+(define (reset-plt-collects)
+  (putenv "PLTCOLLECTS" plt-collects)
+  (print-plt-collects))
+
+(define MRED (list "/home/scheme/plt/bin/mred"))
+
+(printf "WARNING: this script will move your ~~/.mredrc to ~~/mredrc
+and write into your .mredrc. It should restore things, but if tests
+fail your .mredrc may by in ~~/mredrc.
+
+If you pass an argument, that is passed on to
+/home/scheme/Executables/mred. It's used for -robby or something like that
+
+If you see lines prefixed by `>' they are from mred's stderr and
+mean that test has failed (even tho the script does not stop or say FAIL)
+
+If you see the splash screen (except during the splash screen test),
+the test failed. The console window popping up occasionally is okay,
+tho.
+
+You must run this script from the directory where it is located.
+
+")
+
+(printf "mred is: ~s~n" MRED)
+(reset-plt-collects)
+
+(when (file-exists? "~/.mredrc")
+  (printf "-- moving ~~/.mredrc to ~~/mredrc~n")
+  (system "mv -f ~/.mredrc ~/mredrc"))
+
+(define (set-mredrc s)
+  (let ([p (open-output-file "~/.mredrc" 'replace)])
+    (display s p)
+    (close-output-port p))
+  (printf "set .mredrc to:~n~a~n" s))
+(define (clear-mredrc)
+  (when (file-exists? "~/.mredrc")
+    (delete-file "~/.mredrc"))
+  (printf "cleared .mredrc~n"))
+
+(define (move-in-mredrc)
+  (printf "-- moving ~~/mredrc to ~~/.mredrc~n")
+  (if (file-exists? "~/mredrc")
+      (system "mv -f ~/mredrc ~/.mredrc")))
+
+(current-exception-handler
+ (let ([old (current-exception-handler)])
+   (lambda (exn)
+     (when (file-exists? "~/mredrc")
+       (move-in-mredrc))
+     (old exn))))
+
+(user-break-poll-handler
+ (let ([old (user-break-poll-handler)])
+   (lambda ()
+     (if (old)
+	 (begin (move-in-mredrc)
+		(printf "caught break ~n")
+		#t)
+	 #f))))
+
+(define test-mred
+  (lambda (expected . args)
+    (let*-values ([(command) (append MRED args)]
+		  [(stdout stdin pid stderr info)
+		   (apply values
+			  (apply process*
+				 command))])
+      (printf "running: ~s~n" command)
+      (thread
+       (lambda ()
+	 (let loop ()
+	   (let ([line (read-line stderr)])
+	     (unless (eof-object? line)
+	       (display "> ")
+	       (display line)
+	       (newline)
+	       (loop))))))
+      (let ([received (read-line stdout)])
+	(if (equal? expected received)
+	    (printf "test passed~n")
+	    (printf "FAILED TEST: got: ~s wanted: ~s~n" received expected))
+	(printf "killing ~a~n" pid)
+	(system (format "kill ~a" pid))))))
+
+(define (test:no-flags)
+  (printf "~n- testing no flags~n")
+  (set-mredrc "(fprintf mred:constants:original-output-port \"whee~n\")")
+  (test-mred "whee")
+  (clear-mredrc))
+
+(define (test:-f)
+  (printf"~n- testing -f flag~n")
+  (test-mred "whee" "-f" "whee.ss"))
+
+(define (test:-e)
+  (printf "~n- testing -e flag~n")
+  (test-mred "whee" "-e" "(printf \"whee~n\")"))
+
+(define (test:-nu-e)
+  (printf "~n- testing -nu with -e flag~n")
+  (test-mred "whee" 
+	     "-e"
+	     "(when (defined? 'mred:frame%)
+		(printf \"wh\"))"
+	     "-nu"
+	     "-e"
+	     "(when (and (defined? 'mred:frame%)
+			 (defined? 'mred:console))
+		(printf \"ee~n\"))"))
+
+(define (test:-nu-f)
+  (printf "~n- testing -nu with -f flag~n")
+  (test-mred "whee" 
+	     "-f"
+	     "wh-has-mred.ss"
+	     "-nu"
+	     "-f"
+	     "ee-has-mred.ss"))
+
+(define (test:.mredrc)
+  (printf "~n- testing that .mredrc is loaded~n")
+  (set-mredrc "(fprintf mred:constants:original-output-port \"whee~n\")")
+  (test-mred "whee")
+  (clear-mredrc))
+
+(define (test:.mredrc-nu-f)
+  (printf "~n- testing that .mredrc is run during -nu flag~n")
+  (set-mredrc "(fprintf mred:constants:original-output-port \"ee~n\")")
+  (test-mred "whee" "-f" "wh.ss" "-nu")
+  (clear-mredrc))
+
+(define (test:mred:startup-before)
+  (printf "~n- testing mred:startup after -nu~n")
+  (set-mredrc "(printf \"ee~n\")")
+  (test-mred "whee" "-nu" "-e"
+	     "(define mred:startup (lambda x (printf \"wh\")))")
+  (clear-mredrc))
+
+(define (test:-a)
+  (printf "~n- testing -a flag~n")
+  (extend-plt-collects (current-load-relative-directory))
+  (test-mred
+   "whee" "-a" "app-a" "tapp.ss" "tsig.ss")
+  (reset-plt-collects))
+
+(define (test:-A)
+  (printf "~n- testing -A flag~n")
+  (extend-plt-collects (current-load-relative-directory))
+  (test-mred
+   "whee" "-A" "app-A")
+  (reset-plt-collects))
+
+(define (test:-p)
+  (printf "~n- testing -p flag~n")
+  (test-mred
+   "whee" 
+   "-nu"
+   "-p" "/home/scheme/plt/collects/icons/anchor.gif" "splash screen test" "150" "4"
+   "-e" "(printf \"whee~n\")"))
+
+(define (test:no-icons)
+  (let ([icons-before/after (collection-path "icons")])
+    (let-values ([(path _1 _2) (split-path icons-before/after)])
+      (let ([icons-during (build-path path "renamed-icons")])
+	(printf "~n- testing icon-less startup~n")
+	(printf "~n  This test expects only one icons collection is available")
+	(printf "~n-- moving ~a to ~a ~n" icons-before/after icons-during)
+	(rename-file icons-before/after icons-during)
+	(test-mred "whee" "-e" "(printf \"whee~n\")")
+	(printf "~n-- moving ~a to ~a ~n" icons-during icons-before/after)
+	(rename-file icons-during icons-before/after)))))
+
+(test:no-icons)
+(test:no-flags)
+(test:-e)
+(test:-f)
+(test:-nu-e)
+(test:-nu-f)
+(test:.mredrc)
+(test:.mredrc-nu-f)
+(test:mred:startup-before)
+(test:-a)
+(test:-A)
+(test:-p)
+
+(move-in-mredrc)
\ No newline at end of file
diff --git a/collects/tests/mred/startup/w.ss b/collects/tests/mred/startup/w.ss
new file mode 100644
index 0000000..e073ee7
--- /dev/null
+++ b/collects/tests/mred/startup/w.ss
@@ -0,0 +1 @@
+(printf "w")
diff --git a/collects/tests/mred/startup/wh-has-mred.ss b/collects/tests/mred/startup/wh-has-mred.ss
new file mode 100644
index 0000000..152c6c8
--- /dev/null
+++ b/collects/tests/mred/startup/wh-has-mred.ss
@@ -0,0 +1,3 @@
+(when (and (defined? 'mred:frame%)
+	   (defined? 'mred:console))
+  (printf "wh"))
diff --git a/collects/tests/mred/startup/wh.ss b/collects/tests/mred/startup/wh.ss
new file mode 100644
index 0000000..c5f55b4
--- /dev/null
+++ b/collects/tests/mred/startup/wh.ss
@@ -0,0 +1 @@
+(printf "wh")
diff --git a/collects/tests/mred/startup/whee.ss b/collects/tests/mred/startup/whee.ss
new file mode 100644
index 0000000..407ddff
--- /dev/null
+++ b/collects/tests/mred/startup/whee.ss
@@ -0,0 +1 @@
+(printf "whee~n")
diff --git a/collects/tests/mred/steps.txt b/collects/tests/mred/steps.txt
new file mode 100644
index 0000000..b33c7e5
--- /dev/null
+++ b/collects/tests/mred/steps.txt
@@ -0,0 +1,130 @@
+Instructions:
+ Initial Setup:
+  - Second menu is enabled "Apple"
+  Delete Apple
+
+ Menu Inserting & Deleting:
+  Add Apple - apple menu appears
+  Add Banana - banana menu appears
+  Delete Apple (from apple menu) - apple menu goes, banana menu still there
+  Delete Banana - back to starting point
+  Add Apple
+  Add Banana
+  Delete Banana - apple still there
+  Delete Apple
+  Add Apple
+  Add Coconut - coconut submenu appears
+  Delete Coconut (from sub-menu) - coconut submenu gone
+  Delete Apple
+  Add Coconut
+  Add Apple - apple menu appears with coconut already
+  Delete Apple
+  Delete Coconut
+  Add Apple - apple menu appears without coconut
+
+ Menu Enabling:
+  Disable Second - apple menu gray & unselectable
+  Enable Second - back to normal
+  Disable Second
+  Delete Apple (from tester menu)
+  Add Apple - NOT gray anymore
+
+ Item Enabling:
+  Disable Apple Once Item -> once item grayed & unselectable
+  Un-Disable Apple Once Item -> once item normal
+  Disable Apple Once Item
+  Delete Apple
+  Add Apple -> once item still gray
+  Un-Disable Apple Once Item
+  Delete Apple
+  Disable Apple Once Item
+  Add Apple -> once item gray again
+  Un-Disable Apple Once Item
+  
+ Item Inserting & Deleting:
+  Append Donut - donut item added
+  Delete Once - once item disappears
+  Delete Apple
+  Add Apple - once item still gone
+  Append Donut - another donut
+  Delete Apple
+  Append Donut
+  Add Apple - three donuts total
+
+ Checkable Items & Insertions:
+  Test Apple Item -> "no"
+  Apple Checkable
+  Test Apple Item -> "yes"
+  Delete Apple
+  Test Apple Item -> "yes"
+  Apple Checkable
+  Test Apple Item -> "no"
+  Delete Apple
+  Test Apple Item -> "no"
+
+ More Checkable (Apple & Banana currently deleted):
+  Test Aeros -> "yes"
+  Test Bruin -> "no"
+  Test Capitols -> "no"
+
+  Check Astros -> nothing
+  Check Braves -> "Braves checked", braves checked, astros unchecked
+  Check Cardianls -> "Cardinals checked", cardinals checked, braves unchecked
+
+  Check Bruins -> "Boston checked", aeros unchecked, bruins checked
+
+  Test Aeros -> "no"
+  Test Bruin -> "yes"
+  Test Capitols -> "no"
+
+ Checkable via Menubar (Apple & Banana currently deleted):
+  Via Menubar
+  Test Aeros -> "no"
+  Test Bruin -> "yes"
+  Test Apple Item -> "no"
+  Check in Apple (Button)
+  Add Apple - checkable item *not* checked
+  Check in Apple (Button) - item checked
+  Test Apple Item -> "yes"
+  Delete Apple
+  Test Apple Item -> "no"
+  Add Apple
+  Apple | Checkable
+  Delete Apple
+  Via Menubar
+
+ Labels (Apple & Banana currently deleted):
+  Add Coconut - (coconut item needed for the rest)
+  Test Labels - "ok" in console
+  Find Labels - "ok" in console
+  Toggle Labels - "Tester" -> "Hi", "Add Apple" -> "Apple Adder", "Astros" -> "'Stros"
+  Add Apple - check that "Delete Apple" -> "Apple Deleter"
+  Delete Apple
+  Test Labels - "ok" in console
+  Find Labels - "ok" in console
+  Toggle Labels - original labels
+  Add Apple - check for original labels
+  Toggle Labels - "Delete Apple" -> "Apple Deleter"
+  Toggle Labels
+  Delete Apple
+  Via Menubar 
+  Test Labels - "ok" in console
+  Find Labels - "ok" in console
+  Toggle Labels - "Add Apple" -> "Apple Adder", "Astros" -> "'Stros"
+  Test Labels - "ok" in console
+  Find Labels - "ok" in console
+  Toggle Labels - original labels
+  Add Apple
+  Test Labels - "ok" in console
+  Find Labels - "ok" in console
+  Via Menubar - off
+
+ Handling Bad Requests:
+  Test Bad Item -> #f
+  Test Other Bad Item -> #f
+  Bad Item Labels - "ok" in console
+  Via Menubar 
+  Bad Item Labels - "ok" in console
+  Via Menubar 
+  Bad Check - nothing
+  Bad Enable - nothing
diff --git a/collects/tests/mred/tests.ss b/collects/tests/mred/tests.ss
new file mode 100644
index 0000000..4adfdfb
--- /dev/null
+++ b/collects/tests/mred/tests.ss
@@ -0,0 +1,1698 @@
+(hash-table-put! classinfo wx:bitmap%
+  (list wxBitmap!-example-list (quote wx:bitmap%)
+    (list
+      (list charARRAY-example-list int-example-list int-example-list int-example-list)
+      (list int-example-list int-example-list int-example-list)
+      (list pathname-example-list long-example-list))
+    (list 'set-colour-map void-example-list wxColourMap^-example-list)
+    (list 'load-file void-example-list pathname-example-list long-example-list)
+    (list 'ok? bool-example-list)
+    (list 'get-width int-example-list)
+    (list 'get-height int-example-list)
+    (list 'get-depth int-example-list)))
+(hash-table-put! classinfo wx:button%
+  (list wxButton!-example-list (quote wx:button%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list string-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list wxFunction-example-list wxBitmap!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'set-label void-example-list string-example-list)
+    (list 'set-label void-example-list wxBitmap!-example-list)
+    (list 'set-default void-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:choice%
+  (list wxChoice!-example-list (quote wx:choice%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list int-example-list int-example-list int-example-list int-example-list stringARRAY-example-list long-example-list string-example-list))
+    (list 'get-columns int-example-list)
+    (list 'set-columns void-example-list int-example-list)
+    (list 'get-string string-example-list int-example-list)
+    (list 'set-string-selection void-example-list string-example-list)
+    (list 'set-selection void-example-list int-example-list)
+    (list 'get-string-selection string-example-list)
+    (list 'get-selection int-example-list)
+    (list 'find-string int-example-list string-example-list)
+    (list 'number int-example-list)
+    (list 'clear void-example-list)
+    (list 'append void-example-list string-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:check-box%
+  (list wxCheckBox!-example-list (quote wx:check-box%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list string-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list wxFunction-example-list wxBitmap!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'set-label void-example-list string-example-list)
+    (list 'set-label void-example-list wxBitmap!-example-list)
+    (list 'set-value void-example-list bool-example-list)
+    (list 'get-value bool-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:canvas%
+  (list wxCanvas!-example-list (quote wx:canvas%)
+    (list
+      (list wxFrame!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'set-text-foreground void-example-list wxColour!-example-list)
+    (list 'set-text-background void-example-list wxColour!-example-list)
+    (list 'set-pen void-example-list wxPen!-example-list)
+    (list 'set-logical-function void-example-list int-example-list)
+    (list 'set-font void-example-list wxFont!-example-list)
+    (list 'set-brush void-example-list wxBrush!-example-list)
+    (list 'set-background void-example-list wxBrush!-example-list)
+    (list 'get-clipping-region void-example-list float*-example-list float*-example-list float*-example-list float*-example-list)
+    (list 'set-clipping-region void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'destroy-clipping-region void-example-list)
+    (list 'draw-polygon void-example-list wxPoint!-example-list float-example-list float-example-list int-example-list)
+    (list 'draw-lines void-example-list wxPoint!-example-list float-example-list float-example-list)
+    (list 'draw-ellipse void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-arc void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-text void-example-list string-example-list float-example-list float-example-list bool-example-list)
+    (list 'draw-spline void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-rounded-rectangle void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-rectangle void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-point void-example-list float-example-list float-example-list)
+    (list 'draw-line void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'clear void-example-list)
+    (list 'end-drawing void-example-list)
+    (list 'begin-drawing void-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'scroll void-example-list int-example-list int-example-list)
+    (list 'warp-pointer void-example-list int-example-list int-example-list)
+    (list 'view-start void-example-list int*-example-list int*-example-list)
+    (list 'set-scrollbars void-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list bool-example-list)
+    (list 'is-retained? bool-example-list)
+    (list 'get-virtual-size void-example-list int*-example-list int*-example-list)
+    (list 'get-scroll-units-per-page void-example-list int*-example-list int*-example-list)
+    (list 'get-dc wxCanvasDC!-example-list)
+    (list 'popup-menu bool-example-list wxMenu!-example-list float-example-list float-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-paint void-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'enable-scrolling void-example-list bool-example-list bool-example-list)
+    (list 'allow-double-click void-example-list bool-example-list)))
+(hash-table-put! classinfo wx:dc%
+  (list wxDC!-example-list (quote wx:dc%)
+    (list)
+    (list 'end-page void-example-list)
+    (list 'end-doc void-example-list)
+    (list 'start-page void-example-list)
+    (list 'start-doc bool-example-list string-example-list)
+    (list 'ok? bool-example-list)
+    (list 'min-y float-example-list)
+    (list 'min-x float-example-list)
+    (list 'max-y float-example-list)
+    (list 'max-x float-example-list)
+    (list 'get-size void-example-list float*-example-list float*-example-list)
+    (list 'get-text-foreground wxColour%-example-list)
+    (list 'get-text-background wxColour%-example-list)
+    (list 'get-pen wxPen!-example-list)
+    (list 'get-map-mode int-example-list)
+    (list 'get-logical-function int-example-list)
+    (list 'get-font wxFont!-example-list)
+    (list 'get-brush wxBrush!-example-list)
+    (list 'get-background wxBrush!-example-list)
+    (list 'set-device-origin void-example-list float-example-list float-example-list)
+    (list 'set-user-scale void-example-list float-example-list float-example-list)
+    (list 'set-colour-map void-example-list wxColourMap!-example-list)
+    (list 'set-background-mode void-example-list int-example-list)
+    (list 'set-map-mode void-example-list int-example-list)
+    (list 'try-colour void-example-list wxColour!-example-list wxColour!-example-list)
+    (list 'blit bool-example-list float-example-list float-example-list float-example-list float-example-list wxCanvasDC!-example-list float-example-list float-example-list int-example-list)
+    (list 'draw-icon void-example-list wxIcon!-example-list float-example-list float-example-list)
+    (list 'set-optimization void-example-list bool-example-list)
+    (list 'get-char-width float-example-list)
+    (list 'get-char-height float-example-list)
+    (list 'get-text-extent void-example-list string-example-list float*-example-list float*-example-list float?-example-list float?-example-list wxFont^-example-list bool-example-list)
+    (list 'set-text-foreground void-example-list wxColour!-example-list)
+    (list 'set-text-background void-example-list wxColour!-example-list)
+    (list 'set-pen void-example-list wxPen!-example-list)
+    (list 'set-logical-function void-example-list int-example-list)
+    (list 'set-font void-example-list wxFont!-example-list)
+    (list 'set-brush void-example-list wxBrush!-example-list)
+    (list 'set-background void-example-list wxBrush!-example-list)
+    (list 'get-clipping-region void-example-list float*-example-list float*-example-list float*-example-list float*-example-list)
+    (list 'set-clipping-region void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'destroy-clipping-region void-example-list)
+    (list 'draw-polygon void-example-list wxPoint!-example-list float-example-list float-example-list int-example-list)
+    (list 'draw-lines void-example-list wxPoint!-example-list float-example-list float-example-list)
+    (list 'draw-ellipse void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-arc void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-text void-example-list string-example-list float-example-list float-example-list bool-example-list)
+    (list 'draw-spline void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-rounded-rectangle void-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-rectangle void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'draw-point void-example-list float-example-list float-example-list)
+    (list 'draw-line void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'clear void-example-list)
+    (list 'end-drawing void-example-list)
+    (list 'begin-drawing void-example-list)))
+(hash-table-put! classinfo wx:canvas-dc%
+  (list wxCanvasDC!-example-list (quote wx:canvas-dc%)
+    (list
+      (list))
+    (list 'set-pixel void-example-list float-example-list float-example-list wxColour^-example-list)
+    (list 'end-set-pixel void-example-list)
+    (list 'begin-set-pixel void-example-list)
+    (list 'get-pixel bool-example-list float-example-list float-example-list wxColour^-example-list)))
+(hash-table-put! classinfo wx:memory-dc%
+  (list wxMemoryDC!-example-list (quote wx:memory-dc%)
+    (list
+      (list)
+      (list wxCanvasDC!-example-list))
+    (list 'select-object void-example-list wxBitmap^-example-list)))
+(hash-table-put! classinfo wx:post-script-dc%
+  (list wxPostScriptDC!-example-list (quote wx:post-script-dc%)
+    (list
+      (list npathname-example-list bool-example-list wxWindow^-example-list))))
+(hash-table-put! classinfo wx:printer-dc%
+  (list basePrinterDC!-example-list (quote wx:printer-dc%)
+    (list
+      (list nstring-example-list nstring-example-list nstring-example-list bool-example-list))))
+(hash-table-put! classinfo wx:meta-file-dc%
+  (list baseMetaFileDC!-example-list (quote wx:meta-file-dc%)
+    (list
+      (list string-example-list))))
+(hash-table-put! classinfo wx:event%
+  (list wxEvent!-example-list (quote wx:event%)
+    (list)
+    (list 'get-event-class long-example-list)
+    (list 'set-event-class void-example-list long-example-list)
+    (list 'get-event-type long-example-list)
+    (list 'set-event-type void-example-list long-example-list)
+    (list 'get-event-object wxObject!-example-list)
+    (list 'set-event-object void-example-list wxObject!-example-list)))
+(hash-table-put! classinfo wx:command-event%
+  (list wxCommandEvent!-example-list (quote wx:command-event%)
+    (list
+      (list int-example-list))
+    (list 'is-selection? bool-example-list)
+    (list 'checked? bool-example-list)
+    (list 'get-string string-example-list)
+    (list 'get-selection int-example-list)
+    (list 'get-extra-long long-example-list)
+    (list 'set-extra-long void-example-list long-example-list)
+    (list 'get-command-int int-example-list)
+    (list 'set-command-int void-example-list int-example-list)
+    (list 'get-command-string string-example-list)
+    (list 'set-command-string void-example-list string-example-list)))
+(hash-table-put! classinfo wx:key-event%
+  (list wxKeyEvent!-example-list (quote wx:key-event%)
+    (list
+      (list int-example-list))
+    (list 'position void-example-list float*-example-list float*-example-list)
+    (list 'key-code long-example-list)
+    (list 'get-key-code long-example-list)
+    (list 'set-key-code void-example-list long-example-list)
+    (list 'get-shift-down bool-example-list)
+    (list 'set-shift-down void-example-list bool-example-list)
+    (list 'get-control-down bool-example-list)
+    (list 'set-control-down void-example-list bool-example-list)
+    (list 'get-meta-down bool-example-list)
+    (list 'set-meta-down void-example-list bool-example-list)
+    (list 'get-alt-down bool-example-list)
+    (list 'set-alt-down void-example-list bool-example-list)
+    (list 'get-time-stamp long-example-list)
+    (list 'set-time-stamp void-example-list long-example-list)))
+(hash-table-put! classinfo wx:mouse-event%
+  (list wxMouseEvent!-example-list (quote wx:mouse-event%)
+    (list
+      (list int-example-list))
+    (list 'moving? bool-example-list)
+    (list 'is-button? bool-example-list)
+    (list 'leaving? bool-example-list)
+    (list 'entering? bool-example-list)
+    (list 'dragging? bool-example-list)
+    (list 'button-up? bool-example-list int-example-list)
+    (list 'button-down? bool-example-list int-example-list)
+    (list 'button-d-click? bool-example-list int-example-list)
+    (list 'button? bool-example-list int-example-list)
+    (list 'get-left-down bool-example-list)
+    (list 'set-left-down void-example-list bool-example-list)
+    (list 'get-middle-down bool-example-list)
+    (list 'set-middle-down void-example-list bool-example-list)
+    (list 'get-right-down bool-example-list)
+    (list 'set-right-down void-example-list bool-example-list)
+    (list 'get-shift-down bool-example-list)
+    (list 'set-shift-down void-example-list bool-example-list)
+    (list 'get-control-down bool-example-list)
+    (list 'set-control-down void-example-list bool-example-list)
+    (list 'get-meta-down bool-example-list)
+    (list 'set-meta-down void-example-list bool-example-list)
+    (list 'get-alt-down bool-example-list)
+    (list 'set-alt-down void-example-list bool-example-list)
+    (list 'get-x float-example-list)
+    (list 'set-x void-example-list float-example-list)
+    (list 'get-y float-example-list)
+    (list 'set-y void-example-list float-example-list)
+    (list 'get-time-stamp long-example-list)
+    (list 'set-time-stamp void-example-list long-example-list)))
+(hash-table-put! classinfo 'wxEventGlobal
+  (list #f (quote 'wxEventGlobal)
+    (list)
+    (list 'duplicate-mouse-event wxMouseEvent!-example-list wxMouseEvent!-example-list)
+    (list 'duplicate-key-event wxKeyEvent!-example-list wxKeyEvent!-example-list)))
+(hash-table-put! classinfo wx:frame%
+  (list wxFrame!-example-list (quote wx:frame%)
+    (list
+      (list wxFrame^-example-list string-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'on-menu-select void-example-list int-example-list)
+    (list 'on-menu-command void-example-list int-example-list)
+    (list 'command void-example-list int-example-list)
+    (list 'on-close bool-example-list)
+    (list 'on-activate void-example-list bool-example-list)
+    (list 'create-status-line void-example-list int-example-list string-example-list)
+    (list 'load-accelerators void-example-list string-example-list)
+    (list 'maximize void-example-list bool-example-list)
+    (list 'status-line-exists? bool-example-list)
+    (list 'iconized? bool-example-list)
+    (list 'set-status-text void-example-list string-example-list)
+    (list 'get-tool-bar wxToolBar^-example-list)
+    (list 'set-tool-bar void-example-list wxToolBar^-example-list)
+    (list 'get-menu-bar wxMenuBar^-example-list)
+    (list 'set-menu-bar void-example-list wxMenuBar!-example-list)
+    (list 'set-icon void-example-list wxIcon!-example-list)
+    (list 'iconize void-example-list bool-example-list)
+    (list 'set-title void-example-list string-example-list)
+    (list 'get-title string-example-list)
+    (list 'get-menu-bar wxMenuBar^-example-list)))
+(hash-table-put! classinfo wx:gauge%
+  (list wxsGauge!-example-list (quote wx:gauge%)
+    (list
+      (list wxPanel!-example-list nstring-example-list int-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'get-value int-example-list)
+    (list 'set-value void-example-list int-example-list)
+    (list 'get-range int-example-list)
+    (list 'set-range void-example-list int-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:font%
+  (list wxFont!-example-list (quote wx:font%)
+    (list
+      (list)
+      (list int-example-list int-example-list int-example-list int-example-list bool-example-list)
+      (list int-example-list cstring-example-list int-example-list int-example-list int-example-list bool-example-list))
+    (list 'get-underlined bool-example-list)
+    (list 'get-weight int-example-list)
+    (list 'get-point-size int-example-list)
+    (list 'get-style int-example-list)
+    (list 'get-font-id int-example-list)
+    (list 'get-family int-example-list)))
+(hash-table-put! classinfo wx:font-list%
+  (list wxFontList!-example-list (quote wx:font-list%)
+    (list
+      (list))
+    (list 'find-or-create-font wxFont!-example-list int-example-list cstring-example-list int-example-list int-example-list int-example-list bool-example-list)
+    (list 'find-or-create-font wxFont!-example-list int-example-list int-example-list int-example-list int-example-list bool-example-list)))
+(hash-table-put! classinfo wx:colour%
+  (list wxColour!-example-list (quote wx:colour%)
+    (list
+      (list)
+      (list ubyte-example-list ubyte-example-list ubyte-example-list)
+      (list string-example-list))
+    (list 'blue ubyte-example-list)
+    (list 'green ubyte-example-list)
+    (list 'red ubyte-example-list)
+    (list 'set void-example-list ubyte-example-list ubyte-example-list ubyte-example-list)
+    (list 'ok? bool-example-list)
+    (list 'get void-example-list ubyte*-example-list ubyte*-example-list ubyte*-example-list)
+    (list '= wxColour%-example-list wxColour%-example-list)))
+(hash-table-put! classinfo wx:colour-map%
+  (list wxColourMap!-example-list (quote wx:colour-map%)
+    (list)))
+(hash-table-put! classinfo wx:colour-database%
+  (list wxColourDatabase!-example-list (quote wx:colour-database%)
+    (list)
+    (list 'append void-example-list string-example-list wxColour!-example-list)
+    (list 'find-name string-example-list wxColour%-example-list)
+    (list 'find-colour wxColour^-example-list string-example-list)))
+(hash-table-put! classinfo wx:point%
+  (list wxPoint!-example-list (quote wx:point%)
+    (list
+      (list)
+      (list float-example-list float-example-list))
+    (list 'get-x float-example-list)
+    (list 'set-x void-example-list float-example-list)
+    (list 'get-y float-example-list)
+    (list 'set-y void-example-list float-example-list)))
+(hash-table-put! classinfo wx:int-point%
+  (list wxIntPoint!-example-list (quote wx:int-point%)
+    (list
+      (list)
+      (list int-example-list int-example-list))
+    (list 'get-x int-example-list)
+    (list 'set-x void-example-list int-example-list)
+    (list 'get-y int-example-list)
+    (list 'set-y void-example-list int-example-list)))
+(hash-table-put! classinfo wx:brush%
+  (list wxBrush!-example-list (quote wx:brush%)
+    (list
+      (list)
+      (list wxColour%-example-list int-example-list)
+      (list string-example-list int-example-list))
+    (list 'set-style void-example-list int-example-list)
+    (list 'get-style int-example-list)
+    (list 'set-stipple void-example-list wxBitmap^-example-list)
+    (list 'get-stipple wxBitmap!-example-list)
+    (list 'set-colour void-example-list int-example-list int-example-list int-example-list)
+    (list 'set-colour void-example-list string-example-list)
+    (list 'set-colour void-example-list wxColour%-example-list)
+    (list 'get-colour wxColour%-example-list)))
+(hash-table-put! classinfo wx:brush-list%
+  (list wxBrushList!-example-list (quote wx:brush-list%)
+    (list
+      (list))
+    (list 'find-or-create-brush wxBrush!-example-list string-example-list int-example-list)
+    (list 'find-or-create-brush wxBrush!-example-list wxColour!-example-list int-example-list)))
+(hash-table-put! classinfo wx:pen%
+  (list wxPen!-example-list (quote wx:pen%)
+    (list
+      (list)
+      (list wxColour%-example-list int-example-list int-example-list)
+      (list string-example-list int-example-list int-example-list))
+    (list 'set-style void-example-list int-example-list)
+    (list 'get-style int-example-list)
+    (list 'set-stipple void-example-list wxBitmap^-example-list)
+    (list 'get-stipple wxBitmap!-example-list)
+    (list 'set-colour void-example-list int-example-list int-example-list int-example-list)
+    (list 'set-colour void-example-list string-example-list)
+    (list 'set-colour void-example-list wxColour%-example-list)
+    (list 'get-colour wxColour%-example-list)
+    (list 'set-join void-example-list int-example-list)
+    (list 'get-join int-example-list)
+    (list 'set-cap void-example-list int-example-list)
+    (list 'get-cap int-example-list)
+    (list 'set-width void-example-list int-example-list)
+    (list 'get-width int-example-list)))
+(hash-table-put! classinfo wx:pen-list%
+  (list wxPenList!-example-list (quote wx:pen-list%)
+    (list
+      (list))
+    (list 'find-or-create-pen wxPen!-example-list string-example-list int-example-list int-example-list)
+    (list 'find-or-create-pen wxPen!-example-list wxColour!-example-list int-example-list int-example-list)))
+(hash-table-put! classinfo wx:cursor%
+  (list wxCursor!-example-list (quote wx:cursor%)
+    (list
+      (list string-example-list long-example-list int-example-list int-example-list)
+      (list int-example-list))
+    (list 'ok? bool-example-list)))
+(hash-table-put! classinfo wx:icon%
+  (list wxIcon!-example-list (quote wx:icon%)
+    (list
+      (list string-example-list int-example-list))))
+(hash-table-put! classinfo wx:font-name-directory%
+  (list wxFontNameDirectory!-example-list (quote wx:font-name-directory%)
+    (list)
+    (list 'find-or-create-font-id int-example-list cstring-example-list int-example-list)
+    (list 'get-family int-example-list int-example-list)
+    (list 'get-font-name nstring-example-list int-example-list)
+    (list 'get-font-id int-example-list string-example-list)
+    (list 'initialize void-example-list int-example-list int-example-list string-example-list)
+    (list 'get-new-font-id int-example-list)
+    (list 'get-afm-name nstring-example-list int-example-list int-example-list int-example-list)
+    (list 'get-post-script-name nstring-example-list int-example-list int-example-list int-example-list)
+    (list 'get-screen-name nstring-example-list int-example-list int-example-list int-example-list)))
+(hash-table-put! classinfo 'wxsGlobal
+  (list #f (quote 'wxsGlobal)
+    (list)
+    (list 'wx:flush-display void-example-list)
+    (list 'wx:yield bool-example-list voidARRAY-example-list)
+    (list 'wx:get-resource bool-example-list string-example-list string-example-list long*-example-list nstring-example-list)
+    (list 'wx:get-resource bool-example-list string-example-list string-example-list string*-example-list nstring-example-list)
+    (list 'wx:get-free-memory long-example-list)
+    (list 'wx:strip-menu-codes string-example-list string-example-list)
+    (list 'wx:find-window-by-name wxWindow^-example-list string-example-list wxWindow^-example-list)
+    (list 'wx:find-window-by-label wxWindow^-example-list string-example-list wxWindow^-example-list)
+    (list 'wx:display-size void-example-list int*-example-list int*-example-list)
+    (list 'wx:bell void-example-list)
+    (list 'wx:end-busy-cursor void-example-list)
+    (list 'wx:is-busy? bool-example-list)
+    (list 'wx:begin-busy-cursor void-example-list wxCursor!-example-list)
+    (list 'wx:register-id void-example-list long-example-list)
+    (list 'wx:new-id long-example-list)
+    (list 'wx:set-post-script-level-2 void-example-list bool-example-list)
+    (list 'wx:set-afm-path void-example-list nstring-example-list)
+    (list 'wx:set-print-paper-name void-example-list nstring-example-list)
+    (list 'wx:set-printer-translation void-example-list float-example-list float-example-list)
+    (list 'wx:set-printer-scaling void-example-list float-example-list float-example-list)
+    (list 'wx:set-printer-options void-example-list string-example-list)
+    (list 'wx:set-printer-orientation void-example-list int-example-list)
+    (list 'wx:set-printer-mode void-example-list int-example-list)
+    (list 'wx:set-printer-preview-command void-example-list string-example-list)
+    (list 'wx:set-printer-file void-example-list pathname-example-list)
+    (list 'wx:set-printer-command void-example-list string-example-list)
+    (list 'wx:get-post-script-level-2 bool-example-list)
+    (list 'wx:get-afm-path nstring-example-list)
+    (list 'wx:get-print-paper-name nstring-example-list)
+    (list 'wx:get-printer-translation void-example-list float*-example-list float*-example-list)
+    (list 'wx:get-printer-scaling void-example-list float*-example-list float*-example-list)
+    (list 'wx:get-printer-options string-example-list)
+    (list 'wx:get-printer-orientation int-example-list)
+    (list 'wx:get-printer-mode int-example-list)
+    (list 'wx:get-printer-preview-command string-example-list)
+    (list 'wx:get-printer-file string-example-list)
+    (list 'wx:get-printer-command string-example-list)
+    (list 'wx:set-cursor void-example-list wxCursor!-example-list)
+    (list 'wx:make-meta-file-placeable bool-example-list string-example-list float-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'wx:display-depth int-example-list)
+    (list 'wx:colour-display? bool-example-list)
+    (list 'wx:get-single-choice-data string-example-list string-example-list string-example-list stringARRAY-example-list stringARRAY-example-list wxWindow^-example-list int-example-list int-example-list bool-example-list int-example-list int-example-list)
+    (list 'wx:get-single-choice-index int-example-list string-example-list string-example-list stringARRAY-example-list wxWindow^-example-list int-example-list int-example-list bool-example-list int-example-list int-example-list)
+    (list 'wx:get-single-choice string-example-list string-example-list string-example-list stringARRAY-example-list wxWindow^-example-list int-example-list int-example-list bool-example-list int-example-list int-example-list)
+    (list 'wx:get-multiple-choice int-example-list string-example-list string-example-list stringARRAY-example-list int-example-list intARRAY-example-list wxWindow^-example-list int-example-list int-example-list bool-example-list int-example-list int-example-list)
+    (list 'wx:get-text-from-user string-example-list string-example-list string-example-list string-example-list wxWindow^-example-list int-example-list int-example-list bool-example-list)
+    (list 'wx:message-box int-example-list string-example-list string-example-list int-example-list wxWindow^-example-list int-example-list int-example-list)
+    (list 'wx:file-selector string-example-list string-example-list nstring-example-list nstring-example-list nstring-example-list string-example-list int-example-list wxWindow^-example-list int-example-list int-example-list)
+    (list 'wx:get-display-name nstring-example-list)
+    (list 'wx:set-display bool-example-list nstring-example-list)
+    (list 'wx:string-match? bool-example-list string-example-list string-example-list bool-example-list bool-example-list)
+    (list 'wx:get-user-name nstring-example-list)
+    (list 'wx:get-user-id nstring-example-list)
+    (list 'wx:get-email-address nstring-example-list)
+    (list 'wx:get-host-name nstring-example-list)
+    (list 'wx:get-temp-file-name string-example-list string-example-list)))
+(hash-table-put! classinfo wx:item%
+  (list wxItem!-example-list (quote wx:item%)
+    (list)
+    (list 'set-button-colour void-example-list wxColour!-example-list)
+    (list 'set-label-colour void-example-list wxColour!-example-list)
+    (list 'set-background-colour void-example-list wxColour!-example-list)
+    (list 'get-char-width float-example-list)
+    (list 'get-char-height float-example-list)
+    (list 'set-label void-example-list string-example-list)
+    (list 'get-label nstring-example-list)
+    (list 'set-background-colour void-example-list wxColour!-example-list)
+    (list 'get-background-colour wxColour!-example-list)
+    (list 'set-label-colour void-example-list wxColour!-example-list)
+    (list 'get-label-colour wxColour!-example-list)
+    (list 'set-button-colour void-example-list wxColour!-example-list)
+    (list 'get-button-colour wxColour!-example-list)
+    (list 'command void-example-list wxCommandEvent%-example-list)))
+(hash-table-put! classinfo wx:message%
+  (list wxMessage!-example-list (quote wx:message%)
+    (list
+      (list wxPanel!-example-list string-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list wxBitmap!-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'set-label void-example-list string-example-list)
+    (list 'set-label void-example-list wxBitmap!-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:list-box%
+  (list wxListBox!-example-list (quote wx:list-box%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list Bool-example-list int-example-list int-example-list int-example-list int-example-list stringARRAY-example-list long-example-list string-example-list))
+    (list 'set-string void-example-list int-example-list string-example-list)
+    (list 'get-string string-example-list int-example-list)
+    (list 'set-string-selection void-example-list string-example-list)
+    (list 'set-first-item void-example-list string-example-list)
+    (list 'set-first-item void-example-list int-example-list)
+    (list 'set void-example-list stringARRAY-example-list)
+    (list 'get-selections int-example-list int**-example-list)
+    (list 'number int-example-list)
+    (list 'get-selection int-example-list)
+    (list 'find-string int-example-list string-example-list)
+    (list 'set-client-data void-example-list int-example-list string-example-list)
+    (list 'get-client-data string-example-list int-example-list)
+    (list 'get-string-selection string-example-list)
+    (list 'selected? bool-example-list int-example-list)
+    (list 'set-selection void-example-list int-example-list bool-example-list)
+    (list 'deselect void-example-list int-example-list)
+    (list 'delete void-example-list int-example-list)
+    (list 'clear void-example-list)
+    (list 'append void-example-list string-example-list string-example-list)
+    (list 'append void-example-list string-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:media-canvas%
+  (list wxMediaCanvas!-example-list (quote wx:media-canvas%)
+    (list
+      (list wxFrame!-example-list int-example-list int-example-list int-example-list int-example-list string-example-list long-example-list int-example-list wxMediaBuffer^-example-list)
+      (list wxPanel!-example-list int-example-list int-example-list int-example-list int-example-list string-example-list long-example-list int-example-list wxMediaBuffer^-example-list))
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-paint void-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'call-as-primary-owner voidARRAY-example-list CAPOFunc-example-list)
+    (list 'set-lazy-refresh void-example-list bool-example-list)
+    (list 'get-lazy-refresh bool-example-list)
+    (list 'scroll-with-bottom-base void-example-list bool-example-list)
+    (list 'allow-scroll-to-last void-example-list bool-example-list)
+    (list 'force-display-focus void-example-list bool-example-list)
+    (list 'is-focus-on? bool-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'get-media wxMediaBuffer^-example-list)
+    (list 'set-media void-example-list wxMediaBuffer^-example-list bool-example-list)))
+(hash-table-put! classinfo wx:media-admin%
+  (list wxMediaAdmin!-example-list (quote wx:media-admin%)
+    (list
+      (list))
+    (list 'set-cursor void-example-list wxCursor!-example-list)
+    (list 'needs-update void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'resized void-example-list bool-example-list)
+    (list 'grab-caret void-example-list int-example-list)
+    (list 'scroll-to bool-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list int-example-list)
+    (list 'get-view void-example-list float?-example-list float?-example-list float?-example-list float?-example-list bool-example-list)
+    (list 'get-dc wxDC^-example-list float?-example-list float?-example-list)))
+(hash-table-put! classinfo wx:canvas-media-admin%
+  (list wxCanvasMediaAdmin!-example-list (quote wx:canvas-media-admin%)
+    (list)
+    (list 'get-canvas wxMediaCanvas!-example-list)))
+(hash-table-put! classinfo wx:media-snip-media-admin%
+  (list wxMediaSnipMediaAdmin!-example-list (quote wx:media-snip-media-admin%)
+    (list)
+    (list 'get-snip wxMediaSnip!-example-list)))
+(hash-table-put! classinfo wx:snip-admin%
+  (list wxSnipAdmin!-example-list (quote wx:snip-admin%)
+    (list
+      (list))
+    (list 'set-cursor void-example-list wxCursor!-example-list)
+    (list 'release-snip bool-example-list wxSnip!-example-list)
+    (list 'needs-update void-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'recounted bool-example-list wxSnip!-example-list bool-example-list)
+    (list 'resized void-example-list wxSnip!-example-list bool-example-list)
+    (list 'set-caret-owner void-example-list wxSnip!-example-list int-example-list)
+    (list 'scroll-to bool-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list int-example-list)
+    (list 'get-view void-example-list float?-example-list float?-example-list float?-example-list float?-example-list wxSnip^-example-list)
+    (list 'get-view-size void-example-list float?-example-list float?-example-list)
+    (list 'get-dc wxDC!-example-list)
+    (list 'get-media wxMediaBuffer^-example-list)))
+(hash-table-put! classinfo wx:snip-class%
+  (list wxSnipClass!-example-list (quote wx:snip-class%)
+    (list
+      (list))
+    (list 'write-done void-example-list)
+    (list 'write-header bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-done void-example-list)
+    (list 'read-header bool-example-list wxMediaStreamIn%-example-list)
+    (list 'read wxSnip^-example-list wxMediaStreamIn%-example-list)
+    (list 'get-classname string-example-list)
+    (list 'set-classname void-example-list string-example-list)
+    (list 'get-version int-example-list)
+    (list 'set-version void-example-list int-example-list)))
+(hash-table-put! classinfo wx:snip-class-list%
+  (list wxSnipClassList!-example-list (quote wx:snip-class-list%)
+    (list)
+    (list 'nth wxSnipClass^-example-list int-example-list)
+    (list 'number int-example-list)
+    (list 'add void-example-list wxSnipClass!-example-list)
+    (list 'find-position short-example-list wxSnipClass!-example-list)
+    (list 'find wxSnipClass^-example-list string-example-list)))
+(hash-table-put! classinfo wx:keymap%
+  (list wxKeymap!-example-list (quote wx:keymap%)
+    (list
+      (list))
+    (list 'remove-chained-keymap void-example-list wxKeymap!-example-list)
+    (list 'chain-to-keymap void-example-list wxKeymap!-example-list bool-example-list)
+    (list 'set-break-sequence-callback void-example-list wxBreakSequenceFunction-example-list)
+    (list 'set-error-callback void-example-list wxKeyErrorFunction-example-list)
+    (list 'call-function bool-example-list string-example-list wxObject!-example-list wxMouseEvent%-example-list bool-example-list)
+    (list 'call-function bool-example-list string-example-list wxObject!-example-list wxKeyEvent%-example-list bool-example-list)
+    (list 'remove-grab-mouse-function void-example-list)
+    (list 'set-grab-mouse-function void-example-list wxGrabMouseFunction-example-list)
+    (list 'add-mouse-function void-example-list string-example-list wxMouseFunction-example-list)
+    (list 'remove-grab-key-function void-example-list)
+    (list 'set-grab-key-function void-example-list wxGrabKeyFunction-example-list)
+    (list 'add-key-function void-example-list string-example-list wxKeyFunction-example-list)
+    (list 'implies-shift void-example-list string-example-list)
+    (list 'map-function void-example-list string-example-list string-example-list)
+    (list 'break-sequence void-example-list)
+    (list 'handle-mouse-event bool-example-list wxObject!-example-list wxMouseEvent%-example-list)
+    (list 'handle-key-event bool-example-list wxObject!-example-list wxKeyEvent%-example-list)
+    (list 'set-double-click-interval void-example-list long-example-list)
+    (list 'get-double-click-interval long-example-list)))
+(hash-table-put! classinfo wx:media-wordbreak-map%
+  (list wxMediaWordbreakMap!-example-list (quote wx:media-wordbreak-map%)
+    (list
+      (list))
+    (list 'is-used? bool-example-list)
+    (list 'adjust-usage void-example-list bool-example-list)
+    (list 'get-map int-example-list int-example-list)
+    (list 'set-map void-example-list int-example-list int-example-list)))
+(hash-table-put! classinfo wx:media-edit%
+  (list wxMediaEdit!-example-list (quote wx:media-edit%)
+    (list
+      (list float-example-list floatARRAY-example-list))
+    (list 'remove-clickback void-example-list long-example-list long-example-list)
+    (list 'set-clickback void-example-list long-example-list long-example-list wxClickbackFunc-example-list wxStyleDelta^-example-list bool-example-list)
+    (list 'set-wordbreak-func void-example-list wxWordbreakFunc-example-list)
+    (list 'set-autowrap-bitmap wxBitmap^-example-list wxBitmap^-example-list)
+    (list 'on-new-tab-snip wxTabSnip!-example-list)
+    (list 'on-new-text-snip wxTextSnip!-example-list)
+    (list 'caret-hidden? bool-example-list)
+    (list 'hide-caret void-example-list bool-example-list)
+    (list 'get-wordbreak-map wxMediaWordbreakMap^-example-list)
+    (list 'set-wordbreak-map void-example-list wxMediaWordbreakMap^-example-list)
+    (list 'find-wordbreak void-example-list long?-example-list long?-example-list int-example-list)
+    (list 'set-region-data void-example-list long-example-list long-example-list wxBufferData^-example-list)
+    (list 'get-region-data wxBufferData^-example-list long-example-list long-example-list)
+    (list 'after-set-size-constraint void-example-list)
+    (list 'on-set-size-constraint bool-example-list)
+    (list 'after-set-position void-example-list)
+    (list 'after-edit-sequence void-example-list)
+    (list 'on-edit-sequence void-example-list)
+    (list 'after-change-style void-example-list long-example-list long-example-list)
+    (list 'on-change-style bool-example-list long-example-list long-example-list)
+    (list 'after-delete void-example-list long-example-list long-example-list)
+    (list 'on-delete bool-example-list long-example-list long-example-list)
+    (list 'after-insert void-example-list long-example-list long-example-list)
+    (list 'on-insert bool-example-list long-example-list long-example-list)
+    (list 'add-editor-functions void-example-list wxKeymap!-example-list)
+    (list 'set-tabs void-example-list floatARRAY-example-list float-example-list bool-example-list)
+    (list 'get-tabs floatARRAY-example-list int?-example-list float?-example-list bool?-example-list)
+    (list 'set-overwrite-mode void-example-list bool-example-list)
+    (list 'get-overwrite-mode bool-example-list)
+    (list 'set-file-format void-example-list int-example-list)
+    (list 'get-file-format int-example-list)
+    (list 'write-to-file bool-example-list wxMediaStreamOut%-example-list long-example-list long-example-list)
+    (list 'read-from-file bool-example-list wxMediaStreamIn%-example-list long-example-list bool-example-list)
+    (list 'insert-file bool-example-list string-example-list int-example-list)
+    (list 'load-file bool-example-list nstring-example-list int-example-list)
+    (list 'get-character uchar-example-list long-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list bool-example-list)
+    (list 'get-snip-position long-example-list wxSnip!-example-list)
+    (list 'get-snip-position-and-location void-example-list wxSnip!-example-list long?-example-list float?-example-list float?-example-list)
+    (list 'find-snip wxSnip^-example-list long-example-list int-example-list long?-example-list)
+    (list 'find-string-all longARRAY-example-list string-example-list int-example-list long-example-list long-example-list bool-example-list bool-example-list)
+    (list 'find-string long-example-list string-example-list int-example-list long-example-list long-example-list bool-example-list bool-example-list)
+    (list 'last-paragraph long-example-list)
+    (list 'pargraph-end-line long-example-list long-example-list)
+    (list 'paragraph-start-line long-example-list long-example-list)
+    (list 'line-paragraph long-example-list long-example-list)
+    (list 'paragraph-end-position long-example-list long-example-list bool-example-list)
+    (list 'paragraph-start-position long-example-list long-example-list bool-example-list)
+    (list 'position-paragraph long-example-list long-example-list bool-example-list)
+    (list 'last-line long-example-list)
+    (list 'last-position long-example-list)
+    (list 'line-length long-example-list long-example-list)
+    (list 'line-end-position long-example-list long-example-list bool-example-list)
+    (list 'line-start-position long-example-list long-example-list bool-example-list)
+    (list 'line-location float-example-list long-example-list bool-example-list)
+    (list 'position-location void-example-list long-example-list float?-example-list float?-example-list bool-example-list bool-example-list bool-example-list)
+    (list 'position-line long-example-list long-example-list bool-example-list)
+    (list 'set-cursor void-example-list wxCursor^-example-list)
+    (list 'set-between-threshold void-example-list float-example-list)
+    (list 'get-between-threshold float-example-list)
+    (list 'find-position-in-line long-example-list long-example-list float-example-list bool?-example-list bool?-example-list float?-example-list)
+    (list 'find-line long-example-list float-example-list bool?-example-list)
+    (list 'find-position long-example-list float-example-list float-example-list bool?-example-list bool?-example-list float?-example-list)
+    (list 'split-snip void-example-list long-example-list)
+    (list 'change-style void-example-list wxStyle^-example-list long-example-list long-example-list)
+    (list 'change-style void-example-list wxStyleDelta^-example-list long-example-list long-example-list)
+    (list 'do-paste void-example-list long-example-list long-example-list)
+    (list 'do-copy void-example-list long-example-list long-example-list long-example-list bool-example-list)
+    (list 'kill void-example-list long-example-list long-example-list long-example-list)
+    (list 'paste-next void-example-list)
+    (list 'paste void-example-list long-example-list long-example-list long-example-list)
+    (list 'copy void-example-list bool-example-list long-example-list long-example-list long-example-list)
+    (list 'cut void-example-list bool-example-list long-example-list long-example-list long-example-list)
+    (list 'erase void-example-list)
+    (list 'delete void-example-list)
+    (list 'delete void-example-list long-example-list long-example-list bool-example-list)
+    (list 'insert void-example-list uchar-example-list long-example-list long-example-list)
+    (list 'insert void-example-list uchar-example-list)
+    (list 'insert void-example-list wxSnip!-example-list long-example-list long-example-list bool-example-list)
+    (list 'insert void-example-list long-example-list string-example-list)
+    (list 'insert void-example-list long-example-list string-example-list long-example-list long-example-list bool-example-list)
+    (list 'insert void-example-list string-example-list)
+    (list 'insert void-example-list string-example-list long-example-list long-example-list bool-example-list)
+    (list 'flash-off void-example-list)
+    (list 'flash-on void-example-list long-example-list long-example-list bool-example-list bool-example-list long-example-list)
+    (list 'get-anchor bool-example-list)
+    (list 'set-anchor void-example-list bool-example-list)
+    (list 'get-visible-line-range void-example-list long?-example-list long?-example-list)
+    (list 'get-visible-position-range void-example-list long?-example-list long?-example-list)
+    (list 'scroll-to-position bool-example-list long-example-list bool-example-list long-example-list int-example-list)
+    (list 'move-position void-example-list long-example-list bool-example-list int-example-list)
+    (list 'set-position-bias-scroll void-example-list int-example-list long-example-list long-example-list bool-example-list bool-example-list int-example-list)
+    (list 'set-position void-example-list long-example-list long-example-list bool-example-list bool-example-list int-example-list)
+    (list 'get-end-position long-example-list)
+    (list 'get-start-position long-example-list)
+    (list 'get-position void-example-list long?-example-list long?-example-list)
+    (list 'get-flattened-text string-example-list)
+    (list 'after-load-file void-example-list bool-example-list)
+    (list 'on-load-file bool-example-list string-example-list int-example-list)
+    (list 'after-save-file void-example-list bool-example-list)
+    (list 'on-save-file bool-example-list string-example-list int-example-list)
+    (list 'on-new-box wxSnip!-example-list int-example-list)
+    (list 'on-new-image-snip wxImageSnip!-example-list nstring-example-list long-example-list bool-example-list bool-example-list)
+    (list 'invalidate-bitmap-cache void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'on-paint void-example-list bool-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'write-footers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'write-headers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-footer-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'read-header-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'write-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-from-file bool-example-list wxMediaStreamIn%-example-list bool-example-list)
+    (list 'set-filename void-example-list string-example-list bool-example-list)
+    (list 'release-snip bool-example-list wxSnip!-example-list)
+    (list 'set-modified void-example-list bool-example-list)
+    (list 'set-snip-data void-example-list wxSnip!-example-list wxBufferData^-example-list)
+    (list 'get-snip-data wxBufferData^-example-list wxSnip!-example-list)
+    (list 'needs-update void-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'resized void-example-list wxSnip!-example-list bool-example-list)
+    (list 'set-caret-owner void-example-list wxSnip^-example-list int-example-list)
+    (list 'scroll-to bool-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-change void-example-list)
+    (list 'on-focus void-example-list bool-example-list)
+    (list 'on-default-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-default-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-local-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-local-event void-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'refresh void-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'kill void-example-list long-example-list)
+    (list 'paste void-example-list long-example-list)
+    (list 'copy void-example-list bool-example-list long-example-list)
+    (list 'cut void-example-list bool-example-list long-example-list)
+    (list 'insert void-example-list wxSnip!-example-list)
+    (list 'change-style void-example-list wxStyleDelta^-example-list)))
+(hash-table-put! classinfo wx:media-buffer%
+  (list wxMediaBuffer!-example-list (quote wx:media-buffer%)
+    (list)
+    (list 'dc-location-to-buffer-location void*-example-list double-example-list double-example-list)
+    (list 'buffer-location-to-dc-location void*-example-list double-example-list double-example-list)
+    (list 'set-inactive-caret-threshold void-example-list int-example-list)
+    (list 'get-inactive-caret-threshold int-example-list)
+    (list 'get-focus-snip wxSnip^-example-list)
+    (list 'end-write-header-footer-to-file bool-example-list wxMediaStreamOut%-example-list long-example-list)
+    (list 'begin-write-header-footer-to-file bool-example-list wxMediaStreamOut%-example-list string-example-list long*-example-list)
+    (list 'print void-example-list nstring-example-list bool-example-list bool-example-list int-example-list)
+    (list 'insert-image void-example-list nstring-example-list long-example-list bool-example-list bool-example-list)
+    (list 'insert-box void-example-list int-example-list)
+    (list 'get-filename nstring-example-list bool?-example-list)
+    (list 'modified? bool-example-list)
+    (list 'lock void-example-list bool-example-list)
+    (list 'get-load-overwrites-styles bool-example-list)
+    (list 'set-load-overwrites-styles void-example-list bool-example-list)
+    (list 'set-style-list void-example-list wxStyleList!-example-list)
+    (list 'get-style-list wxStyleList!-example-list)
+    (list 'add-buffer-functions void-example-list wxKeymap!-example-list)
+    (list 'get-keymap wxKeymap!-example-list)
+    (list 'set-keymap void-example-list wxKeymap^-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'append-font-items int-example-list wxMenu!-example-list int-example-list)
+    (list 'append-edit-items int-example-list wxMenu!-example-list int-example-list)
+    (list 'get-max-undo-history int-example-list)
+    (list 'set-max-undo-history void-example-list int-example-list)
+    (list 'clear-undos void-example-list)
+    (list 'redo void-example-list)
+    (list 'undo void-example-list)
+    (list 'select-all void-example-list)
+    (list 'clear void-example-list)
+    (list 'get-view-size void-example-list float?-example-list float?-example-list)
+    (list 'get-dc wxDC!-example-list)
+    (list 'local-to-global void-example-list float*-example-list float*-example-list)
+    (list 'global-to-local void-example-list float*-example-list float*-example-list)
+    (list 'set-admin void-example-list wxMediaAdmin^-example-list)
+    (list 'get-admin wxMediaAdmin^-example-list)
+    (list 'print-to-dc void-example-list wxDC!-example-list)
+    (list 'find-scroll-line long-example-list float-example-list)
+    (list 'num-scroll-lines long-example-list)
+    (list 'scroll-line-location float-example-list long-example-list)
+    (list 'get-snip-location bool-example-list wxSnip!-example-list float?-example-list float?-example-list bool-example-list)
+    (list 'end-edit-sequence void-example-list)
+    (list 'begin-edit-sequence void-example-list bool-example-list)
+    (list 'style-has-changed void-example-list wxStyle^-example-list)
+    (list 'write-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-from-file bool-example-list wxMediaStreamIn%-example-list)
+    (list 'set-min-height void-example-list float-example-list)
+    (list 'set-max-height void-example-list float-example-list)
+    (list 'get-min-height float-example-list)
+    (list 'get-max-height float-example-list)
+    (list 'set-min-width void-example-list float-example-list)
+    (list 'set-max-width void-example-list float-example-list)
+    (list 'get-min-width float-example-list)
+    (list 'get-max-width float-example-list)
+    (list 'get-space float-example-list)
+    (list 'get-descent float-example-list)
+    (list 'get-extent void-example-list float?-example-list float?-example-list)
+    (list 'copy-self wxMediaBuffer!-example-list)
+    (list 'get-flattened-text string-example-list)
+    (list 'after-load-file void-example-list bool-example-list)
+    (list 'on-load-file bool-example-list string-example-list int-example-list)
+    (list 'after-save-file void-example-list bool-example-list)
+    (list 'on-save-file bool-example-list string-example-list int-example-list)
+    (list 'on-new-box wxSnip!-example-list int-example-list)
+    (list 'on-new-image-snip wxImageSnip!-example-list nstring-example-list long-example-list bool-example-list bool-example-list)
+    (list 'invalidate-bitmap-cache void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'on-paint void-example-list bool-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'write-footers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'write-headers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-footer-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'read-header-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'write-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-from-file bool-example-list wxMediaStreamIn%-example-list bool-example-list)
+    (list 'set-filename void-example-list string-example-list bool-example-list)
+    (list 'release-snip bool-example-list wxSnip!-example-list)
+    (list 'set-modified void-example-list bool-example-list)
+    (list 'set-snip-data void-example-list wxSnip!-example-list wxBufferData^-example-list)
+    (list 'get-snip-data wxBufferData^-example-list wxSnip!-example-list)
+    (list 'needs-update void-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'resized void-example-list wxSnip!-example-list bool-example-list)
+    (list 'set-caret-owner void-example-list wxSnip^-example-list int-example-list)
+    (list 'scroll-to bool-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-change void-example-list)
+    (list 'on-focus void-example-list bool-example-list)
+    (list 'on-default-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-default-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-local-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-local-event void-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'refresh void-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'kill void-example-list long-example-list)
+    (list 'paste void-example-list long-example-list)
+    (list 'copy void-example-list bool-example-list long-example-list)
+    (list 'cut void-example-list bool-example-list long-example-list)
+    (list 'insert void-example-list wxSnip!-example-list)
+    (list 'change-style void-example-list wxStyleDelta^-example-list)
+    (list 'get-buffer-type int-example-list)
+    (list 'set-buffer-type void-example-list int-example-list)))
+(hash-table-put! classinfo 'wxMediaGlobal
+  (list #f (quote 'wxMediaGlobal)
+    (list)
+    (list 'wx:get-the-buffer-data-class-list wxBufferDataClassList!-example-list)
+    (list 'wx:get-the-snip-class-list wxSnipClassList!-example-list)
+    (list 'wx:media-set-x-selection-mode void-example-list bool-example-list)
+    (list 'wx:add-media-pasteboard-functions void-example-list wxKeymap!-example-list)
+    (list 'wx:add-media-editor-functions void-example-list wxKeymap!-example-list)
+    (list 'wx:add-media-buffer-functions void-example-list wxKeymap!-example-list)
+    (list 'wx:write-media-global-footer bool-example-list wxMediaStreamOut%-example-list)
+    (list 'wx:write-media-global-header bool-example-list wxMediaStreamOut%-example-list)
+    (list 'wx:read-media-global-footer bool-example-list wxMediaStreamIn%-example-list)
+    (list 'wx:read-media-global-header bool-example-list wxMediaStreamIn%-example-list)
+    (list 'wx:set-media-print-margin void-example-list long-example-list long-example-list)
+    (list 'wx:get-media-print-margin void-example-list long?-example-list long?-example-list)))
+(hash-table-put! classinfo wx:menu%
+  (list wxMenu!-example-list (quote wx:menu%)
+    (list
+      (list nstring-example-list wxFunction-example-list))
+    (list 'set-title void-example-list string-example-list)
+    (list 'set-label void-example-list int-example-list string-example-list)
+    (list 'set-help-string void-example-list int-example-list nstring-example-list)
+    (list 'get-title nstring-example-list)
+    (list 'get-label nstring-example-list int-example-list)
+    (list 'get-help-string nstring-example-list int-example-list)
+    (list 'find-item int-example-list string-example-list)
+    (list 'enable void-example-list int-example-list bool-example-list)
+    (list 'check void-example-list int-example-list bool-example-list)
+    (list 'checked? bool-example-list int-example-list)
+    (list 'append-separator void-example-list)
+    (list 'delete-by-position void-example-list int-example-list)
+    (list 'delete void-example-list int-example-list)
+    (list 'append void-example-list int-example-list string-example-list nstring-example-list bool-example-list)
+    (list 'append void-example-list int-example-list string-example-list wxMenu!-example-list nstring-example-list)))
+(hash-table-put! classinfo wx:menu-bar%
+  (list wxMenuBar!-example-list (quote wx:menu-bar%)
+    (list
+      (list)
+      (list wxMenu*ARRAY-example-list stringARRAY-example-list))
+    (list 'set-label-top void-example-list int-example-list string-example-list)
+    (list 'set-label void-example-list int-example-list string-example-list)
+    (list 'set-help-string void-example-list int-example-list nstring-example-list)
+    (list 'get-title nstring-example-list)
+    (list 'get-label-top nstring-example-list int-example-list)
+    (list 'get-label nstring-example-list int-example-list)
+    (list 'get-help-string nstring-example-list int-example-list)
+    (list 'find-menu-item int-example-list string-example-list string-example-list)
+    (list 'enable-top void-example-list int-example-list bool-example-list)
+    (list 'enable void-example-list int-example-list bool-example-list)
+    (list 'checked? bool-example-list int-example-list)
+    (list 'check void-example-list int-example-list bool-example-list)
+    (list 'delete void-example-list wxMenu!-example-list int-example-list)
+    (list 'append void-example-list wxMenu!-example-list string-example-list)))
+(hash-table-put! classinfo wx:media-stream-in-base%
+  (list wxMediaStreamInBase!-example-list (quote wx:media-stream-in-base%)
+    (list
+      (list))
+    (list 'read long-example-list charARRAY-example-list)
+    (list 'bad? bool-example-list)
+    (list 'skip void-example-list long-example-list)
+    (list 'seek void-example-list long-example-list)
+    (list 'tell long-example-list)))
+(hash-table-put! classinfo wx:media-stream-out-base%
+  (list wxMediaStreamOutBase!-example-list (quote wx:media-stream-out-base%)
+    (list
+      (list))
+    (list 'write void-example-list charARRAY-example-list)
+    (list 'bad? bool-example-list)
+    (list 'seek void-example-list long-example-list)
+    (list 'tell long-example-list)))
+(hash-table-put! classinfo wx:media-stream-in-string-base%
+  (list wxMediaStreamInStringBase!-example-list (quote wx:media-stream-in-string-base%)
+    (list
+      (list string-example-list))))
+(hash-table-put! classinfo wx:media-stream-out-string-base%
+  (list wxMediaStreamOutStringBase!-example-list (quote wx:media-stream-out-string-base%)
+    (list
+      (list))
+    (list 'get-string string-example-list)))
+(hash-table-put! classinfo wx:media-stream-in%
+  (list wxMediaStreamIn!-example-list (quote wx:media-stream-in%)
+    (list
+      (list wxMediaStreamInBase%-example-list))
+    (list 'ok? bool-example-list)
+    (list 'jump-to void-example-list long-example-list)
+    (list 'tell long-example-list)
+    (list 'skip void-example-list long-example-list)
+    (list 'remove-boundary void-example-list)
+    (list 'set-boundary void-example-list long-example-list)
+    (list '>> wxMediaStreamIn%-example-list Double+-example-list)
+    (list '>> wxMediaStreamIn%-example-list Long+-example-list)
+    (list 'get-inexact double-example-list)
+    (list 'get-exact long-example-list)
+    (list 'get-fixed wxMediaStreamIn%-example-list long+-example-list)
+    (list 'get-string nstring-example-list long?-example-list)
+    (list 'get wxMediaStreamIn%-example-list Double+-example-list)
+    (list 'get wxMediaStreamIn%-example-list Long+-example-list)))
+(hash-table-put! classinfo wx:media-stream-out%
+  (list wxMediaStreamOut!-example-list (quote wx:media-stream-out%)
+    (list
+      (list wxMediaStreamOutBase%-example-list))
+    (list 'ok? bool-example-list)
+    (list 'jump-to void-example-list long-example-list)
+    (list 'tell long-example-list)
+    (list '<< wxMediaStreamOut%-example-list Long-example-list)
+    (list '<< wxMediaStreamOut%-example-list Double-example-list)
+    (list '<< wxMediaStreamOut%-example-list string-example-list)
+    (list 'put-fixed wxMediaStreamOut%-example-list long-example-list)
+    (list 'put wxMediaStreamOut%-example-list Double-example-list)
+    (list 'put wxMediaStreamOut%-example-list Long-example-list)
+    (list 'put wxMediaStreamOut%-example-list string-example-list)
+    (list 'put wxMediaStreamOut%-example-list long-example-list string-example-list)))
+(hash-table-put! classinfo wx:meta-file%
+  (list baseMetaFile!-example-list (quote wx:meta-file%)
+    (list)
+    (list 'set-clipboard bool-example-list int-example-list int-example-list)
+    (list 'play void-example-list wxDC!-example-list)
+    (list 'ok? bool-example-list)))
+(hash-table-put! classinfo wx:timer%
+  (list wxTimer!-example-list (quote wx:timer%)
+    (list
+      (list))
+    (list 'stop void-example-list)
+    (list 'start bool-example-list int-example-list bool-example-list)
+    (list 'notify void-example-list)
+    (list 'interval int-example-list)))
+(hash-table-put! classinfo wx:clipboard%
+  (list wxClipboard!-example-list (quote wx:clipboard%)
+    (list)
+    (list 'get-clipboard-data nstring-example-list string-example-list long-example-list)
+    (list 'get-clipboard-string nstring-example-list long-example-list)
+    (list 'get-clipboard-client wxClipboardClient^-example-list)
+    (list 'set-clipboard-string void-example-list string-example-list long-example-list)
+    (list 'set-clipboard-client void-example-list wxClipboardClient!-example-list long-example-list)))
+(hash-table-put! classinfo wx:clipboard-client%
+  (list wxClipboardClient!-example-list (quote wx:clipboard-client%)
+    (list
+      (list))
+    (list 'get-types Scheme_Object*-example-list)
+    (list 'add-type void-example-list string-example-list)
+    (list 'get-data nstring-example-list string-example-list)
+    (list 'being-replaced void-example-list)))
+(hash-table-put! classinfo wx:media-pasteboard%
+  (list wxMediaPasteboard!-example-list (quote wx:media-pasteboard%)
+    (list
+      (list))
+    (list 'set-scroll-step void-example-list float-example-list)
+    (list 'get-scroll-step float-example-list)
+    (list 'set-selection-visible void-example-list bool-example-list)
+    (list 'get-selection-visible bool-example-list)
+    (list 'set-dragable void-example-list bool-example-list)
+    (list 'get-dragable bool-example-list)
+    (list 'after-interactive-resize void-example-list wxSnip!-example-list)
+    (list 'on-interactive-resize bool-example-list wxSnip!-example-list)
+    (list 'after-interactive-move void-example-list)
+    (list 'on-interactive-move bool-example-list)
+    (list 'interactive-adjust-resize void-example-list wxSnip!-example-list float*-example-list float*-example-list)
+    (list 'interactive-adjust-move void-example-list wxSnip!-example-list float*-example-list float*-example-list)
+    (list 'interactive-adjust-mouse void-example-list float*-example-list float*-example-list)
+    (list 'on-double-click void-example-list wxSnip!-example-list wxMouseEvent%-example-list)
+    (list 'after-select void-example-list wxSnip!-example-list bool-example-list)
+    (list 'on-select bool-example-list wxSnip!-example-list bool-example-list)
+    (list 'after-resize void-example-list wxSnip!-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-resize bool-example-list wxSnip!-example-list float-example-list float-example-list)
+    (list 'after-move-to void-example-list wxSnip!-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-move-to bool-example-list wxSnip!-example-list float-example-list float-example-list bool-example-list)
+    (list 'after-delete void-example-list wxSnip!-example-list)
+    (list 'on-delete bool-example-list wxSnip!-example-list)
+    (list 'after-insert void-example-list wxSnip!-example-list wxSnip^-example-list float-example-list float-example-list)
+    (list 'on-insert bool-example-list wxSnip!-example-list wxSnip^-example-list float-example-list float-example-list)
+    (list 'find-next-selected-snip wxSnip^-example-list wxSnip^-example-list)
+    (list 'is-selected? bool-example-list wxSnip^-example-list)
+    (list 'find-first-snip wxSnip^-example-list)
+    (list 'find-snip wxSnip^-example-list float-example-list float-example-list)
+    (list 'add-pasteboard-functions void-example-list wxKeymap!-example-list)
+    (list 'get-center void-example-list float*-example-list float*-example-list)
+    (list 'remove-selected void-example-list wxSnip!-example-list)
+    (list 'no-selected void-example-list)
+    (list 'add-selected void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'add-selected void-example-list wxSnip!-example-list)
+    (list 'set-selected void-example-list wxSnip!-example-list)
+    (list 'change-style void-example-list wxStyle^-example-list wxSnip^-example-list)
+    (list 'change-style void-example-list wxStyleDelta^-example-list wxSnip^-example-list)
+    (list 'set-after void-example-list wxSnip!-example-list wxSnip^-example-list)
+    (list 'set-before void-example-list wxSnip!-example-list wxSnip^-example-list)
+    (list 'lower void-example-list wxSnip!-example-list)
+    (list 'raise void-example-list wxSnip!-example-list)
+    (list 'load-file bool-example-list nstring-example-list)
+    (list 'resize bool-example-list wxSnip!-example-list float-example-list float-example-list)
+    (list 'move void-example-list float-example-list float-example-list)
+    (list 'move void-example-list wxSnip!-example-list float-example-list float-example-list)
+    (list 'move-to void-example-list wxSnip!-example-list float-example-list float-example-list)
+    (list 'remove void-example-list wxSnip!-example-list)
+    (list 'erase void-example-list)
+    (list 'do-paste void-example-list long-example-list)
+    (list 'do-copy void-example-list long-example-list bool-example-list)
+    (list 'delete void-example-list wxSnip!-example-list)
+    (list 'delete void-example-list)
+    (list 'insert void-example-list wxSnip!-example-list wxSnip^-example-list float-example-list float-example-list)
+    (list 'insert void-example-list wxSnip!-example-list wxSnip^-example-list)
+    (list 'insert void-example-list wxSnip!-example-list float-example-list float-example-list)
+    (list 'get-flattened-text string-example-list)
+    (list 'after-load-file void-example-list bool-example-list)
+    (list 'on-load-file bool-example-list string-example-list int-example-list)
+    (list 'after-save-file void-example-list bool-example-list)
+    (list 'on-save-file bool-example-list string-example-list int-example-list)
+    (list 'on-new-box wxSnip!-example-list int-example-list)
+    (list 'on-new-image-snip wxImageSnip!-example-list nstring-example-list long-example-list bool-example-list bool-example-list)
+    (list 'invalidate-bitmap-cache void-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'on-paint void-example-list bool-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'write-footers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'write-headers-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-footer-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'read-header-from-file bool-example-list wxMediaStreamIn%-example-list string-example-list)
+    (list 'write-to-file bool-example-list wxMediaStreamOut%-example-list)
+    (list 'read-from-file bool-example-list wxMediaStreamIn%-example-list bool-example-list)
+    (list 'set-filename void-example-list string-example-list bool-example-list)
+    (list 'release-snip bool-example-list wxSnip!-example-list)
+    (list 'set-modified void-example-list bool-example-list)
+    (list 'set-snip-data void-example-list wxSnip!-example-list wxBufferData^-example-list)
+    (list 'get-snip-data wxBufferData^-example-list wxSnip!-example-list)
+    (list 'needs-update void-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list)
+    (list 'resized void-example-list wxSnip!-example-list bool-example-list)
+    (list 'set-caret-owner void-example-list wxSnip^-example-list int-example-list)
+    (list 'scroll-to bool-example-list wxSnip!-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-change void-example-list)
+    (list 'on-focus void-example-list bool-example-list)
+    (list 'on-default-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-default-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-local-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-local-event void-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'refresh void-example-list float-example-list float-example-list float-example-list float-example-list bool-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'kill void-example-list long-example-list)
+    (list 'paste void-example-list long-example-list)
+    (list 'copy void-example-list bool-example-list long-example-list)
+    (list 'cut void-example-list bool-example-list long-example-list)
+    (list 'insert void-example-list wxSnip!-example-list)
+    (list 'change-style void-example-list wxStyleDelta^-example-list)))
+(hash-table-put! classinfo wx:object%
+  (list wxObject!-example-list (quote wx:object%)
+    (list
+      (list))))
+(hash-table-put! classinfo wx:panel%
+  (list wxPanel!-example-list (quote wx:panel%)
+    (list
+      (list wxFrame!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'get-child wxObject!-example-list int-example-list)
+    (list 'advance-cursor void-example-list wxWindow!-example-list)
+    (list 'tab void-example-list int-example-list)
+    (list 'tab void-example-list)
+    (list 'set-background-colour void-example-list wxColour!-example-list)
+    (list 'get-background-colour wxColour!-example-list)
+    (list 'set-label-colour void-example-list wxColour!-example-list)
+    (list 'get-label-colour wxColour!-example-list)
+    (list 'set-button-colour void-example-list wxColour!-example-list)
+    (list 'get-button-colour wxColour!-example-list)
+    (list 'get-label-font wxFont!-example-list)
+    (list 'set-label-font void-example-list wxFont!-example-list)
+    (list 'get-button-font wxFont!-example-list)
+    (list 'set-button-font void-example-list wxFont!-example-list)
+    (list 'get-panel-dc wxDC!-example-list)
+    (list 'new-line void-example-list int-example-list)
+    (list 'new-line void-example-list)
+    (list 'set-vertical-spacing void-example-list int-example-list)
+    (list 'set-horizontal-spacing void-example-list int-example-list)
+    (list 'get-vertical-spacing int-example-list)
+    (list 'get-horizontal-spacing int-example-list)
+    (list 'set-label-position void-example-list int-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-paint void-example-list)
+    (list 'on-default-action void-example-list wxItem!-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-paint void-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'set-item-cursor void-example-list int-example-list int-example-list)
+    (list 'get-item-cursor void-example-list int*-example-list int*-example-list)
+    (list 'get-default-item wxButton!-example-list)
+    (list 'fit void-example-list)))
+(hash-table-put! classinfo wx:dialog-box%
+  (list wxDialogBox!-example-list (quote wx:dialog-box%)
+    (list
+      (list wxWindow^-example-list nstring-example-list bool-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'on-default-action void-example-list wxItem!-example-list)
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxMouseEvent%-example-list)
+    (list 'on-paint void-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'on-close bool-example-list)
+    (list 'on-activate void-example-list bool-example-list)))
+(hash-table-put! classinfo wx:radio-box%
+  (list wxRadioBox!-example-list (quote wx:radio-box%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list int-example-list int-example-list int-example-list int-example-list stringARRAY-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list int-example-list int-example-list int-example-list int-example-list wxBitmap*ARRAY-example-list int-example-list long-example-list string-example-list))
+    (list 'enable void-example-list bool-example-list)
+    (list 'enable void-example-list int-example-list bool-example-list)
+    (list 'get-string string-example-list int-example-list)
+    (list 'set-selection void-example-list int-example-list)
+    (list 'set-string-selection void-example-list string-example-list)
+    (list 'number int-example-list)
+    (list 'get-string-selection nstring-example-list)
+    (list 'get-selection int-example-list)
+    (list 'find-string int-example-list string-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:slider%
+  (list wxSlider!-example-list (quote wx:slider%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'set-value void-example-list int-example-list)
+    (list 'get-value int-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:snip%
+  (list wxSnip!-example-list (quote wx:snip%)
+    (list
+      (list))
+    (list 'previous wxSnip^-example-list)
+    (list 'next wxSnip^-example-list)
+    (list 'set-admin void-example-list wxSnipAdmin^-example-list)
+    (list 'resize bool-example-list float-example-list float-example-list)
+    (list 'write void-example-list wxMediaStreamOut%-example-list)
+    (list 'match? bool-example-list wxSnip!-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'on-char void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'copy wxSnip!-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list)
+    (list 'merge-with wxSnip!-example-list wxSnip!-example-list)
+    (list 'split void-example-list long-example-list wxSnip!*-example-list wxSnip!*-example-list)
+    (list 'draw void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'partial-offset float-example-list wxDC!-example-list float-example-list float-example-list long-example-list)
+    (list 'get-extent void-example-list wxDC!-example-list float-example-list float-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list)
+    (list 'release-from-owner bool-example-list)
+    (list 'is-owned? bool-example-list)
+    (list 'set-style void-example-list wxStyle!-example-list)
+    (list 'set-flags void-example-list long-example-list)
+    (list 'set-count void-example-list long-example-list)
+    (list 'get-admin wxSnipAdmin!-example-list)
+    (list 'get-count long-example-list)
+    (list 'get-flags long-example-list)
+    (list 'get-style wxStyle!-example-list)
+    (list 'get-snipclass wxSnipClass^-example-list)
+    (list 'set-snipclass void-example-list wxSnipClass^-example-list)))
+(hash-table-put! classinfo wx:text-snip%
+  (list wxTextSnip!-example-list (quote wx:text-snip%)
+    (list
+      (list long-example-list))
+    (list 'read void-example-list long-example-list wxMediaStreamIn%-example-list)
+    (list 'insert void-example-list string-example-list long-example-list long-example-list)
+    (list 'set-admin void-example-list wxSnipAdmin^-example-list)
+    (list 'resize bool-example-list float-example-list float-example-list)
+    (list 'write void-example-list wxMediaStreamOut%-example-list)
+    (list 'match? bool-example-list wxSnip!-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'on-char void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'copy wxSnip!-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list)
+    (list 'merge-with wxSnip!-example-list wxSnip!-example-list)
+    (list 'split void-example-list long-example-list wxSnip!*-example-list wxSnip!*-example-list)
+    (list 'draw void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'partial-offset float-example-list wxDC!-example-list float-example-list float-example-list long-example-list)
+    (list 'get-extent void-example-list wxDC!-example-list float-example-list float-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list)))
+(hash-table-put! classinfo wx:tab-snip%
+  (list wxTabSnip!-example-list (quote wx:tab-snip%)
+    (list
+      (list))
+    (list 'set-admin void-example-list wxSnipAdmin^-example-list)
+    (list 'resize bool-example-list float-example-list float-example-list)
+    (list 'write void-example-list wxMediaStreamOut%-example-list)
+    (list 'match? bool-example-list wxSnip!-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'on-char void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'copy wxSnip!-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list)
+    (list 'merge-with wxSnip!-example-list wxSnip!-example-list)
+    (list 'split void-example-list long-example-list wxSnip!*-example-list wxSnip!*-example-list)
+    (list 'draw void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'partial-offset float-example-list wxDC!-example-list float-example-list float-example-list long-example-list)
+    (list 'get-extent void-example-list wxDC!-example-list float-example-list float-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list)))
+(hash-table-put! classinfo wx:image-snip%
+  (list wxImageSnip!-example-list (quote wx:image-snip%)
+    (list
+      (list nstring-example-list long-example-list bool-example-list bool-example-list))
+    (list 'set-offset void-example-list float-example-list float-example-list)
+    (list 'set-bitmap void-example-list wxBitmap!-example-list)
+    (list 'get-filetype long-example-list)
+    (list 'get-filename nstring-example-list bool?-example-list)
+    (list 'load-file void-example-list nstring-example-list long-example-list bool-example-list bool-example-list)
+    (list 'set-admin void-example-list wxSnipAdmin^-example-list)
+    (list 'resize bool-example-list float-example-list float-example-list)
+    (list 'write void-example-list wxMediaStreamOut%-example-list)
+    (list 'match? bool-example-list wxSnip!-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'on-char void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'copy wxSnip!-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list)
+    (list 'merge-with wxSnip!-example-list wxSnip!-example-list)
+    (list 'split void-example-list long-example-list wxSnip!*-example-list wxSnip!*-example-list)
+    (list 'draw void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'partial-offset float-example-list wxDC!-example-list float-example-list float-example-list long-example-list)
+    (list 'get-extent void-example-list wxDC!-example-list float-example-list float-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list)))
+(hash-table-put! classinfo wx:media-snip%
+  (list wxMediaSnip!-example-list (quote wx:media-snip%)
+    (list
+      (list wxMediaBuffer^-example-list bool-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list int-example-list))
+    (list 'get-inset void-example-list int*-example-list int*-example-list int*-example-list int*-example-list)
+    (list 'set-inset void-example-list int-example-list int-example-list int-example-list int-example-list)
+    (list 'get-margin void-example-list int*-example-list int*-example-list int*-example-list int*-example-list)
+    (list 'set-margin void-example-list int-example-list int-example-list int-example-list int-example-list)
+    (list 'border-visible? bool-example-list)
+    (list 'show-border void-example-list bool-example-list)
+    (list 'get-min-height float-example-list)
+    (list 'get-min-width float-example-list)
+    (list 'set-min-height void-example-list float-example-list)
+    (list 'set-min-width void-example-list float-example-list)
+    (list 'get-max-height float-example-list)
+    (list 'get-max-width float-example-list)
+    (list 'set-max-height void-example-list float-example-list)
+    (list 'set-max-width void-example-list float-example-list)
+    (list 'set-admin void-example-list wxSnipAdmin^-example-list)
+    (list 'resize bool-example-list float-example-list float-example-list)
+    (list 'write void-example-list wxMediaStreamOut%-example-list)
+    (list 'match? bool-example-list wxSnip!-example-list)
+    (list 'do-font void-example-list int-example-list bool-example-list)
+    (list 'do-edit void-example-list int-example-list bool-example-list long-example-list)
+    (list 'own-caret void-example-list bool-example-list)
+    (list 'on-char void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxKeyEvent%-example-list)
+    (list 'on-event void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list wxMouseEvent%-example-list)
+    (list 'size-cache-invalid void-example-list)
+    (list 'copy wxSnip!-example-list)
+    (list 'get-text string-example-list long-example-list long-example-list bool-example-list)
+    (list 'merge-with wxSnip!-example-list wxSnip!-example-list)
+    (list 'split void-example-list long-example-list wxSnip!*-example-list wxSnip!*-example-list)
+    (list 'draw void-example-list wxDC!-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list float-example-list int-example-list)
+    (list 'partial-offset float-example-list wxDC!-example-list float-example-list float-example-list long-example-list)
+    (list 'get-extent void-example-list wxDC!-example-list float-example-list float-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list float?-example-list)
+    (list 'set-media void-example-list wxMediaBuffer^-example-list)
+    (list 'get-media wxMediaBuffer^-example-list)
+    (list 'get-this-media wxMediaBuffer^-example-list)))
+(hash-table-put! classinfo wx:buffer-data-class%
+  (list wxBufferDataClass!-example-list (quote wx:buffer-data-class%)
+    (list
+      (list))
+    (list 'read wxBufferData^-example-list wxMediaStreamIn%-example-list)
+    (list 'get-classname string-example-list)
+    (list 'set-classname void-example-list string-example-list)
+    (list 'get-required bool-example-list)
+    (list 'set-required void-example-list bool-example-list)))
+(hash-table-put! classinfo wx:buffer-data-class-list%
+  (list wxBufferDataClassList!-example-list (quote wx:buffer-data-class-list%)
+    (list
+      (list))
+    (list 'nth wxBufferDataClass^-example-list int-example-list)
+    (list 'number int-example-list)
+    (list 'add void-example-list wxBufferDataClass!-example-list)
+    (list 'find-position short-example-list wxBufferDataClass!-example-list)
+    (list 'find wxBufferDataClass^-example-list string-example-list)))
+(hash-table-put! classinfo wx:buffer-data%
+  (list wxBufferData!-example-list (quote wx:buffer-data%)
+    (list
+      (list))
+    (list 'write bool-example-list wxMediaStreamOut%-example-list)
+    (list 'get-dataclass wxBufferDataClass^-example-list)
+    (list 'set-dataclass void-example-list wxBufferDataClass^-example-list)
+    (list 'get-next wxBufferData^-example-list)
+    (list 'set-next void-example-list wxBufferData^-example-list)))
+(hash-table-put! classinfo wx:mult-colour%
+  (list wxMultColour!-example-list (quote wx:mult-colour%)
+    (list)
+    (list 'set void-example-list float-example-list float-example-list float-example-list)
+    (list 'get void-example-list float*-example-list float*-example-list float*-example-list)
+    (list 'get-r float-example-list)
+    (list 'set-r void-example-list float-example-list)
+    (list 'get-g float-example-list)
+    (list 'set-g void-example-list float-example-list)
+    (list 'get-b float-example-list)
+    (list 'set-b void-example-list float-example-list)))
+(hash-table-put! classinfo wx:add-colour%
+  (list wxAddColour!-example-list (quote wx:add-colour%)
+    (list)
+    (list 'set void-example-list short-example-list short-example-list short-example-list)
+    (list 'get void-example-list short*-example-list short*-example-list short*-example-list)
+    (list 'get-r short-example-list)
+    (list 'set-r void-example-list short-example-list)
+    (list 'get-g short-example-list)
+    (list 'set-g void-example-list short-example-list)
+    (list 'get-b short-example-list)
+    (list 'set-b void-example-list short-example-list)))
+(hash-table-put! classinfo wx:style-delta%
+  (list wxStyleDelta!-example-list (quote wx:style-delta%)
+    (list
+      (list int-example-list int-example-list))
+    (list 'copy void-example-list wxStyleDelta!-example-list)
+    (list 'collapse bool-example-list wxStyleDelta%-example-list)
+    (list 'equal? bool-example-list wxStyleDelta%-example-list)
+    (list 'set-delta-foreground wxStyleDelta!-example-list wxColour%-example-list)
+    (list 'set-delta-foreground wxStyleDelta!-example-list string-example-list)
+    (list 'set-delta-background wxStyleDelta!-example-list wxColour%-example-list)
+    (list 'set-delta-background wxStyleDelta!-example-list string-example-list)
+    (list 'set-delta-face wxStyleDelta!-example-list string-example-list)
+    (list 'set-delta wxStyleDelta!-example-list int-example-list int-example-list)
+    (list 'get-family int-example-list)
+    (list 'set-family void-example-list int-example-list)
+    (list 'get-face nstring-example-list)
+    (list 'set-face void-example-list nstring-example-list)
+    (list 'get-size-mult float-example-list)
+    (list 'set-size-mult void-example-list float-example-list)
+    (list 'get-size-add int-example-list)
+    (list 'set-size-add void-example-list int-example-list)
+    (list 'get-weight-on int-example-list)
+    (list 'set-weight-on void-example-list int-example-list)
+    (list 'get-weight-off int-example-list)
+    (list 'set-weight-off void-example-list int-example-list)
+    (list 'get-style-on int-example-list)
+    (list 'set-style-on void-example-list int-example-list)
+    (list 'get-style-off int-example-list)
+    (list 'set-style-off void-example-list int-example-list)
+    (list 'get-underlined-on bool-example-list)
+    (list 'set-underlined-on void-example-list bool-example-list)
+    (list 'get-underlined-off bool-example-list)
+    (list 'set-underlined-off void-example-list bool-example-list)
+    (list 'get-transparent-text-backing-on bool-example-list)
+    (list 'set-transparent-text-backing-on void-example-list bool-example-list)
+    (list 'get-transparent-text-backing-off bool-example-list)
+    (list 'set-transparent-text-backing-off void-example-list bool-example-list)
+    (list 'get-foreground-mult wxMultColour%-example-list)
+    (list 'get-background-mult wxMultColour%-example-list)
+    (list 'get-foreground-add wxAddColour%-example-list)
+    (list 'get-background-add wxAddColour%-example-list)
+    (list 'get-alignment-on int-example-list)
+    (list 'set-alignment-on void-example-list int-example-list)
+    (list 'get-alignment-off int-example-list)
+    (list 'set-alignment-off void-example-list int-example-list)))
+(hash-table-put! classinfo wx:style%
+  (list wxStyle!-example-list (quote wx:style%)
+    (list)
+    (list 'switch-to void-example-list wxDC!-example-list wxStyle!-example-list)
+    (list 'set-shift-style void-example-list wxStyle!-example-list)
+    (list 'get-shift-style wxStyle!-example-list)
+    (list 'is-join? bool-example-list)
+    (list 'set-delta void-example-list wxStyleDelta%-example-list)
+    (list 'get-delta void-example-list wxStyleDelta%-example-list)
+    (list 'set-base-style void-example-list wxStyle!-example-list)
+    (list 'get-base-style wxStyle!-example-list)
+    (list 'get-transparent-text-backing bool-example-list)
+    (list 'get-alignment int-example-list)
+    (list 'get-colour wxColour%-example-list)
+    (list 'get-foreground wxColour%-example-list)
+    (list 'get-font wxFont!-example-list)
+    (list 'get-underlined bool-example-list)
+    (list 'get-style int-example-list)
+    (list 'get-weight int-example-list)
+    (list 'get-size int-example-list)
+    (list 'get-face nstring-example-list)
+    (list 'get-family int-example-list)
+    (list 'get-name string-example-list)))
+(hash-table-put! classinfo wx:style-list%
+  (list wxStyleList!-example-list (quote wx:style-list%)
+    (list
+      (list))
+    (list 'is-used?  bool-example-list)
+    (list 'adjust-usage void-example-list bool-example-list)
+    (list 'style-to-index int-example-list wxStyle!-example-list)
+    (list 'index-to-style wxStyle^-example-list int-example-list)
+    (list 'convert wxStyle!-example-list wxStyle!-example-list)
+    (list 'replace-named-style wxStyle!-example-list string-example-list wxStyle^-example-list)
+    (list 'new-named-style wxStyle!-example-list string-example-list wxStyle^-example-list)
+    (list 'find-named-style wxStyle!-example-list string-example-list)
+    (list 'find-or-create-join-style wxStyle!-example-list wxStyle^-example-list wxStyle!-example-list)
+    (list 'find-or-create-style wxStyle!-example-list wxStyle^-example-list wxStyleDelta!-example-list)
+    (list 'number int-example-list)
+    (list 'basic-style wxStyle!-example-list)
+    (list 'copy void-example-list wxStyleList!-example-list)
+    (list 'clear void-example-list)))
+(hash-table-put! classinfo wx:text%
+  (list wxText!-example-list (quote wx:text%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list string-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'set-editable void-example-list bool-example-list)
+    (list 'paste void-example-list)
+    (list 'cut void-example-list)
+    (list 'copy void-example-list)
+    (list 'set-value void-example-list string-example-list)
+    (list 'get-value string-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)))
+(hash-table-put! classinfo wx:multi-text%
+  (list wxMultiText!-example-list (quote wx:multi-text%)
+    (list
+      (list wxPanel!-example-list wxFunction-example-list nstring-example-list string-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'get-value string-example-list)))
+(hash-table-put! classinfo wx:text-window%
+  (list wxTextWindow!-example-list (quote wx:text-window%)
+    (list
+      (list wxFrame!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list)
+      (list wxPanel!-example-list int-example-list int-example-list int-example-list int-example-list long-example-list string-example-list))
+    (list 'on-char void-example-list wxKeyEvent%-example-list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'write-text void-example-list string-example-list)
+    (list 'show-position void-example-list long-example-list)
+    (list 'set-insertion-point-end void-example-list)
+    (list 'set-insertion-point void-example-list long-example-list)
+    (list 'set-font void-example-list wxFont!-example-list)
+    (list 'replace void-example-list long-example-list long-example-list string-example-list)
+    (list 'remove void-example-list long-example-list long-example-list)
+    (list 'x-y-to-position long-example-list long-example-list long-example-list)
+    (list 'position-to-x-y void-example-list long-example-list long*-example-list long*-example-list)
+    (list 'modified? bool-example-list)
+    (list 'load-file bool-example-list pathname-example-list)
+    (list 'set-selection void-example-list long-example-list long-example-list)
+    (list 'get-number-of-lines int-example-list)
+    (list 'get-line-length long-example-list int-example-list)
+    (list 'get-last-position long-example-list)
+    (list 'get-insertion-point long-example-list)
+    (list 'get-contents string-example-list)
+    (list 'discard-edits void-example-list)
+    (list 'paste void-example-list)
+    (list 'cut void-example-list)
+    (list 'copy void-example-list)
+    (list 'clear void-example-list)
+    (list 'popup-menu bool-example-list wxMenu!-example-list float-example-list float-example-list)))
+(hash-table-put! classinfo wx:window%
+  (list wxWindow!-example-list (quote wx:window%)
+    (list)
+    (list 'pre-on-event bool-example-list wxWindow!-example-list wxMouseEvent!-example-list)
+    (list 'pre-on-char bool-example-list wxWindow!-example-list wxKeyEvent!-example-list)
+    (list 'on-size void-example-list int-example-list int-example-list)
+    (list 'on-set-focus void-example-list)
+    (list 'on-kill-focus void-example-list)
+    (list 'get-y int-example-list)
+    (list 'get-x int-example-list)
+    (list 'get-width int-example-list)
+    (list 'get-height int-example-list)
+    (list 'center void-example-list int-example-list)
+    (list 'get-label string-example-list)
+    (list 'get-grand-parent wxWindow^-example-list)
+    (list 'get-text-extent void-example-list string-example-list float*-example-list float*-example-list float?-example-list float?-example-list wxFont^-example-list bool-example-list)
+    (list 'get-parent wxWindow^-example-list)
+    (list 'refresh void-example-list)
+    (list 'screen-to-client void-example-list int*-example-list int*-example-list)
+    (list 'client-to-screen void-example-list int*-example-list int*-example-list)
+    (list 'get-char-width float-example-list)
+    (list 'get-char-height float-example-list)
+    (list 'get-name nstring-example-list)
+    (list 'enable void-example-list bool-example-list)
+    (list 'get-position void-example-list int*-example-list int*-example-list)
+    (list 'get-client-size void-example-list int*-example-list int*-example-list)
+    (list 'get-size void-example-list int*-example-list int*-example-list)
+    (list 'fit void-example-list)
+    (list 'is-shown? bool-example-list)
+    (list 'show void-example-list bool-example-list)
+    (list 'set-cursor wxCursor^-example-list wxCursor!-example-list)
+    (list 'move void-example-list int-example-list int-example-list)
+    (list 'set-size void-example-list int-example-list int-example-list int-example-list int-example-list int-example-list)
+    (list 'set-focus void-example-list)
+    (list 'centre void-example-list int-example-list)))
+
+(define classes
+  (list
+    'wxEventGlobal
+    'wxMediaGlobal
+    'wxsGlobal
+    wx:add-colour%
+    wx:bitmap%
+    wx:brush%
+    wx:brush-list%
+    wx:buffer-data%
+    wx:buffer-data-class%
+    wx:buffer-data-class-list%
+    wx:button%
+    wx:canvas%
+    wx:canvas-dc%
+    wx:canvas-media-admin%
+    wx:check-box%
+    wx:choice%
+    wx:clipboard%
+    wx:clipboard-client%
+    wx:colour%
+    wx:colour-database%
+    wx:colour-map%
+    wx:command-event%
+    wx:cursor%
+    wx:dc%
+    wx:dialog-box%
+    wx:event%
+    wx:font%
+    wx:font-list%
+    wx:font-name-directory%
+    wx:frame%
+    wx:gauge%
+    wx:icon%
+    wx:image-snip%
+    wx:int-point%
+    wx:item%
+    wx:key-event%
+    wx:keymap%
+    wx:list-box%
+    wx:media-admin%
+    wx:media-buffer%
+    wx:media-canvas%
+    wx:media-edit%
+    wx:media-pasteboard%
+    wx:media-snip%
+    wx:media-snip-media-admin%
+    wx:media-stream-in%
+    wx:media-stream-in-base%
+    wx:media-stream-in-string-base%
+    wx:media-stream-out%
+    wx:media-stream-out-base%
+    wx:media-stream-out-string-base%
+    wx:media-wordbreak-map%
+    wx:memory-dc%
+    wx:menu%
+    wx:menu-bar%
+    wx:message%
+    wx:meta-file%
+    wx:meta-file-dc%
+    wx:mouse-event%
+    wx:mult-colour%
+    wx:multi-text%
+    wx:object%
+    wx:panel%
+    wx:pen%
+    wx:pen-list%
+    wx:point%
+    wx:post-script-dc%
+    wx:printer-dc%
+    wx:radio-box%
+    wx:slider%
+    wx:snip%
+    wx:snip-admin%
+    wx:snip-class%
+    wx:snip-class-list%
+    wx:style%
+    wx:style-delta%
+    wx:style-list%
+    wx:tab-snip%
+    wx:text%
+    wx:text-snip%
+    wx:text-window%
+    wx:timer%
+    wx:window%))
+
diff --git a/collects/tests/mzscheme/README b/collects/tests/mzscheme/README
new file mode 100644
index 0000000..d3a818a
--- /dev/null
+++ b/collects/tests/mzscheme/README
@@ -0,0 +1,45 @@
+
+To run all of the tests, run:
+ > (load "PATHTOHEREall.ss")
+where PATHTOHERE is the path to this directory.  
+
+Test failures may cause the test to stop before finishing, but most
+test failures will let the test continue, and a summary message at the
+end will enummerate the failures that occurred.
+
+Some files are directories are created (in the current directory)
+during the run. The files are named "tmp<N>" where <N> is a number.
+The directory is named "deep". If the test suite passes, the directory
+should be removed, but some "tmp<N>" files will remain. (The "tmp<N>"
+files are automatically replaced if the test suite is run again.)
+
+Unless your machine clock is always exactly in sync with your disk,
+don't worry about failures that look like this:
+  ((path) (#f #t (#<|primitive:<=|> 11 39 11)))
+  ((path) (#f #t (#<|primitive:<=|> 11 39 11)))
+  ((path) (#f #t (#<|primitive:<=|> 11 39 11)))
+
+Additionally, test expand-defmacro by running:
+ > (load "PATHTOHEREexpand.ss")
+
+Test compilation and writing/reading compiled code with:
+ > (load "PATHTOHEREcompile.ss")
+
+Run the tests with no output except for the results with:
+ > (load "PATHTOHEREquiet.ss")
+
+Run 3 copies of the test suite concurrently in separate threads:
+ > (load "PATHTOHEREparallel.ss")
+
+MzLib tests are run with:
+ > (load "PATHTOHEREmzlib.ss")
+
+
+To run the test suite in MzRice, use these flags:
+  --case-insens --auto-else --no-set-undef --no-sig-undef
+
+
+Please report bugs using
+  http://www.cs.rice.edu/CS/PLT/Gnats/
+or (as a last resort) send mail to
+  plt-bugs@rice.edu
diff --git a/collects/tests/mzscheme/all.ss b/collects/tests/mzscheme/all.ss
new file mode 100644
index 0000000..7ecae32
--- /dev/null
+++ b/collects/tests/mzscheme/all.ss
@@ -0,0 +1,38 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(load-relative "basic.ss")
+(load-relative "read.ss")
+(unless (defined? 'building-flat-tests)
+  (load-relative "macro.ss"))
+(load-relative "syntax.ss")
+(load-relative "number.ss")
+(load-relative "object.ss")
+(load-relative "struct.ss")
+(load-relative "unit.ss")
+(load-relative "unitsig.ss")
+(load-relative "thread.ss")
+(unless (or (defined? 'read/zodiac)
+	    (defined? 'in-drscheme?))
+	(load-relative "namespac.ss"))
+(unless (or (defined? 'building-flat-tests)
+	    (defined? 'read/zodiac)
+	    (defined? 'in-drscheme?))
+   (load-relative "param.ss"))
+(load-relative "file.ss")
+(load-relative "path.ss")
+(unless (defined? 'building-flat-tests)
+   (load-relative "hashper.ss"))
+(unless (or (defined? 'building-flat-tests)
+	    (defined? 'read/zodiac)
+	    (defined? 'in-drscheme?))
+   (load-relative "optimize.ss"))
+(unless (defined? 'building-flat-tests)
+   (load-relative "name.ss"))
+
+;; Ok, so this isn't really all of them. Here are more:
+; thrport.ss
+; deep.ss
+
+; See also README
diff --git a/collects/tests/mzscheme/basic.ss b/collects/tests/mzscheme/basic.ss
new file mode 100644
index 0000000..26f033c
--- /dev/null
+++ b/collects/tests/mzscheme/basic.ss
@@ -0,0 +1,1289 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(test '() 'null null)
+(test '() 'null ())
+
+(let ([f (lambda () #&7)])
+  (test #t eq? (f) (f)))
+
+(test #t type-symbol? #<hello>)
+(test #t type-symbol? #<<\>>)
+(test #t type-symbol? #<<>)
+(test #t type-symbol? '#<hello>)
+(test #f type-symbol? '<hello>)
+(test #t eq? #<hello> '#<hello>)
+(test #f eq? #<hello> #<hello-again>)
+
+(arity-test type-symbol? 1 1)
+
+(SECTION 2 1);; test that all symbol characters are supported.
+'(+ - ... !.. $.+ %.- &.! *.: /:. :+. <-. =. >. ?. ~. _. ^.)
+
+(SECTION 3 4)
+(define disjoint-type-functions
+  (list boolean? char? null? number? pair? procedure? string? symbol? vector?))
+(define type-examples
+  (list
+   #t #f #\a '() 9739 '(test) record-error "test" "" 'test '#() '#(a b c) ))
+(define i 1)
+(for-each (lambda (x) (display (make-string i #\ ))
+		  (set! i (+ 3 i))
+		  (write x)
+		  (newline))
+	  disjoint-type-functions)
+(define type-matrix
+  (map (lambda (x)
+	 (let ((t (map (lambda (f) (f x)) disjoint-type-functions)))
+	   (write t)
+	   (write x)
+	   (newline)
+	   t))
+       type-examples))
+
+(SECTION 6 1)
+(test #f not #t)
+(test #f not 3)
+(test #f not (list 3))
+(test #t not #f)
+(test #f not '())
+(test #f not (list))
+(test #f not 'nil)
+(arity-test not 1 1)
+
+(test #t boolean? #f)
+(test #t boolean? #t)
+(test #f boolean? 0)
+(test #f boolean? '())
+(arity-test boolean? 1 1)
+
+(SECTION 6 2)
+(test #t eqv? 'a 'a)
+(test #f eqv? 'a 'b)
+(test #t eqv? 2 2)
+(test #f eqv? 2 2.0)
+(test #t eqv? '() '())
+(test #t eqv? '10000 '10000)
+(test #t eqv? 10000000000000000000 10000000000000000000)
+(test #f eqv? 10000000000000000000 10000000000000000001)
+(test #f eqv? 10000000000000000000 20000000000000000000)
+(test #f eqv? (cons 1 2) (cons 1 2))
+(test #f eqv? (lambda () 1) (lambda () 2))
+(test #f eqv? #f 'nil)
+(let ((p (lambda (x) x)))
+  (test #t eqv? p p))
+(define gen-counter
+ (lambda ()
+   (let ((n 0))
+      (lambda () (set! n (+ n 1)) n))))
+(let ((g (gen-counter))) (test #t eqv? g g))
+(test #f eqv? (gen-counter) (gen-counter))
+(letrec ((f (lambda () (if (eqv? f g) 'f 'both)))
+	 (g (lambda () (if (eqv? f g) 'g 'both))))
+  (test #f eqv? f g))
+
+(test #t eq? 'a 'a)
+(test #f eq? (list 'a) (list 'a))
+(test #t eq? '() '())
+(test #t eq? car car)
+(let ((x '(a))) (test #t eq? x x))
+(let ((x '#())) (test #t eq? x x))
+(let ((x (lambda (x) x))) (test #t eq? x x))
+
+(test #t equal? 'a 'a)
+(test #t equal? '("a") '("a"))
+(test #t equal? '(a) '(a))
+(test #t equal? '(a (b) c) '(a (b) c))
+(test #t equal? '("a" ("b") "c") '("a" ("b") "c"))
+(test #t equal? "abc" "abc")
+(test #t equal? 2 2)
+(test #t equal? (make-vector 5 'a) (make-vector 5 'a))
+(test #t equal? (box "a") (box "a"))
+(test #f equal? "" (string #\null))
+
+(test #f equal? 'a "a")
+(test #f equal? 'a 'b)
+(test #f equal? '(a) '(b))
+(test #f equal? '(a (b) d) '(a (b) c))
+(test #f equal? '(a (b) c) '(d (b) c))
+(test #f equal? '(a (b) c) '(a (d) c))
+(test #f equal? "abc" "abcd")
+(test #f equal? "abcd" "abc")
+(test #f equal? 2 3)
+(test #f equal? 2.0 2)
+(test #f equal? (make-vector 5 'b) (make-vector 5 'a))
+(test #f equal? (box "a") (box "b"))
+
+(arity-test eq? 2 2)
+(arity-test eqv? 2 2)
+(arity-test equal? 2 2)
+
+(SECTION 6 3)
+(test '(a b c d e) 'dot '(a . (b . (c . (d . (e . ()))))))
+(define x (list 'a 'b 'c))
+(define y x)
+(and list? (test #t list? y))
+(set-cdr! x 4)
+(test '(a . 4) 'set-cdr! x)
+(test #t eqv? x y)
+(test '(a b c . d) 'dot '(a . (b . (c . d))))
+(test #f list? y)
+(let ((x (list 'a))) (set-cdr! x x) (test #f list? x))
+(arity-test list? 1 1)
+
+(test #t pair? '(a . b))
+(test #t pair? '(a . 1))
+(test #t pair? '(a b c))
+(test #f pair? '())
+(test #f pair? '#(a b))
+(arity-test pair? 1 1)
+
+(test '(a) cons 'a '())
+(test '((a) b c d) cons '(a) '(b c d))
+(test '("a" b c) cons "a" '(b c))
+(test '(a . 3) cons 'a 3)
+(test '((a b) . c) cons '(a b) 'c)
+(arity-test cons 2 2) 
+
+(test 'a car '(a b c))
+(test '(a) car '((a) b c d))
+(test 1 car '(1 . 2))
+(arity-test car 1 1)
+(error-test '(car 1))
+
+(test '(b c d) cdr '((a) b c d))
+(test 2 cdr '(1 . 2))
+(arity-test cdr 1 1)
+(error-test '(cdr 1))
+
+(test '(a 7 c) list 'a (+ 3 4) 'c)
+(test '() list)
+
+(test 3 length '(a b c))
+(test 3 length '(a (b) (c d e)))
+(test 0 length '())
+(arity-test length 1 1)
+(error-test '(length 1))
+(error-test '(length '(1 . 2)))
+(error-test '(length "a"))
+; (error-test '(length (quote #0=(1 . #0#))))
+(error-test '(let ([p (cons 1 1)]) (set-cdr! p p) (length p)))
+(define x (cons 4 0))
+(set-cdr! x x) 
+(error-test '(length x))
+
+(define l '(1 2 3))
+(set-cdr! l 5)
+(test '(1 . 5) 'set-cdr! l)
+(set-car! l 0)
+(test '(0 . 5) 'set-car! l)
+(arity-test set-car! 2 2)
+(arity-test set-cdr! 2 2)
+(error-test '(set-car! 4 4))
+(error-test '(set-cdr! 4 4))
+
+(define (box-tests box unbox box? set-box! set-box!-name unbox-name)
+  (define b (box 5))
+  (test 5 unbox b)
+  (when set-box!
+	(set-box! b 6)
+	(test 6 unbox b))
+  (test #t box? b)
+  (test #f box? 5)
+  (arity-test box 1 1)
+  (arity-test unbox 1 1)
+  (arity-test box? 1 1)
+  (when set-box!
+	(arity-test set-box! 2 2))
+  (error-test `(,unbox-name 8))
+  (when set-box!
+	(error-test `(,set-box!-name 8 8))))
+(box-tests box unbox box? set-box! 'set-box! 'unbox)
+(box-tests make-weak-box weak-box-value weak-box? #f #f 'weak-box-value)
+
+(test '(x y) append '(x) '(y))
+(test '(a b c d) append '(a) '(b c d))
+(test '(a (b) (c)) append '(a (b)) '((c)))
+(test '() append)
+(test '(a b c . d) append '(a b) '(c . d))
+(test 'a append '() 'a)
+(test 1 append 1)
+(test '(1 . 2) append '(1) 2)
+(test '(1 . 2) append '(1) 2)
+(error-test '(append '(1 2 . 3) 1))
+(error-test '(append '(1 2 3) 1 '(4 5 6)))
+(test '(x y) append! '(x) '(y))
+(test '(a b c d) append! '(a) '(b c d))
+(test '(a (b) (c)) append! '(a (b)) '((c)))
+(test '() append!)
+(test '(a b c . d) append! '(a b) '(c . d))
+(test 'a append! '() 'a)
+(test 1 append! 1)
+(error-test '(append! '(1 2 . 3) 1))
+(error-test '(append! '(1 2 3) 1 '(4 5 6)))
+
+(define l '(1 2))
+(define l2 '(3 4 . 7))
+(define l3 (append l l2))
+(test '(1 2 3 4 . 7) 'append l3)
+(set-car! l2 5)
+(test '(1 2 5 4 . 7) 'append l3)
+(set-car! l3 0)
+(test '(0 2 5 4 . 7) 'append l3)
+(test '(1 2) 'append l)
+
+(let* ([l '(1 2)]
+       [l2 '(3 4 . 7)]
+       [l3 (append! l l2)])
+  (test '(1 2 3 4 . 7) 'append! l3)
+  (set-car! l2 5)
+  (test '(1 2 5 4 . 7) 'append! l3)
+  (set-car! l3 0)
+  (test '(0 2 5 4 . 7) 'append! l3)
+  (test '(0 2 5 4 . 7) 'append! l))
+
+(test '(c b a) reverse '(a b c))
+(test '((e (f)) d (b c) a) reverse '(a (b c) d (e (f))))
+(arity-test reverse 1 1)
+(error-test '(reverse 1))
+(error-test '(reverse '(1 . 1)))
+
+(define l '(a b c))
+(test '(c b a) reverse! l)
+(test '(a) 'reverse! l)
+(test '((e (f)) d (b c) a) reverse! '(a (b c) d (e (f))))
+(arity-test reverse! 1 1)
+(error-test '(reverse! 1))
+(error-test '(reverse! '(1 . 1)))
+
+(test 'c list-ref '(a b c d) 2)
+(test 'c list-ref '(a b c . d) 2)
+(arity-test list-ref 2 2)
+(error-test '(list-ref 1 1) exn:application:range:list?)
+(error-test '(list-ref '(a b . c) 2) exn:application:range:list?)
+(error-test '(list-ref '(1 2 3) 2.0))
+(error-test '(list-ref '(1) '(1)))
+(error-test '(list-ref '(1) 1) exn:application:range:list?)
+(error-test '(list-ref '() 0) exn:application:range:list?)
+(error-test '(list-ref '() 0) exn:application:range:list?)
+(error-test '(list-ref '(1) -1))
+
+(test '(c d) list-tail '(a b c d) 2)
+(test '(a b c d) list-tail '(a b c d) 0)
+(test '(b c . d) list-tail '(a b c . d) 1)
+(test 1 list-tail 1 0)
+(arity-test list-tail 2 2)
+(error-test '(list-tail 1 1) exn:application:range:list?)
+(error-test '(list-tail '(1 2 3) 2.0))
+(error-test '(list-tail '(1) '(1)))
+(error-test '(list-tail '(1) -1))
+(error-test '(list-tail '(1) 2) exn:application:range:list?)
+(error-test '(list-tail '(1 2 . 3) 3) exn:application:range:list?)
+
+(define (test-mem memq memq-name)
+  (test '(a b c) memq 'a '(a b c))
+  (test '(b c) memq 'b '(a b c))
+  (test '(b . c) memq 'b '(a b . c))
+  (test '#f memq 'a '(b c d))
+
+  (arity-test memq 2 2)
+  (error-test `(,memq-name 'a 1)  exn:application:list?)
+  (error-test `(,memq-name 'a '(1 . 2)) exn:application:list?))
+
+(test-mem memq 'memq)
+(test-mem memv 'memv)
+(test-mem member 'member)
+
+(test #f memq "apple" '("apple"))
+(test #f memv "apple" '("apple"))
+(test '("apple") member "apple" '("apple"))
+
+; (test #f memq 1/2 '(1/2)) ; rationals are immutable and we may want to optimize
+(test '(1/2) memv 1/2 '(1/2))
+(test '(1/2) member 1/2 '(1/2))
+
+(test '((1 2)) member '(1 2) '(1 2 (1 2)))
+
+(define (test-ass assq assq-name)
+  (define e '((a 1) (b 2) (c 3)))
+  (test '(a 1) assq 'a e)
+  (test '(b 2) assq 'b e)
+  (test #f assq 'd e)
+  (test '(a 1) assq 'a '((x 0) (a 1) b 2))
+  (test '(a 1) assq 'a '((x 0) (a 1) . 0))
+  (arity-test assq 2 2)
+
+  (error-test `(,assq-name 1 1) exn:application:list?)
+  (error-test `(,assq-name 1 '(1 2))  exn:application:list?)
+  (error-test `(,assq-name 1 '((0) . 2)) exn:application:list?))
+
+(test-ass assq 'assq)
+(test-ass assv 'assv)
+(test-ass assoc 'assoc)
+
+(test #f assq '(a) '(((a)) ((b)) ((c))))
+(test #f assv '(a) '(((a)) ((b)) ((c))))
+(test '((b) 1) assoc '(b) '(((a)) ((b) 1) ((c))))
+
+; (test #f assq '1/2 '(((a)) (1/2) ((c)))) ; rationals are immutable and we may want to optimize
+(test '(1/2) assv '1/2 '(((a)) (1/2) ((c))))
+(test '(1/2) assoc '1/2 '(((a)) (1/2) ((c))))
+
+(SECTION 6 4)
+(test #t symbol? 'foo)
+(test #t symbol? (car '(a b)))
+(test #f symbol? "bar")
+(test #t symbol? 'nil)
+(test #f symbol? '())
+(test #f symbol? #f)
+;;; But first, what case are symbols in?  Determine the standard case:
+(define char-standard-case char-upcase)
+(if (string=? (symbol->string 'A) "a")
+    (set! char-standard-case char-downcase))
+(test #t 'standard-case
+      (string=? (symbol->string 'a) (symbol->string 'A)))
+(test #t 'standard-case
+      (or (string=? (symbol->string 'a) "A")
+	  (string=? (symbol->string 'A) "a")))
+(define (str-copy s)
+  (let ((v (make-string (string-length s))))
+    (do ((i (- (string-length v) 1) (- i 1)))
+	((< i 0) v)
+      (string-set! v i (string-ref s i)))))
+(define (string-standard-case s)
+  (set! s (str-copy s))
+  (do ((i 0 (+ 1 i))
+       (sl (string-length s)))
+      ((>= i sl) s)
+      (string-set! s i (char-standard-case (string-ref s i)))))
+(test (string-standard-case "flying-fish") symbol->string 'flying-fish)
+(test (string-standard-case "martin") symbol->string 'Martin)
+(test "Malvina" symbol->string (string->symbol "Malvina"))
+(test #t 'standard-case (eq? 'a 'A))
+
+(define x (string #\a #\b))
+(define y (string->symbol x))
+(string-set! x 0 #\c)
+(test "cb" 'string-set! x)
+(test "ab" symbol->string y)
+(test y string->symbol "ab")
+
+(test #t eq? 'mISSISSIppi 'mississippi)
+(test #f 'string->symbol (eq? 'bitBlt (string->symbol "bitBlt")))
+(test 'JollyWog string->symbol (symbol->string 'JollyWog))
+
+(arity-test symbol? 1 1)
+
+(SECTION 6 6)
+(test #t eqv? '#\  #\Space)
+(test #t eqv? #\space '#\Space)
+(test #t char? #\a)
+(test #t char? #\()
+(test #t char? #\ )
+(test #t char? '#\newline)
+(arity-test char? 1 1)
+
+(test #t char=? #\A)
+(test #f char=? #\A #\B)
+(test #f char=? #\A #\A #\B)
+(test #f char=? #\A #\B #\A)
+(test #f char=? #\a #\b)
+(test #f char=? #\9 #\0)
+(test #t char=? #\A #\A)
+(test #t char=? #\A #\A #\A)
+(test #t char=? #\370 #\370)
+(test #f char=? #\371 #\370)
+(test #f char=? #\370 #\371)
+(arity-test char=? 1 -1)
+(error-test '(char=? #\a 1)) 
+(error-test '(char=? #\a #\b 1)) 
+(error-test '(char=? 1 #\a))
+
+(test #t char<? #\A)
+(test #t char<? #\A #\B)
+(test #t char<? #\A #\B #\C)
+(test #f char<? #\A #\B #\A)
+(test #f char<? #\A #\A #\C)
+(test #t char<? #\a #\b)
+(test #f char<? #\9 #\0)
+(test #f char<? #\A #\A)
+(test #f char<? #\370 #\370)
+(test #f char<? #\371 #\370)
+(test #t char<? #\370 #\371)
+(arity-test char<? 1 -1)
+(error-test '(char<? #\a 1)) 
+(error-test '(char<? #\a #\a 1)) 
+(error-test '(char<? 1 #\a))
+
+(test #t char>? #\A)
+(test #f char>? #\A #\B)
+(test #t char>? #\B #\A)
+(test #f char>? #\A #\B #\C)
+(test #f char>? #\B #\A #\C)
+(test #t char>? #\C #\B #\A)
+(test #f char>? #\a #\b)
+(test #t char>? #\9 #\0)
+(test #f char>? #\A #\A)
+(test #f char>? #\370 #\370)
+(test #t char>? #\371 #\370)
+(test #f char>? #\370 #\371)
+(arity-test char>? 1 -1)
+(error-test '(char>? #\a 1)) 
+(error-test '(char>? #\a #\a 1)) 
+(error-test '(char>? 1 #\a))
+
+(test #t char<=? #\A)
+(test #t char<=? #\A #\B)
+(test #t char<=? #\A #\B #\C)
+(test #t char<=? #\A #\A #\C)
+(test #f char<=? #\A #\B #\A)
+(test #f char<=? #\B #\A #\C)
+(test #t char<=? #\a #\b)
+(test #f char<=? #\9 #\0)
+(test #t char<=? #\A #\A)
+(test #t char<=? #\370 #\370)
+(test #f char<=? #\371 #\370)
+(test #t char<=? #\370 #\371)
+(arity-test char<=? 1 -1)
+(error-test '(char<=? #\a 1)) 
+(error-test '(char<=? #\b #\a 1)) 
+(error-test '(char<=? 1 #\a))
+
+(test #t char>=? #\A)
+(test #f char>=? #\A #\B)
+(test #f char>=? #\a #\b)
+(test #t char>=? #\9 #\0)
+(test #t char>=? #\A #\A)
+(test #t char>=? #\370 #\370)
+(test #t char>=? #\371 #\370)
+(test #f char>=? #\370 #\371)
+(arity-test char>=? 1 -1)
+(error-test '(char>=? #\a 1)) 
+(error-test '(char>=? #\a #\b 1)) 
+(error-test '(char>=? 1 #\a))
+
+(test #t char-ci=? #\A)
+(test #f char-ci=? #\A #\B)
+(test #f char-ci=? #\A #\A #\B)
+(test #f char-ci=? #\a #\B)
+(test #f char-ci=? #\A #\b)
+(test #f char-ci=? #\a #\b)
+(test #f char-ci=? #\9 #\0)
+(test #t char-ci=? #\A #\A)
+(test #t char-ci=? #\A #\a)
+(test #t char-ci=? #\A #\a #\A)
+(test #t char-ci=? #\370 #\370)
+(test #f char-ci=? #\371 #\370)
+(test #f char-ci=? #\370 #\371)
+(arity-test char-ci=? 1 -1)
+(error-test '(char-ci=? #\a 1)) 
+(error-test '(char-ci=? #\a #\b 1)) 
+(error-test '(char-ci=? 1 #\a))
+
+(test #t char-ci<? #\A)
+(test #t char-ci<? #\A #\B)
+(test #t char-ci<? #\A #\B #\C)
+(test #t char-ci<? #\a #\B)
+(test #t char-ci<? #\A #\b)
+(test #t char-ci<? #\A #\b #\C)
+(test #t char-ci<? #\a #\b)
+(test #f char-ci<? #\9 #\0)
+(test #f char-ci<? #\A #\A)
+(test #f char-ci<? #\A #\a)
+(test #f char-ci<? #\A #\b #\B)
+(test #f char-ci<? #\370 #\370)
+(test #f char-ci<? #\371 #\370)
+(test #t char-ci<? #\370 #\371)
+(arity-test char-ci<? 1 -1)
+(error-test '(char-ci<? #\a 1)) 
+(error-test '(char-ci<? #\b #\a 1)) 
+(error-test '(char-ci<? 1 #\a))
+
+(test #t char-ci>? #\A)
+(test #f char-ci>? #\A #\B)
+(test #f char-ci>? #\B #\A #\C)
+(test #t char-ci>? #\C #\B #\A)
+(test #f char-ci>? #\a #\B)
+(test #f char-ci>? #\A #\b)
+(test #f char-ci>? #\a #\b)
+(test #t char-ci>? #\C #\b #\A)
+(test #t char-ci>? #\9 #\0)
+(test #f char-ci>? #\A #\A)
+(test #f char-ci>? #\A #\a)
+(test #f char-ci>? #\370 #\370)
+(test #t char-ci>? #\371 #\370)
+(test #f char-ci>? #\370 #\371)
+(arity-test char-ci>? 1 -1)
+(error-test '(char-ci>? #\a 1)) 
+(error-test '(char-ci>? #\a #\b 1)) 
+(error-test '(char-ci>? 1 #\a))
+
+(test #t char-ci<=? #\A)
+(test #t char-ci<=? #\A #\B)
+(test #t char-ci<=? #\a #\B)
+(test #t char-ci<=? #\a #\B #\C)
+(test #f char-ci<=? #\a #\b #\A)
+(test #t char-ci<=? #\A #\b)
+(test #t char-ci<=? #\a #\b)
+(test #f char-ci<=? #\9 #\0)
+(test #t char-ci<=? #\A #\A)
+(test #t char-ci<=? #\A #\a)
+(test #t char-ci<=? #\370 #\370)
+(test #f char-ci<=? #\371 #\370)
+(test #t char-ci<=? #\370 #\371)
+(arity-test char-ci<=? 1 -1)
+(error-test '(char-ci<=? #\a 1)) 
+(error-test '(char-ci<=? #\b #\a 1)) 
+(error-test '(char-ci<=? 1 #\a))
+
+(test #t char-ci>=? #\A)
+(test #f char-ci>=? #\A #\B)
+(test #f char-ci>=? #\B #\A #\C)
+(test #t char-ci>=? #\B #\B #\A)
+(test #f char-ci>=? #\a #\B)
+(test #f char-ci>=? #\A #\b)
+(test #f char-ci>=? #\a #\b)
+(test #t char-ci>=? #\9 #\0)
+(test #t char-ci>=? #\A #\A)
+(test #t char-ci>=? #\A #\a)
+(test #t char-ci>=? #\370 #\370)
+(test #t char-ci>=? #\371 #\370)
+(test #f char-ci>=? #\370 #\371)
+(arity-test char-ci>=? 1 -1)
+(error-test '(char-ci>=? #\a 1)) 
+(error-test '(char-ci>=? #\a #\b 1)) 
+(error-test '(char-ci>=? 1 #\a))
+
+(define (ascii-range start end)
+  (let ([s (char->integer start)]
+	[e (char->integer end)])
+    (let loop ([n e][l (list end)])
+      (if (= n s)
+	  l
+	  (let ([n (sub1 n)])
+	    (loop n (cons (integer->char n) l)))))))
+
+(define uppers (ascii-range #\A #\Z))
+(define lowers (ascii-range #\a #\z))
+(define alphas (append uppers lowers))
+(define digits (ascii-range #\0 #\9))
+(define whites (list #\newline #\return #\space #\page #\tab #\vtab))
+
+(define (test-all is-a? name members)
+  (let loop ([n 0])
+    (unless (= n 256)
+      (let ([c (integer->char n)])
+	(test (and (memq c members) #t) `(,is-a? (integer->char ,n)) (is-a? c))
+	(loop (add1 n)))))
+  (arity-test char-alphabetic? 1 1)
+  (error-test `(,name 1)))
+
+(test-all char-alphabetic? 'char-alphabetic? alphas) 
+(test-all char-numeric? 'char-numeric? digits) 
+(test-all char-whitespace? 'char-whitespace? whites) 
+(test-all char-upper-case? 'char-upper-case? uppers) 
+(test-all char-lower-case? 'char-lower-case? lowers) 
+
+(let loop ([n 0])
+  (unless (= n 256)
+     (test n 'integer->char (char->integer (integer->char n)))
+     (loop (add1 n))))
+
+(test 0 char->integer #\nul)
+(test 10 char->integer #\newline)
+(test 13 char->integer #\return)
+(test 9 char->integer #\tab)
+(test 8 char->integer #\backspace)
+(test 12 char->integer #\page)
+(test 32 char->integer #\space)
+(test 127 char->integer #\rubout)
+(test #\null 'null #\nul)
+(test #\newline 'linefeed #\linefeed)
+
+(test #\. integer->char (char->integer #\.))
+(test #\A integer->char (char->integer #\A))
+(test #\a integer->char (char->integer #\a))
+(test #\371 integer->char (char->integer #\371))
+(arity-test integer->char 1 1)
+(arity-test char->integer 1 1)
+(error-test '(integer->char 5.0))
+(error-test '(integer->char 'a))
+(error-test '(integer->char -1))
+(error-test '(integer->char 256))
+(error-test '(integer->char 10000000000000000))
+(error-test '(char->integer 5))
+
+(define (test-up/down case case-name members memassoc)
+  (let loop ([n 0])
+    (unless (= n 256)
+      (let ([c (integer->char n)])
+	(if (memq c members)
+	    (test (cdr (assq c memassoc)) case c)
+	    (test n `(char->integer (,case-name (integer->char ,n))) (char->integer (case c)))))
+      (loop (add1 n))))
+  (arity-test case 1 1)
+  (error-test `(,case-name 2)))
+
+(test-up/down char-upcase 'char-upcase lowers (map cons lowers uppers))
+(test-up/down char-downcase 'char-downcase uppers (map cons uppers lowers))
+
+(SECTION 6 7)
+(test #t string? "The word \"recursion\\\" has many meanings.")
+(test #t string? "")
+(arity-test string? 1 1)
+(test 3 'make-string (string-length (make-string 3)))
+(test "" make-string 0)
+(arity-test make-string 1 2)
+(error-test '(make-string "hello"))
+(error-test '(make-string 5 "hello"))
+(error-test '(make-string 5.0 #\b))
+(error-test '(make-string 5.2 #\a))
+(error-test '(make-string -5 #\f))
+(error-test '(make-string 500000000000000 #\f) exn:misc:out-of-memory?)
+
+(define f (make-string 3 #\*))
+(test "?**" 'string-set! (begin (string-set! f 0 #\?) f))
+(arity-test string-set! 3 3)
+(error-test '(string-set! "hello" 'a #\a))
+(error-test '(string-set! 'hello 4 #\a))
+(error-test '(string-set! "hello" 4 'a))
+(error-test '(string-set! "hello" 4.0 'a))
+(error-test '(string-set! "hello" 5 #\a) exn:application:range:bounds:string?)
+(error-test '(string-set! "hello" -1 #\a))
+(error-test '(string-set! "hello" (expt 2 100) #\a) exn:application:range:bounds:string?)
+(test "abc" string #\a #\b #\c)
+(test "" string)
+(error-test '(string #\a 1))
+(error-test '(string 1 #\a))
+(error-test '(string 1))
+(test 3 string-length "abc")
+(test 0 string-length "")
+(arity-test string-length 1 1)
+(error-test '(string-length 'apple))
+(test #\a string-ref "abc" 0)
+(test #\c string-ref "abc" 2)
+(arity-test string-ref 2 2)
+(error-test '(string-ref 'apple 4))
+(error-test '(string-ref "apple" 4.0))
+(error-test '(string-ref "apple" '(4)))
+(error-test '(string-ref "apple" 5) exn:application:range:bounds:string?)
+(error-test '(string-ref "" 0) exn:application:range:bounds:string?)
+(error-test '(string-ref "" (expt 2 100)) exn:application:range:bounds:string?)
+(error-test '(string-ref "apple" -1))
+(test "" substring "ab" 0 0)
+(test "" substring "ab" 1 1)
+(test "" substring "ab" 2 2)
+(test "a" substring "ab" 0 1)
+(test "b" substring "ab" 1 2)
+(test "ab" substring "ab" 0 2)
+(test (string #\a #\nul #\b) substring (string #\- #\a #\nul #\b #\*) 1 4)
+(arity-test substring 3 3)
+(error-test '(substring 'hello 2 3))
+(error-test '(substring "hello" "2" 3))
+(error-test '(substring "hello" 2.0 3))
+(error-test '(substring "hello" 2 3.0))
+(error-test '(substring "hello" 2 "3"))
+(error-test '(substring "hello" 2 7) exn:application:range:bounds:string?)
+(error-test '(substring "hello" -2 3))
+(error-test '(substring "hello" 4 3) exn:application:range:bounds:string?)
+(error-test '(substring "hello" (expt 2 100) 3) exn:application:range:bounds:string?)
+(error-test '(substring "hello" 3 (expt 2 100)) exn:application:range:bounds:string?)
+(test "foobar" string-append "foo" "bar")
+(test "foo" string-append "foo")
+(test "foo" string-append "foo" "")
+(test "foogoo" string-append "foo" "" "goo")
+(test "foo" string-append "" "foo")
+(test "" string-append)
+(test (string #\a #\nul #\b #\c #\nul #\d) 
+      string-append (string #\a #\nul #\b) (string #\c #\nul #\d))
+(error-test '(string-append 1))
+(error-test '(string-append "hello" 1))
+(error-test '(string-append "hello" 1 "done"))
+(test "" make-string 0)
+(define s "hello")
+(define s2 (string-copy s))
+(test "hello" 'string-copy s2)
+(string-set! s 2 #\x)
+(test "hello" 'string-copy s2)
+(test (string #\a #\nul #\b) string-copy (string #\a #\nul #\b))
+(string-fill! s #\x)
+(test "xxxxx" 'string-fill! s)
+(arity-test string-copy 1 1)
+(arity-test string-fill! 2 2)
+(error-test '(string-copy 'blah))
+(error-test '(string-fill! "oops" 5))
+
+(define ax (string #\a #\nul #\370 #\x))
+(define abigx (string #\a #\nul #\370 #\X))
+(define ax2 (string #\a #\nul #\370 #\x))
+(define ay (string #\a #\nul #\371 #\x))
+
+(test #t string=? "string")
+(test #t string<? "string")
+(test #t string>? "string")
+(test #t string<=? "string")
+(test #t string>=? "string")
+(test #t string-ci=? "string")
+(test #t string-ci<? "string")
+(test #t string-ci>? "string")
+(test #t string-ci<=? "string")
+(test #t string-ci>=? "string")
+
+(test #t string=? "" "")
+(test #f string<? "" "")
+(test #f string>? "" "")
+(test #t string<=? "" "")
+(test #t string>=? "" "")
+(test #t string-ci=? "" "")
+(test #f string-ci<? "" "")
+(test #f string-ci>? "" "")
+(test #t string-ci<=? "" "")
+(test #t string-ci>=? "" "")
+
+(test #f string=? "A" "B")
+(test #f string=? "a" "b")
+(test #f string=? "9" "0")
+(test #t string=? "A" "A")
+(test #f string=? "A" "AB")
+(test #t string=? ax ax2)
+(test #f string=? ax abigx)
+(test #f string=? ax ay)
+(test #f string=? ay ax)
+
+(test #t string<? "A" "B")
+(test #t string<? "a" "b")
+(test #f string<? "9" "0")
+(test #f string<? "A" "A")
+(test #t string<? "A" "AB")
+(test #f string<? "AB" "A")
+(test #f string<? ax ax2)
+(test #t string<? ax ay)
+(test #f string<? ay ax)
+
+(test #f string>? "A" "B")
+(test #f string>? "a" "b")
+(test #t string>? "9" "0")
+(test #f string>? "A" "A")
+(test #f string>? "A" "AB")
+(test #t string>? "AB" "A")
+(test #f string>? ax ax2)
+(test #f string>? ax ay)
+(test #t string>? ay ax)
+
+(test #t string<=? "A" "B")
+(test #t string<=? "a" "b")
+(test #f string<=? "9" "0")
+(test #t string<=? "A" "A")
+(test #t string<=? "A" "AB")
+(test #f string<=? "AB" "A")
+(test #t string<=? ax ax2)
+(test #t string<=? ax ay)
+(test #f string<=? ay ax)
+
+(test #f string>=? "A" "B")
+(test #f string>=? "a" "b")
+(test #t string>=? "9" "0")
+(test #t string>=? "A" "A")
+(test #f string>=? "A" "AB")
+(test #t string>=? "AB" "A")
+(test #t string>=? ax ax2)
+(test #f string>=? ax ay)
+(test #t string>=? ay ax)
+
+(test #f string-ci=? "A" "B")
+(test #f string-ci=? "a" "B")
+(test #f string-ci=? "A" "b")
+(test #f string-ci=? "a" "b")
+(test #f string-ci=? "9" "0")
+(test #t string-ci=? "A" "A")
+(test #t string-ci=? "A" "a")
+(test #f string-ci=? "A" "AB")
+(test #t string-ci=? ax ax2)
+(test #t string-ci=? ax abigx)
+(test #f string-ci=? ax ay)
+(test #f string-ci=? ay ax)
+(test #f string-ci=? abigx ay)
+(test #f string-ci=? ay abigx)
+
+(test #t string-ci<? "A" "B")
+(test #t string-ci<? "a" "B")
+(test #t string-ci<? "A" "b")
+(test #t string-ci<? "a" "b")
+(test #f string-ci<? "9" "0")
+(test #f string-ci<? "A" "A")
+(test #f string-ci<? "A" "a")
+(test #t string-ci<? "A" "AB")
+(test #f string-ci<? "AB" "A")
+(test #f string-ci<? ax ax2)
+(test #f string-ci<? ax abigx)
+(test #t string-ci<? ax ay)
+(test #f string-ci<? ay ax)
+(test #t string-ci<? abigx ay)
+(test #f string-ci<? ay abigx)
+
+(test #f string-ci>? "A" "B")
+(test #f string-ci>? "a" "B")
+(test #f string-ci>? "A" "b")
+(test #f string-ci>? "a" "b")
+(test #t string-ci>? "9" "0")
+(test #f string-ci>? "A" "A")
+(test #f string-ci>? "A" "a")
+(test #f string-ci>? "A" "AB")
+(test #t string-ci>? "AB" "A")
+(test #f string-ci>? ax ax2)
+(test #f string-ci>? ax abigx)
+(test #f string-ci>? ax ay)
+(test #t string-ci>? ay ax)
+(test #f string-ci>? abigx ay)
+(test #t string-ci>? ay abigx)
+
+(test #t string-ci<=? "A" "B")
+(test #t string-ci<=? "a" "B")
+(test #t string-ci<=? "A" "b")
+(test #t string-ci<=? "a" "b")
+(test #f string-ci<=? "9" "0")
+(test #t string-ci<=? "A" "A")
+(test #t string-ci<=? "A" "a")
+(test #t string-ci<=? "A" "AB")
+(test #f string-ci<=? "AB" "A")
+(test #t string-ci<=? ax ax2)
+(test #t string-ci<=? ax abigx)
+(test #t string-ci<=? ax ay)
+(test #f string-ci<=? ay ax)
+(test #t string-ci<=? abigx ay)
+(test #f string-ci<=? ay abigx)
+
+(test #f string-ci>=? "A" "B")
+(test #f string-ci>=? "a" "B")
+(test #f string-ci>=? "A" "b")
+(test #f string-ci>=? "a" "b")
+(test #t string-ci>=? "9" "0")
+(test #t string-ci>=? "A" "A")
+(test #t string-ci>=? "A" "a")
+(test #f string-ci>=? "A" "AB")
+(test #t string-ci>=? "AB" "A")
+(test #t string-ci>=? ax ax2)
+(test #t string-ci>=? ax abigx)
+(test #f string-ci>=? ax ay)
+(test #t string-ci>=? ay ax)
+(test #f string-ci>=? abigx ay)
+(test #t string-ci>=? ay abigx)
+
+(map (lambda (pred)
+       (arity-test pred 1 -1)
+       (let ([predname (string->symbol
+			(primitive-name pred))])
+	 (error-test `(,predname "a" 1))
+	 (error-test `(,predname "a" "b" 5))
+	 (error-test `(,predname 1 "a"))))
+     (list string=? 
+	   string>? 
+	   string<? 
+	   string>=? 
+	   string<=? 
+	   string-ci=? 
+	   string-ci>? 
+	   string-ci<? 
+	   string-ci>=? 
+	   string-ci<=?))
+
+(SECTION 6 8)
+(test #t vector? '#(0 (2 2 2 2) "Anna"))
+(test #t vector? '#())
+(arity-test vector? 1 1)
+(test '#(a b c) vector 'a 'b 'c)
+(test '#() vector)
+(test 3 vector-length '#(0 (2 2 2 2) "Anna"))
+(test 0 vector-length '#())
+(arity-test vector-length 1 1)
+(error-test '(vector-length "apple"))
+(test 8 vector-ref '#(1 1 2 3 5 8 13 21) 5)
+(arity-test vector-ref 2 2)
+(error-test '(vector-ref "apple" 3))
+(error-test '(vector-ref #(4 5 6) 3) exn:application:range:bounds:vector?)
+(error-test '(vector-ref #() 0) exn:application:range:bounds:vector?)
+(error-test '(vector-ref #() (expt 2 100)) exn:application:range:bounds:vector?)
+(error-test '(vector-ref #(4 5 6) -1))
+(error-test '(vector-ref #(4 5 6) 2.0))
+(error-test '(vector-ref #(4 5 6) "2"))
+(test '#(0 ("Sue" "Sue") "Anna") 'vector-set
+	(let ((vec (vector 0 '(2 2 2 2) "Anna")))
+	  (vector-set! vec 1 '("Sue" "Sue"))
+	  vec))
+(test '#(hi hi) make-vector 2 'hi)
+(test '#() make-vector 0)
+(test '#() make-vector 0 'a)
+(arity-test make-vector 1 2)
+(error-test '(make-vector "a" 'a))
+(error-test '(make-vector 1.0 'a))
+(error-test '(make-vector 10.2 'a))
+(error-test '(make-vector -1 'a))
+(error-test '(make-vector 1000000000000000000000 'a) exn:misc:out-of-memory?)
+(arity-test vector-set! 3 3)
+(error-test '(vector-set! #() 0 'x) exn:application:range:bounds:vector?)
+(error-test '(vector-set! #(1 2 3) -1 'x))
+(error-test '(vector-set! #(1 2 3) 3 'x) exn:application:range:bounds:vector?)
+(error-test '(vector-set! #(1 2 3) (expt 2 100) 'x) exn:application:range:bounds:vector?)
+(error-test '(vector-set! '(1 2 3) 2 'x))
+(error-test '(vector-set! #(1 2 3) "2" 'x))
+(define v (quote #(1 2 3)))
+(vector-fill! v 0)
+(test (quote #(0 0 0)) 'vector-fill! v)
+(arity-test vector-fill! 2 2)
+(error-test '(vector-fill! '(1 2 3) 0))
+
+(SECTION 6 9)
+(test #t procedure? car)
+(test #f procedure? 'car)
+(test #t procedure? (lambda (x) (* x x)))
+(test #f procedure? '(lambda (x) (* x x)))
+(test #t call-with-current-continuation procedure?)
+(test #t call-with-escaping-continuation procedure?)
+(test #t procedure? (case-lambda ((x) x) ((x y) (+ x y))))
+(arity-test procedure? 1 1)
+
+(test 7 apply + (list 3 4))
+(test 7 apply (lambda (a b) (+ a b)) (list 3 4))
+(test 17 apply + 10 (list 3 4))
+(test '() apply list '())
+(define compose (lambda (f g) (lambda args (f (apply g args)))))
+(test 30 (compose sqrt *) 12 75)
+(error-test '(apply) exn:application:arity?)
+(error-test '(apply (lambda x x)) exn:application:arity?)
+(error-test '(apply (lambda x x) 1))
+(error-test '(apply (lambda x x) 1 2))
+(error-test '(apply (lambda x x) 1 '(2 . 3)))
+
+(test '(b e h) map cadr '((a b) (d e) (g h)))
+(test '(5 7 9) map + '(1 2 3) '(4 5 6))
+(test '#(0 1 4 9 16) 'for-each
+	(let ((v (make-vector 5)))
+		(for-each (lambda (i) (vector-set! v i (* i i)))
+			'(0 1 2 3 4))
+		v))
+
+(define (map-tests map)
+  (let ([size? exn:application:list-sizes?]
+	[non-list? type?])
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2) '1))
+    (error-test `(,map (lambda (x y) (+ x y)) '2 '(1 2)))
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2) '(1 2 3)) size?)
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2 3) '(1 2)) size?)
+    (error-test `(,map (lambda (x) (+ x)) '(1 2 . 3)) non-list?)
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2 . 3) '(1 2)) non-list?)
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2 . 3) '(1 2 3)) non-list?)
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2) '(1 2 . 3)) non-list?)
+    (error-test `(,map (lambda (x y) (+ x y)) '(1 2 3) '(1 2 . 3)) non-list?)
+    (error-test `(,map) exn:application:arity?)
+    (error-test `(,map (lambda (x y) (+ x y))) exn:application:arity?)
+    (error-test `(,map (lambda () 10) null) exn:application:map-arity?)
+    (error-test `(,map (lambda (x) 10) '(1 2) '(3 4)) exn:application:map-arity?)))
+(map-tests 'map)
+(map-tests 'for-each)
+(map-tests 'andmap)
+(map-tests 'ormap)
+
+(test (void) for-each (lambda (x) (values 1 2)) '(1 2))
+(error-test '(map (lambda (x) (values 1 2)) '(1 2)) arity?)
+
+(test #t andmap add1 null)
+(test #f ormap add1 null)
+(test #f andmap positive? '(1 -2 3))
+(test #t ormap positive? '(1 -2 3))
+(test #f andmap negative? '(1 -2 3))
+(test #t ormap negative? '(1 -2 3))
+(test 4 andmap add1 '(1 2 3))
+(test 2 ormap add1 '(1 2 3))
+
+(error-test '(ormap (lambda (x) (values 1 2)) '(1 2)) arity?)
+(error-test '(andmap (lambda (x) (values 1 2)) '(1 2)) arity?)
+
+(error-test '(ormap (lambda (x) (values 1 2)) '(1)) arity?)
+(error-test '(andmap (lambda (x) (values 1 2)) '(1)) arity?)
+
+(test -3 call-with-current-continuation
+		(lambda (exit)
+		 (for-each (lambda (x) (if (negative? x) (exit x)))
+		 	'(54 0 37 -3 245 19))
+		#t))
+(define list-length
+ (lambda (obj)
+  (call-with-current-continuation
+   (lambda (return)
+    (letrec ((r (lambda (obj) (cond ((null? obj) 0)
+				((pair? obj) (+ (r (cdr obj)) 1))
+				(else (return #f))))))
+	(r obj))))))
+(test 4 list-length '(1 2 3 4))
+(test #f list-length '(a b . c))
+(test '() map cadr '())
+
+;;; This tests full conformance of call-with-current-continuation.  It
+;;; is a separate test because some schemes do not support call/cc
+;;; other than escape procedures.  I am indebted to
+;;; raja@copper.ucs.indiana.edu (Raja Sooriamurthi) for fixing this
+;;; code.  The function leaf-eq? compares the leaves of 2 arbitrary
+;;; trees constructed of conses.  
+(define (next-leaf-generator obj eot)
+  (letrec ((return #f)
+	   (cont (lambda (x)
+		   (recurx obj)
+		   (set! cont (lambda (x) (return eot)))
+		   (cont #f)))
+	   (recurx (lambda (obj)
+		      (if (pair? obj)
+			  (for-each recurx obj)
+			  (call-with-current-continuation
+			   (lambda (c)
+			     (set! cont c)
+			     (return obj)))))))
+    (lambda () (call-with-current-continuation
+		(lambda (ret) (set! return ret) (cont #f))))))
+(define (leaf-eq? x y)
+  (let* ((eot (list 'eot))
+	 (xf (next-leaf-generator x eot))
+	 (yf (next-leaf-generator y eot)))
+    (letrec ((loop (lambda (x y)
+		     (cond ((not (eq? x y)) #f)
+			   ((eq? eot x) #t)
+			   (else (loop (xf) (yf)))))))
+      (loop (xf) (yf)))))
+(define (test-cont)
+  (newline)
+  (display ";testing continuations; ")
+  (SECTION 6 9)
+  (test #t leaf-eq? '(a (b (c))) '((a) b c))
+  (test #f leaf-eq? '(a (b (c))) '((a) b c d))
+  '(report-errs))
+
+(define (test-cc-values test-call/cc)
+  (test '(a b c)
+	call-with-values
+	(lambda ()
+	  (test-call/cc
+	   (lambda (k)
+	     (dynamic-wind
+	      void
+	      (lambda ()
+		(k 'a 'b 'c))
+	      (lambda ()
+		(values 1 2))))))
+	list)
+
+  (test 1 dynamic-wind
+	(lambda () (test-call/cc void))
+	(lambda () 1)
+	(lambda () (test-call/cc void)))
+
+  ; Try devious jumping with pre- and post-thunks:
+  (test 2 test-call/cc
+	(lambda (exit)
+	  (dynamic-wind
+	   (lambda () (exit 2))
+	   void
+	   void)))
+  (test 3 test-call/cc
+	(lambda (exit)
+	  (dynamic-wind
+	   void
+	   void
+	   (lambda () (exit 3)))))
+
+  (let ([rv
+	 (lambda (get-v)
+	   (let ([x 0])
+	     (test-call/cc
+	      (lambda (exit)
+		(dynamic-wind
+		 void
+		 (lambda () (exit))
+		 (lambda () (set! x (get-v))))))
+	     x))]
+	[r56
+	 (lambda ()
+	   (let ([x 0]
+		 [y 1]
+		 [c1 #f])
+	     (dynamic-wind
+	      (lambda () (set! x (add1 x)))
+	      (lambda () 
+		(let/cc k (set! c1 k))
+		(if (>= x 5)
+		    (set! c1 #f)))
+	      (lambda () (set! y (add1 y))))
+	     (when c1 (c1))
+	     (list x y)))]
+	[rx.y
+	 (lambda (get-x get-y)
+	   (let ([c1 #f]
+		 [x 0]
+		 [y 0])
+	     (let ([v
+		    (dynamic-wind
+		     (lambda () (set! y x))
+		     (lambda () (let/cc k (set! c1 k)))
+		     (lambda () 
+		       (set! x (get-x))
+		       (when c1
+			     ((begin0
+			       c1
+			       (set! c1 #f))
+			      (get-y)))))])
+	       (cons y v))))]
+	[rv2
+	 (lambda (get-v)
+	   (let ([c1 #f]
+		 [give-up #f])
+	     (test-call/cc
+	      (lambda (exit)
+		(dynamic-wind
+		 (lambda () (when give-up (give-up (get-v))))
+		 (lambda () (let/cc k (set! c1 k)))
+		 (lambda () (set! give-up exit) (c1)))))))]
+	[r10-11-12
+	 (lambda ()
+	   (let ([c2 #f]
+		 [x 10]
+		 [y 11])
+	     (let ([v (dynamic-wind
+		       (lambda () (set! y (add1 y)))
+		       (lambda () (begin0 x (set! x (add1 x))))
+		       (lambda () (let/cc k (set! c2 k))))])
+	       (when c2 ((begin0
+			  c2
+			  (set! c2 #f))))
+	       (list v x y))))]
+	[r13.14
+	 (lambda ()
+	   (let ([c0 #f]
+		 [x 11]
+		 [y 12])
+	     (dynamic-wind
+	      (lambda () (let/cc k (set! c0 k)))
+	      (lambda () (set! x (add1 x)))
+	      (lambda () (set! y (add1 y))
+		      (when c0 ((begin0
+				 c0
+				 (set! c0 #f))))))
+	     (cons x y)))]
+	[ra-b-a-b
+	 (lambda (get-a get-b)
+	   (let ([l null])
+	     (let ((k-in (test-call/cc (lambda (k1)
+					 (dynamic-wind
+					  (lambda () (set! l (append l (list (get-a)))))
+					  (lambda ()
+					    (call/cc (lambda (k2) (k1 k2))))
+					  (lambda ()  (set! l (append l (list (get-b))))))))))
+	       (k-in (lambda (v) l)))))])
+
+  (test 4 rv (lambda () 4))
+  (test '(5 6) r56)
+
+  (test '(7 . 8) rx.y (lambda () 7) (lambda () 8))
+
+  (test 9 rv2 (lambda () 9))
+
+  (test '(10 11 12) r10-11-12)
+
+  (test '(13 . 14) r13.14)
+
+  ; !!! fixed in 50:
+  (test '(enter exit enter exit)
+	ra-b-a-b (lambda () 'enter) (lambda () 'exit))
+
+  (test '((13 . 14) (10 11 12) (13 . 14) (10 11 12))
+	ra-b-a-b r13.14 r10-11-12)
+  (test '((10 11 12) (13 . 14) (10 11 12) (13 . 14))
+	ra-b-a-b r10-11-12 r13.14)
+
+  (test '((enter exit enter exit)
+	  (exit enter exit enter)
+	  (enter exit enter exit)
+	  (exit enter exit enter))
+	ra-b-a-b 
+	(lambda () (ra-b-a-b (lambda () 'enter) (lambda () 'exit)))
+	(lambda () (ra-b-a-b (lambda () 'exit) (lambda () 'enter))))
+
+  (test '(enter exit enter exit)
+	rv (lambda () (ra-b-a-b (lambda () 'enter) (lambda () 'exit))))
+  (test '(enter exit enter exit)
+	rv2 (lambda () (ra-b-a-b (lambda () 'enter) (lambda () 'exit))))
+
+  (test '(10 11 12) rv r10-11-12)
+  (test '(10 11 12) rv2 r10-11-12)
+
+  (test '(13 . 14) rv r13.14)
+  (test '(13 . 14) rv2 r13.14)
+
+  ))
+	      
+
+(test-cc-values call/cc)
+(test-cc-values call/ec)
+
+(arity-test call/cc 1 1)
+(arity-test call/ec 1 1)
+(error-test '(call/cc 4))
+(error-test '(call/cc (lambda () 0)))
+(error-test '(call/ec 4))
+(error-test '(call/ec (lambda () 0)))
+
+(test #t primitive? car)
+(test #f primitive? leaf-eq?)
+(arity-test primitive? 1 1)
+
+(test 1 arity arity)
+(test 2 arity cons)
+(test (make-arity-at-least 1) arity >)
+(test (list 0 1) arity current-output-port)
+(test (list 1 3 (make-arity-at-least 5))
+      arity (case-lambda [(x) 0] [(x y z) 1] [(x y z w u . rest) 2]))
+(arity-test arity 1 1)
+
+(test #t procedure-arity-includes? cons 2)
+(test #f procedure-arity-includes? cons 0)
+(test #f procedure-arity-includes? cons 3)
+(test #t procedure-arity-includes? list 3)
+(test #t procedure-arity-includes? list 3000)
+(test #t procedure-arity-includes? (lambda () 0) 0)
+(test #f procedure-arity-includes? (lambda () 0) 1)
+(test #f procedure-arity-includes? cons 10000000000000000000000000000)
+(test #t procedure-arity-includes? list 10000000000000000000000000000)
+(test #t procedure-arity-includes? (lambda x x) 10000000000000000000000000000)
+
+(error-test '(procedure-arity-includes? cons -1))
+(error-test '(procedure-arity-includes? cons 1.0))
+(error-test '(procedure-arity-includes? 'cons 1))
+
+(arity-test procedure-arity-includes? 2 2)
+
+(newline)
+(display ";testing scheme 4 functions; ")
+(SECTION 6 7)
+(test '(#\P #\space #\l) string->list "P l")
+(test '() string->list "")
+(test "1\\\"" list->string '(#\1 #\\ #\"))
+(test "" list->string '())
+(arity-test list->string 1 1)
+(arity-test string->list 1 1)
+(error-test '(string->list 'hello))
+(error-test '(list->string 'hello))
+(error-test '(list->string '(#\h . #\e)))
+(SECTION 6 8)
+(test '(dah dah didah) vector->list '#(dah dah didah))
+(test '() vector->list '#())
+(test '#(dididit dah) list->vector '(dididit dah))
+(test '#() list->vector '())
+(arity-test list->vector 1 1)
+(arity-test vector->list 1 1)
+(error-test '(vector->list 'hello))
+(error-test '(list->vector 'hello))
+(error-test '(list->vector '(#\h . #\e)))
+
+(test-cont)
+
+(report-errs)
+
+"last item in file"
diff --git a/collects/tests/mzscheme/censor.ss b/collects/tests/mzscheme/censor.ss
new file mode 100644
index 0000000..52ef262
--- /dev/null
+++ b/collects/tests/mzscheme/censor.ss
@@ -0,0 +1,30 @@
+
+; run a thunk using a censor that removes dangerous chars from a 
+; string for printing to a terminal
+(lambda (thunk)
+  (let ([censor (lambda (s)
+		  (list->string
+		   (let loop ([s (string->list s)])
+		     (if (null? s)
+			 null
+			 (let ([c (car s)])
+			   (cond
+			    [(and (not (char-whitespace? c)) (or (char<=? c #\space) (char>=? c #\200)))
+			     (append (cons #\{ (string->list 
+						(number->string 
+						 (char->integer c))))
+				     (cons #\} (loop (cdr s))))]
+			    [else
+			     (cons c (loop (cdr s)))]))))))])
+    (let* ([oldp (current-output-port)]
+	   [cp (make-output-port
+		(lambda (s)
+		  (display (censor s) oldp))
+		void)])
+      (dynamic-wind
+       (lambda () (current-output-port cp))
+       thunk
+       (lambda ()
+	 (current-output-port oldp))))))
+
+
diff --git a/collects/tests/mzscheme/cmdline.ss b/collects/tests/mzscheme/cmdline.ss
new file mode 100644
index 0000000..618422d
--- /dev/null
+++ b/collects/tests/mzscheme/cmdline.ss
@@ -0,0 +1,159 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'COMMAND-LINE)
+
+(require-library "cmdline.ss")
+
+(define (r-append opt . rest)
+  (append opt (list (list->vector rest))))
+
+(test '("-bye" #())
+      parse-command-line
+      "test"
+      #("--hi" "-bye")
+      (list 
+       (list
+	'multi
+	(list (list "--hi")
+	      (lambda (flag v) v)
+	      (list "Hello" "x"))))
+      r-append
+      '("arg"))
+
+(test '("1" "2" #("3"))
+      parse-command-line
+      "test"
+      #("-xi" "1" "2" "3")
+      (list 
+       (list
+       'multi
+	(list (list "-x" "-i")
+	      (lambda (flag v) v)
+	      (list "x or i" "x"))))
+      r-append
+      '("arg"))
+
+(test '(("-x" "a" "b") ("-i") #())
+      parse-command-line
+      "test"
+      #("-xi" "a" "b")
+      (list 
+       (list
+	'multi
+	(list (list "-x" "-i")
+	      list
+	      (list "xi"))))
+      r-append
+      '("arg"))
+
+(test '("--simple" ("-x" . "a") ("-i" . "b") #())
+      parse-command-line
+      "test"
+      #("--simple" "-xi" "a" "b")
+      (list 
+       (list
+	'multi
+	(list (list "--simple") (lambda (v) v) (list "S"))
+	(list (list "-x" "-i")
+	      cons
+	      (list "xi" "v"))))
+      r-append
+      '("arg"))
+
+(test '(("-x" "a" "c") ("-i" . "b") #("d"))
+      parse-command-line
+      "test"
+      #("-xi" "a" "c" "b" "d")
+      (list 
+       (list
+	'multi
+	(list (list "-x")
+	      (lambda (x y z) (list x y z))
+	      (list "X" "y" "z"))
+	(list (list "-i")
+	      cons
+	      (list "i" "v"))))
+      r-append
+      '("arg"))
+
+(define (test-end-flags v include?)
+  (test (list
+	 (list->vector
+	  (let ([l '("-xi" "--bad" "--")])
+	    (if include?
+		(cons v l)
+		l))))
+	parse-command-line
+	"test"
+	(vector v "-xi" "--bad" "--")
+	(list 
+	 (list
+	  'multi
+	  (list (list "-x" "-i")
+		list
+		(list "xi"))))
+	r-append
+	'("arg")))
+
+(test-end-flags "1" #t)
+(test-end-flags "+" #t)
+(test-end-flags "-" #t)
+(test-end-flags "--" #f)
+(test-end-flags "-1" #t)
+(test-end-flags "+1" #t)
+(test-end-flags "-1.4" #t)
+(test-end-flags "+1999.0" #t)
+
+(define (test-bad-flag v name) ; -h and -i defined
+  (test 'yes-it-worked
+	(lambda (x-ignored y-ignored)
+	  (with-handlers ([void
+			   (lambda (exn)
+			     (if (regexp-match
+				  (format "unknown flag: ~s" name)
+				  (exn-message exn))
+				 'yes-it-worked
+				 exn))])
+	    (parse-command-line
+	     "test"
+	     (vector name "--")
+	     (list 
+	      (list
+	       'multi
+	       (list (list "-x" "-i")
+		     list
+		     (list "x i"))))
+	     r-append
+	     '("arg"))))
+	v name))
+
+(test-bad-flag "--ok" "--ok")
+(test-bad-flag "-xbi" "-b")
+
+(test (void) parse-command-line "test" #() null void '("arg"))
+(test (void) parse-command-line "test" #() (list (list 'once-each (list null void '("")))) void '("arg"))
+(test (void) parse-command-line "test" #() (list (list 'once-any (list null void '("")))) void '("arg"))
+(test (void) parse-command-line "test" #() (list (list 'multi (list null void '("")))) void '("arg"))
+(test (void) parse-command-line "test" #() (list (list 'multi)) void '("arg"))
+
+(test "2" parse-command-line "test" #("1" "2") null (lambda (a b c) c) '("b" "c"))
+
+(error-test '(parse-command-line 'test #() null void '("arg")))
+(error-test '(parse-command-line "test" 9 null void '("arg")))
+(error-test '(parse-command-line "test" #() (list 0) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'malti)) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list 0 void '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list 0) void '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "hi") void '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "--") void '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "-xi") void '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "-x") (lambda () null) '("")))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "--xi") void ""))) void '("arg")))
+(error-test '(parse-command-line "test" #() (list (list 'multi (list (list "--xi") void '("" a)))) void '("arg")))
+(error-test '(parse-command-line "test" #() null (lambda () null) null))
+
+(error-test '(parse-command-line "test" #() null (lambda (x y) null) null) exn:user?)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/compfile.ss b/collects/tests/mzscheme/compfile.ss
new file mode 100644
index 0000000..4cd9181
--- /dev/null
+++ b/collects/tests/mzscheme/compfile.ss
@@ -0,0 +1,11 @@
+
+(require-library "compat.ss")
+(require-library "compat.ss")
+(require-library "compat.ss")
+
+(defmacro test (x y) (string-append x y))
+
+(test "a" "b")
+
+(load x)
+(require-library)
diff --git a/collects/tests/mzscheme/compile.ss b/collects/tests/mzscheme/compile.ss
new file mode 100644
index 0000000..47fb239
--- /dev/null
+++ b/collects/tests/mzscheme/compile.ss
@@ -0,0 +1,83 @@
+
+; Tests compilation and writing/reading compiled code
+;  by setting the eval handler and running all tests
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(define file
+  (if #f
+      (open-output-file "x" 'replace)
+      (make-output-port void void)))
+
+(define try-one
+  (lambda (e)
+    (let ([c (compile e)]
+	  [p (open-output-string)])
+      (write c p)
+      (let ([s (get-output-string p)])
+	; (write (string->list s)) (newline)
+	(let ([e (parameterize ([read-accept-compiled #t])
+		     (read (open-input-string s)))])
+	  (eval e))))))
+
+(letrec ([orig (current-eval)]
+	 [orig-load (current-load)]
+	 [my-load
+	  (lambda (filename)
+	    (let ([f (open-input-file filename)])
+	      (dynamic-wind
+	       void
+	       (lambda ()
+		 (let loop ([results (list (void))])
+		   (let ([v (parameterize ([read-accept-compiled #t])
+			       (read f))])
+		     (if (eof-object? v)
+			 (apply values results)
+			 (loop (call-with-values
+				(lambda () (my-eval v orig))
+				list))))))
+	       (lambda ()
+		 (close-input-port f)))))]
+	 [my-eval
+	  (case-lambda 
+	   [(x next-eval)
+	    (let ([p (open-output-string)]
+		  [c (compile x)])
+	      (write c p)
+	      (let ([s (get-output-string p)])
+		; (display s file) (newline file)
+		(let ([e (parameterize ([read-accept-compiled #t])
+			   (read (open-input-string s)))])
+		  ; (write e file) (newline file)
+		  (parameterize ([current-eval next-eval])
+		    (orig e)))))]
+	   [(x) (my-eval x orig)])])
+  (dynamic-wind
+   (lambda ()
+     (set! teval (lambda (x) (my-eval x my-eval)))
+     ; (read-accept-compiled #t)
+     (current-eval my-eval)
+     (current-load my-load))
+   (lambda ()
+     (load-relative "all.ss"))
+   (lambda ()
+     (set! teval eval)
+     (close-output-port file)
+     ; (read-accept-compiled #f)
+     (current-eval orig)
+     (current-load orig-load))))
+
+; Check compiled number I/O:
+(let ([l (let loop ([n -512][l null])
+	   (if (= n 513)
+	       l
+	       (loop (add1 n) (cons n l))))]
+      [p (open-output-string)])
+  (write (compile `(quote ,l)) p)
+  (let ([s (open-input-string (get-output-string p))])
+    (let ([l2 (parameterize ([read-accept-compiled #t])
+		    (eval (read s)))])
+      (test #t equal? l l2))))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/compilex.ss b/collects/tests/mzscheme/compilex.ss
new file mode 100644
index 0000000..5e417fb
--- /dev/null
+++ b/collects/tests/mzscheme/compilex.ss
@@ -0,0 +1,14 @@
+
+; Tests simple compilation by setting the eval handler and
+;  running all tests
+
+(let ([orig (current-eval)])
+  (dynamic-wind
+   (lambda ()
+     (current-eval
+      (lambda (x)
+	(orig (compile x)))))
+   (lambda ()
+     (load "all.ss"))
+   (lambda ()
+     (current-eval orig))))
diff --git a/collects/tests/mzscheme/date.ss b/collects/tests/mzscheme/date.ss
new file mode 100644
index 0000000..10671b7
--- /dev/null
+++ b/collects/tests/mzscheme/date.ss
@@ -0,0 +1,42 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'date)
+
+(require-library "date.ss")
+
+(define (test-find s m h d mo y)
+  (let* ([secs (find-seconds s m h d mo y)]
+	 [date (seconds->date secs)])
+    (test #t 'same
+	  (and (= s (date-second date))
+	       (= m (date-minute date))
+	       (= h (date-hour date))
+	       (= d (date-day date))
+	       (= mo (date-month date))
+	       (= y (date-year date))))))
+
+(test-find 0 0 0 1 4 1975)
+(test-find 0 0 0 1 4 2005)
+
+; Bad dates
+(error-test '(find-seconds 0 0 0 0 0 1990) exn:user?)
+(error-test '(find-seconds 0 0 0 0 1 1990) exn:user?)
+(error-test '(find-seconds 0 0 0 1 0 1990) exn:user?)
+
+; Early/late
+(error-test '(find-seconds 0 0 0 1 1 1490) exn:user?)
+(error-test '(find-seconds 0 0 0 1 1 2890) exn:user?)
+
+; 1990 April 1 was start of daylight savings:
+(test-find 0 0 1 1 4 1990) ; ok
+(let ([s (find-seconds 1 0 3 1 4 1990)]) ; ok
+  (when (date-dst? (seconds->date s))
+	; We have daylight savings here; 2:01 AM doesn't exist
+	(error-test '(find-seconds 0 1 2 1 4 1990) exn:user?)
+	; This date is ambiguous; find-seconds should find
+	;  one of the two possible values, though:
+	(test-find 0 30 1 27 10 1996)))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/deep.ss b/collects/tests/mzscheme/deep.ss
new file mode 100644
index 0000000..6232160
--- /dev/null
+++ b/collects/tests/mzscheme/deep.ss
@@ -0,0 +1,47 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'deep)
+
+; Test deep stacks
+
+(define proc-depth 100000)
+
+(test (- proc-depth) 'deep-recursion (let loop ([n proc-depth])
+				       (if (zero? n)
+					   0
+					   (sub1 (loop (sub1 n))))))
+
+(define paren-port
+  (let* ([depth 50000]
+	 [closing? #f]
+	 [count depth])
+    (make-input-port
+     (lambda ()
+       (cond
+	[closing?
+	 (if (= count depth)
+	     eof
+	     (begin
+	       (set! count (add1 count))
+	       #\) ))]
+	[else
+	 (set! count (sub1 count))
+	 (when (zero? count)
+	       (set! closing? #t))
+	 #\(]))
+     (lambda () #t)
+     void)))
+
+(define deep-list (read paren-port))
+
+(test #t 'read-deep (pair? deep-list))
+
+(define s (open-output-string))
+(display deep-list s)
+
+(test #t 'equal? (equal? deep-list (read (open-input-string (get-output-string s)))))
+
+(report-errs)
+
diff --git a/collects/tests/mzscheme/em-imp.ss b/collects/tests/mzscheme/em-imp.ss
new file mode 100644
index 0000000..69a97a0
--- /dev/null
+++ b/collects/tests/mzscheme/em-imp.ss
@@ -0,0 +1,467 @@
+;;; -*- scheme -*-
+;;; Fortran-style implementation of an EM clustering algorithm.
+;;;
+;;; Written by Jeffrey Mark Siskind (qobi@cs.toronto.edu)
+;;; R4RS-ified by by Lars Thomas Hansen (lth@cs.uoregon.edu)
+;;; Random number generator by Ozan Yigit.
+;;;
+;;; To run: (run-benchmark)
+;;; You must provide your own timer function.
+;;;
+;;; Some benchmark times:
+;;;
+;;; Chez Scheme 4.1 for SunOS running on Sparc 10/51 (1MB,96MB,50MHz), Solaris:
+;;;   Optimize-level 2: 112s run (CPU), 2.8s gc, 326 MB allocated, 1181 GCs
+;;;   Optimize-level 3:  79s run (CPU), 2.8s gc, 326 MB allocated, 1163 GCs
+
+(define make-model vector)
+(define (model-pi model) (vector-ref model 0))
+(define (set-model-pi! model x) (vector-set! model 0 x))
+(define (model-mu model) (vector-ref model 1))
+(define (model-sigma model) (vector-ref model 2))
+(define (model-log-pi model) (vector-ref model 3))
+(define (set-model-log-pi! model x) (vector-set! model 3 x))
+(define (model-sigma-inverse model) (vector-ref model 4))
+(define (model-log-determinant-sigma model) (vector-ref model 5))
+(define (set-model-log-sigma-determinant! model x) (vector-set! model 5 x))
+
+;---------------------------------------------------------------------------
+; Minimal Standard Random Number Generator
+; Park & Miller, CACM 31(10), Oct 1988, 32 bit integer version.
+; better constants, as proposed by Park.
+; By Ozan Yigit
+
+(define *seed* 1)
+
+(define (srand seed)
+  (set! *seed* seed)
+  *seed*)
+
+(define (rand)
+  (let ((A 48271)
+        (M 2147483647)
+        (Q 44488)
+        (R 3399))
+    (let* ((hi (quotient *seed* Q))
+           (lo (modulo *seed* Q))
+           (test (- (* A lo) (* R hi))))
+      (if (> test 0)
+          (set! *seed* test)
+          (set! *seed* (+ test M)))))
+  *seed*)
+
+;---------------------------------------------------------------------------
+
+(define (panic s) (error 'panic s))
+
+(define *rand-max* 2147483648)
+
+(define log-math-precision 35.0)
+
+(define minus-infinity (- *rand-max*))
+
+(define first car)
+
+(define second cadr)
+
+(define rest cdr)
+
+(define (reduce f l i)
+ (cond ((null? l) i)
+       ((null? (rest l)) (first l))
+       (else (let loop ((l (rest l)) (c (first l)))
+	      (if (null? l) c (loop (rest l) (f c (first l))))))))
+
+(define (every-n p n)
+ (let loop ((i 0)) (or (>= i n) (and (p i) (loop (+ i 1))))))
+
+(define (sum f n)
+ (let loop ((n (- n 1)) (c 0.0))
+  (if (negative? n) c (loop (- n 1) (+ c (f n))))))
+
+(define (add-exp e1 e2)
+ (let* ((e-max (max e1 e2))
+	(e-min (min e1 e2))
+	(factor (floor e-min)))
+  (if (= e-max minus-infinity)
+      minus-infinity
+      (if (> (- e-max factor) log-math-precision)
+	  e-max
+	  (+ (log (+ (exp (- e-max factor)) (exp (- e-min factor))))
+	     factor)))))
+
+(define (map-n f n)
+ (let loop ((i 0) (c '()))
+  (if (< i n) (loop (+ i 1) (cons (f i) c)) (reverse c))))
+
+(define (map-n-vector f n)
+ (let ((v (make-vector n)))
+  (let loop ((i 0))
+   (if (< i n)
+       (begin (vector-set! v i (f i))
+	      (loop (+ i 1)))))
+  v))
+
+(define (remove-if-not p l)
+ (let loop ((l l) (c '()))
+  (cond ((null? l) (reverse c))
+	((p (first l)) (loop (rest l) (cons (first l) c)))
+	(else (loop (rest l) c)))))
+
+(define (positionv x l)
+ (let loop ((l l) (i 0))
+  (cond ((null? l) #f)
+	((eqv? x (first l)) i)
+	(else (loop (rest l) (+ i 1))))))
+
+(define (make-matrix m n)
+  (map-n-vector (lambda (i) (make-vector n)) m))
+
+(define (make-matrix-initial m n initial)
+  (map-n-vector (lambda (i) (make-vector n initial)) m))
+
+(define (matrix-rows a) (vector-length a))
+
+(define (matrix-columns a) (vector-length (vector-ref a 0)))
+
+(define (matrix-ref a i j) (vector-ref (vector-ref a i) j))
+
+(define (matrix-set! a i j x) (vector-set! (vector-ref a i) j x))
+
+(define (matrix-row-ref a i) (vector-ref a i))
+
+(define (matrix-row-set! a i v) (vector-set! a i v))
+
+(define (determinant a)
+ (if (not (= (matrix-rows a) (matrix-columns a)))
+     (panic "Can only find determinant of a square matrix"))
+ (call-with-current-continuation
+  (lambda (return)
+   (let* ((n (matrix-rows a))
+	  (b (make-matrix n n))
+	  (d 1.0))
+    (do ((i 0 (+ i 1))) ((= i n))
+     (do ((j 0 (+ j 1))) ((= j n)) (matrix-set! b i j (matrix-ref a i j))))
+    (do ((i 0 (+ i 1))) ((= i n))
+     ;; partial pivoting reduces rounding errors
+     (let ((greatest (abs (matrix-ref b i i)))
+	   (index i))
+      (do ((j (+ i 1) (+ j 1))) ((= j n))
+       (let ((x (abs (matrix-ref b j i))))
+	(if (> x greatest) (begin (set! index j) (set! greatest x)))))
+      (if (= greatest 0.0) (return 0.0))
+      (if (not (= index i))
+       (let ((v (matrix-row-ref b i)))
+	(matrix-row-set! b i (matrix-row-ref b index))
+	(matrix-row-set! b index v)
+	(set! d (- d))))
+      (let ((c (matrix-ref b i i)))
+       (set! d (* d c))
+       (do ((j i (+ j 1))) ((= j n))
+	(matrix-set! b i j (/ (matrix-ref b i j) c)))
+       (do ((j (+ i 1) (+ j 1))) ((= j n))
+	(let ((e (matrix-ref b j i)))
+	 (do ((k (+ i 1) (+ k 1))) ((= k n))
+	  (matrix-set!
+	   b j k (- (matrix-ref b j k) (* e (matrix-ref b i k))))))))))
+    d))))
+
+(define (invert-matrix! a b)
+ (if (not (= (matrix-rows a) (matrix-columns a)))
+  (panic "Can only invert a square matrix"))
+ (let* ((n (matrix-rows a))
+	(c (make-matrix n n)))
+  (do ((i 0 (+ i 1))) ((= i n))
+   (do ((j 0 (+ j 1))) ((= j n))
+    (matrix-set! b i j 0.0)
+    (matrix-set! c i j (matrix-ref a i j))))
+  (do ((i 0 (+ i 1))) ((= i n)) (matrix-set! b i i 1.0))
+  (do ((i 0 (+ i 1))) ((= i n))
+   (if (zero? (matrix-ref c i i))
+       (call-with-current-continuation
+	(lambda (return)
+	  (do ((j 0 (+ j 1))) ((= j n))
+	    (if (and (> j i) (not (zero? (matrix-ref c j i))))
+		(begin
+		  (let ((e (vector-ref c i)))
+		    (vector-set! c i (vector-ref c j))
+		    (vector-set! c j e))
+		  (let ((e (vector-ref b i)))
+		    (vector-set! b i (vector-ref b j))
+		    (vector-set! b j e))
+		  (return #f))))
+	  (panic "Matrix is singular"))))
+   (let ((d (/ (matrix-ref c i i))))
+    (do ((j 0 (+ j 1))) ((= j n))
+     (matrix-set! c i j (* d (matrix-ref c i j)))
+     (matrix-set! b i j (* d (matrix-ref b i j))))
+    (do ((k 0 (+ k 1))) ((= k n))
+     (let ((d (- (matrix-ref c k i))))
+      (if (not (= k i))
+       (do ((j 0 (+ j 1))) ((= j n))
+	(matrix-set!
+	 c k j (+ (matrix-ref c k j) (* d (matrix-ref c i j))))
+	(matrix-set!
+	 b k j (+ (matrix-ref b k j) (* d (matrix-ref b i j))))))))))))
+
+(define (jacobi! a)
+ (if (not (and (= (matrix-rows a) (matrix-columns a))
+	      (every-n (lambda (i)
+			(every-n (lambda (j)
+				  (= (matrix-ref a i j) (matrix-ref a j i)))
+				 (matrix-rows a)))
+		       (matrix-rows a))))
+  (panic "Can only compute eigenvalues/eigenvectors of a symmetric matrix"))
+ (let* ((n (matrix-rows a))
+	(d (make-vector n))
+	(v (make-matrix-initial n n 0.0))
+	(b (make-vector n))
+	(z (make-vector n 0.0)))
+  (do ((ip 0 (+ ip 1))) ((= ip n))
+   (matrix-set! v ip ip 1.0)
+   (vector-set! b ip (matrix-ref a ip ip))
+   (vector-set! d ip (matrix-ref a ip ip)))
+  (let loop ((i 0))
+   (if (> i 50) (panic "Too many iterations in JACOBI!"))
+   (let ((sm (sum (lambda (ip)
+		   (sum (lambda (ir)
+			 (let ((iq (+ ip ir 1)))
+			  (abs (matrix-ref a ip iq))))
+			(- n ip 1)))
+		  (- n 1))))
+    (if (not (zero? sm))
+	(begin
+	  (let ((tresh (if (< i 3) (/ (* 0.2 sm) (* n n)) 0.0)))
+	    (do ((ip 0 (+ ip 1))) ((= ip (- n 1)))
+	      (do ((ir 0 (+ ir 1))) ((= ir (- n ip 1)))
+		(let* ((iq (+ ip ir 1))
+		       (g (* 100.0 (abs (matrix-ref a ip iq)))))
+		  (cond
+		   ((and (> i 3)
+			 (= (+ (abs (vector-ref d ip)) g)
+			    (abs (vector-ref d ip)))
+			 (= (+ (abs (vector-ref d iq)) g)
+			    (abs (vector-ref d iq))))
+		    (matrix-set! a ip iq 0.0))
+		   ((> (abs (matrix-ref a ip iq)) tresh)
+		    (let* ((h (- (vector-ref d iq) (vector-ref d ip)))
+			   (t (if (= (+ (abs h) g) (abs h))
+				  (/ (matrix-ref a ip iq) h)
+				  (let ((theta (/ (* 0.5 h)
+						  (matrix-ref a ip iq))))
+				    (if (negative? theta)
+					(- (/ (+ (abs theta)
+						 (sqrt (+ (* theta theta) 1.0)))))
+					(/ (+ (abs theta)
+					      (sqrt (+ (* theta theta) 1.0))))))))
+			   (c (/ (sqrt (+ (* t t) 1.0))))
+			   (s (* t c))
+			   (tau (/ s (+ c 1.0)))
+			   (h (* t (matrix-ref a ip iq))))
+		      (define (rotate a i j k l)
+			(let ((g (matrix-ref a i j))
+			      (h (matrix-ref a k l)))
+			  (matrix-set! a i j (- g (* s (+ h (* g tau)))))
+			  (matrix-set! a k l (+ h (* s (- g (* h tau)))))))
+		      (vector-set! z ip (- (vector-ref z ip) h))
+		      (vector-set! z iq (+ (vector-ref z iq) h))
+		      (vector-set! d ip (- (vector-ref d ip) h))
+		      (vector-set! d iq (+ (vector-ref d iq) h))
+		      (matrix-set! a ip iq 0.0)
+		      (do ((j 0 (+ j 1))) ((= j n))
+			(cond ((< j ip) (rotate a j ip j iq))
+			      ((< ip j iq) (rotate a ip j j iq))
+			      ((< iq j) (rotate a ip j iq j)))
+			(rotate v j ip j iq)))))))))
+	  (do ((ip 0 (+ ip 1))) ((= ip n))
+	    (vector-set! b ip (+ (vector-ref b ip) (vector-ref z ip)))
+	    (vector-set! d ip (vector-ref b ip))
+	    (vector-set! z ip 0.0))
+	  (loop (+ i 1))))))
+  (do ((i 0 (+ i 1))) ((= i (- n 1)))
+   (let ((k i)
+	 (p (vector-ref d i)))
+    (do ((l 0 (+ l 1))) ((= l (- n i 1)))
+     (let* ((j (+ i l 1)))
+      (if (>= (vector-ref d j) p)
+	  (begin (set! k j) (set! p (vector-ref d j))))))
+    (if (not (= k i))
+	(begin (vector-set! d k (vector-ref d i))
+	       (vector-set! d i p)
+	       (do ((j 0 (+ j 1))) ((= j n))
+		 (let ((p (matrix-ref v j i)))
+		   (matrix-set! v j i (matrix-ref v j k))
+		   (matrix-set! v j k p)))))))
+  (list d v)))
+
+(define (clip-eigenvalues! a v)
+ (let* ((j (jacobi! a))
+	(l (first j))
+	(e (second j)))
+  (do ((k1 0 (+ k1 1))) ((= k1 (vector-length a)))
+   (let ((a-k1 (vector-ref a k1))
+	 (e-k1 (vector-ref e k1)))
+    (do ((k2 0 (+ k2 1))) ((= k2 (vector-length a-k1)))
+     (let ((e-k2 (vector-ref e k2))
+	   (s 0.0))
+      (do ((k 0 (+ k 1))) ((= k (vector-length a)))
+       (set! s (+ s (* (max (vector-ref v k) (vector-ref l k))
+		       (vector-ref e-k1 k)
+		       (vector-ref e-k2 k)))))
+      (vector-set! a-k1 k2 s)))))))
+
+;;; EM
+
+(define (e-step! x z models)
+ (do ((i 0 (+ i 1))) ((= i (vector-length x)))
+  (let ((xi (vector-ref x i))
+	(zi (vector-ref z i)))
+   (do ((j 0 (+ j 1))) ((= j (vector-length models)))
+    ;; Compute for each model.
+    (let* ((model (vector-ref models j))
+	   (log-pi (model-log-pi model))
+	   (mu (model-mu model))
+	   (sigma-inverse (model-sigma-inverse model))
+	   (log-determinant-sigma (model-log-determinant-sigma model))
+	   (t 0.0))
+     ;; Compute likelihoods (note: up to constant for all models).
+     (set! t 0.0)
+     (do ((k1 0 (+ k1 1))) ((= k1 (vector-length xi)))
+      (let ((sigma-inverse-k1 (vector-ref sigma-inverse k1)))
+       (do ((k2 0 (+ k2 1))) ((= k2 (vector-length xi)))
+	(set! t (+ t (* (- (vector-ref xi k1) (vector-ref mu k1))
+			(vector-ref sigma-inverse-k1 k2)
+			(- (vector-ref xi k2) (vector-ref mu k2))))))))
+     (vector-set! zi j (- log-pi (* 0.5 (+ log-determinant-sigma t))))))))
+ (let ((l 0.0))
+  (do ((i 0 (+ i 1))) ((= i (vector-length x)))
+   (let ((s minus-infinity)
+	 (zi (vector-ref z i)))
+    ;; Normalize ownerships to sum to one.
+    (do ((j 0 (+ j 1))) ((= j (vector-length models)))
+     (set! s (add-exp s (vector-ref zi j))))
+    (do ((j 0 (+ j 1))) ((= j (vector-length models)))
+     (vector-set! zi j (exp (- (vector-ref zi j) s))))
+    (set! l (+ l s))))
+  ;; Return log likelihood.
+  l))
+
+(define (m-step! x models z clip)
+ (let ((kk (vector-length (vector-ref x 0))))
+  ;; For each model, optimize parameters.
+  (do ((j 0 (+ j 1))) ((= j (vector-length models)))
+   (let* ((model (vector-ref models j))
+	  (mu (model-mu model))
+	  (sigma (model-sigma model))
+	  (s 0.0))
+    ;; Optimize values.
+    (do ((k 0 (+ k 1))) ((= k kk))
+     (do ((i 0 (+ i 1))) ((= i (vector-length x)))
+      (set! s (+ s (vector-ref (vector-ref z i) j)))))
+    (do ((k 0 (+ k 1))) ((= k kk))
+     (let ((m 0.0))
+      (do ((i 0 (+ i 1))) ((= i (vector-length x)))
+       (set! m (+ m (* (vector-ref (vector-ref z i) j)
+		       (vector-ref (vector-ref x i) k)))))
+      (vector-set! mu k (/ m s))))
+    (do ((k1 0 (+ k1 1))) ((= k1 kk))
+     (let ((sigma-k1 (vector-ref sigma k1))
+	   (mu-k1 (vector-ref mu k1)))
+      (do ((k2 0 (+ k2 1))) ((= k2 kk))
+       (let ((mu-k2 (vector-ref mu k2))
+	     (m 0.0))
+	(do ((i 0 (+ i 1))) ((= i (vector-length x)))
+	 (set! m (+ m (* (vector-ref (vector-ref z i) j)
+			 (- (vector-ref (vector-ref x i) k1) mu-k1)
+			 (- (vector-ref (vector-ref x i) k2) mu-k2)))))
+	(vector-set! sigma-k1 k2 (/ m s))))))
+    (clip-eigenvalues! sigma clip)
+    (set-model-pi! model (/ s (vector-length x)))
+    (set-model-log-pi! model (log (/ s (vector-length x))))
+    (invert-matrix! sigma (model-sigma-inverse model))
+    (set-model-log-sigma-determinant! model (log (determinant sigma)))))))
+
+(define (em! x z models clip em-kick-off-tolerance em-convergence-tolerance)
+ (let loop ((old-log-likelihood minus-infinity) (starting? #t))
+  (let ((log-likelihood (e-step! x z models)))
+   (cond
+    ((or (and starting? (> log-likelihood old-log-likelihood))
+	 (> log-likelihood (+ old-log-likelihood em-convergence-tolerance)))
+     (m-step! x models z clip)
+     (loop log-likelihood
+	   (and starting?
+		(not (= (vector-length models) 1))
+		(or (= old-log-likelihood minus-infinity)
+		    (< log-likelihood
+		       (+ old-log-likelihood em-kick-off-tolerance))))))
+    (else old-log-likelihood)))))
+
+(define (noise epsilon) (- (* 2.0 epsilon (/ (rand) *rand-max*)) epsilon))
+
+(define (initial-z ii jj)
+ (map-n-vector
+  (lambda (i)
+   (let ((zi (map-n-vector (lambda (j) (+ (/ jj) (noise (/ jj)))) jj))
+	 (s 0.0))
+    (do ((j 0 (+ j 1))) ((= j jj)) (set! s (+ s (vector-ref zi j))))
+    (do ((j 0 (+ j 1))) ((= j jj)) (vector-set! zi j (/ (vector-ref zi j) s)))
+    zi))
+  ii))
+
+(define (ems x clip em-kick-off-tolerance em-convergence-tolerance
+	     ems-convergence-tolerance)
+ (let loop ((jj 1)
+	    (old-z #f)
+	    (old-models #f)
+	    (old-log-likelihood minus-infinity))
+  (let* ((kk (vector-length (vector-ref x 0)))
+	 (z (initial-z (vector-length x) jj))
+	 (models (map-n-vector
+		  (lambda (j)
+		   (make-model 0.0
+			       (make-vector kk)
+			       (make-matrix kk kk)
+			       0.0
+			       (make-matrix kk kk)
+			       0.0))
+		  jj)))
+   (m-step! x models z clip)
+   (let ((new-log-likelihood
+	  (em!
+	   x z models clip em-kick-off-tolerance em-convergence-tolerance)))
+    (if (> (- (/ old-log-likelihood new-log-likelihood) 1.0)
+	   ems-convergence-tolerance)
+	(loop (+ jj 1) z models new-log-likelihood)
+	(list old-z old-models))))))
+
+(define (em-clusterer x clip em-kick-off-tolerance em-convergence-tolerance
+		      ems-convergence-tolerance)
+ (let* ((z-models (ems x clip em-kick-off-tolerance
+		       em-convergence-tolerance
+		       ems-convergence-tolerance))
+	(z (first z-models))
+	(models (second z-models)))
+  (e-step! x z models)
+  (let ((clusters
+	 (map-n (lambda (i)
+		 (let ((zi (vector->list (vector-ref z i))))
+		  (list i (positionv (reduce max zi minus-infinity) zi))))
+		(vector-length z))))
+   (map-n (lambda (j)
+	   (map (lambda (cluster) (vector-ref x (first cluster)))
+		(remove-if-not (lambda (cluster) (= (second cluster) j))
+			       clusters)))
+	  (vector-length (vector-ref z 0))))))
+
+(define (go)
+  (em-clusterer
+   '#(#(1.0) #(2.0) #(3.0) #(11.0) #(12.0) #(13.0)) '#(1.0) 10.0 1.0 0.01))
+
+(define (run-benchmark)
+  (srand 1)
+  (do ((i 0 (+ i 1))) ((= i 100))
+    (write (go))
+    (newline)))
+
+; eof
+
diff --git a/collects/tests/mzscheme/expand.ss b/collects/tests/mzscheme/expand.ss
new file mode 100644
index 0000000..92ab7dd
--- /dev/null
+++ b/collects/tests/mzscheme/expand.ss
@@ -0,0 +1,18 @@
+
+; Tests macro expansion by setting the eval handler and
+;  running all tests
+
+(let ([orig (current-eval)])
+  (dynamic-wind
+   (lambda ()
+     (current-eval
+      (lambda (x)
+	(orig
+	 (expand-defmacro
+	  (expand-defmacro
+	   (expand-defmacro-once
+	    (expand-defmacro-once x))))))))
+   (lambda ()
+     (load-relative "all.ss"))
+   (lambda ()
+     (current-eval orig))))
diff --git a/collects/tests/mzscheme/fact.ss b/collects/tests/mzscheme/fact.ss
new file mode 100644
index 0000000..d991f2f
--- /dev/null
+++ b/collects/tests/mzscheme/fact.ss
@@ -0,0 +1,6 @@
+(define fact
+    (lambda (n)
+      (let loop ([n n][res 1])
+	(if (zero? n)
+	    res
+	    (loop (sub1 n) (* n res))))))
diff --git a/collects/tests/mzscheme/file.ss b/collects/tests/mzscheme/file.ss
new file mode 100644
index 0000000..1cc70d1
--- /dev/null
+++ b/collects/tests/mzscheme/file.ss
@@ -0,0 +1,520 @@
+
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(define testing.ss (build-path (current-load-relative-directory) "testing.ss"))
+
+(SECTION 6 10 1)
+(test #t input-port? (current-input-port))
+(test #t output-port? (current-output-port))
+(test #t output-port? (current-error-port))
+(test (void) current-input-port (current-input-port))
+(test (void) current-output-port (current-output-port))
+(test (void) current-error-port (current-error-port))
+(test #t call-with-input-file testing.ss input-port?)
+(define this-file (open-input-file testing.ss))
+(test #t input-port? this-file)
+(close-input-port this-file)
+(define this-file (open-input-file testing.ss 'binary))
+(test #t input-port? this-file)
+(close-input-port this-file)
+(define this-file (open-input-file testing.ss 'text))
+(test #t input-port? this-file)
+(arity-test input-port? 1 1)
+(arity-test output-port? 1 1)
+(arity-test current-input-port 0 1)
+(arity-test current-output-port 0 1)
+(arity-test current-error-port 0 1)
+(error-test '(current-input-port 8))
+(error-test '(current-output-port 8))
+(error-test '(current-error-port 8))
+(error-test '(current-input-port (current-output-port)))
+(error-test '(current-output-port (current-input-port)))
+(error-test '(current-error-port (current-input-port)))
+(SECTION 6 10 2)
+(test #\; peek-char this-file)
+(arity-test peek-char 0 1)
+(test #\; read-char this-file)
+(arity-test read-char 0 1)
+(test '(define cur-section '()) read this-file)
+(arity-test read 0 1)
+(test #\( peek-char this-file)
+(test '(define errs '()) read this-file)
+(close-input-port this-file)
+(close-input-port this-file)
+(arity-test close-input-port 1 1)
+(arity-test close-output-port 1 1)
+(error-test '(peek-char 5))
+(error-test '(peek-char (current-output-port)))
+(error-test '(read-char 5))
+(error-test '(read-char (current-output-port)))
+(error-test '(read 5))
+(error-test '(read (current-output-port)))
+(error-test '(close-input-port 5))
+(error-test '(close-output-port 5))
+(error-test '(close-input-port (current-output-port)))
+(error-test '(close-output-port (current-input-port)))
+(define (check-test-file name)
+  (define test-file (open-input-file name))
+  (test #t 'input-port?
+	(call-with-input-file
+	    name
+	  (lambda (test-file)
+	    (test load-test-obj read test-file)
+	    (test #t eof-object? (peek-char test-file))
+	    (test #t eof-object? (read-char test-file))
+	    (input-port? test-file))))
+  (test #\; read-char test-file)
+  (test display-test-obj read test-file)
+  (test load-test-obj read test-file)
+  (close-input-port test-file))
+(SECTION 6 10 3)
+(define write-test-obj
+  '(#t #f #\a () 9739 -3 . #((test) "te \" \" st" "" test #() b c)))
+(define display-test-obj
+  '(#t #f a () 9739 -3 . #((test) te " " st test #() b c)))
+(define load-test-obj
+  (list 'define 'foo (list 'quote write-test-obj)))
+(let ([f (lambda (test-file)
+	   (write-char #\; test-file)
+	   (display write-test-obj test-file)
+	   (newline test-file)
+	   (write load-test-obj test-file)
+	   (output-port? test-file))])
+  (test #t call-with-output-file
+	"tmp1" f 'truncate))
+(check-test-file "tmp1")
+
+(test (string #\null #\null #\" #\null #\")
+      'write-null
+      (let ([p (open-output-string)])
+	(write-char #\null p)
+	(display (string #\null) p)
+	(write (string #\null) p)
+	(let ([s (get-output-string p)])
+	  s)))
+
+(arity-test open-input-file 1 2)
+(error-test '(open-input-file 8))
+(error-test '(open-input-file "x" 8))
+(error-test '(open-input-file "x" 'something-else))
+(error-test '(open-input-file "badfile") exn:i/o:filesystem:file?)
+
+(arity-test open-output-file 1 3)
+(error-test '(open-output-file 8))
+(error-test '(open-output-file "x" 8))
+(error-test '(open-output-file "x" 'something-else))
+(let ([conflict? exn:application:mode-conflict?]
+      [modes '(binary text)]
+      [replacement '(error replace truncate append)])
+  (for-each
+   (lambda (ones)
+     (for-each
+      (lambda (one)
+	(error-test `(open-output-file "x" ',one 'bad))
+	(error-test `(open-output-file "x" ',one 8))
+	(error-test `(open-output-file "x" 'bad ',one))
+	(error-test `(open-output-file "x" 8 ',one))
+	(error-test `(call-with-output-file "x" void ',one 'bad))
+	(error-test `(call-with-output-file "x" void ',one 8))
+	(error-test `(call-with-output-file "x" void 'bad ',one))
+	(error-test `(call-with-output-file "x" void 8 ',one))
+	(error-test `(with-output-to-file "x" void ',one 8))
+	(error-test `(with-output-to-file "x" void ',one 'bad))
+	(error-test `(with-output-to-file "x" void 8 ',one))
+	(error-test `(with-output-to-file "x" void 'bad ',one))
+	(for-each
+	 (lambda (two)
+	   (error-test `(open-output-file "x" ',one ',two) conflict?)
+	   (error-test `(call-with-output-file "x" void ',one ',two) conflict?)
+	   (error-test `(with-output-to-file "x" void ',one ',two) conflict?))
+	 ones))
+      ones))
+   `(,modes ,replacement)))
+(error-test '(open-output-file (build-path (current-directory) "baddir" "x"))
+	    exn:i/o:filesystem:file?)
+
+(delete-file "tmp4")
+(close-output-port (open-output-file "tmp4"))
+(error-test '(let ([c (make-custodian)])
+	       (let ([p (parameterize ([current-custodian c])
+				      (open-output-file "tmp4" 'replace))])
+		 (custodian-shutdown-all c)
+		 (display 'hi p)))
+	    exn:i/o:port-closed?)
+(error-test '(open-output-file "tmp4" 'error) exn:i/o:filesystem:file-exists?)
+(define p (open-output-file "tmp4" 'replace))
+(display 7 p)
+(display "" p)
+(close-output-port p)
+(close-output-port (open-output-file "tmp4" 'truncate))
+(define p (open-input-file "tmp4"))
+(test eof read p)
+(close-input-port p)
+(define p (open-output-file "tmp4" 'replace))
+(display 7 p)
+(close-output-port p)
+(define p (open-output-file "tmp4" 'append))
+(display 7 p)
+(close-output-port p)
+(error-test '(display 9 p) exn:i/o:port-closed?)
+(error-test '(write 9 p) exn:i/o:port-closed?)
+(error-test '(write-char #\a p) exn:i/o:port-closed?)
+
+(error-test '(let ([c (make-custodian)])
+	       (let ([p (parameterize ([current-custodian c])
+				      (open-input-file "tmp4"))])
+		 (custodian-shutdown-all c)
+		 (read p)))
+	    exn:i/o:port-closed?)
+(define p (open-input-file "tmp4"))
+(test 77 read p)
+(close-input-port p)
+(error-test '(read p) exn:i/o:port-closed?)
+(error-test '(read-char p) exn:i/o:port-closed?)
+(error-test '(char-ready? p) exn:i/o:port-closed?)
+
+(arity-test call-with-input-file 2 3)
+(arity-test call-with-output-file 2 4)
+(arity-test with-input-from-file 2 3)
+(arity-test with-output-to-file 2 4)
+
+(error-test '(call-with-input-file "x" 8))
+(error-test '(call-with-input-file  8 (lambda (x) x)))
+(error-test '(call-with-input-file  8 (lambda () 9)))
+(error-test '(call-with-input-file  "x" (lambda (x) x) 8))
+(error-test '(call-with-input-file  "x" (lambda (x) x) 'bad))
+
+(error-test '(call-with-output-file "x" 8))
+(error-test '(call-with-output-file  8 (lambda (x) x)))
+(error-test '(call-with-output-file  8 (lambda () 9)))
+(error-test '(call-with-output-file  "x" (lambda (x) x) 8))
+(error-test '(call-with-output-file  "x" (lambda (x) x) 'bad))
+
+(error-test '(with-input-from-file "x" 8))
+(error-test '(with-input-from-file  8 (lambda () 9)))
+(error-test '(with-input-from-file  8 (lambda (x) x)))
+(error-test '(with-input-from-file  "x" (lambda () 9) 8))
+(error-test '(with-input-from-file  "x" (lambda () 9) 'bad))
+
+(error-test '(with-output-to-file "x" 8))
+(error-test '(with-output-to-file  8 (lambda () 9)))
+(error-test '(with-output-to-file  8 (lambda (x) x)))
+(error-test '(with-output-to-file  "x" (lambda () 9) 8))
+(error-test '(with-output-to-file  "x" (lambda () 9) 'bad))
+
+(define s (open-output-string))
+(test #f input-port? s)
+(test #t output-port? s)
+(let ([c (current-output-port)])
+  (current-output-port s) 
+  (display 8)
+  (current-output-port c))
+(test "8" get-output-string s)
+(let ([c (current-error-port)])
+  (current-error-port s) 
+  (display 9 (current-error-port))
+  (current-error-port c))
+(test "89" get-output-string s)
+(define s (open-input-string (get-output-string s)))
+(test #t input-port? s)
+(test #f output-port? s)
+(test 89 + 0
+      (let ([c (current-input-port)])
+	(current-input-port s) 
+	(begin0
+	 (read)
+	 (current-input-port c))))
+(test eof read s)
+
+(arity-test open-output-string 0 0)
+(arity-test open-input-string 1 1)
+(arity-test get-output-string 1 1)
+
+(error-test '(get-output-string 9))
+(error-test '(get-output-string (current-output-port)))
+
+(define-values (out in) (make-pipe))
+(test #t input-port? out)
+(test #t output-port? in)
+(let loop ([n 1000])
+  (unless (zero? n)
+	  (display n in)
+	  (newline in)
+	  (loop (sub1 n))))
+(let loop ([n 999])
+  (unless (zero? n)
+	  (read out)
+	  (loop (sub1 n))))
+(test 1 read out)
+(close-output-port in)
+(test eof read out)
+(close-input-port out)
+(arity-test make-pipe 0 0)
+
+(test #t input-port? (make-input-port void void void))
+(error-test '(read (make-input-port void void void))
+	    exn:i/o:user-port?)
+(arity-test make-input-port 3 3)
+(error-test '(make-input-port 8 void void))
+(error-test '(make-input-port void 8 void))
+(error-test '(make-input-port void void 8))
+(error-test '(make-input-port add1 void void))
+(error-test '(make-input-port void add1 void))
+(error-test '(make-input-port void void add1))
+
+(test #t output-port? (make-output-port void void))
+(arity-test make-output-port 2 2)
+(error-test '(make-output-port 8 void))
+(error-test '(make-output-port void 8))
+(error-test '(make-output-port (lambda () 9) void))
+(error-test '(make-output-port void add1))
+
+(define test-file 
+  (open-output-file "tmp2" 'truncate))
+(write-char #\; test-file)
+(display write-test-obj test-file)
+(newline test-file)
+(write load-test-obj test-file)
+(test #t output-port? test-file)
+(close-output-port test-file)
+(check-test-file "tmp2")
+
+(define ui (make-input-port (lambda () #\") (lambda () #t) void))
+(test "" read ui)
+(arity-test (port-read-handler ui) 1 1)
+(error-test '((port-read-handler ui) 8))
+(let ([old (port-read-handler ui)])
+  (port-read-handler ui (lambda (x) "hello"))
+  (test "hello" read ui)
+  (port-read-handler ui old)
+  (test "" read ui))
+(arity-test port-read-handler 1 2)
+(error-test '(port-read-handler 1))
+(error-test '(port-read-handler ui 8))
+(error-test '(port-read-handler (current-output-port) 8))
+(error-test '(port-read-handler ui (lambda () 9)))
+(error-test '(port-read-handler ui (lambda (x y) 9)))
+
+(define sp (open-output-string))
+(test (void) display "hello" sp)
+(test "hello" get-output-string sp)
+(test (void) write "hello" sp)
+(test "hello\"hello\"" get-output-string sp)
+(arity-test (port-display-handler sp) 2 2)
+(arity-test (port-write-handler sp) 2 2)
+(arity-test (port-print-handler sp) 2 2)
+(error-test '((port-display-handler sp) 8 8))
+(error-test '((port-write-handler sp) 8 8))
+(error-test '((port-print-handler sp) 8 8))
+(let ([oldd (port-display-handler sp)]
+      [oldw (port-write-handler sp)]
+      [oldp (port-print-handler sp)]
+      [adding (let ([s "hello\"hello\""])
+		(lambda (a)
+		  (set! s (string-append s a))
+		  s))])
+  (port-display-handler sp (lambda (v p) (oldd "X" p) (values 1 2)))
+  (test (void) display "hello" sp)
+  (test (adding "X") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+  (test (void) print "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+
+  (port-write-handler sp (lambda (v p) (oldd "Y" p) 5))
+  (test (void) display "hello" sp)
+  (test (adding "X") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "Y") get-output-string sp)
+  (test (void) print "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+  (parameterize ([global-port-print-handler display])
+     (test (void) print "hello" sp)
+     (test (adding "X") get-output-string sp))
+  (parameterize ([global-port-print-handler oldd])
+     (test (void) print "hello" sp)
+     (test (adding "hello") get-output-string sp))
+  (test (void) print "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+		
+
+  (port-print-handler sp (lambda (v p) (oldd "Z" p) 5))
+  (test (void) display "hello" sp)
+  (test (adding "X") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "Y") get-output-string sp)
+  (test (void) print "hello" sp)
+  (test (adding "Z") get-output-string sp)
+  (parameterize ([global-port-print-handler display])
+     (test (void) print "hello" sp)
+     (test (adding "Z") get-output-string sp))
+  (test (void) print "hello" sp)
+  (test (adding "Z") get-output-string sp)
+
+  (port-display-handler sp oldd)
+  (test (void) display "hello" sp)
+  (test (adding "hello") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "Y") get-output-string sp)
+
+  (port-write-handler sp oldw)
+  (test (void) display "hello" sp)
+  (test (adding "hello") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+
+  (port-display-handler sp oldw)
+  (port-write-handler sp oldd)
+  (port-print-handler sp oldp)
+  (test (void) display "hello" sp)
+  (test (adding "\"hello\"") get-output-string sp)
+  (test (void) write "hello" sp)
+  (test (adding "hello") get-output-string sp)
+  (test (void) print "goodbye" sp)
+  (test (adding "\"goodbye\"") get-output-string sp)
+  (port-display-handler sp oldd)
+  (port-write-handler sp oldw))
+(error-test '(port-display-handler 1))
+(error-test '(port-display-handler sp 8))
+(error-test '(port-display-handler (current-input-port) 8))
+(error-test '(port-display-handler sp (lambda (x) 9)))
+(error-test '(port-display-handler sp (lambda (x y z) 9)))
+(error-test '(port-write-handler 1))
+(error-test '(port-write-handler sp 8))
+(error-test '(port-write-handler (current-input-port) 8))
+(error-test '(port-write-handler sp (lambda (x) 9)))
+(error-test '(port-write-handler sp (lambda (x y z) 9)))
+
+(SECTION 6 10 4)
+(load "tmp1")
+(test write-test-obj 'load foo)
+
+(SECTION 'INEXACT-I/IO)
+(define wto write-test-obj)
+(define dto display-test-obj)
+(define lto load-test-obj)
+(define f-3.25 (string->number "-3.25"))
+(define f.25 (string->number ".25"))
+(set! write-test-obj (list f.25 f-3.25));.25 inexact errors less likely.
+(set! display-test-obj (list f.25 f-3.25));.3 often has such errors (~10^-13)
+(set! load-test-obj (list 'define 'foo (list 'quote write-test-obj)))
+(let ([f (lambda (test-file)
+	   (write-char #\; test-file)
+	   (display write-test-obj test-file)
+	   (newline test-file)
+	   (write load-test-obj test-file)
+	   (output-port? test-file))])
+  (test #t call-with-output-file
+	"tmp3" f 'truncate))
+(check-test-file "tmp3")
+(set! write-test-obj wto)
+(set! display-test-obj dto)
+(set! load-test-obj lto)
+
+(define badc-range-start 0)
+(define badc-range-end 255)
+
+(SECTION 'PRINTF)
+(define (test-format format format-name)
+  (test "hello---~---there" format "~a---~~---~a" "hello" 'there)
+  (test "\"hello\"---~---there" format "~s---~~---~s" "hello" 'there)
+  (test "\"hello\"---~---there" format "~v---~~---~v" "hello" 'there)
+  (test (string #\a #\newline #\b #\newline #\c) format "a~nb~%c")
+  (let ([try-newline-stuff
+	 (lambda (newlines)
+	   (test "12" format (apply string `(#\1 #\~ #\space ,@newlines #\space #\2)))
+	   (test "12" format (apply string `(#\1 #\~ ,@newlines #\space #\2)))
+	   (test "12" format (apply string `(#\1 #\~ ,@newlines #\2)))
+	   (test (apply string `(#\1 ,@newlines #\2)) 
+		 format (apply string `(#\1 #\~ ,@newlines #\space ,@newlines #\2))))])
+    (for-each try-newline-stuff '((#\return) (#\newline) (#\return #\newline))))
+  (test "twenty=20..." format "twenty=~s..." 20)
+  (test "twenty=20..." format "twenty=~v..." 20)
+  (test "twenty=20..." format "twenty=~e..." 20)
+  (test "twenty=14..." format "twenty=~x..." 20)
+  (test "twenty=24..." format "twenty=~o..." 20)
+  (test "twenty=10100..." format "twenty=~b..." 20)
+  (test "zee=z..." format "zee=~c..." #\z)
+
+  (test #\. 
+	(lambda (s) (string-ref s (sub1 (string-length s))))
+	(parameterize ([error-print-width 40])
+		      (format "~e" #100(v))))
+  
+  (begin
+    (define bads
+      (let loop ([i badc-range-end])
+	(cond
+	 [(eq? i badc-range-start) (list (integer->char i))]
+	 [else (let ([c (integer->char i)]
+		     [rest (loop (sub1 i))])
+		 (case c
+		   [(#\~ #\% #\n #\a #\s #\c #\o #\x #\b #\v #\e
+			 #\N #\A #\S #\C #\O #\X #\B #\V #\E)
+		    rest]
+		   [else (if (char-whitespace? c)
+			     rest
+			     (cons c rest))]))])))
+
+    (define with-censor (load-relative "censor.ss"))
+
+    ; test for all bad tags; the string we generate shouldn't
+    ;  be printed to a terminal directly because it can contain contain
+    ;  control characters; censor it
+    (unless (defined? 'building-flat-tests)
+	    (with-censor
+	     (lambda ()
+	       (for-each (lambda (c)
+			   (error-test `(,@format-name ,(format "a~~~cb" c) 0)))
+			 bads)))))
+  
+  (error-test `(,@format-name 9))
+  (error-test `(,@format-name "apple~"))
+  (error-test `(,@format-name "~o") exn:application:fprintf:no-argument?)
+  (error-test `(,@format-name "~o" 1 2) exn:application:fprintf:extra-arguments?)
+  (error-test `(,@format-name "~c" 1) exn:application:fprintf:argument-type?)
+  (error-test `(,@format-name "~x" 'a) exn:application:fprintf:argument-type?)
+  (error-test `(,@format-name "~x" 4.0) exn:application:fprintf:argument-type?)
+  (error-test `(,@format-name "~x" 5+4.0i) exn:application:fprintf:argument-type?))
+
+(test-format format '(format))
+(test-format
+ (lambda args
+   (let ([p (open-output-string)])
+     (apply fprintf p args)
+     (get-output-string p)))
+ '(fprintf (current-output-port)))
+(test-format
+ (lambda args
+   (let ([p (open-output-string)])
+     (parameterize ([current-output-port p])
+		   (apply printf args))
+     (get-output-string p)))
+ '(printf))
+
+(arity-test format 1 -1)
+(arity-test printf 1 -1)
+(arity-test fprintf 2 -1)
+
+(define success-1? (putenv "APPLE" "AnApple"))
+(define success-2? (putenv "BANANA" "AnotherApple"))
+(error-test `(getenv 7))
+(error-test `(getenv (string #\a #\nul #\b)))
+(error-test `(putenv 7 "hi"))
+(error-test `(putenv "hi" 7))
+(error-test `(putenv (string #\a #\nul #\b) "hi"))
+(error-test `(putenv "hi" (string #\a #\nul #\b)))
+(collect-garbage)
+(unless (eq? (system-type) 'macos)
+	(test #t 'success-1 success-1?)
+	(test #t 'success-2 success-2?)
+	(test "AnApple" getenv "APPLE")
+	(test "AnotherApple" getenv "BANANA"))
+(test #f getenv "AnUndefinedEnvironmentVariable")
+
+(arity-test getenv 1 1)
+(arity-test putenv 2 2)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/fold.ss b/collects/tests/mzscheme/fold.ss
new file mode 100644
index 0000000..8911ca0
--- /dev/null
+++ b/collects/tests/mzscheme/fold.ss
@@ -0,0 +1,46 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'function)
+
+(require-library "function.ss")
+
+(test (list 1 2 3 4) foldl cons '() (list 4 3 2 1))
+(test (list 1 2 3 4) foldr cons '() (list 1 2 3 4))
+(test 
+ (list (list 5 6) (list 3 4) (list 1 2))
+ foldl (lambda (x y sofar) (cons (list x y) sofar))
+ '()
+ (list 1 3 5)
+ (list 2 4 6))
+(test 
+ (list (list 1 2) (list 3 4) (list 5 6))
+ foldr (lambda (x y sofar) (cons (list x y) sofar))
+ '()
+ (list 1 3 5)
+ (list 2 4 6))
+
+(arity-test foldl 3 -1)
+(arity-test foldr 3 -1)
+
+(test 0 (compose add1 sub1) 0)
+(test 2 (compose add1 (lambda () 1)))
+(test 5 (compose (lambda (a b) a) (lambda (x) (values (add1 x) x))) 4)
+(test -1 (compose (lambda (a b) (+ a b)) (lambda (x y) (values (- y) x))) 2 3)
+(test 'hi (compose (case-lambda [(x) 'bye][(y z) 'hi]) (lambda () (values 1 2))))
+(test 'ok (compose (lambda () 'ok) (lambda () (values))))
+(test 'ok (compose (lambda () 'ok) (lambda (w) (values))) 5)
+(test-values '(1 2 3) (lambda () ((compose (lambda (x) (values x (add1 x) (+ x 2))) (lambda (y) y)) 1)))
+
+(error-test '(compose 5))
+(error-test '(compose add1 sub1 5))
+(error-test '(compose add1 5 sub1))
+(error-test '(compose 5 add1 sub1))
+(error-test '((compose add1 (lambda () (values 1 2)))) exn:application:arity?)
+(error-test '((compose add1 sub1)) exn:application:arity?)
+(error-test '((compose (lambda () 1) add1) 8) exn:application:arity?)
+
+(arity-test compose 1 -1)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/hashper.ss b/collects/tests/mzscheme/hashper.ss
new file mode 100644
index 0000000..a2822be
--- /dev/null
+++ b/collects/tests/mzscheme/hashper.ss
@@ -0,0 +1,57 @@
+; Test suite to ensure #% objects are handled properly by MzRice.
+; Report problems to Shriram Krishnamurthi <shriram@cs.rice.edu>.
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(define bad#%?
+  (if (defined? 'read/zodiac)
+    exn?
+    syntaxe?))
+
+; Masking names shouldn't hurt the #% versions..
+
+(define car 3)
+(test 3 #%car (cons 3 2))
+(define car #%car)
+
+(let ((lambda 2))
+  (test #t equal? 2 ((#%lambda (x) x) lambda)))
+
+; You can't mask the #% versions.
+
+(error-test '(define #%lambda 2) bad#%?)
+(error-test '(set! #%lambda 2) bad#%?)
+
+; We allow random #% things to be set!'ed and define'd.
+
+(test #t equal? (void) (eval '(define #%foo 3)))
+(test #t equal? 4 (begin (set! #%foo 4) #%foo))
+
+; But you can't bind #% things either.
+
+(error-test '(let ((#%car 3)) 3) syntaxe?)
+(error-test '(let ((#%lambda 3)) 3) syntaxe?)
+
+; Let's try out all #% syntax to make sure it's immune.  (We'll skip
+; the macro stuff.)
+
+(map (lambda (s)
+       (error-test `(define ,s 3) bad#%?)
+       (error-test `(set! ,s 3) bad#%?))
+  '(#%lambda #%let-values #%letrec*-values #%define-values #%quote
+     #%if #%begin #%set! #%begin0 #%case-lambda #%struct))
+
+; And a few primitives, for good measure.
+
+(map (lambda (s)
+       (error-test `(define ,s 3) bad#%?)
+       (error-test `(set! ,s 3) bad#%?))
+  '(#%car #%cdr #%cons))
+
+(newline)
+(newline)
+
+; (printf "Done with #% test suite!~n~n")
+
+(report-errs)
diff --git a/collects/tests/mzscheme/image.ss b/collects/tests/mzscheme/image.ss
new file mode 100644
index 0000000..41219f0
--- /dev/null
+++ b/collects/tests/mzscheme/image.ss
@@ -0,0 +1,32 @@
+
+; Tests image saving/loading by dumping an image
+;  and loading it with every report-errs
+
+(define dump/restore
+  (lambda ()
+    (printf "Dumping image...~n")
+    (let ([result (write-image-to-file "tmp9")])
+      (if (vector? result)
+	  (printf "Continuing ~a~n" result)
+	  (read-image-from-file "tmp9" #("after" "restore"))))))
+
+(define ll null)
+(define load-relative
+  (lambda (f)
+    (set! ll (append ll (list f)))))
+
+(#%load-relative "all.ss")
+
+(define load-relative #%load-relative)
+
+(define go
+  (let ([d (current-load-relative-directory)])
+    (lambda ()
+      (parameterize ([current-load-relative-directory d])
+		    (for-each
+		     (lambda (f)
+		       (load-relative f)
+		       (dump/restore))
+		     ll)))))
+
+(printf "Run `(go)'~n")
diff --git a/collects/tests/mzscheme/ktest.ss b/collects/tests/mzscheme/ktest.ss
new file mode 100644
index 0000000..86d2d0d
--- /dev/null
+++ b/collects/tests/mzscheme/ktest.ss
@@ -0,0 +1,11 @@
+(define k 
+  (call-with-current-continuation
+   (lambda (exit)
+     (let loop ((n 60000))
+       (if (zero? n)
+	   (let ((v (call-with-current-continuation (lambda (k) k))))
+	    (if (number? v)
+		v
+		(exit v)))
+	  (- (loop (- n 1)) 1))))))
+
diff --git a/collects/tests/mzscheme/loadable.ss b/collects/tests/mzscheme/loadable.ss
new file mode 100644
index 0000000..eb943a3
--- /dev/null
+++ b/collects/tests/mzscheme/loadable.ss
@@ -0,0 +1 @@
+"This is a simple file used by param.ss"
diff --git a/collects/tests/mzscheme/loop.ss b/collects/tests/mzscheme/loop.ss
new file mode 100644
index 0000000..18fde59
--- /dev/null
+++ b/collects/tests/mzscheme/loop.ss
@@ -0,0 +1,29 @@
+
+
+(define five +)
+
+(define (one v)
+  (if (equal? v 15)
+      (apply five (list 1 2 3 4 5))
+      15))
+
+(define (dloop x d)
+  (if (zero? d)
+      0
+      (if (equal? x 15)
+	  (let ([v (one 10)])
+	    (let ([c (one v)])
+	      (add1 (dloop c (sub1 d)))))
+	  (dloop 15 d))))
+
+(define (loop)
+  (let loop ([n 0])
+    (let ([v (dloop 0 n)])
+      (if (equal? n v)
+	  (begin
+	    (when (zero? (modulo n 100))
+		  (printf "~a~n" n))
+	    (loop (add1 n)))
+	  (error 'loop "messed up: ~a != ~a~n" n v)))))
+
+
diff --git a/collects/tests/mzscheme/ltest.ss b/collects/tests/mzscheme/ltest.ss
new file mode 100644
index 0000000..5765a97
--- /dev/null
+++ b/collects/tests/mzscheme/ltest.ss
@@ -0,0 +1,88 @@
+(printf "nested loop~n")
+(time
+ (let loop ([n 10000])
+  (unless (zero? n)
+      (let loop2 ([m 10])
+	(if (zero? m)
+	    (loop (sub1 n))
+	    (loop2 (sub1 m)))))))
+
+(printf "single loop~n")
+(time
+ (let loop ([n 100000])
+   (unless (zero? n)
+	   (loop (sub1 n)))))
+
+(printf "Y loop~n")
+(time
+ ((lambda (f n) (f f n))
+  (lambda (loop n)
+    (unless (zero? n)
+	    (loop loop (sub1 n))))
+  100000))
+
+
+(printf "let closure recur~n")
+(time
+ (let ([f (lambda (x) (sub1 x))])
+   (let loop ([n 100000])
+     (unless (zero? n)
+	     (loop (f n))))))
+
+(printf "direct closure recur~n")
+(time
+ (let loop ([n 100000])
+   (unless (zero? n)
+	   (loop ((lambda (x) (sub1 x)) n)))))
+
+(printf "direct closure recur if~n")
+(time
+ (let loop ([n 100000])
+   (if (zero? n)
+       (void)
+       (loop ((lambda (x) (sub1 x)) n)))))
+
+(printf "let closure top-level~n")
+(define loop
+ (let ([f (lambda (x) (sub1 x))])
+   (lambda (n)
+     (unless (zero? n)
+	     (loop (f n))))))
+(time (loop 100000))
+
+(printf "direct closure top-level~n")
+(define loop
+  (lambda (n)
+    (unless (zero? n)
+	    (loop ((lambda (x) (sub1 x)) n)))))
+(time (loop 100000))
+
+
+; > (load "ltest.ss")
+; cpu time: 1820  real time: 1826
+; cpu time: 1420  real time: 1422
+; cpu time: 1960  real time: 1957
+; cpu time: 2630  real time: 2626
+; > (load "ltest.ss")
+; cpu time: 1790  real time: 1803
+; cpu time: 1430  real time: 1468
+; cpu time: 2150  real time: 2159
+; cpu time: 2820  real time: 2824
+
+; > (load "ltest.ss")
+; nested loop
+; cpu time: 1750  real time: 1817
+; single loop
+; cpu time: 1430  real time: 1425
+; Y loop
+; cpu time: 1500  real time: 1500
+; let closure recur
+; cpu time: 1830  real time: 1835
+; direct closure recur
+; cpu time: 1790  real time: 1791
+; direct closure recur if
+; cpu time: 1800  real time: 1793
+; let closure top-level
+; cpu time: 1810  real time: 1804
+; direct closure top-level
+; cpu time: 1760  real time: 1758
diff --git a/collects/tests/mzscheme/macro.ss b/collects/tests/mzscheme/macro.ss
new file mode 100644
index 0000000..3b752ff
--- /dev/null
+++ b/collects/tests/mzscheme/macro.ss
@@ -0,0 +1,35 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+
+(SECTION 'MACRO)
+
+(define-macro mx
+  (lambda (x)
+    (list x 1 8)))
+(test 9 'macro (mx +))
+(test -7 'macro (mx -))
+(test 18 'macro (let ([mx (lambda (x) (x 1 8 9))]) (mx +)))
+(when (defined? 'let-macro)
+      (teval '(test 13 'let-macro (let-macro mx (lambda (x) (list x 6 7)) (mx +))))
+      (teval '(test -7 'let-macro (let-macro mx2 (lambda (x y) (list 'mx y)) (mx2 + -))))
+      (teval '(test '(10) 'let-macro ((lambda () (let-macro x (lambda x (cons 'list x)) (x 10))))))
+      (teval '(test '(10) 'let-macro (let () (define-macro x (lambda x (cons 'list x))) (x 10))))
+      ; (test '(10) eval '((lambda () (define-macro x (lambda x (cons 'list x))) (x 10))))
+      )
+
+(define a-global-var 1)
+(define-macro a-macro (lambda () a-global-var))
+(test 1 'macro (a-macro))
+
+(when (defined? 'let-macro)
+      (teval '(define (defmacro-test)
+		(define-macro define-alias (lambda (x y) `(define ,x ,y)))
+		(test 45 'define
+		      (let ((x 5))
+			(define-alias foo (lambda (y) (bar x y)))
+			(define-alias bar (lambda (a b) (+ (* a b) a)))
+			(foo (+ x 3)))))))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/macrolib.ss b/collects/tests/mzscheme/macrolib.ss
new file mode 100644
index 0000000..c247e6d
--- /dev/null
+++ b/collects/tests/mzscheme/macrolib.ss
@@ -0,0 +1,72 @@
+
+(if (not (defined? 'SECTION))
+    (load "testing.ss"))
+
+(SECTION 'macrolib)
+
+(require-library "macro.ss")
+
+(let ([u (letrec ([x x]) x)])
+  (let ([l1
+	 (let+ ([rec a a]
+		[recs [b c] [c b]]
+		[rec d 1]
+		[val e 1]
+		[val x 1]
+		[val y 2]
+		[vals (x y) (y x)]
+		[rec (values f) (values 1)]
+		[vals [(values g h) (values 2 3)]]
+		[val i 3]
+		[_ (set! i 4)
+		   (set! i 5)])
+	       'x
+	       (list a b c d e x y f g h i))]
+	[l2 (list u u u 1 1 2 1 1 2 3 5)])
+    (test l1 'let-plus l2)))
+
+(require-library "shared.ss")
+
+(test "((car . cdr) #(one two three four five six) #&box (list1 list2 list3 list4) #<weak-box> 3 3)"
+      'shared
+      (let ([s (open-output-string)])
+	(display
+	 (shared ((a (cons 'car 'cdr)) 
+		  (b (vector 'one 'two 'three 'four 'five 'six))
+		  (c (box 'box))
+		  (d (list 'list1 'list2 'list3 'list4))
+		  (e (make-weak-box 'weak-box))
+		  (f (+ 1 2))
+		  (g 3))
+		 (list a b c d e f g))
+	 s)
+	(get-output-string s)))
+
+(define x 7)
+(test 6 'local (local ((define x 6)) x))
+(test 7 'local x)
+(test 6 vector-ref (struct->vector (local ((define x 6) (define-struct a (b))) (make-a x))) 1)
+(test #t 'local (local [(define o (lambda (x) (if (zero? x) #f (e (sub1 x)))))
+			(define e (lambda (x) (if (zero? x) #t (o (sub1 x)))))]
+		       (e 10)))
+(test 'second 'local (local ((define x 10) (define u 'second)) (cons x 1) u))
+(test-values '(4 6) (lambda () (local ((define y 6) (define x 4)) (values x y))))
+(test 10 'local (let ([x 10]) (local ((define y (lambda () x))) (define x 5) (y))))
+(test 5 'local (let ([x 10]) (local ((define y (lambda () x))) (define x 5) x)))
+(test 8 'local (local [(define lambda 8)] lambda))
+(test 9 'local (local [(define lambda 9) (define lambda2 lambda)] lambda2))
+(test 1 'local (local ((define-values (a b c) (values 1 2 3))) a))
+(test 1 (lambda () (local ((define-values (a b c) (values 1 2 3))) a)))
+(syntax-test '(local))
+(syntax-test '(local . 1))
+(syntax-test '(local ()))
+(syntax-test '(local () . 1))
+(syntax-test '(local 1 1))
+(syntax-test '(local (1) 1))
+(syntax-test '(local (x) 1))
+(syntax-test '(local ((+ 1 2)) 1))
+(syntax-test '(local ((define x)) 1))
+(syntax-test '(local ((define x 4) (+ 1 2)) 1))
+(syntax-test '(local ((define x 4) (+ 1 2) (define y 10)) 1))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/makeflat.ss b/collects/tests/mzscheme/makeflat.ss
new file mode 100644
index 0000000..bf20fdc
--- /dev/null
+++ b/collects/tests/mzscheme/makeflat.ss
@@ -0,0 +1,60 @@
+
+(unless (defined? 'flat-load)
+   (define flat-load "all.ss"))
+(unless (defined? 'lines-per-file)
+   (define lines-per-file +inf.0))
+
+(require-library "pretty.ss")
+
+
+(define line-count 0)
+(define file-count 0)
+
+(define flatp (open-output-file "flat.ss" 'replace))
+(define old-eval (current-eval))
+(define old-namespace (current-namespace))
+
+(pretty-print '(define error-test void) flatp)
+(pretty-print '(define building-flat-tests #t) flatp)
+(pretty-print '(define section #f) flatp)
+
+(define (flat-pp v)
+  (pretty-print v flatp)
+  (set! line-count (add1 line-count))
+  (when (>= line-count lines-per-file)
+	(set! line-count 0)
+	(set! file-count (add1 file-count))
+	(close-output-port flatp)
+	(set! flatp
+	      (open-output-file
+	       (format "flat~a.ss" file-count)
+	       'replace))))
+
+(define error-test
+  (case-lambda
+   [(expr) (error-test expr #f)]
+   [(expr exn?)
+    (unless (eq? exn? exn:syntax?)
+	    (flat-pp `(thunk-error-test (lambda () ,expr)
+					(quote ,expr)
+					,@(if exn?
+					      (list (string->symbol
+						     (primitive-name
+						      exn?)))
+					      null))))]))
+
+(define building-flat-tests #t)
+
+(dynamic-wind
+ (lambda () 
+   (current-eval
+    (lambda (e)
+      (unless (or (and (pair? e)
+		       (memq (car e) '(load load-relative error-test)))
+		  (not (eq? (current-namespace) old-namespace)))
+	      (flat-pp e))
+      (old-eval e))))
+ (lambda ()
+   (load flat-load))
+ (lambda ()
+   (current-eval old-eval)))
diff --git a/collects/tests/mzscheme/mzlib.ss b/collects/tests/mzscheme/mzlib.ss
new file mode 100644
index 0000000..839e909
--- /dev/null
+++ b/collects/tests/mzscheme/mzlib.ss
@@ -0,0 +1,29 @@
+
+; Test MzLib
+; See also pptest.ss and ztest.ss
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+; Should be named "function" instead:
+(load-relative "fold.ss")
+
+(load-relative "date.ss")
+
+(load-relative "cmdline.ss")
+
+(load-relative "pconvert.ss")
+
+; Last - so macros are not present by accident
+(load-relative "macrolib.ss")
+
+(require-library "core.ss")
+(test #t 'invoke-core-in-#%-space
+      (begin
+	(let ([l (require-library "corer.ss")])
+	  (parameterize ([current-namespace (make-namespace 'hash-percent-syntax)])
+			(invoke-unit/sig l)))
+	#t))
+
+
+(report-errs)
diff --git a/collects/tests/mzscheme/mzthr.ss b/collects/tests/mzscheme/mzthr.ss
new file mode 100644
index 0000000..844710d
--- /dev/null
+++ b/collects/tests/mzscheme/mzthr.ss
@@ -0,0 +1,75 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'mzlib-threads)
+
+(require-library "thread.ss")
+
+(define sema (make-semaphore))
+(define sema2 (make-semaphore))
+(define c-out 0)
+(define SLEEP-TIME 0.1)
+
+;;; consumer-thread ;;;
+
+(define-values (th g) (consumer-thread (case-lambda
+					[(f arg) (set! c-out (f arg))
+						 (semaphore-post sema)]
+					[(f arg1 arg2) (set! c-out (f arg1 arg2))
+						       (semaphore-post sema)])))
+(g + 1 2)
+(semaphore-wait sema)
+(test 3 'consumer-thread c-out)
+
+; queue 2
+(g car '(4 5))
+(g semaphore-wait sema2)
+(semaphore-wait sema)
+(test 4 'consumer-thread c-out)
+(semaphore-post sema2)
+(semaphore-wait sema)
+(test (void) 'consumer-thread c-out)
+
+; queue 3
+(g / 2)
+(g semaphore-wait sema2)
+(g (lambda (s) (semaphore-wait s) 5) sema2)
+(semaphore-wait sema)
+(test 1/2 'consumer-thread c-out)
+(semaphore-post sema2)
+(semaphore-wait sema)
+(test (void) 'consumer-thread c-out)
+(semaphore-post sema2)
+(semaphore-wait sema)
+(test 5 'consumer-thread c-out)
+
+; kill the consumer
+(kill-thread th)
+(g - 7)
+(sleep SLEEP-TIME)
+(test 5 'consumer-thread c-out)
+
+(arity-test consumer-thread 1 1) 
+(error-test '(consumer-thread 9))
+(arity-test g 2 3)
+
+;;; semaphore-wait-multiple ;;;
+
+(test #f semaphore-wait-multiple (list sema sema2) SLEEP-TIME)
+(semaphore-post sema)
+(test sema semaphore-wait-multiple (list sema sema2))
+(test #f semaphore-wait-multiple (list sema sema2) SLEEP-TIME)
+(semaphore-post sema2)
+(test sema2 semaphore-wait-multiple (list sema sema2))
+(test #f semaphore-wait-multiple (list sema sema2) SLEEP-TIME)
+(semaphore-post sema)
+(semaphore-post sema2)
+(let ([first (semaphore-wait-multiple (list sema sema2))])
+  (test #t semaphore? first)
+  (test (if (eq? first sema) sema2 sema) semaphore-wait-multiple (list sema sema2)))
+(test #f semaphore-wait-multiple (list sema sema2) SLEEP-TIME)
+
+(arity-test semaphore-wait-multiple 1 3)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/name.ss b/collects/tests/mzscheme/name.ss
new file mode 100644
index 0000000..f5cd5f7
--- /dev/null
+++ b/collects/tests/mzscheme/name.ss
@@ -0,0 +1,103 @@
+
+; Test MzScheme's name inference
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'NAMES)
+
+(arity-test inferred-name 1 1)
+(test #f inferred-name 0)
+(test #f inferred-name 'hello)
+(test #f inferred-name "hi")
+
+; Test ok when no name for proc
+(test #f inferred-name (lambda () 0))
+(test #f inferred-name (case-lambda))
+(test #f inferred-name (case-lambda [(x) 9]))
+(test #f inferred-name (case-lambda [(x) 9][(y z) 12]))
+
+; Test constructs that don't provide a name
+(test #f inferred-name (let ([x (cons (lambda () 10) 0)]) (car x)))
+(test #f inferred-name (let ([x (let ([y (lambda (x) x)]) (y (lambda () 10)))]) x))
+
+; Test ok when name for proc
+(define f (lambda () 0))
+(define f2 (lambda (a) 0))
+(define f3 (case-lambda))
+(define f4 (case-lambda [(x) 9]))
+(define f5 (case-lambda [(x) 9][(y z) 10]))
+
+(test 'f inferred-name f)
+(test 'f2 inferred-name f2)
+(test 'f3 inferred-name f3)
+(test 'f4 inferred-name f4)
+(test 'f5 inferred-name f5)
+
+; Test constructs that do provide a name
+(test 'a inferred-name (let ([a (lambda () 0)]) a))
+(test 'a inferred-name (let ([a (lambda () 0)]) (let ([b a]) b)))
+(test 'b inferred-name (let* ([b (lambda () 0)]) b))
+(test 'c inferred-name (letrec ([c (lambda () 0)]) c))
+(test 'loop inferred-name (let loop () loop))
+
+(test 'd inferred-name (let ([d (begin (lambda () x))]) d))
+(test 'e inferred-name (let ([e (begin0 (lambda () x))]) e))
+
+(test 'd2 inferred-name (let ([d2 (begin 7 (lambda () x))]) d2))
+(test 'e2 inferred-name (let ([e2 (begin0 (lambda () x) 7)]) e2))
+
+(test 'd3 inferred-name (let ([d3 (begin (cons 1 2) (lambda () x))]) d3))
+(test 'e3 inferred-name (let ([e3 (begin0 (lambda () x) (cons 1 2))]) e3))
+
+(test 'f inferred-name (let ([f (begin0 (begin (cons 1 2) (lambda () x)) (cons 1 2))]) f))
+
+(test 'g1 inferred-name (let ([g1 (if (cons 1 2) (lambda () x) #f)]) g1))
+(test 'g2 inferred-name (let ([g2 (if (negative? (car (cons 1 2))) #t (lambda () x))]) g2))
+
+(test 'w inferred-name (let ([w (let ([x 5]) (lambda () x))]) w))
+(test 'z inferred-name (let ([z (let ([x 5]) (cons 1 2) (lambda () x))]) z))
+
+(set! f (lambda () 10))
+(test 'f inferred-name f)
+
+; Test class stuff ok when no name
+(test #f inferred-name (class null ()))
+(test #f inferred-name (interface ()))
+
+; Test class stuff ok when name
+(test 'c1 inferred-name (let ([c1 (class null ())]) c1))
+(test 'i1 inferred-name (let ([i1 (interface ())]) i1))
+(test 'm inferred-name
+      (ivar
+       (make-object
+	(class null ()
+	       (public
+		[m (lambda () 10)])))
+       m))
+ ; Use external name:
+(test 'mex inferred-name
+      (ivar
+       (make-object
+	(class null ()
+	       (public
+		[(m mex) (lambda () 10)])))
+       mex))
+
+; Test unit stuff ok when no name
+(test #f inferred-name (unit (import) (export)))
+(test #f inferred-name (compound-unit (import) (link) (export)))
+
+; Test class stuff ok when name
+(test 'u1 inferred-name (let ([u1 (unit (import) (export))]) u1))
+(test 'u2 inferred-name (let ([u2 (compound-unit (import) (link) (export))]) u2))
+
+(test 'x inferred-name (invoke-unit
+		        (unit (import) (export) (define x (lambda () 0)) x)))
+(test 'x2 inferred-name (invoke-unit
+		        (unit (import) (export x2) (define x2 (lambda () 0)) x2)))
+ ; Use external name:
+(test 'x3 inferred-name (invoke-unit
+			 (unit (import) (export (x x3)) (define x (lambda () 0)) x)))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/namespac.ss b/collects/tests/mzscheme/namespac.ss
new file mode 100644
index 0000000..c7d6e14
--- /dev/null
+++ b/collects/tests/mzscheme/namespac.ss
@@ -0,0 +1,105 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'namespaces)
+
+(define flag-map
+  (list (list 'constants 
+	      'no-constants
+	      '(#%define car 5) 
+	      exn:misc:constant?
+	      #f)
+	(list 'keywords 
+	      'no-keywords
+	      '(#%let ([#%lambda 7]) (void)) 
+	      exn:syntax?
+	      #f)
+	(list 'call/cc=call/ec
+	      'call/cc!=call/ec
+	      '((call/cc (#%lambda (x) x)) void)
+	      exn:misc:continuation?
+	      #f)
+	(list 'hash-percent-syntax
+	      'all-syntax
+	      '(if #t (void))
+	      exn:variable?
+	      #f)))
+
+(define (do-one-by-one more less)
+  (let loop ([n (length flag-map)])
+    (unless (zero? n)
+	    (let ([test-info
+		   (let loop ([l flag-map][p 1])
+		     (if (null? l)
+			 '()
+			 (let* ([g (car l)]
+				[g++ (cdddr g)])
+			   (cons
+			    (cond
+			     [(= p n) (cons (less g) (less g++))]
+			     [else (cons (more g) (more g++))])
+			    (loop (cdr l) (add1 p))))))])
+	      (let* ([flags (map car test-info)]
+		     [namespace (apply make-namespace flags)])
+		(printf "trying: ~s~n" flags)
+		(let loop ([tests (map caddr flag-map)]
+			   [results (map cdr test-info)])
+		  (if (null? results)
+		      '()
+		      (begin
+			(if (car results)
+			    (error-test 
+			     `(with-handlers ([(#%lambda (x) #f) void]) ; outside parameterize re-raises exns after escaping
+				(parameterize ([current-namespace ,namespace])
+				  (eval ',(car tests))))
+			     (car results))
+			    (with-handlers ([(lambda (x) #f) void]) 
+			      (parameterize ([current-namespace namespace])
+			        (test (void) eval (car tests)))))
+			(loop (cdr tests) (cdr results)))))))
+	    (loop (sub1 n)))))
+
+(unless (defined? 'building-flat-tests)
+    (do-one-by-one car cadr)
+    (do-one-by-one cadr car))
+
+; Test primitive-name
+(let ([gvl (parameterize ([current-namespace (make-namespace)]) (make-global-value-list))]
+      [aliases (list (cons "call/cc" "call-with-current-continuation")
+		     (cons "call/ec" "call-with-escaping-continuation")
+		     (cons "unit/sig?" "unit-with-signature?")
+		     (cons "unit/sig->unit" "unit-with-signature-unit")
+		     (cons "unit-with-signature->unit" "unit-with-signature-unit"))])
+  (test #t 'names
+	(andmap
+	 (lambda (nv-pair)
+	   (let ([name (car nv-pair)]
+		 [value (cdr nv-pair)])
+	     (or (not (primitive? value))
+		 (let* ([s (symbol->string name)]
+			[sr (if (char=? #\# (string-ref s 0))
+				(substring s 2 (string-length s))
+				s)]
+			[st (let ([m (assoc sr aliases)])
+			      (if m
+				  (cdr m)
+				  sr))])
+		   (equal? st (primitive-name value))))))
+	 gvl)))
+
+(define (test-empty . flags)
+  (let ([e (apply make-namespace flags)])
+    (parameterize ([current-namespace e])
+      (test null make-global-value-list)
+      (test 'unbound 'empty-namespace
+	    (with-handlers ([void (lambda (exn) 'unbound)])
+			   (eval 'car)))
+      (test 'unbound 'empty-namespace
+	    (with-handlers ([void (lambda (exn) 'unbound)])
+			   (eval '#%car)))
+      (global-defined-value 'hello 5)
+      (test 5 'empty-namespace (eval 'hello))
+      (test '((hello . 5)) make-global-value-list))))
+(test-empty 'empty)
+(apply test-empty (append '(empty) (map car flag-map) (map cadr flag-map)))
diff --git a/collects/tests/mzscheme/nch.ss b/collects/tests/mzscheme/nch.ss
new file mode 100644
index 0000000..45398e6
--- /dev/null
+++ b/collects/tests/mzscheme/nch.ss
@@ -0,0 +1,30 @@
+
+(define (fact n)
+  (if (zero? n)
+      1
+      (* n (fact (- n 1)))))
+
+(define f1000 (fact 1000))
+
+(define (divall n d)
+  (if (<= n 1)
+      d
+      (divall (/ n d) (+ 1 d))))
+
+(define (nch n c)
+  (/ (fact n) (fact (- n c)) (fact c)))
+
+(define (snch n)
+  (letrec ((loop
+	    (lambda (i)
+	      (if (> i n)
+		  0
+		  (+ (nch n i) (loop (+ i 1)))))))
+    (loop 0)))
+
+(define (fsum n)
+  (if (zero? n)
+      1
+      (+ (fact n) (fsum (- n 1)))))
+
+
diff --git a/collects/tests/mzscheme/number.ss b/collects/tests/mzscheme/number.ss
new file mode 100644
index 0000000..87d0714
--- /dev/null
+++ b/collects/tests/mzscheme/number.ss
@@ -0,0 +1,1239 @@
+
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 6 5 5)
+(test #f number? 'a)
+(test #f complex? 'a)
+(test #f real? 'a)
+(test #f rational? 'a)
+(test #f integer? 'a)
+
+(test #t number? 3)
+(test #t complex? 3)
+(test #t real? 3)
+(test #t rational? 3)
+(test #t integer? 3)
+
+(test #t number? 3.0)
+(test #t complex? 3.0)
+(test #t real? 3.0)
+(test #t rational? 3.0)
+(test #t integer? 3.0)
+
+(test #t number? 3.1)
+(test #t complex? 3.1)
+(test #t real? 3.1)
+(test #t rational? 3.1)
+(test #f integer? 3.1)
+
+(test #t number? 3/2)
+(test #t complex? 3/2)
+(test #t real? 3/2)
+(test #t rational? 3/2)
+(test #f integer? 3/2)
+
+(test #t number? 3+i)
+(test #t complex? 3+i)
+(test #f real? 3+i)
+(test #f rational? 3+i)
+(test #f integer? 3+i)
+
+(test #t exact? 3)
+(test #t exact? 3/4)
+(test #f exact? 3.0)
+(test #t exact? (expt 2 100))
+(test #t exact? 3+4i)
+(test #f exact? 3.0+4i)
+
+(test #f inexact? 3)
+(test #f inexact? 3/4)
+(test #t inexact? 3.0)
+(test #f inexact? (expt 2 100))
+(test #f inexact? 3+4i)
+(test #t inexact? 3.0+4i)
+
+(test #t complex? -4.242154731064108e-5-6.865001427422244e-5i)
+(test #f exact? -4.242154731064108e-5-6.865001427422244e-5i)
+(test #t inexact? -4.242154731064108e-5-6.865001427422244e-5i)
+
+(test #t complex? -4.242154731064108f-5-6.865001427422244f-5i)
+(test #f exact? -4.242154731064108f-5-6.865001427422244f-5i)
+(test #t inexact? -4.242154731064108f-5-6.865001427422244f-5i)
+
+(test #t number? +inf.0)
+(test #t complex? +inf.0)
+(test #t real? +inf.0)
+(test #t rational? +inf.0)
+(test #t integer? +inf.0)
+
+(test #t number? -inf.0)
+(test #t complex? -inf.0)
+(test #t real? -inf.0)
+(test #t rational? -inf.0)
+(test #t integer? -inf.0)
+
+(test #t number? +nan.0)
+(test #t complex? +nan.0)
+(test #t real? +nan.0)
+(test #t rational? +nan.0)
+(test #f integer? +nan.0)
+
+(arity-test inexact? 1 1)
+(arity-test number? 1 1)
+(arity-test complex? 1 1)
+(arity-test real? 1 1)
+(arity-test rational? 1 1)
+(arity-test integer? 1 1)
+(arity-test exact? 1 1)
+(arity-test inexact? 1 1)
+
+(error-test '(exact? 'a))
+(error-test '(inexact? 'a))
+
+(test "+inf.0" number->string +inf.0)
+(test "-inf.0" number->string -inf.0)
+(test "+nan.0" number->string +nan.0)
+(test "+nan.0" number->string +nan.0)
+
+(test #t = 0)
+(test #t > 0)
+(test #t < 0)
+(test #t >= 0)
+(test #t <= 0)
+(test #t = 22 22 22)
+(test #t = 22 22)
+(test #f = 34 34 35)
+(test #f = 34 35)
+(test #t > 3 -6246)
+(test #f > 9 9 -2424)
+(test #t >= 3 -4 -6246)
+(test #t >= 9 9)
+(test #f >= 8 9)
+(test #t < -1 2 3 4 5 6 7 8)
+(test #f < -1 2 3 4 4 5 6 7)
+(test #t <= -1 2 3 4 5 6 7 8)
+(test #t <= -1 2 3 4 4 5 6 7)
+(test #f < 1 3 2)
+(test #f >= 1 3 2)
+
+(define (test-compare lo m hi) ; all positive!
+  (define -lo (- lo))
+  (define -m (- m))
+  (define -hi (- hi))
+
+  (define (test-lh l h)
+    (test #f > l h)
+    (test #t < l h)
+    (test #f = l h)
+    (test #f >= l h)
+    (test #t <= l h))
+
+  (define (test-hl h l)
+    (test #t > h l)
+    (test #f < h l)
+    (test #f = h l)
+    (test #t >= h l)
+    (test #f <= h l))
+
+  (define (test-zero z)
+    (test-hl m z)
+    (test-lh -m z)
+    (test-hl z -m)
+    (test-lh z m))
+
+  (test-lh m hi)
+  (test-hl -m -hi)
+
+  (test #f > m m)
+  (test #f < m m)
+  (test #t = m m)
+  (test #t >= m m)
+  (test #t <= m m)
+
+  (test-hl m -m)
+  (test-lh -m m)
+
+  (test-hl m lo)
+  (test-lh -m -lo)
+
+  (test-zero 0)
+  (test-zero 0.0))
+  
+(test-compare 0.5 1.2 2.3)
+(test-compare 2/5 1/2 2/3)
+(test #t = 1/2 2/4)
+
+(test-compare 0.5 6/5 2.3)
+(test-compare 1 11922615739/10210200 3000)
+(test-compare 1.0 11922615739/10210200 3000.0)
+
+(test #f > 0 (/ 1 (expt 2 400)))
+
+(test #t < 0.5 2/3)
+(test #f < 2/3 0.5)
+(test #t = 0.5 1/2)
+(test #t = +0.5i +1/2i)
+(test #f = +0.5i 1+1/2i)
+
+(test #f = 1+2i 2+i)
+
+(define (test-nan.0 f . args)
+  (apply test +nan.0 f args))
+
+(define (test-nan c)
+  (test #f < +nan.0 c)
+  (test #f > +nan.0 c)
+  (test #f = +nan.0 c)
+  (test #f <= +nan.0 c)
+  (test #f >= +nan.0 c))
+(test-nan 0)
+(test-nan 0.0)
+(test-nan 0.3)
+(test-nan +nan.0)
+(test-nan +inf.0)
+(test-nan -inf.0)
+(test #f = +nan.0 1+2i)
+(test #f = +nan.0 (make-rectangular +inf.0 -inf.0))
+
+(test-compare 999999999999 1000000000000 1000000000001)
+(define big-num (expt 2 1500))
+(test-compare (sub1 big-num) big-num (add1 big-num))
+(test-compare 1.0 (expt 10 100) 1e200)
+
+(define (inf-zero-test inf rx negnot)
+  (let ([inf-test-x
+	 (lambda (r v)
+	   (test r < v inf)
+	   (test (not r) > v inf)
+	   (test r <= v inf)
+	   (test (not r) >= v inf)
+	   
+	   (test (not r) < inf v)
+	   (test r > inf v)
+	   (test (not r) <= inf v)
+	   (test r >= inf v))])
+    (inf-test-x rx 5)
+    (inf-test-x (negnot rx) -5)
+    (inf-test-x rx big-num)
+    (inf-test-x (negnot rx) (- big-num))
+    (inf-test-x rx (/ big-num 3))
+    (inf-test-x (negnot rx) (/ (- big-num) 3))
+    (inf-test-x rx (/ 1 big-num))
+    (inf-test-x (negnot rx) (/ 1 (- big-num)))))
+(inf-zero-test +inf.0 #t (lambda (x) x))
+(inf-zero-test -inf.0 #f (lambda (x) x))
+(inf-zero-test 0.0 #f not)
+
+(error-test '(= 1 'a))
+(error-test '(= 1 1 'a))
+(error-test '(= 1 2 'a))
+(error-test '(= 'a 1))
+(error-test '(= 'a))
+(error-test '(> 1 'a))
+(error-test '(> 1 0 'a))
+(error-test '(> 1 2 'a))
+(error-test '(> 'a 1))
+(error-test '(< 1 'a))
+(error-test '(< 1 2 'a))
+(error-test '(< 1 0 'a))
+(error-test '(< 'a 1))
+(error-test '(>= 1 'a))
+(error-test '(>= 1 1 'a))
+(error-test '(>= 1 2 'a))
+(error-test '(>= 'a 1))
+(error-test '(<= 1 'a))
+(error-test '(<= 1 1 'a))
+(error-test '(<= 1 0 'a))
+(error-test '(<= 'a 1))
+
+(arity-test = 1 -1)
+(arity-test < 1 -1)
+(arity-test > 1 -1)
+(arity-test <= 1 -1)
+(arity-test >= 1 -1)
+
+(test #t zero? 0)
+(test #t zero? 0.0)
+(test #t zero? +0.0i)
+(test #t zero? 0/1)
+(test #f zero? 1)
+(test #f zero? -1)
+(test #f zero? -100)
+(test #f zero? 1.0)
+(test #f zero? -1.0)
+(test #f zero? 1/2)
+(test #f zero? -1/2)
+(test #f zero? -1/2+2i)
+(test #f zero? +inf.0)
+(test #f zero? -inf.0)
+(test #f zero? +nan.0)
+(test #t positive? 4)
+(test #f positive? -4)
+(test #f positive? 0)
+(test #t positive? 4.0)
+(test #f positive? -4.0)
+(test #f positive? 0.0)
+(test #t positive? 2/4)
+(test #f positive? -2/4)
+(test #f positive? 0/2)
+(test #t positive? +inf.0)
+(test #f positive? -inf.0)
+(test #f positive? +nan.0)
+(test #f negative? 4)
+(test #t negative? -4)
+(test #f negative? 0)
+(test #f negative? 4.0)
+(test #t negative? -4.0)
+(test #f negative? 0.0)
+(test #f negative? 2/4)
+(test #t negative? -2/4)
+(test #f negative? 0/4)
+(test #f negative? +inf.0)
+(test #t negative? -inf.0)
+(test #f negative? +nan.0)
+(test #t odd? 3)
+(test #f odd? 2)
+(test #f odd? -4)
+(test #t odd? -1)
+(test #t odd? +inf.0)
+(test #t odd? -inf.0)
+(test #f even? 3)
+(test #t even? 2)
+(test #t even? -4)
+(test #f even? -1)
+(test #t even? +inf.0)
+(test #t even? -inf.0)
+
+(arity-test zero? 1 1)
+(arity-test positive? 1 1)
+(arity-test negative? 1 1)
+(arity-test odd? 1 1)
+(arity-test even? 1 1)
+
+(error-test '(positive? 2+i))
+(error-test '(negative? 2+i))
+(error-test '(odd? 4.1))
+(error-test '(even? 4.1))
+(error-test '(odd? 4+1i))
+(error-test '(even? 4+1i))
+(error-test '(even? +nan.0))
+
+(error-test '(positive? 'i))
+(error-test '(negative? 'i))
+(error-test '(odd? 'a))
+(error-test '(even? 'a))
+(error-test '(odd? 'i))
+(error-test '(even? 'i))
+
+(test 5 max 5)
+(test 5 min 5)
+(test 38 max 34 5 7 38 6)
+(test -24 min 3  5 5 330 4 -24)
+(test 38.0 max 34 5.0 7 38 6)
+(test -24.0 min 3  5 5 330 4 -24.0)
+(test 2/3 max 1/2 2/3)
+(test 2/3 max 2/3 1/2)
+(test 2/3 max 2/3 -4/5)
+(test 1/2 min 1/2 2/3)
+(test 1/2 min 2/3 1/2)
+(test -4/5 min 2/3 -4/5)
+(test +inf.0 max +inf.0 0 -inf.0)
+(test -inf.0 min +inf.0 0 -inf.0)
+(test-nan.0 max +inf.0 +nan.0 0 -inf.0)
+(test-nan.0 min +inf.0 0 +nan.0 -inf.0)
+
+(error-test '(max 0 'a))
+(error-test '(min 0 'a))
+(error-test '(max 'a 0))
+(error-test '(min 'a 0))
+(error-test '(max 'a))
+(error-test '(min 'a))
+(error-test '(min 2 4+i))
+(error-test '(max 2 4+i))
+(error-test '(min 4+i))
+(error-test '(max 4+i))
+
+(arity-test max 1 -1)
+(arity-test min 1 -1)
+
+(test 0 +)
+(test 7 + 3 4)
+(test 6 + 1 2 3)
+(test 7.0 + 3 4.0)
+(test 6.0 + 1 2.0 3)
+(test 19/12 + 1/4 1/3 1)
+(test +i + +i)
+(test 3/2+1i + 1 2+2i -i -3/2)
+(test 3 + 3)
+(test 0 +)
+(test 4 * 4)
+(test 16.0 * 4 4.0)
+(test 1 *)
+(test 6/25 * 3/5 1/5 2)
+(test #i+6/25 * 3/5 1/5 2.0)
+(test +6/25i * 3/5 1/5 2 +i)
+(test #i+6/25i * 3/5 1/5 2.0 +i)
+(test 18805208620685182736256260714897 
+      * (sub1 (expt 2 31))  
+      8756857658476587568751)
+
+(arity-test * 0 -1)
+(arity-test + 0 -1)
+(arity-test - 1 -1)
+(arity-test / 1 -1)
+
+(test 2 add1 1)
+(test 0 add1 -1)
+(test 2.0 add1 1.0)
+(test 0.0 add1 -1.0)
+(test 3/2 add1 1/2)
+(test 1/2 add1 -1/2)
+(test 2.0+i add1 1.0+i)
+(test 0.0+i add1 -1.0+i)
+
+(error-test '(add1 "a"))
+(arity-test add1 1 1)
+
+(test 1 sub1 2)
+(test -2 sub1 -1)
+(test 1.0 sub1 2.0)
+(test -2.0 sub1 -1.0)
+(test -1/2 sub1 1/2)
+(test -3/2 sub1 -1/2)
+(test 1.0+i sub1 2.0+i)
+(test -2.0+i sub1 -1.0+i)
+
+(error-test '(sub1 "a"))
+(arity-test sub1 1 1)
+
+(test 1024 expt 2 10)
+(test 1/1024 expt 2 -10)
+(arity-test expt 2 2)
+
+(test 0 apply + (map inexact->exact (list 3.2e+270 -2.4e+270 -8e+269)))
+(test 0 apply + (map inexact->exact (list 3.2f+7 -2.4f+7 -8f+6)))
+
+(test #t positive? (inexact->exact 0.1))
+(test #t negative? (inexact->exact -0.1))
+(test 0 + (inexact->exact -0.1) (inexact->exact 0.1))
+(arity-test inexact->exact 1 1)
+(error-test '(inexact->exact 'a))
+(test 1+i inexact->exact 1.0+1.0i)
+
+(test #t positive? (exact->inexact 1/10))
+(test #t negative? (exact->inexact -1/10))
+(test 0.0 + (exact->inexact -1/10) (exact->inexact 1/10))
+(arity-test exact->inexact 1 1)
+(error-test '(exact->inexact 'a))
+(test 1.0+1.0i exact->inexact 1+1i)
+
+(error-test '(inexact->exact +inf.0))
+(error-test '(inexact->exact -inf.0))
+(error-test '(inexact->exact +nan.0))
+
+(error-test '(* 'a 0))
+(error-test '(+ 'a 0))
+(error-test '(+ 0 'a))
+(error-test '(* 0 'a))
+(error-test '(+ 'a))
+(error-test '(* 'a))
+
+(define (test-inf-plus-times v)
+  (define (test+ +)
+    (test +inf.0 + v (+ +inf.0))
+    (test -inf.0 + v (+ -inf.0))
+    (test +inf.0 + (- v) (+ +inf.0))
+    (test -inf.0 + (- v) (+ -inf.0))
+    
+    (test +inf.0 + +inf.0 v)
+    (test -inf.0 + -inf.0 v)
+    (test +inf.0 + +inf.0 (- v))
+    (test -inf.0 + -inf.0 (- v))
+
+    (test-nan.0 + +nan.0 v)
+    (test-nan.0 + v +nan.0))
+
+  (test+ +)
+  (test+ -)
+  
+  (test +inf.0 * +inf.0 v)
+  (test -inf.0 * -inf.0 v)
+  (test -inf.0 * +inf.0 (- v))
+  (test +inf.0 * -inf.0 (- v))
+
+  (test +inf.0 * v +inf.0)
+  (test -inf.0 * v -inf.0)
+  (test -inf.0 * (- v) +inf.0)
+  (test +inf.0 * (- v) -inf.0)
+
+  (test-nan.0 * +nan.0 v)
+  (test-nan.0 * v +nan.0))
+
+(test-inf-plus-times 1)
+(test-inf-plus-times 1.0)
+(test-inf-plus-times (expt 2 100))
+
+(test -inf.0 - +inf.0)
+(test +inf.0 - -inf.0)
+(test +inf.0 + +inf.0 +inf.0)
+(test -inf.0 + -inf.0 -inf.0)
+(test-nan.0 + +inf.0 -inf.0)
+(test-nan.0 - +inf.0 +inf.0)
+(test-nan.0 - -inf.0 -inf.0)
+(test +inf.0 * +inf.0 +inf.0)
+(test -inf.0 * +inf.0 -inf.0)
+(test-nan.0 * +inf.0 0)
+(test-nan.0 + +nan.0 +nan.0)
+(test-nan.0 - +nan.0 +nan.0)
+(test-nan.0 * +nan.0 +nan.0)
+
+(test 1/2 / 1 2)
+(test 1/2 / 1/4 1/2)
+(test 0.5 / 1 2.0)
+(test 0.5 / 1.0 2)
+(test 1/2+3/2i / 1+3i 2)
+(test 1/5-3/5i / 2 1+3i)
+
+(test +inf.0 / 1.0 0.0)
+(test -inf.0 / -1.0 0.0)
+
+(define (test-inf-zero-div v)
+  (test 0.0 / v +inf.0)
+  (test 0.0 / v -inf.0)
+  (test 0.0 / (- v) +inf.0)
+  (test 0.0 / (- v) -inf.0)
+  
+  (test +inf.0 / +inf.0 v)
+  (test -inf.0 / -inf.0 v)
+  (test -inf.0 / +inf.0 (- v))
+  (test +inf.0 / -inf.0 (- v))
+
+  (test 0.0 / 0.0 v)
+  (test 0.0 / 0.0 (- v))
+
+  (test +inf.0 / v 0.0)
+  (test -inf.0 / (- v) 0.0)
+
+  (test-nan.0 / +nan.0 v)
+  (test-nan.0 / v +nan.0))
+
+(test-inf-zero-div big-num)
+(test-inf-zero-div (/ big-num 3))
+
+(test-nan.0 / +inf.0 +inf.0)
+(test-nan.0 / +inf.0 -inf.0)
+(test-nan.0 / +nan.0 -nan.0)
+
+(test 1.0 exact->inexact (/ big-num (add1 big-num)))
+
+(error-test '(/ 0) exn:application:math:zero?)
+(error-test '(/ 1 0) exn:application:math:zero?)
+(error-test '(/ 1/2 0) exn:application:math:zero?)
+(error-test '(/ 1+2i 0) exn:application:math:zero?)
+(error-test '(/ 1.0 0) exn:application:math:zero?)
+
+(test -1 - 3 4)
+(test -3 - 3)
+(test -1.0 - 3.0 4)
+(test -3.0 - 3.0)
+(test 7 abs -7)
+(test 7.0 abs -7.0)
+(test 7 abs 7)
+(test 0 abs 0)
+(test 1/2 abs 1/2)
+(test 1/2 abs -1/2)
+(test +inf.0 abs +inf.0)
+(test +inf.0 abs -inf.0)
+(test-nan.0 abs -nan.0)
+
+(arity-test abs 1 1)
+(error-test '(-) exn:application:arity?)
+(error-test '(abs 'a))
+(error-test '(abs +5i))
+
+(test 5 quotient 35 7)
+(test 5.0 quotient 35 7.0)
+(test 5.0 quotient 36 7.0)
+(test 5.0 quotient 36.0 7)
+(test -5 quotient -35 7)
+(test -5.0 quotient -35 7.0)
+(test -5 quotient 35 -7)
+(test -5.0 quotient 35 -7.0)
+(test 5 quotient -35 -7)
+(test 5.0 quotient -35 -7.0)
+(test -5.0 quotient -36 7.0)
+(test -5.0 quotient 36.0 -7)
+(test 1 modulo 13 4)
+(test 1 remainder 13 4)
+(test 1.0 modulo 13 4.0)
+(test 1.0 remainder 13 4.0)
+(test 3 modulo -13 4)
+(test -1 remainder -13 4)
+(test 3.0 modulo -13 4.0)
+(test -1.0 remainder -13 4.0)
+(test -3 modulo 13 -4)
+(test 1 remainder 13 -4)
+(test -3.0 modulo 13.0 -4)
+(test 1.0 remainder 13.0 -4)
+(test -1 modulo -13 -4)
+(test -1 remainder -13 -4)
+(test -1.0 modulo -13 -4.0)
+(test -1.0 remainder -13 -4.0)
+(test -2 remainder -3333333332 -3)
+(test -2 modulo -3333333332 -3)
+(test 2 remainder 3333333332 -3)
+(test -1 modulo 3333333332 -3)
+(test 0 modulo 4 2)
+(test 0 modulo -4 2)
+(test 0 modulo 4 -2)
+(test 0 modulo -4 -2)
+(test 0.0 modulo 4.0 2)
+(test 0.0 modulo -4.0 2)
+(test 0.0 modulo 4.0 -2)
+(test 0.0 modulo -4.0 -2)
+(define (divtest n1 n2)
+	(= n1 (+ (* n2 (quotient n1 n2))
+		 (remainder n1 n2))))
+(test #t divtest 238 9)
+(test #t divtest -238 9)
+(test #t divtest 238 -9)
+(test #t divtest -238 -9)
+
+(test 13.0 quotient 1324.0 100)
+
+(define (test-qrm-inf v)
+  (define iv (exact->inexact v))
+
+  (test 0.0 quotient v +inf.0)
+  (test 0.0 quotient v -inf.0)
+  (test iv remainder v +inf.0)
+  (test iv remainder v -inf.0)
+  (test iv modulo v +inf.0)
+  (test -inf.0 modulo v -inf.0)
+
+  (test +inf.0 quotient +inf.0 v)
+  (test -inf.0 quotient -inf.0 v)
+  (test 0.0 remainder +inf.0 v)
+  (test 0.0 remainder -inf.0 v)
+  (test 0.0 modulo +inf.0 v)
+  (test 0.0 modulo -inf.0 v))
+
+(test-qrm-inf 9)
+(test-qrm-inf 9.0)
+(test-qrm-inf (expt 2 100))
+
+(arity-test quotient 2 2)
+(arity-test modulo 2 2)
+(arity-test remainder 2 2)
+
+(error-test '(quotient 'a 1))
+(error-test '(quotient 1 'a))
+(error-test '(quotient 1 +nan.0))
+(error-test '(quotient +nan.0 1))
+(error-test '(modulo 'a 1))
+(error-test '(modulo 1 'a))
+(error-test '(modulo +nan.0 1))
+(error-test '(modulo 1 +nan.0))
+(error-test '(remainder 'a 1))
+(error-test '(remainder 1 'a))
+(error-test '(remainder +nan.0 1))
+(error-test '(remainder 1 +nan.0))
+(error-test '(quotient 'a 1.0))
+(error-test '(quotient 1.0 'a))
+(error-test '(modulo 'a 1.0))
+(error-test '(modulo 1.0 'a))
+(error-test '(remainder 'a 1.0))
+(error-test '(remainder 1.0 'a))
+(error-test '(quotient 1/2 1))
+(error-test '(remainder 1/2 1))
+(error-test '(modulo 1/2 1))
+(error-test '(quotient 2 1/2))
+(error-test '(remainder 2 1/2))
+(error-test '(modulo 2 1/2))
+(error-test '(quotient 12.3 1))
+(error-test '(remainder 12.3 1))
+(error-test '(modulo 12.3 1))
+(error-test '(quotient 2 12.3))
+(error-test '(remainder 2 12.3))
+(error-test '(modulo 2 12.3))
+(error-test '(quotient 1+2i 1))
+(error-test '(remainder 1+2i 1))
+(error-test '(modulo 1+2i 1))
+(error-test '(quotient 2 1+2i))
+(error-test '(remainder 2 1+2i))
+(error-test '(modulo 2 1+2i))
+
+(test 10 bitwise-ior 10)
+(test 10 bitwise-and 10)
+(test 10 bitwise-xor 10)
+(test 7 bitwise-ior 3 4)
+(test 0 bitwise-and 3 4)
+(test 7 bitwise-xor 3 4)
+(test 7 bitwise-ior 3 4 1)
+(test 1 bitwise-and 3 5 1)
+(test 6 bitwise-xor 3 4 1)
+
+(test #x1ffff7777 bitwise-ior #x1aaaa5555 #x155553333)
+(test #x100001111 bitwise-and #x1aaaa5555 #x155553333)
+(test #x0ffff6666 bitwise-xor #x1aaaa5555 #x155553333)
+
+(test #x3ffff7777 bitwise-ior #x2aaaa5555 #x155553333)
+(test #x000001111 bitwise-and #x2aaaa5555 #x155553333)
+(test #x3ffff6666 bitwise-xor #x2aaaa5555 #x155553333)
+
+(test #x3ffff7777 bitwise-ior #x2aaaa5555 #x155553333)
+(test #x000001111 bitwise-and #x2aaaa5555 #x155553333)
+(test #x3ffff6666 bitwise-xor #x2aaaa5555 #x155553333)
+
+(test #xfffffffffffffe bitwise-not #x-FFFFFFFFFFFFFF)
+(test #x-100000000000000 bitwise-not #xFFFFFFFFFFFFFF)
+
+(test (bitwise-and (bitwise-not #x-2aaaa5555) (bitwise-not #x-15555aaaa))
+      bitwise-not (bitwise-ior #x-2aaaa5555 #x-15555aaaa))
+(test (bitwise-and (bitwise-not #x-2aaaa5555) (bitwise-not #x-155553333))
+      bitwise-not (bitwise-ior #x-2aaaa5555 #x-155553333))
+(test (bitwise-and (bitwise-not #x-2aaaa5555) (bitwise-not #x-15555333))
+      bitwise-not (bitwise-ior #x-2aaaa5555 #x-15555333))
+
+(test #x-155553333 bitwise-xor #x-2aaaa5555 (bitwise-xor #x-2aaaa5555 #x-155553333))
+(test #x-15555333 bitwise-xor #x-2aaaa5555 (bitwise-xor #x-2aaaa5555 #x-15555333))
+
+(arity-test bitwise-ior 1 -1)
+(arity-test bitwise-and 1 -1)
+(arity-test bitwise-xor 1 -1)
+(arity-test bitwise-not 1 1)
+
+(define error-test-bitwise-procs
+  (lambda (v)
+    (error-test `(bitwise-ior ,v))
+    (error-test `(bitwise-and ,v))
+    (error-test `(bitwise-xor ,v))
+    (error-test `(bitwise-not ,v))
+    (error-test `(bitwise-ior 1 ,v))
+    (error-test `(bitwise-and 1 ,v))
+    (error-test `(bitwise-xor 1 ,v))
+    (error-test `(bitwise-ior ,v 1))
+    (error-test `(bitwise-and ,v 1))
+    (error-test `(bitwise-xor ,v 1))))
+
+(error-test-bitwise-procs 1.0)
+(error-test-bitwise-procs 1/2)
+(error-test-bitwise-procs 1+2i)
+(error-test-bitwise-procs +inf.0)
+(error-test-bitwise-procs ''a)
+
+(test 1 arithmetic-shift 1 0)
+(test 1024 arithmetic-shift 1 10)
+(test 1 arithmetic-shift 1024 -10)
+(test 256 arithmetic-shift 1024 -2)
+(test 0 arithmetic-shift 1024 -11)
+(test 0 arithmetic-shift 1024 -20)
+(test 0 arithmetic-shift 1024 -40)
+(test 0 arithmetic-shift 1024 -20000000000000000000)
+
+(test (expt 2 40) arithmetic-shift (expt 2 40) 0)
+(test (expt 2 50) arithmetic-shift (expt 2 40) 10)
+(test (expt 2 30) arithmetic-shift (expt 2 40) -10) ; somewhere close to here is a boundary...
+(test (expt 2 29) arithmetic-shift (expt 2 40) -11)
+(test (expt 2 31) arithmetic-shift (expt 2 40) -9)
+(test 1 arithmetic-shift (expt 2 40) -40)
+(test 0 arithmetic-shift (expt 2 40) -41)
+(test 0 arithmetic-shift (expt 2 40) -100)
+
+(test -1 arithmetic-shift -1 0)
+(test -1024 arithmetic-shift -1 10)
+(test -1 arithmetic-shift -1024 -10)
+(test -256 arithmetic-shift -1024 -2)
+(test -1 arithmetic-shift -1024 -11)
+(test -1 arithmetic-shift -1024 -20)
+(test -1 arithmetic-shift -1024 -20000000000000000000)
+
+(test (- (expt 2 40)) arithmetic-shift (- (expt 2 40)) 0)
+(test (- (expt 2 50)) arithmetic-shift (- (expt 2 40)) 10)
+(test (- (expt 2 30)) arithmetic-shift (- (expt 2 40)) -10) ; somewhere close to here is a boundary...
+(test (- (expt 2 29)) arithmetic-shift (- (expt 2 40)) -11)
+(test (- (expt 2 31)) arithmetic-shift (- (expt 2 40)) -9)
+(test -1 arithmetic-shift (- (expt 2 40)) -40)
+(test -1 arithmetic-shift (- (expt 2 40)) -41)
+(test -1 arithmetic-shift (- (expt 2 40)) -100)
+
+(arity-test arithmetic-shift 2 2)
+(error-test '(arithmetic-shift "a" 1))
+(error-test '(arithmetic-shift 1 "a"))
+(error-test '(arithmetic-shift 1.0 1))
+(error-test '(arithmetic-shift 1 1.0))
+(error-test '(arithmetic-shift 1 (expt 2 80)) exn:misc:out-of-memory?)
+
+(test 4 gcd 0 4)
+(test 4 gcd -4 0)
+(test 4 gcd 32 -36)
+(test 2 gcd 6 10 14)
+(test 0 gcd)
+(test 5 gcd 5)
+(test 5.0 gcd 5.0 10)
+(test 9.0 gcd +inf.0 9)
+(test 9.0 gcd -inf.0 9)
+(test 288 lcm 32 -36)
+(test 12 lcm 2 3 4)
+(test 1 lcm)
+(test 5 lcm 5)
+(test 30.0 lcm 5 6.0)
+
+(error-test '(gcd +nan.0))
+(error-test '(gcd 'a))
+(error-test '(gcd 'a 1))
+(error-test '(gcd 1 'a))
+(error-test '(lcm +nan.0))
+(error-test '(lcm 'a))
+(error-test '(lcm 'a 1))
+(error-test '(lcm 1 'a))
+(error-test '(gcd 1/2))
+(error-test '(gcd 3 1/2))
+(error-test '(gcd 1/2 3))
+(error-test '(lcm 1/2))
+(error-test '(lcm 3 1/2))
+(error-test '(lcm 1/2 3))
+(error-test '(gcd 1+2i))
+(error-test '(lcm 1+2i))
+(error-test '(gcd 1 1+2i))
+(error-test '(lcm 1 1+2i))
+
+(arity-test gcd 0 -1)
+(arity-test lcm 0 -1)
+
+(test 2 floor 5/2)
+(test 3 ceiling 5/2)
+(test 2 round 5/2)
+(test 2 truncate 5/2)
+(test -3 floor -5/2)
+(test -2 ceiling -5/2)
+(test -2 round -5/2)
+(test -2 truncate -5/2)
+
+(test 1 floor 4/3)
+(test 2 ceiling 4/3)
+(test 1 round 4/3)
+(test 1 truncate 4/3)
+(test -2 floor -4/3)
+(test -1 ceiling -4/3)
+(test -1 round -4/3)
+(test -1 truncate -4/3)
+
+(test 1 floor 5/3)
+(test 2 ceiling 5/3)
+(test 2 round 5/3)
+(test 1 truncate 5/3)
+(test -2 floor -5/3)
+(test -1 ceiling -5/3)
+(test -2 round -5/3)
+(test -1 truncate -5/3)
+
+(test 2 floor 11/4)
+(test 3 ceiling 11/4)
+(test 3 round 11/4)
+(test 2 truncate 11/4)
+(test -3 floor -11/4)
+(test -2 ceiling -11/4)
+(test -3 round -11/4)
+(test -2 truncate -11/4)
+
+(test 2 floor 9/4)
+(test 3 ceiling 9/4)
+(test 2 round 9/4)
+(test 2 truncate 9/4)
+(test -3 floor -9/4)
+(test -2 ceiling -9/4)
+(test -2 round -9/4)
+(test -2 truncate -9/4)
+
+(define (test-fcrt-int v)
+  (test v floor v)
+  (test v ceiling v)
+  (test v round v)
+  (test v truncate v))
+
+(test-fcrt-int 2)
+(test-fcrt-int 2.0)
+(test-fcrt-int (expt 2 100))
+(test-fcrt-int +inf.0)
+(test-fcrt-int -inf.0)
+
+(test-nan.0 floor +nan.0)
+(test-nan.0 ceiling +nan.0)
+(test-nan.0 round +nan.0)
+(test-nan.0 truncate +nan.0)
+
+(arity-test round 1 1)
+(arity-test floor 1 1)
+(arity-test ceiling 1 1)
+(arity-test truncate 1 1)
+
+(error-test '(floor 2+i))
+(error-test '(ceiling 2+i))
+(error-test '(truncate 2+i))
+(error-test '(round 2+i))
+
+(error-test '(floor "a"))
+(error-test '(ceiling "a"))
+(error-test '(truncate "a"))
+(error-test '(round "a"))
+
+(test 5 numerator 5)
+(test 5000000000000 numerator 5000000000000)
+(test 5.0 numerator 5.0)
+(test 1 denominator 5)
+(test 1 denominator 5000000000000)
+(test 1.0 denominator 5.0)
+(test 2 numerator 2/3)
+(test 3 denominator 2/3)
+(test 1000.0 round (* 10000.0 (/ (numerator 0.1) (denominator 0.1))))
+
+(test +inf.0 numerator +inf.0)
+(test -inf.0 numerator -inf.0)
+(test-nan.0 numerator +nan.0)
+(test 1.0 denominator +inf.0)
+(test 1.0 denominator -inf.0)
+(test-nan.0 denominator +nan.0)
+
+(error-test '(numerator 'a))
+(error-test '(numerator 1+2i))
+(error-test '(denominator 'a))
+(error-test '(denominator 1+2i))
+
+(arity-test numerator 1 1)
+(arity-test denominator 1 1)
+
+(define (test-on-reals f filter)
+  (test (filter 5) f 5)
+  (test (filter 5.0) f 5.0)
+  (test (filter 1/5) f 1/5)
+  (test (filter (expt 2 100)) f (expt 2 100)))
+
+(test 1+2i make-rectangular 1 2)
+(test 1.0+2.0i make-rectangular 1.0 2)
+(test-nan.0 make-rectangular +nan.0 1)
+(test-nan.0 make-rectangular 1 +nan.0)
+(test 1 real-part 1+2i)
+(test 1/5 real-part 1/5+2i)
+(test-on-reals real-part (lambda (x) x))
+(test 2.0 imag-part 1+2.0i)
+(test 1/5 imag-part 1+1/5i)
+(test-on-reals imag-part (lambda (x) (if (exact? x) 0 0.0)))
+(test-nan.0 real-part +nan.0)
+(test-nan.0 imag-part +nan.0)
+(test 6@1 (lambda (x) x) 6.0@1.0)
+(test 324.0 floor (* 100 (real-part 6@1)))
+(test 50488.0 floor (* 10000 (imag-part 6@1)))
+(test 1.0 make-polar 1 0)
+(let ([v (make-polar 1 1)])
+  (test 5403.0 floor (* 10000 (real-part v)))
+  (test 84147.0 floor (* 100000 (imag-part v)))
+  (test 10000.0 round (* 10000.0 (magnitude v))))
+(let ([v (make-polar 1 2)])
+  (test -416.0 ceiling (* 1000 (real-part v)))
+  (test 909.0 floor (* 1000 (imag-part v)))
+  (test 1.0 magnitude v)
+  (test 2.0 angle v))
+(test-nan.0 make-polar +nan.0 1)
+(test-nan.0 make-polar 1 +nan.0)
+(test 785.0 floor (* 1000 (angle (make-rectangular 1 1))))
+(test 14142.0 floor (* 10000 (magnitude (make-rectangular 1 1))))
+(test-on-reals magnitude (lambda (x) x))
+(test-on-reals angle (lambda (x) (if (exact? x) 0 0.0)))
+
+(error-test '(make-rectangular 1 'a))
+(error-test '(make-rectangular 'a 1))
+(error-test '(make-rectangular 1+2i 1))
+(error-test '(make-rectangular 1 1+2i))
+(arity-test make-rectangular 2 2)
+
+(error-test '(make-polar 1 'a))
+(error-test '(make-polar 'a 1))
+(error-test '(make-polar 1+2i 1))
+(error-test '(make-polar 1 1+2i))
+(arity-test make-polar 2 2)
+
+(error-test '(real-part 'a))
+(error-test '(imag-part 'a))
+(arity-test real-part 1 1)
+(arity-test imag-part 1 1)
+
+(error-test '(angle 'a))
+(error-test '(magnitude 'a))
+(arity-test angle 1 1)
+(arity-test magnitude 1 1)
+
+(test -1 * +i +i)
+(test 1 * +i -i)
+(test 2 * 1+i 1-i)
+(test +2i * 1+i 1+i)
+(test 0.5 - (+ 0.5 +i) +i)
+(test 1/2 - (+ 1/2 +i) +i)
+(test 1.0 - (+ 1 +0.5i) +1/2i)
+
+(test 1 sqrt 1)
+(test 1.0 sqrt 1.0)
+(test 25 sqrt 625)
+(test 3/7 sqrt 9/49)
+(test 0.5 sqrt 0.25)
+(test +1i sqrt -1)
+(test +2/3i sqrt -4/9)
+(test +1.0i sqrt -1.0)
+(test 1+1i sqrt +2i)
+(test 2+1i sqrt 3+4i)
+(test +inf.0 sqrt +inf.0)
+(test (make-rectangular 0 +inf.0) sqrt -inf.0)
+(test-nan.0 sqrt +nan.0)
+
+(error-test '(sqrt "a"))
+(arity-test sqrt 1 1)
+
+(test -13/64-21/16i expt -3/4+7/8i 2)
+(let ([v (expt -3/4+7/8i 2+3i)])
+  (test 3826.0 floor (* 10000000 (real-part v)))
+  (test -137.0 ceiling (* 100000 (imag-part v))))
+(test 49.0 floor (* 10 (expt 2 2.3)))
+(test 189.0 floor (* 1000 (expt 2.3 -2)))
+(test 1/4 expt 2 -2)
+(test 1/1125899906842624 expt 2 -50)
+(test 1/1024 expt 1/2 10)
+(test 1024 expt 1/2 -10)
+(test 707.0 floor (* 1000 (expt 1/2 1/2)))
+(test 707.0 floor (* 1000 (expt 1/2 0.5)))
+(test 707.0 floor (* 1000 (expt 0.5 1/2)))
+(test +inf.0 expt 2 +inf.0)
+(test +inf.0 expt +inf.0 10)
+(test 1.0 expt +inf.0 0)
+(test 0.0 expt 2 -inf.0)
+(test -inf.0 expt -inf.0 11)
+(test +inf.0 expt -inf.0 10)
+(test 1.0 expt -inf.0 0)
+(test-nan.0 expt +nan.0 0)
+(test-nan.0 expt +nan.0 10)
+(test-nan.0 expt 2 +nan.0)
+
+;;;;From: fred@sce.carleton.ca (Fred J Kaudel)
+;;; Modified by jaffer.
+(define f3.9 (string->number "3.9"))
+(define f4.0 (string->number "4.0"))
+(define f-3.25 (string->number "-3.25"))
+(define f.25 (string->number ".25"))
+(define f4.5 (string->number "4.5"))
+(define f3.5 (string->number "3.5"))
+(define f0.0 (string->number "0.0"))
+(define f0.8 (string->number "0.8"))
+(define f1.0 (string->number "1.0"))
+(newline)
+(display ";testing inexact numbers; ")
+(newline)
+(SECTION 6 5 5)
+(test #t inexact? f3.9)
+(test #f exact? f3.9)
+(test #t 'inexact? (inexact? (max f3.9 4)))
+(test f4.0 'max (max f3.9 4))
+(test f4.0 'exact->inexact (exact->inexact 4))
+
+; Should at least be close...
+(test 4.0 round (log (exp 4.0)))
+(test 125.0 round (* 1000 (asin (sin 0.125))))
+(test 125.0 round (* 1000 (asin (sin 1/8))))
+(test 125.0 round (* 1000 (acos (cos 0.125))))
+(test 125.0 round (* 1000 (acos (cos 1/8))))
+(test 785.0 round (* 1000 (atan 1 1)))
+(test 2356.0 round (* 1000 (atan 1 -1)))
+(test -785.0 round (* 1000 (atan -1 1)))
+(test 785.0 round (* 1000 (atan 1)))
+(test 0.0 atan 0 0)
+(test 100.0 round (* 100 (tan (atan 1))))
+(test 1024.0 round (expt 2.0 10.0))
+(test 1024.0 round (expt -2.0 10.0))
+(test -512.0 round (expt -2.0 9.0))
+(test 32.0 round (sqrt 1024.0))
+
+(define (test-inf-bad f)
+  (test-nan.0 f +inf.0)
+  (test-nan.0 f -inf.0)
+  (test-nan.0 f +nan.0))
+
+(test-inf-bad tan)
+(test-inf-bad sin)
+(test-inf-bad cos)
+(test-inf-bad asin)
+(test-inf-bad acos)
+
+(test 11/7 rationalize (inexact->exact (atan +inf.0 1)) 1/100)
+(test -11/7 rationalize (inexact->exact (atan -inf.0 1)) 1/100)
+(test 0.0 atan 1 +inf.0)
+(test 22/7 rationalize (inexact->exact (atan 1 -inf.0)) 1/100)
+
+; Is this really right???
+(test 7/9 rationalize (inexact->exact (atan +inf.0 +inf.0)) 1/100)
+(test 26/11 rationalize (inexact->exact (atan +inf.0 -inf.0)) 1/100)
+(test -7/9 rationalize (inexact->exact (atan -inf.0 +inf.0)) 1/100)
+
+(test-nan.0 atan +nan.0)
+(test-nan.0 atan 1 +nan.0)
+(test-nan.0 atan +nan.0 1)
+
+(map (lambda (f fname) 
+       (error-test `(,fname "a"))
+       (arity-test f 1 1))
+     (list log exp asin acos tan)
+     `(log exp asin acos tan))
+(error-test '(atan "a" 1))
+(error-test '(atan 2+i 1))
+(error-test '(atan "a"))
+(error-test '(atan 1 "a"))
+(error-test '(atan 1 2+i))
+(arity-test atan 1 2)
+
+(define (z-round c) (make-rectangular (round (real-part c)) (round (imag-part c))))
+
+(test 3166.+1960.i  z-round (* 1000 (sin 1+2i)))
+(test -3166.-1960.i  z-round (* 1000 (sin -1-2i)))
+(test -642.-1069.i z-round (* 1000 (cos 2+i)))
+(test -642.-1069.i z-round (* 1000 (cos -2-i)))
+(test 272-1084.i z-round (* 1000 (tan 1-i)))
+(test -272+1084.i z-round (* 1000 (tan -1+i)))
+
+(test 693.+3142.i z-round (* 1000 (log -2)))
+(test 1571.-1317.i z-round (* 1000 (asin 2)))
+(test -1571.+1317.i z-round (* 1000 (asin -2)))
+(test +3688.i z-round (* 1000 (acos 20)))
+(test 3142.-3688.i z-round (* 1000 (acos -20)))
+
+(define (cs2 c) (+ (* (cos c) (cos c)) (* (sin c) (sin c))))
+(test 1000.0 round (* 1000 (cs2 2+3i)))
+(test 1000.0 round (* 1000 (cs2 -2+3i)))
+(test 1000.0 round (* 1000 (cs2 2-3i)))
+
+(test #t positive? (real-part (sqrt (- 1 (* 2+3i 2+3i)))))
+
+(test (- f4.0) round (- f4.5))
+(test (- f4.0) round (- f3.5))
+(test (- f4.0) round (- f3.9))
+(test f0.0 round f0.0)
+(test f0.0 round f.25)
+(test f1.0 round f0.8)
+(test f4.0 round f3.5)
+(test f4.0 round f4.5)
+(let ((x (string->number "4195835.0"))
+      (y (string->number "3145727.0")))
+  (test #t 'pentium-fdiv-bug (> f1.0 (- x (* (/ x y) y)))))
+
+(test (exact->inexact 1/3) rationalize .3 1/10)
+(test 1/3 rationalize 3/10 1/10)
+(test (exact->inexact 1/3) rationalize .3 -1/10)
+(test 1/3 rationalize 3/10 -1/10)
+(test 0 rationalize 3/10 4/10)
+(test 0.0 rationalize .3 4/10)
+
+(define (test-rat-inf v)
+  (define zero (if (exact? v) 0 0.0))
+
+  (test +inf.0 rationalize +inf.0 v)
+  (test -inf.0 rationalize -inf.0 v)
+  (test-nan.0 rationalize +nan.0 v)
+
+  (test zero rationalize v +inf.0)
+  (test zero rationalize v -inf.0)
+  (test-nan.0 rationalize v +nan.0))
+
+(let loop ([i 100])
+  (unless (= i -100)
+	  (test (/ i 100) rationalize (inexact->exact (/ i 100.0)) 1/100000)
+	  (loop (sub1 i))))
+
+(arity-test rationalize 2 2)
+
+(define tb
+  (lambda (n1 n2)
+    (= n1 (+ (* n2 (quotient n1 n2))
+	     (remainder n1 n2)))))
+(newline)
+(display ";testing bignums; ")
+(newline)
+(SECTION 6 5 5)
+
+(test -2147483648 - 2147483648)
+(test 2147483648 - -2147483648)
+(test #f = -2147483648 2147483648)
+(test #t = -2147483648 -2147483648)
+(test #t = 2147483648 2147483648)
+(test 2147483647 sub1 2147483648)
+(test 2147483648 add1 2147483647)
+(test 2147483648 * 1 2147483648)
+
+(test 437893890380859375 expt 15 15)
+
+(test 0 modulo -2177452800 86400)
+(test 0 modulo 2177452800 -86400)
+(test 0 modulo 2177452800 86400)
+(test 0 modulo -2177452800 -86400)
+
+(test 86399 modulo -2177452801 86400)
+(test -1 modulo 2177452799 -86400)
+(test 1 modulo 2177452801 86400)
+(test -86399 modulo -2177452799 -86400)
+
+(test #t 'remainder (tb 281474976710655 65535))
+(test #t 'remainder (tb 281474976710654 65535))
+(SECTION 6 5 6)
+(test 281474976710655 string->number "281474976710655")
+(test "281474976710655" number->string 281474976710655)
+(test "-4" number->string -4 16)
+(test "-e" number->string -14 16)
+(test "0" number->string 0 16)
+(test "30000000" number->string #x30000000 16)
+
+
+(SECTION 6 5 6)
+(test "0" number->string 0)
+(test "100" number->string 100)
+(test "100" number->string 256 16)
+(test 256 string->number "100" 16)
+(test 15 string->number "#o17")
+(test 15 string->number "#o17" 10)
+
+(load-relative "numstrs.ss")
+(let loop ([l number-table])
+  (unless (null? l)
+	  (let* ([pair (car l)]
+		 [v (car pair)]
+		 [v (if (or (eq? v 'X)
+			    (symbol? v)
+			    (eof-object? v))
+			#f 
+			v)]
+		 [s (cadr pair)])
+	    (test v string->number s))
+	  (loop (cdr l))))
+
+(test #f string->number "88" 7)
+(test #f string->number "")
+(test #f string->number " 1")
+(test #f string->number ".")
+(test #f string->number "#4@#i5")
+(test #t symbol? '1/x)
+(test #t symbol? '1+ei)
+(test #t symbol? '|1/0|)
+
+(arity-test string->number 1 2)
+(arity-test number->string 1 2)
+
+(error-test '(number->string 'a))
+(error-test '(number->string 1 'a))
+(error-test '(number->string 'a 10))
+(error-test '(number->string 1.8 8) exn:application:math:radix?)
+(error-test '(number->string 1 -1))
+
+(error-test '(string->number 'a))
+(error-test '(string->number 'a 'a))
+(error-test '(string->number "12" -1))
+(error-test '(string->number "12" 17))
+(error-test '(string->number "1" "1"))
+(error-test '(string->number 1 1))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/numstrs.ss b/collects/tests/mzscheme/numstrs.ss
new file mode 100644
index 0000000..5489fc7
--- /dev/null
+++ b/collects/tests/mzscheme/numstrs.ss
@@ -0,0 +1,126 @@
+
+(define number-table
+  `((,(+ 1/2 +i) "1/2+i")
+    (100 "100")
+    (0.1 ".1")
+    (1/20000 "#e1/2e-4")
+    (10.0 "1e1")
+    (10.0 "1E1")
+    (10.0 "1s1")
+    (10.0 "1S1")
+    (10.0 "1f1")
+    (10.0 "1F1")
+    (10.0 "1l1")
+    (10.0 "1L1")
+    (10.0 "1d1")
+    (10.0 "1D1")
+    (0.0 "0e13")
+    (+inf.0 ".3e2666666666")
+    (+inf.0 "+INF.0")
+    (+nan.0 "+NaN.0")
+    (10.0 "1#")
+    (10.0 "1#e0")
+    (10.0 "1####e-3")
+    (10.0 "1#.e0")
+    (10.0 "10.#e0")
+    (10.0 "10.e0")
+    (10.0 "1#.e0")
+    (10.0 "10.0#e0")
+    (10.0 "1#.##e0")
+    (10 "#e1#")
+    (10 "#e1#e0")
+    (10 "#e1#.e0")
+    (5e-5 "1/2e-4")
+    (5e-5 "#i1/2e-4")
+    (0.5 "#i1/2")
+    (1/2 "#e1/2")
+    (0.5 "#i0.5")
+    (1/2 "#e0.5")
+    (1/20 "#e0.5e-1")
+    (1/20 "#e0.005e1")
+    (1.0+0.5i "1+0.5i")
+    (1/2 "1/2@0")
+    (-1/2 "-1/2@0")
+    (1/2 "1/2@-0")
+    (0 "#b#e0")
+    (0.0 "#b#i0")
+    (4.0 "#b1e10")
+    (4 "#b#e1e10")
+    (1/10+1/5i "#e0.1+0.2i")
+    (0.0+80.0i "#i+8#i")
+    (521976 "#x7f6f8")
+    (1+8i "#b#e1+1#e10i")
+    (1.125 "#x1.2")
+
+    (#f "d")
+    (D "D")
+    (#f "i")
+    (I "I")
+    (#f "3i")
+    (3I "3I")
+    (#f "33i")
+    (33I "33I")
+    (#f "3.3i")
+    (3.3I "3.3I")
+    (#f "e")
+    (#f "e1")
+    (#f "e1")
+    (#f "-")
+    (#f "+")
+    (X "#e-")
+    (X "#e+")
+    (X "#i-")
+    (X "#i+")
+    (#f "+.")
+    (X "#e+.")
+    (#f "/")
+    (#f "+1+1")
+    (#f "+1/+1")
+    (#f "1//2")
+    (#f "mod//")
+    (#f "-1.0/2")
+    (#f "/2")
+    (#f "2..")
+    (#f ".2.")
+    (X "#e2..")
+    (X "#e.2.")
+    (#f "1#.0e4")
+    (#f "1#0e4")
+    (#f "1#0.e4")
+    (#f "1##.##0e4")
+    (#f "2i")
+    (#f "/2i")
+    (#f "2@2i")
+    (#f "2@@2")
+    (#f "-2@-+2")
+    (#f "1/1-e4")
+    (#f "1.-2")
+    (X "#e1.-2")
+    (X "#b#b0")
+    (X "#b#o0")
+    (X "#i#i0")
+    (X "#e#e0")
+    (X "#i8#i")
+    (X "#i4@#i5")
+    (X "#i4+#d6i")
+    (X "#i4+#d6")
+    (#f "4ef5")
+    (X "#e4ef5")
+    (X "1/0")
+    (X "5+1/0i")
+    (X "1/0+5i")
+    (X "5@1/0")
+    (X "1/0@5")
+    (X "1/0e2")
+    (#f "1/0+hi")
+    (#f "x+1/0i")
+    (#f "+nan.0+1i")
+    (#f "1+nan.0i")
+    (#f "1++nan.0i")
+    (#f "1+inf.0i")
+    (#f "1++inf.0i")
+    (#f "+nan.0@1")
+    (#f "+inf.0@1")
+    (#f "1@+inf.0")
+    (#f "1e1/0")
+    (#f "011111122222222223333333333444444x")))
diff --git a/collects/tests/mzscheme/object.ss b/collects/tests/mzscheme/object.ss
new file mode 100644
index 0000000..ccc6d89
--- /dev/null
+++ b/collects/tests/mzscheme/object.ss
@@ -0,0 +1,507 @@
+
+; Test MzScheme's object system
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'OBJECT)
+
+(define (test-class* cl* renames)
+  (syntax-test  `(,cl*))
+  (syntax-test  `(,cl* ,@renames . x))
+  (syntax-test  `(,cl* ,@renames 0))
+  (syntax-test  `(,cl* ,@renames () . x))
+  (syntax-test  `(,cl* ,@renames () 0))
+  (syntax-test  `(,cl* ,@renames () x))
+  (syntax-test  `(,cl* ,@renames () ()))
+  (syntax-test  `(,cl* ,@renames () () (0) x))
+  (syntax-test  `(,cl* ,@renames () () 0))
+  (syntax-test  `(,cl* ,@renames () () . x))
+  (syntax-test  `(,cl* ,@renames () () () . x))
+  (syntax-test  `(,cl* ,@renames () () () x))
+  (syntax-test  `(,cl* ,@renames () () () public))
+  (syntax-test  `(,cl* ,@renames () () () (x)))
+  (syntax-test  `(,cl* ,@renames () () (x) ()))
+
+  (begin
+    (define (try-dotted cl)
+      (syntax-test  `(,cl* ,@renames () () () (,cl . x))))
+    
+    (map try-dotted '(public private inherit rename
+			     inherit-from rename-from
+			     sequence)))
+  
+  (begin
+    (define (try-defn-kind cl)
+      (syntax-test  `(,cl* ,@renames () () () (,cl 8)))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [8 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(x) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(x y x) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [x . 1])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [x 1 . 3])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [x 1 3]))))
+    
+    (try-defn-kind 'public)
+    (try-defn-kind 'private))
+
+  (begin
+    (define (try-defn-rename-kind cl)
+      (syntax-test  `(,cl* ,@renames () () () (,cl [((x) y) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(x (y)) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(x . y) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(x 1) 9])))
+      (syntax-test  `(,cl* ,@renames () () () (,cl [(1 x) 9]))))
+    (try-defn-rename-kind 'public))
+
+  (begin
+    (define (try-ref-kind cl)
+      (syntax-test  `(,cl* ,@renames () () () (,cl 8)))
+      (syntax-test  `(,cl* ,@renames () () () (,cl x 8)))
+      (syntax-test  `(,cl* ,@renames () () () (,cl (x . y))))
+      (syntax-test  `(,cl* ,@renames () () () (,cl (x y z)))))
+    
+    (map try-ref-kind '(inherit rename share)))
+  (error-test `(,cl* ,@renames () () () (inherit x)) exn:object:inherit?)
+  (error-test `(,cl* ,@renames () () () (inherit (x y))) exn:object:inherit?)
+  (syntax-test  `(,cl* ,@renames () () () (inherit (x y z))))
+  (syntax-test  `(,cl* ,@renames () () () (inherit (x 5))))
+  (syntax-test  `(,cl* ,@renames () () () (inherit (x))))
+  (syntax-test  `(,cl* ,@renames () () () (rename x)))
+  (syntax-test  `(,cl* ,@renames () () () (rename (x))))
+  (syntax-test  `(,cl* ,@renames () () () (rename ((x) y))))
+  (syntax-test  `(,cl* ,@renames () () () (rename ((x y) y))))
+  (syntax-test  `(,cl* ,@renames () () () (rename ((1) y))))
+
+  (syntax-test  `(,cl* ,@renames () () () (sequence 1 . 2)))
+  
+  (syntax-test  `(,cl* ,@renames () () () (public [x 7] [x 9])))
+  (syntax-test  `(,cl* ,@renames () () (x) (public [x 7])))
+  (syntax-test  `(,cl* ,@renames () () (x) (public [(x w) 7])))
+  (syntax-test  `(,cl* ,@renames () () () (public [(x y) 7] [(z y) 9])))
+  (syntax-test  `(,cl* ,@renames () () () (public [(x y) 7] [(x z) 9])))
+
+  (syntax-test  `(,cl* ,@renames () a ()))
+  (syntax-test  `(,cl* ,@renames () (1 . a) ())))
+
+(test-class* 'class* ())
+(test-class* 'class*/names '((this super)))
+
+(syntax-test  `(class*/names 8 () () () ()))
+(syntax-test  `(class*/names () () () ()))
+(syntax-test  `(class*/names (8) () () ()))
+(syntax-test  `(class*/names (this . 8) () () ()))
+(syntax-test  `(class*/names (this 8) () () ()))
+(syntax-test  `(class*/names (this super-init . 8) () () ()))
+(syntax-test  `(class*/names (this super-init 8) () () ()))
+
+(test #t class? (class* () () ()))
+(test #t class? (class* () () ()))
+(test #t class? (class* () () x))
+(test #t class? (class* () () () (public)))
+(test #t class? (class* () () () (public sequence)))
+(test #t class? (class* () () (x) (public [(y x) 9])))
+(test #t class? (class*/names (this super-init) () () () (public)))
+
+(syntax-test  `(interface))
+(syntax-test  `(interface . x))
+(syntax-test  `(interface 8))
+(syntax-test  `(interface () 8))
+(syntax-test  `(interface () x . y))
+(syntax-test  `(interface () x 8))
+(syntax-test  `(interface () x x))
+(error-test `(interface (8) x) exn:object:interface-type?)
+
+(test #t interface? (interface ()))
+(test #t interface? (interface () x))
+(test #f interface? (class* () () ()))
+
+(define i0.1 (interface () x y))
+(define i0.2 (interface () y c d))
+(define i1 (interface (i0.1 i0.2) e))
+(define ix (interface () x y))
+
+(test #t interface-extension? i1 i0.1)
+(test #t interface-extension? i1 i0.2)
+(test #f interface-extension? i0.1 i1)
+(test #f interface-extension? i0.2 i1)
+(test #f interface-extension? i0.2 i0.1)
+(test #f interface-extension? i0.1 i0.2)
+
+(error-test '(let [(bad (class* () (i0.1) ()))] bad) exn:object:implement?)
+(test #t class? (class* () (i0.1) () (public x y)))
+(error-test '(let ([cl (class* () (i0.1 i0.2) () (public x y c))]) cl) exn:object:implement?)
+(error-test '(class* () (i1) () (public x y c)) exn:object:implement?)
+(test #t class? (class* () (i0.1 i0.1) () (public x y c d)))
+(error-test '(class* () (i1) () (public x y c d)) exn:object:implement?)
+(test #t class? (class* () (i1) () (public x y c d e)))
+
+(define c1 
+  (let ((v 10))
+    (class* '() (i1) (in [in-2 'banana] . in-rest)
+	   (public (x 1) (y 2))
+	   (private (a in) (b3 3))
+	   (public (b1 2) (b2 2) (e 0))
+	   (public (c 3) (d 7)
+		   (f-1-a (lambda () a))
+		   (f-1-b1 (lambda () b1))
+		   (f-1-b2 (lambda () b2))
+		   (f-1-c (lambda () c))
+		   (f-1-v (lambda () v))
+		   (f-1-x (lambda () x))
+		   (f-1-top-a (lambda () (ivar this a)))
+		   (f-1-other-e (lambda (o) (ivar o e)))
+		   (f-1-set-b2 (lambda (v) (set! b2 v) b2))
+		   (f-1-in-2 (lambda () in-2))
+		   (f-1-in-rest (lambda () in-rest)))
+	   (sequence
+	     (set! e in)))))
+  
+(test #t implementation? c1 i0.1)
+(test #t implementation? c1 i0.2)
+(test #t implementation? c1 i1)
+(test #f implementation? c1 ix)
+
+(define o1 (make-object c1 0 'apple "first" "last"))
+
+(define c2 
+  (let ((v 20))
+    (class c1 ()
+	   (inherit b2 (sup-set-b2 f-1-set-b2))
+	   (rename (also-e e)
+		   (also-b2 b2))
+	   (public (a 4) (b1 5) (c 6)
+		   (f-2-a (lambda () a))
+		   (f-2-b1 (lambda () b1))
+		   (f-2-b2 (lambda () b2))
+		   (f-2-also-b2 (lambda () also-b2))
+		   (f-2-c (lambda () c))
+		   ((i-f-2-v f-2-v) (lambda () v))
+		   (f-2-v-copy (lambda () (i-f-2-v)))
+		   (f-2-set-b2 (lambda (v) (sup-set-b2 v))))
+	   (private (y 3))
+	   (sequence
+	     (super-init 1)))))
+
+(test #t implementation? c2 i0.1)
+(test #t implementation? c2 i0.2)
+(test #t implementation? c2 i1)
+(test #f implementation? c2 ix)
+
+(define o2 (make-object c2))
+
+(define c2.1
+  (class*/names (this c2-init) c2 () ()
+	  (sequence
+	    (c2-init))))
+
+(define o2.1 (make-object c2.1))
+
+(define c3
+  (class* () () ()
+	  (public (x 6) (z 7) (b2 8)
+		  (f-3-b2 (lambda () b2)))))
+
+(define o3 (make-object c3))
+
+(define c6
+  (class null (x-x)
+    (public
+     [(i-a x-a) (lambda () 'x-a)]
+     [(x-a i-a) (lambda () 'i-a)]
+     [(i-x x-x) (lambda () 'x-x)]
+     [x-a-copy (lambda () (i-a))]
+     [i-a-copy (lambda () (x-a))])))
+
+(define o6 (make-object c6 'bad))
+
+(define c7
+  (class*/names (self super-init) () () ()
+    (public
+     [get-self (lambda () self)])))
+
+(define o7 (make-object c7))
+
+(define display-test 
+  (lambda (p v)
+    (printf "Should be ~s: ~s ~a~n"
+	    p v (if (equal? p v)
+		    ""
+		    "ERROR"))))
+
+(define ivar? exn:object:ivar?)
+
+(test #t is-a? o1 c1)
+(test #t is-a? o1 i1)
+(test #t is-a? o2 c1)
+(test #t is-a? o2 i1)
+(test #f is-a? o1 c2)
+(test #t is-a? o2 c2)
+(test #t is-a? o2.1 c1)
+(test #f is-a? o1 c3)
+(test #f is-a? o2 c3)
+(test #f is-a? o1 ix)
+(test #f is-a? o2 ix)
+(test #f is-a? o3 i1)
+(test #f is-a? i1 i1)
+(test #t subclass? c2 c1)
+(test #t subclass? c2.1 c1)
+(test #f subclass? c1 c2)
+(test #f subclass? c1 c3)
+(test #f subclass? i1 c3)
+(test #t ivar-in-class? 'f-1-a c1)
+(test #t ivar-in-class? 'f-1-a c2)
+(test #f ivar-in-class? 'f-2-a c1)
+(test #t ivar-in-class? 'f-2-a c2)
+
+(error-test '(is-a? o1 o1))
+(error-test '(subclass? o1 o1))
+(error-test '(subclass? o1 i1))
+(error-test '(implementation? o1 o1))
+(error-test '(implementation? o1 c1))
+(error-test '(ivar-in-class? 0 c1))
+(error-test '(ivar-in-class? 'a i1))
+(error-test '(ivar-in-class? 'a o1))
+
+(arity-test object? 1 1)
+(arity-test class? 1 1)
+(arity-test interface? 1 1)
+(arity-test is-a? 2 2)
+(arity-test subclass? 2 2)
+(arity-test interface-extension? 2 2)
+(arity-test ivar-in-class? 2 2)
+
+(arity-test uq-ivar 2 2)
+(arity-test uq-make-generic 2 2)
+
+(error-test '(ivar o1 a) ivar?)
+(test 4 uq-ivar o2 'a)
+
+(test 0 'send (send o1 f-1-a))
+(test 1 'send (send o2 f-1-a))
+(test 4 'send (send o2 f-2-a))
+
+(test 'apple 'send (send o1 f-1-in-2))
+(test 'banana 'send (send o2 f-1-in-2))
+(test '("first" "last") 'send (send o1 f-1-in-rest))
+(test '() 'send (send o2 f-1-in-rest))
+
+(error-test '(send o1 f-1-top-a) ivar?)
+(test 4 'send (send o2 f-1-top-a))
+
+(test 5 uq-ivar o2 'b1)
+
+(test 2 'send (send o1 f-1-b1))
+(test 2 'send (send o1 f-1-b2))
+(test 5 'send (send o2 f-1-b1))
+(test 2 'send (send o2 f-1-b2))
+(test 5 'send (send o2 f-2-b1))
+(test 2 'send (send o2 f-2-b2))
+(test 2 'send (send o2 f-2-also-b2))
+
+(test 3 uq-ivar o1 'c)
+(test 6 uq-ivar o2 'c)
+
+(test 3 'send (send o1 f-1-c))
+(test 6 'send (send o2 f-1-c))
+(test 6 'send (send o2 f-2-c))
+
+(test 7 uq-ivar o1 'd)
+(test 7 uq-ivar o2 'd)
+
+(test 10 'send (send o1 f-1-v))
+(test 10 'send (send o2 f-1-v))
+(test 20 'send (send o2 f-2-v))
+(test 20 'send (send o2 f-2-v-copy))
+
+(error-test '(ivar o2 i-f-2-v) ivar?)
+
+(test 0 'send (send o1 f-1-other-e o1))
+(test 1 'send (send o1 f-1-other-e o2))
+
+(test 2 uq-ivar o2 'y)
+
+(test 3 'send (send o2 f-2-set-b2 3))
+(test 3 'send (send o2 f-2-also-b2))
+
+(test 'i-a 'send (send o6 i-a))
+(test 'x-a 'send (send o6 x-a))
+(test 'i-a 'send (send o6 i-a-copy))
+(test 'x-a 'send (send o6 x-a-copy))
+(test 'x-x 'send (send o6 x-x))
+
+(test #t eq? o7 (send o7 get-self))
+
+(define g1 (make-generic c1 x))
+(test 1 g1 o1)
+(test 1 g1 o2)
+
+(define g2 (make-generic c2 x))
+(test 1 g2 o2)
+
+(define g0 (make-generic i0.1 x))
+(test 1 g0 o1)
+(test 1 g0 o2)
+(test 'hi g0 (make-object (class* () (i0.1) () (public [x 'hi][y 'bye]))))
+
+(error-test '(g2 o1) exn:object:generic?)
+(error-test '(g0 o3) exn:object:generic?)
+
+(error-test '(class* 7 () ()) exn:object:class-type?)
+(error-test '(let ([c (class* 7 () ())]) c) exn:object:class-type?)
+(error-test '(class* () (i1 7) ()) exn:object:interface-type?)
+(error-test '(let ([c (class* () (i1 7) ())]) c) exn:object:interface-type?)
+(error-test '(interface (8) x) exn:object:interface-type?)
+(error-test '(let ([i (interface (8) x)]) i) exn:object:interface-type?)
+(error-test '(interface (i1 8) x) exn:object:interface-type?)
+(error-test '(make-generic c2 not-there) exn:object:class-ivar?)
+
+(error-test '(make-object (class* c1 () ())) exn:object:init:never?)
+(error-test '(make-object (let ([c (class* c1 () ())]) c)) exn:object:init:never?)
+
+(error-test '(make-object 
+	      (class* c2 () () (sequence (super-init) (super-init)))) 
+	    exn:object:init:multiple?)
+(error-test '(make-object 
+	      (let ([c (class* c2 () () (sequence (super-init) (super-init)))]) c))
+	    exn:object:init:multiple?)
+
+(error-test '(make-object (class null (x))) exn:application:arity?)
+(error-test '(make-object (let ([c (class null (x))]) c)) exn:application:arity?)
+	      
+
+(define c100
+  (let loop ([n 99][c c1])
+    (if (zero? n)
+	c
+	(loop (sub1 n) (class c args 
+			      (public (z n))
+			      (sequence
+				(apply super-init args)))))))
+
+(define o100 (make-object c100 100))
+(test 100 'send (send o100 f-1-a))
+(test 1 'ivar (ivar o100 z))
+
+(test 5 'init (let ([g-x 8]) (make-object (class* () () ([x (set! g-x 5)]))) g-x))
+(test 8 'init (let ([g-x 8]) (make-object (class* () () ([x (set! g-x 5)])) 0) g-x))
+
+(test (letrec ([x x]) x) 'init (send (make-object 
+				      (class* () () ([x y] [y x]) (public (f (lambda () x)))))
+				     f))
+
+(define inh-test-expr
+ (lambda (super derive-pre? rename? override? override-pre?)
+   (let* ([order
+	   (lambda (pre? a b)
+	     (if pre?
+		 (list a b)
+		 (list b a)))]
+	  [base-class
+	   `(class ,(if super
+			super
+			'(class null (n) (public [name (lambda () n)])))
+		   ()
+		   ,(if (not rename?)
+			'(inherit name)
+			'(rename [super-name name]))
+		   ,@(order
+		      derive-pre?
+		      `(public [w ,(if rename? 'super-name 'name)])
+		      '(sequence (super-init 'tester))))])
+     `(ivar
+       (make-object
+	,(if override?
+	     `(class ,base-class ()
+		     ,@(order
+			override-pre?
+			'(sequence (super-init))
+			'(public [name (lambda () 'o-tester)])))
+	     base-class))
+       w))))
+
+(define (do-override-tests super)
+  (define (eval-test v e)
+    (teval `(test ,v (quote, e)
+		  (let ([v ,e]) 
+		    (if (procedure? v)
+			(v)
+			v)))))
+
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #t #f  #f #f))
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #t #f  #t #t))
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #f #f  #t #t))
+
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #t #t  #f #f))
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #t #t  #t #f))
+  (eval-test '(letrec ([x x]) x) (inh-test-expr super #t #t  #t #t))
+  
+  (eval-test ''tester (inh-test-expr super #f #f  #f #f))
+  (eval-test ''o-tester (inh-test-expr super #t #f  #t #f))
+  (eval-test ''o-tester (inh-test-expr super #f #f  #t #f))
+
+  (eval-test ''tester (inh-test-expr super #f #t  #f #f))  
+  (eval-test ''tester (inh-test-expr super #f #t  #t #t))
+  (eval-test ''tester (inh-test-expr super #f #t  #t #f)))
+
+(do-override-tests #f)
+
+(when (defined? 'primclass%)
+      (error-test '(make-object primclass%) exn:application:arity?)
+      (error-test '(make-object primsubclass%) exn:application:arity?)
+
+      (define o (make-object primclass% 'tester))
+      (arity-test (ivar o name) 0 0)
+      (test 'tester (ivar o name))
+      (test "primclass%" (ivar o class-name))
+
+      (define o2 (make-object primsubclass% 'tester))
+      (arity-test (ivar o2 name) 0 0)
+      (arity-test (ivar o2 detail) 0 0)
+      (test 'tester (ivar o2 name))
+      (test #f (ivar o2 detail))
+      (test "primsubclass%" (ivar o2 class-name))
+
+      (do-override-tests 'primclass%)
+      (do-override-tests 'primsubclass%)
+
+      (define name-g (make-generic primclass% name))
+      (define class-name-g (make-generic primclass% class-name))
+
+      (define sub-name-g (make-generic primsubclass% name))
+      (define sub-class-name-g (make-generic primsubclass% class-name))
+      (define sub-detail-g (make-generic primsubclass% detail))
+
+      (test 'tester (name-g o))
+      (test "primclass%" (class-name-g o))
+
+      (test 'tester (name-g o2))
+      (test "primsubclass%" (class-name-g o2))
+      (test 'tester (sub-name-g o2))
+      (test "primsubclass%" (sub-class-name-g o2))
+      (test #f (sub-detail-g o2))
+
+      (define c%
+	(class primsubclass% ()
+	   (inherit name detail class-name)
+	   (sequence (super-init 'example))
+	   (public
+	    [n name]
+	    [d detail]
+	    [c class-name])))
+
+      (define o3 (make-object c%))
+      (test 'example (ivar o3 n))
+      (test #f (ivar o3 d))
+      (test "primsubclass%" (ivar o3 c))
+      (test 'example (ivar o3 name))
+      (test #f (ivar o3 detail))
+      (test "primsubclass%" (ivar o3 class-name))
+
+      (test 'example (name-g o3))
+      (test "primsubclass%" (class-name-g o3))
+      (test 'example (sub-name-g o3))
+      (test "primsubclass%" (sub-class-name-g o3))
+      (test #f (sub-detail-g o3)))
+
+(report-errs)
+
diff --git a/collects/tests/mzscheme/oe.ss b/collects/tests/mzscheme/oe.ss
new file mode 100644
index 0000000..b2b1740
--- /dev/null
+++ b/collects/tests/mzscheme/oe.ss
@@ -0,0 +1,42 @@
+(define-values (odd) (lambda (x) (if (zero? x) #f (even (- x 1)))))
+(define-values (even) (lambda (x) (if (zero? x) #t (odd (- x 1)))))
+
+(define-values (odd2)
+  (letrec ([even (lambda (x) (if (zero? x) #t (odd (- x 1))))]
+	   [odd (lambda (x) (if (zero? x) #f (even (- x 1))))])
+    odd))
+
+(define-values (odd3)
+  (let ([test (lambda (base other)
+		(lambda (x) (if (zero? x) base ((other) (- x 1)))))])
+    (letrec ([odd (test #f (lambda () even))]
+	     [even (test #t (lambda () odd))])
+      odd)))
+
+(define-values (fib)
+  (lambda (n)
+    (if (<= n 1)
+	1
+	(+ (fib (- n 1)) (fib (- n 2))))))
+
+(define-values (mutate)
+  (lambda (n)
+    (let loop ()
+      (unless (zero? n)
+	      (set! n (sub1 n))
+	      (loop)))))
+
+(define-values (mutate-evil)
+  (lambda (n)
+    (let loop ([n n])
+      (unless (zero? n)
+	      (set! n (sub1 n))
+	      (loop n)))))
+
+(define-values (c-loop)
+  (let-values ([(a b c d e f g) (values 1 2 3 4 5 6 7)])
+    (lambda (n)
+      (let loop ([n n])
+	(if (zero? n)
+	    (+ a b c d e f g)
+	    (loop (sub1 n)))))))
diff --git a/collects/tests/mzscheme/oee.ss b/collects/tests/mzscheme/oee.ss
new file mode 100644
index 0000000..a4a4827
--- /dev/null
+++ b/collects/tests/mzscheme/oee.ss
@@ -0,0 +1,45 @@
+
+; Test the oe extension
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(define b1 (class null () (public [z1 7][z2 8])))
+(define b3 (class null () (public [z1 13][z2 14])))
+
+(define i1 (mktinterface (interface () z1)))
+(define i3 (mktinterface (interface () z2)))
+
+(define c1 (mktclass b1 i1))
+(define c3 (mktclass b3 i3))
+
+(define o1 (make-object c1 1 2))
+(define o2 (make-object c1 3 4))
+(define o3 (make-object c3 5 6))
+
+(test 5 'oee (send o1 get-y))
+(test 5 'oee (send o2 get-y))
+(test 5 'oee (send o3 get-y))
+
+(test 7 'oee (send o1 get-z1))
+(test 7 'oee (send o2 get-z1))
+(test 13 'oee (send o3 get-z1))
+
+(test 8 'oee (send o1 get-z2))
+(test 8 'oee (send o2 get-z2))
+(test 14 'oee (send o3 get-z2))
+
+(test 1 'oee (send o1 get-x1))
+(test 3 'oee (send o2 get-x1))
+(test 5 'oee (send o3 get-x1))
+
+(test 2 'oee (send o1 get-x2))
+(test 4 'oee (send o2 get-x2))
+(test 6 'oee (send o3 get-x2))
+
+(error-test '(mktinterface 0) exn:object:interface-type?)
+(error-test '(mktclass 0 i1) exn:object:class-type?)
+(error-test '(mktclass b1 0) exn:object:interface-type?)
+(error-test '(mktclass b1 (interface () not-there)) exn:object:implement?)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/optimize.ss b/collects/tests/mzscheme/optimize.ss
new file mode 100644
index 0000000..f23115a
--- /dev/null
+++ b/collects/tests/mzscheme/optimize.ss
@@ -0,0 +1,57 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'optimization)
+
+(define (comp=? c1 c2)
+  (let ([s1 (open-output-string)]
+	[s2 (open-output-string)])
+    (write c1 s1)
+    (write c2 s2)
+    (string=? (get-output-string s1) (get-output-string s2))))
+
+(define test-comp
+  (case-lambda
+   [(expr1 expr2) (test-comp expr1 expr2 #t)]
+   [(expr1 expr2 same?)
+    (test same? `(compile ,same? ,expr2) (comp=? (compile expr1) (compile expr2)))]))
+
+(test-comp 5 '(if #t 5 (cons 1 2)))
+(test-comp 5 '(if #f (cons 1 2) 5))
+
+(test-comp 5 '(begin0 5 'hi "apple" 1.5))
+(test-comp 5 '(begin0 5 (begin0 'hi "apple" 1.5)))
+(test-comp 5 '(begin0 5 (begin0 'hi "apple") 1.5))
+(test-comp 5 '(begin0 5 (begin 'hi "apple" 1.5)))
+(test-comp 5 '(begin0 5 (begin 'hi "apple") 1.5))
+(test-comp 5 '(begin0 (begin0 5 'hi "apple" 1.5)))
+(test-comp 5 '(begin0 (begin0 5 'hi "apple") 1.5))
+
+(test-comp 5 '(begin 'hi "apple" 1.5 5))
+(test-comp 5 '(begin (begin 'hi "apple" 1.5) 5))
+(test-comp 5 '(begin (begin 'hi "apple") 1.5 5))
+(test-comp 5 '(begin (begin0 'hi "apple" 1.5) 5))
+(test-comp 5 '(begin (begin0 'hi "apple") 1.5 5))
+(test-comp 5 '(begin (begin 'hi "apple" 1.5 5)))
+(test-comp 5 '(begin 'hi (begin "apple" 1.5 5)))
+
+(test-comp '(let ([x 8][y 9]) (lambda () x))
+	   '(let ([x 8][y 9]) (lambda () (if #f y x))))
+(test-comp '(let ([x 8][y 9]) (lambda () (+ x y)))
+	   '(let ([x 8][y 9]) (lambda () (if #f y (+ x y)))))
+
+(test-comp '(let ([x 5]) (set! x 2)) '(let ([x 5]) (set! x x) (set! x 2)))
+
+(test-comp '(let* () (f 5))
+	   '(f 5))
+(test-comp '(letrec* () (f 5))
+	   '(f 5))
+(test-comp '(with-handlers () (f 5))
+	   '(f 5))
+(test-comp '(parameterize () (f 5))
+	   '(f 5))
+(test-comp '(fluid-let () (f 5))
+	   '(f 5))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/parallel.ss b/collects/tests/mzscheme/parallel.ss
new file mode 100644
index 0000000..4cab5b5
--- /dev/null
+++ b/collects/tests/mzscheme/parallel.ss
@@ -0,0 +1,50 @@
+
+;; Runs 3 threads perfoming the test suite simultaneously. Each
+;;  thread creates a directory sub<n> to run in, so that filesystem
+;;  tests don't collide.
+
+; Runs n versions of test in parallel threads and namespaces, 
+; waiting until all are done
+(define (parallel n test)
+  (let ([done (make-semaphore)]
+	[go (make-semaphore)])
+    (let loop ([n n])
+      (unless (zero? n)
+	      (let ([ns (make-namespace)]
+		    [p (make-parameterization)])
+		(thread
+		 (lambda ()
+		   (with-parameterization 
+		    p
+		    (lambda ()
+		      (parameterize ([current-namespace ns]
+				     [parameterization-branch-handler
+				      (lambda () (make-parameterization p))])
+				    (let ([dirname (format "sub~s" n)])
+				      (unless (directory-exists? dirname)
+					      (make-directory dirname))
+				      (current-directory dirname)
+				      (dynamic-wind
+				       void
+				       (lambda ()
+					 (load test))
+				       (lambda ()
+					 (semaphore-post done)
+					 (semaphore-wait go)
+					 (printf "~nThread ~s:" n)
+					 (eval '(report-errs))
+					 (current-directory (build-path 'up))
+					 (delete-directory dirname)
+					 (semaphore-post done)))))))))
+		(loop (sub1 n)))))
+    (let loop ([n n])
+      (unless (zero? n)
+	      (semaphore-wait done)
+	      (loop (sub1 n))))
+    (let loop ([n n])
+      (unless (zero? n)
+	      (semaphore-post go)
+	      (semaphore-wait done)
+	      (loop (sub1 n))))))
+
+(parallel 3 (path->complete-path "all.ss" (current-load-relative-directory)))
diff --git a/collects/tests/mzscheme/param.ss b/collects/tests/mzscheme/param.ss
new file mode 100644
index 0000000..0c6adff
--- /dev/null
+++ b/collects/tests/mzscheme/param.ss
@@ -0,0 +1,567 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'parameterizations)
+
+(let ([p (open-output-file "tmp5" 'replace)])
+  (display (compile '(cons 1 2)) p)
+  (close-output-port p))
+
+(define-struct tester (x))
+(define a-tester (make-tester 5))
+
+(define (check-write-string v s)
+  (let ([p (open-output-string)])
+    (display v p)
+    (let ([s2 (get-output-string p)])
+      (or (string=? s s2)
+	  (error 'check-string "strings didn't match: ~s vs. ~s"
+		 s s2)))))
+
+(define exn:check-string? exn:user?)
+
+(define called-break? #f)
+
+(define erroring-set? #f)
+
+(define erroring-port
+  (make-output-port (let ([orig (current-output-port)])
+		      (lambda (s) 
+			(if erroring-set?
+			    (begin
+			      (set! erroring-set? #f)
+			      (error 'output))
+			    (display s orig))))
+		    void))
+
+(define erroring-eval
+  (let ([orig (current-eval)])
+    (lambda (x)
+      (if erroring-set?
+	  (begin
+	    (set! erroring-set? #f)
+	    (error 'eval))
+	  (orig x)))))
+
+(define blocking-thread
+  (lambda (thunk)
+    (let ([x #f])
+      (thread-wait (thread (lambda () (set! x (thunk)))))
+      x)))
+
+(define main-cust (current-custodian))
+(define main-executor (current-will-executor))
+
+(define zero-arg-proc (lambda () #t))
+(define one-arg-proc (lambda (x) #t))
+(define two-arg-proc (lambda (x y) #t))
+(define three-arg-proc (lambda (x y z) #t))
+
+(define test-param1 (make-parameter 'one))
+(define test-param2 (make-parameter 
+		     'two
+		     ; generates type error:
+		     (lambda (x) (if (symbol? x)
+				     x
+				     (add1 'x)))))
+
+(test 'one test-param1)
+(test 'two test-param2) 
+
+(arity-test make-parameter 1 2)
+(error-test '(make-parameter 0 zero-arg-proc))
+(error-test '(make-parameter 0 two-arg-proc))
+
+(define-struct bad-test (value exn?))
+
+(define params (list
+		(list read-case-sensitive 
+		      (list #f #t) 
+		      '(if (eq? (read (open-input-string "HELLO")) (quote hello))
+			   (void) 
+			   (error (quote hello)))
+		      exn:user?
+		      #f)
+		(list read-square-bracket-as-paren
+		      (list #t #f)
+		      '(when (symbol? (read (open-input-string "[4]")))
+			     (error 'read))
+		      exn:user?
+		      #f)
+		(list read-curly-brace-as-paren
+		      (list #t #f)
+		      '(when (symbol? (read (open-input-string "{4}")))
+			     (error 'read))
+		      exn:user?
+		      #f)
+		(list read-accept-box
+		      (list #t #f)
+		      '(read (open-input-string "#&5"))
+		      exn:read:unsupported?
+		      #f)
+		(list read-accept-graph
+		      (list #t #f)
+		      '(read (open-input-string "#0=(1 . #0#)"))
+		      exn:read:unsupported?
+		      #f)
+		(list read-accept-compiled
+		      (list #t #f)
+		      '(let ([p (open-input-file "tmp5")])
+			 (dynamic-wind
+			  void
+			  (lambda () (read p))
+			  (lambda () (close-input-port p))))
+		      exn:read:unsupported?
+		      #f)
+		(list read-accept-type-symbol
+		      (list #t #f)
+		      '(read (open-input-string "#<hello>"))
+		      exn:read:unsupported?
+		      #f)
+		(list read-accept-bar-quote
+		      (list #t #f)
+		      '(let ([p (open-input-string "|hello #$ there| x")])
+			 (read p)
+			 (read p))
+		      exn:read:unsupported?
+		      #f)
+		(list print-graph
+		      (list #t #f)
+		      '(check-write-string (quote (#0=(1 2) . #0#)) "(#0=(1 2) . #0#)")
+		      exn:check-string?
+		      #f)
+		(list print-struct
+		      (list #t #f)
+		      '(check-write-string a-tester "#(struct:tester 5)")
+		      exn:check-string?
+		      #f)
+		(list print-box
+		      (list #t #f)
+		      '(check-write-string (box 5) "#&5")
+		      exn:check-string?
+		      #f)
+
+		(list current-input-port
+		      (list (make-input-port (lambda () #\x) (lambda () #t) void)
+			    (make-input-port (lambda () 5) (lambda () #t) void))
+		      '(read-char)
+		      exn:i/o:user-port?
+		      '("bad string"))
+		(list current-output-port
+		      (list (current-output-port)
+			    erroring-port)
+		      '(begin 
+			 (set! erroring-set? #t) 
+			 (display 5) 
+			 (set! erroring-set? #f))
+		      exn:user?
+		      '("bad string"))
+
+#|
+		; Doesn't work since error-test sets the port!
+		(list current-error-port
+		      (list (current-error-port)
+			    erroring-port)
+		      '(begin 
+			 (set! erroring-set? #t) 
+			 ((error-display-handler) "hello")
+			 (set! erroring-set? #f))
+		      exn:user?
+		      "bad setting")
+|#
+		
+		(list compile-allow-cond-fallthrough
+		      (list #t #f)
+		      '(cond)
+		      exn:else?
+		      #f)
+		
+		(list compile-allow-set!-undefined
+		      (list #t #f)
+		      '(eval `(set! ,(gensym) 9))
+		      exn:variable?
+		      #f)
+
+		(list current-namespace
+		      (list (make-namespace)
+			    (make-namespace 'hash-percent-syntax))
+		      '(begin 0)
+		      exn:variable?
+		      '("bad setting"))
+
+		(list error-print-width
+		      (list 10 50)
+		      '(when (< 10 (error-print-width)) (error 'print-width))
+		      exn:user?
+		      '("bad setting"))
+		(list error-value->string-handler
+		      (list (error-value->string-handler) (lambda (x w) (error 'converter)))
+		      '(format "~e" 10)
+		      exn:user?
+		      (list "bad setting" zero-arg-proc one-arg-proc three-arg-proc))
+
+		(list debug-info-handler
+		      (list (debug-info-handler)
+			    (lambda () 'boo!))
+		      `(with-handlers ([(lambda (x) (not (eq? (exn-debug-info x) 'boo!))) void])
+			   (/ 0))
+		      exn:application:math:zero?
+		      (list "bad setting" one-arg-proc two-arg-proc))
+
+		(list user-break-poll-handler
+		      (list (user-break-poll-handler)
+			    (lambda () (set! called-break? #t) #f))
+		      `(begin
+			 (set! called-break? #f)
+			 ((user-break-poll-handler))
+			 (if called-break?
+			     (error 'break))
+			 (set! called-break? #f))
+		      exn:user?
+		      (list "bad setting" one-arg-proc two-arg-proc))
+		(list break-enabled
+		      (list #t #f)
+		      '(let ([cont? #f])
+			 (thread-wait
+			  (parameterize ([parameterization-branch-handler
+					  current-parameterization])
+			     (thread
+			      (lambda ()
+				(break-thread (current-thread))
+				(sleep)
+				(set! cont? #t)))))
+			 (when cont?
+			       (error 'break-enabled)))
+		      exn:user?
+		      #f)
+		; exception-break-enabled: still needs test!
+
+		(list current-print
+		      (list (current-print)
+			    (lambda (x) (display "frog")))
+		      `(let ([i (open-input-string "5")]
+			     [o (open-output-string)])
+			 (parameterize ([current-input-port i]
+					[current-output-port o])
+			     (read-eval-print-loop))
+			 (let ([s (get-output-string o)])
+			   (unless (char=? #\5 (string-ref s 2))
+				   (error 'print))))
+		      exn:user?
+		      (list "bad setting" zero-arg-proc two-arg-proc))
+
+		(list current-prompt-read
+		      (list (current-prompt-read)
+			    (let ([x #f]) 
+			      (lambda () 
+				(set! x (not x))
+				(if x
+				    '(quote hi)
+				    eof))))
+		      `(let ([i (open-input-string "5")]
+			     [o (open-output-string)])
+			 (parameterize ([current-input-port i]
+					[current-output-port o])
+			     (read-eval-print-loop))
+			 (let ([s (get-output-string o)])
+			   (unless (and (char=? #\> (string-ref s 0))
+					(not (char=? #\h (string-ref s 0))))
+				   (error 'prompt))))
+		      exn:user?
+		      (list "bad setting" one-arg-proc two-arg-proc))
+
+		(list current-load
+		      (list (current-load) (lambda (f) (error "This won't do it")))
+		      '(load "tmp5")
+		      exn:user?
+		      (list "bad setting" zero-arg-proc two-arg-proc))
+		(list current-eval	
+		      (list (current-eval) erroring-eval)
+		      '(begin 
+			 (set! erroring-set? #t) 
+			 (eval 5)
+			 (set! erroring-set? #f))
+		      exn:user?
+		      (list "bad setting" zero-arg-proc two-arg-proc))
+
+		(list current-load-relative-directory
+		      (list (current-load-relative-directory) 
+			    (build-path (current-load-relative-directory) 'up))
+		      '(load-relative "loadable.ss")
+		      exn:i/o:filesystem:file?
+		      (append (list 0)
+			      (map
+			       (lambda (t)
+				 (make-bad-test t exn:i/o:filesystem:path?))
+			       (list
+				"definitely a bad path"
+				(string #\a #\nul #\b)
+				"relative"
+				(build-path 'up))))
+		      equal?)
+
+		(list global-port-print-handler
+		      (list write display)
+		      '(let ([s (open-output-string)])
+			 (print "hi" s)
+			 (unless (char=? #\" (string-ref (get-output-string s) 0))
+				 (error 'global-port-print-handler)))
+		      exn:user?
+		      (list "bad setting" zero-arg-proc one-arg-proc three-arg-proc))
+
+		(list current-custodian
+		      (list main-cust (make-custodian))
+		      '(let ([th (parameterize ([current-custodian main-cust])
+				    (thread (lambda () (sleep 1))))])
+			 (kill-thread th))
+		      exn:misc:thread:kill?
+		      (list "bad setting"))
+
+		(list current-will-executor
+		      (list main-executor (make-will-executor))
+		      '(unless (eq? main-executor (current-will-executor))
+			       (error 'will-exec))
+		      exn:user?
+		      (list "bad setting"))
+
+		(list exit-handler
+		      (list void (lambda (x) (error 'exit-handler)))
+		      '(exit)
+		      exn:user?
+		      (list "bad setting" zero-arg-proc two-arg-proc))
+
+		(list test-param1
+		      (list 'one 'bad-one)
+		      '(when (eq? (test-param1) 'bad-one)
+			     (error 'bad-one))
+		      exn:user?
+		      #f)
+		(list test-param2
+		      (list 'two 'bad-two)
+		      '(when (eq? (test-param2) 'bad-two)
+			     (error 'bad-two))
+		      exn:user?
+		      '("bad string"))))
+
+(for-each
+ (lambda (d)
+   (let ([param (car d)]
+	 [alt1 (caadr d)]
+	 [alt2 (cadadr d)]
+	 [expr (caddr d)]
+	 [exn? (cadddr d)])
+     (parameterize ([param alt1])
+	  (test (void) void (teval expr)))
+     (parameterize ([param alt2])
+	  (error-test expr exn?))))
+ params)
+
+(define p1 (make-parameterization))
+(define p2 (make-parameterization p1))
+(define p3 (make-parameterization p2))
+(define p3.again (make-parameterization-with-sharing p3 p3 null void))
+
+(test #t parameterization? p1)
+(test #f parameterization? 'hi)
+(arity-test parameterization? 1 1)
+
+(test 'one (in-parameterization p3 test-param1))
+(test 'two (in-parameterization p3 test-param2))
+
+(define test-param3 (make-parameter 'hi))
+(test 'hi (in-parameterization p3 test-param3))
+((in-parameterization p3 test-param3) 'goodbye)
+(test 'goodbye (in-parameterization p3.again test-param3))
+
+(arity-test make-parameterization 0 1)
+(error-test '(make-parameterization #f))
+
+(arity-test in-parameterization 2 2)
+(error-test '(in-parameterization #f current-output-port))
+(error-test '(in-parameterization p1 (lambda (x) 8)))
+(error-test '(in-parameterization p1 add1))
+
+; Randomly set some
+(for-each
+ (lambda (d)
+   (let* ([param (car d)]
+	  [alt1 (caadr d)])
+     (when (zero? (random 2))
+	   (display "setting ") (display param) (newline)
+	   (test (void) (in-parameterization p1 param) alt1))))
+ params)
+
+(test #f parameter? add1)
+
+(for-each
+ (lambda (d)
+   (let* ([param (car d)]
+	  [alt1 (caadr d)]
+	  [bads (cadddr (cdr d))]
+	  [pp1 (in-parameterization p1 param)])
+     (test #t parameter? param)
+     (arity-test param 0 1)
+     (arity-test pp1 0 1)
+     (when bads
+	   (for-each
+	    (lambda (bad)
+	      (let-values ([(bad exn?)
+			    (if (bad-test? bad)
+				(values (bad-test-value bad)
+					(bad-test-exn? bad))
+				(values bad
+					exn:application:type?))])
+			  (error-test `(,param ,bad) exn?)
+			  (error-test `(,pp1 ,bad) exn?)))
+	    bads))))
+ params)
+
+((in-parameterization p1 error-print-width) 577)
+(define main-pw (error-print-width))
+(test #f = 577 main-pw)
+
+(test #t = main-pw (blocking-thread (lambda () (error-print-width))))
+(parameterize ([parameterization-branch-handler
+		(lambda ()
+		  (make-parameterization p1))])
+    (test #t equal? '(577 578 578)
+	    (blocking-thread 
+	     (lambda () 
+	       (list
+		(begin0 
+		 (error-print-width)
+		 (error-print-width 578))
+		(error-print-width)
+		(blocking-thread ; this thread made with p1's branch handler, which is the default one
+		 (lambda () (error-print-width)))))))
+    (test #t = main-pw (error-print-width)))
+
+(test #t = main-pw (error-print-width))
+(test #t = main-pw (blocking-thread (lambda () (error-print-width))))
+
+(test 577 'ize (parameterize ([error-print-width 577])
+		  (error-print-width)))
+(test main-pw error-print-width)
+
+(test 577 with-new-parameterization
+      (lambda ()
+	(error-print-width 577)
+	(error-print-width)))
+(test main-pw error-print-width)
+
+(define (make-sharing share-from)
+  (make-parameterization-with-sharing 
+   p1 #f 
+   (list read-case-sensitive test-param2 test-param1)
+   (lambda (x)
+     (if (or (parameter-procedure=? x read-case-sensitive)
+	     (parameter-procedure=? x test-param2))
+	 share-from
+	 #f))))
+
+(define (check-sharing p-share other inh)
+  (define (check-one-param param v1 v2 shared?)
+    (with-parameterization 
+     p-share
+     (lambda ()
+       (test v1 param)
+       (parameterize ([param v2])
+          (test v2 param)
+	  (test (if shared? v2 v1) (in-parameterization other param))
+	  (test v1 (in-parameterization inh param))
+	  (if shared?
+	      (begin
+		((in-parameterization other param) v1)
+		(test v1 param)
+		(param v2))
+	      (with-parameterization
+	       other
+	       (lambda ()
+		 (parameterize ([param v1])
+		    (test v2 (in-parameterization p-share param)))))))
+       (test v1 param)
+       (test v1 (in-parameterization other param))
+       (with-parameterization 
+	other
+	(lambda ()
+	  (parameterize ([param v2])
+	     (test v2 param)
+	     (test v1 (in-parameterization inh param))
+	     (test (if shared? v2 v1) (in-parameterization p-share param)))))
+       (with-parameterization 
+	inh
+	(lambda ()
+	  (let ([o1 ((in-parameterization other param))]
+		[o2 ((in-parameterization p-share param))])
+	    (parameterize ([param v2])
+	     (test v2 param)
+	     (test o1 (in-parameterization other param))
+	     (test o2 (in-parameterization p-share param))))))
+       (test v1 param))))
+
+  (check-one-param read-accept-compiled #f #t #f)
+  (check-one-param read-case-sensitive #f #t #t)
+  (check-one-param test-param1 'one 'uno #f)
+  (check-one-param test-param2 'two 'dos #t))
+
+((in-parameterization p1 read-accept-compiled) #f)
+((in-parameterization p1 read-case-sensitive) #f)
+
+((in-parameterization p1 test-param2) 'two)
+((in-parameterization p1 test-param1) 'one)
+
+(define ps1.a (make-sharing p3))
+(define ps1.b (make-sharing p3))
+(define ps2 (make-sharing ps1.a))
+
+(check-sharing ps1.a p3 p1)
+(check-sharing ps1.b p3 p1)
+(check-sharing ps2 p3 p1)
+(check-sharing ps2 ps1.a p1)
+
+(test #t parameterization? (make-parameterization-with-sharing (current-parameterization) #f null void))
+(test #t parameterization? (make-parameterization-with-sharing (current-parameterization) (current-parameterization) null void))
+
+(arity-test make-parameterization-with-sharing 4 4)
+(error-test '(make-parameterization-with-sharing #f #f null void))
+(error-test '(make-parameterization-with-sharing (current-parameterization) 2 null void))
+(error-test '(make-parameterization-with-sharing (current-parameterization) #f (list 5) void))
+(error-test '(make-parameterization-with-sharing (current-parameterization) #f (list read-case-sensitive read-case-sensitive) void))
+(error-test '(make-parameterization-with-sharing (current-parameterization) #f (list read-case-sensitive) (lambda () 0)))
+(error-test '(make-parameterization-with-sharing (current-parameterization) #f (list read-case-sensitive) (lambda (x) 0))
+	    exn:misc:parameterization?)
+
+(arity-test with-new-parameterization 1 1)
+(arity-test with-parameterization 2 2)
+
+(arity-test parameterization-branch-handler 0 1)
+(error-test '(parameterization-branch-handler 0))
+(error-test '(parameterization-branch-handler (lambda (x) x)))
+(error-test '(parameterize ([parameterization-branch-handler void])
+			   (thread void))
+	    exn:misc:parameterization?)
+
+(test #t parameter-procedure=? read-accept-compiled read-accept-compiled)
+(test #f parameter-procedure=? read-accept-compiled read-case-sensitive)
+(error-test '(parameter-procedure=? read-accept-compiled 5))
+(error-test '(parameter-procedure=? 5 read-accept-compiled))
+(arity-test parameter-procedure=? 2 2)
+
+; Test current-library-collection-paths?
+; Test require-library-use-compiled?
+
+; Use this with SGC to check GC behavior:
+(define save-it #f)
+(define (pgc-check)
+  (let ([rp (current-parameterization)])
+    (let loop ([n 100][p rp])
+      (if (zero? n)
+	  (set! save-it p)
+	  (begin
+	    (make-parameter n)
+	    (make-parameterization)
+	    (make-parameterization-with-sharing rp rp null void)
+	    (loop (sub1 n) (make-parameterization-with-sharing p p null void)))))))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/path.ss b/collects/tests/mzscheme/path.ss
new file mode 100644
index 0000000..003ebb9
--- /dev/null
+++ b/collects/tests/mzscheme/path.ss
@@ -0,0 +1,326 @@
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'PATH)
+
+(test #f relative-path? (current-directory))
+(test #t relative-path? "down")
+(test #t relative-path? (build-path 'up "down"))
+(test #t relative-path? (build-path 'same "down"))
+(test #t relative-path? (build-path 'same "down" "deep"))
+(test #f relative-path? (build-path (current-directory) 'up "down"))
+(test #f relative-path? (build-path (current-directory) 'same "down"))
+(test #f relative-path? (build-path (current-directory) 'same "down" "deep"))
+(test #f relative-path? (string #\a #\nul #\b))
+
+(arity-test relative-path? 1 1)
+(error-test '(relative-path? 'a))
+
+(test #t absolute-path? (current-directory))
+(test #f absolute-path? (build-path 'up))
+(test #f absolute-path? (string #\a #\nul #\b))
+
+(arity-test absolute-path? 1 1)
+(error-test '(absolute-path? 'a))
+
+(test #t complete-path? (current-directory))
+(test #f complete-path? (build-path 'up))
+(test #f complete-path? (string #\a #\nul #\b))
+
+(arity-test complete-path? 1 1)
+(error-test '(complete-path? 'a))
+
+(call-with-output-file "tmp6" void 'replace)
+(define existant "tmp6")
+
+(test #t file-exists? existant)
+
+(test #t make-directory "down")
+(test #f make-directory "down")
+(test #t directory-exists? "down")
+(test #f file-exists? "down")
+
+(define deepdir (build-path "down" "deep"))
+(test #t make-directory deepdir)
+(test #f make-directory deepdir)
+(test #t directory-exists? deepdir)
+(test #f file-exists? deepdir)
+
+(test #t file-exists? (build-path "down" 'up existant))
+(test #t file-exists? (build-path deepdir 'up 'up existant))
+(test #t file-exists? (build-path 'same deepdir 'same 'up 'same 'up existant))
+
+(test #f file-exists? (build-path "down" existant))
+(test #f file-exists? (build-path deepdir 'up existant))
+(test #f file-exists? (build-path 'same deepdir 'same 'same 'up existant))
+
+(delete-file "tmp6")
+
+(test #f file-exists? (build-path "down" 'up "badfile"))
+(test #f file-exists? (build-path deepdir 'up 'up "badfile"))
+(test #f file-exists? (build-path 'same deepdir 'same 'up 'same 'up "badfile"))
+
+(error-test '(open-output-file (build-path "wrong" "down" "tmp8"))
+	    exn:i/o:filesystem:file?)
+(error-test '(open-output-file (build-path deepdir "wrong" "tmp7"))
+	    exn:i/o:filesystem:file?)
+
+(define start-time (current-seconds))
+(close-output-port (open-output-file "tmp5" 'replace))
+(close-output-port (open-output-file (build-path "down" "tmp8") 'replace))
+(close-output-port (open-output-file (build-path deepdir "tmp7") 'replace))
+(define end-time (current-seconds))
+
+(map
+ (lambda (f)
+   (let ([time (seconds->date (file-modify-seconds f))]
+	 [start (seconds->date start-time)]
+	 [end (seconds->date end-time)])
+     (test #t = (date-year start) (date-year time) (date-year end))
+     (test #t = (date-month start) (date-month time) (date-month end))
+     (test #t = (date-day start) (date-day time) (date-day end))
+     (test #t = (date-week-day start) (date-week-day time) (date-week-day end))
+     (test #t = (date-year-day start) (date-year-day time) (date-year-day end))
+     (test #t = (date-hour start) (date-hour time) (date-hour end))
+     (test #t <= (date-minute start) (date-minute time) (date-minute end))
+     (test #t <= (date-second start) (date-second time) (date-second end))))
+ (list "tmp5"
+       (build-path "down" "tmp8")
+       (build-path deepdir "tmp7")))
+
+(test #t file-exists? "tmp5")
+(test #t file-exists? (build-path "down" "tmp8"))
+(test #t file-exists? (build-path deepdir "tmp7"))
+
+(test #t rename-file "tmp5" "tmp5x")
+(test #f rename-file "tmp5" "tmp5x")
+(test #t rename-file (build-path "down" "tmp8") (build-path "down" "tmp8x"))
+(test #f rename-file (build-path "down" "tmp8") (build-path "down" "tmp8x"))
+(test #t rename-file (build-path deepdir "tmp7") (build-path deepdir "tmp7x"))
+(test #f rename-file (build-path deepdir "tmp7") (build-path deepdir "tmp7x"))
+
+(test #t rename-file (build-path deepdir "tmp7x") "tmp7x")
+(test #f rename-file (build-path deepdir "tmp7x") "tmp7x")
+(test #t rename-file "tmp7x" (build-path deepdir "tmp7x"))
+(test #f rename-file "tmp7x" (build-path deepdir "tmp7x"))
+
+(test #f not (member "tmp5x" (directory-list)))
+(test #t 'directory-list 
+      (let ([l (directory-list "down")])
+	(or (equal? l '("deep" "tmp8x"))
+	    (equal? l '("tmp8x" "deep")))))
+(test '("tmp7x") directory-list deepdir)
+
+(test #f delete-directory deepdir)
+(test #f delete-directory "down")
+
+(test #t delete-file (build-path deepdir "tmp7x"))
+(test #f delete-file (build-path deepdir "tmp7x"))
+(test #t delete-file (build-path "down" "tmp8x"))
+(test #f delete-file (build-path "down" "tmp8x"))
+(test #t delete-file "tmp5x")
+(test #f delete-file "tmp5x")
+
+(test #f delete-directory "down")
+(test #t delete-directory deepdir)
+(test #f delete-directory deepdir)
+(test #t delete-directory "down")
+(test #f delete-directory "down")
+
+; Redefine these per-platform
+(define drives null)
+(define nondrive-roots (list "/"))
+(define a (list "a"))
+(define a/b (list "a/b" "a//b"))
+(define a/b/c (list "a/b/c" "a//b/c"))
+(define /a/b (list "/a/b"))
+(define a/../b (list "a/../b"))
+(define a/./b (list "a/./b"))
+(define a/../../b (list "a/../../b"))
+(define trail-sep "/")
+
+(define add-slashes
+  (lambda (l)
+    (if (null? l)
+	null
+	(let loop ([s (car l)][rest (add-slashes (cdr l))])
+	  (let ([naya (regexp-replace "/" s "\\")])
+	    (if (string=? naya s)
+		(cons s rest)
+		(loop naya (cons s rest))))))))
+
+(when (eq? (system-type) 'windows)
+      (set! drives (list "c:" "c:/" "//hello/start" "//hello/start/"))
+      (set! nondrive-roots null)
+      (for-each
+       (lambda (var)
+	 (eval `(set! ,var (add-slashes ,var))))
+       '(a a/b a/b/c /a/b a/../b a/./b a/../../b)))
+
+
+(when (eq? (system-type) 'macos)
+      (set! drives null)
+      (set! nondrive-roots (filesystem-root-list))
+      (set! a (list ":a"))
+	  (set! a/b (list ":a:b"))
+	  (set! a/b/c (list ":a:b:c"))
+      (set! /a/b (list "a:b"))
+      (set! a/../b (list ":a::b"))
+      (set! a/./b null)
+	  (set! a/../../b (list ":a:::b"))
+	  (set! trail-sep ":"))
+
+(define roots (append drives nondrive-roots))
+
+(define a/ (map (lambda (s) (string-append s trail-sep)) a))
+(define a/b/ (map (lambda (s) (string-append s trail-sep)) a/b))
+(define a/b/c/ (map (lambda (s) (string-append s trail-sep)) a/b/c))
+(define /a/b/ (map (lambda (s) (string-append s trail-sep)) /a/b))
+
+(define absols (append roots /a/b /a/b/))
+(define nondrive-absols (append nondrive-roots /a/b /a/b/))
+(define rels (append a a/ a/b a/b/ a/b/c a/b/c/ a/../b a/./b a/../../b))
+
+(define i (lambda (x) x))
+
+(test #f ormap i (map relative-path? roots))
+(test #t andmap i (map relative-path? a/b))
+(test #f ormap i (map relative-path? /a/b))
+
+(test #t andmap i (map absolute-path? roots))
+(test #f ormap i (map absolute-path? a/b))
+
+(test #t andmap i (map complete-path? drives))
+(test #t andmap i (map complete-path? nondrive-roots))
+(test #f ormap i (map complete-path? a/b))
+
+(for-each
+ (lambda (abs)
+   (for-each
+    (lambda (rel)
+      (test #t string? (build-path abs rel))
+      (for-each
+       (lambda (rel2)
+	 (test #t string? (build-path abs rel rel2)))
+       rels))
+    rels))
+ absols)
+
+(for-each
+ (lambda (drive)
+   (for-each
+    (lambda (root)
+      (test #t string? (build-path drive root))
+      (for-each
+       (lambda (rel)
+	 (test #t string? (build-path drive root rel)))
+       rels))
+    nondrive-absols))
+ drives)
+
+(for-each
+ (lambda (rel)
+   (test (build-path (current-directory) rel)
+	 path->complete-path rel))
+ rels)
+
+(define (test-path expect f . args)
+  (test (normal-case-path (expand-path expect))
+	normal-case-path (expand-path (apply f args))))
+
+(for-each
+ (lambda (absol)
+   (let ([cabsol (path->complete-path absol)])
+     (for-each
+      (lambda (rel)
+	(test-path (build-path cabsol rel) path->complete-path rel cabsol)
+	(test-path (build-path cabsol rel rel) path->complete-path rel (build-path cabsol rel))
+	(error-test `(path->complete-path ,rel ,rel) exn:i/o:filesystem:path?))
+      rels)))
+ absols)
+
+(for-each
+ (lambda (drive)
+   (for-each
+    (lambda (rel)
+      (unless (relative-path? rel)
+	      (test-path (build-path (current-drive) rel)
+			 path->complete-path rel))
+      (test-path (build-path drive rel) path->complete-path rel drive)
+      (test-path (if (relative-path? rel)
+		     (build-path drive rel rel)
+		     (build-path drive rel))
+		 path->complete-path rel (build-path drive rel)))
+    (append rels nondrive-absols)))
+ drives)
+
+(for-each
+ (lambda (drive)
+   (test drive path->complete-path drive)
+   (test drive path->complete-path drive drive))
+ drives)
+
+(unless (eq? (system-type) 'macos)
+ (for-each
+  (lambda (abs1)
+    (for-each
+     (lambda (abs2)
+       (error-test `(build-path ,abs1 ,abs2) exn:i/o:filesystem:path?))
+     absols))
+  nondrive-roots))
+
+(for-each
+ (lambda (root)
+   (let-values ([(base name dir?) (split-path root)])
+      (test #f 'split-path base)
+      (test #t 'split-path dir?)))
+ roots)
+
+(let ([check-a/b
+       (lambda (a/b end/?)
+	 (for-each
+	  (lambda (path)
+	    (let*-values ([(base name dir?) (split-path path)]
+			  [(base2 name2 dir?2) (split-path base)])
+	       (test "b" substring name 0 1)
+	       (test end/? 'split-path dir?)
+	       (test "a" substring name2 0 1)
+	       (test 'relative 'split-path base2)
+	       (test #t 'split-path dir?2)
+	       (for-each 
+		(lambda (root)
+		  (let ([bigpath (build-path root path)])
+		    (let*-values ([(base name dir?) (split-path bigpath)]
+				  [(base2 name2 dir?2) (split-path base)]
+				  [(base3 name3 dir?3) (split-path base2)])
+		       (test #f 'split-path base3)
+		       (test #t 'split-path dir?3))))
+		roots)))
+	  a/b))])
+  (check-a/b a/b #f)
+  (check-a/b a/b/ #t))
+
+(arity-test split-path 1 1)
+
+(arity-test path->complete-path 1 2)
+(error-test '(path->complete-path 1))
+(error-test '(path->complete-path "a" 1))
+
+(map
+ (lambda (f)
+   (error-test `(,f (string #\a #\nul #\b)) exn:i/o:filesystem:path?))
+ '(build-path split-path file-exists? directory-exists?
+	      delete-file directory-list make-directory delete-directory
+	      file-modify-seconds file-or-directory-permissions 
+	      expand-path resolve-path path->complete-path
+	      open-input-file open-output-file))
+(map 
+ (lambda (f)
+   (error-test `(,f (string #\a #\nul #\b) "a") exn:i/o:filesystem:path?)
+   (error-test `(,f "a" (string #\a #\nul #\b)) exn:i/o:filesystem:path?))
+ '(rename-file path->complete-path))
+
+; normal-case-path doesn't check for pathness:
+(test #t string? (normal-case-path (string #\a #\nul #\b)))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/pconvert.ss b/collects/tests/mzscheme/pconvert.ss
new file mode 100644
index 0000000..078ce91
--- /dev/null
+++ b/collects/tests/mzscheme/pconvert.ss
@@ -0,0 +1,261 @@
+
+(unless (defined? 'SECTION)
+  (load-relative "testing.ss"))
+
+(SECTION 'pconvert)
+
+(require-library "pconver.ss")
+
+(constructor-style-printing #t)
+(quasi-read-style-printing #f)
+
+(define (xl) 1)
+(define (xu) (unit (import) (export)))
+(define (xc) (class '() ()))
+
+(begin
+  (define-struct test (value constructor-sexp shared-constructor-sexp
+			     quasi-sexp shared-quasi-sexp cons-as-list))
+  
+  (define-struct no-cons-test (value constructor-sexp shared-constructor-sexp
+				     quasi-sexp shared-quasi-sexp))
+  (define-struct same-test (value sexp))
+  (define get-value
+    (lambda (test-case)
+      (cond
+	[(test? test-case)
+	 (test-value test-case)]
+	[(no-cons-test? test-case)
+	 (no-cons-test-value test-case)]
+	[(same-test? test-case)
+	 (same-test-value test-case)])))
+  (define run-test
+    (lambda (test-case)
+      (let* ([before (get-value test-case)]
+	     [cmp
+	      (lambda (selector constructor-style? quasi-read? sharing? cons-as-list?)
+		(unless (parameterize ([constructor-style-printing constructor-style?]
+				       [show-sharing sharing?]
+				       [quasi-read-style-printing quasi-read?]
+				       [abbreviate-cons-as-list cons-as-list?])
+			  (test (selector test-case) print-convert before))
+		  (printf ">> (constructor-style-printing ~a) (quasi-read-style-printing ~a) (show-sharing ~a) (abbreviate-cons-as-list ~a)~n"
+			  constructor-style? quasi-read? sharing? cons-as-list?)))])
+	;(printf "testing: ~s~n" before)
+	;(printf ".") (flush-output (current-output-port))
+	(cond
+	  [(test? test-case)
+	   (cmp test-shared-constructor-sexp #t #f #t #t)
+	   (cmp test-constructor-sexp #t #f #f #t)
+	   (cmp test-shared-quasi-sexp #f #f #t #t)
+	   (cmp test-quasi-sexp #f #f #f #t)
+	   (cmp test-cons-as-list #t #f #f #f)]
+	  [(no-cons-test? test-case)
+	   (cmp no-cons-test-shared-constructor-sexp #t #f #t #t)
+	   (cmp no-cons-test-constructor-sexp #t #f #f #t)
+	   (cmp no-cons-test-shared-quasi-sexp #f #f #t #t)
+	   (cmp no-cons-test-quasi-sexp #f #f #f #t)]
+	  [(same-test? test-case)
+	   (cmp same-test-sexp #t #t #t #t)
+	   (cmp same-test-sexp #t #t #t #f)
+	   (cmp same-test-sexp #t #t #f #t)
+	   (cmp same-test-sexp #t #t #f #f)
+	   (cmp same-test-sexp #t #f #t #t)
+	   (cmp same-test-sexp #t #f #t #f)
+	   (cmp same-test-sexp #t #f #f #t)
+	   (cmp same-test-sexp #t #f #f #f)
+	   (cmp same-test-sexp #f #t #t #t)
+	   (cmp same-test-sexp #f #t #t #f)
+	   (cmp same-test-sexp #f #t #f #t)
+	   (cmp same-test-sexp #f #t #f #f)
+	   (cmp same-test-sexp #f #f #t #t)
+	   (cmp same-test-sexp #f #f #t #f)
+	   (cmp same-test-sexp #f #f #f #t)
+	   (cmp same-test-sexp #f #f #f #f)]))))
+
+  (define 
+    tests
+    (list
+     (make-same-test "abc" "abc")
+     (make-same-test 8 8)
+     (make-same-test 'a ''a)
+     (make-test (list 1) '(list 1) '(list 1) '`(1) '`(1) '(cons 1 null))
+     (make-same-test (vector 0 0 0 0 0 0 0 0 0 0) '(vector 0 0 0 0 0 0 0 0 0 0))
+     (make-same-test (delay 1) '(delay ...))
+     (make-same-test (let-struct a (a) (make-a 3)) '(make-a 3))
+     (make-same-test (box 3) '(box 3))
+     (make-test null 'null 'null '`() '`() 'null)
+     (make-same-test add1 'add1)
+     (make-same-test (void) '(void))
+     (make-same-test (unit (import) (export)) '(unit ...))
+     (make-same-test (make-weak-box 12) '(make-weak-box 12))
+     (make-same-test (regexp "1") '(regexp ...))
+     (make-same-test (lambda () 0) '(lambda () ...))
+     (make-same-test xl 'xl)
+     (make-same-test (letrec ([xl (lambda () 1)]) xl) '(lambda () ...))
+     (make-same-test (letrec ([xl-ID-BETTER-NOT-BE-DEFINED (lambda () 1)]) 
+		       xl-ID-BETTER-NOT-BE-DEFINED)
+		     '(lambda () ...))
+     (make-same-test xc 'xc)
+     (make-same-test (letrec ([xc (class '() ())]) xc) '(class ...))
+     (make-same-test (letrec ([xc-ID-BETTER-NOT-BE-DEFINED (class '() ())]) 
+		       xc-ID-BETTER-NOT-BE-DEFINED)
+		     '(class ...))
+     (make-same-test xu 'xu)
+     (make-same-test (letrec ([xu (unit (import) (export))]) xu)
+		     '(unit ...))
+     (make-same-test (letrec ([xu-ID-BETTER-NOT-BE-DEFINED (unit (import) (export))]) 
+		       xu-ID-BETTER-NOT-BE-DEFINED)
+		     '(unit ...))
+     (make-same-test (lambda (x) x) '(lambda (a1) ...))
+     (make-same-test (lambda x x) '(lambda args ...))
+     (make-same-test (lambda (a b . c) a) '(lambda (a1 a2 . args) ...))
+     (make-same-test (case-lambda) '(case-lambda))
+     (make-same-test (case-lambda [() a] [(x) a]) '(case-lambda [() ...] [(a1) ...]))
+     (make-same-test (case-lambda [() a] [(x y) a])
+		     '(case-lambda [() ...] [(a1 a2) ...]))
+     (make-same-test (case-lambda [() a] [(x . y) a])
+		     '(case-lambda [() ...] [(a1 . args) ...]))
+     (make-same-test (case-lambda [() a] [x a])
+		     '(case-lambda [() ...] [args ...]))
+     (make-same-test (case-lambda [() a] [(x y z) a] [x a])
+		     '(case-lambda [() ...] [(a1 a2 a3) ...] [args ...]))
+     (make-same-test (let ([ht (make-hash-table)])
+		       (hash-table-put! ht 'x 1)
+		       ht)
+		     '(make-hash-table))
+     (make-test (list 'a (box (list ())) (cons 1 '()))
+		'(list (quote a) (box (list null)) (list 1))
+		'(list (quote a) (box (list null)) (list 1))
+		'`(a ,(box `(())) (1))
+		'`(a ,(box `(())) (1))
+		'(cons 'a 
+		       (cons (box (cons null null))
+			     (cons (cons 1 null)
+				   null))))
+     (make-test (let ([x (list 1)]) (set-car! x x) x)
+		'(shared ([-0- (list -0-)]) -0-)
+		'(shared ([-0- (list -0-)]) -0-)
+		'(shared ([-0- `(,-0-)]) -0-)
+		'(shared ([-0- `(,-0-)]) -0-)
+		'(shared ([-0- (cons -0- null)]) -0-))
+     (make-test (let ([x (list 1)]) (set-cdr! x x) x)
+		'(shared ([-0- (cons 1 -0-)]) -0-)
+		'(shared ([-0- (cons 1 -0-)]) -0-)
+		'(shared ([-0- `(1 . ,-0-)]) -0-)
+		'(shared ([-0- `(1 . ,-0-)]) -0-)
+		'(shared ([-0- (cons 1 -0-)]) -0-))
+     (make-test (let* ([a (list 1 2 3)]
+		       [b (list 1 a (cdr a))])
+		  (set-car! b b)
+		  (append b (list (list 2 3))))
+		'(shared ([-1- (list -1- (list 1 2 3) (list 2 3))])
+		   (list -1- (list 1 2 3) (list 2 3) (list 2 3)))
+		'(shared ([-1- (list -1- -3- -4-)]
+			  [-3- (cons 1 -4-)]
+			  [-4- (list 2 3)])
+		   (list -1- -3- -4- (list 2 3)))
+		'(shared ([-1- `(,-1- (1 2 3) (2 3))])
+		   `(,-1- (1 2 3) (2 3) (2 3)))
+		'(shared ([-1- `(,-1- ,-3- ,-4-)]
+			  [-3- `(1 . ,-4-)]
+			  [-4- `(2 3)])
+		   `(,-1- ,-3- ,-4- (2 3)))
+		'(shared ([-1- (cons -1- 
+				     (cons (cons 1 (cons 2 (cons 3 null)))
+					   (cons (cons 2 (cons 3 null))
+						 null)))])
+		   (cons -1- 
+			 (cons (cons 1 (cons 2 (cons 3 null)))
+			       (cons (cons 2 (cons 3 null)) 
+				     (cons (cons 2 (cons 3 null))
+					   null))))))
+     (make-no-cons-test (let* ([a (list 1 2 3)]
+			       [b (list 1 a (cdr a))])
+			  (set-car! b b)
+			  (let* ([share-list (append b (list (list 2 3)))]
+				 [v (vector 1 share-list (cdr share-list))])
+			    (vector-set! v 0 v)
+			    v))
+			'(shared
+			     ((-0- (vector -0-
+					   (list -2-
+						 (list 1 2 3)
+						 (list 2 3)
+						 (list 2 3))
+					   (list (list 1 2 3)
+						 (list 2 3)
+						 (list 2 3))))
+			      (-2- (list -2- (list 1 2 3) (list 2 3))))
+			   -0-)
+			'(shared
+			     ((-0- (vector -0- (cons -2- -8-) -8-))
+			      (-2- (list -2- -4- -5-))
+			      (-4- (cons 1 -5-))
+			      (-5- (list 2 3))
+			      (-8- (list -4- -5- (list 2 3))))
+			   -0-)
+			'(shared
+			     ((-0- (vector -0-
+					   `(,-2-
+					     (1 2 3)
+					     (2 3)
+					     (2 3))
+					   `((1 2 3)
+					     (2 3)
+					     (2 3))))
+			      (-2- `(,-2- (1 2 3) (2 3))))
+			   -0-)
+			'(shared
+			     ((-0- (vector -0- `(,-2- . ,-8-) -8-))
+			      (-2- `(,-2- ,-4- ,-5-))
+			      (-4- `(1 . ,-5-))
+			      (-5- `(2 3))
+			      (-8- `(,-4- ,-5- (2 3))))
+			   -0-))))
+  (for-each run-test tests))
+
+(begin
+  (define make-test-shared
+    (lambda (shared?)
+      (lambda (object output)
+	(parameterize ([constructor-style-printing #t]
+		       [show-sharing #t]
+		       [quasi-read-style-printing #f]
+		       [abbreviate-cons-as-list #t])
+	  (test (if shared?
+		    `(shared ((-1- ,output))
+		       (list -1- -1-))
+		    `(list ,output ,output))
+		print-convert
+		(list object object))))))
+  (define test-shared (make-test-shared #t))
+  (define test-not-shared (make-test-shared #f))
+
+  (test-not-shared #t #t)
+  (test-not-shared #f #f)
+  (test-not-shared 1 1)
+  (test-not-shared 3276832768 3276832768)
+  (test-not-shared (regexp "") '(regexp ...))
+  (let ([in (open-input-string "")]) (test-not-shared in in))
+  (let ([out (open-output-string)]) (test-not-shared out out))
+  (test-not-shared #\a #\a)
+  (test-not-shared 'x ''x)
+  (test-not-shared (lambda (x) x) '(lambda (a1) ...))
+  (test-not-shared (make-promise (lambda () 1)) '(delay ...))
+  (test-not-shared (class () ()) '(class ...))
+  (test-not-shared (unit (import) (export)) '(unit ...))
+  (test-not-shared (make-object (class () ())) '(make-object (class ...)))
+
+  (test-shared "abc" "abc")
+  (test-shared (list 1 2 3) '(list 1 2 3))
+  (test-shared (vector 1 2 3) '(vector 1 2 3))
+  (let-struct a () (test-shared (make-a) '(make-a)))
+  (test-shared (box 1) '(box 1))
+  (test-shared (make-hash-table) '(make-hash-table)))
+
+(arity-test print-convert 1 2)
+(arity-test build-share 1 1)
+(arity-test get-shared 1 2)
+(arity-test print-convert-expr 3 3)
+(report-errs)
diff --git a/collects/tests/mzscheme/pretty.ss b/collects/tests/mzscheme/pretty.ss
new file mode 100644
index 0000000..7bef9fe
--- /dev/null
+++ b/collects/tests/mzscheme/pretty.ss
@@ -0,0 +1,64 @@
+
+; Test pretty-print; relies on personal inspection of the results
+
+(require-library "pretty.ss")
+
+(define-struct s (a b c))
+
+(define (make k?)
+  (let ([make (if k? make (lambda (x) '(end)))])
+    (list
+     1
+     'a
+     "a"
+     (list 'long-name-numero-uno-one-the-first-supreme-item
+	   'long-name-number-two-di-ar-ge-second-line)
+     (map (lambda (v v2)
+	    (make-s v 2 v2))
+	  (make #f)
+	  (reverse (make #f)))
+     '(1)
+     '(1 2 3)
+     '(1 . 2)
+     #(1 2 3 4 5)
+     '(#0=() . #0#)
+     '#1=(1 . #1#)
+     (map box (make #f))
+     (make #f))))
+
+(define vs (make #t))
+
+(define print-line-no
+  (lambda (line port offset width) 
+    (if line         
+	(begin
+	  (when (positive? line) (write-char #\newline port))
+	  (fprintf port "~s~a~a~a " line
+		   (if (< line 10) " " "")
+		   (if (< line 100) " " "")
+		   (if (< line 1000) " " ""))
+	  5)
+	(fprintf port "!~n"))))
+
+(define modes
+  (list
+   (list "DEPTH=2" pretty-print-depth 2)
+   (list "GRAPH-ON" print-graph #t)
+   (list "STRUCT-ON" print-struct #t)
+   (list "LINE-NO-ON" pretty-print-print-line print-line-no)))
+
+(define num-combinations (arithmetic-shift 1 (length modes)))
+
+(let loop ([n 0])
+  (when (< n num-combinations)
+     (let loop ([modes modes][n n])
+       (cond
+	[(null? modes) (printf ":~n") (map pretty-print vs)]
+	[(positive? (bitwise-and n 1))
+	 (let ([mode (car modes)])
+	   (printf "~s " (car mode))
+	   (parameterize ([(cadr mode) (caddr mode)])
+	      (loop (cdr modes) (arithmetic-shift n -1))))]
+	[else
+	 (loop (cdr modes) (arithmetic-shift n -1))]))
+     (loop (add1 n))))
diff --git a/collects/tests/mzscheme/quiet.ss b/collects/tests/mzscheme/quiet.ss
new file mode 100644
index 0000000..8bd4810
--- /dev/null
+++ b/collects/tests/mzscheme/quiet.ss
@@ -0,0 +1,9 @@
+
+(unless (defined? 'quiet-load)
+   (define quiet-load "all.ss"))
+
+(let ([p (make-output-port void void)])
+  (parameterize ([current-output-port p])
+      (load-relative quiet-load))
+  (report-errs))
+
diff --git a/collects/tests/mzscheme/read.ss b/collects/tests/mzscheme/read.ss
new file mode 100644
index 0000000..ab34213
--- /dev/null
+++ b/collects/tests/mzscheme/read.ss
@@ -0,0 +1,168 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'READING)
+(define readstr
+  (lambda (s)
+    (let* ([o (open-input-string s)]
+	   [read (if (defined? 'read/zodiac)
+		     (let ([r (read/zodiac (open-input-string s))])
+		       (lambda ()
+			 (let ([orig (error-escape-handler )])
+			   (dynamic-wind
+			    (lambda () (error-escape-handler 
+					(lambda ()
+					  (error-escape-handler orig)
+					  (error 'read/zodiac))))
+			    r
+			    (lambda () (error-escape-handler orig))))))
+		     (lambda () (read o)))])
+      (let loop ([last eof])
+	(let ([v (read)])
+	  (if (eof-object? v)
+	      last
+	      (loop v)))))))
+
+(define readerrtype
+  (if (defined? 'read/zodiac)
+      (lambda (x) (lambda (y) #t))
+      (lambda (x) x)))
+
+; Make sure {whitespace} == {delimiter}
+(let ([with-censor (load-relative "censor.ss")])
+  (with-censor
+   (lambda ()
+     (let loop ([n 0])
+       (unless (= n 256)
+	       (let* ([c0 (integer->char n)]
+		      [c (if (read-case-sensitive)
+			     c0
+			     (char-downcase c0))])
+		 (cond
+		  [(char-whitespace? c)
+		   (test 'b readstr (string #\a c #\b))]
+		  [(char=? #\\ c) (test 'ab readstr (string #\a c #\b))]
+		  [(char=? #\; c) (test 'a readstr (string #\a c #\b))]
+		  [(char=? #\' c) (test ''b readstr (string #\a c #\b))]
+		  [(char=? #\` c) (test '`b readstr (string #\a c #\b))]
+		  [(char=? #\, c) (test ',b readstr (string #\a c #\b))]
+		  [else
+		   (test (string->symbol (string #\a (char-downcase c) #\b))
+			 'readstr
+			 (with-handlers ([void 
+					  (lambda (x) 
+					    (string->symbol (string #\a (char-downcase c) #\b)))])
+			      (readstr (string #\a c #\b))))]))
+	       (loop (add1 n)))))))
+
+(error-test '(readstr ")") (readerrtype exn:read:paren?))
+(error-test '(readstr "[)") (readerrtype exn:read:paren?))
+(error-test '(readstr "[}") (readerrtype exn:read:paren?))
+(error-test '(readstr "8 )") (readerrtype exn:read:paren?))
+(error-test '(readstr "(8 . )") (readerrtype exn:read:paren?))
+
+(load-relative "numstrs.ss")
+(let loop ([l number-table])
+  (unless (null? l)
+	  (let* ([pair (car l)]
+		 [v (car pair)]
+		 [s (cadr pair)])
+	    (cond
+	     [(eq? v 'X) (error-test `(readstr ,s) (readerrtype exn:read:number?))]
+	     [v (test v readstr s)]
+	     [else (test (string->symbol s) readstr s)]))
+	  (loop (cdr l))))
+
+(error-test '(readstr "#\\silly") (readerrtype exn:read:char?))
+(error-test '(readstr "#\\nully") (readerrtype exn:read:char?))
+(error-test '(readstr "#\\nu") (readerrtype exn:read:char?))
+(error-test '(readstr "#\\733") (readerrtype exn:read:char?))
+(error-test '(readstr "#\\433") (readerrtype exn:read:char?))
+
+(error-test '(readstr "(hi") (readerrtype exn:read:eof?))
+(error-test '(readstr "\"hi") (readerrtype exn:read:eof?))
+(error-test '(readstr "#(hi") (readerrtype exn:read:eof?))
+(error-test '(readstr "#4(hi") (readerrtype exn:read:eof?))
+(error-test '(readstr "|hi") (readerrtype exn:read:eof?))
+(error-test '(readstr "#\\") (readerrtype exn:read:eof?))
+(error-test '(readstr "#| hi") (readerrtype exn:read:eof?))
+
+(error-test '(readstr ".") (readerrtype exn:read:dot?))
+(error-test '(readstr "a .") (readerrtype exn:read:dot?))
+(error-test '(readstr "a . b") (readerrtype exn:read:dot?))
+(error-test '(readstr "( . )") (readerrtype exn:read:dot?))
+(error-test '(readstr "( . 8)") (readerrtype exn:read:dot?))
+(error-test '(readstr "(0 . 8 9)") (readerrtype exn:read:dot?))
+(error-test '(readstr "( . 8 9)") (readerrtype exn:read:dot?))
+(error-test '(readstr "#(8 . )") (readerrtype exn:read:dot?))
+(error-test '(readstr "#( . )") (readerrtype exn:read:dot?))
+(error-test '(readstr "#( . 8)") (readerrtype exn:read:dot?))
+(error-test '(readstr "#(0 . 8 9)") (readerrtype exn:read:dot?))
+(error-test '(readstr "#( . 8 9)") (readerrtype exn:read:dot?))
+(error-test '(readstr "#( 8 . 9)") (readerrtype exn:read:dot?))
+(error-test '(readstr "#( 8 . (9))") (readerrtype exn:read:dot?))
+
+(error-test '(readstr "#Q") (readerrtype exn:read:unsupported?))
+(error-test '(readstr "##") (readerrtype exn:read:unsupported?))
+(error-test '(readstr "#?") (readerrtype exn:read:unsupported?))
+(error-test '(readstr "#-1()") (readerrtype exn:read:unsupported?))
+
+(test 2 vector-length (readstr "#2()"))
+(test 0 vector-ref (readstr "#2()") 1)
+(test 2 vector-length (readstr "#000000000000000000000000000000002()"))
+
+(error-test '(readstr "#2(1 2 3)") (readerrtype exn:read:vector-length?))
+(error-test '(readstr "#200000000000(1 2 3)") (readerrtype exn:misc:out-of-memory?))
+
+(unless (defined? 'read/zodiac)
+  (test #t (lambda (x) (eq? (car x) (cdr x))) (readstr "(#0=(1 2) . #0#)"))
+  (test #t (lambda (x) (eq? (car x) (cdr x))) (readstr "(#1=(1 2) . #0001#)")))
+
+(error-test '(readstr "#0#") (readerrtype exn:read:graph?))
+(error-test '(readstr "#0=#0#") (readerrtype exn:read:graph?))
+(error-test '(readstr "(#0# #0=7)") (readerrtype exn:read:graph?))
+(error-test '(readstr "(#0=7 #1#)") (readerrtype exn:read:graph?))
+(error-test '(readstr "#012345678=7") (readerrtype exn:read:graph?))
+(error-test '(readstr "(#12345678=7 #012345678#)") (readerrtype exn:read:graph?))
+
+(test 3 string-length (readstr (string #\" #\a #\nul #\b #\")))
+(test (string->symbol (string #\a #\nul #\b)) 'sym (readstr (string #\a #\nul #\b)))
+(test (string->symbol (string #\1 #\nul #\b)) 'sym (readstr (string #\1 #\nul #\b)))
+
+; Test read/write invariance on symbols and use of pipe quotes
+(define (test-write-sym with-bar without-bar s)
+  (let ([sym (string->symbol s)])
+    (parameterize ([read-case-sensitive #t])
+		  (let ([p (open-output-string)])
+		    (write sym p)
+		    (test with-bar 'write-sym-with-bar (get-output-string p))
+		    (test sym read (open-input-string (get-output-string p))))
+		  (let ([p (open-output-string)])
+		    (parameterize ([read-accept-bar-quote #f])
+				  (write sym p)
+				  (test without-bar 'write-sym-no-bar (get-output-string p))
+				  (test sym read (open-input-string (get-output-string p)))))
+		  (let ([p (open-output-string)])
+		    (display sym p)
+		    (test s 'display-sym (get-output-string p))))))
+
+(test-write-sym "a->b" "a->b" "a->b")
+(test-write-sym "|a,b|" "a\\,b" "a,b")
+(test-write-sym "a\\|b" "a|b" "a|b")
+(test-write-sym "|a\\b|" "a\\\\b" "a\\b")
+
+(load-relative "numstrs.ss")
+(let loop ([l number-table])
+  (cond
+   [(null? l) 'done]
+   [(or (number? (caar l)) (eq? (caar l) 'X))
+    (test-write-sym (string-append "|" (cadar l) "|") 
+		    (string-append "\\" (cadar l)) 
+		    (cadar l))
+    (loop (cdr l))]
+   [else 
+    (test-write-sym (cadar l) (cadar l) (cadar l))
+    (loop (cdr l))]))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/struct.ss b/collects/tests/mzscheme/struct.ss
new file mode 100644
index 0000000..f3dd129
--- /dev/null
+++ b/collects/tests/mzscheme/struct.ss
@@ -0,0 +1,234 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'STRUCT)
+
+(test 7 call-with-values
+      (lambda () (struct a (b c)))
+      (lambda args (length args)))
+(let-values ([(type make pred sel1 set1 sel2 set2) (struct a (b c))])
+   (test #t struct-type? type)
+   (test #t procedure? make)
+   (test 2 arity make)
+   (test 1 arity sel1)
+   (test 2 arity set1)
+   (test #t struct-setter-procedure? set2)
+   (test #f struct-setter-procedure? sel2))
+
+(define-struct a (b c))
+(define-struct aa ())
+(define ai (make-a 1 2))
+(define aai (make-aa))
+(test #t struct-type? struct:a)
+(test #f struct-type? 5)
+(test #t procedure? a?)
+(test #t a? ai)
+(test #f a? 1)
+(test #f aa? ai)
+(test 1 a-b ai)
+(test 2 a-c ai)
+(define ai2 (make-a 1 2))
+(set-a-b! ai2 3)
+(set-a-c! ai2 4)
+(test 1 a-b ai)
+(test 2 a-c ai)
+(test 3 a-b ai2)
+(test 4 a-c ai2)
+(define-struct a (b c))
+(test #f a? ai)
+(arity-test make-a 2 2)
+(error-test `(make-aa 1) exn:application:arity?)
+(arity-test a? 1 1)
+(arity-test a-b 1 1)
+(arity-test a-c 1 1)
+(arity-test set-a-b! 2 2)
+(arity-test set-a-c! 2 2)
+(error-test `(a-b 5))
+(error-test `(a-b ,ai))
+(error-test `(set-a-b! ai 5))
+(error-test `(set-a-c! ai 5))
+(error-test `(begin (define-struct (a 9) (b c)) (void)) exn:struct:struct-type?)
+
+(arity-test struct-type? 1 1)
+
+(define (gen-struct-syntax-test formname suffix)
+  (syntax-test `(,formname 1 (x) ,@suffix))
+  (syntax-test `(,formname a (1) ,@suffix))
+  (syntax-test `(,formname a (x 1) ,@suffix))
+  (syntax-test `(,formname a (x . y) ,@suffix))
+  (syntax-test `(,formname (a) (x) ,@suffix))
+  (syntax-test `(,formname (a . y) (x) ,@suffix))
+  (syntax-test `(,formname (a 2 3) (x) ,@suffix)))
+(define (struct-syntax-test formname)
+  (syntax-test `(,formname))
+  (syntax-test `(,formname . a))
+  (syntax-test `(,formname a . x))
+  (syntax-test `(,formname a x))
+  (gen-struct-syntax-test formname '()))
+
+(struct-syntax-test 'struct)
+(struct-syntax-test 'define-struct)
+(gen-struct-syntax-test 'let-struct '(5))
+
+(define-struct base0 ())
+(define-struct base1 (a))
+(define-struct base2 (l r))
+(define-struct base3 (x y z))
+
+(define-struct (one00 struct:base0) ())
+(define-struct (one01 struct:base1) ())
+(define-struct (one02 struct:base2) ())
+(define-struct (one03 struct:base3) ())
+
+(define-struct (one10 struct:base0) (a))
+(define-struct (one11 struct:base1) (a))
+(define-struct (one12 struct:base2) (a))
+(define-struct (one13 struct:base3) (a))
+
+(define-struct (one20 struct:base0) (l r))
+(define-struct (one21 struct:base1) (l r))
+(define-struct (one22 struct:base2) (l r))
+(define-struct (one23 struct:base3) (l r))
+
+(define-struct (one30 struct:base0) (x y z))
+(define-struct (one31 struct:base1) (x y z))
+(define-struct (one32 struct:base2) (x y z))
+(define-struct (one33 struct:base3) (x y z))
+
+(define-struct (two100 struct:one00) (a))
+(define-struct (two101 struct:one01) (a))
+(define-struct (two102 struct:one02) (a))
+(define-struct (two103 struct:one03) (a))
+(define-struct (two110 struct:one10) (a))
+(define-struct (two111 struct:one11) (a))
+(define-struct (two112 struct:one12) (a))
+(define-struct (two113 struct:one13) (a))
+(define-struct (two120 struct:one20) (a))
+(define-struct (two121 struct:one21) (a))
+(define-struct (two122 struct:one22) (a))
+(define-struct (two123 struct:one23) (a))
+(define-struct (two130 struct:one30) (a))
+(define-struct (two131 struct:one31) (a))
+(define-struct (two132 struct:one32) (a))
+(define-struct (two133 struct:one33) (a))
+
+(define x00 (make-one00))
+
+(define x01 (make-one01 1))
+
+(define x10 (make-one10 1))
+(define x11 (make-one11 1 2))
+(define x12 (make-one12 1 2 3))
+(define x13 (make-one13 1 2 3 4))
+
+(define x31 (make-one31 1 2 3 4))
+
+(define x33 (make-one33 1 2 3 4 5 6))
+
+(define x132 (make-two132 1 2 3 4 5 6))
+
+(define (ones v)
+  (cond
+   [(one00? v) 'one00]
+   [(one01? v) 'one01]
+   [(one02? v) 'one02]
+   [(one03? v) 'one03]
+   
+   [(one10? v) 'one10]
+   [(one11? v) 'one11]
+   [(one12? v) 'one12]
+   [(one13? v) 'one13]
+   
+   [(one20? v) 'one20]
+   [(one21? v) 'one21]
+   [(one22? v) 'one22]
+   [(one23? v) 'one23]
+   
+   [(one30? v) 'one30]
+   [(one31? v) 'one31]
+   [(one32? v) 'one32]
+   [(one33? v) 'one33]))
+
+(define (multi v)
+  (cond
+   [(two130? v) 'two130]
+   [(two131? v) 'two131]
+   [(two132? v) 'two132]
+   [(two133? v) 'two133]
+   
+   [(one10? v) 'one10]
+   [(one11? v) 'one11]
+   [(one12? v) 'one12]
+   [(one13? v) 'one13]
+   
+   [(one20? v) 'one20]
+   [(one21? v) 'one21]
+   [(one22? v) 'one22]
+   [(one23? v) 'one23]
+   
+   [(base0? v) 'base0]
+   [(base1? v) 'base1]
+   [(base2? v) 'base2]
+   [(base3? v) 'base3]))
+
+(define (dummy v)
+  'ok)
+
+(define (go f v n)
+  (time
+   (let loop ([n n])
+     (unless (zero? n)
+	     (f v)
+	     (loop (sub1 n))))))
+
+(define check
+  (lambda (l)
+    (cond
+     [(null? l) #f]
+     [else
+      (test (caddr l) (car l) (cadr l))
+      (check (cdddr l))])))
+
+(define ones-test
+  (list x00 'one00
+	x10 'one10
+	x11 'one11
+	x12 'one12
+	x13 'one13
+	x33 'one33))
+	
+(define multi-test
+  (list x00 'base0
+	x10 'one10
+	x11 'one11
+	x12 'one12
+	x13 'one13
+	x33 'base3
+	x132 'two132))	     
+
+(letrec ([bundle
+	  (lambda (l f)
+	    (if (null? l)
+		null
+		(list* f (car l) (cadr l)
+		       (bundle (cddr l) f))))])
+  (check (append
+	  (bundle ones-test ones)
+	  (bundle multi-test multi)
+	  (list base1-a x11 1
+		one11-a x11 2
+		one10-a x10 1
+		
+		base1-a x31 1
+		one31-z x31 4
+		
+		base2-l x132 1
+		two132-a x132 6
+		one32-y x132 4))))
+
+
+(error-test '(struct x (y z)) exn:application:arity?)
+(error-test '(let ([x (struct x (y z))]) 10) exn:application:arity?)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/structc.ss b/collects/tests/mzscheme/structc.ss
new file mode 100644
index 0000000..2e7d616
--- /dev/null
+++ b/collects/tests/mzscheme/structc.ss
@@ -0,0 +1,182 @@
+
+(define ones-case
+  (make-struct-case
+   (list
+    one00?
+    one01?
+    one02?
+    one03?
+    
+    one10?
+    one11?
+    one12?
+    one13?
+    
+    one20?
+    one21?
+    one22?
+    one23?
+    
+    one30?
+    one31?
+    one32?
+    one33?)
+   
+   (list
+    (lambda (x) 'one00)
+    (lambda (x) 'one01)
+    (lambda (x) 'one02)
+    (lambda (x) 'one03)
+    
+    (lambda (x) 'one10)
+    (lambda (x) 'one11)
+    (lambda (x) 'one12)
+    (lambda (x) 'one13)
+    
+    (lambda (x) 'one20)
+    (lambda (x) 'one21)
+    (lambda (x) 'one22)
+    (lambda (x) 'one23)
+    
+    (lambda (x) 'one30)
+    (lambda (x) 'one31)
+    (lambda (x) 'one32)
+    (lambda (x) 'one33))))
+
+(define multi-case
+  (make-struct-case
+   (list
+    two130?
+    two131?
+    two132?
+    two133?
+    
+    one10?
+    one11?
+    one12?
+    one13?
+    
+    one20?
+    one21?
+    one22?
+    one23?
+    
+    base0?
+    base1?
+    base2?
+    base3?)
+
+   (list
+    (lambda (x) 'two130)
+    (lambda (x) 'two131)
+    (lambda (x) 'two132)
+    (lambda (x) 'two133)
+    
+    (lambda (x) 'one10)
+    (lambda (x) 'one11)
+    (lambda (x) 'one12)
+    (lambda (x) 'one13)
+    
+    (lambda (x) 'one20)
+    (lambda (x) 'one21)
+    (lambda (x) 'one22)
+    (lambda (x) 'one23)
+    
+    (lambda (x) 'base0)
+    (lambda (x) 'base1)
+    (lambda (x) 'base2)
+    (lambda (x) 'base3))
+   
+   (lambda (x) x)))
+
+(letrec ([bundle
+	  (lambda (l f)
+	    (if (null? l)
+		null
+		(list* f (car l) (cadr l)
+		       (bundle (cddr l) f))))])
+  (check (append
+	  (bundle ones-test ones-case)
+	  (bundle multi-test multi-case)
+	  (list base1-a x11 1
+		one11-a x11 2
+		one10-a x10 1
+		
+		base1-a x31 1
+		one31-z x31 4
+		
+		base2-l x132 1
+		two132-a x132 6
+		one32-y x132 4))))
+
+(test #t arity-at-least? (multi-case (arity void)))
+
+(arity-test multi-case 1 1)
+
+(error-test `(,ones-case 6) type?)
+(error-test `(,multi-case 6) type?)
+
+(error-test `(,ones-case (arity void)) exn:else?)
+
+(test (void) (make-struct-case null null void) x00)
+(test #t procedure? (make-struct-case null null))
+
+(error-test `((make-struct-case null null) x00) exn:else?)
+
+(error-test `(make-struct-case (list 8) (list void)))
+(error-test `(make-struct-case (list exn:misc? 8) (list void void)))
+(error-test `(make-struct-case (list exn:misc? 8 exn?) (list void void void)))
+(error-test `(make-struct-case exn? (list void)))
+(error-test `(make-struct-case (list* exn:misc? exn?) (list void)))
+
+(error-test `(make-struct-case (list exn?) (list 8)))
+(error-test `(make-struct-case (list exn?) (list (lambda () 8))))
+(error-test `(make-struct-case (list exn:misc? exn?) 
+			       (list void string-set!)))
+(error-test `(make-struct-case (list exn:misc? exn:syntax? exn?) 
+			       (list void void string-set!)))
+(error-test `(make-struct-case (list exn?) void))
+(error-test `(make-struct-case (list exn?) (list* void void)))
+
+(error-test `(make-struct-case (list exn:misc?) (list void void)) 
+	    exn:application:list-sizes?)
+(error-test `(make-struct-case (list exn:misc? exn?) (list void)) 
+	    exn:application:list-sizes?)
+
+(arity-test make-struct-case 2 3)
+
+(test 0 (struct-case-lambda x (else 0)) (arity void))
+(test (arity void) (struct-case-lambda x (else)) (arity void))
+(test (arity void) (struct-case-lambda x (arity-at-least?)) (arity void))
+(test 0 (struct-case-lambda x (arity-at-least? 0) (else 1)) (arity void))
+
+(define s (struct-case-lambda x
+	    [exn? 'exn]
+	    [arity-at-least? x]
+	    [else (cons x 5)]))
+
+(test 'exn s (make-exn 1 2))
+(test (arity void) s (arity void))
+(test (cons x00 5) s x00)
+
+(arity-test s 1 1)
+
+(error-test '(s 9))
+(error-test '(struct-case-lambda) syntaxe?)
+(error-test '(struct-case-lambda 5) syntaxe?)
+(error-test '(struct-case-lambda x . 5) syntaxe?)
+(error-test '(struct-case-lambda x ()) syntaxe?)
+(error-test '(struct-case-lambda x else) syntaxe?)
+(error-test '(struct-case-lambda x (else 9) (exn? 8)) syntaxe?))
+
+(define time-branch
+  (lambda (proc list)
+    (time
+     (let loop ([n 1000])
+       (unless (zero? n)
+	       (let loop ([l list])
+		 (unless (null? l)
+			 (proc (car l))
+			 (loop (cddr l))))
+	       (loop (sub1 n)))))))
+
diff --git a/collects/tests/mzscheme/syntax.ss b/collects/tests/mzscheme/syntax.ss
new file mode 100644
index 0000000..c27e36c
--- /dev/null
+++ b/collects/tests/mzscheme/syntax.ss
@@ -0,0 +1,870 @@
+
+(if (not (defined? 'SECTION))
+    (load "testing.ss"))
+
+(test 0 'with-handlers (with-handlers () 0))
+(test 1 'with-handlers (with-handlers ([void void]) 1))
+(test 2 'with-handlers (with-handlers ([void void]) 1 2))
+(test 'zero 'zero
+      (with-handlers ((zero? (lambda (x) 'zero)))
+		     (raise 0)))
+(test 'zero 'zero
+      (with-handlers ((zero? (lambda (x) 'zero))
+		      (positive? (lambda (x) 'positive)))
+		     (raise 0)))
+(test 'positive 'positive
+      (with-handlers ((zero? (lambda (x) 'zero))
+		      (positive? (lambda (x) 'positive)))
+		     (raise 1)))
+(error-test '(with-handlers ()
+			    (/ 0))
+	    exn:application:math:zero?)
+(error-test '(with-handlers ((zero? (lambda (x) 'zero)))
+			    (/ 0))
+	    exn:application:math:zero?)
+(error-test '(with-handlers ((zero? (lambda (x) 'zero))
+			     (boolean? (lambda (x) 'boolean)))
+			    (/ 0))
+	    exn:application:math:zero?)
+(syntax-test '(with-handlers))
+(syntax-test '(with-handlers . 1))
+(syntax-test '(with-handlers ((zero? (lambda (x) 'zero)))))
+(syntax-test '(with-handlers ((zero? (lambda (x) 'zero))) . 1))
+(syntax-test '(with-handlers (zero?) 1))
+(syntax-test '(with-handlers ((zero?)) 1))
+(syntax-test '(with-handlers ((zero? . zero?)) 1))
+(syntax-test '(with-handlers ((zero? zero?) . 2) 1))
+(syntax-test '(with-handlers ((zero? zero?) zero?) 1))
+(syntax-test '(with-handlers ((zero? zero?) (zero?)) 1))
+(syntax-test '(with-handlers ((zero? zero?) (zero?)) 1))
+(syntax-test '(with-handlers ((zero? zero? zero?)) 1))
+(syntax-test '(with-handlers ((zero? zero? . zero?)) 1))
+(syntax-test '(with-handlers ((zero? zero?)) 1 . 2))
+
+(error-test '(with-handlers ((0 void)) (/ 0)) 
+	    exn:application:non-procedure?)
+(error-test '(with-handlers ((void 0)) (/ 0))
+	    exn:application:non-procedure?)
+(error-test '(with-handlers ((unbound-variable void)) 0)
+	    exn:variable?)
+(error-test '(with-handlers ((void unbound-variable)) 0)
+	    exn:variable?)
+(error-test '(with-handlers (((values 1 2) void)) 0)
+	    arity?)
+(error-test '(with-handlers ((void (values 1 2))) 0)
+	    arity?)
+
+(test-values '(1 2) (lambda () (with-handlers ([void void])
+					      (values 1 2))))
+
+(SECTION 4 1 2)
+(test '(quote a) 'quote (quote 'a))
+(test '(quote a) 'quote ''a)
+(syntax-test '(quote))
+(syntax-test '(quote 1 2))
+
+(SECTION 4 1 3)
+(test 12 (if #f + *) 3 4)
+(syntax-test '(+ 3 . 4))
+
+(SECTION 4 1 4)
+(test 8 (lambda (x) (+ x x)) 4)
+(define reverse-subtract
+  (lambda (x y) (- y x)))
+(test 3 reverse-subtract 7 10)
+(define add4
+  (let ((x 4))
+    (lambda (y) (+ x y))))
+(test 10 add4 6)
+(test (letrec([x x]) x) 'lambda ((lambda () (begin (define d d) d))))
+(test '(3 4 5 6) (lambda x x) 3 4 5 6)
+(test '(5 6) (lambda (x y . z) z) 3 4 5 6)
+(test 'second (lambda () (cons 'first 2) 'second))
+(syntax-test '(lambda))
+(syntax-test '(lambda x))
+(syntax-test '(lambda . x))
+(syntax-test '(lambda x . x))
+(syntax-test '(lambda x . 5))
+(syntax-test '(lambda ((x)) x))
+(syntax-test '(lambda 5 x))
+(syntax-test '(lambda (5) x))
+(syntax-test '(lambda (x (y)) x))
+(syntax-test '(lambda (x . 5) x))
+(syntax-test '(lambda (x) x . 5))
+
+(let ([f
+       (case-lambda
+	[() 'zero]
+	[(x) (cons 1 1) 'one]
+	[(x y) 'two]
+	[(x y z . rest) 'three+]
+	[x 'bad])]
+      [g
+       (case-lambda
+	[(x y z) 'three]
+	[(x y) (cons 2 2) 'two]
+	[(x) 'one]
+	[() 'zero]
+	[x (cons 0 'more!) 'more])]
+      [h
+       (case-lambda
+	[(x y) 'two]
+	[(x y z w) 'four])])
+  (test 'zero f)
+  (test 'one f 1)
+  (test 'two f 1 2)
+  (test 'three+ f 1 2 3)
+  (test 'three+ f 1 2 3 4)
+  (test 'three+ f 1 2 3 4 5 6 7 8 9 10)
+
+  (test 'zero g)
+  (test 'one g 1)
+  (test 'two g 1 2)
+  (test 'three g 1 2 3)
+  (test 'more g 1 2 3 4 5 6 7 8 9 10)
+
+  (test 'two h 1 2)
+  (test 'four h 1 2 3 4)
+  (let ([h '(case-lambda
+	     [(x y) 'two]
+	     [(x y z w) 'four])])
+    (error-test (list h) arity?)
+    (error-test (list* h '(1)) arity?)
+    (error-test (list* h '(1 2 3)) arity?)
+    (error-test (list* h '(1 2 3 4 5 6)) arity?)))
+
+(error-test '((case-lambda)) arity?)
+
+(syntax-test '(case-lambda []))
+(syntax-test '(case-lambda 1))
+(syntax-test '(case-lambda x))
+(syntax-test '(case-lambda [x]))
+(syntax-test '(case-lambda [x 8][y]))
+(syntax-test '(case-lambda [x][y 9]))
+(syntax-test '(case-lambda [8 8]))
+(syntax-test '(case-lambda [((x)) 8]))
+(syntax-test '(case-lambda [(8) 8]))
+(syntax-test '(case-lambda [(x . 9) 8]))
+(syntax-test '(case-lambda [x . 8]))
+(syntax-test '(case-lambda [(x) . 8]))
+(syntax-test '(case-lambda . [(x) 8]))
+(syntax-test '(case-lambda [(x) 8] . [y 7]))
+(syntax-test '(case-lambda [(x) 8] . [y 7]))
+(syntax-test '(case-lambda [(x) 8] [8 7]))
+(syntax-test '(case-lambda [(x) 8] [((y)) 7]))
+(syntax-test '(case-lambda [(x) 8] [(8) 7]))
+(syntax-test '(case-lambda [(x) 8] [(y . 8) 7]))
+(syntax-test '(case-lambda [(x) 8] [y . 7]))
+(syntax-test '(case-lambda [(x) 8] [(y) . 7]))
+
+(SECTION 4 1 5)
+(test 'yes 'if (if (> 3 2) 'yes 'no))
+(test 'no 'if (if (> 2 3) 'yes 'no))
+(test '1 'if (if (> 3 2) (- 3 2) (+ 3 2)))
+(test-values '(1 2) (lambda () (if (cons 1 2) (values 1 2) 0)))
+(test-values '(1 2) (lambda () (if (not (cons 1 2)) 0 (values 1 2))))
+(syntax-test '(if . #t))
+(syntax-test '(if #t . 1))
+(syntax-test '(if #t 1 . 2))
+(syntax-test '(if #t))
+(syntax-test '(if #t 1 2 3))
+(syntax-test '(if #t 1 2 . 3))
+(error-test '(if (values 1 2) 3 4) arity?)
+
+(test (void) 'when (when (> 1 2) 0))
+(test (void) 'when (when (> 1 2) (cons 1 2) 0))
+(test 0 'when (when (< 1 2) 0))
+(test 0 'when (when (< 1 2) (cons 1 2) 0))
+(test-values '(0 10) (lambda () (when (< 1 2) (values 0 10))))
+(syntax-test '(when))
+(syntax-test '(when . 1))
+(syntax-test '(when 1))
+(syntax-test '(when 1 . 2))
+(error-test '(when (values 1 2) 0) arity?)
+
+(test (void) 'unless (unless (< 1 2) 0))
+(test (void) 'unless (unless (< 1 2) (cons 1 2) 0))
+(test 0 'unless (unless (> 1 2) 0))
+(test 0 'unless (unless (> 1 2) (cons 1 2) 0))
+(test-values '(0 10) (lambda () (unless (> 1 2) (values 0 10))))
+(syntax-test '(unless))
+(syntax-test '(unless . 1))
+(syntax-test '(unless 1))
+(syntax-test '(unless 1 . 2))
+(error-test '(unless (values 1 2) 0) arity?)
+
+(SECTION 4 1 6)
+(define x 2)
+(test 3 'define (+ x 1))
+(set! x 4)
+(test 5 'set! (+ x 1))
+(syntax-test '(set!))
+(syntax-test '(set! x))
+(syntax-test '(set! x 1 2))
+(syntax-test '(set! 1 2))
+(syntax-test '(set! (x) 1))
+(syntax-test '(set! . x))
+(syntax-test '(set! x . 1))
+(syntax-test '(set! x 1 . 2))
+
+(set!-values (x) 9)
+(test 9 'set!-values x)
+(test (void) 'set!-values (set!-values () (values)))
+(set!-values (x x) (values 1 2))
+(test 2 'set!-values x)
+(syntax-test '(set!-values))
+(syntax-test '(set!-values . x))
+(syntax-test '(set!-values x))
+(syntax-test '(set!-values 8))
+(syntax-test '(set!-values (x)))
+(syntax-test '(set!-values (x) . 0))
+(syntax-test '(set!-values x 0))
+(syntax-test '(set!-values (x . y) 0))
+(syntax-test '(set!-values (x . 8) 0))
+(syntax-test '(set!-values (x 8) 0))
+(syntax-test '(set!-values (x) 0 1))
+(syntax-test '(set!-values (x) 0 . 1))
+
+(error-test '(set!-values () 1) arity?)
+(error-test '(set!-values () (values 1 2)) arity?)
+(error-test '(set!-values (x) (values)) arity?)
+(error-test '(set!-values (x) (values 1 2)) arity?)
+(error-test '(set!-values (x y) 1) arity?)
+(error-test '(set!-values (x y) (values 1 2 3)) arity?)
+
+(error-test '(set! unbound-variable 5) exn:variable?)
+
+(SECTION 4 2 1)
+(test 'greater 'cond (cond ((> 3 2) 'greater)
+			   ((< 3 2) 'less)))
+(test 'equal 'cond (cond ((> 3 3) 'greater)
+			 ((< 3 3) 'less)
+			 (else 'equal)))
+(test 2 'cond (cond ((assv 'b '((a 1) (b 2))) => cadr)
+		     (else #f)))
+(test #f 'cond (cond ((assv 'z '((a 1) (b 2))) => cadr)
+		     (else #f)))
+(syntax-test '(cond ((assv 'z '((a 1) (b 2))) => cadr)
+		    (else 8)
+		    (else #f)))
+(test #f 'cond (let ([else #f])
+		 (cond ((assv 'z '((a 1) (b 2))) => cadr)
+		       (else 8)
+		       (#t #f))))
+(test 'second 'cond (cond ((< 1 2) (cons 1 2) 'second)))
+(test 'second-again 'cond (cond ((> 1 2) 'ok) (else (cons 1 2) 'second-again)))
+(test 1 'cond (cond (1)))
+(test 1 'cond (cond (#f) (1)))
+(test 1 'cond (cond (#f 7) (1)))
+(test 2 'cond (cond (#f 7) (1 => add1)))
+(test add1 'cond (let ([=> 9]) (cond (#f 7) (1 => add1))))
+(non-z '(test 0 'case (case (* 2 3)
+		(6 0)
+		(else 7))))
+(test 'composite 'case (case (* 2 3)
+			 ((2 3 5 7) 'prime)
+			 ((1 4 6 8 9) 'composite)))
+(test 'consonant 'case (case (car '(c d))
+			 ((a e i o u) 'vowel)
+			 ((w y) 'semivowel)
+			 (else 'consonant)))
+(test 'second 'case (case 10
+		      [(10) (cons 1 2) 'second]
+		      [else 5]))
+(test 'second-again 'case (case 11
+			    [(10) (cons 1 2) 'second]
+			    [else (cons 1 2) 'second-again]))
+(test-values '(10 9) (lambda ()
+		       (cond
+			[(positive? 0) 'a]
+			[(positive? 10) (values 10 9)]
+			[else #f])))
+(test-values '(10 9) (lambda ()
+		       (case (string->symbol "hello")
+			[(bye) 'a]
+			[(hello) (values 10 9)]
+			[else #f])))
+(error-test '(cond [(values 1 2) 8]) arity?)
+(error-test '(case (values 1 2) [(a) 8]) arity?)
+
+(test #t 'and (and (= 2 2) (> 2 1)))
+(test #f 'and (and (= 2 2) (< 2 1)))
+(test '(f g) 'and (and 1 2 'c '(f g)))
+(test #t 'and (and))
+(test-values '(1 12) (lambda () (and (cons 1 2) (values 1 12))))
+(test #t 'or (or (= 2 2) (> 2 1)))
+(test #t 'or (or (= 2 2) (< 2 1)))
+(test #f 'or (or #f #f #f))
+(test #f 'or (or))
+(test '(b c) 'or (or (memq 'b '(a b c)) (+ 3 0)))
+(test-values '(1 12) (lambda () (or (not (cons 1 2)) (values 1 12))))
+(syntax-test '(cond #t))
+(syntax-test '(cond ())  )
+(syntax-test '(cond (1 =>))  )
+(syntax-test '(cond (1 => 3 4))  )
+(syntax-test '(cond . #t))
+(syntax-test '(cond (#t . 1)))
+(syntax-test '(cond (#t 1) #f))
+(syntax-test '(cond (#t 1) . #f))
+(error-test '(cond ((values #t #f) 1)) arity?)
+(syntax-test '(case))
+(syntax-test '(case 0 #t))
+(syntax-test '(case . 0))
+(syntax-test '(case 0 . #t))
+(syntax-test '(case 0 (0 #t)))
+(syntax-test '(case 0 ()))
+(syntax-test '(case 0 (0)))
+(syntax-test '(case 0 (0 . 8)))
+(syntax-test '(case 0 ((0 . 1) 8)))
+(syntax-test '(case 0 (0 8) #f))
+(syntax-test '(case 0 (0 8) . #f))
+(syntax-test '(case 0 (else 1) (else 2)))
+(error-test '(case 0 ((0) =>))  exn:variable?)
+(syntax-test '(and . 1))
+(syntax-test '(and 1 . 2))
+(syntax-test '(or . 1))
+(syntax-test '(or 1 . 2))
+(error-test '(and #t (values 1 2) 8) arity?)
+(error-test '(or #f (values 1 2) 8) arity?)
+
+(SECTION 4 2 2)
+(test 6 'let (let ((x 2) (y 3)) (* x y)))
+(test 'second 'let (let ((x 2) (y 3)) (* x y) 'second))
+(test 6 'let-values (let-values (((x) 2) ((y) 3)) (* x y)))
+(test 6 'let-values (let-values (((x y) (values 2 3))) (* x y)))
+(test 35 'let (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))))
+(test 35 'let-values (let-values (((x y) (values 2 3))) (let-values (((x) 7) ((z) (+ x y))) (* z x))))
+(test 70 'let* (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x))))
+(test 70 'let*-values (let ((x 2) (y 3)) (let*-values (((x) 7) ((z) (+ x y))) (* z x))))
+(test #t 'letrec (letrec ((-even?
+			   (lambda (n) (if (zero? n) #t (-odd? (- n 1)))))
+			  (-odd?
+			   (lambda (n) (if (zero? n) #f (-even? (- n 1))))))
+		   (-even? 88)))
+(test #t 'letrec-values (letrec-values (((-even? -odd?)
+					 (values
+					  (lambda (n) (if (zero? n) #t (-odd? (- n 1))))
+					  (lambda (n) (if (zero? n) #f (-even? (- n 1)))))))
+				       (-even? 88)))
+(define x 34)
+(test 5 'let (let ((x 3)) (define x 5) x))
+(test 5 'let (let ((x 3)) (define-values (x w) (values 5 8)) x))
+(test 34 'let x)
+(test 6 'let (let () (define x 6) x))
+(test 34 'let x)
+(test 7 'let* (let* ((x 3)) (define x 7) x))
+(test 34 'let* x)
+(test 8 'let* (let* () (define x 8) x))
+(test 34 'let* x)
+(test 9 'letrec (letrec () (define x 9) x))
+(test 34 'letrec x)
+(test 10 'letrec (letrec ((x 3)) (define x 10) x))
+(test 34 'letrec x)
+(teval '(test 5 'letrec* (letrec* ((x 5)(y x)) y)))
+(test 3 'let (let ((y 'apple) (x 3) (z 'banana)) x))
+(test 3 'let* (let* ((y 'apple) (x 3) (z 'banana)) x))
+(test 3 'letrec (letrec ((y 'apple) (x 3) (z 'banana)) x))
+(test 3 'let* (let* ((x 7) (y 'apple) (z (set! x 3))) x))
+(test 3 'let* (let* ((x 7) (y 'apple) (z (if (not #f) (set! x 3) #f))) x))
+(test 3 'let* (let* ((x 7) (y 'apple) (z (if (not #t) #t (set! x 3)))) x))
+(test 3 'let-values (let-values (((y x z) (values 'apple 3 'banana))) x))
+(test 3 'let*-values (let*-values (((y x z) (values 'apple 3 'banana))) x))
+(test 3 'letrec-values (letrec-values (((y x z) (values 'apple 3 'banana))) x))
+(test 3 'let*-values (let*-values (((x y) (values 7 'apple)) ((z) (set! x 3))) x))
+(test 3 'let*-values (let*-values (((x y) (values 7 'apple)) ((z) (if (not #f) (set! x 3) #f))) x))
+(test 3 'let*-values (let*-values (((x y) (values 7 'apple)) ((z) (if (not #t) #t (set! x 3)))) x))
+
+(test-values '(3 4) (lambda () (let ([x 3][y 4]) (values x y))))
+(test-values '(3 -4) (lambda () (let loop ([x 3][y -4]) (values x y))))
+(test-values '(3 14) (lambda () (let* ([x 3][y 14]) (values x y))))
+(test-values '(3 24) (lambda () (letrec ([x 3][y 24]) (values x y))))
+(test-values '(3 24) (lambda () (letrec* ([x 3][y 24]) (values x y))))
+(test-values '(3 54) (lambda () (let-values ([(x y) (values 3 54)]) (values x y))))
+(test-values '(3 64) (lambda () (let*-values ([(x y) (values 3 64)]) (values x y))))
+(test-values '(3 74) (lambda () (letrec-values ([(x y) (values 3 74)]) (values x y))))
+(test-values '(3 84) (lambda () (letrec*-values ([(x y) (values 3 84)]) (values x y))))
+
+(test '(10 11) 'letrec-values (letrec-values ([(names kps)
+					       (letrec ([oloop 10])
+						 (values oloop (add1 oloop)))])
+					     (list names kps)))
+
+(define (error-test-let expr)
+  (syntax-test (cons 'let expr))
+  (syntax-test (cons 'let (cons 'name expr)))
+  (syntax-test (cons 'let* expr))
+  (syntax-test (cons 'letrec expr))
+  (syntax-test (cons 'letrec* expr)))
+(error-test-let 'x)
+(error-test-let '(x))
+(error-test-let '(()))
+(error-test-let '(x ()))
+(syntax-test '(let* x () 1))
+(syntax-test '(letrec x () 1))
+(syntax-test '(letrec* x () 1))
+(error-test-let '(x . 1))
+(error-test-let '(() . 1))
+(error-test-let '(((x 1))))
+(error-test-let '(((x 1)) . 1))
+(error-test-let '(((x . 1)) 1))
+(error-test-let '(((1 1)) 1))
+(error-test-let '(((x 1) 1)  1))
+(error-test-let '(((x 1) . 1)  1))
+(error-test-let '(((x 1 1)) 1))
+(error-test-let '(((x 1 1)) 1))
+(error-test-let '(((x 1)) 1 . 2))
+
+(define (do-error-test-let-values expr syntax-test)
+  (syntax-test (cons 'let-values expr))
+  (syntax-test (cons 'let*-values expr))
+  (syntax-test (cons 'letrec-values expr))
+  (syntax-test (cons 'letrec*-values expr)))
+(define (error-test-let-values expr)
+  (do-error-test-let-values expr syntax-test))
+(error-test-let-values 'x)
+(error-test-let-values '(x))
+(error-test-let-values '(()))
+(error-test-let-values '(x ()))
+(syntax-test '(let*-values x () 1))
+(syntax-test '(letrec-values x () 1))
+(syntax-test '(letrec*-values x () 1))
+(error-test-let-values '(x . 1))
+(error-test-let-values '(() . 1))
+(error-test-let-values '((((x) 1))))
+(error-test-let-values '((((x) 1)) . 1))
+(error-test-let-values '((((x) . 1)) 1))
+(error-test-let-values '((((1) 1)) 1))
+(error-test-let-values '((((x 1) 1)) 1))
+(error-test-let-values '((((1 x) 1)) 1))
+(error-test-let-values '((((x) 1) . 1)  1))
+(error-test-let-values '((((x) 1 1)) 1))
+(error-test-let-values '((((x . y) 1)) 1))
+(error-test-let-values '((((x . 1) 1)) 1))
+(error-test-let-values '((((x) 1)) 1 . 2))
+
+(do-error-test-let-values '((((x y) 1)) 1) (lambda (x) (error-test x arity?)))
+(do-error-test-let-values '((((x) (values 1 2))) 1) (lambda (x) (error-test x arity?)))
+(do-error-test-let-values '(((() (values 1))) 1) (lambda (x) (error-test x arity?)))
+(do-error-test-let-values '((((x) (values))) 1) (lambda (x) (error-test x arity?)))
+
+(test 5 'embedded (let () (define y (lambda () x)) (define x 5) (y)))
+
+(let ([wrap (lambda (body)
+	      (syntax-test `(let () ,@body))
+	      (syntax-test `(let () (begin ,@body))))])
+  (wrap '((define x 7) (define x 8) x))
+  (wrap '(2 (define y 8) x))
+  (wrap '((define 3 8) x))
+  (wrap '((define-values x 8) x)))
+
+(syntax-test '(let () (begin (define x 5)) x))
+
+(SECTION 4 2 3)
+(define x 0)
+(define (test-begin bg nested-bg)
+  (let* ([make-args
+	  (lambda (bg b)
+	    (if (eq? bg 'begin)
+		b
+		(let* ([len (length b)]
+		       [last (list-ref b (sub1 len))])
+		  (cons last
+			(let loop ([l b])
+			  (if (null? (cdr l))
+			      null
+			      (cons (car l) (loop (cdr l)))))))))]
+	 [test-bg
+	  (lambda (v b)
+	    (let* ([args (make-args bg b)]
+		   [expr (cons bg args)])
+	      (printf "~s:~n" expr)
+	      (teval `(test ,v (quote ,bg) ,expr))))]
+	 [make-bg
+	  (lambda (b)
+	    (cons nested-bg (make-args nested-bg b)))]
+	 [make-test-bg-d
+	  (lambda (bg)
+	    (lambda (v1 v2 b)
+	      (test-bg (if (eq? bg 'begin)
+			   v1
+			   v2)
+		       b)))]
+	 [test-bg-d (make-test-bg-d bg)]
+	 [test-bg-d2 (make-test-bg-d nested-bg)])
+  (teval '(set! x 0))
+  (test-bg-d 6 1 '((set! x 5) (+ x 1)))
+  (test-bg 5 '(5))
+  (test-bg 3 '(2 3))
+  (test-bg 3 `(2 (,bg 3)))
+  (test-bg 3 `(,(make-bg '(2)) ,(make-bg '(3))))
+  (test-bg-d 7 6 '((set! x 6) 'a (+ x 1)))
+  (test-bg ''w '((set! x 6) 'a (+ x 1) 'w))
+  (test-bg-d 8 7 '('b (set! x 7) (+ x 1)))
+  (test-bg-d 9 8 '('b (set! x 8) 'a (+ x 1)))
+  (test-bg ''z '('b (set! x 8) 'a (+ x 1) 'z))
+  (test-bg-d 7 9 `(,(make-bg '((set! x 6) 'a)) (+ x 1)))
+  (test-bg 10 `(,(make-bg '((set! x 60) 'a)) 10))
+  (teval '(test 60 'x x))
+  (test-bg 10 `(,(make-bg '((set! x 65) 'a)) (add1 20) 10))
+  (teval '(test 65 'x x))
+  (test-bg ''a `(10 ,(make-bg '((set! x 66) 'a))))
+  (teval '(test 66 'x x))
+  (test-bg ''a `(10 (add1 32) ,(make-bg '((set! x 67) 'a))))
+  (teval '(test 67 'x x))
+  (teval '(set! x 6))
+  (test-bg-d 8 7 `(,(make-bg '('b (set! x 7) 'a)) (+ x 1)))
+  (test-bg-d 9 8 `(,(make-bg '('b (set! x 8))) ,(make-bg '('a (+ x 1)))))
+  (test-bg-d2 10 9 `(,(make-bg `(,(make-bg `('b (set! x 9) ,(make-bg '('a (+ x 1)))))))))
+  (test-bg ''s `(,(make-bg `(,(make-bg `('b (set! x 9) ,(make-bg '('a (+ x 1) 's))))))))
+  (test-bg ''t `(,(make-bg `(,(make-bg `('b (set! x 9) ,(make-bg '('a (+ x 1))))))) 't))
+  (teval `(test 5 call-with-values (lambda () ,(make-bg '((values 1 2) (values 1 3 1)))) +))
+  (syntax-test `(,bg))
+  (syntax-test `(,bg . 1))
+  (syntax-test `(,bg 1 . 2))))
+
+(test-begin 'begin 'begin)
+(test-begin 'begin0 'begin)
+(test-begin 'begin0 'begin0)
+(test-begin 'begin 'begin0)
+
+(test 4 'implicit-begin (let ([x 4][y 7]) 'y x))
+(test 4 'implicit-begin (let ([x 4][y 7]) y x))
+
+(SECTION 4 2 5)
+(define f-check #t)
+(define f (delay (begin (set! f-check #f) 5)))
+(test #t (lambda () f-check))
+(test 5 force f)
+(test #f (lambda () f-check))
+(test 5 force f)
+(define f-check-2 (delay (values 1 5)))
+(test-values '(1 5) (lambda () (force f-check-2)))
+(values 1 2)
+(test-values '(1 5) (lambda () (force f-check-2)))
+(syntax-test '(delay))
+(syntax-test '(delay . 1))
+(syntax-test '(delay 1 . 2))
+(syntax-test '(delay 1 2))
+
+(SECTION 4 2 6)
+(test '(list 3 4) 'quasiquote `(list ,(+ 1 2) 4))
+(test '(list a (quote a)) 'quasiquote (let ((name 'a)) `(list ,name ',name)))
+(test '(a 3 4 5 6 b) 'quasiquote `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b))
+(test '((foo 7) . cons)
+	'quasiquote
+	`((foo ,(- 10 3)) ,@(cdr '(c)) . ,(car '(cons))))
+(test '#(10 5 2 4 3 8) 'quasiquote `#(10 5 ,(sqrt 4) ,@(map sqrt '(16 9)) 8))
+(test 5 'quasiquote `,(+ 2 3))
+(test '(a `(b ,(+ 1 2) ,(foo 4 d) e) f)
+      'quasiquote `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f))
+(test '(a `(b ,x ,'y d) e) 'quasiquote
+	(let ((name1 'x) (name2 'y)) `(a `(b ,,name1 ,',name2 d) e)))
+(test '(list 3 4) 'quasiquote (quasiquote (list (unquote (+ 1 2)) 4)))
+(test '`(list ,(+ 1 2) 4) 'quasiquote '(quasiquote (list (unquote (+ 1 2)) 4)))
+(test '(()) 'qq `((,@())))
+(define x 5)
+(test '(quasiquote (unquote x)) 'qq ``,x)
+(test '(quasiquote (unquote 5)) 'qq ``,,x)
+(test '(quasiquote (unquote-splicing x)) 'qq ``,@x)
+(test '(quasiquote (unquote-splicing 5)) 'qq ``,@,x)
+(test '(quasiquote (quasiquote (quasiquote (unquote (unquote (unquote x)))))) 'qq ````,,,x)
+(test '(quasiquote (quasiquote (quasiquote (unquote (unquote (unquote 5)))))) 'qq ````,,,,x)
+
+(test '(quasiquote (unquote result)) 'qq `(quasiquote ,result))
+(test (list 'quasiquote car) 'qq `(,'quasiquote ,car))
+
+(syntax-test '(quasiquote))
+(syntax-test '(quasiquote . 5))
+(syntax-test '(quasiquote 1 . 2))
+(syntax-test '(quasiquote 1 2))
+(syntax-test '(unquote 7))
+(syntax-test '(unquote-splicing 7))
+
+(syntax-test '`(1 . ,@5))
+(error-test '`(1 ,@5))
+(error-test '`(1 ,@5 2))
+
+(define (qq-test e)
+  (syntax-test e )
+  (syntax-test (list 'quasiquote e))
+  (syntax-test (list 'quasiquote e))
+  (syntax-test (list 'quasiquote (list 'quasiquote e)))
+  (syntax-test (list 'quasiquote (list 'quasiquote (list 'unquote e))))
+  (syntax-test (list 'quasiquote (list 'quasiquote (list 'unquote-splicing e)))))
+(qq-test '(unquote))
+(qq-test '(unquote 7 8 9))
+(qq-test '(unquote-splicing))
+(qq-test '(unquote-splicing 7 8 9))
+
+(test '(unquote . 5) 'qq (quasiquote (unquote . 5)))
+(test '(unquote 1 . 5) 'qq (quasiquote (unquote 1 . 5)))
+(test '(unquote 1 2 . 5) 'qq (quasiquote (unquote 1 2 . 5)))
+
+(test '(unquote 1 2 7 . 5) 'qq (quasiquote (unquote 1 2 ,(+ 3 4) . 5)))
+(test '(unquote 1 2 (unquote (+ 3 4)) . 5) 'qq (quasiquote (unquote 1 2 ,',(+ 3 4) . 5)))
+
+(test '(1 2 3 4 . 5) 'qq `(1 ,@'(2 3 4) . 5))
+
+(error-test '`(10 ,(values 1 2)) arity?)
+(error-test '`(10 ,@(values 1 2)) arity?)
+
+(SECTION 5 2 1)
+(define add3 (lambda (x) (+ x 3)))
+(test 6 'define (add3 3))
+(define (add3 x) (+ x 3))
+(test 6 'define (add3 3))
+(define first car)
+(test 1 'define (first '(1 2)))
+(syntax-test '(define))
+(syntax-test '(define . x))
+(syntax-test '(define x))
+(syntax-test '(define x . 1))
+(syntax-test '(define 1 2))
+(syntax-test '(define (1) 1))
+(syntax-test '(define (x 1) 1))
+(syntax-test '(define x 1 . 2))
+(syntax-test '(define x 1 2))
+
+(define-values (add3) (lambda (x) (+ x 3)))
+(test 6 'define (add3 3))
+(define-values (add3 another) (values (lambda (x) (+ x 3)) 9))
+(test 6 'define (add3 3))
+(test 9 'define another)
+(define-values (first second third) (values car cadr caddr))
+(test 1 'define (first '(1 2)))
+(test 2 'define (second '(1 2)))
+(test 3 'define (third '(1 2 3)))
+(define-values () (values))
+(syntax-test '(define-values))
+(syntax-test '(define-values . x))
+(syntax-test '(define-values x))
+(syntax-test '(define-values (x)))
+(syntax-test '(define-values x . 1))
+(syntax-test '(define-values (x) . 1))
+(syntax-test '(define-values 1 2))
+(syntax-test '(define-values (1) 2))
+(syntax-test '(define-values (x 1) 1))
+(syntax-test '(define-values (x . y) 1))
+(syntax-test '(define-values (x) 1 . 2))
+(syntax-test '(define-values (x) 1 2))
+
+(syntax-test '((define x 2) 0 1))
+(syntax-test '(+ (define x 2) 1))
+(syntax-test '(if (define x 2) 0 1))
+(syntax-test '(begin0 (define x 2)))
+(syntax-test '(begin0 (define x 2) 0))
+(syntax-test '(begin0 0 (define x 2)))
+(syntax-test '(let () (define x 2)))
+(syntax-test '(letrec () (define x 2)))
+(syntax-test '(lambda () (define x 2)))
+
+; Unfortunately, there's no good way to test this for mzc:
+(unless (defined? 'building-flat-tests)
+  (error-test '(define x (values)) exn:application:arity?)
+  (error-test '(define x (values 1 2)) exn:application:arity?)
+  (error-test '(define-values () 3) exn:application:arity?)
+  (error-test '(define-values () (values 1 3)) exn:application:arity?)
+  (error-test '(define-values (x y) (values)) exn:application:arity?)
+  (error-test '(define-values (x y) 3) exn:application:arity?)
+  (error-test '(define-values (x y) (values 1 2 3)) exn:application:arity?))
+
+(define ed-t0 0)
+(test 0 'begin0-define (begin0 0 (define x 5) (set! ed-t0 x)))
+(test 5 'begi0-define ed-t0)
+
+(begin (define ed-t1 1) (define ed-t2 2))
+(test 1 'begin-define ed-t1)
+(test 2 'begin-define ed-t2)
+(if (zero? (car (cons 0 0))) (define ed-t3 3) (define ed-t3 -3))
+(test 3 'begin-define ed-t3)
+
+(SECTION 5 2 2)
+(test 45 'define
+	(let ((x 5))
+		(define foo (lambda (y) (bar x y)))
+		(define bar (lambda (a b) (+ (* a b) a)))
+		(foo (+ x 3))))
+(define x 34)
+(define (foo) (define x 5) x)
+(test 5 foo)
+(test 34 'define x)
+(define foo (lambda () (define x 5) x))
+(test 5 foo)
+(test 34 'define x)
+(define (foo x) ((lambda () (define x 5) x)) x)
+(test 88 foo 88)
+(test 4 foo 4)
+(test 34 'define x)
+
+'(teval '(test 5 'define
+	       (let ()
+		 (define x 5)
+		 (define define (lambda (a b) (+ a b)))
+		 (define x 7)
+		 x)))
+'(teval '(syntax-test '(let ()
+			 (define define 5)
+			 (define y 6)
+			 y)))
+
+(syntax-test '(let ()
+		(define x 5)))
+(syntax-test '(let ()
+		(if #t
+		    (define x 5))
+		5))
+
+(SECTION 4 2 4)
+(test '#(0 1 2 3 4) 'do (do ((vec (make-vector 5))
+			    (i 0 (+ i 1)))
+			   ((= i 5) vec)
+			 (vector-set! vec i i)))
+(test 25 'do (let ((x '(1 3 5 7 9)))
+	       (do ((x x (cdr x))
+		    (sum 0 (+ sum (car x))))
+		   ((null? x) sum))))
+(test 1 'let (let foo () 1))
+(test '((6 1 3) (-5 -2)) 'let
+      (let loop ((numbers '(3 -2 1 6 -5))
+		 (nonneg '())
+		 (neg '()))
+	(cond ((null? numbers) (list nonneg neg))
+	      ((negative? (car numbers))
+	       (loop (cdr numbers)
+		     nonneg
+		     (cons (car numbers) neg)))
+	      (else
+	       (loop (cdr numbers)
+		     (cons (car numbers) nonneg)
+		     neg)))))
+(test 5 'do (do ((x 1)) (#t 5)))
+(test-values '(10 5) (lambda () (do ((x 1)) (#t (values 10 5)))))
+(syntax-test '(do))
+(syntax-test '(do ()) )
+(syntax-test '(do () ()) )
+(syntax-test '(do (1) (#t 5) 5))
+(syntax-test '(do ((1)) (#t 5) 5))
+(syntax-test '(do ((1 7)) (#t 5) 5))
+(syntax-test '(do ((x . 1)) (#t 5) 5))
+(syntax-test '(do ((x 1) 2) (#t 5) 5))
+(syntax-test '(do ((x 1) . 2) (#t 5) 5))
+(syntax-test '(do ((x 1)) (#t . 5) 5))
+(syntax-test '(do ((x 1)) (#t 5) . 5))
+
+(SECTION 'let/cc)
+
+(test 0 'let/cc (let/cc k (k 0) 1))
+(test 0 'let/cc (let/cc k 0))
+(test 1 'let/cc (let/cc k (cons 1 2) 1))
+(test-values '(2 1) (lambda () (let/cc k (values 2 1))))
+(test-values '(2 1) (lambda () (let/cc k (k 2 1))))
+(syntax-test '(let/cc))
+(syntax-test '(let/cc . k))
+(syntax-test '(let/cc k))
+(syntax-test '(let/cc k . 1))
+(syntax-test '(let/cc 1 1))
+
+(test 0 'let/ec (let/ec k (k 0) 1))
+(test 0 'let/ec (let/ec k 0))
+(test 1 'let/ec (let/ec k (cons 1 2) 1))
+(test-values '(2 1) (lambda () (let/ec k (values 2 1))))
+(test-values '(2 1) (lambda () (let/ec k (k 2 1))))
+(syntax-test '(let/ec))
+(syntax-test '(let/ec . k))
+(syntax-test '(let/ec k))
+(syntax-test '(let/ec k . 1))
+(syntax-test '(let/ec 1 1))
+
+(SECTION 'fluid-let)
+(define x 1)
+(define y -1)
+(define (get-x) x)
+(test 5 'fluid-let (fluid-let () 5))
+(test 2 'fluid-let (fluid-let ([x 2]) x))
+(test 0 'fluid-let (fluid-let ([x 2][y -2]) (+ x y)))
+(test 20 'fluid-let (fluid-let ([x 20]) (get-x)))
+(test 1 'fluid-let-done x)
+(error-test '(fluid-let ([x 10]) (error 'bad)) exn:user?)
+(test 1 'fluid-let-done-escape x)
+(test 3 'fluid-let (let* ([x 0][y (lambda () x)]) (fluid-let ([x 3]) (y))))
+(test 0 'fluid-let (let* ([x 0][y (lambda () x)]) (fluid-let ([x 3]) (y)) (y)))
+(test-values '(34 56) (lambda () (fluid-let ([x 34][y 56]) (values x y))))
+(test 'second 'fluid-let (fluid-let ([x 2][y -2]) (+ x y) 'second))
+
+(error-test '(fluid-let ([undefined-variable 0]) 8) exn:variable?)
+
+(syntax-test '(fluid-let))
+(syntax-test '(fluid-let . 1))
+(syntax-test '(fluid-let x 9))
+(syntax-test '(fluid-let 1 9))
+(syntax-test '(fluid-let (x) 9))
+(syntax-test '(fluid-let ([x]) 9))
+(syntax-test '(fluid-let ([x . 5]) 9))
+(syntax-test '(fluid-let ([x 5] . y) 9))
+(syntax-test '(fluid-let ([x 5] [y]) 9))
+(syntax-test '(fluid-let ([x 5]) . 9))
+(syntax-test '(fluid-let ([x 5]) 9 . 10))
+
+(SECTION 'parameterize)
+
+(test 5 'parameterize (parameterize () 5))
+(test 6 'parameterize (parameterize ([error-print-width 10]) 6))
+(test 7 'parameterize (parameterize ([error-print-width 10]
+				     [current-exception-handler void]) 
+				    7))
+(define oepw (error-print-width))
+(error-test '(parameterize ([error-print-width 777]) (error 'bad)) exn:user?)
+(test oepw 'parameterize (error-print-width))
+(error-test '(parameterize ([error-print-width 777]
+			    [current-output-port (current-error-port)])
+			   (error 'bad)) 
+	    exn:user?)
+(error-test '(parameterize ([error-print-width 'a]) 10))
+
+(error-test '(parameterize) syntaxe?)
+(error-test '(parameterize ()) syntaxe?)
+(error-test '(parameterize ((x y))) syntaxe?)
+(error-test '(parameterize ((x y)) . 8) syntaxe?)
+(error-test '(parameterize (x) 8) syntaxe?)
+(error-test '(parameterize (9) 8) syntaxe?)
+(error-test '(parameterize ((x z) . y) 8) syntaxe?)
+(error-test '(parameterize ((x . z)) 8) syntaxe?)
+(error-test '(parameterize ((x . 9)) 8) syntaxe?)
+(error-test '(parameterize ((x . 9)) 8) syntaxe?)
+
+(SECTION 'time)
+(test 1 'time (time 1))
+(test -1 'time (time (cons 1 2) -1))
+(test-values '(-1 1) (lambda () (time (values -1 1))))
+(syntax-test '(time))
+(syntax-test '(time . 1))
+(syntax-test '(time 1 . 2))
+
+(SECTION 'compiler)
+; Tests specifically aimed at the compiler
+(error-test '(let ([x (values 1 2)]) x) exn:application:arity?)
+; Known primitive
+(error-test '(let ([x (#%make-pipe)]) x) exn:application:arity?)
+; Known local
+(error-test '(let* ([f (lambda () (values 1 2))][x (f)]) x) exn:application:arity?)
+
+; Known local with global in its closure
+(test 15 'known (let ([g (lambda ()
+			   (letrec ([f (lambda (x)
+					 (+ x 5))])
+			     (f 10)))])
+		  (g)))
+; Known local with a set!
+(test 16 'known (let ([g (lambda ()
+			   (letrec ([f (lambda (x)
+					 (let ([y x])
+					   (set! x 7)
+					   (+ y 5)))])
+			     (f 11)))])
+		  (g)))
+; Known local non-function
+(error-test '(apply (lambda () (let ([f 12]) (f))) null) exn:application:non-procedure?)
+; Known local with revsed arguments:
+(test 10 (letrec ([f (lambda (a b) (if (zero? a) b (f b a)))]) f) 10 0)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/tcp.ss b/collects/tests/mzscheme/tcp.ss
new file mode 100644
index 0000000..7d62b51
--- /dev/null
+++ b/collects/tests/mzscheme/tcp.ss
@@ -0,0 +1,33 @@
+
+(define (tread)
+  (let ([l (tcp-listen 40000)])
+    (let-values ([(r w) (tcp-accept l)])
+	(read-line)
+	(printf "Hit return to start reading~n")
+	(read-line)
+	(let loop ([last 'none-read])
+	  (let ([v (read r)])
+	    (if (eof-object? v)
+		last
+		(loop v)))))))
+
+(define (twrite)
+  (let-values ([(r w) (tcp-connect "localhost" 40000)])
+    (let loop ([n 0])
+      (if (tcp-port-send-waiting? w)
+	  (begin
+	    (printf "write-full at ~s~n" n)
+	    (let loop ([m 0])
+	      (if (= m 5)
+		  (begin
+		    (printf "done: ~s~n" (+ m n -1))
+		    (close-output-port w)
+		    (close-input-port r))
+		  (begin
+		    (fprintf w "~s~n" (+ m n))
+		    (loop (add1 m))))))
+	  (begin
+	    (fprintf w "~s~n" n)
+	    (loop (add1 n)))))))
+
+		
\ No newline at end of file
diff --git a/collects/tests/mzscheme/testing.ss b/collects/tests/mzscheme/testing.ss
new file mode 100644
index 0000000..fa3023b
--- /dev/null
+++ b/collects/tests/mzscheme/testing.ss
@@ -0,0 +1,318 @@
+;;; `test.scm' Test correctness of MzScheme implementations.
+;;; Copyright (C) 1991, 1992, 1993, 1994 Aubrey Jaffer.
+;;; Modified for MzScheme by Matthew
+
+;;; MODIFIED for MzScheme - Matthew 8/95
+;;;  Added a few more tests, like append!, reverse!, etc.
+;;;  Added testing for inexact numbers
+;;;  Added a lot of error testing
+;;; modified for rational and complex numbers - Matthew 12/95
+;;; modified to test exceptions and more of MzScheme - Matthew 4/96
+;;; split into multiple files - Matthew 4/96
+;;; extended, extended, extended
+
+;;; This includes examples from
+;;; William Clinger and Jonathan Rees, editors.
+;;; Revised^4 Report on the Algorithmic Language Scheme
+;;; and the IEEE specification.
+
+; The format of the next line is important: file.ss relies on it
+(define cur-section '())(define errs '())
+
+(define teval eval)
+
+(define SECTION (lambda args
+		  (display "SECTION") (write args) (newline)
+		  (set! cur-section args) #t))
+(define record-error (lambda (e) (set! errs (cons (list cur-section e) errs))))
+
+(print-struct #t)
+
+(define number-of-tests 0)
+(define number-of-error-tests 0)
+(define number-of-exn-tests 0)
+
+(define test
+  (lambda (expect fun . args)
+    (set! number-of-tests (add1 number-of-tests))
+    (write (cons fun args))
+    (display "  ==> ")
+    (flush-output)
+    ((lambda (res)
+      (write res)
+      (newline)
+      (cond ((not (equal? expect res))
+	     (record-error (list res expect (cons fun args)))
+	     (display " BUT EXPECTED ")
+	     (write expect)
+	     (newline)
+	     #f)
+	    (else #t)))
+     (if (procedure? fun) (apply fun args) (car args)))))
+
+(define exn-table
+  (list (cons exn? (cons exn-message string?))
+	(cons exn:variable? (cons exn:variable-id symbol?))
+	(cons exn:application:non-procedure? (cons exn:application-value 
+						   (lambda (x) (not (procedure? x)))))
+	(cons exn:application:arity? (cons exn:application-value integer?))
+	(cons exn:application:arity? (cons exn:application:arity-expected
+					   (lambda (a)
+					     (or (integer? a)
+						 (and (arity-at-least? a)
+						      (integer? (arity-at-least-value a)))
+						 (and (list? a)
+						      (andmap
+						       (lambda (a)
+							 (or (integer? a)
+							     (and (arity-at-least? a)
+								  (integer? 
+								   (arity-at-least-value a)))))
+						       a))))))
+	(cons exn:application:type? (cons exn:application:type-expected symbol?))
+	(cons exn:application:range? (cons exn:application-value integer?))
+	(cons exn:application:range:bounds? (cons exn:application:range:bounds-min integer?))
+	(cons exn:application:range:bounds? (cons exn:application:range:bounds-max integer?))
+	(cons exn:application:math:zero? (cons exn:application-value zero?))
+	(cons exn:application:math:radix? (cons exn:application-value integer?))
+	(cons exn:application:list-sizes? (cons exn:application-value list?))
+	(cons exn:application:map-arity? (cons exn:application-value procedure?))
+	(cons exn:application:map-arity? (cons exn:application:map-arity-provided 
+					       (lambda (x) (and (integer? x) (positive? x)))))
+	(cons exn:application:mode-conflict? 
+	      (cons exn:application-value symbol?))
+	(cons exn:application:mode-conflict? 
+	      (cons exn:application:mode-conflict-filename
+		    string?))
+	(cons exn:application:file-position?
+	      (cons exn:application-value (lambda (x) (or (input-port? x)
+							  (output-port? x)))))
+	(cons exn:application:fprintf:extra-arguments?
+	      (cons exn:application-value string?))
+	(cons exn:application:fprintf:extra-arguments?
+	      (cons exn:application:fprintf:extra-arguments-extras list?))
+	(cons exn:application:fprintf:no-argument?
+	      (cons exn:application-value string?))
+	(cons exn:application:fprintf:argument-type?
+	      (cons exn:application:fprintf:argument-type-expected symbol?))
+
+	(cons exn:struct:struct-type? 
+	      (cons exn:struct:struct-type-value (lambda (x) (not (struct-type? x)))))
+
+	(cons exn:read? (cons exn:read-port input-port?))
+	(cons exn:read:number? (cons exn:read:number-input string?))
+	(cons exn:read:char? (cons exn:read:char-input string?))
+	(cons exn:read:eof? (cons exn:read:eof-expected string?))
+	(cons exn:read:unsupported? (cons exn:read:unsupported-input string?))
+	(cons exn:read:vector-length? (cons exn:read:vector-length-input string?))
+
+	(cons exn:object:class-type? (cons exn:object:class-type-value
+					   (lambda (x) (not (class? x)))))
+	(cons exn:object:interface-type? (cons exn:object:interface-type-value
+					       (lambda (x) (not (interface? x)))))
+	(cons exn:object:generic? (cons exn:object:generic-object object?))
+	(cons exn:object:inherit? (cons exn:object:inherit-ivar symbol?))
+	(cons exn:object:implement? (cons exn:object:implement-ivar symbol?))
+	(cons exn:object:class-ivar? (cons exn:object:class-ivar-class class?))
+	(cons exn:object:class-ivar? (cons exn:object:class-ivar-ivar symbol?))
+	(cons exn:object:interface-ivar? (cons exn:object:interface-ivar-interface interface?))
+	(cons exn:object:interface-ivar? (cons exn:object:interface-ivar-ivar symbol?))
+	(cons exn:object:ivar? (cons exn:object:ivar-object object?))
+	(cons exn:object:ivar? (cons exn:object:ivar-ivar symbol?))
+	(cons exn:object:private-class? (cons exn:object:private-class-class class?))
+	(cons exn:object:init? (cons exn:object:init-object object?))
+	(cons exn:object:init? (cons exn:object:init-class class?))
+
+	(cons exn:unit:non-unit? (cons exn:unit:non-unit-value (lambda (x) (not (unit? x)))))
+	(cons exn:unit:arity? (cons exn:unit:arity-unit unit?))
+	(cons exn:unit:import? (cons exn:unit:import-in-unit unit?))
+	(cons exn:unit:import? (cons exn:unit:import-out-unit unit?))
+	(cons exn:unit:import? (cons exn:unit:import-in-tag symbol?))
+	(cons exn:unit:import? (cons exn:unit:import-out-tag symbol?))
+	(cons exn:unit:import? (cons exn:unit:import-name symbol?))
+	(cons exn:unit:export? (cons exn:unit:export-unit unit?))
+	(cons exn:unit:export? (cons exn:unit:export-tag symbol?))
+	(cons exn:unit:export? (cons exn:unit:export-name symbol?))
+	(cons exn:unit:invoke:variable? (cons exn:unit:invoke:variable-name symbol?))
+	(cons exn:unit:signature:non-signed-unit? 
+	      (cons exn:unit:signature:non-signed-unit-value (lambda (x) (not (unit/sig? x)))))
+	(cons exn:unit:signature:arity?
+	      (cons exn:unit:signature:arity-unit unit/sig?))
+	(cons exn:unit:signature:match? (cons exn:unit:signature:match-dest-context string?))
+	(cons exn:unit:signature:match? (cons exn:unit:signature:match-src-context string?))
+	(cons exn:unit:signature:match? (cons exn:unit:signature:match-variable string?))
+
+	(cons exn:i/o:read? (cons exn:i/o:read-port input-port?))
+	(cons exn:i/o:write? (cons exn:i/o:write-port output-port?))
+	(cons exn:i/o:filesystem? (cons exn:i/o:filesystem-pathname string?))
+	(cons exn:i/o:port-closed? (cons exn:i/o:port-closed-port 
+				    (lambda (x) (or (input-port? x) (output-port? x)))))
+	(cons exn:i/o:user-port? (cons exn:i/o:user-port-port input-port?))
+
+	(cons exn:i/o:tcp:connect? (cons exn:i/o:tcp:connect-address string?))
+	(cons exn:i/o:tcp:connect? (cons exn:i/o:tcp:connect-port-id integer?))
+	(cons exn:i/o:tcp:listen? (cons exn:i/o:tcp:listen-port-id integer?))
+	(cons exn:i/o:tcp:accept? (cons exn:i/o:tcp:accept-listener tcp-listener?))
+	(cons exn:i/o:tcp:listener-closed? (cons exn:i/o:tcp:listener-closed-listener tcp-listener?))
+	
+	(cons exn:misc:constant? (cons exn:misc:constant-id symbol?))))
+
+(define thunk-error-test
+  (case-lambda 
+   [(th expr) (thunk-error-test th expr exn:application:type?)]
+   [(th expr exn?)
+    (set! number-of-error-tests (add1 number-of-error-tests))
+    (write expr)
+    (display "  =e=> ")
+    (call/ec (lambda (escape)
+	       (let* ([old-esc-handler (error-escape-handler)]
+		      [old-handler (current-exception-handler)]
+		      [orig-err-port (current-error-port)]
+		      [test-handler
+		       (lambda ()
+			 (escape #t))]
+		      [test-exn-handler
+		       (lambda (e)
+			 (when (and exn? (not (exn? e)))
+			       (printf " WRONG EXN TYPE: ~s " e)
+			       (record-error (list e 'exn-type expr)))
+
+			 (for-each
+			  (lambda (row)
+			    (let ([pred? (car row)])
+			      (when (pred? e)
+				    (set! number-of-exn-tests 
+					  (add1 number-of-exn-tests))
+				    (let ([sel (cadr row)]
+					  [pred? (cddr row)])
+				      (unless (pred? (sel e))
+					      (printf " WRONG EXN ELEM: ~s " e)
+					      (record-error (list e 'exn-elem expr)))))))
+			  exn-table)
+						 
+			 (old-handler e))])
+		 (dynamic-wind
+		  (lambda () 
+		    (current-error-port (current-output-port))
+		    (current-exception-handler test-exn-handler)
+		    (error-escape-handler test-handler))
+		  (lambda ()
+		    (let ([v (th)])
+		      (write v)
+		      (display " BUT EXPECTED ERROR")
+		      (record-error (list v 'Error expr))
+		      (newline)
+		      #f))
+		  (lambda () 
+		    (current-error-port orig-err-port)
+		    (current-exception-handler old-handler)
+		    (error-escape-handler old-esc-handler))))))]))
+
+(if (not (defined? 'error-test))
+    (define error-test
+      (case-lambda 
+       [(expr) (error-test expr exn:application:type?)]
+       [(expr exn?)
+	(thunk-error-test (lambda () (eval expr)) expr exn?)])))
+
+(define (syntax-test expr)
+  (error-test expr exn:syntax?)
+  (error-test `(if #f ,expr) exn:syntax?))
+
+(define (arity-test f min max)
+  (letrec ([aok?
+	    (lambda (a)
+	      (cond
+	       [(integer? a) (= a min max)]
+	       [(arity-at-least? a) (and (negative? max)
+					 (= (arity-at-least-value a) min))]
+	       [(and (list? a) (andmap integer? a))
+		(and (= min (car a)) (= max
+					(let loop ([l a])
+					  (if (null? (cdr l))
+					      (car l)
+					      (loop (cdr l))))))]
+	       [(list? a)
+		; Just check that all are consistent for now.
+		; This should be improved.
+		(andmap
+		 (lambda (a)
+		   (if (number? a)
+		       (<= min a (if (negative? max) a max))
+		       (>= (arity-at-least-value a) min)))
+		 a)]
+	       [else #f]))]
+	   [make-ok?
+	    (lambda (v)
+	      (lambda (e)
+		(and (exn:application:arity? e)
+		     (= (exn:application-value e) v)
+		     (aok? (exn:application:arity-expected e)))))]
+	   [do-test
+	    (lambda (f args check?)
+	      (set! number-of-error-tests (add1 number-of-error-tests))
+	      (printf "(apply ~s '~s)  =e=> " f args)
+	      (let/ec done
+		      (let ([v (with-handlers ([void
+						(lambda (exn)
+						  (if (check? exn)
+						      (printf " ~a~n" (exn-message exn))
+						      (let ([ok-type? (exn:application:arity? exn)])
+							(printf " WRONG EXN ~a: ~s~n" 
+								(if ok-type?
+								    "FIELD"
+								    "TYPE")
+								exn)
+							(record-error (list exn 
+									    (if ok-type?
+										'exn-field
+										'exn-type)
+									    (cons f args)))))
+						  (done (void)))])
+					      (apply f args))])
+			(printf "~s~n BUT EXPECTED ERROR~n" v)
+			(record-error (list v 'Error (cons f args))))))])
+    (let loop ([n 0][l '()])
+      (unless (>= n min)
+	      (do-test f l (make-ok? n))
+	      (loop (add1 n) (cons 1 l))))
+    (let loop ([n min])
+      (test #t procedure-arity-includes? f n)
+      (unless (>= n max)
+	  (loop (add1 n))))
+    (if (>= max 0)
+	(do-test f (let loop ([n 0][l '(1)])
+		     (if (= n max)
+			 l
+			 (loop (add1 n) (cons 1 l))))
+		 (make-ok? (add1 max)))
+	(test #t procedure-arity-includes? f (arithmetic-shift 1 100)))))
+
+(define (test-values l thunk)
+  (test l call-with-values thunk list))
+
+(define (report-errs)
+  (printf "~nPerformed ~a expression tests (~a good expressions, ~a bad expressions)~n"
+	  (+ number-of-tests number-of-error-tests)
+	  number-of-tests 
+	  number-of-error-tests)
+  (printf "and ~a exception field tests.~n~n" 
+	  number-of-exn-tests)
+  (if (null? errs) 
+      (display "Passed all tests.")
+      (begin
+	(display "Errors were:")
+	(newline)
+	(display "(SECTION (got expected (call)))")
+	(newline)
+	(for-each (lambda (l) (write l) (newline))
+		  errs)))
+  (newline)
+  (display "(Other messages report successful tests of error-handling behavior.)")
+  (newline))
+
+(define type? exn:application:type?)
+(define arity? exn:application:arity?)
+(define syntaxe? exn:syntax?)
+
+(define non-z void)
diff --git a/collects/tests/mzscheme/thread.ss b/collects/tests/mzscheme/thread.ss
new file mode 100644
index 0000000..b1bb038
--- /dev/null
+++ b/collects/tests/mzscheme/thread.ss
@@ -0,0 +1,142 @@
+
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'threads)
+
+(define t (thread (lambda () 8)))
+(test #t thread? t)
+
+(arity-test thread 1 1)
+(error-test '(thread 5) type?)
+(error-test '(thread (lambda (x) 8)) type?)
+(arity-test thread? 1 1)
+
+; Should be able to make an arbitrarily deep chain of custodians
+; if only the first & last are accssible:
+(test #t custodian?
+      (let loop ([n 1000][c (current-custodian)])
+	(if (zero? n)
+	    c
+	    (loop (sub1 n) (make-custodian c)))))
+
+(define SLEEP-TIME 0.1)
+(define result 0)
+(define th1 0)
+(define set-ready
+  (let ([s (make-semaphore 1)]
+	[r #f])
+    (lambda (v)
+      (semaphore-wait s)
+      (begin0
+       r
+       (set! r v)
+       (semaphore-post s)))))
+(define cm (make-custodian))
+(define th2 (parameterize ([current-custodian cm])
+              (thread 
+	       (lambda ()
+		 (let ([cm2 (make-custodian cm)])
+		   (parameterize ([current-custodian cm2])
+		      (set! th1 (thread 
+				 (lambda ()
+				   (let loop ()
+				     (let ([r (set-ready #f)])
+				       (sleep SLEEP-TIME)
+				       (set! result (add1 result))
+				       (when r (semaphore-post r)))
+				     (loop)))))))))))
+(define start result)
+(let ([r (make-semaphore)])
+  (set-ready r)
+  (semaphore-wait r))
+(test #f eq? start result)
+(kill-thread th2)
+(set! start result)
+(let ([r (make-semaphore)])
+  (set-ready r)
+  (semaphore-wait r))
+(test #f eq? start result)
+(test #t thread-running? th1)
+(custodian-shutdown-all cm)
+(thread-wait th1)
+(set! start result)
+(test #f thread-running? th1)
+(sleep SLEEP-TIME)
+(test #t eq? start result)
+
+(error-test `(parameterize ([current-custodian cm]) (kill-thread (current-thread)))
+	    exn:misc:thread:kill?)
+
+(test #t custodian? cm)
+(test #f custodian? 1)
+(arity-test custodian? 1 1)
+
+(arity-test make-custodian 0 1)
+(error-test '(make-custodian 0))
+
+(test (void) kill-thread t)
+(arity-test kill-thread 1 1)
+(error-test '(kill-thread 5) type?)
+
+(test #t thread-running? (current-thread))
+(arity-test thread-running? 1 1)
+(error-test '(thread-running? 5) type?)
+
+(arity-test sleep 0 1)
+(error-test '(sleep 'a) type?)
+(error-test '(sleep 1+3i) type?)
+
+(define s (make-semaphore 1))
+
+(test #t semaphore? s)
+
+(arity-test make-semaphore 0 1)
+(error-test '(make-semaphore "a") type?)
+(error-test '(make-semaphore -1) type?)
+(error-test '(make-semaphore 1.0) type?)
+(error-test '(make-semaphore (expt 2 64)) exn:misc:semaphore?)
+(arity-test semaphore? 1 1)
+
+(define test-block
+  (lambda (block? thunk)
+    (let* ([hit? #f]
+	   [t (parameterize
+	       ([current-custodian (make-custodian)])
+	       (thread (lambda () (thunk) (set! hit? #t))))])
+      (sleep 0.1)
+      (begin0 (test block? 'nondeterministic-block-test (not hit?))
+	      (kill-thread t)))))
+
+(test #t semaphore-try-wait? s) 
+(test #f semaphore-try-wait? s) 
+(semaphore-post s) 
+(test #t semaphore-try-wait? s) 
+(test #f semaphore-try-wait? s) 
+(semaphore-post s) 
+(test-block #f (lambda () (semaphore-wait s)))
+(test-block #t (lambda () (semaphore-wait s)))
+(semaphore-post s) 
+(test-block #f (lambda () (semaphore-wait/enable-break s)))
+(test-block #t (lambda () (semaphore-wait/enable-break s)))
+
+(arity-test semaphore-try-wait? 1 1)
+(arity-test semaphore-wait 1 1)
+(arity-test semaphore-post 1 1)
+
+(define s (make-semaphore))
+(define result 0)
+(define t-loop
+  (lambda (n m)
+    (lambda ()
+      (if (zero? n)
+	  (begin
+	    (set! result m)
+	    (semaphore-post s))
+	  (thread (t-loop (sub1 n) (add1 m)))))))
+(thread (t-loop 25 1))
+(semaphore-wait s)
+(test 26 'thread-loop result)
+
+(report-errs)
diff --git a/collects/tests/mzscheme/thrport.ss b/collects/tests/mzscheme/thrport.ss
new file mode 100644
index 0000000..86d378f
--- /dev/null
+++ b/collects/tests/mzscheme/thrport.ss
@@ -0,0 +1,59 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'multi-threaded-ports)
+
+; Read from file with 3 threads, all writing to the same pipe
+; read from pipe with 3 threads, all writing to the same output string
+; compare resulting character content to the original file
+(test 0 'threaded-ports
+      (let*-values ([(f-in) (open-input-file 
+			     (path->complete-path "testing.ss" 
+						  (current-load-relative-directory)))]
+		    [(p-in p-out) (make-pipe)]
+		    [(s-out) (open-output-string)]
+		    [(in->out) (lambda (in out)
+				 (lambda ()
+				   (let loop ()
+				     (let ([c (read-char in)]
+					   [dummy (lambda () 'hi)])
+				       (unless (eof-object? c)
+					       (write-char c out)
+					       (loop))))))]
+		    [(f->p) (in->out f-in p-out)]
+		    [(p->s) (in->out p-in s-out)]
+		    [(sthread) (lambda (thunk)
+				 (let ([t (thread (lambda () (sleep) (thunk)))])
+				   (thread-weight t 101)
+				   t))])
+		   (thread
+		    (lambda ()
+		      (for-each thread-wait
+				(list (sthread f->p)
+				      (sthread f->p)
+				      (sthread f->p)))
+		      (close-output-port p-out)))
+		   (for-each thread-wait
+			     (list (sthread p->s)
+				   (sthread p->s)
+				   (sthread p->s)))
+		   (let ([s (get-output-string s-out)]
+			 [hits (make-vector 256 0)])
+		     (for-each (lambda (c)
+				 (let ([n (char->integer c)])
+				   (vector-set! hits n (add1 (vector-ref hits n)))))
+			       (string->list s))
+		     (file-position f-in 0)
+		     (let loop ()
+		       (let ([c (read-char f-in)])
+			 (unless (eof-object? c)
+				 (let ([n (char->integer c)])
+				   (vector-set! hits n (sub1 (vector-ref hits n))))
+				 (loop))))
+		     (let loop ([i 0][total 0])
+		       (if (= i 256)
+			   total
+			   (loop (add1 i) (+ total (abs (vector-ref hits i)))))))))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/ttt/listlib.ss b/collects/tests/mzscheme/ttt/listlib.ss
new file mode 100644
index 0000000..c02be8c
--- /dev/null
+++ b/collects/tests/mzscheme/ttt/listlib.ss
@@ -0,0 +1,42 @@
+;; --------------------------------------------------------------------------
+;; list-library.ss
+;; export: 
+;; collect: 
+;;   (A ((cons B (listof B)) (listof B) (union A C) -> (union A C))
+;;    -> 
+;;    ((listof B) -> (union A C)))
+
+; #|
+; (unit/sig
+;   (collect filter set-minus subset?)
+;   (import plt:userspace^)
+; |#
+
+  (define collect
+    (lambda (base combine)
+      (local ((define C 
+		(lambda (l)
+		  (cond
+		    ((null? l) base)
+		    (else (combine l (car l) (C (cdr l))))))))
+	C)))
+
+  (define filter
+    (lambda (p? l)
+      [(collect null (lambda (_ x rest) (if (p? x) (cons x rest) rest))) l]))
+
+  ;; set library
+  (define set-minus
+    (lambda (set1 set2)
+      [(collect null (lambda (_ e1 rest) (if (member e1 set2) rest (cons e1 rest))))
+       set1]))
+
+  (define subset?
+    (lambda (state1 state2)
+      (cond
+	((null? state1) #t)
+	(else (and (member (car state1) state2)
+		(subset? (cdr state1) state2))))))
+; #|
+;   )
+; |#
diff --git a/collects/tests/mzscheme/ttt/tic-bang.ss b/collects/tests/mzscheme/ttt/tic-bang.ss
new file mode 100644
index 0000000..85422cd
--- /dev/null
+++ b/collects/tests/mzscheme/ttt/tic-bang.ss
@@ -0,0 +1,123 @@
+;; --------------------------------------------------------------------------
+;; tic-bang.ss
+;; This is an imperative version.
+
+;; This program plays through all possibilities of a tic-tac-toe
+;; game, given the first move of a player. It only prints how many
+;; states are being processed and how many states are terminal at
+;; each stage of the game.
+
+;; This program lacks the capability to print how a situation arose. 
+
+;; It relies on list-library.ss. 
+
+;; representations of fields, states, and collections of states
+(define BLANK 0)
+
+(define new-state
+  (lambda ()
+    (make-2vec 3 BLANK)))
+
+(define update-state
+  (lambda (state x y token)
+    (2vec-set! state x y token)
+    state))
+
+(define blank?
+  (lambda (astate i j)
+    (eq? (2vec-ref astate i j) BLANK)))
+
+(define clone-state
+  (lambda (state)
+    (let ((s (new-state)))
+      (let loop ((i 0) (j 0))
+	(cond
+	  ((and (= i 3) (= j 0)) (void))
+	  ((< j 3) (update-state s i j (2vec-ref state i j)) (loop i (+ j 1)))
+	  ((< i 3) (loop (+ i 1) 0))
+	  (else 'bad)))
+      s)))
+
+;(define-type state (2vector (union 'x 'o '_)))
+;(define-type states (listof state))
+
+(define PLAYER 1)
+(define OPPONENT 2)
+
+(define tic-tac-toe
+  (lambda (x y)
+    (tic (list (update-state (new-state) (- x 1) (- y 1) PLAYER)))))
+
+(define make-move
+  (lambda (other-move p/o tag)
+    (lambda (states)
+      (printf "~s: processing ~s states ~n" tag (length states))
+      (let ((t (print&remove-terminals states)))
+	(printf "terminal states removed: ~s~n" 
+		(- (length states) (length t)))
+	(if (null? t) 
+	    (void)
+	    (other-move (apply append (map p/o t))))))))
+
+(define tic (make-move (lambda (x) (tac x)) (lambda (x) (opponent x)) 'tic))
+
+(define tac (make-move (lambda (x) (tic x)) (lambda (x) (player x)) 'tac))
+
+(define make-players
+  (lambda (p/o)
+    (lambda (astate)
+      (let loop ((i 0) (j 0))
+	(cond
+	  ((and (= i 3) (= j 0)) null)
+	  ((< j 3) (if (blank? astate i j)
+		       (cons (update-state (clone-state astate) i j p/o)
+			     (loop i (+ j 1)))
+		       (loop i (+ j 1))))
+	  ((< i 3) (loop (+ i 1) 0))
+	  (else (error 'make-player "ouch")))))))
+
+(define player (make-players PLAYER))
+
+(define opponent (make-players OPPONENT))
+
+(define print&remove-terminals
+  (local ((define print-state
+	    (lambda (x)
+	      ;(display ".")
+	      (void))))
+
+    (collect null (lambda (_ astate rest)
+		    (if (terminal? astate)
+			(begin (print-state astate) rest)
+			(cons astate rest))))))
+
+(define terminal?
+  (lambda (astate)
+    (or (terminal-row 0 astate)
+	(terminal-row 1 astate)
+	(terminal-row 2 astate)
+	(terminal-col 0 astate)
+	(terminal-col 1 astate)
+	(terminal-col 2 astate)
+	(terminal-posdg astate)
+	(terminal-negdg astate))))
+
+(define terminal-row 
+  (lambda (n state)
+    (and (not (blank? state n 0))
+	 (= (2vec-ref state n 0) (2vec-ref state n 1) (2vec-ref state n 2)))))
+
+(define terminal-col
+  (lambda (n state)
+    (and (not (blank? state 0 n))
+	 (= (2vec-ref state 0 n) (2vec-ref state 1 n) (2vec-ref state 2 n)))))
+
+(define terminal-posdg
+  (lambda (state)
+    (and (not (blank? state 0 0))
+	 (= (2vec-ref state 0 0) (2vec-ref state 1 1) (2vec-ref state 2 2)))))
+
+(define terminal-negdg
+  (lambda (state)
+    (and (not (blank? state 0 2))
+	 (= (2vec-ref state 0 2) (2vec-ref state 1 1) (2vec-ref state 2 0)))))
diff --git a/collects/tests/mzscheme/ttt/tic-func.ss b/collects/tests/mzscheme/ttt/tic-func.ss
new file mode 100644
index 0000000..337a77a
--- /dev/null
+++ b/collects/tests/mzscheme/ttt/tic-func.ss
@@ -0,0 +1,119 @@
+;; --------------------------------------------------------------------------
+;; tic-func.ss 
+;; This program plays through all possibilities of a tic-tac-toe
+;; game, given the first move of a player. It only prints how many
+;; states are being processed and how many states are terminal at
+;; each stage of the game. But it is constructed so that it can
+;; print how to get to a winning terminal state. 
+
+;; It relies on list-library.ss. 
+
+;; representations of fields, states, and collections of states
+(define null '())
+(define-structure (entry x y who))
+(define entry-field
+  (lambda (an-entry)
+    (list (entry-x an-entry) (entry-y an-entry))))
+;(define-type state  (listof (structure:entry num num (union 'x 'o)))
+;(define-type states (listof state))
+
+(define PLAYER 'x)
+(define OPPONENT 'o)
+
+(define tic-tac-toe
+  (lambda (x y)
+    (tic (list (list (make-entry x y PLAYER))))))
+
+(define make-move
+  (lambda (other-move p/o tag)
+    (lambda (states)
+      (printf "~s: processing ~s states of length ~s ~n"
+	tag (length states) (length (car states)))
+      (let ((t (print&remove-terminals states)))
+	(printf "terminal states removed: ~s~n"
+	  (- (length states) (length t)))
+	(if (null? t) 
+	    (void)
+	    (other-move (apply append (map p/o t))))))))
+
+(define tic (make-move (lambda (x) (tac x)) (lambda (x) (opponent x)) 'tic))
+
+(define tac (make-move (lambda (x) (tic x)) (lambda (x) (player x)) 'tac))
+
+(define make-players
+  (local ((define rest-of-fields
+	    (lambda (used-fields)
+	      (set-minus ALL-FIELDS used-fields))))
+    (lambda (player/opponent)
+      (lambda (astate)
+	(map (lambda (counter-move)
+	       (let ((counter-x (car counter-move))
+		     (counter-y (cadr counter-move)))
+		 (cons (make-entry counter-x counter-y player/opponent)
+		   astate)))
+	  (rest-of-fields (map entry-field astate)))))))
+
+(define player (make-players PLAYER))
+
+(define opponent (make-players OPPONENT))
+
+(define terminal?
+  (local ((define filter-p/o
+	    (lambda (p/o astate)
+	      (map entry-field
+		(filter (lambda (x) (eq? (entry-who x) p/o)) astate)))))
+    (lambda (astate)
+      (and (>= (length astate) 5)
+	(let ((PLAYERf (filter-p/o PLAYER astate))
+	      (OPPONENTf (filter-p/o OPPONENT astate)))
+	  (or 
+	    (= (length astate) 9)
+	    (ormap (lambda (ts) (subset? ts PLAYERf)) TERMINAL-STATES)
+	    (ormap (lambda (ts) (subset? ts OPPONENTf)) TERMINAL-STATES)))))))
+
+(define print&remove-terminals
+  (local (
+
+	  (define print-state1
+	    (lambda (x)
+	      (display x)
+	      (newline)))
+
+	  (define print-state2
+	    (lambda (astate)
+	      (cond
+		((null? astate) (printf "------------~n"))
+		(else (print-state (cdr astate))
+		  (let ((x (car astate)))
+		    (printf " ~s @ (~s,~s) ~n"
+		      (entry-who x) (entry-x x) (entry-y x)))))))
+
+	  (define print-state
+	    (lambda (x)
+	      ;(display ".")
+	      (void))))
+
+    (collect null (lambda (_ astate rest)
+		    (if (terminal? astate)
+			(begin (print-state astate) rest)
+			(cons astate rest))))))
+;; fields
+(define T
+  (lambda (alof)
+    (cond
+      ((null? alof) null)
+      (else (cons (list (cadr (car alof)) (car (car alof)))
+		  (T (cdr alof)))))))
+
+(define row1 (list (list 1 1) (list 1 2) (list 1 3)))
+(define row2 (list (list 2 1) (list 2 2) (list 2 3)))
+(define row3 (list (list 3 1) (list 3 2) (list 3 3)))
+(define col1 (list (list 1 1) (list 2 1) (list 3 1)))
+(define col2 (list (list 1 2) (list 2 2) (list 3 2)))
+(define col3 (list (list 1 3) (list 2 3) (list 3 3)))
+(define posd (list (list 1 1) (list 2 2) (list 3 3)))
+(define negd (list (list 1 3) (list 2 2) (list 3 1)))
+
+(define TERMINAL-STATES (list row1 row2 row3 col1 col2 col3 posd negd))
+
+(define ALL-FIELDS (append row1 row2 row3))
diff --git a/collects/tests/mzscheme/ttt/ttt.ss b/collects/tests/mzscheme/ttt/ttt.ss
new file mode 100644
index 0000000..091e9f1
--- /dev/null
+++ b/collects/tests/mzscheme/ttt/ttt.ss
@@ -0,0 +1,14 @@
+
+(read-case-sensitive #t)
+(require-library "core.ss")
+(load "listlib.ss")
+(load "veclib.ss")
+(load "tic-func.ss")
+
+(let loop ()
+  (collect-garbage)
+  (collect-garbage)
+  (collect-garbage)
+  (dump-memory-stats)
+  (time (tic-tac-toe 1 1))
+  (loop))
diff --git a/collects/tests/mzscheme/ttt/veclib.ss b/collects/tests/mzscheme/ttt/veclib.ss
new file mode 100644
index 0000000..18ac802
--- /dev/null
+++ b/collects/tests/mzscheme/ttt/veclib.ss
@@ -0,0 +1,57 @@
+;; --------------------------------------------------------------------------
+;; 2vec-library.ss
+
+; #|
+; (unit/sig
+;   (make-2vec 2vec-ref 2vec-set! collect)
+;   (import plt:userspace^)
+; |#
+  
+  ;; 2 dimensional, square vectors
+
+    (define collect
+    (lambda (base combine)
+      (local ((define C 
+		(lambda (l)
+		  (cond
+		    ((null? l) base)
+		    (else (combine l (car l) (C (cdr l))))))))
+	C)))
+    
+  (define (make-2vec N element)
+    (make-vector (* N N) element))
+  
+  (define (2vec-ref 2vec i j)
+    (let ((L (sqrt (vector-length 2vec))))
+      (vector-ref 2vec (+ (* i L) j))))
+  
+  (define (2vec-set! 2vec i j element)
+    (let ((L (sqrt (vector-length 2vec))))
+      (if (and (< i L) (< j L))
+	  (vector-set! 2vec (+ (* i L) j) element)
+	  (error '2vec-set! "~s ~s" i j))))
+  
+  (define (I N)
+    (let ((2vec (make-2vec N 0)))
+      (let loop ((i 0) (j 0))
+	(if (= i N)
+	    (void)
+	    (begin
+	      (2vec-set! 2vec i j 1)
+	      (loop (add1 i) (add1 j)))))
+      2vec))
+  
+  (define (P N)
+    (let ((2vec (make-2vec N 0)))
+      (let loop ((i 0) (j 0))
+	(cond
+	  [(and (= i N) (= j 0)) (void)]
+	  [(< j N) (2vec-set! 2vec i j (list i j)) (loop i (add1 j))]
+	  [(< i N) (loop (add1 i) 0)]
+	  [else (error 'P "impossible ~s ~s" i j)]))
+      2vec))
+
+; #|
+;   )
+; |#
+
diff --git a/collects/tests/mzscheme/uinc.ss b/collects/tests/mzscheme/uinc.ss
new file mode 100644
index 0000000..ea489aa
--- /dev/null
+++ b/collects/tests/mzscheme/uinc.ss
@@ -0,0 +1,2 @@
+
+(+ 4 5)
diff --git a/collects/tests/mzscheme/uinc2.ss b/collects/tests/mzscheme/uinc2.ss
new file mode 100644
index 0000000..c1de73f
--- /dev/null
+++ b/collects/tests/mzscheme/uinc2.ss
@@ -0,0 +1,2 @@
+
+(define x 8)
diff --git a/collects/tests/mzscheme/unit.ss b/collects/tests/mzscheme/unit.ss
new file mode 100644
index 0000000..6c4febf
--- /dev/null
+++ b/collects/tests/mzscheme/unit.ss
@@ -0,0 +1,383 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'unit)
+
+(syntax-test '(unit))
+(syntax-test '(unit (import)))
+(syntax-test '(unit (impLort)))
+(syntax-test '(unit (impLort) (export) 5))
+(syntax-test '(unit (import) (expLort) 5))
+(syntax-test '(unit import (export) 5))
+(syntax-test '(unit (import) export 5))
+(syntax-test '(unit (import) (export) . 5))
+(syntax-test '(unit (import 8) (export) 5))
+(syntax-test '(unit (import . i) (export) 5))
+(syntax-test '(unit (import (i)) (export) 5))
+(syntax-test '(unit (import i 8) (export) 5))
+(syntax-test '(unit (import i . b) (export) 5))
+(syntax-test '(unit (import i (b)) (export) 5))
+(syntax-test '(unit (import i) (export 7) 5))
+(syntax-test '(unit (import i) (export . a) (define a 6)))
+(syntax-test '(unit (import i) (export a . b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x) . b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a 8) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export b (a 8)) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a . x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export b (a . x)) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x y) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x . y) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export b (a x . y)) (define a 5) (define b 6)))
+
+(syntax-test '(unit (import i) (export) (begin)))
+(syntax-test '(unit (import i) (export) (begin 1 . 2)))
+(syntax-test '(unit (import i) (export b a) (begin (define a 5) (define b 6) . x)))
+(syntax-test '(unit (import i) (export b a) (begin (define a 5) (define b 6)) (define b 6)))
+
+(syntax-test '(unit (import #%car) (export) (define a 5)))
+(syntax-test '(unit (import) (export #%car) (define a 5)))
+(syntax-test '(unit (import) (export #%car) (define #%car 5)))
+(syntax-test '(unit (import) (export) (define #%car 5)))
+(syntax-test '(unit (import) (export) (define-values (3) 5)))
+
+(syntax-test '(unit (import a) (export (a x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import a) (export (a x) (a y)) (define a 5) (define b 6)))
+(syntax-test '(unit (import i a) (export (a x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import b) (export (a x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i j i) (export (a x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i j j) (export (a x) b) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export a a) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x) (b x)) (define a 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x) b) (define a 5) (define a 6) (define b 6)))
+(syntax-test '(unit (import make-i) (export (a x) b) (define a 5) (define-struct i ()) (define b 6)))
+(syntax-test '(unit (import i) (export (make-a x) b) (define make-a 5) (define-struct a ()) (define b 6)))
+(syntax-test '(unit (import i) (export (a x) b) (define a 5) (define r 6) (define r 7) (define b 6)))
+
+(syntax-test '(unit (import i) (export b (a x)) 5))
+(syntax-test '(unit (import i) (export (a x) b) (define x 5) (define b 6)))
+(syntax-test '(unit (import i) (export (a x) b) (set! a 5) (define b 6)))
+
+(syntax-test '(compound-unit (import) (link (A (0 (A)))) (export))) ; self-import
+(syntax-test '(compound-unit (import) (link (A (0 (A x)))) (export))) ; self-import
+
+(unless (defined? 'test-global-var)
+	(define test-global-var 5)
+	(syntax-test '(unit (import) (export) test-global-var))
+	(constant-name 'test-global-var)
+	(syntax-test '(unit (import) (export) test-global-var)))
+
+(test #t unit? (unit (import) (export)))
+(test #t unit? (unit (import) (export) 5))
+(test #t unit? (unit (import i) (export (a x)) (define a 8) (define x 5)))
+(test 5 (lambda (f) (invoke-unit f)) (unit (import) (export) 5))
+
+(test #t unit? (unit (import i) (export b a) (begin (define a 5) (define b 6))))
+(test #t unit? (unit (import i) (export b a) 'a (begin (define a 5) (define b 6)) 'b))
+(test #t unit? (unit (import i) (export b a) (begin (define a 5)) (define b 6)))
+(test #t unit? (unit (import i) (export b a) (define a 5) (begin (define b 6))))
+(test #t unit? (unit (import i) (export b a) (define a 5) (begin (define y 7) (define b 6)) (+ y b a)))
+
+(test 3 'embedded-deeply ((invoke-unit (unit (import) (export) (lambda () (define x 3) x)))))
+(test 1 'embedded-deeply-struct ((invoke-unit (unit (import) (export) (lambda () 
+									(define-struct a ())
+									make-a
+									1)))))
+(syntax-test '(compound-unit))
+(syntax-test '(compound-unit . x))
+(syntax-test '(compound-unit (import)))
+(syntax-test '(compound-unit (import) . x))
+(syntax-test '(compound-unit (import) (link)))
+(syntax-test '(compound-unit (import) (link) . x))
+(syntax-test '(compound-unit import (link) (export)))
+(syntax-test '(compound-unit (import) link (export)))
+(syntax-test '(compound-unit (import) (link) export))
+(syntax-test '(compound-unit ((import)) (link) (export)))
+(syntax-test '(compound-unit (import) ((link)) (export)))
+(syntax-test '(compound-unit (import) (link) ((export))))
+(syntax-test '(compound-unit (import . a) (link) (export)))
+(syntax-test '(compound-unit (import b . a) (link) (export)))
+(syntax-test '(compound-unit (import 1) (link) (export)))
+(syntax-test '(compound-unit (import (a)) (link) (export)))
+(syntax-test '(compound-unit (import (a . b)) (link) (export)))
+(syntax-test '(compound-unit (import (a (b))) (link) (export)))
+(syntax-test '(compound-unit (import ((a) b)) (link) (export)))
+(syntax-test '(compound-unit (import) (link . a) (export)))
+(syntax-test '(compound-unit (import) (link a) (export)))
+(syntax-test '(compound-unit (import) (link (a)) (export)))
+(syntax-test '(compound-unit (import) (link (a (b)) . c) (export)))
+(syntax-test '(compound-unit (import) (link (a (b) . c)) (export)))
+(syntax-test '(compound-unit (import) (link (a (b . c)) (c (d))) (export)))
+(syntax-test '(compound-unit (import) (link (a (b c . e)) (c (d)) (e (f))) (export)))
+(syntax-test '(compound-unit (import) (link (a (b 1))) (export)))
+(syntax-test '(compound-unit (import) (link (a (b))) (export . a)))
+(syntax-test '(compound-unit (import) (link (a (b))) (export a)))
+(syntax-test '(compound-unit (import) (link (a (b))) (export (a w) . a)))
+(syntax-test '(compound-unit (import) (link (a (b))) (export (a 1))))
+(syntax-test '(compound-unit (import) (link (a (b))) (export (a (x)))))
+(syntax-test '(compound-unit (import) (link (a (b))) (export (1 w))))
+
+
+; Simple:
+
+(define m1
+  (unit
+   (import)
+   (export x y a? set-a-b!)
+   
+   (define-struct a (b c))
+
+   (define x 7)
+   (define z 8)
+   (define y (lambda () (* z x)))
+
+   (list x y z)))
+
+(test #t apply (lambda (x y z) (and (= x 7) (= z 8) (procedure? y) (= 0 (arity y))))
+      (invoke-unit m1))
+
+(test #t apply
+      (lambda (x y-val a? set-a-b!)
+	(and (= x 7) (= y-val 56)
+	     (= 1 (arity a?))
+	     (= 2 (arity set-a-b!))))
+      (invoke-unit
+       (compound-unit 
+	(import)
+	(link [M (m1)]
+	      [N ((unit 
+		   (import x y a? set-a-b!)
+		   (export)
+		   (list x (y) a? set-a-b!))
+		  (M x y a? set-a-b!))])
+	(export))))
+
+; Structures:
+
+
+(define m2-1
+  (unit 
+   (import)
+   (export x struct:a a? v y)
+
+   (define x 5)
+   (define-struct a (b c))
+   (define v (make-a 5 6))
+   (define (y v) (a? v))))
+
+(define m2-2
+  (unit
+   (import struct:a a?)
+   (export x? make-x x-z both)
+   
+   (define-struct (x struct:a) (y z))
+   (define both (lambda (v)
+		  (and (a? v) (x? v))))))
+
+(define m2-3
+  (compound-unit
+   (import)
+   (link [O (m2-1)][T (m2-2 (O struct:a) (O a?))])
+   (export [O x struct:a v y]
+	   [T x? make-x x-z both])))
+
+
+(let ([p (open-output-string)])
+  (invoke-unit
+   (compound-unit
+    (import)
+    (link [M (m2-3)]
+	  [N ((unit
+	       (import x v struct:a y x? make-x x-z both)
+	       (export)
+	       (define (filter v)
+		 (if (procedure? v)
+		     `(proc: ,(inferred-name v))
+		     v))
+	       (display 
+		(map filter (list x v struct:a y make-x x? x-z both))
+		p)
+	       (let ([v2 (make-x 1 2 3 4)])
+		 (display (map filter
+			       (list x (struct-type? struct:a)
+				     v (y v) (y x)
+				     v2
+				     (y v2)
+				     (x? v2)
+				     (both v)
+				     (both v2)))
+			  p)))
+	      (M x v struct:a y x? make-x x-z both))])
+    (export)))
+
+  (test (string-append "(5 #(struct:a 5 6) #<struct-type> (proc: y)"
+		       " (proc: make-x) (proc: x?)"
+		       " (proc: x-z) (proc: both))"
+		       "(5 #t #(struct:a 5 6) #t #f #(struct:x 1 2 3 4) #t #t #f #t)")
+	get-output-string p))
+
+; Compound with circularity
+
+(define make-z
+  (lambda (x-val)
+    (unit
+     (import z)
+     (export (x z) y)
+     
+     (define x x-val)
+     (define y (lambda () (- z x))))))
+    
+(define z1 (make-z 8))
+(define z2 (make-z 7))
+
+(define m3
+  (compound-unit
+   (import)
+   (link [Z1 (z1 (Z2 z))][Z2 (z2 (Z1 z))])
+   (export [Z1 (y y1) (z x1)][Z2 (y y2) (z x2)])))
+
+(invoke-open-unit m3)
+(test '(-1 1 8 7) 'invoke-open-unit (list (y1) (y2) x1 x2))
+
+; Dynamic linking
+
+(let ([u
+       (unit
+	(import x)
+	(export)
+	
+	(+ x 8))])
+
+  (test 10 'dynamic (invoke-unit
+		     (unit
+		      (import)
+		      (export w)
+		      
+		      (define w 2)
+
+		      (invoke-unit u w)))))
+
+; Linking environemtns
+
+(if (defined? 'x)
+    (undefine 'x))
+
+(define (make--eval)
+  (let ([n (make-namespace)])
+    (lambda (e)
+      (let ([orig (current-namespace)])
+	(dynamic-wind
+	 (lambda () (current-namespace n))
+	 (lambda () (eval e))
+	 (lambda () (current-namespace orig)))))))
+
+(define u
+  (unit
+   (import)
+   (export x)
+   (define x 5)))
+(define e (make--eval))
+(e (list 'invoke-open-unit u #f))
+(test #f defined? 'x)
+(test #t e '(defined? 'x))
+
+(define u2
+  (let ([u u])
+    (unit
+     (import)
+     (export)
+     (invoke-open-unit u #f))))
+(define e (make--eval))
+(e (list 'invoke-open-unit u2 #f))
+(test #f defined? 'x)
+(test #t e '(defined? 'x))
+
+
+; Misc
+
+(test 12 'nested-units
+      (invoke-unit
+       (compound-unit
+	(import)
+	(link (a@ ((unit (import) (export s@:a) (define s@:a 5))))
+	      (u@ ((compound-unit
+		    (import a@:s@:a)
+		    (link (r@ ((unit (import a) (export) (+ a 7)) a@:s@:a)))
+		    (export))
+		   (a@ s@:a))))
+	(export))))
+
+; Import linking via invoke-unit
+
+(test '(5 7 (7 2)) 'invoke-unit-linking
+      (let ([u (unit (import x) (export) x)]
+	    [v (unit (import x) (export) (lambda () x))]
+	    [x 5])
+	(list (invoke-unit u x)
+	      (begin 
+		(set! x 7)
+		(invoke-unit u x))
+	      (let ([f (invoke-unit v x)])
+		(list
+		 (f)
+		 (begin
+		   (set! x 2)
+		   (f)))))))
+
+; Shadowed syntax definitions:
+
+(test 8 'unit (invoke-unit (unit (import) (export) (define lambda 8) lambda)))
+(test 9 'unit (invoke-unit (unit (import) (export) (begin (define lambda 9) (define lambda2 lambda)) lambda2)))
+
+; Multiple values
+(test '(1 2 3) 
+      call-with-values
+      (lambda () (invoke-unit (unit (import) (export) (values 1 2 3))))
+      list)
+
+; Units within units:
+
+(define u (unit
+	   (import)
+	   (export)
+	   (define y 10)
+	   (define x 5)
+	   (unit
+	    (import)
+	    (export)
+	    x)))
+(test #t unit? u)
+(define u2 (invoke-unit u))
+(test #t unit? u2)
+(test 5 'invoke-unit-in-unit (invoke-unit u2))
+
+; Units and objects combined:
+
+(define u@ 
+  (unit (import x) (export)  
+	(class* () () () (public (y x)))))
+(define v (invoke-unit u@ car))
+(test #t class? v)
+(define w (make-object v))
+(test car 'ivar (ivar w y))
+
+(define c% 
+  (class* () () (x)        
+	  (public (z (unit (import) (export) x)))))
+(define u (ivar (make-object c% car) z))
+(test #t unit? u)
+(test car 'invoke (invoke-unit u))
+
+
+(define c% 
+  (class* () () (x) (public (y x))
+	  (public (z (unit (import) (export) y)))))
+(define u (make-object c% 3))
+(define u2 (ivar u z))
+(test #t unit? u2)
+(test 3 'invoke (invoke-unit u2))
+
+(test (letrec* ([x y][y 0]) x) 'invoke 
+      (invoke-unit (unit (import) (export) (define x y) (define y 7) x)))
+
+(report-errs)
diff --git a/collects/tests/mzscheme/unitsig.ss b/collects/tests/mzscheme/unitsig.ss
new file mode 100644
index 0000000..81d9be9
--- /dev/null
+++ b/collects/tests/mzscheme/unitsig.ss
@@ -0,0 +1,441 @@
+
+(if (not (defined? 'SECTION))
+    (load-relative "testing.ss"))
+
+(SECTION 'unit/sig)
+
+(undefine 'a)
+(undefine 'b)
+
+(syntax-test '(define-signature))
+(syntax-test '(define-signature))
+(syntax-test '(define-signature 8))
+(syntax-test '(define-signature . x))
+(syntax-test '(define-signature x))
+(syntax-test '(define-signature 8))
+(syntax-test '(define-signature x (8)))
+(syntax-test '(define-signature x (a . 8)))
+(syntax-test '(define-signature x (a . y)))
+(syntax-test '(define-signature x (y y)))
+(syntax-test '(define-signature x ((y))))
+(syntax-test '(define-signature x ((struct))))
+(syntax-test '(define-signature x ((struct y))))
+(syntax-test '(define-signature x ((struct . y))))
+(syntax-test '(define-signature x ((struct y . x))))
+(syntax-test '(define-signature x ((struct y x))))
+(syntax-test '(define-signature x ((struct y (x)) . x)))
+(syntax-test '(define-signature x ((unit))))
+(syntax-test '(define-signature x ((unit y))))
+(syntax-test '(define-signature x ((unit . y))))
+(syntax-test '(define-signature x ((unit y : a))))
+(define-signature a ())
+(syntax-test '(define-signature x ((unit y a))))
+(syntax-test '(define-signature x ((unit y . a))))
+(syntax-test '(define-signature x ((unit y : . a))))
+(syntax-test '(define-signature x ((unit y a) . x)))
+(syntax-test '(define-signature x (y (unit y a))))
+
+(syntax-test '(unit/sig))
+(syntax-test '(unit/sig 8))
+(syntax-test '(unit/sig b))
+(define-signature b (x y))
+(syntax-test '(unit/sig (a)))
+(syntax-test '(unit/sig a (impLort)))
+(syntax-test '(unit/sig a (impLort) 5))
+(syntax-test '(unit/sig a import 5))
+(syntax-test '(unit/sig a (import . x) . 5))
+(syntax-test '(unit/sig a (import (x) 8) 5))
+(syntax-test '(unit/sig a (import (x) . i) 5))
+(syntax-test '(unit/sig a (import (i : a) . b) 5))
+(syntax-test '(unit/sig b (import (i : a)) 5))
+(syntax-test '(unit/sig a (import (i : a x)) 5))
+(syntax-test '(unit/sig a (import (i : a) x) 5))
+(syntax-test '(unit/sig b (import (i : a)) (define x 7)))
+(syntax-test '(unit/sig b (import (i : a)) (define x 7) (define i:y 6)))
+(syntax-test '(unit/sig blah (import) (define x 7)))
+
+(syntax-test '(unit/sig () (import) (begin)))
+(syntax-test '(unit/sig () (import) (begin 1 . 2)))
+(syntax-test '(unit/sig () (import) (begin (define x 5)) (define x 5)))
+
+(define b@ (unit/sig b (import) (define x 9) (define y 9)))
+(define b2@ (unit/sig b (import (i : a)) (define x 9) (define y 9)))
+(define b3@ (unit/sig b (import (i : ())) (define x 9) (define y 9)))
+(define b3u@ (unit/sig b (import ()) (define x 9) (define y 9)))
+(define b3u2@ (unit/sig b (import a) (define x 9) (define y 9)))
+(define-signature >b ((unit b@ : b)))
+(define b3u3@ (unit/sig b (import (i : >b)) (define x 9) (define y 9)))
+
+(define >b@ (compound-unit/sig (import) (link [b@ : b (b@)]) (export (unit b@))))
+
+(syntax-test '(compound-unit/sig))
+(syntax-test '(compound-unit/sig 8))
+(syntax-test '(compound-unit/sig b))
+(syntax-test '(compound-unit/sig (import) (link) (export (var (U x)))))
+(syntax-test '(compound-unit/sig (import a) (link) (export)))
+(syntax-test '(compound-unit/sig (import 5) (link) (export)))
+(syntax-test '(compound-unit/sig (import . i) (link) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link ()) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@)) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ b)) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b)) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b ())) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ 5))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ . i))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ (i . a)))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ (i a a)))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ c@))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ (c@ a)))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export . b@)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export b@)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit c@))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit b@ : c))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit b@ (b@)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit b@ : (b@)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (open))))
+(error-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@ (i : a)))) (export)) exn:unit:signature:arity?)
+(error-test '(compound-unit/sig (import (i : a)) (link (b@ : b (5 (i : a)))) (export)) exn:unit:signature:non-signed-unit?)
+(error-test '(compound-unit/sig (import (i : b)) (link (b@ : b (b3@ (i : b)))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : b)) (link (b@ : b (b3u@ (i : b)))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : b)) (link (b@ : b (b3u2@ (i : b)))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : >b)) (link (b@ : b (b3@ (i : >b)))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : ((open a) x))) (link (b@ : b (b3@ (i : ((open a) x))))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : ((unit b@ : ((open b) w))))) (link (b@ : b (b3u3@ i))) (export)) exn:unit:signature:match:extra?)
+(error-test '(compound-unit/sig (import (i : a)) (link (b@ : (w) (b@))) (export)) exn:unit:signature:match:missing?)
+(error-test '(compound-unit/sig (import (i : ())) (link (b@ : b (b3u3@ i))) (export)) exn:unit:signature:match:missing?)
+(error-test '(compound-unit/sig (import (i : ((unit b@ : ())))) (link (b@ : b (b3u3@ i))) (export)) exn:unit:signature:match:missing?)
+(error-test '(compound-unit/sig (import (i : (b@))) (link (b@ : b (b3u3@ i))) (export)) exn:unit:signature:match:kind?)
+(error-test '(compound-unit/sig (import (i : ((unit b@ : (x (unit y : ())))))) (link (b@ : b (b3u3@ i))) (export)) exn:unit:signature:match:kind?)
+(syntax-test '(compound-unit/sig (import) (link [b@ : b (0 5)]) (export)))
+(syntax-test '(compound-unit/sig (import) (link [b@ : b (0 ())]) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : a (5 (i : b)))) (export)))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var b@))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@ x y)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (5 x)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@ 5)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var ((b@ w) 5)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var ((b@ 7) 5)))))
+(syntax-test '(compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@ x . a)))))
+
+(syntax-test '(compound-unit/sig (import) (link (A : () (0 A))) (export))) ; self-import
+(syntax-test '(compound-unit/sig (import) (link (A : (x) (0 A))) (export))) ; self-import
+
+(test #t unit/sig? (unit/sig a (import)))
+(test #t unit/sig? (unit/sig b (import) (define x 1) (define y 2)))
+(test #t unit/sig? (unit/sig a (import (i : b)) i:x))
+(test 5 (lambda (f) (invoke-unit/sig f ())) (unit/sig a (import ()) 5))
+(test #t unit/sig? (unit/sig (x) (import) (begin (define x 5))))
+(test #t unit/sig? (unit/sig (x) (import) (define a 14) (begin (define x 5) (define y 10)) (define z 12)))
+(test #t unit/sig? (compound-unit/sig (import) (link) (export)))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export)))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b2@ (i : a)))) (export)))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b2@ ((i) : a)))) (export)))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b2@ ((i) : ())))) (export)))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@ x)))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var (b@ x) w))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (var ((b@) x) w))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit b@))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit (b@)))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (unit b@ b@))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (open b@))))
+(test #t unit/sig? (compound-unit/sig (import (i : a)) (link (b@ : b (b@))) (export (open (b@ : b)))))
+
+; Include:
+
+(define i1@
+  (unit/sig 
+   ()
+   (import)
+   
+   (include "uinc.ss")))
+
+(test 9 'include (invoke-unit/sig i1@))
+
+(define i2@
+  (unit/sig 
+   ()
+   (import)
+   
+   (include "uinc.ss")
+   (include "uinc2.ss")
+   (include "uinc.ss")
+   (+ x 2)))
+
+(test 10 'include (invoke-unit/sig i2@))
+
+; Simple:
+
+(define-signature m1^
+  (x y a? set-a-b!))
+
+(define m1@
+  (unit/sig 
+   m1^
+   (import)
+   
+   (define-struct a (b c))
+
+   (define x 7)
+   (define z 8)
+   (define y (lambda () (* z x)))
+
+   (list x y z)))
+
+(test #t apply (lambda (x y z) (and (= x 7) (= z 8) (procedure? y) (= 0 (arity y))))
+      (invoke-unit/sig m1@))
+
+(test #t apply
+      (lambda (x y-val a? set-a-b!)
+	(and (= x 7) (= y-val 56)
+	     (= 1 (arity a?))
+	     (= 2 (arity set-a-b!))))
+      (invoke-unit/sig
+       (compound-unit/sig 
+	(import)
+	(link [M@ : m1^ (m1@)]
+	      [N@ : () ((unit/sig
+			 ()
+			 (import (i@ : m1^))
+			 (list i@:x (i@:y) i@:a? i@:set-a-b!))
+			M@)])
+	(export (open M@)))))
+
+; More:
+
+(define-signature m2-1-lite^
+  (x struct:a v y))
+
+(define-signature m2-1^
+  (a?
+   (open m2-1-lite^)))
+
+(define-signature m2-2^
+  (x? make-x x-z both))
+
+(define m2-1@
+  (unit/sig 
+   m2-1^
+   (import)
+
+   (define x 5)
+   (define-struct a (b c))
+   (define v (make-a 5 6))
+   (define (y v) (a? v))))
+
+(define m2-2@
+  (unit/sig
+   m2-2^
+   (import m2-1^)
+
+   (define-struct (x struct:a) (y z))
+   (define both (lambda (v)
+		  (and (a? v) (x? v))))))
+
+(define-signature m2-3^
+  (simple))
+
+(let-signature m2-3^
+  ((unit one@ : m2-1-lite^)
+   (unit two@ : m2-2^)
+   a?-again)
+
+  (define m2-3@
+    (compound-unit/sig
+     
+     (import)
+     (link [O@ : m2-1^ (m2-1@)]
+	   [T@ : m2-2^ (m2-2@ O@)])
+     (export (unit (O@ : m2-1-lite^) one@)
+	     (unit T@ two@)
+	     (var (O@ a?) a?-again))))
+
+  (let ([p (open-output-string)]
+	[filter (lambda (v)
+		  (if (procedure? v)
+		      `(proc: ,(inferred-name v))
+		      v))])
+    (invoke-unit/sig
+     (compound-unit/sig
+      (import)
+      (link [M@ : m2-3^ (m2-3@)]
+	    [N@ : () ((unit/sig
+		       ()
+		       (import (i : m2-3^))
+		       (display (map
+				 filter
+				 (list i:one@:x i:one@:v i:one@:struct:a i:one@:y 
+				       i:two@:make-x i:two@:x? i:two@:x-z i:two@:both
+				       i:a?-again))
+				p)
+		       (let ([v2 (i:two@:make-x 1 2 3 4)])
+			 (display (map
+				   filter
+				   (list i:one@:x (struct-type? i:one@:struct:a)
+					 i:one@:v (i:one@:y i:one@:v) (i:one@:y i:one@:x)
+					 v2
+					 (i:one@:y v2)
+					 (i:two@:x? v2)
+					 (i:two@:both i:one@:v)
+					 (i:two@:both v2)))
+				  p)))
+		      M@)])
+      (export)))
+    (test (string-append "(5 #(struct:a 5 6) #<struct-type> (proc: y)"
+			 " (proc: make-x) (proc: x?)"
+			 " (proc: x-z) (proc: both) (proc: a?))"
+			 "(5 #t #(struct:a 5 6) #t #f #(struct:x 1 2 3 4) #t #t #f #t)")
+	  get-output-string p)))
+
+(test 5 'let-sig
+      (invoke-unit/sig
+       (unit/sig
+	m2-3^
+	(import)
+	(define simple 5)
+	simple)))
+
+(define-signature big^
+  (a b c))
+(define-signature little^
+  (a b c))
+
+(test 11
+      'link-restrict 
+      (invoke-unit/sig
+       (compound-unit/sig
+	(import)
+	(link [a@ : big^ ((unit/sig big^ (import) (define a 5) (define b 6) (define c 7)))]
+	      [b@ : () ((unit/sig () (import (i : little^)) (+ i:a i:b)) 
+			(a@ : little^))])
+	(export))))
+
+(define-signature just-a^
+  (a))
+(define-signature >just-a^
+  ((unit s@ : just-a^)))
+
+; Test a path for linking: root is a constiuent
+(test 12
+      'link-path
+      (invoke-unit/sig
+       (compound-unit/sig
+	(import)
+	(link [a@ : >just-a^ ((compound-unit/sig
+			       (import)
+			       (link [i@ : just-a^ ((unit/sig 
+						     just-a^ 
+						     (import) 
+						     (define a 5)))])
+			       (export (unit i@ s@))))]
+	      [r@ : () ((unit/sig 
+			 () 
+			 (import (i : just-a^))
+			 (+ i:a 7))
+			(a@ s@))])
+	(export))))
+
+; Test a path for linking: root is an import
+(test 12
+      'import-path
+      (invoke-unit/sig
+       (compound-unit/sig
+	(import)
+	(link [a@ : >just-a^ ((compound-unit/sig
+			       (import)
+			       (link [i@ : just-a^ ((unit/sig 
+						     just-a^ 
+						     (import) 
+						     (define a 5)))])
+			       (export (unit i@ s@))))]
+	      [u@ : () ((compound-unit/sig
+			 (import (a@ : >just-a^))
+			 (link [r@ : () ((unit/sig 
+					  () 
+					  (import (i : just-a^))
+					  (+ i:a 7))
+					 (a@ s@))])
+			 (export))
+			a@)])
+	(export))))
+
+; Export var from embedded unit:
+
+(define-signature e ((unit w : (embedded-v))))
+(invoke-open-unit/sig
+ (compound-unit/sig
+  (import)
+  (link [E : e ((compound-unit/sig
+		 (import)
+		 (link [w : (embedded-v) ((unit/sig (embedded-v)
+						    (import)
+						    (define embedded-v 0)))])
+		 (export (unit w))))])
+  (export (var ((E w) embedded-v)))))
+(test 0 'embedded-v embedded-v)
+
+; Signature ordering
+
+(define o1 (unit/sig (num sym) (import) (define num 5) (define sym 'a)))
+(define o2 (unit/sig () (import (sym num)) (list sym (+ num))))
+
+(test (list 'a 5)
+      'order
+      (invoke-unit/sig
+       (compound-unit/sig
+	(import)
+	(link [one : (num sym) (o1)]
+	      [two : () (o2 one)])
+	(export))))
+
+; unit->unit/sig, etc.
+
+(define-signature s1
+  (a b c))
+(define-signature s2
+  (+))
+
+(define us1 
+  (unit
+   (import +)
+   (export a b c)
+   
+   (define a 1)
+   (define b 2)
+   (define c 3)
+   (+ a b c)))
+   
+(test 6 'u->s (invoke-unit us1 +))
+(test 6 'u->s (invoke-unit/sig (unit->unit/sig us1 (s2) s1) s2))
+
+; Exporting a name twice:
+
+(syntax-test
+ '(compound-unit/sig
+   (import)
+   (link [A : (a) ((unit/sig (a) (import) (define a 1)))])
+   (export (var (A a)) (open A))))
+
+(syntax-test
+ '(compound-unit/sig
+   (import)
+   (link [A : (a) ((unit/sig (a) (import) (define a 1)))]
+	 [B : (b) ((unit/sig (b) (import) (define b 2)))])
+   (export (unit A x) (unit B x))))
+
+(syntax-test
+ '(compound-unit/sig
+   (import)
+   (link [A : (a) ((unit/sig (a) (import) (define a 1)))]
+	 [B : (b) ((unit/sig (b) (import) (define b 2)))])
+   (export (unit A) (unit B A))))
+
+; Shadowed syntax definitions:
+
+(test 8 'unit/sig (invoke-unit/sig (unit/sig () (import) (define lambda 8) lambda)))
+(test 9 'unit/sig (invoke-unit/sig (unit/sig () (import) (begin (define lambda 9) (define lambda2 lambda)) lambda2)))
+
+(report-errs)
+
diff --git a/collects/tests/mzscheme/ztest.ss b/collects/tests/mzscheme/ztest.ss
new file mode 100644
index 0000000..2956776
--- /dev/null
+++ b/collects/tests/mzscheme/ztest.ss
@@ -0,0 +1,20 @@
+;; rudimentary test harness for complex math routines in 
+;; zmath.ss 
+
+(require-library "zmath.ss")
+
+(define ztest
+  (lambda (z)
+    (printf "z = ~a~n" z)
+    (printf " zabs(z) = ~a~n" (zabs z))
+    (printf " zlog(z) = ~a~n" (zlog z))
+    (printf " zexp(z) = ~a~n" (zexp z))
+    (printf " zsqrt(z) = ~a~n" (zsqrt z))
+    (printf " zsin(z) = ~a~n" (zsin z))
+    (printf " zcos(z) = ~a~n" (zcos z))
+    (printf " ztan(z) = ~a~n" (ztan z))
+    (printf " zasin(z) = ~a~n" (zasin z))
+    (printf " zacos(z) = ~a~n" (zacos z))
+    (printf " zatan(z) = ~a~n" (zatan z))))
+
+(ztest 0.5)
diff --git a/notes/drscheme/openbugs b/notes/drscheme/openbugs
new file mode 100644
index 0000000..34e8067
--- /dev/null
+++ b/notes/drscheme/openbugs
@@ -0,0 +1,11 @@
+- in the language dialog box, "allow set! on undefined" is ignored
+
+- check syntax doesn't traverse unit or class expressions
+
+- check syntax: identifiers with newlines in them have their arrows
+  start from funny places.
+
+- eval'ing images in drscheme is broken
+
+- backup files don't preserve file permissions
+
diff --git a/notes/mred/COPYING.LIB b/notes/mred/COPYING.LIB
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/notes/mred/COPYING.LIB
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/notes/mred/FONTS b/notes/mred/FONTS
new file mode 100644
index 0000000..c584f91
--- /dev/null
+++ b/notes/mred/FONTS
@@ -0,0 +1,432 @@
+
+Do not read this file. If you want to change the fonts in MrEd,
+use the preferences dialog instead.
+
+Ok, if you're still reading, you must really want to do something that
+can't be done via the preferences dialog. Most likely, it *can* be
+done, and this file will tell you how if you're pantient enough.
+
+---------------------------------------------------
+    1. Welcome to the Weird World of MrEd Fonts
+---------------------------------------------------
+
+MrEd's font system is designed to appear to work gracefully across
+platforms to a naive MrEd user. It is also designed to provide
+complete configuration control to a knowledgeable user (this may be
+especially necessary under X Windows). These are somewhat
+contradictory goals, and leave MrEd with a somewhat complex font
+system.
+
+Terminology will be developed here to explain the working of the font
+system, but do not expect these terms to be used by the MrEd
+toolbox. The toolbox is designed to do what a programmer or user
+probably wanted using names that a programmer or user would probably
+understand intuitively.
+
+A "real font" is a device-speicific font used to draw or measure text
+for a screen or a printer. MrEd handles three kinds of real fonts:
+
+  * Screen fonts
+  * PostScript font names
+  * AFM font files
+
+An "abstract font" is a platform- and device-independent entity
+that describes a font. MrEd uses 8 abstract fonts:
+
+  * "Default"
+  * "Decorative"
+  * "Roman"
+  * "Script"
+  * "Swiss"
+  * "Modern"
+  * "Teletype"
+  * "System"
+
+The "System" abstract font is intended only for use with screen-based
+controls. The "Teletype" abstract font is rarely used.
+
+There are two basic problems:
+
+ * Mapping abstract fonts to real fonts
+ * Specifying a real font without a corresponding abstract font
+
+The solution in the latter case is simply to let the user or
+programmer invent new abstract fonts. However, the new abstract font
+is associated with a core abstract font so that a suitable default
+real font can be selected when no information about the new abstract
+font is available.
+
+Abstract fonts are mapped to real fonts via the low-level setup
+resource file read by MrEd at startup time. (Under X Windows, X
+resources can be specified in any way, but specifying X resources
+through the startup file is the preferred mechanism.)
+
+In the case of real fonts for an X Windows screen, it is necssary to
+map not only an abstract font toa real font, but an abstract font
+combined with a weight, style, and size to a real font - hence, the
+insane complexity of MrEd's font system.
+
+---------------------------
+    1. Resource Entries
+---------------------------
+
+First, we consider the mechanism tha maps abstract fonts to real fonts
+in the case that the information is provided via resources.
+
+To find a font name in the resource, MrEd looks for a resource item
+named by:
+
+  <dest><type><weight><style>
+
+Where
+
+  <dest> is either "Screen", "PostScript", or "AFM"
+  <type> is either "Default", "Decorative", "Roman", "Script", "Swiss", 
+         "Modern", "Teletype", or "Screen", or a programmer- or 
+         user-generated abstract font name
+  <weight> is either "Medium", "Bold", or "Light"
+  <style> is either "Straight", "Italic", or "Slant"
+
+Once the resource value is obtained, the way in which is it used is
+destination- and platform-specific (surprise, surprise):
+
+ * A PostScript name value is always used as a PostScript 
+   font name (the preceeding slash is added automatically).
+
+ * An AFM name is used as the base file name.  The ".afm"
+   extension is added automatically. The AFM file is found
+   according to the path maintained by wx:get-afm-path
+   and wx:set-afm-path.
+
+ * A screen name is interpreted in a platform-specific way:
+ 
+   - Under Windows and MacOS, the name is used directly as the
+     font name.
+
+   - Under X-Windows, the name is either:
+
+       - a full X Windows font name (including style information), 
+         with a "%d" in place of the point-size field, and 
+         prefixed with a "+"; or
+
+       - a partial X Windows font name, matching one of the 
+         following regexp replacements:
+
+          -([^-]*) 
+            => -*-\1-<weight>-<style>-normal-*-*-%d-*-*-*-*-*-*
+	  -([^-]*)-(.*) 
+            => -\1-\2-<weight>-<style>-normal-*-*-%d-*-*-*-*-*-*
+	  ([^-].*[^-]) 
+            => \1
+
+         Note that the absence of a leading "+" triggers the 
+         regexp-replace attempt
+
+For example, under X Windows, this X resource entry specifies the
+Default, medium-weight, unslanted font:
+
+ mred.ScreenDefaultMediumStraight: +-*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+and this is equivalent:
+
+ mred.ScreenDefaultMediumStraight: -*-*
+
+or even this:
+
+ mred.ScreenDefaultMediumStraight: -*
+
+
+A non-core abstract font <x> is associated with core abstract fonts
+with a resource item named by Family<x> where the value is the name
+of a core abstract font. For example, the new abstract font "Century" 
+might be asscoaited with the "Roman" core abstract class:
+
+  mred.FamilyCentury: Roman
+
+
+1.1. Wildcards
+--------------
+
+It has probably not escpaed the reader's attention that building
+items names by <dest><type><weight><style> will creates a rather
+large number of resource entires. Furthermore, the <weight><style>
+part is only useful for X Windows screen fonts. To avoid an
+explosion of resource entires, MrEd actually finds resource items
+via a wildcarding search.
+
+The <type>, <weight>, and <style> parts of a resource name can
+be wildcarded by using "_". Thus, to set the default font for all
+types, weights, and styles, use this X resource entry:
+
+ mred.Screen___: +-*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+Wildcarded resource entires are used only when un-wildcarded values
+cannot be found. If two resource names both match for some search,
+then the one with the "earliest" (i.e., closest to the beginning of
+the resource name) non-wildcarded part will prevail.
+
+The default MrEd resource file for Windows uses wildcarding to
+specify the basic font mapping:
+
+ [mred]
+ defaultFontSize=10
+ ScreenDefault__=MS Sans Serif
+ ScreenRoman__=Times New Roman
+ ScreenDecorative__=Modern
+ ScreenModern__=Courier New
+ ScreenSwiss__=Arial
+ ScreenScript__=Script
+
+Wildcarding by itself is altogether too simple, so we add more
+power/confusion with References, Parameterizations, and Wildcarding
+References. Non-masochists may consider skipping to section 1.2.
+
+1.1.1 References
+- - - - - - - - 
+
+Suppose we define the default font for all of "Default", and then
+we want "Roman" to use this setting, too. We could copy the
+resource entry, like this:
+
+ mred.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+ mred.ScreenRoman__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+but the MrEd font-reading system provides a better syntax for
+referencing another resource entry. When a resource value contains
+"${x}", then the "${x}" fragment is replaced by the resource value of
+"x". Thus, the above could be re-written:
+
+ mred.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+ mred.ScreenRoman__: ${ScreenDefault__}
+
+But wait, there's more...
+
+1.1.2 Parameterizations
+- - - - - - - - - - - -
+
+Parameterization can be used with referencing to parameterize default
+values based on the weight and style that is needed.  When a resource
+value contains "$[weight]", then "$[weight]" is replaced with a string
+for the desired font weight. Similarly, "$[style]" is replaced with
+the desired style. Parameterizing expressions can be embedded in 
+referencing expressions, like this:
+
+  mred.ScreenDefault__: -*-*-${Def$[weight]}-r-normal-*-*-%d-*-*-*-*-*-*
+  mred.DefMedium: medium
+  mred.DefBold: bold
+  mred.DefLight: medium
+
+Now, when the "ScreenDefault__" resource is used for different weights,
+it will return different values; the "${Def$[weight]}~ expression will
+turn into "${DefMedium}" for a medium-weight lookup, or "${DefBold}"
+for a bold-weight lookup. These references will in turn give either
+"medium" or "bold".
+
+We're not done, yet...
+
+1.1.3 Wildcarding References
+- - - - - - - - - - - - - - 
+
+Consider the following resource configuration:
+
+  MrEd.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenRoman__: ${ScreenDefault__}
+
+The effect of this statement is probably not what was intended; when
+a bold version of the "Roman" font is needed, "ScreenRoman__"
+references "ScreenDefault__", which does not specify a bold font.
+We could try to remedy the situation this way:
+
+  MrEd.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenRoman__: ${ScreenDefault$[weight]_}
+
+but this does not work either. It works fine for bold "Roman", now, 
+but medium "Roman" will cause a reference to "ScreenDefaultMedium_",
+which doesn't exist. The problem is that our reference does not use
+wildcarding like the original medium "Roman" lookup did.
+
+Wildcarding can be specified in a reference by separating each
+wildcardable field with a comma. This resource specification does
+what we want:
+
+  wxApp.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  wxApp.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  wxApp.ScreenRoman__: ${ScreenDefault,$[weight],_}
+
+Since "$[weight]" is set off by commas, it can be wildcarded if no
+name excatly matching "SchemeDefault$[weight]_" is found. In this case
+"SchemeDefault" and "_" can also be wildcarded, but this will have no
+effect.
+
+
+1.2 Internal Resources
+----------------------
+
+The initial font setup is built into MrEd through a built-in resource
+table. This table is shown in the appendix. When font information is
+looked up, it is *almost* as if this table were installed into your
+resources file; the difference is that resource specifications in your
+file can override specifications in the built-in table, even when the
+wildcarding of your resource provides a weaker match.
+
+
+1.3 Lookup Failures
+-------------------
+
+When no information is available mapping a non-core abstract font to a
+real font for the screen, the abstract font name is used as the font
+name. This heuristic means that MrEd generally does the expected thing
+when a program provides an arbitrary platform-specific face name to a
+wx:font constructor (see section 2.).
+
+The core abstract fonts all have defaults screen real fonts used as a
+last resort. Under Windows and MacOS, these real fonts correspond to
+the default font suggested by the font's abstract font (or associated
+abstract font in the case of non-core abstract fonts).
+
+
+-----------------------------------------------
+    2. wx:font%
+-----------------------------------------------
+
+The remaining question is how MrEd maps information specified in
+wx:font% constructions to obtain real fonts via the abstract font
+mapping:
+
+ * If only a "family" is supplied to wx:font%, the corresponding
+   core abstract font is used.
+
+ * If a "face name" is supplied to wx:font%, then the face name
+   is used as a new abstract font name. The provided "family"
+   specifies the associated core abstract font.
+
+That's it. Sounds too easy? Then you didn't read the preceding
+sections closely enough.
+
+------------------------------------
+    Appendix: Built-in Resources
+------------------------------------
+ 
+ FamilyDefault: Default
+ FamilyRoman: Roman
+ FamilyDecorative: Decorative
+ FamilyModern: Modern
+ FamilyTeletype: Teletype
+ FamilySwiss: Swiss
+ FamilyScript: Script
+ FamilySystem: System
+
+ AfmMedium: 
+ AfmLight: 
+ AfmStraight: 
+ AfmItalic: ${AfmSlant}
+ 
+ Afm___: ${AfmTimes,$[weight],$[style]}
+ 
+ AfmTimes__: ${AfmTimes}${Afm$[weight]}${Afm$[style]}
+ AfmTimesMediumStraight: ${AfmTimes}${AfmRoman}
+ AfmTimesLightStraight: ${AfmTimes}${AfmRoman}
+ AfmTimes_Italic: ${AfmTimes}$[weight]${AfmItalic}
+ AfmTimes_Slant: ${AfmTimes}$[weight]${AfmItalic}
+ 
+ AfmSwiss__: ${AfmHelvetica}${Afm$[weight]}${Afm$[style]}
+ AfmModern__: ${AfmCourier}${Afm$[weight]}${Afm$[style]}
+ 
+ AfmTeletype__: ${AfmModern,$[weight],$[style]}
+ 
+ 
+ PostScriptMediumStraight: 
+ PostScriptMediumItalic: -Oblique
+ PostScriptMediumSlant: -Oblique
+ PostScriptLightStraight: 
+ PostScriptLightItalic: -Oblique
+ PostScriptLightSlant: -Oblique
+ PostScriptBoldStraight: -Bold
+ PostScriptBoldItalic: -BoldOblique
+ PostScriptBoldSlant: -BoldOblique
+
+ PostScriptTimesMedium: 
+ PostScriptTimesLight: 
+ PostScriptTimesBold: Bold
+
+ PostScriptTimes__: Times${PostScript$[weight]$[style]}
+ PostScriptTimesMediumStraight: Times-Roman
+ PostScriptTimesLightStraight: Times-Roman
+ PostScriptTimes_Slant: Times-${PostScriptTimes$[weight]}Italic
+ PostScriptTimes_Italic: Times-${PostScriptTimes$[weight]}Italic
+ 
+ PostScriptSwiss__: Helvetica${PostScript$[weight]$[style]}
+ PostScriptModern__: Courier${PostScript$[weight]$[style]}
+ 
+ PostScriptTeletype__: ${PostScriptModern,$[weight],$[style]}
+
+ PostScript___: ${PostScriptTimes,$[weight],$[style]} 
+ 
+
+X Windows only:
+
+ AfmBold: Bo
+ AfmSlant: O
+ AfmRoman: Ro
+ AfmTimes: Times
+ AfmHelvetica: Helv
+ AfmCourier: Cour
+ 
+ ScreenMedium: medium
+ ScreenBold: bold
+ ScreenLight: light
+ ScreenStraight: r
+ ScreenItalic: i
+ ScreenSlant: o
+ 
+ ScreenDefaultBase: misc-fixed
+ ScreenRomanBase: *-times
+ ScreenDecorativeBase: *-helvetica
+ ScreenModernBase: *-courier
+ ScreenTeletypeBase: *-courier
+ ScreenSwissBase: *-lucida
+ ScreenScriptBase: *-zapfchancery
+
+ ScreenStdSuffix: -${Screen$[weight]}-${Screen$[style]}-normal-*-*-%d-*-*-*-*-*-*
+
+ ScreenDefault__: +-${ScreenDefaultBase}${ScreenStdSuffix}
+ ScreenRoman__: +-${ScreenRomanBase}${ScreenStdSuffix}
+ ScreenDecorative__: +-${ScreenDecorativeBase}${ScreenStdSuffix}
+ ScreenModern__: +-${ScreenModernBase}${ScreenStdSuffix}
+ ScreenTeletype__: +-${ScreenTeletypeBase}${ScreenStdSuffix}
+ ScreenSwiss__: +-${ScreenSwissBase}${ScreenStdSuffix}
+ ScreenScript__: +-${ScreenScriptBase}${ScreenStdSuffix}
+
+
+Windows/MacOS only:
+
+ AfmBold: bo
+ AfmSlant: ob
+ AfmRoman: ro
+ AfmTimes: time
+ AfmHelvetica: helv
+ AfmCourier: cour  
+ 
+
+Windows only:
+
+ Screen___: MS Sans Serif
+ ScreenRoman__: Times New Roman
+ ScreenDecorative__: Modern
+ ScreenModern__: Courier New
+ ScreenTeletype__: ${ScreenModern$[weight];$[style]}
+ ScreenSwiss__: Arial
+ ScreenScript__: Script
+ 
+MacOS only:
+
+ ScreenDefault__: applicationfont
+ ScreenSystem__: systemfont
+ ScreenRoman__: times
+ ScreenDecorative__: geneva
+ ScreenModern__: monaco
+ ScreenTeletype__: ${ScreenModern,$[weight],$[style]}
+ ScreenSwiss__  helvetica
+ ScreenScript__: geneva
diff --git a/notes/mred/HISTORY b/notes/mred/HISTORY
new file mode 100644
index 0000000..22c4a70
--- /dev/null
+++ b/notes/mred/HISTORY
@@ -0,0 +1,373 @@
+Version 51: ??, 1997
+X Windows: window manager close-frame request is ignored
+ when a modal dialog is in control
+Added security so that wx:snip% methods cannot be overridden 
+ to crash MrEd
+
+Version 50: August 26, 1997
+Changed wx:dc%'s get-size method to return size of
+ destination area; old [documented] functionality
+ is available via max-x and max-y
+Made button-click state visible for Xt on b&w displays
+Fixed and normalized PostScript drawing
+Removed wx:dc% methods: device-to-logical-x, etc.
+Windows wx:display-size changed to return the size of the
+ screen not including the task bar
+Windows: finally fixed scale for [non-PostScript] printing
+Added wx:[un]register-collecting-blit
+X Windows: Fixed use of colormap by loaded bitmap images
+Added an optional argument to wx:media-buffer's print method
+ to supporting fitting to the destination page
+X Windows: Saving as xbm works for bitmaps of any depth
+MzScheme pathname expansion performed by all wx: toolbox
+ procedures that take a pathname
+X Windows Xt: removed excessive borders on wx:canvas% objects
+X Windows Xt: removed 2 pixel offset for a single auto-sized
+ child in a wx:frame% or wx:dialog-box%
+Windows: Fixed scrollbars on editor buffers; they're always
+ shown now, but the editor never gets confused about the size
+Fixed on-size, pre-on-char, and pre-on-event for wx:item% 
+ subclasses
+Fixed confusing argument type and number error messages
+ for overloaded methods of primitive classes
+
+Version 49: May 31, 1997
+Object system changes: see mzscheme/HISTORY for details
+Fixed Mac event-handling and many other Mac things
+Fixed garbage collection of hidden frames under Windows (!)
+Panels, canvases, and controls that are both hidden and
+  inaccessible are now garbage-collected
+Disabled controls are reliably grayed-out, including items 
+  within a disabled panel 
+Instances of wx:pen%, wx:brush%, or wx:pen% that are
+  selected into a drawing context cannot be mutated
+Immutability of objects obtained via wx:the-XXX-list is
+  enforced
+Controls for Windows, Xt are created with the "System" family
+  rather than the "Default" family (using resources)
+Single wx:bitmap% object can be used by multiple controls
+  and/or pens and/or brushes
+Fixed Motif image-label radio button
+wx:find-directory replaced with wx:find-path
+All wx:dc% instances have a default font for drawing
+wx:const-copy blit never uses the pen/background color;
+  new blit mode wx:const-colour uses current pen
+X Windows: removed mapping of Mod3 to Alt (too confusing on
+  keyboards where NumLock is Mod3)
+Fixed wx:timer% bug that caused autosaving to not work
+Fixed eventspace bugs
+Fixed .bmp reading when smaller-than-max colormap is provided
+Fixed interlaced .gif reading for Windows and MacOS
+Xt: fixed default height of wx:text% items
+Xt: In a wx:mouse-event% instance, type wx:const-type-XXX-down
+  implies get-XXX-down => #t (formerly #f)
+Removed wx:group-box% class; use a panel with a border, instead
+Removed wx:tool-bar% class
+wx:choice% get-columns and set-columns no longer supported
+Added wx:gauge% methods: get-value and get-range
+wx:media-pasteboard% bug fixes and improvements: raise, lower, 
+  set-before, and set-after methods now work
+wx:list-box% set-client-data and get-client-data work with
+  any Scheme data type
+Windows and X Windows: Break key changed back to shift-ctl-c 
+  instead of ctl-c (to avoid conflicts with Emacs-std keyboard
+  mappings)
+
+Version 48: Skipped to avoid confusion with Scheme48
+
+Version 47: January 11, 1997
+WARNING: multiple inhertance is going away in 48
+Added overwrite-styles? arg to wx:media-buffer%'s read-from-file,
+  and added get-/set-load-overwrites-styles methods
+Modified wx:media-buffer%'s set-caret-owner to provide more
+  levels of focus control
+Controls with bitmap labels work correctly, fixed crashing bugs,
+  some Mac controls do not display yet
+wx:bitmap%'s load-file only allowed when the bitmap is not selected
+  into a wx:memory-dc% object or used by a control
+
+Version 46: December 5, 1996
+Fixed misc. Motif control-sizing problems
+Mac & Xt: "&" stripped from control labels correctly
+wx:yield takes an optional semaphore argument
+
+Version 45: November 12, 1996
+IMPORTANT: let-values is now analogous to let; the old 
+  let-values is now let*-values
+Added thread-savy parameterization system; namespace system changed
+Added eventspaces
+wx:server%, wx:client%, and wx:connection% are no longer supported
+  (Better TCP support is now built into MzScheme)
+wx:the-snip-class-list was replaced by (wx:get-the-snip-class-list)
+wx:the-buffer-data-class-list was replaced by (wx:get-the-buffer-data-class-list)
+Added transparent text backing for editor text
+Added wx:dc% try-colour method
+wx:window% capture-mode, release-mouse, and make-modal no longer supported
+  Modal dialogs can be used instead of make-modal (modal is
+  specified through the constructor). There is currently no
+  replacement for capture-mouse and release-mouse, but a replacement is
+  likely to be in 46.
+Xt and Mac: "&" stripped from control labels (matches Windows/Motif), sortof
+
+Version 44: September 9, 1996
+wx:play-sound added
+Saving bitmaps fixed on all platforms; editor can now save 
+  "inlined" images instead of only references to images
+Hyper-text browser handles HTML files (w/o networking)
+Fixed Mac control drawing and hiding
+Fixed Xt menus (finally!)
+Fixed menu item auto-check for popup menus
+Fixed Motif canvas click event reporting (spurious drags)
+See also mzscheme/HISTORY, wxme/README, and system/HISTORY
+Upgraded to gc 11alpha3
+
+Version 43: Re-released August 12, 1996
+Under GNU LGPL license
+
+Version 43: August 9, 1996
+Major system overhaul (Robby Findler); see system/HISTORY
+Windows stability greatly advanced
+Windows and MacOS versions much more "Windows-like" and "Mac-like"
+  with standard menu shortcuts and better icons
+MacOS and Windows use native print facilities
+GIF images supported under Windows
+wx:window set-client-size removed
+wx:panel%'s get-cursor renamed to get-item-cursor; added set-item-cursor
+Fixed cut-n-paste newlines under MacOS and Windows
+Xt: panel with one item no longer auto-sizes the child
+See also mzscheme/HISTORY
+
+Version 42: June 8, 1996
+Documentation translated to Scheme notation, corrected
+Windows update bug fixed for embedded buffers
+MacOS memory use greatly improved
+Fixed annoying non-standard Windows beep
+Non-matching cond or case expression raises and error
+mred:platform and mred:window-system changed to wx:...
+standard system uses functors (see MzScheme)
+wx:canvas%::int-draw-line and wx:int-point% removed
+wx:list%, wx:hash-table%, wx:string-list%, wx:path-list removed
+wx:media-stream-in%::get removed for strings; use get-string
+Redundant wx: functions removed:
+  wx:dir-exists?  (use directory-exists?)
+  wx:file-exists? (use file-exists?)
+  wx:file-name-from-path (use file-name-from-path or split-path)
+  wx:path-only (use path-only or split-path)
+  wx:is-absolute-path? (use reletaive-path?)
+  wx:expand-path (use expand-path)
+  wx:get-working-directory (use current-directory)
+  wx:set-working-directory (use current-directory)
+  wx:mkdir (use make-directory)
+  wx:remove-file (use delete-file)
+  wx:rename-file (use rename-file)
+  wx:get-user-home and wx:get-home-dir (use expand-path with "~")
+  wx:execute and wx:shell (use system or process)
+  wx:find-first-file and wx:find-next-file (use get-directory-list)
+  wx:sleep (use sleep)
+  wx:sub-type? (use subclass?)
+  wx:to-lower (use char-upcase)
+  wx:to-upper (use char-downcase)
+  wx:is-wild? (use reg exps)
+  wx:match-wild? (use reg exps)
+
+Version 0.41: April 15, 1996
+Important language changes; see mzscheme/HISTORY
+Fixed bug in wxCanvas drawing methods
+Fixed wxCanvasDC and wxMemoryDC bugs in Xt version
+Pasteboards fixed
+AIX: two consecutive SIGDANGERs => exit(-1)
+wxGetMultipleChoice supported
+
+Version 0.40: March 24, 1996
+Possible improvements to memory system
+Some redundant event methods removed
+Finally fixed Windows NT/95 Scheme threads
+Stdout/stderr messages to a window instead of file for Windows/Mac+
+Fixed misc. Xt problems, including show-n-hide on frame
+
+Version 0.39: March 6, 1996
+Fixed safety from Scheme on invalidated C++ objects (stack objs, too)
+Fixed many bugs in Xt version
+Upgraded to gc version 4.10
+Reduced memory usage of buffer objects
+
+Version 0.38: February 22, 1996
+Xt port released
+Part of standard system moved to DrScheme
+See also mzscheme HISTORY and wxmedia README
+
+Version 0.37: Not released
+
+Version 0.36: January 18, 1996
+Fixed bug in MzScheme's bignum multiplication
+
+Version 0.35: January 17, 1996
+X selection protocol supported. To get the old clipboard-style
+  mechanism, add this to your .mredrc:
+     (wx:media-set-x-selection-mode #f)
+ See also wxMediaEdit::SetPosition() in the wxMedia manual.
+
+Version 0.34: December 30, 1995
+Minor improvements to MzScheme and the standard system
+
+Version 0.33: December 21, 1995
+MzScheme language changes; see mzscheme/HISTORY
+Old standard system no longer compatible
+Project system improved
+Many bugs fixed in the new standard system
+
+Version 0.32: December 4, 1995
+New standard system:
+  * The console I/O is completely different. It works more
+     like an Emacs shell. Use M-p and M-n to access previously
+     entered expressions. (read) will now read from the console.
+  * All mred:std-<x> variables have been eliminated. For each
+     mred:<x>%, there is now a procedure mred:make-<x>% that takes a
+     superclass and returns a new class.
+  * The frame and buffer hierarchies have changed a little.
+  * From a mred:edit% object, you can get to its canvas or frame.
+  * The menubar/menu system is completely revised. You don't have to
+     deal with menu ids much anymore. Menus and menu items can now be 
+     dynamically added and removed.
+  * Keymap chaining works differently.
+  * The new Scheme project system is roughly in place. This will let you
+     develop Scheme programs by organizing Scheme files within a project.
+     Projects help manage loading program files into the
+     evaluator and uses Shriram's Zodiac/Aries packages to
+     provide debugging facilities. This will be improved in the near 
+     future.
+ The old standard system is available in the "oldsys" directory.
+Pretty printer handles loops and graphs
+Very limited support for wxYield under XView - will be extended
+Fixed some wxMedia bugs (see wxme/README)
+Fixed some MzScheme bugs (see mzscheme/HISTORY)
+
+Version 0.31: November 14, 1995
+Fixed some wxMedia bugs (see wxme/README)
+Fixed some MzScheme bugs (see mzscheme/HISTORY)
+Parameterization for Macintosh
+
+Verion 0.30: October 25, 1995
+Added call-with-values and regexp to MzScheme
+Unix stack-checking setup code fixed in MzScheme
+wxMediaPasteboard implemented more
+Scheme-C++ object link changed; use ptr in all C++ objects
+Added tutorial section to "User Manual"
+
+Version 0.29: October 18, 1995
+Editor can save text preserving automatic CR
+Bug fix in automatic line-wrapping
+New font system can access arbitrary fonts
+Multiple displays in Motif: wx:set-display and wx:get-display-name
+MzScheme fix for forms such as (let ([x (let ...)]) ...)
+
+Version 0.28: October 3, 1995
+MzScheme bug fix: stack-checking on Unix
+wxMedia fix: Insert(unsigned char, ...) instead of Insert(char, ...)
+ and proper use of `unsigned' in word-breaking array access
+
+Version 0.27: September 29, 1995
+Major MzScheme upgrade, including multiple inheritance
+ (See MzScheme HISTORY for details)
+Win32: Allow deeper recursion by copying the stack
+Win32: Allow breaking with Shift-Ctl-C
+New font configuration system
+
+Version 0.26: September 8, 1995
+Very minor changes
+Bug fix to MzScheme for Win32s
+
+Version 0.25: September 7, 1995
+Upgraded to wxWindows 1.63
+Minor bug fixes
+
+Version 0.24: September 1, 1995
+Minor bug fixes
+
+Version 0.23: August 23, 1995
+Minor bug fixes
+Editor can display images (types depend on wxWindow compile flags)
+MzScheme correction: expand & expand-once
+
+Version 0.22: August 17, 1995
+Mostly MzScheme improvements
+File-format bug fixed related to portability; To make files created 
+  earlier portable, open and re-save them.
+
+Version 0.21: August 8, 1995
+Bug fixes
+triggers, hash tables, and case-lambda added to MzScheme
+MzScheme "sleeps" properly
+Connected MrEd to wxWindow's layout constraint system
+
+Version 0.20: July 26, 1995
+MzScheme Bug fixes
+
+Version 0.19: July 25, 1995
+All "!"s removed from method names!!!!!
+Full continuations and bignums added to MzScheme
+Bug Fixes
+
+Version 0.18: July 20, 1995
+Win32s kinda supported
+Bug fixes
+Added (compile ...) to MzScheme
+Added internal processes & threads to MzScheme
+wxSnipData -> wxBufferData
+Old process and system changed to process* and system*
+
+Version 0.17: July 11, 1995
+Bug fixes, especially Motif and memory bugs
+Rewrote editor line-maintenance
+Faster caret updating
+Upgraded garbage collector
+File format changed to accomodate nested buffers with
+  separate style lists
+Standard system standardized
+Code changes for compiling on MSWindows (almost works...)
+Scheme mode
+
+Version 0.16: June 16, 1995
+Fixed define-struct bug
+
+Version 0.15: June 15, 1995
+Bug fixes, especially XView
+make-input-port takes only 3 args; "unget" param dropped
+on-local-char & on-local-event renamed to on-default-char 
+  and on-default-event
+name changes: to have "!" or not to have "!". See doc/names.diff
+  for a list of changed names
+fonts configuarble through .Xdefaults; see MrEd.ad
+
+Version 0.14: June 9, 1995
+Bug fixes, including wxWindows widget table clash
+Scheme mode works
+error-handler changed to parameterizing function
+
+Version 0.13: June 5, 1995
+MzScheme replaced libscheme
+ctl-c breaks Scheme evaluation in MrEd
+libscheme/ changed to mzscheme/ - change your make.env!
+
+Version 0.12: June 1, 1995
+Bug fixes
+Revised object system: requires (inherit ...) declarations
+(pretty-print ...) installed
+
+Version 0.11: May 19, 1995
+Bug Fixes
+
+Version 0.10: May 19, 1995
+Bug fixes
+(match ...) installed
+
+Version 0.9: May 18, 1995
+wxMediaPasteboard
+
+Version 0.8: May 11, 1995
+Bug fixes
+
+Version 0.7: May 10, 1995
+mred:default-<x> changed to mred:<x> in system
+README in demo directory
+Lots of bug fixes
diff --git a/notes/mred/LICENSE b/notes/mred/LICENSE
new file mode 100644
index 0000000..e06bcc0
--- /dev/null
+++ b/notes/mred/LICENSE
@@ -0,0 +1,51 @@
+MrEd
+Copyright (c) 1995-96 PLT, Rice University
+
+MrEd is distributed under the GNU Library General Public License. This
+means that you can link to and use MrEd in any application (including
+commercial applications with private source code) but all derivatives
+of MrEd itself must be distributed with a license consistent with the
+GNU LGPL (i.e., the derivative and its source code must be freely
+distributed). See COPYING.LIB for more information.
+
+MrEd is based on:
+
+  wxWindows
+  Copyright (c) 1994 Artificial Intelligence Applications Institute,
+                     The University of Edinburgh
+  All rights reserved.
+
+and/or
+
+  wxWindows Xt
+  Copyright (c) 1994 Artificial Intelligence Applications Institute,
+                     The University of Edinburgh
+  Copyright (c) 1995 GNU (Markus Holzem)
+  All rights reserved.
+
+  Therefore, the "Xt" version of MrEd is under the GNU General Public 
+  License.
+
+and
+
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+and
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+
+and
+
+  Conservative garbage collector
+  Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+  Copyright (c) 1991-1994 by Xerox Corporation.  
+  All rights reserved.
+
+  C++ extension by Jesse Hull and John Ellis
+  Copyright (c) 1994 by Xerox Corporation.  
+  All rights reserved.
+
diff --git a/notes/mred/MrEd.ad b/notes/mred/MrEd.ad
new file mode 100644
index 0000000..d8dcde0
--- /dev/null
+++ b/notes/mred/MrEd.ad
@@ -0,0 +1,29 @@
+! MrEd resources:
+
+!  Font names
+mred.ScreenDefaultBase: *-courier
+mred.ScreenModernBase: misc-fixed
+mred.ScreenDecorativeBase: *-helvetica
+mred.ScreenScriptBase: *-charter
+mred.ScreenSwissBase: *-lucida
+mred.ScreenRomanBase: *-times
+
+!  Font size
+mred.defaultFontSize: 12
+
+!  Time between clicks for a double-click
+mred.doubleClickTime:   500
+
+!  Standard system's console (uncomment it to use)
+! *MrEdConsole.geometry: +40+40
+
+
+!  Indigo Magic look & feel
+! MrEd*useSchemes: all
+! MrEd*sgiMode: true
+! MrEd*schemeFileList: SgiSpec
+! MrEd*paletteFileList: FontPalette
+! MrEd*SgNuseEnhancedFSB: true
+
+!  SGI Style guide specifies pointer focus for applications
+! MrEd*keyboardFocusPolicy: pointer
diff --git a/notes/mred/fonts12.mre b/notes/mred/fonts12.mre
new file mode 100644
index 0000000..74e90a8
Binary files /dev/null and b/notes/mred/fonts12.mre differ
diff --git a/notes/mred/fontsall.mre b/notes/mred/fontsall.mre
new file mode 100644
index 0000000..7b00f0f
Binary files /dev/null and b/notes/mred/fontsall.mre differ
diff --git a/notes/mred/mred.fnt b/notes/mred/mred.fnt
new file mode 100644
index 0000000..674472a
--- /dev/null
+++ b/notes/mred/mred.fnt
@@ -0,0 +1,8 @@
+[mred]
+defaultFontSize=12
+ScreenDefault__=applicationfont
+ScreenRoman__=times
+ScreenDecorative__=geneva
+ScreenModern__=monaco
+ScreenSwiss__=helvetica
+ScreenScript__=geneva
diff --git a/notes/mred/mred.ini b/notes/mred/mred.ini
new file mode 100644
index 0000000..0dd9b5d
--- /dev/null
+++ b/notes/mred/mred.ini
@@ -0,0 +1,8 @@
+[mred]
+defaultFontSize=12
+ScreenDefault__=MS Sans Serif
+ScreenRoman__=Times New Roman
+ScreenDecorative__=
+ScreenModern__=Courier New
+ScreenSwiss__=Arial
+ScreenScript__=Script
diff --git a/notes/mred/mred.txt b/notes/mred/mred.txt
new file mode 100644
index 0000000..c958e82
--- /dev/null
+++ b/notes/mred/mred.txt
@@ -0,0 +1,408 @@
+
+
+About PLT MrEd
+
+
+
+Matthew Flatt
+mflatt@cs.rice.edu
+Rice University
+
+
+
+Version 50
+August 1997
+
+
+
+
+
+Copyright notice
+
+
+
+Copyright (c)1995-97 Matthew Flatt
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose is hereby granted without fee, provided
+that the above copyright notice, author statement and this permission
+notice appear in all copies of this software and related documentation.
+
+THE SOFTWARE IS PROVIDED ``AS-IS'' AND WITHOUT WARRANTY OF ANY KIND,
+EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+
+IN NO EVENT SHALL MATTHEW FLATT OR RICE UNIVERITY BE LIABLE FOR ANY
+SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY
+OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+wxWindows: Copyright (c)1994 Artificial Intelligence Applications
+Institute, The University of Edinburgh. All rights reserved.
+
+libscheme: Copyright (c)1994 Brent Benson. All rights reserved.
+
+Conservative garbage collector: Copyright (c)1988, 1989 Hans-J.
+Boehm, Alan J. Demers. Copyright (c)1991-1994 by Xerox Corporation.
+All rights reserved.
+
+Collector C++ extension by Jesse Hull and John Ellis: Copyright
+(c)1994 by Xerox Corporation. All rights reserved.
+
+
+
+
+
+Contents
+
+   * This Manual
+        * Thanks
+   * About MrEd
+        * What is MrEd?
+        * What is MrEd Used For?
+        * How was MrEd Developed?
+        * Comparisons to Other Systems
+        * Distribution
+        * More Information
+   * Compiling MrEd
+   * Running MrEd
+   * Index
+
+
+
+This Manual
+
+
+
+This manual explains what MrEd is and why MrEd might be useful. Complete
+information for MrEd is in PLT MrEd: Graphical Toolbox Manual
+../toolbox/index.htm.
+
+
+
+Thanks
+
+
+
+  Many thanks to Julian Smart for wxWindows and his help.
+Thanks also to Brent Benson for libscheme , and to Hans Boehm and John
+Ellis for the conservative garbage collector and their help. MrEd would
+not be possible without these fine packages.
+
+Thanks also to Robby Findler, Shriram Krishnamurthi, Cormac Flanagan,
+Matthias Felleisen, Gann Bierner, Richard Cobbe, Dan Grossman, Stephanie
+Weirich, Sebastian Good, Johnathan Franklin, Mark Krentel, Corky
+Cartwright, Michael Ernst, Kennis Koldewyn, Bruce Duba, and many others
+for feedback and help.
+
+Some basic typesetting sources for this manual are taken from Julian
+Smart's Reference Manual for wxWindows 1.60: a portable C++ GUI toolkit
+.
+
+
+
+About MrEd
+
+
+
+
+
+What is MrEd?
+
+
+
+ MrEd is a new architecture for developing portable graphical user
+interface (GUI) applications. MrEd provides the developer with a modern,
+high-level language supporting classes and objects, compilation units,
+execptions, pre-emptive threads, run-time safety, and automatic memory
+management. The language is integrated with an extensive, class-based
+GUI toolbox including frames, menus, controls, multimedia text editors,
+click-and-drag pasteboards, mulitple event spaces ("event loops"), and
+automatic geometry management.
+
+MrEd is based on Scheme (specifically,
+MzSchemehttp://www.cs.rice.edu/CS/PLT/packages /mzscheme) with a GUI
+toolbox that runs under X Windows, Microsoft Windows, and MacOS.
+Applications written using MrEd run on all three platforms without
+modification.
+
+MrEd is the graphical and compuational engine behind DrScheme, a new
+environment for developing and debugging Scheme applications. DrScheme
+will eventually provide a complete integrated evironment for developing
+MrEd applications.
+
+
+
+What is MrEd Used For?
+
+
+
+ MrEd is appropriate for developing any Scheme-based application
+which needs a graphic interface. MrEd is particularly useful when the
+graphic interface needs to be portable, when it needs sophisticated text
+or graphics manipulation, or when it needs threads or eventspaces
+(mulitple ``event loops''). MrEd is probably not appropriate for
+applications with tight memory constraints.
+
+MrEd can also be used as an editor. The system that MrEd uses to start
+up provides an Emacs-like editing environment. However, the vast body of
+Emacs packages has not been ported to MrEd; only Scheme mode and a
+hyper-text mode have been fully implemented. As code is written to
+extend the standard editor, new features can be inherited by all
+applications written in MrEd.
+
+
+
+How was MrEd Developed?
+
+
+
+ MrEd's core Scheme implementation is
+MzSchemehttp://www.cs.rice.edu/CS/PLT/packages /mzscheme, which was
+derived from Brent Benson's libscheme . MzScheme uses the conservative
+garbage collectorhttp://reality.sgi.com/employees/boehm_mti/gc.html from
+Hans Boehm et al.
+
+The GUI toolbox is derived from wxWindows
+http://web.ukonline.co.uk/julian.smart/wxwin/, version 1.66 (or so).
+MrEd's wxWindows has been debugged and developed along a largely
+divergent path since early 1996. While this is unfortunate in that MrEd
+and the wxWindows community can no longer collaborate on continued
+development, the divergence also means that MrEd's branch of wxWindows
+has stabilized.
+
+
+
+Comparisons to Other Systems
+
+
+
+    The GUI aspect of MrEd is much like Tcl/Tk
+or STk: both provide a toolbox of graphic objects with an interactive
+development language. MrEd's graphic object toolbox contains essentially
+the same elements as Tk. The basic difference is that MrEd provides a
+much richer ``operating system'' for developing large applications.
+
+ There are several all GUI development system that are comparable
+to MrEd in that they connect LISP or Scheme to an external GUI toolbox.
+These tools are typically not portable, and the GUI toolbox tends to be
+smaller or lower-level.
+
+A list of other GUI development systems is available at:
+http://www.cs.cmu.edu/afs/cs/user/bam/www/toolnames.html
+http://www.cs.cmu.edu/afs/cs/user/bam/www/toolnames.html
+
+ MrEd's editing system follows the Emacs model of extensibility:
+the editor is written in its own extension language. However, there are
+fundamental differences:
+   * In Emacs, the extension language is a dynamically-scoped dialect of
+     Lisp. Packages work in a global namespace. A single core editor is
+     extended through a standard set of functions and variables.
+   * In MrEd, the extension language is Scheme extended with an object
+     system, and the core editor is represented by a set of classes. The
+     editor can be extended Emacs-style by deriving new classes from the
+     editor class, but a package is not necessarily just an extension of
+     the editor. Rather, the core editor is available for use as a
+     submodule within a package's larger architecture. MrEd's editor
+system has the same potential for expansion as Emacs. Certainly, MrEd
+would be an ideal platform for a new full-functioned editor based on the
+Emacs model.
+
+
+
+Distribution
+
+
+
+  MrEd's source code can be freely distributed. Please read
+the license agreement, as well as the license agreements for wxWindows,
+libscheme, and the conservative garbage collector.
+
+The latest distribution for MrEd can be obtained from the MrEd Home
+Page: http://www.cs.rice.edu/CS/PLT/packages/mred/
+http://www.cs.rice.edu/CS/PLT/packages/mred/
+
+
+
+More Information
+
+
+
+   Up-to-date information about MrEd can be found at
+the MrEd Home Page: http://www.cs.rice.edu/CS/PLT/packages/mred/
+http://www.cs.rice.edu/CS/PLT/packages/mred/
+
+
+
+Compiling MrEd
+
+
+
+Compiled versions of MrEd are available from the MrEd Home Page (see
+section 2.6 , above). Some X Windows users will need to compile the code
+from scratch (because it is impossible for us to provide compiled
+executables for all platforms). Unfortunately, compiling MrEd is not a
+trivial task.
+
+  This section will describe how to compile MrEd for X
+Windows under Unix, which requires around 20-30 MB of disk space. First,
+download the following packages:
+   * wxWindows  -- Information about wxWindows is available from
+     http://web.ukonline.co.uk/julian.smart/wxwin/
+     http://web.ukonline.co.uk/julian.smart/wxwin/ but to compile MrEd,
+     special patched versions of wxWindows must be obtained from
+     http://www.cs.rice.edu/CS/PLT/packages/mred/
+     http://www.cs.rice.edu/CS/PLT/packages/mred/ MrEd works with two
+     flavors of wxWindows: Motif and ``Xt''. MrEd works with these
+     flavors about equally well. Most every X Windows installation can
+     support the ``Xt'' version, while Motif must be purchased.
+   * MrEd -- MrEd can be found at
+     http://www.cs.rice.edu/CS/PLT/packages/mred/
+     http://www.cs.rice.edu/CS/PLT/packages/mred/ This distribution
+     includes MzScheme and the conservative garbage collector.
+
+Set the WXDIR environment variable to the path of the wxWindows
+installation. All the directories from the wxWindows installation should
+be in the WXDIR directory.
+
+In wxWindows's src/make.env , some of the variables may need to be
+changed:
+   * Set OPTIONS:
+        * Add -DWXME_FOR_MRED=1.
+        * Add -DWX_NORMALIZED_PS_FONTS=1 (Motif only)
+        * Add -DWXME_LSB_FIRST=1 if the target machine represents
+          integers with the least-significant byte in the lowest memory
+          address. For example, this flag is needed for Intel machines,
+          but not Sparc machines. MrEd will display a warning at startup
+          if the flag value is incorrectly chosen.
+        * Add -DOPERATOR_NEW_ARRAY if the C++ compiler uses separate new
+          and new[] operators. For example, this flag is needed for gcc
+          version 2.6.3, but not for version 2.5.8.
+        * Add -DWXS_CANT_ASSIGN_STRUCTURES if the C++ compiler does not
+          allow an assignment to copy structures. A compile-time error
+          will occur if the flag is needed but not provided.
+   * Add three paths to COMPPATHS in make.env: -I gc-directory , -I
+     wxme-directory , and -I mzscheme-include-directory .
+        * The gc-directory path lets the wxWindows compilation find the
+          garbage collector header files. This directory is in the MrEd
+          distribution as mred/mzscheme/gc .
+        * The wxme-directory path lets MrEd find the wxme header files.
+          This directory in the MrEd distribution as mred/wxme .
+        * The mzscheme-include-directory lets MrEd find the MzScheme
+          headers. This directory in the MrEd distribution as
+          mred/mzscheme/include .
+   * Probably, XLIB and/or XINCLUDE must be adjusted.
+   * Possibly, other flags must be changed for your local configuration.
+
+If you're unlucky, you'll also have to adjust the flags for compiling
+MzScheme. These are in mred/mzscheme/Makefile and in
+mred/mzscheme/sconfig.h . (A description for each flag is included
+there.) Try compiling with the default flags unless there is a problem.
+
+Once all of the setup files are ready, go to the main MrEd distribution
+directory. Execute gnumake wx to compile wxWindows. After wxWindows has
+compiled, use gnumake to compile MrEd. (You must use gnumake to compile
+MrEd; the standard make will not work. Note, however, that make may
+actually be gnumake on your system, as on Linux.)
+
+Here are a few compiling hints:
+   * Turn off the debugging flags in ``make.env''. This will make the
+     object files and executable much smaller.
+   * There may be a lot of `void * operator new (...)' defined but not
+     used warnings from the compiler. Ignore them.
+
+
+
+Running MrEd
+
+
+
+Complete information about running MrEd is in PLT MrEd: Graphical
+Toolbox Manual ../toolbox/index.htm, but this chapter provides a quick
+overview of how to run MrEd.
+
+At run-time, MrEd needs to find three directories: the system directory,
+the MrEd system library collection directory, and the MzLib collection
+directory. The system directory is named system ; it should be in the
+same directory as the MrEd executable. The system library directory is
+named mred , inside a collects sub-directory in the same directory as
+the executable. Finally, the MzLib directory is named standard ; this
+directory must be in a collects sub-directory that can be in either of
+two places:
+   * in a mzscheme directory that is in the same directory as MrEd's
+     executeable (this is what you get after compiling MrEd)
+   * in a mzscheme directory that is in the same directory as MrEd's
+     directory (this is how the PLT distribution is configured)
+
+The search path for MzLib is actually defined in terms of the location
+of system . See PLT MrEd: Graphical Toolbox Manual ../toolbox/index.htm
+for more information.
+
+When you run MrEd, the window that appears is a console that provides a
+Scheme read-eval-print loop. To evaluate an expression, type it after
+the prompt and hit return. You can re-evaluate old expressions by moving
+the caret to the end of the expression and hitting return (or by using
+Meta-P from the current prompt). Evaluate a subexpression by hiliting it
+and hitting return. To stop evaluation, type Ctl-C (Unix and Windows) or
+Cmd-. (MacOS). 
+
+To open a standard text-editing window from the console, use the ``New''
+or ``Open...'' items in the ``File'' menu.
+
+To run a few simple demo programs, use the ``Load Scheme File'' menu
+item and select ``demo.ss'' in the distribution's ``demo'' directory
+(with MrEd).
+
+When MrEd starts up, it looks for a ``.mredrc'' file in the user's home
+directory (``mredrc.ss'' under Windows). If such a file exists, it is
+loaded (as a Scheme file) before the console is opened. Preferences
+about the appearance and behaviour of MrEd can be set using the
+``Preferences...'' menu item in the console's ``Edit'' menu.
+
+
+
+
+
+Index
+
+
+
+breaking
+     Running MrEd
+comparisons to other systems
+     Comparisons to Other Systems
+compiling
+     Compiling MrEd
+distribution
+     Distribution
+EmacsComparisons to Other Systems
+how? How was MrEd Developed?
+information
+     More Information
+pain and agony
+     Compiling MrEd
+STk  Comparisons to Other Systems
+Tcl  Comparisons to Other Systems
+thanks
+     Thanks
+Tk   Comparisons to Other Systems
+what?What is MrEd?
+when?What is MrEd Used
+where?
+     More Information
+who? Thanks
+why? 
+     
+     because we like you
+          Distribution
+     
+Winterp
+     Comparisons to Other Systems
+WWW  More Information
+wxWindows
+     Compiling MrEd
+-----------------------------------------------------------------------
+
+x
diff --git a/notes/mred/openbugs b/notes/mred/openbugs
new file mode 100644
index 0000000..35c7b50
--- /dev/null
+++ b/notes/mred/openbugs
@@ -0,0 +1,77 @@
+
+* Command events: doc fields that are used by checked?, etc.
+
+* X Windows and drawing into b & w bitmaps: black and white
+  are reversed when using certain kinds of displays
+
+* wx:dc%'s draw-arc is undefined when input isn't
+  consistent with a circle
+
+* wx:key-event% needs a set-position method
+
+* Windows: set-user-scale with wx:memory-dc% doesn't work right
+
+* MacOS: busy-cursor state is wrong for new windows when the
+   busy cursor is active
+
+* pasteboards: printing not yet implemented
+
+* need to penalize the current thread more for certain primitive
+   operations that can take a long time (e.g., loading a bitmap
+   or saving a file)
+
+* need range check for dc transfer modes
+
+* need directory-selection dialog
+
+* cursor does not change over clickbacks in embedded buffers
+
+* Keys like KP_end, etc. are not currently accessible
+
+* doc: [Mr] clarify "owning the caret" with respect to ownership by the parent, etc.
+
+* doc: [Mr] "only valid when displayed": hyper-link to explanation.
+
+* Motif: get-file dialog modality is wrong for eventspaces
+
+* Windows and MacOS: "primitive" dialogs don't get closed by
+   custodian-shutdown-all
+
+* MacOS: std file dialog and print dialogs block MzScheme threads
+
+* cut-n-paste within mred but across eventspaces breaks security and
+  filesaving because snip class list is eventspace-specific
+
+* how does wx:dc% get-size interact with the user scale?
+
+* the full width for non-wrapped lines need not include the autowrap bitmap
+
+* should use a guranteed offset for stippling in buffer redraws
+
+* Xt: out-of-colours - widgets use too much black
+
+* signature include: unbalanced parens => diverge?
+
+* drag outisde view => should keep going even if mouse is still
+
+* hidden files - add a MzScheme predicate?
+
+* dragging selection shouldn't keep changing the auto-X-selection
+
+* Xt: busy cursor not shown in the menu bar
+
+* editor buffers should show a blinking caret
+
+* Motif: menus don't work with multiple displays
+
+* Motif: wxDialogBox doesn't obey current display for multiple displays
+
+* add background colour for buffers?
+
+* updating bug?: long flash, not on same line, update on focus-in
+
+* add paragraph styles?
+
+* need better de-fragmentation of text snips
+
+* need to show a mystery snip icon when unknown data is loaded from a file
diff --git a/notes/mzscheme/COPYING.LIB b/notes/mzscheme/COPYING.LIB
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/notes/mzscheme/COPYING.LIB
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/notes/mzscheme/HISTORY b/notes/mzscheme/HISTORY
new file mode 100644
index 0000000..5d5a890
--- /dev/null
+++ b/notes/mzscheme/HISTORY
@@ -0,0 +1,453 @@
+Version 51, ??, 1997
+Changed load/use-compiled: searches for .zo files in
+  a "compiled/" subdirectory, and searches for .so/.dll
+  files in (build-path "compiled" (system-library-subpath))
+Changed load and current-load/default-load-handler: `load'
+  now sets the current-load-relative-directory, so a load
+  handler does not need to set this parameter
+Added current-load-extension (load-extension handler)
+Added read-image-from-file procedure
+Unix images: removed constraint against using stdio before
+ dumps
+Unix: fixed file-or-directory-permissions for group-based 
+ permissions when the group is not the current group (but
+ still includes the user)
+Windows: fixed directory-exists? et. al for UNC paths
+Added local-expand-body-expression
+Added link-exists?
+Added copy-file
+Added path-list-string->path-list
+Added collection-path
+Changed initial setting of current-library-collection-paths
+Changed display for symbols containg special characters:
+ the special characters are not escaped (or bar-quoted)
+Changed write to use the value of (read-accept-bar-quote)
+ for printing symbols containing special charaters; if
+ bar qute reading is off, it is turned off for printing, too.
+Fixed unit/sig: correctly handles syntax where defintions in 
+ the unit shadow syntactic forms
+Fixed round of exact rational n/d in the case when (odd? d)
+ and (= (remainder n d) (quotient d 2))
+Extended exp, sin, cos, tan, log, asin, acons, atan to
+ complex numbers; changed sqrt to choose the root with a
+ positive real part
+Removed rectangular <, >, <=, >= for complex numbers
+Changed storage of loaded-library table from built into the
+ `require-library' procedure to built into the current
+ namespace
+Added require-relative-library
+Fixed error messages for +, -, etc. to show all arguments
+Changed MzLib's pconver.ss libraries; the print-convert-hook@
+ unit was removed (along with the pchookr.ss library) and
+ replaced with parameters defined in pconverr.ss for similar
+ (more powerful) hooks.
+Fixed interfaces for compiled-file (.zo) loading across
+ MzScheme startups
+Unused interned symbols are now garbage-collected
+Added support for single-precision floating points (turned
+ off in default compilation)
+Changed read-eval-print-loop, removing its cooperation with
+ the default error escape handler; instead, it installs its
+ own error escape handler
+Improved the support for dynamic extensions that gives an 
+ error if an extension is already loaded, or calls a
+ reloading function provided by the extension
+
+Version 50, August 26, 1997
+Added compile-time inferrence of names for closures, classes,
+  and units to improve error messages
+Added inferred-name
+Added file-size
+Added write-image-to-file for creating heap images of a
+  MzScheme program
+Fixed reader to disallow . in vectors: #(1 . 2) or #(1 . (3))
+Removed global-defined-signature
+Fixed string->number: explicit radix in string can override
+  radix argument
+Bug fixed in call/cc related to dynamic-wind (see !!! in 
+  tests/basic.ss)
+Fixed weak hash table's accumulation of hashing buckets
+Added 'empty flag for make-namespace
+Added two-argument form for global-defined-value
+Added system-library-subpath
+Changed standalone mzscheme to return -1 if a loaded file
+  or evaluated expression returns an error without the rep
+Refined error messages
+
+Version 49, May 31, 1997 
+Multiple superclass inheritance is no longer supported
+Added (Java-ish) interfaces to object system
+class* syntax changed to accomodate interfaces and removed
+  multiple superclasses
+uq-ivar always takes two arguments; class is not a legal argument
+uq-make-generic accepts a class or an interface
+Object system exceptions changed
+Added custodian system
+Embedded define conventions changed: "regular" defines are only
+  allowed in begin expressions and the branches of an if;
+  embedded defines can appear in a begin0 expression, but not
+  in the first position; defines must all appear at the beginning
+  of the block
+Contents of a begin expression as an immediate unit or unit/sig 
+  expression are promoted to immediate expressions
+case supports only R4RS syntax; a single non-list "datum" is
+  no longer allowed
+Removed catch; use let/ec instead
+Removed vector-append
+Removed load-with-cd (use load/cd)
+Added load/use-compiled
+Added current-load-directory parameter (set by the default load
+ handler while loading a file) and load-relative (uses the
+ parameter for loading a relative filename)
+unit/sig's include form is like load-relative instead of load/cd
+require-library uses load or load/use-compiled instead of load/cd
+Windows: expand-path does not put a drive on a driveless path
+  anymore; use path->complete-path instead
+compile-file moved out of MzScheme into MzLib "compile.ss"; now 
+  takes a single flag list argument instead of two final Booleans
+current-base-parameterization parameter replaced with 
+  parameterization-branch-handler parameter
+Parameterizations support sharing (in addition to defaulting);
+  see docs for make-parameterization-with-sharing
+Added print, port print handlers, and a global port print handler
+Changed the default print handler to use print instead of write
+Fixed bug in ports returned by make-pipe
+Fixed bug in dynamic-wind; continuation jumps into the pre-thunk
+  had a non-intuitive semantics; the correct semantics is now 
+  implemented and documented (also for jumps with the post-thunk)
+Changed time-apply to always return a list as its first return
+  value; time form can return multiple values for its expressions
+format, fprintf, and printf are case-insensitive for ~ directives;
+  added ~v, ~e, ~<whitespace>
+Added semaphore-wait/enable-break
+Added thread-running? and thread-wait
+Fixed bug in threads and timed sleeping
+Fixed bug in breaking a blocked thread
+Fixed bug in continuations returning multiple values through a
+  dynamic-wind (multiple return values could be corrupted)
+Fixed arity reporting for continuations
+Fixed Windows system* and read from console stdin and process*
+  ports: MzScheme threads no longer blocked; ctl-c breaking works
+  in stand-alone console MzScheme
+process and process* now return a list of 5 values (instead of 4)
+map, for-each, andmap, and ormap raise exn:application:map-arity
+ when the procedure's arity does not match the number of supplied
+ lists; note that (map (lambda () 10) null) now signals an error
+list-ref and list-tail accept arbitrarily large indices
+Type for indices changed: must be an exact integer (matches R4RS better)
+  affects make-vector, vector-ref, vector-set!, make-string, string-ref, 
+  string-set!, substring, and struct-ref
+make-namespace's '[no-]set!-undefined and '[no-]auto-else flags
+  removed; replaced with two new parameters: 
+  compile-allow-set!-undefined and compile-allow-cond-fallthrough
+Fixed in units: (define x y) (define y 0) x => #<undefined> instead of 
+  #<void>
+exn:struct's super-type field renamed struct-type for consistency
+exn:i/o:filesystem:filename split into exn:i/o:filesystem:path
+  and exn:i/o:filesystem:file; username exception moved under path
+Unix: system no longer blocks other MzScheme threads
+Unix: processes created by process and process* are not zombies forever, 
+  anymore. (The SIGCHLD signal is handled appropriately.)
+MacOS: dynamic extension suopport via CFM (PPC only in the distributed
+  applications from PLT)
+Windows: removed attempted fix for thread-blocking problem 
+  when reading stdin from console
+Fixed auto-flush of stdout for read of stdin
+Fixed <, >, <=, >= for certain exact rational number comparisons
+Fixed inexact->exact for negative inexact numbers (fractional part
+  was added to the resulting number with the wrong sign)
+Fixed rational? to answer #t for inexact numbers
+Fixed odd?, even?, and trig functions for +inf.0 and -inf.0
+Fixed handling of +nan.0 by many math routines; fixed +nan.0 for
+  everything under Windows
+Added R4RS rationalize
+compound-unit/sig export var clause syntax now matches documentation
+Added require-library-use-zo
+Moved cons? and last-pair into functio.ss instead of compat.ss
+Library system generalized to supoprt multiple collections;
+  current-library-path replaced with current-library-collection-path
+require-library now returns the result of the loaded library
+Removed load-recent from MzLib's file.ss; use load/use-compiled
+  instead
+Added reference-library, "refer.ss" [core], "XXXr.ss" MzLib libraries
+Added build-string, build-vector, build-list, loop-until to MzLib's 
+  functio.ss
+Added thread.ss MzLib library [core]
+Added inflate.ss MzLib library
+Moved synrule.ss out of core
+Fixed MzLib's stringu.ss to not use macro.ss
+Updated MzLib's spidey.ss, added it to core
+Removed define-some, define-virtual-struct, define-struct-tree from
+  MzLib's macro.ss
+begin-expansion-time returns the value of the last expression
+set-thread-weight! replaced with 2-argument thread-weight
+Inside MzScheme: changed class/object toolbox, added custodian
+  toolbox
+Upgraded to gc 11
+
+Version 48: Skipped to avoid confusion with Scheme48
+
+Version 47, January 11, 1997
+WARNING: multiple inhertance is going away in the next version or so
+Added will executors
+pretty-print-print-hook and pretty-print-size-hook now take
+ three arguments: value display? port
+file-position can return the current position for any port
+Fixed errors reading floating-point constants due to system
+ library bugs:
+   Linux: strtod("0e...", ...) quits looking after "0"
+   SunOS/Solaris: strtod(".3e2666666666") returned 0.0
+   HP/UX: strtod(".3e2666666666") fails
+Windows: fixed thread-blocking problem for reading stdin from console
+Insize MzScheme: when working with "fd_set" values, use
+  MZ_FD_ZERO, MZ_FD_SET, MZ_FD_CLR, MZ_FD_ISSET; use 
+  scheme_get_fdset() to get the second or third fd_set in an array;
+  routines for thread-blocking are now documented in "Inside MzScheme"
+
+Version 46, December 5, 1996
+unit/sig macros moved out of MzLib and into core MzScheme; 
+  (require-library "unitsig.ss") is obsolete, but still supported
+  as a no-op
+Unit signature matching is now position-independent, and the error
+  messages are better
+Removed obsolete install-unit-with-signature
+(begin) or (begin0) is now a syntax error
+Changed class* syntax so that an explicit name for `this' is provided
+MzLib's class-asi* changed to class*-asi, while adding new `this' id
+Prettier(?) printing for prims like >: #<|primitive:>|>
+invoke-open-unit w/o path/prefix is now the same as #f instead of ();
+  the path form will probably be phased out in a future release
+quasiquote syntax changed slightly
+stdout/stderr are not auto-flushed for read-char or peek-char on stdin
+ (still flushed by read and read-line)
+Added port-display-handler and port-write-handler
+
+Version 45, November 12, 1996
+Multiple return values are agressively supported
+IMPORTANT: let-values is now analogous to let; the old 
+  let-values is now let*-values
+let-values, letrec-values, define-values, and begin0 are primitive
+define-struct and let-struct expand to new struct form
+Added thread-savy parameterization system; namespace system changed
+pipe changed to make-pipe, returns 2 values
+Case-sensitivity for the reader is a settable parameter
+Reading [] and {} as parens is a settable parameter
+class* syntax extended to allow local renaming of public ivars
+delay/force support multiple values
+else and => in cond and else are now "scoped"
+normalize-path from MzLib signals an error for bad paths
+Windows: build-path can join a drive to a (driveless) absolute path
+  and //machine/disk drive names are supported; also fixed 
+  file-system-root-list
+Added complete-path? and current-drive (for Windows)
+Fixed (begin (values ...) ...) and (begin0 (values ...) ...)
+Fixed comparisons between inexact and exact when the
+  exact to inexact conversion results in overflow or underflow,
+  and fixed (exact->inexact (/ X Y)) and (/ +inf.0 X), etc. when 
+  X & Y are larger than the largest floating-point, fixed modulo,
+  remainder, quotient for infinities
+Fixed TCP problems (Unix, Windows) and implemented for MacOS
+Fixed dynamic-loading to always search from current directory
+Fixed real process idling for a timed sleep
+Fixed file read/write exceptions (write exceptions now raised)
+Fixed quasiquote bug with ,@ and unquoting depth
+Fixed filesystem-root-list for Windows
+Fixed dynamic-wind when a continuation is invoked from the post-thunk
+Fixed continuations for re-entry of a continuation that is mulitply-invoked
+Fixed string->number with leading spaces; e.g., (string->number " 1") 
+invoke-unit import variable restriction removed (locals are allowed)
+(case-lambda) is now legal
+\ escapes & and \ in regexp-replace replacement string
+Added regexp-replace*
+Added port-read-handler
+Inside MzScheme: Changed use of scheme_sleep
+Inside MzScheme: Changed primitive unit init func arguments
+Inside MzScheme: Changed primitive accessing of unit boxes and environment boxes
+Inside MzScheme: Revoked syntax extensibility
+Reimplemented the core interpreter (chained closures -> flattened)
+
+Version 44, September 9, 1996
+load, load/cd return value of last loaded expression
+scheme_load returns Scheme_Object* or NULL
+Built-in TCP support (Not MacOS, yet)
+unit clauses macro-expanded before checking `define' keywords
+Better dynamic extension handling and compilation support
+Fixed read blocking threads in FreeBSD
+Extensions' scheme_initialize must return Scheme_Object*
+scheme_sleep has internal default for basic sleeping, installed by
+ scheme_basic_env if scheme_sleep is still NULL
+Unix/Winsock: fds arg for needs_wakeup and scheme_sleep expanded 
+ for writes and exceptions
+Fixed quotient for inexact numbers
+Fixed bug comparing a bignum rational with a fixnum rational
+Fixed startup crash when PATH env variable is slightly bad
+Sped up thread switching for Mac
+Sped up thread switching for most Unix for a small number of threads
+Upgraded to gc 11alpha3
+
+Version 43 re-released August 12, 1996 with libguile
+
+Version 43, August 9, 1996
+"functor" -> "unit"
+signed units added to and used by mzlib (sigfunctors gone)
+Made .zo files smaller and faster to load
+Use 64-bit fixnums for Alpha
+system, system*, process*, and execute* supported for Windows
+Fixed memory bug in printing hexadecimal
+Fix bug in modulo
+Better floating-point control for infinity, nan results
+ on many platforms
+
+Version 42: June 8, 1996
+Functor system added
+Fixed (cond (1)), etc.
+Fixed type-checking for numerical comparisons; e.g., (< 2 1 'a)
+Fixed dynamic-wind and call/ec for values
+Fixed read for strings containing #\nul
+Non-matching cond/case raises an error
+Made string=?, char=?, etc. multi-arity like numerical =, etc.
+Changed definition of time-apply (returns values, now)
+MzScheme threads can almost be real OS threads under Solaris, but more work
+  is needed to guarantee safety for the symbol table and globals. More thread 
+  systems to follow.
+spawn-eval replaced by make-eval
+thread-input-port, thread-output-port, and thread-error-port removed
+binary-and, etc. replaced with 2's complement bitwise-and, etc.
+Fixed writing compiled quoted graph expressions
+Fixed return value of system
+test.scm expanded and broken into multiple files: (load/cd "tests/all.ss")
+
+Version 0.41: April 15, 1996
+Revised class syntax; see the manual
+Exception system added; primitive errors raise exceptions
+defmacro replaced by define-macro
+Added define-id-macro
+Fixed let-macro shadowing local vars
+Improved error messages; error-print-width
+Fixed stack checking for Win32
+'. no longer allowed
+unquote and unquote-splicing now defined at top level
+equal? supports boxes
+
+Version 0.40: March 24, 1996
+structure:X => struct:x
+mzlib path uses MZLIB or PLTHOME environment variables
+
+Version 0.39: March 6, 1996
+Fixed expand-defmacro for (lambda () (and)) et al.
+Fixed sqrt on complex numbers; coefficients were reversed
+Cleaned up read and display/write to handle C stack overflow
+Arity checking bug fixed for arity 0
+Pretty-print is parameterized by depth
+
+Version 0.38: February 22, 1996
+Fixed bug in compiling frame-sharing; e.g.,
+  (let ([d 0]) ((car (cons (let ([a 4]) (lambda () a)) 
+			   (let ([b 7]) b)))))
+ returned 7 instead of 4
+Fixed bug in closing port by call-with-input-file
+Fixed magnitude on negative reals
+Fixed angle on negative reals
+Fixed cos, sin, etc. on rationals
+Fixed min and max on rationals with non-rationals
+Fixed (random 0)
+Fixed equal? on really long lists
+Fixed list procedures with arbitrary duration: checking for break
+Fixed char-X? and characters past ASCII 127
+Fixed hash table bug that causes infinite internal loop
+Fixed bug in reading #| |# comments at the end of a list
+Filesystem utilities added
+"processes" are now called "threads"; procedure names changed accordingly
+eval can return multiple values; r-e-p-l handles correctly
+Some changes to compilation interface:
+  must set new flag is_proc_closure in compile_info rec
+  scheme_static_distance changed; use flags
+scheme_sleep() must now take a float
+current-prompt-read added
+Console version reads ~/.mzschemerc init file (or mzscheme.rc)
+NO_STAT compilation flag -> NO_STAT_PROC
+
+Version 0.37: unreleased
+
+Version 0.36: January 18, 1996
+Fixed bug in bignum multiplication
+
+Version 0.35: January 17, 1996
+current-print added
+x@y notation supported
+~ expanded in pathnames (Unix)
+Fixed bug parsing #T, etc.
+Fixed bug parsing hex numbers and others
+Fixed fp-initialization bug for Win32
+Better printing for special symbols
+
+Version 0.34: December 30, 1995
+Various bignum operations sped up
+Chez-style symbol parsing supported (escaping \ and quoting |)
+
+Version 0.33: December 21, 1995
+rationals and complex numbers supported
+make-class and make-class* syntax changed (one set of parens
+  added). The old syntax is still supported for now, but you
+  should convert. The old syntax will eventualy go away (and
+  Zodiac will never be compatible with it).
+class variables and cvar no longer allowed
+ivar always takes an object; if class included, must be first
+threads/processes changed w.r.t. environment used during execution
+error handler split into erro displayer and error escaper
+stack limitation of expander/compiler removed
+expand => expand-defmacro
+expand-once => expand-defmacro-once
+user-break-poll => user-break-poll-handler
+enable-break => break-enabled
+#% now legal for starting non-keyword symbols
+full floating-point input format supported
+
+Version 0.32: December 4, 1995
+Added weak boxes
++inf.0, -inf.0, -nan.0, +nan.0 constants added
+Better checking when using floats as indices (vector-ref, etc.)
+Better (correct!) hashing procedure
+Fixed threads in Win32s/WinNT by creating a new stack
+Fixed bug in spawning new (MzScheme) processes
+Fixed incorrect process progress (~deadlock) analysis
+Fixed bug in resizing hash table
+Fixed bug in read (reading "+", "-", or "." at EOF)
+Fixed bug in read-number (fractions and forcing; e.g. "../")
+Fixed bug in open-output-string (> 100 chars gave empty result)
+Fixed regexp-replace (memory bug)
+
+Version 0.31: November 14, 1995
+Bignum bigs: subtracting from 0, comparing negative
+(current-eval) initially returned the wrong procedure
+tan procedure added
+putenv
+S-expression graph reading and printing
+
+Version 0.30: October 25, 1995
+Added call-with-values and regexp
+Unix stack-checking setup code fixed
+
+Version 0.29: October 18, 1995
+Added `arity' procedure
+Bug fix related to forms such as (let ([x (let ...)]) ...)
+
+Verion 0.28: October 3, 1995
+Fixed general stack overflow-checking for Unix
+
+Verion 0.27: September 26, 1995
+Moved compilation flags from the Makefile into "sconfig.h"
+More general stack overflow-checking (when needed)
+Computations can overflow the stack and continue
+Changed command line flags; added -r (or --script) flag
+Added multiple inheritance and `rename', `share', and `local' declarations
+Merged Patrick Barta's Windows DLL implementation for `load-extention'
+Re-implemented `quasiquote', `and', and `or' as a macros
+Re-implemented let-forms to make small `let's efficient
+`let*' expands to `let'
+Made core syntactic form names keywords
+Added #% keywords
+Added `hash-table-map' and `hash-table-for-each'
+Fixed bignum bugs: `eqv?'/`equal?' and `modulo'
+Fixed inexact bugs: `floor', `ceiling', and `round'
+Created this "HISTORY" file
diff --git a/notes/mzscheme/README b/notes/mzscheme/README
new file mode 100644
index 0000000..7bd15ff
--- /dev/null
+++ b/notes/mzscheme/README
@@ -0,0 +1,37 @@
+MzScheme (pronounced "Ms. Scheme") is an implementation of R4RS Scheme
+extended with an object system and time-preempted threads.  It uses
+libscheme 0.5's interface for embedding and/or extending the core
+interpreter with other C/C++ programs. MzScheme's virtual machine,
+implemented in C, is easily ported to any platform with 32-bit or
+64-bit addresses. MzScheme is used in MrEd, an engine for portable GUI
+applications.
+
+Please see the file LICENSE for license information.
+
+Documentation and up-to-date information about MzScheme are at
+ http://www.cs.rice.edu/CS/PLT/packages/mzscheme/
+
+If you are compiling MzScheme, see the INSTALL file for compilation
+instructions. 
+
+If you have a compiled MzScheme, then the `mzlib' directory should be
+in a `collects' directory that is in the same directory as the
+`mzscheme' executable. If you use the PLT directory configuration,
+then `plt/.bin/PLATFORM/' (where PLATFORM is a tag indicating your
+platform, as returned by `plt/bin/archsys') should contain the binary
+and `plt/collects' should contain `mzlib'.
+
+See SCRIPTS for information about writing MzScheme scripts for Unix
+platforms.
+
+Comments and bug reports are welcome. 
+Please report bugs using
+  http://www.cs.rice.edu/CS/PLT/Bugs/
+or (as a last resort) send mail to
+  plt-bugs@cs.rice.edu
+
+-Matthew Flatt
+ Rice University PLT
+ mflatt@cs.rice.edu
+ http://www.cs.rice.edu/~mflatt/
+
diff --git a/notes/mzscheme/SCRIPTS b/notes/mzscheme/SCRIPTS
new file mode 100644
index 0000000..378115b
--- /dev/null
+++ b/notes/mzscheme/SCRIPTS
@@ -0,0 +1,40 @@
+When MzScheme is installed as part of the standard Unix PLT
+distribution, the executable ${PLTHOME}/bin/mzscheme is actually a
+script that selects an executable based on the current platform. This
+is done to support multiple platforms in a single PLT installation.
+
+Unfortunately, this causes problems for writing scripts that use
+MzScheme, because the shell's #! convention requires that a binary is
+specified.
+
+Fortunately, there is a sneaky workaround. To write a MzScheme script,
+use the following at the top of your script:
+
+  #!/bin/sh
+  string=? ; exec ${PLTHOME}/bin/mzscheme -r $0 $0 ${1+"$@"}
+
+  ... <scheme program> ...
+
+(It may be better to hardwire the path to mzscheme instead of using
+${PLTHOME}.)
+
+Within <scheme program>, (vector-ref argv 0) is the name of the
+script; arguments passed to the script start at (vector-ref argv 1).
+
+How does this work? "#!/bin/sh" causes the shell to run /bin/sh on the
+file. The first command, "string=?" is a harmless assignment, and ";"
+separates this assignment from the "exec" command. The "exec" command
+replaces /bin/sh with mzscheme (so /bin/sh does not see the actual
+Scheme program). The "-r" flag tells mzscheme to load the next
+argument as a script and forces the remaining arguments into
+`argv'. (For information on ${1+"$@"}, consult your `sh' man page.)
+Thus, mzscheme will start up and load this file. As always, mzscheme
+ignores "#!" in the first line of a loaded file as a comment. And
+"string=?" is again a harmless expression (since it's a built-in
+variable). The ";" starts a Scheme comment, so the "exec" expression
+is ignored. Finally, mzscheme continues to load the file and evaluates
+the real Scheme program.
+
+Thanks to J. P. Lewis <zilla@interval.com> for the basic idea behind
+this trick. Many others have suggested alternatives to `string=?'
+for shells other than /bin/sh.
diff --git a/notes/mzscheme/mzscheme.init b/notes/mzscheme/mzscheme.init
new file mode 100644
index 0000000..27eeb4a
--- /dev/null
+++ b/notes/mzscheme/mzscheme.init
@@ -0,0 +1,304 @@
+;"Template.scm" configuration template of *features* for Scheme	-*-scheme-*-
+; Copyright (C) 1991, 1992, 1993 Aubrey Jaffer.
+
+; Compatibility file for MzScheme --
+;   http://www.cs.rice.edu/CS/PLT/packages/mzscheme/
+; -- and DrScheme --
+;   http://www.cs.rice.edu/CS/PLT/packages/drscheme/
+; -- produced by Shriram Krishnamurthi <shriram@cs.rice.edu>,
+; Mon Feb 10 12:03:53 CST 1997
+;
+; To configure for DrScheme instead of MzScheme, delete the
+;   (require-library "pretty.ss")
+; below, then follow remaining instructions.
+
+(require-library "pretty.ss")
+
+; Set appropriate values for
+; 1. default-software-type
+; 2. implementation-vicinity
+; 3. library-vicinity
+; 
+; There are two system dependencies:
+; a. current-time is bound to a platform-dependent function, so it 
+;    may not work on non-Unix (or even all Unix) systems.
+; b. most-positive-fixnum is bound to a 32-bit-specific value.
+;
+; Nothing else should require changing.
+;
+; If you have problems or comments, please use the above email address.
+; Do NOT contact Aubrey Jaffer with problems in this file!
+
+; Now, for the rest of the spiel ...
+
+;Permission to copy this software, to redistribute it, and to use it
+;for any purpose is granted, subject to the following restrictions and
+;understandings.
+;
+;1.  Any copy made of this software must include this copyright notice
+;in full.
+;
+;2.  I have made no warrantee or representation that the operation of
+;this software will be error-free, and I am under no obligation to
+;provide any services, by way of maintenance, update, or otherwise.
+;
+;3.  In conjunction with products arising from the use of this
+;material, there shall be no use of my name in any advertising,
+;promotional, or sales literature without prior written consent in
+;each case.
+
+;;; (software-type) should be set to the generic operating system type.
+;;; UNIX, VMS, MACOS, AMIGA and MS-DOS are supported.
+
+(define (software-type) 'UNIX)
+
+;;; (scheme-implementation-type) should return the name of the scheme
+;;; implementation loading this file.
+
+(define (scheme-implementation-type) '|MzScheme|)
+
+;;; (scheme-implementation-version) should return a string describing
+;;; the version the scheme implementation loading this file.
+
+(define scheme-implementation-version version)
+
+;;; (implementation-vicinity) should be defined to be the pathname of
+;;; the directory where any auxillary files to your Scheme
+;;; implementation reside.
+
+(define (implementation-vicinity)
+  (case (software-type)
+    ((UNIX)     (or (getenv "PLTHOME")
+		  "/usr/local/lib/plt"))
+    ((VMS)	"scheme$src:")
+    ((MS-DOS)	"C:\\scheme\\")))
+
+;;; (library-vicinity) should be defined to be the pathname of the
+;;; directory where files of Scheme library functions reside.
+
+(define library-vicinity
+  (let ((library-path
+	 (or
+	  ;; Use this getenv if your implementation supports it.
+	  (getenv "SCHEME_LIBRARY_PATH")
+	  ;; Use this path if your scheme does not support GETENV
+	  ;; or if SCHEME_LIBRARY_PATH is not set.
+	  (case (software-type)
+	    ((UNIX) "/home/shriram/slib/")
+	    ((UNIX) "/usr/local/lib/slib/")
+	    ((VMS) "lib$scheme:")
+	    ((MS-DOS) "C:\\SLIB\\")
+	    (else "")))))
+    (lambda () library-path)))
+
+;;; *FEATURES* should be set to a list of symbols describing features
+;;; of this implementation.  Suggestions for features are:
+
+(define *features*
+      '(
+	source				;can load scheme source files
+					;(slib:load-source "filename")
+	compiled			;can load compiled files
+					;(slib:load-compiled "filename")
+	rev4-report			;conforms to
+;	rev3-report			;conforms to
+;	ieee-p1178			;conforms to
+;	sicp				;runs code from Structure and
+					;Interpretation of Computer
+					;Programs by Abelson and Sussman.
+	rev4-optional-procedures	;LIST-TAIL, STRING->LIST,
+					;LIST->STRING, STRING-COPY,
+					;STRING-FILL!, LIST->VECTOR,
+					;VECTOR->LIST, and VECTOR-FILL!
+;	rev2-procedures			;SUBSTRING-MOVE-LEFT!,
+					;SUBSTRING-MOVE-RIGHT!,
+					;SUBSTRING-FILL!,
+					;STRING-NULL?, APPEND!, 1+,
+					;-1+, <?, <=?, =?, >?, >=?
+	multiarg/and-			;/ and - can take more than 2 args.
+	multiarg-apply			;APPLY can take more than 2 args.
+	rationalize
+	delay				;has DELAY and FORCE
+	with-file			;has WITH-INPUT-FROM-FILE and
+					;WITH-OUTPUT-FROM-FILE
+	string-port			;has CALL-WITH-INPUT-STRING and
+					;CALL-WITH-OUTPUT-STRING
+	transcript			;TRANSCRIPT-ON and TRANSCRIPT-OFF
+	char-ready?
+;	macro				;has R4RS high level macros
+	defmacro			;has Common Lisp DEFMACRO
+	eval				;SLIB:EVAL is single argument eval
+;	record				;has user defined data structures
+	values				;proposed multiple values
+	dynamic-wind			;proposed dynamic-wind
+	ieee-floating-point		;conforms to
+	full-continuation		;can return multiple times
+;	object-hash			;has OBJECT-HASH
+
+;	sort
+;	queue				;queues
+	pretty-print
+;	object->string
+	format
+;	trace				;has macros: TRACE and UNTRACE
+;	compiler			;has (COMPILER)
+;	ed				;(ED) is editor
+	system				;posix (system <string>)
+	getenv				;posix (getenv <string>)
+	program-arguments		;returns list of strings (argv)
+;	Xwindows			;X support
+;	curses				;screen management package
+;	termcap				;terminal description package
+;	terminfo			;sysV terminal description
+;	current-time			;returns time in seconds since 1/1/1970
+	))
+
+;;; Compatibility code added by Shriram.
+
+(define-macro defmacro
+  (lambda (name params . body)
+    `(define-macro ,name
+       (lambda ,params
+	 ,@body))))
+
+(define program-arguments
+  (lambda ()
+    (vector->list argv)))
+
+(define current-time current-seconds)
+
+;;; Remainder is modifications of existing code in Template.scm.
+
+;;; (OUTPUT-PORT-WIDTH <port>)
+(define (output-port-width . arg) 79)
+
+;;; (OUTPUT-PORT-HEIGHT <port>)
+(define (output-port-height . arg) 24)
+
+;;; (CURRENT-ERROR-PORT)
+
+;;; (TMPNAM) makes a temporary file name.
+(define tmpnam (let ((cntr 100))
+		 (lambda () (set! cntr (+ 1 cntr))
+			 (string-append "slib_" (number->string cntr)))))
+
+;;; (FILE-EXISTS? <string>)
+
+;;; (DELETE-FILE <string>)
+
+;;; FORCE-OUTPUT flushes any pending output on optional arg output port
+;;; use this definition if your system doesn't have such a procedure.
+(define force-output flush-output)
+
+;;; CALL-WITH-INPUT-STRING and CALL-WITH-OUTPUT-STRING are the string
+;;; port versions of CALL-WITH-*PUT-FILE.
+
+(define call-with-input-string
+  (lambda (string thunk)
+    (parameterize ((current-input-port (open-input-string string)))
+      (thunk))))
+
+(define call-with-output-string
+  (lambda (receiver)
+    (let ((sp (open-output-string)))
+      (receiver sp))))
+
+;;; CHAR-CODE-LIMIT is one greater than the largest integer which can
+;;; be returned by CHAR->INTEGER.
+(define char-code-limit 256)
+
+;;; MOST-POSITIVE-FIXNUM is used in modular.scm
+(define most-positive-fixnum #x3FFFFFFFF) ; 30 bits on 32-bit machines
+
+;;; Return argument
+(define (identity x) x)
+
+;;; If your implementation provides eval SLIB:EVAL is single argument
+;;; eval using the top-level (user) environment.
+(define slib:eval eval)
+
+;;; If your implementation provides R4RS macros:
+;(define macro:eval slib:eval)
+;(define macro:load load)
+
+(define gentemp
+  (let ((*gensym-counter* -1))
+    (lambda ()
+      (set! *gensym-counter* (+ *gensym-counter* 1))
+      (string->symbol
+       (string-append "slib:G" (number->string *gensym-counter*))))))
+
+(define defmacro? macro?)
+
+(define macroexpand-1 expand-defmacro-once)
+
+(define macroexpand expand-defmacro)
+
+(define base:eval slib:eval)
+(define (defmacro:expand* x)
+  (require 'defmacroexpand) (apply defmacro:expand* x '()))
+(define (defmacro:eval x) (base:eval (defmacro:expand* x)))
+
+(define (defmacro:load <pathname>)
+  (slib:eval-load <pathname> defmacro:eval))
+
+(define (slib:eval-load <pathname> evl)
+  (if (not (file-exists? <pathname>))
+      (set! <pathname> (string-append <pathname> (scheme-file-suffix))))
+  (call-with-input-file <pathname>
+    (lambda (port)
+      (let ((old-load-pathname *load-pathname*))
+	(set! *load-pathname* <pathname>)
+	(do ((o (read port) (read port)))
+	    ((eof-object? o))
+	  (evl o))
+	(set! *load-pathname* old-load-pathname)))))
+
+;;; define an error procedure for the library
+(define slib:error error)
+
+;;; define these as appropriate for your system.
+(define slib:tab (integer->char 9))
+(define slib:form-feed (integer->char 12))
+
+;;; Support for older versions of Scheme.  Not enough code for its own file.
+(define (last-pair l) (if (pair? (cdr l)) (last-pair (cdr l)) l))
+(define t #t)
+(define nil #f)
+
+;;; Define these if your implementation's syntax can support it and if
+;;; they are not already defined.
+
+(define (1+ n) (+ n 1))
+(define (-1+ n) (+ n -1))
+(define 1- -1+)
+
+(define in-vicinity string-append)
+
+;;; Define SLIB:EXIT to be the implementation procedure to exit or
+;;; return if exitting not supported.
+(define slib:exit exit)
+
+;;; Here for backward compatability
+(define scheme-file-suffix
+  (let ((suffix (case (software-type)
+		  ((NOSVE) "_scm")
+		  (else ".scm"))))
+    (lambda () suffix)))
+
+;;; (SLIB:LOAD-SOURCE "foo") should load "foo.scm" or with whatever
+;;; suffix all the module files in SLIB have.  See feature 'SOURCE.
+
+(define (slib:load-source f) (load (string-append f ".scm")))
+
+;;; (SLIB:LOAD-COMPILED "foo") should load the file that was produced
+;;; by compiling "foo.scm" if this implementation can compile files.
+;;; See feature 'COMPILED.
+
+(define (slib:load-compiled f) (load (string-append f ".zo")))
+
+;;; At this point SLIB:LOAD must be able to load SLIB files.
+
+(define slib:load slib:load-source)
+
+(slib:load (in-vicinity (library-vicinity) "require"))
diff --git a/notes/mzscheme/openbugs b/notes/mzscheme/openbugs
new file mode 100644
index 0000000..a4d6bb8
--- /dev/null
+++ b/notes/mzscheme/openbugs
@@ -0,0 +1,39 @@
+
+doc: scheme_reload()
+
+doc: simple-return-primitive?
+
+Changed load/use-compiled: searches for .zo files in
+  a "compiled/" subdirectory, and searches for .so/.dll
+  files in (build-path "compiled" (system-library-subpath))
+
+system: check for null in string
+
+(let loop ([x 0]) (call/cc loop)) accumulates memory
+
+"synrule.ss" is missing `let-syntax' and `letrec-syntax'
+
+On Alpha machines, floating-point overflow is not handled properly
+ (so +inf.0, -inf.0, and +nan.0 are messed up)
+
+Under MacOS, `tcp-listen' does not work reliably
+
+Under MacOS, in the standalone MzScheme application, a blocking read 
+ from stdin blocks all MzScheme threads
+
+Under Unix, (execute s) is just (exit (if (system s) 0 -1)), while
+ execute* replaces the current process like it is supposed to
+
+Under Windows, the `system' procedure blocks all MzScheme threads
+ (`system*' works correctly)
+
+Under AIX, write to tcp output port blocks when the low-level
+  buffer is full
+
+Under FreeBSD, if the descripters limit is greater than 256, then
+  it is automatically reduced to 256 within MzScheme/MrEd/DrScheme
+
+Still to be added to support R5RS:
+  (scheme-report-environment n)
+  (null-environment)
+  (interaction-environment)
diff --git a/notes/openbugs b/notes/openbugs
new file mode 100644
index 0000000..d93e83f
--- /dev/null
+++ b/notes/openbugs
@@ -0,0 +1,174 @@
+======================================================================
+DrScheme
+======================================================================
+- in the language dialog box, "allow set! on undefined" is ignored
+
+- check syntax doesn't traverse unit or class expressions
+
+- check syntax: identifiers with newlines in them have their arrows
+  start from funny places.
+
+- eval'ing images in drscheme is broken
+
+- backup files don't preserve file permissions
+
+
+
+======================================================================
+MrEd System
+======================================================================
+
+- replace can't replace with an empty string (ie, deleting
+  a word by finding it and replacing it with empty doesn't work)
+
+- bad url's are not handled smoothly
+
+- mred:console%'s initialization argument: `close-item?' is being ignored
+
+- backup files don't preserve permissions
+
+- the directory line in the common-file-dialogs is confusing
+
+- embedded snips should be reset on the styles-fixed? ivar
+
+- "scale" in open-viewport does effect the size
+  of the viewport, but is ignored by at least
+  draw-line into that viewport.
+	
+- you cannot break (read)
+
+- pathnames should be normalized to early and can cause automouter problems
+
+- control-l doesn't get the horizontal direction right.
+
+- editor frames aren't gc'd when modified and search is open
+
+
+======================================================================
+MrEd
+======================================================================
+
+* Windows: place windows neatly for "default" position instead of
+   always placing them at 0, 0
+
+* X Windows: modal dialogs can still be closed with the Window
+   Manager
+
+* X Windows and drawing into b & w bitmaps: black and white
+  are reversed when using certain kinds of displays
+
+* wx:dc%'s draw-arc is undefined when input isn't
+  consistent with a circle
+
+* wx:key-event% needs a set-position method
+
+* Windows: set-user-scale with wx:memory-dc% doesn't work right
+
+* MacOS: busy-cursor state is wrong for new windows when the
+   busy cursor is active
+
+* pasteboards: printing not yet implemented
+
+* need to penalize the current thread more for certain primitive
+   operations that can take a long time (e.g., loading a bitmap
+   or saving a file)
+
+* need range check for dc transfer modes
+
+* need directory-selection dialog
+
+* cursor changes to arrow over clickback after hitting it
+
+* cursor does not change over clickbacks in embedded buffers
+
+* Keys like KP_end, etc. are not currently accessible
+
+* doc: [Mr] clarify "owning the caret" with respect to ownership by the parent, etc.
+
+* doc: [Mr] "only valid when displayed": hyper-link to explanation.
+
+* Motif: get-file dialog modality is wrong for eventspaces
+
+* Windows and MacOS: "primitive" dialogs don't get closed by
+   custodian-shutdown-all
+
+* MacOS: std file dialog and print dialogs block MzScheme threads
+
+* maliciously overriding set-admin can crash merge-snip and split-snip
+
+* cut-n-paste within mred but across eventspaces breaks security and
+  filesaving because snip class list is eventspace-specific
+
+* how does wx:dc% get-size interact with the user scale?
+
+* the full width for non-wrapped lines need not include the autowrap bitmap
+
+* should use a guranteed offset for stippling in buffer redraws
+
+* Xt: out-of-colours - widgets use too much black
+
+* signature include: unbalanced parens => diverge?
+
+* drag outisde view => should keep going even if mouse is still
+
+* hidden files - add a MzScheme predicate?
+
+* dragging selection shouldn't keep changing the auto-X-selection
+
+* Xt: busy cursor not shown in the menu bar
+
+* editor buffers should show a blinking caret
+
+* Motif: menus don't work with multiple displays
+
+* Motif: wxDialogBox doesn't obey current display for multiple displays
+
+* add background colour for buffers?
+
+* updating bug?: long flash, not on same line, update on focus-in
+
+* add paragraph styles?
+
+* need better de-fragmentation of text snips
+
+* need to show a mystery snip icon when unknown data is loaded from a file
+
+
+======================================================================
+MzScheme
+======================================================================
+
+"synrule.ss" is missing `let-syntax' and `letrec-syntax'
+
+`unit/sig' incorrectly handles syntax where defintions in the unit
+ shadow syntactic forms
+
+Under HP/UX, image --restore doesn't work
+
+On Alpha machines, floating-point overflow is not handled properly
+ (so +inf.0, -inf.0, and +nan.0 are messed up)
+
+Under MacOS, `tcp-listen' does not work reliably
+
+Under MacOS, in the standalone MzScheme application, a blocking read 
+ from stdin blocks all MzScheme threads
+
+Under Unix, (execute s) is just (exit (if (system s) 0 -1)), while
+ execute* replaces the current process like it is supposed to
+
+Under Windows, the `system' procedure blocks all MzScheme threads
+ (`system*' works correctly)
+
+Under AIX, write to tcp output port blocks when the low-level
+  buffer is full
+
+Under FreeBSD, if the descripters limit is greater than 256, then
+  it is automatically reduced to 256 within MzScheme/MrEd/DrScheme
+
+Still to be added to support R5RS:
+  (scheme-report-environment n)
+  (null-environment n)
+  (interaction-environment)
+  (port? v)
+
+
diff --git a/notes/releases/040.html b/notes/releases/040.html
new file mode 100644
index 0000000..1994270
--- /dev/null
+++ b/notes/releases/040.html
@@ -0,0 +1,82 @@
+<title>Release Notes for DrScheme</title>
+
+<body>
+
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>: 0.40.<br>
+<b>Release Date</b>: March 22, 1996.
+
+<p>
+
+The following is a list of differences between this release and the
+previous one.
+
+<p>
+
+<h4>Editor</h4>
+
+<p>
+
+The long-known instability in the Windows 95/NT version has finally
+been corrected. Also, a major instability in the 68k Macintosh version
+has been fixed. The Win32s version remains unstable.
+
+<p>
+
+<h4>Type-Analysis</h4>
+
+<p>
+
+The number in parentheses indicates the section in the reference
+manual that describes the feature.
+
+<ul>
+
+<li>Improved, faster type compression.
+<li>Accurate description of numeric values (4.3).
+<li>Constants (number, character or symbol) in the input type
+    language.
+<li>Type assertions, <code>(: exp type)</code>, have been added (5.4).
+<li><code>define-type</code> changed to
+    <code>define-constructor</code> (5.2).
+<li><code>st:deftype</code> changed to <code>st:defconstructor</code> (6.2).
+<li>Added <code>define-type</code>, <code>st:deftype</code> (5.3 and 6.2).
+<li>Changed <code>(list T)</code> to <code>(listof T)</code> (4.2).
+<li>Added list type with the same same semantics as in Scheme (4.2).
+<li><code>(+ T1 ... Tn)</code> changed to <code>(union T1
+    ... Tn)</code> (4.1).
+
+</ul>
+
+<h4>Debugger</h4>
+
+<p>
+
+A completely new debugger has been incorporated.  This debugger has
+been measured to be twenty times or more faster than the previous
+version.  In particular, the debugger does not do worse than double
+the execution time.  In return, the debugger currently reports both
+incorrect-arity errors and non-procedural application errors as
+``application errors''.
+
+<p>
+
+<img align=center
+     src="http://www.cs.rice.edu/CS/PLT/lambdahead.gif"
+     alt="[PLT logo]">
+
+<p>
+
+<address>
+<a href="http://www.cs.rice.edu/~shriram/">Shriram
+Krishnamurthi</a> /
+<a href="mailto:shriram@cs.rice.edu">shriram@cs.rice.edu</a>
+</address>
+
+</body>
diff --git a/notes/releases/041.html b/notes/releases/041.html
new file mode 100644
index 0000000..a755a80
--- /dev/null
+++ b/notes/releases/041.html
@@ -0,0 +1,178 @@
+<title>Release Notes for DrScheme</title>
+
+<body>
+
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>: 0.41.<br>
+<b>Release Date</b>: April 16, 1996.
+
+<p>
+
+The following is a list of differences between this release and the
+previous one.
+
+
+<h3>Highlights</h3>
+
+A mail alias has been created for reporting bugs.
+Bug reports for DrScheme (and other PLT software) should be sent to:
+
+<pre>    plt-bugs@cs.rice.edu
+</pre>
+
+<p>
+The error messages in DrScheme have been improved and should now
+be more descriptive of the problem.
+
+<p>
+Several changes to the MzScheme language affecting the class system,
+exceptions and macros have been made in release 0.41.
+Many of the new features are incompatible with the old system.
+
+
+<h4>Classes</h4>
+
+`make-class' and `make-class*' have been replaced with `class' 
+and `class*'. 
+`class' looks a lot like `make-class', but there are
+some important differences:
+
+<ol>
+<li>
+The initialization procedure of `make-class' is gone.
+Instead, in `class', there is always an implicit `lambda'
+(really something like an `opt-lambda').  As a result,
+the arguments to `make-object' can be used in the ivar
+initialization expressions.
+
+<li>
+All ivars are intialized in order, even across clauses.
+
+<li>
+A new kind of clause is available: `sequence' clauses
+evaluate expressions without assigning them to ivars.
+
+<li>
+The scope of `super-init' includes all of the clauses now. 
+(It used to be only the initialization procedure.)
+
+<li>
+apply-super-init is gone. Use (apply super-init ...) instead.
+</ol>
+
+<p>
+For example, this expression:
+
+<pre>  (make-class c%
+    (private y)
+    (public [x (lambda () y)])
+    (lambda (v)
+      (set! y v)
+      (super-init)))
+</pre>
+
+can now be written:
+
+<pre>  (class c% (v) ; (v) is the arg list for the implicit lambda
+    (private [y v])
+    (public [x (lambda () y)])
+    (sequence
+      (super-init)))
+</pre>
+
+or even better:
+
+<pre>  (class c% (y)
+    (public [x (lambda () y)])
+    (sequence
+      (super-init)))
+</pre>
+
+This expression:
+
+<pre>  (make-class d%
+    (public [x 5]))
+</pre>
+
+translates to:
+
+<pre>  (class d% args
+    (public [x 5])
+    (sequence
+      (apply super-init args)))
+</pre>
+
+Since this happens a lot, mzlib's `macros.ss' defines `class-asi'
+(auto super init):
+
+<pre>  (class-asi d%
+    (public [x 5]))
+</pre>
+
+(Here, `make-class' was simply changed to `class-asi'.)
+
+<p>
+Default expressions can be provided for `make-object' arguments
+(`opt-lambda' style):
+
+<pre>  (class x% (a [b (add1 a)] [c (lambda (x) b)])
+    ...)
+</pre>
+
+Each default value expression is not evaluated when an argument is
+supplied. The scope of all argument variables includes all default
+value expressions (i.e., like `letrec', while `opt-lambda' is like
+`let*').
+
+
+<h4>Exceptions</h4>
+
+Errors are now always signaled using exceptions. The `raise' procedure
+takes any value and invokes the current exception handler with that
+value. All primitive errors invoke `raise' with an instance of the
+struct type `exn'. There is always a current exception handler, just
+as there has previously been a current error handler in MzScheme.
+(The current error display and escape handlers are still used by the
+default eception handler). A `with-handlers' form provides ML-like
+syntax for handling exceptions in a subexpression.
+
+<h4>Macros</h4>
+
+`defmacro' and `letmacro' have been replaced with `define-macro' and
+`let-macro'. The only difference is that the implicit `lambda' must
+now be explicit:
+
+(defmacro when (test . body)
+  `(if ,test
+       (begin
+	 ,@body)))
+
+becomes
+
+(define-macro when 
+  (lambda (test . body)
+    `(if ,test
+	 (begin
+	   ,@body))))
+
+mzlib's `compat.ss' defines macros for `defmacro' and `letmacro'.
+
+<h4>Package Macro</h4>
+
+
+The `package' macro in mzlib's "macros.ss" has been renamed to
+`define-some' to avoid confusion with DrScheme's `make-package' form.
+
+<h4>Error Messages</h4>
+
+The error messages from MzScheme have been revised. 
+Hopefully, the syntax error messages will now be more helpful.
+
+
+</body>
diff --git a/notes/releases/42.html b/notes/releases/42.html
new file mode 100644
index 0000000..6904c44
--- /dev/null
+++ b/notes/releases/42.html
@@ -0,0 +1,133 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 42. <br>
+<b>Release Date</b>:<tt> </tt> June 8, 1996.
+
+<p>
+The following is a summary of the changes in this release
+from the previous one.
+
+<p>
+A reminder that bug reports should be sent to:<tt>  
+plt-bugs@cs.rice.edu</tt>.
+
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+Added a facility for single-stepping through small programs.<tt> </tt>
+See the 
+<a href="http://www.cs.rice.edu/CS/PLT/packages/doc/donkey/donkey.html"> 
+documentation for the stepper</a>.
+
+<li>
+Major restructuring in the online documentation for the builtin
+gui-making classes.<tt> </tt>
+See the
+<a href="http://www.cs.rice.edu/CS/PLT/packages/doc/toolbox">
+MrEd ToolBox</a>.
+
+<li>
+Added a copy ring similar to emacs's "kill ring".<tt> </tt>
+For example, you can copy, cut or kill selection A, 
+then copy B, then paste B, and then use Meta-Y to replace
+the pasted B with A.
+
+<li>
+Disabled editing before the prompt in the console (lower) window.
+
+<li>
+MacOS memory use greatly improved.
+
+<li>
+DrScheme's support for the <tt>do</tt> form currently requires 
+the <tt>&lt;step&gt;</tt> part.<tt> </tt>
+This will be fixed in future versions.
+
+<li>
+DrScheme's support for <tt>(import ...)</tt> requires that the
+<tt>module</tt> specification be an identifier bound to
+a module value.
+
+<li>
+Added support for 16-bit color in XFree86 (unix only).
+
+<li>
+Dropped the decimal point in the version number.
+
+</ul>
+
+
+<h4> Underlying MzScheme Language </h4>
+
+<ul>
+<li>
+<tt>null</tt> is bound to the empty list.
+
+<li>
+Falling through a <tt>cond</tt> expression without matching any case
+is now an error.
+
+<li>
+The primitives <tt>binary-and</tt>, etc., are renamed to <tt>bitwise-and</tt>,
+<tt>bitwise-ior</tt>, <tt>bitwise-xor</tt>, and <tt>bitwise-not</tt>.
+
+<li>
+<tt>string=?</tt>, <tt>char=?</tt>, etc., are now multi-arity 
+like numerical <tt>=</tt>, etc.
+
+<li>
+The braces { and } are treated as a matching set of parentheses,
+along with ( ) and [ ].
+</ul>
+
+For a more complete description of the mzscheme changes, see the 
+<a href="http://www.cs.rice.edu/CS/PLT/packages/mzscheme/HISTORY">
+MzScheme release notes</a>.
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The analysis now understands the types of most mzlib primitives.
+
+<li>
+Added an option to view parameterized types for functions.
+
+<li>
+Minor changes in the layout of some options and menus,
+and some minor options deleted.
+</ul>
+
+
+<h4> Bug Fixes </h4>
+
+<ul>
+<li>
+Fixed bugs in <tt>module</tt>, <tt>import</tt> and <tt>do</tt>.
+
+<li>
+Fixed <tt>dynamic-wind</tt> and <tt>call/ec</tt> for values.
+
+<li>
+Fixed <tt>read</tt> for strings containing #\nul.
+
+<li>
+Fixed annoying non-standard Windows beep.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/43.html b/notes/releases/43.html
new file mode 100644
index 0000000..bdd8ab0
--- /dev/null
+++ b/notes/releases/43.html
@@ -0,0 +1,125 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 43. <br>
+<b>Release Date</b>:<tt> </tt> August 9, 1996.
+
+<p>
+<b>Note:</b><tt> </tt>
+Release 44 is planned for August 28 and will include bug fixes 
+and better documentation for the new tools.<tt> </tt>
+We encourage our users to try release 43 and submit bug 
+reports.<tt> </tt>
+If at all possible, fixes for bugs in release 43 will be 
+incorporated into release 44.
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+Added a "Preferences" item on the "Edit" menu.<tt> </tt>
+The "DrScheme" category allows selection of the subset of Scheme
+from purely functional Scheme (no set!, etc) to (almost)
+fully R4RS Scheme.
+
+<li>
+The Scheme primitives can now be redefined, and there is no longer
+a restriction on using names that begin with "zodiac:".
+
+<li> 
+These syntactic forms not yet supported:<tt> </tt>
+do without the step form, vector constants inside quasiquote, local,
+and define-structure (use define-struct instead).
+
+<li>
+Significant internal restructuring of the GUI tools DrScheme uses
+to make windows, panels, buttons, etc.
+</ul>
+
+<h4> Syntax Checker </h4>
+
+<ul>
+<li>
+Added a Syntax Checker and Colorizer.
+
+<li>
+Go to the "Tools" menu and click on "Syntax Checker."<tt> </tt>
+Then, clicking on the "Check Syntax" button will highlight
+syntax errors and (on some platforms) color the program according 
+to free and bound identifiers, syntactic forms, constants, etc.
+</ul>
+
+<h4> Debugger </h4>
+
+<ul>
+<li>
+Added early support for a Debugger.
+
+<li> 
+After loading a file, click on "Debug."<tt> </tt>
+Then, clicking on the beginning of an expression (a "Hotspot")
+will enable setting breakpoints and recording history 
+information.<tt> </tt>
+Better documentation is planned for release 44.
+
+<li>
+<i>Note:</i><tt> </tt>
+The Debugger currently doesn't handle syntax errors very well.<tt> </tt>
+So, first make sure that the program passes "Check Syntax" before
+running the Debugger.
+</ul>
+
+<h4> Stepper </h4>
+
+<ul>
+<li>
+Added support for let, let*, letrec, call/cc and improper arguments
+in lambda.
+
+<li>
+Added Cut, Copy, Paste and Delete to the Edit menu.<tt> </tt>
+Copy and Paste also work between the Stepper and DrScheme.
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) is temporarily unavailable in 
+releases 43 and 44 and will reappear in a future release.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+On some platforms (Macintosh and Microsoft Windows), the Syntax Checker
+and the Debugger do not display the program in color.
+
+<li>
+On the Macintosh, the Debugger window is too small, and the Hotspot
+window does not pop up correctly.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/44.html b/notes/releases/44.html
new file mode 100644
index 0000000..72535c6
--- /dev/null
+++ b/notes/releases/44.html
@@ -0,0 +1,71 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 44 <br>
+<b>Release Date</b>:<tt> </tt> September 9, 1996.
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+Non-text items (e.g. a picture) can be used in a program as a contant
+value. The interaction window handles non-text for both input and
+output. When non-text is used in a program saved to disk, the file is
+automatically saved to disk in DrScheme's binary format.
+
+<li> 
+Syntax checking has been improved, and the colors are
+now parameterized through preferences.
+
+<li> 
+These syntactic forms not yet supported:<tt> </tt>
+do without the step form and define-structure (use define-struct instead).
+
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) is temporarily unavailable in 
+release 44 and will reappear in a future release.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+DrScheme internally normalizes pathnames, resolving all links
+to absolute paths. This causes problems with systems that use
+automounting.
+
+<li>
+Even in the R4RS language level, DrSchemd does not support 
+case-insensitive identifiers.
+
+<li>
+The <tt>eval</tt> procedure is not supported.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/45.html b/notes/releases/45.html
new file mode 100644
index 0000000..56fed13
--- /dev/null
+++ b/notes/releases/45.html
@@ -0,0 +1,102 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 45 <br>
+<b>Release Date</b>:<tt> </tt> November 12, 1996.
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the major changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+Scheme I/O through <tt>read</tt>, <tt>read-char</tt>, and
+<tt>read-line</tt> is now supported. All I/O is specially boxed in the
+interactive console to distinguish it from evaluator I/O.
+
+<li> 
+Two syntactic forms are not yet supported:<tt> </tt>
+<tt>do</tt> without the step form and 
+<tt>define-structure</tt> (use <tt>define-struct</tt> instead).
+
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) is temporarily unavailable in 
+release 45 and will reappear in a future release.
+</ul>
+
+<h4> MrEd </h4>
+
+<ul>
+<li> A new construct has been added: eventspaces. An eventspace
+encapsulates an independent event loop. A single running MrEd can
+contain multiple eventspaces, each owning a collection of top-level
+windows that are connected through the event loop, but indepedent of
+event-handling for other eventspaces. This supports a better
+integration of asynchonous threads and synchnous eventspaces.
+
+<li> A prototype Web browser is available through the standard "Open
+URL..."  menu item in the "File" menu.
+
+<li>See <tt>plt/mred/HISTORY</tt> and <tt>plt/mred/system/history</tt>
+in the distribution for more information and other changes.
+</ul>
+
+<h4> MzScheme </h4>
+
+<ul>
+<li>Multiple return values are now agressively supported,
+and new forms <tt>define-values</tt>, <tt>letrec-values</tt>,
+<tt>set!-values</tt>, etc. have been added.
+<br>
+IMPORTANT: The <tt>let-values</tt> of previous versions is
+now <tt>let*-values</tt>. The new <tt>let-values</tt> binds
+a sequence of identifier sets all with the same enviornment.
+
+<li>See <tt>plt/mzscheme/HISTORY</tt> in the distribution for more
+information and other changes.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+DrScheme internally normalizes pathnames, resolving all links
+to absolute paths. This causes problems with systems that use
+automounting.
+
+<li>
+Even in the R4RS language level, DrScheme does not support 
+case-insensitive identifiers.
+
+<li>
+The <tt>eval</tt> procedure is not supported.
+
+<li>
+See also <tt>plt/openbugs</tt> in the distribution.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/46.html b/notes/releases/46.html
new file mode 100644
index 0000000..0a508f0
--- /dev/null
+++ b/notes/releases/46.html
@@ -0,0 +1,79 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 46 <br>
+<b>Release Date</b>:<tt> </tt> December 5, 1996.
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the major changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+All of MzScheme's syntax is now supported in DrScheme, except
+for units with signatures.
+
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) is temporarily unavailable in 
+release 46 and will reappear in a future release.
+</ul>
+
+<h4> Donkey </h4>
+
+<ul>
+<li>
+The Stepper tool (Donkey) is temporarily unavailable in 
+release 46 and will reappear in 47.
+</ul>
+
+<h4> MrEd </h4>
+
+<ul>
+<li>See <tt>plt/mred/HISTORY</tt> and <tt>plt/mred/system/history</tt>
+in the distribution for changes.
+</ul>
+
+<h4> MzScheme </h4>
+
+<ul>
+<li>See <tt>plt/mzscheme/HISTORY</tt> in the distribution for
+changes.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+DrScheme internally normalizes pathnames, resolving all links
+to absolute paths. This causes problems with systems that use
+automounting.
+
+<li>
+See also <tt>plt/openbugs</tt> in the distribution.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/47.html b/notes/releases/47.html
new file mode 100644
index 0000000..e2b3803
--- /dev/null
+++ b/notes/releases/47.html
@@ -0,0 +1,74 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 47 <br>
+<b>Release Date</b>:<tt> </tt> January 11, 1997.
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the major changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+The entire MrEd graphical toolbox is now available for development
+within DrScheme.
+
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) is temporarily unavailable in 
+release 47 and will reappear in a future release.
+</ul>
+
+<h4> Donkey </h4>
+
+<ul>
+<li>
+The Stepper tool (Donkey) is temporarily unavailable in 
+release 47 and will reappear in a future release.
+</ul>
+
+<h4> MrEd </h4>
+
+<ul>
+<li>See <tt>plt/mred/HISTORY</tt> and <tt>plt/mred/system/history</tt>
+in the distribution for changes.
+</ul>
+
+<h4> MzScheme </h4>
+
+<ul>
+<li>See <tt>plt/mzscheme/HISTORY</tt> in the distribution for
+changes.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+See <tt>plt/openbugs</tt> in the distribution.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/49.html b/notes/releases/49.html
new file mode 100644
index 0000000..cde666c
--- /dev/null
+++ b/notes/releases/49.html
@@ -0,0 +1,73 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 49 <br>
+<b>Release Date</b>:<tt> </tt> May 31, 1997.
+<br>(Note: 49 is the successor to 47)
+
+<p>
+Send bug reports to:<tt>
+<a href="mailto:plt-bugs@cs.rice.edu">
+plt-bugs@cs.rice.edu</a></tt>
+
+<p>
+The following is a summary of the major changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+DrScheme uses substantially less memory.
+
+</ul>
+
+<h4> Analysis </h4>
+
+<ul>
+<li>
+The Analysis tool (MrSpidey) has returned.
+</ul>
+
+<h4> Donkey </h4>
+
+<ul>
+<li>
+The Stepper tool (Donkey) is temporarily unavailable in 
+release 49 and will reappear in a future release.
+</ul>
+
+<h4> MrEd </h4>
+
+<ul>
+<li>See <tt>plt/mred/HISTORY</tt> and <tt>plt/mred/system/history</tt>
+in the distribution for changes.
+</ul>
+
+<h4> MzScheme </h4>
+
+<ul>
+<li>See <tt>plt/mzscheme/HISTORY</tt> in the distribution for
+changes.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+See <tt>plt/openbugs</tt> in the distribution.
+</ul>
+
+</body>
+</html>
diff --git a/notes/releases/50.html b/notes/releases/50.html
new file mode 100644
index 0000000..926a0c5
--- /dev/null
+++ b/notes/releases/50.html
@@ -0,0 +1,89 @@
+<html>
+
+<head>
+<title> DrScheme Release Notes </title>
+</head>
+
+<body>
+<h2><img align=center
+         src="http://www.cs.rice.edu/CS/PLT/packages/drscheme/logo.gif"
+         alt="[DrScheme logo]">
+DrScheme Release Notes</h2>
+
+<p>
+
+<b>Current Release</b>:<tt> </tt> 50 <br>
+<b>Release Date</b>:<tt> </tt> August 26, 1997.
+
+<p>
+Submit bugs using the <A HREF="http://www.cs.rice.edu/CS/PLT/Gnats/">web interface</A>
+(encouraged) or send mail to
+<A HREF="mailto:plt-bugs@cs.rice.edu">plt-bugs@cs.rice.edu</A>
+(discouraged).
+
+<p>
+The following is a summary of the major changes in this release
+from the previous one.
+
+<h4> DrScheme </h4>
+
+<ul>
+<li>
+DrScheme's fonts can now be configured through the Preferences dialog.
+
+<li>
+DrScheme's Beginner and Intermediate languages are more strict. This
+provides better error messages for expressions like <TT>(1 2)</TT>
+or <TT>(cond (null? l))</TT>.
+
+<li>
+A quasiquote bug has been fixed for forms like <TT>`(1 . ,3)</TT>.
+
+<li>
+The <TT>turn</TT> turtle command now turns counter-clockwise in degrees
+(instead of clockwise in radians). The The <TT>turn/radians</TT> command
+turns counter-clockwise in radians.
+
+<li>
+Printing has been fixed.
+
+<li>
+Output in the interactions window is much faster.
+
+</ul>
+
+<h4> Donkey </h4>
+
+<ul>
+<li>
+The Stepper tool (Donkey) is temporarily unavailable in 
+release 50 and will reappear in a future release.
+</ul>
+
+<h4> MrEd </h4>
+
+<ul>
+<li>The look and speed of the non-Motif X Windows version has improved.
+<li>See <tt>plt/mred/HISTORY</tt> and <tt>plt/mred/system/history</tt>
+in the distribution for other changes.
+</ul>
+
+<h4> MzScheme </h4>
+
+<ul>
+<li>Added compile-time inference of procedure names for
+better error reporting.
+<li>Added a mechanism for saving and restoring heap dumps under Unix.
+<li>See <tt>plt/mzscheme/HISTORY</tt> in the distribution for
+other changes.
+</ul>
+
+<h4> Known Problems </h4>
+
+<ul>
+<li>
+See <tt>plt/openbugs</tt> in the distribution.
+</ul>
+
+</body>
+</html>
diff --git a/src/mred/COPYING.LIB b/src/mred/COPYING.LIB
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/src/mred/COPYING.LIB
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/src/mred/FONTS b/src/mred/FONTS
new file mode 100644
index 0000000..c584f91
--- /dev/null
+++ b/src/mred/FONTS
@@ -0,0 +1,432 @@
+
+Do not read this file. If you want to change the fonts in MrEd,
+use the preferences dialog instead.
+
+Ok, if you're still reading, you must really want to do something that
+can't be done via the preferences dialog. Most likely, it *can* be
+done, and this file will tell you how if you're pantient enough.
+
+---------------------------------------------------
+    1. Welcome to the Weird World of MrEd Fonts
+---------------------------------------------------
+
+MrEd's font system is designed to appear to work gracefully across
+platforms to a naive MrEd user. It is also designed to provide
+complete configuration control to a knowledgeable user (this may be
+especially necessary under X Windows). These are somewhat
+contradictory goals, and leave MrEd with a somewhat complex font
+system.
+
+Terminology will be developed here to explain the working of the font
+system, but do not expect these terms to be used by the MrEd
+toolbox. The toolbox is designed to do what a programmer or user
+probably wanted using names that a programmer or user would probably
+understand intuitively.
+
+A "real font" is a device-speicific font used to draw or measure text
+for a screen or a printer. MrEd handles three kinds of real fonts:
+
+  * Screen fonts
+  * PostScript font names
+  * AFM font files
+
+An "abstract font" is a platform- and device-independent entity
+that describes a font. MrEd uses 8 abstract fonts:
+
+  * "Default"
+  * "Decorative"
+  * "Roman"
+  * "Script"
+  * "Swiss"
+  * "Modern"
+  * "Teletype"
+  * "System"
+
+The "System" abstract font is intended only for use with screen-based
+controls. The "Teletype" abstract font is rarely used.
+
+There are two basic problems:
+
+ * Mapping abstract fonts to real fonts
+ * Specifying a real font without a corresponding abstract font
+
+The solution in the latter case is simply to let the user or
+programmer invent new abstract fonts. However, the new abstract font
+is associated with a core abstract font so that a suitable default
+real font can be selected when no information about the new abstract
+font is available.
+
+Abstract fonts are mapped to real fonts via the low-level setup
+resource file read by MrEd at startup time. (Under X Windows, X
+resources can be specified in any way, but specifying X resources
+through the startup file is the preferred mechanism.)
+
+In the case of real fonts for an X Windows screen, it is necssary to
+map not only an abstract font toa real font, but an abstract font
+combined with a weight, style, and size to a real font - hence, the
+insane complexity of MrEd's font system.
+
+---------------------------
+    1. Resource Entries
+---------------------------
+
+First, we consider the mechanism tha maps abstract fonts to real fonts
+in the case that the information is provided via resources.
+
+To find a font name in the resource, MrEd looks for a resource item
+named by:
+
+  <dest><type><weight><style>
+
+Where
+
+  <dest> is either "Screen", "PostScript", or "AFM"
+  <type> is either "Default", "Decorative", "Roman", "Script", "Swiss", 
+         "Modern", "Teletype", or "Screen", or a programmer- or 
+         user-generated abstract font name
+  <weight> is either "Medium", "Bold", or "Light"
+  <style> is either "Straight", "Italic", or "Slant"
+
+Once the resource value is obtained, the way in which is it used is
+destination- and platform-specific (surprise, surprise):
+
+ * A PostScript name value is always used as a PostScript 
+   font name (the preceeding slash is added automatically).
+
+ * An AFM name is used as the base file name.  The ".afm"
+   extension is added automatically. The AFM file is found
+   according to the path maintained by wx:get-afm-path
+   and wx:set-afm-path.
+
+ * A screen name is interpreted in a platform-specific way:
+ 
+   - Under Windows and MacOS, the name is used directly as the
+     font name.
+
+   - Under X-Windows, the name is either:
+
+       - a full X Windows font name (including style information), 
+         with a "%d" in place of the point-size field, and 
+         prefixed with a "+"; or
+
+       - a partial X Windows font name, matching one of the 
+         following regexp replacements:
+
+          -([^-]*) 
+            => -*-\1-<weight>-<style>-normal-*-*-%d-*-*-*-*-*-*
+	  -([^-]*)-(.*) 
+            => -\1-\2-<weight>-<style>-normal-*-*-%d-*-*-*-*-*-*
+	  ([^-].*[^-]) 
+            => \1
+
+         Note that the absence of a leading "+" triggers the 
+         regexp-replace attempt
+
+For example, under X Windows, this X resource entry specifies the
+Default, medium-weight, unslanted font:
+
+ mred.ScreenDefaultMediumStraight: +-*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+and this is equivalent:
+
+ mred.ScreenDefaultMediumStraight: -*-*
+
+or even this:
+
+ mred.ScreenDefaultMediumStraight: -*
+
+
+A non-core abstract font <x> is associated with core abstract fonts
+with a resource item named by Family<x> where the value is the name
+of a core abstract font. For example, the new abstract font "Century" 
+might be asscoaited with the "Roman" core abstract class:
+
+  mred.FamilyCentury: Roman
+
+
+1.1. Wildcards
+--------------
+
+It has probably not escpaed the reader's attention that building
+items names by <dest><type><weight><style> will creates a rather
+large number of resource entires. Furthermore, the <weight><style>
+part is only useful for X Windows screen fonts. To avoid an
+explosion of resource entires, MrEd actually finds resource items
+via a wildcarding search.
+
+The <type>, <weight>, and <style> parts of a resource name can
+be wildcarded by using "_". Thus, to set the default font for all
+types, weights, and styles, use this X resource entry:
+
+ mred.Screen___: +-*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+Wildcarded resource entires are used only when un-wildcarded values
+cannot be found. If two resource names both match for some search,
+then the one with the "earliest" (i.e., closest to the beginning of
+the resource name) non-wildcarded part will prevail.
+
+The default MrEd resource file for Windows uses wildcarding to
+specify the basic font mapping:
+
+ [mred]
+ defaultFontSize=10
+ ScreenDefault__=MS Sans Serif
+ ScreenRoman__=Times New Roman
+ ScreenDecorative__=Modern
+ ScreenModern__=Courier New
+ ScreenSwiss__=Arial
+ ScreenScript__=Script
+
+Wildcarding by itself is altogether too simple, so we add more
+power/confusion with References, Parameterizations, and Wildcarding
+References. Non-masochists may consider skipping to section 1.2.
+
+1.1.1 References
+- - - - - - - - 
+
+Suppose we define the default font for all of "Default", and then
+we want "Roman" to use this setting, too. We could copy the
+resource entry, like this:
+
+ mred.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+ mred.ScreenRoman__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+
+but the MrEd font-reading system provides a better syntax for
+referencing another resource entry. When a resource value contains
+"${x}", then the "${x}" fragment is replaced by the resource value of
+"x". Thus, the above could be re-written:
+
+ mred.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+ mred.ScreenRoman__: ${ScreenDefault__}
+
+But wait, there's more...
+
+1.1.2 Parameterizations
+- - - - - - - - - - - -
+
+Parameterization can be used with referencing to parameterize default
+values based on the weight and style that is needed.  When a resource
+value contains "$[weight]", then "$[weight]" is replaced with a string
+for the desired font weight. Similarly, "$[style]" is replaced with
+the desired style. Parameterizing expressions can be embedded in 
+referencing expressions, like this:
+
+  mred.ScreenDefault__: -*-*-${Def$[weight]}-r-normal-*-*-%d-*-*-*-*-*-*
+  mred.DefMedium: medium
+  mred.DefBold: bold
+  mred.DefLight: medium
+
+Now, when the "ScreenDefault__" resource is used for different weights,
+it will return different values; the "${Def$[weight]}~ expression will
+turn into "${DefMedium}" for a medium-weight lookup, or "${DefBold}"
+for a bold-weight lookup. These references will in turn give either
+"medium" or "bold".
+
+We're not done, yet...
+
+1.1.3 Wildcarding References
+- - - - - - - - - - - - - - 
+
+Consider the following resource configuration:
+
+  MrEd.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenRoman__: ${ScreenDefault__}
+
+The effect of this statement is probably not what was intended; when
+a bold version of the "Roman" font is needed, "ScreenRoman__"
+references "ScreenDefault__", which does not specify a bold font.
+We could try to remedy the situation this way:
+
+  MrEd.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  MrEd.ScreenRoman__: ${ScreenDefault$[weight]_}
+
+but this does not work either. It works fine for bold "Roman", now, 
+but medium "Roman" will cause a reference to "ScreenDefaultMedium_",
+which doesn't exist. The problem is that our reference does not use
+wildcarding like the original medium "Roman" lookup did.
+
+Wildcarding can be specified in a reference by separating each
+wildcardable field with a comma. This resource specification does
+what we want:
+
+  wxApp.ScreenDefault__: -*-*-medium-r-normal-*-*-%d-*-*-*-*-*-*
+  wxApp.ScreenDefaultBold_: -*-*-bold-r-normal-*-*-%d-*-*-*-*-*-*
+  wxApp.ScreenRoman__: ${ScreenDefault,$[weight],_}
+
+Since "$[weight]" is set off by commas, it can be wildcarded if no
+name excatly matching "SchemeDefault$[weight]_" is found. In this case
+"SchemeDefault" and "_" can also be wildcarded, but this will have no
+effect.
+
+
+1.2 Internal Resources
+----------------------
+
+The initial font setup is built into MrEd through a built-in resource
+table. This table is shown in the appendix. When font information is
+looked up, it is *almost* as if this table were installed into your
+resources file; the difference is that resource specifications in your
+file can override specifications in the built-in table, even when the
+wildcarding of your resource provides a weaker match.
+
+
+1.3 Lookup Failures
+-------------------
+
+When no information is available mapping a non-core abstract font to a
+real font for the screen, the abstract font name is used as the font
+name. This heuristic means that MrEd generally does the expected thing
+when a program provides an arbitrary platform-specific face name to a
+wx:font constructor (see section 2.).
+
+The core abstract fonts all have defaults screen real fonts used as a
+last resort. Under Windows and MacOS, these real fonts correspond to
+the default font suggested by the font's abstract font (or associated
+abstract font in the case of non-core abstract fonts).
+
+
+-----------------------------------------------
+    2. wx:font%
+-----------------------------------------------
+
+The remaining question is how MrEd maps information specified in
+wx:font% constructions to obtain real fonts via the abstract font
+mapping:
+
+ * If only a "family" is supplied to wx:font%, the corresponding
+   core abstract font is used.
+
+ * If a "face name" is supplied to wx:font%, then the face name
+   is used as a new abstract font name. The provided "family"
+   specifies the associated core abstract font.
+
+That's it. Sounds too easy? Then you didn't read the preceding
+sections closely enough.
+
+------------------------------------
+    Appendix: Built-in Resources
+------------------------------------
+ 
+ FamilyDefault: Default
+ FamilyRoman: Roman
+ FamilyDecorative: Decorative
+ FamilyModern: Modern
+ FamilyTeletype: Teletype
+ FamilySwiss: Swiss
+ FamilyScript: Script
+ FamilySystem: System
+
+ AfmMedium: 
+ AfmLight: 
+ AfmStraight: 
+ AfmItalic: ${AfmSlant}
+ 
+ Afm___: ${AfmTimes,$[weight],$[style]}
+ 
+ AfmTimes__: ${AfmTimes}${Afm$[weight]}${Afm$[style]}
+ AfmTimesMediumStraight: ${AfmTimes}${AfmRoman}
+ AfmTimesLightStraight: ${AfmTimes}${AfmRoman}
+ AfmTimes_Italic: ${AfmTimes}$[weight]${AfmItalic}
+ AfmTimes_Slant: ${AfmTimes}$[weight]${AfmItalic}
+ 
+ AfmSwiss__: ${AfmHelvetica}${Afm$[weight]}${Afm$[style]}
+ AfmModern__: ${AfmCourier}${Afm$[weight]}${Afm$[style]}
+ 
+ AfmTeletype__: ${AfmModern,$[weight],$[style]}
+ 
+ 
+ PostScriptMediumStraight: 
+ PostScriptMediumItalic: -Oblique
+ PostScriptMediumSlant: -Oblique
+ PostScriptLightStraight: 
+ PostScriptLightItalic: -Oblique
+ PostScriptLightSlant: -Oblique
+ PostScriptBoldStraight: -Bold
+ PostScriptBoldItalic: -BoldOblique
+ PostScriptBoldSlant: -BoldOblique
+
+ PostScriptTimesMedium: 
+ PostScriptTimesLight: 
+ PostScriptTimesBold: Bold
+
+ PostScriptTimes__: Times${PostScript$[weight]$[style]}
+ PostScriptTimesMediumStraight: Times-Roman
+ PostScriptTimesLightStraight: Times-Roman
+ PostScriptTimes_Slant: Times-${PostScriptTimes$[weight]}Italic
+ PostScriptTimes_Italic: Times-${PostScriptTimes$[weight]}Italic
+ 
+ PostScriptSwiss__: Helvetica${PostScript$[weight]$[style]}
+ PostScriptModern__: Courier${PostScript$[weight]$[style]}
+ 
+ PostScriptTeletype__: ${PostScriptModern,$[weight],$[style]}
+
+ PostScript___: ${PostScriptTimes,$[weight],$[style]} 
+ 
+
+X Windows only:
+
+ AfmBold: Bo
+ AfmSlant: O
+ AfmRoman: Ro
+ AfmTimes: Times
+ AfmHelvetica: Helv
+ AfmCourier: Cour
+ 
+ ScreenMedium: medium
+ ScreenBold: bold
+ ScreenLight: light
+ ScreenStraight: r
+ ScreenItalic: i
+ ScreenSlant: o
+ 
+ ScreenDefaultBase: misc-fixed
+ ScreenRomanBase: *-times
+ ScreenDecorativeBase: *-helvetica
+ ScreenModernBase: *-courier
+ ScreenTeletypeBase: *-courier
+ ScreenSwissBase: *-lucida
+ ScreenScriptBase: *-zapfchancery
+
+ ScreenStdSuffix: -${Screen$[weight]}-${Screen$[style]}-normal-*-*-%d-*-*-*-*-*-*
+
+ ScreenDefault__: +-${ScreenDefaultBase}${ScreenStdSuffix}
+ ScreenRoman__: +-${ScreenRomanBase}${ScreenStdSuffix}
+ ScreenDecorative__: +-${ScreenDecorativeBase}${ScreenStdSuffix}
+ ScreenModern__: +-${ScreenModernBase}${ScreenStdSuffix}
+ ScreenTeletype__: +-${ScreenTeletypeBase}${ScreenStdSuffix}
+ ScreenSwiss__: +-${ScreenSwissBase}${ScreenStdSuffix}
+ ScreenScript__: +-${ScreenScriptBase}${ScreenStdSuffix}
+
+
+Windows/MacOS only:
+
+ AfmBold: bo
+ AfmSlant: ob
+ AfmRoman: ro
+ AfmTimes: time
+ AfmHelvetica: helv
+ AfmCourier: cour  
+ 
+
+Windows only:
+
+ Screen___: MS Sans Serif
+ ScreenRoman__: Times New Roman
+ ScreenDecorative__: Modern
+ ScreenModern__: Courier New
+ ScreenTeletype__: ${ScreenModern$[weight];$[style]}
+ ScreenSwiss__: Arial
+ ScreenScript__: Script
+ 
+MacOS only:
+
+ ScreenDefault__: applicationfont
+ ScreenSystem__: systemfont
+ ScreenRoman__: times
+ ScreenDecorative__: geneva
+ ScreenModern__: monaco
+ ScreenTeletype__: ${ScreenModern,$[weight],$[style]}
+ ScreenSwiss__  helvetica
+ ScreenScript__: geneva
diff --git a/src/mred/HISTORY b/src/mred/HISTORY
new file mode 100644
index 0000000..06ed948
--- /dev/null
+++ b/src/mred/HISTORY
@@ -0,0 +1,409 @@
+Version 51: ??, 1997
+X Windows: window manager close-frame request is ignored
+ when a modal dialog is in control
+Added security so that wx:snip% methods cannot be overridden 
+ to crash MrEd
+Fixed wx:canvas% scrolling on all platforms; the style flags
+ wx:const-hscroll and wx:const-vscroll must be used at
+ canvas-creation to set up for scrolling. Removed the
+ enable-scrolling method from wx:canvas%. Renamed the method
+ get-scroll-page-units to get-scroll-units. Added methods
+ get-scroll-pos, get-scroll-range, and get-scroll-page.
+The wx:canvas% wx:const-backingstore and wx:const-retained
+ style flags have been removed.
+Removed wx:key-event%'s position method and added get-x,
+ get-y, set-x, and set-y
+Changed default pen in DC to width 0 instead of 1
+Added get-max-view method to wx:media-admin%
+Revised wx:media-buffer%'s cursor system for better 
+ cooperation with embedded buffers; instead of handling
+ the cursor in on-default-event, added a method adjust-cursor
+ to buffers and snips, and replaced admin's set-cursor with
+ update-cursor
+Added refresh-delayed? predicate to wx:media-buffer%, useful
+ for deciding whether a buffer (or one of its enclosing 
+ buffers) is in an edit-sequence
+Added a --pre flag for evaluating an expression in a 
+ MzScheme-only namespace at startup. This flag is intended
+ for use with image dumps (see the MzScheme manual)
+Removed wx:copy-file; MzScheme now has copy-file
+Fixed wx:media-stream-in%'s get-string (it was adding an
+ extra nul character)
+Removed error dialogs when wx:media-buffer%'s load-file or
+ save-file fails
+Windows: fixed canvas mouse events; button-down event grabs
+ the mouse until the next button-up event
+Windows: fixed initial setting of DC text mode: transparent
+ instead of opaque
+X Windows: fixed wx:frame's iconize and iconized? methods,
+ ignoring the X idea of not de-iconifying windows that were 
+ iconified by the user
+Removed wx:exit
+
+Version 50: August 26, 1997
+Changed wx:dc%'s get-size method to return size of
+ destination area; old [documented] functionality
+ is available via max-x and max-y
+Made button-click state visible for Xt on b&w displays
+Fixed and normalized PostScript drawing
+Removed wx:dc% methods: device-to-logical-x, etc.
+Windows wx:display-size changed to return the size of the
+ screen not including the task bar
+Windows: finally fixed scale for [non-PostScript] printing
+Added wx:[un]register-collecting-blit
+X Windows: Fixed use of colormap by loaded bitmap images
+Added an optional argument to wx:media-buffer's print method
+ to supporting fitting to the destination page
+X Windows: Saving as xbm works for bitmaps of any depth
+MzScheme pathname expansion performed by all wx: toolbox
+ procedures that take a pathname
+X Windows Xt: removed excessive borders on wx:canvas% objects
+X Windows Xt: removed 2 pixel offset for a single auto-sized
+ child in a wx:frame% or wx:dialog-box%
+Windows: Fixed scrollbars on editor buffers; they're always
+ shown now, but the editor never gets confused about the size
+Fixed on-size, pre-on-char, and pre-on-event for wx:item% 
+ subclasses
+Fixed confusing argument type and number error messages
+ for overloaded methods of primitive classes
+
+Version 49: May 31, 1997
+Object system changes: see mzscheme/HISTORY for details
+Fixed Mac event-handling and many other Mac things
+Fixed garbage collection of hidden frames under Windows (!)
+Panels, canvases, and controls that are both hidden and
+  inaccessible are now garbage-collected
+Disabled controls are reliably grayed-out, including items 
+  within a disabled panel 
+Instances of wx:pen%, wx:brush%, or wx:pen% that are
+  selected into a drawing context cannot be mutated
+Immutability of objects obtained via wx:the-XXX-list is
+  enforced
+Controls for Windows, Xt are created with the "System" family
+  rather than the "Default" family (using resources)
+Single wx:bitmap% object can be used by multiple controls
+  and/or pens and/or brushes
+Fixed Motif image-label radio button
+wx:find-directory replaced with wx:find-path
+All wx:dc% instances have a default font for drawing
+wx:const-copy blit never uses the pen/background color;
+  new blit mode wx:const-colour uses current pen
+X Windows: removed mapping of Mod3 to Alt (too confusing on
+  keyboards where NumLock is Mod3)
+Fixed wx:timer% bug that caused autosaving to not work
+Fixed eventspace bugs
+Fixed .bmp reading when smaller-than-max colormap is provided
+Fixed interlaced .gif reading for Windows and MacOS
+Xt: fixed default height of wx:text% items
+Xt: In a wx:mouse-event% instance, type wx:const-type-XXX-down
+  implies get-XXX-down => #t (formerly #f)
+Removed wx:group-box% class; use a panel with a border, instead
+Removed wx:tool-bar% class
+wx:choice% get-columns and set-columns no longer supported
+Added wx:gauge% methods: get-value and get-range
+wx:media-pasteboard% bug fixes and improvements: raise, lower, 
+  set-before, and set-after methods now work
+wx:list-box% set-client-data and get-client-data work with
+  any Scheme data type
+Windows and X Windows: Break key changed back to shift-ctl-c 
+  instead of ctl-c (to avoid conflicts with Emacs-std keyboard
+  mappings)
+
+Version 48: Skipped to avoid confusion with Scheme48
+
+Version 47: January 11, 1997
+WARNING: multiple inhertance is going away in 48
+Added overwrite-styles? arg to wx:media-buffer%'s read-from-file,
+  and added get-/set-load-overwrites-styles methods
+Modified wx:media-buffer%'s set-caret-owner to provide more
+  levels of focus control
+Controls with bitmap labels work correctly, fixed crashing bugs,
+  some Mac controls do not display yet
+wx:bitmap%'s load-file only allowed when the bitmap is not selected
+  into a wx:memory-dc% object or used by a control
+
+Version 46: December 5, 1996
+Fixed misc. Motif control-sizing problems
+Mac & Xt: "&" stripped from control labels correctly
+wx:yield takes an optional semaphore argument
+
+Version 45: November 12, 1996
+IMPORTANT: let-values is now analogous to let; the old 
+  let-values is now let*-values
+Added thread-savy parameterization system; namespace system changed
+Added eventspaces
+wx:server%, wx:client%, and wx:connection% are no longer supported
+  (Better TCP support is now built into MzScheme)
+wx:the-snip-class-list was replaced by (wx:get-the-snip-class-list)
+wx:the-buffer-data-class-list was replaced by (wx:get-the-buffer-data-class-list)
+Added transparent text backing for editor text
+Added wx:dc% try-colour method
+wx:window% capture-mode, release-mouse, and make-modal no longer supported
+  Modal dialogs can be used instead of make-modal (modal is
+  specified through the constructor). There is currently no
+  replacement for capture-mouse and release-mouse, but a replacement is
+  likely to be in 46.
+Xt and Mac: "&" stripped from control labels (matches Windows/Motif), sortof
+
+Version 44: September 9, 1996
+wx:play-sound added
+Saving bitmaps fixed on all platforms; editor can now save 
+  "inlined" images instead of only references to images
+Hyper-text browser handles HTML files (w/o networking)
+Fixed Mac control drawing and hiding
+Fixed Xt menus (finally!)
+Fixed menu item auto-check for popup menus
+Fixed Motif canvas click event reporting (spurious drags)
+See also mzscheme/HISTORY, wxme/README, and system/HISTORY
+Upgraded to gc 11alpha3
+
+Version 43: Re-released August 12, 1996
+Under GNU LGPL license
+
+Version 43: August 9, 1996
+Major system overhaul (Robby Findler); see system/HISTORY
+Windows stability greatly advanced
+Windows and MacOS versions much more "Windows-like" and "Mac-like"
+  with standard menu shortcuts and better icons
+MacOS and Windows use native print facilities
+GIF images supported under Windows
+wx:window set-client-size removed
+wx:panel%'s get-cursor renamed to get-item-cursor; added set-item-cursor
+Fixed cut-n-paste newlines under MacOS and Windows
+Xt: panel with one item no longer auto-sizes the child
+See also mzscheme/HISTORY
+
+Version 42: June 8, 1996
+Documentation translated to Scheme notation, corrected
+Windows update bug fixed for embedded buffers
+MacOS memory use greatly improved
+Fixed annoying non-standard Windows beep
+Non-matching cond or case expression raises and error
+mred:platform and mred:window-system changed to wx:...
+standard system uses functors (see MzScheme)
+wx:canvas%::int-draw-line and wx:int-point% removed
+wx:list%, wx:hash-table%, wx:string-list%, wx:path-list removed
+wx:media-stream-in%::get removed for strings; use get-string
+Redundant wx: functions removed:
+  wx:dir-exists?  (use directory-exists?)
+  wx:file-exists? (use file-exists?)
+  wx:file-name-from-path (use file-name-from-path or split-path)
+  wx:path-only (use path-only or split-path)
+  wx:is-absolute-path? (use reletaive-path?)
+  wx:expand-path (use expand-path)
+  wx:get-working-directory (use current-directory)
+  wx:set-working-directory (use current-directory)
+  wx:mkdir (use make-directory)
+  wx:remove-file (use delete-file)
+  wx:rename-file (use rename-file)
+  wx:get-user-home and wx:get-home-dir (use expand-path with "~")
+  wx:execute and wx:shell (use system or process)
+  wx:find-first-file and wx:find-next-file (use get-directory-list)
+  wx:sleep (use sleep)
+  wx:sub-type? (use subclass?)
+  wx:to-lower (use char-upcase)
+  wx:to-upper (use char-downcase)
+  wx:is-wild? (use reg exps)
+  wx:match-wild? (use reg exps)
+
+Version 0.41: April 15, 1996
+Important language changes; see mzscheme/HISTORY
+Fixed bug in wxCanvas drawing methods
+Fixed wxCanvasDC and wxMemoryDC bugs in Xt version
+Pasteboards fixed
+AIX: two consecutive SIGDANGERs => exit(-1)
+wxGetMultipleChoice supported
+
+Version 0.40: March 24, 1996
+Possible improvements to memory system
+Some redundant event methods removed
+Finally fixed Windows NT/95 Scheme threads
+Stdout/stderr messages to a window instead of file for Windows/Mac+
+Fixed misc. Xt problems, including show-n-hide on frame
+
+Version 0.39: March 6, 1996
+Fixed safety from Scheme on invalidated C++ objects (stack objs, too)
+Fixed many bugs in Xt version
+Upgraded to gc version 4.10
+Reduced memory usage of buffer objects
+
+Version 0.38: February 22, 1996
+Xt port released
+Part of standard system moved to DrScheme
+See also mzscheme HISTORY and wxmedia README
+
+Version 0.37: Not released
+
+Version 0.36: January 18, 1996
+Fixed bug in MzScheme's bignum multiplication
+
+Version 0.35: January 17, 1996
+X selection protocol supported. To get the old clipboard-style
+  mechanism, add this to your .mredrc:
+     (wx:media-set-x-selection-mode #f)
+ See also wxMediaEdit::SetPosition() in the wxMedia manual.
+
+Version 0.34: December 30, 1995
+Minor improvements to MzScheme and the standard system
+
+Version 0.33: December 21, 1995
+MzScheme language changes; see mzscheme/HISTORY
+Old standard system no longer compatible
+Project system improved
+Many bugs fixed in the new standard system
+
+Version 0.32: December 4, 1995
+New standard system:
+  * The console I/O is completely different. It works more
+     like an Emacs shell. Use M-p and M-n to access previously
+     entered expressions. (read) will now read from the console.
+  * All mred:std-<x> variables have been eliminated. For each
+     mred:<x>%, there is now a procedure mred:make-<x>% that takes a
+     superclass and returns a new class.
+  * The frame and buffer hierarchies have changed a little.
+  * From a mred:edit% object, you can get to its canvas or frame.
+  * The menubar/menu system is completely revised. You don't have to
+     deal with menu ids much anymore. Menus and menu items can now be 
+     dynamically added and removed.
+  * Keymap chaining works differently.
+  * The new Scheme project system is roughly in place. This will let you
+     develop Scheme programs by organizing Scheme files within a project.
+     Projects help manage loading program files into the
+     evaluator and uses Shriram's Zodiac/Aries packages to
+     provide debugging facilities. This will be improved in the near 
+     future.
+ The old standard system is available in the "oldsys" directory.
+Pretty printer handles loops and graphs
+Very limited support for wxYield under XView - will be extended
+Fixed some wxMedia bugs (see wxme/README)
+Fixed some MzScheme bugs (see mzscheme/HISTORY)
+
+Version 0.31: November 14, 1995
+Fixed some wxMedia bugs (see wxme/README)
+Fixed some MzScheme bugs (see mzscheme/HISTORY)
+Parameterization for Macintosh
+
+Verion 0.30: October 25, 1995
+Added call-with-values and regexp to MzScheme
+Unix stack-checking setup code fixed in MzScheme
+wxMediaPasteboard implemented more
+Scheme-C++ object link changed; use ptr in all C++ objects
+Added tutorial section to "User Manual"
+
+Version 0.29: October 18, 1995
+Editor can save text preserving automatic CR
+Bug fix in automatic line-wrapping
+New font system can access arbitrary fonts
+Multiple displays in Motif: wx:set-display and wx:get-display-name
+MzScheme fix for forms such as (let ([x (let ...)]) ...)
+
+Version 0.28: October 3, 1995
+MzScheme bug fix: stack-checking on Unix
+wxMedia fix: Insert(unsigned char, ...) instead of Insert(char, ...)
+ and proper use of `unsigned' in word-breaking array access
+
+Version 0.27: September 29, 1995
+Major MzScheme upgrade, including multiple inheritance
+ (See MzScheme HISTORY for details)
+Win32: Allow deeper recursion by copying the stack
+Win32: Allow breaking with Shift-Ctl-C
+New font configuration system
+
+Version 0.26: September 8, 1995
+Very minor changes
+Bug fix to MzScheme for Win32s
+
+Version 0.25: September 7, 1995
+Upgraded to wxWindows 1.63
+Minor bug fixes
+
+Version 0.24: September 1, 1995
+Minor bug fixes
+
+Version 0.23: August 23, 1995
+Minor bug fixes
+Editor can display images (types depend on wxWindow compile flags)
+MzScheme correction: expand & expand-once
+
+Version 0.22: August 17, 1995
+Mostly MzScheme improvements
+File-format bug fixed related to portability; To make files created 
+  earlier portable, open and re-save them.
+
+Version 0.21: August 8, 1995
+Bug fixes
+triggers, hash tables, and case-lambda added to MzScheme
+MzScheme "sleeps" properly
+Connected MrEd to wxWindow's layout constraint system
+
+Version 0.20: July 26, 1995
+MzScheme Bug fixes
+
+Version 0.19: July 25, 1995
+All "!"s removed from method names!!!!!
+Full continuations and bignums added to MzScheme
+Bug Fixes
+
+Version 0.18: July 20, 1995
+Win32s kinda supported
+Bug fixes
+Added (compile ...) to MzScheme
+Added internal processes & threads to MzScheme
+wxSnipData -> wxBufferData
+Old process and system changed to process* and system*
+
+Version 0.17: July 11, 1995
+Bug fixes, especially Motif and memory bugs
+Rewrote editor line-maintenance
+Faster caret updating
+Upgraded garbage collector
+File format changed to accomodate nested buffers with
+  separate style lists
+Standard system standardized
+Code changes for compiling on MSWindows (almost works...)
+Scheme mode
+
+Version 0.16: June 16, 1995
+Fixed define-struct bug
+
+Version 0.15: June 15, 1995
+Bug fixes, especially XView
+make-input-port takes only 3 args; "unget" param dropped
+on-local-char & on-local-event renamed to on-default-char 
+  and on-default-event
+name changes: to have "!" or not to have "!". See doc/names.diff
+  for a list of changed names
+fonts configuarble through .Xdefaults; see MrEd.ad
+
+Version 0.14: June 9, 1995
+Bug fixes, including wxWindows widget table clash
+Scheme mode works
+error-handler changed to parameterizing function
+
+Version 0.13: June 5, 1995
+MzScheme replaced libscheme
+ctl-c breaks Scheme evaluation in MrEd
+libscheme/ changed to mzscheme/ - change your make.env!
+
+Version 0.12: June 1, 1995
+Bug fixes
+Revised object system: requires (inherit ...) declarations
+(pretty-print ...) installed
+
+Version 0.11: May 19, 1995
+Bug Fixes
+
+Version 0.10: May 19, 1995
+Bug fixes
+(match ...) installed
+
+Version 0.9: May 18, 1995
+wxMediaPasteboard
+
+Version 0.8: May 11, 1995
+Bug fixes
+
+Version 0.7: May 10, 1995
+mred:default-<x> changed to mred:<x> in system
+README in demo directory
+Lots of bug fixes
diff --git a/src/mred/LICENSE b/src/mred/LICENSE
new file mode 100644
index 0000000..4cf2ad6
--- /dev/null
+++ b/src/mred/LICENSE
@@ -0,0 +1,52 @@
+MrEd
+Copyright (c) 1995-96 PLT, Rice University
+
+MrEd is distributed under the GNU Library General Public License
+(LGPL).  This means you can link MrEd into proprietary applications,
+provided you follow the specific rules stated in the LGPL.  You can
+also modify MrEd; if you distribute a modified version, you must
+distribute it under the terms of the LGPL, which in particular means
+that you must release the source code for the modified MrEd. See
+COPYING.LIB for more information.
+
+MrEd is based on:
+
+  wxWindows
+  Copyright (c) 1994 Artificial Intelligence Applications Institute,
+                     The University of Edinburgh
+  All rights reserved.
+
+and/or
+
+  wxWindows Xt
+  Copyright (c) 1994 Artificial Intelligence Applications Institute,
+                     The University of Edinburgh
+  Copyright (c) 1995 GNU (Markus Holzem)
+  All rights reserved.
+
+  Therefore, the "Xt" version of MrEd is under the GNU General Public 
+  License.
+
+and
+
+  MzScheme
+  Copyright (c) 1995-97 PLT (Matthew Flatt)
+  All rights reserved.
+
+and
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+
+and
+
+  Conservative garbage collector
+  Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+  Copyright (c) 1991-1994 by Xerox Corporation.  
+  All rights reserved.
+
+  C++ extension by Jesse Hull and John Ellis
+  Copyright (c) 1994 by Xerox Corporation.  
+  All rights reserved.
+
diff --git a/src/mred/Makefile b/src/mred/Makefile
new file mode 100644
index 0000000..79b4a2c
--- /dev/null
+++ b/src/mred/Makefile
@@ -0,0 +1,187 @@
+
+include $(WXDIR)/src/make$(MZPLATFORMSUFFIX).env
+
+OBJDIR=objects/sys$(MZPLATFORMSUFFIX)$(GUISUFFIX)
+LIBDIR=lib/sys$(MZPLATFORMSUFFIX)
+MZLIBDIR=$(LIBDIR)$(MZTHREADSUFFIX)
+
+MZSCHEMELDFLAGS = -L../mzscheme/$(LIBDIR)/
+MZSCHEMELDLIBS = -lmzscheme -lgc
+
+WXSCHEMELDFLAGS = -Lwxs/$(OBJDIR)
+WXSCHEMELDLIBS = -lwxscheme
+
+WXMELDFLAGS = -Lwxme/$(OBJDIR)
+WXMELDLIBS = -lwxme
+
+MREDLDFLAGS = $(LDFLAGS) $(MZSCHEMELDFLAGS) $(WXSCHEMELDFLAGS) $(WXMELDFLAGS)
+MREDLDLIBS = $(MZSCHEMELDLIBS) $(WXSCHEMELDLIBS) $(WXMELDLIBS) $(LDLIBS) $(LDNONSTATICLIBS)
+
+MREDOBJECTS = $(OBJDIR)/mred.o $(OBJDIR)/mredx.o
+
+MRED = $(MRBUILDDIR)mred
+MZSCHEME = ../mzscheme/$(MZLIBDIR)/libmzscheme.a ../mzscheme/$(MZLIBDIR)/libgc.a
+WXSCHEME = wxs/$(OBJDIR)/libwxscheme.a
+WXME = wxme/$(OBJDIR)/libwxme.a
+
+INSTALLDEST=/home/scheme/plt
+
+MRSTATIC = 
+MRSTATIC_STUB =
+
+MRCHECK =
+
+# For SGIs and gcc 2.7.2, I needed a hack
+# (not needed with CC)
+SGILINKHACK =
+# SGILINKHACK = $(OBJDIR)/sgilinkhack.o
+
+EXPORT = CC='$(CC)' CXX='$(CXX)' AS='$(AS)' RANLIB='$(RANLIB)' DEBUGFLAGS='$(DEBUGFLAGS)' OPTIONS='$(OPTIONS)' THREADFLAGS='$(THREADFLAGS)' WARN='$(WARN)' OPT='$(OPT)' $(MZEXTRAEXPORT)
+
+# Used for distribution
+HIDEDIR = /home/mflatt/mredhide
+FTPDIR = /home/scheme/FTP/plt/staging
+
+all:  objects $(OBJDIR)
+	cd ../mzscheme; $(MAKE) $(EXPORT) mzschemelib++
+	cd wxs; $(MAKE)
+	cd wxme; $(MAKE)
+	cd wxme; $(MAKE) $(OBJDIR)/edjr.o
+	$(MAKE) $(MRED) MRCHECK='$(MRCHECK)'
+
+bin:
+	$(MAKE) $(MRED)
+
+checked:
+	$(MAKE) all MRCHECK='$(OBJDIR)/checkm.o'
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+$(MRED) : $(WXME) $(WXSCHEME) $(MZSCHEME) $(MREDOBJECTS) wxme/$(OBJDIR)/edjr.o \
+          $(WXDIR)/$(LIBDIR)/libwx$(GUISUFFIX).a \
+          $(MRSTATIC_STUB) $(MRCHECK)
+	$(LINKER) $(MREDLDFLAGS) $(MRSTATIC) -o $(MRED) $(LDSTARTERS) $(MREDOBJECTS) wxme/$(OBJDIR)/edjr.o $(MRCHECK) $(MREDLDLIBS) $(MRSTATIC_STUB) $(SGILINKHACK) $(LDENDERS)
+
+sunos4-static: $(OBJDIR)/dl_stub.o
+	$(MAKE) $(MRED) MRSTATIC=-static  MRSTATIC_STUB='$(OBJDIR)/dl_stub.o' LDNONSTATICLIBS=''
+
+solaris-static:
+	$(MAKE) $(MRED) MRSTATIC="-Wl,-Bstatic" LDNONSTATICLIBS='-Wl,-Bdynamic -ldl -Wl,-Bstatic'
+
+$(OBJDIR)/checkm.o: misc/checkm.c
+	$(CC) $(CFLAGS) $(LOCALFLAGS) -c misc/checkm.c -o $(OBJDIR)/checkm.o
+
+wx:
+	cd $(WXDIR)/src/x; $(MAKE) -f makefile.unx
+
+$(OBJDIR)/mred.o : mred.cxx wxme/wx_media.h wxme/wx_medad.h wxs/wxscheme.h ../mzscheme/include/scheme.h mred.h
+	$(CXX) $(CPPFLAGS) $(LOCALFLAGS) -c mred.cxx -o $(OBJDIR)/mred.o
+
+$(OBJDIR)/mredx.o : mredx.cxx ../mzscheme/include/scheme.h mred.h
+	$(CXX) $(CPPFLAGS) $(LOCALFLAGS) -c mredx.cxx -o $(OBJDIR)/mredx.o
+
+$(OBJDIR)/dl_stub.o: misc/dl_stub.c
+	$(CC) $(CPPFLAGS) $(LOCALFLAGS) -c misc/dl_stub.c -o $(OBJDIR)/dl_stub.o
+
+$(OBJDIR)/sgilinkhack.o:
+	$(CXX) $(CPPFLAGS) $(LOCALFLAGS) -c misc/sgilinkhack.cxx -o $(OBJDIR)/sgilinkhack.o
+
+$(WXDIR)/$(LIBDIR)/libwx$(GUISUFFIX).a:
+	echo Updating $(WXDIR)/$(LIBDIR)/libwx$(GUISUFFIX).a
+	$(MAKE) wx
+
+depend:
+	cd wxs; $(MAKE) depend
+	cd ../mzscheme; $(MAKE) depend
+
+TILDES=*~ ../collects/mrdemo/*~ demo/turtles/*~ demo/morph/*~ system/*~ collects/mred/*~ tests/*~ misc/*~ windows/*~ ../*~
+
+clean:
+	rm -rf objects/*/*.o $(TILDES) core
+	cd wxme; $(MAKE) clean
+	cd wxs; $(MAKE) clean
+	cd ../mzscheme; $(MAKE) clean
+
+exile:
+	rm -rf $(TILDES) core
+	mkdir $(HIDEDIR)/mred_objects
+	mv objects .bin $(HIDEDIR)/mred_objects
+	mv mred.exe $(HIDEDIR)/mred_objects
+	cd ../mzscheme; $(MAKE) exile
+	cd wxs; $(MAKE) HIDEDIR='$(HIDEDIR)' exile
+	cd wxme; $(MAKE) HIDEDIR='$(HIDEDIR)' exile
+	rm tests/RCS
+	rm ../collects/icons
+	rm ../collects/make/RCS
+
+repatriate:
+	mv $(HIDEDIR)/mred_objects/objects .
+	mv $(HIDEDIR)/mred_objects/.bin .
+	mv $(HIDEDIR)/mred_objects/mred.exe .
+	rmdir $(HIDEDIR)/mred_objects
+	cd ../mzscheme; $(MAKE) repatriate
+	cd wxs; $(MAKE) HIDEDIR='$(HIDEDIR)' repatriate
+	cd wxme; $(MAKE) HIDEDIR='$(HIDEDIR)' repatriate
+	/bin/ln -s /home/scheme/plt/tests/mred/RCS tests/RCS
+	/bin/ln -s /home/scheme/plt/collects/icons ../collects/icons
+	/bin/ln -s /home/scheme/plt/collects/make/RCS ../collects/make/RCS
+
+bundle:
+	# $(MAKE) exile
+	rm -rf mred
+	$(MAKE) bundle-wxme
+	$(MAKE) bundle-mzscheme
+	$(MAKE) bundle-self
+
+bundle-wxme:
+	tar -cf wxmedia.tar wxme
+	mv wxmedia.tar ../
+	cd ..; gzip wxmedia.tar
+	cd ..; mv wxmedia.tar.gz $(FTPDIR)/wxmedia/
+	rm -f $(FTPDIR)/wxmedia/wxmedia.zip
+	zip -r $(FTPDIR)/wxmedia/wxmedia.zip wxme
+
+bundle-mzscheme:
+	cd ..; tar -cf mzscheme.src.tar mzscheme
+	cd ..; gzip mzscheme.src.tar
+	cd ..; mv mzscheme.src.tar.gz $(FTPDIR)/mzscheme/
+	rm -f $(FTPDIR)/mzscheme/mzsrc.zip
+	cd ..; zip -r $(FTPDIR)/mzscheme/mzsrc.zip mzscheme
+
+bundle-self:
+	cd ..; tar -cf mred.src.tar mred
+	cd ..; gzip mred.src.tar
+	cd ..; mv mred.src.tar.gz $(FTPDIR)/mred/
+	rm -f $(FTPDIR)/mred/mredsrc.zip
+	cd ..; zip -r $(FTPDIR)/mred/mredsrc.zip mred
+
+install:
+	# cd system; rm -rf *~ core
+	# cd system/hyper; rm -rf *~ core
+	# cp -r system $(INSTALLDEST)/system
+	cp MrEd.ad $(INSTALLDEST)/notes/mred/MrEd.ad
+	cp LICENSE COPYING.LIB HISTORY FONTS mred.txt fonts12.mre fontsall.mre openbugs \
+            $(INSTALLDEST)/notes/mred
+	cp mred.sh $(INSTALLDEST)/bin/mred
+	cp mred.ini $(INSTALLDEST)/notes/mred/mred.ini
+	cp mred.fnt $(INSTALLDEST)/notes/mred/mred.fnt
+	cd tests; ci -l -mrelease *.ss README
+	cd $(INSTALLDEST)/tests/mred; co RCS/*
+	$(MAKE) install-demo
+
+install-demo:
+	cd ../collects/mrdemo; rm -f *~
+	rm -rf $(INSTALLDEST)/collects/mrdemo/*
+	cp -r ../collects/mrdemo/* $(INSTALLDEST)/collects/mrdemo
+
+asia:
+	rdist -m asia
+
+hk:
+	rdist -m hk
+
+stan:
+	rdist -m stan
diff --git a/src/mred/MrEd.ad b/src/mred/MrEd.ad
new file mode 100644
index 0000000..d8dcde0
--- /dev/null
+++ b/src/mred/MrEd.ad
@@ -0,0 +1,29 @@
+! MrEd resources:
+
+!  Font names
+mred.ScreenDefaultBase: *-courier
+mred.ScreenModernBase: misc-fixed
+mred.ScreenDecorativeBase: *-helvetica
+mred.ScreenScriptBase: *-charter
+mred.ScreenSwissBase: *-lucida
+mred.ScreenRomanBase: *-times
+
+!  Font size
+mred.defaultFontSize: 12
+
+!  Time between clicks for a double-click
+mred.doubleClickTime:   500
+
+!  Standard system's console (uncomment it to use)
+! *MrEdConsole.geometry: +40+40
+
+
+!  Indigo Magic look & feel
+! MrEd*useSchemes: all
+! MrEd*sgiMode: true
+! MrEd*schemeFileList: SgiSpec
+! MrEd*paletteFileList: FontPalette
+! MrEd*SgNuseEnhancedFSB: true
+
+!  SGI Style guide specifies pointer focus for applications
+! MrEd*keyboardFocusPolicy: pointer
diff --git a/src/mred/README b/src/mred/README
new file mode 100644
index 0000000..c579443
--- /dev/null
+++ b/src/mred/README
@@ -0,0 +1,35 @@
+
+This is MrEd for X Windows, Microsoft Windows, and MacOS. MrEd is
+described for new users in `mred.txt'. Old users should consult the
+HISTORY file for information about changes in this version.
+
+Please see the file LICENSE for license information.
+
+Documentation and up-to-date information about MrEd are at
+  http://www.cs.rice.edu/CS/PLT/packages/mred/
+
+Please report bugs using
+  http://www.cs.rice.edu/CS/PLT/Bugs/
+or (as a last resort) send mail to
+  plt-bugs@cs.rice.edu
+
+For more details on compiling and/or running MrEd, read `mred.txt' in
+this directory. For Win32 compilation, you will also need to consult
+the directory `windows'. Additional files for MacOS compilation are
+bundled with the MacOS version of MrEd's wxWindows.
+
+The following are miscellaneous files in this directory:
+   FONTS - Describes low-level font configuration
+   MrEd.ad - Some X resources
+   mred.ini - Some Windows resources
+   mred.fnt - Some MacOS "resources"
+   fonts12.mre - A MrEd-readable file showing 12-point fonts
+   fontsall.mre  - A MrEd-readable file showing lots of fonts
+   openbugs - known mred bugs
+
+-Matthew Flatt and Robby Findler
+ Rice University PLT
+ mflatt@cs.rice.edu
+ http://www.cs.rice.edu/~mflatt/
+ robby@cs.rice.edu
+ http://www.cs.rice.edu/~robby/
diff --git a/src/mred/fonts12.mre b/src/mred/fonts12.mre
new file mode 100644
index 0000000..74e90a8
Binary files /dev/null and b/src/mred/fonts12.mre differ
diff --git a/src/mred/fontsall.mre b/src/mred/fontsall.mre
new file mode 100644
index 0000000..7b00f0f
Binary files /dev/null and b/src/mred/fontsall.mre differ
diff --git a/src/mred/misc/checkm.c b/src/mred/misc/checkm.c
new file mode 100644
index 0000000..d9a20d3
--- /dev/null
+++ b/src/mred/misc/checkm.c
@@ -0,0 +1,261 @@
+
+/* Slow, but effective, memory debugging for Unix. */
+/* Run checkmem() to test memory consistency and get allocated bytes. */
+
+/* Replace GC routines, too? (Don't link with libgc.a.) */
+#define GC_too 0
+
+typedef long SPACE;
+#define SPACE_VAL 0x77777777
+#define CHAR_SPACE_VAL ((unsigned char)0x99)
+#define FREED_VAL 0x55555555
+
+static long total_allocated;
+
+typedef struct HEADER {
+  struct HEADER *prev;
+  struct HEADER *next;
+  unsigned long exact_len; /* 0 => free */
+  unsigned long len;
+  SPACE s;
+} HEADER;
+
+HEADER *chain_start, *chain_end;
+
+static long looking_for;
+
+void *malloc(unsigned long len)
+{
+  long pos, d, exact_len = len;
+  HEADER *h;
+
+  total_allocated += exact_len;
+
+  d = len % sizeof(long);
+  if (d)
+    len += (sizeof(long) - d);
+
+  pos = sbrk(len + sizeof(HEADER) + sizeof(SPACE));
+
+  if (pos == looking_for) {
+    /* Found it ... */
+    looking_for = 0;
+  }
+
+  h = (HEADER *)pos;
+  if (chain_end)
+    chain_end->next = h;
+  else
+    chain_start = h;
+  h->prev = chain_end;
+  h->len = len;
+  h->exact_len = exact_len;
+
+  h->s = SPACE_VAL;
+  
+  *(SPACE *)(pos + sizeof(HEADER) + len) = SPACE_VAL;
+  while (exact_len < len) {
+    *(unsigned char *)(pos + sizeof(HEADER) + exact_len) = CHAR_SPACE_VAL;
+    exact_len++;
+  }
+
+  chain_end = h;
+
+  return (void *)(pos + sizeof(HEADER));
+}
+
+void *realloc(void *p, unsigned long len)
+{
+  void *n;
+  unsigned long olen;
+
+  olen = ((HEADER *)((long)p - sizeof(HEADER)))->len;
+  if (olen > len)
+    return p;
+
+  n = malloc(len);
+
+  memcpy(n, p, olen);
+
+  free(p);
+
+  return n;
+}
+
+void *calloc(unsigned long len0, unsigned long len)
+{
+  void *v;
+
+  len *= len0;
+  v = malloc(len);
+  memset(v, 0, len);
+  return v;
+}
+
+void free(void *p)
+{
+  HEADER *h = (HEADER *)(((long)p) - sizeof(HEADER));
+  SPACE v;
+
+  if (!p)
+    return;
+
+  if (!h->exact_len) {
+    printf("%lx: double-free (%lx)\n", h, h->len);
+  } else {
+    int i;
+
+    if (h->s != SPACE_VAL)
+      printf("%lx: bad start for free (%lx)\n", h, h->s);
+
+    if (h->exact_len < h->len) {
+      for (i = h->exact_len; i < h->len; i++) {
+	v = (*(unsigned char *)((long)h + sizeof(HEADER) + i));
+	if (v != CHAR_SPACE_VAL)
+	  printf("%lx: bad inexact end for free (%lx)\n", h, v);
+      }
+    }
+
+    v = (*(SPACE *)((long)h + sizeof(HEADER) + h->len));
+    if (v != SPACE_VAL)
+      printf("%lx: bad end for free (%lx)\n", h, v);
+
+    for (i = h->len; i; ) {
+      i -= sizeof(long);
+      (*(long *)((long)h + sizeof(HEADER) + i)) = FREED_VAL;
+    }
+  }
+
+  total_allocated -= h->exact_len;
+
+  h->exact_len = 0;
+}
+
+unsigned long checkmem(void)
+{
+  HEADER *h, *prev = 0;
+  SPACE v;
+  unsigned long total_use = 0;
+
+  for (h = chain_start; h; prev = h, h = h->next) {
+    if (h->s != SPACE_VAL)
+      printf("%lx [after %lx]: bad start (%lx)\n", h, prev, h->s);
+
+    if (h->exact_len) {
+      total_use += h->exact_len;
+
+      if (h->exact_len < h->len) {
+	int i;
+	for (i = h->exact_len; i < h->len; i++) {
+	  v = (*(unsigned char *)((long)h + sizeof(HEADER) + i));
+	  if (v != CHAR_SPACE_VAL)
+	    printf("%lx: bad inexact end (%lx)\n", h, v);
+	}
+      }
+    } else {
+      int i;
+      for (i = h->len; i; ) {
+	i -= sizeof(long);
+	v = (*(long *)((long)h + sizeof(HEADER) + i));
+	if (v != FREED_VAL)
+	  printf("%lx: bad freed val (%lx)\n", h, v);
+      }
+    }
+
+    v = (*(SPACE *)((long)h + sizeof(HEADER) + h->len));
+    if (v != SPACE_VAL)
+      printf("%lx: bad end (%lx)\n", h, v);
+  }
+
+  return total_use;
+}
+
+long get_total(void)
+{
+  return total_allocated;
+}
+
+#if GC_too
+
+void (*GC_collect_start_callback)(void);
+void (*GC_collect_end_callback)(void);
+void (*GC_out_of_memory)(void);
+
+long GC_dl_entries;
+long GC_fo_entries;
+void *GC_changing_list_start, *GC_changing_list_current;
+
+void *GC_malloc(unsigned long len)
+{
+  return malloc(len);
+}
+
+void *GC_malloc_atomic(unsigned long len)
+{
+  return malloc(len);
+}
+
+void *GC_malloc_stubborn(unsigned long len)
+{
+  return malloc(len);
+}
+
+void *GC_malloc_uncollectable(unsigned long len)
+{
+  return malloc(len);
+}
+
+void GC_free(void *p)
+{
+}
+
+void GC_end_stubborn_change(void *p)
+{
+}
+
+void *GC_base(void *p)
+{
+  return 0;
+}
+
+void GC_general_register_disappearing_link(void)
+{
+}
+
+void GC_register_finalizer_ignore_self(void)
+{
+}
+
+void GC_register_finalizer(void)
+{
+}
+
+void GC_gcollect(void)
+{
+}
+
+void GC_dump(void)
+{
+}
+
+long GC_get_heap_size(void)
+{
+  return 0;
+}
+
+void GC_add_roots(void)
+{
+}
+
+void GC_set_warn_proc(void)
+{
+}
+
+void *GC_get_stack_base(void)
+{
+  void *dummy;
+
+  return (void *)(((char *)(&dummy)) + 3000);
+}
+
+#endif
diff --git a/src/mred/misc/dl_stub.c b/src/mred/misc/dl_stub.c
new file mode 100644
index 0000000..73973e6
--- /dev/null
+++ b/src/mred/misc/dl_stub.c
@@ -0,0 +1,31 @@
+/*
+  This is used for static-linking in UNIX when otherwise compiled for
+   dynamic linking.
+*/
+
+#include "scheme.h"
+#include <dlfcn.h>
+
+void *dlopen(const char *filename, int flags)
+{
+  scheme_signal_error("load-extension: can't use with a statically-linked"
+		      " MrEd");
+
+  return NULL;
+}
+
+char *dlerror()
+{
+  return NULL;
+}
+
+void *dlsym(void *dl, const char *name)
+{
+  return NULL;
+}
+
+int dlclose(void *dl)
+{
+  return -1;
+}
+
diff --git a/src/mred/misc/sgilinkhack.cxx b/src/mred/misc/sgilinkhack.cxx
new file mode 100644
index 0000000..36f50b6
--- /dev/null
+++ b/src/mred/misc/sgilinkhack.cxx
@@ -0,0 +1,11 @@
+
+class Iostream_init
+{
+public:
+  Iostream_init();
+  ~Iostream_init();
+};
+
+Iostream_init::~Iostream_init(void)
+{
+}
diff --git a/src/mred/mred.cxx b/src/mred/mred.cxx
new file mode 100644
index 0000000..c5d3128
--- /dev/null
+++ b/src/mred/mred.cxx
@@ -0,0 +1,2208 @@
+/*
+ * File:        mred.cc
+ * Purpose:     MrEd main file, including a hodge-podge of global stuff
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+ */
+
+/* wx_xt: */
+#define Uses_XtIntrinsic
+#define Uses_XtIntrinsicP
+#define Uses_XLib
+
+/* wx_motif, for wxTimer: */
+#ifdef __GNUG__
+# pragma implementation "wx_timer.h"
+#endif
+
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wx_main.h"
+#include "wx_buttn.h"
+#include "wx_messg.h"
+#include "wx_timer.h"
+#include "wx_media.h"
+#include "wx_dialg.h"
+#include "wx_cmdlg.h"
+#ifdef USE_SENORA_GC
+# include "wx_types.h"
+#endif
+#include "edjr.h"
+#ifdef wx_mac
+# include "simpledrop.h"
+#endif
+#ifdef wx_msw
+# include "wx_wmgr.h"
+#endif
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+#if defined(wx_mac) && defined(__MC68K__)
+# include "boundary.h"
+#endif
+
+/* Solaris: getdtablesize sometimes not available */
+#if !defined(USE_ULIMIT) && defined(sun) && defined(__svr4__)
+# define USE_ULIMIT
+#endif
+
+#if defined(wx_motif) || defined(wx_xt)
+# include <X11/Xlib.h>
+# include <X11/keysymdef.h>
+#endif
+
+#ifdef wx_x
+# include <sys/types.h>
+# include <sys/time.h>
+# include <unistd.h>
+#  if defined(_IBMR2)
+#   include <sys/select.h>
+#  endif
+# include <signal.h>
+#endif
+
+#ifdef wx_msw
+# ifdef _MSC_VER
+#  include <direct.h>
+# else
+#  include <dir.h>
+# endif
+#endif
+
+#ifdef wx_mac
+# include <unistd.h>
+# include <Events.h>
+#endif
+
+#if defined(wx_x) || defined(wx_msw)
+# define ADD_OBJ_DUMP 1
+#else
+# define ADD_OBJ_DUMP 0
+#endif
+
+#define INTERRUPT_CHECK_ON 0
+
+#ifdef INCLUDE_WITHOUT_PATHS
+# include "wxscheme.h"
+# include "wxsmred.h"
+# include "wxs_fram.h"
+# include "wxs_obj.h"
+#else
+# include "wxs/wxscheme.h"
+# include "wxs/wxsmred.h"
+# include "wxs/wxs_fram.h"
+# include "wxs/wxs_obj.h"
+#endif
+
+wxFrame *mred_real_main_frame;
+
+extern void wxMediaIOCheckLSB(void);
+
+#include "mred.h"
+
+#ifndef USE_SENORA_GC
+/* Force initialization of the garbage collector (currently needed
+   only when supporting Irix sprocs) */
+class GCInit {
+public:
+  GCInit() {
+    GC_INIT();
+  }
+};
+static GCInit _gcinit;
+#endif
+
+extern "C" char *scheme_get_thread_current_directory(Scheme_Process *p, int *len, int noexn);
+
+static Scheme_Env *global_env;
+
+class MrEdApp: public wxApp
+{
+public:
+  char *file, *collection;
+  Bool initialized;
+  Bool edjrMode;
+  int xargc;
+  char **xargv;
+
+  MrEdApp();
+  wxFrame *OnInit(void);
+  void RealInit(void);
+#ifdef wx_mac
+  char *GetDefaultAboutItemName();
+  void DoDefaultAboutItem();
+#endif
+  int OnExit(void);
+};
+
+#if !defined(wx_msw)
+MrEdApp *TheMrEdApp;
+#else
+MrEdApp _TheMrEdApp;
+#define TheMrEdApp (&_TheMrEdApp)
+#endif
+
+#ifdef wx_mac
+DialogPtr startup_dial;
+#endif
+
+#ifdef LIBGPP_REGEX_HACK
+/* Fixes weirdness with libg++ and the compiler: it tries to
+   destroy global regexp objects that were never created. Calling
+   the constructor forces the other global values to be initialized. */
+# include <Regex.h>
+#endif
+
+#ifdef wx_x
+extern Display *MrEdGetXDisplay(void);
+#endif
+
+/****************************************************************************/
+/*                               Contexts                                   */
+/****************************************************************************/
+
+MrEdContext *mred_contexts;
+static MrEdContext *mred_main_context;
+static MrEdContext *mred_only_context;
+static MrEdContextFrames *mred_frames;
+static wxTimer *mred_timers;
+int mred_eventspace_param;
+int mred_event_dispatch_param;
+Scheme_Type mred_eventspace_type;
+static Scheme_Object *def_dispatch;
+
+MrEdContext *MrEdGetContext(wxObject *w)
+{
+  if (w) {
+#if !defined(wx_xt) && !defined(wx_mac)
+    if (wxSubType(w->__type, wxTYPE_FRAME)) {
+#endif
+      MrEdContext *c;
+      c = (MrEdContext *)((wxFrame *)w)->context;
+      if (c) 
+	return c;
+#if !defined(wx_xt) && !defined(wx_mac)
+    } else {
+      MrEdContext *c;
+      c = (MrEdContext *)((wxDialogBox *)w)->context;
+      if (c) 
+	return c;
+    }
+#endif
+  }
+
+  if (mred_only_context)
+    return mred_only_context;
+  else
+    return (MrEdContext *)scheme_get_param(scheme_config, mred_eventspace_param);
+}
+
+void *wxGetContextForFrame()
+{
+  if (!TheMrEdApp)
+    return NULL;
+  else
+    return (void *)MrEdGetContext();
+}
+
+wxChildList *wxGetTopLevelWindowsList(wxObject *w)
+{
+  return MrEdGetContext(w)->topLevelWindowList;
+}
+
+wxWindow *wxGetModalWindow(wxObject *w)
+{
+  MrEdContext *c = MrEdGetContext(w);
+
+  return c->modal_window;
+}
+
+void wxPutModalWindow(wxObject *w, wxWindow *win)
+{
+  MrEdContext *c = MrEdGetContext(w);
+
+  c->modal_window = win;
+}
+
+wxStandardSnipClassList *wxGetTheSnipClassList()
+{
+  return MrEdGetContext()->snipClassList;
+}
+
+wxBufferDataClassList *wxGetTheBufferDataClassList()
+{
+  return MrEdGetContext()->bufferDataClassList;
+}
+
+int wxGetBusyState(void)
+{
+  MrEdContext *c = MrEdGetContext();
+
+  return c->busyState;
+}
+
+void wxSetBusyState(int state)
+{
+  MrEdContext *c = MrEdGetContext();
+
+  c->busyState = state;
+}
+
+Bool wxIsPrimEventspace()
+{
+  return MrEdGetContext() == mred_main_context;
+}
+
+static int num_contexts = 0;
+
+/* Forward decl: */
+static int MrEdSameContext(void *c, void *testc);
+
+static void destroy_wxObject(wxWindow *w, void *)
+{
+  if (w->__gc_external) {
+    objscheme_destroy(w, (Scheme_Object *)w->__gc_external);
+    ((Scheme_Class_Object *)w->__gc_external)->primflag = -2; /* -2 => shutdown */
+    w->__gc_external = NULL;
+  }
+}
+
+static void kill_eventspace(Scheme_Object *ec, void *)
+{
+  MrEdContext *c = (MrEdContext *)ec;
+
+  {
+    wxChildNode *node, *next;
+    for (node = c->topLevelWindowList->First(); node; node = next) {
+      wxWindow *w = (wxWindow *)node->Data();
+      next = node->Next();
+      if (w) {
+	if (node->IsShown())
+	  w->Show(FALSE);
+	w->ForEach(destroy_wxObject, NULL);
+      }
+    }
+  }
+
+  {
+    wxTimer *t, *next;
+    for (t = mred_timers; t; t = next) {
+      next = t->next;
+      if (t->context == (void *)c)
+	t->Stop();
+    }
+  }
+
+  scheme_remove_sema_callbacks(MrEdSameContext, c);
+}
+
+static void CollectingContext(void *cfx, void *)
+{
+  MrEdFinalizedContext *cf = (MrEdFinalizedContext *)cfx;
+
+  if (cf->frames->next)
+    cf->frames->next->prev = cf->frames->prev;
+  if (cf->frames->prev)
+    cf->frames->prev->next = cf->frames->next;
+  else
+    mred_frames = cf->frames->next;
+
+  /* Must explicitly delete frames now because their context
+     is going away. (The frame would certainly have been finalized
+     later during this set of finalizations, but that would be
+     too late.) */
+  wxChildNode *cnode, *next;
+  for (cnode = cf->frames->list->First(); cnode; cnode = next) {
+    next = cnode->Next();
+    wxFrame *fr = (wxFrame *)cnode->Data();
+    if (fr)
+      delete fr;
+  }
+
+  MrEdDestroyContext(cf);
+
+  delete cf->frames->list;
+  cf->frames = NULL;
+
+  --num_contexts;
+}
+
+static MrEdContext *MakeContext(MrEdContext *c, Scheme_Config *config)
+{
+  if (!c) {
+    c = new MrEdContext;
+
+    c->topLevelWindowList = new wxChildList();
+    c->snipClassList = wxMakeTheSnipClassList();
+    c->bufferDataClassList = wxMakeTheBufferDataClassList();
+    c->finalized = new MrEdFinalizedContext;
+  }
+
+  c->ready = 1;
+
+  c->handler_running = NULL;
+
+  c->wd = NULL;
+  c->wdlen = 0;
+
+  c->busyState = 0;
+
+  MrEdContextFrames *frames;
+  frames = c->finalized->frames = new MrEdContextFrames;
+  frames->next = mred_frames;
+  frames->prev = NULL;
+  frames->list = c->topLevelWindowList;
+  if (mred_frames)
+    mred_frames->prev = frames;
+  mred_frames = frames;
+
+  c->modal_window = NULL;
+
+  if (!config) {
+    config = (Scheme_Config *)scheme_branch_config();
+#if 0
+    scheme_set_param(config, MZCONFIG_CONFIG_BRANCH_HANDLER, 
+		     scheme_make_closed_prim_w_arity((Scheme_Closed_Prim *)scheme_make_config,
+						     config,
+						     "eventspace-parameterization-branch-handler",
+						     0, 0));
+#endif
+    scheme_set_param(config, mred_eventspace_param, (Scheme_Object *)c);
+  }
+
+  c->main_config = config;
+
+  scheme_register_finalizer((void *)c->finalized,
+			    CollectingContext, NULL,
+			    NULL, NULL);
+
+  num_contexts++;
+
+  c->type = mred_eventspace_type;
+  scheme_add_managed(NULL, (Scheme_Object *)c, kill_eventspace, NULL, 0);
+
+  return c;
+}
+
+static void ChainContextsList()
+{
+  MrEdContextFrames *f = mred_frames;
+  wxChildNode *first;
+  
+  mred_contexts = NULL;
+
+  while (f) {
+    first = f->list->First();
+
+    while (first && !first->IsShown())
+      first = first->Next();
+
+    if (first) {
+      wxObject *o = first->Data();
+      MrEdContext *c;
+      c = MrEdGetContext(o);
+      c->next = mred_contexts;
+      mred_contexts = c;
+    }
+    f = f->next;
+  }
+}
+
+static void UnchainContextsList()
+{
+  while (mred_contexts) {
+    MrEdContext *next = mred_contexts->next;
+    mred_contexts->next = NULL;
+    mred_contexts = next;
+  }
+}
+
+Scheme_Object *MrEdMakeEventspace(Scheme_Config *config)
+{
+  MrEdContext *c;
+
+  c = MakeContext(NULL, config);
+
+  MrEdInitNewContext(c);
+
+  return (Scheme_Object *)c;
+}
+
+Scheme_Object *MrEdEventspaceConfig(Scheme_Object *e)
+{
+  return (Scheme_Object *)((MrEdContext *)e)->main_config;
+}
+
+Scheme_Object *MrEdGetFrameList(void)
+{
+  MrEdContext *c = MrEdGetContext();
+  Scheme_Object *l = scheme_null;
+
+  if (c) {
+    wxChildNode *node;
+    for (node = c->topLevelWindowList->First(); node; node = node->Next()) {
+      wxObject *o = node->Data();
+      if (node->IsShown())
+	l = scheme_make_pair(objscheme_bundle_wxObject(o), l);
+    }
+  }
+
+  return l;
+}
+
+/****************************************************************************/
+/*                               Events                                     */
+/****************************************************************************/
+
+static wxTimer *TimerReady(MrEdContext *c)
+{
+  wxTimer *timer = mred_timers;
+  
+  if (c) {
+    while (timer && (timer->context != (void *)c))
+      timer = timer->next;
+  } else {
+    while (timer && !((MrEdContext *)timer->context)->ready)
+      timer = timer->next;
+  }
+
+  if (timer) {
+    unsigned long now = (unsigned long)scheme_get_milliseconds();
+    unsigned long goal = timer->expiration;
+    
+    return ((now >= goal)
+	    ? timer
+	    : (wxTimer *)NULL);
+  } else
+    return NULL;
+}
+
+static void DoTimer(wxTimer *timer)
+{
+  int once;
+
+  if (timer->interval == -1)
+    return;
+
+  once = timer->one_shot;
+  timer->one_shot = -1;
+
+  timer->Notify();
+
+  if (!once && (timer->one_shot == -1) && (timer->interval != -1))
+    timer->Start(timer->interval, FALSE);
+}
+
+static int check_for_nested_event(Scheme_Object *cx)
+{
+  MrEdContext *c = (MrEdContext *)cx;
+
+  return (!c->waiting_for_nested
+	  || (c->alternate
+	      && c->alternate(c->alt_data)));
+}
+
+static int MrEdSameContext(void *c, void *testc)
+{
+  return (c == testc);
+}
+
+static void GoAhead(MrEdContext *c)
+{
+  c->ready_to_go = 0;
+
+  if (c->sema_callback) {
+    c->sema_callback = 0;
+    (void)scheme_check_sema_callbacks(MrEdSameContext, c, 0);
+  } else if (c->timer) {
+    wxTimer *timer;
+    timer = c->timer;
+    c->timer = NULL;
+    DoTimer(timer);
+  } else {
+    MrEdEvent e;
+    
+    memcpy(&e, &c->event, sizeof(MrEdEvent));
+    
+    MrEdDispatchEvent(&e);
+  }
+}
+
+static Scheme_Object *def_event_dispatch_handler(int argc, Scheme_Object *argv[])
+{
+  MrEdContext *c;
+
+  c = (MrEdContext *)argv[0];
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), mred_eventspace_type)
+      || !c->ready_to_go) {
+    scheme_wrong_type("default-event-dispatch-handler",
+		      "eventspace (with ready event)",
+		      0, argc, argv);
+    return NULL;
+  }
+
+  GoAhead(c);
+
+  return scheme_void;
+}
+
+static void DoTheEvent(MrEdContext *c)
+{
+  Scheme_Object *a[1], *p;
+
+  c->ready_to_go = 1;
+
+  p = scheme_get_param(scheme_config, mred_event_dispatch_param);
+  if (p != def_dispatch) {
+    a[0] = (Scheme_Object *)c;
+    _scheme_apply_multi(p, 1, a);
+  }
+  
+  if (c->ready_to_go)
+    GoAhead(c);
+}
+
+void MrEdDoNextEvent(MrEdContext *c, int (*alt)(void *), void *altdata)
+{
+  wxTimer *timer;
+  Scheme_Config *save_config;
+
+  save_config = scheme_config;
+  scheme_config = c->main_config;
+
+  if (scheme_check_sema_callbacks(MrEdSameContext, c, 1)) {
+    c->sema_callback = 1;
+    DoTheEvent(c);
+  } else if ((timer = TimerReady(c))) {
+    timer->Dequeue();
+    c->timer = timer;
+    DoTheEvent(c);
+  } else if (MrEdGetNextEvent(0, 1, &c->event, NULL)) {
+    DoTheEvent(c);
+  } else if (c != mred_main_context) {
+    c->ready = 1;
+    c->waiting_for_nested = 1;
+
+    c->alternate = alt;
+    c->alt_data = altdata;
+
+    /* Temp restore config: */
+    scheme_config = save_config;
+
+    scheme_current_process->block_descriptor = -1;
+    scheme_current_process->blocker = (Scheme_Object *)c;
+    scheme_current_process->block_check = check_for_nested_event;
+    do {
+      scheme_process_block(0);
+    } while (!check_for_nested_event((Scheme_Object *)c));
+    scheme_current_process->block_descriptor = 0;
+    scheme_current_process->ran_some = 1;
+
+    /* un-'Temp restore config': */
+    scheme_config = c->main_config;
+
+    c->alternate = NULL;
+    c->alt_data = NULL;
+
+    if (c->waiting_for_nested) {
+      /* Alternate condition fired. Do nothing. */
+      c->ready = 0;
+      c->waiting_for_nested = 0;
+    } else
+      DoTheEvent(c);
+  }
+
+  scheme_config = save_config;
+}
+
+void wxDoNextEvent()
+{
+  MrEdContext *c = MrEdGetContext();
+
+  if (!c->ready_to_go)
+    if (c->handler_running == scheme_current_process)
+      MrEdDoNextEvent(c, NULL, NULL);
+}
+
+int MrEdEventReady(MrEdContext *c)
+{
+  return (TimerReady(c) || MrEdGetNextEvent(1, 1, NULL, NULL)
+	  || scheme_check_sema_callbacks(MrEdSameContext, c, 1));
+}
+
+int wxEventReady()
+{
+  MrEdContext *c = MrEdGetContext();
+
+  return (!c->ready_to_go
+	  && (c->handler_running == scheme_current_process)
+	  && MrEdEventReady(c));
+}
+
+#define LET_HOW_MANY_WAIT 10
+#define WAIT_JUST_HOW_LONG 2.0
+
+static int num_waiting_a_little;
+
+static int check_for_nested_or_timeout(Scheme_Object *cx)
+{
+  if (check_for_nested_event(cx))
+    return 1;
+  
+  long d = scheme_get_milliseconds() -  scheme_current_process->block_start_sleep;
+  if (d < 0)
+    d = -d;
+
+  if ((d / 1000.0) > scheme_current_process->sleep_time)
+    return 1;
+
+  return 0;
+}
+
+static int WaitJustALittleLonger(MrEdContext *c)
+{
+  if (num_waiting_a_little >= LET_HOW_MANY_WAIT)
+    return 0;
+
+  num_waiting_a_little++;
+  c->ready = 1;
+  c->waiting_for_nested = 1;
+  c->waiting_a_little = 1;
+  c->alternate = NULL;
+  scheme_current_process->sleep_time = WAIT_JUST_HOW_LONG;
+  scheme_current_process->block_start_sleep = scheme_get_milliseconds();
+
+  scheme_block_until(check_for_nested_or_timeout, NULL, c, 0);
+
+  scheme_current_process->sleep_time = 0;
+
+  c->waiting_a_little = 0;
+  --num_waiting_a_little;
+
+  if (!c->waiting_for_nested) {
+    DoTheEvent(c);
+    return 1;
+  } else {
+    c->ready = 0;
+    c->waiting_for_nested = 0;
+
+    return 0;
+  }
+}
+
+static void on_handler_killed(Scheme_Process *p)
+{
+  MrEdContext *c = (MrEdContext *)p->kill_data;
+
+  p->on_kill = NULL;
+  p->kill_data = NULL;
+
+  if (c->waiting_a_little) {
+    c->waiting_a_little = 0;
+    --num_waiting_a_little;
+  }
+
+  c->ready = 1;
+  c->waiting_for_nested = 0;
+  c->sema_callback = 0;
+  c->timer = NULL;
+  c->alternate = NULL;
+  c->alt_data = NULL;
+  c->ready_to_go = 0;
+
+  c->wd = scheme_get_thread_current_directory(p, &c->wdlen, 1);
+}
+
+static Scheme_Object *handle_events(void *cx, int, Scheme_Object **)
+{
+  MrEdContext *c = (MrEdContext *)cx;
+  Scheme_Process *this_thread;
+
+#if SGC_STD_DEBUGGING
+  fprintf(stderr, "new thread\n");
+#endif
+
+  scheme_config = c->main_config;
+
+  this_thread = scheme_current_process;
+  c->handler_running = this_thread;
+  this_thread->on_kill = on_handler_killed;
+  this_thread->kill_data = c;
+  c->ready = 0;
+
+  if (c->wd)
+    scheme_setcwd(c->wd, 1);
+  
+  if (!scheme_setjmp(scheme_error_buf)) {
+    if (!TheMrEdApp->initialized)
+      TheMrEdApp->RealInit();
+    else {
+      DoTheEvent(c);
+
+      do {
+	while (MrEdEventReady(c)) {
+	  /* reset parameterization in case the last event handler 
+	     changed it */
+	  scheme_config = c->main_config;
+	  
+	  MrEdDoNextEvent(c, NULL, NULL);
+	}
+      } while (WaitJustALittleLonger(c));
+    }
+  }
+   
+  int newlen;
+  char *newdir;
+
+  newdir = scheme_getcwd(c->wd, c->wdlen, &newlen, 1);
+  if (!newdir)
+    c->wdlen = 0;
+  else if (newlen > c->wdlen)
+    c->wdlen = newlen;
+  c->wd = newdir;
+
+  c->ready = 1;
+  c->handler_running = NULL;
+  this_thread->on_kill = NULL;
+  this_thread->kill_data = NULL;
+
+  return scheme_void;
+}
+
+static int main_loop_exited = 0;
+
+static int MrEdContextReady(void *, void *c)
+{
+  return ((MrEdContext *)c)->ready;
+}
+
+static int try_dispatch(Scheme_Object *do_it)
+{
+  MrEdContext *c;
+  MrEdEvent e;
+  wxTimer *timer;
+  int got_one;
+
+  if (main_loop_exited)
+    return 1;
+
+  if ((c = (MrEdContext *)scheme_check_sema_callbacks(MrEdContextReady, NULL, 1))) {
+    if (!do_it)
+      return 1;
+
+    if (SCHEME_FALSEP(do_it))
+      scheme_current_process->ran_some = 1;
+
+    if (c == mred_main_context) {
+      scheme_check_sema_callbacks(MrEdSameContext, c, 0);
+    } else {
+      c->ready = 0;
+      c->sema_callback = 1;
+      if (c->waiting_for_nested)
+	c->waiting_for_nested = 0;
+      else
+	scheme_thread(scheme_make_closed_prim(handle_events,
+					      c), 
+		      c->main_config);
+    }
+
+    return 1;
+  }
+
+  if ((timer = TimerReady(NULL))) {
+    if (!do_it)
+      return 1;
+    if (SCHEME_FALSEP(do_it))
+      scheme_current_process->ran_some = 1;
+
+    c = (MrEdContext *)timer->context;
+
+    timer->Dequeue();
+
+    if (c == mred_main_context) {
+      timer->Notify();
+    } else {
+      c->ready = 0;
+      c->timer = timer;
+      if (c->waiting_for_nested)
+	c->waiting_for_nested = 0;
+      else
+	scheme_thread(scheme_make_closed_prim(handle_events,
+					      c), 
+		      c->main_config);
+    }
+
+    return 1;
+  }
+
+  ChainContextsList();
+
+  got_one = MrEdGetNextEvent(!do_it, 0, &e, &c);
+
+  UnchainContextsList();
+
+  if (!got_one)
+    return 0;
+
+  if (!do_it)
+    return 1;
+  if (SCHEME_FALSEP(do_it))
+    scheme_current_process->ran_some = 1;
+
+  if (c) {
+    c->ready = 0;
+    memcpy(&c->event, &e, sizeof(MrEdEvent));
+    if (c->waiting_for_nested)
+      c->waiting_for_nested = 0;
+    else
+      scheme_thread(scheme_make_closed_prim(handle_events,
+					    c), 
+		    c->main_config);
+  } else
+    /* Event with unknown context: */
+    MrEdDispatchEvent(&e);
+
+  return 1;
+}
+
+static void wakeup_on_dispatch(Scheme_Object *, void *fds)
+{
+#ifdef wx_x
+#ifdef wx_xt
+  Display *d = XtDisplay(mred_main_context->finalized->toplevel);
+#else
+  Display *d = XtDisplay(wxTheApp->topLevel);
+#endif
+  int fd;
+  
+  fd = ConnectionNumber(d);
+  
+  MZ_FD_SET(fd, (fd_set *)fds);
+#endif
+}
+
+static int check_initialized(Scheme_Object *)
+{
+  return TheMrEdApp->initialized;
+}
+
+# define KEEP_GOING wxTheApp->keep_going
+
+void wxDoEvents()
+{
+  /* When we get here, we are in the main dispatcher thread */
+  if (!TheMrEdApp->initialized) {
+    MrEdContext *c;
+
+    c = (MrEdContext *)MrEdMakeEventspace(NULL);
+    
+    scheme_thread(scheme_make_closed_prim(handle_events,
+					  c), 
+		  c->main_config);
+
+    /* Block until initialized: */
+    scheme_current_process->block_descriptor = -1;
+    scheme_current_process->blocker = NULL;
+    scheme_current_process->block_check = check_initialized;
+    scheme_current_process->block_needs_wakeup = NULL;
+    do {
+      scheme_process_block(0);
+    } while (!TheMrEdApp->initialized);
+    scheme_current_process->block_descriptor = 0;
+  }
+
+  if (!try_dispatch(scheme_true)) {
+    do {
+      scheme_current_process->block_descriptor = -1;
+      scheme_current_process->blocker = NULL;
+      scheme_current_process->block_check = try_dispatch;
+      scheme_current_process->block_needs_wakeup = wakeup_on_dispatch;
+
+      scheme_process_block(0);
+
+      scheme_current_process->block_descriptor = 0;
+      /* Sets ran_some if it succeeds: */
+      if (try_dispatch(scheme_false))
+	break;
+    } while (KEEP_GOING);
+  }
+}
+
+void wxDispatchEventsUntil(int (*f)(void *), void *data)
+{
+  MrEdContext *c = MrEdGetContext();
+
+  if (c->ready_to_go
+      || (c->handler_running != scheme_current_process)) {
+    /* This is not the handler thread or an event still hasn't been
+       dispatched. Wait. */
+    do {
+      scheme_current_process->block_descriptor = -1;
+      scheme_current_process->blocker = (Scheme_Object *)data;
+      scheme_current_process->block_check = (int (*)(Scheme_Object *))f;
+      do {
+	scheme_process_block(0);
+      } while (!f(data));
+      scheme_current_process->block_descriptor = 0;
+      scheme_current_process->ran_some = 1;
+    } while (!f(data));
+  } else {
+    /* This is the main process. Handle events */
+    do
+      MrEdDoNextEvent(c, f, data);
+    while (!f(data));
+  }
+}
+
+static void (*mzsleep)(float secs, void *fds);
+
+static void MrEdSleep(float secs, void *fds)
+{
+  MrEdContext *c;
+  unsigned long now;
+
+  if (!(KEEP_GOING))
+    return;
+
+  ChainContextsList();
+  
+  now = (unsigned long)scheme_get_milliseconds();
+  for (c = mred_contexts; c; c = c->next) {
+    wxTimer *timer = mred_timers;
+    
+    while (timer && !((MrEdContext *)timer->context)->ready)
+      timer = timer->next;
+    
+    if (timer) {
+      unsigned long done = timer->expiration;
+      float diff;
+      diff = done - now;
+      
+      diff /= 1000;
+      if (diff <= 0)
+	secs = 0.00001;
+      else if (!secs || (secs > diff))
+	secs = diff;
+    }
+  }
+  
+  UnchainContextsList();
+  
+#ifdef wx_msw
+  MrEdMSWSleep(secs, fds);
+#else
+#ifdef wx_mac
+  MrEdMacSleep(secs);
+#else
+  mzsleep(secs, fds);
+#endif
+#endif
+}
+
+/****************************************************************************/
+/*                                wxTimer                                   */
+/****************************************************************************/
+
+wxTimer::wxTimer(void)
+{
+  __type = wxTYPE_TIMER;
+
+  next = prev = NULL;
+
+  context = (void *)MrEdGetContext();
+
+  WXGC_IGNORE(context);
+}
+
+wxTimer::~wxTimer(void)
+{
+}
+
+Bool wxTimer::Start(int millisec, Bool _one_shot)
+{
+  if (prev || next || (mred_timers == this))
+    return FALSE;
+
+  interval = millisec;
+  if (interval <= 0)
+    interval = 1;
+  one_shot = !!_one_shot;
+
+  unsigned long now = (unsigned long)scheme_get_milliseconds();
+  expiration = now + interval;
+
+  if (mred_timers) {
+    wxTimer *t = mred_timers;
+
+    while (1) {
+      int later;
+
+      later = (expiration >= t->expiration);
+
+      if (!later) {
+	prev = t->prev;
+	t->prev = this;
+	next = t;
+	if (prev)
+	  prev->next = this;
+	else
+	  mred_timers = this;
+	return TRUE;
+      }
+
+      if (!t->next) {
+	t->next = this;
+	prev = t;
+
+	return TRUE;
+      }
+      t = t->next;
+    } 
+  } else
+    mred_timers = this;
+
+  return TRUE;
+}
+
+void wxTimer::Dequeue(void)
+{
+  if (!prev) {
+    if (mred_timers == this)
+      mred_timers = next;
+  }
+
+  if (prev)
+    prev->next = next;
+  if (next)
+    next->prev = prev;
+
+  next = prev = NULL;
+}
+
+void wxTimer::Stop(void)
+{
+  Dequeue();
+
+  interval = -1;
+}
+
+/****************************************************************************/
+/*                        Redirected Standard I/O                           */
+/****************************************************************************/
+
+#ifndef WINDOW_STDIO
+/* Removing "|| defined(wx_msw)" below uses the Windows console.
+   The danger is that closing that console kills MrEd without
+   any chance of cancelling the kill. */
+# if defined(wx_mac) || defined(wx_msw)
+#  define WINDOW_STDIO 1
+# else
+#  define WINDOW_STDIO 0
+# endif
+#endif
+
+#ifndef WCONSOLE_STDIO
+# if defined(wx_msw) && !WINDOW_STDIO
+#  define WCONSOLE_STDIO 1
+# else
+#  define WCONSOLE_STDIO 0
+# endif
+#endif
+
+#ifndef REDIRECT_STDIO
+# if (defined(wx_msw) || defined(wx_mac)) && !WINDOW_STDIO && !WCONSOLE_STDIO
+#  define REDIRECT_STDIO 1
+# else
+#  define REDIRECT_STDIO 0
+# endif
+#endif
+
+#if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE_STDIO
+static void MrEdSchemeMessages(char *, ...);
+#endif
+
+#if WINDOW_STDIO
+
+class IOFrame : public wxFrame
+{
+public:
+  wxMediaCanvas *display;
+  wxMediaEdit *media;
+  Bool hidden, beginEditSeq;
+
+  IOFrame() : wxFrame(NULL, "Standard Output", -1, -1, 600, 400, 
+		      wxDEFAULT_FRAME + wxSDI, "stdout")
+    {
+      display = new wxMediaCanvas(this);
+      
+      media = new wxMediaEdit();
+      display->SetMedia(media);
+      media->Lock(1);
+      hidden = FALSE;
+
+      /* Map copy keys: */
+      wxKeymap *km = media->GetKeymap();
+      media->AddBufferFunctions(km);
+      media->AddEditorFunctions(km);
+# ifdef wx_msw
+      km->MapFunction("c:c", "copy-clipboard");
+      km->MapFunction("c:x", "copy-clipboard");
+# else
+      km->MapFunction("d:c", "copy-clipboard");
+      km->MapFunction("d:x", "copy-clipboard");
+# endif
+
+      /* Fixed-width font: */
+      wxStyle *style = media->GetStyleList()->FindNamedStyle("Standard");
+      style->SetDelta(*(new wxStyleDelta(wxCHANGE_FAMILY, wxMODERN)));
+
+#ifdef wx_mac
+      OnSize(600, 400);
+#endif
+      
+      Show(TRUE);
+
+      beginEditSeq = 0;
+    }
+
+  void OnSize(int x, int y)
+    {
+      GetClientSize(&x, &y);
+      if (display)
+	display->SetSize(0, 0, x, y);
+    }
+
+  Bool OnClose(void) 
+    { 
+      hidden = TRUE;
+      return TRUE; 
+    }
+};
+
+static IOFrame *ioFrame = NULL;
+
+#else  /* !WINDOW_STDIO */
+
+#if WCONSOLE_STDIO
+
+static HANDLE console_out;
+
+#else  /* !WCONSOLE_STDIO */
+
+#if REDIRECT_STDIO
+static FILE *mrerr = NULL;
+#else
+#define mrerr stderr
+#endif
+
+#endif /* WCONSOLE_STDIO */
+
+#endif /* WINDOW_STDIO */
+
+#if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE_STDIO
+static void MrEdSchemeMessages(char *msg, ...)
+{
+  va_list args;
+
+#if WINDOW_STDIO
+  static opening = 0;
+  if (opening)
+	return;
+  opening = 1;
+  if (!ioFrame)
+    ioFrame = new IOFrame;
+  opening = 0;
+  if (ioFrame->hidden) {
+    ioFrame->hidden = FALSE;
+    ioFrame->Show(TRUE);
+  }
+#endif
+#if WCONSOLE_STDIO
+  if (!console_out) {
+	AllocConsole();
+    console_out = GetStdHandle(STD_OUTPUT_HANDLE);
+  }
+#endif
+#if REDIRECT_STDIO
+  if (!mrerr)
+    mrerr = fopen("mrstderr.txt", "w");
+  if (!mrerr)
+    return;
+#endif
+
+  va_start(args, msg);
+#if WINDOW_STDIO
+  if (!msg) {
+    char *s;
+    long l;
+    
+    s = va_arg(args, char*);
+    l = va_arg(args, long);
+
+    if (!ioFrame->beginEditSeq) {
+      ioFrame->media->BeginEditSequence();
+      ioFrame->beginEditSeq = 1;
+    }
+    ioFrame->media->Lock(0);
+    ioFrame->media->Insert(l, s, ioFrame->media->LastPosition());
+    ioFrame->media->Lock(1);
+
+    if (l != 1 || s[0] == '\n') {
+      ioFrame->media->EndEditSequence();
+      ioFrame->beginEditSeq = 0;
+    }
+  } else {
+    char buffer[2048];
+    vsprintf(buffer, msg, args);
+    ioFrame->media->Lock(0);
+    ioFrame->media->Insert((char *)buffer, ioFrame->media->LastPosition());
+    ioFrame->media->Lock(1);
+    if (ioFrame->beginEditSeq) {
+      ioFrame->media->EndEditSequence();
+      ioFrame->beginEditSeq = 0;
+    }
+  }
+#endif
+#if WCONSOLE_STDIO
+  if (!msg) {
+    char *s;
+    long l;
+	DWORD wrote;
+    
+    s = va_arg(args, char*);
+    l = va_arg(args, long);
+
+	WriteConsole(console_out, s, l, &wrote, NULL);
+  } else {
+	char buffer[2048];
+	DWORD wrote;
+    vsprintf(buffer, msg, args);
+	WriteConsole(console_out, buffer, strlen(buffer), &wrote, NULL);
+  }
+#endif
+#if !WINDOW_STDIO && !WCONSOLE_STDIO
+  vfprintf(mrerr, msg, args);
+#endif
+  va_end(args);
+}
+#endif
+
+#if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE_STDIO
+
+int stdin_getc(Scheme_Input_Port*)
+{
+  return EOF;
+}
+
+int stdin_char_ready(Scheme_Input_Port*)
+{
+  return TRUE;
+}
+
+static Scheme_Object *MrEdMakeStdIn(void)
+{
+  Scheme_Object *intype = scheme_make_port_type("stdin");
+
+  return (Scheme_Object *)scheme_make_input_port(intype, NULL,
+						 stdin_getc,
+						 stdin_char_ready,
+						 NULL, NULL, 0);
+}
+
+void stdout_write(char *s, long l, Scheme_Output_Port*)
+{
+#if WINDOW_STDIO || WCONSOLE_STDIO
+  MrEdSchemeMessages(NULL, s, l);
+#else
+  static FILE *out = NULL;
+
+  if (!out)
+    out = fopen("mrstdout.txt", "w");
+  
+  if (out)
+    fwrite(s, l, 1, out);
+#endif
+}
+
+static Scheme_Object *MrEdMakeStdOut(void)
+{
+  Scheme_Object *outtype = scheme_make_port_type("stdout");
+
+  return (Scheme_Object *)scheme_make_output_port(outtype, NULL,
+						  stdout_write,
+						  NULL, 0);
+}
+
+void stderr_write(char *s, long l, Scheme_Output_Port*)
+{
+#if WINDOW_STDIO || WCONSOLE_STDIO
+  MrEdSchemeMessages(NULL, s, l);
+#else
+  if (!mrerr)
+    mrerr = fopen("mrstderr.txt", "w");
+  
+  if (mrerr)
+    fwrite(s, l, 1, mrerr);
+#endif
+}
+
+static Scheme_Object *MrEdMakeStdErr(void)
+{
+  Scheme_Object *errtype = scheme_make_port_type("stderr");
+
+  return (Scheme_Object *)scheme_make_output_port(errtype, NULL,
+						  stderr_write,
+						  NULL, 0);
+}
+#endif
+
+/****************************************************************************/
+/*                               Debugging                                  */
+/****************************************************************************/
+
+#if ADD_OBJ_DUMP
+extern int wx_object_count;
+
+# ifndef USE_SENORA_GC
+extern "C" GC_PTR GC_changing_list_start, GC_changing_list_current;
+# else
+# define GC_word int
+# endif
+extern "C" GC_word GC_dl_entries;
+extern "C" GC_word GC_fo_entries;
+
+Scheme_Object *OBJDump(int, Scheme_Object *[])
+{
+# if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE
+# define PRINT_IT MrEdSchemeMessages
+# else
+# define PRINT_IT scheme_console_printf
+# endif
+  int c;
+
+  PRINT_IT("Objects: %d\n", wx_object_count);
+# ifndef USE_SENORA_GC
+  PRINT_IT("Memory: %d\n", GC_get_heap_size());
+# endif
+  PRINT_IT("FO: %d\n", GC_fo_entries);
+  PRINT_IT("DL: %d\n", GC_dl_entries);
+# ifndef USE_SENORA_GC
+  PRINT_IT("Changing: %d\n",
+	 (long)GC_changing_list_current - (long)GC_changing_list_start);
+# endif
+
+  wxTimer *timer;
+  for (c = 0, timer = mred_timers; timer; timer = timer->next)
+    c++;
+  PRINT_IT("Timers: %d\n", c);
+
+  Scheme_Process *p;
+  for (c = 0, p = scheme_first_process; p; p = p->next)
+    c++;
+
+  PRINT_IT("Threads: %d\n", c);
+
+  return scheme_make_integer(wx_object_count);
+}
+#endif
+
+#ifdef USE_SENORA_GC
+extern "C" {
+  void (*scheme_external_dump_info)(void);
+  void (*scheme_external_dump_arg)(Scheme_Object *);
+  char *(*scheme_external_dump_type)(void *);
+};
+extern void GC_cpp_for_each(void (*f)(void *, int, void *), void *data);
+extern int GC_is_wx_object(void *v);
+
+#define NUM_OBJ_KIND (wxTYPE_SNIP_CLASS_LIST + 1)
+static int cpp_count[NUM_OBJ_KIND], cpp_sch_count[NUM_OBJ_KIND], cpp_size[NUM_OBJ_KIND];
+static int cpp_actual_count[NUM_OBJ_KIND], cpp_actual_size[NUM_OBJ_KIND];
+static unsigned long cpp_lo[NUM_OBJ_KIND], cpp_hi[NUM_OBJ_KIND];
+
+static int trace_path_type;
+
+#ifdef USE_WXOBJECT_TRACE_COUNTER
+
+void wxTraceCount(void *o, int size)
+{
+  wxObject *obj = (wxObject *)o;
+  int type = obj->__type;
+
+  if ((type >= 0) && (type < NUM_OBJ_KIND)) {
+    cpp_actual_count[type]++;
+    cpp_actual_size[type] += size;
+
+    unsigned long s = (unsigned long)o;
+    if (!cpp_lo[type] || (s < cpp_lo[type]))
+      cpp_lo[type] = s;
+    if (!cpp_hi[type] || (s > cpp_hi[type]))
+      cpp_hi[type] = s;
+  }
+}
+
+void wxTracePath(void *o, unsigned long src, void *pd)
+{
+  if (trace_path_type > 0) {
+    wxObject *obj = (wxObject *)o;
+    int type = obj->__type;
+    
+    if (type == trace_path_type)
+      GC_store_path(o, src, pd);
+  }
+}
+
+void wxTraceInit(void)
+{
+  int i;
+
+  for (i = 0; i < NUM_OBJ_KIND; i++) {
+    cpp_actual_count[i] = cpp_actual_size[i] = 0;
+    cpp_lo[i] = cpp_hi[i] = 0;
+  }
+}
+
+void wxTraceDone(void)
+{
+  /* nothing */
+}
+
+void wxObjectFinalize(void *o)
+{
+  if (((wxObject *)o)->__type != -1) {
+#if 0
+    /* New non-cleanup flag makes this incorrect: */
+    fprintf(stderr, "ERROR: free wxObject had non-deleted type value!");
+#else
+    ((wxObject *)o)->__type = -1;
+#endif
+  }
+}
+
+static void set_trace_arg(Scheme_Object *a)
+{
+  trace_path_type = -1;
+  if (a && SCHEME_SYMBOLP(a)) {
+    char *s = SCHEME_SYM_VAL(a);
+    int i;
+
+    for (i = 0; i < NUM_OBJ_KIND; i++) {
+      char *tn = wxGetTypeName(i);
+      if (tn && !strcmp(tn, s)) {
+	trace_path_type = i;
+	return;
+      }
+    }
+  }
+}
+
+static char *object_type_name(void *v)
+{
+  if (GC_is_wx_object(v)) {
+    int t = ((wxObject *)v)->__type;
+    if ((t >= 0) && (t < NUM_OBJ_KIND)) {
+      char *c = wxGetTypeName(t);
+      if (c)
+	return c;
+      else
+	return "wxUNKNOWN";
+    } else
+      return "wxBAD";
+  } else
+    return "";
+}
+
+#endif
+
+static void count_obj(void *o, int s, void *)
+{
+  wxObject *obj = (wxObject *)o;
+  int type = obj->__type;
+
+  if ((type >= 0) && (type < NUM_OBJ_KIND)) {
+    cpp_count[type]++;
+    if (obj->__gc_external)
+      cpp_sch_count[type]++;
+#ifdef MEMORY_USE_METHOD
+    cpp_size[type] += s + (obj->MemoryUse());
+#endif
+  }
+}
+
+static void dump_cpp_info()
+{
+  int i, total_count = 0, total_size = 0, total_actual_size = 0;
+  
+  for (i = 0; i < NUM_OBJ_KIND; i++)
+    cpp_count[i] = cpp_sch_count[i] = cpp_size[i] = 0;
+
+  GC_cpp_for_each(count_obj, NULL);
+
+  scheme_console_printf("\nBegin wxWindows\n");
+
+  for (i = 0; i < NUM_OBJ_KIND; i++) {
+    if (cpp_count[i] || cpp_actual_count[i]) {
+      char buffer[50];
+      char *name = wxGetTypeName(i);
+
+      if (!name) {
+	sprintf(buffer, "#%d", i);
+	name = buffer;
+      }
+
+      scheme_console_printf("%30.30s %4ld %5ld %10ld %10ld %8lx - %8lx\n",
+			    name,
+			    cpp_sch_count[i],
+			    cpp_count[i],
+			    cpp_size[i],
+			    cpp_actual_size[i],
+			    cpp_lo[i],
+			    cpp_hi[i]);
+#ifdef USE_WXOBJECT_TRACE_COUNTER
+      if (cpp_count[i] != cpp_actual_count[i])
+	scheme_console_printf("%30.30s actual count: %10ld\n",
+			      "", cpp_actual_count[i]);
+#endif
+      total_count += cpp_count[i];
+      total_size += cpp_size[i];
+      total_actual_size += cpp_actual_size[i];
+    }
+  }
+    
+  scheme_console_printf("%30.30s %10ld %10ld %10ld\n",
+			"total", total_count, total_size, total_actual_size);
+  
+  scheme_console_printf("End wxWindows\n");
+
+#if ADD_OBJ_DUMP
+  scheme_console_printf("\n");
+  OBJDump(0, NULL);
+#endif
+}
+
+#endif
+
+/****************************************************************************/
+/*                           AIX DANGER signal                              */
+/****************************************************************************/
+
+#if defined(_IBMR2)
+#define DANGER_ALARM
+#endif
+
+#ifdef DANGER_ALARM
+
+static int danger_signal_received = 0;
+static wxDialogBox *dangerFrame = NULL;
+
+class DangerThreadTimer : public wxTimer
+{
+ public:
+  void Notify(void);
+};
+
+void DismissDanger(wxObject &o, wxEvent &e)
+{
+  dangerFrame->Show(FALSE);
+  dangerFrame = NULL;
+  danger_signal_received = 0;
+}
+
+void DangerThreadTimer::Notify(void)
+{
+  if (danger_signal_received) {
+    if (!dangerFrame) {
+      dangerFrame = new wxDialogBox((wxWindow *)NULL, "Danger", FALSE, 0, 0, 300, 200);
+
+      (void) new wxMessage(dangerFrame, "Warning: Paging space is low.");
+
+      dangerFrame->NewLine();
+
+      wxButton *b = new wxButton(dangerFrame, DismissDanger, "Ok");
+
+      dangerFrame->Fit();
+      b->Centre(wxHORIZONTAL);
+
+      dangerFrame->Centre(wxBOTH);
+      dangerFrame->Show(TRUE);
+    }
+  }
+}
+
+#endif
+
+/****************************************************************************/
+/*                             Application                                  */
+/****************************************************************************/
+
+MrEdApp::MrEdApp()
+{
+#ifndef wx_xt
+  if (!wx_class)
+    wx_class = "mred";
+#endif
+}
+
+static int exit_status = -1;
+
+static void MrEdExit(int status)
+{
+  exit_status = status;
+  main_loop_exited = 1;
+
+  wxTheApp->ExitMainLoop();
+}
+
+extern "C" void (*GC_out_of_memory)(void);
+
+static void MrEdOutOfMemory(void)
+{
+#ifdef wx_mac
+  Alert(101, NULL);
+  ExitToShell();
+#else
+  _exit(-1);
+#endif
+}
+
+void *wxOutOfMemory()
+{
+  MrEdOutOfMemory();
+  return NULL;
+}
+
+static const char *CallSchemeExpand(const char *filename)
+{
+  char *s;
+
+  s = scheme_expand_filename((char *)filename, strlen(filename), NULL, 0);
+  
+  return s ? s : filename;
+}
+
+#ifndef USE_SENORA_GC
+static void MrEdIgnoreWarnings(char *, GC_word)
+{
+}
+#endif
+
+static void mred_init(int argc, char **argv)
+{
+#if 0
+  /* Turns off GC: */
+  GC_free_space_divisor = 1;
+#endif
+
+#if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE_STDIO
+  scheme_make_stdin = MrEdMakeStdIn;
+  scheme_make_stdout = MrEdMakeStdOut;
+  scheme_make_stderr = MrEdMakeStdErr;
+#endif
+
+#ifndef USE_SENORA_GC
+  GC_set_warn_proc(MrEdIgnoreWarnings);
+#endif
+  GC_out_of_memory = MrEdOutOfMemory;
+
+#ifdef USE_SENORA_GC
+  scheme_external_dump_info = dump_cpp_info;
+# ifdef USE_WXOBJECT_TRACE_COUNTER
+  scheme_external_dump_type = object_type_name;
+  scheme_external_dump_arg = set_trace_arg;
+# endif
+#endif
+
+#if REDIRECT_STDIO || WINDOW_STDIO || WCONSOLE_STDIO
+  scheme_console_printf = MrEdSchemeMessages;
+#endif
+  scheme_get_sema_callback_context = wxGetContextForFrame;
+
+  scheme_case_sensitive = 1;
+  scheme_constant_builtins = 0;
+  scheme_allow_cond_auto_else = 0;
+  
+  mred_eventspace_param = scheme_new_param();
+  mred_event_dispatch_param = scheme_new_param();
+
+  global_env = scheme_basic_env();
+
+  /* Temporarily add `program': */
+  {
+    char *program;
+    if (argc)
+      program = argv[0];
+    else
+      program = "MrEd";
+
+    scheme_add_global("program",
+		      scheme_make_string(program), 
+		      global_env);
+  }
+
+    scheme_eval_string("(#%current-library-collection-paths "
+		        "(#%path-list-string->path-list "
+		         "(#%or (#%getenv \"PLTCOLLECTS\") \"\")"
+		         "(#%or"
+		          "(#%ormap"
+		           "(#%lambda (f) (#%let ([p (f)]) (#%and p (#%directory-exists? p) (#%list p))))"
+		           "(#%list"
+		            "(#%lambda () (#%let ((v (#%getenv \"PLTHOME\")))"
+		                          "(#%and v (#%build-path v \"collects\"))))"
+		            "(#%lambda () (#%find-executable-path program \"collects\"))"
+#ifdef wx_x
+		            "(#%lambda () \"/usr/local/lib/plt/collects\")"
+#endif
+#ifdef wx_msw
+		            "(#%lambda () \"c:\\plt\\collects\")"
+#endif
+		          ")) #%null)))",
+		       global_env);
+
+  scheme_remove_global("program", global_env);
+
+  if ((argc > 1) && !strcmp(argv[1], "--pre")) {
+    if (argc > 2) {
+      /* Collect the rest of the arguments into argv: */
+      Scheme_Object *sch_argv = scheme_make_vector(argc - 3, scheme_null);
+      for (int i = 3; i < argc; i++)
+	SCHEME_VEC_ELS(sch_argv)[i - 3] = scheme_make_string(argv[i]);
+      scheme_add_global("argv", sch_argv, global_env);
+
+      if (!scheme_setjmp(scheme_error_buf)) {
+        scheme_eval_string_all(argv[2], global_env, 0);
+      } else {
+#ifndef wx_x      
+	wxMessageBox("Error evaluating --pre expression.", "Error");
+#endif
+	exit(-1);
+      }
+    } else {
+      scheme_console_printf("%s: --pre flag needs an expression", argv[0]);
+#ifndef wx_x      
+      wxMessageBox("--pre command-line flag needs an expression", "Error");
+#endif
+      exit(-1);
+    }
+  }
+}
+
+wxFrame *MrEdApp::OnInit(void)
+{
+#if defined(wx_msw)
+  mred_init(argc, argv);
+#endif
+
+  scheme_no_dumps("the graphics library is running");
+
+  initialized = 0;
+  edjrMode = FALSE;
+
+#ifdef LIBGPP_REGEX_HACK
+  new Regex("a", 0);
+#endif
+
+#if 0
+  {
+    unsigned long now, start = (unsigned long)scheme_get_milliseconds();
+
+    while ((now = (unsigned long)scheme_get_milliseconds()) == start);
+      
+    if (start > now) {
+      wxMessageBox("Time goes down!", "Error");
+    }
+  }
+#endif
+
+  wxmeExpandFilename = CallSchemeExpand;
+
+  mred_main_context = new MrEdContext;
+  mred_main_context->topLevelWindowList = new wxChildList();
+  mred_main_context->snipClassList = wxMakeTheSnipClassList();
+  mred_main_context->bufferDataClassList = wxMakeTheBufferDataClassList();
+
+  mred_main_context->finalized = new MrEdFinalizedContext;
+
+  mred_only_context = mred_main_context;
+
+  MrEdInitFirstContext(mred_main_context);
+
+#ifdef DANGER_ALARM
+  {
+    DangerThreadTimer *t = new DangerThreadTimer();
+    t->Start(10000);
+  }
+#endif
+
+  wxInitMedia();
+
+  mred_real_main_frame = new wxFrame(NULL, "MrEd");
+  wxPanel *p = new wxPanel(mred_real_main_frame);
+  (void)(new wxButton(p, (wxFunction)MrEdExit, "Quit"));
+  p->Fit();
+  mred_real_main_frame->Fit();
+
+#if 0
+  XSynchronize(MrEdGetXDisplay(), 1);
+#endif
+
+  wxsScheme_setup(global_env);
+
+  mred_eventspace_type = scheme_make_type("<eventspace>");
+
+  scheme_set_param(scheme_config, mred_eventspace_param, (Scheme_Object *)mred_main_context);
+  scheme_set_param(scheme_config, MZCONFIG_ENABLE_BREAK, scheme_false);
+
+  def_dispatch = scheme_make_prim_w_arity(def_event_dispatch_handler,
+					  "default-event-dispatch-handler",
+					  0, 0);
+  scheme_set_param(scheme_config, mred_event_dispatch_param, def_dispatch);
+
+  MakeContext(mred_main_context, NULL);
+
+  mred_only_context = NULL;
+
+  mred_main_context->handler_running = scheme_current_process;
+
+  mzsleep = scheme_sleep;
+  scheme_sleep = MrEdSleep;
+
+  scheme_exit = MrEdExit;
+
+#if ADD_OBJ_DUMP
+  scheme_add_global("dump-object-stats", 
+		    scheme_make_prim(OBJDump), global_env);
+#endif
+
+  xargc = argc;
+  xargv = argv;
+
+  if (xargc) {
+    /* Skip command name */
+    xargv++;
+    --xargc;
+  }
+
+  if (xargc >= 2 && !strcmp(xargv[0], "--pre")) {
+    /* Already done. */
+    xargc -= 2;
+    xargv += 2;
+  }
+
+  if (xargc >= 2 && !strcmp(xargv[0], "-s")) {
+    collection = xargv[1];
+    xargc -=2;
+    xargv += 2;
+  } else
+    collection = "system";
+
+  file = "system.ss";
+
+  return mred_real_main_frame;
+}
+
+void MrEdApp::RealInit(void)
+{
+  const char *rl = "(require-library \"%s\" \"%s\")";
+  char *s;
+  jmp_buf savebuf;
+
+  initialized = 1;
+
+  wxMediaIOCheckLSB();
+
+  s = (char *)scheme_malloc_atomic(strlen(rl) + strlen(file) + strlen(collection) + 3);
+  sprintf(s, rl, file, collection);
+  
+  memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+  if (scheme_setjmp(scheme_error_buf)) {
+    /* give up */
+    wxMessageBox("Error loading system.", "Error");
+    goto giveup;
+  } else {
+    scheme_eval_string(s, global_env);
+  }
+
+#ifdef wx_mac
+  if (startup_dial) {
+    DisposDialog(startup_dial);
+    startup_dial = NULL;
+  }
+#endif
+
+  Scheme_Object *startup;
+
+  startup = scheme_lookup_global(scheme_intern_symbol("mred:initialize"), 
+				 global_env);
+
+  if (!startup) {
+    wxMessageBox("Can't find mred:intialize function.", "Error");
+    goto giveup;
+  }
+
+  if (scheme_setjmp(scheme_error_buf)) {
+    wxMessageBox("Error initializing.", "Error");
+    goto giveup;
+  } else {
+    Scheme_Object **p;
+    int i;
+
+    p = (Scheme_Object **)scheme_malloc(xargc * sizeof(Scheme_Object *));
+    for (i = 0; i < xargc; i++)
+      p[i] = scheme_make_string(xargv[i]);
+
+    scheme_apply(startup, xargc, p);
+  }
+
+  goto done;
+
+ giveup:
+#ifdef wx_mac
+  if (startup_dial)
+    DisposDialog(startup_dial);
+#endif
+
+  MakeEdJrFrame();
+  edjrMode = TRUE;
+
+ done:
+
+  memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+
+  return;
+}
+
+#ifdef wx_mac
+char *MrEdApp::GetDefaultAboutItemName()
+{
+  return edjrMode ? "About EdJr..." : "About MrEd...";
+}
+
+void MrEdApp::DoDefaultAboutItem()
+{
+  DialogPtr dial;
+  short hit;
+  GrafPtr port;
+ 
+  dial = GetNewDialog(edjrMode ? 130 : 129, NULL, (WindowRef)-1);
+  GetPort(&port);
+  SetPort(dial);
+  TextFont(geneva);
+  TextSize(10);
+  SetPort(port);
+
+  ModalDialog(NULL, &hit);
+  
+  DisposDialog(dial);
+}
+
+#endif
+
+int MrEdApp::OnExit(void)
+{
+  return exit_status;
+}
+
+/* Remap main: */
+#if !defined(wx_msw)
+
+#if !defined(SYSVR4) && !defined(wx_xt)
+extern "C" { 
+#endif
+  int wxEntry(int argc, char *argv[]);
+#if !defined(SYSVR4) && !defined(wx_xt)
+};
+#endif
+
+#ifdef wx_mac
+extern Scheme_Object *wxs_app_file_proc;
+
+void Drop_Runtime(char **argv, int argc)
+{
+  int i;
+  jmp_buf savebuf;
+  
+  memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+
+  if (scheme_setjmp(scheme_error_buf)) {
+    /* give up on rest */
+  } else {
+    for (i = 0; i < argc; i++) {
+      Scheme_Object *p[1];
+      p[0] = scheme_make_string(argv[0]);
+      scheme_apply(wxs_app_file_proc, 1, p);
+    }
+  }
+
+  memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+}
+
+void Drop_Quit()
+{
+  Scheme_Object *sym, *quit;
+
+  sym = scheme_intern_symbol("mred:exit");
+  quit = scheme_lookup_global(sym, scheme_get_env(scheme_config));
+
+  scheme_apply(quit, 0, NULL);
+}
+#endif
+
+#ifdef wx_x
+#if INTERRUPT_CHECK_ON
+static int interrupt_signal_received;
+
+static void interrupt(int)
+{
+  interrupt_signal_received = 1;
+
+  signal(SIGINT, interrupt);
+}
+#endif
+#endif
+
+#if defined(_IBMR2)
+static void dangerdanger(int)
+{
+  if (danger_signal_received) {
+    fprintf(stderr, "mred: Danger - paging space STILL low - exiting\n");
+    exit(-1);
+  } else {
+    fprintf(stderr, "mred: Danger - paging space low\n");
+    scheme_collect_garbage();
+    danger_signal_received = 1;
+  }
+  
+  signal(SIGDANGER, dangerdanger);
+}
+#endif
+
+#ifdef wx_mac
+extern short wxMacDisableMods;
+extern long wxMediaCreatorId;
+#endif
+
+extern "C" {
+int actual_main(int argc, char **argv)
+{
+  mred_init(argc, argv);
+
+  TheMrEdApp = new MrEdApp;
+
+  int r = wxEntry(argc, argv);
+
+  return r;
+}
+} ;
+
+int main(int argc, char *argv[])
+{
+#if defined(_IBMR2)
+  int dummy;
+
+  if ((unsigned long)&dummy > (unsigned long)0x2ff23000)
+    scheme_stackbottom = 0x2ff80000;
+  else
+    scheme_stackbottom = 0x2ff23000;
+
+  signal(SIGDANGER, dangerdanger);
+#endif
+#ifdef wx_x
+#if INTERRUPT_CHECK_ON
+  signal(SIGINT, interrupt);
+#endif
+#endif
+
+#ifdef USE_SENORA_GC
+  {
+    int dummy;
+    GC_set_stack_base(&dummy);
+  }
+
+  fprintf(stderr, "Starting MrEd sgc\n");
+#endif
+
+#ifdef wx_mac
+  wxMacDisableMods = 4096;
+
+  scheme_creator_id = 'MrEd';
+  wxMediaCreatorId = 'MrEd';
+
+#if !defined(__powerc)
+  long calcLimit;
+  THz zone;
+	
+  zone = GetZone();
+  calcLimit = ((long)LMGetCurStackBase()-(*(long *)zone)-sizeof(Zone))*3/4;
+  if (calcLimit % 2)
+    calcLimit++;
+  SetApplLimit((Ptr)((*(long *)zone)+sizeof(Zone)+calcLimit));
+#endif
+#endif
+
+#if defined(__MC68K__)
+  go_alpha_boundary();
+  go_omega_boundary();
+  if ((unsigned long)_alpha_.my_address < (unsigned long)_omega_.my_address)
+    GC_add_roots((char *)_alpha_.my_address, (char *)_omega_.my_address);
+  else
+    GC_add_roots((char *)_omega_.my_address, (char *)_alpha_.my_address);
+#endif
+  
+#ifdef wx_mac
+  /* initialize Mac stuff */
+  MaxApplZone();
+  InitGraf(&qd.thePort);		
+  InitFonts();
+  InitWindows();
+  InitMenus();
+  TEInit();
+  InitDialogs(NULL);
+  MoreMasters();
+  MoreMasters();
+  
+  Drop_GetArgs(&argc, &argv);
+  
+  while (argc > 2 && (!strcmp(argv[1], "-r"))) {
+    char *file = argv[2];
+    int j;
+    
+    OpenResFile(CtoPstr(file));
+    
+    for (j = 1; j < argc - 2; j++)
+      argv[j] = argv[j + 2];
+    argc -= 2;
+  }  
+#endif
+  
+  scheme_actual_main = actual_main;
+
+  return scheme_image_main(argc, argv);
+}
+#endif
+
+/****************************************************************************/
+/*                              wxFlushDisplay                              */
+/****************************************************************************/
+
+void wxFlushDisplay(void)
+{
+#ifdef wx_x
+  Display *d;
+
+#ifdef wx_motif
+    d = XtDisplay(wxTheApp->topLevel);
+#endif
+#ifdef wx_xview
+    d = (Display*)xv_get((Frame)(wxTheApp->wx_frame->GetHandle()), XV_DISPLAY);
+#endif
+#ifdef wx_xt
+    d = XtDisplay(wxAPP_TOPLEVEL);
+#endif
+
+  XFlush(d);
+  XSync(d, FALSE);
+  XFlush(d);
+  XSync(d, FALSE);
+#endif
+}
diff --git a/src/mred/mred.fnt b/src/mred/mred.fnt
new file mode 100644
index 0000000..674472a
--- /dev/null
+++ b/src/mred/mred.fnt
@@ -0,0 +1,8 @@
+[mred]
+defaultFontSize=12
+ScreenDefault__=applicationfont
+ScreenRoman__=times
+ScreenDecorative__=geneva
+ScreenModern__=monaco
+ScreenSwiss__=helvetica
+ScreenScript__=geneva
diff --git a/src/mred/mred.h b/src/mred/mred.h
new file mode 100644
index 0000000..7295243
--- /dev/null
+++ b/src/mred/mred.h
@@ -0,0 +1,84 @@
+
+#define BREAKING_REQUIRES_SHIFT 1
+
+#ifdef wx_x
+typedef XEvent MrEdEvent;
+#else
+#ifdef wx_msw
+typedef MSG MrEdEvent;
+#else
+typedef EventRecord MrEdEvent;
+#endif
+#endif
+
+class wxTimer;
+
+typedef struct MrEdContextFrames {
+  wxChildList *list;
+  struct MrEdContextFrames *next, *prev;
+} MrEdContextFrames;
+
+typedef struct MrEdFinalizedContext {
+#ifdef wx_xt
+  Widget toplevel;
+#endif
+  MrEdContextFrames *frames;
+  struct MrEdContext **real_context; /* atomic ptr to actual context */
+} MrEdFinalizedContext;
+
+typedef struct MrEdContext {
+  Scheme_Type type;
+
+  Scheme_Process *handler_running;
+
+  MrEdFinalizedContext *finalized;
+
+  wxChildList *topLevelWindowList;
+  wxStandardSnipClassList *snipClassList;
+  wxBufferDataClassList *bufferDataClassList;
+  wxWindow *modal_window;
+
+  Scheme_Config *main_config;
+
+  short ready_to_go;
+
+  short ready, waiting_for_nested, waiting_a_little;
+  short sema_callback;
+  wxTimer *timer;
+  MrEdEvent event;
+
+  /* Alternate condition for nested event loop pending some condition */
+  int (*alternate)(void *);
+  void *alt_data;
+
+  /* Save current directory across thread creations: */
+  char *wd;
+  int wdlen; /* size of buffer, not name */
+
+  /* Used to chain active contexts while reading events: */
+  struct MrEdContext *next;
+
+  int busyState;
+
+  Scheme_Manager_Reference *mref;
+} MrEdContext;
+
+extern MrEdContext *mred_contexts;
+
+MrEdContext *MrEdGetContext(wxObject *w = NULL);
+
+int MrEdGetNextEvent(int peek, int current_only, MrEdEvent *, MrEdContext **);
+void MrEdDispatchEvent(MrEdEvent *);
+
+void MrEdInitFirstContext(MrEdContext *c);
+void MrEdInitNewContext(MrEdContext *c);
+void MrEdDestroyContext(MrEdFinalizedContext *c);
+
+#ifdef wx_msw
+void MrEdMSWSleep(float secs, void *fds);
+#endif
+
+#ifdef wx_mac
+void MrEdMacSleep(float secs);
+#endif
+
diff --git a/src/mred/mred.ini b/src/mred/mred.ini
new file mode 100644
index 0000000..0dd9b5d
--- /dev/null
+++ b/src/mred/mred.ini
@@ -0,0 +1,8 @@
+[mred]
+defaultFontSize=12
+ScreenDefault__=MS Sans Serif
+ScreenRoman__=Times New Roman
+ScreenDecorative__=
+ScreenModern__=Courier New
+ScreenSwiss__=Arial
+ScreenScript__=Script
diff --git a/src/mred/mred.sh b/src/mred/mred.sh
new file mode 100755
index 0000000..a6677fd
--- /dev/null
+++ b/src/mred/mred.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# This script picks the right binary for a mutli-platform
+#  configuration
+
+if [ "$PLTHOME" = '' ] ; then
+  PLTHOME=/usr/local/lib/plt
+  export PLTHOME
+fi
+
+SYS=`${PLTHOME}/bin/archsys`
+
+exec ${PLTHOME}/.bin/${SYS}/mred ${1+"$@"}
+
diff --git a/src/mred/mred.txt b/src/mred/mred.txt
new file mode 100644
index 0000000..c958e82
--- /dev/null
+++ b/src/mred/mred.txt
@@ -0,0 +1,408 @@
+
+
+About PLT MrEd
+
+
+
+Matthew Flatt
+mflatt@cs.rice.edu
+Rice University
+
+
+
+Version 50
+August 1997
+
+
+
+
+
+Copyright notice
+
+
+
+Copyright (c)1995-97 Matthew Flatt
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose is hereby granted without fee, provided
+that the above copyright notice, author statement and this permission
+notice appear in all copies of this software and related documentation.
+
+THE SOFTWARE IS PROVIDED ``AS-IS'' AND WITHOUT WARRANTY OF ANY KIND,
+EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+
+IN NO EVENT SHALL MATTHEW FLATT OR RICE UNIVERITY BE LIABLE FOR ANY
+SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY
+OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+wxWindows: Copyright (c)1994 Artificial Intelligence Applications
+Institute, The University of Edinburgh. All rights reserved.
+
+libscheme: Copyright (c)1994 Brent Benson. All rights reserved.
+
+Conservative garbage collector: Copyright (c)1988, 1989 Hans-J.
+Boehm, Alan J. Demers. Copyright (c)1991-1994 by Xerox Corporation.
+All rights reserved.
+
+Collector C++ extension by Jesse Hull and John Ellis: Copyright
+(c)1994 by Xerox Corporation. All rights reserved.
+
+
+
+
+
+Contents
+
+   * This Manual
+        * Thanks
+   * About MrEd
+        * What is MrEd?
+        * What is MrEd Used For?
+        * How was MrEd Developed?
+        * Comparisons to Other Systems
+        * Distribution
+        * More Information
+   * Compiling MrEd
+   * Running MrEd
+   * Index
+
+
+
+This Manual
+
+
+
+This manual explains what MrEd is and why MrEd might be useful. Complete
+information for MrEd is in PLT MrEd: Graphical Toolbox Manual
+../toolbox/index.htm.
+
+
+
+Thanks
+
+
+
+  Many thanks to Julian Smart for wxWindows and his help.
+Thanks also to Brent Benson for libscheme , and to Hans Boehm and John
+Ellis for the conservative garbage collector and their help. MrEd would
+not be possible without these fine packages.
+
+Thanks also to Robby Findler, Shriram Krishnamurthi, Cormac Flanagan,
+Matthias Felleisen, Gann Bierner, Richard Cobbe, Dan Grossman, Stephanie
+Weirich, Sebastian Good, Johnathan Franklin, Mark Krentel, Corky
+Cartwright, Michael Ernst, Kennis Koldewyn, Bruce Duba, and many others
+for feedback and help.
+
+Some basic typesetting sources for this manual are taken from Julian
+Smart's Reference Manual for wxWindows 1.60: a portable C++ GUI toolkit
+.
+
+
+
+About MrEd
+
+
+
+
+
+What is MrEd?
+
+
+
+ MrEd is a new architecture for developing portable graphical user
+interface (GUI) applications. MrEd provides the developer with a modern,
+high-level language supporting classes and objects, compilation units,
+execptions, pre-emptive threads, run-time safety, and automatic memory
+management. The language is integrated with an extensive, class-based
+GUI toolbox including frames, menus, controls, multimedia text editors,
+click-and-drag pasteboards, mulitple event spaces ("event loops"), and
+automatic geometry management.
+
+MrEd is based on Scheme (specifically,
+MzSchemehttp://www.cs.rice.edu/CS/PLT/packages /mzscheme) with a GUI
+toolbox that runs under X Windows, Microsoft Windows, and MacOS.
+Applications written using MrEd run on all three platforms without
+modification.
+
+MrEd is the graphical and compuational engine behind DrScheme, a new
+environment for developing and debugging Scheme applications. DrScheme
+will eventually provide a complete integrated evironment for developing
+MrEd applications.
+
+
+
+What is MrEd Used For?
+
+
+
+ MrEd is appropriate for developing any Scheme-based application
+which needs a graphic interface. MrEd is particularly useful when the
+graphic interface needs to be portable, when it needs sophisticated text
+or graphics manipulation, or when it needs threads or eventspaces
+(mulitple ``event loops''). MrEd is probably not appropriate for
+applications with tight memory constraints.
+
+MrEd can also be used as an editor. The system that MrEd uses to start
+up provides an Emacs-like editing environment. However, the vast body of
+Emacs packages has not been ported to MrEd; only Scheme mode and a
+hyper-text mode have been fully implemented. As code is written to
+extend the standard editor, new features can be inherited by all
+applications written in MrEd.
+
+
+
+How was MrEd Developed?
+
+
+
+ MrEd's core Scheme implementation is
+MzSchemehttp://www.cs.rice.edu/CS/PLT/packages /mzscheme, which was
+derived from Brent Benson's libscheme . MzScheme uses the conservative
+garbage collectorhttp://reality.sgi.com/employees/boehm_mti/gc.html from
+Hans Boehm et al.
+
+The GUI toolbox is derived from wxWindows
+http://web.ukonline.co.uk/julian.smart/wxwin/, version 1.66 (or so).
+MrEd's wxWindows has been debugged and developed along a largely
+divergent path since early 1996. While this is unfortunate in that MrEd
+and the wxWindows community can no longer collaborate on continued
+development, the divergence also means that MrEd's branch of wxWindows
+has stabilized.
+
+
+
+Comparisons to Other Systems
+
+
+
+    The GUI aspect of MrEd is much like Tcl/Tk
+or STk: both provide a toolbox of graphic objects with an interactive
+development language. MrEd's graphic object toolbox contains essentially
+the same elements as Tk. The basic difference is that MrEd provides a
+much richer ``operating system'' for developing large applications.
+
+ There are several all GUI development system that are comparable
+to MrEd in that they connect LISP or Scheme to an external GUI toolbox.
+These tools are typically not portable, and the GUI toolbox tends to be
+smaller or lower-level.
+
+A list of other GUI development systems is available at:
+http://www.cs.cmu.edu/afs/cs/user/bam/www/toolnames.html
+http://www.cs.cmu.edu/afs/cs/user/bam/www/toolnames.html
+
+ MrEd's editing system follows the Emacs model of extensibility:
+the editor is written in its own extension language. However, there are
+fundamental differences:
+   * In Emacs, the extension language is a dynamically-scoped dialect of
+     Lisp. Packages work in a global namespace. A single core editor is
+     extended through a standard set of functions and variables.
+   * In MrEd, the extension language is Scheme extended with an object
+     system, and the core editor is represented by a set of classes. The
+     editor can be extended Emacs-style by deriving new classes from the
+     editor class, but a package is not necessarily just an extension of
+     the editor. Rather, the core editor is available for use as a
+     submodule within a package's larger architecture. MrEd's editor
+system has the same potential for expansion as Emacs. Certainly, MrEd
+would be an ideal platform for a new full-functioned editor based on the
+Emacs model.
+
+
+
+Distribution
+
+
+
+  MrEd's source code can be freely distributed. Please read
+the license agreement, as well as the license agreements for wxWindows,
+libscheme, and the conservative garbage collector.
+
+The latest distribution for MrEd can be obtained from the MrEd Home
+Page: http://www.cs.rice.edu/CS/PLT/packages/mred/
+http://www.cs.rice.edu/CS/PLT/packages/mred/
+
+
+
+More Information
+
+
+
+   Up-to-date information about MrEd can be found at
+the MrEd Home Page: http://www.cs.rice.edu/CS/PLT/packages/mred/
+http://www.cs.rice.edu/CS/PLT/packages/mred/
+
+
+
+Compiling MrEd
+
+
+
+Compiled versions of MrEd are available from the MrEd Home Page (see
+section 2.6 , above). Some X Windows users will need to compile the code
+from scratch (because it is impossible for us to provide compiled
+executables for all platforms). Unfortunately, compiling MrEd is not a
+trivial task.
+
+  This section will describe how to compile MrEd for X
+Windows under Unix, which requires around 20-30 MB of disk space. First,
+download the following packages:
+   * wxWindows  -- Information about wxWindows is available from
+     http://web.ukonline.co.uk/julian.smart/wxwin/
+     http://web.ukonline.co.uk/julian.smart/wxwin/ but to compile MrEd,
+     special patched versions of wxWindows must be obtained from
+     http://www.cs.rice.edu/CS/PLT/packages/mred/
+     http://www.cs.rice.edu/CS/PLT/packages/mred/ MrEd works with two
+     flavors of wxWindows: Motif and ``Xt''. MrEd works with these
+     flavors about equally well. Most every X Windows installation can
+     support the ``Xt'' version, while Motif must be purchased.
+   * MrEd -- MrEd can be found at
+     http://www.cs.rice.edu/CS/PLT/packages/mred/
+     http://www.cs.rice.edu/CS/PLT/packages/mred/ This distribution
+     includes MzScheme and the conservative garbage collector.
+
+Set the WXDIR environment variable to the path of the wxWindows
+installation. All the directories from the wxWindows installation should
+be in the WXDIR directory.
+
+In wxWindows's src/make.env , some of the variables may need to be
+changed:
+   * Set OPTIONS:
+        * Add -DWXME_FOR_MRED=1.
+        * Add -DWX_NORMALIZED_PS_FONTS=1 (Motif only)
+        * Add -DWXME_LSB_FIRST=1 if the target machine represents
+          integers with the least-significant byte in the lowest memory
+          address. For example, this flag is needed for Intel machines,
+          but not Sparc machines. MrEd will display a warning at startup
+          if the flag value is incorrectly chosen.
+        * Add -DOPERATOR_NEW_ARRAY if the C++ compiler uses separate new
+          and new[] operators. For example, this flag is needed for gcc
+          version 2.6.3, but not for version 2.5.8.
+        * Add -DWXS_CANT_ASSIGN_STRUCTURES if the C++ compiler does not
+          allow an assignment to copy structures. A compile-time error
+          will occur if the flag is needed but not provided.
+   * Add three paths to COMPPATHS in make.env: -I gc-directory , -I
+     wxme-directory , and -I mzscheme-include-directory .
+        * The gc-directory path lets the wxWindows compilation find the
+          garbage collector header files. This directory is in the MrEd
+          distribution as mred/mzscheme/gc .
+        * The wxme-directory path lets MrEd find the wxme header files.
+          This directory in the MrEd distribution as mred/wxme .
+        * The mzscheme-include-directory lets MrEd find the MzScheme
+          headers. This directory in the MrEd distribution as
+          mred/mzscheme/include .
+   * Probably, XLIB and/or XINCLUDE must be adjusted.
+   * Possibly, other flags must be changed for your local configuration.
+
+If you're unlucky, you'll also have to adjust the flags for compiling
+MzScheme. These are in mred/mzscheme/Makefile and in
+mred/mzscheme/sconfig.h . (A description for each flag is included
+there.) Try compiling with the default flags unless there is a problem.
+
+Once all of the setup files are ready, go to the main MrEd distribution
+directory. Execute gnumake wx to compile wxWindows. After wxWindows has
+compiled, use gnumake to compile MrEd. (You must use gnumake to compile
+MrEd; the standard make will not work. Note, however, that make may
+actually be gnumake on your system, as on Linux.)
+
+Here are a few compiling hints:
+   * Turn off the debugging flags in ``make.env''. This will make the
+     object files and executable much smaller.
+   * There may be a lot of `void * operator new (...)' defined but not
+     used warnings from the compiler. Ignore them.
+
+
+
+Running MrEd
+
+
+
+Complete information about running MrEd is in PLT MrEd: Graphical
+Toolbox Manual ../toolbox/index.htm, but this chapter provides a quick
+overview of how to run MrEd.
+
+At run-time, MrEd needs to find three directories: the system directory,
+the MrEd system library collection directory, and the MzLib collection
+directory. The system directory is named system ; it should be in the
+same directory as the MrEd executable. The system library directory is
+named mred , inside a collects sub-directory in the same directory as
+the executable. Finally, the MzLib directory is named standard ; this
+directory must be in a collects sub-directory that can be in either of
+two places:
+   * in a mzscheme directory that is in the same directory as MrEd's
+     executeable (this is what you get after compiling MrEd)
+   * in a mzscheme directory that is in the same directory as MrEd's
+     directory (this is how the PLT distribution is configured)
+
+The search path for MzLib is actually defined in terms of the location
+of system . See PLT MrEd: Graphical Toolbox Manual ../toolbox/index.htm
+for more information.
+
+When you run MrEd, the window that appears is a console that provides a
+Scheme read-eval-print loop. To evaluate an expression, type it after
+the prompt and hit return. You can re-evaluate old expressions by moving
+the caret to the end of the expression and hitting return (or by using
+Meta-P from the current prompt). Evaluate a subexpression by hiliting it
+and hitting return. To stop evaluation, type Ctl-C (Unix and Windows) or
+Cmd-. (MacOS). 
+
+To open a standard text-editing window from the console, use the ``New''
+or ``Open...'' items in the ``File'' menu.
+
+To run a few simple demo programs, use the ``Load Scheme File'' menu
+item and select ``demo.ss'' in the distribution's ``demo'' directory
+(with MrEd).
+
+When MrEd starts up, it looks for a ``.mredrc'' file in the user's home
+directory (``mredrc.ss'' under Windows). If such a file exists, it is
+loaded (as a Scheme file) before the console is opened. Preferences
+about the appearance and behaviour of MrEd can be set using the
+``Preferences...'' menu item in the console's ``Edit'' menu.
+
+
+
+
+
+Index
+
+
+
+breaking
+     Running MrEd
+comparisons to other systems
+     Comparisons to Other Systems
+compiling
+     Compiling MrEd
+distribution
+     Distribution
+EmacsComparisons to Other Systems
+how? How was MrEd Developed?
+information
+     More Information
+pain and agony
+     Compiling MrEd
+STk  Comparisons to Other Systems
+Tcl  Comparisons to Other Systems
+thanks
+     Thanks
+Tk   Comparisons to Other Systems
+what?What is MrEd?
+when?What is MrEd Used
+where?
+     More Information
+who? Thanks
+why? 
+     
+     because we like you
+          Distribution
+     
+Winterp
+     Comparisons to Other Systems
+WWW  More Information
+wxWindows
+     Compiling MrEd
+-----------------------------------------------------------------------
+
+x
diff --git a/src/mred/mredgcpp.cxx b/src/mred/mredgcpp.cxx
new file mode 100644
index 0000000..442b38d
--- /dev/null
+++ b/src/mred/mredgcpp.cxx
@@ -0,0 +1,4 @@
+/* Hack to facilitate SGC compilation under windows with
+   MS Developer Studio. */
+
+#include "gc_cpp.cc"
diff --git a/src/mred/mredmac.cxx b/src/mred/mredmac.cxx
new file mode 100644
index 0000000..9977151
--- /dev/null
+++ b/src/mred/mredmac.cxx
@@ -0,0 +1,759 @@
+/*
+ * File:        mredmac.cc
+ * Purpose:     MrEd MacOS event loop
+ * Author:      Matthew Flatt
+ * Created:     1996
+ * Copyright:   (c) 1996, Matthew Flatt
+ */
+
+// #define USE_OS_QUEUE
+#define SELF_SUSPEND_RESUME
+
+#ifdef SELF_SUSPEND_RESUME
+/* Note on handling Suspend/Resume events:
+    Something in the handling of events messes up the sending of 
+    suspend and resume events. So, we ignore these events if they happen 
+    to occur, but notice suspension and resumption ourselves (by testing 
+    for the current process).
+*/
+#endif
+
+#include "wx_main.h"
+#include "wx_media.h"
+#include "scheme.h"
+
+#include "mred.h"
+
+#include <Events.h>
+#include <Processes.h>
+
+#define SLEEP_TIME 30
+
+static long resume_ticks;
+
+static int dispatched = 1;
+
+void MrEdInitFirstContext(MrEdContext *)
+{
+}
+
+void MrEdInitNewContext(MrEdContext *)
+{
+}
+
+void MrEdDestroyContext(MrEdFinalizedContext *)
+{
+}
+
+static wxFrame *_wxWindowPtrToFrame(WindowPtr w, wxChildList *l)
+{
+  wxChildNode *n;
+
+  for (n = l->First(); n; n = n->Next()) {
+    wxFrame *f = (wxFrame *)n->Data();
+    if (f->macWindow() == w)
+      return f;
+  }
+
+  return NULL;
+}
+
+static wxFrame *wxWindowPtrToFrame(WindowPtr w, MrEdContext *c)
+{
+  if (c)
+    return _wxWindowPtrToFrame(w, c->topLevelWindowList);
+  else {
+    for (c = mred_contexts; c; c = c->next) {
+      wxFrame *f;
+      if ((f = _wxWindowPtrToFrame(w, c->topLevelWindowList)))
+	return f;
+    }
+  }
+
+  return NULL;
+}
+
+typedef struct MrQueueElem {
+  EventRecord event;
+  RgnHandle rgn;
+  struct MrQueueElem *next, *prev;
+} MrQueueElem;
+
+MrQueueElem *first, *last;
+
+WindowPtr needsActive, needsDeactive;
+
+static void TransferQueue(int all)
+{
+  EventRecord e;
+  short mask;
+
+#ifdef USE_OS_QUEUE
+   if (all)
+     mask = everyEvent;
+   else
+    mask = everyEvent - mDownMask - mUpMask - keyDownMask - keyUpMask - autoKeyMask;
+#else
+  mask = everyEvent;
+#endif
+  
+  while (WaitNextEvent(mask, &e, dispatched ? SLEEP_TIME : 0, NULL)) {
+    MrQueueElem *q;
+    int done;
+    
+    dispatched = 0;
+
+    done = 0;
+#ifdef USE_OS_QUEUE
+    if ((e.what == mouseDown) 
+    	  || (e.what == mouseUp)
+    	  || (e.what == keyDown)
+    	  || (e.what == keyUp)
+    	  || (e.what == autoKey)) {
+    	/* Throw it away and stop */
+    	return;
+    } else 
+#endif
+    if (e.what == updateEvt) {
+      WindowPtr w = (WindowPtr)e.message;
+      for (q = first; q; q = q->next) {
+	if ((q->event.what == updateEvt)
+	    && (w == ((WindowPtr)q->event.message))) {
+	  UnionRgn(((WindowRecord *)w)->updateRgn, q->rgn, q->rgn);
+	  BeginUpdate(w);
+	  EndUpdate(w);
+	  done = 1;
+	  // break;
+	}
+      }
+    }
+
+    if (!done) {
+      q = new MrQueueElem;
+      memcpy(&q->event, &e, sizeof(EventRecord));
+      q->next = NULL;
+      q->prev = last;
+      if (last)
+	last->next = q;
+      else
+	first = q;
+      last = q;
+      
+      q->rgn = NULL;
+      
+      if (e.what == updateEvt) {
+	WindowPtr w = (WindowPtr)e.message;
+	q->rgn = NewRgn();
+	CopyRgn(((WindowRecord *)w)->updateRgn, q->rgn);
+	BeginUpdate(w);
+	EndUpdate(w);
+      } else if ((e.what == osEvt)
+      		 && ((e.message >> 24) & 0x0ff) == suspendResumeMessage) {
+#ifdef SELF_SUSPEND_RESUME
+	/* Forget it; we do fg/bg ourselves. See note at top. */
+	last = q->prev;
+	if (last)
+	  last->next = NULL;
+	else
+	  first = NULL;
+#else
+	int we_are_front = e.message & resumeFlag;
+	WindowPtr front = FrontWindow();
+
+	if (we_are_front) {     
+          TEFromScrap();
+          resume_ticks = TickCount();
+        } else {
+          ZeroScrap();
+          TEToScrap();
+        }
+        
+        q->event.what = activateEvt;
+        q->event.modifiers = we_are_front ? activeFlag : 0;
+        q->event.message = (long)front;
+#endif
+      }
+    }
+  }
+}
+
+#ifdef USE_OS_QUEUE
+static void DEQUEUE(QElemPtr q, QHdrPtr)
+{
+  while (1) {
+    QHdrPtr osqstart = GetEvQHdr();
+    EvQEl *osq = (EvQEl *)osqstart->qHead;
+    
+    while (osq) {
+      if (osq == (EvQEl *)q)
+        break;
+      osq = (EvQEl *)osq->qLink;
+    }
+    
+    if (osq) {
+      TransferQueue(1);
+    } else
+      break;
+  }
+}
+#endif
+
+static void MrDequeue(MrQueueElem *q)
+{
+  if (q->prev)
+    q->prev->next = q->next;
+  else
+    first = q->next;
+  if (q->next)
+    q->next->prev = q->prev;
+  else
+    last = q->prev;
+}
+
+static MrEdContext *KeyOk(int current_only)
+{
+  WindowPtr w;
+  wxFrame *fr;
+  MrEdContext *c;
+  
+  c = current_only ? MrEdGetContext() : NULL;
+  
+  w = FrontWindow();
+  fr = wxWindowPtrToFrame(w, c);
+  if (!fr || (c && (fr->context != (void *)c)) 
+      || (!c && !((MrEdContext *)fr->context)->ready))
+    return NULL;
+  
+  return (fr ? (MrEdContext *)fr->context : c);
+}
+
+static int WindowStillHere(WindowPtr win)
+{
+  WindowPtr f = FrontWindow();
+
+  while (f) {
+    if (f == win)
+      return TRUE;
+    f = (WindowPtr)((WindowRecord *)f)->nextWindow;
+  }
+
+  return FALSE;
+}
+
+#if defined(SELF_SUSPEND_RESUME) || defined(USE_OS_QUEUE)
+static int WeAreFront()
+{
+  static int inited;
+  static ProcessSerialNumber us;
+  ProcessSerialNumber front;
+  Boolean r;
+  
+  if (!inited) {
+    GetCurrentProcess(&us);
+    inited = 1;
+  }
+  GetFrontProcess(&front);
+  SameProcess(&us, &front, &r);
+  
+  return r;
+}
+#endif
+
+static MrEdContext *cont_event_context;
+static short cont_event_context_modifiers;
+static Point last_mouse;
+static int last_was_front;
+
+#ifdef RECORD_HISTORY
+FILE *history;
+#endif
+
+int MrEdGetNextEvent(int check_only, int current_only,
+		             EventRecord *event, MrEdContext **which)
+{
+  /* Search for an event. Handle clicks in non-frontmost windows
+     immediately. */
+#ifdef USE_OS_QUEUE
+  QHdrPtr osqstart;
+  EvQEl *osq, *next;
+#else
+  MrQueueElem *osq, *next;
+#endif
+  EventRecord *e, ebuf;
+  MrQueueElem *q;
+  MrEdContext *c, *keyOk, *fc, *foundc;
+  WindowPtr window;
+  wxFrame *fr;
+  int found = 0;
+  int saw_mdown = 0, saw_kdown = 0, we_are_front;
+  
+  if (!event)
+    event = &ebuf;
+  
+  c = current_only ? MrEdGetContext() : NULL;
+  
+  keyOk = KeyOk(current_only);
+  
+#ifdef RECORD_HISTORY
+  if (!history) history = fopen("history3", "w");
+  fprintf(history, "%lx %lx %lx\n",
+  	  c, keyOk, cont_event_context);
+#endif
+  
+  TransferQueue(0);
+
+#ifdef SELF_SUSPEND_RESUME 
+  /* Do fg/bg ourselves. See note at top. */
+  we_are_front = WeAreFront();
+  if (we_are_front != last_was_front) {
+     last_was_front = we_are_front;
+
+     if (we_are_front) {     
+       TEFromScrap();
+       resume_ticks = TickCount();
+     } else {
+       ZeroScrap();
+       TEToScrap();
+     }
+     
+     WindowPtr front = FrontWindow();
+  
+     if (front) {
+      q = new MrQueueElem;
+      q->next = NULL;
+      q->prev = last;
+      if (last)
+	last->next = q;
+      else
+	first = q;
+      last = q;
+      
+      q->rgn = NULL;
+    
+      q->event.what = activateEvt;
+      q->event.modifiers = we_are_front ? activeFlag : 0;
+      q->event.message = (long)front;
+    }
+  }
+#endif
+  
+  /* First service mouse & key events: */
+#ifdef USE_OS_QUEUE
+  osqstart = GetEvQHdr();
+  osq = (EvQEl *)osqstart->qHead;
+#else
+  osq = first;
+#endif
+  while (osq 
+#ifdef USE_OS_QUEUE
+  	 && WeAreFront()
+#endif
+  	 ) {
+#ifdef USE_OS_QUEUE
+    next = (EvQEl *)osq->qLink;
+    e = (EventRecord *)&osq->evtQWhat;
+#else
+    next = osq->next;
+    e = &osq->event;
+#endif
+    switch (e->what) {
+      case mouseDown:
+      {
+	WindowPtr window, front;
+	int part;
+
+	saw_mdown = 1;
+
+        part = FindWindow(e->where, &window);
+	front = FrontWindow();
+	if (part == inMenuBar)
+	  window = front;
+
+	if (!window) {
+#ifdef USE_OS_QUEUE
+	  DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+	  osqstart = GetEvQHdr();
+	  next = (EvQEl *)osqstart->qHead;
+#else
+	  MrDequeue(osq);
+#endif
+	  cont_event_context = NULL;
+        } else if (window != front) {
+	  fr = wxWindowPtrToFrame(window, NULL);
+	  fc = fr ? (MrEdContext *)fr->context : NULL;
+	  if (!fc->modal_window || (fr == fc->modal_window)) {
+	    SelectWindow(window);
+#ifdef USE_OS_QUEUE
+	    DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+	    osqstart = GetEvQHdr();
+	    next = (EvQEl *)osqstart->qHead;
+#else
+	    MrDequeue(osq);
+#endif
+	    cont_event_context = NULL;
+	  }
+	} else if (resume_ticks > e->when) {
+	    /* Clicked us into foreground - toss the event */
+#ifdef USE_OS_QUEUE
+	    DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+	    osqstart = GetEvQHdr();
+	    next = (EvQEl *)osqstart->qHead;
+#else
+	    MrDequeue(osq);
+#endif
+	} else {
+	  foundc = keyOk;
+	  if (foundc) {
+	    last_mouse.h = -1;
+	    found = 1;
+	    if (!check_only && (part != inMenuBar)) {
+	      cont_event_context = foundc;
+	      cont_event_context_modifiers = e->modifiers;
+	      cont_event_context_modifiers |= btnState;
+	    } else
+	      cont_event_context = NULL;
+	  }
+	}
+      }
+      break;
+    case mouseUp:
+      if (!cont_event_context) {
+      	if (!saw_mdown) {
+#ifdef USE_OS_QUEUE
+	  DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+	  osqstart = GetEvQHdr();
+	  next = (EvQEl *)osqstart->qHead;
+#else
+	  MrDequeue(osq);
+#endif
+        }
+      } else if (keyOk == cont_event_context) {
+	foundc = keyOk;
+	if (foundc) {
+	  found = 1;
+	  if (!check_only)
+	    cont_event_context = NULL;
+	}
+      }
+      break;
+    case keyDown:
+    case autoKey:
+      foundc = keyOk;
+      if (foundc) {
+#if GETS_KEY_UP
+	if (!check_only)
+	  cont_event_context = foundc;
+#endif
+	found = 1;
+      }
+      break;
+    case keyUp:
+      if (!cont_event_context) {
+        if (!saw_kdown) {
+#ifdef USE_OS_QUEUE
+	  DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+	  osqstart = GetEvQHdr();
+	  next = (EvQEl *)osqstart->qHead;
+#else
+	  MrDequeue(osq);
+#endif
+        }
+      } else if (keyOk == cont_event_context) {
+	foundc = keyOk;
+	if (foundc)
+	  found = 1;
+	if (!check_only)
+	  cont_event_context = NULL;
+      }
+      break;
+    }
+
+    if (found)
+      break;
+
+    osq = next;
+  }
+
+  if (found) {
+    /* Remove intervening mouse/key events: */
+#ifdef USE_OS_QUEUE
+#if 0
+    EvQEl *qq;
+    for (qq = (EvQEl *)osqstart->qHead; qq && (qq != osq); qq = next) {
+      next = (EvQEl *)qq->qLink;
+      Dequeue((QElemPtr)qq, (QHdrPtr)osqstart);
+    }
+    e = (EventRecord *)&osq->evtQWhat;
+#endif
+#else
+    MrQueueElem *qq;
+    for (qq = first; qq && (qq != osq); qq = next) {
+      next = qq->next;
+      MrDequeue(qq);
+    }
+    e = &osq->event;
+#endif
+
+    if (which)
+      *which = foundc;
+
+#ifdef RECORD_HISTORY
+    fprintf(history, "mouse or key\n");
+    fflush(history);
+#endif
+
+    if (check_only)
+      return TRUE;
+    
+    memcpy(event, e, sizeof(EventRecord));
+#ifdef USE_OS_QUEUE
+    DEQUEUE((QElemPtr)osq, (QHdrPtr)osqstart);
+#else
+    MrDequeue(osq);
+#endif
+    
+    return TRUE;
+  }
+  
+  if (keyOk) {
+     if ((check_only && EventAvail(autoKeyMask, event))
+         || (!check_only && GetNextEvent(autoKeyMask, event))) {
+     	if (which)
+     	  *which = keyOk;
+
+#ifdef RECORD_HISTORY
+	fprintf(history, "autokey\n");
+	fflush(history);
+#endif
+
+     	return TRUE;
+     }
+  }
+  
+  // TransferQueue(0);
+    
+  /* Try activate events: */
+  for (q = first; q; q = q->next) {
+    switch (q->event.what) {
+    case activateEvt:
+      window = (WindowPtr)q->event.message;
+      if (WindowStillHere(window)) {
+        fr = wxWindowPtrToFrame(window, c);
+        fc = fr ? (MrEdContext *)fr->context : NULL;
+        if ((!c && !fr) || (!c && fc->ready) || (fc == c)) {
+	  if (which)
+	    *which = fc;
+
+#ifdef RECORD_HISTORY
+	  fprintf(history, "activate\n");
+	  fflush(history);
+#endif
+
+	  if (check_only)
+	    return TRUE;
+	
+	  MrDequeue(q);
+	  memcpy(event, &q->event, sizeof(EventRecord));
+	  return TRUE;
+        }
+      } else
+	MrDequeue(q);
+      break;
+    }
+  }
+  
+  /* Update events: */
+  for (q = first; q; q = q->next) {
+    switch (q->event.what) {
+    case updateEvt:
+      window = (WindowPtr)q->event.message;
+      if (WindowStillHere(window)) {
+	fr = wxWindowPtrToFrame(window, c);
+	fc = fr ? (MrEdContext *)fr->context : NULL;
+	if ((!c && !fr) || (!c && fc->ready) || (fc == c)) {
+	  if (which)
+	    *which = fc;
+
+#ifdef RECORD_HISTORY
+	  fprintf(history, "update\n");
+	  fflush(history);
+#endif
+
+	  if (check_only)
+	    return TRUE;
+	
+	  // MrDequeue(q);
+	  memcpy(event, &q->event, sizeof(EventRecord));
+	  return TRUE;
+	}
+      } else {
+	DisposeRgn(q->rgn);
+	MrDequeue(q);
+      }
+      break;
+    }
+  }
+
+  /* Generate a motion event? */
+  if ((cont_event_context == c) || (cont_event_context == keyOk)) {      
+      GetMouse(&event->where);
+      LocalToGlobal(&event->where);
+      
+      if ((event->where.v != last_mouse.v)
+          || (event->where.h != last_mouse.h)) {
+          
+        if (which)
+	  *which = (cont_event_context ? cont_event_context : keyOk);
+        if (check_only) {
+#ifdef RECORD_HISTORY
+	  fprintf(history, "move or drag\n");
+	  fflush(history);
+#endif
+          return TRUE;
+        }
+
+        last_mouse.v = event->where.v;
+        last_mouse.h = event->where.h;
+        
+        event->what = nullEvent;
+        event->when = TickCount();
+        if (cont_event_context && StillDown()) {
+	  /* Dragging... */
+	  event->modifiers = cont_event_context_modifiers;
+	  event->message = 1;
+#ifdef RECORD_HISTORY
+	  fprintf(history, "drag\n");
+  	  fflush(history);
+#endif
+        } else {
+          event->modifiers = 0;
+	  event->message = (keyOk ? 1 : 0);
+#ifdef RECORD_HISTORY
+	  fprintf(history, "move\n");
+  	  fflush(history);
+#endif
+        }
+        return TRUE;
+     }
+  }
+  
+#ifdef RECORD_HISTORY
+  fprintf(history, "no event\n");
+  fflush(history);
+#endif
+  
+  return FALSE;
+}
+
+extern void wxCheckFinishedSounds(void);
+
+void MrEdDispatchEvent(EventRecord *e)
+{
+  dispatched = 1;
+
+  if (e->what == updateEvt) {
+    /* Find the update event for this window: */
+    RgnHandle rgn;
+    MrQueueElem *q;
+    WindowPtr w;
+    GrafPtr p;    
+
+    w = (WindowPtr)e->message;
+
+    for (q = first; q; q = q->next) {
+      if ((q->event.what == updateEvt)
+	  && (w == ((WindowPtr)q->event.message))) {
+	rgn = q->rgn;
+	MrDequeue(q);
+	break;
+      }
+    }
+
+    Point o = {0, 0};
+    GetPort(&p);
+    SetPort(w);
+    GlobalToLocal(&o);
+    OffsetRgn(rgn, o.h, o.v);
+    InvalRgn(rgn);
+    SetPort(p);
+
+    DisposeRgn(rgn);
+  }
+    
+  wxTheApp->doMacPreEvent();
+  wxTheApp->doMacDispatch(e);
+  wxTheApp->doMacPostEvent();
+  
+  wxCheckFinishedSounds();
+}
+
+int MrEdCheckForBreak(void)
+{
+#ifdef USE_OS_QUEUE
+  QHdrPtr start;
+  EvQEl *q;
+#else
+  MrQueueElem *q;
+#endif
+  EventRecord event;
+  
+  if (!KeyOk(TRUE))
+    return 0;
+  
+#ifdef USE_OS_QUEUE
+  start = GetEvQHdr();
+  q = (EvQEl *)start->qHead;
+  while (q) {
+    if (q->evtQWhat == keyDown) {
+      if ((((q->evtQMessage & charCodeMask) == '.') 
+	   && (q->evtQModifiers & cmdKey))
+      	  || (((q->evtQMessage & charCodeMask) == 3) 
+	      && (q->evtQModifiers & controlKey))) {
+        DEQUEUE((QElemPtr)q, (QHdrPtr)start);
+        return TRUE;
+      }
+    }
+    q = (EvQEl *)q->qLink;
+  }
+#else
+  TransferQueue(0);
+
+  for (q = first; q; q = q->next) {
+    if (q->event.what == keyDown) {
+      if ((((q->event.message & charCodeMask) == '.') 
+	   && (q->event.message & cmdKey))
+      	  || (((q->event.message & charCodeMask) == 3) 
+	      && (q->event.modifiers & controlKey))) {
+        MrDequeue(q);
+        return TRUE;
+      }
+    }
+  }
+#endif
+  
+  return FALSE;
+}
+
+void MrEdMacSleep(float secs)
+{
+  secs = 0;
+  
+  EventRecord e;
+  
+#if 0
+  /* This is right only if there is no TCP blocking */
+  RgnHandle rgn;
+  rgn = ::NewRgn();
+  if (rgn) {
+    Point pt;
+    GetMouse(&pt);
+    LocalToGlobal(&pt);
+    ::SetRectRgn(rgn, pt.h - 1, pt.v - 1, pt.h + 1, pt.v + 1);
+  }
+#else
+  RgnHandle rgn = NULL;
+#endif
+  
+  WaitNextEvent(0, &e, secs ? secs * 60 : SLEEP_TIME, rgn);
+}
+
diff --git a/src/mred/mredmsw.cxx b/src/mred/mredmsw.cxx
new file mode 100644
index 0000000..5085a3b
--- /dev/null
+++ b/src/mred/mredmsw.cxx
@@ -0,0 +1,406 @@
+/*
+ * File:        mredmsw.cc
+ * Purpose:     MrEd Windows event loop
+ * Author:      Matthew Flatt
+ * Created:     1996
+ * Copyright:   (c) 1996, Matthew Flatt
+ */
+
+
+#include "wx_main.h"
+#include "wx_media.h"
+#include "scheme.h"
+#include "wx_dialg.h"
+
+#include "mred.h"
+
+#include "../mzscheme/src/schwinfd.h"
+
+#include <winsock.h>
+
+extern long last_msg_time;
+
+int mred_do_prepost_gm = 0;
+extern void wxDoPreGM(void);
+extern void wxDoPostGM(void);
+
+void MrEdInitFirstContext(MrEdContext *c)
+{
+}
+
+void MrEdInitNewContext(MrEdContext *c)
+{
+}
+
+void MrEdDestroyContext(MrEdFinalizedContext *)
+{
+}
+
+void wxCreatedWindow(wxWindow *w)
+{
+}
+
+void wxDestroyedWindow(void *context, wxWindow *w)
+{
+}
+
+extern wxWindow *wxHWNDtoWindow(HWND);
+
+static MrEdContext *GetContext(HWND hwnd)
+{
+  HWND next = hwnd, wnd;
+  do {
+    do {
+      wnd = next;
+      next = GetParent(next);
+    } while (next);
+    next = GetWindow(wnd, GW_OWNER);
+  } while (next);
+
+  wxWindow *w;
+  w = wxHWNDtoWindow(wnd);
+  
+  if (!w)
+    return NULL;
+
+  if (wxSubType(w->__type, wxTYPE_FRAME))
+    return (MrEdContext *)((wxFrame *)w)->context;
+  else if (wxSubType(w->__type, wxTYPE_DIALOG_BOX))
+    return (MrEdContext *)((wxDialogBox *)w)->context;
+  else
+    return NULL;
+}
+
+typedef struct {
+  MrEdContext *c, *c_return;
+  MSG *msg;
+  int remove;
+  HWND wnd;
+} CheckInfo;
+
+static BOOL CALLBACK CheckWindow(HWND wnd, LPARAM param)
+{
+  CheckInfo *info = (CheckInfo *)param;
+  MrEdContext *c;
+
+  c = GetContext(wnd);
+
+  if ((!info->c && (!c || c->ready))
+      || (info->c == c)) {
+    if (PeekMessage(info->msg, wnd, NULL, NULL, 
+                    info->remove ? PM_REMOVE : PM_NOREMOVE)) {
+      info->wnd = wnd;
+      info->c_return = c;
+      return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+int FindReady(MrEdContext *c, MSG *msg, int remove, MrEdContext **c_return)
+{
+  MSG backup;
+  CheckInfo info;
+
+  if (!msg)
+    msg = &backup;
+
+  info.c = c;
+  info.msg = msg;
+  info.remove = remove;
+
+  if (!EnumWindows((WNDENUMPROC)CheckWindow, (LPARAM)&info)) {
+    if (c_return)
+      *c_return = info.c_return;
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+int MrEdGetNextEvent(int check_only, int current_only, 
+		     MSG *event, MrEdContext **which)
+{
+  MrEdContext *c;
+
+#if 0
+  /* Test code: (doesn't work with modal dialogs!) */
+  if (!current_only && PeekMessage(event, NULL, NULL, NULL, 
+			   check_only ? PM_NOREMOVE : PM_REMOVE)) {
+    if (which)
+       *which = NULL;
+     return TRUE;
+  } else
+    return FALSE;
+#endif
+
+  if (which)
+    *which = NULL;
+
+  if (current_only)
+    c = MrEdGetContext();
+  else
+    c = NULL;
+
+  return FindReady(c, event, !check_only, which);
+
+#if 0
+  if (current_only) {
+    c = MrEdGetContext();
+    if (FindReady(c, event, !check_only)) {
+      if (which)
+	*which = c;
+      return TRUE;
+    }
+
+    return FALSE;
+  }
+
+#if 0
+  if (AnyPopup()) {
+    if (PeekMessage(event, NULL, NULL, NULL, 
+	            check_only ? PM_NOREMOVE : PM_REMOVE)) {
+      if (which)
+	*which = c;
+      return TRUE;
+    }
+  }
+#endif
+
+  for (c = mred_contexts; c; c = c->next) {
+    if (c->ready && FindReady(c, event, !check_only)) {
+      if (which)
+	*which = c;
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+#endif
+}
+
+void MrEdDispatchEvent(MSG *msg)
+{
+  if (!wxTheApp->ProcessMessage(msg)) {
+    TranslateMessage(msg);
+    last_msg_time = msg->time;
+    DispatchMessage(msg);
+  }
+}
+
+static void SaveMsg(int& msgs_count, int& msgs_size, 
+		    MSG*& msgs, MSG&msg)
+{
+  if (msgs_count == msgs_size) {
+    MSG *save = msgs;
+
+    msgs_size = (msgs_size ? 2 * msgs_size : 10);
+    msgs = new MSG[msgs_size];
+
+    memcpy(msgs, save, msgs_count * sizeof(MSG));
+
+    delete[] save;
+  }
+  memcpy(msgs + (msgs_count++), &msg, sizeof(MSG));
+}
+
+#if 0
+int MrEdCheckForBreak(void)
+{ 
+  MSG msg;
+  MSG *msgs = NULL, *omsgs = NULL;
+  int msgs_size = 0, msgs_count = 0;
+  int omsgs_size = 0, omsgs_count = 0;
+  int i, retval = FALSE;
+  Bool ctlDown = FALSE;
+#if BREAKING_REQUIRES_SHIFT
+  Bool shiftDown = FALSE;
+#endif
+  MrEdContext *lc = MrEdGetContext();
+
+  if (!::PeekMessage(&msg, NULL, WM_KEYDOWN, WM_KEYDOWN, PM_NOREMOVE))
+    return FALSE;
+
+  // To search all the messages, we have to Peek them all and then
+  // Post them back. This will mess up the timing and locations of
+  // these events.
+  //
+  // Is there a better way to do this???
+
+  while (::PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)) {
+    if (GetContext(msg.hwnd) == lc) {
+      if (msg.message == WM_KEYDOWN) {
+	if (msg.wParam == VK_CONTROL)
+	  ctlDown = TRUE;
+#if BREAKING_REQUIRES_SHIFT
+	else if (msg.wParam == VK_SHIFT)
+	  shiftDown = TRUE;
+#endif
+	else if (ctlDown 
+#if BREAKING_REQUIRES_SHIFT
+		 && shiftDown
+#endif
+		 && (msg.wParam == 'C')) {
+	  delete[] msgs;
+	  retval = TRUE;
+	  msgs_count = 0;
+	}
+      } else if (msg.message == WM_KEYUP) {
+	if (msg.wParam == VK_CONTROL)
+	  ctlDown = FALSE;
+#if BREAKING_REQUIRES_SHIFT
+	else if (msg.wParam == VK_SHIFT)
+	  shiftDown = FALSE;
+#endif
+      }
+      SaveMsg(msgs_count, msgs_size, msgs, msg);
+    } else
+      SaveMsg(omsgs_count, omsgs_size, omsgs, msg);
+  }
+
+  for (i = 0; i < msgs_count; i++)
+    ::PostMessage(msgs[i].hwnd, msgs[i].message, 
+		  msgs[i].wParam, msgs[i].lParam);
+  for (i = 0; i < omsgs_count; i++)
+    ::PostMessage(omsgs[i].hwnd, omsgs[i].message, 
+		  omsgs[i].wParam, omsgs[i].lParam);
+
+  delete[] msgs;
+
+  return retval;
+}
+#endif
+
+int MrEdCheckForBreak(void)
+{
+  HWND w = GetActiveWindow();
+  if (MrEdGetContext() != GetContext(w))
+    return 0;
+
+  SHORT hit = 0x8000;
+  SHORT hitnow = 0x0001;
+  SHORT c = GetAsyncKeyState('C');
+#if BREAKING_REQUIRES_SHIFT
+  SHORT shift = GetAsyncKeyState(VK_SHIFT);
+#else
+  SHORT shift = hit;
+#endif
+  SHORT control = GetAsyncKeyState(VK_CONTROL);
+  
+  return ((c & hit) && (c & hitnow) && (control & hit) && (shift & hit));
+}
+
+static long signal_waitdone(void *)
+{
+  WaitMessage();
+  return 0;
+}
+
+static long signal_fddone(void *fds)
+{
+  win_extended_fd_set *r = (win_extended_fd_set *)fds;
+  win_extended_fd_set *w = ((win_extended_fd_set *)fds) + 1;
+  win_extended_fd_set *e = ((win_extended_fd_set *)fds) + 2;
+  
+  select(0, &r->set, &w->set, &e->set, 0);
+
+  return 0;
+}
+
+static HANDLE wait_msg_thread = NULL;
+
+void MrEdMSWSleep(float secs, void *fds)
+{
+  if (mred_do_prepost_gm)
+    wxDoPreGM();
+
+  win_extended_fd_set *r, *w, *e;
+  
+  if (fds) {
+    r = (win_extended_fd_set *)fds;
+    w = ((win_extended_fd_set *)fds) + 1;
+    e = ((win_extended_fd_set *)fds) + 2;
+  } else
+    r = w = e = NULL;
+    
+  /* Block: use different stratgey if there are handles or fds to watch: */
+  if (fds && ((r->set.fd_count || w->set.fd_count || e->set.fd_count)
+              || r->num_handles)) {
+      
+    int num_handles = r->num_handles, *rps, two_rps[2];
+    HANDLE *handles, two_handles[2];
+    SOCKET fake;
+
+    if (num_handles) {
+      /* handles has been set up with an extra couple of slots: */ 
+      handles = r->handles;
+      rps = r->repost_sema;
+    } else {
+      handles = two_handles;
+      rps = two_rps;
+    }
+
+  
+    HANDLE th1, th2;
+    DWORD result;
+    DWORD id;
+
+    if (r->set.fd_count || w->set.fd_count || e->set.fd_count) {
+      fake = socket(PF_INET, SOCK_STREAM, 0);
+      FD_SET(fake, e);
+
+      th2 = CreateThread(NULL, 5000, 
+	              (LPTHREAD_START_ROUTINE)signal_fddone,
+		      fds, 0, &id);
+    
+      rps[num_handles] = 0;
+      handles[num_handles++] = th2;
+    } else
+      th2 = NULL;
+
+    if (wait_msg_thread)
+      if (WaitForSingleObject(wait_msg_thread, 0) == WAIT_OBJECT_0) {
+	CloseHandle(wait_msg_thread);
+	wait_msg_thread = NULL;
+      }
+
+    if (!wait_msg_thread)
+      wait_msg_thread = CreateThread(NULL, 5000, 
+				     (LPTHREAD_START_ROUTINE)signal_waitdone,
+				     NULL, 0, &id);
+
+    rps[num_handles] = 0;
+    handles[num_handles++] = wait_msg_thread;
+
+    result = WaitForMultipleObjects(num_handles, handles, FALSE, 
+                                    secs ? (DWORD)(secs * 1000) : INFINITE);
+
+    if ((result >= WAIT_OBJECT_0) && (result < WAIT_OBJECT_0 + num_handles)) {
+      result -= WAIT_OBJECT_0;
+      if (rps[result])
+        ReleaseSemaphore(handles[result], 1, NULL);
+    }
+
+    if (th2) {
+      closesocket(fake);
+      CloseHandle(th2);
+    }
+  } else {
+    UINT id;
+    
+    if (secs)
+      id = SetTimer(NULL, 0, secs * 1000, NULL);
+    else
+      id = 0;
+  
+    if (wxTheApp->keep_going)
+      WaitMessage();
+
+    if (secs)
+      KillTimer(NULL, id);
+  }
+  
+  if (mred_do_prepost_gm)
+    wxDoPostGM();
+}
diff --git a/src/mred/mredx.cxx b/src/mred/mredx.cxx
new file mode 100644
index 0000000..8584abf
--- /dev/null
+++ b/src/mred/mredx.cxx
@@ -0,0 +1,594 @@
+/*
+ * File:        mredx.cc
+ * Purpose:     MrEd X Windows event loop
+ * Author:      Matthew Flatt
+ * Created:     1996
+ * Copyright:   (c) 1996, Matthew Flatt
+ */
+
+#define Uses_XtIntrinsic
+#define Uses_XtIntrinsicP
+#define Uses_XLib
+
+#include "wx_main.h"
+#include "wx_media.h"
+#include "scheme.h"
+
+#if defined(wx_motif)
+#include <X11/Xlib.h>
+#include <X11/keysymdef.h>
+#endif
+
+#include "mred.h"
+
+static int short_circuit = 0, just_check = 0, checking_for_break = 0;
+#ifdef wx_xt
+static Widget just_this_one;
+#else
+static MrEdContext *just_this_one;
+#endif
+
+#ifdef wx_xt
+static Widget orig_top_level;
+static Widget save_top_level = 0;
+#endif
+
+static KeyCode breaking_code;
+static int breaking_code_set = 0;
+
+#ifdef wx_xt
+static Widget *grab_stack, grabber;
+static int grab_stack_pos = 0, grab_stack_size = 0;
+#define WSTACK_INC 3
+
+extern "C" {
+  void wxAddGrab(Widget w)
+    {
+      if (!grab_stack_pos) {
+	Widget *naya;
+	grab_stack_size += WSTACK_INC;
+	naya = (Widget *)scheme_malloc(grab_stack_size * sizeof(Widget));
+	memcpy(naya + WSTACK_INC, grab_stack, (grab_stack_size - WSTACK_INC) * sizeof(Widget));
+	grab_stack = naya;
+	grab_stack_pos = WSTACK_INC;
+      }
+
+      grabber = grab_stack[--grab_stack_pos] = w;
+    }
+
+  void wxRemoveGrab(Widget w)
+    {
+      if (w != grabber)
+	return;
+
+      if (++grab_stack_pos < grab_stack_size)
+	grabber = grab_stack[grab_stack_pos];
+      else
+	grabber = NULL;
+    }
+};
+#endif
+
+#ifdef wx_motif
+Scheme_Hash_Table *registered_widgets;
+
+void wxRegisterFrameWidget(Widget w)
+{
+  if (!registered_widgets) {
+    /* Use SCHEME_hash_weak_ptr so elements can be deleted from the table */
+    registered_widgets = scheme_hash_table(7, SCHEME_hash_weak_ptr, 0, 0);
+  }
+
+  Scheme_Bucket *b;
+  
+  b = scheme_bucket_from_table(registered_widgets, (const char *)w);
+  b->val = (void *)MrEdGetContext();
+}
+
+void wxUnregisterFrameWidget(Widget w)
+{
+  if (!registered_widgets)
+    return;
+
+  if (scheme_lookup_in_table(registered_widgets, (const char *)w)) {
+    Scheme_Bucket *b;
+    
+    b = scheme_bucket_from_table(registered_widgets, (const char *)w);
+    /* Removes from hash table: */
+    *(void **)b->key = NULL;
+  }
+}
+
+static MrEdContext *WidgetContext(Widget w)
+{
+  if (!registered_widgets)
+    return NULL;
+
+  void *v = scheme_lookup_in_table(registered_widgets, (const char *)w);
+
+  return (MrEdContext *)v;
+}
+
+typedef struct IdleCallback {
+  MrEdContext *context;
+  void (*f)(void *);
+  void *data;
+  struct IdleCallback *next;
+} IdleCallback;
+
+IdleCallback *idleList = NULL;
+
+void wxRegsiterIdleCallback(void (*f)(void *), void *data, wxWindow *w)
+{
+  IdleCallback *i = new IdleCallback, *j = idleList;
+  i->next = NULL;
+  i->f = f;
+  i->data = data;
+  i->context = MrEdGetContext(w);
+
+  if (j) {
+    while (j->next)
+      j = j->next;
+    j->next = i;
+  } else
+    idleList = i;
+}
+
+#endif
+
+#if wx_xt
+Widget wxGetAppToplevel()
+{
+  if (save_top_level)
+    return save_top_level;
+  else
+    return MrEdGetContext()->finalized->toplevel;
+}
+
+void wxPutAppToplevel(Widget w)
+{
+  save_top_level = w;
+}
+#endif
+
+void MrEdInitFirstContext(MrEdContext *c)
+{
+#ifdef wx_xt
+  orig_top_level = save_top_level;
+  c->finalized->toplevel = save_top_level;
+  save_top_level = 0;
+#endif
+}
+
+void MrEdInitNewContext(MrEdContext *c)
+{
+#ifdef wx_xt
+  wxInitNewToplevel();
+  c->finalized->toplevel = save_top_level;
+  save_top_level = 0;
+#endif
+}
+
+void MrEdDestroyContext(MrEdFinalizedContext *c)
+{
+#ifdef wx_xt
+  XtDestroyWidget(c->toplevel);
+#endif
+}
+
+Window GetEventWindow(XEvent *e)
+{
+  Window window = 0;
+
+#define WINCASEEX(type, record, field) case type: window = e->record.field; break
+#define WINCASE(type, record) WINCASEEX(type, record, window)
+
+  switch (e->type) {
+    WINCASE(MappingNotify, xmapping);
+    WINCASE(ClientMessage, xclient);
+    WINCASE(SelectionClear, xselectionclear);
+    WINCASEEX(SelectionNotify, xselection, requestor);
+    WINCASEEX(SelectionRequest, xselectionrequest, owner);
+    WINCASE(ButtonPress, xbutton);
+    WINCASE(ButtonRelease, xbutton);
+    WINCASE(MotionNotify, xmotion);
+    WINCASE(ColormapNotify, xcolormap);
+    WINCASE(EnterNotify, xcrossing);
+    WINCASE(LeaveNotify, xcrossing);
+    WINCASE(FocusIn, xfocus);
+    WINCASE(FocusOut, xfocus);
+    WINCASE(Expose, xexpose);
+    WINCASEEX(GraphicsExpose, xgraphicsexpose, drawable);
+    WINCASEEX(NoExpose, xnoexpose, drawable);
+    WINCASE(VisibilityNotify, xvisibility);
+    WINCASE(KeyPress, xkey);
+    WINCASE(KeyRelease, xkey);
+    WINCASE(KeymapNotify, xkeymap);
+    WINCASE(PropertyNotify, xproperty);
+    WINCASE(ResizeRequest, xresizerequest);
+    WINCASE(CirculateNotify, xcirculate);
+    WINCASE(ConfigureNotify, xconfigure);
+    WINCASE(DestroyNotify, xdestroywindow);
+    WINCASE(GravityNotify, xgravity);
+    WINCASE(MapNotify, xmap);
+    WINCASE(ReparentNotify, xreparent);
+    WINCASE(UnmapNotify, xunmap);
+    WINCASE(CirculateRequest, xcirculaterequest);
+    WINCASE(ConfigureRequest, xconfigurerequest);
+    WINCASE(MapRequest, xmaprequest);
+  }
+
+  return window;
+}
+
+#if 0
+char *get_event_type(XEvent *e)
+{
+
+#define NAMECASE(type) case type: return #type;
+
+  switch (e->type) {
+    NAMECASE(MappingNotify);
+    NAMECASE(ClientMessage);
+    NAMECASE(SelectionClear);
+    NAMECASE(SelectionNotify);
+    NAMECASE(SelectionRequest);
+    NAMECASE(ButtonPress);
+    NAMECASE(ButtonRelease);
+    NAMECASE(MotionNotify);
+    NAMECASE(ColormapNotify);
+    NAMECASE(EnterNotify);
+    NAMECASE(LeaveNotify);
+    NAMECASE(FocusIn);
+    NAMECASE(FocusOut);
+    NAMECASE(Expose);
+    NAMECASE(GraphicsExpose);
+    NAMECASE(NoExpose);
+    NAMECASE(VisibilityNotify);
+    NAMECASE(KeyPress);
+    NAMECASE(KeyRelease);
+    NAMECASE(KeymapNotify);
+    NAMECASE(PropertyNotify);
+    NAMECASE(ResizeRequest);
+    NAMECASE(CirculateNotify);
+    NAMECASE(ConfigureNotify);
+    NAMECASE(DestroyNotify);
+    NAMECASE(GravityNotify);
+    NAMECASE(MapNotify);
+    NAMECASE(ReparentNotify);
+    NAMECASE(UnmapNotify);
+    NAMECASE(CirculateRequest);
+    NAMECASE(ConfigureRequest);
+    NAMECASE(MapRequest);
+  }
+}
+#endif
+
+static Bool CheckPred(Display *display, XEvent *e, char *args)
+{
+  if (short_circuit)
+    return FALSE;
+
+#if 0
+  printf("trying %s\n", get_event_type(e));
+#endif
+
+  Window window = GetEventWindow(e);
+  Widget widget;
+
+  if (window)
+    widget = XtWindowToWidget(display, window);
+  else
+    widget = 0;
+
+  if (widget) {
+    Widget parent;
+    for (parent = widget; XtParent(parent); parent = XtParent(parent));
+    
+#ifdef wx_motif
+    MrEdContext *parent_context = WidgetContext(parent);
+#endif
+
+#if 0
+    printf("parent: %lx context: %lx\n", parent, parent_context);
+#endif
+
+    if (just_this_one) {
+      if (
+#ifdef wx_xt
+	  parent == just_this_one
+#else
+	  just_this_one == parent_context
+#endif
+	  ) {
+	if (checking_for_break) {
+	  if (e->type == KeyPress) {
+	    if ((e->xkey.state & ControlMask) 
+#if BREAKING_REQUIRES_SHIFT
+		&& (e->xkey.state & ShiftMask)
+#endif
+		&& (e->xkey.keycode == breaking_code))
+	      goto found;
+	  }
+	} else {
+	  goto found;
+	}
+      } else {
+#if 0
+	printf("wrong eventspace (%lx != %lx)\n", just_this_one, parent_context);
+#endif
+      }
+    } else {
+      MrEdContext *c;
+      
+      for (c = mred_contexts; c; c = c->next)
+	if (
+#ifdef wx_xt
+	    c->finalized->toplevel == parent
+#else
+	    c == parent_context
+#endif
+	    ) {
+	  if (!c->ready) {
+#if 0
+	    printf("not ready\n");
+#endif
+	    return FALSE;
+	  } else {
+	    *(MrEdContext **)args = c;
+	    goto found;
+	  }
+	}
+
+      /* Toplevel without context; perhaps it's the main context: */
+      if (checking_for_break)
+	return FALSE;
+      else
+	goto found;
+    }
+
+  } else {
+#if 0
+    printf("warning: window->widget mapping failed!\n");
+#endif
+    if (checking_for_break)
+      return FALSE;
+    else
+      goto found;
+  }
+
+  return FALSE;
+
+ found:
+  if (just_check) {
+    short_circuit = TRUE;
+    return FALSE;
+  } else
+    return TRUE;
+}
+
+
+int MrEdGetNextEvent(int check_only, int current_only, 
+		     XEvent *event, MrEdContext **which)
+{
+  Display *d;
+
+  if (which)
+    *which = NULL;
+
+  just_check = check_only;
+#ifdef wx_xt
+  just_this_one = (current_only ? wxGetAppToplevel() : (Widget)NULL);
+#else
+  just_this_one = (current_only ? MrEdGetContext() : NULL);
+#endif
+
+#ifdef wx_motif
+  d = XtDisplay(wxTheApp->topLevel);
+#else
+  if (!orig_top_level)
+    d = XtDisplay(save_top_level);
+  else
+    d = XtDisplay(orig_top_level);
+#endif
+
+  if (XCheckIfEvent(d, event, CheckPred, (char *)which)) {
+    just_check = 0;
+    return 1;
+  } else if (short_circuit) {
+    short_circuit = 0;
+    return 1;
+  }
+
+#ifdef wx_motif
+  if (idleList) {
+    MrEdContext *c = MrEdGetContext();
+    IdleCallback *i = idleList, *prev = NULL, *x;
+
+    while (i) {
+      if (!current_only || (idleList->context == c)) {
+	x = i;
+	i = i->next;
+	if (prev)
+	  prev->next = i;
+	else
+	  idleList = i;
+
+	x->f(x->data);
+      } else {
+	prev = i;
+	i = i->next;
+      }
+    }
+  }
+#endif
+
+  return 0;
+}
+
+Scheme_Hash_Table *disabled_widgets;
+
+void wxSetSensitive(Widget w, Bool enabled)
+{
+  if (!disabled_widgets) {
+    if (enabled)
+      return;
+
+    /* Use SCHEME_hash_weak_ptr so elements can be deleted from the table */
+    disabled_widgets = scheme_hash_table(7, SCHEME_hash_weak_ptr, 0, 0);
+  }
+
+  if (enabled) {
+    if (scheme_lookup_in_table(disabled_widgets, (const char *)w)) {
+      /* Removes from hash table: */
+      scheme_change_in_table(disabled_widgets, (const char *)w, NULL);
+    }
+  } else {
+    Scheme_Bucket *b;
+
+    b = scheme_bucket_from_table(disabled_widgets, (const char *)w);
+    b->val = (void *)0x1;
+  }
+}
+
+Display *MrEdGetXDisplay(void)
+{
+#ifdef wx_motif
+  return XtDisplay(wxTheApp->topLevel);
+#else
+  if (!orig_top_level)
+    return XtDisplay(save_top_level);
+  else
+    return XtDisplay(orig_top_level);
+#endif
+}
+
+void MrEdDispatchEvent(XEvent *event)
+{
+  if (disabled_widgets) {
+    int type = event->type;
+    Display *d;
+    
+    d = MrEdGetXDisplay();
+
+    if ((type == KeyPress)
+	|| (type == KeyRelease)
+	|| (type == ButtonPress)
+	|| (type == ButtonRelease)
+	|| (type == MotionNotify)
+	|| ((type == ClientMessage)
+	    && !strcmp(XGetAtomName(d, event->xclient.message_type), "WM_PROTOCOLS")
+	    && !strcmp(XGetAtomName(d, event->xclient.data.l[0]), "WM_DELETE_WINDOW"))) {
+      Window window = GetEventWindow(event);
+      Widget widget, ow;
+
+      if (window)
+	widget = XtWindowToWidget(d, window);
+      else
+	widget = 0;
+      ow = widget;
+
+      while (widget) {
+#ifdef wx_xt
+	if (widget == grabber)
+	  break;
+#endif
+	if (scheme_lookup_in_table(disabled_widgets, (const char *)widget)) {
+#if 0
+	  printf("disabled for %s: %lx from %lx\n", get_event_type(event), widget, ow);
+#endif
+#ifdef wx_motif
+	  if (type == ButtonPress
+	      || type == ButtonRelease) {
+	    /* Mouse down: make sure the event is dispatched, but redirect it to a harmless
+	       window. Otherwise, if a popup menu is active, Motif gets confused. */
+	    extern wxFrame *mred_real_main_frame;
+	    if (mred_real_main_frame) {
+	      event->xbutton.window = XtWindow(mred_real_main_frame->clientArea);
+	      break;
+	    }
+	  }
+#endif
+	  return;
+	}
+	widget = XtParent(widget);
+      }
+    }
+  }
+
+  XtDispatchEvent(event);
+}
+
+int MrEdCheckForBreak(void)
+{
+  int br;
+  XEvent e;
+  Display *d;
+
+#ifdef wx_motif
+  d = XtDisplay(wxTheApp->topLevel);
+#else
+  if (!orig_top_level)
+    d = XtDisplay(save_top_level);
+  else
+    d = XtDisplay(orig_top_level);
+#endif
+
+  if (!breaking_code_set) {
+    breaking_code = XKeysymToKeycode(d, 'c');
+    breaking_code_set = 1;
+  }
+
+  XFlush(d);
+
+  checking_for_break = 1;
+  br = MrEdGetNextEvent(0, 1, &e, NULL);
+  checking_for_break = 0;
+
+  return br;
+}
+
+#ifdef wx_xt
+#include "wx_timer.h"
+
+class wxXtTimer : public wxTimer
+{
+public:
+  XtTimerCallbackProc callback;
+  XtPointer data;
+  int ok;
+
+  wxXtTimer(XtTimerCallbackProc c, XtPointer d) : wxTimer()
+    {
+      callback = c;
+      data = d;
+      ok = 1;
+    }
+
+  void Stopped() { ok = 0; }
+
+  void Notify(void) {
+    wxYield();
+    if (ok)
+      callback(data, NULL);
+  }
+};
+
+extern "C" {
+
+  void wxRemoveTimeOut(long timer)
+    {
+      ((wxTimer *)timer)->Stop();
+      ((wxXtTimer *)timer)->Stopped();
+    }
+  
+  long wxAppAddTimeOut(XtAppContext, unsigned long interval, 
+		       XtTimerCallbackProc callback, XtPointer data)
+    {
+      wxTimer *t = new wxXtTimer(callback, data);
+      t->Start(interval, TRUE);
+      return (long)t;
+    }
+}
+#endif
+
diff --git a/src/mred/openbugs b/src/mred/openbugs
new file mode 100644
index 0000000..0412ae6
--- /dev/null
+++ b/src/mred/openbugs
@@ -0,0 +1,73 @@
+
+* skill-focus
+
+* command-event: string for text events
+
+* when an overridden function returns the wrong type,
+   bad error message (says "expects")
+
+* MacOS needs way to control the 0-window menu bar
+
+* X Windows and drawing into b & w bitmaps: black and white
+  are reversed when using certain kinds of displays
+
+* wx:dc%'s draw-arc is undefined when input isn't
+  consistent with a circle
+
+* Windows: set-user-scale with wx:memory-dc% doesn't work right
+
+* MacOS: busy-cursor state is wrong for new windows when the
+   busy cursor is active
+
+* pasteboards: printing not yet implemented
+
+* need to penalize the current thread more for certain primitive
+   operations that can take a long time (e.g., loading a bitmap
+   or saving a file)
+
+* need directory-selection dialog
+
+* Keys like KP_end, etc. are not currently accessible
+
+* doc: [Mr] clarify "owning the caret" with respect to ownership by the parent, etc.
+
+* Motif: get-file dialog modality is wrong for eventspaces
+
+* Windows and MacOS: "primitive" dialogs don't get closed by
+   custodian-shutdown-all
+
+* MacOS: std file dialog and print dialogs block MzScheme threads
+
+* how does wx:dc% get-size interact with the user scale?
+
+* the full width for non-wrapped lines need not include the autowrap bitmap
+
+* should use a guranteed offset for stippling in buffer redraws
+
+* Xt: out-of-colours - widgets use too much black
+
+* signature include: unbalanced parens => diverge?
+
+* drag outisde view => should keep going even if mouse is still
+
+* hidden files - add a MzScheme predicate?
+
+* dragging selection shouldn't keep changing the auto-X-selection
+
+* Xt: busy cursor not shown in the menu bar
+
+* editor buffers should show a blinking caret
+
+* Motif: menus don't work with multiple displays
+
+* Motif: wxDialogBox doesn't obey current display for multiple displays
+
+* add background colour for buffers?
+
+* updating bug?: long flash, not on same line, update on focus-in
+
+* add paragraph styles?
+
+* need better de-fragmentation of text snips
+
+* need to show a mystery snip icon when unknown data is loaded from a file
diff --git a/src/mred/relbin b/src/mred/relbin
new file mode 100755
index 0000000..a228071
--- /dev/null
+++ b/src/mred/relbin
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+RDIST=rdist
+
+if [ "-r" = "$1" ] ; then
+  shift
+  RDIST=$1
+  shift
+fi
+
+if [ "-self" = "$1" ] ; then
+  shift
+  FARHOST=`hostname`
+else
+  FARHOST=asia
+fi
+
+MRSYS=`/home/scheme/plt/bin/archsys -`$1
+
+MRDEST=/home/scheme/plt/.bin/${MRSYS}/mred
+
+echo ${MRBUILDDIR}mred to ${MRDEST}
+
+strip ${MRBUILDDIR}mred
+
+echo Installing MrEd
+echo "${MRBUILDDIR}mred -> ${FARHOST} install $MRDEST ;" | $RDIST -f -
diff --git a/src/mred/wxme/COPYING.LIB b/src/mred/wxme/COPYING.LIB
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/src/mred/wxme/COPYING.LIB
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/src/mred/wxme/Makefile b/src/mred/wxme/Makefile
new file mode 100644
index 0000000..b0a6066
--- /dev/null
+++ b/src/mred/wxme/Makefile
@@ -0,0 +1,106 @@
+
+include $(WXDIR)/src/make$(MZPLATFORMSUFFIX).env
+
+OBJDIR=objects/sys$(MZPLATFORMSUFFIX)$(GUISUFFIX)
+
+# Don't use wx_gclip.o in wxWindows 1.62(f) or later
+CLIPOBJ = 
+# CLIPOBJ = $(OBJDIR)/wx_gclip.o
+
+# GCLIBS used only for edjr
+# Don't need GC objects unless you're compiling with garbage collection on
+GCLIBS =
+# GCLIBS = -L../mzscheme/lib/sys -lgc
+
+OBJECTS = $(OBJDIR)/wx_style.o $(CLIPOBJ) $(OBJDIR)/wx_keym.o $(OBJDIR)/wx_mbuf.o \
+          $(OBJDIR)/wx_media.o $(OBJDIR)/wx_mpriv.o $(OBJDIR)/wx_msnip.o \
+          $(OBJDIR)/wx_mline.o $(OBJDIR)/wx_mpbrd.o \
+          $(OBJDIR)/wx_medad.o $(OBJDIR)/wx_snip.o $(OBJDIR)/wx_cgrec.o \
+          $(OBJDIR)/wx_medio.o
+
+ALLHEADERS = wx_ptreq.h wx_mtype.h
+HEADERS = wx_media.h wx_medad.h wx_cgrec.h wx_medio.h wx_style.h \
+          $(ALLHEADERS)
+
+# Used only when bundling a distribution
+HIDEDIR = /home/mflatt/mredhide
+
+$(OBJDIR)/libwxme.a: objects $(OBJDIR) $(OBJECTS)
+	$(AR) ruv $(OBJDIR)/libwxme.a $(OBJECTS)
+	$(RANLIB) $(OBJDIR)/libwxme.a
+
+$(OBJDIR): 
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+edjr: $(OBJDIR) $(OBJDIR)/libwxme.a $(OBJDIR)/edjr.o $(OBJDIR)/edjrmain.o
+	$(LINKER) $(CPPFLAGS) $(LDFLAGS) -L$(OBJDIR) -o edjr $(OBJDIR)/edjr.o $(OBJDIR)/edjrmain.o -lwxme $(LDLIBS) $(GCLIBS)
+
+MCC = $(CXX) $(CPPFLAGS) $(LOCALFLAGS) -c
+
+$(OBJDIR)/wx_media.o : wx_media.cxx $(HEADERS) wx_keym.h wx_snip.h wx_gclip.h \
+                       wx_mpriv.h wx_mline.h
+	$(MCC) wx_media.cxx -o $(OBJDIR)/wx_media.o
+
+$(OBJDIR)/wx_mpriv.o : wx_mpriv.cxx $(HEADERS) wx_keym.h wx_snip.h wx_gclip.h wx_mpriv.h \
+                       wx_mline.h wx_gcrct.h
+	$(MCC) wx_mpriv.cxx -o $(OBJDIR)/wx_mpriv.o
+
+$(OBJDIR)/wx_msnip.o : wx_msnip.cxx $(HEADERS) wx_keym.h wx_snip.h wx_gclip.h wx_madm.h \
+                       wx_mpriv.h wx_gcrct.h
+	$(MCC) wx_msnip.cxx -o $(OBJDIR)/wx_msnip.o
+
+$(OBJDIR)/wx_mline.o : wx_mline.cxx wx_mline.h wx_snip.h $(HEADERS)
+	$(MCC) wx_mline.cxx -o $(OBJDIR)/wx_mline.o
+
+$(OBJDIR)/wx_mpbrd.o : wx_mpbrd.cxx $(HEADERS) wx_keym.h wx_snip.h wx_medpb.h
+	$(MCC) wx_mpbrd.cxx -o $(OBJDIR)/wx_mpbrd.o
+
+$(OBJDIR)/wx_medad.o : wx_medad.cxx $(HEADERS) wx_snip.h
+	$(MCC) wx_medad.cxx -o $(OBJDIR)/wx_medad.o
+
+$(OBJDIR)/wx_mbuf.o : wx_mbuf.cxx $(HEADERS) wx_keym.h wx_snip.h
+	$(MCC) wx_mbuf.cxx -o $(OBJDIR)/wx_mbuf.o
+
+$(OBJDIR)/wx_snip.o : wx_snip.cxx $(HEADERS) wx_gcrct.h
+	$(MCC) wx_snip.cxx -o $(OBJDIR)/wx_snip.o
+
+$(OBJDIR)/wx_cgrec.o : wx_cgrec.cxx $(HEADERS) wx_snip.h
+	$(MCC) wx_cgrec.cxx -o $(OBJDIR)/wx_cgrec.o
+
+$(OBJDIR)/wx_keym.o : wx_keym.cxx wx_keym.h $(ALLHEADERS)
+	$(MCC) wx_keym.cxx -o $(OBJDIR)/wx_keym.o
+
+$(OBJDIR)/wx_medio.o : wx_medio.cxx wx_medio.h $(ALLHEADERS)
+	$(MCC) wx_medio.cxx -o $(OBJDIR)/wx_medio.o
+
+$(OBJDIR)/wx_gclip.o : wx_gclip.cxx wx_gclip.h $(ALLHEADERS)
+	$(MCC) wx_gclip.cxx -o $(OBJDIR)/wx_gclip.o 
+
+$(OBJDIR)/wx_style.o : wx_style.cxx wx_style.h wx_medio.h $(ALLHEADERS)
+	$(MCC) wx_style.cxx -o $(OBJDIR)/wx_style.o 
+
+$(OBJDIR)/edjr.o : edjr.cxx edjr.h  wx_media.h wx_medad.h
+	$(MCC) edjr.cxx -o $(OBJDIR)/edjr.o
+
+$(OBJDIR)/edjrmain.o : edjrmain.cxx edjr.h
+	$(MCC) edjrmain.cxx -o $(OBJDIR)/edjrmain.o
+
+clean:
+	rm -f objects/*/* *~
+
+exile-common:
+	rm -f *~ libwxme.a edjr
+	mkdir $(HIDEDIR)/wxme_objects
+	mv objects $(HIDEDIR)/wxme_objects
+
+exile:
+	$(MAKE) exile-common
+
+soft-exile:
+	$(MAKE) exile-common
+
+repatriate:
+	mv $(HIDEDIR)/wxme_objects/objects .
+	rmdir $(HIDEDIR)/wxme_objects
diff --git a/src/mred/wxme/README b/src/mred/wxme/README
new file mode 100644
index 0000000..4eeaa82
--- /dev/null
+++ b/src/mred/wxme/README
@@ -0,0 +1,205 @@
+
+This directory contains source for the wxMedia class library for
+wxWindows. To compile the library libwxme.a (in UNIX), you will need
+to set the environment variable WXDIR.
+
+This code should work with wxWindows 1.62(e) and later versions.
+
+If your platform stores the least-significant byte of an integer or
+floating-point first, then add -DWXME_LSB_FIRST=1 to the flags in
+`make.env'. All Intel machines need this flag, so it's done
+automatically for Windows. The wxMedia classes will work fine if you
+get this wrong, but files saved to disk will not be readable on other
+platforms.
+
+If you are using 1.62(e) or an earlier version, you will need to add
+-DOLD_WXWINDOWS=1 to the list of compiler flags, and you will need to
+edit the Makefile to add wx_gclip.o to the list of object files.
+
+If you are using 1.63 or an earlier version, you will need to
+add -DNO_GENERAL_FONTS to the list of compiler flags.
+
+If use are using 1.66 or an earlier version (in which the method
+wxDC::GetClippingRegion is not defined), you will need to add
+-DNO_GET_CLIPPING_REGION to the list of compiler flags. You may
+need to add -DEACH_BUFFER_OWN_OFFSCREEN to get correct drawing.
+
+If use are using 1.66 or an earlier version (in which the method
+wxDC::GetTextExtent does not use the font argument), you will need to
+add -DBROKEN_GET_TEXT_EXTENT to the list of compiler flags. 
+
+If you are using wxxt 1.64, you may have to comment out the call to
+XClearArea() in wxWindow::Refresh() in wxxt/src/Windows/Window.cc.
+
+The Makefile provided here creates a library file
+objects/sys/libwxme.a. 'make edjr' creates the demo executeable 'edjr'
+(Ed Jr.).
+
+-Matthew
+ mflatt@cs.rice.edu
+
+-------------------------------------------------------------------------
+
+License:
+--------
+
+wxMedia is distributed under the GNU Library General Public License
+(LGPL).  This means you can link wxMedia into proprietary
+applications, provided you follow the specific rules stated in the
+LGPL.  You can also modify wxMedia; if you distribute a modified
+version, you must distribute it under the terms of the LGPL, which in
+particular means that you must release the source code for the
+modified wxMedia. See COPYING.LIB for more information.
+
+-------------------------------------------------------------------------
+
+History:
+--------
+
+Version 51: ??, 1997
+Added wxMediaAdmin::GetMaxWidth()
+
+Version 50: August 26, 1997
+Added argument to wxMediaBuffer::Print()
+
+Version 49: May 31, 1997
+Adjusted wxSnipAdmin methods: GetView and GetViewSize
+
+Version 48: Skipped to avoid confusion with Scheme48
+
+Version 47: January 11, 1997
+Made wxCanvasMediaAdmin and wxMediaSnipMediaAdmin explicit
+Changed how LoadFile deals with the current style list (replaces
+  named styles instead of erasing all first)
+Fixed bug in wxImageSnip copy/free
+
+Version 46: December 5, 1996
+Incremented version number
+
+Version 45: November 12, 1996
+Added transparent text backing
+WXME file format incremented to version 3 (for trans text backing)
+ When reading version 1 & 2 files, style deltas with non-zero
+ background addition also turn off transparent text backing.
+Added overwrite mode to the editor
+Fixed text-wrapping (even yet again)
+
+Version 44: September 9, 1996
+Fixed file saving - was especially broken for Windows
+Image snips can be saved as inlined in a wxMedia file
+wxMediaBuffer::OnInsertImage added arg for inlining image
+Fixed text-wrapping (yet again)
+Fixed biased scrolling (yet again)
+Smaller wxTextSnip instances
+
+Version 43: Re-released August 12, 1996
+Under GNU LGPL license
+
+Version 43: August 9, 1996
+MacOS/Windows printing through wxPrinter/wxPrinterDC
+Added wxMediaEdit OnLoadFile, AfterSaveFile, AfterLoadFile, AfterSetPosition
+Added lazy-refresh mode for canvases
+Flattened newlines are platform-dependent
+Added inactive focus display
+wxSnip::Draw and wxMediaBuffer::OnPaint's last arg changed to int
+Complicated Makefile: binaries go to ./objects/sys
+Patched for wxWindows 1.66 and wxxt 1.64
+
+Version 42: June 8, 1996
+Copy ring added (like an Emacs kill-ring)
+Keymap extensions: key & mouse grabs
+Give unknown snip class warning only when class is used for loading
+Fixed bug in mapping saved snip classes to active classes
+Added wxMediaEdit::OnStyleChange (and ...After...)
+Fixed wxSnip::ReleaseFromOwner when owning buffer lies
+
+Version 0.41: April 16, 1996
+Pasteboards fixed (not completed, though)
+
+Version 0.40: March 24, 1996
+Added callOnDown arg to SetClickback()
+Shared offscreen buffer properly freed after last buffer is released.
+Text color bug fixed when using nested buffers
+
+Version 0.39: March 6, 1996
+Made file format indepedent of wxWindows port values for wxDEFAULT, etc.
+  (Xt port reads & writes corerctly now)
+New flags for wx:MedaiEdit::Insert and wxMediaEdit::Delete for scrolling
+Improved wordbreak algorithm to handle really long lines
+Keymaps much more lightweight, espcecially empty ones
+Buffer/editor keymap no longer initialized with buffer/editor functions
+
+Version 0.38: February 22, 1996
+Xt version ready
+Fixed number i/o for some compilers that treat char as unsigned char
+Fixed hiding one custom scrollbar (XView and Xt only)
+Fixed file reading bug for numbers on AIX machines
+Improved OnSize handling in canvas to avoid redundancy
+
+Version 0.37: unreleased
+
+Version 0.36: January 18, 1996
+Incremented version number
+
+Version 0.35: January 17, 1996
+X selection machanism supported (X-Windows only); enable/disable with:
+    void wxMediaSetXSelectionMode(Bool on);
+ See also wxMediaEdit::SetPosition() in the manual.
+Uses a single offscreen bitmap for all buffers
+Fixed bug in line spacing when using different alignments
+Fixed bug in vertical scroll bias and use of bias by vertical selection
+wxMediaEdit::HideCaret
+wxMediaEdit::SetBetweenThreshold
+Page up & down more Emacs-like
+PutFile & GetFile use of wxFileSelector fixed (fixes crash)
+
+Version 0.34: December 30, 1995
+wxMediaBuffer::GetFile() and wxMediaBuffer::PutFile() added
+
+Version 0.33: December 21, 1995
+wxMediaEdit::SetAutowrapBitmap() added
+
+Version 0.32: December 4, 1995
+Fixed several MS Windows problems
+wxMEDIA_FF_COPY added
+wxMediaBuffer::OnSaveFile() added
+wxKeymap chaining changed
+
+Version 0.31: November 14, 1995
+Fixed memory bug related to cut-n-paste and saving
+wxMedia::PositionParagraph, etc. added
+wxMedia::OnNewTextSnip, etc. added
+Tabs fixed (they adjust themselves when you insert more text)
+wxReadMediaGlobalHeader, etc. for read/writing buffers
+
+Version 0.30: October 25, 1995
+wxMediaPasteboard implemented more
+
+Version 0.29: October 18, 1995
+Editor can save text preserving automatic CR
+Bug fixes in automatic line-wrapping
+`int' in some internal line procedures changed to `long'
+Uses new wxWindows font systems to access more fonts
+
+Version 0.28: October 3, 1995
+Fixed word-brekaing on characters with ASCII values > 127
+
+Version 0.27: September 30, 1995
+Minor changes
+
+Version 0.26: September 8, 1995
+Very minor changes
+
+Version 0.25: September 7, 1995
+Upgraded to wxWindows 1.63
+
+Version 0.24: September 1, 1995
+Printing support improved
+
+Version 0.23: August 23, 1995
+Added wxImageSnip class for displaying images
+
+Version 0.22: August 17, 1995
+Fixed stream functions GetFixed, PutFixed, and Get/Put on
+  doubles to store/read in a machine-independent manner.
+  To make files created earlier portable, open and re-save them.
diff --git a/src/mred/wxme/edjr.cxx b/src/mred/wxme/edjr.cxx
new file mode 100644
index 0000000..622c42b
--- /dev/null
+++ b/src/mred/wxme/edjr.cxx
@@ -0,0 +1,296 @@
+/*
+ * File:        edjr.cc
+ * Purpose:     EdJr - for demonstration of wxMedia classes
+ *                and backup editor in MrEd
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+ */
+
+#include "wx_frame.h"
+#include "wx_main.h"
+#include "wx_menu.h"
+#include "wx_utils.h"
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_media.h"
+#include "edjr.h"
+
+class EdJrWindow : public wxFrame
+{
+public:
+  wxMediaCanvas *display;
+  wxMediaEdit *media;
+
+  int editOffset, fontOffset;
+
+  EdJrWindow *parent;
+
+  wxList *children;
+
+  EdJrWindow(char *filename, EdJrWindow *parent);
+  ~EdJrWindow();
+
+  void OnSize(int x, int y);
+  void OnMenuCommand(int op);
+
+  Bool OnClose(void);
+};
+
+#ifdef wx_xt
+# define MARGIN 0
+#else
+# define MARGIN 2
+#endif
+
+wxFrame *MakeEdJrFrame(void)
+{
+  return new EdJrWindow(NULL, NULL);
+}
+
+enum {
+  EdJrFILE_OPEN = 1,
+  EdJrFILE_SAVE,
+  EdJrFILE_SAVE_AS,
+  EdJrFILE_SAVE_AS_TEXT,
+  EdJrFILE_SAVE_AS_FORMATTED,
+  EdJrFILE_RELOAD,
+  EdJrFILE_NEW_FRAME,
+  EdJrFILE_QUIT,
+  EdJrLAST_MENU_PLUS_ONE
+  };
+
+EdJrWindow::EdJrWindow(char *filename, EdJrWindow *mainParent)
+: wxFrame(NULL, "EdJr", -1, -1, 600, 400, wxDEFAULT_FRAME + wxSDI, "EdJr")
+{
+  wxMenuBar *menubar;
+  wxMenu *file, *edit;
+  wxKeymap *km;
+
+  display = new wxMediaCanvas(this);
+
+  media = new wxMediaEdit();
+  display->SetMedia(media);
+
+  menubar = new wxMenuBar();
+
+#ifdef wx_mac
+#define OPEN_SUFFIX "\tCmd+O"
+#define SAVE_SUFFIX "\tCmd+S"
+#define NEW_SUFFIX "\tCmd+N"
+#define CLOSE_SUFFIX "\tCmd+W"
+#else
+#define OPEN_SUFFIX
+#define SAVE_SUFFIX
+#define NEW_SUFFIX
+#define CLOSE_SUFFIX
+#endif
+
+  file = new wxMenu();
+  file->Append(EdJrFILE_NEW_FRAME, "New" NEW_SUFFIX);
+  file->Append(EdJrFILE_OPEN, "Open..." OPEN_SUFFIX);
+  file->Append(EdJrFILE_RELOAD, "Reload");  
+  file->AppendSeparator();
+  file->Append(EdJrFILE_SAVE, "Save" SAVE_SUFFIX);
+  file->Append(EdJrFILE_SAVE_AS, "Save As...");
+  file->Append(EdJrFILE_SAVE_AS_TEXT, "Save As Text...");
+  file->Append(EdJrFILE_SAVE_AS_FORMATTED, "Save As Formatted...");
+  file->AppendSeparator();
+  file->Append(EdJrFILE_QUIT, 
+	       !mainParent 
+#ifndef wx_mac
+	       ? "E&xit" 
+#else
+	       ? "Quit\tCmd+Q" 
+#endif
+	       : "Close" CLOSE_SUFFIX);
+    
+  editOffset = EdJrLAST_MENU_PLUS_ONE;
+
+  edit = new wxMenu();
+  fontOffset = media->AppendEditItems(edit, editOffset);
+  edit->AppendSeparator();
+  media->AppendFontItems(edit, fontOffset);
+  
+  menubar->Append(file, "&File");
+  menubar->Append(edit, "&Edit");
+
+  SetMenuBar(menubar);
+
+  /* Map some basic keys: */
+  km = media->GetKeymap();
+  media->AddBufferFunctions(km);
+  media->AddEditorFunctions(km);
+
+  km->MapFunction("c:e", "end-of-line");
+  km->MapFunction("END", "end-of-line");
+  km->MapFunction("c:a", "beginning-of-line");
+  km->MapFunction("HOME", "beginning-of-line");
+
+  km->MapFunction("c:p", "previous-line");
+  km->MapFunction("c:n", "next-line");
+	
+  km->MapFunction("c:h", "delete-previous-character");
+  km->MapFunction("c:d", "delete-next-character");
+  km->MapFunction("c:f", "forward-character");
+  km->MapFunction("c:b", "backward-character");
+
+  km->MapFunction("m:f", "forward-word");
+  km->MapFunction("m:b", "backward-word");
+  km->MapFunction("m:d", "kill-word");
+  km->MapFunction("m:DEL", "backward-kill-word");
+
+  km->MapFunction("ESC;f", "forward-word");
+  km->MapFunction("ESC;b", "backward-word");
+  km->MapFunction("ESC;d", "kill-word");
+  km->MapFunction("ESC;DEL", "backward-kill-word");
+
+  km->MapFunction("m:s:<", "beginning-of-file");
+  km->MapFunction("m:s:>", "end-of-file");
+
+  km->MapFunction("ESC;s:<", "beginning-of-file");
+  km->MapFunction("ESC;s:>", "end-of-file");
+
+  km->MapFunction("c:v", "next-page");
+  km->MapFunction("m:v", "previous-page");
+  km->MapFunction("ESC;v", "previous-page");
+	
+  km->MapFunction("c:k", "delete-to-end-of-line");
+  km->MapFunction("c:y", "paste-clipboard");
+  km->MapFunction("a:v", "paste-clipboard");
+  km->MapFunction("c:s:_", "undo");
+  km->MapFunction("c:s:+", "redo");
+  km->MapFunction("a:z", "undo");
+  km->MapFunction("c:x;u", "undo");
+  km->MapFunction("c:w", "cut-clipboard");
+  km->MapFunction("a:x", "cut-clipboard");
+  km->MapFunction("m:w", "copy-clipboard");
+  km->MapFunction("ESC;w", "copy-clipboard");
+  km->MapFunction("a:c", "copy-clipboard");
+
+  Show(TRUE);
+
+  parent = mainParent;  
+  if (parent) {
+    parent->children->Append(this);
+    children = NULL;
+  } else
+    children = new wxList;
+
+  if (filename)
+    media->LoadFile(filename);
+
+#ifdef wx_mac
+  OnSize(600, 400);
+#endif
+}
+
+EdJrWindow::~EdJrWindow()
+{
+  wxNode *node, *next;
+
+  if (parent)
+    parent->children->DeleteObject(this);
+
+  if (children)
+    for (node = children->First(); node; node = next) {
+      next = node->Next();
+      delete (EdJrWindow *)node->Data();
+    }
+
+  delete display;
+}
+
+void EdJrWindow::OnMenuCommand(int op)
+{
+  if (!display)
+    return;
+
+  if (op >= fontOffset)
+    media->DoFont(op - fontOffset);
+  else if (op >= editOffset)
+    media->DoEdit(op - editOffset);
+  else {
+    switch(op) {
+    case EdJrFILE_OPEN:
+      media->LoadFile("");
+      break;
+    case EdJrFILE_SAVE:
+      media->SaveFile();
+      break;
+    case EdJrFILE_SAVE_AS:
+      media->SaveFile("");
+      break;
+    case EdJrFILE_SAVE_AS_TEXT:
+      media->SaveFile("", wxMEDIA_FF_TEXT);
+      break;
+    case EdJrFILE_SAVE_AS_FORMATTED:
+      media->SaveFile("", wxMEDIA_FF_STD);
+      break;
+    case EdJrFILE_RELOAD:
+      media->LoadFile();
+      break;
+    case EdJrFILE_NEW_FRAME:
+      (void)(new EdJrWindow(NULL, parent ? parent : this));
+      break;
+    case EdJrFILE_QUIT:
+      if (OnClose()) {
+	if (!parent)
+	  wxTheApp->ExitMainLoop();
+	delete this;
+      }
+      return;
+    }
+
+    char *s = media->GetFilename();
+    if (s)
+      SetTitle(wxFileNameFromPath(s));
+    else
+      SetTitle("EdJr");
+  }
+}
+
+void EdJrWindow::OnSize(int x, int y)
+{
+  int top_h;
+
+  GetClientSize(&x, &y);
+
+  top_h = 0;
+
+  if (display)
+    display->SetSize(MARGIN, MARGIN + top_h, 
+		     x - 2 * MARGIN, y - (2 * MARGIN + top_h));
+}
+
+Bool EdJrWindow::OnClose(void)
+{
+  if (media->Modified()) {
+    if (wxMessageBox("This file has been modified.\n\n"
+		     "Are you sure you want to quit?",
+		     "Warning", wxYES_NO) == wxNO)
+      return FALSE;
+  }
+  if (children) {
+    wxNode *node;
+    for (node = children->First(); node; node = node->Next()) {
+      EdJrWindow *child;
+      child = (EdJrWindow *)node->Data();
+      if (child->media->Modified()) {
+	if (wxMessageBox("An open file (in another frame) "
+			 "has been modified.\n\n"
+			 "Are you sure you want to quit?",
+			 "Warning", wxYES_NO) == wxNO)
+	  return FALSE;
+	break;
+      }
+    }
+  }
+
+  if (!parent)
+    wxTheApp->ExitMainLoop();
+
+  return TRUE;
+}
diff --git a/src/mred/wxme/edjr.h b/src/mred/wxme/edjr.h
new file mode 100644
index 0000000..3339f3c
--- /dev/null
+++ b/src/mred/wxme/edjr.h
@@ -0,0 +1,9 @@
+
+#ifndef _edjr
+#define _edjr
+
+class wxFrame;
+wxFrame *MakeEdJrFrame(void);
+
+#endif
+
diff --git a/src/mred/wxme/edjrmain.cxx b/src/mred/wxme/edjrmain.cxx
new file mode 100644
index 0000000..5d4f184
--- /dev/null
+++ b/src/mred/wxme/edjrmain.cxx
@@ -0,0 +1,92 @@
+/*
+ * File:        edjr.cc
+ * Purpose:     EdJr main file - demonstration of wxMedia classes
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+ */
+
+#include "wx.h"
+#include "wx_main.h"
+#include "wx_media.h"
+#include "edjr.h"
+
+class EdJrApp: public wxApp
+{
+public:
+  EdJrApp();
+  wxFrame *OnInit(void);
+};
+
+#if WX_FORCE_APP_CREATION
+EdJrApp *TheApp;
+#else
+EdJrApp TheApp;
+#endif
+
+EdJrApp::EdJrApp()
+{
+#ifdef wx_xt
+  SetClassName("EdJr");
+#else
+  wx_class = "EdJr";
+#endif
+}
+
+#ifdef WXME_FOR_MRED
+static wxStandardSnipClassList *snipClassList;
+static wxBufferDataClassList *bufferDataClassList;
+
+wxStandardSnipClassList *wxGetTheSnipClassList()
+{
+  return snipClassList;
+}
+
+wxBufferDataClassList *wxGetTheBufferDataClassList()
+{
+  return bufferDataClassList;
+}
+
+#endif
+
+wxFrame *EdJrApp::OnInit(void)
+{
+#ifdef WXME_FOR_MRED
+  snipClassList = wxMakeTheSnipClassList();
+  bufferDataClassList = wxMakeTheBufferDataClassList();
+#endif
+
+  wxInitMedia();
+
+  return MakeEdJrFrame();
+}
+
+#if WX_FORCE_APP_CREATION
+extern "C" { int wxEntry(int argc, char *argv[]); };
+
+/* Solves C++ problem of intializing TheApp for some compilers */
+int main(int argc, char *argv[])
+{
+  TheApp = new EdJrApp;
+  return wxEntry(argc, argv);
+}
+#endif
+
+#if WXGARBAGE_COLLECTION_ON
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+void gc_mark_external_invalid(void *sobj)
+{
+  /* Do nothing. */
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/src/mred/wxme/makefile.bcc b/src/mred/wxme/makefile.bcc
new file mode 100644
index 0000000..cef3c12
--- /dev/null
+++ b/src/mred/wxme/makefile.bcc
@@ -0,0 +1,105 @@
+#
+# File:        makefile.bcc
+# Purpose:     Makefile for wxMedia classes for Borland C++ 4.5.1
+# Author:      Lewis Tanzos
+# Created:     1996
+# Copyright:   (c) 1996, Lewis Tanzos
+# Notice:      This file was modified from the UNIX makefile provided 
+#               by the wxMedia libraries by Matthew Flatt
+#
+# INCLUDES "NO_GENERAL_FONTS" THAT REMOVES SOME wxMedia CAPABILITIES!
+#
+
+!if "$(BCCDIR)" == ""
+!error You must define the BCCDIR variable in autoexec.bat, e.g. BCCDIR=d:\bc4
+!endif
+
+# You may need to change WXWIN to WXDIR, depending on your version of
+# wxWindows:
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+CC = $(BCCDIR)\bin\bcc -P
+
+LIBDIR = -I$(WXWIN)\include\base -I$(WXWIN)\include\msw
+
+OBJECTS = wx_style.obj $(CLIPOBJ) wx_keym.obj wx_mbuf.obj \
+          wx_media.obj wx_mpriv.obj wx_msnip.obj wx_mline.obj wx_mpbrd.obj \
+          wx_medad.obj wx_snip.obj wx_cgrec.obj wx_medio.obj
+
+ALLHEADERS = wx_ptreq.h
+HEADERS = wx_media.h wx_medad.h wx_cgrec.h wx_keym.h wx_medio.h wx_style.h \
+          $(ALLHEADERS)
+
+libwxme.lib: $(OBJECTS)
+	del libwxme.lib
+	tlib /C libwxme.lib /P64 @&&!
++$(OBJECTS:.obj =.obj +)
+!
+
+LDLIBS = $(WXWIN)\lib\wx.lib
+CFG = $(WXWIN)\src\wxwin.cfg
+CPPFLAGS = @$(CFG)
+
+edjr:	edjr.exe
+
+edjr.exe: libwxme.lib edjr.obj edjrmain.obj
+	$(CC) $(CPPFLAGS) $(LDFLAGS) edjr.obj edjrmain.obj libwxme.lib $(LDLIBS)
+
+MCC = $(CC) $(CPPFLAGS) $(LOCALFLAGS) -c $(LIBDIR) -DNO_GENERAL_FONTS -ml 
+
+wx_media.obj : wx_media.cc $(HEADERS) wx_snip.h wx_gclip.h wx_mpriv.h wx_mline.h
+	$(MCC) wx_media.cc 
+
+wx_mpriv.obj : wx_mpriv.cc $(HEADERS) wx_snip.h wx_gclip.h wx_mpriv.h \
+             wx_mline.h wx_gcrct.h
+	$(MCC) wx_mpriv.cc 
+
+wx_msnip.obj : wx_msnip.cc $(HEADERS) wx_snip.h wx_gclip.h wx_mpriv.h wx_gcrct.h
+	$(MCC) wx_msnip.cc 
+
+wx_mline.obj : wx_mline.cc wx_mline.h wx_snip.h $(HEADERS)
+	$(MCC) wx_mline.cc 
+
+wx_mpbrd.obj : wx_mpbrd.cc $(HEADERS) wx_snip.h wx_medpb.h
+	$(MCC) wx_mpbrd.cc 
+
+wx_medad.obj : wx_medad.cc $(HEADERS) wx_snip.h
+	$(MCC) wx_medad.cc 
+
+wx_mbuf.obj : wx_mbuf.cc $(HEADERS) wx_snip.h
+	$(MCC) wx_mbuf.cc
+
+wx_snip.obj : wx_snip.cc $(HEADERS) wx_gcrct.h
+	$(MCC) wx_snip.cc
+
+wx_cgrec.obj : wx_cgrec.cc $(HEADERS)
+	$(MCC) wx_cgrec.cc
+
+wx_keym.obj : wx_keym.cc wx_keym.h $(ALLHEADERS)
+	$(MCC) wx_keym.cc 
+
+wx_medio.obj : wx_medio.cc wx_medio.h $(ALLHEADERS)
+	$(MCC) wx_medio.cc
+
+wx_gclip.obj : wx_gclip.cc wx_gclip.h $(ALLHEADERS)
+	$(MCC) wx_gclip.cc
+
+wx_style.obj : wx_style.cc wx_style.h wx_medio.h $(ALLHEADERS)
+	$(MCC) wx_style.cc
+
+edjr.obj : edjr.cc edjr.h
+	$(MCC) edjr.cc
+
+edjrmain.obj : edjrmain.cc edjr.h
+	$(MCC) edjrmain.cc
+
+clean:
+	del *.obj
+	del *.lib
+	del *.bak
+	del *.csm
+	del *.exe
+
diff --git a/src/mred/wxme/wx_cgrec.cxx b/src/mred/wxme/wx_cgrec.cxx
new file mode 100644
index 0000000..e968ffe
--- /dev/null
+++ b/src/mred/wxme/wx_cgrec.cxx
@@ -0,0 +1,441 @@
+/*
+ * File:        wx_cgrec.cc
+ * Purpose:     wxChangeRecord implementations
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include <stdio.h>
+#include "wx_media.h"
+#include "wx_ptreq.h"
+
+class wxcgList 
+{
+public:
+  long count, size;
+  wxObject **array;
+
+  wxcgList(void) { count = size = 0; }
+  
+  int Count() { return count; }
+  wxObject *Get(int i) { return array[i]; }
+
+  void Append(wxObject *o)
+  {
+    if (count >= size) {
+      wxObject **naya;
+      if (size)
+	size *= 2;
+      else
+	size = 2;
+      naya = new wxObject*[size];
+      memcpy(naya, array, count * sizeof(wxObject*));
+      array = naya;
+    }
+    array[count++] = o;
+  }
+
+  void DeleteAll(void)
+  {
+    while (count--)
+      delete array[count];
+  }
+};
+
+wxChangeRecord::wxChangeRecord(void)
+{
+}
+
+wxChangeRecord::~wxChangeRecord(void)
+{
+}
+
+Bool wxChangeRecord::Undo(wxMediaBuffer *)
+{
+  return FALSE;
+}
+
+Bool wxUnmodifyRecord::Undo(wxMediaBuffer *media)
+{
+  media->SetModified(FALSE);
+  return FALSE;
+}
+
+wxInsertRecord::wxInsertRecord(long position, long length, Bool cont)
+{
+  start = position;
+  end = position + length;
+  continued = cont;
+}
+
+Bool wxInsertRecord::Undo(wxMediaBuffer *buffer)
+{
+  wxMediaEdit *media;
+  media = (wxMediaEdit *)buffer;
+
+  media->Delete(start, end);
+  if (!continued)
+   media->SetPosition(start);
+
+  return continued;
+}
+
+wxInsertSnipRecord::wxInsertSnipRecord(wxSnip *thesnip, Bool cont)
+{
+  snip = thesnip;
+  continued = cont;
+}
+
+Bool wxInsertSnipRecord::Undo(wxMediaBuffer *buffer)
+{
+  wxMediaPasteboard *media;
+  media = (wxMediaPasteboard *)buffer;
+
+  media->Delete(snip);
+  if (!continued)
+   media->SetSelected(snip);
+
+  return continued;
+}
+
+class DeleteSnipItem /* : public wxObject --- uncomment to GC */
+{
+ public:
+  ~DeleteSnipItem();
+
+  wxDeleteSnipRecord *parent;
+  wxSnip *snip, *before;
+  float x, y;
+};
+
+DeleteSnipItem::~DeleteSnipItem()
+{
+  if (!parent->undid) {
+#if !WXGARBAGE_COLLECTION_ON
+    delete snip;
+#else
+    if (snip->flags & wxSNIP_OWNED)
+      snip->flags -= wxSNIP_OWNED;
+    snip->SetAdmin(NULL);
+#endif
+  }
+}
+
+wxDeleteSnipRecord::wxDeleteSnipRecord(Bool cont)
+{
+  continued = cont;
+  deletions = new wxcgList();
+}
+
+wxDeleteSnipRecord::~wxDeleteSnipRecord()
+{
+  int i;
+  
+  for (i = deletions->Count(); i--; )
+    delete (DeleteSnipItem *)deletions->Get(i);
+
+  delete deletions;
+}
+
+void wxDeleteSnipRecord::InsertSnip(wxSnip *snip, wxSnip *before, 
+				    float x, float y)
+{
+  DeleteSnipItem *item;
+
+  item = new DeleteSnipItem();
+  item->parent = this;
+  item->snip = snip;
+  item->before = before;
+  item->x = x;
+  item->y = y;
+
+  deletions->Append((wxObject *)item);
+}
+
+Bool wxDeleteSnipRecord::Undo(wxMediaBuffer *buffer)
+{
+  DeleteSnipItem *item;
+  wxMediaPasteboard *media;
+  int i, count;
+
+  media = (wxMediaPasteboard *)buffer;
+  
+  if (!continued)
+    media->NoSelected();
+
+  count = deletions->Count();
+  for (i = 0; i < count; i++) {
+    item = (DeleteSnipItem *)deletions->Get(i);
+
+    /* Have to turn off the owned flag; we know that it's really ours */
+    if (item->snip->flags & wxSNIP_OWNED)
+      item->snip->flags -= wxSNIP_OWNED;
+
+    media->Insert(item->snip, item->before, item->x, item->y);
+    if (!continued)
+      media->AddSelected(item->snip);
+  }
+
+  undid = TRUE;
+
+  return continued;
+}
+
+wxDeleteRecord::wxDeleteRecord(long startpos, long endpos, Bool cont)
+{
+  continued = cont;
+  start = startpos;
+  end = endpos;
+  undid = FALSE;
+  deletions = new wxcgList();
+  clickbacks = NULL;
+}
+
+wxDeleteRecord::~wxDeleteRecord()
+{
+  if (!undid) {
+#if !WXGARBAGE_COLLECTION_ON
+    deletions->DeleteAll();
+#else
+    wxSnip *snip;
+    int i;
+    for (i = deletions->Count(); i--; ) {
+      snip = (wxSnip *)deletions->Get(i);
+      if (snip->flags & wxSNIP_OWNED)
+	snip->flags -= wxSNIP_OWNED;
+      snip->SetAdmin(NULL);
+    }
+#endif
+    if (clickbacks)
+      clickbacks->DeleteAll();
+  }
+
+  delete deletions;
+  if (clickbacks)
+    delete clickbacks;
+}
+
+void wxDeleteRecord::InsertSnip(wxSnip *snip)
+{
+  deletions->Append(snip);
+}
+
+void wxDeleteRecord::AddClickback(wxClickback *click)
+{
+  if (!clickbacks)
+    clickbacks = new wxcgList();
+  clickbacks->Append((wxObject *)click);
+}
+
+Bool wxDeleteRecord::Undo(wxMediaBuffer *buffer)
+{
+  wxSnip *snip;
+  wxMediaEdit *media;
+  int i, count;
+
+  media = (wxMediaEdit *)buffer;
+
+  count = deletions->Count();
+  for (i = 0; i < count; i++) {
+    snip = (wxSnip *)deletions->Get(i);
+
+    /* Have to turn off the owned flag; we know that it's really ours */
+    if (snip->flags & wxSNIP_OWNED)
+      snip->flags -= wxSNIP_OWNED;
+
+    media->Insert(snip, start);
+  }
+  if (clickbacks) {
+    count = clickbacks->Count();
+    for (i = 0; i < count; i++)
+      media->SetClickback((wxClickback *)clickbacks->Get(i));
+  }
+
+  if (!continued)
+   media->SetPosition(end);
+
+  undid = TRUE;
+
+  return continued;
+}
+
+class StyleChange /* : public wxObject  */
+{
+ public:
+  long start, end;
+  wxStyle *style;
+};
+
+wxStyleChangeRecord::wxStyleChangeRecord(long startpos, long endpos, Bool cont)
+{
+  continued = cont;
+  start = startpos;
+  end = endpos;
+
+  changes = new wxcgList();
+}
+
+wxStyleChangeRecord::~wxStyleChangeRecord()
+{
+  int i;
+
+  for (i = changes->Count(); i--; )
+    delete (StyleChange *)changes->Get(i);
+
+  delete changes;
+}
+
+void wxStyleChangeRecord::AddStyleChange(long start, long end, wxStyle *style)
+{
+  StyleChange *change;
+
+  change = new StyleChange;
+
+  change->start = start;
+  change->end = end;
+  change->style = style;
+
+  changes->Append((wxObject *)change);
+}
+
+Bool wxStyleChangeRecord::Undo(wxMediaBuffer *buffer)
+{
+  StyleChange *change;
+  long p;
+  wxMediaEdit *media;
+  int i, count;
+
+  media = (wxMediaEdit *)buffer;
+  
+  p = start;
+
+  count = changes->Count();
+  for (i = 0; i < count; i++) {
+    change = (StyleChange *)changes->Get(i);
+    media->ChangeStyle(change->style, change->start, change->end);
+  }
+
+  if (!continued)
+    media->SetPosition(start, end);
+
+  return continued;
+}
+
+class StyleChangeSnip : public wxObject 
+{
+ public:
+  wxSnip *snip;
+  wxStyle *style;
+};
+
+wxStyleChangeSnipRecord::wxStyleChangeSnipRecord(Bool cont)
+{
+  continued = cont;
+
+  changes = new wxcgList();
+}
+
+wxStyleChangeSnipRecord::~wxStyleChangeSnipRecord()
+{
+  int i;
+
+  for (i = changes->Count(); i--; )
+    delete (StyleChange *)changes->Get(i);
+  
+  delete changes;
+}
+
+void wxStyleChangeSnipRecord::AddStyleChange(wxSnip *snip, wxStyle *style)
+{
+  StyleChangeSnip *change;
+
+  change = new StyleChangeSnip;
+
+  change->snip = snip;
+  change->style = style;
+
+  changes->Append((wxObject *)change);
+}
+
+Bool wxStyleChangeSnipRecord::Undo(wxMediaBuffer *buffer)
+{
+  StyleChangeSnip *change;
+  wxMediaPasteboard *media;
+  int i, count;
+
+  media = (wxMediaPasteboard *)buffer;
+  
+  if (!continued)
+    media->NoSelected();
+
+  count = changes->Count();
+  for (i = 0; i < count; i++) {
+    change = (StyleChangeSnip *)changes->Get(i);
+    media->ChangeStyle(change->style, change->snip);
+    if (!continued)
+      media->AddSelected(change->snip);
+  }
+
+  return continued;
+}
+
+wxMoveSnipRecord::wxMoveSnipRecord(wxSnip *s, float fx, float fy, 
+				   Bool d, Bool cont)
+{
+  snip = s;
+  continued = cont;
+  x = fx;
+  y = fy;
+  delta = d;
+}
+
+Bool wxMoveSnipRecord::Undo(wxMediaBuffer *buffer)
+{
+  wxMediaPasteboard *media;
+
+  media = (wxMediaPasteboard *)buffer;
+  
+  if (delta)
+    media->Move(snip, x, y);
+  else
+    media->MoveTo(snip, x, y);
+
+  return continued;
+}
+
+wxResizeSnipRecord::wxResizeSnipRecord(wxSnip *s, float fx, float fy, 
+				       Bool cont)
+{
+  snip = s;
+  continued = cont;
+  x = fx;
+  y = fy;
+}
+
+Bool wxResizeSnipRecord::Undo(wxMediaBuffer *buffer)
+{
+  wxMediaPasteboard *media;
+
+  media = (wxMediaPasteboard *)buffer;
+
+  media->Resize(snip, x, y);
+
+  return continued;
+}
+
diff --git a/src/mred/wxme/wx_cgrec.h b/src/mred/wxme/wx_cgrec.h
new file mode 100644
index 0000000..749dcfc
--- /dev/null
+++ b/src/mred/wxme/wx_cgrec.h
@@ -0,0 +1,131 @@
+
+/* WARNING: These classes are not garbage-collected. */
+
+class wxcgList;
+
+class wxChangeRecord /* : public wxObject - uncomment to GC */
+{
+ public:
+  wxChangeRecord(void);
+  virtual ~wxChangeRecord();
+  virtual Bool Undo(wxMediaBuffer *media);
+};
+
+class wxUnmodifyRecord : public wxChangeRecord
+{
+ public:
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxInsertRecord : public wxChangeRecord
+{
+ private:
+  long start, end;
+  Bool continued;
+
+ public:
+  wxInsertRecord(long position, long length, Bool cont);
+
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxInsertSnipRecord : public wxChangeRecord
+{
+ private:
+  wxSnip *snip;
+  Bool continued;
+
+ public:
+  wxInsertSnipRecord(wxSnip *, Bool cont);
+
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxDeleteRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  long start, end;
+  wxcgList *deletions;
+  wxcgList *clickbacks;
+  Bool undid;
+
+ public:
+  wxDeleteRecord(long start, long end, Bool cont);
+  ~wxDeleteRecord();
+
+  void InsertSnip(wxSnip *);
+  void AddClickback(wxClickback *);
+
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxDeleteSnipRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  wxcgList *deletions;
+
+ public:
+  Bool undid;
+
+  wxDeleteSnipRecord(Bool cont);
+  ~wxDeleteSnipRecord();
+
+  void InsertSnip(wxSnip *, wxSnip *, float, float);
+
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxStyleChangeRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  long start, end;
+  wxcgList *changes;
+
+ public:
+  wxStyleChangeRecord(long start, long end, Bool cont);
+  ~wxStyleChangeRecord();
+
+  void AddStyleChange(long start, long end, wxStyle *style);
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxStyleChangeSnipRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  wxcgList *changes;
+
+ public:
+  wxStyleChangeSnipRecord(Bool cont);
+  ~wxStyleChangeSnipRecord();
+
+  void AddStyleChange(wxSnip *, wxStyle *style);
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxMoveSnipRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  wxSnip *snip;
+  float x, y;
+  Bool delta;
+ public:
+  wxMoveSnipRecord(wxSnip *snip, float x, float y, Bool delta, Bool cont);
+  Bool Undo(wxMediaBuffer *media);
+};
+
+class wxResizeSnipRecord : public wxChangeRecord
+{
+ private:
+  Bool continued;
+  wxSnip *snip;
+  float x, y;
+ public:
+  wxResizeSnipRecord(wxSnip *snip, float x, float y, Bool cont);
+  Bool Undo(wxMediaBuffer *media);
+};
+
diff --git a/src/mred/wxme/wx_gclip.cxx b/src/mred/wxme/wx_gclip.cxx
new file mode 100644
index 0000000..ece5900
--- /dev/null
+++ b/src/mred/wxme/wx_gclip.cxx
@@ -0,0 +1,475 @@
+/*
+ * File:        wx_gclip.cc
+ * Purpose:     a generalized clipboard class
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+ */
+
+#include "wx_main.h"
+#include "wx_gclip.h"
+#include "wx_utils.h"
+
+#if defined(wx_msw) || defined(wx_mac)
+#define CLIP_USE_WX_UTILS
+#endif
+
+#ifdef CLIP_USE_WX_UTILS
+#include "wx_clipb.h"
+#endif
+
+wxClipboard *wxTheClipboard;
+
+#ifdef wx_xview
+#include <xview/sel_pkg.h>
+extern Xv_Server xview_server;
+
+#define ATOM(atom) xv_get(xview_server, SERVER_ATOM, atom)
+#define VALUE_TYPE Xv_opaque
+#endif
+
+#ifdef wx_motif
+#define ATOM(atom) XInternAtom(XtDisplay(wxTheApp->topLevel), atom, FALSE)
+#define VALUE_TYPE void*
+#endif
+
+#ifdef wx_x
+Atom xa_text, xa_targets;
+#endif
+
+void wxInitClipboard(void)
+{
+  if (!wxTheClipboard)
+    wxTheClipboard = new wxClipboard;
+#ifdef wx_x
+  xa_text = ATOM("TEXT");
+  xa_targets = ATOM("TARGETS");
+#endif
+}
+
+wxClipboard::wxClipboard()
+{
+  clipOwner = NULL;
+  cbString = NULL;
+#ifdef wx_xview
+  sel_owner = 0;
+#endif
+}
+
+wxClipboard::~wxClipboard()
+{
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  if (cbString)
+    delete[] cbString;
+}
+
+#ifdef CLIP_USE_WX_UTILS
+
+static int FormatStringToID(char *str)
+{
+  if (!strcmp(str, "TEXT"))
+    return wxCF_TEXT;
+  
+  return wxRegisterClipboardFormat(str);
+}
+
+#endif
+
+#ifdef wx_x
+
+#ifdef wx_motif
+static Boolean wxConvertClipboard(Widget w, Atom *selection, Atom *target,
+				  Atom *type_return, XtPointer *value_return,
+				  unsigned long *length_return,
+				  int *format_return)
+#endif
+#ifdef wx_xview
+static int wxConvertClipboard(Selection_owner sel, Atom *target,
+			      Xv_opaque *value_return, long *length_return,
+			      int *format_return)
+#endif
+{
+  wxClipboard *cb;
+  Atom xa;
+  char **formats;
+  int i, count, extra;
+
+  cb = wxTheClipboard;
+
+  if (*target == xa_targets) {
+    if (cb->clipOwner) {
+      count = cb->clipOwner->formats.Number();
+      extra = (cb->clipOwner->formats.Member("TEXT")) ? 1 : 0;
+      cb->receivedTargets = new Atom[count + extra];
+      formats = cb->clipOwner->formats.ListToArray(FALSE);
+      for (i = 0; i < count; i++)
+	((Atom *)cb->receivedTargets)[i] = ATOM(formats[i]);
+      if (extra)
+	((Atom *)cb->receivedTargets)[count] = XA_STRING;
+    } else {
+      count = 2;
+      cb->receivedTargets = new Atom[2];
+      ((Atom *)cb->receivedTargets)[0] = XA_STRING;
+      ((Atom *)cb->receivedTargets)[1] = xa_text;
+      extra = 0;
+    }
+
+    *value_return = (VALUE_TYPE)cb->receivedTargets;
+#ifdef wx_motif
+    *type_return = XA_ATOM;
+#else
+    *target = XA_ATOM;
+#endif
+    *format_return = 8 * sizeof(Atom);
+    *length_return = count + extra;
+
+    cb->sentString = NULL;
+
+    return TRUE;
+  } 
+  
+  cb->receivedTargets = NULL;
+
+  if (cb->clipOwner) {
+    formats = cb->clipOwner->formats.ListToArray(FALSE);
+    for (i = cb->clipOwner->formats.Number(); i--; ) {
+      xa = ATOM(formats[i]);
+      if (xa == *target)
+	break;
+      if (xa == xa_text && *target == XA_STRING)
+	break;
+    }
+    if (i < 0)
+      return FALSE;
+  } else if (*target != xa_text && *target != XA_STRING)
+    return FALSE;
+
+#ifdef wx_motif
+  *type_return = XA_STRING;
+#else
+  *target = XA_STRING;
+#endif
+  *format_return = 8;
+  if (cb->clipOwner) {
+    cb->sentString = cb->clipOwner->GetData(formats[i], (long *)length_return);
+    *value_return = (VALUE_TYPE)cb->sentString;
+  } else {
+    *value_return = (VALUE_TYPE)cb->cbString;
+    *length_return = strlen(cb->cbString);
+  }
+
+  return TRUE;
+}
+
+#ifdef wx_motif
+static void wxSelectionDone(Widget w, Atom *selection, Atom *target)
+#endif
+#ifdef wx_xview
+static void wxSelectionDone(Selection_owner sel, Xv_opaque data, Atom target)
+#endif
+{
+  wxClipboard *cb;
+
+  cb = wxTheClipboard;
+  if (cb->sentString) {
+    delete[] cb->sentString;
+    cb->sentString = NULL;
+  }
+  if (cb->receivedTargets)
+    delete[]  cb->receivedTargets;
+}
+
+#ifdef wx_motif
+static void wxLoseClipboard(Widget w, Atom *selection)
+#endif
+#ifdef wx_xview
+static void wxLoseClipboard(Selection_owner sel)
+#endif
+{
+  wxClipboard *cb;
+
+  cb = wxTheClipboard;
+  
+  if (cb->clipOwner) {
+    cb->clipOwner->BeingReplaced();
+    cb->clipOwner = NULL;
+  }
+  if (cb->cbString) {
+    delete[] cb->cbString;
+    cb->cbString = NULL;
+  }
+}
+
+#endif
+
+void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
+{
+  Bool got_selection;
+
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  clipOwner = client;
+  if (cbString) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+
+#ifdef wx_x
+#ifdef wx_motif
+  got_selection = XtOwnSelection(wxTheApp->topLevel, XA_PRIMARY, time,
+				 wxConvertClipboard, wxLoseClipboard, 
+				 wxSelectionDone);
+#endif
+#ifdef wx_xview
+  if (!sel_owner) {
+    Frame x_frame = (Frame)wxTheApp->wx_frame->handle;
+    sel_owner = xv_create(x_frame, SELECTION_OWNER, NULL);
+  }
+
+  xv_set(sel_owner, SEL_OWN, TRUE,
+	 SEL_CONVERT_PROC, wxConvertClipboard,
+	 SEL_LOSE_PROC, wxLoseClipboard,
+	 SEL_DONE_PROC, wxSelectionDone,
+	 NULL);
+
+  got_selection = TRUE;
+#endif
+
+#else
+  if (wxOpenClipboard()) {
+    char **formats, *data;
+    int i;
+    int ftype;
+    long size;
+
+    wxEmptyClipboard();
+
+    formats = clipOwner->formats.ListToArray(FALSE);
+    for (i = clipOwner->formats.Number(); i--; ) {
+      ftype = FormatStringToID(formats[i]);
+      data = clipOwner->GetData(formats[i], &size);
+      if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
+	got_selection = FALSE;
+	break;
+      }
+    }
+
+    if (i < 0)
+      got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+  
+  got_selection = FALSE; // Assume another process takes over
+
+#endif
+
+  if (!got_selection) {
+    clipOwner->BeingReplaced();
+    clipOwner = NULL;
+  }
+}
+
+wxClipboardClient *wxClipboard::GetClipboardClient()
+{
+  return clipOwner;
+}
+
+void wxClipboard::SetClipboardString(char *str, long time)
+{
+  Bool got_selection;
+
+  if (clipOwner) {
+    clipOwner->BeingReplaced();
+    clipOwner = NULL;
+  }
+  if (cbString)
+    delete[] cbString;
+
+  cbString = str;
+
+#ifdef wx_x
+
+#ifdef wx_motif
+  got_selection = XtOwnSelection(wxTheApp->topLevel, XA_PRIMARY, time,
+				 wxConvertClipboard, wxLoseClipboard, NULL);
+#endif
+#ifdef wx_xview
+  if (!sel_owner) {
+    Frame x_frame = (Frame)wxTheApp->wx_frame->handle;
+    sel_owner = xv_create(x_frame, SELECTION_OWNER, NULL);
+  }
+
+  xv_set(sel_owner, SEL_OWN, TRUE,
+	 SEL_CONVERT_PROC, wxConvertClipboard,
+	 SEL_LOSE_PROC, wxLoseClipboard,
+	 SEL_DONE_PROC, wxSelectionDone,
+	 NULL);
+
+  got_selection = TRUE;
+#endif
+
+#else
+
+  if (wxOpenClipboard()) {    
+    wxEmptyClipboard();
+    if (!wxSetClipboardData(wxCF_TEXT, (wxObject *)str))
+      got_selection = FALSE;
+    else
+      got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+
+  got_selection = FALSE; // Assume another process takes over
+
+#endif
+
+  if (!got_selection) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+}
+
+#ifdef wx_motif
+static void wxGetTargets(Widget w, XtPointer cbv, Atom *sel, Atom *type,
+			 XtPointer value, unsigned long *len, int *format)
+{
+  wxClipboard *cb;
+
+  cb = (wxClipboard *)cbv;
+  if (*len <= 0) {
+    cb->receivedTargets = (void *)1; /* To break the waiting loop */
+    cb->receivedLength = 0;
+  } else {
+    cb = (wxClipboard *)cbv;
+    cb->receivedTargets = new Atom[*len];
+    memcpy(cb->receivedTargets, value, *len * sizeof(Atom));
+    cb->receivedLength = *len;
+  }
+}
+
+static void wxGetSelection(Widget w, XtPointer cbv, Atom *sel, Atom *type,
+			   XtPointer value, unsigned long *len, int *format)
+{
+  wxClipboard *cb;
+
+  cb = (wxClipboard *)cbv;
+  cb->receivedString = new char[*len + 1];
+  memcpy(cb->receivedString, value, *len);
+  cb->receivedString[*len] = 0;
+  cb->receivedLength = *len;
+}
+#endif
+
+char *wxClipboard::GetClipboardString(long time)
+{
+  char *str;
+  long length;
+
+  str = GetClipboardData("TEXT", &length, time);
+  if (!str) {
+    str = new char[1];
+    *str = 0;
+  }
+
+  return str;
+}
+
+char *wxClipboard::GetClipboardData(char *format, long *length, long time)
+{
+  if (clipOwner)  {
+    if (clipOwner->formats.Member(format))
+      return clipOwner->GetData(format, length);
+    else
+      return NULL;
+  } else if (cbString) {
+    if (!strcmp(format, "TEXT"))
+      return copystring(cbString);
+    else
+      return NULL;
+  } else {
+#ifdef wx_x
+    receivedString = NULL;
+    receivedTargets = NULL;
+
+#ifdef wx_motif
+    XtGetSelectionValue(wxTheApp->topLevel, XA_PRIMARY,
+			xa_targets, wxGetTargets, (XtPointer)this, time);
+
+    while (!receivedTargets)
+      wxYield();
+#endif
+#if wx_xview
+    Selection_requestor req;
+    Frame x_frame = (Frame)wxTheApp->wx_frame->handle;
+    int get_format;
+
+    req = (Selection_requestor)xv_create(x_frame, SELECTION_REQUESTOR, 
+					 SEL_TYPE, xa_targets, NULL);
+    receivedTargets = (void *)xv_get(req, SEL_DATA, &receivedLength, 
+				     &get_format);
+    if (!receivedTargets)
+      receivedLength = 0;
+#endif
+
+    Atom xa;
+    long i;
+
+    xa = ATOM(format);
+
+    for (i = 0; i < receivedLength; i++)
+      if (((Atom *)receivedTargets)[i] == xa
+	  || (((Atom *)receivedTargets)[i] == XA_STRING
+	      && xa == xa_text))
+	break;
+
+#ifdef wx_motif
+    if (receivedLength)
+      delete[] receivedTargets;
+#endif
+#ifdef wx_xview
+    if (receivedLength)
+      free(receivedTargets);
+#endif
+
+    if (i >= receivedLength)
+      return NULL;
+
+#ifdef wx_motif
+    XtGetSelectionValue(wxTheApp->topLevel, XA_PRIMARY,
+			xa, wxGetSelection, (XtPointer)this, 0);
+    
+    while (!receivedString)
+      wxYield();
+
+    *length = receivedLength;
+#endif
+#ifdef wx_xview
+    char *str;
+
+    xv_set(req, SEL_TYPE, xa, NULL);
+    str = (char *)xv_get(req, SEL_DATA, length, &get_format);
+    if (!str)
+      *length = 0;
+    
+    if (str) {
+      receivedString = new char[*length + 1];
+      memcpy(receivedString, str, *length);
+      receivedString[*length] = 0;
+      free(str);
+    } else
+      receivedString = NULL;
+#endif
+
+#else
+    if (wxOpenClipboard()) {
+      receivedString = (char *)wxGetClipboardData(FormatStringToID(format), 
+						  length);
+      wxCloseClipboard();
+    } else
+      receivedString = NULL;
+#endif
+
+    return receivedString;
+  }
+}
diff --git a/src/mred/wxme/wx_gclip.h b/src/mred/wxme/wx_gclip.h
new file mode 100644
index 0000000..f78789d
--- /dev/null
+++ b/src/mred/wxme/wx_gclip.h
@@ -0,0 +1,71 @@
+/* wx_clipb.h */
+/* Header flie for clipboard class. */
+
+#ifndef __WX_CLIPBOARD__
+#define __WX_CLIPBOARD__
+
+#include "wx_text.h"
+#include "wx_frame.h"
+#include "wx_list.h"
+
+/* A clipboard client holds data belonging to the clipboard.
+   For plain text, a client is not necessary. */
+class wxClipboardClient : public wxObject
+{
+ public:
+  wxStringList formats;
+  /* This list should be filled in with strings indicating the formats
+     this client can provide. Almost all clients will provide "TEXT".
+     Format names should be 4 characters long, so things will work
+     out on the Macintosh */
+
+  virtual void BeingReplaced(void) = 0;
+  /* This method is called when the client is losing the selection. */
+  virtual char *GetData(char *format, long *size) = 0;
+  /* This method is called when someone wants the data this client is
+     supplying to the clipboard. "format" is a string indicating the
+     format of the data - one of the strings from the "formats"
+     list. "*size" should be filled with the size of the resulting
+     data. In the case of text, "*size" does not count the
+     NULL terminator. */
+};
+
+/* ONE instance of this class: */
+class wxClipboard : public wxObject
+{
+ public:
+  wxClipboardClient *clipOwner;
+  char *cbString, *sentString, *receivedString;
+  void *receivedTargets;
+  long receivedLength;
+#ifdef wx_xview
+  long sel_owner;
+#endif
+
+  wxClipboard();
+  ~wxClipboard();
+
+  void SetClipboardClient(wxClipboardClient *, long time);
+  /* Set the clipboard data owner. "time" comes from the event record. */
+  void SetClipboardString(char *, long time);
+  /* Set the clipboard string; does not require a client. */
+
+  char *GetClipboardString(long time);
+  /* Get data from the clipboard in the format "TEXT". */
+  char *GetClipboardData(char *format, long *length, long time);
+  /* Get data from the clipboard */
+  wxClipboardClient *GetClipboardClient(void);
+  /* Get the clipboard client directly. Will be NULL if clipboard data
+     is a string, or if some other application owns the clipboard. 
+     This can be useful for shortcutting data translation, if the
+     clipboard user can check for a specific client. (This is used
+     by the wxMediaEdit class.) */
+};
+
+void wxInitClipboard(void);
+/* Initialize wxTheClipboard. Can be called repeatedly */
+
+extern wxClipboard *wxTheClipboard;
+/* The clipboard */
+
+#endif
diff --git a/src/mred/wxme/wx_gcrct.h b/src/mred/wxme/wx_gcrct.h
new file mode 100644
index 0000000..7c16ae2
--- /dev/null
+++ b/src/mred/wxme/wx_gcrct.h
@@ -0,0 +1,30 @@
+
+#if !WX_STANDARD_GRAPHICS
+
+/* Corrections when not using standard graphics: */
+
+#ifdef wx_x
+#define GC_RECT_FRAME_EXTEND (-1)
+#endif
+
+#ifdef wx_msw
+#define GC_LINE_EXTEND 1
+#define GC_RECT_BRUSH_EXTEND 1
+#endif
+
+#endif
+
+
+
+
+#ifndef GC_LINE_EXTEND
+#define GC_LINE_EXTEND 0
+#endif
+
+#ifndef GC_RECT_BRUSH_EXTEND
+#define GC_RECT_BRUSH_EXTEND 0
+#endif
+
+#ifndef GC_RECT_FRAME_EXTEND
+#define GC_RECT_FRAME_EXTEND 0
+#endif
diff --git a/src/mred/wxme/wx_keym.cxx b/src/mred/wxme/wx_keym.cxx
new file mode 100644
index 0000000..59f12b6
--- /dev/null
+++ b/src/mred/wxme/wx_keym.cxx
@@ -0,0 +1,1020 @@
+/*
+ * File:        wx_keym.cc
+ * Purpose:     wxKeymap implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_main.h"
+#include "wx_keym.h"
+#include "wx_mtype.h"
+#include "wx_utils.h"
+#include <string.h>
+#include <ctype.h>
+#include "wx_ptreq.h"
+
+#define DOUBLE_CLICK_THRESHOLD 500 /* Half-second */
+
+#if WXGARBAGE_COLLECTION_ON
+#define FUNC_REC_INHERITANCE /* empty */
+#else
+#define FUNC_REC_INHERITANCE : public wxObject
+#endif
+
+class wxKeyFunc FUNC_REC_INHERITANCE
+{
+ public:
+  char *name;
+  wxKeyFunction f;
+  void *data;
+
+  wxKeyFunc(char *name, wxKeyFunction, void *);
+#if !WXGARBAGE_COLLECTION_ON
+  ~wxKeyFunc();
+#endif
+  Bool Call(wxObject *, wxKeyEvent &);
+};
+
+class wxMouseFunc FUNC_REC_INHERITANCE
+{
+ public:
+  char *name;
+  wxMouseFunction f;
+  void *data;
+
+  wxMouseFunc(char *name, wxMouseFunction, void *);
+#if !WXGARBAGE_COLLECTION_ON
+  ~wxMouseFunc();
+#endif
+  Bool Call(wxObject *, wxMouseEvent &);
+};
+
+class wxKeycode FUNC_REC_INHERITANCE
+{
+ public:
+  long code;
+  Bool shift;
+  Bool ctrl;
+  Bool alt;
+  Bool meta;
+  char *fname;
+
+  Bool isprefix;
+  wxKeycode *seqprefix;
+
+  wxKeycode *next;
+};
+
+/***************************************************************/
+
+static int doubleClickThreshold = -1;
+
+wxKeymap::wxKeymap()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_KEYMAP;
+#endif
+
+  keyfunctions = NULL;
+  mousefunctions = NULL;
+  keys = NULL;
+
+  numImpliedShifts = allocedImplies = 0;
+  impliesShift = NULL;
+
+  prefix = NULL;
+  err = NULL;
+  WXGC_IGNORE(errdata);
+
+  active_mouse_function = NULL;
+
+  grabKeyFunction = NULL;
+  grabMouseFunction = NULL;
+  onBreak = NULL;
+
+  WXGC_IGNORE(grabKeyData);
+  WXGC_IGNORE(grabMouseData);
+  WXGC_IGNORE(onBreakData);
+
+  chainCount = 0;
+  chainTo = NULL;
+
+  usage = 0;
+
+  lastButton = 0;
+
+  if (doubleClickThreshold < 0) {
+#if USE_RESOURCES
+    if (!wxGetResource(wxTheApp->wx_class, "doubleClickTime", 
+		       &doubleClickThreshold))
+#endif
+      doubleClickThreshold = DOUBLE_CLICK_THRESHOLD;
+  }
+
+  doubleInterval = doubleClickThreshold;
+}
+
+wxKeymap::~wxKeymap()
+{
+  int i;
+
+  BreakSequence();
+
+  for (i = chainCount; i--; )
+    RemoveChainedKeymap(chainTo[i]);
+  if (chainTo)
+    delete[] chainTo;
+
+  if (keys) {
+#if !WXGARBAGE_COLLECTION_ON
+    keys->DeleteContents(TRUE);
+#endif
+    delete keys;
+  }
+
+  if (keyfunctions) {
+#if !WXGARBAGE_COLLECTION_ON
+    keyfunctions->DeleteContents(TRUE);
+#endif
+    delete keyfunctions;
+  }
+
+  if (mousefunctions) {
+#if !WXGARBAGE_COLLECTION_ON
+    mousefunctions->DeleteContents(TRUE);
+#endif
+    delete mousefunctions;
+  }
+
+  if (impliesShift)
+    delete[] impliesShift;
+}
+
+void wxKeymap::Reset(void)
+{
+  int i;
+
+  prefix = NULL;
+
+  for (i = 0; i < chainCount; i++)
+    chainTo[i]->Reset();  
+}
+
+void wxKeymap::BreakSequence(void)
+{
+  int i;
+
+  prefix = NULL;
+
+  if (onBreak) {
+    wxBreakSequenceFunction f;
+    void *data;
+
+    f = onBreak;
+    data = onBreakData;
+
+    onBreak = NULL;
+    onBreakData = NULL;
+
+    f(data);
+  }
+
+  for (i = 0; i < chainCount; i++)
+    chainTo[i]->BreakSequence();
+}
+
+void wxKeymap::SetBreakSequenceCallback(wxBreakSequenceFunction f, 
+					void *data)
+{
+  wxBreakSequenceFunction fold;
+  void *dataold;
+  
+  fold = onBreak;
+  dataold = onBreakData;
+
+  onBreak = f;
+  onBreakData = data;
+
+  if (fold)
+    fold(dataold);
+}
+
+wxKeycode *wxKeymap::FindKey(long code, Bool shift, Bool ctrl, 
+			     Bool alt, Bool meta,
+			     wxKeycode *prefix)
+{
+  wxKeycode *key;
+  
+  if (!keys)
+    return NULL;
+
+  shift = !!shift;
+  ctrl = !!ctrl;
+  alt = !!alt;
+  meta = !!meta;
+
+  key = (wxKeycode *)keys->Get(code);
+  while (key) {
+    if (key->code == code
+	&& key->shift == shift
+	&& key->ctrl == ctrl
+	&& key->alt == alt
+	&& key->meta == meta
+	&& key->seqprefix == prefix) {
+      return key;
+    }
+    key = key->next;
+  }
+
+  return key;
+}
+
+wxKeycode *wxKeymap::MapFunction(long code, Bool shift, Bool ctrl, 
+				 Bool alt, Bool meta,
+				 char *fname, wxKeycode *prev, int type)
+{
+  wxKeycode *key, *newkey;
+
+  if ((key = FindKey(code, shift, ctrl, alt, meta, prev))) {
+    if ((type == wxKEY_PREFIX) != key->isprefix) {
+      if (err) {
+	char buffer[256];
+	
+	if (isprint(code))
+	  sprintf(buffer, "keymap: key %c ", (char)code);
+	else
+	  sprintf(buffer, "keymap: key code %ld ", code);
+
+	if (shift)
+	  strcat(buffer, "+ shift ");
+	if (ctrl)
+	  strcat(buffer, "+ control ");
+	if (alt)
+	  strcat(buffer, "+ alt ");
+	if (meta)
+	  strcat(buffer, "+ meta ");
+
+	strcat(buffer, "is ");
+	if (!key->isprefix)
+	  strcat(buffer, "not ");
+	strcat(buffer, "a prefix key");
+
+	err(errdata, buffer);
+      }
+
+      return NULL;
+    }  else {
+      if (strcmp(key->fname, fname)) {
+	delete[] key->fname;
+	key->fname = copystring(fname);
+      }
+      return key;
+    }
+  }
+
+  newkey = new wxKeycode;
+
+  newkey->code = code;
+  newkey->shift = shift;
+  newkey->ctrl = ctrl;
+  newkey->alt = alt;
+  newkey->meta = meta;
+  newkey->fname = copystring(fname);
+  newkey->next = NULL;
+
+  newkey->seqprefix = prev;
+
+  newkey->isprefix = (type == wxKEY_PREFIX);
+
+  if (!keys)
+    keys = new wxHashTable(wxKEY_INTEGER, 25);
+
+  key = (wxKeycode *)keys->Get(code);
+  if (!key)
+    keys->Put(code, (wxObject *)newkey);
+  else {
+    while (key->next)
+      key = key->next;
+    key->next = newkey;
+  }
+
+  return newkey;
+}
+
+static struct {
+  char *str;
+  long code;
+} keylist[] = { { "leftbutton" , WXK_MOUSE_LEFT },
+		{ "rightbutton" , WXK_MOUSE_RIGHT },
+		{ "middlebutton" , WXK_MOUSE_MIDDLE },
+		{ "leftbuttondouble" , WXK_MOUSE_LEFT_DOUBLE },
+		{ "rightbuttondouble" , WXK_MOUSE_RIGHT_DOUBLE },
+		{ "middlebuttondouble" , WXK_MOUSE_MIDDLE_DOUBLE },
+		{ "leftbuttontriple" , WXK_MOUSE_LEFT_TRIPLE },
+		{ "rightbuttontriple" , WXK_MOUSE_RIGHT_TRIPLE },
+		{ "middlebuttontriple" , WXK_MOUSE_MIDDLE_TRIPLE },
+		{ "esc", WXK_ESCAPE }, 
+		{ "delete", WXK_DELETE },
+		{ "del", WXK_DELETE },
+		{ "insert", WXK_INSERT },
+		{ "ins", WXK_INSERT },
+		{ "add", WXK_ADD },
+		{ "subtract", WXK_SUBTRACT },
+		{ "multiply", WXK_MULTIPLY },
+		{ "divide", WXK_DIVIDE },
+		{ "backspace", WXK_BACK },
+		{ "back", WXK_BACK },
+		{ "return", WXK_RETURN },
+		{ "tab", WXK_TAB },
+		{ "space", WXK_SPACE },
+		{ "right", WXK_RIGHT },
+		{ "left", WXK_LEFT },
+		{ "up", WXK_UP },
+		{ "down", WXK_DOWN },
+		{ "home", WXK_HOME },
+		{ "end", WXK_END },
+		{ "pageup", WXK_PRIOR },
+		{ "pagedown", WXK_NEXT },
+		{ "semicolon", ';' },
+		{ "colon", ':' },
+		{ "numpad1", WXK_NUMPAD1 },
+		{ "numpad2", WXK_NUMPAD2 },
+		{ "numpad3", WXK_NUMPAD3 },
+		{ "numpad4", WXK_NUMPAD4 },
+		{ "numpad5", WXK_NUMPAD5 },
+		{ "numpad6", WXK_NUMPAD6 },
+		{ "numpad7", WXK_NUMPAD7 },
+		{ "numpad8", WXK_NUMPAD8 },
+		{ "numpad9", WXK_NUMPAD9 },
+		{ "f1", WXK_F1 },
+		{ "f2", WXK_F2 },
+		{ "f3", WXK_F3 },
+		{ "f4", WXK_F4 },
+		{ "f5", WXK_F5 },
+		{ "f6", WXK_F6 },
+		{ "f7", WXK_F7 },
+		{ "f8", WXK_F8 },
+		{ "f9", WXK_F9 },
+		{ "f10", WXK_F10 },
+		{ "f11", WXK_F11 },
+		{ "f12", WXK_F12 },
+		{ "f13", WXK_F13 },
+		{ "f14", WXK_F14 },
+		{ "f15", WXK_F15 },
+		{ "f16", WXK_F16 },
+		{ "f17", WXK_F17 },
+		{ "f18", WXK_F18 },
+		{ "f19", WXK_F19 },
+		{ "f20", WXK_F20 },
+		{ "f21", WXK_F21 },
+		{ "f22", WXK_F22 },
+		{ "f23", WXK_F23 },
+		{ "f24", WXK_F24 },
+		{ NULL, 0 }};
+
+static long GetCode(char **keyseqp)
+{
+  char *keyseq = *keyseqp;
+  long i, code;
+#define MAX_BUF 256
+  char buffer[MAX_BUF], first;
+
+  first = buffer[0] = *(keyseq++);
+  for (i = 1; *keyseq && (*keyseq != ';'); i++) {
+    if (i >= MAX_BUF - 1)
+      return 0;
+    buffer[i] = tolower(*keyseq);
+    keyseq++;
+  }
+  buffer[i] = 0;
+  code = 0;
+  if (buffer[1]) {
+    buffer[0] = tolower(buffer[0]);
+    for (i = 0; keylist[i].str; i++)
+      if (!strcmp(buffer, keylist[i].str)) {
+	code = keylist[i].code;
+	break;
+      }
+  } else
+    code = first;
+
+  *keyseqp = keyseq;
+
+  return code;
+}
+
+void wxKeymap::ImpliesShift(char *str)
+{
+  long code;
+  char buffer[256];
+
+  code = GetCode(&str);
+  if (!code) {
+    if (err) {
+      sprintf(buffer, "implies-shift: bad key: \"%.100s\"", str);
+      err(errdata, buffer);
+    }
+    return;
+  }
+
+  if (numImpliedShifts == allocedImplies) {
+    long *old;
+
+    old = impliesShift;
+    allocedImplies = (!allocedImplies ? 40 : 2 * allocedImplies);
+    impliesShift = new long[allocedImplies];
+    if (old) {
+      memcpy(impliesShift, old, allocedImplies * sizeof(long));
+      delete[] old;
+    }
+  }
+
+  impliesShift[numImpliedShifts++] = code;
+}
+
+void wxKeymap::MapFunction(char *keys, char *fname)
+{
+  char *keyseq = keys;
+  wxKeycode *key = NULL;
+  Bool shift, ctrl, alt, meta;
+  int part = 1, i;
+  long code;
+  char *errstr;
+  char buffer[256];
+
+  while (*keyseq) {
+    shift = ctrl = alt = meta = 0;
+    code = 0;
+    
+    while (*keyseq && (*keyseq != ';')) {
+      if (isspace(*keyseq)) {
+      } else if (keyseq[1] == ':') {
+	switch (tolower(*keyseq)) {
+	case 's':
+	  shift = TRUE;
+	  break;
+	case 'c':
+	  ctrl = TRUE;
+	  break;
+	case 'm':
+#ifdef wx_mac
+	  return; // impossible
+#endif
+	  meta = TRUE;
+	  break;
+	case 'd':
+#ifndef wx_mac
+	  return; // impossible
+#endif
+	  meta = TRUE;
+	  break;
+	case 'a':
+	  alt = TRUE;
+	  break;
+	default:
+	  errstr = "bad modifier";
+	  goto key_error;
+	}
+	keyseq += 2;
+      } else {
+	code = GetCode(&keyseq);
+	if (!code) {
+	  errstr = "bad keyname";
+	  goto key_error;
+	}
+      }
+    }
+
+    if (code) {
+      if ((code > 0) && (code < 256) && isalpha(code)) {
+	if (shift)
+	  code = toupper(code);
+	else if (isupper(code))
+	  shift = TRUE;
+      } 
+
+      if (!shift) {
+	for (i = 0; i < numImpliedShifts; i++)
+	  if (code == impliesShift[i]) {
+	    shift = TRUE;
+	    break;
+	  }
+      }
+
+      key = MapFunction(code, shift, ctrl, alt, meta, fname, key, 
+			*keyseq ? wxKEY_PREFIX : wxKEY_FINAL);
+      part++;
+      if (*keyseq)
+	keyseq++;
+    } else {
+      errstr = "no non-modifier key";
+      goto key_error;
+    }
+
+    if (!key)
+      return;
+  }
+
+  return;
+
+ key_error:
+  if (err) {
+    sprintf(buffer, "keymap: %s in keystring: \"%.100s\", part %d", 
+	    errstr, keys, part);
+    err(errdata, buffer);
+  }
+}
+
+int wxKeymap::HandleEvent(long code, Bool shift, Bool ctrl, 
+			  Bool alt, Bool meta,
+			  char **fname)
+{
+  wxKeycode *key;
+
+  key = FindKey(code, shift, ctrl, alt, meta, prefix);
+  
+  prefix = NULL;
+
+  if (key) {
+    if (key->isprefix) {
+      prefix = key;
+      *fname = NULL;
+      return 1;
+    }
+    *fname = key->fname;
+    return 1;
+  }
+
+  return 0;
+}
+
+void wxKeymap::SetGrabKeyFunction(wxGrabKeyFunction grab, void *grabData)
+{
+  grabKeyFunction = grab;
+  grabKeyData = grabData;
+}
+
+void wxKeymap::RemoveGrabKeyFunction(void)
+{
+  grabKeyFunction = NULL;
+  grabKeyData = NULL;
+}
+
+Bool wxKeymap::HandleKeyEvent(wxObject *media, wxKeyEvent &event)
+{
+  if (event.keyCode == WXK_SHIFT
+      || event.keyCode == WXK_CONTROL
+      || !event.keyCode)
+    return TRUE;
+
+  return ChainHandleKeyEvent(media, event, NULL, NULL, 0) ? TRUE : FALSE;
+}
+
+int wxKeymap::OtherHandleKeyEvent(wxObject *media, wxKeyEvent &event,
+				  wxGrabKeyFunction grab, void *grabData,
+				  int try_state)
+{
+  int i, result = 0;
+  
+  for (i = 0; i < chainCount; i++) {
+    int r = chainTo[i]->ChainHandleKeyEvent(media, event, grab, grabData, try_state);
+    if (r > 0) {
+      Reset();
+      return r;
+    } else if (r)
+      result = r;
+  }
+  
+  return result;
+}
+
+int wxKeymap::ChainHandleKeyEvent(wxObject *media, wxKeyEvent &event,
+				  wxGrabKeyFunction grab, void *grabData,
+				  int try_state)
+{
+  char *fname;
+
+  lastTime = event.timeStamp;
+  lastButton = 0;
+
+  if (grabKeyFunction) {
+    grab = grabKeyFunction;
+    grabData = grabKeyData;
+  }
+
+  if (!prefix && (try_state >= 0)) {
+    int r = OtherHandleKeyEvent(media, event, grab, grabData, 1);
+    
+    if (r > 0)
+      return r;
+
+    if (try_state > 0)
+      return r;
+    else
+      try_state = -1;
+  } else if (prefix && (try_state < 0))
+    return OtherHandleKeyEvent(media, event, grab, grabData, -1);
+
+  if (HandleEvent(event.keyCode,
+		  event.shiftDown,
+		  event.controlDown,
+		  event.altDown,
+		  event.metaDown,
+		  &fname)) {
+    if (fname) {
+      Reset();
+      if (grab && grab(fname, this, media, event, grabData))
+	return 1;
+      return CallFunction(fname, media, event) ? 1 : 0;
+    } else {
+      if (prefix) {
+	/* Just found prefix; try others */
+	int r = OtherHandleKeyEvent(media, event, grab, grabData, try_state);
+	if (r > 0)
+	  return r;
+	return -1;
+      }
+    }
+  }
+
+  int result = OtherHandleKeyEvent(media, event, grab, grabData, try_state);
+
+  if (!result && grabKeyFunction)
+    if (grabKeyFunction(NULL, this, media, event, grabKeyData))
+      return 1;
+
+  return result;
+}
+
+static inline long Abs(long x)
+{
+  if (x < 0)
+    return -x;
+  else
+    return x;
+}
+
+void wxKeymap::SetGrabMouseFunction(wxGrabMouseFunction grab, void *grabData)
+{
+  grabMouseFunction = grab;
+  grabMouseData = grabData;
+}
+
+void wxKeymap::RemoveGrabMouseFunction(void)
+{
+  grabMouseFunction = NULL;
+  grabMouseData = NULL;
+}
+
+Bool wxKeymap::HandleMouseEvent(wxObject *media, wxMouseEvent &event)
+{
+  return ChainHandleMouseEvent(media, event, NULL, NULL, 0) ? TRUE : FALSE;
+}
+
+int wxKeymap::OtherHandleMouseEvent(wxObject *media, wxMouseEvent &event,
+				    wxGrabMouseFunction grab, void *grabData,
+				    int try_state)
+{
+  int i, result = 0;
+  
+  for (i = 0; i < chainCount; i++) {
+    int r = chainTo[i]->ChainHandleMouseEvent(media, event, grab, grabData, try_state);
+    if (r > 0) {
+      Reset();
+      return r;
+    } else if (r)
+      result = r;
+  }
+  
+  return result;
+}
+
+int wxKeymap::ChainHandleMouseEvent(wxObject *media, wxMouseEvent &event,
+				    wxGrabMouseFunction grab, void *grabData,
+				    int try_state)
+{
+  long code, origCode, lastCode;
+  char *fname;
+
+  if (grabMouseFunction) {
+    grab = grabMouseFunction;
+    grabData = grabMouseData;
+  }
+
+  if (!prefix && (try_state >= 0)) {
+    int r = OtherHandleMouseEvent(media, event, grab, grabData, 1);
+    
+    if (r > 0)
+      return r;
+
+    if (try_state > 0)
+      return r;
+    else
+      try_state = -1;
+  } else if (prefix && (try_state < 0))
+    return OtherHandleMouseEvent(media, event, grab, grabData, -1);
+
+  if (!event.ButtonDown()) {
+    Bool v;
+
+    if (!event.Dragging() && !event.ButtonUp()) {
+      /* We must have missed the button-up */
+      active_mouse_function = NULL;
+    }
+
+    if (!active_mouse_function)
+      return 0;
+    if (grab && grab(active_mouse_function, this, media, event, grabData))
+      v = 1;
+    else
+      v = CallFunction(active_mouse_function, media, event);
+    if (event.ButtonUp())
+      active_mouse_function = NULL;
+    return v;
+  }
+
+  if (event.RightDown())
+    code = WXK_MOUSE_RIGHT;
+  else if (event.LeftDown())
+    code = WXK_MOUSE_LEFT;
+  else if (event.MiddleDown())
+    code = WXK_MOUSE_MIDDLE;
+  else
+    return 0;
+
+  origCode = code;
+
+  if (code == lastButton && event.x == lastX && event.y == lastY) {
+    if (Abs(event.timeStamp - lastTime) < doubleInterval) {
+      code += WXK_CLICK_ADDER * clickCount;
+      clickCount++;
+    } else
+      clickCount = 1;
+  } else {
+    lastButton = code;
+    clickCount = 1;
+  }
+  lastTime = event.timeStamp;
+  lastX = event.x;
+  lastY = event.y;
+
+  do {
+    if (HandleEvent(code,
+		    event.shiftDown,
+		    event.controlDown,
+		    event.altDown,
+		    event.metaDown,
+		    &fname)) {
+      if (fname) {
+	Reset();
+	if (grab && grab(fname, this, media, event, grabData))
+	  return 1;
+	return CallFunction(fname, media, event) 
+	  ? 1 : 0;
+      } else {
+	int r = OtherHandleMouseEvent(media, event, grab, grabData, try_state);
+
+	if (r > 0)
+	  return r;
+	return -1;
+      }
+    }
+    lastCode = code;
+    code = origCode;
+  } while (lastCode != origCode);
+
+  int result = OtherHandleMouseEvent(media, event, grab, grabData, try_state);
+
+  if (!result && grabMouseFunction)
+    if (grabMouseFunction(NULL, this, media, event, grabMouseData))
+      return 1;
+  
+  return result;
+}
+
+void wxKeymap::AddKeyFunction(char *name, wxKeyFunction func, void *data)
+{
+  wxKeyFunc *f;
+
+  if (!keyfunctions)
+    keyfunctions = new wxHashTable(wxKEY_STRING, 50);
+
+  f = new wxKeyFunc(name, func, data);
+  if (keyfunctions->Get(f->name))
+    keyfunctions->Delete(f->name);
+  keyfunctions->Put(f->name, (wxObject *)f);
+}
+  
+void wxKeymap::AddMouseFunction(char *name, wxMouseFunction func, 
+				void *data)
+{
+  wxMouseFunc *f;
+
+  if (!mousefunctions)
+    mousefunctions = new wxHashTable(wxKEY_STRING, 50);
+
+  f = new wxMouseFunc(name, func, data);
+  if (mousefunctions->Get(f->name))
+    mousefunctions->Delete(f->name);
+  mousefunctions->Put(f->name, (wxObject *)f);
+}
+  
+Bool wxKeymap::CallFunction(char *name, wxObject *media, wxKeyEvent &event,
+			    Bool try_chained)
+{
+  wxKeyFunc *f;
+
+  if (keyfunctions) {
+    f = (wxKeyFunc *)keyfunctions->Get(name);
+    if (f)
+      return f->Call(media, event);
+  }
+
+  if (try_chained) {
+    int i;
+
+    for (i = 0; i < chainCount; i++)
+      if (chainTo[i]->CallFunction(name, media, event, TRUE))
+	return TRUE;
+  } else if (err) {
+    char buffer[256];
+    
+    sprintf(buffer, "keymap: no key function \"%s\"", name);
+    err(errdata, buffer);
+  }
+
+  return 0;
+}
+
+Bool wxKeymap::CallFunction(char *name, wxObject *media, wxMouseEvent &event,
+			    Bool try_chained)
+{
+  wxMouseFunc *f;
+
+  active_mouse_function = name;
+
+  if (mousefunctions) {
+    f = (wxMouseFunc *)mousefunctions->Get(name);
+    if (f)
+      return f->Call(media, event);
+  }
+
+  if (try_chained) {
+    int i;
+
+    for (i = 0; i < chainCount; i++)
+      if (chainTo[i]->CallFunction(name, media, event, TRUE))
+	return TRUE;
+  } else if (err) {
+    char buffer[256];
+    
+    sprintf(buffer, "keymap: no mouse function \"%s\"", name);
+    err(errdata, buffer);
+  }
+
+  return FALSE;
+}
+
+void wxKeymap::SetErrorCallback(wxKeyErrorFunction f, void *d)
+{
+  err = f;
+  errdata = d;
+}
+
+void wxKeymap::AdjustUsage(Bool newUser)
+{
+  if (newUser)
+    usage++;
+  else
+    --usage;
+}
+
+Bool wxKeymap::IsUsed(void)
+{
+  return (usage != 0);
+}
+
+long wxKeymap::GetDoubleClickInterval()
+{
+  return doubleInterval;
+}
+
+void wxKeymap::SetDoubleClickInterval(long d)
+{
+  doubleInterval = d;
+}
+
+Bool wxKeymap::CycleCheck(wxKeymap *km)
+{
+  int i;
+
+  for (i = 0; i < chainCount; i++)
+    if (PTREQ(km, chainTo[i]) || chainTo[i]->CycleCheck(km))
+      return TRUE;
+  
+  return FALSE;
+}
+
+typedef wxKeymap *wxKeymapPtr;
+
+void wxKeymap::ChainToKeymap(wxKeymap *km, Bool prefix)
+{
+  wxKeymap **old;
+  
+  if ((km == this) || CycleCheck(km) || km->CycleCheck(this))
+    return;
+
+  old = chainTo;
+  chainTo = new wxKeymapPtr[chainCount + 1];
+
+  memcpy(chainTo + (prefix ? 1 : 0), old, chainCount * sizeof(wxKeymap *));
+  chainTo[prefix ? 0 : chainCount] = km;
+
+  if (old)
+    delete[] old;
+
+  chainCount++;
+
+  km->AdjustUsage(TRUE);
+}
+
+void wxKeymap::RemoveChainedKeymap(wxKeymap *km)
+{
+  int i;
+
+  for (i = 0; i < chainCount; i++)
+    if (PTREQ(km, chainTo[i]))
+      break;
+  
+  if (i >= chainCount)
+    return;
+
+  memcpy(chainTo + i, chainTo + i + 1, 
+	 sizeof(wxKeymap *) * (chainCount - i - 1));
+
+  chainCount--;
+
+  km->AdjustUsage(FALSE);
+#if !WXGARBAGE_COLLECTION_ON
+  if (!km->IsUsed())
+    delete km;
+#endif
+}
+
+/***************************************************************/
+
+wxKeyFunc::wxKeyFunc(char *fname, wxKeyFunction func, void *d)
+{
+  name = copystring(fname);
+  f = func;
+  data = d;
+}
+
+#if !WXGARBAGE_COLLECTION_ON
+wxKeyFunc::~wxKeyFunc()
+{
+  delete[] name;
+}
+#endif
+
+Bool wxKeyFunc::Call(wxObject *media, wxKeyEvent &event)
+{
+  return f(media, event, data);
+}
+
+/***************************************************************/
+
+wxMouseFunc::wxMouseFunc(char *fname, wxMouseFunction func, void *d)
+{
+  name = copystring(fname);
+  f = func;
+  data = d;
+}
+
+#if !WXGARBAGE_COLLECTION_ON
+wxMouseFunc::~wxMouseFunc()
+{
+  delete[] name;
+}
+#endif
+
+Bool wxMouseFunc::Call(wxObject *media, wxMouseEvent &event)
+{
+  return f(media, event, data);
+}
diff --git a/src/mred/wxme/wx_keym.h b/src/mred/wxme/wx_keym.h
new file mode 100644
index 0000000..99ca802
--- /dev/null
+++ b/src/mred/wxme/wx_keym.h
@@ -0,0 +1,140 @@
+
+#ifndef wx_keym
+#define wx_keym
+
+#include "wx_stdev.h"
+#include "wx_hash.h"
+
+class wxObject;
+
+typedef Bool (*wxKeyFunction)(wxObject *media, wxKeyEvent &event, 
+			      void *data);
+typedef Bool (*wxMouseFunction)(wxObject *media, wxMouseEvent &event, 
+				void *data);
+
+typedef Bool (*wxGrabKeyFunction)(char *str, class wxKeymap *km,
+				  wxObject *media, wxKeyEvent &event, 
+				  void *data);
+typedef Bool (*wxGrabMouseFunction)(char *str, class wxKeymap *km,
+				    wxObject *media, wxMouseEvent &event, 
+				    void *data);
+
+typedef void (*wxBreakSequenceFunction)(void *data);
+
+enum {
+  wxKEY_FINAL = 0,
+  wxKEY_PREFIX
+};
+
+typedef void (*wxKeyErrorFunction)(void *data, char *str);
+
+#define WXK_MOUSE_RIGHT         (-1)
+#define WXK_MOUSE_LEFT          (-2)
+#define WXK_MOUSE_MIDDLE        (-3)
+#define WXK_MOUSE_RIGHT_DOUBLE  (-4)
+#define WXK_MOUSE_LEFT_DOUBLE   (-5)
+#define WXK_MOUSE_MIDDLE_DOUBLE (-6)
+#define WXK_MOUSE_RIGHT_TRIPLE  (-7)
+#define WXK_MOUSE_LEFT_TRIPLE   (-8)
+#define WXK_MOUSE_MIDDLE_TRIPLE (-9)
+
+#define WXK_CLICK_ADDER         (-3)
+
+class wxKeymap : public wxObject
+{
+  wxHashTable *keyfunctions, *mousefunctions;
+  wxHashTable *keys;
+  wxKeyErrorFunction err;
+  void *errdata;
+
+  long numImpliedShifts, allocedImplies;
+  long *impliesShift;
+  int usage;
+
+  int chainCount;
+  wxKeymap **chainTo;
+
+  long doubleInterval;
+
+  int lastButton;
+  int clickCount;
+  long lastTime;
+  float lastX, lastY;
+
+  class wxKeycode *prefix;
+
+  char *active_mouse_function;
+
+  wxGrabKeyFunction grabKeyFunction;
+  void *grabKeyData;
+  wxGrabMouseFunction grabMouseFunction;
+  void *grabMouseData;
+
+  wxBreakSequenceFunction onBreak;
+  void *onBreakData;
+
+  class wxKeycode *FindKey(long, Bool, Bool, Bool, Bool, class wxKeycode *);
+  int HandleEvent(long code, Bool shift, Bool ctrl, Bool alt, Bool meta,
+		  char **fname);
+
+  Bool CycleCheck(wxKeymap *km);
+
+  int ChainHandleKeyEvent(wxObject *media, wxKeyEvent &event,
+			  wxGrabKeyFunction grab, void *grabData,
+			  int try_state);
+  int ChainHandleMouseEvent(wxObject *media, wxMouseEvent &event,
+			    wxGrabMouseFunction grab, void *grabData,
+			    int try_state);
+
+  int OtherHandleKeyEvent(wxObject *media, wxKeyEvent &event,
+			  wxGrabKeyFunction grab, void *grabData,
+			  int try_state);
+  int OtherHandleMouseEvent(wxObject *media, wxMouseEvent &event,
+			    wxGrabMouseFunction grab, void *grabData,
+			    int try_state);
+
+  void Reset(void);
+
+ public:
+  wxKeymap();
+  ~wxKeymap();
+  
+  virtual Bool HandleKeyEvent(wxObject *media, wxKeyEvent &event);
+  virtual Bool HandleMouseEvent(wxObject *media, wxMouseEvent &event);
+
+  void SetGrabKeyFunction(wxGrabKeyFunction grab, void *grabData);
+  void RemoveGrabKeyFunction(void);
+  void SetGrabMouseFunction(wxGrabMouseFunction grab, void *grabData);
+  void RemoveGrabMouseFunction(void);
+
+  void BreakSequence(void);
+  void SetBreakSequenceCallback(wxBreakSequenceFunction f, void *data);
+
+  class wxKeycode *MapFunction(long code, Bool shift, Bool ctrl, 
+			       Bool alt, Bool meta, 
+			       char *fname, class wxKeycode *prevkey=NULL, 
+			       int keytype = wxKEY_FINAL);
+  void MapFunction(char *keyname, char *fname);
+
+  void ImpliesShift(char *str);
+
+  void AddKeyFunction(char *name, wxKeyFunction func, void *data);
+  void AddMouseFunction(char *name, wxMouseFunction func, void *data);
+  Bool CallFunction(char *name, wxObject *media, wxKeyEvent &event, 
+		    Bool try_chained = FALSE);
+  Bool CallFunction(char *name, wxObject *media, wxMouseEvent &event, 
+		    Bool try_chained = FALSE);
+
+  void SetErrorCallback(wxKeyErrorFunction, void *d=NULL);
+
+  void ChainToKeymap(wxKeymap *, Bool prefix);
+  void RemoveChainedKeymap(wxKeymap *);
+
+  void AdjustUsage(Bool newUser);
+  Bool IsUsed(void);
+
+  long GetDoubleClickInterval();
+  void SetDoubleClickInterval(long);
+};
+
+#endif
diff --git a/src/mred/wxme/wx_madm.h b/src/mred/wxme/wx_madm.h
new file mode 100644
index 0000000..e2a784a
--- /dev/null
+++ b/src/mred/wxme/wx_madm.h
@@ -0,0 +1,124 @@
+/*
+ * File:        wx_madm.cc
+ * Purpose:     wxMediaAdmins
+ * Author:      Matthew Flatt
+ * Created:     1997
+ * Copyright:   (c) 1997, Matthew Flatt
+ */
+
+
+#ifndef __WX_MEDIA_ADMIN__
+#define __WX_MEDIA_ADMIN__
+
+class wxMediaAdmin : public wxObject
+{
+ private:
+  friend class wxMediaCanvas;
+  friend class wxMediaEdit;
+  friend class wxCanvasMediaAdmin;
+  int standard; /* Used to recognize standard display. Hack. */
+  
+ public:
+  wxMediaAdmin() 
+    {
+      standard = 0; 
+#if USE_OLD_TYPE_SYSTEM
+      __type = wxTYPE_MEDIA_ADMIN; 
+#endif
+    };
+
+  /* Usually called by wxMediaBuffer objects: */
+  virtual wxDC *GetDC(float *x = NULL, float *y = NULL) = 0;
+  virtual void GetView(float *x, float *y, float *w, float *h, 
+		       Bool full = FALSE) = 0;
+  virtual Bool ScrollTo(float localx, float localy, float w, float h,
+			Bool refresh = TRUE, int bias = 0) = 0;
+  virtual void GrabCaret(int = wxFOCUS_GLOBAL) = 0;
+
+  virtual void Resized(Bool redraw_now) = 0;
+  virtual void NeedsUpdate(float localx, float localy, float w, float h) = 0;
+
+  virtual void UpdateCursor() = 0;
+
+  virtual void GetMaxView(float *x, float *y, float *w, float *h, 
+			  Bool full = FALSE);
+  virtual Bool DelayRefresh();
+};
+
+class wxCanvasMediaAdmin : public wxMediaAdmin
+{
+ private:
+  friend class wxMediaCanvas;
+  friend class os_wxCanvasMediaAdmin;
+  friend class wxUpdateCursorTimer;
+
+  wxMediaCanvas *canvas;
+  wxCanvasMediaAdmin *nextadmin, *prevadmin;
+  Bool resetFlag;
+  Bool updateBlock, resizedBlock;
+  class wxUpdateCursorTimer *updateCursorTimer;
+
+  inline void AdjustStdFlag(void);
+
+  wxCanvasMediaAdmin(wxMediaCanvas *);
+
+ public:
+  ~wxCanvasMediaAdmin();
+
+  /* Usually called by wxMediaBuffer objects: */
+  wxDC *GetDC(float *x = NULL, float *y = NULL);
+  void GetView(float *x, float *y, float *h, float *w, Bool full = FALSE);
+  Bool ScrollTo(float localx, float localy, float, float, 
+		Bool refresh = TRUE, int bias = 0);
+
+  void GrabCaret(int = wxFOCUS_GLOBAL);
+
+  void Resized(Bool update);
+  void NeedsUpdate(float localx, float localy, float w, float h);
+
+  void UpdateCursor();
+  void GetMaxView(float *x, float *y, float *h, float *w, Bool full = FALSE);
+
+  inline wxMediaCanvas *GetCanvas() { return canvas; }
+};
+
+/* Used by wxMediaSnipMediaAdmin: */
+typedef struct {
+  Bool drawing;
+  float x, y;
+  wxDC *dc;
+} wxMSMA_SnipDrawState;
+
+class wxMediaSnipMediaAdmin : public wxMediaAdmin
+{
+  friend class wxMediaSnip;
+  friend class os_wxMediaSnipMediaAdmin;
+  
+  wxMSMA_SnipDrawState state;
+
+  wxMediaSnip *snip;
+
+  void RestoreState(wxMSMA_SnipDrawState *saved);
+  void SaveState(wxMSMA_SnipDrawState *save, wxDC *dc, float x, float y);
+
+  wxMediaSnipMediaAdmin(wxMediaSnip *);
+
+ public:
+
+  wxDC *GetDC(float *x = NULL, float *y = NULL);
+  void GetView(float *x, float *y, float *h, float *w, Bool full = FALSE);
+  Bool ScrollTo(float localx, float localy, float w, float h,
+			Bool refresh = TRUE, int bias = 0);
+  void GrabCaret(int = wxFOCUS_GLOBAL);
+
+  void Resized(Bool redraw_now);
+  void NeedsUpdate(float localx, float localy, float w, float h);
+
+  void UpdateCursor();
+
+  virtual Bool DelayRefresh();
+
+  inline wxMediaSnip* GetSnip() { return snip; }
+};
+
+#endif /* __WX_MEDIA_ADMIN__ */
diff --git a/src/mred/wxme/wx_mbuf.cxx b/src/mred/wxme/wx_mbuf.cxx
new file mode 100644
index 0000000..baee55a
--- /dev/null
+++ b/src/mred/wxme/wx_mbuf.cxx
@@ -0,0 +1,2405 @@
+/*
+ * File:        wx_mbuf.cc
+ * Purpose:     wxMediaBuffer implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#define  Uses_wxPrintSetup /* for wx_xt */
+#include "wx_utils.h"
+#include "wx_win.h"
+#include "wx_menu.h"
+#include "wx_dialg.h"
+#include "wx_buttn.h"
+#include "wx_rbox.h"
+#include "wx_check.h"
+#include "wx_dcps.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_print.h"
+
+#include "wx_media.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_clipb.h"
+#else
+#include "wx_gclip.h"
+#endif
+#include "wx_ptreq.h"
+#include <ctype.h>
+#include <string.h>
+
+#define NUM_MAX_UNDOS 500
+
+#if ALLOW_X_STYLE_SELECTION
+Bool wxMediaXSelectionMode = TRUE;
+wxMediaBuffer *wxMediaXSelectionOwner = NULL;
+wxMediaBuffer *wxMediaXSelectionAllowed = NULL;
+static Bool xSelectionCopied = FALSE;
+static Bool xClipboardHack = FALSE;
+#endif
+
+static void InitCutNPaste(void);
+
+static void MediaStyleNotify(wxStyle *which, wxMediaBuffer *media);
+
+class wxMediaClipboardClient : public wxClipboardClient
+{
+ public:
+  wxMediaClipboardClient();
+  char *GetData(char *format, long *size);
+  void BeingReplaced(void);
+};
+static wxMediaClipboardClient TheMediaClipboardClient;
+
+#if ALLOW_X_STYLE_SELECTION
+class wxMediaXClipboardClient : public wxClipboardClient
+{
+ public:
+  wxMediaXClipboardClient();
+  char *GetData(char *format, long *size);
+  void BeingReplaced(void);
+};
+static wxMediaXClipboardClient TheMediaXClipboardClient;
+#endif
+
+typedef wxChangeRecord *wxChangeRecordPtr;
+
+wxBitmap *wxMediaBuffer::bitmap;
+wxMemoryDC *wxMediaBuffer::offscreen = NULL;
+long wxMediaBuffer::bmHeight, wxMediaBuffer::bmWidth;
+#if defined(wx_msw) && defined(USE_SEP_WINDOW_MGR)
+#define OFFSCREEN_IN_USE_INIT TRUE  /* Until we fix Win32 bug */
+#else
+#define OFFSCREEN_IN_USE_INIT FALSE
+#endif
+Bool wxMediaBuffer::offscreenInUse = OFFSCREEN_IN_USE_INIT;
+wxMediaBuffer *wxMediaBuffer::lastUsedOffscreen = NULL;
+
+
+/******************************************************************/
+
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+static bcounter = 0;
+#endif
+
+wxMediaBuffer::wxMediaBuffer()
+{  
+  map = new wxKeymap();
+  map->AdjustUsage(TRUE);
+  // AddBufferFunctions(map);
+
+  styleList = new wxStyleList;
+  styleList->AdjustUsage(TRUE);
+  styleList->NewNamedStyle(STD_STYLE, NULL);
+  notifyId = styleList->NotifyOnChange((wxStyleNotifyFunc)MediaStyleNotify, 
+				       this);
+
+  filename = NULL;
+
+  undomode = redomode = interceptmode = FALSE;
+  maxUndos = NUM_MAX_UNDOS;
+  changes = new wxChangeRecordPtr[maxUndos];
+  changes_start = changes_end = 0;
+  redochanges =  new wxChangeRecordPtr[maxUndos];
+  redochanges_start = redochanges_end = 0;
+
+  customCursor = NULL;
+
+  loadoverwritesstyles = 1;
+
+  noundomode = 0;
+
+  ownCaret = FALSE;
+  caretSnip = NULL;  
+
+  InitCutNPaste();
+
+  admin = NULL;
+  WXGC_IGNORE(admin);
+
+#ifdef EACH_BUFFER_OWN_OFFSCREEN
+  offscreen = NULL;
+#endif
+
+  if (!offscreen) {
+    bitmap = NULL;
+    offscreen = new wxMemoryDC();
+    bmHeight = bmWidth = 0;
+#ifndef wx_mac
+    offscreen->SetOptimization(TRUE);
+#endif
+  }
+
+  inactiveCaretThreshold = wxSNIP_DRAW_SHOW_INACTIVE_CARET;
+
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+  bcounter++;
+#endif
+}
+
+wxMediaBuffer::~wxMediaBuffer()
+{
+#if ALLOW_X_STYLE_SELECTION
+  if (wxMediaXSelectionOwner == this)
+    wxMediaXSelectionOwner = NULL;
+#endif
+
+  if (map)
+    SetKeymap(NULL);
+
+  styleList->AdjustUsage(FALSE);
+  styleList->ForgetNotification(notifyId);
+#if !WXGARBAGE_COLLECTION_ON
+  if (!styleList->IsUsed())
+    delete styleList;
+#endif
+
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+  --bcounter;
+  if (!bcounter) {
+#endif
+    offscreen->SelectObject(NULL);
+    delete offscreen;
+    if (bitmap)
+      delete bitmap;
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+  }
+#endif
+
+  if (filename)
+    delete[] filename;
+
+  ClearUndos();
+
+  delete[] changes;
+  delete[] redochanges;
+}
+
+/******************************************************************/
+
+void wxMediaBuffer::OnLocalEvent(wxMouseEvent &event)
+{
+  if (map) {
+    if (map->HandleMouseEvent(this, event))
+      return;
+    else if (!event.Moving())
+      map->BreakSequence();
+  }
+
+  OnDefaultEvent(event);
+}
+
+void wxMediaBuffer::OnLocalChar(wxKeyEvent &event)
+{
+  if (map) {
+    if (map->HandleKeyEvent(this, event))
+      return;
+    else
+      map->BreakSequence();
+  }
+
+  OnDefaultChar(event);
+}
+
+void wxMediaBuffer::OnFocus(Bool WXUNUSED(on))
+{
+}
+
+/******************************************************************/
+
+void wxMediaBuffer::SetAdmin(wxMediaAdmin *administrator)
+{
+  SettingAdmin(administrator);
+
+  admin = administrator;
+  if (!admin)
+    ownCaret = FALSE;
+
+  if (admin)
+    InitNewAdmin();
+}
+
+void wxMediaBuffer::SettingAdmin(wxMediaAdmin *)
+{
+}
+
+void wxMediaBuffer::InitNewAdmin()
+{
+}
+
+wxMediaAdmin *wxMediaBuffer::GetAdmin(void)
+{
+  return admin;
+}
+
+/******************************************************************/
+
+#define ShowsGhostCaret() 1
+
+Bool wxMediaBuffer::DoOwnCaret(Bool ownit)
+{
+  Bool refresh;
+
+  refresh = (!caretSnip && (((Bool)ownCaret != ownit) || ShowsGhostCaret()));
+
+  ownCaret = ownit;
+  if (caretSnip)
+    caretSnip->OwnCaret(ownit);
+  if (map && !ownit && refresh)
+    map->BreakSequence();
+
+#if ALLOW_X_STYLE_SELECTION
+  if (ownit && !caretSnip)
+    wxMediaXSelectionAllowed = this;
+  else if (wxMediaXSelectionAllowed == this)
+    wxMediaXSelectionAllowed = NULL;
+#endif
+
+  if (admin)
+    admin->UpdateCursor();
+
+  return refresh;
+}
+
+wxDC *wxMediaBuffer::GetDC()
+{
+  /* This can be called by snips to get a DC appropriate for
+     sizing text, etc., outside of draws. It isn't the destination 
+     for draws, though. */
+  if (admin)
+    return admin->GetDC(NULL, NULL);
+  else
+    return NULL;
+}
+
+void wxMediaBuffer::GetViewSize(float *w, float *h)
+{
+  if (admin)
+    admin->GetView(NULL, NULL, w, h);
+  else {
+    if (w)
+      *w = 0;
+    if (h)
+      *h = 0;
+  }
+}
+
+Bool wxMediaBuffer::DoSetCaretOwner(wxSnip *snip, int dist)
+{
+  Bool hadCaret, visCaret;
+  wxSnip *oldCaret;
+  Bool refresh;
+
+  if (PTREQ(snip, caretSnip)) {
+    if (!admin || (dist == wxFOCUS_IMMEDIATE))
+      return FALSE;
+    admin->GrabCaret(dist);
+  }
+
+  refresh = FALSE;
+
+  visCaret = ownCaret || ShowsGhostCaret();
+
+  if (!snip || !(snip->flags & wxSNIP_HANDLES_EVENTS)) {
+    if (caretSnip) {
+      caretSnip->OwnCaret(FALSE);
+      if (visCaret)
+	refresh = TRUE;
+    }
+    caretSnip = NULL;
+#if ALLOW_X_STYLE_SELECTION
+    wxMediaXSelectionAllowed = this;
+#endif
+    if (admin)
+      admin->UpdateCursor();
+    return refresh;
+  }
+
+  if (!GetSnipLocation(snip, NULL, NULL))
+    return refresh;
+
+  if (!ownCaret)
+    hadCaret = FALSE;
+  else
+    hadCaret = !caretSnip;
+
+  oldCaret = caretSnip;
+  caretSnip = snip;
+
+  BeginEditSequence();
+  if (oldCaret)
+    oldCaret->OwnCaret(FALSE);
+  else if (visCaret)
+    refresh = TRUE;
+  snip->OwnCaret(ownCaret);
+  EndEditSequence();
+
+  if (admin && (dist != wxFOCUS_IMMEDIATE))
+    admin->GrabCaret(dist);
+
+  if (admin)
+    admin->UpdateCursor();
+
+  return refresh;
+}
+
+void wxMediaBuffer::GlobalToLocal(float *x, float *y)
+{
+  float lx, ly;
+
+  if (admin) {
+    admin->GetDC(&lx, &ly);
+    if (x)
+      *x += lx;
+    if (y)
+      *y += ly;
+  }
+}
+
+void wxMediaBuffer::LocalToGlobal(float *x, float *y)
+{
+  float lx, ly;
+
+  if (admin) {
+    admin->GetDC(&lx, &ly);
+    if (x)
+      *x -= lx;
+    if (y)
+      *y -= ly;
+  }
+}
+
+void wxMediaBuffer::SetCursor(wxCursor *c, Bool override)
+{  
+  customCursor = c;
+  customCursorOverrides = override;
+
+  if (admin)
+    admin->UpdateCursor();
+}
+
+/******************************************************************/
+
+#ifndef ROUND
+#include <math.h>
+#define ROUND(x) (int)floor(x)
+#endif
+
+#define REDICULOUS_SIZE 2000
+
+Bool wxMediaBuffer::ReadyOffscreen(float width, float height)
+{
+  if ((width > REDICULOUS_SIZE)
+      || (height > REDICULOUS_SIZE))
+    return FALSE;
+
+  if (!offscreenInUse && (height > bmHeight || width > bmWidth)) {
+    wxBitmap *oldbm = bitmap;
+
+    bmWidth = ROUND(width);
+    bmHeight = ROUND(height);
+
+    bitmap = new wxBitmap(bmWidth, bmHeight);
+
+    offscreen->SelectObject(NULL);
+    if (oldbm)
+      delete oldbm;
+  
+    if (bitmap->Ok())
+      offscreen->SelectObject(bitmap);
+
+    return TRUE;
+  } 
+  
+  return FALSE;
+}
+
+/******************************************************************/
+
+void wxMediaBuffer::SetKeymap(wxKeymap *keymap)
+{
+  if (map) {
+    map->AdjustUsage(FALSE);
+#if !WXGARBAGE_COLLECTION_ON
+    if (!map->IsUsed())
+      delete map;
+#endif
+  }
+  map = keymap;
+  if (keymap)
+    keymap->AdjustUsage(TRUE);
+}
+
+wxKeymap *wxMediaBuffer::GetKeymap(void)
+{
+  return map;
+}
+
+wxStyleList *wxMediaBuffer::GetStyleList(void)
+{
+  return styleList;
+}
+
+void wxMediaBuffer::SetStyleList(wxStyleList *newList)
+{
+  styleList->AdjustUsage(FALSE);
+  styleList->ForgetNotification(notifyId);
+#if !WXGARBAGE_COLLECTION_ON
+  if (!styleList->IsUsed())
+    delete styleList;
+#endif
+  newList->AdjustUsage(TRUE);
+  notifyId = newList->NotifyOnChange((wxStyleNotifyFunc)MediaStyleNotify, 
+				     this);
+  styleList = newList;
+
+  if (!styleList->FindNamedStyle(STD_STYLE))
+    styleList->NewNamedStyle(STD_STYLE, NULL);
+}
+
+static void MediaStyleNotify(wxStyle *which, wxMediaBuffer *media)
+{
+  if (media)
+    media->StyleHasChanged(which);
+}
+
+/******************************************************************/
+
+#define NUM_IMAGE_TYPES 4
+
+static long image_type[NUM_IMAGE_TYPES]
+  = {wxBITMAP_TYPE_BMP,
+     wxBITMAP_TYPE_GIF,
+     wxBITMAP_TYPE_XBM,
+     wxBITMAP_TYPE_XPM};
+static char *image_type_name[NUM_IMAGE_TYPES]
+  = {"Windows Bitmap", "GIF", "X Bitmap", "XPM"};
+static char *image_extension[NUM_IMAGE_TYPES]
+  = {"bmp", "gif", "xbm", "xpm"};
+
+static int image_hit_ok;
+
+static void wxmbSetCancel(wxObject& obj, wxEvent& WXUNUSED(evt))
+{
+  image_hit_ok = 0;
+  ((wxButton *)&obj)->GetParent()->Show(FALSE);
+}
+
+static void wxmbSetOK(wxObject& obj, wxEvent& evt)
+{
+  wxmbSetCancel(obj, evt);
+  image_hit_ok = 1;
+}
+
+#ifdef wx_mac
+#define wxmbUNDO_SUFFIX "\tCmd+Z"
+#define wxmbREDO_SUFFIX 
+#define wxmbCLEAR_SUFFIX
+#define wxmbCOPY_SUFFIX "\tCmd+C"
+#define wxmbCUT_SUFFIX "\tCmd+X"
+#define wxmbPATSE_SUFFIX "\tCmd+V"
+#else
+#define wxmbUNDO_SUFFIX 
+#define wxmbREDO_SUFFIX 
+#define wxmbCLEAR_SUFFIX
+#define wxmbCOPY_SUFFIX
+#define wxmbCUT_SUFFIX
+#define wxmbPATSE_SUFFIX
+#endif
+
+int wxMediaBuffer::AppendEditItems(wxMenu *edit, int idOffset)
+{
+  edit->Append(idOffset + wxEDIT_UNDO, "Undo" wxmbUNDO_SUFFIX );
+  edit->Append(idOffset + wxEDIT_REDO, "Redo" wxmbREDO_SUFFIX );
+  edit->AppendSeparator();
+  edit->Append(idOffset + wxEDIT_CLEAR, "Clear" wxmbCLEAR_SUFFIX);
+  edit->Append(idOffset + wxEDIT_COPY, "Copy" wxmbCOPY_SUFFIX);
+  edit->Append(idOffset + wxEDIT_CUT, "Cut" wxmbCUT_SUFFIX);
+  edit->Append(idOffset + wxEDIT_PASTE, "Paste" wxmbPATSE_SUFFIX);
+  edit->AppendSeparator();
+  edit->Append(idOffset + wxEDIT_INSERT_TEXT_BOX, "Insert Text Box");
+  edit->Append(idOffset + wxEDIT_INSERT_GRAPHIC_BOX, "Insert Graphic Box");
+  edit->Append(idOffset + wxEDIT_INSERT_IMAGE, "Insert Image...");
+
+  return idOffset + _wx_EDIT_counter + 1;
+}
+
+void wxMediaBuffer::DoEdit(int op, Bool recursive, long time)
+{  
+  if (recursive && caretSnip) {
+    caretSnip->DoEdit(op, TRUE, time);
+    return;
+  }
+
+  switch(op) {
+  case wxEDIT_UNDO:
+    Undo();
+    break;
+  case wxEDIT_REDO:
+    Redo();
+    break;
+  case wxEDIT_CLEAR:
+    Clear();
+    break;
+  case wxEDIT_CUT:
+    Cut(FALSE, time);
+    break;
+  case wxEDIT_COPY:
+    Copy(FALSE, time);
+    break;
+  case wxEDIT_PASTE:
+    Paste(time);
+    break;
+  case wxEDIT_KILL:
+    Kill(time);
+    break;
+  case wxEDIT_INSERT_TEXT_BOX:
+    InsertBox(wxEDIT_BUFFER);
+    break;
+  case wxEDIT_INSERT_GRAPHIC_BOX:
+    InsertBox(wxPASTEBOARD_BUFFER);
+    break;
+  case wxEDIT_INSERT_IMAGE:
+    InsertImage();
+    break;
+  case wxEDIT_SELECT_ALL:
+    SelectAll();
+    break;
+  }
+}
+
+#define NUM_FAMILIES 7
+#define NUM_DELTA_SIZES 10
+#define NUM_SIZES 8
+#define NUM_STYLES 3
+#define NUM_WEIGHTS 3
+#define NUM_UNDERLINES 3
+#define NUM_ALIGNS 3
+#define NUM_COLOURS 11
+
+int m_families[NUM_FAMILIES] = {wxDEFAULT,wxDECORATIVE,wxROMAN,
+			      wxSCRIPT,wxSWISS,wxMODERN, -1};
+int m_pl_deltasizes[NUM_DELTA_SIZES] = {1,2,4,8,16,32,0,0,0,0};
+int m_ti_deltasizes[NUM_DELTA_SIZES] = {1,1,1,1,01,01,2,3,4,5};
+int m_sizes[NUM_SIZES] = {9, 10, 12, 14, 16, 24, 32, 48};
+int m_styles[NUM_STYLES] = {wxNORMAL, wxSLANT, wxITALIC};
+int m_weights[NUM_WEIGHTS] = {wxNORMAL, wxLIGHT, wxBOLD};
+int m_alignments[NUM_ALIGNS] = {wxALIGN_TOP, wxALIGN_CENTER, wxALIGN_BOTTOM};
+const char *m_colour_names[NUM_COLOURS] = {"Black", "White",
+				      "Red", "Orange", "Yellow",
+				      "Green", "Blue", "Purple",
+				      "Cyan", "Magenta", "Grey"};
+const char *m_colours[NUM_COLOURS] = {"BLACK", "WHITE",
+				      "RED", "ORANGE", "YELLOW",
+				      "GREEN", "BLUE", "PURPLE",
+				      "CYAN", "MAGENTA", "GREY"};
+				      
+
+int wxMediaBuffer::AppendFontItems(wxMenu *font, int idOffset)
+{
+  wxMenu *family, *size, *style, *weight, *underline;
+  wxMenu *colour, *background, *alignment;
+  wxMenu *bigger, *smaller;
+  int i;
+  
+  family = new wxMenu(NULL, (wxFunction)NULL);
+  bigger = new wxMenu(NULL, (wxFunction)NULL);
+  smaller = new wxMenu(NULL, (wxFunction)NULL);
+  size = new wxMenu(NULL, (wxFunction)NULL);
+  style = new wxMenu(NULL, (wxFunction)NULL);
+  weight = new wxMenu(NULL, (wxFunction)NULL);
+  underline = new wxMenu(NULL, (wxFunction)NULL);
+  colour = new wxMenu(NULL, (wxFunction)NULL);
+  background = new wxMenu(NULL, (wxFunction)NULL);
+  alignment = new wxMenu(NULL, (wxFunction)NULL);
+  
+  font->Append(0, "Face", family);
+  font->Append(1, "Size", size);
+  font->Append(2, "Style", style);
+  font->Append(3, "Weight", weight);
+  font->Append(4, "Underline", underline);
+  font->Append(5, "Alignment", alignment);
+  font->Append(6, "Color", colour);
+  font->Append(7, "Background", background);
+
+  family->Append(idOffset++, "Standard");
+  family->Append(idOffset++, "Decorative");
+  family->Append(idOffset++, "Roman");
+  family->Append(idOffset++, "Script");
+  family->Append(idOffset++, "Swiss");
+  family->Append(idOffset++, "Fixed");
+  family->AppendSeparator();
+  family->Append(idOffset++, "Other...");
+
+  bigger->Append(idOffset++, "+1");
+  bigger->Append(idOffset++, "+2");
+  bigger->Append(idOffset++, "+4");
+  bigger->Append(idOffset++, "+8");
+  bigger->Append(idOffset++, "+16");
+  bigger->Append(idOffset++, "+32");
+  bigger->AppendSeparator();
+  bigger->Append(idOffset++, "x2");
+  bigger->Append(idOffset++, "x3");
+  bigger->Append(idOffset++, "x4");
+  bigger->Append(idOffset++, "x5");
+  
+  smaller->Append(idOffset++, "-1");
+  smaller->Append(idOffset++, "-2");
+  smaller->Append(idOffset++, "-4");
+  smaller->Append(idOffset++, "-8");
+  smaller->Append(idOffset++, "-16");
+  smaller->Append(idOffset++, "-32");
+  smaller->AppendSeparator();
+  smaller->Append(idOffset++, "1/2");
+  smaller->Append(idOffset++, "1/3");
+  smaller->Append(idOffset++, "1/4");
+  smaller->Append(idOffset++, "1/5");
+
+  size->Append(0, "Bigger", bigger);
+  size->Append(1, "Smaller", smaller);
+  size->Append(idOffset++, "9");
+  size->Append(idOffset++, "10");
+  size->Append(idOffset++, "12");
+  size->Append(idOffset++, "14");
+  size->Append(idOffset++, "16");
+  size->Append(idOffset++, "24");
+  size->Append(idOffset++, "32");
+  size->Append(idOffset++, "48");
+
+  style->Append(idOffset++, "Normal");
+  style->Append(idOffset++, "Slant");
+  style->Append(idOffset++, "Italic");
+
+  weight->Append(idOffset++, "Normal");
+  weight->Append(idOffset++, "Light");
+  weight->Append(idOffset++, "Bold");
+
+  underline->Append(idOffset++, "No Underline");
+  underline->Append(idOffset++, "Underlined");
+  underline->Append(idOffset++, "Toggle");
+
+  alignment->Append(idOffset++, "Top");
+  alignment->Append(idOffset++, "Center");
+  alignment->Append(idOffset++, "Bottom");
+
+  for (i = 0; i < NUM_COLOURS; i++)
+    colour->Append(idOffset++, (char *)m_colour_names[i]);
+
+  background->Append(idOffset++, "Transparent");
+  background->AppendSeparator();
+  for (i = 0; i < NUM_COLOURS; i++)
+    background->Append(idOffset++, (char *)m_colour_names[i]);
+
+  return idOffset;
+}
+
+void wxMediaBuffer::DoFont(int op, Bool recursive)
+{
+  if (recursive && caretSnip) {
+    caretSnip->DoFont(op, TRUE);
+    return;
+  }
+
+  if (op < NUM_FAMILIES) {
+    int family = m_families[op];
+    if (family < 0) {
+      char *s = wxGetTextFromUser("Face name:", "Select Face");
+      if (!s)
+	return;
+      wxStyleDelta delta;
+
+      delta.SetDeltaFace(s);
+
+      ChangeStyle(&delta);
+    } else {
+      wxStyleDelta delta(wxCHANGE_FAMILY, family);
+      ChangeStyle(&delta);
+    }
+    return;
+  }
+  op -= NUM_FAMILIES;
+  if (op < NUM_DELTA_SIZES) {
+    wxStyleDelta delta(wxCHANGE_BIGGER, m_pl_deltasizes[op]);
+    delta.sizeMult = m_ti_deltasizes[op];
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_DELTA_SIZES;
+  if (op < NUM_DELTA_SIZES) {
+    wxStyleDelta delta(wxCHANGE_SMALLER, m_pl_deltasizes[op]);
+    delta.sizeMult = 1.0/m_ti_deltasizes[op];
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_DELTA_SIZES;
+  if (op < NUM_SIZES) {
+    wxStyleDelta delta(wxCHANGE_SIZE, m_sizes[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_SIZES;
+  if (op < NUM_STYLES) {
+    wxStyleDelta delta(wxCHANGE_STYLE, m_styles[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_STYLES;
+  if (op < NUM_WEIGHTS) {
+    wxStyleDelta delta(wxCHANGE_WEIGHT, m_weights[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_WEIGHTS;
+  if (op < NUM_UNDERLINES) {
+    wxStyleDelta delta;
+
+    if (op == 2)
+      delta.SetDelta(wxCHANGE_TOGGLE_UNDERLINE);
+    else
+      delta.SetDelta(wxCHANGE_UNDERLINE, op);
+
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_UNDERLINES;
+  if (op < NUM_ALIGNS) {
+    wxStyleDelta delta(wxCHANGE_ALIGNMENT, m_alignments[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_ALIGNS;
+  if (op < NUM_COLOURS) {
+    wxStyleDelta delta;
+    delta.SetDeltaForeground((char *)m_colours[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_COLOURS;
+  if (!op) {
+    wxStyleDelta delta;
+    delta.transparentTextBackingOn = TRUE;
+    ChangeStyle(&delta);
+    return;
+  }
+  op--;
+  if (op < NUM_COLOURS) {
+    wxStyleDelta delta;
+    delta.SetDeltaBackground((char *)m_colours[op]);
+    ChangeStyle(&delta);
+    return;
+  }
+  op -= NUM_COLOURS;
+}
+
+void wxMediaBuffer::InsertBox(int type)
+{
+  wxSnip *snip;
+
+  snip = OnNewBox(type);
+  if (!snip)
+    return;
+
+  BeginEditSequence();
+  snip->style = styleList->FindNamedStyle(STD_STYLE);
+  Insert(snip);
+  SetCaretOwner(snip);
+  EndEditSequence();
+}
+
+wxSnip *wxMediaBuffer::OnNewBox(int type)
+{
+  wxMediaSnip *snip;
+  wxMediaBuffer *media;
+
+  if (type == wxEDIT_BUFFER)
+    media = new wxMediaEdit();
+  else
+    media = new wxMediaPasteboard();
+  snip = new wxMediaSnip(media);
+
+  media->SetKeymap(map);  
+  media->SetStyleList(styleList);
+
+  return snip;
+}
+
+#ifdef wx_msw
+#define WILDCARD "*.*"
+#else
+#define WILDCARD "*"
+#endif
+
+void wxMediaBuffer::InsertImage(char *filename, long type, Bool relative, Bool inlineImg)
+{
+  wxDialogBox *dial;
+  wxRadioBox *boxes;
+  wxCheckBox *inlineBox;
+  int i, len;
+  char extension[10];
+    
+  if (!filename)
+    filename = GetFile(NULL);
+
+  if (!filename)
+    return;
+
+  for (i = 0; i < NUM_IMAGE_TYPES; i++)
+    if (type == image_type[i])
+      break;
+
+  if (i >=  NUM_IMAGE_TYPES) {
+    dial = new wxDialogBox((wxFrame *)NULL, "Image Type", TRUE);
+    
+    len = strlen(filename);
+    for (i = len; --i; )
+      if (filename[i] == '.')
+	break;
+    
+    if (i + 10 > len) {
+      strcpy(extension, filename + i + 1);
+      for (i = 0; extension[i]; i++)
+	extension[i] = tolower(extension[i]);
+    } else
+      extension[0] = 0;
+    
+    dial->SetLabelPosition(wxVERTICAL);
+    boxes = new wxRadioBox(dial, NULL,
+			   "Image format:", -1, -1, -1, -1,
+			   NUM_IMAGE_TYPES, image_type_name,
+			   0, wxVERTICAL);
+    
+    for (i = 0; i < NUM_IMAGE_TYPES; i++)
+      if (!strcmp(image_extension[i], extension))
+	boxes->SetSelection(i);
+    
+    dial->NewLine();
+
+    inlineBox = new wxCheckBox(dial, NULL, "Inline Image");
+    if (inlineImg)
+      inlineBox->SetValue(1);
+    
+    dial->NewLine();
+    
+    (void)(new wxButton(dial, (wxFunction)wxmbSetCancel, "Cancel"));
+    (void)(new wxButton(dial, (wxFunction)wxmbSetOK, "OK"));
+    
+    dial->NewLine();
+    
+    dial->Fit();
+    dial->Center(wxBOTH);
+    dial->Show(TRUE);
+    
+    inlineImg = inlineBox->GetValue();
+
+    type = image_type[boxes->GetSelection()];
+
+    delete dial;
+
+    if (!image_hit_ok)
+      return;
+  }
+
+  wxImageSnip *snip;
+      
+  snip = OnNewImageSnip(filename, type, relative, inlineImg);
+  Insert(snip);
+}
+
+wxImageSnip *wxMediaBuffer::OnNewImageSnip(char *filename, long type, 
+					   Bool relative, Bool inlineImg)
+{
+  return new wxImageSnip(filename, type, relative, inlineImg);
+}
+
+/**********************************************************************/
+
+wxBufferData *wxMediaBuffer::GetSnipData(wxSnip *)
+{
+  return NULL;
+}
+
+void wxMediaBuffer::SetSnipData(wxSnip *, wxBufferData *)
+{
+}
+
+/**********************************************************************/
+
+void *wxMediaFileIOReady = NULL;
+
+Bool wxReadMediaGlobalHeader(wxMediaStreamIn &f)
+{
+  if (wxMediaFileIOReady) {
+    wxMessageBox("File I/O already in progress for some stream.", "Error");
+    return FALSE;
+  }
+
+  wxMediaFileIOReady = (void *)&f;
+
+  wxTheSnipClassList.ResetHeaderFlags();
+  if (!wxTheSnipClassList.Read(f))
+    return FALSE;
+
+  wxmbSetupStyleReadsWrites();
+
+  return wxTheBufferDataClassList.Read(f);
+}
+
+Bool wxReadMediaGlobalFooter(wxMediaStreamIn &f)
+{
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File reading not in progress for this stream.", "Error");
+    return FALSE;
+  }
+
+  wxmbDoneStyleReadsWrites();
+  wxTheSnipClassList.ResetHeaderFlags(wxRESET_DONE_READ);
+
+  wxMediaFileIOReady = NULL;
+
+  return TRUE;
+}
+
+Bool wxWriteMediaGlobalHeader(wxMediaStreamOut &f)
+{
+  if (wxMediaFileIOReady) {
+    wxMessageBox("File I/O already in progress for some stream.", "Error");
+    return FALSE;
+  }
+
+  wxMediaFileIOReady = (void *)&f;
+
+  wxTheSnipClassList.ResetHeaderFlags();
+  if (!wxTheSnipClassList.Write(f))
+    return FALSE;
+
+  wxmbSetupStyleReadsWrites();
+
+  return wxTheBufferDataClassList.Write(f);
+}
+
+Bool wxWriteMediaGlobalFooter(wxMediaStreamOut &f)
+{
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File writing not in progress for this stream.", "Error");
+    return FALSE;
+  }
+
+  wxmbDoneStyleReadsWrites();
+  wxTheSnipClassList.ResetHeaderFlags(wxRESET_DONE_WRITE);
+
+  wxMediaFileIOReady = NULL;
+
+  return TRUE;
+}
+
+/**********************************************************************/
+
+char wxme_current_read_format[MRED_FORMAT_STR_LEN + 1];
+char wxme_current_read_version[MRED_VERSION_STR_LEN + 1];
+
+int wxmeCheckFormatAndVersion(void)
+{
+  if (strcmp(wxme_current_read_format, MRED_FORMAT_STR)) {
+    wxMessageBox("Unknown format number.", "Error");
+    return 0;
+  }
+  if (strcmp(wxme_current_read_version, MRED_VERSION_STR)
+      && strcmp(wxme_current_read_version, "01")
+      && strcmp(wxme_current_read_version, "02")) {
+    wxMessageBox("Unknown version number.", "Error");
+    return 0;
+  }
+
+  return 1;
+}
+
+Bool wxMediaBuffer::ReadHeaderFromFile(wxMediaStreamIn &, char *headerName)
+{
+  char buffer[256];
+
+  sprintf(buffer, "Unknown header data: \"%.100s\"."
+	  " The file will be loaded anyway.", headerName);
+
+  wxMessageBox(buffer, "Warning");
+
+  return TRUE;
+}
+
+Bool wxMediaBuffer::ReadFooterFromFile(wxMediaStreamIn &, char *headerName)
+{
+  char buffer[256];
+
+  sprintf(buffer, "Unknown header data: \"%.100s\"."
+	  " The file will be loaded anyway.", headerName);
+
+  wxMessageBox(buffer, "Warning");
+
+  return TRUE;
+}
+
+Bool wxMediaBuffer::WriteHeadersToFile(wxMediaStreamOut &WXUNUSED(f))
+{
+  return TRUE;
+}
+
+Bool wxMediaBuffer::WriteFootersToFile(wxMediaStreamOut &WXUNUSED(f))
+{
+  return TRUE;
+}
+
+Bool wxMediaBuffer::BeginWriteHeaderFooterToFile(wxMediaStreamOut &f, 
+						 char *headerName,
+						 long *dataBuffer)
+{
+  *dataBuffer = f.Tell();
+  f.PutFixed(0);
+  f << headerName;
+
+  return TRUE;
+}
+
+Bool wxMediaBuffer::EndWriteHeaderFooterToFile(wxMediaStreamOut &f, 
+					       long dataBuffer)
+{
+  long end, pos;
+
+  end = f.Tell();
+
+  f.JumpTo(dataBuffer);
+  f.PutFixed(0);
+  pos = f.Tell();
+  
+  f.JumpTo(dataBuffer);
+  f.PutFixed(end - pos);
+
+  f.JumpTo(end);
+
+  numExtraHeaders++;
+  
+  return TRUE;
+}
+
+Bool wxMediaBuffer::ReadHeadersFooters(wxMediaStreamIn &f, Bool headers)
+{
+  char headerName[256];
+  long len, hlen, i, pos, numHeaders;
+
+  f.GetFixed(numHeaders);
+  if (numHeaders > 1000) {
+    if (wxMessageBox("File contains suspiciously large value for special"
+		     " headers/footers. Should I give up?", "Warning",
+		     wxYES_NO | wxCENTRE) == wxYES)
+      return FALSE;
+  }
+
+  for (i = 0; i < numHeaders; i++) {
+    f.GetFixed(len);
+    if (!f.Ok())
+      return FALSE;
+    if (len) {
+      pos = f.Tell();
+      f.SetBoundary(len);
+      hlen = 256;
+      f.Get((long *)&hlen, (char *)headerName);
+      if (headers) {
+	if (!ReadHeaderFromFile(f, headerName))
+	  return FALSE;
+      } else {
+	if (!ReadFooterFromFile(f, headerName))
+	  return FALSE;
+      }
+      if (!f.Ok())
+	return FALSE;
+      f.RemoveBoundary();
+      if (len -= (f.Tell() - pos))
+	f.Skip(len);
+      if (!f.Ok())
+	return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+Bool wxMediaBuffer::DoWriteHeadersFooters(wxMediaStreamOut &f, Bool headers)
+{
+  long allStart, allEnd;
+
+  allStart = f.Tell();
+  f.PutFixed(0);
+  numExtraHeaders = 0;
+
+  if (headers) {
+    if (!WriteHeadersToFile(f))
+      return FALSE;
+  } else {
+    if (!WriteFootersToFile(f))
+      return FALSE;
+  }
+
+  if (numExtraHeaders) {
+    allEnd = f.Tell();
+    f.JumpTo(allStart);
+    f.PutFixed(numExtraHeaders);
+    f.JumpTo(allEnd);
+  }
+
+  return TRUE;
+}
+
+/**********************************************************************/
+
+static wxBufferData *ReadBufferData(wxMediaStreamIn &f)
+{
+  wxBufferData *data, *newdata;
+  wxBufferDataClass *dclass;
+  int extraDataIndex;
+  long datalen;
+
+  data = NULL;
+  do {
+    f >> extraDataIndex;
+    if (extraDataIndex) {
+      dclass = wxTheBufferDataClassList.FindByMapPosition(extraDataIndex);
+      
+      if (!dclass || !dclass->required)
+	f >> datalen;
+      else
+	datalen = -1;
+      
+      if (dclass) {
+	long start = f.Tell();
+	if (datalen >= 0)
+	  f.SetBoundary(datalen);
+	if (!(newdata = dclass->Read(f)))
+	  return FALSE;
+	newdata->next = data;
+	data = newdata;
+	if (datalen >= 0) {
+	  long rcount = f.Tell() - start;
+	  if (rcount < datalen) {
+	    wxMessageBox("Warning: underread caused by file "
+			 "corruption or unknown internal error.", 
+			 "Warning");
+	    f.Skip(datalen - rcount);
+	  }
+	  f.RemoveBoundary();
+	}
+      } else {
+	/* Unknown extra data */
+	f.Skip(datalen);
+      }
+      if (!f.Ok())
+	return FALSE;
+    }
+  } while (extraDataIndex);
+
+  return data;
+}
+
+Bool wxMediaBuffer::ReadSnipsFromFile(wxMediaStreamIn &f, Bool overwritestylename)
+{
+  long len, numHeaders, numSnips, i;
+  int styleIndex;
+  short n;
+  wxStyleList *newList;
+  wxSnipClass *sclass;
+  wxBufferData *data;
+  wxSnip *snip;
+
+  if (!ReadHeadersFooters(f, TRUE))
+    return FALSE;
+
+  if (!(newList = wxmbReadStylesFromFile(styleList, f, overwritestylename)))
+    return FALSE;
+
+  if (PTRNE(newList, styleList))
+    SetStyleList(newList);
+  
+  f.GetFixed(numHeaders);
+  
+  if (numHeaders > 100) {
+    if (wxMessageBox("File contains suspiciously large value for class"
+		     " headers. Should I give up?", "Warning",
+		     wxYES_NO | wxCENTRE) == wxYES)
+      return FALSE;
+  }
+
+  for (i = 0; i < numHeaders; i++) {
+    f >> n;
+    f.GetFixed(len);
+    if (!f.Ok())
+      return FALSE;
+    if (len) {
+      sclass = wxTheSnipClassList.FindByMapPosition(n);
+      if (sclass) {
+	long start = f.Tell();
+
+	f.SetBoundary(len);
+	if (!sclass->ReadHeader(f))
+	  return FALSE;
+	if (!f.Ok())
+	  return FALSE;
+	sclass->headerFlag = 1;
+
+	long rcount = f.Tell() - start;
+	if (rcount < len) {
+	  wxMessageBox("Warning: underread caused by file "
+		       "corruption or unknown internal error.", 
+		       "Warning");
+	  f.Skip(len - rcount);
+	}
+	
+	f.RemoveBoundary();
+      } else {
+	f.Skip(len);
+      }
+      if (!f.Ok())
+	return FALSE;
+    }
+  }
+
+  f >> numSnips;
+
+  for (i = 0; i < numSnips; i++) {
+    f >> n;
+    if (n >= 0)
+      sclass = wxTheSnipClassList.FindByMapPosition(n);
+    else
+      sclass = NULL; /* -1 => unknown */
+    if (!sclass || !sclass->required)
+      f.GetFixed(len);
+    else
+      len = -1;
+    if (!f.Ok())
+      return FALSE;
+    if (len) {
+      if (sclass) {
+	long start = f.Tell();
+
+	if (len >= 0)
+	  f.SetBoundary(len);
+	f >> styleIndex;
+	if (styleIndex < 0 || styleIndex >= styleList->numMappedStyles) {
+	  wxMessageBox("Bad style index for snip.", "Error");
+	  return FALSE;
+	}
+	if ((snip = sclass->Read(f))) {
+	  if (snip->flags & wxSNIP_OWNED)
+	    snip->flags -= wxSNIP_OWNED;
+	  snip->style = styleList->MapIndexToStyle(styleIndex);
+	  if (!ReadInsert(snip))
+	    return FALSE;
+	} else
+	  return FALSE;
+
+	data = ReadBufferData(f);
+	if (!f.Ok())
+	  return FALSE;
+
+	if (data)
+	  SetSnipData(snip, data);
+
+	if (len >= 0) {
+	  long rcount = f.Tell() - start;
+	  if (rcount < len) {
+	    wxMessageBox("Warning: underread caused by file "
+			 "corruption or unknown internal error.", 
+			 "Warning");
+	    f.Skip(len - rcount);
+	  }
+	  f.RemoveBoundary();
+	}
+      } else {
+	f.Skip(len);
+      }
+      if (!f.Ok())
+	return FALSE;
+    }
+  }
+
+  if (!ReadHeadersFooters(f, FALSE))
+    return FALSE;
+
+  return TRUE;
+}
+
+Bool wxmbWriteBufferData(wxMediaStreamOut &f, wxBufferData *data)
+{
+  long dataPos = 0, dataStart = 0, dataEnd;
+  
+  while (data) {
+    f << data->dataclass->mapPosition;
+    
+    if (!data->dataclass->required) {
+      dataStart = f.Tell();
+      f.PutFixed(0);
+      dataPos = f.Tell();
+    }
+
+    if (!data->Write(f))
+      return FALSE;
+    
+    if (!data->dataclass->required) {
+      dataEnd = f.Tell();
+      f.JumpTo(dataStart);
+      f.PutFixed(dataEnd - dataPos);
+      f.JumpTo(dataEnd);
+    }
+    data = data->next;
+  }
+
+  f << 0;
+
+  return TRUE;
+}
+
+Bool wxmbWriteSnipsToFile(wxMediaStreamOut &f, 
+			  wxStyleList *styleList,
+			  wxList *snipList, 
+			  wxSnip *startSnip, wxSnip *endSnip,
+			  wxList *extraData,
+			  wxMediaBuffer *buffer)
+{
+  long allStart, allEnd, headerPos, headerStart, headerEnd;
+  long snipCount, snipPos = 0, snipStart = 0, snipEnd;
+  long numHeaders;
+  int styleIndex;
+  wxNode *node = NULL, *node2;
+  wxSnip *snip;
+  wxSnipClass *sclass;
+  wxBufferData *data;
+
+  if (!wxmbWriteStylesToFile(styleList, f))
+    return FALSE;
+  
+  allStart = f.Tell();
+  f.PutFixed(0);
+
+  if (snipList) {
+    node = snipList->First();
+    if (!node)
+      return FALSE;
+    startSnip = (wxSnip *)node->Data();
+    endSnip = NULL;
+  } else
+    node = NULL;
+
+  numHeaders = 0;
+  snipCount = 0;
+  for (snip = startSnip; PTRNE(snip, endSnip); snipCount++) {
+    sclass = snip->snipclass;
+    if (!sclass) {
+      wxMessageBox("There's a snip without a class."
+		   " Data will be lost.", "Warning");
+    } else if (!sclass->headerFlag) {
+      f << (short)sclass->mapPosition;
+      headerStart = f.Tell();
+      f.PutFixed(0);
+      headerPos = f.Tell();
+      if (!sclass->WriteHeader(f))
+	return FALSE;
+      sclass->headerFlag = 1;
+      headerEnd = f.Tell();
+      f.JumpTo(headerStart);
+      f.PutFixed(headerEnd - headerPos);
+      f.JumpTo(headerEnd);
+      numHeaders++;
+      if (!f.Ok())
+	return FALSE;
+    }
+
+    if (snipList) {
+      node = node->Next();
+      if (node)
+	snip = (wxSnip *)node->Data();
+      else
+	snip = NULL;
+    } else
+      snip = snip->next;
+  }
+
+  allEnd = f.Tell();
+  f.JumpTo(allStart);
+  f.PutFixed(numHeaders);
+  f.JumpTo(allEnd);
+
+  f << snipCount;
+
+  if (snipList)
+    node = snipList->First();
+  else
+    node = NULL;
+  if (extraData)
+    node2 = extraData->First();
+  else
+    node2 = NULL;
+
+  for (snip = startSnip; PTRNE(snip, endSnip); ) {
+    sclass = snip->snipclass;
+
+    if (sclass)
+      f << (short)sclass->mapPosition;
+    else
+      f << (short)(-1);
+
+    if (!snip->snipclass || !snip->snipclass->required) {
+      snipStart = f.Tell();
+      f.PutFixed(0);
+      snipPos = f.Tell();
+    }
+
+    styleIndex = styleList->StyleToIndex(snip->style);
+    if (styleIndex < 0) {
+      wxMessageBox("Bad style discovered.", "Warning");
+      styleIndex = 0;
+    }
+    f << styleIndex;
+
+    snip->Write(f);
+    if (node2)
+      data = (wxBufferData *)node2->Data();
+    else
+      data = buffer->GetSnipData(snip);
+
+    if (!wxmbWriteBufferData(f, data))
+      return FALSE;
+
+    if (!snip->snipclass || !snip->snipclass->required) {
+      snipEnd = f.Tell();
+      f.JumpTo(snipStart);
+      f.PutFixed(snipEnd - snipPos);
+      f.JumpTo(snipEnd);
+    }
+
+    if (!f.Ok())
+      return FALSE;
+
+    if (snipList) {
+      node = node->Next();
+      if (node)
+	snip = (wxSnip *)node->Data();
+      else
+	snip = NULL;
+    } else
+      snip = snip->next;
+    if (extraData)
+      node2 = node2->Next();
+  }
+
+  return TRUE;
+}
+
+char *wxMediaBuffer::GetFilename(Bool *temp)
+{
+  if (temp)
+    *temp = tempFilename;
+  return filename;
+}
+
+#ifndef wx_xt
+class wxMediaPrintout : public wxPrintout
+{
+private:
+  wxMediaBuffer *b;
+  void *data;
+  Bool fitToPage;
+
+public:
+  wxMediaPrintout(wxMediaBuffer *buffer, Bool fit) : wxPrintout()
+    {
+      b = buffer;
+      fitToPage = fit;
+    }
+
+  Bool HasPage(int page)
+    {
+      return b->HasPrintPage(GetDC(), page);
+    }
+
+  Bool OnPrintPage(int page)
+    {
+      b->PrintToDC(GetDC(), page);
+
+      return TRUE;
+    }
+
+  Bool OnBeginDocument(int startPage, int endPage)
+    {
+      b->printing = GetDC();
+      data = b->BeginPrint(b->printing, fitToPage);
+      return wxPrintout::OnBeginDocument(startPage, endPage);
+    }
+
+  void OnEndDocument()
+    {
+      wxDC *pr = b->printing;
+      b->printing = NULL;
+      b->EndPrint(pr, data);
+      wxPrintout::OnEndDocument();
+    }
+};
+#endif
+
+#ifdef wx_x
+# define WXUNUSED_X(x) /* empty */
+#else
+# define WXUNUSED_X(x) x
+#endif
+
+void wxMediaBuffer::Print(char *filename, Bool interactive, Bool fitToPage, 
+			  int WXUNUSED_X(output_mode))
+{
+  int ps;
+
+#ifndef wx_x
+  if (output_mode == 2) {
+    char *choices[2] = {"PostScript File", "Normal"};
+    int choice = wxGetSingleChoiceIndex("Print as:", "Print Form", 2, choices);
+    if (choice == -1)
+      return;
+    ps = !choice;
+  } else
+    ps = (output_mode == 1);
+#else
+  ps = 1;
+#endif
+
+  if (ps) {
+    wxDC *dc;
+    void *data;
+    
+    dc = new wxPostScriptDC(filename, interactive);
+
+    if (dc->Ok()) { 
+      dc->StartDoc("Printing buffer");
+
+      printing = dc;
+      data = BeginPrint(dc, fitToPage);
+
+      PrintToDC(dc);
+
+      printing = NULL;
+      EndPrint(dc, data);
+
+      dc->EndDoc();
+    }
+
+    delete dc;
+    
+    return;
+  } 
+
+#ifndef wx_x
+  wxPrinter *p = new wxPrinter();
+  wxPrintout *o = new wxMediaPrintout(this, fitToPage);
+  
+  p->Print(NULL, o, interactive);
+
+  delete o;
+  delete p;
+#endif
+}
+
+/****************************************************************/
+
+void wxMediaBuffer::Undo(void)
+{
+  undomode = TRUE;
+
+  PerformUndos(changes, changes_start, changes_end);
+
+  undomode = FALSE;
+}
+
+void wxMediaBuffer::Redo(void)
+{ 
+  redomode = TRUE;
+
+  PerformUndos(redochanges, redochanges_start, redochanges_end);
+
+  redomode = FALSE;
+}
+
+static void wxmeClearUndos(wxChangeRecord **changes, int& start, int& end,
+			   int maxUndos)
+{
+  int i;
+
+  for (i = start; i != end; i = (i + 1) % maxUndos) {
+    delete changes[i];
+    changes[i] = NULL;
+  }
+
+  start = end = 0;  
+}
+
+void wxMediaBuffer::AddUndo(wxChangeRecord *rec)
+{
+  if (interceptmode)
+    intercepted->Append((wxObject *)rec);
+  else if (undomode)
+    AppendUndo(rec, redochanges, redochanges_start, redochanges_end);
+  else if (!noundomode) {
+    if (!redomode)
+      wxmeClearUndos(redochanges, redochanges_start,
+		     redochanges_end, maxUndos);
+    AppendUndo(rec, changes, changes_start, changes_end);    
+  } else
+    delete rec;
+}
+
+void wxMediaBuffer::AppendUndo(wxChangeRecord *rec, wxChangeRecord **changes, 
+			       int& start, int& end)
+{
+  if (maxUndos) {
+    changes[end] = rec;
+    end = (end + 1) % maxUndos;
+    if (end == start) {
+      delete changes[start];
+      changes[start] = NULL;
+      start = (start + 1) % maxUndos;
+    }
+  } else
+    delete rec;
+}
+
+void wxMediaBuffer::PerformUndos(wxChangeRecord **changes, 
+				 int& start, int& end)
+{
+  wxChangeRecord *rec;
+  Bool cont;
+  
+  BeginEditSequence();
+  while (start != end) {
+    end = (end - 1 + maxUndos) % maxUndos;
+    rec = changes[end];
+    changes[end] = NULL;
+    cont = rec->Undo(this);
+    delete rec;
+    if (!cont)
+      break;
+  }
+  EndEditSequence();
+}
+
+void wxMediaBuffer::PerformUndoList(wxList *changes)
+{
+  wxNode *node;
+  wxChangeRecord *rec;
+  Bool cont = FALSE;
+  
+  BeginEditSequence();
+  do {
+    node = changes->Last();
+    if (node) {
+      rec = (wxChangeRecord *)node->Data();
+      cont = rec->Undo(this);
+      delete rec;
+      changes->DeleteNode(node);
+    }
+  } while (node && cont);
+  EndEditSequence();
+}
+
+void wxMediaBuffer::ClearUndos()
+{
+  wxmeClearUndos(changes, changes_start, changes_end, maxUndos);
+  wxmeClearUndos(redochanges, redochanges_start, redochanges_end, maxUndos);
+}
+
+void wxMediaBuffer::SetMaxUndoHistory(int v)
+{
+  if (undomode || redomode || (v == maxUndos))
+    return;
+
+  wxChangeRecord **naya;
+  int i, j;
+
+  naya = new wxChangeRecordPtr[v];
+  for (j = 0, i = changes_start; 
+       (i != changes_end) && (j < v); 
+       j++, i = (i + 1) % maxUndos)
+    naya[j] = changes[i];
+  changes_start = 0;
+  changes_end = v ? (j % v) : 0;
+
+  naya = new wxChangeRecordPtr[v];
+  for (j = 0, i = redochanges_start; 
+       (i != redochanges_end) && (j < v); 
+       j++, i = (i + 1) % maxUndos)
+    naya[j] = redochanges[i];
+  redochanges_start = 0;
+  redochanges_end = v ? (j % v) : v;
+
+  maxUndos = v;
+}
+
+int wxMediaBuffer::GetMaxUndoHistory()
+{
+  return maxUndos;
+}
+
+/****************************************************************/
+
+typedef struct {
+  wxList *buffer1, *buffer2;
+  wxStyleList *style;
+  wxBufferData *data;
+} CopyRingElem;
+
+static int copyDepth = 0;
+
+static int copyRingSize = 30;
+static int copyRingPos = 0, copyRingMax = 0;
+static CopyRingElem *copyRing = NULL;
+
+wxList *wxmb_commonCopyBuffer = NULL;
+wxList *wxmb_commonCopyBuffer2 = NULL;
+wxStyleList *wxmb_copyStyleList = NULL;
+wxBufferData *wxmb_commonCopyRegionData = NULL;
+
+static void InitCutNPaste()
+{
+  if (!copyRing) {
+    copyRing = new CopyRingElem[copyRingSize];
+
+    wxmb_commonCopyBuffer = new wxList();
+    wxmb_commonCopyBuffer2 = new wxList();
+  }
+}
+
+void wxMediaBuffer::CopyRingNext(void)
+{
+  if (!copyRingMax)
+    return;
+
+  copyRingPos = copyRingPos - 1;
+  if (copyRingPos < 1)
+    copyRingPos = copyRingMax - 1;
+  
+  wxList *temp;
+  wxStyleList *stemp;
+  wxBufferData *dtemp;
+
+  temp = wxmb_commonCopyBuffer;
+  wxmb_commonCopyBuffer = copyRing[copyRingPos].buffer1;
+  copyRing[copyRingPos].buffer1 = temp;
+
+  temp = wxmb_commonCopyBuffer2;
+  wxmb_commonCopyBuffer2 = copyRing[copyRingPos].buffer2;
+  copyRing[copyRingPos].buffer2 = temp;
+  
+  dtemp = wxmb_commonCopyRegionData;
+  wxmb_commonCopyRegionData = copyRing[copyRingPos].data;
+  copyRing[copyRingPos].data = dtemp;
+
+  stemp = wxmb_copyStyleList;
+  wxmb_copyStyleList = copyRing[copyRingPos].style;
+  copyRing[copyRingPos].style = stemp;
+}
+
+void wxMediaBuffer::BeginCopyBuffer(void)
+{
+  copyDepth++;
+}
+
+void wxMediaBuffer::EndCopyBuffer(void)
+{
+  --copyDepth;
+}
+
+void wxMediaBuffer::FreeOldCopies(void)
+{
+  if (!wxmb_copyStyleList)
+    return;
+
+  if (copyDepth > 1) {
+    /* Delete current ring occupant: */
+    wxmb_commonCopyBuffer->DeleteContents(TRUE);
+    delete wxmb_commonCopyBuffer;
+    wxmb_commonCopyBuffer2->DeleteContents(TRUE);
+    delete wxmb_commonCopyBuffer2;
+
+    if (wxmb_commonCopyRegionData)
+      delete wxmb_commonCopyRegionData;
+    if (wxmb_copyStyleList) {
+      wxmb_copyStyleList->AdjustUsage(FALSE);
+#ifndef WXGARBAGE_COLLECTION_ON
+      if (!wxmb_copyStyleList->IsUsed())
+	delete wxmb_copyStyleList;
+#endif
+    }
+
+    wxmb_commonCopyBuffer = new wxList();
+    wxmb_commonCopyBuffer2 = new wxList();
+
+    wxmb_commonCopyRegionData = NULL;
+
+    wxmb_copyStyleList = NULL;
+
+    return;
+  }
+
+  if (copyRingMax > copyRingPos) {
+    /* Delete current ring occupant: */
+    copyRing[copyRingPos].buffer1->DeleteContents(TRUE);
+    delete copyRing[copyRingPos].buffer1;
+    copyRing[copyRingPos].buffer2->DeleteContents(TRUE);
+    delete copyRing[copyRingPos].buffer2;
+
+    if (copyRing[copyRingPos].data)
+      delete copyRing[copyRingPos].data;
+    if (copyRing[copyRingPos].style) {
+      copyRing[copyRingPos].style->AdjustUsage(FALSE);
+#ifndef WXGARBAGE_COLLECTION_ON
+      if (!copyRing[copyRingPos].style->IsUsed())
+	delete copyRing[copyRingPos].style;
+#endif
+    }
+  }
+
+  copyRing[copyRingPos].buffer1 = wxmb_commonCopyBuffer;
+  copyRing[copyRingPos].buffer2 = wxmb_commonCopyBuffer2;
+  
+  wxmb_commonCopyBuffer = new wxList();
+  wxmb_commonCopyBuffer2 = new wxList();
+
+  copyRing[copyRingPos].data = wxmb_commonCopyRegionData;
+  wxmb_commonCopyRegionData = NULL;
+
+  copyRing[copyRingPos].style = wxmb_copyStyleList;
+  wxmb_copyStyleList = NULL;
+
+  copyRingPos++;
+  if (copyRingMax < copyRingPos)
+    copyRingMax = copyRingPos;
+  if (copyRingPos > copyRingSize)
+    copyRingPos = 0;
+}
+
+void wxMediaBuffer::InstallCopyBuffer(long time, wxStyleList *sl)
+{
+  wxmb_copyStyleList = sl;
+  wxmb_copyStyleList->AdjustUsage(TRUE);
+
+#if ALLOW_X_STYLE_SELECTION
+  if (!xClipboardHack)
+#endif
+    wxTheClipboard->SetClipboardClient(&TheMediaClipboardClient, time);
+}
+
+void wxMediaBuffer::DoBufferPaste(long time, Bool local)
+{
+  wxClipboardClient *owner;
+  wxNode *node, *node2;
+  wxSnip *snip;
+  
+  owner = wxTheClipboard->GetClipboardClient();
+  if (local || PTREQ(owner, &TheMediaClipboardClient)) {
+    copyDepth++;
+    for (node = wxmb_commonCopyBuffer->First(),
+	 node2 = wxmb_commonCopyBuffer2->First(); 
+	 node; 
+	 node = node->Next(),
+	 node2 = node2->Next())
+      InsertPasteSnip(snip = ((wxSnip *)node->Data())->Copy(),
+		      (wxBufferData *)node2->Data());
+    --copyDepth;
+    if (wxmb_commonCopyRegionData && bufferType == wxEDIT_BUFFER)
+      ((wxMediaEdit *)this)->PasteRegionData(wxmb_commonCopyRegionData);
+  } else {
+    char *str;
+    long len;
+
+    if ((str = wxTheClipboard->GetClipboardData("WXME", &len, time))) {
+
+      strcpy(wxme_current_read_format, MRED_FORMAT_STR);
+      strcpy(wxme_current_read_version, MRED_VERSION_STR);
+
+      wxMediaStreamInStringBase b(str, len);
+      wxMediaStreamIn mf(b);
+
+      if (wxReadMediaGlobalHeader(mf))
+	if (mf.Ok())
+	  if (ReadFromFile(mf)) {
+	    wxBufferData *data;
+	    data = ReadBufferData(mf);
+	    if (data && bufferType == wxEDIT_BUFFER)
+	      ((wxMediaEdit *)this)->PasteRegionData(data);
+	  }
+      wxReadMediaGlobalFooter(mf);
+      delete[] str;
+    } else {
+      str = wxTheClipboard->GetClipboardString(time);
+      InsertPasteString(str);
+      delete[] str;
+    }
+  }
+}
+
+wxMediaClipboardClient::wxMediaClipboardClient()
+{
+  formats.Add("TEXT");
+  formats.Add("WXME");
+}
+
+char *wxMediaClipboardClient::GetData(char *format, long *size)
+{
+  wxNode *node;
+  wxSnip *snip;
+  long l, length = 0;
+  char *str, *total = NULL, *old;
+
+  if (!strcmp(format, "TEXT")) {
+    for (node = wxmb_commonCopyBuffer->First(); node; node = node->Next()) {
+      snip = (wxSnip *)node->Data();
+      str = snip->GetText(0, snip->count, TRUE);
+      l = strlen(str);
+      if (total) {
+	old = total;
+	total = new char[length + l + 1];
+	memcpy(total, old, length);
+	memcpy(total + length, str, l);
+	delete[] old;
+      } else
+	total = str;
+      length += l;
+    }
+    
+    if (!total)
+      total = new char[1];
+    
+    total[length] = 0;
+    
+    *size = length;
+
+    return total;
+  } else if (!strcmp(format, "WXME")) {
+    wxMediaStreamOutStringBase b;
+    wxMediaStreamOut mf(b);
+
+    wxWriteMediaGlobalHeader(mf);
+    if (mf.Ok()) {
+      mf.PutFixed(0);
+      if (!wxmbWriteSnipsToFile(mf, wxmb_copyStyleList, wxmb_commonCopyBuffer, 
+				NULL, NULL, wxmb_commonCopyBuffer2, NULL))
+	return FALSE;
+      mf.PutFixed(0);
+      wxmbWriteBufferData(mf, wxmb_commonCopyRegionData);
+    }
+    wxWriteMediaGlobalFooter(mf);
+
+    return b.GetString(size);
+  } else {
+    *size = 0;
+    return "";
+  }
+}  
+
+void wxMediaClipboardClient::BeingReplaced(void)
+{
+}
+
+#if ALLOW_X_STYLE_SELECTION
+
+wxMediaXClipboardClient::wxMediaXClipboardClient()
+{
+  formats.Add("TEXT");
+  formats.Add("WXME");
+}
+
+char *wxMediaXClipboardClient::GetData(char *format, long *size)
+{
+  if (!xSelectionCopied && !wxMediaXSelectionOwner) {
+    *size = 0;
+    return "";
+  }
+
+  if (!xSelectionCopied || wxMediaXSelectionOwner) {
+    xClipboardHack = TRUE;
+    wxMediaXSelectionOwner->Copy(FALSE, 0L);
+    xClipboardHack = FALSE;
+  }
+
+  /* If nothing is copied (e.g., DoCopy is overriden to not copy anything
+     or copies directly to clipboard): */
+  if (!wxmb_copyStyleList) {
+    if (wxTheClipboard->GetClipboardClient() == this)
+      return NULL;
+    else
+      return wxTheClipboard->GetClipboardData(format, size, 0);
+  }
+
+  return TheMediaClipboardClient.GetData(format, size);
+}
+
+void wxMediaXClipboardClient::BeingReplaced(void)
+{
+  if (wxMediaXSelectionOwner) {
+    wxMediaBuffer *b = wxMediaXSelectionOwner;
+    wxMediaXSelectionOwner= NULL;
+    xSelectionCopied = FALSE;
+    b->OwnXSelection(FALSE, TRUE, FALSE);
+  } else
+    xSelectionCopied = FALSE;
+}
+
+#endif
+
+/****************************************************************/
+
+#if ALLOW_X_STYLE_SELECTION
+
+Bool wxMediaBuffer::DoOwnXSelection(Bool on, Bool force)
+{
+  if (on) {
+    if (!force && wxMediaXSelectionAllowed != this)
+      return FALSE;
+    if (wxMediaXSelectionOwner) {
+      wxMediaXSelectionOwner->OwnXSelection(FALSE, TRUE, FALSE);
+      wxMediaXSelectionOwner = NULL; // should be redundant
+    }
+    xSelectionCopied = FALSE;
+    wxTheClipboard->SetClipboardClient(&TheMediaXClipboardClient, 0L);
+    wxMediaXSelectionOwner = this;
+  } else if (this == wxMediaXSelectionOwner) {
+    wxMediaXSelectionOwner = NULL;
+    if (!xSelectionCopied
+	&& PTREQ(wxTheClipboard->GetClipboardClient(), 
+		 &TheMediaXClipboardClient)) {
+      wxTheClipboard->SetClipboardString("", 0L);
+    }
+  }
+
+  return TRUE;
+}
+
+void wxMediaBuffer::CopyOutXSelection(void)
+{
+  if (this == wxMediaXSelectionOwner) {
+    xClipboardHack = TRUE;
+    wxMediaXSelectionOwner->Copy(FALSE, 0L);
+    xClipboardHack = FALSE;
+    xSelectionCopied = TRUE;
+  }
+}
+
+#endif
+
+void wxMediaSetXSelectionMode(Bool on)
+{
+#if ALLOW_X_STYLE_SELECTION
+  wxMediaXSelectionMode = on;
+  if (!on && PTREQ(wxTheClipboard->GetClipboardClient(), 
+		   &TheMediaXClipboardClient))
+    wxTheClipboard->SetClipboardString("", 0L);
+#endif
+}
+
+/****************************************************************/
+
+void wxMediaBuffer::Lock(Bool lock)
+{
+  userLocked = lock;
+}
+
+Bool wxMediaBuffer::Modified(void)
+{
+  return modified;
+}
+
+void wxMediaBuffer::SetModified(Bool mod)
+{
+  modified = mod;
+}
+
+int wxMediaBuffer::GetInactiveCaretThreshold(void)
+{
+  return inactiveCaretThreshold;
+}
+
+void wxMediaBuffer::SetInactiveCaretThreshold(int v)
+{
+  inactiveCaretThreshold = v;
+}
+
+
+void wxMediaBuffer::OnPaint(Bool WXUNUSED(pre),
+			    wxDC *WXUNUSED(dc), 
+			    float WXUNUSED(l), float WXUNUSED(t), 
+			    float WXUNUSED(r), float WXUNUSED(b), 
+			    float WXUNUSED(dx), float WXUNUSED(dy),
+			    int WXUNUSED(show_caret))
+{
+  /* Do nothing */
+}
+
+Bool wxMediaBuffer::OnSaveFile(char *WXUNUSED(filename), int WXUNUSED(format))
+{
+  return TRUE;
+}
+
+void wxMediaBuffer::AfterSaveFile(Bool WXUNUSED(success))
+{
+  /* do nothing */
+}
+
+Bool wxMediaBuffer::OnLoadFile(char *WXUNUSED(filename), int WXUNUSED(format))
+{
+  return TRUE;
+}
+
+void wxMediaBuffer::AfterLoadFile(Bool WXUNUSED(success))
+{
+  /* do nothing */
+}
+
+void wxMediaBuffer::OnEditSequence(void)
+{
+  /* Do nothing */
+}
+
+void wxMediaBuffer::AfterEditSequence(void)
+{
+  /* Do nothing */
+}
+
+char *wxMediaBuffer::GetFile(char *path)
+{
+  return wxFileSelector("Choose a file", path, NULL,
+			NULL, WILDCARD, wxOPEN);
+}
+ 
+char *wxMediaBuffer::PutFile(char *path, char *suggested_name)
+{
+  return wxFileSelector("Save file as", path,
+			suggested_name, NULL, WILDCARD, wxSAVE);
+}
+
+void wxMediaBuffer::SetLoadOverwritesStyles(Bool b)
+{
+  loadoverwritesstyles = b;
+}
+
+Bool wxMediaBuffer::GetLoadOverwritesStyles()
+{
+  return loadoverwritesstyles;
+}
+
+
+/****************************************************************/
+
+#if USE_OLD_TYPE_SYSTEM
+#define __CHECK_TYPE(b) b->__type != wxTYPE_MEDIA_EDIT && b->__type != wxTYPE_MEDIA_PASTEBOARD
+#else
+#define __CHECK_TYPE(b) TRUE
+#endif
+
+#define edf(name, action, kname) \
+     static Bool ed_##name(wxMediaBuffer *b, wxKeyEvent kname, void *) \
+     { if (__CHECK_TYPE(b)) \
+        return FALSE; \
+       b->action; \
+       return TRUE; } \
+
+edf(copy, Copy(FALSE, event.timeStamp), &event)
+edf(copyappend, Copy(TRUE, event.timeStamp), &event)
+edf(paste, Paste(event.timeStamp), &event)
+edf(cut, Cut(FALSE, event.timeStamp), &event)
+edf(kill, Kill(event.timeStamp), &event)
+edf(cutappend, Cut(TRUE, event.timeStamp), &event)
+edf(undo, Undo(), &)
+edf(redo, Redo(), &)
+edf(delete, Clear(), &)
+edf(select_all, SelectAll(), &)
+
+void wxMediaBuffer::AddBufferFunctions(wxKeymap *tab)
+{
+  wxAddMediaBufferFunctions(tab);
+}
+
+void wxAddMediaBufferFunctions(wxKeymap *tab)
+{
+#define setf(name, func) \
+  tab->AddKeyFunction(name, (wxKeyFunction)ed_##func, NULL)
+
+  setf("copy-clipboard", copy);
+  setf("copy-append-clipboard", copyappend);
+  setf("cut-clipboard", cut);
+  setf("cut-append-clipboard", cutappend);
+  setf("paste-clipboard", paste);
+  setf("delete-selection", delete);
+  setf("clear-selection", delete);
+  setf("delete-to-end-of-line", kill);
+
+  setf("undo", undo);
+  setf("redo", redo);
+
+  setf("select-all", select_all);
+}
+
+/****************************************************************/
+
+#ifdef MEMORY_USE_METHOD
+long wxMediaBuffer::MemoryUse(void)
+{
+  return ((filename ? strlen(filename) + 1 : 0)
+	  + (maxUndos * 2 * sizeof(wxChangeRecord*))
+	  + wxObject::MemoryUse());
+}
+#endif
+
+/****************************************************************/
+
+wxStandardSnipAdmin::wxStandardSnipAdmin(wxMediaBuffer *m)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_MEDIA_SNIP_ADMIN;
+#endif
+
+  media = m;
+  WXGC_IGNORE(media);
+}
+
+wxMediaBuffer *wxStandardSnipAdmin::GetMedia(void)
+{
+  return media;
+}
+
+wxDC *wxStandardSnipAdmin::GetDC()
+{
+  return media->GetDC();
+}
+
+void wxStandardSnipAdmin::GetViewSize(float *w, float *h)
+{
+  GetView(NULL, NULL, w, h, NULL);
+}
+
+void wxStandardSnipAdmin::GetView(float *x, float *y, float *w, float *h, wxSnip *snip)
+{
+  wxMediaAdmin *admin = media->GetAdmin();
+    
+  if (snip) {
+    if (admin) {
+      float mx, my, mh, mw, mr, mb, sl, st, sr, sb;
+
+      admin->GetView(&mx, &my, &mw, &mh, FALSE);
+
+      mb = my + mh;
+      mr = mx + mw;
+      if (media->GetSnipLocation(snip, &sl, &st, FALSE)) {
+	media->GetSnipLocation(snip, &sr, &sb, TRUE);
+	
+	float l, t, r, b;
+	l = (mx > sl ? mx : sl);
+	t = (my > st ? my : st);
+	r = (mr > sr ? sr : mr);
+	b = (mb > sb ? sb : mb);
+	
+	if (x)
+	  *x = l - sl;
+	if (y)
+	  *y = t - st;
+	if (w)
+	  *w = (r - l);
+	if (h)
+	  *h = (b - t);
+	
+	return;
+      }
+    }
+  } else {
+    if (admin) {
+      admin->GetView(x, y, w, h, TRUE);
+      return;
+    }
+  }
+
+  if (x) *x = 0;
+  if (y) *y = 0;
+  if (w) *w = 0;
+  if (h) *h = 0;
+}
+
+Bool wxStandardSnipAdmin::ScrollTo(wxSnip *s, float localx, float localy, 
+				   float w, float h, Bool refresh, int bias)
+{
+  return media->ScrollTo(s, localx, localy, w, h, refresh, bias);
+}
+
+void wxStandardSnipAdmin::SetCaretOwner(wxSnip *s, int dist)
+{
+  media->SetCaretOwner(s, dist);
+}
+ 
+void wxStandardSnipAdmin::Resized(wxSnip *s, Bool redraw_now)
+{
+  media->Resized(s, redraw_now);
+}
+
+Bool wxStandardSnipAdmin::Recounted(wxSnip *s, Bool redraw_now)
+{
+  return media->Recounted(s, redraw_now);
+}
+
+void wxStandardSnipAdmin::NeedsUpdate(wxSnip *s, float localx, float localy, 
+				      float w, float h)
+{
+  media->NeedsUpdate(s, localx, localy, w, h);
+}
+
+Bool wxStandardSnipAdmin::ReleaseSnip(wxSnip *snip)
+{
+  return media->ReleaseSnip(snip);
+}
+
+void wxStandardSnipAdmin::UpdateCursor()
+{
+  if (media->admin)
+    media->admin->UpdateCursor();
+}
+
+#ifdef wx_mac
+
+#include <Files.h>
+
+long wxMediaCreatorId = 'WXME';
+
+void wxMediaSetFileCreatorType(char *file, Bool is_binary)
+{
+  FSSpec spec;
+  FInfo info;
+  Str255 filename;
+
+  memcpy(filename, file, 255);
+  filename[255] = 0;
+  CtoPstr((char *)filename);
+
+  FSMakeFSSpec(0, 0, filename, &spec);
+
+  FSpGetFInfo(&spec, &info);
+  info.fdCreator = wxMediaCreatorId;
+  info.fdType = is_binary ? 'WXME' : 'TEXT';
+  FSpSetFInfo(&spec, &info);
+}
+
+#endif
diff --git a/src/mred/wxme/wx_medad.cxx b/src/mred/wxme/wx_medad.cxx
new file mode 100644
index 0000000..93c8975
--- /dev/null
+++ b/src/mred/wxme/wx_medad.cxx
@@ -0,0 +1,1489 @@
+/*
+ * File:        wx_medad.cc
+ * Purpose:     wxMediaCanvas & wxDrawableMediaAdmin implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+ */
+
+
+#include "wx_canvs.h"
+#include "wx_media.h"
+#include "wx_types.h"
+#include "wx_gcrct.h"
+#include "wx_ptreq.h"
+#include "wx_timer.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <fstream.h>
+#include <ctype.h>
+
+#define XMARGIN 5
+#define YMARGIN 5
+
+#ifdef wx_motif
+#define MEDIA_CANVAS_COMBAT_CLIP_BUG
+#endif
+
+class SimpleScroll
+{
+  Bool horizontal;
+
+  int count, pageStep, value;
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  wxMediaCanvas *canvas;
+
+  int h, w;
+  int arrow_w, bar_w, thumb_w, thumb_x;
+
+  int wherex, wherey;
+
+  int thumb_drag_offset;
+  
+#endif
+ public:
+  SimpleScroll(wxMediaCanvas *, long style = 0,
+	      int length = 0, int stepsPerPage = 4,
+	      int position = 0);
+  ~SimpleScroll();
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  void DoCallback(void);
+
+  void Event(int x, int y, int w, int h, wxMouseEvent &);
+  void Paint(int x, int y, int w, int h);
+
+  void IntDrawLine(int x1, int y1, int x2, int y2);
+  void DrawRectangle(float x, float y, float w, float h);
+
+  void Click(int x);
+  int trackState;
+  Bool scrolling;
+#endif
+
+  void SetValue(int);
+  int GetValue(void);
+  void SetScroll(int len = -1, int page = -1, int position = -1);  
+};
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+#define SB_WIDTH 14
+#endif
+
+class wxUpdateCursorTimer : public wxTimer 
+{
+  wxCanvasMediaAdmin *admin;
+ public:
+  wxUpdateCursorTimer(wxCanvasMediaAdmin *a) {
+    admin = a;
+    Start(0, TRUE);
+  }
+  void Notify(void) {
+    Stop();
+    admin->updateCursorTimer = NULL;
+    admin->canvas->UpdateCursorNow();
+  }
+};
+
+/************************************************************************/
+
+#ifndef wxOVERRIDE_KEY_TRANSLATIONS
+#define wxOVERRIDE_KEY_TRANSLATIONS 0
+#endif
+
+#define INIT_SB ((style & (wxMCANVAS_NO_H_SCROLL | wxMCANVAS_HIDE_H_SCROLL)) ? 0 : wxHSCROLL) \
+                + ((style & (wxMCANVAS_NO_V_SCROLL | wxMCANVAS_HIDE_V_SCROLL)) ? 0 : wxVSCROLL)
+
+wxMediaCanvas::wxMediaCanvas(wxWindow *parent,
+			     int x, int y,
+			     int width, int height,
+			     char *name,
+			     long style,
+			     int scrollsPP,
+			     wxMediaBuffer *m)
+: wxCanvas(parent, x, y, width, height,
+	   wxRETAINED + wxBORDER + wxOVERRIDE_KEY_TRANSLATIONS + INIT_SB, name)
+{
+  static int type_added = FALSE;
+
+#if USE_OLD_TYPE_SYSTEM
+  if (!type_added) {
+    wxAllTypes.AddType(wxTYPE_MEDIA_CANVAS, wxTYPE_CANVAS, "media-canvas");
+    type_added = TRUE;
+  }
+
+  __type = wxTYPE_MEDIA_CANVAS;
+#endif
+
+  givenHScrollsPerPage = scrollsPP;
+
+  allowXScroll = !(style  & wxMCANVAS_NO_H_SCROLL);
+  allowYScroll = !(style  & wxMCANVAS_NO_V_SCROLL);
+  fakeXScroll = !allowXScroll || (style & wxMCANVAS_HIDE_H_SCROLL);
+  fakeYScroll = !allowYScroll || (style & wxMCANVAS_HIDE_V_SCROLL);
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  hscroll = new SimpleScroll(this, wxHORIZONTAL, 0, 1, 0);
+  vscroll = new SimpleScroll(this, wxVERTICAL, 0, 1, 0);
+  scrollWidth = scrollHeight = 0;
+#else
+  EnableScrolling(!fakeXScroll, !fakeYScroll);
+  noloop = TRUE;
+  wxCanvas::SetScrollbars(fakeXScroll ? -1 : 1, fakeYScroll ? -1 : 1,
+#ifdef wx_msw
+			  fakeXScroll ? -1 : 1, fakeYScroll ? -1 : 1,
+#else
+			  1, 1,
+#endif
+			  1, 1, 0, 0, FALSE);
+  hscroll = fakeXScroll 
+    ? new SimpleScroll(this, wxHORIZONTAL, 0, 1, 0) 
+    : (SimpleScroll *)NULL;
+  vscroll = fakeYScroll 
+    ? new SimpleScroll(this, wxVERTICAL, 0, 1, 0) 
+    : (SimpleScroll *)NULL;
+  scrollWidth = fakeXScroll ? 0 : 1;
+  scrollHeight = fakeYScroll ? 0 : 1;
+#endif
+
+  vscrollsPerPage = hscrollsPerPage = 1;
+  hpixelsPerScroll = 0;
+
+  noloop = FALSE;
+
+  SetBackground(wxTheBrushList->FindOrCreateBrush("white", wxSOLID));
+
+  admin = new wxCanvasMediaAdmin(this);
+  admin->standard = 1;
+
+  customCursor = NULL;
+  customCursorOn = FALSE;
+
+  focuson = FALSE;
+  focusforcedon = FALSE;
+
+  scrollToLast = FALSE;
+  scrollBottomBased = FALSE;
+  scrollOffset = 0;
+
+  lastwidth = lastheight = -1;
+
+  lazy_refresh = need_refresh = FALSE;
+
+  if (m)
+    SetMedia(m);
+
+#ifndef wx_mac
+  GetDC()->SetOptimization(TRUE);
+#endif
+}
+
+wxMediaCanvas::~wxMediaCanvas()
+{
+  if (media) {
+    if (admin->nextadmin || admin->prevadmin)
+      SetMedia(NULL);
+    else
+      delete media;
+  }
+
+  delete admin;
+}
+
+void wxMediaCanvas::OnSize(int w, int h)
+{
+#ifndef wx_msw
+  wxCanvas::OnSize(w, h);
+#endif
+
+  if (noloop)
+    return;
+
+  if (w == lastwidth
+      && h == lastheight)
+    return;
+
+  if (media && media->printing)
+    return;
+
+  ResetVisual(FALSE);
+
+#if defined(MEDIA_CANVAS_INTERNAL_SCROLLS) || defined(wx_mac)
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  DestroyClippingRegion();
+#endif
+  Clear();
+#endif
+
+#ifdef NO_GET_CLIPPING_REGION
+#ifndef MEDIA_CANVAS_INTERNAL_SCROLLS
+  int cliph, clipw;
+  GetClientSize(&clipw, &cliph);
+  SetClippingRegion(XMARGIN, YMARGIN,
+		    clipw - 2 * XMARGIN, cliph - 2 * YMARGIN);
+#endif
+#endif
+
+  Refresh();
+}
+
+void wxMediaCanvas::OnFocus(Bool focus)
+{
+  if (focuson == focus)
+    return;
+
+  focuson = focus;
+  if (media && !media->printing) {
+    wxCanvasMediaAdmin *oldadmin;
+    
+    if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin)) {
+      media->SetAdmin(admin);
+    }
+    
+    media->OwnCaret(focus);
+    
+    if (PTRNE(oldadmin, admin)) {
+      media->SetAdmin(oldadmin);
+    }
+  }
+}
+
+void *wxMediaCanvas::CallAsPrimaryOwner(void *(*f)(void *), void *data)
+{
+  void *r;
+
+  if (media) {
+    wxCanvasMediaAdmin *oldadmin;
+    
+    if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin)) {
+      media->SetAdmin(admin);
+    }
+    
+    r = f(data);
+    
+    if (PTRNE(oldadmin, admin)) {
+      media->SetAdmin(oldadmin);
+    }
+  } else
+    r = f(data);
+
+  return r;
+}
+
+void wxMediaCanvas::OnSetFocus()
+{
+  OnFocus(TRUE);
+}
+
+void wxMediaCanvas::OnKillFocus()
+{
+  OnFocus(FALSE);
+}
+
+Bool wxMediaCanvas::IsFocusOn()
+{
+  return focuson;
+}
+
+void wxMediaCanvas::ForceDisplayFocus(Bool on)
+{
+  int old = focusforcedon;
+
+  focusforcedon = on;
+
+  admin->AdjustStdFlag();
+
+  if ((focuson || focusforcedon) != ((focuson || old)))
+    Repaint();
+}
+
+void wxMediaCanvas::OnEvent(wxMouseEvent &event)
+{
+  last_x = event.x;
+  last_y = event.y;
+
+#ifdef wx_msw
+  if (!focuson && event.ButtonDown())
+    SetFocus();
+#endif
+  
+  if (media && !media->printing) {
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+    if ((!event.Dragging() 
+	 || (vscroll && vscroll->scrolling) 
+	 || (hscroll && hscroll->scrolling))
+	// Dragging into/outof window gives enter/leave events
+	&& !(event.ButtonIsDown(-1) && (event.Leaving() || event.Entering()))) {
+      int h, w;
+      GetClientSize(&w, &h);
+      if (!fakeYScroll) {
+	if (vscroll->scrolling
+	    || ((fakeXScroll || !hscroll->scrolling)
+		&& (event.x > w - SB_WIDTH) 
+		&& (event.y < h - (fakeXScroll ? 0 : SB_WIDTH)))) {
+	  NoCustomCursor();
+	  vscroll->Event(w - SB_WIDTH, 0, SB_WIDTH, h - SB_WIDTH, event);
+	  return;
+	}
+      }
+      if (!fakeXScroll) {
+	if (hscroll->scrolling
+	    || ((event.y > h - SB_WIDTH) 
+		&& (event.x < w - (fakeYScroll ? SB_WIDTH : 0)))) {
+	  NoCustomCursor();
+	  hscroll->Event(0, h - SB_WIDTH, w - SB_WIDTH, SB_WIDTH, event);
+	  return;
+	}
+      }
+      if (!fakeXScroll && !fakeYScroll)
+	if ((event.y > h - SB_WIDTH) || (event.x > w - SB_WIDTH)) {
+	  NoCustomCursor();
+	  return;
+	}
+
+      if (customCursor && !customCursorOn)
+	SetCustomCursor(customCursor);
+    }
+#endif
+    wxCanvasMediaAdmin *oldadmin;
+    
+    if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin)) {
+      media->SetAdmin(admin);
+    }
+    
+    event.eventObject = this;
+
+    SetCustomCursor(media->AdjustCursor(event));
+    media->OnEvent(event);
+    
+    if (PTRNE(oldadmin, admin)) {
+      media->SetAdmin(oldadmin);
+    }
+  }
+}
+
+void wxMediaCanvas::UpdateCursorNow(void)
+{
+  if (!media)
+    return;
+
+  wxMouseEvent *event = new wxMouseEvent(wxEVENT_TYPE_MOTION);
+  
+  event->x = last_x;
+  event->y = last_y;
+  event->timeStamp = 0L;
+  event->eventObject = this;
+
+  wxCanvasMediaAdmin *oldadmin;
+    
+  if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin))
+    media->SetAdmin(admin);
+  
+  SetCustomCursor(media->AdjustCursor(*event));
+    
+  if (PTRNE(oldadmin, admin))
+    media->SetAdmin(oldadmin);
+}
+
+void wxMediaCanvas::OnChar(wxKeyEvent &event)
+{
+  if (media && !media->printing) {
+    wxCanvasMediaAdmin *oldadmin;
+    
+    if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin)) {
+      media->SetAdmin(admin);
+    }
+
+    event.eventObject = this;
+    
+    media->OnChar(event);
+    
+    if (PTRNE(oldadmin, admin)) {
+      media->SetAdmin(oldadmin);
+    }
+  }
+}
+
+void wxMediaCanvas::OnPaint(void)
+{
+  need_refresh = FALSE;
+
+  if (media) {
+    if (!media->printing) {
+      float w, h, x, y;
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+      PaintScrolls();
+#endif
+      GetView(&x, &y, &w, &h);
+      Redraw(x, y, w, h);
+    }
+  } else
+    Clear();
+  
+  wxCanvas::OnPaint();
+}
+
+void wxMediaCanvas::Repaint(void)
+{
+  if (need_refresh)
+    return;
+
+  if (lazy_refresh) {
+    need_refresh = TRUE;
+    Refresh();
+  } else
+    OnPaint();
+}
+
+void wxMediaCanvas::PaintScrolls(void)
+{
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  int h, w;
+
+  DestroyClippingRegion();
+  GetClientSize(&w, &h);
+  if (!fakeXScroll)
+    hscroll->Paint(0, h - (fakeYScroll ? 0 : SB_WIDTH), 
+		   w - SB_WIDTH, SB_WIDTH);
+  if (!fakeYScroll)
+    vscroll->Paint(w - SB_WIDTH, 0, 
+		   SB_WIDTH, h - (fakeXScroll ? 0 : SB_WIDTH));
+  
+  SetClippingRegion(XMARGIN, YMARGIN,
+		    w - 2 * XMARGIN - (fakeYScroll ? 0 : SB_WIDTH),
+		    h - 2 * YMARGIN - (fakeXScroll ? 0 : SB_WIDTH));
+#endif
+}
+
+void wxMediaCanvas::SetLazyRefresh(Bool on)
+{
+  lazy_refresh = on;
+  if (!on && need_refresh)
+    OnPaint();
+}
+
+Bool wxMediaCanvas::GetLazyRefresh(void)
+{
+  return lazy_refresh;
+}
+
+void wxMediaCanvas::SetCustomCursor(wxCursor *cursor)
+{
+  if (!cursor) {
+    NoCustomCursor();
+  } else {
+    customCursorOn = TRUE;
+    customCursor = cursor;
+    SetCursor(customCursor);
+  }
+}
+
+void wxMediaCanvas::NoCustomCursor(void)
+{
+  static wxCursor *arrow = NULL;
+  
+  if (!arrow)
+    arrow = new wxCursor(wxCURSOR_ARROW);
+
+  if (customCursorOn) {
+    customCursorOn = FALSE;
+    SetCursor(arrow);
+  }
+}
+
+wxDC *wxMediaCanvas::GetDCAndOffset(float *fx, float *fy)
+{
+  int x, y;
+
+  if (fx || fy) {
+    GetScroll(&x, &y);
+    if (fx)
+      *fx = x * hpixelsPerScroll - XMARGIN;
+    if (fy) {
+      if (media && (y  || scrollBottomBased)) {
+	int h, w;
+	GetClientSize(&w, &h);
+	h -= 2 * YMARGIN;
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+	if (!fakeXScroll)
+	  h -= SB_WIDTH;
+#endif
+	if (h < 0)
+	  h = 0;
+	*fy = media->ScrollLineLocation(y + scrollOffset) - YMARGIN;
+	if (scrollBottomBased && (scrollHeight || scrollToLast))
+	  *fy -= h;
+      } else
+	*fy = -YMARGIN;
+    }
+  }
+
+  return GetDC();
+}
+
+void wxMediaCanvas::GetView(float *fx, float *fy, float *fw, float *fh, 
+			    Bool WXUNUSED(full))
+{
+  int h, w;
+
+  GetClientSize(&w, &h);
+  GetDCAndOffset(fx, fy);
+  if (1 /* !full */) {
+    if (fx)
+      *fx += XMARGIN;
+    if (fy)
+      *fy += YMARGIN;
+  }
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  if (!fakeXScroll)
+    h -= SB_WIDTH;
+  if (!fakeYScroll)
+    w -= SB_WIDTH;
+  if (h < 0)
+    h = 0;
+  if (w < 0)
+    w = 0;
+#endif
+  if (0 /* full */) {
+    if (fh)
+      *fh = h;
+    if (fw)
+      *fw = w;
+  } else {
+    if (fh) {
+      if (h > 2 * YMARGIN)
+	*fh = h - 2 * YMARGIN;
+      else
+	*fh = 0;
+    }
+    if (fw) {
+      if (w > 2 * XMARGIN)
+	*fw = w - 2 * XMARGIN;
+      else
+	*fw = 0;
+    }
+  }
+}
+
+void wxMediaCanvas::Redraw(float localx, float localy, float fw, float fh)
+{
+  float x, y, w, h, right, bottom;
+
+  if (!media || media->printing)
+    return;
+
+#ifdef MEDIA_CANVAS_COMBAT_CLIP_BUG
+  int cliph, clipw;
+  GetClientSize(&clipw, &cliph);
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  if (!fakeXScroll)
+    cliph -= SB_WIDTH;
+  if (!fakeYScroll)
+    clipw -= SB_WIDTH;
+#endif
+  SetClippingRegion(XMARGIN, YMARGIN,
+		    clipw - 2 * XMARGIN, cliph - 2 * YMARGIN);
+#endif
+  
+  GetView(&x, &y, &w, &h);
+
+  right = x + w;
+  bottom = y + h;
+
+  if (localx > x)
+    x = localx;
+  if (localy > y)
+    y = localy;
+
+  if (right > localx + fw)
+    right = localx + fw;
+  if (bottom > localy + fh)
+    bottom = localy + fh;
+  w = right - x;
+  h = bottom - y;
+
+  if (w < 0)
+    w = 0;
+  if (h < 0)
+    h = 0;
+
+  if (w && h) {
+    wxCanvasMediaAdmin *oldadmin;
+
+    if (PTRNE((oldadmin = (wxCanvasMediaAdmin *)media->GetAdmin()), admin)) {
+      media->SetAdmin(admin);
+    }
+    
+    media->Refresh(x, y, w, h, 
+		   (focuson || focusforcedon)
+		   ? wxSNIP_DRAW_SHOW_CARET
+		   : wxSNIP_DRAW_SHOW_INACTIVE_CARET);
+
+    if (PTRNE(oldadmin, admin)) {
+      media->SetAdmin(oldadmin);
+    }
+  }
+}
+
+Bool wxMediaCanvas::ScrollTo(float localx, float localy, float fw, float fh,
+			     Bool refresh, int bias)
+{
+  int cy, cx, sy, sx;
+  float iw, ih;
+  float x, y;
+  float find_dy;
+
+  if (!media || media->printing || (!allowXScroll && !allowYScroll))
+    return FALSE;
+
+  GetView(&x, &y, &iw, &ih);
+
+  if (!iw || !ih)
+    return FALSE;
+
+  if (scrollBottomBased)
+    find_dy = ih;
+  else
+    find_dy = 0;
+
+  GetScroll(&cx, &cy);
+
+  if (allowYScroll) {
+    if (// doesn't fit and bias is set:
+	(bias == -1 && fh > ih) 
+	// fits, need to shift down into view:
+	|| (fh <= ih && localy < y) 
+	// doesn't fit, no conflicting bias, can shift up to see more:
+	|| (fh > ih && bias != 1 && y < localy)) 
+      sy = media->FindScrollLine(find_dy + localy) - scrollOffset;
+    else if (// doesn't fit, bias is set:
+	     (bias == 1 && fh > ih) 
+	     // fits, need to shift up into view:
+	     || (fh <= ih && y + ih < localy + fh) 
+	     // doesn't fit, no conflicting bias, can shift down to see more:
+	     || (fh > ih && bias != -1 && localy + fh > y + ih))
+      sy = media->FindScrollLine(find_dy + localy + fh - ih) + 1 - scrollOffset;
+    else
+      sy = cy;
+  } else
+    sy = cy;
+
+  if (allowXScroll) {
+    if (hpixelsPerScroll) {
+      if ((bias == -1 && fw > iw)
+	  || (fw < iw && localx < x)
+	  || (fw > iw && bias != 1 && x < localx))
+	sx = (int)(localx / hpixelsPerScroll);
+      else if ((bias == 1 && fw > iw)
+	       || (fw < iw && x + iw < localx + fw)
+	       || (fw > iw && bias != -1 && localx + fw > x + iw))
+	sx = (int)((localx + fw - iw) / hpixelsPerScroll) + 1;
+      else
+	sx = cx;
+    } else
+      sx = 0;
+  } else
+    sx = cx;
+
+  if (sy != cy || sx != cx) {
+    if (hscroll)
+      hscroll->SetValue(sx);
+    if (vscroll)
+      vscroll->SetValue(sy);
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+    if (refresh)
+      Repaint();
+    else
+      PaintScrolls();      
+#else
+    Scroll(sx, sy, refresh);
+#endif
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+Bool wxMediaCanvas::ResetVisual(Bool reset_scroll)
+{
+  int x, y, sx, sy;
+  float w, h;
+  int hnumScrolls, vnumScrolls, hspp, vspp;
+  long tw;
+  float totalHeight, totalWidth;
+  Bool retval = FALSE;
+
+  if (givenHScrollsPerPage < 0) {
+    givenHScrollsPerPage = -2;
+    return FALSE;
+  }
+
+  while (1) {
+    GetScroll(&sx, &sy);
+
+    GetSize(&lastwidth, &lastheight);
+
+    if (media && (allowXScroll || allowYScroll)) {
+      if (reset_scroll)
+	x = y = 0;
+      else {
+	x = sx;
+	y = sy;
+      }
+      
+      GetView(NULL, NULL, &w, &h);
+      media->GetExtent(&totalWidth, &totalHeight);
+
+      if (!h || (!scrollToLast && (h >= totalHeight))) {
+	vnumScrolls = 0;
+	scrollOffset = 0;
+      } else {
+	if (scrollBottomBased) {
+	  vnumScrolls = media->NumScrollLines() - 1;
+	  scrollOffset = 1;
+	  if (!scrollToLast) {
+	    long start;
+	    start = media->FindScrollLine(h + 1) - 1;
+	    scrollOffset += start;
+	    vnumScrolls -= start;
+	  }
+	} else {
+	  long top = (long)(totalHeight - (scrollToLast ? 0 : h));
+	  if (top)
+	    --top;
+	  vnumScrolls = media->FindScrollLine(top) + 1;
+	  if (vnumScrolls >= media->NumScrollLines())
+	    vnumScrolls = media->NumScrollLines() - 1;
+	  scrollOffset = 0;
+	}
+      }
+
+      if (vnumScrolls) {
+	int numLines = media->NumScrollLines() - 1;
+	vspp = (long)(((float)h * numLines) / totalHeight) - 1;
+	if (vspp < 1)
+	  vspp = 1;
+      } else
+	vspp = 1;
+
+      if (totalWidth >= w) {
+	tw = (long)(totalWidth - w);
+
+	hpixelsPerScroll = (long)(w / givenHScrollsPerPage);
+	if (!hpixelsPerScroll)
+	  hpixelsPerScroll = 2;
+
+	if (tw % hpixelsPerScroll)
+	  tw += (hpixelsPerScroll - (tw % hpixelsPerScroll));
+	
+	hnumScrolls = tw / hpixelsPerScroll;
+	hspp = givenHScrollsPerPage;
+      } else {
+	hnumScrolls = 0;
+	hspp = 1;
+      }
+    } else {
+      x = y = 0;
+      hnumScrolls = vnumScrolls = 0;
+      vspp = hspp = 1;
+      if (!media)
+	Clear();
+    }    
+
+    if (scrollWidth != hnumScrolls || scrollHeight != vnumScrolls
+	|| vspp != vscrollsPerPage
+	|| hspp != hscrollsPerPage
+	|| x != sx || y != sy) {
+      
+      if (hscroll)
+	hscroll->SetScroll(hnumScrolls, hspp, x);
+      if (vscroll)
+	vscroll->SetScroll(vnumScrolls, vspp, y);
+      
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+      PaintScrolls();
+#else
+      int savenoloop = noloop;
+      int saveHSPP = givenHScrollsPerPage;
+      
+      noloop = TRUE;
+      givenHScrollsPerPage = -1;
+      
+      if (!fakeXScroll) {
+	if (x > hnumScrolls)
+	  x = hnumScrolls;
+	if (hspp < hscrollsPerPage)
+	  SetScrollPage(wxHORIZONTAL, hspp);
+	if (x < sx)
+	  SetScrollPos(wxHORIZONTAL, x);
+	if (scrollWidth != hnumScrolls)
+	  SetScrollRange(wxHORIZONTAL, hnumScrolls);
+	if (x > sx)
+	  SetScrollPos(wxHORIZONTAL, x);
+	if (hspp > hscrollsPerPage)
+	  SetScrollPage(wxHORIZONTAL, hspp);
+      }
+
+      if (!fakeYScroll) {
+	if (y > vnumScrolls)
+	  y = vnumScrolls;
+	if (vspp < vscrollsPerPage)
+	  SetScrollPage(wxVERTICAL, vspp);
+	if (y < sy)
+	  SetScrollPos(wxVERTICAL, y);
+	if (scrollHeight != vnumScrolls)
+	  SetScrollRange(wxVERTICAL, vnumScrolls);
+	if (y > sy)
+	  SetScrollPos(wxVERTICAL, y);
+	if (vspp > vscrollsPerPage)
+	  SetScrollPage(wxVERTICAL, vspp);
+      }
+
+      Bool goAgain = (givenHScrollsPerPage < -1);
+      givenHScrollsPerPage = saveHSPP;
+      
+      noloop = savenoloop;
+#endif
+      hscrollsPerPage = hspp;
+      vscrollsPerPage = vspp;
+      scrollWidth = hnumScrolls;
+      scrollHeight = vnumScrolls;
+
+#ifndef MEDIA_CANVAS_INTERNAL_SCROLLS
+      if (!goAgain)
+	return TRUE;
+      else
+	retval = TRUE;
+#else
+      return TRUE;
+#endif
+    } else
+      return retval;
+  }
+}
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+#define MCIS_UNUSED(x) 
+#else
+#define MCIS_UNUSED(x) x
+#endif
+
+void wxMediaCanvas::Scroll(int MCIS_UNUSED(x), int MCIS_UNUSED(y), 
+			   Bool MCIS_UNUSED(refresh))
+{
+#ifndef MEDIA_CANVAS_INTERNAL_SCROLLS
+  int savenoloop = noloop;
+  noloop = TRUE;
+  
+  if (x > -1 && !fakeXScroll) {
+    if (scrollWidth) {
+      if (x > scrollWidth)
+	x = scrollWidth;
+      SetScrollPos(wxHORIZONTAL, x);
+    }
+  }
+
+  if (y > -1 && !fakeYScroll) {
+    if (scrollHeight) {
+      if (y > scrollHeight)
+	y = scrollHeight;
+      SetScrollPos(wxVERTICAL, y);
+    }
+  }
+  
+  noloop = savenoloop;
+
+  if (refresh)
+    Repaint();
+#endif
+}
+
+#ifdef WXME_FOR_MRED
+void wxMediaCanvas::Scroll(int, int)
+{
+  /* Nothing */
+}
+
+void wxMediaCanvas::SetScrollbars(int, int, int, int,
+				  int, int, int, int,
+				  Bool)
+{
+  /* Nothing */
+}
+#endif
+
+void wxMediaCanvas::GetScroll(int *x, int *y)
+{
+  /* Get fake scroll values if available */
+  if (hscroll)
+    *x = hscroll->GetValue();
+  if (vscroll)
+    *y = vscroll->GetValue();
+
+#ifndef MEDIA_CANVAS_INTERNAL_SCROLLS
+  if (!hscroll)
+    *x = GetScrollPos(wxHORIZONTAL);
+  if (!vscroll)
+    *y = GetScrollPos(wxVERTICAL);
+#endif
+}
+
+void wxMediaCanvas::OnScroll(wxCommandEvent &)
+{
+  if (noloop)
+    return;
+  Repaint();
+}
+
+wxMediaBuffer *wxMediaCanvas::GetMedia(void)
+{
+  return media;
+}
+
+void wxMediaCanvas::SetMedia(wxMediaBuffer *m, Bool update)
+{
+  if (media) {
+    if (PTREQ((wxCanvasMediaAdmin *)media->GetAdmin(), admin)) {
+      if (admin->nextadmin)
+	media->SetAdmin(admin->nextadmin);
+      else if (admin->prevadmin)
+	media->SetAdmin(admin->prevadmin);
+      else
+	media->SetAdmin(NULL);
+    }
+
+    if (admin->nextadmin) {
+      admin->nextadmin->prevadmin = admin->prevadmin;
+      admin->nextadmin->AdjustStdFlag();
+    }
+    if (admin->prevadmin) {
+      admin->prevadmin->nextadmin = admin->nextadmin;
+      admin->prevadmin->AdjustStdFlag();
+    }
+    if (customCursor) {
+      NoCustomCursor();
+      customCursor = NULL;
+    }
+  }
+  media = m;
+  if (media) {
+    wxMediaAdmin *oldadmin;
+    if ((oldadmin = media->GetAdmin())) {
+      if (!oldadmin->standard) {
+	media = NULL;
+	return;
+      }
+      admin->nextadmin = (wxCanvasMediaAdmin *)oldadmin;
+      admin->prevadmin = admin->nextadmin->prevadmin;
+      admin->nextadmin->prevadmin = admin;
+      admin->nextadmin->AdjustStdFlag();
+      if (admin->prevadmin) {
+	admin->prevadmin->nextadmin = admin;
+	admin->prevadmin->AdjustStdFlag();
+      }
+      /* Get the right cursor: */
+      admin->UpdateCursor();
+    } else {
+      admin->nextadmin = admin->prevadmin = NULL;
+      media->SetAdmin(admin);
+      media->OwnCaret(focuson);
+    }
+  }
+
+  admin->AdjustStdFlag();
+
+  ResetVisual(TRUE);
+  if (update)
+    Repaint();
+}
+
+void wxMediaCanvas::AllowScrollToLast(Bool toLast)
+{
+  scrollToLast = toLast;
+  ResetVisual(FALSE);
+  Repaint();
+}
+
+void wxMediaCanvas::ScrollWithBottomBase(Bool bottom)
+{
+  scrollBottomBased = bottom;
+  ResetVisual(FALSE);
+  Repaint();
+}
+
+/************************************************************************/
+
+wxCanvasMediaAdmin::wxCanvasMediaAdmin(wxMediaCanvas *c)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_CANVAS_MEDIA_ADMIN;
+#endif
+
+  canvas = c;
+  resetFlag = FALSE;
+  nextadmin = prevadmin = NULL;
+  WXGC_IGNORE(canvas);
+  WXGC_IGNORE(nextadmin);
+  WXGC_IGNORE(prevadmin);
+
+  updateCursorTimer = NULL;
+
+  updateBlock = resizedBlock = FALSE;
+}
+
+wxCanvasMediaAdmin::~wxCanvasMediaAdmin()
+{
+}
+
+wxDC *wxCanvasMediaAdmin::GetDC(float *fx, float *fy)
+{
+  if (canvas->media && canvas->media->printing) {
+    if (fx)
+      *fx = 0;
+    if (fy)
+      *fy = 0;
+    return canvas->media->printing;
+  } else
+    return canvas->GetDCAndOffset(fx, fy);
+}
+
+void wxCanvasMediaAdmin::GetView(float *fx, float *fy, float *fh, float *fw, 
+				 Bool full)
+{
+  if (canvas->media && canvas->media->printing) {
+    if (fx)
+      *fx = 0;
+    if (fy)
+      *fy = 0;
+    if (fh)
+      *fh = 10000;
+    if (fw)
+      *fw = 10000;
+  } else
+    canvas->GetView(fx, fy, fh, fw, full);
+}
+
+void wxCanvasMediaAdmin::GetMaxView(float *fx, float *fy, float *fw, float *fh, 
+				    Bool full)
+{
+  if ((!nextadmin && !prevadmin) || (canvas->media && canvas->media->printing)) {
+    GetView(fx, fy, fw, fh, full);
+  } else {
+    wxCanvasMediaAdmin *a;
+    float cx, x, cy, y, cw, w, ch, h;
+
+    a = this;
+    while (a->prevadmin)
+      a = a->prevadmin;
+    a->GetView(&cx, &cy, &cw, &ch);
+    for (a = a->nextadmin; a; a = a->nextadmin) {
+      a->GetView(&x, &y, &w, &h);
+      if (w > cw)
+	cw = w;
+      if (h > ch)
+	ch = h;
+    }
+
+    if (fx)
+      *fx = cx;
+    if (fy)
+      *fy = cy;
+    if (fw)
+      *fw = cw;
+    if (fh)
+      *fh = ch;
+  }
+}
+
+Bool wxCanvasMediaAdmin::ScrollTo(float localx, float localy,
+				    float w, float h, Bool refresh, int bias)
+{
+  if (!canvas->IsFocusOn()) {
+    wxCanvasMediaAdmin *a;
+    
+    for (a = nextadmin; a; a = a->nextadmin)
+      if (a->canvas->IsFocusOn())
+	return a->ScrollTo(localx, localy, w, h, refresh, bias);
+    for (a = prevadmin; a; a = a->prevadmin)
+      if (a->canvas->IsFocusOn())
+	return a->ScrollTo(localx, localy, w, h, refresh, bias);
+  }
+
+  return canvas->ScrollTo(localx, localy, w, h, refresh, bias);
+}
+
+void wxCanvasMediaAdmin::GrabCaret(int dist)
+{
+  if (dist == wxFOCUS_GLOBAL)
+    canvas->SetFocus();
+}
+
+void wxCanvasMediaAdmin::NeedsUpdate(float localx, float localy, 
+				       float w, float h)
+{
+  if (updateBlock)
+    return;
+
+  updateBlock = TRUE;
+
+  if (resetFlag) {
+    canvas->Repaint();
+    resetFlag = FALSE;
+  } else
+    canvas->Redraw(localx, localy, w, h);
+
+  if (nextadmin)
+    nextadmin->NeedsUpdate(localx, localy, w, h);
+  if (prevadmin)
+    prevadmin->NeedsUpdate(localx, localy, w, h);
+
+  updateBlock = FALSE;
+}
+
+void wxCanvasMediaAdmin::Resized(Bool update)
+{
+  if (resizedBlock)
+    return;
+
+  resizedBlock = TRUE;
+
+  resetFlag = canvas->ResetVisual(FALSE) || resetFlag;
+  if (update) {
+    canvas->Repaint();
+    resetFlag = FALSE;
+  }
+  if (nextadmin)
+    nextadmin->Resized(update);
+  if (prevadmin)
+    prevadmin->Resized(update);
+
+  resizedBlock = FALSE;
+}
+
+void wxCanvasMediaAdmin::UpdateCursor()
+{
+  if (!updateCursorTimer) {
+    updateCursorTimer = new wxUpdateCursorTimer(this);
+
+    if (nextadmin)
+      nextadmin->UpdateCursor();
+    if (prevadmin)
+      prevadmin->UpdateCursor();
+  }
+}
+
+void wxCanvasMediaAdmin::AdjustStdFlag(void)
+{ 
+  /* 1 indicates that this is the main admin. 
+     This info is used for quick (Xor) caret refreshing
+     by an editor buffer. */
+
+  standard = (nextadmin 
+	      || prevadmin 
+	      || (canvas && canvas->focusforcedon)) 
+    ? -1 : 1; 
+}
+
+void wxMediaAdmin::GetMaxView(float *fx, float *fy, float *fh, float *fw, 
+			      Bool full)
+{
+  GetView(fx, fy, fh, fw, full);
+}
+
+Bool wxMediaAdmin::DelayRefresh()
+{
+  return FALSE;
+}
+
+/*************************************************************/
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+static wxBrush *scrollBrush = NULL;
+static wxBrush *scrollEraseBrush = NULL;
+static wxPen *scrollErasePen = NULL;
+#endif
+
+#define MIN_THUMB_WIDTH 8
+
+SimpleScroll::SimpleScroll(wxMediaCanvas *
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+			   inside
+#endif
+			   ,
+			   long style,
+			   int length, int stepsPerPage,
+			   int position)
+{
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+  canvas = inside;
+
+  if (!scrollBrush) {
+    scrollBrush = new wxBrush("BLACK", wxSOLID);
+    scrollEraseBrush = new wxBrush("WHITE", wxSOLID);
+    scrollErasePen = new wxPen("WHITE", 1, wxTRANSPARENT);
+  }
+#endif
+
+  count = length;
+  pageStep = stepsPerPage;
+  value = position;
+
+  horizontal = !!(style & wxHORIZONTAL);
+  SetScroll(length, stepsPerPage, position);
+}
+
+SimpleScroll::~SimpleScroll()
+{
+}
+
+void SimpleScroll::SetValue(int position)
+{
+  if (position < 0)
+    position = 0;
+  if (position >= count)
+    position = count;
+
+  value = position;
+}
+
+void SimpleScroll::SetScroll(int length, int stepsPerPage, int position)
+{
+  if (length > -1)
+    count = length;
+  if (stepsPerPage > 0)
+    pageStep = stepsPerPage;
+  if (position > -1)
+    value = position;
+
+  if (value < 0)
+    value = 0;
+  if (value > count)
+    value = count;
+}
+
+int SimpleScroll::GetValue(void)
+{
+  return value;
+}
+
+#ifdef MEDIA_CANVAS_INTERNAL_SCROLLS
+
+void SimpleScroll::IntDrawLine(int x1, int y1, int x2, int y2)
+{
+  if (horizontal)
+    canvas->IntDrawLine(wherex + x1, wherey + y1, wherex + x2, wherey + y2);
+  else
+    canvas->IntDrawLine(wherex + y1, wherey + x1, wherex + y2, wherey + x2);
+}
+
+void SimpleScroll::DrawRectangle(float x, float y, float w, float h)
+{
+  if (horizontal)
+    canvas->DrawRectangle(wherex + x, wherey + y, w, h);
+  else
+    canvas->DrawRectangle(wherex + y, wherey + x, h, w);
+}
+
+void SimpleScroll::Paint(int x, int y, int w, int h)
+{
+  int oldvalue;
+  wxDC *dc;
+  wxBrush *save;
+  wxPen *savePen;
+  int seg, half;
+
+  if (!horizontal) {
+    oldvalue = w;
+    w = h;
+    h = oldvalue;
+  }
+
+  h -= 2;
+
+  wherex = x + (horizontal ? 0 : 1);
+  wherey = y + (horizontal ? 1 : 0);
+
+  if (w < 2 * h)
+    arrow_w = w / 2;
+  else
+    arrow_w = h;
+
+  bar_w = w - 2 * arrow_w;
+  if (bar_w <= 0) {
+    thumb_w = bar_w = 0;
+    thumb_x = arrow_w;
+  } else {
+    if (!count) {
+      thumb_w = bar_w;
+      thumb_x = arrow_w;
+    } else {
+      thumb_w = (long)(((float)pageStep * bar_w) / (count + pageStep));
+      if ((thumb_w < MIN_THUMB_WIDTH) && (bar_w > MIN_THUMB_WIDTH))
+	thumb_w = MIN_THUMB_WIDTH;
+      thumb_x = arrow_w + (long)(((float)value * (bar_w - thumb_w - 1)) / count);
+    }
+  }
+
+  dc = canvas->GetDC();
+  
+  save = dc->GetBrush();
+  savePen = dc->GetPen();
+  dc->SetBrush(scrollBrush);
+
+  IntDrawLine(arrow_w, 0, arrow_w, h);
+  IntDrawLine(w - arrow_w, 0, w - arrow_w, h);
+  IntDrawLine(w + 1, 0, w + 1, h);
+  IntDrawLine(0, 0, w + 1, 0);
+  IntDrawLine(0, h, w + 1, h);
+
+  half = h / 2;
+  seg = arrow_w / 4;
+
+  IntDrawLine(3 * seg, 0, seg, half);
+  IntDrawLine(3 * seg, h, seg + 1, half + 1);
+  IntDrawLine(w - 3 * seg, 0, w - seg, half);
+  IntDrawLine(w - 3 * seg, h, w - seg - 1, half + 1);
+
+  if (bar_w) {
+    if (thumb_w < bar_w) {
+      if (thumb_x > arrow_w)
+	DrawRectangle(arrow_w + 1, 1, thumb_x - arrow_w, h - 1);
+      if (value < count)
+	DrawRectangle(thumb_x + thumb_w, 1, 
+		      w - arrow_w - (thumb_x + thumb_w), h - 1);
+    } else
+      --thumb_w;
+  }
+
+  if (thumb_w > 0) {
+    dc->SetBrush(scrollEraseBrush);
+    dc->SetPen(scrollErasePen);
+    DrawRectangle(thumb_x + 1, 1, thumb_w, h - 1);
+  }
+
+  dc->SetBrush(save);
+  dc->SetPen(savePen);
+}
+
+enum {
+  ss_CLICK = 1,
+  ss_PAGE_DOWN,
+  ss_PAGE_UP,
+  ss_THUMB
+};
+
+void SimpleScroll::Click(int x)
+{
+  int oldvalue = value;
+
+  if (trackState == ss_CLICK) {
+    if (x < arrow_w)
+      SetValue(value - 1);
+    else if (x > w - arrow_w)
+      SetValue(value + 1);
+  } else if (trackState == ss_PAGE_DOWN) {
+    if (x > thumb_x + thumb_w)
+      SetValue(value + pageStep);
+  } else if (trackState == ss_PAGE_UP) {
+    if (x < thumb_x)
+      SetValue(value - pageStep);
+  } else if (trackState == ss_THUMB) {
+    x = (x - arrow_w - thumb_drag_offset);
+    int w = bar_w - thumb_w;
+    if (x < 0)
+      x = 0;
+    if (x > w)
+      x = w;
+    SetValue((int)(((float)(x * count) / w) + 0.5));
+  }
+
+  if (value != oldvalue)
+    canvas->Repaint();
+}
+
+#include "wx_timer.h"
+
+#define SS_TIMER_FIRST_DELAY 500
+#define SS_TIMER_DELAY 80
+
+class SSTimer : public wxTimer
+{
+  int x;
+  Bool restarted;
+  SimpleScroll *ss;
+public:
+  SSTimer(int _x, SimpleScroll *_ss) { x = _x; ss = _ss; restarted = FALSE;}
+  void Notify(void) 
+  {
+    if (ss->trackState) {
+      wxYield(); /* timer can take over: check for events */
+      ss->Click(x);
+      if (!restarted) {
+	restarted = 1;
+	Start(SS_TIMER_DELAY);
+      }
+    } else if (restarted)
+      Stop();
+  }
+};
+
+#define SS_USE_TIMER(trackState) \
+ (trackState == ss_CLICK \
+  || trackState == ss_PAGE_UP \
+  || trackState == ss_PAGE_DOWN)
+
+void SimpleScroll::Event(int x, int y, int w, int h, wxMouseEvent &event)
+{
+  x = (long)event.x - x;
+  y = (long)event.y - y;
+
+  if (!horizontal) {
+    int oldvalue = x;
+    x = y;
+    y = oldvalue;
+    oldvalue = w;
+    w = h;
+    h = oldvalue;
+  }
+
+  if (event.ButtonDown() && !scrolling) {
+    if (x < arrow_w || x > w - arrow_w)
+      trackState = ss_CLICK;
+    else if (event.MiddleDown()) {
+      thumb_drag_offset = (thumb_w / 2);
+      trackState = ss_THUMB;
+    } else {
+      if (x < thumb_x)
+	trackState = ss_PAGE_UP;
+      else if (x > thumb_x + thumb_w)
+	trackState = ss_PAGE_DOWN;
+      else {
+	thumb_drag_offset = x - thumb_x;
+	trackState = ss_THUMB;
+      }
+    }
+
+    if (SS_USE_TIMER(trackState))
+      (new SSTimer(x, this))->Start(SS_TIMER_FIRST_DELAY, TRUE);
+    scrolling = TRUE;
+  } else if (event.Dragging()) {
+    if (SS_USE_TIMER(trackState))
+      return;
+  } else if (event.ButtonUp()) {
+    trackState = 0;
+    scrolling = FALSE;
+  } else
+    return;
+
+  /* In case mouse-up gets lost: */
+  if (scrolling && !event.leftDown && !event.rightDown && !event.middleDown) {
+    trackState = 0;
+    scrolling = FALSE;
+  }
+
+  if (trackState)
+    Click(x);
+}
+
+#endif
diff --git a/src/mred/wxme/wx_medad.h b/src/mred/wxme/wx_medad.h
new file mode 100644
index 0000000..34f9521
--- /dev/null
+++ b/src/mred/wxme/wx_medad.h
@@ -0,0 +1,465 @@
+
+#ifndef __WX_MEDIA_BUFFER__
+#define __WX_MEDIA_BUFFER__
+
+class wxStyleCanvas;
+class wxStyleScrollbar;
+
+const long
+wxMCANVAS_NO_H_SCROLL = 0x1,
+wxMCANVAS_NO_V_SCROLL = 0x2,
+wxMCANVAS_HIDE_H_SCROLL = 0x4,
+wxMCANVAS_HIDE_V_SCROLL = 0x8;
+
+enum {
+  wxEDIT_BUFFER =1,
+  wxPASTEBOARD_BUFFER
+};
+
+#define STD_STYLE "Standard"
+
+extern int wxmeCheckFormatAndVersion(void);
+
+class wxMediaAdmin;
+class wxKeymap;
+class wxImageSnip;
+
+#ifdef OLD_WXWINDOWS
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+#define EACH_BUFFER_OWN_OFFSCREEN
+#endif
+#endif
+
+#ifndef ALLOW_X_STYLE_SELECTION
+#ifdef wx_x
+#define ALLOW_X_STYLE_SELECTION 1
+#else
+#define ALLOW_X_STYLE_SELECTION 0
+#endif
+#endif
+
+class wxMediaBuffer : public wxObject
+{
+ protected:
+#ifdef EACH_BUFFER_OWN_OFFSCREEN
+  wxBitmap *bitmap;
+  wxMemoryDC *offscreen;
+  long bmHeight, bmWidth;
+  const Bool offscreenInUse = FALSE;
+#else
+  static wxBitmap *bitmap;
+  static wxMemoryDC *offscreen;
+  static long bmHeight, bmWidth;
+  static Bool offscreenInUse;
+  static wxMediaBuffer *lastUsedOffscreen;
+#endif
+
+#if ALLOW_X_STYLE_SELECTION
+  virtual Bool OwnXSelection(Bool on, Bool update, Bool force) = 0;
+  Bool DoOwnXSelection(Bool on, Bool force);
+  void CopyOutXSelection(void);
+
+  friend class wxMediaXClipboardClient;
+#endif
+  friend class wxStandardSnipAdmin;
+
+  wxMediaAdmin *admin;
+
+  wxKeymap *map;
+
+#define TF_Flag(var) unsigned var : 1
+
+  TF_Flag( ownCaret );
+  TF_Flag( tempFilename ); /* TRUE if filename is just a temporary name */
+  TF_Flag( userLocked );
+  TF_Flag( modified );
+  TF_Flag( undomode );
+  TF_Flag( redomode );
+  TF_Flag( interceptmode );
+  TF_Flag( loadoverwritesstyles );
+  TF_Flag( customCursorOverrides );
+  
+  int noundomode;
+
+  wxSnip *caretSnip;
+
+  wxStyleList *styleList;
+  long notifyId;
+  
+  char *filename;  /* last loaded file, or NULL */
+
+  int maxUndos;
+
+  wxChangeRecord **changes;
+  int changes_start, changes_end;
+  wxChangeRecord **redochanges;
+  int redochanges_start, redochanges_end;
+  wxList *intercepted;
+
+  wxCursor *customCursor;
+
+  int inactiveCaretThreshold;
+
+  Bool DoWriteHeadersFooters(wxMediaStreamOut &f, Bool headers);
+  Bool ReadHeadersFooters(wxMediaStreamIn &f, Bool headers);
+
+  Bool ReadSnipsFromFile(wxMediaStreamIn &f, int overstyle);
+
+  virtual Bool ReadInsert(wxSnip *snip) = 0;
+
+  void CopyRingNext(void);
+  void BeginCopyBuffer(void);
+  void EndCopyBuffer(void);
+  void FreeOldCopies(void);
+  void InstallCopyBuffer(long time, wxStyleList *sl);
+  void DoBufferPaste(long time, Bool local = FALSE);
+  virtual void InsertPasteSnip(wxSnip *snip, wxBufferData *) = 0;
+  virtual void InsertPasteString(char *str) = 0;
+
+  void AddUndo(wxChangeRecord *);
+  void PerformUndos(wxChangeRecord **, int& start, int& end);
+  void PerformUndoList(wxList *);
+  void AppendUndo(wxChangeRecord *, wxChangeRecord **, int& start, int& end);
+
+  Bool DoOwnCaret(Bool ownit);
+  Bool DoSetCaretOwner(wxSnip *, int);
+
+  Bool ReadyOffscreen(float w, float h);
+
+  virtual void SettingAdmin(wxMediaAdmin *);
+  virtual void InitNewAdmin(void); 
+
+ public:
+  wxMediaBuffer();
+  ~wxMediaBuffer();
+
+  int bufferType;
+  wxDC *printing;
+
+  void SetAdmin(wxMediaAdmin *admin);
+  wxMediaAdmin *GetAdmin(void);
+
+  virtual void OnEvent(wxMouseEvent &event) = 0;
+  virtual void OnChar(wxKeyEvent &event) = 0;
+  virtual wxCursor *AdjustCursor(wxMouseEvent &event) = 0;
+  virtual void Refresh(float localx, float localy, float w, float h, 
+		       Bool show_caret) = 0;
+  virtual void OwnCaret(Bool ownit) = 0;
+  virtual void SizeCacheInvalid(void) = 0;
+  virtual void GetExtent(float *w, float *h) = 0;
+
+  virtual void OnDefaultEvent(wxMouseEvent &event) = 0;
+  virtual void OnLocalEvent(wxMouseEvent &event);
+
+  virtual void OnDefaultChar(wxKeyEvent &event) = 0;
+  virtual void OnLocalChar(wxKeyEvent &event);
+  
+  /* Callbacks for the wxSnipAdmin: */
+  virtual wxDC *GetDC();
+  virtual void GetViewSize(float *h, float *w);
+  virtual Bool ScrollTo(wxSnip *, float localx, float localy, 
+			float w, float h, Bool refresh, int bias = 0) = 0;
+  virtual void SetCaretOwner(wxSnip *, int = wxFOCUS_IMMEDIATE) = 0;
+  virtual void Resized(wxSnip *, Bool redraw_now) = 0;
+  virtual Bool Recounted(wxSnip *, Bool redraw_now) = 0;
+  virtual void NeedsUpdate(wxSnip *, float localx, float localy, 
+			   float w, float h) = 0;
+  virtual Bool ReleaseSnip(wxSnip *) = 0;
+
+  virtual float ScrollLineLocation(long line) = 0;
+  virtual long NumScrollLines() = 0;
+  virtual long FindScrollLine(float y) = 0;
+
+  virtual wxMediaBuffer *CopySelf(void) = 0;
+  virtual float GetDescent(void) = 0;
+  virtual float GetSpace(void) = 0;
+  virtual char *GetFlattenedText(long *got = NULL) = 0;
+
+  void GlobalToLocal(float *x, float *y);
+  void LocalToGlobal(float *x, float *y);
+
+  /* Edit & Font menus: */
+  void DoEdit(int op, Bool recursive = TRUE, long time = 0);
+  void DoFont(int op, Bool recursive = TRUE);
+  virtual void ChangeStyle(wxStyleDelta *) = 0;
+
+  virtual void Clear() = 0;
+  virtual void Cut(Bool extend, long time) = 0;
+  virtual void Copy(Bool extend, long time) = 0;
+  virtual void Paste(long time) = 0;
+  virtual void Kill(long time) = 0;
+  virtual void SelectAll(void) = 0;
+
+  virtual void Insert(wxSnip *) = 0;
+
+  inline wxSnip *GetFocusSnip(void) { return caretSnip; }
+
+  void InsertBox(int type = wxEDIT_BUFFER);
+  void InsertImage(char *filename = NULL, long type = -1, 
+		   Bool relative = FALSE, Bool inlineImg = TRUE);
+
+  virtual wxSnip *OnNewBox(int type);
+
+  void Undo(void);
+  void Redo(void);
+  void ClearUndos(void);
+
+  void SetMaxUndoHistory(int);
+  int GetMaxUndoHistory();
+
+  int AppendEditItems(wxMenu *edit, int idOffset = 0);
+  int AppendFontItems(wxMenu *font, int idOffset = 0);
+
+  virtual Bool GetSnipLocation(wxSnip *thesnip, 
+			       float *x = NULL, float *y = NULL,
+			       Bool bottomRight=FALSE) = 0;
+
+  virtual Bool WriteToFile(wxMediaStreamOut &) = 0;
+  virtual Bool ReadFromFile(wxMediaStreamIn &, Bool owrs = FALSE) = 0;
+
+  /* Override this to put more information in the file. Make
+     sure that you follow the rules for extra header data. */
+  virtual Bool ReadHeaderFromFile(wxMediaStreamIn &, char *headerName);
+  virtual Bool ReadFooterFromFile(wxMediaStreamIn &, char *headerName);
+  virtual Bool WriteHeadersToFile(wxMediaStreamOut &);
+  virtual Bool WriteFootersToFile(wxMediaStreamOut &);
+  /* Use these functions for adding custom header data: */
+  Bool BeginWriteHeaderFooterToFile(wxMediaStreamOut &, char *headerName,
+				    long *dataBuffer);
+  Bool EndWriteHeaderFooterToFile(wxMediaStreamOut &, long dataBuffer);
+  
+  void SetKeymap(wxKeymap *keymap = NULL);
+  wxKeymap *GetKeymap(void);
+  wxStyleList *GetStyleList(void);
+  virtual void SetStyleList(wxStyleList *styles);
+  virtual void StyleHasChanged(wxStyle *style) = 0;
+
+  /* For making a lot of changes to be displayed at once: */
+  virtual void BeginEditSequence(Bool undoable = TRUE) = 0;
+  virtual void EndEditSequence(void) = 0;
+  virtual Bool RefreshDelayed(void) = 0;
+
+  virtual void SetMaxWidth(float w) = 0;
+  virtual void SetMinWidth(float w) = 0;
+  virtual float GetMaxWidth() = 0;
+  virtual float GetMinWidth() = 0;
+  virtual void SetMinHeight(float w) = 0;
+  virtual void SetMaxHeight(float w) = 0;
+  virtual float GetMinHeight() = 0;
+  virtual float GetMaxHeight() = 0;
+
+  virtual void OnPaint(Bool pre, wxDC *dc,
+		       float, float, float, float, 
+		       float dx, float dy,
+		       int show_caret);
+  virtual void InvalidateBitmapCache(float x=0.0, float y=0.0,
+				     float w=-1.0, float h=-1.0) = 0;
+
+  void Print(char *filename=NULL, Bool interactive=TRUE, Bool fit=FALSE,
+	     int output_mode = 0);
+  virtual void *BeginPrint(wxDC *dc, Bool fit) = 0;
+  virtual void EndPrint(wxDC*, void*) = 0;
+  virtual void PrintToDC(wxDC *dc, int page = -1) = 0;
+  virtual Bool HasPrintPage(wxDC *dc, int page) = 0;
+
+  virtual Bool LoadFile(char *filename = NULL, int format = wxMEDIA_FF_GUESS, Bool showErrors = TRUE) = 0;
+  virtual Bool SaveFile(char *filename = NULL, int format = wxMEDIA_FF_SAME, Bool showErrors = TRUE) = 0;
+  virtual Bool InsertFile(char *filename, int format = wxMEDIA_FF_GUESS, Bool showErrors = TRUE) = 0;
+
+  char *GetFilename(Bool *temp = NULL);
+  virtual void SetFilename(char *, Bool temp = FALSE) = 0;
+  
+  virtual wxBufferData *GetSnipData(wxSnip *);
+  virtual void SetSnipData(wxSnip *, wxBufferData *);
+
+  virtual void OnChange(void) = 0;
+
+  virtual void OnFocus(Bool on);
+
+  virtual Bool OnSaveFile(char *filename, int format);
+  virtual void AfterSaveFile(Bool success);
+  virtual Bool OnLoadFile(char *filename, int format);
+  virtual void AfterLoadFile(Bool success);
+
+  virtual void OnEditSequence(void);
+  virtual void AfterEditSequence(void);
+
+  virtual wxImageSnip *OnNewImageSnip(char *filename, long type, 
+				      Bool relative, Bool inlineImg);
+
+  virtual char *GetFile(char *path);
+  virtual char *PutFile(char *path, char *suggested_name);
+
+  int GetInactiveCaretThreshold(void);
+  void SetInactiveCaretThreshold(int);
+
+  void SetCursor(wxCursor *cursor, Bool override = TRUE);
+
+  /* State */
+  void Lock(Bool);
+  Bool Modified(void);
+  virtual void SetModified(Bool);
+
+  void SetLoadOverwritesStyles(Bool);
+  Bool GetLoadOverwritesStyles();
+
+  void AddBufferFunctions(wxKeymap *tab);
+
+#ifdef MEMORY_USE_METHOD
+  virtual long MemoryUse(void);
+#endif
+
+ private:
+  int numExtraHeaders;
+};
+
+Bool wxReadMediaGlobalHeader(wxMediaStreamIn &f);
+Bool wxReadMediaGlobalFooter(wxMediaStreamIn &f);
+Bool wxWriteMediaGlobalHeader(wxMediaStreamOut &f);
+Bool wxWriteMediaGlobalFooter(wxMediaStreamOut &f);
+wxStyle *wxmbStyleByIndex(int index);
+
+Bool wxmbWriteSnipsToFile(wxMediaStreamOut &, wxStyleList *, 
+			  wxList *, wxSnip *, wxSnip *, wxList *,
+			  wxMediaBuffer *);
+
+class wxCanvasMediaAdmin;
+class SimpleScroll;
+
+class wxMediaCanvas : public wxCanvas
+{
+  friend class wxCanvasMediaAdmin;
+  friend class wxUpdateCursorTimer;
+
+  wxCanvasMediaAdmin *admin;
+  wxMediaBuffer *media;
+  Bool noloop;
+  long hpixelsPerScroll;
+  int givenHScrollsPerPage;
+  int hscrollsPerPage, vscrollsPerPage;
+  int scrollHeight, scrollWidth;
+  Bool focuson, focusforcedon;
+  Bool lazy_refresh, need_refresh;
+
+  wxCursor *customCursor;
+  Bool customCursorOn;
+
+  Bool scrollToLast, scrollBottomBased;
+  int scrollOffset;
+
+  int lastwidth, lastheight;
+
+  float last_x, last_y;
+
+  Bool allowXScroll, allowYScroll;
+  Bool fakeXScroll, fakeYScroll;
+  SimpleScroll *hscroll, *vscroll;
+  void PaintScrolls(void);
+
+  void GetScroll(int *x, int *y);
+  Bool ResetVisual(Bool reset_scroll = FALSE);
+
+  void GetView(float *fx, float *fy, float *fh, float *fw, Bool full = FALSE);
+  wxDC *GetDCAndOffset(float *fx, float *fy);
+  void Redraw(float, float, float, float);
+  Bool ScrollTo(float, float, float, float, Bool refresh = TRUE, int bias = 0);
+
+  void NoCustomCursor(void);
+
+  void UpdateCursorNow(void);
+
+ public:
+  wxMediaCanvas(wxWindow *parent, int x = -1, int y = -1,
+		int width = -1, int height = -1, char *name = "",
+		long scrollStyle = 0,
+		int scrollsPerPage = 100, wxMediaBuffer *m = NULL);
+  ~wxMediaCanvas();
+
+  Bool IsFocusOn();
+
+  /* Override some wxCanvas methods: */
+  virtual void OnSize(int, int);
+  virtual void OnEvent(wxMouseEvent &event);
+  virtual void OnChar(wxKeyEvent &event);
+  virtual void OnPaint(void);
+  virtual void OnScroll(wxCommandEvent& event);
+  virtual void OnSetFocus();
+  virtual void OnKillFocus();
+  virtual void OnFocus(Bool focus);
+
+  virtual void Scroll(int x, int y, Bool refresh);
+
+#ifdef WXME_FOR_MRED
+  /* To block bad uses: */
+  virtual void Scroll(int x, int y);
+  virtual void SetScrollbars(int h_pixels, int v_pixels, int x_len, int y_len,
+			     int x_page, int y_page, int x_pos=0, int y_pos=0,
+			     Bool setVirtualSize = TRUE);
+#endif
+
+  void ForceDisplayFocus(Bool on);
+
+  void SetLazyRefresh(Bool on);
+  Bool GetLazyRefresh(void);
+  void Repaint();
+
+  wxMediaBuffer *GetMedia(void);
+  void SetMedia(wxMediaBuffer *, Bool redisplay = TRUE);
+
+  void SetCustomCursor(wxCursor *cursor);
+
+  void AllowScrollToLast(Bool toLast);
+  void ScrollWithBottomBase(Bool bottom);
+
+  void *CallAsPrimaryOwner(void *(*f)(void *), void *);
+};
+
+class wxCursor;
+
+#include "wx_madm.h"
+
+class wxStandardSnipAdmin : public wxSnipAdmin
+{
+  wxMediaBuffer *media;
+ public:
+  wxStandardSnipAdmin(wxMediaBuffer *m);
+
+  wxMediaBuffer *GetMedia(void);
+
+  wxDC *GetDC();
+  void GetViewSize(float *h, float *w);
+  void GetView(float *x, float *y, float *h, float *w, wxSnip *snip = NULL);
+  Bool ScrollTo(wxSnip *, float localx, float localy, 
+		float w, float h, Bool refresh, int bias = 0);
+  void SetCaretOwner(wxSnip *, int = wxFOCUS_IMMEDIATE);
+  void Resized(wxSnip *, Bool redraw_now);
+  Bool Recounted(wxSnip *, Bool redraw_now);
+  void NeedsUpdate(wxSnip *, float localx, float localy, 
+		   float w, float h);
+  Bool ReleaseSnip(wxSnip *);
+
+  void UpdateCursor();
+};
+
+class wxBufferData;
+class wxStyleList;
+
+extern wxList *wxmb_commonCopyBuffer;
+extern wxList *wxmb_commonCopyBuffer2;
+extern wxBufferData *wxmb_commonCopyRegionData;
+extern wxStyleList *wxmb_copyStyleList;
+
+void wxGetMediaPrintMargin(long *hm=NULL, long *vm=NULL);
+void wxSetMediaPrintMargin(long hm=-1, long vm=-1);
+
+void wxAddMediaBufferFunctions(wxKeymap *tab);
+
+#if ALLOW_X_STYLE_SELECTION
+extern Bool wxMediaXSelectionMode;
+extern wxMediaBuffer *wxMediaXSelectionOwner;
+extern wxMediaBuffer *wxMediaXSelectionAllowed;
+#endif
+
+void wxMediaSetXSelectionMode(Bool on);
+
+#endif /* __WX_MEDIA_BUFFER__ */
diff --git a/src/mred/wxme/wx_media.cxx b/src/mred/wxme/wx_media.cxx
new file mode 100644
index 0000000..9c99e25
--- /dev/null
+++ b/src/mred/wxme/wx_media.cxx
@@ -0,0 +1,3782 @@
+/*
+ * File:        wx_media.cc
+ * Purpose:     wxMediaEdit implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_utils.h"
+#include "wx_media.h"
+#include "wx_types.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "wx_mpriv.h"
+
+static void StandardWordbreak(wxMediaEdit *win, long *start, long *end, int, void*);
+
+wxMediaWordbreakMap wxTheMediaWordbreakMap;
+
+extern void *wxMediaFileIOReady;
+
+#ifdef wx_mac
+extern void wxMediaSetFileCreatorType(char *file, Bool is_binary);
+#endif
+
+static wxCursor *iBeam = NULL, *arrow = NULL;
+
+/************************************************************************/
+
+extern void wxMediaIOCheckLSB(void);
+
+const char *(*wxmeExpandFilename)(const char *) = NULL;
+
+static const char *wxCallExpandPath(const char *f)
+{
+  return wxExpandPath(NULL, f);
+}
+
+void wxInitMedia(void)
+{
+  wxInitClipboard();
+  wxInitStyles();
+
+#if USE_OLD_TYPE_SYSTEM
+  wxAllTypes.AddType(wxTYPE_MEDIA_CANVAS, wxTYPE_CANVAS, "media-canvas");
+
+  wxAllTypes.AddType(wxTYPE_MEDIA_BUFFER, wxTYPE_OBJECT, "media-buffer");
+  wxAllTypes.AddType(wxTYPE_MEDIA_EDIT, wxTYPE_MEDIA_BUFFER, "media-edit");
+  wxAllTypes.AddType(wxTYPE_MEDIA_PASTEBOARD, wxTYPE_MEDIA_BUFFER, "media-pasteboard");
+
+  wxAllTypes.AddType(wxTYPE_SNIP, wxTYPE_OBJECT, "snip");
+  wxAllTypes.AddType(wxTYPE_TEXT_SNIP, wxTYPE_SNIP, "text-snip");
+  wxAllTypes.AddType(wxTYPE_TAB_SNIP, wxTYPE_SNIP, "tab-snip");
+  wxAllTypes.AddType(wxTYPE_IMAGE_SNIP, wxTYPE_SNIP, "image-snip");
+  wxAllTypes.AddType(wxTYPE_MEDIA_SNIP, wxTYPE_SNIP, "media-snip");
+
+  wxAllTypes.AddType(wxTYPE_MEDIA_ADMIN, wxTYPE_OBJECT, "media-admin");
+  wxAllTypes.AddType(wxTYPE_CANVAS_MEDIA_ADMIN, wxTYPE_MEDIA_ADMIN, "canvas-media-admin");
+  wxAllTypes.AddType(wxTYPE_MEDIA_SNIP_MEDIA_ADMIN, wxTYPE_MEDIA_ADMIN, "media-snip-media-admin");
+
+  wxAllTypes.AddType(wxTYPE_MEDIA_SNIP_ADMIN, wxTYPE_OBJECT, "media-snip-admin");
+
+  wxAllTypes.AddType(wxTYPE_SNIP_CLASS, wxTYPE_OBJECT, "snip-class");
+  wxAllTypes.AddType(wxTYPE_BUFFER_DATA, wxTYPE_OBJECT, "buffer-data");
+  wxAllTypes.AddType(wxTYPE_BUFFER_DATA_CLASS, wxTYPE_OBJECT, "buffer-data-class");
+
+  wxAllTypes.AddType(wxTYPE_KEYMAP, wxTYPE_OBJECT, "keymap");
+
+  wxAllTypes.AddType(wxTYPE_STYLE, wxTYPE_OBJECT, "style");
+  wxAllTypes.AddType(wxTYPE_STYLE_DELTA, wxTYPE_OBJECT, "style-delta");
+  wxAllTypes.AddType(wxTYPE_STYLE_LIST, wxTYPE_OBJECT, "style-list");
+
+  wxAllTypes.AddType(wxTYPE_WORDBREAK_MAP, wxTYPE_OBJECT, "wordbreak-map");
+
+  wxAllTypes.AddType(wxTYPE_SNIP_CLASS_LIST, wxTYPE_LIST, "snip-class-list");
+  wxAllTypes.AddType(wxTYPE_BUFFER_DATA_CLASS_LIST, wxTYPE_LIST, "buffer-data-class-list");
+#endif
+
+#ifndef WXME_FOR_MRED
+  wxMediaIOCheckLSB();
+#endif
+
+  if (!wxmeExpandFilename)
+    wxmeExpandFilename = wxCallExpandPath;
+}
+
+wxMediaEdit::wxMediaEdit(float spacing, float *tabstops, int numtabs) 
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_MEDIA_EDIT;
+#endif
+  bufferType = wxEDIT_BUFFER;
+
+  readLocked = FALSE;
+  flowLocked = FALSE;
+  writeLocked = FALSE;
+  userLocked = modified = FALSE;
+  
+  lineSpacing = spacing;
+  maxWidth = minWidth = minHeight = maxHeight = -1;
+
+  hiliteOn = TRUE;
+
+  len = 0;
+
+  // AddEditorFunctions(map);
+
+  startpos = endpos = 0;
+  posateol = FALSE;
+
+  flash = FALSE;
+  flashTimer = NULL;
+
+  delayRefresh = 0;
+
+  refreshUnset = refreshBoxUnset = TRUE;
+  refreshAll = FALSE;
+  delayedscroll = -1;
+  delayedscrollbox = FALSE;
+
+  snipAdmin = new wxStandardSnipAdmin(this);
+
+  caretStyle = NULL;
+
+  MakeOnlySnip();
+
+  snipCacheInvalid = FALSE;
+
+  graphicsInvalid = flowInvalid = FALSE;
+  graphicMaybeInvalid = TRUE;
+  graphicMaybeInvalidForce = FALSE;
+
+  totalHeight = totalWidth = finalDescent = initialSpace = 0;
+
+  drawCachedInBitmap = FALSE;
+
+  overwriteMode = FALSE;
+
+  clickbacks = new wxList();
+
+  typingStreak = FALSE;
+  deletionStreak = FALSE;
+  delayedStreak = FALSE;
+  anchorStreak = FALSE;
+  vcursorStreak = FALSE;
+  killStreak = FALSE;
+  insertForceStreak = FALSE;
+  deleteForceStreak = FALSE;
+
+  keepAnchorStreak = FALSE;
+
+  changed = FALSE;
+
+#if ALLOW_X_STYLE_SELECTION
+  needXCopy = FALSE;
+#endif
+
+  tracking = dragging = FALSE;
+
+  fileFormat = wxMEDIA_FF_STD;
+
+  prevPasteStart = -1;
+
+  tabcount = numtabs;
+  tabs = tabstops;
+  tabSpace = wxTAB_WIDTH;
+  tabSpaceInUnits = TRUE;
+
+  wordBreak = StandardWordbreak;
+  wordBreakData = NULL;
+  wordBreakMap = &wxTheMediaWordbreakMap;
+  if (!wxTheMediaWordbreakMap.IsUsed())
+    wxTheMediaWordbreakMap.AdjustUsage(TRUE); /* Once to keep forever */
+  wxTheMediaWordbreakMap.AdjustUsage(TRUE);
+
+  caretLocationX = -1;
+  caretOn = FALSE;
+
+  autoWrapBitmap = NULL;
+  wrapBitmapWidth = 0;
+
+  betweenThreshold = 2.0;
+}
+
+wxMediaEdit::~wxMediaEdit()
+{
+  wxSnip *snip, *next;
+
+  SetWordbreakMap(NULL);
+
+  for (snip = snips; snip; snip = next) {
+    next = snip->next;
+    delete snip;
+  }
+
+  delete lineRoot;
+
+  clickbacks->DeleteContents(TRUE);
+  delete clickbacks;
+
+  if (tabs)
+    delete[] tabs;
+
+  delete snipAdmin;
+}
+
+wxMediaBuffer *wxMediaEdit::CopySelf(void)
+{
+  wxMediaEdit *m;
+
+  m = new wxMediaEdit(lineSpacing);
+
+  /* Copy parameters, such as tab settings: */
+  if (tabs) {
+    float *t;
+
+    t = new float[tabcount];
+    memcpy(t, tabs, sizeof(float) * tabcount);
+    m->SetTabs(t, tabcount, tabSpace, tabSpaceInUnits);
+  }
+
+  /* Copy style list */
+  m->styleList->Copy(styleList);
+
+  /* Copy all the snips: */
+  wxList *saveBuffer = wxmb_commonCopyBuffer, *copySnips;
+  wxList *saveBuffer2 = wxmb_commonCopyBuffer2, *copySnips2;
+  wxStyleList *saveStyles = wxmb_copyStyleList;
+  wxBufferData *saveData = wxmb_commonCopyRegionData;
+
+  wxmb_commonCopyBuffer = copySnips = new wxList();
+  wxmb_commonCopyBuffer2 = copySnips2 = new wxList();
+  wxmb_copyStyleList = NULL;
+  wxmb_commonCopyRegionData = NULL;
+  Copy(FALSE, 0, 0, len);
+  wxmb_commonCopyBuffer = saveBuffer;
+  wxmb_commonCopyBuffer2 = saveBuffer2;
+  wxmb_copyStyleList = saveStyles;
+  wxmb_commonCopyRegionData = saveData;
+
+  wxNode *node;
+  BeginEditSequence();
+
+  for (node = copySnips->First(); node; node = node->Next())
+    m->Insert((wxSnip *)node->Data());
+
+  EndEditSequence();
+
+  /* Don't delete the snips themselves, though */
+  delete copySnips;
+  delete copySnips2;
+
+  m->SizeCacheInvalid();
+
+  /* All done! */
+  return m;
+}
+
+/******************************************************************/
+
+wxCursor *wxMediaEdit::AdjustCursor(wxMouseEvent &event)
+{
+  float scrollx, scrolly;
+  float x, y;
+  wxSnip *snip;
+  wxDC *dc;
+  Bool onit;
+  long pos;
+  wxCursor *c;
+  float how_close;
+
+  if (!iBeam) {
+    arrow = new wxCursor(wxCURSOR_ARROW);
+    iBeam = new wxCursor(wxCURSOR_IBEAM);
+  }
+
+  if (!admin)
+    return NULL;
+
+  dc = admin->GetDC(&scrollx, &scrolly);
+  if (!dc)
+    return NULL;
+
+  x = event.x + scrollx;
+  y = event.y + scrolly;
+
+  if (tracking)
+    return customCursor ? customCursor : arrow;
+  
+  if (!customCursorOverrides) {
+
+    if (caretSnip && event.Dragging()) {
+      float x, y;
+      GetSnipPositionAndLocation(caretSnip, NULL, &x, &y);
+      c = caretSnip->AdjustCursor(dc, x - scrollx, y - scrolly, x, y, event);
+      if (c)
+	return c;
+    }
+    
+    /* Find snip: */
+    
+    pos = FindPosition(x, y, NULL, &onit, &how_close);
+    if ((how_close > 0  && how_close <= betweenThreshold)
+	|| (how_close < 0  && -how_close <= betweenThreshold))
+      onit = FALSE;
+    
+    if (onit)
+      snip = FindSnip(pos, +1);
+    else
+      snip = NULL;
+    
+    if (snip) {
+      float x, y;
+      GetSnipPositionAndLocation(snip, NULL, &x, &y);
+      c = snip->AdjustCursor(dc, x - scrollx, y - scrolly, x, y, event);
+      if (c)
+	return c;
+    }
+  }
+  
+  if (customCursor)
+    return customCursor;
+
+  pos = FindPosition(x, y, NULL);
+  return FindClickback(pos) ? arrow : iBeam;
+}
+
+void wxMediaEdit::OnEvent(wxMouseEvent &event)
+{
+  float scrollx, scrolly;
+  float x, y;
+  wxSnip *snip;
+  wxDC *dc;
+  Bool onit;
+  Bool sequenced = FALSE;
+  long now;
+
+  if (!admin)
+    return;
+
+  if (!event.Moving())
+    EndStreaks(wxSTREAK_KEY_SEQUENCE);
+
+  if (event.ButtonDown() || caretSnip) {
+    /* First, find clicked-on snip: */
+    x = event.x;
+    y = event.y;
+    
+    dc = admin->GetDC(&scrollx, &scrolly);
+    y += scrolly;
+    x += scrollx;
+
+    if (!dc)
+      return;
+  } else
+    dc = NULL;
+
+  if (event.ButtonDown()) {
+    float how_close;
+
+    now = FindPosition(x, y, NULL, &onit, &how_close);
+    if ((how_close > 0  && how_close <= betweenThreshold)
+	|| (how_close < 0  && -how_close <= betweenThreshold))
+      onit = FALSE;
+
+    if (onit)
+      snip = FindSnip(now, +1);
+    else
+      snip = NULL;
+    sequenced = (PTRNE(snip, caretSnip));
+    if (sequenced)
+      BeginEditSequence();
+    SetCaretOwner(snip);
+  }
+
+  if (caretSnip && (caretSnip->flags & wxSNIP_HANDLES_EVENTS)) {
+    GetSnipPositionAndLocation(caretSnip, NULL, &x, &y);
+    caretSnip->OnEvent(dc, x - scrollx, y - scrolly, x, y, event);
+    if (sequenced)
+      EndEditSequence();
+    return;
+  }
+
+  OnLocalEvent(event);
+
+  if (sequenced)
+    EndEditSequence();
+}
+
+void wxMediaEdit::OnDefaultEvent(wxMouseEvent& event)
+{
+  long now;
+  float scrollx, scrolly;
+  float x, y;
+  Bool ateol;
+  wxClickback *click;
+  wxDC *dc;
+  float how_close;
+
+  if (!admin)
+    return;
+
+  x = event.x;
+  y = event.y;
+  dc = admin->GetDC(&scrollx, &scrolly);
+  y += scrolly;
+  x += scrollx;
+
+  if (!dc)
+    return;
+
+  now = FindPosition(x, y, &ateol, NULL, &how_close);
+  if (how_close > 0  && how_close <= betweenThreshold)
+    now++;
+
+  if (event.ButtonDown()) {
+    tracking = FALSE;
+    if ((click = FindClickback(now))) {
+      if (click->callOnDown) {
+	click->f(this, click->start, click->end, click->data);
+      } else {
+	tracking = TRUE;
+	trackClickback = click;
+	if (admin)
+	  admin->UpdateCursor();
+	SetClickbackHilited(trackClickback, TRUE);
+      }
+    } else {
+      dragstart = now;
+      dragging = TRUE;
+      if (event.ShiftDown()) {
+	if (dragstart > startpos)
+	  dragstart = startpos;
+	else
+	  dragstart = endpos;
+      }
+      if (now < dragstart)
+	SetPositionBiasScroll(-2, now, dragstart, ateol);
+      else
+	SetPositionBiasScroll(2, dragstart, now, ateol);
+    }
+  } else if (event.Dragging()) {
+    now = FindPosition(x, y, &ateol);
+    if (dragging) {
+      if (now < dragstart) {
+	if (now != startpos || dragstart != endpos)
+	  SetPositionBiasScroll(-2, now, dragstart, ateol);
+      } else {
+	if (now != endpos || dragstart != startpos)
+	  SetPositionBiasScroll(2, dragstart, now, ateol);
+      }
+    } else if (tracking) {
+      SetClickbackHilited(trackClickback, now >= trackClickback->start
+			  && now <= trackClickback->end);
+    }
+  } else if (event.ButtonUp()) {
+    if (dragging)
+      dragging = FALSE;
+    else if (tracking) {
+      tracking = FALSE;
+      if (trackClickback->hilited) {
+	SetClickbackHilited(trackClickback, FALSE);
+	trackClickback->f(this, trackClickback->start, 
+			  trackClickback->end, trackClickback->data);
+      }
+      if (admin)
+	admin->UpdateCursor();
+    }
+  } else if (event.Moving()) {
+    dragging = FALSE;
+    if (tracking) {
+      tracking = FALSE;
+      if (admin)
+	admin->UpdateCursor();
+    }
+  }
+}
+
+void wxMediaEdit::OnChar(wxKeyEvent &event)
+{
+  if (!admin)
+    return;
+
+  if (caretSnip && (caretSnip->flags & wxSNIP_HANDLES_EVENTS)) {
+    wxDC *dc;
+    float scrollx, scrolly, x, y;
+    
+    dc = admin->GetDC(&scrollx, &scrolly);
+    GetSnipPositionAndLocation(caretSnip, NULL, &x, &y);
+
+    caretSnip->OnChar(dc, x - scrollx, y - scrolly, x, y, event);
+    return;
+  }
+
+  OnLocalChar(event);
+}
+
+void wxMediaEdit::OnDefaultChar(wxKeyEvent &event)
+{
+  long code;
+
+  if (!admin)
+    return;
+
+  code = event.KeyCode();
+
+  if (code == WXK_RETURN 
+      || code == WXK_TAB
+      || (code >= 32 && code <= 126)) {
+    if (overwriteMode && (startpos == endpos))
+      Insert(code, startpos, startpos + 1);
+    else
+      Insert(code);
+  } else  {
+    switch(code) {
+    case WXK_BACK:
+    case WXK_DELETE:
+      Delete();
+      break;
+    case WXK_RIGHT:
+    case WXK_LEFT:
+    case WXK_UP:
+    case WXK_DOWN:
+    case WXK_HOME:
+    case WXK_END:
+    case WXK_PRIOR:
+    case WXK_NEXT:
+      MovePosition(code, event.ShiftDown());
+      break;
+    }
+  }
+}
+
+void wxMediaEdit::OwnCaret(Bool ownit)
+{
+  if (DoOwnCaret(ownit)) {
+    NeedCaretRefresh();
+    OnFocus(ownit);
+  }
+}
+
+void wxMediaEdit::SizeCacheInvalid(void)
+{
+  if (!graphicMaybeInvalid)
+    graphicMaybeInvalid = TRUE;
+  graphicsInvalid = TRUE;
+  if (maxWidth > 0)
+    flowInvalid = TRUE;
+  snipCacheInvalid = TRUE;
+}
+
+/****************************************************************/
+
+void wxMediaEdit::OnChange(void)
+{
+  /* Do nothing */
+}
+
+Bool wxMediaEdit::OnInsert(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+  return TRUE;
+}
+
+void wxMediaEdit::AfterInsert(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+}
+
+Bool wxMediaEdit::OnDelete(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+  return TRUE;
+}
+
+void wxMediaEdit::AfterDelete(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+}
+
+Bool wxMediaEdit::OnChangeStyle(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+  return TRUE;
+}
+
+void wxMediaEdit::AfterChangeStyle(long WXUNUSED(start), long WXUNUSED(len))
+{
+  /* Do nothing */
+}
+
+
+void wxMediaEdit::AfterSetPosition(void)
+{
+  /* Do nothing */
+}
+
+Bool wxMediaEdit::OnSetSizeConstraint(void)
+{
+  return TRUE;
+}
+
+void wxMediaEdit::AfterSetSizeConstraint(void)
+{
+  /* Do nothing */
+}
+
+/****************************************************************/
+
+void wxMediaEdit::BeginEditSequence(Bool undoable)
+{
+  EndStreaks(wxSTREAK_EXCEPT_DELAYED);
+
+  if (noundomode || !undoable)
+    noundomode++;
+
+  if (!delayRefresh) {
+#if ALLOW_X_STYLE_SELECTION
+    needXCopy = TRUE;
+#endif
+
+    OnEditSequence();
+  }
+  delayRefresh++;
+}
+
+void wxMediaEdit::EndEditSequence(void)
+{
+  if (!delayRefresh) {
+#ifdef wx_x
+    fprintf(stderr, "EndEditSequence without BeginEditSequence\n");
+    return;
+#endif
+  }
+
+  if (!(--delayRefresh)) {
+    EndStreaks();
+    Redraw();
+#if ALLOW_X_STYLE_SELECTION
+    needXCopy = FALSE;
+#endif
+    AfterEditSequence();
+  } else if (delayRefresh < 0)
+    delayRefresh = 0;
+
+  if (noundomode)
+    --noundomode;
+}
+
+Bool wxMediaEdit::RefreshDelayed(void)
+{
+  if (delayRefresh > 0)
+    return 1;
+    
+  if (!admin)
+    return 1;
+  else
+    return admin->DelayRefresh();
+}
+
+void wxMediaEdit::Recalculate(void)
+{
+}
+
+void wxMediaEdit::GetPosition(long *start, long *end)
+{
+  if (start)
+    *start = startpos;
+  if (end)
+    *end = endpos;
+}
+
+long wxMediaEdit::GetStartPosition(void)
+{
+  return startpos;
+}
+
+long wxMediaEdit::GetEndPosition(void)
+{
+  return endpos;
+}
+  
+void wxMediaEdit::SetPosition(long start, long end, Bool ateol, Bool scroll,
+			      int seltype)
+{
+  _SetPosition(FALSE, 0, start, end, ateol, scroll, seltype);
+}
+
+void wxMediaEdit::SetPositionBiasScroll(int bias, long start, long end, 
+					Bool ateol, Bool scroll, int seltype)
+{
+  _SetPosition(FALSE, bias, start, end, ateol, scroll, seltype);
+}
+
+Bool wxMediaEdit::ScrollToPosition(long start, Bool ateol, Bool refresh,
+				   long end, int bias)
+{
+  float topx, botx, topy, boty;
+
+  if (flowLocked)
+    return FALSE;
+
+  if (end < start)
+    end = start;
+
+  if (delayRefresh) {
+    delayedscrollbox = FALSE;
+    delayedscroll = start;
+    delayedscrollend = end;
+    delayedscrollateol = ateol;
+    delayedscrollbias = bias;
+    return FALSE;
+  }
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return FALSE;
+
+  delayedscroll = -1;
+  
+  PositionLocation(start, &topx, &topy, TRUE, ateol, TRUE);
+  PositionLocation(end, &botx, &boty, FALSE, ateol, TRUE);
+
+  return admin->ScrollTo(topx, topy, botx - topx, boty - topy, refresh, bias);
+}
+
+Bool wxMediaEdit::ScrollToPosition(long start, Bool ateol, long end, int bias)
+{
+  return ScrollToPosition(start, ateol, TRUE, end, bias);
+}
+
+void wxMediaEdit::GetVisiblePositionRange(long *start, long *end)
+{
+  float x, y, h, w;
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return;
+
+  admin->GetMaxView(&x, &y, &w, &h);
+  if (start)
+    *start = FindPosition(x, y);
+  if (end)
+    *end = FindPosition(x + w, y + h);
+}
+
+void wxMediaEdit::GetVisibleLineRange(long *start, long *end)
+{  
+  float x, y, h, w;
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return;
+
+  admin->GetMaxView(&x, &y, &w, &h);
+  if (start)
+    *start = FindLine(y);
+  if (end)
+    *end = FindLine(y + h);
+}
+
+void wxMediaEdit::MovePosition(long code, Bool extendSelection,
+					 int kind)
+{
+  long i, start, end, extendstart, extendend;
+  Bool ateol, vcursor, anchor, extend, kas;
+  float h, w, y;
+
+  if (flowLocked)
+    return;
+
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return;
+
+  anchor = anchorStreak;
+  vcursor = vcursorStreak;
+
+  kas = keepAnchorStreak;
+  keepAnchorStreak = anchorStreak;
+
+  EndStreaks(wxSTREAK_EXCEPT_DELAYED);
+
+  extendend = endpos;
+  extendstart = startpos;
+  extend = anchor || extendSelection;
+
+  if (code == WXK_PRIOR) {
+    code = WXK_UP;
+    kind = wxMOVE_PAGE;
+  } else if (code == WXK_NEXT) {
+    code = WXK_DOWN;
+    kind = wxMOVE_PAGE;
+  }
+
+  if (code == WXK_HOME)
+    SetPositionBiasScroll(-1, 0, extend ? extendend : 0);
+  else if (code == WXK_END)
+    SetPositionBiasScroll(1, extend ? extendstart : len, len);
+  else if (code == WXK_LEFT) {
+    if (kind == wxMOVE_WORD) {
+      start = startpos;
+      FindWordbreak(&start, NULL, wxBREAK_FOR_CARET);
+      end = (extend ? extendend : start);
+      SetPositionBiasScroll(-2, start, end);
+    } else if (kind == wxMOVE_LINE) {
+      start = LineStartPosition(PositionLine(startpos, posateol));
+      end = extend ? extendend : start;
+      SetPositionBiasScroll(-2, start, end);
+    } else {
+      if (!extend && startpos == endpos)
+	SetPositionBiasScroll(0, startpos - 1);
+      else if (extend)
+	SetPositionBiasScroll(-2, startpos - 1, extendend);
+      else
+	SetPosition(startpos);
+    }
+  } else if (code == WXK_RIGHT) {
+    if (kind == wxMOVE_WORD) {
+      end = endpos;
+      FindWordbreak(NULL, &end, wxBREAK_FOR_CARET);
+      start = (extend ? extendstart : end);
+      SetPositionBiasScroll(1, start, end);
+    } else if (kind == wxMOVE_LINE) {
+      end = LineEndPosition(PositionLine(endpos, posateol));
+      start = extend ? extendstart : end;
+      SetPositionBiasScroll(2, start, end, TRUE);
+    } else {
+      if (!extend && startpos == endpos)
+	SetPositionBiasScroll(0, startpos + 1, startpos + 1, TRUE);
+      else if (extend)
+	SetPositionBiasScroll(2, extendstart, endpos + 1, TRUE);
+      else
+	SetPosition(endpos, endpos, TRUE);
+    }
+  } else if ((code == WXK_UP) || (code == WXK_DOWN)) {
+    int cline;
+    /* Used when paging: */
+    int scrollFar = 0;
+    Bool specialScroll = (kind == wxMOVE_PAGE);
+
+    if (!vcursor) {
+      PositionLocation(startpos, &startloc, NULL, TRUE, posateol, TRUE);
+      PositionLocation(endpos, &endloc, NULL, TRUE, posateol, TRUE);
+    }
+    if (code == WXK_UP) {
+      cline = PositionLine(startpos, posateol);
+      if (kind == wxMOVE_PAGE) {
+	long top, bottom, diff;
+	GetVisibleLineRange(&top, &bottom);
+	diff = bottom - top;
+	if (!diff) diff = 1;
+	else if (diff > 4) diff = 2;
+	else diff = 1;
+	admin->GetView(NULL, NULL, &w, &h);
+	if (extend && cline < top)
+	  top = cline;
+	y = LineLocation(top + diff, FALSE);
+	scrollFar = LineStartPosition(FindLine(y - h));
+	i = top;
+      } else
+	i = cline - 1;
+      if (i >= 0)
+	start = FindPositionInLine(i, startloc, &ateol);
+      else {
+	start = 0;
+	ateol = FALSE;
+      }
+      if (!extend)
+	end = start;
+      else
+	end = extendend;
+    } else {
+      cline = PositionLine(endpos, posateol);
+      if (kind == wxMOVE_PAGE) {
+	long top, bottom, diff;
+	GetVisibleLineRange(&top, &bottom);
+	diff = bottom - top;
+	if (!diff) diff = 1;
+	else if (diff > 4) diff = 2;
+	else diff = 1;
+	admin->GetView(NULL, NULL, &w, &h);
+	if (extend && cline > bottom)
+	  bottom = cline;
+	y = LineLocation(bottom - diff, TRUE);
+	scrollFar = LineStartPosition(FindLine(y + h));
+	i = bottom;
+      } else
+	i = cline + 1;
+      if (i <= numValidLines - 1)
+	end = FindPositionInLine(i, endloc, &ateol);
+      else
+	end = len;
+      if (!extend)
+	start = end;
+      else
+	start = extendstart;
+    }
+
+    if (specialScroll)
+      BeginEditSequence();
+
+    /* Scroll only if !specialScroll */
+    SetPositionBiasScroll((code == WXK_UP) ? -2 : 2, start, end, ateol, 
+			  !specialScroll);
+    if (specialScroll)
+      /* Special scrolling intructions: */
+      ScrollToPosition((code == WXK_UP) ? scrollFar : start,
+		       FALSE, 
+		       (code == WXK_UP) ? end : scrollFar,
+		       (code == WXK_UP) ? -1 : 1);
+
+    if (specialScroll)
+      EndEditSequence();
+
+    vcursorStreak = TRUE;
+  }
+
+  keepAnchorStreak = kas;
+}
+
+void wxMediaEdit::SetAnchor(Bool on)
+{
+  anchorStreak = on;
+}
+
+Bool wxMediaEdit::GetAnchor(void)
+{
+  return anchorStreak;
+}
+
+void wxMediaEdit::_Insert(wxSnip *isnip, long strlen, char *str, 
+			  long start, long end, Bool scrollOk)
+{
+  long addlen, i, sPos, s, snipStartPos;
+  wxSnip *gsnip, *cSnip;
+  wxTextSnip *snip;
+  wxTabSnip *tabsnip;
+  Bool deleted = FALSE, insertedLine = FALSE, scroll;
+
+  if (writeLocked || userLocked || (!isnip && !strlen))
+    return;
+
+  if (start < 0)
+    return;
+  if (start > len)
+    start = len;
+
+  if (caretStyle)
+    if (start != end || start != startpos)
+      caretStyle = NULL;
+
+  if (end > -1)
+    if (start < end) {
+#if ALLOW_X_STYLE_SELECTION
+      if (!delayRefresh)
+	needXCopy = TRUE;
+#endif	
+      delayRefresh++;
+      Delete(start, end);
+      deleted = TRUE;
+      --delayRefresh;
+#if ALLOW_X_STYLE_SELECTION
+      if (!delayRefresh)
+	needXCopy = FALSE;
+#endif	
+    }
+
+  writeLocked = TRUE;
+
+  if (isnip) {
+    if (!isnip->count)
+      goto give_up;
+
+    addlen = isnip->count;
+
+    if (isnip->IsOwned())
+      goto give_up;
+
+    if (!OnInsert(start, addlen))
+      goto give_up;
+
+    flowLocked = TRUE;
+
+    /* Make sure OnInsert didn't do something bad to the snip: */
+    if (!isnip->count)
+      goto give_up;
+    if (isnip->IsOwned())
+      goto give_up;
+
+
+    if (!isnip->snipclass)
+      wxMessageBox("Inserting a snip without a class."
+		   " Data will be lost if you try to save the file.", 
+		   "Warning");
+
+    if ((isnip->flags & wxSNIP_NEWLINE)&&!(isnip->flags & wxSNIP_HARD_NEWLINE))
+      isnip->flags -= wxSNIP_NEWLINE;
+    
+    if (!len) {
+      /* Special case: ignore the empty snip */
+      snips = lastSnip = isnip;
+      isnip->line = lineRoot = new wxMediaLine;
+      lineRoot->snip = lineRoot->lastSnip = isnip;
+      if (maxWidth > 0)
+	lineRoot->MarkCheckFlow();
+    } else {
+      MakeSnipset(start, start);
+      gsnip = FindSnip(start, +2);
+      
+      if (!gsnip) {
+	AppendSnip(isnip);
+	gsnip = lastLine->lastSnip;
+	if (gsnip && (gsnip->flags & wxSNIP_HARD_NEWLINE)) {
+	  isnip->line = lastLine->Insert(&lineRoot, FALSE);
+	  isnip->line->snip = isnip->line->lastSnip = isnip;
+	  numValidLines++;
+	  insertedLine = TRUE;
+	} else {
+	  isnip->line = lastLine;
+	  if (!lastLine->snip)
+	    lastLine->snip = isnip;
+	  lastLine->lastSnip = isnip;
+	  if (isnip->flags & wxSNIP_HARD_NEWLINE)
+	    insertedLine = TRUE; /* b/c added extra ghost line */
+	}
+      } else {
+	InsertSnip(gsnip, isnip);
+	if (isnip->flags & wxSNIP_HARD_NEWLINE) {
+	  isnip->line = gsnip->line->Insert(&lineRoot, TRUE);
+	  insertedLine = TRUE;
+	  numValidLines++;
+	  if (PTREQ(gsnip->line->snip, gsnip))
+	    isnip->line->snip = isnip;
+	  else
+	    isnip->line->snip = gsnip->line->snip;
+	  isnip->line->lastSnip = isnip;
+	  gsnip->line->snip = gsnip;
+	  
+	  for (cSnip = isnip->line->snip; PTRNE(cSnip, isnip); 
+	       cSnip = cSnip->next)
+	    cSnip->line = isnip->line;
+	  
+	  gsnip->line->CalcLineLength();
+	  gsnip->line->MarkRecalculate();
+	} else {
+	  isnip->line = gsnip->line;
+	  if (PTREQ(isnip->line->snip, gsnip))
+	    isnip->line->snip = isnip;
+	}
+      }
+
+      if (maxWidth > 0) {
+	isnip->line->MarkCheckFlow();
+	if (isnip->line->prev
+	    && !(isnip->line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+	  isnip->line->prev->MarkCheckFlow();
+	if ((isnip->flags & wxSNIP_HARD_NEWLINE) && isnip->line->next)
+	  isnip->line->next->MarkCheckFlow();
+      }
+    }
+
+    isnip->SizeCacheInvalid();
+    isnip->style = styleList->Convert(isnip->style);  
+
+    isnip->line->CalcLineLength();
+    isnip->line->MarkRecalculate();
+    
+    SnipSetAdmin(isnip, snipAdmin);
+  } else {
+    addlen = strlen;
+    
+    if (!OnInsert(start, addlen))
+      goto give_up;
+
+    flowLocked = TRUE;
+
+    if (!len) {
+      snip = InsertTextSnip(start, snips->style);
+      sPos = 0;
+      caretStyle = NULL;
+      lineRoot->snip = lineRoot->lastSnip = snip;
+    } else {
+      if (start)
+	gsnip = FindSnip(start, -1, &sPos);
+      else
+	gsnip = NULL;
+
+      if (!gsnip || caretStyle || !(gsnip->flags & wxSNIP_IS_TEXT)
+	  || (gsnip->count + addlen > MAX_COUNT_FOR_SNIP)) {
+	snip = InsertTextSnip(start, 
+			      caretStyle
+			      ? caretStyle
+			      : (gsnip
+				 ? gsnip->style
+				 : snips->style)); // No style: use forward
+	caretStyle = NULL;
+	sPos = start;
+      } else {
+	snip = (wxTextSnip *)gsnip;
+	if (!(snip->flags & wxSNIP_CAN_APPEND)) {
+	  snip = InsertTextSnip(start, snip->style);
+	  sPos = start;
+	}
+      }
+
+      if (gsnip && gsnip->flags & wxSNIP_HARD_NEWLINE) {
+	wxMediaLine *oldline = gsnip->line, *newline;
+	
+	if (!oldline->next) {
+	  oldline->Insert(&lineRoot, FALSE);
+	  insertedLine = TRUE;
+	  numValidLines++;
+	  
+	  oldline->next->lastSnip = snip;
+	}
+      
+	newline = oldline->next;
+	
+	snip->line = newline;
+	
+	oldline->lastSnip = gsnip;
+	newline->snip = snip;
+	
+	oldline->CalcLineLength();
+	oldline->MarkRecalculate();
+      }
+    }
+
+    s = start - sPos;
+
+    snip->flags |= wxSNIP_CAN_SPLIT;
+    snip->Insert(str, addlen, s);
+    if (snip->flags & wxSNIP_CAN_SPLIT)
+      snip->flags -= wxSNIP_CAN_SPLIT;
+
+    snip->line->CalcLineLength();
+    snip->line->MarkRecalculate();
+
+    if (maxWidth > 0) {
+      snip->line->MarkCheckFlow();
+      if (snip->line->prev 
+	  && !(snip->line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+	snip->line->prev->MarkCheckFlow();
+    }
+
+    snipStartPos = start;
+    str = snip->text + s;
+    for (i = 0; i < addlen; i++) {
+      if (*str == '\r')
+	*str = '\n';
+      if (*str == '\n' || *str == '\t') {
+	Bool newline = (*str == '\n');
+
+	MakeSnipset(i + start, i + start + 1);
+	snip = (wxTextSnip *)FindSnip(i + start, +1);
+
+	if (newline) {
+	  /* Forced return - split the snip */
+	  wxMediaLine *oldLine;
+
+	  snip->flags |= wxSNIP_NEWLINE | wxSNIP_HARD_NEWLINE 
+	    | wxSNIP_INVISIBLE;
+	  snip->flags -= (snip->flags & wxSNIP_CAN_APPEND);
+
+	  if (PTRNE(snip, snip->line->lastSnip)) {
+	    oldLine = snip->line;
+	    snip->line = oldLine->Insert(&lineRoot, TRUE);
+	    insertedLine = TRUE;
+	    numValidLines++;
+	    snip->line->lastSnip = snip;
+	    snip->line->snip = oldLine->snip;
+	    
+	    /* Retarget snips moved to new line: */
+	    for (cSnip = snip->line->snip; PTRNE(cSnip, snip);
+		 cSnip = cSnip->next)
+	      cSnip->line = snip->line;
+
+	    oldLine->snip = snip->next;
+
+	    oldLine->CalcLineLength();
+	    oldLine->MarkRecalculate();
+	    if (maxWidth > 0)
+	      oldLine->MarkCheckFlow();
+
+	    snip->line->CalcLineLength();
+	    snip->line->MarkRecalculate();
+	    if (maxWidth > 0)
+	      snip->line->MarkCheckFlow();
+	  } else if (PTREQ(snip, lastSnip))
+	    insertedLine = TRUE; /* b/c added extra ghost line */
+	} else {
+	  tabsnip = OnNewTabSnip();
+	  if (tabsnip->IsOwned() || tabsnip->count) {
+	    /* Uh-oh. */
+	    tabsnip = new wxTabSnip();
+	  }
+	  tabsnip->style = snip->style;
+	  wxSnip *rsnip = SnipSetAdmin(tabsnip, snipAdmin);
+	  if (rsnip!= tabsnip) {
+	    /* Uh-oh. */
+	    tabsnip = new wxTabSnip();
+	    tabsnip->style = snip->style;
+	    tabsnip->SetAdmin(snipAdmin);
+	  }
+	  
+	  tabsnip->flags |= wxSNIP_CAN_SPLIT;
+	  tabsnip->Insert("\t", 1, 0);
+	  if (tabsnip->flags & wxSNIP_CAN_SPLIT)
+	    tabsnip->flags -= wxSNIP_CAN_SPLIT;
+
+	  SpliceSnip(tabsnip, snip->prev, snip->next);
+	  tabsnip->line = snip->line;
+	  if (PTREQ(snip->line->snip, snip))
+	    tabsnip->line->snip = tabsnip;
+	  if (PTREQ(snip->line->lastSnip, snip))
+	    tabsnip->line->lastSnip = tabsnip;
+	  delete snip;
+	}
+
+	snip = (wxTextSnip *)FindSnip(i + start + 1, +1);
+	snipStartPos = i + start + 1;
+	str = snip->text;
+      } else
+	str++;
+    }
+
+    /* Divide up snip if it's too large: */
+    while (snip->count > MAX_COUNT_FOR_SNIP) {
+      long next = snipStartPos + MAX_COUNT_FOR_SNIP - 10;
+      MakeSnipset(snipStartPos, next);
+      snip = (wxTextSnip *)FindSnip(next, +1);
+      snipStartPos = next;
+    }
+  }
+
+  firstLine = lineRoot->First();
+  lastLine = lineRoot->Last();
+
+  len += addlen;
+  
+  AdjustClickbacks(start, start, addlen, NULL);
+
+  if (!modified)
+    AddUndo(new wxUnmodifyRecord);
+  if (!noundomode) {
+    AddUndo(new wxInsertRecord(start, addlen, 
+			       deleted || typingStreak || delayedStreak
+			       || insertForceStreak
+			       || !modified));
+  }
+
+  if (delayRefresh)
+    delayedStreak = TRUE;
+
+  scroll = (startpos == start);
+
+  if (startpos >= start)
+    startpos += addlen;
+  if (endpos >= start)
+    endpos += addlen;
+
+  extraLine = !!(lastSnip->flags & wxSNIP_NEWLINE);
+
+  writeLocked = FALSE;
+  flowLocked = FALSE;
+
+  if (scroll && scrollOk) {
+    delayRefresh++;
+    ScrollToPosition(startpos);
+    --delayRefresh;
+  }
+
+  changed = TRUE;
+
+  caretStyle = NULL;
+
+  if (insertedLine)
+    NeedRefresh(start);
+  else
+    RefreshByLineDemand();
+
+  if (!modified)
+    SetModified(TRUE);
+  
+  AfterInsert(start, addlen);
+
+  return;
+
+ give_up:
+  writeLocked = FALSE;
+  flowLocked = FALSE;
+  return;
+}
+
+void wxMediaEdit::Insert(char *str, long start, long end, Bool scrollOk)
+{
+  _Insert(NULL, strlen(str), str, start, end, scrollOk);
+}
+
+void wxMediaEdit::Insert(char *str)
+{
+  Insert(str, startpos, endpos);
+}
+
+void wxMediaEdit::Insert(long len, char *str, long start, long end, Bool scrollOk)
+{
+  _Insert(NULL, len, str, start, end, scrollOk);
+}
+
+void wxMediaEdit::Insert(long len, char *str)
+{
+  _Insert(NULL, len, str, startpos, endpos);
+}
+
+void wxMediaEdit::Insert(unsigned char ascii, long start, long end)
+{
+  Bool streak, ifs;
+  unsigned char buffer[2];
+
+  buffer[0] = ascii;
+  buffer[1] = 0;
+  
+  streak = typingStreak;
+  ifs = insertForceStreak;
+
+  EndStreaks();
+
+  insertForceStreak = streak;
+  Insert((char *)buffer, start, end);
+
+  insertForceStreak = ifs;
+  typingStreak = TRUE;
+}
+
+void wxMediaEdit::Insert(unsigned char ascii)
+{
+  Insert(ascii, startpos, endpos);
+}
+
+void wxMediaEdit::Insert(wxSnip *snip, long start, long end, Bool scrollOk)
+{
+  _Insert(snip, 0, NULL, start, end, scrollOk);
+}
+
+void wxMediaEdit::Insert(wxSnip *snip)
+{
+  Insert(snip, startpos, endpos);
+}
+
+void wxMediaEdit::_Delete(long start, long end, Bool withUndo, Bool scrollOk)
+{
+  wxSnip *prev, *next, *startSnip, *endSnip;
+  long dellen;
+  wxSnip *snip;
+  wxDeleteRecord *rec;
+  wxMediaLine *line;
+  Bool deletedLine = FALSE, setCaretStyle = FALSE;
+  Bool updateCursor = FALSE;
+
+  if (writeLocked || userLocked)
+    return;
+
+  if (end == -1) {
+    if (!start)
+      return;
+    end = start;
+    --start;
+    setCaretStyle = TRUE;
+  } else if (start == startpos && end == endpos)
+    setCaretStyle = TRUE;
+
+  if (start >= end)
+    return;
+  if ((start < 0) || (start >= len))
+    return;
+
+  if (end > len)
+    end = len;
+  
+#if ALLOW_X_STYLE_SELECTION
+  if (start <= startpos && end >= endpos)
+    if (!delayRefresh || needXCopy) {
+      needXCopy = FALSE;
+      CopyOutXSelection();
+    }
+#endif
+
+  writeLocked = TRUE;
+
+  if (!OnDelete(start, end - start))
+    goto give_up;
+
+  flowLocked = TRUE;
+
+  MakeSnipset(start, end);
+  
+  startSnip = FindSnip(start, -2);
+  endSnip = FindSnip(end, -1);
+
+  if (noundomode)
+    withUndo = FALSE;
+
+  if (withUndo) {
+    if (!modified)
+      AddUndo(new wxUnmodifyRecord);
+    rec = new wxDeleteRecord(start, end, deletionStreak || delayedStreak
+			     || deleteForceStreak || !modified);
+  } else
+    rec = NULL;
+
+  if (setCaretStyle)
+    caretStyle = startSnip ? startSnip->next->style : snips->style;
+
+  for (snip = endSnip; PTRNE(snip, startSnip); snip = prev) {
+    if (PTREQ(snip, caretSnip)) {
+      caretSnip->OwnCaret(FALSE);
+      caretSnip = NULL;
+      updateCursor = TRUE;
+    }
+
+    if (withUndo)
+      rec->InsertSnip(snip);
+
+    prev = snip->prev;
+
+    if (PTREQ(snip->line->snip, snip)) {
+      if (PTREQ(snip->line->lastSnip, snip)) {
+	snip->line->Delete(&lineRoot);
+	deletedLine = TRUE;
+	numValidLines--;
+      } else
+	snip->line->snip = snip->next;
+    } else if (PTREQ(snip->line->lastSnip, snip)) {
+      if (snip->line->next) {
+	snip->line->lastSnip = snip->line->next->lastSnip;
+	snip->line->next->Delete(&lineRoot);
+	deletedLine = TRUE;
+	numValidLines--;
+      } else {
+	snip->line->lastSnip = prev;
+	if (!snip->line->next && extraLine)
+	  deletedLine = TRUE; /* b/c maybe deleted extra ghost line */
+      }
+    }
+
+    DeleteSnip(snip);
+  }
+
+  if (!snipCount) {
+    MakeOnlySnip();
+    if (caretStyle) {
+      snips->style = caretStyle;
+      caretStyle = NULL;
+    }
+  }
+
+  firstLine = lineRoot->First();
+  lastLine = lineRoot->Last();
+
+  if (startSnip) {
+    if (startSnip->flags & wxSNIP_NEWLINE) {
+      if (startSnip->line->next)
+	line = startSnip->line->next;
+      else {
+	startSnip->line->MarkCheckFlow();
+	line = NULL;
+      }
+    } else
+      line = startSnip->line;
+  } else
+    line = firstLine;
+
+  if (line) {
+    /* Fix line references from possibly moved snips: */
+    next = line->lastSnip->next;
+    for (snip = line->snip; PTRNE(snip, next); snip = snip->next)
+      snip->line = line;
+    
+    line->CalcLineLength();
+    line->MarkRecalculate();
+
+    if (maxWidth >= 0) {
+      line->MarkCheckFlow();
+      if (line->prev && !(line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+	line->prev->MarkCheckFlow();
+    }
+  }
+
+  AdjustClickbacks(start, end, start - end, rec);
+
+  if (withUndo) {
+    AddUndo(rec);
+    if (delayRefresh)
+      delayedStreak = TRUE;
+  }
+
+  dellen = end - start;
+  
+  len -= dellen;
+
+  CheckMergeSnips(start);
+
+  flowLocked = FALSE;
+  writeLocked = FALSE;
+
+  if ((startpos >= start) && (startpos <= end))
+    startpos = start;
+  else if (startpos > end)
+    startpos -= dellen;
+
+  if ((endpos >= start) && (endpos <= end))
+    endpos = start;
+  else if (endpos > end)
+    endpos -= dellen;
+
+  extraLine = !!(lastSnip->flags & wxSNIP_NEWLINE);
+
+  if (scrollOk && startpos == start) {
+    delayRefresh++;
+    ScrollToPosition(startpos);
+    --delayRefresh;
+  }
+
+  changed = TRUE;
+
+  if (!setCaretStyle)
+    caretStyle = NULL;
+
+  if (start == len) {
+    /* force recheck extra line state: */
+    graphicMaybeInvalid = TRUE;
+    graphicMaybeInvalidForce = TRUE;
+  }
+
+  if (deletedLine)
+    NeedRefresh(start);
+  else
+    RefreshByLineDemand();
+
+  if (!modified)
+    SetModified(TRUE);
+
+  AfterDelete(start, dellen);
+
+  if (updateCursor)
+    if (admin)
+      admin->UpdateCursor();
+
+  return;
+
+ give_up:
+  writeLocked = FALSE;
+  flowLocked = FALSE;
+
+  return;
+}
+
+void wxMediaEdit::Delete(long start, long end, Bool scrollOk)
+{
+  _Delete(start, end, TRUE, scrollOk);
+}
+
+void wxMediaEdit::Delete()
+{
+  Bool dstreak, streak = (startpos == endpos), dfs;
+
+  dstreak = deletionStreak;
+  dfs = deleteForceStreak;
+
+  EndStreaks();
+  deleteForceStreak = dstreak;
+  Delete(startpos, (endpos == startpos) ? -1 : endpos);
+
+  deleteForceStreak = dfs;
+  deletionStreak = streak;
+}
+
+void wxMediaEdit::Erase(void)
+{
+  Delete(0, len);
+}
+
+void wxMediaEdit::Clear()
+{
+  Delete(startpos, endpos);
+}
+
+void wxMediaEdit::Cut(Bool extend, long time, long start, long end)
+{
+  if (start == -1)
+    start = startpos;
+  if (end == -1)
+    end = endpos;
+  if (start < 0)
+    start = 0;
+  if (end > len)
+    end = len;
+  if (start >= end)
+    return;
+  Copy(extend, time, start, end);
+  Delete(start, end);
+}
+
+void wxMediaEdit::Cut(Bool extend, long time)
+{
+  Cut(extend, time, -1);
+}
+
+void wxMediaEdit::DoCopy(long startp, long endp, long time, Bool extend)
+{
+  wxSnip *start, *end;
+  wxSnip *asnip, *snip;
+  wxStyleList *sl;
+
+  if (startp < 0)
+    startp = 0;
+  if (endp > len)
+    endp = len;
+  if (endp <= startp)
+    return;
+
+  MakeSnipset(startp, endp);
+  
+  sl = (extend && wxmb_copyStyleList) ? wxmb_copyStyleList : styleList;
+
+  wxmb_commonCopyRegionData = GetRegionData(startp, endp);
+
+  start = FindSnip(startp, +1);
+  end = FindSnip(endp, +2);
+
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  for (snip = start; PTRNE(snip, end); snip = snip->next) {
+    asnip = snip->Copy();
+    SnipSetAdmin(asnip, NULL);
+    asnip->style = sl->Convert(asnip->style);  
+    wxmb_commonCopyBuffer->Append(asnip);
+    wxmb_commonCopyBuffer2->Append(GetSnipData(snip));
+  }
+
+  writeLocked = wl;
+  flowLocked = fl;
+
+  InstallCopyBuffer(time, sl);
+}
+
+void wxMediaEdit::Copy(Bool extend, long time, long startp, long endp)
+{
+  if (startp == -1)
+    startp = startpos;
+  if (endp == -1)
+    endp = endpos;
+  if (startp < 0)
+    startp = 0;
+  if (endp > len)
+    endp = len;
+  if (startp >= endp)
+    return;
+
+  BeginCopyBuffer();
+
+  if (!extend)
+    FreeOldCopies(); 
+  
+  DoCopy(startp, endp, time, extend);
+
+  EndCopyBuffer();
+}
+
+void wxMediaEdit::Copy(Bool extend, long time)
+{
+  Copy(extend, time, -1);
+}
+
+void wxMediaEdit::DoPaste(long start, long time)
+{
+  long delta;
+
+  readInsert = readInsertStart = start;
+
+  delta = len;
+
+  DoBufferPaste(time, FALSE);
+
+  delta = len - delta;
+
+  prevPasteStart = start;
+  prevPasteEnd = start + delta;
+}
+
+void wxMediaEdit::Paste(long time, long start, long end)
+{
+  if (end == -1)
+    end = (start == -1) ? endpos : start;
+  if (start == -1)
+    start = endpos;
+  if (start < 0)
+    start = 0;
+  if (end > len)
+    end = len;
+  if (start > end)
+    return;
+
+  BeginEditSequence();
+
+  if (start < end)
+    Delete(start, end);
+
+  DoPaste(start, time);
+
+  int savePrevPaste = prevPasteStart;
+
+  EndEditSequence();
+
+  prevPasteStart = savePrevPaste;
+}
+
+void wxMediaEdit::InsertPasteSnip(wxSnip *snip, wxBufferData *data)
+{
+  int addpos = snip->count;
+
+  Insert(snip, readInsert);
+  if (data) {
+    wxSnip *snip = FindSnip(readInsert, +1);
+    SetSnipData(snip, data);
+  }
+  readInsert += addpos;
+}
+
+void wxMediaEdit::PasteRegionData(wxBufferData *data)
+{
+  SetRegionData(readInsertStart, readInsert, data);
+}
+
+void wxMediaEdit::InsertPasteString(char *str)
+{
+#ifdef wx_msw
+  /* Change cr/lf to just lf: */
+  int i, offset = 0;
+  for (i = 0; str[i]; i++)
+    if (str[i] == '\r' && str[i + 1] == '\n') {
+      str[i + offset] = '\n';
+      i++;
+      --offset;
+    } else if (offset)
+      str[i + offset] = str[i];
+  str[i + offset] = 0;
+#endif
+
+  Insert(str, readInsert);
+  readInsert += strlen(str);
+}
+
+void wxMediaEdit::Paste(long time)
+{
+  Paste(time, startpos, endpos);
+}
+
+void wxMediaEdit::PasteNext(void)
+{
+  long start, end, delta;
+
+  if (prevPasteStart < 0)
+    return;
+
+  start = prevPasteStart;
+  end = prevPasteEnd;
+
+  CopyRingNext();
+
+  BeginEditSequence();
+
+  Delete(start, end);
+
+  readInsert = readInsertStart = start;
+
+  delta = len;
+
+  DoBufferPaste(0, TRUE);
+
+  EndEditSequence();
+
+  delta = len - delta;
+
+  prevPasteStart = start;
+  prevPasteEnd = start + delta;
+}
+
+void wxMediaEdit::Kill(long time, long start, long end)
+{
+  int streak;
+  char *text;
+
+  if ((start < 0) != (end < 0))
+    return;
+
+  streak = killStreak;
+
+  BeginEditSequence();
+  if (start < 0) {
+    MovePosition(WXK_RIGHT, TRUE, wxMOVE_LINE);
+    if (startpos == endpos)
+      SetPosition(startpos, startpos + 1);
+    else {
+      long i;
+      
+      text = GetText(startpos, endpos);
+      for (i = endpos - startpos; i--; )
+	if (!isspace(text[i]))
+	  break;
+      
+      if (i < 0) {
+	/* Line has all spaces: move one more */
+	SetPosition(startpos, endpos + 1);
+      }
+      
+      delete[] text;
+    }
+    start = startpos;
+    end = endpos;
+  }
+  Cut(streak, time, start, end);
+  EndEditSequence();
+
+  killStreak = TRUE;
+}
+
+void wxMediaEdit::Kill(long time)
+{
+  Kill(time, -1, -1);
+}
+
+void wxMediaEdit::SelectAll(void)
+{
+  SetPosition(0, len);
+}
+
+
+void wxMediaEdit::SplitSnip(long pos)
+{
+  if (flowLocked)
+    return;
+
+  if (pos <= 0)
+    return;
+  if (pos >= len)
+    return;
+
+  Bool wl = writeLocked;
+
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+  MakeSnipset(pos, pos);
+  writeLocked = wl;
+  flowLocked = FALSE;
+}
+
+/****************************************************************/
+
+char *wxMediaEdit::GetFlattenedText(long *got)
+{
+  return GetText(-1, -1, TRUE, FALSE, got);
+}
+
+char *wxMediaEdit::GetText(long start, long end, Bool flatt, Bool forceCR, long *got)
+{
+  wxSnip *snip;
+  long count, sPos, p, num, offset, total;
+  long alloc;
+  char *s, *t, *old;
+
+  if (readLocked) {
+    if (got)
+      *got = 0;
+    return "";
+  }
+
+  if (start < 0)
+    start = 0;
+  if (end < 0)
+    end = len;
+
+  if (start > len)
+    start = len;
+  if (end < start)
+    end = start;
+
+  count = end - start;
+
+  if (!flatt) {
+    s = new char[count + 1];
+    s[count] = 0;
+    alloc = count + 1;
+  } else {
+    alloc = 2 * count;
+    if (!alloc)
+      alloc = 2;
+    s = new char[alloc];
+    s[0] = 0;
+  }
+
+  if (!count) {
+    if (got)
+      *got = 0;
+    return s;
+  }
+
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  snip = FindSnip(start, +1, &sPos);
+  offset = start - sPos;
+  num = ((snip->count - offset <= count) ? snip->count - offset : count);
+  if (!flatt) {
+    snip->GetText(s, offset, num);
+    p = num;
+  } else {
+    int add_newline;
+
+    t = snip->GetText(offset, num, TRUE);
+    p = strlen(t);
+    if (forceCR && (snip->flags & wxSNIP_NEWLINE) 
+	  && !(snip->flags & wxSNIP_HARD_NEWLINE)) {
+      p++;
+      add_newline = 1;
+    } else
+      add_newline = 0;
+    if (p >= alloc) {
+      alloc = 2 * p;
+      delete[] s;
+      s = new char[alloc];
+    }
+    memcpy(s, t, p - add_newline);
+    if (add_newline)
+      s[p - 1] = '\n';
+    delete[] t;
+  }
+  total = num;
+  snip = snip->next;
+  while (snip && (count > total)) {
+    num = ((total + snip->count <= count) ? snip->count : count - total);
+    if (!flatt) {
+      snip->GetText(s + p, 0, num);
+      p += num;
+    } else {
+      int add_newline;
+
+      t = snip->GetText(0, num, TRUE);
+      offset = strlen(t);
+
+      if (forceCR && (snip->flags & wxSNIP_NEWLINE) 
+	  && !(snip->flags & wxSNIP_HARD_NEWLINE)) {
+	offset++;
+	add_newline = 1;
+      } else
+	add_newline = 0;
+
+      if (p + offset >= alloc) {
+	alloc = 2 * (p + offset);
+	old = s;
+	s = new char[alloc];
+	memcpy(s, old, p);
+	delete[] old;
+      }
+
+      memcpy(s + p, t, offset);
+      if (add_newline)
+	s[p + offset - 1] = '\n';
+      p += offset;
+
+      delete[] t;
+    }
+    total += num;
+    snip = snip->next;
+  }
+
+  writeLocked = wl;
+  flowLocked = fl;
+
+  if (flatt)
+    s[p] = 0;
+
+  if (got)
+    *got = p;
+
+  return s;
+}
+
+unsigned char wxMediaEdit::GetCharacter(long start)
+{
+  wxSnip *snip;
+  long sPos;
+  unsigned char buffer[2];
+
+  if (readLocked)
+    return 0;
+
+  if (start < 0)
+    start = 0;
+  else if (start >= len)
+    return 0;
+
+  snip = FindSnip(start, +1, &sPos);
+  snip->GetText((char *)buffer, start - sPos, 1);
+
+  return buffer[0];
+}
+
+/****************************************************************/
+
+void wxMediaEdit::SetClickback(long start, long end, 
+			       wxClickbackFunc f, void *d,
+			       wxStyleDelta *delta,
+			       Bool callOnDown)
+{
+  wxClickback *click;
+
+  click = new wxClickback;
+  click->start = start;
+  click->end = end;
+  click->f = f;
+  click->data = d;
+  click->callOnDown = callOnDown;
+  WXGC_IGNORE(click->data);
+
+  click->delta = new wxStyleDelta;
+  if (delta)
+    memcpy(click->delta, delta, sizeof(wxStyleDelta));
+
+  SetClickback(click);
+} 
+
+void wxMediaEdit::SetClickback(wxClickback *click)
+{
+  clickbacks->Append(click);
+}
+
+void wxMediaEdit::RemoveClickback(long start, long end)
+{
+  wxNode *node, *next;
+  wxClickback *click;
+
+  for (node = clickbacks->First(); node; node = next) {
+    next = node->Next();
+    click = (wxClickback *)node->Data();
+    if (click->start == start && click->end == end) {
+      delete click;
+      clickbacks->DeleteNode(node);
+    }
+  }
+}
+
+/****************************************************************/
+
+void wxMediaEdit::FlashOn(long start, long end, Bool ateol, Bool scroll, 
+			  long timeout)
+{
+  _SetPosition(TRUE, 0, start, end, ateol, scroll, wxDEFAULT_SELECT);
+  if (timeout > 0) {
+    flashautoreset = TRUE;
+    if (flashTimer) {
+      flashTimer->Stop();
+      delete flashTimer;
+    }
+    flashTimer = new wxMediaFlashTimer();
+    flashTimer->media = this;
+    WXGC_IGNORE(flashTimer->media);
+    flashTimer->Start(timeout);
+  }
+  flashscroll = scroll;
+}
+
+void wxMediaEdit::FlashOff(void)
+{
+  if (!flash)
+    return;
+  flashautoreset = TRUE;
+  flashdirectoff = TRUE;
+  _SetPosition(FALSE, 0, startpos, endpos, posateol, flashscroll, wxDEFAULT_SELECT);
+}
+
+/****************************************************************/
+
+void StandardWordbreak(wxMediaEdit *win, long *startp, long *endp, 
+		       int reason, void *)
+{
+  long pstart, start, lstart, tstart, end, lend, tend;
+  unsigned char *text;
+  char *map;
+  wxMediaWordbreakMap *wordBreakMap;
+
+  wordBreakMap = win->GetWordbreakMap();
+
+  map = wordBreakMap ? wordBreakMap->map : wxTheMediaWordbreakMap.map;
+
+#define nonbreak(x) (map[x] & reason)
+  /* Try looking at only MAX_DIST_TRY chars. If that fails, then
+     look until a newline. */
+#define MAX_DIST_TRY 30
+
+  if (startp) {
+    pstart = start = *startp;
+
+    lstart = win->FindNewline(-1, start);
+    if (lstart < 0)
+      lstart = 0;
+    else if (reason == wxBREAK_FOR_CARET) {
+      lstart = win->FindNewline(-1, lstart - 1);
+      if (lstart < 0)
+	lstart = 0;
+    }
+    lend = start + 1;
+
+    if (start - lstart > MAX_DIST_TRY)
+      tstart = start - MAX_DIST_TRY;
+    else
+      tstart = lstart;
+
+    text = (unsigned char *)win->GetText(tstart, lend);
+    
+    start -= tstart;
+    pstart -= tstart;
+
+  try_start_again:
+
+    if (start && nonbreak(text[start]))
+      --start;
+    if (reason != wxBREAK_FOR_SELECTION) {
+      while (start && !nonbreak(text[start]))
+	--start;
+    }
+    while (start && nonbreak(text[start]))
+      --start;
+    if ((start < pstart) && !nonbreak(text[start]))
+      start++;
+
+    if (!start && (tstart != lstart)) {
+      start += (tstart - lstart);
+      pstart += (tstart - lstart);
+      delete[] text;
+      text = (unsigned char *)win->GetText(lstart, lend);
+      tstart = lstart;
+      goto try_start_again;
+    }
+
+    *startp = start + tstart;
+
+    delete[] text;
+  }
+
+  if (endp) {
+    end = *endp;
+
+    lstart = end;
+    lend = win->FindNewline(1, end);
+    if (lend < 0)
+      lend = win->LastPosition();
+    else if (reason == wxBREAK_FOR_CARET) {
+      lend = win->FindNewline(1, lend + 1);
+      if (lend < 0)
+	lend = win->LastPosition();
+    }
+
+    if (lend - end > MAX_DIST_TRY)
+      tend = end + MAX_DIST_TRY;
+    else
+      tend = lend;
+
+    text = (unsigned char *)win->GetText(lstart, tend);
+    
+    end -= lstart;
+    lend -= lstart;
+
+    while ((end < lend) && !nonbreak(text[end]))
+      end++;
+  try_end_again:
+    while ((end < lend) && nonbreak(text[end]))
+      end++;
+
+    if ((end == lend) && (lend != tend)) {
+      delete[] text;
+      text = (unsigned char *)win->GetText(lstart, lend);
+      tend = lend;
+      goto try_end_again;
+    }
+
+    *endp = end + lstart;
+
+    delete[] text;
+  }
+}
+
+/****************************************************************/
+
+void wxMediaEdit::SetWordbreakFunc(wxWordbreakFunc f, void *data)
+{
+  wordBreak = f;
+  wordBreakData = data;
+  WXGC_IGNORE(wordBreakData);
+}
+
+void wxMediaEdit::FindWordbreak(long *start, long *end, int reason)
+{
+  long oldstart, oldend;
+
+  if (readLocked)
+    return;
+
+  oldstart = start ? *start : 0;
+  oldend = end ? *end : 0;
+
+  wordBreak(this, start, end, reason, wordBreakData);
+
+  if (start && *start > oldstart)
+    *start = oldstart;
+  if (end && *end < oldend)
+    *end = oldend;
+}
+
+wxMediaWordbreakMap *wxMediaEdit::GetWordbreakMap(void)
+{
+  return wordBreakMap;
+}
+
+void wxMediaEdit::SetWordbreakMap(wxMediaWordbreakMap *map)
+{
+  if (wordBreakMap) {
+    wordBreakMap->AdjustUsage(FALSE);
+#if !WXGARBAGE_COLLECTION_ON
+    if (!wordBreakMap->IsUsed())
+      delete wordBreakMap;
+#endif
+  }
+
+  wordBreakMap = map;
+
+  if (!map)
+    return;
+
+  map->AdjustUsage(TRUE);
+}
+
+/****************************************************************/
+
+float wxMediaEdit::GetMaxWidth()
+{
+  if (maxWidth <= 0)
+    return 0.0;
+  else
+    return maxWidth + wrapBitmapWidth;
+}
+
+float wxMediaEdit::GetMinWidth()
+{
+  return minWidth;
+}
+
+void wxMediaEdit::SetMaxWidth(float w)
+{
+  if (flowLocked)
+    return;
+
+  if (wrapBitmapWidth && (w > 0)) {
+    w -= wrapBitmapWidth;
+    if (w <= 0.0)
+      w = CURSOR_WIDTH + 1;
+  }
+
+  if ((w == maxWidth) || ((w <= 0) && (maxWidth <= 0)))
+    return;
+
+  if (!OnSetSizeConstraint())
+    return;
+
+  if (w > 0 && w < (CURSOR_WIDTH + 1))
+    w = CURSOR_WIDTH + 1;
+  maxWidth = w;
+  flowInvalid = TRUE;
+  if (!graphicMaybeInvalid)
+    graphicMaybeInvalid = TRUE;
+  NeedRefresh(-1, -1);
+
+  AfterSetSizeConstraint();
+}
+
+void wxMediaEdit::SetMinWidth(float w)
+{
+  if (flowLocked)
+    return;
+
+  if (w == minWidth || ((w <= 0) && (minWidth <= 0)))
+    return;
+
+  if (!OnSetSizeConstraint())
+    return;
+
+  graphicMaybeInvalid = TRUE;
+  graphicMaybeInvalidForce = TRUE;
+  minWidth = w;
+  NeedRefresh(-1,-1);
+
+  AfterSetSizeConstraint();
+}
+
+void wxMediaEdit::SetMinHeight(float h)
+{
+  if (flowLocked)
+    return;
+
+  if (h == minHeight || ((h <= 0) && (minHeight <= 0)))
+    return;
+
+  if (!OnSetSizeConstraint())
+    return;
+
+  graphicMaybeInvalid = TRUE;
+  graphicMaybeInvalidForce = TRUE;
+  minHeight = h;
+  NeedRefresh(-1,-1);
+
+  AfterSetSizeConstraint();
+}
+
+void wxMediaEdit::SetMaxHeight(float h)
+{
+  if (flowLocked)
+    return;
+
+  if (h == maxHeight || ((h <= 0) && (maxHeight <= 0)))
+    return;
+
+  if (!OnSetSizeConstraint())
+    return;
+
+  graphicMaybeInvalid = TRUE;
+  graphicMaybeInvalidForce = TRUE;
+  maxHeight = h;
+  NeedRefresh(-1,-1);
+
+  AfterSetSizeConstraint();
+}
+
+float wxMediaEdit::GetMinHeight()
+{
+  return minHeight;
+}
+
+float wxMediaEdit::GetMaxHeight()
+{
+  return maxHeight;
+}
+
+/****************************************************************/
+
+Bool wxMediaEdit::LoadFile(char *file, int format, Bool showErrors)
+{
+  if (writeLocked)
+    return FALSE;
+
+  if (!file || !*file) {
+    if ((file && !*file) || !filename || tempFilename) {
+      char *path;
+      
+      if (filename) {
+	path = PathOnly(filename);
+	if (path)
+	  path = copystring(path);
+      } else
+	path = NULL;
+      
+      file = GetFile(path);
+      
+      if (path)
+	delete[] path;
+    } else
+      file = filename;
+  }
+
+  if (!file)
+    return FALSE;
+
+  if (!OnLoadFile(file, format))
+    return FALSE;
+
+  if (::DirExists(file)) {
+    if (showErrors)
+      wxMessageBox("Can't load a directory.", "Error");
+    return FALSE;
+  }
+
+  FILE *f = fopen(wxmeExpandFilename(file), "rb");
+  
+  if (!f) {
+    if (showErrors)
+      wxMessageBox("Couldn't open the file.", "Error");
+    return FALSE;
+  }
+
+  wxBeginBusyCursor();
+
+  BeginEditSequence();
+
+  Erase();
+	
+  if (PTRNE(file, filename))
+    SetFilename(file, FALSE);
+
+  if (format == wxMEDIA_FF_SAME)
+    format = fileFormat;
+
+  Bool fileerr = !InsertFile(f, file, format, loadoverwritesstyles, showErrors);
+
+  fileFormat = format;
+
+  SetPosition(0, 0);
+
+  EndEditSequence();
+
+  ClearUndos();
+
+  wxEndBusyCursor();
+
+  SetModified(fileerr);
+
+  AfterLoadFile(!fileerr);
+
+  return !fileerr;
+}
+
+Bool wxMediaEdit::InsertFile(char *file, int format, Bool showErrors)
+{
+  if (writeLocked)
+    return FALSE;
+
+  FILE *f = fopen(wxmeExpandFilename(file), "rb");
+  
+  if (!f)
+    return FALSE;
+
+  return InsertFile(f, file, format, FALSE, showErrors);
+}
+
+Bool wxMediaEdit::InsertFile(FILE *f, char *WXUNUSED(file), int& format, Bool clearStyles, Bool showErrors)
+{
+  long n;
+  const int BUF_SIZE = 1000;
+  char buffer[BUF_SIZE];
+
+  if (format == wxMEDIA_FF_GUESS) {
+    n = fread((char *)buffer, 1, MRED_START_STR_LEN, f);
+    buffer[MRED_START_STR_LEN] = 0;
+    if ((n != MRED_START_STR_LEN) || strcmp(buffer, MRED_START_STR))
+      format = wxMEDIA_FF_TEXT;
+    else
+      format = wxMEDIA_FF_STD;
+    fseek(f, 0, 0);
+  }
+
+#ifdef READ_TEXT_WITH_TEXT_FILE_MODE
+  if (format == wxMEDIA_FF_TEXT || format == wxMEDIA_FF_TEXT_FORCE_CR) {
+    if (fclose(f)) {
+      if (showErrors)
+	wxMessageBox("There was an error closing the file.", "Warning");
+    }
+    f = fopen(wxmeExpandFilename(file), "r");
+    if (!f) {
+      if (showErrors)
+	wxMessageBox("Couldn't open the file.", "Error");
+      return FALSE;
+    }
+  }
+#endif
+
+  BeginEditSequence();
+
+  Bool fileerr = FALSE;
+
+  if (format == wxMEDIA_FF_STD) {
+    n = fread((char *)buffer, 1, MRED_START_STR_LEN, f);
+    buffer[MRED_START_STR_LEN] = 0;
+    if ((n != MRED_START_STR_LEN) || strcmp(buffer, MRED_START_STR)){
+      if (showErrors)
+	wxMessageBox("This is not a MrEd file.", "Error");
+      fseek(f, 0, 0);
+      format = wxMEDIA_FF_TEXT;
+    } else {
+      fread((char *)wxme_current_read_format, 1, MRED_FORMAT_STR_LEN, f);
+      fread((char *)wxme_current_read_version, 1, MRED_VERSION_STR_LEN, f);
+      
+      if (wxmeCheckFormatAndVersion()) {
+	wxMediaStreamInFileBase b(f);
+	wxMediaStreamIn mf(b);
+
+	if (wxReadMediaGlobalHeader(mf)) {
+	  if (mf.Ok())
+	    fileerr = !ReadFromFile(mf, clearStyles);
+	  else
+	    fileerr = TRUE;
+	} else
+	  fileerr = TRUE;
+	fileerr = !wxReadMediaGlobalFooter(mf) || fileerr;
+
+	/* If STD_STYLE wasn't loaded, re-create it: */
+	styleList->NewNamedStyle(STD_STYLE, NULL);
+	
+	fileerr = fileerr || !mf.Ok();
+      } else
+	fileerr = TRUE;
+    }
+  }
+
+  if (format == wxMEDIA_FF_TEXT || format == wxMEDIA_FF_TEXT_FORCE_CR) {
+    int savecr = 0;
+    while (!ferror(f) && !feof(f)) {
+      buffer[0] = '\r';
+      n = fread((char *)buffer + savecr, 1, BUF_SIZE - savecr, f) + savecr;
+#ifndef READ_TEXT_WITH_TEXT_FILE_MODE
+      if ((n > 1) && (buffer[n - 1] == '\r')) {
+	savecr = 1;
+	--n;
+      } else
+#endif
+	savecr = 0;
+#ifndef READ_TEXT_WITH_TEXT_FILE_MODE
+      {
+	int i;
+	for (i = 0; i < n - 1; i++) {
+	  if ((buffer[i] == '\r') && (buffer[i + 1] == '\n')) {
+	    memcpy(buffer + i + 1, buffer + i + 2, n - i - 2);
+	    --n;
+	  }
+	}
+      }
+#endif
+      Insert(n, (char *)buffer);
+    }
+    if (savecr)
+      Insert(1, "\r");
+  } 
+
+  fileerr = fileerr || ferror(f);
+
+  if (fclose(f) && showErrors)
+    wxMessageBox("There was an error closing the file.", "Warning");
+
+  if (fileerr && showErrors)
+    wxMessageBox("There was an error loading the file.", "Error");
+
+  EndEditSequence();
+
+  return !fileerr;
+}
+
+Bool wxMediaEdit::SaveFile(char *file, int format, Bool showErrors)
+{
+  if (readLocked)
+    return FALSE;
+
+  Bool no_set_filename;
+
+  if (!file || !*file) {
+    if ((file && !*file) || !filename || tempFilename) {
+      char *path, *pfile;
+      
+      if (filename) {
+	path = PathOnly(filename);
+	if (path && *path)
+	  path = copystring(path);
+	else
+	  path = NULL;
+	pfile = copystring(FileNameFromPath(filename));
+      } else
+	path = pfile = NULL;
+      
+      file = PutFile(path, pfile);
+      
+      if (path) {
+	delete[] path;
+	delete[] pfile;
+      }
+    } else
+      file = filename;
+  }
+
+  if (!file)
+    return FALSE;
+
+  if (!OnSaveFile(file, format))
+    return FALSE;
+
+  no_set_filename = (format == wxMEDIA_FF_COPY);
+
+  if ((format == wxMEDIA_FF_SAME) || (format == wxMEDIA_FF_GUESS)
+      || (format == wxMEDIA_FF_COPY))
+    format = fileFormat;
+
+#ifdef wx_mac
+  int is_binary = !((format == wxMEDIA_FF_TEXT) 
+		    || (format == wxMEDIA_FF_TEXT_FORCE_CR));
+#endif
+
+  /* Always open in binary mode, because flattened text
+     gets cr/lf as appropriate */
+  FILE *f = fopen(wxmeExpandFilename(file), "wb");
+
+  if (!f) {
+    if (showErrors)
+      wxMessageBox("Couldn't write the file.", "Error");
+    AfterSaveFile(FALSE);
+    return FALSE;
+  }
+
+  wxBeginBusyCursor();
+
+#ifdef wx_mac
+  wxMediaSetFileCreatorType(file, is_binary);
+#endif
+
+  Bool fileerr = FALSE;
+
+  if (format == wxMEDIA_FF_TEXT || format == wxMEDIA_FF_TEXT_FORCE_CR) {
+    char *s = GetText(-1, -1, TRUE, format == wxMEDIA_FF_TEXT_FORCE_CR);
+    fwrite(s, 1, strlen(s), f);
+    fileerr = ferror(f);
+    if (fclose(f)) {
+      if (showErrors)
+	wxMessageBox("There was an error closing the file.", "Error");
+      fileerr = TRUE;
+    }
+    delete[] s;
+  } else {
+    fwrite(MRED_START_STR, 1, MRED_START_STR_LEN, f);
+    fwrite(MRED_FORMAT_STR, 1, MRED_FORMAT_STR_LEN, f);
+    fwrite(MRED_VERSION_STR, 1, MRED_VERSION_STR_LEN, f);    
+
+    wxMediaStreamOutFileBase b(f);
+    wxMediaStreamOut mf(b);
+
+    wxWriteMediaGlobalHeader(mf);
+    if (mf.Ok())
+      fileerr = !WriteToFile(mf);
+    wxWriteMediaGlobalFooter(mf);
+
+    fileerr = fileerr || !mf.Ok();
+
+    if (fclose(f)) {
+      if (showErrors)
+	wxMessageBox("There was an error closing the file.", "Error");
+      fileerr = TRUE;
+    }
+  }
+
+  if (fileerr && showErrors)
+    wxMessageBox("There was an error writing the file.", "Error");
+
+  if (!no_set_filename && PTRNE(file, filename))
+    SetFilename(file, FALSE);
+  fileFormat = format;
+
+  wxEndBusyCursor();
+
+  if (!no_set_filename)
+    SetModified(fileerr);
+
+  AfterSaveFile(!fileerr);
+
+  return !fileerr;
+}
+
+Bool wxMediaEdit::ReadFromFile(wxMediaStreamIn &f, long start, Bool overwritestyle)
+{
+  if (writeLocked)
+    return FALSE;
+
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File reading has not been initialized for this stream.", "Error");
+    return FALSE;
+  }
+
+  if (start < 0)
+    start = startpos;
+
+  readInsert = start;
+
+  return ReadSnipsFromFile(f, overwritestyle);
+}
+
+Bool wxMediaEdit::ReadFromFile(wxMediaStreamIn &f, Bool owrs)
+{
+  return ReadFromFile(f, -1, owrs);
+}
+
+
+Bool wxMediaEdit::ReadInsert(wxSnip *snip)
+{
+  int addpos = snip->count;
+
+  Insert(snip, readInsert);
+  readInsert += addpos;
+
+  return TRUE;
+}
+
+Bool wxMediaEdit::WriteToFile(wxMediaStreamOut &f, long start, long end)
+{
+  wxSnip *startSnip, *endSnip;
+
+  if (readLocked)
+    return FALSE;
+
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File writing has not been initialized for this stream.", "Error");
+    return FALSE;
+  }
+
+  if (start < 0)
+    start = 0;
+  if (end < 0)
+    end = len;
+    
+  startSnip = FindSnip(start, +1);
+  endSnip = FindSnip(end, +2);
+
+  if (!DoWriteHeadersFooters(f, TRUE))
+    return FALSE;
+
+  wxmbWriteSnipsToFile(f, styleList, NULL, startSnip, endSnip, NULL, this);
+  
+  if (!DoWriteHeadersFooters(f, FALSE))
+    return FALSE;
+
+  return TRUE;
+}
+
+Bool wxMediaEdit::WriteToFile(wxMediaStreamOut &f)
+{
+  return WriteToFile(f, -1);
+}
+
+int wxMediaEdit::GetFileFormat(void)
+{
+  return fileFormat;
+}
+
+void wxMediaEdit::SetFileFormat(int format)
+{
+  if (format == wxMEDIA_FF_STD
+      || format == wxMEDIA_FF_TEXT
+      || format == wxMEDIA_FF_TEXT_FORCE_CR)
+    fileFormat = format;
+}
+
+void wxMediaEdit::SetFilename(char *name, Bool temp)
+{
+  wxSnip *snip;
+
+  if (filename)
+    delete[] filename;
+  filename = copystring(name);
+  tempFilename = temp;
+
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  for (snip = snips; snip; snip = snip->next)
+    if (snip->flags & wxSNIP_USES_BUFFER_PATH)
+      snip->SetAdmin(snipAdmin);
+
+  writeLocked = wl;
+  flowLocked = fl;
+}
+
+wxBufferData *wxMediaEdit::GetRegionData(long WXUNUSED(start), long WXUNUSED(end))
+{
+  return NULL;
+}
+
+void wxMediaEdit::SetRegionData(long WXUNUSED(start), long WXUNUSED(end), 
+				wxBufferData *)
+{
+}
+
+/****************************************************************/
+
+float *wxMediaEdit::GetTabs(int *count, float *space, Bool *inUnits)
+{
+  if (count)
+    *count = tabcount;
+
+  if (space)
+    *space = tabSpace;
+
+  if (inUnits)
+    *inUnits = tabSpaceInUnits;
+
+  return tabs;
+}
+
+void wxMediaEdit::SetTabs(float *newtabs, int count, 
+			  float tabWidth, Bool inUnits)
+{
+  if (flowLocked)
+    return;
+
+  delete tabs;
+  
+  tabs = newtabs;
+  tabcount = count;
+
+  if (tabWidth >= 1)
+    tabSpace = tabWidth;
+  else
+    tabSpace = wxTAB_WIDTH;
+
+  tabSpaceInUnits = inUnits;
+
+  SizeCacheInvalid();
+  NeedRefresh(-1, -1);
+}
+
+/****************************************************************/
+
+long wxMediaEdit::FindPositionInLine(long i, float x, Bool *ateol, Bool *onit,
+				     float *how_close)
+{
+  return _FindPositionInLine(FALSE, i, x, ateol, onit, how_close);
+}
+
+long wxMediaEdit::_FindPositionInSnip(wxDC *dc, float X, float Y,
+				      wxSnip *snip, float x,
+				      float *how_close)
+{
+  long offset, range, i;
+
+  if (readLocked)
+    return 0;
+
+  if (x < 0) {
+    if (how_close)
+      *how_close = -100;
+    return 0;
+  }
+
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  if (snip->PartialOffset(dc, X, Y, snip->count) <= x) {
+    if (how_close)
+      *how_close = 100;
+    writeLocked = wl;
+    flowLocked = fl;
+    return snip->count;
+  }
+
+  /* Binary search for position within snip: */
+  range = snip->count;
+  i = range / 2;
+  offset = 0;
+
+  while (1) {
+    float dl, dr;
+
+    if ((dl = snip->PartialOffset(dc, X, Y, offset + i)) > x)
+      range = i;
+    else if ((dr = snip->PartialOffset(dc, X, Y, offset + i + 1)) <= x) {
+      offset += i;
+      range -= i;
+    } else {
+      if (how_close) {
+	if (dr - x < x - dl)
+	  *how_close = dr - x;
+	else
+	  *how_close = dl - x;
+      }
+      break;
+    }
+    
+    i = range / 2;
+  }
+
+  writeLocked = wl;
+  flowLocked = fl;
+
+  return i + offset;
+}
+
+long wxMediaEdit::FindLine(float y, Bool *onit)
+{
+  if (onit)
+    *onit = FALSE;
+    
+  if (!CheckRecalc(TRUE, FALSE))
+    return 0;
+
+  if (y <= 0)
+    return 0;
+  if ((y >= totalHeight) || (extraLine && y >= totalHeight - extraLineH))
+    return numValidLines - (extraLine ? 0 : 1);
+
+  if (onit)
+    *onit = TRUE;
+
+  return lineRoot->FindLocation(y)->GetLine();
+}
+
+long wxMediaEdit::FindPosition(float x, float y, Bool *ateol, Bool *onit,
+			       float *how_close)
+{
+  long i, p;
+  Bool online;
+
+  if (readLocked)
+    return 0;
+
+  if (ateol)
+    *ateol = FALSE;
+
+  i = FindLine(y, &online);
+  if ((i >= numValidLines - 1) && !online && (y > 0)) {
+    if (onit)
+      *onit = FALSE;
+    if (how_close)
+      *how_close = 100;
+    return len;
+  }
+
+  p = FindPositionInLine(i, x, ateol, onit, how_close);
+  if (onit)
+    *onit = online && *onit;
+
+  return p;
+}
+
+long wxMediaEdit::PositionLine(long start, Bool eol)
+{
+  wxMediaLine *line;
+
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  if (start <= 0)
+    return 0;
+  if (start >= len) {
+    if (extraLine && !eol)
+      return numValidLines;
+    else
+      return numValidLines - 1;
+  }
+
+  line = lineRoot->FindPosition(start);
+  if (eol && (line->GetPosition() == start))
+    line = line->prev;
+  
+  return line->GetLine();
+}
+
+void wxMediaEdit::PositionLocation(long start, float *x, float *y, 
+				   Bool top, Bool eol, Bool wholeLine)
+{
+  float horiz, h, descent, space, topy;
+  int align;
+  wxMediaLine *line;
+  wxSnip *snip;
+  wxDC *dc;
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return;
+
+  /* Handle boundary cases first: */
+
+  if (start <= 0) {
+    if (wholeLine) {
+      if (x)
+	*x = 0;
+      if (y) {
+	*y = firstLine->GetLocation();
+	if (!top)
+	  *y += firstLine->h;
+      }
+      return;
+    }
+    line = firstLine;
+  } else if (start >= len) {
+    if (extraLine && !eol) {
+      if (y)
+	*y = totalHeight - (top ? extraLineH : 0);
+      if (x)
+	*x = 0;
+      return;
+    } 
+
+    line = lastLine;
+
+    if (wholeLine || !len) {
+      if (x)
+	*x = line->w;
+      if (y) {
+	*y = lastLine->GetLocation();
+	if (!top)
+	  *y += lastLine->h;
+      }
+      return;
+    }
+  } else {
+    line = lineRoot->FindLine(PositionLine(start, eol));
+
+    if (wholeLine) {
+      if (y) {
+	*y = line->GetLocation();
+	if (!top)
+	  *y += line->h;
+      }
+      if (!x)
+	return;
+    }
+  }
+
+  dc = NULL;
+
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  topy = line->GetLocation();
+
+  start -= line->GetPosition();
+  if (!start) {
+    horiz = 0;
+    snip = line->snip;
+  } else if (start >= line->len) {
+    horiz = line->w - line->lastW;
+    snip = line->lastSnip;
+  } else {
+    /* linear seach for snip */
+    snip = NULL;
+    horiz = 0;
+    
+    while(1) {
+      snip = snip ? snip->next : line->snip;
+      
+      if ((start > snip->count)
+	  || ((wholeLine || start) && start == snip->count)) {
+	start -= snip->count;
+	if (!dc) {
+	  dc = admin->GetDC();
+	  if (!dc) {
+	    writeLocked = wl;
+	    flowLocked = fl;
+	    return;
+	  }
+	}
+	
+	float v;
+	snip->GetExtent(dc, horiz, topy, &v);
+	horiz += v;
+      } else
+	break;
+    }
+  }
+
+
+  if (x) {
+    if (start && !dc) {
+      dc = admin->GetDC();
+      if (!dc) {
+	writeLocked = wl;
+	flowLocked = fl;
+	return;
+      }
+    }
+      
+    *x = horiz + (start ? snip->PartialOffset(dc, horiz, topy, start) : 0);
+  }
+
+  if (!wholeLine && y) {
+    if (!dc) {
+      dc = admin->GetDC();
+      if (!dc) {
+	writeLocked = wl;
+	flowLocked = fl;
+	return;
+      }
+    }
+    snip->GetExtent(dc, horiz, topy, NULL, &h, &descent, &space);
+    align = snip->style->GetAlignment();
+    if (align == wxALIGN_BOTTOM)
+      *y = topy + line->bottombase + descent - (top ? h : 0);
+    else if (align == wxALIGN_TOP)
+      *y = topy + line->topbase - space + (top ? 0 : h);
+    else {
+      h = (h - descent - space) / 2;
+      *y = topy + ((line->topbase + line->bottombase) / 2)
+	+ (top ? (- h - space) : (h + descent));
+    }
+  }
+
+  writeLocked = wl;
+  flowLocked = fl;
+}
+
+float wxMediaEdit::LineLocation(long i, Bool top)
+{
+  wxMediaLine *line;
+  float y;
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return 0.0;
+
+  if (i < 0)
+    return 0;
+  else if (i > numValidLines)
+    return totalHeight;
+  else if (i == numValidLines) {
+    if (extraLine)
+      return totalHeight - extraLineH;
+    return totalHeight;
+  }
+
+  line = lineRoot->FindLine(i);
+  y = line->GetLocation();
+
+  if (top)
+    return y;
+  else
+    return y + line->h;
+}
+
+long wxMediaEdit::LineStartPosition(long i, Bool visibleOnly)
+{
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  if (i < 0)
+    i = 0;
+  else if (i >= numValidLines) {
+    if (extraLine)
+      return len;
+    i = numValidLines - 1;
+  }
+
+  if (visibleOnly)
+    return FindFirstVisiblePosition(lineRoot->FindLine(i));
+  else
+    return lineRoot->FindLine(i)->GetPosition();
+}
+
+long wxMediaEdit::LineEndPosition(long i, Bool visibleOnly)
+{
+  wxMediaLine *line;
+  long p;
+
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  if (i < 0)
+    i = 0;
+  else if (i >= numValidLines) {
+    if (extraLine)
+      return len;
+    i = numValidLines - 1;
+  }
+
+  line = lineRoot->FindLine(i);
+
+  p = line->GetPosition() + line->len;
+  if (visibleOnly)
+    FindLastVisiblePosition(line, &p);
+
+  return p;
+}
+
+long wxMediaEdit::LineLength(long i)
+{
+  if (readLocked)
+    return 0;
+
+  if (i < 0)
+    return 0;
+  else if (i >= numValidLines)
+    return 0;
+  
+  return lineRoot->FindLine(i)->len;
+}
+
+long wxMediaEdit::PositionParagraph(long i, Bool WXUNUSED(eol))
+{
+  if (readLocked)
+    return 0;
+
+  wxMediaLine *l;
+  int delta = 0;
+
+  if (i < 0)
+    i = 0;
+  else if (i >= len) {
+    i = len;
+    if (extraLine)
+      delta = 1;
+  }
+
+  l = lineRoot->FindPosition(i);
+
+  return l->GetParagraph() + delta;
+}
+
+long wxMediaEdit::ParagraphStartPosition(long i, Bool visibleOnly)
+{
+  if (readLocked)
+    return 0;
+
+  wxMediaLine *l;
+
+  if (i < 0)
+    i = 0;
+
+  l = lineRoot->FindParagraph(i);
+  if (!l) {
+    if (extraLine)
+      return len;
+    else {
+      l = lastLine;
+      while (l->prev && !l->StartsParagraph())
+	l = l->prev;
+    }
+  }
+  
+  if (visibleOnly)
+    return FindFirstVisiblePosition(l);
+  else
+    return l->GetPosition();
+}
+
+long wxMediaEdit::ParagraphEndPosition(long i, Bool visibleOnly)
+{
+  if (readLocked)
+    return 0;
+
+  wxMediaLine *l;
+  long p;
+
+  if (i < 0)
+    i = 0;
+
+  l = lineRoot->FindParagraph(i);
+  if (l) {
+    while (l->next && !l->next->StartsParagraph())
+      l = l->next;
+  } else {
+    if (extraLine)
+      return len;
+    else
+      l = lastLine;
+  }
+
+  p = l->GetPosition() + l->len;
+  if (visibleOnly)
+    FindLastVisiblePosition(l, &p);
+
+  return p;
+}
+
+long wxMediaEdit::LineParagraph(long i)
+{
+  wxMediaLine *l;
+
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  if (i < 0)
+    return 0;
+  else if (i >= numValidLines)
+    return lastLine->GetParagraph() + (extraLine ? 1 : 0);
+  
+  l = lineRoot->FindLine(i);
+  
+  return l->GetParagraph();
+}
+
+long wxMediaEdit::ParagraphStartLine(long i)
+{
+  wxMediaLine *l;
+
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  if (i < 0)
+    i = 0;
+
+  l = lineRoot->FindParagraph(i);
+  if (!l)
+    return LastLine();
+  
+  return l->GetLine();
+}
+
+long wxMediaEdit::ParagraphEndLine(long i)
+{
+  if (!CheckRecalc(maxWidth > 0, FALSE, TRUE))
+    return 0;
+
+  wxMediaLine *l;
+
+  if (i < 0)
+    i = 0;
+
+  l = lineRoot->FindParagraph(i);
+  if (l) {
+    while (l->next && !l->next->StartsParagraph())
+      l = l->next;
+  } else
+    return LastLine();
+
+  return l->GetLine();
+}
+
+long wxMediaEdit::LastPosition(void)
+{
+  return len;
+}
+
+long wxMediaEdit::LastLine(void)
+{
+  return numValidLines - (extraLine ? 0 : 1);
+}
+
+long wxMediaEdit::LastParagraph(void)
+{
+  if (readLocked)
+    return 0;
+
+  return lastLine->GetParagraph() + (extraLine ? 1 : 0);
+}
+
+void wxMediaEdit::GetExtent(float *w, float *h)
+{
+  CheckRecalc(TRUE, FALSE);
+
+  if (w)
+    *w = totalWidth;
+  if (h)
+    *h = totalHeight;
+}
+
+float wxMediaEdit::GetDescent(void)
+{
+  CheckRecalc(TRUE, FALSE);
+
+  return finalDescent;
+}
+
+float wxMediaEdit::GetSpace(void)
+{
+  CheckRecalc(TRUE, FALSE);
+
+  return initialSpace;
+}
+
+float wxMediaEdit::ScrollLineLocation(long scroll)
+{
+  if (readLocked)
+    return 0;
+
+  wxMediaLine *line;
+  long p;
+  float y;
+  long total = lastLine->GetScroll() + lastLine->numscrolls;
+
+  if (scroll == total) {
+    if (extraLine)
+      return totalHeight - extraLineH;
+    else
+      return totalHeight;
+  } else if (scroll > total)
+    return totalHeight;
+
+  line = lineRoot->FindScroll(scroll);
+  p = line->GetScroll();
+  y = line->GetLocation();
+
+  if (p < scroll)
+    y += line->ScrollOffset(scroll - p);
+
+  return y;
+}
+
+long wxMediaEdit::NumScrollLines()
+{
+  if (readLocked)
+    return 0;
+
+  return lastLine->GetScroll() + lastLine->numscrolls + (extraLine ? 1 : 0);
+}
+
+long wxMediaEdit::FindScrollLine(float p)
+{
+  if (readLocked)
+    return 0;
+
+  wxMediaLine *line;
+  float y;
+  long s;
+
+  if (extraLine && (p >= totalHeight - extraLineH))
+    return NumScrollLines() - 1;
+
+  line = lineRoot->FindLocation(p);
+  s = line->GetScroll();
+
+  if (line->numscrolls > 1) {
+    y = line->GetLocation();
+    s += line->FindExtraScroll(p - y);
+  }
+
+  return s;
+}
+
+/****************************************************************/
+
+long wxMediaEdit::FindString(char *str, int direction, long start, long end,
+			     Bool bos, Bool caseSens)
+{
+  if (!CheckRecalc(FALSE, FALSE))
+    return -1;
+
+  return _FindStringAll(str, direction, start, end, NULL, TRUE, bos, caseSens);
+}
+
+long *wxMediaEdit::FindStringAll(char *str, long *cnt, int direction,
+				long start, long end, Bool bos, Bool caseSens)
+{
+  long *positions;
+
+  if (!CheckRecalc(FALSE, FALSE)) {
+    *cnt = 0;
+    return NULL;
+  }
+
+  *cnt = _FindStringAll(str, direction, start, end, &positions, FALSE,
+			bos, caseSens);
+  if (*cnt < 0) {
+    *cnt = 0;
+    positions = NULL;
+  }
+  return positions;
+}
+
+long wxMediaEdit::FindNewline(int direction, long start, long end)
+{
+  long para = PositionParagraph(start, direction < 0 ? TRUE : FALSE);
+
+  if (direction > 0)
+    para++;
+
+  long pos = ParagraphStartPosition(para);
+
+  if (direction > 0) {
+    if (pos > end)
+      return -1;
+  } else {
+    if (pos < end)
+      return -1;
+  }
+
+  return pos;
+}
+
+/****************************************************************/
+
+void wxMediaEdit::ChangeStyle(wxStyleDelta *delta)
+{
+  ChangeStyle(delta, -1);
+}
+
+void wxMediaEdit::ChangeStyle(wxStyleDelta *delta, long start, long end)
+{
+  _ChangeStyle(start > -1 ? start : startpos, 
+	       end > -1 ? end : (start > -1 ? len : endpos), 
+	       NULL, delta);
+}
+
+void wxMediaEdit::ChangeStyle(wxStyle *style, long start, long end)
+{
+  _ChangeStyle(start > -1 ? start : startpos, 
+	       end > -1 ? end : (start > -1 ? len : endpos), 
+	       style, NULL);
+}
+
+void wxMediaEdit::SetStyleList(wxStyleList *newList)
+{
+  wxSnip *snip;
+  wxStyle *style, *baseStyle, *newStyle = NULL;
+  int count, index, baseIndex;
+  wxStyle **map;
+  wxStyleDelta delta;
+  char *name;
+
+  if (writeLocked)
+    return;
+
+  count = styleList->Number();
+  if (count) {
+    map = new wxStyle*[count];
+    map[0] = newList->IndexToStyle(0); /* base style maps to base style */
+    for (index = 1; index < count; index++) {
+      style = styleList->IndexToStyle(index);
+      name = style->GetName();
+
+      if (!name || !(newStyle = newList->FindNamedStyle(name))) {
+	baseStyle = style->GetBaseStyle();
+	baseIndex = styleList->StyleToIndex(baseStyle);
+	
+	if (style->IsJoin()) {
+	  int shiftIndex = styleList->StyleToIndex(style->GetShiftStyle());
+	  
+	  newStyle = newList->FindOrCreateJoinStyle(map[baseIndex], map[shiftIndex]);
+	} else {
+	  style->GetDelta(delta);
+	  
+	  newStyle = newList->FindOrCreateStyle(map[baseIndex], &delta);
+	}
+	if (name)
+	  newStyle = newList->NewNamedStyle(name, newStyle);
+      }
+      
+      map[index] = newStyle;
+    }
+    
+    for (snip = snips; snip; snip = snip->next) {
+      style = snip->style;
+      index = styleList->StyleToIndex(style);
+      if (index < 0) {
+	/* Bad! Snip had style not from this buffer's style list */
+	snip->style = map[0];
+      } else
+	snip->style = map[index];
+    }
+  }
+
+  wxMediaBuffer::SetStyleList(newList);
+
+  SizeCacheInvalid();
+  NeedRefresh(-1, -1);
+}
+
+void wxMediaEdit::StyleHasChanged(wxStyle *style)
+{
+  if (readLocked)
+    return;
+
+  if (!style) {
+    NeedRefresh(-1, -1); /* Our queue to repaint */
+    return;
+  }
+  
+  wxSnip *snip;
+  
+  Bool wl = writeLocked, fl = flowLocked;
+  writeLocked = TRUE;
+  flowLocked = TRUE;
+
+  for (snip = snips; snip; snip = snip->next) {
+    if (PTREQ(snip->style, style)) {
+      snip->style = style;
+      snip->SizeCacheInvalid();
+      snip->line->MarkRecalculate();
+      if (maxWidth >= 0) {
+	snip->line->MarkCheckFlow();
+	if (snip->line->prev
+	    && !(snip->line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+	  snip->line->prev->MarkCheckFlow();
+      }
+    }
+  }
+
+  writeLocked = wl;
+  flowLocked = fl;
+}
+
+/****************************************************************/
+
+Bool wxMediaEdit::ScrollTo(wxSnip *snip, float localx, float localy, 
+			   float w, float h, Bool refresh, int bias)
+{
+  if (flowLocked)
+    return FALSE;
+
+  float x, y;
+
+  if (delayRefresh) {
+    delayedscroll = -1;
+    delayedscrollbox = TRUE;
+    delayedscrollsnip = snip;
+    delayedscrollX = localx;
+    delayedscrollY = localy;
+    delayedscrollW = w;
+    delayedscrollH = h;
+    delayedscrollbias = bias;
+    return FALSE;
+  } else {
+    if (!GetSnipPositionAndLocation(snip, NULL, &x, &y))
+      return FALSE;
+    if (admin->ScrollTo(x + localx, y + localy, w, h, refresh, bias)) {
+      if (!refresh)
+	refreshAll = TRUE;
+      return TRUE;
+    } else
+      return FALSE;
+  }
+}
+
+void wxMediaEdit::Resized(wxSnip *snip, Bool redraw_now)
+{
+  if (!GetSnipPositionAndLocation(snip, NULL, NULL, NULL))
+    return;
+
+  snip->line->MarkRecalculate();
+  if (maxWidth >= 0) {
+    snip->line->MarkCheckFlow();
+    if (snip->line->prev
+	&& !(snip->line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+      snip->line->prev->MarkCheckFlow();
+  }
+  if (!graphicMaybeInvalid)
+    graphicMaybeInvalid = TRUE;
+
+  if (flowLocked)
+    redraw_now = FALSE;
+
+  if (!redraw_now)
+    delayRefresh++;
+  RefreshByLineDemand();
+  if (!redraw_now)
+    --delayRefresh;
+}
+
+Bool wxMediaEdit::Recounted(wxSnip *snip, Bool redraw_now)
+{
+  if (writeLocked)
+    return FALSE;
+
+  Resized(snip, redraw_now);
+  
+  return TRUE;
+}
+
+void wxMediaEdit::SetCaretOwner(wxSnip *snip, int dist)
+{
+  if (DoSetCaretOwner(snip, dist)) {
+    NeedRefresh(startpos, endpos); /* NeedCaretRefresh(); <- doesn't work; local caret ownership weirdness*/
+    OnFocus(!snip);
+  }
+}
+
+Bool wxMediaEdit::ReleaseSnip(wxSnip *snip)
+{
+  long pos;
+
+  if ((pos = GetSnipPosition(snip)) < 0)
+    return FALSE;
+
+  _Delete(pos, pos + snip->count, FALSE, FALSE);
+
+  if (!(*snip->admin_ptr) && (snip->flags & wxSNIP_OWNED))
+    snip->flags  -= wxSNIP_OWNED;
+
+  return TRUE;
+}
+
+void wxMediaEdit::RefreshBox(float L, float T, float w, float h)
+{
+  float B, R;
+
+  B = T + h;
+  R = L + w;
+
+  if (refreshBoxUnset) {
+    refreshL = L;
+    refreshR = R;
+    refreshT = T;
+    refreshB = B;
+    refreshBoxUnset = FALSE;
+  } else {
+    if (L < refreshL)
+      refreshL = L;
+    if (R > refreshR)
+      refreshR = R;
+    if (T < refreshT)
+      refreshT = T;
+    if (B > refreshB)
+      refreshB = B;
+  }
+
+  drawCachedInBitmap = FALSE;
+}
+
+void wxMediaEdit::NeedsUpdate(wxSnip *snip, float localx, float localy, 
+			      float w, float h)
+{
+  float x, y;
+
+  if (!GetSnipLocation(snip, &x, &y))
+    return;
+
+  RefreshBox(x + localx, y + localy, w, h);
+
+  if (!delayRefresh)
+    Redraw();
+}
+
+void wxMediaEdit::InvalidateBitmapCache(float x, float y, float w, float h)
+{
+  if (w < 0)
+    w = totalWidth - x;
+  if (h < 0)
+    h = totalHeight - y;
+
+  RefreshBox(x, y, w, h);
+  if (!delayRefresh)
+    Redraw();
+}
+
+void wxMediaEdit::HideCaret(Bool hide)
+{
+  if (!!hiliteOn == !!hide) {
+    hiliteOn = !hide;
+    if (ownCaret || (startpos != endpos))
+      NeedCaretRefresh();
+  }
+}
+
+Bool wxMediaEdit::CaretHidden(void)
+{
+  return !hiliteOn;
+}
+
+float wxMediaEdit::GetBetweenThreshold()
+{
+  return betweenThreshold;
+}
+
+void wxMediaEdit::SetBetweenThreshold(float t)
+{
+  if (t > 99.0)
+    t = 99.0;
+  betweenThreshold = t;
+}
+
+/****************************************************************/
+
+#ifdef MEMORY_USE_METHOD
+long wxMediaEdit::MemoryUse(void)
+{
+  return ((numValidLines * sizeof(wxMediaLine))
+	  + (tabcount * sizeof(float))
+	  + wxMediaBuffer::MemoryUse());
+}
+#endif
+
diff --git a/src/mred/wxme/wx_media.h b/src/mred/wxme/wx_media.h
new file mode 100644
index 0000000..bc0cfaf
--- /dev/null
+++ b/src/mred/wxme/wx_media.h
@@ -0,0 +1,594 @@
+/* Main header file for wxMedia */
+/* Include this file for anything using wxMedia */
+
+#ifndef __WX_MEDIA__
+#define __WX_MEDIA__
+
+#include "wx_panel.h"
+#include "wx_canvs.h"
+#include "wx_dcmem.h"
+#include "wx_keym.h"
+#include "wx_medio.h"
+#include "wx_style.h"
+#include "wx_mtype.h"
+
+class wxMediaEdit;
+class wxClickback;
+
+#define wxFOCUS_IMMEDIATE 0
+#define wxFOCUS_DISPLAY 1
+#define wxFOCUS_GLOBAL 2
+
+/* File formats */
+enum {
+  wxMEDIA_FF_GUESS,
+  wxMEDIA_FF_STD,
+  wxMEDIA_FF_TEXT,
+  wxMEDIA_FF_TEXT_FORCE_CR,
+  wxMEDIA_FF_SAME,
+  wxMEDIA_FF_COPY
+};
+
+#include "wx_snip.h"
+#include "wx_cgrec.h"
+#include "wx_medad.h"
+
+class wxSnipLocation;
+class wxMediaFlashTimer;
+
+class wxBitmap;
+
+/* Edit commands */
+enum {
+  wxEDIT_UNDO = 1,
+  wxEDIT_REDO,
+  wxEDIT_CLEAR,
+  wxEDIT_CUT,
+  wxEDIT_COPY,
+  wxEDIT_PASTE,
+  wxEDIT_KILL,
+  wxEDIT_INSERT_TEXT_BOX,
+  wxEDIT_INSERT_GRAPHIC_BOX,
+  wxEDIT_INSERT_IMAGE,
+  wxEDIT_SELECT_ALL,
+  _wx_EDIT_counter
+};
+
+/* Movement kinds */
+enum {
+  wxMOVE_SIMPLE = 1,
+  wxMOVE_LINE,
+  wxMOVE_PAGE,
+  wxMOVE_WORD
+};
+
+/* For Finding Wordbreaks: */
+enum {
+  wxBREAK_FOR_CARET = 1,
+  wxBREAK_FOR_LINE = 2,
+  wxBREAK_FOR_SELECTION = 4,
+  wxBREAK_FOR_USER_1 = 32,
+  wxBREAK_FOR_USER_2 = 64
+};
+
+/* Selection: */
+enum {
+  wxDEFAULT_SELECT = 0,
+  wxX_SELECT = 1,
+  wxLOCAL_SELECT = 2
+};
+
+/* Drawing: */
+enum {
+  wxSNIP_DRAW_NO_CARET = 0,
+  wxSNIP_DRAW_SHOW_INACTIVE_CARET,
+  wxSNIP_DRAW_SHOW_CARET
+};
+
+
+/* For FindSnip: */
+#define wxSNIP_BEFORE_OR_NULL (-2)
+#define wxSNIP_BEFORE (-1)
+#define wxSNIP_AFTER 1
+#define wxSNIP_AFTER_OR_NULL 2
+
+#define wxTAB_WIDTH 20
+
+typedef void (*wxClickbackFunc)(wxMediaEdit *, long start, long end, void *);
+typedef void (*wxWordbreakFunc)(wxMediaEdit *, long *start, long *end, 
+				int reason, void *);
+
+class wxMediaAdmin;
+
+
+class wxMediaWordbreakMap : public wxObject
+{
+  int usage;
+ public:
+  char map[256];
+
+  wxMediaWordbreakMap();
+
+  void SetMap(int ch, int mask);
+  int GetMap(int ch);
+
+  void AdjustUsage(Bool newUser);
+  Bool IsUsed(void);
+};
+
+extern wxMediaWordbreakMap wxTheMediaWordbreakMap;
+
+class wxMediaEdit : public wxMediaBuffer
+{
+  friend class wxMediaLine;
+  friend class wxMediaSnipMediaAdmin;
+ public:
+  wxMediaEdit(float lineSpacing = 1.0, 
+	      float *tabstops = NULL, int numtabs = 0);
+  ~wxMediaEdit();
+
+  wxMediaBuffer *CopySelf(void);
+
+  /* Usually called by wxMediaAdmin */
+  virtual void OnEvent(wxMouseEvent &event);
+  virtual void OnChar(wxKeyEvent &event);
+  virtual wxCursor *AdjustCursor(wxMouseEvent &event);
+  virtual void Refresh(float localx, float localy, float w, float h, 
+		       int show_caret);
+  virtual void OwnCaret(Bool ownit);
+  virtual void SizeCacheInvalid(void);
+
+  virtual void OnDefaultEvent(wxMouseEvent &event);
+  virtual void OnDefaultChar(wxKeyEvent &event);
+
+  /* Callbacks for the wxSnipAdmin: */
+  virtual Bool ScrollTo(wxSnip *, float localx, float localy, 
+			float w, float h, Bool refresh, int bias = 0);
+  virtual void Resized(wxSnip *, Bool redraw_now);
+  virtual Bool Recounted(wxSnip *, Bool redraw_now);
+  virtual void NeedsUpdate(wxSnip *, float localx, float localy, 
+			   float w, float h);
+  virtual void SetCaretOwner(wxSnip *, int = wxFOCUS_IMMEDIATE);
+  virtual Bool ReleaseSnip(wxSnip *);
+
+  /* Methods for you to override: */
+  virtual void OnChange(void);
+  virtual Bool OnInsert(long start, long len);
+  virtual void AfterInsert(long start, long len);
+  virtual Bool OnDelete(long start, long len);
+  virtual void AfterDelete(long start, long len);
+  virtual Bool OnChangeStyle(long start, long len);
+  virtual void AfterChangeStyle(long start, long len);
+  virtual void AfterSetPosition(void);
+  virtual Bool OnSetSizeConstraint(void);
+  virtual void AfterSetSizeConstraint(void);
+
+  /* Set the caret position: */
+  void GetPosition(long *start, long *end = NULL);
+  long GetStartPosition(void);
+  long GetEndPosition(void);
+  void SetPosition(long start, long end = -1, 
+		   Bool eol = FALSE, Bool scroll = TRUE,
+		   int seltype = wxDEFAULT_SELECT);
+  void MovePosition(long code, Bool extend = FALSE,
+		    int kind = wxMOVE_SIMPLE);
+  void SetPositionBiasScroll(int bias, long start, long end = -1, 
+			     Bool eol = FALSE, Bool scroll = TRUE,
+			     int seltype = wxDEFAULT_SELECT);
+
+  virtual void SetAnchor(Bool);
+  Bool GetAnchor(void);
+
+  Bool ScrollToPosition(long start, Bool ateol = FALSE, 
+			long end = -1, int bias = 0);
+  void GetVisiblePositionRange(long *start, long *end);
+  void GetVisibleLineRange(long *start, long *end);
+
+  /* Hilite a region without changing the selection position: */
+  void FlashOn(long start, long end, Bool ateol = FALSE, 
+	       Bool scroll = TRUE, long timeout = 500);
+  void FlashOff();
+
+  /* Change the text */
+  void Insert(char *str, long start, long end = -1, Bool scrollOk = TRUE);
+  void Insert(char *str);
+  void Insert(long len, char *str, long start, long end = -1, Bool scrollOk=TRUE);
+  void Insert(long len, char *str);
+  void Insert(wxSnip *snip, long start, long end = -1, Bool scrollOk=TRUE);
+  void Insert(wxSnip *snip);
+  void Insert(unsigned char ascii);
+  void Insert(unsigned char ascii, long start, long end = -1);
+  void Delete(long start, long end = -1, Bool scrollOk = TRUE);
+  void Delete();
+  void Erase();
+
+  void Cut(Bool extend, long time, long start, long end = -1);
+  void Cut(Bool extend = FALSE, long time = 0);
+  void Copy(Bool extend, long time, long start, long end = -1);
+  void Copy(Bool extend = FALSE, long time = 0);
+  void Paste(long time, long start, long end = -1);
+  void Paste(long time = 0);
+  void PasteNext(void);
+  void Kill(long time = 0);
+  void Kill(long time, long start, long end);
+  void Clear(void);
+  void SelectAll(void);
+
+  virtual void DoCopy(long start, long end, long time, Bool extend);
+  virtual void DoPaste(long start, long time);
+
+  /* For making a lot of changes to be displayed at once: */
+  void BeginEditSequence(Bool undoable = TRUE);
+  void EndEditSequence(void);
+  Bool RefreshDelayed(void);
+
+  void ChangeStyle(wxStyleDelta *);
+  void ChangeStyle(wxStyle *, long start = -1, long end = -1);
+  void ChangeStyle(wxStyleDelta *, long start, long end = -1);
+  /* Called automatically when a style is changed; no need to call this */
+  void StyleHasChanged(wxStyle *style);
+
+  void SetStyleList(wxStyleList *styles);
+
+  /* Convert canvas co-ordinates to caret position */
+  long FindPosition(float x, float y, Bool 
+		    *ateol = NULL, Bool *onit = NULL,
+		    float *how_close = NULL);
+  long FindLine(float y, Bool *onit = NULL);
+  long FindPositionInLine(long i, float x, 
+			  Bool *ateol = NULL, Bool *onit =NULL,
+			  float *how_close = NULL);
+
+  /* Find the line or canvas co-ordinates for a caret position */
+  long PositionLine(long start, Bool eol=FALSE);
+  void PositionLocation(long start, 
+			float *x = NULL, float *y = NULL, 
+			Bool front = TRUE, Bool eol = FALSE,
+			Bool wholeLine = FALSE);
+  float LineLocation(long line, Bool top = TRUE);
+
+  /* Get first/last caret position in a line: */
+  long LineStartPosition(long i, Bool visibleOnly = TRUE);
+  long LineEndPosition(long i, Bool visibleOnly = TRUE);
+  long LineLength(long i);
+
+  /* Paragraphs */
+  long PositionParagraph(long start, Bool eol=FALSE);
+  long ParagraphStartPosition(long i, Bool visibleOnly = TRUE);
+  long ParagraphEndPosition(long i, Bool visibleOnly = TRUE);
+  long LineParagraph(long line);
+  long ParagraphStartLine(long i);
+  long ParagraphEndLine(long i);
+
+  long LastPosition(void);
+  long LastLine(void);
+  long LastParagraph(void);
+  
+  void GetExtent(float *w, float *h);
+  float GetDescent(void);
+  float GetSpace(void);
+
+  float ScrollLineLocation(long line);
+  long NumScrollLines();
+  long FindScrollLine(float y);
+
+  /* Searching */
+  long FindString(char *str, int direction = 1, long start =-1, long end =-1,
+		  Bool bos = TRUE, Bool caseSens = TRUE);
+  long *FindStringAll(char *str, long *cnt, int direction = 1,
+		      long start =-1, long end =-1, Bool bos = TRUE,
+		      Bool caseSens = TRUE);
+  long FindNewline(int direction = 1, long start =-1, long end =-1);
+
+  /* Create clickable ranges: */
+  void SetClickback(long start, long end, wxClickbackFunc, void *,
+		    wxStyleDelta *hiliteDelta = NULL, Bool callOnDown = FALSE);
+  void RemoveClickback(long start, long end);
+
+  void SetClickback(wxClickback *); /* Used by undo record only */
+
+  wxSnip *FindSnip(long p, int direction, long *sPos = NULL);
+  Bool GetSnipPositionAndLocation(wxSnip *thesnip, long *pos, 
+				  float *x = NULL, float *y = NULL);
+  Bool GetSnipLocation(wxSnip *thesnip, float *x = NULL, float *y = NULL,
+		       Bool bottomRight=FALSE);
+  long GetSnipPosition(wxSnip *thesnip);
+
+  char *GetFlattenedText(long *len = NULL);
+  char *GetText(long start = -1, long end = -1, 
+		Bool flattened = FALSE, Bool forceCR = FALSE,
+		long *got = NULL);
+  unsigned char GetCharacter(long start);
+
+  Bool LoadFile(char *filename = NULL, int format = wxMEDIA_FF_GUESS, Bool showErrors = TRUE);
+  Bool SaveFile(char *filename = NULL, int format = wxMEDIA_FF_SAME, Bool showErrors = TRUE);
+  Bool InsertFile(char *filename, int format = wxMEDIA_FF_GUESS, Bool showErrors = TRUE);
+
+  Bool ReadFromFile(wxMediaStreamIn &, long start, Bool overwritestyle = FALSE);
+  Bool ReadFromFile(wxMediaStreamIn &, Bool overwritestyle = FALSE);
+  Bool WriteToFile(wxMediaStreamOut &, long start, long end = -1);
+  Bool WriteToFile(wxMediaStreamOut &);
+
+  void SetFilename(char *, Bool temp = FALSE);
+  int GetFileFormat(void);
+  void SetFileFormat(int);
+
+  void SplitSnip(long pos);
+
+  float *GetTabs(int *length = NULL, 
+		 float *tabInc = NULL, Bool *inUnits = NULL);
+  void SetTabs(float *tabs, int count, 
+	       float tabIncrement = wxTAB_WIDTH, Bool inUnits = TRUE);
+
+  void AddEditorFunctions(wxKeymap *keymap);
+
+  void SetWordbreakFunc(wxWordbreakFunc f, void *data);
+  void FindWordbreak(long *start, long *end, int reason);
+
+  wxMediaWordbreakMap *GetWordbreakMap(void);
+  void SetWordbreakMap(wxMediaWordbreakMap *map);
+
+  virtual void PrintToDC(wxDC *dc, int page = -1);
+  virtual void *BeginPrint(wxDC *, Bool);
+  virtual void EndPrint(wxDC *, void *);
+  virtual Bool HasPrintPage(wxDC *dc, int page);
+
+  void SetMaxWidth(float w);
+  void SetMinWidth(float w);
+  float GetMaxWidth();
+  float GetMinWidth();
+  void SetMinHeight(float h);
+  void SetMaxHeight(float w);
+  float GetMinHeight();
+  float GetMaxHeight();
+
+  virtual void InvalidateBitmapCache(float x=0.0, float y=0.0,
+				     float w=-1.0, float h=-1.0);
+
+  /* You might need to call this if you're doing text changes within
+     BeginEditSequence() and EndEditSequence(). Hopefully, it will
+     get called automatically. */
+  void Recalculate(void);
+
+  void SettingAdmin(wxMediaAdmin *);
+  void InitNewAdmin(void);
+
+  virtual wxBufferData *GetRegionData(long start, long end);
+  virtual void SetRegionData(long start, long end, wxBufferData *);
+
+  void PasteRegionData(wxBufferData *);
+
+  virtual wxTextSnip *OnNewTextSnip();
+  virtual wxTabSnip *OnNewTabSnip();
+
+  wxBitmap *SetAutowrapBitmap(wxBitmap *bm);
+
+  void HideCaret(Bool hide);
+  Bool CaretHidden(void);
+
+  float GetBetweenThreshold();
+  void SetBetweenThreshold(float thresh);
+
+  inline Bool GetOverwriteMode(void) { return overwriteMode; }
+  inline void SetOverwriteMode(Bool m) { overwriteMode = !!m; }
+
+#if ALLOW_X_STYLE_SELECTION
+  virtual Bool OwnXSelection(Bool on, Bool update, Bool force);
+#endif
+
+#ifdef MEMORY_USE_METHOD
+  virtual long MemoryUse(void);
+#endif
+
+ private:
+#define TF_Flag(var) unsigned var : 1
+
+  TF_Flag( readLocked );
+  TF_Flag( flowLocked );
+  TF_Flag( writeLocked );
+
+  TF_Flag( hiliteOn );
+
+  TF_Flag( changed ); /* Set if OnChange() needs to be called */
+
+  TF_Flag( flash );
+  TF_Flag( flashautoreset );
+  TF_Flag( flashdirectoff );
+
+  TF_Flag( posateol ); /* display the caret at the end of a line? */
+  TF_Flag( flashposateol );
+  TF_Flag( flashscroll ); /* Scroll back after unflashing? */
+
+  TF_Flag( graphicsInvalid );
+  TF_Flag( flowInvalid );
+  TF_Flag( snipCacheInvalid );
+  TF_Flag( graphicMaybeInvalid );
+  TF_Flag( graphicMaybeInvalidForce );
+
+  TF_Flag( typingStreak );
+  TF_Flag( deletionStreak );
+  TF_Flag( delayedStreak );
+  TF_Flag( vcursorStreak );
+  TF_Flag( killStreak );
+  TF_Flag( anchorStreak );
+  TF_Flag( insertForceStreak );
+  TF_Flag( deleteForceStreak );
+
+  TF_Flag( keepAnchorStreak );
+
+  TF_Flag( dragging );
+  TF_Flag( tracking );
+  TF_Flag( extraLine ); /* Empty line at end of file with no representative */
+
+  TF_Flag( delayedscrollateol );
+  TF_Flag( delayedscrollbox );
+  TF_Flag( caretOn );
+  TF_Flag( drawCachedInBitmap );
+  TF_Flag( refreshUnset );
+  TF_Flag( refreshBoxUnset );
+  TF_Flag( refreshAll );
+
+  TF_Flag( tabSpaceInUnits );
+  TF_Flag( overwriteMode );
+
+#if ALLOW_X_STYLE_SELECTION
+  TF_Flag( needXCopy );
+#endif
+
+#undef TF_Flag
+
+  int lastDrawCaret;
+  int lastDrawXSel;
+
+  float lineSpacing;
+  float maxWidth, minWidth, minHeight, maxHeight;
+  float wrapBitmapWidth;
+
+  wxBitmap *autoWrapBitmap;
+
+
+  int delayRefresh;
+
+  long len; /* Total length in "characters" == number of positions - 1 */
+
+  long startpos, endpos;
+  float startloc, endloc; /* for vcursorStreak */
+
+  wxMediaFlashTimer *flashTimer;
+  long flashstartpos, flashendpos;
+
+  wxSnip *snips, *lastSnip; /* The contents of this edit session */
+  long snipCount;
+
+  wxStandardSnipAdmin *snipAdmin;
+  
+  class wxMediaLine *lineRoot, *firstLine, *lastLine; /* Line information */
+  long numValidLines;
+
+  float extraLineH;
+
+  float totalHeight, totalWidth; /* Total height/width in canvas units */
+  float finalDescent; /* Descent of last line */
+  float initialSpace; /* Space from first line */
+
+  wxStyle *caretStyle;
+
+  long dragstart;
+
+  wxClickback *trackClickback;
+
+  long refreshStart, refreshEnd;
+  float refreshL, refreshT, refreshR, refreshB;
+
+  float lastDrawL, lastDrawT, lastDrawR, lastDrawB;
+
+  float caretLocationX, caretLocationT, caretLocationB;
+
+  long delayedscroll, delayedscrollend;
+  int delayedscrollbias;
+  wxSnip *delayedscrollsnip;
+  float delayedscrollX, delayedscrollY, delayedscrollW, delayedscrollH;
+
+  wxList *clickbacks;
+
+  int fileFormat;
+
+  float betweenThreshold;
+
+  float *tabs;
+  int tabcount;
+  float tabSpace;
+  
+  long readInsert, readInsertStart;
+
+  long prevPasteStart, prevPasteEnd;
+
+  wxWordbreakFunc wordBreak;
+  void *wordBreakData;
+
+  wxMediaWordbreakMap *wordBreakMap;
+
+  void _Insert(wxSnip *snip, long len, char *str, long start, long end = -1, 
+	       Bool scrollOk = TRUE);
+  void _Delete(long start, long end, Bool undo, Bool scrollOk);
+
+  void _SetPosition(Bool setflash, int bias, long start, long end, 
+		    Bool ateol, Bool scroll, int seltype);
+
+  void _ChangeStyle(long start, long end, wxStyle *, wxStyleDelta *);
+
+  void MakeOnlySnip(void);
+  void SpliceSnip(wxSnip *snip, wxSnip *prev, wxSnip *next);
+  void InsertSnip(wxSnip *before, wxSnip *snip);
+  void AppendSnip(wxSnip *snip);
+  void DeleteSnip(wxSnip *snip);
+  wxSnip *SnipSetAdmin(wxSnip *snip, wxSnipAdmin *a);
+  void SnipSplit(wxSnip *snip, long pos, wxSnip **a, wxSnip **b);
+
+  void MakeSnipset(long start, long end);
+  wxTextSnip *InsertTextSnip(long start, wxStyle *style = NULL);
+  void CheckMergeSnips(long start);
+
+  void AdjustClickbacks(long start, long end, long d, wxDeleteRecord *rec);
+  wxClickback *FindClickback(long start);
+  void SetClickbackHilited(wxClickback *, Bool);
+
+  Bool ScrollToPosition(long start, Bool ateol, Bool refresh, long end,
+			int bias);
+
+  long FindFirstVisiblePosition(wxMediaLine *line, wxSnip *snip = NULL);
+  void FindLastVisiblePosition(wxMediaLine *line, long *p,
+			       wxSnip **snipP = NULL);
+
+  long _FindPositionLine(long pos);
+  void _CalcValidPositionLine(void);
+
+  long _FindPositionInLine(Bool internal, long i, float x, 
+			   Bool *ateol = NULL, Bool *onit =NULL,
+			   float *how_close = NULL);
+  long _FindPositionInSnip(wxDC *dc, float X, float Y,
+			   wxSnip *snip, float x, float *how_close = NULL);
+
+  void LinesInvalidAfter(long);
+  void OneLineInvalid(long);
+  void SnipChangedAt(long);
+
+  long _FindStringAll(char *str, int direction,
+		      long start, long end, long **positions, 
+		      Bool, Bool, Bool);
+  
+  Bool InsertFile(FILE *f, char *filename, int& format, Bool clearStyles, Bool showErrors);
+
+  void RecalcLines(wxDC *dc, Bool calcGraphic = TRUE);
+  Bool CheckFlow(float maxw, wxDC *dc, float Y, long startp, wxSnip *start);
+  Bool CheckRecalc(Bool need_graphic = TRUE, Bool need_write = TRUE, Bool no_display_ok = FALSE);
+  void Redraw(wxDC *, float, float, float, float, float, float, int, int);
+  void Redraw();
+
+  void NeedRefresh(long start, long end = -1);
+  void NeedRefresh(float, float, float, float);
+  void RefreshByLineDemand(void);
+  void RefreshBox(float x, float y, float w, float h);
+
+  void NeedCaretRefresh(void);
+  void CaretOn(void);
+  Bool CaretOff(void);
+  void CalcCaretLocation(void);
+  
+  void EndStreaks(int exception = 0);
+ protected:
+  Bool ReadInsert(wxSnip *snip);
+  void InsertPasteSnip(wxSnip *snip, wxBufferData *);
+  void InsertPasteString(char *str);
+};
+
+#include "wx_medpb.h"
+
+void wxInitMedia(void);
+void wxAddMediaEditorFunctions(wxKeymap *tab);
+void wxAddMediaPasteboardFunctions(wxKeymap *tab);
+
+extern const char *(*wxmeExpandFilename)(const char *);
+
+#endif /* __WX_MEDIA__ */
+
diff --git a/src/mred/wxme/wx_medio.cxx b/src/mred/wxme/wx_medio.cxx
new file mode 100644
index 0000000..6277904
--- /dev/null
+++ b/src/mred/wxme/wx_medio.cxx
@@ -0,0 +1,694 @@
+
+#include <stdio.h>
+
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+// wxWindows 1.62(f): new include for common dialogs
+#include "wx_cmdlg.h"
+#endif
+
+#include "wx_medio.h"
+#include <string.h>
+
+#ifndef WXME_LSB_FIRST
+#ifdef wx_msw
+#define WXME_LSB_FIRST 1
+#else
+#define WXME_LSB_FIRST 0
+#endif
+#endif
+
+#define TYPESAFE 0
+
+enum {
+  st_STRING,
+  st_NUMBER,
+  st_FLOAT,
+  st_FIXED
+};
+
+/* 
+   Integer format specified by first byte:
+     bit 8: 0 - read 7-bit (positive) number
+     bit 8: 1 - ...
+        bit 7: 0 - read abother byte for 15-bit (positive) number
+	bit 7: 1 - negative and long numbers...
+	 bit 1: 1 - read another 8-bit (signed) number
+	 bit 1: 0 - ...
+	   bit 2: 1 - read another 16-bit (signed) number
+	   bit 2: 0 - read another 32-bit (signed) number
+*/
+
+void wxMediaIOCheckLSB(void)
+{
+  long v = 1;
+  char first;
+
+  first = *(char *)&v;
+#if WXME_LSB_FIRST
+  first = !first;
+#endif
+  if (first)
+    wxMessageBox("wxMedia was compiled with the wrong WXME_LSB_FIRST flag\nvalue. The correct value is "
+#if WXME_LSB_FIRST
+		 "FALSE"
+#else
+		 "TRUE"
+#endif
+		 ".",
+		 "Warning");
+}
+
+/****************************************************************/
+
+wxMediaStreamInFileBase::wxMediaStreamInFileBase(FILE *s)
+{
+  f = s;
+}
+
+wxMediaStreamInFileBase::~wxMediaStreamInFileBase()
+{
+}
+
+long wxMediaStreamInFileBase::Tell(void)
+{
+  return ftell(f);
+}
+
+void wxMediaStreamInFileBase::Seek(long p)
+{
+  fseek(f, p, 0);
+}
+
+void wxMediaStreamInFileBase::Skip(long n)
+{
+  fseek(f, n, 1);
+}
+
+Bool wxMediaStreamInFileBase::Bad(void)
+{
+  return ferror(f);
+}
+
+long wxMediaStreamInFileBase::Read(char *data, long len)
+{
+  if (len <= 0)
+    return 0;
+
+  return fread(data, 1, len, f);
+}
+
+/****************************************************************/
+
+wxMediaStreamOutFileBase::wxMediaStreamOutFileBase(FILE *s)
+{
+  f = s;
+}
+
+wxMediaStreamOutFileBase::~wxMediaStreamOutFileBase()
+{
+}
+
+long wxMediaStreamOutFileBase::Tell(void)
+{
+  return ftell(f);
+}
+
+void wxMediaStreamOutFileBase::Seek(long p)
+{
+  fseek(f, p, 0);
+}
+
+Bool wxMediaStreamOutFileBase::Bad(void)
+{
+  return ferror(f);
+}
+
+void wxMediaStreamOutFileBase::Write(char *data, long len)
+{
+  if (len <= 0)
+    return;
+
+  fwrite(data, 1, len, f);
+}
+
+/****************************************************************/
+
+wxMediaStreamInStringBase::wxMediaStreamInStringBase(char *s, long l)
+{
+  string = s;
+  len = l;
+  pos = 0;
+  bad = FALSE;
+}
+
+wxMediaStreamInStringBase::~wxMediaStreamInStringBase()
+{
+}
+
+long wxMediaStreamInStringBase::Tell(void)
+{
+  return pos;
+}
+
+void wxMediaStreamInStringBase::Seek(long p)
+{
+  if (p < 0)
+    p = 0;
+  else if (p < len)
+    pos = p;
+  else
+    pos = len;
+}
+
+void wxMediaStreamInStringBase::Skip(long n)
+{
+  pos += n;
+  if (pos > len)
+    pos = len;
+  else if (pos < 0)
+    pos = 0;
+}
+
+Bool wxMediaStreamInStringBase::Bad(void)
+{
+  return bad;
+}
+
+long wxMediaStreamInStringBase::Read(char *data, long l)
+{
+  if (l + pos > len) {
+    bad = TRUE;
+    l = len - pos;
+  }
+
+  memcpy(data, string + pos, l);
+  pos += l;
+
+  return l;
+}
+
+/****************************************************************/
+
+wxMediaStreamOutStringBase::wxMediaStreamOutStringBase()
+{
+  alloc = 50;
+  len = pos = 0;
+  string = new char[alloc];
+  bad = FALSE;
+}
+
+wxMediaStreamOutStringBase::~wxMediaStreamOutStringBase()
+{
+}
+
+char *wxMediaStreamOutStringBase::GetString(long *l)
+{
+  *l = len;
+  return string;
+}
+
+long wxMediaStreamOutStringBase::Tell(void)
+{
+  return pos;
+}
+
+void wxMediaStreamOutStringBase::Seek(long p)
+{
+  if (p < 0)
+    pos = 0;
+  else if (p > len)
+    pos = len;
+  else
+    pos = p;
+}
+
+Bool wxMediaStreamOutStringBase::Bad(void)
+{
+  return bad;
+}
+
+void wxMediaStreamOutStringBase::Write(char *data, long l)
+{
+  if (l + pos > alloc) {
+    char *old = string;
+
+    alloc *= 2;
+    string = new char[alloc];
+    memcpy(string, old, len);
+    delete[] old;
+  }
+
+  memcpy(string + pos, data, l);
+  pos += l;
+  if (len < pos)
+    len = pos;
+}
+
+/****************************************************************/
+
+wxMediaStreamIn::wxMediaStreamIn(wxMediaStreamInBase& s)
+{
+  f = &s;
+  boundalloc = 10;
+  boundcount = 0;
+  boundaries = new long[boundalloc];
+  bad = FALSE;
+}
+
+wxMediaStreamIn::~wxMediaStreamIn()
+{
+  delete[] boundaries;
+}
+
+void wxMediaStreamIn::Typecheck(char v)
+{
+  if (bad)
+    return;
+
+  if (boundcount && (f->Tell() >= boundaries[boundcount - 1])) {
+    bad = TRUE;
+    wxMessageBox("Overread caused by file corruption"
+		 " or unknown internal error.", "Error");
+    return;
+  }
+
+  bad = f->Bad();
+
+  if (bad) {
+    wxMessageBox("Unknown stream error.", "Error");
+    return;
+  }
+
+#if TYPESAFE
+  char t;
+
+  f->Read(&t, 1);
+
+  if (bad = f->Bad()) {
+    wxMessageBox("Unknown stream error.", "Error");
+    return;
+  }
+
+  bad = (t != v);
+
+  if (bad)
+    wxMessageBox("Type safety error.", "Error");
+#endif
+}
+
+wxMediaStreamIn& wxMediaStreamIn::GetFixed(long& v)
+{
+  Typecheck(st_FIXED);
+
+  if (bad) {
+    v = 0;
+    return *this;
+  }
+
+#if !WXME_LSB_FIRST
+  f->Read((char *)&v, sizeof(long));
+#else
+  if (WXME_VERSION_ONE())
+    f->Read((char *)&v, sizeof(long));
+  else {
+    unsigned char bl[4];
+    
+    f->Read((char *)bl, 4);
+    v = (((long)bl[0]) << 24) + (((long)bl[1]) << 16)
+      + (((long)bl[2]) << 8) + bl[3];
+  }
+#endif
+
+  return *this;
+}
+
+char *wxMediaStreamIn::GetString(long *n)
+{
+  long m;
+  char *r;
+
+  if (bad) {
+    if (n)
+      *n = 0;
+    return NULL;
+  }
+
+  Get(m);
+
+  Typecheck(st_STRING);
+
+  r = new char[m];
+
+  f->Read(r, m);
+  if (n)
+    *n = m;
+
+  return r;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(long *n, char *str)
+{
+  long m;
+
+  if (bad) {
+    *n = 0;
+    return *this;
+  }
+
+  Get(m);
+
+  Typecheck(st_STRING);
+
+  if (m <= *n)
+    f->Read(str, m);
+  else {
+    f->Read(str, *n);
+    f->Skip(m - *n);
+  }
+  *n = m;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(long &v)
+{
+  char b;
+  
+
+  Typecheck(st_NUMBER);
+
+  if (bad) {
+    v = 0;
+    return *this;
+  }
+
+  f->Read((char *)&b, sizeof(char));
+  if (b & 0x80) {
+    if (b & 0x40) {
+      if (b & 0x1) {
+	signed char bv;
+	f->Read((char *)&bv, 1);
+	v = bv;
+      } else if (b & 0x2) {
+	unsigned char bl[2];
+	f->Read((char *)bl, 2);
+	v = (((int)((signed char *)bl)[0]) << 8) + bl[1];
+      } else {
+	unsigned char bl[4];
+	f->Read((char *)bl, 4);
+	v = (((long)((signed char *)bl)[0]) << 24) 
+	  + (((long)bl[1]) << 16)
+	  + (((long)bl[2]) << 8) + bl[3];
+      }
+    } else {
+      unsigned char b2;
+      f->Read((char *)&b2, sizeof(char));
+      v = (((int)(b & 0x3F)) << 8) | b2;
+    }
+  } else
+    v = b;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(short &v)
+{
+  long lv;
+
+  Get(lv);
+  v = lv;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(int &v)
+{
+  long lv;
+
+  Get(lv);
+  v = lv;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(char &v)
+{
+  long lv;
+
+  Get(lv);
+  v = lv;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(double &v)
+{
+  Typecheck(st_FLOAT);
+
+  if (bad) {
+    v = 0.0;
+    return *this;
+  }
+
+#if !WXME_LSB_FIRST
+  f->Read((char *)&v, sizeof(double));
+#else
+  if (WXME_VERSION_ONE())
+    f->Read((char *)&v, sizeof(double));
+  else {
+    char num[sizeof(double)], num2[sizeof(double)];
+    int i, j;
+
+    f->Read((char *)num, sizeof(double));
+    for (i = 0, j = sizeof(double); i < sizeof(double); )
+      num2[i++] = num[--j];
+
+    memcpy((char *)&v, num2, sizeof(double));
+  }
+#endif
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::Get(float &v)
+{
+  double lv;
+
+  Get(lv);
+  v = lv;
+
+  return *this;
+}
+
+wxMediaStreamIn& wxMediaStreamIn::operator>>(long &v) { return Get(v); }
+wxMediaStreamIn& wxMediaStreamIn::operator>>(short &v) { return Get(v); }
+wxMediaStreamIn& wxMediaStreamIn::operator>>(int &v) { return Get(v); }
+wxMediaStreamIn& wxMediaStreamIn::operator>>(char &v) { return Get(v); }
+wxMediaStreamIn& wxMediaStreamIn::operator>>(float &v) { return Get(v); }
+wxMediaStreamIn& wxMediaStreamIn::operator>>(double &v) { return Get(v); }
+
+void wxMediaStreamIn::SetBoundary(long n)
+{
+  if (boundcount == boundalloc) {
+    long *old = boundaries;
+    boundalloc *= 2;
+    boundaries = new long[boundalloc];
+    memcpy(boundaries, old, boundcount * sizeof(long));
+    delete[] old;
+  }
+
+  boundaries[boundcount++] = f->Tell() + n;
+}
+
+void wxMediaStreamIn::RemoveBoundary()
+{
+  --boundcount;
+}
+
+void wxMediaStreamIn::Skip(long n)
+{
+  f->Skip(n);
+}
+
+long wxMediaStreamIn::Tell(void)
+{
+  return f->Tell();
+}
+
+void wxMediaStreamIn::JumpTo(long pos)
+{
+  f->Seek(pos);
+}
+
+Bool wxMediaStreamIn::Ok(void)
+{
+  return !bad;
+}
+
+/*********************************************************************/
+
+wxMediaStreamOut::wxMediaStreamOut(wxMediaStreamOutBase& s)
+{
+  f = &s;
+  bad = FALSE;
+}
+
+void wxMediaStreamOut::Typeset(char v)
+{
+  if (bad)
+    return;
+
+  bad = f->Bad();
+
+  if (bad) {
+    wxMessageBox("Unknown stream error.", "Error");
+    return;
+  }
+
+#if TYPESAFE
+  f->Write(&v, 1);
+#endif
+}
+
+wxMediaStreamOut& wxMediaStreamOut::PutFixed(long v)
+{
+  Typeset(st_FIXED);
+
+#if !WXME_LSB_FIRST
+  f->Write((char *)&v, sizeof(long));
+#else
+  char lb[4];
+
+  lb[0] = (v >> 24) & 0xFF;
+  lb[1] = (v >> 16) & 0xFF;
+  lb[2] = (v >> 8) & 0xFF;
+  lb[3] = v & 0xFF;
+  f->Write(lb, 4);
+#endif
+
+  return *this;
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(long n, char *str)
+{
+  Put(n);
+
+  Typeset(st_STRING);
+
+  f->Write(str, n);
+
+  return *this;
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(char *v)
+{
+  return Put(strlen(v) + 1, v);
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(long v)
+{
+  Typeset(st_NUMBER);
+
+  if (v >= 0) {
+    if (v <= 0x7F) {
+      char b = v;
+      f->Write(&b, 1);
+    } else if (v <= 0x1FFF) {
+      unsigned char b[2];
+      b[0] = (v >> 8) | 0x80;
+      b[1] = v & 0xFF;
+      f->Write((char *)b, 2);
+    } else {
+      char markb = 0xC0;
+      unsigned char lb[4];
+      lb[0] = (v >> 24) & 0xFF;
+      lb[1] = (v >> 16) & 0xFF;
+      lb[2] = (v >> 8) & 0xFF;
+      lb[3] = v & 0xFF;
+      f->Write(&markb, 1);
+      f->Write((char *)lb, 4);
+    }
+  } else {
+    char b = 0xC0;
+    if (v > ((signed char)0x80)) {
+      signed char b2 = v;
+      b |= 0x1;
+      f->Write(&b, 1);
+      f->Write((char *)&b2, 1);
+    } else {
+      unsigned char lb[4];
+      f->Write(&b, sizeof(char));
+      ((signed char *)lb)[0] = (v >> 24) & 0xFF;
+      lb[1] = (v >> 16) & 0xFF;
+      lb[2] = (v >> 8) & 0xFF;
+      lb[3] = v & 0xFF;
+      f->Write((char *)lb, 4);
+    }
+  }
+
+  return *this;
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(short v)
+{
+  return Put((long)v);
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(int v)
+{
+  return Put((long)v);
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(char v)
+{
+  return Put((long)v);
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(double v)
+{
+  Typeset(st_FLOAT);
+
+#if !WXME_LSB_FIRST
+  f->Write((char *)&v, sizeof(double));
+#else
+  char num[sizeof(double)], num2[sizeof(double)];
+  int i, j;
+
+  memcpy(num2, (char *)&v, sizeof(double));
+  for (i = 0, j = sizeof(double); i < sizeof(double); )
+    num[i++] = num2[--j];
+  
+  f->Write((char *)num, sizeof(double));
+#endif
+
+  return *this;
+}
+
+wxMediaStreamOut& wxMediaStreamOut::Put(float v)
+{
+  return Put((double)v);
+}
+
+wxMediaStreamOut& wxMediaStreamOut::operator<<(char *str) { return Put(str); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(long v) {return Put(v); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(short v) {return Put(v); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(int v) {return Put(v); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(char v) {return Put(v); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(float v) {return Put(v); }
+wxMediaStreamOut& wxMediaStreamOut::operator<<(double v) {return Put(v); }
+
+long wxMediaStreamOut::Tell(void)
+{
+  return f->Tell();
+}
+
+void wxMediaStreamOut::JumpTo(long pos)
+{
+  f->Seek(pos);
+}
+
+Bool wxMediaStreamOut::Ok(void)
+{
+  return !bad;
+}
diff --git a/src/mred/wxme/wx_medio.h b/src/mred/wxme/wx_medio.h
new file mode 100644
index 0000000..41ff84c
--- /dev/null
+++ b/src/mred/wxme/wx_medio.h
@@ -0,0 +1,186 @@
+/* Header file for wxMediaStream */
+
+#ifndef wx_medio
+#define wx_medio
+
+#include <stdio.h>
+
+class wxMediaStreamInBase : public wxObject
+{
+ public:
+  virtual long Tell(void) = 0;
+  virtual void Seek(long) = 0;
+  virtual void Skip(long) = 0;
+  virtual Bool Bad(void) = 0;
+  virtual long Read(char *data, long len) = 0;
+};
+
+class wxMediaStreamOutBase : public wxObject
+{
+ public:
+  virtual long Tell(void) = 0;
+  virtual void Seek(long) = 0;
+  virtual Bool Bad(void) = 0;
+  virtual void Write(char *data, long len) = 0;
+};
+
+/*******************************************************************/
+
+class wxMediaStreamInFileBase : public wxMediaStreamInBase
+{
+  FILE *f;
+ public:
+  wxMediaStreamInFileBase(FILE *s);
+  ~wxMediaStreamInFileBase();
+
+  long Tell(void);
+  void Seek(long);
+  void Skip(long);
+  Bool Bad(void);
+  long Read(char *data, long len);
+};
+
+class wxMediaStreamOutFileBase : public wxMediaStreamOutBase
+{
+  FILE *f;
+ public:
+  wxMediaStreamOutFileBase(FILE *s);
+  ~wxMediaStreamOutFileBase();
+
+  long Tell(void);
+  void Seek(long);
+  Bool Bad(void);
+  void Write(char *data, long len);
+};
+
+/*******************************************************************/
+
+class wxMediaStreamInStringBase : public wxMediaStreamInBase
+{
+  char *string;
+  long len;
+  long pos;
+  Bool bad;
+ public:
+  wxMediaStreamInStringBase(char *s, long len);
+  ~wxMediaStreamInStringBase();
+
+  long Tell(void);
+  void Seek(long);
+  void Skip(long);
+  Bool Bad(void);
+  long Read(char *data, long len);
+};
+
+class wxMediaStreamOutStringBase : public wxMediaStreamOutBase
+{
+  char *string;
+  long len, alloc;
+  long pos;
+  Bool bad;
+ public:
+  wxMediaStreamOutStringBase();
+  ~wxMediaStreamOutStringBase();
+
+  char *GetString(long *len);
+
+  long Tell(void);
+  void Seek(long);
+  Bool Bad(void);
+  void Write(char *data, long len);
+};
+
+/*******************************************************************/
+
+class wxMediaStreamIn : public wxObject
+{
+  wxMediaStreamInBase *f;
+  long *boundaries;
+  int boundalloc, boundcount;
+  int bad;
+
+  void Typecheck(char);
+
+ public:
+  wxMediaStreamIn(wxMediaStreamInBase &base);
+  ~wxMediaStreamIn();
+  
+  wxMediaStreamIn& Get(long *n, char *str);
+  wxMediaStreamIn& Get(long&);
+  wxMediaStreamIn& Get(short&);
+  wxMediaStreamIn& Get(int&);
+  wxMediaStreamIn& Get(char&);
+  wxMediaStreamIn& Get(float&);
+  wxMediaStreamIn& Get(double&);
+
+  wxMediaStreamIn& GetFixed(long&);
+
+  char *GetString(long *n);
+
+  wxMediaStreamIn& operator>>(long&);
+  wxMediaStreamIn& operator>>(short&);
+  wxMediaStreamIn& operator>>(int&);
+  wxMediaStreamIn& operator>>(char&);
+  wxMediaStreamIn& operator>>(float&);
+  wxMediaStreamIn& operator>>(double&);
+
+  void SetBoundary(long n);
+  void RemoveBoundary();
+
+  void Skip(long n);
+  long Tell(void);
+  void JumpTo(long pos);
+
+  Bool Ok(void);
+};
+
+class wxMediaStreamOut : public wxObject
+{
+  wxMediaStreamOutBase *f;
+  int bad;
+
+  void Typeset(char);
+
+ public:
+  wxMediaStreamOut(wxMediaStreamOutBase& s);
+  
+  wxMediaStreamOut& Put(long n, char *str);
+  wxMediaStreamOut& Put(char *);
+  wxMediaStreamOut& Put(long);
+  wxMediaStreamOut& Put(short);
+  wxMediaStreamOut& Put(int);
+  wxMediaStreamOut& Put(char);
+  wxMediaStreamOut& Put(float);
+  wxMediaStreamOut& Put(double);
+
+  wxMediaStreamOut& PutFixed(long);
+
+  wxMediaStreamOut& operator<<(char *);
+  wxMediaStreamOut& operator<<(long);
+  wxMediaStreamOut& operator<<(short);
+  wxMediaStreamOut& operator<<(int);
+  wxMediaStreamOut& operator<<(char);
+  wxMediaStreamOut& operator<<(float);
+  wxMediaStreamOut& operator<<(double);
+
+  long Tell(void);
+  void JumpTo(long pos);
+
+  Bool Ok(void);
+};
+
+#define MRED_START_STR "WXME"
+#define MRED_START_STR_LEN 4
+#define MRED_FORMAT_STR "01"
+#define MRED_FORMAT_STR_LEN 2
+#define MRED_VERSION_STR "03"
+#define MRED_VERSION_STR_LEN 2
+
+extern char wxme_current_read_format[MRED_FORMAT_STR_LEN + 1];
+extern char wxme_current_read_version[MRED_VERSION_STR_LEN + 1];
+
+#define WXME_VERSION_ONE() (wxme_current_read_version[1] == '1')
+#define WXME_VERSION_TWO() (wxme_current_read_version[1] == '2')
+
+#endif /* wx_medio */
+
diff --git a/src/mred/wxme/wx_medpb.h b/src/mred/wxme/wx_medpb.h
new file mode 100644
index 0000000..662ed99
--- /dev/null
+++ b/src/mred/wxme/wx_medpb.h
@@ -0,0 +1,243 @@
+
+/* Included by wx_media.h */
+
+class wxMediaPasteboard : public wxMediaBuffer
+{
+ protected:
+  Bool ReadInsert(wxSnip *snip);
+  void InsertPasteSnip(wxSnip *snip, wxBufferData *);
+  void InsertPasteString(char *str);
+ public:
+  wxMediaPasteboard();
+  ~wxMediaPasteboard();
+
+  virtual void OnEvent(wxMouseEvent &event);
+  virtual void OnChar(wxKeyEvent &event);
+  virtual wxCursor *AdjustCursor(wxMouseEvent &event);
+  virtual void Refresh(float localx, float localy, float w, float h, 
+		       int show_caret);
+  virtual void OwnCaret(Bool ownit);
+  virtual void SizeCacheInvalid(void);
+  void GetExtent(float *w, float *h);
+
+  virtual void OnDefaultEvent(wxMouseEvent &event);
+  virtual void OnDefaultChar(wxKeyEvent &event);
+
+  virtual void OnDoubleClick(wxSnip *, wxMouseEvent &event);
+
+  /* Callbacks for the wxSnipAdmin: */
+  virtual Bool ScrollTo(wxSnip *, float localx, float localy, 
+			float w, float h, Bool refresh, int bias = 0);
+  virtual void SetCaretOwner(wxSnip *, int = wxFOCUS_IMMEDIATE);
+  virtual void Resized(wxSnip *, Bool redraw_now);
+  virtual Bool Recounted(wxSnip *, Bool redraw_now);
+  virtual void NeedsUpdate(wxSnip *, float localx, float localy, 
+			   float w, float h);
+  virtual Bool ReleaseSnip(wxSnip *);
+
+  float ScrollLineLocation(long line);
+  long NumScrollLines();
+  long FindScrollLine(float y);
+
+  wxMediaBuffer *CopySelf(void);
+  float GetDescent(void);
+  float GetSpace(void);
+  char *GetFlattenedText(long *got=NULL);
+  void GetCenter(float *x, float *y);
+
+  void Clear();
+  void Cut(Bool extend=FALSE, long time=0);
+  void Copy(Bool extend=FALSE, long time=0);
+  void Paste(long time=0);
+  void Kill(long time=0);
+  void SelectAll(void);
+
+  virtual void DoCopy(long time, Bool extend);
+  virtual void DoPaste(long time);
+
+  void SetSelected(wxSnip *);
+  void AddSelected(wxSnip *);
+  void RemoveSelected(wxSnip *);
+  void NoSelected();
+  void AddSelected(float x, float y, float w, float h);
+
+  void Insert(wxSnip *snip, wxSnip *before, float x, float y);
+  void Insert(wxSnip *snip, float x, float y);
+  void Insert(wxSnip *snip);
+  void Insert(wxSnip *snip, wxSnip *before);
+
+  void Delete();
+  void Delete(wxSnip *snip);
+  void Remove(wxSnip *snip);
+
+  void Erase(void);
+
+  void ChangeStyle(wxStyleDelta *delta);
+  void ChangeStyle(wxStyle *style, wxSnip *snip = NULL);
+  void ChangeStyle(wxStyleDelta *delta, wxSnip *snip);
+
+  Bool GetSnipLocation(wxSnip *thesnip, float *x = NULL, float *y = NULL, Bool bottomRight=FALSE);
+
+  void SetFilename(char *, Bool temp = FALSE);
+
+  Bool WriteToFile(wxMediaStreamOut &);
+  Bool ReadFromFile(wxMediaStreamIn &, Bool overwritestyle = FALSE);
+  Bool LoadFile(char *filename = NULL, int format = wxMEDIA_FF_STD, Bool showErrors = TRUE);
+  Bool SaveFile(char *filename = NULL, int format = wxMEDIA_FF_STD, Bool showErrors = TRUE);
+  Bool InsertFile(char *filename, int format = wxMEDIA_FF_GUESS, Bool showErrors = TRUE);
+
+  void StyleHasChanged(wxStyle *style);
+
+  /* For making a lot of changes to be displayed at once: */
+  void BeginEditSequence(Bool undoable = TRUE);
+  void EndEditSequence(void);
+  Bool RefreshDelayed(void);
+
+  void SetMaxWidth(float w);
+  void SetMinWidth(float w);
+  float GetMaxWidth();
+  float GetMinWidth();
+  void SetMinHeight(float h);
+  void SetMaxHeight(float w);
+  float GetMinHeight();
+  float GetMaxHeight();
+
+  virtual void PrintToDC(wxDC *print, int page = -1);
+  virtual void *BeginPrint(wxDC *, Bool);
+  virtual void EndPrint(wxDC *, void *);
+  virtual Bool HasPrintPage(wxDC *dc, int page);
+
+  void AddPasteboardFunctions(wxKeymap *tab);
+
+  wxSnip *FindSnip(float x, float y);
+  wxSnip *FindFirstSnip(void);
+
+  Bool IsSelected(wxSnip *asnip);
+  wxSnip *FindNextSelectedSnip(wxSnip *start);
+  
+  void MoveTo(wxSnip *, float x, float y);
+  void Move(wxSnip *, float x, float y);
+  void Move(float x, float y);
+
+  Bool Resize(wxSnip *, float w, float h);
+
+  void Raise(wxSnip *snip);
+  void Lower(wxSnip *snip);
+  void SetBefore(wxSnip *snip, wxSnip *before);
+  void SetAfter(wxSnip *snip, wxSnip *after);
+
+  Bool GetDragable();
+  void SetDragable(Bool);
+
+  Bool GetSelectionVisible();
+  void SetSelectionVisible(Bool);
+
+  virtual void SetSnipData(wxSnip *, wxBufferData *);
+  virtual wxBufferData *GetSnipData(wxSnip *snip);
+
+  virtual void InvalidateBitmapCache(float x=0.0, float y=0.0,
+				     float w=-1.0, float h=-1.0);
+
+#if ALLOW_X_STYLE_SELECTION
+  virtual Bool OwnXSelection(Bool on, Bool update, Bool force);
+#endif
+
+  /* Override these for your own use: */
+  virtual void OnChange(void);
+  virtual Bool OnInsert(wxSnip *, wxSnip *, float x, float y);
+  virtual void AfterInsert(wxSnip *, wxSnip *, float x, float y);
+  virtual Bool OnDelete(wxSnip *);
+  virtual void AfterDelete(wxSnip *);
+  virtual Bool OnMoveTo(wxSnip *, float x, float y, Bool dragging);
+  virtual void AfterMoveTo(wxSnip *, float x, float y, Bool dragging);
+  virtual Bool OnResize(wxSnip *, float w, float h);
+  virtual void AfterResize(wxSnip *, float w, float h, Bool did);
+
+  virtual Bool OnSelect(wxSnip *, Bool on);
+  virtual void AfterSelect(wxSnip *, Bool on);
+
+  virtual Bool OnInteractiveMove(void);
+  virtual void AfterInteractiveMove(void);
+  virtual Bool OnInteractiveResize(wxSnip *snip);
+  virtual void AfterInteractiveResize(wxSnip *snip);
+
+  virtual void InteractiveAdjustMouse(float *x, float *y);
+  virtual void InteractiveAdjustResize(wxSnip *s, float *x, float *y);
+  virtual void InteractiveAdjustMove(wxSnip *s, float *x, float *y);
+
+  void SetScrollStep(float s);
+  float GetScrollStep(void);
+
+ private:
+  Bool dragable, selectionVisible;
+
+  wxSnip *snips, *lastSnip;
+  wxList *snipLocationList;
+
+  wxStandardSnipAdmin *snipAdmin;
+  
+  long lastTime;
+  float startX, startY;
+  float lastX, lastY;
+
+  float origX, origY, origW, origH;
+  
+  float maxWidth, minWidth, minHeight, maxHeight;
+
+  Bool keepSize, dragging, rubberband;
+
+  int needResize;
+
+  wxSnip *resizing;
+  float sizedxm, sizedym;
+
+  float scrollStep;
+
+  float totalWidth, totalHeight, realWidth, realHeight;
+
+  float updateLeft, updateRight, updateTop, updateBottom;
+  Bool updateNonemtpy;
+
+  Bool sizeCacheInvalid;
+  Bool locked;
+
+  int sequence;
+
+  Bool sequenceStreak;
+
+  Bool changed;
+
+  void InitDragging();
+  void FinishDragging();
+
+  void DoSelect(wxSnip *, Bool on);
+
+  void DoEventResize(float eventX, float eventY);
+  void DoEventMove(float eventX, float eventY);
+
+  void _Delete(wxSnip *, wxDeleteSnipRecord *del);
+
+  Bool InsertFile(FILE *f, Bool clearStyles, Bool showErrors);
+
+  void Draw(wxDC *dc, float dx, float dy, 
+	    float cx, float cy, float cw, float ch, 
+	    int show_caret);
+
+  Bool FindDot(wxSnipLocation *loc, float x, float y,
+	       float *dxm, float *dym);
+
+  void Update(float x, float y, float w, float h);
+  void UpdateSnip(wxSnip *);
+  void UpdateLocation(wxSnipLocation *);
+  void UpdateSelected();
+  void UpdateAll();
+  void UpdateNeeded();
+
+  void CheckRecalc();
+
+  void RubberBand(float x, float y, float w, float h);
+
+  void _ChangeStyle(wxStyle *style, wxStyleDelta *delta, wxSnip *snip);
+
+  wxSnip *SnipSetAdmin(wxSnip *snip, wxSnipAdmin *a);
+};
diff --git a/src/mred/wxme/wx_mline.cxx b/src/mred/wxme/wx_mline.cxx
new file mode 100644
index 0000000..18d124d
--- /dev/null
+++ b/src/mred/wxme/wx_mline.cxx
@@ -0,0 +1,1162 @@
+/*
+ * File:        wx_mline.cc
+ * Purpose:     wxMediaLine (internal class for wxMediaEdit) implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_media.h"
+#include "wx_mline.h"
+#include "wx_ptreq.h"
+
+#define MAX_W_MASK (WXLINE_MAX_W_HERE | WXLINE_MAX_W_LEFT | WXLINE_MAX_W_RIGHT)
+#define COLOR_MASK (WXLINE_RED | WXLINE_BLACK)
+#define CALC_MASK (WXLINE_CALC_HERE | WXLINE_CALC_LEFT | WXLINE_CALC_RIGHT)
+#define FLOW_MASK (WXLINE_FLOW_HERE | WXLINE_FLOW_LEFT | WXLINE_FLOW_RIGHT)
+
+#define SET_RED(n) ((n)->flags = (((n)->flags & ~COLOR_MASK) | WXLINE_RED))
+#define SET_BLACK(n) ((n)->flags = (((n)->flags & ~COLOR_MASK) | WXLINE_BLACK))
+
+#define REDP(node) (node->flags & WXLINE_RED)
+#define BLACKP(node) (node->flags & WXLINE_BLACK)
+
+wxMediaLine *NIL = new wxMediaLine;
+
+/*****************************************************************/
+
+wxMediaLine::wxMediaLine()
+{
+  pos = line = scroll = 0;
+  y = 0;
+
+  prev = next = NULL;
+  left = right = parent = NIL;
+
+  flags = WXLINE_BLACK | WXLINE_MAX_W_HERE | WXLINE_CALC_HERE;
+  w = maxWidth = 0;
+
+  snip = lastSnip = scrollSnip = NULL;
+
+  numscrolls = 1;
+  len = 0;
+  h = w = 0;
+  lastH = lastW = 0;
+  bottombase = topbase = 0;
+  parno = 0;
+}
+
+wxMediaLine::~wxMediaLine()
+{
+  if (PTRNE(left, NIL))
+    delete left;
+  if (PTRNE(right, NIL))
+    delete right;
+}
+
+/*****************************************************************/
+
+void wxMediaLine::AdjustOffsets(wxMediaLine *newchild)
+{
+  if (PTREQ(newchild, NIL))
+    return;
+
+  newchild->line -= line + 1;
+  newchild->pos -= pos + len;
+  newchild->scroll -= scroll + numscrolls;
+  newchild->y -= y + h;
+  newchild->parno -= parno + StartsParagraph();
+}
+
+void wxMediaLine::DeadjustOffsets(wxMediaLine *oldchild)
+{
+  if (PTREQ(oldchild, NIL))
+    return;
+
+  oldchild->line += line + 1;
+  oldchild->pos += pos + len;
+  oldchild->scroll += scroll + numscrolls;
+  oldchild->y += y + h;
+  oldchild->parno += parno + StartsParagraph();
+}
+
+void wxMediaLine::RotateLeft(wxMediaLine **root)
+{
+  wxMediaLine *oldright;
+
+  oldright = right;
+  
+  DeadjustOffsets(oldright);
+  
+  right = oldright->left;
+  if (PTRNE(right, NIL))
+    right->parent = this;
+
+  oldright->parent = parent;
+  if (PTREQ(parent, NIL))
+    *root = oldright;
+  else if (PTREQ(this, parent->left))
+    parent->left = oldright;
+  else      
+    parent->right = oldright;
+
+  oldright->left = this;
+  parent = oldright;
+
+  AdjustMaxWidth();
+  AdjustNeedCalc();
+  AdjustNeedFlow();
+  oldright->AdjustMaxWidth();
+  oldright->AdjustNeedCalc();
+  oldright->AdjustNeedFlow();
+}
+
+void wxMediaLine::RotateRight(wxMediaLine **root)
+{
+  wxMediaLine *oldleft;
+
+  oldleft = left;
+
+  oldleft->AdjustOffsets(this);
+
+  left = oldleft->right;
+  if (PTRNE(left, NIL))
+    left->parent = this;
+
+  oldleft->parent = parent;
+  if (PTREQ(parent, NIL))
+    *root = oldleft;
+  else if (PTREQ(this, parent->left))
+    parent->left = oldleft;
+  else      
+    parent->right = oldleft;
+
+  oldleft->right = this;
+  parent = oldleft;
+
+  AdjustMaxWidth();
+  AdjustNeedCalc();
+  AdjustNeedFlow();
+  oldleft->AdjustMaxWidth();
+  oldleft->AdjustNeedCalc();
+  oldleft->AdjustNeedFlow();
+}
+
+wxMediaLine *wxMediaLine::Insert(wxMediaLine **root, Bool before)
+{
+  wxMediaLine *newline, *node;
+
+  newline = new wxMediaLine;
+
+  if (PTREQ(*root, NIL)) {
+    *root = newline;
+    return newline;
+  }
+
+  SET_RED(newline);
+
+  if (before) {
+    newline->prev = prev;
+    if (prev)
+      prev->next = newline;
+    newline->next = this;
+    prev = newline;
+  } else {
+    newline->prev = this;
+    newline->next = next;
+    if (next)
+      next->prev = newline;
+    next = newline;
+  }
+
+  if (before) {
+    if (PTREQ(left, NIL)) {
+      left = newline;
+      node = this;
+    } else {
+      node = left;
+      while (PTRNE(node->right, NIL))
+	node = node->right;
+      node->right = newline;
+    }
+  } else {
+    if (PTREQ(right, NIL)) {
+      right = newline;
+      node = this;
+    } else {
+      node = right;
+      while (PTRNE(node->left, NIL))
+	node = node->left;
+      node->left = newline;
+    }
+  }
+ 
+  newline->parent = node;
+  node->AdjustNeedCalc(TRUE);
+
+  node = newline;
+  while (PTRNE(node->parent, NIL)) {
+    if (PTREQ(node, node->parent->left)) {
+      node = node->parent;
+      newline->DeadjustOffsets(node);
+    } else
+      node = node->parent;
+  }
+	
+  node = newline;
+  while (PTRNE(node, *root) && REDP(node->parent)) {
+    if (PTREQ(node->parent, node->parent->parent->left)) {
+      wxMediaLine *y = node->parent->parent->right;
+      if (REDP(y)) {
+	SET_BLACK(node->parent);
+	SET_BLACK(y);
+	node = node->parent->parent;
+	SET_RED(node);
+      } else {
+	if (PTREQ(node, node->parent->right)) {
+	  node = node->parent;
+	  node->RotateLeft(root);
+	}
+	SET_BLACK(node->parent);
+	node = node->parent->parent;
+	SET_RED(node);
+	node->RotateRight(root);
+      }
+    } else {
+      wxMediaLine *y = node->parent->parent->left;
+      if (REDP(y)) {
+	SET_BLACK(node->parent);
+	SET_BLACK(y);
+	node = node->parent->parent;
+	SET_RED(node);
+      } else {
+	if (PTREQ(node, node->parent->left)) {
+	  node = node->parent;
+	  node->RotateRight(root);
+	}
+	SET_BLACK(node->parent);
+	node = node->parent->parent;
+	SET_RED(node);
+	node->RotateLeft(root);
+      }
+    }
+  }
+  
+  SET_BLACK(*root);
+
+  return newline;
+}
+
+void wxMediaLine::Delete(wxMediaLine **root)
+{
+  wxMediaLine *y, *x;
+  Bool wasBlack;
+
+  /* Adjust ancestor offsets */
+  y = this;
+  while (PTRNE(y->parent, NIL)) {
+    if (PTREQ(y->parent->right, y))
+      y = y->parent;
+    else {
+      y = y->parent;
+      y->line -= 1;
+      y->pos -= len;
+      y->scroll -= numscrolls;
+      y->y -= h;
+      y->parno -= StartsParagraph();
+    }
+  }
+
+  if (PTREQ(left, NIL) || PTREQ(right, NIL)) {
+    y = this;
+  } else {
+    y = this->next;
+    x = y;
+    while (PTRNE(x->parent, this)) {
+      if (PTREQ(x->parent->right, x))
+	x = x->parent;
+      else {
+	x = x->parent;
+	x->line -= 1;
+	x->pos -= y->len;
+	x->scroll -= y->numscrolls;
+	x->y -= y->h;
+	x->parno -= y->StartsParagraph();
+      }
+    }
+  }
+
+  if (PTRNE(y->left, NIL))
+    x = y->left;
+  else
+    x = y->right;
+
+  x->parent = y->parent;
+
+  if (PTREQ(y->parent, NIL))
+    *root = x;
+  else if (PTREQ(y, y->parent->left))
+    y->parent->left = x;
+  else
+    y->parent->right = x;
+
+  wasBlack = BLACKP(y);
+
+  if (PTRNE(y, this)) {
+    wxMediaLine *oldparent;
+
+    oldparent = y->parent;
+
+    if (BLACKP(this))
+      SET_BLACK(y);
+    else
+      SET_RED(y);
+
+    y->left = left;
+    if (PTRNE(left, NIL))
+      left->parent = y;
+    y->right = right;
+    if (PTRNE(right, NIL))
+      right->parent = y;
+    y->parent = parent;
+    if (PTREQ(*root, this))
+      *root = y;
+    else if (PTREQ(parent->right, this))
+      parent->right = y;
+    else
+      parent->left = y;
+
+    y->prev = prev;
+    if (y->prev)
+      y->prev->next = y;
+    
+    y->line = line;
+    y->pos = pos;
+    y->scroll = scroll;
+    y->y = this->y;
+    y->parno = parno;
+
+    oldparent->AdjustMaxWidth(TRUE);
+    oldparent->AdjustNeedCalc(TRUE);
+    oldparent->AdjustNeedFlow(TRUE);
+    
+    y->AdjustMaxWidth(TRUE);
+    y->AdjustNeedCalc(TRUE);
+    y->AdjustNeedFlow(TRUE);
+
+    if (PTREQ(x->parent, this))
+      x->parent = y;
+  } else {
+    if (prev)
+      prev->next = next;
+    if (next)
+      next->prev = prev;
+  }
+
+  if (wasBlack) {
+    /* Fixup */
+    wxMediaLine *w;
+
+    while (PTRNE(x, *root) && BLACKP(x)) {
+      if (PTREQ(x, x->parent->left)) {
+	w = x->parent->right;
+	if (REDP(w)) {
+	  SET_BLACK(w);
+	  SET_RED(x->parent);
+	  x->parent->RotateLeft(root);
+	  w = x->parent->right;
+	}
+	if (BLACKP(w->left) && BLACKP(w->right)) {
+	  SET_RED(w);
+	  x = x->parent;
+	} else {
+	  if (BLACKP(w->right)) {
+	    SET_BLACK(w->left);
+	    SET_RED(w);
+	    w->RotateRight(root);
+	    w = x->parent->right;
+	  }
+	  if (REDP(x->parent))
+	    SET_RED(w);
+	  else
+	    SET_BLACK(w);
+	  SET_BLACK(x->parent);
+	  SET_BLACK(w->right);
+	  x->parent->RotateLeft(root);
+	  x = *root;
+	}
+      } else {
+	w = x->parent->left;
+	if (REDP(w)) {
+	  SET_BLACK(w);
+	  SET_RED(x->parent);
+	  x->parent->RotateRight(root);
+	  w = x->parent->left;
+	}
+	if (BLACKP(w->right) && BLACKP(w->left)) {
+	  SET_RED(w);
+	  x = x->parent;
+	} else {
+	  if (BLACKP(w->left)) {
+	    SET_BLACK(w->right);
+	    SET_RED(w);
+	    w->RotateLeft(root);
+	    w = x->parent->left;
+	  }
+	  if (REDP(x->parent))
+	    SET_RED(w);
+	  else
+	    SET_BLACK(w);
+	  SET_BLACK(x->parent);
+	  SET_BLACK(w->left);
+	  x->parent->RotateRight(root);
+	  x = *root;
+	}
+      }
+    }
+    
+    SET_BLACK(x);
+  }
+
+  right = left = NIL;
+  delete this;
+}
+
+/***************************************************************/
+
+#define SEARCH(what, size)                   \
+  wxMediaLine *node, *prev;                  \
+                                             \
+  node = this;                               \
+                                             \
+  do {                                       \
+    prev = node;                             \
+    if (what < node->what)                   \
+      node = node->left;                     \
+    else if (what >= node->what + size) {    \
+      what -= node->what + size;             \
+      node = node->right;                    \
+    } else                                   \
+      return node;                           \
+  } while (PTRNE(node, NIL));                \
+                                             \
+  return prev;                               \
+
+wxMediaLine *wxMediaLine::FindLine(long line)
+{
+  SEARCH(line, 1);
+}
+
+wxMediaLine *wxMediaLine::FindPosition(long pos)
+{
+  SEARCH(pos, node->len);
+}
+
+wxMediaLine *wxMediaLine::FindScroll(long scroll)
+{
+  SEARCH(scroll, node->numscrolls);
+}
+
+wxMediaLine *wxMediaLine::FindLocation(float y)
+{
+  SEARCH(y, node->h);
+}
+
+wxMediaLine *wxMediaLine::FindParagraph(long parno)
+{
+  wxMediaLine *node, *prev;
+
+  node = this;
+
+  do {
+    prev = node;
+    if (parno < node->parno)
+      node = node->left;
+    else if (parno > node->parno
+	     || (parno == node->parno
+		 && !node->StartsParagraph())) {
+      parno -= node->parno + node->StartsParagraph();
+      node = node->right;
+    } else
+      return node;
+  } while (PTRNE(node, NIL));
+
+  return NULL;
+}
+
+/***************************************************************/
+
+#define SUM(what, size, adjust)              \
+  wxMediaLine *node;                         \
+                                             \
+  node = this;                               \
+                                             \
+  what = node->what;                         \
+  while (PTRNE(node->parent, NIL)) {         \
+    if (PTREQ(node, node->parent->left))     \
+      node = node->parent;                   \
+    else {                                   \
+      node = node->parent;                   \
+      what += node->what + size;             \
+    }                                        \
+  }                                          \
+                                             \
+  return what + adjust;                      \
+
+long wxMediaLine::GetLine()
+{
+  long line;
+  SUM(line, 1, 0);
+}
+
+long wxMediaLine::GetPosition()
+{
+  long pos;
+  SUM(pos, node->len, 0);
+}
+
+long wxMediaLine::GetScroll()
+{
+  long scroll;
+  SUM(scroll, node->numscrolls, 0);
+}
+
+float wxMediaLine::GetLocation()
+{
+  float y;
+  SUM(y, node->h, 0);
+}
+
+long wxMediaLine::GetParagraph()
+{
+  long parno;
+  SUM(parno, node->StartsParagraph(), (StartsParagraph() ? 0 : -1));
+}
+
+/***************************************************************/
+
+#define ADJUST(what, adj)                    \
+  wxMediaLine *node;                         \
+                                             \
+  node = this;                               \
+                                             \
+  delta = what - node->what;                 \
+  node->what = what;                         \
+  while (PTRNE(node->parent, NIL)) {         \
+    if (PTREQ(node, node->parent->left)) {   \
+      node = node->parent;                   \
+      node->adj += delta;                    \
+    } else {                                 \
+      node = node->parent;                   \
+    }                                        \
+  }                                          \
+
+void wxMediaLine::SetLength(long len)
+{
+  long delta;
+  ADJUST(len, pos);
+}
+
+void wxMediaLine::CalcLineLength()
+{
+  wxSnip *asnip, *nexts;
+  long l = 0;
+
+  nexts = lastSnip->next;
+  for(asnip = snip; PTRNE(asnip, nexts); asnip = asnip->next) {
+    l += asnip->count;
+    if (asnip->flags & wxSNIP_WIDTH_DEPENDS_ON_X)
+      asnip->SizeCacheInvalid();
+  }
+
+  if (l != len)
+    SetLength(l);
+
+  if (next && (lastSnip->flags & wxSNIP_HARD_NEWLINE)) {
+    if (!next->StartsParagraph())
+      next->SetStartsParagraph(TRUE);
+  } else if (next)
+    if (next->StartsParagraph())
+      next->SetStartsParagraph(FALSE);
+
+  if (!prev || (prev->lastSnip->flags & wxSNIP_HARD_NEWLINE)) {
+    if (!StartsParagraph())
+      SetStartsParagraph(TRUE);
+  } else
+    if (StartsParagraph())
+      SetStartsParagraph(FALSE);
+}
+
+void wxMediaLine::SetScrollLength(long numscrolls)
+{
+  long delta;
+  ADJUST(numscrolls, scroll);
+}
+
+void wxMediaLine::SetHeight(float h)
+{
+  float delta;
+  ADJUST(h, y);
+}
+
+void wxMediaLine::SetStartsParagraph(Bool starts)
+{
+  wxMediaLine *node;
+
+  if ((starts ? 1 : 0) == StartsParagraph())
+    return;
+
+  if (starts)
+    flags |= WXLINE_STARTS_PARA;
+  else
+    flags -= WXLINE_STARTS_PARA;
+
+  node = this;
+
+  while (PTRNE(node->parent, NIL)) {
+    if (PTREQ(node, node->parent->left)) {
+      node = node->parent;
+      if (starts)
+	node->parno += 1;
+      else
+	node->parno -= 1;
+    } else {
+      node = node->parent;
+    }
+  }
+}
+
+/***************************************************************/
+
+void wxMediaLine::AdjustMaxWidth(Bool recur)
+{
+  wxMediaLine *node = this;
+  long which, old;
+
+  if (PTREQ(this, NIL))
+    return;
+
+  while (1) {
+    old = node->flags & MAX_W_MASK;
+
+    if (PTRNE(node->right, NIL)
+	&& node->right->maxWidth > node->w 
+	&& (PTREQ(node->left, NIL)
+	    || node->right->maxWidth > node->left->maxWidth)) {
+      node->maxWidth = node->right->maxWidth;
+      which = WXLINE_MAX_W_RIGHT;
+    } else if (PTRNE(node->left, NIL)
+	       && node->left->maxWidth > node->w) {
+      node->maxWidth = node->left->maxWidth;
+      which = WXLINE_MAX_W_LEFT;
+    } else {
+      node->maxWidth = node->w;
+      which = WXLINE_MAX_W_HERE;
+    }
+
+    if (old != which) {
+      node->flags &= ~MAX_W_MASK;
+      node->flags |= which;
+    }
+    
+    node = node->parent;
+    if (!recur || PTREQ(node, NIL))
+      return;
+  }
+}
+
+void wxMediaLine::SetWidth(float w)
+{
+  this->w = w;
+  AdjustMaxWidth(TRUE);
+}
+
+/***************************************************************/
+
+float wxMediaLine::ScrollOffset(long p)
+{
+  if (!scrollSnip)
+    return 0;
+
+  if (p >= numscrolls)
+    return h;
+
+  return scrollSnip->GetScrollStepOffset(p);
+}
+
+long wxMediaLine::FindExtraScroll(float y)
+{
+  if (y >= h)
+    return numscrolls;
+  
+  if (!scrollSnip)
+    return 0;
+
+  return scrollSnip->FindScrollStep(y);
+}
+
+/***************************************************************/
+
+void wxMediaLine::MarkRecalculate()
+{
+  if (!(flags & WXLINE_CALC_HERE)) {
+    flags |= WXLINE_CALC_HERE;
+    if (PTRNE(parent, NIL))
+      parent->AdjustNeedCalc(TRUE);
+  }
+}
+
+void wxMediaLine::AdjustNeedCalc(Bool recur)
+{
+  wxMediaLine *node = this;
+  long which, old;
+
+  while (1) {
+    old = node->flags & CALC_MASK;
+
+    which = old & WXLINE_CALC_HERE;
+
+    if (PTRNE(node->right, NIL) && node->right->flags & CALC_MASK)
+      which |= WXLINE_CALC_RIGHT;
+    if (PTRNE(node->left, NIL) && node->left->flags & CALC_MASK)
+      which |= WXLINE_CALC_LEFT;
+
+    if (old != which) {
+      node->flags &= ~CALC_MASK;
+      node->flags |= which;
+      if (!recur || PTREQ(node->parent, NIL))
+	return;
+      node = node->parent;
+    } else
+      return;
+  }
+}
+
+/***************************************************************/
+
+void wxMediaLine::MarkCheckFlow()
+{
+  if (!(flags & WXLINE_FLOW_HERE)) {
+    flags |= WXLINE_FLOW_HERE;
+    if (PTRNE(parent, NIL))
+      parent->AdjustNeedFlow(TRUE);
+  }
+}
+
+void wxMediaLine::AdjustNeedFlow(Bool recur)
+{
+  wxMediaLine *node = this;
+  long which, old;
+
+  while (1) {
+    old = node->flags & FLOW_MASK;
+
+    which = old & WXLINE_FLOW_HERE;
+
+    if (PTRNE(node->right, NIL) && node->right->flags & FLOW_MASK)
+      which |= WXLINE_FLOW_RIGHT;
+    if (PTRNE(node->left, NIL) && node->left->flags & FLOW_MASK)
+      which |= WXLINE_FLOW_LEFT;
+
+    if (old != which) {
+      node->flags &= ~FLOW_MASK;
+      node->flags |= which;
+      if (!recur || PTREQ(node->parent, NIL))
+	return;
+      node = node->parent;
+    } else
+      return;
+  }
+}
+
+/***************************************************************/
+
+wxMediaLine *wxMediaLine::GetRoot()
+{
+  wxMediaLine *node;
+
+  node = this;
+  while (PTRNE(node->parent, NIL))
+    node = node->parent;
+
+  return node;
+}
+
+/***************************************************************/
+
+Bool wxMediaLine::UpdateFlow(wxMediaLine **root,
+			     wxMediaEdit *media, float maxWidth, wxDC *dc)
+{
+  if (flags & WXLINE_FLOW_LEFT) {
+    if (PTRNE(left, NIL) && left->UpdateFlow(root, media, maxWidth, dc))
+      return TRUE;
+    flags -= WXLINE_FLOW_LEFT;
+  }
+
+  if (flags & WXLINE_FLOW_HERE) {
+    flags -= WXLINE_FLOW_HERE;
+    if (media->CheckFlow(maxWidth, dc, GetLocation(), GetPosition(), snip)) {
+      wxSnip *asnip;
+
+      for (asnip = snip; PTRNE(asnip, lastSnip); asnip = asnip->next) {
+	if (asnip->flags & wxSNIP_NEWLINE) {
+	  /* Items pushed to next line or new line was inserted */
+	  wxSnip *nextsnip = NULL;
+
+	  if (next) {
+	    nextsnip = asnip->next;
+	    while (nextsnip && PTRNE(nextsnip, next->lastSnip)
+		   && !(nextsnip->flags & wxSNIP_NEWLINE)) {
+	      nextsnip = nextsnip->next;
+	    }
+	  }
+	  
+	  if (!next || PTRNE(nextsnip, next->lastSnip)) {
+	    /* It was a new line */
+
+	    wxMediaLine *newline;
+
+	    newline = Insert(root, FALSE);
+	    newline->snip = asnip->next;
+	    newline->lastSnip = lastSnip;
+	    lastSnip = asnip;
+	    
+	    nextsnip = newline->lastSnip->next;
+	    
+	    for (asnip = newline->snip; PTRNE(asnip, nextsnip); 
+		 asnip = asnip->next)
+	      asnip->line = newline;
+	    
+	    newline->MarkCheckFlow();
+	    newline->MarkRecalculate();
+	    newline->CalcLineLength();
+	  } else {
+	    /* Just pushed to next line */
+	    lastSnip = asnip;
+	    asnip->line = this;
+
+	    next->snip = asnip->next;
+
+	    nextsnip = next->lastSnip->next;
+	    for (asnip = next->snip; PTRNE(asnip, nextsnip);
+		 asnip = asnip->next)
+	      asnip->line = next;
+
+	    next->MarkCheckFlow();
+	    next->MarkRecalculate();
+	    next->CalcLineLength();
+	  }
+
+	  CalcLineLength();
+	  MarkRecalculate();
+
+	  return TRUE;
+	}
+	asnip->line = this;
+      }
+      /* This line was extended */
+
+      if (asnip) {
+	while (asnip->next && !(asnip->flags & wxSNIP_NEWLINE)) {
+	  asnip->line = this;
+	  if (next && PTREQ(asnip, next->lastSnip)) {
+	    /* a line was deleted */
+	    next->Delete(root);
+	  }
+	  asnip = asnip->next;
+	}
+
+	if (next && PTREQ(asnip, next->lastSnip)) {
+	  /* a line was deleted */
+	  next->Delete(root);
+	}
+
+	lastSnip = asnip;
+      } else {
+	lastSnip = media->lastSnip;
+	while (next)
+	  next->Delete(root);
+      }
+
+      lastSnip->line = this;
+
+      if (next) {
+	asnip = asnip->next;
+	if (PTRNE(next->snip, asnip) || !(next->lastSnip->flags & wxSNIP_NEWLINE)) {
+	  /* Effect can propogate to more lines, merging the
+             next several. (Handle prefixing the remains of the source of
+             the extension to this line onto the next line. Implemented
+             as the next line eating the next->next line.) */
+	  next->snip = asnip;
+	  while (asnip->next && !(asnip->flags & wxSNIP_NEWLINE)) {
+	    if (next->next && PTREQ(asnip, next->next->lastSnip)) {
+	      /* a line was deleted */
+	      next->next->Delete(root);
+	    }
+	    asnip->line = next;
+	    asnip = asnip->next;
+	  }
+	  asnip->line = next;
+	  next->lastSnip = asnip;
+	  if (next->next) {
+	    if (PTREQ(asnip, next->next->lastSnip)) {
+	      /* a line was deleted */
+	      next->next->Delete(root);
+	    } else
+	      next->next->snip = asnip->next;
+	  }
+
+	  next->CalcLineLength();
+	  next->MarkRecalculate();
+	  next->MarkCheckFlow();
+	}
+      }
+
+      CalcLineLength();
+      MarkRecalculate();
+      
+      return TRUE;
+    }
+  }
+
+  if (flags & WXLINE_FLOW_RIGHT) {
+    if (PTRNE(right, NIL) && right->UpdateFlow(root, media, maxWidth, dc))
+      return TRUE;
+    flags -= WXLINE_FLOW_RIGHT;
+  }
+
+  return FALSE;
+}
+
+Bool wxMediaLine::UpdateGraphics(wxMediaEdit *media, wxDC *dc)
+{
+  Bool changed = FALSE;
+
+  if (flags & WXLINE_CALC_LEFT)
+    if (PTRNE(left, NIL) && left->UpdateGraphics(media, dc))
+      changed = TRUE;
+  
+  if (flags & WXLINE_CALC_HERE) {
+    wxSnip *asnip, *next;
+    long maxscroll, scroll;
+    float y, bigwidth;
+    float h, w, descent, space, totalwidth;
+    float maxh, maxbase, maxdescent, maxspace, maxantidescent, maxantispace;
+  
+    y = GetLocation();
+
+    maxbase = maxdescent = maxspace = maxantidescent = maxantispace = 0;
+    totalwidth = 0;
+	
+    maxscroll = 1;
+    scrollSnip = NULL;
+
+    next = lastSnip->next;
+    for (asnip = snip; PTRNE(asnip, next); asnip = asnip->next) {
+      asnip->GetExtent(dc, totalwidth, y, &w, &h, 
+		       &descent, &space);
+
+      int align = asnip->style->GetAlignment();
+	  
+      scroll = asnip->GetNumScrollSteps();
+
+      if (h - descent - space > maxbase)
+	maxbase = h - descent - space;
+	 
+      if (align == wxALIGN_BOTTOM) {
+	if (descent > maxdescent)
+	  maxdescent = descent;
+      } else {
+	if (h - space > maxantispace)
+	  maxantispace = h - space;
+      }
+
+      if (align == wxALIGN_TOP) {
+	if (space > maxspace)
+	  maxspace = space;
+      } else {
+	if (h - descent > maxantidescent)
+	  maxantidescent = h - descent;
+      }
+
+      if (scroll > maxscroll) {
+	scrollSnip = asnip;
+	maxscroll = scroll;
+      }
+	  
+      totalwidth += w;
+    }
+    
+    if (maxantidescent - maxbase > maxspace)
+      maxspace = maxantidescent - maxbase;
+
+    if (maxantispace - maxbase > maxdescent)
+      maxdescent = maxantispace - maxbase;
+
+    lastH = h;
+    lastW = w;
+    topbase = maxspace;
+    bottombase = maxspace + maxbase;
+
+    maxh = maxbase + maxdescent + maxspace;
+	
+    maxh += media->lineSpacing;
+
+    if (this->w > totalwidth)
+      bigwidth = this->w;
+    else
+      bigwidth = totalwidth;
+    bigwidth += CURSOR_WIDTH;
+
+    SetWidth(totalwidth);
+
+    if (maxscroll != this->numscrolls)
+      SetScrollLength(maxscroll);
+
+    if (maxh == this->h)
+      media->RefreshBox(0, y, bigwidth, maxh);
+    else {
+      float bigheight;
+
+      SetHeight(maxh);
+
+      bigwidth = 1e5; /* Really want viewable width, but > ok */
+      if (bigwidth < media->totalWidth)
+	bigwidth = media->totalWidth;
+
+      bigheight = maxh + media->totalHeight;
+      
+      media->RefreshBox(0, y, bigwidth, bigheight);      
+    }
+
+    changed = TRUE;
+  }
+
+  if (flags & WXLINE_CALC_RIGHT)
+    if (PTRNE(right, NIL) && right->UpdateGraphics(media, dc))
+      changed = TRUE;
+
+  flags &= ~CALC_MASK;
+
+  return changed;
+}
+
+/***************************************************************/
+
+long wxMediaLine::Number()
+{
+  return Last()->GetLine() + 1;
+}
+
+wxMediaLine *wxMediaLine::First()
+{
+  wxMediaLine *node;
+  
+  node = this;
+  while (PTRNE(node->left, NIL))
+    node = node->left;
+
+  return node;
+}
+
+wxMediaLine *wxMediaLine::Last()
+{
+  wxMediaLine *node;
+  
+  node = this;
+  while (PTRNE(node->right, NIL))
+    node = node->right;
+
+  return node;  
+}
+
+/***************************************************************/
+
+#ifdef TEST
+
+#include <iostream.h>
+
+wxMgediaLine *root = NIL;
+int numLines = 0;
+
+main()
+{
+  long i;
+  wxMediaLine *line;
+  char command[256];
+
+  line->Insert(&root);
+  numLines++;
+
+  while (1) {
+    cout << "Lines:\n";
+    for (i = 0; i < numLines; i++) {
+      line = root->FindLine(i);
+      cout << "  " << i 
+        << " (" << line->GetLine() << ")"
+	<< ": [" << ((void *)line->prev) << ","
+	         << ((void *)line) << ","
+	         << ((void *)line->next) << "]"
+	<< " pos=" << line->GetPosition()
+	<< " len=" << line->len
+	<< " scr=" << line->GetScroll()
+	<< " slen=" << line->numscrolls
+	<< " loc=" << line->GetLocation()
+	<< " ht=" << line->h
+	<< "\n";
+    }
+    
+    cout << "Line? ";
+    cin >> i;
+    if (i >= numLines)
+      return 0;
+    
+    line = root->FindLine(i);
+    cout << "[" << ((void *)line) << "]\n";    
+
+    cout << "Command? [i,d,l,h,s,q] ";
+    cin >> command;
+    if (command[0] == 'i') {
+      line->Insert(&root);
+      numLines++;
+    } else if (command[0] == 'd') {
+      line->Delete(&root);
+      --numLines;
+    } else if (command[0] == 'l') {
+      cout << "How many? ";
+      cin >> i;
+      if (i >= 0)
+	line->SetLength(i);
+    } else if (command[0] == 's') {
+      cout << "How many? ";
+      cin >> i;
+      if (i >= 0)
+	line->SetScrollLength(i);
+    } else if (command[0] == 'h') {
+      float h;
+      cout << "How tall? ";
+      cin >> h;
+      if (h >= 0.0)
+	line->SetHeight(h);
+    } else if (command[0] == 'q') {
+      return 0;
+    }
+  }
+}
+
+#endif
diff --git a/src/mred/wxme/wx_mline.h b/src/mred/wxme/wx_mline.h
new file mode 100644
index 0000000..e0074e7
--- /dev/null
+++ b/src/mred/wxme/wx_mline.h
@@ -0,0 +1,97 @@
+
+#define CURSOR_WIDTH 2
+
+const unsigned long
+  WXLINE_RED = 0x1,
+  WXLINE_BLACK = 0x2,
+  WXLINE_MAX_W_HERE = 0x4,
+  WXLINE_MAX_W_LEFT = 0x8,
+  WXLINE_MAX_W_RIGHT = 0x10,
+  WXLINE_CALC_HERE = 0x20,
+  WXLINE_CALC_LEFT = 0x40,
+  WXLINE_CALC_RIGHT = 0x80,
+  WXLINE_FLOW_HERE = 0x100,
+  WXLINE_FLOW_LEFT = 0x200,
+  WXLINE_FLOW_RIGHT = 0x400,
+  WXLINE_STARTS_PARA = 0x800;
+
+/* WARNING: This structure is *NOT* garbage-collected.
+   It could be, but it doesn't need to be right now. */
+
+class wxMediaLine /* : wxObject - Uncomment for GC */
+{
+ public:
+  wxMediaLine *next, *prev, *parent, *left, *right;
+  long flags;
+
+  /* relative values: */
+  long line;   // line number
+  long pos;    // starting item position
+  long scroll; // starting scroll step
+  long parno;  // paragraph number
+  float y;     // starting y location
+  
+  float maxWidth;
+
+  class wxSnip *snip, *lastSnip, *scrollSnip;
+
+  long len, numscrolls;
+  float lastH, lastW; /* height/width of last snip in line */
+  float h, w; /* height/width of line */
+  float bottombase, topbase; /* bottom baseline, top baseline (relative) */
+
+  wxMediaLine();
+  ~wxMediaLine();
+
+  wxMediaLine *Insert(wxMediaLine **root, Bool before = TRUE);
+  void Delete(wxMediaLine **root);
+
+  wxMediaLine *FindLine(long line);
+  wxMediaLine *FindPosition(long pos);
+  wxMediaLine *FindScroll(long scroll);
+  wxMediaLine *FindLocation(float y);
+  wxMediaLine *FindParagraph(long parnp);
+
+  long GetLine();
+  long GetPosition();
+  long GetScroll();
+  float GetLocation();
+  long GetParagraph();
+
+  float ScrollOffset(long p);
+  long FindExtraScroll(float y);
+
+  void SetLength(long len);
+  void CalcLineLength();
+  void SetScrollLength(long numScrolls);
+  void SetHeight(float h);
+
+  void SetWidth(float w);
+  void MarkRecalculate();
+  void MarkCheckFlow();
+
+  void SetStartsParagraph(Bool starts);
+  inline int StartsParagraph(void) 
+    { return (flags & WXLINE_STARTS_PARA) ? 1 : 0; };
+
+  wxMediaLine *GetRoot();
+
+  Bool UpdateFlow(wxMediaLine **root, wxMediaEdit *, float maxw, wxDC *dc);
+  Bool UpdateGraphics(wxMediaEdit *media, wxDC *dc);
+
+  long Number();
+  wxMediaLine *First();
+  wxMediaLine *Last();
+
+ private:
+  void AdjustOffsets(wxMediaLine *newchild);
+  void DeadjustOffsets(wxMediaLine *oldchild);
+
+  void RotateLeft(wxMediaLine **root);
+  void RotateRight(wxMediaLine **root);
+  void AdjustNeedCalc(Bool recur = FALSE);
+  void AdjustNeedFlow(Bool recur = FALSE);
+  void AdjustMaxWidth(Bool recur = FALSE);
+};
+
+extern wxMediaLine *NIL;
diff --git a/src/mred/wxme/wx_mpbrd.cxx b/src/mred/wxme/wx_mpbrd.cxx
new file mode 100644
index 0000000..298f214
--- /dev/null
+++ b/src/mred/wxme/wx_mpbrd.cxx
@@ -0,0 +1,2755 @@
+/*
+ * File:        wx_mpbd.cc
+ * Purpose:     wxMediaPasteboard implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_utils.h"
+#include "wx_media.h"
+#include "wx_gcrct.h"
+#include "wx_ptreq.h"
+#include <string.h>
+
+#define LINE_HEIGHT 16
+
+#define DOT_WIDTH 5
+#define HALF_DOT_WIDTH 2
+
+static wxCursor *arrow = NULL;
+  
+static wxSnipLocation *DoXSnipLoc(wxList *snipLocationList, wxSnip *s)
+{
+  wxNode *n = snipLocationList->Find((long)s);
+  if (n)
+    return (wxSnipLocation *)n->Data();
+  else
+    return NULL;
+}
+#define SnipLoc(snip) ((wxSnipLocation *)snipLocationList->Find((long)snip)->Data())
+#define XSnipLoc(snip) DoXSnipLoc(snipLocationList, snip)
+
+inline Bool Inbox(float lx, float x)
+{ 
+  return ((lx - HALF_DOT_WIDTH <= x)
+	  && (lx - HALF_DOT_WIDTH + DOT_WIDTH >= x));
+}
+
+class wxSnipLocation : public wxObject
+{
+ public:
+  float x, y, w, h, r, b, hm, vm;
+  float startx, starty;
+  Bool selected, needResize;
+  wxSnip *snip;
+
+  void Resize(wxDC *dc);
+};
+
+static wxBrush *blackBrush = NULL, *whiteBrush = NULL, *rbBrush = NULL;
+static wxPen *invisiPen = NULL, *rbPen = NULL;
+
+extern void *wxMediaFileIOReady;
+
+#ifdef wx_mac
+extern void wxMediaSetFileCreatorType(char *file, Bool is_binary);
+#endif
+
+/**********************************************************************/
+
+wxMediaPasteboard::wxMediaPasteboard()
+{
+  sizeCacheInvalid = TRUE;
+  updateNonemtpy = FALSE;
+  locked = FALSE;
+
+  snips = lastSnip = NULL;
+  snipLocationList = new wxList(wxKEY_INTEGER);
+  snipLocationList->DeleteContents(TRUE);
+
+  sequence = 0;
+
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_MEDIA_PASTEBOARD;
+#endif
+  bufferType = wxPASTEBOARD_BUFFER;
+
+  totalWidth = totalHeight = realWidth = realHeight = 0;
+
+  dragable = TRUE;
+  selectionVisible = TRUE;
+
+  sequenceStreak = FALSE;
+
+  dragging = rubberband = FALSE;
+
+  if (!blackBrush) {
+    blackBrush = wxTheBrushList->FindOrCreateBrush("BLACK", wxSOLID);
+    whiteBrush = wxTheBrushList->FindOrCreateBrush("WHITE", wxSOLID);
+    invisiPen = wxThePenList->FindOrCreatePen("BLACK", 1, wxTRANSPARENT);
+    rbBrush = wxTheBrushList->FindOrCreateBrush("BLACK", wxTRANSPARENT);
+    rbPen = wxThePenList->FindOrCreatePen("BLACK", 1, wxDOT);
+  }
+
+  snipAdmin = new wxStandardSnipAdmin(this);
+
+  needResize = FALSE;
+
+  keepSize = FALSE;
+
+  scrollStep = LINE_HEIGHT;
+
+  maxWidth = minWidth = minHeight = maxHeight = 0.0;
+}
+
+wxMediaPasteboard::~wxMediaPasteboard()
+{
+  wxSnip *snip, *next;
+  for (snip = snips; snip; snip = next) {
+    next = snip->next;
+    delete snip;
+  }
+
+  delete snipLocationList;
+
+  delete snipAdmin;
+}
+
+void wxMediaPasteboard::RubberBand(float x, float y, float w, float h)
+{
+  wxPen *oldPen;
+  wxBrush *oldBrush;
+  wxDC *dc;
+  float vx, vy, vw, vh, b, r, dx, dy;
+
+  if (!admin)
+    return;
+
+  if (!w & !h)
+    return;
+
+  if (w < 0) {
+    x += w;
+    w = -w;
+  }
+  r = x + w;
+  if (h < 0) {
+    y += h;
+    h = -h;
+  }
+  b = y + h;
+
+  admin->GetView(&vx, &vy, &vw, &vh);
+
+  if (x < vx)
+    x = vx;
+  if (y < vy)
+    y = vy;
+  if (r > vx + vw)
+    r = vx + vw;
+  if (b > vy + vh)
+    b = vy + vh;
+
+  if (x >= r || y >= b)
+    return;
+
+  dc = admin->GetDC(&dx, &dy);
+  
+  oldPen = dc->GetPen();
+  oldBrush = dc->GetBrush();
+  dc->SetPen(rbPen);
+  dc->SetBrush(rbBrush);
+  dc->SetLogicalFunction(wxXOR);
+  
+  dc->DrawRectangle(x - dx, y - dy, 
+		    r - x + GC_RECT_BRUSH_EXTEND, 
+		    b - y + GC_RECT_BRUSH_EXTEND);
+  
+  dc->SetLogicalFunction(wxCOPY);
+  dc->SetPen(oldPen);
+  dc->SetBrush(oldBrush);;
+}
+
+wxCursor *wxMediaPasteboard::AdjustCursor(wxMouseEvent &event)
+{
+  float scrollx, scrolly;
+  float x, y;
+  wxSnip *snip;
+  wxDC *dc;
+  wxCursor *c;
+
+  if (!admin)
+    return NULL;
+
+  dc = admin->GetDC(&scrollx, &scrolly);
+  if (!dc)
+    return NULL;
+
+  x = event.x + scrollx;
+  y = event.y + scrolly;
+
+  if (!customCursorOverrides) {
+
+    if (caretSnip && event.Dragging()) {
+      float x, y;
+      GetSnipLocation(caretSnip, &x, &y);
+      c = caretSnip->AdjustCursor(dc, x - scrollx, y - scrolly, x, y, event);
+      if (c)
+	return c;
+    }
+    
+    snip = FindSnip(x, y);
+    
+    if (snip && (snip == caretSnip)) {
+      float x, y;
+      GetSnipLocation(caretSnip, &x, &y);
+      c = snip->AdjustCursor(dc, x - scrollx, y - scrolly, x, y, event);
+      if (c)
+	return c;
+    }
+  }
+  
+  if (customCursor)
+    return customCursor;
+
+  if (!arrow)
+    arrow = new wxCursor(wxCURSOR_ARROW);
+
+  return arrow;
+}
+
+void wxMediaPasteboard::OnEvent(wxMouseEvent &event)
+{
+  float x, y, scrollx, scrolly;
+  wxSnip *snip;
+  wxSnipLocation *loc;
+  wxDC *dc;
+
+  if (!admin)
+    return;
+
+  if (event.ButtonDown() || caretSnip) {
+    /* First, find clicked-on snip: */
+    x = event.x;
+    y = event.y;
+    
+    dc = admin->GetDC(&scrollx, &scrolly);
+    y += scrolly;
+    x += scrollx;
+  } else {
+    x = y = 0;
+    dc = NULL;
+  }
+
+  if (event.ButtonDown())
+    snip = FindSnip(x, y);
+  else
+    snip = caretSnip;
+
+  if (caretSnip && PTREQ(snip, caretSnip)) {
+    loc = SnipLoc(caretSnip);
+    caretSnip->OnEvent(dc, loc->x, loc->y, x - scrollx, y - scrolly, event);
+    return;
+  }
+
+  OnLocalEvent(event);
+}
+
+void wxMediaPasteboard::OnDefaultEvent(wxMouseEvent& event)
+{
+  float x, y, scrollx, scrolly;
+  wxSnip *snip;
+  wxSnipLocation *loc;
+  wxDC *dc;
+  Bool click;
+
+  if (!admin)
+    return;
+
+  /* First, find clicked-on snip: */
+  x = event.x;
+  y = event.y;
+  
+  dc = admin->GetDC(&scrollx, &scrolly);
+  y += scrolly;
+  x += scrollx;
+
+  InteractiveAdjustMouse(&x, &y);
+
+  if (event.ButtonDown() 
+      || (event.Moving() && !event.Dragging())
+      || event.ButtonUp()) {
+    Bool update = FALSE;
+
+    keepSize = FALSE;
+    if (dragging) {
+      if (resizing) {
+	BeginEditSequence();
+	/* Move & resize back without Undo */
+	if (sizedxm < 0 || sizedym < 0)
+	  MoveTo(resizing, origX, origY);
+	Resize(resizing, origW, origH);
+	dragging = FALSE;
+	/* Re-move and re-size with undo: */
+	DoEventResize(lastX, lastY);
+	AfterInteractiveResize(resizing);
+	EndEditSequence();
+	resizing = NULL;
+      } else {
+	FinishDragging();
+      }
+    }
+    if (rubberband) {
+      rubberband = FALSE;
+      RubberBand(startX, startY, lastX - startX, lastY - startY);
+      AddSelected(startX, startY, lastX - startX, lastY - startY);
+      update = TRUE;
+    }
+
+    if (update) {
+      UpdateAll();
+    }
+  }
+
+  click = FALSE;
+  if (event.ButtonDown())
+    click = TRUE;
+  if (event.Dragging() && !dragging && !rubberband)
+    click = TRUE;
+
+  if (click) {
+    snip = FindSnip(x, y);
+
+    if (dragable) {
+      if (snip) {
+	loc = SnipLoc(snip);
+	origX = loc->x;
+	origY = loc->y;
+	origW = loc->w;
+	origH = loc->h;
+	if (!loc->selected) {
+	  if (!event.shiftDown)
+	    NoSelected();
+	  AddSelected(snip);
+	  InitDragging();
+	} else {
+	  long interval;
+
+	  interval = event.timeStamp - lastTime;
+	  if (interval < 0)
+	    interval = -interval;
+	  if (event.ButtonDown() && (interval < map->GetDoubleClickInterval()))
+	    OnDoubleClick(snip, event);
+	  else {
+	    if (FindDot(loc, x, y, &sizedxm, &sizedym))
+	      resizing = snip;
+	    InitDragging();
+	  }
+	}
+        if (event.ButtonDown())
+	  lastTime = event.timeStamp;
+      } else {
+	if (!event.shiftDown)
+	  NoSelected();
+	SetCaretOwner(NULL);
+	rubberband = TRUE;
+      }
+      startX = lastX = x;
+      startY = lastY = y;
+    } else
+      SetCaretOwner(snip);
+
+    return;
+  }
+
+  if (dragable) {
+    if (event.Dragging()) {
+      if (rubberband) {
+	/* Erase old */
+	RubberBand(startX, startY, lastX - startX, lastY - startY);
+	/* Draw new: */
+	RubberBand(startX, startY, x - startX, y - startY);
+      } else {
+	if (resizing)
+	  DoEventResize(x, y);
+	else {
+	  DoEventMove(x, y);
+	}
+      }
+      lastX = x;
+      lastY = y;
+    }
+  }
+}
+
+void wxMediaPasteboard::OnDoubleClick(wxSnip *snip, wxMouseEvent&)
+{
+  if (snip->flags & wxSNIP_HANDLES_EVENTS) {
+    NoSelected();
+    SetCaretOwner(snip);
+  }
+}
+
+void wxMediaPasteboard::OnChar(wxKeyEvent &event)
+{
+  float x, y, scrollx, scrolly;
+  wxSnipLocation *loc;
+  wxDC *dc;
+
+  if (!admin)
+    return;
+  
+  x = event.x;
+  y = event.y;
+
+  dc = admin->GetDC(&scrollx, &scrolly);
+  y += scrolly;
+  x += scrollx;
+
+  if (caretSnip) {
+    loc = SnipLoc(caretSnip);
+    caretSnip->OnChar(dc, loc->x, loc->y, x - scrollx, y - scrolly, event);
+    return;
+  }
+
+  OnLocalChar(event);
+}
+
+void wxMediaPasteboard::OnDefaultChar(wxKeyEvent &event)
+{
+  long code;
+
+  if (!admin)
+    return;
+
+  code = event.KeyCode();
+
+  switch(code) {
+    case WXK_BACK:
+    case WXK_DELETE:
+      Delete();
+      break;
+    case WXK_RIGHT:
+      Move(1, 0);
+      break;
+    case WXK_LEFT:
+      Move(-1, 0);
+      break;
+    case WXK_UP:
+      Move(0, -1);
+      break;
+    case WXK_DOWN:
+      Move(0, 1);
+      break;
+    }
+}
+
+void wxMediaPasteboard::InitDragging(void)
+{
+  wxSnip *s = NULL;
+
+  if (resizing) {
+    if (!OnInteractiveResize(resizing)) {
+      resizing = NULL;
+      return;
+    }
+  } else
+    if (!OnInteractiveMove())
+      return;
+
+  dragging = TRUE;
+  keepSize = TRUE;
+
+  while ((s = FindNextSelectedSnip(s))) {
+    wxSnipLocation *loc;
+    loc = SnipLoc(s);
+    loc->startx = loc->x;
+    loc->starty = loc->y;
+  }
+}
+
+void wxMediaPasteboard::FinishDragging(void)
+{
+  wxSnip *s = NULL;
+
+  BeginEditSequence();
+  /* Move back without Undo and remember final */
+  while ((s = FindNextSelectedSnip(s))) {
+    float x, y;
+    wxSnipLocation *loc;
+    loc = SnipLoc(s);
+    x = loc->startx;
+    y = loc->starty;
+    loc->startx = loc->x;
+    loc->starty = loc->y;
+    MoveTo(s, x, y);
+  }
+  dragging = FALSE;
+  /* Move to final position with undo: */
+  s = NULL;
+  while ((s = FindNextSelectedSnip(s))) {
+    wxSnipLocation *loc;
+    loc = SnipLoc(s);
+    MoveTo(s, loc->startx, loc->starty);
+  }
+
+  AfterInteractiveMove();
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::DoEventMove(float eventX, float eventY)
+{
+  wxSnip *s = NULL;
+  float dx, dy;
+  
+  dx = eventX - startX;
+  dy = eventY - startY;
+
+  BeginEditSequence();
+
+  while ((s = FindNextSelectedSnip(s))) {
+    wxSnipLocation *loc;
+    float x, y;
+
+    loc = SnipLoc(s);
+    x = loc->startx + dx;
+    y = loc->starty + dy;
+    InteractiveAdjustMove(s, &x, &y);
+    MoveTo(s, x, y);
+  }
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::DoEventResize(float eventX, float eventY)
+{
+  float Dx, Dy, w, h, x, y;
+  
+  Dx = eventX - startX;
+  Dy = eventY - startY;
+
+  w = origW + Dx * sizedxm;
+  h = origH + Dy * sizedym;
+  
+  if (w < 0)
+    w = 0;
+  if (h < 0)
+    h = 0;
+
+  InteractiveAdjustResize(resizing, &w, &h);
+  
+  if (w < 0)
+    w = 0;
+  if (h < 0)
+    h = 0;
+  
+  x = origX;
+  if (sizedxm < 0) {
+    x += (origW - w);
+  }
+  y = origY;
+  if (sizedym < 0) {
+    y += (origH - h);
+  }
+  
+  BeginEditSequence();
+  
+  if (Resize(resizing, w, h)) {
+    if ((sizedxm < 0 || sizedym < 0))
+      MoveTo(resizing, x, y);
+  }
+  
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::InteractiveAdjustMouse(float *x, float *y)
+{
+  if (*x < 0)
+    *x = 0;
+  if (*y < 0)
+    *y = 0;
+}
+
+void wxMediaPasteboard::InteractiveAdjustResize(wxSnip *, float *, float *)
+{
+  /* Do nothing */
+}
+
+void wxMediaPasteboard::InteractiveAdjustMove(wxSnip *, float *x, float *y)
+{
+  if (*x < 0)
+    *x = 0;
+  if (*y < 0)
+    *y = 0;
+}
+
+
+/***************************************************************************/
+
+void wxMediaPasteboard::SetSelected(wxSnip *snip)
+{
+  BeginEditSequence();
+  NoSelected();
+  AddSelected(snip);
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::DoSelect(wxSnip *snip, Bool on)
+{
+  wxSnipLocation *loc;
+
+  if ((loc = XSnipLoc(snip))) {
+    if (loc->selected != on) {
+      if (OnSelect(snip, on)) {
+	loc->selected = on;
+	AfterSelect(snip, on);
+	UpdateLocation(loc);
+      }
+    }
+  }
+}
+
+void wxMediaPasteboard::AddSelected(wxSnip *snip)
+{
+  DoSelect(snip, TRUE);
+}
+
+void wxMediaPasteboard::RemoveSelected(wxSnip *snip)
+{
+  DoSelect(snip, FALSE);
+}
+
+void wxMediaPasteboard::AddSelected(float x, float y, float w, float h)
+{
+  wxSnip *s;
+  float r, b;
+
+  if (w < 0) {
+    x += w;
+    w = -w;
+  }
+  if (h < 0) {
+    y += h;
+    h = -h;
+  }
+
+  r = x + w;
+  b = y + h;
+
+  BeginEditSequence();
+
+  for (s = snips; s; s = s->next) {
+    wxSnipLocation *loc = SnipLoc(s);
+    if (loc
+	&& !loc->selected
+	&& (loc->x <= r)
+	&& (loc->y <= b)
+	&& (loc->r >= x)
+	&& (loc->b >= y)) {
+      AddSelected(s);
+    }
+  }
+  
+  EndEditSequence();
+}
+				  
+void wxMediaPasteboard::SelectAll(void)
+{
+  wxSnip *s;
+
+  BeginEditSequence();
+
+  for (s = snips; s; s = s->next)
+    AddSelected(s);
+  
+  EndEditSequence();
+}
+				  
+void wxMediaPasteboard::NoSelected()
+{
+  wxSnip *s;
+
+  BeginEditSequence();
+
+  for (s = snips; s; s = s->next)
+    RemoveSelected(s);
+  
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::Insert(wxSnip *snip, wxSnip *before, float x, float y)
+{
+  wxSnipLocation *loc;
+  wxSnip *search;
+
+  if (userLocked)
+    return;
+
+  if (snip->IsOwned())
+    return;
+
+  if (!snip->snipclass)
+    wxMessageBox("Inserting a snip without a class."
+		 " Data will be lost if you try to save the file.", 
+		 "Warning");
+
+  BeginEditSequence();
+  if (!OnInsert(snip, before, x, y)) {
+    EndEditSequence();
+    return;
+  }
+
+  for (search = snips; search && (search != before); search = search->next);
+  
+  snip->next = search;
+  if (snip->next) {
+    snip->prev = search->prev;
+    snip->next->prev = snip;
+  } else {
+    snip->prev = lastSnip;
+    lastSnip = snip;
+  }
+  if (snip->prev)
+    snip->prev->next = snip;
+  else
+    snips = snip;
+
+  loc = new wxSnipLocation;
+  loc->x = x;
+  loc->y = y;
+  loc->snip = snip;
+  loc->needResize = TRUE;
+  loc->selected = FALSE;
+  snipLocationList->Append((long)snip, loc);
+
+  snip->style = styleList->Convert(snip->style);
+  if (PTREQ(snip->style, styleList->BasicStyle()))
+    snip->style = styleList->FindNamedStyle(STD_STYLE);
+
+  snip->SizeCacheInvalid();
+
+  SnipSetAdmin(snip, snipAdmin);
+
+  if (!noundomode)
+    AddUndo(new wxInsertSnipRecord(snip, sequenceStreak));
+  if (sequence)
+    sequenceStreak = TRUE;
+
+  changed = TRUE;
+
+  if (!modified)
+    SetModified(TRUE);
+
+  AfterInsert(snip, before, x, y);
+
+  needResize = TRUE;
+  UpdateLocation(loc);
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::Insert(wxSnip *snip, float x, float y)
+{
+  Insert(snip, snips, x, y);
+}
+
+void wxMediaPasteboard::Insert(wxSnip *snip)
+{
+  float x, y;
+
+  GetCenter(&x, &y);
+  Insert(snip, x, y);
+}
+
+void wxMediaPasteboard::Insert(wxSnip *snip, wxSnip *before)
+{
+  float x, y;
+
+  GetCenter(&x, &y);
+  Insert(snip, before, x, y);
+}
+
+void wxMediaPasteboard::Delete()
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+  wxDeleteSnipRecord *del;
+
+  if (userLocked)
+    return;
+
+  del = new wxDeleteSnipRecord(sequenceStreak);
+  if (sequence)
+    sequenceStreak = TRUE;
+
+  BeginEditSequence();
+
+  for (node = snipLocationList->First(); node; node = node->Next()) {
+    loc = (wxSnipLocation *)node->Data();
+    if (loc->selected) 
+      _Delete(loc->snip, del);
+  }
+
+  if (!noundomode)
+    AddUndo(del);
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::Erase()
+{
+  wxSnip *snip, *next;
+  wxDeleteSnipRecord *del;
+
+  if (userLocked)
+    return;
+
+  del = new wxDeleteSnipRecord(sequenceStreak);
+  if (sequence)
+    sequenceStreak = TRUE;
+
+  BeginEditSequence();
+  for (snip = snips; snip; snip = next) {
+    next = snip->next;
+    _Delete(snip, del);
+  }
+
+  if (!noundomode)
+    AddUndo(del);
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::_Delete(wxSnip *del_snip,
+				wxDeleteSnipRecord *del)
+{
+  wxSnip *snip;
+  wxNode *node;
+  wxSnipLocation *loc;
+  Bool updateCursor = FALSE;
+
+  for (snip = snips; snip; snip = snip->next) {
+    if (PTREQ(snip, del_snip)) {
+      BeginEditSequence();
+
+      if (!OnDelete(del_snip)) {
+	EndEditSequence();
+	return;
+      }
+
+      if (del_snip == caretSnip) {
+	caretSnip->OwnCaret(FALSE);
+	caretSnip = NULL;
+	updateCursor = TRUE;
+      }
+
+      UpdateSnip(del_snip);
+
+      if (!snip->prev)
+	snips = snip->next;
+      else
+	snip->prev->next = snip->next;
+      if (!snip->next)
+	lastSnip = snip->prev;
+      else
+	snip->next->prev = snip->prev;
+
+      node = snipLocationList->Find((long)snip);
+      snipLocationList->DeleteNode(node);
+      loc = (wxSnipLocation *)node->Data();
+      if (del)
+	del->InsertSnip(snip, snip->next, loc->x, loc->y);
+      snip->next = snip->prev = NULL;
+
+      snip->flags += wxSNIP_CAN_DISOWN;
+      SnipSetAdmin(snip, NULL);
+      snip->flags -= wxSNIP_CAN_DISOWN;
+
+      if (!modified)
+	SetModified(TRUE);
+
+      AfterDelete(del_snip);
+      changed = TRUE;
+
+      EndEditSequence();
+    }
+  }  
+
+  if (updateCursor)
+    if (admin)
+      admin->UpdateCursor();
+}
+
+void wxMediaPasteboard::Delete(wxSnip *del_snip)
+{
+  wxDeleteSnipRecord *del;
+
+  if (userLocked)
+    return;
+
+  del = new wxDeleteSnipRecord(sequenceStreak);
+  if (sequence)
+    sequenceStreak = TRUE;
+
+  _Delete(del_snip, del);
+
+  if (!noundomode)
+    AddUndo(del);
+}
+
+void wxMediaPasteboard::Remove(wxSnip *del_snip)
+{
+  if (userLocked)
+    return;
+
+  _Delete(del_snip, NULL);
+}
+
+void wxMediaPasteboard::MoveTo(wxSnip *snip, float x, float y)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+  wxMoveSnipRecord *rec;
+
+  if (userLocked)
+    return;
+
+  if ((node = snipLocationList->Find((long)snip))) {
+    loc = (wxSnipLocation *)node->Data();
+
+    if ((loc->x == x) && (loc->y == y))
+      return;
+
+    BeginEditSequence();
+    if (!OnMoveTo(snip, x, y, dragging)) {
+      EndEditSequence();
+      return;
+    }
+
+    UpdateLocation(loc);
+
+    if (!dragging) {
+      rec = new wxMoveSnipRecord(loc->snip, loc->x, loc->y, 
+				 FALSE, sequenceStreak);
+      if (sequence)
+	sequenceStreak = TRUE;
+      if (!noundomode)
+	AddUndo(rec);
+    }
+
+    loc->x = x;
+    loc->y = y;
+    loc->r = x + loc->w;
+    loc->b = y + loc->h;
+    loc->hm = x + loc->w/2;
+    loc->vm = y + loc->h/2;
+    UpdateLocation(loc);
+
+    if (!dragging && !modified)
+	SetModified(TRUE);
+
+    AfterMoveTo(snip, x, y, dragging);
+
+    needResize = TRUE;
+
+    EndEditSequence();
+  }
+}
+
+void wxMediaPasteboard::Move(wxSnip *snip, float dx, float dy)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  if (userLocked)
+    return;
+
+  if ((node = snipLocationList->Find((long)snip))) {
+    loc = (wxSnipLocation *)node->Data();
+    MoveTo(snip, loc->x + dx, loc->y + dy);
+  }
+}
+
+void wxMediaPasteboard::Move(float dx, float dy)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  if (userLocked)
+    return;
+
+  BeginEditSequence();
+
+  for (node = snipLocationList->First(); node; node = node->Next()) {
+    loc = (wxSnipLocation *)node->Data();
+    if (loc->selected)
+      Move(loc->snip, dx, dy);
+  }
+
+  EndEditSequence();
+}
+
+Bool wxMediaPasteboard::Resize(wxSnip *snip, float w, float h)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+  float oldw, oldh;
+  Bool rv;
+  
+  if (!admin)
+    return FALSE;
+
+  if (!(node = snipLocationList->Find((long)snip)))
+    return FALSE;
+
+  loc = (wxSnipLocation *)node->Data();
+  oldw = loc->w;
+  oldh = loc->h;
+
+  BeginEditSequence();
+  if (!OnResize(snip, w, h)) {
+    EndEditSequence();
+    return FALSE;
+  }
+
+  if (!snip->Resize(w, h))
+    rv = FALSE;
+  else {
+    if (!dragging) {
+      if (!noundomode)
+	AddUndo(new wxResizeSnipRecord(snip, oldw, oldh, sequenceStreak));
+      if (sequence)
+	sequenceStreak = TRUE;
+    }
+    rv = TRUE;
+  }
+
+  if (rv)
+    changed = TRUE;
+
+  if (rv && !dragging && !modified)
+    SetModified(TRUE);
+
+  AfterResize(snip, w, h, rv);
+
+  EndEditSequence();
+
+  return rv;
+}
+
+void wxMediaPasteboard::ChangeStyle(wxStyleDelta *delta)
+{ 
+  ChangeStyle(delta, NULL);
+}
+
+void wxMediaPasteboard::ChangeStyle(wxStyle *style, wxSnip *snip)
+{
+  _ChangeStyle(style, NULL, snip);
+}
+
+void wxMediaPasteboard::ChangeStyle(wxStyleDelta *delta, wxSnip *snip)
+{
+  _ChangeStyle(NULL, delta, snip);
+}
+ 
+void wxMediaPasteboard::_ChangeStyle(wxStyle *style, wxStyleDelta *delta, 
+				     wxSnip *snip)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+  wxStyleChangeSnipRecord *rec;
+  Bool didit = FALSE;
+
+  if (userLocked)
+    return;
+
+  rec = new wxStyleChangeSnipRecord(sequenceStreak);
+  if (sequence)
+    sequenceStreak = TRUE;
+
+  if (!style && !delta)
+    style = styleList->FindNamedStyle(STD_STYLE);
+
+  BeginEditSequence();
+
+  if (snip) {
+    rec->AddStyleChange(snip, snip->style);
+    if (style)
+      snip->style = style;
+    else
+      snip->style = styleList->FindOrCreateStyle(snip->style, delta);
+    snip->SizeCacheInvalid();
+    UpdateSnip(snip);
+    didit = TRUE;
+  } else {
+    for (node = snipLocationList->First(); node; node = node->Next()) {
+      loc = (wxSnipLocation *)node->Data();
+      if (loc->selected) {
+	rec->AddStyleChange(loc->snip, loc->snip->style);
+	if (style)
+	  loc->snip->style = style;
+	else
+	  loc->snip->style = styleList->FindOrCreateStyle(loc->snip->style, 
+							  delta);
+	loc->snip->SizeCacheInvalid();
+	loc->needResize = TRUE;
+	needResize = TRUE;
+	UpdateLocation(loc);
+	didit = TRUE;
+      }
+    }
+  }
+  
+  if (didit) {
+    if (!noundomode)
+      AddUndo(rec);
+
+    changed = TRUE;
+    if (!modified)
+      SetModified(TRUE);
+  }
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::Raise(wxSnip *snip)
+{
+  wxSnip *prev;
+
+  if (userLocked)
+    return;
+
+  if (!snipLocationList->Find((long)snip))
+    return;
+
+  prev = snip->prev;
+  if (prev) {
+    prev->next = snip->next;
+    if (!snip->next)
+      lastSnip = prev;
+    else
+      snip->next->prev = prev;
+    snip->prev = prev->prev;
+    prev->prev = snip;
+    if (!snip->prev)
+      snips = snip;
+    else
+      snip->prev->next = snip;
+
+    changed = TRUE;
+    if (!modified)
+      SetModified(TRUE);
+
+    UpdateSnip(snip);
+  }
+}
+
+void wxMediaPasteboard::Lower(wxSnip *snip)
+{
+  wxSnip *next;
+
+  if (userLocked)
+    return;
+
+  if (!snipLocationList->Find((long)snip))
+    return;
+  
+  next = snip->next;
+  if (next) {
+    next->prev = snip->prev;
+    if (!snip->prev)
+      snips = next;
+    else
+      snip->prev->next = next;
+    snip->next = next->next;
+    next->next = snip;
+    if (!snip->next)
+      lastSnip = snip;
+    else
+      snip->next->prev = snip;
+
+    changed = TRUE;
+    if (!modified)
+      SetModified(TRUE);
+
+    UpdateSnip(snip);
+  }
+}
+
+void wxMediaPasteboard::SetBefore(wxSnip *snip, wxSnip *before)
+{
+  if (userLocked)
+    return;
+
+  if (!before)
+    before = snips;
+
+  if (!snipLocationList->Find((long)snip)
+      || !snipLocationList->Find((long)before))
+    return;
+
+  if (snip == before)
+    return;
+  
+  /* Remove snip from current pos: */
+  if (snip->prev)
+    snip->prev->next = snip->next;
+  else
+    snips = snip->next;
+  if (snip->next)
+    snip->next->prev = snip->prev;
+  else
+    lastSnip = snip->prev;
+
+  /* Insert before `before': */
+  snip->prev = before->prev;
+  snip->next = before;
+  before->prev = snip;
+  if (snip->prev)
+    snip->prev->next = snip;
+  else
+    snips = snip;
+
+  changed = TRUE;
+  if (!modified)
+    SetModified(TRUE);
+
+  UpdateSnip(snip);
+}
+
+void wxMediaPasteboard::SetAfter(wxSnip *snip, wxSnip *after)
+{
+  if (userLocked)
+    return;
+
+  if (!after)
+    after = lastSnip;
+
+  if (!snipLocationList->Find((long)snip)
+      || !snipLocationList->Find((long)after))
+    return;
+
+  if (snip == after)
+    return;
+  
+  /* Remove snip from current pos: */
+  if (snip->prev)
+    snip->prev->next = snip->next;
+  else
+    snips = snip->next;
+  if (snip->next)
+    snip->next->prev = snip->prev;
+  else
+    lastSnip = snip->prev;
+
+  /* Insert after `after': */
+  snip->next = after->next;
+  snip->prev = after;
+  after->next = snip;
+  if (snip->next)
+    snip->next->prev = snip;
+  else
+    lastSnip = snip;
+
+  changed = TRUE;
+  if (!modified)
+    SetModified(TRUE);
+
+  UpdateSnip(snip);
+}
+
+wxSnip *wxMediaPasteboard::SnipSetAdmin(wxSnip *snip, wxSnipAdmin *a)
+{
+  wxSnipAdmin *orig_admin = snip->GetAdmin();
+
+  /* Lock during SetAdmin! */
+  snip->SetAdmin(a);
+
+  if (snip->GetAdmin() != a) {
+    /* Something went wrong. */
+    if (!a && (snip->GetAdmin() == orig_admin)) {
+      /* Force admin to NULL. */
+      snip->wxSnip::SetAdmin(NULL);
+    } else if (a) {
+      /* Snip didn't accept membership into this buffer. Give up on it. */
+      wxSnip *naya = new wxSnip();
+      naya->prev = snip->prev;
+      naya->next = snip->next;
+      if (naya->prev)
+	naya->prev->next = naya;
+      else
+	snips = naya;
+      if (naya->next)
+	naya->next->prev = naya;
+      else
+	lastSnip = naya;
+
+      snip->wxSnip::SetAdmin(NULL);
+
+      naya->SetAdmin(a);
+      snip = naya;
+    }
+  }
+
+  return snip;
+}
+
+/***************************************************************************/
+
+Bool wxMediaPasteboard::FindDot(wxSnipLocation *loc, float x, float y,
+				float *dxm, float *dym)
+{
+  if (Inbox(loc->x, x)) {
+    *dxm = -1;
+    if (Inbox(loc->y, y))
+      *dym = -1;
+    else if (Inbox(loc->vm, y))
+      *dym = 0;
+    else if (Inbox(loc->b, y))
+      *dym = 1;
+    else
+      return FALSE;
+  } else if (Inbox(loc->hm, x)) {
+    *dxm = 0;
+    if (Inbox(loc->y, y))
+      *dym = -1;
+    else if (Inbox(loc->b, y))
+      *dym = 1;
+    else
+      return FALSE;
+  } else if (Inbox(loc->r, x)) {
+    *dxm = 1;
+    if (Inbox(loc->y, y))
+      *dym = -1;
+    else if (Inbox(loc->vm, y))
+      *dym = 0;
+    else if (Inbox(loc->b, y))
+      *dym = 1;
+    else
+      return FALSE;
+  } else
+    return FALSE;
+
+  return TRUE;
+}
+
+wxSnip *wxMediaPasteboard::FindSnip(float x, float y)
+{
+  wxSnip *snip;
+  wxSnipLocation *loc;
+  float dym, dxm;
+
+  for (snip = snips; snip; snip = snip->next) {
+    loc = SnipLoc(snip);
+    if (loc->x <= x && loc->y <= y
+	&& loc->r >= x && loc->b >= y)
+      return snip;
+    else if (loc->selected && FindDot(loc, x, y, &dxm, &dym))
+      return snip;
+  }
+
+  return NULL;
+}
+
+wxSnip *wxMediaPasteboard::FindFirstSnip(void)
+{
+  return snips;
+}
+
+Bool wxMediaPasteboard::IsSelected(wxSnip *asnip)
+{
+  wxSnip *snip;
+  wxSnipLocation *loc;
+
+  for (snip = snips; snip; snip = snip->next) {
+    if (PTREQ(asnip, snip)) {
+      loc = SnipLoc(snip);
+      return loc->selected;
+    }
+  }
+
+  return FALSE;
+}
+
+wxSnip *wxMediaPasteboard::FindNextSelectedSnip(wxSnip *start)
+{
+  wxSnip *snip;
+  wxSnipLocation *loc;
+
+  if (!start)
+    snip = snips;
+  else
+    snip = start->next;
+
+  for (; snip; snip = snip->next) {
+    loc = SnipLoc(snip);
+    if (loc->selected)
+      return snip;
+  }
+
+  return NULL;
+}
+
+/***************************************************************************/
+
+void wxMediaPasteboard::Draw(wxDC *dc, float dx, float dy, 
+			     float cx, float cy, float cw, float ch, 
+			     int show_caret)
+{
+  wxSnip *snip;
+  wxStyle *oldstyle = NULL;
+  wxSnipLocation *loc;
+  float cr, cb, x, y, r, b, hm, vm, dcx, dcy, dcr, dcb;
+
+  if (!admin)
+    return;
+
+  locked = TRUE;
+
+  dcx = cx + dx;
+  dcy = cy + dy;
+
+  cr = cx + cw;
+  cb = cy + ch;
+
+  dcr = dcx + cw;
+  dcb = dcy + ch;
+
+  {
+    wxPen *savePen = dc->GetPen();
+    wxBrush *saveBrush = dc->GetBrush();
+
+    dc->SetBrush(whiteBrush);
+    dc->SetPen(invisiPen);
+    dc->DrawRectangle(dcx, dcy,
+		      cw + GC_RECT_BRUSH_EXTEND,
+		      ch + GC_RECT_BRUSH_EXTEND);
+
+    dc->SetBrush(saveBrush);
+    dc->SetPen(savePen);
+  }
+
+  OnPaint(TRUE, dc, cx, cy, cr, cb, dx, dy, 
+	  (show_caret && !caretSnip)
+	  ? show_caret
+	  : (int)wxSNIP_DRAW_NO_CARET);
+
+  for (snip = lastSnip; snip; snip = snip->prev) {
+    loc = SnipLoc(snip);
+
+    if ((loc->x <= cr)
+	&& (loc->y <= cb)
+	&& (loc->r >= cx)
+	&& (loc->b >= cy)) {
+      snip->style->SwitchTo(dc, oldstyle);
+      oldstyle = snip->style;
+
+      x = loc->x + dx;
+      y = loc->y + dy;
+      
+      snip->Draw(dc, x, y, dcx, dcy, dcr, dcb, dx, dy, 
+		 PTREQ(snip, caretSnip) 
+		 ? (show_caret ? show_caret : (int)wxSNIP_DRAW_NO_CARET)
+		 : (int)wxSNIP_DRAW_NO_CARET);
+
+      if ((show_caret == wxSNIP_DRAW_SHOW_CARET)
+	  && ownCaret 
+	  && selectionVisible
+	  && loc->selected) {
+	wxBrush *oldbrush;
+	wxPen *oldpen;
+	int lf;
+
+	oldbrush = dc->GetBrush();
+	oldpen = dc->GetPen();
+	lf = dc->GetLogicalFunction();
+	dc->SetBrush(blackBrush);
+	dc->SetPen(invisiPen);
+	dc->SetLogicalFunction(wxXOR);
+
+	r = loc->r + dx;
+	b = loc->b + dy;
+	hm = loc->hm + dx;
+	vm = loc->vm + dy;
+
+	dc->DrawRectangle(x - HALF_DOT_WIDTH, 
+			  y - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(hm - HALF_DOT_WIDTH, 
+			  y - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(r - HALF_DOT_WIDTH, 
+			  y - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(r - HALF_DOT_WIDTH, 
+			  vm - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(r - HALF_DOT_WIDTH, 
+			  b - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND,
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(hm - HALF_DOT_WIDTH, 
+			  b - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(x - HALF_DOT_WIDTH, 
+			  b - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+	dc->DrawRectangle(x - HALF_DOT_WIDTH, 
+			  vm - HALF_DOT_WIDTH, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND, 
+			  DOT_WIDTH + GC_RECT_BRUSH_EXTEND);
+
+	dc->SetLogicalFunction(lf);
+	dc->SetPen(oldpen);
+	dc->SetBrush(oldbrush);
+      }
+    }
+  }
+
+  styleList->BasicStyle()->SwitchTo(dc, oldstyle);
+
+  OnPaint(FALSE, dc, cx, cy, cr, cb, dx, dy, 
+	  (show_caret && !caretSnip)
+	  ? show_caret
+	  : (int)wxSNIP_DRAW_NO_CARET);
+
+  locked = FALSE;
+}
+
+void wxMediaPasteboard::Refresh(float localx, float localy, float w, float h, 
+				int show_caret)
+{
+  float dx, dy, ddx, ddy;
+  wxDC *dc;
+
+  if (!admin || locked)
+    return;
+
+  if ((h <= 0) || (w <= 0))
+    return;
+
+  ReadyOffscreen(w, h);
+
+  dc = admin->GetDC(&dx, &dy);
+
+  if (!offscreenInUse && bitmap && bitmap->Ok() && offscreen->Ok()) {
+    /* Need to make sure that difference between coordinates is
+       integral; otherwise, roundoff error could affect drawing */
+    ddx = (localx - dx) - (long)(localx - dx);
+    if (ddx < 0)
+      ddx = 1 + ddx;
+    localx -= ddx;
+    w += ddx;
+    ddy = (localy - dy) - (long)(localy - dy);
+    if (ddy < 0)
+      ddy = 1 + ddy;
+    localy -= ddy;
+    h += ddy;
+
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+    offscreenInUse = TRUE;
+#endif
+
+    Draw(offscreen, -localx, -localy, localx, localy, w, h, show_caret);
+    dc->Blit(localx - dx, localy - dy, w, h, offscreen, 0, 0, wxCOPY);
+
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+    offscreenInUse = FALSE;
+    lastUsedOffscreen = this;
+#endif
+  } else {
+    wxPen *pen;
+    wxBrush *brush;
+    wxFont *font;
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    wxColour *fg, *bg;
+#else
+    wxColour fg, bg;
+#endif
+    int log;
+
+    log = dc->GetLogicalFunction();
+    pen = dc->GetPen();
+    brush = dc->GetBrush();
+    font = dc->GetFont();
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    fg = &dc->GetTextForeground();
+    bg = &dc->GetTextBackground();
+#else
+    fg = dc->GetTextForeground();
+    bg = dc->GetTextBackground();
+#endif
+
+#ifndef NO_GET_CLIPPING_REGION
+    float cx, cy, cw, ch;
+    dc->GetClippingRegion(&cx, &cy, &cw, &ch);
+    dc->SetClippingRegion(localx - dx, localy - dy, w, h);
+#endif
+
+    Draw(dc, -dx, -dy, localx, localy, w, h, show_caret);
+
+#ifndef NO_GET_CLIPPING_REGION
+    if (cw < 0)
+      dc->DestroyClippingRegion();
+    else
+      dc->SetClippingRegion(cx, cy, cw, ch);
+#endif
+
+    dc->SetLogicalFunction(log);
+    dc->SetBrush(brush);
+    dc->SetPen(pen);
+    dc->SetFont(font);
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    dc->SetTextForeground(fg);
+    dc->SetTextBackground(bg);
+#else
+    dc->SetTextForeground(&fg);
+    dc->SetTextBackground(&bg);
+#endif
+  }
+}
+
+void wxMediaPasteboard::CheckRecalc()
+{
+  float r, b;
+  wxDC *dc;
+  wxNode *node;
+  wxSnipLocation *loc;
+  
+  if (!admin)
+    return;
+
+  dc = admin->GetDC();
+
+  if (needResize) {
+    /* Find right & bottom */
+    r = b = 0;
+    for (node = snipLocationList->First(); node; node = node->Next()) {
+      loc = (wxSnipLocation *)node->Data();
+      if (loc->needResize)
+	loc->Resize(dc);
+      if (loc->r + DOT_WIDTH > r)
+	r = loc->r + DOT_WIDTH;
+      if (loc->b + DOT_WIDTH > b)
+	b = loc->b + DOT_WIDTH;
+    }
+  
+    realWidth = r;
+    realHeight = b;
+
+    if (minWidth && (realWidth < minWidth))
+      realWidth = minWidth;
+    if (maxWidth && (realWidth > maxWidth))
+      realWidth = maxWidth;
+
+    if (minHeight && (realHeight < minHeight))
+      realHeight = minHeight;
+    if (maxHeight && (realHeight > maxHeight))
+      realHeight = maxHeight;
+
+    needResize = FALSE;
+  }
+
+  if (!keepSize) {
+    if (realWidth != totalWidth || realHeight != totalHeight) {
+      totalWidth = realWidth;
+      totalHeight = realHeight;
+      admin->Resized(FALSE);
+    }
+  }
+
+  
+}
+
+void wxMediaPasteboard::Update(float x, float y, float w, float h)
+{
+  float r, b;
+
+  r = x + w;
+  b = y + h;
+
+  if (x < 0)
+    x = 0;
+  if (y < 0)
+    y = 0;
+  if (r < 0)
+    r = 0;
+  if (b < 0)
+    b = 0;
+
+  if (!updateNonemtpy) {
+    updateTop = y;
+    updateLeft = x;
+    if (h < 0)
+      updateBottom = h;
+    else
+      updateBottom = b;
+    if (w < 0)
+      updateRight = w;
+    else
+      updateRight = r;
+    updateNonemtpy = TRUE;
+  } else {
+    if (y < updateTop)
+      updateTop = y;
+
+    if (x < updateLeft)
+      updateLeft = x;
+
+    if ((h < 0) && (updateBottom > 0))
+      updateBottom = -updateBottom;
+    if (updateBottom < 0) {
+      if (h < 0 && h < updateBottom)
+	updateBottom = h;
+      else if (h > 0 && (-b) < updateBottom)
+	updateBottom = -b;
+    } else if (b > updateBottom)
+      updateBottom = b;
+
+    if ((w < 0) && (updateRight > 0))
+      updateRight = -updateRight;
+    if (updateRight < 0) {
+      if (w < 0 && w < updateRight)
+	updateRight = w;
+      else if (h > 0 && (-r) < updateRight)
+	updateRight = -r;
+    } else if (r > updateRight)
+      updateRight = r;
+  }
+
+  if (sequence || !admin)
+    return;
+
+  CheckRecalc();
+
+  if (updateBottom < 0) {
+    updateBottom = -updateBottom;
+    if (updateBottom < realHeight)
+      updateBottom = realHeight;
+  }
+  if (updateRight < 0) {
+    updateRight = -updateRight;
+    if (updateRight < realWidth)
+      updateRight = realWidth;
+  }
+
+  if (updateTop != updateBottom || updateLeft != updateRight)
+    admin->NeedsUpdate(updateLeft, updateTop, 
+		       updateRight - updateLeft + 1, 
+		       updateBottom - updateTop + 1);
+
+  updateNonemtpy = FALSE;
+
+  if (changed) {
+    changed = FALSE;
+    OnChange();
+  }
+}
+
+void wxMediaPasteboard::UpdateLocation(wxSnipLocation *loc)
+{
+  if (admin) {
+    if (loc->needResize)
+      loc->Resize(admin->GetDC());
+    Update(loc->x - HALF_DOT_WIDTH, loc->y - HALF_DOT_WIDTH, 
+	   loc->w + DOT_WIDTH, loc->h + DOT_WIDTH);
+  }
+}
+
+void wxMediaPasteboard::UpdateSnip(wxSnip *snip)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  if ((node = snipLocationList->Find((long)snip))) {
+    loc = (wxSnipLocation *)node->Data();
+    UpdateLocation(loc);
+  }
+}
+
+void wxMediaPasteboard::UpdateSelected()
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  BeginEditSequence();
+
+  for (node = snipLocationList->First(); node; node = node->Next()) {
+    loc = (wxSnipLocation *)node->Data();
+    if (loc->selected)
+      UpdateLocation(loc);
+  }
+  
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::UpdateAll()
+{
+  Update(0, 0, -1, -1);
+}
+
+void wxMediaPasteboard::UpdateNeeded()
+{
+  if (updateNonemtpy)
+    Update(updateLeft, updateTop, 0, 0);
+}
+
+void wxMediaPasteboard::InvalidateBitmapCache(float x, float y, float w, float h)
+{
+  Update(x, y, w, h);
+}
+
+/***************************************************************************/
+
+void wxMediaPasteboard::OwnCaret(Bool ownit)
+{
+  if (DoOwnCaret(ownit)) {
+    UpdateSelected();
+    OnFocus(ownit);
+  }
+}
+
+void wxMediaPasteboard::SizeCacheInvalid(void)
+{
+  sizeCacheInvalid = TRUE;
+}
+
+
+void wxMediaPasteboard::GetExtent(float *w, float *h)
+{
+  CheckRecalc();
+
+  if (w)
+    *w = totalWidth;
+  if (h)
+    *h = totalHeight;
+}
+
+Bool wxMediaPasteboard::ScrollTo(wxSnip *snip, 
+				 float WXUNUSED(localx), float WXUNUSED(localy), 
+				 float WXUNUSED(w), float WXUNUSED(h), 
+				 Bool refresh, int WXUNUSED(bias))
+{
+  if (refresh)
+    UpdateSnip(snip);
+  return FALSE;
+}
+
+void wxMediaPasteboard::SetCaretOwner(wxSnip *snip, int dist)
+{
+  if (DoSetCaretOwner(snip, dist)) {
+    UpdateAll();
+    OnFocus(!snip);
+  }
+}
+
+
+void wxMediaPasteboard::Resized(wxSnip *snip, Bool redraw_now)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  if (!(node = snipLocationList->Find((long)snip)))
+    return;
+  loc = (wxSnipLocation *)node->Data();  
+
+  if (loc->needResize)
+    return;
+
+  if (!redraw_now)
+    sequence++;
+  BeginEditSequence();
+  
+  UpdateLocation(loc);
+
+  loc->needResize = TRUE;
+  needResize = TRUE;
+
+  UpdateLocation(loc);
+
+  EndEditSequence();
+  if (!redraw_now)
+    --sequence;
+}
+
+Bool wxMediaPasteboard::Recounted(wxSnip *snip, Bool redraw_now)
+{
+  Resized(snip, redraw_now);
+  return TRUE;
+}
+
+void wxMediaPasteboard::NeedsUpdate(wxSnip *snip, float localx, float localy, 
+				    float w, float h)
+{
+  float x, y;
+
+  GetSnipLocation(snip, &x, &y);
+  Update(x + localx, y + localy, w, h);
+}
+
+Bool wxMediaPasteboard::ReleaseSnip(wxSnip *WXUNUSED(snip))
+{
+  return FALSE;
+}
+
+/************************************************************************/
+
+float wxMediaPasteboard::ScrollLineLocation(long line)
+{
+  return line * scrollStep;
+}
+
+
+long wxMediaPasteboard::NumScrollLines()
+{
+  return (long)((totalHeight + scrollStep - 1) / scrollStep);
+}
+
+long wxMediaPasteboard::FindScrollLine(float y)
+{
+  return (long)(y / scrollStep);
+}
+
+void wxMediaPasteboard::SetScrollStep(float s)
+{
+  if (scrollStep != s) {
+    scrollStep = s;
+    if (admin)
+      admin->Resized(TRUE);
+  }
+}
+ 
+float wxMediaPasteboard::GetScrollStep(void)
+{
+  return scrollStep;
+}
+
+/************************************************************************/
+
+void wxMediaPasteboard::SetMinWidth(float w)
+{
+  if (w <= 0)
+    minWidth = 0.0;
+  else
+    minWidth = w;
+
+  needResize = TRUE;
+  UpdateAll();
+}
+
+void wxMediaPasteboard::SetMaxWidth(float w)
+{
+  if (w <= 0)
+    maxWidth = 0.0;
+  else
+    maxWidth = w;
+
+  needResize = TRUE;
+  UpdateAll();
+}
+
+float wxMediaPasteboard::GetMinWidth()
+{
+  return minWidth;
+}
+
+float wxMediaPasteboard::GetMaxWidth()
+{
+  return maxWidth;
+}
+
+void wxMediaPasteboard::SetMinHeight(float h)
+{
+  if (h <= 0)
+    minHeight = 0.0;
+  else
+    minHeight = h;
+
+  needResize = TRUE;
+  UpdateAll();
+}
+
+void wxMediaPasteboard::SetMaxHeight(float h)
+{
+  if (h <= 0)
+    maxHeight = 0.0;
+  else
+    maxHeight = h;
+
+  needResize = TRUE;
+  UpdateAll();
+}
+
+float wxMediaPasteboard::GetMinHeight()
+{
+  return minHeight;
+}
+
+float wxMediaPasteboard::GetMaxHeight()
+{
+  return maxHeight;
+}
+
+/************************************************************************/
+
+
+wxMediaBuffer *wxMediaPasteboard::CopySelf(void)
+{
+  wxMediaPasteboard *pb;
+
+  pb = new wxMediaPasteboard();
+
+  return pb;
+}
+
+
+float wxMediaPasteboard::GetDescent(void)
+{
+  return 0;
+}
+
+
+float wxMediaPasteboard::GetSpace(void)
+{
+  return 0;
+}
+
+void wxMediaPasteboard::GetCenter(float *fx, float *fy)
+{
+  float x, y, w, h;
+
+  if (!admin) {
+    w = totalWidth;
+    h = totalHeight;
+    x = y = 0;
+  } else
+    admin->GetView(&x, &y, &w, &h, TRUE);
+
+  if (w > 1000)
+    // Don't belive it
+    w = 500;
+  if (h > 1000)
+    // Don't belive it
+    h = 500;
+
+  if (fx)
+    *fx = w / 2;
+  if (fy)
+    *fy = h / 2;
+
+}
+
+char *wxMediaPasteboard::GetFlattenedText(long *got)
+{
+  wxSnip *snip;
+  char *t, *s, *old;
+  long p, alloc, offset;
+
+  alloc = 100;
+  s = new char[alloc];
+
+  snip = snips;
+
+  p = 0;
+
+  while (snip) {
+    t = snip->GetText(0, snip->count, TRUE);
+
+    offset = strlen(t);
+    if (p + offset >= alloc) {
+      alloc = 2 * (p + offset);
+      old = s;
+      s = new char[alloc];
+      memcpy(s, old, p);
+      delete[] old;
+    }
+    memcpy(s + p, t, offset);
+    p += offset;
+    delete[] t;
+
+    snip = snip->next;
+  }
+
+  s[p] = 0;
+  if (got)
+    *got = p;
+
+  return s;
+}
+
+/************************************************************************/
+
+void wxMediaPasteboard::Clear()
+{
+  Delete();
+}
+
+void wxMediaPasteboard::Cut(Bool extend, long time)
+{
+  Copy(extend, time);
+  Clear();
+}
+
+void wxMediaPasteboard::DoCopy(long time, Bool extend)
+{
+  wxSnip *asnip;
+  wxNode *node;
+  wxSnipLocation *loc;
+  wxStyleList *sl;
+
+  wxmb_commonCopyRegionData = NULL;
+
+  sl = (extend && wxmb_copyStyleList) ? wxmb_copyStyleList : styleList;
+
+  for (node = snipLocationList->First(); node; node = node->Next()) {
+    loc = (wxSnipLocation *)node->Data();
+    if (loc->selected) {
+      asnip = loc->snip->Copy();
+      asnip->SetAdmin(NULL);
+      asnip->style = sl->Convert(asnip->style);  
+      wxmb_commonCopyBuffer->Append(asnip);
+      wxmb_commonCopyBuffer2->Append(GetSnipData(loc->snip));
+    }
+  }
+
+  InstallCopyBuffer(time, sl);
+}
+
+void wxMediaPasteboard::Copy(Bool extend, long time)
+{
+  BeginCopyBuffer();
+
+  if (!extend)
+    FreeOldCopies();
+
+  DoCopy(time, extend);
+
+  EndCopyBuffer();
+}
+
+void wxMediaPasteboard::DoPaste(long time)
+{
+  wxSnip *start, *snip;
+  float cx, cy, left, right, top, bottom, dx, dy;
+  wxSnipLocation *loc;
+  wxDC *dc;
+
+  start = snips;
+  GetCenter(&cx, &cy);
+
+  DoBufferPaste(time);
+
+  // Quiet the compiler:
+  left = right = top = bottom = 0;
+
+  if (admin && PTRNE(snips, start)) {
+    dc = GetDC();
+
+    /* Get top/left/bottom/right of pasted group: */
+    for (snip = snips; PTRNE(snip, start); snip = snip->next) {
+      loc = SnipLoc(snip);      
+      if (loc->needResize)
+	loc->Resize(dc);
+      if (PTREQ(snip, snips)) {
+	left = loc->x;
+	top = loc->y;
+	right = loc->r;
+	bottom = loc->b;
+      } else {
+	if (loc->x < left)
+	  left = loc->x;
+	if (loc->y < top)
+	  top = loc->y;
+	if (loc->r > right)
+	  right = loc->r;
+	if (loc->b > bottom)
+	  bottom = loc->b;
+      }
+      AddSelected(snip);
+    }
+
+    dx = cx - (left + right) / 2;
+    dy = cy - (top + bottom) / 2;
+    
+    /* Shift the pasted group to center: */
+    Move(dx, dy);
+  } else {
+    /* Just select them: */
+    for (snip = snips; PTRNE(snip, start); snip = snip->next)
+      AddSelected(snip);
+  }
+}
+
+void wxMediaPasteboard::Paste(long time)
+{
+  BeginEditSequence();
+
+  NoSelected();
+
+  DoPaste(time);
+
+  EndEditSequence();
+}
+
+void wxMediaPasteboard::InsertPasteSnip(wxSnip *snip, wxBufferData *data)
+{
+  Insert(snip);
+  SetSnipData(snip, data);
+}
+
+void wxMediaPasteboard::InsertPasteString(char *str)
+{
+  wxTextSnip *snip;
+
+  snip = new wxTextSnip();
+  snip->style = styleList->FindNamedStyle(STD_STYLE);
+  snip->Insert(str, strlen(str));
+  
+  InsertPasteSnip(snip, NULL);
+}
+
+void wxMediaPasteboard::Kill(long time)
+{
+  Cut(time);
+}
+
+/************************************************************************/
+
+Bool wxMediaPasteboard::GetSnipLocation(wxSnip *thesnip, float *x, float *y, 
+					Bool bottomRight)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+
+  if (!admin)
+    return FALSE;
+
+  if (bottomRight)
+    CheckRecalc();
+
+  node = snipLocationList->Find((long)thesnip);
+  if (!node)
+    return FALSE;
+  
+  loc = (wxSnipLocation *)node->Data();
+  if (x)
+    *x = loc->x;
+  if (y)
+    *y = loc->y;
+  if (bottomRight) {
+    if (x)
+      *x += loc->w;
+    if (y)
+      *y += loc->h;
+  }
+
+  return TRUE;
+}
+
+/************************************************************************/
+
+wxBufferData *wxMediaPasteboard::GetSnipData(wxSnip *snip)
+{
+  wxNode *node;
+  wxSnipLocation *loc;
+  wxLocationBufferData *data;
+
+  if (!(node = snipLocationList->Find((long)snip)))
+    return wxMediaBuffer::GetSnipData(snip);
+
+  loc = (wxSnipLocation *)node->Data();  
+  data = new wxLocationBufferData;
+  data->x = loc->x;
+  data->y = loc->y;
+
+  data->next = wxMediaBuffer::GetSnipData(snip);
+
+  return data;
+}
+
+void wxMediaPasteboard::SetSnipData(wxSnip *snip, wxBufferData *data)
+{
+  while (data) {
+    if (data->dataclass && !strcmp(data->dataclass->classname, "wxloc")) {
+      wxLocationBufferData *ldata;
+      ldata = (wxLocationBufferData *)data;
+      MoveTo(snip, ldata->x, ldata->y);
+    }
+    data = data->next;
+  }
+}
+
+Bool wxMediaPasteboard::LoadFile(char *file, int WXUNUSED(format), Bool showErrors)
+{
+  if (!file || !*file) {
+    if ((file && !*file) || !filename || tempFilename) {
+      char *path;
+      
+      if (filename) {
+	path = PathOnly(filename);
+	if (path)
+	  path = copystring(path);
+      } else
+	path = NULL;
+      
+      file = GetFile(path);
+      
+      if (path)
+	delete[] path;
+    } else
+      file = filename;
+  }
+
+  if (!file)
+    return FALSE;
+
+  if (!OnLoadFile(file, wxMEDIA_FF_STD))
+    return FALSE;
+
+  if (::DirExists(file)) {
+    if (showErrors)
+      wxMessageBox("Can't load a directory.", "Error");
+    AfterLoadFile(FALSE);
+    return FALSE;
+  }
+
+  SetFilename(file, FALSE);
+
+  FILE *f = fopen(wxmeExpandFilename(file), "rb");
+  
+  if (!f) {
+    if (showErrors)
+      wxMessageBox("Couldn't open the file.", "Error");
+    AfterLoadFile(FALSE);
+    return FALSE;
+  }
+
+  wxBeginBusyCursor();
+
+  BeginEditSequence();
+
+  Erase();
+
+  Bool ok = InsertFile(f, loadoverwritesstyles, showErrors);
+
+  EndEditSequence();
+
+  ClearUndos();
+
+  wxEndBusyCursor();
+
+  SetModified(!ok);
+
+  AfterLoadFile(ok);
+
+  return ok;
+}
+
+Bool wxMediaPasteboard::InsertFile(char *file, int WXUNUSED(format), Bool showErrors)
+{
+  FILE *f = fopen(wxmeExpandFilename(file), "rb");
+  
+  if (!f)
+    return FALSE;
+
+  return InsertFile(f, FALSE, showErrors);
+}
+
+Bool wxMediaPasteboard::InsertFile(FILE *f, Bool clearStyles, Bool showErrors)
+{
+  int n;
+  char buffer[MRED_START_STR_LEN + 1];
+  Bool fileerr;
+
+  n = fread((char *)buffer, 1, MRED_START_STR_LEN, f);
+  buffer[MRED_START_STR_LEN] = 0;
+  if ((n != MRED_START_STR_LEN) || strcmp(buffer, MRED_START_STR)){
+    if (showErrors)
+      wxMessageBox("This is not a MrEd file.", "Error");
+    fileerr = TRUE;
+  } else {
+    fread((char *)wxme_current_read_format, 1, MRED_FORMAT_STR_LEN, f);
+    fread((char *)wxme_current_read_version, 1, MRED_VERSION_STR_LEN, f);
+
+    if (wxmeCheckFormatAndVersion()) {
+      wxMediaStreamInFileBase b(f);
+      wxMediaStreamIn mf(b);
+      
+      if (wxReadMediaGlobalHeader(mf)) {
+	if (mf.Ok())
+	  fileerr = !ReadFromFile(mf, clearStyles);
+	else
+	  fileerr = TRUE;
+      } else
+	fileerr = TRUE;
+      fileerr = !wxReadMediaGlobalFooter(mf) || fileerr;
+    
+      styleList->NewNamedStyle(STD_STYLE, NULL);
+      
+      fileerr = fileerr || !mf.Ok();
+    } else
+      fileerr = TRUE;
+  }
+
+  fileerr = fileerr || ferror(f);
+  
+  fclose(f);
+
+  if (fileerr && showErrors)
+    wxMessageBox("There was an error loading the file.", "Error");
+
+  return !fileerr;
+}
+
+Bool wxMediaPasteboard::SaveFile(char *file, int format, Bool showErrors)
+{
+  if (!file || !*file) {
+    if ((file && !*file) || !filename || tempFilename) {
+      char *path, *pfile;
+      
+      if (filename) {
+	path = PathOnly(filename);
+	if (path && *path)
+	  path = copystring(path);
+	else
+	  path = NULL;
+	pfile = copystring(FileNameFromPath(filename));
+      } else
+	path = pfile = NULL;
+      
+      file = PutFile(path, pfile);
+      
+      if (path) {
+	delete[] path;
+	delete[] pfile;
+      }
+    } else
+      file = filename;
+  }
+
+  if (!file)
+    return FALSE;
+
+  if (format != wxMEDIA_FF_COPY)
+    format = wxMEDIA_FF_STD;
+
+  Bool no_set_filename = (format == wxMEDIA_FF_COPY);
+
+  if (!OnSaveFile(file, wxMEDIA_FF_STD))
+    return FALSE;
+  
+  FILE *f = fopen(wxmeExpandFilename(file), "wb");
+  Bool fileerr;
+
+  if (!f) {
+    if (showErrors)
+      wxMessageBox("Couldn't write the file.", "Error");
+    AfterSaveFile(FALSE);
+    return FALSE;
+  }
+
+  wxBeginBusyCursor();
+
+#ifdef wx_mac
+  wxMediaSetFileCreatorType(file, TRUE);
+#endif
+
+  fwrite(MRED_START_STR, 1, MRED_START_STR_LEN, f);
+  fwrite(MRED_FORMAT_STR, 1, MRED_FORMAT_STR_LEN, f);
+  fwrite(MRED_VERSION_STR, 1, MRED_VERSION_STR_LEN, f);    
+
+  wxMediaStreamOutFileBase b(f);
+  wxMediaStreamOut mf(b);
+  
+  wxWriteMediaGlobalHeader(mf);
+  if (mf.Ok())
+    fileerr = !WriteToFile(mf);
+  else
+    fileerr = TRUE;
+  wxWriteMediaGlobalFooter(mf);
+  
+  fileerr = fileerr || !mf.Ok();
+
+  fclose(f);
+
+  if (fileerr && showErrors)
+    wxMessageBox("There was an error writing the file.", "Error");
+
+  if (!no_set_filename)
+    SetFilename(file, FALSE);
+
+  wxEndBusyCursor();
+
+  if (!no_set_filename)
+    SetModified(fileerr);
+
+  AfterSaveFile(!fileerr);
+
+  return !fileerr;
+}
+
+Bool wxMediaPasteboard::WriteToFile(wxMediaStreamOut &f)
+{
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File writing has not been initialized for this stream.", "Error");
+    return FALSE;
+  }
+
+  if (!DoWriteHeadersFooters(f, TRUE))
+    return FALSE;
+
+  wxmbWriteSnipsToFile(f, styleList, NULL, snips, NULL, NULL, this);
+  
+  if (!DoWriteHeadersFooters(f, FALSE))
+    return FALSE;
+
+  return TRUE;
+}
+
+
+Bool wxMediaPasteboard::ReadFromFile(wxMediaStreamIn &f, Bool overwritestyle)
+{
+  if (wxMediaFileIOReady != (void *)&f) {
+    wxMessageBox("File reading has not been initialized for this stream.", "Error");
+    return FALSE;
+  }
+
+  return ReadSnipsFromFile(f, overwritestyle);
+}
+
+
+Bool wxMediaPasteboard::ReadInsert(wxSnip *snip)
+{
+  Insert(snip, (wxSnip *)NULL);
+  return TRUE;
+}
+
+void wxMediaPasteboard::SetFilename(char *name, Bool temp)
+{
+  wxSnip *snip;
+
+  if (filename)
+    delete[] filename;
+  filename = copystring(name);
+  tempFilename = temp;
+
+  for (snip = snips; snip; snip = snip->next)
+    if (snip->flags & wxSNIP_USES_BUFFER_PATH)
+      /* Just a notification */
+      snip->SetAdmin(snipAdmin);
+}
+
+/************************************************************************/
+
+void wxMediaPasteboard::StyleHasChanged(wxStyle *style)
+{
+  if (!style) {
+    UpdateAll();
+    return;
+  }
+}
+
+/************************************************************************/
+
+void wxMediaPasteboard::BeginEditSequence(Bool undoable)
+{
+  if (noundomode || !undoable)
+    noundomode++;
+
+  if (!sequence)
+    OnEditSequence();
+
+  sequence++;
+}
+
+
+void wxMediaPasteboard::EndEditSequence(void)
+{
+  if (!(--sequence)) {
+    sequenceStreak = FALSE;
+    UpdateNeeded();
+    AfterEditSequence();
+  }
+
+  if (noundomode)
+    --noundomode;
+}
+
+Bool wxMediaPasteboard::RefreshDelayed(void)
+{
+  if (sequence)
+    return 1;
+  
+  if (!admin)
+    return 1;
+  else
+    return admin->DelayRefresh();
+}
+
+/************************************************************************/
+
+void wxMediaPasteboard::AddPasteboardFunctions(wxKeymap *tab)
+{
+  wxAddMediaPasteboardFunctions(tab);
+}
+
+void wxAddMediaPasteboardFunctions(wxKeymap *)
+{
+}
+
+Bool wxMediaPasteboard::GetDragable()
+{
+  return dragable;
+}
+
+void wxMediaPasteboard::SetDragable(Bool d)
+{
+  dragable = d;
+}
+
+Bool wxMediaPasteboard::GetSelectionVisible()
+{
+  return selectionVisible;
+}
+
+void wxMediaPasteboard::SetSelectionVisible(Bool v)
+{
+  selectionVisible = v;
+}
+
+
+/************************************************************************/
+
+void wxMediaPasteboard::OnChange(void)
+{
+}
+
+Bool wxMediaPasteboard::OnInsert(wxSnip *, wxSnip *, float, float)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterInsert(wxSnip *, wxSnip *, float, float)
+{
+}
+
+Bool wxMediaPasteboard::OnDelete(wxSnip *)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterDelete(wxSnip *)
+{
+}
+
+Bool wxMediaPasteboard::OnMoveTo(wxSnip *, float, float, Bool WXUNUSED(dragging))
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterMoveTo(wxSnip *, float, float, Bool WXUNUSED(dragging))
+{
+}
+
+Bool wxMediaPasteboard::OnResize(wxSnip *, float, float)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterResize(wxSnip *, float, float, Bool WXUNUSED(did))
+{
+}
+
+Bool wxMediaPasteboard::OnSelect(wxSnip *, Bool)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterSelect(wxSnip *, Bool)
+{
+}
+
+#if ALLOW_X_STYLE_SELECTION
+Bool wxMediaPasteboard::OwnXSelection(Bool on, Bool WXUNUSED(update), Bool force)
+{
+  return DoOwnXSelection(on, force);
+}
+#endif
+
+Bool wxMediaPasteboard::OnInteractiveMove(void)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterInteractiveMove(void)
+{
+}
+
+Bool wxMediaPasteboard::OnInteractiveResize(wxSnip *)
+{
+  return TRUE;
+}
+
+void wxMediaPasteboard::AfterInteractiveResize(wxSnip *)
+{
+}
+
+/************************************************************************/
+
+void *wxMediaPasteboard::BeginPrint(wxDC *, Bool)
+{
+  return NULL;
+}
+
+void wxMediaPasteboard::EndPrint(wxDC *, void *)
+{
+}
+
+Bool wxMediaPasteboard::HasPrintPage(wxDC *, int)
+{
+  return FALSE;
+}
+
+void wxMediaPasteboard::PrintToDC(wxDC *, int)
+{
+
+}
+
+/************************************************************************/
+
+void wxSnipLocation::Resize(wxDC *dc)
+{
+  snip->GetExtent(dc, x, y, &w, &h);
+  r = x + w;
+  b = y + h;
+  hm = x + w/2;
+  vm = y + h/2;
+  
+  needResize = FALSE;
+}
diff --git a/src/mred/wxme/wx_mpriv.cxx b/src/mred/wxme/wx_mpriv.cxx
new file mode 100644
index 0000000..7866bd3
--- /dev/null
+++ b/src/mred/wxme/wx_mpriv.cxx
@@ -0,0 +1,2762 @@
+/*
+ * File:        wx_mpriv.cc
+ * Purpose:     wxMediaEdit private methods implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#define Uses_wxPrintSetup /* for wx_xt */
+#define Uses_XLib /* for getting black pixel value */
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_utils.h"
+#include "wx_dcps.h"
+#include "wx_media.h"
+#ifdef wx_xt
+#include "wx_types.h"
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+#include <fstream.h>
+#include <ctype.h>
+
+#include "wx_mpriv.h"
+
+#include "wx_gcrct.h"
+
+/* Debugging: */
+#define CHECK_CONSISTENCY 0
+#define LOOK_FOR_ZEROED 0
+#define PLOT_SNIP_DOT 0
+
+#define A_VERY_BIG_NUMBER 1e50
+
+/****************************************************************/
+/*                             PRIVATE                          */
+/****************************************************************/
+
+void wxMediaEdit::_SetPosition(Bool setflash, int bias, long start, long end, 
+			       Bool ateol, Bool scroll, int seltype)
+{
+  long oldstart, oldend, sPos;
+  Bool oldateol;
+  wxSnip *snip;
+  Bool needRefresh, needFullRefresh, changedPos;
+
+  if (flowLocked)
+    return;
+  
+  if (!setflash && (!flash || !flashautoreset || !flashdirectoff))
+    EndStreaks(wxSTREAK_EXCEPT_DELAYED);
+  
+  if ((start < 0) 
+      || ((end != -1) && (start > end)))
+    return;
+
+  if (end == -1)
+    end = start;
+  else if (end > len)
+    end = len;
+
+  if (start > len)
+    start = len;
+
+  if (ateol) {
+    if (start != end)
+      ateol = FALSE;
+    else {
+      snip = FindSnip(start, -1, &sPos);
+      if (!(snip->flags & wxSNIP_NEWLINE) 
+	  || (snip->flags & wxSNIP_INVISIBLE) 
+	  || start != sPos + snip->count)
+	ateol = FALSE;
+    }
+  }
+
+  if (flash) {
+    oldstart = flashstartpos;
+    oldend = flashendpos;
+    oldateol = flashposateol;
+  } else {
+    oldstart = startpos;
+    oldend = endpos;
+    oldateol = posateol;
+  }
+  
+  if (!setflash && flash && flashautoreset) {
+    flash = FALSE;
+    if (flashTimer) {
+      flashTimer->Stop();
+      delete flashTimer;
+      flashTimer = NULL;
+    }
+  }
+
+  if (start == oldstart && end == oldend && ateol == oldateol)
+    needRefresh = changedPos = FALSE;
+  else {
+    needRefresh = changedPos = TRUE;
+
+    if (setflash) {
+      flashstartpos = start;
+      flashendpos = end;
+      flashposateol = ateol;
+    } else {
+#if ALLOW_X_STYLE_SELECTION
+      if (start == end || wxMediaXSelectionAllowed != this 
+	  || (seltype == wxLOCAL_SELECT)) {
+	if (!delayRefresh || needXCopy) {
+	  needXCopy = FALSE;
+	  CopyOutXSelection();
+	}
+      }
+#endif
+
+      CheckMergeSnips(startpos);
+      CheckMergeSnips(endpos);
+    
+      caretStyle = NULL;
+      startpos = start;
+      endpos = end;
+      posateol = ateol;
+    }
+  }
+
+  needFullRefresh = FALSE;
+#if ALLOW_X_STYLE_SELECTION
+  if (!setflash && wxMediaXSelectionMode) {
+    if ((seltype != wxLOCAL_SELECT) 
+	&& start != end 
+	&& this != wxMediaXSelectionOwner) {
+      if (OwnXSelection(TRUE, FALSE, seltype == wxX_SELECT)) {
+	needFullRefresh = TRUE;
+	needRefresh = TRUE;
+      }
+    } else if ((start == end 
+		|| wxMediaXSelectionAllowed != this 
+		|| (seltype == wxLOCAL_SELECT))
+	       && this == wxMediaXSelectionOwner) {
+      if (OwnXSelection(FALSE, FALSE, FALSE)) {
+	needFullRefresh = TRUE;
+	needRefresh = TRUE;
+      }
+    }
+  }
+#endif
+
+  if (setflash)
+    flash = TRUE;
+
+  if (scroll) {
+    long scrollStart, scrollEnd;
+
+    if (bias < -1) {
+      scrollStart = scrollEnd = start;
+      bias = 0;
+    } else if (bias > 1) {
+      scrollStart = scrollEnd = end;
+      bias = 0;
+    } else {
+      scrollStart = start;
+      scrollEnd = end;
+    }
+  
+    if (ScrollToPosition(scrollStart, posateol, TRUE, scrollEnd, bias))
+      needRefresh = FALSE;
+  }
+
+  if (needRefresh) {
+    if (hiliteOn && admin && (admin->standard > 0) && !delayRefresh 
+	&& oldstart == oldend && start == end && caretOn
+	&& caretLocationX >= 0 && !flash) {
+      /* Try to take a shortcut */
+      if (CaretOff()) {
+	/* Shortcut works */
+	caretLocationX = -1;
+	CaretOn();
+	needRefresh = FALSE;
+      }
+    }
+
+    if (needRefresh) {
+      if (start >= oldend || end <= oldstart || needFullRefresh) {
+	/* No overlap: */
+	NeedRefresh(oldstart, oldend);
+	NeedRefresh(start, end);
+      } else {
+	if (start < oldstart)
+	  NeedRefresh(start, oldstart);
+	if (oldstart < start)
+	  NeedRefresh(oldstart, start);
+	if (end < oldend)
+	  NeedRefresh(end, oldend);
+	if (oldend < end)
+	  NeedRefresh(oldend, end);
+      }
+    }
+  }
+
+  if (changedPos && !setflash)
+    AfterSetPosition();
+}
+
+void wxMediaFlashTimer::Notify(void)
+{
+  media->FlashOff();
+}
+
+/**********************************************************************/
+
+void wxMediaEdit::_ChangeStyle(long start, long end, 
+			       wxStyle *newStyle, wxStyleDelta *delta)
+{
+  wxSnip *gsnip, *startSnip, *endSnip;
+  wxStyleChangeRecord *rec;
+  wxStyle *style, *style2;
+  long p;
+  int something;
+
+  if (writeLocked || userLocked)
+    return;
+
+  if (newStyle && (styleList->StyleToIndex(newStyle) < 0))
+    return;
+
+  if (start < 0)
+    start = 0;
+  if (start > len)
+    start = len;
+  if (end > len)
+    end = len;
+  if (start > end)
+    return;
+
+  if (!newStyle && !delta)
+    newStyle = styleList->FindNamedStyle(STD_STYLE);
+
+  if ((startpos == start) && (endpos == end) && (start == end) && len) {
+    if (newStyle)
+      caretStyle = newStyle;
+    else {
+      gsnip = FindSnip(start, -1);
+      caretStyle = styleList->FindOrCreateStyle(gsnip->style, delta);
+    }
+    return;
+  }
+
+  writeLocked = TRUE;
+
+  if (!OnChangeStyle(start, end - start))
+    goto give_up;
+  
+  flowLocked = TRUE;
+
+  MakeSnipset(start, end);
+  
+  if (!len) {
+    startSnip = snips;
+    endSnip = NULL;
+  } else {
+    startSnip = FindSnip(start, +1);
+    endSnip = FindSnip(end, +2);
+  }
+
+  if (!noundomode)
+    rec = new wxStyleChangeRecord(start, end, delayedStreak || !modified);
+  else
+    rec = NULL;
+
+  something = FALSE;
+
+  p = start;
+  for (gsnip = startSnip; PTRNE(gsnip, endSnip); gsnip = gsnip->next) {
+    style = gsnip->style;
+
+    if (newStyle)
+      style2 = newStyle;
+    else
+      style2 = styleList->FindOrCreateStyle(style, delta);
+
+    if (PTRNE(style, style2)) {
+      gsnip->style = style2;
+      if (rec)
+	rec->AddStyleChange(p, p + gsnip->count, style);
+
+      gsnip->SizeCacheInvalid();
+      gsnip->line->MarkRecalculate();
+      if (maxWidth > 0)
+	gsnip->line->MarkCheckFlow();
+
+      something = TRUE;
+    }
+
+    p += gsnip->count;
+  }
+
+  if (something) {
+    if (startSnip->line->prev
+	&& !(startSnip->line->prev->lastSnip->flags & wxSNIP_HARD_NEWLINE))
+      startSnip->line->prev->MarkCheckFlow();
+    
+    if (!modified)
+      AddUndo(new wxUnmodifyRecord);
+    if (rec)
+      AddUndo(rec);
+    if (delayRefresh)
+      delayedStreak = TRUE;
+    
+    CheckMergeSnips(start);
+    CheckMergeSnips(end);
+    
+    if (!modified)
+      SetModified(TRUE);
+
+    writeLocked = FALSE;
+    flowLocked = FALSE;
+
+    RefreshByLineDemand();
+  } else {
+    if (rec)
+      delete rec;
+    writeLocked = FALSE;
+    flowLocked = FALSE;
+
+    CheckMergeSnips(start);
+    CheckMergeSnips(end);
+  }
+
+  AfterChangeStyle(start, end - start);
+
+  return;
+
+ give_up:
+  writeLocked = FALSE;
+  flowLocked = FALSE;
+
+  return;
+}
+
+/****************************************************************/
+
+void wxMediaEdit::SettingAdmin(wxMediaAdmin * /* newadmin */)
+{
+  caretLocationX = -1;
+}
+
+void wxMediaEdit::InitNewAdmin(void)
+{
+  Redraw();
+}
+
+void wxMediaEdit::EndStreaks(int exception)
+{
+  if (map && (exception != wxSTREAK_KEY_SEQUENCE))
+    map->BreakSequence();
+  if (flash && flashautoreset && !flashdirectoff)
+    FlashOff();
+
+  typingStreak = FALSE;
+  deletionStreak = FALSE;
+  vcursorStreak = FALSE;  
+  if (anchorStreak && !keepAnchorStreak)
+    SetAnchor(FALSE);
+
+  if (exception != wxSTREAK_EXCEPT_DELAYED)
+    delayedStreak = FALSE;
+
+  killStreak = FALSE;
+
+  prevPasteStart = -1;
+}
+
+
+/****************************************************************/
+
+long wxMediaEdit::_FindPositionInLine(Bool internal, long i, float x, 
+				      Bool *ateol, Bool *onit,
+				      float *how_close)
+{
+  float w, X, topy;
+  wxSnip *snip;
+  wxDC *dc;
+  long p, sPos;
+  wxMediaLine *line;
+  Bool atsnipend;
+
+  if (onit)
+    *onit = FALSE;
+  if (how_close)
+    *how_close = 100;
+
+  if (!internal && !CheckRecalc(TRUE, FALSE))
+    return 0;
+
+  if (i < 0)
+    return 0;
+  if (i >= numValidLines)
+    return len;
+
+  line = lineRoot->FindLine(i);
+
+  if (ateol)
+    *ateol = FALSE;
+
+  if (x <= 0)
+    return FindFirstVisiblePosition(line);
+
+  p = line->GetPosition();
+
+  if (x >= line->w) {
+    /* snip == the last one */
+    snip = line->lastSnip;
+    sPos = p + line->len - snip->count;
+    p += line->len;
+  } else {
+    if (onit)
+      *onit = TRUE;
+
+    dc = admin->GetDC();
+    if (!dc)
+      return 0;
+    
+    X = 0;
+
+    Bool wl = writeLocked, fl = flowLocked;
+    writeLocked = TRUE;
+    flowLocked = TRUE;
+
+    /* linear seach for snip */
+    snip = NULL;
+    topy = line->GetLocation();
+    while(1) {
+      snip = snip ? snip->next : line->snip;
+
+      snip->GetExtent(dc, X, topy, &w);
+
+      if (x > w && snip->next) {
+	x -= w;
+	X += w;
+	p += snip->count;
+      } else {
+	/* Found the right snip */
+	sPos = p;
+	p += _FindPositionInSnip(dc, X, topy, snip, x, how_close);
+	break;
+      }
+    }
+
+    writeLocked = wl;
+    flowLocked = fl;
+  }
+
+  /* Back up over invisibles */
+  atsnipend = (p - sPos == snip->count);
+  if (atsnipend)
+    FindLastVisiblePosition(line, &p, &snip);
+
+  if (ateol && atsnipend && snip && PTREQ(snip, line->lastSnip))
+    *ateol = TRUE;
+
+  return p;
+}
+
+long wxMediaEdit::FindFirstVisiblePosition(wxMediaLine *line, wxSnip *snip)
+{
+  wxSnip *nextSnip;
+  long p, startp;
+
+  if (readLocked)
+    return 0;
+
+  if (!snip)
+    snip = line->snip;
+
+  p = startp = line->GetPosition();
+  nextSnip = line->lastSnip->next;
+
+  while (PTRNE(snip, nextSnip)) {
+    if (snip->flags & wxSNIP_INVISIBLE)
+      p += snip->count;
+    else
+      break;
+    snip = snip->next;
+  }
+
+  if (PTREQ(snip, nextSnip)) {
+    /* If everything is invisible, then presumably the CR is forced,
+       so go to the beginning of the line anyway */
+    p = startp;
+  }
+
+  return p;
+}
+
+void wxMediaEdit::FindLastVisiblePosition(wxMediaLine *line, long *p, 
+					  wxSnip **snipP)
+{
+  if (readLocked)
+    return;
+
+  wxSnip *snip;
+  
+  snip = snipP ? *snipP : (wxSnip *)NULL;
+
+  if (!snip)
+    snip = line->lastSnip;
+
+  do {
+    if (snip->flags & wxSNIP_INVISIBLE) {
+      *p -= snip->count;
+      if (PTRNE(snip, line->snip))
+	snip = snip->prev;
+    }
+  } while ((snip->flags & wxSNIP_INVISIBLE) && PTRNE(snip, line->snip));
+
+  if (snipP)
+    *snipP = snip;
+}
+
+/****************************************************************/
+
+long wxMediaEdit::_FindStringAll(char *str, int direction, 
+				 long start, long end,
+				 long **positions, Bool justOne,
+				 Bool bos, Bool caseSens)
+{
+  wxSnip *snip;
+  char text[256], *oldStr, c;
+  long *smap;
+  long sPos, p, n, thistime, thisoffset, need, checked, offset, shorten, i;
+  long slen, s, sbase, beyond, sgoal, totalCount, allocFound, foundCount;
+
+  if (!direction)
+    direction = 1;
+  if (direction < -1)
+    direction = -1;
+  else if (direction > 1)
+    direction = 1;
+
+  if (start < 0)
+    start = startpos;
+  if (end < 0) {
+    if (direction < 0)
+      end = 0;
+    else
+      end = len;
+  }
+  if (start > len)
+    start = len;
+  if (end > len)
+    end = len;
+
+  if (direction < 0)
+    totalCount = start - end;
+  else
+    totalCount = end - start;
+  if (totalCount < 0)
+    return -1;
+
+  slen = strlen(str);
+  if (!slen)
+    return -1;
+
+  if (!caseSens) {
+    oldStr = str;
+    str = new char[slen + 1];
+    for (i = 0; i < slen; i++)
+      str[i] = tolower(oldStr[i]);
+    str[i] = 0;
+  }
+  
+  snip = FindSnip(start, direction, &sPos);
+  if (!snip)
+    return -1;
+
+  if (direction > 0) {
+    offset = start - sPos;
+    shorten = 0;
+    sbase = 0;
+    beyond = -1;
+    sgoal = slen;
+  } else {
+    shorten = (sPos + snip->count) - start;
+    offset = 0;
+    sbase = slen - 1;
+    beyond = slen;
+    sgoal = -1;
+  }
+
+  smap = new long[slen];
+
+  smap[sbase] = beyond;
+  s = beyond;
+  for (i = sbase + direction; i != sgoal; i += direction) {
+    while ((s != beyond) && (str[s + direction] != str[i]))
+      s = smap[s];
+    if (str[s + direction] == str[i])
+      s += direction;
+    smap[i] = s;
+  }
+
+  s = beyond;
+
+  if (!justOne) {
+    allocFound = 10;
+    *positions = new long[allocFound];
+    foundCount = 0;
+  } else
+    allocFound = foundCount = 0;
+
+  while (snip && totalCount) {
+    need = snip->count - shorten - offset;
+    if (need > totalCount) {
+      if (direction < 0)
+	offset += (need - totalCount);
+      need = totalCount;
+    }
+
+    checked = 0;
+
+    totalCount -= need;
+
+    do {
+      thistime = need;
+      if (thistime > 255)
+	thistime = 255;
+      need -= thistime;
+
+      thisoffset = offset + ((direction < 0) ? need : checked);
+
+      Bool wl = writeLocked, fl = flowLocked;
+      writeLocked = TRUE;
+      flowLocked = TRUE;
+      
+      snip->GetText((char *)text, thisoffset, thistime);
+
+      writeLocked = wl;
+      flowLocked = fl;
+
+      text[thistime] = 0;
+      
+      i = (direction > 0) ? 0 : thistime - 1;
+      n = thistime;
+      while(n--) {
+	c = text[i];
+	if (!caseSens)
+	  if (c >= 'A' && c <= 'Z')
+	    c += ('a' - 'A');
+	while ((s != beyond) && (str[s + direction] != c))
+	  s = smap[s];
+	if (str[s + direction] == c) {
+	  s += direction;
+	  if (s + direction == sgoal) {
+	    p = sPos + i + thisoffset;
+	    if (bos) {
+	      if (direction < 0)
+		p += slen;
+	      else
+		p -= (slen - 1);
+	    } else if (direction > 0)
+	      p++;
+	    if (justOne)
+	      goto search_done;
+	    else {
+	      if (foundCount == allocFound) {
+		long *old = *positions, oldCount = allocFound;
+
+		allocFound *= 2;
+		*positions = new long[allocFound];
+
+		memcpy(*positions, old, oldCount * sizeof(long));
+	      }
+	      (*positions)[foundCount++] = p;
+	      s = beyond;
+	    }
+	  }
+	}
+	i += direction;
+      }
+
+      checked += thistime;
+    } while(need);
+
+    if (direction > 0)
+      sPos += snip->count;
+    snip = (direction > 0) ? snip->next : snip->prev;
+    if (snip) {
+      if (direction < 0)
+	sPos -= snip->count;
+    }
+    offset = shorten = 0;
+  }
+
+  p = -1;
+
+ search_done:
+  delete[] smap;
+
+  return justOne ? p : foundCount;
+}
+
+/****************************************************************/
+
+void wxMediaEdit::MakeOnlySnip(void)
+{
+  snips = new wxTextSnip();
+  snips->style = styleList->FindNamedStyle(STD_STYLE);
+#if CHECK_CONSISTENCY
+  if (!snips->style)
+    fprintf(stderr, "NULL style for STD_STYLE!\n");
+#endif
+  snips->count = 0;
+  snips->SetAdmin(snipAdmin);
+  snips->prev = NULL;
+  snips->next = NULL;
+
+  snips->line = lineRoot = firstLine = lastLine = new wxMediaLine;
+
+  lineRoot->snip = lineRoot->lastSnip = snips;
+
+  lastSnip = snips;
+  snipCount = 1;
+
+  numValidLines = 1;
+}
+
+void wxMediaEdit::SpliceSnip(wxSnip *snip, wxSnip *prev, wxSnip *next)
+{
+  if (prev)
+    prev->next = snip;
+  else
+    snips = snip;
+  snip->prev = prev;
+  snip->next = next;
+  if (next)
+    next->prev = snip;
+  else
+    lastSnip = snip;
+}
+
+void wxMediaEdit::InsertSnip(wxSnip *before, wxSnip *snip)
+{
+  if (PTREQ(snips, lastSnip) && !snips->count) {
+    AppendSnip(snip);
+  } else {
+    SpliceSnip(snip, before->prev, before);
+    snipCount++;
+  }
+}
+
+void wxMediaEdit::AppendSnip(wxSnip *snip)
+{
+  if (PTREQ(snips, lastSnip) && !snips->count) {
+    /* Get rid of empty snip */
+    delete snips;
+    snips = lastSnip = snip;
+  } else {
+    SpliceSnip(snip, lastSnip, NULL);
+    snipCount++;
+  }
+}
+
+void wxMediaEdit::DeleteSnip(wxSnip *snip)
+{
+  if (snip->next)
+    SpliceSnip(snip->next, snip->prev, snip->next->next);
+  else if (snip->prev)
+    SpliceSnip(snip->prev, snip->prev->prev, snip->next);
+  else {
+    lastSnip = snips = NULL;
+  }
+  --snipCount;
+  snip->flags += wxSNIP_CAN_DISOWN;
+  SnipSetAdmin(snip, NULL);
+  snip->line = NULL;
+  snip->prev = snip->next = NULL;
+  snip->flags -= wxSNIP_CAN_DISOWN;
+}
+
+wxSnip *wxMediaEdit::SnipSetAdmin(wxSnip *snip, wxSnipAdmin *a)
+{
+  wxSnipAdmin *orig_admin = snip->GetAdmin();
+  long orig_count = snip->count;
+  wxMediaLine *line = snip->line;
+
+  Bool wl = writeLocked, fl = flowLocked;
+  readLocked = writeLocked = flowLocked = TRUE;
+  snip->SetAdmin(a);
+  readLocked = FALSE; writeLocked = wl; flowLocked = fl;
+
+  if (snip->GetAdmin() != a) {
+    /* Something went wrong. */
+    if (!a && (snip->GetAdmin() == orig_admin)) {
+      /* Force admin to NULL. */
+      snip->wxSnip::SetAdmin(NULL);
+    } else if (a) {
+      /* Snip didn't accept membership into this buffer. Give up on it. */
+      wxSnip *naya = new wxSnip();
+      naya->count = orig_count;
+      SpliceSnip(naya, snip->prev, snip->next);
+      naya->line = line;
+
+      if (line) {
+	if (line->snip == snip)
+	  line->snip = naya;
+	if (line->lastSnip == snip)
+	  line->lastSnip = naya;
+      }
+
+      snip->wxSnip::SetAdmin(NULL);
+
+      naya->SetAdmin(a);
+      snip = naya;
+    }
+  }
+
+  /* Force count to be consistent: */
+  if (a && (snip->count != orig_count))
+    snip->count = orig_count;
+
+  return snip;
+}
+
+void wxMediaEdit::SnipSplit(wxSnip *snip, long pos, wxSnip **a_ptr, wxSnip **b_ptr)
+{
+  int c = snip->count;
+  wxSnip *a, *b;
+
+  snip->flags |= wxSNIP_CAN_SPLIT;
+  wxSnip *orig = snip;
+
+  DeleteSnip(snip);
+  orig->flags -= wxSNIP_OWNED;
+
+  Bool wl = writeLocked, fl = flowLocked;
+  readLocked = writeLocked = flowLocked = TRUE;
+  *a_ptr = NULL;
+  *b_ptr = NULL;
+  snip->Split(pos, a_ptr, b_ptr);
+  readLocked = FALSE; writeLocked = wl; flowLocked = fl;
+
+  a = *a_ptr;
+  b = *b_ptr;
+
+  if (!a)
+    a = new wxSnip();
+  if (!b)
+    b = new wxSnip();
+
+  if (a->IsOwned()) {
+    /* uh-oh: make up a dummy */
+     a = new wxSnip();
+  }
+  if (b->IsOwned()) {
+    /* uh-oh: make up a dummy */
+     b = new wxSnip();
+  }
+
+  *a_ptr = a;
+  *b_ptr = b;
+
+  if (a->flags & wxSNIP_CAN_SPLIT)
+    a->flags -= wxSNIP_CAN_SPLIT;
+  if (b->flags & wxSNIP_CAN_SPLIT)
+    b->flags -= wxSNIP_CAN_SPLIT;
+  if (orig->flags & wxSNIP_CAN_SPLIT)
+    orig->flags -= wxSNIP_CAN_SPLIT;
+
+  /* Make *sure* that count is right */
+  a->count = pos;
+  b->count = c - pos;
+}
+
+/****************************************************************/
+
+wxSnip *wxMediaEdit::FindSnip(long p, int direction, long *sPos)
+{
+  wxSnip *snip;
+  wxMediaLine *line;
+  long pos;
+
+  if ((direction < -1) && !p)
+    return NULL;
+
+  line = lineRoot->FindPosition(p);
+  pos = line->GetPosition();
+  p -= pos;
+  if (sPos)
+    *sPos = pos;
+
+  snip = line->snip;
+  if (!p && snip->prev) {
+    /* Back up one: */
+    snip = snip->prev;
+    p += snip->count;
+    if (sPos)
+      *sPos -= snip->count;
+  }
+
+  for (; snip; snip = snip->next) {
+    p -= snip->count;
+    if ((!direction && !p)
+	|| ((direction < 0) && (p <= 0))
+	|| ((direction > 0) && (p < 0)))
+      return snip;
+
+    if (!direction && (p < 0))
+      return NULL;
+
+    if (sPos)
+      *sPos += snip->count;
+  }
+
+  if (direction < 2)
+    return lastSnip;
+  else
+    return NULL;
+}
+
+void wxMediaEdit::MakeSnipset(long start, long end) 
+{
+  long sPos;
+  wxSnip *prev, *next, *snip, *insSnip;
+  wxStyle *style;
+  wxMediaLine *line;
+  Bool atStart, atEnd;
+
+  if (start) {
+    snip = FindSnip(start, +1, &sPos);
+    if (start != sPos) {
+      line = snip->line;
+      prev = snip->prev; next = snip->next;
+      style = snip->style;
+      
+      atStart = PTREQ(line->snip, snip);
+      atEnd = PTREQ(line->lastSnip, snip);
+      
+      SnipSplit(snip, start - sPos, &insSnip, &snip);
+      
+      snip->style = insSnip->style = style;
+      
+      snip->line = insSnip->line = line;
+      if (atStart)
+	line->snip = insSnip;
+      if (atEnd)
+	line->lastSnip = snip;
+      
+      SpliceSnip(snip, prev, next);
+      snipCount++;
+      InsertSnip(snip, insSnip);
+      
+      SnipSetAdmin(snip, snipAdmin);
+      SnipSetAdmin(insSnip, snipAdmin);
+    }
+  }
+
+  if (end) {
+    snip = FindSnip(end, -1, &sPos);
+    if (end != sPos + snip->count) {
+      line = snip->line;
+      prev = snip->prev; next = snip->next;
+      style = snip->style;
+      
+      atStart = PTREQ(line->snip, snip);
+      atEnd = PTREQ(line->lastSnip, snip);
+      
+      SnipSplit(snip, end - sPos, &insSnip, &snip);
+      
+      snip->style = insSnip->style = style;
+      
+      snip->line = insSnip->line = line;
+      if (atStart)
+	line->snip = insSnip;
+      if (atEnd)
+	line->lastSnip = snip;
+      
+      SpliceSnip(snip, prev, next);
+      snipCount++;
+      InsertSnip(snip, insSnip);
+      
+      SnipSetAdmin(snip, snipAdmin);
+      SnipSetAdmin(insSnip, snipAdmin);
+    }
+  }
+}
+
+wxTextSnip *wxMediaEdit::InsertTextSnip(long start, wxStyle *style)
+{
+  long sPos;
+  wxSnip *gsnip, *insGsnip, *prev, *next;
+  wxTextSnip *snip;
+  wxStyle *gstyle;
+  wxMediaLine *line;
+  Bool atStart, atEnd;
+
+  snip = OnNewTextSnip();
+  if (snip->IsOwned() || snip->count) {
+    /* Uh-oh. Resort to wxTextSnip() */
+    snip = new wxTextSnip();
+  }
+  snip->style = (style ? style : styleList->FindNamedStyle(STD_STYLE));
+  wxSnip *rsnip = SnipSetAdmin(snip, snipAdmin);
+  if (rsnip != snip) {
+    /* Uh-oh. Resort to wxTextSnip() */
+    snip = new wxTextSnip();
+    snip->style = (style ? style : styleList->FindNamedStyle(STD_STYLE));
+    snip->SetAdmin(snipAdmin);
+  }
+  snip->count = 0;
+
+  gsnip = FindSnip(start, +2, &sPos);
+  if (!gsnip) {
+    AppendSnip(snip);
+    snip->line = lastLine;
+    if (PTREQ(lastLine->snip, lastSnip))
+      lastLine->snip = lastLine->lastSnip = snip;
+    else
+      lastLine->lastSnip = snip;
+  } else if (start == sPos) {
+    InsertSnip(gsnip, snip);
+    snip->line = gsnip->line;
+    if (PTREQ(snip->line->snip, gsnip))
+      snip->line->snip = snip;
+  } else {
+    prev = gsnip->prev; next = gsnip->next;
+    gstyle = gsnip->style;
+    line = gsnip->line;
+
+    atStart = PTREQ(line->snip, gsnip);
+    atEnd = PTREQ(line->lastSnip, gsnip);
+
+    SnipSplit(gsnip, start - sPos, &insGsnip, &gsnip);
+    
+    gsnip->style = insGsnip->style = gstyle;
+
+    gsnip->line = insGsnip->line = snip->line = line;
+    if (atStart)
+      line->snip = insGsnip;
+    if (atEnd)
+      line->lastSnip = gsnip;
+
+    SpliceSnip(gsnip, prev, next);
+    snipCount++;
+    InsertSnip(gsnip, snip);
+    InsertSnip(snip, insGsnip);
+
+    SnipSetAdmin(gsnip, snipAdmin);
+    SnipSetAdmin(insGsnip,snipAdmin);
+  }
+
+  return snip;
+}
+
+void wxMediaEdit::CheckMergeSnips(long start)
+{
+  wxSnip *snip1, *snip2, *prev, *next;
+  long sPos1, sPos2, c;
+
+  wxMediaLine *line;
+  Bool atStart, atEnd;
+
+  snip1 = FindSnip(start, -1, &sPos1);
+  snip2 = FindSnip(start, +1, &sPos2);
+
+  if (PTRNE(snip1, snip2)) {
+    if (snip1->snipclass 
+#if USE_OLD_TYPE_SYSTEM
+	&& (snip1->__type == snip2->__type)
+#endif
+	&& PTREQ(snip1->snipclass, snip2->snipclass)
+	&& PTREQ(snip1->style, snip2->style)) {
+      if (!(snip1->flags & wxSNIP_NEWLINE)
+	  && (snip1->flags & wxSNIP_CAN_APPEND) 
+	  && (snip2->flags & wxSNIP_CAN_APPEND)
+	  && (snip1->count + snip2->count < MAX_COUNT_FOR_SNIP)) {
+	if (!snip1->count) {
+	  if (PTREQ(snip1->line->snip, snip1))
+	    snip1->line->snip = snip2;
+	  DeleteSnip(snip1);
+	  snip1->flags -= wxSNIP_OWNED;
+	  CheckMergeSnips(start);
+	} else if (!snip2->count) {
+	  if (PTREQ(snip1->line->lastSnip, snip2)) {
+	    snip1->line->lastSnip = snip1;
+	    snip1->line->MarkRecalculate(); // need lastW updated
+	    graphicMaybeInvalid = TRUE;
+	  }
+	  DeleteSnip(snip2);
+	  snip2->flags -= wxSNIP_OWNED;
+	  CheckMergeSnips(start);
+	} else {
+	  wxSnip *naya;
+
+	  c = snip1->count + snip2->count;
+	  prev = snip1->prev;
+	  next = snip2->next;
+	  line = snip1->line;
+	  atStart = PTREQ(line->snip, snip1);
+	  atEnd = PTREQ(line->lastSnip, snip2);
+	  snip2->flags |= wxSNIP_CAN_SPLIT;
+
+	  Bool wl = writeLocked, fl = flowLocked;
+	  readLocked = writeLocked = flowLocked = TRUE;
+	  naya = snip2->MergeWith(snip1);
+	  readLocked = FALSE; writeLocked = wl; flowLocked = fl;
+
+	  if (naya) {
+	    if (snip1->flags & wxSNIP_CAN_SPLIT)
+	      snip1->flags -= wxSNIP_CAN_SPLIT;
+	    if (snip2->flags & wxSNIP_CAN_SPLIT)
+	      snip2->flags -= wxSNIP_CAN_SPLIT;
+
+	    /* Claim snip1 & snip2 unowned for naya test: */
+	    snip1->flags -= wxSNIP_OWNED;
+	    snip2->flags -= wxSNIP_OWNED;
+	    if (naya->IsOwned()) {
+	      /* Uh-oh. Make dummy */
+	      naya = new wxSnip();
+	    }
+	    if (naya->flags & wxSNIP_CAN_SPLIT)
+	      naya->flags -= wxSNIP_CAN_SPLIT;
+	    snip1->flags += wxSNIP_OWNED;
+	    snip2->flags += wxSNIP_OWNED;
+
+	    DeleteSnip(snip1);
+	    snip1->flags -= wxSNIP_OWNED;
+	    DeleteSnip(snip2);
+	    snip2->flags -= wxSNIP_OWNED;
+
+	    SpliceSnip(naya, prev, next);
+	    snipCount++;
+	    /* Make *sure* that count is right */
+	    naya->count = c;
+
+	    naya = SnipSetAdmin(naya, snipAdmin);
+
+	    naya->line = line;
+	    if (atStart)
+	      line->snip = naya;
+	    if (atEnd) {
+	      line->lastSnip = naya;
+	      line->MarkRecalculate(); // need lastW updated
+	      graphicMaybeInvalid = TRUE;
+	    }
+	  } else if (snip2->flags & wxSNIP_CAN_SPLIT)
+	    snip2->flags -= wxSNIP_CAN_SPLIT;
+	}
+      }
+    }
+  }
+}
+
+wxTextSnip *wxMediaEdit::OnNewTextSnip()
+{
+  return new wxTextSnip();
+}
+
+wxTabSnip *wxMediaEdit::OnNewTabSnip()
+{
+  return new wxTabSnip();
+}
+
+/****************************************************************/
+
+Bool wxMediaEdit::GetSnipPositionAndLocation(wxSnip *thesnip, long *pos, 
+					     float *x, float *y)
+{
+  wxSnip *snip;
+  long p;
+
+  if (!CheckRecalc(x || y, FALSE))
+    return FALSE;
+
+  if (!thesnip->line || PTRNE(thesnip->line->GetRoot(), lineRoot))
+    return FALSE;
+
+  if (pos || x || y) {
+    p = thesnip->line->GetPosition();
+    
+    for (snip = thesnip->line->snip; PTRNE(snip, thesnip); snip = snip->next)
+      p += snip->count;
+    
+    if (pos)
+      *pos = p;
+    
+    if (x || y) 
+      PositionLocation(p, x, y);
+  }
+
+  return TRUE;
+}
+
+Bool wxMediaEdit::GetSnipLocation(wxSnip *thesnip, float *x, float *y, Bool bottomRight)
+{
+  float lx, ly;
+
+  if (bottomRight) {
+    if (!x)
+      x = &lx;
+    if (!y)
+      y = &ly;
+  }
+
+  if (GetSnipPositionAndLocation(thesnip, NULL, x, y)) {
+    if (bottomRight) {
+      wxDC *dc = admin->GetDC();
+      float w, h;
+      
+      Bool wl = writeLocked, fl = flowLocked;
+      writeLocked = TRUE;
+      flowLocked = TRUE;
+      
+      thesnip->GetExtent(dc, *x, *y, &w, &h);
+
+      writeLocked = wl;
+      flowLocked = fl;
+
+      *x += w;
+      *y += h;
+    }
+     
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+long wxMediaEdit::GetSnipPosition(wxSnip *thesnip)
+{
+  long pos;
+
+  if (GetSnipPositionAndLocation(thesnip, &pos))
+    return pos;
+  else
+    return -1;
+}
+
+/****************************************************************/
+
+void wxMediaEdit::AdjustClickbacks(long start, long end, 
+				   long d, wxDeleteRecord *rec)
+{
+  wxNode *node, *next;
+  wxClickback *click;
+  Bool deleteit;
+
+  for (node = clickbacks->First(); node; node = next) {
+    next = node->Next();
+    click = (wxClickback *)node->Data();
+    deleteit = FALSE;
+    if (click->start >= start && click->end <= end) {
+      deleteit = TRUE;
+    } else if (click->start >= end) {
+      click->start += d;
+      click->end += d;
+    } else if (click->start <= start && click->end > end)
+      click->end += d;
+    else if (click->start > start && click->end > end) {
+      click->start = start;
+      click->end += d;
+    }
+
+    if (click->end == click->start)
+      deleteit = TRUE;
+    if (deleteit) {
+      clickbacks->DeleteNode(node);
+      if (rec)
+	rec->AddClickback(click);
+      else
+	delete click;
+    }
+  }
+}
+
+wxClickback *wxMediaEdit::FindClickback(long start)
+{
+  wxNode *node;
+  wxClickback *click;
+
+  for (node = clickbacks->First(); node; node = node->Next()) {
+    click = (wxClickback *)node->Data();
+    if (click->start <= start && click->end > start)
+      return click;
+  }
+
+  return NULL;
+}
+
+void wxMediaEdit::SetClickbackHilited(wxClickback *click, Bool on)
+{
+  if (on != click->hilited) {
+    if (on) {
+      interceptmode = TRUE;
+      intercepted = new wxList();
+      
+      BeginEditSequence();
+      FlashOn(click->start, click->end, FALSE, FALSE, -1);
+      ChangeStyle(click->delta, click->start, click->end);
+      EndEditSequence();
+
+      click->unhilite = intercepted;
+      interceptmode = FALSE;
+    } else {
+      PerformUndoList(click->unhilite);
+
+      wxNode *node;
+      for (node = click->unhilite->First(); node; node = node->Next())
+	delete (wxChangeRecord *)node->Data();
+  
+      delete click->unhilite;
+      FlashOff();
+    }
+    click->hilited = on;
+  }
+}
+
+/****************************************************************/
+
+Bool wxMediaEdit::CheckRecalc(Bool need_graphic, Bool need_write, Bool no_display_ok)
+{
+  if (readLocked)
+    return FALSE;
+  if (writeLocked && need_write)
+    return FALSE;
+
+  if (need_graphic) {
+    if (!admin)
+      return FALSE;
+
+    if (graphicMaybeInvalid) {
+      if (flowLocked)
+	return FALSE;
+
+      wxDC *dc;
+
+      dc = admin->GetDC();
+      if (!dc) {
+	if (no_display_ok)
+	  return TRUE;
+	return FALSE;
+      }
+      
+      RecalcLines(dc, need_graphic);
+    }
+  }
+
+  return TRUE;
+}
+
+Bool wxMediaEdit::CheckFlow(float maxw, wxDC *dc, float Y, 
+			    long startp, wxSnip *start)
+  /* This method is called with writeLocked and flowLocked already TRUE */
+{
+  long p, c, origc, b;
+  float totalWidth, w;
+  wxSnip *snip;
+  Bool checkingUnderflow; // no overflow => check move up from next line
+  Bool checkingUnderflowAtNext;
+  Bool noChangeIfEndOfSnip, noChangeIfStartOfSnip;
+  Bool theFirstSnip, firstUnderflow, hadNewline;
+
+  totalWidth = 0;
+  p = startp;
+  checkingUnderflow = FALSE; // start by insuring no overflow
+  checkingUnderflowAtNext = FALSE;
+  noChangeIfEndOfSnip = TRUE; // Because an immediate overflow can't be helped
+  noChangeIfStartOfSnip = FALSE;
+  theFirstSnip = TRUE;
+  firstUnderflow = FALSE;
+
+  for (snip = start; 
+       snip && !(snip->flags & wxSNIP_HARD_NEWLINE); 
+       snip = snip->next) {
+
+    if (!checkingUnderflow) {
+      if ((checkingUnderflow = checkingUnderflowAtNext))
+	firstUnderflow = TRUE;
+    }
+    noChangeIfStartOfSnip = noChangeIfEndOfSnip;
+
+    if (snip->flags & wxSNIP_NEWLINE) {
+      noChangeIfEndOfSnip = !checkingUnderflow;
+      snip->flags -= wxSNIP_NEWLINE;
+      checkingUnderflowAtNext = TRUE;
+      hadNewline = TRUE;
+    } else {
+      noChangeIfEndOfSnip = FALSE;
+      checkingUnderflowAtNext = FALSE;
+      hadNewline = FALSE;
+    }
+
+    snip->GetExtent(dc, totalWidth, Y, &w);
+    totalWidth += w;
+    if (totalWidth > maxw) {
+      totalWidth -= w;
+      /* Get best breaking position: (0.1 is hopefully a positive value smaller than any character) */
+      origc = _FindPositionInSnip(dc, totalWidth, Y, snip, maxw - totalWidth - 0.1);
+
+      /* get legal breaking position before optimal: */
+      b = p + origc + 1;
+      FindWordbreak(&b, NULL, wxBREAK_FOR_LINE);
+      c = b - p;
+      if (c > origc)
+	c = origc;
+
+      if (c <= 0) {
+	if ((b <= startp) && checkingUnderflow && origc) {
+	  /* The word was currently force-broken; shift some part to here */
+	  p = p + origc;
+	} else if ((checkingUnderflow && firstUnderflow
+		    && (b <= startp || c>= 0))
+		   || (!theFirstSnip 
+		       && (!c || (!origc && (c < 0) && (b <= startp))))) {
+	  /* Can't fit this snip in the line */
+	  if (snip->prev)
+	    snip->prev->flags |= wxSNIP_NEWLINE;
+	  if (hadNewline && snip->next)
+	    snip->flags |= wxSNIP_NEWLINE;
+	  if (noChangeIfStartOfSnip && (!hadNewline || snip->next))
+	    return FALSE;
+	  refreshAll = TRUE;
+	  return TRUE;
+	} else if ((c < 0) && (b > startp)) {
+	  /* Overflow, but previous wordbreak was before this snip */
+	  p = b;
+	} else {
+	  /* Overflow: we have to break the word anyway */
+	  if (!origc) {
+	    if ((snip->count == 1) 
+		&& snip->next
+		&& (snip->next->flags & wxSNIP_HARD_NEWLINE)) {
+	      /* don't insert a break before a real newline */
+	      break;
+	    } else
+	      p++;
+	  } else
+	    p += origc;
+	}
+      } else {
+	p = p + c;
+      }
+      MakeSnipset(p, p);
+      snip = FindSnip(p, -1);
+      if (snip->next)
+	snip->flags |= wxSNIP_NEWLINE;
+      refreshAll = TRUE;
+      return TRUE;
+    }
+    
+    p += snip->count;
+
+    theFirstSnip = FALSE;
+    firstUnderflow = FALSE;
+  }
+
+  if (!snip 
+      && (lastSnip->flags & wxSNIP_NEWLINE)
+      && !(lastSnip->flags & wxSNIP_HARD_NEWLINE)) {
+    lastSnip->flags -= wxSNIP_NEWLINE;
+    refreshAll = TRUE;
+    return TRUE;
+  }
+
+  if (!checkingUnderflow || noChangeIfEndOfSnip)
+    return FALSE;
+  else {
+    refreshAll = TRUE;
+    return TRUE;
+  }
+}
+
+#if CHECK_CONSISTENCY
+static int CheckRBConsistent(wxMediaLine *line)
+{
+  Bool red;
+  int l, r;
+
+  if (line == NIL)
+    return 0;
+
+  red = (line->flags & 1);
+
+  if (red) {
+    if (line->left->flags & 1)
+      fprintf(stderr, "Red left inconsistency\n");
+    if (line->right->flags & 1)
+      fprintf(stderr, "Red right inconsistency\n");
+  }
+
+  l = CheckRBConsistent(line->left);
+  r = CheckRBConsistent(line->right);
+
+  if (l != r)
+    fprintf(stderr, "Black count inconsistency\n");
+  
+  return l + (red ? 0 : 1);
+}
+#endif
+
+void wxMediaEdit::RecalcLines(wxDC *dc, Bool calcGraphics)
+{
+  wxMediaLine *line;
+  wxSnip *snip;
+  float X, Y, descent, space;
+  Bool changed, resized;
+
+  if (!calcGraphics)
+    return;
+
+  changed = FALSE;
+
+#if CHECK_CONSISTENCY
+  long p, p2;
+
+  snip = snips;
+
+  if (firstLine != lineRoot->First())
+    fprintf(stderr, "First line inconsistency\n");
+  if (lastLine != lineRoot->Last())
+    fprintf(stderr, "Last line inconsistency\n");
+
+  if (firstLine->prev)
+    fprintf(stderr, "First line prev inconsistency\n");
+  if (lastLine->next)
+    fprintf(stderr, "First line next inconsistency\n");
+
+  if (firstLine->snip != snips)
+    fprintf(stderr, "First line first snip inconsistency\n");
+  if (lastLine->lastSnip != lastSnip)
+    fprintf(stderr, "Last line last snip inconsistency\n");
+
+  CheckRBConsistent(lineRoot);
+
+  Y = 0;
+  p = 0;
+  for (line = firstLine; line; line = line->next) {
+    if (line->snip != snip)
+      fprintf(stderr, "Line start inconsistency\n");
+    
+    if (line->GetPosition() != p)
+      fprintf(stderr, "Line position inconsistency\n");
+    if (line->GetLocation() != Y)
+      fprintf(stderr, "Line location inconsistency\n");
+
+    if (line->prev && (line->snip != line->prev->lastSnip->next))
+      fprintf(stderr, "Line snip continuity inconsistency\n");
+
+    p2 = p;
+    for (snip = line->snip; snip && snip != line->lastSnip; snip = snip->next){
+      if (snip->line != line)
+	fprintf(stderr, "Snip's line inconsistency\n");
+      if (!snip->style)
+	fprintf(stderr, "Snip's style missing\n");
+      if (*snip->admin_ptr != snipAdmin)
+	fprintf(stderr, "Snip's admin inconsistency\n");
+      if (!(snip->flags & wxSNIP_OWNED))
+	fprintf(stderr, "Snip's is-owned inconsistency\n");
+      p2 += snip->count;
+    }
+    if (snip->line != line)
+	fprintf(stderr, "Snip's line inconsistency\n");
+
+    if (!snip)
+      fprintf(stderr, "Line end inconsistency\n");
+
+    p2 += snip->count;
+    if ((p2 - p) != line->len)
+      fprintf(stderr, "Line count inconsistency\n");
+
+    snip = line->lastSnip->next;
+
+    if (!line->next && line != lastLine)
+      fprintf(stderr, "Last line link inconsistency\n");
+
+    wxMediaLine *other;
+    if (line->left != NIL) {
+      for (other=line->prev; other && other != line->left; other=other->prev);
+      if (!other)
+	fprintf(stderr, "Left link inconsistency\n");
+    }
+    if (line->right != NIL) {
+      for (other=line->next; other && other!=line->right; other=other->next);
+      if (!other)
+	fprintf(stderr, "Right link inconsistency\n");
+    }
+    if (line->parent == NIL) {
+      if (line != lineRoot)
+	fprintf(stderr, "Root inconsistency\n");
+    } else if (line != line->parent->right && line != line->parent->left)
+      fprintf(stderr, "Parent inconsistency\n");
+
+    Y += line->h;
+    p += line->len;
+  }
+  if (p != len)
+    fprintf(stderr, "Total count inconsistency\n");
+
+#endif
+
+  if (snipCacheInvalid)
+    for (snip = snips; snip; snip = snip->next)
+      snip->SizeCacheInvalid();
+
+  float old_max_width = maxWidth;
+
+  if (flowInvalid && (maxWidth <= 0))
+    maxWidth = A_VERY_BIG_NUMBER;
+
+  if (graphicsInvalid || flowInvalid || snipCacheInvalid) {
+    /* Set all lines invalid. */
+    for (line = firstLine; line; line = line->next) {
+      line->MarkRecalculate();
+      if (flowInvalid)
+	line->MarkCheckFlow();
+    }
+  }
+
+#if LOOK_FOR_ZEROED
+  if (len)
+    for (snip = snips, i = 0; snip; snip = snip->next)
+      if (!snip->count)
+	fprintf(stderr, "zero snip found at %d\n", i);
+      else
+	i += snip->count;
+#endif
+
+  if (maxWidth > 0) {
+    Bool fl = flowLocked, wl = writeLocked;
+
+    /* If any flow is update, snip sizing methods will be called. */
+    flowLocked = TRUE;
+    writeLocked = TRUE;
+
+    float w;
+    w = maxWidth - CURSOR_WIDTH;
+    while (lineRoot->UpdateFlow(&lineRoot, this, w, dc))
+      changed = TRUE;
+
+    flowLocked = fl;
+    writeLocked = wl;    
+  }
+
+  if (old_max_width != maxWidth)
+    maxWidth = old_max_width;
+
+  if (changed) {
+    refreshAll = TRUE;
+    firstLine = lineRoot->First();
+    lastLine = lineRoot->Last();
+    numValidLines = lineRoot->Number();
+  }
+
+  if (lineRoot->UpdateGraphics(this, dc))
+    changed = TRUE;
+
+  if (!changed && !graphicMaybeInvalidForce) {
+    graphicMaybeInvalid = FALSE;
+    return;
+  }
+
+  graphicMaybeInvalid = FALSE;
+  graphicMaybeInvalidForce = FALSE;
+
+  Y = lastLine->GetLocation() + lastLine->h;
+
+  if (lastSnip->flags & wxSNIP_NEWLINE) {
+    extraLine = TRUE;
+    extraLineH = lastLine->lastH + lineSpacing;
+    Y += extraLineH;
+  } else {
+    extraLine = FALSE;
+    extraLineH = 0;
+  }
+
+  X = lineRoot->maxWidth + CURSOR_WIDTH;
+  if (minWidth > 0 && X < minWidth)
+    X = minWidth;
+
+  if (minHeight > 0 && Y < minHeight)
+    Y = minHeight;
+  if (maxHeight > 0 && Y > maxHeight)
+    Y = maxHeight;
+
+  descent = lastLine->h - lastLine->bottombase;
+  space = firstLine->topbase;
+  
+  if (totalHeight != Y || totalWidth != X 
+      || finalDescent != descent || initialSpace != space) {
+    totalHeight = Y;
+    totalWidth = X;
+    finalDescent = descent;
+    initialSpace = space;
+    resized = TRUE;
+  } else
+    resized = FALSE;
+
+  graphicsInvalid = FALSE;  
+  flowInvalid = FALSE;
+  snipCacheInvalid = FALSE;
+
+  drawCachedInBitmap = FALSE;
+
+  if (resized && admin)
+    admin->Resized(FALSE);
+}
+
+static wxMemoryDC *autowrapMemDC = NULL;
+static wxBitmap *lastSetAWMDC = NULL;
+
+wxBitmap *wxMediaEdit::SetAutowrapBitmap(wxBitmap *bm)
+{
+  wxBitmap *old;
+  float oldWidth;
+
+  if (flowLocked)
+    return NULL;
+
+  old = autoWrapBitmap;
+
+  autoWrapBitmap = bm;
+  oldWidth = wrapBitmapWidth;
+  if (autoWrapBitmap)
+    wrapBitmapWidth = autoWrapBitmap->GetWidth();
+  else
+    wrapBitmapWidth = 0;
+
+  if (maxWidth > 0)
+    SetMaxWidth(maxWidth + oldWidth);
+
+  if (old && PTREQ(old, lastSetAWMDC)) {
+    autowrapMemDC->SelectObject(NULL);
+    lastSetAWMDC = NULL;
+  }
+
+  return old;
+}
+
+static skipBox = FALSE;
+static wxPen *caretPen = NULL;
+
+/* This does the actual drawing */
+void wxMediaEdit::Redraw(wxDC *dc, float starty, float endy, 
+			 float leftx, float rightx,
+			 float dy, float dx, 
+			 int show_caret, int show_xsel)
+{
+  wxMediaLine *line;
+  wxSnip *snip, *first, *last;
+  float x, topbase, bottombase, hxs, hxe, hsxs, hsxe, hsys, hsye, down, bottom;
+  float tleftx, tstarty, trightx, tendy;
+  float h, w, descent, space, ycounter, prevwasfirst = 0.0;
+  long p, pcounter;
+  long startpos, endpos;
+  Bool posAtEol;
+  Bool hilite, hiliteSome;
+  int align;
+  wxStyle *oldStyle;
+  wxPen *savePen;
+  wxBrush *saveBrush;
+  static wxPen *outlinePen = NULL;
+  static wxBrush *outlineBrush = NULL;
+#if ALLOW_X_STYLE_SELECTION
+  static wxBrush *outlineNonownerBrush = NULL;
+#if 1
+  static char xpattern[32] = {0x88, 0x88,
+			      0x00, 0x00,
+			      0x22, 0x22, 
+			      0x00, 0x00,
+			      0x88, 0x88,
+			      0x00, 0x00,
+			      0x22, 0x22,
+			      0x00, 0x00,
+			      0x88, 0x88,
+			      0x00, 0x00,
+			      0x22, 0x22, 
+			      0x00, 0x00,
+			      0x88, 0x88,
+			      0x00, 0x00,
+			      0x22, 0x22,
+			      0x00, 0x00};
+#else
+  static char xpattern[32] = {0x80, 0x80,
+			      0x00, 0x00,
+			      0x08, 0x08, 
+			      0x00, 0x00,
+			      0x80, 0x80,
+			      0x00, 0x00,
+			      0x08, 0x08,
+			      0x00, 0x00,
+			      0x80, 0x80,
+			      0x00, 0x00,
+			      0x08, 0x08, 
+			      0x00, 0x00,
+			      0x80, 0x80,
+			      0x00, 0x00,
+			      0x08, 0x08,
+			      0x00, 0x00};
+#endif
+#endif
+  static wxBrush *clearBrush = NULL;
+
+  if (flowLocked)
+    return;
+
+  Bool wl = writeLocked;
+
+  flowLocked = TRUE;
+  writeLocked = TRUE;
+
+  if (flash) {
+    startpos = wxMediaEdit::flashstartpos;
+    endpos = wxMediaEdit::flashendpos;
+    posAtEol = flashposateol;
+  } else {
+    startpos = wxMediaEdit::startpos;
+    endpos = wxMediaEdit::endpos;
+    posAtEol = posateol;
+  }
+
+  if (!outlinePen) {
+    outlinePen = new wxPen("BLACK", 0, wxTRANSPARENT);
+    if (!caretPen)
+      caretPen = new wxPen("BLACK", 1, wxSOLID);
+    outlineBrush = new wxBrush("BLACK", wxSOLID);
+#if ALLOW_X_STYLE_SELECTION
+    outlineNonownerBrush = new wxBrush();
+    wxTheBrushList->RemoveBrush(outlineNonownerBrush);
+    outlineNonownerBrush->SetColour("BLACK");
+    outlineNonownerBrush->SetStipple(new wxBitmap(xpattern, 16, 16, 1));
+    outlineNonownerBrush->SetStyle(wxSTIPPLE);
+#endif
+    clearBrush = new wxBrush("WHITE", wxSOLID);
+  }
+  
+  dc->SetBackgroundMode(wxSOLID);
+
+  line = lineRoot->FindLocation(starty);
+
+  if (!skipBox) {
+    wxPen *savePen = dc->GetPen();
+    wxBrush *saveBrush = dc->GetBrush();
+
+    dc->SetBrush(clearBrush);
+    dc->SetPen(outlinePen);
+    dc->DrawRectangle(leftx + dx, starty + dy, 
+		      rightx - leftx + GC_RECT_BRUSH_EXTEND,
+		      endy - starty + GC_RECT_BRUSH_EXTEND);
+
+    dc->SetBrush(saveBrush);
+    dc->SetPen(savePen);
+  }
+
+  OnPaint(TRUE, dc, leftx, starty, rightx, endy, dx, dy, 
+	  (show_caret && !caretSnip) 
+	  ? show_caret
+	  : (int)wxSNIP_DRAW_NO_CARET);
+
+  if (!line)
+    goto paint_done;
+
+  tleftx = leftx + dx;
+  tstarty = starty + dy;
+  trightx = rightx + dx;
+  tendy = endy + dy;
+
+  oldStyle = NULL;
+
+  ycounter = line->GetLocation();
+  pcounter = line->GetPosition();
+
+  /* Quiet the compiler: */
+  hsxs = hsxe = hsys = hsye = 0;
+
+  for (; line; line = line->next) {
+    if (ycounter >= endy)
+      goto paint_done;
+
+    first = line->snip;
+    last = line->lastSnip->next;
+
+    x = 0;
+    bottombase = ycounter + line->bottombase;
+    topbase = ycounter + line->topbase;
+    p = pcounter;
+
+    hiliteSome = FALSE;
+
+    for (snip = first; PTRNE(snip, last); snip = snip->next) {
+      snip->style->SwitchTo(dc, oldStyle);
+      oldStyle = snip->style;
+
+      snip->GetExtent(dc, x, ycounter, &w, &h, &descent, &space);
+      
+      align = snip->style->GetAlignment();
+      
+      if (align == wxALIGN_BOTTOM)
+	down = bottombase - h + descent;
+      else if (align == wxALIGN_TOP)
+	down = topbase - space;
+      else {
+	down = (h - descent - space) / 2;
+	down = (topbase + bottombase) / 2 - down - space;
+      }
+
+      if ((x <= rightx) && (x + w >= leftx)) {
+	snip->Draw(dc, x + dx, down + dy, 
+		   tleftx, tstarty, trightx, tendy, 
+		   dx, dy, 
+		   (PTREQ(snip, caretSnip) && show_caret)
+		   ? show_caret
+		   : (int)wxSNIP_DRAW_NO_CARET);
+
+#if PLOT_SNIP_DOT
+	dc->DrawLine(x + dx, down + dy, x + dx + 2, down + dy + 2);
+#endif
+      }
+
+      /* The rules for hiliting are surprisingly complicated: */
+
+      if (hiliteOn && !skipBox
+	  && (show_xsel
+	      || (!caretSnip
+		  && ((show_caret == wxSNIP_DRAW_SHOW_CARET)
+		      || ((show_caret >= inactiveCaretThreshold)
+			  && (startpos != endpos)))))) {
+	if (posAtEol)
+	  hilite = (startpos == p + snip->count);
+	else
+	  hilite = (((startpos < p + snip->count) && (endpos >= p)
+		     && (startpos == endpos || endpos > p))
+		    || (p + snip->count == len && startpos == len));
+	
+	if (hilite && (snip->flags & wxSNIP_NEWLINE))
+	  /* End of line: */
+	  hilite = ((startpos != p + snip->count)
+		    || (startpos == endpos && posAtEol)
+		    || (startpos != endpos && startpos < p + snip->count));
+	if (hilite && PTREQ(snip, first))
+	  /* Beginning of line: */
+	  hilite = ((endpos != p)
+		    || (startpos == endpos && !posAtEol)
+		    || (startpos != endpos && endpos > p));
+      } else
+	hilite = FALSE;
+
+      if (hilite) {
+	bottom = down + h;
+
+	if (startpos <= p)
+	  hxs = x;
+	else
+	  hxs = x + snip->PartialOffset(dc, x, ycounter, startpos - p);
+	
+	if (endpos >= p + snip->count) {
+	  if (snip->flags & wxSNIP_NEWLINE) {
+	    if (endpos == startpos)
+	      hxe = hxs;
+	    else {
+	      hxe = rightx;
+	      bottom = ycounter + line->h;
+	    }
+	  } else
+	    hxe = x + w;
+	} else
+	  hxe = x + snip->PartialOffset(dc, x, ycounter, endpos - p);
+	
+	if (!hiliteSome) {
+	  hsxs = hxs;
+	  hsxe = hxe;
+	  hsys = down;
+	  hsye = bottom;
+	  hiliteSome = TRUE;
+	} else {
+	  hsxe = hxe;
+	  if (down < hsys)
+	    hsys = down;
+	  if (bottom > hsye)
+	    hsye = bottom;
+	}
+      }
+
+      x += w;
+      
+      p += snip->count;
+    }
+
+    if (wrapBitmapWidth 
+	&& !(line->lastSnip->flags & wxSNIP_HARD_NEWLINE)
+	&& last
+	&& (rightx >= maxWidth) && autoWrapBitmap->Ok()) {
+      int h;
+
+      if (PTRNE(autoWrapBitmap, lastSetAWMDC)) {
+	if (!autowrapMemDC)
+	  autowrapMemDC = new wxMemoryDC;
+	autowrapMemDC->SelectObject(autoWrapBitmap);
+	lastSetAWMDC = autoWrapBitmap;
+      }
+
+      if (autowrapMemDC->Ok()) {
+	h = (int)autoWrapBitmap->GetHeight();
+	if (h > line->bottombase)
+	  h = (int)line->bottombase;
+
+#ifndef WXME_FOR_MRED
+# define wxCOLOR wxCOPY
+#endif
+
+	dc->Blit(maxWidth + dx - 1, bottombase - h + dy, 
+		 wrapBitmapWidth, h,
+		 autowrapMemDC, 0, 0,
+		 wxCOLOR);
+      }
+    }
+
+    if (hiliteSome) {
+      if (hsxe != hsxs) {
+	if ((hsxs <= rightx) && (hsxe >= leftx)) {
+	  savePen = dc->GetPen();
+	  dc->SetLogicalFunction(wxXOR);
+	  
+	  if (hsxs < leftx)
+	    hsxs = leftx;
+	  if (hsxe > rightx)
+	    hsxe = rightx;
+
+	  if (!show_xsel && (show_caret < wxSNIP_DRAW_SHOW_CARET)) {
+	    int lastHilite, firstHilite;
+	    
+	    firstHilite = (startpos >= pcounter);
+	    lastHilite = (endpos <= pcounter + line->len);
+	    
+	    dc->SetPen(caretPen);
+	    
+	    if (firstHilite) {
+	      dc->DrawLine(hsxs + dx, hsys + dy, hsxe + dx - 1, hsys + dy);
+	      prevwasfirst = hsxs;
+	    } else if (prevwasfirst) {
+	      dc->DrawLine(0 + dx, hsys + dy, prevwasfirst + dx, hsys + dy);
+	      prevwasfirst = 0.0;
+	    }
+	    dc->DrawLine(hsxs + dx, hsys + dy, hsxs + dx, hsye + dy - 1);
+	    dc->DrawLine(hsxe + dx - 1, hsys + dy, hsxe + dx - 1, hsye + dy - 1);
+	    if (lastHilite) {
+	      dc->DrawLine(hsxs + dx, hsye + dy, hsxe + dx - 1, hsye + dy);
+	      if (!firstHilite)
+		dc->DrawLine(hsxe + dx, hsys + dy, rightx + dx, hsys + dy);
+	    }
+	  } else {
+	    saveBrush = dc->GetBrush();
+	    dc->SetPen(outlinePen);
+	    dc->SetBrush(outlineBrush);
+	    
+	    dc->DrawRectangle(hsxs + dx, hsys + dy, 
+			      hsxe - hsxs + GC_RECT_BRUSH_EXTEND, 
+			      hsye - hsys + GC_RECT_BRUSH_EXTEND);
+#if ALLOW_X_STYLE_SELECTION
+	    if (show_xsel) {
+	      dc->SetBrush(outlineNonownerBrush);
+	      
+	      int log = wxAND_INVERT;
+#ifdef wx_x
+	      
+	      static Bool _black_pixel_set_ = FALSE;
+	      static unsigned long _black_pixel_;
+	      
+	      if (!_black_pixel_set_) {
+#ifdef wx_xt
+		Display *d = wxAPP_DISPLAY;
+#else
+		Display *d = wxGetDisplay();
+#endif
+		int sc = DefaultScreen(d);
+		_black_pixel_ = BlackPixel(d, sc);
+		_black_pixel_set_ = TRUE;
+	      }
+	      
+	      /* If black == 0, then reverse */
+	      if (!_black_pixel_)
+		log = wxOR;
+#endif
+	      dc->SetLogicalFunction(log);
+	      
+	      dc->DrawRectangle(hsxs + dx, hsys + dy, 
+				hsxe - hsxs + GC_RECT_BRUSH_EXTEND, 
+				hsye - hsys + GC_RECT_BRUSH_EXTEND);
+	    }
+#endif
+	    
+	    dc->SetBrush(saveBrush);
+	  }
+	  dc->SetLogicalFunction(wxCOPY);
+	  dc->SetPen(savePen);
+	}
+      } else {
+	if (show_caret == wxSNIP_DRAW_SHOW_CARET) {
+	  if ((hsxs <= rightx) && (hsxs >= leftx)) {
+	    savePen = dc->GetPen();
+	    dc->SetPen(caretPen);
+	    dc->SetLogicalFunction(wxXOR);
+	    dc->DrawLine(hsxs + dx, hsys + dy, 
+			 hsxs + dx, 
+			 hsye + dy - 1 + GC_LINE_EXTEND);
+	    dc->SetLogicalFunction(wxCOPY);
+	    dc->SetPen(savePen);
+	  } 
+	  caretLocationX = hsxs;
+	  caretLocationT = hsys;
+	  caretLocationB = hsye + GC_LINE_EXTEND;
+	  caretOn = TRUE;
+	}
+      }
+    }
+
+    pcounter += line->len;
+    ycounter += line->h;
+  }
+
+  styleList->BasicStyle()->SwitchTo(dc, oldStyle);
+
+  if ((show_caret == wxSNIP_DRAW_SHOW_CARET) && !caretSnip)
+    if (!line && extraLine)
+      if (!posAtEol && startpos == len && endpos == startpos
+	  && hiliteOn) {
+	float y;
+	y = ycounter;
+
+	savePen = dc->GetPen();
+	dc->SetPen(caretPen);
+	dc->SetLogicalFunction(wxXOR);
+	dc->DrawLine(dx, y + dy, dx, 
+		     y + extraLineH + dy - 1 + GC_LINE_EXTEND);
+	dc->SetLogicalFunction(wxCOPY);
+	dc->SetPen(savePen);
+
+	caretLocationX = 0;
+	caretLocationT = y;
+	caretLocationB = y + extraLineH + GC_LINE_EXTEND;
+	caretOn = TRUE;
+      }
+ 
+paint_done:
+
+  OnPaint(FALSE, dc, leftx, starty, rightx, endy, dx, dy, 
+	  (show_caret && !caretSnip)
+	  ? show_caret
+	  : (int)wxSNIP_DRAW_NO_CARET);
+
+  writeLocked = wl;
+  flowLocked = FALSE;
+}
+
+/* This one notifies the administrator that we need to be updated. */
+void wxMediaEdit::Redraw()
+{
+  float w, h;
+  float top, bottom, height, width, left, right;
+  float x, y, origx, origy;
+  float fy, fx;
+  Bool oneline;
+  wxDC *dc;
+
+  if (flowLocked || !admin)
+    return;
+
+  if (admin->DelayRefresh()) {
+    /* Do we know the refresh box already? */
+    if (!delayedscroll && !delayedscrollbox && (refreshAll || refreshUnset)) {
+      /* Yes ... */
+      if (!refreshAll && refreshBoxUnset)
+	return; /* Nothing to do */
+      admin->GetMaxView(&x, &y, &w, &h);
+      top = y;
+      bottom = y + h;
+      left = x;
+      right = left + w;
+      if (!refreshAll) {
+	if (refreshL > left)
+	  left = refreshL;
+	if (refreshR < right)
+	  right = refreshR;
+	if (refreshT > top)
+	  top = refreshT;
+	if (refreshB < bottom)
+	  bottom = refreshB;
+      }
+      refreshUnset = refreshBoxUnset = TRUE;
+      refreshAll = FALSE;
+      height = bottom - top;
+      width = right - left;
+      admin->NeedsUpdate(left, top, width, height);
+    }
+  }
+
+  dc = admin->GetDC(&x, &y);
+
+  if (!dc)
+    return;
+
+  origx = x;
+  origy = y;
+
+  RecalcLines(dc);
+
+  if (delayedscroll != -1) {
+    if (ScrollToPosition(delayedscroll, delayedscrollateol, FALSE,
+			 delayedscrollend, delayedscrollbias))
+      refreshAll = TRUE;
+  } else if (delayedscrollbox) {
+    delayedscrollbox = FALSE;
+    if (ScrollTo(delayedscrollsnip, delayedscrollX, delayedscrollY,
+		 delayedscrollW, delayedscrollH, FALSE, delayedscrollbias))
+      refreshAll = TRUE;
+  }
+
+  admin->GetDC(&x, &y);
+  
+  if (x != origx || y != origy)
+    refreshAll = TRUE;
+
+  admin->GetMaxView(&x, &y, &w, &h);
+
+  top = y;
+  bottom = y + h;
+  left = x;
+  right = left + w;
+
+  /* Figure out the minimal refresh area. The refresh area may be
+     determined by character position ranges, box coordinates, or
+     both. If neither is specified, we have to assume that everything
+     needs to be refreshed. */
+  if (!refreshAll && (!refreshUnset || !refreshBoxUnset)) {
+    if (!refreshUnset) {
+      top = y;
+      if (refreshStart > -1 && refreshEnd > -1) {
+	// oneline = PositionLine(refreshStart) == PositionLine(refreshEnd);
+	oneline = FALSE; // b/c it doesn't seem to help
+      } else
+	oneline = FALSE;
+      if (refreshStart > -1) {
+	PositionLocation(refreshStart, 
+			 oneline ? (float *)&fx : (float *)NULL, (float *)&fy, 
+			 TRUE, TRUE, TRUE);
+	if (fy > top)
+	  top = (long)fy;
+	if (oneline && fx > left)
+	  left = fx;
+      }
+      bottom = y + h;
+      if (refreshEnd > -1) {
+	PositionLocation(refreshEnd, 
+			 oneline ? (float *)&fx : (float *)NULL, (float *)&fy, 
+			 FALSE, FALSE, TRUE);
+	if (fy < bottom)
+	  bottom = (long)fy;
+	if (oneline && fx + CURSOR_WIDTH < right)
+	  right = fx + CURSOR_WIDTH;
+      }
+
+      if (!refreshBoxUnset) {
+	if (refreshT < top)
+	  top = refreshT;
+	if (refreshB > bottom)
+	  bottom = refreshB;
+      }
+    } else {
+      if (refreshL > left)
+	left = refreshL;
+      if (refreshR < right)
+	right = refreshR;
+      if (refreshT > top)
+	top = refreshT;
+      if (refreshB < bottom)
+	bottom = refreshB;
+    }
+  } else if (!refreshAll)
+    return; /* Nothing needs to be updated! */
+
+  refreshUnset = refreshBoxUnset = TRUE;
+  refreshAll = FALSE;
+
+  height = bottom - top;
+  width = right - left;
+
+  admin->NeedsUpdate(left, top, width, height);
+}
+
+/* This one is called by the administrator: */
+void wxMediaEdit::Refresh(float left, float top, float width, float height,
+			  int show_caret)
+{
+  float x, y, bottom, right, ddx, ddy;
+  Bool ps;
+  wxDC *dc;
+  int show_xsel = 0;
+
+  if ((width <= 0) || (height <= 0))
+    return;
+
+  if (graphicMaybeInvalid) {
+    /* This Refresh command was not requested by us and we're busy. 
+       (Probably in the middle of a begin-/end-edit-sequnce.)
+       Add the given region to our own invalid-region tracking and
+       we'll get back to it when we're done with whatever. */
+    RefreshBox(left, top, width, height);
+    return;
+  }
+
+  dc = admin->GetDC(&x, &y);
+  if (!dc)
+    return;
+
+  caretLocationX = -1;
+  caretOn = FALSE;
+
+  if (ReadyOffscreen(width, height))
+    drawCachedInBitmap = FALSE;
+
+  bottom = top + height;
+  right = left + width;
+
+#if USE_OLD_TYPE_SYSTEM
+  ps = wxSubType(dc->__type, wxTYPE_DC_POSTSCRIPT)
+    || wxSubType(dc->__type, wxTYPE_DC_PRINTER);
+#else
+  ps = FALSE; /* FIXME! */
+#endif
+
+#if ALLOW_X_STYLE_SELECTION
+  if (((show_caret != wxSNIP_DRAW_SHOW_CARET) || caretSnip)
+      && (wxMediaXSelectionOwner == this)
+      && !flash 
+      && (startpos != endpos))
+    show_xsel = 1;
+#endif
+
+  if (!offscreenInUse && bitmap && bitmap->Ok() && offscreen->Ok() && !ps) {
+    /* Need to make sure that difference between coordinates is
+       integral; otherwise, roundoff error could affect drawing */
+    ddx = (left - x) - (long)(left - x);
+    if (ddx < 0)
+      ddx = 1 + ddx;
+    left -= ddx;
+    width += ddx;
+    ddy = (top - y) - (long)(top - y);
+    if (ddy < 0)
+      ddy = 1 + ddy;
+    top -= ddy;
+    height += ddy;
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+    offscreenInUse = TRUE;
+#endif
+    if (!drawCachedInBitmap 
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+	|| (lastUsedOffscreen != this)
+#endif
+	|| (top != lastDrawT) || (bottom != lastDrawB)
+	|| (left != lastDrawL) || (right != lastDrawR)
+	|| (lastDrawCaret != show_caret)
+	|| (lastDrawXSel != show_xsel)) {
+      offscreen->BeginDrawing();
+      Redraw(offscreen, top, bottom, left, right, -top, -left, 
+	     show_caret, show_xsel);
+      offscreen->EndDrawing();
+      lastDrawL = left;
+      lastDrawT = top;
+      lastDrawR = right;
+      lastDrawB = bottom;
+      lastDrawCaret = show_caret;
+      lastDrawXSel = show_xsel;
+      drawCachedInBitmap = TRUE;
+    }
+    dc->Blit(left - x, top - y, width, height, offscreen, 0, 0, wxCOPY);
+#ifndef EACH_BUFFER_OWN_OFFSCREEN
+    offscreenInUse = FALSE;
+    lastUsedOffscreen = this;
+#endif
+  } else {
+    if (ps)
+      skipBox = TRUE;
+
+    wxPen *pen;
+    wxBrush *brush;
+    wxFont *font;
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    wxColour *fg, *bg;
+#else
+    wxColour fg, bg;
+#endif
+    int log;
+
+    log = dc->GetLogicalFunction();
+    pen = dc->GetPen();
+    brush = dc->GetBrush();
+    font = dc->GetFont();
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    fg = &dc->GetTextForeground();
+    bg = &dc->GetTextBackground();
+#else
+    fg = dc->GetTextForeground();
+    bg = dc->GetTextBackground();
+#endif
+
+#ifndef NO_GET_CLIPPING_REGION
+    float cx, cy, cw, ch;
+    dc->GetClippingRegion(&cx, &cy, &cw, &ch);
+    dc->SetClippingRegion(left - x, top - y, width, height);
+#endif
+
+    Redraw(dc, top, bottom, left, right, -y, -x, show_caret, show_xsel);
+
+#ifndef NO_GET_CLIPPING_REGION
+    if (cw < 0)
+      dc->DestroyClippingRegion();
+    else
+      dc->SetClippingRegion(cx, cy, cw, ch);
+#endif
+
+    dc->SetLogicalFunction(log);
+    dc->SetBrush(brush);
+    dc->SetPen(pen);
+    dc->SetFont(font);
+#if defined(wx_xt) && !defined(WXME_FOR_MRED)
+    dc->SetTextForeground(fg);
+    dc->SetTextBackground(bg);
+#else
+    dc->SetTextForeground(&fg);
+    dc->SetTextBackground(&bg);
+#endif
+
+    if (ps)
+      skipBox = FALSE;
+  }
+
+  if (changed) {
+    changed = FALSE;
+    OnChange();
+  }
+}
+
+/* This one is used internally to delay refreshes: */
+void wxMediaEdit::NeedRefresh(long start, long end)
+{
+  if (refreshUnset) {
+    refreshStart = start;
+    refreshEnd = end;
+    refreshUnset = FALSE;
+  } else {
+    if (start < refreshStart)
+      refreshStart = start;
+    if (end == -1)
+      refreshEnd = -1;
+    else if (refreshEnd != -1 && end > refreshEnd)
+      refreshEnd = end;
+  }
+
+  drawCachedInBitmap = FALSE;
+
+  if (!delayRefresh && !printing && (!admin || !admin->DelayRefresh()))
+    Redraw();
+  else if (admin && !admin->standard)
+    admin->Resized(FALSE);
+}
+
+void wxMediaEdit::RefreshByLineDemand(void)
+{
+  if (!graphicMaybeInvalid)
+    graphicMaybeInvalid = TRUE;
+
+  if (!delayRefresh && !printing && (!admin || !admin->DelayRefresh()))
+    Redraw();
+  else if (admin && !admin->standard)
+    admin->Resized(FALSE);
+}
+
+void wxMediaEdit::NeedCaretRefresh(void)
+{
+  if (!admin || (admin->standard <= 0) || delayRefresh 
+      || startpos != endpos || flash || !hiliteOn)
+    NeedRefresh(startpos, endpos);
+  else if (ownCaret) {
+    if (hiliteOn)
+      CaretOn();
+  } else
+    CaretOff();
+}
+
+void wxMediaEdit::CalcCaretLocation(void)
+{
+  if (caretLocationX < 0) {
+    PositionLocation(startpos, &caretLocationX, &caretLocationT,
+		     TRUE, posateol, FALSE);
+    PositionLocation(startpos, NULL, &caretLocationB,
+		     FALSE, posateol, FALSE);
+  }
+}
+
+Bool wxMediaEdit::CaretOff(void)
+{
+  wxDC *dc;
+  float dx, dy, x, y, w, h, X, T, B;
+
+  if (!CheckRecalc(TRUE, FALSE))
+    return FALSE;
+
+  if (refreshAll || !refreshUnset || !refreshBoxUnset || (delayedscroll!=-1)) {
+    Redraw();
+    return FALSE;
+  }
+
+  dc = admin->GetDC(&dx, &dy);
+
+  if (!dc)
+    return FALSE;
+
+  admin->GetView(&x, &y, &w, &h);
+
+  CalcCaretLocation();
+
+  X = caretLocationX;
+  T = caretLocationT;
+  B = caretLocationB;
+
+  if (B < y)
+    return TRUE;
+  if (T >= y + h)
+    return TRUE;
+  if (X < x || X >= x + w)
+    return TRUE;
+
+  if (T < y)
+    T = y;
+  if (B > y + h)
+    B = y + h;
+
+  if (!caretPen)
+    caretPen = new wxPen("BLACK", 1, wxSOLID);
+
+  dc->SetPen(caretPen);
+  dc->SetLogicalFunction(wxXOR);
+  dc->DrawLine(X - dx, T - dy, X - dx, B - dy - 1 + GC_LINE_EXTEND);
+  dc->SetLogicalFunction(wxCOPY);
+
+  drawCachedInBitmap = FALSE;
+
+  caretOn = FALSE;
+
+  return TRUE;
+}
+
+void wxMediaEdit::CaretOn(void)
+{
+  if (CaretOff())
+    caretOn = TRUE;
+}
+
+/* 8.5" x 11" Paper, 0.5" Margin; usually not used */
+static long page_width = 612, page_height = 792;
+/* Printing margins: */
+static long h_margin = 36, v_margin = 36;
+
+void wxGetMediaPrintMargin(long *hm, long *vm)
+{
+  if (hm)
+    *hm = h_margin;
+  if (vm)
+    *vm = v_margin;
+}
+
+void wxSetMediaPrintMargin(long hm, long vm)
+{
+  if (hm > -1)
+    h_margin = hm;
+  if (vm > -1)
+    v_margin = vm;
+}
+
+typedef struct {
+  float maxw;
+  wxBitmap *bm;
+} SaveSizeInfo;
+
+void *wxMediaEdit::BeginPrint(wxDC *dc, Bool fit)
+{
+  if (flowLocked)
+    return NULL;
+
+  CheckRecalc();
+
+  SizeCacheInvalid();
+
+  if (fit) {
+    float w, h;
+    SaveSizeInfo *savedInfo = new SaveSizeInfo;
+    
+    savedInfo->maxw = GetMaxWidth();
+    savedInfo->bm = SetAutowrapBitmap(NULL);
+
+    dc->GetSize(&w, &h);
+    w -= 2 * h_margin;
+    SetMaxWidth(w);
+
+    return savedInfo;
+  } else
+    return NULL;
+}
+
+void wxMediaEdit::EndPrint(wxDC *, void *data)
+{
+  if (flowLocked)
+    return;
+
+  SizeCacheInvalid();  
+  if (data) {
+    SaveSizeInfo *savedInfo = (SaveSizeInfo *)data;
+    
+    SetMaxWidth(savedInfo->maxw);
+    SetAutowrapBitmap(savedInfo->bm);
+
+    delete data;
+  }
+}
+
+Bool wxMediaEdit::HasPrintPage(wxDC *dc, int page)
+{
+  if (flowLocked)
+    return FALSE;
+
+  float H, W, h;
+  int i, this_page = 1;
+  wxMediaLine *line;
+
+  RecalcLines(dc, TRUE);
+
+  dc->GetSize(&W, &H);
+
+  if (!W || !H) {
+    W = page_width;
+    H = page_height;
+
+    if (wxGetPrinterOrientation() != PS_PORTRAIT)  {
+      float tmp;
+      
+      tmp = H;
+      H = W;
+      W = tmp;
+    }
+  }
+
+  line = firstLine;
+  for (i = 0; i < numValidLines; this_page++) {
+    h = 0;
+    while (!h || ((i < numValidLines) && (line->h < H - h))) {
+      h += line->h;
+      i++;
+      line = line->next;
+    }
+
+    if (this_page >= page)
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+void wxMediaEdit::PrintToDC(wxDC *dc, int page)
+{
+  if (flowLocked)
+    return;
+
+  float H, W, FH, FW, y, h;
+  int i, this_page = 1;
+  wxMediaLine *line;
+
+  RecalcLines(dc, TRUE);
+
+  dc->GetSize(&W, &H);
+
+  if (!W || !H) {
+    W = page_width;
+    H = page_height;
+
+    if (wxGetPrinterOrientation() != PS_PORTRAIT)  {
+      float tmp;
+      
+      tmp = H;
+      H = W;
+      W = tmp;
+    }
+  }
+
+  FH = H;
+  FW = W;
+
+  H -= (2 * v_margin);
+  W -= (2 * h_margin);
+
+  y = 0;
+  line = firstLine;
+  for (i = 0; i < numValidLines; this_page++) {
+    h = 0;
+    while (!h || ((i < numValidLines) && (line->h < H - h))) {
+      h += line->h;
+      i++;
+      line = line->next;
+    }
+
+    if (page < 0 || (page == this_page)) {
+      if (page < 0)
+	dc->StartPage();
+      
+      /* Establish page size: */
+      dc->DrawLine(0, 0, 0, 0);
+      dc->DrawLine(FW, FH, FW, FH);
+      
+      skipBox = TRUE;
+      Redraw(dc, y + (i ? 1 : 0), y + h, 0, W, -y + v_margin, h_margin, 
+	     wxSNIP_DRAW_NO_CARET, 0);
+      skipBox = FALSE;
+      
+      if (page < 0)
+	dc->EndPage();
+
+      if (page >= 0)
+	break;
+    }
+
+    y += h;
+  }
+}
+
+#if ALLOW_X_STYLE_SELECTION
+
+Bool wxMediaEdit::OwnXSelection(Bool on, Bool update, Bool force)
+{
+  if (DoOwnXSelection(on, force)) {
+    if (update)
+      NeedCaretRefresh();
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+#endif
+
diff --git a/src/mred/wxme/wx_mpriv.h b/src/mred/wxme/wx_mpriv.h
new file mode 100644
index 0000000..e257c23
--- /dev/null
+++ b/src/mred/wxme/wx_mpriv.h
@@ -0,0 +1,40 @@
+
+#include "wx_mline.h"
+
+#define MAX_COUNT_FOR_SNIP 500
+
+enum {
+  wxSTREAK_EXCEPT_DELAYED = 1,
+  wxSTREAK_KEY_SEQUENCE
+  };
+
+class wxClickback : public wxObject
+{
+ public:
+  long start, end;
+  wxClickbackFunc f;
+  void *data;
+  Bool callOnDown;
+
+  wxStyleDelta *delta;
+
+  Bool hilited;
+  wxList *unhilite;
+};
+
+#include "wx_timer.h"
+
+class wxMediaFlashTimer : public wxTimer
+{
+ public:
+  wxMediaEdit *media;
+  void Notify(void);
+};
+
+#if VERSION_F
+#include "wx_clipb.h"
+#else
+#include "wx_gclip.h"
+#endif
+
+#include "wx_ptreq.h"
diff --git a/src/mred/wxme/wx_msnip.cxx b/src/mred/wxme/wx_msnip.cxx
new file mode 100644
index 0000000..5f918ee
--- /dev/null
+++ b/src/mred/wxme/wx_msnip.cxx
@@ -0,0 +1,888 @@
+/*
+ * File:        wx_msnip.cc
+ * Purpose:     wxMediaSnip implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_media.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "wx_mpriv.h"
+#include "wx_gcrct.h"
+
+wxMediaSnip::wxMediaSnip(wxMediaBuffer *useme,
+			 Bool border,
+			 int lm, int tm, int rm, int bm,
+			 int li, int ti, int ri, int bi,
+			 float w, float W, float h, float H)
+: wxSnip()
+{
+  Bool istemp;
+
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_MEDIA_SNIP;
+#endif
+
+  flags |= wxSNIP_HANDLES_EVENTS;
+
+  snipclass = wxTheSnipClassList.Find("wxmedia");
+
+  withBorder = border;
+  leftMargin = lm;
+  topMargin = tm;
+  rightMargin = rm;
+  bottomMargin = bm;
+  leftInset = li;
+  topInset = ti;
+  rightInset = ri;
+  bottomInset = bi;
+
+  minWidth = w;
+  maxWidth = W;
+  minHeight = h;
+  maxHeight = H;
+
+  if (useme && !useme->GetAdmin())
+    me = useme;
+  else
+    me = new wxMediaEdit();
+  myAdmin = new wxMediaSnipMediaAdmin(this);
+
+  if (!me->GetFilename(&istemp) || istemp)
+    /* Turn on flag to mirror filename: */
+    flags |= wxSNIP_USES_BUFFER_PATH;
+
+  me->OwnCaret(FALSE);
+}
+
+wxMediaSnip::~wxMediaSnip()
+{
+  if (me) {
+#if !WXGARBAGE_COLLECTION_ON
+    delete me;
+#else
+    if (me->GetAdmin() == myAdmin)
+      me->SetAdmin(NULL);
+#endif
+  }
+  delete myAdmin;
+}
+
+void wxMediaSnip::SetAdmin(wxSnipAdmin *a)
+{
+  if (PTRNE(a, (*admin_ptr))) {
+    wxSnip::SetAdmin(a);
+    if (me) {
+      if (a) {
+	if (me->GetAdmin())
+	  me = NULL; /* traitor! - get rid of it */
+	else
+	  me->SetAdmin(myAdmin);
+      } else
+	me->SetAdmin(NULL);
+    }
+  } 
+
+  if ((*admin_ptr) && (flags & wxSNIP_USES_BUFFER_PATH)) {
+    /* Propogate a filename change: */
+    Bool istemp;
+    if (me && (!me->GetFilename(&istemp) || istemp)) {
+      wxMediaBuffer *b;
+      b = (*admin_ptr)->GetMedia();
+      if (b) {
+	char *filename;
+	filename = b->GetFilename();
+	if (filename)
+	  me->SetFilename(filename, TRUE);
+      }
+    } else
+      flags -= wxSNIP_USES_BUFFER_PATH; /* Turn off the flag; not needed */
+  }
+}
+
+void wxMediaSnip::SetMedia(wxMediaBuffer *b)
+{
+  if (me == b)
+    return;
+
+  if (me && (*admin_ptr))
+    me->SetAdmin(NULL);
+  me = b;
+  if (b) {
+    if (b->GetAdmin()) {
+      me = NULL;
+      return;
+    } else if (*admin_ptr) {
+      me->SetAdmin(myAdmin);
+    }
+  }
+
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+wxMediaBuffer *wxMediaSnip::GetThisMedia(void)
+{
+  return me;
+}
+
+wxCursor *wxMediaSnip::AdjustCursor(wxDC *dc, float x, float y, 
+				    float, float, wxMouseEvent &event)
+{
+  if (!me) 
+    return NULL;
+
+  wxMSMA_SnipDrawState save;
+  wxCursor *c;
+
+  myAdmin->SaveState(&save, dc, x, y);
+  c = me->AdjustCursor(event);
+  myAdmin->RestoreState(&save);
+
+  return c;
+}
+
+void wxMediaSnip::OnEvent(wxDC *dc, float x, float y, 
+			  float, float, wxMouseEvent &event)
+{
+  if (!me) return;
+
+  wxMSMA_SnipDrawState save;
+
+  myAdmin->SaveState(&save, dc, x, y);
+  me->OnEvent(event);
+  myAdmin->RestoreState(&save);
+}
+
+void wxMediaSnip::OnChar(wxDC *dc, float x, float y, 
+			  float, float, wxKeyEvent &event)
+{
+  if (!me) return;
+
+  wxMSMA_SnipDrawState save;
+
+  myAdmin->SaveState(&save, dc, x, y);
+  me->OnChar(event);
+  myAdmin->RestoreState(&save);
+}
+
+void wxMediaSnip::OwnCaret(Bool ownit)
+{
+  if (me)
+    me->OwnCaret(ownit);
+}
+
+void wxMediaSnip::DoEdit(int op, Bool recursive, long time)
+{
+  if (me)
+    me->DoEdit(op, recursive, time);
+}
+
+void wxMediaSnip::DoFont(int op, Bool recursive)
+{
+  if (me)
+    me->DoFont(op, recursive);
+}
+
+Bool wxMediaSnip::Match(wxSnip *)
+{
+  return FALSE;
+}
+
+void wxMediaSnip::SizeCacheInvalid(void)
+{
+  if (me)
+    me->SizeCacheInvalid();
+}
+
+char *wxMediaSnip::GetText(long offset, long num, Bool flat, long *got)
+{
+  if (offset >= 1 || !num) {
+    if (got) *got = 0;
+    return "";
+  }
+
+  if (!flat) {
+    char *s = new char[2];
+    s[0] = '.';
+    s[1] = 0;
+    if (got) *got = 1;
+    return s;
+  } else if (me)
+    return me->GetFlattenedText(got);
+  else
+    return "";
+}
+
+
+void wxMediaSnip::GetExtent(wxDC *dc, 
+			    float x, float y,
+			    float *w, float *h,
+			    float *descent, float *space,
+			    float *lspace, float *rspace)
+{
+  wxMSMA_SnipDrawState save;
+
+  myAdmin->SaveState(&save, dc, x, y);
+  
+  if (me)
+    me->GetExtent(w, h);
+  else {
+    if (w)
+      *w = 0;
+    if (h)
+      *h = 0;
+  }
+
+  if (w) {
+    if (*w) --(*w); /* It looks better to subtract 1 */
+    if (*w < minWidth)
+      *w = minWidth;
+    else if (maxWidth > 0 && *w > maxWidth)
+      *w = maxWidth;
+
+    *w += rightMargin + leftMargin;
+  }
+  if (h) {
+    if (*h < minHeight)
+      *h = minHeight;
+    else if (maxHeight > 0 && *h > maxHeight)
+      *h = maxHeight;
+
+    *h += topMargin + bottomMargin;
+  }
+
+  if (descent)
+    *descent = (me ? me->GetDescent() : 0.0) + bottomMargin;
+  if (space)
+    *space = (me ? me->GetSpace() : 0.0) + topMargin;
+  if (lspace)
+    *lspace = leftMargin;
+  if (rspace)
+    *rspace = rightMargin;
+
+  myAdmin->RestoreState(&save);
+}
+	       
+void wxMediaSnip::Draw(wxDC *dc, float x, float y, 
+		       float left, float top, float right, float bottom,
+		       float WXUNUSED(dx), float WXUNUSED(dy), 
+		       int show_caret)
+{
+  float w, h, r, b, orig_x, orig_y;
+
+  wxMSMA_SnipDrawState save;
+
+  myAdmin->SaveState(&save, dc, x, y);
+  
+  if (me) {
+    me->GetExtent(&w, &h);
+    if (w) --w; /* It looks better to subtract 1 */
+  } else 
+    w = h = 0.0;
+
+  if (w < minWidth)
+    w = minWidth;
+  else if (maxWidth > 0 && w > maxWidth)
+    w = maxWidth;
+
+  if (h < minHeight)
+    h = minHeight;
+  else if (maxHeight > 0 && h > maxHeight)
+    h = maxHeight;
+
+  orig_x = x;
+  orig_y = y;
+
+  x += leftMargin;
+  y += topMargin;
+  r = x + w;
+  b = y + h;
+  
+  float t, l;
+
+  l = ((x > left) ? x : left);
+  t = ((y > top) ? y : top);
+  r = ((r < right) ? r : right);
+  b = ((b < bottom) ? b : bottom);
+
+  if (me)
+    me->Refresh(l - x, t - y, r - l, b - t, show_caret);
+
+  if (withBorder) {
+    float mt, ml, mb, mr;
+    
+    l = orig_x + leftInset;
+    t = orig_y + topInset;
+    r = l + (w + leftMargin + rightMargin - (leftInset + rightInset)) - 1;
+    b = t + (h + topMargin + bottomMargin - (topInset + bottomInset)) - 1;
+    
+    ml = ((l > left) ? ((l < right) ? l : right) : left);
+    mr = ((r > left) ? ((r < right) ? r : right) : left);
+    mt = ((t > top) ? ((t < bottom) ? t : bottom) : top);
+    mb = ((b > top) ? ((b < bottom) ? b : bottom) : top);
+
+    if (l >= left && l < right  && mt <= mb + GC_LINE_EXTEND)
+      dc->DrawLine(l, mt, l, mb + GC_LINE_EXTEND);
+    if (r >= left && r < right && mt <= mb + GC_LINE_EXTEND)
+      dc->DrawLine(r, mt, r, mb + GC_LINE_EXTEND);
+
+    if (t >= top && t < bottom && ml <= mr + GC_LINE_EXTEND)
+      dc->DrawLine(ml, t, mr + GC_LINE_EXTEND, t);
+    if (b >= top && b < bottom && ml <= mr + GC_LINE_EXTEND)
+      dc->DrawLine(ml, b, mr + GC_LINE_EXTEND, b);
+  }
+
+  myAdmin->RestoreState(&save);
+}
+
+wxSnip *wxMediaSnip::Copy(void)
+{
+  wxMediaSnip *ms;
+
+  ms = new wxMediaSnip(me ? me->CopySelf() : (wxMediaBuffer *)NULL, 
+		       withBorder,
+		       leftMargin, topMargin,
+		       rightMargin, bottomMargin,
+		       leftInset, topInset,
+		       rightInset, bottomInset,
+		       minWidth, maxWidth,
+		       minHeight, maxHeight);
+
+  if (!me)
+    ms->SetMedia(NULL);
+
+  return ms;
+}
+
+void wxMediaSnip::Write(wxMediaStreamOut &f)
+{
+  f << (me ? me->bufferType : 0)
+    << withBorder
+    << leftMargin << topMargin << rightMargin << bottomMargin
+    << leftInset << topInset << rightInset << bottomInset
+    << minWidth << maxWidth
+    << minHeight << maxHeight;
+
+  if (me)
+    me->WriteToFile(f);
+}
+
+void wxMediaSnip::SetMaxWidth(float w)
+{
+  maxWidth = w;
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxMediaSnip::SetMinWidth(float w)
+{
+  minWidth = w;
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxMediaSnip::SetMaxHeight(float h)
+{
+  maxHeight = h;
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxMediaSnip::SetMinHeight(float h)
+{
+  minHeight = h;
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+float wxMediaSnip::GetMaxWidth(void) { return maxWidth; }
+float wxMediaSnip::GetMaxHeight(void) { return maxHeight; }
+float wxMediaSnip::GetMinWidth(void) { return minWidth; }
+float wxMediaSnip::GetMinHeight(void) { return minHeight; }
+
+Bool wxMediaSnip::Resize(float w, float h)
+{
+  w -= leftMargin + rightMargin;
+  h -= topMargin + bottomMargin;
+  if (w < 0)
+    w = 0;
+  if (h < 0)
+    h = 0;
+  minWidth = maxWidth = w;
+  minHeight = maxHeight = h;
+
+  if (me) {
+    me->SetMaxWidth(w);
+    me->SetMinWidth(w);
+  }
+
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+
+  return TRUE;
+}
+
+void wxMediaSnip::ShowBorder(Bool show)
+{
+  if (withBorder != show) {
+    withBorder = show;
+    if (*admin_ptr) {
+      wxDC *dc;
+      float w, h;
+
+      dc = (*admin_ptr)->GetDC();
+      if (dc) {
+	GetExtent(dc, 0, 0, &w, &h);
+	(*admin_ptr)->NeedsUpdate(this, leftInset, topInset, 
+				  w + rightMargin - rightInset, 
+				  h + bottomMargin - bottomInset);
+      }
+    }
+  }
+}
+
+Bool wxMediaSnip::BorderVisible()
+{
+  return withBorder;
+}
+
+void wxMediaSnip::SetMargin(int lm, int tm, int rm, int bm)
+{
+  leftMargin = lm;
+  topMargin = tm;
+  rightMargin = rm;
+  bottomMargin = bm;
+  
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxMediaSnip::GetMargin(int *lm, int *tm, int *rm, int *bm)
+{
+  *lm = leftMargin;
+  *tm = topMargin;
+  *rm = rightMargin;
+  *bm = bottomMargin;
+}
+
+void wxMediaSnip::SetInset(int lm, int tm, int rm, int bm)
+{
+  leftMargin = lm;
+  topMargin = tm;
+  rightMargin = rm;
+  bottomMargin = bm;
+
+  if (*admin_ptr) {
+    wxDC *dc;
+    float w, h;
+
+    dc = (*admin_ptr)->GetDC();
+    if (dc) {
+      GetExtent(dc, 0, 0, &w, &h);
+      (*admin_ptr)->NeedsUpdate(this, 0, 0, 
+			 w + rightMargin + leftMargin,
+			 h + bottomMargin + topMargin);
+    }
+  }
+}
+
+void wxMediaSnip::GetInset(int *li, int *ti, int *ri, int *bi)
+{
+  *li = leftInset;
+  *ti = topInset;
+  *ri = rightInset;
+  *bi = bottomInset;
+}
+
+long wxMediaSnip::GetNumScrollSteps()
+{
+  return (me ? me->NumScrollLines() : 1);
+}
+
+long wxMediaSnip::FindScrollStep(float y)
+{
+  return (me ? me->FindScrollLine(y - topMargin) : 0);
+}
+
+float wxMediaSnip::GetScrollStepOffset(long i)
+{
+  return (me ? me->ScrollLineLocation(i) + topMargin : 0);
+}
+
+/****************************************************************/
+
+wxMediaSnipMediaAdmin::wxMediaSnipMediaAdmin(wxMediaSnip *s)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_MEDIA_SNIP_MEDIA_ADMIN;
+#endif
+
+  snip = s;
+  state.drawing = 0;
+
+  WXGC_IGNORE(snip);
+  WXGC_IGNORE(state.dc);
+}
+
+wxDC *wxMediaSnipMediaAdmin::GetDC(float *xp, float *yp)
+{
+  if (state.drawing) {
+    if (xp)
+      *xp = -state.x;
+    if (yp)
+      *yp = -state.y;
+  } else {
+    if (xp)
+      *xp = 0;
+    if (yp)
+      *yp = 0;
+  }
+  
+  if (state.drawing)
+    return state.dc;
+  else {
+    wxSnipAdmin *sadmin;
+    sadmin = snip->GetAdmin();
+    if (sadmin)
+      return sadmin->GetDC();
+    else
+      return NULL;
+  }
+}
+
+void wxMediaSnipMediaAdmin::SaveState(wxMSMA_SnipDrawState *save, wxDC *dc, 
+				      float x, float y)
+{
+  save->drawing = state.drawing;
+  save->dc = state.dc;
+  save->x = state.x;
+  save->y = state.y;
+
+  state.drawing = TRUE;
+  state.x = x + snip->leftMargin;
+  state.y = y + snip->topMargin;
+  state.dc = dc;
+}
+
+void wxMediaSnipMediaAdmin::RestoreState(wxMSMA_SnipDrawState *saved)
+{
+  state.drawing = saved->drawing;
+  state.dc = saved->dc;
+  state.x = saved->x;
+  state.y = saved->y;
+}
+
+void wxMediaSnipMediaAdmin::GetView(float *x, float *y, float *w, float *h, 
+				    Bool full)
+{
+  wxSnipAdmin *sadmin = snip->GetAdmin();
+
+  if (!sadmin) {
+    if (x) *x = 0;
+    if (y) *y = 0;
+    if (w) *w = 0;
+    if (h) *h = 0;
+    return;  
+  }
+
+  if (full) {
+    sadmin->GetView(x, y, w, h, NULL);
+  } else {
+    float sx, sy, sw, sh;
+    sadmin->GetView(&sx, &sy, &sw, &sh, snip);
+    if (x) {
+      *x = sx - snip->leftMargin;
+      if (*x < 0)
+	*x = 0;
+    }
+    if (y) {
+      *y = sy - snip->topMargin;
+      if (*y < 0)
+	*y = 0;
+    }
+    if (w) *w = sw; /* possibly too high due to margins */
+    if (h) *h = sh; /* possibly too high due to margins */
+  }
+}
+
+Bool wxMediaSnipMediaAdmin::ScrollTo(float localx, float localy, float w, float h,
+				Bool refresh, int bias)
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (sadmin)
+    return sadmin->ScrollTo(snip, localx + snip->leftMargin,
+			    localy + snip->topMargin,
+			    w, h, refresh, bias);
+  else
+    return FALSE;
+}
+	
+void wxMediaSnipMediaAdmin::GrabCaret(int dist)
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (sadmin)
+    sadmin->SetCaretOwner(snip, dist);
+}
+
+void wxMediaSnipMediaAdmin::Resized(Bool redraw_now)
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (sadmin)
+    sadmin->Resized(snip, redraw_now);
+}
+
+void wxMediaSnipMediaAdmin::NeedsUpdate(float localx, float localy, 
+				   float w, float h)
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (sadmin)
+    sadmin->NeedsUpdate(snip, 
+			localx + snip->leftMargin,
+			localy + snip->topMargin,
+			w, h);
+}
+
+void wxMediaSnipMediaAdmin::UpdateCursor()
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (sadmin)
+    sadmin->UpdateCursor();
+}
+
+Bool wxMediaSnipMediaAdmin::DelayRefresh()
+{
+  wxSnipAdmin *sadmin;
+  sadmin = snip->GetAdmin();
+  if (!sadmin)
+    return 1;
+
+  if (sadmin->__type == wxTYPE_MEDIA_SNIP_ADMIN) {
+    wxMediaBuffer *b = ((wxStandardSnipAdmin *)sadmin)->GetMedia();
+
+    return b->RefreshDelayed();
+  } else
+    return 0;
+}
+
+/************************************************************************/
+
+#if USE_OLD_TYPE_SYSTEM
+#define __CHECK_TYPE(b) b->__type != wxTYPE_MEDIA_EDIT
+#else
+#define __CHECK_TYPE(b) TRUE
+#endif
+
+#define edf(name, action) \
+     static Bool ed_##name(wxMediaEdit *b, wxKeyEvent &, wxObject *) \
+     { if (__CHECK_TYPE(b)) return FALSE; \
+      b->action; return TRUE; } \
+
+edf(right, MovePosition(WXK_RIGHT))
+edf(left, MovePosition(WXK_LEFT))
+edf(up, MovePosition(WXK_UP))
+edf(down, MovePosition(WXK_DOWN))
+edf(pageup, MovePosition(WXK_UP, FALSE, wxMOVE_PAGE))
+edf(pagedown, MovePosition(WXK_DOWN, FALSE, wxMOVE_PAGE))
+edf(rightword, MovePosition(WXK_RIGHT, FALSE, wxMOVE_WORD))
+edf(leftword, MovePosition(WXK_LEFT, FALSE, wxMOVE_WORD))
+
+edf(selectright, MovePosition(WXK_RIGHT, TRUE))
+edf(selectleft, MovePosition(WXK_LEFT, TRUE))
+edf(selectup, MovePosition(WXK_UP, TRUE))
+edf(selectdown, MovePosition(WXK_DOWN, TRUE))
+edf(selectpageup, MovePosition(WXK_UP, TRUE, wxMOVE_PAGE))
+edf(selectpagedown, MovePosition(WXK_DOWN, TRUE, wxMOVE_PAGE))
+edf(selectrightword, MovePosition(WXK_RIGHT, TRUE, wxMOVE_WORD))
+edf(selectleftword, MovePosition(WXK_LEFT, TRUE, wxMOVE_WORD))
+
+edf(startofline, MovePosition(WXK_LEFT, FALSE, wxMOVE_LINE))
+edf(endofline, MovePosition(WXK_RIGHT, FALSE, wxMOVE_LINE))
+edf(home, MovePosition(WXK_HOME))
+edf(end,  MovePosition(WXK_END))
+
+edf(selecttostartofline, MovePosition(WXK_LEFT, TRUE, wxMOVE_LINE))
+edf(selecttoendofline, MovePosition(WXK_RIGHT, TRUE, wxMOVE_LINE))
+edf(selecttohome, MovePosition(WXK_HOME, TRUE))
+edf(selecttoend,  MovePosition(WXK_END, TRUE))
+
+edf(clear, Erase())
+edf(delete, Delete())
+
+edf(pastenext, PasteNext())
+
+static Bool ed_deletenext(wxMediaEdit *edit, wxKeyEvent &, wxObject *)
+{
+#if USE_OLD_TYPE_SYSTEM
+  if (edit->__type != wxTYPE_MEDIA_EDIT) return FALSE;
+#endif
+
+  long s, e;
+  edit->GetPosition(&s, &e);
+  if (s != e)
+    edit->Delete();
+  else
+    edit->Delete(s, s + 1);
+  return TRUE;
+}
+
+static Bool ed_deletenextword(wxMediaEdit *edit, wxKeyEvent &event, wxObject *)
+{
+#if USE_OLD_TYPE_SYSTEM
+  if (edit->__type != wxTYPE_MEDIA_EDIT) return FALSE;
+#endif
+
+  edit->BeginEditSequence();
+  ed_selectrightword(edit, event, NULL);
+  ed_delete(edit, event, NULL);
+  edit->EndEditSequence();
+  return TRUE;
+}
+
+static Bool ed_deleteprevword(wxMediaEdit *edit, wxKeyEvent &event, wxObject *)
+{
+#if USE_OLD_TYPE_SYSTEM
+  if (edit->__type != wxTYPE_MEDIA_EDIT) return FALSE;
+#endif
+
+  edit->BeginEditSequence();
+  ed_selectleftword(edit, event, NULL);
+  ed_delete(edit, event, NULL);
+  edit->EndEditSequence();
+  return TRUE;
+}
+
+static Bool ed_deleteline(wxMediaEdit *edit, wxKeyEvent &event, wxObject *)
+{
+#if USE_OLD_TYPE_SYSTEM
+  if (edit->__type != wxTYPE_MEDIA_EDIT) return FALSE;
+#endif
+
+  edit->BeginEditSequence();
+  ed_startofline(edit, event, NULL);
+  ed_selecttoendofline(edit, event, NULL);
+  ed_delete(edit, event, NULL);
+  edit->EndEditSequence();
+  return TRUE;
+}
+
+void wxMediaEdit::AddEditorFunctions(wxKeymap *tab)
+{
+  ::wxAddMediaEditorFunctions(tab);
+}
+
+void wxAddMediaEditorFunctions(wxKeymap *tab)
+{
+#define setf(name, func) \
+  tab->AddKeyFunction(name, (wxKeyFunction)ed_##func, NULL)
+
+  setf("forward-character", right);
+  setf("backward-character", left);
+  setf("previous-line", up);
+  setf("next-line", down);
+  setf("previous-page", pageup);
+  setf("next-page", pagedown);
+  setf("forward-word", rightword);
+  setf("backward-word", leftword);
+
+  setf("forward-select", selectright);
+  setf("backward-select", selectleft);
+  setf("select-down", selectdown);
+  setf("select-up", selectup);
+  setf("select-page-up", selectpageup);
+  setf("select-page-down", selectpagedown);
+  setf("forward-select-word", selectrightword);
+  setf("backward-select-word", selectleftword);
+
+  setf("beginning-of-file", home);
+  setf("end-of-file", end);
+  setf("beginning-of-line", startofline);
+  setf("end-of-line", endofline);
+
+  setf("select-to-beginning-of-file", selecttohome);
+  setf("select-to-end-of-file", selecttoend);
+  setf("select-to-beginning-of-line", selecttostartofline);
+  setf("select-to-end-of-line", selecttoendofline);
+
+  setf("delete-previous-character", delete);
+  setf("delete-next-character", deletenext);
+  setf("clear-buffer", clear);
+  setf("delete-next-word", deletenextword);
+  setf("delete-previous-word", deleteprevword);
+
+  setf("delete-line", deleteline);
+  setf("paste-next", pastenext);
+
+  wxAddMediaBufferFunctions(tab);
+}
+
+/*************************************************************/
+
+wxMediaWordbreakMap::wxMediaWordbreakMap()
+{
+  int i;
+
+  usage = 0;
+  memset(map, 0, sizeof(map));
+
+  for (i = 0; i < 256; i++) {
+    if (isalnum(i))
+      map[i] = wxBREAK_FOR_CARET | wxBREAK_FOR_LINE | wxBREAK_FOR_SELECTION;
+    else if (!isspace(i))
+      map[i] = wxBREAK_FOR_LINE;
+  }
+
+  map['-'] -= wxBREAK_FOR_LINE;
+}
+
+void wxMediaWordbreakMap::SetMap(int ch, int mask)
+{
+  if ((ch >= 0) && (ch <= 255))
+    map[ch] = mask;
+}
+
+int wxMediaWordbreakMap::GetMap(int ch)
+{
+  if ((ch >= 0) && (ch <= 255))
+    return map[ch];
+  else
+    return 0;
+}
+
+void wxMediaWordbreakMap::AdjustUsage(Bool newUser)
+{
+  if (newUser)
+    usage++;
+  else
+    --usage;
+}
+
+Bool wxMediaWordbreakMap::IsUsed(void)
+{
+  return !!usage;
+}
diff --git a/src/mred/wxme/wx_mtype.h b/src/mred/wxme/wx_mtype.h
new file mode 100644
index 0000000..ef0963e
--- /dev/null
+++ b/src/mred/wxme/wx_mtype.h
@@ -0,0 +1,38 @@
+
+#if defined(WXME_FOR_MRED) || defined(wx_xt)
+#define USE_OLD_TYPE_SYSTEM 1
+#endif
+
+#define wxTYPE_MEDIA_CANVAS 344
+#define wxTYPE_MEDIA_BUFFER 345
+#define wxTYPE_MEDIA_EDIT 346
+#define wxTYPE_MEDIA_PASTEBOARD 347
+#define wxTYPE_SNIP 348
+#define wxTYPE_TEXT_SNIP 349
+#define wxTYPE_TAB_SNIP 350
+#define wxTYPE_MEDIA_SNIP 351
+#define wxTYPE_SNIP_CLASS 352
+#define wxTYPE_MEDIA_ADMIN 353
+#define wxTYPE_MEDIA_SNIP_ADMIN 354
+#define wxTYPE_MEDIA_SNIP_MEDIA_ADMIN 355
+#define wxTYPE_CANVAS_MEDIA_ADMIN 356
+#define wxTYPE_MEDIA_STREAM_IN 357
+#define wxTYPE_MEDIA_STREAM_OUT 358
+#define wxTYPE_MEDIA_STREAM_IN_BASE 359
+#define wxTYPE_MEDIA_STREAM_OUT_BASE 360
+#define wxTYPE_MEDIA_STREAM_IN_FILE_BASE 361
+#define wxTYPE_MEDIA_STREAM_IN_STRING_BASE 362
+#define wxTYPE_MEDIA_STREAM_OUT_FILE_BASE 363
+#define wxTYPE_MEDIA_STREAM_OUT_STRING_BASE 364
+#define wxTYPE_KEYMAP 365
+#define wxTYPE_MULT_COLOUR 366
+#define wxTYPE_ADD_COLOUR 367
+#define wxTYPE_STYLE 368
+#define wxTYPE_STYLE_DELTA 369
+#define wxTYPE_STYLE_LIST 370
+#define wxTYPE_IMAGE_SNIP 371
+#define wxTYPE_BUFFER_DATA 372
+#define wxTYPE_BUFFER_DATA_CLASS 373
+#define wxTYPE_BUFFER_DATA_CLASS_LIST 374
+#define wxTYPE_WORDBREAK_MAP 375
+#define wxTYPE_SNIP_CLASS_LIST 376
diff --git a/src/mred/wxme/wx_ptreq.h b/src/mred/wxme/wx_ptreq.h
new file mode 100644
index 0000000..a95aaab
--- /dev/null
+++ b/src/mred/wxme/wx_ptreq.h
@@ -0,0 +1,8 @@
+
+#ifndef PTREQ
+
+/* Comparing pointers: */
+#define PTREQ(x, y) ((x) == (y))
+#define PTRNE(x, y) ((x) != (y))
+
+#endif
diff --git a/src/mred/wxme/wx_snip.cxx b/src/mred/wxme/wx_snip.cxx
new file mode 100644
index 0000000..33a69ea
--- /dev/null
+++ b/src/mred/wxme/wx_snip.cxx
@@ -0,0 +1,1989 @@
+/*
+ * File:        wx_snip.cc
+ * Purpose:     wxSnip implementations
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_utils.h"
+#include "wx_media.h"
+#include "wx_ptreq.h"
+#include <string.h>
+#include "wx_gcrct.h"
+
+#define SETWD_NOT_PRESENT 1
+
+#ifdef wx_x
+#define CHECK_SPLIT 1
+#else
+#define CHECK_SPLIT 0
+#endif
+
+#define CHECK_CS_FLAG 1
+
+#ifdef MEMMOVE_NOT_PRESENT
+static void memmove(char *dest, char *src, long size)
+{
+  if (dest < src) {
+    while (size--)
+      *(dest++) = *(src++);
+  } else {
+    dest += size;
+    src += size;
+    while (size--)
+      *(--dest) = *(--src);
+  }
+}
+#endif
+
+#ifndef WXME_FOR_MRED
+#ifndef wx_mac
+#define KeyType int
+#endif
+#endif
+
+/* MSW version needs this for just a little while longer... */
+#ifndef WXGC_ATOMIC
+#define WXGC_ATOMIC /* empty */
+#endif
+
+#define MAX_WASTE 3
+
+#define IMAGE_PIXELS_PER_SCROLL 20
+#define IMAGE_VOID_SIZE 20
+
+#define ALWAYSZERO(x) if (x) *x = 0;
+
+#define STRALLOC(n) (new WXGC_ATOMIC char[n])
+#define STRFREE(s) (delete[] s)
+
+/***************************************************************/
+
+wxSnipClass::wxSnipClass()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_SNIP_CLASS;
+#endif
+
+  classname = "wxbad";
+  version = 0;
+  required = 0;
+  mapPosition = -1;
+}
+
+Bool wxSnipClass::ReadHeader(wxMediaStreamIn &)
+{
+  return TRUE;
+}
+
+void wxSnipClass::ReadDone(void)
+{
+}
+
+Bool wxSnipClass::WriteHeader(wxMediaStreamOut &)
+{
+  return TRUE;
+}
+
+void wxSnipClass::WriteDone(void)
+{
+}
+
+/***************************************************************/
+
+wxSnip::wxSnip() : wxObject(WXGC_NO_CLEANUP)
+{
+  Init();
+}
+
+wxSnip::wxSnip(Bool cleanup) : wxObject(cleanup)
+{
+  Init();
+}
+
+void wxSnip::Init(void)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_SNIP;
+#endif
+
+  count = 1;
+
+  flags = 0;
+
+  snipclass = NULL;
+
+
+  next = prev = NULL;
+  line = NULL;
+
+  admin_ptr = new WXGC_ATOMIC wxSnipAdmin*;
+  *admin_ptr = NULL;
+
+  style = wxTheStyleList->BasicStyle();
+}
+
+wxSnip::~wxSnip()
+{
+  next = prev = NULL;
+  line = NULL;
+}
+
+wxSnip *wxSnip::Next(void)
+{
+  return next;
+}
+
+wxSnip *wxSnip::Previous(void)
+{
+  return prev;
+}
+
+wxSnipAdmin *wxSnip::GetAdmin(void)
+{
+  return *admin_ptr;
+}
+
+void wxSnip::SetAdmin(wxSnipAdmin *a)
+{
+  if (PTRNE(a, *admin_ptr) && (flags & wxSNIP_OWNED)
+      && (a || !(flags & wxSNIP_CAN_DISOWN)))
+    return;
+
+  *admin_ptr = a;
+  SizeCacheInvalid();
+  if (!a) {
+    prev = next = NULL;
+    line = NULL;
+  } else
+    flags |= wxSNIP_OWNED;
+}
+
+void wxSnip::SetCount(long new_count)
+{
+  long old_count = count;
+
+  if (new_count <= 0)
+    new_count = 1;
+  count = new_count;
+  if (*admin_ptr) {
+    if (!(*admin_ptr)->Recounted(this, TRUE))
+      count = old_count;
+  }
+}
+
+void wxSnip::SetFlags(long new_flags)
+{
+  /* Make sure that wxSNIP_HARD_NEWLINE implies a wxSNIP_NEWLINE */
+  if (new_flags & wxSNIP_NEWLINE)
+    new_flags -= wxSNIP_NEWLINE;    
+  if (new_flags & wxSNIP_HARD_NEWLINE)
+    new_flags |= wxSNIP_NEWLINE;
+
+  /* Make sure ownership and splitness flags don't change */
+  if (new_flags & wxSNIP_OWNED)
+    new_flags -= wxSNIP_OWNED;
+  if (new_flags & wxSNIP_CAN_DISOWN)
+    new_flags -= wxSNIP_CAN_DISOWN;
+  if (new_flags & wxSNIP_CAN_SPLIT)
+    new_flags -= wxSNIP_CAN_SPLIT; 
+
+  if (flags & wxSNIP_OWNED)
+    new_flags |= wxSNIP_OWNED;
+  if (flags & wxSNIP_CAN_DISOWN)
+    new_flags |= wxSNIP_CAN_DISOWN;
+  if (flags & wxSNIP_CAN_SPLIT)
+    new_flags |= wxSNIP_CAN_SPLIT; 
+
+  flags = new_flags;
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxSnip::OnEvent(wxDC *, float, float, float, float, wxMouseEvent &)
+{
+}
+
+wxCursor *wxSnip::AdjustCursor(wxDC *, float, float, float, float, wxMouseEvent &)
+{
+  return NULL;
+}
+
+void wxSnip::OnChar(wxDC *, float, float, float, float, wxKeyEvent &)
+{
+}
+
+void wxSnip::DoEdit(int, Bool, long)
+{
+}
+
+void wxSnip::DoFont(int, Bool)
+{
+}
+
+Bool wxSnip::Match(wxSnip *other)
+{
+  if (PTRNE(other->snipclass, snipclass))
+    return FALSE;
+  if (other->count != count)
+    return FALSE;
+  return TRUE;
+}
+ 
+void wxSnip::OwnCaret(Bool)
+{
+}
+
+void wxSnip::SizeCacheInvalid(void)
+{
+}
+
+void wxSnip::GetExtent(wxDC *, 
+		       float, float, 
+		       float *w, float *h, 
+		       float *descent, float *space,
+		       float *lspace, float *rspace)
+{
+  if (w)
+    *w = 0;
+  if (h)
+    *h = 0;
+  if (descent)
+    *descent = 0;
+  if (space)
+    *space = 0;
+  if (lspace)
+    *lspace = 0;
+  if (rspace)
+    *rspace = 0;
+}
+
+float wxSnip::PartialOffset(wxDC *dc, 
+			    float x, float y, long offset)
+{
+  if (!offset)
+    return 0.0;
+
+  float w;
+  GetExtent(dc, x, y, &w);
+  return w;
+}
+
+void wxSnip::Draw(wxDC *, float, float,
+		  float, float, float, float, 
+		  float, float, int)
+{
+}
+
+void wxSnip::Split(long position, wxSnip **first, wxSnip **second)
+{
+  wxSnip *snip;
+
+  snip = new wxSnip();
+  snip->count = position;
+  count -= position;
+
+  *first = snip;
+  *second = this;
+
+#if CHECK_CS_FLAG
+  if (!(flags & wxSNIP_CAN_SPLIT) && *admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+#endif
+}
+
+wxSnip *wxSnip::MergeWith(wxSnip *)
+{
+  return NULL;
+}
+
+void wxSnip::GetText(char *s, long offset, long num)
+{
+  char *str;
+
+  str = GetText(offset, num, FALSE);
+  if (!str)
+    memset(s, '.', num);
+  else
+    memcpy(s, str, num);
+}
+
+char *wxSnip::GetText(long offset, long num, 
+		      Bool WXUNUSED(flattened), long *got)
+{
+  if (offset < 0)
+    offset = 0;
+  if (offset > count)
+    return "";
+  if (num > count - offset)
+    num = count - offset;
+
+  char *s = new WXGC_ATOMIC char[num + 1];
+  memset(s, '.', num);
+  s[num] = 0;
+
+  if (got)
+    *got = num;
+
+  return s;
+}
+
+wxSnip *wxSnip::Copy()
+{
+  wxSnip *snip;
+
+  snip = new wxSnip();
+  Copy(snip);
+
+  return snip;
+}
+
+void wxSnip::SetStyle(wxStyle *s)
+{
+  if (flags & wxSNIP_OWNED)
+    return;
+
+  style = s;
+}
+
+void wxSnip::Copy(wxSnip *snip)
+{
+  snip->count = count;
+  snip->flags = flags;
+  if (snip->flags & wxSNIP_OWNED)
+    snip->flags -= wxSNIP_OWNED;
+  if (snip->flags & wxSNIP_CAN_DISOWN)
+    snip->flags -= wxSNIP_CAN_DISOWN;
+  if (snip->flags & wxSNIP_CAN_SPLIT)
+    snip->flags -= wxSNIP_CAN_SPLIT;
+  snip->snipclass = snipclass;
+  snip->style = style;
+}
+
+void wxSnip::Write(wxMediaStreamOut &)
+{
+}
+
+Bool wxSnip::Resize(float, float)
+{
+  return FALSE;
+}
+
+long wxSnip::GetNumScrollSteps()
+{
+  return 1;
+}
+
+long wxSnip::FindScrollStep(float)
+{
+  return 0;
+}
+
+float wxSnip::GetScrollStepOffset(long)
+{
+  return 0;
+}
+
+Bool wxSnip::IsOwned(void)
+{
+  return !!(flags & wxSNIP_OWNED);
+}
+
+Bool wxSnip::ReleaseFromOwner(void)
+{
+  if (!IsOwned())
+    return TRUE;
+
+  if (!*admin_ptr)
+    return FALSE;
+
+  if ((*admin_ptr)->ReleaseSnip(this))
+    return !(flags & wxSNIP_OWNED);
+  else
+    return FALSE;
+}
+
+/***************************************************************/
+
+class TextSnipClass : public wxSnipClass
+{
+ public:
+  TextSnipClass(void);
+
+  virtual wxSnip *Read(wxMediaStreamIn &);
+  wxSnip *Read(wxTextSnip *, wxMediaStreamIn &);
+};
+
+static TextSnipClass TheTextSnipClass;
+
+TextSnipClass::TextSnipClass(void)
+{
+  classname = "wxtext";
+  version = 1;
+  required = TRUE;
+}
+
+wxSnip *TextSnipClass::Read(wxMediaStreamIn &f)
+{
+  return Read(new wxTextSnip(0), f);
+}
+
+wxSnip *TextSnipClass::Read(wxTextSnip *snip, wxMediaStreamIn &f)
+{
+  long flags;
+  long count, pos;
+
+  f >> flags;
+
+  pos = f.Tell();
+  f >> count;
+  f.JumpTo(pos);
+
+  snip->Read(count, f);
+
+  snip->flags = flags;
+
+  return snip;
+}
+
+/***************************************************************/
+
+wxTextSnip::wxTextSnip(long allocsize) 
+: wxSnip()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_TEXT_SNIP;
+#endif
+
+  flags |= wxSNIP_IS_TEXT | wxSNIP_CAN_APPEND;
+
+  w = -1.0;
+
+  allocated = (allocsize > 0) ? 2 * allocsize : 20;
+  text = buffer = STRALLOC(allocated + 1);
+
+  snipclass = &TheTextSnipClass;
+  
+  count = 0;
+}
+
+wxTextSnip::~wxTextSnip()
+{
+  STRFREE(buffer);
+  text = buffer = NULL;
+}
+
+void wxTextSnip::SizeCacheInvalid(void)
+{
+  w = -1.0;
+}
+
+void wxTextSnip::GetTextExtent(wxDC *dc, int count, float *wo)
+{
+  char save;
+  float w, h;
+
+  save = text[count];
+  text[count] = 0;
+
+  int i;
+  for (i = count; i--; )
+    if (!text[i])
+      break;
+  
+  wxFont *font = style->GetFont();
+#ifdef BROKEN_GET_TEXT_EXTENT 
+  dc->SetFont(font);
+#endif
+
+  if (i < 0) {
+    dc->GetTextExtent(text, &w, &h, NULL, NULL, font);
+  } else {
+    /* text includes null chars */
+    float ex_w;
+    int start = 0, i;
+    
+#ifndef BROKEN_GET_TEXT_EXTENT 
+    dc->SetFont(font);
+#endif
+    dc->GetTextExtent("X", &ex_w, &h, NULL, NULL);
+    
+    w = 0;
+    for (i = 0; i <= count; i++)
+      if (!text[i] || (i == count)) {
+	if (i > start) {
+	  float piece_w, h;
+	  dc->GetTextExtent(text + start, &piece_w, &h, NULL, NULL);
+	  w += piece_w;
+	}
+	if (i < count) {
+	  start = i + 1;
+	  w += ex_w;
+	}
+      }
+  }
+  
+  text[count] = save;
+
+  *wo = w;
+}
+
+void wxTextSnip::GetExtent(wxDC *dc, 
+			   float WXUNUSED(x), float WXUNUSED(y), 
+			   float *wo, float *ho, float *dso, float *so,
+			   float *ls, float *rs)
+{
+
+  if (w < 0) {
+    if ((flags & wxSNIP_INVISIBLE) || !count 
+	|| (count == 1 && text[0] == '\n')
+	|| (count == 1 && text[0] == '\t')) {
+      if (text[0] == '\t')
+	w = style->GetTextWidth(dc);
+      else
+	w = 0;
+    } else {
+      GetTextExtent(dc, count, &w);
+    }
+  }
+
+  if (wo)
+    *wo = w;
+  if (ho)
+    *ho = style->GetTextHeight(dc);
+  if (dso)
+    *dso = style->GetTextDescent(dc);
+  if (so)
+    *so = style->GetTextSpace(dc);
+  if (ls)
+    *ls = 0.0;
+  if (rs)
+    *rs = 0.0;
+}
+
+float wxTextSnip::PartialOffset(wxDC *dc, 
+				float, float, long offset)
+{
+  float w;
+  
+  if (offset > count)
+    offset = count;
+
+  GetTextExtent(dc, offset, &w);
+
+  return w;
+}
+
+void wxTextSnip::Draw(wxDC *dc, float x, float y, 
+		      float, float, float, float, 
+		      float WXUNUSED(dx), float WXUNUSED(dy), 
+		      int)
+{
+  char save;
+
+  if (flags & wxSNIP_INVISIBLE)
+    return;
+
+  save = text[count];
+  text[count] = 0;
+
+  int i;
+  for (i = count; i--; )
+    if (!text[i])
+      break;
+  
+  if (i < 0)
+    dc->DrawText(text, x, y);
+  else {
+    /* text includes null chars */
+    float px, h, ex_w;
+    int start = 0, i;
+
+    dc->GetTextExtent("X", &ex_w, &h, NULL, NULL);
+    
+    px = x;
+    for (i = 0; i <= count; i++)
+      if (!text[i] || (i == count)) {
+	if (i > start) {
+	  float piece_w, h;
+	  dc->GetTextExtent(text + start, &piece_w, &h, NULL, NULL);
+	  dc->DrawText(text + start, px, y);
+	  px += piece_w;
+	}
+	if (i < count) {
+	  if (h > 2 && ex_w > 2)
+	    dc->DrawRectangle(px + 1, y + 1, ex_w - 2, h - 2);
+	  start = i + 1;
+	  px += ex_w;
+	}
+      }
+  }
+
+  text[count] = save;
+
+#if defined(wx_x) && (defined(WXME_FOR_MRED) || !defined(wx_xt))
+  if (style->GetUnderlined()) {
+    float descent = style->GetTextDescent(dc);
+    float h = style->GetTextHeight(dc);
+
+    if (descent >= 2)
+      y += h - (descent / 2);
+    else
+      y += h - descent;
+    dc->DrawLine(x, y, x + w + GC_LINE_EXTEND, y);
+  }
+#endif
+}
+
+void wxTextSnip::Split(long position, wxSnip **first, wxSnip **second)
+{
+  wxTextSnip *snip;
+
+  if (position < 0 || position > count)
+    return;
+
+  snip = new wxTextSnip(position);
+
+  w = -1.0;
+
+  memcpy(snip->text, text, position);
+  text += position;
+
+  snip->count = position;
+  count -= position;
+
+  if (count && ((allocated / count) > MAX_WASTE)) {
+    char *old = buffer;
+    allocated = count;
+    buffer = STRALLOC(allocated + 1);
+    memcpy(buffer, text, count + 1);
+    text = buffer;
+    STRFREE(old);
+  }
+
+  *first = snip;
+  *second = this;
+
+#if CHECK_CS_FLAG
+  if (!(flags & wxSNIP_CAN_SPLIT) && *admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+#endif
+}
+
+wxSnip *wxTextSnip::MergeWith(wxSnip *pred)
+{
+#if USE_OLD_TYPE_SYSTEM
+  if (pred->__type != wxTYPE_TEXT_SNIP)
+    return this;
+#endif
+
+  w = -1.0;
+
+  Insert(((wxTextSnip *)pred)->text, pred->count, 0);
+
+#if !WXGARBAGE_COLLECTION_ON
+  delete pred;
+#endif
+
+#if CHECK_CS_FLAG
+  if (!(flags & wxSNIP_CAN_SPLIT) && (*admin_ptr))
+    (*admin_ptr)->Resized(this, TRUE);
+#endif
+
+  return this;
+}
+
+void wxTextSnip::Insert(char *str, long len, long pos)
+{
+  if (len <= 0)
+    return;
+  if (pos < 0)
+    pos = 0;
+
+  if (allocated < count + len) {
+    char *oldbuffer = buffer;
+
+    allocated = 2 * (count + len);
+    buffer = STRALLOC(allocated + 1);
+
+    memcpy(buffer, text, count);
+    STRFREE(oldbuffer);
+
+    text = buffer;
+  } else if (PTRNE(text, buffer)
+	     && ((text - buffer) + count + len > allocated)) {
+    memmove(buffer, text, count);
+    text = buffer;
+  }
+   
+  if (pos < count)
+    memmove(text + pos + len, text + pos, count - pos);
+  memcpy(text + pos, str, len);
+  
+  count += len;
+
+  w = -1.0;
+  
+#if CHECK_CS_FLAG
+  if (!(flags & wxSNIP_CAN_SPLIT) && (*admin_ptr))
+    if (!(*admin_ptr)->Recounted(this, TRUE))
+      count -= len;
+#endif
+}
+
+void wxTextSnip::GetText(char *s, long offset, long num)
+{
+  if (num <= 0)
+    return;
+
+  memcpy(s, text + offset, num);
+}
+
+char *wxTextSnip::GetText(long offset, long num, Bool flat, long *got)
+{
+  if (offset < 0) offset = 0;
+  if ((num <= 0) || (offset >= count)) {
+    if (got)
+      *got = 0;
+    return "";
+  }
+  if (num + offset > count)
+    num = count - offset;
+
+  if (flat && (flags & wxSNIP_HARD_NEWLINE)) {
+#ifdef wx_msw
+#define NWL_RC 2
+#else
+#define NWL_RC 1
+#endif
+
+    if (got)
+      *got = NWL_RC;
+
+    char *s = new WXGC_ATOMIC char[NWL_RC + 1];
+#ifdef wx_x
+    s[0] = '\n';
+#else
+#ifdef wx_msw
+    s[0] = '\r';
+    s[1] = '\n';
+#else
+    // Macintosh
+    s[0] = '\r';
+#endif
+#endif
+    s[NWL_RC] = 0;
+    return s;
+  } else {
+    char *s = new WXGC_ATOMIC char[num + 1];
+    memcpy(s, text + offset, num);
+    s[num] = 0;
+    if (got)
+      *got = num;
+    return s;
+  }
+}
+
+wxSnip *wxTextSnip::Copy()
+{
+  wxTextSnip *snip = new wxTextSnip(count);
+
+  Copy(snip);
+
+  return snip;
+}
+
+void wxTextSnip::Copy(wxTextSnip *snip) 
+{
+  wxSnip::Copy(snip);
+  
+  memcpy(snip->text, text, count);
+  snip->count = count;
+
+  snip->w = -1.0;
+}
+
+void wxTextSnip::Write(wxMediaStreamOut &f)
+{
+  long writeFlags;
+
+  writeFlags = flags;
+  if (writeFlags & wxSNIP_OWNED)
+    writeFlags -= wxSNIP_OWNED;
+  if (writeFlags & wxSNIP_CAN_DISOWN)
+    writeFlags -= wxSNIP_CAN_DISOWN;
+  if (writeFlags & wxSNIP_CAN_SPLIT)
+    writeFlags -= wxSNIP_CAN_SPLIT;
+
+  f << writeFlags;
+  f.Put(count, text);
+}
+
+void wxTextSnip::Read(long len, wxMediaStreamIn &f)
+{
+  if (len <= 0)
+    return;
+
+  if (allocated < len) {
+    allocated = 2 * len;
+    STRFREE(buffer);
+    buffer = STRALLOC(allocated + 1);
+  }
+
+  f.Get((long *)&len, text = buffer);
+  count = len;
+  w = -1.0;
+}
+
+#ifdef MEMORY_USE_METHOD
+long wxTextSnip::MemoryUse(void)
+{
+  return allocated + wxObject::MemoryUse();
+}
+#endif
+
+/***************************************************************/
+
+class TabSnipClass : public TextSnipClass
+{
+ public:
+  TabSnipClass(void);
+
+  virtual wxSnip *Read(wxMediaStreamIn &);
+};
+
+static TabSnipClass TheTabSnipClass;
+
+TabSnipClass::TabSnipClass(void)
+{
+  classname = "wxtab";
+  version = 1;
+  required = TRUE;
+}
+
+wxSnip *TabSnipClass::Read(wxMediaStreamIn &f)
+{
+  return TextSnipClass::Read(new wxTabSnip(), f);
+}
+
+/***************************************************************/
+
+wxTabSnip::wxTabSnip() : wxTextSnip(1)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_TAB_SNIP;
+#endif
+
+  snipclass = &TheTabSnipClass;
+
+  flags |= wxSNIP_WIDTH_DEPENDS_ON_X;
+  flags -= (flags & wxSNIP_CAN_APPEND);
+}
+
+void wxTabSnip::GetExtent(wxDC *dc, 
+			  float x, float y, 
+			  float *wi, float *h, 
+			  float *descent, float *space,
+			  float *lspace, float *rspace)
+{
+  float *tabs, oldw;
+  float tabspace;
+  int n, i;
+  Bool changed;
+
+  changed = (w < 0);
+  oldw = w;
+
+  wxTextSnip::GetExtent(dc, x, y, wi, h, descent, space, lspace, rspace);
+
+  if (changed) {
+    /* w is now width of a space */
+    float mult;
+    wxMediaBuffer *media = NULL;
+
+    if ((*admin_ptr) && (media = (*admin_ptr)->GetMedia()) && (media->bufferType == wxEDIT_BUFFER)) {
+      float space;
+      Bool units;
+
+      tabs = ((wxMediaEdit *)(*admin_ptr)->GetMedia())->GetTabs(&n, &space, &units);
+      tabspace = space;
+      mult = units ? 1 : w;
+    } else {
+      n = 0;
+      tabs = NULL;
+      tabspace = wxTAB_WIDTH;
+      mult = 1;
+    }
+    
+    for (i = 0; i < n; i++)
+      if (tabs[i] * mult > x) {
+	w = tabs[i] * mult - x;
+	break;
+      }
+
+    if (i >= n) {
+      float base;
+
+      base = tabs ? (tabs[n - 1] * mult) : 0;
+      x -= base;
+
+      tabspace *= mult;
+      w = base + ((long)tabspace - ((long)x % (long)tabspace));
+    }
+    
+  } else
+    w = oldw;
+
+  if (wi)
+    *wi = w;
+}
+
+float wxTabSnip::PartialOffset(wxDC *dc, float x, float y, long offset)
+{
+  float w;
+
+  if (!offset)
+    return 0;
+  else {
+    GetExtent(dc, x, y, &w);
+    return w;
+  }
+}
+
+void wxTabSnip::Draw(wxDC *, float, float, 
+		     float, float, float, float, 
+		     float, float, int)
+{
+  /* Do nothing! */
+}
+
+wxSnip *wxTabSnip::Copy()
+{
+  wxTabSnip *snip = new wxTabSnip();
+
+  wxTextSnip::Copy(snip);
+
+  return snip;
+}
+
+/***************************************************************/
+
+#define IMG_MOVE_BUF_SIZE 500
+
+class ImageSnipClass : public wxSnipClass
+{
+ public:
+  ImageSnipClass(void);
+
+  virtual wxSnip *Read(wxMediaStreamIn &);
+};
+
+static ImageSnipClass TheImageSnipClass;
+
+ImageSnipClass::ImageSnipClass(void)
+{
+  classname = "wximage";
+  version = 2;
+  required = FALSE;
+}
+
+wxSnip *ImageSnipClass::Read(wxMediaStreamIn &f)
+{
+  wxImageSnip *snip;
+  char *filename, *delfile = NULL, *loadfile;
+  long type;
+  Bool relative, inlined = FALSE;
+  float w, h, dx, dy;
+  Bool canInline = (wxTheSnipClassList.ReadingVersion(this) > 1);
+
+  filename = f.GetString(NULL);
+  f >> type;
+  f >> w;
+  f >> h;
+  f >> dx;
+  f >> dy;
+  f >> relative;
+
+  loadfile = filename;
+
+  if (!*filename && canInline && type) {
+    /* read inlined image */
+
+    long len;
+    f.GetFixed(len);
+
+    if (len) {
+      char *fname = wxGetTempFileName("img", NULL);
+
+      FILE *fi;
+      char buffer[IMG_MOVE_BUF_SIZE + 1];
+    
+      fi = fopen(fname, "wb");
+      if (fi) {
+	long c;
+	
+	while (len--) {
+	  c = IMG_MOVE_BUF_SIZE + 1;
+	  f.Get(&c, buffer);
+	  
+	  c = fwrite(buffer, 1, c, fi);
+	}
+	fclose(fi);
+
+	loadfile = fname;
+	type = ((type == 1) ? wxBITMAP_TYPE_XBM : wxBITMAP_TYPE_XPM);
+	inlined = TRUE;
+      }
+
+      delfile = fname;      
+    }
+  }
+  
+  snip = new wxImageSnip(loadfile, type, relative, inlined);
+
+  delete[] filename;
+  if (delfile) {
+    wxRemoveFile(delfile);
+    delete[] delfile;
+  }
+
+  snip->Resize(w, h);
+  snip->SetOffset(dx, dy);
+
+  return (wxSnip *)snip;
+}
+
+/***************************************************************/
+
+wxImageSnip::wxImageSnip(char *name, long type, Bool relative, Bool inlineImg) : wxSnip(TRUE)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_IMAGE_SNIP;
+#endif
+
+  snipclass = &TheImageSnipClass;
+
+  contentsChanged = TRUE;
+  filename = NULL;
+  filetype = 0;
+  relativePath = FALSE;
+  userbm = FALSE;
+  sharing = NULL;
+  bm = NULL;
+  vieww = viewh = -1.0;
+  viewdx = viewdy = 0.0;
+  offscreen = NULL;
+
+  if (name && *name)
+    LoadFile(name, type, relative, inlineImg);
+}
+
+wxImageSnip::~wxImageSnip()
+{
+  if (filename)
+    delete[] filename;
+
+  if (!sharing || !(--*sharing)) {
+    if (offscreen) {
+      offscreen->SelectObject(NULL);
+      delete offscreen;
+    }
+
+    if (bm && !userbm) {
+      delete bm;
+      bm = NULL;
+    }
+  }
+}
+
+void wxImageSnip::SizeCacheInvalid(void)
+{
+  contentsChanged = TRUE;  
+}
+
+
+void wxImageSnip::GetExtent(wxDC *,
+			    float WXUNUSED(x), 
+			    float WXUNUSED(y),
+			    float *wi, float *hi, 
+			    float *descent, float *space,
+			    float *lspace, float *rspace)
+{
+  if (contentsChanged) {
+    if (bm && bm->Ok()) {
+      if (viewh <= 0)
+	h = bm->GetHeight();
+      else
+	h = viewh;
+      if (vieww <= 0)
+	w = bm->GetWidth();
+      else
+	w = vieww;
+    } else {
+      h = w = 0;
+    }
+    if (!h)
+      h = IMAGE_VOID_SIZE;
+    if (!w)
+      w = IMAGE_VOID_SIZE;
+  }
+
+  if (wi)
+    *wi = w;
+  if (hi)
+    *hi = h;
+  if (descent) {
+    if (!bm || !bm->Ok())
+      *descent = 1;
+    else
+      *descent = 0;
+  }
+  ALWAYSZERO(space);
+  ALWAYSZERO(lspace);
+  ALWAYSZERO(rspace);
+}
+
+void wxImageSnip::Draw(wxDC *dc, float x, float y, 
+		       float WXUNUSED(l), float WXUNUSED(t), 
+		       float WXUNUSED(r), float WXUNUSED(b),
+		       float WXUNUSED(dx), float WXUNUSED(dy), 
+		       int)
+{
+  if (!bm || !bm->Ok()) {
+    dc->DrawRectangle(x + 1, y + 1, 
+		      w - 2 + GC_RECT_FRAME_EXTEND, 
+		      h - 2 + GC_RECT_FRAME_EXTEND);
+    dc->DrawLine(x + 1, y + 1, 
+		 x + w - 2 + GC_LINE_EXTEND, 
+		 y + h - 2 + GC_LINE_EXTEND);
+    dc->DrawLine(x + 1, y + h - 2, 
+		 x + w - 2 + GC_LINE_EXTEND, 
+		 y + 1 - GC_LINE_EXTEND);
+    return;
+  }
+
+
+  dc->Blit(x, y, w, h, offscreen, 0, 0, wxCOPY);
+  return;
+
+#if 0
+  float lx, ly, lt, ll, lw, lh;
+
+  /* Doesn't work. I don't know why. Doesn't matter. */
+  if (vieww > 0 && r > x + vieww)
+    r = x + vieww;
+  if (x + w < r)
+    r = w + x;
+  if (viewh > 0 && b > y + viewh)
+    b = y + viewh;
+  if (y + h < b)
+    b = y + h;
+
+  x += viewdx;
+  y += viewdy;
+
+  if ((l > x + w) || (t > y + h))
+    return;
+  
+  lx = l - x;
+  if (lx < 0) {
+    lx = 0;
+    ll = x;
+  } else
+    ll = l;
+    
+  ly = t - y;
+  if (ly < 0) {
+    ly = 0;
+    lt = y;
+  } else
+    lt = t;
+
+  lw = r - ll;
+  lh = b - lt;
+
+  dc->Blit(ll, lt, lw, lh, offscreen, lx, ly, wxCOPY);
+#endif
+}
+
+wxSnip *wxImageSnip::Copy(void)
+{
+  wxImageSnip *snip;
+
+  snip = new wxImageSnip();
+  Copy(snip);
+
+  return (wxSnip *)snip;
+}
+
+void wxImageSnip::Write(wxMediaStreamOut &f)
+{
+  int writeBm = 0, writePm = 0;
+
+  f << (filename ? filename : "");
+  if (filename)
+    f << filetype;
+  else {
+    if (!bm)
+      f << 0;
+    else if (bm->GetDepth() == 1) {
+      f << 1;
+      writeBm = 1;
+    } else {
+      f << 2;
+      writePm = 1;
+    }
+  }
+  f << vieww;
+  f << viewh;
+  f << viewdx;
+  f << viewdy;
+  f << relativePath;
+
+  /* inline the image */
+  if (writeBm || writePm) {
+    long lenpos = f.Tell(), numlines = 0;
+    f.PutFixed(0);
+
+    char *fname = wxGetTempFileName("img", NULL);
+
+    bm->SaveFile(fname, writeBm ? wxBITMAP_TYPE_XBM : wxBITMAP_TYPE_XPM, NULL);
+
+    FILE *fi;
+    char buffer[IMG_MOVE_BUF_SIZE];
+    
+    fi = fopen(fname, "rb");
+    if (fi) {
+      while (1) {
+	int c;
+	c = fread(buffer, 1, IMG_MOVE_BUF_SIZE, fi);
+	if (c) {
+	  numlines++;
+	  f.Put(c, buffer);
+	} else 
+	  break;
+      }
+      fclose(fi);
+    }
+
+    wxRemoveFile(fname);
+    delete[] fname;
+
+    long end = f.Tell();
+    f.JumpTo(lenpos);
+    f.PutFixed(numlines);
+    f.JumpTo(end);
+  }
+}
+
+void wxImageSnip::LoadFile(char *name, long type, Bool relative, Bool inlineImg)
+{
+  if (filename) 
+    delete[] filename;
+ 
+  if (name && !*name)
+    name = NULL;
+
+  if (!sharing || !(--*sharing)) {
+    if (offscreen && sharing) {
+      offscreen->SelectObject(NULL);
+      delete offscreen;
+      offscreen = NULL;
+    }
+    if (bm && !userbm)
+      delete bm;
+    bm = NULL;
+  }
+
+  if (sharing) {
+    sharing = NULL;
+    offscreen = NULL;
+    bm = NULL;
+  }
+
+  userbm = FALSE;
+  
+  if (relative && name) {
+#ifdef wx_mac
+    if (name[0] != ':') {
+      int i;
+      for (i = 0; name[i]; i++)
+	if (name[i] == ':') {
+	  relative = FALSE;
+	  break;
+	}
+    }
+#else
+    if (name[0] == '/')
+      relative = FALSE;
+#ifdef wx_msw
+    if (name[0] == '\\')
+      relative = FALSE;
+    if (name[0] && name[1] == ':')
+      relative = FALSE;
+#endif
+#ifdef wx_x
+    if (name[0] == '~')
+      relative = FALSE;
+#endif
+#endif
+  }
+
+  relativePath = relative && name;
+
+  if (relativePath)
+    flags |= wxSNIP_USES_BUFFER_PATH;
+  else if (flags & wxSNIP_USES_BUFFER_PATH)
+    flags -= wxSNIP_USES_BUFFER_PATH;
+
+  if (name) {
+    char *loadname;
+
+    loadname = name;
+
+    if (!relativePath || (*admin_ptr)) {
+      if (relativePath) {
+	wxMediaBuffer *b;
+	char *fn, *path;
+	
+	b = (*admin_ptr) ? (*admin_ptr)->GetMedia() : (wxMediaBuffer *)NULL;
+	fn = b ? b->GetFilename() : (char *)NULL;
+	if (fn) {
+	  path = wxPathOnly(fn);
+	  if (path) {
+	    loadname = new WXGC_ATOMIC char[strlen(path) + strlen(name) + 2];
+	    strcpy(loadname, path);
+#ifdef wx_x
+	    strcat(loadname, "/");
+#else
+#ifdef wx_mac
+	    strcat(loadname, ":");
+#else
+	    strcat(loadname, "\\");
+#endif	    
+#endif
+	    strcat(loadname, name);
+	  }
+	}
+      }
+      
+      wxBeginBusyCursor();
+
+      bm = new wxBitmap((char *)wxmeExpandFilename(loadname), type);
+
+      wxEndBusyCursor();
+      
+      if (bm->Ok()) {
+	if (!offscreen)
+	  offscreen = new wxMemoryDC;
+	offscreen->SelectObject(bm);
+      } else {
+	delete bm;
+	bm = NULL;
+      }
+    }
+
+    if (!inlineImg) {
+      filename = copystring(name);
+      filetype = type;
+    } else
+      filename = NULL;
+  } else {
+    filename = NULL;
+  }
+
+  contentsChanged = TRUE;
+
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxImageSnip::Copy(wxImageSnip *newSnip)
+{
+  wxSnip::Copy(newSnip);
+  
+  newSnip->userbm = userbm;
+  if (filename)
+    newSnip->filename = copystring(filename);
+  else
+    newSnip->filename = NULL;
+  newSnip->filetype = filetype;
+  newSnip->relativePath = relativePath;
+
+  newSnip->vieww = vieww;
+  newSnip->viewh = viewh;
+  newSnip->viewdx = viewdx;
+  newSnip->viewdy = viewdy;
+  
+  if (bm) {
+    if (!sharing) {
+      sharing = new int;
+      *sharing = 1;
+    }
+    (*sharing)++;
+    newSnip->sharing = sharing;
+    newSnip->bm = bm;
+    newSnip->offscreen = offscreen;
+  } else {
+    newSnip->sharing = NULL;
+    newSnip->bm = NULL;
+    newSnip->offscreen = NULL;
+  }
+}
+
+char *wxImageSnip::GetFilename(Bool *rel)
+{
+  if (rel)
+    *rel = filename && relativePath;
+
+  return filename;
+}
+
+long wxImageSnip::GetFiletype()
+{
+  return filename ? 0 : filetype;
+}
+
+void wxImageSnip::SetBitmap(wxBitmap *map)
+{
+  if (sharing) {
+    if (--(*sharing)) {
+      offscreen = NULL;
+      bm = NULL;
+    }
+    sharing = NULL;
+  } else if (offscreen)
+    offscreen->SelectObject(NULL);
+
+  if (bm && !userbm)
+    delete bm;
+  bm = NULL;
+  userbm = FALSE;
+
+  if (!map->Ok())
+    return;
+
+  bm = map;
+
+  if (!offscreen)
+    offscreen = new wxMemoryDC;
+
+  offscreen->SelectObject(map);
+  userbm = TRUE;
+
+  contentsChanged = TRUE;
+  
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+}
+
+void wxImageSnip::SetOffset(float x, float y)
+{
+  viewdx = x;
+  viewdy = y;
+
+  contentsChanged = TRUE;
+
+  if (*admin_ptr)
+    (*admin_ptr)->NeedsUpdate(this, 0, 0, w, h);
+}
+
+Bool wxImageSnip::Resize(float w, float h)
+{
+  if (w <= 0 && !bm)
+    w = IMAGE_VOID_SIZE;
+  if (h <= 0 && !bm)
+    h = IMAGE_VOID_SIZE;
+
+  vieww = w;
+  viewh = h;
+
+  contentsChanged = TRUE;
+
+  if (*admin_ptr)
+    (*admin_ptr)->Resized(this, TRUE);
+
+  return TRUE;
+}
+
+long wxImageSnip::GetNumScrollSteps()
+{
+  long ss;
+
+  ss = (long)(h / IMAGE_PIXELS_PER_SCROLL);
+
+  return ss ? ss : 1;
+}
+
+long wxImageSnip::FindScrollStep(float y)
+{
+  return (long)(y / IMAGE_PIXELS_PER_SCROLL);
+}
+
+float wxImageSnip::GetScrollStepOffset(long i)
+{
+  return ((float )i) * IMAGE_PIXELS_PER_SCROLL;
+}
+
+void wxImageSnip::SetAdmin(wxSnipAdmin *a)
+{
+  if (PTRNE(*admin_ptr, a))
+    wxSnip::SetAdmin(a);
+  if (*admin_ptr && relativePath && filename)
+    LoadFile(filename, filetype, TRUE);
+}
+
+/***************************************************************/
+
+class MediaSnipClass : public wxSnipClass
+{
+ public:
+  MediaSnipClass(void);
+
+  virtual wxSnip *Read(wxMediaStreamIn &);
+};
+
+static MediaSnipClass TheMediaSnipClass;
+
+MediaSnipClass::MediaSnipClass(void)
+{
+  classname = "wxmedia";
+  version = 1;
+  required = TRUE;
+}
+
+wxSnip *MediaSnipClass::Read(wxMediaStreamIn &f)
+{
+  wxMediaBuffer *media;
+  wxMediaSnip *snip;
+  Bool border;
+  int lm, tm, rm, bm, li, ti, ri, bi, type;
+  float w, W, h, H;
+
+  f >> type >> border >> lm >> tm >> rm >> bm >> li >> ti >> ri >> bi
+    >> w >> W >> h >> H;
+
+  if (!type)
+    media = NULL;
+  else if (type == wxEDIT_BUFFER)
+    media = new wxMediaEdit();
+  else
+    media = new wxMediaPasteboard();
+
+  snip = new wxMediaSnip(media, border, lm, tm, rm, bm, li, ti, ri, bi,
+			 w, W, h, H);
+
+  if (media) {
+    media->GetStyleList()->Clear();
+    media->ReadFromFile(f);
+  } else
+    snip->SetMedia(NULL);
+
+  return snip;
+}
+
+/***************************************************************/
+
+wxSnipClassList::wxSnipClassList(void)
+: wxList((KeyType)wxKEY_STRING)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_SNIP_CLASS_LIST;
+#endif
+}
+
+wxSnipClassList::~wxSnipClassList()
+{
+}
+
+wxSnipClass *wxSnipClassList::Find(char *name)
+{
+  wxNode *node;
+
+  node = wxList::Find(name);
+
+  return node ? (wxSnipClass *)node->Data() : (wxSnipClass *)NULL;
+}
+
+short wxSnipClassList::FindPosition(wxSnipClass *sclass)
+{
+  wxNode *node;
+  short i;
+  
+  for (i = 0, node = First(); node; node = node->Next(), i++)
+    if (PTREQ(sclass, (wxSnipClass *)node->Data()))
+      return i;
+
+  return -1;
+}
+
+int wxSnipClassList::ReadingVersion(wxSnipClass *sclass)
+{
+  return sclass->readingVersion;
+}
+
+void wxSnipClassList::Add(wxSnipClass *snipclass)
+{
+  if (wxList::Find(snipclass->classname))
+    return;
+
+  Append(snipclass->classname, snipclass);
+}
+
+int wxSnipClassList::Number(void)
+{
+  return wxList::Number();
+}
+
+wxSnipClass *wxSnipClassList::Nth(int n)
+{
+  wxNode *node = wxList::Nth(n);
+
+  if (node)
+    return (wxSnipClass *)node->Data();
+  else
+    return NULL;
+}
+
+/***************************************************************/
+
+wxStandardSnipClassList::wxStandardSnipClassList(void)
+{
+  unknowns = new wxList((KeyType)wxKEY_INTEGER);
+
+  Add(&TheTextSnipClass);
+  Add(&TheTabSnipClass);
+  Add(&TheMediaSnipClass);
+  Add(&TheImageSnipClass);
+}
+
+void wxStandardSnipClassList::ResetHeaderFlags(int doneMsg)
+{
+  wxNode *node;
+  wxSnipClass *sclass;
+
+  for (node = First(); node; node = node->Next()) {
+    sclass = (wxSnipClass *)node->Data();
+    if (sclass->headerFlag) {
+      if (doneMsg == wxRESET_DONE_WRITE)
+	sclass->WriteDone();
+      else if (doneMsg == wxRESET_DONE_READ)
+	sclass->ReadDone();
+    }
+    sclass->headerFlag = 0;
+    sclass->mapPosition = -1;
+  }
+}
+
+Bool wxStandardSnipClassList::Write(wxMediaStreamOut &f)
+{
+  wxNode *node;
+  wxSnipClass *sclass;
+  short i;
+
+  f << Number();
+
+  for (i = 0, node = First(); node; node = node->Next(), i++) {
+    sclass = (wxSnipClass *)node->Data();
+    f << sclass->classname;
+    f << sclass->version;
+    f << sclass->required;
+    sclass->mapPosition = i;
+  }
+
+  return TRUE;
+}
+
+Bool wxStandardSnipClassList::Read(wxMediaStreamIn &f)
+{
+  int count, i;
+  long n;
+  wxSnipClass *sclass;
+  char buffer[256];
+  int version;
+  Bool required;
+
+  f >> count;
+
+  buffer[255] = 0;
+
+  wxNode *node, *next;
+  for (node = unknowns->First(); node; node = next) {
+    next = node->Next();
+    delete[] (char *)node->Data();
+    delete node;
+  }
+
+  for (i = 0; i < count; i++) {
+    n = 255;
+    f.Get((long *)&n, (char *)buffer);
+    f >> version;
+    f >> required;
+    if (!f.Ok())
+      return FALSE;
+    sclass = Find(buffer);
+    if (!sclass || (sclass->version < version)) {
+      /* unknown class; remember name in case it's used */
+      char *copy = copystring(buffer);
+      unknowns->Append(i, (wxObject *)copy);
+    } else {
+      sclass->mapPosition = i /* FindPosition(sclass) */;
+      sclass->readingVersion = version;
+    }
+  }
+
+  return TRUE;
+}
+
+wxSnipClass *wxStandardSnipClassList::FindByMapPosition(short n)
+{
+  wxNode *node;
+  wxSnipClass *sclass;
+  
+  if (n < 0)
+    return NULL;
+
+  for (node = First(); node; node = node->Next()) {
+    sclass = (wxSnipClass *)node->Data();
+    if (sclass->mapPosition == n)
+      return sclass;
+  }
+
+  if ((node = unknowns->Find(n))) {
+    /* Show error and then remove it from the list so it isn't shown again. */
+    char buffer2[256];
+    sprintf(buffer2, "Unknown snip class \"%.100s\".", (char *)node->Data());
+    wxMessageBox(buffer2, "Warning");
+
+    delete[] (char *)node->Data();
+    delete node;
+  }
+
+  return NULL;
+}
+
+#ifdef WXME_FOR_MRED
+wxStandardSnipClassList *wxMakeTheSnipClassList(void)
+{
+  return new wxStandardSnipClassList;
+}
+#else
+wxStandardSnipClassList wxTheSnipClassList;
+#endif
+
+/***************************************************************/
+
+wxBufferDataClass::wxBufferDataClass()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_BUFFER_DATA_CLASS;
+#endif
+
+  classname = "wxbad";
+  required = 0;
+}
+
+wxBufferData::wxBufferData()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_BUFFER_DATA;
+#endif
+
+  next = NULL;
+}
+
+wxBufferData::~wxBufferData()
+{
+  if (next)
+    delete next;
+}
+
+class LocationBufferDataClass : public wxBufferDataClass
+{
+ public:
+  LocationBufferDataClass();
+  wxBufferData *Read(wxMediaStreamIn &);
+};
+
+LocationBufferDataClass::LocationBufferDataClass()
+{
+  classname = "wxloc";
+  required = 1;
+}
+
+wxBufferData *LocationBufferDataClass::Read(wxMediaStreamIn &f)
+{
+  wxLocationBufferData *data;
+
+  data = new wxLocationBufferData;
+  f >> data->x;
+  f >> data->y;
+
+  return data;
+}
+
+LocationBufferDataClass TheLocationBufferDataClass;
+
+wxLocationBufferData::wxLocationBufferData()
+{
+  x = y = 0;
+  dataclass = &TheLocationBufferDataClass;
+}
+
+Bool wxLocationBufferData::Write(wxMediaStreamOut &f)
+{
+  f << x;
+  f << y;
+  return TRUE;
+}
+
+/**************************************************************/
+
+wxBufferDataClassList::wxBufferDataClassList(void)
+: wxList((KeyType)wxKEY_STRING)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_BUFFER_DATA_CLASS_LIST;
+#endif
+
+  Add(&TheLocationBufferDataClass);
+}
+
+wxBufferDataClassList::~wxBufferDataClassList()
+{
+}
+
+wxBufferDataClass *wxBufferDataClassList::Find(char *name)
+{
+  wxNode *node;
+
+  node = wxList::Find(name);
+
+  return node ? (wxBufferDataClass *)node->Data() : (wxBufferDataClass *)NULL;
+}
+
+short wxBufferDataClassList::FindPosition(wxBufferDataClass *sclass)
+{
+  wxNode *node;
+  short i;
+  
+  for (i = 0, node = First(); node; node = node->Next(), i++)
+    if (PTREQ(sclass, (wxBufferDataClass *)node->Data()))
+      return i + 1;
+
+  return 0;
+}
+
+void wxBufferDataClassList::Add(wxBufferDataClass *dataclass)
+{
+  if (wxList::Find(dataclass->classname))
+    return;
+
+  Append(dataclass->classname, dataclass);
+}
+
+int wxBufferDataClassList::Number(void)
+{
+  return wxList::Number();
+}
+
+wxBufferDataClass *wxBufferDataClassList::Nth(int n)
+{
+  wxNode *o = wxList::Nth(n);
+
+  if (!o)
+    return NULL;
+  else
+    return (wxBufferDataClass *)o->Data();
+}
+
+Bool wxBufferDataClassList::Write(wxMediaStreamOut &f)
+{
+  wxNode *node;
+  wxBufferDataClass *sclass;
+  short i;
+
+  f << Number();
+
+  for (i = 0, node = First(); node; node = node->Next(), i++) {
+    sclass = (wxBufferDataClass *)node->Data();
+    f << sclass->classname;
+    sclass->mapPosition = i + 1;
+  }
+
+  return TRUE;
+}
+
+Bool wxBufferDataClassList::Read(wxMediaStreamIn &f)
+{
+  int count, i;
+  long n;
+  wxBufferDataClass *sclass;
+  char buffer[256];
+
+  f >> count;
+
+  buffer[255] = 0;
+
+  for (i = 0; i < count; i++) {
+    n = 255;
+    f.Get((long *)&n, (char *)buffer);
+    if (!f.Ok())
+      return FALSE;
+    sclass = Find(buffer);
+    if (!sclass) {
+      char buffer2[256];
+      sprintf(buffer2, "Unknown snip data class \"%.100s\".", buffer);
+      wxMessageBox(buffer2, "Warning");
+    } else
+      sclass->mapPosition = FindPosition(sclass);
+  }
+
+  return TRUE;
+}
+
+wxBufferDataClass *wxBufferDataClassList::FindByMapPosition(short n)
+{
+  wxNode *node;
+  wxBufferDataClass *sclass;
+  
+  if (n <= 0)
+    return NULL;
+
+  for (node = First(); node; node = node->Next()) {
+    sclass = (wxBufferDataClass *)node->Data();
+    if (sclass->mapPosition == n)
+      return sclass;
+  }
+
+  return NULL;
+}
+
+#ifdef WXME_FOR_MRED
+wxBufferDataClassList *wxMakeTheBufferDataClassList()
+{
+  return new wxBufferDataClassList;
+}
+#else
+wxBufferDataClassList wxTheBufferDataClassList;
+#endif
diff --git a/src/mred/wxme/wx_snip.h b/src/mred/wxme/wx_snip.h
new file mode 100644
index 0000000..3de79ed
--- /dev/null
+++ b/src/mred/wxme/wx_snip.h
@@ -0,0 +1,496 @@
+
+#ifndef __WX_SNIP__
+#define __WX_SNIP__
+
+class wxSnipAdmin;
+
+/* The default is that none of these flags are on: */
+enum {
+  wxSNIP_IS_TEXT = 0x1,
+  wxSNIP_CAN_APPEND = 0x2,
+  wxSNIP_INVISIBLE = 0x4,
+  wxSNIP_NEWLINE = 0x8, /* Soft newline, typically inserted by wxMediaEdit */
+  wxSNIP_HARD_NEWLINE = 0x10, /* => Snip must be follwed by newline */
+  wxSNIP_HANDLES_EVENTS = 0x20,
+  wxSNIP_WIDTH_DEPENDS_ON_X = 0x40,
+  wxSNIP_HEIGHT_DEPENDS_ON_Y = 0x80,
+  wxSNIP_WIDTH_DEPENDS_ON_Y = 0x100,
+  wxSNIP_HEIGHT_DEPENDS_ON_X = 0x200,
+  wxSNIP_ANCHORED = 0x400,
+  wxSNIP_USES_BUFFER_PATH = 0x800,
+  wxSNIP_CAN_SPLIT = 0x1000, /* safety feature */
+  wxSNIP_OWNED = 0x2000,
+  wxSNIP_CAN_DISOWN = 0x4000
+};
+
+#define WRITE_FUNC \
+   Bool wxmbWriteSnipsToFile(class wxMediaStreamOut &, \
+			     class wxStyleList *, \
+			     class wxList *, class wxSnip *, \
+			     class wxSnip *, wxList *, \
+			     class wxMediaBuffer *)
+
+class wxSnip;
+extern WRITE_FUNC;
+
+class wxSnipClass : public wxObject
+{
+  friend class wxStandardSnipClassList;
+  friend class wxSnipClassList;
+  friend class wxMediaBuffer;
+  friend WRITE_FUNC;
+
+  /* Special fields just for wxStandardSnipClassList & wxMediaEdit */
+  Bool headerFlag;
+  short mapPosition;
+  int readingVersion;
+
+ public:
+  char *classname;
+  int version;
+
+  /* If this flag is TRUE, then files saved to disk will be written
+     assuming that, when the file is read from disk, the class will
+     always be present. */
+  Bool required;
+  
+  wxSnipClass();
+
+  virtual class wxSnip *Read(wxMediaStreamIn &) = 0;
+
+  virtual Bool ReadHeader(wxMediaStreamIn &);
+  virtual void ReadDone(void);
+
+  virtual Bool WriteHeader(wxMediaStreamOut &);
+  virtual void WriteDone(void);
+};
+
+class wxSnipClassList : public /* should be private */ wxList
+{
+ public:
+  wxSnipClassList(void);
+  ~wxSnipClassList();
+
+  wxSnipClass *Find(char *name);
+  short FindPosition(wxSnipClass *);
+  int ReadingVersion(wxSnipClass *);
+  void Add(wxSnipClass *snipclass); /* Checks for duplicates */
+  int Number(void);
+  wxSnipClass *Nth(int);
+};
+
+enum {
+  wxRESET_NO_MSG = 0,
+  wxRESET_DONE_READ,
+  wxRESET_DONE_WRITE
+};
+
+class wxStandardSnipClassList : public wxSnipClassList
+{
+ private:
+  wxList *unknowns;
+
+ public:
+  wxStandardSnipClassList(void);
+
+  void ResetHeaderFlags(int doneMsg = wxRESET_NO_MSG);
+  Bool Write(wxMediaStreamOut &f);
+  Bool Read(wxMediaStreamIn &f);
+  wxSnipClass *FindByMapPosition(short n);
+};
+
+#ifdef WXME_FOR_MRED
+extern wxStandardSnipClassList *wxMakeTheSnipClassList();
+extern wxStandardSnipClassList *wxGetTheSnipClassList();
+#define wxTheSnipClassList (*wxGetTheSnipClassList())
+#else
+extern wxStandardSnipClassList wxTheSnipClassList;
+#endif
+
+/******************************************************************/
+
+class wxSnip : public wxObject
+{
+ private:
+  friend class wxMediaEdit;
+  friend class wxMediaPasteboard;
+  friend class wxMediaBuffer;
+  friend class wxMediaLine;
+  friend WRITE_FUNC;
+
+  /* For use only by the owning wxMediaBuffer */
+  wxSnip *prev, *next;
+  class wxMediaLine *line;
+
+  void Init(void);
+
+ protected:
+  wxSnipAdmin **admin_ptr;
+
+ public:
+  long count;
+  long flags;
+  wxSnipClass *snipclass;
+  wxStyle *style;
+
+  wxSnip();
+  wxSnip(Bool cleanup);
+  ~wxSnip();
+
+  wxSnip *Next(void);
+  wxSnip *Previous(void);
+
+  wxSnipAdmin *GetAdmin(void);
+  virtual void SetAdmin(wxSnipAdmin *);
+
+  Bool IsOwned(void);
+  Bool ReleaseFromOwner(void);
+
+  void SetCount(long count);
+  void SetFlags(long flags);
+
+  virtual void OnEvent(wxDC *dc, float x, float y, 
+		       float mediax, float mediay, 
+		       wxMouseEvent &event);
+  virtual void OnChar(wxDC *dc, float x, float y, 
+		      float mediax, float mediay, 
+		      wxKeyEvent &event);
+  virtual wxCursor *AdjustCursor(wxDC *dc, float x, float y, 
+				 float mediax, float mediay, 
+				 wxMouseEvent &event);
+  virtual void OwnCaret(Bool);  
+  
+  virtual void DoEdit(int op, Bool recursive = TRUE, long time = 0);
+  virtual void DoFont(int op, Bool recursive = TRUE);
+
+  virtual int Match(wxSnip *other); 
+
+  virtual void SizeCacheInvalid(void);
+
+  virtual void GetExtent(wxDC *dc, 
+			 float x, float y,
+			 float *w = NULL, float *h = NULL, 
+			 float *descent = NULL, float *space = NULL,
+			 float *lspace = NULL, float *rspace = NULL);
+  virtual float PartialOffset(wxDC *, float x, float y, long);
+  virtual void Draw(wxDC *dc, float x, float y, 
+		    float,float,float,float, 
+		    float dx, float xy, 
+		    int show_caret);
+  virtual void Split(long position, wxSnip **first, wxSnip **second);
+  virtual wxSnip *MergeWith(wxSnip *pred);
+  virtual void GetText(char *s, long offset, long num);
+  virtual char *GetText(long offset, long num, Bool flattened = FALSE, long *got=NULL);
+  virtual wxSnip *Copy();
+  virtual void Write(wxMediaStreamOut &f);
+
+  virtual Bool Resize(float w, float h);
+
+  virtual long GetNumScrollSteps();
+  virtual long FindScrollStep(float y);
+  virtual float GetScrollStepOffset(long i);
+
+  void SetStyle(wxStyle *s);
+
+ protected:
+  void Copy(wxSnip *); /* Copy basic values into given snip */
+};
+
+class wxTextSnip : public wxSnip
+{
+ protected:
+  float w; /* < 0 => need to recalc size */
+
+  void GetTextExtent(wxDC *dc, int count, float *wo);
+
+ public:
+  char *text;
+  char *buffer;
+
+  long allocated;
+
+  wxTextSnip(long allocsize = 0); 
+  ~wxTextSnip(); 
+
+  virtual void SizeCacheInvalid(void);
+
+  virtual void GetExtent(wxDC *dc,
+			 float x, float y,
+			 float *w = NULL, float *h = NULL, 
+			 float *descent = NULL, float *space = NULL,
+			 float *lspace = NULL, float *rspace = NULL);
+  virtual float PartialOffset(wxDC *, float x, float y, long);
+  virtual void Draw(wxDC *dc, float x, float y, 
+		    float,float,float,float, 
+		    float dx, float dy, int);
+  virtual void Split(long position, wxSnip **first, wxSnip **second);
+  virtual wxSnip *MergeWith(wxSnip *pred);
+
+  virtual void Insert(char *str, long len, long pos = 0);
+  virtual void Read(long len, wxMediaStreamIn &f);
+  virtual void GetText(char *s, long offset, long num);
+  virtual char *GetText(long offset, long num, Bool flattened = FALSE, long *got=NULL);
+  virtual wxSnip *Copy(void);
+  virtual void Write(wxMediaStreamOut &f);
+
+
+#ifdef MEMORY_USE_METHOD
+  long MemoryUse(void);
+#endif
+
+ protected:
+  void Copy(wxTextSnip *); /* Copy text values into given snip */
+};
+
+class wxTabSnip : public wxTextSnip
+{
+ public:
+  wxTabSnip();
+  
+  virtual void GetExtent(wxDC *dc, 
+			 float x, float y,
+			 float *w = NULL, float *h = NULL, 
+			 float *descent = NULL, float *space = NULL,
+			 float *lspace = NULL, float *rspace = NULL);
+  virtual float PartialOffset(wxDC *, float x, float y, long);
+  virtual void Draw(wxDC *dc, float x, float y, 
+		    float,float,float,float, 
+		    float dx, float dy, int);
+  virtual wxSnip *Copy();
+};
+
+class wxImageSnip : public wxSnip
+{
+ private:
+  Bool userbm;
+  char *filename;
+  long filetype; /* file != NULL => type of file, otherwise loaded 1 => XBM and 2 => XPM */
+  wxBitmap *bm;
+  wxMemoryDC *offscreen;
+  int *sharing;
+  Bool relativePath;
+
+ protected:
+  float w, h, vieww, viewh, viewdx, viewdy;
+  Bool contentsChanged;
+
+ public:
+  wxImageSnip(char *name = NULL, long type = 0, Bool relative = FALSE, Bool inlineImg = TRUE); 
+  ~wxImageSnip(); 
+
+  virtual void SizeCacheInvalid(void);
+
+  virtual void GetExtent(wxDC *dc,
+			 float x, float y,
+			 float *w = NULL, float *h = NULL, 
+			 float *descent = NULL, float *space = NULL,
+			 float *lspace = NULL, float *rspace = NULL);
+
+  virtual void Draw(wxDC *dc, float x, float y, 
+		    float,float,float,float, 
+		    float dx, float dy, int);
+
+  virtual wxSnip *Copy(void);
+
+  virtual void Write(wxMediaStreamOut &f);
+
+  void LoadFile(char *name, long type, Bool relative = FALSE, Bool inlineImg = TRUE);
+  char *GetFilename(Bool *relative);
+  long GetFiletype();
+
+  void SetBitmap(wxBitmap *);
+
+  void SetOffset(float dx, float dy);
+  virtual Bool Resize(float w, float h);
+
+  virtual long GetNumScrollSteps();
+  virtual long FindScrollStep(float y);
+  virtual float GetScrollStepOffset(long i);
+
+  virtual void SetAdmin(wxSnipAdmin *);
+
+ protected:
+  void Copy(wxImageSnip *);
+};
+
+class wxSnipAdmin : public wxObject
+{
+ public:
+  virtual wxMediaBuffer *GetMedia(void) = 0;
+
+  virtual wxDC *GetDC() = 0;
+  virtual void GetViewSize(float *h, float *w) = 0;
+  virtual void GetView(float *x, float *y, float *h, float *w, wxSnip *snip = NULL) = 0;
+  virtual Bool ScrollTo(wxSnip *, float localx, float localy, 
+			float w, float h, Bool refresh, int bias = 0) = 0;
+  virtual void SetCaretOwner(wxSnip *, int = wxFOCUS_IMMEDIATE) = 0;
+  virtual void Resized(wxSnip *, Bool redraw_now) = 0;
+  virtual Bool Recounted(wxSnip *, Bool redraw_now) = 0;
+  virtual void NeedsUpdate(wxSnip *, float localx, float localy, 
+			   float w, float h) = 0;
+  virtual Bool ReleaseSnip(wxSnip *) = 0;
+
+  virtual void UpdateCursor() = 0;
+};
+
+#define wxMSNIPBOX_XMARGIN 5
+#define wxMSNIPBOX_YMARGIN 5
+#define wxMSNIPBOX_XINSET 1
+#define wxMSNIPBOX_YINSET 1
+
+class wxMediaSnip : public wxSnip
+{
+  friend class wxMediaSnipMediaAdmin;
+
+  wxMediaBuffer *me;
+  class wxMediaSnipMediaAdmin *myAdmin;
+
+  Bool withBorder;
+  int leftMargin, topMargin, rightMargin, bottomMargin;
+  int leftInset, topInset, rightInset, bottomInset;
+
+  float minWidth, maxWidth, minHeight, maxHeight;
+
+ public:
+  wxMediaSnip(wxMediaBuffer *useme = NULL,
+	      Bool withBorder = TRUE,
+	      int leftMargin = wxMSNIPBOX_XMARGIN,
+	      int topMargin = wxMSNIPBOX_YMARGIN,
+	      int rightMargin = wxMSNIPBOX_XMARGIN,
+	      int bottomMargin = wxMSNIPBOX_YMARGIN,
+	      int leftInset = wxMSNIPBOX_XINSET,
+	      int topInset = wxMSNIPBOX_YINSET,
+	      int rightInset = wxMSNIPBOX_XINSET,
+	      int bottomInset = wxMSNIPBOX_YINSET,
+	      float w = -1, float W = -1, 
+	      float h = -1, float H = -1);
+  ~wxMediaSnip();
+
+  virtual void SetAdmin(wxSnipAdmin *a);
+
+  virtual void OnEvent(wxDC *, float, float, float,float, wxMouseEvent &event);
+  virtual void OnChar(wxDC *, float, float, float, float, wxKeyEvent &event);
+  virtual wxCursor *AdjustCursor(wxDC *, float, float, float,float, wxMouseEvent &event);
+  virtual void OwnCaret(Bool);  
+
+  virtual void DoEdit(int op, Bool recursive = TRUE, long time = 0);
+  virtual void DoFont(int op, Bool recursive = TRUE);
+
+  virtual Bool Match(wxSnip *other); 
+
+  virtual void SizeCacheInvalid(void);
+
+  virtual char *GetText(long offset, long num, Bool flattened = FALSE, long *got = NULL);
+
+  virtual void GetExtent(wxDC *dc, 
+			 float x, float y,
+			 float *w = NULL, float *h = NULL, 
+			 float *descent = NULL, float *space = NULL,
+			 float *lspace = NULL, float *rspace = NULL);
+  virtual void Draw(wxDC *dc, float x, float y, 
+		    float, float, float, float, float dx, float dy, 
+		    int show_caret);
+  virtual wxSnip *Copy(void);
+
+  virtual void Write(wxMediaStreamOut &f);
+
+  virtual long GetNumScrollSteps();
+  virtual long FindScrollStep(float y);
+  virtual float GetScrollStepOffset(long i);
+
+  void SetMaxWidth(float);
+  void SetMaxHeight(float);
+  float GetMaxWidth(void);
+  float GetMaxHeight(void);
+  void SetMinWidth(float);
+  void SetMinHeight(float);
+  float GetMinWidth(void);
+  float GetMinHeight(void);
+
+  void ShowBorder(Bool show);
+  Bool BorderVisible();
+
+  void SetMargin(int lm, int tm, int rm, int bm);
+  void GetMargin(int *lm, int *tm, int *rm, int *bm);
+  void SetInset(int lm, int tm, int rm, int bm);
+  void GetInset(int *li, int *ti, int *ri, int *bi);
+
+  virtual Bool Resize(float w, float h);
+
+  wxMediaBuffer *GetThisMedia(void);
+  void SetMedia(wxMediaBuffer *b);
+};
+
+/**********************************************************************/
+
+class wxMediaStreamOut;
+class wxBufferData;
+
+class wxBufferDataClass : public wxObject
+{
+ private:
+  friend class wxBufferDataClassList;
+  friend class wxMediaBuffer;
+  friend WRITE_FUNC;
+  friend Bool wxmbWriteBufferData(wxMediaStreamOut&, wxBufferData *data);
+
+  int mapPosition;
+ public:
+  char *classname;
+  Bool required;
+
+  wxBufferDataClass();
+
+  virtual class wxBufferData *Read(wxMediaStreamIn &) = 0;
+};
+
+class wxBufferData : public wxObject
+{
+ public:
+  wxBufferDataClass *dataclass;
+  wxBufferData *next; /* Used to chain them in a list */
+
+  wxBufferData();
+  ~wxBufferData();
+
+  virtual Bool Write(wxMediaStreamOut &) = 0;
+};
+
+class wxBufferDataClassList : public /* should be private */ wxList
+{
+ public:
+  wxBufferDataClassList();
+  ~wxBufferDataClassList();
+
+  wxBufferDataClass *Find(char *name);
+  short FindPosition(wxBufferDataClass *);
+  void Add(wxBufferDataClass *dataclass); /* Checks for duplicates */
+  int Number(void);
+  wxBufferDataClass *Nth(int);
+
+  Bool Write(wxMediaStreamOut &f);
+  Bool Read(wxMediaStreamIn &f);
+  wxBufferDataClass *FindByMapPosition(short n);
+};
+
+#ifdef WXME_FOR_MRED
+extern wxBufferDataClassList *wxMakeTheBufferDataClassList();
+extern wxBufferDataClassList *wxGetTheBufferDataClassList();
+#define wxTheBufferDataClassList (*wxGetTheBufferDataClassList())
+#else
+extern wxBufferDataClassList wxTheBufferDataClassList;
+#endif
+
+/**********************************************************************/
+
+class wxLocationBufferData : public wxBufferData
+{
+ public:
+  float x, y;
+
+  wxLocationBufferData();
+
+  Bool Write(wxMediaStreamOut &);
+};
+
+#endif __WX_SNIP__
diff --git a/src/mred/wxme/wx_style.cxx b/src/mred/wxme/wx_style.cxx
new file mode 100644
index 0000000..c655171
--- /dev/null
+++ b/src/mred/wxme/wx_style.cxx
@@ -0,0 +1,1591 @@
+/*
+ * File:        wx_style.cc
+ * Purpose:     wxStyle and wxStyleList implementation
+ * Author:      Matthew Flatt
+ * Created:     1995
+ * Copyright:   (c) 1995, Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ */
+
+#include "wx_gdi.h"
+#include "wx_main.h"
+#include "wx_dialg.h"
+#ifndef OLD_WXWINDOWS
+#include "wx_cmdlg.h"
+#endif
+#include "wx_style.h"
+#include "wx_mtype.h"
+#include "wx_medio.h"
+#include "wx_ptreq.h"
+#include <string.h>
+
+#ifdef wx_x
+static int defaultSize = 12;
+#endif
+#ifdef wx_msw
+static int defaultSize = 12;
+#endif
+#ifdef wx_mac
+static int defaultSize = 12;
+#endif
+
+#if !defined(wx_xt) || defined(WXME_FOR_MRED)
+#define FONT_DIRECTORY wxTheFontNameDirectory
+#else
+#define FONT_DIRECTORY (*wxTheFontNameDirectory)
+#endif
+
+wxStyleList *wxTheStyleList;
+
+static wxColour *whiteColour, *blackColour;
+
+void wxInitStyles(void)
+{
+  if (wxTheStyleList)
+    return;
+
+  whiteColour = wxTheColourDatabase->FindColour("WHITE");
+  blackColour = wxTheColourDatabase->FindColour("BLACK");
+
+#if USE_RESOURCES
+  wxGetResource(wxTheApp->wx_class, "defaultFontSize", &defaultSize);
+#endif
+
+  wxTheStyleList = new wxStyleList;
+}
+
+void wxMultColour::Get(float *rf, float *gf, float *bf)
+{
+  *rf = r;
+  *gf = g;
+  *bf = b;
+}
+
+void wxMultColour::Set(float rf, float gf, float bf)
+{
+  r = rf;
+  g = gf;
+  b = bf;
+}
+
+void wxAddColour::Get(short *rf, short *gf, short *bf)
+{
+  *rf = r;
+  *gf = g;
+  *bf = b;
+}
+
+void wxAddColour::Set(short rf, short gf, short bf)
+{
+  r = rf;
+  g = gf;
+  b = bf;
+}
+
+wxStyleDelta::wxStyleDelta(int changeCommand, int param) 
+: wxObject(WXGC_NO_CLEANUP)
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_STYLE_DELTA;
+#endif
+
+  face = NULL;
+    
+  SetDelta(wxCHANGE_NOTHING);
+  SetDelta(changeCommand, param);
+}
+
+wxStyleDelta::~wxStyleDelta()
+{
+  if (face)
+    delete[] face;
+}
+
+wxStyleDelta *wxStyleDelta::SetDelta(int changeCommand, int param)
+{
+  switch (changeCommand) {
+  case wxCHANGE_NOTHING:
+    family = wxBASE;
+    if (face) {
+      delete[] face;
+      face = NULL;
+    }
+    sizeMult = 1;
+    sizeAdd = 0;
+    weightOn = wxBASE;
+    weightOff = wxBASE;
+    styleOn = wxBASE;
+    styleOff = wxBASE;
+    underlinedOn = underlinedOff = FALSE;
+    transparentTextBackingOn = transparentTextBackingOff = FALSE;
+    foregroundMult.Set(1, 1, 1);
+    foregroundAdd.Set(0, 0, 0);
+    backgroundMult.Set(1, 1, 1);
+    backgroundAdd.Set(0, 0, 0);
+    alignmentOn = wxBASE;
+    alignmentOff = wxBASE;
+    break;
+  case wxCHANGE_STYLE:
+    styleOn = param;
+    styleOff = wxBASE;
+    break;
+  case wxCHANGE_WEIGHT:
+    weightOn = param;
+    weightOff = wxBASE;
+    break;
+  case wxCHANGE_UNDERLINE:
+    underlinedOn = param;
+    underlinedOff = !param;
+    break;
+  case wxCHANGE_SIZE:
+    sizeMult = 0;
+    sizeAdd = param;
+    break;
+  case wxCHANGE_FAMILY:
+    family = param;
+    if (face) {
+      delete[] face;
+      face = NULL;
+    }
+    break;
+  case wxCHANGE_ALIGNMENT:
+    alignmentOn = param;
+    alignmentOff = wxBASE;
+    break;
+  case wxCHANGE_BOLD:
+    weightOn = wxBOLD;
+    weightOff = wxBASE;
+    break;
+  case wxCHANGE_ITALIC:
+    styleOn = wxITALIC;
+    styleOff = wxBASE;
+    break;
+  case wxCHANGE_TOGGLE_STYLE:
+    styleOn = param;
+    styleOff = param;
+    break;
+  case wxCHANGE_TOGGLE_WEIGHT:
+    weightOn = param;
+    weightOff = param;
+    break;
+  case wxCHANGE_TOGGLE_UNDERLINE:
+    underlinedOn = TRUE;
+    underlinedOff = TRUE;
+    break;
+  case wxCHANGE_BIGGER:
+    sizeMult = 1;
+    sizeAdd = param;
+    break;
+  case wxCHANGE_SMALLER:
+    sizeMult = 1;
+    sizeAdd = -param;
+    break;
+  case wxCHANGE_NORMAL:
+    family = wxDEFAULT;
+    if (face) {
+      delete[] face;
+      face = NULL;
+    }
+    sizeMult = 0;
+    sizeAdd = defaultSize;
+    weightOn = wxNORMAL;
+    weightOff = wxBASE;
+    styleOn = wxNORMAL;
+    styleOff = wxBASE;
+    underlinedOn = FALSE;
+    underlinedOff = TRUE;
+    alignmentOn = wxALIGN_BOTTOM;
+    alignmentOff = wxBASE;
+    /* fall through ... */
+  case wxCHANGE_NORMAL_COLOUR: /* ^^ falls through */
+    foregroundMult.Set(0, 0, 0);
+    foregroundAdd.Set(0, 0, 0);
+    backgroundMult.Set(0, 0, 0);
+    backgroundAdd.Set(255, 255, 255);
+    break;
+  }
+
+  return this;
+}
+
+wxStyleDelta *wxStyleDelta::SetDeltaFace(char *name)
+{
+  if (face)
+    delete[] face;
+  face = copystring(name);
+#ifdef NO_GENERAL_FONTS
+  family = wxBASE;
+#else
+  int id = FONT_DIRECTORY.FindOrCreateFontId(name, wxDEFAULT);
+  family = FONT_DIRECTORY.GetFamily(id);
+#endif
+  return this;
+}
+
+wxStyleDelta *wxStyleDelta::SetDeltaBackground(char *name)
+{
+  wxColour *c;
+
+  transparentTextBackingOn = FALSE;
+  transparentTextBackingOff = TRUE;
+
+  if ((c = wxTheColourDatabase->FindColour(name)))
+    SetDeltaBackground(*c);
+
+  return this;
+}
+
+wxStyleDelta *wxStyleDelta::SetDeltaBackground(wxColour& colour)
+{
+  unsigned char r, g, b;
+
+  transparentTextBackingOn = FALSE;
+  transparentTextBackingOff = TRUE;
+
+  backgroundMult.Set(0, 0, 0);
+  colour.Get(&r, &g, &b);
+  backgroundAdd.Set(r, g, b);
+
+  return this;
+}
+
+wxStyleDelta *wxStyleDelta::SetDeltaForeground(char *name)
+{
+  wxColour *c;
+
+  if ((c = wxTheColourDatabase->FindColour(name)))
+    SetDeltaForeground(*c);
+  return this;
+}
+
+wxStyleDelta *wxStyleDelta::SetDeltaForeground(wxColour& colour)
+{
+  unsigned char r, g, b;
+
+  foregroundMult.Set(0, 0, 0);
+  colour.Get(&r, &g, &b);
+  foregroundAdd.Set(r, g, b);
+  return this;
+}
+
+Bool wxStyleDelta::Collapse(wxStyleDelta &deltaIn)
+{
+  float ambr, ambb, ambg, amfr, amfb, amfg;
+  float bmbr, bmbb, bmbg, bmfr, bmfb, bmfg;
+  short aabr, aabb, aabg, aafr, aafb, aafg;
+  short babr, babb, babg, bafr, bafb, bafg;
+
+  /* If collapsing possible? */
+  /* It may not be if add & multiply sequence occurs, */
+  /* or certain toggling settings conflict or */
+  if (sizeMult && sizeMult != 1.0 && deltaIn.sizeAdd != 0)
+    return FALSE;
+
+  foregroundMult.Get(&amfr, &amfb, &amfg);
+  backgroundMult.Get(&ambr, &ambb, &ambg);
+  deltaIn.foregroundAdd.Get(&bafr, &bafb, &bafg);
+  deltaIn.backgroundAdd.Get(&babr, &babb, &babg);
+  if ((amfr && amfr != 1.0 && bafr != 0)
+      || (amfg && amfg != 1.0 && bafg != 0)
+      || (amfb && amfb != 1.0 && bafb != 0)
+      || (ambr && ambr != 1.0 && babr != 0)
+      || (ambg && ambg != 1.0 && babg != 0)
+      || (ambb && ambb != 1.0 && babb != 0))
+    return FALSE;
+
+  // Cases: simple or double toggle
+  //        no further change
+  //        formerly no change
+  //        style definitely on
+  //        style definitely off
+  if (!((styleOn == deltaIn.styleOn && styleOff == deltaIn.styleOff)
+	|| (styleOn == wxBASE && styleOff == wxBASE)
+	|| (deltaIn.styleOn == wxBASE && deltaIn.styleOff == wxBASE)
+	|| (styleOn == wxBASE && styleOff != wxBASE)
+	|| (styleOff == wxBASE && styleOn != wxBASE)))
+    return FALSE;
+  if (!((weightOn == deltaIn.weightOn && weightOff == deltaIn.weightOff)
+	|| (weightOn == wxBASE && weightOff == wxBASE)
+	|| (weightOn == wxBASE && weightOff != wxBASE)
+	|| (weightOff == wxBASE && weightOn != wxBASE)))
+    return FALSE;
+  if (!((alignmentOn == deltaIn.alignmentOn 
+	 && alignmentOff == deltaIn.alignmentOff)
+	|| (alignmentOn == wxBASE && alignmentOff == wxBASE)
+	|| (alignmentOn == wxBASE && alignmentOff != wxBASE)
+	|| (alignmentOff == wxBASE && alignmentOn != wxBASE)))
+    return FALSE;
+
+  if (!((underlinedOn == deltaIn.underlinedOn
+	 && underlinedOff == deltaIn.underlinedOff)
+	|| (!underlinedOn && !underlinedOff)
+	|| (!deltaIn.underlinedOn && !deltaIn.underlinedOff)
+	|| (!underlinedOn && underlinedOff)
+	|| (!underlinedOff && underlinedOn)))
+    return FALSE;
+
+  if (!((transparentTextBackingOn == deltaIn.transparentTextBackingOn
+	 && transparentTextBackingOff == deltaIn.transparentTextBackingOff)
+	|| (!transparentTextBackingOn && !transparentTextBackingOff)
+	|| (!deltaIn.transparentTextBackingOn && !deltaIn.transparentTextBackingOff)
+	|| (!transparentTextBackingOn && transparentTextBackingOff)
+	|| (!transparentTextBackingOff && transparentTextBackingOn)))
+    return FALSE;
+
+  /* Collapsing is possible. */
+
+  deltaIn.foregroundMult.Get(&bmfr, &bmfb, &bmfg);
+  deltaIn.backgroundMult.Get(&bmbr, &bmbb, &bmbg);
+  foregroundAdd.Get(&aafr, &aafb, &aafg);
+  backgroundAdd.Get(&aabr, &aabb, &aabg);
+  
+  sizeAdd += (int)(sizeMult * deltaIn.sizeAdd);
+  sizeMult *= deltaIn.sizeMult;
+
+  foregroundMult.Set(amfr * bmfr, amfb * bmfb, amfg * bmfg);
+  backgroundMult.Set(ambr * bmbr, ambb * bmbb, ambg * bmbg);
+  foregroundAdd.Set(aafr + (int)(amfr * bafr), 
+		    aafb + (int)(amfb * bafb), 
+		    aafg + (int)(amfg * bafg));
+  backgroundAdd.Set(aabr + (int)(ambr * babr), 
+		    aabb + (int)(ambb * babb), 
+		    aabg + (int)(ambg * babg));
+
+  if (family == wxBASE) {
+    family = deltaIn.family;
+    if (deltaIn.face)
+      face = copystring(deltaIn.face);
+  }
+
+  if (styleOn == wxBASE && styleOff == wxBASE) {
+    styleOff = deltaIn.styleOff;
+    styleOn = deltaIn.styleOn;
+  } else if (styleOn != wxBASE && styleOff != wxBASE) {
+    if (deltaIn.styleOn != wxBASE || deltaIn.styleOff != wxBASE
+	&& styleOn == styleOff)
+      styleOn = styleOff = wxBASE; // Double toggle
+  }
+  if (weightOn == wxBASE && weightOff == wxBASE) {
+    weightOff = deltaIn.weightOff;
+    weightOn = deltaIn.weightOn;
+  } else if (weightOn != wxBASE && weightOff != wxBASE) {
+    if (deltaIn.weightOn != wxBASE || deltaIn.weightOff != wxBASE
+	&& weightOn == weightOff)
+      weightOn = weightOff = wxBASE; // Double toggle
+  }
+  if (alignmentOn == wxBASE && alignmentOff == wxBASE) {
+    alignmentOff = deltaIn.alignmentOff;
+    alignmentOn = deltaIn.alignmentOn;
+  } else if (alignmentOn != wxBASE && alignmentOff != wxBASE) {
+    if (deltaIn.alignmentOn != wxBASE || deltaIn.alignmentOff != wxBASE
+	&& alignmentOn == alignmentOff)
+      alignmentOn = alignmentOff = wxBASE; // Double toggle
+  }
+  if (!underlinedOn && !underlinedOff) {
+    underlinedOn = deltaIn.underlinedOn;
+    underlinedOff = deltaIn.underlinedOff;
+  } else if (underlinedOn && underlinedOff) {
+    if (deltaIn.underlinedOn && deltaIn.underlinedOff)
+      underlinedOn = underlinedOff = FALSE;
+  }
+  if (!transparentTextBackingOn && !transparentTextBackingOff) {
+    transparentTextBackingOn = deltaIn.transparentTextBackingOn;
+    transparentTextBackingOff = deltaIn.transparentTextBackingOff;
+  } else if (transparentTextBackingOn && transparentTextBackingOff) {
+    if (deltaIn.transparentTextBackingOn && deltaIn.transparentTextBackingOff)
+      transparentTextBackingOn = transparentTextBackingOff = FALSE;
+  }
+
+  return TRUE;
+}
+
+Bool wxStyleDelta::Equal(wxStyleDelta &deltaIn)
+{
+  float ambr, ambb, ambg, amfr, amfb, amfg;
+  float bmbr, bmbb, bmbg, bmfr, bmfb, bmfg;
+  short aabr, aabb, aabg, aafr, aafb, aafg;
+  short babr, babb, babg, bafr, bafb, bafg;
+  
+  foregroundMult.Get(&amfr, &amfb, &amfg);
+  backgroundMult.Get(&ambr, &ambb, &ambg);
+  foregroundAdd.Get(&aafr, &aafb, &aafg);
+  backgroundAdd.Get(&aabr, &aabb, &aabg);
+  deltaIn.foregroundMult.Get(&bmfr, &bmfb, &bmfg);
+  deltaIn.backgroundMult.Get(&bmbr, &bmbb, &bmbg);
+  deltaIn.foregroundAdd.Get(&bafr, &bafb, &bafg);
+  deltaIn.backgroundAdd.Get(&babr, &babb, &babg);
+
+  return (((!face && !deltaIn.face && family == deltaIn.family)
+	   || (face && deltaIn.face && !strcmp(face, deltaIn.face)))
+	  && sizeMult == deltaIn.sizeMult
+	  && sizeAdd == deltaIn.sizeAdd
+	  && weightOn == deltaIn.weightOn
+	  && weightOff == deltaIn.weightOff
+	  && styleOn == deltaIn.styleOn
+	  && styleOff == deltaIn.styleOff
+	  && underlinedOn == deltaIn.underlinedOn
+	  && underlinedOff == deltaIn.underlinedOff
+	  && transparentTextBackingOn == deltaIn.transparentTextBackingOn
+	  && transparentTextBackingOff == deltaIn.transparentTextBackingOff
+	  && amfr == bmfr && amfb == bmfb && amfg == bmfg
+	  && aafr == bafr && aafb == bafb && aafg == bafg
+	  && ambr == bmbr && ambb == bmbb && ambg == bmbg
+	  && aabr == babr && aabb == babb && aabg == babg
+	  && alignmentOn == deltaIn.alignmentOn
+	  && alignmentOff == deltaIn.alignmentOff);
+}
+
+void wxStyleDelta::Copy(wxStyleDelta *in)
+{
+#define DCOPY(x) x = in->x
+  DCOPY(family);
+  DCOPY(face);
+  DCOPY(sizeMult);
+  DCOPY(sizeAdd);
+  DCOPY(weightOn);
+  DCOPY(weightOff);
+  DCOPY(styleOn);
+  DCOPY(styleOff);
+  DCOPY(underlinedOn);
+  DCOPY(underlinedOff);
+  DCOPY(transparentTextBackingOn);
+  DCOPY(transparentTextBackingOff);
+  DCOPY(foregroundMult.r);
+  DCOPY(foregroundMult.g);
+  DCOPY(foregroundMult.b);
+  DCOPY(foregroundAdd.r);
+  DCOPY(foregroundAdd.g);
+  DCOPY(foregroundAdd.b);
+  DCOPY(backgroundMult.r);
+  DCOPY(backgroundMult.g);
+  DCOPY(backgroundMult.b);
+  DCOPY(backgroundAdd.r);
+  DCOPY(backgroundAdd.g);
+  DCOPY(backgroundAdd.b);
+  DCOPY(alignmentOn);
+  DCOPY(alignmentOff);
+}
+
+/***************************************************************/
+
+static unsigned char ColourNum(float v)
+{
+  if (v < 0)
+    return 0;
+  else if (v > 255)
+    return 255;
+  else
+    return (unsigned char)v;
+}
+
+wxStyle::wxStyle()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_STYLE;
+#endif
+
+  textMetricDC = NULL;
+
+  WXGC_IGNORE(styleList);
+  WXGC_IGNORE(baseStyle);
+  WXGC_IGNORE(textMetricDC);
+
+  joinStyle = FALSE;
+}
+
+wxStyle::~wxStyle()
+{
+  if (!joinStyle)
+    delete u.delta;
+}
+
+void wxStyle::Update(wxStyle *basic, wxStyle *target, 
+		     Bool propogate, Bool topLevel)
+{
+  int size;
+  int fontid;
+  int style, weight;
+  unsigned char r, g, b;
+  float rm, gm, bm;
+  short rp, gp, bp; 
+  Bool match;
+  wxNode *node;
+  Bool underlined;
+  wxStyle *base;
+
+  base = baseStyle;
+  if (basic) {
+    if (PTREQ(base, styleList->BasicStyle())) {
+      base = basic;
+    } else {
+      base->Update(basic, target, FALSE, FALSE);
+      base = target;
+    }
+  }
+
+  if (!target)
+    target = this;
+
+  if (joinStyle) {
+    if (!PTREQ(u.shiftStyle, styleList->BasicStyle()))
+      u.shiftStyle->Update(base, target, FALSE, topLevel);
+    return;
+  }
+
+  size = (int)(u.delta->sizeMult * base->font->GetPointSize());
+  size += u.delta->sizeAdd;
+  if (size <= 0)
+    size = 1;
+
+  if (!u.delta->face && u.delta->family == wxBASE) {
+#ifndef NO_GENERAL_FONTS
+    fontid = base->font->GetFontId();
+#else
+    fontid = base->font->GetFamily();
+#endif
+  }
+#ifndef NO_GENERAL_FONTS
+  else if (u.delta->face)
+    fontid = FONT_DIRECTORY.FindOrCreateFontId(u.delta->face, 
+					       u.delta->family);
+#endif
+  else
+    fontid = u.delta->family;
+
+  style = base->font->GetStyle();
+  match = (style == u.delta->styleOff);
+  if (match)
+    style = wxNORMAL;
+  if (!match || (match && u.delta->styleOn != u.delta->styleOff))
+    if (u.delta->styleOn != wxBASE)
+      style = u.delta->styleOn;
+
+  weight = base->font->GetWeight();
+  match = (weight == u.delta->weightOff);
+  if (match)
+    weight = wxNORMAL;
+  if (!match || (match && u.delta->weightOn != u.delta->weightOff))
+    if (u.delta->weightOn != wxBASE)
+      weight = u.delta->weightOn;
+
+  target->alignment = base->alignment;
+  match = (target->alignment == u.delta->alignmentOff);
+  if (match)
+    target->alignment = wxALIGN_BOTTOM;
+  if (!match || (match && u.delta->alignmentOn != u.delta->alignmentOff))
+    if (u.delta->alignmentOn != wxBASE)
+      target->alignment = u.delta->alignmentOn;
+
+  if (u.delta->underlinedOff && u.delta->underlinedOn)
+    underlined = !base->font->GetUnderlined();
+  else if (u.delta->underlinedOff)
+    underlined = FALSE;
+  else if (u.delta->underlinedOn)
+    underlined = TRUE;
+  else
+    underlined = base->font->GetUnderlined();
+  
+  target->font = wxTheFontList->FindOrCreateFont(size, fontid,
+						 style, weight, underlined);
+
+  target->textMetricDC = NULL;
+
+  if (u.delta->transparentTextBackingOff && u.delta->transparentTextBackingOn)
+    transText = !base->transText;
+  else if (u.delta->transparentTextBackingOff)
+    transText = FALSE;
+  else if (u.delta->transparentTextBackingOn)
+    transText = TRUE;
+  else
+    transText = base->transText;
+  
+  base->foreground.Get(&r, &g, &b);
+  u.delta->foregroundMult.Get(&rm, &gm, &bm);
+  u.delta->foregroundAdd.Get(&rp, &gp, &bp);
+  r = ColourNum(r * rm + rp);
+  g = ColourNum(g * gm + gp);
+  b = ColourNum(b * bm + bp);
+  target->foreground.Set(r, g, b);
+
+  base->background.Get(&r, &g, &b);
+  u.delta->backgroundMult.Get(&rm, &gm, &bm);
+  u.delta->backgroundAdd.Get(&rp, &gp, &bp);
+  r = ColourNum(r * rm + rp);
+  g = ColourNum(g * gm + gp);
+  b = ColourNum(b * bm + bp);
+  target->background.Set(r, g, b);
+
+  target->pen = wxThePenList->FindOrCreatePen(&foreground, 0, wxSOLID);
+  target->brush = wxTheBrushList->FindOrCreateBrush(&background, wxSOLID);
+
+  if (propogate)
+    for (node = children.First(); node; node = node->Next())
+      ((wxStyle *)node->Data())->Update(NULL, NULL, TRUE, FALSE);
+
+  styleList->StyleWasChanged(target);
+  if (topLevel)
+    styleList->StyleWasChanged(NULL);
+}
+
+char *wxStyle::GetName()
+{
+  return name;
+}
+
+int wxStyle::GetFamily()
+{
+  return font->GetFamily();
+}
+
+char *wxStyle::GetFace()
+{
+#ifndef NO_GENERAL_FONTS
+#ifndef WXME_FOR_MRED
+  return font->GetFaceName();
+#else
+  return font->GetFaceString();
+#endif
+#else
+  return font->GetFamilyString();
+#endif
+}
+
+wxFont *wxStyle::GetFont()
+{
+  return font;
+}
+
+int wxStyle::GetSize()
+{
+  return font->GetPointSize();
+}
+
+int wxStyle::GetWeight()
+{
+  return font->GetWeight();
+}
+
+int wxStyle::GetStyle()
+{
+  return font->GetStyle();
+}
+
+Bool wxStyle::GetUnderlined()
+{
+  return font->GetUnderlined();
+}
+
+Bool wxStyle::GetTransparentTextBacking()
+{
+  return transText;
+}
+
+wxColour &wxStyle::GetForeground()
+{
+  return foreground;
+}
+
+wxColour &wxStyle::GetBackground()
+{
+  return background;
+}
+
+int wxStyle::GetAlignment()
+{
+  return alignment;
+}
+
+Bool wxStyle::IsJoin()
+{
+  return joinStyle;
+}
+
+void wxStyle::GetDelta(wxStyleDelta &d)
+{
+  if (joinStyle)
+    d.SetDelta(wxCHANGE_NOTHING);
+  else
+    d.Copy(u.delta);
+}
+
+void wxStyle::SetDelta(wxStyleDelta &d)
+{
+  if (joinStyle || PTREQ(this, styleList->BasicStyle()))
+    return;
+
+  u.delta->Copy(&d);
+  Update();
+}
+
+wxStyle *wxStyle::GetShiftStyle()
+{
+  if (joinStyle)
+    return u.shiftStyle;
+  else
+    return styleList->BasicStyle();
+}
+
+void wxStyle::SetShiftStyle(wxStyle *style)
+{
+  if (!joinStyle || (styleList->StyleToIndex(style) < 0))
+    return;
+
+  if (styleList->CheckForLoop(this, style))
+    return;
+
+  if (u.shiftStyle)
+    u.shiftStyle->children.DeleteObject(this);
+  style->children.Append(this);
+
+  u.shiftStyle = style;
+  styleList->StyleHasNewChild(style, this);
+
+  Update();
+
+  u.shiftStyle = style;
+  Update();
+}
+
+wxStyle *wxStyle::GetBaseStyle(void)
+{
+  return baseStyle;
+}
+
+void wxStyle::SetBaseStyle(wxStyle *style)
+{
+  if (PTREQ(this, styleList->BasicStyle()))
+    return;
+
+  if (!style)
+    style = styleList->BasicStyle();
+  else
+    if (styleList->StyleToIndex(style) < 0)
+      return;
+
+  if (styleList->CheckForLoop(this, style))
+    return;
+
+  if (baseStyle)
+    baseStyle->children.DeleteObject(this);
+
+  baseStyle = style;
+  style->children.Append(this);
+
+  styleList->StyleHasNewChild(style, this);
+
+  Update();
+}
+
+void wxStyle::SwitchTo(wxDC *dc, wxStyle *oldStyle)
+{
+  unsigned char afr, afg, afb, bfr, bfg, bfb;
+  unsigned char abr, abg, abb, bbr, bbg, bbb;
+
+  if (oldStyle) {
+    oldStyle->foreground.Get(&afr, &afg, &afb);
+    foreground.Get(&bfr, &bfg, &bfb);
+    oldStyle->background.Get(&abr, &abg, &abb);
+    background.Get(&bbr, &bbg, &bbb);
+  }
+
+  if (!oldStyle || oldStyle->font != font)
+    dc->SetFont(font);
+  if (!oldStyle || afr != bfr || afb != bfb || afg != bfg)
+    dc->SetTextForeground(&foreground);
+  if (!oldStyle || abr != bbr || abb != bbb || abg != bbg)
+    dc->SetTextBackground(&background);
+  if (!oldStyle || oldStyle->pen != pen)
+    dc->SetPen(pen);
+  if (!oldStyle || oldStyle->transText != transText)
+    dc->SetBackgroundMode(transText ? wxTRANSPARENT : wxSOLID);
+}
+
+void wxStyle::ResetTextMetrics(wxDC *dc)
+{
+  textMetricDC = dc;
+#ifdef BROKEN_GET_TEXT_EXTENT 
+  dc->SetFont(style->GetFont());
+#endif
+  dc->GetTextExtent(" ", &textWidth, &textHeight, &textDescent, &textSpace, font);
+}
+
+float wxStyle::GetTextWidth(wxDC *dc)
+{
+  if (dc != textMetricDC)
+    ResetTextMetrics(dc);
+
+  return textWidth;
+}
+
+float wxStyle::GetTextHeight(wxDC *dc)
+{
+  if (dc != textMetricDC)
+    ResetTextMetrics(dc);
+
+  return textHeight;
+}
+
+float wxStyle::GetTextDescent(wxDC *dc)
+{
+  if (dc != textMetricDC)
+    ResetTextMetrics(dc);
+
+  return textDescent;
+}
+
+float wxStyle::GetTextSpace(wxDC *dc)
+{
+  if (dc != textMetricDC)
+    ResetTextMetrics(dc);
+
+  return textSpace;
+}
+
+/***************************************************************/
+
+class NotificationRec {
+ public:
+  wxStyleNotifyFunc f;
+  void *data;
+  long id;
+};
+
+static long nextNotifyId = 0;
+
+wxStyleList::wxStyleList() : wxList()
+{
+#if USE_OLD_TYPE_SYSTEM
+  __type = wxTYPE_STYLE_LIST;
+#endif
+
+  usage = 0;
+  Clear();
+}
+
+void wxStyleList::Clear(void)
+{
+  wxNode *node;
+  wxStyle *style;
+
+  while ((node = First())) {
+    style = (wxStyle *)node->Data();
+    delete style;
+    DeleteNode(node);
+  }
+
+  basic = new wxStyle;
+
+  basic->styleList = this;
+
+  basic->name = "Basic";
+  basic->baseStyle = NULL;
+
+  basic->u.delta = new wxStyleDelta;
+  basic->u.delta->SetDelta(wxCHANGE_NORMAL);
+
+  basic->font = wxTheFontList->FindOrCreateFont(defaultSize, wxDEFAULT,
+						wxNORMAL, wxNORMAL);
+  basic->foreground = *blackColour;
+  basic->background = *whiteColour;
+  basic->pen = wxThePenList->FindOrCreatePen(&basic->foreground, 0, wxSOLID);
+  basic->brush = wxTheBrushList->FindOrCreateBrush(&basic->background, wxSOLID);
+  basic->alignment = wxALIGN_BOTTOM;
+  basic->transText = TRUE;
+
+  Append(basic);
+
+  notifications = new wxList();
+
+  listId = 0;
+  styleMap = NULL;
+}
+
+void wxStyleList::Copy(wxStyleList *other)
+{
+  wxNode *node;
+
+  Clear();
+
+  for (node = other->First(); node; node = node->Next()) {
+    wxStyle *s = (wxStyle *)node->Data();
+    Convert(s);
+  }
+}
+
+wxStyleList::~wxStyleList()
+{
+  DeleteContents(TRUE);
+}
+
+wxStyle *wxStyleList::BasicStyle(void)
+{
+  return basic;
+}
+
+wxStyle *wxStyleList::FindOrCreateStyle(wxStyle *baseStyle, 
+					wxStyleDelta *deltain)
+{
+  wxNode *node;
+  wxStyle *style;
+  wxStyleDelta delta;
+
+  if (!baseStyle || (StyleToIndex(baseStyle) < 0))
+    baseStyle = basic;
+
+  /* Collapse the delta: */
+  delta.Copy(deltain);
+  while (!baseStyle->name && !baseStyle->joinStyle) {
+    if (!delta.Collapse(*baseStyle->u.delta))
+      break;
+    baseStyle = baseStyle->baseStyle;
+  }
+
+  for (node = First(); node; node = node->Next()) {
+    style = (wxStyle *)node->Data();
+    if (!style->name
+	&& !style->joinStyle
+	&& PTREQ(style->baseStyle, baseStyle)
+	&& delta.Equal(*style->u.delta))
+      return style;
+  }
+
+  style = new wxStyle;
+
+  style->styleList = this;
+
+  style->name = NULL;
+
+  style->u.delta = new wxStyleDelta;
+  style->u.delta->Copy(&delta);
+
+  style->baseStyle = baseStyle;
+  baseStyle->children.Append(style);
+
+  style->Update();
+
+  Append(style);
+
+  return style;
+}
+
+wxStyle *wxStyleList::FindOrCreateJoinStyle(wxStyle *baseStyle, 
+					    wxStyle *shiftStyle)
+{
+  wxNode *node;
+  wxStyle *style;
+
+  if (!baseStyle || (StyleToIndex(baseStyle) < 0))
+    baseStyle = basic;
+  if (!shiftStyle || (StyleToIndex(shiftStyle) < 0))
+    return baseStyle;
+
+  for (node = First(); node; node = node->Next()) {
+    style = (wxStyle *)node->Data();
+    if (!style->name
+	&& style->joinStyle
+	&& PTREQ(style->baseStyle, baseStyle)
+	&& PTREQ(style->u.shiftStyle, shiftStyle))
+      return style;
+  }
+
+  style = new wxStyle;
+
+  style->styleList = this;
+
+  style->name = NULL;
+
+  style->joinStyle = TRUE;
+
+  WXGC_IGNORE(style->u.shiftStyle);
+  style->u.shiftStyle = shiftStyle;
+  shiftStyle->children.Append(style);
+
+  style->baseStyle = baseStyle;
+  baseStyle->children.Append(style);
+
+  style->Update();
+
+  Append(style);
+
+  return style;
+}
+
+wxStyle *wxStyleList::FindNamedStyle(char *name)
+{
+  wxNode *node;
+  wxStyle *style;
+
+  for (node = First(); node; node = node->Next()) {
+    style = (wxStyle *)node->Data();
+    if (style->name && !strcmp(name, style->name))
+      return style;
+  }
+
+  return NULL;
+}
+
+wxStyle *wxStyleList::DoNamedStyle(char *name, wxStyle *plainStyle, Bool replac)
+{
+  wxNode *node;
+  wxStyle *style;
+
+  if (!plainStyle || (StyleToIndex(plainStyle) < 0))
+    plainStyle = basic;
+
+  style = NULL;
+  for (node = First(); node; node = node->Next()) {
+    style = (wxStyle *)node->Data();
+    if (style->name && !strcmp(name, style->name)) {
+      if (!replac)
+	return style;
+      break;
+    }
+  }
+
+  if (!node) {
+    style = new wxStyle;
+    style->name = copystring(name);
+    style->styleList = this;
+  } else {
+    /* Can't replace basic style: */
+    if (style == basic)
+      return basic;
+
+    style->baseStyle->children.DeleteObject(style);
+    if (style->joinStyle)
+      style->u.shiftStyle->children.DeleteObject(style);
+  }
+
+  if (plainStyle->joinStyle) {
+    style->joinStyle = TRUE;
+    style->u.shiftStyle = plainStyle->u.shiftStyle;
+    style->u.shiftStyle->children.Append(style);
+  } else {
+    style->u.delta = new wxStyleDelta;
+    if (PTRNE(plainStyle, basic))
+      style->u.delta->Copy(plainStyle->u.delta);
+  }
+
+  if (PTREQ(plainStyle, basic))
+    style->baseStyle = basic;
+  else
+    style->baseStyle = plainStyle->baseStyle;
+  style->baseStyle->children.Append(style);
+
+  style->Update();
+
+  Append(style);
+
+  return style;
+}
+
+wxStyle *wxStyleList::NewNamedStyle(char *name, wxStyle *plainStyle)
+{
+  return DoNamedStyle(name, plainStyle, FALSE);
+}
+
+wxStyle *wxStyleList::ReplaceNamedStyle(char *name, wxStyle *plainStyle)
+{
+  return DoNamedStyle(name, plainStyle, TRUE);
+}
+
+wxStyle *wxStyleList::Convert(wxStyle *style)
+{
+  wxStyle *base, *newstyle;
+
+  if (StyleToIndex(style) >= 0)
+    return style;
+
+  if (style->name) {
+    newstyle = FindNamedStyle(style->name);
+    if (newstyle)
+      return newstyle;
+  }
+
+  if (!style->baseStyle)
+    base = BasicStyle();
+  else
+    base = Convert(style->baseStyle);
+
+  if (style->joinStyle) {
+    wxStyle *shift;
+
+    shift = Convert(style->u.shiftStyle);
+    newstyle = FindOrCreateJoinStyle(base, shift);
+  } else
+    newstyle = FindOrCreateStyle(base, style->u.delta);
+
+  if (style->name)
+    return NewNamedStyle(style->name, newstyle);
+  else
+    return newstyle;
+}
+
+void wxStyleList::StyleWasChanged(wxStyle *which)
+{
+  NotificationRec *rec;
+  wxNode *node;
+
+  for (node = notifications->First(); node; node = node->Next()) {
+    rec = (NotificationRec *)node->Data();
+    rec->f(which, rec->data);
+  }
+}
+
+long wxStyleList::NotifyOnChange(wxStyleNotifyFunc f, void *data)
+{
+  NotificationRec *rec = new WXGC_ATOMIC NotificationRec;
+
+  rec->f = f;
+  rec->data = data;
+  WXGC_IGNORE(rec->data);
+  rec->id = nextNotifyId++;
+  notifications->Append((wxObject *)rec);
+
+  return rec->id;
+}
+
+void wxStyleList::ForgetNotification(long id)
+{
+  NotificationRec *rec;
+  wxNode *node;
+  
+  for (node = notifications->First(); node; node = node->Next()) {
+    rec = (NotificationRec *)node->Data();
+    if (rec->id == id) {
+      notifications->DeleteNode(node);
+      delete rec;
+      return;
+    }
+  }
+}
+
+Bool wxStyleList::CheckForLoop(wxStyle *s, wxStyle *p)
+{
+  if (PTREQ(p, s))
+    return TRUE;
+
+  if (!p->baseStyle)
+    return FALSE;
+
+  if (p->joinStyle) {
+    if (CheckForLoop(s, p->baseStyle))
+      return TRUE;
+    return CheckForLoop(s, p->u.shiftStyle);
+  } else
+    return CheckForLoop(s, p->baseStyle);
+}
+
+void wxStyleList::StyleHasNewChild(wxStyle *s, wxStyle *c)
+{
+  wxNode *cnode, *snode, *node;
+
+  /* Need to maintain the invariant that parents are in the list
+     before children... */
+  cnode = Member(c);
+  snode = Member(s);
+  
+  for (node = cnode; node; node = node->Next()) {
+    if (PTREQ(node, snode)) {
+      /* Move base style to before this style */
+      DeleteNode(snode);
+      Insert(cnode, s);
+      break;
+    }
+  }
+}
+
+int wxStyleList::Number(void)
+{
+  return wxList::Number();
+}
+
+wxStyle *wxStyleList::IndexToStyle(int i)
+{
+  wxNode *node;
+
+  for (node = First(); i && node; i--, node = node->Next());
+
+  if (node)
+    return (wxStyle *)node->Data();
+  else
+    return NULL;
+}
+ 
+int wxStyleList::StyleToIndex(wxStyle *s)
+{
+  wxNode *node;
+  int i = 0;
+
+  for (node = First(); 
+       node && PTRNE((wxStyle *)node->Data(), s); 
+       i++, node = node->Next());
+
+  if (node)
+    return i;
+  else
+    return -1;
+}
+
+void wxStyleList::AdjustUsage(Bool newUser)
+{
+  if (newUser)
+    usage++;
+  else
+    --usage;
+}
+
+Bool wxStyleList::IsUsed(void)
+{
+  return !!usage;
+}
+
+Bool wxStyleList::WriteToFile(class wxMediaStreamOut &f)
+{
+  return wxmbWriteStylesToFile(this, f);
+}
+
+wxStyle *wxStyleList::MapIndexToStyle(int i)
+{
+  if (styleMap && i < numMappedStyles)
+    return styleMap[i];
+  else
+    return basic;
+}
+
+wxStyleList *wxReadStyleList(class wxMediaStreamIn &f)
+{
+  wxStyleList *l = new wxStyleList;
+
+  return wxmbReadStylesFromFile(l, f, 0);
+}
+
+static wxList *readStyles = NULL;
+
+void wxmbSetupStyleReadsWrites(void)
+{
+  readStyles = new wxList(wxKEY_INTEGER);
+}
+
+void wxmbDoneStyleReadsWrites(void)
+{
+  wxNode *node;
+  wxStyleList *l;
+
+  for (node = readStyles->First(); node; node = node->Next()) { 
+    l = (wxStyleList *)node->Data();
+    if (l->styleMap) {
+      delete[] l->styleMap;
+      l->styleMap = NULL;
+    }
+    l->listId = 0;
+  }
+
+  delete readStyles;
+  readStyles = NULL;
+}
+
+static int FamilyStandardToThis(int v)
+{
+  switch (v) {
+  case 71:
+    return wxDECORATIVE;
+  case 72:
+    return wxROMAN;
+  case 73:
+    return wxSCRIPT;
+  case 74:
+    return wxSWISS;
+  case 75:
+    return wxMODERN;
+  case 76:
+    return wxTELETYPE;
+  case 70:
+  default:
+    return wxDEFAULT;
+  }
+}
+
+static int FamilyThisToStandard(int v)
+{
+  switch (v) {
+  case wxDECORATIVE:
+    return 71;
+  case wxROMAN:
+    return 72;
+  case wxSCRIPT:
+    return 73;
+  case wxSWISS:
+    return 74;
+  case wxMODERN:
+    return 75;
+  case wxTELETYPE:
+    return 76;
+  case wxDEFAULT:
+  default:
+    return 70;
+  }
+}
+
+static int WeightStandardToThis(int v)
+{
+  switch (v) {
+  case 91:
+    return wxLIGHT;
+  case 92:
+    return wxBOLD;
+  case 90:
+  default:
+    return wxNORMAL;
+  }
+}
+
+static int WeightThisToStandard(int v)
+{
+  switch (v) {
+  case wxLIGHT:
+    return 91;
+  case wxBOLD:
+    return 92;
+  case wxNORMAL:
+  default:
+    return 90;
+  }
+}
+
+static int StyleStandardToThis(int v)
+{
+  switch (v) {
+  case 93:
+    return wxITALIC;
+  case 94:
+    return wxSLANT;
+  case 90:
+  default:
+    return wxNORMAL;
+  }
+}
+
+static int StyleThisToStandard(int v)
+{
+  switch (v) {
+  case wxITALIC:
+    return 93;
+  case wxSLANT:
+    return 94;
+  case wxNORMAL:
+  default:
+    return 90;
+  }
+}
+
+wxStyleList *wxmbReadStylesFromFile(wxStyleList *styleList, 
+				    wxMediaStreamIn& f, 
+				    Bool overwritename)
+{
+#define MAX_STYLE_NAME 256
+  int baseIndex, shiftIndex;
+  long nameSize;
+  char name[MAX_STYLE_NAME];
+  char face[MAX_STYLE_NAME];
+  short r, g, b;
+  int i, isJoin, listId;
+  wxStyleDelta delta;
+  wxNode *node;
+
+  f >> listId;
+  
+  if ((node = readStyles->Find(listId)))
+    return (wxStyleList *)node->Data();
+
+  f >> styleList->numMappedStyles;
+  styleList->styleMap = new wxStyle*[styleList->numMappedStyles];
+
+  styleList->styleMap[0] = styleList->BasicStyle();
+  for (i = 1; i < styleList->numMappedStyles; i++) {
+    f >> baseIndex;
+
+    if (baseIndex >= i) {
+      wxMessageBox("Bad style index.", "Error");
+      return FALSE;
+    }
+
+    nameSize = MAX_STYLE_NAME;
+    f.Get((long *)&nameSize, (char *)name);
+
+    f >> isJoin;
+
+    if (isJoin) {
+      f >> shiftIndex;
+
+      styleList->styleMap[i] = 
+	styleList->FindOrCreateJoinStyle(styleList->styleMap[baseIndex], 
+					 styleList->styleMap[shiftIndex]);
+    } else {
+      f >> delta.family;
+      delta.family = FamilyStandardToThis(delta.family);
+
+      nameSize = MAX_STYLE_NAME;
+      f.Get((long *)&nameSize, (char *)face);
+      
+      if (*face)
+	delta.face = copystring(face);
+      else
+	delta.face = NULL;
+
+      // printf("%d %s\n", delta.family, delta.face ? delta.face : "NULL");
+      
+      f >> delta.sizeMult;
+      f >> delta.sizeAdd;
+      f >> delta.weightOn;
+      delta.weightOn = WeightStandardToThis(delta.weightOn);
+      f >> delta.weightOff;
+      delta.weightOff = WeightStandardToThis(delta.weightOff);
+      f >> delta.styleOn;
+      delta.styleOn = StyleStandardToThis(delta.styleOn);
+      f >> delta.styleOff;
+      delta.styleOff = StyleStandardToThis(delta.styleOff);
+      f >> delta.underlinedOn;
+      f >> delta.underlinedOff;
+      if (WXME_VERSION_ONE() || WXME_VERSION_TWO()) {
+	delta.transparentTextBackingOn = FALSE;
+	delta.transparentTextBackingOff = FALSE;
+      } else {
+	f >> delta.transparentTextBackingOn;
+	f >> delta.transparentTextBackingOff;
+      }
+      
+      f >> delta.foregroundMult.r;
+      f >> delta.foregroundMult.g;
+      f >> delta.foregroundMult.b;
+      f >> delta.backgroundMult.r;
+      f >> delta.backgroundMult.g;
+      f >> delta.backgroundMult.b;
+      f >> r;
+      f >> g;
+      f >> b;
+      delta.foregroundAdd.Set(r, g, b);
+      f >> r;
+      f >> g;
+      f >> b;
+      delta.backgroundAdd.Set(r, g, b);
+      if (WXME_VERSION_ONE() || WXME_VERSION_TWO()) {
+	if (r || g || b)
+	  delta.transparentTextBackingOff = TRUE;
+      }
+
+      f >> delta.alignmentOn;
+      f >> delta.alignmentOff;
+
+      styleList->styleMap[i] = 
+	styleList->FindOrCreateStyle(styleList->styleMap[baseIndex], &delta);
+    }
+
+    if (*name)
+      styleList->styleMap[i] = 
+	(overwritename 
+	 ? styleList->ReplaceNamedStyle(name, styleList->styleMap[i])
+	 : styleList->NewNamedStyle(name, styleList->styleMap[i]));
+  }
+
+  readStyles->Append(listId, styleList);
+
+  return styleList;
+}
+
+Bool wxmbWriteStylesToFile(wxStyleList *styleList, wxMediaStreamOut &f)
+{
+  int i, count;
+  wxStyle *style;
+  short r, g, b;
+  char *name;
+  wxStyleDelta delta;
+
+  if (styleList->listId) {
+    f << styleList->listId;
+    return TRUE;
+  }
+
+  styleList->listId = readStyles->Number() + 1;
+
+  f << styleList->listId;
+
+  count = styleList->Number();
+
+  f << count;
+
+  // Basic style is implied
+
+  for (i = 1; i < count; i++) {
+    style = styleList->IndexToStyle(i);
+
+    f << styleList->StyleToIndex(style->GetBaseStyle());
+    if ((name = style->GetName()))
+      f << name;
+    else
+      f << "";
+
+    if (style->IsJoin()) {
+      f << 1;
+
+      f << styleList->StyleToIndex(style->GetShiftStyle());
+    } else {
+      style->GetDelta(delta);
+      
+      f << 0;
+
+      f << FamilyThisToStandard(delta.family);
+      if (delta.face)
+	f << delta.face;
+      else
+	f << "";
+
+      f << delta.sizeMult;
+      f << delta.sizeAdd;
+      f << WeightThisToStandard(delta.weightOn); 
+      f << WeightThisToStandard(delta.weightOff);
+      f << StyleThisToStandard(delta.styleOn);
+      f << StyleThisToStandard(delta.styleOff);
+      f << delta.underlinedOn;
+      f << delta.underlinedOff;
+      f << delta.transparentTextBackingOn;
+      f << delta.transparentTextBackingOff;
+
+      f << delta.foregroundMult.r;
+      f << delta.foregroundMult.g;
+      f << delta.foregroundMult.b;
+      f << delta.backgroundMult.r;
+      f << delta.backgroundMult.g;
+      f << delta.backgroundMult.b;
+      delta.foregroundAdd.Get(&r, &g, &b);
+      f << r;
+      f << g;
+      f << b;
+      delta.backgroundAdd.Get(&r, &g, &b);
+      f << r;
+      f << g;
+      f << b;
+
+      f << delta.alignmentOn;
+      f << delta.alignmentOff;
+    }
+  }
+
+  readStyles->Append(styleList->listId, styleList);
+
+  return TRUE;
+}
diff --git a/src/mred/wxme/wx_style.h b/src/mred/wxme/wx_style.h
new file mode 100644
index 0000000..2517622
--- /dev/null
+++ b/src/mred/wxme/wx_style.h
@@ -0,0 +1,242 @@
+
+#ifndef __WXME_STYLE__
+#define __WXME_STYLE__
+
+#include "wx_list.h"
+#include "wx_gdi.h"
+#include "wx_dc.h"
+#include "wx_utils.h"
+
+#ifndef WXGC_NO_CLEANUP
+#define WXGC_NO_CLEANUP /* empty */
+#endif
+
+#define wxBASE (-1)
+
+#ifndef wxALIGN_TOP
+enum {
+  wxALIGN_TOP,
+  wxALIGN_BOTTOM
+#ifndef wxALIGN_CENTER
+  , wxALIGN_CENTER
+#endif
+};
+#endif
+
+/* Simple style change commands */
+enum {
+  wxCHANGE_NOTHING,
+
+  wxCHANGE_STYLE,
+  wxCHANGE_WEIGHT,
+  wxCHANGE_UNDERLINE,
+  wxCHANGE_SIZE,
+  wxCHANGE_FAMILY,
+  wxCHANGE_ALIGNMENT,
+
+  wxCHANGE_BOLD,
+  wxCHANGE_ITALIC,
+
+  wxCHANGE_TOGGLE_STYLE,
+  wxCHANGE_TOGGLE_WEIGHT,
+  wxCHANGE_TOGGLE_UNDERLINE,
+
+  wxCHANGE_BIGGER,
+  wxCHANGE_SMALLER,
+
+  wxCHANGE_NORMAL,
+
+  wxCHANGE_NORMAL_COLOUR
+};
+
+class wxMultColour : public wxObject
+{
+ public:
+  float r, g, b;
+  void Get(float *r, float *g, float *b);
+  void Set(float r, float g, float b);
+};
+
+class wxAddColour : public wxObject
+{
+ public:
+  short r, g, b;
+  void Get(short *r, short *g, short *b);
+  void Set(short r, short g, short b);
+};
+
+class wxStyleDelta : public wxObject
+{
+ public:
+  int family;
+  char *face;
+  float sizeMult;
+  int sizeAdd;
+  int weightOn; /* On == Off => Toggle */ 
+  int weightOff; /* On & Off, but On != Off => Converting toggle */
+  int styleOn;
+  int styleOff;
+  Bool underlinedOn;
+  Bool underlinedOff;
+  Bool transparentTextBackingOn;
+  Bool transparentTextBackingOff;
+  wxMultColour foregroundMult, backgroundMult;
+  wxAddColour foregroundAdd, backgroundAdd;
+  int alignmentOn;
+  int alignmentOff;
+  
+  wxStyleDelta(int changeCommand = wxCHANGE_NOTHING, int param = 0);
+  ~wxStyleDelta();
+
+  wxStyleDelta *SetDelta(int changeCommand, int param = 0);
+  wxStyleDelta *SetDeltaFace(char *name);
+  wxStyleDelta *SetDeltaBackground(char *name);
+  wxStyleDelta *SetDeltaBackground(wxColour& colour);
+  wxStyleDelta *SetDeltaForeground(char *name);
+  wxStyleDelta *SetDeltaForeground(wxColour& colour);
+
+  Bool Collapse(wxStyleDelta &delta);
+
+  Bool Equal(wxStyleDelta &delta);
+
+  void Copy(wxStyleDelta *delta);
+};
+
+class wxStyle : public wxObject
+{
+  friend class wxStyleList;
+
+ private:
+  class wxStyleList *styleList; /* Points back to the list owning the style */
+
+  char *name;
+
+  wxStyle *baseStyle;
+
+  Bool joinStyle;
+  union {
+    wxStyle *shiftStyle;
+    wxStyleDelta *delta;
+  } u;
+
+  /* cache computation: */
+  Bool transText;
+  wxColour foreground, background;
+  wxFont *font;
+  wxPen *pen;
+  wxBrush *brush;
+  int alignment;
+
+  wxDC *textMetricDC;
+  float textWidth, textHeight, textDescent, textSpace;
+
+  wxList children;
+
+  void Update(wxStyle *basic = NULL, wxStyle *target = NULL, 
+	      Bool propogate = TRUE, Bool topLevel = TRUE);
+
+  void ResetTextMetrics(wxDC *dc);
+
+ public:
+  wxStyle();
+  ~wxStyle();
+
+  char *GetName();
+  int GetFamily();
+  char *GetFace();
+  int GetSize();
+  int GetWeight();
+  int GetStyle();
+  Bool GetUnderlined();
+  wxFont *GetFont();
+  wxColour &GetForeground();
+  wxColour &GetBackground();
+  int GetAlignment();
+  Bool GetTransparentTextBacking();
+
+  wxStyle *GetBaseStyle(void);
+  void SetBaseStyle(wxStyle *baseStyle);
+
+  Bool IsJoin(void);
+
+  void GetDelta(wxStyleDelta &delta);
+  void SetDelta(wxStyleDelta &delta);
+
+  wxStyle *GetShiftStyle();
+  void SetShiftStyle(wxStyle *);
+
+  void SwitchTo(wxDC *dc, wxStyle *oldStyle);
+
+  float GetTextWidth(wxDC *dc);
+  float GetTextHeight(wxDC *dc);
+  float GetTextDescent(wxDC *dc);
+  float GetTextSpace(wxDC *dc);
+};
+
+typedef void (*wxStyleNotifyFunc)(wxStyle *which, void *data);
+
+class wxStyleList : public wxList /* should be private */
+{
+  wxStyle *basic;
+  wxList *notifications;
+
+  int usage;
+
+  wxStyle *DoNamedStyle(char *name, wxStyle *plainStyle, Bool replace);
+
+ public:
+  wxStyle **styleMap; /* internal use only */
+  int numMappedStyles; /* internal use only */
+  int listId; /* internal use only */
+
+  wxStyleList();
+  ~wxStyleList();
+
+  void Clear();
+  void Copy(wxStyleList *other);
+
+  wxStyle *BasicStyle(void);
+
+  int Number(void);
+
+  /* Called automatically by style: */
+  void StyleWasChanged(wxStyle *which);
+  void StyleHasNewChild(wxStyle *s, wxStyle *c);
+  Bool CheckForLoop(wxStyle *s, wxStyle *p);
+
+  wxStyle *FindOrCreateStyle(wxStyle *baseStyle, wxStyleDelta *delta);
+
+  wxStyle *FindOrCreateJoinStyle(wxStyle *baseStyle, wxStyle *shiftStyle);
+
+  wxStyle *FindNamedStyle(char *name);
+  wxStyle *NewNamedStyle(char *name, wxStyle *plainStyle);
+  wxStyle *ReplaceNamedStyle(char *name, wxStyle *plainStyle);
+
+  wxStyle *Convert(wxStyle *);
+
+  long NotifyOnChange(wxStyleNotifyFunc f, void *data);
+  void ForgetNotification(long id);
+
+  wxStyle *IndexToStyle(int i);
+  int StyleToIndex(wxStyle *);
+
+  void AdjustUsage(Bool newUser);
+  Bool IsUsed(void);
+
+  Bool WriteToFile(class wxMediaStreamOut &f);
+  wxStyle *MapIndexToStyle(int i);
+};
+
+extern wxStyleList *wxTheStyleList;
+
+void wxInitStyles(void);
+
+wxStyleList *wxReadStyleList(class wxMediaStreamIn &f);
+
+/* Internal use only */
+Bool wxmbWriteStylesToFile(wxStyleList *styleList, class wxMediaStreamOut &f);
+wxStyleList *wxmbReadStylesFromFile(wxStyleList *, class wxMediaStreamIn &f, Bool overwritename);
+void wxmbSetupStyleReadsWrites(void);
+void wxmbDoneStyleReadsWrites(void);
+
+#endif
diff --git a/src/mred/wxs/Makefile b/src/mred/wxs/Makefile
new file mode 100644
index 0000000..a461ba3
--- /dev/null
+++ b/src/mred/wxs/Makefile
@@ -0,0 +1,226 @@
+
+include $(WXDIR)/src/make$(MZPLATFORMSUFFIX).env
+
+LOCALFLAGS = 
+
+WXSCFLAGS = $(XINCLUDE) $(INC) $(OPTIONS) $(GUI) $(WARN) $(OPT) $(DEBUGFLAGS)
+
+WXSCHEMEHEADERS = wxscheme.h ../../mzscheme/src/stypes.h
+MEDIAHEADERS = ../wxme/wx_media.h ../wxme/wx_medad.h ../wxme/wx_snip.h
+
+OBJDIR=objects/sys$(MZPLATFORMSUFFIX)$(GUISUFFIX)
+
+OBJECTS = $(OBJDIR)/xcglue.o $(OBJDIR)/wxscomon.o $(OBJDIR)/wxs_bmap.o $(OBJDIR)/wxs_butn.o $(OBJDIR)/wxs_chce.o $(OBJDIR)/wxs_ckbx.o $(OBJDIR)/wxs_cnvs.o $(OBJDIR)/wxs_cstr.o $(OBJDIR)/wxs_dc.o $(OBJDIR)/wxs_evnt.o $(OBJDIR)/wxs_fram.o $(OBJDIR)/wxs_gage.o $(OBJDIR)/wxs_gdi.o $(OBJDIR)/wxs_glob.o $(OBJDIR)/wxs_help.o $(OBJDIR)/wxs_ipc.o $(OBJDIR)/wxs_item.o $(OBJDIR)/wxs_lbox.o $(OBJDIR)/wxs_list.o $(OBJDIR)/wxs_madm.o $(OBJDIR)/wxs_mede.o $(OBJDIR)/wxs_medi.o $(OBJDIR)/wxs_menu.o $(OBJDIR)/wxs_mio.o $(OBJDIR)/wxs_misc.o $(OBJDIR)/wxs_mpb.o $(OBJDIR)/wxs_obj.o $(OBJDIR)/wxs_panl.o $(OBJDIR)/wxs_rado.o $(OBJDIR)/wxs_slid.o $(OBJDIR)/wxs_snip.o $(OBJDIR)/wxs_styl.o $(OBJDIR)/wxs_tbar.o $(OBJDIR)/wxs_text.o $(OBJDIR)/wxs_win.o $(OBJDIR)/wxscheme.o
+
+SOURCES = wxscomon.cxx wxs_bmap.cxx wxs_butn.cxx wxs_chce.cxx wxs_ckbx.cxx wxs_cnvs.cxx wxs_cstr.cxx wxs_dc.cxx wxs_evnt.cxx wxs_fram.cxx wxs_gage.cxx wxs_gdi.cxx wxs_glob.cxx wxs_help.cxx wxs_ipc.cxx wxs_item.cxx wxs_lbox.cxx wxs_list.cxx wxs_madm.cxx wxs_mede.cxx wxs_medi.cxx wxs_menu.cxx wxs_mio.cxx wxs_misc.cxx wxs_mpb.cxx wxs_obj.cxx wxs_panl.cxx wxs_rado.cxx wxs_slid.cxx wxs_snip.cxx wxs_styl.cxx wxs_tbar.cxx wxs_text.cxx wxs_win.cxx wxscheme.cxx
+
+SCRIPTS = wxs_bmap.xc wxs_butn.xc wxs_chce.xc wxs_ckbx.xc wxs_cnvs.xc wxs_cstr.xc wxs_dc.xc wxs_evnt.xc wxs_fram.xc wxs_gage.xc wxs_gdi.xc wxs_glob.xc wxs_help.xc wxs_ipc.xc wxs_item.xc wxs_lbox.xc wxs_list.xc wxs_madm.xc wxs_mede.xc wxs_medi.xc wxs_menu.xc wxs_mio.xc wxs_misc.xc wxs_mpb.xc wxs_obj.xc wxs_panl.xc wxs_rado.xc wxs_slid.xc wxs_snip.xc wxs_styl.xc wxs_tbar.xc wxs_text.xc wxs_win.xc
+
+DOCDIR = /home/mflatt/proj/doc/
+
+all: objects $(OBJDIR)
+	$(MAKE) $(OBJDIR)/libwxscheme.a
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+$(OBJDIR)/libwxscheme.a : $(OBJECTS) 
+	$(AR) ruv $(OBJDIR)/libwxscheme.a $(OBJECTS)
+	$(RANLIB) $(OBJDIR)/libwxscheme.a
+
+names:
+	$(MAKE) $(DOCDIR)/names.tex
+
+test-file:
+	$(MAKE) ../tests/tests.ss
+
+../tests/tests.ss: $(SCRIPTS) danger.tst
+	../../mzscheme/utils/xctotest danger.tst *.xc > ../tests/tests.ss
+
+$(DOCDIR)/names.tex: $(SCRIPTS)
+	../../mzscheme/utils/xctotex *.xc > $(DOCDIR)/names.tex
+
+ccsources: $(SOURCES)
+
+
+xdepend:
+	makedepend -- $(CFLAGS) -- $(SOURCES)
+
+depend:
+
+clean:
+	rm -f objects/*/*
+
+exile-common:
+	mkdir $(HIDEDIR)/wxs_objects
+	mv objects $(HIDEDIR)/wxs_objects/
+	rm -f libwxscheme.a
+
+exile:
+	$(MAKE) exile-common
+	rm -f *~ testobj
+
+soft-exile:
+	$(MAKE) exile-common
+
+repatriate:
+	mv $(HIDEDIR)/wxs_objects/objects .
+	rmdir $(HIDEDIR)/wxs_objects
+
+XCTOCXX = ../../mzscheme/utils/xctocc -cxx
+XCDEPEND = ../../mzscheme/utils/xctocc ../../mzscheme/utils/parse.pl wxs.xci common.txt
+
+CB_DEPEND = cb_start.xci cb_end.xci cbgen_s.xci
+LIST_DEPEND = list.xci
+DRAW_DEPEND = wxs_draw.xci wxs_drwf.xci $(LIST_DEPEND)
+ITEM_DEPEND = wxs_item.xci wxs_win.xci
+
+wxscomon.cxx : wxscomon.xc $(XCDEPEND)
+	$(XCTOCXX) wxscomon.xc
+wxs_bmap.cxx : wxs_bmap.xc $(XCDEPEND) $(LIST_DEPEND)
+	$(XCTOCXX) wxs_bmap.xc
+wxs_butn.cxx : wxs_butn.xc  $(XCDEPEND) $(CB_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_butn.xc
+wxs_chce.cxx : wxs_chce.xc  range.xci $(XCDEPEND) $(CB_DEPEND) $(LIST_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_chce.xc
+wxs_ckbx.cxx : wxs_ckbx.xc  $(XCDEPEND) $(CB_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_ckbx.xc
+wxs_cnvs.cxx : wxs_cnvs.xc wxs_win.xci wxs_cnvs.xci $(XCDEPEND) $(DRAW_DEPEND)
+	$(XCTOCXX) wxs_cnvs.xc
+wxs_cstr.cxx : wxs_cstr.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_cstr.xc
+wxs_dc.cxx : wxs_dc.xc  wxs_dorf.xci $(XCDEPEND) $(DRAW_DEPEND)
+	$(XCTOCXX) wxs_dc.xc
+wxs_evnt.cxx : wxs_evnt.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_evnt.xc
+wxs_form.cxx : wxs_form.xc  $(XCDEPEND) $(CB_DEPEND)
+	$(XCTOCXX) wxs_form.xc
+wxs_fram.cxx : wxs_fram.xc wxs_win.xci wxs_fram.xci $(XCDEPEND)
+	$(XCTOCXX) wxs_fram.xc
+wxs_gage.cxx : wxs_gage.xc  $(XCDEPEND) $(CB_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_gage.xc
+wxs_gdi.cxx : wxs_gdi.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_gdi.xc
+wxs_glob.cxx : wxs_glob.xc  $(XCDEPEND) $(LIST_DEPEND)
+	$(XCTOCXX) wxs_glob.xc
+wxs_help.cxx : wxs_help.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_help.xc
+wxs_ipc.cxx : wxs_ipc.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_ipc.xc
+wxs_item.cxx : wxs_item.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_item.xc
+wxs_lbox.cxx : wxs_lbox.xc  range.xci $(XCDEPEND) $(CB_DEPEND) $(LIST_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_lbox.xc
+wxs_list.cxx : wxs_list.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_list.xc
+wxs_madm.cxx : wxs_madm.xc wxs_madm.xci wxs_win.xci $(XCDEPEND)
+	$(XCTOCXX) wxs_madm.xc
+wxs_medi.cxx : wxs_medi.xc wxs_mbuf.xci $(XCDEPEND) $(LIST_DEPEND)
+	$(XCTOCXX) wxs_medi.xc
+wxs_mede.cxx : wxs_mede.xc wxs_mbuf.xci $(XCDEPEND) $(LIST_DEPEND)
+	$(XCTOCXX) wxs_mede.xc
+wxs_menu.cxx : wxs_menu.xc  $(XCDEPEND) $(CB_DEPEND) $(LIST_DEPEND)
+	$(XCTOCXX) wxs_menu.xc
+wxs_mio.cxx : wxs_mio.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_mio.xc
+wxs_misc.cxx : wxs_misc.xc  $(XCDEPEND) $(CB_DEPEND)
+	$(XCTOCXX) wxs_misc.xc
+wxs_mpb.cxx : wxs_mpb.xc  wxs_mbuf.xci $(XCDEPEND)
+	$(XCTOCXX) wxs_mpb.xc
+wxs_obj.cxx : wxs_obj.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_obj.xc
+wxs_panl.cxx : wxs_panl.xc wxs_panl.xci wxs_fram.xci wxs_cnvs.xci wxs_dorf.xci $(XCDEPEND) $(CB_DEPEND)
+	$(XCTOCXX) wxs_panl.xc
+wxs_rado.cxx : wxs_rado.xc  range.xci $(XCDEPEND) $(CB_DEPEND) $(LIST_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_rado.xc
+wxs_slid.cxx : wxs_slid.xc  $(XCDEPEND) $(CB_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_slid.xc
+wxs_snip.cxx : wxs_snip.xc  wxs_snip.xci $(XCDEPEND)
+	$(XCTOCXX) wxs_snip.xc
+wxs_styl.cxx : wxs_styl.xc  $(XCDEPEND)
+	$(XCTOCXX) wxs_styl.xc
+wxs_tbar.cxx : wxs_tbar.xc $(XCDEPEND)
+	$(XCTOCXX) wxs_tbar.xc
+wxs_text.cxx : wxs_text.xc wxs_win.xci  $(XCDEPEND) $(CB_DEPEND) $(ITEM_DEPEND)
+	$(XCTOCXX) wxs_text.xc
+wxs_win.cxx : wxs_win.xc wxs_win.xci $(XCDEPEND)
+	$(XCTOCXX) wxs_win.xc
+
+WXSCC = $(CXX) $(WXSCFLAGS) $(LOCALFLAGS) -c
+
+$(OBJDIR)/wxscheme.o : wxscheme.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS) wxsmred.h
+	$(WXSCC) wxscheme.cxx -o $(OBJDIR)/wxscheme.o 
+
+$(OBJDIR)/xcglue.o : ../../mzscheme/utils/xcglue.c ../../mzscheme/utils/xcglue.h ../../mzscheme/src/stypes.h
+	$(WXSCC) ../../mzscheme/utils/xcglue.c -o $(OBJDIR)/xcglue.o
+
+$(OBJDIR)/wxscomon.o : wxscomon.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxscomon.cxx -o $(OBJDIR)/wxscomon.o
+$(OBJDIR)/wxs_bmap.o : wxs_bmap.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_bmap.cxx -o $(OBJDIR)/wxs_bmap.o
+$(OBJDIR)/wxs_butn.o : wxs_butn.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_butn.cxx -o $(OBJDIR)/wxs_butn.o
+$(OBJDIR)/wxs_chce.o : wxs_chce.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_chce.cxx -o $(OBJDIR)/wxs_chce.o
+$(OBJDIR)/wxs_ckbx.o : wxs_ckbx.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_ckbx.cxx -o $(OBJDIR)/wxs_ckbx.o
+$(OBJDIR)/wxs_cnvs.o : wxs_cnvs.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_cnvs.cxx -o $(OBJDIR)/wxs_cnvs.o
+$(OBJDIR)/wxs_cstr.o : wxs_cstr.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_cstr.cxx -o $(OBJDIR)/wxs_cstr.o
+$(OBJDIR)/wxs_dc.o : wxs_dc.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_dc.cxx -o $(OBJDIR)/wxs_dc.o
+$(OBJDIR)/wxs_evnt.o : wxs_evnt.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_evnt.cxx -o $(OBJDIR)/wxs_evnt.o
+$(OBJDIR)/wxs_fram.o : wxs_fram.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_fram.cxx -o $(OBJDIR)/wxs_fram.o
+$(OBJDIR)/wxs_gage.o : wxs_gage.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_gage.cxx -o $(OBJDIR)/wxs_gage.o
+$(OBJDIR)/wxs_gdi.o : wxs_gdi.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_gdi.cxx -o $(OBJDIR)/wxs_gdi.o
+$(OBJDIR)/wxs_glob.o : wxs_glob.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_glob.cxx -o $(OBJDIR)/wxs_glob.o
+$(OBJDIR)/wxs_help.o : wxs_help.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_help.cxx -o $(OBJDIR)/wxs_help.o
+$(OBJDIR)/wxs_ipc.o : wxs_ipc.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_ipc.cxx -o $(OBJDIR)/wxs_ipc.o
+$(OBJDIR)/wxs_item.o : wxs_item.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_item.cxx -o $(OBJDIR)/wxs_item.o
+$(OBJDIR)/wxs_lbox.o : wxs_lbox.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_lbox.cxx -o $(OBJDIR)/wxs_lbox.o
+$(OBJDIR)/wxs_list.o : wxs_list.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_list.cxx -o $(OBJDIR)/wxs_list.o
+$(OBJDIR)/wxs_madm.o : wxs_madm.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS)
+	$(WXSCC) wxs_madm.cxx -o $(OBJDIR)/wxs_madm.o
+$(OBJDIR)/wxs_medi.o : wxs_medi.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS)
+	$(WXSCC) wxs_medi.cxx -o $(OBJDIR)/wxs_medi.o
+$(OBJDIR)/wxs_mede.o : wxs_mede.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS)
+	$(WXSCC) wxs_mede.cxx -o $(OBJDIR)/wxs_mede.o
+$(OBJDIR)/wxs_menu.o : wxs_menu.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_menu.cxx -o $(OBJDIR)/wxs_menu.o
+$(OBJDIR)/wxs_mio.o : wxs_mio.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS)
+	$(WXSCC) wxs_mio.cxx -o $(OBJDIR)/wxs_mio.o
+$(OBJDIR)/wxs_misc.o : wxs_misc.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_misc.cxx -o $(OBJDIR)/wxs_misc.o
+$(OBJDIR)/wxs_mpb.o : wxs_mpb.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS) ../wxme/wx_medpb.h
+	$(WXSCC) wxs_mpb.cxx -o $(OBJDIR)/wxs_mpb.o
+$(OBJDIR)/wxs_obj.o : wxs_obj.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_obj.cxx -o $(OBJDIR)/wxs_obj.o
+$(OBJDIR)/wxs_panl.o : wxs_panl.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_panl.cxx -o $(OBJDIR)/wxs_panl.o
+$(OBJDIR)/wxs_rado.o : wxs_rado.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_rado.cxx -o $(OBJDIR)/wxs_rado.o
+$(OBJDIR)/wxs_slid.o : wxs_slid.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_slid.cxx -o $(OBJDIR)/wxs_slid.o
+$(OBJDIR)/wxs_snip.o : wxs_snip.cxx $(WXSCHEMEHEADERS) $(MEDIAHEADERS)
+	$(WXSCC) wxs_snip.cxx -o $(OBJDIR)/wxs_snip.o
+$(OBJDIR)/wxs_styl.o : wxs_styl.cxx $(WXSCHEMEHEADERS) ../wxme/wx_style.h
+	$(WXSCC) wxs_styl.cxx -o $(OBJDIR)/wxs_styl.o
+$(OBJDIR)/wxs_tbar.o : wxs_tbar.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_tbar.cxx -o $(OBJDIR)/wxs_tbar.o
+$(OBJDIR)/wxs_text.o : wxs_text.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_text.cxx -o $(OBJDIR)/wxs_text.o
+$(OBJDIR)/wxs_win.o : wxs_win.cxx $(WXSCHEMEHEADERS)
+	$(WXSCC) wxs_win.cxx -o $(OBJDIR)/wxs_win.o
diff --git a/src/mred/wxs/cb_end.xci b/src/mred/wxs/cb_end.xci
new file mode 100644
index 0000000..92fe1fa
--- /dev/null
+++ b/src/mred/wxs/cb_end.xci
@@ -0,0 +1,47 @@
+
+#if 0
+
+static Scheme_Object *CB_TOC(wxFunction f, int n, Scheme_Object **p)
+{
+  CB_REALCLASS *b;
+  wxCommandEvent *c;
+
+  if (n != 2)
+    scheme_signal_error("need two arguments for callback for %s", CB_USER);
+
+  if (f) {
+    b = CB_UNBUNDLE(p[0], "callback for " CB_USER, 0);  
+    c = objscheme_unbundle_wxCommandEvent(p[1], "callback for " CB_USER, 0);
+
+    f(*b, *c);
+  }
+
+  return scheme_void;
+}
+
+#endif
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/cb_start.xci b/src/mred/wxs/cb_start.xci
new file mode 100644
index 0000000..c67cd9e
--- /dev/null
+++ b/src/mred/wxs/cb_start.xci
@@ -0,0 +1,12 @@
+
+@DEFINE CB_FUNCTYPE wxFunction
+
+@INCLUDE cbgen_s.xci
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+#if 0
+static Scheme_Object *CB_TOC(wxFunction f, int n, struct Scheme_Object **p);
+#endif
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
diff --git a/src/mred/wxs/cbgen_s.xci b/src/mred/wxs/cbgen_s.xci
new file mode 100644
index 0000000..abde8a4
--- /dev/null
+++ b/src/mred/wxs/cbgen_s.xci
@@ -0,0 +1,30 @@
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+@DEFINE CALLBACKCLASS = os_<CALLBACK_CLASS>
+@DEFINE CB_REALCLASS = <CALLBACK_CLASS>
+@DEFINE CB_UNBUNDLE = objscheme_unbundle_<CALLBACK_CLASS>
+@DEFINE CB_USER = <CALLBACK_CLASS_USER>
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+@DEFINE CB_TOSCHEME = <CALLBACK_CLASS>CallbackToScheme
+@DEFINE CB_TOC = <CALLBACK_CLASS>CallbackToC
+
+@VAR Scheme_Object *callback_closure;
+
+class CALLBACKCLASS;
+
+@MACRO ubCallback = (SCHEME_NULLP({x}) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2({x}, CB_USER), tmp_callback = {x}, (CB_FUNCTYPE)CB_TOSCHEME))
+
+@MACRO ubCallbackSetup = Scheme_Object *tmp_callback = NULL;
+@MACRO ubCallbackFinish = ((CALLBACKCLASS *)((Scheme_Class_Object *)obj)->primdata)->callback_closure = tmp_callback; objscheme_backpointer(&((CALLBACKCLASS *)((Scheme_Class_Object *)obj)->primdata)->callback_closure);
+@MACRO ubCallbackCreatorFinish = realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+
+@MACRO bCallback = scheme_make_closed_prim((Scheme_Closed_Prim *)CB_TOC, {x})
+@MACRO cCallback = (SCHEME_NULLP({x}) || objscheme_istype_proc2({x}, {s}))
+
+@MACRO spCallback = $$>(<CALLBACK_CLASS>-object wxEvent-object -> void)
diff --git a/src/mred/wxs/common.txt b/src/mred/wxs/common.txt
new file mode 100644
index 0000000..e69de29
diff --git a/src/mred/wxs/danger.tst b/src/mred/wxs/danger.tst
new file mode 100644
index 0000000..fbeb2df
--- /dev/null
+++ b/src/mred/wxs/danger.tst
@@ -0,0 +1,16 @@
+# Methods that should not be called by random testing
+wx:media-edit% save-file
+wx:media-pasteboard% save-file
+wx:multi-text% save-file
+wx:text-window% save-file
+wx:bitmap% save-file
+'wxsGlobal wx:write-resource
+'wxsGlobal wx:exit
+'wxsGlobal wx:concat-files
+'wxsGlobal wx:copy-file
+wx:media-buffer% get-file
+wx:media-buffer% put-file
+wx:media-edit% get-file
+wx:media-edit% put-file
+wx:media-pasteboard% get-file
+wx:media-pasteboard% put-file
diff --git a/src/mred/wxs/list.xci b/src/mred/wxs/list.xci
new file mode 100644
index 0000000..050fd1f
--- /dev/null
+++ b/src/mred/wxs/list.xci
@@ -0,0 +1,97 @@
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+@IFDEFINE l_ADDRESS = INDIRECT : & : 
+@IFDEFINE l_DEREF = INDIRECT : * : 
+@IFDEFINE l_NULLOK = ALLOWNULL : 1 : 0
+@IFDEFINE l_TEST = NOTEST :  : , l_NULLOK
+@IFDEFINE l_POINT = POINTERS : * : 
+@IFDEFINE l_EXTRA = NULLTERM : 1 : 0
+@IFDEFINE l_TERMINATE = NULLTERM : f[i] = 0; :
+@IFDEFINE l_COPY = POINTWISE : l_COPYDEST.x=l_COPYSRC.x; l_COPYDEST.y=l_COPYSRC.y; : l_COPYDEST=l_COPYSRC;
+@IFDEFINE l_OKTEST = DOOKTEST : if (!((l_COPYDEST)->Ok())) scheme_signal_error("%s: bad bitmap", OKTESTWHERE);
+@IFDEFINE l_INTTYPE = SIZEISLONG : long : int
+
+@DEFINE l_TYPE = <TYPE>
+@DEFINE l_LIST_ITEM_BUNDLE = objscheme_bundle_<TYPE>
+@DEFINE l_LIST_ITEM_UNBUNDLE = objscheme_unbundle_<TYPE>
+@DEFINE l_MAKE_LIST = __Make<TYPE>List
+@DEFINE l_MAKE_ARRAY = __Make<TYPE>Array
+
+@MACRO bList = NULL
+@MACRO ubList = NULL
+@MACRO cList = SCHEME_LISTP({x})
+
+@MACRO glueListSet[type.list.array.cnt.who] = x<array> = __Make<type>Array((<list> < n) ? p[<list>] : scheme_null, &x<cnt>, <who>);
+@MACRO glueUncountedListSet[type.list.array.who] = x<array> = __Make<type>Array((<array> < n) ? p[<list>] : scheme_null, NULL, <who>);
+@MACRO methListSet[type.list.array.cnt] = p[<list>] = __Make<type>List(x<array>, x<cnt>);
+
+@MACRO glueCleanup[array] = delete[] x<array>;
+
+@MACRO bReturnList[type.cnt] =  __Make<type>List({x}, *x<cnt>);
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+@SET NOTEST = 0
+@SET INDIRECT = 0
+@SET POINTERS = 0
+@SET NULLTERM = 0
+@SET ALLOWNULL = 0
+@SET POINTWISE = 0
+@SET DOOKTEST = 0
diff --git a/src/mred/wxs/prefix.xci b/src/mred/wxs/prefix.xci
new file mode 100644
index 0000000..96840db
--- /dev/null
+++ b/src/mred/wxs/prefix.xci
@@ -0,0 +1,3 @@
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
diff --git a/src/mred/wxs/qbool.xci b/src/mred/wxs/qbool.xci
new file mode 100644
index 0000000..fcaa836
--- /dev/null
+++ b/src/mred/wxs/qbool.xci
@@ -0,0 +1,6 @@
+
+// Quasi-booleans; nominally Bool, but really ints
+
+@MACRO cQBool = objscheme_istype_number({x}, NULL)
+@MACRO bQBool = objscheme_bundle_integer({x})
+@MACRO ubQBool = objscheme_unbundle_integer({x}, NULL)
diff --git a/src/mred/wxs/range.xci b/src/mred/wxs/range.xci
new file mode 100644
index 0000000..df30b27
--- /dev/null
+++ b/src/mred/wxs/range.xci
@@ -0,0 +1,5 @@
+
+#define THISOBJECT ((RANGECLASS *)((Scheme_Class_Object *)obj)->primdata)
+
+@MACRO RANGERET[p.rv] = if ((x<p> < 0) || (x<p> >= THISOBJECT->Number())) return <rv>;
+@MACRO RANGE[p] = $$RANGERET[<p>.scheme_void]
diff --git a/src/mred/wxs/test.h b/src/mred/wxs/test.h
new file mode 100644
index 0000000..cdb6f4a
--- /dev/null
+++ b/src/mred/wxs/test.h
@@ -0,0 +1,5 @@
+extern int objscheme_istype_wxMenu(Scheme_Object *, const char *, int);
+void objscheme_setup_x(Scheme_Env *env);
+int objscheme_istype_x(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_x(class x *realobj);
+class x *objscheme_unbundle_x(Scheme_Object *obj, const char *where, int nullOK);
diff --git a/src/mred/wxs/test.xc b/src/mred/wxs/test.xc
new file mode 100644
index 0000000..f74d439
--- /dev/null
+++ b/src/mred/wxs/test.xc
@@ -0,0 +1,30 @@
+
+@TEST
+
+@SETMARK X = 
+
+@CLASSBASE x "x":"y"
+@SETMARK Q = H
+@SETMARK q = v
+
+@MACRO NULL = NULL
+@ v "wx:get-os-version" : int wxGetOsVersion(int?,int?); : : : NULL
+@ v "wx:get-resource" : bool wxGetResource(string,string,string*,string=NULL);
+
+@ V "scroll" : void Scroll(int,int,bool);
+@ V "scroll" : void Scroll(int,int);
+@ Q "append" : void Append(int,string,string=NULL);
+@ Q "append" : void Append(int,string,wxMenu!,string=NULL);
+
+@MACRO blah[sam.i.am] = blah({x} + <sam> + <i> + <am>)
+
+@SET temp = 1
+@IFDEFINE HM = temp : A : B
+
+// @ V "test" : int& Test(int*,int/blah[a.b.c], -int,int*);
+
+@IVAR "i" : float i
+
+@CONSTANT "one" : int 1
+
+@END
diff --git a/src/mred/wxs/vector.xci b/src/mred/wxs/vector.xci
new file mode 100644
index 0000000..ff318a2
--- /dev/null
+++ b/src/mred/wxs/vector.xci
@@ -0,0 +1,77 @@
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_VECTOR_ITEM_BUNDLE
+#undef l_VECTOR_ITEM_UNBUNDLE
+#undef l_MAKE_VECTOR
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+
+@IFDEFINE l_ADDRESS = INDIRECT : & : 
+@IFDEFINE l_DEREF = INDIRECT : * : 
+@IFDEFINE l_TEST = NOTEST :  : , 1
+@IFDEFINE l_POINT = POINTERS : * : 
+@IFDEFINE l_EXTRA = NULLTERM : 1 : 0
+@IFDEFINE l_TERMINATE = NULLTERM : f[i] = 0; :
+
+@DEFINE l_TYPE = <TYPE>
+@DEFINE l_VECTOR_ITEM_BUNDLE = objscheme_bundle_<TYPE>
+@DEFINE l_VECTOR_ITEM_UNBUNDLE = objscheme_unbundle_<TYPE>
+@DEFINE l_MAKE_VECTOR = __Make<TYPE>Vector
+@DEFINE l_MAKE_ARRAY = __Make<TYPE>Array
+
+@MACRO bVec = NULL
+@MACRO ubVec = NULL
+@MACRO cVec = SCHEME_VECP({x})
+
+@MACRO glueVectorSet[type.vector.array.cnt] = x<array> = __Make<type>Array((<vector> < n) ? p[<vector>] : scheme_null, &x<cnt>);
+@MACRO glueUncountedVectorSet[type.vector.array] = x<array> = __Make<type>Array((<array> < n) ? p[<vector>] : scheme_null, NULL);
+@MACRO methVectorSet[type.vector.array.cnt] = p[<vector>] = __Make<type>Vector(x<array>, x<cnt>);
+
+@MACRO glueCleanup[array] = delete[] x<array>;
+
+@MACRO bReturnVec[type.cnt] =  __Make<type>Vector({x}, *x<cnt>);
+
+static Scheme_Object *l_MAKE_VECTOR(l_TYPE l_POINT *f, int c)
+{
+  Scheme_Object *vec, *obj;
+
+  vec = scheme_make_vector(c, scheme_null);
+
+  while (c--) {
+    obj = l_VECTOR_ITEM_BUNDLE(l_ADDRESS f[c]);
+    SCHEME_VEC_ELS(vec)[c] = obj;
+  }
+  
+  return vec;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, int *c)
+{
+  int i = 0;
+  long len;
+
+  len = SCHEME_VEC_SIZE(l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (len--) {
+    f[i++] = l_DEREF l_VECTOR_ITEM_UNBUNDLE(SCHEME_VEC_ELS(l)[i], 
+					  "make-array" l_TEST);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+@SET NOTEST = 0
+@SET INDIRECT = 0
+@SET POINTERS = 0
+@SET NULLTERM = 0
diff --git a/src/mred/wxs/wxs.xci b/src/mred/wxs/wxs.xci
new file mode 100644
index 0000000..4891427
--- /dev/null
+++ b/src/mred/wxs/wxs.xci
@@ -0,0 +1,9 @@
+
+@BOOLEAN Bool
+@CLASSSUFFIX "%"
+@IDFIELD __type
+
+@MACRO NOZERO[p] = if (!x<p>) x<p> = -1;
+@MACRO CHECKOK[p.who] = if (x<p> && !x<p>->Ok()) scheme_signal_error("%s: bad bitmap", <who>);
+@MACRO CHECKVOIDABLEOK[p] = if (x<p> && !x<p>->Ok()) return scheme_void;
+
diff --git a/src/mred/wxs/wxs_bmap.cxx b/src/mred/wxs/wxs_bmap.cxx
new file mode 100644
index 0000000..5e5b722
--- /dev/null
+++ b/src/mred/wxs/wxs_bmap.cxx
@@ -0,0 +1,452 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_bmap.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_gdi.h"
+
+
+
+
+
+#include "wxs_bmt.h"
+
+#ifndef wx_mac
+#define wxBITMAP_TYPE_PICT 0
+#define wxBITMAP_TYPE_PICT_RESOURCE 0
+#endif
+
+#include "wxscheme.h"
+#include "wxs_bmap.h"
+#include "wxscomon.h"
+
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE char
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_char
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_char
+#define l_MAKE_LIST __MakecharList
+#define l_MAKE_ARRAY __MakecharArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+	
+
+
+
+
+// @CONSTANT "wx:const-bitmap-type-xbm-data" : long wxBITMAP_TYPE_XBM_DATA
+// @CONSTANT "wx:const-bitmap-type-xpm-data" : long wxBITMAP_TYPE_XPM_DATA
+// @CONSTANT "wx:const-bitmap-type-resource" : long wxBITMAP_TYPE_RESOURCE
+
+class os_wxBitmap : public wxBitmap {
+ public:
+
+  os_wxBitmap(Scheme_Object * obj, char* x0, int x1, int x2, int x3 = 1);
+  os_wxBitmap(Scheme_Object * obj, int x0, int x1, int x2 = -1);
+  os_wxBitmap(Scheme_Object * obj, pathname x0, long x1 = wxBITMAP_TYPE_DEFAULT);
+  ~os_wxBitmap();
+};
+
+Scheme_Object *os_wxBitmap_class;
+
+os_wxBitmap::os_wxBitmap(Scheme_Object * o, char* x0, int x1, int x2, int x3)
+: wxBitmap(x0, x1, x2, x3)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBitmap::os_wxBitmap(Scheme_Object * o, int x0, int x1, int x2)
+: wxBitmap(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBitmap::os_wxBitmap(Scheme_Object * o, pathname x0, long x1)
+: wxBitmap(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBitmap::~os_wxBitmap()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapSetColourMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColourMap* x0;
+
+  
+  x0 = objscheme_unbundle_wxColourMap(p[0], "wx:bitmap%::set-colour-map", 1);
+
+  
+  ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->SetColourMap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  pathname x0;
+  int x1;
+  class wxColourMap* x2;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "wx:bitmap%::save-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:bitmap%::save-file");
+  if (n > 2) {
+    x2 = objscheme_unbundle_wxColourMap(p[2], "wx:bitmap%::save-file", 1);
+  } else
+    x2 = NULL;
+
+  
+  ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->SaveFile(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  pathname x0;
+  long x1;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "wx:bitmap%::load-file");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:bitmap%::load-file");
+  } else
+    x1 = wxBITMAP_TYPE_DEFAULT;
+
+  
+  ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->LoadFile(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapGetWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->GetWidth();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapGetHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->GetHeight();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmapGetDepth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBitmap *)((Scheme_Class_Object *)obj)->primdata)->GetDepth();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBitmap_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBitmap *realobj;
+  if ((n >= 1) && objscheme_istype_pathname(p[0], NULL)) {
+    pathname x0;
+    long x1;
+
+    
+    if ((n < 1) ||(n > 2)) 
+      scheme_wrong_count("wx:bitmap%::initialization (pathname case)", 1, 2, n, p);
+    x0 = (pathname)objscheme_unbundle_pathname(p[0], "wx:bitmap%::initialization (pathname case)");
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:bitmap%::initialization (pathname case)");
+    } else
+      x1 = wxBITMAP_TYPE_DEFAULT;
+
+    
+    realobj = new os_wxBitmap(obj, x0, x1);
+    
+    
+  } else if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+    int x1;
+    int x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:bitmap%::initialization (width/height case)", 2, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:bitmap%::initialization (width/height case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:bitmap%::initialization (width/height case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:bitmap%::initialization (width/height case)");
+    } else
+      x2 = -1;
+
+    if ((x0 < 1) || (x0 > 100000)) scheme_signal_error("wx:bitmap%%::initialization: bad " "width" ": %d", x0);if ((x1 < 1) || (x1 > 100000)) scheme_signal_error("wx:bitmap%%::initialization: bad " "height" ": %d", x1);
+    realobj = new os_wxBitmap(obj, x0, x1, x2);
+    
+    
+  } else  {
+    char* x0;
+    int x1;
+    int x2;
+    int x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:bitmap%::initialization (character list case)", 3, 4, n, p);
+    x0 = NULL;
+    x1 = objscheme_unbundle_integer(p[1], "wx:bitmap%::initialization (character list case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:bitmap%::initialization (character list case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:bitmap%::initialization (character list case)");
+    } else
+      x3 = 1;
+
+    if ((x1 < 1) || (x1 > 100000)) scheme_signal_error("wx:bitmap%%::initialization: bad " "width" ": %d", x1);if ((x2 < 1) || (x2 > 100000)) scheme_signal_error("wx:bitmap%%::initialization: bad " "height" ": %d", x2);if (x3 != 1) scheme_signal_error("wx:bitmap%%::initialization: depth %d is illegal (only depth 1 is supported)", x3);if (scheme_proper_list_length(p[0]) < (((x1 * x2) >> 3) * x3)) scheme_signal_error("wx:bitmap%%::initialization: byte list too short");x0 = __MakecharArray((0 < n) ? p[0] : scheme_null, NULL, "wx:bitmap%::initialization");
+    realobj = new os_wxBitmap(obj, x0, x1, x2, x3);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBitmap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:bitmap%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:bitmap%");
+}
+
+void objscheme_setup_wxBitmap(void *env)
+{
+if (os_wxBitmap_class) {
+    objscheme_add_global_class(os_wxBitmap_class,  "wx:bitmap%", env);
+} else {
+  os_wxBitmap_class = objscheme_def_prim_class(env, "wx:bitmap%", "wx:object%", os_wxBitmap_ConstructScheme, 8);
+
+  scheme_add_method_w_arity(os_wxBitmap_class,"get-class-name",objscheme_classname_os_wxBitmap, 0, 0);
+
+ scheme_add_method_w_arity(os_wxBitmap_class, "set-colour-map", os_wxBitmapSetColourMap, 1, 1);
+ scheme_add_method_w_arity(os_wxBitmap_class, "save-file", os_wxBitmapSaveFile, 2, 3);
+ scheme_add_method_w_arity(os_wxBitmap_class, "load-file", os_wxBitmapLoadFile, 1, 2);
+ scheme_add_method_w_arity(os_wxBitmap_class, "ok?", os_wxBitmapOk, 0, 0);
+ scheme_add_method_w_arity(os_wxBitmap_class, "get-width", os_wxBitmapGetWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxBitmap_class, "get-height", os_wxBitmapGetHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxBitmap_class, "get-depth", os_wxBitmapGetDepth, 0, 0);
+
+
+  scheme_made_class(os_wxBitmap_class);
+
+
+}
+  scheme_install_xc_global("wx:const-bitmap-type-default", scheme_make_integer(wxBITMAP_TYPE_DEFAULT), env);
+  scheme_install_xc_global("wx:const-bitmap-discard-colourmap", scheme_make_integer(wxBITMAP_DISCARD_COLOURMAP), env);
+  scheme_install_xc_global("wx:const-bitmap-type-bmp", scheme_make_integer(wxBITMAP_TYPE_BMP), env);
+  scheme_install_xc_global("wx:const-bitmap-type-bmp-resource", scheme_make_integer(wxBITMAP_TYPE_BMP_RESOURCE), env);
+  scheme_install_xc_global("wx:const-bitmap-type-gif", scheme_make_integer(wxBITMAP_TYPE_GIF), env);
+  scheme_install_xc_global("wx:const-bitmap-type-xbm", scheme_make_integer(wxBITMAP_TYPE_XBM), env);
+  scheme_install_xc_global("wx:const-bitmap-type-xpm", scheme_make_integer(wxBITMAP_TYPE_XPM), env);
+  scheme_install_xc_global("wx:const-bitmap-type-pict", scheme_make_integer(wxBITMAP_TYPE_PICT), env);
+  scheme_install_xc_global("wx:const-bitmap-type-pict-resource", scheme_make_integer(wxBITMAP_TYPE_PICT_RESOURCE), env);
+}
+
+int objscheme_istype_wxBitmap(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBitmap_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:bitmap%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBitmap(class wxBitmap *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBitmap_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBitmap(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBitmap *)o->primdata;
+  else
+    return (wxBitmap *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_bmap.h b/src/mred/wxs/wxs_bmap.h
new file mode 100644
index 0000000..dca90d2
--- /dev/null
+++ b/src/mred/wxs/wxs_bmap.h
@@ -0,0 +1,10 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxColourMap *objscheme_unbundle_wxColourMap(Scheme_Object *, const char *, int);
+extern class wxColourMap *objscheme_unbundle_wxColourMap(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxBitmap(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxBitmap(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBitmap(class wxBitmap *realobj);
+class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_bmap.xc b/src/mred/wxs/wxs_bmap.xc
new file mode 100644
index 0000000..aff1221
--- /dev/null
+++ b/src/mred/wxs/wxs_bmap.xc
@@ -0,0 +1,55 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_gdi.h"
+
+@INCLUDE wxs.xci
+
+#include "wxs_bmt.h"
+
+#ifndef wx_mac
+#define wxBITMAP_TYPE_PICT 0
+#define wxBITMAP_TYPE_PICT_RESOURCE 0
+#endif
+
+@HEADER
+
+@CLASSBASE wxBitmap "wx:bitmap" : "wx:object"
+
+@SET TYPE = char
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@MACRO ZEROERR[p.woh] = if ((x<p> < 1) || (x<p> > 100000)) scheme_signal_error("wx:bitmap%%::initialization: bad " <woh> ": %d", x<p>);
+
+@MACRO NONZERODEPTH = if (x3 != 1) scheme_signal_error("wx:bitmap%%::initialization: depth %d is illegal (only depth 1 is supported)", x3);
+@MACRO LISTENOUGH = if (scheme_proper_list_length(p[0]) < (((x1 * x2) >> 3) * x3)) scheme_signal_error("wx:bitmap%%::initialization: byte list too short");
+	
+@CREATOR (char[]/bList/ubList/cList,int,int,int=1); : : /ZEROERR[1."width"]|ZEROERR[2."height"]|NONZERODEPTH|LISTENOUGH|glueUncountedListSet[char.0.0."wx:bitmap%::initialization"]// <> character list
+@CREATOR (int,int,int=-1); : : /ZEROERR[0."width"]|ZEROERR[1."height"] <> width/height
+@CREATOR (pathname,long=wxBITMAP_TYPE_DEFAULT); <> pathname
+
+@ "get-depth" : int GetDepth();
+@ "get-height" : int GetHeight();
+@ "get-width" : int GetWidth();
+@ "ok?" : bool Ok();
+
+@ "load-file" : void LoadFile(pathname,long=wxBITMAP_TYPE_DEFAULT);
+@ "save-file" : void SaveFile(pathname,int,wxColourMap^=NULL);
+
+@ "set-colour-map" : void SetColourMap(wxColourMap^);
+
+@CONSTANT "wx:const-bitmap-type-default" : long wxBITMAP_TYPE_DEFAULT
+@CONSTANT "wx:const-bitmap-discard-colourmap" : long wxBITMAP_DISCARD_COLOURMAP
+@CONSTANT "wx:const-bitmap-type-bmp" : long wxBITMAP_TYPE_BMP
+@CONSTANT "wx:const-bitmap-type-bmp-resource" : long wxBITMAP_TYPE_BMP_RESOURCE
+@CONSTANT "wx:const-bitmap-type-gif" : long wxBITMAP_TYPE_GIF
+@CONSTANT "wx:const-bitmap-type-xbm" : long wxBITMAP_TYPE_XBM
+// @CONSTANT "wx:const-bitmap-type-xbm-data" : long wxBITMAP_TYPE_XBM_DATA
+@CONSTANT "wx:const-bitmap-type-xpm" : long wxBITMAP_TYPE_XPM
+// @CONSTANT "wx:const-bitmap-type-xpm-data" : long wxBITMAP_TYPE_XPM_DATA
+// @CONSTANT "wx:const-bitmap-type-resource" : long wxBITMAP_TYPE_RESOURCE
+@CONSTANT "wx:const-bitmap-type-pict" : long wxBITMAP_TYPE_PICT
+@CONSTANT "wx:const-bitmap-type-pict-resource" : long wxBITMAP_TYPE_PICT_RESOURCE
+
+@END
diff --git a/src/mred/wxs/wxs_bmt.h b/src/mred/wxs/wxs_bmt.h
new file mode 100644
index 0000000..77d96a0
--- /dev/null
+++ b/src/mred/wxs/wxs_bmt.h
@@ -0,0 +1,11 @@
+
+#ifdef wx_x
+#define wxBITMAP_TYPE_DEFAULT (wxBITMAP_DISCARD_COLOURMAP | wxBITMAP_TYPE_XBM)
+#else
+#ifdef wx_msw
+#define wxBITMAP_TYPE_DEFAULT (wxBITMAP_DISCARD_COLOURMAP | wxBITMAP_TYPE_BMP)
+#else
+#define wxBITMAP_TYPE_DEFAULT (wxBITMAP_DISCARD_COLOURMAP | wxBITMAP_TYPE_PICT)
+#endif
+#endif
+
diff --git a/src/mred/wxs/wxs_butn.cxx b/src/mred/wxs/wxs_butn.cxx
new file mode 100644
index 0000000..13c8b12
--- /dev/null
+++ b/src/mred/wxs/wxs_butn.cxx
@@ -0,0 +1,628 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_butn.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_buttn.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_butn.h"
+#include "wxscomon.h"
+
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxButton
+#define CB_REALCLASS wxButton
+#define CB_UNBUNDLE objscheme_unbundle_wxButton
+#define CB_USER "wx:button%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxButtonCallbackToScheme
+#define CB_TOC wxButtonCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+
+
+
+
+
+class os_wxButton : public wxButton {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxButton(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, string x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, long x7 = 0, string x8 = "button");
+  os_wxButton(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, class wxBitmap* x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, long x7 = 0, string x8 = "button");
+  ~os_wxButton();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxButton_class;
+
+os_wxButton::os_wxButton(Scheme_Object * o, class wxPanel* x0, wxFunction x1, string x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxButton(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxButton::os_wxButton(Scheme_Object * o, class wxPanel* x0, wxFunction x1, class wxBitmap* x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxButton(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxButton::~os_wxButton()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxButton::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxButton_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:button%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxButton::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxButton_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:button%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxButton::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxButton_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxButton::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxButton::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxButton_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxButton::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxButton::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxButton_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxButton::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxBitmap(p[0], NULL, 0)) {
+    class wxBitmap* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:button%::set-label (bitmap label case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxBitmap(p[0], "wx:button%::set-label (bitmap label case)", 0);
+
+    if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:button%::set-label");
+    ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  } else  {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:button%::set-label (string label case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:button%::set-label (string label case)");
+
+    
+    ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonSetDefault(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->SetDefault();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:button%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:button%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxButton *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:button%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:button%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxButton *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:button%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:button%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxButton *)((Scheme_Class_Object *)obj)->primdata)->wxButton::OnSize(x0, x1);
+  else
+    ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxButton *)((Scheme_Class_Object *)obj)->primdata)->wxButton::OnSetFocus();
+  else
+    ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButtonOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxButton *)((Scheme_Class_Object *)obj)->primdata)->wxButton::OnKillFocus();
+  else
+    ((wxButton *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxButton_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxButton *realobj;
+  if ((n >= 3) && objscheme_istype_wxPanel(p[0], NULL, 0) && (SCHEME_NULLP(p[1]) || objscheme_istype_proc2(p[1], NULL)) && objscheme_istype_wxBitmap(p[2], NULL, 0)) {
+    class wxPanel* x0;
+    wxFunction x1;
+    class wxBitmap* x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    long x7;
+    string x8;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 3) ||(n > 9)) 
+      scheme_wrong_count("wx:button%::initialization (bitmap label case)", 3, 9, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:button%::initialization (bitmap label case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = objscheme_unbundle_wxBitmap(p[2], "wx:button%::initialization (bitmap label case)", 0);
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:button%::initialization (bitmap label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:button%::initialization (bitmap label case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:button%::initialization (bitmap label case)");
+    } else
+      x5 = -1;
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:button%::initialization (bitmap label case)");
+    } else
+      x6 = -1;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:button%::initialization (bitmap label case)");
+    } else
+      x7 = 0;
+    if (n > 8) {
+      x8 = (string)objscheme_unbundle_string(p[8], "wx:button%::initialization (bitmap label case)");
+    } else
+      x8 = "button";
+
+    if (x2 && !x2->Ok()) scheme_signal_error("%s: bad bitmap", "wx:button%::initialization");if (!x5) x5 = -1;if (!x6) x6 = -1;
+    realobj = new os_wxButton(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  } else  {
+    class wxPanel* x0;
+    wxFunction x1;
+    string x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    long x7;
+    string x8;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 3) ||(n > 9)) 
+      scheme_wrong_count("wx:button%::initialization (string label case)", 3, 9, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:button%::initialization (string label case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = (string)objscheme_unbundle_string(p[2], "wx:button%::initialization (string label case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:button%::initialization (string label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:button%::initialization (string label case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:button%::initialization (string label case)");
+    } else
+      x5 = -1;
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:button%::initialization (string label case)");
+    } else
+      x6 = -1;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:button%::initialization (string label case)");
+    } else
+      x7 = 0;
+    if (n > 8) {
+      x8 = (string)objscheme_unbundle_string(p[8], "wx:button%::initialization (string label case)");
+    } else
+      x8 = "button";
+
+    if (!x5) x5 = -1;if (!x6) x6 = -1;
+    realobj = new os_wxButton(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxButton(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:button%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:button%");
+}
+
+void objscheme_setup_wxButton(void *env)
+{
+if (os_wxButton_class) {
+    objscheme_add_global_class(os_wxButton_class,  "wx:button%", env);
+} else {
+  os_wxButton_class = objscheme_def_prim_class(env, "wx:button%", "wx:item%", os_wxButton_ConstructScheme, 8);
+
+  scheme_add_method_w_arity(os_wxButton_class,"get-class-name",objscheme_classname_os_wxButton, 0, 0);
+
+ scheme_add_method(os_wxButton_class, "set-label", os_wxButtonSetLabel);
+ scheme_add_method_w_arity(os_wxButton_class, "set-default", os_wxButtonSetDefault, 0, 0);
+ scheme_add_method_w_arity(os_wxButton_class, "pre-on-event", os_wxButtonPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxButton_class, "pre-on-char", os_wxButtonPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxButton_class, "on-size", os_wxButtonOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxButton_class, "on-set-focus", os_wxButtonOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxButton_class, "on-kill-focus", os_wxButtonOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxButton_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxButton, wxTYPE_BUTTON);
+
+}
+}
+
+int objscheme_istype_wxButton(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxButton_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:button%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxButton(class wxButton *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_BUTTON) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxButton_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxButton *objscheme_unbundle_wxButton(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxButton(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxButton *)o->primdata;
+  else
+    return (wxButton *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_butn.h b/src/mred/wxs/wxs_butn.h
new file mode 100644
index 0000000..dc9b58e
--- /dev/null
+++ b/src/mred/wxs/wxs_butn.h
@@ -0,0 +1,23 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxButton(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxButton(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxButton(class wxButton *realobj);
+class wxButton *objscheme_unbundle_wxButton(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_butn.xc b/src/mred/wxs/wxs_butn.xc
new file mode 100644
index 0000000..b1ffacd
--- /dev/null
+++ b/src/mred/wxs/wxs_butn.xc
@@ -0,0 +1,30 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_buttn.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxButton "wx:button":"wx:item"
+
+@CLASSID wxTYPE_BUTTON
+
+@SET CALLBACK_CLASS = wxButton
+@SET CALLBACK_CLASS_USER = "wx:button%::initialization"
+@INCLUDE cb_start.xci
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,string,int=-1,int=-1,int=-1,int=-1,long=0,string="button"); : : ubCallbackSetup/NOZERO[5]|NOZERO[6]//ubCallbackCreatorFinish <> string label
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,wxBitmap!,int=-1,int=-1,int=-1,int=-1,long=0,string="button"); : : ubCallbackSetup/CHECKOK[2."wx:button%::initialization"]|NOZERO[5]|NOZERO[6]//ubCallbackCreatorFinish <> bitmap label
+
+@INCLUDE wxs_item.xci
+
+@ "set-default" : void SetDefault();
+@ "set-label" : void SetLabel(wxBitmap!) : : /CHECKOK[0."wx:button%::set-label"] <> bitmap label
+@ "set-label" : void SetLabel(string); <> string label
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_char.xci b/src/mred/wxs/wxs_char.xci
new file mode 100644
index 0000000..9355545
--- /dev/null
+++ b/src/mred/wxs/wxs_char.xci
@@ -0,0 +1,2 @@
+
+@ c "on-char" : void OnChar(wxKeyEvent%);
diff --git a/src/mred/wxs/wxs_chce.cxx b/src/mred/wxs/wxs_chce.cxx
new file mode 100644
index 0000000..226a48f
--- /dev/null
+++ b/src/mred/wxs/wxs_chce.cxx
@@ -0,0 +1,832 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_chce.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_choic.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_chce.h"
+#include "wxscomon.h"
+
+
+#define USE_COLUMNS 0
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxChoice
+#define CB_REALCLASS wxChoice
+#define CB_UNBUNDLE objscheme_unbundle_wxChoice
+#define CB_USER "wx:choice%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxChoiceCallbackToScheme
+#define CB_TOC wxChoiceCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE string
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_string
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_string
+#define l_MAKE_LIST __MakestringList
+#define l_MAKE_ARRAY __MakestringArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+#define RANGECLASS wxChoice
+
+#define THISOBJECT ((RANGECLASS *)((Scheme_Class_Object *)obj)->primdata)
+
+
+
+
+
+
+
+
+
+
+class os_wxChoice : public wxChoice {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxChoice(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, int x7 = 0, string* x8 = NULL, long x9 = 0, string x10 = "checkBox");
+  ~os_wxChoice();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxChoice_class;
+
+os_wxChoice::os_wxChoice(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7, string* x8, long x9, string x10)
+: wxChoice(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxChoice::~os_wxChoice()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxChoice::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxChoice_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:choice%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxChoice::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxChoice_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:choice%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxChoice::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxChoice_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxChoice::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxChoice::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxChoice_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxChoice::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxChoice::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxChoice_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxChoice::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#if  USE_COLUMNS
+#pragma argsused
+static Scheme_Object *os_wxChoiceGetColumns(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+#if  USE_COLUMNS
+
+  
+
+  
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->GetColumns();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:choice%::get-columns");
+#endif
+  return scheme_make_integer(r);
+}
+#endif
+
+#if  USE_COLUMNS
+#pragma argsused
+static Scheme_Object *os_wxChoiceSetColumns(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+#if  USE_COLUMNS
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:choice%::set-columns");
+  } else
+    x0 = 1;
+
+  
+  ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->SetColumns(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:choice%::get-string");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_null;
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->GetString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceSetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:choice%::set-string-selection");
+
+  
+  ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->SetStringSelection(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceSetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:choice%::set-selection");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->SetSelection(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceGetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->GetStringSelection();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceGetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->GetSelection();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceFindString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:choice%::find-string");
+
+  
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->FindString(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceAppend(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:choice%::append");
+
+  
+  ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->Append(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoicePreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:choice%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:choice%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxChoice *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoicePreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:choice%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:choice%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxChoice *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:choice%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:choice%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxChoice *)((Scheme_Class_Object *)obj)->primdata)->wxChoice::OnSize(x0, x1);
+  else
+    ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxChoice *)((Scheme_Class_Object *)obj)->primdata)->wxChoice::OnSetFocus();
+  else
+    ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoiceOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxChoice *)((Scheme_Class_Object *)obj)->primdata)->wxChoice::OnKillFocus();
+  else
+    ((wxChoice *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxChoice_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxChoice *realobj;
+  class wxPanel* x0;
+  wxFunction x1;
+  nstring x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  string* x8;
+  long x9;
+  string x10;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n < 3) ||(n > 10)) 
+    scheme_wrong_count("wx:choice%::initialization", 3, 10, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:choice%::initialization", 0);
+  x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:choice%::initialization");
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:choice%::initialization");
+  } else
+    x3 = -1;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:choice%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:choice%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:choice%::initialization");
+  } else
+    x6 = -1;
+  if (n > 7) {
+    x8 = NULL;
+  } else
+    x8 = NULL;
+  if (n > 8) {
+    x9 = objscheme_unbundle_integer(p[8], "wx:choice%::initialization");
+  } else
+    x9 = 0;
+  if (n > 9) {
+    x10 = (string)objscheme_unbundle_string(p[9], "wx:choice%::initialization");
+  } else
+    x10 = "checkBox";
+
+  x8 = __MakestringArray((7 < n) ? p[7] : scheme_null, &x7, "wx:choice%::initialization");if (!x5) x5 = -1;if (!x6) x6 = -1;
+  realobj = new os_wxChoice(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
+  delete[] x8;
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxChoice(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:choice%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:choice%");
+}
+
+void objscheme_setup_wxChoice(void *env)
+{
+if (os_wxChoice_class) {
+    objscheme_add_global_class(os_wxChoice_class,  "wx:choice%", env);
+} else {
+  os_wxChoice_class = objscheme_def_prim_class(env, "wx:choice%", "wx:item%", os_wxChoice_ConstructScheme, 17);
+
+  scheme_add_method_w_arity(os_wxChoice_class,"get-class-name",objscheme_classname_os_wxChoice, 0, 0);
+
+#if  USE_COLUMNS
+ scheme_add_method_w_arity(os_wxChoice_class, "get-columns", os_wxChoiceGetColumns, 0, 0);
+#endif
+#if  USE_COLUMNS
+ scheme_add_method_w_arity(os_wxChoice_class, "set-columns", os_wxChoiceSetColumns, 0, 1);
+#endif
+ scheme_add_method_w_arity(os_wxChoice_class, "get-string", os_wxChoiceGetString, 1, 1);
+ scheme_add_method_w_arity(os_wxChoice_class, "set-string-selection", os_wxChoiceSetStringSelection, 1, 1);
+ scheme_add_method_w_arity(os_wxChoice_class, "set-selection", os_wxChoiceSetSelection, 1, 1);
+ scheme_add_method_w_arity(os_wxChoice_class, "get-string-selection", os_wxChoiceGetStringSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxChoice_class, "get-selection", os_wxChoiceGetSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxChoice_class, "find-string", os_wxChoiceFindString, 1, 1);
+ scheme_add_method_w_arity(os_wxChoice_class, "number", os_wxChoiceNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxChoice_class, "clear", os_wxChoiceClear, 0, 0);
+ scheme_add_method_w_arity(os_wxChoice_class, "append", os_wxChoiceAppend, 1, 1);
+ scheme_add_method_w_arity(os_wxChoice_class, "pre-on-event", os_wxChoicePreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxChoice_class, "pre-on-char", os_wxChoicePreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxChoice_class, "on-size", os_wxChoiceOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxChoice_class, "on-set-focus", os_wxChoiceOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxChoice_class, "on-kill-focus", os_wxChoiceOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxChoice_class);
+
+
+}
+}
+
+int objscheme_istype_wxChoice(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxChoice_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:choice%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxChoice(class wxChoice *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxChoice_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxChoice *objscheme_unbundle_wxChoice(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxChoice(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxChoice *)o->primdata;
+  else
+    return (wxChoice *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_chce.h b/src/mred/wxs/wxs_chce.h
new file mode 100644
index 0000000..68ff4b5
--- /dev/null
+++ b/src/mred/wxs/wxs_chce.h
@@ -0,0 +1,17 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxChoice(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxChoice(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxChoice(class wxChoice *realobj);
+class wxChoice *objscheme_unbundle_wxChoice(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_chce.xc b/src/mred/wxs/wxs_chce.xc
new file mode 100644
index 0000000..88379d7
--- /dev/null
+++ b/src/mred/wxs/wxs_chce.xc
@@ -0,0 +1,44 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_choic.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#define USE_COLUMNS 0
+
+@CLASSBASE wxChoice "wx:choice":"wx:item"
+
+@SET CALLBACK_CLASS = wxChoice
+@SET CALLBACK_CLASS_USER = "wx:choice%::initialization"
+@INCLUDE cb_start.xci
+
+@SET TYPE = string
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+#define RANGECLASS wxChoice
+@INCLUDE range.xci
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,int=-1,int=-1,int=-1,int=-1,-int=0,string[]=NULL/bList/ubList/cList,long=0,string="checkBox"); : : ubCallbackSetup/glueListSet[string.7.8.7."wx:choice%::initialization"]|NOZERO[5]|NOZERO[6]/glueCleanup[8]/ubCallbackCreatorFinish
+
+@INCLUDE wxs_item.xci
+
+@ "append" : void Append(string);
+@ "clear" : void Clear();
+@ "number" : int Number();
+@ "find-string" : int FindString(string);
+@ "get-selection" : int GetSelection();
+@ "get-string-selection" : string GetStringSelection();
+@ "set-selection" : void SetSelection(int); : : /RANGE[0]
+@ "set-string-selection" : void SetStringSelection(string);
+@ "get-string" : string GetString(int); : : /RANGERET[0.scheme_null]
+
+@ "set-columns" : void SetColumns(int=1); ## USE_COLUMNS
+@ "get-columns" :  int GetColumns();  ## USE_COLUMNS
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_ckbx.cxx b/src/mred/wxs/wxs_ckbx.cxx
new file mode 100644
index 0000000..b02cb95
--- /dev/null
+++ b/src/mred/wxs/wxs_ckbx.cxx
@@ -0,0 +1,645 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_ckbx.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_check.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_ckbx.h"
+#include "wxscomon.h"
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxCheckBox
+#define CB_REALCLASS wxCheckBox
+#define CB_UNBUNDLE objscheme_unbundle_wxCheckBox
+#define CB_USER "wx:check-box%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxCheckBoxCallbackToScheme
+#define CB_TOC wxCheckBoxCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+
+
+
+
+class os_wxCheckBox : public wxCheckBox {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxCheckBox(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, string x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, long x7 = 0, string x8 = "checkBox");
+  os_wxCheckBox(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, class wxBitmap* x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, long x7 = 0, string x8 = "checkBox");
+  ~os_wxCheckBox();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxCheckBox_class;
+
+os_wxCheckBox::os_wxCheckBox(Scheme_Object * o, class wxPanel* x0, wxFunction x1, string x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxCheckBox(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCheckBox::os_wxCheckBox(Scheme_Object * o, class wxPanel* x0, wxFunction x1, class wxBitmap* x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxCheckBox(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCheckBox::~os_wxCheckBox()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxCheckBox::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCheckBox_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:check-box%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxCheckBox::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCheckBox_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:check-box%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxCheckBox::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCheckBox_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCheckBox::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCheckBox::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCheckBox_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCheckBox::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCheckBox::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCheckBox_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCheckBox::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxBitmap(p[0], NULL, 0)) {
+    class wxBitmap* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:check-box%::set-label (bitmap label case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxBitmap(p[0], "wx:check-box%::set-label (bitmap label case)", 0);
+
+    if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:check-box%::set-label");
+    ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  } else  {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:check-box%::set-label (string label case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:check-box%::set-label (string label case)");
+
+    
+    ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxSetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:check-box%::set-value");
+
+  
+  ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->SetValue(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxGetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->GetValue();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:check-box%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:check-box%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:check-box%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:check-box%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:check-box%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:check-box%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->wxCheckBox::OnSize(x0, x1);
+  else
+    ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->wxCheckBox::OnSetFocus();
+  else
+    ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBoxOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->wxCheckBox::OnKillFocus();
+  else
+    ((wxCheckBox *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCheckBox_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxCheckBox *realobj;
+  if ((n >= 3) && objscheme_istype_wxPanel(p[0], NULL, 0) && (SCHEME_NULLP(p[1]) || objscheme_istype_proc2(p[1], NULL)) && objscheme_istype_wxBitmap(p[2], NULL, 0)) {
+    class wxPanel* x0;
+    wxFunction x1;
+    class wxBitmap* x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    long x7;
+    string x8;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 3) ||(n > 9)) 
+      scheme_wrong_count("wx:check-box%::initialization (bitmap label case)", 3, 9, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:check-box%::initialization (bitmap label case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = objscheme_unbundle_wxBitmap(p[2], "wx:check-box%::initialization (bitmap label case)", 0);
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x5 = -1;
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x6 = -1;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x7 = 0;
+    if (n > 8) {
+      x8 = (string)objscheme_unbundle_string(p[8], "wx:check-box%::initialization (bitmap label case)");
+    } else
+      x8 = "checkBox";
+
+    if (x2 && !x2->Ok()) scheme_signal_error("%s: bad bitmap", "wx:check-box%::initialization");if (!x5) x5 = -1;if (!x6) x6 = -1;
+    realobj = new os_wxCheckBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  } else  {
+    class wxPanel* x0;
+    wxFunction x1;
+    string x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    long x7;
+    string x8;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 3) ||(n > 9)) 
+      scheme_wrong_count("wx:check-box%::initialization (string label case)", 3, 9, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:check-box%::initialization (string label case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = (string)objscheme_unbundle_string(p[2], "wx:check-box%::initialization (string label case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:check-box%::initialization (string label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:check-box%::initialization (string label case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:check-box%::initialization (string label case)");
+    } else
+      x5 = -1;
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:check-box%::initialization (string label case)");
+    } else
+      x6 = -1;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:check-box%::initialization (string label case)");
+    } else
+      x7 = 0;
+    if (n > 8) {
+      x8 = (string)objscheme_unbundle_string(p[8], "wx:check-box%::initialization (string label case)");
+    } else
+      x8 = "checkBox";
+
+    if (!x5) x5 = -1;if (!x6) x6 = -1;
+    realobj = new os_wxCheckBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxCheckBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:check-box%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:check-box%");
+}
+
+void objscheme_setup_wxCheckBox(void *env)
+{
+if (os_wxCheckBox_class) {
+    objscheme_add_global_class(os_wxCheckBox_class,  "wx:check-box%", env);
+} else {
+  os_wxCheckBox_class = objscheme_def_prim_class(env, "wx:check-box%", "wx:item%", os_wxCheckBox_ConstructScheme, 9);
+
+  scheme_add_method_w_arity(os_wxCheckBox_class,"get-class-name",objscheme_classname_os_wxCheckBox, 0, 0);
+
+ scheme_add_method(os_wxCheckBox_class, "set-label", os_wxCheckBoxSetLabel);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "set-value", os_wxCheckBoxSetValue, 1, 1);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "get-value", os_wxCheckBoxGetValue, 0, 0);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "pre-on-event", os_wxCheckBoxPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "pre-on-char", os_wxCheckBoxPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "on-size", os_wxCheckBoxOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "on-set-focus", os_wxCheckBoxOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxCheckBox_class, "on-kill-focus", os_wxCheckBoxOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxCheckBox_class);
+
+
+}
+}
+
+int objscheme_istype_wxCheckBox(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCheckBox_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:check-box%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCheckBox(class wxCheckBox *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCheckBox_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCheckBox *objscheme_unbundle_wxCheckBox(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCheckBox(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCheckBox *)o->primdata;
+  else
+    return (wxCheckBox *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_ckbx.h b/src/mred/wxs/wxs_ckbx.h
new file mode 100644
index 0000000..866fed6
--- /dev/null
+++ b/src/mred/wxs/wxs_ckbx.h
@@ -0,0 +1,23 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxCheckBox(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCheckBox(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCheckBox(class wxCheckBox *realobj);
+class wxCheckBox *objscheme_unbundle_wxCheckBox(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_ckbx.xc b/src/mred/wxs/wxs_ckbx.xc
new file mode 100644
index 0000000..2d8ade9
--- /dev/null
+++ b/src/mred/wxs/wxs_ckbx.xc
@@ -0,0 +1,28 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_check.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxCheckBox "wx:check-box":"wx:item"
+
+@SET CALLBACK_CLASS = wxCheckBox
+@SET CALLBACK_CLASS_USER = "wx:check-box%::initialization"
+@INCLUDE cb_start.xci
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,string,int=-1,int=-1,int=-1,int=-1,long=0,string="checkBox"); : : ubCallbackSetup/NOZERO[5]|NOZERO[6]//ubCallbackCreatorFinish <> string label
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,wxBitmap!,int=-1,int=-1,int=-1,int=-1,long=0,string="checkBox"); : : ubCallbackSetup/CHECKOK[2."wx:check-box%::initialization"]|NOZERO[5]|NOZERO[6]//ubCallbackCreatorFinish <> bitmap label
+
+@INCLUDE wxs_item.xci
+
+@ "get-value" : bool GetValue();
+@ "set-value" : void SetValue(bool);
+@ "set-label" : void SetLabel(wxBitmap!); : : /CHECKOK[0."wx:check-box%::set-label"] <> bitmap label
+@ "set-label" : void SetLabel(string); <> string label
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_cnvs.cxx b/src/mred/wxs/wxs_cnvs.cxx
new file mode 100644
index 0000000..29fab7e
--- /dev/null
+++ b/src/mred/wxs/wxs_cnvs.cxx
@@ -0,0 +1,1808 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_cnvs.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_canvs.h"
+#include "wx_panel.h"
+#include "wx_frame.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_cnvs.h"
+#include "wxscomon.h"
+
+
+#ifdef wx_xt
+# include "wx_types.h"
+# define CHECK_FOR_PANEL(x) !wxSubType((x)->__type, wxTYPE_CANVAS)
+#else
+# define CHECK_FOR_PANEL(x) 0
+#endif
+
+static void FillZero(int *a, int *b) {
+  *a = *b = 0;
+}
+
+/* Handle cases in Xt that are a problem because a wxPanel isn't really a wxCanvas */
+
+
+// @CREATOR ();
+
+// @ "enable-scrolling" : void EnableScrolling(bool,bool);
+
+
+
+
+
+
+
+
+// Override wx-window:
+// @ "set-size" : void SetSize(int,int,int,int); : : /NOZERO[2]|NOZERO[3]
+// @ "set-client-size" : void SetClientSize(int,int); : : /NOZERO[0]|NOZERO[1]
+// @ "get-size" : void GetSize(int*,int*);
+// @ "get-client-size" : void GetClientSize(int*,int*);
+// @ "get-position" : void GetPosition(int*,int*);
+
+
+// @ "is-retained?" : bool IsRetained(); : : / PANELREDIRECT[return scheme_false]
+
+
+
+
+
+
+
+#define DrawsForCanvas
+
+#undef DO_OK_CHECK
+#ifdef DrawsForCanvas
+#define DO_OK_CHECK(v)
+#else
+#define DO_OK_CHECK(v) if (!((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Ok()) return v;
+#endif
+
+
+
+extern Scheme_Object *objscheme_bundle_wxPoint(wxPoint *);
+extern wxPoint *objscheme_unbundle_wxPoint(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxIntPoint(wxIntPoint *);
+extern wxIntPoint *objscheme_unbundle_wxIntPoint(Scheme_Object *, const char *, int);
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS &
+#define l_DEREF *
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST.x=l_COPYSRC.x; l_COPYDEST.y=l_COPYSRC.y;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE wxPoint
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxPoint
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxPoint
+#define l_MAKE_LIST __MakewxPointList
+#define l_MAKE_ARRAY __MakewxPointArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS &
+#define l_DEREF *
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST.x=l_COPYSRC.x; l_COPYDEST.y=l_COPYSRC.y;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE wxIntPoint
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxIntPoint
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxIntPoint
+#define l_MAKE_LIST __MakewxIntPointList
+#define l_MAKE_ARRAY __MakewxIntPointArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+/* The methods are here: */
+
+
+
+
+// @ Q "int-draw-line" : void IntDrawLine(int,int,int,int); : : /CheckOk
+// @ q "draw-spline" : void DrawSpline(wxList!); : : /CheckOk
+
+
+
+// Undefined?
+//@ "int-draw-lines" : void IntDrawLines(-int,wxIntPoint!/bList/ubList/cList,float=0,float=0); : / methListSet[wxIntPoint.0.1.0]// : /CheckOk|glueListSet[wxIntPoint.0.1.0]//
+
+
+
+// @CONSTANT "wx:const-retained" : long wxRETAINED
+// @CONSTANT "wx:const-backingstore" : long wxBACKINGSTORE
+
+class os_wxCanvas : public wxCanvas {
+ public:
+
+  os_wxCanvas(Scheme_Object * obj, class wxFrame* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "canvas");
+  os_wxCanvas(Scheme_Object * obj, class wxPanel* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "canvas");
+  ~os_wxCanvas();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+  void OnScroll(class wxCommandEvent& x0);
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+  void OnPaint();
+};
+
+Scheme_Object *os_wxCanvas_class;
+
+os_wxCanvas::os_wxCanvas(Scheme_Object * o, class wxFrame* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxCanvas(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCanvas::os_wxCanvas(Scheme_Object * o, class wxPanel* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxCanvas(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCanvas::~os_wxCanvas()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxCanvas::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:canvas%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxCanvas::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:canvas%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxCanvas::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnScroll(class wxCommandEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-scroll", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnScroll(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxCommandEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxCanvas::OnPaint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxCanvas_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxCanvas::OnPaint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetTextForeground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:canvas%::set-text-foreground", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetTextForeground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetTextBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:canvas%::set-text-background", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetTextBackground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetPen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxPen* x0;
+
+  
+  x0 = objscheme_unbundle_wxPen(p[0], "wx:canvas%::set-pen", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetPen(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetLogicalFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::set-logical-function");
+
+  switch (x0) { case wxAND: case wxAND_INVERT: case wxAND_REVERSE: case wxCLEAR: case wxCOPY: case wxEQUIV: case wxINVERT: case wxNAND: case wxNOR: case wxNO_OP: case wxOR: case wxOR_INVERT: case wxOR_REVERSE: case wxSET: case wxSRC_INVERT: case wxXOR: break; case wxCOLOR: if (x0 == wxCOPY) break; default: scheme_wrong_type("wx:dc::set-logical-function", "logicalfunction integer", 0, n, p); }DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetLogicalFunction(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxFont* x0;
+
+  
+  x0 = objscheme_unbundle_wxFont(p[0], "wx:canvas%::set-font", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetFont(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetBrush(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBrush* x0;
+
+  
+  x0 = objscheme_unbundle_wxBrush(p[0], "wx:canvas%::set-brush", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetBrush(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBrush* x0;
+
+  
+  x0 = objscheme_unbundle_wxBrush(p[0], "wx:canvas%::set-background", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetBackground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:canvas%::get-clipping-region", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:canvas%::get-clipping-region"), "wx:canvas%::get-clipping-region");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:canvas%::get-clipping-region", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:canvas%::get-clipping-region"), "wx:canvas%::get-clipping-region");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:canvas%::get-clipping-region", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:canvas%::get-clipping-region"), "wx:canvas%::get-clipping-region");
+  if (SCHEME_NULLP(p[3]))
+    scheme_wrong_type("wx:canvas%::get-clipping-region", "non-null", (3 - 0), n, p);
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:canvas%::get-clipping-region"), "wx:canvas%::get-clipping-region");
+
+  
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetClippingRegion(x0, x1, x2, x3);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3)
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::set-clipping-region");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::set-clipping-region");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:canvas%::set-clipping-region");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:canvas%::set-clipping-region");
+
+  DO_OK_CHECK(scheme_void)if (x2 < 0) x2 = 0;if (x3 < 0) x3 = 0;
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetClippingRegion(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDestroyClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DestroyClippingRegion();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawPolygon(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  class wxPoint* x1;
+  float x2;
+  float x3;
+  int x4;
+
+  
+  x1 = NULL;
+  if (n > 1) {
+    x2 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-polygon");
+  } else
+    x2 = 0;
+  if (n > 2) {
+    x3 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-polygon");
+  } else
+    x3 = 0;
+  if (n > 3) {
+    x4 = objscheme_unbundle_integer(p[3], "wx:canvas%::draw-polygon");
+  } else
+    x4 = wxODDEVEN_RULE;
+
+  DO_OK_CHECK(scheme_void)x1 = __MakewxPointArray((0 < n) ? p[0] : scheme_null, &x0, "wx:dc%::draw-polygon");
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawPolygon(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawLines(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  class wxPoint* x1;
+  float x2;
+  float x3;
+
+  
+  x1 = NULL;
+  if (n > 1) {
+    x2 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-lines");
+  } else
+    x2 = 0;
+  if (n > 2) {
+    x3 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-lines");
+  } else
+    x3 = 0;
+
+  DO_OK_CHECK(scheme_void)x1 = __MakewxPointArray((0 < n) ? p[0] : scheme_null, &x0, "wx:dc%::draw-lines");
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawLines(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawEllipse(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-ellipse");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-ellipse");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:canvas%::draw-ellipse");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:canvas%::draw-ellipse");
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawEllipse(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawArc(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-arc");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-arc");
+  x2 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-arc");
+  x3 = objscheme_unbundle_float(p[3], "wx:canvas%::draw-arc");
+  x4 = objscheme_unbundle_float(p[4], "wx:canvas%::draw-arc");
+  x5 = objscheme_unbundle_float(p[5], "wx:canvas%::draw-arc");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawArc(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  float x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:canvas%::draw-text");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-text");
+  x2 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-text");
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:canvas%::draw-text");
+  } else
+    x3 = FALSE;
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawSpline(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-spline");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-spline");
+  x2 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-spline");
+  x3 = objscheme_unbundle_float(p[3], "wx:canvas%::draw-spline");
+  x4 = objscheme_unbundle_float(p[4], "wx:canvas%::draw-spline");
+  x5 = objscheme_unbundle_float(p[5], "wx:canvas%::draw-spline");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawSpline(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawRoundedRectangle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-rounded-rectangle");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-rounded-rectangle");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:canvas%::draw-rounded-rectangle");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:canvas%::draw-rounded-rectangle");
+  if (n > 4) {
+    x4 = objscheme_unbundle_float(p[4], "wx:canvas%::draw-rounded-rectangle");
+  } else
+    x4 = 20;
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawRoundedRectangle(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawRectangle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-rectangle");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-rectangle");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:canvas%::draw-rectangle");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:canvas%::draw-rectangle");
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawRectangle(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-point");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-point");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawPoint(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDrawLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas%::draw-line");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::draw-line");
+  x2 = objscheme_unbundle_float(p[2], "wx:canvas%::draw-line");
+  x3 = objscheme_unbundle_float(p[3], "wx:canvas%::draw-line");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->DrawLine(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasEndDrawing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->EndDrawing();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasBeginDrawing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->BeginDrawing();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:canvas%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:canvas%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:canvas%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:canvas%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnSize(x0, x1);
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnSetFocus();
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnKillFocus();
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnScroll(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxCommandEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxCommandEvent(p[0], "wx:canvas%::on-scroll", 0);
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { return scheme_void; }
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnScroll(*x0);
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnScroll(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetScrollPage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::get-scroll-page");
+
+  
+  r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetScrollPage(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetScrollRange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::get-scroll-range");
+
+  
+  r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetScrollRange(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetScrollPos(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::get-scroll-pos");
+
+  
+  r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetScrollPos(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasScroll(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::scroll");
+  x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::scroll");
+
+  
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->Scroll(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasWarpPointer(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::warp-pointer");
+  x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::warp-pointer");
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { return scheme_void; }
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->WarpPointer(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasViewStart(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:canvas%::view-start", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:canvas%::view-start"), "wx:canvas%::view-start");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:canvas%::view-start", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:canvas%::view-start"), "wx:canvas%::view-start");
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { FillZero(x0,x1); return scheme_void; }
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->ViewStart(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasSetScrollbars(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  Bool x8;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:canvas%::set-scrollbars");
+  x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::set-scrollbars");
+  x2 = objscheme_unbundle_integer(p[2], "wx:canvas%::set-scrollbars");
+  x3 = objscheme_unbundle_integer(p[3], "wx:canvas%::set-scrollbars");
+  x4 = objscheme_unbundle_integer(p[4], "wx:canvas%::set-scrollbars");
+  x5 = objscheme_unbundle_integer(p[5], "wx:canvas%::set-scrollbars");
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:canvas%::set-scrollbars");
+  } else
+    x6 = 0;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:canvas%::set-scrollbars");
+  } else
+    x7 = 0;
+  if (n > 8) {
+    x8 = objscheme_unbundle_bool(p[8], "wx:canvas%::set-scrollbars");
+  } else
+    x8 = TRUE;
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { return scheme_void; }
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetScrollbars(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetVirtualSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:canvas%::get-virtual-size", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:canvas%::get-virtual-size"), "wx:canvas%::get-virtual-size");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:canvas%::get-virtual-size", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:canvas%::get-virtual-size"), "wx:canvas%::get-virtual-size");
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { FillZero(x0,x1); return scheme_void; }
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetVirtualSize(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetScrollUnitsPerPage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:canvas%::get-scroll-units", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:canvas%::get-scroll-units"), "wx:canvas%::get-scroll-units");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:canvas%::get-scroll-units", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:canvas%::get-scroll-units"), "wx:canvas%::get-scroll-units");
+
+  if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { FillZero(x0,x1); return scheme_void; }
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetScrollUnitsPerPage(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasGetDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCanvasDC* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetDC();
+
+  
+  
+  return objscheme_bundle_wxCanvasDC(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasPopupMenu(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:canvas%::popup-menu", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas%::popup-menu");
+  x2 = objscheme_unbundle_float(p[2], "wx:canvas%::popup-menu");
+
+  
+  r = ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->PopupMenu(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:canvas%::on-char", 0);
+
+  
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:canvas%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnEvent(*x0);
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxCanvas::OnPaint();
+  else
+    ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnPaint();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasAllowDoubleClick(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:canvas%::allow-double-click");
+
+  
+  ((wxCanvas *)((Scheme_Class_Object *)obj)->primdata)->AllowDoubleClick(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvas_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxCanvas *realobj;
+  if ((n >= 1) && objscheme_istype_wxPanel(p[0], NULL, 0)) {
+    class wxPanel* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:canvas%::initialization (panel case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:canvas%::initialization (panel case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::initialization (panel case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:canvas%::initialization (panel case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:canvas%::initialization (panel case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:canvas%::initialization (panel case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:canvas%::initialization (panel case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:canvas%::initialization (panel case)");
+    } else
+      x6 = "canvas";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxCanvas(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  } else  {
+    class wxFrame* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:canvas%::initialization (frame case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxFrame(p[0], "wx:canvas%::initialization (frame case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:canvas%::initialization (frame case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:canvas%::initialization (frame case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:canvas%::initialization (frame case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:canvas%::initialization (frame case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:canvas%::initialization (frame case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:canvas%::initialization (frame case)");
+    } else
+      x6 = "canvas";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxCanvas(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxCanvas(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:canvas%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:canvas%");
+}
+
+void objscheme_setup_wxCanvas(void *env)
+{
+if (os_wxCanvas_class) {
+    objscheme_add_global_class(os_wxCanvas_class,  "wx:canvas%", env);
+} else {
+  os_wxCanvas_class = objscheme_def_prim_class(env, "wx:canvas%", "wx:window%", os_wxCanvas_ConstructScheme, 45);
+
+  scheme_add_method_w_arity(os_wxCanvas_class,"get-class-name",objscheme_classname_os_wxCanvas, 0, 0);
+
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-text-foreground", os_wxCanvasSetTextForeground, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-text-background", os_wxCanvasSetTextBackground, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-pen", os_wxCanvasSetPen, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-logical-function", os_wxCanvasSetLogicalFunction, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-font", os_wxCanvasSetFont, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-brush", os_wxCanvasSetBrush, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-background", os_wxCanvasSetBackground, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-clipping-region", os_wxCanvasGetClippingRegion, 4, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-clipping-region", os_wxCanvasSetClippingRegion, 4, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "destroy-clipping-region", os_wxCanvasDestroyClippingRegion, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-polygon", os_wxCanvasDrawPolygon, 1, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-lines", os_wxCanvasDrawLines, 1, 3);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-ellipse", os_wxCanvasDrawEllipse, 4, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-arc", os_wxCanvasDrawArc, 6, 6);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-text", os_wxCanvasDrawText, 3, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-spline", os_wxCanvasDrawSpline, 6, 6);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-rounded-rectangle", os_wxCanvasDrawRoundedRectangle, 4, 5);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-rectangle", os_wxCanvasDrawRectangle, 4, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-point", os_wxCanvasDrawPoint, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "draw-line", os_wxCanvasDrawLine, 4, 4);
+ scheme_add_method_w_arity(os_wxCanvas_class, "clear", os_wxCanvasClear, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "end-drawing", os_wxCanvasEndDrawing, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "begin-drawing", os_wxCanvasBeginDrawing, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "pre-on-event", os_wxCanvasPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "pre-on-char", os_wxCanvasPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-size", os_wxCanvasOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-set-focus", os_wxCanvasOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-kill-focus", os_wxCanvasOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-scroll", os_wxCanvasOnScroll, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-scroll-page", os_wxCanvasGetScrollPage, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-scroll-range", os_wxCanvasGetScrollRange, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-scroll-pos", os_wxCanvasGetScrollPos, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "scroll", os_wxCanvasScroll, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "warp-pointer", os_wxCanvasWarpPointer, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "view-start", os_wxCanvasViewStart, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "set-scrollbars", os_wxCanvasSetScrollbars, 6, 9);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-virtual-size", os_wxCanvasGetVirtualSize, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-scroll-units", os_wxCanvasGetScrollUnitsPerPage, 2, 2);
+ scheme_add_method_w_arity(os_wxCanvas_class, "get-dc", os_wxCanvasGetDC, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "popup-menu", os_wxCanvasPopupMenu, 3, 3);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-char", os_wxCanvasOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-event", os_wxCanvasOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxCanvas_class, "on-paint", os_wxCanvasOnPaint, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvas_class, "allow-double-click", os_wxCanvasAllowDoubleClick, 1, 1);
+
+
+  scheme_made_class(os_wxCanvas_class);
+
+
+}
+  scheme_install_xc_global("wx:const-border", scheme_make_integer(wxBORDER), env);
+}
+
+int objscheme_istype_wxCanvas(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCanvas_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:canvas%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCanvas(class wxCanvas *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCanvas_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCanvas *objscheme_unbundle_wxCanvas(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCanvas(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCanvas *)o->primdata;
+  else
+    return (wxCanvas *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_cnvs.h b/src/mred/wxs/wxs_cnvs.h
new file mode 100644
index 0000000..1b3e00d
--- /dev/null
+++ b/src/mred/wxs/wxs_cnvs.h
@@ -0,0 +1,33 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(class wxCommandEvent *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxPen *objscheme_unbundle_wxPen(Scheme_Object *, const char *, int);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *, const char *, int);
+extern class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCanvasDC(class wxCanvasDC *);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxCanvas(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCanvas(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCanvas(class wxCanvas *realobj);
+class wxCanvas *objscheme_unbundle_wxCanvas(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_cnvs.xc b/src/mred/wxs/wxs_cnvs.xc
new file mode 100644
index 0000000..1126fcf
--- /dev/null
+++ b/src/mred/wxs/wxs_cnvs.xc
@@ -0,0 +1,75 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_canvs.h"
+#include "wx_panel.h"
+#include "wx_frame.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#ifdef wx_xt
+# include "wx_types.h"
+# define CHECK_FOR_PANEL(x) !wxSubType((x)->__type, wxTYPE_CANVAS)
+#else
+# define CHECK_FOR_PANEL(x) 0
+#endif
+
+static void FillZero(int *a, int *b) {
+  *a = *b = 0;
+}
+
+/* Handle cases in Xt that are a problem because a wxPanel isn't really a wxCanvas */
+@MACRO PANELREDIRECT[x] = if (CHECK_FOR_PANEL((wxObject *)((Scheme_Class_Object *)obj)->primdata)) { <x>; }
+
+@CLASSBASE wxCanvas "wx:canvas":"wx:window"
+
+// @CREATOR ();
+@CREATOR (wxFrame!,int=-1,int=-1,int=-1,int=-1,long=0,string="canvas") : : /NOZERO[3]|NOZERO[4]/ <> frame
+@CREATOR (wxPanel!,int=-1,int=-1,int=-1,int=-1,long=0,string="canvas") : : /NOZERO[3]|NOZERO[4]/ <> panel
+
+@ "allow-double-click" : void AllowDoubleClick(bool);
+// @ "enable-scrolling" : void EnableScrolling(bool,bool);
+
+@INCLUDE wxs_char.xci
+
+@SETMARK c = d
+@INCLUDE wxs_cnvs.xci
+
+@ "popup-menu" : bool PopupMenu(wxMenu!, float, float);
+
+// Override wx-window:
+// @ "set-size" : void SetSize(int,int,int,int); : : /NOZERO[2]|NOZERO[3]
+// @ "set-client-size" : void SetClientSize(int,int); : : /NOZERO[0]|NOZERO[1]
+// @ "get-size" : void GetSize(int*,int*);
+// @ "get-client-size" : void GetClientSize(int*,int*);
+// @ "get-position" : void GetPosition(int*,int*);
+
+@ "get-dc" : wxCanvasDC! GetDC();
+
+@ "get-scroll-units" : void GetScrollUnitsPerPage(int*,int*); : : / PANELREDIRECT[ FillZero(x0,x1); return scheme_void]
+@ "get-virtual-size" : void GetVirtualSize(int*,int*); : : / PANELREDIRECT[FillZero(x0,x1); return scheme_void]
+// @ "is-retained?" : bool IsRetained(); : : / PANELREDIRECT[return scheme_false]
+@ "set-scrollbars" : void SetScrollbars(int,int,int,int,int,int,int=0,int=0,bool=TRUE);  : : / PANELREDIRECT[return scheme_void]
+@ "view-start" : void ViewStart(int*,int*); : : / PANELREDIRECT[FillZero(x0,x1); return scheme_void]
+@ "warp-pointer" : void WarpPointer(int,int);  : : / PANELREDIRECT[return scheme_void]
+
+@ "scroll" : void Scroll(int,int);
+@ "get-scroll-pos" : int GetScrollPos(int);
+@ "get-scroll-range" : int GetScrollRange(int);
+@ "get-scroll-page" : int GetScrollPage(int);
+
+@ v "on-scroll" : void OnScroll(wxCommandEvent%); : : / PANELREDIRECT[return scheme_void]
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
+
+#define DrawsForCanvas
+@INCLUDE wxs_draw.xci
+
+@CONSTANT "wx:const-border" : long wxBORDER
+// @CONSTANT "wx:const-retained" : long wxRETAINED
+// @CONSTANT "wx:const-backingstore" : long wxBACKINGSTORE
+
+@END
diff --git a/src/mred/wxs/wxs_cnvs.xci b/src/mred/wxs/wxs_cnvs.xci
new file mode 100644
index 0000000..296bc32
--- /dev/null
+++ b/src/mred/wxs/wxs_cnvs.xci
@@ -0,0 +1,5 @@
+
+@ c "on-paint" : void OnPaint();
+@ c "on-event" : void OnEvent(wxMouseEvent%);
+
+@INCLUDE wxs_char.xci
diff --git a/src/mred/wxs/wxs_cstr.cxx b/src/mred/wxs/wxs_cstr.cxx
new file mode 100644
index 0000000..080fd38
--- /dev/null
+++ b/src/mred/wxs/wxs_cstr.cxx
@@ -0,0 +1,4 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_cstr.xc". */
+
+
diff --git a/src/mred/wxs/wxs_cstr.h b/src/mred/wxs/wxs_cstr.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxs_cstr.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_cstr.xc b/src/mred/wxs/wxs_cstr.xc
new file mode 100644
index 0000000..6517782
--- /dev/null
+++ b/src/mred/wxs/wxs_cstr.xc
@@ -0,0 +1,69 @@
+
+#if 0
+
+#include "wx_win.h"
+
+#if USE_CONSTRAINTS
+
+#include "wx_lay.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxLayoutConstraints "wx:layout-constraints":"wx:object"
+
+@CREATOR ()
+
+@IVAR "bottom" : wxIndividualLayoutConstraint% bottom
+@IVAR "top" : wxIndividualLayoutConstraint% top
+@IVAR "right" : wxIndividualLayoutConstraint% right
+@IVAR "left" : wxIndividualLayoutConstraint% left
+@IVAR "width" : wxIndividualLayoutConstraint% width
+@IVAR "height" : wxIndividualLayoutConstraint% height
+@IVAR "centreX" : wxIndividualLayoutConstraint% centreX
+@IVAR "centreY" : wxIndividualLayoutConstraint% centreY
+
+@END
+
+@CLASSBASE wxIndividualLayoutConstraint "wx:inidividual-layout-constraint":"wx:object"
+
+@CONSTANT "wx:const-left" : int wxLeft
+@CONSTANT "wx:const-top" : int wxTop
+@CONSTANT "wx:const-right" : int wxRight
+@CONSTANT "wx:const-bottom" : int wxBottom
+@CONSTANT "wx:const-centre-x" : int wxCentreX
+@CONSTANT "wx:const-centre-y" : int wxCentreY
+
+@CONSTANT "wx:const-unconstrained" : int wxUnconstrained
+@CONSTANT "wx:const-as-is" : int wxAsIs
+@CONSTANT "wx:const-above" : int wxAbove
+@CONSTANT "wx:const-below" : int wxBelow
+@CONSTANT "wx:const-left-of" : int wxLeftOf
+@CONSTANT "wx:const-right-of" : int wxRightOf
+@CONSTANT "wx:const-same-as" : int wxSameAs
+@CONSTANT "wx:const-percent-of" : int wxPercentOf
+@CONSTANT "wx:const-absolute" : int wxAbsolute
+
+@ "above" : void Above(wxWindow!,int=0);
+@ "absolute" : void Absolute(int);
+@ "as-is" : void AsIs();
+@ "below" : void Below(wxWindow!,int=0);
+@ "left-of" : void LeftOf(wxWindow!,int=0);
+@ "right-of" : void RightOf(wxWindow!,int=0);
+
+@MACRO bInt = objscheme_bundle_integer((int){x})
+@MACRO ubIntE = (wxEdge)objscheme_unbundle_integer({x}, "constraint")
+@MACRO ubIntR = (wxRelationship)objscheme_unbundle_integer({x}, "constraint")
+@MACRO tInt = objscheme_istype_number({x}, NULL)
+
+@ "percent-of" : void PercentOf(wxWindow!,wxEdge/bInt/ubIntE/tInt,int=0);
+@ "same-as" : void SameAs(wxWindow!,wxEdge/bInt/ubIntE/tInt,int=0);
+
+@ "set" : void Set(wxRelationship/bInt/ubIntR/tInt,wxWindow!,wxEdge/bInt/ubIntE/tInt,int=0,int=0);
+
+@END
+
+#endif
+
+#endif
diff --git a/src/mred/wxs/wxs_dc.cxx b/src/mred/wxs/wxs_dc.cxx
new file mode 100644
index 0000000..521c70a
--- /dev/null
+++ b/src/mred/wxs/wxs_dc.cxx
@@ -0,0 +1,2392 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_dc.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_dccan.h"
+#include "wx_dcmem.h"
+#include "wx_dcps.h"
+#ifndef wx_mac
+#include "wx_dcpan.h"
+#endif
+#ifdef wx_msw
+#include "wx_mf.h"
+#endif
+#include "wx_types.h"
+#ifdef wx_mac
+#include "wx_dcpr.h"
+#endif
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_dc.h"
+#include "wxscomon.h"
+
+
+
+
+// "U" for undefined (pure virtual); don't think we'll need it
+// @SETMARK q = v
+
+#undef DO_OK_CHECK
+#ifdef DrawsForCanvas
+#define DO_OK_CHECK(v)
+#else
+#define DO_OK_CHECK(v) if (!((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Ok()) return v;
+#endif
+
+
+
+extern Scheme_Object *objscheme_bundle_wxPoint(wxPoint *);
+extern wxPoint *objscheme_unbundle_wxPoint(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxIntPoint(wxIntPoint *);
+extern wxIntPoint *objscheme_unbundle_wxIntPoint(Scheme_Object *, const char *, int);
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS &
+#define l_DEREF *
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST.x=l_COPYSRC.x; l_COPYDEST.y=l_COPYSRC.y;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE wxPoint
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxPoint
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxPoint
+#define l_MAKE_LIST __MakewxPointList
+#define l_MAKE_ARRAY __MakewxPointArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS &
+#define l_DEREF *
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST.x=l_COPYSRC.x; l_COPYDEST.y=l_COPYSRC.y;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE wxIntPoint
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxIntPoint
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxIntPoint
+#define l_MAKE_LIST __MakewxIntPointList
+#define l_MAKE_ARRAY __MakewxIntPointArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+/* The methods are here: */
+
+
+
+
+// @ Q "int-draw-line" : void IntDrawLine(int,int,int,int); : : /CheckOk
+// @ q "draw-spline" : void DrawSpline(wxList!); : : /CheckOk
+
+
+
+// Undefined?
+//@ "int-draw-lines" : void IntDrawLines(-int,wxIntPoint!/bList/ubList/cList,float=0,float=0); : / methListSet[wxIntPoint.0.1.0]// : /CheckOk|glueListSet[wxIntPoint.0.1.0]//
+
+
+
+// Also in wxWindow:
+
+
+#ifndef wx_mac
+#define HIDETHISSTATEMENT(x) x
+#else
+#define HIDETHISSTATEMENT(x) 
+#endif
+
+
+
+#ifndef wx_mac
+#define CHECKTHISONE(x) x
+#else
+#define CHECKTHISONE(x) 1
+#endif
+
+
+
+
+
+
+
+
+// @ Q "device-to-logical-x" : float DeviceToLogicalX(int); : : : rZERO
+// @ Q "device-to-logical-y" : float DeviceToLogicalY(int); : : : rZERO
+// @ Q "logical-to-device-x" : float LogicalToDeviceX(int); : : : rZERO
+// @ Q "logical-to-device-y" : float LogicalToDeviceY(int); : : : rZERO
+
+
+
+
+
+
+
+class os_wxDC : public wxDC {
+ public:
+
+  ~os_wxDC();
+};
+
+Scheme_Object *os_wxDC_class;
+
+os_wxDC::~os_wxDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCEndPage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->EndPage();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCEndDoc(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->EndDoc();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCStartPage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->StartPage();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCStartDoc(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:dc%::start-doc");
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->StartDoc(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCMinY(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->MinY();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCMinX(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->MinX();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCMaxY(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->MaxY();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCMaxX(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->MaxX();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:dc%::get-size", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:dc%::get-size"), "wx:dc%::get-size");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:dc%::get-size", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:dc%::get-size"), "wx:dc%::get-size");
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetSize(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetTextForeground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetTextForeground();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetTextBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetTextBackground();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetPen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxPen* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetPen();
+
+  
+  
+  return objscheme_bundle_wxPen(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetMapMode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetMapMode();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetLogicalFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetLogicalFunction();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxFont* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetFont();
+
+  
+  
+  return objscheme_bundle_wxFont(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetBrush(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBrush* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetBrush();
+
+  
+  
+  return objscheme_bundle_wxBrush(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBrush* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetBackground();
+
+  
+  
+  return objscheme_bundle_wxBrush(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetDeviceOrigin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::set-device-origin");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::set-device-origin");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetDeviceOrigin(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetUserScale(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  nnfloat x0;
+  nnfloat x1;
+
+  
+  x0 = objscheme_unbundle_nonnegative_float(p[0], "wx:dc%::set-user-scale");
+  x1 = objscheme_unbundle_nonnegative_float(p[1], "wx:dc%::set-user-scale");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetUserScale(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetColourMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColourMap* x0;
+
+  
+  x0 = objscheme_unbundle_wxColourMap(p[0], "wx:dc%::set-colour-map", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetColourMap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetBackgroundMode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:dc%::set-background-mode");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetBackgroundMode(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetMapMode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:dc%::set-map-mode");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetMapMode(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCTryColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+  class wxColour* x1;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:dc%::try-colour", 0);
+  x1 = objscheme_unbundle_wxColour(p[1], "wx:dc%::try-colour", 0);
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->TryColour(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCBlit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  class wxCanvasDC* x4;
+  float x5;
+  float x6;
+  int x7;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::blit");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::blit");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::blit");
+  x3 = objscheme_unbundle_float(p[3], "wx:dc%::blit");
+  x4 = objscheme_unbundle_wxCanvasDC(p[4], "wx:dc%::blit", 0);
+  x5 = objscheme_unbundle_float(p[5], "wx:dc%::blit");
+  x6 = objscheme_unbundle_float(p[6], "wx:dc%::blit");
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:dc%::blit");
+  } else
+    x7 = wxCOPY;
+
+  switch (x7) { case wxAND: case wxAND_INVERT: case wxAND_REVERSE: case wxCLEAR: case wxCOPY: case wxEQUIV: case wxINVERT: case wxNAND: case wxNOR: case wxNO_OP: case wxOR: case wxOR_INVERT: case wxOR_REVERSE: case wxSET: case wxSRC_INVERT: case wxXOR: break; case wxCOLOR: if (x7 == wxCOLOR) break; default: scheme_wrong_type("wx:dc::blit", "logicalfunction integer", 7, n, p); }DO_OK_CHECK(scheme_false)if (!x4->Ok()) return scheme_false;
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Blit(x0, x1, x2, x3, x4, x5, x6, x7);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawIcon(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxIcon* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxIcon(p[0], "wx:dc%::draw-icon", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-icon");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::draw-icon");
+
+  DO_OK_CHECK(scheme_void)if (!CHECKTHISONE(x0->Ok())) return scheme_void;
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawIcon(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetOptimization(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:dc%::set-optimization");
+
+  HIDETHISSTATEMENT(
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetOptimization(x0);
+
+  )
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetCharWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetCharWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetCharHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetCharHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetTextExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  class wxFont* x5;
+  Bool x6;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:dc%::get-text-extent");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:dc%::get-text-extent", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:dc%::get-text-extent"), "wx:dc%::get-text-extent");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:dc%::get-text-extent", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:dc%::get-text-extent"), "wx:dc%::get-text-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:dc%::get-text-extent"), "wx:dc%::get-text-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:dc%::get-text-extent"), "wx:dc%::get-text-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    x5 = objscheme_unbundle_wxFont(p[5], "wx:dc%::get-text-extent", 1);
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    x6 = objscheme_unbundle_bool(p[6], "wx:dc%::get-text-extent");
+  } else
+    x6 = FALSE;
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetTextExtent(x0, x1, x2, x3, x4, x5, x6);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetTextForeground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:dc%::set-text-foreground", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetTextForeground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetTextBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:dc%::set-text-background", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetTextBackground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetPen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxPen* x0;
+
+  
+  x0 = objscheme_unbundle_wxPen(p[0], "wx:dc%::set-pen", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetPen(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetLogicalFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:dc%::set-logical-function");
+
+  switch (x0) { case wxAND: case wxAND_INVERT: case wxAND_REVERSE: case wxCLEAR: case wxCOPY: case wxEQUIV: case wxINVERT: case wxNAND: case wxNOR: case wxNO_OP: case wxOR: case wxOR_INVERT: case wxOR_REVERSE: case wxSET: case wxSRC_INVERT: case wxXOR: break; case wxCOLOR: if (x0 == wxCOPY) break; default: scheme_wrong_type("wx:dc::set-logical-function", "logicalfunction integer", 0, n, p); }DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetLogicalFunction(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxFont* x0;
+
+  
+  x0 = objscheme_unbundle_wxFont(p[0], "wx:dc%::set-font", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetFont(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetBrush(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBrush* x0;
+
+  
+  x0 = objscheme_unbundle_wxBrush(p[0], "wx:dc%::set-brush", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetBrush(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBrush* x0;
+
+  
+  x0 = objscheme_unbundle_wxBrush(p[0], "wx:dc%::set-background", 0);
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetBackground(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCGetClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:dc%::get-clipping-region", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:dc%::get-clipping-region"), "wx:dc%::get-clipping-region");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:dc%::get-clipping-region", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:dc%::get-clipping-region"), "wx:dc%::get-clipping-region");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:dc%::get-clipping-region", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:dc%::get-clipping-region"), "wx:dc%::get-clipping-region");
+  if (SCHEME_NULLP(p[3]))
+    scheme_wrong_type("wx:dc%::get-clipping-region", "non-null", (3 - 0), n, p);
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:dc%::get-clipping-region"), "wx:dc%::get-clipping-region");
+
+  
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->GetClippingRegion(x0, x1, x2, x3);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3)
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCSetClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::set-clipping-region");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::set-clipping-region");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:dc%::set-clipping-region");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:dc%::set-clipping-region");
+
+  DO_OK_CHECK(scheme_void)if (x2 < 0) x2 = 0;if (x3 < 0) x3 = 0;
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->SetClippingRegion(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDestroyClippingRegion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DestroyClippingRegion();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawPolygon(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  class wxPoint* x1;
+  float x2;
+  float x3;
+  int x4;
+
+  
+  x1 = NULL;
+  if (n > 1) {
+    x2 = objscheme_unbundle_float(p[1], "wx:dc%::draw-polygon");
+  } else
+    x2 = 0;
+  if (n > 2) {
+    x3 = objscheme_unbundle_float(p[2], "wx:dc%::draw-polygon");
+  } else
+    x3 = 0;
+  if (n > 3) {
+    x4 = objscheme_unbundle_integer(p[3], "wx:dc%::draw-polygon");
+  } else
+    x4 = wxODDEVEN_RULE;
+
+  DO_OK_CHECK(scheme_void)x1 = __MakewxPointArray((0 < n) ? p[0] : scheme_null, &x0, "wx:dc%::draw-polygon");
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawPolygon(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawLines(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  class wxPoint* x1;
+  float x2;
+  float x3;
+
+  
+  x1 = NULL;
+  if (n > 1) {
+    x2 = objscheme_unbundle_float(p[1], "wx:dc%::draw-lines");
+  } else
+    x2 = 0;
+  if (n > 2) {
+    x3 = objscheme_unbundle_float(p[2], "wx:dc%::draw-lines");
+  } else
+    x3 = 0;
+
+  DO_OK_CHECK(scheme_void)x1 = __MakewxPointArray((0 < n) ? p[0] : scheme_null, &x0, "wx:dc%::draw-lines");
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawLines(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawEllipse(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-ellipse");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-ellipse");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:dc%::draw-ellipse");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:dc%::draw-ellipse");
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawEllipse(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawArc(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-arc");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-arc");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::draw-arc");
+  x3 = objscheme_unbundle_float(p[3], "wx:dc%::draw-arc");
+  x4 = objscheme_unbundle_float(p[4], "wx:dc%::draw-arc");
+  x5 = objscheme_unbundle_float(p[5], "wx:dc%::draw-arc");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawArc(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  float x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:dc%::draw-text");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-text");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::draw-text");
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:dc%::draw-text");
+  } else
+    x3 = FALSE;
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawSpline(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-spline");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-spline");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::draw-spline");
+  x3 = objscheme_unbundle_float(p[3], "wx:dc%::draw-spline");
+  x4 = objscheme_unbundle_float(p[4], "wx:dc%::draw-spline");
+  x5 = objscheme_unbundle_float(p[5], "wx:dc%::draw-spline");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawSpline(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawRoundedRectangle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-rounded-rectangle");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-rounded-rectangle");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:dc%::draw-rounded-rectangle");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:dc%::draw-rounded-rectangle");
+  if (n > 4) {
+    x4 = objscheme_unbundle_float(p[4], "wx:dc%::draw-rounded-rectangle");
+  } else
+    x4 = 20;
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawRoundedRectangle(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawRectangle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  nnfloat x2;
+  nnfloat x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-rectangle");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-rectangle");
+  x2 = objscheme_unbundle_nonnegative_float(p[2], "wx:dc%::draw-rectangle");
+  x3 = objscheme_unbundle_nonnegative_float(p[3], "wx:dc%::draw-rectangle");
+
+  if (x2 <= 0) return scheme_void;if (x3 <= 0) return scheme_void;DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawRectangle(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-point");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-point");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawPoint(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCDrawLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:dc%::draw-line");
+  x1 = objscheme_unbundle_float(p[1], "wx:dc%::draw-line");
+  x2 = objscheme_unbundle_float(p[2], "wx:dc%::draw-line");
+  x3 = objscheme_unbundle_float(p[3], "wx:dc%::draw-line");
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->DrawLine(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCEndDrawing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->EndDrawing();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDCBeginDrawing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  DO_OK_CHECK(scheme_void)
+  ((wxDC *)((Scheme_Class_Object *)obj)->primdata)->BeginDrawing();
+
+  
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:dc%");
+}
+
+void objscheme_setup_wxDC(void *env)
+{
+if (os_wxDC_class) {
+    objscheme_add_global_class(os_wxDC_class,  "wx:dc%", env);
+} else {
+  os_wxDC_class = objscheme_def_prim_class(env, "wx:dc%", "wx:object%", NULL, 54);
+
+  scheme_add_method_w_arity(os_wxDC_class,"get-class-name",objscheme_classname_os_wxDC, 0, 0);
+
+ scheme_add_method_w_arity(os_wxDC_class, "end-page", os_wxDCEndPage, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "end-doc", os_wxDCEndDoc, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "start-page", os_wxDCStartPage, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "start-doc", os_wxDCStartDoc, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "ok?", os_wxDCOk, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "min-y", os_wxDCMinY, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "min-x", os_wxDCMinX, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "max-y", os_wxDCMaxY, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "max-x", os_wxDCMaxX, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-size", os_wxDCGetSize, 2, 2);
+ scheme_add_method_w_arity(os_wxDC_class, "get-text-foreground", os_wxDCGetTextForeground, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-text-background", os_wxDCGetTextBackground, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-pen", os_wxDCGetPen, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-map-mode", os_wxDCGetMapMode, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-logical-function", os_wxDCGetLogicalFunction, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-font", os_wxDCGetFont, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-brush", os_wxDCGetBrush, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-background", os_wxDCGetBackground, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "set-device-origin", os_wxDCSetDeviceOrigin, 2, 2);
+ scheme_add_method_w_arity(os_wxDC_class, "set-user-scale", os_wxDCSetUserScale, 2, 2);
+ scheme_add_method_w_arity(os_wxDC_class, "set-colour-map", os_wxDCSetColourMap, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-background-mode", os_wxDCSetBackgroundMode, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-map-mode", os_wxDCSetMapMode, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "try-colour", os_wxDCTryColour, 2, 2);
+ scheme_add_method_w_arity(os_wxDC_class, "blit", os_wxDCBlit, 7, 8);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-icon", os_wxDCDrawIcon, 3, 3);
+ scheme_add_method_w_arity(os_wxDC_class, "set-optimization", os_wxDCSetOptimization, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "get-char-width", os_wxDCGetCharWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-char-height", os_wxDCGetCharHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "get-text-extent", os_wxDCGetTextExtent, 3, 7);
+ scheme_add_method_w_arity(os_wxDC_class, "set-text-foreground", os_wxDCSetTextForeground, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-text-background", os_wxDCSetTextBackground, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-pen", os_wxDCSetPen, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-logical-function", os_wxDCSetLogicalFunction, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-font", os_wxDCSetFont, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-brush", os_wxDCSetBrush, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "set-background", os_wxDCSetBackground, 1, 1);
+ scheme_add_method_w_arity(os_wxDC_class, "get-clipping-region", os_wxDCGetClippingRegion, 4, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "set-clipping-region", os_wxDCSetClippingRegion, 4, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "destroy-clipping-region", os_wxDCDestroyClippingRegion, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-polygon", os_wxDCDrawPolygon, 1, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-lines", os_wxDCDrawLines, 1, 3);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-ellipse", os_wxDCDrawEllipse, 4, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-arc", os_wxDCDrawArc, 6, 6);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-text", os_wxDCDrawText, 3, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-spline", os_wxDCDrawSpline, 6, 6);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-rounded-rectangle", os_wxDCDrawRoundedRectangle, 4, 5);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-rectangle", os_wxDCDrawRectangle, 4, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-point", os_wxDCDrawPoint, 2, 2);
+ scheme_add_method_w_arity(os_wxDC_class, "draw-line", os_wxDCDrawLine, 4, 4);
+ scheme_add_method_w_arity(os_wxDC_class, "clear", os_wxDCClear, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "end-drawing", os_wxDCEndDrawing, 0, 0);
+ scheme_add_method_w_arity(os_wxDC_class, "begin-drawing", os_wxDCBeginDrawing, 0, 0);
+
+
+  scheme_made_class(os_wxDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxDC, wxTYPE_DC);
+
+}
+  scheme_install_xc_global("wx:const-oddeven-rule", scheme_make_integer(wxODDEVEN_RULE), env);
+  scheme_install_xc_global("wx:const-winding-rule", scheme_make_integer(wxWINDING_RULE), env);
+  scheme_install_xc_global("wx:const-and", scheme_make_integer(wxAND), env);
+  scheme_install_xc_global("wx:const-and-invert", scheme_make_integer(wxAND_INVERT), env);
+  scheme_install_xc_global("wx:const-and-reverse", scheme_make_integer(wxAND_REVERSE), env);
+  scheme_install_xc_global("wx:const-clear", scheme_make_integer(wxCLEAR), env);
+  scheme_install_xc_global("wx:const-copy", scheme_make_integer(wxCOPY), env);
+  scheme_install_xc_global("wx:const-equiv", scheme_make_integer(wxEQUIV), env);
+  scheme_install_xc_global("wx:const-invert", scheme_make_integer(wxINVERT), env);
+  scheme_install_xc_global("wx:const-nand", scheme_make_integer(wxNAND), env);
+  scheme_install_xc_global("wx:const-nor", scheme_make_integer(wxNOR), env);
+  scheme_install_xc_global("wx:const-no-op", scheme_make_integer(wxNO_OP), env);
+  scheme_install_xc_global("wx:const-or", scheme_make_integer(wxOR), env);
+  scheme_install_xc_global("wx:const-or-invert", scheme_make_integer(wxOR_INVERT), env);
+  scheme_install_xc_global("wx:const-or-reverse", scheme_make_integer(wxOR_REVERSE), env);
+  scheme_install_xc_global("wx:const-set", scheme_make_integer(wxSET), env);
+  scheme_install_xc_global("wx:const-src-invert", scheme_make_integer(wxSRC_INVERT), env);
+  scheme_install_xc_global("wx:const-xor", scheme_make_integer(wxXOR), env);
+  scheme_install_xc_global("wx:const-colour", scheme_make_integer(wxCOLOR), env);
+  scheme_install_xc_global("wx:const-mm-twips", scheme_make_integer(MM_TWIPS), env);
+  scheme_install_xc_global("wx:const-mm-points", scheme_make_integer(MM_POINTS), env);
+  scheme_install_xc_global("wx:const-mm-metric", scheme_make_integer(MM_METRIC), env);
+  scheme_install_xc_global("wx:const-mm-lometric", scheme_make_integer(MM_LOMETRIC), env);
+  scheme_install_xc_global("wx:const-mm-text", scheme_make_integer(MM_TEXT), env);
+}
+
+int objscheme_istype_wxDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxDC(class wxDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxDC *objscheme_unbundle_wxDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxDC *)o->primdata;
+  else
+    return (wxDC *)o->primdata;
+}
+
+
+
+
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+
+
+class os_wxCanvasDC : public wxCanvasDC {
+ public:
+
+  os_wxCanvasDC(Scheme_Object * obj);
+  ~os_wxCanvasDC();
+};
+
+Scheme_Object *os_wxCanvasDC_class;
+
+os_wxCanvasDC::os_wxCanvasDC(Scheme_Object * o)
+: wxCanvasDC()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCanvasDC::~os_wxCanvasDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDCSetPixel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  class wxColour* x2;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas-dc%::set-pixel");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas-dc%::set-pixel");
+  x2 = objscheme_unbundle_wxColour(p[2], "wx:canvas-dc%::set-pixel", 1);
+
+  
+  ((wxCanvasDC *)((Scheme_Class_Object *)obj)->primdata)->SetPixel(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDCEndSetPixel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxCanvasDC *)((Scheme_Class_Object *)obj)->primdata)->EndSetPixel();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDCBeginSetPixel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxCanvasDC *)((Scheme_Class_Object *)obj)->primdata)->BeginSetPixel();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDCGetPixel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  class wxColour* x2;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:canvas-dc%::get-pixel");
+  x1 = objscheme_unbundle_float(p[1], "wx:canvas-dc%::get-pixel");
+  x2 = objscheme_unbundle_wxColour(p[2], "wx:canvas-dc%::get-pixel", 1);
+
+  
+  r = ((wxCanvasDC *)((Scheme_Class_Object *)obj)->primdata)->GetPixel(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasDC_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxCanvasDC *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:canvas-dc%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxCanvasDC(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxCanvasDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:canvas-dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:canvas-dc%");
+}
+
+void objscheme_setup_wxCanvasDC(void *env)
+{
+if (os_wxCanvasDC_class) {
+    objscheme_add_global_class(os_wxCanvasDC_class,  "wx:canvas-dc%", env);
+} else {
+  os_wxCanvasDC_class = objscheme_def_prim_class(env, "wx:canvas-dc%", "wx:dc%", os_wxCanvasDC_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxCanvasDC_class,"get-class-name",objscheme_classname_os_wxCanvasDC, 0, 0);
+
+ scheme_add_method_w_arity(os_wxCanvasDC_class, "set-pixel", os_wxCanvasDCSetPixel, 3, 3);
+ scheme_add_method_w_arity(os_wxCanvasDC_class, "end-set-pixel", os_wxCanvasDCEndSetPixel, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvasDC_class, "begin-set-pixel", os_wxCanvasDCBeginSetPixel, 0, 0);
+ scheme_add_method_w_arity(os_wxCanvasDC_class, "get-pixel", os_wxCanvasDCGetPixel, 3, 3);
+
+
+  scheme_made_class(os_wxCanvasDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxCanvasDC, wxTYPE_DC_CANVAS);
+
+}
+}
+
+int objscheme_istype_wxCanvasDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCanvasDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:canvas-dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCanvasDC(class wxCanvasDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC_CANVAS) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCanvasDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCanvasDC *objscheme_unbundle_wxCanvasDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCanvasDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCanvasDC *)o->primdata;
+  else
+    return (wxCanvasDC *)o->primdata;
+}
+
+
+
+
+
+
+
+class os_wxMemoryDC : public wxMemoryDC {
+ public:
+
+  os_wxMemoryDC(Scheme_Object * obj);
+  os_wxMemoryDC(Scheme_Object * obj, class wxCanvasDC* x0);
+  ~os_wxMemoryDC();
+};
+
+Scheme_Object *os_wxMemoryDC_class;
+
+os_wxMemoryDC::os_wxMemoryDC(Scheme_Object * o)
+: wxMemoryDC()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMemoryDC::os_wxMemoryDC(Scheme_Object * o, class wxCanvasDC* x0)
+: wxMemoryDC(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMemoryDC::~os_wxMemoryDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMemoryDCSelectObject(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBitmap* x0;
+
+  
+  x0 = objscheme_unbundle_wxBitmap(p[0], "wx:memory-dc%::select-object", 1);
+
+  
+  ((wxMemoryDC *)((Scheme_Class_Object *)obj)->primdata)->SelectObject(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMemoryDC_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMemoryDC *realobj;
+  if ((n >= 1) && objscheme_istype_wxCanvasDC(p[0], NULL, 0)) {
+    class wxCanvasDC* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:memory-dc%::initialization (wx:canvas-dc% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxCanvasDC(p[0], "wx:memory-dc%::initialization (wx:canvas-dc% case)", 0);
+
+    
+    realobj = new os_wxMemoryDC(obj, x0);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:memory-dc%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxMemoryDC(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMemoryDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:memory-dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:memory-dc%");
+}
+
+void objscheme_setup_wxMemoryDC(void *env)
+{
+if (os_wxMemoryDC_class) {
+    objscheme_add_global_class(os_wxMemoryDC_class,  "wx:memory-dc%", env);
+} else {
+  os_wxMemoryDC_class = objscheme_def_prim_class(env, "wx:memory-dc%", "wx:canvas-dc%", os_wxMemoryDC_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxMemoryDC_class,"get-class-name",objscheme_classname_os_wxMemoryDC, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMemoryDC_class, "select-object", os_wxMemoryDCSelectObject, 1, 1);
+
+
+  scheme_made_class(os_wxMemoryDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMemoryDC, wxTYPE_DC_MEMORY);
+
+}
+}
+
+int objscheme_istype_wxMemoryDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMemoryDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:memory-dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMemoryDC(class wxMemoryDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC_MEMORY) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMemoryDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMemoryDC *objscheme_unbundle_wxMemoryDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMemoryDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMemoryDC *)o->primdata;
+  else
+    return (wxMemoryDC *)o->primdata;
+}
+
+
+
+
+
+
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+class os_wxPostScriptDC : public wxPostScriptDC {
+ public:
+
+  os_wxPostScriptDC(Scheme_Object * obj, npathname x0, Bool x1 = TRUE, class wxWindow* x2 = NULL);
+  ~os_wxPostScriptDC();
+};
+
+Scheme_Object *os_wxPostScriptDC_class;
+
+os_wxPostScriptDC::os_wxPostScriptDC(Scheme_Object * o, npathname x0, Bool x1, class wxWindow* x2)
+: wxPostScriptDC(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPostScriptDC::~os_wxPostScriptDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPostScriptDC_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxPostScriptDC *realobj;
+  npathname x0;
+  Bool x1;
+  class wxWindow* x2;
+
+  
+  if ((n < 1) ||(n > 3)) 
+    scheme_wrong_count("wx:post-script-dc%::initialization", 1, 3, n, p);
+  x0 = (npathname)objscheme_unbundle_nullable_pathname(p[0], "wx:post-script-dc%::initialization");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:post-script-dc%::initialization");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_wxWindow(p[2], "wx:post-script-dc%::initialization", 1);
+  } else
+    x2 = NULL;
+
+  if (x2 && !wxSubType(((wxObject *)x2)->__type, wxTYPE_FRAME) && !wxSubType(((wxObject *)x2)->__type, wxTYPE_DIALOG_BOX)) scheme_wrong_type("wx:post-script-dc::initialization", "frame or dialog box", 2, n, p);
+  realobj = new os_wxPostScriptDC(obj, x0, x1, x2);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxPostScriptDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:post-script-dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:post-script-dc%");
+}
+
+void objscheme_setup_wxPostScriptDC(void *env)
+{
+if (os_wxPostScriptDC_class) {
+    objscheme_add_global_class(os_wxPostScriptDC_class,  "wx:post-script-dc%", env);
+} else {
+  os_wxPostScriptDC_class = objscheme_def_prim_class(env, "wx:post-script-dc%", "wx:dc%", os_wxPostScriptDC_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_wxPostScriptDC_class,"get-class-name",objscheme_classname_os_wxPostScriptDC, 0, 0);
+
+
+
+  scheme_made_class(os_wxPostScriptDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxPostScriptDC, wxTYPE_DC_POSTSCRIPT);
+
+}
+}
+
+int objscheme_istype_wxPostScriptDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxPostScriptDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:post-script-dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxPostScriptDC(class wxPostScriptDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC_POSTSCRIPT) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxPostScriptDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxPostScriptDC *objscheme_unbundle_wxPostScriptDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxPostScriptDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxPostScriptDC *)o->primdata;
+  else
+    return (wxPostScriptDC *)o->primdata;
+}
+
+
+#ifdef wx_x
+
+class basePrinterDC : public wxObject
+{
+public:
+  basePrinterDC(char *, char *, char *, Bool = TRUE)
+  {
+    scheme_signal_error("wx:printer-dc%::initialization: not supported for X Windows");
+  }
+};
+
+#else
+
+class basePrinterDC : public wxPrinterDC
+{
+public:
+  basePrinterDC(char *a, char *b, char *c, Bool d = TRUE)
+    : wxPrinterDC(
+#ifndef wx_mac
+		  a, b, c, d
+#endif
+		  )
+  {
+  }
+};
+
+#endif
+
+
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+
+class os_basePrinterDC : public basePrinterDC {
+ public:
+
+  os_basePrinterDC(Scheme_Object * obj, nstring x0, nstring x1, nstring x2, Bool x3 = TRUE);
+  ~os_basePrinterDC();
+};
+
+Scheme_Object *os_basePrinterDC_class;
+
+os_basePrinterDC::os_basePrinterDC(Scheme_Object * o, nstring x0, nstring x1, nstring x2, Bool x3)
+: basePrinterDC(x0, x1, x2, x3)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_basePrinterDC::~os_basePrinterDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_basePrinterDC_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_basePrinterDC *realobj;
+  nstring x0;
+  nstring x1;
+  nstring x2;
+  Bool x3;
+
+  
+  if ((n < 3) ||(n > 4)) 
+    scheme_wrong_count("wx:printer-dc%::initialization", 3, 4, n, p);
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:printer-dc%::initialization");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:printer-dc%::initialization");
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:printer-dc%::initialization");
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:printer-dc%::initialization");
+  } else
+    x3 = TRUE;
+
+  
+  realobj = new os_basePrinterDC(obj, x0, x1, x2, x3);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_basePrinterDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:printer-dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:printer-dc%");
+}
+
+void objscheme_setup_basePrinterDC(void *env)
+{
+if (os_basePrinterDC_class) {
+    objscheme_add_global_class(os_basePrinterDC_class,  "wx:printer-dc%", env);
+} else {
+  os_basePrinterDC_class = objscheme_def_prim_class(env, "wx:printer-dc%", "wx:dc%", os_basePrinterDC_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_basePrinterDC_class,"get-class-name",objscheme_classname_os_basePrinterDC, 0, 0);
+
+
+
+  scheme_made_class(os_basePrinterDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_basePrinterDC, wxTYPE_DC_PRINTER);
+
+}
+}
+
+int objscheme_istype_basePrinterDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_basePrinterDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:printer-dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_basePrinterDC(class basePrinterDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC_PRINTER) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_basePrinterDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class basePrinterDC *objscheme_unbundle_basePrinterDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_basePrinterDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_basePrinterDC *)o->primdata;
+  else
+    return (basePrinterDC *)o->primdata;
+}
+
+
+
+#ifdef wx_msw
+
+class baseMetaFileDC : public wxMetaFileDC {
+public:
+  baseMetaFileDC(char *s = NULL);
+};
+
+baseMetaFileDC::baseMetaFileDC(char *s)
+    : wxMetaFileDC(s)
+{
+}
+
+#else
+
+class baseMetaFileDC : public wxObject 
+{
+public:
+  baseMetaFileDC(char * = NULL) {
+    scheme_signal_error("wx:meta-file-dc%::initialization: only supported for Windows");
+  }
+};
+
+#endif
+
+
+
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+class os_baseMetaFileDC : public baseMetaFileDC {
+ public:
+
+  os_baseMetaFileDC(Scheme_Object * obj, string x0 = NULL);
+  ~os_baseMetaFileDC();
+};
+
+Scheme_Object *os_baseMetaFileDC_class;
+
+os_baseMetaFileDC::os_baseMetaFileDC(Scheme_Object * o, string x0)
+: baseMetaFileDC(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_baseMetaFileDC::~os_baseMetaFileDC()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_baseMetaFileDC_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_baseMetaFileDC *realobj;
+  string x0;
+
+  
+  if ((n > 1)) 
+    scheme_wrong_count("wx:meta-file-dc%::initialization", 0, 1, n, p);
+  if (n > 0) {
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:meta-file-dc%::initialization");
+  } else
+    x0 = NULL;
+
+  
+  realobj = new os_baseMetaFileDC(obj, x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_baseMetaFileDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:meta-file-dc%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:meta-file-dc%");
+}
+
+void objscheme_setup_baseMetaFileDC(void *env)
+{
+if (os_baseMetaFileDC_class) {
+    objscheme_add_global_class(os_baseMetaFileDC_class,  "wx:meta-file-dc%", env);
+} else {
+  os_baseMetaFileDC_class = objscheme_def_prim_class(env, "wx:meta-file-dc%", "wx:dc%", os_baseMetaFileDC_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_baseMetaFileDC_class,"get-class-name",objscheme_classname_os_baseMetaFileDC, 0, 0);
+
+
+
+  scheme_made_class(os_baseMetaFileDC_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_baseMetaFileDC, wxTYPE_DC_METAFILE);
+
+}
+}
+
+int objscheme_istype_baseMetaFileDC(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_baseMetaFileDC_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:meta-file-dc%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_baseMetaFileDC(class baseMetaFileDC *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DC_METAFILE) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_baseMetaFileDC_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class baseMetaFileDC *objscheme_unbundle_baseMetaFileDC(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_baseMetaFileDC(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_baseMetaFileDC *)o->primdata;
+  else
+    return (baseMetaFileDC *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_dc.h b/src/mred/wxs/wxs_dc.h
new file mode 100644
index 0000000..751294e
--- /dev/null
+++ b/src/mred/wxs/wxs_dc.h
@@ -0,0 +1,62 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxPen(class wxPen *);
+extern Scheme_Object *objscheme_bundle_wxFont(class wxFont *);
+extern Scheme_Object *objscheme_bundle_wxBrush(class wxBrush *);
+extern Scheme_Object *objscheme_bundle_wxBrush(class wxBrush *);
+extern class wxColourMap *objscheme_unbundle_wxColourMap(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxCanvasDC *objscheme_unbundle_wxCanvasDC(Scheme_Object *, const char *, int);
+extern class wxIcon *objscheme_unbundle_wxIcon(Scheme_Object *, const char *, int);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxPen *objscheme_unbundle_wxPen(Scheme_Object *, const char *, int);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *, const char *, int);
+extern class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxDC(class wxDC *realobj);
+class wxDC *objscheme_unbundle_wxDC(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxCanvasDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCanvasDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCanvasDC(class wxCanvasDC *realobj);
+class wxCanvasDC *objscheme_unbundle_wxCanvasDC(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxCanvasDC(Scheme_Object *, const char *, int);
+extern class wxCanvasDC *objscheme_unbundle_wxCanvasDC(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMemoryDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMemoryDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMemoryDC(class wxMemoryDC *realobj);
+class wxMemoryDC *objscheme_unbundle_wxMemoryDC(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxPostScriptDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxPostScriptDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxPostScriptDC(class wxPostScriptDC *realobj);
+class wxPostScriptDC *objscheme_unbundle_wxPostScriptDC(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_basePrinterDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_basePrinterDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_basePrinterDC(class basePrinterDC *realobj);
+class basePrinterDC *objscheme_unbundle_basePrinterDC(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_baseMetaFileDC(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_baseMetaFileDC(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_baseMetaFileDC(class baseMetaFileDC *realobj);
+class baseMetaFileDC *objscheme_unbundle_baseMetaFileDC(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_dc.xc b/src/mred/wxs/wxs_dc.xc
new file mode 100644
index 0000000..4ffdd5b
--- /dev/null
+++ b/src/mred/wxs/wxs_dc.xc
@@ -0,0 +1,247 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_dccan.h"
+#include "wx_dcmem.h"
+#include "wx_dcps.h"
+#ifndef wx_mac
+#include "wx_dcpan.h"
+#endif
+#ifdef wx_msw
+#include "wx_mf.h"
+#endif
+#include "wx_types.h"
+#ifdef wx_mac
+#include "wx_dcpr.h"
+#endif
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxDC "wx:dc":"wx:object"
+
+@CLASSID wxTYPE_DC
+
+@SETMARK Q = U
+// "U" for undefined (pure virtual); don't think we'll need it
+// @SETMARK q = v
+@INCLUDE wxs_draw.xci
+
+// Also in wxWindow:
+@ Q "get-text-extent" : void GetTextExtent(string,float*,float*,float?=NULL,float?=NULL,wxFont^=NULL,bool=FALSE); : : /CheckOk
+@ Q "get-char-height" : float GetCharHeight();
+@ Q "get-char-width" : float GetCharWidth();
+
+@MACRO rZERO = return 0;
+@MACRO rFALSE = return FALSE;
+
+#ifndef wx_mac
+#define HIDETHISSTATEMENT(x) x
+#else
+#define HIDETHISSTATEMENT(x) 
+#endif
+
+@MACRO IFNOTMAC = HIDETHISSTATEMENT(
+@MACRO ENDIF = )
+
+@ "set-optimization" : void SetOptimization(bool); : : /IFNOTMAC/ENDIF/
+
+#ifndef wx_mac
+#define CHECKTHISONE(x) x
+#else
+#define CHECKTHISONE(x) 1
+#endif
+
+@MACRO CheckIcon[p] = if (!CHECKTHISONE(x<p>->Ok())) return scheme_void;
+
+@ Q "draw-icon" : void DrawIcon(wxIcon!,float,float); : : /CheckOk|CheckIcon[0]
+
+@ Q "blit" : bool Blit(float,float,float,float,wxCanvasDC!,float,float,int=wxCOPY); : : /CheckLogicalFunc[7.wxCOLOR."wx:dc::blit"]|CheckOkFalse|CheckFalse[4] : : rFALSE
+
+@ Q "try-colour" : void TryColour(wxColour!,wxColour!);
+
+@ Q "set-map-mode" : void SetMapMode(int); : : /CheckOk
+@ Q "set-background-mode" : void SetBackgroundMode(int); :  : /CheckOk
+@ q "set-colour-map" : void SetColourMap(wxColourMap!); : : /CheckOk
+@ Q "set-user-scale" : void SetUserScale(nnfloat,nnfloat); : : /CheckOk
+@ Q "set-device-origin" : void SetDeviceOrigin(float,float); : : /CheckOk
+
+@ q "get-background" : wxBrush! GetBackground();
+@ q "get-brush" : wxBrush! GetBrush();
+@ q "get-font" : wxFont! GetFont();
+@ q "get-logical-function" : int GetLogicalFunction();
+@ q "get-map-mode" : int GetMapMode();
+@ q "get-pen" : wxPen! GetPen();
+@ q "get-text-background" : wxColour% GetTextBackground();
+@ q "get-text-foreground" : wxColour% GetTextForeground();
+
+@ q "get-size" : void GetSize(float*,float*);
+
+// @ Q "device-to-logical-x" : float DeviceToLogicalX(int); : : : rZERO
+// @ Q "device-to-logical-y" : float DeviceToLogicalY(int); : : : rZERO
+// @ Q "logical-to-device-x" : float LogicalToDeviceX(int); : : : rZERO
+// @ Q "logical-to-device-y" : float LogicalToDeviceY(int); : : : rZERO
+
+@ q "max-x" : float MaxX();
+@ q "max-y" : float MaxY();
+@ q "min-x" : float MinX();
+@ q "min-y" : float MinY();
+
+@ q "ok?" : bool Ok();
+
+@ Q "start-doc" : bool StartDoc(string); : : : rFALSE
+@ Q "start-page" : void StartPage();
+@ Q "end-doc" : void EndDoc();
+@ Q "end-page" : void EndPage();
+
+@CONSTANT "wx:const-oddeven-rule" : int wxODDEVEN_RULE
+@CONSTANT "wx:const-winding-rule" : int wxWINDING_RULE
+
+@CONSTANT "wx:const-and" : int wxAND
+@CONSTANT "wx:const-and-invert" : int wxAND_INVERT
+@CONSTANT "wx:const-and-reverse" : int wxAND_REVERSE
+@CONSTANT "wx:const-clear" : int wxCLEAR
+@CONSTANT "wx:const-copy" : int wxCOPY
+@CONSTANT "wx:const-equiv" : int wxEQUIV
+@CONSTANT "wx:const-invert" : int wxINVERT
+@CONSTANT "wx:const-nand" : int wxNAND
+@CONSTANT "wx:const-nor" : int wxNOR
+@CONSTANT "wx:const-no-op" : int wxNO_OP
+@CONSTANT "wx:const-or" : int wxOR
+@CONSTANT "wx:const-or-invert" : int wxOR_INVERT
+@CONSTANT "wx:const-or-reverse" : int wxOR_REVERSE
+@CONSTANT "wx:const-set" : int wxSET
+@CONSTANT "wx:const-src-invert" : int wxSRC_INVERT
+@CONSTANT "wx:const-xor" : int wxXOR
+@CONSTANT "wx:const-colour" : int wxCOLOR
+
+@CONSTANT "wx:const-mm-twips" : int MM_TWIPS
+@CONSTANT "wx:const-mm-points" : int MM_POINTS
+@CONSTANT "wx:const-mm-metric" : int MM_METRIC
+@CONSTANT "wx:const-mm-lometric" : int MM_LOMETRIC
+@CONSTANT "wx:const-mm-text" : int MM_TEXT
+
+@END
+
+@CLASSBASE wxCanvasDC "wx:canvas-dc":"wx:dc"
+
+@CLASSID wxTYPE_DC_CANVAS
+
+@CREATOR ();
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+@ "get-pixel" : bool GetPixel(float,float,wxColour^)
+
+@ "begin-set-pixel" : void BeginSetPixel()
+@ "end-set-pixel" : void EndSetPixel()
+@ "set-pixel" : void SetPixel(float,float,wxColour^)
+
+@END
+
+
+@CLASSBASE wxMemoryDC "wx:memory-dc":"wx:canvas-dc"
+
+@CLASSID wxTYPE_DC_MEMORY
+
+@CREATOR (); <> no argument
+@CREATOR (wxCanvasDC!); <> wx:canvas-dc%
+
+@ "select-object" : void SelectObject(wxBitmap^);
+
+@END
+
+@CLASSBASE wxPostScriptDC "wx:post-script-dc":"wx:dc"
+
+@CLASSID wxTYPE_DC_POSTSCRIPT
+
+@INCLUDE wxs_dorf.xci
+
+@CREATOR (npathname,bool=TRUE,wxWindow^=NULL); : : /DLGORFRAME[2."wx:post-script-dc::initialization"]
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+@END
+
+#ifdef wx_x
+
+class basePrinterDC : public wxObject
+{
+public:
+  basePrinterDC(char *, char *, char *, Bool = TRUE)
+  {
+    scheme_signal_error("wx:printer-dc%::initialization: not supported for X Windows");
+  }
+};
+
+#else
+
+class basePrinterDC : public wxPrinterDC
+{
+public:
+  basePrinterDC(char *a, char *b, char *c, Bool d = TRUE)
+    : wxPrinterDC(
+#ifndef wx_mac
+		  a, b, c, d
+#endif
+		  )
+  {
+  }
+};
+
+#endif
+
+@CLASSBASE basePrinterDC "wx:printer-dc":"wx:dc"
+
+@CLASSID wxTYPE_DC_PRINTER
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+@CREATOR (nstring,nstring,nstring,bool=TRUE);
+
+@END
+
+
+#ifdef wx_msw
+
+class baseMetaFileDC : public wxMetaFileDC {
+public:
+  baseMetaFileDC(char *s = NULL);
+};
+
+baseMetaFileDC::baseMetaFileDC(char *s)
+    : wxMetaFileDC(s)
+{
+}
+
+#else
+
+class baseMetaFileDC : public wxObject 
+{
+public:
+  baseMetaFileDC(char * = NULL) {
+    scheme_signal_error("wx:meta-file-dc%::initialization: only supported for Windows");
+  }
+};
+
+#endif
+
+@CLASSBASE baseMetaFileDC "wx:meta-file-dc":"wx:dc"
+
+@CLASSID wxTYPE_DC_METAFILE
+
+@CREATOR (string=NULL);
+
+// @SETMARK Q = d
+// @SETMARK q = d
+// @INCLUDE wxs_drwf.xci
+
+@END
+
diff --git a/src/mred/wxs/wxs_dorf.xci b/src/mred/wxs/wxs_dorf.xci
new file mode 100644
index 0000000..7439fb9
--- /dev/null
+++ b/src/mred/wxs/wxs_dorf.xci
@@ -0,0 +1,2 @@
+
+@MACRO DLGORFRAME[f.n] = if (x<f> && !wxSubType(((wxObject *)x<f>)->__type, wxTYPE_FRAME) && !wxSubType(((wxObject *)x<f>)->__type, wxTYPE_DIALOG_BOX)) scheme_wrong_type(<n>, "frame or dialog box", <f>, n, p);
diff --git a/src/mred/wxs/wxs_draw.xci b/src/mred/wxs/wxs_draw.xci
new file mode 100644
index 0000000..d1b5896
--- /dev/null
+++ b/src/mred/wxs/wxs_draw.xci
@@ -0,0 +1,34 @@
+
+#undef DO_OK_CHECK
+#ifdef DrawsForCanvas
+#define DO_OK_CHECK(v)
+#else
+#define DO_OK_CHECK(v) if (!((wxDC *)((Scheme_Class_Object *)obj)->primdata)->Ok()) return v;
+#endif
+
+@MACRO CheckLogicalFunc[p.v.n] = switch (x<p>) { case wxAND: case wxAND_INVERT: case wxAND_REVERSE: case wxCLEAR: case wxCOPY: case wxEQUIV: case wxINVERT: case wxNAND: case wxNOR: case wxNO_OP: case wxOR: case wxOR_INVERT: case wxOR_REVERSE: case wxSET: case wxSRC_INVERT: case wxXOR: break; case wxCOLOR: if (x<p> == <v>) break; default: scheme_wrong_type(<n>, "logicalfunction integer", <p>, n, p); }
+
+@MACRO CheckOkGen[ret] = DO_OK_CHECK(<ret>)
+@MACRO CheckGen[p.ret] = if (!x<p>->Ok()) return <ret>;
+@MACRO CheckOk = $$CheckOkGen[scheme_void]
+@MACRO Check[p] = $$CheckGen[<p>.scheme_void]
+@MACRO CheckOkFalse = $$CheckOkGen[scheme_false]
+@MACRO CheckFalse[p] = $$CheckGen[<p>.scheme_false]
+
+extern Scheme_Object *objscheme_bundle_wxPoint(wxPoint *);
+extern wxPoint *objscheme_unbundle_wxPoint(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxIntPoint(wxIntPoint *);
+extern wxIntPoint *objscheme_unbundle_wxIntPoint(Scheme_Object *, const char *, int);
+
+@SET TYPE = wxPoint
+@SET INDIRECT = 1
+@SET POINTWISE = 1
+@INCLUDE list.xci
+
+@SET TYPE = wxIntPoint
+@SET INDIRECT = 1
+@SET POINTWISE = 1
+@INCLUDE list.xci
+
+/* The methods are here: */
+@INCLUDE wxs_drwf.xci
diff --git a/src/mred/wxs/wxs_drwf.xci b/src/mred/wxs/wxs_drwf.xci
new file mode 100644
index 0000000..626e3ef
--- /dev/null
+++ b/src/mred/wxs/wxs_drwf.xci
@@ -0,0 +1,38 @@
+
+@MACRO ZeroReturn[p] = if (x<p> <= 0) return scheme_void;
+@MACRO ZeroBoundary[p] = if (x<p> < 0) x<p> = 0;
+
+@ q "begin-drawing" : void BeginDrawing(); : : /CheckOk
+@ q "end-drawing" : void EndDrawing(); : : /CheckOk
+
+@ Q "clear" : void Clear(); : : /CheckOk
+
+@ Q "draw-line" : void DrawLine(float,float,float,float); : : /CheckOk
+// @ Q "int-draw-line" : void IntDrawLine(int,int,int,int); : : /CheckOk
+@ Q "draw-point" : void DrawPoint(float,float); : : /CheckOk
+@ Q "draw-rectangle" : void DrawRectangle(float,float,nnfloat,nnfloat); : : /ZeroReturn[2]|ZeroReturn[3]|CheckOk
+@ Q "draw-rounded-rectangle" : void DrawRoundedRectangle(float,float,nnfloat,nnfloat,float=20); : : /ZeroReturn[2]|ZeroReturn[3]|CheckOk
+// @ q "draw-spline" : void DrawSpline(wxList!); : : /CheckOk
+@ q "draw-spline" : void DrawSpline(float,float,float,float,float,float); : : /CheckOk
+@ Q "draw-text" : void DrawText(string,float,float,bool=FALSE); : : /CheckOk
+
+@ Q "draw-arc" : void DrawArc(float,float,float,float,float,float); : : /CheckOk
+@ Q "draw-ellipse" : void DrawEllipse(float,float,nnfloat,nnfloat); : : /ZeroReturn[2]|ZeroReturn[3]|CheckOk
+
+@ Q "draw-lines" : void DrawLines(-int,wxPoint!/bList/ubList/cList,float=0,float=0); : /methListSet[wxPoint.0.1.0]// : / CheckOk|glueListSet[wxPoint.0.1.0."wx:dc%::draw-lines"]//
+@ Q "draw-polygon" : void DrawPolygon(-int,wxPoint!/bList/ubList/cList,float=0,float=0,int=wxODDEVEN_RULE); : / methListSet[wxPoint.0.1.0]// : /CheckOk|glueListSet[wxPoint.0.1.0."wx:dc%::draw-polygon"]//
+
+// Undefined?
+//@ "int-draw-lines" : void IntDrawLines(-int,wxIntPoint!/bList/ubList/cList,float=0,float=0); : / methListSet[wxIntPoint.0.1.0]// : /CheckOk|glueListSet[wxIntPoint.0.1.0]//
+
+@ Q "destroy-clipping-region" : void DestroyClippingRegion(); : : /CheckOk
+@ Q "set-clipping-region" : void SetClippingRegion(float,float,nnfloat,nnfloat); : : /CheckOk|ZeroBoundary[2]|ZeroBoundary[3]
+@ Q "get-clipping-region" : void GetClippingRegion(float*,float*,float*,float*);
+
+@ Q "set-background" : void SetBackground(wxBrush!); : : /CheckOk
+@ Q "set-brush" : void SetBrush(wxBrush!); : : /CheckOk
+@ Q "set-font" : void SetFont(wxFont!); : : /CheckOk
+@ Q "set-logical-function" : void SetLogicalFunction(int); : : /CheckLogicalFunc[0.wxCOPY."wx:dc::set-logical-function"]|CheckOk
+@ Q "set-pen" : void SetPen(wxPen!); : : /CheckOk
+@ q "set-text-background" : void SetTextBackground(wxColour!); : : /CheckOk
+@ q "set-text-foreground" : void SetTextForeground(wxColour!); : : /CheckOk
diff --git a/src/mred/wxs/wxs_evnt.cxx b/src/mred/wxs/wxs_evnt.cxx
new file mode 100644
index 0000000..27b6686
--- /dev/null
+++ b/src/mred/wxs/wxs_evnt.cxx
@@ -0,0 +1,1671 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_evnt.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_stdev.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_evnt.h"
+#include "wxscomon.h"
+
+
+#if !defined(wx_mac)
+#define NEW_EVENT_IDS 1
+#else
+#define NEW_EVENT_IDS 0
+#endif
+
+
+// @CREATOR ()
+
+// These are not ready to be used:
+// @ H "write-event" : bool WriteEvent(ostream%);
+// @ H "read-event" : bool ReadEvent(istream%);
+
+
+// Don't know where else to put these:
+
+
+class os_wxEvent : public wxEvent {
+ public:
+
+  ~os_wxEvent();
+};
+
+Scheme_Object *os_wxEvent_class;
+
+os_wxEvent::~os_wxEvent()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+static Scheme_Object *objscheme_wxEvent_GeteventClass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-event-class", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxEvent *)cobj->primdata)->wxEvent::eventClass;
+  else
+    v = ((wxEvent *)cobj->primdata)->eventClass;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxEvent_SeteventClass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-event-class", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:event%::event-class");
+  ((wxEvent *)cobj->primdata)->eventClass = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxEvent_GeteventType(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-event-type", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxEvent *)cobj->primdata)->wxEvent::eventType;
+  else
+    v = ((wxEvent *)cobj->primdata)->eventType;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxEvent_SeteventType(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-event-type", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:event%::event-type");
+  ((wxEvent *)cobj->primdata)->eventType = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxEvent_GeteventObject(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxObject* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-event-object", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxEvent *)cobj->primdata)->wxEvent::eventObject;
+  else
+    v = ((wxEvent *)cobj->primdata)->eventObject;
+
+  return objscheme_bundle_wxObject(v);
+}
+
+static Scheme_Object *objscheme_wxEvent_SeteventObject(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  class wxObject* v;
+
+  if (n != 1) scheme_wrong_count("set-event-object", 1, 1, n, p);
+
+  v = objscheme_unbundle_wxObject(p[0], "wx:event%::event-object", 0);
+  ((wxEvent *)cobj->primdata)->eventObject = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:event%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:event%");
+}
+
+void objscheme_setup_wxEvent(void *env)
+{
+if (os_wxEvent_class) {
+    objscheme_add_global_class(os_wxEvent_class,  "wx:event%", env);
+} else {
+  os_wxEvent_class = objscheme_def_prim_class(env, "wx:event%", "wx:object%", NULL, 7);
+
+  scheme_add_method_w_arity(os_wxEvent_class,"get-class-name",objscheme_classname_os_wxEvent, 0, 0);
+
+
+  scheme_add_method_w_arity(os_wxEvent_class,"get-event-class", objscheme_wxEvent_GeteventClass, 0, 0);
+  scheme_add_method_w_arity(os_wxEvent_class,"set-event-class", objscheme_wxEvent_SeteventClass, 1, 1);
+  scheme_add_method_w_arity(os_wxEvent_class,"get-event-type", objscheme_wxEvent_GeteventType, 0, 0);
+  scheme_add_method_w_arity(os_wxEvent_class,"set-event-type", objscheme_wxEvent_SeteventType, 1, 1);
+  scheme_add_method_w_arity(os_wxEvent_class,"get-event-object", objscheme_wxEvent_GeteventObject, 0, 0);
+  scheme_add_method_w_arity(os_wxEvent_class,"set-event-object", objscheme_wxEvent_SeteventObject, 1, 1);
+
+  scheme_made_class(os_wxEvent_class);
+
+
+}
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-top", scheme_make_integer(wxEVENT_TYPE_SCROLL_TOP), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-bottom", scheme_make_integer(wxEVENT_TYPE_SCROLL_BOTTOM), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-lineup", scheme_make_integer(wxEVENT_TYPE_SCROLL_LINEUP), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-linedown", scheme_make_integer(wxEVENT_TYPE_SCROLL_LINEDOWN), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-pageup", scheme_make_integer(wxEVENT_TYPE_SCROLL_PAGEUP), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-pagedown", scheme_make_integer(wxEVENT_TYPE_SCROLL_PAGEDOWN), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scroll-thumbtrack", scheme_make_integer(wxEVENT_TYPE_SCROLL_THUMBTRACK), env);
+#endif
+  scheme_install_xc_global("wx:const-type-key-event", scheme_make_integer(wxTYPE_KEY_EVENT), env);
+  scheme_install_xc_global("wx:const-type-command-event", scheme_make_integer(wxTYPE_COMMAND_EVENT), env);
+  scheme_install_xc_global("wx:const-type-mouse-event", scheme_make_integer(wxTYPE_MOUSE_EVENT), env);
+}
+
+int objscheme_istype_wxEvent(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxEvent_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:event%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxEvent(class wxEvent *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxEvent_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxEvent *objscheme_unbundle_wxEvent(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxEvent(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxEvent *)o->primdata;
+  else
+    return (wxEvent *)o->primdata;
+}
+
+
+
+
+
+
+
+
+class os_wxCommandEvent : public wxCommandEvent {
+ public:
+
+  os_wxCommandEvent(Scheme_Object * obj, int x0);
+  ~os_wxCommandEvent();
+};
+
+Scheme_Object *os_wxCommandEvent_class;
+
+os_wxCommandEvent::os_wxCommandEvent(Scheme_Object * o, int x0)
+: wxCommandEvent(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCommandEvent::~os_wxCommandEvent()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCommandEventIsSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCommandEvent *)((Scheme_Class_Object *)obj)->primdata)->IsSelection();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCommandEventChecked(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCommandEvent *)((Scheme_Class_Object *)obj)->primdata)->Checked();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCommandEventGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCommandEvent *)((Scheme_Class_Object *)obj)->primdata)->GetString();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCommandEventGetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCommandEvent *)((Scheme_Class_Object *)obj)->primdata)->GetSelection();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_GetextraLong(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-extra-long", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxCommandEvent *)cobj->primdata)->wxCommandEvent::extraLong;
+  else
+    v = ((wxCommandEvent *)cobj->primdata)->extraLong;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_SetextraLong(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-extra-long", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:command-event%::extra-long");
+  ((wxCommandEvent *)cobj->primdata)->extraLong = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_GetcommandInt(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-command-int", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxCommandEvent *)cobj->primdata)->wxCommandEvent::commandInt;
+  else
+    v = ((wxCommandEvent *)cobj->primdata)->commandInt;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_SetcommandInt(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-command-int", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:command-event%::command-int");
+  ((wxCommandEvent *)cobj->primdata)->commandInt = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_GetcommandString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  string v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-command-string", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxCommandEvent *)cobj->primdata)->wxCommandEvent::commandString;
+  else
+    v = ((wxCommandEvent *)cobj->primdata)->commandString;
+
+  return objscheme_bundle_string((char *)v);
+}
+
+static Scheme_Object *objscheme_wxCommandEvent_SetcommandString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  string v;
+
+  if (n != 1) scheme_wrong_count("set-command-string", 1, 1, n, p);
+
+  v = (string)objscheme_unbundle_string(p[0], "wx:command-event%::command-string");
+  ((wxCommandEvent *)cobj->primdata)->commandString = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCommandEvent_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxCommandEvent *realobj;
+  int x0;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:command-event%::initialization", 1, 1, n, p);
+  x0 = objscheme_unbundle_integer(p[0], "wx:command-event%::initialization");
+
+  
+  realobj = new os_wxCommandEvent(obj, x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxCommandEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:command-event%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:command-event%");
+}
+
+void objscheme_setup_wxCommandEvent(void *env)
+{
+if (os_wxCommandEvent_class) {
+    objscheme_add_global_class(os_wxCommandEvent_class,  "wx:command-event%", env);
+} else {
+  os_wxCommandEvent_class = objscheme_def_prim_class(env, "wx:command-event%", "wx:event%", os_wxCommandEvent_ConstructScheme, 11);
+
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"get-class-name",objscheme_classname_os_wxCommandEvent, 0, 0);
+
+ scheme_add_method_w_arity(os_wxCommandEvent_class, "is-selection?", os_wxCommandEventIsSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxCommandEvent_class, "checked?", os_wxCommandEventChecked, 0, 0);
+ scheme_add_method_w_arity(os_wxCommandEvent_class, "get-string", os_wxCommandEventGetString, 0, 0);
+ scheme_add_method_w_arity(os_wxCommandEvent_class, "get-selection", os_wxCommandEventGetSelection, 0, 0);
+
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"get-extra-long", objscheme_wxCommandEvent_GetextraLong, 0, 0);
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"set-extra-long", objscheme_wxCommandEvent_SetextraLong, 1, 1);
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"get-command-int", objscheme_wxCommandEvent_GetcommandInt, 0, 0);
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"set-command-int", objscheme_wxCommandEvent_SetcommandInt, 1, 1);
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"get-command-string", objscheme_wxCommandEvent_GetcommandString, 0, 0);
+  scheme_add_method_w_arity(os_wxCommandEvent_class,"set-command-string", objscheme_wxCommandEvent_SetcommandString, 1, 1);
+
+  scheme_made_class(os_wxCommandEvent_class);
+
+
+}
+  scheme_install_xc_global("wx:const-event-type-button-command", scheme_make_integer(wxEVENT_TYPE_BUTTON_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-checkbox-command", scheme_make_integer(wxEVENT_TYPE_CHECKBOX_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-choice-command", scheme_make_integer(wxEVENT_TYPE_CHOICE_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-listbox-command", scheme_make_integer(wxEVENT_TYPE_LISTBOX_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-text-command", scheme_make_integer(wxEVENT_TYPE_TEXT_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-multitext-command", scheme_make_integer(wxEVENT_TYPE_MULTITEXT_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-menu-command", scheme_make_integer(wxEVENT_TYPE_MENU_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-slider-command", scheme_make_integer(wxEVENT_TYPE_SLIDER_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-radiobox-command", scheme_make_integer(wxEVENT_TYPE_RADIOBOX_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-text-enter-command", scheme_make_integer(wxEVENT_TYPE_TEXT_ENTER_COMMAND), env);
+  scheme_install_xc_global("wx:const-event-type-set-focus", scheme_make_integer(wxEVENT_TYPE_SET_FOCUS), env);
+  scheme_install_xc_global("wx:const-event-type-kill-focus", scheme_make_integer(wxEVENT_TYPE_KILL_FOCUS), env);
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-scrollbar-command", scheme_make_integer(wxEVENT_TYPE_SCROLLBAR_COMMAND), env);
+#endif
+#if  NEW_EVENT_IDS
+  scheme_install_xc_global("wx:const-event-type-virt-listbox-command", scheme_make_integer(wxEVENT_TYPE_VIRT_LISTBOX_COMMAND), env);
+#endif
+}
+
+int objscheme_istype_wxCommandEvent(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCommandEvent_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:command-event%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCommandEvent(class wxCommandEvent *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCommandEvent_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCommandEvent(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCommandEvent *)o->primdata;
+  else
+    return (wxCommandEvent *)o->primdata;
+}
+
+
+
+
+
+// @ "control-down?" : bool ControlDown();
+// @ "shift-down?" : bool ShiftDown();
+
+
+
+
+
+class os_wxKeyEvent : public wxKeyEvent {
+ public:
+
+  os_wxKeyEvent(Scheme_Object * obj, int x0);
+  ~os_wxKeyEvent();
+};
+
+Scheme_Object *os_wxKeyEvent_class;
+
+os_wxKeyEvent::os_wxKeyEvent(Scheme_Object * o, int x0)
+: wxKeyEvent(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxKeyEvent::~os_wxKeyEvent()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeyEventKeyCode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxKeyEvent *)((Scheme_Class_Object *)obj)->primdata)->KeyCode();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GetkeyCode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-key-code", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::keyCode;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->keyCode;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SetkeyCode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-key-code", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:key-event%::key-code");
+  ((wxKeyEvent *)cobj->primdata)->keyCode = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GetshiftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-shift-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::shiftDown;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->shiftDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SetshiftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-shift-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:key-event%::shift-down");
+  ((wxKeyEvent *)cobj->primdata)->shiftDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GetcontrolDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-control-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::controlDown;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->controlDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SetcontrolDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-control-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:key-event%::control-down");
+  ((wxKeyEvent *)cobj->primdata)->controlDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GetmetaDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-meta-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::metaDown;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->metaDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SetmetaDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-meta-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:key-event%::meta-down");
+  ((wxKeyEvent *)cobj->primdata)->metaDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GetaltDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-alt-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::altDown;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->altDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SetaltDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-alt-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:key-event%::alt-down");
+  ((wxKeyEvent *)cobj->primdata)->altDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_GettimeStamp(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-time-stamp", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::timeStamp;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->timeStamp;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_SettimeStamp(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-time-stamp", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:key-event%::time-stamp");
+  ((wxKeyEvent *)cobj->primdata)->timeStamp = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_Getx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-x", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::x;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->x;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_Setx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-x", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:key-event%::x");
+  ((wxKeyEvent *)cobj->primdata)->x = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_Gety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-y", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxKeyEvent *)cobj->primdata)->wxKeyEvent::y;
+  else
+    v = ((wxKeyEvent *)cobj->primdata)->y;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxKeyEvent_Sety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-y", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:key-event%::y");
+  ((wxKeyEvent *)cobj->primdata)->y = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeyEvent_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxKeyEvent *realobj;
+  int x0;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:key-event%::initialization", 1, 1, n, p);
+  x0 = objscheme_unbundle_integer(p[0], "wx:key-event%::initialization");
+
+  
+  realobj = new os_wxKeyEvent(obj, x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxKeyEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:key-event%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:key-event%");
+}
+
+void objscheme_setup_wxKeyEvent(void *env)
+{
+if (os_wxKeyEvent_class) {
+    objscheme_add_global_class(os_wxKeyEvent_class,  "wx:key-event%", env);
+} else {
+  os_wxKeyEvent_class = objscheme_def_prim_class(env, "wx:key-event%", "wx:event%", os_wxKeyEvent_ConstructScheme, 18);
+
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-class-name",objscheme_classname_os_wxKeyEvent, 0, 0);
+
+ scheme_add_method_w_arity(os_wxKeyEvent_class, "key-code", os_wxKeyEventKeyCode, 0, 0);
+
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-key-code", objscheme_wxKeyEvent_GetkeyCode, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-key-code", objscheme_wxKeyEvent_SetkeyCode, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-shift-down", objscheme_wxKeyEvent_GetshiftDown, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-shift-down", objscheme_wxKeyEvent_SetshiftDown, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-control-down", objscheme_wxKeyEvent_GetcontrolDown, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-control-down", objscheme_wxKeyEvent_SetcontrolDown, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-meta-down", objscheme_wxKeyEvent_GetmetaDown, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-meta-down", objscheme_wxKeyEvent_SetmetaDown, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-alt-down", objscheme_wxKeyEvent_GetaltDown, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-alt-down", objscheme_wxKeyEvent_SetaltDown, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-time-stamp", objscheme_wxKeyEvent_GettimeStamp, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-time-stamp", objscheme_wxKeyEvent_SettimeStamp, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-x", objscheme_wxKeyEvent_Getx, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-x", objscheme_wxKeyEvent_Setx, 1, 1);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"get-y", objscheme_wxKeyEvent_Gety, 0, 0);
+  scheme_add_method_w_arity(os_wxKeyEvent_class,"set-y", objscheme_wxKeyEvent_Sety, 1, 1);
+
+  scheme_made_class(os_wxKeyEvent_class);
+
+
+}
+  scheme_install_xc_global("wx:const-event-type-char", scheme_make_integer(wxEVENT_TYPE_CHAR), env);
+  scheme_install_xc_global("wx:const-k-back", scheme_make_integer(WXK_BACK), env);
+  scheme_install_xc_global("wx:const-k-tab", scheme_make_integer(WXK_TAB), env);
+  scheme_install_xc_global("wx:const-k-return", scheme_make_integer(WXK_RETURN), env);
+  scheme_install_xc_global("wx:const-k-escape", scheme_make_integer(WXK_ESCAPE), env);
+  scheme_install_xc_global("wx:const-k-space", scheme_make_integer(WXK_SPACE), env);
+  scheme_install_xc_global("wx:const-k-delete", scheme_make_integer(WXK_DELETE), env);
+  scheme_install_xc_global("wx:const-k-start", scheme_make_integer(WXK_START), env);
+  scheme_install_xc_global("wx:const-k-lbutton", scheme_make_integer(WXK_LBUTTON), env);
+  scheme_install_xc_global("wx:const-k-rbutton", scheme_make_integer(WXK_RBUTTON), env);
+  scheme_install_xc_global("wx:const-k-cancel", scheme_make_integer(WXK_CANCEL), env);
+  scheme_install_xc_global("wx:const-k-mbutton", scheme_make_integer(WXK_MBUTTON), env);
+  scheme_install_xc_global("wx:const-k-clear", scheme_make_integer(WXK_CLEAR), env);
+  scheme_install_xc_global("wx:const-k-shift", scheme_make_integer(WXK_SHIFT), env);
+  scheme_install_xc_global("wx:const-k-control", scheme_make_integer(WXK_CONTROL), env);
+  scheme_install_xc_global("wx:const-k-menu", scheme_make_integer(WXK_MENU), env);
+  scheme_install_xc_global("wx:const-k-pause", scheme_make_integer(WXK_PAUSE), env);
+  scheme_install_xc_global("wx:const-k-capital", scheme_make_integer(WXK_CAPITAL), env);
+  scheme_install_xc_global("wx:const-k-prior", scheme_make_integer(WXK_PRIOR), env);
+  scheme_install_xc_global("wx:const-k-next", scheme_make_integer(WXK_NEXT), env);
+  scheme_install_xc_global("wx:const-k-end", scheme_make_integer(WXK_END), env);
+  scheme_install_xc_global("wx:const-k-home", scheme_make_integer(WXK_HOME), env);
+  scheme_install_xc_global("wx:const-k-left", scheme_make_integer(WXK_LEFT), env);
+  scheme_install_xc_global("wx:const-k-up", scheme_make_integer(WXK_UP), env);
+  scheme_install_xc_global("wx:const-k-right", scheme_make_integer(WXK_RIGHT), env);
+  scheme_install_xc_global("wx:const-k-down", scheme_make_integer(WXK_DOWN), env);
+  scheme_install_xc_global("wx:const-k-select", scheme_make_integer(WXK_SELECT), env);
+  scheme_install_xc_global("wx:const-k-print", scheme_make_integer(WXK_PRINT), env);
+  scheme_install_xc_global("wx:const-k-execute", scheme_make_integer(WXK_EXECUTE), env);
+  scheme_install_xc_global("wx:const-k-snapshot", scheme_make_integer(WXK_SNAPSHOT), env);
+  scheme_install_xc_global("wx:const-k-insert", scheme_make_integer(WXK_INSERT), env);
+  scheme_install_xc_global("wx:const-k-help", scheme_make_integer(WXK_HELP), env);
+  scheme_install_xc_global("wx:const-k-numpad0", scheme_make_integer(WXK_NUMPAD0), env);
+  scheme_install_xc_global("wx:const-k-numpad1", scheme_make_integer(WXK_NUMPAD1), env);
+  scheme_install_xc_global("wx:const-k-numpad2", scheme_make_integer(WXK_NUMPAD2), env);
+  scheme_install_xc_global("wx:const-k-numpad3", scheme_make_integer(WXK_NUMPAD3), env);
+  scheme_install_xc_global("wx:const-k-numpad4", scheme_make_integer(WXK_NUMPAD4), env);
+  scheme_install_xc_global("wx:const-k-numpad5", scheme_make_integer(WXK_NUMPAD5), env);
+  scheme_install_xc_global("wx:const-k-numpad6", scheme_make_integer(WXK_NUMPAD6), env);
+  scheme_install_xc_global("wx:const-k-numpad7", scheme_make_integer(WXK_NUMPAD7), env);
+  scheme_install_xc_global("wx:const-k-numpad8", scheme_make_integer(WXK_NUMPAD8), env);
+  scheme_install_xc_global("wx:const-k-numpad9", scheme_make_integer(WXK_NUMPAD9), env);
+  scheme_install_xc_global("wx:const-k-multiply", scheme_make_integer(WXK_MULTIPLY), env);
+  scheme_install_xc_global("wx:const-k-add", scheme_make_integer(WXK_ADD), env);
+  scheme_install_xc_global("wx:const-k-separator", scheme_make_integer(WXK_SEPARATOR), env);
+  scheme_install_xc_global("wx:const-k-subtract", scheme_make_integer(WXK_SUBTRACT), env);
+  scheme_install_xc_global("wx:const-k-decimal", scheme_make_integer(WXK_DECIMAL), env);
+  scheme_install_xc_global("wx:const-k-divide", scheme_make_integer(WXK_DIVIDE), env);
+  scheme_install_xc_global("wx:const-k-f1", scheme_make_integer(WXK_F1), env);
+  scheme_install_xc_global("wx:const-k-f2", scheme_make_integer(WXK_F2), env);
+  scheme_install_xc_global("wx:const-k-f3", scheme_make_integer(WXK_F3), env);
+  scheme_install_xc_global("wx:const-k-f4", scheme_make_integer(WXK_F4), env);
+  scheme_install_xc_global("wx:const-k-f5", scheme_make_integer(WXK_F5), env);
+  scheme_install_xc_global("wx:const-k-f6", scheme_make_integer(WXK_F6), env);
+  scheme_install_xc_global("wx:const-k-f7", scheme_make_integer(WXK_F7), env);
+  scheme_install_xc_global("wx:const-k-f8", scheme_make_integer(WXK_F8), env);
+  scheme_install_xc_global("wx:const-k-f9", scheme_make_integer(WXK_F9), env);
+  scheme_install_xc_global("wx:const-k-f10", scheme_make_integer(WXK_F10), env);
+  scheme_install_xc_global("wx:const-k-f11", scheme_make_integer(WXK_F11), env);
+  scheme_install_xc_global("wx:const-k-f12", scheme_make_integer(WXK_F12), env);
+  scheme_install_xc_global("wx:const-k-f13", scheme_make_integer(WXK_F13), env);
+  scheme_install_xc_global("wx:const-k-f14", scheme_make_integer(WXK_F14), env);
+  scheme_install_xc_global("wx:const-k-f15", scheme_make_integer(WXK_F15), env);
+  scheme_install_xc_global("wx:const-k-f16", scheme_make_integer(WXK_F16), env);
+  scheme_install_xc_global("wx:const-k-f17", scheme_make_integer(WXK_F17), env);
+  scheme_install_xc_global("wx:const-k-f18", scheme_make_integer(WXK_F18), env);
+  scheme_install_xc_global("wx:const-k-f19", scheme_make_integer(WXK_F19), env);
+  scheme_install_xc_global("wx:const-k-f20", scheme_make_integer(WXK_F20), env);
+  scheme_install_xc_global("wx:const-k-f21", scheme_make_integer(WXK_F21), env);
+  scheme_install_xc_global("wx:const-k-f22", scheme_make_integer(WXK_F22), env);
+  scheme_install_xc_global("wx:const-k-f23", scheme_make_integer(WXK_F23), env);
+  scheme_install_xc_global("wx:const-k-f24", scheme_make_integer(WXK_F24), env);
+  scheme_install_xc_global("wx:const-k-numlock", scheme_make_integer(WXK_NUMLOCK), env);
+  scheme_install_xc_global("wx:const-k-scroll", scheme_make_integer(WXK_SCROLL), env);
+}
+
+int objscheme_istype_wxKeyEvent(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxKeyEvent_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:key-event%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxKeyEvent_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxKeyEvent(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxKeyEvent *)o->primdata;
+  else
+    return (wxKeyEvent *)o->primdata;
+}
+
+
+
+
+// @ "control-down?" : bool ControlDown();
+// @ "shift-down?" : bool ShiftDown();
+// @ "left-down?" : bool LeftDown();
+// @ "left-is-down?" : bool LeftIsDown();
+// @ "left-up?" : bool LeftUp();
+// @ "middle-down?" : bool MiddleDown();
+// @ "middle-is-down?" : bool MiddleIsDown();
+// @ "middle-up?" : bool MiddleUp();
+// @ "right-down?" : bool RightDown();
+// @ "right-is-down?" : bool RightIsDown();
+// @ "right-up?" : bool RightUp();
+// @ "position" : void Position(float*,float*);
+
+
+
+class os_wxMouseEvent : public wxMouseEvent {
+ public:
+
+  os_wxMouseEvent(Scheme_Object * obj, int x0);
+  ~os_wxMouseEvent();
+};
+
+Scheme_Object *os_wxMouseEvent_class;
+
+os_wxMouseEvent::os_wxMouseEvent(Scheme_Object * o, int x0)
+: wxMouseEvent(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMouseEvent::~os_wxMouseEvent()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventMoving(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->Moving();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventIsButton(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->IsButton();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventLeaving(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->Leaving();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventEntering(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->Entering();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventDragging(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->Dragging();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventButtonUp(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:mouse-event%::button-up?");
+  } else
+    x0 = -1;
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->ButtonUp(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventButtonDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:mouse-event%::button-down?");
+  } else
+    x0 = -1;
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->ButtonDown(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventButtonDClick(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:mouse-event%::button-d-click?");
+  } else
+    x0 = -1;
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->ButtonDClick(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEventButton(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:mouse-event%::button?");
+
+  
+  r = ((wxMouseEvent *)((Scheme_Class_Object *)obj)->primdata)->Button(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetleftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-left-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::leftDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->leftDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetleftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-left-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::left-down");
+  ((wxMouseEvent *)cobj->primdata)->leftDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetmiddleDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-middle-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::middleDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->middleDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetmiddleDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-middle-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::middle-down");
+  ((wxMouseEvent *)cobj->primdata)->middleDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetrightDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-right-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::rightDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->rightDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetrightDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-right-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::right-down");
+  ((wxMouseEvent *)cobj->primdata)->rightDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetshiftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-shift-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::shiftDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->shiftDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetshiftDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-shift-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::shift-down");
+  ((wxMouseEvent *)cobj->primdata)->shiftDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetcontrolDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-control-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::controlDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->controlDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetcontrolDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-control-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::control-down");
+  ((wxMouseEvent *)cobj->primdata)->controlDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetmetaDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-meta-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::metaDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->metaDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetmetaDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-meta-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::meta-down");
+  ((wxMouseEvent *)cobj->primdata)->metaDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GetaltDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-alt-down", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::altDown;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->altDown;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SetaltDown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-alt-down", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:mouse-event%::alt-down");
+  ((wxMouseEvent *)cobj->primdata)->altDown = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_Getx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-x", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::x;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->x;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_Setx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-x", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:mouse-event%::x");
+  ((wxMouseEvent *)cobj->primdata)->x = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_Gety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-y", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::y;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->y;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_Sety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-y", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:mouse-event%::y");
+  ((wxMouseEvent *)cobj->primdata)->y = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_GettimeStamp(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-time-stamp", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMouseEvent *)cobj->primdata)->wxMouseEvent::timeStamp;
+  else
+    v = ((wxMouseEvent *)cobj->primdata)->timeStamp;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxMouseEvent_SettimeStamp(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  long v;
+
+  if (n != 1) scheme_wrong_count("set-time-stamp", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:mouse-event%::time-stamp");
+  ((wxMouseEvent *)cobj->primdata)->timeStamp = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMouseEvent_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMouseEvent *realobj;
+  int x0;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:mouse-event%::initialization", 1, 1, n, p);
+  x0 = objscheme_unbundle_integer(p[0], "wx:mouse-event%::initialization");
+
+  
+  realobj = new os_wxMouseEvent(obj, x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMouseEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:mouse-event%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:mouse-event%");
+}
+
+void objscheme_setup_wxMouseEvent(void *env)
+{
+if (os_wxMouseEvent_class) {
+    objscheme_add_global_class(os_wxMouseEvent_class,  "wx:mouse-event%", env);
+} else {
+  os_wxMouseEvent_class = objscheme_def_prim_class(env, "wx:mouse-event%", "wx:event%", os_wxMouseEvent_ConstructScheme, 30);
+
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-class-name",objscheme_classname_os_wxMouseEvent, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "moving?", os_wxMouseEventMoving, 0, 0);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "is-button?", os_wxMouseEventIsButton, 0, 0);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "leaving?", os_wxMouseEventLeaving, 0, 0);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "entering?", os_wxMouseEventEntering, 0, 0);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "dragging?", os_wxMouseEventDragging, 0, 0);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "button-up?", os_wxMouseEventButtonUp, 0, 1);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "button-down?", os_wxMouseEventButtonDown, 0, 1);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "button-d-click?", os_wxMouseEventButtonDClick, 0, 1);
+ scheme_add_method_w_arity(os_wxMouseEvent_class, "button?", os_wxMouseEventButton, 1, 1);
+
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-left-down", objscheme_wxMouseEvent_GetleftDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-left-down", objscheme_wxMouseEvent_SetleftDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-middle-down", objscheme_wxMouseEvent_GetmiddleDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-middle-down", objscheme_wxMouseEvent_SetmiddleDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-right-down", objscheme_wxMouseEvent_GetrightDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-right-down", objscheme_wxMouseEvent_SetrightDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-shift-down", objscheme_wxMouseEvent_GetshiftDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-shift-down", objscheme_wxMouseEvent_SetshiftDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-control-down", objscheme_wxMouseEvent_GetcontrolDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-control-down", objscheme_wxMouseEvent_SetcontrolDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-meta-down", objscheme_wxMouseEvent_GetmetaDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-meta-down", objscheme_wxMouseEvent_SetmetaDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-alt-down", objscheme_wxMouseEvent_GetaltDown, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-alt-down", objscheme_wxMouseEvent_SetaltDown, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-x", objscheme_wxMouseEvent_Getx, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-x", objscheme_wxMouseEvent_Setx, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-y", objscheme_wxMouseEvent_Gety, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-y", objscheme_wxMouseEvent_Sety, 1, 1);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"get-time-stamp", objscheme_wxMouseEvent_GettimeStamp, 0, 0);
+  scheme_add_method_w_arity(os_wxMouseEvent_class,"set-time-stamp", objscheme_wxMouseEvent_SettimeStamp, 1, 1);
+
+  scheme_made_class(os_wxMouseEvent_class);
+
+
+}
+  scheme_install_xc_global("wx:const-event-type-left-down", scheme_make_integer(wxEVENT_TYPE_LEFT_DOWN), env);
+  scheme_install_xc_global("wx:const-event-type-left-up", scheme_make_integer(wxEVENT_TYPE_LEFT_UP), env);
+  scheme_install_xc_global("wx:const-event-type-middle-down", scheme_make_integer(wxEVENT_TYPE_MIDDLE_DOWN), env);
+  scheme_install_xc_global("wx:const-event-type-middle-up", scheme_make_integer(wxEVENT_TYPE_MIDDLE_UP), env);
+  scheme_install_xc_global("wx:const-event-type-right-down", scheme_make_integer(wxEVENT_TYPE_RIGHT_DOWN), env);
+  scheme_install_xc_global("wx:const-event-type-right-up", scheme_make_integer(wxEVENT_TYPE_RIGHT_UP), env);
+  scheme_install_xc_global("wx:const-event-type-motion", scheme_make_integer(wxEVENT_TYPE_MOTION), env);
+  scheme_install_xc_global("wx:const-event-type-enter-window", scheme_make_integer(wxEVENT_TYPE_ENTER_WINDOW), env);
+  scheme_install_xc_global("wx:const-event-type-leave-window", scheme_make_integer(wxEVENT_TYPE_LEAVE_WINDOW), env);
+  scheme_install_xc_global("wx:const-event-type-left-dclick", scheme_make_integer(wxEVENT_TYPE_LEFT_DCLICK), env);
+  scheme_install_xc_global("wx:const-event-type-middle-dclick", scheme_make_integer(wxEVENT_TYPE_MIDDLE_DCLICK), env);
+  scheme_install_xc_global("wx:const-event-type-right-dclick", scheme_make_integer(wxEVENT_TYPE_RIGHT_DCLICK), env);
+}
+
+int objscheme_istype_wxMouseEvent(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMouseEvent_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:mouse-event%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMouseEvent_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMouseEvent(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMouseEvent *)o->primdata;
+  else
+    return (wxMouseEvent *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_evnt.h b/src/mred/wxs/wxs_evnt.h
new file mode 100644
index 0000000..1e4ecca
--- /dev/null
+++ b/src/mred/wxs/wxs_evnt.h
@@ -0,0 +1,28 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxObject(class wxObject *);
+extern class wxObject *objscheme_unbundle_wxObject(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxEvent(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxEvent(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxEvent(class wxEvent *realobj);
+class wxEvent *objscheme_unbundle_wxEvent(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxCommandEvent(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCommandEvent(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCommandEvent(class wxCommandEvent *realobj);
+class wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxKeyEvent(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxKeyEvent(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *realobj);
+class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxMouseEvent(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMouseEvent(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *realobj);
+class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_evnt.xc b/src/mred/wxs/wxs_evnt.xc
new file mode 100644
index 0000000..03d8b83
--- /dev/null
+++ b/src/mred/wxs/wxs_evnt.xc
@@ -0,0 +1,221 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_stdev.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if !defined(wx_mac)
+#define NEW_EVENT_IDS 1
+#else
+#define NEW_EVENT_IDS 0
+#endif
+
+@CLASSBASE wxEvent "wx:event":"wx:object"
+
+// @CREATOR ()
+
+// These are not ready to be used:
+// @ H "write-event" : bool WriteEvent(ostream%);
+// @ H "read-event" : bool ReadEvent(istream%);
+
+@IVAR "event-class" : long eventClass
+@IVAR "event-type" : long eventType
+@IVAR "event-object" : wxObject! eventObject
+
+// Don't know where else to put these:
+@CONSTANT "wx:const-event-type-scroll-top" : int wxEVENT_TYPE_SCROLL_TOP ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-bottom" : int wxEVENT_TYPE_SCROLL_BOTTOM ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-lineup" : int wxEVENT_TYPE_SCROLL_LINEUP ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-linedown" : int wxEVENT_TYPE_SCROLL_LINEDOWN ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-pageup" : int wxEVENT_TYPE_SCROLL_PAGEUP ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-pagedown" : int wxEVENT_TYPE_SCROLL_PAGEDOWN ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-scroll-thumbtrack" : int wxEVENT_TYPE_SCROLL_THUMBTRACK ## NEW_EVENT_IDS
+
+@CONSTANT "wx:const-type-key-event" : int wxTYPE_KEY_EVENT
+@CONSTANT "wx:const-type-command-event" : int wxTYPE_COMMAND_EVENT
+@CONSTANT "wx:const-type-mouse-event" : int wxTYPE_MOUSE_EVENT
+
+@END
+
+
+@CLASSBASE wxCommandEvent "wx:command-event":"wx:event"
+
+@CREATOR (int)
+
+@ "get-selection" : int GetSelection();
+@ "get-string" : string GetString();
+@ "checked?" : bool Checked();
+@ "is-selection?" : bool IsSelection();
+
+@IVAR "extra-long" : long extraLong
+@IVAR "command-int" : int commandInt
+@IVAR "command-string" : string commandString
+
+@CONSTANT "wx:const-event-type-button-command" : int wxEVENT_TYPE_BUTTON_COMMAND
+@CONSTANT "wx:const-event-type-checkbox-command" : int wxEVENT_TYPE_CHECKBOX_COMMAND
+@CONSTANT "wx:const-event-type-choice-command" : int wxEVENT_TYPE_CHOICE_COMMAND
+@CONSTANT "wx:const-event-type-listbox-command" : int wxEVENT_TYPE_LISTBOX_COMMAND
+@CONSTANT "wx:const-event-type-text-command" : int wxEVENT_TYPE_TEXT_COMMAND
+@CONSTANT "wx:const-event-type-multitext-command" : int wxEVENT_TYPE_MULTITEXT_COMMAND
+@CONSTANT "wx:const-event-type-menu-command" : int wxEVENT_TYPE_MENU_COMMAND
+@CONSTANT "wx:const-event-type-slider-command" : int wxEVENT_TYPE_SLIDER_COMMAND
+@CONSTANT "wx:const-event-type-radiobox-command" : int wxEVENT_TYPE_RADIOBOX_COMMAND
+@CONSTANT "wx:const-event-type-text-enter-command" : int wxEVENT_TYPE_TEXT_ENTER_COMMAND
+@CONSTANT "wx:const-event-type-set-focus" : int wxEVENT_TYPE_SET_FOCUS
+@CONSTANT "wx:const-event-type-kill-focus" : int wxEVENT_TYPE_KILL_FOCUS
+@CONSTANT "wx:const-event-type-scrollbar-command" : int wxEVENT_TYPE_SCROLLBAR_COMMAND   ## NEW_EVENT_IDS
+@CONSTANT "wx:const-event-type-virt-listbox-command" : int wxEVENT_TYPE_VIRT_LISTBOX_COMMAND   ## NEW_EVENT_IDS
+
+@END
+
+
+@CLASSBASE wxKeyEvent "wx:key-event":"wx:event"
+
+@CREATOR (int);
+
+// @ "control-down?" : bool ControlDown();
+// @ "shift-down?" : bool ShiftDown();
+@ "key-code" : long KeyCode();
+
+@IVAR "key-code" : long keyCode
+@IVAR "shift-down" : bool shiftDown
+@IVAR "control-down" : bool controlDown
+@IVAR "meta-down" : bool metaDown
+@IVAR "alt-down" : bool altDown
+@IVAR "time-stamp" : long timeStamp
+
+@IVAR "x" : float x
+@IVAR "y" : float y
+
+@CONSTANT "wx:const-event-type-char" : int wxEVENT_TYPE_CHAR
+
+@CONSTANT "wx:const-k-back" : int WXK_BACK
+@CONSTANT "wx:const-k-tab" : int WXK_TAB
+@CONSTANT "wx:const-k-return" : int WXK_RETURN
+@CONSTANT "wx:const-k-escape" : int WXK_ESCAPE
+@CONSTANT "wx:const-k-space" : int WXK_SPACE
+@CONSTANT "wx:const-k-delete" : int WXK_DELETE
+@CONSTANT "wx:const-k-start" : int WXK_START
+@CONSTANT "wx:const-k-lbutton" : int WXK_LBUTTON
+@CONSTANT "wx:const-k-rbutton" : int WXK_RBUTTON
+@CONSTANT "wx:const-k-cancel" : int WXK_CANCEL
+@CONSTANT "wx:const-k-mbutton" : int WXK_MBUTTON
+@CONSTANT "wx:const-k-clear" : int WXK_CLEAR
+@CONSTANT "wx:const-k-shift" : int WXK_SHIFT
+@CONSTANT "wx:const-k-control" : int WXK_CONTROL
+@CONSTANT "wx:const-k-menu" : int WXK_MENU
+@CONSTANT "wx:const-k-pause" : int WXK_PAUSE
+@CONSTANT "wx:const-k-capital" : int WXK_CAPITAL
+@CONSTANT "wx:const-k-prior" : int WXK_PRIOR
+@CONSTANT "wx:const-k-next" : int WXK_NEXT
+@CONSTANT "wx:const-k-end" : int WXK_END
+@CONSTANT "wx:const-k-home" : int WXK_HOME
+@CONSTANT "wx:const-k-left" : int WXK_LEFT
+@CONSTANT "wx:const-k-up" : int WXK_UP
+@CONSTANT "wx:const-k-right" : int WXK_RIGHT
+@CONSTANT "wx:const-k-down" : int WXK_DOWN
+@CONSTANT "wx:const-k-select" : int WXK_SELECT
+@CONSTANT "wx:const-k-print" : int WXK_PRINT
+@CONSTANT "wx:const-k-execute" : int WXK_EXECUTE
+@CONSTANT "wx:const-k-snapshot" : int WXK_SNAPSHOT
+@CONSTANT "wx:const-k-insert" : int WXK_INSERT
+@CONSTANT "wx:const-k-help" : int WXK_HELP
+@CONSTANT "wx:const-k-numpad0" : int WXK_NUMPAD0
+@CONSTANT "wx:const-k-numpad1" : int WXK_NUMPAD1
+@CONSTANT "wx:const-k-numpad2" : int WXK_NUMPAD2
+@CONSTANT "wx:const-k-numpad3" : int WXK_NUMPAD3
+@CONSTANT "wx:const-k-numpad4" : int WXK_NUMPAD4
+@CONSTANT "wx:const-k-numpad5" : int WXK_NUMPAD5
+@CONSTANT "wx:const-k-numpad6" : int WXK_NUMPAD6
+@CONSTANT "wx:const-k-numpad7" : int WXK_NUMPAD7
+@CONSTANT "wx:const-k-numpad8" : int WXK_NUMPAD8
+@CONSTANT "wx:const-k-numpad9" : int WXK_NUMPAD9
+@CONSTANT "wx:const-k-multiply" : int WXK_MULTIPLY
+@CONSTANT "wx:const-k-add" : int WXK_ADD
+@CONSTANT "wx:const-k-separator" : int WXK_SEPARATOR
+@CONSTANT "wx:const-k-subtract" : int WXK_SUBTRACT
+@CONSTANT "wx:const-k-decimal" : int WXK_DECIMAL
+@CONSTANT "wx:const-k-divide" : int WXK_DIVIDE
+@CONSTANT "wx:const-k-f1" : int WXK_F1
+@CONSTANT "wx:const-k-f2" : int WXK_F2
+@CONSTANT "wx:const-k-f3" : int WXK_F3
+@CONSTANT "wx:const-k-f4" : int WXK_F4
+@CONSTANT "wx:const-k-f5" : int WXK_F5
+@CONSTANT "wx:const-k-f6" : int WXK_F6
+@CONSTANT "wx:const-k-f7" : int WXK_F7
+@CONSTANT "wx:const-k-f8" : int WXK_F8
+@CONSTANT "wx:const-k-f9" : int WXK_F9
+@CONSTANT "wx:const-k-f10" : int WXK_F10
+@CONSTANT "wx:const-k-f11" : int WXK_F11
+@CONSTANT "wx:const-k-f12" : int WXK_F12
+@CONSTANT "wx:const-k-f13" : int WXK_F13
+@CONSTANT "wx:const-k-f14" : int WXK_F14
+@CONSTANT "wx:const-k-f15" : int WXK_F15
+@CONSTANT "wx:const-k-f16" : int WXK_F16
+@CONSTANT "wx:const-k-f17" : int WXK_F17
+@CONSTANT "wx:const-k-f18" : int WXK_F18
+@CONSTANT "wx:const-k-f19" : int WXK_F19
+@CONSTANT "wx:const-k-f20" : int WXK_F20
+@CONSTANT "wx:const-k-f21" : int WXK_F21
+@CONSTANT "wx:const-k-f22" : int WXK_F22
+@CONSTANT "wx:const-k-f23" : int WXK_F23
+@CONSTANT "wx:const-k-f24" : int WXK_F24
+@CONSTANT "wx:const-k-numlock" : int WXK_NUMLOCK
+@CONSTANT "wx:const-k-scroll" : int WXK_SCROLL
+
+@END
+
+@CLASSBASE wxMouseEvent "wx:mouse-event":"wx:event"
+
+@CREATOR (int);
+
+@ "button?" : bool Button(int);
+@ "button-d-click?" : bool ButtonDClick(int=-1);
+@ "button-down?" : bool ButtonDown(int=-1);
+@ "button-up?" : bool ButtonUp(int=-1);
+// @ "control-down?" : bool ControlDown();
+// @ "shift-down?" : bool ShiftDown();
+@ "dragging?" : bool Dragging();
+@ "entering?" : bool Entering();
+@ "leaving?" : bool Leaving();
+@ "is-button?" : bool IsButton();
+// @ "left-down?" : bool LeftDown();
+// @ "left-is-down?" : bool LeftIsDown();
+// @ "left-up?" : bool LeftUp();
+// @ "middle-down?" : bool MiddleDown();
+// @ "middle-is-down?" : bool MiddleIsDown();
+// @ "middle-up?" : bool MiddleUp();
+@ "moving?" : bool Moving();
+// @ "right-down?" : bool RightDown();
+// @ "right-is-down?" : bool RightIsDown();
+// @ "right-up?" : bool RightUp();
+// @ "position" : void Position(float*,float*);
+
+@IVAR "left-down" : bool leftDown
+@IVAR "middle-down" : bool middleDown
+@IVAR "right-down" : bool rightDown
+@IVAR "shift-down" : bool shiftDown
+@IVAR "control-down" : bool controlDown
+@IVAR "meta-down" : bool metaDown
+@IVAR "alt-down" : bool altDown
+@IVAR "x" : float x
+@IVAR "y" : float y
+@IVAR "time-stamp" : long timeStamp
+
+@CONSTANT "wx:const-event-type-left-down" : int wxEVENT_TYPE_LEFT_DOWN
+@CONSTANT "wx:const-event-type-left-up" : int wxEVENT_TYPE_LEFT_UP
+@CONSTANT "wx:const-event-type-middle-down" : int wxEVENT_TYPE_MIDDLE_DOWN
+@CONSTANT "wx:const-event-type-middle-up" : int wxEVENT_TYPE_MIDDLE_UP
+@CONSTANT "wx:const-event-type-right-down" : int wxEVENT_TYPE_RIGHT_DOWN
+@CONSTANT "wx:const-event-type-right-up" : int wxEVENT_TYPE_RIGHT_UP
+@CONSTANT "wx:const-event-type-motion" : int wxEVENT_TYPE_MOTION
+@CONSTANT "wx:const-event-type-enter-window" : int wxEVENT_TYPE_ENTER_WINDOW
+@CONSTANT "wx:const-event-type-leave-window" : int wxEVENT_TYPE_LEAVE_WINDOW
+@CONSTANT "wx:const-event-type-left-dclick" : int wxEVENT_TYPE_LEFT_DCLICK
+@CONSTANT "wx:const-event-type-middle-dclick" : int wxEVENT_TYPE_MIDDLE_DCLICK
+@CONSTANT "wx:const-event-type-right-dclick" : int wxEVENT_TYPE_RIGHT_DCLICK
+
+@END
diff --git a/src/mred/wxs/wxs_form.h b/src/mred/wxs/wxs_form.h
new file mode 100644
index 0000000..aa0265d
--- /dev/null
+++ b/src/mred/wxs/wxs_form.h
@@ -0,0 +1,22 @@
+extern Scheme_Object *objscheme_bundle_wxItem(wxItem *);
+void objscheme_setup_wxFormItem(Scheme_Env *env);
+int objscheme_istype_wxFormItem(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxFormItem(class wxFormItem *realobj);
+class wxFormItem *objscheme_unbundle_wxFormItem(Scheme_Object *obj, const char *where, int nullOK);
+extern wxFormItem *objscheme_unbundle_wxFormItem(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxNode(wxNode *);
+extern wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern wxFormItem *objscheme_unbundle_wxFormItem(Scheme_Object *, const char *, int);
+void objscheme_setup_wxForm(Scheme_Env *env);
+int objscheme_istype_wxForm(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxForm(class wxForm *realobj);
+class wxForm *objscheme_unbundle_wxForm(Scheme_Object *obj, const char *where, int nullOK);
+extern wxList *objscheme_unbundle_wxList(Scheme_Object *, const char *, int);
+extern wxList *objscheme_unbundle_wxList(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxFormItem(wxFormItem *);
+extern wxList *objscheme_unbundle_wxList(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxFormItem(wxFormItem *);
+extern Scheme_Object *objscheme_bundle_wxFormItem(wxFormItem *);
+extern Scheme_Object *objscheme_bundle_wxFormItem(wxFormItem *);
+extern Scheme_Object *objscheme_bundle_wxFormItem(wxFormItem *);
+void objscheme_setup_wxFormGlobal(Scheme_Env *env);
diff --git a/src/mred/wxs/wxs_form.xc b/src/mred/wxs/wxs_form.xc
new file mode 100644
index 0000000..39229be
--- /dev/null
+++ b/src/mred/wxs/wxs_form.xc
@@ -0,0 +1,78 @@
+
+#if 0
+
+#include "wx_form.h"
+
+@HEADER
+
+@INCLUDE wxs.xci
+
+@CLASSBASE wxFormItem "wx:form-item" : "wx:object"
+
+@ "get-panel-item" : wxItem! GetPanelItem();
+
+@END
+
+@CLASSBASE wxForm "wx:form" : "wx:object"
+
+@CREATOR (int=wxFORM_BUTTON_ALL,int=wxFORM_BUTTON_AT_TOP);
+
+@ "add" : void Add(wxFormItem!,long=-1);
+@ "associate-panel" : void AssociatePanel(wxPanel!);
+@ "delete" : bool Delete(int);
+@ "find-item" : wxNode^ FindItem(int);
+@ v "on-cancel" : void OnCancel();
+@ v "on-ok" : void OnOk();
+@ v "on-revert" : void OnRevert();
+@ v "on-update" : void OnUpdate();
+@ "revert-values" : void RevertValues();
+@ "update-values" : bool UpdateValues();
+@ "set" : bool Set(int,wxFormItem!);
+
+@CONSTANT "wx:const-form-default" : int wxFORM_DEFAULT
+@CONSTANT "wx:const-form-single-list" : int wxFORM_SINGLE_LIST
+@CONSTANT "wx:const-form-multi-list" : int wxFORM_MULTI_LIST
+@CONSTANT "wx:const-form-choice" : int wxFORM_CHOICE
+@CONSTANT "wx:const-form-checkbox" : int wxFORM_CHECKBOX
+@CONSTANT "wx:const-form-text" : int wxFORM_TEXT
+@CONSTANT "wx:const-form-multitext" : int wxFORM_MULTITEXT
+@CONSTANT "wx:const-form-slider" : int wxFORM_SLIDER
+@CONSTANT "wx:const-form-message" : int wxFORM_MESSAGE
+@CONSTANT "wx:const-form-newline" : int wxFORM_NEWLINE
+@CONSTANT "wx:const-form-button" : int wxFORM_BUTTON
+@CONSTANT "wx:const-form-dumb-message" : int wxFORM_DUMB_MESSAGE
+@CONSTANT "wx:const-form-radiobox" : int wxFORM_RADIOBOX
+
+@CONSTANT "wx:const-form-button-ok" : int wxFORM_BUTTON_OK    
+@CONSTANT "wx:const-form-button-cancal" : int wxFORM_BUTTON_CANCEL
+@CONSTANT "wx:const-form-button-update" : int wxFORM_BUTTON_UPDATE
+@CONSTANT "wx:const-form-button-revert" : int wxFORM_BUTTON_REVERT
+@CONSTANT "wx:const-form-button-help" : int wxFORM_BUTTON_HELP  
+@CONSTANT "wx:const-form-button-all" : int wxFORM_BUTTON_ALL
+
+@CONSTANT "wx:const-form-button-at-top" : int wxFORM_BUTTON_AT_TOP
+@CONSTANT "wx:const-form-button-at-bottom" : int wxFORM_BUTTON_AT_BOTTOM
+
+@END
+
+@GLOBAL wxFormGlobal
+
+@SET CALLBACK_CLASS = wxButton
+@INCLUDE cb_start.xci
+
+@ "wx:make-form-button" : wxFormItem! wxMakeFormButton(string,wxFunction/bCallback/ubCallback/cCallback); : : ubCallbackSetup///ubCallbackFinish
+@ "wx:make-form-message" : wxFormItem! wxMakeFormMessage(string);
+@ "wx:make-form-newline" : wxFormItem! wxMakeFormNewLine();
+
+// These aren't going to work right!
+@ "wx:make-form-long" : wxFormItem! wxMakeFormLong(string,long*,int=wxFORM_DEFAULT,wxList^=NULL, string=NULL,int=0,int=-1,int=-1);
+// @ "wx:make-form-short" : wxFormItem! wxMakeFormShort(string,short*,int=wxFORM_DEFAULT,wxList^=NULL, string=NULL,int=0,int=-1,int=-1);
+// @ "wx:make-form-float" : wxFormItem! wxMakeFormFloat(string,float*,int=wxFORM_DEFAULT,wxList^=NULL, string=NULL,int=0,int=-1,int=-1);
+// @ "wx:make-form-bool" : wxFormItem! wxMakeFormFloat(string,bool*,int=wxFORM_DEFAULT,wxList^=NULL, string=NULL,int=0,int=-1,int=-1);
+// @ "wx:make-form-string" : wxFormItem! wxMakeFormFloat(string,string*,int=wxFORM_DEFAULT,wxList^=NULL, string=NULL,int=0,int=-1,int=-1);
+
+@END
+
+@INCLUDE cb_end.xci
+
+#endif
diff --git a/src/mred/wxs/wxs_fram.cxx b/src/mred/wxs/wxs_fram.cxx
new file mode 100644
index 0000000..cf491a1
--- /dev/null
+++ b/src/mred/wxs/wxs_fram.cxx
@@ -0,0 +1,1077 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_fram.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_frame.h"
+#include "wx_gdi.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_fram.h"
+#include "wxscomon.h"
+
+
+#ifdef wx_xt
+#define NOT_XT 0
+#define HAS_GET_MENU_BAR 1
+#define GET_THE_MENU_BAR(f) (f)->GetMenuBar()
+#else
+#define HAS_GET_MENU_BAR 0
+#define NOT_XT 1
+#define GET_THE_MENU_BAR(f) (f)->wx_menu_bar
+#endif
+
+#ifdef wx_motif
+#define wxALLOW_AUTO_RESIZE wxPUSH_PIN
+#else
+#define wxALLOW_AUTO_RESIZE 0
+#endif
+
+#define NO_GET_MENU_BAR !HAS_GET_MENU_BAR
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxFrame : public wxFrame {
+ public:
+
+  os_wxFrame(Scheme_Object * obj, class wxFrame* x0, string x1, int x2 = -1, int x3 = -1, int x4 = -1, int x5 = -1, long x6 = wxDEFAULT_FRAME, string x7 = "frame");
+  ~os_wxFrame();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+  void OnMenuSelect(int x0);
+  void OnMenuCommand(int x0);
+  void Command(int x0);
+  Bool OnClose();
+  void OnActivate(Bool x0);
+};
+
+Scheme_Object *os_wxFrame_class;
+
+os_wxFrame::os_wxFrame(Scheme_Object * o, class wxFrame* x0, string x1, int x2, int x3, int x4, int x5, long x6, string x7)
+: wxFrame(x0, x1, x2, x3, x4, x5, x6, x7)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxFrame::~os_wxFrame()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxFrame::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:frame%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxFrame::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:frame%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxFrame::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxFrame::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxFrame::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxFrame::OnMenuSelect(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-menu-select", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnMenuSelect(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxFrame::OnMenuCommand(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-menu-command", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnMenuCommand(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxFrame::Command(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "command", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::Command(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxFrame::OnClose()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-close", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxFrame::OnClose();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:frame%::on-close"", extracting return value");
+  }
+}
+
+void os_wxFrame::OnActivate(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxFrame_class, "on-activate", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxFrame::OnActivate(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFramePreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:frame%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:frame%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFramePreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:frame%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:frame%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:frame%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:frame%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnSize(x0, x1);
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnSetFocus();
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnKillFocus();
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnMenuSelect(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  if (!GET_THE_MENU_BAR(((wxFrame *)((Scheme_Class_Object *)obj)->primdata))) return scheme_void;
+  x0 = objscheme_unbundle_integer(p[0], "wx:frame%::on-menu-select");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnMenuSelect(x0);
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnMenuSelect(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnMenuCommand(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:frame%::on-menu-command");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnMenuCommand(x0);
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnMenuCommand(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameCommand(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:frame%::command");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::Command(x0);
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->Command(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnClose(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnClose();
+  else
+    r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnClose();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameOnActivate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:frame%::on-activate");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxFrame *)((Scheme_Class_Object *)obj)->primdata)->wxFrame::OnActivate(x0);
+  else
+    ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->OnActivate(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameCreateStatusLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:frame%::create-status-line");
+  } else
+    x0 = 1;
+  if (n > 1) {
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:frame%::create-status-line");
+  } else
+    x1 = "status_line";
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->CreateStatusLine(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameLoadAccelerators(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:frame%::load-accelerators");
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->LoadAccelerators(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameMaximize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:frame%::maximize");
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->Maximize(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameStatusLineExists(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->StatusLineExists();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameIconized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->Iconized();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameSetStatusText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:frame%::set-status-text");
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->SetStatusText(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#if  USE_TOOLBAR
+#pragma argsused
+static Scheme_Object *os_wxFrameGetToolBar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxToolBar* r;
+  objscheme_check_valid(obj);
+#if  USE_TOOLBAR
+
+  
+
+  
+  r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->GetToolBar();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:frame%::get-tool-bar");
+#endif
+  return objscheme_bundle_wxToolBar(r);
+}
+#endif
+
+#if  USE_TOOLBAR
+#pragma argsused
+static Scheme_Object *os_wxFrameSetToolBar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+#if  USE_TOOLBAR
+  class wxToolBar* x0;
+
+  
+  x0 = objscheme_unbundle_wxToolBar(p[0], "wx:frame%::set-tool-bar", 1);
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->SetToolBar(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  HAS_GET_MENU_BAR
+#pragma argsused
+static Scheme_Object *os_wxFrameGetMenuBar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMenuBar* r;
+  objscheme_check_valid(obj);
+#if  HAS_GET_MENU_BAR
+
+  
+
+  
+  r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->GetMenuBar();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:frame%::get-menu-bar");
+#endif
+  return objscheme_bundle_wxMenuBar(r);
+}
+#endif
+
+#pragma argsused
+static Scheme_Object *os_wxFrameSetMenuBar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMenuBar* x0;
+
+  
+  x0 = objscheme_unbundle_wxMenuBar(p[0], "wx:frame%::set-menu-bar", 0);
+
+  if (GET_THE_MENU_BAR(((wxFrame *)((Scheme_Class_Object *)obj)->primdata))) return scheme_void;
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->SetMenuBar(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameSetIcon(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxIcon* x0;
+
+  
+  x0 = objscheme_unbundle_wxIcon(p[0], "wx:frame%::set-icon", 0);
+
+  if (x0 && !x0->Ok()) return scheme_void;
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->SetIcon(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameIconize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:frame%::iconize");
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->Iconize(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameSetTitle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:frame%::set-title");
+
+  
+  ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->SetTitle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFrameGetTitle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFrame *)((Scheme_Class_Object *)obj)->primdata)->GetTitle();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#if  NO_GET_MENU_BAR
+static Scheme_Object *objscheme_wxFrame_Getwx_menu_bar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxMenuBar* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-menu-bar", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxFrame *)cobj->primdata)->wxFrame::wx_menu_bar;
+  else
+    v = ((wxFrame *)cobj->primdata)->wx_menu_bar;
+
+  return objscheme_bundle_wxMenuBar(v);
+}
+#endif
+
+#pragma argsused
+static Scheme_Object *os_wxFrame_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxFrame *realobj;
+  class wxFrame* x0;
+  string x1;
+  int x2;
+  int x3;
+  int x4;
+  int x5;
+  long x6;
+  string x7;
+
+  
+  if ((n < 2) ||(n > 8)) 
+    scheme_wrong_count("wx:frame%::initialization", 2, 8, n, p);
+  x0 = objscheme_unbundle_wxFrame(p[0], "wx:frame%::initialization", 1);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:frame%::initialization");
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:frame%::initialization");
+  } else
+    x2 = -1;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:frame%::initialization");
+  } else
+    x3 = -1;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:frame%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:frame%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:frame%::initialization");
+  } else
+    x6 = wxDEFAULT_FRAME;
+  if (n > 7) {
+    x7 = (string)objscheme_unbundle_string(p[7], "wx:frame%::initialization");
+  } else
+    x7 = "frame";
+
+  if (!x4) x4 = -1;if (!x5) x5 = -1;
+  realobj = new os_wxFrame(obj, x0, x1, x2, x3, x4, x5, x6, x7);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxFrame(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:frame%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:frame%");
+}
+
+void objscheme_setup_wxFrame(void *env)
+{
+if (os_wxFrame_class) {
+    objscheme_add_global_class(os_wxFrame_class,  "wx:frame%", env);
+} else {
+  os_wxFrame_class = objscheme_def_prim_class(env, "wx:frame%", "wx:window%", os_wxFrame_ConstructScheme, 26);
+
+  scheme_add_method_w_arity(os_wxFrame_class,"get-class-name",objscheme_classname_os_wxFrame, 0, 0);
+
+ scheme_add_method_w_arity(os_wxFrame_class, "pre-on-event", os_wxFramePreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxFrame_class, "pre-on-char", os_wxFramePreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-size", os_wxFrameOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-set-focus", os_wxFrameOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-kill-focus", os_wxFrameOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-menu-select", os_wxFrameOnMenuSelect, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-menu-command", os_wxFrameOnMenuCommand, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "command", os_wxFrameCommand, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-close", os_wxFrameOnClose, 0, 0);
+ scheme_add_method_w_arity(os_wxFrame_class, "on-activate", os_wxFrameOnActivate, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "create-status-line", os_wxFrameCreateStatusLine, 0, 2);
+ scheme_add_method_w_arity(os_wxFrame_class, "load-accelerators", os_wxFrameLoadAccelerators, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "maximize", os_wxFrameMaximize, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "status-line-exists?", os_wxFrameStatusLineExists, 0, 0);
+ scheme_add_method_w_arity(os_wxFrame_class, "iconized?", os_wxFrameIconized, 0, 0);
+ scheme_add_method_w_arity(os_wxFrame_class, "set-status-text", os_wxFrameSetStatusText, 1, 1);
+#if  USE_TOOLBAR
+ scheme_add_method_w_arity(os_wxFrame_class, "get-tool-bar", os_wxFrameGetToolBar, 0, 0);
+#endif
+#if  USE_TOOLBAR
+ scheme_add_method_w_arity(os_wxFrame_class, "set-tool-bar", os_wxFrameSetToolBar, 1, 1);
+#endif
+#if  HAS_GET_MENU_BAR
+ scheme_add_method_w_arity(os_wxFrame_class, "get-menu-bar", os_wxFrameGetMenuBar, 0, 0);
+#endif
+ scheme_add_method_w_arity(os_wxFrame_class, "set-menu-bar", os_wxFrameSetMenuBar, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "set-icon", os_wxFrameSetIcon, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "iconize", os_wxFrameIconize, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "set-title", os_wxFrameSetTitle, 1, 1);
+ scheme_add_method_w_arity(os_wxFrame_class, "get-title", os_wxFrameGetTitle, 0, 0);
+
+#if  NO_GET_MENU_BAR
+  scheme_add_method_w_arity(os_wxFrame_class,"get-menu-bar", objscheme_wxFrame_Getwx_menu_bar, 0, 0);
+#endif
+
+  scheme_made_class(os_wxFrame_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxFrame, wxTYPE_FRAME);
+
+}
+  scheme_install_xc_global("wx:const-iconize", scheme_make_integer(wxICONIZE), env);
+  scheme_install_xc_global("wx:const-minimize", scheme_make_integer(wxMINIMIZE), env);
+  scheme_install_xc_global("wx:const-maximize", scheme_make_integer(wxMAXIMIZE), env);
+  scheme_install_xc_global("wx:const-sdi", scheme_make_integer(wxSDI), env);
+  scheme_install_xc_global("wx:const-mdi-parent", scheme_make_integer(wxMDI_PARENT), env);
+  scheme_install_xc_global("wx:const-mdi-child", scheme_make_integer(wxMDI_CHILD), env);
+  scheme_install_xc_global("wx:const-thick-frame", scheme_make_integer(wxTHICK_FRAME), env);
+  scheme_install_xc_global("wx:const-system-menu", scheme_make_integer(wxSYSTEM_MENU), env);
+  scheme_install_xc_global("wx:const-minimize-box", scheme_make_integer(wxMINIMIZE_BOX), env);
+  scheme_install_xc_global("wx:const-maximize-box", scheme_make_integer(wxMAXIMIZE_BOX), env);
+  scheme_install_xc_global("wx:const-resize-border", scheme_make_integer(wxRESIZE_BORDER), env);
+  scheme_install_xc_global("wx:const-default-frame", scheme_make_integer(wxDEFAULT_FRAME), env);
+  scheme_install_xc_global("wx:const-allow-auto-resize", scheme_make_integer(wxALLOW_AUTO_RESIZE), env);
+  scheme_install_xc_global("wx:const-both", scheme_make_integer(wxBOTH), env);
+  scheme_install_xc_global("wx:const-horizontal", scheme_make_integer(wxHORIZONTAL), env);
+  scheme_install_xc_global("wx:const-vertical", scheme_make_integer(wxVERTICAL), env);
+}
+
+int objscheme_istype_wxFrame(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxFrame_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:frame%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxFrame(class wxFrame *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_FRAME) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxFrame_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxFrame(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxFrame *)o->primdata;
+  else
+    return (wxFrame *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_fram.h b/src/mred/wxs/wxs_fram.h
new file mode 100644
index 0000000..b18a100
--- /dev/null
+++ b/src/mred/wxs/wxs_fram.h
@@ -0,0 +1,23 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxToolBar(class wxToolBar *);
+extern class wxToolBar *objscheme_unbundle_wxToolBar(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMenuBar(class wxMenuBar *);
+extern class wxMenuBar *objscheme_unbundle_wxMenuBar(Scheme_Object *, const char *, int);
+extern class wxIcon *objscheme_unbundle_wxIcon(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMenuBar(class wxMenuBar *);
+extern class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxFrame(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxFrame(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxFrame(class wxFrame *realobj);
+class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_fram.xc b/src/mred/wxs/wxs_fram.xc
new file mode 100644
index 0000000..0c37963
--- /dev/null
+++ b/src/mred/wxs/wxs_fram.xc
@@ -0,0 +1,85 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_frame.h"
+#include "wx_gdi.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#ifdef wx_xt
+#define NOT_XT 0
+#define HAS_GET_MENU_BAR 1
+#define GET_THE_MENU_BAR(f) (f)->GetMenuBar()
+#else
+#define HAS_GET_MENU_BAR 0
+#define NOT_XT 1
+#define GET_THE_MENU_BAR(f) (f)->wx_menu_bar
+#endif
+
+#ifdef wx_motif
+#define wxALLOW_AUTO_RESIZE wxPUSH_PIN
+#else
+#define wxALLOW_AUTO_RESIZE 0
+#endif
+
+#define NO_GET_MENU_BAR !HAS_GET_MENU_BAR
+
+@MACRO CHECKHASMENU[log] = if (<log>GET_THE_MENU_BAR(((wxFrame *)((Scheme_Class_Object *)obj)->primdata))) return scheme_void;
+
+@CLASSBASE wxFrame "wx:frame":"wx:window"
+
+@CLASSID wxTYPE_FRAME
+
+@CREATOR (wxFrame^, string, int = -1, int = -1, int = -1, int = -1, long = wxDEFAULT_FRAME, string = "frame") : : /NOZERO[4]|NOZERO[5]/
+
+@MACRO CHECKICONOK[p] = if (x<p> && !x<p>->Ok()) return scheme_void;
+
+@ "get-title" : string GetTitle();
+@ "set-title" : void SetTitle(string);
+@ "iconize" : void Iconize(bool);
+@ "set-icon" : void SetIcon(wxIcon!); : : /CHECKICONOK[0]
+@ "set-menu-bar" : void SetMenuBar(wxMenuBar!) : : /CHECKHASMENU[ ]
+@IVAR r "menu-bar" : wxMenuBar^ wx_menu_bar ## NO_GET_MENU_BAR
+@ "get-menu-bar" : wxMenuBar^ GetMenuBar() ## HAS_GET_MENU_BAR
+@ "set-tool-bar" : void SetToolBar(wxToolBar^) ## USE_TOOLBAR 
+@ "get-tool-bar" : wxToolBar^ GetToolBar() ## USE_TOOLBAR
+@ "set-status-text" : void SetStatusText(string);
+@ "iconized?" : bool Iconized();
+@ "status-line-exists?" : bool StatusLineExists();
+@ "maximize" : void Maximize(bool)
+@ "load-accelerators" : void LoadAccelerators(string);
+@ "create-status-line" : void CreateStatusLine(int = 1, string = "status_line")
+
+@SETMARK f = d
+@INCLUDE wxs_fram.xci
+
+@ v "command" : void Command(int);
+@ v "on-menu-command" : void OnMenuCommand(int)
+@ v "on-menu-select" : void OnMenuSelect(int) : : CHECKHASMENU[!]
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
+
+@MACRO TRUE = return TRUE;
+
+@CONSTANT "wx:const-iconize" : long wxICONIZE
+@CONSTANT "wx:const-minimize" : long wxMINIMIZE
+@CONSTANT "wx:const-maximize" : long wxMAXIMIZE
+@CONSTANT "wx:const-sdi" : long wxSDI
+@CONSTANT "wx:const-mdi-parent" : long wxMDI_PARENT
+@CONSTANT "wx:const-mdi-child" : long wxMDI_CHILD
+@CONSTANT "wx:const-thick-frame" : long wxTHICK_FRAME
+@CONSTANT "wx:const-system-menu" : long wxSYSTEM_MENU
+@CONSTANT "wx:const-minimize-box" : long wxMINIMIZE_BOX
+@CONSTANT "wx:const-maximize-box" : long wxMAXIMIZE_BOX
+@CONSTANT "wx:const-resize-border" : long wxRESIZE_BORDER
+@CONSTANT "wx:const-default-frame" : long wxDEFAULT_FRAME
+@CONSTANT "wx:const-allow-auto-resize" : long wxALLOW_AUTO_RESIZE
+
+@CONSTANT "wx:const-both" : int wxBOTH
+@CONSTANT "wx:const-horizontal" : int wxHORIZONTAL
+@CONSTANT "wx:const-vertical" : int wxVERTICAL
+
+@END
diff --git a/src/mred/wxs/wxs_fram.xci b/src/mred/wxs/wxs_fram.xci
new file mode 100644
index 0000000..76de6cb
--- /dev/null
+++ b/src/mred/wxs/wxs_fram.xci
@@ -0,0 +1,3 @@
+
+@ f "on-activate" : void OnActivate(bool);
+@ f "on-close" : bool OnClose();
diff --git a/src/mred/wxs/wxs_gage.cxx b/src/mred/wxs/wxs_gage.cxx
new file mode 100644
index 0000000..27c985d
--- /dev/null
+++ b/src/mred/wxs/wxs_gage.cxx
@@ -0,0 +1,561 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_gage.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_gauge.h"
+
+
+
+
+
+class wxsGauge : public wxGauge
+{
+ public:
+   int range, pos;
+
+   wxsGauge(wxPanel *panel, char *label, int rng,
+	    int x = -1, int y = -1, int width = -1, int height = -1,
+	    long style = wxHORIZONTAL, char *name = "gauge")
+    : wxGauge(panel, label, rng, x, y, width, height,
+	      style, name)
+  {
+    range = rng; pos = 0;
+  }
+  void SetRange(int r) {
+    if (r > 0) {
+      range = r;
+      wxGauge::SetRange(r);
+      if (pos > r) {
+       pos = r;
+       wxGauge::SetValue(r);
+      }
+    }
+  }
+  void SetValue(int v) {
+    if (v >= 0 && v <= range) {
+     pos = v;
+     wxGauge::SetValue(v);
+    }
+  }
+  int GetValue(void) { return pos; }
+  int GetRange(void) { return range; }
+};
+
+#include "wxscheme.h"
+#include "wxs_gage.h"
+#include "wxscomon.h"
+
+
+
+
+
+
+
+
+
+
+class os_wxsGauge : public wxsGauge {
+ public:
+
+  os_wxsGauge(Scheme_Object * obj, class wxPanel* x0, nstring x1, int x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, long x7 = wxHORIZONTAL, string x8 = "gauge");
+  ~os_wxsGauge();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxsGauge_class;
+
+os_wxsGauge::os_wxsGauge(Scheme_Object * o, class wxPanel* x0, nstring x1, int x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxsGauge(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxsGauge::~os_wxsGauge()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxsGauge::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxsGauge_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:gauge%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxsGauge::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxsGauge_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:gauge%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxsGauge::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxsGauge_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxsGauge::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxsGauge::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxsGauge_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxsGauge::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxsGauge::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxsGauge_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxsGauge::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeGetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->GetValue();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeSetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:gauge%::set-value");
+
+  
+  ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->SetValue(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeGetRange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->GetRange();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeSetRange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:gauge%::set-range");
+
+  
+  ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->SetRange(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugePreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:gauge%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:gauge%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxsGauge *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugePreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:gauge%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:gauge%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxsGauge *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:gauge%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:gauge%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->wxsGauge::OnSize(x0, x1);
+  else
+    ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->wxsGauge::OnSetFocus();
+  else
+    ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGaugeOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->wxsGauge::OnKillFocus();
+  else
+    ((wxsGauge *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxsGauge_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxsGauge *realobj;
+  class wxPanel* x0;
+  nstring x1;
+  int x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  long x7;
+  string x8;
+
+  
+  if ((n < 3) ||(n > 9)) 
+    scheme_wrong_count("wx:gauge%::initialization", 3, 9, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:gauge%::initialization", 0);
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:gauge%::initialization");
+  x2 = objscheme_unbundle_integer(p[2], "wx:gauge%::initialization");
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:gauge%::initialization");
+  } else
+    x3 = -1;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:gauge%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:gauge%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:gauge%::initialization");
+  } else
+    x6 = -1;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:gauge%::initialization");
+  } else
+    x7 = wxHORIZONTAL;
+  if (n > 8) {
+    x8 = (string)objscheme_unbundle_string(p[8], "wx:gauge%::initialization");
+  } else
+    x8 = "gauge";
+
+  if (!x5) x5 = -1;if (!x6) x6 = -1;
+  realobj = new os_wxsGauge(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxsGauge(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:gauge%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:gauge%");
+}
+
+void objscheme_setup_wxsGauge(void *env)
+{
+if (os_wxsGauge_class) {
+    objscheme_add_global_class(os_wxsGauge_class,  "wx:gauge%", env);
+} else {
+  os_wxsGauge_class = objscheme_def_prim_class(env, "wx:gauge%", "wx:item%", os_wxsGauge_ConstructScheme, 10);
+
+  scheme_add_method_w_arity(os_wxsGauge_class,"get-class-name",objscheme_classname_os_wxsGauge, 0, 0);
+
+ scheme_add_method_w_arity(os_wxsGauge_class, "get-value", os_wxsGaugeGetValue, 0, 0);
+ scheme_add_method_w_arity(os_wxsGauge_class, "set-value", os_wxsGaugeSetValue, 1, 1);
+ scheme_add_method_w_arity(os_wxsGauge_class, "get-range", os_wxsGaugeGetRange, 0, 0);
+ scheme_add_method_w_arity(os_wxsGauge_class, "set-range", os_wxsGaugeSetRange, 1, 1);
+ scheme_add_method_w_arity(os_wxsGauge_class, "pre-on-event", os_wxsGaugePreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxsGauge_class, "pre-on-char", os_wxsGaugePreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxsGauge_class, "on-size", os_wxsGaugeOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxsGauge_class, "on-set-focus", os_wxsGaugeOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxsGauge_class, "on-kill-focus", os_wxsGaugeOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxsGauge_class);
+
+
+}
+}
+
+int objscheme_istype_wxsGauge(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxsGauge_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:gauge%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxsGauge(class wxsGauge *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxsGauge_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxsGauge *objscheme_unbundle_wxsGauge(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxsGauge(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxsGauge *)o->primdata;
+  else
+    return (wxsGauge *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_gage.h b/src/mred/wxs/wxs_gage.h
new file mode 100644
index 0000000..fab493d
--- /dev/null
+++ b/src/mred/wxs/wxs_gage.h
@@ -0,0 +1,17 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxsGauge(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxsGauge(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxsGauge(class wxsGauge *realobj);
+class wxsGauge *objscheme_unbundle_wxsGauge(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_gage.xc b/src/mred/wxs/wxs_gage.xc
new file mode 100644
index 0000000..813de90
--- /dev/null
+++ b/src/mred/wxs/wxs_gage.xc
@@ -0,0 +1,54 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_gauge.h"
+
+@INCLUDE wxs.xci
+
+class wxsGauge : public wxGauge
+{
+ public:
+   int range, pos;
+
+   wxsGauge(wxPanel *panel, char *label, int rng,
+	    int x = -1, int y = -1, int width = -1, int height = -1,
+	    long style = wxHORIZONTAL, char *name = "gauge")
+    : wxGauge(panel, label, rng, x, y, width, height,
+	      style, name)
+  {
+    range = rng; pos = 0;
+  }
+  void SetRange(int r) {
+    if (r > 0) {
+      range = r;
+      wxGauge::SetRange(r);
+      if (pos > r) {
+       pos = r;
+       wxGauge::SetValue(r);
+      }
+    }
+  }
+  void SetValue(int v) {
+    if (v >= 0 && v <= range) {
+     pos = v;
+     wxGauge::SetValue(v);
+    }
+  }
+  int GetValue(void) { return pos; }
+  int GetRange(void) { return range; }
+};
+
+@HEADER
+
+@CLASSBASE wxsGauge "wx:gauge" : "wx:item"
+
+@CREATOR (wxPanel!,nstring,int,int=-1,int=-1,int=-1,int=-1,long=wxHORIZONTAL,string="gauge"); : : /NOZERO[5]|NOZERO[6]//
+
+@INCLUDE wxs_item.xci
+
+@ "set-range" : void SetRange(int);
+@ "get-range" : int GetRange();
+@ "set-value" : void SetValue(int);
+@ "get-value" : int GetValue();
+
+@END
diff --git a/src/mred/wxs/wxs_gdi.cxx b/src/mred/wxs/wxs_gdi.cxx
new file mode 100644
index 0000000..e089eaf
--- /dev/null
+++ b/src/mred/wxs/wxs_gdi.cxx
@@ -0,0 +1,3284 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_gdi.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_obj.h"
+#include "wx_list.h"
+#include "wx_gdi.h"
+#ifdef wx_xt
+#include "wx_dc.h"
+#endif
+
+
+
+
+
+#include "wxs_bmt.h"
+
+#include "wxscheme.h"
+#include "wxs_gdi.h"
+#include "wxscomon.h"
+
+
+#define USE_FONT_NAME_DIRECTORY 1
+
+#if defined(wx_mac) || defined(wx_xt)
+#define COLORMAP_CREATE 0
+#else
+#define COLORMAP_CREATE 1
+#endif
+
+
+
+
+
+
+// Not used:
+// @CONSTANT "wx:const-variable" : int wxVARIABLE
+// @CONSTANT "wx:const-fixed" : int wxFIXED
+
+
+
+class os_wxFont : public wxFont {
+ public:
+
+  os_wxFont(Scheme_Object * obj);
+  os_wxFont(Scheme_Object * obj, nnint x0, int x1, int x2, int x3, Bool x4 = 0);
+  os_wxFont(Scheme_Object * obj, nnint x0, cstring x1, int x2, int x3, int x4, Bool x5 = 0);
+  ~os_wxFont();
+};
+
+Scheme_Object *os_wxFont_class;
+
+os_wxFont::os_wxFont(Scheme_Object * o)
+: wxFont()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxFont::os_wxFont(Scheme_Object * o, nnint x0, int x1, int x2, int x3, Bool x4)
+: wxFont(x0, x1, x2, x3, x4)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+#if  USE_FONT_NAME_DIRECTORY 
+os_wxFont::os_wxFont(Scheme_Object * o, nnint x0, cstring x1, int x2, int x3, int x4, Bool x5)
+: wxFont(x0, x1, x2, x3, x4, x5)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+#endif
+
+os_wxFont::~os_wxFont()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontGetUnderlined(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetUnderlined();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontGetWeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetWeight();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontGetPointSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetPointSize();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontGetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetStyle();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#if  USE_FONT_NAME_DIRECTORY
+#pragma argsused
+static Scheme_Object *os_wxFontGetFontId(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+#if  USE_FONT_NAME_DIRECTORY
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetFontId();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:font%::get-font-id");
+#endif
+  return scheme_make_integer(r);
+}
+#endif
+
+#pragma argsused
+static Scheme_Object *os_wxFontGetFamily(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFont *)((Scheme_Class_Object *)obj)->primdata)->GetFamily();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFont_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxFont *realobj;
+  if ((n >= 2) && objscheme_istype_number(p[0], NULL) && objscheme_istype_string(p[1], NULL)) {
+#if  USE_FONT_NAME_DIRECTORY 
+    nnint x0;
+    cstring x1;
+    int x2;
+    int x3;
+    int x4;
+    Bool x5;
+
+    
+    if ((n < 5) ||(n > 6)) 
+      scheme_wrong_count("wx:font%::initialization (font name case)", 5, 6, n, p);
+    x0 = objscheme_unbundle_nonnegative_integer(p[0], "wx:font%::initialization (font name case)");
+    x1 = (cstring)objscheme_unbundle_string(p[1], "wx:font%::initialization (font name case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:font%::initialization (font name case)");
+    x3 = objscheme_unbundle_integer(p[3], "wx:font%::initialization (font name case)");
+    x4 = objscheme_unbundle_integer(p[4], "wx:font%::initialization (font name case)");
+    if (n > 5) {
+      x5 = objscheme_unbundle_bool(p[5], "wx:font%::initialization (font name case)");
+    } else
+      x5 = 0;
+
+    
+    realobj = new os_wxFont(obj, x0, x1, x2, x3, x4, x5);
+    
+    
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:font%::initialization (font name case)");
+#endif
+  } else if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    nnint x0;
+    int x1;
+    int x2;
+    int x3;
+    Bool x4;
+
+    
+    if ((n < 4) ||(n > 5)) 
+      scheme_wrong_count("wx:font%::initialization (font id case)", 4, 5, n, p);
+    x0 = objscheme_unbundle_nonnegative_integer(p[0], "wx:font%::initialization (font id case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:font%::initialization (font id case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:font%::initialization (font id case)");
+    x3 = objscheme_unbundle_integer(p[3], "wx:font%::initialization (font id case)");
+    if (n > 4) {
+      x4 = objscheme_unbundle_bool(p[4], "wx:font%::initialization (font id case)");
+    } else
+      x4 = 0;
+
+    
+    realobj = new os_wxFont(obj, x0, x1, x2, x3, x4);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:font%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxFont(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:font%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:font%");
+}
+
+void objscheme_setup_wxFont(void *env)
+{
+if (os_wxFont_class) {
+    objscheme_add_global_class(os_wxFont_class,  "wx:font%", env);
+} else {
+  os_wxFont_class = objscheme_def_prim_class(env, "wx:font%", "wx:object%", os_wxFont_ConstructScheme, 7);
+
+  scheme_add_method_w_arity(os_wxFont_class,"get-class-name",objscheme_classname_os_wxFont, 0, 0);
+
+ scheme_add_method_w_arity(os_wxFont_class, "get-underlined", os_wxFontGetUnderlined, 0, 0);
+ scheme_add_method_w_arity(os_wxFont_class, "get-weight", os_wxFontGetWeight, 0, 0);
+ scheme_add_method_w_arity(os_wxFont_class, "get-point-size", os_wxFontGetPointSize, 0, 0);
+ scheme_add_method_w_arity(os_wxFont_class, "get-style", os_wxFontGetStyle, 0, 0);
+#if  USE_FONT_NAME_DIRECTORY
+ scheme_add_method_w_arity(os_wxFont_class, "get-font-id", os_wxFontGetFontId, 0, 0);
+#endif
+ scheme_add_method_w_arity(os_wxFont_class, "get-family", os_wxFontGetFamily, 0, 0);
+
+
+  scheme_made_class(os_wxFont_class);
+
+
+}
+  scheme_install_xc_global("wx:const-default", scheme_make_integer(wxDEFAULT), env);
+  scheme_install_xc_global("wx:const-decorative", scheme_make_integer(wxDECORATIVE), env);
+  scheme_install_xc_global("wx:const-roman", scheme_make_integer(wxROMAN), env);
+  scheme_install_xc_global("wx:const-script", scheme_make_integer(wxSCRIPT), env);
+  scheme_install_xc_global("wx:const-swiss", scheme_make_integer(wxSWISS), env);
+  scheme_install_xc_global("wx:const-modern", scheme_make_integer(wxMODERN), env);
+  scheme_install_xc_global("wx:const-teletype", scheme_make_integer(wxTELETYPE), env);
+  scheme_install_xc_global("wx:const-system", scheme_make_integer(wxSYSTEM), env);
+  scheme_install_xc_global("wx:const-normal", scheme_make_integer(wxNORMAL), env);
+  scheme_install_xc_global("wx:const-light", scheme_make_integer(wxLIGHT), env);
+  scheme_install_xc_global("wx:const-bold", scheme_make_integer(wxBOLD), env);
+  scheme_install_xc_global("wx:const-italic", scheme_make_integer(wxITALIC), env);
+  scheme_install_xc_global("wx:const-slant", scheme_make_integer(wxSLANT), env);
+}
+
+int objscheme_istype_wxFont(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxFont_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:font%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxFont(class wxFont *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxFont_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxFont *objscheme_unbundle_wxFont(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxFont(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxFont *)o->primdata;
+  else
+    return (wxFont *)o->primdata;
+}
+
+
+
+
+
+// @ "remove-font" : void RemoveFont(wxFont!);
+
+
+class os_wxFontList : public wxFontList {
+ public:
+
+  os_wxFontList(Scheme_Object * obj);
+  ~os_wxFontList();
+};
+
+Scheme_Object *os_wxFontList_class;
+
+os_wxFontList::os_wxFontList(Scheme_Object * o)
+: wxFontList()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxFontList::~os_wxFontList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontListFindOrCreateFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxFont* r;
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_number(p[0], NULL) && objscheme_istype_number(p[1], NULL)) {
+    nnint x0;
+    int x1;
+    int x2;
+    int x3;
+    Bool x4;
+
+    
+    if ((n < 4) ||(n > 5)) 
+      scheme_wrong_count("wx:font-list%::find-or-create-font (font id case)", 4, 5, n, p);
+    x0 = objscheme_unbundle_nonnegative_integer(p[0], "wx:font-list%::find-or-create-font (font id case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:font-list%::find-or-create-font (font id case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:font-list%::find-or-create-font (font id case)");
+    x3 = objscheme_unbundle_integer(p[3], "wx:font-list%::find-or-create-font (font id case)");
+    if (n > 4) {
+      x4 = objscheme_unbundle_bool(p[4], "wx:font-list%::find-or-create-font (font id case)");
+    } else
+      x4 = 0;
+
+    
+    r = ((wxFontList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateFont(x0, x1, x2, x3, x4);
+
+    
+    
+  } else  {
+#if  USE_FONT_NAME_DIRECTORY
+    nnint x0;
+    cstring x1;
+    int x2;
+    int x3;
+    int x4;
+    Bool x5;
+
+    
+    if ((n < 5) ||(n > 6)) 
+      scheme_wrong_count("wx:font-list%::find-or-create-font (font name case)", 5, 6, n, p);
+    x0 = objscheme_unbundle_nonnegative_integer(p[0], "wx:font-list%::find-or-create-font (font name case)");
+    x1 = (cstring)objscheme_unbundle_string(p[1], "wx:font-list%::find-or-create-font (font name case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:font-list%::find-or-create-font (font name case)");
+    x3 = objscheme_unbundle_integer(p[3], "wx:font-list%::find-or-create-font (font name case)");
+    x4 = objscheme_unbundle_integer(p[4], "wx:font-list%::find-or-create-font (font name case)");
+    if (n > 5) {
+      x5 = objscheme_unbundle_bool(p[5], "wx:font-list%::find-or-create-font (font name case)");
+    } else
+      x5 = 0;
+
+    
+    r = ((wxFontList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateFont(x0, x1, x2, x3, x4, x5);
+
+    
+    
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "wx:font-list%::find-or-create-font (font name case)");
+#endif
+  }
+
+  return objscheme_bundle_wxFont(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontList_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxFontList *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:font-list%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxFontList(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxFontList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:font-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:font-list%");
+}
+
+void objscheme_setup_wxFontList(void *env)
+{
+if (os_wxFontList_class) {
+    objscheme_add_global_class(os_wxFontList_class,  "wx:font-list%", env);
+} else {
+  os_wxFontList_class = objscheme_def_prim_class(env, "wx:font-list%", "wx:object%", os_wxFontList_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxFontList_class,"get-class-name",objscheme_classname_os_wxFontList, 0, 0);
+
+#if  USE_FONT_NAME_DIRECTORY
+ scheme_add_method(os_wxFontList_class, "find-or-create-font", os_wxFontListFindOrCreateFont);
+#endif
+
+
+  scheme_made_class(os_wxFontList_class);
+
+
+}
+  scheme_install_xc_global("wx:the-font-list", objscheme_bundle_wxFontList(wxTheFontList), env);
+}
+
+int objscheme_istype_wxFontList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxFontList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:font-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxFontList(class wxFontList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxFontList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxFontList *objscheme_unbundle_wxFontList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxFontList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxFontList *)o->primdata;
+  else
+    return (wxFontList *)o->primdata;
+}
+
+
+
+
+
+
+
+class os_wxColour : public wxColour {
+ public:
+
+  os_wxColour(Scheme_Object * obj);
+  os_wxColour(Scheme_Object * obj, ubyte x0, ubyte x1, ubyte x2);
+  os_wxColour(Scheme_Object * obj, string x0);
+  ~os_wxColour();
+};
+
+Scheme_Object *os_wxColour_class;
+
+os_wxColour::os_wxColour(Scheme_Object * o)
+: wxColour()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxColour::os_wxColour(Scheme_Object * o, ubyte x0, ubyte x1, ubyte x2)
+: wxColour(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxColour::os_wxColour(Scheme_Object * o, string x0)
+: wxColour(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxColour::~os_wxColour()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourBlue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  ubyte r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Blue();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourGreen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  ubyte r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Green();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourRed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  ubyte r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Red();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourSet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  ubyte x0;
+  ubyte x1;
+  ubyte x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:colour%::set");
+  x1 = objscheme_unbundle_integer(p[1], "wx:colour%::set");
+  x2 = objscheme_unbundle_integer(p[2], "wx:colour%::set");
+
+  if (!((wxColour *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:colour%::set", "colour", "colour");
+  ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Set(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourGet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  ubyte _x0;
+  ubyte* x0 = &_x0;
+  ubyte _x1;
+  ubyte* x1 = &_x1;
+  ubyte _x2;
+  ubyte* x2 = &_x2;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:colour%::get", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:colour%::get"), "wx:colour%::get");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:colour%::get", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:colour%::get"), "wx:colour%::get");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:colour%::get", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:colour%::get"), "wx:colour%::get");
+
+  
+  ((wxColour *)((Scheme_Class_Object *)obj)->primdata)->Get(x0, x1, x2);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColouroperatorEQUAL(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:colour%::=", 0);
+
+  if (!((wxColour *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:colour%::=", "colour", "colour");
+  r = &((wxColour *)((Scheme_Class_Object *)obj)->primdata)->operator=(*x0);
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColour_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxColour *realobj;
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:colour%::initialization (color name case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:colour%::initialization (color name case)");
+
+    
+    realobj = new os_wxColour(obj, x0);
+    
+    
+  } else if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    ubyte x0;
+    ubyte x1;
+    ubyte x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:colour%::initialization (rgb values case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:colour%::initialization (rgb values case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:colour%::initialization (rgb values case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:colour%::initialization (rgb values case)");
+
+    
+    realobj = new os_wxColour(obj, x0, x1, x2);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:colour%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxColour(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:colour%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:colour%");
+}
+
+void objscheme_setup_wxColour(void *env)
+{
+if (os_wxColour_class) {
+    objscheme_add_global_class(os_wxColour_class,  "wx:colour%", env);
+} else {
+  os_wxColour_class = objscheme_def_prim_class(env, "wx:colour%", "wx:object%", os_wxColour_ConstructScheme, 8);
+
+  scheme_add_method_w_arity(os_wxColour_class,"get-class-name",objscheme_classname_os_wxColour, 0, 0);
+
+ scheme_add_method_w_arity(os_wxColour_class, "blue", os_wxColourBlue, 0, 0);
+ scheme_add_method_w_arity(os_wxColour_class, "green", os_wxColourGreen, 0, 0);
+ scheme_add_method_w_arity(os_wxColour_class, "red", os_wxColourRed, 0, 0);
+ scheme_add_method_w_arity(os_wxColour_class, "set", os_wxColourSet, 3, 3);
+ scheme_add_method_w_arity(os_wxColour_class, "ok?", os_wxColourOk, 0, 0);
+ scheme_add_method_w_arity(os_wxColour_class, "get", os_wxColourGet, 3, 3);
+ scheme_add_method_w_arity(os_wxColour_class, "=", os_wxColouroperatorEQUAL, 1, 1);
+
+
+  scheme_made_class(os_wxColour_class);
+
+
+}
+}
+
+int objscheme_istype_wxColour(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxColour_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:colour%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxColour(class wxColour *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxColour_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxColour *objscheme_unbundle_wxColour(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxColour(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxColour *)o->primdata;
+  else
+    return (wxColour *)o->primdata;
+}
+
+
+
+
+// @CREATOR (); ## !defined(wx_mac)
+
+// @ "create" : bool Create(int,custring,custring,custring); ## COLORMAP_CREATE
+
+class os_wxColourMap : public wxColourMap {
+ public:
+
+  ~os_wxColourMap();
+};
+
+Scheme_Object *os_wxColourMap_class;
+
+os_wxColourMap::~os_wxColourMap()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+static Scheme_Object *objscheme_classname_os_wxColourMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:colour-map%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:colour-map%");
+}
+
+void objscheme_setup_wxColourMap(void *env)
+{
+if (os_wxColourMap_class) {
+    objscheme_add_global_class(os_wxColourMap_class,  "wx:colour-map%", env);
+} else {
+  os_wxColourMap_class = objscheme_def_prim_class(env, "wx:colour-map%", "wx:object%", NULL, 1);
+
+  scheme_add_method_w_arity(os_wxColourMap_class,"get-class-name",objscheme_classname_os_wxColourMap, 0, 0);
+
+
+
+  scheme_made_class(os_wxColourMap_class);
+
+
+}
+}
+
+int objscheme_istype_wxColourMap(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxColourMap_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:colour-map%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxColourMap(class wxColourMap *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxColourMap_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxColourMap *objscheme_unbundle_wxColourMap(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxColourMap(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxColourMap *)o->primdata;
+  else
+    return (wxColourMap *)o->primdata;
+}
+
+
+#ifdef wx_mac
+#define _KEY_TYPE KeyType
+#else
+#define _KEY_TYPE int
+#endif
+
+// Since we don't allow creating this anymore, need a Mac fix:
+#if defined(wx_mac)
+#define CDB_FIX os_wxColourDatabase(_KEY_TYPE x) : wxColourDatabase(x) {}
+#else
+#define CDB_FIX 
+#endif
+
+
+
+// @CREATOR (_KEY_TYPE/bInt/ubIntKey/tInt);
+
+// @ "initialize" : void Initialize(); ## !defined(wx_xt)
+
+
+class os_wxColourDatabase : public wxColourDatabase {
+ public:
+  CDB_FIX
+
+  ~os_wxColourDatabase();
+};
+
+Scheme_Object *os_wxColourDatabase_class;
+
+os_wxColourDatabase::~os_wxColourDatabase()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourDatabaseAppend(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  class wxColour* x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:colour-database%::append");
+  x1 = objscheme_unbundle_wxColour(p[1], "wx:colour-database%::append", 0);
+
+  
+  ((wxColourDatabase *)((Scheme_Class_Object *)obj)->primdata)->Append(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourDatabaseFindName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:colour-database%::find-name", 0);
+
+  
+  r = ((wxColourDatabase *)((Scheme_Class_Object *)obj)->primdata)->FindName(*x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxColourDatabaseFindColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:colour-database%::find-colour");
+
+  
+  r = ((wxColourDatabase *)((Scheme_Class_Object *)obj)->primdata)->FindColour(x0);
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxColourDatabase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:colour-database%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:colour-database%");
+}
+
+void objscheme_setup_wxColourDatabase(void *env)
+{
+if (os_wxColourDatabase_class) {
+    objscheme_add_global_class(os_wxColourDatabase_class,  "wx:colour-database%", env);
+} else {
+  os_wxColourDatabase_class = objscheme_def_prim_class(env, "wx:colour-database%", "wx:object%", NULL, 4);
+
+  scheme_add_method_w_arity(os_wxColourDatabase_class,"get-class-name",objscheme_classname_os_wxColourDatabase, 0, 0);
+
+ scheme_add_method_w_arity(os_wxColourDatabase_class, "append", os_wxColourDatabaseAppend, 2, 2);
+ scheme_add_method_w_arity(os_wxColourDatabase_class, "find-name", os_wxColourDatabaseFindName, 1, 1);
+ scheme_add_method_w_arity(os_wxColourDatabase_class, "find-colour", os_wxColourDatabaseFindColour, 1, 1);
+
+
+  scheme_made_class(os_wxColourDatabase_class);
+
+
+}
+  scheme_install_xc_global("wx:the-colour-database", objscheme_bundle_wxColourDatabase(wxTheColourDatabase), env);
+}
+
+int objscheme_istype_wxColourDatabase(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxColourDatabase_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:colour-database%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxColourDatabase(class wxColourDatabase *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxColourDatabase_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxColourDatabase *objscheme_unbundle_wxColourDatabase(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxColourDatabase(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxColourDatabase *)o->primdata;
+  else
+    return (wxColourDatabase *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxPoint : public wxPoint {
+ public:
+
+  os_wxPoint(Scheme_Object * obj);
+  os_wxPoint(Scheme_Object * obj, float x0, float x1);
+  ~os_wxPoint();
+};
+
+Scheme_Object *os_wxPoint_class;
+
+os_wxPoint::os_wxPoint(Scheme_Object * o)
+: wxPoint()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPoint::os_wxPoint(Scheme_Object * o, float x0, float x1)
+: wxPoint(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPoint::~os_wxPoint()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+static Scheme_Object *objscheme_wxPoint_Getx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-x", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxPoint *)cobj->primdata)->wxPoint::x;
+  else
+    v = ((wxPoint *)cobj->primdata)->x;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxPoint_Setx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-x", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:point%::x");
+  ((wxPoint *)cobj->primdata)->x = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxPoint_Gety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-y", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxPoint *)cobj->primdata)->wxPoint::y;
+  else
+    v = ((wxPoint *)cobj->primdata)->y;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxPoint_Sety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-y", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:point%::y");
+  ((wxPoint *)cobj->primdata)->y = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPoint_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxPoint *realobj;
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    float x0;
+    float x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:point%::initialization (xy values case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_float(p[0], "wx:point%::initialization (xy values case)");
+    x1 = objscheme_unbundle_float(p[1], "wx:point%::initialization (xy values case)");
+
+    
+    realobj = new os_wxPoint(obj, x0, x1);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:point%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxPoint(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:point%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:point%");
+}
+
+void objscheme_setup_wxPoint(void *env)
+{
+if (os_wxPoint_class) {
+    objscheme_add_global_class(os_wxPoint_class,  "wx:point%", env);
+} else {
+  os_wxPoint_class = objscheme_def_prim_class(env, "wx:point%", "wx:object%", os_wxPoint_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxPoint_class,"get-class-name",objscheme_classname_os_wxPoint, 0, 0);
+
+
+  scheme_add_method_w_arity(os_wxPoint_class,"get-x", objscheme_wxPoint_Getx, 0, 0);
+  scheme_add_method_w_arity(os_wxPoint_class,"set-x", objscheme_wxPoint_Setx, 1, 1);
+  scheme_add_method_w_arity(os_wxPoint_class,"get-y", objscheme_wxPoint_Gety, 0, 0);
+  scheme_add_method_w_arity(os_wxPoint_class,"set-y", objscheme_wxPoint_Sety, 1, 1);
+
+  scheme_made_class(os_wxPoint_class);
+
+
+}
+}
+
+int objscheme_istype_wxPoint(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxPoint_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:point%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxPoint(class wxPoint *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxPoint_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxPoint *objscheme_unbundle_wxPoint(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxPoint(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxPoint *)o->primdata;
+  else
+    return (wxPoint *)o->primdata;
+}
+
+
+
+
+
+class os_wxIntPoint : public wxIntPoint {
+ public:
+
+  os_wxIntPoint(Scheme_Object * obj);
+  os_wxIntPoint(Scheme_Object * obj, int x0, int x1);
+  ~os_wxIntPoint();
+};
+
+Scheme_Object *os_wxIntPoint_class;
+
+os_wxIntPoint::os_wxIntPoint(Scheme_Object * o)
+: wxIntPoint()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxIntPoint::os_wxIntPoint(Scheme_Object * o, int x0, int x1)
+: wxIntPoint(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxIntPoint::~os_wxIntPoint()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+static Scheme_Object *objscheme_wxIntPoint_Getx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-x", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxIntPoint *)cobj->primdata)->wxIntPoint::x;
+  else
+    v = ((wxIntPoint *)cobj->primdata)->x;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxIntPoint_Setx(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-x", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:int-point%::x");
+  ((wxIntPoint *)cobj->primdata)->x = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxIntPoint_Gety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-y", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxIntPoint *)cobj->primdata)->wxIntPoint::y;
+  else
+    v = ((wxIntPoint *)cobj->primdata)->y;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxIntPoint_Sety(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-y", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:int-point%::y");
+  ((wxIntPoint *)cobj->primdata)->y = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxIntPoint_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxIntPoint *realobj;
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+    int x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:int-point%::initialization (xy values case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:int-point%::initialization (xy values case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:int-point%::initialization (xy values case)");
+
+    
+    realobj = new os_wxIntPoint(obj, x0, x1);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:int-point%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxIntPoint(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxIntPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:int-point%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:int-point%");
+}
+
+void objscheme_setup_wxIntPoint(void *env)
+{
+if (os_wxIntPoint_class) {
+    objscheme_add_global_class(os_wxIntPoint_class,  "wx:int-point%", env);
+} else {
+  os_wxIntPoint_class = objscheme_def_prim_class(env, "wx:int-point%", "wx:object%", os_wxIntPoint_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxIntPoint_class,"get-class-name",objscheme_classname_os_wxIntPoint, 0, 0);
+
+
+  scheme_add_method_w_arity(os_wxIntPoint_class,"get-x", objscheme_wxIntPoint_Getx, 0, 0);
+  scheme_add_method_w_arity(os_wxIntPoint_class,"set-x", objscheme_wxIntPoint_Setx, 1, 1);
+  scheme_add_method_w_arity(os_wxIntPoint_class,"get-y", objscheme_wxIntPoint_Gety, 0, 0);
+  scheme_add_method_w_arity(os_wxIntPoint_class,"set-y", objscheme_wxIntPoint_Sety, 1, 1);
+
+  scheme_made_class(os_wxIntPoint_class);
+
+
+}
+}
+
+int objscheme_istype_wxIntPoint(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxIntPoint_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:int-point%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxIntPoint(class wxIntPoint *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxIntPoint_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxIntPoint *objscheme_unbundle_wxIntPoint(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxIntPoint(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxIntPoint *)o->primdata;
+  else
+    return (wxIntPoint *)o->primdata;
+}
+
+
+
+
+
+
+
+
+class os_wxBrush : public wxBrush {
+ public:
+
+  os_wxBrush(Scheme_Object * obj);
+  os_wxBrush(Scheme_Object * obj, class wxColour& x0, int x1);
+  os_wxBrush(Scheme_Object * obj, string x0, int x1);
+  ~os_wxBrush();
+};
+
+Scheme_Object *os_wxBrush_class;
+
+os_wxBrush::os_wxBrush(Scheme_Object * o)
+: wxBrush()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBrush::os_wxBrush(Scheme_Object * o, class wxColour& x0, int x1)
+: wxBrush(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBrush::os_wxBrush(Scheme_Object * o, string x0, int x1)
+: wxBrush(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBrush::~os_wxBrush()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushSetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:brush%::set-style");
+
+  if (!((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:brush::set-style", "brush", "brush");
+  ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->SetStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushGetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->GetStyle();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushSetStipple(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBitmap* x0;
+
+  
+  x0 = objscheme_unbundle_wxBitmap(p[0], "wx:brush%::set-stipple", 1);
+
+  if (x0 && !x0->Ok()) return scheme_void;if (!((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:brush::set-stipple", "brush", "brush");
+  ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->SetStipple(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushGetStipple(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBitmap* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->GetStipple();
+
+  
+  
+  return objscheme_bundle_wxBitmap(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushSetColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:brush%::set-colour (wx:colour% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:brush%::set-colour (wx:colour% case)", 0);
+
+    if (!((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:brush::set-colour", "brush", "brush");
+    ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->SetColour(*x0);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:brush%::set-colour (color name case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:brush%::set-colour (color name case)");
+
+    if (!((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:brush::set-colour", "brush", "brush");
+    ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->SetColour(x0);
+
+    
+    
+  } else  {
+    int x0;
+    int x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:brush%::set-colour (rgb values case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:brush%::set-colour (rgb values case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:brush%::set-colour (rgb values case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:brush%::set-colour (rgb values case)");
+
+    if (!((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:brush::set-colour", "brush", "brush");
+    ((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->SetColour(x0, x1, x2);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushGetColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxBrush *)((Scheme_Class_Object *)obj)->primdata)->GetColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrush_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBrush *realobj;
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+    int x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:brush%::initialization (color name case)", 2, 2, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:brush%::initialization (color name case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:brush%::initialization (color name case)");
+
+    
+    realobj = new os_wxBrush(obj, x0, x1);
+    
+    
+  } else if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+    int x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:brush%::initialization (wx:colour% case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:brush%::initialization (wx:colour% case)", 0);
+    x1 = objscheme_unbundle_integer(p[1], "wx:brush%::initialization (wx:colour% case)");
+
+    
+    realobj = new os_wxBrush(obj, *x0, x1);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:brush%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxBrush(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBrush(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:brush%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:brush%");
+}
+
+void objscheme_setup_wxBrush(void *env)
+{
+if (os_wxBrush_class) {
+    objscheme_add_global_class(os_wxBrush_class,  "wx:brush%", env);
+} else {
+  os_wxBrush_class = objscheme_def_prim_class(env, "wx:brush%", "wx:object%", os_wxBrush_ConstructScheme, 7);
+
+  scheme_add_method_w_arity(os_wxBrush_class,"get-class-name",objscheme_classname_os_wxBrush, 0, 0);
+
+ scheme_add_method_w_arity(os_wxBrush_class, "set-style", os_wxBrushSetStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxBrush_class, "get-style", os_wxBrushGetStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxBrush_class, "set-stipple", os_wxBrushSetStipple, 1, 1);
+ scheme_add_method_w_arity(os_wxBrush_class, "get-stipple", os_wxBrushGetStipple, 0, 0);
+ scheme_add_method(os_wxBrush_class, "set-colour", os_wxBrushSetColour);
+ scheme_add_method_w_arity(os_wxBrush_class, "get-colour", os_wxBrushGetColour, 0, 0);
+
+
+  scheme_made_class(os_wxBrush_class);
+
+
+}
+  scheme_install_xc_global("wx:const-transparent", scheme_make_integer(wxTRANSPARENT), env);
+  scheme_install_xc_global("wx:const-solid", scheme_make_integer(wxSOLID), env);
+  scheme_install_xc_global("wx:const-bdiagonal-hatch", scheme_make_integer(wxBDIAGONAL_HATCH), env);
+  scheme_install_xc_global("wx:const-crossdiag-hatch", scheme_make_integer(wxCROSSDIAG_HATCH), env);
+  scheme_install_xc_global("wx:const-fdiagonal-hatch", scheme_make_integer(wxFDIAGONAL_HATCH), env);
+  scheme_install_xc_global("wx:const-cross-hatch", scheme_make_integer(wxCROSS_HATCH), env);
+  scheme_install_xc_global("wx:const-horizontal-hatch", scheme_make_integer(wxHORIZONTAL_HATCH), env);
+  scheme_install_xc_global("wx:const-vertical-hatch", scheme_make_integer(wxVERTICAL_HATCH), env);
+  scheme_install_xc_global("wx:const-stipple", scheme_make_integer(wxSTIPPLE), env);
+  scheme_install_xc_global("wx:const-opaque-stipple", scheme_make_integer(wxOPAQUE_STIPPLE), env);
+}
+
+int objscheme_istype_wxBrush(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBrush_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:brush%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBrush(class wxBrush *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBrush_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBrush(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBrush *)o->primdata;
+  else
+    return (wxBrush *)o->primdata;
+}
+
+
+
+
+// @ "remove-brush" : void RemoveBrush(wxBrush!);
+
+
+class os_wxBrushList : public wxBrushList {
+ public:
+
+  os_wxBrushList(Scheme_Object * obj);
+  ~os_wxBrushList();
+};
+
+Scheme_Object *os_wxBrushList_class;
+
+os_wxBrushList::os_wxBrushList(Scheme_Object * o)
+: wxBrushList()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBrushList::~os_wxBrushList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushListFindOrCreateBrush(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBrush* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+    int x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:brush-list%::find-or-create-brush (wx:colour% case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:brush-list%::find-or-create-brush (wx:colour% case)", 0);
+    x1 = objscheme_unbundle_integer(p[1], "wx:brush-list%::find-or-create-brush (wx:colour% case)");
+
+    
+    r = ((wxBrushList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateBrush(x0, x1);
+
+    
+    
+  } else  {
+    string x0;
+    int x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:brush-list%::find-or-create-brush (color name case)", 2, 2, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:brush-list%::find-or-create-brush (color name case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:brush-list%::find-or-create-brush (color name case)");
+
+    
+    r = ((wxBrushList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateBrush(x0, x1);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxBrush(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBrushList_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBrushList *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:brush-list%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxBrushList(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBrushList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:brush-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:brush-list%");
+}
+
+void objscheme_setup_wxBrushList(void *env)
+{
+if (os_wxBrushList_class) {
+    objscheme_add_global_class(os_wxBrushList_class,  "wx:brush-list%", env);
+} else {
+  os_wxBrushList_class = objscheme_def_prim_class(env, "wx:brush-list%", "wx:object%", os_wxBrushList_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxBrushList_class,"get-class-name",objscheme_classname_os_wxBrushList, 0, 0);
+
+ scheme_add_method(os_wxBrushList_class, "find-or-create-brush", os_wxBrushListFindOrCreateBrush);
+
+
+  scheme_made_class(os_wxBrushList_class);
+
+
+}
+  scheme_install_xc_global("wx:the-brush-list", objscheme_bundle_wxBrushList(wxTheBrushList), env);
+}
+
+int objscheme_istype_wxBrushList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBrushList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:brush-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBrushList(class wxBrushList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBrushList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBrushList *objscheme_unbundle_wxBrushList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBrushList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBrushList *)o->primdata;
+  else
+    return (wxBrushList *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+class os_wxPen : public wxPen {
+ public:
+
+  os_wxPen(Scheme_Object * obj);
+  os_wxPen(Scheme_Object * obj, class wxColour& x0, nnint x1, int x2);
+  os_wxPen(Scheme_Object * obj, string x0, nnint x1, int x2);
+  ~os_wxPen();
+};
+
+Scheme_Object *os_wxPen_class;
+
+os_wxPen::os_wxPen(Scheme_Object * o)
+: wxPen()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPen::os_wxPen(Scheme_Object * o, class wxColour& x0, nnint x1, int x2)
+: wxPen(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPen::os_wxPen(Scheme_Object * o, string x0, nnint x1, int x2)
+: wxPen(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPen::~os_wxPen()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:pen%::set-style");
+
+  if (!((wxPen *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:pen::set-style", "pen", "pen");
+  ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetStyle();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetStipple(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBitmap* x0;
+
+  
+  x0 = objscheme_unbundle_wxBitmap(p[0], "wx:pen%::set-stipple", 1);
+
+  if (x0 && !x0->Ok()) return scheme_void;if (!((wxPen *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:pen::set-stipple", "pen", "pen");
+  ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetStipple(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetStipple(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBitmap* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetStipple();
+
+  
+  
+  return objscheme_bundle_wxBitmap(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:pen%::set-colour (wx:colour% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:pen%::set-colour (wx:colour% case)", 0);
+
+    if (!((wxPen *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:pen::set-colour", "pen", "pen");
+    ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetColour(*x0);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:pen%::set-colour (color name case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:pen%::set-colour (color name case)");
+
+    if (!((wxPen *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:pen::set-colour", "pen", "pen");
+    ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetColour(x0);
+
+    
+    
+  } else  {
+    int x0;
+    int x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:pen%::set-colour (rgb values case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:pen%::set-colour (rgb values case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:pen%::set-colour (rgb values case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:pen%::set-colour (rgb values case)");
+
+    if (!((wxPen *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", "wx:pen::set-colour", "pen", "pen");
+    ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetColour(x0, x1, x2);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetJoin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:pen%::set-join");
+
+  
+  ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetJoin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetJoin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetJoin();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetCap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:pen%::set-cap");
+
+  
+  ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetCap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetCap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetCap();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenSetWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:pen%::set-width");
+
+  
+  ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->SetWidth(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenGetWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPen *)((Scheme_Class_Object *)obj)->primdata)->GetWidth();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPen_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxPen *realobj;
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+    nnint x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:pen%::initialization (color name case)", 3, 3, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:pen%::initialization (color name case)");
+    x1 = objscheme_unbundle_nonnegative_integer(p[1], "wx:pen%::initialization (color name case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:pen%::initialization (color name case)");
+
+    
+    realobj = new os_wxPen(obj, x0, x1, x2);
+    
+    
+  } else if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+    nnint x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:pen%::initialization (wx:colour% case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:pen%::initialization (wx:colour% case)", 0);
+    x1 = objscheme_unbundle_nonnegative_integer(p[1], "wx:pen%::initialization (wx:colour% case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:pen%::initialization (wx:colour% case)");
+
+    
+    realobj = new os_wxPen(obj, *x0, x1, x2);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:pen%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxPen(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxPen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:pen%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:pen%");
+}
+
+void objscheme_setup_wxPen(void *env)
+{
+if (os_wxPen_class) {
+    objscheme_add_global_class(os_wxPen_class,  "wx:pen%", env);
+} else {
+  os_wxPen_class = objscheme_def_prim_class(env, "wx:pen%", "wx:object%", os_wxPen_ConstructScheme, 13);
+
+  scheme_add_method_w_arity(os_wxPen_class,"get-class-name",objscheme_classname_os_wxPen, 0, 0);
+
+ scheme_add_method_w_arity(os_wxPen_class, "set-style", os_wxPenSetStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxPen_class, "get-style", os_wxPenGetStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxPen_class, "set-stipple", os_wxPenSetStipple, 1, 1);
+ scheme_add_method_w_arity(os_wxPen_class, "get-stipple", os_wxPenGetStipple, 0, 0);
+ scheme_add_method(os_wxPen_class, "set-colour", os_wxPenSetColour);
+ scheme_add_method_w_arity(os_wxPen_class, "get-colour", os_wxPenGetColour, 0, 0);
+ scheme_add_method_w_arity(os_wxPen_class, "set-join", os_wxPenSetJoin, 1, 1);
+ scheme_add_method_w_arity(os_wxPen_class, "get-join", os_wxPenGetJoin, 0, 0);
+ scheme_add_method_w_arity(os_wxPen_class, "set-cap", os_wxPenSetCap, 1, 1);
+ scheme_add_method_w_arity(os_wxPen_class, "get-cap", os_wxPenGetCap, 0, 0);
+ scheme_add_method_w_arity(os_wxPen_class, "set-width", os_wxPenSetWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxPen_class, "get-width", os_wxPenGetWidth, 0, 0);
+
+
+  scheme_made_class(os_wxPen_class);
+
+
+}
+  scheme_install_xc_global("wx:const-join-bevel", scheme_make_integer(wxJOIN_BEVEL), env);
+  scheme_install_xc_global("wx:const-join-miter", scheme_make_integer(wxJOIN_MITER), env);
+  scheme_install_xc_global("wx:const-join-round", scheme_make_integer(wxJOIN_ROUND), env);
+  scheme_install_xc_global("wx:const-cap-round", scheme_make_integer(wxCAP_ROUND), env);
+  scheme_install_xc_global("wx:const-cap-projecting", scheme_make_integer(wxCAP_PROJECTING), env);
+  scheme_install_xc_global("wx:const-cap-butt", scheme_make_integer(wxCAP_BUTT), env);
+  scheme_install_xc_global("wx:const-dot", scheme_make_integer(wxDOT), env);
+  scheme_install_xc_global("wx:const-long-dash", scheme_make_integer(wxLONG_DASH), env);
+  scheme_install_xc_global("wx:const-short-dash", scheme_make_integer(wxSHORT_DASH), env);
+  scheme_install_xc_global("wx:const-dot-dash", scheme_make_integer(wxDOT_DASH), env);
+}
+
+int objscheme_istype_wxPen(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxPen_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:pen%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxPen(class wxPen *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxPen_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxPen *objscheme_unbundle_wxPen(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxPen(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxPen *)o->primdata;
+  else
+    return (wxPen *)o->primdata;
+}
+
+
+
+
+
+// @ "remove-pen" : void RemovePen(wxPen!);
+
+
+class os_wxPenList : public wxPenList {
+ public:
+
+  os_wxPenList(Scheme_Object * obj);
+  ~os_wxPenList();
+};
+
+Scheme_Object *os_wxPenList_class;
+
+os_wxPenList::os_wxPenList(Scheme_Object * o)
+: wxPenList()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPenList::~os_wxPenList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenListFindOrCreatePen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxPen* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxColour(p[0], NULL, 0)) {
+    class wxColour* x0;
+    nnint x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:pen-list%::find-or-create-pen (wx:colour% case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:pen-list%::find-or-create-pen (wx:colour% case)", 0);
+    x1 = objscheme_unbundle_nonnegative_integer(p[1], "wx:pen-list%::find-or-create-pen (wx:colour% case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:pen-list%::find-or-create-pen (wx:colour% case)");
+
+    
+    r = ((wxPenList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreatePen(x0, x1, x2);
+
+    
+    
+  } else  {
+    string x0;
+    nnint x1;
+    int x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:pen-list%::find-or-create-pen (color name case)", 3, 3, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:pen-list%::find-or-create-pen (color name case)");
+    x1 = objscheme_unbundle_nonnegative_integer(p[1], "wx:pen-list%::find-or-create-pen (color name case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:pen-list%::find-or-create-pen (color name case)");
+
+    
+    r = ((wxPenList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreatePen(x0, x1, x2);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxPen(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPenList_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxPenList *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:pen-list%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxPenList(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxPenList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:pen-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:pen-list%");
+}
+
+void objscheme_setup_wxPenList(void *env)
+{
+if (os_wxPenList_class) {
+    objscheme_add_global_class(os_wxPenList_class,  "wx:pen-list%", env);
+} else {
+  os_wxPenList_class = objscheme_def_prim_class(env, "wx:pen-list%", "wx:object%", os_wxPenList_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxPenList_class,"get-class-name",objscheme_classname_os_wxPenList, 0, 0);
+
+ scheme_add_method(os_wxPenList_class, "find-or-create-pen", os_wxPenListFindOrCreatePen);
+
+
+  scheme_made_class(os_wxPenList_class);
+
+
+}
+  scheme_install_xc_global("wx:the-pen-list", objscheme_bundle_wxPenList(wxThePenList), env);
+}
+
+int objscheme_istype_wxPenList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxPenList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:pen-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxPenList(class wxPenList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxPenList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxPenList *objscheme_unbundle_wxPenList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxPenList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxPenList *)o->primdata;
+  else
+    return (wxPenList *)o->primdata;
+}
+
+
+
+// @CREATOR ();
+
+
+
+class os_wxCursor : public wxCursor {
+ public:
+
+  os_wxCursor(Scheme_Object * obj, string x0, long x1 = wxBITMAP_TYPE_DEFAULT, int x2 = 0, int x3 = 0);
+  os_wxCursor(Scheme_Object * obj, int x0);
+  ~os_wxCursor();
+};
+
+Scheme_Object *os_wxCursor_class;
+
+os_wxCursor::os_wxCursor(Scheme_Object * o, string x0, long x1, int x2, int x3)
+: wxCursor(x0, x1, x2, x3)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCursor::os_wxCursor(Scheme_Object * o, int x0)
+: wxCursor(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxCursor::~os_wxCursor()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCursorOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCursor *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCursor_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxCursor *realobj;
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:cursor%::initialization (cursor id case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:cursor%::initialization (cursor id case)");
+
+    
+    realobj = new os_wxCursor(obj, x0);
+    
+    
+  } else  {
+    string x0;
+    long x1;
+    int x2;
+    int x3;
+
+    
+    if ((n < 1) ||(n > 4)) 
+      scheme_wrong_count("wx:cursor%::initialization (cursor name case)", 1, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:cursor%::initialization (cursor name case)");
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:cursor%::initialization (cursor name case)");
+    } else
+      x1 = wxBITMAP_TYPE_DEFAULT;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:cursor%::initialization (cursor name case)");
+    } else
+      x2 = 0;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:cursor%::initialization (cursor name case)");
+    } else
+      x3 = 0;
+
+    
+    realobj = new os_wxCursor(obj, x0, x1, x2, x3);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:cursor%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:cursor%");
+}
+
+void objscheme_setup_wxCursor(void *env)
+{
+if (os_wxCursor_class) {
+    objscheme_add_global_class(os_wxCursor_class,  "wx:cursor%", env);
+} else {
+  os_wxCursor_class = objscheme_def_prim_class(env, "wx:cursor%", "wx:object%", os_wxCursor_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxCursor_class,"get-class-name",objscheme_classname_os_wxCursor, 0, 0);
+
+ scheme_add_method_w_arity(os_wxCursor_class, "ok?", os_wxCursorOk, 0, 0);
+
+
+  scheme_made_class(os_wxCursor_class);
+
+
+}
+  scheme_install_xc_global("wx:const-cursor-arrow", scheme_make_integer(wxCURSOR_ARROW), env);
+  scheme_install_xc_global("wx:const-cursor-bullseye", scheme_make_integer(wxCURSOR_BULLSEYE), env);
+  scheme_install_xc_global("wx:const-cursor-char", scheme_make_integer(wxCURSOR_CHAR), env);
+  scheme_install_xc_global("wx:const-cursor-cross", scheme_make_integer(wxCURSOR_CROSS), env);
+  scheme_install_xc_global("wx:const-cursor-hand", scheme_make_integer(wxCURSOR_HAND), env);
+  scheme_install_xc_global("wx:const-cursor-ibeam", scheme_make_integer(wxCURSOR_IBEAM), env);
+  scheme_install_xc_global("wx:const-cursor-left-button", scheme_make_integer(wxCURSOR_LEFT_BUTTON), env);
+  scheme_install_xc_global("wx:const-cursor-magnifier", scheme_make_integer(wxCURSOR_MAGNIFIER), env);
+  scheme_install_xc_global("wx:const-cursor-middle-button", scheme_make_integer(wxCURSOR_MIDDLE_BUTTON), env);
+  scheme_install_xc_global("wx:const-cursor-no-entry", scheme_make_integer(wxCURSOR_NO_ENTRY), env);
+  scheme_install_xc_global("wx:const-cursor-painr-brush", scheme_make_integer(wxCURSOR_PAINT_BRUSH), env);
+  scheme_install_xc_global("wx:const-cursor-pencil", scheme_make_integer(wxCURSOR_PENCIL), env);
+  scheme_install_xc_global("wx:const-cursor-point-left", scheme_make_integer(wxCURSOR_POINT_LEFT), env);
+  scheme_install_xc_global("wx:const-cursor-point-right", scheme_make_integer(wxCURSOR_POINT_RIGHT), env);
+  scheme_install_xc_global("wx:const-cursor-question-arrow", scheme_make_integer(wxCURSOR_QUESTION_ARROW), env);
+  scheme_install_xc_global("wx:const-cursor-right-button", scheme_make_integer(wxCURSOR_RIGHT_BUTTON), env);
+  scheme_install_xc_global("wx:const-cursor-sizenesw", scheme_make_integer(wxCURSOR_SIZENESW), env);
+  scheme_install_xc_global("wx:const-cursor-sizens", scheme_make_integer(wxCURSOR_SIZENS), env);
+  scheme_install_xc_global("wx:const-cursor-sizenwse", scheme_make_integer(wxCURSOR_SIZENWSE), env);
+  scheme_install_xc_global("wx:const-cursor-sizewe", scheme_make_integer(wxCURSOR_SIZEWE), env);
+  scheme_install_xc_global("wx:const-cursor-sizing", scheme_make_integer(wxCURSOR_SIZING), env);
+  scheme_install_xc_global("wx:const-cursor-spraycan", scheme_make_integer(wxCURSOR_SPRAYCAN), env);
+  scheme_install_xc_global("wx:const-cursor-wait", scheme_make_integer(wxCURSOR_WAIT), env);
+  scheme_install_xc_global("wx:const-cursor-watch", scheme_make_integer(wxCURSOR_WATCH), env);
+}
+
+int objscheme_istype_wxCursor(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCursor_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:cursor%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCursor_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCursor(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCursor *)o->primdata;
+  else
+    return (wxCursor *)o->primdata;
+}
+
+
+
+
+// @CREATOR ();
+
+// in wx:bitmap%: 
+// @ "ok?" : bool Ok();
+
+class os_wxIcon : public wxIcon {
+ public:
+
+  os_wxIcon(Scheme_Object * obj, string x0, int x1 = wxBITMAP_TYPE_DEFAULT);
+  ~os_wxIcon();
+};
+
+Scheme_Object *os_wxIcon_class;
+
+os_wxIcon::os_wxIcon(Scheme_Object * o, string x0, int x1)
+: wxIcon(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxIcon::~os_wxIcon()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxIcon_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxIcon *realobj;
+  string x0;
+  int x1;
+
+  
+  if ((n < 1) ||(n > 2)) 
+    scheme_wrong_count("wx:icon%::initialization", 1, 2, n, p);
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:icon%::initialization");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:icon%::initialization");
+  } else
+    x1 = wxBITMAP_TYPE_DEFAULT;
+
+  
+  realobj = new os_wxIcon(obj, x0, x1);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxIcon(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:icon%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:icon%");
+}
+
+void objscheme_setup_wxIcon(void *env)
+{
+if (os_wxIcon_class) {
+    objscheme_add_global_class(os_wxIcon_class,  "wx:icon%", env);
+} else {
+  os_wxIcon_class = objscheme_def_prim_class(env, "wx:icon%", "wx:bitmap%", os_wxIcon_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_wxIcon_class,"get-class-name",objscheme_classname_os_wxIcon, 0, 0);
+
+
+
+  scheme_made_class(os_wxIcon_class);
+
+
+}
+}
+
+int objscheme_istype_wxIcon(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxIcon_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:icon%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxIcon(class wxIcon *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxIcon_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxIcon *objscheme_unbundle_wxIcon(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxIcon(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxIcon *)o->primdata;
+  else
+    return (wxIcon *)o->primdata;
+}
+
+
+#if USE_FONT_NAME_DIRECTORY
+
+
+
+
+
+
+
+class os_wxFontNameDirectory : public wxFontNameDirectory {
+ public:
+
+  ~os_wxFontNameDirectory();
+};
+
+Scheme_Object *os_wxFontNameDirectory_class;
+
+os_wxFontNameDirectory::~os_wxFontNameDirectory()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryFindOrCreateFontId(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  cstring x0;
+  int x1;
+
+  
+  x0 = (cstring)objscheme_unbundle_string(p[0], "wx:font-name-directory%::find-or-create-font-id");
+  x1 = objscheme_unbundle_integer(p[1], "wx:font-name-directory%::find-or-create-font-id");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateFontId(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetFamily(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::get-family");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetFamily(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetFontName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::get-font-name");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetFontName(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetFontId(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:font-name-directory%::get-font-id");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetFontId(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryInitialize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  string x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::initialize");
+  x1 = objscheme_unbundle_integer(p[1], "wx:font-name-directory%::initialize");
+  x2 = (string)objscheme_unbundle_string(p[2], "wx:font-name-directory%::initialize");
+
+  
+  ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->Initialize(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetNewFontId(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetNewFontId();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetAFMName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::get-afm-name");
+  x1 = objscheme_unbundle_integer(p[1], "wx:font-name-directory%::get-afm-name");
+  x2 = objscheme_unbundle_integer(p[2], "wx:font-name-directory%::get-afm-name");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetAFMName(x0, x1, x2);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetPostScriptName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::get-post-script-name");
+  x1 = objscheme_unbundle_integer(p[1], "wx:font-name-directory%::get-post-script-name");
+  x2 = objscheme_unbundle_integer(p[2], "wx:font-name-directory%::get-post-script-name");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetPostScriptName(x0, x1, x2);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxFontNameDirectoryGetScreenName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:font-name-directory%::get-screen-name");
+  x1 = objscheme_unbundle_integer(p[1], "wx:font-name-directory%::get-screen-name");
+  x2 = objscheme_unbundle_integer(p[2], "wx:font-name-directory%::get-screen-name");
+
+  
+  r = ((wxFontNameDirectory *)((Scheme_Class_Object *)obj)->primdata)->GetScreenName(x0, x1, x2);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxFontNameDirectory(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:font-name-directory%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:font-name-directory%");
+}
+
+void objscheme_setup_wxFontNameDirectory(void *env)
+{
+if (os_wxFontNameDirectory_class) {
+    objscheme_add_global_class(os_wxFontNameDirectory_class,  "wx:font-name-directory%", env);
+} else {
+  os_wxFontNameDirectory_class = objscheme_def_prim_class(env, "wx:font-name-directory%", "wx:object%", NULL, 10);
+
+  scheme_add_method_w_arity(os_wxFontNameDirectory_class,"get-class-name",objscheme_classname_os_wxFontNameDirectory, 0, 0);
+
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "find-or-create-font-id", os_wxFontNameDirectoryFindOrCreateFontId, 2, 2);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-family", os_wxFontNameDirectoryGetFamily, 1, 1);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-font-name", os_wxFontNameDirectoryGetFontName, 1, 1);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-font-id", os_wxFontNameDirectoryGetFontId, 1, 1);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "initialize", os_wxFontNameDirectoryInitialize, 3, 3);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-new-font-id", os_wxFontNameDirectoryGetNewFontId, 0, 0);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-afm-name", os_wxFontNameDirectoryGetAFMName, 3, 3);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-post-script-name", os_wxFontNameDirectoryGetPostScriptName, 3, 3);
+ scheme_add_method_w_arity(os_wxFontNameDirectory_class, "get-screen-name", os_wxFontNameDirectoryGetScreenName, 3, 3);
+
+
+  scheme_made_class(os_wxFontNameDirectory_class);
+
+
+}
+  scheme_install_xc_global("wx:the-font-name-directory", objscheme_bundle_wxFontNameDirectory(&wxTheFontNameDirectory), env);
+}
+
+int objscheme_istype_wxFontNameDirectory(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxFontNameDirectory_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:font-name-directory%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxFontNameDirectory(class wxFontNameDirectory *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxFontNameDirectory_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxFontNameDirectory *objscheme_unbundle_wxFontNameDirectory(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxFontNameDirectory(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxFontNameDirectory *)o->primdata;
+  else
+    return (wxFontNameDirectory *)o->primdata;
+}
+
+
+#endif
diff --git a/src/mred/wxs/wxs_gdi.h b/src/mred/wxs/wxs_gdi.h
new file mode 100644
index 0000000..7a090f3
--- /dev/null
+++ b/src/mred/wxs/wxs_gdi.h
@@ -0,0 +1,117 @@
+#ifndef WXS_SETUP_ONLY
+#endif
+void objscheme_setup_wxFont(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxFont(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxFont(class wxFont *realobj);
+class wxFont *objscheme_unbundle_wxFont(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxFont(class wxFont *);
+#endif
+void objscheme_setup_wxFontList(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxFontList(class wxFontList *);
+int objscheme_istype_wxFontList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxFontList(class wxFontList *realobj);
+class wxFontList *objscheme_unbundle_wxFontList(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+#endif
+void objscheme_setup_wxColour(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxColour(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxColour(class wxColour *realobj);
+class wxColour *objscheme_unbundle_wxColour(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxColourMap(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxColourMap(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxColourMap(class wxColourMap *realobj);
+class wxColourMap *objscheme_unbundle_wxColourMap(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+#endif
+void objscheme_setup_wxColourDatabase(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxColourDatabase(class wxColourDatabase *);
+int objscheme_istype_wxColourDatabase(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxColourDatabase(class wxColourDatabase *realobj);
+class wxColourDatabase *objscheme_unbundle_wxColourDatabase(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxPoint(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxPoint(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxPoint(class wxPoint *realobj);
+class wxPoint *objscheme_unbundle_wxPoint(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxIntPoint(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxIntPoint(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxIntPoint(class wxIntPoint *realobj);
+class wxIntPoint *objscheme_unbundle_wxIntPoint(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBitmap(class wxBitmap *);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxBrush(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxBrush(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBrush(class wxBrush *realobj);
+class wxBrush *objscheme_unbundle_wxBrush(Scheme_Object *obj, const char *where, int nullOK);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBrush(class wxBrush *);
+#endif
+void objscheme_setup_wxBrushList(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxBrushList(class wxBrushList *);
+int objscheme_istype_wxBrushList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBrushList(class wxBrushList *realobj);
+class wxBrushList *objscheme_unbundle_wxBrushList(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBitmap(class wxBitmap *);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxPen(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxPen(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxPen(class wxPen *realobj);
+class wxPen *objscheme_unbundle_wxPen(Scheme_Object *obj, const char *where, int nullOK);
+extern int objscheme_istype_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxPen(class wxPen *);
+#endif
+void objscheme_setup_wxPenList(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxPenList(class wxPenList *);
+int objscheme_istype_wxPenList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxPenList(class wxPenList *realobj);
+class wxPenList *objscheme_unbundle_wxPenList(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxCursor(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCursor(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *realobj);
+class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxIcon(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxIcon(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxIcon(class wxIcon *realobj);
+class wxIcon *objscheme_unbundle_wxIcon(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxFontNameDirectory(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxFontNameDirectory(class wxFontNameDirectory *);
+int objscheme_istype_wxFontNameDirectory(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxFontNameDirectory(class wxFontNameDirectory *realobj);
+class wxFontNameDirectory *objscheme_unbundle_wxFontNameDirectory(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_gdi.xc b/src/mred/wxs/wxs_gdi.xc
new file mode 100644
index 0000000..3c8e34b
--- /dev/null
+++ b/src/mred/wxs/wxs_gdi.xc
@@ -0,0 +1,315 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_obj.h"
+#include "wx_list.h"
+#include "wx_gdi.h"
+#ifdef wx_xt
+#include "wx_dc.h"
+#endif
+
+@INCLUDE wxs.xci
+
+#include "wxs_bmt.h"
+
+@HEADER
+
+#define USE_FONT_NAME_DIRECTORY 1
+
+#if defined(wx_mac) || defined(wx_xt)
+#define COLORMAP_CREATE 0
+#else
+#define COLORMAP_CREATE 1
+#endif
+
+@MACRO CHECKMUT[TYPE.what.who] = if (!((<TYPE> *)((Scheme_Class_Object *)obj)->primdata)->IsMutable()) scheme_signal_error("%s: this wx:%s%% object is locked (in use by a wx:dc%% or in a list of %s constants)", <who>, <what>, <what>);
+
+@CLASSBASE wxFont "wx:font":"wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (nnint,int,int,int,bool=0) <> font id
+@CREATOR (nnint,cstring,int,int,int,bool=0) <> font name ## USE_FONT_NAME_DIRECTORY
+
+@ "get-family" : int GetFamily();
+@ "get-font-id" : int GetFontId(); ## USE_FONT_NAME_DIRECTORY
+@ "get-style" : int GetStyle();
+@ "get-point-size" : int GetPointSize();
+@ "get-weight" : int GetWeight();
+@ "get-underlined" : bool GetUnderlined();
+
+@CONSTANT "wx:const-default" : int wxDEFAULT
+@CONSTANT "wx:const-decorative" : int wxDECORATIVE
+@CONSTANT "wx:const-roman" : int wxROMAN
+@CONSTANT "wx:const-script" : int wxSCRIPT
+@CONSTANT "wx:const-swiss" : int wxSWISS
+@CONSTANT "wx:const-modern" : int wxMODERN
+@CONSTANT "wx:const-teletype" : int wxTELETYPE
+@CONSTANT "wx:const-system" : int wxSYSTEM
+
+// Not used:
+// @CONSTANT "wx:const-variable" : int wxVARIABLE
+// @CONSTANT "wx:const-fixed" : int wxFIXED
+
+@CONSTANT "wx:const-normal" : int wxNORMAL
+@CONSTANT "wx:const-light" : int wxLIGHT
+@CONSTANT "wx:const-bold" : int wxBOLD
+
+@CONSTANT "wx:const-italic" : int wxITALIC
+@CONSTANT "wx:const-slant" : int wxSLANT
+
+@END
+
+
+@CLASSBASE wxFontList "wx:font-list":"wx:object"
+
+@CREATOR ();
+
+@ "find-or-create-font" : wxFont! FindOrCreateFont(nnint,int,int,int,bool=0) <> font id
+@ "find-or-create-font" : wxFont! FindOrCreateFont(nnint,cstring,int,int,int,bool=0) <> font name ## USE_FONT_NAME_DIRECTORY
+// @ "remove-font" : void RemoveFont(wxFont!);
+
+@CONSTANT "wx:the-font-list" : wxFontList! wxTheFontList
+
+@END
+
+
+@CLASSBASE wxColour "wx:colour" : "wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (ubyte,ubyte,ubyte); <> rgb values
+@CREATOR (string); <> color name
+
+@ "=" : wxColour% operator=(wxColour%);  : : /CHECKMUT[wxColour."colour"."wx:colour%::="]
+@ "get" : void Get(ubyte*,ubyte*,ubyte*);
+@ "ok?" : bool Ok();
+@ "set" : void Set(ubyte,ubyte,ubyte);   : : /CHECKMUT[wxColour."colour"."wx:colour%::set"]
+
+@ "red" : ubyte Red();
+@ "green" : ubyte Green();
+@ "blue" : ubyte Blue();
+
+@END
+
+
+@CLASSBASE wxColourMap "wx:colour-map" : "wx:object"
+
+// @CREATOR (); ## !defined(wx_mac)
+
+// @ "create" : bool Create(int,custring,custring,custring); ## COLORMAP_CREATE
+
+@END
+
+#ifdef wx_mac
+#define _KEY_TYPE KeyType
+#else
+#define _KEY_TYPE int
+#endif
+@MACRO bInt = objscheme_bundle_integer((int){x})
+@MACRO ubIntKey = (_KEY_TYPE)objscheme_unbundle_integer({x}, "wxColourDatabase")
+@MACRO tInt = objscheme_istype_number({x}, NULL)
+
+// Since we don't allow creating this anymore, need a Mac fix:
+#if defined(wx_mac)
+#define CDB_FIX os_wxColourDatabase(_KEY_TYPE x) : wxColourDatabase(x) {}
+#else
+#define CDB_FIX 
+#endif
+
+@CLASSBASE wxColourDatabase "wx:colour-database" : "wx:object"
+
+@VAR CDB_FIX
+
+// @CREATOR (_KEY_TYPE/bInt/ubIntKey/tInt);
+
+@ "find-colour" : wxColour^ FindColour(string);
+@ "find-name" : string FindName(wxColour%);
+// @ "initialize" : void Initialize(); ## !defined(wx_xt)
+@ "append" : void Append(string, wxColour!);
+
+@CONSTANT "wx:the-colour-database" : wxColourDatabase! wxTheColourDatabase
+
+@END
+
+
+@CLASSBASE wxPoint "wx:point" : "wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (float,float); <> xy values
+
+@IVAR "x" : float x
+@IVAR "y" : float y
+
+@END
+
+@CLASSBASE wxIntPoint "wx:int-point" : "wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (int,int) <> xy values
+
+@IVAR "x" : int x
+@IVAR "y" : int y
+
+@END
+
+@CLASSBASE wxBrush "wx:brush" : "wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (wxColour%,int); <> wx:colour%
+@CREATOR (string,int); <> color name
+
+@ "get-colour" : wxColour% GetColour();
+@ "set-colour" : void SetColour(wxColour%); : : /CHECKMUT[wxBrush."brush"."wx:brush::set-colour"] <> wx:colour%
+@ "set-colour" : void SetColour(string); : : /CHECKMUT[wxBrush."brush"."wx:brush::set-colour"] <> color name
+@ "set-colour" : void SetColour(int,int,int); : : /CHECKMUT[wxBrush."brush"."wx:brush::set-colour"] <> rgb values
+
+@ "get-stipple" : wxBitmap! GetStipple();
+@ "set-stipple" : void SetStipple(wxBitmap^); : : /CHECKVOIDABLEOK[0]|CHECKMUT[wxBrush."brush"."wx:brush::set-stipple"]
+
+@ "get-style" : int GetStyle();
+@ "set-style" : void SetStyle(int); : : /CHECKMUT[wxBrush."brush"."wx:brush::set-style"]
+
+@CONSTANT "wx:const-transparent" : int wxTRANSPARENT
+@CONSTANT "wx:const-solid" : int wxSOLID
+@CONSTANT "wx:const-bdiagonal-hatch" : int wxBDIAGONAL_HATCH
+@CONSTANT "wx:const-crossdiag-hatch" : int wxCROSSDIAG_HATCH
+@CONSTANT "wx:const-fdiagonal-hatch" : int wxFDIAGONAL_HATCH
+@CONSTANT "wx:const-cross-hatch" : int wxCROSS_HATCH
+@CONSTANT "wx:const-horizontal-hatch" : int wxHORIZONTAL_HATCH
+@CONSTANT "wx:const-vertical-hatch" : int wxVERTICAL_HATCH
+@CONSTANT "wx:const-stipple" : int wxSTIPPLE
+@CONSTANT "wx:const-opaque-stipple" : int wxOPAQUE_STIPPLE
+
+@END
+
+@CLASSBASE wxBrushList "wx:brush-list" : "wx:object"
+
+@CREATOR ();
+
+@ "find-or-create-brush" : wxBrush! FindOrCreateBrush(wxColour!,int); <> wx:colour%
+@ "find-or-create-brush" : wxBrush! FindOrCreateBrush(string,int); <> color name
+// @ "remove-brush" : void RemoveBrush(wxBrush!);
+
+@CONSTANT "wx:the-brush-list" : wxBrushList! wxTheBrushList
+
+@END
+
+@CLASSBASE wxPen "wx:pen" : "wx:object"
+
+@CREATOR (); <> no argument
+@CREATOR (wxColour%,nnint,int); <> wx:colour%
+@CREATOR (string,nnint,int); <> color name
+
+@ "get-width" : int GetWidth();
+@ "set-width" : void SetWidth(int);
+@ "get-cap" : int GetCap();
+@ "set-cap" : void SetCap(int);
+@ "get-join" : int GetJoin();
+@ "set-join" : void SetJoin(int);
+
+@ "get-colour" : wxColour% GetColour();
+@ "set-colour" : void SetColour(wxColour%);  : : /CHECKMUT[wxPen."pen"."wx:pen::set-colour"] <> wx:colour%
+@ "set-colour" : void SetColour(string);  : : /CHECKMUT[wxPen."pen"."wx:pen::set-colour"] <> color name
+@ "set-colour" : void SetColour(int,int,int);  : : /CHECKMUT[wxPen."pen"."wx:pen::set-colour"] <> rgb values
+
+@ "get-stipple" : wxBitmap! GetStipple();
+@ "set-stipple" : void SetStipple(wxBitmap^); : : /CHECKVOIDABLEOK[0]|CHECKMUT[wxPen."pen"."wx:pen::set-stipple"]
+
+@ "get-style" : int GetStyle();
+@ "set-style" : void SetStyle(int); : : /CHECKMUT[wxPen."pen"."wx:pen::set-style"]
+
+@CONSTANT "wx:const-join-bevel" : int wxJOIN_BEVEL
+@CONSTANT "wx:const-join-miter" : int wxJOIN_MITER
+@CONSTANT "wx:const-join-round" : int wxJOIN_ROUND
+
+@CONSTANT "wx:const-cap-round" : int wxCAP_ROUND
+@CONSTANT "wx:const-cap-projecting" : int wxCAP_PROJECTING
+@CONSTANT "wx:const-cap-butt" : int wxCAP_BUTT
+
+@CONSTANT "wx:const-dot" : int wxDOT
+@CONSTANT "wx:const-long-dash" : int wxLONG_DASH
+@CONSTANT "wx:const-short-dash" : int wxSHORT_DASH
+@CONSTANT "wx:const-dot-dash" : int wxDOT_DASH
+
+@END
+
+
+@CLASSBASE wxPenList "wx:pen-list" : "wx:object"
+
+@CREATOR ();
+
+@ "find-or-create-pen" : wxPen! FindOrCreatePen(wxColour!,nnint,int); <> wx:colour%
+@ "find-or-create-pen" : wxPen! FindOrCreatePen(string,nnint,int); <> color name
+// @ "remove-pen" : void RemovePen(wxPen!);
+
+@CONSTANT "wx:the-pen-list" : wxPenList! wxThePenList
+
+@END
+
+@CLASSBASE wxCursor "wx:cursor" : "wx:object"
+
+// @CREATOR ();
+@CREATOR (string,long=wxBITMAP_TYPE_DEFAULT,int=0,int=0); <> cursor name
+@CREATOR (int); <> cursor id
+
+@ "ok?" : bool Ok();
+
+@CONSTANT "wx:const-cursor-arrow" : int wxCURSOR_ARROW
+@CONSTANT "wx:const-cursor-bullseye" : int wxCURSOR_BULLSEYE
+@CONSTANT "wx:const-cursor-char" : int wxCURSOR_CHAR
+@CONSTANT "wx:const-cursor-cross" : int wxCURSOR_CROSS
+@CONSTANT "wx:const-cursor-hand" : int wxCURSOR_HAND
+@CONSTANT "wx:const-cursor-ibeam" : int wxCURSOR_IBEAM
+@CONSTANT "wx:const-cursor-left-button" : int wxCURSOR_LEFT_BUTTON
+@CONSTANT "wx:const-cursor-magnifier" : int wxCURSOR_MAGNIFIER
+@CONSTANT "wx:const-cursor-middle-button" : int wxCURSOR_MIDDLE_BUTTON
+@CONSTANT "wx:const-cursor-no-entry" : int wxCURSOR_NO_ENTRY
+@CONSTANT "wx:const-cursor-painr-brush" : int wxCURSOR_PAINT_BRUSH
+@CONSTANT "wx:const-cursor-pencil" : int wxCURSOR_PENCIL
+@CONSTANT "wx:const-cursor-point-left" : int wxCURSOR_POINT_LEFT
+@CONSTANT "wx:const-cursor-point-right" : int wxCURSOR_POINT_RIGHT
+@CONSTANT "wx:const-cursor-question-arrow" : int wxCURSOR_QUESTION_ARROW
+@CONSTANT "wx:const-cursor-right-button" : int wxCURSOR_RIGHT_BUTTON
+@CONSTANT "wx:const-cursor-sizenesw" : int wxCURSOR_SIZENESW
+@CONSTANT "wx:const-cursor-sizens" : int wxCURSOR_SIZENS
+@CONSTANT "wx:const-cursor-sizenwse" : int wxCURSOR_SIZENWSE
+@CONSTANT "wx:const-cursor-sizewe" : int wxCURSOR_SIZEWE
+@CONSTANT "wx:const-cursor-sizing" : int wxCURSOR_SIZING
+@CONSTANT "wx:const-cursor-spraycan" : int wxCURSOR_SPRAYCAN
+@CONSTANT "wx:const-cursor-wait" : int wxCURSOR_WAIT
+@CONSTANT "wx:const-cursor-watch" : int wxCURSOR_WATCH
+
+@END
+
+
+@CLASSBASE wxIcon "wx:icon" : "wx:bitmap"
+
+// @CREATOR ();
+@CREATOR (string, int=wxBITMAP_TYPE_DEFAULT);
+
+// in wx:bitmap%: 
+// @ "ok?" : bool Ok();
+
+@END
+
+#if USE_FONT_NAME_DIRECTORY
+
+@CLASSBASE wxFontNameDirectory "wx:font-name-directory":"wx:object"
+
+@ "get-screen-name" : nstring GetScreenName(int,int,int);
+@ "get-post-script-name" : nstring GetPostScriptName(int,int,int);
+@ "get-afm-name" : nstring GetAFMName(int,int,int);
+
+@ "get-new-font-id" :   int GetNewFontId()
+@ "initialize" : void Initialize(int,int,string);
+
+@ "get-font-id" : int GetFontId(string);
+@ "get-font-name" : nstring GetFontName(int);
+@ "get-family" : int GetFamily(int);
+
+@ "find-or-create-font-id" : int FindOrCreateFontId(cstring,int);
+
+@CONSTANT "wx:the-font-name-directory" : wxFontNameDirectory% wxTheFontNameDirectory
+
+@END
+
+#endif
diff --git a/src/mred/wxs/wxs_glob.cxx b/src/mred/wxs/wxs_glob.cxx
new file mode 100644
index 0000000..6575553
--- /dev/null
+++ b/src/mred/wxs/wxs_glob.cxx
@@ -0,0 +1,1917 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_glob.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_utils.h"
+#include "wx_dialg.h"
+#include "wx_cmdlg.h"
+#include "wx_timer.h"
+#include "wx_dcps.h"
+#include "wx_main.h"
+#ifdef wx_xt
+#define Uses_wxPrintSetup
+#include "wx_types.h"
+#include "wx_print.h"
+#endif
+
+#ifdef wx_msw
+#ifdef _MSC_VER
+#include <direct.h>
+#else
+#include <dir.h>
+#endif
+#endif
+
+#if USE_METAFILE
+#include "wx_mf.h"
+#endif
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_glob.h"
+#include "wxscomon.h"
+
+
+#define USE_PRINTER 1
+
+#define wxSetPrintPaperName wxThePrintSetupData->SetPaperName
+#define wxGetPrintPaperName wxThePrintSetupData->GetPaperName
+
+extern Bool wxSchemeYield(void *sema);
+
+extern void wxFlushDisplay(void);
+
+#ifdef wx_xt
+#define NO_XT 0
+#else
+#define NO_XT 1
+#endif
+
+#ifdef wx_x
+#define FILE_SEL_DEF_PATTERN "*"
+#else
+#define FILE_SEL_DEF_PATTERN "*.*"
+#endif
+
+#define BUF_SIZE 1000
+static char buffer[BUF_SIZE];
+
+static char *wxGetHostName_Scheme(void)
+{
+  if (!wxGetHostName(buffer, BUF_SIZE))
+    return NULL;
+  
+  return buffer;
+}
+static char *wxGet_Scheme(Bool (*f)(char *, int))
+{
+  if (!f(buffer, BUF_SIZE))
+    return NULL;
+  else
+    return buffer;
+}
+
+static char *wxExpandPath_Scheme(char *path)
+{
+  return wxExpandPath(buffer, (const char *)path);
+}
+
+static char *wxGetEmailAddress_Scheme(void)
+{
+  return wxGet_Scheme(wxGetEmailAddress);
+}
+
+static char *wxGetUserId_Scheme(void)
+{
+  return wxGet_Scheme(wxGetUserId);
+}
+
+static char *wxGetUserName_Scheme(void)
+{
+  return wxGet_Scheme(wxGetUserName);
+}
+
+static char *wxGetHomeDir_Scheme(void)
+{
+#if defined(wx_msw) || defined(wx_mac)
+  return NULL;
+#else
+  return wxGetHomeDir(buffer);
+#endif
+}
+
+static char *wxStripMenuCodes_Scheme(char *in)
+{
+  static char *buffer = NULL;
+  static long buflen = 0;
+  long len;
+
+  len = strlen(in);
+  if (buflen <= len) {
+    if (buffer)
+      delete[] buffer;
+    buflen = 2 * len + 1;
+    buffer = new char[buflen];
+  }
+
+  wxStripMenuCodes(in, buffer);
+  return buffer;
+}
+
+#if !defined(wx_x) || defined(wx_xt)
+Bool wxSetDisplay(char *)
+{
+  return FALSE;
+}
+
+char *wxGetDisplayName(void)
+{
+  return NULL;
+}
+#endif
+
+#ifdef wx_xt
+extern void wxBell(void);
+#endif
+
+
+// @ "wx:dir-exists?" : bool DirExists(string);
+// @ "wx:file-exists?" : bool FileExists(string);
+// @ "wx:file-name-from-path" : string FileNameFromPath(string);
+// @ "wx:is-absolute-path?" : bool IsAbsolutePath(string);
+// @ "wx:path-only" : string PathOnly(string);
+// @ "wx:expand-path" : string wxExpandPath_Scheme(string);
+// @ "wx:copy-file" : bool wxCopyFile(pathname,pathname);
+// @ "wx:get-working-directory" : string wxGetWorkingDirectory();
+// @ "wx:set-working-directory" : void wxSetWorkingDirectory(string);
+// @ "wx:is-wild?" : bool wxIsWild(string);
+// @ "wx:match-wild?" : bool wxMatchWild(string,string,bool);
+// @ "wx:mkdir" : bool wxMkdir(string);
+// Doesn't exist? @ "wx:rmdir" : bool wxRmdir(string);
+// @ "wx:remove-file" : bool wxRemoveFile(string);
+// @ "wx:rename-file" : bool wxRenameFile(string,string);
+// @ "wx:get-user-home" : string wxGetUserHome(ncstring=NULL);
+
+// @ "wx:get-home-dir" : string wxGetHomeDir_Scheme();
+
+
+
+// @ "wx:exit" : void wxExit();
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 1
+#define l_TERMINATE f[i] = 0;
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE string
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_string
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_string
+#define l_MAKE_LIST __MakestringList
+#define l_MAKE_ARRAY __MakestringArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+static int *__CopyIntArray(Scheme_Object *vec, Scheme_Object *list_for_count)
+{
+  int c = scheme_proper_list_length(list_for_count);
+  int *r = new int[c];
+  int i;
+  Scheme_Object **a;
+ 
+  if (c < 0)
+   scheme_wrong_type("wx:get-multiple-choice", "proper list", -1, 0, &list_for_count);
+
+  if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:get-multiple-choice", "vector", -1, 0, &vec);
+
+  if (SCHEME_VEC_SIZE(vec) != c)
+    scheme_signal_error("wx:get-multiple-choice: result array is size %d "
+			"but there are %d choices",
+			SCHEME_VEC_SIZE(vec), c);
+
+  a = SCHEME_VEC_ELS(vec);
+
+  for (i = 0; i < c; i++)
+    r[i] = objscheme_unbundle_integer(a[i], "wx:get-multiple-choice");
+
+  return r;
+}
+
+static void __CopyBackIntArray(int count, Scheme_Object *vec, int *r)
+{
+  int i;
+  Scheme_Object **a;
+  
+  a = SCHEME_VEC_ELS(vec);
+  for (i = 0; i < count; i++)
+    a[i] = objscheme_bundle_int(r[i]);
+
+  delete[] r;
+}
+
+
+
+
+
+
+#if !USE_METAFILE
+#define wxMakeMetaFilePlaceable(a,b,c,d,e,f) TRUE
+#endif
+
+
+
+
+// @ "wx:new-id" : long wxNewId(); ## NO_XT
+// @ "wx:register-id" : void wxRegisterId(long); ## NO_XT
+
+
+// @ "wx:error" : void wxError(string,string="wxWindows Internal Error");
+// @ "wx:fatal-error" : void wxFatalError(string,string="wxWindows Fatal Error");
+
+// @ "wx:execute" : void wxExecute(string,bool=FALSE); ## !defined(wx_mac)
+// @ "wx:execute" : void wxExecute(string[]/bList/ubList/cList,bool=FALSE); : /// : /glueUncountedListSet[string.0.0."wx:execute"]/glueCleanup[0]/ ## !defined(wx_mac)
+// @ "wx:shell" : void wxShell(string); ## !defined(wx_mac)
+
+// @ "wx:find-first-file" : string wxFindFirstFile(cstring, int=0);
+// @ "wx:find-next-file" : nstring wxFindNextFile();
+
+// @ "wx:find-menu-item-id" : int wxFindMenuItemId(wxFrame!,string,string);
+
+// @ "wx:get-elapsed-time" : long wxGetElapsedTime(bool=TRUE);  ## NO_XT
+// @ "wx:sleep" : void wxSleep(int);
+// @ "wx:start-timer" : void wxStartTimer(); ## NO_XT
+
+// @ "wx:sub-type?" : bool wxSubType(int,int);
+
+// @ "wx:to-lower" : char wxToLower(char);
+// @ "wx:to-upper" : char wxToUpper(char);
+
+// @ "wx:get-os-version" : int wxGetOsVersion(int?,int?);
+
+
+
+
+
+
+
+
+// @CONSTANT "wx:const-file" : int wxFILE ## NO_XT
+// @CONSTANT "wx:const-dir" : int wxDIR
+
+ 
+ 
+
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxFlushDisplay(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+
+  
+
+  
+  wxFlushDisplay();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSchemeYield(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  void* x0;
+
+  
+  if (n > 0) {
+    x0 = (void *)p[0];
+  } else
+    x0 = NULL;
+
+  
+  r = wxSchemeYield(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxWriteResource(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  if ((n >= 3) && objscheme_istype_string(p[0], NULL) && objscheme_istype_string(p[1], NULL) && objscheme_istype_string(p[2], NULL)) {
+    string x0;
+    string x1;
+    string x2;
+    nstring x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("::wx:write-resource (string case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "::wx:write-resource (string case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:write-resource (string case)");
+    x2 = (string)objscheme_unbundle_string(p[2], "::wx:write-resource (string case)");
+    if (n > 3) {
+      x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "::wx:write-resource (string case)");
+    } else
+      x3 = NULL;
+
+    
+    r = wxWriteResource(x0, x1, x2, x3);
+
+    
+    
+  } else  {
+    string x0;
+    string x1;
+    long x2;
+    nstring x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("::wx:write-resource (number case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "::wx:write-resource (number case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:write-resource (number case)");
+    x2 = objscheme_unbundle_integer(p[2], "::wx:write-resource (number case)");
+    if (n > 3) {
+      x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "::wx:write-resource (number case)");
+    } else
+      x3 = NULL;
+
+    
+    r = wxWriteResource(x0, x1, x2, x3);
+
+    
+    
+  }
+
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetResource(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  if ((n >= 3) && objscheme_istype_string(p[0], NULL) && objscheme_istype_string(p[1], NULL) && (objscheme_istype_box(p[2], NULL) && objscheme_istype_string(objscheme_unbox(p[2], NULL), NULL))) {
+    string x0;
+    string x1;
+    string _x2;
+    string* x2 = &_x2;
+    nstring x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("::wx:get-resource (string case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-resource (string case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-resource (string case)");
+    if (SCHEME_NULLP(p[2]))
+      scheme_wrong_type("::wx:get-resource (string case)", "non-null", (2 - 0), n, p);
+    else
+      *x2 = (string)objscheme_unbundle_string(objscheme_unbox(p[2], "::wx:get-resource (string case)"), "::wx:get-resource (string case)");
+    if (n > 3) {
+      x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "::wx:get-resource (string case)");
+    } else
+      x3 = NULL;
+
+    
+    r = wxGetResource(x0, x1, x2, x3);
+
+    
+    if (n > 2)
+      objscheme_set_box(p[2], objscheme_bundle_string((char *)_x2));
+    
+  } else  {
+    string x0;
+    string x1;
+    long _x2;
+    long* x2 = &_x2;
+    nstring x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("::wx:get-resource (number case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-resource (number case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-resource (number case)");
+    if (SCHEME_NULLP(p[2]))
+      scheme_wrong_type("::wx:get-resource (number case)", "non-null", (2 - 0), n, p);
+    else
+      *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "::wx:get-resource (number case)"), "::wx:get-resource (number case)");
+    if (n > 3) {
+      x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "::wx:get-resource (number case)");
+    } else
+      x3 = NULL;
+
+    
+    r = wxGetResource(x0, x1, x2, x3);
+
+    
+    if (n > 2)
+      objscheme_set_box(p[2], scheme_make_integer(_x2));
+    
+  }
+
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetFreeMemory(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+
+  
+
+  
+  r = wxGetFreeMemory();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxStripMenuCodes_Scheme(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:strip-menu-codes");
+
+  
+  r = wxStripMenuCodes_Scheme(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxFindWindowByName(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxWindow* r;
+  string x0;
+  class wxWindow* x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:find-window-by-name");
+  if (n > 1) {
+    x1 = objscheme_unbundle_wxWindow(p[1], "::wx:find-window-by-name", 1);
+  } else
+    x1 = NULL;
+
+  
+  r = wxFindWindowByName(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxWindow(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxFindWindowByLabel(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxWindow* r;
+  string x0;
+  class wxWindow* x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:find-window-by-label");
+  if (n > 1) {
+    x1 = objscheme_unbundle_wxWindow(p[1], "::wx:find-window-by-label", 1);
+  } else
+    x1 = NULL;
+
+  
+  r = wxFindWindowByLabel(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxWindow(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxDisplaySize(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("::wx:display-size", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "::wx:display-size"), "::wx:display-size");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("::wx:display-size", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "::wx:display-size"), "::wx:display-size");
+
+  
+  wxDisplaySize(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxBell(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+
+  
+
+  
+  wxBell();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxEndBusyCursor(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+
+  
+
+  
+  wxEndBusyCursor();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxIsBusy(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+
+  
+
+  
+  r = wxIsBusy();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxBeginBusyCursor(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_wxCursor(p[0], "::wx:begin-busy-cursor", 0);
+  } else
+    x0 = wxHOURGLASS_CURSOR;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:begin-busy-cursor");
+  wxBeginBusyCursor(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetLevel2Ok(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "::wx:set-post-script-level-2");
+
+  
+  wxSetLevel2Ok(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetAFMPath(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "::wx:set-afm-path");
+
+  
+  wxSetAFMPath(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrintPaperName(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "::wx:set-print-paper-name");
+
+  
+  wxSetPrintPaperName(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterTranslation(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "::wx:set-printer-translation");
+  x1 = objscheme_unbundle_float(p[1], "::wx:set-printer-translation");
+
+  
+  wxSetPrinterTranslation(x0, x1);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterScaling(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  nnfloat x0;
+  nnfloat x1;
+
+  
+  x0 = objscheme_unbundle_nonnegative_float(p[0], "::wx:set-printer-scaling");
+  x1 = objscheme_unbundle_nonnegative_float(p[1], "::wx:set-printer-scaling");
+
+  
+  wxSetPrinterScaling(x0, x1);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterOptions(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:set-printer-options");
+
+  
+  wxSetPrinterOptions(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterOrientation(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "::wx:set-printer-orientation");
+
+  
+  wxSetPrinterOrientation(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterMode(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "::wx:set-printer-mode");
+
+  
+  wxSetPrinterMode(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrintPreviewCommand(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:set-printer-preview-command");
+
+  
+  wxSetPrintPreviewCommand(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterFile(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  pathname x0;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "::wx:set-printer-file");
+
+  
+  wxSetPrinterFile(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetPrinterCommand(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:set-printer-command");
+
+  
+  wxSetPrinterCommand(x0);
+
+  
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetLevel2Ok(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetLevel2Ok();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-post-script-level-2");
+#endif
+  return (r ? scheme_true : scheme_false);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetAFMPath(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetAFMPath();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-afm-path");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrintPaperName(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrintPaperName();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-print-paper-name");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterTranslation(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("::wx:get-printer-translation", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "::wx:get-printer-translation"), "::wx:get-printer-translation");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("::wx:get-printer-translation", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "::wx:get-printer-translation"), "::wx:get-printer-translation");
+
+  
+  wxGetPrinterTranslation(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterScaling(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+#if  USE_PRINTER
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("::wx:get-printer-scaling", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "::wx:get-printer-scaling"), "::wx:get-printer-scaling");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("::wx:get-printer-scaling", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "::wx:get-printer-scaling"), "::wx:get-printer-scaling");
+
+  
+  wxGetPrinterScaling(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+#endif
+  return scheme_void;
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterOptions(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrinterOptions();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-options");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterOrientation(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrinterOrientation();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-orientation");
+#endif
+  return scheme_make_integer(r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterMode(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrinterMode();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-mode");
+#endif
+  return scheme_make_integer(r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrintPreviewCommand(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrintPreviewCommand();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-preview-command");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterFile(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrinterFile();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-file");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#if  USE_PRINTER
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetPrinterCommand(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+#if  USE_PRINTER
+
+  
+
+  
+  r = wxGetPrinterCommand();
+
+  
+  
+#else
+ scheme_signal_error("%s: provided arglist unsupported on this platform", "::wx:get-printer-command");
+#endif
+  return objscheme_bundle_string((char *)r);
+}
+#endif
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetCursor(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* x0;
+
+  
+  x0 = objscheme_unbundle_wxCursor(p[0], "::wx:set-cursor", 0);
+
+  if (x0 && !x0->Ok()) return scheme_void;
+  wxSetCursor(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxMakeMetaFilePlaceable(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  string x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:make-meta-file-placeable");
+  x1 = objscheme_unbundle_float(p[1], "::wx:make-meta-file-placeable");
+  x2 = objscheme_unbundle_float(p[2], "::wx:make-meta-file-placeable");
+  x3 = objscheme_unbundle_float(p[3], "::wx:make-meta-file-placeable");
+  x4 = objscheme_unbundle_float(p[4], "::wx:make-meta-file-placeable");
+  x5 = objscheme_unbundle_float(p[5], "::wx:make-meta-file-placeable");
+
+  
+  r = wxMakeMetaFilePlaceable(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxDisplayDepth(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+
+  
+
+  
+  r = wxDisplayDepth();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxColourDisplay(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+
+  
+
+  
+  r = wxColourDisplay();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetSingleChoiceData(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+  string x1;
+  int x2;
+  string* x3;
+  string* x4;
+  class wxWindow* x5;
+  int x6;
+  int x7;
+  Bool x8;
+  int x9;
+  int x10;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-single-choice-data");
+  x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-single-choice-data");
+  x3 = NULL;
+  x4 = NULL;
+  if (n > 4) {
+    x5 = objscheme_unbundle_wxWindow(p[4], "::wx:get-single-choice-data", 1);
+  } else
+    x5 = NULL;
+  if (n > 5) {
+    x6 = objscheme_unbundle_integer(p[5], "::wx:get-single-choice-data");
+  } else
+    x6 = -1;
+  if (n > 6) {
+    x7 = objscheme_unbundle_integer(p[6], "::wx:get-single-choice-data");
+  } else
+    x7 = -1;
+  if (n > 7) {
+    x8 = objscheme_unbundle_bool(p[7], "::wx:get-single-choice-data");
+  } else
+    x8 = TRUE;
+  if (n > 8) {
+    x9 = objscheme_unbundle_integer(p[8], "::wx:get-single-choice-data");
+  } else
+    x9 = 150;
+  if (n > 9) {
+    x10 = objscheme_unbundle_integer(p[9], "::wx:get-single-choice-data");
+  } else
+    x10 = 200;
+
+  if (scheme_proper_list_length(p[2]) != scheme_proper_list_length(p[3])) { scheme_signal_error("%s: choice and data lists are different lengths", "wx:get-single-choice-data"); }x3 = __MakestringArray((2 < n) ? p[2] : scheme_null, &x2, "wx:get-single-choice-data");x4 = __MakestringArray((3 < n) ? p[3] : scheme_null, &x2, "wx:get-single-choice-data");
+  r = wxGetSingleChoiceData(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
+
+  delete[] x3;delete[] x4;
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetSingleChoiceIndex(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  string x0;
+  string x1;
+  int x2;
+  string* x3;
+  class wxWindow* x4;
+  int x5;
+  int x6;
+  Bool x7;
+  int x8;
+  int x9;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-single-choice-index");
+  x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-single-choice-index");
+  x3 = NULL;
+  if (n > 3) {
+    x4 = objscheme_unbundle_wxWindow(p[3], "::wx:get-single-choice-index", 1);
+  } else
+    x4 = NULL;
+  if (n > 4) {
+    x5 = objscheme_unbundle_integer(p[4], "::wx:get-single-choice-index");
+  } else
+    x5 = -1;
+  if (n > 5) {
+    x6 = objscheme_unbundle_integer(p[5], "::wx:get-single-choice-index");
+  } else
+    x6 = -1;
+  if (n > 6) {
+    x7 = objscheme_unbundle_bool(p[6], "::wx:get-single-choice-index");
+  } else
+    x7 = TRUE;
+  if (n > 7) {
+    x8 = objscheme_unbundle_integer(p[7], "::wx:get-single-choice-index");
+  } else
+    x8 = 150;
+  if (n > 8) {
+    x9 = objscheme_unbundle_integer(p[8], "::wx:get-single-choice-index");
+  } else
+    x9 = 200;
+
+  x3 = __MakestringArray((2 < n) ? p[2] : scheme_null, &x2, "wx:get-single-choice-index");
+  r = wxGetSingleChoiceIndex(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  delete[] x3;
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetSingleChoice(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+  string x1;
+  int x2;
+  string* x3;
+  class wxWindow* x4;
+  int x5;
+  int x6;
+  Bool x7;
+  int x8;
+  int x9;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-single-choice");
+  x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-single-choice");
+  x3 = NULL;
+  if (n > 3) {
+    x4 = objscheme_unbundle_wxWindow(p[3], "::wx:get-single-choice", 1);
+  } else
+    x4 = NULL;
+  if (n > 4) {
+    x5 = objscheme_unbundle_integer(p[4], "::wx:get-single-choice");
+  } else
+    x5 = -1;
+  if (n > 5) {
+    x6 = objscheme_unbundle_integer(p[5], "::wx:get-single-choice");
+  } else
+    x6 = -1;
+  if (n > 6) {
+    x7 = objscheme_unbundle_bool(p[6], "::wx:get-single-choice");
+  } else
+    x7 = TRUE;
+  if (n > 7) {
+    x8 = objscheme_unbundle_integer(p[7], "::wx:get-single-choice");
+  } else
+    x8 = 150;
+  if (n > 8) {
+    x9 = objscheme_unbundle_integer(p[8], "::wx:get-single-choice");
+  } else
+    x9 = 200;
+
+  x3 = __MakestringArray((2 < n) ? p[2] : scheme_null, &x2, "wx:get-single-choice");
+  r = wxGetSingleChoice(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  delete[] x3;
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetMultipleChoice(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  string x0;
+  string x1;
+  int x2;
+  string* x3;
+  int x4;
+  int* x5;
+  class wxWindow* x6;
+  int x7;
+  int x8;
+  Bool x9;
+  int x10;
+  int x11;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-multiple-choice");
+  x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-multiple-choice");
+  x3 = NULL;
+  x4 = objscheme_unbundle_integer(p[3], "::wx:get-multiple-choice");
+  x5 = __CopyIntArray(p[4], p[2]);
+  if (n > 5) {
+    x6 = objscheme_unbundle_wxWindow(p[5], "::wx:get-multiple-choice", 1);
+  } else
+    x6 = NULL;
+  if (n > 6) {
+    x7 = objscheme_unbundle_integer(p[6], "::wx:get-multiple-choice");
+  } else
+    x7 = -1;
+  if (n > 7) {
+    x8 = objscheme_unbundle_integer(p[7], "::wx:get-multiple-choice");
+  } else
+    x8 = -1;
+  if (n > 8) {
+    x9 = objscheme_unbundle_bool(p[8], "::wx:get-multiple-choice");
+  } else
+    x9 = TRUE;
+  if (n > 9) {
+    x10 = objscheme_unbundle_integer(p[9], "::wx:get-multiple-choice");
+  } else
+    x10 = 150;
+  if (n > 10) {
+    x11 = objscheme_unbundle_integer(p[10], "::wx:get-multiple-choice");
+  } else
+    x11 = 200;
+
+  x3 = __MakestringArray((2 < n) ? p[2] : scheme_null, &x2, "wx:get-multiple-choice");
+  r = wxGetMultipleChoice(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
+
+  delete[] x3;__CopyBackIntArray(r, p[4], x5);
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetTextFromUser(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+  string x1;
+  string x2;
+  class wxWindow* x3;
+  int x4;
+  int x5;
+  Bool x6;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-text-from-user");
+  if (n > 1) {
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:get-text-from-user");
+  } else
+    x1 = "Input text";
+  if (n > 2) {
+    x2 = (string)objscheme_unbundle_string(p[2], "::wx:get-text-from-user");
+  } else
+    x2 = "";
+  if (n > 3) {
+    x3 = objscheme_unbundle_wxWindow(p[3], "::wx:get-text-from-user", 1);
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "::wx:get-text-from-user");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "::wx:get-text-from-user");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_bool(p[6], "::wx:get-text-from-user");
+  } else
+    x6 = TRUE;
+
+  
+  r = wxGetTextFromUser(x0, x1, x2, x3, x4, x5, x6);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxMessageBox(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  string x0;
+  string x1;
+  int x2;
+  class wxWindow* x3;
+  int x4;
+  int x5;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:message-box");
+  if (n > 1) {
+    x1 = (string)objscheme_unbundle_string(p[1], "::wx:message-box");
+  } else
+    x1 = "Message";
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "::wx:message-box");
+  } else
+    x2 = wxOK|wxCENTER;
+  if (n > 3) {
+    x3 = objscheme_unbundle_wxWindow(p[3], "::wx:message-box", 1);
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "::wx:message-box");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "::wx:message-box");
+  } else
+    x5 = -1;
+
+  
+  r = wxMessageBox(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxFileSelector(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+  nstring x1;
+  nstring x2;
+  nstring x3;
+  string x4;
+  int x5;
+  class wxWindow* x6;
+  int x7;
+  int x8;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:file-selector");
+  if (n > 1) {
+    x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "::wx:file-selector");
+  } else
+    x1 = NULL;
+  if (n > 2) {
+    x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "::wx:file-selector");
+  } else
+    x2 = NULL;
+  if (n > 3) {
+    x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "::wx:file-selector");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    x4 = (string)objscheme_unbundle_string(p[4], "::wx:file-selector");
+  } else
+    x4 = FILE_SEL_DEF_PATTERN;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "::wx:file-selector");
+  } else
+    x5 = 0;
+  if (n > 6) {
+    x6 = objscheme_unbundle_wxWindow(p[6], "::wx:file-selector", 1);
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "::wx:file-selector");
+  } else
+    x7 = -1;
+  if (n > 8) {
+    x8 = objscheme_unbundle_integer(p[8], "::wx:file-selector");
+  } else
+    x8 = -1;
+
+  
+  r = wxFileSelector(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetDisplayName(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+
+  
+
+  
+  r = wxGetDisplayName();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxSetDisplay(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "::wx:set-display");
+
+  
+  r = wxSetDisplay(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalStringMatch(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  string x0;
+  string x1;
+  Bool x2;
+  Bool x3;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:string-match?");
+  x1 = (string)objscheme_unbundle_string(p[1], "::wx:string-match?");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "::wx:string-match?");
+  } else
+    x2 = TRUE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "::wx:string-match?");
+  } else
+    x3 = FALSE;
+
+  
+  r = StringMatch(x0, x1, x2, x3);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetUserName_Scheme(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+
+  
+
+  
+  r = wxGetUserName_Scheme();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetUserId_Scheme(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+
+  
+
+  
+  r = wxGetUserId_Scheme();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetEmailAddress_Scheme(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+
+  
+
+  
+  r = wxGetEmailAddress_Scheme();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetHostName_Scheme(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+
+  
+
+  
+  r = wxGetHostName_Scheme();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxGetTempFileName(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "::wx:get-temp-file-name");
+
+  
+  r = wxGetTempFileName(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *wxsGlobalwxConcatFiles(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  pathname x0;
+  pathname x1;
+  pathname x2;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "::wx:concat-files");
+  x1 = (pathname)objscheme_unbundle_pathname(p[1], "::wx:concat-files");
+  x2 = (pathname)objscheme_unbundle_pathname(p[2], "::wx:concat-files");
+
+  
+  r = wxConcatFiles(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+void objscheme_setup_wxsGlobal(void *env)
+{
+  scheme_install_xc_global("wx:flush-display", scheme_make_prim_w_arity(wxsGlobalwxFlushDisplay, "wx:flush-display", 0, 0), env);
+  scheme_install_xc_global("wx:yield", scheme_make_prim_w_arity(wxsGlobalwxSchemeYield, "wx:yield", 0, 1), env);
+  scheme_install_xc_global("wx:write-resource", scheme_make_prim(wxsGlobalwxWriteResource), env);
+  scheme_install_xc_global("wx:get-resource", scheme_make_prim(wxsGlobalwxGetResource), env);
+  scheme_install_xc_global("wx:get-free-memory", scheme_make_prim_w_arity(wxsGlobalwxGetFreeMemory, "wx:get-free-memory", 0, 0), env);
+  scheme_install_xc_global("wx:strip-menu-codes", scheme_make_prim_w_arity(wxsGlobalwxStripMenuCodes_Scheme, "wx:strip-menu-codes", 1, 1), env);
+  scheme_install_xc_global("wx:find-window-by-name", scheme_make_prim_w_arity(wxsGlobalwxFindWindowByName, "wx:find-window-by-name", 1, 2), env);
+  scheme_install_xc_global("wx:find-window-by-label", scheme_make_prim_w_arity(wxsGlobalwxFindWindowByLabel, "wx:find-window-by-label", 1, 2), env);
+  scheme_install_xc_global("wx:display-size", scheme_make_prim_w_arity(wxsGlobalwxDisplaySize, "wx:display-size", 2, 2), env);
+  scheme_install_xc_global("wx:bell", scheme_make_prim_w_arity(wxsGlobalwxBell, "wx:bell", 0, 0), env);
+  scheme_install_xc_global("wx:end-busy-cursor", scheme_make_prim_w_arity(wxsGlobalwxEndBusyCursor, "wx:end-busy-cursor", 0, 0), env);
+  scheme_install_xc_global("wx:is-busy?", scheme_make_prim_w_arity(wxsGlobalwxIsBusy, "wx:is-busy?", 0, 0), env);
+  scheme_install_xc_global("wx:begin-busy-cursor", scheme_make_prim_w_arity(wxsGlobalwxBeginBusyCursor, "wx:begin-busy-cursor", 0, 1), env);
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-post-script-level-2", scheme_make_prim_w_arity(wxsGlobalwxSetLevel2Ok, "wx:set-post-script-level-2", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-afm-path", scheme_make_prim_w_arity(wxsGlobalwxSetAFMPath, "wx:set-afm-path", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-print-paper-name", scheme_make_prim_w_arity(wxsGlobalwxSetPrintPaperName, "wx:set-print-paper-name", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-translation", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterTranslation, "wx:set-printer-translation", 2, 2), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-scaling", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterScaling, "wx:set-printer-scaling", 2, 2), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-options", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterOptions, "wx:set-printer-options", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-orientation", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterOrientation, "wx:set-printer-orientation", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-mode", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterMode, "wx:set-printer-mode", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-preview-command", scheme_make_prim_w_arity(wxsGlobalwxSetPrintPreviewCommand, "wx:set-printer-preview-command", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-file", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterFile, "wx:set-printer-file", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:set-printer-command", scheme_make_prim_w_arity(wxsGlobalwxSetPrinterCommand, "wx:set-printer-command", 1, 1), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-post-script-level-2", scheme_make_prim_w_arity(wxsGlobalwxGetLevel2Ok, "wx:get-post-script-level-2", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-afm-path", scheme_make_prim_w_arity(wxsGlobalwxGetAFMPath, "wx:get-afm-path", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-print-paper-name", scheme_make_prim_w_arity(wxsGlobalwxGetPrintPaperName, "wx:get-print-paper-name", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-translation", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterTranslation, "wx:get-printer-translation", 2, 2), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-scaling", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterScaling, "wx:get-printer-scaling", 2, 2), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-options", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterOptions, "wx:get-printer-options", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-orientation", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterOrientation, "wx:get-printer-orientation", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-mode", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterMode, "wx:get-printer-mode", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-preview-command", scheme_make_prim_w_arity(wxsGlobalwxGetPrintPreviewCommand, "wx:get-printer-preview-command", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-file", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterFile, "wx:get-printer-file", 0, 0), env);
+#endif
+#if  USE_PRINTER
+  scheme_install_xc_global("wx:get-printer-command", scheme_make_prim_w_arity(wxsGlobalwxGetPrinterCommand, "wx:get-printer-command", 0, 0), env);
+#endif
+  scheme_install_xc_global("wx:set-cursor", scheme_make_prim_w_arity(wxsGlobalwxSetCursor, "wx:set-cursor", 1, 1), env);
+  scheme_install_xc_global("wx:make-meta-file-placeable", scheme_make_prim_w_arity(wxsGlobalwxMakeMetaFilePlaceable, "wx:make-meta-file-placeable", 6, 6), env);
+  scheme_install_xc_global("wx:display-depth", scheme_make_prim_w_arity(wxsGlobalwxDisplayDepth, "wx:display-depth", 0, 0), env);
+  scheme_install_xc_global("wx:colour-display?", scheme_make_prim_w_arity(wxsGlobalwxColourDisplay, "wx:colour-display?", 0, 0), env);
+  scheme_install_xc_global("wx:get-single-choice-data", scheme_make_prim_w_arity(wxsGlobalwxGetSingleChoiceData, "wx:get-single-choice-data", 4, 10), env);
+  scheme_install_xc_global("wx:get-single-choice-index", scheme_make_prim_w_arity(wxsGlobalwxGetSingleChoiceIndex, "wx:get-single-choice-index", 3, 9), env);
+  scheme_install_xc_global("wx:get-single-choice", scheme_make_prim_w_arity(wxsGlobalwxGetSingleChoice, "wx:get-single-choice", 3, 9), env);
+  scheme_install_xc_global("wx:get-multiple-choice", scheme_make_prim_w_arity(wxsGlobalwxGetMultipleChoice, "wx:get-multiple-choice", 5, 11), env);
+  scheme_install_xc_global("wx:get-text-from-user", scheme_make_prim_w_arity(wxsGlobalwxGetTextFromUser, "wx:get-text-from-user", 1, 7), env);
+  scheme_install_xc_global("wx:message-box", scheme_make_prim_w_arity(wxsGlobalwxMessageBox, "wx:message-box", 1, 6), env);
+  scheme_install_xc_global("wx:file-selector", scheme_make_prim_w_arity(wxsGlobalwxFileSelector, "wx:file-selector", 1, 9), env);
+  scheme_install_xc_global("wx:get-display-name", scheme_make_prim_w_arity(wxsGlobalwxGetDisplayName, "wx:get-display-name", 0, 0), env);
+  scheme_install_xc_global("wx:set-display", scheme_make_prim_w_arity(wxsGlobalwxSetDisplay, "wx:set-display", 1, 1), env);
+  scheme_install_xc_global("wx:string-match?", scheme_make_prim_w_arity(wxsGlobalStringMatch, "wx:string-match?", 2, 4), env);
+  scheme_install_xc_global("wx:get-user-name", scheme_make_prim_w_arity(wxsGlobalwxGetUserName_Scheme, "wx:get-user-name", 0, 0), env);
+  scheme_install_xc_global("wx:get-user-id", scheme_make_prim_w_arity(wxsGlobalwxGetUserId_Scheme, "wx:get-user-id", 0, 0), env);
+  scheme_install_xc_global("wx:get-email-address", scheme_make_prim_w_arity(wxsGlobalwxGetEmailAddress_Scheme, "wx:get-email-address", 0, 0), env);
+  scheme_install_xc_global("wx:get-host-name", scheme_make_prim_w_arity(wxsGlobalwxGetHostName_Scheme, "wx:get-host-name", 0, 0), env);
+  scheme_install_xc_global("wx:get-temp-file-name", scheme_make_prim_w_arity(wxsGlobalwxGetTempFileName, "wx:get-temp-file-name", 1, 1), env);
+  scheme_install_xc_global("wx:concat-files", scheme_make_prim_w_arity(wxsGlobalwxConcatFiles, "wx:concat-files", 3, 3), env);
+  scheme_install_xc_global("wx:const-ok", scheme_make_integer(wxOK), env);
+  scheme_install_xc_global("wx:const-yes-no", scheme_make_integer(wxYES_NO), env);
+  scheme_install_xc_global("wx:const-cancel", scheme_make_integer(wxCANCEL), env);
+  scheme_install_xc_global("wx:const-yes", scheme_make_integer(wxYES), env);
+  scheme_install_xc_global("wx:const-no", scheme_make_integer(wxNO), env);
+  scheme_install_xc_global("wx:const-icon-exclamation", scheme_make_integer(wxICON_EXCLAMATION), env);
+  scheme_install_xc_global("wx:const-icon-hand", scheme_make_integer(wxICON_HAND), env);
+  scheme_install_xc_global("wx:const-icon-question", scheme_make_integer(wxICON_QUESTION), env);
+  scheme_install_xc_global("wx:const-icon-information", scheme_make_integer(wxICON_INFORMATION), env);
+  scheme_install_xc_global("wx:const-icon-stop", scheme_make_integer(wxICON_STOP), env);
+  scheme_install_xc_global("wx:const-icon-asterisk", scheme_make_integer(wxICON_ASTERISK), env);
+  scheme_install_xc_global("wx:const-icon-mask", scheme_make_integer(wxICON_MASK), env);
+  scheme_install_xc_global("wx:const-center", scheme_make_integer(wxCENTER), env);
+  scheme_install_xc_global("wx:const-centre", scheme_make_integer(wxCENTRE), env);
+  scheme_install_xc_global("wx:const-ps-portrait", scheme_make_integer(PS_PORTRAIT), env);
+  scheme_install_xc_global("wx:const-ps-landscape", scheme_make_integer(PS_LANDSCAPE), env);
+  scheme_install_xc_global("wx:const-ps-preview", scheme_make_integer(PS_PREVIEW), env);
+  scheme_install_xc_global("wx:const-ps-file", scheme_make_integer(PS_FILE), env);
+  scheme_install_xc_global("wx:const-ps-printer", scheme_make_integer(PS_PRINTER), env);
+  scheme_install_xc_global("wx:const-open", scheme_make_integer(wxOPEN), env);
+  scheme_install_xc_global("wx:const-save", scheme_make_integer(wxSAVE), env);
+  scheme_install_xc_global("wx:const-overwrite-prompt", scheme_make_integer(wxOVERWRITE_PROMPT), env);
+  scheme_install_xc_global("wx:const-hide-readonly", scheme_make_integer(wxHIDE_READONLY), env);
+  scheme_install_xc_global("wx:hourglass-cursor", objscheme_bundle_wxCursor(wxHOURGLASS_CURSOR), env);
+}
+
diff --git a/src/mred/wxs/wxs_glob.h b/src/mred/wxs/wxs_glob.h
new file mode 100644
index 0000000..440e9ca
--- /dev/null
+++ b/src/mred/wxs/wxs_glob.h
@@ -0,0 +1,19 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxsGlobal(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+#endif
diff --git a/src/mred/wxs/wxs_glob.xc b/src/mred/wxs/wxs_glob.xc
new file mode 100644
index 0000000..35823fa
--- /dev/null
+++ b/src/mred/wxs/wxs_glob.xc
@@ -0,0 +1,342 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_utils.h"
+#include "wx_dialg.h"
+#include "wx_cmdlg.h"
+#include "wx_timer.h"
+#include "wx_dcps.h"
+#include "wx_main.h"
+#ifdef wx_xt
+#define Uses_wxPrintSetup
+#include "wx_types.h"
+#include "wx_print.h"
+#endif
+
+#ifdef wx_msw
+#ifdef _MSC_VER
+#include <direct.h>
+#else
+#include <dir.h>
+#endif
+#endif
+
+#if USE_METAFILE
+#include "wx_mf.h"
+#endif
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#define USE_PRINTER 1
+
+#define wxSetPrintPaperName wxThePrintSetupData->SetPaperName
+#define wxGetPrintPaperName wxThePrintSetupData->GetPaperName
+
+extern Bool wxSchemeYield(void *sema);
+
+extern void wxFlushDisplay(void);
+
+#ifdef wx_xt
+#define NO_XT 0
+#else
+#define NO_XT 1
+#endif
+
+#ifdef wx_x
+#define FILE_SEL_DEF_PATTERN "*"
+#else
+#define FILE_SEL_DEF_PATTERN "*.*"
+#endif
+
+#define BUF_SIZE 1000
+static char buffer[BUF_SIZE];
+
+static char *wxGetHostName_Scheme(void)
+{
+  if (!wxGetHostName(buffer, BUF_SIZE))
+    return NULL;
+  
+  return buffer;
+}
+static char *wxGet_Scheme(Bool (*f)(char *, int))
+{
+  if (!f(buffer, BUF_SIZE))
+    return NULL;
+  else
+    return buffer;
+}
+
+static char *wxExpandPath_Scheme(char *path)
+{
+  return wxExpandPath(buffer, (const char *)path);
+}
+
+static char *wxGetEmailAddress_Scheme(void)
+{
+  return wxGet_Scheme(wxGetEmailAddress);
+}
+
+static char *wxGetUserId_Scheme(void)
+{
+  return wxGet_Scheme(wxGetUserId);
+}
+
+static char *wxGetUserName_Scheme(void)
+{
+  return wxGet_Scheme(wxGetUserName);
+}
+
+static char *wxGetHomeDir_Scheme(void)
+{
+#if defined(wx_msw) || defined(wx_mac)
+  return NULL;
+#else
+  return wxGetHomeDir(buffer);
+#endif
+}
+
+static char *wxStripMenuCodes_Scheme(char *in)
+{
+  static char *buffer = NULL;
+  static long buflen = 0;
+  long len;
+
+  len = strlen(in);
+  if (buflen <= len) {
+    if (buffer)
+      delete[] buffer;
+    buflen = 2 * len + 1;
+    buffer = new char[buflen];
+  }
+
+  wxStripMenuCodes(in, buffer);
+  return buffer;
+}
+
+#if !defined(wx_x) || defined(wx_xt)
+Bool wxSetDisplay(char *)
+{
+  return FALSE;
+}
+
+char *wxGetDisplayName(void)
+{
+  return NULL;
+}
+#endif
+
+#ifdef wx_xt
+extern void wxBell(void);
+#endif
+
+@GLOBAL wxsGlobal
+
+// @ "wx:dir-exists?" : bool DirExists(string);
+// @ "wx:file-exists?" : bool FileExists(string);
+// @ "wx:file-name-from-path" : string FileNameFromPath(string);
+// @ "wx:is-absolute-path?" : bool IsAbsolutePath(string);
+// @ "wx:path-only" : string PathOnly(string);
+@ "wx:concat-files" : bool wxConcatFiles(pathname,pathname,pathname);
+// @ "wx:expand-path" : string wxExpandPath_Scheme(string);
+// @ "wx:copy-file" : bool wxCopyFile(pathname,pathname);
+// @ "wx:get-working-directory" : string wxGetWorkingDirectory();
+// @ "wx:set-working-directory" : void wxSetWorkingDirectory(string);
+@ "wx:get-temp-file-name" : string wxGetTempFileName(string);
+// @ "wx:is-wild?" : bool wxIsWild(string);
+// @ "wx:match-wild?" : bool wxMatchWild(string,string,bool);
+// @ "wx:mkdir" : bool wxMkdir(string);
+// Doesn't exist? @ "wx:rmdir" : bool wxRmdir(string);
+// @ "wx:remove-file" : bool wxRemoveFile(string);
+// @ "wx:rename-file" : bool wxRenameFile(string,string);
+// @ "wx:get-user-home" : string wxGetUserHome(ncstring=NULL);
+
+@ "wx:get-host-name" : nstring wxGetHostName_Scheme();
+// @ "wx:get-home-dir" : string wxGetHomeDir_Scheme();
+@ "wx:get-email-address" : nstring wxGetEmailAddress_Scheme();
+@ "wx:get-user-id" : nstring wxGetUserId_Scheme();
+@ "wx:get-user-name" : nstring wxGetUserName_Scheme();
+
+@ "wx:string-match?" : bool StringMatch(string,string,bool=TRUE,bool=FALSE);
+
+@ "wx:set-display" : bool wxSetDisplay(nstring);
+@ "wx:get-display-name" : nstring wxGetDisplayName();
+
+// @ "wx:exit" : void wxExit();
+
+@ "wx:file-selector" : string wxFileSelector(string,nstring=NULL,nstring=NULL,nstring=NULL,string=FILE_SEL_DEF_PATTERN,int=0,wxWindow^=NULL,int=-1,int=-1);
+@ "wx:message-box" : int wxMessageBox(string, string="Message",int=wxOK|wxCENTER,wxWindow^=NULL,int=-1,int=-1);
+@ "wx:get-text-from-user" : string wxGetTextFromUser(string,string="Input text",string="",wxWindow^=NULL,int=-1,int=-1,bool=TRUE);
+
+@SET TYPE = string
+@SET NOTEST = 1
+@SET NULLTERM = 1
+@INCLUDE list.xci
+
+static int *__CopyIntArray(Scheme_Object *vec, Scheme_Object *list_for_count)
+{
+  int c = scheme_proper_list_length(list_for_count);
+  int *r = new int[c];
+  int i;
+  Scheme_Object **a;
+ 
+  if (c < 0)
+   scheme_wrong_type("wx:get-multiple-choice", "proper list", -1, 0, &list_for_count);
+
+  if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:get-multiple-choice", "vector", -1, 0, &vec);
+
+  if (SCHEME_VEC_SIZE(vec) != c)
+    scheme_signal_error("wx:get-multiple-choice: result array is size %d "
+			"but there are %d choices",
+			SCHEME_VEC_SIZE(vec), c);
+
+  a = SCHEME_VEC_ELS(vec);
+
+  for (i = 0; i < c; i++)
+    r[i] = objscheme_unbundle_integer(a[i], "wx:get-multiple-choice");
+
+  return r;
+}
+
+static void __CopyBackIntArray(int count, Scheme_Object *vec, int *r)
+{
+  int i;
+  Scheme_Object **a;
+  
+  a = SCHEME_VEC_ELS(vec);
+  for (i = 0; i < count; i++)
+    a[i] = objscheme_bundle_int(r[i]);
+
+  delete[] r;
+}
+
+@MACRO ubMutArray = __CopyIntArray({x}, p[2])
+@MACRO mutArrayFinish = __CopyBackIntArray(r, p[4], x5);
+
+@MACRO checkSameLength[n.m.who] = if (scheme_proper_list_length(p[<n>]) != scheme_proper_list_length(p[<m>])) { scheme_signal_error("%s: choice and data lists are different lengths", <who>); }
+
+@ "wx:get-multiple-choice" : int wxGetMultipleChoice(string,string,-int,string[]/bList/ubList/cList,int,int[]//ubMutArray,wxWindow^=NULL,int=-1,int=-1,bool=TRUE,int=150,int=200); : /// : /glueListSet[string.2.3.2."wx:get-multiple-choice"]/glueCleanup[3]|mutArrayFinish/
+
+@ "wx:get-single-choice" : string wxGetSingleChoice(string,string,-int,string[]/bList/ubList/cList,wxWindow^=NULL,int=-1,int=-1,bool=TRUE,int=150,int=200); : /// : /glueListSet[string.2.3.2."wx:get-single-choice"]/glueCleanup[3]/
+@ "wx:get-single-choice-index" : int wxGetSingleChoiceIndex(string,string,-int,string[]/bList/ubList/cList,wxWindow^=NULL,int=-1,int=-1,bool=TRUE,int=150,int=200); : /// : /glueListSet[string.2.3.2."wx:get-single-choice-index"]/glueCleanup[3]/
+@ "wx:get-single-choice-data" : string wxGetSingleChoiceData(string,string,-int,string[]/bList/ubList/cList,string[]/bList/ubList/cList,wxWindow^=NULL,int=-1,int=-1,bool=TRUE,int=150,int=200); : /// : /checkSameLength[2.3."wx:get-single-choice-data"]|glueListSet[string.2.3.2."wx:get-single-choice-data"]|glueListSet[string.3.4.2."wx:get-single-choice-data"]/glueCleanup[3] | glueCleanup[4] /
+
+@ "wx:colour-display?" : bool wxColourDisplay();
+@ "wx:display-depth" : int wxDisplayDepth();
+
+#if !USE_METAFILE
+#define wxMakeMetaFilePlaceable(a,b,c,d,e,f) TRUE
+#endif
+@ "wx:make-meta-file-placeable" : bool wxMakeMetaFilePlaceable(string,float,float,float,float,float);
+
+@ "wx:set-cursor" : void wxSetCursor(wxCursor!); : : /CHECKVOIDABLEOK[0]
+
+@ "wx:get-printer-command" : string wxGetPrinterCommand(); ## USE_PRINTER
+@ "wx:get-printer-file" : string wxGetPrinterFile(); ## USE_PRINTER
+@ "wx:get-printer-preview-command" : string wxGetPrintPreviewCommand(); ## USE_PRINTER
+@ "wx:get-printer-mode" : int wxGetPrinterMode(); ## USE_PRINTER
+@ "wx:get-printer-orientation" : int wxGetPrinterOrientation(); ## USE_PRINTER
+@ "wx:get-printer-options" : string wxGetPrinterOptions(); ## USE_PRINTER
+@ "wx:get-printer-scaling" : void wxGetPrinterScaling(float*,float*); ## USE_PRINTER
+@ "wx:get-printer-translation" : void wxGetPrinterTranslation(float*,float*); ## USE_PRINTER
+@ "wx:get-print-paper-name" : nstring wxGetPrintPaperName(); ## USE_PRINTER
+@ "wx:get-afm-path" : nstring wxGetAFMPath(); ## USE_PRINTER
+@ "wx:get-post-script-level-2" : bool wxGetLevel2Ok(); ## USE_PRINTER
+
+@ "wx:set-printer-command" : void wxSetPrinterCommand(string); ## USE_PRINTER
+@ "wx:set-printer-file" : void wxSetPrinterFile(pathname); ## USE_PRINTER
+@ "wx:set-printer-preview-command" : void wxSetPrintPreviewCommand(string);  ## USE_PRINTER
+@ "wx:set-printer-mode" : void wxSetPrinterMode(int); ## USE_PRINTER
+@ "wx:set-printer-orientation" : void wxSetPrinterOrientation(int); ## USE_PRINTER
+@ "wx:set-printer-options" : void wxSetPrinterOptions(string); ## USE_PRINTER
+@ "wx:set-printer-scaling" : void wxSetPrinterScaling(nnfloat,nnfloat); ## USE_PRINTER
+@ "wx:set-printer-translation" : void wxSetPrinterTranslation(float,float); ## USE_PRINTER
+@ "wx:set-print-paper-name" : void wxSetPrintPaperName(nstring); ## USE_PRINTER
+@ "wx:set-afm-path" : void wxSetAFMPath(nstring); ## USE_PRINTER
+@ "wx:set-post-script-level-2" : void wxSetLevel2Ok(bool); ## USE_PRINTER
+
+// @ "wx:new-id" : long wxNewId(); ## NO_XT
+// @ "wx:register-id" : void wxRegisterId(long); ## NO_XT
+
+@ "wx:begin-busy-cursor" : void wxBeginBusyCursor(wxCursor!=wxHOURGLASS_CURSOR); : : /CHECKOK[0."wx:begin-busy-cursor"]
+@ "wx:is-busy?" : bool wxIsBusy();
+@ "wx:end-busy-cursor" : void wxEndBusyCursor();
+@ "wx:bell" : void wxBell();
+@ "wx:display-size" : void wxDisplaySize(int*,int*);
+
+// @ "wx:error" : void wxError(string,string="wxWindows Internal Error");
+// @ "wx:fatal-error" : void wxFatalError(string,string="wxWindows Fatal Error");
+
+// @ "wx:execute" : void wxExecute(string,bool=FALSE); ## !defined(wx_mac)
+// @ "wx:execute" : void wxExecute(string[]/bList/ubList/cList,bool=FALSE); : /// : /glueUncountedListSet[string.0.0."wx:execute"]/glueCleanup[0]/ ## !defined(wx_mac)
+// @ "wx:shell" : void wxShell(string); ## !defined(wx_mac)
+
+// @ "wx:find-first-file" : string wxFindFirstFile(cstring, int=0);
+// @ "wx:find-next-file" : nstring wxFindNextFile();
+
+// @ "wx:find-menu-item-id" : int wxFindMenuItemId(wxFrame!,string,string);
+@ "wx:find-window-by-label" : wxWindow^ wxFindWindowByLabel(string,wxWindow^=NULL);
+@ "wx:find-window-by-name" : wxWindow^ wxFindWindowByName(string,wxWindow^=NULL);
+@ "wx:strip-menu-codes" : string wxStripMenuCodes_Scheme(string);
+
+// @ "wx:get-elapsed-time" : long wxGetElapsedTime(bool=TRUE);  ## NO_XT
+// @ "wx:sleep" : void wxSleep(int);
+// @ "wx:start-timer" : void wxStartTimer(); ## NO_XT
+
+// @ "wx:sub-type?" : bool wxSubType(int,int);
+
+// @ "wx:to-lower" : char wxToLower(char);
+// @ "wx:to-upper" : char wxToUpper(char);
+
+@ "wx:get-free-memory" : long wxGetFreeMemory();
+// @ "wx:get-os-version" : int wxGetOsVersion(int?,int?);
+
+@ "wx:get-resource" : bool wxGetResource(string,string,string*,nstring=NULL); <> string
+@ "wx:get-resource" : bool wxGetResource(string,string,long*,nstring=NULL); <> number
+@ "wx:write-resource" : bool wxWriteResource(string,string,string,nstring=NULL); <> string
+@ "wx:write-resource" : bool wxWriteResource(string,string,long,nstring=NULL); <> number
+
+@MACRO BundleVoidStar = (void *){x}
+@MACRO spSema = semaphore
+
+@ "wx:yield" : bool wxSchemeYield(void[]=NULL//BundleVoidStar///spSema);
+@ "wx:flush-display" : void wxFlushDisplay();
+
+@CONSTANT "wx:const-ok" : int wxOK
+@CONSTANT "wx:const-yes-no" : int wxYES_NO
+@CONSTANT "wx:const-cancel" : int wxCANCEL
+@CONSTANT "wx:const-yes" : int wxYES
+@CONSTANT "wx:const-no" : int wxNO
+
+@CONSTANT "wx:const-icon-exclamation" : int wxICON_EXCLAMATION
+@CONSTANT "wx:const-icon-hand" : int wxICON_HAND
+@CONSTANT "wx:const-icon-question" : int wxICON_QUESTION
+@CONSTANT "wx:const-icon-information" : int wxICON_INFORMATION
+
+@CONSTANT "wx:const-icon-stop" : int wxICON_STOP
+@CONSTANT "wx:const-icon-asterisk" : int wxICON_ASTERISK
+@CONSTANT "wx:const-icon-mask" : int wxICON_MASK
+
+@CONSTANT "wx:const-center" : int wxCENTER
+@CONSTANT "wx:const-centre" : int wxCENTRE
+
+// @CONSTANT "wx:const-file" : int wxFILE ## NO_XT
+// @CONSTANT "wx:const-dir" : int wxDIR
+
+@CONSTANT "wx:const-ps-portrait" : int PS_PORTRAIT
+@CONSTANT "wx:const-ps-landscape" : int PS_LANDSCAPE
+ 
+@CONSTANT "wx:const-ps-preview" : int PS_PREVIEW
+@CONSTANT "wx:const-ps-file" : int PS_FILE
+@CONSTANT "wx:const-ps-printer" : int PS_PRINTER
+ 
+@CONSTANT "wx:const-open" : int wxOPEN
+@CONSTANT "wx:const-save" : int wxSAVE
+@CONSTANT "wx:const-overwrite-prompt" : int wxOVERWRITE_PROMPT
+@CONSTANT "wx:const-hide-readonly" : int wxHIDE_READONLY
+
+@CONSTANT "wx:hourglass-cursor" : wxCursor! wxHOURGLASS_CURSOR
+
+@END
diff --git a/src/mred/wxs/wxs_help.cxx b/src/mred/wxs/wxs_help.cxx
new file mode 100644
index 0000000..a79ee18
--- /dev/null
+++ b/src/mred/wxs/wxs_help.cxx
@@ -0,0 +1,15 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_help.xc". */
+
+
+#include "wx_help.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_help.h"
+#include "wxscomon.h"
+
+
diff --git a/src/mred/wxs/wxs_help.h b/src/mred/wxs/wxs_help.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxs_help.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_help.xc b/src/mred/wxs/wxs_help.xc
new file mode 100644
index 0000000..b7b22e5
--- /dev/null
+++ b/src/mred/wxs/wxs_help.xc
@@ -0,0 +1,25 @@
+
+#include "wx_help.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if 0
+
+@CLASSBASE wxHelpInstance "wx:help-instance" : "wx:client"
+
+@CREATOR ()
+
+@ "initialize" : void Initialize(string,int=-1);
+@ "display-block" : bool DisplayBlock(long);
+@ "display-contents" : bool DisplayContents();
+@ "display-section" : bool DisplaySection(int);
+@ "keyword-search" : bool KeywordSearch(string);
+@ "load-file" : bool LoadFile(string=NULL);
+@ "on-quit" : void OnQuit();
+@ "quit" : bool Quit();
+
+@END
+
+#endif
diff --git a/src/mred/wxs/wxs_icol.xci b/src/mred/wxs/wxs_icol.xci
new file mode 100644
index 0000000..7d9c591
--- /dev/null
+++ b/src/mred/wxs/wxs_icol.xci
@@ -0,0 +1,8 @@
+@ "get-button-colour" : wxColour! GetButtonColour();
+@ "set-button-colour" : void SetButtonColour(wxColour!);
+
+@ "get-label-colour" : wxColour! GetLabelColour();
+@ "set-label-colour" : void SetLabelColour(wxColour!);
+
+@ "get-background-colour" : wxColour! GetBackgroundColour();
+@ "set-background-colour" : void SetBackgroundColour(wxColour!);
diff --git a/src/mred/wxs/wxs_ifnt.xci b/src/mred/wxs/wxs_ifnt.xci
new file mode 100644
index 0000000..b36af6c
--- /dev/null
+++ b/src/mred/wxs/wxs_ifnt.xci
@@ -0,0 +1,5 @@
+@ "set-button-font" : void SetButtonFont(wxFont!);
+@ "get-button-font" : wxFont! GetButtonFont();
+@ "set-label-font" : void SetLabelFont(wxFont!);
+@ "get-label-font" : wxFont! GetLabelFont();
+
diff --git a/src/mred/wxs/wxs_ipc.cxx b/src/mred/wxs/wxs_ipc.cxx
new file mode 100644
index 0000000..90acebc
--- /dev/null
+++ b/src/mred/wxs/wxs_ipc.cxx
@@ -0,0 +1,4 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_ipc.xc". */
+
+
diff --git a/src/mred/wxs/wxs_ipc.h b/src/mred/wxs/wxs_ipc.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxs_ipc.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_ipc.xc b/src/mred/wxs/wxs_ipc.xc
new file mode 100644
index 0000000..9e87ba3
--- /dev/null
+++ b/src/mred/wxs/wxs_ipc.xc
@@ -0,0 +1,57 @@
+
+#if 0
+
+#include "wx_ipc.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@GLOBAL wxsIPCGlobal
+
+@ "wx:ipc-initialize" : void wxIPCInitialize();
+
+@END
+
+@CLASSBASE wxConnection "wx:connection" : "wx:object"
+
+@CREATOR ();
+
+@ "advise" : bool Advise(string,string,int=-1,int=wxCF_TEXT);
+@ "poke" : bool Poke(string,string,int=-1,int=wxCF_TEXT);
+@ "execute" : bool Execute(string,int=-1,int=wxCF_TEXT);
+@ "request" : string Request(string,int*,int=wxCF_TEXT);
+@ "start-advise" : bool StartAdvise(string);
+@ "stop-advise" : bool StopAdvise(string);
+
+@ v "on-advise" : bool OnAdvise(string,string,string,int,int);
+@ v "on-start-advise" : bool OnStartAdvise(string,string);
+@ v "on-stop-advise" : bool OnStopAdvise(string,string);
+@ v "on-poke" : bool OnPoke(string,string,string,int,int);
+@ v "on-execute" : bool OnExecute(string,string,int,int);
+@ v "on-request" : string OnRequest(string,string,int*,int);
+@ v "on-disconnect" : bool OnDisconnect();
+
+@ "disconnect" : void Disconnect();
+
+@END
+
+@CLASSBASE wxClient "wx:client" : "wx:object"
+
+@CREATOR ();
+
+@ "make-connection" : wxConnection^ MakeConnection(string,string,string);
+@ v "on-make-connection" : wxConnection^ OnMakeConnection()
+
+@END
+
+@CLASSBASE wxServer "wx:server" : "wx:object"
+
+@CREATOR ();
+
+@ "create" : bool Create(string);
+@ v "on-accept-connection" : wxConnection^ OnAcceptConnection(string)
+
+@END
+
+#endif
diff --git a/src/mred/wxs/wxs_item.cxx b/src/mred/wxs/wxs_item.cxx
new file mode 100644
index 0000000..6076e8d
--- /dev/null
+++ b/src/mred/wxs/wxs_item.cxx
@@ -0,0 +1,830 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_item.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_item.h"
+#include "wx_messg.h"
+#include "wx_group.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_item.h"
+#include "wxscomon.h"
+
+
+
+
+// @ "centre" : void Centre(int=wxHORIZONTAL);
+
+
+
+
+
+
+
+class os_wxItem : public wxItem {
+ public:
+
+  ~os_wxItem();
+};
+
+Scheme_Object *os_wxItem_class;
+
+os_wxItem::~os_wxItem()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemSetButtonColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:item%::set-button-colour", 0);
+
+  
+  ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->SetButtonColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemSetLabelColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:item%::set-label-colour", 0);
+
+  
+  ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->SetLabelColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemSetBackgroundColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:item%::set-background-colour", 0);
+
+  
+  ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->SetBackgroundColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetCharWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetCharWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetCharHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetCharHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:item%::set-label");
+
+  
+  ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetLabel();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetBackgroundColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetBackgroundColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetLabelColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetLabelColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemGetButtonColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->GetButtonColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxItemCommand(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxCommandEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxCommandEvent(p[0], "wx:item%::command", 0);
+
+  
+  ((wxItem *)((Scheme_Class_Object *)obj)->primdata)->Command(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxItem(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:item%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:item%");
+}
+
+void objscheme_setup_wxItem(void *env)
+{
+if (os_wxItem_class) {
+    objscheme_add_global_class(os_wxItem_class,  "wx:item%", env);
+} else {
+  os_wxItem_class = objscheme_def_prim_class(env, "wx:item%", "wx:window%", NULL, 12);
+
+  scheme_add_method_w_arity(os_wxItem_class,"get-class-name",objscheme_classname_os_wxItem, 0, 0);
+
+ scheme_add_method_w_arity(os_wxItem_class, "set-button-colour", os_wxItemSetButtonColour, 1, 1);
+ scheme_add_method_w_arity(os_wxItem_class, "set-label-colour", os_wxItemSetLabelColour, 1, 1);
+ scheme_add_method_w_arity(os_wxItem_class, "set-background-colour", os_wxItemSetBackgroundColour, 1, 1);
+ scheme_add_method_w_arity(os_wxItem_class, "get-char-width", os_wxItemGetCharWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "get-char-height", os_wxItemGetCharHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "set-label", os_wxItemSetLabel, 1, 1);
+ scheme_add_method_w_arity(os_wxItem_class, "get-label", os_wxItemGetLabel, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "get-background-colour", os_wxItemGetBackgroundColour, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "get-label-colour", os_wxItemGetLabelColour, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "get-button-colour", os_wxItemGetButtonColour, 0, 0);
+ scheme_add_method_w_arity(os_wxItem_class, "command", os_wxItemCommand, 1, 1);
+
+
+  scheme_made_class(os_wxItem_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxItem, wxTYPE_ITEM);
+
+}
+}
+
+int objscheme_istype_wxItem(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxItem_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:item%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxItem(class wxItem *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_ITEM) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxItem_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxItem *objscheme_unbundle_wxItem(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxItem(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxItem *)o->primdata;
+  else
+    return (wxItem *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+class os_wxMessage : public wxMessage {
+ public:
+
+  os_wxMessage(Scheme_Object * obj, class wxPanel* x0, string x1, int x2 = -1, int x3 = -1, long x4 = 0, string x5 = "message");
+  os_wxMessage(Scheme_Object * obj, class wxPanel* x0, class wxBitmap* x1, int x2 = -1, int x3 = -1, long x4 = 0, string x5 = "message");
+  ~os_wxMessage();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxMessage_class;
+
+os_wxMessage::os_wxMessage(Scheme_Object * o, class wxPanel* x0, string x1, int x2, int x3, long x4, string x5)
+: wxMessage(x0, x1, x2, x3, x4, x5)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMessage::os_wxMessage(Scheme_Object * o, class wxPanel* x0, class wxBitmap* x1, int x2, int x3, long x4, string x5)
+: wxMessage(x0, x1, x2, x3, x4, x5)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMessage::~os_wxMessage()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxMessage::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMessage_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:message%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxMessage::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMessage_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:message%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxMessage::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMessage_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMessage::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMessage::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMessage_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMessage::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMessage::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMessage_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMessage::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessageSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxBitmap(p[0], NULL, 0)) {
+    class wxBitmap* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:message%::set-label (bitmap label case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxBitmap(p[0], "wx:message%::set-label (bitmap label case)", 0);
+
+    if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:button%::set-label");
+    ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  } else  {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:message%::set-label (string label case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:message%::set-label (string label case)");
+
+    
+    ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessagePreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:message%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:message%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMessage *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessagePreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:message%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:message%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMessage *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessageOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:message%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:message%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMessage *)((Scheme_Class_Object *)obj)->primdata)->wxMessage::OnSize(x0, x1);
+  else
+    ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessageOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMessage *)((Scheme_Class_Object *)obj)->primdata)->wxMessage::OnSetFocus();
+  else
+    ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessageOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMessage *)((Scheme_Class_Object *)obj)->primdata)->wxMessage::OnKillFocus();
+  else
+    ((wxMessage *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMessage_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMessage *realobj;
+  if ((n >= 2) && objscheme_istype_wxPanel(p[0], NULL, 0) && objscheme_istype_wxBitmap(p[1], NULL, 0)) {
+    class wxPanel* x0;
+    class wxBitmap* x1;
+    int x2;
+    int x3;
+    long x4;
+    string x5;
+
+    
+    if ((n < 2) ||(n > 6)) 
+      scheme_wrong_count("wx:message%::initialization (bitmap label case)", 2, 6, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:message%::initialization (bitmap label case)", 0);
+    x1 = objscheme_unbundle_wxBitmap(p[1], "wx:message%::initialization (bitmap label case)", 0);
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:message%::initialization (bitmap label case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:message%::initialization (bitmap label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:message%::initialization (bitmap label case)");
+    } else
+      x4 = 0;
+    if (n > 5) {
+      x5 = (string)objscheme_unbundle_string(p[5], "wx:message%::initialization (bitmap label case)");
+    } else
+      x5 = "message";
+
+    if (x1 && !x1->Ok()) scheme_signal_error("%s: bad bitmap", "wx:message::initialization");
+    realobj = new os_wxMessage(obj, x0, x1, x2, x3, x4, x5);
+    
+    
+  } else  {
+    class wxPanel* x0;
+    string x1;
+    int x2;
+    int x3;
+    long x4;
+    string x5;
+
+    
+    if ((n < 2) ||(n > 6)) 
+      scheme_wrong_count("wx:message%::initialization (string label case)", 2, 6, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:message%::initialization (string label case)", 0);
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:message%::initialization (string label case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:message%::initialization (string label case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:message%::initialization (string label case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:message%::initialization (string label case)");
+    } else
+      x4 = 0;
+    if (n > 5) {
+      x5 = (string)objscheme_unbundle_string(p[5], "wx:message%::initialization (string label case)");
+    } else
+      x5 = "message";
+
+    
+    realobj = new os_wxMessage(obj, x0, x1, x2, x3, x4, x5);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMessage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:message%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:message%");
+}
+
+void objscheme_setup_wxMessage(void *env)
+{
+if (os_wxMessage_class) {
+    objscheme_add_global_class(os_wxMessage_class,  "wx:message%", env);
+} else {
+  os_wxMessage_class = objscheme_def_prim_class(env, "wx:message%", "wx:item%", os_wxMessage_ConstructScheme, 7);
+
+  scheme_add_method_w_arity(os_wxMessage_class,"get-class-name",objscheme_classname_os_wxMessage, 0, 0);
+
+ scheme_add_method(os_wxMessage_class, "set-label", os_wxMessageSetLabel);
+ scheme_add_method_w_arity(os_wxMessage_class, "pre-on-event", os_wxMessagePreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxMessage_class, "pre-on-char", os_wxMessagePreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxMessage_class, "on-size", os_wxMessageOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxMessage_class, "on-set-focus", os_wxMessageOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxMessage_class, "on-kill-focus", os_wxMessageOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxMessage_class);
+
+
+}
+}
+
+int objscheme_istype_wxMessage(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMessage_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:message%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMessage(class wxMessage *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMessage_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMessage *objscheme_unbundle_wxMessage(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMessage(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMessage *)o->primdata;
+  else
+    return (wxMessage *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_item.h b/src/mred/wxs/wxs_item.h
new file mode 100644
index 0000000..60d63f5
--- /dev/null
+++ b/src/mred/wxs/wxs_item.h
@@ -0,0 +1,36 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern class wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxItem(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxItem(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxItem(class wxItem *realobj);
+class wxItem *objscheme_unbundle_wxItem(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMessage(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMessage(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMessage(class wxMessage *realobj);
+class wxMessage *objscheme_unbundle_wxMessage(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_item.xc b/src/mred/wxs/wxs_item.xc
new file mode 100644
index 0000000..6d497f7
--- /dev/null
+++ b/src/mred/wxs/wxs_item.xc
@@ -0,0 +1,56 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_item.h"
+#include "wx_messg.h"
+#include "wx_group.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxItem "wx:item":"wx:window"
+
+@CLASSID wxTYPE_ITEM
+
+// @ "centre" : void Centre(int=wxHORIZONTAL);
+@ "command" : void Command(wxCommandEvent%);
+
+@INCLUDE wxs_icol.xci
+
+@ "get-label" : nstring GetLabel();
+@ "set-label" : void SetLabel(string);
+
+@ "get-char-height" : float GetCharHeight();
+@ "get-char-width" : float GetCharWidth();
+
+@ "set-background-colour" : void SetBackgroundColour(wxColour!);
+@ "set-label-colour" : void SetLabelColour(wxColour!);
+@ "set-button-colour" : void SetButtonColour(wxColour!);
+
+@END
+
+
+@CLASSBASE wxMessage "wx:message" : "wx:item"
+
+@CREATOR (wxPanel!,string,int=-1,int=-1,long=0,string="message"); <> string label
+@CREATOR (wxPanel!,wxBitmap!,int=-1,int=-1,long=0,string="message"); : : /CHECKOK[1."wx:message::initialization"] <> bitmap label
+
+@INCLUDE wxs_item.xci
+
+@ "set-label" : void SetLabel(wxBitmap!) : : /CHECKOK[0."wx:button%::set-label"] <> bitmap label
+@ "set-label" : void SetLabel(string); <> string label
+
+@END
+
+#if 0
+
+@CLASSBASE wxGroupBox "wx:group-box":"wx:item"
+
+@CLASSID wxTYPE_GROUP_BOX
+
+@CREATOR (wxPanel!,string,int=-1,int=-1,int=-1,int=-1,long=0,string="groupBox");
+
+@END
+
+#endif
diff --git a/src/mred/wxs/wxs_item.xci b/src/mred/wxs/wxs_item.xci
new file mode 100644
index 0000000..a0e9cd6
--- /dev/null
+++ b/src/mred/wxs/wxs_item.xci
@@ -0,0 +1,3 @@
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
diff --git a/src/mred/wxs/wxs_lbox.cxx b/src/mred/wxs/wxs_lbox.cxx
new file mode 100644
index 0000000..41e062c
--- /dev/null
+++ b/src/mred/wxs/wxs_lbox.cxx
@@ -0,0 +1,1032 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_lbox.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_lbox.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_lbox.h"
+#include "wxscomon.h"
+
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxListBox
+#define CB_REALCLASS wxListBox
+#define CB_UNBUNDLE objscheme_unbundle_wxListBox
+#define CB_USER "wx:list-box%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxListBoxCallbackToScheme
+#define CB_TOC wxListBoxCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE string
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_string
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_string
+#define l_MAKE_LIST __MakestringList
+#define l_MAKE_ARRAY __MakestringArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+// Quasi-booleans; nominally Bool, but really ints
+
+
+
+
+
+
+
+
+
+
+#define RANGECLASS wxListBox
+
+#define THISOBJECT ((RANGECLASS *)((Scheme_Class_Object *)obj)->primdata)
+
+
+
+
+
+Scheme_Object *MakeIntList(int *v, int c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = scheme_make_integer(v[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+
+
+class os_wxListBox : public wxListBox {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxListBox(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, Bool x3 = wxSINGLE, int x4 = -1, int x5 = -1, int x6 = -1, int x7 = -1, int x8 = 0, string* x9 = NULL, long x10 = 0, string x11 = "button");
+  ~os_wxListBox();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxListBox_class;
+
+os_wxListBox::os_wxListBox(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, Bool x3, int x4, int x5, int x6, int x7, int x8, string* x9, long x10, string x11)
+: wxListBox(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxListBox::~os_wxListBox()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxListBox::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxListBox_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:list-box%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxListBox::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxListBox_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:list-box%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxListBox::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxListBox_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxListBox::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxListBox::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxListBox_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxListBox::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxListBox::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxListBox_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxListBox::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::set-string");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:list-box%::set-string");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetString(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::get-string");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_null;
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->GetString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:list-box%::set-string-selection");
+
+  
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetStringSelection(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSetFirstItem(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:list-box%::set-first-item (index case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::set-first-item (index case)");
+
+    if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetFirstItem(x0);
+
+    
+    
+  } else  {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:list-box%::set-first-item (string case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:list-box%::set-first-item (string case)");
+
+    
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetFirstItem(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string* x1;
+
+  
+  x1 = NULL;
+
+  x1 = __MakestringArray((0 < n) ? p[0] : scheme_null, &x0, "wx:list%::set");
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Set(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxGetSelections(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int* _x0;
+  int** x0 = &_x0;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:list-box%::get-selections", "non-null", (0 - 0), n, p);
+  else
+    *x0 = NULL;
+
+  
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->GetSelections(x0);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], MakeIntList(*x0, r));
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxGetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->GetSelection();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxFindString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:list-box%::find-string");
+
+  
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->FindString(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSetClientData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::set-client-data");
+  x1 = ((char *)p[1]);
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetClientData(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxGetClientData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::get-client-data");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_null;
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->GetClientData(x0);
+
+  
+  
+  return ((r) ? ((Scheme_Object *)r) : scheme_null);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxGetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->GetStringSelection();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::selected?");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Selected(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxSetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::set-selection");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:list-box%::set-selection");
+  } else
+    x1 = TRUE;
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->SetSelection(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxDeselect(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::deselect");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Deselect(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::delete");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Delete(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxAppend(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_string(p[0], NULL) && 1) {
+    string x0;
+    string x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:list-box%::append (with data case)", 2, 2, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:list-box%::append (with data case)");
+    x1 = ((char *)p[1]);
+
+    
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Append(x0, x1);
+
+    
+    
+  } else  {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:list-box%::append (without data case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:list-box%::append (without data case)");
+
+    
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->Append(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:list-box%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:list-box%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxListBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:list-box%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:list-box%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxListBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:list-box%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:list-box%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxListBox *)((Scheme_Class_Object *)obj)->primdata)->wxListBox::OnSize(x0, x1);
+  else
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxListBox *)((Scheme_Class_Object *)obj)->primdata)->wxListBox::OnSetFocus();
+  else
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBoxOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxListBox *)((Scheme_Class_Object *)obj)->primdata)->wxListBox::OnKillFocus();
+  else
+    ((wxListBox *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxListBox_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxListBox *realobj;
+  class wxPanel* x0;
+  wxFunction x1;
+  nstring x2;
+  Bool x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  int x8;
+  string* x9;
+  long x10;
+  string x11;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n < 3) ||(n > 11)) 
+    scheme_wrong_count("wx:list-box%::initialization", 3, 11, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:list-box%::initialization", 0);
+  x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:list-box%::initialization");
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], NULL);
+  } else
+    x3 = wxSINGLE;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:list-box%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:list-box%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:list-box%::initialization");
+  } else
+    x6 = -1;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:list-box%::initialization");
+  } else
+    x7 = -1;
+  if (n > 8) {
+    x9 = NULL;
+  } else
+    x9 = NULL;
+  if (n > 9) {
+    x10 = objscheme_unbundle_integer(p[9], "wx:list-box%::initialization");
+  } else
+    x10 = 0;
+  if (n > 10) {
+    x11 = (string)objscheme_unbundle_string(p[10], "wx:list-box%::initialization");
+  } else
+    x11 = "button";
+
+  if (!x6) x6 = -1;if (!x7) x7 = -1;if (((x3 & wxMULTIPLE) && (x3 & wxEXTENDED)) || (x3 & ~((Bool)(wxMULTIPLE | wxEXTENDED | wxALWAYS_SB)))) scheme_signal_error("wx:list-box%%::initialization: bad style specification: %d", x3);x9 = __MakestringArray((8 < n) ? p[8] : scheme_null, &x8, "wx:list-box%::initialization");
+  realobj = new os_wxListBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
+  delete[] x9;
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxListBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:list-box%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:list-box%");
+}
+
+void objscheme_setup_wxListBox(void *env)
+{
+if (os_wxListBox_class) {
+    objscheme_add_global_class(os_wxListBox_class,  "wx:list-box%", env);
+} else {
+  os_wxListBox_class = objscheme_def_prim_class(env, "wx:list-box%", "wx:item%", os_wxListBox_ConstructScheme, 24);
+
+  scheme_add_method_w_arity(os_wxListBox_class,"get-class-name",objscheme_classname_os_wxListBox, 0, 0);
+
+ scheme_add_method_w_arity(os_wxListBox_class, "set-string", os_wxListBoxSetString, 2, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "get-string", os_wxListBoxGetString, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "set-string-selection", os_wxListBoxSetStringSelection, 1, 1);
+ scheme_add_method(os_wxListBox_class, "set-first-item", os_wxListBoxSetFirstItem);
+ scheme_add_method_w_arity(os_wxListBox_class, "set", os_wxListBoxSet, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "get-selections", os_wxListBoxGetSelections, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "number", os_wxListBoxNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxListBox_class, "get-selection", os_wxListBoxGetSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxListBox_class, "find-string", os_wxListBoxFindString, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "set-client-data", os_wxListBoxSetClientData, 2, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "get-client-data", os_wxListBoxGetClientData, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "get-string-selection", os_wxListBoxGetStringSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxListBox_class, "selected?", os_wxListBoxSelected, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "set-selection", os_wxListBoxSetSelection, 1, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "deselect", os_wxListBoxDeselect, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "delete", os_wxListBoxDelete, 1, 1);
+ scheme_add_method_w_arity(os_wxListBox_class, "clear", os_wxListBoxClear, 0, 0);
+ scheme_add_method(os_wxListBox_class, "append", os_wxListBoxAppend);
+ scheme_add_method_w_arity(os_wxListBox_class, "pre-on-event", os_wxListBoxPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "pre-on-char", os_wxListBoxPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "on-size", os_wxListBoxOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxListBox_class, "on-set-focus", os_wxListBoxOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxListBox_class, "on-kill-focus", os_wxListBoxOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxListBox_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxListBox, wxTYPE_LIST_BOX);
+
+}
+}
+
+int objscheme_istype_wxListBox(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxListBox_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:list-box%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxListBox(class wxListBox *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_LIST_BOX) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxListBox_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxListBox *objscheme_unbundle_wxListBox(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxListBox(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxListBox *)o->primdata;
+  else
+    return (wxListBox *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_lbox.h b/src/mred/wxs/wxs_lbox.h
new file mode 100644
index 0000000..6bdf717
--- /dev/null
+++ b/src/mred/wxs/wxs_lbox.h
@@ -0,0 +1,17 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxListBox(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxListBox(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxListBox(class wxListBox *realobj);
+class wxListBox *objscheme_unbundle_wxListBox(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_lbox.xc b/src/mred/wxs/wxs_lbox.xc
new file mode 100644
index 0000000..e29e2b1
--- /dev/null
+++ b/src/mred/wxs/wxs_lbox.xc
@@ -0,0 +1,80 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_lbox.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxListBox "wx:list-box":"wx:item"
+
+@CLASSID wxTYPE_LIST_BOX
+
+@SET CALLBACK_CLASS = wxListBox
+@SET CALLBACK_CLASS_USER = "wx:list-box%::initialization"
+@INCLUDE cb_start.xci
+
+@SET TYPE = string
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@INCLUDE qbool.xci
+
+@MACRO CHECKKIND[n] = if (((x<n> & wxMULTIPLE) && (x<n> & wxEXTENDED)) || (x<n> & ~((Bool)(wxMULTIPLE | wxEXTENDED | wxALWAYS_SB)))) scheme_signal_error("wx:list-box%%::initialization: bad style specification: %d", x<n>);
+
+@MACRO spNum = num
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,Bool=wxSINGLE/bQBool/ubQBool/cQBool//spNum,int=-1,int=-1,int=-1,int=-1,-int=0,string[]=NULL/bList/ubList/cList,long=0,string="button"); : : ubCallbackSetup/NOZERO[6]|NOZERO[7]|CHECKKIND[3]|glueListSet[string.8.9.8."wx:list-box%::initialization"]/glueCleanup[9]/ubCallbackCreatorFinish
+
+@INCLUDE wxs_item.xci
+
+#define RANGECLASS wxListBox
+@INCLUDE range.xci
+
+@MACRO bAnythingFromString = (({x}) ? ((Scheme_Object *){x}) : scheme_null)
+@MACRO ubAnythingToString = ((char *){x})
+@MACRO cAnything = 1
+
+@ "append" : void Append(string); <> without data
+@ "append" : void Append(string, string//ubAnythingToString/cAnything); <> with data
+@ "clear" : void Clear();
+@ "delete" : void Delete(int); : : /RANGE[0]
+@ "deselect" : void Deselect(int); : : /RANGE[0]
+@ "set-selection" : void SetSelection(int,bool=TRUE); : : /RANGE[0]
+@ "selected?" : bool Selected(int); : : /RANGE[0]
+@ "get-string-selection" : string GetStringSelection();
+@ "get-client-data" : string/bAnythingFromString GetClientData(int); : : /RANGERET[0.scheme_null]
+@ "set-client-data" : void SetClientData(int, string//ubAnythingToString/cAnything); : : /RANGE[0]
+@ "find-string" : int FindString(string);
+@ "get-selection" : int GetSelection();
+@ "number" : int Number();
+
+@MACRO ubArrayBox = NULL
+@MACRO cArrayBox = SCHEME_BOXP({x})
+@MACRO boxArrayResult = MakeIntList(*x0, r)
+
+Scheme_Object *MakeIntList(int *v, int c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = scheme_make_integer(v[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+@ "get-selections" : int GetSelections(int**/boxArrayResult/ubArrayBox/cArrayBox);
+
+@ "set" : void Set(-int,string[]/bList/ubList/cList); : : /glueListSet[string.0.1.0."wx:list%::set"]//
+@ "set-first-item" : void SetFirstItem(int); : : /RANGE[0] <> index
+@ "set-first-item" : void SetFirstItem(string); <> string
+@ "set-string-selection" : void SetStringSelection(string);
+@ "get-string" : string GetString(int); : : /RANGERET[0.scheme_null]
+@ "set-string" : void SetString(int,string); : : /RANGE[0]
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_list.cxx b/src/mred/wxs/wxs_list.cxx
new file mode 100644
index 0000000..4fa8f3e
--- /dev/null
+++ b/src/mred/wxs/wxs_list.cxx
@@ -0,0 +1,8 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_list.xc". */
+
+
+#include "wx_list.h"
+#include "wx_hash.h"
+#include "wx_utils.h"
+
diff --git a/src/mred/wxs/wxs_list.h b/src/mred/wxs/wxs_list.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxs_list.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_list.xc b/src/mred/wxs/wxs_list.xc
new file mode 100644
index 0000000..3499d46
--- /dev/null
+++ b/src/mred/wxs/wxs_list.xc
@@ -0,0 +1,128 @@
+
+#include "wx_list.h"
+#include "wx_hash.h"
+#include "wx_utils.h"
+
+#if 0
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if defined(wx_mac)
+#define NODE_FIX os_wxNode() : wxNode(NULL, NULL, NULL, NULL) {}
+#else
+#define NODE_FIX 
+#endif
+
+#if 1
+#define NODE_DATA_GC_IGNORED(r) r->DataGCIgnored()
+#else
+#define NODE_DATA_GC_IGNORED(r) WXGC_IGNORED(r->data)
+#endif
+
+@MACRO ThisNodeDataIgnored = NODE_DATA_GC_IGNORED(((wxNode *)((Scheme_Class_Object *)obj)->primdata));
+
+
+@CLASSBASE wxNode "wx:node":"wx:object"
+
+@VAR NODE_FIX
+
+@ "data" : wxObject! Data();
+@ "next" : wxNode^ Next();
+@ "previous" : wxNode^ Previous();
+@ "set-data" : void SetData(wxObject!); : : ///ThisNodeDataIgnored
+
+@END
+
+#ifdef wx_mac
+#define _KEY_TYPE KeyType
+#else
+#define _KEY_TYPE unsigned
+#endif
+@MACRO bInt = objscheme_bundle_integer((int){x})
+@MACRO ubIntKey = (_KEY_TYPE)objscheme_unbundle_integer({x}, "wxList")
+@MACRO tInt = objscheme_istype_number({x}, NULL)
+
+@MACRO CHECKVALIDKEYTYPE = if ((x0 != wxKEY_NONE) && (x0 != wxKEY_INTEGER) && (x0 != wxKEY_STRING)) scheme_wrong_type("make-wx:list%", "wx:const-key-none, wx:const-key-integer, or wx:const-key-string", 0, 1, p);
+
+@MACRO CHECKVALIDHKEYTYPE = if ((x0 != wxKEY_INTEGER) && (x0 != wxKEY_STRING)) scheme_wrong_type("make-wx:hash-table", "wx:const-key-integer or wx:const-key-string", 0, 2, p);
+
+@MACRO CHECKKEYTYPE[cl.t.k.w.s] = if (((<cl> *)((Scheme_Class_Object *)obj)->primdata)->key_type != <t>) scheme_signal_error("wx:" <k> "%%::" <w> ": list does not have " <s> " keys");
+
+@MACRO NodeDataGCIgnored = NODE_DATA_GC_IGNORED(r);
+
+
+@CLASSBASE wxList "wx:list" : "wx:object"
+
+@CREATOR ()
+@CREATOR (_KEY_TYPE/bInt/ubIntKey/tInt) : : /CHECKVALIDKEYTYPE
+// @CREATOR (int, wxObject*[]);
+
+@ "append" : wxNode! Append(wxObject!); : : CHECKKEYTYPE[wxList.wxKEY_NONE."list"."append"."empty"]///NodeDataGCIgnored
+@ "append" : wxNode! Append(long,wxObject!); : : CHECKKEYTYPE[wxList.wxKEY_INTEGER."list"."append"."integer"]///NodeDataGCIgnored
+@ "append" : wxNode! Append(string,wxObject!); : : CHECKKEYTYPE[wxList.wxKEY_STRING."list"."append"."string"]///NodeDataGCIgnored
+
+@ "clear" : void Clear();
+// UNSAFE -- @ "set-delete-contents" : void DeleteContents(bool);
+@ "delete-node" : bool DeleteNode(wxNode!);
+@ "delete-object" : bool DeleteObject(wxObject!);
+@ "find" : wxNode^ Find(long); : : CHECKKEYTYPE[wxList.wxKEY_INTEGER."list"."find"."integer"]
+@ "find" : wxNode^ Find(string); : : CHECKKEYTYPE[wxList.wxKEY_STRING."list"."find"."string"]
+@ "first" : wxNode^ First();
+@ "insert" : wxNode! Insert(wxNode!, wxObject!); : : CHECKKEYTYPE[wxList.wxKEY_NONE."list"."insert"."empty"]///NodeDataGCIgnored
+@ "insert" : wxNode! Insert(wxObject!); : : CHECKKEYTYPE[wxList.wxKEY_NONE."list"."insert"."empty"]///NodeDataGCIgnored
+@ "last" : wxNode^ Last();
+@ "member" : wxNode^ Member(wxObject!);
+@ "nth" : wxNode^ Nth(int);
+@ "number" : int Number();
+
+@END
+
+
+@CLASSBASE wxHashTable "wx:hash-table" : "wx:list"
+
+@CREATOR (int,int=1000) : : /CHECKVALIDHKEYTYPE|NOZERO[1]
+
+@ "begin-find" : void BeginFind();
+@ "clear" : void Clear();
+@ "delete" : void Delete(long); : : CHECKKEYTYPE[wxHashTable.wxKEY_INTEGER."hash-table"."delete"."integer"]
+@ "delete" : void Delete(string); : : CHECKKEYTYPE[wxHashTable.wxKEY_STRING."hash-table"."delete"."string"]
+@ "get" : wxObject^ Get(long); : : CHECKKEYTYPE[wxHashTable.wxKEY_INTEGER."hash-table"."get"."integer"]
+@ "get" : wxObject^ Get(string); : : CHECKKEYTYPE[wxHashTable.wxKEY_STRING."hash-table"."get"."string"]
+@ "make-key" : long MakeKey(string);
+@ "next" : wxNode^ Next();
+@ "put" : void Put(long, wxObject!); : : CHECKKEYTYPE[wxHashTable.wxKEY_INTEGER."hash-table"."put"."integer"]
+@ "put" : void Put(string, wxObject!); : : CHECKKEYTYPE[wxHashTable.wxKEY_STRING."hash-table"."put"."string"]
+
+@CONSTANT "wx:const-key-integer" : int wxKEY_INTEGER
+@CONSTANT "wx:const-key-string" : int wxKEY_STRING
+
+@END
+
+
+@CLASSBASE wxPathList "wx:path-list" : "wx:list"
+
+@CREATOR ();
+
+@ "add-env-list" : void AddEnvList(string);
+@ "add" : void Add(string)
+@ "find-valid-path" : string FindValidPath(string);
+@ "member?" : bool Member(string);
+
+@END
+
+
+@CLASSBASE wxStringList "wx:string-list" : "wx:list"
+
+@CREATOR ();
+
+@ "add" : void Add(string);
+@ "delete" : void Delete(string);
+@ "sort" : void Sort();
+@ "member?" : bool Member(string);
+
+@END
+
+
+#endif
\ No newline at end of file
diff --git a/src/mred/wxs/wxs_madm.cxx b/src/mred/wxs/wxs_madm.cxx
new file mode 100644
index 0000000..8c1d2a9
--- /dev/null
+++ b/src/mred/wxs/wxs_madm.cxx
@@ -0,0 +1,4313 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_madm.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_media.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_madm.h"
+#include "wxscomon.h"
+
+
+#include "wxs_obj.h"
+
+
+static void *DoCAPOCallback(void *data)
+{
+  jmp_buf savebuf;
+  void *r;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf))
+    r = (void *)scheme_apply((Scheme_Object *)data, 0, NULL);
+  else
+    r = (void *)scheme_false;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return r;
+}
+
+typedef void *(*CAPOFunc)(void*);
+
+
+
+
+
+// @ v "scroll" : void Scroll(int,int,bool);
+// @ v "scroll" : void Scroll(int,int);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxMediaCanvas : public wxMediaCanvas {
+ public:
+
+  os_wxMediaCanvas(Scheme_Object * obj, class wxFrame* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, string x5 = "", long x6 = 0, int x7 = 100, class wxMediaBuffer* x8 = NULL);
+  os_wxMediaCanvas(Scheme_Object * obj, class wxPanel* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, string x5 = "", long x6 = 0, int x7 = 100, class wxMediaBuffer* x8 = NULL);
+  ~os_wxMediaCanvas();
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+  void OnPaint();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxMediaCanvas_class;
+
+os_wxMediaCanvas::os_wxMediaCanvas(Scheme_Object * o, class wxFrame* x0, int x1, int x2, int x3, int x4, string x5, long x6, int x7, class wxMediaBuffer* x8)
+: wxMediaCanvas(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaCanvas::os_wxMediaCanvas(Scheme_Object * o, class wxPanel* x0, int x1, int x2, int x3, int x4, string x5, long x6, int x7, class wxMediaBuffer* x8)
+: wxMediaCanvas(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaCanvas::~os_wxMediaCanvas()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMediaCanvas::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaCanvas::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaCanvas::OnPaint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnPaint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaCanvas::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-canvas%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxMediaCanvas::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-canvas%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxMediaCanvas::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaCanvas::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaCanvas::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaCanvas_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaCanvas::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-canvas%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnChar(*x0);
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-canvas%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnEvent(*x0);
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnPaint();
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnPaint();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:media-canvas%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:media-canvas%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:media-canvas%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:media-canvas%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-canvas%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-canvas%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnSize(x0, x1);
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnSetFocus();
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->wxMediaCanvas::OnKillFocus();
+  else
+    ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasCallAsPrimaryOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  void* r;
+  objscheme_check_valid(obj);
+  CAPOFunc x0;
+  void* x1;
+
+  
+  x0 = DoCAPOCallback;
+  x1 = p[0];
+
+  
+  r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->CallAsPrimaryOwner(x0, x1);
+
+  
+  
+  return (Scheme_Object*)r;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasSetLazyRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-canvas%::set-lazy-refresh");
+
+  
+  ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetLazyRefresh(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasGetLazyRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetLazyRefresh();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasScrollWithBottomBase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-canvas%::scroll-with-bottom-base");
+
+  
+  ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->ScrollWithBottomBase(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasAllowScrollToLast(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-canvas%::allow-scroll-to-last");
+
+  
+  ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->AllowScrollToLast(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasForceDisplayFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-canvas%::force-display-focus");
+
+  
+  ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->ForceDisplayFocus(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasIsFocusOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->IsFocusOn();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasGetMedia(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaBuffer* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->GetMedia();
+
+  
+  
+  return objscheme_bundle_wxMediaBuffer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvasSetMedia(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaBuffer* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaBuffer(p[0], "wx:media-canvas%::set-media", 1);
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-canvas%::set-media");
+  } else
+    x1 = TRUE;
+
+  
+  ((wxMediaCanvas *)((Scheme_Class_Object *)obj)->primdata)->SetMedia(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaCanvas_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaCanvas *realobj;
+  if ((n >= 1) && objscheme_istype_wxPanel(p[0], NULL, 0)) {
+    class wxPanel* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    string x5;
+    long x6;
+    int x7;
+    class wxMediaBuffer* x8;
+
+    
+    if ((n < 1) ||(n > 9)) 
+      scheme_wrong_count("wx:media-canvas%::initialization (panel case)", 1, 9, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:media-canvas%::initialization (panel case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = (string)objscheme_unbundle_string(p[5], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x5 = "";
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x6 = 0;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:media-canvas%::initialization (panel case)");
+    } else
+      x7 = 100;
+    if (n > 8) {
+      x8 = objscheme_unbundle_wxMediaBuffer(p[8], "wx:media-canvas%::initialization (panel case)", 1);
+    } else
+      x8 = NULL;
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxMediaCanvas(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    
+  } else  {
+    class wxFrame* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    string x5;
+    long x6;
+    int x7;
+    class wxMediaBuffer* x8;
+
+    
+    if ((n < 1) ||(n > 9)) 
+      scheme_wrong_count("wx:media-canvas%::initialization (frame case)", 1, 9, n, p);
+    x0 = objscheme_unbundle_wxFrame(p[0], "wx:media-canvas%::initialization (frame case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = (string)objscheme_unbundle_string(p[5], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x5 = "";
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x6 = 0;
+    if (n > 7) {
+      x7 = objscheme_unbundle_integer(p[7], "wx:media-canvas%::initialization (frame case)");
+    } else
+      x7 = 100;
+    if (n > 8) {
+      x8 = objscheme_unbundle_wxMediaBuffer(p[8], "wx:media-canvas%::initialization (frame case)", 1);
+    } else
+      x8 = NULL;
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxMediaCanvas(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaCanvas(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-canvas%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-canvas%");
+}
+
+void objscheme_setup_wxMediaCanvas(void *env)
+{
+if (os_wxMediaCanvas_class) {
+    objscheme_add_global_class(os_wxMediaCanvas_class,  "wx:media-canvas%", env);
+} else {
+  os_wxMediaCanvas_class = objscheme_def_prim_class(env, "wx:media-canvas%", "wx:canvas%", os_wxMediaCanvas_ConstructScheme, 18);
+
+  scheme_add_method_w_arity(os_wxMediaCanvas_class,"get-class-name",objscheme_classname_os_wxMediaCanvas, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-char", os_wxMediaCanvasOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-event", os_wxMediaCanvasOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-paint", os_wxMediaCanvasOnPaint, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "pre-on-event", os_wxMediaCanvasPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "pre-on-char", os_wxMediaCanvasPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-size", os_wxMediaCanvasOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-set-focus", os_wxMediaCanvasOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "on-kill-focus", os_wxMediaCanvasOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "call-as-primary-owner", os_wxMediaCanvasCallAsPrimaryOwner, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "set-lazy-refresh", os_wxMediaCanvasSetLazyRefresh, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "get-lazy-refresh", os_wxMediaCanvasGetLazyRefresh, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "scroll-with-bottom-base", os_wxMediaCanvasScrollWithBottomBase, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "allow-scroll-to-last", os_wxMediaCanvasAllowScrollToLast, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "force-display-focus", os_wxMediaCanvasForceDisplayFocus, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "is-focus-on?", os_wxMediaCanvasIsFocusOn, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "get-media", os_wxMediaCanvasGetMedia, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaCanvas_class, "set-media", os_wxMediaCanvasSetMedia, 1, 2);
+
+
+  scheme_made_class(os_wxMediaCanvas_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaCanvas, wxTYPE_MEDIA_CANVAS);
+
+}
+  scheme_install_xc_global("wx:const-mcanvas-no-h-scroll", scheme_make_integer(wxMCANVAS_NO_H_SCROLL), env);
+  scheme_install_xc_global("wx:const-mcanvas-no-v-scroll", scheme_make_integer(wxMCANVAS_NO_V_SCROLL), env);
+  scheme_install_xc_global("wx:const-mcanvas-hide-h-scroll", scheme_make_integer(wxMCANVAS_HIDE_H_SCROLL), env);
+  scheme_install_xc_global("wx:const-mcanvas-hide-v-scroll", scheme_make_integer(wxMCANVAS_HIDE_V_SCROLL), env);
+}
+
+int objscheme_istype_wxMediaCanvas(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaCanvas_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-canvas%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaCanvas(class wxMediaCanvas *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_CANVAS) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaCanvas_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaCanvas *objscheme_unbundle_wxMediaCanvas(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaCanvas(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaCanvas *)o->primdata;
+  else
+    return (wxMediaCanvas *)o->primdata;
+}
+
+
+
+
+
+
+
+
+class os_wxMediaAdmin : public wxMediaAdmin {
+ public:
+
+  os_wxMediaAdmin(Scheme_Object * obj);
+  ~os_wxMediaAdmin();
+  Bool DelayRefresh();
+  void UpdateCursor();
+  void NeedsUpdate(float x0, float x1, float x2, float x3);
+  void Resized(Bool x0);
+  void GrabCaret(int x0 = wxFOCUS_GLOBAL);
+  Bool ScrollTo(float x0, float x1, float x2, float x3, Bool x4 = TRUE, int x5 = 0);
+  void GetMaxView(float* x0, float* x1, float* x2, float* x3, Bool x4 = FALSE);
+  void GetView(float* x0, float* x1, float* x2, float* x3, Bool x4 = FALSE);
+  class wxDC* GetDC(float* x0 = NULL, float* x1 = NULL);
+};
+
+Scheme_Object *os_wxMediaAdmin_class;
+
+os_wxMediaAdmin::os_wxMediaAdmin(Scheme_Object * o)
+: wxMediaAdmin()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaAdmin::~os_wxMediaAdmin()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxMediaAdmin::DelayRefresh()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "refresh-delayed?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-admin%::refresh-delayed?"", extracting return value");
+  }
+}
+
+void os_wxMediaAdmin::UpdateCursor()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "update-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaAdmin::NeedsUpdate(float x0, float x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "needs-update", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaAdmin::Resized(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "resized", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaAdmin::GrabCaret(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "grab-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaAdmin::ScrollTo(float x0, float x1, float x2, float x3, Bool x4, int x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "scroll-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  p[5] = scheme_make_integer(x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-admin%::scroll-to"", extracting return value");
+  }
+}
+
+void os_wxMediaAdmin::GetMaxView(float* x0, float* x1, float* x2, float* x3, Bool x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "get-max-view", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  p[2] = ((x2) ? objscheme_box(scheme_make_double((*x2))) : scheme_null);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-max-view"", extracting return value via box"), "wx:media-admin%::get-max-view"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-max-view"", extracting return value via box"), "wx:media-admin%::get-max-view"", extracting return value via box");
+  if (x2) *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-admin%::get-max-view"", extracting return value via box"), "wx:media-admin%::get-max-view"", extracting return value via box");
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-admin%::get-max-view"", extracting return value via box"), "wx:media-admin%::get-max-view"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaAdmin::GetView(float* x0, float* x1, float* x2, float* x3, Bool x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "get-view", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  p[2] = ((x2) ? objscheme_box(scheme_make_double((*x2))) : scheme_null);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-view"", extracting return value via box"), "wx:media-admin%::get-view"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-view"", extracting return value via box"), "wx:media-admin%::get-view"", extracting return value via box");
+  if (x2) *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-admin%::get-view"", extracting return value via box"), "wx:media-admin%::get-view"", extracting return value via box");
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-admin%::get-view"", extracting return value via box"), "wx:media-admin%::get-view"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxDC* os_wxMediaAdmin::GetDC(float* x0, float* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaAdmin_class, "get-dc", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-dc"", extracting return value via box"), "wx:media-admin%::get-dc"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-dc"", extracting return value via box"), "wx:media-admin%::get-dc"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxDC(v, "wx:media-admin%::get-dc"", extracting return value", 1);
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminDelayRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->DelayRefresh();
+  else
+    r = ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->DelayRefresh();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminUpdateCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->UpdateCursor();
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->UpdateCursor();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminNeedsUpdate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-admin%::needs-update");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-admin%::needs-update");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-admin%::needs-update");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-admin%::needs-update");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3);
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminResized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-admin%::resized");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0);
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminGrabCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-admin%::grab-caret");
+  } else
+    x0 = wxFOCUS_GLOBAL;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GrabCaret(x0);
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GrabCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminScrollTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  Bool x4;
+  int x5;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-admin%::scroll-to");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-admin%::scroll-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-admin%::scroll-to");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-admin%::scroll-to");
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-admin%::scroll-to");
+  } else
+    x4 = TRUE;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:media-admin%::scroll-to");
+  } else
+    x5 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+  else
+    r = ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminGetMaxView(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+  Bool x4;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-max-view"), "wx:media-admin%::get-max-view");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-max-view"), "wx:media-admin%::get-max-view");
+  if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-admin%::get-max-view"), "wx:media-admin%::get-max-view");
+  if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-admin%::get-max-view"), "wx:media-admin%::get-max-view");
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-admin%::get-max-view");
+  } else
+    x4 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetMaxView(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetMaxView(x0, x1, x2, x3, x4);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminGetView(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+  Bool x4;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-view"), "wx:media-admin%::get-view");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-view"), "wx:media-admin%::get-view");
+  if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-admin%::get-view"), "wx:media-admin%::get-view");
+  if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-admin%::get-view"), "wx:media-admin%::get-view");
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-admin%::get-view");
+  } else
+    x4 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetView(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetView(x0, x1, x2, x3, x4);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdminGetDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxDC* r;
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (n > 0) {
+    if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-admin%::get-dc"), "wx:media-admin%::get-dc");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-admin%::get-dc"), "wx:media-admin%::get-dc");
+  } else
+    x1 = NULL;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetDC(x0, x1);
+  else
+    r = ((wxMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetDC(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return objscheme_bundle_wxDC(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaAdmin_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaAdmin *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-admin%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaAdmin(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-admin%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-admin%");
+}
+
+void objscheme_setup_wxMediaAdmin(void *env)
+{
+if (os_wxMediaAdmin_class) {
+    objscheme_add_global_class(os_wxMediaAdmin_class,  "wx:media-admin%", env);
+} else {
+  os_wxMediaAdmin_class = objscheme_def_prim_class(env, "wx:media-admin%", "wx:object%", os_wxMediaAdmin_ConstructScheme, 10);
+
+  scheme_add_method_w_arity(os_wxMediaAdmin_class,"get-class-name",objscheme_classname_os_wxMediaAdmin, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "refresh-delayed?", os_wxMediaAdminDelayRefresh, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "update-cursor", os_wxMediaAdminUpdateCursor, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "needs-update", os_wxMediaAdminNeedsUpdate, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "resized", os_wxMediaAdminResized, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "grab-caret", os_wxMediaAdminGrabCaret, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "scroll-to", os_wxMediaAdminScrollTo, 4, 6);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "get-max-view", os_wxMediaAdminGetMaxView, 4, 5);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "get-view", os_wxMediaAdminGetView, 4, 5);
+ scheme_add_method_w_arity(os_wxMediaAdmin_class, "get-dc", os_wxMediaAdminGetDC, 0, 2);
+
+
+  scheme_made_class(os_wxMediaAdmin_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaAdmin, wxTYPE_MEDIA_ADMIN);
+
+}
+}
+
+int objscheme_istype_wxMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaAdmin_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-admin%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaAdmin(class wxMediaAdmin *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_ADMIN) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaAdmin_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaAdmin *objscheme_unbundle_wxMediaAdmin(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaAdmin(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaAdmin *)o->primdata;
+  else
+    return (wxMediaAdmin *)o->primdata;
+}
+
+
+#define FIXCMA os_wxCanvasMediaAdmin() : wxCanvasMediaAdmin(NULL) {}
+
+
+
+
+// Virtual, but not really overrideable since the class isn't instantiable
+// @SETMARK A = d
+// @INCLUDE wxs_madm.xci
+
+
+class os_wxCanvasMediaAdmin : public wxCanvasMediaAdmin {
+ public:
+  FIXCMA
+
+  ~os_wxCanvasMediaAdmin();
+};
+
+Scheme_Object *os_wxCanvasMediaAdmin_class;
+
+os_wxCanvasMediaAdmin::~os_wxCanvasMediaAdmin()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxCanvasMediaAdminGetCanvas(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaCanvas* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxCanvasMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetCanvas();
+
+  
+  
+  return objscheme_bundle_wxMediaCanvas(r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxCanvasMediaAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:canvas-media-admin%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:canvas-media-admin%");
+}
+
+void objscheme_setup_wxCanvasMediaAdmin(void *env)
+{
+if (os_wxCanvasMediaAdmin_class) {
+    objscheme_add_global_class(os_wxCanvasMediaAdmin_class,  "wx:canvas-media-admin%", env);
+} else {
+  os_wxCanvasMediaAdmin_class = objscheme_def_prim_class(env, "wx:canvas-media-admin%", "wx:media-admin%", NULL, 2);
+
+  scheme_add_method_w_arity(os_wxCanvasMediaAdmin_class,"get-class-name",objscheme_classname_os_wxCanvasMediaAdmin, 0, 0);
+
+ scheme_add_method_w_arity(os_wxCanvasMediaAdmin_class, "get-canvas", os_wxCanvasMediaAdminGetCanvas, 0, 0);
+
+
+  scheme_made_class(os_wxCanvasMediaAdmin_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxCanvasMediaAdmin, wxTYPE_CANVAS_MEDIA_ADMIN);
+
+}
+}
+
+int objscheme_istype_wxCanvasMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxCanvasMediaAdmin_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:canvas-media-admin%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxCanvasMediaAdmin(class wxCanvasMediaAdmin *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_CANVAS_MEDIA_ADMIN) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxCanvasMediaAdmin_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxCanvasMediaAdmin *objscheme_unbundle_wxCanvasMediaAdmin(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxCanvasMediaAdmin(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxCanvasMediaAdmin *)o->primdata;
+  else
+    return (wxCanvasMediaAdmin *)o->primdata;
+}
+
+
+#define FIXMSMA os_wxMediaSnipMediaAdmin() : wxMediaSnipMediaAdmin(NULL) {}
+
+
+
+
+// Virtual, but not really overrideable since the class isn't instantiable
+// @SETMARK A = d
+// @INCLUDE wxs_madm.xci
+
+
+class os_wxMediaSnipMediaAdmin : public wxMediaSnipMediaAdmin {
+ public:
+  FIXMSMA
+
+  ~os_wxMediaSnipMediaAdmin();
+};
+
+Scheme_Object *os_wxMediaSnipMediaAdmin_class;
+
+os_wxMediaSnipMediaAdmin::~os_wxMediaSnipMediaAdmin()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipMediaAdminGetSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnipMediaAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetSnip();
+
+  
+  
+  return objscheme_bundle_wxMediaSnip(r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaSnipMediaAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-snip-media-admin%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-snip-media-admin%");
+}
+
+void objscheme_setup_wxMediaSnipMediaAdmin(void *env)
+{
+if (os_wxMediaSnipMediaAdmin_class) {
+    objscheme_add_global_class(os_wxMediaSnipMediaAdmin_class,  "wx:media-snip-media-admin%", env);
+} else {
+  os_wxMediaSnipMediaAdmin_class = objscheme_def_prim_class(env, "wx:media-snip-media-admin%", "wx:media-admin%", NULL, 2);
+
+  scheme_add_method_w_arity(os_wxMediaSnipMediaAdmin_class,"get-class-name",objscheme_classname_os_wxMediaSnipMediaAdmin, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaSnipMediaAdmin_class, "get-snip", os_wxMediaSnipMediaAdminGetSnip, 0, 0);
+
+
+  scheme_made_class(os_wxMediaSnipMediaAdmin_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaSnipMediaAdmin, wxTYPE_MEDIA_SNIP_MEDIA_ADMIN);
+
+}
+}
+
+int objscheme_istype_wxMediaSnipMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaSnipMediaAdmin_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-snip-media-admin%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaSnipMediaAdmin(class wxMediaSnipMediaAdmin *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_SNIP_MEDIA_ADMIN) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaSnipMediaAdmin_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaSnipMediaAdmin *objscheme_unbundle_wxMediaSnipMediaAdmin(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaSnipMediaAdmin(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaSnipMediaAdmin *)o->primdata;
+  else
+    return (wxMediaSnipMediaAdmin *)o->primdata;
+}
+
+
+
+
+
+
+
+class os_wxSnipAdmin : public wxSnipAdmin {
+ public:
+
+  os_wxSnipAdmin(Scheme_Object * obj);
+  ~os_wxSnipAdmin();
+  void UpdateCursor();
+  Bool ReleaseSnip(class wxSnip* x0);
+  void NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4);
+  Bool Recounted(class wxSnip* x0, Bool x1);
+  void Resized(class wxSnip* x0, Bool x1);
+  void SetCaretOwner(class wxSnip* x0, int x1 = wxFOCUS_IMMEDIATE);
+  Bool ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5, int x6 = 0);
+  void GetView(float* x0, float* x1, float* x2, float* x3, class wxSnip* x4 = NULL);
+  void GetViewSize(float* x0, float* x1);
+  class wxDC* GetDC();
+  class wxMediaBuffer* GetMedia();
+};
+
+Scheme_Object *os_wxSnipAdmin_class;
+
+os_wxSnipAdmin::os_wxSnipAdmin(Scheme_Object * o)
+: wxSnipAdmin()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxSnipAdmin::~os_wxSnipAdmin()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxSnipAdmin::UpdateCursor()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "update-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnipAdmin::ReleaseSnip(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "release-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip-admin%::release-snip"", extracting return value");
+  }
+}
+
+void os_wxSnipAdmin::NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "needs-update", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnipAdmin::Recounted(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "recounted", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip-admin%::recounted"", extracting return value");
+  }
+}
+
+void os_wxSnipAdmin::Resized(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "resized", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnipAdmin::SetCaretOwner(class wxSnip* x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "set-caret-owner", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnipAdmin::ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5, int x6)
+{
+  Scheme_Object *p[7];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "scroll-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = (x5 ? scheme_true : scheme_false);
+  p[6] = scheme_make_integer(x6);
+  
+
+  v = scheme_apply(method, 7, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip-admin%::scroll-to"", extracting return value");
+  }
+}
+
+void os_wxSnipAdmin::GetView(float* x0, float* x1, float* x2, float* x3, class wxSnip* x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "get-view", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  p[2] = ((x2) ? objscheme_box(scheme_make_double((*x2))) : scheme_null);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = objscheme_bundle_wxSnip(x4);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:snip-admin%::get-view"", extracting return value via box"), "wx:snip-admin%::get-view"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:snip-admin%::get-view"", extracting return value via box"), "wx:snip-admin%::get-view"", extracting return value via box");
+  if (x2) *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:snip-admin%::get-view"", extracting return value via box"), "wx:snip-admin%::get-view"", extracting return value via box");
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:snip-admin%::get-view"", extracting return value via box"), "wx:snip-admin%::get-view"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnipAdmin::GetViewSize(float* x0, float* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "get-view-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:snip-admin%::get-view-size"", extracting return value via box"), "wx:snip-admin%::get-view-size"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:snip-admin%::get-view-size"", extracting return value via box"), "wx:snip-admin%::get-view-size"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxDC* os_wxSnipAdmin::GetDC()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "get-dc", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxDC(v, "wx:snip-admin%::get-dc"", extracting return value", 0);
+  }
+}
+
+class wxMediaBuffer* os_wxSnipAdmin::GetMedia()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipAdmin_class, "get-media", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxMediaBuffer(v, "wx:snip-admin%::get-media"", extracting return value", 1);
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminUpdateCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->UpdateCursor();
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->UpdateCursor();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminReleaseSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::release-snip", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+  else
+    r = ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminNeedsUpdate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::needs-update", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip-admin%::needs-update");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip-admin%::needs-update");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip-admin%::needs-update");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip-admin%::needs-update");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminRecounted(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::recounted", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:snip-admin%::recounted");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->Recounted(x0, x1);
+  else
+    r = ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->Recounted(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminResized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::resized", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:snip-admin%::resized");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminSetCaretOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::set-caret-owner", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:snip-admin%::set-caret-owner");
+  } else
+    x1 = wxFOCUS_IMMEDIATE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminScrollTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  Bool x5;
+  int x6;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip-admin%::scroll-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip-admin%::scroll-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip-admin%::scroll-to");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip-admin%::scroll-to");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip-admin%::scroll-to");
+  x5 = objscheme_unbundle_bool(p[5], "wx:snip-admin%::scroll-to");
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:snip-admin%::scroll-to");
+  } else
+    x6 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5, x6);
+  else
+    r = ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5, x6);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminGetView(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+  class wxSnip* x4;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:snip-admin%::get-view"), "wx:snip-admin%::get-view");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:snip-admin%::get-view"), "wx:snip-admin%::get-view");
+  if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:snip-admin%::get-view"), "wx:snip-admin%::get-view");
+  if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:snip-admin%::get-view"), "wx:snip-admin%::get-view");
+  if (n > 4) {
+    x4 = objscheme_unbundle_wxSnip(p[4], "wx:snip-admin%::get-view", 1);
+  } else
+    x4 = NULL;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetView(x0, x1, x2, x3, x4);
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetView(x0, x1, x2, x3, x4);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminGetViewSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:snip-admin%::get-view-size"), "wx:snip-admin%::get-view-size");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:snip-admin%::get-view-size"), "wx:snip-admin%::get-view-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetViewSize(x0, x1);
+  else
+    ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetViewSize(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminGetDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxDC* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetDC();
+  else
+    r = ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetDC();
+
+  
+  
+  return objscheme_bundle_wxDC(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdminGetMedia(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaBuffer* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetMedia();
+  else
+    r = ((wxSnipAdmin *)((Scheme_Class_Object *)obj)->primdata)->GetMedia();
+
+  
+  
+  return objscheme_bundle_wxMediaBuffer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdmin_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxSnipAdmin *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:snip-admin%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxSnipAdmin(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxSnipAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:snip-admin%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:snip-admin%");
+}
+
+void objscheme_setup_wxSnipAdmin(void *env)
+{
+if (os_wxSnipAdmin_class) {
+    objscheme_add_global_class(os_wxSnipAdmin_class,  "wx:snip-admin%", env);
+} else {
+  os_wxSnipAdmin_class = objscheme_def_prim_class(env, "wx:snip-admin%", "wx:object%", os_wxSnipAdmin_ConstructScheme, 12);
+
+  scheme_add_method_w_arity(os_wxSnipAdmin_class,"get-class-name",objscheme_classname_os_wxSnipAdmin, 0, 0);
+
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "update-cursor", os_wxSnipAdminUpdateCursor, 0, 0);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "release-snip", os_wxSnipAdminReleaseSnip, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "needs-update", os_wxSnipAdminNeedsUpdate, 5, 5);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "recounted", os_wxSnipAdminRecounted, 2, 2);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "resized", os_wxSnipAdminResized, 2, 2);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "set-caret-owner", os_wxSnipAdminSetCaretOwner, 1, 2);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "scroll-to", os_wxSnipAdminScrollTo, 6, 7);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "get-view", os_wxSnipAdminGetView, 4, 5);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "get-view-size", os_wxSnipAdminGetViewSize, 2, 2);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "get-dc", os_wxSnipAdminGetDC, 0, 0);
+ scheme_add_method_w_arity(os_wxSnipAdmin_class, "get-media", os_wxSnipAdminGetMedia, 0, 0);
+
+
+  scheme_made_class(os_wxSnipAdmin_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxSnipAdmin, wxTYPE_MEDIA_SNIP_ADMIN);
+
+}
+}
+
+int objscheme_istype_wxSnipAdmin(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxSnipAdmin_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:snip-admin%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_SNIP_ADMIN) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxSnipAdmin_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxSnipAdmin(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxSnipAdmin *)o->primdata;
+  else
+    return (wxSnipAdmin *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+class os_wxSnipClass : public wxSnipClass {
+ public:
+
+  os_wxSnipClass(Scheme_Object * obj);
+  ~os_wxSnipClass();
+  void WriteDone();
+  Bool WriteHeader(class wxMediaStreamOut& x0);
+  void ReadDone();
+  Bool ReadHeader(class wxMediaStreamIn& x0);
+  class wxSnip* Read(class wxMediaStreamIn& x0);
+};
+
+Scheme_Object *os_wxSnipClass_class;
+
+os_wxSnipClass::os_wxSnipClass(Scheme_Object * o)
+: wxSnipClass()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxSnipClass::~os_wxSnipClass()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxSnipClass::WriteDone()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipClass_class, "write-done", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnipClass::WriteDone();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnipClass::WriteHeader(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipClass_class, "write-header", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnipClass::WriteHeader(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip-class%::write-header"", extracting return value");
+  }
+}
+
+void os_wxSnipClass::ReadDone()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipClass_class, "read-done", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnipClass::ReadDone();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnipClass::ReadHeader(class wxMediaStreamIn& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipClass_class, "read-header", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnipClass::ReadHeader(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip-class%::read-header"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxSnipClass::Read(class wxMediaStreamIn& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnipClass_class, "read", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:snip-class%::read"", extracting return value", 1);
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassWriteDone(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->wxSnipClass::WriteDone();
+  else
+    ((wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->WriteDone();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassWriteHeader(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:snip-class%::write-header", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->wxSnipClass::WriteHeader(*x0);
+  else
+    r = ((wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->WriteHeader(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassReadDone(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->wxSnipClass::ReadDone();
+  else
+    ((wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->ReadDone();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassReadHeader(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:snip-class%::read-header", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->wxSnipClass::ReadHeader(*x0);
+  else
+    r = ((wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->ReadHeader(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassRead(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:snip-class%::read", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->Read(*x0);
+  else
+    r = ((wxSnipClass *)((Scheme_Class_Object *)obj)->primdata)->Read(*x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+static Scheme_Object *objscheme_wxSnipClass_Getclassname(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  string v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-classname", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnipClass *)cobj->primdata)->wxSnipClass::classname;
+  else
+    v = ((wxSnipClass *)cobj->primdata)->classname;
+
+  return objscheme_bundle_string((char *)v);
+}
+
+static Scheme_Object *objscheme_wxSnipClass_Setclassname(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  string v;
+
+  if (n != 1) scheme_wrong_count("set-classname", 1, 1, n, p);
+
+  v = (string)objscheme_unbundle_string(p[0], "wx:snip-class%::classname");
+  ((wxSnipClass *)cobj->primdata)->classname = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxSnipClass_Getversion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-version", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnipClass *)cobj->primdata)->wxSnipClass::version;
+  else
+    v = ((wxSnipClass *)cobj->primdata)->version;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxSnipClass_Setversion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-version", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:snip-class%::version");
+  ((wxSnipClass *)cobj->primdata)->version = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClass_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxSnipClass *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:snip-class%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxSnipClass(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxSnipClass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:snip-class%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:snip-class%");
+}
+
+void objscheme_setup_wxSnipClass(void *env)
+{
+if (os_wxSnipClass_class) {
+    objscheme_add_global_class(os_wxSnipClass_class,  "wx:snip-class%", env);
+} else {
+  os_wxSnipClass_class = objscheme_def_prim_class(env, "wx:snip-class%", "wx:object%", os_wxSnipClass_ConstructScheme, 10);
+
+  scheme_add_method_w_arity(os_wxSnipClass_class,"get-class-name",objscheme_classname_os_wxSnipClass, 0, 0);
+
+ scheme_add_method_w_arity(os_wxSnipClass_class, "write-done", os_wxSnipClassWriteDone, 0, 0);
+ scheme_add_method_w_arity(os_wxSnipClass_class, "write-header", os_wxSnipClassWriteHeader, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClass_class, "read-done", os_wxSnipClassReadDone, 0, 0);
+ scheme_add_method_w_arity(os_wxSnipClass_class, "read-header", os_wxSnipClassReadHeader, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClass_class, "read", os_wxSnipClassRead, 1, 1);
+
+  scheme_add_method_w_arity(os_wxSnipClass_class,"get-classname", objscheme_wxSnipClass_Getclassname, 0, 0);
+  scheme_add_method_w_arity(os_wxSnipClass_class,"set-classname", objscheme_wxSnipClass_Setclassname, 1, 1);
+  scheme_add_method_w_arity(os_wxSnipClass_class,"get-version", objscheme_wxSnipClass_Getversion, 0, 0);
+  scheme_add_method_w_arity(os_wxSnipClass_class,"set-version", objscheme_wxSnipClass_Setversion, 1, 1);
+
+  scheme_made_class(os_wxSnipClass_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxSnipClass, wxTYPE_SNIP_CLASS);
+
+}
+}
+
+int objscheme_istype_wxSnipClass(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxSnipClass_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:snip-class%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxSnipClass(class wxSnipClass *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_SNIP_CLASS) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxSnipClass_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxSnipClass(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxSnipClass *)o->primdata;
+  else
+    return (wxSnipClass *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxSnipClassList : public wxSnipClassList {
+ public:
+
+  ~os_wxSnipClassList();
+};
+
+Scheme_Object *os_wxSnipClassList_class;
+
+os_wxSnipClassList::~os_wxSnipClassList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListReadingVersion(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  class wxSnipClass* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipClass(p[0], "wx:snip-class-list%::reading-version", 0);
+
+  
+  r = ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->ReadingVersion(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListNth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnipClass* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip-class-list%::nth");
+
+  
+  r = ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->Nth(x0);
+
+  
+  
+  return objscheme_bundle_wxSnipClass(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipClass* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipClass(p[0], "wx:snip-class-list%::add", 0);
+
+  
+  ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->Add(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListFindPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  short r;
+  objscheme_check_valid(obj);
+  class wxSnipClass* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipClass(p[0], "wx:snip-class-list%::find-position", 0);
+
+  
+  r = ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->FindPosition(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipClassListFind(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnipClass* r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:snip-class-list%::find");
+
+  
+  r = ((wxSnipClassList *)((Scheme_Class_Object *)obj)->primdata)->Find(x0);
+
+  
+  
+  return objscheme_bundle_wxSnipClass(r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxSnipClassList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:snip-class-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:snip-class-list%");
+}
+
+void objscheme_setup_wxSnipClassList(void *env)
+{
+if (os_wxSnipClassList_class) {
+    objscheme_add_global_class(os_wxSnipClassList_class,  "wx:snip-class-list%", env);
+} else {
+  os_wxSnipClassList_class = objscheme_def_prim_class(env, "wx:snip-class-list%", "wx:object%", NULL, 7);
+
+  scheme_add_method_w_arity(os_wxSnipClassList_class,"get-class-name",objscheme_classname_os_wxSnipClassList, 0, 0);
+
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "reading-version", os_wxSnipClassListReadingVersion, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "nth", os_wxSnipClassListNth, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "number", os_wxSnipClassListNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "add", os_wxSnipClassListAdd, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "find-position", os_wxSnipClassListFindPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxSnipClassList_class, "find", os_wxSnipClassListFind, 1, 1);
+
+
+  scheme_made_class(os_wxSnipClassList_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxSnipClassList, wxTYPE_SNIP_CLASS_LIST);
+
+}
+}
+
+int objscheme_istype_wxSnipClassList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxSnipClassList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:snip-class-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxSnipClassList(class wxSnipClassList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_SNIP_CLASS_LIST) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxSnipClassList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxSnipClassList *objscheme_unbundle_wxSnipClassList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxSnipClassList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxSnipClassList *)o->primdata;
+  else
+    return (wxSnipClassList *)o->primdata;
+}
+
+
+
+
+typedef Scheme_Object KeymapCallbackToSchemeRec;
+#define kctsr(o) o
+
+static int KeyCallbackToScheme(wxObject *, wxKeyEvent &, KeymapCallbackToSchemeRec *data);
+static int MouseCallbackToScheme(wxObject *, wxMouseEvent &, KeymapCallbackToSchemeRec *data);
+static int GrabKeyCallbackToScheme(char *s, wxKeymap *km, wxObject *, wxKeyEvent &, KeymapCallbackToSchemeRec *data);
+static int GrabMouseCallbackToScheme(char *s, wxKeymap *km, wxObject *, wxMouseEvent &, KeymapCallbackToSchemeRec *data);
+static void ErrorCallbackToScheme(KeymapCallbackToSchemeRec *data, char *str);
+static void BreakSequenceCallbackToScheme(KeymapCallbackToSchemeRec *data);
+
+
+
+
+
+
+
+
+
+// @ "chain-handle-key-event" : int ChainHandleKeyEvent(wxObject!,wxKeyEvent%);
+// @ "chain-handle-mouse-event" : int ChainHandleMouseEvent(wxObject!,wxMouseEvent%);
+
+class os_wxKeymap : public wxKeymap {
+ public:
+
+  os_wxKeymap(Scheme_Object * obj);
+  ~os_wxKeymap();
+  Bool HandleMouseEvent(class wxObject* x0, class wxMouseEvent& x1);
+  Bool HandleKeyEvent(class wxObject* x0, class wxKeyEvent& x1);
+};
+
+Scheme_Object *os_wxKeymap_class;
+
+os_wxKeymap::os_wxKeymap(Scheme_Object * o)
+: wxKeymap()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxKeymap::~os_wxKeymap()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxKeymap::HandleMouseEvent(class wxObject* x0, class wxMouseEvent& x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxKeymap_class, "handle-mouse-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxKeymap::HandleMouseEvent(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxObject(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(&x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:keymap%::handle-mouse-event"", extracting return value");
+  }
+}
+
+Bool os_wxKeymap::HandleKeyEvent(class wxObject* x0, class wxKeyEvent& x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxKeymap_class, "handle-key-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxKeymap::HandleKeyEvent(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxObject(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(&x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:keymap%::handle-key-event"", extracting return value");
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapRemoveChainedKeymap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:keymap%::remove-chained-keymap", 0);
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->RemoveChainedKeymap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapChainToKeymap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:keymap%::chain-to-keymap", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:keymap%::chain-to-keymap");
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->ChainToKeymap(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapSetBreakSequenceCallback(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  wxBreakSequenceFunction x0;
+  void* x1;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (wxBreakSequenceFunction)BreakSequenceCallbackToScheme;
+
+  kctsr(cb) = p[0]; x1 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->SetBreakSequenceCallback(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapSetErrorCallback(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  wxKeyErrorFunction x0;
+  void* x1;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (wxKeyErrorFunction)ErrorCallbackToScheme;
+
+  kctsr(cb) = p[0]; x1 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->SetErrorCallback(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapCallFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  if ((n >= 3) && objscheme_istype_string(p[0], NULL) && objscheme_istype_wxObject(p[1], NULL, 0) && objscheme_istype_wxKeyEvent(p[2], NULL, 0)) {
+    string x0;
+    class wxObject* x1;
+    class wxKeyEvent* x2;
+    Bool x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:keymap%::call-function (wx:key-event% case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::call-function (wx:key-event% case)");
+    x1 = objscheme_unbundle_wxObject(p[1], "wx:keymap%::call-function (wx:key-event% case)", 0);
+    x2 = objscheme_unbundle_wxKeyEvent(p[2], "wx:keymap%::call-function (wx:key-event% case)", 0);
+    if (n > 3) {
+      x3 = objscheme_unbundle_bool(p[3], "wx:keymap%::call-function (wx:key-event% case)");
+    } else
+      x3 = FALSE;
+
+    
+    r = ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->CallFunction(x0, x1, *x2, x3);
+
+    
+    
+  } else  {
+    string x0;
+    class wxObject* x1;
+    class wxMouseEvent* x2;
+    Bool x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:keymap%::call-function (wx:mouse-event% case)", 3, 4, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::call-function (wx:mouse-event% case)");
+    x1 = objscheme_unbundle_wxObject(p[1], "wx:keymap%::call-function (wx:mouse-event% case)", 0);
+    x2 = objscheme_unbundle_wxMouseEvent(p[2], "wx:keymap%::call-function (wx:mouse-event% case)", 0);
+    if (n > 3) {
+      x3 = objscheme_unbundle_bool(p[3], "wx:keymap%::call-function (wx:mouse-event% case)");
+    } else
+      x3 = FALSE;
+
+    
+    r = ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->CallFunction(x0, x1, *x2, x3);
+
+    
+    
+  }
+
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapRemoveGrabMouseFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->RemoveGrabMouseFunction();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapSetGrabMouseFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  wxGrabMouseFunction x0;
+  void* x1;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (wxGrabMouseFunction)GrabMouseCallbackToScheme;
+
+  kctsr(cb) = p[0]; x1 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->SetGrabMouseFunction(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapAddMouseFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  wxMouseFunction x1;
+  void* x2;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::add-mouse-function");
+  x1 = (wxMouseFunction)MouseCallbackToScheme;
+
+  kctsr(cb) = p[1]; x2 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->AddMouseFunction(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapRemoveGrabKeyFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->RemoveGrabKeyFunction();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapSetGrabKeyFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  wxGrabKeyFunction x0;
+  void* x1;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (wxGrabKeyFunction)GrabKeyCallbackToScheme;
+
+  kctsr(cb) = p[0]; x1 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->SetGrabKeyFunction(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapAddKeyFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  wxKeyFunction x1;
+  void* x2;
+
+  KeymapCallbackToSchemeRec *cb;
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::add-key-function");
+  x1 = (wxKeyFunction)KeyCallbackToScheme;
+
+  kctsr(cb) = p[1]; x2 = (void *)cb;
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->AddKeyFunction(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapImpliesShift(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::implies-shift");
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->ImpliesShift(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapMapFunction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  string x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:keymap%::map-function");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:keymap%::map-function");
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->MapFunction(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapBreakSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->BreakSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapHandleMouseEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxObject* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxObject(p[0], "wx:keymap%::handle-mouse-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:keymap%::handle-mouse-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->wxKeymap::HandleMouseEvent(x0, *x1);
+  else
+    r = ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->HandleMouseEvent(x0, *x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapHandleKeyEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxObject* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxObject(p[0], "wx:keymap%::handle-key-event", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:keymap%::handle-key-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->wxKeymap::HandleKeyEvent(x0, *x1);
+  else
+    r = ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->HandleKeyEvent(x0, *x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapSetDoubleClickInterval(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:keymap%::set-double-click-interval");
+
+  
+  ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->SetDoubleClickInterval(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymapGetDoubleClickInterval(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxKeymap *)((Scheme_Class_Object *)obj)->primdata)->GetDoubleClickInterval();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxKeymap_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxKeymap *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:keymap%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxKeymap(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxKeymap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:keymap%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:keymap%");
+}
+
+void objscheme_setup_wxKeymap(void *env)
+{
+if (os_wxKeymap_class) {
+    objscheme_add_global_class(os_wxKeymap_class,  "wx:keymap%", env);
+} else {
+  os_wxKeymap_class = objscheme_def_prim_class(env, "wx:keymap%", "wx:object%", os_wxKeymap_ConstructScheme, 19);
+
+  scheme_add_method_w_arity(os_wxKeymap_class,"get-class-name",objscheme_classname_os_wxKeymap, 0, 0);
+
+ scheme_add_method_w_arity(os_wxKeymap_class, "remove-chained-keymap", os_wxKeymapRemoveChainedKeymap, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "chain-to-keymap", os_wxKeymapChainToKeymap, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "set-break-sequence-callback", os_wxKeymapSetBreakSequenceCallback, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "set-error-callback", os_wxKeymapSetErrorCallback, 1, 1);
+ scheme_add_method(os_wxKeymap_class, "call-function", os_wxKeymapCallFunction);
+ scheme_add_method_w_arity(os_wxKeymap_class, "remove-grab-mouse-function", os_wxKeymapRemoveGrabMouseFunction, 0, 0);
+ scheme_add_method_w_arity(os_wxKeymap_class, "set-grab-mouse-function", os_wxKeymapSetGrabMouseFunction, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "add-mouse-function", os_wxKeymapAddMouseFunction, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "remove-grab-key-function", os_wxKeymapRemoveGrabKeyFunction, 0, 0);
+ scheme_add_method_w_arity(os_wxKeymap_class, "set-grab-key-function", os_wxKeymapSetGrabKeyFunction, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "add-key-function", os_wxKeymapAddKeyFunction, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "implies-shift", os_wxKeymapImpliesShift, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "map-function", os_wxKeymapMapFunction, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "break-sequence", os_wxKeymapBreakSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxKeymap_class, "handle-mouse-event", os_wxKeymapHandleMouseEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "handle-key-event", os_wxKeymapHandleKeyEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxKeymap_class, "set-double-click-interval", os_wxKeymapSetDoubleClickInterval, 1, 1);
+ scheme_add_method_w_arity(os_wxKeymap_class, "get-double-click-interval", os_wxKeymapGetDoubleClickInterval, 0, 0);
+
+
+  scheme_made_class(os_wxKeymap_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxKeymap, wxTYPE_KEYMAP);
+
+}
+}
+
+int objscheme_istype_wxKeymap(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxKeymap_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:keymap%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxKeymap(class wxKeymap *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_KEYMAP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxKeymap_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxKeymap(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxKeymap *)o->primdata;
+  else
+    return (wxKeymap *)o->primdata;
+}
+
+
+static Bool KeyCallbackToScheme(wxObject *media, wxKeyEvent &event, 
+			       KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxKeyEvent(wxKeyEvent *);
+  Scheme_Object *p[2], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxObject(media);
+  p[1] = objscheme_bundle_wxKeyEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 2, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme key callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static Bool GrabKeyCallbackToScheme(char *s, wxKeymap *km,
+				    wxObject *media, wxKeyEvent &event, 
+				    KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxKeyEvent(wxKeyEvent *);
+  Scheme_Object *p[4], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(s);
+  p[1] = objscheme_bundle_wxKeymap(km);
+  p[2] = objscheme_bundle_wxObject(media);
+  p[3] = objscheme_bundle_wxKeyEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 4, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme grab-key callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static Bool MouseCallbackToScheme(wxObject *media, wxMouseEvent &event, 
+				 KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxMouseEvent(wxMouseEvent *);
+  Scheme_Object *p[2], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxObject(media);
+  p[1] = objscheme_bundle_wxMouseEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 2, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme mouse callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+  
+  return retval;
+}
+
+static Bool GrabMouseCallbackToScheme(char *s, wxKeymap *km,
+				      wxObject *media, wxMouseEvent &event, 
+				      KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxMouseEvent(wxMouseEvent *);
+  Scheme_Object *p[3], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(s);
+  p[1] = objscheme_bundle_wxKeymap(km);
+  p[2] = objscheme_bundle_wxObject(media);
+  p[3] = objscheme_bundle_wxMouseEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 4, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme grab-mouse callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static void ErrorCallbackToScheme(KeymapCallbackToSchemeRec *data, char *err)
+{
+  Scheme_Object *p[1];
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(err);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(kctsr(data), 1, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+static void BreakSequenceCallbackToScheme(KeymapCallbackToSchemeRec *data)
+{
+  jmp_buf savebuf;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(kctsr(data), 0, NULL);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+
+
+
+
+
+
+
+
+class os_wxMediaWordbreakMap : public wxMediaWordbreakMap {
+ public:
+
+  os_wxMediaWordbreakMap(Scheme_Object * obj);
+  ~os_wxMediaWordbreakMap();
+};
+
+Scheme_Object *os_wxMediaWordbreakMap_class;
+
+os_wxMediaWordbreakMap::os_wxMediaWordbreakMap(Scheme_Object * o)
+: wxMediaWordbreakMap()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaWordbreakMap::~os_wxMediaWordbreakMap()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaWordbreakMapIsUsed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaWordbreakMap *)((Scheme_Class_Object *)obj)->primdata)->IsUsed();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaWordbreakMapAdjustUsage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-wordbreak-map%::adjust-usage");
+
+  
+  ((wxMediaWordbreakMap *)((Scheme_Class_Object *)obj)->primdata)->AdjustUsage(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaWordbreakMapGetMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-wordbreak-map%::get-map");
+
+  
+  r = ((wxMediaWordbreakMap *)((Scheme_Class_Object *)obj)->primdata)->GetMap(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaWordbreakMapSetMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-wordbreak-map%::set-map");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-wordbreak-map%::set-map");
+
+  
+  ((wxMediaWordbreakMap *)((Scheme_Class_Object *)obj)->primdata)->SetMap(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaWordbreakMap_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaWordbreakMap *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-wordbreak-map%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaWordbreakMap(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaWordbreakMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-wordbreak-map%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-wordbreak-map%");
+}
+
+void objscheme_setup_wxMediaWordbreakMap(void *env)
+{
+if (os_wxMediaWordbreakMap_class) {
+    objscheme_add_global_class(os_wxMediaWordbreakMap_class,  "wx:media-wordbreak-map%", env);
+} else {
+  os_wxMediaWordbreakMap_class = objscheme_def_prim_class(env, "wx:media-wordbreak-map%", "wx:object%", os_wxMediaWordbreakMap_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxMediaWordbreakMap_class,"get-class-name",objscheme_classname_os_wxMediaWordbreakMap, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaWordbreakMap_class, "is-used?", os_wxMediaWordbreakMapIsUsed, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaWordbreakMap_class, "adjust-usage", os_wxMediaWordbreakMapAdjustUsage, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaWordbreakMap_class, "get-map", os_wxMediaWordbreakMapGetMap, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaWordbreakMap_class, "set-map", os_wxMediaWordbreakMapSetMap, 2, 2);
+
+
+  scheme_made_class(os_wxMediaWordbreakMap_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaWordbreakMap, wxTYPE_WORDBREAK_MAP);
+
+}
+  scheme_install_xc_global("wx:the-media-wordbreak-map", objscheme_bundle_wxMediaWordbreakMap(&wxTheMediaWordbreakMap), env);
+}
+
+int objscheme_istype_wxMediaWordbreakMap(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaWordbreakMap_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-wordbreak-map%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaWordbreakMap(class wxMediaWordbreakMap *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_WORDBREAK_MAP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaWordbreakMap_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaWordbreakMap *objscheme_unbundle_wxMediaWordbreakMap(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaWordbreakMap(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaWordbreakMap *)o->primdata;
+  else
+    return (wxMediaWordbreakMap *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_madm.h b/src/mred/wxs/wxs_madm.h
new file mode 100644
index 0000000..dfb6c05
--- /dev/null
+++ b/src/mred/wxs/wxs_madm.h
@@ -0,0 +1,127 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+extern class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *, const char *, int);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaCanvas(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaCanvas(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaCanvas(class wxMediaCanvas *realobj);
+class wxMediaCanvas *objscheme_unbundle_wxMediaCanvas(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+#endif
+void objscheme_setup_wxMediaAdmin(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaAdmin(class wxMediaAdmin *realobj);
+class wxMediaAdmin *objscheme_unbundle_wxMediaAdmin(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaCanvas(class wxMediaCanvas *);
+#endif
+void objscheme_setup_wxCanvasMediaAdmin(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxCanvasMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxCanvasMediaAdmin(class wxCanvasMediaAdmin *realobj);
+class wxCanvasMediaAdmin *objscheme_unbundle_wxCanvasMediaAdmin(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaSnip(class wxMediaSnip *);
+#endif
+void objscheme_setup_wxMediaSnipMediaAdmin(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaSnipMediaAdmin(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaSnipMediaAdmin(class wxMediaSnipMediaAdmin *realobj);
+class wxMediaSnipMediaAdmin *objscheme_unbundle_wxMediaSnipMediaAdmin(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *);
+#endif
+void objscheme_setup_wxSnipAdmin(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxSnipAdmin(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *realobj);
+class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+#endif
+void objscheme_setup_wxSnipClass(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxSnipClass(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxSnipClass(class wxSnipClass *realobj);
+class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnipClass(class wxSnipClass *);
+extern class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *, const char *, int);
+extern class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnipClass(class wxSnipClass *);
+#endif
+void objscheme_setup_wxSnipClassList(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxSnipClassList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxSnipClassList(class wxSnipClassList *realobj);
+class wxSnipClassList *objscheme_unbundle_wxSnipClassList(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxObject(class wxObject *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxObject(class wxObject *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxObject(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxObject *objscheme_unbundle_wxObject(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxObject *objscheme_unbundle_wxObject(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxObject *objscheme_unbundle_wxObject(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxObject *objscheme_unbundle_wxObject(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxKeymap(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxKeymap(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxKeymap(class wxKeymap *realobj);
+class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxMediaWordbreakMap(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxMediaWordbreakMap(class wxMediaWordbreakMap *);
+int objscheme_istype_wxMediaWordbreakMap(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaWordbreakMap(class wxMediaWordbreakMap *realobj);
+class wxMediaWordbreakMap *objscheme_unbundle_wxMediaWordbreakMap(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_madm.xc b/src/mred/wxs/wxs_madm.xc
new file mode 100644
index 0000000..bc59736
--- /dev/null
+++ b/src/mred/wxs/wxs_madm.xc
@@ -0,0 +1,392 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_media.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#include "wxs_obj.h"
+
+@MACRO rNULL = return NULL;
+@MACRO rFALSE = return FALSE;
+@MACRO rZERO = return 0;
+
+static void *DoCAPOCallback(void *data)
+{
+  jmp_buf savebuf;
+  void *r;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf))
+    r = (void *)scheme_apply((Scheme_Object *)data, 0, NULL);
+  else
+    r = (void *)scheme_false;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return r;
+}
+
+typedef void *(*CAPOFunc)(void*);
+
+@CLASSBASE wxMediaCanvas "wx:media-canvas" : "wx:canvas"
+
+@CREATOR (wxFrame!,int=-1,int=-1,int=-1,int=-1, string="",long=0,int=100,wxMediaBuffer^=NULL); : : /NOZERO[3]|NOZERO[4] <> frame
+@CREATOR (wxPanel!,int=-1,int=-1,int=-1,int=-1, string="",long=0,int=100,wxMediaBuffer^=NULL); : : /NOZERO[3]|NOZERO[4] <> panel
+
+@CLASSID wxTYPE_MEDIA_CANVAS
+
+@ "set-media" : void SetMedia(wxMediaBuffer^,bool=TRUE);
+@ "get-media" : wxMediaBuffer^ GetMedia();
+
+// @ v "scroll" : void Scroll(int,int,bool);
+// @ v "scroll" : void Scroll(int,int);
+@ v "on-set-focus" : void OnSetFocus();
+@ v "on-kill-focus" : void OnKillFocus();
+
+@ "is-focus-on?" : bool IsFocusOn();
+
+@ "force-display-focus" : void ForceDisplayFocus(bool);
+
+@ "allow-scroll-to-last" : void AllowScrollToLast(bool);
+@ "scroll-with-bottom-base" : void ScrollWithBottomBase(bool);
+
+@ "get-lazy-refresh" : bool GetLazyRefresh();
+@ "set-lazy-refresh" : void SetLazyRefresh(bool);
+
+@MACRO CastToSO = (Scheme_Object*){x}
+@MACRO ubTestFunc = DoCAPOCallback
+@MACRO ubData = p[0]
+@MACRO spAnything = _
+@MACRO spCAPOProc = (-> _)
+
+@ "call-as-primary-owner" : void[]/CastToSO//spAnything CallAsPrimaryOwner(CAPOFunc//ubTestFunc///spCAPOProc, -void[]//ubData);
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
+
+@SETMARK c = d
+@INCLUDE wxs_cnvs.xci
+
+@CONSTANT "wx:const-mcanvas-no-h-scroll" : long wxMCANVAS_NO_H_SCROLL
+@CONSTANT "wx:const-mcanvas-no-v-scroll" : long wxMCANVAS_NO_V_SCROLL
+@CONSTANT "wx:const-mcanvas-hide-h-scroll" : long wxMCANVAS_HIDE_H_SCROLL
+@CONSTANT "wx:const-mcanvas-hide-v-scroll" : long wxMCANVAS_HIDE_V_SCROLL
+
+@END
+
+
+@CLASSBASE wxMediaAdmin "wx:media-admin":"wx:object"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_MEDIA_ADMIN
+
+@SETMARK A = V
+@INCLUDE wxs_madm.xci
+
+@END
+
+#define FIXCMA os_wxCanvasMediaAdmin() : wxCanvasMediaAdmin(NULL) {}
+
+@CLASSBASE wxCanvasMediaAdmin "wx:canvas-media-admin":"wx:media-admin"
+
+@CLASSID wxTYPE_CANVAS_MEDIA_ADMIN
+
+@VAR FIXCMA
+
+// Virtual, but not really overrideable since the class isn't instantiable
+// @SETMARK A = d
+// @INCLUDE wxs_madm.xci
+
+@ "get-canvas" : wxMediaCanvas! GetCanvas()
+
+@END
+
+#define FIXMSMA os_wxMediaSnipMediaAdmin() : wxMediaSnipMediaAdmin(NULL) {}
+
+@CLASSBASE wxMediaSnipMediaAdmin "wx:media-snip-media-admin":"wx:media-admin"
+
+@CLASSID wxTYPE_MEDIA_SNIP_MEDIA_ADMIN
+
+@VAR FIXMSMA
+
+// Virtual, but not really overrideable since the class isn't instantiable
+// @SETMARK A = d
+// @INCLUDE wxs_madm.xci
+
+@ "get-snip" : wxMediaSnip! GetSnip()
+
+@END
+
+
+@CLASSBASE wxSnipAdmin "wx:snip-admin":"wx:object"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_MEDIA_SNIP_ADMIN
+
+@ V "get-media" : wxMediaBuffer^ GetMedia(); : : : rNULL
+@ V "get-dc" : wxDC! GetDC(); : : : rNULL
+@ V "get-view-size" : void GetViewSize(float?, float?);
+@ V "get-view" : void GetView(float?, float?, float?, float?, wxSnip^=NULL);
+@ V "scroll-to" : bool ScrollTo(wxSnip!, float,float,float,float, bool,int=0); : : : rFALSE
+@ V "set-caret-owner" : void SetCaretOwner(wxSnip!,int=wxFOCUS_IMMEDIATE);
+@ V "resized" : void Resized(wxSnip!, bool);
+@ V "recounted" : bool Recounted(wxSnip!, bool); : : : rFALSE
+@ V "needs-update" : void NeedsUpdate(wxSnip!, float,float,float,float);
+@ V "release-snip" : bool ReleaseSnip(wxSnip!); : : : rFALSE
+@ V "update-cursor" : void UpdateCursor();
+
+@END
+
+
+
+@CLASSBASE wxSnipClass "wx:snip-class" : "wx:object"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_SNIP_CLASS
+
+@IVAR "classname" : string classname
+@IVAR "version" : int version
+
+@ V "read" : wxSnip^ Read(wxMediaStreamIn%); : : : rNULL
+@ v "read-header" : bool ReadHeader(wxMediaStreamIn%);
+@ v "read-done" : void ReadDone();
+@ v "write-header" : bool WriteHeader(wxMediaStreamOut%);
+@ v "write-done" : void WriteDone();
+
+@END
+
+
+@CLASSBASE wxSnipClassList "wx:snip-class-list" : "wx:object"
+
+@CLASSID wxTYPE_SNIP_CLASS_LIST
+
+@ "find" : wxSnipClass^ Find(string);
+@ "find-position" : short FindPosition(wxSnipClass!);
+@ "add" : void Add(wxSnipClass!);
+@ "number" : int Number();
+@ "nth" : wxSnipClass^ Nth(int);
+@ "reading-version" : int ReadingVersion(wxSnipClass!);
+
+@END
+
+
+@CLASSBASE wxKeymap "wx:keymap":"wx:object"
+
+typedef Scheme_Object KeymapCallbackToSchemeRec;
+#define kctsr(o) o
+
+static int KeyCallbackToScheme(wxObject *, wxKeyEvent &, KeymapCallbackToSchemeRec *data);
+static int MouseCallbackToScheme(wxObject *, wxMouseEvent &, KeymapCallbackToSchemeRec *data);
+static int GrabKeyCallbackToScheme(char *s, wxKeymap *km, wxObject *, wxKeyEvent &, KeymapCallbackToSchemeRec *data);
+static int GrabMouseCallbackToScheme(char *s, wxKeymap *km, wxObject *, wxMouseEvent &, KeymapCallbackToSchemeRec *data);
+static void ErrorCallbackToScheme(KeymapCallbackToSchemeRec *data, char *str);
+static void BreakSequenceCallbackToScheme(KeymapCallbackToSchemeRec *data);
+
+@MACRO bCallback =
+@MACRO ubSetup = KeymapCallbackToSchemeRec *cb;
+
+@MACRO ubCallbackKey = (wxKeyFunction)KeyCallbackToScheme
+@MACRO ubCallbackMouse = (wxMouseFunction)MouseCallbackToScheme
+@MACRO ubCallbackGrabKey = (wxGrabKeyFunction)GrabKeyCallbackToScheme
+@MACRO ubCallbackGrabMouse = (wxGrabMouseFunction)GrabMouseCallbackToScheme
+@MACRO ubCallbackError = (wxKeyErrorFunction)ErrorCallbackToScheme
+@MACRO ubCallbackBreak = (wxBreakSequenceFunction)BreakSequenceCallbackToScheme
+
+@MACRO spCallbackKey = (wxObject-object wxKeyEvent-object -> bool)
+@MACRO spCallbackMouse = (wxObject-object wxMousrEvent-object -> bool)
+@MACRO spCallbackGrabKey = (str wxKeymap-object wxObject-object wxKeyEvent-object -> bool)
+@MACRO spCallbackGrabMouse = (str wxKeymap-object wxObject-object wxMouseEvent-object -> bool)
+@MACRO spCallbackError = (str -> void)
+@MACRO spCallbackBreak = (-> void)
+
+@MACRO ubData = NULL
+
+@MACRO ubSetData[n.m] = kctsr(cb) = p[<n>]; x<m> = (void *)cb;
+
+@CREATOR ();
+
+@CLASSID wxTYPE_KEYMAP
+
+@ "get-double-click-interval" : long GetDoubleClickInterval();
+@ "set-double-click-interval" : void SetDoubleClickInterval(long);
+
+@ v "handle-key-event" : bool HandleKeyEvent(wxObject!,wxKeyEvent%);
+@ v "handle-mouse-event" : bool HandleMouseEvent(wxObject!,wxMouseEvent%);
+// @ "chain-handle-key-event" : int ChainHandleKeyEvent(wxObject!,wxKeyEvent%);
+// @ "chain-handle-mouse-event" : int ChainHandleMouseEvent(wxObject!,wxMouseEvent%);
+@ "break-sequence" : void BreakSequence();
+@ "map-function" : void MapFunction(string,string);
+@ "implies-shift" : void ImpliesShift(string);
+@ "add-key-function" : void AddKeyFunction(string,wxKeyFunction/bCallback/ubCallbackKey/cCallback//spCallbackKey,-unknown#void*=NULL); : : ubSetup / ubSetData[1.2]
+@ "set-grab-key-function" : void SetGrabKeyFunction(wxGrabKeyFunction/bCallback/ubCallbackGrabKey/cCallback//spCallbackGrabKey,-unknown#void*=NULL); : : ubSetup / ubSetData[0.1]
+@ "remove-grab-key-function" : void RemoveGrabKeyFunction()
+@ "add-mouse-function" : void AddMouseFunction(string,wxMouseFunction/bCallback/ubCallbackMouse/cCallback2//spCallbackMouse,-unknown#void*=NULL); : : ubSetup / ubSetData[1.2]
+@ "set-grab-mouse-function" : void SetGrabMouseFunction(wxGrabMouseFunction/bCallback/ubCallbackGrabMouse/cCallback//spCallbackGrabMouse,-unknown#void*=NULL); : : ubSetup / ubSetData[0.1]
+@ "remove-grab-mouse-function" : void RemoveGrabMouseFunction()
+@ "call-function" : bool CallFunction(string,wxObject!,wxKeyEvent%,bool=FALSE); <> wx:key-event%
+@ "call-function" : bool CallFunction(string,wxObject!,wxMouseEvent%,bool=FALSE); <> wx:mouse-event%
+@ "set-error-callback" : void SetErrorCallback(wxKeyErrorFunction/bCallback/ubCallbackError/cCallback//spCallbackError,-unknown#void*=NULL); : : ubSetup / ubSetData[0.1]
+@ "set-break-sequence-callback" : void SetBreakSequenceCallback(wxBreakSequenceFunction/bCallback/ubCallbackBreak/cCallback//spCallbackBreak,-unknown#void*=NULL); : : ubSetup / ubSetData[0.1]
+@ "chain-to-keymap" : void ChainToKeymap(wxKeymap!,bool);
+@ "remove-chained-keymap" : void RemoveChainedKeymap(wxKeymap!);
+
+@END
+
+static Bool KeyCallbackToScheme(wxObject *media, wxKeyEvent &event, 
+			       KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxKeyEvent(wxKeyEvent *);
+  Scheme_Object *p[2], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxObject(media);
+  p[1] = objscheme_bundle_wxKeyEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 2, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme key callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static Bool GrabKeyCallbackToScheme(char *s, wxKeymap *km,
+				    wxObject *media, wxKeyEvent &event, 
+				    KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxKeyEvent(wxKeyEvent *);
+  Scheme_Object *p[4], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(s);
+  p[1] = objscheme_bundle_wxKeymap(km);
+  p[2] = objscheme_bundle_wxObject(media);
+  p[3] = objscheme_bundle_wxKeyEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 4, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme grab-key callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static Bool MouseCallbackToScheme(wxObject *media, wxMouseEvent &event, 
+				 KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxMouseEvent(wxMouseEvent *);
+  Scheme_Object *p[2], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxObject(media);
+  p[1] = objscheme_bundle_wxMouseEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 2, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme mouse callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+  
+  return retval;
+}
+
+static Bool GrabMouseCallbackToScheme(char *s, wxKeymap *km,
+				      wxObject *media, wxMouseEvent &event, 
+				      KeymapCallbackToSchemeRec *data)
+{
+  extern Scheme_Object *objscheme_bundle_wxMouseEvent(wxMouseEvent *);
+  Scheme_Object *p[3], *obj;
+  Bool retval;
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(s);
+  p[1] = objscheme_bundle_wxKeymap(km);
+  p[2] = objscheme_bundle_wxObject(media);
+  p[3] = objscheme_bundle_wxMouseEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    obj = scheme_apply(kctsr(data), 4, p);
+    retval = objscheme_unbundle_bool(obj, "Scheme grab-mouse callback");
+  } else
+    retval = 0;
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+ 
+  return retval;
+}
+
+static void ErrorCallbackToScheme(KeymapCallbackToSchemeRec *data, char *err)
+{
+  Scheme_Object *p[1];
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_string(err);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(kctsr(data), 1, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+static void BreakSequenceCallbackToScheme(KeymapCallbackToSchemeRec *data)
+{
+  jmp_buf savebuf;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(kctsr(data), 0, NULL);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+
+
+@CLASSBASE wxMediaWordbreakMap "wx:media-wordbreak-map" : "wx:object"
+
+@CREATOR ()
+
+@CLASSID wxTYPE_WORDBREAK_MAP
+
+@ "set-map" : void SetMap(int,int);
+@ "get-map" : int GetMap(int);
+
+@ "adjust-usage" : void AdjustUsage(bool)
+@ "is-used?" : bool IsUsed();
+
+@CONSTANT "wx:the-media-wordbreak-map" : wxMediaWordbreakMap% wxTheMediaWordbreakMap
+
+@END
+
diff --git a/src/mred/wxs/wxs_madm.xci b/src/mred/wxs/wxs_madm.xci
new file mode 100644
index 0000000..a4a8c12
--- /dev/null
+++ b/src/mred/wxs/wxs_madm.xci
@@ -0,0 +1,10 @@
+
+@ A "get-dc" : wxDC^ GetDC(float?=NULL,float?=NULL); : : : rNULL
+@ A "get-view" : void GetView(float?,float?,float?,float?,bool=FALSE);
+@ A "get-max-view" : void GetMaxView(float?,float?,float?,float?,bool=FALSE);
+@ A "scroll-to" : bool ScrollTo(float,float,float,float,bool=TRUE,int=0); : : : rFALSE
+@ A "grab-caret" : void GrabCaret(int=wxFOCUS_GLOBAL);
+@ A "resized" : void Resized(bool);
+@ A "needs-update" : void NeedsUpdate(float,float,float,float);
+@ A "update-cursor" : void UpdateCursor();
+@ A "refresh-delayed?" : bool DelayRefresh(); : : : rFALSE
diff --git a/src/mred/wxs/wxs_mbuf.xci b/src/mred/wxs/wxs_mbuf.xci
new file mode 100644
index 0000000..41477dc
--- /dev/null
+++ b/src/mred/wxs/wxs_mbuf.xci
@@ -0,0 +1,77 @@
+
+/* 
+   X = Not meant for virtual, defined in wxMediaEdit/wxMediaPasteboard
+       and overloaded there
+   Y = Virtual, defined in wxMediaEdit/wxMediaPasteboard
+   Z = Virtual, defined in wxMediaBuffer 
+*/
+
+@MACRO XrZERO = return 0;
+@MACRO XrNULL = return NULL;
+
+@ X "change-style" : void ChangeStyle(wxStyleDelta^); <> wx:style-delta% without position or wx:snip%
+@ X "insert" : void Insert(wxSnip!); <> wx:snip% without position
+
+@ X "cut" :  void Cut(bool=FALSE,long=0); <> without position
+@ X "copy" : void Copy(bool=FALSE,long=0); <> without position
+@ X "paste" : void Paste(long=0); <> without position
+@ X "kill" : void Kill(long=0); <> without position
+
+@ Y "on-event" : void OnEvent(wxMouseEvent%);
+@ Y "on-char" : void OnChar(wxKeyEvent%);
+@ Y "adjust-cursor" : wxCursor^ AdjustCursor(wxMouseEvent%); : : : : XrNULL
+@ Y "refresh" : void Refresh(float,float,float,float,bool);
+@ Y "own-caret" : void OwnCaret(bool);
+@ Y "size-cache-invalid" : void SizeCacheInvalid();
+
+@ Z "on-local-event" : void OnLocalEvent(wxMouseEvent%);
+@ Z "on-local-char" : void OnLocalChar(wxKeyEvent%);
+@ Y "on-default-event" : void OnDefaultEvent(wxMouseEvent%);
+@ Y "on-default-char" : void OnDefaultChar(wxKeyEvent%);
+
+@ Z "on-focus" : void OnFocus(bool);
+
+@ Y "on-change" : void OnChange();
+
+@ Y "scroll-to" : bool ScrollTo(wxSnip!,float,float,float,float,bool); : : : : XrZERO
+@ Y "set-caret-owner" : void SetCaretOwner(wxSnip^,int=wxFOCUS_IMMEDIATE);
+@ Y "resized" : void Resized(wxSnip!,bool);
+@ Y "needs-update" : void NeedsUpdate(wxSnip!,float,float,float,float);
+
+@ Y "get-snip-data" : wxBufferData^ GetSnipData(wxSnip!); : : : : XrZERO
+@ Y "set-snip-data" : void SetSnipData(wxSnip!, wxBufferData^);
+
+@ Z "set-modified" : void SetModified(bool);
+
+@ Y "release-snip" : bool ReleaseSnip(wxSnip!); : : : : XrZERO
+
+@ Y "set-filename" : void SetFilename(string,bool=FALSE);
+
+@ X "read-from-file" : bool ReadFromFile(wxMediaStreamIn%,bool=FALSE); <> without position
+@ X "write-to-file" : bool WriteToFile(wxMediaStreamOut%); <> without position
+
+@ Z "read-header-from-file" : bool ReadHeaderFromFile(wxMediaStreamIn%,string);
+@ Z "read-footer-from-file" : bool ReadFooterFromFile(wxMediaStreamIn%,string);
+@ Z "write-headers-to-file" : bool WriteHeadersToFile(wxMediaStreamOut%);
+@ Z "write-footers-to-file" : bool WriteFootersToFile(wxMediaStreamOut%);
+
+@ Z "on-paint" : void OnPaint(bool,wxDC!,float,float,float,float,float,float,int);  : : /CHECKOK[1."wx:media-buffer%::on-paint"]
+@ Y "invalidate-bitmap-cache" : void InvalidateBitmapCache(float=0.0,float=0.0,float=-1.0,float=-1.0);
+
+@ Z "on-new-image-snip" : wxImageSnip! OnNewImageSnip(nstring,long,bool,bool);
+@ Z "on-new-box" : wxSnip! OnNewBox(int);
+
+@ Z "on-save-file" : bool OnSaveFile(string,int);
+@ Z "after-save-file" : void AfterSaveFile(bool);
+@ Z "on-load-file" : bool OnLoadFile(string,int);
+@ Z "after-load-file" : void AfterLoadFile(bool);
+
+@ Z "on-edit-sequence" : void OnEditSequence();
+@ Z "after-edit-sequence" : void AfterEditSequence();
+
+@ Z "get-file" : nstring GetFile(nstring);
+@ Z "put-file" : nstring PutFile(nstring, nstring);
+
+@MACRO makeNoCopyFlatString[len] = scheme_make_sized_string(r, <len>, 0)
+
+@ X "get-flattened-text" : string/makeNoCopyFlatString[_x0] GetFlattenedText(-long*);
diff --git a/src/mred/wxs/wxs_mede.cxx b/src/mred/wxs/wxs_mede.cxx
new file mode 100644
index 0000000..5aeabb5
--- /dev/null
+++ b/src/mred/wxs/wxs_mede.cxx
@@ -0,0 +1,5719 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_mede.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_media.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_mede.h"
+#include "wxscomon.h"
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE float
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_float
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_float
+#define l_MAKE_LIST __MakefloatList
+#define l_MAKE_ARRAY __MakefloatArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+
+
+
+
+
+/* 
+   X = Not meant for virtual, defined in wxMediaEdit/wxMediaPasteboard
+       and overloaded there
+   Y = Virtual, defined in wxMediaEdit/wxMediaPasteboard
+   Z = Virtual, defined in wxMediaBuffer 
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+			
+
+
+
+
+
+
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE long
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_long
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_long
+#define l_MAKE_LIST __MakelongList
+#define l_MAKE_ARRAY __MakelongArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static void WordbreakCallbackToScheme(wxMediaEdit *,long*,long*,int,Scheme_Object *);
+
+
+
+
+
+static void WordbreakCallbackToScheme(wxMediaEdit *media,
+				      long *start, long *end,
+				      int reason,
+				      Scheme_Object *f)
+{
+  Scheme_Object *p[4], *s, *e;
+  jmp_buf savebuf;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    p[0] = objscheme_bundle_wxMediaEdit(media);
+    if (start)
+      s = scheme_box(objscheme_bundle_integer(*start));
+    else
+      s = scheme_null;
+    if (end)
+      e = scheme_box(objscheme_bundle_integer(*end));
+    else
+      e = scheme_null;
+    p[1] = s;
+    p[2] = e;
+    p[3] = scheme_make_integer(reason);
+
+    scheme_apply(f, 4, p);
+    if (start)
+      *start = objscheme_unbundle_integer(scheme_unbox(s), "Scheme wordbreak callback");
+    if (end)
+      *end = objscheme_unbundle_integer(scheme_unbox(e), "Scheme wordbreak callback");
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+static void ClickbackToScheme(wxMediaEdit *media,
+			      long start, long end,
+			      Scheme_Object *f)
+{
+  Scheme_Object *p[3];
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxMediaEdit(media);
+  p[1] = objscheme_bundle_integer(start);
+  p[2] = objscheme_bundle_integer(end);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf))
+    scheme_apply(f, 3, p);
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+
+
+
+
+
+
+
+class os_wxMediaEdit : public wxMediaEdit {
+ public:
+  Scheme_Object *scroll_closure;
+
+  os_wxMediaEdit(Scheme_Object * obj, float x0 = 1.0, float* x1 = NULL, int x2 = 0);
+  ~os_wxMediaEdit();
+  class wxTabSnip* OnNewTabSnip();
+  class wxTextSnip* OnNewTextSnip();
+  void SetRegionData(long x0, long x1, class wxBufferData* x2);
+  class wxBufferData* GetRegionData(long x0, long x1);
+  void AfterSetSizeConstraint();
+  Bool OnSetSizeConstraint();
+  void AfterSetPosition();
+  void AfterChangeStyle(long x0, long x1);
+  Bool OnChangeStyle(long x0, long x1);
+  void AfterDelete(long x0, long x1);
+  Bool OnDelete(long x0, long x1);
+  void AfterInsert(long x0, long x1);
+  Bool OnInsert(long x0, long x1);
+  void DoPaste(long x0, long x1);
+  void DoCopy(long x0, long x1, long x2, Bool x3);
+  void SetAnchor(Bool x0);
+  nstring PutFile(nstring x0, nstring x1);
+  nstring GetFile(nstring x0);
+  void AfterEditSequence();
+  void OnEditSequence();
+  void AfterLoadFile(Bool x0);
+  Bool OnLoadFile(string x0, int x1);
+  void AfterSaveFile(Bool x0);
+  Bool OnSaveFile(string x0, int x1);
+  class wxSnip* OnNewBox(int x0);
+  class wxImageSnip* OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3);
+  void InvalidateBitmapCache(float x0 = 0.0, float x1 = 0.0, float x2 = -1.0, float x3 = -1.0);
+  void OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8);
+  Bool WriteFootersToFile(class wxMediaStreamOut& x0);
+  Bool WriteHeadersToFile(class wxMediaStreamOut& x0);
+  Bool ReadFooterFromFile(class wxMediaStreamIn& x0, string x1);
+  Bool ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1);
+  void SetFilename(string x0, Bool x1 = FALSE);
+  Bool ReleaseSnip(class wxSnip* x0);
+  void SetModified(Bool x0);
+  void SetSnipData(class wxSnip* x0, class wxBufferData* x1);
+  class wxBufferData* GetSnipData(class wxSnip* x0);
+  void NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4);
+  void Resized(class wxSnip* x0, Bool x1);
+  void SetCaretOwner(class wxSnip* x0, int x1 = wxFOCUS_IMMEDIATE);
+  Bool ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5);
+  void OnChange();
+  void OnFocus(Bool x0);
+  void OnDefaultChar(class wxKeyEvent& x0);
+  void OnDefaultEvent(class wxMouseEvent& x0);
+  void OnLocalChar(class wxKeyEvent& x0);
+  void OnLocalEvent(class wxMouseEvent& x0);
+  void SizeCacheInvalid();
+  void OwnCaret(Bool x0);
+  void Refresh(float x0, float x1, float x2, float x3, Bool x4);
+  class wxCursor* AdjustCursor(class wxMouseEvent& x0);
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+};
+
+Scheme_Object *os_wxMediaEdit_class;
+
+os_wxMediaEdit::os_wxMediaEdit(Scheme_Object * o, float x0, float* x1, int x2)
+: wxMediaEdit(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaEdit::~os_wxMediaEdit()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+class wxTabSnip* os_wxMediaEdit::OnNewTabSnip()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-new-tab-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnNewTabSnip();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxTabSnip(v, "wx:media-edit%::on-new-tab-snip"", extracting return value", 0);
+  }
+}
+
+class wxTextSnip* os_wxMediaEdit::OnNewTextSnip()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-new-text-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnNewTextSnip();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxTextSnip(v, "wx:media-edit%::on-new-text-snip"", extracting return value", 0);
+  }
+}
+
+void os_wxMediaEdit::SetRegionData(long x0, long x1, class wxBufferData* x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-region-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetRegionData(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = objscheme_bundle_wxBufferData(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxBufferData* os_wxMediaEdit::GetRegionData(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "get-region-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::GetRegionData(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxBufferData(v, "wx:media-edit%::get-region-data"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaEdit::AfterSetSizeConstraint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-set-size-constraint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterSetSizeConstraint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnSetSizeConstraint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-set-size-constraint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnSetSizeConstraint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-set-size-constraint"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::AfterSetPosition()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-set-position", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterSetPosition();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::AfterChangeStyle(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-change-style", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterChangeStyle(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnChangeStyle(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-change-style", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnChangeStyle(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-change-style"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::AfterDelete(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-delete", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterDelete(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnDelete(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-delete", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnDelete(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-delete"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::AfterInsert(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-insert", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterInsert(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnInsert(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-insert", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnInsert(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-insert"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::DoPaste(long x0, long x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "do-paste", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::DoPaste(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::DoCopy(long x0, long x1, long x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "do-copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::DoCopy(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = scheme_make_integer(x2);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::SetAnchor(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-anchor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetAnchor(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+nstring os_wxMediaEdit::PutFile(nstring x0, nstring x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "put-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::PutFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-edit%::put-file"", extracting return value");
+  }
+}
+
+nstring os_wxMediaEdit::GetFile(nstring x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "get-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::GetFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-edit%::get-file"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::AfterEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::AfterLoadFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterLoadFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnLoadFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnLoadFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-load-file"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::AfterSaveFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "after-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::AfterSaveFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::OnSaveFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnSaveFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::on-save-file"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxMediaEdit::OnNewBox(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-new-box", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnNewBox(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:media-edit%::on-new-box"", extracting return value", 0);
+  }
+}
+
+class wxImageSnip* os_wxMediaEdit::OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-new-image-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::OnNewImageSnip(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxImageSnip(v, "wx:media-edit%::on-new-image-snip"", extracting return value", 0);
+  }
+}
+
+void os_wxMediaEdit::InvalidateBitmapCache(float x0, float x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "invalidate-bitmap-cache", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::InvalidateBitmapCache(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  p[1] = objscheme_bundle_wxDC(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_integer(x8);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::WriteFootersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "write-footers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::WriteFootersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::write-footers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaEdit::WriteHeadersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "write-headers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::WriteHeadersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::write-headers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaEdit::ReadFooterFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "read-footer-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::ReadFooterFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::read-footer-from-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaEdit::ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "read-header-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::ReadHeaderFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::read-header-from-file"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::SetFilename(string x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-filename", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetFilename(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::ReleaseSnip(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "release-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::ReleaseSnip(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::release-snip"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::SetModified(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-modified", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetModified(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::SetSnipData(class wxSnip* x0, class wxBufferData* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetSnipData(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxBufferData(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxBufferData* os_wxMediaEdit::GetSnipData(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "get-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::GetSnipData(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxBufferData(v, "wx:media-edit%::get-snip-data"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaEdit::NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "needs-update", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::NeedsUpdate(x0, x1, x2, x3, x4);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::Resized(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "resized", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::Resized(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::SetCaretOwner(class wxSnip* x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "set-caret-owner", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SetCaretOwner(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaEdit::ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "scroll-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::ScrollTo(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = (x5 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-edit%::scroll-to"", extracting return value");
+  }
+}
+
+void os_wxMediaEdit::OnChange()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-change", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnChange();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnFocus(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnFocus(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnDefaultChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-default-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnDefaultChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnDefaultEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-default-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnDefaultEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnLocalChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-local-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnLocalChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnLocalEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-local-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnLocalEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::Refresh(float x0, float x1, float x2, float x3, Bool x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "refresh", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::Refresh(x0, x1, x2, x3, x4);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxMediaEdit::AdjustCursor(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaEdit::AdjustCursor(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:media-edit%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaEdit::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaEdit::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaEdit_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaEdit::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditRemoveClickback(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::remove-clickback");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::remove-clickback");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->RemoveClickback(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetClickback(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  wxClickbackFunc x2;
+  void* x3;
+  class wxStyleDelta* x4;
+  Bool x5;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::set-clickback");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::set-clickback");
+  x2 = (wxClickbackFunc)ClickbackToScheme;
+  x3 = p[2];
+  if (n > 3) {
+    x4 = objscheme_unbundle_wxStyleDelta(p[3], "wx:media-edit%::set-clickback", 1);
+  } else
+    x4 = NULL;
+  if (n > 4) {
+    x5 = objscheme_unbundle_bool(p[4], "wx:media-edit%::set-clickback");
+  } else
+    x5 = FALSE;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetClickback(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetWordbreakFunc(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  wxWordbreakFunc x0;
+  void* x1;
+
+  
+  x0 = (wxWordbreakFunc)WordbreakCallbackToScheme;
+  x1 = p[0];
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetWordbreakFunc(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetAutowrapBitmap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBitmap* r;
+  objscheme_check_valid(obj);
+  class wxBitmap* x0;
+
+  
+  x0 = objscheme_unbundle_wxBitmap(p[0], "wx:media-edit%::set-autowrap-bitmap", 1);
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetAutowrapBitmap(x0);
+
+  
+  
+  return objscheme_bundle_wxBitmap(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnNewTabSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxTabSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnNewTabSnip();
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnNewTabSnip();
+
+  
+  
+  return objscheme_bundle_wxTabSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnNewTextSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxTextSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnNewTextSnip();
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnNewTextSnip();
+
+  
+  
+  return objscheme_bundle_wxTextSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditCaretHidden(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->CaretHidden();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditHideCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::hide-caret");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->HideCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetWordbreakMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaWordbreakMap* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetWordbreakMap();
+
+  
+  
+  return objscheme_bundle_wxMediaWordbreakMap(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetWordbreakMap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaWordbreakMap* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaWordbreakMap(p[0], "wx:media-edit%::set-wordbreak-map", 1);
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetWordbreakMap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindWordbreak(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+  long _x1;
+  long* x1 = &_x1;
+  int x2;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-edit%::find-wordbreak"), "wx:media-edit%::find-wordbreak");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-edit%::find-wordbreak"), "wx:media-edit%::find-wordbreak");
+  x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::find-wordbreak");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindWordbreak(x0, x1, x2);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetRegionData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  class wxBufferData* x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::set-region-data");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::set-region-data");
+  x2 = objscheme_unbundle_wxBufferData(p[2], "wx:media-edit%::set-region-data", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetRegionData(x0, x1, x2);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetRegionData(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetRegionData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferData* r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::get-region-data");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::get-region-data");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::GetRegionData(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetRegionData(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxBufferData(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterSetSizeConstraint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterSetSizeConstraint();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterSetSizeConstraint();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnSetSizeConstraint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnSetSizeConstraint();
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnSetSizeConstraint();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterSetPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterSetPosition();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterSetPosition();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterChangeStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::after-change-style");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::after-change-style");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterChangeStyle(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterChangeStyle(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnChangeStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::on-change-style");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-change-style");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnChangeStyle(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnChangeStyle(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::after-delete");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::after-delete");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterDelete(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterDelete(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::on-delete");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-delete");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnDelete(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnDelete(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::after-insert");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::after-insert");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterInsert(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterInsert(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::on-insert");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-insert");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnInsert(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnInsert(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAddEditorFunctions(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-edit%::add-editor-functions", 0);
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AddEditorFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetTabs(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float* x0;
+  int x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = NULL;
+  if (n > 1) {
+    x2 = objscheme_unbundle_float(p[1], "wx:media-edit%::set-tabs");
+  } else
+    x2 = wxTAB_WIDTH;
+  if (n > 2) {
+    x3 = objscheme_unbundle_bool(p[2], "wx:media-edit%::set-tabs");
+  } else
+    x3 = TRUE;
+
+  x0 = __MakefloatArray((0 < n) ? p[0] : scheme_null, &x1, "wx:media-edit%::set-tabs");
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetTabs(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetTabs(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float* r;
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  Bool _x2;
+  Bool* x2 = &_x2;
+
+  
+  if (n > 0) {
+    if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-edit%::get-tabs"), "wx:media-edit%::get-tabs");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-edit%::get-tabs"), "wx:media-edit%::get-tabs");
+  } else
+    x1 = NULL;
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_bool(objscheme_unbox(p[2], "wx:media-edit%::get-tabs"), "wx:media-edit%::get-tabs");
+  } else
+    x2 = NULL;
+
+  if (!x0) x0 = &_x0;
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetTabs(x0, x1, x2);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], (_x2 ? scheme_true : scheme_false));
+  
+  return __MakefloatList(r, *x0);;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetOverwriteMode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::set-overwrite-mode");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetOverwriteMode(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetOverwriteMode(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetOverwriteMode();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetFileFormat(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::set-file-format");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetFileFormat(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetFileFormat(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetFileFormat();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditWriteToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_wxMediaStreamOut(p[0], NULL, 0) && objscheme_istype_number(p[1], NULL)) {
+    class wxMediaStreamOut* x0;
+    long x1;
+    long x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::write-to-file (with position case)", 2, 3, n, p);
+    x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-edit%::write-to-file (with position case)", 0);
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::write-to-file (with position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::write-to-file (with position case)");
+    } else
+      x2 = -1;
+
+    
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->WriteToFile(*x0, x1, x2);
+
+    
+    
+  } else  {
+    class wxMediaStreamOut* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-edit%::write-to-file (without position case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-edit%::write-to-file (without position case)", 0);
+
+    
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->WriteToFile(*x0);
+
+    
+    
+  }
+
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditReadFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_wxMediaStreamIn(p[0], NULL, 0) && objscheme_istype_number(p[1], NULL)) {
+    class wxMediaStreamIn* x0;
+    long x1;
+    Bool x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::read-from-file (with position case)", 2, 3, n, p);
+    x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-edit%::read-from-file (with position case)", 0);
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::read-from-file (with position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::read-from-file (with position case)");
+    } else
+      x2 = FALSE;
+
+    
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ReadFromFile(*x0, x1, x2);
+
+    
+    
+  } else  {
+    class wxMediaStreamIn* x0;
+    Bool x1;
+
+    
+    if ((n < 1) ||(n > 2)) 
+      scheme_wrong_count("wx:media-edit%::read-from-file (without position case)", 1, 2, n, p);
+    x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-edit%::read-from-file (without position case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::read-from-file (without position case)");
+    } else
+      x1 = FALSE;
+
+    
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ReadFromFile(*x0, x1);
+
+    
+    
+  }
+
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditInsertFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::insert-file");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::insert-file");
+  } else
+    x1 = wxMEDIA_FF_GUESS;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->InsertFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetCharacter(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  unsigned char r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::get-character");
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetCharacter(x0);
+
+  
+  
+  return scheme_make_char((char)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+  long _x4;
+  long* x4 = &_x4;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::get-text");
+  } else
+    x0 = -1;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::get-text");
+  } else
+    x1 = -1;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::get-text");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::get-text");
+  } else
+    x3 = FALSE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_make_sized_string(r, _x4, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetSnipPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::get-snip-position", 0);
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetSnipPosition(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetSnipPositionAndLocation(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  long _x1;
+  long* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::get-snip-position-and-location", 0);
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-edit%::get-snip-position-and-location"), "wx:media-edit%::get-snip-position-and-location");
+  if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-edit%::get-snip-position-and-location"), "wx:media-edit%::get-snip-position-and-location");
+  if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-edit%::get-snip-position-and-location"), "wx:media-edit%::get-snip-position-and-location");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetSnipPositionAndLocation(x0, x1, x2, x3);
+
+  
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  long x0;
+  int x1;
+  long _x2;
+  long* x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::find-snip");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::find-snip");
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:media-edit%::find-snip"), "wx:media-edit%::find-snip");
+  } else
+    x2 = NULL;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindSnip(x0, x1, x2);
+
+  
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindStringAll(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long* r;
+  objscheme_check_valid(obj);
+  string x0;
+  long _x1;
+  long* x1 = &_x1;
+  int x2;
+  long x3;
+  long x4;
+  Bool x5;
+  Bool x6;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::find-string-all");
+  if (n > 1) {
+    x2 = objscheme_unbundle_integer(p[1], "wx:media-edit%::find-string-all");
+  } else
+    x2 = 1;
+  if (n > 2) {
+    x3 = objscheme_unbundle_integer(p[2], "wx:media-edit%::find-string-all");
+  } else
+    x3 = -1;
+  if (n > 3) {
+    x4 = objscheme_unbundle_integer(p[3], "wx:media-edit%::find-string-all");
+  } else
+    x4 = -1;
+  if (n > 4) {
+    x5 = objscheme_unbundle_bool(p[4], "wx:media-edit%::find-string-all");
+  } else
+    x5 = TRUE;
+  if (n > 5) {
+    x6 = objscheme_unbundle_bool(p[5], "wx:media-edit%::find-string-all");
+  } else
+    x6 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindStringAll(x0, x1, x2, x3, x4, x5, x6);
+
+  
+  
+  return __MakelongList(r, *x1);;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+  long x2;
+  long x3;
+  Bool x4;
+  Bool x5;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::find-string");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::find-string");
+  } else
+    x1 = 1;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::find-string");
+  } else
+    x2 = -1;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:media-edit%::find-string");
+  } else
+    x3 = -1;
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-edit%::find-string");
+  } else
+    x4 = TRUE;
+  if (n > 5) {
+    x5 = objscheme_unbundle_bool(p[5], "wx:media-edit%::find-string");
+  } else
+    x5 = TRUE;
+
+  if ((x1 != 1) && (x1 != -1)) scheme_signal_error("wx:media-edit%%::find-string: direction must be 1 or -1, given %d", x1);
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindString(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLastParagraph(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LastParagraph();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditParagraphEndLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::pargraph-end-line");
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ParagraphEndLine(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditParagraphStartLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::paragraph-start-line");
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ParagraphStartLine(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLineParagraph(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::line-paragraph");
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LineParagraph(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditParagraphEndPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::paragraph-end-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::paragraph-end-position");
+  } else
+    x1 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ParagraphEndPosition(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditParagraphStartPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::paragraph-start-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::paragraph-start-position");
+  } else
+    x1 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ParagraphStartPosition(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPositionParagraph(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::position-paragraph");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::position-paragraph");
+  } else
+    x1 = FALSE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->PositionParagraph(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLastLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LastLine();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLastPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LastPosition();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLineLength(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::line-length");
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LineLength(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLineEndPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::line-end-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::line-end-position");
+  } else
+    x1 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LineEndPosition(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLineStartPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::line-start-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::line-start-position");
+  } else
+    x1 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LineStartPosition(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditLineLocation(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::line-location");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::line-location");
+  } else
+    x1 = TRUE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->LineLocation(x0, x1);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPositionLocation(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  Bool x3;
+  Bool x4;
+  Bool x5;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::position-location");
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-edit%::position-location"), "wx:media-edit%::position-location");
+  } else
+    x1 = NULL;
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-edit%::position-location"), "wx:media-edit%::position-location");
+  } else
+    x2 = NULL;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::position-location");
+  } else
+    x3 = TRUE;
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-edit%::position-location");
+  } else
+    x4 = FALSE;
+  if (n > 5) {
+    x5 = objscheme_unbundle_bool(p[5], "wx:media-edit%::position-location");
+  } else
+    x5 = FALSE;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->PositionLocation(x0, x1, x2, x3, x4, x5);
+
+  
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPositionLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::position-line");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::position-line");
+  } else
+    x1 = FALSE;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->PositionLine(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetBetweenThreshold(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::set-between-threshold");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetBetweenThreshold(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetBetweenThreshold(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetBetweenThreshold();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindPositionInLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  float x1;
+  Bool _x2;
+  Bool* x2 = &_x2;
+  Bool _x3;
+  Bool* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::find-position-in-line");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::find-position-in-line");
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_bool(objscheme_unbox(p[2], "wx:media-edit%::find-position-in-line"), "wx:media-edit%::find-position-in-line");
+  } else
+    x2 = NULL;
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_bool(objscheme_unbox(p[3], "wx:media-edit%::find-position-in-line"), "wx:media-edit%::find-position-in-line");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:media-edit%::find-position-in-line"), "wx:media-edit%::find-position-in-line");
+  } else
+    x4 = NULL;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindPositionInLine(x0, x1, x2, x3, x4);
+
+  
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], (_x2 ? scheme_true : scheme_false));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], (_x3 ? scheme_true : scheme_false));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  float x0;
+  Bool _x1;
+  Bool* x1 = &_x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::find-line");
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_bool(objscheme_unbox(p[1], "wx:media-edit%::find-line"), "wx:media-edit%::find-line");
+  } else
+    x1 = NULL;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindLine(x0, x1);
+
+  
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], (_x1 ? scheme_true : scheme_false));
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFindPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  Bool _x2;
+  Bool* x2 = &_x2;
+  Bool _x3;
+  Bool* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::find-position");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::find-position");
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_bool(objscheme_unbox(p[2], "wx:media-edit%::find-position"), "wx:media-edit%::find-position");
+  } else
+    x2 = NULL;
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_bool(objscheme_unbox(p[3], "wx:media-edit%::find-position"), "wx:media-edit%::find-position");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:media-edit%::find-position"), "wx:media-edit%::find-position");
+  } else
+    x4 = NULL;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FindPosition(x0, x1, x2, x3, x4);
+
+  
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], (_x2 ? scheme_true : scheme_false));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], (_x3 ? scheme_true : scheme_false));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSplitSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::split-snip");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SplitSnip(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditChangeStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_wxStyleDelta(p[0], NULL, 1) && objscheme_istype_number(p[1], NULL)) {
+    class wxStyleDelta* x0;
+    long x1;
+    long x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::change-style (wx:style-delta% and position case)", 2, 3, n, p);
+    x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:media-edit%::change-style (wx:style-delta% and position case)", 1);
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::change-style (wx:style-delta% and position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::change-style (wx:style-delta% and position case)");
+    } else
+      x2 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0, x1, x2);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_wxStyleDelta(p[0], NULL, 1)) {
+    class wxStyleDelta* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-edit%::change-style (wx:style-delta% without position or wx:snip% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:media-edit%::change-style (wx:style-delta% without position or wx:snip% case)", 1);
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0);
+
+    
+    
+  } else  {
+    class wxStyle* x0;
+    long x1;
+    long x2;
+
+    
+    if ((n < 1) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::change-style (wx:style% case)", 1, 3, n, p);
+    x0 = objscheme_unbundle_wxStyle(p[0], "wx:media-edit%::change-style (wx:style% case)", 1);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::change-style (wx:style% case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::change-style (wx:style% case)");
+    } else
+      x2 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0, x1, x2);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditDoPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::do-paste");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::do-paste");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::DoPaste(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->DoPaste(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditDoCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  long x2;
+  Bool x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::do-copy");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::do-copy");
+  x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::do-copy");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::do-copy");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::DoCopy(x0, x1, x2, x3);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->DoCopy(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditKill(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_number(p[0], NULL) && objscheme_istype_number(p[1], NULL)) {
+    long x0;
+    long x1;
+    long x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:media-edit%::kill (position case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::kill (position case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::kill (position case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::kill (position case)");
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Kill(x0, x1, x2);
+
+    
+    
+  } else  {
+    long x0;
+
+    
+    if ((n > 1)) 
+      scheme_wrong_count("wx:media-edit%::kill (without position case)", 0, 1, n, p);
+    if (n > 0) {
+      x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::kill (without position case)");
+    } else
+      x0 = 0;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Kill(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPasteNext(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->PasteNext();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_number(p[0], NULL) && objscheme_istype_number(p[1], NULL)) {
+    long x0;
+    long x1;
+    long x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::paste (position case)", 2, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::paste (position case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::paste (position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::paste (position case)");
+    } else
+      x2 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Paste(x0, x1, x2);
+
+    
+    
+  } else  {
+    long x0;
+
+    
+    if ((n > 1)) 
+      scheme_wrong_count("wx:media-edit%::paste (without position case)", 0, 1, n, p);
+    if (n > 0) {
+      x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::paste (without position case)");
+    } else
+      x0 = 0;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Paste(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 3) && objscheme_istype_bool(p[0], NULL) && objscheme_istype_number(p[1], NULL) && objscheme_istype_number(p[2], NULL)) {
+    Bool x0;
+    long x1;
+    long x2;
+    long x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:media-edit%::copy (position case)", 3, 4, n, p);
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::copy (position case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::copy (position case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::copy (position case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:media-edit%::copy (position case)");
+    } else
+      x3 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0, x1, x2, x3);
+
+    
+    
+  } else  {
+    Bool x0;
+    long x1;
+
+    
+    if ((n > 2)) 
+      scheme_wrong_count("wx:media-edit%::copy (without position case)", 0, 2, n, p);
+    if (n > 0) {
+      x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::copy (without position case)");
+    } else
+      x0 = FALSE;
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::copy (without position case)");
+    } else
+      x1 = 0;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0, x1);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditCut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 3) && objscheme_istype_bool(p[0], NULL) && objscheme_istype_number(p[1], NULL) && objscheme_istype_number(p[2], NULL)) {
+    Bool x0;
+    long x1;
+    long x2;
+    long x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:media-edit%::cut (position case)", 3, 4, n, p);
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::cut (position case)");
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::cut (position case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::cut (position case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:media-edit%::cut (position case)");
+    } else
+      x3 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Cut(x0, x1, x2, x3);
+
+    
+    
+  } else  {
+    Bool x0;
+    long x1;
+
+    
+    if ((n > 2)) 
+      scheme_wrong_count("wx:media-edit%::cut (without position case)", 0, 2, n, p);
+    if (n > 0) {
+      x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::cut (without position case)");
+    } else
+      x0 = FALSE;
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::cut (without position case)");
+    } else
+      x1 = 0;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Cut(x0, x1);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditErase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Erase();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    long x0;
+    long x1;
+    Bool x2;
+
+    
+    if ((n < 1) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::delete (position case)", 1, 3, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::delete (position case)");
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::delete (position case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::delete (position case)");
+    } else
+      x2 = TRUE;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Delete(x0, x1, x2);
+
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:media-edit%::delete (no position case)", 0, 0, n, p);
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Delete();
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_string(p[0], NULL) && objscheme_istype_number(p[1], NULL)) {
+    long x0;
+    string x1;
+    long x2;
+    long x3;
+    Bool x4;
+
+    
+    if ((n < 2) ||(n > 4)) 
+      scheme_wrong_count("wx:media-edit%::insert (string and position case)", 2, 4, n, p);
+    x1 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::insert (string and position case)");
+    x2 = objscheme_unbundle_integer(p[1], "wx:media-edit%::insert (string and position case)");
+    if (n > 2) {
+      x3 = objscheme_unbundle_integer(p[2], "wx:media-edit%::insert (string and position case)");
+    } else
+      x3 = -1;
+    if (n > 3) {
+      x4 = objscheme_unbundle_bool(p[3], "wx:media-edit%::insert (string and position case)");
+    } else
+      x4 = TRUE;
+
+    x0 = SCHEME_STRTAG_VAL(p[0]);
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2, x3, x4);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    long x0;
+    string x1;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-edit%::insert (string without position case)", 1, 1, n, p);
+    x1 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::insert (string without position case)");
+
+    x0 = SCHEME_STRTAG_VAL(p[0]);
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1);
+
+    
+    
+  } else if ((n >= 3) && objscheme_istype_number(p[0], NULL) && objscheme_istype_string(p[1], NULL) && objscheme_istype_number(p[2], NULL)) {
+    long x0;
+    string x1;
+    long x2;
+    long x3;
+    Bool x4;
+
+    
+    if ((n < 3) ||(n > 5)) 
+      scheme_wrong_count("wx:media-edit%::insert (length and string without position case)", 3, 5, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::insert (length and string without position case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:media-edit%::insert (length and string without position case)");
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::insert (length and string without position case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:media-edit%::insert (length and string without position case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_bool(p[4], "wx:media-edit%::insert (length and string without position case)");
+    } else
+      x4 = TRUE;
+
+    if ((x0 < 0) || (x0 > SCHEME_STRTAG_VAL(p[1]))) scheme_signal_error("wx:media-edit%%::insert: bad string length");
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2, x3, x4);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    long x0;
+    string x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:media-edit%::insert (length, string, and position case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::insert (length, string, and position case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:media-edit%::insert (length, string, and position case)");
+
+    if ((x0 < 0) || (x0 > SCHEME_STRTAG_VAL(p[1]))) scheme_signal_error("wx:media-edit%%::insert: bad string length");
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1);
+
+    
+    
+  } else if ((n >= 2) && objscheme_istype_wxSnip(p[0], NULL, 0) && objscheme_istype_number(p[1], NULL)) {
+    class wxSnip* x0;
+    long x1;
+    long x2;
+    Bool x3;
+
+    
+    if ((n < 2) ||(n > 4)) 
+      scheme_wrong_count("wx:media-edit%::insert (wx:snip% and position case)", 2, 4, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::insert (wx:snip% and position case)", 0);
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::insert (wx:snip% and position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::insert (wx:snip% and position case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::insert (wx:snip% and position case)");
+    } else
+      x3 = TRUE;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2, x3);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_wxSnip(p[0], NULL, 0)) {
+    class wxSnip* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-edit%::insert (wx:snip% without position case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::insert (wx:snip% without position case)", 0);
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0);
+
+    
+    
+  } else if ((n >= 2) && objscheme_istype_char(p[0], NULL) && objscheme_istype_number(p[1], NULL)) {
+    unsigned char x0;
+    long x1;
+    long x2;
+
+    
+    if ((n < 2) ||(n > 3)) 
+      scheme_wrong_count("wx:media-edit%::insert (character and position case)", 2, 3, n, p);
+    x0 = ((unsigned char)objscheme_unbundle_char(p[0], "wx:media-edit%::insert (character and position case)"));
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::insert (character and position case)");
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::insert (character and position case)");
+    } else
+      x2 = -1;
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2);
+
+    
+    
+  } else  {
+    unsigned char x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-edit%::insert (character without position case)", 1, 1, n, p);
+    x0 = ((unsigned char)objscheme_unbundle_char(p[0], "wx:media-edit%::insert (character without position case)"));
+
+    
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFlashOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FlashOff();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditFlashOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+  long x4;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::flash-on");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::flash-on");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::flash-on");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::flash-on");
+  } else
+    x3 = TRUE;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:media-edit%::flash-on");
+  } else
+    x4 = 500;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->FlashOn(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetAnchor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetAnchor();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetAnchor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::set-anchor");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetAnchor(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetAnchor(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetVisibleLineRange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+  long _x1;
+  long* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-edit%::get-visible-line-range"), "wx:media-edit%::get-visible-line-range");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-edit%::get-visible-line-range"), "wx:media-edit%::get-visible-line-range");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetVisibleLineRange(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetVisiblePositionRange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+  long _x1;
+  long* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-edit%::get-visible-position-range"), "wx:media-edit%::get-visible-position-range");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-edit%::get-visible-position-range"), "wx:media-edit%::get-visible-position-range");
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetVisiblePositionRange(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditScrollToPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+  long x2;
+  int x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::scroll-to-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::scroll-to-position");
+  } else
+    x1 = FALSE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::scroll-to-position");
+  } else
+    x2 = -1;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:media-edit%::scroll-to-position");
+  } else
+    x3 = 0;
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ScrollToPosition(x0, x1, x2, x3);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditMovePosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+  int x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::move-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::move-position");
+  } else
+    x1 = FALSE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::move-position");
+  } else
+    x2 = wxMOVE_SIMPLE;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->MovePosition(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetPositionBiasScroll(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  long x1;
+  long x2;
+  Bool x3;
+  Bool x4;
+  int x5;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::set-position-bias-scroll");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::set-position-bias-scroll");
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-edit%::set-position-bias-scroll");
+  } else
+    x2 = -1;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::set-position-bias-scroll");
+  } else
+    x3 = FALSE;
+  if (n > 4) {
+    x4 = objscheme_unbundle_bool(p[4], "wx:media-edit%::set-position-bias-scroll");
+  } else
+    x4 = TRUE;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:media-edit%::set-position-bias-scroll");
+  } else
+    x5 = wxDEFAULT_SELECT;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetPositionBiasScroll(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+  int x4;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::set-position");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::set-position");
+  } else
+    x1 = -1;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::set-position");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::set-position");
+  } else
+    x3 = TRUE;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:media-edit%::set-position");
+  } else
+    x4 = wxDEFAULT_SELECT;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetPosition(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetEndPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetEndPosition();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetStartPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetStartPosition();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+  long _x1;
+  long* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-edit%::get-position"), "wx:media-edit%::get-position");
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-edit%::get-position"), "wx:media-edit%::get-position");
+  } else
+    x1 = NULL;
+
+  
+  ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetPosition(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetFlattenedText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+
+  
+  r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetFlattenedText(x0);
+
+  
+  
+  return scheme_make_sized_string(r, _x0, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditPutFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  nstring x1;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-edit%::put-file");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:media-edit%::put-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::PutFile(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->PutFile(x0, x1);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-edit%::get-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::GetFile(x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetFile(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterEditSequence();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnEditSequence();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::after-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterLoadFile(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterLoadFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::on-load-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnLoadFile(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnLoadFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAfterSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::after-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AfterSaveFile(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AfterSaveFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::on-save-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnSaveFile(x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnSaveFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnNewBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-edit%::on-new-box");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnNewBox(x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnNewBox(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnNewImageSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxImageSnip* r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-edit%::on-new-image-snip");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::on-new-image-snip");
+  x2 = objscheme_unbundle_bool(p[2], "wx:media-edit%::on-new-image-snip");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-edit%::on-new-image-snip");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnNewImageSnip(x0, x1, x2, x3);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnNewImageSnip(x0, x1, x2, x3);
+
+  
+  
+  return objscheme_bundle_wxImageSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditInvalidateBitmapCache(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::invalidate-bitmap-cache");
+  } else
+    x0 = 0.0;
+  if (n > 1) {
+    x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::invalidate-bitmap-cache");
+  } else
+    x1 = 0.0;
+  if (n > 2) {
+    x2 = objscheme_unbundle_float(p[2], "wx:media-edit%::invalidate-bitmap-cache");
+  } else
+    x2 = -1.0;
+  if (n > 3) {
+    x3 = objscheme_unbundle_float(p[3], "wx:media-edit%::invalidate-bitmap-cache");
+  } else
+    x3 = -1.0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::InvalidateBitmapCache(x0, x1, x2, x3);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->InvalidateBitmapCache(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  class wxDC* x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  int x8;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::on-paint");
+  x1 = objscheme_unbundle_wxDC(p[1], "wx:media-edit%::on-paint", 0);
+  x2 = objscheme_unbundle_float(p[2], "wx:media-edit%::on-paint");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-edit%::on-paint");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-edit%::on-paint");
+  x5 = objscheme_unbundle_float(p[5], "wx:media-edit%::on-paint");
+  x6 = objscheme_unbundle_float(p[6], "wx:media-edit%::on-paint");
+  x7 = objscheme_unbundle_float(p[7], "wx:media-edit%::on-paint");
+  x8 = objscheme_unbundle_integer(p[8], "wx:media-edit%::on-paint");
+
+  if (x1 && !x1->Ok()) scheme_signal_error("%s: bad bitmap", "wx:media-buffer%::on-paint");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditWriteFootersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-edit%::write-footers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::WriteFootersToFile(*x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->WriteFootersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditWriteHeadersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-edit%::write-headers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::WriteHeadersToFile(*x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->WriteHeadersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditReadFooterFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-edit%::read-footer-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-edit%::read-footer-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::ReadFooterFromFile(*x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ReadFooterFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditReadHeaderFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-edit%::read-header-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-edit%::read-header-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::ReadHeaderFromFile(*x0, x1);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ReadHeaderFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetFilename(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  Bool x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-edit%::set-filename");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::set-filename");
+  } else
+    x1 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetFilename(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetFilename(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditReleaseSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::release-snip", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::ReleaseSnip(x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetModified(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::set-modified");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetModified(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetModified(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxBufferData* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::set-snip-data", 0);
+  x1 = objscheme_unbundle_wxBufferData(p[1], "wx:media-edit%::set-snip-data", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetSnipData(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetSnipData(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditGetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferData* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::get-snip-data", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::GetSnipData(x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->GetSnipData(x0);
+
+  
+  
+  return objscheme_bundle_wxBufferData(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditNeedsUpdate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::needs-update", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::needs-update");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-edit%::needs-update");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-edit%::needs-update");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-edit%::needs-update");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::NeedsUpdate(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditResized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::resized", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-edit%::resized");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::Resized(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSetCaretOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::set-caret-owner", 1);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-edit%::set-caret-owner");
+  } else
+    x1 = wxFOCUS_IMMEDIATE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SetCaretOwner(x0, x1);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditScrollTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  Bool x5;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-edit%::scroll-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::scroll-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-edit%::scroll-to");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-edit%::scroll-to");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-edit%::scroll-to");
+  x5 = objscheme_unbundle_bool(p[5], "wx:media-edit%::scroll-to");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::ScrollTo(x0, x1, x2, x3, x4, x5);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnChange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnChange();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnChange();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::on-focus");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnFocus(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnFocus(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnDefaultChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-edit%::on-default-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnDefaultChar(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnDefaultEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-edit%::on-default-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnDefaultEvent(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnLocalChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-edit%::on-local-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnLocalChar(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnLocalChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnLocalEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-edit%::on-local-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnLocalEvent(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnLocalEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::SizeCacheInvalid();
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-edit%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OwnCaret(x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  Bool x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::refresh");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-edit%::refresh");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-edit%::refresh");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-edit%::refresh");
+  x4 = objscheme_unbundle_bool(p[4], "wx:media-edit%::refresh");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::Refresh(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->Refresh(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-edit%::adjust-cursor", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::AdjustCursor(*x0);
+  else
+    r = ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(*x0);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-edit%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnChar(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEditOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-edit%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->wxMediaEdit::OnEvent(*x0);
+  else
+    ((wxMediaEdit *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaEdit_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaEdit *realobj;
+  float x0;
+  float* x1;
+  int x2;
+
+  
+  if ((n > 2)) 
+    scheme_wrong_count("wx:media-edit%::initialization", 0, 2, n, p);
+  if (n > 0) {
+    x0 = objscheme_unbundle_float(p[0], "wx:media-edit%::initialization");
+  } else
+    x0 = 1.0;
+  if (n > 1) {
+    x1 = NULL;
+  } else
+    x1 = NULL;
+
+  x1 = __MakefloatArray((1 < n) ? p[1] : scheme_null, &x2, "wx:media-edit%::initialization");
+  realobj = new os_wxMediaEdit(obj, x0, x1, x2);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-edit%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-edit%");
+}
+
+void objscheme_setup_wxMediaEdit(void *env)
+{
+if (os_wxMediaEdit_class) {
+    objscheme_add_global_class(os_wxMediaEdit_class,  "wx:media-edit%", env);
+} else {
+  os_wxMediaEdit_class = objscheme_def_prim_class(env, "wx:media-edit%", "wx:media-buffer%", os_wxMediaEdit_ConstructScheme, 123);
+
+  scheme_add_method_w_arity(os_wxMediaEdit_class,"get-class-name",objscheme_classname_os_wxMediaEdit, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "remove-clickback", os_wxMediaEditRemoveClickback, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-clickback", os_wxMediaEditSetClickback, 3, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-wordbreak-func", os_wxMediaEditSetWordbreakFunc, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-autowrap-bitmap", os_wxMediaEditSetAutowrapBitmap, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-new-tab-snip", os_wxMediaEditOnNewTabSnip, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-new-text-snip", os_wxMediaEditOnNewTextSnip, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "caret-hidden?", os_wxMediaEditCaretHidden, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "hide-caret", os_wxMediaEditHideCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-wordbreak-map", os_wxMediaEditGetWordbreakMap, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-wordbreak-map", os_wxMediaEditSetWordbreakMap, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-wordbreak", os_wxMediaEditFindWordbreak, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-region-data", os_wxMediaEditSetRegionData, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-region-data", os_wxMediaEditGetRegionData, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-set-size-constraint", os_wxMediaEditAfterSetSizeConstraint, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-set-size-constraint", os_wxMediaEditOnSetSizeConstraint, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-set-position", os_wxMediaEditAfterSetPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-change-style", os_wxMediaEditAfterChangeStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-change-style", os_wxMediaEditOnChangeStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-delete", os_wxMediaEditAfterDelete, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-delete", os_wxMediaEditOnDelete, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-insert", os_wxMediaEditAfterInsert, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-insert", os_wxMediaEditOnInsert, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "add-editor-functions", os_wxMediaEditAddEditorFunctions, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-tabs", os_wxMediaEditSetTabs, 1, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-tabs", os_wxMediaEditGetTabs, 0, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-overwrite-mode", os_wxMediaEditSetOverwriteMode, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-overwrite-mode", os_wxMediaEditGetOverwriteMode, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-file-format", os_wxMediaEditSetFileFormat, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-file-format", os_wxMediaEditGetFileFormat, 0, 0);
+ scheme_add_method(os_wxMediaEdit_class, "write-to-file", os_wxMediaEditWriteToFile);
+ scheme_add_method(os_wxMediaEdit_class, "read-from-file", os_wxMediaEditReadFromFile);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "insert-file", os_wxMediaEditInsertFile, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-character", os_wxMediaEditGetCharacter, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-text", os_wxMediaEditGetText, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-snip-position", os_wxMediaEditGetSnipPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-snip-position-and-location", os_wxMediaEditGetSnipPositionAndLocation, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-snip", os_wxMediaEditFindSnip, 2, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-string-all", os_wxMediaEditFindStringAll, 1, 6);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-string", os_wxMediaEditFindString, 1, 6);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "last-paragraph", os_wxMediaEditLastParagraph, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "pargraph-end-line", os_wxMediaEditParagraphEndLine, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "paragraph-start-line", os_wxMediaEditParagraphStartLine, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "line-paragraph", os_wxMediaEditLineParagraph, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "paragraph-end-position", os_wxMediaEditParagraphEndPosition, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "paragraph-start-position", os_wxMediaEditParagraphStartPosition, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "position-paragraph", os_wxMediaEditPositionParagraph, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "last-line", os_wxMediaEditLastLine, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "last-position", os_wxMediaEditLastPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "line-length", os_wxMediaEditLineLength, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "line-end-position", os_wxMediaEditLineEndPosition, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "line-start-position", os_wxMediaEditLineStartPosition, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "line-location", os_wxMediaEditLineLocation, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "position-location", os_wxMediaEditPositionLocation, 1, 6);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "position-line", os_wxMediaEditPositionLine, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-between-threshold", os_wxMediaEditSetBetweenThreshold, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-between-threshold", os_wxMediaEditGetBetweenThreshold, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-position-in-line", os_wxMediaEditFindPositionInLine, 2, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-line", os_wxMediaEditFindLine, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "find-position", os_wxMediaEditFindPosition, 2, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "split-snip", os_wxMediaEditSplitSnip, 1, 1);
+ scheme_add_method(os_wxMediaEdit_class, "change-style", os_wxMediaEditChangeStyle);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "do-paste", os_wxMediaEditDoPaste, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "do-copy", os_wxMediaEditDoCopy, 4, 4);
+ scheme_add_method(os_wxMediaEdit_class, "kill", os_wxMediaEditKill);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "paste-next", os_wxMediaEditPasteNext, 0, 0);
+ scheme_add_method(os_wxMediaEdit_class, "paste", os_wxMediaEditPaste);
+ scheme_add_method(os_wxMediaEdit_class, "copy", os_wxMediaEditCopy);
+ scheme_add_method(os_wxMediaEdit_class, "cut", os_wxMediaEditCut);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "erase", os_wxMediaEditErase, 0, 0);
+ scheme_add_method(os_wxMediaEdit_class, "delete", os_wxMediaEditDelete);
+ scheme_add_method(os_wxMediaEdit_class, "insert", os_wxMediaEditInsert);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "flash-off", os_wxMediaEditFlashOff, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "flash-on", os_wxMediaEditFlashOn, 2, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-anchor", os_wxMediaEditGetAnchor, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-anchor", os_wxMediaEditSetAnchor, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-visible-line-range", os_wxMediaEditGetVisibleLineRange, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-visible-position-range", os_wxMediaEditGetVisiblePositionRange, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "scroll-to-position", os_wxMediaEditScrollToPosition, 1, 4);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "move-position", os_wxMediaEditMovePosition, 1, 3);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-position-bias-scroll", os_wxMediaEditSetPositionBiasScroll, 2, 6);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-position", os_wxMediaEditSetPosition, 1, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-end-position", os_wxMediaEditGetEndPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-start-position", os_wxMediaEditGetStartPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-position", os_wxMediaEditGetPosition, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-flattened-text", os_wxMediaEditGetFlattenedText, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "put-file", os_wxMediaEditPutFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-file", os_wxMediaEditGetFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-edit-sequence", os_wxMediaEditAfterEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-edit-sequence", os_wxMediaEditOnEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-load-file", os_wxMediaEditAfterLoadFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-load-file", os_wxMediaEditOnLoadFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "after-save-file", os_wxMediaEditAfterSaveFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-save-file", os_wxMediaEditOnSaveFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-new-box", os_wxMediaEditOnNewBox, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-new-image-snip", os_wxMediaEditOnNewImageSnip, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "invalidate-bitmap-cache", os_wxMediaEditInvalidateBitmapCache, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-paint", os_wxMediaEditOnPaint, 9, 9);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "write-footers-to-file", os_wxMediaEditWriteFootersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "write-headers-to-file", os_wxMediaEditWriteHeadersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "read-footer-from-file", os_wxMediaEditReadFooterFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "read-header-from-file", os_wxMediaEditReadHeaderFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-filename", os_wxMediaEditSetFilename, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "release-snip", os_wxMediaEditReleaseSnip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-modified", os_wxMediaEditSetModified, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-snip-data", os_wxMediaEditSetSnipData, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "get-snip-data", os_wxMediaEditGetSnipData, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "needs-update", os_wxMediaEditNeedsUpdate, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "resized", os_wxMediaEditResized, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "set-caret-owner", os_wxMediaEditSetCaretOwner, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "scroll-to", os_wxMediaEditScrollTo, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-change", os_wxMediaEditOnChange, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-focus", os_wxMediaEditOnFocus, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-default-char", os_wxMediaEditOnDefaultChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-default-event", os_wxMediaEditOnDefaultEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-local-char", os_wxMediaEditOnLocalChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-local-event", os_wxMediaEditOnLocalEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "size-cache-invalid", os_wxMediaEditSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "own-caret", os_wxMediaEditOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "refresh", os_wxMediaEditRefresh, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "adjust-cursor", os_wxMediaEditAdjustCursor, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-char", os_wxMediaEditOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaEdit_class, "on-event", os_wxMediaEditOnEvent, 1, 1);
+
+
+  scheme_made_class(os_wxMediaEdit_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaEdit, wxTYPE_MEDIA_EDIT);
+
+}
+  scheme_install_xc_global("wx:const-edit-undo", scheme_make_integer(wxEDIT_UNDO), env);
+  scheme_install_xc_global("wx:const-edit-redo", scheme_make_integer(wxEDIT_REDO), env);
+  scheme_install_xc_global("wx:const-edit-clear", scheme_make_integer(wxEDIT_CLEAR), env);
+  scheme_install_xc_global("wx:const-edit-cut", scheme_make_integer(wxEDIT_CUT), env);
+  scheme_install_xc_global("wx:const-edit-copy", scheme_make_integer(wxEDIT_COPY), env);
+  scheme_install_xc_global("wx:const-edit-paste", scheme_make_integer(wxEDIT_PASTE), env);
+  scheme_install_xc_global("wx:const-edit-kill", scheme_make_integer(wxEDIT_KILL), env);
+  scheme_install_xc_global("wx:const-edit-insert-text-box", scheme_make_integer(wxEDIT_INSERT_TEXT_BOX), env);
+  scheme_install_xc_global("wx:const-edit-insert-graphic-box", scheme_make_integer(wxEDIT_INSERT_GRAPHIC_BOX), env);
+  scheme_install_xc_global("wx:const-edit-insert-image", scheme_make_integer(wxEDIT_INSERT_IMAGE), env);
+  scheme_install_xc_global("wx:const-edit-select-all", scheme_make_integer(wxEDIT_SELECT_ALL), env);
+  scheme_install_xc_global("wx:const-move-simple", scheme_make_integer(wxMOVE_SIMPLE), env);
+  scheme_install_xc_global("wx:const-move-line", scheme_make_integer(wxMOVE_LINE), env);
+  scheme_install_xc_global("wx:const-move-page", scheme_make_integer(wxMOVE_PAGE), env);
+  scheme_install_xc_global("wx:const-move-word", scheme_make_integer(wxMOVE_WORD), env);
+  scheme_install_xc_global("wx:const-media-ff-guess", scheme_make_integer(wxMEDIA_FF_GUESS), env);
+  scheme_install_xc_global("wx:const-media-ff-std", scheme_make_integer(wxMEDIA_FF_STD), env);
+  scheme_install_xc_global("wx:const-media-ff-text", scheme_make_integer(wxMEDIA_FF_TEXT), env);
+  scheme_install_xc_global("wx:const-media-ff-text-force-cr", scheme_make_integer(wxMEDIA_FF_TEXT_FORCE_CR), env);
+  scheme_install_xc_global("wx:const-media-ff-same", scheme_make_integer(wxMEDIA_FF_SAME), env);
+  scheme_install_xc_global("wx:const-media-ff-copy", scheme_make_integer(wxMEDIA_FF_COPY), env);
+  scheme_install_xc_global("wx:const-snip-draw-no-caret", scheme_make_integer(wxSNIP_DRAW_NO_CARET), env);
+  scheme_install_xc_global("wx:const-snip-draw-show-caret", scheme_make_integer(wxSNIP_DRAW_SHOW_CARET), env);
+  scheme_install_xc_global("wx:const-snip-draw-show-inactive-caret", scheme_make_integer(wxSNIP_DRAW_SHOW_INACTIVE_CARET), env);
+  scheme_install_xc_global("wx:const-snip-before-or-null", scheme_make_integer(wxSNIP_BEFORE_OR_NULL), env);
+  scheme_install_xc_global("wx:const-snip-before", scheme_make_integer(wxSNIP_BEFORE), env);
+  scheme_install_xc_global("wx:const-snip-after", scheme_make_integer(wxSNIP_AFTER), env);
+  scheme_install_xc_global("wx:const-snip-after-or-null", scheme_make_integer(wxSNIP_AFTER_OR_NULL), env);
+  scheme_install_xc_global("wx:const-break-for-caret", scheme_make_integer(wxBREAK_FOR_CARET), env);
+  scheme_install_xc_global("wx:const-break-for-line", scheme_make_integer(wxBREAK_FOR_LINE), env);
+  scheme_install_xc_global("wx:const-break-for-selection", scheme_make_integer(wxBREAK_FOR_SELECTION), env);
+  scheme_install_xc_global("wx:const-break-for-user-1", scheme_make_integer(wxBREAK_FOR_USER_1), env);
+  scheme_install_xc_global("wx:const-break-for-user-2", scheme_make_integer(wxBREAK_FOR_USER_2), env);
+  scheme_install_xc_global("wx:const-default-select", scheme_make_integer(wxDEFAULT_SELECT), env);
+  scheme_install_xc_global("wx:const-x-select", scheme_make_integer(wxX_SELECT), env);
+  scheme_install_xc_global("wx:const-local-select", scheme_make_integer(wxLOCAL_SELECT), env);
+}
+
+int objscheme_istype_wxMediaEdit(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaEdit_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-edit%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaEdit(class wxMediaEdit *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_EDIT) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaEdit_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaEdit *objscheme_unbundle_wxMediaEdit(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaEdit(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaEdit *)o->primdata;
+  else
+    return (wxMediaEdit *)o->primdata;
+}
+
+
+
diff --git a/src/mred/wxs/wxs_mede.h b/src/mred/wxs/wxs_mede.h
new file mode 100644
index 0000000..2845cfd
--- /dev/null
+++ b/src/mred/wxs/wxs_mede.h
@@ -0,0 +1,88 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxTabSnip *objscheme_unbundle_wxTabSnip(Scheme_Object *, const char *, int);
+extern class wxTextSnip *objscheme_unbundle_wxTextSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxImageSnip *objscheme_unbundle_wxImageSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBitmap(class wxBitmap *);
+extern Scheme_Object *objscheme_bundle_wxTabSnip(class wxTabSnip *);
+extern Scheme_Object *objscheme_bundle_wxTextSnip(class wxTextSnip *);
+extern Scheme_Object *objscheme_bundle_wxMediaWordbreakMap(class wxMediaWordbreakMap *);
+extern class wxMediaWordbreakMap *objscheme_unbundle_wxMediaWordbreakMap(Scheme_Object *, const char *, int);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern int objscheme_istype_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxImageSnip(class wxImageSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaEdit(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaEdit(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaEdit(class wxMediaEdit *realobj);
+class wxMediaEdit *objscheme_unbundle_wxMediaEdit(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_mede.xc b/src/mred/wxs/wxs_mede.xc
new file mode 100644
index 0000000..3aa8910
--- /dev/null
+++ b/src/mred/wxs/wxs_mede.xc
@@ -0,0 +1,278 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_media.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@SET TYPE = float
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@MACRO rNULL = return NULL;
+@MACRO rFALSE = return FALSE;
+@MACRO rZERO = return 0;
+
+@CLASSBASE wxMediaEdit "wx:media-edit" : "wx:media-buffer"
+
+@CREATOR (float=1.0,float[]=NULL/bList/ubList/cList,-int=0); : : /glueListSet[float.1.1.2."wx:media-edit%::initialization"]//
+
+@CLASSID wxTYPE_MEDIA_EDIT
+
+@VAR Scheme_Object *scroll_closure;
+
+@SETMARK X = 
+@SETMARK Y = d
+@SETMARK Z = d
+@INCLUDE wxs_mbuf.xci
+
+@ "get-position" : void GetPosition(long?,long?=NULL);
+@ "get-start-position" : long GetStartPosition();
+@ "get-end-position" : long GetEndPosition();
+@ "set-position" : void SetPosition(long,long=-1,bool=FALSE,bool=TRUE,int=wxDEFAULT_SELECT);
+@ "set-position-bias-scroll" : void SetPositionBiasScroll(int,long,long=-1,bool=FALSE,bool=TRUE,int=wxDEFAULT_SELECT);
+@ "move-position" :  void MovePosition(long,bool=FALSE,int=wxMOVE_SIMPLE);
+@ "scroll-to-position" : bool ScrollToPosition(long,bool=FALSE,long=-1,int=0);
+@ "get-visible-position-range" : void GetVisiblePositionRange(long?,long?);
+@ "get-visible-line-range" : void GetVisibleLineRange(long?,long?);
+
+@ v "set-anchor" : void SetAnchor(bool);
+@ "get-anchor" : bool GetAnchor();
+
+@ "flash-on" : void FlashOn(long,long,bool=FALSE,bool=TRUE,long=500);
+@ "flash-off" : void FlashOff();
+
+@MACRO setStringLen[i.s] = x<i> = SCHEME_STRTAG_VAL(p[<s>]);
+@MACRO checkStringLen[i.s] = if ((x<i> < 0) || (x<i> > SCHEME_STRTAG_VAL(p[<s>]))) scheme_signal_error("wx:media-edit%%::insert: bad string length");
+
+@ "insert" : void Insert(-long,string,long,long=-1,bool=TRUE);  : : /setStringLen[0.0] <> string and position
+@ "insert" : void Insert(-long,string);  : : /setStringLen[0.0] <> string without position
+@ "insert" : void Insert(long,string,long,long=-1,bool=TRUE);  : : /checkStringLen[0.1] <> length and string without position
+@ "insert" : void Insert(long,string);  : : /checkStringLen[0.1] <> length, string, and position
+@ "insert" : void Insert(wxSnip!,long,long=-1,bool=TRUE); <> wx:snip% and position
+@ "insert" : void Insert(uchar); <> character without position
+@ "insert" : void Insert(uchar,long,long=-1); <> character and position
+
+@ "delete" : void Delete(long, long=-1,bool=TRUE); <> position
+@ "delete" : void Delete(); <> no position
+@ "erase" :  void Erase();
+
+@ "cut" :  void Cut(bool,long,long,long=-1); <> position
+@ "copy" : void Copy(bool,long,long,long=-1); <> position
+@ "paste" : void Paste(long,long,long=-1); <> position
+@ "paste-next" : void PasteNext();
+@ "kill" : void Kill(long,long,long); <> position
+
+@ v "do-copy" : void DoCopy(long,long,long,bool);
+@ v "do-paste" : void DoPaste(long,long);
+
+@ "change-style" : void ChangeStyle(wxStyleDelta^,long,long=-1); <> wx:style-delta% and position
+@ "change-style" : void ChangeStyle(wxStyle^,long=-1,long=-1); <> wx:style%
+			
+@ "split-snip" : void SplitSnip(long);
+
+@ "find-position" : long FindPosition(float,float,bool?=NULL,bool?=NULL,float?=NULL);
+@ "find-line" : long FindLine(float,bool?=NULL);
+@ "find-position-in-line" : long FindPositionInLine(long,float,bool?=NULL,bool?=NULL,float?=NULL);
+
+@ "get-between-threshold" : float GetBetweenThreshold();
+@ "set-between-threshold" : void SetBetweenThreshold(float);
+
+@ "position-line" : long PositionLine(long,bool=FALSE);
+@ "position-location" :  void PositionLocation(long,float?=NULL,float?=NULL,bool=TRUE,bool=FALSE,bool=FALSE);
+@ "line-location" : float LineLocation(long,bool=TRUE);
+
+@ "line-start-position" : long LineStartPosition(long,bool=TRUE);
+@ "line-end-position" : long LineEndPosition(long,bool=TRUE);
+@ "line-length" : long LineLength(long);
+@ "last-position" : long LastPosition();
+@ "last-line" : long LastLine();
+
+@ "position-paragraph" : long PositionParagraph(long,bool=FALSE);
+@ "paragraph-start-position" : long ParagraphStartPosition(long,bool=TRUE);
+@ "paragraph-end-position" : long ParagraphEndPosition(long,bool=TRUE);
+@ "line-paragraph" : long LineParagraph(long);
+@ "paragraph-start-line" : long ParagraphStartLine(long);
+@ "pargraph-end-line" : long ParagraphEndLine(long);
+@ "last-paragraph" : long LastParagraph();
+
+@MACRO CHECKDIR[p] = if ((x<p> != 1) && (x<p> != -1)) scheme_signal_error("wx:media-edit%%::find-string: direction must be 1 or -1, given %d", x<p>);
+
+@ "find-string" : long FindString(string,int=1,long=-1,long=-1,bool=TRUE,bool=TRUE);  : : /CHECKDIR[1]
+
+@SET TYPE = long
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@ "find-string-all" : long[]/bReturnList[long.1] FindStringAll(string,-long*,int=1,long=-1,long=-1,bool=TRUE,bool=TRUE);
+
+@ "find-snip" : wxSnip^ FindSnip(long,int,long?=NULL)
+@ "get-snip-position-and-location" : void GetSnipPositionAndLocation(wxSnip!,long?,float?,float?);
+@ "get-snip-position" : long GetSnipPosition(wxSnip!);
+
+@MACRO makeNoCopyString[len] = scheme_make_sized_string(r, <len>, 0)
+
+@ "get-text" : string/makeNoCopyString[_x4] GetText(long=-1,long=-1,bool=FALSE,bool=FALSE,-long*=NULL);
+@ "get-character" : uchar GetCharacter(long);
+
+@ "insert-file" : bool InsertFile(string,int=wxMEDIA_FF_GUESS);
+
+@ "read-from-file" : bool ReadFromFile(wxMediaStreamIn%,long,bool=FALSE); <> with position
+@ "write-to-file" : bool WriteToFile(wxMediaStreamOut%,long,long=-1); <> with position
+
+@ "get-file-format" : int GetFileFormat();
+@ "set-file-format" : void SetFileFormat(int);
+
+@ "get-overwrite-mode" : bool GetOverwriteMode();
+@ "set-overwrite-mode" : void SetOverwriteMode(bool);
+
+@MACRO checkNull = if (!x0) x0 = &_x0;
+
+@ "get-tabs" : float[]/bReturnList[float.0] GetTabs(int?=NULL,float?=NULL,bool?=NULL); : : /checkNull/
+@ "set-tabs" : void SetTabs(float[]/bList/ubList/cList,-int,float=wxTAB_WIDTH,bool=TRUE); : : /glueListSet[float.0.0.1."wx:media-edit%::set-tabs"]//
+
+@ "add-editor-functions" : void AddEditorFunctions(wxKeymap!);
+
+@ v "on-insert" : bool OnInsert(long,long);
+@ v "after-insert" : void AfterInsert(long,long);
+@ v "on-delete" : bool OnDelete(long,long);
+@ v "after-delete" : void AfterDelete(long,long);
+@ v "on-change-style" : bool OnChangeStyle(long,long);
+@ v "after-change-style" : void AfterChangeStyle(long,long);
+@ v "after-set-position" : void AfterSetPosition();
+@ v "on-set-size-constraint" : bool OnSetSizeConstraint();
+@ v "after-set-size-constraint" : void AfterSetSizeConstraint();
+
+@ v "get-region-data" : wxBufferData^ GetRegionData(long,long);
+@ v "set-region-data" : void SetRegionData(long, long, wxBufferData^);
+
+@ "find-wordbreak" : void FindWordbreak(long?,long?,int);
+
+@ "set-wordbreak-map" : void SetWordbreakMap(wxMediaWordbreakMap^);
+@ "get-wordbreak-map" : wxMediaWordbreakMap^ GetWordbreakMap();
+
+@ "hide-caret" : void HideCaret(bool);
+@ "caret-hidden?" : bool CaretHidden();
+
+@ v "on-new-text-snip" : wxTextSnip! OnNewTextSnip();
+@ v "on-new-tab-snip" : wxTabSnip! OnNewTabSnip();
+
+@ "set-autowrap-bitmap" : wxBitmap^ SetAutowrapBitmap(wxBitmap^);
+
+static void WordbreakCallbackToScheme(wxMediaEdit *,long*,long*,int,Scheme_Object *);
+
+@MACRO ubCallback = (wxWordbreakFunc)WordbreakCallbackToScheme
+@MACRO ubData = p[0]
+@MACRO spCallback = (wxMediaEdit-object (box num) (box num) num -> void)
+
+@MACRO ubCallback2 = (wxClickbackFunc)ClickbackToScheme
+@MACRO ubData2 = p[2]
+@MACRO cCallback2 = SCHEME_PROCP({x})
+@MACRO spCallback2 = (wxMediaEdit-object num num -> void)
+
+@ "set-wordbreak-func" : void SetWordbreakFunc(wxWordbreakFunc//ubCallback/cCallback//spCallback,-unknown#void*//ubData);
+
+@ "set-clickback" : void SetClickback(long,long,wxClickbackFunc//ubCallback2/cCallback2//spCallback2,-unknown#void*//ubData2,wxStyleDelta^=NULL,bool=FALSE);
+@ "remove-clickback" : void RemoveClickback(long,long);
+
+static void WordbreakCallbackToScheme(wxMediaEdit *media,
+				      long *start, long *end,
+				      int reason,
+				      Scheme_Object *f)
+{
+  Scheme_Object *p[4], *s, *e;
+  jmp_buf savebuf;
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    p[0] = objscheme_bundle_wxMediaEdit(media);
+    if (start)
+      s = scheme_box(objscheme_bundle_integer(*start));
+    else
+      s = scheme_null;
+    if (end)
+      e = scheme_box(objscheme_bundle_integer(*end));
+    else
+      e = scheme_null;
+    p[1] = s;
+    p[2] = e;
+    p[3] = scheme_make_integer(reason);
+
+    scheme_apply(f, 4, p);
+    if (start)
+      *start = objscheme_unbundle_integer(scheme_unbox(s), "Scheme wordbreak callback");
+    if (end)
+      *end = objscheme_unbundle_integer(scheme_unbox(e), "Scheme wordbreak callback");
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+static void ClickbackToScheme(wxMediaEdit *media,
+			      long start, long end,
+			      Scheme_Object *f)
+{
+  Scheme_Object *p[3];
+  jmp_buf savebuf;
+
+  p[0] = objscheme_bundle_wxMediaEdit(media);
+  p[1] = objscheme_bundle_integer(start);
+  p[2] = objscheme_bundle_integer(end);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf))
+    scheme_apply(f, 3, p);
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+@CONSTANT "wx:const-edit-undo" : int wxEDIT_UNDO
+@CONSTANT "wx:const-edit-redo" : int wxEDIT_REDO
+@CONSTANT "wx:const-edit-clear" : int wxEDIT_CLEAR
+@CONSTANT "wx:const-edit-cut" : int wxEDIT_CUT
+@CONSTANT "wx:const-edit-copy" : int wxEDIT_COPY
+@CONSTANT "wx:const-edit-paste" : int wxEDIT_PASTE
+@CONSTANT "wx:const-edit-kill" : int wxEDIT_KILL
+@CONSTANT "wx:const-edit-insert-text-box" : int wxEDIT_INSERT_TEXT_BOX
+@CONSTANT "wx:const-edit-insert-graphic-box" : int wxEDIT_INSERT_GRAPHIC_BOX
+@CONSTANT "wx:const-edit-insert-image" : int wxEDIT_INSERT_IMAGE
+@CONSTANT "wx:const-edit-select-all" : int wxEDIT_SELECT_ALL
+
+@CONSTANT "wx:const-move-simple" : int wxMOVE_SIMPLE
+@CONSTANT "wx:const-move-line" : int wxMOVE_LINE
+@CONSTANT "wx:const-move-page" : int wxMOVE_PAGE
+@CONSTANT "wx:const-move-word" : int wxMOVE_WORD
+
+@CONSTANT "wx:const-media-ff-guess" : int wxMEDIA_FF_GUESS
+@CONSTANT "wx:const-media-ff-std" : int wxMEDIA_FF_STD
+@CONSTANT "wx:const-media-ff-text" : int wxMEDIA_FF_TEXT
+@CONSTANT "wx:const-media-ff-text-force-cr" : int wxMEDIA_FF_TEXT_FORCE_CR
+@CONSTANT "wx:const-media-ff-same" : int wxMEDIA_FF_SAME
+@CONSTANT "wx:const-media-ff-copy" : int wxMEDIA_FF_COPY
+
+@CONSTANT "wx:const-snip-draw-no-caret" : int wxSNIP_DRAW_NO_CARET
+@CONSTANT "wx:const-snip-draw-show-caret" : int wxSNIP_DRAW_SHOW_CARET
+@CONSTANT "wx:const-snip-draw-show-inactive-caret" : int wxSNIP_DRAW_SHOW_INACTIVE_CARET
+
+@CONSTANT "wx:const-snip-before-or-null" : int wxSNIP_BEFORE_OR_NULL
+@CONSTANT "wx:const-snip-before" : int wxSNIP_BEFORE
+@CONSTANT "wx:const-snip-after" : int wxSNIP_AFTER
+@CONSTANT "wx:const-snip-after-or-null" : int wxSNIP_AFTER_OR_NULL
+
+@CONSTANT "wx:const-break-for-caret" : int wxBREAK_FOR_CARET
+@CONSTANT "wx:const-break-for-line" : int wxBREAK_FOR_LINE
+@CONSTANT "wx:const-break-for-selection" : int wxBREAK_FOR_SELECTION
+@CONSTANT "wx:const-break-for-user-1" : int wxBREAK_FOR_USER_1
+@CONSTANT "wx:const-break-for-user-2" : int wxBREAK_FOR_USER_2
+
+@CONSTANT "wx:const-default-select" : int wxDEFAULT_SELECT
+@CONSTANT "wx:const-x-select" : int wxX_SELECT
+@CONSTANT "wx:const-local-select" : int wxLOCAL_SELECT
+
+@END
+
+
diff --git a/src/mred/wxs/wxs_medi.cxx b/src/mred/wxs/wxs_medi.cxx
new file mode 100644
index 0000000..c75e94c
--- /dev/null
+++ b/src/mred/wxs/wxs_medi.cxx
@@ -0,0 +1,4302 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_medi.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_media.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_medi.h"
+#include "wxscomon.h"
+
+
+static void *cconvert(wxMediaBuffer *b, double x, double y, int todc)
+{
+  double dcx, dcy;
+  wxMediaAdmin *admin;
+  Scheme_Object *a[2];
+
+  admin = b->GetAdmin();
+  if (admin) {
+    float dx, dy;
+    admin->GetDC(&dx, &dy);
+    if (!todc) {
+      dcx = dx + x;
+      dcy = dy + y;
+    } else {
+      dcx = x - dx;
+      dcy = y - dy;
+    }
+  } else {
+    dcx = x;
+    dcy = y;
+  }
+
+  a[0] = objscheme_bundle_double(dcx);
+  a[1] = objscheme_bundle_double(dcy);
+
+  return scheme_values(2, a);
+}
+
+static void *wxbBufferToDC(wxMediaBuffer *b, double x, double y)
+{
+  return cconvert(b, x, y, 1);
+}
+
+static void *wxbDCToBuffer(wxMediaBuffer *b, double x, double y)
+{
+  return cconvert(b, x, y, 0);
+}
+
+
+
+
+
+
+/* 
+   X = Not meant for virtual, defined in wxMediaEdit/wxMediaPasteboard
+       and overloaded there
+   Y = Virtual, defined in wxMediaEdit/wxMediaPasteboard
+   Z = Virtual, defined in wxMediaBuffer 
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// X are Methods not intended to be overriden by the user,
+// but acutally are implemented with virtual
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+class os_wxMediaBuffer : public wxMediaBuffer {
+ public:
+
+  ~os_wxMediaBuffer();
+  void GetViewSize(float* x0, float* x1);
+  class wxDC* GetDC();
+  nstring PutFile(nstring x0, nstring x1);
+  nstring GetFile(nstring x0);
+  void AfterEditSequence();
+  void OnEditSequence();
+  void AfterLoadFile(Bool x0);
+  Bool OnLoadFile(string x0, int x1);
+  void AfterSaveFile(Bool x0);
+  Bool OnSaveFile(string x0, int x1);
+  class wxSnip* OnNewBox(int x0);
+  class wxImageSnip* OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3);
+  void InvalidateBitmapCache(float x0 = 0.0, float x1 = 0.0, float x2 = -1.0, float x3 = -1.0);
+  void OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8);
+  Bool WriteFootersToFile(class wxMediaStreamOut& x0);
+  Bool WriteHeadersToFile(class wxMediaStreamOut& x0);
+  Bool ReadFooterFromFile(class wxMediaStreamIn& x0, string x1);
+  Bool ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1);
+  void SetFilename(string x0, Bool x1 = FALSE);
+  Bool ReleaseSnip(class wxSnip* x0);
+  void SetModified(Bool x0);
+  void SetSnipData(class wxSnip* x0, class wxBufferData* x1);
+  class wxBufferData* GetSnipData(class wxSnip* x0);
+  void NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4);
+  void Resized(class wxSnip* x0, Bool x1);
+  void SetCaretOwner(class wxSnip* x0, int x1 = wxFOCUS_IMMEDIATE);
+  Bool ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5);
+  void OnChange();
+  void OnFocus(Bool x0);
+  void OnDefaultChar(class wxKeyEvent& x0);
+  void OnDefaultEvent(class wxMouseEvent& x0);
+  void OnLocalChar(class wxKeyEvent& x0);
+  void OnLocalEvent(class wxMouseEvent& x0);
+  void SizeCacheInvalid();
+  void OwnCaret(Bool x0);
+  void Refresh(float x0, float x1, float x2, float x3, Bool x4);
+  class wxCursor* AdjustCursor(class wxMouseEvent& x0);
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+};
+
+Scheme_Object *os_wxMediaBuffer_class;
+
+os_wxMediaBuffer::~os_wxMediaBuffer()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMediaBuffer::GetViewSize(float* x0, float* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "get-view-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::GetViewSize(x0, x1);
+  } else {
+  
+  p[0] = ((x0) ? objscheme_box(scheme_make_double((*x0))) : scheme_null);
+  p[1] = ((x1) ? objscheme_box(scheme_make_double((*x1))) : scheme_null);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-buffer%::get-view-size"", extracting return value via box"), "wx:media-buffer%::get-view-size"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::get-view-size"", extracting return value via box"), "wx:media-buffer%::get-view-size"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxDC* os_wxMediaBuffer::GetDC()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "get-dc", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::GetDC();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxDC(v, "wx:media-buffer%::get-dc"", extracting return value", 0);
+  }
+}
+
+nstring os_wxMediaBuffer::PutFile(nstring x0, nstring x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "put-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::PutFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-buffer%::put-file"", extracting return value");
+  }
+}
+
+nstring os_wxMediaBuffer::GetFile(nstring x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "get-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::GetFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-buffer%::get-file"", extracting return value");
+  }
+}
+
+void os_wxMediaBuffer::AfterEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "after-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::AfterEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::OnEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::AfterLoadFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "after-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::AfterLoadFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaBuffer::OnLoadFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::OnLoadFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::on-load-file"", extracting return value");
+  }
+}
+
+void os_wxMediaBuffer::AfterSaveFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "after-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::AfterSaveFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaBuffer::OnSaveFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::OnSaveFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::on-save-file"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxMediaBuffer::OnNewBox(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-new-box", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::OnNewBox(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:media-buffer%::on-new-box"", extracting return value", 0);
+  }
+}
+
+class wxImageSnip* os_wxMediaBuffer::OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-new-image-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::OnNewImageSnip(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxImageSnip(v, "wx:media-buffer%::on-new-image-snip"", extracting return value", 0);
+  }
+}
+
+void os_wxMediaBuffer::InvalidateBitmapCache(float x0, float x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "invalidate-bitmap-cache", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  p[1] = objscheme_bundle_wxDC(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_integer(x8);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaBuffer::WriteFootersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "write-footers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::WriteFootersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::write-footers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaBuffer::WriteHeadersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "write-headers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::WriteHeadersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::write-headers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaBuffer::ReadFooterFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "read-footer-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::ReadFooterFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::read-footer-from-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaBuffer::ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "read-header-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaBuffer::ReadHeaderFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::read-header-from-file"", extracting return value");
+  }
+}
+
+void os_wxMediaBuffer::SetFilename(string x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "set-filename", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaBuffer::ReleaseSnip(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "release-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::release-snip"", extracting return value");
+  }
+}
+
+void os_wxMediaBuffer::SetModified(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "set-modified", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::SetModified(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::SetSnipData(class wxSnip* x0, class wxBufferData* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "set-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxBufferData(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxBufferData* os_wxMediaBuffer::GetSnipData(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "get-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxBufferData(v, "wx:media-buffer%::get-snip-data"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaBuffer::NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "needs-update", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::Resized(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "resized", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::SetCaretOwner(class wxSnip* x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "set-caret-owner", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaBuffer::ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "scroll-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = (x5 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-buffer%::scroll-to"", extracting return value");
+  }
+}
+
+void os_wxMediaBuffer::OnChange()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-change", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnFocus(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::OnFocus(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnDefaultChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-default-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnDefaultEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-default-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnLocalChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-local-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::OnLocalChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnLocalEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-local-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaBuffer::OnLocalEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::Refresh(float x0, float x1, float x2, float x3, Bool x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "refresh", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxMediaBuffer::AdjustCursor(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:media-buffer%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaBuffer::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaBuffer::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaBuffer_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferwxbDCToBuffer(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  void* r;
+  objscheme_check_valid(obj);
+  double x0;
+  double x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::dc-location-to-buffer-location");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::dc-location-to-buffer-location");
+
+  
+  r = wxbDCToBuffer(((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata), x0, x1);
+
+  
+  
+  return ((Scheme_Object *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferwxbBufferToDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  void* r;
+  objscheme_check_valid(obj);
+  double x0;
+  double x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::buffer-location-to-dc-location");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::buffer-location-to-dc-location");
+
+  
+  r = wxbBufferToDC(((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata), x0, x1);
+
+  
+  
+  return ((Scheme_Object *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetInactiveCaretThreshold(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::set-inactive-caret-threshold");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetInactiveCaretThreshold(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetInactiveCaretThreshold(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetInactiveCaretThreshold();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetFocusSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetFocusSnip();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferEndWriteHeaderFooterToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::end-write-header-footer-to-file", 0);
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::end-write-header-footer-to-file");
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->EndWriteHeaderFooterToFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferBeginWriteHeaderFooterToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+  string x1;
+  long _x2;
+  long* x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::begin-write-header-footer-to-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-buffer%::begin-write-header-footer-to-file");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-buffer%::begin-write-header-footer-to-file", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:media-buffer%::begin-write-header-footer-to-file"), "wx:media-buffer%::begin-write-header-footer-to-file");
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->BeginWriteHeaderFooterToFile(*x0, x1, x2);
+
+  
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferPrint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  nstring x0;
+  Bool x1;
+  Bool x2;
+  int x3;
+
+  
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::print");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::print");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::print");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:media-buffer%::print");
+  } else
+    x3 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Print(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferInsertImage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::insert-image");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::insert-image");
+  } else
+    x1 = -1;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::insert-image");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-buffer%::insert-image");
+  } else
+    x3 = TRUE;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->InsertImage(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferInsertBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::insert-box");
+  } else
+    x0 = wxEDIT_BUFFER;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->InsertBox(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetFilename(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  Bool _x0;
+  Bool* x0 = &_x0;
+
+  
+  if (n > 0) {
+    if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_bool(objscheme_unbox(p[0], "wx:media-buffer%::get-filename"), "wx:media-buffer%::get-filename");
+  } else
+    x0 = NULL;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetFilename(x0);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], (_x0 ? scheme_true : scheme_false));
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferModified(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Modified();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferLock(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::lock");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Lock(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxCursor* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxCursor(p[0], "wx:media-buffer%::set-cursor", 1);
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::set-cursor");
+  } else
+    x1 = TRUE;
+
+  if (x0 && !x0->Ok()) return scheme_void;
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetCursor(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetLoadOverwritesStyles(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetLoadOverwritesStyles();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetLoadOverwritesStyles(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::set-load-overwrites-styles");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetLoadOverwritesStyles(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetStyleList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleList* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleList(p[0], "wx:media-buffer%::set-style-list", 0);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetStyleList(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetStyleList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyleList* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetStyleList();
+
+  
+  
+  return objscheme_bundle_wxStyleList(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAddBufferFunctions(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-buffer%::add-buffer-functions", 0);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AddBufferFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetKeymap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxKeymap* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetKeymap();
+
+  
+  
+  return objscheme_bundle_wxKeymap(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetKeymap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-buffer%::set-keymap", 1);
+  } else
+    x0 = NULL;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetKeymap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-buffer%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAppendFontItems(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:media-buffer%::append-font-items", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::append-font-items");
+  } else
+    x1 = 0;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AppendFontItems(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAppendEditItems(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:media-buffer%::append-edit-items", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::append-edit-items");
+  } else
+    x1 = 0;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AppendEditItems(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetMaxUndoHistory(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetMaxUndoHistory();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetMaxUndoHistory(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::set-max-undo-history");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetMaxUndoHistory(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferClearUndos(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ClearUndos();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferRedo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Redo();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferUndo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Undo();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSelectAll(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SelectAll();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetViewSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-buffer%::get-view-size"), "wx:media-buffer%::get-view-size");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::get-view-size"), "wx:media-buffer%::get-view-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::GetViewSize(x0, x1);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetViewSize(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxDC* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::GetDC();
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetDC();
+
+  
+  
+  return objscheme_bundle_wxDC(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferLocalToGlobal(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-buffer%::local-to-global", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-buffer%::local-to-global"), "wx:media-buffer%::local-to-global");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-buffer%::local-to-global", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::local-to-global"), "wx:media-buffer%::local-to-global");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->LocalToGlobal(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGlobalToLocal(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-buffer%::global-to-local", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-buffer%::global-to-local"), "wx:media-buffer%::global-to-local");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-buffer%::global-to-local", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::global-to-local"), "wx:media-buffer%::global-to-local");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GlobalToLocal(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaAdmin(p[0], "wx:media-buffer%::set-admin", 1);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaAdmin* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetAdmin();
+
+  
+  
+  return objscheme_bundle_wxMediaAdmin(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferPrintToDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-buffer%::print-to-dc", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:media-buffer%::print-to-dc");
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->PrintToDC(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferFindScrollLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::find-scroll-line");
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->FindScrollLine(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferNumScrollLines(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->NumScrollLines();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferScrollLineLocation(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::scroll-line-location");
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ScrollLineLocation(x0);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetSnipLocation(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  Bool x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::get-snip-location", 0);
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::get-snip-location"), "wx:media-buffer%::get-snip-location");
+  } else
+    x1 = NULL;
+  if (n > 2) {
+    if (SCHEME_NULLP(p[2]))
+    x2 = NULL;
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-buffer%::get-snip-location"), "wx:media-buffer%::get-snip-location");
+  } else
+    x2 = NULL;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:media-buffer%::get-snip-location");
+  } else
+    x3 = FALSE;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetSnipLocation(x0, x1, x2, x3);
+
+  
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2 && !SCHEME_NULLP(p[2]))
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferRefreshDelayed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->RefreshDelayed();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferEndEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->EndEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferBeginEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::begin-edit-sequence");
+  } else
+    x0 = TRUE;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->BeginEditSequence(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferStyleHasChanged(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:media-buffer%::style-has-changed", 1);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->StyleHasChanged(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferWriteToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::write-to-file", 0);
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->WriteToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferReadFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-buffer%::read-from-file", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::read-from-file");
+  } else
+    x1 = FALSE;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ReadFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetMinHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::set-min-height");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetMinHeight(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetMaxHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::set-max-height");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetMaxHeight(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetMinHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetMinHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetMaxHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetMaxHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetMinWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::set-min-width");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetMinWidth(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetMaxWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::set-max-width");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetMaxWidth(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetMinWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetMinWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetMaxWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetMaxWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetSpace(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetSpace();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetDescent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetDescent();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-buffer%::get-extent"), "wx:media-buffer%::get-extent");
+  if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-buffer%::get-extent"), "wx:media-buffer%::get-extent");
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferCopySelf(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaBuffer* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->CopySelf();
+
+  
+  
+  return objscheme_bundle_wxMediaBuffer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferInsertFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+  Bool x2;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-buffer%::insert-file");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::insert-file");
+  } else
+    x1 = wxMEDIA_FF_GUESS;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::insert-file");
+  } else
+    x2 = TRUE;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->InsertFile(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  int x1;
+  Bool x2;
+
+  
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::save-file");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::save-file");
+  } else
+    x1 = wxMEDIA_FF_SAME;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::save-file");
+  } else
+    x2 = TRUE;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SaveFile(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  int x1;
+  Bool x2;
+
+  
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::load-file");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::load-file");
+  } else
+    x1 = wxMEDIA_FF_GUESS;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::load-file");
+  } else
+    x2 = TRUE;
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->LoadFile(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetFlattenedText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+
+  
+  r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetFlattenedText(x0);
+
+  
+  
+  return scheme_make_sized_string(r, _x0, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferPutFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  nstring x1;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::put-file");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:media-buffer%::put-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::PutFile(x0, x1);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->PutFile(x0, x1);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::get-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::GetFile(x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetFile(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAfterEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::AfterEditSequence();
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AfterEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnEditSequence();
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAfterLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::after-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::AfterLoadFile(x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AfterLoadFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-buffer%::on-load-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::on-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnLoadFile(x0, x1);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnLoadFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAfterSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::after-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::AfterSaveFile(x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AfterSaveFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-buffer%::on-save-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::on-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnSaveFile(x0, x1);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnSaveFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnNewBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::on-new-box");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnNewBox(x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnNewBox(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnNewImageSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxImageSnip* r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-buffer%::on-new-image-snip");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::on-new-image-snip");
+  x2 = objscheme_unbundle_bool(p[2], "wx:media-buffer%::on-new-image-snip");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-buffer%::on-new-image-snip");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnNewImageSnip(x0, x1, x2, x3);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnNewImageSnip(x0, x1, x2, x3);
+
+  
+  
+  return objscheme_bundle_wxImageSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferInvalidateBitmapCache(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::invalidate-bitmap-cache");
+  } else
+    x0 = 0.0;
+  if (n > 1) {
+    x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::invalidate-bitmap-cache");
+  } else
+    x1 = 0.0;
+  if (n > 2) {
+    x2 = objscheme_unbundle_float(p[2], "wx:media-buffer%::invalidate-bitmap-cache");
+  } else
+    x2 = -1.0;
+  if (n > 3) {
+    x3 = objscheme_unbundle_float(p[3], "wx:media-buffer%::invalidate-bitmap-cache");
+  } else
+    x3 = -1.0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->InvalidateBitmapCache(x0, x1, x2, x3);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->InvalidateBitmapCache(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  class wxDC* x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  int x8;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::on-paint");
+  x1 = objscheme_unbundle_wxDC(p[1], "wx:media-buffer%::on-paint", 0);
+  x2 = objscheme_unbundle_float(p[2], "wx:media-buffer%::on-paint");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-buffer%::on-paint");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-buffer%::on-paint");
+  x5 = objscheme_unbundle_float(p[5], "wx:media-buffer%::on-paint");
+  x6 = objscheme_unbundle_float(p[6], "wx:media-buffer%::on-paint");
+  x7 = objscheme_unbundle_float(p[7], "wx:media-buffer%::on-paint");
+  x8 = objscheme_unbundle_integer(p[8], "wx:media-buffer%::on-paint");
+
+  if (x1 && !x1->Ok()) scheme_signal_error("%s: bad bitmap", "wx:media-buffer%::on-paint");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferWriteFootersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::write-footers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::WriteFootersToFile(*x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->WriteFootersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferWriteHeadersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::write-headers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::WriteHeadersToFile(*x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->WriteHeadersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferReadFooterFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-buffer%::read-footer-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-buffer%::read-footer-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::ReadFooterFromFile(*x0, x1);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ReadFooterFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferReadHeaderFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-buffer%::read-header-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-buffer%::read-header-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::ReadHeaderFromFile(*x0, x1);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ReadHeaderFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetFilename(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  Bool x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-buffer%::set-filename");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::set-filename");
+  } else
+    x1 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetFilename(x0, x1);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetFilename(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferReleaseSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::release-snip", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetModified(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::set-modified");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::SetModified(x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetModified(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxBufferData* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::set-snip-data", 0);
+  x1 = objscheme_unbundle_wxBufferData(p[1], "wx:media-buffer%::set-snip-data", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetSnipData(x0, x1);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetSnipData(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferGetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferData* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::get-snip-data", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetSnipData(x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->GetSnipData(x0);
+
+  
+  
+  return objscheme_bundle_wxBufferData(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferNeedsUpdate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::needs-update", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::needs-update");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-buffer%::needs-update");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-buffer%::needs-update");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-buffer%::needs-update");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferResized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::resized", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-buffer%::resized");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSetCaretOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::set-caret-owner", 1);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::set-caret-owner");
+  } else
+    x1 = wxFOCUS_IMMEDIATE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferScrollTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  Bool x5;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::scroll-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::scroll-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-buffer%::scroll-to");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-buffer%::scroll-to");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-buffer%::scroll-to");
+  x5 = objscheme_unbundle_bool(p[5], "wx:media-buffer%::scroll-to");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnChange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnChange();
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnChange();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::on-focus");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnFocus(x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnFocus(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnDefaultChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-buffer%::on-default-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultChar(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnDefaultEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-buffer%::on-default-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultEvent(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnLocalChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-buffer%::on-local-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnLocalChar(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnLocalChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnLocalEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-buffer%::on-local-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->wxMediaBuffer::OnLocalEvent(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnLocalEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  Bool x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-buffer%::refresh");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-buffer%::refresh");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-buffer%::refresh");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-buffer%::refresh");
+  x4 = objscheme_unbundle_bool(p[4], "wx:media-buffer%::refresh");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Refresh(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Refresh(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-buffer%::adjust-cursor", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(*x0);
+  else
+    r = ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(*x0);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-buffer%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-buffer%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+  else
+    ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferKill(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::kill");
+  } else
+    x0 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Kill(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::paste");
+  } else
+    x0 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Paste(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  long x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::copy");
+  } else
+    x0 = FALSE;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::copy");
+  } else
+    x1 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferCut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  long x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::cut");
+  } else
+    x0 = FALSE;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::cut");
+  } else
+    x1 = 0;
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Cut(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-buffer%::insert", 0);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaBufferChangeStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:media-buffer%::change-style", 1);
+
+  
+  ((wxMediaBuffer *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMediaBuffer_GetbufferType(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-buffer-type", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMediaBuffer *)cobj->primdata)->wxMediaBuffer::bufferType;
+  else
+    v = ((wxMediaBuffer *)cobj->primdata)->bufferType;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxMediaBuffer_SetbufferType(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-buffer-type", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:media-buffer%::buffer-type");
+  ((wxMediaBuffer *)cobj->primdata)->bufferType = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaBuffer(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-buffer%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-buffer%");
+}
+
+void objscheme_setup_wxMediaBuffer(void *env)
+{
+if (os_wxMediaBuffer_class) {
+    objscheme_add_global_class(os_wxMediaBuffer_class,  "wx:media-buffer%", env);
+} else {
+  os_wxMediaBuffer_class = objscheme_def_prim_class(env, "wx:media-buffer%", "wx:object%", NULL, 111);
+
+  scheme_add_method_w_arity(os_wxMediaBuffer_class,"get-class-name",objscheme_classname_os_wxMediaBuffer, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "dc-location-to-buffer-location", os_wxMediaBufferwxbDCToBuffer, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "buffer-location-to-dc-location", os_wxMediaBufferwxbBufferToDC, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-inactive-caret-threshold", os_wxMediaBufferSetInactiveCaretThreshold, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-inactive-caret-threshold", os_wxMediaBufferGetInactiveCaretThreshold, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-focus-snip", os_wxMediaBufferGetFocusSnip, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "end-write-header-footer-to-file", os_wxMediaBufferEndWriteHeaderFooterToFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "begin-write-header-footer-to-file", os_wxMediaBufferBeginWriteHeaderFooterToFile, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "print", os_wxMediaBufferPrint, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "insert-image", os_wxMediaBufferInsertImage, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "insert-box", os_wxMediaBufferInsertBox, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-filename", os_wxMediaBufferGetFilename, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "modified?", os_wxMediaBufferModified, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "lock", os_wxMediaBufferLock, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-cursor", os_wxMediaBufferSetCursor, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-load-overwrites-styles", os_wxMediaBufferGetLoadOverwritesStyles, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-load-overwrites-styles", os_wxMediaBufferSetLoadOverwritesStyles, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-style-list", os_wxMediaBufferSetStyleList, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-style-list", os_wxMediaBufferGetStyleList, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "add-buffer-functions", os_wxMediaBufferAddBufferFunctions, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-keymap", os_wxMediaBufferGetKeymap, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-keymap", os_wxMediaBufferSetKeymap, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "do-font", os_wxMediaBufferDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "do-edit", os_wxMediaBufferDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "append-font-items", os_wxMediaBufferAppendFontItems, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "append-edit-items", os_wxMediaBufferAppendEditItems, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-max-undo-history", os_wxMediaBufferGetMaxUndoHistory, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-max-undo-history", os_wxMediaBufferSetMaxUndoHistory, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "clear-undos", os_wxMediaBufferClearUndos, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "redo", os_wxMediaBufferRedo, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "undo", os_wxMediaBufferUndo, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "select-all", os_wxMediaBufferSelectAll, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "clear", os_wxMediaBufferClear, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-view-size", os_wxMediaBufferGetViewSize, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-dc", os_wxMediaBufferGetDC, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "local-to-global", os_wxMediaBufferLocalToGlobal, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "global-to-local", os_wxMediaBufferGlobalToLocal, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-admin", os_wxMediaBufferSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-admin", os_wxMediaBufferGetAdmin, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "print-to-dc", os_wxMediaBufferPrintToDC, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "find-scroll-line", os_wxMediaBufferFindScrollLine, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "num-scroll-lines", os_wxMediaBufferNumScrollLines, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "scroll-line-location", os_wxMediaBufferScrollLineLocation, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-snip-location", os_wxMediaBufferGetSnipLocation, 1, 4);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "refresh-delayed?", os_wxMediaBufferRefreshDelayed, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "end-edit-sequence", os_wxMediaBufferEndEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "begin-edit-sequence", os_wxMediaBufferBeginEditSequence, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "style-has-changed", os_wxMediaBufferStyleHasChanged, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "write-to-file", os_wxMediaBufferWriteToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "read-from-file", os_wxMediaBufferReadFromFile, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-min-height", os_wxMediaBufferSetMinHeight, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-max-height", os_wxMediaBufferSetMaxHeight, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-min-height", os_wxMediaBufferGetMinHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-max-height", os_wxMediaBufferGetMaxHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-min-width", os_wxMediaBufferSetMinWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-max-width", os_wxMediaBufferSetMaxWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-min-width", os_wxMediaBufferGetMinWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-max-width", os_wxMediaBufferGetMaxWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-space", os_wxMediaBufferGetSpace, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-descent", os_wxMediaBufferGetDescent, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-extent", os_wxMediaBufferGetExtent, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "copy-self", os_wxMediaBufferCopySelf, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "insert-file", os_wxMediaBufferInsertFile, 1, 3);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "save-file", os_wxMediaBufferSaveFile, 0, 3);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "load-file", os_wxMediaBufferLoadFile, 0, 3);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-flattened-text", os_wxMediaBufferGetFlattenedText, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "put-file", os_wxMediaBufferPutFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-file", os_wxMediaBufferGetFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "after-edit-sequence", os_wxMediaBufferAfterEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-edit-sequence", os_wxMediaBufferOnEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "after-load-file", os_wxMediaBufferAfterLoadFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-load-file", os_wxMediaBufferOnLoadFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "after-save-file", os_wxMediaBufferAfterSaveFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-save-file", os_wxMediaBufferOnSaveFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-new-box", os_wxMediaBufferOnNewBox, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-new-image-snip", os_wxMediaBufferOnNewImageSnip, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "invalidate-bitmap-cache", os_wxMediaBufferInvalidateBitmapCache, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-paint", os_wxMediaBufferOnPaint, 9, 9);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "write-footers-to-file", os_wxMediaBufferWriteFootersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "write-headers-to-file", os_wxMediaBufferWriteHeadersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "read-footer-from-file", os_wxMediaBufferReadFooterFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "read-header-from-file", os_wxMediaBufferReadHeaderFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-filename", os_wxMediaBufferSetFilename, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "release-snip", os_wxMediaBufferReleaseSnip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-modified", os_wxMediaBufferSetModified, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-snip-data", os_wxMediaBufferSetSnipData, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "get-snip-data", os_wxMediaBufferGetSnipData, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "needs-update", os_wxMediaBufferNeedsUpdate, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "resized", os_wxMediaBufferResized, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "set-caret-owner", os_wxMediaBufferSetCaretOwner, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "scroll-to", os_wxMediaBufferScrollTo, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-change", os_wxMediaBufferOnChange, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-focus", os_wxMediaBufferOnFocus, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-default-char", os_wxMediaBufferOnDefaultChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-default-event", os_wxMediaBufferOnDefaultEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-local-char", os_wxMediaBufferOnLocalChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-local-event", os_wxMediaBufferOnLocalEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "size-cache-invalid", os_wxMediaBufferSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "own-caret", os_wxMediaBufferOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "refresh", os_wxMediaBufferRefresh, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "adjust-cursor", os_wxMediaBufferAdjustCursor, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-char", os_wxMediaBufferOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "on-event", os_wxMediaBufferOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "kill", os_wxMediaBufferKill, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "paste", os_wxMediaBufferPaste, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "copy", os_wxMediaBufferCopy, 0, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "cut", os_wxMediaBufferCut, 0, 2);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "insert", os_wxMediaBufferInsert, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaBuffer_class, "change-style", os_wxMediaBufferChangeStyle, 1, 1);
+
+  scheme_add_method_w_arity(os_wxMediaBuffer_class,"get-buffer-type", objscheme_wxMediaBuffer_GetbufferType, 0, 0);
+  scheme_add_method_w_arity(os_wxMediaBuffer_class,"set-buffer-type", objscheme_wxMediaBuffer_SetbufferType, 1, 1);
+
+  scheme_made_class(os_wxMediaBuffer_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaBuffer, wxTYPE_MEDIA_BUFFER);
+
+}
+  scheme_install_xc_global("wx:const-edit-buffer", scheme_make_integer(wxEDIT_BUFFER), env);
+  scheme_install_xc_global("wx:const-pasteboard-buffer", scheme_make_integer(wxPASTEBOARD_BUFFER), env);
+  scheme_install_xc_global("wx:const-focus-immediate", scheme_make_integer(wxFOCUS_IMMEDIATE), env);
+  scheme_install_xc_global("wx:const-focus-display", scheme_make_integer(wxFOCUS_DISPLAY), env);
+  scheme_install_xc_global("wx:const-focus-global", scheme_make_integer(wxFOCUS_GLOBAL), env);
+}
+
+int objscheme_istype_wxMediaBuffer(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaBuffer_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-buffer%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_BUFFER) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaBuffer_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaBuffer(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaBuffer *)o->primdata;
+  else
+    return (wxMediaBuffer *)o->primdata;
+}
+
+
+
+
+
+
+
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxGetTheBufferDataClassList(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferDataClassList* r;
+
+  
+
+  
+  r = wxGetTheBufferDataClassList();
+
+  
+  
+  return objscheme_bundle_wxBufferDataClassList(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxGetTheSnipClassList(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnipClassList* r;
+
+  
+
+  
+  r = wxGetTheSnipClassList();
+
+  
+  
+  return objscheme_bundle_wxSnipClassList(r);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxMediaSetXSelectionMode(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-buffer%::wx:media-set-x-selection-mode");
+
+  
+  wxMediaSetXSelectionMode(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxAddMediaPasteboardFunctions(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-buffer%::wx:add-media-pasteboard-functions", 0);
+
+  
+  wxAddMediaPasteboardFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxAddMediaEditorFunctions(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-buffer%::wx:add-media-editor-functions", 0);
+
+  
+  wxAddMediaEditorFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxAddMediaBufferFunctions(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-buffer%::wx:add-media-buffer-functions", 0);
+
+  
+  wxAddMediaBufferFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxWriteMediaGlobalFooter(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::wx:write-media-global-footer", 0);
+
+  
+  r = wxWriteMediaGlobalFooter(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxWriteMediaGlobalHeader(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-buffer%::wx:write-media-global-header", 0);
+
+  
+  r = wxWriteMediaGlobalHeader(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxReadMediaGlobalFooter(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  class wxMediaStreamIn* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-buffer%::wx:read-media-global-footer", 0);
+
+  
+  r = wxReadMediaGlobalFooter(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxReadMediaGlobalHeader(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  class wxMediaStreamIn* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-buffer%::wx:read-media-global-header", 0);
+
+  
+  r = wxReadMediaGlobalHeader(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxSetMediaPrintMargin(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long x0;
+  long x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-buffer%::wx:set-media-print-margin");
+  } else
+    x0 = -1;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-buffer%::wx:set-media-print-margin");
+  } else
+    x1 = -1;
+
+  
+  wxSetMediaPrintMargin(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *wxMediaGlobalwxGetMediaPrintMargin(int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long _x0;
+  long* x0 = &_x0;
+  long _x1;
+  long* x1 = &_x1;
+
+  
+  if (n > 0) {
+    if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-buffer%::wx:get-media-print-margin"), "wx:media-buffer%::wx:get-media-print-margin");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    if (SCHEME_NULLP(p[1]))
+    x1 = NULL;
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-buffer%::wx:get-media-print-margin"), "wx:media-buffer%::wx:get-media-print-margin");
+  } else
+    x1 = NULL;
+
+  
+  wxGetMediaPrintMargin(x0, x1);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1 && !SCHEME_NULLP(p[1]))
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+void objscheme_setup_wxMediaGlobal(void *env)
+{
+  scheme_install_xc_global("wx:get-the-buffer-data-class-list", scheme_make_prim_w_arity(wxMediaGlobalwxGetTheBufferDataClassList, "wx:get-the-buffer-data-class-list", 0, 0), env);
+  scheme_install_xc_global("wx:get-the-snip-class-list", scheme_make_prim_w_arity(wxMediaGlobalwxGetTheSnipClassList, "wx:get-the-snip-class-list", 0, 0), env);
+  scheme_install_xc_global("wx:media-set-x-selection-mode", scheme_make_prim_w_arity(wxMediaGlobalwxMediaSetXSelectionMode, "wx:media-set-x-selection-mode", 1, 1), env);
+  scheme_install_xc_global("wx:add-media-pasteboard-functions", scheme_make_prim_w_arity(wxMediaGlobalwxAddMediaPasteboardFunctions, "wx:add-media-pasteboard-functions", 1, 1), env);
+  scheme_install_xc_global("wx:add-media-editor-functions", scheme_make_prim_w_arity(wxMediaGlobalwxAddMediaEditorFunctions, "wx:add-media-editor-functions", 1, 1), env);
+  scheme_install_xc_global("wx:add-media-buffer-functions", scheme_make_prim_w_arity(wxMediaGlobalwxAddMediaBufferFunctions, "wx:add-media-buffer-functions", 1, 1), env);
+  scheme_install_xc_global("wx:write-media-global-footer", scheme_make_prim_w_arity(wxMediaGlobalwxWriteMediaGlobalFooter, "wx:write-media-global-footer", 1, 1), env);
+  scheme_install_xc_global("wx:write-media-global-header", scheme_make_prim_w_arity(wxMediaGlobalwxWriteMediaGlobalHeader, "wx:write-media-global-header", 1, 1), env);
+  scheme_install_xc_global("wx:read-media-global-footer", scheme_make_prim_w_arity(wxMediaGlobalwxReadMediaGlobalFooter, "wx:read-media-global-footer", 1, 1), env);
+  scheme_install_xc_global("wx:read-media-global-header", scheme_make_prim_w_arity(wxMediaGlobalwxReadMediaGlobalHeader, "wx:read-media-global-header", 1, 1), env);
+  scheme_install_xc_global("wx:set-media-print-margin", scheme_make_prim_w_arity(wxMediaGlobalwxSetMediaPrintMargin, "wx:set-media-print-margin", 0, 2), env);
+  scheme_install_xc_global("wx:get-media-print-margin", scheme_make_prim_w_arity(wxMediaGlobalwxGetMediaPrintMargin, "wx:get-media-print-margin", 0, 2), env);
+}
+
diff --git a/src/mred/wxs/wxs_medi.h b/src/mred/wxs/wxs_medi.h
new file mode 100644
index 0000000..2d4a66d
--- /dev/null
+++ b/src/mred/wxs/wxs_medi.h
@@ -0,0 +1,91 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxImageSnip *objscheme_unbundle_wxImageSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern class wxStyleList *objscheme_unbundle_wxStyleList(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyleList(class wxStyleList *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxKeymap(class wxKeymap *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxMediaAdmin *objscheme_unbundle_wxMediaAdmin(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMediaAdmin(class wxMediaAdmin *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxImageSnip(class wxImageSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaBuffer(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaBuffer(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *realobj);
+class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxBufferDataClassList(class wxBufferDataClassList *);
+extern Scheme_Object *objscheme_bundle_wxSnipClassList(class wxSnipClassList *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaGlobal(void *env);
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_medi.xc b/src/mred/wxs/wxs_medi.xc
new file mode 100644
index 0000000..7c38bc1
--- /dev/null
+++ b/src/mred/wxs/wxs_medi.xc
@@ -0,0 +1,191 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_media.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+static void *cconvert(wxMediaBuffer *b, double x, double y, int todc)
+{
+  double dcx, dcy;
+  wxMediaAdmin *admin;
+  Scheme_Object *a[2];
+
+  admin = b->GetAdmin();
+  if (admin) {
+    float dx, dy;
+    admin->GetDC(&dx, &dy);
+    if (!todc) {
+      dcx = dx + x;
+      dcy = dy + y;
+    } else {
+      dcx = x - dx;
+      dcy = y - dy;
+    }
+  } else {
+    dcx = x;
+    dcy = y;
+  }
+
+  a[0] = objscheme_bundle_double(dcx);
+  a[1] = objscheme_bundle_double(dcy);
+
+  return scheme_values(2, a);
+}
+
+static void *wxbBufferToDC(wxMediaBuffer *b, double x, double y)
+{
+  return cconvert(b, x, y, 1);
+}
+
+static void *wxbDCToBuffer(wxMediaBuffer *b, double x, double y)
+{
+  return cconvert(b, x, y, 0);
+}
+
+@MACRO rNULL = return NULL;
+@MACRO rFALSE = return FALSE;
+@MACRO rZERO = return 0;
+
+@CLASSBASE wxMediaBuffer "wx:media-buffer" : "wx:object"
+
+@CLASSID wxTYPE_MEDIA_BUFFER
+
+@IVAR "buffer-type" : int bufferType
+
+@SETMARK Y = V
+@SETMARK Z = v
+@INCLUDE wxs_mbuf.xci
+
+// X are Methods not intended to be overriden by the user,
+// but acutally are implemented with virtual
+@SETMARK X = D
+
+@ X "load-file" : bool LoadFile(nstring=NULL,int=wxMEDIA_FF_GUESS,bool=TRUE);
+@ X "save-file" : bool SaveFile(nstring=NULL,int=wxMEDIA_FF_SAME,bool=TRUE);
+@ X "insert-file" : bool InsertFile(string,int=wxMEDIA_FF_GUESS,bool=TRUE);
+
+@ X "copy-self" : wxMediaBuffer! CopySelf(); : : : : XrZERO
+
+@ X "get-extent" : void GetExtent(float?,float?);
+@ X "get-descent" : float GetDescent(); : : : : XrZERO
+@ X "get-space" : float GetSpace(); : : : : XrZERO
+
+@ X "get-max-width" : float GetMaxWidth(); : : : : XrZERO
+@ X "get-min-width" : float GetMinWidth(); : : : : XrZERO
+@ X "set-max-width" : void SetMaxWidth(float);
+@ X "set-min-width" : void SetMinWidth(float);
+@ X "get-max-height" : float GetMaxHeight(); : : : : XrZERO
+@ X "get-min-height" : float GetMinHeight(); : : : : XrZERO
+@ X "set-max-height" : void SetMaxHeight(float);
+@ X "set-min-height" : void SetMinHeight(float);
+
+@ X "read-from-file" : bool ReadFromFile(wxMediaStreamIn%); : : : : XrZERO
+@ X "write-to-file" : bool WriteToFile(wxMediaStreamOut%); : : : : XrZERO
+
+@ X "style-has-changed" : void StyleHasChanged(wxStyle^);
+
+@ X "begin-edit-sequence" : void BeginEditSequence(bool=TRUE);
+@ X "end-edit-sequence" : void EndEditSequence();
+@ X "refresh-delayed?" : bool RefreshDelayed();
+
+@ X "get-snip-location" : bool GetSnipLocation(wxSnip!,float?=NULL,float?=NULL,bool=FALSE); : : : : XrZERO
+
+@ X "scroll-line-location" : float ScrollLineLocation(long); : : : : XrZERO
+@ X "num-scroll-lines" : long NumScrollLines(); : : : : XrZERO
+@ X "find-scroll-line" : long FindScrollLine(float); : : : : XrZERO
+
+@ X "print-to-dc" : void PrintToDC(wxDC!); : : /CHECKOK[0."wx:media-buffer%::print-to-dc"]
+
+@ X "get-admin" : wxMediaAdmin^ GetAdmin(); : : : rNULL
+@ X "set-admin" : void SetAdmin(wxMediaAdmin^);
+
+
+@ "global-to-local" : void GlobalToLocal(float*,float*);
+@ "local-to-global" : void LocalToGlobal(float*,float*);
+
+@ v "get-dc" : wxDC! GetDC();
+@ v "get-view-size" : void GetViewSize(float?,float?);
+
+@ "clear" : void Clear();
+@ "select-all" : void SelectAll();
+
+@ "undo" :  void Undo();
+@ "redo": void Redo()
+@ "clear-undos" : void ClearUndos();
+
+@ "set-max-undo-history" : void SetMaxUndoHistory(int);
+@ "get-max-undo-history" : int GetMaxUndoHistory();
+
+@ "append-edit-items" : int AppendEditItems(wxMenu!,int=0);
+@ "append-font-items" : int AppendFontItems(wxMenu!,int=0);
+@ "do-edit" : void DoEdit(int,bool=TRUE,long=0);
+@ "do-font" : void DoFont(int,bool=TRUE);
+
+@ "set-keymap" : void SetKeymap(wxKeymap^=NULL);
+@ "get-keymap" : wxKeymap! GetKeymap();
+
+@ "add-buffer-functions" : void AddBufferFunctions(wxKeymap!);
+
+@ "get-style-list" : wxStyleList! GetStyleList();
+@ "set-style-list" : void SetStyleList(wxStyleList!);
+
+@ "set-load-overwrites-styles" : void SetLoadOverwritesStyles(bool)
+@ "get-load-overwrites-styles" : bool GetLoadOverwritesStyles();
+
+@ "set-cursor" : void SetCursor(wxCursor^,bool=TRUE); : : /CHECKVOIDABLEOK[0]
+
+@ "lock" : void Lock(bool);
+@ "modified?" : bool Modified();
+
+@ "get-filename" : nstring GetFilename(bool?=NULL);
+
+@ "insert-box" : void InsertBox(int=wxEDIT_BUFFER);
+@ "insert-image" : void InsertImage(nstring=NULL,long=-1,bool=FALSE,bool=TRUE);
+
+@ "print" : void Print(nstring=NULL,bool=TRUE,bool=FALSE,int=0);
+
+@ "begin-write-header-footer-to-file" : bool BeginWriteHeaderFooterToFile(wxMediaStreamOut%,string,long*);
+@ "end-write-header-footer-to-file" : bool EndWriteHeaderFooterToFile(wxMediaStreamOut%,long);
+
+@ "get-focus-snip" : wxSnip^ GetFocusSnip();
+
+@ "get-inactive-caret-threshold" : int GetInactiveCaretThreshold();
+@ "set-inactive-caret-threshold" : void SetInactiveCaretThreshold(int);
+
+@MACRO bundleAny = ((Scheme_Object *){x})
+ 
+@ m "buffer-location-to-dc-location" : void*/bundleAny wxbBufferToDC(double, double);
+@ m "dc-location-to-buffer-location" : void*/bundleAny wxbDCToBuffer(double, double);
+
+@CONSTANT "wx:const-edit-buffer" : int wxEDIT_BUFFER
+@CONSTANT "wx:const-pasteboard-buffer" : int wxPASTEBOARD_BUFFER
+
+@CONSTANT "wx:const-focus-immediate" : int wxFOCUS_IMMEDIATE
+@CONSTANT "wx:const-focus-display" : int wxFOCUS_DISPLAY
+@CONSTANT "wx:const-focus-global" : int wxFOCUS_GLOBAL
+
+@END
+
+@GLOBAL wxMediaGlobal
+
+@ "wx:get-media-print-margin" : void wxGetMediaPrintMargin(long?=NULL,long?=NULL);
+@ "wx:set-media-print-margin" : void wxSetMediaPrintMargin(long=-1,long=-1);
+
+@ "wx:read-media-global-header" : bool wxReadMediaGlobalHeader(wxMediaStreamIn%);
+@ "wx:read-media-global-footer" : bool wxReadMediaGlobalFooter(wxMediaStreamIn%);
+@ "wx:write-media-global-header" : bool wxWriteMediaGlobalHeader(wxMediaStreamOut%);
+@ "wx:write-media-global-footer" : bool wxWriteMediaGlobalFooter(wxMediaStreamOut%);
+
+@ "wx:add-media-buffer-functions" : void wxAddMediaBufferFunctions(wxKeymap!);
+@ "wx:add-media-editor-functions" : void wxAddMediaEditorFunctions(wxKeymap!);
+@ "wx:add-media-pasteboard-functions" : void wxAddMediaPasteboardFunctions(wxKeymap!);
+
+@ "wx:media-set-x-selection-mode" : void wxMediaSetXSelectionMode(bool);
+
+@ "wx:get-the-snip-class-list" : wxSnipClassList! wxGetTheSnipClassList()
+@ "wx:get-the-buffer-data-class-list" : wxBufferDataClassList! wxGetTheBufferDataClassList()
+
+@END
diff --git a/src/mred/wxs/wxs_menu.cxx b/src/mred/wxs/wxs_menu.cxx
new file mode 100644
index 0000000..78ddd3a
--- /dev/null
+++ b/src/mred/wxs/wxs_menu.cxx
@@ -0,0 +1,1139 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_menu.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_menu.h"
+
+#include "wxscheme.h"
+#include "wxs_menu.h"
+#include "wxscomon.h"
+
+
+
+
+
+
+// @CLASSBASE wxMenuItem "wx:menu-item" : "wx:object"
+// @END
+
+// wxMenu is really derived from wxItem
+//  but that makes no sense. Enforce different hierarchy here
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxMenu
+#define CB_REALCLASS wxMenu
+#define CB_UNBUNDLE objscheme_unbundle_wxMenu
+#define CB_USER "wx:menu%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxMenuCallbackToScheme
+#define CB_TOC wxMenuCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+// @ "find-item-for-id" : wxMenuItem^ FindItemForId(int);
+
+
+class os_wxMenu : public wxMenu {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxMenu(Scheme_Object * obj, nstring x0 = NULL, wxFunction x1 = NULL);
+  ~os_wxMenu();
+};
+
+Scheme_Object *os_wxMenu_class;
+
+os_wxMenu::os_wxMenu(Scheme_Object * o, nstring x0, wxFunction x1)
+: wxMenu(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMenu::~os_wxMenu()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuSetTitle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:menu%::set-title");
+
+  
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->SetTitle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::set-label");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:menu%::set-label");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuSetHelpString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  nstring x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::set-help-string");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:menu%::set-help-string");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->SetHelpString(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuGetTitle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->GetTitle();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuGetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::get-label");
+
+  if (x0 < 0) return scheme_null;
+  r = ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->GetLabel(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuGetHelpString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::get-help-string");
+
+  if (x0 < 0) return scheme_null;
+  r = ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->GetHelpString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuFindItem(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:menu%::find-item");
+
+  
+  r = ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->FindItem(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuEnable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::enable");
+  x1 = objscheme_unbundle_bool(p[1], "wx:menu%::enable");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Enable(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuCheck(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::check");
+  x1 = objscheme_unbundle_bool(p[1], "wx:menu%::check");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Check(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuChecked(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::checked?");
+
+  if (x0 < 0) return scheme_false;
+  r = ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Checked(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuAppendSeparator(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->AppendSeparator();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuDeleteByPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::delete-by-position");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->DeleteByPosition(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu%::delete");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Delete(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuAppend(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 3) && objscheme_istype_number(p[0], NULL) && objscheme_istype_string(p[1], NULL) && objscheme_istype_wxMenu(p[2], NULL, 0)) {
+    int x0;
+    string x1;
+    class wxMenu* x2;
+    nstring x3;
+
+    
+    if ((n < 3) ||(n > 4)) 
+      scheme_wrong_count("wx:menu%::append (submenu case)", 3, 4, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:menu%::append (submenu case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:menu%::append (submenu case)");
+    x2 = objscheme_unbundle_wxMenu(p[2], "wx:menu%::append (submenu case)", 0);
+    if (n > 3) {
+      x3 = (nstring)objscheme_unbundle_nullable_string(p[3], "wx:menu%::append (submenu case)");
+    } else
+      x3 = NULL;
+
+    if (x0 < 0) return scheme_void;
+    ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Append(x0, x1, x2, x3);
+
+    
+    
+  } else  {
+    int x0;
+    string x1;
+    nstring x2;
+    Bool x3;
+
+    
+    if ((n < 2) ||(n > 4)) 
+      scheme_wrong_count("wx:menu%::append (string item case)", 2, 4, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:menu%::append (string item case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:menu%::append (string item case)");
+    if (n > 2) {
+      x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:menu%::append (string item case)");
+    } else
+      x2 = NULL;
+    if (n > 3) {
+      x3 = objscheme_unbundle_bool(p[3], "wx:menu%::append (string item case)");
+    } else
+      x3 = FALSE;
+
+    if (x0 < 0) return scheme_void;
+    ((wxMenu *)((Scheme_Class_Object *)obj)->primdata)->Append(x0, x1, x2, x3);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenu_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMenu *realobj;
+  nstring x0;
+  wxFunction x1;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n > 2)) 
+    scheme_wrong_count("wx:menu%::initialization", 0, 2, n, p);
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:menu%::initialization");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  } else
+    x1 = NULL;
+
+  
+  realobj = new os_wxMenu(obj, x0, x1);
+  
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMenu(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:menu%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:menu%");
+}
+
+void objscheme_setup_wxMenu(void *env)
+{
+if (os_wxMenu_class) {
+    objscheme_add_global_class(os_wxMenu_class,  "wx:menu%", env);
+} else {
+  os_wxMenu_class = objscheme_def_prim_class(env, "wx:menu%", "wx:object%", os_wxMenu_ConstructScheme, 15);
+
+  scheme_add_method_w_arity(os_wxMenu_class,"get-class-name",objscheme_classname_os_wxMenu, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMenu_class, "set-title", os_wxMenuSetTitle, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "set-label", os_wxMenuSetLabel, 2, 2);
+ scheme_add_method_w_arity(os_wxMenu_class, "set-help-string", os_wxMenuSetHelpString, 2, 2);
+ scheme_add_method_w_arity(os_wxMenu_class, "get-title", os_wxMenuGetTitle, 0, 0);
+ scheme_add_method_w_arity(os_wxMenu_class, "get-label", os_wxMenuGetLabel, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "get-help-string", os_wxMenuGetHelpString, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "find-item", os_wxMenuFindItem, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "enable", os_wxMenuEnable, 2, 2);
+ scheme_add_method_w_arity(os_wxMenu_class, "check", os_wxMenuCheck, 2, 2);
+ scheme_add_method_w_arity(os_wxMenu_class, "checked?", os_wxMenuChecked, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "append-separator", os_wxMenuAppendSeparator, 0, 0);
+ scheme_add_method_w_arity(os_wxMenu_class, "delete-by-position", os_wxMenuDeleteByPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxMenu_class, "delete", os_wxMenuDelete, 1, 1);
+ scheme_add_method(os_wxMenu_class, "append", os_wxMenuAppend);
+
+
+  scheme_made_class(os_wxMenu_class);
+
+
+}
+}
+
+int objscheme_istype_wxMenu(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMenu_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:menu%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMenu(class wxMenu *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMenu_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMenu(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMenu *)o->primdata;
+  else
+    return (wxMenu *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+// wxMenuBar is really derived from wxItem
+//  but that makes no sense. Enforce different hierarchy here
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE string
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_string
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_string
+#define l_MAKE_LIST __MakestringList
+#define l_MAKE_ARRAY __MakestringArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT *
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE wxMenu
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxMenu
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxMenu
+#define l_MAKE_LIST __MakewxMenuList
+#define l_MAKE_ARRAY __MakewxMenuArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+
+
+
+// @ "find-item-for-id" : wxMenuItem^ FindItemForId(int);
+
+
+// @ "set-title" : void SetTitle(string);
+
+class os_wxMenuBar : public wxMenuBar {
+ public:
+
+  os_wxMenuBar(Scheme_Object * obj);
+  os_wxMenuBar(Scheme_Object * obj, int x0, wxMenu** x1, string* x2);
+  ~os_wxMenuBar();
+};
+
+Scheme_Object *os_wxMenuBar_class;
+
+os_wxMenuBar::os_wxMenuBar(Scheme_Object * o)
+: wxMenuBar()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMenuBar::os_wxMenuBar(Scheme_Object * o, int x0, wxMenu** x1, string* x2)
+: wxMenuBar(x0, x1, x2)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMenuBar::~os_wxMenuBar()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarSetLabelTop(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::set-label-top");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:menu-bar%::set-label-top");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->SetLabelTop(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarSetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::set-label");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:menu-bar%::set-label");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->SetLabel(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarSetHelpString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  nstring x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::set-help-string");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:menu-bar%::set-help-string");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->SetHelpString(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarGetTitle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->GetTitle();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarGetLabelTop(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::get-label-top");
+
+  if (x0 < 0) return scheme_null;
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->GetLabelTop(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarGetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::get-label");
+
+  if (x0 < 0) return scheme_null;
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->GetLabel(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarGetHelpString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::get-help-string");
+
+  if (x0 < 0) return scheme_null;
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->GetHelpString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarFindMenuItem(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+  string x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:menu-bar%::find-menu-item");
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:menu-bar%::find-menu-item");
+
+  
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->FindMenuItem(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarEnableTop(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::enable-top");
+  x1 = objscheme_unbundle_bool(p[1], "wx:menu-bar%::enable-top");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->EnableTop(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarEnable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::enable");
+  x1 = objscheme_unbundle_bool(p[1], "wx:menu-bar%::enable");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->Enable(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarChecked(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::checked?");
+
+  if (x0 < 0) return scheme_false;
+  r = ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->Checked(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarCheck(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:menu-bar%::check");
+  x1 = objscheme_unbundle_bool(p[1], "wx:menu-bar%::check");
+
+  if (x0 < 0) return scheme_void;
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->Check(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:menu-bar%::delete", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:menu-bar%::delete");
+  } else
+    x1 = 0;
+
+  
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->Delete(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBarAppend(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:menu-bar%::append", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:menu-bar%::append");
+
+  
+  ((wxMenuBar *)((Scheme_Class_Object *)obj)->primdata)->Append(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMenuBar_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMenuBar *realobj;
+  if ((n >= 1) && SCHEME_LISTP(p[0])) {
+    int x0;
+    wxMenu** x1;
+    string* x2;
+
+    if (scheme_proper_list_length(p[0]) != scheme_proper_list_length(p[1])) scheme_signal_error("wx:menu-bar%%::initialization: list size mismatch");
+    if (n != 2) 
+      scheme_wrong_count("wx:menu-bar%::initialization (wx:menu% list case)", 2, 2, n, p);
+    x1 = NULL;
+    x2 = NULL;
+
+    x1 = __MakewxMenuArray((0 < n) ? p[0] : scheme_null, &x0, "wx:menu-bar%::initialization");x2 = __MakestringArray((1 < n) ? p[1] : scheme_null, &x0, "wx:menu-bar%::initialization");
+    realobj = new os_wxMenuBar(obj, x0, x1, x2);
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:menu-bar%::initialization (no argument case)", 0, 0, n, p);
+
+    
+    realobj = new os_wxMenuBar(obj);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMenuBar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:menu-bar%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:menu-bar%");
+}
+
+void objscheme_setup_wxMenuBar(void *env)
+{
+if (os_wxMenuBar_class) {
+    objscheme_add_global_class(os_wxMenuBar_class,  "wx:menu-bar%", env);
+} else {
+  os_wxMenuBar_class = objscheme_def_prim_class(env, "wx:menu-bar%", "wx:object%", os_wxMenuBar_ConstructScheme, 15);
+
+  scheme_add_method_w_arity(os_wxMenuBar_class,"get-class-name",objscheme_classname_os_wxMenuBar, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMenuBar_class, "set-label-top", os_wxMenuBarSetLabelTop, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "set-label", os_wxMenuBarSetLabel, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "set-help-string", os_wxMenuBarSetHelpString, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "get-title", os_wxMenuBarGetTitle, 0, 0);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "get-label-top", os_wxMenuBarGetLabelTop, 1, 1);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "get-label", os_wxMenuBarGetLabel, 1, 1);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "get-help-string", os_wxMenuBarGetHelpString, 1, 1);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "find-menu-item", os_wxMenuBarFindMenuItem, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "enable-top", os_wxMenuBarEnableTop, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "enable", os_wxMenuBarEnable, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "checked?", os_wxMenuBarChecked, 1, 1);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "check", os_wxMenuBarCheck, 2, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "delete", os_wxMenuBarDelete, 1, 2);
+ scheme_add_method_w_arity(os_wxMenuBar_class, "append", os_wxMenuBarAppend, 2, 2);
+
+
+  scheme_made_class(os_wxMenuBar_class);
+
+
+}
+}
+
+int objscheme_istype_wxMenuBar(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMenuBar_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:menu-bar%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMenuBar(class wxMenuBar *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMenuBar_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMenuBar *objscheme_unbundle_wxMenuBar(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMenuBar(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMenuBar *)o->primdata;
+  else
+    return (wxMenuBar *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_menu.h b/src/mred/wxs/wxs_menu.h
new file mode 100644
index 0000000..aedb006
--- /dev/null
+++ b/src/mred/wxs/wxs_menu.h
@@ -0,0 +1,18 @@
+#ifndef WXS_SETUP_ONLY
+extern int objscheme_istype_wxMenu(Scheme_Object *, const char *, int);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMenu(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMenu(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMenu(class wxMenu *realobj);
+class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMenuBar(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMenuBar(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMenuBar(class wxMenuBar *realobj);
+class wxMenuBar *objscheme_unbundle_wxMenuBar(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_menu.xc b/src/mred/wxs/wxs_menu.xc
new file mode 100644
index 0000000..36fdea7
--- /dev/null
+++ b/src/mred/wxs/wxs_menu.xc
@@ -0,0 +1,90 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_menu.h"
+
+@HEADER
+
+@INCLUDE wxs.xci
+
+// @CLASSBASE wxMenuItem "wx:menu-item" : "wx:object"
+// @END
+
+// wxMenu is really derived from wxItem
+//  but that makes no sense. Enforce different hierarchy here
+@CLASSBASE wxMenu "wx:menu" : "wx:object"
+
+@SET CALLBACK_CLASS = wxMenu
+@SET CALLBACK_CLASS_USER = "wx:menu%::initialization"
+@INCLUDE cb_start.xci
+
+@MACRO CHECKNEG[pos.result] = if (x<pos> < 0) return <result>;
+@MACRO CHECKNEGVOID[pos] = $$CHECKNEG[<pos>.scheme_void]
+@MACRO CHECKNEGNULL[pos] = $$CHECKNEG[<pos>.scheme_null]
+@MACRO CHECKNEGFALSE[pos] = $$CHECKNEG[<pos>.scheme_false]
+
+@CREATOR (nstring=NULL,wxFunction=NULL/bCallback/ubCallback/cCallback//spCallback); : : ubCallbackSetup///ubCallbackCreatorFinish
+
+@ "append" : void Append(int,string,wxMenu!,nstring=NULL); : : /CHECKNEGVOID[0] <> submenu
+@ "append" : void Append(int,string,nstring=NULL,bool=FALSE); : : /CHECKNEGVOID[0] <> string item
+@ "delete" : void Delete(int); : : /CHECKNEGVOID[0]
+@ "delete-by-position" : void DeleteByPosition(int); : : /CHECKNEGVOID[0]
+@ "append-separator" : void AppendSeparator();
+@ "checked?" : bool Checked(int); : : /CHECKNEGFALSE[0]
+@ "check" : void Check(int,bool); : : /CHECKNEGVOID[0]
+@ "enable" : void Enable(int,bool); : : /CHECKNEGVOID[0]
+
+@ "find-item" : int FindItem(string);
+// @ "find-item-for-id" : wxMenuItem^ FindItemForId(int);
+@ "get-help-string" : nstring GetHelpString(int); : : /CHECKNEGNULL[0]
+@ "get-label" : nstring GetLabel(int); : : /CHECKNEGNULL[0]
+@ "get-title" : nstring GetTitle();
+
+@ "set-help-string" : void SetHelpString(int, nstring); : : /CHECKNEGVOID[0]
+@ "set-label" : void SetLabel(int, string); : : /CHECKNEGVOID[0]
+@ "set-title" : void SetTitle(string);
+
+@END
+
+@INCLUDE cb_end.xci
+
+// wxMenuBar is really derived from wxItem
+//  but that makes no sense. Enforce different hierarchy here
+@CLASSBASE wxMenuBar "wx:menu-bar" : "wx:object"
+
+@SET TYPE = string
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@SET TYPE = wxMenu
+@SET POINTERS = 1
+@INCLUDE list.xci
+
+@MACRO CHECKSAMELENGTH = if (scheme_proper_list_length(p[0]) != scheme_proper_list_length(p[1])) scheme_signal_error("wx:menu-bar%%::initialization: list size mismatch");
+
+@MACRO spMenuList = (listof wxMenu-object)
+
+@CREATOR (); <> no argument
+@CREATOR (-int, wxMenu*[]/bList/ubList/cList//spMenuList, string[]/bList/ubList/cList); : : CHECKSAMELENGTH/glueListSet[wxMenu.0.1.0."wx:menu-bar%::initialization"] | glueListSet[string.1.2.0."wx:menu-bar%::initialization"]// <> wx:menu% list
+
+@ "append" : void Append(wxMenu!,string);
+@ "delete" : void Delete(wxMenu!,int=0);
+@ "check" : void Check(int,bool); : : /CHECKNEGVOID[0]
+@ "checked?" : bool Checked(int); : : /CHECKNEGFALSE[0]
+@ "enable" : void Enable(int,bool); : : /CHECKNEGVOID[0]
+@ "enable-top" : void EnableTop(int,bool); : : /CHECKNEGVOID[0]
+
+@ "find-menu-item" : int FindMenuItem(string,string);
+// @ "find-item-for-id" : wxMenuItem^ FindItemForId(int);
+
+@ "get-help-string" : nstring GetHelpString(int); : : /CHECKNEGNULL[0]
+@ "get-label" : nstring GetLabel(int); : : /CHECKNEGNULL[0]
+@ "get-label-top" : nstring GetLabelTop(int); : : /CHECKNEGNULL[0]
+@ "get-title" : nstring GetTitle();
+
+@ "set-help-string" : void SetHelpString(int, nstring); : : /CHECKNEGVOID[0]
+@ "set-label" : void SetLabel(int, string); : : /CHECKNEGVOID[0]
+@ "set-label-top" : void SetLabelTop(int, string); : : /CHECKNEGVOID[0]
+// @ "set-title" : void SetTitle(string);
+
+@END
diff --git a/src/mred/wxs/wxs_mio.cxx b/src/mred/wxs/wxs_mio.cxx
new file mode 100644
index 0000000..7f290f0
--- /dev/null
+++ b/src/mred/wxs/wxs_mio.cxx
@@ -0,0 +1,1906 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_mio.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_obj.h"
+#include "wx_medio.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_mio.h"
+#include "wxscomon.h"
+
+
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE long
+
+#define l_TYPE char
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_char
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_char
+#define l_MAKE_LIST __MakecharList
+#define l_MAKE_ARRAY __MakecharArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+static char *VectorToArray(char *r, Scheme_Object *vec, long *len)
+{
+  long c, i;
+  Scheme_Object **a;
+
+  if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:media-stream-in-base::read", 
+		      "character vector", -1, 0, &vec);
+
+  c = *len = SCHEME_VEC_SIZE(vec);
+
+  if (!r)
+    r = (char *)scheme_malloc_atomic(c);
+
+  for (a = SCHEME_VEC_ELS(vec), i = 0; i < c; i++) {
+    if (!SCHEME_CHARP(a[i]))
+      scheme_wrong_type("wx:media-stream-in-base::read", 
+			"character vector", -1, 0, &vec);
+    r[i] = SCHEME_CHAR_VAL(a[i]);
+  }
+
+  return r;
+}
+
+static Scheme_Object *ArrayToVector(char *r, Scheme_Object *vec, long len)
+{
+  long i;
+  Scheme_Object **a;
+
+  if (!vec)
+    vec = scheme_make_vector(len, scheme_make_char(0));
+  else if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:media-stream-in-base::read", 
+		      "character vector", -1, 0, &vec);
+  
+  for (a = SCHEME_VEC_ELS(vec), i = 0; i < len; i++)
+    a[i] = scheme_make_char(r[i]);
+
+  return vec;
+}
+
+
+
+
+class os_wxMediaStreamInBase : public wxMediaStreamInBase {
+ public:
+
+  os_wxMediaStreamInBase(Scheme_Object * obj);
+  ~os_wxMediaStreamInBase();
+  long Read(char* x0, long x1);
+  Bool Bad();
+  void Skip(long x0);
+  void Seek(long x0);
+  long Tell();
+};
+
+Scheme_Object *os_wxMediaStreamInBase_class;
+
+os_wxMediaStreamInBase::os_wxMediaStreamInBase(Scheme_Object * o)
+: wxMediaStreamInBase()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamInBase::~os_wxMediaStreamInBase()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+long os_wxMediaStreamInBase::Read(char* x0, long x1)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamInBase_class, "read", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  p[0] = NULL;
+  p[0] = ArrayToVector(x0, NULL, x1);
+
+  v = scheme_apply(method, 1, p);
+  VectorToArray(x0, p[0], &x1);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_integer(v, "wx:media-stream-in-base%::read"", extracting return value");
+  }
+}
+
+Bool os_wxMediaStreamInBase::Bad()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamInBase_class, "bad?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-stream-in-base%::bad?"", extracting return value");
+  }
+}
+
+void os_wxMediaStreamInBase::Skip(long x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamInBase_class, "skip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaStreamInBase::Seek(long x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamInBase_class, "seek", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+long os_wxMediaStreamInBase::Tell()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamInBase_class, "tell", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_integer(v, "wx:media-stream-in-base%::tell"", extracting return value");
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBaseRead(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  char* x0;
+  long x1;
+
+  
+  x0 = NULL;
+
+  x0 = VectorToArray(NULL, p[0], &x1);
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Read(x0, x1);
+  else
+    r = ((wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Read(x0, x1);
+
+  ArrayToVector(x0, p[0], x1);
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBaseBad(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Bad();
+  else
+    r = ((wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Bad();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBaseSkip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-in-base%::skip");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Skip(x0);
+  else
+    ((wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Skip(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBaseSeek(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-in-base%::seek");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Seek(x0);
+  else
+    ((wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Seek(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBaseTell(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+  else
+    r = ((wxMediaStreamInBase *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInBase_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamInBase *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-stream-in-base%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaStreamInBase(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamInBase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-in-base%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-in-base%");
+}
+
+void objscheme_setup_wxMediaStreamInBase(void *env)
+{
+if (os_wxMediaStreamInBase_class) {
+    objscheme_add_global_class(os_wxMediaStreamInBase_class,  "wx:media-stream-in-base%", env);
+} else {
+  os_wxMediaStreamInBase_class = objscheme_def_prim_class(env, "wx:media-stream-in-base%", "wx:object%", os_wxMediaStreamInBase_ConstructScheme, 6);
+
+  scheme_add_method_w_arity(os_wxMediaStreamInBase_class,"get-class-name",objscheme_classname_os_wxMediaStreamInBase, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaStreamInBase_class, "read", os_wxMediaStreamInBaseRead, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamInBase_class, "bad?", os_wxMediaStreamInBaseBad, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamInBase_class, "skip", os_wxMediaStreamInBaseSkip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamInBase_class, "seek", os_wxMediaStreamInBaseSeek, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamInBase_class, "tell", os_wxMediaStreamInBaseTell, 0, 0);
+
+
+  scheme_made_class(os_wxMediaStreamInBase_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamInBase(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamInBase_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-in-base%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamInBase(class wxMediaStreamInBase *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamInBase_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamInBase *objscheme_unbundle_wxMediaStreamInBase(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamInBase(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamInBase *)o->primdata;
+  else
+    return (wxMediaStreamInBase *)o->primdata;
+}
+
+
+
+
+
+class os_wxMediaStreamOutBase : public wxMediaStreamOutBase {
+ public:
+
+  os_wxMediaStreamOutBase(Scheme_Object * obj);
+  ~os_wxMediaStreamOutBase();
+  void Write(char* x0, long x1);
+  Bool Bad();
+  void Seek(long x0);
+  long Tell();
+};
+
+Scheme_Object *os_wxMediaStreamOutBase_class;
+
+os_wxMediaStreamOutBase::os_wxMediaStreamOutBase(Scheme_Object * o)
+: wxMediaStreamOutBase()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamOutBase::~os_wxMediaStreamOutBase()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMediaStreamOutBase::Write(char* x0, long x1)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamOutBase_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = NULL;
+  p[0] = __MakecharList(x0, x1);
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaStreamOutBase::Bad()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamOutBase_class, "bad?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-stream-out-base%::bad?"", extracting return value");
+  }
+}
+
+void os_wxMediaStreamOutBase::Seek(long x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamOutBase_class, "seek", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+long os_wxMediaStreamOutBase::Tell()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaStreamOutBase_class, "tell", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_integer(v, "wx:media-stream-out-base%::tell"", extracting return value");
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutBaseWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  char* x0;
+  long x1;
+
+  
+  x0 = NULL;
+
+  x0 = __MakecharArray((0 < n) ? p[0] : scheme_null, &x1, "wx:media-stream-out-base%::write");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Write(x0, x1);
+  else
+    ((wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Write(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutBaseBad(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Bad();
+  else
+    r = ((wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Bad();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutBaseSeek(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out-base%::seek");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Seek(x0);
+  else
+    ((wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Seek(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutBaseTell(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+  else
+    r = ((wxMediaStreamOutBase *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutBase_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamOutBase *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-stream-out-base%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaStreamOutBase(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamOutBase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-out-base%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-out-base%");
+}
+
+void objscheme_setup_wxMediaStreamOutBase(void *env)
+{
+if (os_wxMediaStreamOutBase_class) {
+    objscheme_add_global_class(os_wxMediaStreamOutBase_class,  "wx:media-stream-out-base%", env);
+} else {
+  os_wxMediaStreamOutBase_class = objscheme_def_prim_class(env, "wx:media-stream-out-base%", "wx:object%", os_wxMediaStreamOutBase_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxMediaStreamOutBase_class,"get-class-name",objscheme_classname_os_wxMediaStreamOutBase, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaStreamOutBase_class, "write", os_wxMediaStreamOutBaseWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamOutBase_class, "bad?", os_wxMediaStreamOutBaseBad, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamOutBase_class, "seek", os_wxMediaStreamOutBaseSeek, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamOutBase_class, "tell", os_wxMediaStreamOutBaseTell, 0, 0);
+
+
+  scheme_made_class(os_wxMediaStreamOutBase_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamOutBase(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamOutBase_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-out-base%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamOutBase(class wxMediaStreamOutBase *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamOutBase_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamOutBase *objscheme_unbundle_wxMediaStreamOutBase(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamOutBase(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamOutBase *)o->primdata;
+  else
+    return (wxMediaStreamOutBase *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxMediaStreamInStringBase : public wxMediaStreamInStringBase {
+ public:
+
+  os_wxMediaStreamInStringBase(Scheme_Object * obj, string x0, long x1);
+  ~os_wxMediaStreamInStringBase();
+};
+
+Scheme_Object *os_wxMediaStreamInStringBase_class;
+
+os_wxMediaStreamInStringBase::os_wxMediaStreamInStringBase(Scheme_Object * o, string x0, long x1)
+: wxMediaStreamInStringBase(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamInStringBase::~os_wxMediaStreamInStringBase()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInStringBase_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamInStringBase *realobj;
+  string x0;
+  long x1;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:media-stream-in-string-base%::initialization", 1, 1, n, p);
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-stream-in-string-base%::initialization");
+
+  x1 = SCHEME_STRTAG_VAL(p[0]);
+  realobj = new os_wxMediaStreamInStringBase(obj, x0, x1);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamInStringBase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-in-string-base%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-in-string-base%");
+}
+
+void objscheme_setup_wxMediaStreamInStringBase(void *env)
+{
+if (os_wxMediaStreamInStringBase_class) {
+    objscheme_add_global_class(os_wxMediaStreamInStringBase_class,  "wx:media-stream-in-string-base%", env);
+} else {
+  os_wxMediaStreamInStringBase_class = objscheme_def_prim_class(env, "wx:media-stream-in-string-base%", "wx:media-stream-in-base%", os_wxMediaStreamInStringBase_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_wxMediaStreamInStringBase_class,"get-class-name",objscheme_classname_os_wxMediaStreamInStringBase, 0, 0);
+
+
+
+  scheme_made_class(os_wxMediaStreamInStringBase_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamInStringBase(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamInStringBase_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-in-string-base%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamInStringBase(class wxMediaStreamInStringBase *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamInStringBase_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamInStringBase *objscheme_unbundle_wxMediaStreamInStringBase(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamInStringBase(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamInStringBase *)o->primdata;
+  else
+    return (wxMediaStreamInStringBase *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxMediaStreamOutStringBase : public wxMediaStreamOutStringBase {
+ public:
+
+  os_wxMediaStreamOutStringBase(Scheme_Object * obj);
+  ~os_wxMediaStreamOutStringBase();
+};
+
+Scheme_Object *os_wxMediaStreamOutStringBase_class;
+
+os_wxMediaStreamOutStringBase::os_wxMediaStreamOutStringBase(Scheme_Object * o)
+: wxMediaStreamOutStringBase()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamOutStringBase::~os_wxMediaStreamOutStringBase()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutStringBaseGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+
+  
+  r = ((wxMediaStreamOutStringBase *)((Scheme_Class_Object *)obj)->primdata)->GetString(x0);
+
+  
+  
+  return (r ? scheme_make_sized_string(r, _x0 - 1, 0) : scheme_null);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutStringBase_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamOutStringBase *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-stream-out-string-base%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaStreamOutStringBase(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamOutStringBase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-out-string-base%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-out-string-base%");
+}
+
+void objscheme_setup_wxMediaStreamOutStringBase(void *env)
+{
+if (os_wxMediaStreamOutStringBase_class) {
+    objscheme_add_global_class(os_wxMediaStreamOutStringBase_class,  "wx:media-stream-out-string-base%", env);
+} else {
+  os_wxMediaStreamOutStringBase_class = objscheme_def_prim_class(env, "wx:media-stream-out-string-base%", "wx:media-stream-out-base%", os_wxMediaStreamOutStringBase_ConstructScheme, 2);
+
+  scheme_add_method_w_arity(os_wxMediaStreamOutStringBase_class,"get-class-name",objscheme_classname_os_wxMediaStreamOutStringBase, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaStreamOutStringBase_class, "get-string", os_wxMediaStreamOutStringBaseGetString, 0, 0);
+
+
+  scheme_made_class(os_wxMediaStreamOutStringBase_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamOutStringBase(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamOutStringBase_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-out-string-base%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamOutStringBase(class wxMediaStreamOutStringBase *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamOutStringBase_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamOutStringBase *objscheme_unbundle_wxMediaStreamOutStringBase(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamOutStringBase(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamOutStringBase *)o->primdata;
+  else
+    return (wxMediaStreamOutStringBase *)o->primdata;
+}
+
+
+static long GetExact(wxMediaStreamIn *s)
+{
+  long l;
+  s->Get(l);
+  return l;
+}
+static double GetInexact(wxMediaStreamIn *s)
+{
+  double d;
+  s->Get(d);
+  return d;
+}
+
+
+  
+// This is too dangerous: it is going away
+// @ "get" : wxMediaStreamIn% Get(long*////long,string);
+
+// @ "get" : wxMediaStreamIn% Get(short+);
+// @ "get" : wxMediaStreamIn% Get(int+);
+// @ "get" : wxMediaStreamIn% Get(char+);
+// @ "get" : wxMediaStreamIn% Get(float+);
+
+
+
+
+// @ ">>" : wxMediaStreamIn% operator>>(short+);
+// @ ">>" : wxMediaStreamIn% operator>>(int+);
+// @ ">>" : wxMediaStreamIn% operator>>(char+);
+// @ ">>" : wxMediaStreamIn% operator>>(float+);
+
+
+
+
+class os_wxMediaStreamIn : public wxMediaStreamIn {
+ public:
+
+  os_wxMediaStreamIn(Scheme_Object * obj, class wxMediaStreamInBase& x0);
+  ~os_wxMediaStreamIn();
+};
+
+Scheme_Object *os_wxMediaStreamIn_class;
+
+os_wxMediaStreamIn::os_wxMediaStreamIn(Scheme_Object * o, class wxMediaStreamInBase& x0)
+: wxMediaStreamIn(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamIn::~os_wxMediaStreamIn()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInJumpTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-in%::jump-to");
+
+  
+  ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->JumpTo(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInTell(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInSkip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-in%::skip");
+
+  
+  ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->Skip(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInRemoveBoundary(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->RemoveBoundary();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInSetBoundary(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-in%::set-boundary");
+
+  
+  ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->SetBoundary(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInoperatorGTGT(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamIn* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && (objscheme_istype_box(p[0], NULL) && objscheme_istype_integer(objscheme_unbox(p[0], NULL), NULL))) {
+    long _x0;
+    long* x0 = &_x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-in%::>> (exact case)", 1, 1, n, p);
+    if (SCHEME_NULLP(p[0]))
+      scheme_wrong_type("wx:media-stream-in%::>> (exact case)", "non-null", (0 - 0), n, p);
+    else
+      *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-stream-in%::>> (exact case)"), "wx:media-stream-in%::>> (exact case)");
+
+    
+    r = &((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->operator>>(*x0);
+
+    
+    if (n > 0)
+      objscheme_set_box(p[0], scheme_make_integer(_x0));
+    
+  } else  {
+    double _x0;
+    double* x0 = &_x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-in%::>> (inexact case)", 1, 1, n, p);
+    if (SCHEME_NULLP(p[0]))
+      scheme_wrong_type("wx:media-stream-in%::>> (inexact case)", "non-null", (0 - 0), n, p);
+    else
+      *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-stream-in%::>> (inexact case)"), "wx:media-stream-in%::>> (inexact case)");
+
+    
+    r = &((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->operator>>(*x0);
+
+    
+    if (n > 0)
+      objscheme_set_box(p[0], scheme_make_double(_x0));
+    
+  }
+
+  return objscheme_bundle_wxMediaStreamIn(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInGetInexact(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  double r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = GetInexact(((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInGetExact(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = GetExact(((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInGetFixed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamIn* r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-stream-in%::get-fixed", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-stream-in%::get-fixed"), "wx:media-stream-in%::get-fixed");
+
+  
+  r = &((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->GetFixed(*x0);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  
+  return objscheme_bundle_wxMediaStreamIn(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+  if (n > 0) {
+    if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-stream-in%::get-string"), "wx:media-stream-in%::get-string");
+  } else
+    x0 = NULL;
+
+  x0 = &_x0;
+  r = ((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->GetString(x0);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  
+  return (r ? scheme_make_sized_string(r, _x0 - 1, 0) : scheme_null);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamInGet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamIn* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && (objscheme_istype_box(p[0], NULL) && objscheme_istype_integer(objscheme_unbox(p[0], NULL), NULL))) {
+    long _x0;
+    long* x0 = &_x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-in%::get (exact number case)", 1, 1, n, p);
+    if (SCHEME_NULLP(p[0]))
+      scheme_wrong_type("wx:media-stream-in%::get (exact number case)", "non-null", (0 - 0), n, p);
+    else
+      *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-stream-in%::get (exact number case)"), "wx:media-stream-in%::get (exact number case)");
+
+    
+    r = &((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->Get(*x0);
+
+    
+    if (n > 0)
+      objscheme_set_box(p[0], scheme_make_integer(_x0));
+    
+  } else  {
+    double _x0;
+    double* x0 = &_x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-in%::get (inexact number case)", 1, 1, n, p);
+    if (SCHEME_NULLP(p[0]))
+      scheme_wrong_type("wx:media-stream-in%::get (inexact number case)", "non-null", (0 - 0), n, p);
+    else
+      *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-stream-in%::get (inexact number case)"), "wx:media-stream-in%::get (inexact number case)");
+
+    
+    r = &((wxMediaStreamIn *)((Scheme_Class_Object *)obj)->primdata)->Get(*x0);
+
+    
+    if (n > 0)
+      objscheme_set_box(p[0], scheme_make_double(_x0));
+    
+  }
+
+  return objscheme_bundle_wxMediaStreamIn(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamIn_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamIn *realobj;
+  class wxMediaStreamInBase* x0;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:media-stream-in%::initialization", 1, 1, n, p);
+  x0 = objscheme_unbundle_wxMediaStreamInBase(p[0], "wx:media-stream-in%::initialization", 0);
+
+  
+  realobj = new os_wxMediaStreamIn(obj, *x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamIn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-in%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-in%");
+}
+
+void objscheme_setup_wxMediaStreamIn(void *env)
+{
+if (os_wxMediaStreamIn_class) {
+    objscheme_add_global_class(os_wxMediaStreamIn_class,  "wx:media-stream-in%", env);
+} else {
+  os_wxMediaStreamIn_class = objscheme_def_prim_class(env, "wx:media-stream-in%", "wx:object%", os_wxMediaStreamIn_ConstructScheme, 13);
+
+  scheme_add_method_w_arity(os_wxMediaStreamIn_class,"get-class-name",objscheme_classname_os_wxMediaStreamIn, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "ok?", os_wxMediaStreamInOk, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "jump-to", os_wxMediaStreamInJumpTo, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "tell", os_wxMediaStreamInTell, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "skip", os_wxMediaStreamInSkip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "remove-boundary", os_wxMediaStreamInRemoveBoundary, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "set-boundary", os_wxMediaStreamInSetBoundary, 1, 1);
+ scheme_add_method(os_wxMediaStreamIn_class, ">>", os_wxMediaStreamInoperatorGTGT);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "get-inexact", os_wxMediaStreamInGetInexact, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "get-exact", os_wxMediaStreamInGetExact, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "get-fixed", os_wxMediaStreamInGetFixed, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamIn_class, "get-string", os_wxMediaStreamInGetString, 0, 1);
+ scheme_add_method(os_wxMediaStreamIn_class, "get", os_wxMediaStreamInGet);
+
+
+  scheme_made_class(os_wxMediaStreamIn_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamIn(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamIn_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-in%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamIn_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamIn(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamIn *)o->primdata;
+  else
+    return (wxMediaStreamIn *)o->primdata;
+}
+
+
+
+
+
+// @ "put" : wxMediaStreamOut% Put(short);
+// @ "put" : wxMediaStreamOut% Put(int);
+// @ "put" : wxMediaStreamOut% Put(char);
+// @ "put" : wxMediaStreamOut% Put(float);
+
+
+// @ "<<" : wxMediaStreamOut% operator<<(short);
+// @ "<<" : wxMediaStreamOut% operator<<(int);
+// @ "<<" : wxMediaStreamOut% operator<<(byte);
+// @ "<<" : wxMediaStreamOut% operator<<(float);
+
+
+
+class os_wxMediaStreamOut : public wxMediaStreamOut {
+ public:
+
+  os_wxMediaStreamOut(Scheme_Object * obj, class wxMediaStreamOutBase& x0);
+  ~os_wxMediaStreamOut();
+};
+
+Scheme_Object *os_wxMediaStreamOut_class;
+
+os_wxMediaStreamOut::os_wxMediaStreamOut(Scheme_Object * o, class wxMediaStreamOutBase& x0)
+: wxMediaStreamOut(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaStreamOut::~os_wxMediaStreamOut()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutJumpTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out%::jump-to");
+
+  
+  ((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->JumpTo(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutTell(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Tell();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutoperatorLTLT(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamOut* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::<< (string case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:media-stream-out%::<< (string case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->operator<<(x0);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_float(p[0], NULL)) {
+    double x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::<< (inexact number case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_float(p[0], "wx:media-stream-out%::<< (inexact number case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->operator<<(x0);
+
+    
+    
+  } else  {
+    long x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::<< (exact number case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out%::<< (exact number case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->operator<<(x0);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxMediaStreamOut(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutPutFixed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamOut* r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out%::put-fixed");
+
+  
+  r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->PutFixed(x0);
+
+  
+  
+  return objscheme_bundle_wxMediaStreamOut(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOutPut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaStreamOut* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::put (string without length case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:media-stream-out%::put (string without length case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Put(x0);
+
+    
+    
+  } else if ((n >= 2) && objscheme_istype_number(p[0], NULL) && objscheme_istype_string(p[1], NULL)) {
+    long x0;
+    string x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:media-stream-out%::put (length and string case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out%::put (length and string case)");
+    x1 = (string)objscheme_unbundle_string(p[1], "wx:media-stream-out%::put (length and string case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Put(x0, x1);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_integer(p[0], NULL)) {
+    long x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::put (exact number case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-stream-out%::put (exact number case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Put(x0);
+
+    
+    
+  } else  {
+    double x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-stream-out%::put (inexact number case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_float(p[0], "wx:media-stream-out%::put (inexact number case)");
+
+    
+    r = &((wxMediaStreamOut *)((Scheme_Class_Object *)obj)->primdata)->Put(x0);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxMediaStreamOut(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaStreamOut_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaStreamOut *realobj;
+  class wxMediaStreamOutBase* x0;
+
+  
+  if (n != 1) 
+    scheme_wrong_count("wx:media-stream-out%::initialization", 1, 1, n, p);
+  x0 = objscheme_unbundle_wxMediaStreamOutBase(p[0], "wx:media-stream-out%::initialization", 0);
+
+  
+  realobj = new os_wxMediaStreamOut(obj, *x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaStreamOut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-stream-out%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-stream-out%");
+}
+
+void objscheme_setup_wxMediaStreamOut(void *env)
+{
+if (os_wxMediaStreamOut_class) {
+    objscheme_add_global_class(os_wxMediaStreamOut_class,  "wx:media-stream-out%", env);
+} else {
+  os_wxMediaStreamOut_class = objscheme_def_prim_class(env, "wx:media-stream-out%", "wx:object%", os_wxMediaStreamOut_ConstructScheme, 7);
+
+  scheme_add_method_w_arity(os_wxMediaStreamOut_class,"get-class-name",objscheme_classname_os_wxMediaStreamOut, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaStreamOut_class, "ok?", os_wxMediaStreamOutOk, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaStreamOut_class, "jump-to", os_wxMediaStreamOutJumpTo, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaStreamOut_class, "tell", os_wxMediaStreamOutTell, 0, 0);
+ scheme_add_method(os_wxMediaStreamOut_class, "<<", os_wxMediaStreamOutoperatorLTLT);
+ scheme_add_method_w_arity(os_wxMediaStreamOut_class, "put-fixed", os_wxMediaStreamOutPutFixed, 1, 1);
+ scheme_add_method(os_wxMediaStreamOut_class, "put", os_wxMediaStreamOutPut);
+
+
+  scheme_made_class(os_wxMediaStreamOut_class);
+
+
+}
+}
+
+int objscheme_istype_wxMediaStreamOut(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaStreamOut_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-stream-out%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaStreamOut_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaStreamOut(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaStreamOut *)o->primdata;
+  else
+    return (wxMediaStreamOut *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_mio.h b/src/mred/wxs/wxs_mio.h
new file mode 100644
index 0000000..584c85c
--- /dev/null
+++ b/src/mred/wxs/wxs_mio.h
@@ -0,0 +1,46 @@
+#ifndef WXS_SETUP_ONLY
+#endif
+void objscheme_setup_wxMediaStreamInBase(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamInBase(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamInBase(class wxMediaStreamInBase *realobj);
+class wxMediaStreamInBase *objscheme_unbundle_wxMediaStreamInBase(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxMediaStreamOutBase(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamOutBase(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamOutBase(class wxMediaStreamOutBase *realobj);
+class wxMediaStreamOutBase *objscheme_unbundle_wxMediaStreamOutBase(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxMediaStreamInStringBase(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamInStringBase(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamInStringBase(class wxMediaStreamInStringBase *realobj);
+class wxMediaStreamInStringBase *objscheme_unbundle_wxMediaStreamInStringBase(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxMediaStreamOutStringBase(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamOutStringBase(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamOutStringBase(class wxMediaStreamOutStringBase *realobj);
+class wxMediaStreamOutStringBase *objscheme_unbundle_wxMediaStreamOutStringBase(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern class wxMediaStreamInBase *objscheme_unbundle_wxMediaStreamInBase(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaStreamIn(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamIn(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *realobj);
+class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern class wxMediaStreamOutBase *objscheme_unbundle_wxMediaStreamOutBase(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaStreamOut(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaStreamOut(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *realobj);
+class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_mio.xc b/src/mred/wxs/wxs_mio.xc
new file mode 100644
index 0000000..9e4e9eb
--- /dev/null
+++ b/src/mred/wxs/wxs_mio.xc
@@ -0,0 +1,190 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_obj.h"
+#include "wx_medio.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@MACRO rZERO = return 0;
+
+@SET TYPE = char
+@SET NOTEST = 1
+@SET SIZEISLONG = 1
+@INCLUDE list.xci
+
+@CLASSBASE wxMediaStreamInBase "wx:media-stream-in-base" : "wx:object"
+
+static char *VectorToArray(char *r, Scheme_Object *vec, long *len)
+{
+  long c, i;
+  Scheme_Object **a;
+
+  if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:media-stream-in-base::read", 
+		      "character vector", -1, 0, &vec);
+
+  c = *len = SCHEME_VEC_SIZE(vec);
+
+  if (!r)
+    r = (char *)scheme_malloc_atomic(c);
+
+  for (a = SCHEME_VEC_ELS(vec), i = 0; i < c; i++) {
+    if (!SCHEME_CHARP(a[i]))
+      scheme_wrong_type("wx:media-stream-in-base::read", 
+			"character vector", -1, 0, &vec);
+    r[i] = SCHEME_CHAR_VAL(a[i]);
+  }
+
+  return r;
+}
+
+static Scheme_Object *ArrayToVector(char *r, Scheme_Object *vec, long len)
+{
+  long i;
+  Scheme_Object **a;
+
+  if (!vec)
+    vec = scheme_make_vector(len, scheme_make_char(0));
+  else if (!SCHEME_VECTORP(vec))
+    scheme_wrong_type("wx:media-stream-in-base::read", 
+		      "character vector", -1, 0, &vec);
+  
+  for (a = SCHEME_VEC_ELS(vec), i = 0; i < len; i++)
+    a[i] = scheme_make_char(r[i]);
+
+  return vec;
+}
+
+@MACRO setNULL = NULL
+@MACRO arrayToVector = p[0] = ArrayToVector(x0, NULL, x1);
+@MACRO copyArrayToVector = ArrayToVector(x0, p[0], x1);
+@MACRO vectorToArray = x0 = VectorToArray(NULL, p[0], &x1);
+@MACRO copyVectorToArray = VectorToArray(x0, p[0], &x1);
+
+@CREATOR ();
+
+@ V "tell" : long Tell(); : : : rZERO
+@ V "seek" : void Seek(long);
+@ V "skip" : void Skip(long);
+@ V "bad?" : bool Bad(); : : : rZERO
+@ V "read" : long Read(char[]/setNULL/setNULL,-long); : /arrayToVector/copyVectorToArray : /vectorToArray/copyArrayToVector : rZERO
+
+@END
+
+@CLASSBASE wxMediaStreamOutBase "wx:media-stream-out-base" : "wx:object"
+
+@CREATOR ();
+
+@ V "tell" : long Tell(); : : : rZERO
+@ V "seek" : void Seek(long);
+@ V "bad?" : bool Bad(); : : : rZERO
+@ V "write" : void Write(char[]/bList/ubList/cList,-long); : /methListSet[char.0.0.1] : /glueListSet[char.0.0.1."wx:media-stream-out-base%::write"]
+
+@END
+
+
+@CLASSBASE wxMediaStreamInStringBase "wx:media-stream-in-string-base" : "wx:media-stream-in-base"
+
+@MACRO setStringSize[ss.cn] = x<cn> = SCHEME_STRTAG_VAL(p[<ss>]);
+
+@CREATOR (string,-long); : : /setStringSize[0.1]
+
+@END
+
+@CLASSBASE wxMediaStreamOutStringBase "wx:media-stream-out-string-base" : "wx:media-stream-out-base"
+
+@CREATOR ()
+
+@MACRO makeSizedString = (r ? scheme_make_sized_string(r, _x0 - 1, 0) : scheme_null)
+
+@ "get-string" : nstring/makeSizedString GetString(-long*);
+
+@END
+
+static long GetExact(wxMediaStreamIn *s)
+{
+  long l;
+  s->Get(l);
+  return l;
+}
+static double GetInexact(wxMediaStreamIn *s)
+{
+  double d;
+  s->Get(d);
+  return d;
+}
+
+@CLASSBASE wxMediaStreamIn "wx:media-stream-in" : "wx:object"
+
+@CREATOR (wxMediaStreamInBase%);
+  
+// This is too dangerous: it is going away
+// @ "get" : wxMediaStreamIn% Get(long*////long,string);
+
+@ "get" : wxMediaStreamIn% Get(Long+////long); <> exact number
+@ "get" : wxMediaStreamIn% Get(Double+); <> inexact number
+// @ "get" : wxMediaStreamIn% Get(short+);
+// @ "get" : wxMediaStreamIn% Get(int+);
+// @ "get" : wxMediaStreamIn% Get(char+);
+// @ "get" : wxMediaStreamIn% Get(float+);
+
+@MACRO alwaysPassPtr = x0 = &_x0;
+
+@ "get-string" : nstring/makeSizedString GetString(long?=NULL); : : /alwaysPassPtr/
+@ "get-fixed" : wxMediaStreamIn% GetFixed(long+);
+
+@ m "get-exact" : long GetExact();
+@ m "get-inexact" : double GetInexact();
+
+@ ">>" : wxMediaStreamIn% operator>>(Long+); <> exact
+@ ">>" : wxMediaStreamIn% operator>>(Double+); <> inexact
+// @ ">>" : wxMediaStreamIn% operator>>(short+);
+// @ ">>" : wxMediaStreamIn% operator>>(int+);
+// @ ">>" : wxMediaStreamIn% operator>>(char+);
+// @ ">>" : wxMediaStreamIn% operator>>(float+);
+
+@ "set-boundary" : void SetBoundary(long);
+@ "remove-boundary" : void RemoveBoundary();
+
+@ "skip" : void Skip(long);
+@ "tell" : long Tell();
+@ "jump-to" : void JumpTo(long);
+
+@ "ok?" : bool Ok();
+
+@END
+
+
+@CLASSBASE wxMediaStreamOut "wx:media-stream-out" : "wx:object"
+
+@CREATOR (wxMediaStreamOutBase%);
+
+@ "put" : wxMediaStreamOut% Put(long////long,string); <> length and string
+@ "put" : wxMediaStreamOut% Put(string); <> string without length
+@ "put" : wxMediaStreamOut% Put(Long////long); <> exact number
+@ "put" : wxMediaStreamOut% Put(Double); <> inexact number
+// @ "put" : wxMediaStreamOut% Put(short);
+// @ "put" : wxMediaStreamOut% Put(int);
+// @ "put" : wxMediaStreamOut% Put(char);
+// @ "put" : wxMediaStreamOut% Put(float);
+
+@ "put-fixed" : wxMediaStreamOut% PutFixed(long);
+
+@ "<<" : wxMediaStreamOut% operator<<(string); <> string
+@ "<<" : wxMediaStreamOut% operator<<(Double); <> inexact number
+@ "<<" : wxMediaStreamOut% operator<<(Long); <> exact number
+// @ "<<" : wxMediaStreamOut% operator<<(short);
+// @ "<<" : wxMediaStreamOut% operator<<(int);
+// @ "<<" : wxMediaStreamOut% operator<<(byte);
+// @ "<<" : wxMediaStreamOut% operator<<(float);
+
+@ "tell" : long Tell();
+@ "jump-to" : void JumpTo(long);
+
+@ "ok?" : bool Ok();
+
+@END
+
diff --git a/src/mred/wxs/wxs_misc.cxx b/src/mred/wxs/wxs_misc.cxx
new file mode 100644
index 0000000..56adbbe
--- /dev/null
+++ b/src/mred/wxs/wxs_misc.cxx
@@ -0,0 +1,927 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_misc.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_obj.h"
+#include "wx_win.h"
+#include "wx_timer.h"
+#include "wx_types.h"
+#include "wx_stdev.h"
+#include "wx_dc.h"
+#include "wx_clipb.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_misc.h"
+#include "wxscomon.h"
+
+
+#if !defined(wx_mac)
+#define NEWEST_TYPES 1
+#else
+#define NEWEST_TYPES 0
+#endif
+
+#ifdef wx_msw
+
+#include "wx_mf.h"
+
+class baseMetaFile : public wxMetaFile
+{
+};
+
+#else
+
+class baseMetaFile : public wxObject
+{
+public:
+  Bool Ok() { return FALSE; }
+  void Play(wxDC*) { }
+  Bool SetClipboard(int, int) { return FALSE; }
+
+};
+
+#endif
+
+
+// @CREATOR (string=NULL);
+
+
+class os_baseMetaFile : public baseMetaFile {
+ public:
+
+  ~os_baseMetaFile();
+};
+
+Scheme_Object *os_baseMetaFile_class;
+
+os_baseMetaFile::~os_baseMetaFile()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_baseMetaFileSetClipboard(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:meta-file%::set-clipboard");
+  } else
+    x0 = 0;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:meta-file%::set-clipboard");
+  } else
+    x1 = 0;
+
+  
+  r = ((baseMetaFile *)((Scheme_Class_Object *)obj)->primdata)->SetClipboard(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_baseMetaFilePlay(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:meta-file%::play", 0);
+
+  
+  ((baseMetaFile *)((Scheme_Class_Object *)obj)->primdata)->Play(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_baseMetaFileOk(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((baseMetaFile *)((Scheme_Class_Object *)obj)->primdata)->Ok();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_classname_os_baseMetaFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:meta-file%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:meta-file%");
+}
+
+void objscheme_setup_baseMetaFile(void *env)
+{
+if (os_baseMetaFile_class) {
+    objscheme_add_global_class(os_baseMetaFile_class,  "wx:meta-file%", env);
+} else {
+  os_baseMetaFile_class = objscheme_def_prim_class(env, "wx:meta-file%", "wx:object%", NULL, 4);
+
+  scheme_add_method_w_arity(os_baseMetaFile_class,"get-class-name",objscheme_classname_os_baseMetaFile, 0, 0);
+
+ scheme_add_method_w_arity(os_baseMetaFile_class, "set-clipboard", os_baseMetaFileSetClipboard, 0, 2);
+ scheme_add_method_w_arity(os_baseMetaFile_class, "play", os_baseMetaFilePlay, 1, 1);
+ scheme_add_method_w_arity(os_baseMetaFile_class, "ok?", os_baseMetaFileOk, 0, 0);
+
+
+  scheme_made_class(os_baseMetaFile_class);
+
+
+}
+}
+
+int objscheme_istype_baseMetaFile(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_baseMetaFile_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:meta-file%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_baseMetaFile(class baseMetaFile *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_baseMetaFile_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class baseMetaFile *objscheme_unbundle_baseMetaFile(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_baseMetaFile(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_baseMetaFile *)o->primdata;
+  else
+    return (baseMetaFile *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxTimer : public wxTimer {
+ public:
+
+  os_wxTimer(Scheme_Object * obj);
+  ~os_wxTimer();
+  void Notify();
+};
+
+Scheme_Object *os_wxTimer_class;
+
+os_wxTimer::os_wxTimer(Scheme_Object * o)
+: wxTimer()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxTimer::~os_wxTimer()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxTimer::Notify()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTimer_class, "notify", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTimer::Notify();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTimerStop(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTimer *)((Scheme_Class_Object *)obj)->primdata)->Stop();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTimerStart(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:timer%::start");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:timer%::start");
+  } else
+    x1 = FALSE;
+
+  
+  r = ((wxTimer *)((Scheme_Class_Object *)obj)->primdata)->Start(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTimerNotify(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTimer *)((Scheme_Class_Object *)obj)->primdata)->wxTimer::Notify();
+  else
+    ((wxTimer *)((Scheme_Class_Object *)obj)->primdata)->Notify();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTimerInterval(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTimer *)((Scheme_Class_Object *)obj)->primdata)->Interval();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTimer_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxTimer *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:timer%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxTimer(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxTimer(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:timer%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:timer%");
+}
+
+void objscheme_setup_wxTimer(void *env)
+{
+if (os_wxTimer_class) {
+    objscheme_add_global_class(os_wxTimer_class,  "wx:timer%", env);
+} else {
+  os_wxTimer_class = objscheme_def_prim_class(env, "wx:timer%", "wx:object%", os_wxTimer_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxTimer_class,"get-class-name",objscheme_classname_os_wxTimer, 0, 0);
+
+ scheme_add_method_w_arity(os_wxTimer_class, "stop", os_wxTimerStop, 0, 0);
+ scheme_add_method_w_arity(os_wxTimer_class, "start", os_wxTimerStart, 1, 2);
+ scheme_add_method_w_arity(os_wxTimer_class, "notify", os_wxTimerNotify, 0, 0);
+ scheme_add_method_w_arity(os_wxTimer_class, "interval", os_wxTimerInterval, 0, 0);
+
+
+  scheme_made_class(os_wxTimer_class);
+
+
+}
+}
+
+int objscheme_istype_wxTimer(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxTimer_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:timer%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxTimer(class wxTimer *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxTimer_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxTimer *objscheme_unbundle_wxTimer(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxTimer(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxTimer *)o->primdata;
+  else
+    return (wxTimer *)o->primdata;
+}
+
+
+
+void AddType(wxClipboardClient *c, char *s) 
+{ 
+  c->formats.Add(s); 
+}
+
+Scheme_Object *GetTypes(wxClipboardClient *c)
+{
+  wxNode *n = c->formats.First();
+  Scheme_Object *first = scheme_null, *last = NULL;
+  for (; n; n = n->Next()) {
+    Scheme_Object *p;
+    
+    p = scheme_make_pair(scheme_make_string((char *)n->Data()), scheme_null);
+    if (last)
+      SCHEME_CDR(last) = p;
+    else
+      first = p;
+    last = p;
+  }
+  
+  return first;
+}
+
+
+
+
+
+class os_wxClipboard : public wxClipboard {
+ public:
+
+  ~os_wxClipboard();
+};
+
+Scheme_Object *os_wxClipboard_class;
+
+os_wxClipboard::~os_wxClipboard()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardGetClipboardData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  string x0;
+  long _x1;
+  long* x1 = &_x1;
+  long x2;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:clipboard%::get-clipboard-data");
+  x2 = objscheme_unbundle_integer(p[1], "wx:clipboard%::get-clipboard-data");
+
+  
+  r = ((wxClipboard *)((Scheme_Class_Object *)obj)->primdata)->GetClipboardData(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_make_sized_string(r, _x1, 1) : scheme_null);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardGetClipboardString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:clipboard%::get-clipboard-string");
+
+  
+  r = ((wxClipboard *)((Scheme_Class_Object *)obj)->primdata)->GetClipboardString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardGetClipboardClient(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxClipboardClient* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxClipboard *)((Scheme_Class_Object *)obj)->primdata)->GetClipboardClient();
+
+  
+  
+  return objscheme_bundle_wxClipboardClient(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardSetClipboardString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  long x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:clipboard%::set-clipboard-string");
+  x1 = objscheme_unbundle_integer(p[1], "wx:clipboard%::set-clipboard-string");
+
+  
+  ((wxClipboard *)((Scheme_Class_Object *)obj)->primdata)->SetClipboardString(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardSetClipboardClient(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxClipboardClient* x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_wxClipboardClient(p[0], "wx:clipboard%::set-clipboard-client", 0);
+  x1 = objscheme_unbundle_integer(p[1], "wx:clipboard%::set-clipboard-client");
+
+  
+  ((wxClipboard *)((Scheme_Class_Object *)obj)->primdata)->SetClipboardClient(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxClipboard(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:clipboard%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:clipboard%");
+}
+
+void objscheme_setup_wxClipboard(void *env)
+{
+if (os_wxClipboard_class) {
+    objscheme_add_global_class(os_wxClipboard_class,  "wx:clipboard%", env);
+} else {
+  os_wxClipboard_class = objscheme_def_prim_class(env, "wx:clipboard%", "wx:object%", NULL, 6);
+
+  scheme_add_method_w_arity(os_wxClipboard_class,"get-class-name",objscheme_classname_os_wxClipboard, 0, 0);
+
+ scheme_add_method_w_arity(os_wxClipboard_class, "get-clipboard-data", os_wxClipboardGetClipboardData, 2, 2);
+ scheme_add_method_w_arity(os_wxClipboard_class, "get-clipboard-string", os_wxClipboardGetClipboardString, 1, 1);
+ scheme_add_method_w_arity(os_wxClipboard_class, "get-clipboard-client", os_wxClipboardGetClipboardClient, 0, 0);
+ scheme_add_method_w_arity(os_wxClipboard_class, "set-clipboard-string", os_wxClipboardSetClipboardString, 2, 2);
+ scheme_add_method_w_arity(os_wxClipboard_class, "set-clipboard-client", os_wxClipboardSetClipboardClient, 2, 2);
+
+
+  scheme_made_class(os_wxClipboard_class);
+
+
+}
+  scheme_install_xc_global("wx:the-clipboard", objscheme_bundle_wxClipboard(wxTheClipboard), env);
+}
+
+int objscheme_istype_wxClipboard(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxClipboard_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:clipboard%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxClipboard(class wxClipboard *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxClipboard_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxClipboard *objscheme_unbundle_wxClipboard(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxClipboard(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxClipboard *)o->primdata;
+  else
+    return (wxClipboard *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+class os_wxClipboardClient : public wxClipboardClient {
+ public:
+
+  os_wxClipboardClient(Scheme_Object * obj);
+  ~os_wxClipboardClient();
+  nstring GetData(string x0, long* x1);
+  void BeingReplaced();
+};
+
+Scheme_Object *os_wxClipboardClient_class;
+
+os_wxClipboardClient::os_wxClipboardClient(Scheme_Object * o)
+: wxClipboardClient()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxClipboardClient::~os_wxClipboardClient()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+nstring os_wxClipboardClient::GetData(string x0, long* x1)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxClipboardClient_class, "get-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  if (SCHEME_STRINGP(v)) (*x1) = SCHEME_STRTAG_VAL(v);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:clipboard-client%::get-data"", extracting return value");
+  }
+}
+
+void os_wxClipboardClient::BeingReplaced()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxClipboardClient_class, "being-replaced", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardClientGetTypes(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Scheme_Object* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = GetTypes(((wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return r;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardClientAddType(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:clipboard-client%::add-type");
+
+  
+  AddType(((wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata), x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardClientGetData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  string x0;
+  long _x1;
+  long* x1 = &_x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:clipboard-client%::get-data");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata)->GetData(x0, x1);
+  else
+    r = ((wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata)->GetData(x0, x1);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardClientBeingReplaced(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata)->BeingReplaced();
+  else
+    ((wxClipboardClient *)((Scheme_Class_Object *)obj)->primdata)->BeingReplaced();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxClipboardClient_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxClipboardClient *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:clipboard-client%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxClipboardClient(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxClipboardClient(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:clipboard-client%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:clipboard-client%");
+}
+
+void objscheme_setup_wxClipboardClient(void *env)
+{
+if (os_wxClipboardClient_class) {
+    objscheme_add_global_class(os_wxClipboardClient_class,  "wx:clipboard-client%", env);
+} else {
+  os_wxClipboardClient_class = objscheme_def_prim_class(env, "wx:clipboard-client%", "wx:object%", os_wxClipboardClient_ConstructScheme, 5);
+
+  scheme_add_method_w_arity(os_wxClipboardClient_class,"get-class-name",objscheme_classname_os_wxClipboardClient, 0, 0);
+
+ scheme_add_method_w_arity(os_wxClipboardClient_class, "get-types", os_wxClipboardClientGetTypes, 0, 0);
+ scheme_add_method_w_arity(os_wxClipboardClient_class, "add-type", os_wxClipboardClientAddType, 1, 1);
+ scheme_add_method_w_arity(os_wxClipboardClient_class, "get-data", os_wxClipboardClientGetData, 1, 1);
+ scheme_add_method_w_arity(os_wxClipboardClient_class, "being-replaced", os_wxClipboardClientBeingReplaced, 0, 0);
+
+
+  scheme_made_class(os_wxClipboardClient_class);
+
+
+}
+}
+
+int objscheme_istype_wxClipboardClient(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxClipboardClient_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:clipboard-client%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxClipboardClient(class wxClipboardClient *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxClipboardClient_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxClipboardClient *objscheme_unbundle_wxClipboardClient(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxClipboardClient(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxClipboardClient *)o->primdata;
+  else
+    return (wxClipboardClient *)o->primdata;
+}
+
+
+
diff --git a/src/mred/wxs/wxs_misc.h b/src/mred/wxs/wxs_misc.h
new file mode 100644
index 0000000..d4c6599
--- /dev/null
+++ b/src/mred/wxs/wxs_misc.h
@@ -0,0 +1,30 @@
+#ifndef WXS_SETUP_ONLY
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_baseMetaFile(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_baseMetaFile(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_baseMetaFile(class baseMetaFile *realobj);
+class baseMetaFile *objscheme_unbundle_baseMetaFile(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxTimer(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxTimer(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxTimer(class wxTimer *realobj);
+class wxTimer *objscheme_unbundle_wxTimer(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxClipboardClient(class wxClipboardClient *);
+extern class wxClipboardClient *objscheme_unbundle_wxClipboardClient(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxClipboard(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxClipboard(class wxClipboard *);
+int objscheme_istype_wxClipboard(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxClipboard(class wxClipboard *realobj);
+class wxClipboard *objscheme_unbundle_wxClipboard(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxClipboardClient(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxClipboardClient(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxClipboardClient(class wxClipboardClient *realobj);
+class wxClipboardClient *objscheme_unbundle_wxClipboardClient(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_misc.xc b/src/mred/wxs/wxs_misc.xc
new file mode 100644
index 0000000..ed23545
--- /dev/null
+++ b/src/mred/wxs/wxs_misc.xc
@@ -0,0 +1,197 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_obj.h"
+#include "wx_win.h"
+#include "wx_timer.h"
+#include "wx_types.h"
+#include "wx_stdev.h"
+#include "wx_dc.h"
+#include "wx_clipb.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if !defined(wx_mac)
+#define NEWEST_TYPES 1
+#else
+#define NEWEST_TYPES 0
+#endif
+
+#ifdef wx_msw
+
+#include "wx_mf.h"
+
+class baseMetaFile : public wxMetaFile
+{
+};
+
+#else
+
+class baseMetaFile : public wxObject
+{
+public:
+  Bool Ok() { return FALSE; }
+  void Play(wxDC*) { }
+  Bool SetClipboard(int, int) { return FALSE; }
+
+};
+
+#endif
+
+@CLASSBASE baseMetaFile "wx:meta-file" : "wx:object"
+
+// @CREATOR (string=NULL);
+
+@ "ok?" : bool Ok();
+@ "play" : void Play(wxDC!);
+@ "set-clipboard" : bool SetClipboard(int=0,int=0);
+
+@END
+
+@MACRO rFALSE = return FALSE;
+
+@CLASSBASE wxTimer "wx:timer" : "wx:object"
+
+@CREATOR ();
+
+@ "interval" : int Interval();
+@ v "notify" : void Notify();
+@ "start" : bool Start(int,bool=FALSE); : : : : rFALSE
+@ "stop" : void Stop();
+
+@END
+
+
+void AddType(wxClipboardClient *c, char *s) 
+{ 
+  c->formats.Add(s); 
+}
+
+Scheme_Object *GetTypes(wxClipboardClient *c)
+{
+  wxNode *n = c->formats.First();
+  Scheme_Object *first = scheme_null, *last = NULL;
+  for (; n; n = n->Next()) {
+    Scheme_Object *p;
+    
+    p = scheme_make_pair(scheme_make_string((char *)n->Data()), scheme_null);
+    if (last)
+      SCHEME_CDR(last) = p;
+    else
+      first = p;
+    last = p;
+  }
+  
+  return first;
+}
+
+@MACRO makeSizedString[i] = (r ? scheme_make_sized_string(r, _x<i>, 1) : scheme_null)
+
+@CLASSBASE wxClipboard "wx:clipboard" : "wx:object"
+
+@ "set-clipboard-client" : void SetClipboardClient(wxClipboardClient!,long);
+@ "set-clipboard-string" : void SetClipboardString(string,long);
+@ "get-clipboard-client" : wxClipboardClient^ GetClipboardClient();
+@ "get-clipboard-string" : nstring GetClipboardString(long);
+@ "get-clipboard-data" : nstring/makeSizedString[1] GetClipboardData(string,-long*,long);
+
+@CONSTANT "wx:the-clipboard" : wxClipboard^ wxTheClipboard
+
+@END
+
+
+@MACRO setStringSize[cn] = if (SCHEME_STRINGP(v)) (*x<cn>) = SCHEME_STRTAG_VAL(v);
+@MACRO identity = {x}
+@MACRO XrNULL = return NULL;
+
+@MACRO sbString = str
+
+@CLASSBASE wxClipboardClient "wx:clipboard-client" : "wx:object"
+
+@CREATOR ()
+
+@ V "being-replaced" : void BeingReplaced();
+@ V "get-data" : nstring GetData(string,-long*); : //setStringSize[1] : : : XrNULL
+
+@ m "add-type" : void AddType(string);
+@ m "get-types" : Scheme_Object*/identity//sbString GetTypes();
+
+@END
+
+
+#if 0
+
+@CLASSBASE wxTypeTree "wx:type-tree" : "wx:list"
+
+@CREATOR ();
+
+@ "add-type" : void AddType(int,int,string);
+
+@CONSTANT "wx:const-type-any" : int wxTYPE_ANY
+@CONSTANT "wx:const-type-object" : int wxTYPE_OBJECT
+@CONSTANT "wx:const-type-window" : int wxTYPE_WINDOW
+@CONSTANT "wx:const-type-dialog-box" : int wxTYPE_DIALOG_BOX
+@CONSTANT "wx:const-type-item" : int wxTYPE_ITEM
+@CONSTANT "wx:const-type-panel" : int wxTYPE_PANEL
+@CONSTANT "wx:const-type-canvas" : int wxTYPE_CANVAS
+@CONSTANT "wx:const-type-text-window" : int wxTYPE_TEXT_WINDOW
+@CONSTANT "wx:const-type-frame" : int wxTYPE_FRAME
+@CONSTANT "wx:const-type-button" : int wxTYPE_BUTTON
+@CONSTANT "wx:const-type-text" : int wxTYPE_TEXT
+@CONSTANT "wx:const-type-message" : int wxTYPE_MESSAGE
+@CONSTANT "wx:const-type-choice" : int wxTYPE_CHOICE
+@CONSTANT "wx:const-type-list-box" : int wxTYPE_LIST_BOX
+@CONSTANT "wx:const-type-slider" : int wxTYPE_SLIDER
+@CONSTANT "wx:const-type-check-box" : int wxTYPE_CHECK_BOX
+@CONSTANT "wx:const-type-menu" : int wxTYPE_MENU
+@CONSTANT "wx:const-type-menu-bar" : int wxTYPE_MENU_BAR
+@CONSTANT "wx:const-type-multi-text" : int wxTYPE_MULTI_TEXT
+@CONSTANT "wx:const-type-radio-box" : int wxTYPE_RADIO_BOX
+@CONSTANT "wx:const-type-group-box" : int wxTYPE_GROUP_BOX
+@CONSTANT "wx:const-type-guage" : int wxTYPE_GAUGE
+@CONSTANT "wx:const-type-scroll-box" : int wxTYPE_SCROLL_BAR  ## NEWEST_TYPES
+@CONSTANT "wx:const-type-virt-list-box" : int wxTYPE_VIRT_LIST_BOX ## NEWEST_TYPES
+@CONSTANT "wx:const-type-event" : int wxTYPE_EVENT
+@CONSTANT "wx:const-type-dc" : int wxTYPE_DC
+@CONSTANT "wx:const-type-dc-canvas" : int wxTYPE_DC_CANVAS
+@CONSTANT "wx:const-type-dc-postscript" : int wxTYPE_DC_POSTSCRIPT
+@CONSTANT "wx:const-type-dc-printer" : int wxTYPE_DC_PRINTER
+@CONSTANT "wx:const-type-dc-metafile" : int wxTYPE_DC_METAFILE
+@CONSTANT "wx:const-type-dc-memory" : int wxTYPE_DC_MEMORY
+@CONSTANT "wx:const-type-pen" : int wxTYPE_PEN
+@CONSTANT "wx:const-type-brush" : int wxTYPE_BRUSH
+@CONSTANT "wx:const-type-font" : int wxTYPE_FONT
+@CONSTANT "wx:const-type-icon" : int wxTYPE_ICON
+@CONSTANT "wx:const-type-bitmap" : int wxTYPE_BITMAP
+@CONSTANT "wx:const-type-metafile" : int wxTYPE_METAFILE
+@CONSTANT "wx:const-type-timer" : int wxTYPE_TIMER
+@CONSTANT "wx:const-type-colour" : int wxTYPE_COLOUR
+@CONSTANT "wx:const-type-colourmap" : int wxTYPE_COLOURMAP
+@CONSTANT "wx:const-type-cusor" : int wxTYPE_CURSOR
+@CONSTANT "wx:const-type-dde-cliebt" : int wxTYPE_DDE_CLIENT
+@CONSTANT "wx:const-type-dde-server" : int wxTYPE_DDE_SERVER
+@CONSTANT "wx:const-type-dde-connection" : int wxTYPE_DDE_CONNECTION
+@CONSTANT "wx:const-type-help-instance" : int wxTYPE_HELP_INSTANCE
+@CONSTANT "wx:const-type-list" : int wxTYPE_LIST
+@CONSTANT "wx:const-type-string-list" : int wxTYPE_STRING_LIST
+@CONSTANT "wx:const-type-hash-table" : int wxTYPE_HASH_TABLE
+@CONSTANT "wx:const-type-node" : int wxTYPE_NODE
+@CONSTANT "wx:const-type-app" : int wxTYPE_APP
+@CONSTANT "wx:const-type-enhanced-dialog" : int wxTYPE_ENHANCED_DIALOG
+@CONSTANT "wx:const-type-toolbar" : int wxTYPE_TOOLBAR  ## NEWEST_TYPES
+@CONSTANT "wx:const-type-buttonbar" : int wxTYPE_BUTTONBAR  ## NEWEST_TYPES
+@CONSTANT "wx:const-type-user" : int wxTYPE_USER
+
+
+@END
+
+@GLOBAL wxsTypesGlobal
+
+@ "wx:get-type-name" : string wxGetTypeName(int);
+
+@END
+
+
+#endif
diff --git a/src/mred/wxs/wxs_mpb.cxx b/src/mred/wxs/wxs_mpb.cxx
new file mode 100644
index 0000000..ec6c6d8
--- /dev/null
+++ b/src/mred/wxs/wxs_mpb.cxx
@@ -0,0 +1,4411 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_mpb.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_media.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_mpb.h"
+#include "wxscomon.h"
+
+
+
+
+
+
+/* 
+   X = Not meant for virtual, defined in wxMediaEdit/wxMediaPasteboard
+       and overloaded there
+   Y = Virtual, defined in wxMediaEdit/wxMediaPasteboard
+   Z = Virtual, defined in wxMediaBuffer 
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxMediaPasteboard : public wxMediaPasteboard {
+ public:
+
+  os_wxMediaPasteboard(Scheme_Object * obj);
+  ~os_wxMediaPasteboard();
+  void AfterInteractiveResize(class wxSnip* x0);
+  Bool OnInteractiveResize(class wxSnip* x0);
+  void AfterInteractiveMove();
+  Bool OnInteractiveMove();
+  void InteractiveAdjustResize(class wxSnip* x0, float* x1, float* x2);
+  void InteractiveAdjustMove(class wxSnip* x0, float* x1, float* x2);
+  void InteractiveAdjustMouse(float* x0, float* x1);
+  void OnDoubleClick(class wxSnip* x0, class wxMouseEvent& x1);
+  void AfterSelect(class wxSnip* x0, Bool x1);
+  Bool OnSelect(class wxSnip* x0, Bool x1);
+  void AfterResize(class wxSnip* x0, float x1, float x2, Bool x3);
+  Bool OnResize(class wxSnip* x0, float x1, float x2);
+  void AfterMoveTo(class wxSnip* x0, float x1, float x2, Bool x3);
+  Bool OnMoveTo(class wxSnip* x0, float x1, float x2, Bool x3);
+  void AfterDelete(class wxSnip* x0);
+  Bool OnDelete(class wxSnip* x0);
+  void AfterInsert(class wxSnip* x0, class wxSnip* x1, float x2, float x3);
+  Bool OnInsert(class wxSnip* x0, class wxSnip* x1, float x2, float x3);
+  void DoPaste(long x0);
+  void DoCopy(long x0, Bool x1);
+  nstring PutFile(nstring x0, nstring x1);
+  nstring GetFile(nstring x0);
+  void AfterEditSequence();
+  void OnEditSequence();
+  void AfterLoadFile(Bool x0);
+  Bool OnLoadFile(string x0, int x1);
+  void AfterSaveFile(Bool x0);
+  Bool OnSaveFile(string x0, int x1);
+  class wxSnip* OnNewBox(int x0);
+  class wxImageSnip* OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3);
+  void InvalidateBitmapCache(float x0 = 0.0, float x1 = 0.0, float x2 = -1.0, float x3 = -1.0);
+  void OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8);
+  Bool WriteFootersToFile(class wxMediaStreamOut& x0);
+  Bool WriteHeadersToFile(class wxMediaStreamOut& x0);
+  Bool ReadFooterFromFile(class wxMediaStreamIn& x0, string x1);
+  Bool ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1);
+  void SetFilename(string x0, Bool x1 = FALSE);
+  Bool ReleaseSnip(class wxSnip* x0);
+  void SetModified(Bool x0);
+  void SetSnipData(class wxSnip* x0, class wxBufferData* x1);
+  class wxBufferData* GetSnipData(class wxSnip* x0);
+  void NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4);
+  void Resized(class wxSnip* x0, Bool x1);
+  void SetCaretOwner(class wxSnip* x0, int x1 = wxFOCUS_IMMEDIATE);
+  Bool ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5);
+  void OnChange();
+  void OnFocus(Bool x0);
+  void OnDefaultChar(class wxKeyEvent& x0);
+  void OnDefaultEvent(class wxMouseEvent& x0);
+  void OnLocalChar(class wxKeyEvent& x0);
+  void OnLocalEvent(class wxMouseEvent& x0);
+  void SizeCacheInvalid();
+  void OwnCaret(Bool x0);
+  void Refresh(float x0, float x1, float x2, float x3, Bool x4);
+  class wxCursor* AdjustCursor(class wxMouseEvent& x0);
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+};
+
+Scheme_Object *os_wxMediaPasteboard_class;
+
+os_wxMediaPasteboard::os_wxMediaPasteboard(Scheme_Object * o)
+: wxMediaPasteboard()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaPasteboard::~os_wxMediaPasteboard()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMediaPasteboard::AfterInteractiveResize(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-interactive-resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterInteractiveResize(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnInteractiveResize(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-interactive-resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnInteractiveResize(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-interactive-resize"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterInteractiveMove()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-interactive-move", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterInteractiveMove();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnInteractiveMove()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-interactive-move", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnInteractiveMove();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-interactive-move"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::InteractiveAdjustResize(class wxSnip* x0, float* x1, float* x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "interactive-adjust-resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::InteractiveAdjustResize(x0, x1, x2);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_box(scheme_make_double((*x1)));
+  p[2] = objscheme_box(scheme_make_double((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-resize"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-resize"", extracting return value via box");
+  if (x2) *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-pasteboard%::interactive-adjust-resize"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-resize"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::InteractiveAdjustMove(class wxSnip* x0, float* x1, float* x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "interactive-adjust-move", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::InteractiveAdjustMove(x0, x1, x2);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_box(scheme_make_double((*x1)));
+  p[2] = objscheme_box(scheme_make_double((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-move"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-move"", extracting return value via box");
+  if (x2) *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-pasteboard%::interactive-adjust-move"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-move"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::InteractiveAdjustMouse(float* x0, float* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "interactive-adjust-mouse", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::InteractiveAdjustMouse(x0, x1);
+  } else {
+  
+  p[0] = objscheme_box(scheme_make_double((*x0)));
+  p[1] = objscheme_box(scheme_make_double((*x1)));
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  if (x0) *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-pasteboard%::interactive-adjust-mouse"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-mouse"", extracting return value via box");
+  if (x1) *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-mouse"", extracting return value via box"), "wx:media-pasteboard%::interactive-adjust-mouse"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnDoubleClick(class wxSnip* x0, class wxMouseEvent& x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-double-click", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnDoubleClick(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(&x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::AfterSelect(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-select", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterSelect(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnSelect(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-select", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnSelect(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-select"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterResize(class wxSnip* x0, float x1, float x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterResize(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnResize(class wxSnip* x0, float x1, float x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnResize(x0, x1, x2);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-resize"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterMoveTo(class wxSnip* x0, float x1, float x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-move-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterMoveTo(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnMoveTo(class wxSnip* x0, float x1, float x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-move-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnMoveTo(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-move-to"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterDelete(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-delete", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterDelete(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnDelete(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-delete", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnDelete(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-delete"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterInsert(class wxSnip* x0, class wxSnip* x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-insert", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterInsert(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxSnip(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnInsert(class wxSnip* x0, class wxSnip* x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-insert", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnInsert(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxSnip(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-insert"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::DoPaste(long x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "do-paste", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::DoPaste(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::DoCopy(long x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "do-copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::DoCopy(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+nstring os_wxMediaPasteboard::PutFile(nstring x0, nstring x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "put-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::PutFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-pasteboard%::put-file"", extracting return value");
+  }
+}
+
+nstring os_wxMediaPasteboard::GetFile(nstring x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "get-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::GetFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (nstring)objscheme_unbundle_nullable_string(v, "wx:media-pasteboard%::get-file"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnEditSequence()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-edit-sequence", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnEditSequence();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::AfterLoadFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterLoadFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnLoadFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-load-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnLoadFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-load-file"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::AfterSaveFile(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "after-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::AfterSaveFile(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::OnSaveFile(string x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-save-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnSaveFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::on-save-file"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxMediaPasteboard::OnNewBox(int x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-new-box", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnNewBox(x0);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:media-pasteboard%::on-new-box"", extracting return value", 0);
+  }
+}
+
+class wxImageSnip* os_wxMediaPasteboard::OnNewImageSnip(nstring x0, long x1, Bool x2, Bool x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-new-image-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::OnNewImageSnip(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  p[3] = (x3 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxImageSnip(v, "wx:media-pasteboard%::on-new-image-snip"", extracting return value", 0);
+  }
+}
+
+void os_wxMediaPasteboard::InvalidateBitmapCache(float x0, float x1, float x2, float x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "invalidate-bitmap-cache", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::InvalidateBitmapCache(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnPaint(Bool x0, class wxDC* x1, float x2, float x3, float x4, float x5, float x6, float x7, int x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  p[1] = objscheme_bundle_wxDC(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_integer(x8);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::WriteFootersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "write-footers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::WriteFootersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::write-footers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaPasteboard::WriteHeadersToFile(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "write-headers-to-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::WriteHeadersToFile(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::write-headers-to-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaPasteboard::ReadFooterFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "read-footer-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::ReadFooterFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::read-footer-from-file"", extracting return value");
+  }
+}
+
+Bool os_wxMediaPasteboard::ReadHeaderFromFile(class wxMediaStreamIn& x0, string x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "read-header-from-file", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::ReadHeaderFromFile(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  p[1] = objscheme_bundle_string((char *)x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::read-header-from-file"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::SetFilename(string x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "set-filename", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::SetFilename(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_string((char *)x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::ReleaseSnip(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "release-snip", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::ReleaseSnip(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::release-snip"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::SetModified(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "set-modified", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::SetModified(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::SetSnipData(class wxSnip* x0, class wxBufferData* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "set-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::SetSnipData(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = objscheme_bundle_wxBufferData(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxBufferData* os_wxMediaPasteboard::GetSnipData(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "get-snip-data", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::GetSnipData(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxBufferData(v, "wx:media-pasteboard%::get-snip-data"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaPasteboard::NeedsUpdate(class wxSnip* x0, float x1, float x2, float x3, float x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "needs-update", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::NeedsUpdate(x0, x1, x2, x3, x4);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::Resized(class wxSnip* x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "resized", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::Resized(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::SetCaretOwner(class wxSnip* x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "set-caret-owner", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::SetCaretOwner(x0, x1);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaPasteboard::ScrollTo(class wxSnip* x0, float x1, float x2, float x3, float x4, Bool x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "scroll-to", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::ScrollTo(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = (x5 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-pasteboard%::scroll-to"", extracting return value");
+  }
+}
+
+void os_wxMediaPasteboard::OnChange()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-change", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnChange();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnFocus(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnFocus(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnDefaultChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-default-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnDefaultChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnDefaultEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-default-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnDefaultEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnLocalChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-local-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnLocalChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnLocalEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-local-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnLocalEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::Refresh(float x0, float x1, float x2, float x3, Bool x4)
+{
+  Scheme_Object *p[5];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "refresh", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::Refresh(x0, x1, x2, x3, x4);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = (x4 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 5, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxMediaPasteboard::AdjustCursor(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaPasteboard::AdjustCursor(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:media-pasteboard%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaPasteboard::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaPasteboard::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaPasteboard_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaPasteboard::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetScrollStep(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::set-scroll-step");
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetScrollStep(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetScrollStep(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetScrollStep();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetSelectionVisible(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::set-selection-visible");
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetSelectionVisible(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetSelectionVisible(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetSelectionVisible();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetDragable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::set-dragable");
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetDragable(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetDragable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetDragable();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterInteractiveResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-interactive-resize", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterInteractiveResize(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterInteractiveResize(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnInteractiveResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-interactive-resize", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnInteractiveResize(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnInteractiveResize(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterInteractiveMove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterInteractiveMove();
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterInteractiveMove();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnInteractiveMove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnInteractiveMove();
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnInteractiveMove();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardInteractiveAdjustResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::interactive-adjust-resize", 0);
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-resize", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-resize"), "wx:media-pasteboard%::interactive-adjust-resize");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-resize", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-pasteboard%::interactive-adjust-resize"), "wx:media-pasteboard%::interactive-adjust-resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::InteractiveAdjustResize(x0, x1, x2);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->InteractiveAdjustResize(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardInteractiveAdjustMove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::interactive-adjust-move", 0);
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-move", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-move"), "wx:media-pasteboard%::interactive-adjust-move");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-move", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:media-pasteboard%::interactive-adjust-move"), "wx:media-pasteboard%::interactive-adjust-move");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::InteractiveAdjustMove(x0, x1, x2);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->InteractiveAdjustMove(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardInteractiveAdjustMouse(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-mouse", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-pasteboard%::interactive-adjust-mouse"), "wx:media-pasteboard%::interactive-adjust-mouse");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-pasteboard%::interactive-adjust-mouse", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::interactive-adjust-mouse"), "wx:media-pasteboard%::interactive-adjust-mouse");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::InteractiveAdjustMouse(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->InteractiveAdjustMouse(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnDoubleClick(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-double-click", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:media-pasteboard%::on-double-click", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnDoubleClick(x0, *x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnDoubleClick(x0, *x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterSelect(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-select", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::after-select");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterSelect(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterSelect(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnSelect(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-select", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::on-select");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnSelect(x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnSelect(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-resize", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::after-resize");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::after-resize");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-pasteboard%::after-resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterResize(x0, x1, x2, x3);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterResize(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-resize", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::on-resize");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::on-resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnResize(x0, x1, x2);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnResize(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterMoveTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-move-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::after-move-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::after-move-to");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-pasteboard%::after-move-to");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterMoveTo(x0, x1, x2, x3);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterMoveTo(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnMoveTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  Bool x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-move-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::on-move-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::on-move-to");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-pasteboard%::on-move-to");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnMoveTo(x0, x1, x2, x3);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnMoveTo(x0, x1, x2, x3);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-delete", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterDelete(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterDelete(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-delete", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnDelete(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnDelete(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxSnip* x1;
+  float x2;
+  float x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::after-insert", 0);
+  x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::after-insert", 1);
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::after-insert");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::after-insert");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterInsert(x0, x1, x2, x3);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterInsert(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxSnip* x1;
+  float x2;
+  float x3;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::on-insert", 0);
+  x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::on-insert", 1);
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::on-insert");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::on-insert");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnInsert(x0, x1, x2, x3);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnInsert(x0, x1, x2, x3);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardFindNextSelectedSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::find-next-selected-snip", 1);
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->FindNextSelectedSnip(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardIsSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::is-selected?", 1);
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->IsSelected(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardFindFirstSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->FindFirstSnip();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardFindSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::find-snip");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::find-snip");
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->FindSnip(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAddPasteboardFunctions(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeymap* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeymap(p[0], "wx:media-pasteboard%::add-pasteboard-functions", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AddPasteboardFunctions(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetCenter(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-pasteboard%::get-center", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:media-pasteboard%::get-center"), "wx:media-pasteboard%::get-center");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-pasteboard%::get-center", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:media-pasteboard%::get-center"), "wx:media-pasteboard%::get-center");
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetCenter(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardRemoveSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::remove-selected", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->RemoveSelected(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardNoSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->NoSelected();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAddSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxSnip(p[0], NULL, 0)) {
+    class wxSnip* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-pasteboard%::add-selected (wx:snip% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::add-selected (wx:snip% case)", 0);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AddSelected(x0);
+
+    
+    
+  } else  {
+    float x0;
+    float x1;
+    float x2;
+    float x3;
+
+    
+    if (n != 4) 
+      scheme_wrong_count("wx:media-pasteboard%::add-selected (rectangle case)", 4, 4, n, p);
+    x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::add-selected (rectangle case)");
+    x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::add-selected (rectangle case)");
+    x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::add-selected (rectangle case)");
+    x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::add-selected (rectangle case)");
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AddSelected(x0, x1, x2, x3);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetSelected(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::set-selected", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetSelected(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardChangeStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_wxStyleDelta(p[0], NULL, 1) && objscheme_istype_wxSnip(p[1], NULL, 1)) {
+    class wxStyleDelta* x0;
+    class wxSnip* x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:media-pasteboard%::change-style (wx:style-delta% and wx:snip% case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:media-pasteboard%::change-style (wx:style-delta% and wx:snip% case)", 1);
+    x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::change-style (wx:style-delta% and wx:snip% case)", 1);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0, x1);
+
+    
+    
+  } else if ((n >= 1) && objscheme_istype_wxStyleDelta(p[0], NULL, 1)) {
+    class wxStyleDelta* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-pasteboard%::change-style (wx:style-delta% without position or wx:snip% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:media-pasteboard%::change-style (wx:style-delta% without position or wx:snip% case)", 1);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0);
+
+    
+    
+  } else  {
+    class wxStyle* x0;
+    class wxSnip* x1;
+
+    
+    if ((n < 1) ||(n > 2)) 
+      scheme_wrong_count("wx:media-pasteboard%::change-style (wx:style% case)", 1, 2, n, p);
+    x0 = objscheme_unbundle_wxStyle(p[0], "wx:media-pasteboard%::change-style (wx:style% case)", 1);
+    if (n > 1) {
+      x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::change-style (wx:style% case)", 1);
+    } else
+      x1 = NULL;
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ChangeStyle(x0, x1);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetAfter(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxSnip* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::set-after", 0);
+  x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::set-after", 1);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetAfter(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetBefore(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxSnip* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::set-before", 0);
+  x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::set-before", 1);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetBefore(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardLower(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::lower", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Lower(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardRaise(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::raise", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Raise(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::resize", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::resize");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::resize");
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardMove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxSnip(p[0], NULL, 0)) {
+    class wxSnip* x0;
+    float x1;
+    float x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:media-pasteboard%::move (wx:snip% case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::move (wx:snip% case)", 0);
+    x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::move (wx:snip% case)");
+    x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::move (wx:snip% case)");
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Move(x0, x1, x2);
+
+    
+    
+  } else  {
+    float x0;
+    float x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:media-pasteboard%::move (without wx:snip% case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::move (without wx:snip% case)");
+    x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::move (without wx:snip% case)");
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Move(x0, x1);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardMoveTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::move-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::move-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::move-to");
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->MoveTo(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardRemove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::remove", 0);
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Remove(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardErase(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Erase();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardDoPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-pasteboard%::do-paste");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::DoPaste(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->DoPaste(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardDoCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-pasteboard%::do-copy");
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::do-copy");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::DoCopy(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->DoCopy(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardDelete(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_wxSnip(p[0], NULL, 0)) {
+    class wxSnip* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-pasteboard%::delete (wx:snip% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::delete (wx:snip% case)", 0);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Delete(x0);
+
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:media-pasteboard%::delete (no argument case)", 0, 0, n, p);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Delete();
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 2) && objscheme_istype_wxSnip(p[0], NULL, 0) && objscheme_istype_number(p[1], NULL)) {
+    class wxSnip* x0;
+    float x1;
+    float x2;
+
+    
+    if (n != 3) 
+      scheme_wrong_count("wx:media-pasteboard%::insert (wx:snip% with location case)", 3, 3, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::insert (wx:snip% with location case)", 0);
+    x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::insert (wx:snip% with location case)");
+    x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::insert (wx:snip% with location case)");
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2);
+
+    
+    
+  } else if ((n >= 3) && objscheme_istype_wxSnip(p[0], NULL, 0) && objscheme_istype_wxSnip(p[1], NULL, 1) && objscheme_istype_number(p[2], NULL)) {
+    class wxSnip* x0;
+    class wxSnip* x1;
+    float x2;
+    float x3;
+
+    
+    if (n != 4) 
+      scheme_wrong_count("wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% and location case)", 4, 4, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% and location case)", 0);
+    x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% and location case)", 1);
+    x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% and location case)");
+    x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% and location case)");
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2, x3);
+
+    
+    
+  } else if ((n >= 2) && objscheme_istype_wxSnip(p[0], NULL, 0) && objscheme_istype_wxSnip(p[1], NULL, 1)) {
+    class wxSnip* x0;
+    class wxSnip* x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% case)", 0);
+    x1 = objscheme_unbundle_wxSnip(p[1], "wx:media-pasteboard%::insert (wx:snip% with before-wx:snip% case)", 1);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1);
+
+    
+    
+  } else  {
+    class wxSnip* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:media-pasteboard%::insert (wx:snip% without position case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::insert (wx:snip% without position case)", 0);
+
+    
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetFlattenedText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long _x0;
+  long* x0 = &_x0;
+
+  
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetFlattenedText(x0);
+
+  
+  
+  return scheme_make_sized_string(r, _x0, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardPutFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  nstring x1;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-pasteboard%::put-file");
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:media-pasteboard%::put-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::PutFile(x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->PutFile(x0, x1);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  nstring x0;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-pasteboard%::get-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::GetFile(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetFile(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterEditSequence();
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnEditSequence(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnEditSequence();
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnEditSequence();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::after-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterLoadFile(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterLoadFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-pasteboard%::on-load-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::on-load-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnLoadFile(x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnLoadFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAfterSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::after-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AfterSaveFile(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AfterSaveFile(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  string x0;
+  int x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-pasteboard%::on-save-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::on-save-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnSaveFile(x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnSaveFile(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnNewBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-pasteboard%::on-new-box");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnNewBox(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnNewBox(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnNewImageSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxImageSnip* r;
+  objscheme_check_valid(obj);
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:media-pasteboard%::on-new-image-snip");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::on-new-image-snip");
+  x2 = objscheme_unbundle_bool(p[2], "wx:media-pasteboard%::on-new-image-snip");
+  x3 = objscheme_unbundle_bool(p[3], "wx:media-pasteboard%::on-new-image-snip");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnNewImageSnip(x0, x1, x2, x3);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnNewImageSnip(x0, x1, x2, x3);
+
+  
+  
+  return objscheme_bundle_wxImageSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardInvalidateBitmapCache(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::invalidate-bitmap-cache");
+  } else
+    x0 = 0.0;
+  if (n > 1) {
+    x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::invalidate-bitmap-cache");
+  } else
+    x1 = 0.0;
+  if (n > 2) {
+    x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::invalidate-bitmap-cache");
+  } else
+    x2 = -1.0;
+  if (n > 3) {
+    x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::invalidate-bitmap-cache");
+  } else
+    x3 = -1.0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::InvalidateBitmapCache(x0, x1, x2, x3);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->InvalidateBitmapCache(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  class wxDC* x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  int x8;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::on-paint");
+  x1 = objscheme_unbundle_wxDC(p[1], "wx:media-pasteboard%::on-paint", 0);
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::on-paint");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::on-paint");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-pasteboard%::on-paint");
+  x5 = objscheme_unbundle_float(p[5], "wx:media-pasteboard%::on-paint");
+  x6 = objscheme_unbundle_float(p[6], "wx:media-pasteboard%::on-paint");
+  x7 = objscheme_unbundle_float(p[7], "wx:media-pasteboard%::on-paint");
+  x8 = objscheme_unbundle_integer(p[8], "wx:media-pasteboard%::on-paint");
+
+  if (x1 && !x1->Ok()) scheme_signal_error("%s: bad bitmap", "wx:media-buffer%::on-paint");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnPaint(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardWriteFootersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-pasteboard%::write-footers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::WriteFootersToFile(*x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->WriteFootersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardWriteHeadersToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-pasteboard%::write-headers-to-file", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::WriteHeadersToFile(*x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->WriteHeadersToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardReadFooterFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-pasteboard%::read-footer-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-pasteboard%::read-footer-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::ReadFooterFromFile(*x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ReadFooterFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardReadHeaderFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  string x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-pasteboard%::read-header-from-file", 0);
+  x1 = (string)objscheme_unbundle_string(p[1], "wx:media-pasteboard%::read-header-from-file");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::ReadHeaderFromFile(*x0, x1);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ReadHeaderFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardWriteToFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-pasteboard%::write-to-file", 0);
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->WriteToFile(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardReadFromFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:media-pasteboard%::read-from-file", 0);
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::read-from-file");
+  } else
+    x1 = FALSE;
+
+  
+  r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ReadFromFile(*x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetFilename(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  Bool x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:media-pasteboard%::set-filename");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::set-filename");
+  } else
+    x1 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::SetFilename(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetFilename(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardReleaseSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::release-snip", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::ReleaseSnip(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ReleaseSnip(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetModified(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::set-modified");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::SetModified(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetModified(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  class wxBufferData* x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::set-snip-data", 0);
+  x1 = objscheme_unbundle_wxBufferData(p[1], "wx:media-pasteboard%::set-snip-data", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::SetSnipData(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetSnipData(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardGetSnipData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferData* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::get-snip-data", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::GetSnipData(x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->GetSnipData(x0);
+
+  
+  
+  return objscheme_bundle_wxBufferData(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardNeedsUpdate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::needs-update", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::needs-update");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::needs-update");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::needs-update");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-pasteboard%::needs-update");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::NeedsUpdate(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->NeedsUpdate(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardResized(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::resized", 0);
+  x1 = objscheme_unbundle_bool(p[1], "wx:media-pasteboard%::resized");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::Resized(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Resized(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSetCaretOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::set-caret-owner", 1);
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::set-caret-owner");
+  } else
+    x1 = wxFOCUS_IMMEDIATE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::SetCaretOwner(x0, x1);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SetCaretOwner(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardScrollTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  Bool x5;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-pasteboard%::scroll-to", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::scroll-to");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::scroll-to");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::scroll-to");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-pasteboard%::scroll-to");
+  x5 = objscheme_unbundle_bool(p[5], "wx:media-pasteboard%::scroll-to");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::ScrollTo(x0, x1, x2, x3, x4, x5);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->ScrollTo(x0, x1, x2, x3, x4, x5);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnChange(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnChange();
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnChange();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::on-focus");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnFocus(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnFocus(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnDefaultChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-pasteboard%::on-default-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnDefaultChar(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnDefaultEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-pasteboard%::on-default-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnDefaultEvent(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnLocalChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-pasteboard%::on-local-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnLocalChar(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnLocalChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnLocalEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-pasteboard%::on-local-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnLocalEvent(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnLocalEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::SizeCacheInvalid();
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OwnCaret(x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+  float x3;
+  Bool x4;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-pasteboard%::refresh");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-pasteboard%::refresh");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-pasteboard%::refresh");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-pasteboard%::refresh");
+  x4 = objscheme_unbundle_bool(p[4], "wx:media-pasteboard%::refresh");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::Refresh(x0, x1, x2, x3, x4);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Refresh(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-pasteboard%::adjust-cursor", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::AdjustCursor(*x0);
+  else
+    r = ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(*x0);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:media-pasteboard%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnChar(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:media-pasteboard%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->wxMediaPasteboard::OnEvent(*x0);
+  else
+    ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardKill(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-pasteboard%::kill");
+  } else
+    x0 = 0;
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Kill(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:media-pasteboard%::paste");
+  } else
+    x0 = 0;
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Paste(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  long x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::copy");
+  } else
+    x0 = FALSE;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::copy");
+  } else
+    x1 = 0;
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboardCut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+  long x1;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_bool(p[0], "wx:media-pasteboard%::cut");
+  } else
+    x0 = FALSE;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:media-pasteboard%::cut");
+  } else
+    x1 = 0;
+
+  
+  ((wxMediaPasteboard *)((Scheme_Class_Object *)obj)->primdata)->Cut(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaPasteboard_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaPasteboard *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:media-pasteboard%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxMediaPasteboard(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaPasteboard(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-pasteboard%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-pasteboard%");
+}
+
+void objscheme_setup_wxMediaPasteboard(void *env)
+{
+if (os_wxMediaPasteboard_class) {
+    objscheme_add_global_class(os_wxMediaPasteboard_class,  "wx:media-pasteboard%", env);
+} else {
+  os_wxMediaPasteboard_class = objscheme_def_prim_class(env, "wx:media-pasteboard%", "wx:media-buffer%", os_wxMediaPasteboard_ConstructScheme, 93);
+
+  scheme_add_method_w_arity(os_wxMediaPasteboard_class,"get-class-name",objscheme_classname_os_wxMediaPasteboard, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-scroll-step", os_wxMediaPasteboardSetScrollStep, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-scroll-step", os_wxMediaPasteboardGetScrollStep, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-selection-visible", os_wxMediaPasteboardSetSelectionVisible, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-selection-visible", os_wxMediaPasteboardGetSelectionVisible, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-dragable", os_wxMediaPasteboardSetDragable, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-dragable", os_wxMediaPasteboardGetDragable, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-interactive-resize", os_wxMediaPasteboardAfterInteractiveResize, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-interactive-resize", os_wxMediaPasteboardOnInteractiveResize, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-interactive-move", os_wxMediaPasteboardAfterInteractiveMove, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-interactive-move", os_wxMediaPasteboardOnInteractiveMove, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "interactive-adjust-resize", os_wxMediaPasteboardInteractiveAdjustResize, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "interactive-adjust-move", os_wxMediaPasteboardInteractiveAdjustMove, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "interactive-adjust-mouse", os_wxMediaPasteboardInteractiveAdjustMouse, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-double-click", os_wxMediaPasteboardOnDoubleClick, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-select", os_wxMediaPasteboardAfterSelect, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-select", os_wxMediaPasteboardOnSelect, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-resize", os_wxMediaPasteboardAfterResize, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-resize", os_wxMediaPasteboardOnResize, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-move-to", os_wxMediaPasteboardAfterMoveTo, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-move-to", os_wxMediaPasteboardOnMoveTo, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-delete", os_wxMediaPasteboardAfterDelete, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-delete", os_wxMediaPasteboardOnDelete, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-insert", os_wxMediaPasteboardAfterInsert, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-insert", os_wxMediaPasteboardOnInsert, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "find-next-selected-snip", os_wxMediaPasteboardFindNextSelectedSnip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "is-selected?", os_wxMediaPasteboardIsSelected, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "find-first-snip", os_wxMediaPasteboardFindFirstSnip, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "find-snip", os_wxMediaPasteboardFindSnip, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "add-pasteboard-functions", os_wxMediaPasteboardAddPasteboardFunctions, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-center", os_wxMediaPasteboardGetCenter, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "remove-selected", os_wxMediaPasteboardRemoveSelected, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "no-selected", os_wxMediaPasteboardNoSelected, 0, 0);
+ scheme_add_method(os_wxMediaPasteboard_class, "add-selected", os_wxMediaPasteboardAddSelected);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-selected", os_wxMediaPasteboardSetSelected, 1, 1);
+ scheme_add_method(os_wxMediaPasteboard_class, "change-style", os_wxMediaPasteboardChangeStyle);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-after", os_wxMediaPasteboardSetAfter, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-before", os_wxMediaPasteboardSetBefore, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "lower", os_wxMediaPasteboardLower, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "raise", os_wxMediaPasteboardRaise, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "resize", os_wxMediaPasteboardResize, 3, 3);
+ scheme_add_method(os_wxMediaPasteboard_class, "move", os_wxMediaPasteboardMove);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "move-to", os_wxMediaPasteboardMoveTo, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "remove", os_wxMediaPasteboardRemove, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "erase", os_wxMediaPasteboardErase, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "do-paste", os_wxMediaPasteboardDoPaste, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "do-copy", os_wxMediaPasteboardDoCopy, 2, 2);
+ scheme_add_method(os_wxMediaPasteboard_class, "delete", os_wxMediaPasteboardDelete);
+ scheme_add_method(os_wxMediaPasteboard_class, "insert", os_wxMediaPasteboardInsert);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-flattened-text", os_wxMediaPasteboardGetFlattenedText, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "put-file", os_wxMediaPasteboardPutFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-file", os_wxMediaPasteboardGetFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-edit-sequence", os_wxMediaPasteboardAfterEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-edit-sequence", os_wxMediaPasteboardOnEditSequence, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-load-file", os_wxMediaPasteboardAfterLoadFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-load-file", os_wxMediaPasteboardOnLoadFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "after-save-file", os_wxMediaPasteboardAfterSaveFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-save-file", os_wxMediaPasteboardOnSaveFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-new-box", os_wxMediaPasteboardOnNewBox, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-new-image-snip", os_wxMediaPasteboardOnNewImageSnip, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "invalidate-bitmap-cache", os_wxMediaPasteboardInvalidateBitmapCache, 0, 4);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-paint", os_wxMediaPasteboardOnPaint, 9, 9);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "write-footers-to-file", os_wxMediaPasteboardWriteFootersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "write-headers-to-file", os_wxMediaPasteboardWriteHeadersToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "read-footer-from-file", os_wxMediaPasteboardReadFooterFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "read-header-from-file", os_wxMediaPasteboardReadHeaderFromFile, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "write-to-file", os_wxMediaPasteboardWriteToFile, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "read-from-file", os_wxMediaPasteboardReadFromFile, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-filename", os_wxMediaPasteboardSetFilename, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "release-snip", os_wxMediaPasteboardReleaseSnip, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-modified", os_wxMediaPasteboardSetModified, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-snip-data", os_wxMediaPasteboardSetSnipData, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "get-snip-data", os_wxMediaPasteboardGetSnipData, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "needs-update", os_wxMediaPasteboardNeedsUpdate, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "resized", os_wxMediaPasteboardResized, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "set-caret-owner", os_wxMediaPasteboardSetCaretOwner, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "scroll-to", os_wxMediaPasteboardScrollTo, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-change", os_wxMediaPasteboardOnChange, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-focus", os_wxMediaPasteboardOnFocus, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-default-char", os_wxMediaPasteboardOnDefaultChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-default-event", os_wxMediaPasteboardOnDefaultEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-local-char", os_wxMediaPasteboardOnLocalChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-local-event", os_wxMediaPasteboardOnLocalEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "size-cache-invalid", os_wxMediaPasteboardSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "own-caret", os_wxMediaPasteboardOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "refresh", os_wxMediaPasteboardRefresh, 5, 5);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "adjust-cursor", os_wxMediaPasteboardAdjustCursor, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-char", os_wxMediaPasteboardOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "on-event", os_wxMediaPasteboardOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "kill", os_wxMediaPasteboardKill, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "paste", os_wxMediaPasteboardPaste, 0, 1);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "copy", os_wxMediaPasteboardCopy, 0, 2);
+ scheme_add_method_w_arity(os_wxMediaPasteboard_class, "cut", os_wxMediaPasteboardCut, 0, 2);
+
+
+  scheme_made_class(os_wxMediaPasteboard_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaPasteboard, wxTYPE_MEDIA_PASTEBOARD);
+
+}
+}
+
+int objscheme_istype_wxMediaPasteboard(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaPasteboard_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-pasteboard%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaPasteboard(class wxMediaPasteboard *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_PASTEBOARD) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaPasteboard_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaPasteboard *objscheme_unbundle_wxMediaPasteboard(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaPasteboard(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaPasteboard *)o->primdata;
+  else
+    return (wxMediaPasteboard *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_mpb.h b/src/mred/wxs/wxs_mpb.h
new file mode 100644
index 0000000..a2b58cb
--- /dev/null
+++ b/src/mred/wxs/wxs_mpb.h
@@ -0,0 +1,136 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxImageSnip *objscheme_unbundle_wxImageSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxKeymap *objscheme_unbundle_wxKeymap(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxStyleDelta(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxImageSnip(class wxImageSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaPasteboard(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaPasteboard(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaPasteboard(class wxMediaPasteboard *realobj);
+class wxMediaPasteboard *objscheme_unbundle_wxMediaPasteboard(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_mpb.xc b/src/mred/wxs/wxs_mpb.xc
new file mode 100644
index 0000000..a00a390
--- /dev/null
+++ b/src/mred/wxs/wxs_mpb.xc
@@ -0,0 +1,95 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_media.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxMediaPasteboard "wx:media-pasteboard" : "wx:media-buffer"
+
+@CREATOR ()
+
+@CLASSID wxTYPE_MEDIA_PASTEBOARD
+
+@SETMARK X = 
+@SETMARK Y = d
+@SETMARK Z = d
+@INCLUDE wxs_mbuf.xci
+
+@ "insert" : void Insert(wxSnip!,float,float); <> wx:snip% with location
+@ "insert" : void Insert(wxSnip!,wxSnip^); <> wx:snip% with before-wx:snip%
+@ "insert" : void Insert(wxSnip!,wxSnip^,float,float); <> wx:snip% with before-wx:snip% and location
+
+@ "delete" : void Delete(); <> no argument
+@ "delete" : void Delete(wxSnip!); <> wx:snip%
+
+@ v "do-copy" : void DoCopy(long,bool);
+@ v "do-paste" : void DoPaste(long);
+
+@ "erase" : void Erase();
+
+@ "remove" : void Remove(wxSnip!);
+
+@ "move-to" : void MoveTo(wxSnip!,float,float);
+@ "move" : void Move(wxSnip!,float,float); <> wx:snip%
+@ "move" : void Move(float,float); <> without wx:snip%
+
+@ "resize" : bool Resize(wxSnip!, float, float);
+
+@ "raise" : void Raise(wxSnip!);
+@ "lower" : void Lower(wxSnip!);
+@ "set-before" : void SetBefore(wxSnip!,wxSnip^);
+@ "set-after" : void SetAfter(wxSnip!,wxSnip^);
+  
+@ "change-style" : void ChangeStyle(wxStyleDelta^,wxSnip^); <> wx:style-delta% and wx:snip%
+@ "change-style" : void ChangeStyle(wxStyle^,wxSnip^=NULL); <> wx:style%
+
+@ "set-selected" : void SetSelected(wxSnip!);
+@ "add-selected" : void AddSelected(wxSnip!); <> wx:snip%
+@ "add-selected" : void AddSelected(float,float,float,float); <> rectangle
+@ "no-selected" :  void NoSelected();
+@ "remove-selected" :  void RemoveSelected(wxSnip!);
+
+@ "get-center" : void GetCenter(float*, float*);
+
+@ "add-pasteboard-functions" : void AddPasteboardFunctions(wxKeymap!);
+
+@ "find-snip" : wxSnip^ FindSnip(float,float);
+@ "find-first-snip" : wxSnip^ FindFirstSnip();
+@ "is-selected?" : bool IsSelected(wxSnip^);
+@ "find-next-selected-snip" : wxSnip^ FindNextSelectedSnip(wxSnip^);
+
+@ v "on-insert" : bool OnInsert(wxSnip!,wxSnip^,float, float);
+@ v "after-insert" : void AfterInsert(wxSnip!,wxSnip^,float,float);
+@ v "on-delete" : bool OnDelete(wxSnip!);
+@ v "after-delete" :  void AfterDelete(wxSnip!);
+@ v "on-move-to" :  bool OnMoveTo(wxSnip!,float,float,bool);
+@ v "after-move-to" :  void AfterMoveTo(wxSnip!,float,float,bool);
+@ v "on-resize" :  bool OnResize(wxSnip!,float,float);
+@ v "after-resize" :  void AfterResize(wxSnip!,float,float,bool);
+
+@ v "on-select" : bool OnSelect(wxSnip!, bool);
+@ v "after-select" :  void AfterSelect(wxSnip!, bool);
+
+@ v "on-double-click" : void OnDoubleClick(wxSnip!, wxMouseEvent%);
+
+@ v "interactive-adjust-mouse" : void InteractiveAdjustMouse(float*,float*);
+@ v "interactive-adjust-move" : void InteractiveAdjustMove(wxSnip!,float*,float*);
+@ v "interactive-adjust-resize" : void InteractiveAdjustResize(wxSnip!,float*,float*);
+
+@ v "on-interactive-move" : bool OnInteractiveMove();
+@ v "after-interactive-move" : void AfterInteractiveMove();
+@ v "on-interactive-resize" : bool OnInteractiveResize(wxSnip!);
+@ v "after-interactive-resize" : void AfterInteractiveResize(wxSnip!);
+
+@ "get-dragable" : bool GetDragable();
+@ "set-dragable" : void SetDragable(bool);
+@ "get-selection-visible" : bool GetSelectionVisible();
+@ "set-selection-visible" : void SetSelectionVisible(bool);
+
+@ "get-scroll-step" : float GetScrollStep();
+@ "set-scroll-step" : void SetScrollStep(float);
+
+@END
diff --git a/src/mred/wxs/wxs_obj.cxx b/src/mred/wxs/wxs_obj.cxx
new file mode 100644
index 0000000..c8451a7
--- /dev/null
+++ b/src/mred/wxs/wxs_obj.cxx
@@ -0,0 +1,136 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_obj.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_obj.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_obj.h"
+#include "wxscomon.h"
+
+
+
+
+class os_wxObject : public wxObject {
+ public:
+
+  os_wxObject(Scheme_Object * obj);
+  ~os_wxObject();
+};
+
+Scheme_Object *os_wxObject_class;
+
+os_wxObject::os_wxObject(Scheme_Object * o)
+: wxObject()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxObject::~os_wxObject()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxObject_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxObject *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:object%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxObject(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxObject(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:object%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:object%");
+}
+
+void objscheme_setup_wxObject(void *env)
+{
+if (os_wxObject_class) {
+    objscheme_add_global_class(os_wxObject_class,  "wx:object%", env);
+} else {
+  os_wxObject_class = objscheme_def_prim_class(env, "wx:object%", NULL, os_wxObject_ConstructScheme, 1);
+
+  scheme_add_method_w_arity(os_wxObject_class,"get-class-name",objscheme_classname_os_wxObject, 0, 0);
+
+
+
+  scheme_made_class(os_wxObject_class);
+
+
+}
+}
+
+int objscheme_istype_wxObject(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxObject_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:object%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxObject(class wxObject *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxObject_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxObject *objscheme_unbundle_wxObject(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxObject(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxObject *)o->primdata;
+  else
+    return (wxObject *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_obj.h b/src/mred/wxs/wxs_obj.h
new file mode 100644
index 0000000..1249092
--- /dev/null
+++ b/src/mred/wxs/wxs_obj.h
@@ -0,0 +1,8 @@
+#ifndef WXS_SETUP_ONLY
+#endif
+void objscheme_setup_wxObject(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxObject(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxObject(class wxObject *realobj);
+class wxObject *objscheme_unbundle_wxObject(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_obj.xc b/src/mred/wxs/wxs_obj.xc
new file mode 100644
index 0000000..cff6584
--- /dev/null
+++ b/src/mred/wxs/wxs_obj.xc
@@ -0,0 +1,15 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_obj.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxObject "wx:object"
+
+@CREATOR ()
+
+@END
+
diff --git a/src/mred/wxs/wxs_obj.xci b/src/mred/wxs/wxs_obj.xci
new file mode 100644
index 0000000..6123834
--- /dev/null
+++ b/src/mred/wxs/wxs_obj.xci
@@ -0,0 +1,2 @@
+
+@ERROR
diff --git a/src/mred/wxs/wxs_panl.cxx b/src/mred/wxs/wxs_panl.cxx
new file mode 100644
index 0000000..b20bc25
--- /dev/null
+++ b/src/mred/wxs/wxs_panl.cxx
@@ -0,0 +1,2028 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_panl.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_panel.h"
+#include "wx_enhdg.h"
+#include "wx_dialg.h"
+#include "wx_types.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_panl.h"
+#include "wxscomon.h"
+
+
+#if !defined(wx_mac)
+#define INTERACT_METHODS 1
+#else
+#define INTERACT_METHODS 0
+#endif
+
+/* The derivation wx:panel -> wx:canvas is a lie for Xt */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// @ p "on-item-event" : void OnItemEvent(wxItem!,wxMouseEvent%); ## INTERACT_METHODS
+// @ p "on-item-left-click" : void OnItemLeftClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-right-click" : void OnItemRightClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-move" : void OnItemMove(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-item-size" : void OnItemSize(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-left-click" : void OnLeftClick(int,int,int); ## INTERACT_METHODS
+// @ p "on-right-click" : void OnRightClick(int,int,int); ## INTERACT_METHODS
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// @ "advance-cursor" : void AdvanceCursor(wxWindow!); ## !defined(wx_xt)
+// @ "get-child" : wxObject! GetChild(int); ## !defined(wx_xt)
+
+// @CONSTANT "wx:const-multiple-mask" : long wxMULTIPLE_MASK ## !defined(wx_xt)
+// @CONSTANT "wx:const-sb-mask" : long wxSB_MASK ## !defined(wx_xt)
+// @CONSTANT "wx:const-editable" : long wxEDITABLE ## !defined(wx_xt)
+
+class os_wxPanel : public wxPanel {
+ public:
+
+  os_wxPanel(Scheme_Object * obj, class wxFrame* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "panel");
+  os_wxPanel(Scheme_Object * obj, class wxPanel* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "panel");
+  ~os_wxPanel();
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+  void OnPaint();
+  void OnDefaultAction(class wxItem* x0);
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxPanel_class;
+
+os_wxPanel::os_wxPanel(Scheme_Object * o, class wxFrame* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxPanel(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPanel::os_wxPanel(Scheme_Object * o, class wxPanel* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxPanel(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxPanel::~os_wxPanel()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxPanel::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxPanel::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxPanel::OnPaint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnPaint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxPanel::OnDefaultAction(class wxItem* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-default-action", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnDefaultAction(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxItem(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxPanel::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:panel%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxPanel::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:panel%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxPanel::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxPanel::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxPanel::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxPanel_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxPanel::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelTab(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:panel%::tab (tab amount case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:panel%::tab (tab amount case)");
+
+    
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->Tab(x0);
+
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:panel%::tab (no argument case)", 0, 0, n, p);
+
+    
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->Tab();
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetBackgroundColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:panel%::set-background-colour", 0);
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetBackgroundColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetBackgroundColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetBackgroundColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetLabelColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:panel%::set-label-colour", 0);
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetLabelColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetLabelColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetLabelColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetButtonColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxColour* x0;
+
+  
+  x0 = objscheme_unbundle_wxColour(p[0], "wx:panel%::set-button-colour", 0);
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetButtonColour(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetButtonColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetButtonColour();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetLabelFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxFont* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetLabelFont();
+
+  
+  
+  return objscheme_bundle_wxFont(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetLabelFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxFont* x0;
+
+  
+  x0 = objscheme_unbundle_wxFont(p[0], "wx:panel%::set-label-font", 0);
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetLabelFont(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetButtonFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxFont* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetButtonFont();
+
+  
+  
+  return objscheme_bundle_wxFont(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetButtonFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxFont* x0;
+
+  
+  x0 = objscheme_unbundle_wxFont(p[0], "wx:panel%::set-button-font", 0);
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetButtonFont(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetDC(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxDC* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetDC();
+
+  
+  
+  return objscheme_bundle_wxDC(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelNewLine(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:panel%::new-line (tab amount case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:panel%::new-line (tab amount case)");
+
+    
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->NewLine(x0);
+
+    
+    
+  } else  {
+
+    
+    if (n != 0) 
+      scheme_wrong_count("wx:panel%::new-line (no argument case)", 0, 0, n, p);
+
+    
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->NewLine();
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetVerticalSpacing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:panel%::set-vertical-spacing");
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetVerticalSpacing(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetHorizontalSpacing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:panel%::set-horizontal-spacing");
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetHorizontalSpacing(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetVerticalSpacing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetVerticalSpacing();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetHorizontalSpacing(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetHorizontalSpacing();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetLabelPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetLabelPosition();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetLabelPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:panel%::set-label-position");
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetLabelPosition(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:panel%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnChar(*x0);
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:panel%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnEvent(*x0);
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnPaint();
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnPaint();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnDefaultAction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxItem* x0;
+
+  
+  x0 = objscheme_unbundle_wxItem(p[0], "wx:panel%::on-default-action", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnDefaultAction(x0);
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultAction(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:panel%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:panel%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:panel%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:panel%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:panel%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:panel%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnSize(x0, x1);
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnSetFocus();
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxPanel *)((Scheme_Class_Object *)obj)->primdata)->wxPanel::OnKillFocus();
+  else
+    ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelSetItemCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:panel%::set-item-cursor");
+  x1 = objscheme_unbundle_integer(p[1], "wx:panel%::set-item-cursor");
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->SetItemCursor(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:panel%::get-item-cursor", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:panel%::get-item-cursor"), "wx:panel%::get-item-cursor");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:panel%::get-item-cursor", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:panel%::get-item-cursor"), "wx:panel%::get-item-cursor");
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetCursor(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelGetDefaultItem(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxButton* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->GetDefaultItem();
+
+  
+  
+  return objscheme_bundle_wxButton(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanelFit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxPanel *)((Scheme_Class_Object *)obj)->primdata)->Fit();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxPanel_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxPanel *realobj;
+  if ((n >= 1) && objscheme_istype_wxPanel(p[0], NULL, 0)) {
+    class wxPanel* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:panel%::initialization (panel parent case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:panel%::initialization (panel parent case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:panel%::initialization (panel parent case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:panel%::initialization (panel parent case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:panel%::initialization (panel parent case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:panel%::initialization (panel parent case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:panel%::initialization (panel parent case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:panel%::initialization (panel parent case)");
+    } else
+      x6 = "panel";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxPanel(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  } else  {
+    class wxFrame* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:panel%::initialization (frame case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxFrame(p[0], "wx:panel%::initialization (frame case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:panel%::initialization (frame case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:panel%::initialization (frame case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:panel%::initialization (frame case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:panel%::initialization (frame case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:panel%::initialization (frame case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:panel%::initialization (frame case)");
+    } else
+      x6 = "panel";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxPanel(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxPanel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:panel%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:panel%");
+}
+
+void objscheme_setup_wxPanel(void *env)
+{
+if (os_wxPanel_class) {
+    objscheme_add_global_class(os_wxPanel_class,  "wx:panel%", env);
+} else {
+  os_wxPanel_class = objscheme_def_prim_class(env, "wx:panel%", "wx:canvas%", os_wxPanel_ConstructScheme, 33);
+
+  scheme_add_method_w_arity(os_wxPanel_class,"get-class-name",objscheme_classname_os_wxPanel, 0, 0);
+
+ scheme_add_method(os_wxPanel_class, "tab", os_wxPanelTab);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-background-colour", os_wxPanelSetBackgroundColour, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-background-colour", os_wxPanelGetBackgroundColour, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-label-colour", os_wxPanelSetLabelColour, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-label-colour", os_wxPanelGetLabelColour, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-button-colour", os_wxPanelSetButtonColour, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-button-colour", os_wxPanelGetButtonColour, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-label-font", os_wxPanelGetLabelFont, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-label-font", os_wxPanelSetLabelFont, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-button-font", os_wxPanelGetButtonFont, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-button-font", os_wxPanelSetButtonFont, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-panel-dc", os_wxPanelGetDC, 0, 0);
+ scheme_add_method(os_wxPanel_class, "new-line", os_wxPanelNewLine);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-vertical-spacing", os_wxPanelSetVerticalSpacing, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-horizontal-spacing", os_wxPanelSetHorizontalSpacing, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-vertical-spacing", os_wxPanelGetVerticalSpacing, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-horizontal-spacing", os_wxPanelGetHorizontalSpacing, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-label-position", os_wxPanelGetLabelPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-label-position", os_wxPanelSetLabelPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-char", os_wxPanelOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-event", os_wxPanelOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-paint", os_wxPanelOnPaint, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-default-action", os_wxPanelOnDefaultAction, 1, 1);
+ scheme_add_method_w_arity(os_wxPanel_class, "pre-on-event", os_wxPanelPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxPanel_class, "pre-on-char", os_wxPanelPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-size", os_wxPanelOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-set-focus", os_wxPanelOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "on-kill-focus", os_wxPanelOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "set-item-cursor", os_wxPanelSetItemCursor, 2, 2);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-item-cursor", os_wxPanelGetCursor, 2, 2);
+ scheme_add_method_w_arity(os_wxPanel_class, "get-default-item", os_wxPanelGetDefaultItem, 0, 0);
+ scheme_add_method_w_arity(os_wxPanel_class, "fit", os_wxPanelFit, 0, 0);
+
+
+  scheme_made_class(os_wxPanel_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxPanel, wxTYPE_PANEL);
+
+}
+  scheme_install_xc_global("wx:const-single", scheme_make_integer(wxSINGLE), env);
+  scheme_install_xc_global("wx:const-multiple", scheme_make_integer(wxMULTIPLE), env);
+  scheme_install_xc_global("wx:const-extended", scheme_make_integer(wxEXTENDED), env);
+  scheme_install_xc_global("wx:const-needed-sb", scheme_make_integer(wxNEEDED_SB), env);
+  scheme_install_xc_global("wx:const-always-sb", scheme_make_integer(wxALWAYS_SB), env);
+  scheme_install_xc_global("wx:const-process-enter", scheme_make_integer(wxPROCESS_ENTER), env);
+  scheme_install_xc_global("wx:const-password", scheme_make_integer(wxPASSWORD), env);
+  scheme_install_xc_global("wx:const-vscroll", scheme_make_integer(wxVSCROLL), env);
+  scheme_install_xc_global("wx:const-hscroll", scheme_make_integer(wxHSCROLL), env);
+  scheme_install_xc_global("wx:const-caption", scheme_make_integer(wxCAPTION), env);
+  scheme_install_xc_global("wx:const-readonly", scheme_make_integer(wxREADONLY), env);
+}
+
+int objscheme_istype_wxPanel(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxPanel_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:panel%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxPanel(class wxPanel *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_PANEL) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxPanel_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxPanel(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxPanel *)o->primdata;
+  else
+    return (wxPanel *)o->primdata;
+}
+
+
+
+
+
+
+
+
+// @ "centre" : void Centre(int=wxBOTH);
+
+
+
+
+
+
+
+
+
+
+
+
+
+// @ p "on-item-event" : void OnItemEvent(wxItem!,wxMouseEvent%); ## INTERACT_METHODS
+// @ p "on-item-left-click" : void OnItemLeftClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-right-click" : void OnItemRightClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-move" : void OnItemMove(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-item-size" : void OnItemSize(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-left-click" : void OnLeftClick(int,int,int); ## INTERACT_METHODS
+// @ p "on-right-click" : void OnRightClick(int,int,int); ## INTERACT_METHODS
+
+class os_wxDialogBox : public wxDialogBox {
+ public:
+
+  os_wxDialogBox(Scheme_Object * obj, class wxWindow* x0, nstring x1, Bool x2 = FALSE, int x3 = 300, int x4 = 300, int x5 = 500, int x6 = 500, long x7 = wxDEFAULT_DIALOG_STYLE, string x8 = "dialogBox");
+  ~os_wxDialogBox();
+  void OnDefaultAction(class wxItem* x0);
+  void OnChar(class wxKeyEvent& x0);
+  void OnEvent(class wxMouseEvent& x0);
+  void OnPaint();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+  Bool OnClose();
+  void OnActivate(Bool x0);
+};
+
+Scheme_Object *os_wxDialogBox_class;
+
+os_wxDialogBox::os_wxDialogBox(Scheme_Object * o, class wxWindow* x0, nstring x1, Bool x2, int x3, int x4, int x5, int x6, long x7, string x8)
+: wxDialogBox(x0, x1, x2, x3, x4, x5, x6, x7, x8)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxDialogBox::~os_wxDialogBox()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxDialogBox::OnDefaultAction(class wxItem* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-default-action", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnDefaultAction(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxItem(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxDialogBox::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxDialogBox::OnEvent(class wxMouseEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnEvent(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMouseEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxDialogBox::OnPaint()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-paint", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnPaint();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxDialogBox::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:dialog-box%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxDialogBox::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:dialog-box%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxDialogBox::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxDialogBox::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxDialogBox::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxDialogBox::OnClose()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-close", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxDialogBox::OnClose();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:dialog-box%::on-close"", extracting return value");
+  }
+}
+
+void os_wxDialogBox::OnActivate(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxDialogBox_class, "on-activate", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxDialogBox::OnActivate(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnDefaultAction(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxItem* x0;
+
+  
+  x0 = objscheme_unbundle_wxItem(p[0], "wx:dialog-box%::on-default-action", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnDefaultAction(x0);
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnDefaultAction(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:dialog-box%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnChar(*x0);
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMouseEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxMouseEvent(p[0], "wx:dialog-box%::on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnEvent(*x0);
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnPaint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnPaint();
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnPaint();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:dialog-box%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:dialog-box%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:dialog-box%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:dialog-box%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:dialog-box%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:dialog-box%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnSize(x0, x1);
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnSetFocus();
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnKillFocus();
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnClose(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnClose();
+  else
+    r = ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnClose();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBoxOnActivate(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:dialog-box%::on-activate");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->wxDialogBox::OnActivate(x0);
+  else
+    ((wxDialogBox *)((Scheme_Class_Object *)obj)->primdata)->OnActivate(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxDialogBox_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxDialogBox *realobj;
+  class wxWindow* x0;
+  nstring x1;
+  Bool x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  long x7;
+  string x8;
+
+  
+  if ((n < 2) ||(n > 9)) 
+    scheme_wrong_count("wx:dialog-box%::initialization", 2, 9, n, p);
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:dialog-box%::initialization", 1);
+  x1 = (nstring)objscheme_unbundle_nullable_string(p[1], "wx:dialog-box%::initialization");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:dialog-box%::initialization");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:dialog-box%::initialization");
+  } else
+    x3 = 300;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:dialog-box%::initialization");
+  } else
+    x4 = 300;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:dialog-box%::initialization");
+  } else
+    x5 = 500;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:dialog-box%::initialization");
+  } else
+    x6 = 500;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:dialog-box%::initialization");
+  } else
+    x7 = wxDEFAULT_DIALOG_STYLE;
+  if (n > 8) {
+    x8 = (string)objscheme_unbundle_string(p[8], "wx:dialog-box%::initialization");
+  } else
+    x8 = "dialogBox";
+
+  if (x0 && !wxSubType(((wxObject *)x0)->__type, wxTYPE_FRAME) && !wxSubType(((wxObject *)x0)->__type, wxTYPE_DIALOG_BOX)) scheme_wrong_type("wx:dialog-box%::initialization", "frame or dialog box", 0, n, p);if (!x5) x5 = -1;if (!x6) x6 = -1;
+  realobj = new os_wxDialogBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxDialogBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:dialog-box%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:dialog-box%");
+}
+
+void objscheme_setup_wxDialogBox(void *env)
+{
+if (os_wxDialogBox_class) {
+    objscheme_add_global_class(os_wxDialogBox_class,  "wx:dialog-box%", env);
+} else {
+  os_wxDialogBox_class = objscheme_def_prim_class(env, "wx:dialog-box%", "wx:panel%", os_wxDialogBox_ConstructScheme, 12);
+
+  scheme_add_method_w_arity(os_wxDialogBox_class,"get-class-name",objscheme_classname_os_wxDialogBox, 0, 0);
+
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-default-action", os_wxDialogBoxOnDefaultAction, 1, 1);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-char", os_wxDialogBoxOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-event", os_wxDialogBoxOnEvent, 1, 1);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-paint", os_wxDialogBoxOnPaint, 0, 0);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "pre-on-event", os_wxDialogBoxPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "pre-on-char", os_wxDialogBoxPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-size", os_wxDialogBoxOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-set-focus", os_wxDialogBoxOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-kill-focus", os_wxDialogBoxOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-close", os_wxDialogBoxOnClose, 0, 0);
+ scheme_add_method_w_arity(os_wxDialogBox_class, "on-activate", os_wxDialogBoxOnActivate, 1, 1);
+
+
+  scheme_made_class(os_wxDialogBox_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxDialogBox, wxTYPE_DIALOG_BOX);
+
+}
+  scheme_install_xc_global("wx:const-default-dialog-style", scheme_make_integer(wxDEFAULT_DIALOG_STYLE), env);
+}
+
+int objscheme_istype_wxDialogBox(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxDialogBox_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:dialog-box%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxDialogBox(class wxDialogBox *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_DIALOG_BOX) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxDialogBox_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxDialogBox *objscheme_unbundle_wxDialogBox(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxDialogBox(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxDialogBox *)o->primdata;
+  else
+    return (wxDialogBox *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_panl.h b/src/mred/wxs/wxs_panl.h
new file mode 100644
index 0000000..e1ad37f
--- /dev/null
+++ b/src/mred/wxs/wxs_panl.h
@@ -0,0 +1,58 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxItem(class wxItem *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxFont(class wxFont *);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxFont(class wxFont *);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxItem *objscheme_unbundle_wxItem(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxButton(class wxButton *);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxPanel(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxPanel(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxPanel(class wxPanel *realobj);
+class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxItem(class wxItem *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxItem *objscheme_unbundle_wxItem(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxDialogBox(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxDialogBox(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxDialogBox(class wxDialogBox *realobj);
+class wxDialogBox *objscheme_unbundle_wxDialogBox(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_panl.xc b/src/mred/wxs/wxs_panl.xc
new file mode 100644
index 0000000..60d7305
--- /dev/null
+++ b/src/mred/wxs/wxs_panl.xc
@@ -0,0 +1,127 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_panel.h"
+#include "wx_enhdg.h"
+#include "wx_dialg.h"
+#include "wx_types.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if !defined(wx_mac)
+#define INTERACT_METHODS 1
+#else
+#define INTERACT_METHODS 0
+#endif
+
+/* The derivation wx:panel -> wx:canvas is a lie for Xt */
+@CLASSBASE wxPanel "wx:panel":"wx:canvas"
+
+@CLASSID wxTYPE_PANEL
+
+@CREATOR (wxFrame!,int=-1,int=-1,int=-1,int=-1,long=0,string="panel") : : /NOZERO[3]|NOZERO[4] <> frame
+@CREATOR (wxPanel!,int=-1,int=-1,int=-1,int=-1,long=0,string="panel") : : /NOZERO[3]|NOZERO[4] <> panel parent
+
+@ "fit" : void Fit();
+@ "get-default-item" : wxButton! GetDefaultItem();
+@ "get-item-cursor" : void GetCursor(int*,int*);
+@ "set-item-cursor" : void SetItemCursor(int,int);
+
+@SETMARK p = v
+@INCLUDE wxs_panl.xci
+
+@INCLUDE wxs_cnvs.xci
+
+@ "set-label-position" : void SetLabelPosition(int);
+@ "get-label-position" : int GetLabelPosition();
+
+@ "get-horizontal-spacing" : int GetHorizontalSpacing();
+@ "get-vertical-spacing" : int GetVerticalSpacing();
+@ "set-horizontal-spacing" : void SetHorizontalSpacing(int);
+@ "set-vertical-spacing" : void SetVerticalSpacing(int);
+
+@ "new-line" : void NewLine(); <> no argument
+@ "new-line" : void NewLine(int); <> tab amount
+
+@ "get-panel-dc" : wxDC! GetDC();
+
+@INCLUDE wxs_ifnt.xci
+@INCLUDE wxs_icol.xci
+
+@ "tab" : void Tab(); <> no argument
+@ "tab" : void Tab(int); <> tab amount
+
+// @ "advance-cursor" : void AdvanceCursor(wxWindow!); ## !defined(wx_xt)
+// @ "get-child" : wxObject! GetChild(int); ## !defined(wx_xt)
+
+// @CONSTANT "wx:const-multiple-mask" : long wxMULTIPLE_MASK ## !defined(wx_xt)
+@CONSTANT "wx:const-single" : long wxSINGLE       
+@CONSTANT "wx:const-multiple" : long wxMULTIPLE     
+@CONSTANT "wx:const-extended" : long wxEXTENDED     
+// @CONSTANT "wx:const-sb-mask" : long wxSB_MASK ## !defined(wx_xt)
+@CONSTANT "wx:const-needed-sb" : long wxNEEDED_SB    
+@CONSTANT "wx:const-always-sb" : long wxALWAYS_SB    
+@CONSTANT "wx:const-process-enter" : long wxPROCESS_ENTER
+@CONSTANT "wx:const-password" : long wxPASSWORD
+@CONSTANT "wx:const-vscroll" : long wxVSCROLL      
+@CONSTANT "wx:const-hscroll" : long wxHSCROLL      
+@CONSTANT "wx:const-caption" : long wxCAPTION      
+// @CONSTANT "wx:const-editable" : long wxEDITABLE ## !defined(wx_xt)
+@CONSTANT "wx:const-readonly" : long wxREADONLY      
+
+@END
+
+@CLASSBASE wxDialogBox "wx:dialog-box" : "wx:panel"
+
+@CLASSID wxTYPE_DIALOG_BOX
+
+@INCLUDE wxs_dorf.xci
+
+@CREATOR (wxWindow^,nstring,bool=FALSE,int=300,int=300,int=500,int=500,long=wxDEFAULT_DIALOG_STYLE,string="dialogBox"); : : /DLGORFRAME[0."wx:dialog-box%::initialization"]|NOZERO[5]|NOZERO[6]
+
+@CONSTANT "wx:const-default-dialog-style" : long wxDEFAULT_DIALOG_STYLE
+
+// @ "centre" : void Centre(int=wxBOTH);
+
+@SETMARK f = d
+@INCLUDE wxs_fram.xci
+
+@SETMARK p = d
+@INCLUDE wxs_panl.xci
+
+@END
+
+#if 0
+#if USE_ENHANCED_DIALOG
+
+@CLASSBASE wxEnhDialogBox "wx:enh-dialog-box" : "wx:dialog-box"
+
+@SET CALLBACK_CLASS = wxEnhDialogBox
+@INCLUDE cb_start.xci
+
+@MACRO rTRUE = return TRUE;
+
+@CREATOR (wxFrame^,string,bool=FALSE,wxFunction=NULL/bCallback/ubCallback/cCallback,int=-1,int=0,int=0,int=10,int=10,long=wxDEFAULT_DIALOG_STYLE,string="Shell"); : : ubCallbackSetup///ubCallbackCreatorFinish
+
+@IVAR "user-panel" : wxPanel! userPanel
+
+@ "set-status" : void SetStatus(string=NULL);
+@ "add-cmd" : wxButton! AddCmd(string,wxFunction/bCallback/ubCallback/cCallback,int=0); : : ubCallbackSetup///ubCallbackFinish
+@ "add-cmd" : wxButton! AddCmd(wxBitmap!,wxFunction/bCallback/ubCallback/cCallback,int=0); : : ubCallbackSetup///ubCallbackFinish
+	
+@ "get-cmd" : wxButton^ GetCmd(int);
+@ "set-pin" : void SetPin(bool);
+
+@ v "on-close" : bool OnClose(); : : : rTRUE
+
+@SETMARK p = d
+@INCLUDE wxs_panl.xci
+
+@END
+
+@INCLUDE cb_end.xci
+
+#endif
+#endif
diff --git a/src/mred/wxs/wxs_panl.xci b/src/mred/wxs/wxs_panl.xci
new file mode 100644
index 0000000..be6e19e
--- /dev/null
+++ b/src/mred/wxs/wxs_panl.xci
@@ -0,0 +1,16 @@
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
+
+@SETMARK c = d
+@INCLUDE wxs_cnvs.xci
+
+@ p "on-default-action" : void OnDefaultAction(wxItem!);
+
+// @ p "on-item-event" : void OnItemEvent(wxItem!,wxMouseEvent%); ## INTERACT_METHODS
+// @ p "on-item-left-click" : void OnItemLeftClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-right-click" : void OnItemRightClick(wxItem!,int,int,int); ## INTERACT_METHODS
+// @ p "on-item-move" : void OnItemMove(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-item-size" : void OnItemSize(wxItem!,int,int); ## INTERACT_METHODS
+// @ p "on-left-click" : void OnLeftClick(int,int,int); ## INTERACT_METHODS
+// @ p "on-right-click" : void OnRightClick(int,int,int); ## INTERACT_METHODS
diff --git a/src/mred/wxs/wxs_rado.cxx b/src/mred/wxs/wxs_rado.cxx
new file mode 100644
index 0000000..90f0227
--- /dev/null
+++ b/src/mred/wxs/wxs_rado.cxx
@@ -0,0 +1,926 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_rado.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_rbox.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_rado.h"
+#include "wxscomon.h"
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxRadioBox
+#define CB_REALCLASS wxRadioBox
+#define CB_UNBUNDLE objscheme_unbundle_wxRadioBox
+#define CB_USER "wx:radio-box%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxRadioBoxCallbackToScheme
+#define CB_TOC wxRadioBoxCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+#include "wxs_bmap.h"
+
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST 
+#define l_POINT 
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST 
+#define l_INTTYPE int
+
+#define l_TYPE string
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_string
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_string
+#define l_MAKE_LIST __MakestringList
+#define l_MAKE_ARRAY __MakestringArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+#define OKTESTWHERE "wx:radio-box%::initialization" 
+#undef l_ADDRESS
+#undef l_DEREF
+#undef l_TEST
+#undef l_POINT
+#undef l_TYPE
+#undef l_LIST_ITEM_BUNDLE
+#undef l_LIST_ITEM_UNBUNDLE
+#undef l_MAKE_LIST
+#undef l_MAKE_ARRAY
+#undef l_EXTRA
+#undef l_TERMINATE
+#undef l_COPY
+#undef l_OKTEST
+#undef l_INTTYPE
+
+#define l_ADDRESS 
+#define l_DEREF 
+#define l_NULLOK 0
+#define l_TEST , l_NULLOK
+#define l_POINT *
+#define l_EXTRA 0
+#define l_TERMINATE 
+#define l_COPY l_COPYDEST=l_COPYSRC;
+#define l_OKTEST if (!((l_COPYDEST)->Ok())) scheme_signal_error("%s: bad bitmap", OKTESTWHERE);
+#define l_INTTYPE int
+
+#define l_TYPE wxBitmap
+#define l_LIST_ITEM_BUNDLE objscheme_bundle_wxBitmap
+#define l_LIST_ITEM_UNBUNDLE objscheme_unbundle_wxBitmap
+#define l_MAKE_LIST __MakewxBitmapList
+#define l_MAKE_ARRAY __MakewxBitmapArray
+
+
+
+
+
+static Scheme_Object *l_MAKE_LIST(l_TYPE l_POINT *f, l_INTTYPE c)
+{
+  Scheme_Object *cdr = scheme_null, *obj;
+
+  while (c--) {
+    obj = l_LIST_ITEM_BUNDLE(l_ADDRESS f[c]);
+    cdr = scheme_make_pair(obj, cdr);
+  }
+  
+  return cdr;
+}
+
+static l_TYPE l_POINT *l_MAKE_ARRAY(Scheme_Object *l, l_INTTYPE *c, char *who)
+{
+  int i = 0;
+  long len;
+
+  len = scheme_proper_list_length(l);
+  if (len < 0) scheme_wrong_type(who, "proper-list", -1, 0, &l);
+  if (c) *c = len;
+
+  if (!(len + l_EXTRA))
+    return NULL;
+
+  l_TYPE l_POINT *f = new l_TYPE l_POINT[len + l_EXTRA];
+
+  while (!SCHEME_NULLP(l)) {
+    if (!SCHEME_LISTP(l))
+     scheme_signal_error("%s: expected a proper list", who);
+
+#define l_COPYDEST f[i]
+#define l_COPYSRC (l_DEREF l_LIST_ITEM_UNBUNDLE(SCHEME_CAR(l), who l_TEST))
+
+    l_COPY
+
+    l_OKTEST
+
+    i++;
+
+    l = SCHEME_CDR(l);
+  }
+  l_TERMINATE
+
+  return f;
+}
+
+
+
+
+
+
+
+
+
+
+#define RANGECLASS wxRadioBox
+
+#define THISOBJECT ((RANGECLASS *)((Scheme_Class_Object *)obj)->primdata)
+
+
+
+
+class os_wxRadioBox : public wxRadioBox {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxRadioBox(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, int x3 = -1, int x4 = -1, int x5 = -1, int x6 = -1, int x7 = 0, string* x8 = NULL, int x9 = 0, long x10 = wxVERTICAL, string x11 = "radioBox");
+  os_wxRadioBox(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7, wxBitmap** x8, int x9 = 0, long x10 = wxVERTICAL, string x11 = "radioBox");
+  ~os_wxRadioBox();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxRadioBox_class;
+
+os_wxRadioBox::os_wxRadioBox(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7, string* x8, int x9, long x10, string x11)
+: wxRadioBox(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxRadioBox::os_wxRadioBox(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7, wxBitmap** x8, int x9, long x10, string x11)
+: wxRadioBox(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxRadioBox::~os_wxRadioBox()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxRadioBox::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxRadioBox_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:radio-box%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxRadioBox::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxRadioBox_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:radio-box%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxRadioBox::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxRadioBox_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxRadioBox::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxRadioBox::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxRadioBox_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxRadioBox::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxRadioBox::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxRadioBox_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxRadioBox::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxEnable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_number(p[0], NULL)) {
+    int x0;
+    Bool x1;
+
+    
+    if (n != 2) 
+      scheme_wrong_count("wx:radio-box%::enable (single-button case)", 2, 2, n, p);
+    x0 = objscheme_unbundle_integer(p[0], "wx:radio-box%::enable (single-button case)");
+    x1 = objscheme_unbundle_bool(p[1], "wx:radio-box%::enable (single-button case)");
+
+    if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+    ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->Enable(x0, x1);
+
+    
+    
+  } else  {
+    Bool x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:radio-box%::enable (all-buttons case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_bool(p[0], "wx:radio-box%::enable (all-buttons case)");
+
+    
+    ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->Enable(x0);
+
+    
+    
+  }
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxGetString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:radio-box%::get-string");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_null;
+  r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->GetString(x0);
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxSetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:radio-box%::set-selection");
+
+  if ((x0 < 0) || (x0 >= THISOBJECT->Number())) return scheme_void;
+  ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->SetSelection(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxSetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:radio-box%::set-string-selection");
+
+  
+  ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->SetStringSelection(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxGetStringSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->GetStringSelection();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxGetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->GetSelection();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxFindString(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:radio-box%::find-string");
+
+  
+  r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->FindString(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:radio-box%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:radio-box%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:radio-box%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:radio-box%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:radio-box%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:radio-box%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->wxRadioBox::OnSize(x0, x1);
+  else
+    ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->wxRadioBox::OnSetFocus();
+  else
+    ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBoxOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->wxRadioBox::OnKillFocus();
+  else
+    ((wxRadioBox *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxRadioBox_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxRadioBox *realobj;
+  if ((n >= 8) && objscheme_istype_wxPanel(p[0], NULL, 0) && (SCHEME_NULLP(p[1]) || objscheme_istype_proc2(p[1], NULL)) && (SCHEME_NULLP(p[2]) || objscheme_istype_string(p[2], NULL)) && objscheme_istype_number(p[3], NULL) && objscheme_istype_number(p[4], NULL) && objscheme_istype_number(p[5], NULL) && objscheme_istype_number(p[6], NULL) && (SCHEME_LISTP(p[7]) && (SCHEME_NULLP(p[7]) || objscheme_istype_wxBitmap((SCHEME_CAR(p[7])), NULL, 0)))) {
+    class wxPanel* x0;
+    wxFunction x1;
+    nstring x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    int x7;
+    wxBitmap** x8;
+    int x9;
+    long x10;
+    string x11;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 8) ||(n > 11)) 
+      scheme_wrong_count("wx:radio-box%::initialization (bitmap list case)", 8, 11, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:radio-box%::initialization (bitmap list case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:radio-box%::initialization (bitmap list case)");
+    x3 = objscheme_unbundle_integer(p[3], "wx:radio-box%::initialization (bitmap list case)");
+    x4 = objscheme_unbundle_integer(p[4], "wx:radio-box%::initialization (bitmap list case)");
+    x5 = objscheme_unbundle_integer(p[5], "wx:radio-box%::initialization (bitmap list case)");
+    x6 = objscheme_unbundle_integer(p[6], "wx:radio-box%::initialization (bitmap list case)");
+    x8 = NULL;
+    if (n > 8) {
+      x9 = objscheme_unbundle_integer(p[8], "wx:radio-box%::initialization (bitmap list case)");
+    } else
+      x9 = 0;
+    if (n > 9) {
+      x10 = objscheme_unbundle_integer(p[9], "wx:radio-box%::initialization (bitmap list case)");
+    } else
+      x10 = wxVERTICAL;
+    if (n > 10) {
+      x11 = (string)objscheme_unbundle_string(p[10], "wx:radio-box%::initialization (bitmap list case)");
+    } else
+      x11 = "radioBox";
+
+    if (!x5) x5 = -1;if (!x6) x6 = -1;x8 = __MakewxBitmapArray((7 < n) ? p[7] : scheme_null, &x7, "wx:radio-box%::initialization");
+    realobj = new os_wxRadioBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
+    delete[] x8;
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  } else  {
+    class wxPanel* x0;
+    wxFunction x1;
+    nstring x2;
+    int x3;
+    int x4;
+    int x5;
+    int x6;
+    int x7;
+    string* x8;
+    int x9;
+    long x10;
+    string x11;
+
+    Scheme_Object *tmp_callback = NULL;
+    if ((n < 3) ||(n > 11)) 
+      scheme_wrong_count("wx:radio-box%::initialization (string list case)", 3, 11, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:radio-box%::initialization (string list case)", 0);
+    x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+    x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:radio-box%::initialization (string list case)");
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:radio-box%::initialization (string list case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:radio-box%::initialization (string list case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:radio-box%::initialization (string list case)");
+    } else
+      x5 = -1;
+    if (n > 6) {
+      x6 = objscheme_unbundle_integer(p[6], "wx:radio-box%::initialization (string list case)");
+    } else
+      x6 = -1;
+    if (n > 7) {
+      x8 = NULL;
+    } else
+      x8 = NULL;
+    if (n > 8) {
+      x9 = objscheme_unbundle_integer(p[8], "wx:radio-box%::initialization (string list case)");
+    } else
+      x9 = 0;
+    if (n > 9) {
+      x10 = objscheme_unbundle_integer(p[9], "wx:radio-box%::initialization (string list case)");
+    } else
+      x10 = wxVERTICAL;
+    if (n > 10) {
+      x11 = (string)objscheme_unbundle_string(p[10], "wx:radio-box%::initialization (string list case)");
+    } else
+      x11 = "radioBox";
+
+    if (!x5) x5 = -1;if (!x6) x6 = -1;x8 = __MakestringArray((7 < n) ? p[7] : scheme_null, &x7, "wx:radio-box%::initialization");
+    realobj = new os_wxRadioBox(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
+    delete[] x8;
+    realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxRadioBox(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:radio-box%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:radio-box%");
+}
+
+void objscheme_setup_wxRadioBox(void *env)
+{
+if (os_wxRadioBox_class) {
+    objscheme_add_global_class(os_wxRadioBox_class,  "wx:radio-box%", env);
+} else {
+  os_wxRadioBox_class = objscheme_def_prim_class(env, "wx:radio-box%", "wx:item%", os_wxRadioBox_ConstructScheme, 14);
+
+  scheme_add_method_w_arity(os_wxRadioBox_class,"get-class-name",objscheme_classname_os_wxRadioBox, 0, 0);
+
+ scheme_add_method(os_wxRadioBox_class, "enable", os_wxRadioBoxEnable);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "get-string", os_wxRadioBoxGetString, 1, 1);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "set-selection", os_wxRadioBoxSetSelection, 1, 1);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "set-string-selection", os_wxRadioBoxSetStringSelection, 1, 1);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "number", os_wxRadioBoxNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "get-string-selection", os_wxRadioBoxGetStringSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "get-selection", os_wxRadioBoxGetSelection, 0, 0);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "find-string", os_wxRadioBoxFindString, 1, 1);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "pre-on-event", os_wxRadioBoxPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "pre-on-char", os_wxRadioBoxPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "on-size", os_wxRadioBoxOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "on-set-focus", os_wxRadioBoxOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxRadioBox_class, "on-kill-focus", os_wxRadioBoxOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxRadioBox_class);
+
+
+}
+}
+
+int objscheme_istype_wxRadioBox(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxRadioBox_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:radio-box%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxRadioBox(class wxRadioBox *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxRadioBox_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxRadioBox *objscheme_unbundle_wxRadioBox(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxRadioBox(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxRadioBox *)o->primdata;
+  else
+    return (wxRadioBox *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_rado.h b/src/mred/wxs/wxs_rado.h
new file mode 100644
index 0000000..0020178
--- /dev/null
+++ b/src/mred/wxs/wxs_rado.h
@@ -0,0 +1,19 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxRadioBox(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxRadioBox(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxRadioBox(class wxRadioBox *realobj);
+class wxRadioBox *objscheme_unbundle_wxRadioBox(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_rado.xc b/src/mred/wxs/wxs_rado.xc
new file mode 100644
index 0000000..f5385c2
--- /dev/null
+++ b/src/mred/wxs/wxs_rado.xc
@@ -0,0 +1,54 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_rbox.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxRadioBox "wx:radio-box":"wx:item"
+
+@SET CALLBACK_CLASS = wxRadioBox
+@SET CALLBACK_CLASS_USER = "wx:radio-box%::initialization"
+@INCLUDE cb_start.xci
+
+#include "wxs_bmap.h"
+
+@SET TYPE = string
+@SET NOTEST = 1
+@INCLUDE list.xci
+
+@SET TYPE = wxBitmap
+@SET POINTERS = 1
+@SET DOOKTEST = 1
+@DEFINE OKTESTWHERE "wx:radio-box%::initialization"
+@INCLUDE list.xci
+
+@MACRO cStringList = (SCHEME_LISTP({x}) && (SCHEME_NULLP({x}) || SCHEME_STRINGP(SCHEME_CAR({x}))))
+@MACRO cBitmapList = (SCHEME_LISTP({x}) && (SCHEME_NULLP({x}) || objscheme_istype_wxBitmap((SCHEME_CAR({x})), NULL, 0)))
+
+@MACRO spBitmapList = (listof wxBitmap-object)
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,int=-1,int=-1,int=-1,int=-1,-int=0,string[]=NULL/bList/ubList/cStringList,int=0,long=wxVERTICAL,string="radioBox"); : : ubCallbackSetup/NOZERO[5]|NOZERO[6]|glueListSet[string.7.8.7."wx:radio-box%::initialization"]/glueCleanup[8]/ubCallbackCreatorFinish <> string list
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,int,int,int,int,-int,wxBitmap*[]/bList/ubList/cBitmapList//spBitmapList,int=0,long=wxVERTICAL,string="radioBox"); : : ubCallbackSetup/NOZERO[5]|NOZERO[6]|glueListSet[wxBitmap.7.8.7."wx:radio-box%::initialization"]/glueCleanup[8]/ubCallbackCreatorFinish <> bitmap list
+
+@INCLUDE wxs_item.xci
+
+#define RANGECLASS wxRadioBox
+@INCLUDE range.xci
+
+@ "find-string" : int FindString(string);
+@ "get-selection" : int GetSelection();
+@ "get-string-selection" : nstring GetStringSelection();
+@ "number" : int Number();
+@ "set-string-selection" : void SetStringSelection(string);
+@ "set-selection" : void SetSelection(int); : : /RANGE[0]
+@ "get-string" : string GetString(int);  : : /RANGERET[0.scheme_null]
+
+@ "enable" : void Enable(int,bool); : : /RANGE[0] <> single-button
+@ "enable" : void Enable(bool); <> all-buttons
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_slid.cxx b/src/mred/wxs/wxs_slid.cxx
new file mode 100644
index 0000000..a717956
--- /dev/null
+++ b/src/mred/wxs/wxs_slid.cxx
@@ -0,0 +1,549 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_slid.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_slidr.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_slid.h"
+#include "wxscomon.h"
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxSlider
+#define CB_REALCLASS wxSlider
+#define CB_UNBUNDLE objscheme_unbundle_wxSlider
+#define CB_USER "wx:slider%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxSliderCallbackToScheme
+#define CB_TOC wxSliderCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+
+
+
+
+
+class os_wxSlider : public wxSlider {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxSlider(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7 = -1, int x8 = -1, long x9 = wxHORIZONTAL, string x10 = "slider");
+  ~os_wxSlider();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxSlider_class;
+
+os_wxSlider::os_wxSlider(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, int x3, int x4, int x5, int x6, int x7, int x8, long x9, string x10)
+: wxSlider(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxSlider::~os_wxSlider()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxSlider::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSlider_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:slider%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxSlider::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSlider_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:slider%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxSlider::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSlider_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSlider::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSlider::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSlider_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSlider::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSlider::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSlider_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSlider::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderSetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:slider%::set-value");
+
+  
+  ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->SetValue(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderGetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->GetValue();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:slider%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:slider%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSlider *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:slider%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:slider%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSlider *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:slider%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:slider%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSlider *)((Scheme_Class_Object *)obj)->primdata)->wxSlider::OnSize(x0, x1);
+  else
+    ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSlider *)((Scheme_Class_Object *)obj)->primdata)->wxSlider::OnSetFocus();
+  else
+    ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSliderOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSlider *)((Scheme_Class_Object *)obj)->primdata)->wxSlider::OnKillFocus();
+  else
+    ((wxSlider *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSlider_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxSlider *realobj;
+  class wxPanel* x0;
+  wxFunction x1;
+  nstring x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  int x8;
+  long x9;
+  string x10;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n < 7) ||(n > 11)) 
+    scheme_wrong_count("wx:slider%::initialization", 7, 11, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:slider%::initialization", 0);
+  x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:slider%::initialization");
+  x3 = objscheme_unbundle_integer(p[3], "wx:slider%::initialization");
+  x4 = objscheme_unbundle_integer(p[4], "wx:slider%::initialization");
+  x5 = objscheme_unbundle_integer(p[5], "wx:slider%::initialization");
+  x6 = objscheme_unbundle_integer(p[6], "wx:slider%::initialization");
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:slider%::initialization");
+  } else
+    x7 = -1;
+  if (n > 8) {
+    x8 = objscheme_unbundle_integer(p[8], "wx:slider%::initialization");
+  } else
+    x8 = -1;
+  if (n > 9) {
+    x9 = objscheme_unbundle_integer(p[9], "wx:slider%::initialization");
+  } else
+    x9 = wxHORIZONTAL;
+  if (n > 10) {
+    x10 = (string)objscheme_unbundle_string(p[10], "wx:slider%::initialization");
+  } else
+    x10 = "slider";
+
+  if (x3 < x4 || x5 < x3) scheme_signal_error("wx:slider%%::initialization: minimum, value, and maximum must be increasing");if (x6 <= 0) x6 = 1;
+  realobj = new os_wxSlider(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
+  
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxSlider(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:slider%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:slider%");
+}
+
+void objscheme_setup_wxSlider(void *env)
+{
+if (os_wxSlider_class) {
+    objscheme_add_global_class(os_wxSlider_class,  "wx:slider%", env);
+} else {
+  os_wxSlider_class = objscheme_def_prim_class(env, "wx:slider%", "wx:item%", os_wxSlider_ConstructScheme, 8);
+
+  scheme_add_method_w_arity(os_wxSlider_class,"get-class-name",objscheme_classname_os_wxSlider, 0, 0);
+
+ scheme_add_method_w_arity(os_wxSlider_class, "set-value", os_wxSliderSetValue, 1, 1);
+ scheme_add_method_w_arity(os_wxSlider_class, "get-value", os_wxSliderGetValue, 0, 0);
+ scheme_add_method_w_arity(os_wxSlider_class, "pre-on-event", os_wxSliderPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxSlider_class, "pre-on-char", os_wxSliderPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxSlider_class, "on-size", os_wxSliderOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxSlider_class, "on-set-focus", os_wxSliderOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxSlider_class, "on-kill-focus", os_wxSliderOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxSlider_class);
+
+
+}
+}
+
+int objscheme_istype_wxSlider(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxSlider_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:slider%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxSlider(class wxSlider *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxSlider_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxSlider *objscheme_unbundle_wxSlider(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxSlider(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxSlider *)o->primdata;
+  else
+    return (wxSlider *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
diff --git a/src/mred/wxs/wxs_slid.h b/src/mred/wxs/wxs_slid.h
new file mode 100644
index 0000000..f9ccbfd
--- /dev/null
+++ b/src/mred/wxs/wxs_slid.h
@@ -0,0 +1,17 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxSlider(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxSlider(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxSlider(class wxSlider *realobj);
+class wxSlider *objscheme_unbundle_wxSlider(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_slid.xc b/src/mred/wxs/wxs_slid.xc
new file mode 100644
index 0000000..9ea9c1a
--- /dev/null
+++ b/src/mred/wxs/wxs_slid.xc
@@ -0,0 +1,28 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_slidr.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxSlider "wx:slider" : "wx:item"
+
+@SET CALLBACK_CLASS = wxSlider
+@SET CALLBACK_CLASS_USER = "wx:slider%::initialization"
+@INCLUDE cb_start.xci
+
+@MACRO PROGRESS = if (x3 < x4 || x5 < x3) scheme_signal_error("wx:slider%%::initialization: minimum, value, and maximum must be increasing");
+@MACRO NOZEROX[p] = if (x<p> <= 0) x<p> = 1;
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,int,int,int,int,int=-1,int=-1,long=wxHORIZONTAL,string="slider"); : : ubCallbackSetup/PROGRESS|NOZEROX[6]//ubCallbackCreatorFinish
+
+@INCLUDE wxs_item.xci
+
+@ "get-value" : int GetValue();
+@ "set-value" : void SetValue(int);
+
+@END
+
+@INCLUDE cb_end.xci
diff --git a/src/mred/wxs/wxs_snip.cxx b/src/mred/wxs/wxs_snip.cxx
new file mode 100644
index 0000000..f89292f
--- /dev/null
+++ b/src/mred/wxs/wxs_snip.cxx
@@ -0,0 +1,8258 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_snip.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_media.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_snip.h"
+#include "wxscomon.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxSnip : public wxSnip {
+ public:
+
+  os_wxSnip(Scheme_Object * obj);
+  ~os_wxSnip();
+  void SetAdmin(class wxSnipAdmin* x0);
+  Bool Resize(float x0, float x1);
+  void Write(class wxMediaStreamOut& x0);
+  Bool Match(class wxSnip* x0);
+  void DoFont(int x0, Bool x1 = TRUE);
+  void DoEdit(int x0, Bool x1 = TRUE, long x2 = 0);
+  void OwnCaret(Bool x0);
+  class wxCursor* AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5);
+  void OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void SizeCacheInvalid();
+  class wxSnip* Copy();
+  string GetText(long x0, long x1, Bool x2 = FALSE, long* x3 = NULL);
+  class wxSnip* MergeWith(class wxSnip* x0);
+  void Split(long x0, class wxSnip** x1, class wxSnip** x2);
+  void Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9);
+  float PartialOffset(class wxDC* x0, float x1, float x2, long x3);
+  void GetExtent(class wxDC* x0, float x1, float x2, float* x3 = NULL, float* x4 = NULL, float* x5 = NULL, float* x6 = NULL, float* x7 = NULL, float* x8 = NULL);
+};
+
+Scheme_Object *os_wxSnip_class;
+
+os_wxSnip::os_wxSnip(Scheme_Object * o)
+: wxSnip()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxSnip::~os_wxSnip()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxSnip::SetAdmin(class wxSnipAdmin* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "set-admin", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::SetAdmin(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnipAdmin(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnip::Resize(float x0, float x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::Resize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip%::resize"", extracting return value");
+  }
+}
+
+void os_wxSnip::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::Write(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxSnip::Match(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "match?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::Match(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:snip%::match?"", extracting return value");
+  }
+}
+
+void os_wxSnip::DoFont(int x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "do-font", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::DoFont(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnip::DoEdit(int x0, Bool x1, long x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "do-edit", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::DoEdit(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  p[2] = scheme_make_integer(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnip::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxSnip::AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::AdjustCursor(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:snip%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxSnip::OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::OnChar(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxKeyEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnip::OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::OnEvent(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnip::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxSnip* os_wxSnip::Copy()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::Copy();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:snip%::copy"", extracting return value", 0);
+  }
+}
+
+string os_wxSnip::GetText(long x0, long x1, Bool x2, long* x3)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "get-text", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::GetText(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (string)objscheme_unbundle_string(v, "wx:snip%::get-text"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxSnip::MergeWith(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "merge-with", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::MergeWith(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:snip%::merge-with"", extracting return value", 0);
+  }
+}
+
+void os_wxSnip::Split(long x0, class wxSnip** x1, class wxSnip** x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "split", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::Split(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = objscheme_box(objscheme_bundle_wxSnip((*x1)));
+  p[2] = objscheme_box(objscheme_bundle_wxSnip((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:snip%::split"", extracting return value via box"), "wx:snip%::split"", extracting return value via box", 0);
+  if (x2) *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:snip%::split"", extracting return value via box"), "wx:snip%::split"", extracting return value via box", 0);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxSnip::Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9)
+{
+  Scheme_Object *p[10];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "draw", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_double(x8);
+  p[9] = scheme_make_integer(x9);
+  
+
+  v = scheme_apply(method, 10, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+float os_wxSnip::PartialOffset(class wxDC* x0, float x1, float x2, long x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "partial-offset", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxSnip::PartialOffset(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_integer(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_float(v, "wx:snip%::partial-offset"", extracting return value");
+  }
+}
+
+void os_wxSnip::GetExtent(class wxDC* x0, float x1, float x2, float* x3, float* x4, float* x5, float* x6, float* x7, float* x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxSnip_class, "get-extent", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = ((x4) ? objscheme_box(scheme_make_double((*x4))) : scheme_null);
+  p[5] = ((x5) ? objscheme_box(scheme_make_double((*x5))) : scheme_null);
+  p[6] = ((x6) ? objscheme_box(scheme_make_double((*x6))) : scheme_null);
+  p[7] = ((x7) ? objscheme_box(scheme_make_double((*x7))) : scheme_null);
+  p[8] = ((x8) ? objscheme_box(scheme_make_double((*x8))) : scheme_null);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  if (x4) *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  if (x5) *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  if (x6) *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  if (x7) *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  if (x8) *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:snip%::get-extent"", extracting return value via box"), "wx:snip%::get-extent"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipPrevious(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Previous();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipNext(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Next();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipAdmin(p[0], "wx:snip%::set-admin", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::SetAdmin(x0);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:snip%::resize");
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Resize(x0, x1);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:snip%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Write(*x0);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipMatch(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip%::match?", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Match(x0);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Match(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:snip%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::DoFont(x0, x1);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:snip%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:snip%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::DoEdit(x0, x1, x2);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:snip%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::OwnCaret(x0);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::adjust-cursor", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::adjust-cursor");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::adjust-cursor");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip%::adjust-cursor");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip%::adjust-cursor");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:snip%::adjust-cursor", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::adjust-cursor");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::AdjustCursor(x0, x1, x2, x3, x4, *x5);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxKeyEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::on-char", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::on-char");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::on-char");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip%::on-char");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip%::on-char");
+  x5 = objscheme_unbundle_wxKeyEvent(p[5], "wx:snip%::on-char", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-char");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::OnChar(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->OnChar(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::on-event", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::on-event");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::on-event");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip%::on-event");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip%::on-event");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:snip%::on-event", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-event");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::OnEvent(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::SizeCacheInvalid();
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Copy();
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  long _x3;
+  long* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::get-text");
+  x1 = objscheme_unbundle_integer(p[1], "wx:snip%::get-text");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:snip%::get-text");
+  } else
+    x2 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::GetText(x0, x1, x2, x3);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_sized_string(r, _x3, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipMergeWith(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:snip%::merge-with", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::MergeWith(x0);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->MergeWith(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSplit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxSnip* _x1;
+  class wxSnip** x1 = &_x1;
+  class wxSnip* _x2;
+  class wxSnip** x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::split");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:snip%::split", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:snip%::split"), "wx:snip%::split", 0);
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:snip%::split", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:snip%::split"), "wx:snip%::split", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Split(x0, x1, x2);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Split(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], objscheme_bundle_wxSnip(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], objscheme_bundle_wxSnip(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipDraw(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  float x8;
+  int x9;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::draw", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::draw");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::draw");
+  x3 = objscheme_unbundle_float(p[3], "wx:snip%::draw");
+  x4 = objscheme_unbundle_float(p[4], "wx:snip%::draw");
+  x5 = objscheme_unbundle_float(p[5], "wx:snip%::draw");
+  x6 = objscheme_unbundle_float(p[6], "wx:snip%::draw");
+  x7 = objscheme_unbundle_float(p[7], "wx:snip%::draw");
+  x8 = objscheme_unbundle_float(p[8], "wx:snip%::draw");
+  x9 = objscheme_unbundle_integer(p[9], "wx:snip%::draw");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::draw");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipPartialOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  long x3;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::partial-offset", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::partial-offset");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::partial-offset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:snip%::partial-offset");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::partial-offset");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::PartialOffset(x0, x1, x2, x3);
+  else
+    r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->PartialOffset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  float _x5;
+  float* x5 = &_x5;
+  float _x6;
+  float* x6 = &_x6;
+  float _x7;
+  float* x7 = &_x7;
+  float _x8;
+  float* x8 = &_x8;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:snip%::get-extent", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:snip%::get-extent");
+  x2 = objscheme_unbundle_float(p[2], "wx:snip%::get-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    if (SCHEME_NULLP(p[5]))
+    x5 = NULL;
+  else
+    *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    if (SCHEME_NULLP(p[6]))
+    x6 = NULL;
+  else
+    *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    if (SCHEME_NULLP(p[7]))
+    x7 = NULL;
+  else
+    *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x7 = NULL;
+  if (n > 8) {
+    if (SCHEME_NULLP(p[8]))
+    x8 = NULL;
+  else
+    *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:snip%::get-extent"), "wx:snip%::get-extent");
+  } else
+    x8 = NULL;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::get-extent");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxSnip *)((Scheme_Class_Object *)obj)->primdata)->wxSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  if (n > 5 && !SCHEME_NULLP(p[5]))
+    objscheme_set_box(p[5], scheme_make_double(_x5));
+  if (n > 6 && !SCHEME_NULLP(p[6]))
+    objscheme_set_box(p[6], scheme_make_double(_x6));
+  if (n > 7 && !SCHEME_NULLP(p[7]))
+    objscheme_set_box(p[7], scheme_make_double(_x7));
+  if (n > 8 && !SCHEME_NULLP(p[8]))
+    objscheme_set_box(p[8], scheme_make_double(_x8));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipReleaseFromOwner(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->ReleaseFromOwner();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipIsOwned(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->IsOwned();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:snip%::set-style", 0);
+
+  
+  ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->SetStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSetFlags(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::set-flags");
+
+  
+  ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->SetFlags(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipSetCount(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:snip%::set-count");
+
+  
+  ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->SetCount(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnipGetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnipAdmin* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxSnip *)((Scheme_Class_Object *)obj)->primdata)->GetAdmin();
+
+  
+  
+  return objscheme_bundle_wxSnipAdmin(r);
+}
+
+static Scheme_Object *objscheme_wxSnip_Getcount(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-count", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnip *)cobj->primdata)->wxSnip::count;
+  else
+    v = ((wxSnip *)cobj->primdata)->count;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxSnip_Getflags(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  long v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-flags", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnip *)cobj->primdata)->wxSnip::flags;
+  else
+    v = ((wxSnip *)cobj->primdata)->flags;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxSnip_Getstyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxStyle* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-style", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnip *)cobj->primdata)->wxSnip::style;
+  else
+    v = ((wxSnip *)cobj->primdata)->style;
+
+  return objscheme_bundle_wxStyle(v);
+}
+
+static Scheme_Object *objscheme_wxSnip_Getsnipclass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxSnipClass* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-snipclass", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxSnip *)cobj->primdata)->wxSnip::snipclass;
+  else
+    v = ((wxSnip *)cobj->primdata)->snipclass;
+
+  return objscheme_bundle_wxSnipClass(v);
+}
+
+static Scheme_Object *objscheme_wxSnip_Setsnipclass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  class wxSnipClass* v;
+
+  if (n != 1) scheme_wrong_count("set-snipclass", 1, 1, n, p);
+
+  v = objscheme_unbundle_wxSnipClass(p[0], "wx:snip%::snipclass", 1);
+  ((wxSnip *)cobj->primdata)->snipclass = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxSnip_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxSnip *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:snip%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxSnip(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:snip%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:snip%");
+}
+
+void objscheme_setup_wxSnip(void *env)
+{
+if (os_wxSnip_class) {
+    objscheme_add_global_class(os_wxSnip_class,  "wx:snip%", env);
+} else {
+  os_wxSnip_class = objscheme_def_prim_class(env, "wx:snip%", "wx:object%", os_wxSnip_ConstructScheme, 32);
+
+  scheme_add_method_w_arity(os_wxSnip_class,"get-class-name",objscheme_classname_os_wxSnip, 0, 0);
+
+ scheme_add_method_w_arity(os_wxSnip_class, "previous", os_wxSnipPrevious, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "next", os_wxSnipNext, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "set-admin", os_wxSnipSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "resize", os_wxSnipResize, 2, 2);
+ scheme_add_method_w_arity(os_wxSnip_class, "write", os_wxSnipWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "match?", os_wxSnipMatch, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "do-font", os_wxSnipDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxSnip_class, "do-edit", os_wxSnipDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxSnip_class, "own-caret", os_wxSnipOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "adjust-cursor", os_wxSnipAdjustCursor, 6, 6);
+ scheme_add_method_w_arity(os_wxSnip_class, "on-char", os_wxSnipOnChar, 6, 6);
+ scheme_add_method_w_arity(os_wxSnip_class, "on-event", os_wxSnipOnEvent, 6, 6);
+ scheme_add_method_w_arity(os_wxSnip_class, "size-cache-invalid", os_wxSnipSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "copy", os_wxSnipCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "get-text", os_wxSnipGetText, 2, 3);
+ scheme_add_method_w_arity(os_wxSnip_class, "merge-with", os_wxSnipMergeWith, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "split", os_wxSnipSplit, 3, 3);
+ scheme_add_method_w_arity(os_wxSnip_class, "draw", os_wxSnipDraw, 10, 10);
+ scheme_add_method_w_arity(os_wxSnip_class, "partial-offset", os_wxSnipPartialOffset, 4, 4);
+ scheme_add_method_w_arity(os_wxSnip_class, "get-extent", os_wxSnipGetExtent, 3, 9);
+ scheme_add_method_w_arity(os_wxSnip_class, "release-from-owner", os_wxSnipReleaseFromOwner, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "is-owned?", os_wxSnipIsOwned, 0, 0);
+ scheme_add_method_w_arity(os_wxSnip_class, "set-style", os_wxSnipSetStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "set-flags", os_wxSnipSetFlags, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "set-count", os_wxSnipSetCount, 1, 1);
+ scheme_add_method_w_arity(os_wxSnip_class, "get-admin", os_wxSnipGetAdmin, 0, 0);
+
+  scheme_add_method_w_arity(os_wxSnip_class,"get-count", objscheme_wxSnip_Getcount, 0, 0);
+  scheme_add_method_w_arity(os_wxSnip_class,"get-flags", objscheme_wxSnip_Getflags, 0, 0);
+  scheme_add_method_w_arity(os_wxSnip_class,"get-style", objscheme_wxSnip_Getstyle, 0, 0);
+  scheme_add_method_w_arity(os_wxSnip_class,"get-snipclass", objscheme_wxSnip_Getsnipclass, 0, 0);
+  scheme_add_method_w_arity(os_wxSnip_class,"set-snipclass", objscheme_wxSnip_Setsnipclass, 1, 1);
+
+  scheme_made_class(os_wxSnip_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxSnip, wxTYPE_SNIP);
+
+}
+  scheme_install_xc_global("wx:const-snip-can-append", scheme_make_integer(wxSNIP_CAN_APPEND), env);
+  scheme_install_xc_global("wx:const-snip-newline", scheme_make_integer(wxSNIP_NEWLINE), env);
+  scheme_install_xc_global("wx:const-snip-hard-newline", scheme_make_integer(wxSNIP_HARD_NEWLINE), env);
+  scheme_install_xc_global("wx:const-snip-is-text", scheme_make_integer(wxSNIP_IS_TEXT), env);
+  scheme_install_xc_global("wx:const-snip-invisible", scheme_make_integer(wxSNIP_INVISIBLE), env);
+  scheme_install_xc_global("wx:const-snip-handles-events", scheme_make_integer(wxSNIP_HANDLES_EVENTS), env);
+  scheme_install_xc_global("wx:const-snip-width-depends-on-x", scheme_make_integer(wxSNIP_WIDTH_DEPENDS_ON_X), env);
+  scheme_install_xc_global("wx:const-snip-height-depends-on-x", scheme_make_integer(wxSNIP_HEIGHT_DEPENDS_ON_X), env);
+  scheme_install_xc_global("wx:const-snip-width-depends-on-y", scheme_make_integer(wxSNIP_WIDTH_DEPENDS_ON_Y), env);
+  scheme_install_xc_global("wx:const-snip-height-depends-on-y", scheme_make_integer(wxSNIP_HEIGHT_DEPENDS_ON_Y), env);
+  scheme_install_xc_global("wx:const-snip-anchored", scheme_make_integer(wxSNIP_ANCHORED), env);
+  scheme_install_xc_global("wx:const-snip-uses-buffer-path", scheme_make_integer(wxSNIP_USES_BUFFER_PATH), env);
+}
+
+int objscheme_istype_wxSnip(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxSnip_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:snip%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_SNIP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxSnip_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxSnip(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxSnip *)o->primdata;
+  else
+    return (wxSnip *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxTextSnip : public wxTextSnip {
+ public:
+
+  os_wxTextSnip(Scheme_Object * obj, long x0 = 0);
+  ~os_wxTextSnip();
+  void SetAdmin(class wxSnipAdmin* x0);
+  Bool Resize(float x0, float x1);
+  void Write(class wxMediaStreamOut& x0);
+  Bool Match(class wxSnip* x0);
+  void DoFont(int x0, Bool x1 = TRUE);
+  void DoEdit(int x0, Bool x1 = TRUE, long x2 = 0);
+  void OwnCaret(Bool x0);
+  class wxCursor* AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5);
+  void OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void SizeCacheInvalid();
+  class wxSnip* Copy();
+  string GetText(long x0, long x1, Bool x2 = FALSE, long* x3 = NULL);
+  class wxSnip* MergeWith(class wxSnip* x0);
+  void Split(long x0, class wxSnip** x1, class wxSnip** x2);
+  void Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9);
+  float PartialOffset(class wxDC* x0, float x1, float x2, long x3);
+  void GetExtent(class wxDC* x0, float x1, float x2, float* x3 = NULL, float* x4 = NULL, float* x5 = NULL, float* x6 = NULL, float* x7 = NULL, float* x8 = NULL);
+};
+
+Scheme_Object *os_wxTextSnip_class;
+
+os_wxTextSnip::os_wxTextSnip(Scheme_Object * o, long x0)
+: wxTextSnip(x0)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxTextSnip::~os_wxTextSnip()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxTextSnip::SetAdmin(class wxSnipAdmin* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "set-admin", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::SetAdmin(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnipAdmin(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxTextSnip::Resize(float x0, float x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::Resize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text-snip%::resize"", extracting return value");
+  }
+}
+
+void os_wxTextSnip::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::Write(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxTextSnip::Match(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "match?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::Match(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text-snip%::match?"", extracting return value");
+  }
+}
+
+void os_wxTextSnip::DoFont(int x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "do-font", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::DoFont(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextSnip::DoEdit(int x0, Bool x1, long x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "do-edit", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::DoEdit(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  p[2] = scheme_make_integer(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextSnip::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxTextSnip::AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::AdjustCursor(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:text-snip%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxTextSnip::OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::OnChar(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxKeyEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextSnip::OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::OnEvent(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextSnip::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxSnip* os_wxTextSnip::Copy()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::Copy();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:text-snip%::copy"", extracting return value", 0);
+  }
+}
+
+string os_wxTextSnip::GetText(long x0, long x1, Bool x2, long* x3)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "get-text", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::GetText(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (string)objscheme_unbundle_string(v, "wx:text-snip%::get-text"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxTextSnip::MergeWith(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "merge-with", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::MergeWith(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:text-snip%::merge-with"", extracting return value", 0);
+  }
+}
+
+void os_wxTextSnip::Split(long x0, class wxSnip** x1, class wxSnip** x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "split", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::Split(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = objscheme_box(objscheme_bundle_wxSnip((*x1)));
+  p[2] = objscheme_box(objscheme_bundle_wxSnip((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:text-snip%::split"", extracting return value via box"), "wx:text-snip%::split"", extracting return value via box", 0);
+  if (x2) *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:text-snip%::split"", extracting return value via box"), "wx:text-snip%::split"", extracting return value via box", 0);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextSnip::Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9)
+{
+  Scheme_Object *p[10];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "draw", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_double(x8);
+  p[9] = scheme_make_integer(x9);
+  
+
+  v = scheme_apply(method, 10, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+float os_wxTextSnip::PartialOffset(class wxDC* x0, float x1, float x2, long x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "partial-offset", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTextSnip::PartialOffset(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_integer(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_float(v, "wx:text-snip%::partial-offset"", extracting return value");
+  }
+}
+
+void os_wxTextSnip::GetExtent(class wxDC* x0, float x1, float x2, float* x3, float* x4, float* x5, float* x6, float* x7, float* x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextSnip_class, "get-extent", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = ((x4) ? objscheme_box(scheme_make_double((*x4))) : scheme_null);
+  p[5] = ((x5) ? objscheme_box(scheme_make_double((*x5))) : scheme_null);
+  p[6] = ((x6) ? objscheme_box(scheme_make_double((*x6))) : scheme_null);
+  p[7] = ((x7) ? objscheme_box(scheme_make_double((*x7))) : scheme_null);
+  p[8] = ((x8) ? objscheme_box(scheme_make_double((*x8))) : scheme_null);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  if (x4) *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  if (x5) *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  if (x6) *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  if (x7) *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  if (x8) *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:text-snip%::get-extent"", extracting return value via box"), "wx:text-snip%::get-extent"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipRead(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxMediaStreamIn* x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::read");
+  x1 = objscheme_unbundle_wxMediaStreamIn(p[1], "wx:text-snip%::read", 0);
+
+  
+  ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Read(x0, *x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipInsert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  long x1;
+  long x2;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:text-snip%::insert");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-snip%::insert");
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:text-snip%::insert");
+  } else
+    x2 = 0;
+
+  
+  ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Insert(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipAdmin(p[0], "wx:text-snip%::set-admin", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::SetAdmin(x0);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:text-snip%::resize");
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Resize(x0, x1);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:text-snip%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Write(*x0);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipMatch(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:text-snip%::match?", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Match(x0);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Match(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:text-snip%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::DoFont(x0, x1);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:text-snip%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:text-snip%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::DoEdit(x0, x1, x2);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:text-snip%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::OwnCaret(x0);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::adjust-cursor", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::adjust-cursor");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::adjust-cursor");
+  x3 = objscheme_unbundle_float(p[3], "wx:text-snip%::adjust-cursor");
+  x4 = objscheme_unbundle_float(p[4], "wx:text-snip%::adjust-cursor");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:text-snip%::adjust-cursor", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::adjust-cursor");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::AdjustCursor(x0, x1, x2, x3, x4, *x5);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxKeyEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::on-char", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::on-char");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::on-char");
+  x3 = objscheme_unbundle_float(p[3], "wx:text-snip%::on-char");
+  x4 = objscheme_unbundle_float(p[4], "wx:text-snip%::on-char");
+  x5 = objscheme_unbundle_wxKeyEvent(p[5], "wx:text-snip%::on-char", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-char");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::OnChar(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->OnChar(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::on-event", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::on-event");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::on-event");
+  x3 = objscheme_unbundle_float(p[3], "wx:text-snip%::on-event");
+  x4 = objscheme_unbundle_float(p[4], "wx:text-snip%::on-event");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:text-snip%::on-event", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-event");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::OnEvent(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::SizeCacheInvalid();
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Copy();
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  long _x3;
+  long* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::get-text");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-snip%::get-text");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:text-snip%::get-text");
+  } else
+    x2 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::GetText(x0, x1, x2, x3);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_sized_string(r, _x3, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipMergeWith(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:text-snip%::merge-with", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::MergeWith(x0);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->MergeWith(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipSplit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxSnip* _x1;
+  class wxSnip** x1 = &_x1;
+  class wxSnip* _x2;
+  class wxSnip** x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::split");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:text-snip%::split", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:text-snip%::split"), "wx:text-snip%::split", 0);
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:text-snip%::split", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:text-snip%::split"), "wx:text-snip%::split", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Split(x0, x1, x2);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Split(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], objscheme_bundle_wxSnip(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], objscheme_bundle_wxSnip(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipDraw(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  float x8;
+  int x9;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::draw", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::draw");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::draw");
+  x3 = objscheme_unbundle_float(p[3], "wx:text-snip%::draw");
+  x4 = objscheme_unbundle_float(p[4], "wx:text-snip%::draw");
+  x5 = objscheme_unbundle_float(p[5], "wx:text-snip%::draw");
+  x6 = objscheme_unbundle_float(p[6], "wx:text-snip%::draw");
+  x7 = objscheme_unbundle_float(p[7], "wx:text-snip%::draw");
+  x8 = objscheme_unbundle_float(p[8], "wx:text-snip%::draw");
+  x9 = objscheme_unbundle_integer(p[9], "wx:text-snip%::draw");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::draw");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipPartialOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  long x3;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::partial-offset", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::partial-offset");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::partial-offset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:text-snip%::partial-offset");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::partial-offset");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::PartialOffset(x0, x1, x2, x3);
+  else
+    r = ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->PartialOffset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnipGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  float _x5;
+  float* x5 = &_x5;
+  float _x6;
+  float* x6 = &_x6;
+  float _x7;
+  float* x7 = &_x7;
+  float _x8;
+  float* x8 = &_x8;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:text-snip%::get-extent", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-snip%::get-extent");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-snip%::get-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    if (SCHEME_NULLP(p[5]))
+    x5 = NULL;
+  else
+    *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    if (SCHEME_NULLP(p[6]))
+    x6 = NULL;
+  else
+    *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    if (SCHEME_NULLP(p[7]))
+    x7 = NULL;
+  else
+    *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x7 = NULL;
+  if (n > 8) {
+    if (SCHEME_NULLP(p[8]))
+    x8 = NULL;
+  else
+    *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:text-snip%::get-extent"), "wx:text-snip%::get-extent");
+  } else
+    x8 = NULL;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::get-extent");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTextSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxTextSnip *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  if (n > 5 && !SCHEME_NULLP(p[5]))
+    objscheme_set_box(p[5], scheme_make_double(_x5));
+  if (n > 6 && !SCHEME_NULLP(p[6]))
+    objscheme_set_box(p[6], scheme_make_double(_x6));
+  if (n > 7 && !SCHEME_NULLP(p[7]))
+    objscheme_set_box(p[7], scheme_make_double(_x7));
+  if (n > 8 && !SCHEME_NULLP(p[8]))
+    objscheme_set_box(p[8], scheme_make_double(_x8));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSnip_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxTextSnip *realobj;
+  long x0;
+
+  
+  if ((n > 1)) 
+    scheme_wrong_count("wx:text-snip%::initialization", 0, 1, n, p);
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:text-snip%::initialization");
+  } else
+    x0 = 0;
+
+  
+  realobj = new os_wxTextSnip(obj, x0);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxTextSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:text-snip%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:text-snip%");
+}
+
+void objscheme_setup_wxTextSnip(void *env)
+{
+if (os_wxTextSnip_class) {
+    objscheme_add_global_class(os_wxTextSnip_class,  "wx:text-snip%", env);
+} else {
+  os_wxTextSnip_class = objscheme_def_prim_class(env, "wx:text-snip%", "wx:snip%", os_wxTextSnip_ConstructScheme, 21);
+
+  scheme_add_method_w_arity(os_wxTextSnip_class,"get-class-name",objscheme_classname_os_wxTextSnip, 0, 0);
+
+ scheme_add_method_w_arity(os_wxTextSnip_class, "read", os_wxTextSnipRead, 2, 2);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "insert", os_wxTextSnipInsert, 2, 3);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "set-admin", os_wxTextSnipSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "resize", os_wxTextSnipResize, 2, 2);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "write", os_wxTextSnipWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "match?", os_wxTextSnipMatch, 1, 1);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "do-font", os_wxTextSnipDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "do-edit", os_wxTextSnipDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "own-caret", os_wxTextSnipOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "adjust-cursor", os_wxTextSnipAdjustCursor, 6, 6);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "on-char", os_wxTextSnipOnChar, 6, 6);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "on-event", os_wxTextSnipOnEvent, 6, 6);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "size-cache-invalid", os_wxTextSnipSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "copy", os_wxTextSnipCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "get-text", os_wxTextSnipGetText, 2, 3);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "merge-with", os_wxTextSnipMergeWith, 1, 1);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "split", os_wxTextSnipSplit, 3, 3);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "draw", os_wxTextSnipDraw, 10, 10);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "partial-offset", os_wxTextSnipPartialOffset, 4, 4);
+ scheme_add_method_w_arity(os_wxTextSnip_class, "get-extent", os_wxTextSnipGetExtent, 3, 9);
+
+
+  scheme_made_class(os_wxTextSnip_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxTextSnip, wxTYPE_TEXT_SNIP);
+
+}
+}
+
+int objscheme_istype_wxTextSnip(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxTextSnip_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:text-snip%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxTextSnip(class wxTextSnip *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_TEXT_SNIP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxTextSnip_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxTextSnip *objscheme_unbundle_wxTextSnip(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxTextSnip(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxTextSnip *)o->primdata;
+  else
+    return (wxTextSnip *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxTabSnip : public wxTabSnip {
+ public:
+
+  os_wxTabSnip(Scheme_Object * obj);
+  ~os_wxTabSnip();
+  void SetAdmin(class wxSnipAdmin* x0);
+  Bool Resize(float x0, float x1);
+  void Write(class wxMediaStreamOut& x0);
+  Bool Match(class wxSnip* x0);
+  void DoFont(int x0, Bool x1 = TRUE);
+  void DoEdit(int x0, Bool x1 = TRUE, long x2 = 0);
+  void OwnCaret(Bool x0);
+  class wxCursor* AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5);
+  void OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void SizeCacheInvalid();
+  class wxSnip* Copy();
+  string GetText(long x0, long x1, Bool x2 = FALSE, long* x3 = NULL);
+  class wxSnip* MergeWith(class wxSnip* x0);
+  void Split(long x0, class wxSnip** x1, class wxSnip** x2);
+  void Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9);
+  float PartialOffset(class wxDC* x0, float x1, float x2, long x3);
+  void GetExtent(class wxDC* x0, float x1, float x2, float* x3 = NULL, float* x4 = NULL, float* x5 = NULL, float* x6 = NULL, float* x7 = NULL, float* x8 = NULL);
+};
+
+Scheme_Object *os_wxTabSnip_class;
+
+os_wxTabSnip::os_wxTabSnip(Scheme_Object * o)
+: wxTabSnip()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxTabSnip::~os_wxTabSnip()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxTabSnip::SetAdmin(class wxSnipAdmin* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "set-admin", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::SetAdmin(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnipAdmin(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxTabSnip::Resize(float x0, float x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::Resize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:tab-snip%::resize"", extracting return value");
+  }
+}
+
+void os_wxTabSnip::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::Write(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxTabSnip::Match(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "match?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::Match(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:tab-snip%::match?"", extracting return value");
+  }
+}
+
+void os_wxTabSnip::DoFont(int x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "do-font", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::DoFont(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTabSnip::DoEdit(int x0, Bool x1, long x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "do-edit", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::DoEdit(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  p[2] = scheme_make_integer(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTabSnip::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxTabSnip::AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::AdjustCursor(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:tab-snip%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxTabSnip::OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::OnChar(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxKeyEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTabSnip::OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::OnEvent(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTabSnip::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxSnip* os_wxTabSnip::Copy()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::Copy();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:tab-snip%::copy"", extracting return value", 0);
+  }
+}
+
+string os_wxTabSnip::GetText(long x0, long x1, Bool x2, long* x3)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "get-text", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::GetText(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (string)objscheme_unbundle_string(v, "wx:tab-snip%::get-text"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxTabSnip::MergeWith(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "merge-with", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::MergeWith(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:tab-snip%::merge-with"", extracting return value", 0);
+  }
+}
+
+void os_wxTabSnip::Split(long x0, class wxSnip** x1, class wxSnip** x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "split", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::Split(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = objscheme_box(objscheme_bundle_wxSnip((*x1)));
+  p[2] = objscheme_box(objscheme_bundle_wxSnip((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:tab-snip%::split"", extracting return value via box"), "wx:tab-snip%::split"", extracting return value via box", 0);
+  if (x2) *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:tab-snip%::split"", extracting return value via box"), "wx:tab-snip%::split"", extracting return value via box", 0);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTabSnip::Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9)
+{
+  Scheme_Object *p[10];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "draw", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_double(x8);
+  p[9] = scheme_make_integer(x9);
+  
+
+  v = scheme_apply(method, 10, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+float os_wxTabSnip::PartialOffset(class wxDC* x0, float x1, float x2, long x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "partial-offset", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxTabSnip::PartialOffset(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_integer(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_float(v, "wx:tab-snip%::partial-offset"", extracting return value");
+  }
+}
+
+void os_wxTabSnip::GetExtent(class wxDC* x0, float x1, float x2, float* x3, float* x4, float* x5, float* x6, float* x7, float* x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTabSnip_class, "get-extent", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTabSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = ((x4) ? objscheme_box(scheme_make_double((*x4))) : scheme_null);
+  p[5] = ((x5) ? objscheme_box(scheme_make_double((*x5))) : scheme_null);
+  p[6] = ((x6) ? objscheme_box(scheme_make_double((*x6))) : scheme_null);
+  p[7] = ((x7) ? objscheme_box(scheme_make_double((*x7))) : scheme_null);
+  p[8] = ((x8) ? objscheme_box(scheme_make_double((*x8))) : scheme_null);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  if (x4) *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  if (x5) *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  if (x6) *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  if (x7) *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  if (x8) *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:tab-snip%::get-extent"", extracting return value via box"), "wx:tab-snip%::get-extent"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipAdmin(p[0], "wx:tab-snip%::set-admin", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::SetAdmin(x0);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:tab-snip%::resize");
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Resize(x0, x1);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:tab-snip%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Write(*x0);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipMatch(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:tab-snip%::match?", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Match(x0);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Match(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:tab-snip%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:tab-snip%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::DoFont(x0, x1);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:tab-snip%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:tab-snip%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:tab-snip%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::DoEdit(x0, x1, x2);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:tab-snip%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::OwnCaret(x0);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::adjust-cursor", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::adjust-cursor");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::adjust-cursor");
+  x3 = objscheme_unbundle_float(p[3], "wx:tab-snip%::adjust-cursor");
+  x4 = objscheme_unbundle_float(p[4], "wx:tab-snip%::adjust-cursor");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:tab-snip%::adjust-cursor", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::adjust-cursor");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::AdjustCursor(x0, x1, x2, x3, x4, *x5);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxKeyEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::on-char", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::on-char");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::on-char");
+  x3 = objscheme_unbundle_float(p[3], "wx:tab-snip%::on-char");
+  x4 = objscheme_unbundle_float(p[4], "wx:tab-snip%::on-char");
+  x5 = objscheme_unbundle_wxKeyEvent(p[5], "wx:tab-snip%::on-char", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-char");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::OnChar(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->OnChar(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::on-event", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::on-event");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::on-event");
+  x3 = objscheme_unbundle_float(p[3], "wx:tab-snip%::on-event");
+  x4 = objscheme_unbundle_float(p[4], "wx:tab-snip%::on-event");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:tab-snip%::on-event", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-event");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::OnEvent(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::SizeCacheInvalid();
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Copy();
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  long _x3;
+  long* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:tab-snip%::get-text");
+  x1 = objscheme_unbundle_integer(p[1], "wx:tab-snip%::get-text");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:tab-snip%::get-text");
+  } else
+    x2 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::GetText(x0, x1, x2, x3);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_sized_string(r, _x3, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipMergeWith(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:tab-snip%::merge-with", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::MergeWith(x0);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->MergeWith(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipSplit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxSnip* _x1;
+  class wxSnip** x1 = &_x1;
+  class wxSnip* _x2;
+  class wxSnip** x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:tab-snip%::split");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:tab-snip%::split", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:tab-snip%::split"), "wx:tab-snip%::split", 0);
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:tab-snip%::split", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:tab-snip%::split"), "wx:tab-snip%::split", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Split(x0, x1, x2);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Split(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], objscheme_bundle_wxSnip(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], objscheme_bundle_wxSnip(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipDraw(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  float x8;
+  int x9;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::draw", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::draw");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::draw");
+  x3 = objscheme_unbundle_float(p[3], "wx:tab-snip%::draw");
+  x4 = objscheme_unbundle_float(p[4], "wx:tab-snip%::draw");
+  x5 = objscheme_unbundle_float(p[5], "wx:tab-snip%::draw");
+  x6 = objscheme_unbundle_float(p[6], "wx:tab-snip%::draw");
+  x7 = objscheme_unbundle_float(p[7], "wx:tab-snip%::draw");
+  x8 = objscheme_unbundle_float(p[8], "wx:tab-snip%::draw");
+  x9 = objscheme_unbundle_integer(p[9], "wx:tab-snip%::draw");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::draw");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipPartialOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  long x3;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::partial-offset", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::partial-offset");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::partial-offset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:tab-snip%::partial-offset");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::partial-offset");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::PartialOffset(x0, x1, x2, x3);
+  else
+    r = ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->PartialOffset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnipGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  float _x5;
+  float* x5 = &_x5;
+  float _x6;
+  float* x6 = &_x6;
+  float _x7;
+  float* x7 = &_x7;
+  float _x8;
+  float* x8 = &_x8;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:tab-snip%::get-extent", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:tab-snip%::get-extent");
+  x2 = objscheme_unbundle_float(p[2], "wx:tab-snip%::get-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    if (SCHEME_NULLP(p[5]))
+    x5 = NULL;
+  else
+    *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    if (SCHEME_NULLP(p[6]))
+    x6 = NULL;
+  else
+    *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    if (SCHEME_NULLP(p[7]))
+    x7 = NULL;
+  else
+    *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x7 = NULL;
+  if (n > 8) {
+    if (SCHEME_NULLP(p[8]))
+    x8 = NULL;
+  else
+    *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:tab-snip%::get-extent"), "wx:tab-snip%::get-extent");
+  } else
+    x8 = NULL;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::get-extent");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->wxTabSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxTabSnip *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  if (n > 5 && !SCHEME_NULLP(p[5]))
+    objscheme_set_box(p[5], scheme_make_double(_x5));
+  if (n > 6 && !SCHEME_NULLP(p[6]))
+    objscheme_set_box(p[6], scheme_make_double(_x6));
+  if (n > 7 && !SCHEME_NULLP(p[7]))
+    objscheme_set_box(p[7], scheme_make_double(_x7));
+  if (n > 8 && !SCHEME_NULLP(p[8]))
+    objscheme_set_box(p[8], scheme_make_double(_x8));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTabSnip_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxTabSnip *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:tab-snip%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxTabSnip(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxTabSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:tab-snip%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:tab-snip%");
+}
+
+void objscheme_setup_wxTabSnip(void *env)
+{
+if (os_wxTabSnip_class) {
+    objscheme_add_global_class(os_wxTabSnip_class,  "wx:tab-snip%", env);
+} else {
+  os_wxTabSnip_class = objscheme_def_prim_class(env, "wx:tab-snip%", "wx:text-snip%", os_wxTabSnip_ConstructScheme, 19);
+
+  scheme_add_method_w_arity(os_wxTabSnip_class,"get-class-name",objscheme_classname_os_wxTabSnip, 0, 0);
+
+ scheme_add_method_w_arity(os_wxTabSnip_class, "set-admin", os_wxTabSnipSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "resize", os_wxTabSnipResize, 2, 2);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "write", os_wxTabSnipWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "match?", os_wxTabSnipMatch, 1, 1);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "do-font", os_wxTabSnipDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "do-edit", os_wxTabSnipDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "own-caret", os_wxTabSnipOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "adjust-cursor", os_wxTabSnipAdjustCursor, 6, 6);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "on-char", os_wxTabSnipOnChar, 6, 6);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "on-event", os_wxTabSnipOnEvent, 6, 6);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "size-cache-invalid", os_wxTabSnipSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "copy", os_wxTabSnipCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "get-text", os_wxTabSnipGetText, 2, 3);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "merge-with", os_wxTabSnipMergeWith, 1, 1);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "split", os_wxTabSnipSplit, 3, 3);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "draw", os_wxTabSnipDraw, 10, 10);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "partial-offset", os_wxTabSnipPartialOffset, 4, 4);
+ scheme_add_method_w_arity(os_wxTabSnip_class, "get-extent", os_wxTabSnipGetExtent, 3, 9);
+
+
+  scheme_made_class(os_wxTabSnip_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxTabSnip, wxTYPE_TAB_SNIP);
+
+}
+}
+
+int objscheme_istype_wxTabSnip(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxTabSnip_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:tab-snip%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxTabSnip(class wxTabSnip *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_TAB_SNIP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxTabSnip_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxTabSnip *objscheme_unbundle_wxTabSnip(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxTabSnip(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxTabSnip *)o->primdata;
+  else
+    return (wxTabSnip *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxImageSnip : public wxImageSnip {
+ public:
+
+  os_wxImageSnip(Scheme_Object * obj, nstring x0 = NULL, long x1 = 0, Bool x2 = FALSE, Bool x3 = TRUE);
+  ~os_wxImageSnip();
+  void SetAdmin(class wxSnipAdmin* x0);
+  Bool Resize(float x0, float x1);
+  void Write(class wxMediaStreamOut& x0);
+  Bool Match(class wxSnip* x0);
+  void DoFont(int x0, Bool x1 = TRUE);
+  void DoEdit(int x0, Bool x1 = TRUE, long x2 = 0);
+  void OwnCaret(Bool x0);
+  class wxCursor* AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5);
+  void OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void SizeCacheInvalid();
+  class wxSnip* Copy();
+  string GetText(long x0, long x1, Bool x2 = FALSE, long* x3 = NULL);
+  class wxSnip* MergeWith(class wxSnip* x0);
+  void Split(long x0, class wxSnip** x1, class wxSnip** x2);
+  void Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9);
+  float PartialOffset(class wxDC* x0, float x1, float x2, long x3);
+  void GetExtent(class wxDC* x0, float x1, float x2, float* x3 = NULL, float* x4 = NULL, float* x5 = NULL, float* x6 = NULL, float* x7 = NULL, float* x8 = NULL);
+};
+
+Scheme_Object *os_wxImageSnip_class;
+
+os_wxImageSnip::os_wxImageSnip(Scheme_Object * o, nstring x0, long x1, Bool x2, Bool x3)
+: wxImageSnip(x0, x1, x2, x3)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxImageSnip::~os_wxImageSnip()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxImageSnip::SetAdmin(class wxSnipAdmin* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "set-admin", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::SetAdmin(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnipAdmin(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxImageSnip::Resize(float x0, float x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::Resize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:image-snip%::resize"", extracting return value");
+  }
+}
+
+void os_wxImageSnip::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::Write(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxImageSnip::Match(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "match?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::Match(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:image-snip%::match?"", extracting return value");
+  }
+}
+
+void os_wxImageSnip::DoFont(int x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "do-font", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::DoFont(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxImageSnip::DoEdit(int x0, Bool x1, long x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "do-edit", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::DoEdit(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  p[2] = scheme_make_integer(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxImageSnip::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxImageSnip::AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::AdjustCursor(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:image-snip%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxImageSnip::OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::OnChar(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxKeyEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxImageSnip::OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::OnEvent(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxImageSnip::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxSnip* os_wxImageSnip::Copy()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::Copy();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:image-snip%::copy"", extracting return value", 0);
+  }
+}
+
+string os_wxImageSnip::GetText(long x0, long x1, Bool x2, long* x3)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "get-text", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::GetText(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (string)objscheme_unbundle_string(v, "wx:image-snip%::get-text"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxImageSnip::MergeWith(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "merge-with", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::MergeWith(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:image-snip%::merge-with"", extracting return value", 0);
+  }
+}
+
+void os_wxImageSnip::Split(long x0, class wxSnip** x1, class wxSnip** x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "split", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::Split(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = objscheme_box(objscheme_bundle_wxSnip((*x1)));
+  p[2] = objscheme_box(objscheme_bundle_wxSnip((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:image-snip%::split"", extracting return value via box"), "wx:image-snip%::split"", extracting return value via box", 0);
+  if (x2) *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:image-snip%::split"", extracting return value via box"), "wx:image-snip%::split"", extracting return value via box", 0);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxImageSnip::Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9)
+{
+  Scheme_Object *p[10];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "draw", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_double(x8);
+  p[9] = scheme_make_integer(x9);
+  
+
+  v = scheme_apply(method, 10, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+float os_wxImageSnip::PartialOffset(class wxDC* x0, float x1, float x2, long x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "partial-offset", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxImageSnip::PartialOffset(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_integer(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_float(v, "wx:image-snip%::partial-offset"", extracting return value");
+  }
+}
+
+void os_wxImageSnip::GetExtent(class wxDC* x0, float x1, float x2, float* x3, float* x4, float* x5, float* x6, float* x7, float* x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxImageSnip_class, "get-extent", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxImageSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = ((x4) ? objscheme_box(scheme_make_double((*x4))) : scheme_null);
+  p[5] = ((x5) ? objscheme_box(scheme_make_double((*x5))) : scheme_null);
+  p[6] = ((x6) ? objscheme_box(scheme_make_double((*x6))) : scheme_null);
+  p[7] = ((x7) ? objscheme_box(scheme_make_double((*x7))) : scheme_null);
+  p[8] = ((x8) ? objscheme_box(scheme_make_double((*x8))) : scheme_null);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  if (x4) *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  if (x5) *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  if (x6) *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  if (x7) *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  if (x8) *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:image-snip%::get-extent"", extracting return value via box"), "wx:image-snip%::get-extent"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipSetOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:image-snip%::set-offset");
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::set-offset");
+
+  
+  ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->SetOffset(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipSetBitmap(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBitmap* x0;
+
+  
+  x0 = objscheme_unbundle_wxBitmap(p[0], "wx:image-snip%::set-bitmap", 0);
+
+  
+  ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->SetBitmap(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipGetFiletype(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->GetFiletype();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipGetFilename(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+  Bool _x0;
+  Bool* x0 = &_x0;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    x0 = NULL;
+  else
+    *x0 = objscheme_unbundle_bool(objscheme_unbox(p[0], "wx:image-snip%::get-filename"), "wx:image-snip%::get-filename");
+
+  
+  r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->GetFilename(x0);
+
+  
+  if (n > 0 && !SCHEME_NULLP(p[0]))
+    objscheme_set_box(p[0], (_x0 ? scheme_true : scheme_false));
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:image-snip%::load-file");
+  x1 = objscheme_unbundle_integer(p[1], "wx:image-snip%::load-file");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:image-snip%::load-file");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:image-snip%::load-file");
+  } else
+    x3 = TRUE;
+
+  
+  ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->LoadFile(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipAdmin(p[0], "wx:image-snip%::set-admin", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::SetAdmin(x0);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:image-snip%::resize");
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Resize(x0, x1);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:image-snip%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Write(*x0);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipMatch(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:image-snip%::match?", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Match(x0);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Match(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:image-snip%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:image-snip%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::DoFont(x0, x1);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:image-snip%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:image-snip%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:image-snip%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::DoEdit(x0, x1, x2);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:image-snip%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::OwnCaret(x0);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::adjust-cursor", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::adjust-cursor");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::adjust-cursor");
+  x3 = objscheme_unbundle_float(p[3], "wx:image-snip%::adjust-cursor");
+  x4 = objscheme_unbundle_float(p[4], "wx:image-snip%::adjust-cursor");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:image-snip%::adjust-cursor", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::adjust-cursor");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::AdjustCursor(x0, x1, x2, x3, x4, *x5);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxKeyEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::on-char", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::on-char");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::on-char");
+  x3 = objscheme_unbundle_float(p[3], "wx:image-snip%::on-char");
+  x4 = objscheme_unbundle_float(p[4], "wx:image-snip%::on-char");
+  x5 = objscheme_unbundle_wxKeyEvent(p[5], "wx:image-snip%::on-char", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-char");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::OnChar(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->OnChar(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::on-event", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::on-event");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::on-event");
+  x3 = objscheme_unbundle_float(p[3], "wx:image-snip%::on-event");
+  x4 = objscheme_unbundle_float(p[4], "wx:image-snip%::on-event");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:image-snip%::on-event", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-event");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::OnEvent(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::SizeCacheInvalid();
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Copy();
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  long _x3;
+  long* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:image-snip%::get-text");
+  x1 = objscheme_unbundle_integer(p[1], "wx:image-snip%::get-text");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:image-snip%::get-text");
+  } else
+    x2 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::GetText(x0, x1, x2, x3);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_sized_string(r, _x3, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipMergeWith(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:image-snip%::merge-with", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::MergeWith(x0);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->MergeWith(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipSplit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxSnip* _x1;
+  class wxSnip** x1 = &_x1;
+  class wxSnip* _x2;
+  class wxSnip** x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:image-snip%::split");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:image-snip%::split", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:image-snip%::split"), "wx:image-snip%::split", 0);
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:image-snip%::split", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:image-snip%::split"), "wx:image-snip%::split", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Split(x0, x1, x2);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Split(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], objscheme_bundle_wxSnip(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], objscheme_bundle_wxSnip(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipDraw(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  float x8;
+  int x9;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::draw", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::draw");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::draw");
+  x3 = objscheme_unbundle_float(p[3], "wx:image-snip%::draw");
+  x4 = objscheme_unbundle_float(p[4], "wx:image-snip%::draw");
+  x5 = objscheme_unbundle_float(p[5], "wx:image-snip%::draw");
+  x6 = objscheme_unbundle_float(p[6], "wx:image-snip%::draw");
+  x7 = objscheme_unbundle_float(p[7], "wx:image-snip%::draw");
+  x8 = objscheme_unbundle_float(p[8], "wx:image-snip%::draw");
+  x9 = objscheme_unbundle_integer(p[9], "wx:image-snip%::draw");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::draw");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipPartialOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  long x3;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::partial-offset", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::partial-offset");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::partial-offset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:image-snip%::partial-offset");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::partial-offset");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::PartialOffset(x0, x1, x2, x3);
+  else
+    r = ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->PartialOffset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnipGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  float _x5;
+  float* x5 = &_x5;
+  float _x6;
+  float* x6 = &_x6;
+  float _x7;
+  float* x7 = &_x7;
+  float _x8;
+  float* x8 = &_x8;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:image-snip%::get-extent", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:image-snip%::get-extent");
+  x2 = objscheme_unbundle_float(p[2], "wx:image-snip%::get-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    if (SCHEME_NULLP(p[5]))
+    x5 = NULL;
+  else
+    *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    if (SCHEME_NULLP(p[6]))
+    x6 = NULL;
+  else
+    *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    if (SCHEME_NULLP(p[7]))
+    x7 = NULL;
+  else
+    *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x7 = NULL;
+  if (n > 8) {
+    if (SCHEME_NULLP(p[8]))
+    x8 = NULL;
+  else
+    *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:image-snip%::get-extent"), "wx:image-snip%::get-extent");
+  } else
+    x8 = NULL;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::get-extent");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->wxImageSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxImageSnip *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  if (n > 5 && !SCHEME_NULLP(p[5]))
+    objscheme_set_box(p[5], scheme_make_double(_x5));
+  if (n > 6 && !SCHEME_NULLP(p[6]))
+    objscheme_set_box(p[6], scheme_make_double(_x6));
+  if (n > 7 && !SCHEME_NULLP(p[7]))
+    objscheme_set_box(p[7], scheme_make_double(_x7));
+  if (n > 8 && !SCHEME_NULLP(p[8]))
+    objscheme_set_box(p[8], scheme_make_double(_x8));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxImageSnip_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxImageSnip *realobj;
+  nstring x0;
+  long x1;
+  Bool x2;
+  Bool x3;
+
+  
+  if ((n > 4)) 
+    scheme_wrong_count("wx:image-snip%::initialization", 0, 4, n, p);
+  if (n > 0) {
+    x0 = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:image-snip%::initialization");
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:image-snip%::initialization");
+  } else
+    x1 = 0;
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:image-snip%::initialization");
+  } else
+    x2 = FALSE;
+  if (n > 3) {
+    x3 = objscheme_unbundle_bool(p[3], "wx:image-snip%::initialization");
+  } else
+    x3 = TRUE;
+
+  
+  realobj = new os_wxImageSnip(obj, x0, x1, x2, x3);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxImageSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:image-snip%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:image-snip%");
+}
+
+void objscheme_setup_wxImageSnip(void *env)
+{
+if (os_wxImageSnip_class) {
+    objscheme_add_global_class(os_wxImageSnip_class,  "wx:image-snip%", env);
+} else {
+  os_wxImageSnip_class = objscheme_def_prim_class(env, "wx:image-snip%", "wx:snip%", os_wxImageSnip_ConstructScheme, 24);
+
+  scheme_add_method_w_arity(os_wxImageSnip_class,"get-class-name",objscheme_classname_os_wxImageSnip, 0, 0);
+
+ scheme_add_method_w_arity(os_wxImageSnip_class, "set-offset", os_wxImageSnipSetOffset, 2, 2);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "set-bitmap", os_wxImageSnipSetBitmap, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "get-filetype", os_wxImageSnipGetFiletype, 0, 0);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "get-filename", os_wxImageSnipGetFilename, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "load-file", os_wxImageSnipLoadFile, 2, 4);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "set-admin", os_wxImageSnipSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "resize", os_wxImageSnipResize, 2, 2);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "write", os_wxImageSnipWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "match?", os_wxImageSnipMatch, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "do-font", os_wxImageSnipDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "do-edit", os_wxImageSnipDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "own-caret", os_wxImageSnipOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "adjust-cursor", os_wxImageSnipAdjustCursor, 6, 6);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "on-char", os_wxImageSnipOnChar, 6, 6);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "on-event", os_wxImageSnipOnEvent, 6, 6);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "size-cache-invalid", os_wxImageSnipSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "copy", os_wxImageSnipCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "get-text", os_wxImageSnipGetText, 2, 3);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "merge-with", os_wxImageSnipMergeWith, 1, 1);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "split", os_wxImageSnipSplit, 3, 3);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "draw", os_wxImageSnipDraw, 10, 10);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "partial-offset", os_wxImageSnipPartialOffset, 4, 4);
+ scheme_add_method_w_arity(os_wxImageSnip_class, "get-extent", os_wxImageSnipGetExtent, 3, 9);
+
+
+  scheme_made_class(os_wxImageSnip_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxImageSnip, wxTYPE_IMAGE_SNIP);
+
+}
+}
+
+int objscheme_istype_wxImageSnip(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxImageSnip_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:image-snip%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxImageSnip(class wxImageSnip *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_IMAGE_SNIP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxImageSnip_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxImageSnip *objscheme_unbundle_wxImageSnip(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxImageSnip(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxImageSnip *)o->primdata;
+  else
+    return (wxImageSnip *)o->primdata;
+}
+
+
+
+#define Get_This_Media GetThisMedia
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxMediaSnip : public wxMediaSnip {
+ public:
+
+  os_wxMediaSnip(Scheme_Object * obj, class wxMediaBuffer* x0 = NULL, Bool x1 = TRUE, int x2 = wxMSNIPBOX_XMARGIN, int x3 = wxMSNIPBOX_YMARGIN, int x4 = wxMSNIPBOX_XMARGIN, int x5 = wxMSNIPBOX_YMARGIN, int x6 = wxMSNIPBOX_XINSET, int x7 = wxMSNIPBOX_YINSET, int x8 = wxMSNIPBOX_XINSET, int x9 = wxMSNIPBOX_YINSET, int x10 = -1, int x11 = -1, int x12 = -1, int x13 = -1);
+  ~os_wxMediaSnip();
+  void SetAdmin(class wxSnipAdmin* x0);
+  Bool Resize(float x0, float x1);
+  void Write(class wxMediaStreamOut& x0);
+  Bool Match(class wxSnip* x0);
+  void DoFont(int x0, Bool x1 = TRUE);
+  void DoEdit(int x0, Bool x1 = TRUE, long x2 = 0);
+  void OwnCaret(Bool x0);
+  class wxCursor* AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5);
+  void OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5);
+  void SizeCacheInvalid();
+  class wxSnip* Copy();
+  string GetText(long x0, long x1, Bool x2 = FALSE, long* x3 = NULL);
+  class wxSnip* MergeWith(class wxSnip* x0);
+  void Split(long x0, class wxSnip** x1, class wxSnip** x2);
+  void Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9);
+  float PartialOffset(class wxDC* x0, float x1, float x2, long x3);
+  void GetExtent(class wxDC* x0, float x1, float x2, float* x3 = NULL, float* x4 = NULL, float* x5 = NULL, float* x6 = NULL, float* x7 = NULL, float* x8 = NULL);
+};
+
+Scheme_Object *os_wxMediaSnip_class;
+
+os_wxMediaSnip::os_wxMediaSnip(Scheme_Object * o, class wxMediaBuffer* x0, Bool x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9, int x10, int x11, int x12, int x13)
+: wxMediaSnip(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMediaSnip::~os_wxMediaSnip()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMediaSnip::SetAdmin(class wxSnipAdmin* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "set-admin", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::SetAdmin(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnipAdmin(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaSnip::Resize(float x0, float x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "resize", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::Resize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_double(x0);
+  p[1] = scheme_make_double(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-snip%::resize"", extracting return value");
+  }
+}
+
+void os_wxMediaSnip::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::Write(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxMediaSnip::Match(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "match?", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::Match(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:media-snip%::match?"", extracting return value");
+  }
+}
+
+void os_wxMediaSnip::DoFont(int x0, Bool x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "do-font", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::DoFont(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaSnip::DoEdit(int x0, Bool x1, long x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "do-edit", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::DoEdit(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = (x1 ? scheme_true : scheme_false);
+  p[2] = scheme_make_integer(x2);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaSnip::OwnCaret(Bool x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "own-caret", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::OwnCaret(x0);
+  } else {
+  
+  p[0] = (x0 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxCursor* os_wxMediaSnip::AdjustCursor(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "adjust-cursor", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::AdjustCursor(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxCursor(v, "wx:media-snip%::adjust-cursor"", extracting return value", 1);
+  }
+}
+
+void os_wxMediaSnip::OnChar(class wxDC* x0, float x1, float x2, float x3, float x4, class wxKeyEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::OnChar(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxKeyEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaSnip::OnEvent(class wxDC* x0, float x1, float x2, float x3, float x4, class wxMouseEvent& x5)
+{
+  Scheme_Object *p[6];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::OnEvent(x0, x1, x2, x3, x4, x5);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = objscheme_bundle_wxMouseEvent(&x5);
+  
+
+  v = scheme_apply(method, 6, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaSnip::SizeCacheInvalid()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "size-cache-invalid", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::SizeCacheInvalid();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+class wxSnip* os_wxMediaSnip::Copy()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "copy", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::Copy();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:media-snip%::copy"", extracting return value", 0);
+  }
+}
+
+string os_wxMediaSnip::GetText(long x0, long x1, Bool x2, long* x3)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "get-text", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::GetText(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  p[2] = (x2 ? scheme_true : scheme_false);
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return (string)objscheme_unbundle_string(v, "wx:media-snip%::get-text"", extracting return value");
+  }
+}
+
+class wxSnip* os_wxMediaSnip::MergeWith(class wxSnip* x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "merge-with", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::MergeWith(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxSnip(x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxSnip(v, "wx:media-snip%::merge-with"", extracting return value", 0);
+  }
+}
+
+void os_wxMediaSnip::Split(long x0, class wxSnip** x1, class wxSnip** x2)
+{
+  Scheme_Object *p[3];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "split", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::Split(x0, x1, x2);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = objscheme_box(objscheme_bundle_wxSnip((*x1)));
+  p[2] = objscheme_box(objscheme_bundle_wxSnip((*x2)));
+  
+
+  v = scheme_apply(method, 3, p);
+  
+  if (x1) *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:media-snip%::split"", extracting return value via box"), "wx:media-snip%::split"", extracting return value via box", 0);
+  if (x2) *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:media-snip%::split"", extracting return value via box"), "wx:media-snip%::split"", extracting return value via box", 0);
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxMediaSnip::Draw(class wxDC* x0, float x1, float x2, float x3, float x4, float x5, float x6, float x7, float x8, int x9)
+{
+  Scheme_Object *p[10];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "draw", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_double(x3);
+  p[4] = scheme_make_double(x4);
+  p[5] = scheme_make_double(x5);
+  p[6] = scheme_make_double(x6);
+  p[7] = scheme_make_double(x7);
+  p[8] = scheme_make_double(x8);
+  p[9] = scheme_make_integer(x9);
+  
+
+  v = scheme_apply(method, 10, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+float os_wxMediaSnip::PartialOffset(class wxDC* x0, float x1, float x2, long x3)
+{
+  Scheme_Object *p[4];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "partial-offset", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return wxMediaSnip::PartialOffset(x0, x1, x2, x3);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = scheme_make_integer(x3);
+  
+
+  v = scheme_apply(method, 4, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_float(v, "wx:media-snip%::partial-offset"", extracting return value");
+  }
+}
+
+void os_wxMediaSnip::GetExtent(class wxDC* x0, float x1, float x2, float* x3, float* x4, float* x5, float* x6, float* x7, float* x8)
+{
+  Scheme_Object *p[9];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMediaSnip_class, "get-extent", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMediaSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  } else {
+  
+  p[0] = objscheme_bundle_wxDC(x0);
+  p[1] = scheme_make_double(x1);
+  p[2] = scheme_make_double(x2);
+  p[3] = ((x3) ? objscheme_box(scheme_make_double((*x3))) : scheme_null);
+  p[4] = ((x4) ? objscheme_box(scheme_make_double((*x4))) : scheme_null);
+  p[5] = ((x5) ? objscheme_box(scheme_make_double((*x5))) : scheme_null);
+  p[6] = ((x6) ? objscheme_box(scheme_make_double((*x6))) : scheme_null);
+  p[7] = ((x7) ? objscheme_box(scheme_make_double((*x7))) : scheme_null);
+  p[8] = ((x8) ? objscheme_box(scheme_make_double((*x8))) : scheme_null);
+  
+
+  v = scheme_apply(method, 9, p);
+  
+  if (x3) *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  if (x4) *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  if (x5) *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  if (x6) *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  if (x7) *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  if (x8) *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:media-snip%::get-extent"", extracting return value via box"), "wx:media-snip%::get-extent"", extracting return value via box");
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetInset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+  int _x2;
+  int* x2 = &_x2;
+  int _x3;
+  int* x3 = &_x3;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-snip%::get-inset", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-snip%::get-inset"), "wx:media-snip%::get-inset");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-snip%::get-inset", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-snip%::get-inset"), "wx:media-snip%::get-inset");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-snip%::get-inset", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:media-snip%::get-inset"), "wx:media-snip%::get-inset");
+  if (SCHEME_NULLP(p[3]))
+    scheme_wrong_type("wx:media-snip%::get-inset", "non-null", (3 - 0), n, p);
+  else
+    *x3 = objscheme_unbundle_integer(objscheme_unbox(p[3], "wx:media-snip%::get-inset"), "wx:media-snip%::get-inset");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetInset(x0, x1, x2, x3);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  if (n > 3)
+    objscheme_set_box(p[3], scheme_make_integer(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetInset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+  int x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::set-inset");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-snip%::set-inset");
+  x2 = objscheme_unbundle_integer(p[2], "wx:media-snip%::set-inset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:media-snip%::set-inset");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetInset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetMargin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+  int _x2;
+  int* x2 = &_x2;
+  int _x3;
+  int* x3 = &_x3;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:media-snip%::get-margin", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:media-snip%::get-margin"), "wx:media-snip%::get-margin");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-snip%::get-margin", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:media-snip%::get-margin"), "wx:media-snip%::get-margin");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-snip%::get-margin", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:media-snip%::get-margin"), "wx:media-snip%::get-margin");
+  if (SCHEME_NULLP(p[3]))
+    scheme_wrong_type("wx:media-snip%::get-margin", "non-null", (3 - 0), n, p);
+  else
+    *x3 = objscheme_unbundle_integer(objscheme_unbox(p[3], "wx:media-snip%::get-margin"), "wx:media-snip%::get-margin");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetMargin(x0, x1, x2, x3);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  if (n > 3)
+    objscheme_set_box(p[3], scheme_make_integer(_x3));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMargin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+  int x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::set-margin");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-snip%::set-margin");
+  x2 = objscheme_unbundle_integer(p[2], "wx:media-snip%::set-margin");
+  x3 = objscheme_unbundle_integer(p[3], "wx:media-snip%::set-margin");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMargin(x0, x1, x2, x3);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipBorderVisible(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->BorderVisible();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipShowBorder(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-snip%::show-border");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->ShowBorder(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetMinHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetMinHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetMinWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetMinWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMinHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-snip%::set-min-height");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMinHeight(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMinWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-snip%::set-min-width");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMinWidth(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetMaxHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetMaxHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetMaxWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetMaxWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMaxHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-snip%::set-max-height");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMaxHeight(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMaxWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-snip%::set-max-width");
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMaxWidth(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetAdmin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxSnipAdmin* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnipAdmin(p[0], "wx:media-snip%::set-admin", 1);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::SetAdmin(x0);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetAdmin(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipResize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:media-snip%::resize");
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::resize");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Resize(x0, x1);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Resize(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:media-snip%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Write(*x0);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipMatch(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-snip%::match?", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Match(x0);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Match(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipDoFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::do-font");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-snip%::do-font");
+  } else
+    x1 = TRUE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::DoFont(x0, x1);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->DoFont(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipDoEdit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  Bool x1;
+  long x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::do-edit");
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-snip%::do-edit");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-snip%::do-edit");
+  } else
+    x2 = 0;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::DoEdit(x0, x1, x2);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->DoEdit(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipOwnCaret(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:media-snip%::own-caret");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::OwnCaret(x0);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->OwnCaret(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipAdjustCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::adjust-cursor", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::adjust-cursor");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::adjust-cursor");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-snip%::adjust-cursor");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-snip%::adjust-cursor");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:media-snip%::adjust-cursor", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::adjust-cursor");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::AdjustCursor(x0, x1, x2, x3, x4, *x5);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->AdjustCursor(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxKeyEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::on-char", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::on-char");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::on-char");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-snip%::on-char");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-snip%::on-char");
+  x5 = objscheme_unbundle_wxKeyEvent(p[5], "wx:media-snip%::on-char", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-char");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::OnChar(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->OnChar(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  class wxMouseEvent* x5;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::on-event", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::on-event");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::on-event");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-snip%::on-event");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-snip%::on-event");
+  x5 = objscheme_unbundle_wxMouseEvent(p[5], "wx:media-snip%::on-event", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::on-event");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::OnEvent(x0, x1, x2, x3, x4, *x5);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->OnEvent(x0, x1, x2, x3, x4, *x5);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSizeCacheInvalid(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::SizeCacheInvalid();
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SizeCacheInvalid();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Copy();
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  Bool x2;
+  long _x3;
+  long* x3 = &_x3;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::get-text");
+  x1 = objscheme_unbundle_integer(p[1], "wx:media-snip%::get-text");
+  if (n > 2) {
+    x2 = objscheme_unbundle_bool(p[2], "wx:media-snip%::get-text");
+  } else
+    x2 = FALSE;
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::GetText(x0, x1, x2, x3);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetText(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_sized_string(r, _x3, 0);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipMergeWith(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxSnip* r;
+  objscheme_check_valid(obj);
+  class wxSnip* x0;
+
+  
+  x0 = objscheme_unbundle_wxSnip(p[0], "wx:media-snip%::merge-with", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::MergeWith(x0);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->MergeWith(x0);
+
+  
+  
+  return objscheme_bundle_wxSnip(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSplit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  class wxSnip* _x1;
+  class wxSnip** x1 = &_x1;
+  class wxSnip* _x2;
+  class wxSnip** x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:media-snip%::split");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:media-snip%::split", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_wxSnip(objscheme_unbox(p[1], "wx:media-snip%::split"), "wx:media-snip%::split", 0);
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:media-snip%::split", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_wxSnip(objscheme_unbox(p[2], "wx:media-snip%::split"), "wx:media-snip%::split", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Split(x0, x1, x2);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Split(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], objscheme_bundle_wxSnip(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], objscheme_bundle_wxSnip(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipDraw(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float x3;
+  float x4;
+  float x5;
+  float x6;
+  float x7;
+  float x8;
+  int x9;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::draw", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::draw");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::draw");
+  x3 = objscheme_unbundle_float(p[3], "wx:media-snip%::draw");
+  x4 = objscheme_unbundle_float(p[4], "wx:media-snip%::draw");
+  x5 = objscheme_unbundle_float(p[5], "wx:media-snip%::draw");
+  x6 = objscheme_unbundle_float(p[6], "wx:media-snip%::draw");
+  x7 = objscheme_unbundle_float(p[7], "wx:media-snip%::draw");
+  x8 = objscheme_unbundle_float(p[8], "wx:media-snip%::draw");
+  x9 = objscheme_unbundle_integer(p[9], "wx:media-snip%::draw");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::draw");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Draw(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipPartialOffset(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  long x3;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::partial-offset", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::partial-offset");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::partial-offset");
+  x3 = objscheme_unbundle_integer(p[3], "wx:media-snip%::partial-offset");
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::partial-offset");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::PartialOffset(x0, x1, x2, x3);
+  else
+    r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->PartialOffset(x0, x1, x2, x3);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  float x1;
+  float x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  float _x5;
+  float* x5 = &_x5;
+  float _x6;
+  float* x6 = &_x6;
+  float _x7;
+  float* x7 = &_x7;
+  float _x8;
+  float* x8 = &_x8;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:media-snip%::get-extent", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:media-snip%::get-extent");
+  x2 = objscheme_unbundle_float(p[2], "wx:media-snip%::get-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    if (SCHEME_NULLP(p[5]))
+    x5 = NULL;
+  else
+    *x5 = objscheme_unbundle_float(objscheme_unbox(p[5], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    if (SCHEME_NULLP(p[6]))
+    x6 = NULL;
+  else
+    *x6 = objscheme_unbundle_float(objscheme_unbox(p[6], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x6 = NULL;
+  if (n > 7) {
+    if (SCHEME_NULLP(p[7]))
+    x7 = NULL;
+  else
+    *x7 = objscheme_unbundle_float(objscheme_unbox(p[7], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x7 = NULL;
+  if (n > 8) {
+    if (SCHEME_NULLP(p[8]))
+    x8 = NULL;
+  else
+    *x8 = objscheme_unbundle_float(objscheme_unbox(p[8], "wx:media-snip%::get-extent"), "wx:media-snip%::get-extent");
+  } else
+    x8 = NULL;
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:snip%::get-extent");
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->wxMediaSnip::GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+  else
+    ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetExtent(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+
+  
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  if (n > 5 && !SCHEME_NULLP(p[5]))
+    objscheme_set_box(p[5], scheme_make_double(_x5));
+  if (n > 6 && !SCHEME_NULLP(p[6]))
+    objscheme_set_box(p[6], scheme_make_double(_x6));
+  if (n > 7 && !SCHEME_NULLP(p[7]))
+    objscheme_set_box(p[7], scheme_make_double(_x7));
+  if (n > 8 && !SCHEME_NULLP(p[8]))
+    objscheme_set_box(p[8], scheme_make_double(_x8));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipSetMedia(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxMediaBuffer* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaBuffer(p[0], "wx:media-snip%::set-media", 1);
+
+  
+  ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->SetMedia(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGetThisMedia(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaBuffer* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->GetThisMedia();
+
+  
+  
+  return objscheme_bundle_wxMediaBuffer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnipGet_This_Media(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxMediaBuffer* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMediaSnip *)((Scheme_Class_Object *)obj)->primdata)->Get_This_Media();
+
+  
+  
+  return objscheme_bundle_wxMediaBuffer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMediaSnip_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMediaSnip *realobj;
+  class wxMediaBuffer* x0;
+  Bool x1;
+  int x2;
+  int x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  int x8;
+  int x9;
+  int x10;
+  int x11;
+  int x12;
+  int x13;
+
+  
+  if ((n > 14)) 
+    scheme_wrong_count("wx:media-snip%::initialization", 0, 14, n, p);
+  if (n > 0) {
+    x0 = objscheme_unbundle_wxMediaBuffer(p[0], "wx:media-snip%::initialization", 1);
+  } else
+    x0 = NULL;
+  if (n > 1) {
+    x1 = objscheme_unbundle_bool(p[1], "wx:media-snip%::initialization");
+  } else
+    x1 = TRUE;
+  if (n > 2) {
+    x2 = objscheme_unbundle_integer(p[2], "wx:media-snip%::initialization");
+  } else
+    x2 = wxMSNIPBOX_XMARGIN;
+  if (n > 3) {
+    x3 = objscheme_unbundle_integer(p[3], "wx:media-snip%::initialization");
+  } else
+    x3 = wxMSNIPBOX_YMARGIN;
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:media-snip%::initialization");
+  } else
+    x4 = wxMSNIPBOX_XMARGIN;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:media-snip%::initialization");
+  } else
+    x5 = wxMSNIPBOX_YMARGIN;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:media-snip%::initialization");
+  } else
+    x6 = wxMSNIPBOX_XINSET;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:media-snip%::initialization");
+  } else
+    x7 = wxMSNIPBOX_YINSET;
+  if (n > 8) {
+    x8 = objscheme_unbundle_integer(p[8], "wx:media-snip%::initialization");
+  } else
+    x8 = wxMSNIPBOX_XINSET;
+  if (n > 9) {
+    x9 = objscheme_unbundle_integer(p[9], "wx:media-snip%::initialization");
+  } else
+    x9 = wxMSNIPBOX_YINSET;
+  if (n > 10) {
+    x10 = objscheme_unbundle_integer(p[10], "wx:media-snip%::initialization");
+  } else
+    x10 = -1;
+  if (n > 11) {
+    x11 = objscheme_unbundle_integer(p[11], "wx:media-snip%::initialization");
+  } else
+    x11 = -1;
+  if (n > 12) {
+    x12 = objscheme_unbundle_integer(p[12], "wx:media-snip%::initialization");
+  } else
+    x12 = -1;
+  if (n > 13) {
+    x13 = objscheme_unbundle_integer(p[13], "wx:media-snip%::initialization");
+  } else
+    x13 = -1;
+
+  
+  realobj = new os_wxMediaSnip(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMediaSnip(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:media-snip%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:media-snip%");
+}
+
+void objscheme_setup_wxMediaSnip(void *env)
+{
+if (os_wxMediaSnip_class) {
+    objscheme_add_global_class(os_wxMediaSnip_class,  "wx:media-snip%", env);
+} else {
+  os_wxMediaSnip_class = objscheme_def_prim_class(env, "wx:media-snip%", "wx:snip%", os_wxMediaSnip_ConstructScheme, 36);
+
+  scheme_add_method_w_arity(os_wxMediaSnip_class,"get-class-name",objscheme_classname_os_wxMediaSnip, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-inset", os_wxMediaSnipGetInset, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-inset", os_wxMediaSnipSetInset, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-margin", os_wxMediaSnipGetMargin, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-margin", os_wxMediaSnipSetMargin, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "border-visible?", os_wxMediaSnipBorderVisible, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "show-border", os_wxMediaSnipShowBorder, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-min-height", os_wxMediaSnipGetMinHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-min-width", os_wxMediaSnipGetMinWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-min-height", os_wxMediaSnipSetMinHeight, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-min-width", os_wxMediaSnipSetMinWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-max-height", os_wxMediaSnipGetMaxHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-max-width", os_wxMediaSnipGetMaxWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-max-height", os_wxMediaSnipSetMaxHeight, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-max-width", os_wxMediaSnipSetMaxWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-admin", os_wxMediaSnipSetAdmin, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "resize", os_wxMediaSnipResize, 2, 2);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "write", os_wxMediaSnipWrite, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "match?", os_wxMediaSnipMatch, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "do-font", os_wxMediaSnipDoFont, 1, 2);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "do-edit", os_wxMediaSnipDoEdit, 1, 3);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "own-caret", os_wxMediaSnipOwnCaret, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "adjust-cursor", os_wxMediaSnipAdjustCursor, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "on-char", os_wxMediaSnipOnChar, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "on-event", os_wxMediaSnipOnEvent, 6, 6);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "size-cache-invalid", os_wxMediaSnipSizeCacheInvalid, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "copy", os_wxMediaSnipCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-text", os_wxMediaSnipGetText, 2, 3);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "merge-with", os_wxMediaSnipMergeWith, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "split", os_wxMediaSnipSplit, 3, 3);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "draw", os_wxMediaSnipDraw, 10, 10);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "partial-offset", os_wxMediaSnipPartialOffset, 4, 4);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-extent", os_wxMediaSnipGetExtent, 3, 9);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "set-media", os_wxMediaSnipSetMedia, 1, 1);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-media", os_wxMediaSnipGetThisMedia, 0, 0);
+ scheme_add_method_w_arity(os_wxMediaSnip_class, "get-this-media", os_wxMediaSnipGet_This_Media, 0, 0);
+
+
+  scheme_made_class(os_wxMediaSnip_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMediaSnip, wxTYPE_MEDIA_SNIP);
+
+}
+  scheme_install_xc_global("wx:const-msnipbox-xmargin", scheme_make_integer(wxMSNIPBOX_XMARGIN), env);
+  scheme_install_xc_global("wx:const-msnipbox-ymargin", scheme_make_integer(wxMSNIPBOX_YMARGIN), env);
+  scheme_install_xc_global("wx:const-msnipbox-xinset", scheme_make_integer(wxMSNIPBOX_XINSET), env);
+  scheme_install_xc_global("wx:const-msnipbox-yinset", scheme_make_integer(wxMSNIPBOX_YINSET), env);
+}
+
+int objscheme_istype_wxMediaSnip(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMediaSnip_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:media-snip%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMediaSnip(class wxMediaSnip *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MEDIA_SNIP) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMediaSnip_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMediaSnip *objscheme_unbundle_wxMediaSnip(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMediaSnip(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMediaSnip *)o->primdata;
+  else
+    return (wxMediaSnip *)o->primdata;
+}
+
+
+
+
+
+
+
+
+class os_wxBufferDataClass : public wxBufferDataClass {
+ public:
+
+  os_wxBufferDataClass(Scheme_Object * obj);
+  ~os_wxBufferDataClass();
+  class wxBufferData* Read(class wxMediaStreamIn& x0);
+};
+
+Scheme_Object *os_wxBufferDataClass_class;
+
+os_wxBufferDataClass::os_wxBufferDataClass(Scheme_Object * o)
+: wxBufferDataClass()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBufferDataClass::~os_wxBufferDataClass()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+class wxBufferData* os_wxBufferDataClass::Read(class wxMediaStreamIn& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxBufferDataClass_class, "read", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return NULL;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamIn(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_wxBufferData(v, "wx:buffer-data-class%::read"", extracting return value", 1);
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassRead(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferData* r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamIn* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamIn(p[0], "wx:buffer-data-class%::read", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxBufferDataClass *)((Scheme_Class_Object *)obj)->primdata)->Read(*x0);
+  else
+    r = ((wxBufferDataClass *)((Scheme_Class_Object *)obj)->primdata)->Read(*x0);
+
+  
+  
+  return objscheme_bundle_wxBufferData(r);
+}
+
+static Scheme_Object *objscheme_wxBufferDataClass_Getclassname(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  string v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-classname", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxBufferDataClass *)cobj->primdata)->wxBufferDataClass::classname;
+  else
+    v = ((wxBufferDataClass *)cobj->primdata)->classname;
+
+  return objscheme_bundle_string((char *)v);
+}
+
+static Scheme_Object *objscheme_wxBufferDataClass_Setclassname(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  string v;
+
+  if (n != 1) scheme_wrong_count("set-classname", 1, 1, n, p);
+
+  v = (string)objscheme_unbundle_string(p[0], "wx:buffer-data-class%::classname");
+  ((wxBufferDataClass *)cobj->primdata)->classname = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxBufferDataClass_Getrequired(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-required", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxBufferDataClass *)cobj->primdata)->wxBufferDataClass::required;
+  else
+    v = ((wxBufferDataClass *)cobj->primdata)->required;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxBufferDataClass_Setrequired(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-required", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:buffer-data-class%::required");
+  ((wxBufferDataClass *)cobj->primdata)->required = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClass_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBufferDataClass *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:buffer-data-class%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxBufferDataClass(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBufferDataClass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:buffer-data-class%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:buffer-data-class%");
+}
+
+void objscheme_setup_wxBufferDataClass(void *env)
+{
+if (os_wxBufferDataClass_class) {
+    objscheme_add_global_class(os_wxBufferDataClass_class,  "wx:buffer-data-class%", env);
+} else {
+  os_wxBufferDataClass_class = objscheme_def_prim_class(env, "wx:buffer-data-class%", "wx:object%", os_wxBufferDataClass_ConstructScheme, 6);
+
+  scheme_add_method_w_arity(os_wxBufferDataClass_class,"get-class-name",objscheme_classname_os_wxBufferDataClass, 0, 0);
+
+ scheme_add_method_w_arity(os_wxBufferDataClass_class, "read", os_wxBufferDataClassRead, 1, 1);
+
+  scheme_add_method_w_arity(os_wxBufferDataClass_class,"get-classname", objscheme_wxBufferDataClass_Getclassname, 0, 0);
+  scheme_add_method_w_arity(os_wxBufferDataClass_class,"set-classname", objscheme_wxBufferDataClass_Setclassname, 1, 1);
+  scheme_add_method_w_arity(os_wxBufferDataClass_class,"get-required", objscheme_wxBufferDataClass_Getrequired, 0, 0);
+  scheme_add_method_w_arity(os_wxBufferDataClass_class,"set-required", objscheme_wxBufferDataClass_Setrequired, 1, 1);
+
+  scheme_made_class(os_wxBufferDataClass_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxBufferDataClass, wxTYPE_BUFFER_DATA_CLASS);
+
+}
+}
+
+int objscheme_istype_wxBufferDataClass(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBufferDataClass_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:buffer-data-class%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBufferDataClass(class wxBufferDataClass *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_BUFFER_DATA_CLASS) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBufferDataClass_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBufferDataClass *objscheme_unbundle_wxBufferDataClass(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBufferDataClass(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBufferDataClass *)o->primdata;
+  else
+    return (wxBufferDataClass *)o->primdata;
+}
+
+
+
+
+
+
+class os_wxBufferDataClassList : public wxBufferDataClassList {
+ public:
+
+  os_wxBufferDataClassList(Scheme_Object * obj);
+  ~os_wxBufferDataClassList();
+};
+
+Scheme_Object *os_wxBufferDataClassList_class;
+
+os_wxBufferDataClassList::os_wxBufferDataClassList(Scheme_Object * o)
+: wxBufferDataClassList()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBufferDataClassList::~os_wxBufferDataClassList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassListNth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferDataClass* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:buffer-data-class-list%::nth");
+
+  
+  r = ((wxBufferDataClassList *)((Scheme_Class_Object *)obj)->primdata)->Nth(x0);
+
+  
+  
+  return objscheme_bundle_wxBufferDataClass(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassListNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxBufferDataClassList *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassListAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxBufferDataClass* x0;
+
+  
+  x0 = objscheme_unbundle_wxBufferDataClass(p[0], "wx:buffer-data-class-list%::add", 0);
+
+  
+  ((wxBufferDataClassList *)((Scheme_Class_Object *)obj)->primdata)->Add(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassListFindPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  short r;
+  objscheme_check_valid(obj);
+  class wxBufferDataClass* x0;
+
+  
+  x0 = objscheme_unbundle_wxBufferDataClass(p[0], "wx:buffer-data-class-list%::find-position", 0);
+
+  
+  r = ((wxBufferDataClassList *)((Scheme_Class_Object *)obj)->primdata)->FindPosition(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassListFind(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxBufferDataClass* r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:buffer-data-class-list%::find");
+
+  
+  r = ((wxBufferDataClassList *)((Scheme_Class_Object *)obj)->primdata)->Find(x0);
+
+  
+  
+  return objscheme_bundle_wxBufferDataClass(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataClassList_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBufferDataClassList *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:buffer-data-class-list%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxBufferDataClassList(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBufferDataClassList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:buffer-data-class-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:buffer-data-class-list%");
+}
+
+void objscheme_setup_wxBufferDataClassList(void *env)
+{
+if (os_wxBufferDataClassList_class) {
+    objscheme_add_global_class(os_wxBufferDataClassList_class,  "wx:buffer-data-class-list%", env);
+} else {
+  os_wxBufferDataClassList_class = objscheme_def_prim_class(env, "wx:buffer-data-class-list%", "wx:object%", os_wxBufferDataClassList_ConstructScheme, 6);
+
+  scheme_add_method_w_arity(os_wxBufferDataClassList_class,"get-class-name",objscheme_classname_os_wxBufferDataClassList, 0, 0);
+
+ scheme_add_method_w_arity(os_wxBufferDataClassList_class, "nth", os_wxBufferDataClassListNth, 1, 1);
+ scheme_add_method_w_arity(os_wxBufferDataClassList_class, "number", os_wxBufferDataClassListNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxBufferDataClassList_class, "add", os_wxBufferDataClassListAdd, 1, 1);
+ scheme_add_method_w_arity(os_wxBufferDataClassList_class, "find-position", os_wxBufferDataClassListFindPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxBufferDataClassList_class, "find", os_wxBufferDataClassListFind, 1, 1);
+
+
+  scheme_made_class(os_wxBufferDataClassList_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxBufferDataClassList, wxTYPE_BUFFER_DATA_CLASS_LIST);
+
+}
+}
+
+int objscheme_istype_wxBufferDataClassList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBufferDataClassList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:buffer-data-class-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBufferDataClassList(class wxBufferDataClassList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_BUFFER_DATA_CLASS_LIST) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBufferDataClassList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBufferDataClassList *objscheme_unbundle_wxBufferDataClassList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBufferDataClassList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBufferDataClassList *)o->primdata;
+  else
+    return (wxBufferDataClassList *)o->primdata;
+}
+
+
+
+
+
+
+
+class os_wxBufferData : public wxBufferData {
+ public:
+
+  os_wxBufferData(Scheme_Object * obj);
+  ~os_wxBufferData();
+  Bool Write(class wxMediaStreamOut& x0);
+};
+
+Scheme_Object *os_wxBufferData_class;
+
+os_wxBufferData::os_wxBufferData(Scheme_Object * o)
+: wxBufferData()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxBufferData::~os_wxBufferData()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxBufferData::Write(class wxMediaStreamOut& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxBufferData_class, "write", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return 0;
+  } else {
+  
+  p[0] = objscheme_bundle_wxMediaStreamOut(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:buffer-data%::write"", extracting return value");
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferDataWrite(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMediaStreamOut* x0;
+
+  
+  x0 = objscheme_unbundle_wxMediaStreamOut(p[0], "wx:buffer-data%::write", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxBufferData *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+  else
+    r = ((wxBufferData *)((Scheme_Class_Object *)obj)->primdata)->Write(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxBufferData_Getdataclass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxBufferDataClass* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-dataclass", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxBufferData *)cobj->primdata)->wxBufferData::dataclass;
+  else
+    v = ((wxBufferData *)cobj->primdata)->dataclass;
+
+  return objscheme_bundle_wxBufferDataClass(v);
+}
+
+static Scheme_Object *objscheme_wxBufferData_Setdataclass(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  class wxBufferDataClass* v;
+
+  if (n != 1) scheme_wrong_count("set-dataclass", 1, 1, n, p);
+
+  v = objscheme_unbundle_wxBufferDataClass(p[0], "wx:buffer-data%::dataclass", 1);
+  ((wxBufferData *)cobj->primdata)->dataclass = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxBufferData_Getnext(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxBufferData* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-next", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxBufferData *)cobj->primdata)->wxBufferData::next;
+  else
+    v = ((wxBufferData *)cobj->primdata)->next;
+
+  return objscheme_bundle_wxBufferData(v);
+}
+
+static Scheme_Object *objscheme_wxBufferData_Setnext(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  class wxBufferData* v;
+
+  if (n != 1) scheme_wrong_count("set-next", 1, 1, n, p);
+
+  v = objscheme_unbundle_wxBufferData(p[0], "wx:buffer-data%::next", 1);
+  ((wxBufferData *)cobj->primdata)->next = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxBufferData_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxBufferData *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:buffer-data%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxBufferData(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxBufferData(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:buffer-data%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:buffer-data%");
+}
+
+void objscheme_setup_wxBufferData(void *env)
+{
+if (os_wxBufferData_class) {
+    objscheme_add_global_class(os_wxBufferData_class,  "wx:buffer-data%", env);
+} else {
+  os_wxBufferData_class = objscheme_def_prim_class(env, "wx:buffer-data%", "wx:object%", os_wxBufferData_ConstructScheme, 6);
+
+  scheme_add_method_w_arity(os_wxBufferData_class,"get-class-name",objscheme_classname_os_wxBufferData, 0, 0);
+
+ scheme_add_method_w_arity(os_wxBufferData_class, "write", os_wxBufferDataWrite, 1, 1);
+
+  scheme_add_method_w_arity(os_wxBufferData_class,"get-dataclass", objscheme_wxBufferData_Getdataclass, 0, 0);
+  scheme_add_method_w_arity(os_wxBufferData_class,"set-dataclass", objscheme_wxBufferData_Setdataclass, 1, 1);
+  scheme_add_method_w_arity(os_wxBufferData_class,"get-next", objscheme_wxBufferData_Getnext, 0, 0);
+  scheme_add_method_w_arity(os_wxBufferData_class,"set-next", objscheme_wxBufferData_Setnext, 1, 1);
+
+  scheme_made_class(os_wxBufferData_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxBufferData, wxTYPE_BUFFER_DATA);
+
+}
+}
+
+int objscheme_istype_wxBufferData(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxBufferData_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:buffer-data%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_BUFFER_DATA) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxBufferData_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxBufferData(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxBufferData *)o->primdata;
+  else
+    return (wxBufferData *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_snip.h b/src/mred/wxs/wxs_snip.h
new file mode 100644
index 0000000..3524345
--- /dev/null
+++ b/src/mred/wxs/wxs_snip.h
@@ -0,0 +1,277 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern Scheme_Object *objscheme_bundle_wxSnipClass(class wxSnipClass *);
+extern class wxSnipClass *objscheme_unbundle_wxSnipClass(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxSnip(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxSnip(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *realobj);
+class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxTextSnip(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxTextSnip(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxTextSnip(class wxTextSnip *realobj);
+class wxTextSnip *objscheme_unbundle_wxTextSnip(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxTabSnip(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxTabSnip(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxTabSnip(class wxTabSnip *realobj);
+class wxTabSnip *objscheme_unbundle_wxTabSnip(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxBitmap *objscheme_unbundle_wxBitmap(Scheme_Object *, const char *, int);
+extern class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxImageSnip(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxImageSnip(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxImageSnip(class wxImageSnip *realobj);
+class wxImageSnip *objscheme_unbundle_wxImageSnip(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxSnipAdmin(class wxSnipAdmin *);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern Scheme_Object *objscheme_bundle_wxDC(class wxDC *);
+extern class wxSnipAdmin *objscheme_unbundle_wxSnipAdmin(Scheme_Object *, const char *, int);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern class wxSnip *objscheme_unbundle_wxSnip(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern Scheme_Object *objscheme_bundle_wxSnip(class wxSnip *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *);
+extern Scheme_Object *objscheme_bundle_wxMediaBuffer(class wxMediaBuffer *);
+extern class wxMediaBuffer *objscheme_unbundle_wxMediaBuffer(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMediaSnip(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMediaSnip(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMediaSnip(class wxMediaSnip *realobj);
+class wxMediaSnip *objscheme_unbundle_wxMediaSnip(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamIn(class wxMediaStreamIn *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+extern class wxMediaStreamIn *objscheme_unbundle_wxMediaStreamIn(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+#endif
+void objscheme_setup_wxBufferDataClass(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxBufferDataClass(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBufferDataClass(class wxBufferDataClass *realobj);
+class wxBufferDataClass *objscheme_unbundle_wxBufferDataClass(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxBufferDataClass(class wxBufferDataClass *);
+extern class wxBufferDataClass *objscheme_unbundle_wxBufferDataClass(Scheme_Object *, const char *, int);
+extern class wxBufferDataClass *objscheme_unbundle_wxBufferDataClass(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferDataClass(class wxBufferDataClass *);
+#endif
+void objscheme_setup_wxBufferDataClassList(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxBufferDataClassList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBufferDataClassList(class wxBufferDataClassList *realobj);
+class wxBufferDataClassList *objscheme_unbundle_wxBufferDataClassList(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxMediaStreamOut(class wxMediaStreamOut *);
+extern class wxMediaStreamOut *objscheme_unbundle_wxMediaStreamOut(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferDataClass(class wxBufferDataClass *);
+extern class wxBufferDataClass *objscheme_unbundle_wxBufferDataClass(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *);
+extern class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxBufferData(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxBufferData(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxBufferData(class wxBufferData *realobj);
+class wxBufferData *objscheme_unbundle_wxBufferData(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_snip.xc b/src/mred/wxs/wxs_snip.xc
new file mode 100644
index 0000000..9d4a319
--- /dev/null
+++ b/src/mred/wxs/wxs_snip.xc
@@ -0,0 +1,182 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_media.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxSnip "wx:snip":"wx:object"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_SNIP
+
+@CONSTANT "wx:const-snip-can-append" : int wxSNIP_CAN_APPEND
+@CONSTANT "wx:const-snip-newline" : int wxSNIP_NEWLINE
+@CONSTANT "wx:const-snip-hard-newline" : int wxSNIP_HARD_NEWLINE
+@CONSTANT "wx:const-snip-is-text" : int wxSNIP_IS_TEXT
+@CONSTANT "wx:const-snip-invisible" : int wxSNIP_INVISIBLE
+@CONSTANT "wx:const-snip-handles-events" : int wxSNIP_HANDLES_EVENTS
+@CONSTANT "wx:const-snip-width-depends-on-x" : int wxSNIP_WIDTH_DEPENDS_ON_X
+@CONSTANT "wx:const-snip-height-depends-on-x" : int wxSNIP_HEIGHT_DEPENDS_ON_X
+@CONSTANT "wx:const-snip-width-depends-on-y" : int wxSNIP_WIDTH_DEPENDS_ON_Y
+@CONSTANT "wx:const-snip-height-depends-on-y" : int wxSNIP_HEIGHT_DEPENDS_ON_Y
+@CONSTANT "wx:const-snip-anchored" : int wxSNIP_ANCHORED
+@CONSTANT "wx:const-snip-uses-buffer-path" : int wxSNIP_USES_BUFFER_PATH
+
+@IVAR r "count" : long count
+@IVAR r "flags" : long flags
+@IVAR r "style" : wxStyle! style
+@IVAR "snipclass" : wxSnipClass^ snipclass
+
+@ "get-admin" : wxSnipAdmin! GetAdmin();
+
+@ "set-count" : void SetCount(long);
+@ "set-flags" : void SetFlags(long);
+
+@ "set-style" : void SetStyle(wxStyle!)
+
+@ "is-owned?" : bool IsOwned();
+@ "release-from-owner" : bool ReleaseFromOwner();
+
+@SETMARK s = v
+@INCLUDE wxs_snip.xci
+
+@ "next" : wxSnip^ Next();
+@ "previous" : wxSnip^ Previous();
+
+@END
+
+
+@CLASSBASE wxTextSnip "wx:text-snip":"wx:snip"
+
+@CREATOR (long=0);
+
+@CLASSID wxTYPE_TEXT_SNIP
+
+@SETMARK s = d
+@INCLUDE wxs_snip.xci
+
+@ "insert" : void Insert(string,long,long=0);
+@ "read" : void Read(long,wxMediaStreamIn%);
+
+@END
+
+
+@CLASSBASE wxTabSnip "wx:tab-snip":"wx:text-snip"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_TAB_SNIP
+
+@SETMARK s = d
+@INCLUDE wxs_snip.xci
+
+@END
+
+
+@CLASSBASE wxImageSnip "wx:image-snip":"wx:snip"
+
+@CREATOR (nstring=NULL,long=0,bool=FALSE,bool=TRUE);
+
+@CLASSID wxTYPE_IMAGE_SNIP
+
+@SETMARK s = d
+@INCLUDE wxs_snip.xci
+
+@ "load-file" : void LoadFile(nstring,long,bool=FALSE,bool=TRUE);
+
+@ "get-filename" : nstring GetFilename(bool?);
+@ "get-filetype" : long GetFiletype();
+
+@ "set-bitmap" : void SetBitmap(wxBitmap!);
+
+@ "set-offset" : void SetOffset(float, float);
+
+@END
+
+
+#define Get_This_Media GetThisMedia
+
+@CLASSBASE wxMediaSnip "wx:media-snip" : "wx:snip"
+
+@CREATOR (wxMediaBuffer^=NULL,bool=TRUE,int=wxMSNIPBOX_XMARGIN,int=wxMSNIPBOX_YMARGIN,int=wxMSNIPBOX_XMARGIN,int=wxMSNIPBOX_YMARGIN,int=wxMSNIPBOX_XINSET,int=wxMSNIPBOX_YINSET,int=wxMSNIPBOX_XINSET,int=wxMSNIPBOX_YINSET,int=-1,int=-1,int=-1,int=-1);
+
+@CLASSID wxTYPE_MEDIA_SNIP
+
+@ "get-this-media" : wxMediaBuffer^ Get_This_Media();
+@ "get-media" : wxMediaBuffer^ GetThisMedia();
+@ "set-media" : void SetMedia(wxMediaBuffer^);
+
+@CONSTANT "wx:const-msnipbox-xmargin" : int wxMSNIPBOX_XMARGIN
+@CONSTANT "wx:const-msnipbox-ymargin" : int wxMSNIPBOX_YMARGIN
+@CONSTANT "wx:const-msnipbox-xinset" : int wxMSNIPBOX_XINSET
+@CONSTANT "wx:const-msnipbox-yinset" : int wxMSNIPBOX_YINSET
+
+@SETMARK s = d
+@INCLUDE wxs_snip.xci
+
+@ "set-max-width" : void SetMaxWidth(float);
+@ "set-max-height" : void SetMaxHeight(float);
+@ "get-max-width" : float GetMaxWidth();
+@ "get-max-height" : float GetMaxHeight();
+@ "set-min-width" : void SetMinWidth(float);
+@ "set-min-height" : void SetMinHeight(float);
+@ "get-min-width" : float GetMinWidth();
+@ "get-min-height" : float GetMinHeight();
+
+@ "show-border" : void ShowBorder(bool);
+@ "border-visible?" : bool BorderVisible();
+
+@ "set-margin" : void SetMargin(int,int,int,int);
+@ "get-margin" :void GetMargin(int*,int*,int*,int*);
+@ "set-inset" :void SetInset(int,int,int,int);
+@ "get-inset" :void GetInset(int*,int*,int*,int*);
+
+@END
+
+@MACRO rZERO = return 0;
+@MACRO rNULL = return NULL;
+
+@CLASSBASE wxBufferDataClass "wx:buffer-data-class" : "wx:object"
+
+@CREATOR ()
+
+@CLASSID wxTYPE_BUFFER_DATA_CLASS
+
+@IVAR "classname" : string classname
+@IVAR "required" : bool required
+
+@ V "read" : wxBufferData^ Read(wxMediaStreamIn%); : : : : rNULL
+
+@END
+
+@CLASSBASE wxBufferDataClassList "wx:buffer-data-class-list" : "wx:object"
+
+@CREATOR ()
+
+@CLASSID wxTYPE_BUFFER_DATA_CLASS_LIST
+
+@ "find" : wxBufferDataClass^ Find(string);
+@ "find-position" : short FindPosition(wxBufferDataClass!);
+@ "add" : void Add(wxBufferDataClass!);
+@ "number" : int Number();
+@ "nth" : wxBufferDataClass^ Nth(int);
+
+@END
+
+@CLASSBASE wxBufferData "wx:buffer-data" : "wx:object"
+
+@CREATOR ()
+
+@CLASSID wxTYPE_BUFFER_DATA
+
+@IVAR "dataclass" : wxBufferDataClass^ dataclass
+@IVAR "next" : wxBufferData^ next
+
+@ V "write" : bool Write(wxMediaStreamOut%); : : : : rZERO
+
+@END
+
diff --git a/src/mred/wxs/wxs_snip.xci b/src/mred/wxs/wxs_snip.xci
new file mode 100644
index 0000000..625dedb
--- /dev/null
+++ b/src/mred/wxs/wxs_snip.xci
@@ -0,0 +1,27 @@
+
+@MACRO makeNoCopyString[len] = scheme_make_sized_string(r, <len>, 0)
+
+@ s "get-extent" : void GetExtent(wxDC!,float,float,float?=NULL,float?=NULL,float?=NULL,float?=NULL,float?=NULL,float?=NULL); : : /CHECKOK[0."wx:snip%::get-extent"]
+@ s "partial-offset" : float PartialOffset(wxDC!,float,float,long); : : /CHECKOK[0."wx:snip%::partial-offset"]
+@ s "draw" : void Draw(wxDC!,float,float,float,float,float,float,float,float,int); : : /CHECKOK[0."wx:snip%::draw"]
+@ s "split" : void Split(long,wxSnip!*,wxSnip!*);
+@ s "merge-with" : wxSnip! MergeWith(wxSnip!);
+@ s "get-text" : string/makeNoCopyString[_x3] GetText(long,long,bool=FALSE,-long*=NULL);
+@ s "copy" : wxSnip! Copy();
+@ s "size-cache-invalid" : void SizeCacheInvalid();
+
+@ s "on-event" : void OnEvent(wxDC!,float,float,float,float,wxMouseEvent%); : : /CHECKOK[0."wx:snip%::on-event"]
+@ s "on-char" : void OnChar(wxDC!,float,float,float,float,wxKeyEvent%); : : /CHECKOK[0."wx:snip%::on-char"]
+@ s "adjust-cursor" : wxCursor^ AdjustCursor(wxDC!,float,float,float,float,wxMouseEvent%); : : /CHECKOK[0."wx:snip%::adjust-cursor"]
+@ s "own-caret" : void OwnCaret(bool); 
+
+@ s "do-edit" : void DoEdit(int,bool=TRUE,long=0);
+@ s "do-font" : void DoFont(int,bool=TRUE);
+@ s "match?" : bool Match(wxSnip!);
+
+@ s "write" : void Write(wxMediaStreamOut%);
+
+@ s "resize" : bool Resize(float, float);
+
+@ s "set-admin" : void SetAdmin(wxSnipAdmin^);
+
diff --git a/src/mred/wxs/wxs_styl.cxx b/src/mred/wxs/wxs_styl.cxx
new file mode 100644
index 0000000..78b2b87
--- /dev/null
+++ b/src/mred/wxs/wxs_styl.cxx
@@ -0,0 +1,2326 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_styl.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_style.h"
+#include "wx_mtype.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_styl.h"
+#include "wxscomon.h"
+
+
+
+
+
+class os_wxMultColour : public wxMultColour {
+ public:
+
+  ~os_wxMultColour();
+};
+
+Scheme_Object *os_wxMultColour_class;
+
+os_wxMultColour::~os_wxMultColour()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMultColourSet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_float(p[0], "wx:mult-colour%::set");
+  x1 = objscheme_unbundle_float(p[1], "wx:mult-colour%::set");
+  x2 = objscheme_unbundle_float(p[2], "wx:mult-colour%::set");
+
+  
+  ((wxMultColour *)((Scheme_Class_Object *)obj)->primdata)->Set(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMultColourGet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  float _x0;
+  float* x0 = &_x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:mult-colour%::get", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_float(objscheme_unbox(p[0], "wx:mult-colour%::get"), "wx:mult-colour%::get");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:mult-colour%::get", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:mult-colour%::get"), "wx:mult-colour%::get");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:mult-colour%::get", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:mult-colour%::get"), "wx:mult-colour%::get");
+
+  
+  ((wxMultColour *)((Scheme_Class_Object *)obj)->primdata)->Get(x0, x1, x2);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_double(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMultColour_Getr(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-r", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMultColour *)cobj->primdata)->wxMultColour::r;
+  else
+    v = ((wxMultColour *)cobj->primdata)->r;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxMultColour_Setr(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-r", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:mult-colour%::r");
+  ((wxMultColour *)cobj->primdata)->r = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMultColour_Getg(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-g", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMultColour *)cobj->primdata)->wxMultColour::g;
+  else
+    v = ((wxMultColour *)cobj->primdata)->g;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxMultColour_Setg(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-g", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:mult-colour%::g");
+  ((wxMultColour *)cobj->primdata)->g = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxMultColour_Getb(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-b", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxMultColour *)cobj->primdata)->wxMultColour::b;
+  else
+    v = ((wxMultColour *)cobj->primdata)->b;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxMultColour_Setb(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-b", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:mult-colour%::b");
+  ((wxMultColour *)cobj->primdata)->b = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMultColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:mult-colour%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:mult-colour%");
+}
+
+void objscheme_setup_wxMultColour(void *env)
+{
+if (os_wxMultColour_class) {
+    objscheme_add_global_class(os_wxMultColour_class,  "wx:mult-colour%", env);
+} else {
+  os_wxMultColour_class = objscheme_def_prim_class(env, "wx:mult-colour%", "wx:object%", NULL, 9);
+
+  scheme_add_method_w_arity(os_wxMultColour_class,"get-class-name",objscheme_classname_os_wxMultColour, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMultColour_class, "set", os_wxMultColourSet, 3, 3);
+ scheme_add_method_w_arity(os_wxMultColour_class, "get", os_wxMultColourGet, 3, 3);
+
+  scheme_add_method_w_arity(os_wxMultColour_class,"get-r", objscheme_wxMultColour_Getr, 0, 0);
+  scheme_add_method_w_arity(os_wxMultColour_class,"set-r", objscheme_wxMultColour_Setr, 1, 1);
+  scheme_add_method_w_arity(os_wxMultColour_class,"get-g", objscheme_wxMultColour_Getg, 0, 0);
+  scheme_add_method_w_arity(os_wxMultColour_class,"set-g", objscheme_wxMultColour_Setg, 1, 1);
+  scheme_add_method_w_arity(os_wxMultColour_class,"get-b", objscheme_wxMultColour_Getb, 0, 0);
+  scheme_add_method_w_arity(os_wxMultColour_class,"set-b", objscheme_wxMultColour_Setb, 1, 1);
+
+  scheme_made_class(os_wxMultColour_class);
+
+
+}
+}
+
+int objscheme_istype_wxMultColour(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMultColour_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:mult-colour%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMultColour(class wxMultColour *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMultColour_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMultColour *objscheme_unbundle_wxMultColour(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMultColour(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMultColour *)o->primdata;
+  else
+    return (wxMultColour *)o->primdata;
+}
+
+
+
+
+
+class os_wxAddColour : public wxAddColour {
+ public:
+
+  ~os_wxAddColour();
+};
+
+Scheme_Object *os_wxAddColour_class;
+
+os_wxAddColour::~os_wxAddColour()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxAddColourSet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  short x0;
+  short x1;
+  short x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:add-colour%::set");
+  x1 = objscheme_unbundle_integer(p[1], "wx:add-colour%::set");
+  x2 = objscheme_unbundle_integer(p[2], "wx:add-colour%::set");
+
+  
+  ((wxAddColour *)((Scheme_Class_Object *)obj)->primdata)->Set(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxAddColourGet(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  short _x0;
+  short* x0 = &_x0;
+  short _x1;
+  short* x1 = &_x1;
+  short _x2;
+  short* x2 = &_x2;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:add-colour%::get", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:add-colour%::get"), "wx:add-colour%::get");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:add-colour%::get", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:add-colour%::get"), "wx:add-colour%::get");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:add-colour%::get", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:add-colour%::get"), "wx:add-colour%::get");
+
+  
+  ((wxAddColour *)((Scheme_Class_Object *)obj)->primdata)->Get(x0, x1, x2);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxAddColour_Getr(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  short v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-r", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxAddColour *)cobj->primdata)->wxAddColour::r;
+  else
+    v = ((wxAddColour *)cobj->primdata)->r;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxAddColour_Setr(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  short v;
+
+  if (n != 1) scheme_wrong_count("set-r", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:add-colour%::r");
+  ((wxAddColour *)cobj->primdata)->r = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxAddColour_Getg(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  short v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-g", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxAddColour *)cobj->primdata)->wxAddColour::g;
+  else
+    v = ((wxAddColour *)cobj->primdata)->g;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxAddColour_Setg(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  short v;
+
+  if (n != 1) scheme_wrong_count("set-g", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:add-colour%::g");
+  ((wxAddColour *)cobj->primdata)->g = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxAddColour_Getb(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  short v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-b", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxAddColour *)cobj->primdata)->wxAddColour::b;
+  else
+    v = ((wxAddColour *)cobj->primdata)->b;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxAddColour_Setb(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  short v;
+
+  if (n != 1) scheme_wrong_count("set-b", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:add-colour%::b");
+  ((wxAddColour *)cobj->primdata)->b = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxAddColour(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:add-colour%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:add-colour%");
+}
+
+void objscheme_setup_wxAddColour(void *env)
+{
+if (os_wxAddColour_class) {
+    objscheme_add_global_class(os_wxAddColour_class,  "wx:add-colour%", env);
+} else {
+  os_wxAddColour_class = objscheme_def_prim_class(env, "wx:add-colour%", "wx:object%", NULL, 9);
+
+  scheme_add_method_w_arity(os_wxAddColour_class,"get-class-name",objscheme_classname_os_wxAddColour, 0, 0);
+
+ scheme_add_method_w_arity(os_wxAddColour_class, "set", os_wxAddColourSet, 3, 3);
+ scheme_add_method_w_arity(os_wxAddColour_class, "get", os_wxAddColourGet, 3, 3);
+
+  scheme_add_method_w_arity(os_wxAddColour_class,"get-r", objscheme_wxAddColour_Getr, 0, 0);
+  scheme_add_method_w_arity(os_wxAddColour_class,"set-r", objscheme_wxAddColour_Setr, 1, 1);
+  scheme_add_method_w_arity(os_wxAddColour_class,"get-g", objscheme_wxAddColour_Getg, 0, 0);
+  scheme_add_method_w_arity(os_wxAddColour_class,"set-g", objscheme_wxAddColour_Setg, 1, 1);
+  scheme_add_method_w_arity(os_wxAddColour_class,"get-b", objscheme_wxAddColour_Getb, 0, 0);
+  scheme_add_method_w_arity(os_wxAddColour_class,"set-b", objscheme_wxAddColour_Setb, 1, 1);
+
+  scheme_made_class(os_wxAddColour_class);
+
+
+}
+}
+
+int objscheme_istype_wxAddColour(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxAddColour_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:add-colour%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxAddColour(class wxAddColour *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxAddColour_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxAddColour *objscheme_unbundle_wxAddColour(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxAddColour(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxAddColour *)o->primdata;
+  else
+    return (wxAddColour *)o->primdata;
+}
+
+
+
+
+  
+
+
+
+
+
+
+
+class os_wxStyleDelta : public wxStyleDelta {
+ public:
+
+  os_wxStyleDelta(Scheme_Object * obj, int x0 = wxCHANGE_NOTHING, int x1 = 0);
+  ~os_wxStyleDelta();
+};
+
+Scheme_Object *os_wxStyleDelta_class;
+
+os_wxStyleDelta::os_wxStyleDelta(Scheme_Object * o, int x0, int x1)
+: wxStyleDelta(x0, x1)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxStyleDelta::~os_wxStyleDelta()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:style-delta%::copy", 0);
+
+  
+  ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaCollapse(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:style-delta%::collapse", 0);
+
+  
+  r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->Collapse(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaEqual(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:style-delta%::equal?", 0);
+
+  
+  r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->Equal(*x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaSetDeltaForeground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyleDelta* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:style-delta%::set-delta-foreground (color name case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:style-delta%::set-delta-foreground (color name case)");
+
+    
+    r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDeltaForeground(x0);
+
+    
+    
+  } else  {
+    class wxColour* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:style-delta%::set-delta-foreground (wx:colour% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:style-delta%::set-delta-foreground (wx:colour% case)", 0);
+
+    
+    r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDeltaForeground(*x0);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxStyleDelta(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaSetDeltaBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyleDelta* r;
+  objscheme_check_valid(obj);
+  if ((n >= 1) && objscheme_istype_string(p[0], NULL)) {
+    string x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:style-delta%::set-delta-background (color name case)", 1, 1, n, p);
+    x0 = (string)objscheme_unbundle_string(p[0], "wx:style-delta%::set-delta-background (color name case)");
+
+    
+    r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDeltaBackground(x0);
+
+    
+    
+  } else  {
+    class wxColour* x0;
+
+    
+    if (n != 1) 
+      scheme_wrong_count("wx:style-delta%::set-delta-background (wx:colour% case)", 1, 1, n, p);
+    x0 = objscheme_unbundle_wxColour(p[0], "wx:style-delta%::set-delta-background (wx:colour% case)", 0);
+
+    
+    r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDeltaBackground(*x0);
+
+    
+    
+  }
+
+  return objscheme_bundle_wxStyleDelta(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaSetDeltaFace(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyleDelta* r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:style-delta%::set-delta-face");
+
+  
+  r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDeltaFace(x0);
+
+  
+  
+  return objscheme_bundle_wxStyleDelta(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDeltaSetDelta(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyleDelta* r;
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:style-delta%::set-delta");
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:style-delta%::set-delta");
+  } else
+    x1 = 0;
+
+  
+  r = ((wxStyleDelta *)((Scheme_Class_Object *)obj)->primdata)->SetDelta(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxStyleDelta(r);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_Getfamily(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-family", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::family;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->family;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_Setfamily(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-family", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::family");
+  ((wxStyleDelta *)cobj->primdata)->family = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_Getface(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  nstring v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-face", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::face;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->face;
+
+  return objscheme_bundle_string((char *)v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_Setface(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  nstring v;
+
+  if (n != 1) scheme_wrong_count("set-face", 1, 1, n, p);
+
+  v = (nstring)objscheme_unbundle_nullable_string(p[0], "wx:style-delta%::face");
+  ((wxStyleDelta *)cobj->primdata)->face = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetsizeMult(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  float v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-size-mult", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::sizeMult;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->sizeMult;
+
+  return scheme_make_double(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetsizeMult(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  float v;
+
+  if (n != 1) scheme_wrong_count("set-size-mult", 1, 1, n, p);
+
+  v = objscheme_unbundle_float(p[0], "wx:style-delta%::size-mult");
+  ((wxStyleDelta *)cobj->primdata)->sizeMult = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetsizeAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-size-add", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::sizeAdd;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->sizeAdd;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetsizeAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-size-add", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::size-add");
+  ((wxStyleDelta *)cobj->primdata)->sizeAdd = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetweightOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-weight-on", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::weightOn;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->weightOn;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetweightOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-weight-on", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::weight-on");
+  ((wxStyleDelta *)cobj->primdata)->weightOn = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetweightOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-weight-off", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::weightOff;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->weightOff;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetweightOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-weight-off", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::weight-off");
+  ((wxStyleDelta *)cobj->primdata)->weightOff = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetstyleOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-style-on", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::styleOn;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->styleOn;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetstyleOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-style-on", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::style-on");
+  ((wxStyleDelta *)cobj->primdata)->styleOn = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetstyleOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-style-off", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::styleOff;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->styleOff;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetstyleOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-style-off", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::style-off");
+  ((wxStyleDelta *)cobj->primdata)->styleOff = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetunderlinedOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-underlined-on", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::underlinedOn;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->underlinedOn;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetunderlinedOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-underlined-on", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:style-delta%::underlined-on");
+  ((wxStyleDelta *)cobj->primdata)->underlinedOn = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetunderlinedOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-underlined-off", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::underlinedOff;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->underlinedOff;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetunderlinedOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-underlined-off", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:style-delta%::underlined-off");
+  ((wxStyleDelta *)cobj->primdata)->underlinedOff = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GettransparentTextBackingOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-transparent-text-backing-on", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::transparentTextBackingOn;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->transparentTextBackingOn;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SettransparentTextBackingOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-transparent-text-backing-on", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:style-delta%::transparent-text-backing-on");
+  ((wxStyleDelta *)cobj->primdata)->transparentTextBackingOn = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GettransparentTextBackingOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  Bool v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-transparent-text-backing-off", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::transparentTextBackingOff;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->transparentTextBackingOff;
+
+  return (v ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SettransparentTextBackingOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  Bool v;
+
+  if (n != 1) scheme_wrong_count("set-transparent-text-backing-off", 1, 1, n, p);
+
+  v = objscheme_unbundle_bool(p[0], "wx:style-delta%::transparent-text-backing-off");
+  ((wxStyleDelta *)cobj->primdata)->transparentTextBackingOff = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetforegroundMult(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxMultColour* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-foreground-mult", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = &((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::foregroundMult;
+  else
+    v = &((wxStyleDelta *)cobj->primdata)->foregroundMult;
+
+  return objscheme_bundle_wxMultColour(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetbackgroundMult(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxMultColour* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-background-mult", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = &((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::backgroundMult;
+  else
+    v = &((wxStyleDelta *)cobj->primdata)->backgroundMult;
+
+  return objscheme_bundle_wxMultColour(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetforegroundAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxAddColour* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-foreground-add", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = &((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::foregroundAdd;
+  else
+    v = &((wxStyleDelta *)cobj->primdata)->foregroundAdd;
+
+  return objscheme_bundle_wxAddColour(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetbackgroundAdd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  class wxAddColour* v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-background-add", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = &((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::backgroundAdd;
+  else
+    v = &((wxStyleDelta *)cobj->primdata)->backgroundAdd;
+
+  return objscheme_bundle_wxAddColour(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetalignmentOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-alignment-on", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::alignmentOn;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->alignmentOn;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetalignmentOn(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-alignment-on", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::alignment-on");
+  ((wxStyleDelta *)cobj->primdata)->alignmentOn = v;
+
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_GetalignmentOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  Scheme_Class_Object *cobj;
+  int v;
+
+  objscheme_check_valid(obj);
+  if (n) scheme_wrong_count("get-alignment-off", 0, 0, n, p);
+  cobj = (Scheme_Class_Object *)obj;
+  if (cobj->primflag)
+    v = ((os_wxStyleDelta *)cobj->primdata)->wxStyleDelta::alignmentOff;
+  else
+    v = ((wxStyleDelta *)cobj->primdata)->alignmentOff;
+
+  return scheme_make_integer(v);
+}
+
+static Scheme_Object *objscheme_wxStyleDelta_SetalignmentOff(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  objscheme_check_valid(obj);
+  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;
+  int v;
+
+  if (n != 1) scheme_wrong_count("set-alignment-off", 1, 1, n, p);
+
+  v = objscheme_unbundle_integer(p[0], "wx:style-delta%::alignment-off");
+  ((wxStyleDelta *)cobj->primdata)->alignmentOff = v;
+
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleDelta_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxStyleDelta *realobj;
+  int x0;
+  int x1;
+
+  
+  if ((n > 2)) 
+    scheme_wrong_count("wx:style-delta%::initialization", 0, 2, n, p);
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:style-delta%::initialization");
+  } else
+    x0 = wxCHANGE_NOTHING;
+  if (n > 1) {
+    x1 = objscheme_unbundle_integer(p[1], "wx:style-delta%::initialization");
+  } else
+    x1 = 0;
+
+  
+  realobj = new os_wxStyleDelta(obj, x0, x1);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxStyleDelta(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:style-delta%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:style-delta%");
+}
+
+void objscheme_setup_wxStyleDelta(void *env)
+{
+if (os_wxStyleDelta_class) {
+    objscheme_add_global_class(os_wxStyleDelta_class,  "wx:style-delta%", env);
+} else {
+  os_wxStyleDelta_class = objscheme_def_prim_class(env, "wx:style-delta%", "wx:object%", os_wxStyleDelta_ConstructScheme, 40);
+
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-class-name",objscheme_classname_os_wxStyleDelta, 0, 0);
+
+ scheme_add_method_w_arity(os_wxStyleDelta_class, "copy", os_wxStyleDeltaCopy, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleDelta_class, "collapse", os_wxStyleDeltaCollapse, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleDelta_class, "equal?", os_wxStyleDeltaEqual, 1, 1);
+ scheme_add_method(os_wxStyleDelta_class, "set-delta-foreground", os_wxStyleDeltaSetDeltaForeground);
+ scheme_add_method(os_wxStyleDelta_class, "set-delta-background", os_wxStyleDeltaSetDeltaBackground);
+ scheme_add_method_w_arity(os_wxStyleDelta_class, "set-delta-face", os_wxStyleDeltaSetDeltaFace, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleDelta_class, "set-delta", os_wxStyleDeltaSetDelta, 1, 2);
+
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-family", objscheme_wxStyleDelta_Getfamily, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-family", objscheme_wxStyleDelta_Setfamily, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-face", objscheme_wxStyleDelta_Getface, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-face", objscheme_wxStyleDelta_Setface, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-size-mult", objscheme_wxStyleDelta_GetsizeMult, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-size-mult", objscheme_wxStyleDelta_SetsizeMult, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-size-add", objscheme_wxStyleDelta_GetsizeAdd, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-size-add", objscheme_wxStyleDelta_SetsizeAdd, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-weight-on", objscheme_wxStyleDelta_GetweightOn, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-weight-on", objscheme_wxStyleDelta_SetweightOn, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-weight-off", objscheme_wxStyleDelta_GetweightOff, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-weight-off", objscheme_wxStyleDelta_SetweightOff, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-style-on", objscheme_wxStyleDelta_GetstyleOn, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-style-on", objscheme_wxStyleDelta_SetstyleOn, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-style-off", objscheme_wxStyleDelta_GetstyleOff, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-style-off", objscheme_wxStyleDelta_SetstyleOff, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-underlined-on", objscheme_wxStyleDelta_GetunderlinedOn, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-underlined-on", objscheme_wxStyleDelta_SetunderlinedOn, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-underlined-off", objscheme_wxStyleDelta_GetunderlinedOff, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-underlined-off", objscheme_wxStyleDelta_SetunderlinedOff, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-transparent-text-backing-on", objscheme_wxStyleDelta_GettransparentTextBackingOn, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-transparent-text-backing-on", objscheme_wxStyleDelta_SettransparentTextBackingOn, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-transparent-text-backing-off", objscheme_wxStyleDelta_GettransparentTextBackingOff, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-transparent-text-backing-off", objscheme_wxStyleDelta_SettransparentTextBackingOff, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-foreground-mult", objscheme_wxStyleDelta_GetforegroundMult, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-background-mult", objscheme_wxStyleDelta_GetbackgroundMult, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-foreground-add", objscheme_wxStyleDelta_GetforegroundAdd, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-background-add", objscheme_wxStyleDelta_GetbackgroundAdd, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-alignment-on", objscheme_wxStyleDelta_GetalignmentOn, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-alignment-on", objscheme_wxStyleDelta_SetalignmentOn, 1, 1);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"get-alignment-off", objscheme_wxStyleDelta_GetalignmentOff, 0, 0);
+  scheme_add_method_w_arity(os_wxStyleDelta_class,"set-alignment-off", objscheme_wxStyleDelta_SetalignmentOff, 1, 1);
+
+  scheme_made_class(os_wxStyleDelta_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxStyleDelta, wxTYPE_STYLE_DELTA);
+
+}
+  scheme_install_xc_global("wx:const-base", scheme_make_integer(wxBASE), env);
+  scheme_install_xc_global("wx:const-change-nothing", scheme_make_integer(wxCHANGE_NOTHING), env);
+  scheme_install_xc_global("wx:const-change-normal", scheme_make_integer(wxCHANGE_NORMAL), env);
+  scheme_install_xc_global("wx:const-change-style", scheme_make_integer(wxCHANGE_STYLE), env);
+  scheme_install_xc_global("wx:const-change-weight", scheme_make_integer(wxCHANGE_WEIGHT), env);
+  scheme_install_xc_global("wx:const-change-underline", scheme_make_integer(wxCHANGE_UNDERLINE), env);
+  scheme_install_xc_global("wx:const-change-size", scheme_make_integer(wxCHANGE_SIZE), env);
+  scheme_install_xc_global("wx:const-change-bold", scheme_make_integer(wxCHANGE_BOLD), env);
+  scheme_install_xc_global("wx:const-change-italic", scheme_make_integer(wxCHANGE_ITALIC), env);
+  scheme_install_xc_global("wx:const-change-toggle-style", scheme_make_integer(wxCHANGE_TOGGLE_STYLE), env);
+  scheme_install_xc_global("wx:const-change-toggle-weight", scheme_make_integer(wxCHANGE_TOGGLE_WEIGHT), env);
+  scheme_install_xc_global("wx:const-change-toggle-underline", scheme_make_integer(wxCHANGE_TOGGLE_UNDERLINE), env);
+  scheme_install_xc_global("wx:const-change-bigger", scheme_make_integer(wxCHANGE_BIGGER), env);
+  scheme_install_xc_global("wx:const-change-smaller", scheme_make_integer(wxCHANGE_SMALLER), env);
+  scheme_install_xc_global("wx:const-change-family", scheme_make_integer(wxCHANGE_FAMILY), env);
+  scheme_install_xc_global("wx:const-change-alignment", scheme_make_integer(wxCHANGE_ALIGNMENT), env);
+  scheme_install_xc_global("wx:const-change-normal-colour", scheme_make_integer(wxCHANGE_NORMAL_COLOUR), env);
+  scheme_install_xc_global("wx:const-align-top", scheme_make_integer(wxALIGN_TOP), env);
+  scheme_install_xc_global("wx:const-align-bottom", scheme_make_integer(wxALIGN_BOTTOM), env);
+  scheme_install_xc_global("wx:const-align-center", scheme_make_integer(wxALIGN_CENTER), env);
+}
+
+int objscheme_istype_wxStyleDelta(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxStyleDelta_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:style-delta%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_STYLE_DELTA) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxStyleDelta_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxStyleDelta(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxStyleDelta *)o->primdata;
+  else
+    return (wxStyleDelta *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+class os_wxStyle : public wxStyle {
+ public:
+
+  ~os_wxStyle();
+};
+
+Scheme_Object *os_wxStyle_class;
+
+os_wxStyle::~os_wxStyle()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleSwitchTo(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+  class wxStyle* x1;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:style%::switch-to", 0);
+  x1 = objscheme_unbundle_wxStyle(p[1], "wx:style%::switch-to", 0);
+
+  if (x0 && !x0->Ok()) scheme_signal_error("%s: bad bitmap", "wx:style%::switch-to");
+  ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->SwitchTo(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleSetShiftStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style%::set-shift-style", 0);
+
+  
+  ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->SetShiftStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetShiftStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetShiftStyle();
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleIsJoin(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->IsJoin();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleSetDelta(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:style%::set-delta", 0);
+
+  
+  ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->SetDelta(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetDelta(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleDelta* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleDelta(p[0], "wx:style%::get-delta", 0);
+
+  
+  ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetDelta(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleSetBaseStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style%::set-base-style", 0);
+
+  
+  ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->SetBaseStyle(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetBaseStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetBaseStyle();
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetTextWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:style%::get-text-width", 0);
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetTextWidth(x0);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetTextSpace(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:style%::get-text-space", 0);
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetTextSpace(x0);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetTextDescent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:style%::get-text-descent", 0);
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetTextDescent(x0);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetTextHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+  class wxDC* x0;
+
+  
+  x0 = objscheme_unbundle_wxDC(p[0], "wx:style%::get-text-height", 0);
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetTextHeight(x0);
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetTransparentTextBacking(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetTransparentTextBacking();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetAlignment(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetAlignment();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetBackground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetBackground();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetForeground(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxColour* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = &((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetForeground();
+
+  
+  
+  return objscheme_bundle_wxColour(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxFont* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetFont();
+
+  
+  
+  return objscheme_bundle_wxFont(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetUnderlined(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetUnderlined();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetStyle();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetWeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetWeight();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetSize();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetFace(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetFace();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetFamily(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetFamily();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleGetName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyle *)((Scheme_Class_Object *)obj)->primdata)->GetName();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+static Scheme_Object *objscheme_classname_os_wxStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:style%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:style%");
+}
+
+void objscheme_setup_wxStyle(void *env)
+{
+if (os_wxStyle_class) {
+    objscheme_add_global_class(os_wxStyle_class,  "wx:style%", env);
+} else {
+  os_wxStyle_class = objscheme_def_prim_class(env, "wx:style%", "wx:object%", NULL, 25);
+
+  scheme_add_method_w_arity(os_wxStyle_class,"get-class-name",objscheme_classname_os_wxStyle, 0, 0);
+
+ scheme_add_method_w_arity(os_wxStyle_class, "switch-to", os_wxStyleSwitchTo, 2, 2);
+ scheme_add_method_w_arity(os_wxStyle_class, "set-shift-style", os_wxStyleSetShiftStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-shift-style", os_wxStyleGetShiftStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "is-join?", os_wxStyleIsJoin, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "set-delta", os_wxStyleSetDelta, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-delta", os_wxStyleGetDelta, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "set-base-style", os_wxStyleSetBaseStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-base-style", os_wxStyleGetBaseStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-text-width", os_wxStyleGetTextWidth, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-text-space", os_wxStyleGetTextSpace, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-text-descent", os_wxStyleGetTextDescent, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-text-height", os_wxStyleGetTextHeight, 1, 1);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-transparent-text-backing", os_wxStyleGetTransparentTextBacking, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-alignment", os_wxStyleGetAlignment, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-colour", os_wxStyleGetBackground, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-foreground", os_wxStyleGetForeground, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-font", os_wxStyleGetFont, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-underlined", os_wxStyleGetUnderlined, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-style", os_wxStyleGetStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-weight", os_wxStyleGetWeight, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-size", os_wxStyleGetSize, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-face", os_wxStyleGetFace, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-family", os_wxStyleGetFamily, 0, 0);
+ scheme_add_method_w_arity(os_wxStyle_class, "get-name", os_wxStyleGetName, 0, 0);
+
+
+  scheme_made_class(os_wxStyle_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxStyle, wxTYPE_STYLE);
+
+}
+}
+
+int objscheme_istype_wxStyle(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxStyle_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:style%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_STYLE) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxStyle_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxStyle(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxStyle *)o->primdata;
+  else
+    return (wxStyle *)o->primdata;
+}
+
+
+
+
+
+
+
+
+
+
+
+// @ "notify-on-change" : long NotifyOnChange(wxStyleNotifyFunc f, void *data);
+// @ "forget-notification" : void ForgetNotification(long);
+
+
+
+
+class os_wxStyleList : public wxStyleList {
+ public:
+
+  os_wxStyleList(Scheme_Object * obj);
+  ~os_wxStyleList();
+};
+
+Scheme_Object *os_wxStyleList_class;
+
+os_wxStyleList::os_wxStyleList(Scheme_Object * o)
+: wxStyleList()
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxStyleList::~os_wxStyleList()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListIsUsed(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->IsUsed();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListAdjustUsage(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:style-list%::adjust-usage");
+
+  
+  ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->AdjustUsage(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListStyleToIndex(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style-list%::style-to-index", 0);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->StyleToIndex(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListIndexToStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:style-list%::index-to-style");
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->IndexToStyle(x0);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListConvert(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style-list%::convert", 0);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->Convert(x0);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListReplaceNamedStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  string x0;
+  class wxStyle* x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:style-list%::replace-named-style");
+  x1 = objscheme_unbundle_wxStyle(p[1], "wx:style-list%::replace-named-style", 1);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->ReplaceNamedStyle(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListNewNamedStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  string x0;
+  class wxStyle* x1;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:style-list%::new-named-style");
+  x1 = objscheme_unbundle_wxStyle(p[1], "wx:style-list%::new-named-style", 1);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->NewNamedStyle(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListFindNamedStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:style-list%::find-named-style");
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->FindNamedStyle(x0);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListFindOrCreateJoinStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+  class wxStyle* x1;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style-list%::find-or-create-join-style", 1);
+  x1 = objscheme_unbundle_wxStyle(p[1], "wx:style-list%::find-or-create-join-style", 0);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateJoinStyle(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListFindOrCreateStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+  class wxStyle* x0;
+  class wxStyleDelta* x1;
+
+  
+  x0 = objscheme_unbundle_wxStyle(p[0], "wx:style-list%::find-or-create-style", 1);
+  x1 = objscheme_unbundle_wxStyleDelta(p[1], "wx:style-list%::find-or-create-style", 0);
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->FindOrCreateStyle(x0, x1);
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListNumber(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->Number();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListBasicStyle(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxStyle* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->BasicStyle();
+
+  
+  
+  return objscheme_bundle_wxStyle(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxStyleList* x0;
+
+  
+  x0 = objscheme_unbundle_wxStyleList(p[0], "wx:style-list%::copy", 0);
+
+  
+  ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->Copy(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleListClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxStyleList *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxStyleList_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxStyleList *realobj;
+
+  
+  if (n != 0) 
+    scheme_wrong_count("wx:style-list%::initialization", 0, 0, n, p);
+
+  
+  realobj = new os_wxStyleList(obj);
+  
+  
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxStyleList(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:style-list%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:style-list%");
+}
+
+void objscheme_setup_wxStyleList(void *env)
+{
+if (os_wxStyleList_class) {
+    objscheme_add_global_class(os_wxStyleList_class,  "wx:style-list%", env);
+} else {
+  os_wxStyleList_class = objscheme_def_prim_class(env, "wx:style-list%", "wx:object%", os_wxStyleList_ConstructScheme, 15);
+
+  scheme_add_method_w_arity(os_wxStyleList_class,"get-class-name",objscheme_classname_os_wxStyleList, 0, 0);
+
+ scheme_add_method_w_arity(os_wxStyleList_class, "is-used? ", os_wxStyleListIsUsed, 0, 0);
+ scheme_add_method_w_arity(os_wxStyleList_class, "adjust-usage", os_wxStyleListAdjustUsage, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "style-to-index", os_wxStyleListStyleToIndex, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "index-to-style", os_wxStyleListIndexToStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "convert", os_wxStyleListConvert, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "replace-named-style", os_wxStyleListReplaceNamedStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxStyleList_class, "new-named-style", os_wxStyleListNewNamedStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxStyleList_class, "find-named-style", os_wxStyleListFindNamedStyle, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "find-or-create-join-style", os_wxStyleListFindOrCreateJoinStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxStyleList_class, "find-or-create-style", os_wxStyleListFindOrCreateStyle, 2, 2);
+ scheme_add_method_w_arity(os_wxStyleList_class, "number", os_wxStyleListNumber, 0, 0);
+ scheme_add_method_w_arity(os_wxStyleList_class, "basic-style", os_wxStyleListBasicStyle, 0, 0);
+ scheme_add_method_w_arity(os_wxStyleList_class, "copy", os_wxStyleListCopy, 1, 1);
+ scheme_add_method_w_arity(os_wxStyleList_class, "clear", os_wxStyleListClear, 0, 0);
+
+
+  scheme_made_class(os_wxStyleList_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxStyleList, wxTYPE_STYLE_LIST);
+
+}
+  scheme_install_xc_global("wx:the-style-list", objscheme_bundle_wxStyleList(wxTheStyleList), env);
+}
+
+int objscheme_istype_wxStyleList(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxStyleList_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:style-list%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxStyleList(class wxStyleList *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_STYLE_LIST) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxStyleList_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxStyleList *objscheme_unbundle_wxStyleList(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxStyleList(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxStyleList *)o->primdata;
+  else
+    return (wxStyleList *)o->primdata;
+}
+
+
diff --git a/src/mred/wxs/wxs_styl.h b/src/mred/wxs/wxs_styl.h
new file mode 100644
index 0000000..65b4e97
--- /dev/null
+++ b/src/mred/wxs/wxs_styl.h
@@ -0,0 +1,78 @@
+#ifndef WXS_SETUP_ONLY
+#endif
+void objscheme_setup_wxMultColour(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMultColour(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMultColour(class wxMultColour *realobj);
+class wxMultColour *objscheme_unbundle_wxMultColour(Scheme_Object *obj, const char *where, int nullOK);
+#endif
+void objscheme_setup_wxAddColour(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxAddColour(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxAddColour(class wxAddColour *realobj);
+class wxAddColour *objscheme_unbundle_wxAddColour(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *);
+extern class wxColour *objscheme_unbundle_wxColour(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *);
+extern Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *);
+extern Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *);
+extern Scheme_Object *objscheme_bundle_wxMultColour(class wxMultColour *);
+extern Scheme_Object *objscheme_bundle_wxMultColour(class wxMultColour *);
+extern Scheme_Object *objscheme_bundle_wxAddColour(class wxAddColour *);
+extern Scheme_Object *objscheme_bundle_wxAddColour(class wxAddColour *);
+#endif
+void objscheme_setup_wxStyleDelta(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxStyleDelta(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxStyleDelta(class wxStyleDelta *realobj);
+class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern class wxDC *objscheme_unbundle_wxDC(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxColour(class wxColour *);
+extern Scheme_Object *objscheme_bundle_wxFont(class wxFont *);
+#endif
+void objscheme_setup_wxStyle(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxStyle(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *realobj);
+class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *obj, const char *where, int nullOK);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyle *objscheme_unbundle_wxStyle(Scheme_Object *, const char *, int);
+extern class wxStyleDelta *objscheme_unbundle_wxStyleDelta(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern Scheme_Object *objscheme_bundle_wxStyle(class wxStyle *);
+extern class wxStyleList *objscheme_unbundle_wxStyleList(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxStyleList(void *env);
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxStyleList(class wxStyleList *);
+int objscheme_istype_wxStyleList(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxStyleList(class wxStyleList *realobj);
+class wxStyleList *objscheme_unbundle_wxStyleList(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_styl.xc b/src/mred/wxs/wxs_styl.xc
new file mode 100644
index 0000000..65d61ed
--- /dev/null
+++ b/src/mred/wxs/wxs_styl.xc
@@ -0,0 +1,167 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_style.h"
+#include "wx_mtype.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxMultColour "wx:mult-colour" : "wx:object"
+
+@IVAR "r" : float r
+@IVAR "g" : float g
+@IVAR "b" : float b
+
+@ "get" : void Get(float*,float*,float*);
+@ "set" : void Set(float,float,float);
+
+@END
+
+@CLASSBASE wxAddColour "wx:add-colour" : "wx:object"
+
+@IVAR "r" : short r
+@IVAR "g" : short g
+@IVAR "b" : short b
+
+@ "get" : void Get(short*,short*,short*);
+@ "set" : void Set(short,short,short);
+
+@END
+
+
+@CLASSBASE wxStyleDelta "wx:style-delta" : "wx:object"
+
+@IVAR "family" : int family
+@IVAR "face" : nstring face
+@IVAR "size-mult" : float sizeMult
+@IVAR "size-add" : int sizeAdd
+@IVAR "weight-on" : int weightOn
+@IVAR "weight-off" : int weightOff
+@IVAR "style-on" : int styleOn
+@IVAR "style-off" : int styleOff
+@IVAR "underlined-on" : bool underlinedOn
+@IVAR "underlined-off" : bool underlinedOff
+@IVAR "transparent-text-backing-on" : bool transparentTextBackingOn
+@IVAR "transparent-text-backing-off" : bool transparentTextBackingOff
+@IVAR r "foreground-mult" : wxMultColour% foregroundMult
+@IVAR r "background-mult" : wxMultColour% backgroundMult
+@IVAR r "foreground-add" : wxAddColour% foregroundAdd
+@IVAR r "background-add" : wxAddColour% backgroundAdd
+@IVAR "alignment-on" : int alignmentOn
+@IVAR "alignment-off" : int alignmentOff
+  
+@CREATOR (int=wxCHANGE_NOTHING,int=0);
+
+@CLASSID wxTYPE_STYLE_DELTA
+
+@ "set-delta" : wxStyleDelta! SetDelta(int,int=0);
+@ "set-delta-face" : wxStyleDelta! SetDeltaFace(string);
+@ "set-delta-background" : wxStyleDelta! SetDeltaBackground(string); <> color name
+@ "set-delta-background" : wxStyleDelta! SetDeltaBackground(wxColour%); <> wx:colour%
+@ "set-delta-foreground" : wxStyleDelta! SetDeltaForeground(string); <> color name
+@ "set-delta-foreground" : wxStyleDelta! SetDeltaForeground(wxColour%); <> wx:colour%
+
+@ "equal?" : bool Equal(wxStyleDelta%);
+@ "collapse" : bool Collapse(wxStyleDelta%);
+@ "copy" : void Copy(wxStyleDelta!);
+
+@CONSTANT "wx:const-base" : int wxBASE
+
+@CONSTANT "wx:const-change-nothing" : int wxCHANGE_NOTHING
+@CONSTANT "wx:const-change-normal" : int wxCHANGE_NORMAL
+@CONSTANT "wx:const-change-style" : int wxCHANGE_STYLE
+@CONSTANT "wx:const-change-weight" : int wxCHANGE_WEIGHT
+@CONSTANT "wx:const-change-underline" : int wxCHANGE_UNDERLINE
+@CONSTANT "wx:const-change-size" : int wxCHANGE_SIZE
+@CONSTANT "wx:const-change-bold" : int wxCHANGE_BOLD
+@CONSTANT "wx:const-change-italic" : int wxCHANGE_ITALIC
+@CONSTANT "wx:const-change-toggle-style" : int wxCHANGE_TOGGLE_STYLE
+@CONSTANT "wx:const-change-toggle-weight" : int wxCHANGE_TOGGLE_WEIGHT
+@CONSTANT "wx:const-change-toggle-underline" : int wxCHANGE_TOGGLE_UNDERLINE
+@CONSTANT "wx:const-change-bigger" : int wxCHANGE_BIGGER
+@CONSTANT "wx:const-change-smaller" : int wxCHANGE_SMALLER
+@CONSTANT "wx:const-change-family" : int wxCHANGE_FAMILY
+@CONSTANT "wx:const-change-alignment" : int wxCHANGE_ALIGNMENT
+@CONSTANT "wx:const-change-normal-colour" : int wxCHANGE_NORMAL_COLOUR
+
+@CONSTANT "wx:const-align-top" : int wxALIGN_TOP
+@CONSTANT "wx:const-align-bottom" : int wxALIGN_BOTTOM
+@CONSTANT "wx:const-align-center" : int wxALIGN_CENTER
+
+@END
+
+
+@CLASSBASE wxStyle "wx:style" : "wx:object"
+
+@CLASSID wxTYPE_STYLE
+
+@ "get-name" : string GetName();
+@ "get-family" : int GetFamily();
+@ "get-face" : nstring GetFace();
+@ "get-size" : int GetSize();
+@ "get-weight" : int GetWeight();
+@ "get-style" : int GetStyle();
+@ "get-underlined" : bool GetUnderlined();
+@ "get-font" : wxFont! GetFont();
+@ "get-foreground" : wxColour% GetForeground();
+@ "get-colour" : wxColour% GetBackground();
+@ "get-alignment" : int GetAlignment();
+@ "get-transparent-text-backing" : bool GetTransparentTextBacking();
+
+@ "get-text-height" : float GetTextHeight(wxDC!);
+@ "get-text-descent" : float GetTextDescent(wxDC!);
+@ "get-text-space" : float GetTextSpace(wxDC!);
+@ "get-text-width" : float GetTextWidth(wxDC!);
+
+@ "get-base-style" : wxStyle! GetBaseStyle();
+@ "set-base-style" : void SetBaseStyle(wxStyle!);
+
+@ "get-delta" : void GetDelta(wxStyleDelta%);
+@ "set-delta" : void SetDelta(wxStyleDelta%);
+
+@ "is-join?" : bool IsJoin();
+
+@ "get-shift-style" :  wxStyle! GetShiftStyle();
+@ "set-shift-style" : void SetShiftStyle(wxStyle!);
+
+@ "switch-to" : void SwitchTo(wxDC!, wxStyle!); : : /CHECKOK[0."wx:style%::switch-to"]
+
+@END
+
+
+@CLASSBASE wxStyleList "wx:style-list" : "wx:object"
+
+@CREATOR ();
+
+@CLASSID wxTYPE_STYLE_LIST
+
+@ "clear" : void Clear();
+@ "copy" : void Copy(wxStyleList!);
+
+@ "basic-style" : wxStyle! BasicStyle();
+
+@ "number" : int Number();
+
+@ "find-or-create-style" : wxStyle! FindOrCreateStyle(wxStyle^,wxStyleDelta!);
+@ "find-or-create-join-style" : wxStyle! FindOrCreateJoinStyle(wxStyle^,wxStyle!);
+@ "find-named-style" : wxStyle! FindNamedStyle(string);
+@ "new-named-style" : wxStyle! NewNamedStyle(string,wxStyle^);
+@ "replace-named-style" : wxStyle! ReplaceNamedStyle(string,wxStyle^);
+
+@ "convert" : wxStyle! Convert(wxStyle!);
+
+// @ "notify-on-change" : long NotifyOnChange(wxStyleNotifyFunc f, void *data);
+// @ "forget-notification" : void ForgetNotification(long);
+
+@ "index-to-style" : wxStyle^ IndexToStyle(int);
+@ "style-to-index" : int StyleToIndex(wxStyle!);
+
+@ "adjust-usage" : void AdjustUsage(bool);
+@ "is-used? " : bool IsUsed();
+
+@CONSTANT "wx:the-style-list" : wxStyleList! wxTheStyleList
+
+@END
+
diff --git a/src/mred/wxs/wxs_tbar.cxx b/src/mred/wxs/wxs_tbar.cxx
new file mode 100644
index 0000000..4d357b9
--- /dev/null
+++ b/src/mred/wxs/wxs_tbar.cxx
@@ -0,0 +1,4 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_tbar.xc". */
+
+
diff --git a/src/mred/wxs/wxs_tbar.h b/src/mred/wxs/wxs_tbar.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxs_tbar.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxs_tbar.xc b/src/mred/wxs/wxs_tbar.xc
new file mode 100644
index 0000000..26a8841
--- /dev/null
+++ b/src/mred/wxs/wxs_tbar.xc
@@ -0,0 +1,59 @@
+
+#if 0
+
+#include "wx_tbar.h"
+#include "wx_bbar.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if USE_TOOLBAR 
+
+@CLASSBASE wxToolBarTool "wx:tool-bar-tool" : "wx:canvas"
+
+@END
+
+@CLASSBASE wxToolBar "wx:tool-bar" : "wx:canvas"
+
+@CREATOR (wxFrame!,int=0,int=0,int=-1,int=-1,long=0,int=wxVERTICAL,int=2);
+
+@CLASSID wxTYPE_TOOLBAR
+
+@ "add-tool" : wxToolBarTool! AddTool(int,wxBitmap!,wxBitmap^=NULL,bool=FALSE,float=-1,float=-1,wxObject^=NULL);
+
+@ "enable-tool" : void EnableTool(int,bool);
+
+@ "find-tool-for-position" : wxToolBarTool^ FindToolForPosition(float,float);
+
+@ "get-max-size" : void GetMaxSize(float*,float*);
+
+@ "get-tool-client-data" : wxObject^ GetToolClientData(int);
+
+@ "get-tool-enabled?" : bool GetToolEnabled(int);
+@ "get-tool-state?" : bool GetToolState(int);
+
+@ "set-margins" : void SetMargins(float,float);
+
+@ "toggle-tool" : void ToggleTool(int,bool);
+
+@END
+
+#if USE_BUTTONBAR && defined(wx_msw)
+
+@CLASSBASE wxButtonBar "wx:button-bar" : "wx:tool-bar"
+
+@CLASSID wxTYPE_BUTTONBAR
+
+@CREATOR (wxFrame!,int=0,int=0,int=-1,int=-1,long=0,int=wxVERTICAL,int=2);
+
+@ "get-default-button-height" : float GetDefaultButtonHeight();
+@ "get-default-button-width" : float GetDefaultButtonWidth();
+@ "set-default-size" : void SetDefaultSize(float,float);
+
+@END
+
+#endif
+#endif
+
+#endif
diff --git a/src/mred/wxs/wxs_text.cxx b/src/mred/wxs/wxs_text.cxx
new file mode 100644
index 0000000..5ca9fe1
--- /dev/null
+++ b/src/mred/wxs/wxs_text.cxx
@@ -0,0 +1,2005 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_text.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_item.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_text.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_text.h"
+#include "wxscomon.h"
+
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxText
+#define CB_REALCLASS wxText
+#define CB_UNBUNDLE objscheme_unbundle_wxText
+#define CB_USER "wx:text%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxTextCallbackToScheme
+#define CB_TOC wxTextCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+
+
+
+
+
+
+
+class os_wxText : public wxText {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxText(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, string x3 = "", int x4 = -1, int x5 = -1, int x6 = -1, int x7 = -1, long x8 = 0, string x9 = "text");
+  ~os_wxText();
+  void OnChar(class wxKeyEvent& x0);
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxText_class;
+
+os_wxText::os_wxText(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, string x3, int x4, int x5, int x6, int x7, long x8, string x9)
+: wxText(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxText::~os_wxText()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxText::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxText::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxText::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxText::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxText::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxText::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxText::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxText::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxText::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxText_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxText::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:text%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)->wxText::OnChar(*x0);
+  else
+    ((wxText *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSetEditable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:text%::set-editable");
+
+  
+  ((wxText *)((Scheme_Class_Object *)obj)->primdata)->SetEditable(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxText *)((Scheme_Class_Object *)obj)->primdata)->Paste();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextCut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxText *)((Scheme_Class_Object *)obj)->primdata)->Cut();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxText *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextSetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:text%::set-value");
+
+  
+  ((wxText *)((Scheme_Class_Object *)obj)->primdata)->SetValue(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextGetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxText *)((Scheme_Class_Object *)obj)->primdata)->GetValue();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:text%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:text%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxText *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:text%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:text%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxText *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)->wxText::OnSize(x0, x1);
+  else
+    ((wxText *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)->wxText::OnSetFocus();
+  else
+    ((wxText *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxText *)((Scheme_Class_Object *)obj)->primdata)->wxText::OnKillFocus();
+  else
+    ((wxText *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxText_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxText *realobj;
+  class wxPanel* x0;
+  wxFunction x1;
+  nstring x2;
+  string x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  long x8;
+  string x9;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n < 3) ||(n > 10)) 
+    scheme_wrong_count("wx:text%::initialization", 3, 10, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:text%::initialization", 0);
+  x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:text%::initialization");
+  if (n > 3) {
+    x3 = (string)objscheme_unbundle_string(p[3], "wx:text%::initialization");
+  } else
+    x3 = "";
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:text%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:text%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:text%::initialization");
+  } else
+    x6 = -1;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:text%::initialization");
+  } else
+    x7 = -1;
+  if (n > 8) {
+    x8 = objscheme_unbundle_integer(p[8], "wx:text%::initialization");
+  } else
+    x8 = 0;
+  if (n > 9) {
+    x9 = (string)objscheme_unbundle_string(p[9], "wx:text%::initialization");
+  } else
+    x9 = "text";
+
+  if (!x6) x6 = -1;if (!x7) x7 = -1;
+  realobj = new os_wxText(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:text%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:text%");
+}
+
+void objscheme_setup_wxText(void *env)
+{
+if (os_wxText_class) {
+    objscheme_add_global_class(os_wxText_class,  "wx:text%", env);
+} else {
+  os_wxText_class = objscheme_def_prim_class(env, "wx:text%", "wx:item%", os_wxText_ConstructScheme, 13);
+
+  scheme_add_method_w_arity(os_wxText_class,"get-class-name",objscheme_classname_os_wxText, 0, 0);
+
+ scheme_add_method_w_arity(os_wxText_class, "on-char", os_wxTextOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxText_class, "set-editable", os_wxTextSetEditable, 1, 1);
+ scheme_add_method_w_arity(os_wxText_class, "paste", os_wxTextPaste, 0, 0);
+ scheme_add_method_w_arity(os_wxText_class, "cut", os_wxTextCut, 0, 0);
+ scheme_add_method_w_arity(os_wxText_class, "copy", os_wxTextCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxText_class, "set-value", os_wxTextSetValue, 1, 1);
+ scheme_add_method_w_arity(os_wxText_class, "get-value", os_wxTextGetValue, 0, 0);
+ scheme_add_method_w_arity(os_wxText_class, "pre-on-event", os_wxTextPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxText_class, "pre-on-char", os_wxTextPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxText_class, "on-size", os_wxTextOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxText_class, "on-set-focus", os_wxTextOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxText_class, "on-kill-focus", os_wxTextOnKillFocus, 0, 0);
+
+
+  scheme_made_class(os_wxText_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxText, wxTYPE_TEXT);
+
+}
+}
+
+int objscheme_istype_wxText(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxText_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:text%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxText(class wxText *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_TEXT) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxText_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxText *objscheme_unbundle_wxText(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxText(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxText *)o->primdata;
+  else
+    return (wxText *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+
+
+
+#define CB_FUNCTYPE wxFunction 
+
+
+#undef CALLBACKCLASS
+#undef CB_REALCLASS
+#undef CB_UNBUNDLE
+#undef CB_USER
+
+#define CALLBACKCLASS os_wxMultiText
+#define CB_REALCLASS wxMultiText
+#define CB_UNBUNDLE objscheme_unbundle_wxMultiText
+#define CB_USER "wx:multi-text%::initialization"
+
+#undef CB_TOSCHEME
+#undef CB_TOC
+#define CB_TOSCHEME wxMultiTextCallbackToScheme
+#define CB_TOC wxMultiTextCallbackToC
+
+
+class CALLBACKCLASS;
+
+
+
+
+
+extern wxCommandEvent *objscheme_unbundle_wxCommandEvent(Scheme_Object *,const char *,int);
+extern Scheme_Object *objscheme_bundle_wxCommandEvent(wxCommandEvent *);
+
+static void CB_TOSCHEME(CB_REALCLASS *obj, wxCommandEvent &event);
+
+
+
+
+
+class os_wxMultiText : public wxMultiText {
+ public:
+  Scheme_Object *callback_closure;
+
+  os_wxMultiText(Scheme_Object * obj, class wxPanel* x0, wxFunction x1, nstring x2, string x3 = "", int x4 = -1, int x5 = -1, int x6 = -1, int x7 = -1, long x8 = 0, string x9 = "text");
+  ~os_wxMultiText();
+  void OnChar(class wxKeyEvent& x0);
+};
+
+Scheme_Object *os_wxMultiText_class;
+
+os_wxMultiText::os_wxMultiText(Scheme_Object * o, class wxPanel* x0, wxFunction x1, nstring x2, string x3, int x4, int x5, int x6, int x7, long x8, string x9)
+: wxMultiText(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxMultiText::~os_wxMultiText()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxMultiText::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxMultiText_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxMultiText::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMultiTextOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:multi-text%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxMultiText *)((Scheme_Class_Object *)obj)->primdata)->wxMultiText::OnChar(*x0);
+  else
+    ((wxMultiText *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMultiTextGetValue(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxMultiText *)((Scheme_Class_Object *)obj)->primdata)->GetValue();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxMultiText_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxMultiText *realobj;
+  class wxPanel* x0;
+  wxFunction x1;
+  nstring x2;
+  string x3;
+  int x4;
+  int x5;
+  int x6;
+  int x7;
+  long x8;
+  string x9;
+
+  Scheme_Object *tmp_callback = NULL;
+  if ((n < 3) ||(n > 10)) 
+    scheme_wrong_count("wx:multi-text%::initialization", 3, 10, n, p);
+  x0 = objscheme_unbundle_wxPanel(p[0], "wx:multi-text%::initialization", 0);
+  x1 = (SCHEME_NULLP(p[1]) ? NULL : (WXGC_IGNORE(tmp_callback), objscheme_istype_proc2(p[1], CB_USER), tmp_callback = p[1], (CB_FUNCTYPE)CB_TOSCHEME));
+  x2 = (nstring)objscheme_unbundle_nullable_string(p[2], "wx:multi-text%::initialization");
+  if (n > 3) {
+    x3 = (string)objscheme_unbundle_string(p[3], "wx:multi-text%::initialization");
+  } else
+    x3 = "";
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:multi-text%::initialization");
+  } else
+    x4 = -1;
+  if (n > 5) {
+    x5 = objscheme_unbundle_integer(p[5], "wx:multi-text%::initialization");
+  } else
+    x5 = -1;
+  if (n > 6) {
+    x6 = objscheme_unbundle_integer(p[6], "wx:multi-text%::initialization");
+  } else
+    x6 = -1;
+  if (n > 7) {
+    x7 = objscheme_unbundle_integer(p[7], "wx:multi-text%::initialization");
+  } else
+    x7 = -1;
+  if (n > 8) {
+    x8 = objscheme_unbundle_integer(p[8], "wx:multi-text%::initialization");
+  } else
+    x8 = 0;
+  if (n > 9) {
+    x9 = (string)objscheme_unbundle_string(p[9], "wx:multi-text%::initialization");
+  } else
+    x9 = "text";
+
+  if (!x6) x6 = -1;if (!x7) x7 = -1;
+  realobj = new os_wxMultiText(obj, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  
+  realobj->callback_closure = tmp_callback; objscheme_backpointer(&realobj->callback_closure);
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxMultiText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:multi-text%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:multi-text%");
+}
+
+void objscheme_setup_wxMultiText(void *env)
+{
+if (os_wxMultiText_class) {
+    objscheme_add_global_class(os_wxMultiText_class,  "wx:multi-text%", env);
+} else {
+  os_wxMultiText_class = objscheme_def_prim_class(env, "wx:multi-text%", "wx:text%", os_wxMultiText_ConstructScheme, 3);
+
+  scheme_add_method_w_arity(os_wxMultiText_class,"get-class-name",objscheme_classname_os_wxMultiText, 0, 0);
+
+ scheme_add_method_w_arity(os_wxMultiText_class, "on-char", os_wxMultiTextOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxMultiText_class, "get-value", os_wxMultiTextGetValue, 0, 0);
+
+
+  scheme_made_class(os_wxMultiText_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxMultiText, wxTYPE_MULTI_TEXT);
+
+}
+}
+
+int objscheme_istype_wxMultiText(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxMultiText_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:multi-text%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxMultiText(class wxMultiText *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_MULTI_TEXT) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxMultiText_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxMultiText *objscheme_unbundle_wxMultiText(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxMultiText(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxMultiText *)o->primdata;
+  else
+    return (wxMultiText *)o->primdata;
+}
+
+
+
+
+static void CB_TOSCHEME(CB_REALCLASS *realobj, wxCommandEvent &event)
+{
+  Scheme_Object *p[2];
+  Scheme_Class_Object *obj;
+  jmp_buf savebuf;
+
+  obj = (Scheme_Class_Object *)realobj->__gc_external;
+
+  if (!obj) {
+    // scheme_signal_error("bad callback object");
+    return;
+  }
+
+  p[0] = (Scheme_Object *)obj;
+  p[1] = objscheme_bundle_wxCommandEvent(&event);
+
+  COPY_JMPBUF(savebuf, scheme_error_buf);
+
+  if (!scheme_setjmp(scheme_error_buf)) {
+    scheme_apply(((CALLBACKCLASS *)obj->primdata)->callback_closure, 2, p);
+  }
+
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+}
+
+
+
+
+
+// @ "get-line-text" : int GetLineText(int, string);
+
+
+
+
+
+
+
+// @ "<<" : void operator<<(string);
+// @ "<<" : void operator<<(int);
+// @ "<<" : void operator<<(float);
+// @ "<<" : void operator<<(char);
+
+class os_wxTextWindow : public wxTextWindow {
+ public:
+
+  os_wxTextWindow(Scheme_Object * obj, class wxFrame* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "textWindow");
+  os_wxTextWindow(Scheme_Object * obj, class wxPanel* x0, int x1 = -1, int x2 = -1, int x3 = -1, int x4 = -1, long x5 = 0, string x6 = "textWindow");
+  ~os_wxTextWindow();
+  void OnChar(class wxKeyEvent& x0);
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxTextWindow_class;
+
+os_wxTextWindow::os_wxTextWindow(Scheme_Object * o, class wxFrame* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxTextWindow(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxTextWindow::os_wxTextWindow(Scheme_Object * o, class wxPanel* x0, int x1, int x2, int x3, int x4, long x5, string x6)
+: wxTextWindow(x0, x1, x2, x3, x4, x5, x6)
+{
+  __gc_external = (void *)o;
+  objscheme_backpointer(&__gc_external);
+  objscheme_note_creation(o);
+}
+
+os_wxTextWindow::~os_wxTextWindow()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+void os_wxTextWindow::OnChar(class wxKeyEvent& x0)
+{
+  Scheme_Object *p[1];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextWindow::OnChar(x0);
+  } else {
+  
+  p[0] = objscheme_bundle_wxKeyEvent(&x0);
+  
+
+  v = scheme_apply(method, 1, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+Bool os_wxTextWindow::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text-window%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxTextWindow::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:text-window%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxTextWindow::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextWindow::OnSize(x0, x1);
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextWindow::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextWindow::OnSetFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxTextWindow::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxTextWindow_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    wxTextWindow::OnKillFocus();
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxKeyEvent* x0;
+
+  
+  x0 = objscheme_unbundle_wxKeyEvent(p[0], "wx:text-window%::on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->wxTextWindow::OnChar(*x0);
+  else
+    ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->OnChar(*x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:text-window%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:text-window%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnEvent(x0, x1);
+  else
+    r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:text-window%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:text-window%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)-> wxWindow::PreOnChar(x0, x1);
+  else
+    r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->wxTextWindow::OnSize(x0, x1);
+  else
+    ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->wxTextWindow::OnSetFocus();
+  else
+    ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->wxTextWindow::OnKillFocus();
+  else
+    ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowWriteText(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:text-window%::write-text");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->WriteText(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowShowPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::show-position");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->ShowPosition(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowSetInsertionPointEnd(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->SetInsertionPointEnd();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowSetInsertionPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::set-insertion-point");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->SetInsertionPoint(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowSetFont(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  class wxFont* x0;
+
+  
+  x0 = objscheme_unbundle_wxFont(p[0], "wx:text-window%::set-font", 0);
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->SetFont(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowReplace(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+  string x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::replace");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::replace");
+  x2 = (string)objscheme_unbundle_string(p[2], "wx:text-window%::replace");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Replace(x0, x1, x2);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowRemove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::remove");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::remove");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Remove(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowXYToPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::x-y-to-position");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::x-y-to-position");
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->XYToPosition(x0, x1);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowPositionToXY(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long _x1;
+  long* x1 = &_x1;
+  long _x2;
+  long* x2 = &_x2;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::position-to-x-y");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:text-window%::position-to-x-y", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:text-window%::position-to-x-y"), "wx:text-window%::position-to-x-y");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:text-window%::position-to-x-y", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_integer(objscheme_unbox(p[2], "wx:text-window%::position-to-x-y"), "wx:text-window%::position-to-x-y");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->PositionToXY(x0, x1, x2);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_integer(_x2));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowModified(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Modified();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowSaveFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  pathname x0;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "wx:text-window%::save-file");
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->SaveFile(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowLoadFile(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  pathname x0;
+
+  
+  x0 = (pathname)objscheme_unbundle_pathname(p[0], "wx:text-window%::load-file");
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->LoadFile(x0);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowSetSelection(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  long x0;
+  long x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::set-selection");
+  x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::set-selection");
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->SetSelection(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowGetNumberOfLines(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->GetNumberOfLines();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowGetLineLength(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:text-window%::get-line-length");
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->GetLineLength(x0);
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowGetLastPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->GetLastPosition();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowGetInsertionPoint(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  long r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->GetInsertionPoint();
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowGetContents(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->GetContents();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowDiscardEdits(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->DiscardEdits();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowPaste(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Paste();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowCut(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Cut();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowCopy(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Copy();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowClear(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->Clear();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindowPopupMenu(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxMenu* x0;
+  float x1;
+  float x2;
+
+  
+  x0 = objscheme_unbundle_wxMenu(p[0], "wx:text-window%::popup-menu", 0);
+  x1 = objscheme_unbundle_float(p[1], "wx:text-window%::popup-menu");
+  x2 = objscheme_unbundle_float(p[2], "wx:text-window%::popup-menu");
+
+  
+  r = ((wxTextWindow *)((Scheme_Class_Object *)obj)->primdata)->PopupMenu(x0, x1, x2);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxTextWindow_ConstructScheme(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+  os_wxTextWindow *realobj;
+  if ((n >= 1) && objscheme_istype_wxPanel(p[0], NULL, 0)) {
+    class wxPanel* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:text-window%::initialization (panel case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxPanel(p[0], "wx:text-window%::initialization (panel case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::initialization (panel case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:text-window%::initialization (panel case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:text-window%::initialization (panel case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:text-window%::initialization (panel case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:text-window%::initialization (panel case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:text-window%::initialization (panel case)");
+    } else
+      x6 = "textWindow";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxTextWindow(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  } else  {
+    class wxFrame* x0;
+    int x1;
+    int x2;
+    int x3;
+    int x4;
+    long x5;
+    string x6;
+
+    
+    if ((n < 1) ||(n > 7)) 
+      scheme_wrong_count("wx:text-window%::initialization (frame case)", 1, 7, n, p);
+    x0 = objscheme_unbundle_wxFrame(p[0], "wx:text-window%::initialization (frame case)", 0);
+    if (n > 1) {
+      x1 = objscheme_unbundle_integer(p[1], "wx:text-window%::initialization (frame case)");
+    } else
+      x1 = -1;
+    if (n > 2) {
+      x2 = objscheme_unbundle_integer(p[2], "wx:text-window%::initialization (frame case)");
+    } else
+      x2 = -1;
+    if (n > 3) {
+      x3 = objscheme_unbundle_integer(p[3], "wx:text-window%::initialization (frame case)");
+    } else
+      x3 = -1;
+    if (n > 4) {
+      x4 = objscheme_unbundle_integer(p[4], "wx:text-window%::initialization (frame case)");
+    } else
+      x4 = -1;
+    if (n > 5) {
+      x5 = objscheme_unbundle_integer(p[5], "wx:text-window%::initialization (frame case)");
+    } else
+      x5 = 0;
+    if (n > 6) {
+      x6 = (string)objscheme_unbundle_string(p[6], "wx:text-window%::initialization (frame case)");
+    } else
+      x6 = "textWindow";
+
+    if (!x3) x3 = -1;if (!x4) x4 = -1;
+    realobj = new os_wxTextWindow(obj, x0, x1, x2, x3, x4, x5, x6);
+    
+    
+  }
+
+  ((Scheme_Class_Object *)obj)->primdata = realobj;
+  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)->primdata);
+  ((Scheme_Class_Object *)obj)->primflag = 1;
+  return obj;
+}
+
+static Scheme_Object *objscheme_classname_os_wxTextWindow(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:text-window%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:text-window%");
+}
+
+void objscheme_setup_wxTextWindow(void *env)
+{
+if (os_wxTextWindow_class) {
+    objscheme_add_global_class(os_wxTextWindow_class,  "wx:text-window%", env);
+} else {
+  os_wxTextWindow_class = objscheme_def_prim_class(env, "wx:text-window%", "wx:window%", os_wxTextWindow_ConstructScheme, 31);
+
+  scheme_add_method_w_arity(os_wxTextWindow_class,"get-class-name",objscheme_classname_os_wxTextWindow, 0, 0);
+
+ scheme_add_method_w_arity(os_wxTextWindow_class, "on-char", os_wxTextWindowOnChar, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "pre-on-event", os_wxTextWindowPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "pre-on-char", os_wxTextWindowPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "on-size", os_wxTextWindowOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "on-set-focus", os_wxTextWindowOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "on-kill-focus", os_wxTextWindowOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "write-text", os_wxTextWindowWriteText, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "show-position", os_wxTextWindowShowPosition, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "set-insertion-point-end", os_wxTextWindowSetInsertionPointEnd, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "set-insertion-point", os_wxTextWindowSetInsertionPoint, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "set-font", os_wxTextWindowSetFont, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "replace", os_wxTextWindowReplace, 3, 3);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "remove", os_wxTextWindowRemove, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "x-y-to-position", os_wxTextWindowXYToPosition, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "position-to-x-y", os_wxTextWindowPositionToXY, 3, 3);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "modified?", os_wxTextWindowModified, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "save-file", os_wxTextWindowSaveFile, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "load-file", os_wxTextWindowLoadFile, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "set-selection", os_wxTextWindowSetSelection, 2, 2);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "get-number-of-lines", os_wxTextWindowGetNumberOfLines, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "get-line-length", os_wxTextWindowGetLineLength, 1, 1);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "get-last-position", os_wxTextWindowGetLastPosition, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "get-insertion-point", os_wxTextWindowGetInsertionPoint, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "get-contents", os_wxTextWindowGetContents, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "discard-edits", os_wxTextWindowDiscardEdits, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "paste", os_wxTextWindowPaste, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "cut", os_wxTextWindowCut, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "copy", os_wxTextWindowCopy, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "clear", os_wxTextWindowClear, 0, 0);
+ scheme_add_method_w_arity(os_wxTextWindow_class, "popup-menu", os_wxTextWindowPopupMenu, 3, 3);
+
+
+  scheme_made_class(os_wxTextWindow_class);
+
+  objscheme_install_bundler((Objscheme_Bundler)objscheme_bundle_wxTextWindow, wxTYPE_TEXT_WINDOW);
+
+}
+}
+
+int objscheme_istype_wxTextWindow(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxTextWindow_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:text-window%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxTextWindow(class wxTextWindow *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((realobj->__type != wxTYPE_TEXT_WINDOW) && (sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxTextWindow_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxTextWindow *objscheme_unbundle_wxTextWindow(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxTextWindow(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxTextWindow *)o->primdata;
+  else
+    return (wxTextWindow *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_text.h b/src/mred/wxs/wxs_text.h
new file mode 100644
index 0000000..f0ab2d7
--- /dev/null
+++ b/src/mred/wxs/wxs_text.h
@@ -0,0 +1,49 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxText(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxText(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxText(class wxText *realobj);
+class wxText *objscheme_unbundle_wxText(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxMultiText(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxMultiText(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxMultiText(class wxMultiText *realobj);
+class wxMultiText *objscheme_unbundle_wxMultiText(Scheme_Object *obj, const char *where, int nullOK);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern class wxMenu *objscheme_unbundle_wxMenu(Scheme_Object *, const char *, int);
+extern int objscheme_istype_wxPanel(Scheme_Object *, const char *, int);
+extern class wxPanel *objscheme_unbundle_wxPanel(Scheme_Object *, const char *, int);
+extern class wxFrame *objscheme_unbundle_wxFrame(Scheme_Object *, const char *, int);
+#endif
+void objscheme_setup_wxTextWindow(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxTextWindow(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxTextWindow(class wxTextWindow *realobj);
+class wxTextWindow *objscheme_unbundle_wxTextWindow(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_text.xc b/src/mred/wxs/wxs_text.xc
new file mode 100644
index 0000000..46b4c64
--- /dev/null
+++ b/src/mred/wxs/wxs_text.xc
@@ -0,0 +1,104 @@
+
+@INCLUDE prefix.xci
+
+#include "wx_item.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_text.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+@CLASSBASE wxText "wx:text":"wx:item"
+
+@CLASSID wxTYPE_TEXT
+
+@SET CALLBACK_CLASS = wxText
+@SET CALLBACK_CLASS_USER = "wx:text%::initialization"
+@INCLUDE cb_start.xci
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,string="",int=-1,int=-1,int=-1,int=-1,long=0,string="text"); : : ubCallbackSetup/NOZERO[6]|NOZERO[7]//ubCallbackCreatorFinish
+
+@INCLUDE wxs_item.xci
+
+@ "get-value" : string GetValue();
+@ "set-value" : void SetValue(string);
+
+@ "copy" : void Copy();
+@ "cut" : void Cut();
+@ "paste" : void Paste();
+@ "set-editable" : void SetEditable(bool);
+
+@SETMARK c = d
+@INCLUDE wxs_char.xci
+
+@END
+
+@INCLUDE cb_end.xci
+
+@CLASSBASE wxMultiText "wx:multi-text":"wx:text"
+
+@CLASSID wxTYPE_MULTI_TEXT
+
+@SET CALLBACK_CLASS = wxMultiText
+@SET CALLBACK_CLASS_USER = "wx:multi-text%::initialization"
+@INCLUDE cb_start.xci
+
+@CREATOR (wxPanel!,wxFunction/bCallback/ubCallback/cCallback//spCallback,nstring,string="",int=-1,int=-1,int=-1,int=-1,long=0,string="text"); : : ubCallbackSetup/NOZERO[6]|NOZERO[7]//ubCallbackCreatorFinish
+
+@ "get-value" : string GetValue();
+
+@SETMARK c = d
+@INCLUDE wxs_char.xci
+
+@END
+
+@INCLUDE cb_end.xci
+
+@CLASSBASE wxTextWindow "wx:text-window" : "wx:window"
+
+@CLASSID wxTYPE_TEXT_WINDOW
+
+@CREATOR (wxFrame!,int=-1,int=-1,int=-1,int=-1,long=0,string="textWindow");: : /NOZERO[3]|NOZERO[4] <> frame
+@CREATOR (wxPanel!,int=-1,int=-1,int=-1,int=-1,long=0,string="textWindow");: : /NOZERO[3]|NOZERO[4] <> panel
+
+@ "popup-menu" : bool PopupMenu(wxMenu!, float, float);
+
+@ "clear" : void Clear();
+@ "copy" : void Copy();
+@ "cut" : void Cut();
+@ "paste" : void Paste();
+@ "discard-edits" : void DiscardEdits();
+@ "get-contents" : string GetContents();
+@ "get-insertion-point" : long GetInsertionPoint();
+@ "get-last-position" : long GetLastPosition();
+@ "get-line-length" : long GetLineLength(int);
+// @ "get-line-text" : int GetLineText(int, string);
+@ "get-number-of-lines" : int GetNumberOfLines();
+@ "set-selection" : void SetSelection(long,long);
+@ "load-file" : bool LoadFile(pathname);
+@ "save-file" : bool SaveFile(pathname);
+@ "modified?" : bool Modified();
+@ "position-to-x-y" : void PositionToXY(long,long*,long*);
+@ "x-y-to-position" : long XYToPosition(long,long);
+@ "remove" : void Remove(long,long);
+@ "replace" : void Replace(long,long,string);
+@ "set-font" : void SetFont(wxFont!);
+@ "set-insertion-point" : void SetInsertionPoint(long);
+@ "set-insertion-point-end" : void SetInsertionPointEnd();
+@ "show-position" : void ShowPosition(long);
+@ "write-text" : void WriteText(string);
+
+@SETMARK w = d
+@INCLUDE wxs_win.xci
+
+@SETMARK c = d
+@INCLUDE wxs_char.xci
+
+// @ "<<" : void operator<<(string);
+// @ "<<" : void operator<<(int);
+// @ "<<" : void operator<<(float);
+// @ "<<" : void operator<<(char);
+
+@END
diff --git a/src/mred/wxs/wxs_win.cxx b/src/mred/wxs/wxs_win.cxx
new file mode 100644
index 0000000..3884ef0
--- /dev/null
+++ b/src/mred/wxs/wxs_win.cxx
@@ -0,0 +1,1090 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxs_win.xc". */
+
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#include "wx_win.h"
+#include "wx_gdi.h"
+
+
+
+
+
+#include "wxscheme.h"
+#include "wxs_win.h"
+#include "wxscomon.h"
+
+
+
+#ifdef wx_mac
+#define Move(x, y) SetSize(-1, -1, x, y)
+#endif
+
+#if defined(wx_xt)
+#define wxPOS_USE_MINUS_ONE 0
+#endif
+
+static int wxSchemeWindowGetWidth(wxWindow *w)
+{
+  int x, y;
+
+  w->GetSize(&x, &y);
+  
+  return x;
+}
+
+static int wxSchemeWindowGetHeight(wxWindow *w)
+{
+  int x, y;
+
+  w->GetSize(&x, &y);
+  
+  return y;
+}
+
+static int wxSchemeWindowGetX(wxWindow *w)
+{
+  int x, y;
+
+  w->GetPosition(&x, &y);
+  
+  return x;
+}
+
+static int wxSchemeWindowGetY(wxWindow *w)
+{
+  int x, y;
+
+  w->GetPosition(&x, &y);
+  
+  return y;
+}
+
+
+// @CREATOR ();
+
+
+
+// @ "make-modal" : void MakeModal(bool);
+// @ "set-client-size" : void SetClientSize(int,int); : : /NOZERO[0]|NOZERO[1]
+// @ "set-colour-map" : void SetColourMap(wxColourMap!);
+
+
+// Destruction not allowed in wxScheme:
+// @ "destroy-children" : void DestroyChildren();
+// @ "drag-accept-files" : void DragAcceptFiles(bool);
+// @ "add-child" : void AddChild(wxWindow!);
+// @ "capture-mouse" : void CaptureMouse();
+// @ "release-mouse" : void ReleaseMouse();
+// @ "get-children" : wxList! GetChildren();
+
+
+
+
+
+
+
+
+
+class os_wxWindow : public wxWindow {
+ public:
+
+  ~os_wxWindow();
+  Bool PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1);
+  Bool PreOnChar(class wxWindow* x0, class wxKeyEvent* x1);
+  void OnSize(int x0, int x1);
+  void OnSetFocus();
+  void OnKillFocus();
+};
+
+Scheme_Object *os_wxWindow_class;
+
+os_wxWindow::~os_wxWindow()
+{
+    objscheme_destroy(this, (Scheme_Object *)__gc_external);
+}
+
+Bool os_wxWindow::PreOnEvent(class wxWindow* x0, class wxMouseEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxWindow_class, "pre-on-event", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxMouseEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:window%::pre-on-event"", extracting return value");
+  }
+}
+
+Bool os_wxWindow::PreOnChar(class wxWindow* x0, class wxKeyEvent* x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxWindow_class, "pre-on-char", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return FALSE;
+  } else {
+  
+  p[0] = objscheme_bundle_wxWindow(x0);
+  p[1] = objscheme_bundle_wxKeyEvent(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  return objscheme_unbundle_bool(v, "wx:window%::pre-on-char"", extracting return value");
+  }
+}
+
+void os_wxWindow::OnSize(int x0, int x1)
+{
+  Scheme_Object *p[2];
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxWindow_class, "on-size", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  p[0] = scheme_make_integer(x0);
+  p[1] = scheme_make_integer(x1);
+  
+
+  v = scheme_apply(method, 2, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxWindow::OnSetFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxWindow_class, "on-set-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+void os_wxWindow::OnKillFocus()
+{
+  Scheme_Object **p = NULL;
+  Scheme_Object *v;
+  jmp_buf savebuf;
+  Scheme_Object *method;
+  int sj;
+  static void *mcache = 0;
+
+  method = objscheme_find_method((Scheme_Object *)__gc_external, os_wxWindow_class, "on-kill-focus", &mcache);
+  if (method && !OBJSCHEME_PRIM_METHOD(method)) {
+    COPY_JMPBUF(savebuf, scheme_error_buf);
+    sj = scheme_setjmp(scheme_error_buf);
+  } else sj = 1;
+  if (sj) {
+    if (method && !OBJSCHEME_PRIM_METHOD(method))
+      COPY_JMPBUF(scheme_error_buf, savebuf);
+    return;
+  } else {
+  
+  
+
+  v = scheme_apply(method, 0, p);
+  
+  
+  COPY_JMPBUF(scheme_error_buf, savebuf);
+
+  }
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowPreOnEvent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxMouseEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:window%::pre-on-event", 0);
+  x1 = objscheme_unbundle_wxMouseEvent(p[1], "wx:window%::pre-on-event", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+  else
+    r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnEvent(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowPreOnChar(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+  class wxWindow* x0;
+  class wxKeyEvent* x1;
+
+  
+  x0 = objscheme_unbundle_wxWindow(p[0], "wx:window%::pre-on-char", 0);
+  x1 = objscheme_unbundle_wxKeyEvent(p[1], "wx:window%::pre-on-char", 0);
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    r = ((os_wxWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+  else
+    r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->PreOnChar(x0, x1);
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowOnSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:window%::on-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:window%::on-size");
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+  else
+    ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSize(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowOnSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+  else
+    ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnSetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowOnKillFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  if (((Scheme_Class_Object *)obj)->primflag)
+    ((os_wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+  else
+    ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->OnKillFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowwxSchemeWindowGetY(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = wxSchemeWindowGetY(((wxWindow *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowwxSchemeWindowGetX(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = wxSchemeWindowGetX(((wxWindow *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowwxSchemeWindowGetWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = wxSchemeWindowGetWidth(((wxWindow *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowwxSchemeWindowGetHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  int r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = wxSchemeWindowGetHeight(((wxWindow *)((Scheme_Class_Object *)obj)->primdata));
+
+  
+  
+  return scheme_make_integer(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowCenter(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:window%::center");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Center(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetLabel(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  string r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetLabel();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetGrandParent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxWindow* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetGrandParent();
+
+  
+  
+  return objscheme_bundle_wxWindow(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetTextExtent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  string x0;
+  float _x1;
+  float* x1 = &_x1;
+  float _x2;
+  float* x2 = &_x2;
+  float _x3;
+  float* x3 = &_x3;
+  float _x4;
+  float* x4 = &_x4;
+  class wxFont* x5;
+  Bool x6;
+
+  
+  x0 = (string)objscheme_unbundle_string(p[0], "wx:window%::get-text-extent");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::get-text-extent", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_float(objscheme_unbox(p[1], "wx:window%::get-text-extent"), "wx:window%::get-text-extent");
+  if (SCHEME_NULLP(p[2]))
+    scheme_wrong_type("wx:window%::get-text-extent", "non-null", (2 - 0), n, p);
+  else
+    *x2 = objscheme_unbundle_float(objscheme_unbox(p[2], "wx:window%::get-text-extent"), "wx:window%::get-text-extent");
+  if (n > 3) {
+    if (SCHEME_NULLP(p[3]))
+    x3 = NULL;
+  else
+    *x3 = objscheme_unbundle_float(objscheme_unbox(p[3], "wx:window%::get-text-extent"), "wx:window%::get-text-extent");
+  } else
+    x3 = NULL;
+  if (n > 4) {
+    if (SCHEME_NULLP(p[4]))
+    x4 = NULL;
+  else
+    *x4 = objscheme_unbundle_float(objscheme_unbox(p[4], "wx:window%::get-text-extent"), "wx:window%::get-text-extent");
+  } else
+    x4 = NULL;
+  if (n > 5) {
+    x5 = objscheme_unbundle_wxFont(p[5], "wx:window%::get-text-extent", 1);
+  } else
+    x5 = NULL;
+  if (n > 6) {
+    x6 = objscheme_unbundle_bool(p[6], "wx:window%::get-text-extent");
+  } else
+    x6 = FALSE;
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetTextExtent(x0, x1, x2, x3, x4, x5, x6);
+
+  
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_double(_x1));
+  if (n > 2)
+    objscheme_set_box(p[2], scheme_make_double(_x2));
+  if (n > 3 && !SCHEME_NULLP(p[3]))
+    objscheme_set_box(p[3], scheme_make_double(_x3));
+  if (n > 4 && !SCHEME_NULLP(p[4]))
+    objscheme_set_box(p[4], scheme_make_double(_x4));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetParent(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxWindow* r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetParent();
+
+  
+  
+  return objscheme_bundle_wxWindow(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowRefresh(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Refresh();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowScreenToClient(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:window%::screen-to-client", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:window%::screen-to-client"), "wx:window%::screen-to-client");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::screen-to-client", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:window%::screen-to-client"), "wx:window%::screen-to-client");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->ScreenToClient(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowClientToScreen(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:window%::client-to-screen", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:window%::client-to-screen"), "wx:window%::client-to-screen");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::client-to-screen", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:window%::client-to-screen"), "wx:window%::client-to-screen");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->ClientToScreen(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetCharWidth(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetCharWidth();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetCharHeight(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  float r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetCharHeight();
+
+  
+  
+  return scheme_make_double(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetName(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  nstring r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetName();
+
+  
+  
+  return objscheme_bundle_string((char *)r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowEnable(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:window%::enable");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Enable(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetPosition(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:window%::get-position", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:window%::get-position"), "wx:window%::get-position");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::get-position", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:window%::get-position"), "wx:window%::get-position");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetPosition(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetClientSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:window%::get-client-size", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:window%::get-client-size"), "wx:window%::get-client-size");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::get-client-size", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:window%::get-client-size"), "wx:window%::get-client-size");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetClientSize(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowGetSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int _x0;
+  int* x0 = &_x0;
+  int _x1;
+  int* x1 = &_x1;
+
+  
+  if (SCHEME_NULLP(p[0]))
+    scheme_wrong_type("wx:window%::get-size", "non-null", (0 - 0), n, p);
+  else
+    *x0 = objscheme_unbundle_integer(objscheme_unbox(p[0], "wx:window%::get-size"), "wx:window%::get-size");
+  if (SCHEME_NULLP(p[1]))
+    scheme_wrong_type("wx:window%::get-size", "non-null", (1 - 0), n, p);
+  else
+    *x1 = objscheme_unbundle_integer(objscheme_unbox(p[1], "wx:window%::get-size"), "wx:window%::get-size");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->GetSize(x0, x1);
+
+  
+  if (n > 0)
+    objscheme_set_box(p[0], scheme_make_integer(_x0));
+  if (n > 1)
+    objscheme_set_box(p[1], scheme_make_integer(_x1));
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowFit(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Fit();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowIsShown(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  Bool r;
+  objscheme_check_valid(obj);
+
+  
+
+  
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->IsShown();
+
+  
+  
+  return (r ? scheme_true : scheme_false);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowShow(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  Bool x0;
+
+  
+  x0 = objscheme_unbundle_bool(p[0], "wx:window%::show");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Show(x0);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowSetCursor(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  class wxCursor* r;
+  objscheme_check_valid(obj);
+  class wxCursor* x0;
+
+  
+  x0 = objscheme_unbundle_wxCursor(p[0], "wx:window%::set-cursor", 0);
+
+  if (x0 && !x0->Ok()) x0 = wxSTANDARD_CURSOR;
+  r = ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->SetCursor(x0);
+
+  
+  
+  return objscheme_bundle_wxCursor(r);
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowMove(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:window%::move");
+  x1 = objscheme_unbundle_integer(p[1], "wx:window%::move");
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Move(x0, x1);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowSetSize(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+  int x1;
+  int x2;
+  int x3;
+  int x4;
+
+  
+  x0 = objscheme_unbundle_integer(p[0], "wx:window%::set-size");
+  x1 = objscheme_unbundle_integer(p[1], "wx:window%::set-size");
+  x2 = objscheme_unbundle_integer(p[2], "wx:window%::set-size");
+  x3 = objscheme_unbundle_integer(p[3], "wx:window%::set-size");
+  if (n > 4) {
+    x4 = objscheme_unbundle_integer(p[4], "wx:window%::set-size");
+  } else
+    x4 = wxSIZE_AUTO;
+
+  if (!x2) x2 = -1;if (!x3) x3 = -1;
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->SetSize(x0, x1, x2, x3, x4);
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowSetFocus(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+
+  
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->SetFocus();
+
+  
+  
+  return scheme_void;
+}
+
+#pragma argsused
+static Scheme_Object *os_wxWindowCentre(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)
+  objscheme_check_valid(obj);
+  int x0;
+
+  
+  if (n > 0) {
+    x0 = objscheme_unbundle_integer(p[0], "wx:window%::centre");
+  } else
+    x0 = wxBOTH;
+
+  
+  ((wxWindow *)((Scheme_Class_Object *)obj)->primdata)->Centre(x0);
+
+  
+  
+  return scheme_void;
+}
+
+static Scheme_Object *objscheme_classname_os_wxWindow(Scheme_Object *obj, int n,  Scheme_Object *p[])
+{
+ WXS_USE_ARGUMENT(obj);
+  if (n) scheme_wrong_count("wx:window%" "::get-class-name", 0, 0, n, p);
+  return scheme_intern_symbol("wx:window%");
+}
+
+void objscheme_setup_wxWindow(void *env)
+{
+if (os_wxWindow_class) {
+    objscheme_add_global_class(os_wxWindow_class,  "wx:window%", env);
+} else {
+  os_wxWindow_class = objscheme_def_prim_class(env, "wx:window%", "wx:object%", NULL, 33);
+
+  scheme_add_method_w_arity(os_wxWindow_class,"get-class-name",objscheme_classname_os_wxWindow, 0, 0);
+
+ scheme_add_method_w_arity(os_wxWindow_class, "pre-on-event", os_wxWindowPreOnEvent, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "pre-on-char", os_wxWindowPreOnChar, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "on-size", os_wxWindowOnSize, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "on-set-focus", os_wxWindowOnSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "on-kill-focus", os_wxWindowOnKillFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-y", os_wxWindowwxSchemeWindowGetY, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-x", os_wxWindowwxSchemeWindowGetX, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-width", os_wxWindowwxSchemeWindowGetWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-height", os_wxWindowwxSchemeWindowGetHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "center", os_wxWindowCenter, 1, 1);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-label", os_wxWindowGetLabel, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-grand-parent", os_wxWindowGetGrandParent, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-text-extent", os_wxWindowGetTextExtent, 3, 7);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-parent", os_wxWindowGetParent, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "refresh", os_wxWindowRefresh, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "screen-to-client", os_wxWindowScreenToClient, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "client-to-screen", os_wxWindowClientToScreen, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-char-width", os_wxWindowGetCharWidth, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-char-height", os_wxWindowGetCharHeight, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-name", os_wxWindowGetName, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "enable", os_wxWindowEnable, 1, 1);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-position", os_wxWindowGetPosition, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-client-size", os_wxWindowGetClientSize, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "get-size", os_wxWindowGetSize, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "fit", os_wxWindowFit, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "is-shown?", os_wxWindowIsShown, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "show", os_wxWindowShow, 1, 1);
+ scheme_add_method_w_arity(os_wxWindow_class, "set-cursor", os_wxWindowSetCursor, 1, 1);
+ scheme_add_method_w_arity(os_wxWindow_class, "move", os_wxWindowMove, 2, 2);
+ scheme_add_method_w_arity(os_wxWindow_class, "set-size", os_wxWindowSetSize, 4, 5);
+ scheme_add_method_w_arity(os_wxWindow_class, "set-focus", os_wxWindowSetFocus, 0, 0);
+ scheme_add_method_w_arity(os_wxWindow_class, "centre", os_wxWindowCentre, 0, 1);
+
+
+  scheme_made_class(os_wxWindow_class);
+
+
+}
+  scheme_install_xc_global("wx:const-size-auto", scheme_make_integer(wxSIZE_AUTO), env);
+  scheme_install_xc_global("wx:const-size-auto-width", scheme_make_integer(wxSIZE_AUTO_WIDTH), env);
+  scheme_install_xc_global("wx:const-size-auto-height", scheme_make_integer(wxSIZE_AUTO_HEIGHT), env);
+  scheme_install_xc_global("wx:const-size-use-exsiting", scheme_make_integer(wxSIZE_USE_EXISTING), env);
+  scheme_install_xc_global("wx:const-pos-use-minus-one", scheme_make_integer(wxPOS_USE_MINUS_ONE), env);
+}
+
+int objscheme_istype_wxWindow(Scheme_Object *obj, const char *stop, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return 1;
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+      && scheme_is_subclass(((Scheme_Class_Object *)obj)->sclass,          os_wxWindow_class))
+    return 1;
+  else {
+    if (!stop)
+       return 0;
+    scheme_wrong_type(stop, "wx:window%", -1, 0, &obj);
+    return 0;
+  }
+}
+
+Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *realobj)
+{
+  Scheme_Class_Object *obj;
+  Scheme_Object *sobj;
+
+  if (!realobj) return scheme_null;
+
+  if (realobj->__gc_external)
+    return (Scheme_Object *)realobj->__gc_external;
+  if ((sobj = objscheme_bundle_by_type(realobj, realobj->__type)))
+    return sobj;
+  obj = (Scheme_Class_Object *)scheme_make_uninited_object(os_wxWindow_class);
+
+  obj->primdata = realobj;
+  objscheme_register_primpointer(&obj->primdata);
+  obj->primflag = 0;
+
+  realobj->__gc_external = (void *)obj;
+  objscheme_backpointer(&realobj->__gc_external);
+  return (Scheme_Object *)obj;
+}
+
+class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *obj, const char *where, int nullOK)
+{
+  if (nullOK && SCHEME_NULLP(obj)) return NULL;
+
+  (void)objscheme_istype_wxWindow(obj, where, nullOK);
+  Scheme_Class_Object *o = (Scheme_Class_Object *)obj;
+  objscheme_check_valid(obj);
+  if (o->primflag)
+    return (os_wxWindow *)o->primdata;
+  else
+    return (wxWindow *)o->primdata;
+}
+
diff --git a/src/mred/wxs/wxs_win.h b/src/mred/wxs/wxs_win.h
new file mode 100644
index 0000000..1fda169
--- /dev/null
+++ b/src/mred/wxs/wxs_win.h
@@ -0,0 +1,21 @@
+#ifndef WXS_SETUP_ONLY
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxMouseEvent(class wxMouseEvent *);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern Scheme_Object *objscheme_bundle_wxKeyEvent(class wxKeyEvent *);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxMouseEvent *objscheme_unbundle_wxMouseEvent(Scheme_Object *, const char *, int);
+extern class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *, const char *, int);
+extern class wxKeyEvent *objscheme_unbundle_wxKeyEvent(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern class wxFont *objscheme_unbundle_wxFont(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *);
+extern class wxCursor *objscheme_unbundle_wxCursor(Scheme_Object *, const char *, int);
+extern Scheme_Object *objscheme_bundle_wxCursor(class wxCursor *);
+#endif
+void objscheme_setup_wxWindow(void *env);
+#ifndef WXS_SETUP_ONLY
+int objscheme_istype_wxWindow(Scheme_Object *obj, const char *stop, int nullOK);
+Scheme_Object *objscheme_bundle_wxWindow(class wxWindow *realobj);
+class wxWindow *objscheme_unbundle_wxWindow(Scheme_Object *obj, const char *where, int nullOK);
+#endif
diff --git a/src/mred/wxs/wxs_win.xc b/src/mred/wxs/wxs_win.xc
new file mode 100644
index 0000000..8c50963
--- /dev/null
+++ b/src/mred/wxs/wxs_win.xc
@@ -0,0 +1,132 @@
+
+@INCLUDE prefix.xci 
+
+#include "wx_win.h"
+#include "wx_gdi.h"
+
+@INCLUDE wxs.xci
+
+@HEADER
+
+#if 0
+#ifndef wx_mac
+#define HAS_EDIT_MODE 1
+#else
+#define HAS_EDIT_MODE 0
+#endif
+#else
+#define HAS_EDIT_MODE 0
+#endif
+
+#ifdef wx_mac
+#define Move(x, y) SetSize(-1, -1, x, y)
+#endif
+
+#if defined(wx_xt)
+#define wxPOS_USE_MINUS_ONE 0
+#endif
+
+static int wxSchemeWindowGetWidth(wxWindow *w)
+{
+  int x, y;
+
+  w->GetSize(&x, &y);
+  
+  return x;
+}
+
+static int wxSchemeWindowGetHeight(wxWindow *w)
+{
+  int x, y;
+
+  w->GetSize(&x, &y);
+  
+  return y;
+}
+
+static int wxSchemeWindowGetX(wxWindow *w)
+{
+  int x, y;
+
+  w->GetPosition(&x, &y);
+  
+  return x;
+}
+
+static int wxSchemeWindowGetY(wxWindow *w)
+{
+  int x, y;
+
+  w->GetPosition(&x, &y);
+  
+  return y;
+}
+
+@CLASSBASE wxWindow "wx:window":"wx:object"
+
+// @CREATOR ();
+
+@MACRO CHECKCURSOROK[p] = if (x<p> && !x<p>->Ok()) x<p> = wxSTANDARD_CURSOR;
+
+@ "centre" : void Centre(int = wxBOTH);
+
+// @ "make-modal" : void MakeModal(bool);
+@ "set-focus" : void SetFocus();
+@ "set-size" : void SetSize(int,int,int,int,int=wxSIZE_AUTO); : : /NOZERO[2]|NOZERO[3]
+@ "move" : void Move(int,int); 
+// @ "set-client-size" : void SetClientSize(int,int); : : /NOZERO[0]|NOZERO[1]
+// @ "set-colour-map" : void SetColourMap(wxColourMap!);
+@ "set-cursor" : wxCursor^ SetCursor(wxCursor!); : : /CHECKCURSOROK[0]
+@ "show" : void Show(bool);
+@ "is-shown?" : bool IsShown();
+@ "fit" : void Fit();
+@ "get-size" : void GetSize(int*,int*);
+@ "get-client-size" : void GetClientSize(int*,int*);
+@ "get-position" : void GetPosition(int*,int*);
+@ "enable" : void Enable(bool);
+
+@ "get-name" : nstring GetName();
+
+@ "get-char-height" : float GetCharHeight();
+@ "get-char-width" : float GetCharWidth();
+@ "client-to-screen" : void ClientToScreen(int*, int*);
+// Destruction not allowed in wxScheme:
+// @ "destroy-children" : void DestroyChildren();
+// @ "drag-accept-files" : void DragAcceptFiles(bool);
+// @ "add-child" : void AddChild(wxWindow!);
+// @ "capture-mouse" : void CaptureMouse();
+@ "screen-to-client" : void ScreenToClient(int*,int*);
+@ "refresh" : void Refresh();
+// @ "release-mouse" : void ReleaseMouse();
+@ "get-parent" : wxWindow^ GetParent();
+@ "get-text-extent" : void GetTextExtent(string,float*,float*,float?=NULL,float?=NULL,wxFont^=NULL,bool=FALSE);
+// @ "get-children" : wxList! GetChildren();
+@ "get-grand-parent" : wxWindow^ GetGrandParent();
+@ "get-label" : string GetLabel();
+@ "center" : void Center(int);
+
+#if 0
+@ "set-constraints" : void SetConstraints(wxLayoutConstraints^); ## USE_CONSTRAINTS
+@ "get-constraints" : wxLayoutConstraints^ GetConstraints();  ## USE_CONSTRAINTS
+@ "layout" : void Layout();  ## USE_CONSTRAINTS
+
+@ "get-user-edit-mode" : bool GetUserEditMode(); ## HAS_EDIT_MODE
+@ "set-user-edit-mode" : void SetUserEditMode(bool); ## HAS_EDIT_MODE
+#endif
+
+@ m "get-height" : int wxSchemeWindowGetHeight();
+@ m "get-width" : int wxSchemeWindowGetWidth();
+@ m "get-x" : int wxSchemeWindowGetX();
+@ m "get-y" : int wxSchemeWindowGetY();
+
+@CONSTANT "wx:const-size-auto" : int wxSIZE_AUTO
+@CONSTANT "wx:const-size-auto-width" : int wxSIZE_AUTO_WIDTH
+@CONSTANT "wx:const-size-auto-height" : int wxSIZE_AUTO_HEIGHT
+@CONSTANT "wx:const-size-use-exsiting" : int wxSIZE_USE_EXISTING
+@CONSTANT "wx:const-pos-use-minus-one" : int wxPOS_USE_MINUS_ONE
+
+
+@SETMARK w = V
+@INCLUDE wxs_win.xci
+
+@END
diff --git a/src/mred/wxs/wxs_win.xci b/src/mred/wxs/wxs_win.xci
new file mode 100644
index 0000000..dd23218
--- /dev/null
+++ b/src/mred/wxs/wxs_win.xci
@@ -0,0 +1,9 @@
+
+@MACRO returnFALSE = return FALSE;
+
+@ w "on-kill-focus" : void OnKillFocus();
+@ w "on-set-focus" : void OnSetFocus();
+@ w "on-size" : void OnSize(int,int);
+
+@ w "pre-on-char" : bool PreOnChar(wxWindow!,wxKeyEvent!);  : : : returnFALSE : returnFALSE : wxWindow
+@ w "pre-on-event" : bool PreOnEvent(wxWindow!,wxMouseEvent!);  : : : returnFALSE : returnFALSE : wxWindow
diff --git a/src/mred/wxs/wxscheme.cxx b/src/mred/wxs/wxscheme.cxx
new file mode 100644
index 0000000..a4dc663
--- /dev/null
+++ b/src/mred/wxs/wxscheme.cxx
@@ -0,0 +1,1518 @@
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#endif
+
+#define Uses_XLib // Xt
+#include "common.h" // wxWindows
+#include "wx_media.h"
+#include "wx_win.h"
+#include "wxscheme.h"
+#ifdef wx_msw
+#include "wx_pdf.h"
+#include "wx_main.h"
+#endif
+#include "wxsmred.h"
+
+#define WXS_SETUP_ONLY 1
+#include "wxs_obj.h"
+#include "wxs_win.h"
+#include "wxs_fram.h"
+#include "wxs_item.h"
+#include "wxs_butn.h"
+#include "wxs_text.h"
+#include "wxs_ckbx.h"
+#include "wxs_chce.h"
+#include "wxs_evnt.h"
+#include "wxs_panl.h"
+#include "wxs_list.h"
+#include "wxs_medi.h"
+#include "wxs_mede.h"
+#include "wxs_madm.h"
+#include "wxs_snip.h"
+#include "wxs_mpb.h"
+#include "wxs_mio.h"
+#include "wxs_styl.h"
+#include "wxs_menu.h"
+#include "wxs_bmap.h"
+#include "wxs_ipc.h"
+#include "wxs_help.h"
+#include "wxs_misc.h"
+#include "wxs_rado.h"
+#include "wxs_slid.h"
+#include "wxs_gage.h"
+#include "wxs_lbox.h"
+#if USE_TOOLBAR 
+#include "wxs_tbar.h"
+#endif
+#if USE_CONSTRAINTS && 0
+#include "wxs_cstr.h"
+#endif
+// #include "wxs_form.h"
+
+#include "wxs_glob.h"
+
+#undef WXS_SETUP_ONLY
+#include "wxs_gdi.h"
+#include "wxs_dc.h"
+#include "wxs_cnvs.h"
+
+#include <stdlib.h>
+
+char *WXSCHEME_wrong = "wrong number of parameters to method %s";
+char *WXSCHEME_too_many = "too many parameters to method %s";
+char *WXSCHEME_too_few = "too few parameters to method %s";
+char *WXSCHEME_expected = "expected a %s in %s";
+
+typedef struct GCBitmap {
+  wxCanvas **canvasptr; /* weak reference */
+  float x, y, w, h;
+  float onx, ony, offx, offy;
+  wxMemoryDC *on, *off;
+  struct GCBitmap *next;
+} GCBitmap;
+
+static GCBitmap *gc_bitmaps = NULL;
+extern "C" void (*GC_collect_start_callback)(void);
+extern "C" void (*GC_collect_end_callback)(void);
+static void (*orig_collect_start_callback)(void);
+static void (*orig_collect_end_callback)(void);
+static void collect_start_callback(void);
+static void collect_end_callback(void);
+
+static void wxScheme_Install(Scheme_Env *env, void *global_env);
+
+static Scheme_Object *pref_dir_symbol, *pref_file_symbol, 
+  *setup_file_symbol, *init_file_symbol, *init_dir_symbol, 
+  *temp_dir_symbol, *autosaves_file_symbol;
+
+#define INSTALL_COUNT 520
+
+static Scheme_Unit *wxs_unit;
+static Scheme_Object *wxs_siglist, *wxs_signed_unit, *wxs_signature;
+
+#define CONS scheme_make_pair
+
+static void wxScheme_Invoke(Scheme_Env * env)
+{
+  if (!wxs_signature) {
+    scheme_eval(CONS(scheme_intern_symbol("#%define-signature"),
+		     CONS(scheme_intern_symbol("wx^"),
+			  CONS(wxs_siglist,
+			       scheme_null))),
+		env);
+    wxs_signature = scheme_lookup_global(scheme_intern_symbol("wx^"), env);
+  }
+  scheme_add_global_constant("wx^", wxs_signature, env);
+
+  if (!wxs_signed_unit) {
+    wxs_signed_unit = scheme_eval(CONS(scheme_intern_symbol("#%unit->unit/sig"),
+				       CONS((Scheme_Object *)wxs_unit,
+					    CONS(scheme_null,
+						 CONS(scheme_intern_symbol("wx^"),
+						      scheme_null)))),
+				  env);
+  }
+  
+  scheme_add_global_constant("wx@", wxs_signed_unit, env);
+
+  scheme_invoke_unit((Scheme_Object *)wxs_unit, 0, NULL, NULL, 1, "wx", 0, 0);
+}
+
+typedef struct {
+  int count;
+  struct {
+    char *name;
+    Scheme_Object *val;
+  } v[INSTALL_COUNT];
+} InstallRec;
+
+static Scheme_Object *wxsUnit_Init(Scheme_Object **boxes, Scheme_Object ** /* anchors */,
+				   Scheme_Unit *u, void * /* debug_request */)
+{
+  InstallRec *rec = (InstallRec *)u->data;
+  int i;
+
+  for (i = rec->count; i--; )
+    SCHEME_ENVBOX_VAL(boxes[i]) = rec->v[i].val;
+
+  return scheme_void;
+}
+
+void wxsScheme_setup(Scheme_Env *env)
+{
+  InstallRec *rec = (InstallRec *)scheme_malloc(sizeof(InstallRec));
+  Scheme_Unit *u;
+  int i;
+
+  objscheme_init(env);
+
+  setup_file_symbol = scheme_intern_symbol("setup-file");
+  pref_dir_symbol = scheme_intern_symbol("pref-dir");
+  pref_file_symbol = scheme_intern_symbol("pref-file");
+  init_file_symbol = scheme_intern_symbol("init-file");
+  init_dir_symbol = scheme_intern_symbol("init-dir");
+  autosaves_file_symbol = scheme_intern_symbol("autosaves-file");
+  temp_dir_symbol = scheme_intern_symbol("temp-dir");
+
+  rec->count = 0;
+
+  wxScheme_Install(env, rec);
+
+  qsort(rec->v, rec->count, sizeof(char*) + sizeof(Scheme_Object *), 
+	(int (*)(const void *, const void *))strcmp);
+  u = (Scheme_Unit *)scheme_malloc(sizeof(Scheme_Unit));
+  u->type = scheme_unit_type;
+  u->num_imports = 0;
+  u->num_exports = rec->count;
+  u->exports = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *) * rec->count);
+  u->export_debug_names = NULL;
+  u->data = (Scheme_Object *)rec;
+  wxs_siglist = scheme_null;
+  for (i = rec->count; i--; ) {
+    Scheme_Object *s = scheme_intern_symbol(rec->v[i].name + 3); /* skip `wx:' */
+    u->exports[i] = s;
+    wxs_siglist = scheme_make_pair(s, wxs_siglist);
+  }
+  u->init_func = wxsUnit_Init;
+
+  wxs_unit = u;
+
+  wxScheme_Invoke(env);
+
+  orig_collect_start_callback = GC_collect_start_callback;
+  GC_collect_start_callback = collect_start_callback;
+  orig_collect_end_callback = GC_collect_end_callback;
+  GC_collect_end_callback = collect_end_callback;
+}
+
+void scheme_install_xc_global(char *name, Scheme_Object *val, void *env)
+{
+  InstallRec *rec = (InstallRec *)env;
+
+  if (rec->count >= INSTALL_COUNT) {
+    fprintf(stderr, "wx install overflow~n");
+    exit(-1);
+  }
+
+  rec->v[rec->count].name = name;
+  rec->v[rec->count].val = val;
+  rec->count++;
+}
+
+Scheme_Object * scheme_lookup_xc_global(char *name, void *env)
+{
+  InstallRec *rec = (InstallRec *)env;
+  int i;
+
+  for (i = 0; i < rec->count; i++)
+    if (!strcmp(rec->v[i].name, name))
+      return rec->v[i].val;
+
+  return NULL;
+}
+
+
+#ifdef wx_x
+extern Display *MrEdGetXDisplay(void);
+#endif
+
+static void draw_gc_bm(int on)
+{
+  GCBitmap *gcbm = gc_bitmaps;
+  while (gcbm) {
+    if (*gcbm->canvasptr)
+      (*gcbm->canvasptr)->GetDC()->Blit(gcbm->x, gcbm->y,
+					gcbm->w, gcbm->h,
+					on ? gcbm->on : gcbm->off,
+					0, 0);
+    gcbm = gcbm->next;
+  }
+#ifdef wx_x
+  XFlush(MrEdGetXDisplay());
+#endif
+}
+
+static void collect_start_callback(void)
+{
+  draw_gc_bm(1);
+  orig_collect_start_callback();
+}
+
+static void collect_end_callback(void)
+{
+  orig_collect_end_callback();
+  draw_gc_bm(0);
+}
+
+static Scheme_Object *wxSchemeUnregisterCollectingBitmap(int, Scheme_Object **a)
+{
+  GCBitmap *gcbm, *prev = NULL;
+  wxCanvas *c;
+
+  if (a)
+    c = objscheme_unbundle_wxCanvas(a[0], "wx:unregister-collecting-blit", 0);
+  else
+    c = NULL;
+  
+  gcbm = gc_bitmaps;
+  while (gcbm) {
+    if (!gcbm->canvasptr || (*gcbm->canvasptr == c)) {
+      if (prev)
+	prev->next = gcbm->next;
+      else
+	gc_bitmaps = gcbm->next;
+      gcbm->on = gcbm->off = NULL;
+      gcbm->canvasptr = NULL;
+    } else
+      prev = gcbm;
+    gcbm = gcbm->next;
+  }
+
+  return scheme_void;
+}
+
+static Scheme_Object *wxSchemeRegisterCollectingBitmap(int n, Scheme_Object **a)
+{
+  GCBitmap *gcbm;
+
+  gcbm = new GCBitmap;
+
+  gcbm->canvasptr = (wxCanvas **)scheme_malloc_atomic(sizeof(wxCanvas*));
+
+  *gcbm->canvasptr = objscheme_unbundle_wxCanvas(a[0], "wx:register-collecting-blit", 0);
+  gcbm->x = objscheme_unbundle_float(a[1], "wx:register-collecting-blit");
+  gcbm->y = objscheme_unbundle_float(a[2], "wx:register-collecting-blit");
+  gcbm->w = objscheme_unbundle_float(a[3], "wx:register-collecting-blit");
+  gcbm->h = objscheme_unbundle_float(a[4], "wx:register-collecting-blit");
+  gcbm->on = objscheme_unbundle_wxMemoryDC(a[5], "wx:register-collecting-blit", 0);
+  gcbm->off = objscheme_unbundle_wxMemoryDC(a[6], "wx:register-collecting-blit", 0);
+  gcbm->onx = gcbm->ony = gcbm->offx = gcbm-> offy = 0;
+  if (n > 7) {
+    gcbm->onx = objscheme_unbundle_float(a[7], "wx:register-collecting-blit");
+    if (n > 8) {
+      gcbm->ony = objscheme_unbundle_float(a[8], "wx:register-collecting-blit");
+      if (n > 9) {
+	gcbm->offx = objscheme_unbundle_float(a[9], "wx:register-collecting-blit");
+	if (n > 10) {
+	  gcbm->offy = objscheme_unbundle_float(a[10], "wx:register-collecting-blit");
+	}
+      }
+    }
+  }
+
+  gcbm->next = gc_bitmaps;
+  gc_bitmaps = gcbm;
+
+  GC_general_register_disappearing_link((void **)gcbm->canvasptr, 
+					*gcbm->canvasptr);
+
+  wxSchemeUnregisterCollectingBitmap(0, NULL);
+
+  return scheme_void;
+}
+
+static Scheme_Object *wxSchemeCanGetUserColour(int, Scheme_Object **)
+{
+#ifdef wx_x
+  return scheme_false;
+#else
+  return scheme_true;
+#endif
+}
+
+#ifdef wx_msw
+static BOOL do_choose_color(void *data, HWND parent)
+{
+  CHOOSECOLOR *c = (CHOOSECOLOR *)data;
+  c->hwndOwner = parent;
+
+  return ChooseColor(c);
+}
+#endif
+
+static Scheme_Object *wxSchemeGetColourFromUser(int, Scheme_Object **argv)
+{
+  char *s;
+
+  if (SCHEME_NULLP(argv[0]))
+    s = "Choose a color";
+  else
+    s = objscheme_unbundle_string(argv[0], "wx:get-colour-from-user");
+
+#ifndef wx_x
+  wxColour *c = objscheme_unbundle_wxColour(argv[1], "wx:get-colour-from-user", 1);
+#endif
+
+#ifdef wx_x
+  return scheme_false;
+#endif
+#ifdef wx_mac
+  int l;
+  Point pt = {0, 0};
+  Str255 buf;
+  RGBColor in, out;
+
+  l = strlen(s);
+  if (l > 255) l = 255;
+
+  memcpy(buf + 1, s, l);
+  buf[0] = l;
+
+  if (c) {
+    in.red = c->Red() << 8;
+    in.green = c->Green() << 8;
+    in.blue = c->Blue() << 8;
+  } else
+	in.red = in.green = in.blue = 0;
+
+  if (!GetColor(pt, buf, &in, &out))
+    return scheme_false;
+
+  c = new wxColour(out.red >> 8, out.green >> 8, out.blue >> 8);
+
+  return objscheme_bundle_wxColour(c);
+#endif
+#ifdef wx_msw
+  CHOOSECOLOR *cc;
+  static unsigned long userCustomColors[16];
+
+  cc = new CHOOSECOLOR;
+  cc->lStructSize = sizeof(CHOOSECOLOR);
+  cc->hwndOwner = NULL;
+  if (c)
+    cc->rgbResult = RGB(c->Red(), c->Green(), c->Blue());
+  cc->Flags = (c ? CC_RGBINIT : 0);
+  cc->lpCustColors = userCustomColors;
+
+  if (!wxPrimitiveDialog(do_choose_color, cc, 0))
+    return scheme_false;
+
+  c = new wxColour(GetRValue(cc->rgbResult), GetGValue(cc->rgbResult), GetBValue(cc->rgbResult));
+
+  return objscheme_bundle_wxColour(c);
+#endif
+}
+
+static Scheme_Object *wxSchemeCanGetUserFont(int, Scheme_Object **)
+{
+#ifdef wx_msw
+  return scheme_true;
+#else
+  return scheme_false;
+#endif
+}
+
+#ifdef wx_msw
+static BOOL do_choose_font(void *data, HWND parent)
+{
+  CHOOSEFONT *c = (CHOOSEFONT *)data;
+  c->hwndOwner = parent;
+
+  return ChooseFont(c);
+}
+#endif
+
+static Scheme_Object *wxSchemeGetFontFromUser(int, Scheme_Object **argv)
+{
+  char *prompt;
+
+  if (SCHEME_NULLP(argv[0]))
+    prompt = "Choose a font";
+  else
+    prompt = objscheme_unbundle_string(argv[0], "wx:get-font-from-user");
+
+#ifdef wx_msw
+  wxFont *f = objscheme_unbundle_wxFont(argv[1], "wx:get-font-from-user", 1);
+#endif
+
+#ifdef wx_x
+  return scheme_false;
+#endif
+#ifdef wx_mac
+  return scheme_false;
+#endif
+#ifdef wx_msw
+  CHOOSEFONT *c;
+  LOGFONT *lf;
+  int len;
+  char *s;
+
+  lf = new LOGFONT;
+  c = new CHOOSEFONT;
+
+  s = (f ? f->GetFaceString() : NULL);
+  if (s) {
+    len = strlen(s);
+    if (len > 31)
+      len = 31;
+  } else
+    len = 0;
+  
+  memcpy(lf->lfFaceName, s, len);
+  lf->lfFaceName[len] = 0;
+  
+  lf->lfHeight = 0;
+  lf->lfWidth = 0;
+  lf->lfEscapement = 0;
+  lf->lfOrientation = 0;
+  if (f) {
+    switch (f->GetWeight()) {
+    case wxBOLD:
+      lf->lfWeight = FW_BOLD;
+      break;
+    case wxLIGHT:
+      lf->lfWeight = FW_LIGHT;
+    default:
+      lf->lfWeight = FW_NORMAL;
+    } 
+  } else
+    lf->lfWeight = FW_NORMAL;
+  if (f) {
+    switch (f->GetStyle()) {
+    case wxITALIC:
+    case wxSLANT:
+      lf->lfItalic = TRUE;
+      break;
+    default:
+      lf->lfItalic = FALSE;
+    } 
+  } else
+    lf->lfItalic = FALSE;
+  lf->lfUnderline = f && f->GetUnderlined();
+  lf->lfStrikeOut = FALSE;
+  lf->lfCharSet = OEM_CHARSET;
+  lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
+  lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
+  lf->lfQuality = DEFAULT_QUALITY;
+  lf->lfPitchAndFamily = DEFAULT_PITCH;
+  if (f) {
+    switch (f->GetFamily()) {
+    case wxDECORATIVE:
+      lf->lfPitchAndFamily |= FF_DECORATIVE;
+      break;
+    case wxMODERN:
+      lf->lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
+      break;
+    case wxROMAN:
+      lf->lfPitchAndFamily |= FF_ROMAN;
+      break;
+    case wxSCRIPT:
+      lf->lfPitchAndFamily |= FF_SCRIPT;
+      break;
+    case wxSWISS:
+      lf->lfPitchAndFamily |= FF_SWISS;
+      break;
+    default:
+    case wxDEFAULT:
+      lf->lfPitchAndFamily |= FF_DONTCARE;
+      break;
+    } 
+  } else
+    lf->lfPitchAndFamily |= FF_DONTCARE;
+
+  c->lStructSize = sizeof(CHOOSEFONT);
+  c->hwndOwner = NULL;
+  c->lpLogFont = lf;
+  c->iPointSize = 10 * (f ? f->GetPointSize() : 10);
+  c->Flags = CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS;
+
+  if (!wxPrimitiveDialog(do_choose_font, c, 0))
+    return scheme_false;
+  
+  if (!lf->lfFaceName[0])
+    s = NULL;
+  else
+    s = lf->lfFaceName;
+  
+  int fontFamily = wxSWISS;
+  int fontStyle = wxNORMAL;
+  int fontWeight = wxNORMAL;
+  int fontPoints = 10;
+  Bool fontUnderline = FALSE;
+
+  int lfFamily = lf->lfPitchAndFamily;
+  if (lfFamily & FIXED_PITCH)
+    lfFamily -= FIXED_PITCH;
+  if (lfFamily & VARIABLE_PITCH)
+    lfFamily -= VARIABLE_PITCH;
+  
+  switch (lfFamily)
+  {
+    case FF_ROMAN:
+      fontFamily = wxROMAN;
+      break;
+    case FF_SWISS:
+      fontFamily = wxSWISS;
+      break;
+    case FF_SCRIPT:
+      fontFamily = wxSCRIPT;
+      break;
+    case FF_MODERN:
+      fontFamily = wxMODERN;
+      break;
+    case FF_DECORATIVE:
+      fontFamily = wxDECORATIVE;
+      break;
+    default:
+      fontFamily = wxSWISS;
+      break;
+  }
+  switch (lf->lfWeight)
+  {
+    case FW_LIGHT:
+      fontWeight = wxLIGHT;
+      break;
+    case FW_NORMAL:
+      fontWeight = wxNORMAL;
+      break;
+    case FW_BOLD:
+      fontWeight = wxBOLD;
+      break;
+    default:
+      fontWeight = wxNORMAL;
+      break;
+  }
+  if (lf->lfItalic)
+    fontStyle = wxITALIC;
+  else
+    fontStyle = wxNORMAL;
+
+  if (lf->lfUnderline)
+    fontUnderline = TRUE;
+
+  if (s)
+    f = new wxFont(c->iPointSize / 10, s, fontFamily, fontStyle, 
+		   fontWeight, fontUnderline);
+  else
+    f = new wxFont(c->iPointSize / 10, fontFamily, fontStyle, 
+		   fontWeight, fontUnderline);
+
+  return objscheme_bundle_wxFont(f);
+#endif
+}
+
+#ifdef wx_x
+static int indirect_strcmp(const void *a, const void *b)
+{
+  return strcmp(*(char **)a, *(char **)b);
+}
+#endif
+
+
+#ifdef wx_msw
+typedef struct {
+  int count, size;
+  char **names;
+} gfData;
+
+static int CALLBACK get_font(ENUMLOGFONT FAR*  lpelf, 
+			     NEWTEXTMETRIC FAR* lpntm, 
+			     DWORD type, 
+			     LPARAM _data)
+{
+  gfData *data = (gfData *)_data;
+  int l;
+  char *s;
+  
+  if (data->count == data->size) {
+    char **naya;
+
+    data->size += (2 * data->size) + 10;
+    naya = new char*[data->size];
+    memcpy(naya, data->names, data->count * sizeof(char *));
+    data->names = naya;
+  }
+  
+  l = strlen(lpelf->elfLogFont.lfFaceName);
+  s = new char[l + 1];
+  memcpy(s, lpelf->elfLogFont.lfFaceName, l);
+
+  data->names[data->count++] = s;
+
+  return 1;
+}
+#endif
+
+static Scheme_Object *wxSchemeGetFontList(int, Scheme_Object **)
+{
+  Scheme_Object *first = scheme_null, *last = NULL;
+
+#ifdef wx_x
+#ifdef wx_xt
+#define __DISPLAY wxAPP_DISPLAY
+#else
+#define __DISPLAY wxGetDisplay()
+#endif
+  int count, i = 0;
+  char **xnames = XListFonts(__DISPLAY, "*", 50000, &count), **names;
+  int last_pos = -1, last_len = 0;
+
+  names = new char* [count];
+  for (i = 0; i < count; i++)
+    names[i] = xnames[i];
+
+  qsort(names, count, sizeof(char *), 
+	(int (*)(const void *, const void *))indirect_strcmp);
+
+  i = 0;
+#endif
+#ifdef wx_mac
+  MenuHandle fmenu;
+  Str255 buffer;
+  int count, i = 0;
+  
+  fmenu = NewMenu(42, "\p");
+  if (!fmenu)
+    return scheme_null;
+  AppendResMenu(fmenu, 'FONT');
+  
+  count = CountMItems(fmenu);
+#endif
+#ifdef wx_msw
+  gfData data;
+  HDC dc;
+  int i = 0;
+
+  data.count = data.size = 0;
+  data.names = NULL;
+
+  dc = GetDC(NULL);
+
+  EnumFontFamilies(dc, NULL, (FONTENUMPROC)get_font, (LPARAM)&data);
+#endif
+
+  while (1) {
+    char *s;
+    int l;
+
+#ifdef wx_x
+    while ((i < count)
+	   && ((last_pos >= 0) 
+	       && !strncmp(names[i], names[last_pos], last_len)))
+      i++;
+    if (i >= count)
+      break;
+
+    last_pos = i;
+    if (names[i][0] != '-') {
+      l = strlen(names[i]);
+    } else {
+      int c = 0;
+      for (l = 0; names[i][l]; l++)
+	if (names[i][l] == '-') {
+	  c++;
+	  if (c == 3) {
+	    /* Special case: null weight, slant, non-normal */
+	    if (names[i][l + 1] == '-') {
+	      l++;
+	      if (names[i][l + 1] == '-') {
+		l++;
+		if (names[i][l + 1] == '-')
+		  l++;
+	      }
+	    }
+	    break;
+	  }
+	}
+    }
+    last_len = l;
+    
+    s = names[i++];
+#endif
+#ifdef wx_mac
+    if (i >= count)
+      break;
+    GetMenuItemText(fmenu, ++i, buffer);
+    l = buffer[0];
+    s = PtoCstr(buffer);
+#endif
+#ifdef wx_msw
+    if (i >= data.count)
+      break;
+    s = data.names[i++];
+    l = strlen(s);
+#endif
+    
+    Scheme_Object *pr = scheme_make_pair(scheme_make_sized_string(s, l, 1), scheme_null);
+    if (last)
+      SCHEME_CDR(last) = pr;
+    else
+      first = pr;
+    last = pr;
+  }
+
+#ifdef wx_x
+   XFreeFontNames(xnames);
+#endif
+#ifdef wx_msw
+   ReleaseDC(NULL, dc);
+#endif
+
+  return first;
+}
+
+#ifdef wx_mac
+#include <Sound.h>
+typedef struct AsyncSoundRec {
+  SndChannelPtr snd;
+  short file;
+  struct AsyncSoundRec *next;
+} AsyncSoundRec;
+
+static AsyncSoundRec *playing = NULL, *finished = NULL;
+
+static pascal void SoundFinished(SndChannelPtr snd)
+{
+  AsyncSoundRec **p = &playing;
+
+  while (*p) {
+    if ((*p)->snd == snd) {
+      AsyncSoundRec *r = (*p); 
+      (*p) = r->next;
+      r->next = finished;
+      finished = r;
+      return;
+    }
+  }
+}
+
+void wxCheckFinishedSounds(void)
+{
+  while (finished) {
+    AsyncSoundRec *p = finished;
+    finished = finished->next;
+    
+    FSClose(p->file);
+    SndDisposeChannel(p->snd, FALSE);
+  }
+}
+
+static FilePlayCompletionUPP SoundFinishedProc = NewFilePlayCompletionProc(SoundFinished);
+#endif
+
+#ifndef wx_x
+
+# ifdef wx_mac
+static int IsFinished(void *r)
+{
+  AsyncSoundRec *f = finished;
+  
+  while (f) {
+    if ((void *)f == r)
+      return 1;
+    f = f->next;
+  }
+  
+  return 0;
+}
+
+extern "C" {
+  int scheme_mac_path_to_spec(const char *filename, FSSpec *spec, long *type);
+};
+# endif
+
+static Scheme_Object *wxPlaySound(int argc, Scheme_Object **argv)
+{
+  Bool async, ok;
+  char *f;
+  
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("wx:play-sound", "string", 0, argc, argv);
+  
+  async = SCHEME_TRUEP(argv[1]);
+  
+  f = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+			     SCHEME_STRTAG_VAL(argv[0]),
+			     "wx:play-sound",
+			     NULL);
+
+#ifdef wx_msw  
+  ok = PlaySound(f, NULL, async ? SND_ASYNC : SND_SYNC);
+#endif
+#ifdef wx_mac
+  Bool local_async = TRUE;
+  SndChannelPtr snd;
+  short file;
+  long buffsize = 1024;
+  OSErr snd_err;
+  AsyncSoundRec *r;
+  FSSpec spec;
+  
+  if (!scheme_mac_path_to_spec(f, &spec, FALSE))
+    return scheme_false;
+  
+  if (FSpOpenDF(&spec, fsRdPerm, &file))
+    return scheme_false;
+
+  snd = NULL;
+  if (local_async) {
+    if (SndNewChannel(&snd, sampledSynth, 0, NULL)) {
+      DisposePtr((Ptr)snd);
+      snd = NULL;
+    }
+  }
+
+  if (local_async) {
+    r = new AsyncSoundRec;
+
+    r->snd = snd;
+    r->file = file;
+
+    r->next = playing;
+    playing = r;
+  } else
+    r = NULL;
+
+  do {
+    buffsize *= 2;
+    snd_err = SndStartFilePlay(snd, file, 0, buffsize, NULL, NULL, 
+  			 local_async ? SoundFinishedProc : NULL, 
+  			 local_async);
+  } while (snd_err == buffersTooSmall);
+
+  ok = !snd_err;
+
+  if (ok && local_async && !async) {
+    wxDispatchEventsUntil(IsFinished, r);
+  }
+
+  if (!local_async)
+    FSClose(file);
+
+  if ((!local_async || !ok) && snd) {
+    SoundFinished(snd);
+    wxCheckFinishedSounds();
+  }
+#endif  
+
+  return (ok ? scheme_true : scheme_false);
+}
+#endif
+
+#ifdef wx_mac
+extern short wxMacDisableMods;
+#define SCK_ARG p
+#else
+#define SCK_ARG /**/
+#endif
+
+Scheme_Object *wxs_app_file_proc;
+
+static Scheme_Object *SpecialCtlKey(int, Scheme_Object *SCK_ARG[])
+{
+#ifdef wx_mac
+  if (SCHEME_FALSEP(p[0]))
+    wxMacDisableMods = 0;
+  else
+    wxMacDisableMods = 4096;
+#endif      
+
+  return scheme_void;
+}
+
+
+static Scheme_Object *DefaultAppFileProc(int n, Scheme_Object *p[])
+{
+  if (!SCHEME_STRINGP(p[0]))
+    scheme_wrong_type("default-application-file-handler", "string",
+		      0, n, p);
+
+  return scheme_void;
+}
+
+static Scheme_Object *ApplicationFileProc(int n, Scheme_Object *p[])
+{
+  if (!n)
+    return wxs_app_file_proc;
+  else {
+    scheme_check_proc_arity("wx:application-file-handler", 1,
+			    0, n, p);
+    wxs_app_file_proc = p[0];
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *Eventspace_p(int, Scheme_Object **argv)
+{
+  return ((SCHEME_TYPE(argv[0]) == mred_eventspace_type)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *wxSchemeCurrentEventspace(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("wx:current-eventspace", mred_eventspace_param,
+			     argc, argv,
+			     -1, Eventspace_p, "eventspace", 0);
+}
+
+static Scheme_Object *wxSchemeEventDispatchHandler(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("wx:event-dispatch-handler", 
+			     mred_event_dispatch_param,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *wxSchemeEventspaceConfig(int argc, Scheme_Object **argv)
+{
+  if (SCHEME_TYPE(argv[0]) != mred_eventspace_type)
+    scheme_wrong_type("wx:eventspace-parameterization", "eventspace",
+		      0, argc, argv);
+
+  return MrEdEventspaceConfig(argv[0]);
+}
+
+extern void wxDispatchEventsUntil(int (*f)(void *), void *data);
+
+static Scheme_Object *wxSchemeMakeEventspace(int argc, Scheme_Object **argv)
+{
+  if (argc && (SCHEME_TYPE(argv[0]) != scheme_config_type))
+    scheme_wrong_type("wx:make-eventspace", "parameterization",
+		      0, argc, argv);
+
+  return (Scheme_Object *)MrEdMakeEventspace(argc ? (Scheme_Config *)argv[0] : (Scheme_Config *)NULL);
+}
+
+static int check_sema(void *s)
+{
+  if (!*(void **)s)
+    return 1;
+  else {
+    if (!scheme_wait_sema(*(Scheme_Object **)s, 1))
+      return 0;
+    *(void **)s = NULL;
+    return 1;
+  }
+}
+
+Bool wxSchemeYield(void *sema)
+{
+  if (sema) {
+    void **s;
+
+    if (!SCHEME_SEMAP((Scheme_Object *)sema))
+      scheme_wrong_type("wx:yield", "semaphore", -1, 0, (Scheme_Object **)&sema);
+
+    s = new void*;
+    *s = sema;
+
+    wxDispatchEventsUntil(check_sema, s);
+
+    return 1;
+  } else
+    return wxYield();
+}
+
+static Scheme_Object *wxSchemeCheckForBreak(int, Scheme_Object **)
+{
+  return (MrEdCheckForBreak()
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *wxSchemeGetFrameList(int, Scheme_Object **)
+{
+  return MrEdGetFrameList();
+}
+
+#ifdef wx_mac
+extern "C" {
+ extern char *scheme_build_mac_filename(FSSpec *spec, int given_dir);
+};
+extern char *wxmac_startup_directory;
+#endif
+
+static Scheme_Object *wxSchemeFindDirectory(int argc, Scheme_Object **argv)
+{
+  enum {
+    id_tmp_dir,
+    id_pref_dir,
+    id_init_dir,
+    id_pref_file,
+    id_init_file,
+    id_setup_file,
+    id_autosaves_file
+  };
+
+  int which;
+
+  if (argv[0] == temp_dir_symbol)
+    which = id_tmp_dir;
+  else if (argv[0] == pref_dir_symbol)
+    which = id_pref_dir;
+  else if (argv[0] == pref_file_symbol)
+    which = id_pref_file;
+  else if (argv[0] == init_file_symbol)
+    which = id_init_file;
+  else if (argv[0] == init_dir_symbol)
+    which = id_init_dir;
+  else if (argv[0] == setup_file_symbol)
+    which = id_setup_file;
+  else if (argv[0] == autosaves_file_symbol)
+    which = id_autosaves_file;
+  else {
+    scheme_wrong_type("wx:find-path", "find-path-symbol",
+		      0, argc, argv);
+    return NULL;
+  }
+
+#ifdef wx_x
+  if (which == id_tmp_dir) {
+    char *p;
+    
+    if ((p = getenv("TMPDIR"))) {
+      p = scheme_expand_filename(p, -1, NULL, NULL);
+      if (p && scheme_directory_exists(p))
+	return scheme_make_string(p);
+    }
+
+    if (scheme_directory_exists("/usr/tmp"))
+      return scheme_make_string("/usr/tmp");
+
+    return scheme_make_string("/tmp");
+  }
+
+  Scheme_Object *home;
+
+  home = scheme_make_string(scheme_expand_filename("~/", 2, NULL, NULL));
+
+  if ((which == id_pref_dir) || (which == id_init_dir))
+    return home;
+
+  int ends_in_slash;
+  ends_in_slash = (SCHEME_STR_VAL(home))[SCHEME_STRTAG_VAL(home) - 1] == '/';
+
+  if (which == id_pref_file)
+    return scheme_append_string(home,
+				scheme_make_string("/.mred.prefs" + ends_in_slash));
+
+  if (which == id_init_file)
+    return scheme_append_string(home,
+				scheme_make_string("/.mredrc" + ends_in_slash));
+
+  if (which == id_setup_file)
+    return scheme_append_string(home,
+				scheme_make_string("/.mred.resources" + ends_in_slash));
+
+  if (which == id_autosaves_file)
+    return scheme_append_string(home,
+				scheme_make_string("/.mred.saves" + ends_in_slash));
+#endif
+
+#ifdef wx_msw
+  char *d, *p;
+  Scheme_Object *home;
+
+  d = getenv("HOMEDRIVE");
+  p = getenv("HOMEPATH");
+
+  if (d && p) {
+    char *s;
+    s = new char[strlen(d) + strlen(p) + 1];
+    strcpy(s, d);
+    strcat(s, p);
+    
+    if (scheme_directory_exists(s))
+      home = scheme_make_string_without_copying(s);
+    else
+      home = NULL;
+  } else 
+    home = NULL;
+
+  if (!home) {
+    int i;
+    char *s;
+
+    p = wxTheApp->argv[0];
+    s = copystring(p);
+
+    i = strlen(s) - 1;
+    
+    while (i && (s[i] != '\\'))
+      --i;
+    s[i] = 0;
+    home = scheme_make_string_without_copying(s);
+  }
+
+  if (which == id_tmp_dir)
+    return home;
+
+  if (which == id_pref_dir)
+    return home;
+
+  if (which == id_init_dir)
+    return home;
+
+  int ends_in_slash;
+  ends_in_slash = (SCHEME_STR_VAL(home))[SCHEME_STRTAG_VAL(home) - 1];
+  ends_in_slash = ((ends_in_slash == '/') || (ends_in_slash == '\\'));
+
+  if (which == id_pref_file)
+    return scheme_append_string(home,
+				scheme_make_string("\\mred.pre" + ends_in_slash));
+
+  if (which == id_init_file)
+    return scheme_append_string(home,
+				scheme_make_string("\\mredrc.ss" + ends_in_slash));
+
+  if (which == id_setup_file)
+    return scheme_append_string(home,
+				scheme_make_string("\\mred.ini" + ends_in_slash));  
+
+  if (which == id_autosaves_file)
+    return scheme_append_string(home,
+				scheme_make_string("\\mred.asv" + ends_in_slash));  
+#endif
+
+#ifdef wx_mac
+  OSType t;
+  FSSpec spec;
+  Scheme_Object *home;
+
+  switch (which) {
+  case id_pref_dir:
+  case id_init_dir:
+  case id_pref_file:
+  case id_init_file:
+  case id_setup_file:
+    t = 'pref';
+    break;
+  case id_tmp_dir:
+  default:
+    t = 'temp';
+    break;
+  }
+
+  if (!FindFolder(kOnSystemDisk, t, kCreateFolder, &spec.vRefNum, &spec.parID))
+    home = scheme_make_string(scheme_build_mac_filename(&spec, 1));
+  else if (wxmac_startup_directory) {
+    home = scheme_make_string(wxmac_startup_directory);
+  } else {
+    home = scheme_make_string(scheme_getcwd(NULL, 0, NULL, 1));
+  }
+  
+  if ((which == id_pref_dir) || (which == id_tmp_dir) || (which == id_init_dir))
+    return home;
+
+  int ends_in_colon;
+  ends_in_colon = (SCHEME_STR_VAL(home))[SCHEME_STRTAG_VAL(home) - 1] == ':';
+
+  if (which == id_pref_file)
+    return scheme_append_string(home,
+				scheme_make_string(":MrEd Preferences" + ends_in_colon));
+
+  if (which == id_init_file)
+    return scheme_append_string(home,
+				scheme_make_string(":mredrc.ss" + ends_in_colon));
+
+  if (which == id_setup_file)
+    return scheme_append_string(home,
+				scheme_make_string(":mred.fnt" + ends_in_colon));  
+
+  if (which == id_pref_file)
+    return scheme_append_string(home,
+				scheme_make_string(":MrEd Autosaves" + ends_in_colon));
+#endif
+
+  return scheme_void;
+}
+
+static void wxScheme_Install(Scheme_Env *env, void *global_env)
+{
+  static int installed = 0;
+
+  scheme_defining_primitives = 1;
+  
+  if (!installed) {
+    installed = 1;
+    scheme_add_namespace_option(scheme_intern_symbol("wx"), wxScheme_Invoke);
+    
+    wxs_app_file_proc = scheme_make_prim_w_arity(DefaultAppFileProc,
+						 "default-application-file-handler",
+						 1, 1);
+  }
+
+#ifdef wx_x
+  scheme_install_xc_global("wx:platform", 
+			   scheme_intern_symbol("unix"), global_env);
+#ifdef wx_motif
+  scheme_install_xc_global("wx:window-system", 
+			   scheme_intern_symbol("motif"), global_env);
+#else
+#ifdef wx_xt
+  scheme_install_xc_global("wx:window-system", 
+			   scheme_intern_symbol("xt"), global_env);
+#else
+  scheme_install_xc_global("wx:window-system", 
+			   scheme_intern_symbol("xview"), global_env);
+#endif
+#endif  
+#endif
+#ifdef wx_msw
+  scheme_install_xc_global("wx:platform", 
+			   scheme_intern_symbol("windows"), global_env);
+  scheme_install_xc_global("wx:window-system", 
+			   scheme_intern_symbol("windows"), global_env);
+#endif  
+#ifdef wx_mac
+  scheme_install_xc_global("wx:platform", 
+			   scheme_intern_symbol("macintosh"), global_env);
+  scheme_install_xc_global("wx:window-system", 
+			   scheme_intern_symbol("macintosh"), global_env);
+#endif
+
+  scheme_install_xc_global("wx:special-control-key", 
+			   scheme_make_prim_w_arity(SpecialCtlKey, 
+						    "wx:special-control-key", 
+						    1, 1), 
+			   global_env);
+  
+  scheme_install_xc_global("wx:application-file-handler",
+			   scheme_make_prim_w_arity(ApplicationFileProc,
+						    "wx:application-file-handler",
+						    1, 1),
+			   global_env);
+  
+  scheme_install_xc_global("wx:can-get-user-colour?",
+			   scheme_make_prim_w_arity(wxSchemeCanGetUserColour,
+						    "wx:can-get-user-colour?",
+						    0, 0),
+			   global_env);
+  scheme_install_xc_global("wx:can-get-user-font?",
+			   scheme_make_prim_w_arity(wxSchemeCanGetUserFont,
+						    "wx:can-get-user-font?",
+						    0, 0),
+			   global_env);
+  
+  scheme_install_xc_global("wx:get-colour-from-user",
+			   scheme_make_prim_w_arity(wxSchemeGetColourFromUser,
+						    "wx:get-colour-from-user",
+						    2, 2),
+			   global_env);
+  
+  scheme_install_xc_global("wx:get-font-from-user",
+			   scheme_make_prim_w_arity(wxSchemeGetFontFromUser,
+						    "wx:get-font-from-user",
+						    2, 2),
+			   global_env);
+  
+  scheme_install_xc_global("wx:get-font-list",
+			   scheme_make_prim_w_arity(wxSchemeGetFontList,
+						    "wx:get-font-list",
+						    0, 0),
+			   global_env);
+  
+#ifdef wx_x
+  Scheme_Object *ps;
+
+  ps = scheme_eval_string("(#%lambda (f async?)"
+			  "  (#%unless (#%string? f)"
+			  "    (#%raise-type-error 'wx:play-sound \"string\" f))"
+			  "  (#%let ([b (#%box \"cat ~s > /dev/audio\")])"
+			  "    (#%wx:get-resource \"mred\" \"playcmd\" b)"
+			  "    ((#%if async? (#%lambda (x) (#%process x) #t) #%system)"
+			  "     (#%format (#%unbox b) (#%expand-path f)))))",
+			  env);
+  scheme_install_xc_global("wx:play-sound", ps, global_env);
+#else
+  scheme_install_xc_global("wx:play-sound", 
+			     scheme_make_prim_w_arity(wxPlaySound, 
+						      "wx:play-sound", 
+						      2, 2), 
+			     global_env);
+#endif
+
+  scheme_install_xc_global("wx:make-eventspace",
+			     scheme_make_prim_w_arity(wxSchemeMakeEventspace,
+						      "wx:make-eventspace",
+						      0, 1),
+			     global_env);
+  scheme_install_xc_global("wx:current-eventspace",
+			   scheme_register_parameter(wxSchemeCurrentEventspace,
+						     "wx:current-eventspace",
+						     mred_eventspace_param),
+			   global_env);
+  scheme_install_xc_global("wx:event-dispatch-handler",
+			   scheme_register_parameter(wxSchemeEventDispatchHandler,
+						     "wx:event-dispatch-handler",
+						     mred_event_dispatch_param),
+			   global_env);
+  scheme_install_xc_global("wx:eventspace?",
+			   scheme_make_prim_w_arity(Eventspace_p,
+						    "wx:eventspace?",
+						    1, 1),
+			   global_env);
+  scheme_install_xc_global("wx:eventspace-parameterization",
+			   scheme_make_prim_w_arity(wxSchemeEventspaceConfig,
+						    "wx:eventspace-parameterization",
+						    1, 1),
+			   global_env);
+
+  scheme_install_xc_global("wx:check-for-break",
+			   scheme_make_prim_w_arity(wxSchemeCheckForBreak,
+						    "wx:check-for-break",
+						    0, 0),
+			   global_env);
+
+
+  scheme_install_xc_global("wx:find-path",
+			   scheme_make_prim_w_arity(wxSchemeFindDirectory,
+						    "wx:find-path",
+						    1, 1),
+			   global_env);
+
+  scheme_install_xc_global("wx:get-frame-list",
+			   scheme_make_prim_w_arity(wxSchemeGetFrameList,
+						    "wx:get-frame-list",
+						    0, 0),
+			   global_env);
+
+  scheme_install_xc_global("wx:register-collecting-blit",
+			   scheme_make_prim_w_arity(wxSchemeRegisterCollectingBitmap,
+						    "wx:register-collecting-blit",
+						    7, 11),
+			   global_env);
+  scheme_install_xc_global("wx:unregister-collecting-blit",
+			   scheme_make_prim_w_arity(wxSchemeUnregisterCollectingBitmap,
+						    "wx:unregister-collecting-blit",
+						    1, 1),
+			   global_env);
+
+  /* Order is important! Base class must be initialized before derived. */
+  objscheme_setup_wxObject(global_env);
+#if 0
+  objscheme_setup_wxNode(global_env);
+  objscheme_setup_wxList(global_env);
+  objscheme_setup_wxHashTable(global_env);
+  objscheme_setup_wxPathList(global_env);
+  objscheme_setup_wxStringList(global_env);
+#endif
+  objscheme_setup_wxWindow(global_env);
+  objscheme_setup_wxFrame(global_env);
+  objscheme_setup_wxColour(global_env);
+  objscheme_setup_wxColourMap(global_env);
+  objscheme_setup_wxColourDatabase(global_env);
+  objscheme_setup_wxPoint(global_env);
+  objscheme_setup_wxIntPoint(global_env);
+  objscheme_setup_wxBrush(global_env);
+  objscheme_setup_wxBrushList(global_env);
+  objscheme_setup_wxPen(global_env);
+  objscheme_setup_wxPenList(global_env);
+  objscheme_setup_wxBitmap(global_env);
+  objscheme_setup_wxIcon(global_env);
+  objscheme_setup_wxCursor(global_env);
+  objscheme_setup_wxFont(global_env);
+  objscheme_setup_wxFontList(global_env);
+  objscheme_setup_wxFontNameDirectory(global_env);
+  objscheme_setup_wxItem(global_env);
+  objscheme_setup_wxMessage(global_env);
+  // objscheme_setup_wxGroupBox(global_env);
+  objscheme_setup_wxButton(global_env);
+  objscheme_setup_wxRadioBox(global_env);
+  objscheme_setup_wxCheckBox(global_env);
+  objscheme_setup_wxListBox(global_env);
+  objscheme_setup_wxChoice(global_env);
+  objscheme_setup_wxSlider(global_env);
+  objscheme_setup_wxsGauge(global_env);
+  objscheme_setup_wxText(global_env);
+  objscheme_setup_wxMultiText(global_env);
+  objscheme_setup_wxTextWindow(global_env);
+  objscheme_setup_wxMenu(global_env);
+  objscheme_setup_wxMenuBar(global_env);
+//  objscheme_setup_wxMenuItem(global_env);
+  objscheme_setup_wxEvent(global_env);
+  objscheme_setup_wxCommandEvent(global_env);
+  objscheme_setup_wxKeyEvent(global_env);
+  objscheme_setup_wxMouseEvent(global_env);
+  objscheme_setup_wxDC(global_env);
+  objscheme_setup_wxCanvasDC(global_env);
+#if 0
+#ifndef wx_mac
+  objscheme_setup_wxPanelDC(global_env);
+#endif
+#endif
+  objscheme_setup_wxMemoryDC(global_env);
+  objscheme_setup_wxPostScriptDC(global_env);
+  objscheme_setup_basePrinterDC(global_env);
+  objscheme_setup_wxCanvas(global_env);
+  objscheme_setup_wxPanel(global_env);
+  objscheme_setup_wxDialogBox(global_env);
+#if USE_ENHANCED_DIALOG && 0
+  objscheme_setup_wxEnhDialogBox(global_env);
+#endif
+//  objscheme_setup_wxFormItem(global_env);
+//  objscheme_setup_wxForm(global_env);
+  objscheme_setup_wxMediaGlobal(global_env);
+  objscheme_setup_wxMediaCanvas(global_env);
+  objscheme_setup_wxMediaBuffer(global_env);
+  objscheme_setup_wxMediaEdit(global_env);
+  objscheme_setup_wxMediaPasteboard(global_env);
+  objscheme_setup_wxSnipClass(global_env);
+  objscheme_setup_wxSnipClassList(global_env);
+  objscheme_setup_wxSnip(global_env);
+  objscheme_setup_wxTextSnip(global_env);
+  objscheme_setup_wxTabSnip(global_env);
+  objscheme_setup_wxImageSnip(global_env);
+  objscheme_setup_wxMediaSnip(global_env);
+  objscheme_setup_wxSnipAdmin(global_env);
+  objscheme_setup_wxMediaAdmin(global_env);
+  objscheme_setup_wxCanvasMediaAdmin(global_env);
+  objscheme_setup_wxMediaSnipMediaAdmin(global_env);
+  objscheme_setup_wxBufferData(global_env);
+  objscheme_setup_wxBufferDataClass(global_env);
+  objscheme_setup_wxBufferDataClassList(global_env);
+  objscheme_setup_wxKeymap(global_env);
+  objscheme_setup_wxMediaStreamInBase(global_env);
+  objscheme_setup_wxMediaStreamOutBase(global_env);
+  objscheme_setup_wxMediaStreamInStringBase(global_env);
+  objscheme_setup_wxMediaStreamOutStringBase(global_env);
+  objscheme_setup_wxMediaStreamIn(global_env);
+  objscheme_setup_wxMediaStreamOut(global_env);
+  objscheme_setup_wxMediaWordbreakMap(global_env);
+  objscheme_setup_wxAddColour(global_env);
+  objscheme_setup_wxMultColour(global_env);
+  objscheme_setup_wxStyleDelta(global_env);
+  objscheme_setup_wxStyle(global_env);
+  objscheme_setup_wxStyleList(global_env);
+#if 0
+  objscheme_setup_wxConnection(global_env);
+  objscheme_setup_wxClient(global_env);
+  objscheme_setup_wxServer(global_env);
+#endif
+#if USE_HELP && 0
+  objscheme_setup_wxHelpInstance(global_env);
+#endif
+  objscheme_setup_baseMetaFile(global_env);
+  objscheme_setup_baseMetaFileDC(global_env);
+  objscheme_setup_wxTimer(global_env);
+  objscheme_setup_wxClipboard(global_env);
+  objscheme_setup_wxClipboardClient(global_env);
+#if 0
+  objscheme_setup_wxTypeTree(global_env);
+#endif
+#if USE_TOOLBAR 
+  objscheme_setup_wxToolBar(global_env);
+  objscheme_setup_wxToolBarTool(global_env);
+#if USE_BUTTONBAR && defined(wx_msw)
+  objscheme_setup_wxButtonBar(global_env);
+#endif
+#endif
+#if USE_CONSTRAINTS && 0
+  objscheme_setup_wxLayoutConstraints(global_env);
+  objscheme_setup_wxIndividualLayoutConstraint(global_env);
+#endif
+
+  objscheme_setup_wxsGlobal(global_env);
+#if 0
+  objscheme_setup_wxsIPCGlobal(global_env);
+#endif
+#if 0
+  objscheme_setup_wxsTypesGlobal(global_env);
+#endif
+//  objscheme_setup_wxFormGlobal(global_env);
+
+  scheme_defining_primitives = 0;
+}
+
diff --git a/src/mred/wxs/wxscheme.h b/src/mred/wxs/wxscheme.h
new file mode 100644
index 0000000..490d169
--- /dev/null
+++ b/src/mred/wxs/wxscheme.h
@@ -0,0 +1,17 @@
+
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "xcglue.h"
+#else 
+#include "../../mzscheme/utils/xcglue.h"
+#endif
+
+void wxsScheme_setup(Scheme_Env *env);
+
+extern char *WXSCHEME_wrong, *WXSCHEME_too_many, *WXSCHEME_too_few;
+extern char *WXSCHEME_expected;
+
+#ifndef wx_msw
+#undef USE_METAFILE
+#define USE_METAFILE 0
+#endif
+
diff --git a/src/mred/wxs/wxscomon.cxx b/src/mred/wxs/wxscomon.cxx
new file mode 100644
index 0000000..966d4ef
--- /dev/null
+++ b/src/mred/wxs/wxscomon.cxx
@@ -0,0 +1,16 @@
+/* DO NOT EDIT THIS FILE. */
+/* This file was generated by xctocc from "wxscomon.xc". */
+
+// generated by xctocmn
+
+
+
+
+
+// #include "wx.h"
+// #include "wx_media.h"
+#include "wxscheme.h"
+#include "wxscomon.h"
+#include "wxscomon.h"
+
+
diff --git a/src/mred/wxs/wxscomon.h b/src/mred/wxs/wxscomon.h
new file mode 100644
index 0000000..4f0895d
--- /dev/null
+++ b/src/mred/wxs/wxscomon.h
@@ -0,0 +1,2 @@
+#ifndef WXS_SETUP_ONLY
+#endif
diff --git a/src/mred/wxs/wxscomon.xc b/src/mred/wxs/wxscomon.xc
new file mode 100644
index 0000000..b414fa6
--- /dev/null
+++ b/src/mred/wxs/wxscomon.xc
@@ -0,0 +1,5 @@
+// generated by xctocmn
+@INCLUDE wxscomon.xci
+@COMMON
+
+@END
diff --git a/src/mred/wxs/wxscomon.xci b/src/mred/wxs/wxscomon.xci
new file mode 100644
index 0000000..53f214e
--- /dev/null
+++ b/src/mred/wxs/wxscomon.xci
@@ -0,0 +1,6 @@
+
+@INCLUDE wxs.xci
+
+// #include "wx.h"
+// #include "wx_media.h"
+@HEADER
diff --git a/src/mred/wxs/wxsmred.h b/src/mred/wxs/wxsmred.h
new file mode 100644
index 0000000..6f7469f
--- /dev/null
+++ b/src/mred/wxs/wxsmred.h
@@ -0,0 +1,12 @@
+
+extern int mred_eventspace_param;
+extern int mred_event_dispatch_param;
+extern Scheme_Type mred_eventspace_type;
+
+extern Scheme_Object *MrEdGetFrameList(void);
+extern int MrEdCheckForBreak(void);
+extern Scheme_Object *MrEdEventspaceConfig(Scheme_Object *);
+
+extern Scheme_Object *MrEdMakeEventspace(Scheme_Config *c);
+
+
diff --git a/src/mzscheme/COPYING.LIB b/src/mzscheme/COPYING.LIB
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/src/mzscheme/COPYING.LIB
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/src/mzscheme/HISTORY b/src/mzscheme/HISTORY
new file mode 100644
index 0000000..c14f9a1
--- /dev/null
+++ b/src/mzscheme/HISTORY
@@ -0,0 +1,453 @@
+Version 51, ??, 1997
+Changed load/use-compiled: searches for .zo files in
+  a "compiled/" subdirectory, and searches for .so/.dll
+  files in (build-path "compiled" (system-library-subpath))
+Changed load and current-load/default-load-handler: `load'
+  now sets the current-load-relative-directory, so a load
+  handler does not need to set this parameter
+Added current-load-extension (load-extension handler)
+Added read-image-from-file procedure
+Unix images: removed constraint against using stdio before
+ dumps
+Unix: fixed file-or-directory-permissions for group-based 
+ permissions when the group is not the current group (but
+ still includes the user)
+Windows: fixed directory-exists? et. al for UNC paths
+Added local-expand-body-expression
+Added link-exists?
+Added copy-file
+Added path-list-string->path-list
+Added collection-path
+Changed initial setting of current-library-collection-paths
+Changed display for symbols containg special characters:
+ the special characters are not escaped (or bar-quoted)
+Changed write to use the value of (read-accept-bar-quote)
+ for printing symbols containing special charaters; if
+ bar qute reading is off, it is turned off for printing, too.
+Fixed unit/sig: correctly handles syntax where defintions in 
+ the unit shadow syntactic forms
+Fixed round of exact rational n/d in the case when (odd? d)
+ and (= (remainder n d) (quotient d 2))
+Extended exp, sin, cos, tan, log, asin, acons, atan to
+ complex numbers; changed sqrt to choose the root with a
+ positive real part
+Removed rectangular <, >, <=, >= for complex numbers
+Changed storage of loaded-library table from built into the
+ `require-library' procedure to built into the current
+ namespace
+Added require-relative-library
+Fixed error messages for +, -, etc. to show all arguments
+Changed MzLib's pconver.ss libraries; the print-convert-hook@
+ unit was removed (along with the pchookr.ss library) and
+ replaced with parameters defined in pconverr.ss for similar
+ (more powerful) hooks.
+Fixed interfaces for compiled-file (.zo) loading across
+ MzScheme startups
+Unused interned symbols are now garbage-collected
+Added support for single-precision floating points (turned
+ off in default compilation)
+Changed read-eval-print-loop, removing its cooperation with
+ the default error escape handler; instead, it installs its
+ own error escape handler
+Improved the support for dynamic extensions that gives an 
+ error if an extension is already loaded, or calls a
+ reloading function provided by the extension (scheme_reload)
+
+Version 50, August 26, 1997
+Added compile-time inferrence of names for closures, classes,
+  and units to improve error messages
+Added inferred-name
+Added file-size
+Added write-image-to-file for creating heap images of a
+  MzScheme program
+Fixed reader to disallow . in vectors: #(1 . 2) or #(1 . (3))
+Removed global-defined-signature
+Fixed string->number: explicit radix in string can override
+  radix argument
+Bug fixed in call/cc related to dynamic-wind (see !!! in 
+  tests/basic.ss)
+Fixed weak hash table's accumulation of hashing buckets
+Added 'empty flag for make-namespace
+Added two-argument form for global-defined-value
+Added system-library-subpath
+Changed standalone mzscheme to return -1 if a loaded file
+  or evaluated expression returns an error without the rep
+Refined error messages
+
+Version 49, May 31, 1997 
+Multiple superclass inheritance is no longer supported
+Added (Java-ish) interfaces to object system
+class* syntax changed to accomodate interfaces and removed
+  multiple superclasses
+uq-ivar always takes two arguments; class is not a legal argument
+uq-make-generic accepts a class or an interface
+Object system exceptions changed
+Added custodian system
+Embedded define conventions changed: "regular" defines are only
+  allowed in begin expressions and the branches of an if;
+  embedded defines can appear in a begin0 expression, but not
+  in the first position; defines must all appear at the beginning
+  of the block
+Contents of a begin expression as an immediate unit or unit/sig 
+  expression are promoted to immediate expressions
+case supports only R4RS syntax; a single non-list "datum" is
+  no longer allowed
+Removed catch; use let/ec instead
+Removed vector-append
+Removed load-with-cd (use load/cd)
+Added load/use-compiled
+Added current-load-directory parameter (set by the default load
+ handler while loading a file) and load-relative (uses the
+ parameter for loading a relative filename)
+unit/sig's include form is like load-relative instead of load/cd
+require-library uses load or load/use-compiled instead of load/cd
+Windows: expand-path does not put a drive on a driveless path
+  anymore; use path->complete-path instead
+compile-file moved out of MzScheme into MzLib "compile.ss"; now 
+  takes a single flag list argument instead of two final Booleans
+current-base-parameterization parameter replaced with 
+  parameterization-branch-handler parameter
+Parameterizations support sharing (in addition to defaulting);
+  see docs for make-parameterization-with-sharing
+Added print, port print handlers, and a global port print handler
+Changed the default print handler to use print instead of write
+Fixed bug in ports returned by make-pipe
+Fixed bug in dynamic-wind; continuation jumps into the pre-thunk
+  had a non-intuitive semantics; the correct semantics is now 
+  implemented and documented (also for jumps with the post-thunk)
+Changed time-apply to always return a list as its first return
+  value; time form can return multiple values for its expressions
+format, fprintf, and printf are case-insensitive for ~ directives;
+  added ~v, ~e, ~<whitespace>
+Added semaphore-wait/enable-break
+Added thread-running? and thread-wait
+Fixed bug in threads and timed sleeping
+Fixed bug in breaking a blocked thread
+Fixed bug in continuations returning multiple values through a
+  dynamic-wind (multiple return values could be corrupted)
+Fixed arity reporting for continuations
+Fixed Windows system* and read from console stdin and process*
+  ports: MzScheme threads no longer blocked; ctl-c breaking works
+  in stand-alone console MzScheme
+process and process* now return a list of 5 values (instead of 4)
+map, for-each, andmap, and ormap raise exn:application:map-arity
+ when the procedure's arity does not match the number of supplied
+ lists; note that (map (lambda () 10) null) now signals an error
+list-ref and list-tail accept arbitrarily large indices
+Type for indices changed: must be an exact integer (matches R4RS better)
+  affects make-vector, vector-ref, vector-set!, make-string, string-ref, 
+  string-set!, substring, and struct-ref
+make-namespace's '[no-]set!-undefined and '[no-]auto-else flags
+  removed; replaced with two new parameters: 
+  compile-allow-set!-undefined and compile-allow-cond-fallthrough
+Fixed in units: (define x y) (define y 0) x => #<undefined> instead of 
+  #<void>
+exn:struct's super-type field renamed struct-type for consistency
+exn:i/o:filesystem:filename split into exn:i/o:filesystem:path
+  and exn:i/o:filesystem:file; username exception moved under path
+Unix: system no longer blocks other MzScheme threads
+Unix: processes created by process and process* are not zombies forever, 
+  anymore. (The SIGCHLD signal is handled appropriately.)
+MacOS: dynamic extension suopport via CFM (PPC only in the distributed
+  applications from PLT)
+Windows: removed attempted fix for thread-blocking problem 
+  when reading stdin from console
+Fixed auto-flush of stdout for read of stdin
+Fixed <, >, <=, >= for certain exact rational number comparisons
+Fixed inexact->exact for negative inexact numbers (fractional part
+  was added to the resulting number with the wrong sign)
+Fixed rational? to answer #t for inexact numbers
+Fixed odd?, even?, and trig functions for +inf.0 and -inf.0
+Fixed handling of +nan.0 by many math routines; fixed +nan.0 for
+  everything under Windows
+Added R4RS rationalize
+compound-unit/sig export var clause syntax now matches documentation
+Added require-library-use-zo
+Moved cons? and last-pair into functio.ss instead of compat.ss
+Library system generalized to supoprt multiple collections;
+  current-library-path replaced with current-library-collection-path
+require-library now returns the result of the loaded library
+Removed load-recent from MzLib's file.ss; use load/use-compiled
+  instead
+Added reference-library, "refer.ss" [core], "XXXr.ss" MzLib libraries
+Added build-string, build-vector, build-list, loop-until to MzLib's 
+  functio.ss
+Added thread.ss MzLib library [core]
+Added inflate.ss MzLib library
+Moved synrule.ss out of core
+Fixed MzLib's stringu.ss to not use macro.ss
+Updated MzLib's spidey.ss, added it to core
+Removed define-some, define-virtual-struct, define-struct-tree from
+  MzLib's macro.ss
+begin-expansion-time returns the value of the last expression
+set-thread-weight! replaced with 2-argument thread-weight
+Inside MzScheme: changed class/object toolbox, added custodian
+  toolbox
+Upgraded to gc 11
+
+Version 48: Skipped to avoid confusion with Scheme48
+
+Version 47, January 11, 1997
+WARNING: multiple inhertance is going away in the next version or so
+Added will executors
+pretty-print-print-hook and pretty-print-size-hook now take
+ three arguments: value display? port
+file-position can return the current position for any port
+Fixed errors reading floating-point constants due to system
+ library bugs:
+   Linux: strtod("0e...", ...) quits looking after "0"
+   SunOS/Solaris: strtod(".3e2666666666") returned 0.0
+   HP/UX: strtod(".3e2666666666") fails
+Windows: fixed thread-blocking problem for reading stdin from console
+Insize MzScheme: when working with "fd_set" values, use
+  MZ_FD_ZERO, MZ_FD_SET, MZ_FD_CLR, MZ_FD_ISSET; use 
+  scheme_get_fdset() to get the second or third fd_set in an array;
+  routines for thread-blocking are now documented in "Inside MzScheme"
+
+Version 46, December 5, 1996
+unit/sig macros moved out of MzLib and into core MzScheme; 
+  (require-library "unitsig.ss") is obsolete, but still supported
+  as a no-op
+Unit signature matching is now position-independent, and the error
+  messages are better
+Removed obsolete install-unit-with-signature
+(begin) or (begin0) is now a syntax error
+Changed class* syntax so that an explicit name for `this' is provided
+MzLib's class-asi* changed to class*-asi, while adding new `this' id
+Prettier(?) printing for prims like >: #<|primitive:>|>
+invoke-open-unit w/o path/prefix is now the same as #f instead of ();
+  the path form will probably be phased out in a future release
+quasiquote syntax changed slightly
+stdout/stderr are not auto-flushed for read-char or peek-char on stdin
+ (still flushed by read and read-line)
+Added port-display-handler and port-write-handler
+
+Version 45, November 12, 1996
+Multiple return values are agressively supported
+IMPORTANT: let-values is now analogous to let; the old 
+  let-values is now let*-values
+let-values, letrec-values, define-values, and begin0 are primitive
+define-struct and let-struct expand to new struct form
+Added thread-savy parameterization system; namespace system changed
+pipe changed to make-pipe, returns 2 values
+Case-sensitivity for the reader is a settable parameter
+Reading [] and {} as parens is a settable parameter
+class* syntax extended to allow local renaming of public ivars
+delay/force support multiple values
+else and => in cond and else are now "scoped"
+normalize-path from MzLib signals an error for bad paths
+Windows: build-path can join a drive to a (driveless) absolute path
+  and //machine/disk drive names are supported; also fixed 
+  file-system-root-list
+Added complete-path? and current-drive (for Windows)
+Fixed (begin (values ...) ...) and (begin0 (values ...) ...)
+Fixed comparisons between inexact and exact when the
+  exact to inexact conversion results in overflow or underflow,
+  and fixed (exact->inexact (/ X Y)) and (/ +inf.0 X), etc. when 
+  X & Y are larger than the largest floating-point, fixed modulo,
+  remainder, quotient for infinities
+Fixed TCP problems (Unix, Windows) and implemented for MacOS
+Fixed dynamic-loading to always search from current directory
+Fixed real process idling for a timed sleep
+Fixed file read/write exceptions (write exceptions now raised)
+Fixed quasiquote bug with ,@ and unquoting depth
+Fixed filesystem-root-list for Windows
+Fixed dynamic-wind when a continuation is invoked from the post-thunk
+Fixed continuations for re-entry of a continuation that is mulitply-invoked
+Fixed string->number with leading spaces; e.g., (string->number " 1") 
+invoke-unit import variable restriction removed (locals are allowed)
+(case-lambda) is now legal
+\ escapes & and \ in regexp-replace replacement string
+Added regexp-replace*
+Added port-read-handler
+Inside MzScheme: Changed use of scheme_sleep
+Inside MzScheme: Changed primitive unit init func arguments
+Inside MzScheme: Changed primitive accessing of unit boxes and environment boxes
+Inside MzScheme: Revoked syntax extensibility
+Reimplemented the core interpreter (chained closures -> flattened)
+
+Version 44, September 9, 1996
+load, load/cd return value of last loaded expression
+scheme_load returns Scheme_Object* or NULL
+Built-in TCP support (Not MacOS, yet)
+unit clauses macro-expanded before checking `define' keywords
+Better dynamic extension handling and compilation support
+Fixed read blocking threads in FreeBSD
+Extensions' scheme_initialize must return Scheme_Object*
+scheme_sleep has internal default for basic sleeping, installed by
+ scheme_basic_env if scheme_sleep is still NULL
+Unix/Winsock: fds arg for needs_wakeup and scheme_sleep expanded 
+ for writes and exceptions
+Fixed quotient for inexact numbers
+Fixed bug comparing a bignum rational with a fixnum rational
+Fixed startup crash when PATH env variable is slightly bad
+Sped up thread switching for Mac
+Sped up thread switching for most Unix for a small number of threads
+Upgraded to gc 11alpha3
+
+Version 43 re-released August 12, 1996 with libguile
+
+Version 43, August 9, 1996
+"functor" -> "unit"
+signed units added to and used by mzlib (sigfunctors gone)
+Made .zo files smaller and faster to load
+Use 64-bit fixnums for Alpha
+system, system*, process*, and execute* supported for Windows
+Fixed memory bug in printing hexadecimal
+Fix bug in modulo
+Better floating-point control for infinity, nan results
+ on many platforms
+
+Version 42: June 8, 1996
+Functor system added
+Fixed (cond (1)), etc.
+Fixed type-checking for numerical comparisons; e.g., (< 2 1 'a)
+Fixed dynamic-wind and call/ec for values
+Fixed read for strings containing #\nul
+Non-matching cond/case raises an error
+Made string=?, char=?, etc. multi-arity like numerical =, etc.
+Changed definition of time-apply (returns values, now)
+MzScheme threads can almost be real OS threads under Solaris, but more work
+  is needed to guarantee safety for the symbol table and globals. More thread 
+  systems to follow.
+spawn-eval replaced by make-eval
+thread-input-port, thread-output-port, and thread-error-port removed
+binary-and, etc. replaced with 2's complement bitwise-and, etc.
+Fixed writing compiled quoted graph expressions
+Fixed return value of system
+test.scm expanded and broken into multiple files: (load/cd "tests/all.ss")
+
+Version 0.41: April 15, 1996
+Revised class syntax; see the manual
+Exception system added; primitive errors raise exceptions
+defmacro replaced by define-macro
+Added define-id-macro
+Fixed let-macro shadowing local vars
+Improved error messages; error-print-width
+Fixed stack checking for Win32
+'. no longer allowed
+unquote and unquote-splicing now defined at top level
+equal? supports boxes
+
+Version 0.40: March 24, 1996
+structure:X => struct:x
+mzlib path uses MZLIB or PLTHOME environment variables
+
+Version 0.39: March 6, 1996
+Fixed expand-defmacro for (lambda () (and)) et al.
+Fixed sqrt on complex numbers; coefficients were reversed
+Cleaned up read and display/write to handle C stack overflow
+Arity checking bug fixed for arity 0
+Pretty-print is parameterized by depth
+
+Version 0.38: February 22, 1996
+Fixed bug in compiling frame-sharing; e.g.,
+  (let ([d 0]) ((car (cons (let ([a 4]) (lambda () a)) 
+			   (let ([b 7]) b)))))
+ returned 7 instead of 4
+Fixed bug in closing port by call-with-input-file
+Fixed magnitude on negative reals
+Fixed angle on negative reals
+Fixed cos, sin, etc. on rationals
+Fixed min and max on rationals with non-rationals
+Fixed (random 0)
+Fixed equal? on really long lists
+Fixed list procedures with arbitrary duration: checking for break
+Fixed char-X? and characters past ASCII 127
+Fixed hash table bug that causes infinite internal loop
+Fixed bug in reading #| |# comments at the end of a list
+Filesystem utilities added
+"processes" are now called "threads"; procedure names changed accordingly
+eval can return multiple values; r-e-p-l handles correctly
+Some changes to compilation interface:
+  must set new flag is_proc_closure in compile_info rec
+  scheme_static_distance changed; use flags
+scheme_sleep() must now take a float
+current-prompt-read added
+Console version reads ~/.mzschemerc init file (or mzscheme.rc)
+NO_STAT compilation flag -> NO_STAT_PROC
+
+Version 0.37: unreleased
+
+Version 0.36: January 18, 1996
+Fixed bug in bignum multiplication
+
+Version 0.35: January 17, 1996
+current-print added
+x@y notation supported
+~ expanded in pathnames (Unix)
+Fixed bug parsing #T, etc.
+Fixed bug parsing hex numbers and others
+Fixed fp-initialization bug for Win32
+Better printing for special symbols
+
+Version 0.34: December 30, 1995
+Various bignum operations sped up
+Chez-style symbol parsing supported (escaping \ and quoting |)
+
+Version 0.33: December 21, 1995
+rationals and complex numbers supported
+make-class and make-class* syntax changed (one set of parens
+  added). The old syntax is still supported for now, but you
+  should convert. The old syntax will eventualy go away (and
+  Zodiac will never be compatible with it).
+class variables and cvar no longer allowed
+ivar always takes an object; if class included, must be first
+threads/processes changed w.r.t. environment used during execution
+error handler split into erro displayer and error escaper
+stack limitation of expander/compiler removed
+expand => expand-defmacro
+expand-once => expand-defmacro-once
+user-break-poll => user-break-poll-handler
+enable-break => break-enabled
+#% now legal for starting non-keyword symbols
+full floating-point input format supported
+
+Version 0.32: December 4, 1995
+Added weak boxes
++inf.0, -inf.0, -nan.0, +nan.0 constants added
+Better checking when using floats as indices (vector-ref, etc.)
+Better (correct!) hashing procedure
+Fixed threads in Win32s/WinNT by creating a new stack
+Fixed bug in spawning new (MzScheme) processes
+Fixed incorrect process progress (~deadlock) analysis
+Fixed bug in resizing hash table
+Fixed bug in read (reading "+", "-", or "." at EOF)
+Fixed bug in read-number (fractions and forcing; e.g. "../")
+Fixed bug in open-output-string (> 100 chars gave empty result)
+Fixed regexp-replace (memory bug)
+
+Version 0.31: November 14, 1995
+Bignum bigs: subtracting from 0, comparing negative
+(current-eval) initially returned the wrong procedure
+tan procedure added
+putenv
+S-expression graph reading and printing
+
+Version 0.30: October 25, 1995
+Added call-with-values and regexp
+Unix stack-checking setup code fixed
+
+Version 0.29: October 18, 1995
+Added `arity' procedure
+Bug fix related to forms such as (let ([x (let ...)]) ...)
+
+Verion 0.28: October 3, 1995
+Fixed general stack overflow-checking for Unix
+
+Verion 0.27: September 26, 1995
+Moved compilation flags from the Makefile into "sconfig.h"
+More general stack overflow-checking (when needed)
+Computations can overflow the stack and continue
+Changed command line flags; added -r (or --script) flag
+Added multiple inheritance and `rename', `share', and `local' declarations
+Merged Patrick Barta's Windows DLL implementation for `load-extention'
+Re-implemented `quasiquote', `and', and `or' as a macros
+Re-implemented let-forms to make small `let's efficient
+`let*' expands to `let'
+Made core syntactic form names keywords
+Added #% keywords
+Added `hash-table-map' and `hash-table-for-each'
+Fixed bignum bugs: `eqv?'/`equal?' and `modulo'
+Fixed inexact bugs: `floor', `ceiling', and `round'
+Created this "HISTORY" file
diff --git a/src/mzscheme/INSTALL b/src/mzscheme/INSTALL
new file mode 100644
index 0000000..621b33e
--- /dev/null
+++ b/src/mzscheme/INSTALL
@@ -0,0 +1,141 @@
+
+MzScheme should compile and execute with little or no modification if
+you have an ANSI C compiler on any platform supported by the
+conservative garbage collector. Some flags may need adjustment in the
+Makefile and "sconfig.h".  Special per-platform instructions are
+below, followed by some general notes on compilation.
+
+========================================================================
+ Unix
+========================================================================
+
+To compile the `mzscheme' executable for these platforms:
+  Alpha OSF1
+  DEC Ultrix
+  HP/UX
+  i386 FreeBSD
+  i386 Linux
+  RS6000 AIX
+  SGI IRIX
+  Sparc Solaris [see note below]
+  Sparc SunOS4    
+run the `mzmake' script.
+
+[Solaris Note: To ensure that dynamic extensions work right, use the
+ native Solaris `ld' rather than GNU's `ld'.]
+
+Or, to compile the `mzscheme' executable for other Unix platforms:
+
+        1) Edit the Makefile if necessary. Common changes include the 
+           C compiler, compiler flags, ranlib processor (if your
+           machine does not have `ranlib', set RANLIB to ':'), and
+           libraries
+
+        2) Edit "sconfig.h" to set platform-specific flags if necessary
+
+        3) Execute `make bin' (or just `make')
+
+To compile parts of MzScheme for embedding or extending:
+
+        * `[mz]make mzschemelib' (or `mzmake mzschemelib') compiles 
+           libmzscheme.a and libgc.a and puts them in lib/sys
+
+        * `[mz]make mzschemelib++' is like `make lib', but the GC C++
+           tools are included in libgc.a
+
+        * `[mz]make libguile' creates lib/sys/libguile.a; this is
+           libmzscheme.a + libgc.a + compatibility routines to support
+           GNU's emerging GUILE high-level interface specification
+           (still experimental)
+
+        * `[mz]make dynlib' compiles mzdyn.o (for writing
+           dynamically-loaded extensions to MzScheme) and puts
+           it in lib/sys
+
+        * `[mz]make g-c' just compiles /lib/sys/libgc.a
+
+        * `[mz]make dynexample' compiles the example dynamic
+           extension objects/sys/dynexmpl.so; when this is loaded into
+           MzScheme, (by using load-extension), it defines a "date" 
+           procedure
+
+        * `[mz]make oe' compiles a larger example dynamic
+           extension objects/sys/oe.so; when this is loaded into
+           MzScheme, (by using load-extension), it defines "odd",
+           "even", "fib", and "fib2" procedures, and returns
+           two values (#t and #f) when loaded
+
+------------------------------------------------------------------------
+ Compiling for Multiple Unix Platforms
+------------------------------------------------------------------------
+
+MzScheme's Unix makefiles are set up to support compilation for
+multiple platforms in the same filesystem. To differentiate platforms
+for the makefiles, set the MZPLTFORMSUFFIX environment
+variable. Object files (.o files) are placed in the subdirectory
+  objects/sys${MZPLTFORMSUFFIX} 
+and library files (.a files) are placed in the subdirectory 
+  objects/lib${MZPLTFORMSUFFIX}
+
+MZPLTFORMSUFFIX does not need to be defined if you are only compiling
+for a single platform. In this case, object files are put in
+  objects/sys
+and library files are put in
+  lib/sys
+
+The destination for the `mzscheme' binary does not use the
+MZPLTFORMSUFFIX enrionment variable. (That would be too easy.)
+Instead, the MZBUILDDIR envionrment variable designates a destination
+directory for the binary. If MZBUILDDIR is not defined, the binary is
+placed in the same directory as the main "Makefile".
+
+========================================================================
+ Windows
+========================================================================
+
+The `windows' directory contains additional files and information for
+Windows users.
+
+========================================================================
+ MacOS
+========================================================================
+
+The file `mac.sit.hqx' contains additional files and information for
+MacOS users.
+
+========================================================================
+ General Compilation Notes
+========================================================================
+
+By default, MzScheme is compiled:
+
+ * without image dumps (since the application will probably be linked
+   dynamically);
+
+ * without using any OS-specific threads; and
+
+ * without support for simple-precision floating point numbers.
+
+This can be changed by modifying sconfig.h or specifying -D compiler
+flags for the macros described in sconfig.h. (In the latter case, you
+may find it conveneient to edit `mzmake'.)
+
+------------------------------------------------------------------------
+
+The conservative garbage collector distributed with MzScheme has been
+modified slightly from Boehm's standard distribution.
+
+------------------------------------------------------------------------
+
+If you modify MzScheme and change any primitive syntax or the
+collection of built-in identifers, be sure to turn of
+USE_COMPILED_MACROS in schminc.h. Otherwise, MzScheme won't start up.
+
+========================================================================
+ Bug Reports
+========================================================================
+
+Please report bugs using
+  http://www.cs.rice.edu/CS/PLT/Bugs/
+or (as a last resort) send mail to
+  plt-bugs@cs.rice.edu
diff --git a/src/mzscheme/LICENSE b/src/mzscheme/LICENSE
new file mode 100644
index 0000000..6b975dd
--- /dev/null
+++ b/src/mzscheme/LICENSE
@@ -0,0 +1,16 @@
+MzScheme
+Copyright (c) 1995-97 PLT, Rice University (Matthew Flatt)
+
+MzScheme is distributed under the GNU Library General Public License
+(LGPL).  This means you can link MzScheme into proprietary applications,
+provided you follow the specific rules stated in the LGPL.  You can
+also modify MzScheme; if you distribute a modified version, you must
+distribute it under the terms of the LGPL, which in particular means
+that you must release the source code for the modified MzScheme. See
+COPYING.LIB for more information.
+
+MzScheme is derived from libscheme 0.5:
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
diff --git a/src/mzscheme/Makefile b/src/mzscheme/Makefile
new file mode 100644
index 0000000..f7907eb
--- /dev/null
+++ b/src/mzscheme/Makefile
@@ -0,0 +1,331 @@
+#
+# Makefile for mzscheme
+#
+# 'make' or 'make bin' - makes mzscheme
+# 'make mzschemelib' - make libmzscheme.a and libgc.a
+# 'make mzschemelib++' - make libmzscheme.a and libgc.a with C++ GC tools
+# 'make libguile' - make libguile.a
+# 'make dynlib' - make mzdyn.o, for use in extending MzScheme
+# 'make g-c' - makes only libgc.a
+
+# SEE ALSO sconfig.h for more configuration
+
+# This must be an ANSI C compiler.
+CC=gcc
+CXX=gcc
+AS=gcc -c -x assembler-with-cpp
+
+# Debugging flags
+DEBUGFLAGS = -g
+
+# Other options; mainly used to import other options
+#  Add -DUSE_SENORA_GC for SenoraGC
+#  Add -DSOLARIS_THREADS to THREADFLAGS for Solaris threads
+#  Add -DIRIX_SPROCS to THREADFLAGS for Irix sprocs
+OPTIONS = 
+NONLINKOPTIONS = 
+THREADFLAGS = 
+
+# Options required for dynamically-linkable compilation
+DYNOPTIONS =
+
+# Optimization
+OPT = -O2
+
+# Warnings
+WARN = -Wall 
+
+# The math library is needed for the numeric functions
+#  in number.c.
+# You may need -ldl for dlopen, etc.  (Added automatically for AIX.)
+# Add lib$(MZPLATFORMSUFFIX)$(MZTHREADSUFFIX)/sproc.o for Irix
+#  sprocs
+LIBS=-lm # -ldl
+
+# If your system needs ranlib, put it here.  Otherwise,
+# use a colon.
+RANLIB=ranlib
+
+# GC Directory
+# sgc for SenoraGC
+GCDIR = gc
+
+# Objects directory
+OBJDIR = objects/sys$(MZPLATFORMSUFFIX)$(MZTHREADSUFFIX)
+
+# Library directory
+LIBDIR = lib/sys$(MZPLATFORMSUFFIX)$(MZTHREADSUFFIX)
+
+# Binary
+MZSCHEME = $(MZBUILDDIR)mzscheme
+
+# Extra makes needed for gc lib
+# Change to sproc-extra-lib for Irix sprocs
+GCLIBMAKEEXTRA = no-extra-lib
+
+################################################################################
+
+# Destination for support files installation (Probably PLT only)
+INSTALLDEST = /home/scheme/plt
+
+# Export string for making src & GC
+EXPORT= CC='$(CC)' CXX='$(CXX)' AS='$(AS)' RANLIB='$(RANLIB)' DEBUGFLAGS='$(DEBUGFLAGS)' OPTIONS='$(OPTIONS) $(THREADFLAGS)' DYNOPTIONS='$(DYNOPTIONS)' WARN='$(WARN)' OPT='$(OPT)' OBJDIR='$(OBJDIR)' GCDIR='$(GCDIR)' LIBS='$(LIBS)' GCLIBMAKEEXTRA='$(GCLIBMAKEEXTRA)'
+
+MAIN_CFLAGS_NODBG = $(WARN) $(OPT) $(FLAGS) $(OPTIONS) $(THREADFLAGS) -Iinclude
+MAIN_CFLAGS = $(DEBUGFLAGS) $(NONLINKOPTIONS) $(MAIN_CFLAGS_NODBG)
+
+XMAKE = $(MAKE) $(EXPORT)
+
+bin: 
+	$(XMAKE) g-c
+	./ifaix $(XMAKE) rs6kbin
+	./ifnotaix $(XMAKE) xbin
+
+rs6kbin:
+	./ifaix $(XMAKE) aixdl
+	$(XMAKE) LIBS='$(LIBS) -ldl -lld -Wl,-bE:include/mzscheme.exp' xbin
+
+xbin:
+	$(XMAKE) mzlibrary
+	$(XMAKE) $(MZSCHEME) 
+
+mzschemelib: 
+	./ifaix $(XMAKE) aixdl
+	$(XMAKE) g-c 
+	$(XMAKE) mzlibrary 
+
+mzschemelib++:
+	./ifaix $(XMAKE) aixdl
+	$(XMAKE) g-c 
+	cd $(GCDIR); $(XMAKE) $(OBJDIR)/gc_cpp.o 
+	$(XMAKE) $(GCDIR)/$(OBJDIR)/gc.a
+	$(XMAKE) $(LIBDIR)/libgc.a
+	$(XMAKE) mzlibrary
+
+libguile:
+	$(XMAKE) mzschemelib
+	cd guile; $(XMAKE)
+
+$(LIBDIR): 
+	mkdir $(LIBDIR)
+lib:
+	mkdir lib
+
+$(OBJDIR): 
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+dynlib:
+	cd dynsrc; $(XMAKE) LIBDIR='$(LIBDIR)' -e dynlib 
+
+dynexample:
+	$(XMAKE) dynlib
+	cd dynsrc; $(XMAKE) LIBDIR='$(LIBDIR)' -e dynexample 
+
+withwin:
+	$(XMAKE) dynlib
+	cd dynsrc; $(XMAKE) -e withwin 
+
+oe:
+	$(XMAKE) dynlib
+	cd dynsrc; $(XMAKE) -e oe
+
+aixdl:
+	cd aixdlfcn; $(MAKE) CC=cc
+	$(XMAKE) $(LIBDIR)/libdl.a
+
+g-c: $(GCDIR)/objects $(GCDIR)/$(OBJDIR)
+	cd $(GCDIR); $(XMAKE) -e $(OBJDIR)/gc.a 
+	$(XMAKE) $(LIBDIR)/libgc.a
+	$(XMAKE) $(GCLIBMAKEEXTRA)
+
+no-extra-lib: # Do nothing
+
+sproc-extra-lib:
+	cd $(GCDIR); $(XMAKE) -e $(OBJDIR)/sproc.o
+	$(XMAKE) $(LIBDIR)/sproc.o
+
+$(GCDIR)/$(OBJDIR): 
+	mkdir $(GCDIR)/$(OBJDIR)
+gc/objects:
+	mkdir gc/objects
+sgc/objects:
+	mkdir sgc/objects
+
+$(GCDIR)/$(OBJDIR)/gc.a: $(GCDIR)/$(OBJDIR)/*.o
+	$(AR) ruv $(GCDIR)/$(OBJDIR)/gc.a $(GCDIR)/$(OBJDIR)/*.o  
+
+mzlibrary: lib $(LIBDIR) 
+	cd src; $(XMAKE) -e all 
+	$(XMAKE) $(LIBDIR)/libmzscheme.a
+
+$(LIBDIR)/libmzscheme.a: src/$(OBJDIR)/*.o
+	$(AR) ruv $(LIBDIR)/libmzscheme.a src/$(OBJDIR)/*.o
+	$(RANLIB) $(LIBDIR)/libmzscheme.a
+
+$(LIBDIR)/libgc.a: lib $(LIBDIR) $(GCDIR)/$(OBJDIR)/gc.a
+	cp $(GCDIR)/$(OBJDIR)/gc.a $(LIBDIR)/libgc.a
+	$(RANLIB) $(LIBDIR)/libgc.a
+
+# Irix sproc, only
+$(LIBDIR)/sproc.o: lib $(LIBDIR) $(GCDIR)/$(OBJDIR)/sproc.o
+	cp $(GCDIR)/$(OBJDIR)/sproc.o $(LIBDIR)/sproc.o
+
+$(LIBDIR)/libdl.a: aixdlfcn/libdl.a
+	cp aixdlfcn/libdl.a $(LIBDIR)/libdl.a
+$(GCDIR)/$(OBJDIR)/gc_cpp.o:
+	cd $(GCDIR); $(XMAKE) -e c++ 
+
+$(MZSCHEME): objects $(OBJDIR) $(LIBDIR)/libmzscheme.a $(LIBDIR)/libgc.a $(OBJDIR)/main.o $(SPECIALIZINGOBJECTS)
+	$(CC) $(MAIN_CFLAGS_NODBG) -o $(MZSCHEME) $(OBJDIR)/main.o $(SPECIALIZINGOBJECTS) -L$(LIBDIR)/ -lmzscheme -lgc $(LIBS)
+
+$(OBJDIR)/main.o: main.c include/scheme.h sconfig.h
+	$(CC) $(MAIN_CFLAGS) -c main.c -o $(OBJDIR)/main.o
+
+testext.o: testext.c
+	$(CC) $(MAIN_CFLAGS) -I/home/scheme/plt/compiler/ -c testext.c -o testext.o
+
+CMACRODEST = cmacro.inc
+
+cmacro:
+	$(XMAKE) src/$(CMACRODEST)
+	$(XMAKE) src/cunitsig.inc
+
+headers:
+	$(XMAKE) ../collects/mzscheme/include/scheme.h
+
+../collects/mzscheme/include/scheme.h: sconfig.h uconfig.h include/escheme.h src/schemef.h \
+                                       src/stypes.h src/schemex.h src/schemexm.h src/schexn.h \
+                                       include/ext.exp include/mzscheme.exp include/scheme.h
+	rm -rf ../collects/mzscheme/include
+	mkdir ../collects/mzscheme/include
+	cp sconfig.h uconfig.h include/escheme.h src/schemef.h \
+          src/stypes.h src/schemex.h src/schemexm.h src/schexn.h \
+          include/ext.exp include/mzscheme.exp ../collects/mzscheme/include 
+	perl -ne 's/\/\*III\*\//\#define INCLUDE_WITHOUT_PATHS/; print' \
+          < include/scheme.h > ../collects/mzscheme/include/scheme.h
+
+src/$(CMACRODEST): src/macro.ss src/schvers.h
+	cd src; ../$(MZSCHEME) -gqrna sstoinc.ss $(CMACROEXTRA) < macro.ss > $(CMACRODEST)
+
+src/cunitsig.inc: src/unitsig.ss src/schvers.h
+	cd src; ../$(MZSCHEME) -gqrna sstoinc.ss < unitsig.ss > cunitsig.inc
+
+cmacro.zo:
+	$(XMAKE) cmacro CMACROEXTRA='zo' CMACRODEST="../cmacro.zo"
+
+zo:
+	rm -f ../collects/mzlib/compiled/*.zo
+	rm -f ../collects/mzlib/compiled/*/*.so
+	$(MZSCHEME) -qf mkmzlib.ss -e '(make-zo)' -e '(exit)'
+
+depend:
+	cd src; $(XMAKE) -e depend 
+	cd dynsrc; $(XMAKE) -e depend 
+
+tmpclean:
+	/bin/rm -rf tmp[123456789] tests/tmp[123456789] tests/sub[123]
+
+tests-clean:
+	$(XMAKE) tmpclean
+	/bin/rm -f tests/*~
+
+clean:
+	$(XMAKE) tmpclean
+	$(XMAKE) tests-clean
+	/bin/rm -f objects/*/*.o *~ Makefile.bak utils/*~ include/*~ ../collects/mzlib/*~ core
+	/bin/rm -f aixdlfcn/dlfcn.o aixdlfcn/libdl.a 
+	cd gc; $(XMAKE) clean
+	cd sgc; $(XMAKE) clean
+	cd src; $(XMAKE) clean
+	cd dynsrc; $(XMAKE) clean
+	cd aixdlfcn; $(XMAKE) clean
+	cd guile; $(XMAKE) clean
+
+# exile & repatriate for my development process
+
+HIDEDIR = /home/mflatt/mredhide
+
+exile: lib objects gc/objects sgc/objects
+	mkdir $(HIDEDIR)/mzscheme_lib
+	mv lib $(HIDEDIR)/mzscheme_lib
+	mkdir $(HIDEDIR)/mzscheme_main_objects
+	mv objects $(HIDEDIR)/mzscheme_main_objects
+	mv .bin $(HIDEDIR)/mzscheme_main_objects
+	mkdir $(HIDEDIR)/mzscheme_objects
+	mv src/objects $(HIDEDIR)/mzscheme_objects
+	mkdir $(HIDEDIR)/gc_objects
+	mv gc/objects $(HIDEDIR)/gc_objects	
+	mkdir $(HIDEDIR)/sgc_objects
+	mv sgc/objects $(HIDEDIR)/sgc_objects	
+	mkdir $(HIDEDIR)/guile_objects
+	mv guile/objects $(HIDEDIR)/guile_objects	
+	mkdir $(HIDEDIR)/dynsrc_objects
+	mv dynsrc/objects $(HIDEDIR)/dynsrc_objects	
+	mkdir $(HIDEDIR)/mzscheme_collects
+	mv ../collects/mzscheme/lib $(HIDEDIR)/mzscheme_collects
+	$(XMAKE) clean
+	/bin/rm -f aixdlfcn/dlfcn.o aixdlfcn/libdl.a 
+	/bin/rm -f $(LIBDIR)/* mzscheme withwin.so dynexmpl.so oe.so
+	/bin/rm ../collects/mzlib/RCS
+	/bin/rm tests/RCS
+
+repatriate:
+	mv $(HIDEDIR)/mzscheme_lib/lib .
+	rmdir $(HIDEDIR)/mzscheme_lib
+	mv $(HIDEDIR)/mzscheme_main_objects/objects .
+	mv $(HIDEDIR)/mzscheme_main_objects/.bin .
+	rmdir $(HIDEDIR)/mzscheme_main_objects
+	mv $(HIDEDIR)/mzscheme_objects/objects src
+	rmdir $(HIDEDIR)/mzscheme_objects
+	mv $(HIDEDIR)/gc_objects/objects gc
+	rmdir $(HIDEDIR)/gc_objects
+	mv $(HIDEDIR)/sgc_objects/objects sgc
+	rmdir $(HIDEDIR)/sgc_objects
+	mv $(HIDEDIR)/guile_objects/objects guile
+	rmdir $(HIDEDIR)/guile_objects
+	mv $(HIDEDIR)/dynsrc_objects/objects dynsrc
+	rmdir $(HIDEDIR)/dynsrc_objects
+	mv $(HIDEDIR)/mzscheme_collects/lib ../collects/mzscheme/lib
+	rmdir $(HIDEDIR)/mzscheme_collects
+	/bin/ln -s /home/scheme/plt/collects/mzlib/RCS ../collects/mzlib/RCS
+	/bin/ln -s /home/scheme/plt/tests/mzscheme/RCS tests/RCS
+
+# Doesn't install binaries, only support files:
+install:
+	rm -rf ../collects/mzlib/*~
+	@echo --- README, etc. ---
+	cp README SCRIPTS HISTORY COPYING.LIB mzscheme.init openbugs $(INSTALLDEST)/notes/mzscheme
+	@echo --- tests ---
+	cd tests; echo 'for file in *.ss ; do if [ "`rlog -R -Lmflatt $$file`" != "" ] ; then ci -l -mrelease $$file ; fi ; done' | sh -t 
+	cd tests; ci -l -mrelease README
+	cd $(INSTALLDEST)/tests/mzscheme; co RCS/*
+	$(XMAKE) install-mzlib	
+	$(XMAKE) install-scripts
+	$(XMAKE) install-dynext
+	$(XMAKE) install-headers
+
+install-mzlib:
+	@echo --- mzlib ---
+	cd ../collects/mzlib; echo 'for file in *.ss ; do if [ "`rlog -R -Lmflatt $$file`" != "" ] ; then ci -l -mrelease $$file ; fi ; done' | sh -t
+	cd $(INSTALLDEST)/collects/mzlib; /home/scheme/Executables/update
+	rm -f $(INSTALLDEST)/collects/mzlib/compiled/*.zo
+	cp ../collects/mzlib/compiled/*.zo $(INSTALLDEST)/collects/mzlib/compiled 
+	touch $(INSTALLDEST)/collects/mzlib/compiled/*.zo
+
+install-scripts:
+	@echo --- script ---
+	cp mzscheme.sh $(INSTALLDEST)/bin/mzscheme
+	cp dynsrc/dynlink $(INSTALLDEST)/bin/dynlink
+
+install-dynext:
+	@echo --- script ---
+	rm -rf $(INSTALLDEST)/collects/mzscheme/dynext/*
+	cp ../collects/mzscheme/dynext/* $(INSTALLDEST)/collects/mzscheme/dynext
+
+install-headers:
+	$(XMAKE) headers
+	@echo --- headers ---
+	rm -rf $(INSTALLDEST)/collects/mzscheme/include/*
+	cp ../collects/mzscheme/include/* $(INSTALLDEST)/collects/mzscheme/include
diff --git a/src/mzscheme/README b/src/mzscheme/README
new file mode 100644
index 0000000..7bd15ff
--- /dev/null
+++ b/src/mzscheme/README
@@ -0,0 +1,37 @@
+MzScheme (pronounced "Ms. Scheme") is an implementation of R4RS Scheme
+extended with an object system and time-preempted threads.  It uses
+libscheme 0.5's interface for embedding and/or extending the core
+interpreter with other C/C++ programs. MzScheme's virtual machine,
+implemented in C, is easily ported to any platform with 32-bit or
+64-bit addresses. MzScheme is used in MrEd, an engine for portable GUI
+applications.
+
+Please see the file LICENSE for license information.
+
+Documentation and up-to-date information about MzScheme are at
+ http://www.cs.rice.edu/CS/PLT/packages/mzscheme/
+
+If you are compiling MzScheme, see the INSTALL file for compilation
+instructions. 
+
+If you have a compiled MzScheme, then the `mzlib' directory should be
+in a `collects' directory that is in the same directory as the
+`mzscheme' executable. If you use the PLT directory configuration,
+then `plt/.bin/PLATFORM/' (where PLATFORM is a tag indicating your
+platform, as returned by `plt/bin/archsys') should contain the binary
+and `plt/collects' should contain `mzlib'.
+
+See SCRIPTS for information about writing MzScheme scripts for Unix
+platforms.
+
+Comments and bug reports are welcome. 
+Please report bugs using
+  http://www.cs.rice.edu/CS/PLT/Bugs/
+or (as a last resort) send mail to
+  plt-bugs@cs.rice.edu
+
+-Matthew Flatt
+ Rice University PLT
+ mflatt@cs.rice.edu
+ http://www.cs.rice.edu/~mflatt/
+
diff --git a/src/mzscheme/SCRIPTS b/src/mzscheme/SCRIPTS
new file mode 100644
index 0000000..378115b
--- /dev/null
+++ b/src/mzscheme/SCRIPTS
@@ -0,0 +1,40 @@
+When MzScheme is installed as part of the standard Unix PLT
+distribution, the executable ${PLTHOME}/bin/mzscheme is actually a
+script that selects an executable based on the current platform. This
+is done to support multiple platforms in a single PLT installation.
+
+Unfortunately, this causes problems for writing scripts that use
+MzScheme, because the shell's #! convention requires that a binary is
+specified.
+
+Fortunately, there is a sneaky workaround. To write a MzScheme script,
+use the following at the top of your script:
+
+  #!/bin/sh
+  string=? ; exec ${PLTHOME}/bin/mzscheme -r $0 $0 ${1+"$@"}
+
+  ... <scheme program> ...
+
+(It may be better to hardwire the path to mzscheme instead of using
+${PLTHOME}.)
+
+Within <scheme program>, (vector-ref argv 0) is the name of the
+script; arguments passed to the script start at (vector-ref argv 1).
+
+How does this work? "#!/bin/sh" causes the shell to run /bin/sh on the
+file. The first command, "string=?" is a harmless assignment, and ";"
+separates this assignment from the "exec" command. The "exec" command
+replaces /bin/sh with mzscheme (so /bin/sh does not see the actual
+Scheme program). The "-r" flag tells mzscheme to load the next
+argument as a script and forces the remaining arguments into
+`argv'. (For information on ${1+"$@"}, consult your `sh' man page.)
+Thus, mzscheme will start up and load this file. As always, mzscheme
+ignores "#!" in the first line of a loaded file as a comment. And
+"string=?" is again a harmless expression (since it's a built-in
+variable). The ";" starts a Scheme comment, so the "exec" expression
+is ignored. Finally, mzscheme continues to load the file and evaluates
+the real Scheme program.
+
+Thanks to J. P. Lewis <zilla@interval.com> for the basic idea behind
+this trick. Many others have suggested alternatives to `string=?'
+for shells other than /bin/sh.
diff --git a/src/mzscheme/aixdlfcn/Makefile b/src/mzscheme/aixdlfcn/Makefile
new file mode 100644
index 0000000..e8c1a8a
--- /dev/null
+++ b/src/mzscheme/aixdlfcn/Makefile
@@ -0,0 +1,45 @@
+# %W% revision of %E%  %U%
+# This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
+# 30159 Hannover, Germany
+
+# Do not edit at HELIOS, edit GNUmakefile instead!
+
+SHELL=/bin/sh
+IPATH=
+DEFS=
+DEBUGFLAGS=-g -DDEBUG
+NODEBUGFLAGS=-O
+CFLAGS=$(IPATH) $(DEFS) $(NODEBUGFLAGS)
+TARGET=libdl.a
+DEST=/usr/local/lib
+HDRS=dlfcn.h
+SRCS=dlfcn.c
+NOSTART=-e _nostart	# for AIX 3
+#NOSTART=-bnoentry	# for AIX 4
+OBJS=$(SRCS:%.c=%.o)
+
+all:		$(TARGET) dlfcn.c
+
+dlfcn.o:	dlfcn.h
+
+$(TARGET):	$(OBJS) dl.exp
+#		$(CC) $(CFLAGS) -o $@ $(OBJS) -bE:dl.exp -bM:SRE $(NOSTART) -lld
+		$(AR) ruv libdl.a dlfcn.o
+
+lint:
+		lint $(IPATH) $(DEFS) $(SRCS) >lintout
+
+info:
+		sccs info
+
+clean:
+		rm -f lintout a.out core *.o *-lg *% *~ tags deps%
+
+clobber:	clean
+		rm -f $(TARGET) deps
+
+install:	all
+		cp $(TARGETS) $(DEST)
+
+shar:
+		shar README Makefile dlfcn.h dlfcn.c dl.exp >dlfcn.shar
diff --git a/src/mzscheme/aixdlfcn/README b/src/mzscheme/aixdlfcn/README
new file mode 100644
index 0000000..cee1b75
--- /dev/null
+++ b/src/mzscheme/aixdlfcn/README
@@ -0,0 +1,246 @@
+Copyright (c) 1992,1993,1995,1996, Jens-Uwe Mager, Helios Software GmbH
+Not derived from licensed software.
+
+Permission is granted to freely use, copy, modify, and redistribute
+this software, provided that the author is not construed to be liable
+for any results of using the software, alterations are clearly marked
+as such, and this notice is not modified.
+
+libdl.a
+-------
+
+This is an emulation library to emulate the SunOS/System V.4 functions
+to access the runtime linker. The functions are emulated by using the
+AIX load() function and by reading the .loader section of the loaded
+module to find the exports. The to be loaded module should be linked as
+follows (if using AIX 3):
+
+	cc -o module.so -bM:SRE -bE:module.exp -e _nostart $(OBJS)
+
+For AIX 4:
+
+	cc -o module.so -bM:SRE -bE:module.exp -bnoentry $(OBJS)
+
+If you want to reference symbols from the main part of the program in a
+loaded module, you will have to link against the export file of the
+main part:
+
+	cc -o main -bE:main.exp $(MAIN_OBJS)
+	cc -o module.so -bM:SRE -bI:main.exp -bE:module.exp -bnoentry $(OBJS)
+
+Note that you explicitely have to specify what functions are supposed
+to be accessible from your loaded modules, this is different from
+SunOS/System V.4 where any global is automatically exported. If you
+want to export all globals, the following script might be of help:
+
+#!/bin/sh
+/usr/ucb/nm -g $* | awk '$2 == "B" || $2 == "D" { print $3 }'
+
+The module export file contains the symbols to be exported. Because
+this library uses the loader section, the final module.so file can be
+stripped. C++ users should build their shared objects using the script
+makeC++SharedLib (part of the IBM C++ compiler), this will make sure
+that constructors and destructors for static and global objects will be
+called upon loading and unloading the module. GNU C++ users should use
+the -shared option to g++ to link the shared object:
+
+	g++ -o module.so -shared $(OBJS)
+
+If the shared object does have permissions for anybody, the shared
+object will be loaded into the shared library segment and it will stay
+there even if the main application terminates. If you rebuild your
+shared object after a bugfix and you want to make sure that you really
+get the newest version you will have to use the "slibclean" command
+before starting the application again to garbage collect the shared
+library segment. If the performance utilities (bosperf) are installed
+you can use the following command to see what shared objects are
+loaded:
+
+/usr/lpp/bosperf/genkld | sort | uniq
+
+For easier debugging you can avoid loading the shared object into the
+shared library segment alltogether by removing permissions for others
+from the module.so file:
+
+chmod o-rwx module.so
+
+This will ensure you get a fresh copy of the shared object for every
+dlopen() call which is loaded into the application's data segment.
+
+Usage
+-----
+
+void *dlopen(const char *path, int mode);
+
+This routine loads the module pointed to by path and reads its export
+table. If the path does not contain a '/' character, dlopen will search
+for the module using the LIBPATH environment variable. It returns an
+opaque handle to the module or NULL on error. The mode parameter can be
+either RTLD_LAZY (for lazy function binding) or RTLD_NOW for immediate
+function binding. The AIX implementation currently does treat RTLD_NOW
+the same as RTLD_LAZY. The flag RTLD_GLOBAL might be or'ed into the
+mode parameter to allow loaded modules to bind to global variables or
+functions in other loaded modules loaded by dlopen(). If RTLD_GLOBAL is
+not specified, only globals from the main part of the executable or
+shared libraries are used to look for undefined symbols in loaded
+modules.
+
+
+void *dlsym(void *handle, const char *symbol);
+
+This routine searches for the symbol in the module referred to by
+handle and returns its address. If the symbol could not be found, the
+function returns NULL. The return value must be casted to a proper
+function pointer before it can be used. SunOS/System V.4 allows handle
+to be a NULL pointer to refer to the module the call is made from, this
+is not implemented.
+
+int dlclose(void *handle);
+
+This routine unloads the module referred to by the handle and disposes
+of any local storage. this function returns -1 on failure. Any function
+pointers obtained through dlsym() should be considered invalid after
+closing a module.
+
+As AIX caches shared objects in the shared library segment, function
+pointers obtained through dlsym() might still work even though the
+module has been unloaded. This can introduce subtle bugs that will
+segment fault later if AIX garbage collects or immediatly on
+SunOS/System V.4 as the text segment is unmapped.
+
+char *dlerror(void);
+
+This routine can be used to retrieve a text message describing the most
+recent error that occured on on of the above routines. This function
+returns NULL if there is no error information.
+
+Initialization and termination handlers
+---------------------------------------
+
+The emulation provides for an initialization and a termination
+handler.  The dlfcn.h file contains a structure declaration named
+dl_info with following members:
+
+	void (*init)(void);
+	void (*fini)(void);
+
+The init function is called upon first referencing the library. The
+fini function is called at dlclose() time or when the process exits.
+The module should declare a variable named dl_info that contains this
+structure which must be exported.  These functions correspond to the
+documented _init() and _fini() functions of SunOS 4.x, but these are
+appearently not implemented in SunOS.  When using SunOS 5.0, these
+correspond to #pragma init and #pragma fini respectively. At the same
+time any static or global C++ object's constructors or destructors will
+be called.
+
+BUGS
+----
+
+Please note that there is currently a problem with implicitely loaded
+shared C++ libaries: if you refer to a shared C++ library from a loaded
+module that is not yet used by the main program, the dlopen() emulator
+does not notice this and does not call the static constructors for the
+implicitely loaded library. This can be easily demonstrated by
+referencing the C++ standard streams from a loaded module if the main
+program is a plain C program.
+
+Jens-Uwe Mager
+
+HELIOS Software GmbH
+Lavesstr. 80
+30159 Hannover
+Germany
+
+Phone:		+49 511 36482-0
+FAX:		+49 511 36482-69
+AppleLink:	helios.de/jum
+Internet:	jum@helios.de
+
+Revison History
+---------------
+
+SCCS/s.dlfcn.h:
+
+D 1.4 95/04/25 09:36:52 jum 4 3	00018/00004/00028
+MRs:
+COMMENTS:
+added RTLD_GLOBAL, include and C++ guards
+
+D 1.3 92/12/27 20:58:32 jum 3 2	00001/00001/00031
+MRs:
+COMMENTS:
+we always have prototypes on RS/6000
+
+D 1.2 92/08/16 17:45:11 jum 2 1	00009/00000/00023
+MRs:
+COMMENTS:
+added dl_info structure to implement initialize and terminate functions
+
+D 1.1 92/08/02 18:08:45 jum 1 0	00023/00000/00000
+MRs:
+COMMENTS:
+Erstellungsdatum und -uhrzeit 92/08/02 18:08:45 von jum
+
+SCCS/s.dlfcn.c:
+
+D 1.11 96/04/10 20:12:51 jum 13 12	00037/00000/00533
+MRs:
+COMMENTS:
+Integrated the changes from John W. Eaton <jwe@bevo.che.wisc.edu> to initialize
+g++ generated shared objects.
+
+D 1.10 96/02/15 17:42:44 jum 12 10	00012/00007/00521
+MRs:
+COMMENTS:
+the C++ constructor and destructor chains are now called properly for either
+xlC 2 or xlC 3 (CSet++).
+
+D 1.9 95/09/22 11:09:38 markus 10 9	00001/00008/00527
+MRs:
+COMMENTS:
+Fix version number
+
+D 1.8 95/09/22 10:14:34 markus 9 8	00008/00001/00527
+MRs:
+COMMENTS:
+Added version number for dl lib
+
+D 1.7 95/08/14 19:08:38 jum 8 6	00026/00004/00502
+MRs:
+COMMENTS:
+Integrated the fixes from Kirk Benell (kirk@rsinc.com) to allow loading of
+shared objects generated under AIX 4. Fixed bug that symbols with exactly
+8 characters would use garbage characters from the following symbol value.
+
+D 1.6 95/04/25 09:38:03 jum 6 5	00046/00006/00460
+MRs:
+COMMENTS:
+added handling of C++ static constructors and destructors, added RTLD_GLOBAL to bind against other loaded modules
+
+D 1.5 93/02/14 20:14:17 jum 5 4	00002/00000/00464
+MRs:
+COMMENTS:
+added path to dlopen error message to make clear where there error occured.
+
+D 1.4 93/01/03 19:13:56 jum 4 3	00061/00005/00403
+MRs:
+COMMENTS:
+to allow calling symbols in the main module call load with L_NOAUTODEFER and 
+do a loadbind later with the main module.
+
+D 1.3 92/12/27 20:59:55 jum 3 2	00066/00008/00342
+MRs:
+COMMENTS:
+added search by L_GETINFO if module got loaded by LIBPATH
+
+D 1.2 92/08/16 17:45:43 jum 2 1	00074/00006/00276
+MRs:
+COMMENTS:
+implemented initialize and terminate functions, added reference counting to avoid multiple loads of the same library
+
+D 1.1 92/08/02 18:08:45 jum 1 0	00282/00000/00000
+MRs:
+COMMENTS:
+Erstellungsdatum und -uhrzeit 92/08/02 18:08:45 von jum
+
diff --git a/src/mzscheme/aixdlfcn/dl.exp b/src/mzscheme/aixdlfcn/dl.exp
new file mode 100644
index 0000000..03c048d
--- /dev/null
+++ b/src/mzscheme/aixdlfcn/dl.exp
@@ -0,0 +1,7 @@
+#!
+dlopen
+dlclose
+dlsym
+dlerror
+dl_version
+dlVersionCheck
diff --git a/src/mzscheme/aixdlfcn/dlfcn.c b/src/mzscheme/aixdlfcn/dlfcn.c
new file mode 100644
index 0000000..f5809db
--- /dev/null
+++ b/src/mzscheme/aixdlfcn/dlfcn.c
@@ -0,0 +1,570 @@
+/*
+ * @(#)dlfcn.c	1.11 revision of 96/04/10  20:12:51
+ * This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
+ * 30159 Hannover, Germany
+ */
+
+/*
+ * Changes marked with `--jwe' were made on April 7 1996 by John W. Eaton
+ * <jwe@bevo.che.wisc.edu> to support g++ and/or use with Octave.
+ */
+
+/*
+ * This makes my life easier with Octave.  --jwe
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/ldr.h>
+#include <a.out.h>
+#include <ldfcn.h>
+#include "dlfcn.h"
+
+/*
+ * We simulate dlopen() et al. through a call to load. Because AIX has
+ * no call to find an exported symbol we read the loader section of the
+ * loaded module and build a list of exported symbols and their virtual
+ * address.
+ */
+
+typedef struct {
+	char		*name;		/* the symbols's name */
+	void		*addr;		/* its relocated virtual address */
+} Export, *ExportPtr;
+
+/*
+ * xlC uses the following structure to list its constructors and
+ * destructors. This is gleaned from the output of munch.
+ */
+typedef struct {
+	void (*init)(void);		/* call static constructors */
+	void (*term)(void);		/* call static destructors */
+} Cdtor, *CdtorPtr;
+
+typedef void (*GccCDtorPtr)(void);
+
+/*
+ * The void * handle returned from dlopen is actually a ModulePtr.
+ */
+typedef struct Module {
+	struct Module	*next;
+	char		*name;		/* module name for refcounting */
+	int		refCnt;		/* the number of references */
+	void		*entry;		/* entry point from load */
+	struct dl_info	*info;		/* optional init/terminate functions */
+	CdtorPtr	cdtors;		/* optional C++ constructors */
+	GccCDtorPtr	gcc_ctor;	/* g++ constructors  --jwe */
+	GccCDtorPtr	gcc_dtor;	/* g++ destructors  --jwe */
+	int		nExports;	/* the number of exports found */
+	ExportPtr	exports;	/* the array of exports */
+} Module, *ModulePtr;
+
+/*
+ * We keep a list of all loaded modules to be able to call the fini
+ * handlers and destructors at atexit() time.
+ */
+static ModulePtr modList;
+
+/*
+ * The last error from one of the dl* routines is kept in static
+ * variables here. Each error is returned only once to the caller.
+ */
+static char errbuf[BUFSIZ];
+static int errvalid;
+
+/*
+ * The `fixed' gcc header files on AIX 3.2.5 provide a prototype for
+ * strdup().  --jwe
+ */
+#ifndef HAVE_STRDUP
+extern char *strdup(const char *);
+#endif
+static void caterr(char *);
+static int readExports(ModulePtr);
+static void terminate(void);
+static void *findMain(void);
+
+void *dlopen(const char *path, int mode)
+{
+	register ModulePtr mp;
+	static void *mainModule;
+
+	/*
+	 * Upon the first call register a terminate handler that will
+	 * close all libraries. Also get a reference to the main module
+	 * for use with loadbind.
+	 */
+	if (!mainModule) {
+		if ((mainModule = findMain()) == NULL)
+			return NULL;
+		atexit(terminate);
+	}
+	/*
+	 * Scan the list of modules if we have the module already loaded.
+	 */
+	for (mp = modList; mp; mp = mp->next)
+		if (strcmp(mp->name, path) == 0) {
+			mp->refCnt++;
+			return mp;
+		}
+	if ((mp = (ModulePtr)calloc(1, sizeof(*mp))) == NULL) {
+		errvalid++;
+		strcpy(errbuf, "calloc: ");
+		strcat(errbuf, strerror(errno));
+		return NULL;
+	}
+	if ((mp->name = strdup(path)) == NULL) {
+		errvalid++;
+		strcpy(errbuf, "strdup: ");
+		strcat(errbuf, strerror(errno));
+		free(mp);
+		return NULL;
+	}
+	/*
+	 * load should be declared load(const char *...). Thus we
+	 * cast the path to a normal char *. Ugly.
+	 */
+	if ((mp->entry = (void *)load((char *)path, L_NOAUTODEFER, NULL)) == NULL) {
+		free(mp->name);
+		free(mp);
+		errvalid++;
+		strcpy(errbuf, "dlopen: ");
+		strcat(errbuf, path);
+		strcat(errbuf, ": ");
+		/*
+		 * If AIX says the file is not executable, the error
+		 * can be further described by querying the loader about
+		 * the last error.
+		 */
+		if (errno == ENOEXEC) {
+			char *tmp[BUFSIZ/sizeof(char *)];
+			if (loadquery(L_GETMESSAGES, tmp, sizeof(tmp)) == -1)
+				strcpy(errbuf, strerror(errno));
+			else {
+				char **p;
+				for (p = tmp; *p; p++)
+					caterr(*p);
+			}
+		} else
+			strcat(errbuf, strerror(errno));
+		return NULL;
+	}
+	mp->refCnt = 1;
+	mp->next = modList;
+	modList = mp;
+	if (loadbind(0, mainModule, mp->entry) == -1) {
+		dlclose(mp);
+		errvalid++;
+		strcpy(errbuf, "loadbind: ");
+		strcat(errbuf, strerror(errno));
+		return NULL;
+	}
+	/*
+	 * If the user wants global binding, loadbind against all other
+	 * loaded modules.
+	 */
+	if (mode & RTLD_GLOBAL) {
+		register ModulePtr mp1;
+		for (mp1 = mp->next; mp1; mp1 = mp1->next)
+			if (loadbind(0, mp1->entry, mp->entry) == -1) {
+				dlclose(mp);
+				errvalid++;
+				strcpy(errbuf, "loadbind: ");
+				strcat(errbuf, strerror(errno));
+				return NULL;
+			}
+	}
+	if (readExports(mp) == -1) {
+		dlclose(mp);
+		return NULL;
+	}
+	/*
+	 * If there is a dl_info structure, call the init function.
+	 */
+	if (mp->info = (struct dl_info *)dlsym(mp, "dl_info")) {
+		if (mp->info->init)
+			(*mp->info->init)();
+	} else
+		errvalid = 0;
+	/*
+	 * If the shared object was compiled using xlC we will need
+	 * to call static constructors (and later on dlclose destructors).
+	 */
+	if (mp->cdtors = (CdtorPtr)dlsym(mp, "__cdtors")) {
+		CdtorPtr cp = mp->cdtors;
+		while (cp->init || cp->term) {
+			if (cp->init && cp->init != (void (*)(void))0xffffffff)
+				(*cp->init)();
+			cp++;
+		}
+	/*
+	 * If the shared object was compiled using g++, we will need
+	 * to call global constructors using the _GLOBAL__DI function,
+	 * and later, global destructors using the _GLOBAL_DD
+	 * funciton.  --jwe
+	 */
+	} else if (mp->gcc_ctor = (GccCDtorPtr)dlsym(mp, "_GLOBAL__DI")) {
+		(*mp->gcc_ctor)();
+		mp->gcc_dtor = (GccCDtorPtr)dlsym(mp, "_GLOBAL__DD"); 
+	} else
+		errvalid = 0;
+	return mp;
+}
+
+/*
+ * Attempt to decipher an AIX loader error message and append it
+ * to our static error message buffer.
+ */
+static void caterr(char *s)
+{
+	register char *p = s;
+
+	while (*p >= '0' && *p <= '9')
+		p++;
+	switch(atoi(s)) {
+	case L_ERROR_TOOMANY:
+		strcat(errbuf, "to many errors");
+		break;
+	case L_ERROR_NOLIB:
+		strcat(errbuf, "can't load library");
+		strcat(errbuf, p);
+		break;
+	case L_ERROR_UNDEF:
+		strcat(errbuf, "can't find symbol");
+		strcat(errbuf, p);
+		break;
+	case L_ERROR_RLDBAD:
+		strcat(errbuf, "bad RLD");
+		strcat(errbuf, p);
+		break;
+	case L_ERROR_FORMAT:
+		strcat(errbuf, "bad exec format in");
+		strcat(errbuf, p);
+		break;
+	case L_ERROR_ERRNO:
+		strcat(errbuf, strerror(atoi(++p)));
+		break;
+	default:
+		strcat(errbuf, s);
+		break;
+	}
+}
+
+void *dlsym(void *handle, const char *symbol)
+{
+	register ModulePtr mp = (ModulePtr)handle;
+	register ExportPtr ep;
+	register int i;
+
+	/*
+	 * Could speed up the search, but I assume that one assigns
+	 * the result to function pointers anyways.
+	 */
+	for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
+		if (strcmp(ep->name, symbol) == 0)
+			return ep->addr;
+	errvalid++;
+	strcpy(errbuf, "dlsym: undefined symbol ");
+	strcat(errbuf, symbol);
+	return NULL;
+}
+
+char *dlerror(void)
+{
+	if (errvalid) {
+		errvalid = 0;
+		return errbuf;
+	}
+	return NULL;
+}
+
+int dlclose(void *handle)
+{
+	register ModulePtr mp = (ModulePtr)handle;
+	int result;
+	register ModulePtr mp1;
+
+	if (--mp->refCnt > 0)
+		return 0;
+	if (mp->info && mp->info->fini)
+		(*mp->info->fini)();
+	if (mp->cdtors) {
+		CdtorPtr cp = mp->cdtors;
+		while (cp->init || cp->term) {
+			if (cp->term && cp->init != (void (*)(void))0xffffffff)
+				(*cp->term)();
+			cp++;
+		}
+	/*
+	 * If the function to handle global destructors for g++
+	 * exists, call it.  --jwe
+	 */
+	} else if (mp->gcc_dtor) {
+	        (*mp->gcc_dtor)();
+	}
+	result = unload(mp->entry);
+	if (result == -1) {
+		errvalid++;
+		strcpy(errbuf, strerror(errno));
+	}
+	if (mp->exports) {
+		register ExportPtr ep;
+		register int i;
+		for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
+			if (ep->name)
+				free(ep->name);
+		free(mp->exports);
+	}
+	if (mp == modList)
+		modList = mp->next;
+	else {
+		for (mp1 = modList; mp1; mp1 = mp1->next)
+			if (mp1->next == mp) {
+				mp1->next = mp->next;
+				break;
+			}
+	}
+	free(mp->name);
+	free(mp);
+	return result;
+}
+
+static void terminate(void)
+{
+	while (modList)
+		dlclose(modList);
+}
+
+/*
+ * Build the export table from the XCOFF .loader section.
+ */
+static int readExports(ModulePtr mp)
+{
+	LDFILE *ldp = NULL;
+	SCNHDR sh, shdata;
+	LDHDR *lhp;
+	char *ldbuf;
+	LDSYM *ls;
+	int i;
+	ExportPtr ep;
+
+	if ((ldp = ldopen(mp->name, ldp)) == NULL) {
+		struct ld_info *lp;
+		char *buf;
+		int size = 4*1024;
+		if (errno != ENOENT) {
+			errvalid++;
+			strcpy(errbuf, "readExports: ");
+			strcat(errbuf, strerror(errno));
+			return -1;
+		}
+		/*
+		 * The module might be loaded due to the LIBPATH
+		 * environment variable. Search for the loaded
+		 * module using L_GETINFO.
+		 */
+		if ((buf = malloc(size)) == NULL) {
+			errvalid++;
+			strcpy(errbuf, "readExports: ");
+			strcat(errbuf, strerror(errno));
+			return -1;
+		}
+		while ((i = loadquery(L_GETINFO, buf, size)) == -1 && errno == ENOMEM) {
+			free(buf);
+			size += 4*1024;
+			if ((buf = malloc(size)) == NULL) {
+				errvalid++;
+				strcpy(errbuf, "readExports: ");
+				strcat(errbuf, strerror(errno));
+				return -1;
+			}
+		}
+		if (i == -1) {
+			errvalid++;
+			strcpy(errbuf, "readExports: ");
+			strcat(errbuf, strerror(errno));
+			free(buf);
+			return -1;
+		}
+		/*
+		 * Traverse the list of loaded modules. The entry point
+		 * returned by load() does actually point to the data
+		 * segment origin.
+		 */
+		lp = (struct ld_info *)buf;
+		while (lp) {
+			if (lp->ldinfo_dataorg == mp->entry) {
+				ldp = ldopen(lp->ldinfo_filename, ldp);
+				break;
+			}
+			if (lp->ldinfo_next == 0)
+				lp = NULL;
+			else
+				lp = (struct ld_info *)((char *)lp + lp->ldinfo_next);
+		}
+		free(buf);
+		if (!ldp) {
+			errvalid++;
+			strcpy(errbuf, "readExports: ");
+			strcat(errbuf, strerror(errno));
+			return -1;
+		}
+	}
+	if (TYPE(ldp) != U802TOCMAGIC) {
+		errvalid++;
+		strcpy(errbuf, "readExports: bad magic");
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	/*
+	 * Get the padding for the data section. This is needed for
+	 * AIX 4.1 compilers. This is used when building the final
+	 * function pointer to the exported symbol.
+	 */
+	if (ldnshread(ldp, _DATA, &shdata) != SUCCESS) {
+		errvalid++;
+		strcpy(errbuf, "readExports: cannot read data section header");
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	if (ldnshread(ldp, _LOADER, &sh) != SUCCESS) {
+		errvalid++;
+		strcpy(errbuf, "readExports: cannot read loader section header");
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	/*
+	 * We read the complete loader section in one chunk, this makes
+	 * finding long symbol names residing in the string table easier.
+	 */
+	if ((ldbuf = (char *)malloc(sh.s_size)) == NULL) {
+		errvalid++;
+		strcpy(errbuf, "readExports: ");
+		strcat(errbuf, strerror(errno));
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	if (FSEEK(ldp, sh.s_scnptr, BEGINNING) != OKFSEEK) {
+		errvalid++;
+		strcpy(errbuf, "readExports: cannot seek to loader section");
+		free(ldbuf);
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	if (FREAD(ldbuf, sh.s_size, 1, ldp) != 1) {
+		errvalid++;
+		strcpy(errbuf, "readExports: cannot read loader section");
+		free(ldbuf);
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	lhp = (LDHDR *)ldbuf;
+	ls = (LDSYM *)(ldbuf+LDHDRSZ);
+	/*
+	 * Count the number of exports to include in our export table.
+	 */
+	for (i = lhp->l_nsyms; i; i--, ls++) {
+		if (!LDR_EXPORT(*ls))
+			continue;
+		mp->nExports++;
+	}
+	if ((mp->exports = (ExportPtr)calloc(mp->nExports, sizeof(*mp->exports))) == NULL) {
+		errvalid++;
+		strcpy(errbuf, "readExports: ");
+		strcat(errbuf, strerror(errno));
+		free(ldbuf);
+		while(ldclose(ldp) == FAILURE)
+			;
+		return -1;
+	}
+	/*
+	 * Fill in the export table. All entries are relative to
+	 * the entry point we got from load.
+	 */
+	ep = mp->exports;
+	ls = (LDSYM *)(ldbuf+LDHDRSZ);
+	for (i = lhp->l_nsyms; i; i--, ls++) {
+		char *symname;
+		char tmpsym[SYMNMLEN+1];
+		if (!LDR_EXPORT(*ls))
+			continue;
+		if (ls->l_zeroes == 0)
+			symname = ls->l_offset+lhp->l_stoff+ldbuf;
+		else {
+			/*
+			 * The l_name member is not zero terminated, we
+			 * must copy the first SYMNMLEN chars and make
+			 * sure we have a zero byte at the end.
+			 */
+			strncpy(tmpsym, ls->l_name, SYMNMLEN);
+			tmpsym[SYMNMLEN] = '\0';
+			symname = tmpsym;
+		}
+		ep->name = strdup(symname);
+		ep->addr = (void *)((unsigned long)mp->entry +
+					ls->l_value - shdata.s_vaddr);
+		ep++;
+	}
+	free(ldbuf);
+	while(ldclose(ldp) == FAILURE)
+		;
+	return 0;
+}
+
+/*
+ * Find the main modules entry point. This is used as export pointer
+ * for loadbind() to be able to resolve references to the main part.
+ */
+static void * findMain(void)
+{
+	struct ld_info *lp;
+	char *buf;
+	int size = 4*1024;
+	int i;
+	void *ret;
+
+	if ((buf = malloc(size)) == NULL) {
+		errvalid++;
+		strcpy(errbuf, "findMain: ");
+		strcat(errbuf, strerror(errno));
+		return NULL;
+	}
+	while ((i = loadquery(L_GETINFO, buf, size)) == -1 && errno == ENOMEM) {
+		free(buf);
+		size += 4*1024;
+		if ((buf = malloc(size)) == NULL) {
+			errvalid++;
+			strcpy(errbuf, "findMain: ");
+			strcat(errbuf, strerror(errno));
+			return NULL;
+		}
+	}
+	if (i == -1) {
+		errvalid++;
+		strcpy(errbuf, "findMain: ");
+		strcat(errbuf, strerror(errno));
+		free(buf);
+		return NULL;
+	}
+	/*
+	 * The first entry is the main module. The entry point
+	 * returned by load() does actually point to the data
+	 * segment origin.
+	 */
+	lp = (struct ld_info *)buf;
+	ret = lp->ldinfo_dataorg;
+	free(buf);
+	return ret;
+}
diff --git a/src/mzscheme/aixdlfcn/dlfcn.h b/src/mzscheme/aixdlfcn/dlfcn.h
new file mode 100644
index 0000000..5671e9c
--- /dev/null
+++ b/src/mzscheme/aixdlfcn/dlfcn.h
@@ -0,0 +1,46 @@
+/*
+ * @(#)dlfcn.h	1.4 revision of 95/04/25  09:36:52
+ * This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
+ * 30159 Hannover, Germany
+ */
+
+#ifndef __dlfcn_h__
+#define __dlfcn_h__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Mode flags for the dlopen routine.
+ */
+#define RTLD_LAZY	1	/* lazy function call binding */
+#define RTLD_NOW	2	/* immediate function call binding */
+#define RTLD_GLOBAL	0x100	/* allow symbols to be global */
+
+/*
+ * To be able to intialize, a library may provide a dl_info structure
+ * that contains functions to be called to initialize and terminate.
+ */
+struct dl_info {
+	void (*init)(void);
+	void (*fini)(void);
+};
+
+#if __STDC__ || defined(_IBMR2)
+void *dlopen(const char *path, int mode);
+void *dlsym(void *handle, const char *symbol);
+char *dlerror(void);
+int dlclose(void *handle);
+#else
+void *dlopen();
+void *dlsym();
+char *dlerror();
+int dlclose();
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __dlfcn_h__ */
diff --git a/src/mzscheme/dynsrc/Makefile b/src/mzscheme/dynsrc/Makefile
new file mode 100644
index 0000000..f66e0e2
--- /dev/null
+++ b/src/mzscheme/dynsrc/Makefile
@@ -0,0 +1,73 @@
+#
+# Makefile for mzscheme
+#
+
+# dynlink is a script that uses the right set of link commands
+DYNLINK = ./dynlink
+
+CFLAGS_NODBG = $(OPT) $(WARN) $(OPTIONS) $(DYNOPTIONS) -I../include
+CFLAGS = $(CFLAGS_NODBG) $(DEBUGFLAGS)
+
+SRCS = mzdyn.c dynexmpl.c oe.c
+
+LIBDIR = lib/sys$(MZPLATFORMSUFFIX)
+OBJDIR = objects/sys$(MZPLATFORMSUFFIX)
+
+DIRDEPS = objects $(OBJDIR)
+
+dynlib: $(DIRDEPS)
+	$(MAKE) ../$(LIBDIR)/mzdyn.o
+
+dynexample: $(DIRDEPS)
+	$(MAKE) ../$(OBJDIR)/dynexmpl.so
+
+oe: $(DIRDEPS)
+	$(MAKE) ../$(OBJDIR)/oe.so
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+objects:
+	mkdir objects
+
+HEADERS = ../include/scheme.h ../src/schemef.h ../sconfig.h ../uconfig.h
+
+MZDYNDEP = ../$(LIBDIR)/mzdyn.o ../include/ext.exp ../include/mzscheme.exp
+
+../$(LIBDIR)/mzdyn.o: $(OBJDIR)/mzdyn.o
+	cp $(OBJDIR)/mzdyn.o ../$(LIBDIR)/mzdyn.o
+$(OBJDIR)/mzdyn.o: mzdyn.c ../src/schvers.h  $(HEADERS)
+	$(CC) $(CFLAGS) -c mzdyn.c -o $(OBJDIR)/mzdyn.o
+
+../$(OBJDIR)/dynexmpl.so: $(OBJDIR)/dynexmpl.o $(MZDYNDEP)
+	$(DYNLINK) $(OBJDIR)/dynexmpl.o -o ../$(OBJDIR)/dynexmpl.so
+$(OBJDIR)/dynexmpl.o: dynexmpl.c  $(HEADERS)
+	$(CC) $(CFLAGS) -c dynexmpl.c -o $(OBJDIR)/dynexmpl.o
+
+../$(OBJDIR)/oe.so: $(OBJDIR)/oe.o  $(MZDYNDEP)
+	$(DYNLINK) $(OBJDIR)/oe.o -o ../$(OBJDIR)/oe.so
+$(OBJDIR)/oe.o: oe.c $(HEADERS)
+	$(CC) $(CFLAGS) -c oe.c -o $(OBJDIR)/oe.o
+
+depend:
+	makedepend -- $(CFLAGS) -- $(SRCS)
+
+clean:
+	/bin/rm -f objects/*/*.o *~ Makefile.bak
+
+exile:
+	$(MAKE) clean
+
+# Note: 'make depend' is no longer required. As distributed, the below
+#       dependencies have been trimmed to include only dependencies
+#       on MzScheme files
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+mzdyn.o: ../include/escheme.h ../include/scheme.h ../src/stypes.h \
+         ../src/schemex.h ../src/schemexm.h ../src/schvers.h
+
+dynexmpl.o: ../include/escheme.h ../include/scheme.h ../src/schemexm.h 
+
+oe.o: ../include/escheme.h ../include/scheme.h ../src/stypes.h \
+      ../src/schemex.h ../src/schemexm.h
diff --git a/src/mzscheme/dynsrc/dynexmpl.c b/src/mzscheme/dynsrc/dynexmpl.c
new file mode 100644
index 0000000..64b2f21
--- /dev/null
+++ b/src/mzscheme/dynsrc/dynexmpl.c
@@ -0,0 +1,31 @@
+
+/* Example dynamically-loaded MzScheme extension */
+
+#include "escheme.h"
+#include <time.h>
+
+static Scheme_Object *sch_date(int argc, Scheme_Object **argv)
+{
+  time_t clock;
+  struct tm *now;
+  char *str;
+
+  if (argc)
+    scheme_wrong_count("date", 0, 0, argc, argv);
+
+  time(&clock);
+  now = localtime(&clock);
+  str = asctime(now);
+
+  /* Get rid of newline */
+  str[24] = 0;
+
+  return scheme_make_string(str);
+}
+
+Scheme_Object *scheme_initialize(Scheme_Env *env)
+{
+  scheme_add_global("date", scheme_make_prim(sch_date), env);
+
+  return scheme_void;
+}
diff --git a/src/mzscheme/dynsrc/dynlink b/src/mzscheme/dynsrc/dynlink
new file mode 100755
index 0000000..3a25fe9
--- /dev/null
+++ b/src/mzscheme/dynsrc/dynlink
@@ -0,0 +1,12 @@
+#!/bin/sh
+
+# This script picks the right binary for a mutli-platform
+#  configuration
+
+if [ "$PLTHOME" = '' ] ; then
+  PLTHOME=/usr/local/lib/plt
+  export PLTHOME
+fi
+
+exec ${PLTHOME}/bin/mzscheme -qemv '(require-library "dolink.ss" "mzscheme" "dynext")' -- ${1+"$@"}
+
diff --git a/src/mzscheme/dynsrc/dynlink.ss b/src/mzscheme/dynsrc/dynlink.ss
new file mode 100644
index 0000000..a322ebc
--- /dev/null
+++ b/src/mzscheme/dynsrc/dynlink.ss
@@ -0,0 +1,71 @@
+
+(define argv-l (vector->list argv))
+
+(define (flag f)
+  (let loop ([l argv-l][p null])
+    (if (null? l)
+	#f
+	(if (equal? f (car l))
+	    (begin
+	      (set! argv-l (append p l))
+	      #t)
+	    (loop (cdr l) (append p (list (car l))))))))
+
+(define verbose? (flag "-q"))
+
+
+(unit
+ (define include-dir (collection-path "mzscheme" "include"))
+ 
+ (define link-command
+   (case (system-library-subpath)
+     [("sparc-solaris") "ld -G"]
+     [("sparc-sunos4") "ld -Bdynamic"]
+     [("i386-freebsd") "ld -Bshareable"]
+     [("rs6k-aix") (let ([version (read (car (process* "/usr/bin/uname" "-v")))])
+		     (format "cc -bM:SRE -bI:~a/mzscheme.exp -bE:~a/ext.exp ~a" 
+			     include-dir
+			     include-dir
+			     (if (version = 3)
+				 "-e _nostart"
+				 "-bnoentry")))]
+     [("parisc-hpux") "ld -b"]
+     [else "ld -shared"]))
+ 
+ (define std-library (build-path (collection-path "mzscheme" "lib") (system-library-subpath) "mzdyn.o"))
+
+ (define (link quiet? input-files output-file)
+   (let* ([l (process (format "~a -o ~a ~a ~a"  link-command output-file
+			      (let loop ([l input-files][s ""])
+				(if (null? l)
+				    s
+				    (loop (cdr l) (format "~a ~a" (car l) s))))
+			      std-library))]
+	  [in (car l)]
+	  [out (cadr l)]
+	  [in-error (caddr l)]
+	  [control (cadddr l)]
+
+	  [collect-output (box "")]
+	  [collect-error (box "")]
+	  
+	  [make-collector
+	   (lambda (in dest box)
+	     (thread (lambda () (let loop ()
+				  (let ([t (read-line in)])
+				    (unless (eof-object? t)
+					    (unless quiet? (fprintf (dest) "~a~n" t))
+					    (set-box! box (string-append (unbox box) t))
+					    (loop)))))))]
+	  [in-thread (make-collector in current-output-port collect-output)]
+	  [in-error-thread (make-collector in-error current-error-port collect-error)])
+
+     (thread-wait in-thread)
+     (thread-wait in-error-thread)
+     
+     (unless (eq? ((cadddr l) 'status) 'done-error)
+	     (error 'link
+		    (if (string=? "" (unbox collect-error))
+			(unbox collect-output)
+			(unbox collect-error)))))))
+	     
diff --git a/src/mzscheme/dynsrc/mkmzdyn.bat b/src/mzscheme/dynsrc/mkmzdyn.bat
new file mode 100644
index 0000000..526f5c0
--- /dev/null
+++ b/src/mzscheme/dynsrc/mkmzdyn.bat
@@ -0,0 +1,3 @@
+cl -O2 -I../include /c mzdyn.c
+lib -def:mzdyn.def -out:mzdyn.lib
+
diff --git a/src/mzscheme/dynsrc/mzdyn.c b/src/mzscheme/dynsrc/mzdyn.c
new file mode 100644
index 0000000..476503b
--- /dev/null
+++ b/src/mzscheme/dynsrc/mzdyn.c
@@ -0,0 +1,49 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* This file should be linked with any MzScheme extension dynamic
+   object. */
+
+
+#include "escheme.h"
+#ifdef INCLUDE_WITHOUT_PATHS
+# include "schvers.h"
+#else
+# include "../src/schvers.h"
+#endif
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+Scheme_Extension_Table *scheme_extension_table;
+#endif
+
+#ifdef CODEFRAGMENT_DYNAMIC_LOAD
+#pragma export on
+char *scheme_initialize_internal(
+#ifdef LINK_EXTENSIONS_BY_TABLE
+				 Scheme_Extension_Table *table
+#endif
+				 );
+#pragma export off
+#endif
+
+char *scheme_initialize_internal(
+#ifdef LINK_EXTENSIONS_BY_TABLE
+				 Scheme_Extension_Table *table
+#endif
+				 )
+{
+#ifdef LINK_EXTENSIONS_BY_TABLE
+  scheme_extension_table = table;
+#endif
+
+  return VERSION;
+}
diff --git a/src/mzscheme/dynsrc/mzdyn.def b/src/mzscheme/dynsrc/mzdyn.def
new file mode 100644
index 0000000..ab7a10b
--- /dev/null
+++ b/src/mzscheme/dynsrc/mzdyn.def
@@ -0,0 +1,7 @@
+
+LIBRARY
+
+EXPORTS
+scheme_initialize_internal
+scheme_initialize
+scheme_reload
diff --git a/src/mzscheme/dynsrc/oe.c b/src/mzscheme/dynsrc/oe.c
new file mode 100644
index 0000000..f19261d
--- /dev/null
+++ b/src/mzscheme/dynsrc/oe.c
@@ -0,0 +1,346 @@
+
+#include "escheme.h"
+
+/* Perhaps we should register these globals for GC. Turns out
+   to not matter since they're guranteed to be registered
+   via another path. */
+static Scheme_Object *one_const, *two_const;
+static Scheme_Bucket *zerop_g, *minus_g, *plus_g, *le_g;
+static Scheme_Bucket *odd_g, *even_g, *fib_g, *mod_g, *eq_g;
+
+static Scheme_Prim *le_f, *minus_f, *plus_f;
+
+#define SCHEME_GLOBAL(b) b->val
+
+Scheme_Object *odd(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v, *p, *array[2];
+
+  if (argc != 1)
+    scheme_wrong_count("odd", 1, 1, argc, argv);
+
+  p = SCHEME_GLOBAL(zerop_g);
+  if (!p)
+    scheme_signal_error("odd: zero? undefined");
+  array[0] = argv[0];
+  v = _scheme_apply(p, 1, array);
+
+  if (SCHEME_TRUEP(v)) {
+    return scheme_false;
+  } else {
+    p = SCHEME_GLOBAL(minus_g);
+    if (!p)
+      scheme_signal_error("odd: - undefined");
+    array[0] = argv[0];
+    array[1] = one_const;
+    v = _scheme_apply(p, 2, array);
+
+    p = SCHEME_GLOBAL(even_g);
+    if (!p)
+      scheme_signal_error("odd: even undefined");
+    
+    array[0] = v;
+    return scheme_tail_apply(p, 1, array);
+  }
+}
+
+Scheme_Object *even(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v, *p, *array[2];
+
+  if (argc != 1)
+    scheme_wrong_count("even", 1, 1, argc, argv);
+
+  p = SCHEME_GLOBAL(zerop_g);
+  if (!p)
+    scheme_signal_error("even: zero? undefined");
+  array[0] = argv[0];
+  v = _scheme_apply(p, 1, array);
+
+  if (SCHEME_TRUEP(v)) {
+    return scheme_true;
+  } else {
+    p = SCHEME_GLOBAL(minus_g);
+    if (!p)
+      scheme_signal_error("even: - undefined");
+    array[0] = argv[0];
+    array[1] = one_const;
+    v = _scheme_apply(p, 2, array);
+
+    p = SCHEME_GLOBAL(odd_g);
+    if (!p)
+      scheme_signal_error("even: odd undefined");
+
+    array[0] = v;
+    return scheme_tail_apply(p, 1, array);
+  }
+}
+
+Scheme_Object *fib(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v, *v2, *p, *array[2];
+
+  if (argc != 1)
+    scheme_wrong_count("fib", 1, 1, argc, argv);
+
+  p = SCHEME_GLOBAL(le_g);
+  if (!p)
+    scheme_signal_error("fib: <= undefined");
+  array[0] = argv[0];
+  array[1] = one_const;
+  v = _scheme_apply(p, 2, array);
+
+  if (SCHEME_TRUEP(v)) {
+    return one_const;
+  } else {
+    p = SCHEME_GLOBAL(minus_g);
+    if (!p)
+      scheme_signal_error("fib: - undefined");
+    array[0] = argv[0];
+    array[1] = one_const;
+    v = _scheme_apply(p, 2, array);
+    
+    p = SCHEME_GLOBAL(fib_g);
+    if (!p)
+      scheme_signal_error("fib: fib undefined");
+    array[0] = v;
+    v = _scheme_apply(p, 1, array);
+
+    p = SCHEME_GLOBAL(minus_g);
+    if (!p)
+      scheme_signal_error("fib: - undefined");
+    array[0] = argv[0];
+    array[1] = two_const;
+    v2 = _scheme_apply(p, 2, array);
+    
+    p = SCHEME_GLOBAL(fib_g);
+    if (!p)
+      scheme_signal_error("fib: fib undefined");
+    array[0] = v2;
+    v2 = _scheme_apply(p, 1, array);
+
+    p = SCHEME_GLOBAL(plus_g);
+    if (!p)
+      scheme_signal_error("fib: + undefined");
+    array[0] = v;
+    array[1] = v2;
+    return scheme_tail_apply(p, 2, array);
+  }
+}
+
+Scheme_Object *fib2(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v, *v2, *array[2];
+
+  if (argc != 1)
+    scheme_wrong_count("fib", 1, 1, argc, argv);
+
+  array[0] = argv[0];
+  array[1] = one_const;
+  v = le_f(2, array);
+
+  if (SCHEME_TRUEP(v)) {
+    return one_const;
+  } else {
+    array[0] = argv[0];
+    array[1] = one_const;
+    v = minus_f(2, array);
+    
+    array[0] = v;
+    v = fib2(1, array);
+
+    array[0] = argv[0];
+    array[1] = two_const;
+    v2 = minus_f(2, array);
+    
+    array[0] = v2;
+    v2 = fib2(1, array);
+
+    array[0] = v;
+    array[1] = v2;
+    return plus_f(2, array);
+  }
+}
+
+static Scheme_Object *create_tclass(void *a, int argc, Scheme_Object **argv)
+{
+  return scheme_create_class((struct Scheme_Class_Assembly *)a, argv[0], argv + 1);
+}
+
+static Scheme_Object *create_tinterface(void *a, int argc, Scheme_Object **argv)
+{
+  return scheme_create_interface((struct Scheme_Interface_Assembly *)a, argv);
+}
+
+static Scheme_Object *unboxit(void *v, int argc, Scheme_Object **argv)
+{
+  return SCHEME_ENVBOX_VAL(v);
+}
+
+static Scheme_Object *constfunc(void *v, int argc, Scheme_Object **argv)
+{
+  return (Scheme_Object *)v;
+}
+
+static void init_tclass(Scheme_Object **init_boxes,
+			Scheme_Object **extract_boxes,
+			Scheme_Object *super_init,
+			int argc,
+			Scheme_Object **argv,
+			Scheme_Object *instance)
+{
+  SCHEME_ENVBOX_VAL(init_boxes[0]) = scheme_make_integer(5);
+  SCHEME_ENVBOX_VAL(init_boxes[1]) = scheme_make_closed_prim_w_arity(unboxit,
+                                                                     extract_boxes[0],
+                                                                     "get-y",
+                                                                     0, 0);
+  SCHEME_ENVBOX_VAL(init_boxes[2]) = scheme_make_closed_prim_w_arity(unboxit,
+                                                                     extract_boxes[6],
+                                                                     "get-z1",
+                                                                     0, 0);
+  SCHEME_ENVBOX_VAL(init_boxes[3]) = scheme_make_closed_prim_w_arity(unboxit,
+                                                                     extract_boxes[7],
+                                                                     "get-z2",
+                                                                     0, 0);
+  SCHEME_ENVBOX_VAL(init_boxes[4]) = scheme_make_closed_prim_w_arity(constfunc,
+                                                                     argv[0],
+                                                                     "get-x1",
+                                                                     0, 0);
+  SCHEME_ENVBOX_VAL(init_boxes[5]) = scheme_make_closed_prim_w_arity(constfunc,
+                                                                     argv[1],
+                                                                     "get-x2",
+                                                                     0, 0);
+
+  _scheme_apply(super_init, 0, NULL);
+}
+
+void make_number_indices(void *v, int *h1, int *h2)
+{
+  Scheme_Object *args[2];
+
+  args[0] = (Scheme_Object *)v;
+  args[1] = scheme_make_integer(10000);
+  
+  *h1 = SCHEME_INT_VAL(_scheme_apply(SCHEME_GLOBAL(mod_g), 2, args));
+  *h2 = *h1 % 73;
+}
+
+int compare_numbers(void *v1, void *v2)
+{
+  Scheme_Object *args[2];
+  
+  args[0] = (Scheme_Object *)v1;
+  args[1] = (Scheme_Object *)v2;
+  
+  return SCHEME_FALSEP(_scheme_apply(SCHEME_GLOBAL(eq_g), 2, args));
+}
+
+
+Scheme_Object *scheme_initialize(Scheme_Env *global_env)
+{
+  Scheme_Object *mv[2];
+  Scheme_Hash_Table *table;
+
+  scheme_eval_string("(printf \"loading from~s~n\" "
+		     " (current-load-relative-directory))",
+		     global_env);
+
+  one_const = scheme_make_integer(1);
+  two_const = scheme_make_integer(2);
+
+  scheme_add_global("odd",
+		    scheme_make_prim_w_arity(odd, "odd", 1, 1),
+		    global_env);
+
+  scheme_add_global("even",
+		    scheme_make_prim_w_arity(even, "even", 1, 1),
+		    global_env);
+
+  scheme_add_global("fib",
+		    scheme_make_prim_w_arity(fib, "fib", 1, 1),
+		    global_env);
+
+  scheme_add_global("fib2",
+		    scheme_make_prim_w_arity(fib2, "fib2", 1, 1),
+		    global_env);
+
+  zerop_g = scheme_global_bucket(scheme_intern_symbol("zero?"), global_env);
+  even_g = scheme_global_bucket(scheme_intern_symbol("even"), global_env);
+  odd_g = scheme_global_bucket(scheme_intern_symbol("odd"), global_env);
+  fib_g = scheme_global_bucket(scheme_intern_symbol("fib"), global_env);
+  minus_g = scheme_global_bucket(scheme_intern_symbol("-"), global_env);
+  plus_g = scheme_global_bucket(scheme_intern_symbol("+"), global_env);
+  le_g = scheme_global_bucket(scheme_intern_symbol("<="), global_env);
+  mod_g = scheme_global_bucket(scheme_intern_symbol("modulo"), global_env);
+  eq_g = scheme_global_bucket(scheme_intern_symbol("="), global_env);
+
+  le_f = SCHEME_PRIM(SCHEME_GLOBAL(le_g));
+  minus_f = SCHEME_PRIM(SCHEME_GLOBAL(minus_g));
+  plus_f = SCHEME_PRIM(SCHEME_GLOBAL(plus_g));  
+
+  {
+      /* (define mktinterface
+           (lambda (i)
+             (interface i get-x1 get-x2)))
+         (define mktclass
+          (lambda (c i)
+           (class* c (i) (x1 x2) 
+            (inherit z1 z2)
+            (public [y 5]
+                    [get-y (lambda () y)]
+                    [get-z1 (lambda () z1)]
+                    [get-z2 (lambda () z2)]
+                    [get-x1 (lambda () x1)]
+                    [get-x2 (lambda () x2)])
+            (sequence (super-init))))) */
+      
+    void *v;
+    Scheme_Object *pnames[6], *inames[1];
+
+    pnames[0] = scheme_intern_symbol("y");
+    pnames[1] = scheme_intern_symbol("get-y");
+    pnames[2] = scheme_intern_symbol("get-z1");
+    pnames[3] = scheme_intern_symbol("get-z2");
+    pnames[4] = scheme_intern_symbol("get-x1");
+    pnames[5] = scheme_intern_symbol("get-x2");
+    
+    inames[0] = scheme_intern_symbol("z1");
+    inames[1] = scheme_intern_symbol("z2");
+    
+    v = (void *)scheme_make_class_assembly(1, /* 1 interface */
+					   6, pnames,
+					   2, inames,
+					   2, 2,
+					   init_tclass);
+    
+    scheme_add_global("mktclass",
+		      scheme_make_closed_prim_w_arity(create_tclass, v, "mktclass", 2, 2),
+		      global_env);
+
+    pnames[0] = scheme_intern_symbol("get-x1");
+    pnames[1] = scheme_intern_symbol("get-x2");
+
+    v = (void *)scheme_make_interface_assembly(1, 2, pnames);
+
+    scheme_add_global("mktinterface",
+		      scheme_make_closed_prim_w_arity(create_tinterface, v, "mktinterface", 1, 1),
+		      global_env);
+  }
+
+  table = scheme_hash_table(10, SCHEME_hash_ptr, 0, 0);
+  table->make_hash_indices = make_number_indices;
+  table->compare = compare_numbers;
+
+  scheme_add_global("number-table",
+		    (Scheme_Object *)table,
+		    global_env);
+
+  mv[0] = scheme_true;
+  mv[1] = scheme_false;
+  return scheme_values(2, mv);
+}
+
+Scheme_Object *scheme_reload(Scheme_Env *global_env)
+{
+  return scheme_intern_symbol("reload-does-nothing");
+}
diff --git a/src/mzscheme/dynsrc/winmake.bat b/src/mzscheme/dynsrc/winmake.bat
new file mode 100644
index 0000000..b80b515
--- /dev/null
+++ b/src/mzscheme/dynsrc/winmake.bat
@@ -0,0 +1,3 @@
+cl -O2 -Ic:/msdev/include -I../include /c %1.c
+set LIB=c:/msdev/lib
+link /dll -out:%1.dll mzdyn.obj %1.obj mzdyn.exp
diff --git a/src/mzscheme/gc/BCC_MAKEFILE b/src/mzscheme/gc/BCC_MAKEFILE
new file mode 100644
index 0000000..c65a73e
--- /dev/null
+++ b/src/mzscheme/gc/BCC_MAKEFILE
@@ -0,0 +1,82 @@
+# Makefile for Borland C++ 4.5 on NT
+# For Borland 5.0, replace bc45 by bc5.
+# If you have the Borland assembler, remove "-DUSE_GENERIC"
+#
+bc=        c:\bc45
+bcbin=     $(bc)\bin
+bclib=     $(bc)\lib
+bcinclude= $(bc)\include
+
+cc=      $(bcbin)\bcc32
+rc=      $(bcbin)\brc32
+lib=     $(bcbin)\tlib
+link=    $(bcbin)\tlink32
+cflags=  -R -v -vi -H -H=gc.csm -I$(bcinclude);cord -L$(bclib) \
+         -w-pro -w-aus -w-par -w-ccc -w-rch -a4 -D__STDC__=0
+#defines= -DSILENT
+defines= -DSMALL_CONFIG -DSILENT -DALL_INTERIOR_POINTERS -DUSE_GENERIC
+
+.c.obj:
+	$(cc) @&&|
+        $(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.c
+|
+
+.cpp.obj:
+	$(cc) @&&|
+        $(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.cpp
+|
+
+.rc.res:
+    $(rc) -i$(bcinclude) -r -fo$* $*.rc
+
+XXXOBJS= XXXalloc.obj XXXreclaim.obj XXXallchblk.obj XXXmisc.obj \
+    XXXmach_dep.obj XXXos_dep.obj XXXmark_rts.obj XXXheaders.obj XXXmark.obj \
+    XXXobj_map.obj XXXblacklst.obj XXXfinalize.obj XXXnew_hblk.obj \
+    XXXdbg_mlc.obj XXXmalloc.obj XXXstubborn.obj XXXdyn_load.obj \
+    XXXtypd_mlc.obj XXXptr_chck.obj XXXgc_cpp.obj XXXmallocx.obj
+
+OBJS= $(XXXOBJS:XXX=)
+
+all: gctest.exe cord\de.exe test_cpp.exe
+
+$(OBJS) test.obj: gc_priv.h gc_hdrs.h gc.h config.h MAKEFILE
+
+gc.lib: $(OBJS)
+    -del gc.lib
+	tlib $* @&&|
+        $(XXXOBJS:XXX=+)
+|
+
+gctest.exe: test.obj gc.lib
+    $(cc) @&&|
+        $(cflags) -W -e$* test.obj gc.lib
+|
+
+cord\de.obj cord\de_win.obj: cord\cord.h cord\private\cord_pos.h cord\de_win.h \
+    cord\de_cmds.h
+
+cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj \
+        cord\de_win.res gc.lib
+	$(cc) @&&|
+        $(cflags) -W -e$* cord\cordbscs.obj cord\cordxtra.obj \
+        cord\de.obj cord\de_win.obj gc.lib
+|
+    $(rc) cord\de_win.res cord\de.exe
+
+gc_cpp.obj: gc_cpp.h gc.h
+
+gc_cpp.cpp: gc_cpp.cc
+	copy gc_cpp.cc gc_cpp.cpp
+
+test_cpp.cpp: test_cpp.cc
+	copy test_cpp.cc test_cpp.cpp
+
+test_cpp.exe: test_cpp.obj gc_cpp.h gc.h gc.lib
+    $(cc) @&&|
+        $(cflags) -W -e$* test_cpp.obj gc.lib
+|
+
+scratch:
+    -del *.obj *.res *.exe *.csm cord\*.obj cord\*.res cord\*.exe cord\*.csm
+
+
diff --git a/src/mzscheme/gc/EMX_MAKEFILE b/src/mzscheme/gc/EMX_MAKEFILE
new file mode 100644
index 0000000..1ade12a
--- /dev/null
+++ b/src/mzscheme/gc/EMX_MAKEFILE
@@ -0,0 +1,141 @@
+#
+#  OS/2 specific Makefile for the EMX environment
+#
+#  You need GNU Make 3.71, gcc 2.5.7, emx 0.8h and GNU fileutils 3.9
+#  or similar tools. C++ interface and de.exe weren't tested.
+#
+#  Rename this file "Makefile".
+#
+
+# Primary targets:
+# gc.a - builds basic library
+# c++ - adds C++ interface to library and include directory
+# cords - adds cords (heavyweight strings) to library and include directory
+# test - prints porting information, then builds basic version of gc.a, and runs
+#        some tests of collector and cords.  Does not add cords or c++ interface to gc.a
+# cord/de.exe - builds dumb editor based on cords.
+CC= gcc
+CXX=g++
+# Needed only for "make c++", which adds the c++ interface
+
+CFLAGS= -O -DALL_INTERIOR_POINTERS -DSILENT
+# Setjmp_test may yield overly optimistic results when compiled
+# without optimization.
+# -DSILENT disables statistics printing, and improves performance.
+# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
+#   altered stubborn objects, at substantial performance cost.
+# -DFIND_LEAK causes the collector to assume that all inaccessible
+#   objects should have been explicitly deallocated, and reports exceptions
+# -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
+#   (Clients should also define SOLARIS_THREADS and then include
+#   gc.h before performing thr_ or GC_ operations.)
+# -DALL_INTERIOR_POINTERS allows all pointers to the interior
+#   of objects to be recognized.  (See gc_private.h for consequences.)
+# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+#   usually causing it to use less space in such situations.
+#   Incremental collection no longer works in this case.
+# -DDONT_ADD_BYTE_AT_END is meaningful only with
+#   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+#   causes all objects to be padded so that pointers just past the end of
+#   an object can be recognized.  This can be expensive.  (The padding
+#   is normally more than one byte due to alignment constraints.)
+#   -DDONT_ADD_BYTE_AT_END disables the padding.
+
+AR= ar
+RANLIB= ar s
+
+# Redefining srcdir allows object code for the nonPCR version of the collector
+# to be generated in different directories
+srcdir = .
+VPATH = $(srcdir)
+
+OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o mallocx.o
+
+CORD_OBJS=  cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
+
+CORD_INCLUDE_FILES= $(srcdir)/gc.h $(srcdir)/cord/cord.h $(srcdir)/cord/ec.h \
+           $(srcdir)/cord/cord_pos.h
+
+# Libraries needed for curses applications.  Only needed for de.
+CURSES= -lcurses -ltermlib
+
+# The following is irrelevant on most systems.  But a few
+# versions of make otherwise fork the shell specified in
+# the SHELL environment variable.
+SHELL= bash
+
+SPECIALCFLAGS = 
+# Alternative flags to the C compiler for mach_dep.c.
+# Mach_dep.c often doesn't like optimization, and it's
+# not time-critical anyway.
+
+all: gc.a gctest.exe
+
+$(OBJS) test.o: $(srcdir)/gc_priv.h $(srcdir)/gc_hdrs.h $(srcdir)/gc.h \
+    $(srcdir)/config.h $(srcdir)/gc_typed.h
+# The dependency on Makefile is needed.  Changing
+# options such as -DSILENT affects the size of GC_arrays,
+# invalidating all .o files that rely on gc_priv.h
+
+mark.o typd_mlc.o finalize.o: $(srcdir)/gc_mark.h
+
+gc.a: $(OBJS)
+	$(AR) ru gc.a $(OBJS)
+	$(RANLIB) gc.a
+
+cords: $(CORD_OBJS) cord/cordtest.exe
+	$(AR) ru gc.a $(CORD_OBJS)
+	$(RANLIB) gc.a
+	cp $(srcdir)/cord/cord.h include/cord.h
+	cp $(srcdir)/cord/ec.h include/ec.h
+	cp $(srcdir)/cord/cord_pos.h include/cord_pos.h
+
+gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/gc_cpp.h
+	$(CXX) -c -O $(srcdir)/gc_cpp.cc
+	
+c++: gc_cpp.o $(srcdir)/gc_cpp.h
+	$(AR) ru gc.a gc_cpp.o
+	$(RANLIB) gc.a
+	cp $(srcdir)/gc_cpp.h include/gc_cpp.h 
+
+mach_dep.o: $(srcdir)/mach_dep.c
+	$(CC) -o mach_dep.o -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
+
+mark_rts.o: $(srcdir)/mark_rts.c
+	$(CC) -o mark_rts.o -c $(CFLAGS) $(srcdir)/mark_rts.c
+
+cord/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordbscs.c -o  cord/cordbscs.o
+
+cord/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordxtra.c -o  cord/cordxtra.o
+
+cord/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordprnt.c -o cord/cordprnt.o
+
+cord/cordtest.exe: $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
+	$(CC) $(CFLAGS) -o cord/cordtest.exe $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
+
+cord/de.exe: $(srcdir)/cord/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a
+	$(CC) $(CFLAGS) -o cord/de.exe $(srcdir)/cord/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a $(CURSES)
+
+clean: 
+	rm -f gc.a test.o gctest.exe output-local output-diff $(OBJS) \
+	      setjmp_test  mon.out gmon.out a.out core \
+	      $(CORD_OBJS) cord/cordtest.exe cord/de.exe
+	-rm -f *~
+
+gctest.exe: test.o gc.a
+	$(CC) $(CFLAGS) -o gctest.exe test.o gc.a
+
+# If an optimized setjmp_test generates a segmentation fault,
+# odds are your compiler is broken.  Gctest may still work.
+# Try compiling setjmp_t.c unoptimized.
+setjmp_test.exe: $(srcdir)/setjmp_t.c $(srcdir)/gc.h
+	$(CC) $(CFLAGS) -o setjmp_test.exe $(srcdir)/setjmp_t.c
+
+test: setjmp_test.exe gctest.exe
+	./setjmp_test
+	./gctest
+	make cord/cordtest.exe
+	cord/cordtest
diff --git a/src/mzscheme/gc/MacOS.c b/src/mzscheme/gc/MacOS.c
new file mode 100644
index 0000000..8a3bfff
--- /dev/null
+++ b/src/mzscheme/gc/MacOS.c
@@ -0,0 +1,151 @@
+/*
+	MacOS.c
+	
+	Some routines for the Macintosh OS port of the Hans-J. Boehm, Alan J. Demers
+	garbage collector.
+	
+	<Revision History>
+	
+	11/22/94  pcb  StripAddress the temporary memory handle for 24-bit mode.
+	11/30/94  pcb  Tracking all memory usage so we can deallocate it all at once.
+	02/10/96  pcb  Added routine to perform a final collection when unloading shared library.
+	
+	by Patrick C. Beard.
+
+	MATTHEW: this file is substantially modified for MzScheme/MrEd.
+ */
+/* Boehm, November 17, 1995 11:50 am PST */
+
+#include <Resources.h>
+#include <Memory.h>
+#include <LowMem.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gc.h"
+#include "gc_priv.h"
+
+// use 'CODE' resource 0 to get exact location of the beginning of global space.
+
+typedef struct {
+	unsigned long aboveA5;
+	unsigned long belowA5;
+	unsigned long JTSize;
+	unsigned long JTOffset;
+} *CodeZeroPtr, **CodeZeroHandle;
+
+void* GC_MacGetDataStart()
+{
+	CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
+	if (code0) {
+		long belowA5Size = (**code0).belowA5;
+		ReleaseResource((Handle)code0);
+		return (LMGetCurrentA5() - belowA5Size);
+	}
+	fprintf(stderr, "Couldn't load the jump table.");
+	exit(-1);
+	return 0;
+}
+
+/* track the use of temporary memory so it can be freed all at once. */
+
+typedef struct TemporaryMemoryBlock TemporaryMemoryBlock, **TemporaryMemoryHandle;
+
+struct TemporaryMemoryBlock {
+	TemporaryMemoryHandle nextBlock;
+	char data[];
+};
+
+static TemporaryMemoryHandle theTemporaryMemory = NULL;
+static Boolean firstTime = true;
+
+void GC_MacFreeTemporaryMemory(void);
+
+Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory)
+{
+	static Boolean firstTime = true;
+	OSErr result;
+	TemporaryMemoryHandle tempMemBlock;
+	Ptr tempPtr;
+
+	/* MATTHEW: IM requests that temp memory not be locked across 
+	   calls to GetNextEvent or WaitNextEvent. So, we'll use regular
+	   pointers, but grab temp memory if we run out completely. 
+	   Also, we'll be nicer about not grabbing *all* of temp memory,
+	   as this seems to bring down the whole system. */
+	if ((FreeMem() - size) >= 65536) { /* resort to tmp mem if local < some amount */ 
+	  if (clearMemory)
+	  	tempPtr = NewPtrClear(size);
+	  else
+	  	tempPtr = NewPtr(size);
+	  if (tempPtr)
+	    return tempPtr;		
+	} else
+	  tempPtr = NULL;
+	
+	if ((TempFreeMem() - size) < 65536) {
+	  /* Not much temp mem availabl, either. Give up. */
+	  return NULL;
+	}
+
+	tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result);
+	if (tempMemBlock && result == noErr) {
+		HLockHi((Handle)tempMemBlock);
+		tempPtr = (**tempMemBlock).data;
+		if (clearMemory) memset(tempPtr, 0, size);
+		tempPtr = StripAddress(tempPtr);
+
+		// keep track of the allocated blocks.
+		(**tempMemBlock).nextBlock = theTemporaryMemory;
+		theTemporaryMemory = tempMemBlock;
+	}
+
+#if !defined(SHARED_LIBRARY_BUILD)
+	// install an exit routine to clean up the memory used at the end.
+	if (firstTime) {
+		atexit(&GC_MacFreeTemporaryMemory);
+		firstTime = false;
+	}
+#endif
+
+	return tempPtr;
+}
+
+static void perform_final_collection()
+{
+	int i;
+	
+	/* adjust the stack bottom, because CFM calls us from another stack location. */
+	GC_stackbottom = (ptr_t)&i;
+	
+	/* try to collect everything in sight (from test.c). Is this safe? */
+	while (GC_collect_a_little()) ;
+	for (i = 0; i < 16; i++)
+		GC_gcollect();
+}
+
+void GC_MacFreeTemporaryMemory()
+{
+#if defined(SHARED_LIBRARY_BUILD)
+	/* collect all memory, and invoke all finalizers. */
+	perform_final_collection();
+#endif
+
+	if (theTemporaryMemory != NULL) {
+		long totalMemoryUsed = 0;
+		TemporaryMemoryHandle tempMemBlock = theTemporaryMemory;
+		while (tempMemBlock != NULL) {
+			TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock;
+			totalMemoryUsed += GetHandleSize((Handle)tempMemBlock);
+			DisposeHandle((Handle)tempMemBlock);
+			tempMemBlock = nextBlock;
+		}
+		theTemporaryMemory = NULL;
+		
+#if !defined(SHARED_LIBRARY_BUILD)
+		fprintf(stdout, "[total memory used:  %ld bytes.]\n", totalMemoryUsed);
+		fprintf(stdout, "[total collections:  %ld.]\n", GC_gc_no);
+#endif
+	}
+}
diff --git a/src/mzscheme/gc/MacProjects.sit.hqx b/src/mzscheme/gc/MacProjects.sit.hqx
new file mode 100644
index 0000000..99dff88
--- /dev/null
+++ b/src/mzscheme/gc/MacProjects.sit.hqx
@@ -0,0 +1,886 @@
+(This file must be converted with BinHex 4.0)
+
+:$deKBe"bEfTPBh4c,R0TG!"6594%8dP8)3#3"&)e!!!"4UiT8dP8)3!(!!"50A*
+
+-BA8#ZJ#3!aB"#3d0#'GM,MBi5bkjBf038%-ZZ3#3%)Zi!*!8"@`!N!6rN!4069"
+
+568e$3`%!UbqAD+X`19S!!!Ba!!!,*J!!!F%!!!-PfTmj1`#3"PET)d31)LTH6H4
+
+#*AqG5b5HI*)QjY$IIb00%ReTJSi6rG$jG(bZ,"Rc,9Umf[IRj)6FZ-j`GfGR)#!
+
+m-#qLqB#cj'G%46qffB3q8AppLXKc+P&*il4FMJMq3N32r[U,(PlSNdrQm-J(4!p
+
+jK)NHmKJSHY!,&chS$4)pk%8mL3I)B0'$AU6S3'q)k%%[5[5J&ffa#68)0ZM&#T!
+
+!*fHC-2dFZ3i83[Vr[4Xh'+DNQrm'J)rrpqe%ST`,FeVi6b,*qHH")4eQc28NFMN
+
+ZT*m,L"Y%-`pdAk6RLHDaeVV0a,,@P(4UUK66rUM'8bf91llS("lTh81)MBQ+4*q
+
+rfHENEhD)Ke#3!09'M%bL[P1+G88fa$3e)5Gpf0kARpBf*6eIH*0`ZBHR%ii"PbN
+
++D&*)688M)Sm$Bm[cCdDjh2YIjmAc`(TVpi*Vka((A*&Yl@'LTSH1M*AMP#,2[A$
+
+(FHA@S"dL4dER#3b!EfBYem(C9P5iGH"a-bb-AL(F"bb-AL,F6)%a9pJUL,(hf%B
+
+TeQb["X5ib4DQXV!-fa6&mZf&3,(C&UDd-((SpeMBEIB`8Zc,BcZR3A5'X+jYj$'
+
+6)6HVV+R[!`#3!`X!(E@*MFQ%R4d"))`m[3JM[c)bBS54Tj'M(AP+MK&f%VD5SdG
+
+SANFB@3Rqc$Am83(+)`"G(D%A'9!bBQ6!b)b4Sq3SH8D1NDGNX$)bBi54!51--$*
+
+Kj0L!M"KKK"dC--,)-h+-6#KKC-$)-F)NamL!!Z06#X!!b&%bBUHp8RcN'%%6!b,
+
+i!!kV"`"DLHFaK*!!"Ym4K,,2i2X4c[,`c5!GIPf!ZcNi'8'VfJFpSfdpq+CY$8j
+
+-V'f-DZr2[36#1(ael5hmfT@1cSU66D5pqDSA89pdTP-`Z[jj6T&!PmZBFZjal"&
+
+5iG6#blE$+&kLh#QZ118&(0T1J(hZ,9)5MJ9ic*qPI!ac'RJ96QMZjSbkMq()Ui6
+
+B+f,,#'N1icbM4N"aaBr1`3Z9U'8RY'XAiVXFKp#&k2D5Be%VCdh4%,+2QS'b"Q2
+
+%0PNT4rE#%kTUFqYDM56bVjfe!p8MqmL)1VmjVkJY`U[*$&*L3AMSpB@LCQ*U&l%
+
+T+3890rL,V9klFN*4@f0UTf8Z&&afN!"4GC6G8p3fN9$4+4[-@DAeK%lej"@eAAL
+
+eU@&4[Tm28%mqqUkS(F+VDa#lB&'rlRAllRP&l460Qc,)MHR$jMh@$8Y4Xc'e`cd
+
+ZE2AUUiH+fK96feb$epq&'RAQeLG&lCDjmP+"Kr8k9#qp'eI8RPf[6R$dS+$UcqI
+
+ELYSV[*ETFL&j[@lr803qd9I2A#bi4Vei3*d[+@Urk*!!&abe0HTVm%44"i4A6JN
+
+c(2I!kjRl6a9e813DK"A6p(LjRZZGaGH+1L5SiBT[(6ekd2*ILMSXU(l)#m3QMDB
+
+V+QTG!r*NG#RQai#DNh4,l0&!Ie`dYi98Y1%1A$5hKP4,`d9cHdKP'LkD@q4hYC*
+
+%dfdLeCCNN@i9UIBNLh5l5(8N68qhM&4R`d9cfdKP'bkD@dHU+qe&XRfNZSqc10j
+
+#8Me*&ZNfNZT0hSYd+dP&ri-FGM6G6P,p5D,rPNT0`dQLk5+6'NLb5"HDe'$L)Pe
+
+X8N2bj-Z'$r$6-$NZjLGC)1lB-"jQSff@[ak%LJ[rI#%p2ddAGREN(@"V+,S6CI!
+
+I!!!0$3KRBbj38%-ZZ@0M8&"$,VN!N"#$BJ#3%4B!!!d'!*!%rj!%68e38Ne33d-
+
+"!+X[PfqV-$P*!!!'-3!!&UB!!!(&!!!&C80(jji!N!BMM#0%$L)UANhN3L9rV@9
+
+B`f#c2p$XpAVVCc-[`k20Y5bJ+CTHPScj`Z'!lmr*#EPaRH(ZcR!J!!rqMKG"q)#
+
+cj'G%46qffB3q8Aqp4R6FA83PM6`KUjaYD&IlZ@jDrY"pk[b&AZrdH*kFbb9PM*S
+
+`4Kh$c8Lf0bVe+Y`Q$amM6mc%*C1(jF&1bFSdGIlLpc*04b#X&D8[&6R%+-#6HhJ
+
+kX"#A+Bp6%6RGkB&kM%'jh$ZLmam[1Irq,r82rGM"5H4bh1ZB+b"Z%&-pD)5CL9(
+
+AP(4UUK6$!(lkH+UPFXFARF-MIHHMXf!5Nd%SZYRQj'pfL)G3N!$94X#(q25G8U`
+
+VXL'QU3Njk8[phV2@0Q92J#d6rA2N1["[!%c(M4X-8p,0IcYJf2lRBmD2c)*RQEF
+
+68m'9jqq*MjHTji&GqDp$kh501r9fqVPJe4iQDRS)L!)ELqiX08i#@40jpP1+F@p
+
+iC&))L)Qq4Bk-cK-i*h`cDlN1cMBUbZA3+beKhX*-&UD`X%ME%F91fHB3BaCC''Y
+
+KNba-C@(,"-40Yl"l,#c8`YCDf%#"XGD%F4m3'*i'k"iah[Ddam+k"Xd3eV@02'B
+
+bj'D90I9p!!!-q)[jAU2HhQ[NiCQC&f(Ne`JR!hlN1''4Sjc`)hcL5IK+f(@8(q&
+
+(1&Nj2XreTBI[M!0dGB4'MK01#CFF2c,JK"*1MNZ1(q&(11@5ii5EKimF*ja``Np
+
+#bA(#bBL6BpQ6jq5imT-m2mQ!dq2N'H&2RT2M%Nii'6$J,PF!#N#jGS3IS9Uba%G
+
+'A-)*8[#%!j-9'#r3@EpUPQ9+NL6$ldj*kVS6INIK@`*q'q$hGRJCPb,`pUJm(fQ
+
+3!#mGrdQqe$Nm22hkJ2cerNp"i3$m4Z62S5YA40V([V`MbHF@)QPT2IN@3@$ceHm
+
+I&dT3GqF9K,'&&8[6LKMTbQ6@-*%bJE#4RM,b'FA*'VC5`0BBdTa"@aNXM#)mU'"
+
+N@d@XSIKMMiMh#RbbLSjLT49GG9"F84)Q8QfN&![N1hK"A'V5F,,dJIF@+`iNJEb
+
+H-(5Nar84j!"*Q54MH+j&08dYQc,(ipT9I+aFqIQc-XP313&803UUPPD4*+UAIlj
+
+$U+jMAP1QUSfEYV2Qp4HKfZ#TYQTCT)hEaCbp+ZXH0"m5USfHDV1HbL4cCT@41rr
+
+5+d+eL4&+'hR90)iLRp$LYcm)e5McQN@UMR#&$kKqr%eHU-DBejbUCC-k+P4N5r%
+
+Iha+Uc5aj)kVfm*'ej*8Dali5ULfHDLah-l$Zfer1#G9@6l8TTf*r,RKTZ2#Q8'h
+
+MA2&i%MYq(0aCicHKfPlfDYLeJ3*FFEG3l@"HmfJbqFrdHU&IU+jRHE95BmQFkJF
+
+29)qp)93hX!aCGLfYP0!jSEU4HF9)-e8M9rADGfC4U(BbVVC66+8XR2Hj2RAmGk'
+
+kLDNk8`@p0[6F"hrG,e3h`kmm(BhDMQjBm@`ejDH1pG)YbUXYM'Y'5aD`-H(VPZ)
+
+,*i6A,Nqe)D1Y'5@UV@HM3VAE)a3$3MT+9jAGa)HI#%*E@9ie+jmf-PA9dY#66`Z
+
+[fkMA!l&$eZ3)bP996crcal6`ZRdT$9NG0S#+V([`rRZ&eae,A%dMGB2V4H%9YPL
+
+LfZ3B194,NC[ik!QKZSYlaE"deVc1$3[9(XVeFJIG0T,9**@'AVXJZ2Db$%'!,$a
+
+e+d2+8SES`Z&RD1(C`m,VlM*Aj)cP#M@ZlJI#Djp(U28`fl)VL9dKY+IXeFM!HRJ
+
+MVc0#YCpj6@!,M0VrHYh,CMQN!FBjl1ZVEPhjaCK)``"6,6JiU@@ekMjdmEEPI@M
+
+3DpXKj3pi+f`LFFpIUPrF058)N4X)f4ZQ*P5c1[&!pGhC4i@Ue2BCE"bRL&haLRk
+
+Thb#ZUK&ZK-Kc9k4Z-[QKhdaf&1KhN!#*#IdZ-XfJhdPQ)I6l#![SYjD'HXp$hdA
+
+f$1LhNlN-r4DbV8$I8iS[RSEqj#URqY@$9b3dJG1XG))%khUHJMX,Vh896Z%"I%B
+
+PFK1MejpP2[@,$LpbTe[Q%h#[hhai0BBHF+r-MrTeL9G6k!!IKHa1rmf2qMf,9c6
+
+d)%I[5Hq$1hVVq60(`H@-9fb&cfkb$BBDc1-Ck@@#jrVH%0cXH$@cIK[C#F&2Q9X
+
+[qpl(HTpEQ9F`KqVA3&iYS3Pl6#ARpIXMVpCP6[+ma`PkbJPkbJPkbJPkbJPkbJP
+
+kbJPkbJPkbJPk1MHKTlbJTlbJpqGlF2RNe4CD`1XDTfUZEYjDHE@[F0T$,KbK"Vc
+
+mA!9AAPiGS3Qjm[HQi+l-LraVj'p1i3&mcNKce1@eZ4pFX(PY@1(66rD18)Im"eF
+
+YAJ1K#AYcK92peXpVBfM#AZAIKi*r&r$U$"h)dkhp2[JI!kp0S3GjhdZZV))A!43
+
+jH4kk(TLQKF4pTXhHI!ITRb%hcX3KfeN#**1EI54a"'@Z8(9Dm%D@b"Y#qhm!N!-
+
+0!!PRBfaTBLda,VPM8&"$,VN!N"#ah3#3%!9X!!!I``#3"2q3"&"56dT,38K-!3#
+
+TY1))Uc!eD!!!@F-!N!B563#3"2$I!*!)22J1`2KbNQaPEr+hGEX``Jk!Vpa0&eT
+
+RDl*eSGZ&%EEAc@iGG+hAYBDRapHZd6ETQH'lV2AbpMVJ4lN,ck0G4lMb)fcKAQi
+
+*AeLhm1)VRfPGM,"Zi8pBG1%a3VYZi@m,@rM#2'iAfhjHacE,K"[bJGYB,ZcNP&#
+
+"$cqJ[fRG`SmXR'aMC-H6r-)AXTaNHE+Fj"HkN!"0"R[G!H4jITB&`!(!dKX"PZ#
+
+Z+PX+S(dCS&YGZI3,cN3L+P4H)V5R@D3p,54$JD"3'!j')mhRcl%mUJ)9e2PVUaF
+
+j[6lNX)ll!4,jajb6UrZK!hSTX[caD`$ZIHl,pdeVm&EaLeKG-YjQB6AKT)84pF,
+
+kB$+55%ID`b-4QF0T19ckfSl,d['15$X-4cTr0"2!dIR5%1j[S4JQa0,J4lT!pkc
+
+"EjcQ2ZmmNDF36,1DH)X!8($N3ihbR+mcX1GC!E!0fi)+ra)rCUL`#HU&V9)ke`6
+
+IhTB!b&RK%B!&4fA8Ecr8+8IBcr)4Z8L+$bmVaA0$-Lr)$3+SMf0Xkh!%1L(hiM$
+
+H56i!P'Q(V3ZXrmCRE,f[6f'0N!"Z$E6%fl(AqCL20Ka-#kRdjh`qA&CRACe[!5i
+
++PSiKjh)6PJM4H$#5%&U%HF#GqF0F$MM6fH)T68dFSQ!hQ*["e3hGME'TS#e`Fmq
+
+Sl`'0qRTZMfEcM@b8M`(hV,a,kqB4N8iZ[4Sh5b!9ddQpT9YP#5UK!NX`BDbr,"E
+
+!TME)X#08Bm,*$)fP2Ci@G1bTGUbETe@@q%4QL60h[2d5)BQGX-U5,*6)q)99'NX
+
+bP3a1pJZTH#BC&"!P%4'5XP`!Fm82LidDE@#h&eejC#m'cSQd"k1C&S(CD`*"Va"
+
+S%C+TmmkE6aJ*6S3kTd8)4GS&PNjQ"#DY1419T&!JQT+cV-0*5@'9$$5+K-58Y"%
+
+N8Ea'&)q3!*!!UeBZ'qd'!&14D",LQVJ'$qTI1DUU3$%0cAD!e9HMkl`KaGAASBj
+
+TJ#pMhSb5Rq0c+LJ3l3LJkD2dcrJM2Q%3Kh&mZL-JR(&m+L$L-)j29b,%B4br8)j
+
+X!Y$j4ZUh`)[eI!A!R(d!4AHG`LH[d[f@re6*b2mAI`)H5F0aI+2XYq2iC)+N`6M
+
+qC$b5"Z2ij,N%KHI*24K!$k@Plm*Hm'Rd8-bci0h@*rK6m%JDM[-[aZ1Nhq+IKNH
+
+UJA&mE-V&'KM(2a129!2Mq2,5(2qIrSHmNfTSR2rTH+3D'XHRfL81irM8FE,Ep4r
+
+eTUeM[5Ra8bilkJJ6f!)lF0e(0'p*Cke+2Nq9ccEjh#UIZq6c&[RmM(3ZV*!!cL0
+
+k&5l"Jp4$Ilc)-m$9BDMqeV0m$l6LhM(EAX9A,10lG,aR)2GNb6Sm29&b0@CfmMd
+
+&Mr!pHLh'hX&p"qiPVV#h)jIcaN(YAHVY!-im,lH&lp&Fc$pX!KD$+,qKqbMQh",
+
+@BjDAX[M-KFF0&bH!le%r'GC@E`LVXP9mKXdeG)3QcED[U18Vq4jY2c-fD8XFl$a
+
+Jb0pEdXPRCYXVR!e1c(f%qF`GKAUQcPT3T6E-YjCF2GYHhq#[aqa0'*p@XJl4r*8
+
+qM(Fa(e1(MAb2DUZDVTq-SD2mJ+kFAj*ldAQmX-KFQf"C5i,E1fA&P2jHj`!8*c4
+
+Cbq,eU+LUqmriLrQ-H$8"RJ(GXC,YKXYCKk(M!EcN!3MV-HG3b@DB@MEAd"P5,9[
+
+2CjDYplkH1ckr$1D5aNf'jH[,p0ehXaPCKe@(eI0#11SC',UQT)X9K3qD(G8hK#c
+
+C@GQUfADhU*AQPE#2X"A&i-9KaAUdDe$"bpQU)@mfJNfL,U61YQ4RBFiKFac+[hC
+
+Y@49Fi(Ye4UjKII9Fl[b`UM[(Ca+6ZhF[@mq`0Seer)R3*#Y$$IcK`pPc%EI6FKZ
+
+I`IV"'%bLZK'Mdl!5jqQ+3J!feU'k*f(FZf(EGY@@N!!CGAmMqd9@CrDD68d'jf(
+
+3TlQV6AYhAEJlGh4$epjV3bSqBiDXKA!BPjeTVUYp1pI,DPfESAK1"2eSD[B-elh
+
+H#"KCEIFl0K-Um0E-CFr[,$HC6Hhc`fDr-eb-HmN5*`iSE-8)!#TL+mfKpUV"jrc
+
+$X6fMXIlRYZ5'5$I94YXX-&C(`""L$Dkf)VmVe*%)GZr'mh(#3i3EqlYKNKblRf*
+
+'9fi`h"aV43`ejERI0DPfA"MDB``XX)HHa#bYS3h1c!hCcPlQ0+mDh0Yr`mEU8Hk
+
+YrAmUXCIMj8SFBkA%6iNVCjRI%C(IMj&E3@l3G[C&a#hGId-rBQbXrT)c0e6q'2p
+
+eC)89`[fJmPd62,qrh"5fBCA-$%rb1d1R5hbj`ddQ1G,60%Q1l'T#EqB1)110@)h
+
+%i!95M+ekEiM0HfqSHM1k9UQY&%V$jTQPB&VZFVm*4FmG"[Acbff$#qbZ,a3IKUr
+
+B"VZ2A1J-[B%elK$paa&k8Z63JaakNVNdL$c1fP%+A`QGIJ'bm6iH0ZklkX(0S"E
+
+8jP*3Mb,[3pbE@&fLD'2RS@ZY1`pG"kj1X1j#2R9*X*QX*TAMbYcVef*YX2)T6FA
+
+Q@D$Hf'AE5@VBGSP+2*elSqN#9T4Gc"`I)"SMr!P3K8hPL)Se--@E+!*#j8qBAdA
+
+F)f`H'*JMT!TSH@V*`'V2IZI1K@DpeEljYRXA2YJ9eU,IcfjLaVQJjXS%LTUELM'
+
+UNU1Q*M@HTVX(FV[-AA`QqadqFr3i9[JU81PlSB$r%d$A3iqhZfXV+KG!GjBeeU(
+
+[-cfI+9deX0(XqqDqeeCrEqGcqm6iUPf$i$#AQd`B@p0rSjJ6NR2d'hX'fX5-"MQ
+
+MU,pRS%(-F-NCDZeUk[$*BA*h$2XG9RaZHj-D6bq3!1YJC6AD61@QEFZ@lXi09,[
+
+#3r`40LMRE"V0'C!!FecYKJh1Q(D[`hN%90BLbX@@Y!c8C8j3QmY!ApD)[GhVGTJ
+
+**CcApF6MTA!ZjkemqUrh9AKG,PI[cVeVI+q#h6`$QIm$kKcXmZ"@c&ph+[pbaRf
+
++-2[6I1-)JqV1YQR9UpZ-&Cd9Uc'6i5P6JCdV6"8c-TKV%$1eQ*@af2(L22GJCe"
+
+VaTDFcfaEffcXh1Pef-$Pm$Vic)0VQmqbL$(+mRVQJpGcr8kVcZZakIJ-9F5"VJ2
+
+A)XVacTfpDfd&ZhSY"9l2XleH6rpD3Epa6E1D10FlQJjH!G34SPGS&qM3*fC3Pe2
+
+L`2L%lVY,CV!*T39qcpXH[fHHVQRU'%UAhk2&Qk`VKaD[,i2ZHk`cX2[6K&iQRrQ
+
+lbPXmS@QX)1Y!&RH`da"Y"8BfPYDc4GPC#3lV4AhlG+E(2&HTGaMM!VD)&65CaPL
+
+Dr4lQB&J09`k9kE(,mhf[0f[T[[2#[mfpH2-6*6k4bk,U5Z`kcd%Ia$UcfEZ2Z!G
+
+1&'%PEF2B1aKl$'0hBH`R',X1BjX`pP1-h6AD-aHa8TJD0Z"T@[KdIJ$5L*0!R+1
+
+)NmCi#mDEj(J5i`fS4KaV[49[Y[ASjjGJCfSIkdaR)f+)e-#cLpMMH4iTJQFE+B$
+
+RFiN4RXfXNFpBZGXAc[3QM,G2Yh*CMh@3!(q8lFE6#ID-P'YZ"AefKT9M99N2Re%
+
+Z5UJ[cKd0UjR$Y@%N5eQr[bVdDANH1X3[2[#XjcJ0%Se1!jKa'U#f[M%BE`p&`TC
+
+@-mfEF*1J""c`J'Sc4b0!`0Q1cH9X!e(3aCl!)H`k4qIhpfYS1)*',+EMMLJR'JM
+
+*XAVRp4,L3*6EFHJLENI+bThcfZ@BBX$BV8U1Sr-@+@iljX&F'M+D6*J-'5#(%1k
+
+[1&EhlT'("@L3!%(&RA-a6V0,2#9X9%3D8*&8fT'k`V(k5V),NCZX$kh*MY@GDYV
+
+4Y-8%c[bAlh!l-U6&69c*e@N4Mj-C)C2d+XbiMLZjUSJ3--Aq8HQ-$[R0RcMaPa8
+
+e&lLqlpUj[TGS[iMVqri'VZr9AUl[KhZi[J-YA0r"GUl[d&eFhq'YA0rr0h*pEml
+
+RqYlHa2Ap"212)[Ba!pGh2-6e$Gc+p3dqbr80[FMe`hbZAjA&I4IA2aN0'##DQ-I
+
+F0B%8$M1bX*!!6V&dUi!$KD&N2-DNDAZFBic&F2BrKF2r6-!j%"D+4)8c'q,aD,f
+
+3!-3j51B9SJP@RdlLA(j+(8X++A@L25E3BD9ki@,HV9l@i1F0$6KDbP$RC(bL'2*
+
+%ikP8)(QCZL15MXe30%"dDAVbI)DMURqBCV&i5b4dfDrbrk!LN!!@@#SGL#9B+*j
+
+N3JH#Y3HLV#@5r"fhhq@IS5Jp9LM&BLQF6+PSMTk2cbS%9c)KQ@5a90K#Sf4N5PN
+
+S5M[3da4hiQK)k+XiA(ND$YpSYSe-m)LIZ,6N5rL%!p$M"e)Z2G@JJJ8FXU,((EM
+
+pQ)@$C4*&(*ZN6`SqKSGP)q02Q+F@[iqA@RaFJFBHbCM4qfMF%h!%89`D('LN6e`
+
+k'KDkIh4i5)XM8r4*4)JcM9hKZ+)%Kcj2Rl4%aj+pAcSALTmN,qQmF&6[3Z`$k*0
+
+%H%M18RJEF-b22R&0qM&+6,@P[&-a!BIik*1U!BGKe64B611lY)`iBNHI9"S+Ab9
+
+l)JjKd5HT3V25,H+!P%`9Z`rkT%9kNCS1THY!pHQ6Q&%@$8)T99L%Sfhd5H*hI$J
+
+64C28Y,C`Djl#m$6b!XGfTmrR*X8$d@L`Y6QkdK+%4i(E8[b59GP&,"cqQPC3ih4
+
+MlA''N6k&X1iVfl4IfC%6%hNG3kaD8[4Nmd+LGcpXR+[Xb-XNFZZYEkLS`Q4G+Yd
+
+5L413!'S-T`$1NR'U9P55`+R)+U%aM8!K9-"b-+[Xk$GR5FTkh)hN*rJB5@-L'EP
+
+%j(6IK+GdbSlH-e9"XT!!TkM$335*3-%BFqd`miD+#P4)M`VKJ,5STAS-5DFJ,A9
+
+lRF6mdQ"V)#Q+K-c,[YUNl&M9XNEZ@PkXmY(k8'eCj+P3G[5T%69*)e+cY5@CqV"
+
+#$%SP0969B)9`fR3N*L#-jAfF#50kqURL8%pU-)M3+FmipZBILqkTH!E9YJip)aj
+
+%`mKhi"GMeDhkeqSZq1IU*VIi[,SeRcM3"dM$M['C$j!!BhcZ!m11mCN2&2k,$aK
+
+qi32[Hr5%Rh[d,hX-I&T(k6&F2UIBBc4(!m'9d93k(d+2NBr*-djj`D*SpBJAZ,f
+
+9j!86F'3iZ$+9LDAqShqJf[jh,cLPbr2V[SPKZ8BUA*j'UT'@jR"M,2UIAFerUC*
+
+hbU&Hqqk24KaUB492qKV`$C4!&+Z"V#$rQ"GJ24rmKPrCa6X4KAZ0c$d@5+lmTal
+
+hVejS(qNI[*91V#iSP&p#b,2@2paR1A6E52mJe6FBBMJ1dGJL*2+9p3qIhj!![Bp
+
+M('C8fB"h)XK)5,I&%TpfThIZ`BHa&(9Vm2+9kL#QA,kQIZdYiIaLYrARRVV2f2q
+
+YNG[k'UGr%8DeBN-EK0EmEAlarTd(p5,rIHIa&j&hIpETLXk#R@jbC@-b,9jkj$[
+
+SG20dc3jaep#MG,*Rm*9,kClGd#jFfLM2Qq@TmibVrRcNcU2@95h1CX5Efl"&%5r
+
+8mURGV@U5ZdHGS,k4EYRemG4[EPCrFjZ4PqYQYFV$Li`LB4cI%5Ak4CIabTc4cV5
+
+Z`5pfTSPdXM(B'Xb,d*RQlCVl-6rbfNK(iUpddhemB9))4J14@"k%hM42efh'efl
+
+%*i192U1qBE',qSa81Y2F(%qfjbIV-mbRlM2Dk!QiiGN-X@CeBXhQjHJG2R%#l)P
+
+%*m$r!"'46R)DGS+2k[XNTp(qiGGq@r81$FI)IYZ`[)lZM!cTba)YbQKh2VHq(T'
+
+iYATPahXMf583L9i#-b!5'SA3JP$LMk5FV"eL5P&e,)!2AM(fqq[&rAqqJEX3ZJ0
+
+4GUAcq1#I[$MlrpXrj3jb$ZiY+2BkkdRM@qKR3r"mcb,mia%m2lM89dZ[Vqh!-,f
+
+QqNbpVjjZ29qJCq04M`2d!b+N'UT5MqGLqX832%q[Aej$mA2Gr%)2D,J,T!VQVUK
+
+`%6jhAB9V+HAI4,rjJHFl+Pb,m4eQEZZ5@KrPp5aF@N9GqC2+ql1S&YkPdTmG6Gr
+
+!qEV`09U+&4c&223NLQNk-DpALZNdR1mDqVXNM'QAB`crlBKL%mp(M*G"*FCZ`&J
+
+DZ&cZG*Ki-f,J@mmLMhX`*R29E-FB[Qe,XDNr4DlPFZc[1GrDKlkqQYkKeBBaYUl
+
+YEqK(@E3aM+N[HKM14ThU%2X*Hb(-`McNHXhpB"3j2BDaPJB6I!Ne%&qEaD`r`V`
+
+YU-G"k"3ar)MaKKaEKl'$NQC6hd1-Lq4B$Q0G-XB+e-BRajCJ,+'*V3bd4NrqAp,
+
+B[bJT[kddmXG*R(e#AIa5)9RRT[cr!`!!$3!*Cf0XD@)Y-LkjBe"33bkj!*!3qL)
+
+!N"!0"J!!,h3!N!6rN!438Np+5d&)6!%!UE6L#+X`0A!!!#*k!*!'$d%!N!43[J#
+
+3#1j"$F$iCXbcEQ9ffFS2dS@*jbZl63NYVcACZY$0##1XPDZ$V[@ke[$dmVQ6K5h
+
+FYGEmE+(Rmc@246PGf0D9hF)@VNAi`VhS`KGM(GQA+lmmdfiI)f`c`Tq`63P23V[
+
+Y`VEH`KHqX)9f(@(E*!Zrf-)@IZi)AhKXi3[E,M3j*432"&!HrHaD@&$M#f(,qq3
+
+@XL1hN!$"3Rk6AcKCb%+1%di@J&@""TeG+a&(42abSQ*m9@@VL(4[%29TUPEGj%S
+
+NfN09'd1a&"q0T8,*F(-`0#85E)pZZ-eZrEB+Z[80G6A,A6ir2'5jYd$i*mlPdrI
+
+-@8-1XA6I6r6dUG[h&cAjUSAPI(dbhQEPDb0*+mqX6fN-*U1*9$3@'8GN$c0%(%0
+
+GelfTH&Fd4Q0)jLrR%MNc2aM&pcf8d``Y,Ak!B(cHb*GQH1E2Phb'JLQq0Yi5)P*
+
+IZ&DMccNrDX`mDiN1BLbSE&MC!)B+3p!!(FM4Z3"pmf##5,64Fd39&fA9Eck6N4(
+
+q-Kr+TK`qGQ`-&dGPAb51%'Q'J"dB3bK$iZYMHPIm%$'QJ`j8f2l6cq5j@TmTYD&
+
+8Dh0,2)CCjkGqG*&J+Y5CqU@IDmIQUUrh9q!`X*4GG$59b(1#DBYLrXT3Hc`B6B4
+
+D3NZ)Zr'(SNLFq4ETPX+0#01J@-c9Mci&E"ETe"lZK'B2D682F5pVpcl#6cM0`cF
+
+VIh2RdI%LA6N'$6l@jXi1I@kfp+LX3395@i-*Bq1p(FdBDS-m*N)0#&FB@QXXRJV
+
+TqHr&d$F[UDca!YiDjchaf-C3%T1`bTUFNM26%1V@@T1GbH#dKP"R2*d-KU#5L)D
+
+5FVQ)&NXr0"XEY)Prh,6j`NN!Fk+aB(Zk*F3lDTZ$[P"c5bMC1Arq8UD4i#5T15f
+
+KF$3@iP2*G)M2RB8&#LRFh0iTXfaMT'5S@aDD8))aK6DZ*"9[2BV(P+51c4hG,L+
+
+c53S*k44Xa8Acmd49U9R$Xk-p6,4P'e,Rh4bZH3"e6"(G$Pjab5Ikh&MNk*3JKBH
+
+am`[rd,p4KJ)IdrpGAkQ!SYrdArSB+K6p(4q-kaYR%DeiK@MHTTrT+airpFpf(!c
+
+C6D6hMrH[fSGq[SpSi@NLdj2ApC8!q05rrM0pH5A%p,FGr*AqP!RpYPrTjl,kIr)
+
+Mrc0p)kiXJcl9Cb(1%'6hP`BRQ0MP'EU4U`lF@CCrSLp0(%#3!"HAp98B52*lSGq
+
+&ZrfkrM3CD5@kEp'%2R+m!*ldPFM#f(9p0R-`C#rdT5&)cLr`#Kk#rMULrlIXZ[j
+
+d'6P$Y0N+!(Y!54rDdc&h'$"brDYqB3l4$[hhr$0$4PE$2eXNb2ieb2fErJLM)1T
+
+RZCa*(rQIH68r2Xk[*I+#iKreEj!!r52r-kc1XRmYjSpI3ai@B(RaKIqI,BSqG$#
+
+E'MkH69X[ckB'iJEe$Qi`RhhAFB-&cq&lKKZFKRc"-D9m50)#'Z6Fp%2+jFLffS0
+
+N5Tj%4@C5"GI&cC(ZFcD,h$e838lFZmM*m-eX'F$dP%A,,mqff[SF8$&N-KPiM91
+
+9NF2XSa0J@f1fH(J8"hGPCVYkTSRLJ,V55r6R486P'%J,"U5PdFrVi(p*UM20Z#1
+
+AjGIGE[0r"EdLeqdcjp[mNSplX,Y)hCYJ5aj0I@@G*jb-Gm65lHf-'iiR1d+aG!I
+
+M4Q-YACfKpTEfZ,40CpQLY-XkZ5B+lNFp6BS(cVppFXHLm)JE3biI%jRZ4TD29iR
+
+SY!R1P$QEBbjeBD*lqi'1GccMbIje'bEC1H@a56dI1a@*I@9pEqBF-qYcdaaAM`b
+
+5FjP9B(QLVT*e4Aa$'kXN*T*FX[j[jrbLXcJ8Me@X&Eh%AL-JTT!!Gd4B3#S&rjI
+
+6(0UBDSje*M'BT4+G-9BhC9*@-5jcH$[1@!XpJKl'$ZGDCHXmRb03ICB4reapCC!
+
+!(Mqj("6&rGSNfp+B@FQGKfZV'cfXb6ZLR8&V%2h"l5[mJ8hjJPR%eT0&kPUA"r-
+
+MPcHq*D-)FI[,GTp4[[$$5jiqJ&BGP+G#UkjaI6!H#dFM9NbNa28pDebXI1(,,(N
+
+ED'bUV!CChjPULFDCN!"U8NG00mXke@ZV@1Ge4VY$ke-3#PpeT"PAmJT`"+9)V,N
+
+pTl6IHLkVI,'RZ6PAIkpR2HXM[+GCRdK'0dVZpqGr6kpmXC'CT5KCd3'NL33K%LA
+
+eT(2pQ21Q5[3dR+GDX116UUkC9$)S5UXm2KGcINq`Y6NTP421bhiMS(ba5j&Vj+N
+
+6f#aTQ1JNeElPhNVPLj`GVbDV%DYQDdZbmeS[j5Xpee4GLelLG+PS4`JbeUXka[&
+
+k0V$H4$f6H2FMHFHjNP0bI"Sd(Fh4'2DERk5`R-%10TmaEFjrI`$I68b$mrG)kq6
+
+aHBBP*&LlQC0%8Xl9HQQfr9b!L@&XcMHPT*eJ*QI3,1Ibj`$iNqZ&q@YbPJ1Ha&!
+
+Tc3P+,rc(E-IjIaGE%9QEH@4l"'92bccba&FiN!#)&l6[jHikPAbI*GrYmVe9[[I
+
+)phhbr86Z2U8bGeIk!)'b%TGV)mAiNDCMGeGHc9GI%IUT&GqZ"BjUSA+ed+mA[-2
+
+LXC)(FAZaC"ZB'D&IrCc3Ep!"HarI&r!YF8GmAD,SLj2'YmVA4CaPLEK2k0IH*6a
+
+V*Vk$fS9GI4I"H5aL!-[(@%*ka9$HA3N5qMA()VUDA4&9YPT)mi[cZX*6&cM@eJP
+
+93VpZN!!h"R3P6RiqmI$[+mN)k3@15PH6#pcRH,qPD`T@&9NVUY3'[UeNf`)(%Um
+
+4l0h!LdSHK&T$P4pi$qrR04'Md+mkS'(0E3aI&)EejF*+mAAAd"56T5l"Ckd*lZ6
+
+dYG-("ec$9*M3CUehlN4&9Aer+0`PT+AR#H3GeRp3FMK[%pq9er8Y223JLKM!HEY
+
+N,mdU@jbA#DY@la65UhIkhK'(PTE4BPEM30kDR@@'[UIiiUc6TNIh["CTp`k2hPr
+
+5`jXLjbc1QSI$eZbmE28#KdHUPIB[)RkQV95-AKqV@,pZ+bUiLHmHp@@M''(eB8f
+
+f*6X2R,FYF5Vrc4ePeE6)rfDaf,5cCM&h@d69*`VTa,5qikYhmZK0Ble`+6c9aU-
+
+'$C(cf9ZKQl&q68LMIi$490Bh%PU%6PbL0f'aB1Hl9(X5aT1l$Kj@l3YE82GhXer
+
+JkbdqLcQ3!1Fk6iB8YmemmZL+iq,&A6dRGi493YT#@5[6iERXA%YphBr&!El1[CF
+
++&dD44l1b0lLIpNA*b0Ie[@mhS`,[c9hpkT&bXm8F@aUa0,JLKIL@V(3KLJm!)8*
+
+&l+8LDUmD1G8`KVdmJ3fHfLH1XVUTHZhcb&J6TE``hq4Z-c@i`ef*B0pah)HB(K3
+
+H'HbMU6,f$BBChH*)C%0(+c3dM1IjL9Re`SV`bmEQ#NIi'&Lk[$Dk84behl,DCHN
+
+H16RiF'r0K2I@`Gr,ZCIaFJ8(9XVm+EKbPreGN!$mr6@mUF84qbhVQ,I8i-1$d1L
+
+YqD*,(#erAVJEVY!Kh&Y92c(6UfI+c4%lZQ4ZC'U$+c`cjjFl(c$,5(pJUS`F$5#
+
+EZE0`h)YZC!jHBaAMZcmFjCGm1&U$M9+Ne&j+T4(,h&)bVh&lrSC-Tmk6jY8epT%
+
++KrZQ`[0dKhfNlm)+9rKGp,K6bKpRq*MNS4mHqT0LLL3I0lp35RH%Cbk#'pph)mE
+
+6[h0S,fP#'NXTD5D86d2hbhap`Y5EHAZ(lFME$j!!1d1fSr"6Rb5lf@C@BB2jcJl
+
+d"Pmq29"SQ8HDhKll%9B0qe'T%Lq*l`B@mDEXREcc)d9M9,K%USLj(+VSJHQqK)Q
+
+BUR$*mLCd,r",+)phKPA01S'YCFRQb(lRkmXX"TYMlpHHARDS*k*$hLm)m'`$`C@
+
+&''S*&!*9bDJjS-&YYQGB2'VT%G,Cl`MTLd2Sm'j5'3C),I`f)I@3!2%1,)HU+UJ
+
+[bkq[4qlc"L&GfMhFDr(rrZQrf[,p)kG15hMhd4&b@XV0CQ"E"aq41''CBqMY(fk
+
+6'%db`c6B2p`N-G`b3k2E`LC4PM$L%f0jKiiA$`FdZ,h'8JHGYGjZ,MFIA,hUZ$K
+
+Fiik-#KIi%CQcHi)c,(2FXEaGVJlG5DIV!UPX*XE&5&T'QM)AD5aPC#KEMpRZ(3F
+
+@d#@FcrhLGd[T9XjApG)IRkldZGhZJ5-RYrVI*)HP'-lr3A8KTMck#[J2AZG[`VV
+
+Jha3@r)a[((G3NfNVUYR5CUc-9'i"NmFYABR*P@C*M$5iH4*6"eEDLVfl+"l+"(8
+
+@M14#qZ$f$FE-%Cr66QkRcbQN$fhIF,09`KM,jee+2Zp$4fakRpHZ&p+X)mlfR0d
+
+"PD(-NB(YG[A4!D[DjheP`1FGh"ibp'lGS''H'jf"FrF4Q`L4&ES+2A+LQ%dj*8l
+
+JqAe2P46cqDAU"Zq2[3hH*IV!V%Q9RJD[$Y[IcD0hlLbM[MffBNarf[!E,'IqV1S
+
+aElL)9fHGF2%%2`0UDi(dPMEbbl2c%Kck4I2iE0i!RV[80kDaL&r1U`2Q5CH@"Lr
+
+[j0%0QdI,$*Mbr0mIb&Vl[VlL6mAA(hfaa#pj@9j6KDPc$R)3I@Chp&h`$&mbSC-
+
+1!RXIf22!RJ6fYm!H!,BEf0m"Hh*LCMEaT63VNSGE8@5Q-%`Tk#5JFa%k+H!Y`!-
+
+bRJ6HK'V%dHZYf,SBN!$R'c'C1LBRd`93$,0Ui1jQlR&I`LU#Zje9!2GEQ52F,Ia
+
+k)@hM(PmfejF`2MlEaQ@pYK(Kfraah#la*h*F5bXCXX8fMUr1HS@dXLKKFl&i-D,
+
+KRHjGikbVar'Y9la$l2RB6pmR,LdS'+0CVLaC,H`"dT@r%Z!F2cScr3P3LVMhU0$
+
+RDQ6lXmIBIJ6h2FZaT-(pd#Tr(GX$[`!BEfIS4+1rNEepHBe0*1LCXfaR!QFkYKh
+
+"[C!!E89`RpfiTTEKYhU%C9l5FSYb1eVZ[NShdqFHU(5[B[`[Xmd%lNp8ZZr%``V
+
+Z`-Sk2q2e,eY9c6DeamCH2MPq""hf),AJ0Z`'mAk4BHU,`2"fN@(D$$6B3eKJHLe
+
+ijh+BEJhfCmrNX"X@BR0iMP35pJI3b"!RLM2TKUm#`jj4mR%B@%X1Qrhh`&k8X3q
+
+"I82'4(M5h,f&[F[64H#l[1e2f"XKA3FdhPMh,0f#,XX(PR*-SARJ23cXC6*+rTj
+
+($GBeQHQ,U+Ad,JkXA`G[(hJpP*%d'S#PC1a"B'rNDPDX"RC'a[6!hT)eeX&I3XE
+
+f-%rDMYpUEQfrmLafmJQYmYTfr+%XjmL[Mpm65YCl'2rr!!d!#'GMG'9cG#kjZ@0
+
+38%-ZZ3#3%%0D!*!3(m-!!%+&!*!%rj!%8&*25NY"5%`"!+QdiJLV-$9B!!"5l3#
+
+3"K+K!*!%$I3!N!Me"!i!pCQCc1abX2*Ef-,&mj8EA@KjV4fRQfkf--,fZP@[Eld
+
+Z$dq2VmN'A5Bp-hbAY9lHAJFXfQdl+AG,Z2)ME*&GEJRrA-libQIDl@-,fic`*fc
+
+6K5HKhAEKE`YIq-)mEQiRK(pXXmb@iapGq-+kKCfFELT3q1c,IZ&ZXPf1@pl#b%)
+
+ffjdZC,)F@FK#&m,)B+r,!D4[CPq-FBbaqZ@-eH&@A,@%-I9,M(@V+THFE3i'I@,
+
+PFV%p`R[E)f,)lA5*'SmV)SBMaKm`"H(DkkSAQQdeb1%*lP8%I"Kcj(3rX&H6m0M
+
+IZTkaqjrj`UCT$PZ9X*!!V`m&fSamV5GNj#ReR!CAb"Z-H0XpDBqF`ePa(%eGaiT
+
+)S-2EcP+HcTr1B+bXmm9Kh'q$6Mf`X[$"KF4R$RhYV2*CXk3m49H%V`fdL)`T"cl
+
+J+-2j13Fpcq@-E8&E8'&IE%H%!Ne3,pZF#1HDf2Hf""Q,&l1('*Yr8%EphJ1GXSF
+
+r%JrNr)3rGBV*(aq@mf,a)FC8Kq$ER2+`6KCr)B9h0"r'+0,%0Xm[rQdqSqFB2cQ
+
+eBU69f4*S4krcbhc8LClZG$iIR'*cIAh0I"abUXM3iXkAEq$(ilQ,49r!j3f+,H)
+
+maNhp56c112ejNK@"P6JkPXIB&fjK8aKcR!drZX6iG+jqq&li[TdQiqM4U(!CR@&
+
+rGU+(,&FBA8QAdZJ+kKT@q*eSAPdm1Mm9!Sj'C"RE!a%aQhqm(IAaK-)B'-FE!ha
+
+jS(fj'%,(Uc#'FK,*f-@9@FC3113DEaI$J@M)*3)Pk"9$i'!+Qm`pccf[0,(*#J2
+
+h%ZcNS8*JE#k(6ij38,[0q$[cVaRB"FIjhRDA,pSLmUCDTmXQ1P[%8(M@V%X))mK
+
+*81HhL'j[ZmK(3P'46jb,ab@$h%jI@)iU6J@&a*8bd!J5%NZ'TC%NDKY",5%K9lA
+
+%%1kQ%f8Z9IE(4kQ5X*9Mq!UPK%dirih2+53-k[E(m!QELQ!-Rl#ccq$6B)6Z-I`
+
+FQ(52iC0Hd6f'2a&QlKPm`YDG`5GX%V)aI-*'%r+rq)3prJ`qB9260)C2f"21i"-
+
+feI!B2QRI@@I`#A[5'Ic*-1NH`dIV+GeMrFY8Q(52j8mG(mdXar#TGUKe(X1R`pq
+
+T1G'EYSlfTT4IFZ446jL-RfpLA2G!eYX*@kf3!1dTXPdLfkfbh5AE'fAlbB5G8j'
+
+`4rJkCZFXKT(SUhpj-0jKc0+KVIl1dd)2DmAG-GY8*93X&AUb"HYJr,'#0E!H,EJ
+
+1NCe#Mr)KS8HMKZmGh)rJ,V"iE"haZ#h!9,BPYJl''HE&0`Sp@9F+$qSClfFqB9h
+
+h3F6FlY%JbNC43[653pSVJdcS86hQ89H[mbKL98+8Rk[YF1I00PeH*e3+2HTqAYH
+
+N,LMMCc%HqGX+1SASE&1&f@&'l%0mMD%M4m1VBND`e)EiiS,VCTXD(2B'40m'rl5
+
+#08#c9pE!hmAAm#U26ZK4E&E48%VR2LJ-CTF+Lq-[Q!rPj"[UJRc-'14f6EKm3Rq
+
+[HC!!63aQaBb,eS*44IHY`T9#9"TN-1YJpRX&fl4AmahDMZpMp-1B4i1Br38Ef*5
+
+LZGT1Yf,T@L'kG+hYpILK5iVBA1+i5A[CfL*0plhmp&KCF6DUCir(CadF[VkJLmr
+
+hl$189GrN0XCQaUTQQmSPVV*HpY33GT)apN++X4le+M"i0Epbf"EcSZR0GUYL,E'
+
+CL0P[#,$5,pp39-AQe,`b2HjB@cfAZmLMk)i,dH$ilTe,er+S69fpF0LG9mb$!l[
+
+R31a#i(BDla#LU"ri@"l9MH5GKNUFPjh[CUb%le$F&p6Y@VGPQf+Mf`$HhiaG`0F
+
+EE!CpNpCmJ'NLh(AkA6XZh4NrZ+jVe`eZK4!eX*L4F(JZ0X03ArHcH#pICpR!*Pl
+
+XK4j0L8ffh'rc-KeIere1L4i-[$eMkE2E5r8'IIXP(S2Gl*Q)Zf#a'@X,Qq&K$)b
+
+8&-E"[@,S'A[+pp5)VrqCMI&KiNfa[Q3Qde9lQGE01baYqAD,Zb2SkYi*qa$K!H(
+
+QrQk@*rZq5ckG*6lNDIDh!N0&FHA[kK@2A1Tq5ZHFEh)rKLLeYSe0M3qAR,I8E&J
+
+jY+[rT[A9)lQhp[p4)R[CAjVd`eG)q5Ap59[1Ed$+lfq3!*Xb2P4bhK@8@k6rTRj
+
+JV+rq[$NqA2U`m"9NK3VKAUem9mqHIDj8lbP"PFc`j0R0lNQ*I,N$6AVCdp18*hY
+
+f0%'EZEh)H$fUN6,B3ica+pmIjZHp2ebp!DT9@&,)#Mf''B9-IjQPr#f@rm`"TRV
+
+fXT+Kq5E,f4-2X#q@$(82A'Tf[iND,j2dTmcpQ*4$$h,S#F8M6-VMR%F+f4IGNqB
+
+J'pZ22,VGhpLkJDP%PD'3!+P'N!"h!rF@[MkB[ljcr`h&frIIb#bGV(J(mUN2X4*
+
+pX9j4GNhmp4Y3'hcTK+D*KTP-YEkVC$Za8E*$BZ+*q*Y0FrMmf#+ql$LLcLXFCJU
+
+2[K5SU)%*YQ!q)e6KX1%9i!l`mjL@,h-VR'U"@M4@E)Vpm1i&"NfaDF-GpbrBfZ9
+
+43qpR0r'kZ8c&&BRN0640K&FKHr90+PMRPJr'GaLkK'MXKd,di#&8q%UQd23bTI"
+
+9"Y@$aT[+kbSUjl2Z'0pB$phR08+dF1AJHN20YhDrGZhcfjrC,IPAlKKLCBC5[4k
+
+q9Idh5c&Z18Dc[QH`6BT`b"(jr6f$$LR#)NHSe0H#a(a5Q2KG+Ee$aFHh0DPJl5(
+
+93@8ePZK,p9Z@,YNC(kbfH)D&!Aj)MVPY*'C3MV'dDpHCrHTGCHB"TLM1TeLdU%9
+
+-9@4Q+N-4da3eSVGlhF4QX!,1CRRd4iAX3Xj@qF4Il+k`@5b@hZfl9Y@m`Nb'kFM
+
+m(e%[4TI(rJ6aDdl'AmecRb,-rM4HPmkJZV0Y@[@eEEU+cSTV%FR$LPDJFf96T)J
+
+SBV95T"T4851Qcr(ieNkAfS!@ABKZ@GfXkpaZ+bYKPM*EQ4$GZVVj(+2NSbLEp4*
+
+QXhjcHh'fc9U5,85T)[CflEd"+)FkYrHZ,P(Zk$8UEGDRHfh@rY@LC[fUCKAPh&$
+
+@Y1rVM$T#D)9kIMCdBMTe139Pm1GfheX`RFmY90UY2l2DVI1bQkD-SR6CVHVV',Y
+
+QH0(D)YCpAr&dG(pClTG)CrkkmRDVHaU[M*8KLl[iXi"f16cV#a[iKE'C33leSVV
+
+cA&k$1%ZK,B8aKer)+j[dSeNDl&DqM%FeA$0FT%'A9r0mEmcBIIHPIa9riGZ2&Y4
+
+)Z5bXVN6AH6jd%(9@BZSH+"mmR)p+fJ,I1r!p$0mpm2dGI$I#GaYmI`rI25-pFcj
+
+Ib+CiY,#QH5B*Jb`#R#"`$J)R!Rm,r%fb2`5r!f`%81ZYQ*CVS1I,dCQD4M[6f8"
+
+d%aZ`,C3pl(R%#1`5BJ$fKC34E!2I+%5,Z6XAc,!&GAHH@mc&V-9$`JriRE!1mdm
+
+QBJfY6"1EAXca96'V%%d15UJ[MKrdU2JbblTde+I(r2fRV)GU*0F[GKFZ'6FZ&@C
+
+!@&e$S`1V*BfZ3,[Ekc'f'QM#1TGaI6mfFAd[dRd&lTYa2mhe[DcQqPkGarAYVFD
+
+pRq[EGj!!kh[Gb2@pdFVerHebVZqYjlLqJ6bZladIehI`(Ul[(a4Fhf(J[@rMqRk
+
+qJHZ,jh2ph!,FAqIkPGrNqY@YA,rQDG`$A2piD5R$)dE#I+49a0+%1a6`miQp3Qa
+
+bq2hBFJaMcC%A-H[Lh9kI1084#2JDa"!f3ALEk![b$C%30K$$+Rp)$+Z#lAk4M'@
+
+U"BZ%FY95Keh3%Y-m5!m&aNNZUbm3$MY$+e3GhSKrHRQY-ib9%UaRb2XM&r&Bb[Q
+
+$#1m2Y(MG+riPr[FUR"'4$dHFrL$[$S4iX30Jl8iIhq)0r5khhm926M)p@LJ6T9)
+
+i'P,4l,[)jI1kP[&L+-6l`aiMMHaaP!k@(kR(!$5jIF64)2HV9c"fkm2Bb8M[NA,
+
+5*ahe$KKB9T9'TSPBKI4**`H4UR2Kk*+M&9J[`FHC*Q&NUD#pVUA83F[45Jadk'0
+
+F3Yf1$dpTM65,Hfl&AGM3!#1U'a&eQabGKF82I&eA%c-D$%HjjT%"U4TMFAb*[&A
+
+h)@)HETXFRBf&$h`V0NVHj1U3!,`K#cY(qL511H*j`3MI14L%iN0H')LU%pY@kEb
+
+e@+I!ap@!&jDr$K6[395bNR+a,%&ISM6!LST@Uj*V5MUX3Y#A)"$4+kM@NKY`il$
+
+S30pF$R`T#q@S*(BHeKMSieHp#Flf)`,0AQTaDcb@&2)PHQQ)5fb5Xdb1cXF+!Vj
+
+N8DB2,Ic5f4Kjid'T!M!XRlE0,$48%8&NcjVeLhiPLG[pfVbedR#BF'qX0CFl+(-
+
+SP#2N$)DCki1*FLTMEYAMF%qMfLlECUkT+5IZR$kIUlACYmcS)YhC12(&iZ3YB9'
+
+@5Q5*+ZHdkID)X$BCAmp+hXKTKT6AHm#U3r4C*hSQB(BrU*ZE[*&EJ[hH"NF&f1H
+
+b`j%@Ei"`&+-i5TRYhSDUbbZ*lE"hTGJB!9#%@0JA5pj3Yh-5l&V,'fQFRq0a03C
+
+$hZ956TYb(mp1hP#k+8NN)bQBbZ-#L*FT4c0ATc*h9&5!)3dB`XSCTF08SdMC5D3
+
+Pj6BcCAk9Up8CNNK#jN9IDNVH8!QCSr)k39+0G(N`aFD&eSVN$99-XdNF%CZY,D(
+
+`"a@L69D5SkS@&F+T)ekr#"MM-CcF0*pfUMM`5Hd-*A450pjlk`mPT8VU"Y9h0R3
+
+Mi#,4b)#J'D-9V[Mh#PIqZX**-8jAH0BrUp"aT*4UR0)#8Sh6@T!!8Se6@T!!maX
+
+Yd(kN"FGd1[HIG2TA[3DH,8Mf'TBDXp4V02ZFVQ8q2,U3!#'KemM%T"XRp@#KVcU
+
+Y"q@f5Y+$A#aMZCD&Srj`4S3qiL3hckljPY445pa8@+b09#FYcCj'[bpc@BGcr'Q
+
+!%69iq@)m[C*8URU(RG4!'ib%'PfYVS`*8j,-6"h[aReIXbG[D8k5c,e@cYh[$#h
+
+lT)pilFFr65[(JLU"+N',p`QF2Y40KM[Pq2-plHN1e&CT4R@a((P61@0C"rU4'Q`
+
+blVmMh8FNDTaTr9MRD@`4JjR-qSM6-pGM1,T84T8160L3!*%BDI-(2jh'hIh8YR5
+
+r8BZ42Y@"2cR5GhfQ,m$+0,B(FZ(*qFCchdR[JG5Dl3[K98[0EFBhc6Jf!k'Hj$p
+
+R)(rUIIG)ebZT#lVHd,,'8%3DJQ5UfdlEP"@LKiU5A8P9!ff@U2hH-(@biF`FQ[(
+
+KV+6++NJeiI9JS(a#A@K@FPTGe,p@Pj4QR&)AdSc6kT,5M&2U3T15dqU5QT4mULl
+
+T5FPrl#eaeipXJ`L95k4YN!"fmDV'M(FlXp`hrMJpBDZc9%XlCB(Q0M6#dJJhdpT
+
+%2bZdFd30'KTT[d-6#2rA22prCQFCZHEjar[pNj2C69PYp)K@DM)V+8'fT!3C%RU
+
+0$!Sc%%F&0K8NII&jQb@NScQPp1@%DKc0DD4,rDbV-ccd@PV(lCAPY$H4%a*G2UI
+
+ARl'MdM)(c3+5MpDF8)f1Rr4*kNc)faB*9I4DMcVDlZfJPej1UXfAEck8RMde1"C
+
+Ci0@')p(QjN#S(A*Mr%a[J*8"E)T3G!%pL5YhHBl+"RVj4bhpa)5,Y@G#d)*M[FH
+
+rp@3IGap(N9*kF+TlbrUSQrlA5IIaD[aidXeYj&CVNMH83&CM+!&9RaC+%&Q"[`%
+
+!PM5C'9(,)ph(*fUTr9!YMqT9DV2iP&iGfErj4+r'r8D[mMkHFibb02iMPNjf1PA
+
+[d("$VLh(CI8d(p1LX&VN*cJbP(8k[pfF2kE#ZPqTX(51-%LC%ZXU[a22)[*i8[E
+
+rZJ[cIcUGL4G#pHMBk,e2kCF0VX,2PP#E5Iik[#T1$qmHrqXJc[6'Fa2`XLUETTM
+
+$*YV-$D3cYp12%m#qEb(qhJ$feL8eGE5PqJMF0!YqXU&'QZAY39+9b(8[r8`"-MX
+
+Ah$6![T!!ITF!pTb'bfV*EbNA&PMaKL[H#UA+i@kTX"!qGeH&C3R&EkCI&X"$k6d
+
+9PN9@f#m[VUY"R%+aB%N90%@4PhahPUZj([c3IkY-$A%eUr''+[Q8"m(LQS3[kcE
+
+1G+!PiF[1j8b6mBiYqG4I![EZK'rFji"Ab"55leDmdYV+9*,[$[MHa&2kj,XIH(K
+
+90KkIa-Ep'I$!Tj5(&h&2b4cN`,G2pSf$$kqZ5Vi*m(hh+pHLCV(B#pqMEAp*2`L
+
+K$S-ce482X[1!F4&mDd`jE#EL`-(e-DD6q,X(FCd12IXm1+#IdU#-2SFi1q)HB*d
+
+54KI`ANVie'C`8jVJFZTNa%85A%ip'ebqP1"bkZr$jj-acJ0'8-Di!,i@'@-Q-2E
+
+*q68KTiMXZ`ja[9RqCFj@hp%rG"RpQjINMlqNrpQ&-qA@"ki53rAP&2rr!!!0$3p
+
+YGbpRBh4PFh3Z0MK,,VN!N""453#3%#pd!!"+8`#3"2q3"%e08&*0680$!3#V,jH
+
+ZUc!jB!!!"M%!!"R%!!!"V3!!"E(*MaZS!*!'[VXM4!iL+Pj0j%)PIdhl9fbRBC!
+
+!DR1(JAFp3hUJ2KNcZ@(k&LeHlIYc*cMM1X2GRCf"!*`N(81C&iAQNTm4&Ifii1"
+
+EpGII4h6#PiP+'R-jb[e$&IeM12rA3hh-XBk+D2XK9#@U!P9e!@eRU22XRT!!%ar
+
+%6jaP3[FjFKhiIjQ@hidE$&25cAm$`-IrIXai*1U*jZd88q%pXX1%F$M`RNJbAQS
+
+ih%%N0J*@A""6p[pE#%1,cL9X%K8j[Z%i38$F)*'R%8!QpTQQT&06TCMf4amme9+
+
+jii[1iC(HE43E%aa#QlrCjZ4[GSL(8*!!e8D-E"#r6LR@&GN3aF6F'028K*cdTGk
+
+aT$fkUhhK6F,P(Tj11!CFTLJ+QQSXDINp,M$RL-+Cm9q6j"VK+Hr'rhrjXB16b1@
+
+iec&AC&Z,)bAP)A[QZNkT`brFF9bj0@L(b*(4H3)$i*YCbh9`YK90aj%$0a!Gm&!
+
+,de[B3!XlC'%$"-Eme,D0'(Z229-8DlB`9Q$FC!Y6@9L'KA%@PQm[")V0YM#PKBP
+
+$[mI#m!L#i#MfjAH50i4eE512Q3bj@@90I4m!N!--!'XcXfpJlh2Ij$4lRaZHF-P
+
+a`Tr-D)4&@%FjIAiV9hi5rZ3i@3NqRhV5`hI'm8m[3MNjENHi%AjN`!NMR"`rbB$
+
+bTrc)FA,m$%r*F51Fm*03FTa`FTa`-Q#%%hlN'4R`Pa`RA(+FF+mMamRa)mq2m$2
+
+#bB!#GjN8B'@Y6-+0iUpN*rl)-F)*2m)*8[#%!j-9H"9SN!!()1QkKK#+`Hm@K$S
+
+HJ&m,rN[#E`hmIJLEJ,q0bk)PQTCS@&q4J@q@4d"9U,FU)md-(0Yrf-'kLSC3Ech
+
+QTZ6PDfM!,6kXTJh48"8c3%-B$Af2ZR8CG9Ip2$-35k-p#&9[4Zd)$4`EE%%G46!
+
+,R0"9-23T99CN34j4,-#2%@HJ4P(6T'aDQa#N[iMDX5G2a3J5j8hqU`G8AI)J-HU
+
+[2pc+8DXTel3Q5K1DDDe`rC'MeMLS#5QV5"2QC-jFKV@(Y,XiDUf$'TI6Q941+fY
+
+NIrEXmabeMLSdTZC&6Ae8m48krm8h(,@HFXdUSU`BRMk!q[lRHBlD3,RQ4#QENT@
+
+#"cXRI2X+4ie6jif)dMfM+mkEUadrc9%E(G5'h+TKlGFqRHHS#3He,LFDrPe`h($
+
+QCBlDa(3e*P+'jG["RP9riDM0,PI9V"`8d09SikJYP'YH1C5kHVfHlZ'SDkKIpI4
+
+i+LIkaJ28)bpbe,88e9!N694cCG6ZNqFjkMUUN!"T6DE6ZT(h&AViKGmikRVU"NX
+
+TAdR(H9q1FY4@bY@D,XL9SfF2rY6286HiPp,*+'9G,aJIFG50p#Uce14Gj3Y'd81
+
+Ek"h5cFV&)blrQ+1f8B8b8UTJU&0#eN-9cVh+8GXGe*U-j!-kU)P6p4b9*UB'dj*
+
+PCDb-E#IIrF$K4qBkCkfIRK)eFi@ZrFEXr4ae-h@$T1I(e%`C&K,!AUi3T&L#1U`
+
+I'P&bCG3h(rRp#Fje+d8&50fBrKHeFp&j@4Q5M3GV$pea1eGSfk+(0$9pa80R1GF
+
+ZCkfce*a5FDbGI1mKMRSpifUSq482fFRj!BlD6Id+#UPkaDr(MfcMU0YGVSSeRLY
+
+8Z0V[F05H43q4)19lk0aM"lL(GMKViS"LkT1'T(MH+rPeTkZ3!*U"!([&H8FjkLl
+
++0@RS306mKfX[64ZJ+`31D"5@fGUaCaUiVRd8Y@!C+5NVP42Ef6h&a0E[S,D5e*Z
+
+k$e*4k[,4R"1qUq@S0cKV-k$Hk86c@fiEqT2V*rYSlLHcfePEppip1YM9Hl2Del9
+
+2!&`"@TQ,U#F1&[Z''jdelZ4b1(ZHmdimH"0(45eR)(&!*q9f)f6q6PCX0VTUBad
+
+IAd$pf!@`[ik1Br'KUlR)+fakrN"cHF(H36)2h%jb&H(+NrX0&jMF9VMIj$*$&L)
+
+T"p)0cLf`Yq1%"AXR6JQ`Yq'FKMf0GB,GdbRXPYLiZ+lq4#IBL8k`%jeJ*cV"6R5
+
+#RHJ%1p%*GU)6l%3Rf)P1h%qc#+[@Y15RS-eL8qhT&"fJcd&k4dVkK,dC'pb'AVi
+
+MRZjKXmB'HccD3(IrcJ8G(KYmfk)&p1R"5Hkrqa'fKQc`$Bdfm0&Ek'dF5*Cm&25
+
+6E"T+qQc(16M5i"iI4FpKHCCb3p#-XSR6I3[1YF$(e@dVrAm(hAhGA,f#1a4fVQ`
+
+D)a0bM1IcX19PNiJXd-QrQrjp$rTP0Nh4$ljDEE6C0*GdfSPEQNJ$[AaI"9dkQjE
+
+)"&rjZ5PSlpQXL6c)65I42'&jkHi((6HE659pGY(F%GhJrk#CBp-AQC!!QcfG`RF
+
+BE0C'2GbTm18(Qh@4"hI+cbI"'a-fkb-2I05,Qq*VI86`ZS90Dq6"IEUNPpZrZ6d
+
+IkmP@hp@`f9$5UmK,"LjZ2dGjKIdd'pTRSrf,Re6[[[HdcbYXX0R3aK[KcVI)#mr
+
+A-dm"R8jJFcLjAc2T0r!1Xr%Ph(NRKdhm"Y1PM9qd9#9(PFc#![X)[SNKr!e@jAm
+
+!N!-0$3pYGbpRBh4PFh3Z8&"$,VN!N"!4c!#3%%+&!*!)rj!%68e38Ne33d-"!+X
+
+[PkkV-$P&!!!'-3!!'Z!!!!'T!!!&bE5F%03!N!B"fL0%$L)UANhN3L9r6IYAE+G
+
+KN!"UFiH"Gce$HU!q'61jBIV#iB$[cjhJM1X-GhH'!`%ib6Q'-Lm+c58r)bVkFF(
+
+"YqU[[irS4$#9MENFjIkKL[iaR2rVS6lQ@%G&Y2d3UK*9JDUkJ,Bce(Pf6fJm&6R
+
+b2Z8HRJiXa'A+ir""h#2TreqK*11PKX-G4'@dI[MrP@fl(cXiL9b1Haec4BbeKmP
+
+aeJj"iNA$iL1d#Y1J+HR89#QQrG%86l98l[LLFhLNlhad)NaL2JK&0pZFr-d1m4!
+
++XYS)fcSm[diTeKAC%-A8h"M6e)5Fp+AHXD3p1ZNm1FY%rabj$[`E!$0bi`E$P26
+
+rG@!p"$aQr-JXH*CjLX,-Um9UPGj1-5VH)fY@`*(4VHaDSf,&r6CPrlq&--R1K6X
+
+*#r!9a`Q#"HZ@0$hdcLR&Z$Fm-LN%a%6I)NG'j`NF&EkCY9`(CaX9iFL4(fpK!IC
+
+B8#c-*P,XP1dG-@D4KE%@0XR#9"C'PcdhhF,ZXE"3#eYVB3-&a[CDHNU"FB-@YXI
+
+#PPJD!bcX5f0T(aH0)DaV'hR-C-M0+Q[Uq``!Da0l'f3fmMSr"jhCCQZ%N3NRNdf
+
+14LJRP"rPR[a@3Sqr%8D1NjAJmk5Hp2#G-Ic6Le"1MJm)Pachb(2###I(6c*J%8k
+
+j%8k1RiHRj,J46[K*+$P11$P11"P3`JNrmS`-q)!-Z'6!D6eKj2L4C`f-F$+J`(8
+
+Q"D$m9QE4e,T1r"&qK,q%%k6J#3FQ+c!qS%%HJ+LU#N)S",rE%'S`i2Fjq"D$ha,
+
+iI4qf+2P[K53BJQi)Q['&0I#IjBQL)Y4CP"42pjcUHm,'ZSf'8'HBF--Ck@qdLS0
+
+b3K-d'HXH'L*+S#ZS9C93Dp(hThY##E32SH*'Y!@KRP2p0@MV!TJ"6QM*DZUi,'%
+
+T+JeJ!r"$PM03TD!SBLUKM%E&Qd60d0-c)3Z*mVDqK3&9&I13!!6eTfr[iUM&P'Y
+
+#%F4446G@Z(l(88YXe)LB`Z+S2TE@Pf(0!mTp(,A84Uf3!",*H&STD'4qmZcc(,@
+
+-+M3XC`4&IJbl#Phql%Z1'UCF8eL3!,#@e`G3hrdd`e(,+GHd)+EL%XlQBDHLAlh
+
+-85ZSm`B%mB'K&HG0PBjFj+L90QTjHXf`jUXI6h28L)eDPKBdpblBE[Mm*BjDaA6
+
+94Z1DiGV"R*4rj+M9$PGCAcdSS+ZfQD2@8+iCI$4qqhSpdmj4DkPIeF4)2#fiaJ2
+
+8Bbpbe(889F1L)XMT!QVVKFXFYBiUT"YMLB5UC9b&(RhKCikkRVV"`)8VDEQKZf-
+
+V4kfRA)f*V,4kp-cqUedFGB0c+Hf-8Y$eQ[B"4pe)Vc*,6IQVI%eEm0!QHSG8IIA
+
+L@5lrN!#MEUCQhhrr8(p,Ec3@kie#4,V"pIbK)a`9-T!!GBlk-`E@KJ84,f%LG'i
+
+f[T!!!'KLUKNie$XiPM(N0&lQH[KU'dGYS"j+L['X*Sp(8hPGSl0R1'UMM9U5&&e
+
+!'c8b%qDSN!"L,3rTKL6Ki3+b'A[l2CZI0G[Y06`a,LMk#PhcpFQ(1'S6pDZSCSE
+
+PC!&fUR[r&Uj3-eASS(Td!+F,U1H1r2)8jpT#83&5e5EZS1kBGej+JZb9Kc82h(-
+
+h9kKehN1+R,MPS8ZFDjZpPPPABF@aCZbG`abeRA(9j-b+KmcBG!p(lD"q"B9NGG@
+
+[CimeFp5G$PGXM+5cUec0YcMUVRN2@9(2pG$Xii2F3jhf'KR%ZMUQL6M[[CaIGcX
+
++b8Q)f,HFGj+MGP'Z-8d&S[SrA2I32!5k3L5#cQ1CV4NkAXjer4pehS"JT*BMJmh
+
+eq+jHMVUAFXdD@Pa-LB8NHQRI3K)PI3p-0D6jHqhb!-,0lkJIrAq#kpTYIkZh1S$
+
+iJj!!%H0,"hSUqR8TjiTU6d$LH!3qd"l'QVp5(*Z0MQj%N5IR8$IK#2YVk#b4%AU
+
+KAhRjVG*[D*cA0T*HB1mJp`hf9R+*B@mR9a,f0R*MBGp1mJVX655"`0j)XK,X1mL
+
+pKlf"*+irG2*l,$B1E[#"6T2S$,#X@[56ejba+FlV&"bJcm2dMZ6dm6Xk0U4jAES
+
+MHGhp&Sp0DH#"lZkGmrT#0Q@"!rVX)TRXhr[K0j4X`S%(2RS$[3RXDKCpj(@KE-T
+
+cqZ`NL6E3i"kI4160319LE["D@$B9G'mQ#4Ai1,Ued1qGG(GeFr6blT!!hqqbU3a
+
+-b$&jRrZ0-TY)B)&1lYedll[ACE1T#Rl`e9TlcUBkTp0ZdVF%-H4Z[lGR8a1Bi#X
+
+h0hN["GM8"KlNTJYSfQ*jrHjlI6UE66PpZQMZ#'l`[pH@XGNEQ*!!Qr-kq@mqf+`
+
+,HVK6rLX60R@""hI+c5IHHaBfk`-2I,5(G,jrpK(H5aSfpB%(pqQkANlrj[4mV#G
+
+EHm2$CN01V`9H%R"aqMR+bhpj`iDqe%&p8bAIR!qTj%[4$kpFY(MK'lcmYcPXk&Z
+
+H1lcmlTi0lIT[mPVbJIFUL!elGjRM4BM8c8"+#$@"@kr%qK5GrJGH8d5JeDSp%6Z
+
+S`aY94TZmpLQ+$H(Nh"cl%r`RK-KrL#Vr!3#3!aq$!!!"!*!$!43!N!-8!*!$-Tr
+
+lRLe!rr#`!,K[$#eZd!6rm2rdd"lm`FAKdkSV8FY+$deKBe"bEfTPBh4c,R0TG!)
+
+!N!06594%8dP8)3#3"P0*9%46593K!*!BUc!jI3!!8M8!!!&'"1"2l'mDG@6JrHc
+
+K@5U#NI*HN@GK!Z"2kQ`FG&2UN!"S!!,L@5[48(adA`CdC!EJ6qj[8hJS!!EJEHl
+
+LEe5!)D$!FJC1ANl!*IrX51FI-#D`jL63G!*&0K!+1Li!&Ri!)VX-S"lbUKQJ(Z`
+
+3!+SDI!$!#3ZT8,aIE!!!Q$!'8!6"aG!!N!-3!#X!"3%B!J#3"`-!N!-"!*!$!43
+
+!N!-8!*!$-J$j(l!@#J#3!a`!-J!!8f9dC`#3!`S!!2rr!*!&q@G%'@B:
+
diff --git a/src/mzscheme/gc/Mac_files/MacOS_Test_config.h b/src/mzscheme/gc/Mac_files/MacOS_Test_config.h
new file mode 100644
index 0000000..94db03f
--- /dev/null
+++ b/src/mzscheme/gc/Mac_files/MacOS_Test_config.h
@@ -0,0 +1,88 @@
+/*
+	MacOS_Test_config.h
+	
+	Configuration flags for Macintosh development systems.
+	
+	Test version.
+	
+ 	<Revision History>
+
+ 	11/16/95  pcb  Updated compilation flags to reflect latest 4.6 Makefile.
+	
+	by Patrick C. Beard.
+ */
+/* Boehm, November 17, 1995 12:05 pm PST */
+
+#ifdef __MWERKS__
+#if defined(__powerc)
+#include <MacHeadersPPC>
+#else
+#include <MacHeaders68K>
+#endif
+#endif
+
+// these are defined again in gc_priv.h.
+#undef TRUE
+#undef FALSE
+
+#define ALL_INTERIOR_POINTERS	// follows interior pointers.
+//#define SILENT		// want collection messages.
+//#define DONT_ADD_BYTE_AT_END	// no padding.
+//#define SMALL_CONFIG		// whether to a smaller heap.
+#define NO_SIGNALS		// signals aren't real on the Macintosh.
+#define USE_TEMPORARY_MEMORY	// use Macintosh temporary memory.
+
+// CFLAGS= -O -DNO_SIGNALS -DALL_INTERIOR_POINTERS -DSILENT
+//
+//LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
+//    -DREDIRECT_MALLOC=GC_malloc_uncollectable \
+//    -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
+//   Flags for building libgc.a -- the last two are required.
+//
+// Setjmp_test may yield overly optimistic results when compiled
+// without optimization.
+// -DSILENT disables statistics printing, and improves performance.
+// -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
+//   altered stubborn objects, at substantial performance cost.
+//   Use only for incremental collector debugging.
+// -DFIND_LEAK causes the collector to assume that all inaccessible
+//   objects should have been explicitly deallocated, and reports exceptions.
+//   Finalization and the test program are not usable in this mode.
+// -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
+//   (Clients should also define SOLARIS_THREADS and then include
+//   gc.h before performing thr_ or GC_ operations.)
+//   This is broken on nonSPARC machines.
+// -DALL_INTERIOR_POINTERS allows all pointers to the interior
+//   of objects to be recognized.  (See gc_priv.h for consequences.)
+// -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+//   usually causing it to use less space in such situations.
+//   Incremental collection no longer works in this case.
+// -DLARGE_CONFIG tunes the collector for unusually large heaps.
+//   Necessary for heaps larger than about 500 MB on most machines.
+//   Recommended for heaps larger than about 64 MB.
+// -DDONT_ADD_BYTE_AT_END is meaningful only with
+//   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+//   causes all objects to be padded so that pointers just past the end of
+//   an object can be recognized.  This can be expensive.  (The padding
+//   is normally more than one byte due to alignment constraints.)
+//   -DDONT_ADD_BYTE_AT_END disables the padding.
+// -DNO_SIGNALS does not disable signals during critical parts of
+//   the GC process.  This is no less correct than many malloc 
+//   implementations, and it sometimes has a significant performance
+//   impact.  However, it is dangerous for many not-quite-ANSI C
+//   programs that call things like printf in asynchronous signal handlers.
+// -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
+//   new syntax "operator new[]" for allocating and deleting arrays.
+//   See gc_cpp.h for details.  No effect on the C part of the collector.
+//   This is defined implicitly in a few environments.
+// -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
+//   as aliases for X, GC_realloc, and GC_free, respectively.
+//   Calloc is redefined in terms of the new malloc.  X should
+//   be either GC_malloc or GC_malloc_uncollectable.
+//   The former is occasionally useful for working around leaks in code
+//   you don't want to (or can't) look at.  It may not work for
+//   existing code, but it often does.  Neither works on all platforms,
+//   since some ports use malloc or calloc to obtain system memory.
+//   (Probably works for UNIX, and win32.)
+// -DNO_DEBUG removes GC_dump and the debugging routines it calls.
+//   Reduces code size slightly at the expense of debuggability.
\ No newline at end of file
diff --git a/src/mzscheme/gc/Mac_files/MacOS_config.h b/src/mzscheme/gc/Mac_files/MacOS_config.h
new file mode 100644
index 0000000..838be59
--- /dev/null
+++ b/src/mzscheme/gc/Mac_files/MacOS_config.h
@@ -0,0 +1,86 @@
+/*
+	MacOS_config.h
+	
+	Configuration flags for Macintosh development systems.
+	
+ 	<Revision History>
+ 	
+ 	11/16/95  pcb  Updated compilation flags to reflect latest 4.6 Makefile.
+	
+	by Patrick C. Beard.
+ */
+/* Boehm, November 17, 1995 12:10 pm PST */
+
+#ifdef __MWERKS__
+#if defined(__powerc)
+#include <MacHeadersPPC>
+#else
+#include <MacHeaders68K>
+#endif
+#endif
+
+// these are defined again in gc_priv.h.
+#undef TRUE
+#undef FALSE
+
+#define ALL_INTERIOR_POINTERS	// follows interior pointers.
+#define SILENT			// no collection messages.
+//#define DONT_ADD_BYTE_AT_END	// no padding.
+//#define SMALL_CONFIG		// whether to use a smaller heap.
+#define NO_SIGNALS		// signals aren't real on the Macintosh.
+#define USE_TEMPORARY_MEMORY	// use Macintosh temporary memory.
+
+// CFLAGS= -O -DNO_SIGNALS -DSILENT -DALL_INTERIOR_POINTERS
+//
+//LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
+//    -DREDIRECT_MALLOC=GC_malloc_uncollectable \
+//    -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
+//   Flags for building libgc.a -- the last two are required.
+//
+// Setjmp_test may yield overly optimistic results when compiled
+// without optimization.
+// -DSILENT disables statistics printing, and improves performance.
+// -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
+//   altered stubborn objects, at substantial performance cost.
+//   Use only for incremental collector debugging.
+// -DFIND_LEAK causes the collector to assume that all inaccessible
+//   objects should have been explicitly deallocated, and reports exceptions.
+//   Finalization and the test program are not usable in this mode.
+// -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
+//   (Clients should also define SOLARIS_THREADS and then include
+//   gc.h before performing thr_ or GC_ operations.)
+//   This is broken on nonSPARC machines.
+// -DALL_INTERIOR_POINTERS allows all pointers to the interior
+//   of objects to be recognized.  (See gc_priv.h for consequences.)
+// -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+//   usually causing it to use less space in such situations.
+//   Incremental collection no longer works in this case.
+// -DLARGE_CONFIG tunes the collector for unusually large heaps.
+//   Necessary for heaps larger than about 500 MB on most machines.
+//   Recommended for heaps larger than about 64 MB.
+// -DDONT_ADD_BYTE_AT_END is meaningful only with
+//   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+//   causes all objects to be padded so that pointers just past the end of
+//   an object can be recognized.  This can be expensive.  (The padding
+//   is normally more than one byte due to alignment constraints.)
+//   -DDONT_ADD_BYTE_AT_END disables the padding.
+// -DNO_SIGNALS does not disable signals during critical parts of
+//   the GC process.  This is no less correct than many malloc 
+//   implementations, and it sometimes has a significant performance
+//   impact.  However, it is dangerous for many not-quite-ANSI C
+//   programs that call things like printf in asynchronous signal handlers.
+// -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
+//   new syntax "operator new[]" for allocating and deleting arrays.
+//   See gc_cpp.h for details.  No effect on the C part of the collector.
+//   This is defined implicitly in a few environments.
+// -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
+//   as aliases for X, GC_realloc, and GC_free, respectively.
+//   Calloc is redefined in terms of the new malloc.  X should
+//   be either GC_malloc or GC_malloc_uncollectable.
+//   The former is occasionally useful for working around leaks in code
+//   you don't want to (or can't) look at.  It may not work for
+//   existing code, but it often does.  Neither works on all platforms,
+//   since some ports use malloc or calloc to obtain system memory.
+//   (Probably works for UNIX, and win32.)
+// -DNO_DEBUG removes GC_dump and the debugging routines it calls.
+//   Reduces code size slightly at the expense of debuggability.
\ No newline at end of file
diff --git a/src/mzscheme/gc/Mac_files/dataend.c b/src/mzscheme/gc/Mac_files/dataend.c
new file mode 100644
index 0000000..a3e3fe8
--- /dev/null
+++ b/src/mzscheme/gc/Mac_files/dataend.c
@@ -0,0 +1,9 @@
+/*
+	dataend.c
+	
+	A hack to get the extent of global data for the Macintosh.
+	
+	by Patrick C. Beard.
+ */
+
+long __dataend;
diff --git a/src/mzscheme/gc/Mac_files/datastart.c b/src/mzscheme/gc/Mac_files/datastart.c
new file mode 100644
index 0000000..a9e0dd5
--- /dev/null
+++ b/src/mzscheme/gc/Mac_files/datastart.c
@@ -0,0 +1,9 @@
+/*
+	datastart.c
+	
+	A hack to get the extent of global data for the Macintosh.
+	
+	by Patrick C. Beard.
+ */
+
+long __datastart;
diff --git a/src/mzscheme/gc/Makefile b/src/mzscheme/gc/Makefile
new file mode 100644
index 0000000..c01d2fd
--- /dev/null
+++ b/src/mzscheme/gc/Makefile
@@ -0,0 +1,415 @@
+# MATTHEW: This makefile is modified from the original distribution
+#  for the following reasons:
+#    1) To support redirection of objects with OBJDIR
+#    2) To accept flags like CC passed on from other makefiles
+#    3) To use if_mach with a NOT flag instead of touching files
+#       and using if_not_there (doesn't really matter)
+#
+# Primary targets:
+# $(OBJDIR)/gc.a - builds basic library
+# $(OBJDIR)/libgc.a - builds library for use with g++ "-fgc-keyword" extension
+# c++ - adds C++ interface to library
+# cords - adds cords (heavyweight strings) to library
+# test - prints porting information, then builds basic version of $(OBJDIR)/gc.a,
+#      	 and runs some tests of collector and cords.  Does not add cords or
+#	 c++ interface to $(OBJDIR)/gc.a
+# cord/de - builds dumb editor based on cords.
+CC= gcc
+CXX = $(CC)
+AS=as
+
+OBJDIR = objects
+EXEDIR = $(OBJDIR)
+
+#  The above doesn't work with gas, which doesn't run cpp.
+#  Define AS as `gcc -c -x assembler-with-cpp' instead.
+#  Under Irix 6, you will have to specify the ABI for as if you specify
+#  it for the C compiler.
+
+# MATTHEW: setup flags to use inputs from wxWindows:
+
+# compiler options; mainly used to allow importing options
+OPTIONS=
+
+# Debugging, warnings, optimization
+DEBUGFLAGS=
+WARN= -Wall
+OPT= -O
+
+CFLAGS= -DNO_SIGNALS $(WARN) $(OPT) $(OPTIONS) $(DEBUGFLAGS) -DSILENT
+# Setjmp_test may yield overly optimistic results when compiled
+# without optimization.
+# -DSILENT disables statistics printing, and improves performance.
+# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
+#   altered stubborn objects, at substantial performance cost.
+#   Use only for incremental collector debugging.
+# -DFIND_LEAK causes the collector to assume that all inaccessible
+#   objects should have been explicitly deallocated, and reports exceptions.
+#   Finalization and the test program are not usable in this mode.
+# -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
+#   (Clients should also define SOLARIS_THREADS and then include
+#   gc.h before performing thr_ or dl* or GC_ operations.)
+#   This is broken on nonSPARC machines.
+# -DIRIX_THREADS enables support for Irix pthreads.  See README.irix.
+# -DALL_INTERIOR_POINTERS allows all pointers to the interior
+#   of objects to be recognized.  (See gc_priv.h for consequences.)
+# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+#   usually causing it to use less space in such situations.
+#   Incremental collection no longer works in this case.
+# -DLARGE_CONFIG tunes the collector for unusually large heaps.
+#   Necessary for heaps larger than about 500 MB on most machines.
+#   Recommended for heaps larger than about 64 MB.
+# -DDONT_ADD_BYTE_AT_END is meaningful only with
+#   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+#   causes all objects to be padded so that pointers just past the end of
+#   an object can be recognized.  This can be expensive.  (The padding
+#   is normally more than one byte due to alignment constraints.)
+#   -DDONT_ADD_BYTE_AT_END disables the padding.
+# -DNO_SIGNALS does not disable signals during critical parts of
+#   the GC process.  This is no less correct than many malloc 
+#   implementations, and it sometimes has a significant performance
+#   impact.  However, it is dangerous for many not-quite-ANSI C
+#   programs that call things like printf in asynchronous signal handlers.
+# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
+#   have execute permission, i.e. it may be impossible to execute
+#   code from the heap.  Currently this only affects the incremental
+#   collector on UNIX machines.  It may greatly improve its performance,
+#   since this may avoid some expensive cache synchronization.
+# -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
+#   new syntax "operator new[]" for allocating and deleting arrays.
+#   See gc_cpp.h for details.  No effect on the C part of the collector.
+#   This is defined implicitly in a few environments.
+# -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
+#   as aliases for X, GC_realloc, and GC_free, respectively.
+#   Calloc is redefined in terms of the new malloc.  X should
+#   be either GC_malloc or GC_malloc_uncollectable.
+#   The former is occasionally useful for working around leaks in code
+#   you don't want to (or can't) look at.  It may not work for
+#   existing code, but it often does.  Neither works on all platforms,
+#   since some ports use malloc or calloc to obtain system memory.
+#   (Probably works for UNIX, and win32.)
+# -DIGNORE_FREE turns calls to free into a noop.  Only useful with
+#   -DREDIRECT_MALLOC.
+# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
+#   Reduces code size slightly at the expense of debuggability.
+# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
+#   order by specifying a nonstandard finalization mark procedure  (see
+#   finalize.c).  Objects reachable from finalizable objects will be marked
+#   in a sepearte postpass, and hence their memory won't be reclaimed.
+#   Not recommended unless you are implementing a language that specifies
+#   these semantics.
+# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
+#   This is useful if either the vendor malloc implementation is poor,
+#   or if REDIRECT_MALLOC is used.
+
+LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
+    -DREDIRECT_MALLOC=GC_malloc_uncollectable \
+    -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
+#   Flags for building $(OBJDIR)/libgc.a -- the last two are required.
+
+CXXFLAGS= $(CFLAGS) 
+AR= ar
+RANLIB= ranlib
+
+
+# Redefining srcdir allows object code for the nonPCR version of the collector
+# to be generated in different directories.  In this case, the destination directory
+# should contain a copy of the original include directory.
+srcdir = .
+VPATH = $(srcdir)
+
+OBJS= $(OBJDIR)/alloc.o $(OBJDIR)/reclaim.o $(OBJDIR)/allchblk.o $(OBJDIR)/misc.o $(OBJDIR)/mach_dep.o $(OBJDIR)/os_dep.o $(OBJDIR)/mark_rts.o $(OBJDIR)/headers.o $(OBJDIR)/mark.o $(OBJDIR)/obj_map.o $(OBJDIR)/blacklst.o $(OBJDIR)/finalize.o $(OBJDIR)/new_hblk.o $(OBJDIR)/dbg_mlc.o $(OBJDIR)/malloc.o $(OBJDIR)/stubborn.o $(OBJDIR)/checksums.o $(OBJDIR)/solaris_threads.o $(OBJDIR)/irix_threads.o $(OBJDIR)/typd_mlc.o $(OBJDIR)/ptr_chck.o $(OBJDIR)/mallocx.o
+
+CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c irix_threads.c typd_mlc.c ptr_chck.c mallocx.c
+
+CORD_SRCS=  cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c cord/cord.h cord/ec.h cord/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC cord/$(OBJDIR)/SCOPTIONS.amiga cord/$(OBJDIR)/SMakefile.amiga
+
+CORD_OBJS=  cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o cord/$(OBJDIR)/cordprnt.o
+
+SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.s \
+    sparc_mach_dep.s gc.h gc_typed.h gc_hdrs.h gc_priv.h gc_private.h \
+    config.h gc_mark.h include/gc_inl.h include/gc_inline.h gc.man \
+    threadlibs.c if_mach.c if_not_there.c gc_cpp.cc gc_cpp.h weakpointer.h \
+    gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h gc_alloc.h \
+    $(CORD_SRCS)
+
+OTHER_FILES= Makefile PCR-Makefile OS2_MAKEFILE NT_MAKEFILE BCC_MAKEFILE \
+           README test.c test_cpp.cc setjmp_t.c SMakefile.amiga \
+           SCoptions.amiga README.amiga README.win32 cord/README \
+           cord/gc.h include/gc.h include/gc_typed.h include/cord.h \
+           include/ec.h include/private/cord_pos.h include/private/config.h \
+           include/private/gc_hdrs.h include/private/gc_priv.h \
+	   include/gc_cpp.h README.rs6000 \
+           include/weakpointer.h README.QUICK callprocs pc_excludes \
+           barrett_diagram README.OS2 README.Mac MacProjects.sit.hqx \
+           MacOS.c EMX_MAKEFILE makefile.depend README.debugging \
+           include/gc_cpp.h Mac_files/datastart.c Mac_files/dataend.c \
+           Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
+           add_gc_prefix.c README.solaris2 README.sgi README.hp README.uts \
+           win32_threads.c NT_THREADS_MAKEFILE gc.mak README.dj Makefile.dj
+
+CORD_INCLUDE_FILES= $(srcdir)/gc.h $(srcdir)/cord/cord.h $(srcdir)/cord/ec.h \
+           $(srcdir)/cord/private/cord_pos.h
+
+UTILS= $(EXEDIR)/if_mach $(EXEDIR)/if_not_there $(EXEDIR)/threadlibs
+
+# Libraries needed for curses applications.  Only needed for de.
+CURSES= -lcurses -ltermlib
+
+# The following is irrelevant on most systems.  But a few
+# versions of make otherwise fork the shell specified in
+# the SHELL environment variable.
+SHELL= /bin/sh
+
+SPECIALCFLAGS = 
+# Alternative flags to the C compiler for mach_dep.c.
+# Mach_dep.c often doesn't like optimization, and it's
+# not time-critical anyway.
+# Set SPECIALCFLAGS to -q nodirect_code on Encore.
+
+all: $(OBJDIR)/gc.a # gctest # MATTHEW: remove gctest
+
+pcr: PCR-Makefile gc_private.h gc_hdrs.h gc.h config.h $(OBJDIR)/mach_dep.o $(SRCS)
+	make -f PCR-Makefile depend
+	make -f PCR-Makefile
+
+$(OBJS) $(OBJDIR)/test.o $(OBJDIR)/dyn_load.o $(OBJDIR)/dyn_load_sunos53.o: \
+    $(srcdir)/gc_priv.h $(srcdir)/gc_hdrs.h $(srcdir)/gc.h \
+    $(srcdir)/config.h $(srcdir)/gc_typed.h 
+# The dependency on Makefile is needed.  Changing
+# options such as -DSILENT affects the size of GC_arrays,
+# invalidating all .o files that rely on gc_priv.h
+
+$(OBJDIR)/mark.o $(OBJDIR)/typd_mlc.o $(OBJDIR)/finalize.o: $(srcdir)/gc_mark.h
+
+$(OBJDIR)/gc.a: $(OBJS) $(OBJDIR)/dyn_load.o $(UTILS)
+	./$(EXEDIR)/if_mach SPARC SUNOS5 $(AR) rus $(OBJDIR)/gc.a $(OBJS) $(OBJDIR)/dyn_load.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(AR) ru $(OBJDIR)/gc.a $(OBJS) $(OBJDIR)/dyn_load.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(RANLIB) $(OBJDIR)/gc.a || cat /dev/null
+#	ignore ranlib failure; that usually means it doesn't exist, and isn't needed
+
+$(OBJDIR)/libgc.a: 
+	make CFLAGS="$(LIBGC_CFLAGS)" clean $(OBJDIR)/gc.a $(OBJDIR)/gcc_support.o
+	mv $(OBJDIR)/gc.a $(OBJDIR)/libgc.a
+	./$(EXEDIR)/if_mach SPARC SUNOS5 $(AR) rus $(OBJDIR)/libgc.a $(OBJDIR)/gcc_support.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(AR) ru $(OBJDIR)/libgc.a $(OBJDIR)/gcc_support.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(RANLIB) $(OBJDIR)/libgc.a || cat /dev/null
+
+cords: $(CORD_OBJS) cord/cordtest $(UTILS)
+	./$(EXEDIR)/if_mach SPARC SUNOS5 $(AR) rus $(OBJDIR)/gc.a $(CORD_OBJS)
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(AR) ru $(OBJDIR)/gc.a $(CORD_OBJS)
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(RANLIB) $(OBJDIR)/gc.a || cat /dev/null
+
+$(OBJDIR)/gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/gc_cpp.h $(srcdir)/gc.h Makefile
+	$(CXX) -c $(CXXFLAGS) -o $(OBJDIR)/gc_cpp.o $(srcdir)/gc_cpp.cc
+
+test_cpp: $(srcdir)/test_cpp.cc $(srcdir)/gc_cpp.h $(OBJDIR)/gc_cpp.o $(srcdir)/gc.h $(OBJDIR)/gc.a $(UTILS)
+	rm -f test_cpp
+	./$(EXEDIR)/if_mach HP_PA "" $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/test_cpp.cc $(OBJDIR)/gc_cpp.o $(OBJDIR)/gc.a -ldld
+	./$(EXEDIR)/if_not_there test_cpp $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/test_cpp.cc $(OBJDIR)/gc_cpp.o $(OBJDIR)/gc.a `./$(EXEDIR)/threadlibs`
+
+c++: $(OBJDIR)/gc_cpp.o $(srcdir)/gc_cpp.h # test_cpp # MATTHEW: remove test_cpp
+	./$(EXEDIR)/if_mach SPARC SUNOS5 $(AR) rus $(OBJDIR)/gc.a $(OBJDIR)/gc_cpp.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(AR) ru $(OBJDIR)/gc.a $(OBJDIR)/gc_cpp.o
+	./$(EXEDIR)/if_mach SPARC SUNOS5 NOT $(RANLIB) $(OBJDIR)/gc.a || cat /dev/null
+	# MATTHEW: remove
+	# ./$(EXEDIR)/test_cpp 1
+
+$(OBJDIR)/dyn_load_sunos53.o: dyn_load.c
+	$(CC) $(CFLAGS) -DSUNOS53_SHARED_LIB -c $(srcdir)/dyn_load.c -o $@
+
+# SunOS5 shared library version of the collector
+libgc.so: $(OBJS) $(OBJDIR)/dyn_load_sunos53.o
+	$(CC) -G -o libgc.so $(OBJS) $(OBJDIR)/dyn_load_sunos53.o -ldl
+
+# Alpha/OSF shared library version of the collector
+libalphagc.so: $(OBJS)
+	ld -shared -o libalphagc.so $(OBJS) $(OBJDIR)/dyn_load.o -lc
+
+# IRIX shared library version of the collector
+libirixgc.so: $(OBJS) $(OBJDIR)/dyn_load.o
+	ld -shared -o libirixgc.so $(OBJS) $(OBJDIR)/dyn_load.o -lc
+
+$(OBJDIR)/mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s $(srcdir)/mips_ultrix_mach_dep.s $(srcdir)/rs6000_mach_dep.s $(UTILS)
+	rm -f $(OBJDIR)/mach_dep.o
+	./$(EXEDIR)/if_mach MIPS IRIX5 $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/mips_sgi_mach_dep.s
+	./$(EXEDIR)/if_mach MIPS RISCOS $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
+	./$(EXEDIR)/if_mach MIPS ULTRIX $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
+# MATTHEW: I can't get the assembler to work; using generic
+# ./$(EXEDIR)/if_mach RS6000 "" $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/rs6000_mach_dep.s
+	./$(EXEDIR)/if_mach ALPHA "" $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/alpha_mach_dep.s
+	./$(EXEDIR)/if_mach SPARC SUNOS5 $(AS) -o $(OBJDIR)/mach_dep.o $(srcdir)/sparc_mach_dep.s
+	./$(EXEDIR)/if_not_there $(OBJDIR)/mach_dep.o $(CC) -c $(SPECIALCFLAGS) -o $(OBJDIR)/mach_dep.o $(srcdir)/mach_dep.c
+
+$(OBJDIR)/mark_rts.o: $(srcdir)/mark_rts.c $(UTILS)
+	rm -f $(OBJDIR)/mark_rts.o
+	-./$(EXEDIR)/if_mach ALPHA OSF1 $(CC) -c $(CFLAGS) -Wo,-notail $(srcdir)/mark_rts.c
+	./$(EXEDIR)/if_not_there $(OBJDIR)/mark_rts.o $(CC) -c $(CFLAGS) -o $(OBJDIR)/mark_rts.o $(srcdir)/mark_rts.c
+#	Work-around for DEC optimizer tail recursion elimination bug.
+#  The ALPHA-specific line should be removed if gcc is used.
+
+cord/$(OBJDIR)/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordbscs.c
+	mv $(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordbscs.o
+#  not all compilers understand -o filename
+
+cord/$(OBJDIR)/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordxtra.c
+	mv $(OBJDIR)/cordxtra.o cord/$(OBJDIR)/cordxtra.o
+
+cord/$(OBJDIR)/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordprnt.c
+	mv $(OBJDIR)/cordprnt.o cord/$(OBJDIR)/cordprnt.o
+
+cord/cordtest: $(srcdir)/cord/cordtest.c $(CORD_OBJS) $(OBJDIR)/gc.a $(UTILS)
+	rm -f cord/cordtest
+	./$(EXEDIR)/if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) $(OBJDIR)/gc.a -lucb
+	./$(EXEDIR)/if_mach HP_PA "" $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) $(OBJDIR)/gc.a -ldld
+	./$(EXEDIR)/if_not_there cord/cordtest $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) $(OBJDIR)/gc.a `./$(EXEDIR)/threadlibs`
+
+cord/de: $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a $(UTILS)
+	rm -f cord/de
+	./$(EXEDIR)/if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a $(CURSES) -lucb
+	./$(EXEDIR)/if_mach HP_PA "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a $(CURSES) -ldld
+	./$(EXEDIR)/if_mach RS6000 "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a -lcurses
+	./$(EXEDIR)/if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a -lcurses
+	./$(EXEDIR)/if_mach ALPHA LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a -lcurses
+	./$(EXEDIR)/if_not_there cord/de $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/$(OBJDIR)/cordbscs.o cord/$(OBJDIR)/cordxtra.o $(OBJDIR)/gc.a $(CURSES) `./$(EXEDIR)/threadlibs`
+
+$(EXEDIR)/if_mach: $(srcdir)/if_mach.c $(srcdir)/config.h
+	$(CC) $(CFLAGS) -o $(EXEDIR)/if_mach $(srcdir)/if_mach.c
+
+$(EXEDIR)/if_not_there: $(srcdir)/if_not_there.c
+	$(CC) $(CFLAGS) -o $(EXEDIR)/if_not_there $(srcdir)/if_not_there.c
+
+$(EXEDIR)/threadlibs: $(srcdir)/threadlibs.c $(srcdir)/config.h Makefile
+	$(CC) $(CFLAGS) -o $(EXEDIR)/threadlibs $(srcdir)/threadlibs.c
+
+clean: 
+	rm -f objects/*/* gctest gctest_dyn_link test_cpp \
+	      setjmp_test  $(OBJDIR)/mon.out $(OBJDIR)/gmon.out $(OBJDIR)/a.out \
+              core $(EXEDIR)/if_not_there $(EXEDIR)/if_mach $(EXEDIR)/threadlibs \
+	      $(CORD_OBJS) cord/cordtest cord/de
+	-rm -f *~
+
+gctest: $(OBJDIR)/test.o $(OBJDIR)/gc.a $(UTILS)
+	rm -f gctest
+	./$(EXEDIR)/if_mach SPARC DRSNX $(CC) $(CFLAGS) -o gctest  $(OBJDIR)/test.o $(OBJDIR)/gc.a -lucb
+	./$(EXEDIR)/if_mach HP_PA "" $(CC) $(CFLAGS) -o gctest  $(OBJDIR)/test.o $(OBJDIR)/gc.a -ldld
+	./$(EXEDIR)/if_not_there gctest $(CC) $(CFLAGS) -o gctest $(OBJDIR)/test.o $(OBJDIR)/gc.a `./$(EXEDIR)/threadlibs`
+
+# If an optimized setjmp_test generates a segmentation fault,
+# odds are your compiler is broken.  Gctest may still work.
+# Try compiling setjmp_t.c unoptimized.
+setjmp_test: $(srcdir)/setjmp_t.c $(srcdir)/gc.h $(EXEDIR)/if_mach $(EXEDIR)/if_not_there
+	$(CC) $(CFLAGS) -o setjmp_test $(srcdir)/setjmp_t.c
+
+test:  KandRtest cord/cordtest
+	cord/cordtest
+
+# Those tests that work even with a K&R C compiler:
+KandRtest: setjmp_test gctest
+	./$(EXEDIR)/setjmp_test
+	./$(EXEDIR)/gctest
+
+add_gc_prefix: add_gc_prefix.c
+	$(CC) -o add_gc_prefix $(srcdir)/add_gc_prefix.c
+
+gc.tar: $(SRCS) $(OTHER_FILES) add_gc_prefix
+	./add_gc_prefix $(SRCS) $(OTHER_FILES) > /tmp/gc.tar-files
+	(cd $(srcdir)/.. ; tar cvfh - `cat /tmp/gc.tar-files`) > gc.tar
+
+pc_gc.tar: $(SRCS) $(OTHER_FILES)
+	tar cvfX pc_gc.tar pc_excludes $(SRCS) $(OTHER_FILES)
+
+floppy: pc_gc.tar
+	-mmd a:/cord
+	-mmd a:/cord/private
+	-mmd a:/include
+	-mmd a:/include/private
+	mkdir /tmp/pc_gc
+	cat pc_gc.tar | (cd /tmp/pc_gc; tar xvf -)
+	-mcopy -tmn /tmp/pc_gc/* a:
+	-mcopy -tmn /tmp/pc_gc/cord/* a:/cord
+	-mcopy -mn /tmp/pc_gc/cord/de_win.ICO a:/cord
+	-mcopy -tmn /tmp/pc_gc/cord/private/* a:/cord/private
+	-mcopy -tmn /tmp/pc_gc/include/* a:/include
+	-mcopy -tmn /tmp/pc_gc/include/private/* a:/include/private
+	rm -r /tmp/pc_gc
+
+gc.tar.Z: gc.tar
+	compress gc.tar
+
+gc.tar.gz: gc.tar
+	gzip gc.tar
+
+lint: $(CSRCS) test.c
+	lint -DLINT $(CSRCS) test.c | egrep -v "possible pointer alignment problem|abort|exit|sbrk|mprotect|syscall"
+
+# BTL: added to test shared library version of collector.
+# Currently works only under SunOS5.  Requires GC_INIT call from statically
+# loaded client code.
+ABSDIR = `pwd`
+gctest_dyn_link: $(OBJDIR)/test.o libgc.so
+	$(CC) -L$(ABSDIR) -R$(ABSDIR) -o gctest_dyn_link $(OBJDIR)/test.o -lgc -ldl -lthread
+
+gctest_irix_dyn_link: $(OBJDIR)/test.o libirixgc.so
+	$(CC) -L$(ABSDIR) -o gctest_irix_dyn_link $(OBJDIR)/test.o -lirixgc
+
+reserved_namespace: $(SRCS)
+	for file in $(SRCS) test.c test_cpp.cc; do \
+		sed s/GC_/_GC_/g < $$file > tmp; \
+		cp tmp $$file; \
+		done
+
+user_namespace: $(SRCS)
+	for file in $(SRCS) test.c test_cpp.cc; do \
+		sed s/_GC_/GC_/g < $$file > tmp; \
+		cp tmp $$file; \
+		done
+
+$(OBJDIR)/alloc.o: alloc.c
+	$(CC) $(CFLAGS) -c alloc.c -o $(OBJDIR)/alloc.o
+$(OBJDIR)/reclaim.o: reclaim.c
+	$(CC) $(CFLAGS) -c reclaim.c -o $(OBJDIR)/reclaim.o
+$(OBJDIR)/allchblk.o: allchblk.c
+	$(CC) $(CFLAGS) -c allchblk.c -o $(OBJDIR)/allchblk.o
+$(OBJDIR)/misc.o: misc.c
+	$(CC) $(CFLAGS) -c misc.c -o $(OBJDIR)/misc.o
+$(OBJDIR)/os_dep.o: os_dep.c
+	$(CC) $(CFLAGS) -c os_dep.c -o $(OBJDIR)/os_dep.o
+$(OBJDIR)/headers.o: headers.c
+	$(CC) $(CFLAGS) -c headers.c -o $(OBJDIR)/headers.o
+$(OBJDIR)/mark.o: mark.c
+	$(CC) $(CFLAGS) -c mark.c -o $(OBJDIR)/mark.o
+$(OBJDIR)/obj_map.o: obj_map.c
+	$(CC) $(CFLAGS) -c obj_map.c -o $(OBJDIR)/obj_map.o
+$(OBJDIR)/blacklst.o: blacklst.c
+	$(CC) $(CFLAGS) -c blacklst.c -o $(OBJDIR)/blacklst.o
+$(OBJDIR)/finalize.o: finalize.c
+	$(CC) $(CFLAGS) -c finalize.c -o $(OBJDIR)/finalize.o
+$(OBJDIR)/new_hblk.o: new_hblk.c
+	$(CC) $(CFLAGS) -c new_hblk.c -o $(OBJDIR)/new_hblk.o
+$(OBJDIR)/dbg_mlc.o: dbg_mlc.c
+	$(CC) $(CFLAGS) -c dbg_mlc.c -o $(OBJDIR)/dbg_mlc.o
+$(OBJDIR)/malloc.o: malloc.c
+	$(CC) $(CFLAGS) -c malloc.c -o $(OBJDIR)/malloc.o
+$(OBJDIR)/stubborn.o: stubborn.c
+	$(CC) $(CFLAGS) -c stubborn.c -o $(OBJDIR)/stubborn.o
+$(OBJDIR)/checksums.o: checksums.c
+	$(CC) $(CFLAGS) -c checksums.c -o $(OBJDIR)/checksums.o
+$(OBJDIR)/solaris_threads.o: solaris_threads.c
+	$(CC) $(CFLAGS) -c solaris_threads.c -o $(OBJDIR)/solaris_threads.o
+$(OBJDIR)/irix_threads.o: irix_threads.c
+	$(CC) $(CFLAGS) -c irix_threads.c -o $(OBJDIR)/irix_threads.o
+$(OBJDIR)/typd_mlc.o: typd_mlc.c
+	$(CC) $(CFLAGS) -c typd_mlc.c -o $(OBJDIR)/typd_mlc.o
+$(OBJDIR)/ptr_chck.o: ptr_chck.c
+	$(CC) $(CFLAGS) -c ptr_chck.c -o $(OBJDIR)/ptr_chck.o
+$(OBJDIR)/dyn_load.o: dyn_load.c
+	$(CC) $(CFLAGS) -c dyn_load.c -o $(OBJDIR)/dyn_load.o
+$(OBJDIR)/mallocx.o: mallocx.c
+	$(CC) $(CFLAGS) -c mallocx.c -o $(OBJDIR)/mallocx.o
+
+$(OBJDIR)/test.o: test.c
+	$(CC) $(CFLAGS) -c test.c -o $(OBJDIR)/test.o
diff --git a/src/mzscheme/gc/Makefile.dj b/src/mzscheme/gc/Makefile.dj
new file mode 100644
index 0000000..965d314
--- /dev/null
+++ b/src/mzscheme/gc/Makefile.dj
@@ -0,0 +1,215 @@
+# Primary targets:
+# gc.a - builds basic library
+# libgc.a - builds library for use with g++ "-fgc-keyword" extension
+# c++ - adds C++ interface to library
+# cords - adds cords (heavyweight strings) to library
+# test - prints porting information, then builds basic version of gc.a,
+#      	 and runs some tests of collector and cords.  Does not add cords or
+#	 c++ interface to gc.a
+# cord/de - builds dumb editor based on cords.
+CC=gcc
+CXX=gxx
+
+CFLAGS= -O -DNO_SIGNALS -DALL_INTERIOR_POINTERS -DSILENT
+
+# Setjmp_test may yield overly optimistic results when compiled
+# without optimization.
+# -DSILENT disables statistics printing, and improves performance.
+# -DFIND_LEAK causes the collector to assume that all inaccessible
+#   objects should have been explicitly deallocated, and reports exceptions.
+#   Finalization and the test program are not usable in this mode.
+# -DALL_INTERIOR_POINTERS allows all pointers to the interior
+#   of objects to be recognized.  (See gc_priv.h for consequences.)
+# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
+#   usually causing it to use less space in such situations.
+#   Incremental collection no longer works in this case.
+# -DLARGE_CONFIG tunes the collector for unusually large heaps.
+#   Necessary for heaps larger than about 500 MB on most machines.
+#   Recommended for heaps larger than about 64 MB.
+# -DDONT_ADD_BYTE_AT_END is meaningful only with
+#   -DALL_INTERIOR_POINTERS.  Normally -DALL_INTERIOR_POINTERS
+#   causes all objects to be padded so that pointers just past the end of
+#   an object can be recognized.  This can be expensive.  (The padding
+#   is normally more than one byte due to alignment constraints.)
+#   -DDONT_ADD_BYTE_AT_END disables the padding.
+# -DNO_SIGNALS does not disable signals during critical parts of
+#   the GC process.  This is no less correct than many malloc
+#   implementations, and it sometimes has a significant performance
+#   impact.  However, it is dangerous for many not-quite-ANSI C
+#   programs that call things like printf in asynchronous signal handlers.
+# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
+#   have execute permission, i.e. it may be impossible to execute
+#   code from the heap.  Currently this only affects the incremental
+#   collector on UNIX machines.  It may greatly improve its performance,
+#   since this may avoid some expensive cache synchronization.
+# -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
+#   new syntax "operator new[]" for allocating and deleting arrays.
+#   See gc_cpp.h for details.  No effect on the C part of the collector.
+#   This is defined implicitly in a few environments.
+# -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
+#   as aliases for X, GC_realloc, and GC_free, respectively.
+#   Calloc is redefined in terms of the new malloc.  X should
+#   be either GC_malloc or GC_malloc_uncollectable.
+#   The former is occasionally useful for working around leaks in code
+#   you don't want to (or can't) look at.  It may not work for
+#   existing code, but it often does.  Neither works on all platforms,
+#   since some ports use malloc or calloc to obtain system memory.
+#   (Probably works for UNIX, and win32.)
+# -DIGNORE_FREE turns calls to free into a noop.  Only useful with
+#   -DREDIRECT_MALLOC.
+# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
+#   Reduces code size slightly at the expense of debuggability.
+
+LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
+    -DREDIRECT_MALLOC=GC_malloc_uncollectable \
+    -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
+#   Flags for building libgc.a -- the last two are required.
+
+CXXFLAGS= $(CFLAGS) -DOPERATOR_NEW_ARRAY
+AR= ar
+RANLIB= ranlib
+
+
+# Redefining srcdir allows object code for the nonPCR version of the collector
+# to be generated in different directories.  In this case, the destination
+directory
+# should contain a copy of the original include directory.
+srcdir = .
+VPATH = $(srcdir)
+
+OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o \
+headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o\
+stubborn.o typd_mlc.o ptr_chck.o mallocx.o
+
+CORD_OBJS=  cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
+
+CORD_INCLUDE_FILES= $(srcdir)/gc.h $(srcdir)/cord/cord.h $(srcdir)/cord/ec.h \
+           $(srcdir)/cord/private/cord_pos.h
+
+# Libraries needed for curses applications.  Only needed for de.
+CURSES= -lcurses -ltermlib
+
+# The following is irrelevant on most systems.  But a few
+# versions of make otherwise fork the shell specified in
+# the SHELL environment variable.
+SHELL= /bin/sh
+
+SPECIALCFLAGS =
+# Alternative flags to the C compiler for mach_dep.c.
+# Mach_dep.c often doesn't like optimization, and it's
+# not time-critical anyway.
+# Set SPECIALCFLAGS to -q nodirect_code on Encore.
+
+all: gc.a gctest
+
+$(OBJS) test.o dyn_load.o dyn_load_sunos53.o: $(srcdir)/gc_priv.h \
+ $(srcdir)/gc_hdrs.h $(srcdir)/gc.h \
+    $(srcdir)/config.h $(srcdir)/gc_typed.h Makefile
+# The dependency on Makefile is needed.  Changing
+# options such as -DSILENT affects the size of GC_arrays,
+# invalidating all .o files that rely on gc_priv.h
+
+mark.o typd_mlc.o finalize.o: $(srcdir)/gc_mark.h
+
+gc.a: $(OBJS) dyn_load.o
+	$(AR) ru gc.a $(OBJS) dyn_load.o
+	$(RANLIB) gc.a
+
+libgc.a:
+	make CFLAGS="$(LIBGC_CFLAGS)" clean gc.a gcc_support.o
+	move gc.a libgc.a
+	-del on_sparc_sunos5
+	./if_mach SPARC SUNOS5 touch on_sparc_sunos5
+	./if_mach SPARC SUNOS5 $(AR) rus libgc.a gcc_support.o
+	./if_not_there on_sparc_sunos5 $(AR) ru libgc.a gcc_support.o
+	./if_not_there on_sparc_sunos5 $(RANLIB) libgc.a || cat /dev/null
+
+cords: $(CORD_OBJS) cord/cordtest
+	-del on_sparc_sunos5
+	./if_mach SPARC SUNOS5 touch on_sparc_sunos5
+	./if_mach SPARC SUNOS5 $(AR) rus gc.a $(CORD_OBJS)
+	./if_not_there on_sparc_sunos5 $(AR) ru gc.a $(CORD_OBJS)
+	./if_not_there on_sparc_sunos5 $(RANLIB) gc.a || cat /dev/null
+
+gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/gc_cpp.h $(srcdir)/gc.h Makefile
+	$(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc
+
+test_cpp: $(srcdir)/test_cpp.cc $(srcdir)/gc_cpp.h gc_cpp.o $(srcdir)/gc.h gc.a
+	-del test_cpp
+	$(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/test_cpp.cc gc_cpp.o gc.a
+
+
+c++: gc_cpp.o $(srcdir)/gc_cpp.h test_cpp
+	-del on_sparc_sunos5
+	$(AR) ru gc.a gc_cpp.o
+	$(RANLIB) gc.a
+	./test_cpp 1
+
+mach_dep.o: $(srcdir)/mach_dep.c
+# $(srcdir)/mips_mach_dep.s $(srcdir)/rs6000_mach_dep.s if_mach if_not_there
+	-del mach_dep.o
+	$(CC) -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
+
+mark_rts.o: $(srcdir)/mark_rts.c
+	-del mark_rts.o
+	$(CC) -c $(CFLAGS) $(srcdir)/mark_rts.c
+
+cord/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordbscs.c
+	move cordbscs.o cord/cordbscs.o
+#  not all compilers understand -o filename
+
+cord/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordxtra.c
+	move cordxtra.o cord/cordxtra.o
+
+cord/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
+	$(CC) $(CFLAGS) -c $(srcdir)/cord/cordprnt.c
+	move cordprnt.o cord/cordprnt.o
+
+cord/cordtest: $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
+	-del cord/cordtest
+	$(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c\
+		 $(CORD_OBJS) gc.a
+
+cord/de: $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a
+	-del cord/de
+	./if_mach SPARC SUNOS5 $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lthread -ldl
+	./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lucb
+	./if_mach HP_PA "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -ldld
+	./if_mach RS6000 "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
+	./if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
+	./if_not_there cord/de $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c\
+cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES)
+
+clean:
+	-del gc.a *.o gctest gctest_dyn_link test_cpp \
+	      setjmp_test  mon.out gmon.out a.out core if_not_there if_mach \
+	      $(CORD_OBJS) cord/cordtest cord/de
+	-del *~
+
+gctest: test.o gc.a
+	-del gctest
+	$(CC) $(CFLAGS) -o gctest test.o gc.a
+
+# If an optimized setjmp_test generates a segmentation fault,
+# odds are your compiler is broken.  Gctest may still work.
+# Try compiling setjmp_t.c unoptimized.
+setjmp_test: $(srcdir)/setjmp_t.c $(srcdir)/gc.h
+	$(CC) $(CFLAGS) -o setjmp_test $(srcdir)/setjmp_t.c
+
+test:  KandRtest cord/cordtest
+	cord/cordtest
+
+# Those tests that work even with a K&R C compiler:
+KandRtest: setjmp_test gctest
+	./setjmp_test
+	./gctest
+
+
+
diff --git a/src/mzscheme/gc/NT_MAKEFILE b/src/mzscheme/gc/NT_MAKEFILE
new file mode 100644
index 0000000..52f6f4a
--- /dev/null
+++ b/src/mzscheme/gc/NT_MAKEFILE
@@ -0,0 +1,59 @@
+# Makefile for Windows NT.  Assumes Microsoft compiler, and a single thread.
+# DLLs are included in the root set under NT, but not under win32S.
+# Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor.
+
+CPU= i386
+!include <ntwin32.mak>
+
+OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj
+
+all: gctest.exe cord\de.exe test_cpp.exe
+
+.c.obj:
+	$(cc) $(cdebug) $(cflags) $(cvars) -DSMALL_CONFIG -DSILENT -DALL_INTERIOR_POINTERS -D__STDC__ $*.c /Fo$*.obj
+
+.cpp.obj:
+	$(cc) $(cdebug) $(cflags) $(cvars) -DSMALL_CONFIG -DSILENT -DALL_INTERIOR_POINTERS $*.CPP /Fo$*.obj
+
+$(OBJS) test.obj: gc_priv.h gc_hdrs.h gc.h
+
+gc.lib: $(OBJS)
+	lib /MACHINE:i386 /out:gc.lib $(OBJS)
+# The original NT SDK used lib32 instead of lib
+
+gctest.exe: test.obj gc.lib
+#	The following works for win32 debugging.  For win32s debugging use debugtype:coff
+#	and add mapsympe line.
+#  This produces a "GUI" applications that opens no windows and writes to the log file
+#  "gc.log".  This is done to make the result runnable under win32s.
+	$(link) -debug:full -debugtype:cv $(guiflags) -stack:131072 -out:$*.exe test.obj $(guilibs) gc.lib
+#	mapsympe -n -o gctest.sym gctest.exe
+
+cord\de_win.rbj: cord\de_win.res
+	cvtres -$(CPU) cord\de_win.res -o cord\de_win.rbj
+
+cord\de.obj cord\de_win.obj: cord\cord.h cord\private\cord_pos.h cord\de_win.h cord\de_cmds.h
+
+cord\de_win.res: cord\de_win.rc cord\de_win.h cord\de_cmds.h
+	$(rc) $(rcvars) -r -fo cord\de_win.res $(cvars) cord\de_win.rc
+
+# Cord/de is a real win32 gui application.
+cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj cord\de_win.rbj gc.lib
+	$(link) -debug:full -debugtype:cv $(guiflags) -stack:16384 -out:cord\de.exe  cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj cord\de_win.rbj gc.lib $(guilibs)
+
+gc_cpp.obj: gc_cpp.h gc.h
+
+gc_cpp.cpp: gc_cpp.cc
+	copy gc_cpp.cc gc_cpp.cpp
+
+test_cpp.cpp: test_cpp.cc
+	copy test_cpp.cc test_cpp.cpp
+
+# This generates the C++ test executable.  The executable expects
+# a single numeric argument, which is the number of iterations.
+# The output appears in the file "gc.log".
+test_cpp.exe: test_cpp.obj gc_cpp.h gc.h gc.lib
+	$(link) -debug:full -debugtype:cv $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc.lib $(guilibs)
+
+
+
diff --git a/src/mzscheme/gc/NT_THREADS_MAKEFILE b/src/mzscheme/gc/NT_THREADS_MAKEFILE
new file mode 100644
index 0000000..fdd0c9c
--- /dev/null
+++ b/src/mzscheme/gc/NT_THREADS_MAKEFILE
@@ -0,0 +1,2087 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+!IF "$(CFG)" == ""
+CFG=cord - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to cord - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "gc - Win32 Release" && "$(CFG)" != "gc - Win32 Debug" &&\
+ "$(CFG)" != "gctest - Win32 Release" && "$(CFG)" != "gctest - Win32 Debug" &&\
+ "$(CFG)" != "cord - Win32 Release" && "$(CFG)" != "cord - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "gc.mak" CFG="cord - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "gc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "gc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "gctest - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "gctest - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "cord - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "cord - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "gctest - Win32 Debug"
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : ".\Release\gc.dll" ".\Release\gc.bsc"
+
+CLEAN : 
+	-@erase ".\Release\allchblk.obj"
+	-@erase ".\Release\allchblk.sbr"
+	-@erase ".\Release\alloc.obj"
+	-@erase ".\Release\alloc.sbr"
+	-@erase ".\Release\blacklst.obj"
+	-@erase ".\Release\blacklst.sbr"
+	-@erase ".\Release\checksums.obj"
+	-@erase ".\Release\checksums.sbr"
+	-@erase ".\Release\dbg_mlc.obj"
+	-@erase ".\Release\dbg_mlc.sbr"
+	-@erase ".\Release\dyn_load.obj"
+	-@erase ".\Release\dyn_load.sbr"
+	-@erase ".\Release\finalize.obj"
+	-@erase ".\Release\finalize.sbr"
+	-@erase ".\Release\gc.bsc"
+	-@erase ".\Release\gc.dll"
+	-@erase ".\Release\gc.exp"
+	-@erase ".\Release\gc.lib"
+	-@erase ".\Release\headers.obj"
+	-@erase ".\Release\headers.sbr"
+	-@erase ".\Release\mach_dep.obj"
+	-@erase ".\Release\mach_dep.sbr"
+	-@erase ".\Release\malloc.obj"
+	-@erase ".\Release\malloc.sbr"
+	-@erase ".\Release\mallocx.obj"
+	-@erase ".\Release\mallocx.sbr"
+	-@erase ".\Release\mark.obj"
+	-@erase ".\Release\mark.sbr"
+	-@erase ".\Release\mark_rts.obj"
+	-@erase ".\Release\mark_rts.sbr"
+	-@erase ".\Release\misc.obj"
+	-@erase ".\Release\misc.sbr"
+	-@erase ".\Release\new_hblk.obj"
+	-@erase ".\Release\new_hblk.sbr"
+	-@erase ".\Release\obj_map.obj"
+	-@erase ".\Release\obj_map.sbr"
+	-@erase ".\Release\os_dep.obj"
+	-@erase ".\Release\os_dep.sbr"
+	-@erase ".\Release\ptr_chck.obj"
+	-@erase ".\Release\ptr_chck.sbr"
+	-@erase ".\Release\reclaim.obj"
+	-@erase ".\Release\reclaim.sbr"
+	-@erase ".\Release\stubborn.obj"
+	-@erase ".\Release\stubborn.sbr"
+	-@erase ".\Release\typd_mlc.obj"
+	-@erase ".\Release\typd_mlc.sbr"
+	-@erase ".\Release\win32_threads.obj"
+	-@erase ".\Release\win32_threads.sbr"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D\
+ "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
+ "WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\Release/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS= \
+	".\Release\allchblk.sbr" \
+	".\Release\alloc.sbr" \
+	".\Release\blacklst.sbr" \
+	".\Release\checksums.sbr" \
+	".\Release\dbg_mlc.sbr" \
+	".\Release\dyn_load.sbr" \
+	".\Release\finalize.sbr" \
+	".\Release\headers.sbr" \
+	".\Release\mach_dep.sbr" \
+	".\Release\malloc.sbr" \
+	".\Release\mallocx.sbr" \
+	".\Release\mark.sbr" \
+	".\Release\mark_rts.sbr" \
+	".\Release\misc.sbr" \
+	".\Release\new_hblk.sbr" \
+	".\Release\obj_map.sbr" \
+	".\Release\os_dep.sbr" \
+	".\Release\ptr_chck.sbr" \
+	".\Release\reclaim.sbr" \
+	".\Release\stubborn.sbr" \
+	".\Release\typd_mlc.sbr" \
+	".\Release\win32_threads.sbr"
+
+".\Release\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\
+ /pdb:"$(OUTDIR)/gc.pdb" /machine:I386 /out:"$(OUTDIR)/gc.dll"\
+ /implib:"$(OUTDIR)/gc.lib" 
+LINK32_OBJS= \
+	".\Release\allchblk.obj" \
+	".\Release\alloc.obj" \
+	".\Release\blacklst.obj" \
+	".\Release\checksums.obj" \
+	".\Release\dbg_mlc.obj" \
+	".\Release\dyn_load.obj" \
+	".\Release\finalize.obj" \
+	".\Release\headers.obj" \
+	".\Release\mach_dep.obj" \
+	".\Release\malloc.obj" \
+	".\Release\mallocx.obj" \
+	".\Release\mark.obj" \
+	".\Release\mark_rts.obj" \
+	".\Release\misc.obj" \
+	".\Release\new_hblk.obj" \
+	".\Release\obj_map.obj" \
+	".\Release\os_dep.obj" \
+	".\Release\ptr_chck.obj" \
+	".\Release\reclaim.obj" \
+	".\Release\stubborn.obj" \
+	".\Release\typd_mlc.obj" \
+	".\Release\win32_threads.obj"
+
+".\Release\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=.\Debug
+INTDIR=.\Debug
+
+ALL : ".\Debug\gc.dll" ".\Debug\gc.bsc"
+
+CLEAN : 
+	-@erase ".\Debug\allchblk.obj"
+	-@erase ".\Debug\allchblk.sbr"
+	-@erase ".\Debug\alloc.obj"
+	-@erase ".\Debug\alloc.sbr"
+	-@erase ".\Debug\blacklst.obj"
+	-@erase ".\Debug\blacklst.sbr"
+	-@erase ".\Debug\checksums.obj"
+	-@erase ".\Debug\checksums.sbr"
+	-@erase ".\Debug\dbg_mlc.obj"
+	-@erase ".\Debug\dbg_mlc.sbr"
+	-@erase ".\Debug\dyn_load.obj"
+	-@erase ".\Debug\dyn_load.sbr"
+	-@erase ".\Debug\finalize.obj"
+	-@erase ".\Debug\finalize.sbr"
+	-@erase ".\Debug\gc.bsc"
+	-@erase ".\Debug\gc.dll"
+	-@erase ".\Debug\gc.exp"
+	-@erase ".\Debug\gc.lib"
+	-@erase ".\Debug\gc.map"
+	-@erase ".\Debug\gc.pdb"
+	-@erase ".\Debug\headers.obj"
+	-@erase ".\Debug\headers.sbr"
+	-@erase ".\Debug\mach_dep.obj"
+	-@erase ".\Debug\mach_dep.sbr"
+	-@erase ".\Debug\malloc.obj"
+	-@erase ".\Debug\malloc.sbr"
+	-@erase ".\Debug\mallocx.obj"
+	-@erase ".\Debug\mallocx.sbr"
+	-@erase ".\Debug\mark.obj"
+	-@erase ".\Debug\mark.sbr"
+	-@erase ".\Debug\mark_rts.obj"
+	-@erase ".\Debug\mark_rts.sbr"
+	-@erase ".\Debug\misc.obj"
+	-@erase ".\Debug\misc.sbr"
+	-@erase ".\Debug\new_hblk.obj"
+	-@erase ".\Debug\new_hblk.sbr"
+	-@erase ".\Debug\obj_map.obj"
+	-@erase ".\Debug\obj_map.sbr"
+	-@erase ".\Debug\os_dep.obj"
+	-@erase ".\Debug\os_dep.sbr"
+	-@erase ".\Debug\ptr_chck.obj"
+	-@erase ".\Debug\ptr_chck.sbr"
+	-@erase ".\Debug\reclaim.obj"
+	-@erase ".\Debug\reclaim.sbr"
+	-@erase ".\Debug\stubborn.obj"
+	-@erase ".\Debug\stubborn.sbr"
+	-@erase ".\Debug\typd_mlc.obj"
+	-@erase ".\Debug\typd_mlc.sbr"
+	-@erase ".\Debug\vc40.idb"
+	-@erase ".\Debug\vc40.pdb"
+	-@erase ".\Debug\win32_threads.obj"
+	-@erase ".\Debug\win32_threads.sbr"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "SILENT" /D "GC_BUILD"\
+ /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
+ "WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\Debug/
+CPP_SBRS=.\Debug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS= \
+	".\Debug\allchblk.sbr" \
+	".\Debug\alloc.sbr" \
+	".\Debug\blacklst.sbr" \
+	".\Debug\checksums.sbr" \
+	".\Debug\dbg_mlc.sbr" \
+	".\Debug\dyn_load.sbr" \
+	".\Debug\finalize.sbr" \
+	".\Debug\headers.sbr" \
+	".\Debug\mach_dep.sbr" \
+	".\Debug\malloc.sbr" \
+	".\Debug\mallocx.sbr" \
+	".\Debug\mark.sbr" \
+	".\Debug\mark_rts.sbr" \
+	".\Debug\misc.sbr" \
+	".\Debug\new_hblk.sbr" \
+	".\Debug\obj_map.sbr" \
+	".\Debug\os_dep.sbr" \
+	".\Debug\ptr_chck.sbr" \
+	".\Debug\reclaim.sbr" \
+	".\Debug\stubborn.sbr" \
+	".\Debug\typd_mlc.sbr" \
+	".\Debug\win32_threads.sbr"
+
+".\Debug\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /incremental:no /map /debug /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\
+ /pdb:"$(OUTDIR)/gc.pdb" /map:"$(INTDIR)/gc.map" /debug /machine:I386\
+ /out:"$(OUTDIR)/gc.dll" /implib:"$(OUTDIR)/gc.lib" 
+LINK32_OBJS= \
+	".\Debug\allchblk.obj" \
+	".\Debug\alloc.obj" \
+	".\Debug\blacklst.obj" \
+	".\Debug\checksums.obj" \
+	".\Debug\dbg_mlc.obj" \
+	".\Debug\dyn_load.obj" \
+	".\Debug\finalize.obj" \
+	".\Debug\headers.obj" \
+	".\Debug\mach_dep.obj" \
+	".\Debug\malloc.obj" \
+	".\Debug\mallocx.obj" \
+	".\Debug\mark.obj" \
+	".\Debug\mark_rts.obj" \
+	".\Debug\misc.obj" \
+	".\Debug\new_hblk.obj" \
+	".\Debug\obj_map.obj" \
+	".\Debug\os_dep.obj" \
+	".\Debug\ptr_chck.obj" \
+	".\Debug\reclaim.obj" \
+	".\Debug\stubborn.obj" \
+	".\Debug\typd_mlc.obj" \
+	".\Debug\win32_threads.obj"
+
+".\Debug\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "gctest\Release"
+# PROP BASE Intermediate_Dir "gctest\Release"
+# PROP BASE Target_Dir "gctest"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "gctest\Release"
+# PROP Intermediate_Dir "gctest\Release"
+# PROP Target_Dir "gctest"
+OUTDIR=.\gctest\Release
+INTDIR=.\gctest\Release
+
+ALL : "gc - Win32 Release" ".\Release\gctest.exe"
+
+CLEAN : 
+	-@erase ".\gctest\Release\test.obj"
+	-@erase ".\Release\gctest.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS"\
+ /Fp"$(INTDIR)/gctest.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\gctest\Release/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/gctest.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/gctest.pdb" /machine:I386 /out:"Release/gctest.exe" 
+LINK32_OBJS= \
+	".\gctest\Release\test.obj" \
+	".\Release\gc.lib"
+
+".\Release\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "gctest\Debug"
+# PROP BASE Intermediate_Dir "gctest\Debug"
+# PROP BASE Target_Dir "gctest"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "gctest\Debug"
+# PROP Intermediate_Dir "gctest\Debug"
+# PROP Target_Dir "gctest"
+OUTDIR=.\gctest\Debug
+INTDIR=.\gctest\Debug
+
+ALL : "gc - Win32 Debug" ".\Debug\gctest.exe" ".\gctest\Debug\gctest.bsc"
+
+CLEAN : 
+	-@erase ".\Debug\gctest.exe"
+	-@erase ".\gctest\Debug\gctest.bsc"
+	-@erase ".\gctest\Debug\gctest.map"
+	-@erase ".\gctest\Debug\gctest.pdb"
+	-@erase ".\gctest\Debug\test.obj"
+	-@erase ".\gctest\Debug\test.sbr"
+	-@erase ".\gctest\Debug\vc40.idb"
+	-@erase ".\gctest\Debug\vc40.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
+ /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR"$(INTDIR)/"\
+ /Fp"$(INTDIR)/gctest.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\gctest\Debug/
+CPP_SBRS=.\gctest\Debug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" 
+BSC32_SBRS= \
+	".\gctest\Debug\test.sbr"
+
+".\gctest\Debug\gctest.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /incremental:no /map /debug /machine:I386 /out:"Debug/gctest.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/gctest.pdb" /map:"$(INTDIR)/gctest.map" /debug /machine:I386\
+ /out:"Debug/gctest.exe" 
+LINK32_OBJS= \
+	".\Debug\gc.lib" \
+	".\gctest\Debug\test.obj"
+
+".\Debug\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "cord\Release"
+# PROP BASE Intermediate_Dir "cord\Release"
+# PROP BASE Target_Dir "cord"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "cord\Release"
+# PROP Intermediate_Dir "cord\Release"
+# PROP Target_Dir "cord"
+OUTDIR=.\cord\Release
+INTDIR=.\cord\Release
+
+ALL : "gc - Win32 Release" ".\Release\de.exe"
+
+CLEAN : 
+	-@erase ".\cord\Release\cordbscs.obj"
+	-@erase ".\cord\Release\cordxtra.obj"
+	-@erase ".\cord\Release\de.obj"
+	-@erase ".\cord\Release\de_win.obj"
+	-@erase ".\cord\Release\de_win.res"
+	-@erase ".\Release\de.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\cord\Release/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/de.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no /pdb:"$(OUTDIR)/de.pdb"\
+ /machine:I386 /out:"Release/de.exe" 
+LINK32_OBJS= \
+	".\cord\Release\cordbscs.obj" \
+	".\cord\Release\cordxtra.obj" \
+	".\cord\Release\de.obj" \
+	".\cord\Release\de_win.obj" \
+	".\cord\Release\de_win.res" \
+	".\Release\gc.lib"
+
+".\Release\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "cord\Debug"
+# PROP BASE Intermediate_Dir "cord\Debug"
+# PROP BASE Target_Dir "cord"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "cord\Debug"
+# PROP Intermediate_Dir "cord\Debug"
+# PROP Target_Dir "cord"
+OUTDIR=.\cord\Debug
+INTDIR=.\cord\Debug
+
+ALL : "gc - Win32 Debug" ".\Debug\de.exe"
+
+CLEAN : 
+	-@erase ".\cord\Debug\cordbscs.obj"
+	-@erase ".\cord\Debug\cordxtra.obj"
+	-@erase ".\cord\Debug\de.obj"
+	-@erase ".\cord\Debug\de.pdb"
+	-@erase ".\cord\Debug\de_win.obj"
+	-@erase ".\cord\Debug\de_win.res"
+	-@erase ".\cord\Debug\vc40.idb"
+	-@erase ".\cord\Debug\vc40.pdb"
+	-@erase ".\Debug\de.exe"
+	-@erase ".\Debug\de.ilk"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /D "_DEBUG" /D "WIN32" /D\
+ "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\cord\Debug/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"Debug/de.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:yes\
+ /pdb:"$(OUTDIR)/de.pdb" /debug /machine:I386 /out:"Debug/de.exe" 
+LINK32_OBJS= \
+	".\cord\Debug\cordbscs.obj" \
+	".\cord\Debug\cordxtra.obj" \
+	".\cord\Debug\de.obj" \
+	".\cord\Debug\de_win.obj" \
+	".\cord\Debug\de_win.res" \
+	".\Debug\gc.lib"
+
+".\Debug\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+################################################################################
+# Begin Target
+
+# Name "gc - Win32 Release"
+# Name "gc - Win32 Debug"
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\reclaim.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_RECLA=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_RECLA=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+".\Release\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_RECLA=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_RECLA=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+".\Debug\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\os_dep.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_OS_DE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OS_DE=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	".\vd\PCR_VD.h"\
+	
+
+".\Release\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+".\Release\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_OS_DE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OS_DE=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	".\vd\PCR_VD.h"\
+	
+
+".\Debug\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+".\Debug\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\misc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MISC_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MISC_=\
+	".\il\PCR_IL.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+".\Release\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MISC_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MISC_=\
+	".\il\PCR_IL.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+".\Debug\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mark_rts.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MARK_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+".\Release\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MARK_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+".\Debug\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mach_dep.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MACH_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MACH_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+".\Release\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MACH_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MACH_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+".\Debug\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\headers.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_HEADE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_HEADE=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+".\Release\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_HEADE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_HEADE=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+".\Debug\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\alloc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_ALLOC=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLOC=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+".\Release\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_ALLOC=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLOC=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+".\Debug\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\allchblk.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_ALLCH=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLCH=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+".\Release\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_ALLCH=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLCH=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+".\Debug\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\stubborn.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_STUBB=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_STUBB=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+".\Release\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_STUBB=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_STUBB=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+".\Debug\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\obj_map.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_OBJ_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OBJ_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+".\Release\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_OBJ_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OBJ_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+".\Debug\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\new_hblk.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_NEW_H=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_NEW_H=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+".\Release\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_NEW_H=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_NEW_H=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+".\Debug\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mark.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MARK_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+".\Release\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MARK_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+".\Debug\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\malloc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MALLO=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLO=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+".\Release\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MALLO=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLO=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+".\Debug\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mallocx.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MALLX=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLX=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+".\Release\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MALLX=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLX=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+".\Debug\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\finalize.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_FINAL=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_FINAL=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+".\Release\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_FINAL=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_FINAL=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+".\Debug\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dbg_mlc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_DBG_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DBG_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+".\Release\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_DBG_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DBG_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+".\Debug\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\blacklst.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_BLACK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_BLACK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+".\Release\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_BLACK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_BLACK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+".\Debug\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\typd_mlc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_TYPD_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TYPD_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+".\Release\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_TYPD_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TYPD_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+".\Debug\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\ptr_chck.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_PTR_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_PTR_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+".\Release\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_PTR_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_PTR_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+".\Debug\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dyn_load.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_DYN_L=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DYN_L=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+".\Release\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_DYN_L=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DYN_L=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+".\Debug\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\win32_threads.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_WIN32=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_WIN32=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+".\Release\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_WIN32=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_WIN32=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+".\Debug\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\checksums.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_CHECK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_CHECK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+".\Release\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_CHECK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_CHECK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+".\Debug\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+################################################################################
+# Begin Target
+
+# Name "gctest - Win32 Release"
+# Name "gctest - Win32 Debug"
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Project Dependency
+
+# Project_Dep_Name "gc"
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+"gc - Win32 Release" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" 
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+"gc - Win32 Debug" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" 
+
+!ENDIF 
+
+# End Project Dependency
+################################################################################
+# Begin Source File
+
+SOURCE=.\test.c
+DEP_CPP_TEST_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TEST_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+
+".\gctest\Release\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+
+".\gctest\Debug\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+".\gctest\Debug\test.sbr" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+################################################################################
+# Begin Target
+
+# Name "cord - Win32 Release"
+# Name "cord - Win32 Debug"
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Project Dependency
+
+# Project_Dep_Name "gc"
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+"gc - Win32 Release" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" 
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+"gc - Win32 Debug" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" 
+
+!ENDIF 
+
+# End Project Dependency
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de_win.c
+DEP_CPP_DE_WI=\
+	".\cord\cord.h"\
+	".\cord\de_cmds.h"\
+	".\cord\de_win.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_DE_WI=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de.c
+DEP_CPP_DE_C2e=\
+	".\cord\cord.h"\
+	".\cord\de_cmds.h"\
+	".\cord\de_win.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_DE_C2e=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\cordxtra.c
+DEP_CPP_CORDX=\
+	".\cord\cord.h"\
+	".\cord\ec.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_CORDX=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\cordbscs.c
+DEP_CPP_CORDB=\
+	".\cord\cord.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_CORDB=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de_win.RC
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de_win.res" : $(SOURCE) "$(INTDIR)"
+   $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "NDEBUG" $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de_win.res" : $(SOURCE) "$(INTDIR)"
+   $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "_DEBUG" $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/mzscheme/gc/OS2_MAKEFILE b/src/mzscheme/gc/OS2_MAKEFILE
new file mode 100644
index 0000000..7b81621
--- /dev/null
+++ b/src/mzscheme/gc/OS2_MAKEFILE
@@ -0,0 +1,45 @@
+# Makefile for OS/2.  Assumes IBM's compiler, static linking, and a single thread.
+# Adding dynamic linking support seems easy, but takes a little bit of work.
+# Adding thread support may be nontrivial, since we haven't yet figured out how to
+# look at another thread's registers.
+
+# Significantly revised for GC version 4.4 by Mark Boulter (Jan 1994).
+
+OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj malloc.obj stubborn.obj typd_mlc.obj ptr_chck.obj mallocx.obj
+
+CORDOBJS= cord\cordbscs.obj cord\cordxtra.obj cord\cordprnt.obj
+
+CC= icc
+CFLAGS= /O /Q /DSILENT /DSMALL_CONFIG /DALL_INTERIOR_POINTERS
+# Use /Ti instead of /O for debugging
+# Setjmp_test may yield overly optimistic results when compiled
+# without optimization.
+
+all: $(OBJS) gctest.exe cord\cordtest.exe
+
+$(OBJS) test.obj: gc_priv.h gc_hdrs.h gc.h
+
+## ERASE THE LIB FIRST - if it is already there then this command will fail
+## (make sure its there or erase will fail!)
+gc.lib: $(OBJS)
+        echo . > gc.lib
+        erase gc.lib
+        LIB gc.lib $(OBJS), gc.lst
+
+mach_dep.obj: mach_dep.c
+        $(CC) $(CFLAGS) /C mach_dep.c
+
+gctest.exe: test.obj gc.lib
+        $(CC) $(CFLAGS) /B"/STACK:524288" /Fegctest test.obj gc.lib
+
+cord\cordbscs.obj: cord\cordbscs.c cord\cord.h cord\private\cord_pos.h
+        $(CC) $(CFLAGS) /C /Focord\cordbscs cord\cordbscs.c
+
+cord\cordxtra.obj: cord\cordxtra.c cord\cord.h cord\private\cord_pos.h cord\ec.h
+        $(CC) $(CFLAGS) /C /Focord\cordxtra cord\cordxtra.c
+
+cord\cordprnt.obj: cord\cordprnt.c cord\cord.h cord\private\cord_pos.h cord\ec.h
+        $(CC) $(CFLAGS) /C /Focord\cordprnt cord\cordprnt.c
+
+cord\cordtest.exe: cord\cordtest.c cord\cord.h cord\private\cord_pos.h cord\ec.h $(CORDOBJS) gc.lib
+        $(CC) $(CFLAGS) /B"/STACK:65536" /Fecord\cordtest cord\cordtest.c gc.lib $(CORDOBJS)
diff --git a/src/mzscheme/gc/PCR-Makefile b/src/mzscheme/gc/PCR-Makefile
new file mode 100644
index 0000000..7b80637
--- /dev/null
+++ b/src/mzscheme/gc/PCR-Makefile
@@ -0,0 +1,68 @@
+#
+# Default target
+#
+
+default: gc.o
+
+include ../config/common.mk
+
+#
+# compilation flags, etc.
+#
+
+
+CPPFLAGS = $(INCLUDE) $(CONFIG_CPPFLAGS) \
+	-DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR
+#CFLAGS	= -DPCR -DSILENT $(CONFIG_CFLAGS)
+CFLAGS	= -DPCR $(CONFIG_CFLAGS)
+SPECIALCFLAGS = 	# For code involving asm's
+
+ASPPFLAGS  = $(INCLUDE) $(CONFIG_ASPPFLAGS) \
+	-DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR -DASM
+
+ASFLAGS	= $(CONFIG_ASFLAGS)
+
+LDRFLAGS = $(CONFIG_LDRFLAGS)
+
+LDFLAGS = $(CONFIG_LDFLAGS)
+
+#
+#
+#
+#
+# BEGIN PACKAGE-SPECIFIC PART
+#
+#
+#
+#
+
+# Fix to point to local pcr installation directory.
+PCRDIR= ..
+
+COBJ= alloc.o reclaim.o allchblk.o misc.o os_dep.o mark_rts.o headers.o mark.o obj_map.o pcr_interface.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o typd_mlc.o ptr_chck.o mallocx.o
+
+CSRC= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c typd_mlc.c ptr_chck.c mallocx.c
+
+SHELL= /bin/sh
+
+default: gc.o
+
+gc.o: $(COBJ) mach_dep.o
+	$(LDR) $(CONFIG_LDRFLAGS) -o gc.o $(COBJ) mach_dep.o
+
+
+mach_dep.o: mach_dep.c mips_mach_dep.s rs6000_mach_dep.s if_mach if_not_there
+	rm -f mach_dep.o
+	./if_mach MIPS "" as -o mach_dep.o mips_mach_dep.s
+	./if_mach RS6000 "" as -o mach_dep.o rs6000_mach_dep.s
+	./if_mach ALPHA "" as -o mach_dep.o alpha_mach_dep.s
+	./if_mach SPARC SUNOS5 as -o mach_dep.o sparc_mach_dep.s
+	./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) mach_dep.c
+
+if_mach: if_mach.c config.h
+	$(CC) $(CFLAGS) -o if_mach if_mach.c
+
+if_not_there: if_not_there.c
+	$(CC) $(CFLAGS) -o if_not_there if_not_there.c
+
+
diff --git a/src/mzscheme/gc/README b/src/mzscheme/gc/README
new file mode 100644
index 0000000..9d6fc0d
--- /dev/null
+++ b/src/mzscheme/gc/README
@@ -0,0 +1,1253 @@
+Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+Copyright (c) 1991-1996 by Xerox Corporation.  All rights reserved.
+Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+Permission is hereby granted to use or copy this program
+for any purpose,  provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is granted,
+provided the above notices are retained, and a notice that the code was
+modified is included with the above copyright notice.
+
+This is version 4.11 of a conservative garbage collector for C and C++.
+
+HISTORY -
+
+  Early versions of this collector were developed as a part of research
+projects supported in part by the National Science Foundation
+and the Defense Advance Research Projects Agency.
+Much of the code was rewritten by Hans-J. Boehm at Xerox PARC.
+The SPARC specific code was contributed by Mark Weiser
+(weiser@parc.xerox.com).  The Encore Multimax modifications were supplied by
+Kevin Kenny (kenny@m.cs.uiuc.edu).  The adaptation to the RT is largely due
+to Vernon Lee (scorpion@rice.edu), on machines made available by IBM.
+Much of the HP specific code and a number of good suggestions for improving the
+generic code are due to Walter Underwood (wunder@hp-ses.sde.hp.com).
+Robert Brazile (brazile@diamond.bbn.com) originally supplied the ULTRIX code.
+Al Dosser (dosser@src.dec.com) and Regis Cridlig (Regis.Cridlig@cl.cam.ac.uk)
+subsequently provided updates and information on variation between ULTRIX
+systems.  Parag Patel (parag@netcom.com) supplied the A/UX code.
+Jesper Peterson(jep@mtiame.mtia.oz.au) and
+Michel Schinz supplied the Amiga port.
+Thomas Funke (thf@zelator.in-berlin.de(?)) and
+Brian D.Carlstrom (bdc@clark.lcs.mit.edu) supplied the NeXT ports.
+Douglas Steel (doug@wg.icl.co.uk) provided ICL DRS6000 code.
+Bill Janssen (janssen@parc.xerox.com) supplied the SunOS dynamic loader
+specific code. Manuel Serrano (serrano@cornas.inria.fr) supplied linux and
+Sony News specific code.  Al Dosser provided Alpha/OSF/1 code.  He and
+Dave Detlefs(detlefs@src.dec.com) also provided several generic bug fixes.
+Alistair G. Crooks(agc@uts.amdahl.com) supplied the NetBSD and 386BSD ports.
+Jeffrey Hsu (hsu@soda.berkeley.edu) provided the FreeBSD port.
+Brent Benson (brent@jade.ssd.csd.harris.com) ported the collector to
+a Motorola 88K processor running CX/UX (Harris NightHawk).
+Ari Huttunen (Ari.Huttunen@hut.fi) generalized the OS/2 port to
+nonIBM development environments (a nontrivial task).
+Patrick Beard (beard@cs.ucdavis.edu) provided the initial MacOS port.
+David Chase, then at Olivetti Research, suggested several improvements.
+Scott Schwartz (schwartz@groucho.cse.psu.edu) supplied some of the
+code to save and print call stacks for leak detection on a SPARC.
+Jesse Hull and John Ellis supplied the C++ interface code.
+Zhong Shao performed much of the experimentation that led to the
+current typed allocation facility.  (His dynamic type inference code hasn't
+made it into the released version of the collector, yet.)
+(Blame for misinstallation of these modifications goes to the first author,
+however.)
+
+Credits for some more recent modifications are given in the modification
+history at the end of this file.
+
+    This is intended to be a general purpose, garbage collecting storage
+allocator.  The algorithms used are described in:
+
+Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment",
+Software Practice & Experience, September 1988, pp. 807-820.
+
+Boehm, H., A. Demers, and S. Shenker, "Mostly Parallel Garbage Collection",
+Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design
+and Implementation, SIGPLAN Notices 26, 6 (June 1991), pp. 157-164.
+
+Boehm, H., "Space Efficient Conservative Garbage Collection", Proceedings
+of the ACM SIGPLAN '91 Conference on Programming Language Design and
+Implementation, SIGPLAN Notices 28, 6 (June 1993), pp. 197-206.
+
+  Possible interactions between the collector and optimizing compilers are
+discussed in
+
+Boehm, H., and D. Chase, "A Proposal for GC-safe C Compilation",
+The Journal of C Language Translation 4, 2 (December 1992).
+
+and
+
+Boehm H., "Simple GC-safe Compilation", Proceedings
+of the ACM SIGPLAN '96 Conference on Programming Language Design and
+Implementation.
+
+(Both are also available from
+http://reality.sgi.com/employees/boehm_mti/papers/, among other places.)
+
+  Unlike the collector described in the second reference, this collector
+operates either with the mutator stopped during the entire collection
+(default) or incrementally during allocations.  (The latter is supported
+on only a few machines.)  It does not rely on threads, but is intended
+to be thread-safe.
+
+  Some of the ideas underlying the collector have previously been explored
+by others.  (Doug McIlroy wrote a vaguely similar collector that is part of
+version 8 UNIX (tm).)  However none of this work appears to have been widely
+disseminated.
+
+  Rudimentary tools for use of the collector as a leak detector are included, as
+is a fairly sophisticated string package "cord" that makes use of the collector.
+(See cord/README.)
+
+
+GENERAL DESCRIPTION
+
+  This is a garbage collecting storage allocator that is intended to be
+used as a plug-in replacement for C's malloc.
+
+  Since the collector does not require pointers to be tagged, it does not
+attempt to ensure that all inaccessible storage is reclaimed.  However,
+in our experience, it is typically more successful at reclaiming unused
+memory than most C programs using explicit deallocation.  Unlike manually
+introduced leaks, the amount of unreclaimed memory typically stays
+bounded.
+
+  In the following, an "object" is defined to be a region of memory allocated
+by the routines described below.  
+
+  Any objects not intended to be collected must be pointed to either
+from other such accessible objects, or from the registers,
+stack, data, or statically allocated bss segments.  Pointers from
+the stack or registers may point to anywhere inside an object.
+The same is true for heap pointers if the collector is compiled with
+ ALL_INTERIOR_POINTERS defined, as is now the default.
+
+Compiling without ALL_INTERIOR_POINTERS may reduce accidental retention
+of garbage objects, by requiring pointers from the heap to to the beginning
+of an object.  But this no longer appears to be a significant
+issue for most programs.
+
+There are a number of routines which modify the pointer recognition
+algorithm.  GC_register_displacement allows certain interior pointers
+to be recognized even if ALL_INTERIOR_POINTERS is nor defined.
+GC_malloc_ignore_off_page allows some pointers into the middle of large objects
+to be disregarded, greatly reducing the probablility of accidental
+retention of large objects.  For most purposes it seems best to compile
+with ALL_INTERIOR_POINTERS and to use GC_malloc_ignore_off_page if
+you get collector warnings from allocations of very large objects.
+See README.debugging for details.
+
+  Note that pointers inside memory allocated by the standard "malloc" are not
+seen by the garbage collector.  Thus objects pointed to only from such a
+region may be prematurely deallocated.  It is thus suggested that the
+standard "malloc" be used only for memory regions, such as I/O buffers, that
+are guaranteed not to contain pointers.  Pointers in C language automatic,
+static, or register variables, are correctly recognized.  (Note that
+GC_malloc_uncollectable has semantics similar to standard malloc,
+but allocates objects that are traced by the collector.)
+
+  The collector does not always know how to find pointers in data
+areas that are associated with dynamic libraries.  This is easy to
+remedy IF you know how to find those data areas on your operating
+system (see GC_add_roots).  Code for doing this under SunOS, IRIX 5.X and 6.X,
+HP/UX, Alpha OSF/1 and win32 is included and used by default.  (See
+README.win32 for win32 details.)  On other systems pointers from dynamic library
+data areas may not be considered by the collector.
+
+  Note that the garbage collector does not need to be informed of shared
+read-only data.  However if the shared library mechanism can introduce
+discontiguous data areas that may contain pointers, then the collector does
+need to be informed.
+
+  Signal processing for most signals may be deferred during collection,
+and during uninterruptible parts of the allocation process.  Unlike
+standard ANSI C mallocs, it can be safe to invoke malloc
+from a signal handler while another malloc is in progress, provided
+the original malloc is not restarted.  (Empirically, many UNIX
+applications already assume this.)  To obtain this level  of signal
+safety, remove the definition of -DNO_SIGNALS in Makefile.  This incurs
+a minor performance penalty, and hence is no longer the default.
+
+  The allocator/collector can also be configured for thread-safe operation.
+(Full signal safety can also be achieved, but only at the cost of two system
+calls per malloc, which is usually unacceptable.)
+
+INSTALLATION AND PORTABILITY
+
+  As distributed, the macro SILENT is defined in Makefile.
+In the event of problems, this can be removed to obtain a moderate
+amount of descriptive output for each collection.
+(The given statistics exhibit a few peculiarities.
+Things don't appear to add up for a variety of reasons, most notably
+fragmentation losses.  These are probably much more significant for the
+contrived program "test.c" than for your application.)
+
+  Note that typing "make test" will automatically build the collector
+and then run setjmp_test and gctest. Setjmp_test will give you information
+about configuring the collector, which is useful primarily if you have
+a machine that's not already supported.  Gctest is a somewhat superficial
+test of collector functionality.  Failure is indicated by a core dump or
+a message to the effect that the collector is broken.  Gctest takes about 
+35 seconds to run on a SPARCstation 2. On a slower machine,
+expect it to take a while.  It may use up to 8 MB of memory.  (The
+multi-threaded version will use more.)  "Make test" will also, as
+its last step, attempt to build and test the "cord" string library.
+This will fail without an ANSI C compiler.
+
+  The Makefile will generate a library gc.a which you should link against.
+Typing "make cords" will add the cord library to gc.a.
+Note that this requires an ANSI C compiler.
+
+  It is suggested that if you need to replace a piece of the collector
+(e.g. GC_mark_rts.c) you simply list your version ahead of gc.a on the
+		work.)
+ld command line, rather than replacing the one in gc.a.  (This will
+generate numerous warnings under some versions of AIX, but it still
+works.)
+
+  All include files that need to be used by clients will be put in the
+include subdirectory.  (Normally this is just gc.h.  "Make cords" adds
+"cord.h" and "ec.h".)
+
+  The collector currently is designed to run essentially unmodified on
+at least the following machines (most or all of the system names mentioned are
+trademarks of their respective holders):
+
+	    SGI workstations under IRIX 4, 5, & 6
+	    Intel 386 or 486 under most operating systems, but not MSDOS.
+	    	(Win32S is somewhat supported, so it is marginally possible to
+	    	build applications for Windows 3.1.  DOS + djgpp should also
+		work.)
+	    Sun 3
+	    Sun 4 under SunOS 4.X or Solaris2.X (with or without threads)
+	    Vax under 4.3BSD, Ultrix
+	    IBM PC/RT  (Berkeley UNIX)
+	    IBM RS/6000
+	    HP9000/300
+	    HP9000/700
+	    DECstations under Ultrix
+	    DEC Alpha running OSF/1
+	    Sony News
+	    Apple Macintosh under A/UX or MacOS
+	    Commodore Amiga
+	    NeXT machines
+	    Some more obscure and/or obsolete systems ...
+
+  In a few cases (Amiga, OS/2, Win32, MacOS) a separate makefile
+or equivalent is supplied.  Many of these have separate README.system
+files.
+
+  Dynamic libraries are completely supported only under SunOS
+(and even that support is not functional on the last Sun 3 release),
+IRIX 5&6, HP-PA, Win32 (not Win32S) and OSF/1 on DEC AXP machines.
+On other machines we recommend that you do one of the following:
+
+  1) Add dynamic library support (and send us the code).
+  2) Use static versions of the libraries.
+  3) Arrange for dynamic libraries to use the standard malloc.
+     This is still dangerous if the library stores a pointer to a
+     garbage collected object.  But nearly all standard interfaces
+     prohibit this, because they deal correctly with pointers
+     to stack allocated objects.  (Strtok is an exception.  Don't
+     use it.)
+
+  In all cases we assume that pointer alignment is consistent with that
+enforced by the standard C compilers.  If you use a nonstandard compiler
+you may have to adjust the alignment parameters defined in gc_priv.h.
+
+  A port to a machine that is not byte addressed, or does not use 32 bit
+or 64 bit addresses will require a major effort.  A port to plain MSDOS
+or win16 is hard.
+
+  For machines not already mentioned, or for nonstandard compilers, the
+following are likely to require change:
+
+1.  The parameters in config.h.
+      The parameters that will usually require adjustment are
+   STACKBOTTOM,  ALIGNMENT and DATASTART.  Setjmp_test
+   prints its guesses of the first two.
+      DATASTART should be an expression for computing the
+   address of the beginning of the data segment.  This can often be
+   &etext.  But some memory management units require that there be
+   some unmapped space between the text and the data segment.  Thus
+   it may be more complicated.   On UNIX systems, this is rarely
+   documented.  But the adb "$m" command may be helpful.  (Note
+   that DATASTART will usually be a function of &etext.  Thus a
+   single experiment is usually insufficient.)
+     STACKBOTTOM is used to initialize GC_stackbottom, which
+   should be a sufficient approximation to the coldest stack address.
+   On some machines, it is difficult to obtain such a value that is
+   valid across a variety of MMUs, OS releases, etc.  A number of
+   alternatives exist for using the collector in spite of this.  See the
+   discussion in config.h immediately preceding the various
+   definitions of STACKBOTTOM.
+   
+2.  mach_dep.c.
+      The most important routine here is one to mark from registers.
+    The distributed file includes a generic hack (based on setjmp) that
+    happens to work on many machines, and may work on yours.  Try
+    compiling and running setjmp_t.c to see whether it has a chance of
+    working.  (This is not correct C, so don't blame your compiler if it
+    doesn't work.  Based on limited experience, register window machines
+    are likely to cause trouble.  If your version of setjmp claims that
+    all accessible variables, including registers, have the value they
+    had at the time of the longjmp, it also will not work.  Vanilla 4.2 BSD
+    on Vaxen makes such a claim.  SunOS does not.)
+      If your compiler does not allow in-line assembly code, or if you prefer
+    not to use such a facility, mach_dep.c may be replaced by a .s file
+    (as we did for the MIPS machine and the PC/RT).
+      At this point enough architectures are supported by mach_dep.c
+    that you will rarely need to do more than adjust for assembler
+    syntax.
+
+3.  os_dep.c (and gc_priv.h).
+  	  Several kinds of operating system dependent routines reside here.
+  	Many are optional.  Several are invoked only through corresponding
+  	macros in gc_priv.h, which may also be redefined as appropriate.
+      The routine GC_register_data_segments is crucial.  It registers static
+    data areas that must be traversed by the collector. (User calls to
+    GC_add_roots may sometimes be used for similar effect.)
+      Routines to obtain memory from the OS also reside here.
+    Alternatively this can be done entirely by the macro GET_MEM
+    defined in gc_priv.h.  Routines to disable and reenable signals
+    also reside here if they are need by the macros DISABLE_SIGNALS
+    and ENABLE_SIGNALS defined in gc_priv.h.
+      In a multithreaded environment, the macros LOCK and UNLOCK
+    in gc_priv.h will need to be suitably redefined.
+      The incremental collector requires page dirty information, which
+    is acquired through routines defined in os_dep.c.  Unless directed
+    otherwise by config.h, these are implemented as stubs that simply
+    treat all pages as dirty.  (This of course makes the incremental
+    collector much less useful.)
+
+4.  dyn_load.c
+	This provides a routine that allows the collector to scan data
+	segments associated with dynamic libraries.  Often it is not
+	necessary to provide this routine unless user-written dynamic
+	libraries are used.
+
+  For a different version of UN*X or different machines using the
+Motorola 68000, Vax, SPARC, 80386, NS 32000, PC/RT, or MIPS architecture,
+it should frequently suffice to change definitions in config.h.
+
+
+THE C INTERFACE TO THE ALLOCATOR
+
+  The following routines are intended to be directly called by the user.
+Note that usually only GC_malloc is necessary.  GC_clear_roots and GC_add_roots
+calls may be required if the collector has to trace from nonstandard places
+(e.g. from dynamic library data areas on a machine on which the 
+collector doesn't already understand them.)  On some machines, it may
+be desirable to set GC_stacktop to a good approximation of the stack base. 
+(This enhances code portability on HP PA machines, since there is no
+good way for the collector to compute this value.)  Client code may include
+"gc.h", which defines all of the following, plus many others.
+
+1)  GC_malloc(nbytes)
+    - allocate an object of size nbytes.  Unlike malloc, the object is
+      cleared before being returned to the user.  Gc_malloc will
+      invoke the garbage collector when it determines this to be appropriate.
+      GC_malloc may return 0 if it is unable to acquire sufficient
+      space from the operating system.  This is the most probable
+      consequence of running out of space.  Other possible consequences
+      are that a function call will fail due to lack of stack space,
+      or that the collector will fail in other ways because it cannot
+      maintain its internal data structures, or that a crucial system
+      process will fail and take down the machine.  Most of these
+      possibilities are independent of the malloc implementation.
+
+2)  GC_malloc_atomic(nbytes)
+    - allocate an object of size nbytes that is guaranteed not to contain any
+      pointers.  The returned object is not guaranteed to be cleared.
+      (Can always be replaced by GC_malloc, but results in faster collection
+      times.  The collector will probably run faster if large character
+      arrays, etc. are allocated with GC_malloc_atomic than if they are
+      statically allocated.)
+
+3)  GC_realloc(object, new_size)
+    - change the size of object to be new_size.  Returns a pointer to the
+      new object, which may, or may not, be the same as the pointer to
+      the old object.  The new object is taken to be atomic iff the old one
+      was.  If the new object is composite and larger than the original object,
+      then the newly added bytes are cleared (we hope).  This is very likely
+      to allocate a new object, unless MERGE_SIZES is defined in gc_priv.h.
+      Even then, it is likely to recycle the old object only if the object
+      is grown in small additive increments (which, we claim, is generally bad
+      coding practice.)
+
+4)  GC_free(object)
+    - explicitly deallocate an object returned by GC_malloc or
+      GC_malloc_atomic.  Not necessary, but can be used to minimize
+      collections if performance is critical.  Probably a performance
+      loss for very small objects (<= 8 bytes).
+
+5)  GC_expand_hp(bytes)
+    - Explicitly increase the heap size.  (This is normally done automatically
+      if a garbage collection failed to GC_reclaim enough memory.  Explicit
+      calls to GC_expand_hp may prevent unnecessarily frequent collections at
+      program startup.)
+
+6)  GC_malloc_ignore_off_page(bytes)
+	- identical to GC_malloc, but the client promises to keep a pointer to
+	  the somewhere within the first 256 bytes of the object while it is
+	  live.  (This pointer should nortmally be declared volatile to prevent
+	  interference from compiler optimizations.)  This is the recommended
+	  way to allocate anything that is likely to be larger than 100Kbytes
+	  or so.  (GC_malloc may result in failure to reclaim such objects.)
+
+7)  GC_set_warn_proc(proc)
+	- Can be used to redirect warnings from the collector.  Such warnings
+	  should be rare, and should not be ignored during code development.
+      
+8) GC_enable_incremental()
+    - Enables generational and incremental collection.  Useful for large
+      heaps on machines that provide access to page dirty information.
+      Some dirty bit implementations may interfere with debugging
+      (by catching address faults) and place restrictions on heap arguments
+      to system calls (since write faults inside a system call may not be
+      handled well).
+
+9) Several routines to allow for registration of finalization code.
+   User supplied finalization code may be invoked when an object becomes
+   unreachable.  To call (*f)(obj, x) when obj becomes inaccessible, use
+	GC_register_finalizer(obj, f, x, 0, 0);
+   For more sophisticated uses, and for finalization ordering issues,
+   see gc.h.
+
+  The global variable GC_free_space_divisor may be adjusted up from its
+default value of 4 to use less space and more collection time, or down for
+the opposite effect.  Setting it to 1 or 0 will effectively disable collections
+and cause all allocations to simply grow the heap.
+
+  The variable GC_non_gc_bytes, which is normally 0, may be changed to reflect
+the amount of memory allocated by the above routines that should not be
+considered as a candidate for collection.  Careless use may, of course, result
+in excessive memory consumption.
+
+  Some additional tuning is possible through the parameters defined
+near the top of gc_priv.h.
+  
+  If only GC_malloc is intended to be used, it might be appropriate to define:
+
+#define malloc(n) GC_malloc(n)
+#define calloc(m,n) GC_malloc((m)*(n))
+
+  For small pieces of VERY allocation intensive code, gc_inl.h
+includes some allocation macros that may be used in place of GC_malloc
+and friends.
+
+  All externally visible names in the garbage collector start with "GC_".
+To avoid name conflicts, client code should avoid this prefix, except when
+accessing garbage collector routines or variables.
+
+  There are provisions for allocation with explicit type information.
+This is rarely necessary.  Details can be found in gc_typed.h.
+
+THE C++ INTERFACE TO THE ALLOCATOR:
+
+  The Ellis-Hull C++ interface to the collector is included in
+the collector distribution.  If you intend to use this, type
+"make c++" after the initial build of the collector is complete.
+See gc_cpp.h for the definition of the interface.  This interface
+tries to approximate the Ellis-Detlefs C++ garbage collection
+proposal without compiler changes.
+
+Cautions:
+1. Arrays allocated without new placement syntax are
+allocated as uncollectable objects.  They are traced by the
+collector, but will not be reclaimed.
+
+2. Failure to use "make c++" in combination with (1) will
+result in arrays allocated using the default new operator.
+This is likely to result in disaster without linker warnings.
+
+3. If your compiler supports an overloaded new[] operator,
+then gc_cpp.cc and gc_cpp.h should be suitably modified.
+
+4. Many current C++ compilers have deficiencies that
+break some of the functionality.  See the comments in gc_cpp.h
+for suggested workarounds.
+
+USE AS LEAK DETECTOR:
+
+  The collector may be used to track down leaks in C programs that are
+intended to run with malloc/free (e.g. code with extreme real-time or
+portability constraints).  To do so define FIND_LEAK in Makefile
+This will cause the collector to invoke the report_leak
+routine defined near the top of reclaim.c whenever an inaccessible
+object is found that has not been explicitly freed.  The collector will
+no longer reclaim inaccessible memory; in this form it is purely a
+debugging tool.
+  Productive use of this facility normally involves redefining report_leak
+to do something more intelligent.  This typically requires annotating
+objects with additional information (e.g. creation time stack trace) that
+identifies their origin.  Such code is typically not very portable, and is
+not included here, except on SPARC machines.
+  If all objects are allocated with GC_DEBUG_MALLOC (see next section),
+then the default version of report_leak will report the source file
+and line number at which the leaked object was allocated.  This may
+sometimes be sufficient.  (On SPARC/SUNOS4 machines, it will also report
+a cryptic stack trace.  This can often be turned into a sympolic stack
+trace by invoking program "foo" with "callprocs foo".  Callprocs is
+a short shell script that invokes adb to expand program counter values
+to symbolic addresses.  It was largely supplied by Scott Schwartz.)
+  Note that the debugging facilities described in the next section can
+sometimes be slightly LESS effective in leak finding mode, since in
+leak finding mode, GC_debug_free actually results in reuse of the object.
+(Otherwise the object is simply marked invalid.)  Also note that the test
+program is not designed to run meaningfully in FIND_LEAK mode.
+Use "make gc.a" to build the collector.
+
+DEBUGGING FACILITIES:
+
+  The routines GC_debug_malloc, GC_debug_malloc_atomic, GC_debug_realloc,
+and GC_debug_free provide an alternate interface to the collector, which
+provides some help with memory overwrite errors, and the like.
+Objects allocated in this way are annotated with additional
+information.  Some of this information is checked during garbage
+collections, and detected inconsistencies are reported to stderr.
+
+  Simple cases of writing past the end of an allocated object should
+be caught if the object is explicitly deallocated, or if the
+collector is invoked while the object is live.  The first deallocation
+of an object will clear the debugging info associated with an
+object, so accidentally repeated calls to GC_debug_free will report the
+deallocation of an object without debugging information.  Out of
+memory errors will be reported to stderr, in addition to returning
+NIL.
+
+  GC_debug_malloc checking  during garbage collection is enabled
+with the first call to GC_debug_malloc.  This will result in some
+slowdown during collections.  If frequent heap checks are desired,
+this can be achieved by explicitly invoking GC_gcollect, e.g. from
+the debugger.
+
+  GC_debug_malloc allocated objects should not be passed to GC_realloc
+or GC_free, and conversely.  It is however acceptable to allocate only
+some objects with GC_debug_malloc, and to use GC_malloc for other objects,
+provided the two pools are kept distinct.  In this case, there is a very
+low probablility that GC_malloc allocated objects may be misidentified as
+having been overwritten.  This should happen with probability at most
+one in 2**32.  This probability is zero if GC_debug_malloc is never called.
+
+  GC_debug_malloc, GC_malloc_atomic, and GC_debug_realloc take two
+additional trailing arguments, a string and an integer.  These are not
+interpreted by the allocator.  They are stored in the object (the string is
+not copied).  If an error involving the object is detected, they are printed.
+
+  The macros GC_MALLOC, GC_MALLOC_ATOMIC, GC_REALLOC, GC_FREE, and
+GC_REGISTER_FINALIZER are also provided.  These require the same arguments
+as the corresponding (nondebugging) routines.  If gc.h is included
+with GC_DEBUG defined, they call the debugging versions of these
+functions, passing the current file name and line number as the two
+extra arguments, where appropriate.  If gc.h is included without GC_DEBUG
+defined, then all these macros will instead be defined to their nondebugging
+equivalents.  (GC_REGISTER_FINALIZER is necessary, since pointers to
+objects with debugging information are really pointers to a displacement
+of 16 bytes form the object beginning, and some translation is necessary
+when finalization routines are invoked.  For details, about what's stored
+in the header, see the definition of the type oh in debug_malloc.c)
+
+INCREMENTAL/GENERATIONAL COLLECTION:
+
+The collector normally interrupts client code for the duration of 
+a garbage collection mark phase.  This may be unacceptable if interactive
+response is needed for programs with large heaps.  The collector
+can also run in a "generational" mode, in which it usually attempts to
+collect only objects allocated since the last garbage collection.
+Furthermore, in this mode, garbage collections run mostly incrementally,
+with a small amount of work performed in response to each of a large number of
+GC_malloc requests.
+
+This mode is enabled by a call to GC_enable_incremental().
+
+Incremental and generational collection is effective in reducing
+pause times only if the collector has some way to tell which objects
+or pages have been recently modified.  The collector uses two sources
+of information:
+
+1. Information provided by the VM system.  This may be provided in
+one of several forms.  Under Solaris 2.X (and potentially under other
+similar systems) information on dirty pages can be read from the
+/proc file system.  Under other systems (currently SunOS4.X) it is
+possible to write-protect the heap, and catch the resulting faults.
+On these systems we require that system calls writing to the heap
+(other than read) be handled specially by client code.
+See os_dep.c for details.
+
+2. Information supplied by the programmer.  We define "stubborn"
+objects to be objects that are rarely changed.  Such an object
+can be allocated (and enabled for writing) with GC_malloc_stubborn.
+Once it has been initialized, the collector should be informed with
+a call to GC_end_stubborn_change.  Subsequent writes that store
+pointers into the object must be preceded by a call to
+GC_change_stubborn.
+
+This mechanism performs best for objects that are written only for
+initialization, and such that only one stubborn object is writable
+at once.  It is typically not worth using for short-lived
+objects.  Stubborn objects are treated less efficiently than pointerfree
+(atomic) objects.
+
+A rough rule of thumb is that, in the absence of VM information, garbage
+collection pauses are proportional to the amount of pointerful storage
+plus the amount of modified "stubborn" storage that is reachable during
+the collection.  
+
+Initial allocation of stubborn objects takes longer than allocation
+of other objects, since other data structures need to be maintained.
+
+We recommend against random use of stubborn objects in client
+code, since bugs caused by inappropriate writes to stubborn objects
+are likely to be very infrequently observed and hard to trace.  
+However, their use may be appropriate in a few carefully written
+library routines that do not make the objects themselves available
+for writing by client code.
+
+
+BUGS:
+
+  Any memory that does not have a recognizable pointer to it will be
+reclaimed.  Exclusive-or'ing forward and backward links in a list
+doesn't cut it.
+  Some C optimizers may lose the last undisguised pointer to a memory
+object as a consequence of clever optimizations.  This has almost
+never been observed in practice.  Send mail to boehm@mti.sgi.com
+for suggestions on how to fix your compiler.
+  This is not a real-time collector.  In the standard configuration,
+percentage of time required for collection should be constant across
+heap sizes.  But collection pauses will increase for larger heaps.
+(On SPARCstation 2s collection times will be on the order of 300 msecs
+per MB of accessible memory that needs to be scanned.  Your mileage
+may vary.)  The incremental/generational collection facility helps,
+but is portable only if "stubborn" allocation is used.
+  Please address bug reports to boehm@mti.sgi.com.  If you are
+contemplating a major addition, you might also send mail to ask whether
+it's already been done (or whether we tried and discarded it).
+
+RECENT VERSIONS:
+
+  Version 1.3 and immediately preceding versions contained spurious
+assembly language assignments to TMP_SP.  Only the assignment in the PC/RT
+code is necessary.  On other machines, with certain compiler options,
+the assignments can lead to an unsaved register being overwritten.
+Known to cause problems under SunOS 3.5 WITHOUT the -O option.  (With
+-O the compiler recognizes it as dead code.  It probably shouldn't,
+but that's another story.)
+
+  Version 1.4 and earlier versions used compile time determined values
+for the stack base.  This no longer works on Sun 3s, since Sun 3/80s use
+a different stack base.  We now use a straightforward heuristic on all
+machines on which it is known to work (incl. Sun 3s) and compile-time
+determined values for the rest.  There should really be library calls
+to determine such values.
+
+  Version 1.5 and earlier did not ensure 8 byte alignment for objects
+allocated on a sparc based machine.
+
+  Version 1.8 added ULTRIX support in gc_private.h.
+  
+  Version 1.9 fixed a major bug in gc_realloc.
+  
+  Version 2.0 introduced a consistent naming convention for collector
+routines and added support for registering dynamic library data segments
+in the standard mark_roots.c.  Most of the data structures were revamped.
+The treatment of interior pointers was completely changed.  Finalization
+was added.  Support for locking was added.  Object kinds were added.
+We added a black listing facility to avoid allocating at addresses known
+to occur as integers somewhere in the address space.  Much of this
+was accomplished by adapting ideas and code from the PCR collector.
+The test program was changed and expanded.
+
+  Version 2.1 was the first stable version since 1.9, and added support
+for PPCR.
+
+  Version 2.2 added debugging allocation, and fixed various bugs.  Among them:
+- GC_realloc could fail to extend the size of the object for certain large object sizes.
+- A blatant subscript range error in GC_printf, which unfortunately
+  wasn't exercised on machines with sufficient stack alignment constraints.
+- GC_register_displacement did the wrong thing if it was called after
+  any allocation had taken place.
+- The leak finding code would eventually break after 2048 byte
+  byte objects leaked.
+- interface.c didn't compile.
+- The heap size remained much too small for large stacks.
+- The stack clearing code behaved badly for large stacks, and perhaps
+  on HP/PA machines.
+
+  Version 2.3 added ALL_INTERIOR_POINTERS and fixed the following bugs:
+- Missing declaration of etext in the A/UX version.
+- Some PCR root-finding problems.
+- Blacklisting was not 100% effective, because the plausible future
+  heap bounds were being miscalculated.
+- GC_realloc didn't handle out-of-memory correctly.
+- GC_base could return a nonzero value for addresses inside free blocks.
+- test.c wasn't really thread safe, and could erroneously report failure
+  in a multithreaded environment.  (The locking primitives need to be
+  replaced for other threads packages.)
+- GC_CONS was thoroughly broken.
+- On a SPARC with dynamic linking, signals stayed diabled while the
+  client code was running.
+  (Thanks to Manuel Serrano at INRIA for reporting the last two.)
+  
+  Version 2.4 added GC_free_space_divisor as a tuning knob, added
+  support for OS/2 and linux, and fixed the following bugs:
+- On machines with unaligned pointers (e.g. Sun 3), every 128th word could
+  fail to be considered for marking.
+- Dynamic_load.c erroneously added 4 bytes to the length of the data and
+  bss sections of the dynamic library.  This could result in a bad memory
+  reference if the actual length was a multiple of a page.  (Observed on
+  Sun 3.  Can probably also happen on a Sun 4.)
+  (Thanks to Robert Brazile for pointing out that the Sun 3 version
+  was broken.  Dynamic library handling is still broken on Sun 3s
+  under 4.1.1U1, but apparently not 4.1.1.  If you have such a machine,
+  use -Bstatic.)
+  
+  Version 2.5 fixed the following bugs:
+- Removed an explicit call to exit(1)
+- Fixed calls to GC_printf and GC_err_printf, so the correct number of
+  arguments are always supplied.  The OS/2 C compiler gets confused if
+  the number of actuals and the number of formals differ.  (ANSI C
+  doesn't require this to work.  The ANSI sanctioned way of doing things
+  causes too many compatibility problems.)
+  
+  Version 3.0  added generational/incremental collection and stubborn
+  objects.
+
+  Version 3.1 added the following features:
+- A workaround for a SunOS 4.X SPARC C compiler
+  misfeature that caused problems when the collector was turned into
+  a dynamic library.  
+- A fix for a bug in GC_base that could result in a memory fault.
+- A fix for a performance bug (and several other misfeatures) pointed
+  out by Dave Detlefs and Al Dosser.
+- Use of dirty bit information for static data under Solaris 2.X.
+- DEC Alpha/OSF1 support (thanks to Al Dosser).
+- Incremental collection on more platforms.
+- A more refined heap expansion policy.  Less space usage by default.
+- Various minor enhancements to reduce space usage, and to reduce
+  the amount of memory scanned by the collector.
+- Uncollectable allocation without per object overhead.
+- More conscientious handling of out-of-memory conditions.
+- Fixed a bug in debugging stubborn allocation.
+- Fixed a bug that resulted in occasional erroneous reporting of smashed
+  objects with debugging allocation.
+- Fixed bogus leak reports of size 4096 blocks with FIND_LEAK.
+
+  Version 3.2 fixed a serious and not entirely repeatable bug in
+  the incremental collector.  It appeared only when dirty bit info
+  on the roots was available, which is normally only under Solaris.
+  It also added GC_general_register_disappearing_link, and some
+  testing code.  Interface.c disappeared.
+
+  Version 3.3 fixes several bugs and adds new ports:
+- PCR-specific bugs.
+- Missing locking in GC_free, redundant FASTUNLOCK
+  in GC_malloc_stubborn, and 2 bugs in
+  GC_unregister_disappearing_link.
+  All of the above were pointed out by Neil Sharman
+  (neil@cs.mu.oz.au).
+- Common symbols allocated by the SunOS4.X dynamic loader
+  were not included in the root set.
+- Bug in GC_finalize (reported by Brian Beuning and Al Dosser)
+- Merged Amiga port from Jesper Peterson (untested)
+- Merged NeXT port from Thomas Funke (significantly
+  modified and untested)
+
+  Version 3.4:
+- Fixed a performance bug in GC_realloc.
+- Updated the amiga port.
+- Added NetBSD and 386BSD ports.
+- Added cord library.
+- Added trivial performance enhancement for
+  ALL_INTERIOR_POINTERS.  (Don't scan last word.)
+  
+  Version 3.5
+- Minor collections now mark from roots only once, if that
+  doesn't cause an excessive pause.
+- The stack clearing heuristic was refined to prevent anomalies
+  with very heavily recursive programs and sparse stacks.
+- Fixed a bug that prevented mark stack growth in some cases.
+  GC_objects_are_marked should be set to TRUE after a call
+  to GC_push_roots and as part of GC_push_marked, since
+  both can now set mark bits.  I think this is only a performance
+  bug, but I wouldn't bet on it.  It's certainly very hard to argue
+  that the old version was correct.
+- Fixed an incremental collection bug that prevented it from
+  working at all when HBLKSIZE != getpagesize()
+- Changed dynamic_loading.c to include gc_priv.h before testing
+  DYNAMIC_LOADING.  SunOS dynamic library scanning
+  must have been broken in 3.4.
+- Object size rounding now adapts to program behavior.
+- Added a workaround (provided by Manuel Serrano and
+  colleagues) to a long-standing SunOS 4.X (and 3.X?) ld bug
+  that I had incorrectly assumed to have been squished.
+  The collector was broken if the text segment size was within
+  32 bytes of a multiple of 8K bytes, and if the beginning of
+  the data segment contained interesting roots.  The workaround
+  assumes a demand-loadable executable.  The original may have
+  have "worked" in some other cases.
+- Added dynamic library support under IRIX5.
+- Added support for EMX under OS/2 (thanks to Ari Huttunen).
+  
+Version 3.6:
+- fixed a bug in the mark stack growth code that was introduced
+  in 3.4.
+- fixed Makefile to work around DEC AXP compiler tail recursion
+  bug.
+
+Version 3.7:
+- Added a workaround for an HP/UX compiler bug.
+- Fixed another stack clearing performance bug.  Reworked
+  that code once more.
+  
+Version 4.0:
+- Added support for Solaris threads (which was possible
+  only by reimplementing some fraction of Solaris threads,
+  since Sun doesn't currently make the thread debugging
+  interface available).
+- Added non-threads win32 and win32S support.
+- (Grudgingly, with suitable muttering of obscenities) renamed
+  files so that the collector distribution could live on a FAT
+  file system.  Files that are guaranteed to be useless on
+  a PC still have long names.  Gc_inline.h and gc_private.h
+  still exist, but now just include  gc_inl.h and gc_priv.h.
+- Fixed a really obscure bug in finalization that could cause
+  undetected mark stack overflows.  (I would be surprised if
+  any real code ever tickled this one.)
+- Changed finalization code to dynamically resize the hash
+  tables it maintains.  (This probably does not matter for well-
+  -written code.  It no doubt does for C++ code that overuses
+  destructors.)
+- Added typed allocation primitives.  Rewrote the marker to
+  accommodate them with more reasonable efficiency.  This
+  change should also speed up marking for GC_malloc allocated
+  objects a little.  See gc_typed.h for new primitives.
+- Improved debugging facilities slightly.  Allocation time
+  stack traces are now kept by default on SPARC/SUNOS4.
+  (Thanks to Scott Schwartz.)
+- Added better support for small heap applications.
+- Significantly extended cord package.  Fixed a bug in the
+  implementation of lazily read files.  Printf and friends now
+  have cord variants.  Cord traversals are a bit faster.
+- Made ALL_INTERIOR_POINTERS recognition the default.
+- Fixed de so that it can run in constant space, independent
+  of file size.  Added simple string searching to cords and de.
+- Added the Hull-Ellis C++ interface.
+- Added dynamic library support for OSF/1.
+  (Thanks to Al Dosser and Tim Bingham at DEC.)
+- Changed argument to GC_expand_hp to be expressed
+  in units of bytes instead of heap blocks.  (Necessary
+  since the heap block size now varies depending on
+  configuration.  The old version was never very clean.)
+- Added GC_get_heap_size().  The previous "equivalent"
+  was broken.
+- Restructured the Makefile a bit.  
+
+Since version 4.0:
+- Changed finalization implementation to guarantee that
+  finalization procedures are called outside of the allocation
+  lock, making direct use of the interface a little less dangerous.
+  MAY BREAK EXISTING CLIENTS that assume finalizers
+  are protected by a lock.  Since there seem to be few multithreaded
+  clients that use finalization, this is hopefully not much of
+  a problem.
+- Fixed a gross bug in CORD_prev.
+- Fixed a bug in blacklst.c that could result in unbounded
+  heap growth during startup on machines that do not clear
+  memory obtained from the OS (e.g. win32S).
+- Ported de editor to win32/win32S.  (This is now the only
+  version with a mouse-sensitive UI.)
+- Added GC_malloc_ignore_off_page to allocate large arrays
+  in the presence of ALL_INTERIOR_POINTERS.
+- Changed GC_call_with_alloc_lock to not disable signals in
+  the single-threaded case.
+- Reduced retry count in GC_collect_or_expand for garbage
+  collecting when out of memory.
+- Made uncollectable allocations bypass black-listing, as they
+  should.
+- Fixed a bug in typed_test in test.c that could cause (legitimate)
+  GC crashes.
+- Fixed some potential synchronization problems in finalize.c
+- Fixed a real locking problem in typd_mlc.c.
+- Worked around an AIX 3.2 compiler feature that results in
+  out of bounds memory references.
+- Partially worked around an IRIX5.2 beta problem (which may
+  or may not persist to the final release).
+- Fixed a bug in the heap integrity checking code that could
+  result in explicitly deallocated objects being identified as
+  smashed.  Fixed a bug in the dbg_mlc stack saving code
+  that caused old argument pointers to be considered live.
+- Fixed a bug in CORD_ncmp (and hence CORD_str).
+- Repaired the OS2 port, which had suffered from bit rot
+  in 4.0.  Worked around what appears to be CSet/2 V1.0
+  optimizer bug.
+- Fixed a Makefile bug for target "c++".
+
+Since version 4.1:
+- Multiple bug fixes/workarounds in the Solaris threads version.
+  (It occasionally failed to locate some register contents for
+  marking.  It also turns out that thr_suspend and friends are
+  unreliable in Solaris 2.3.  Dirty bit reads appear
+  to be unreliable under some weird 
+  circumstances.  My stack marking code
+  contained a serious performance bug.  The new code is
+  extremely defensive, and has not failed in several cpu
+  hours of testing.  But  no guarantees ...)
+- Added MacOS support (thanks to Patrick Beard.)
+- Fixed several syntactic bugs in gc_c++.h and friends.  (These
+  didn't bother g++, but did bother most other compilers.)
+  Fixed gc_c++.h finalization interface.  (It didn't.)
+- 64 bit alignment for allocated objects was not guaranteed in a
+  few cases in which it should have been.
+- Added GC_malloc_atomic_ignore_off_page.
+- Added GC_collect_a_little.
+- Added some prototypes to gc.h.
+- Some other minor bug fixes (notably in Makefile).
+- Fixed OS/2 / EMX port (thanks to Ari Huttunen).
+- Fixed AmigaDOS port. (thanks to Michel Schinz).
+- Fixed the DATASTART definition under Solaris.  There
+  was a 1 in 16K chance of the collector missing the first
+  64K of static data (and thus crashing).
+- Fixed some blatant anachronisms in the README file.
+- Fixed PCR-Makefile for upcoming PPCR release.
+
+Since version 4.2:
+- Fixed SPARC alignment problem with GC_DEBUG.
+- Fixed Solaris threads /proc workaround.  The real
+  problem was an interaction with mprotect.
+- Incorporated fix from Patrick Beard for gc_c++.h (now gc_cpp.h).
+- Slightly improved allocator space utilization by
+  fixing the GC_size_map mechanism.
+- Integrated some Sony News and MIPS RISCos 4.51
+  patches.  (Thanks to Nobuyuki Hikichi of
+  Software Research Associates, Inc. Japan)
+- Fixed HP_PA alignment problem.  (Thanks to
+  xjam@cork.cs.berkeley.edu.)
+- Added GC_same_obj and friends.  Changed GC_base
+  to return 0 for pointers past the end of large objects.
+  Improved GC_base performance with ALL_INTERIOR_POINTERS
+  on machines with a slow integer mod operation.
+  Added GC_PTR_ADD, GC_PTR_STORE, etc. to prepare
+  for preprocessor.
+- changed the default on most UNIX machines to be that
+  signals are not disabled during critical GC operations.
+  This is still ANSI-conforming, though somewhat dangerous
+  in the presence of signal handlers. But the performance
+  cost of the alternative is sometimes problematic.
+  Can be changed back with a minor Makefile edit.
+- renamed IS_STRING in gc.h, to CORD_IS_STRING, thus
+  following my own naming convention.  Added the function
+  CORD_to_const_char_star.
+- Fixed a gross bug in GC_finalize.  Symptom: occasional
+  address faults in that function.  (Thanks to Anselm
+  Baird-Smith (Anselm.BairdSmith@inria.fr)
+- Added port to ICL DRS6000 running DRS/NX.  Restructured
+  things a bit to factor out common code, and remove obsolete
+  code.  Collector should now run under SUNOS5 with either
+  mprotect or /proc dirty bits.  (Thanks to Douglas Steel
+  (doug@wg.icl.co.uk)).
+- More bug fixes and workarounds for Solaris 2.X.  (These were
+  mostly related to putting the collector in a dynamic library,
+  which didn't really work before.  Also SOLARIS_THREADS
+  didn't interact well with dl_open.)  Thanks to btlewis@eng.sun.com.
+- Fixed a serious performance bug on the DEC Alpha.  The text
+  segment was getting registered as part of the root set.
+  (Amazingly, the result was still fast enough that the bug
+  was not conspicuous.) The fix works on OSF/1, version 1.3.
+  Hopefully it also works on other versions of OSF/1 ...
+- Fixed a bug in GC_clear_roots.
+- Fixed a bug in GC_generic_malloc_words_small that broke
+  gc_inl.h.  (Reported by Antoine de Maricourt.  I broke it
+  in trying to tweak the Mac port.) 
+- Fixed some problems with cord/de under Linux.
+- Fixed some cord problems, notably with CORD_riter4.
+- Added DG/UX port.
+  Thanks to Ben A. Mesander (ben@piglet.cr.usgs.gov)
+- Added finalization registration routines with weaker ordering
+  constraints.  (This is necessary for C++ finalization with
+  multiple inheritance, since the compiler often adds self-cycles.)
+- Filled the holes in the SCO port. (Thanks to Michael Arnoldus
+  <chime@proinf.dk>.)
+- John Ellis' additions to the C++ support:  From John:
+
+* I completely rewrote the documentation in the interface gc_c++.h
+(later renamed gc_cpp.h).  I've tried to make it both clearer and more
+precise.
+
+* The definition of accessibility now ignores pointers from an
+finalizable object (an object with a clean-up function) to itself.
+This allows objects with virtual base classes to be finalizable by the
+collector.  Compilers typically implement virtual base classes using
+pointers from an object to itself, which under the old definition of
+accessibility prevented objects with virtual base classes from ever
+being collected or finalized.
+
+* gc_cleanup now includes gc as a virtual base.  This was enabled by
+the change in the definition of accessibility.
+
+* I added support for operator new[].  Since most (all?) compilers
+don't yet support operator new[], it is conditionalized on
+-DOPERATOR_NEW_ARRAY.  The code is untested, but its trivial and looks
+correct.
+
+* The test program test_gc_c++ (later renamed test_cpp.cc)
+tries to test for the C++-specific functionality not tested by the
+other programs.
+- Added <unistd.h> include to misc.c.  (Needed for ppcr.)
+- Added PowerMac port. (Thanks to Patrick Beard again.)
+- Fixed "srcdir"-related Makefile problems.  Changed things so
+  that all externally visible include files always appear in the
+  include subdirectory of the source.  Made gc.h directly
+  includable from C++ code.  (These were at Per
+  Bothner's suggestion.)
+- Changed Intel code to also mark from ebp (Kevin Warne's
+  suggestion).
+- Renamed C++ related files so they could live in a FAT
+  file system. (Charles Fiterman's suggestion.)
+- Changed Windows NT Makefile to include C++ support in
+  gc.lib.  Added C++ test as Makefile target.
+  
+Since version 4.3:
+ - ASM_CLEAR_CODE was erroneously defined for HP
+   PA machines, resulting in a compile error.
+ - Fixed OS/2 Makefile to create a library.  (Thanks to
+   Mark Boulter (mboulter@vnet.ibm.com)).
+ - Gc_cleanup objects didn't work if they were created on
+   the stack.  Fixed.
+ - One copy of Gc_cpp.h in the distribution was out of 
+   synch, and failed to document some known compiler
+   problems with explicit destructor invocation.  Partially
+   fixed.  There are probably other compilers on which
+   gc_cleanup is miscompiled.
+ - Fixed Makefile to pass C compiler flags to C++ compiler.
+ - Added Mac fixes.
+ - Fixed os_dep.c to work around what appears to be
+   a new and different VirtualQuery bug under newer
+   versions of win32S.
+ - GC_non_gc_bytes was not correctly maintained by
+   GC_free.  Fixed.  Thanks to James Clark (jjc@jclark.com).
+ - Added GC_set_max_heap_size.
+ - Changed allocation code to ignore blacklisting if it is preventing
+   use of a very large block of memory.  This has the advantage
+   that naive code allocating very large objects is much more
+   likely to work.  The downside is you might no
+   longer find out that such code should really use
+   GC_malloc_ignore_off_page.
+ - Changed GC_printf under win32 to close and reopen the file
+   between calls.  FAT file systems otherwise make the log file
+   useless for debugging.
+ - Added GC_try_to_collect and GC_get_bytes_since_gc.  These
+   allow starting an abortable collection during idle times. 
+   This facility does not require special OS support.  (Thanks to
+   Michael Spertus of Geodesic Systems for suggesting this.  It was
+   actually an easy addition.  Kumar Srikantan previously added a similar
+   facility to a now ancient version of the collector.  At the time
+   this was much harder, and the result was less convincing.)
+ - Added some support for the Borland development environment.  (Thanks
+   to John Ellis and Michael Spertus.)
+ - Removed a misfeature from checksums.c that caused unexpected 
+   heap growth.  (Thanks to Scott Schwartz.)
+ - Changed finalize.c to call WARN if it encounters a finalization cycle.
+   WARN is defined in gc_priv.h to write a message, usually to stdout.
+   In many environments, this may be inappropriate.
+ - Renamed NO_PARAMS in gc.h to GC_NO_PARAMS, thus adhering to my own
+   naming convention.
+ - Added GC_set_warn_proc to intercept warnings.
+ - Fixed Amiga port. (Thanks to Michel Schinz (schinz@alphanet.ch).)
+ - Fixed a bug in mark.c that could result in an access to unmapped
+   memory from GC_mark_from_mark_stack on machines with unaligned
+   pointers.
+ - Fixed a win32 specific performance bug that could result in scanning of
+   objects allocated with the system malloc.
+ - Added REDIRECT_MALLOC.
+
+Since version 4.4:
+ - Fixed many minor and one major README bugs. (Thanks to Franklin Chen
+   (chen@adi.com) for pointing out many of them.)
+ - Fixed ALPHA/OSF/1 dynamic library support. (Thanks to Jonathan Bachrach
+   (jonathan@harlequin.com)).
+ - Added incremental GC support (MPROTECT_VDB) for Linux (with some
+   help from Bruno Haible).
+ - Altered SPARC recognition tests in gc.h and config.h (mostly as
+   suggested by Fergus Henderson).
+ - Added basic incremental GC support for win32, as implemented by
+   Windows NT and Windows 95.  GC_enable_incremental is a noop
+   under win32s, which doesn't implement enough of the VM interface.
+ - Added -DLARGE_CONFIG.
+ - Fixed GC_..._ignore_off_page to also function without
+   -DALL_INTERIOR_POINTERS.
+ - (Hopefully) fixed RS/6000 port.  (Only the test was broken.)
+ - Fixed a performance bug in the nonincremental collector running
+   on machines supporting incremental collection with MPROTECT_VDB
+   (e.g. SunOS 4, DEC AXP).  This turned into a correctness bug under
+   win32s with win32 incremental collection.  (Not all memory protection
+   was disabled.)
+ - Fixed some ppcr related bit rot.
+ - Caused dynamic libraries to be unregistered before reregistering.
+   The old way turned out to be a performance bug on some machines.
+ - GC_root_size was not properly maintained under MSWIN32.
+ - Added -DNO_DEBUGGING and GC_dump.
+ - Fixed a couple of bugs arising with SOLARIS_THREADS +
+   REDIRECT_MALLOC.
+ - Added NetBSD/M68K port.  (Thanks to Peter Seebach
+   <seebs@taniemarie.solon.com>.)
+ - Fixed a serious realloc bug.  For certain object sizes, the collector
+   wouldn't scan the expanded part of the object.  (Thanks to Clay Spence
+   (cds@peanut.sarnoff.com) for noticing the problem, and helping me to
+   track it down.)
+   
+Since version 4.5:
+ - Added Linux ELF support.  (Thanks to Arrigo Triulzi <arrigo@ic.ac.uk>.)
+ - GC_base crashed if it was called before any other GC_ routines.
+   This could happen if a gc_cleanup object was allocated outside the heap
+   before any heap allocation.
+ - The heap expansion heuristic was not stable if all objects had finalization
+   enabled.  Fixed finalize.c to count memory in finalization queue and
+   avoid explicit deallocation.  Changed alloc.c to also consider this count.
+   (This is still not recommended.  It's expensive if nothing else.)  Thanks
+   to John Ellis for pointing this out.
+ - GC_malloc_uncollectable(0) was broken.  Thanks to Phong Vo for pointing
+   this out.
+ - The collector didn't compile under Linux 1.3.X.  (Thanks to Fred Gilham for
+   pointing this out.)  The current workaround is ugly, but expected to be
+   temporary.
+ - Fixed a formatting problem for SPARC stack traces.
+ - Fixed some '=='s in os_dep.c that should have been assignments.
+   Fortunately these were in code that should never be executed anyway.
+   (Thanks to Fergus Henderson.)
+ - Fixed the heap block allocator to only drop blacklisted blocks in small
+   chunks.  Made BL_LIMIT self adjusting.  (Both of these were in response
+   to heap growth observed by Paul Graham.)
+ - Fixed the Metrowerks/68K Mac code to also mark from a6.  (Thanks
+   to Patrick Beard.)
+ - Significantly updated README.debugging.
+ - Fixed some problems with longjmps out of signal handlers, especially under
+   Solaris.  Added a workaround for the fact that siglongjmp doesn't appear to
+   do the right thing with -lthread under Solaris.
+ - Added MSDOS/djgpp port.  (Thanks to Mitch Harris  (maharri@uiuc.edu).)
+ - Added "make reserved_namespace" and "make user_namespace".  The
+   first renames ALL "GC_xxx" identifiers as "_GC_xxx".  The second is the
+   inverse transformation.  Note that doing this is guaranteed to break all
+   clients written for the other names.
+ - descriptor field for kind NORMAL in GC_obj_kinds with ADD_BYTE_AT_END
+   defined should be -ALIGNMENT not WORDS_TO_BYTES(-1).  This is
+   a serious bug on machines with pointer alignment of less than a word.
+ - GC_ignore_self_finalize_mark_proc didn't handle pointers to very near the
+   end of the object correctly.  Caused failures of the C++ test on a DEC Alpha
+   with g++.
+ - gc_inl.h still had problems.  Partially fixed.  Added warnings at the
+   beginning to hopefully specify the remaining dangers.
+ - Added DATAEND definition to config.h.
+ - Fixed some of the .h file organization.  Fixed "make floppy".
+ 
+Since version 4.6:
+ - Fixed some compilation problems with -DCHECKSUMS (thanks to Ian Searle)
+ - Updated some Mac specific files to synchronize with Patrick Beard.
+ - Fixed a serious bug for machines with non-word-aligned pointers.
+   (Thanks to Patrick Beard for pointing out the problem.  The collector
+   should fail almost any conceivable test immediately on such machines.)
+
+Since version 4.7:
+ - Changed a "comment" in a MacOS specific part of mach-dep.c that caused
+   gcc to fail on other platforms.
+
+Since version 4.8
+ - More README.debugging fixes.
+ - Objects ready for finalization, but not finalized in the same GC
+   cycle, could be prematurely collected.  This occasionally happened
+   in test_cpp.
+ - Too little memory was obtained from the system for very large
+   objects.  That could cause a heap explosion if these objects were
+   not contiguous (e.g. under PCR), and too much of them was blacklisted.
+ - Due to an improper initialization, the collector was too hesitant to
+   allocate blacklisted objects immediately after system startup.
+ - Moved GC_arrays from the data into the bss segment by not explicitly
+   initializing it to zero.  This significantly
+   reduces the size of executables, and probably avoids some disk accesses
+   on program startup.  It's conceivable that it might break a port that I
+   didn't test.
+ - Fixed EMX_MAKEFILE to reflect the gc_c++.h to gc_cpp.h renaming which
+   occurred a while ago.
+
+Since 4.9:
+ - Fixed a typo around a call to GC_collect_or_expand in alloc.c.  It broke
+   handling of out of memory.  (Thanks to Patrick Beard for noticing.)
+
+Since 4.10:
+ - Rationalized (hopefully) GC_try_to_collect in an incremental collection
+   environment.  It appeared to not handle a call while a collection was in
+   progress, and was otherwise too conservative.
+ - Merged GC_reclaim_or_delete_all into GC_reclaim_all to get rid of some
+   code.
+ - Added Patrick Beard's Mac fixes, with substantial completely untested
+   modifications.
+ - Fixed the MPROTECT_VDB code to deal with large pages and imprecise
+   fault addresses (as on an UltraSPARC running Solaris 2.5).  Note that this
+   was not a problem in the default configuration, which uses PROC_VDB.
+ - The DEC Alpha assembly code needed to restore $gp between calls.
+   Thanks to Fergus Henderson for tracking this down and supplying a
+   patch.
+ - The write command for "de" was completely broken for large files.
+   I used the easiest portable fix, which involved changing the semantics
+   so that f.new is written instead of overwriting f.  That's safer anyway.
+ - Added README.solaris2 with a discussion of the possible problems of
+   mixing the collector's sbrk allocation with malloc/realloc.
+ - Changed the data segment starting address for SGI machines.  The
+   old code failed under IRIX6.
+ - Required double word alignment for MIPS.
+ - Various minor fixes to remove warnings.
+ - Attempted to fix some Solaris threads problems reported by Zhiying Chen.
+   In particular, the collector could try to fork a thread with the
+   world stopped as part of GC_thr_init.  It also failed to deal with
+   the case in which the original thread terminated before the whole
+   process did.
+ - Added -DNO_EXECUTE_PERMISSION.  This has a major performance impact
+   on the incremental collector under Irix, and perhaps under other
+   operating systems.
+ - Added some code to support allocating the heap with mmap.  This may
+   be preferable under some circumstances.
+ - Integrated dynamic library support for HP.
+   (Thanks to Knut Tvedten <knuttv@ifi.uio.no>.)
+ - Integrated James Clark's win32 threads support, and made a number
+   of changes to it, many of which were suggested by Pontus Rydin.
+   This is still not 100% solid.
+ - Integrated Alistair Crooks' support for UTS4 running on an Amdahl
+   370-class machine.
+ - Fixed a serious bug in explicitly typed allocation.  Objects requiring
+   large descriptors where handled in a way that usually resulted in
+   a segmentation fault in the marker.  (Thanks to Jeremy Fitzhardinge
+   for helping to track this down.)
+ - Added partial support for GNU win32 development.  (Thanks to Fergus
+   Henderson.)
+ - Added optional support for Java-style finalization semantics.  (Thanks
+   to Patrick Bridges.)  This is recommended only for Java implementations.
+ - GC_malloc_uncollectable faulted instead of returning 0 when out of
+   memory.  (Thanks to dan@math.uiuc.edu for noticing.)
+ - Calls to GC_base before the collector was initialized failed on a
+   DEC Alpha.  (Thanks to Matthew Flatt.)
+ - Added base pointer checking to GC_REGISTER_FINALIZER in debugging
+   mode, at the suggestion of Jeremy Fitzhardinge.
+ - GC_debug_realloc failed for uncollectable objects.  (Thanks to
+   Jeremy Fitzhardinge.)
+ - Explicitly typed allocation could crash if it ran out of memory.
+   (Thanks to Jeremy Fitzhardinge.)
+ - Added minimal support for a DEC Alpha running Linux.
+ - Fixed a problem with allocation of objects whose size overflowed
+   ptrdiff_t.  (This now fails unconditionally, as it should.)
+ - Added the beginning of Irix pthread support.
+ - Integrated Xiaokun Zhu's fixes for djgpp 2.01.
+ - Added SGI-style STL allocator support (gc_alloc.h).
+ - Fixed a serious bug in README.solaris2.  Multithreaded programs must include
+   gc.h with SOLARIS_THREADS defined.
+ - Changed GC_free so it actually deallocates uncollectable objects.
+   (Thanks to Peter Chubb for pointing out the problem.)
+ - Added Linux ELF support for dynamic libararies.  (Thanks again to
+   Patrick Bridges.)
+ - Changed the Borland cc configuration so that the assembler is not
+   required.
+ - Fixed a bug in the C++ test that casued it to fail in 64-bit
+   environments.
diff --git a/src/mzscheme/gc/README.Mac b/src/mzscheme/gc/README.Mac
new file mode 100644
index 0000000..180de7e
--- /dev/null
+++ b/src/mzscheme/gc/README.Mac
@@ -0,0 +1,50 @@
+README.Mac
+----------
+
+v4.3 of the collector now runs under Symantec C++/THINK C v7.0.4, and
+Metrowerks C/C++ v4.5 both 68K and PowerPC. Project files are provided
+to build and test the collector under both development systems.
+
+Configuration
+-------------
+
+To configure the collector, under both development systems, a prefix file
+is used to set preprocessor directives. This file is called "MacOS_config.h".
+Also to test the collector, "MacOS_Test_config.h" is provided.
+
+Testing
+-------
+
+To test the collector (always a good idea), build one of the gctest projects,
+gctest.¹ (Symantec C++/THINK C), mw/gctest.68K.¹, or mw/gctest.PPC.¹. The
+test will ask you how many times to run; 1 should be sufficient.
+
+Building 
+--------
+
+For your convenience project files for the major Macintosh development
+systems are provided.
+
+For Symantec C++/THINK C, you must build the two projects gclib-1.¹ and
+gclib-2.¹. It has to be split up because the collector has more than 32k
+of static data and no library can have more than this in the Symantec
+environment. (Future versions will probably fix this.)
+
+For Metrowerks C/C++ 4.5 you build gc.68K.¹/gc.PPC.¹ and the result will
+be a library called gc.68K.lib/gc.PPC.lib.
+
+Using
+-----
+
+Under Symantec C++/THINK C, you can just add the gclib-1.¹ and gclib-2.¹
+projects to your own project. Under Metrowerks, you add gc.68K.lib or
+gc.PPC.lib and two additional files. You add the files called datastart.c
+and dataend.c to your project, bracketing all files that use the collector.
+See mw/gctest.¹ for an example.
+
+Include the projects/libraries you built above into your own project,
+#include "gc.h", and call GC_malloc. You don't have to call GC_free.
+
+
+Patrick C. Beard
+January 4, 1995
diff --git a/src/mzscheme/gc/README.OS2 b/src/mzscheme/gc/README.OS2
new file mode 100644
index 0000000..5345bbd
--- /dev/null
+++ b/src/mzscheme/gc/README.OS2
@@ -0,0 +1,6 @@
+The code assumes static linking, and a single thread.  The editor de has
+not been ported.  The cord test program has.  The supplied OS2_MAKEFILE
+assumes the IBM C Set/2 environment, but the code shouldn't.
+
+Since we haven't figured out hoe to do perform partial links or to build static
+libraries, clients currently need to link against a long list of executables.
diff --git a/src/mzscheme/gc/README.QUICK b/src/mzscheme/gc/README.QUICK
new file mode 100644
index 0000000..3273c8b
--- /dev/null
+++ b/src/mzscheme/gc/README.QUICK
@@ -0,0 +1,41 @@
+Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+Permission is hereby granted to use or copy this program
+for any purpose,  provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is granted,
+provided the above notices are retained, and a notice that the code was
+modified is included with the above copyright notice.
+
+
+For more details and the names of other contributors, see the
+README file and gc.h.  This file describes typical use of
+the collector on a machine that is already supported.
+
+INSTALLATION:
+Under UN*X, type "make test".  Under OS/2 or Windows NT, copy the
+appropriate makefile to MAKEFILE, read it, and type "nmake test".
+Read the machine specific README if one exists.  The only way to
+develop code with the collector for Windows 3.1 is to develop under
+Windows NT, and then to use win32S.
+
+If you wish to use the cord (structured string) library type
+"make cords". (This requires an ANSI C compiler.  You may need
+to redefine CC in the Makefile.)
+
+If you wish to use the collector from C++, type
+"make c++".  These add further files to gc.a and to the include
+subdirectory.  See cord/cord.h and gc_c++.h.
+
+TYPICAL USE:
+Include "gc.h" from this directory.  Link against the appropriate library
+("gc.a" under UN*X).  Replace calls to malloc by calls to GC_MALLOC,
+and calls to realloc by calls to GC_REALLOC.  If the object is known
+to never contain pointers, use GC_MALLOC_ATOMIC instead of
+GC_MALLOC.
+
+Define GC_DEBUG before including gc.h for additional checking.
+
diff --git a/src/mzscheme/gc/README.amiga b/src/mzscheme/gc/README.amiga
new file mode 100644
index 0000000..865642b
--- /dev/null
+++ b/src/mzscheme/gc/README.amiga
@@ -0,0 +1,133 @@
+
+===========================================================================
+			   Michel Schinz's notes
+===========================================================================
+WHO DID WHAT
+
+The original Amiga port was made by Jesper Peterson. I (Michel Schinz)
+modified it slightly to reflect the changes made in the new official
+distributions, and to take advantage of the new SAS/C 6.x features. I also
+created a makefile to compile the "cord" package (see the cord
+subdirectory).
+
+TECHNICAL NOTES
+
+In addition to Jesper's notes, I have the following to say:
+
+- Starting with version 4.3, gctest checks to see if the code segment is
+  added to the root set or not, and complains if it is. Previous versions
+  of this Amiga port added the code segment to the root set, so I tried to
+  fix that. The only problem is that, as far as I know, it is impossible to
+  know which segments are code segments and which are data segments (there
+  are indeed solutions to this problem, like scanning the program on disk
+  or patch the LoadSeg functions, but they are rather complicated). The
+  solution I have chosen (see os_dep.c) is to test whether the program
+  counter is in the segment we are about to add to the root set, and if it
+  is, to skip the segment. The problems are that this solution is rather
+  awkward and that it works only for one code segment. This means that if
+  your program has more than one code segment, all of them but one will be
+  added to the root set. This isn't a big problem in fact, since the
+  collector will continue to work correctly, but it may be slower.
+
+  Anyway, the code which decides whether to skip a segment or not can be
+  removed simply by not defining AMIGA_SKIP_SEG. But notice that if you do
+  so, gctest will complain (it will say that "GC_is_visible produced wrong
+  failure indication"). However, it may be useful if you happen to have
+  pointers stored in a code segment (you really shouldn't).
+
+  If anyone has a good solution to the problem of finding, when a program
+  is loaded in memory, whether a segment is a code or a data segment,
+  please let me know.
+
+PROBLEMS
+
+If you have any problem with this version, please contact me at
+schinz@alphanet.ch (but do *not* send long files, since we pay for
+every mail!).
+
+===========================================================================
+			  Jesper Peterson's notes
+===========================================================================
+
+ADDITIONAL NOTES FOR AMIGA PORT
+
+These notes assume some familiarity with Amiga internals.
+
+WHY I PORTED TO THE AMIGA
+
+The sole reason why I made this port was as a first step in getting
+the Sather(*) language on the Amiga. A port of this language will
+be done as soon as the Sather 1.0 sources are made available to me.
+Given this motivation, the garbage collection (GC) port is rather
+minimal.
+
+(*) For information on Sather read the comp.lang.sather newsgroup.
+
+LIMITATIONS
+
+This port assumes that the startup code linked with target programs
+is that supplied with SAS/C versions 6.0 or later. This allows
+assumptions to be made about where to find the stack base pointer
+and data segments when programs are run from WorkBench, as opposed
+to running from the CLI. The compiler dependent code is all in the
+GC_get_stack_base() and GC_register_data_segments() functions, but
+may spread as I add Amiga specific features.
+
+Given that SAS/C was assumed, the port is set up to be built with
+"smake" using the "SMakefile". Compiler options in "SCoptions" can
+be set with "scopts" program. Both "smake" and "scopts" are part of
+the SAS/C commercial development system.
+
+In keeping with the porting philosophy outlined above, this port
+will not behave well with Amiga specific code. Especially not inter-
+process comms via messages, and setting up public structures like
+Intuition objects or anything else in the system lists. For the
+time being the use of this library is limited to single threaded
+ANSI/POSIX  compliant or near-complient code. (ie. Stick to stdio
+for now). Given this limitation there is currently no mechanism for
+allocating "CHIP" or "PUBLIC" memory under the garbage collector.
+I'll add this after giving it considerable thought. The major
+problem is the entire physical address space may have to me scanned,
+since there is no telling who we may have passed memory to.
+
+If you allocate your own stack in client code, you will have to
+assign the pointer plus stack size to GC_stackbottom.
+
+The initial stack size of the target program can be compiled in by
+setting the __stack symbol (see SAS documentaion). It can be over-
+ridden from the CLI by running the AmigaDOS "stack" program, or from
+the WorkBench by setting the stack size in the tool types window.
+
+SAS/C COMPILER OPTIONS (SCoptions)
+
+You may wish to check the "CPU" code option is appropriate for your
+intended target system.
+
+Under no circumstances set the "StackExtend" code option in either
+compiling the library or *ANY* client code.
+
+All benign compiler warnings have been suppressed. These mainly
+involve lack of prototypes in the code, and dead assignments
+detected by the optimizer.
+
+THE GOOD NEWS
+
+The library as it stands is compatible with the GigaMem commercial
+virtual memory software, and probably similar PD software.
+
+The performance of "gctest" on an Amiga 2630 (68030 @ 25Mhz)
+compares favourably with an HP9000 with similar architecture (a 325
+with a 68030 I think).
+
+-----------------------------------------------------------------------
+
+The Amiga port has been brought to you by:
+
+Jesper Peterson.
+
+jep@mtiame.mtia.oz.au		(preferred, but 1 week turnaround)
+jep@orca1.vic.design.telecom.au (that's orca<one>, 1 day turnaround)
+
+At least one of these addresses should be around for a while, even
+though I don't work for either of the companies involved.
+
diff --git a/src/mzscheme/gc/README.debugging b/src/mzscheme/gc/README.debugging
new file mode 100644
index 0000000..80635c2
--- /dev/null
+++ b/src/mzscheme/gc/README.debugging
@@ -0,0 +1,58 @@
+Debugging suggestions:
+
+****If you get a segmentation fault or bus error while debugging with a debugger:
+If the fault occurred in GC_find_limit, or with incremental collection enabled, this is probably normal.  The collector installs handlers to take care of these.  You will not see these unless you are using a debugger.  Your debugger should allow you to continue.  It's preferable to tell the debugger to ignore SIGBUS and SIGSEGV ("handle" in gdb, "ignore" in most versions of dbx) and set a breakpoint in abort.  The collector will call abort if the signal had another cause, and there was not other handler previously installed.  I recommend debugging without incremental collection if possible.  (This applies directly to UNIX systems.  Debugging with incremental collection under win32 is worse.  See README.win32.)  
+
+****If you get warning messages informing you that the collector needed to allocate blacklisted blocks:
+
+0) Ignore these warnings while you are using GC_DEBUG.  Some of the routines mentioned below don't have debugging equivalents.  (Alternatively, write the missing routines and send them to me.)
+
+1) Replace allocator calls that request large blocks with calls to GC_malloc_ignore_off_page or GC_malloc_atomic_ignore_off_page.  You may want to set a breakpoint in GC_default_warn_proc to help you identify such calls.  Make sure that a pointer to somewhere near the beginning of the resulting block is maintained in a (preferably volatile) variable as long as the block is needed.
+
+2) If the large blocks are allocated with realloc, I suggest instead allocating them with something like the following.  Note that the realloc size increment should be fairly large (e.g. a factor of 3/2) for this to exhibit reasonable performance.  But we all know we should do that anyway.
+
+void * big_realloc(void *p, size_t new_size)
+{
+    size_t old_size = GC_size(p);
+    void * result;
+ 
+    if (new_size <= 10000) return(GC_realloc(p, new_size));
+    if (new_size <= old_size) return(p);
+    result = GC_malloc_ignore_off_page(new_size);
+    if (result == 0) return(0);
+    memcpy(result,p,old_size);
+    GC_free(p);
+    return(result);
+}
+
+3) In the unlikely case that even relatively small object (<20KB) allocations are triggering these warnings, then your address space contains lots of "bogus pointers", i.e. values that appear to be pointers but aren't.  Usually this can be solved by using GC_malloc_atomic or the routines in gc_typed.h to allocate large pointerfree regions of bitmaps, etc.  Sometimes the problem can be solved with trivial changes of encoding in certain values.  It is possible, though not pleasant, to identify the source of the bogus pointers by setting a breakpoint in GC_add_to_black_list_stack, and looking at the value of current_p in the GC_mark_from_mark_stack frame.  Current_p contains the address of the bogus pointer.
+
+4) If you get only a fixed number of these warnings, you are probably only introducing a bounded leak by ignoring them.  If the data structures being allocated are intended to be permanent, then it is also safe to ignore them.  The warnings can be turned off by calling GC_set_warn_proc with a procedure that ignores these warnings (e.g. by doing absolutely nothing).
+
+
+****If the collector dies in GC_malloc while trying to remove a free list element:
+
+1) With > 99% probability, you wrote past the end of an allocated object.  Try setting GC_DEBUG and using the debugging facilities in gc.h.
+
+
+****If the heap grows too much:
+
+1) Consider using GC_malloc_atomic for objects containing nonpointers.  This is especially important for large arrays containg compressed data, pseudo-random numbers, and the like.  (This isn't all that likely to solve your problem, but it's a useful and easy optimization anyway, and this is a good time to try it.)   If you allocate large objects containg only one or two pointers at the beginning, either try the typed allocation primitives is gc.h, or separate out the pointerfree component.
+2) If you are using the collector in its default mode, with interior pointer recognition enabled, consider using GC_malloc_ignore_off_page to allocate large objects.  (See gc.h and above for details.  Large means > 100K in most environments.)
+3) GC_print_block_list() will print a list of all currently allocated heap blocks and what size objects they contain.  GC_print_hblkfreelist() will print a list of free heap blocks, and whether they are blacklisted.  GC_dump calls both of these, and also prints information about heap sections, and root segments.
+4) Write a tool that traces back references to the appropriate root.  Send me the code.  (I have code that does this for old PCR.)
+
+
+****If the collector appears to be losing objects:
+
+1) Replace all calls to GC_malloc_atomic and typed allocation by GC_malloc calls.  If this fixes the problem, gradually reinsert your optimizations.
+2) You may also want to try the safe(r) pointer manipulation primitives in gc.h.  But those are hard to use until the preprocessor becomes available.
+3) Try using the GC_DEBUG facilities.  This is less likely to be successful here than if the collector crashes.
+[The rest of these are primarily for wizards.  You shouldn't need them unless you're doing something really strange, or debugging a collector port.]
+4) Don't turn on incremental collection.  If that fixes the problem, suspect a bug in the dirty bit implementation.  Try compiling with -DCHECKSUMS to check for modified, but supposedly clean, pages.
+5) On a SPARC, in a single-threaded environment, GC_print_callers(GC_arrays._last_stack) prints a cryptic stack trace as of the time of the last collection.  (You will need a debugger to decipher the result.)  The question to ask then is "why should this object have been accessible at the time of the last collection?  Where was a pointer to it stored?".  This facility should be easy to add for some other collector ports (namely if it's easy to traverse stack frames), but will be hard for others.
+6) "print *GC_find_header(p)" in dbx or gdb will print the garbage collector block header information associated with the object p (e.g. object size, etc.)
+7) GC_is_marked(p) determines whether p is the base address of a marked object.  Note that objects allocated since the last collection should not be marked, and that unmarked objects are reclaimed incrementally.  It's usually most interesting to set a breakpoint in GC_finish_collection and then to determine how much of the damaged data structure is marked at that point.
+8) Look at the tracing facility in mark.c.  (Ignore this suggestion unless you are very familiar with collector internals.)
+
+
diff --git a/src/mzscheme/gc/README.dj b/src/mzscheme/gc/README.dj
new file mode 100644
index 0000000..0462c38
--- /dev/null
+++ b/src/mzscheme/gc/README.dj
@@ -0,0 +1,19 @@
+[Partially supplied by Xiaokun Zhu <xiaokun@aero.gla.ac.uk>]
+
+There is no caddr_t in djgpp 2.01 so the following declaration was added to
+os_dep.c. It may need to be removed for other versions.
+
+	typedef caddr_t long unsigned int;
+
+
+Use Makefile.dj to compile it :
+
+	C> make -f Makefile.dj test
+
+
+!!! setjmp_t.exe works fine.
+!!! gctest.exe works fine.
+!!! cordtest.exe fail.
+!!! test_cpp.exe works fine.
+
+In some cases it may be necessary to explicitly set GC_stackbottom.
diff --git a/src/mzscheme/gc/README.hp b/src/mzscheme/gc/README.hp
new file mode 100644
index 0000000..70490b9
--- /dev/null
+++ b/src/mzscheme/gc/README.hp
@@ -0,0 +1,5 @@
+Dynamic loading support requires that executables be linked with -ldld.
+The alternative is to build the collector without defining DYNAMIC_LOADING
+in config.h and ensuring that all garbage collectable objects are
+accessible without considering statically allocated variables in dynamic
+libraries.
diff --git a/src/mzscheme/gc/README.rs6000 b/src/mzscheme/gc/README.rs6000
new file mode 100644
index 0000000..0444ac4
--- /dev/null
+++ b/src/mzscheme/gc/README.rs6000
@@ -0,0 +1,6 @@
+We have so far failed to find a good way to determine the stack base.
+It is highly recommended that GC_stackbottom be set explicitly on program
+startup.  The supplied value sometimes causes failure under AIX 4.1, though
+it appears to work under 3.X.  HEURISTIC2 seems to work under 4.1, but
+involves a substantial performance penalty, and will fail if there is
+no limit on stack size.
diff --git a/src/mzscheme/gc/README.sgi b/src/mzscheme/gc/README.sgi
new file mode 100644
index 0000000..c15151f
--- /dev/null
+++ b/src/mzscheme/gc/README.sgi
@@ -0,0 +1,29 @@
+Performance of the incremental collector can be greatly enhanced with
+-DNO_EXECUTE_PERMISSION.
+
+The collector should run with all of the -32, -n32 and -64 ABIs.  Remember to
+define the AS macro in the Makefile to be "as -64", or "as -n32".
+
+If you use -DREDIRECT_MALLOC=GC_malloc with C++ code, your code should make
+at least one explicit call to malloc instead of new to ensure that the proper
+version of malloc is linked in.
+
+Sproc threads are not supported in this version, though there may exist other
+ports.  Pthreads are somewhat supported without incremental collection.  This
+requires that:
+
+1) You compile the collector with -DIRIX_THREADS specified in the Makefile.
+
+2) You have the latest pthreads patches installed.  As of 11/7/96, some of
+the required patches were not yet generally available, so you may have
+to wait.  If gctest fails, this is the likely cause.
+(Though the collector makes only documented pthread calls,
+it relies on signal/threads interactions working just right in ways
+that are not required by the standard.  It is unlikely that this code
+will run on other pthreads platforms.  But please tell me if it does.)
+
+3) Every file that makes thread calls should define IRIX_THREADS and then
+include gc.h.  Gc.h redefines some of the pthread primitives as macros which
+also provide the collector with information it requires.
+
+4) For the time being, you should not use dlopen.
diff --git a/src/mzscheme/gc/README.solaris2 b/src/mzscheme/gc/README.solaris2
new file mode 100644
index 0000000..4a6cf12
--- /dev/null
+++ b/src/mzscheme/gc/README.solaris2
@@ -0,0 +1,71 @@
+The collector supports both incremental collection and threads under
+Solaris 2.  The incremental collector normally retrieves page dirty information
+through the appropriate /proc calls.  But it can also be configured
+(by defining MPROTECT_VDB instead of PROC_VDB in config.h) to use mprotect
+and signals.  This may result in shorter pause times, but it is no longer
+safe to issue arbitrary system calls that write to the heap.
+
+The collector normally obtains memory through sbrk.  There is some reason
+to expect that this is not safe if the client program also calls the system
+malloc, or especially realloc.  The sbrk man page strongly suggests this is
+not safe: "Many library routines use malloc() internally, so use brk()
+and sbrk() only when you know  that malloc() definitely will not be used by
+any library routine."  This doesn't make a lot of sense to me, since there
+seems to be no documentation as to which routines can transitively call malloc.
+Furthermore there typically isn't much of a performance advantage to be
+gained from such a restriction.
+
+To complicate matters, empirically this approach seems to work, at least
+most of the time.  There have been reports of crashes in Sun's realloc
+function.  But I haven't been able to reproduce this on an example small
+enough to preclude other bugs.
+
+As it stands, you have 4 choices:
+
+1. Use the collector as is, possibly avoiding the system realloc function.
+If you get a simple program that does this to crash, send me a copy, and
+I'll change the default to do something else.  Please also complain to Sun,
+if you find such a case.
+
+2. Build the collector with -DREDIRECT_MALLOC=GC_malloc_uncollectable, thus
+redirecting system allocation calls through the collector.  I believe
+this is OK under Solaris, but there is some risk of infinite recursion if
+you turn on collector log messages.
+
+3. Change the GET_MEM definition for SPARC and SUNOS5 in gc_priv.h to
+be the same as for the AMIGA or NEXT.  The collector will then obtain
+memory through the system calloc function.  This is probably the safest,
+but it incurs a fragmentation penalty.  Since the system malloc is likely
+to reserve header space in each object, the different heap sections
+are virtually guaranteed to not be adjacent.  Thus large objects have to fit
+entirely in one section.
+
+4. Change GET_MEM to allocate memory from a different part of the address
+space, e.g. with mmap.  Based on previous experiences with older versions
+of SunOS and other operating systems, this risks other performance problems.
+I have not tried it with Solaris 2.
+
+SOLARIS THREADS:
+
+The collector must be compiled with -DSOLARIS_THREADS to be thread safe.
+It is also essential that gc.h be included in files that call thr_create,
+thr_join, thr_suspend, thr_continue, or dlopen.  Gc.h macro defines
+these to also do GC bookkeeping, etc.  Gc.h must be included with SOLARIS_THREADS
+defined, otherwise these replacements are not visible.
+
+In this mode, the collector contains various workarounds for older Solaris
+bugs.  Mostly, these should not be noticeable unless you look at system
+call traces.  However, it cannot protect a guard page at the end of
+a thread stack.  If you know that you will only be running Solaris2.5
+or later, it should be possible to fix this by compiling the collector
+with -DSOLARIS23_MPROTECT_BUG_FIXED.
+
+Jeremy Fitzhardinge points out that there is a problem with the dlopen
+replacement, in that startup code in the library is run while the allocation
+lock is held.  This appears to be difficult to fix, since the collector does
+look at data structures maintained by dlopen, and hence some locking is needed
+around the dlopen call.
+
+Hans-J. Boehm
+(The above contains my personal opinions, which are probably not shared
+by anyone else.)
diff --git a/src/mzscheme/gc/README.uts b/src/mzscheme/gc/README.uts
new file mode 100644
index 0000000..6be4966
--- /dev/null
+++ b/src/mzscheme/gc/README.uts
@@ -0,0 +1,2 @@
+Alistair Crooks supplied the port.  He used Lexa C version 2.1.3 with
+-Xa to compile.
diff --git a/src/mzscheme/gc/README.win32 b/src/mzscheme/gc/README.win32
new file mode 100644
index 0000000..1611562
--- /dev/null
+++ b/src/mzscheme/gc/README.win32
@@ -0,0 +1,104 @@
+The collector has only been compiled under Windows NT, with the
+original Microsoft SDK, with Visual C++ 2.0, and with Borland 4.5.
+
+It runs under both win32s and win32, but with different semantics.
+Under win32, all writable pages outside of the heaps and stack are
+scanned for roots.  Thus the collector sees pointers in DLL data
+segments.  Under win32s, only the main data segment is scanned.
+(The main data segment should always be scanned.  Under some
+versions of win32s, other regions may also be scanned.)
+Thus all accessible objects should be accessible from local variables
+or variables in the main data segment.  Alternatively, other data
+segments (e.g. in DLLs) may be registered with the collector by
+calling GC_init() and then GC_register_root_section(a), where
+a is the address of some variable inside the data segment.  (Duplicate
+registrations are ignored, but not terribly quickly.)
+
+(There are two reasons for this.  We didn't want to see many 16:16
+pointers.  And the VirtualQuery call has different semantics under
+the two systems, and under different versions of win32s.)
+
+The collector test program "gctest" is linked as a GUI application,
+but does not open any windows.  Its output appears in the file
+"gc.log".  It may be started from the file manager.  The hour glass
+cursor will appear as long as it's running.
+
+The cord test program has not been ported (but should port
+easily).  A toy editor (cord/de.exe) based on cords (heavyweight
+strings represented as trees) has been ported and is included.
+It runs fine under either win32 or win32S.  It serves as an example
+of a true Windows application, except that it was written by a
+nonexpert Windows programmer.  (There are some peculiarities
+in the way files are displayed.  The <cr> is displayed explicitly
+for standard DOS text files.  As in the UNIX version, control
+characters are displayed explicitly, but in this case as red text.
+This may be suboptimal for some tastes and/or sets of default
+window colors.)
+
+For Microsoft development tools, rename NT_MAKEFILE as
+MAKEFILE.  (Make sure that the CPU environment variable is defined
+to be i386.)
+
+For Borland tools, use BCC_MAKEFILE.  Note that
+Borland's compiler defaults to 1 byte alignment in structures (-a1),
+whereas Visual C++ appears to default to 8 byte alignment (/Zp8).
+The garbage collector in its default configuration EXPECTS AT
+LEAST 4 BYTE ALIGNMENT.  Thus the BORLAND DEFAULT MUST
+BE OVERRIDDEN.  (In my opinion, it should usually be anyway.
+I expect that -a1 introduces major performance penalties on a
+486 or Pentium.)  Note that this changes structure layouts.  (As a last
+resort, config.h can be changed to allow 1 byte alignment.  But
+this has significant negative performance implications.)
+The Makefile is set up to assume Borland 4.5.  If you have another
+version, change the line near the top.  By default, it does not
+require the assembler.  If you do have the assembler, I recommend
+removing the -DUSE_GENERIC.
+
+Incremental collection support was recently added.  This is
+currently pretty simpleminded.  Pages are protected.  Protection
+faults are caught by a handler installed at the bottom of the handler
+stack.  This is both slow and interacts poorly with a debugger.
+Whenever possible, I recommend adding a call to
+GC_enable_incremental at the last possible moment, after most
+debugging is complete.  Unlike the UNIX versions, no system
+calls are wrapped by the collector itself.  It may be necessary
+to wrap ReadFile calls that use a buffer in the heap, so that the
+call does not encounter a protection fault while it's running.
+(As usual, none of this is an issue unless GC_enable_incremental
+is called.)
+
+Note that incremental collection is disabled with -DSMALL_CONFIG,
+which is the default for win32.  If you need incremental collection,
+undefine SMALL_CONFIG.
+
+Incremental collection is not supported under win32s, and it may not
+be possible to do so.  However, win32 applications that attempt to use
+incremental collection should continue to run, since the
+collector detects if it's running under win32s and turns calls to
+GC_enable_incremental() into noops.
+
+James Clark has contributed the necessary code to support win32 threads.
+This code is known to exhibit some problems with incremental collection
+enabled.  Use NT_THREADS_MAKEFILE (a.k.a gc.mak) instead of NT_MAKEFILE
+to build this version.  Note that this requires some files whose names
+are more than 8 + 3 characters long.  Thus you should unpack the tar file
+so that long file names are preserved.  To build the garbage collector
+test with VC++ from the command line, use
+
+nmake /F ".\gc.mak" CFG="gctest - Win32 Release"
+
+This requires that the subdirectory gctest\Release exist.
+
+This version relies on the collector residing in a dll.
+
+This version currently supports incremental collection only if it is
+enabled before any additional threads are created.
+It is known to not be completely solid.  At a minimum it can deadlock
+if a thread starts in the middle of an allocation.  There may be
+other problems.  If you need solid support for win32 threads, you
+check with Geodesic Systems.  I haven't tried it, but they claim
+to support it.
+
+Hans
+
+
diff --git a/src/mzscheme/gc/SCoptions.amiga b/src/mzscheme/gc/SCoptions.amiga
new file mode 100644
index 0000000..a61e0cb
--- /dev/null
+++ b/src/mzscheme/gc/SCoptions.amiga
@@ -0,0 +1,16 @@
+CPU=68030
+NOSTACKCHECK
+OPTIMIZE
+VERBOSE
+MAPHUNK
+NOVERSION
+NOICONS
+OPTIMIZERTIME
+DEFINE SILENT
+DEFINE AMIGA_SKIP_SEG
+IGNORE=85
+IGNORE=154
+IGNORE=161
+IGNORE=100
+OPTIMIZERCOMPLEXITY=4
+OPTIMIZERDEPTH=3
diff --git a/src/mzscheme/gc/SMakefile.amiga b/src/mzscheme/gc/SMakefile.amiga
new file mode 100644
index 0000000..b1aa340
--- /dev/null
+++ b/src/mzscheme/gc/SMakefile.amiga
@@ -0,0 +1,48 @@
+OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o
+
+INC=  gc_private.h gc_hdrs.h gc.h config.h
+
+all: gctest setjmp_t
+
+alloc.o : alloc.c $(INC)
+reclaim.o : reclaim.c $(INC)
+allchblk.o : allchblk.c $(INC)
+misc.o : misc.c $(INC)
+os_dep.o : os_dep.c $(INC)
+mark_rts.o : mark_rts.c $(INC)
+headers.o : headers.c $(INC)
+mark.o : mark.c $(INC)
+obj_map.o : obj_map.c $(INC)
+blacklst.o : blacklst.c $(INC)
+finalize.o : finalize.c $(INC)
+  sc noopt finalize.c # There seems to be a bug in the optimizer (V6.51).
+                      # gctest won't work if you remove this...
+new_hblk.o : new_hblk.c $(INC)
+real_malloc.o : real_malloc.c $(INC)
+dyn_load.o : dyn_load.c $(INC)
+dbg_mlc.o : dbg_mlc.c $(INC)
+malloc.o : malloc.c $(INC)
+mallocx.o : malloc.c $(INC)
+stubborn.o : stubborn.c $(INC)
+checksums.o : checksums.c $(INC)
+typd_mlc.o: typd_mlc.c $(INC)
+mach_dep.o : mach_dep.c $(INC)
+ptr_chck.o: ptr_chck.c $(INC)
+test.o : test.c $(INC)
+
+gc.lib: $(OBJS)
+   oml gc.lib r $(OBJS)
+
+clean:
+   delete gc.lib gctest setjmp_t \#?.o
+
+gctest: gc.lib test.o
+   slink LIB:c.o test.o to $@ lib gc.lib LIB:sc.lib LIB:scm.lib
+
+setjmp_t: setjmp_t.c gc.h
+   sc setjmp_t.c
+   slink LIB:c.o $@.o to $@ lib LIB:sc.lib
+
+test: setjmp_t gctest
+   setjmp_t
+   gctest
diff --git a/src/mzscheme/gc/add_gc_prefix.c b/src/mzscheme/gc/add_gc_prefix.c
new file mode 100644
index 0000000..0d1ab6d
--- /dev/null
+++ b/src/mzscheme/gc/add_gc_prefix.c
@@ -0,0 +1,14 @@
+# include <stdio.h>
+ 
+int main(argc, argv, envp)
+int argc;
+char ** argv;
+char ** envp;
+{
+    int i;
+    
+    for (i = 1; i < argc; i++) {
+    	printf("gc/%s ", argv[i]);
+    }
+    return(0);
+}
diff --git a/src/mzscheme/gc/allchblk.c b/src/mzscheme/gc/allchblk.c
new file mode 100644
index 0000000..bb64d03
--- /dev/null
+++ b/src/mzscheme/gc/allchblk.c
@@ -0,0 +1,383 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, August 9, 1995 5:08 pm PDT */
+
+#define DEBUG
+#undef DEBUG
+#include <stdio.h>
+#include "gc_priv.h"
+
+
+/*
+ * allocate/free routines for heap blocks
+ * Note that everything called from outside the garbage collector
+ * should be prepared to abort at any point as the result of a signal.
+ */
+
+/*
+ * Free heap blocks are kept on a list sorted by address.
+ * The hb_hdr.hbh_sz field of a free heap block contains the length
+ * (in bytes) of the entire block.
+ * Neighbors are coalesced.
+ */
+ 
+# define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE)
+		/* largest block we will allocate starting on a black   */
+		/* listed block.  Must be >= HBLKSIZE.			*/
+
+struct hblk * GC_hblkfreelist = 0;
+
+struct hblk *GC_savhbp = (struct hblk *)0;  /* heap block preceding next */
+					 /* block to be examined by   */
+					 /* GC_allochblk.                */
+
+# if !defined(NO_DEBUGGING)
+void GC_print_hblkfreelist()
+{
+    struct hblk * h = GC_hblkfreelist;
+    word total_free = 0;
+    hdr * hhdr = HDR(h);
+    word sz;
+    
+    while (h != 0) {
+        sz = hhdr -> hb_sz;
+    	GC_printf2("0x%lx size %lu ", (unsigned long)h, (unsigned long)sz);
+    	total_free += sz;
+        if (GC_is_black_listed(h, HBLKSIZE) != 0) {
+             GC_printf0("start black listed\n");
+        } else if (GC_is_black_listed(h, hhdr -> hb_sz) != 0) {
+             GC_printf0("partially black listed\n");
+        } else {
+             GC_printf0("not black listed\n");
+        }
+        h = hhdr -> hb_next;
+        hhdr = HDR(h);
+    }
+    GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free);
+}
+
+# endif /* NO_DEBUGGING */
+
+/* Initialize hdr for a block containing the indicated size and 	*/
+/* kind of objects.							*/
+/* Return FALSE on failure.						*/
+static bool setup_header(hhdr, sz, kind, flags)
+register hdr * hhdr;
+word sz;	/* object size in words */
+int kind;
+unsigned char flags;
+{
+    register word descr;
+    
+    /* Add description of valid object pointers */
+      if (!GC_add_map_entry(sz)) return(FALSE);
+      hhdr -> hb_map = GC_obj_map[sz > MAXOBJSZ? 0 : sz];
+      
+    /* Set size, kind and mark proc fields */
+      hhdr -> hb_sz = sz;
+      hhdr -> hb_obj_kind = kind;
+      hhdr -> hb_flags = flags;
+      descr = GC_obj_kinds[kind].ok_descriptor;
+      if (GC_obj_kinds[kind].ok_relocate_descr) descr += WORDS_TO_BYTES(sz);
+      hhdr -> hb_descr = descr;
+      
+    /* Clear mark bits */
+      GC_clear_hdr_marks(hhdr);
+      
+    hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no;
+    return(TRUE);
+}
+
+/*
+ * Allocate (and return pointer to) a heap block
+ *   for objects of size sz words.
+ *
+ * NOTE: We set obj_map field in header correctly.
+ *       Caller is resposnsible for building an object freelist in block.
+ *
+ * We clear the block if it is destined for large objects, and if
+ * kind requires that newly allocated objects be cleared.
+ */
+struct hblk *
+GC_allochblk(sz, kind, flags)
+word sz;
+int kind;
+unsigned char flags;  /* IGNORE_OFF_PAGE or 0 */
+{
+    register struct hblk *thishbp;
+    register hdr * thishdr;		/* Header corr. to thishbp */
+    register struct hblk *hbp;
+    register hdr * hhdr;		/* Header corr. to hbp */
+    struct hblk *prevhbp;
+    register hdr * phdr;		/* Header corr. to prevhbp */
+    signed_word size_needed;    /* number of bytes in requested objects */
+    signed_word size_avail;	/* bytes available in this block	*/
+    bool first_time = TRUE;
+
+    size_needed = HBLKSIZE * OBJ_SZ_TO_BLOCKS(sz);
+
+    /* search for a big enough block in free list */
+	hbp = GC_savhbp;
+	hhdr = HDR(hbp);
+	for(;;) {
+
+	    prevhbp = hbp;
+	    phdr = hhdr;
+	    hbp = (prevhbp == 0? GC_hblkfreelist : phdr->hb_next);
+	    hhdr = HDR(hbp);
+
+	    if( prevhbp == GC_savhbp && !first_time) {
+	        return(0);
+	    }
+
+	    first_time = FALSE;
+
+	    if( hbp == 0 ) continue;
+
+	    size_avail = hhdr->hb_sz;
+	    if (size_avail < size_needed) continue;
+	    /* If the next heap block is obviously better, go on.	*/
+	    /* This prevents us from disassembling a single large block */
+	    /* to get tiny blocks.					*/
+	    {
+	      signed_word next_size;
+	      
+	      thishbp = hhdr -> hb_next;
+	      if (thishbp == 0) thishbp = GC_hblkfreelist; 
+	      thishdr = HDR(thishbp);
+	      next_size = (signed_word)(thishdr -> hb_sz);
+	      if (next_size < size_avail
+	          && next_size >= size_needed
+	          && !GC_is_black_listed(thishbp, (word)size_needed)) {
+	          continue;
+	      }
+	    }
+	    if ( !IS_UNCOLLECTABLE(kind) &&
+	         (kind != PTRFREE || size_needed > MAX_BLACK_LIST_ALLOC)) {
+	      struct hblk * lasthbp = hbp;
+	      ptr_t search_end = (ptr_t)hbp + size_avail - size_needed;
+	      signed_word orig_avail = size_avail;
+	      signed_word eff_size_needed = ((flags & IGNORE_OFF_PAGE)?
+	      					HBLKSIZE
+	      					: size_needed);
+	      
+	      
+	      while ((ptr_t)lasthbp <= search_end
+	             && (thishbp = GC_is_black_listed(lasthbp,
+	             				      (word)eff_size_needed))) {
+	        lasthbp = thishbp;
+	      }
+	      size_avail -= (ptr_t)lasthbp - (ptr_t)hbp;
+	      thishbp = lasthbp;
+	      if (size_avail >= size_needed) {
+	        if (thishbp != hbp && GC_install_header(thishbp)) {
+	          /* Split the block at thishbp */
+	              thishdr = HDR(thishbp);
+	              /* GC_invalidate_map not needed, since we will	*/
+	              /* allocate this block.				*/
+		      thishdr -> hb_next = hhdr -> hb_next;
+		      thishdr -> hb_sz = size_avail;
+		      hhdr -> hb_sz = (ptr_t)thishbp - (ptr_t)hbp;
+		      hhdr -> hb_next = thishbp;
+		  /* Advance to thishbp */
+		      prevhbp = hbp;
+		      phdr = hhdr;
+		      hbp = thishbp;
+		      hhdr = thishdr;
+		}
+	      } else if (size_needed > (signed_word)BL_LIMIT
+	                 && orig_avail - size_needed
+			    > (signed_word)BL_LIMIT) {
+		/* MATTHEW: I'd rather not see this particular message. */
+#if 0
+	        /* Punt, since anything else risks unreasonable heap growth. */
+	        WARN("Needed to allocate blacklisted block at 0x%lx\n",
+		     (word)hbp);
+#endif
+	        thishbp = hbp;
+	        size_avail = orig_avail;
+	      } else if (size_avail == 0
+	      		 && size_needed == HBLKSIZE
+	      		 && prevhbp != 0) {
+#		ifndef FIND_LEAK
+	      	  static unsigned count = 0;
+	      	  
+	      	  /* The block is completely blacklisted.  We need 	*/
+	      	  /* to drop some such blocks, since otherwise we spend */
+	      	  /* all our time traversing them if pointerfree	*/
+	      	  /* blocks are unpopular.				*/
+	          /* A dropped block will be reconsidered at next GC.	*/
+	          if ((++count & 3) == 0) {
+	            /* Allocate and drop the block in small chunks, to	*/
+	            /* maximize the chance that we will recover some	*/
+	            /* later.						*/
+	              struct hblk * limit = hbp + (hhdr->hb_sz/HBLKSIZE);
+	              struct hblk * h;
+	              
+	              phdr -> hb_next = hhdr -> hb_next;
+	              for (h = hbp; h < limit; h++) {
+	                if (h == hbp || GC_install_header(h)) {
+	                  hhdr = HDR(h);
+	                  (void) setup_header(
+	                	  hhdr,
+	              		  BYTES_TO_WORDS(HBLKSIZE - HDR_BYTES),
+	              		  PTRFREE, 0); /* Cant fail */
+	              	  if (GC_debugging_started) {
+	              	    BZERO(hbp + HDR_BYTES, HBLKSIZE - HDR_BYTES);
+	              	  }
+	                }
+	              }
+	            /* Restore hbp to point at free block */
+	              if (GC_savhbp == hbp) GC_savhbp = prevhbp;
+	              hbp = prevhbp;
+	              hhdr = phdr;
+	              if (hbp == GC_savhbp) first_time = TRUE;
+	          }
+#		endif
+	      }
+	    }
+	    if( size_avail >= size_needed ) {
+		/* found a big enough block       */
+		/* let thishbp --> the block      */
+		/* set prevhbp, hbp to bracket it */
+		    thishbp = hbp;
+		    thishdr = hhdr;
+		    if( size_avail == size_needed ) {
+			hbp = hhdr->hb_next;
+			hhdr = HDR(hbp);
+		    } else {
+			hbp = (struct hblk *)
+			    (((word)thishbp) + size_needed);
+			if (!GC_install_header(hbp)) continue;
+			hhdr = HDR(hbp);
+			GC_invalidate_map(hhdr);
+			hhdr->hb_next = thishdr->hb_next;
+			hhdr->hb_sz = size_avail - size_needed;
+		    }
+		/* remove *thishbp from hblk freelist */
+		    if( prevhbp == 0 ) {
+			GC_hblkfreelist = hbp;
+		    } else {
+			phdr->hb_next = hbp;
+		    }
+		/* save current list search position */
+		    GC_savhbp = hbp;
+		break;
+	    }
+	}
+	
+    /* Notify virtual dirty bit implementation that we are about to write. */
+    	GC_write_hint(thishbp);
+    
+    /* Add it to map of valid blocks */
+    	if (!GC_install_counts(thishbp, (word)size_needed)) return(0);
+    	/* This leaks memory under very rare conditions. */
+    		
+    /* Set up header */
+        if (!setup_header(thishdr, sz, kind, flags)) {
+            GC_remove_counts(thishbp, (word)size_needed);
+            return(0); /* ditto */
+        }
+        
+    /* Clear block if necessary */
+	if (GC_debugging_started
+	    || sz > MAXOBJSZ && GC_obj_kinds[kind].ok_init) {
+	    BZERO(thishbp + HDR_BYTES,  size_needed - HDR_BYTES);
+	}
+    
+    return( thishbp );
+}
+ 
+struct hblk * GC_freehblk_ptr = 0;  /* Search position hint for GC_freehblk */
+
+/*
+ * Free a heap block.
+ *
+ * Coalesce the block with its neighbors if possible.
+ *
+ * All mark words are assumed to be cleared.
+ */
+void
+GC_freehblk(p)
+register struct hblk *p;
+{
+register hdr *phdr;	/* Header corresponding to p */
+register struct hblk *hbp, *prevhbp;
+register hdr *hhdr, *prevhdr;
+register signed_word size;
+
+    /* GC_savhbp may become invalid due to coalescing.  Clear it. */
+	GC_savhbp = (struct hblk *)0;
+
+    phdr = HDR(p);
+    size = phdr->hb_sz;
+    size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(size);
+    GC_remove_counts(p, (word)size);
+    phdr->hb_sz = size;
+    GC_invalidate_map(phdr);
+    prevhbp = 0;
+    
+    /* The following optimization was suggested by David Detlefs.	*/
+    /* Note that the header cannot be NIL, since there cannot be an	*/
+    /* intervening  call to GC_freehblk without resetting		*/
+    /* GC_freehblk_ptr.							*/
+    if (GC_freehblk_ptr != 0 &&
+    	HDR(GC_freehblk_ptr)->hb_map == GC_invalid_map &&
+    	(ptr_t)GC_freehblk_ptr < (ptr_t)p) {
+      hbp = GC_freehblk_ptr;
+    } else {
+      hbp = GC_hblkfreelist;
+    };
+    hhdr = HDR(hbp);
+
+    while( (hbp != 0) && (hbp < p) ) {
+	prevhbp = hbp;
+	prevhdr = hhdr;
+	hbp = hhdr->hb_next;
+	hhdr = HDR(hbp);
+    }
+    GC_freehblk_ptr = prevhbp;
+    
+    /* Check for duplicate deallocation in the easy case */
+      if (hbp != 0 && (ptr_t)p + size > (ptr_t)hbp
+        || prevhbp != 0 && (ptr_t)prevhbp + prevhdr->hb_sz > (ptr_t)p) {
+        GC_printf1("Duplicate large block deallocation of 0x%lx\n",
+        	   (unsigned long) p);
+        GC_printf2("Surrounding free blocks are 0x%lx and 0x%lx\n",
+           	   (unsigned long) prevhbp, (unsigned long) hbp);
+      }
+
+    /* Coalesce with successor, if possible */
+      if( (((word)p)+size) == ((word)hbp) ) {
+	phdr->hb_next = hhdr->hb_next;
+	phdr->hb_sz += hhdr->hb_sz;
+	GC_remove_header(hbp);
+      } else {
+	phdr->hb_next = hbp;
+      }
+
+    
+    if( prevhbp == 0 ) {
+	GC_hblkfreelist = p;
+    } else if( (((word)prevhbp) + prevhdr->hb_sz)
+      	       == ((word)p) ) {
+      /* Coalesce with predecessor */
+	prevhdr->hb_next = phdr->hb_next;
+	prevhdr->hb_sz += phdr->hb_sz;
+	GC_remove_header(p);
+    } else {
+	prevhdr->hb_next = p;
+    }
+}
+
diff --git a/src/mzscheme/gc/alloc.c b/src/mzscheme/gc/alloc.c
new file mode 100644
index 0000000..715b9f1
--- /dev/null
+++ b/src/mzscheme/gc/alloc.c
@@ -0,0 +1,830 @@
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+/* Boehm, February 16, 1996 2:26 pm PST */
+
+
+# include "gc_priv.h"
+
+# include <stdio.h>
+# ifndef MACOS
+#   include <signal.h>
+#   include <sys/types.h>
+# endif
+
+/*
+ * Separate free lists are maintained for different sized objects
+ * up to MAXOBJSZ.
+ * The call GC_allocobj(i,k) ensures that the freelist for
+ * kind k objects of size i points to a non-empty
+ * free list. It returns a pointer to the first entry on the free list.
+ * In a single-threaded world, GC_allocobj may be called to allocate
+ * an object of (small) size i as follows:
+ *
+ *            opp = &(GC_objfreelist[i]);
+ *            if (*opp == 0) GC_allocobj(i, NORMAL);
+ *            ptr = *opp;
+ *            *opp = obj_link(ptr);
+ *
+ * Note that this is very fast if the free list is non-empty; it should
+ * only involve the execution of 4 or 5 simple instructions.
+ * All composite objects on freelists are cleared, except for
+ * their first word.
+ */
+
+/*
+ *  The allocator uses GC_allochblk to allocate large chunks of objects.
+ * These chunks all start on addresses which are multiples of
+ * HBLKSZ.   Each allocated chunk has an associated header,
+ * which can be located quickly based on the address of the chunk.
+ * (See headers.c for details.) 
+ * This makes it possible to check quickly whether an
+ * arbitrary address corresponds to an object administered by the
+ * allocator.
+ */
+
+word GC_non_gc_bytes = 0;  /* Number of bytes not intended to be collected */
+
+word GC_gc_no = 0;
+
+int GC_incremental = 0;    /* By default, stop the world.	*/
+
+int GC_full_freq = 4;	   /* Every 5th collection is a full	*/
+			   /* collection.			*/
+
+char * GC_copyright[] =
+{"Copyright 1988,1989 Hans-J. Boehm and Alan J. Demers",
+"Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.",
+"THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY",
+" EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK."};
+
+
+/* some more variables */
+
+extern signed_word GC_mem_found;  /* Number of reclaimed longwords	*/
+				  /* after garbage collection      	*/
+
+bool GC_dont_expand = 0;
+
+word GC_free_space_divisor = 4;
+
+extern bool GC_collection_in_progress();
+
+int GC_never_stop_func GC_PROTO((void)) { return(0); }
+
+CLOCK_TYPE GC_start_time;
+
+int GC_timeout_stop_func GC_PROTO((void))
+{
+    CLOCK_TYPE current_time;
+    static unsigned count = 0;
+    unsigned long time_diff;
+    
+    if ((count++ & 3) != 0) return(0);
+    GET_TIME(current_time);
+    time_diff = MS_TIME_DIFF(current_time,GC_start_time);
+    if (time_diff >= TIME_LIMIT) {
+#   	ifdef PRINTSTATS
+	    GC_printf0("Abandoning stopped marking after ");
+	    GC_printf1("%lu msecs\n", (unsigned long)time_diff);
+#	endif
+    	return(1);
+    }
+    return(0);
+}
+
+/* Return the minimum number of words that must be allocated between	*/
+/* collections to amortize the collection cost.				*/
+static word min_words_allocd()
+{
+#   ifdef THREADS
+ 	/* We punt, for now. */
+ 	register signed_word stack_size = 10000;
+#   else
+        int dummy;
+        register signed_word stack_size = (ptr_t)(&dummy) - GC_stackbottom;
+#   endif
+    register word total_root_size;  /* includes double stack size,	*/
+    				    /* since the stack is expensive	*/
+    				    /* to scan.				*/
+    
+    if (stack_size < 0) stack_size = -stack_size;
+    total_root_size = 2 * stack_size + GC_root_size;
+    if (GC_incremental) {
+        return(BYTES_TO_WORDS(GC_heapsize + total_root_size)
+               / (2 * GC_free_space_divisor));
+    } else {
+        return(BYTES_TO_WORDS(GC_heapsize + total_root_size)
+               / GC_free_space_divisor);
+    }
+}
+
+/* Return the number of words allocated, adjusted for explicit storage	*/
+/* management, etc..  This number is used in deciding when to trigger	*/
+/* collections.								*/
+word GC_adj_words_allocd()
+{
+    register signed_word result;
+    register signed_word expl_managed =
+    		BYTES_TO_WORDS((long)GC_non_gc_bytes
+    				- (long)GC_non_gc_bytes_at_gc);
+    
+    /* Don't count what was explicitly freed, or newly allocated for	*/
+    /* explicit management.  Note that deallocating an explicitly	*/
+    /* managed object should not alter result, assuming the client	*/
+    /* is playing by the rules.						*/
+    result = (signed_word)GC_words_allocd
+    	     - (signed_word)GC_mem_freed - expl_managed;
+    if (result > (signed_word)GC_words_allocd) {
+        result = GC_words_allocd;
+    	/* probably client bug or unfortunate scheduling */
+    }
+    result += GC_words_finalized;
+    	/* We count objects enqueued for finalization as though they	*/
+    	/* had been reallocated this round. Finalization is user	*/
+    	/* visible progress.  And if we don't count this, we have	*/
+    	/* stability problems for programs that finalize all objects.	*/
+    result += GC_words_wasted;
+     	/* This doesn't reflect useful work.  But if there is lots of	*/
+     	/* new fragmentation, the same is probably true of the heap,	*/
+     	/* and the collection will be correspondingly cheaper.		*/
+    if (result < (signed_word)(GC_words_allocd >> 3)) {
+    	/* Always count at least 1/8 of the allocations.  We don't want	*/
+    	/* to collect too infrequently, since that would inhibit	*/
+    	/* coalescing of free storage blocks.				*/
+    	/* This also makes us partially robust against client bugs.	*/
+        return(GC_words_allocd >> 3);
+    } else {
+        return(result);
+    }
+}
+
+
+/* Clear up a few frames worth of garbage left at the top of the stack.	*/
+/* This is used to prevent us from accidentally treating garbade left	*/
+/* on the stack by other parts of the collector as roots.  This 	*/
+/* differs from the code in misc.c, which actually tries to keep the	*/
+/* stack clear of long-lived, client-generated garbage.			*/
+void GC_clear_a_few_frames()
+{
+#   define NWORDS 64
+    word frames[NWORDS];
+    register int i;
+    
+    for (i = 0; i < NWORDS; i++) frames[i] = 0;
+}
+
+/* Have we allocated enough to amortize a collection? */
+bool GC_should_collect()
+{
+    return(GC_adj_words_allocd() >= min_words_allocd());
+}
+
+/* 
+ * Initiate a garbage collection if appropriate.
+ * Choose judiciously
+ * between partial, full, and stop-world collections.
+ * Assumes lock held, signals disabled.
+ */
+void GC_maybe_gc()
+{
+    static int n_partial_gcs = 0;
+    if (GC_should_collect()) {
+        if (!GC_incremental) {
+            GC_gcollect_inner();
+            n_partial_gcs = 0;
+            return;
+        } else if (n_partial_gcs >= GC_full_freq) {
+#   	    ifdef PRINTSTATS
+	      GC_printf2(
+	        "***>Full mark for collection %lu after %ld allocd bytes\n",
+     		(unsigned long) GC_gc_no+1,
+	   	(long)WORDS_TO_BYTES(GC_words_allocd));
+#           endif
+	    GC_promote_black_lists();
+	    (void)GC_reclaim_all((GC_stop_func)0, TRUE);
+	    GC_clear_marks();
+            n_partial_gcs = 0;
+        } else {
+            n_partial_gcs++;
+        }
+        /* We try to mark with the world stopped.	*/
+        /* If we run out of time, this turns into	*/
+        /* incremental marking.			*/
+        GET_TIME(GC_start_time);
+        if (GC_stopped_mark(GC_timeout_stop_func)) {
+#           ifdef SAVE_CALL_CHAIN
+                GC_save_callers(GC_last_stack);
+#           endif
+            GC_finish_collection();
+        }
+    }
+}
+
+/* MATTHEW: notification callback for starting/ending a GC */
+void (*GC_collect_start_callback)(void) = NULL;
+void (*GC_collect_end_callback)(void) = NULL;
+
+/*
+ * Stop the world garbage collection.  Assumes lock held, signals disabled.
+ * If stop_func is not GC_never_stop_func, then abort if stop_func returns TRUE.
+ */
+bool GC_try_to_collect_inner(stop_func)
+GC_stop_func stop_func;
+{
+    /* MATTHEW */
+    if (GC_collect_start_callback)
+      GC_collect_start_callback();
+
+    if (GC_collection_in_progress()) {
+#   ifdef PRINTSTATS
+	GC_printf0(
+	    "GC_try_to_collect_inner: finishing collection in progress\n");
+#    endif /* PRINTSTATS */
+      /* Just finish collection already in progress.	*/
+    	while(GC_collection_in_progress()) {
+    	    if (stop_func()) return(FALSE);
+    	    GC_collect_a_little_inner(1);
+    	}
+    }
+#   ifdef PRINTSTATS
+	GC_printf2(
+	   "Initiating full world-stop collection %lu after %ld allocd bytes\n",
+	   (unsigned long) GC_gc_no+1,
+	   (long)WORDS_TO_BYTES(GC_words_allocd));
+#   endif
+    GC_promote_black_lists();
+    /* Make sure all blocks have been reclaimed, so sweep routines	*/
+    /* don't see cleared mark bits.					*/
+    /* If we're guaranteed to finish, then this is unnecessary.		*/
+	if (stop_func != GC_never_stop_func
+	    && !GC_reclaim_all(stop_func, FALSE)) {
+	    /* Aborted.  So far everything is still consistent.	*/
+	    return(FALSE);
+	}
+    GC_invalidate_mark_state();  /* Flush mark stack.	*/
+    GC_clear_marks();
+#   ifdef SAVE_CALL_CHAIN
+        GC_save_callers(GC_last_stack);
+#   endif
+    if (!GC_stopped_mark(stop_func)) {
+      if (!GC_incremental) {
+    	/* We're partially done and have no way to complete or use 	*/
+    	/* current work.  Reestablish invariants as cheaply as		*/
+    	/* possible.							*/
+    	GC_invalidate_mark_state();
+	GC_unpromote_black_lists();
+      } /* else we claim the world is already still consistent.  We'll 	*/
+        /* finish incrementally.					*/
+      return(FALSE);
+    }
+    GC_finish_collection();
+
+    /* MATTHEW */
+    if (GC_collect_end_callback)
+      GC_collect_end_callback();
+
+    return(TRUE);
+}
+
+
+
+/*
+ * Perform n units of garbage collection work.  A unit is intended to touch
+ * roughly a GC_RATE pages.  Every once in a while, we do more than that.
+ */
+# define GC_RATE 8
+
+int GC_deficit = 0;	/* The number of extra calls to GC_mark_some	*/
+			/* that we have made.				*/
+			/* Negative values are equivalent to 0.		*/
+
+void GC_collect_a_little_inner(n)
+int n;
+{
+    register int i;
+    
+    if (GC_collection_in_progress()) {
+    	for (i = GC_deficit; i < GC_RATE*n; i++) {
+    	    if (GC_mark_some()) {
+    	        /* Need to finish a collection */
+#     		ifdef SAVE_CALL_CHAIN
+        	    GC_save_callers(GC_last_stack);
+#     		endif
+		(void) GC_stopped_mark(GC_never_stop_func);
+    	        GC_finish_collection();
+    	        break;
+    	    }
+    	}
+    	if (GC_deficit > 0) GC_deficit -= GC_RATE*n;
+    } else {
+        GC_maybe_gc();
+    }
+}
+
+int GC_collect_a_little GC_PROTO(())
+{
+    int result;
+    DCL_LOCK_STATE;
+
+    DISABLE_SIGNALS();
+    LOCK();
+    GC_collect_a_little_inner(1);
+    result = (int)GC_collection_in_progress();
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return(result);
+}
+
+/*
+ * Assumes lock is held, signals are disabled.
+ * We stop the world.
+ * If final is TRUE, then we finish the collection, no matter how long
+ * it takes.
+ * Otherwise we may fail and return FALSE if this takes too long.
+ * Increment GC_gc_no if we succeed.
+ */
+bool GC_stopped_mark(stop_func)
+GC_stop_func stop_func;
+{
+    register int i;
+#   ifdef PRINTSTATS
+	CLOCK_TYPE start_time, current_time;
+#   endif
+	
+    STOP_WORLD();
+#   ifdef PRINTSTATS
+	GET_TIME(start_time);
+	GC_printf1("--> Marking for collection %lu ",
+	           (unsigned long) GC_gc_no + 1);
+	GC_printf2("after %lu allocd bytes + %lu wasted bytes\n",
+	   	   (unsigned long) WORDS_TO_BYTES(GC_words_allocd),
+	   	   (unsigned long) WORDS_TO_BYTES(GC_words_wasted));
+#   endif
+
+    /* Mark from all roots.  */
+        /* Minimize junk left in my registers and on the stack */
+            GC_clear_a_few_frames();
+            GC_noop(0,0,0,0,0,0);
+	GC_initiate_gc();
+	for(i = 0;;i++) {
+	    if ((*stop_func)()) {
+#   		    ifdef PRINTSTATS
+		    	GC_printf0("Abandoned stopped marking after ");
+			GC_printf1("%lu iterations\n",
+				   (unsigned long)i);
+#		    endif
+		    GC_deficit = i; /* Give the mutator a chance. */
+	            START_WORLD();
+	            return(FALSE);
+	    }
+	    if (GC_mark_some()) break;
+	}
+	
+    GC_gc_no++;
+#   ifdef PRINTSTATS
+      GC_printf2("Collection %lu reclaimed %ld bytes",
+		  (unsigned long) GC_gc_no - 1,
+	   	  (long)WORDS_TO_BYTES(GC_mem_found));
+      GC_printf1(" ---> heapsize = %lu bytes\n",
+      	        (unsigned long) GC_heapsize);
+      /* Printf arguments may be pushed in funny places.  Clear the	*/
+      /* space.								*/
+      GC_printf0("");
+#   endif      
+
+    /* Check all debugged objects for consistency */
+        if (GC_debugging_started) {
+            (*GC_check_heap)();
+        }
+    
+#   ifdef PRINTTIMES
+	GET_TIME(current_time);
+	GC_printf1("World-stopped marking took %lu msecs\n",
+	           MS_TIME_DIFF(current_time,start_time));
+#   endif
+    START_WORLD();
+    return(TRUE);
+}
+
+
+/* Finish up a collection.  Assumes lock is held, signals are disabled,	*/
+/* but the world is otherwise running.					*/
+void GC_finish_collection()
+{
+#   ifdef PRINTTIMES
+	CLOCK_TYPE start_time;
+	CLOCK_TYPE finalize_time;
+	CLOCK_TYPE done_time;
+	
+	GET_TIME(start_time);
+	finalize_time = start_time;
+#   endif
+
+#   ifdef GATHERSTATS
+        GC_mem_found = 0;
+#   endif
+#   ifdef FIND_LEAK
+      /* Mark all objects on the free list.  All objects should be */
+      /* marked when we're done.				   */
+	{
+	  register word size;		/* current object size		*/
+	  register ptr_t p;	/* pointer to current object	*/
+	  register struct hblk * h;	/* pointer to block containing *p */
+	  register hdr * hhdr;
+	  register int word_no;           /* "index" of *p in *q          */
+	  int kind;
+
+	  for (kind = 0; kind < GC_n_kinds; kind++) {
+	    for (size = 1; size <= MAXOBJSZ; size++) {
+	      for (p= GC_obj_kinds[kind].ok_freelist[size];
+	           p != 0; p=obj_link(p)){
+		h = HBLKPTR(p);
+		hhdr = HDR(h);
+		word_no = (((word *)p) - ((word *)h));
+		set_mark_bit_from_hdr(hhdr, word_no);
+	      }
+	    }
+	  }
+	}
+      /* Check that everything is marked */
+	GC_start_reclaim(TRUE);
+#   else
+
+      GC_finalize();
+#     ifdef STUBBORN_ALLOC
+        GC_clean_changing_list();
+#     endif
+
+#     ifdef PRINTTIMES
+	GET_TIME(finalize_time);
+#     endif
+
+      /* Clear free list mark bits, in case they got accidentally marked   */
+      /* Note: HBLKPTR(p) == pointer to head of block containing *p        */
+      /* Also subtract memory remaining from GC_mem_found count.           */
+      /* Note that composite objects on free list are cleared.             */
+      /* Thus accidentally marking a free list is not a problem;  only     */
+      /* objects on the list itself will be marked, and that's fixed here. */
+      {
+	register word size;		/* current object size		*/
+	register ptr_t p;	/* pointer to current object	*/
+	register struct hblk * h;	/* pointer to block containing *p */
+	register hdr * hhdr;
+	register int word_no;           /* "index" of *p in *q          */
+	int kind;
+
+	for (kind = 0; kind < GC_n_kinds; kind++) {
+	  for (size = 1; size <= MAXOBJSZ; size++) {
+	    for (p= GC_obj_kinds[kind].ok_freelist[size];
+	         p != 0; p=obj_link(p)){
+		h = HBLKPTR(p);
+		hhdr = HDR(h);
+		word_no = (((word *)p) - ((word *)h));
+		clear_mark_bit_from_hdr(hhdr, word_no);
+#		ifdef GATHERSTATS
+		    GC_mem_found -= size;
+#		endif
+	    }
+	  }
+	}
+      }
+
+
+#     ifdef PRINTSTATS
+	GC_printf1("Bytes recovered before sweep - f.l. count = %ld\n",
+	          (long)WORDS_TO_BYTES(GC_mem_found));
+#     endif
+
+    /* Reconstruct free lists to contain everything not marked */
+      GC_start_reclaim(FALSE);
+    
+#   endif /* !FIND_LEAK */
+
+#   ifdef PRINTSTATS
+	GC_printf2(
+		  "Immediately reclaimed %ld bytes in heap of size %lu bytes\n",
+	          (long)WORDS_TO_BYTES(GC_mem_found),
+	          (unsigned long)GC_heapsize);
+	GC_printf2("%lu (atomic) + %lu (composite) collectable bytes in use\n",
+	           (unsigned long)WORDS_TO_BYTES(GC_atomic_in_use),
+	           (unsigned long)WORDS_TO_BYTES(GC_composite_in_use));
+#   endif
+
+    /* Reset or increment counters for next cycle */
+      GC_words_allocd_before_gc += GC_words_allocd;
+      GC_non_gc_bytes_at_gc = GC_non_gc_bytes;
+      GC_words_allocd = 0;
+      GC_words_wasted = 0;
+      GC_mem_freed = 0;
+      
+#   ifdef PRINTTIMES
+	GET_TIME(done_time);
+	GC_printf2("Finalize + initiate sweep took %lu + %lu msecs\n",
+	           MS_TIME_DIFF(finalize_time,start_time),
+	           MS_TIME_DIFF(done_time,finalize_time));
+#   endif
+}
+
+/* Externally callable routine to invoke full, stop-world collection */
+# if defined(__STDC__) || defined(__cplusplus)
+    int GC_try_to_collect(GC_stop_func stop_func)
+# else
+    int GC_try_to_collect(stop_func)
+    GC_stop_func stop_func;
+# endif
+{
+    int result;
+    DCL_LOCK_STATE;
+    
+    GC_invoke_finalizers();
+    DISABLE_SIGNALS();
+    LOCK();
+    ENTER_GC();
+    if (!GC_is_initialized) GC_init_inner();
+    /* Minimize junk left in my registers */
+      GC_noop(0,0,0,0,0,0);
+    result = (int)GC_try_to_collect_inner(stop_func);
+    EXIT_GC();
+    UNLOCK();
+    ENABLE_SIGNALS();
+    if(result) GC_invoke_finalizers();
+    return(result);
+}
+
+void GC_gcollect GC_PROTO(())
+{
+    (void)GC_try_to_collect(GC_never_stop_func);
+}
+
+word GC_n_heap_sects = 0;	/* Number of sections currently in heap. */
+
+/*
+ * Use the chunk of memory starting at p of syze bytes as part of the heap.
+ * Assumes p is HBLKSIZE aligned, and bytes is a multiple of HBLKSIZE.
+ */
+void GC_add_to_heap(p, bytes)
+struct hblk *p;
+word bytes;
+{
+    word words;
+    
+    if (GC_n_heap_sects >= MAX_HEAP_SECTS) {
+    	ABORT("Too many heap sections: Increase MAXHINCR or MAX_HEAP_SECTS");
+    }
+    if (!GC_install_header(p)) {
+    	/* This is extremely unlikely. Can't add it.  This will		*/
+    	/* almost certainly result in a	0 return from the allocator,	*/
+    	/* which is entirely appropriate.				*/
+    	return;
+    }
+    GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p;
+    GC_heap_sects[GC_n_heap_sects].hs_bytes = bytes;
+    GC_n_heap_sects++;
+    words = BYTES_TO_WORDS(bytes - HDR_BYTES);
+    HDR(p) -> hb_sz = words;
+    GC_freehblk(p);
+    GC_heapsize += bytes;
+    if ((ptr_t)p <= GC_least_plausible_heap_addr
+        || GC_least_plausible_heap_addr == 0) {
+        GC_least_plausible_heap_addr = (ptr_t)p - sizeof(word);
+        	/* Making it a little smaller than necessary prevents	*/
+        	/* us from getting a false hit from the variable	*/
+        	/* itself.  There's some unintentional reflection	*/
+        	/* here.						*/
+    }
+    if ((ptr_t)p + bytes >= GC_greatest_plausible_heap_addr) {
+        GC_greatest_plausible_heap_addr = (ptr_t)p + bytes;
+    }
+}
+
+# if !defined(NO_DEBUGGING)
+void GC_print_heap_sects()
+{
+    register unsigned i;
+    
+    GC_printf1("Total heap size: %lu\n", (unsigned long) GC_heapsize);
+    for (i = 0; i < GC_n_heap_sects; i++) {
+        unsigned long start = (unsigned long) GC_heap_sects[i].hs_start;
+        unsigned long len = (unsigned long) GC_heap_sects[i].hs_bytes;
+        struct hblk *h;
+        unsigned nbl = 0;
+        
+    	GC_printf3("Section %ld from 0x%lx to 0x%lx ", (unsigned long)i,
+    		   start, (unsigned long)(start + len));
+    	for (h = (struct hblk *)start; h < (struct hblk *)(start + len); h++) {
+    	    if (GC_is_black_listed(h, HBLKSIZE)) nbl++;
+    	}
+    	GC_printf2("%lu/%lu blacklisted\n", (unsigned long)nbl,
+    		   (unsigned long)(len/HBLKSIZE));
+    }
+}
+# endif
+
+ptr_t GC_least_plausible_heap_addr = (ptr_t)ONES;
+ptr_t GC_greatest_plausible_heap_addr = 0;
+
+ptr_t GC_max(x,y)
+ptr_t x, y;
+{
+    return(x > y? x : y);
+}
+
+ptr_t GC_min(x,y)
+ptr_t x, y;
+{
+    return(x < y? x : y);
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    void GC_set_max_heap_size(GC_word n)
+# else
+    void GC_set_max_heap_size(n)
+    GC_word n;
+# endif
+{
+    GC_max_heapsize = n;
+}
+
+GC_word GC_max_retries = 0;
+
+/*
+ * this explicitly increases the size of the heap.  It is used
+ * internally, but may also be invoked from GC_expand_hp by the user.
+ * The argument is in units of HBLKSIZE.
+ * Tiny values of n are rounded up.
+ * Returns FALSE on failure.
+ */
+bool GC_expand_hp_inner(n)
+word n;
+{
+    word bytes;
+    struct hblk * space;
+    word expansion_slop;	/* Number of bytes by which we expect the */
+    				/* heap to expand soon.			  */
+
+    if (n < MINHINCR) n = MINHINCR;
+    bytes = n * HBLKSIZE;
+    
+    if (GC_max_heapsize != 0 && GC_heapsize + bytes > GC_max_heapsize) {
+        /* Exceeded self-imposed limit */
+        return(FALSE);
+    }
+    space = GET_MEM(bytes);
+    if( space == 0 ) {
+	return(FALSE);
+    }
+#   ifdef PRINTSTATS
+	GC_printf2("Increasing heap size by %lu after %lu allocated bytes\n",
+	           (unsigned long)bytes,
+	           (unsigned long)WORDS_TO_BYTES(GC_words_allocd));
+# 	ifdef UNDEFINED
+	  GC_printf1("Root size = %lu\n", GC_root_size);
+	  GC_print_block_list(); GC_print_hblkfreelist();
+	  GC_printf0("\n");
+#	endif
+#   endif
+    expansion_slop = 8 * WORDS_TO_BYTES(min_words_allocd());
+    if (5 * HBLKSIZE * MAXHINCR > expansion_slop) {
+        expansion_slop = 5 * HBLKSIZE * MAXHINCR;
+    }
+    if (GC_last_heap_addr == 0 && !((word)space & SIGNB)
+        || GC_last_heap_addr != 0 && GC_last_heap_addr < (ptr_t)space) {
+        /* Assume the heap is growing up */
+        GC_greatest_plausible_heap_addr =
+            GC_max(GC_greatest_plausible_heap_addr,
+                   (ptr_t)space + bytes + expansion_slop);
+    } else {
+        /* Heap is growing down */
+        GC_least_plausible_heap_addr =
+            GC_min(GC_least_plausible_heap_addr,
+                   (ptr_t)space - expansion_slop);
+    }
+    GC_prev_heap_addr = GC_last_heap_addr;
+    GC_last_heap_addr = (ptr_t)space;
+    GC_add_to_heap(space, bytes);
+    return(TRUE);
+}
+
+/* MATTHEW: To report out-of-memory in an app- or platform-specific way. */
+void (*GC_out_of_memory)(void) = NULL;
+
+/* Really returns a bool, but it's externally visible, so that's clumsy. */
+/* Arguments is in bytes.						*/
+# if defined(__STDC__) || defined(__cplusplus)
+  int GC_expand_hp(size_t bytes)
+# else
+  int GC_expand_hp(bytes)
+  size_t bytes;
+# endif
+{
+    int result;
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    if (!GC_is_initialized) GC_init_inner();
+    result = (int)GC_expand_hp_inner(divHBLKSZ((word)bytes));
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return(result);
+}
+
+bool GC_collect_or_expand(needed_blocks, ignore_off_page)
+word needed_blocks;
+bool ignore_off_page;
+{
+    static unsigned count = 0;  /* How many failures? */
+    
+    if (!GC_incremental && !GC_dont_gc && GC_should_collect()) {
+      GC_gcollect_inner();
+    } else {
+      word blocks_to_get = GC_heapsize/(HBLKSIZE*GC_free_space_divisor)
+      			   + needed_blocks;
+      
+      if (blocks_to_get > MAXHINCR) {
+          word slop;
+          
+          if (ignore_off_page) {
+              slop = 4;
+          } else {
+	      slop = 2*divHBLKSZ(BL_LIMIT);
+	      if (slop > needed_blocks) slop = needed_blocks;
+	  }
+          if (needed_blocks + slop > MAXHINCR) {
+              blocks_to_get = needed_blocks + slop;
+          } else {
+              blocks_to_get = MAXHINCR;
+          }
+      }
+      if (!GC_expand_hp_inner(blocks_to_get)
+        && !GC_expand_hp_inner(needed_blocks)) {
+      	if (count++ < GC_max_retries) {
+      	    WARN("Out of Memory!  Trying to continue ...\n", 0);
+	    GC_gcollect_inner();
+	} else {
+	    /* MATTHEW */
+	    if (GC_out_of_memory)
+	      GC_out_of_memory();
+
+	    WARN("Out of Memory!  Returning NIL!\n", 0);
+	    return(FALSE);
+	}
+      } else if (count) {
+#	  ifdef PRINTSTATS
+	    GC_printf0("Memory available again ...\n");
+#	  endif
+          count = 0;
+      }
+    }
+    return(TRUE);
+}
+
+/*
+ * Make sure the object free list for sz is not empty.
+ * Return a pointer to the first object on the free list.
+ * The object MUST BE REMOVED FROM THE FREE LIST BY THE CALLER.
+ * Assumes we hold the allocator lock and signals are disabled.
+ *
+ */
+ptr_t GC_allocobj(sz, kind)
+word sz;
+int kind;
+{
+    register ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]);
+    
+    if (sz == 0) return(0);
+
+    while (*flh == 0) {
+      ENTER_GC();
+      /* Do our share of marking work */
+        if(GC_incremental && !GC_dont_gc) GC_collect_a_little_inner(1);
+      /* Sweep blocks for objects of this size */
+          GC_continue_reclaim(sz, kind);
+      EXIT_GC();
+      if (*flh == 0) {
+        GC_new_hblk(sz, kind);
+      }
+      if (*flh == 0) {
+        ENTER_GC();
+        if (!GC_collect_or_expand((word)1,FALSE)) {
+	    EXIT_GC();
+	    return(0);
+	}
+	EXIT_GC();
+      }
+    }
+    
+    return(*flh);
+}
diff --git a/src/mzscheme/gc/alpha_mach_dep.s b/src/mzscheme/gc/alpha_mach_dep.s
new file mode 100644
index 0000000..087baea
--- /dev/null
+++ b/src/mzscheme/gc/alpha_mach_dep.s
@@ -0,0 +1,60 @@
+ # $Id: alpha_mach_dep.s,v 1.2 1993/01/18 22:54:51 dosser Exp $
+
+# define call_push(x)    						\
+	lda   $16, 0(x);    	/* copy x to first argument register */	\
+	jsr   $26, GC_push_one; /* call GC_push_one, ret addr in $26 */	\
+	ldgp  $gp, 0($26)	/* restore $gp register from $ra */
+	
+        .text
+        .align  4
+        .globl  GC_push_regs
+        .ent    GC_push_regs 2
+GC_push_regs:
+	ldgp    $gp, 0($27)		# set gp from the procedure value reg
+	lda     $sp, -32($sp)		# make stack frame
+	stq     $26, 8($sp)		# save return address
+        .mask   0x04000000, -8
+        .frame  $sp, 16, $26, 0
+
+ #      call_push($0)    # expression eval and int func result
+
+ #      call_push($1)    # temp regs - not preserved cross calls
+ #      call_push($2)
+ #      call_push($3)
+ #      call_push($4)
+ #      call_push($5)
+ #      call_push($6)
+ #      call_push($7)
+ #      call_push($8)
+
+        call_push($9)    # Saved regs
+        call_push($10)
+        call_push($11)
+        call_push($12)
+        call_push($13)
+        call_push($14)
+
+        call_push($15)   # frame ptr or saved reg
+
+ #      call_push($16)   # argument regs - not preserved cross calls
+ #      call_push($17)
+ #      call_push($18)
+ #      call_push($19)
+ #      call_push($20)
+ #      call_push($21)
+
+ #      call_push($22)   # temp regs - not preserved cross calls
+ #      call_push($23)
+ #      call_push($24)
+ #      call_push($25)
+
+ #      call_push($26)   # return address - expression eval
+ #      call_push($27)   # procedure value or temporary reg
+ #      call_push($28)   # assembler temp - not presrved
+        call_push($29)   # Global Pointer
+ #      call_push($30)   # Stack Pointer
+
+	ldq     $26, 8($sp)		# restore return address
+	lda     $sp, 32($sp)		# pop stack frame
+	ret     $31, ($26), 1		# return ($31 == hardwired zero)
+	.end    GC_push_regs
diff --git a/src/mzscheme/gc/barrett_diagram b/src/mzscheme/gc/barrett_diagram
new file mode 100644
index 0000000..27e80dc
--- /dev/null
+++ b/src/mzscheme/gc/barrett_diagram
@@ -0,0 +1,106 @@
+This is an ASCII diagram of the data structure used to check pointer
+validity.  It was provided by Dave Barrett <barrett@asgard.cs.colorado.edu>,
+and should be of use to others attempting to understand the code.
+The data structure in GC4.X is essentially the same.   -HB
+
+
+
+
+		Data Structure used by GC_base in gc3.7:
+			      21-Apr-94
+			 
+			
+
+
+    63                  LOG_TOP_SZ[11]  LOG_BOTTOM_SZ[10]   LOG_HBLKSIZE[13]
+   +------------------+----------------+------------------+------------------+
+ p:|                  |   TL_HASH(hi)  |                  |   HBLKDISPL(p)   |
+   +------------------+----------------+------------------+------------------+
+    \-----------------------HBLKPTR(p)-------------------/
+    \------------hi-------------------/ 
+                      \______ ________/ \________ _______/ \________ _______/
+                             V                   V                  V
+                             |                   |                  |
+           GC_top_index[]    |                   |                  | 
+ ---      +--------------+   |                   |                  |  
+  ^       |              |   |                   |                  |   
+  |       |              |   |                   |                  |   
+ TOP      +--------------+<--+                   |                  |      
+ _SZ   +-<|      []      | *                     |                  |     
+(items)|  +--------------+  if 0 < bi< HBLKSIZE  |                  |    
+  |    |  |              | then large object     |                  |    
+  |    |  |              | starts at the bi'th   |                  |    
+  v    |  |              | HBLK before p.        |             i    |    
+ ---   |  +--------------+                       |          (word-  |    
+       v                                         |         aligned) |    
+   bi= |GET_BI(p){->hash_link}->key==hi          |                  |   
+       v                                         |                  |    
+       |   (bottom_index)  \ scratch_alloc'd     |                  |    
+       |   ( struct  bi )  / by get_index()      |                  |    
+ ---   +->+--------------+                       |                  |    
+  ^       |              |                       |                  |
+  ^       |              |                       |                  |
+ BOTTOM   |              |   ha=GET_HDR_ADDR(p)  |                  |
+_SZ(items)+--------------+<----------------------+          +-------+
+  |   +--<|   index[]    |                                  |         
+  |   |   +--------------+                      GC_obj_map: v              
+  |   |   |              |              from      / +-+-+-----+-+-+-+-+  --- 
+  v   |   |              |              GC_add   < 0| | |     | | | | |   ^  
+ ---  |   +--------------+             _map_entry \ +-+-+-----+-+-+-+-+   |  
+      |   |   asc_link   |                          +-+-+-----+-+-+-+-+ MAXOBJSZ
+      |   +--------------+                      +-->| | |  j  | | | | |  +1   
+      |   |     key      |                      |   +-+-+-----+-+-+-+-+   |  
+      |   +--------------+                      |   +-+-+-----+-+-+-+-+   | 
+      |   |  hash_link   |                      |   | | |     | | | | |   v 
+      |   +--------------+                      |   +-+-+-----+-+-+-+-+  ---
+      |                                         |   |<--MAX_OFFSET--->|   
+      |                                         |         (bytes)
+HDR(p)| GC_find_header(p)                       |   |<--MAP_ENTRIES-->| 
+      |                           \ from        |    =HBLKSIZE/WORDSZ   
+      |    (hdr) (struct hblkhdr) / alloc_hdr() |    (1024 on Alpha)
+      +-->+----------------------+              |    (8/16 bits each)
+GET_HDR(p)| word   hb_sz (words) |              |          
+          +----------------------+              |     
+          | struct hblk *hb_next |              |
+          +----------------------+              |       
+          |mark_proc hb_mark_proc|              |
+          +----------------------+              |
+          | char * hb_map        |>-------------+
+          +----------------------+           
+          | ushort hb_obj_kind   |           
+          +----------------------+           
+          |   hb_last_reclaimed  |           
+ ---      +----------------------+                
+  ^       |                      |
+ MARK_BITS|       hb_marks[]     | *if hdr is free, hb_sz + DISCARD_WORDS
+_SZ(words)|                      |  is the size of a heap chunk (struct hblk)
+  v       |                      |  of at least MININCR*HBLKSIZE bytes (below),
+ ---      +----------------------+  otherwise, size of each object in chunk.
+
+Dynamic data structures above are interleaved throughout the heap in blocks of 
+size MININCR * HBLKSIZE bytes as done by gc_scratch_alloc which cannot be
+freed; free lists are used (e.g. alloc_hdr).  HBLKs's below are collected.
+
+	      (struct hblk)      
+ ---      +----------------------+ < HBLKSIZE ---         ---          DISCARD_
+  ^       |garbage[DISCARD_WORDS]|   aligned   ^           ^ HDR_BYTES WORDS
+  |       |                      |             |           v (bytes)   (words)
+  |       +-----hb_body----------+ < WORDSZ    |          ---   ---   
+  |       |                      |   aligned   |           ^     ^
+  |       |      Object 0        |             |           hb_sz |
+  |       |                      |           i |(word-    (words)|
+  |       |                      |      (bytes)|aligned)   v     |
+  |       + - - - - - - - - - - -+ ---         |          ---    |
+  |       |                      |  ^          |           ^     |
+  n *     |                      |  j (words)  |          hb_sz BODY_SZ 
+ HBLKSIZE |      Object 1        |  v          v           |   (words)
+ (bytes)  |                      |---------------          v   MAX_OFFSET
+  |       + - - - - - - - - - - -+                        ---  (bytes)
+  |       |                      | !All_INTERIOR_PTRS      ^     |
+  |       |                      | sets j only for       hb_sz   |
+  |       |      Object N        | valid object offsets.   |     |
+  v       |                      | All objects WORDSZ      v     v
+ ---      +----------------------+ aligned.               ---   ---
+
+DISCARD_WORDS is normally zero.  Indeed the collector has not been tested
+with another value in ages.
diff --git a/src/mzscheme/gc/blacklst.c b/src/mzscheme/gc/blacklst.c
new file mode 100644
index 0000000..7b27993
--- /dev/null
+++ b/src/mzscheme/gc/blacklst.c
@@ -0,0 +1,247 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, August 9, 1995 6:09 pm PDT */
+# include "gc_priv.h"
+
+/*
+ * We maintain several hash tables of hblks that have had false hits.
+ * Each contains one bit per hash bucket;  If any page in the bucket
+ * has had a false hit, we assume that all of them have.
+ * See the definition of page_hash_table in gc_private.h.
+ * False hits from the stack(s) are much more dangerous than false hits
+ * from elsewhere, since the former can pin a large object that spans the
+ * block, eventhough it does not start on the dangerous block.
+ */
+ 
+/*
+ * Externally callable routines are:
+ 
+ * GC_add_to_black_list_normal
+ * GC_add_to_black_list_stack
+ * GC_promote_black_lists
+ * GC_is_black_listed
+ *
+ * All require that the allocator lock is held.
+ */
+
+/* Pointers to individual tables.  We replace one table by another by 	*/
+/* switching these pointers. 						*/
+word * GC_old_normal_bl;
+		/* Nonstack false references seen at last full		*/
+		/* collection.						*/
+word * GC_incomplete_normal_bl;
+		/* Nonstack false references seen since last		*/
+		/* full collection.					*/
+word * GC_old_stack_bl;
+word * GC_incomplete_stack_bl;
+
+word GC_total_black_listed;
+
+word GC_black_list_spacing = MINHINCR*HBLKSIZE;  /* Initial rough guess */
+
+void GC_clear_bl();
+
+void GC_bl_init()
+{
+# ifndef ALL_INTERIOR_POINTERS
+    GC_old_normal_bl = (word *)
+    			 GC_scratch_alloc((word)(sizeof (page_hash_table)));
+    GC_incomplete_normal_bl = (word *)GC_scratch_alloc
+    					((word)(sizeof(page_hash_table)));
+    if (GC_old_normal_bl == 0 || GC_incomplete_normal_bl == 0) {
+        GC_err_printf0("Insufficient memory for black list\n");
+        EXIT();
+    }
+    GC_clear_bl(GC_old_normal_bl);
+    GC_clear_bl(GC_incomplete_normal_bl);
+# endif
+    GC_old_stack_bl = (word *)GC_scratch_alloc((word)(sizeof(page_hash_table)));
+    GC_incomplete_stack_bl = (word *)GC_scratch_alloc
+    					((word)(sizeof(page_hash_table)));
+    if (GC_old_stack_bl == 0 || GC_incomplete_stack_bl == 0) {
+        GC_err_printf0("Insufficient memory for black list\n");
+        EXIT();
+    }
+    GC_clear_bl(GC_old_stack_bl);
+    GC_clear_bl(GC_incomplete_stack_bl);
+}
+		
+void GC_clear_bl(doomed)
+word *doomed;
+{
+    BZERO(doomed, sizeof(page_hash_table));
+}
+
+void GC_copy_bl(old, new)
+word *new, *old;
+{
+    BCOPY(old, new, sizeof(page_hash_table));
+}
+
+static word total_black_listed();
+
+/* Signal the completion of a collection.  Turn the incomplete black	*/
+/* lists into new black lists, etc.					*/			 
+void GC_promote_black_lists()
+{
+    word * very_old_normal_bl = GC_old_normal_bl;
+    word * very_old_stack_bl = GC_old_stack_bl;
+    
+    GC_old_normal_bl = GC_incomplete_normal_bl;
+    GC_old_stack_bl = GC_incomplete_stack_bl;
+#   ifndef ALL_INTERIOR_POINTERS
+      GC_clear_bl(very_old_normal_bl);
+#   endif
+    GC_clear_bl(very_old_stack_bl);
+    GC_incomplete_normal_bl = very_old_normal_bl;
+    GC_incomplete_stack_bl = very_old_stack_bl;
+    GC_total_black_listed = total_black_listed();
+#   ifdef PRINTSTATS
+  	GC_printf1("%ld blacklisted bytes in heap\n",
+  		   (unsigned long)GC_total_black_listed);
+#   endif
+    if (GC_total_black_listed != 0) {
+        GC_black_list_spacing = HBLKSIZE*(GC_heapsize/GC_total_black_listed);
+    }
+    if (GC_black_list_spacing < 3 * HBLKSIZE) {
+    	GC_black_list_spacing = 3 * HBLKSIZE;
+    }
+}
+
+void GC_unpromote_black_lists()
+{
+#   ifndef ALL_INTERIOR_POINTERS
+      GC_copy_bl(GC_old_normal_bl, GC_incomplete_normal_bl);
+#   endif
+    GC_copy_bl(GC_old_stack_bl, GC_incomplete_stack_bl);
+}
+
+# ifndef ALL_INTERIOR_POINTERS
+/* P is not a valid pointer reference, but it falls inside	*/
+/* the plausible heap bounds.					*/
+/* Add it to the normal incomplete black list if appropriate.	*/
+void GC_add_to_black_list_normal(p)
+word p;
+{
+    if (!(GC_modws_valid_offsets[p & (sizeof(word)-1)])) return;
+    {
+        register int index = PHT_HASH(p);
+        
+        if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) {
+#   	    ifdef PRINTBLACKLIST
+		if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) {
+	    	  GC_printf1("Black listing (normal) 0x%lx\n",
+	    	  	     (unsigned long) p);
+	    	}
+#           endif
+            set_pht_entry_from_index(GC_incomplete_normal_bl, index);
+        } /* else this is probably just an interior pointer to an allocated */
+          /* object, and isn't worth black listing.			    */
+    }
+}
+# endif
+
+/* And the same for false pointers from the stack. */
+void GC_add_to_black_list_stack(p)
+word p;
+{
+    register int index = PHT_HASH(p);
+        
+    if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) {
+#   	ifdef PRINTBLACKLIST
+	    if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) {
+	    	  GC_printf1("Black listing (stack) 0x%lx\n",
+	    	             (unsigned long)p);
+	    }
+#       endif
+	set_pht_entry_from_index(GC_incomplete_stack_bl, index);
+    }
+}
+
+/*
+ * Is the block starting at h of size len bytes black listed?   If so,
+ * return the address of the next plausible r such that (r, len) might not
+ * be black listed.  (R may not actually be in the heap.  We guarantee only
+ * that every smaller value of r after h is also black listed.)
+ * If (h,len) is not black listed, return 0.
+ * Knows about the structure of the black list hash tables.
+ */
+struct hblk * GC_is_black_listed(h, len)
+struct hblk * h;
+word len;
+{
+    register int index = PHT_HASH((word)h);
+    register word i;
+    word nblocks = divHBLKSZ(len);
+
+#   ifndef ALL_INTERIOR_POINTERS
+      if (get_pht_entry_from_index(GC_old_normal_bl, index)
+          || get_pht_entry_from_index(GC_incomplete_normal_bl, index)) {
+        return(h+1);
+      }
+#   endif
+    
+    for (i = 0; ; ) {
+        if (GC_old_stack_bl[divWORDSZ(index)] == 0
+            && GC_incomplete_stack_bl[divWORDSZ(index)] == 0) {
+            /* An easy case */
+            i += WORDSZ - modWORDSZ(index);
+        } else {
+          if (get_pht_entry_from_index(GC_old_stack_bl, index)
+              || get_pht_entry_from_index(GC_incomplete_stack_bl, index)) {
+            return(h+i+1);
+          }
+          i++;
+        }
+        if (i >= nblocks) break;
+        index = PHT_HASH((word)(h+i));
+    }
+    return(0);
+}
+
+
+/* Return the number of blacklisted blocks in a given range.	*/
+/* Used only for statistical purposes.				*/
+/* Looks only at the GC_incomplete_stack_bl.			*/
+word GC_number_stack_black_listed(start, endp1)
+struct hblk *start, *endp1;
+{
+    register struct hblk * h;
+    word result = 0;
+    
+    for (h = start; h < endp1; h++) {
+        register int index = PHT_HASH((word)h);
+        
+        if (get_pht_entry_from_index(GC_old_stack_bl, index)) result++;
+    }
+    return(result);
+}
+
+
+/* Return the total number of (stack) black-listed bytes. */
+static word total_black_listed()
+{
+    register unsigned i;
+    word total = 0;
+    
+    for (i = 0; i < GC_n_heap_sects; i++) {
+    	struct hblk * start = (struct hblk *) GC_heap_sects[i].hs_start;
+    	word len = (word) GC_heap_sects[i].hs_bytes;
+    	struct hblk * endp1 = start + len/HBLKSIZE;
+    	
+    	total += GC_number_stack_black_listed(start, endp1);
+    }
+    return(total * HBLKSIZE);
+}
+
diff --git a/src/mzscheme/gc/callprocs b/src/mzscheme/gc/callprocs
new file mode 100755
index 0000000..a8793f0
--- /dev/null
+++ b/src/mzscheme/gc/callprocs
@@ -0,0 +1,4 @@
+#!/bin/sh
+GC_DEBUG=1
+export GC_DEBUG
+$* 2>&1 | awk '{print "0x3e=c\""$0"\""};/^\t##PC##=/ {if ($2 != 0) {print $2"?i"}}' | adb $1 | sed "s/^		>/>/"
diff --git a/src/mzscheme/gc/checksums.c b/src/mzscheme/gc/checksums.c
new file mode 100644
index 0000000..98ef08f
--- /dev/null
+++ b/src/mzscheme/gc/checksums.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 1992-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, March 29, 1995 12:51 pm PST */
+# ifdef CHECKSUMS
+
+# include "gc_priv.h"
+
+/* This is debugging code intended to verify the results of dirty bit	*/
+/* computations. Works only in a single threaded environment.		*/
+/* We assume that stubborn objects are changed only when they are 	*/
+/* enabled for writing.  (Certain kinds of writing are actually		*/
+/* safe under other conditions.)					*/
+# define NSUMS 2000
+
+# define OFFSET 0x10000
+
+typedef struct {
+	bool new_valid;
+	word old_sum;
+	word new_sum;
+	struct hblk * block;	/* Block to which this refers + OFFSET  */
+				/* to hide it from colector.		*/
+} page_entry;
+
+page_entry GC_sums [NSUMS];
+
+word GC_checksum(h)
+struct hblk *h;
+{
+    register word *p = (word *)h;
+    register word *lim = (word *)(h+1);
+    register word result = 0;
+    
+    while (p < lim) {
+        result += *p++;
+    }
+    return(result | 0x80000000 /* doesn't look like pointer */);
+}
+
+# ifdef STUBBORN_ALLOC
+/* Check whether a stubborn object from the given block appears on	*/
+/* the appropriate free list.						*/
+bool GC_on_free_list(h)
+struct hblk *h;
+{
+    register hdr * hhdr = HDR(h);
+    register int sz = hhdr -> hb_sz;
+    ptr_t p;
+    
+    if (sz > MAXOBJSZ) return(FALSE);
+    for (p = GC_sobjfreelist[sz]; p != 0; p = obj_link(p)) {
+        if (HBLKPTR(p) == h) return(TRUE);
+    }
+    return(FALSE);
+}
+# endif
+ 
+int GC_n_dirty_errors;
+int GC_n_changed_errors;
+int GC_n_clean;
+int GC_n_dirty;
+
+void GC_update_check_page(h, index)
+struct hblk *h;
+int index;
+{
+    page_entry *pe = GC_sums + index;
+    register hdr * hhdr = HDR(h);
+    
+    if (pe -> block != 0 && pe -> block != h + OFFSET) ABORT("goofed");
+    pe -> old_sum = pe -> new_sum;
+    pe -> new_sum = GC_checksum(h);
+#   ifndef MSWIN32
+        if (pe -> new_sum != 0 && !GC_page_was_ever_dirty(h)) {
+            GC_printf1("GC_page_was_ever_dirty(0x%lx) is wrong\n",
+        	       (unsigned long)h);
+        }
+#   endif
+    if (GC_page_was_dirty(h)) {
+    	GC_n_dirty++;
+    } else {
+    	GC_n_clean++;
+    }
+    if (pe -> new_valid && pe -> old_sum != pe -> new_sum) {
+    	if (!GC_page_was_dirty(h) || !GC_page_was_ever_dirty(h)) {
+    	    /* Set breakpoint here */GC_n_dirty_errors++;
+    	}
+#	ifdef STUBBORN_ALLOC
+    	  if (!IS_FORWARDING_ADDR_OR_NIL(hhdr)
+    	    && hhdr -> hb_map != GC_invalid_map
+    	    && hhdr -> hb_obj_kind == STUBBORN
+    	    && !GC_page_was_changed(h)
+    	    && !GC_on_free_list(h)) {
+    	    /* if GC_on_free_list(h) then reclaim may have touched it	*/
+    	    /* without any allocations taking place.			*/
+    	    /* Set breakpoint here */GC_n_changed_errors++;
+    	  }
+#	endif
+    }
+    pe -> new_valid = TRUE;
+    pe -> block = h + OFFSET;
+}
+
+word GC_bytes_in_used_blocks;
+
+void GC_add_block(h, dummy)
+struct hblk *h;
+word dummy;
+{
+   register hdr * hhdr = HDR(h);
+   register bytes = WORDS_TO_BYTES(hhdr -> hb_sz);
+   
+   bytes += HDR_BYTES + HBLKSIZE-1;
+   bytes &= ~(HBLKSIZE-1);
+   GC_bytes_in_used_blocks += bytes;
+}
+
+void GC_check_blocks()
+{
+    word bytes_in_free_blocks = 0;
+    struct hblk * h = GC_hblkfreelist;
+    hdr * hhdr = HDR(h);
+    word sz;
+    
+    GC_bytes_in_used_blocks = 0;
+    GC_apply_to_all_blocks(GC_add_block, (word)0);
+    while (h != 0) {
+        sz = hhdr -> hb_sz;
+        bytes_in_free_blocks += sz;
+        h = hhdr -> hb_next;
+        hhdr = HDR(h);
+    }
+    GC_printf2("GC_bytes_in_used_blocks = %ld, bytes_in_free_blocks = %ld ",
+    		GC_bytes_in_used_blocks, bytes_in_free_blocks);
+    GC_printf1("GC_heapsize = %ld\n", GC_heapsize);
+    if (GC_bytes_in_used_blocks + bytes_in_free_blocks != GC_heapsize) {
+    	GC_printf0("LOST SOME BLOCKS!!\n");
+    }
+}
+
+/* Should be called immediately after GC_read_dirty and GC_read_changed. */
+void GC_check_dirty()
+{
+    register int index;
+    register unsigned i;
+    register struct hblk *h;
+    register ptr_t start;
+    
+    GC_check_blocks();
+    
+    GC_n_dirty_errors = 0;
+    GC_n_changed_errors = 0;
+    GC_n_clean = 0;
+    GC_n_dirty = 0;
+    
+    index = 0;
+    for (i = 0; i < GC_n_heap_sects; i++) {
+    	start = GC_heap_sects[i].hs_start;
+        for (h = (struct hblk *)start;
+             h < (struct hblk *)(start + GC_heap_sects[i].hs_bytes);
+             h++) {
+             GC_update_check_page(h, index);
+             index++;
+             if (index >= NSUMS) goto out;
+        }
+    }
+out:
+    GC_printf2("Checked %lu clean and %lu dirty pages\n",
+    	      (unsigned long) GC_n_clean, (unsigned long) GC_n_dirty);
+    if (GC_n_dirty_errors > 0) {
+        GC_printf1("Found %lu dirty bit errors\n",
+        	   (unsigned long)GC_n_dirty_errors);
+    }
+    if (GC_n_changed_errors > 0) {
+    	GC_printf1("Found %lu changed bit errors\n",
+        	   (unsigned long)GC_n_changed_errors);
+	GC_printf0("These may be benign (provoked by nonpointer changes)\n");
+#	ifdef THREADS
+	    GC_printf0(
+	    "Also expect 1 per thread currently allocating a stubborn obj.\n");
+#	endif
+    }
+}
+
+# else
+
+extern int GC_quiet;
+	/* ANSI C doesn't allow translation units to be empty.	*/
+	/* So we guarantee this one is nonempty.		*/
+
+# endif /* CHECKSUMS */
diff --git a/src/mzscheme/gc/config.h b/src/mzscheme/gc/config.h
new file mode 100644
index 0000000..67ffbec
--- /dev/null
+++ b/src/mzscheme/gc/config.h
@@ -0,0 +1,817 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+ 
+#ifndef CONFIG_H
+
+# define CONFIG_H
+
+/* Machine dependent parameters.  Some tuning parameters can be found	*/
+/* near the top of gc_private.h.					*/
+
+/* Machine specific parts contributed by various people.  See README file. */
+
+/* Determine the machine type: */
+# if defined(sun) && defined(mc68000)
+#    define M68K
+#    define SUNOS4
+#    define mach_type_known
+# endif
+# if defined(hp9000s300)
+#    define M68K
+#    define HP
+#    define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(m68k)
+#    define M68K
+#    define NETBSD
+#    define mach_type_known
+# endif
+# if defined(vax)
+#    define VAX
+#    ifdef ultrix
+#	define ULTRIX
+#    else
+#	define BSD
+#    endif
+#    define mach_type_known
+# endif
+# if defined(mips) || defined(__mips)
+#    define MIPS
+#    if defined(ultrix) || defined(__ultrix)
+#	define ULTRIX
+#    else
+#	if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__)
+#	  define IRIX5   /* or IRIX 6.X */
+#	else
+#	  define RISCOS  /* or IRIX 4.X */
+#	endif
+#    endif
+#    define mach_type_known
+# endif
+# if defined(sequent) && defined(i386)
+#    define I386
+#    define SEQUENT
+#    define mach_type_known
+# endif
+# if defined(sun) && defined(i386)
+#    define I386
+#    define SUNOS5
+#    define mach_type_known
+# endif
+# if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
+#    define I386
+#    define OS2
+#    define mach_type_known
+# endif
+# if defined(ibm032)
+#   define RT
+#   define mach_type_known
+# endif
+# if defined(sun) && (defined(sparc) || defined(__sparc))
+#   define SPARC
+    /* Test for SunOS 5.x */
+#     include <errno.h>
+#     ifdef ECHRNG
+#       define SUNOS5
+#     else
+#	define SUNOS4
+#     endif
+#   define mach_type_known
+# endif
+# if defined(sparc) && defined(unix) && !defined(sun)
+#   define SPARC
+#   define DRSNX
+#   define mach_type_known
+# endif
+# if defined(_IBMR2)
+#   define RS6000
+#   define mach_type_known
+# endif
+# if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
+	/* The above test may need refinement	*/
+#   define I386
+#   define SCO
+#   define mach_type_known
+# endif
+# if defined(_AUX_SOURCE)
+#   define M68K
+#   define SYSV
+#   define mach_type_known
+# endif
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1)
+#   define HP_PA
+#   define mach_type_known
+# endif
+# if defined(linux) && defined(i386)
+#    define I386
+#    define LINUX
+#    define mach_type_known
+# endif
+# if defined(__alpha) || defined(__alpha__)
+#   define ALPHA
+#   if defined(linux) || defined(__linux__)
+#     define LINUX
+#   else
+#     define OSF1	/* a.k.a Digital Unix */
+#   endif
+#   define mach_type_known
+# endif
+# if defined(_AMIGA)
+#   define M68K
+#   define AMIGA
+#   define mach_type_known
+# endif
+# if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
+#   define M68K
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(__MWERKS__) && defined(__powerc)
+#   define POWERPC
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(mc68000)
+#   define M68K
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(i386)
+#   define I386
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(__FreeBSD__) && defined(i386)
+#   define I386
+#   define FREEBSD
+#   define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(i386)
+#   define I386
+#   define NETBSD
+#   define mach_type_known
+# endif
+# if defined(bsdi) && defined(i386)
+#    define I386
+#    define BSDI
+#    define mach_type_known
+# endif
+# if !defined(mach_type_known) && defined(__386BSD__)
+#   define I386
+#   define THREE86BSD
+#   define mach_type_known
+# endif
+# if defined(_CX_UX) && defined(_M88K)
+#   define M88K
+#   define CX_UX
+#   define mach_type_known
+# endif
+# if defined(DGUX)
+#   define M88K
+    /* DGUX defined */
+#   define mach_type_known
+# endif
+/* MATTHEW: recognize _WIN32 and any _M_IX86 */
+# if (defined(_MSDOS) || defined(_WIN32)) && defined(_M_IX86)
+#   define I386
+#   define MSWIN32	/* or Win32s */
+#   define mach_type_known
+# endif
+# if defined(GO32)
+#   define I386
+#   define DJGPP  /* MSDOS running the DJGPP port of GCC */
+#   define mach_type_known
+# endif
+# if defined(__CYGWIN32__)
+#   define I386
+#   define CYGWIN32
+#   define mach_type_known
+# endif
+# if defined(__BORLANDC__)
+#   define I386
+#   define MSWIN32
+#   define mach_type_known
+# endif
+# if defined(_UTS) && !defined(mach_type_known)
+#   define S370
+#   define UTS4
+# endif
+
+/* Feel free to add more clauses here */
+
+/* Or manually define the machine type here.  A machine type is 	*/
+/* characterized by the architecture.  Some				*/
+/* machine types are further subdivided by OS.				*/
+/* the macros ULTRIX, RISCOS, and BSD to distinguish.			*/
+/* Note that SGI IRIX is treated identically to RISCOS.			*/
+/* SYSV on an M68K actually means A/UX.					*/
+/* The distinction in these cases is usually the stack starting address */
+# ifndef mach_type_known
+	--> unknown machine type
+# endif
+		    /* Mapping is: M68K       ==> Motorola 680X0	*/
+		    /*		   (SUNOS4,HP,NEXT, and SYSV (A/UX),	*/
+		    /*		   MACOS and AMIGA variants)		*/
+		    /*             I386       ==> Intel 386	 	*/
+		    /*		    (SEQUENT, OS2, SCO, LINUX, NETBSD,	*/
+		    /*		     FREEBSD, THREE86BSD, MSWIN32,	*/
+		    /* 		     BSDI, SUNOS5, NEXT	variants)	*/
+                    /*             NS32K      ==> Encore Multimax 	*/
+                    /*             MIPS       ==> R2000 or R3000	*/
+                    /*			(RISCOS, ULTRIX variants)	*/
+                    /*		   VAX	      ==> DEC VAX		*/
+                    /*			(BSD, ULTRIX variants)		*/
+                    /*		   RS6000     ==> IBM RS/6000 AIX3.X	*/
+                    /*		   RT	      ==> IBM PC/RT		*/
+                    /*		   HP_PA      ==> HP9000/700 & /800	*/
+                    /*				  HP/UX			*/
+		    /*		   SPARC      ==> SPARC under SunOS	*/
+		    /*			(SUNOS4, SUNOS5,		*/
+		    /*			 DRSNX variants)		*/
+		    /* 		   ALPHA      ==> DEC Alpha 		*/
+		    /*			(OSF1 and LINUX variants)	*/
+		    /* 		   M88K       ==> Motorola 88XX0        */
+		    /* 		        (CX_UX and DGUX)		*/
+		    /* 		   S370	      ==> 370-like machine	*/
+		    /* 			running Amdahl UTS4		*/
+
+
+/*
+ * For each architecture and OS, the following need to be defined:
+ *
+ * CPP_WORD_SZ is a simple integer constant representing the word size.
+ * in bits.  We assume byte addressibility, where a byte has 8 bits.
+ * We also assume CPP_WORD_SZ is either 32 or 64.
+ * (We care about the length of pointers, not hardware
+ * bus widths.  Thus a 64 bit processor with a C compiler that uses
+ * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
+ *
+ * MACH_TYPE is a string representation of the machine type.
+ * OS_TYPE is analogous for the OS.
+ *
+ * ALIGNMENT is the largest N, such that
+ * all pointer are guaranteed to be aligned on N byte boundaries.
+ * defining it to be 1 will always work, but perform poorly.
+ *
+ * DATASTART is the beginning of the data segment.
+ * On UNIX systems, the collector will scan the area between DATASTART
+ * and DATAEND for root pointers.
+ *
+ * DATAEND, if not &end.
+ *
+ * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
+ * the pointer size.
+ *
+ * STACKBOTTOM is the cool end of the stack, which is usually the
+ * highest address in the stack.
+ * Under PCR or OS/2, we have other ways of finding thread stacks.
+ * For each machine, the following should:
+ * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
+ * 2) define exactly one of
+ *	STACKBOTTOM (should be defined to be an expression)
+ *	HEURISTIC1
+ *	HEURISTIC2
+ * If either of the last two macros are defined, then STACKBOTTOM is computed
+ * during collector startup using one of the following two heuristics:
+ * HEURISTIC1:  Take an address inside GC_init's frame, and round it up to
+ *		the next multiple of STACK_GRAN.
+ * HEURISTIC2:  Take an address inside GC_init's frame, increment it repeatedly
+ *		in small steps (decrement if STACK_GROWS_UP), and read the value
+ *		at each location.  Remember the value when the first
+ *		Segmentation violation or Bus error is signalled.  Round that
+ *		to the nearest plausible page boundary, and use that instead
+ *		of STACKBOTTOM.
+ *
+ * If no expression for STACKBOTTOM can be found, and neither of the above
+ * heuristics are usable, the collector can still be used with all of the above
+ * undefined, provided one of the following is done:
+ * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
+ *    without reference to STACKBOTTOM.  This is appropriate for use in
+ *    conjunction with thread packages, since there will be multiple stacks.
+ *    (Allocating thread stacks in the heap, and treating them as ordinary
+ *    heap data objects is also possible as a last resort.  However, this is
+ *    likely to introduce significant amounts of excess storage retention
+ *    unless the dead parts of the thread stacks are periodically cleared.)
+ * 2) Client code may set GC_stackbottom before calling any GC_ routines.
+ *    If the author of the client code controls the main program, this is
+ *    easily accomplished by introducing a new main program, setting
+ *    GC_stackbottom to the address of a local variable, and then calling
+ *    the original main program.  The new main program would read something
+ *    like:
+ *
+ *		# include "gc_private.h"
+ *
+ *		main(argc, argv, envp)
+ *		int argc;
+ *		char **argv, **envp;
+ *		{
+ *		    int dummy;
+ *
+ *		    GC_stackbottom = (ptr_t)(&dummy);
+ *		    return(real_main(argc, argv, envp));
+ *		}
+ *
+ *
+ * Each architecture may also define the style of virtual dirty bit
+ * implementation to be used:
+ *   MPROTECT_VDB: Write protect the heap and catch faults.
+ *   PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
+ *
+ * An architecture may define DYNAMIC_LOADING if dynamic_load.c
+ * defined GC_register_dynamic_libraries() for the architecture.
+ */
+
+
+# define STACK_GRAN 0x1000000
+# ifdef M68K
+#   define MACH_TYPE "M68K"
+#   define ALIGNMENT 2
+#   ifdef NETBSD
+#	define OS_TYPE "NETBSD"
+#	define HEURISTIC2
+	extern char etext;
+#	define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef SUNOS4
+#	define OS_TYPE "SUNOS4"
+	extern char etext;
+#	define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
+#	define HEURISTIC1	/* differs	*/
+#	define DYNAMIC_LOADING
+#   endif
+#   ifdef HP
+#	define OS_TYPE "HP"
+	extern char etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0xffeffffc)
+			      /* empirically determined.  seems to work. */
+#   endif
+#   ifdef SYSV
+#	define OS_TYPE "SYSV"
+	extern etext;
+#   	define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+				   & ~0x3fffff) \
+				  +((word)&etext & 0x1fff))
+	/* This only works for shared-text binaries with magic number 0413.
+	   The other sorts of SysV binaries put the data at the end of the text,
+	   in which case the default of &etext would work.  Unfortunately,
+	   handling both would require having the magic-number available.
+	   	   		-- Parag
+	   */
+#	define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
+			/* The stack starts at the top of memory, but   */
+			/* 0x0 cannot be used as setjump_test complains */
+			/* that the stack direction is incorrect.  Two  */
+			/* bytes down from 0x0 should be safe enough.   */
+			/* 		--Parag				*/
+#   endif
+#   ifdef AMIGA
+#	define OS_TYPE "AMIGA"
+ 	    	/* STACKBOTTOM and DATASTART handled specially	*/
+ 	    	/* in os_dep.c					*/
+# 	define DATAEND	/* not needed */
+#   endif
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+			/* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND	/* not needed */
+#   endif
+#   ifdef NEXT
+#	define OS_TYPE "NEXT"
+#	define DATASTART ((ptr_t) get_etext())
+#	define STACKBOTTOM ((ptr_t) 0x4000000)
+#	define DATAEND	/* not needed */
+#   endif
+# endif
+
+# ifdef POWERPC
+#   define MACH_TYPE "POWERPC"
+#   define ALIGNMENT 2
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+			/* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND  /* not needed */
+#   endif
+# endif
+
+# ifdef VAX
+#   define MACH_TYPE "VAX"
+#   define ALIGNMENT 4	/* Pointers are longword aligned by 4.2 C compiler */
+    extern char etext;
+#   define DATASTART ((ptr_t)(&etext))
+#   ifdef BSD
+#	define OS_TYPE "BSD"
+#	define HEURISTIC1
+			/* HEURISTIC2 may be OK, but it's hard to test. */
+#   endif
+#   ifdef ULTRIX
+#	define OS_TYPE "ULTRIX"
+#	define STACKBOTTOM ((ptr_t) 0x7fffc800)
+#   endif
+# endif
+
+# ifdef RT
+#   define MACH_TYPE "RT"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t) 0x10000000)
+#   define STACKBOTTOM ((ptr_t) 0x1fffd800)
+# endif
+
+# ifdef SPARC
+#   define MACH_TYPE "SPARC"
+#   define ALIGNMENT 4	/* Required by hardware	*/
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef SUNOS5
+#	define OS_TYPE "SUNOS5"
+	extern int _etext;
+	extern int _end;
+	extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#	define DATAEND (&_end)
+#	define PROC_VDB
+#	define HEURISTIC1
+#   endif
+#   ifdef SUNOS4
+#	define OS_TYPE "SUNOS4"
+	/* [If you have a weak stomach, don't read this.]		*/
+	/* We would like to use:					*/
+/* #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
+	/* This fails occasionally, due to an ancient, but very 	*/
+	/* persistent ld bug.  &etext is set 32 bytes too high.		*/
+	/* We instead read the text segment size from the a.out		*/
+	/* header, which happens to be mapped into our address space	*/
+	/* at the start of the text segment.  The detective work here	*/
+	/* was done by Robert Ehrlich, Manuel Serrano, and Bernard	*/
+	/* Serpette of INRIA.						*/
+	/* This assumes ZMAGIC, i.e. demand-loadable executables.	*/
+#	define TEXTSTART 0x2000
+#       define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
+#	define MPROTECT_VDB
+#	define HEURISTIC1
+#   endif
+#   ifdef DRSNX
+#       define CPP_WORDSZ 32
+#	define OS_TYPE "DRSNX"
+	extern char * GC_SysVGetDataStart();
+	extern int etext;
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#	define MPROTECT_VDB
+#       define STACKBOTTOM ((ptr_t) 0xdfff0000)
+#   endif
+#   define DYNAMIC_LOADING
+# endif
+
+# ifdef I386
+#   define MACH_TYPE "I386"
+#   define ALIGNMENT 4	/* Appears to hold for all "32 bit" compilers	*/
+			/* except Borland.  The -a4 option fixes 	*/
+			/* Borland.					*/
+#   ifdef SEQUENT
+#	define OS_TYPE "SEQUENT"
+	extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0x3ffff000) 
+#   endif
+#   ifdef SUNOS5
+#	define OS_TYPE "SUNOS5"
+  	extern int etext, _start;
+  	extern char * GC_SysVGetDataStart();
+#       define DATASTART GC_SysVGetDataStart(0x1000, &etext)
+#	define STACKBOTTOM ((ptr_t)(&_start))
+#	define PROC_VDB
+#   endif
+#   ifdef SCO
+#	define OS_TYPE "SCO"
+	extern int etext;
+#   	define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+				  & ~0x3fffff) \
+				 +((word)&etext & 0xfff))
+#	define STACKBOTTOM ((ptr_t) 0x7ffffffc)
+#   endif
+#   ifdef LINUX
+#	define OS_TYPE "LINUX"
+	extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#	define STACKBOTTOM ((ptr_t)0xc0000000)
+#	define MPROTECT_VDB
+#       ifdef __ELF__
+#            define DYNAMIC_LOADING
+#       endif
+#   endif
+#   ifdef CYGWIN32
+#       define OS_TYPE "CYGWIN32"
+        extern int _bss_start__;
+#       define DATASTART       ((ptr_t)&_bss_start__)
+        extern int _data_end__;
+#       define DATAEND          ((ptr_t)&_data_end__)
+#   endif
+#   ifdef OS2
+#	define OS_TYPE "OS2"
+ 	    	/* STACKBOTTOM and DATASTART are handled specially in 	*/
+		/* os_dep.c. OS2 actually has the right			*/
+		/* system call!						*/
+#	define DATAEND	/* not needed */
+#   endif
+#   ifdef MSWIN32
+#	define OS_TYPE "MSWIN32"
+		/* STACKBOTTOM and DATASTART are handled specially in 	*/
+		/* os_dep.c.						*/
+#	define MPROTECT_VDB
+#       define DATAEND  /* not needed */
+#   endif
+#   ifdef DJGPP
+#       define OS_TYPE "DJGPP"
+        extern int etext;
+#       define DATASTART ((ptr_t)(&etext))
+#       define STACKBOTTOM ((ptr_t)0x00080000)
+		/* This may not be right.  It's rumored to vary. */
+#   endif
+#   ifdef FREEBSD
+#	define OS_TYPE "FREEBSD"
+#	define MPROTECT_VDB
+#   endif
+#   ifdef NETBSD
+#	define OS_TYPE "NETBSD"
+#   endif
+#   ifdef THREE86BSD
+#	define OS_TYPE "THREE86BSD"
+#   endif
+#   ifdef BSDI
+#	define OS_TYPE "BSDI"
+#   endif
+#   if defined(FREEBSD) || defined(NETBSD) \
+        || defined(THREE86BSD) || defined(BSDI)
+#	define HEURISTIC2
+	extern char etext;
+#	define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NEXT
+#	define OS_TYPE "NEXT"
+#	define DATASTART ((ptr_t) get_etext())
+#	define STACKBOTTOM ((ptr_t)0xc0000000)
+#	define DATAEND	/* not needed */
+#   endif
+# endif
+
+# ifdef NS32K
+#   define MACH_TYPE "NS32K"
+#   define ALIGNMENT 4
+    extern char **environ;
+#   define DATASTART ((ptr_t)(&environ))
+			      /* hideous kludge: environ is the first   */
+			      /* word in crt0.o, and delimits the start */
+			      /* of the data segment, no matter which   */
+			      /* ld options were passed through.        */
+#   define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
+# endif
+
+# ifdef MIPS
+#   define MACH_TYPE "MIPS"
+#   ifndef IRIX5
+#     define DATASTART (ptr_t)0x10000000
+			      /* Could probably be slightly higher since */
+			      /* startup code allocates lots of stuff.   */
+#   else
+      extern int _fdata;
+#     define DATASTART ((ptr_t)(&_fdata))
+#     ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x40000000
+#     else
+#	  define HEAP_START DATASTART
+#     endif
+			      /* Lowest plausible heap address.		*/
+			      /* In the MMAP case, we map there.	*/
+			      /* In either case it is used to identify	*/
+			      /* heap sections so they're not 		*/
+			      /* considered as roots.			*/
+#   endif /* IRIX5 */
+#   define HEURISTIC2
+/* #   define STACKBOTTOM ((ptr_t)0x7fff8000)  sometimes also works.  */
+#   ifdef ULTRIX
+#	define OS_TYPE "ULTRIX"
+#       define ALIGNMENT 4
+#   endif
+#   ifdef RISCOS
+#	define OS_TYPE "RISCOS"
+#   	define ALIGNMENT 4  /* Required by hardware */
+#   endif
+#   ifdef IRIX5
+#	define OS_TYPE "IRIX5"
+#       ifndef IRIX_THREADS
+#	    define MPROTECT_VDB
+#       endif
+#       ifdef _MIPS_SZPTR
+#	  define CPP_WORDSZ _MIPS_SZPTR
+#	  define ALIGNMENT (_MIPS_SZPTR/8)
+#	  if CPP_WORDSZ != 64
+#	    define ALIGN_DOUBLE
+#	  endif
+#	else
+#         define ALIGNMENT 4
+#	  define ALIGN_DOUBLE
+#	endif
+#	define DYNAMIC_LOADING
+#   endif
+# endif
+
+# ifdef RS6000
+#   define MACH_TYPE "RS6000"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t)0x20000000)
+/* MATTHEW: Use HEURISTIC2: MzScheme/MrEd cleans it up afterwards */
+#  if 0
+#   define STACKBOTTOM ((ptr_t)0x2ff80000)
+	/* This is known to break under 4.X, under some circumstances.	*/
+	/* But there doesn't seem to be a good alternative.  Set	*/
+	/* GC_stackbottom manually.					*/
+#  else
+#   define HEURISTIC2
+#  endif
+# endif
+
+# ifdef HP_PA
+#   define MACH_TYPE "HP_PA"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int __data_start;
+#   define DATASTART ((ptr_t)(&__data_start))
+#   if 0
+	/* The following appears to work for 7xx systems running HP/UX	*/
+	/* 9.xx Furthermore, it might result in much faster		*/
+	/* collections than HEURISTIC2, which may involve scanning	*/
+	/* segments that directly precede the stack.  It is not the	*/
+	/* default, since it may not work on older machine/OS		*/
+	/* combinations. (Thanks to Raymond X.T. Nijssen for uncovering	*/
+	/* this.)							*/
+#       define STACKBOTTOM ((ptr_t) 0x7b033000)  /* from /etc/conf/h/param.h */
+#   else
+#       define HEURISTIC2
+#   endif
+#   define STACK_GROWS_UP
+#   define DYNAMIC_LOADING
+# endif
+
+# ifdef ALPHA
+#   define MACH_TYPE "ALPHA"
+#   define ALIGNMENT 8
+#   ifdef OSF1
+#	define OS_TYPE "OSF1"
+#   	define DATASTART ((ptr_t) 0x140000000)
+#   	define HEURISTIC2
+	/* Normally HEURISTIC2 is too conervative, since		*/
+	/* the text segment immediately follows the stack.		*/
+	/* Hence we give an upper pound.				*/
+    	extern __start;
+#   	define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
+#   	define CPP_WORDSZ 64
+#   	define MPROTECT_VDB
+#   	define DYNAMIC_LOADING
+#   endif
+#   ifdef LINUX
+#       define OS_TYPE "LINUX"
+#       define CPP_WORDSZ 64
+#       define STACKBOTTOM ((ptr_t) 0x120000000)
+#       ifdef __ELF__
+            extern int __data_start;
+#           define DATASTART &__data_start
+#           define DYNAMIC_LOADING
+#       else
+#           define DATASTART ((ptr_t) 0x140000000)
+#       endif
+	extern int _end;
+#	define DATAEND (&_end)
+#       ifdef __ELF__
+#           define DYNAMIC_LOADING
+#       endif
+	/* As of 1.3.90, I couldn't find a way to retrieve the correct	*/
+	/* fault address from a signal handler.				*/
+	/* Hence MPROTECT_VDB is broken.				*/
+#   endif
+# endif
+
+# ifdef M88K
+#   define MACH_TYPE "M88K"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef CX_UX
+#       define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
+#   endif
+#   ifdef  DGUX
+	extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#   endif
+#   define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
+# endif
+
+# ifdef S370
+#   define MACH_TYPE "S370"
+#   define OS_TYPE "UTS4"
+#   define ALIGNMENT 4	/* Required by hardware	*/
+    extern int etext;
+	extern int _etext;
+	extern int _end;
+	extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#	define DATAEND (&_end)
+#	define HEURISTIC2
+# endif
+
+# ifndef STACK_GROWS_UP
+#   define STACK_GROWS_DOWN
+# endif
+
+# ifndef CPP_WORDSZ
+#   define CPP_WORDSZ 32
+# endif
+
+# ifndef OS_TYPE
+#   define OS_TYPE ""
+# endif
+
+# ifndef DATAEND
+    extern int end;
+#   define DATAEND (&end)
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX) || defined(UTS4)
+    /* OS has SVR4 generic features.  Probably others also qualify.	*/
+#   define SVR4
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX)
+    /* OS has SUNOS5 style semi-undocumented interface to dynamic 	*/
+    /* loader.								*/
+#   define SUNOS5DL
+    /* OS has SUNOS5 style signal handlers.				*/
+#   define SUNOS5SIGS
+# endif
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
+   -> bad word size
+# endif
+
+# ifdef PCR
+#   undef DYNAMIC_LOADING
+#   undef STACKBOTTOM
+#   undef HEURISTIC1
+#   undef HEURISTIC2
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+#   define PCR_VDB
+# endif
+
+# ifdef SRC_M3
+/* Postponed for now. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# ifdef SMALL_CONFIG
+/* Presumably not worth the space it takes. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
+#   define DEFAULT_VDB
+# endif
+
+# if defined(IRIX_THREADS) && !defined(IRIX5)
+--> inconsistent configuration
+# endif
+# if defined(SOLARIS_THREADS) && !defined(SUNOS5)
+--> inconsistent configuration
+# endif
+# if defined(PCR) || defined(SRC_M3) || defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(IRIX_THREADS)
+#   define THREADS
+# endif
+
+# if defined(SPARC)
+#   define SAVE_CALL_CHAIN
+#   define ASM_CLEAR_CODE	/* Stack clearing is crucial, and we 	*/
+				/* include assembly code to do it well.	*/
+# endif
+
+# endif
diff --git a/src/mzscheme/gc/cord/README b/src/mzscheme/gc/cord/README
new file mode 100644
index 0000000..865725e
--- /dev/null
+++ b/src/mzscheme/gc/cord/README
@@ -0,0 +1,31 @@
+Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+Permission is hereby granted to use or copy this program
+for any purpose,  provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is granted,
+provided the above notices are retained, and a notice that the code was
+modified is included with the above copyright notice.
+
+Please send bug reports to Hans-J. Boehm (boehm@parc.xerox.com).
+
+This is a string packages that uses a tree-based representation.
+See gc.h for a description of the functions provided.  Ec.h describes
+"extensible cords", which are essentially output streams that write
+to a cord.  These allow for efficient construction of cords without
+requiring a bound on the size of a cord.
+
+de.c is a very dumb text editor that illustrates the use of cords.
+It maintains a list of file versions.  Each version is simply a
+cord representing the file contents.  Nonetheless, standard
+editing operations are efficient, even on very large files.
+(Its 3 line "user manual" can be obtained by invoking it without
+arguments.  Note that ^R^N and ^R^P move the cursor by
+almost a screen.  It does not understand tabs, which will show
+up as highlighred "I"s.  Use the UNIX "expand" program first.)
+To build the editor, type "make cord/de" in the gc directory.
+
+This package assumes an ANSI C compiler such as gcc.  It will
+not compile with an old-style K&R compiler.
diff --git a/src/mzscheme/gc/cord/SCOPTIONS.amiga b/src/mzscheme/gc/cord/SCOPTIONS.amiga
new file mode 100755
index 0000000..2a09197
--- /dev/null
+++ b/src/mzscheme/gc/cord/SCOPTIONS.amiga
@@ -0,0 +1,14 @@
+MATH=STANDARD
+CPU=68030
+NOSTACKCHECK
+OPTIMIZE
+VERBOSE
+NOVERSION
+NOICONS
+OPTIMIZERTIME
+INCLUDEDIR=/
+DEFINE AMIGA
+LIBRARY=cord.lib
+LIBRARY=/gc.lib
+IGNORE=100
+IGNORE=161
diff --git a/src/mzscheme/gc/cord/SMakefile.amiga b/src/mzscheme/gc/cord/SMakefile.amiga
new file mode 100644
index 0000000..5aef131
--- /dev/null
+++ b/src/mzscheme/gc/cord/SMakefile.amiga
@@ -0,0 +1,20 @@
+# Makefile for cord.lib
+# Michel Schinz 1994/07/20
+
+OBJS = cordbscs.o cordprnt.o cordxtra.o
+
+all: cord.lib cordtest
+
+cordbscs.o: cordbscs.c
+cordprnt.o: cordprnt.c
+cordxtra.o: cordxtra.c
+cordtest.o: cordtest.c
+
+cord.lib: $(OBJS)
+	oml cord.lib r $(OBJS)
+
+cordtest: cordtest.o cord.lib
+	sc cordtest.o link
+
+clean:
+	delete cord.lib cordtest \#?.o \#?.lnk
diff --git a/src/mzscheme/gc/cord/cord.h b/src/mzscheme/gc/cord/cord.h
new file mode 100644
index 0000000..584112f
--- /dev/null
+++ b/src/mzscheme/gc/cord/cord.h
@@ -0,0 +1,327 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Author: Hans-J. Boehm (boehm@parc.xerox.com)
+ */
+/* Boehm, October 5, 1995 4:20 pm PDT */
+ 
+/*
+ * Cords are immutable character strings.  A number of operations
+ * on long cords are much more efficient than their strings.h counterpart.
+ * In particular, concatenation takes constant time independent of the length
+ * of the arguments.  (Cords are represented as trees, with internal
+ * nodes representing concatenation and leaves consisting of either C
+ * strings or a functional description of the string.)
+ *
+ * The following are reasonable applications of cords.  They would perform
+ * unacceptably if C strings were used:
+ * - A compiler that produces assembly language output by repeatedly
+ *   concatenating instructions onto a cord representing the output file.
+ * - A text editor that converts the input file to a cord, and then
+ *   performs editing operations by producing a new cord representing
+ *   the file after echa character change (and keeping the old ones in an
+ *   edit history)
+ *
+ * For optimal performance, cords should be built by
+ * concatenating short sections.
+ * This interface is designed for maximum compatibility with C strings.
+ * ASCII NUL characters may be embedded in cords using CORD_from_fn.
+ * This is handled correctly, but CORD_to_char_star will produce a string
+ * with embedded NULs when given such a cord. 
+ *
+ * This interface is fairly big, largely for performance reasons.
+ * The most basic constants and functions:
+ *
+ * CORD - the type fo a cord;
+ * CORD_EMPTY - empty cord;
+ * CORD_len(cord) - length of a cord;
+ * CORD_cat(cord1,cord2) - concatenation of two cords;
+ * CORD_substr(cord, start, len) - substring (or subcord);
+ * CORD_pos i;  CORD_FOR(i, cord) {  ... CORD_pos_fetch(i) ... } -
+ *    examine each character in a cord.  CORD_pos_fetch(i) is the char.
+ * CORD_fetch(int i) - Retrieve i'th character (slowly).
+ * CORD_cmp(cord1, cord2) - compare two cords.
+ * CORD_from_file(FILE * f) - turn a read-only file into a cord.
+ * CORD_to_char_star(cord) - convert to C string.
+ *   (Non-NULL C constant strings are cords.)
+ * CORD_printf (etc.) - cord version of printf. Use %r for cords.
+ */
+# ifndef CORD_H
+
+# define CORD_H
+# include <stddef.h>
+# include <stdio.h>
+/* Cords have type const char *.  This is cheating quite a bit, and not	*/
+/* 100% portable.  But it means that nonempty character string		*/
+/* constants may be used as cords directly, provided the string is	*/
+/* never modified in place.  The empty cord is represented by, and	*/
+/* can be written as, 0.						*/
+
+typedef const char * CORD;
+
+/* An empty cord is always represented as nil 	*/
+# define CORD_EMPTY 0
+
+/* Is a nonempty cord represented as a C string? */
+#define CORD_IS_STRING(s) (*(s) != '\0')
+
+/* Concatenate two cords.  If the arguments are C strings, they may 	*/
+/* not be subsequently altered.						*/
+CORD CORD_cat(CORD x, CORD y);
+
+/* Concatenate a cord and a C string with known length.  Except for the	*/
+/* empty string case, this is a special case of CORD_cat.  Since the	*/
+/* length is known, it can be faster.					*/
+/* The string y is shared with the resulting CORD.  Hence it should	*/
+/* not be altered by the caller.					*/
+CORD CORD_cat_char_star(CORD x, const char * y, size_t leny);
+
+/* Compute the length of a cord */
+size_t CORD_len(CORD x);
+
+/* Cords may be represented by functions defining the ith character */
+typedef char (* CORD_fn)(size_t i, void * client_data);
+
+/* Turn a functional description into a cord. 	*/
+CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len);
+
+/* Return the substring (subcord really) of x with length at most n,	*/
+/* starting at position i.  (The initial character has position 0.)	*/
+CORD CORD_substr(CORD x, size_t i, size_t n);
+
+/* Return the argument, but rebalanced to allow more efficient   	*/
+/* character retrieval, substring operations, and comparisons.		*/
+/* This is useful only for cords that were built using repeated 	*/
+/* concatenation.  Guarantees log time access to the result, unless	*/
+/* x was obtained through a large number of repeated substring ops	*/
+/* or the embedded functional descriptions take longer to evaluate.	*/
+/* May reallocate significant parts of the cord.  The argument is not	*/
+/* modified; only the result is balanced.				*/
+CORD CORD_balance(CORD x);
+
+/* The following traverse a cord by applying a function to each 	*/
+/* character.  This is occasionally appropriate, especially where	*/
+/* speed is crucial.  But, since C doesn't have nested functions,	*/
+/* clients of this sort of traversal are clumsy to write.  Consider	*/
+/* the functions that operate on cord positions instead.		*/
+
+/* Function to iteratively apply to individual characters in cord.	*/
+typedef int (* CORD_iter_fn)(char c, void * client_data);
+
+/* Function to apply to substrings of a cord.  Each substring is a 	*/
+/* a C character string, not a general cord.				*/
+typedef int (* CORD_batched_iter_fn)(const char * s, void * client_data);
+# define CORD_NO_FN ((CORD_batched_iter_fn)0)
+
+/* Apply f1 to each character in the cord, in ascending order,		*/
+/* starting at position i. If						*/
+/* f2 is not CORD_NO_FN, then multiple calls to f1 may be replaced by	*/
+/* a single call to f2.  The parameter f2 is provided only to allow	*/
+/* some optimization by the client.  This terminates when the right	*/
+/* end of this string is reached, or when f1 or f2 return != 0.  In the	*/
+/* latter case CORD_iter returns != 0.  Otherwise it returns 0.		*/
+/* The specified value of i must be < CORD_len(x).			*/
+int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1,
+	       CORD_batched_iter_fn f2, void * client_data);
+
+/* A simpler version that starts at 0, and without f2:	*/
+int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data);
+# define CORD_iter(x, f1, cd) CORD_iter5(x, 0, f1, CORD_NO_FN, cd)
+
+/* Similar to CORD_iter5, but end-to-beginning.	No provisions for	*/
+/* CORD_batched_iter_fn.						*/
+int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data);
+
+/* A simpler version that starts at the end:	*/
+int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data);
+
+/* Functions that operate on cord positions.  The easy way to traverse	*/
+/* cords.  A cord position is logically a pair consisting of a cord	*/
+/* and an index into that cord.  But it is much faster to retrieve a	*/
+/* charcter based on a position than on an index.  Unfortunately,	*/
+/* positions are big (order of a few 100 bytes), so allocate them with	*/
+/* caution.								*/
+/* Things in cord_pos.h should be treated as opaque, except as		*/
+/* described below.  Also note that					*/
+/* CORD_pos_fetch, CORD_next and CORD_prev have both macro and function	*/
+/* definitions.  The former may evaluate their argument more than once. */
+# include "private/cord_pos.h"
+
+/*
+	Visible definitions from above:
+	
+	typedef <OPAQUE but fairly big> CORD_pos[1];
+	
+	* Extract the cord from a position:
+	CORD CORD_pos_to_cord(CORD_pos p);
+	
+	* Extract the current index from a position:
+	size_t CORD_pos_to_index(CORD_pos p);
+	
+	* Fetch the character located at the given position:
+	char CORD_pos_fetch(CORD_pos p);
+	
+	* Initialize the position to refer to the given cord and index.
+	* Note that this is the most expensive function on positions:
+	void CORD_set_pos(CORD_pos p, CORD x, size_t i);
+	
+	* Advance the position to the next character.
+	* P must be initialized and valid.
+	* Invalidates p if past end:
+	void CORD_next(CORD_pos p);
+	
+	* Move the position to the preceding character.
+	* P must be initialized and valid.
+	* Invalidates p if past beginning:
+	void CORD_prev(CORD_pos p);
+	
+	* Is the position valid, i.e. inside the cord?
+	int CORD_pos_valid(CORD_pos p);
+*/
+# define CORD_FOR(pos, cord) \
+    for (CORD_set_pos(pos, cord, 0); CORD_pos_valid(pos); CORD_next(pos))
+
+			
+/* An out of memory handler to call.  May be supplied by client.	*/
+/* Must not return.							*/
+extern void (* CORD_oom_fn)(void);
+
+/* Dump the representation of x to stdout in an implementation defined	*/
+/* manner.  Intended for debugging only.				*/
+void CORD_dump(CORD x);
+
+/* The following could easily be implemented by the client.  They are	*/
+/* provided in cordxtra.c for convenience.				*/
+
+/* Concatenate a character to the end of a cord.	*/
+CORD CORD_cat_char(CORD x, char c);
+
+/* Concatenate n cords.	*/
+CORD CORD_catn(int n, /* CORD */ ...);
+
+/* Return the character in CORD_substr(x, i, 1)  	*/
+char CORD_fetch(CORD x, size_t i);
+
+/* Return < 0, 0, or > 0, depending on whether x < y, x = y, x > y	*/
+int CORD_cmp(CORD x, CORD y);
+
+/* A generalization that takes both starting positions for the 		*/
+/* comparison, and a limit on the number of characters to be compared.	*/
+int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len);
+
+/* Find the first occurrence of s in x at position start or later.	*/
+/* Return the position of the first character of s in x, or		*/
+/* CORD_NOT_FOUND if there is none.					*/
+size_t CORD_str(CORD x, size_t start, CORD s);
+
+/* Return a cord consisting of i copies of (possibly NUL) c.  Dangerous	*/
+/* in conjunction with CORD_to_char_star.				*/
+/* The resulting representation takes constant space, independent of i.	*/
+CORD CORD_chars(char c, size_t i);
+# define CORD_nul(i) CORD_chars('\0', (i))
+
+/* Turn a file into cord.  The file must be seekable.  Its contents	*/
+/* must remain constant.  The file may be accessed as an immediate	*/
+/* result of this call and/or as a result of subsequent accesses to 	*/
+/* the cord.  Short files are likely to be immediately read, but	*/
+/* long files are likely to be read on demand, possibly relying on 	*/
+/* stdio for buffering.							*/
+/* We must have exclusive access to the descriptor f, i.e. we may	*/
+/* read it at any time, and expect the file pointer to be		*/
+/* where we left it.  Normally this should be invoked as		*/
+/* CORD_from_file(fopen(...))						*/
+/* CORD_from_file arranges to close the file descriptor when it is no	*/
+/* longer needed (e.g. when the result becomes inaccessible).		*/ 
+/* The file f must be such that ftell reflects the actual character	*/
+/* position in the file, i.e. the number of characters that can be 	*/
+/* or were read with fread.  On UNIX systems this is always true.  On	*/
+/* MS Windows systems, f must be opened in binary mode.			*/
+CORD CORD_from_file(FILE * f);
+
+/* Equivalent to the above, except that the entire file will be read	*/
+/* and the file pointer will be closed immediately.			*/
+/* The binary mode restriction from above does not apply.		*/
+CORD CORD_from_file_eager(FILE * f);
+
+/* Equivalent to the above, except that the file will be read on demand.*/
+/* The binary mode restriction applies.					*/
+CORD CORD_from_file_lazy(FILE * f);
+
+/* Turn a cord into a C string.	The result shares no structure with	*/
+/* x, and is thus modifiable.						*/
+char * CORD_to_char_star(CORD x);
+
+/* Turn a C string into a CORD.  The C string is copied, and so may	*/
+/* subsequently be modified.						*/
+CORD CORD_from_char_star(const char *s);
+
+/* Identical to the above, but the result may share structure with	*/
+/* the argument and is thus not modifiable.				*/
+const char * CORD_to_const_char_star(CORD x); 
+
+/* Write a cord to a file, starting at the current position.  No	*/
+/* trailing NULs are newlines are added.				*/
+/* Returns EOF if a write error occurs, 1 otherwise.			*/
+int CORD_put(CORD x, FILE * f);
+
+/* "Not found" result for the following two functions.			*/
+# define CORD_NOT_FOUND ((size_t)(-1))
+
+/* A vague analog of strchr.  Returns the position (an integer, not	*/
+/* a pointer) of the first occurrence of (char) c inside x at position 	*/
+/* i or later. The value i must be < CORD_len(x).			*/
+size_t CORD_chr(CORD x, size_t i, int c);
+
+/* A vague analog of strrchr.  Returns index of the last occurrence	*/
+/* of (char) c inside x at position i or earlier. The value i		*/
+/* must be < CORD_len(x).						*/
+size_t CORD_rchr(CORD x, size_t i, int c);
+
+
+/* The following are also not primitive, but are implemented in 	*/
+/* cordprnt.c.  They provide functionality similar to the ANSI C	*/
+/* functions with corresponding names, but with the following		*/
+/* additions and changes:						*/
+/* 1. A %r conversion specification specifies a CORD argument.  Field	*/
+/*    width, precision, etc. have the same semantics as for %s.		*/
+/*    (Note that %c,%C, and %S were already taken.)			*/
+/* 2. The format string is represented as a CORD.		        */
+/* 3. CORD_sprintf and CORD_vsprintf assign the result through the 1st	*/ 	/*    argument.	Unlike their ANSI C versions, there is no need to guess	*/
+/*    the correct buffer size.						*/
+/* 4. Most of the conversions are implement through the native 		*/
+/*    vsprintf.  Hence they are usually no faster, and 			*/
+/*    idiosyncracies of the native printf are preserved.  However,	*/
+/*    CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied;	*/
+/*    the result shares the original structure.  This may make them	*/
+/*    very efficient in some unusual applications.			*/
+/*    The format string is copied.					*/
+/* All functions return the number of characters generated or -1 on	*/
+/* error.  This complies with the ANSI standard, but is inconsistent	*/
+/* with some older implementations of sprintf.				*/
+
+/* The implementation of these is probably less portable than the rest	*/
+/* of this package.							*/
+
+#ifndef CORD_NO_IO
+
+#include <stdarg.h>
+
+int CORD_sprintf(CORD * out, CORD format, ...);
+int CORD_vsprintf(CORD * out, CORD format, va_list args);
+int CORD_fprintf(FILE * f, CORD format, ...);
+int CORD_vfprintf(FILE * f, CORD format, va_list args);
+int CORD_printf(CORD format, ...);
+int CORD_vprintf(CORD format, va_list args);
+
+#endif /* CORD_NO_IO */
+
+# endif /* CORD_H */
diff --git a/src/mzscheme/gc/cord/cordbscs.c b/src/mzscheme/gc/cord/cordbscs.c
new file mode 100644
index 0000000..b75f581
--- /dev/null
+++ b/src/mzscheme/gc/cord/cordbscs.c
@@ -0,0 +1,916 @@
+/*
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Author: Hans-J. Boehm (boehm@parc.xerox.com)
+ */
+/* Boehm, October 3, 1994 5:19 pm PDT */
+# include "gc.h"
+# include "cord.h"
+# include <stdlib.h>
+# include <stdio.h>
+# include <string.h>
+
+/* An implementation of the cord primitives.  These are the only 	*/
+/* Functions that understand the representation.  We perform only	*/
+/* minimal checks on arguments to these functions.  Out of bounds	*/
+/* arguments to the iteration functions may result in client functions	*/
+/* invoked on garbage data.  In most cases, client functions should be	*/
+/* programmed defensively enough that this does not result in memory	*/
+/* smashes.								*/ 
+
+typedef void (* oom_fn)(void);
+
+oom_fn CORD_oom_fn = (oom_fn) 0;
+
+# define OUT_OF_MEMORY {  if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \
+			  ABORT("Out of memory\n"); }
+# define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); }
+
+typedef unsigned long word;
+
+typedef union {
+    struct Concatenation {
+    	char null;
+	char header;
+	char depth;	/* concatenation nesting depth. */
+	unsigned char left_len;
+			/* Length of left child if it is sufficiently	*/
+			/* short; 0 otherwise.				*/
+#	    define MAX_LEFT_LEN 255
+	word len;
+	CORD left;	/* length(left) > 0	*/
+	CORD right;	/* length(right) > 0	*/
+    } concatenation;
+    struct Function {
+	char null;
+	char header;
+	char depth;	/* always 0	*/
+	char left_len;	/* always 0	*/
+	word len;
+	CORD_fn fn;
+	void * client_data;
+    } function;
+    struct Generic {
+    	char null;
+	char header;
+	char depth;
+	char left_len;
+	word len;
+    } generic;
+    char string[1];
+} CordRep;
+
+# define CONCAT_HDR 1
+	
+# define FN_HDR 4
+# define SUBSTR_HDR 6
+	/* Substring nodes are a special case of function nodes.  	*/
+	/* The client_data field is known to point to a substr_args	*/
+	/* structure, and the function is either CORD_apply_access_fn 	*/
+	/* or CORD_index_access_fn.					*/
+
+/* The following may be applied only to function and concatenation nodes: */
+#define IS_CONCATENATION(s)  (((CordRep *)s)->generic.header == CONCAT_HDR)
+
+#define IS_FUNCTION(s)  ((((CordRep *)s)->generic.header & FN_HDR) != 0)
+
+#define IS_SUBSTR(s) (((CordRep *)s)->generic.header == SUBSTR_HDR)
+
+#define LEN(s) (((CordRep *)s) -> generic.len)
+#define DEPTH(s) (((CordRep *)s) -> generic.depth)
+#define GEN_LEN(s) (CORD_IS_STRING(s) ? strlen(s) : LEN(s))
+
+#define LEFT_LEN(c) ((c) -> left_len != 0? \
+				(c) -> left_len \
+				: (CORD_IS_STRING((c) -> left) ? \
+					(c) -> len - GEN_LEN((c) -> right) \
+					: LEN((c) -> left)))
+
+#define SHORT_LIMIT (sizeof(CordRep) - 1)
+	/* Cords shorter than this are C strings */
+
+
+/* Dump the internal representation of x to stdout, with initial 	*/
+/* indentation level n.							*/
+void CORD_dump_inner(CORD x, unsigned n)
+{
+    register size_t i;
+    
+    for (i = 0; i < (size_t)n; i++) {
+        fputs("  ", stdout);
+    }
+    if (x == 0) {
+      	fputs("NIL\n", stdout);
+    } else if (CORD_IS_STRING(x)) {
+        for (i = 0; i <= SHORT_LIMIT; i++) {
+            if (x[i] == '\0') break;
+            putchar(x[i]);
+        }
+        if (x[i] != '\0') fputs("...", stdout);
+        putchar('\n');
+    } else if (IS_CONCATENATION(x)) {
+        register struct Concatenation * conc =
+        			&(((CordRep *)x) -> concatenation);
+        printf("Concatenation: %p (len: %d, depth: %d)\n",
+               x, (int)(conc -> len), (int)(conc -> depth));
+        CORD_dump_inner(conc -> left, n+1);
+        CORD_dump_inner(conc -> right, n+1);
+    } else /* function */{
+        register struct Function * func =
+        			&(((CordRep *)x) -> function);
+        if (IS_SUBSTR(x)) printf("(Substring) ");
+        printf("Function: %p (len: %d): ", x, (int)(func -> len));
+        for (i = 0; i < 20 && i < func -> len; i++) {
+            putchar((*(func -> fn))(i, func -> client_data));
+        }
+        if (i < func -> len) fputs("...", stdout);
+        putchar('\n');
+    }
+}
+
+/* Dump the internal representation of x to stdout	*/
+void CORD_dump(CORD x)
+{
+    CORD_dump_inner(x, 0);
+    fflush(stdout);
+}
+
+CORD CORD_cat_char_star(CORD x, const char * y, size_t leny)
+{
+    register size_t result_len;
+    register size_t lenx;
+    register int depth;
+    
+    if (x == CORD_EMPTY) return(y);
+    if (leny == 0) return(x);
+    if (CORD_IS_STRING(x)) {
+        lenx = strlen(x);
+        result_len = lenx + leny;
+        if (result_len <= SHORT_LIMIT) {
+            register char * result = GC_MALLOC_ATOMIC(result_len+1);
+        
+            if (result == 0) OUT_OF_MEMORY;
+            memcpy(result, x, lenx);
+            memcpy(result + lenx, y, leny);
+            result[result_len] = '\0';
+            return((CORD) result);
+        } else {
+            depth = 1;
+        }
+    } else {
+    	register CORD right;
+    	register CORD left;
+    	register char * new_right;
+    	register size_t right_len;
+    	
+    	lenx = LEN(x);
+    	
+        if (leny <= SHORT_LIMIT/2
+    	    && IS_CONCATENATION(x)
+            && CORD_IS_STRING(right = ((CordRep *)x) -> concatenation.right)) {
+            /* Merge y into right part of x. */
+            if (!CORD_IS_STRING(left = ((CordRep *)x) -> concatenation.left)) {
+            	right_len = lenx - LEN(left);
+            } else if (((CordRep *)x) -> concatenation.left_len != 0) {
+                right_len = lenx - ((CordRep *)x) -> concatenation.left_len;
+            } else {
+            	right_len = strlen(right);
+            }
+            result_len = right_len + leny;  /* length of new_right */
+            if (result_len <= SHORT_LIMIT) {
+            	new_right = GC_MALLOC_ATOMIC(result_len + 1);
+            	memcpy(new_right, right, right_len);
+            	memcpy(new_right + right_len, y, leny);
+            	new_right[result_len] = '\0';
+            	y = new_right;
+            	leny = result_len;
+            	x = left;
+            	lenx -= right_len;
+            	/* Now fall through to concatenate the two pieces: */
+            }
+            if (CORD_IS_STRING(x)) {
+                depth = 1;
+            } else {
+                depth = DEPTH(x) + 1;
+            }
+        } else {
+            depth = DEPTH(x) + 1;
+        }
+        result_len = lenx + leny;
+    }
+    {
+      /* The general case; lenx, result_len is known: */
+    	register struct Concatenation * result;
+    	
+    	result = GC_NEW(struct Concatenation);
+    	if (result == 0) OUT_OF_MEMORY;
+    	result->header = CONCAT_HDR;
+    	result->depth = depth;
+    	if (lenx <= MAX_LEFT_LEN) result->left_len = lenx;
+    	result->len = result_len;
+    	result->left = x;
+    	result->right = y;
+    	if (depth > MAX_DEPTH) {
+    	    return(CORD_balance((CORD)result));
+    	} else {
+    	    return((CORD) result);
+    	}
+    }
+}
+
+
+CORD CORD_cat(CORD x, CORD y)
+{
+    register size_t result_len;
+    register int depth;
+    register size_t lenx;
+    
+    if (x == CORD_EMPTY) return(y);
+    if (y == CORD_EMPTY) return(x);
+    if (CORD_IS_STRING(y)) {
+        return(CORD_cat_char_star(x, y, strlen(y)));
+    } else if (CORD_IS_STRING(x)) {
+        lenx = strlen(x);
+        depth = DEPTH(y) + 1;
+    } else {
+        register int depthy = DEPTH(y);
+        
+        lenx = LEN(x);
+        depth = DEPTH(x) + 1;
+        if (depthy >= depth) depth = depthy + 1;
+    }
+    result_len = lenx + LEN(y);
+    {
+    	register struct Concatenation * result;
+    	
+    	result = GC_NEW(struct Concatenation);
+    	if (result == 0) OUT_OF_MEMORY;
+    	result->header = CONCAT_HDR;
+    	result->depth = depth;
+    	if (lenx <= MAX_LEFT_LEN) result->left_len = lenx;
+    	result->len = result_len;
+    	result->left = x;
+    	result->right = y;
+    	return((CORD) result);
+    }
+}
+
+
+
+CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len)
+{
+    if (len <= 0) return(0);
+    if (len <= SHORT_LIMIT) {
+        register char * result;
+        register size_t i;
+        char buf[SHORT_LIMIT+1];
+        register char c;
+        
+        for (i = 0; i < len; i++) {
+            c = (*fn)(i, client_data);
+            if (c == '\0') goto gen_case;
+            buf[i] = c;
+        }
+        buf[i] = '\0';
+        result = GC_MALLOC_ATOMIC(len+1);
+        if (result == 0) OUT_OF_MEMORY;
+        strcpy(result, buf);
+        result[len] = '\0';
+        return((CORD) result);
+    }
+  gen_case:
+    {
+    	register struct Function * result;
+    	
+    	result = GC_NEW(struct Function);
+    	if (result == 0) OUT_OF_MEMORY;
+    	result->header = FN_HDR;
+    	/* depth is already 0 */
+    	result->len = len;
+    	result->fn = fn;
+    	result->client_data = client_data;
+    	return((CORD) result);
+    }
+}
+
+size_t CORD_len(CORD x)
+{
+    if (x == 0) {
+     	return(0);
+    } else {
+	return(GEN_LEN(x));
+    }
+}
+
+struct substr_args {
+    CordRep * sa_cord;
+    size_t sa_index;
+};
+
+char CORD_index_access_fn(size_t i, void * client_data)
+{
+    register struct substr_args *descr = (struct substr_args *)client_data;
+    
+    return(((char *)(descr->sa_cord))[i + descr->sa_index]);
+}
+
+char CORD_apply_access_fn(size_t i, void * client_data)
+{
+    register struct substr_args *descr = (struct substr_args *)client_data;
+    register struct Function * fn_cord = &(descr->sa_cord->function);
+    
+    return((*(fn_cord->fn))(i + descr->sa_index, fn_cord->client_data));
+}
+
+/* A version of CORD_substr that simply returns a function node, thus	*/
+/* postponing its work.	The fourth argument is a function that may	*/
+/* be used for efficient access to the ith character.			*/
+/* Assumes i >= 0 and i + n < length(x).				*/
+CORD CORD_substr_closure(CORD x, size_t i, size_t n, CORD_fn f)
+{
+    register struct substr_args * sa = GC_NEW(struct substr_args);
+    CORD result;
+    
+    if (sa == 0) OUT_OF_MEMORY;
+    sa->sa_cord = (CordRep *)x;
+    sa->sa_index = i;
+    result = CORD_from_fn(f, (void *)sa, n);
+    ((CordRep *)result) -> function.header = SUBSTR_HDR;
+    return (result);
+}
+
+# define SUBSTR_LIMIT (10 * SHORT_LIMIT)
+	/* Substrings of function nodes and flat strings shorter than 	*/
+	/* this are flat strings.  Othewise we use a functional 	*/
+	/* representation, which is significantly slower to access.	*/
+
+/* A version of CORD_substr that assumes i >= 0, n > 0, and i + n < length(x).*/
+CORD CORD_substr_checked(CORD x, size_t i, size_t n)
+{
+    if (CORD_IS_STRING(x)) {
+        if (n > SUBSTR_LIMIT) {
+            return(CORD_substr_closure(x, i, n, CORD_index_access_fn));
+        } else {
+            register char * result = GC_MALLOC_ATOMIC(n+1);
+            register char * p = result;
+            
+            if (result == 0) OUT_OF_MEMORY;
+            strncpy(result, x+i, n);
+            result[n] = '\0';
+            return(result);
+        }
+    } else if (IS_CONCATENATION(x)) {
+    	register struct Concatenation * conc
+    			= &(((CordRep *)x) -> concatenation);
+    	register size_t left_len;
+    	register size_t right_len;
+    	
+    	left_len = LEFT_LEN(conc);
+    	right_len = conc -> len - left_len;
+    	if (i >= left_len) {
+    	    if (n == right_len) return(conc -> right);
+    	    return(CORD_substr_checked(conc -> right, i - left_len, n));
+    	} else if (i+n <= left_len) {
+    	    if (n == left_len) return(conc -> left);
+    	    return(CORD_substr_checked(conc -> left, i, n));
+    	} else {
+    	    /* Need at least one character from each side. */
+    	    register CORD left_part;
+    	    register CORD right_part;
+    	    register size_t left_part_len = left_len - i;
+     	
+    	    if (i == 0) {
+    	        left_part = conc -> left;
+    	    } else {
+    	        left_part = CORD_substr_checked(conc -> left, i, left_part_len);
+    	    }
+    	    if (i + n == right_len + left_len) {
+    	         right_part = conc -> right;
+    	    } else {
+    	         right_part = CORD_substr_checked(conc -> right, 0,
+    	    				          n - left_part_len);
+    	    }
+    	    return(CORD_cat(left_part, right_part));
+    	}
+    } else /* function */ {
+        if (n > SUBSTR_LIMIT) {
+            if (IS_SUBSTR(x)) {
+            	/* Avoid nesting substring nodes.	*/
+            	register struct Function * f = &(((CordRep *)x) -> function);
+            	register struct substr_args *descr =
+            			(struct substr_args *)(f -> client_data);
+            	
+            	return(CORD_substr_closure((CORD)descr->sa_cord,
+            				   i + descr->sa_index,
+            				   n, f -> fn));
+            } else {
+                return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
+            }
+        } else {
+            char * result;
+            register struct Function * f = &(((CordRep *)x) -> function);
+            char buf[SUBSTR_LIMIT+1];
+            register char * p = buf;
+            register char c;
+            register int j;
+            register int lim = i + n;
+            
+            for (j = i; j < lim; j++) {
+            	c = (*(f -> fn))(j, f -> client_data);
+            	if (c == '\0') {
+            	    return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
+            	}
+            	*p++ = c;
+            }
+            *p = '\0';
+            result = GC_MALLOC_ATOMIC(n+1);
+            if (result == 0) OUT_OF_MEMORY;
+            strcpy(result, buf);
+            return(result);
+        }
+    }
+}
+
+CORD CORD_substr(CORD x, size_t i, size_t n)
+{
+    register size_t len = CORD_len(x);
+    
+    if (i >= len || n <= 0) return(0);
+    	/* n < 0 is impossible in a correct C implementation, but	*/
+    	/* quite possible  under SunOS 4.X.				*/
+    if (i + n > len) n = len - i;
+#   ifndef __STDC__
+      if (i < 0) ABORT("CORD_substr: second arg. negative");
+    	/* Possible only if both client and C implementation are buggy.	*/
+    	/* But empirically this happens frequently.			*/
+#   endif
+    return(CORD_substr_checked(x, i, n));
+}
+
+/* See cord.h for definition.  We assume i is in range.	*/
+int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1,
+			 CORD_batched_iter_fn f2, void * client_data)
+{
+    if (x == 0) return(0);
+    if (CORD_IS_STRING(x)) {
+    	register const char *p = x+i;
+    	
+    	if (*p == '\0') ABORT("2nd arg to CORD_iter5 too big");
+        if (f2 != CORD_NO_FN) {
+            return((*f2)(p, client_data));
+        } else {
+	    while (*p) {
+                if ((*f1)(*p, client_data)) return(1);
+                p++;
+	    }
+	    return(0);
+        }
+    } else if (IS_CONCATENATION(x)) {
+    	register struct Concatenation * conc
+    			= &(((CordRep *)x) -> concatenation);
+    	
+    	
+    	if (i > 0) {
+    	    register size_t left_len = LEFT_LEN(conc);
+    	    
+    	    if (i >= left_len) {
+    	        return(CORD_iter5(conc -> right, i - left_len, f1, f2,
+    	        		  client_data));
+    	    }
+    	}
+    	if (CORD_iter5(conc -> left, i, f1, f2, client_data)) {
+    	    return(1);
+    	}
+    	return(CORD_iter5(conc -> right, 0, f1, f2, client_data));
+    } else /* function */ {
+        register struct Function * f = &(((CordRep *)x) -> function);
+        register size_t j;
+        register size_t lim = f -> len;
+        
+        for (j = i; j < lim; j++) {
+            if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) {
+                return(1);
+            }
+        }
+        return(0);
+    }
+}
+			
+#undef CORD_iter
+int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data)
+{
+    return(CORD_iter5(x, 0, f1, CORD_NO_FN, client_data));
+}
+
+int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data)
+{
+    if (x == 0) return(0);
+    if (CORD_IS_STRING(x)) {
+	register const char *p = x + i;
+	register char c;
+               
+	for(;;) {
+	    c = *p;
+	    if (c == '\0') ABORT("2nd arg to CORD_riter4 too big");
+            if ((*f1)(c, client_data)) return(1);
+	    if (p == x) break;
+            p--;
+	}
+	return(0);
+    } else if (IS_CONCATENATION(x)) {
+    	register struct Concatenation * conc
+    			= &(((CordRep *)x) -> concatenation);
+    	register CORD left_part = conc -> left;
+    	register size_t left_len;
+    	
+    	left_len = LEFT_LEN(conc);
+    	if (i >= left_len) {
+    	    if (CORD_riter4(conc -> right, i - left_len, f1, client_data)) {
+    	    	return(1);
+    	    }
+    	    return(CORD_riter4(left_part, left_len - 1, f1, client_data));
+    	} else {
+    	    return(CORD_riter4(left_part, i, f1, client_data));
+    	}
+    } else /* function */ {
+        register struct Function * f = &(((CordRep *)x) -> function);
+        register size_t j;
+        
+        for (j = i; ; j--) {
+            if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) {
+                return(1);
+            }
+            if (j == 0) return(0);
+        }
+    }
+}
+
+int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data)
+{
+    return(CORD_riter4(x, CORD_len(x) - 1, f1, client_data));
+}
+
+/*
+ * The following functions are concerned with balancing cords.
+ * Strategy:
+ * Scan the cord from left to right, keeping the cord scanned so far
+ * as a forest of balanced trees of exponentialy decreasing length.
+ * When a new subtree needs to be added to the forest, we concatenate all
+ * shorter ones to the new tree in the appropriate order, and then insert
+ * the result into the forest.
+ * Crucial invariants:
+ * 1. The concatenation of the forest (in decreasing order) with the
+ *     unscanned part of the rope is equal to the rope being balanced.
+ * 2. All trees in the forest are balanced.
+ * 3. forest[i] has depth at most i.
+ */
+
+typedef struct {
+    CORD c;
+    size_t len;		/* Actual length of c 	*/
+} ForestElement;
+
+static size_t min_len [ MAX_DEPTH ];
+
+static int min_len_init = 0;
+
+int CORD_max_len;
+
+typedef ForestElement Forest [ MAX_DEPTH ];
+			/* forest[i].len >= fib(i+1)	        */
+			/* The string is the concatenation	*/
+			/* of the forest in order of DECREASING */
+			/* indices.				*/
+
+void CORD_init_min_len()
+{
+    register int i;
+    register size_t last, previous, current;
+        
+    min_len[0] = previous = 1;
+    min_len[1] = last = 2;
+    for (i = 2; i < MAX_DEPTH; i++) {
+    	current = last + previous;
+    	if (current < last) /* overflow */ current = last;
+    	min_len[i] = current;
+    	previous = last;
+    	last = current;
+    }
+    CORD_max_len = last - 1;
+    min_len_init = 1;
+}
+
+
+void CORD_init_forest(ForestElement * forest, size_t max_len)
+{
+    register int i;
+    
+    for (i = 0; i < MAX_DEPTH; i++) {
+    	forest[i].c = 0;
+    	if (min_len[i] > max_len) return;
+    }
+    ABORT("Cord too long");
+}
+
+/* Add a leaf to the appropriate level in the forest, cleaning		*/
+/* out lower levels as necessary.					*/
+/* Also works if x is a balanced tree of concatenations; however	*/
+/* in this case an extra concatenation node may be inserted above x;	*/
+/* This node should not be counted in the statement of the invariants.	*/
+void CORD_add_forest(ForestElement * forest, CORD x, size_t len)
+{
+    register int i = 0;
+    register CORD sum = CORD_EMPTY;
+    register size_t sum_len = 0;
+    
+    while (len > min_len[i + 1]) {
+    	if (forest[i].c != 0) {
+    	    sum = CORD_cat(forest[i].c, sum);
+    	    sum_len += forest[i].len;
+    	    forest[i].c = 0;
+    	}
+        i++;
+    }
+    /* Sum has depth at most 1 greter than what would be required 	*/
+    /* for balance.							*/
+    sum = CORD_cat(sum, x);
+    sum_len += len;
+    /* If x was a leaf, then sum is now balanced.  To see this		*/
+    /* consider the two cases in which forest[i-1] either is or is 	*/
+    /* not empty.							*/
+    while (sum_len >= min_len[i]) {
+    	if (forest[i].c != 0) {
+    	    sum = CORD_cat(forest[i].c, sum);
+    	    sum_len += forest[i].len;
+    	    /* This is again balanced, since sum was balanced, and has	*/
+    	    /* allowable depth that differs from i by at most 1.	*/
+    	    forest[i].c = 0;
+    	}
+        i++;
+    }
+    i--;
+    forest[i].c = sum;
+    forest[i].len = sum_len;
+}
+
+CORD CORD_concat_forest(ForestElement * forest, size_t expected_len)
+{
+    register int i = 0;
+    CORD sum = 0;
+    size_t sum_len = 0;
+    
+    while (sum_len != expected_len) {
+    	if (forest[i].c != 0) {
+    	    sum = CORD_cat(forest[i].c, sum);
+    	    sum_len += forest[i].len;
+    	}
+        i++;
+    }
+    return(sum);
+}
+
+/* Insert the frontier of x into forest.  Balanced subtrees are	*/
+/* treated as leaves.  This potentially adds one to the depth	*/
+/* of the final tree.						*/
+void CORD_balance_insert(CORD x, size_t len, ForestElement * forest)
+{
+    register int depth;
+    
+    if (CORD_IS_STRING(x)) {
+        CORD_add_forest(forest, x, len);
+    } else if (IS_CONCATENATION(x)
+               && ((depth = DEPTH(x)) >= MAX_DEPTH
+                   || len < min_len[depth])) {
+    	register struct Concatenation * conc
+    			= &(((CordRep *)x) -> concatenation);
+    	size_t left_len = LEFT_LEN(conc);
+    	
+    	CORD_balance_insert(conc -> left, left_len, forest);
+    	CORD_balance_insert(conc -> right, len - left_len, forest);
+    } else /* function or balanced */ {
+    	CORD_add_forest(forest, x, len);
+    }
+}
+
+
+CORD CORD_balance(CORD x)
+{
+    Forest forest;
+    register size_t len;
+    
+    if (x == 0) return(0);
+    if (CORD_IS_STRING(x)) return(x);
+    if (!min_len_init) CORD_init_min_len();
+    len = LEN(x);
+    CORD_init_forest(forest, len);
+    CORD_balance_insert(x, len, forest);
+    return(CORD_concat_forest(forest, len));
+}
+
+
+/* Position primitives	*/
+
+/* Private routines to deal with the hard cases only: */
+
+/* P contains a prefix of the  path to cur_pos.	Extend it to a full	*/
+/* path and set up leaf info.						*/
+/* Return 0 if past the end of cord, 1 o.w.				*/
+void CORD__extend_path(register CORD_pos p)
+{
+     register struct CORD_pe * current_pe = &(p[0].path[p[0].path_len]);
+     register CORD top = current_pe -> pe_cord;
+     register size_t pos = p[0].cur_pos;
+     register size_t top_pos = current_pe -> pe_start_pos;
+     register size_t top_len = GEN_LEN(top);
+     
+     /* Fill in the rest of the path. */
+       while(!CORD_IS_STRING(top) && IS_CONCATENATION(top)) {
+     	 register struct Concatenation * conc =
+     	 		&(((CordRep *)top) -> concatenation);
+     	 register size_t left_len;
+     	 
+     	 left_len = LEFT_LEN(conc);
+     	 current_pe++;
+     	 if (pos >= top_pos + left_len) {
+     	     current_pe -> pe_cord = top = conc -> right;
+     	     current_pe -> pe_start_pos = top_pos = top_pos + left_len;
+     	     top_len -= left_len;
+     	 } else {
+     	     current_pe -> pe_cord = top = conc -> left;
+     	     current_pe -> pe_start_pos = top_pos;
+     	     top_len = left_len;
+     	 }
+     	 p[0].path_len++;
+       }
+     /* Fill in leaf description for fast access. */
+       if (CORD_IS_STRING(top)) {
+         p[0].cur_leaf = top;
+         p[0].cur_start = top_pos;
+         p[0].cur_end = top_pos + top_len;
+       } else {
+         p[0].cur_end = 0;
+       }
+       if (pos >= top_pos + top_len) p[0].path_len = CORD_POS_INVALID;
+}
+
+char CORD__pos_fetch(register CORD_pos p)
+{
+    /* Leaf is a function node */
+    struct CORD_pe * pe = &((p)[0].path[(p)[0].path_len]);
+    CORD leaf = pe -> pe_cord;
+    register struct Function * f = &(((CordRep *)leaf) -> function);
+    
+    if (!IS_FUNCTION(leaf)) ABORT("CORD_pos_fetch: bad leaf");
+    return ((*(f -> fn))(p[0].cur_pos - pe -> pe_start_pos, f -> client_data));
+}
+
+void CORD__next(register CORD_pos p)
+{
+    register size_t cur_pos = p[0].cur_pos + 1;
+    register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
+    register CORD leaf = current_pe -> pe_cord;
+    
+    /* Leaf is not a string or we're at end of leaf */
+    p[0].cur_pos = cur_pos;
+    if (!CORD_IS_STRING(leaf)) {
+    	/* Function leaf	*/
+    	register struct Function * f = &(((CordRep *)leaf) -> function);
+    	register size_t start_pos = current_pe -> pe_start_pos;
+    	register size_t end_pos = start_pos + f -> len;
+    	
+    	if (cur_pos < end_pos) {
+    	  /* Fill cache and return. */
+    	    register size_t i;
+    	    register size_t limit = cur_pos + FUNCTION_BUF_SZ;
+    	    register CORD_fn fn = f -> fn;
+    	    register void * client_data = f -> client_data;
+    	    
+    	    if (limit > end_pos) {
+    	        limit = end_pos;
+    	    }
+    	    for (i = cur_pos; i < limit; i++) {
+    	        p[0].function_buf[i - cur_pos] =
+    	        	(*fn)(i - start_pos, client_data);
+    	    }
+    	    p[0].cur_start = cur_pos;
+    	    p[0].cur_leaf = p[0].function_buf;
+    	    p[0].cur_end = limit;
+    	    return;
+    	}
+    }
+    /* End of leaf	*/
+    /* Pop the stack until we find two concatenation nodes with the 	*/
+    /* same start position: this implies we were in left part.		*/
+    {
+    	while (p[0].path_len > 0
+    	       && current_pe[0].pe_start_pos != current_pe[-1].pe_start_pos) {
+    	    p[0].path_len--;
+    	    current_pe--;
+    	}
+    	if (p[0].path_len == 0) {
+	    p[0].path_len = CORD_POS_INVALID;
+            return;
+	}
+    }
+    p[0].path_len--;
+    CORD__extend_path(p);
+}
+
+void CORD__prev(register CORD_pos p)
+{
+    register struct CORD_pe * pe = &(p[0].path[p[0].path_len]);
+    
+    if (p[0].cur_pos == 0) {
+        p[0].path_len = CORD_POS_INVALID;
+        return;
+    }
+    p[0].cur_pos--;
+    if (p[0].cur_pos >= pe -> pe_start_pos) return;
+    
+    /* Beginning of leaf	*/
+    
+    /* Pop the stack until we find two concatenation nodes with the 	*/
+    /* different start position: this implies we were in right part.	*/
+    {
+    	register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
+    	
+    	while (p[0].path_len > 0
+    	       && current_pe[0].pe_start_pos == current_pe[-1].pe_start_pos) {
+    	    p[0].path_len--;
+    	    current_pe--;
+    	}
+    }
+    p[0].path_len--;
+    CORD__extend_path(p);
+}
+
+#undef CORD_pos_fetch
+#undef CORD_next
+#undef CORD_prev
+#undef CORD_pos_to_index
+#undef CORD_pos_to_cord
+#undef CORD_pos_valid
+
+char CORD_pos_fetch(register CORD_pos p)
+{
+    if (p[0].cur_start <= p[0].cur_pos && p[0].cur_pos < p[0].cur_end) {
+    	return(p[0].cur_leaf[p[0].cur_pos - p[0].cur_start]);
+    } else {
+        return(CORD__pos_fetch(p));
+    }
+}
+
+void CORD_next(CORD_pos p)
+{
+    if (p[0].cur_pos < p[0].cur_end - 1) {
+    	p[0].cur_pos++;
+    } else {
+    	CORD__next(p);
+    }
+}
+
+void CORD_prev(CORD_pos p)
+{
+    if (p[0].cur_end != 0 && p[0].cur_pos > p[0].cur_start) {
+    	p[0].cur_pos--;
+    } else {
+    	CORD__prev(p);
+    }
+}
+
+size_t CORD_pos_to_index(CORD_pos p)
+{
+    return(p[0].cur_pos);
+}
+
+CORD CORD_pos_to_cord(CORD_pos p)
+{
+    return(p[0].path[0].pe_cord);
+}
+
+int CORD_pos_valid(CORD_pos p)
+{
+    return(p[0].path_len != CORD_POS_INVALID);
+}
+
+void CORD_set_pos(CORD_pos p, CORD x, size_t i)
+{
+    if (x == CORD_EMPTY) {
+    	p[0].path_len = CORD_POS_INVALID;
+    	return;
+    }
+    p[0].path[0].pe_cord = x;
+    p[0].path[0].pe_start_pos = 0;
+    p[0].path_len = 0;
+    p[0].cur_pos = i;
+    CORD__extend_path(p);
+}
diff --git a/src/mzscheme/gc/cord/cordprnt.c b/src/mzscheme/gc/cord/cordprnt.c
new file mode 100644
index 0000000..667560f
--- /dev/null
+++ b/src/mzscheme/gc/cord/cordprnt.c
@@ -0,0 +1,389 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* An sprintf implementation that understands cords.  This is probably	*/
+/* not terribly portable.  It assumes an ANSI stdarg.h.  It further	*/
+/* assumes that I can make copies of va_list variables, and read 	*/
+/* arguments repeatedly by applyting va_arg to the copies.  This	*/
+/* could be avoided at some performance cost.				*/
+/* We also assume that unsigned and signed integers of various kinds	*/
+/* have the same sizes, and can be cast back and forth.			*/
+/* We assume that void * and char * have the same size.			*/
+/* All this cruft is needed because we want to rely on the underlying	*/
+/* sprintf implementation whenever possible.				*/
+/* Boehm, September 21, 1995 6:00 pm PDT */
+
+#include "cord.h"
+#include "ec.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "gc.h"
+
+#define CONV_SPEC_LEN 50	/* Maximum length of a single	*/
+				/* conversion specification.	*/
+#define CONV_RESULT_LEN 50	/* Maximum length of any 	*/
+				/* conversion with default	*/
+				/* width and prec.		*/
+
+
+static int ec_len(CORD_ec x)
+{
+    return(CORD_len(x[0].ec_cord) + (x[0].ec_bufptr - x[0].ec_buf));
+}
+
+/* Possible nonumeric precision values.	*/
+# define NONE -1
+# define VARIABLE -2
+/* Copy the conversion specification from CORD_pos into the buffer buf	*/
+/* Return negative on error.						*/
+/* Source initially points one past the leading %.			*/
+/* It is left pointing at the conversion type.				*/
+/* Assign field width and precision to *width and *prec.		*/
+/* If width or prec is *, VARIABLE is assigned.				*/
+/* Set *left to 1 if left adjustment flag is present.			*/
+/* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to	*/
+/* -1 if 'h' is present.						*/
+static int extract_conv_spec(CORD_pos source, char *buf,
+			     int * width, int *prec, int *left, int * long_arg)
+{
+    register int result = 0;
+    register int current_number = 0;
+    register int saw_period = 0;
+    register int saw_number;
+    register int chars_so_far = 0;
+    register char current;
+    
+    *width = NONE;
+    buf[chars_so_far++] = '%';
+    while(CORD_pos_valid(source)) {
+        if (chars_so_far >= CONV_SPEC_LEN) return(-1);
+        current = CORD_pos_fetch(source);
+        buf[chars_so_far++] = current;
+        switch(current) {
+	  case '*':
+	    saw_number = 1;
+	    current_number = VARIABLE;
+	    break;
+          case '0':
+            if (!saw_number) {
+                /* Zero fill flag; ignore */
+                break;
+            } /* otherwise fall through: */
+          case '1':
+	  case '2':
+	  case '3':
+	  case '4':
+	  case '5':
+          case '6':
+	  case '7':
+	  case '8':
+	  case '9':
+	    saw_number = 1;
+	    current_number *= 10;
+	    current_number += current - '0';
+	    break;
+	  case '.':
+	    saw_period = 1;
+	    if(saw_number) {
+	        *width = current_number;
+	        saw_number = 0;
+	    }
+	    current_number = 0;
+	    break;
+	  case 'l':
+	  case 'L':
+	    *long_arg = 1;
+	    current_number = 0;
+	    break;
+	  case 'h':
+	    *long_arg = -1;
+	    current_number = 0;
+	    break;
+	  case ' ':
+	  case '+':
+	  case '#':
+	    current_number = 0;
+	    break;
+	  case '-':
+	    *left = 1;
+	    current_number = 0;
+	    break;
+	  case 'd':
+	  case 'i':
+	  case 'o':
+	  case 'u':
+	  case 'x':
+	  case 'X':
+	  case 'f':
+	  case 'e':
+	  case 'E':
+	  case 'g':
+	  case 'G':
+	  case 'c':
+	  case 'C':
+	  case 's':
+	  case 'S':
+	  case 'p':
+	  case 'n':
+	  case 'r':
+	    goto done;          
+          default:
+            return(-1);
+        }
+        CORD_next(source);
+    }
+    return(-1);
+  done:
+    if (saw_number) {
+    	if (saw_period) {
+    	    *prec = current_number;
+    	} else {
+    	    *prec = NONE;
+    	    *width = current_number;
+    	}
+    } else {
+    	*prec = NONE;
+    }
+    buf[chars_so_far] = '\0';
+    return(result);
+}
+
+int CORD_vsprintf(CORD * out, CORD format, va_list args)
+{
+    CORD_ec result;
+    register int count;
+    register char current;
+    CORD_pos pos;
+    char conv_spec[CONV_SPEC_LEN + 1];
+    
+    CORD_ec_init(result);
+    for (CORD_set_pos(pos, format, 0); CORD_pos_valid(pos); CORD_next(pos)) {
+       	current = CORD_pos_fetch(pos);
+       	if (current == '%') {
+            CORD_next(pos);
+            if (!CORD_pos_valid(pos)) return(-1);
+            current = CORD_pos_fetch(pos);
+            if (current == '%') {
+               	CORD_ec_append(result, current);
+            } else {
+             	int width, prec;
+             	int left_adj = 0;
+             	int long_arg = 0;
+		CORD arg;
+		size_t len;
+               
+              	if (extract_conv_spec(pos, conv_spec,
+              			      &width, &prec,
+              			      &left_adj, &long_arg) < 0) {
+              	    return(-1);
+              	}
+              	current = CORD_pos_fetch(pos);
+            	switch(current) {
+            	    case 'n':
+            	    	/* Assign length to next arg */
+            	    	if (long_arg == 0) {
+            	    	    int * pos_ptr;
+            	    	    pos_ptr = va_arg(args, int *);
+            	    	    *pos_ptr = ec_len(result);
+            	    	} else if (long_arg > 0) {
+            	    	    long * pos_ptr;
+            	    	    pos_ptr = va_arg(args, long *);
+            	    	    *pos_ptr = ec_len(result);
+            	    	} else {
+            	    	    short * pos_ptr;
+            	    	    pos_ptr = va_arg(args, short *);
+            	    	    *pos_ptr = ec_len(result);
+            	    	}
+            	    	goto done;
+            	    case 'r':
+            	    	/* Append cord and any padding	*/
+            	    	if (width == VARIABLE) width = va_arg(args, int);
+            	    	if (prec == VARIABLE) prec = va_arg(args, int);
+			arg = va_arg(args, CORD);
+			len = CORD_len(arg);
+			if (prec != NONE && len > prec) {
+			  if (prec < 0) return(-1);
+			  arg = CORD_substr(arg, 0, prec);
+			  len = prec;
+			}
+			if (width != NONE && len < width) {
+			  char * blanks = GC_MALLOC_ATOMIC(width-len+1);
+
+			  memset(blanks, ' ', width-len);
+			  blanks[width-len] = '\0';
+			  if (left_adj) {
+			    arg = CORD_cat(arg, blanks);
+			  } else {
+			    arg = CORD_cat(blanks, arg);
+			  }
+			}
+			CORD_ec_append_cord(result, arg);
+            	    	goto done;
+		    case 'c':
+			if (width == NONE && prec == NONE) {
+			    register char c = va_arg(args, char);
+
+			    CORD_ec_append(result, c);
+			    goto done;
+			}
+			break;
+		    case 's':
+		        if (width == NONE && prec == NONE) {
+			    char * str = va_arg(args, char *);
+			    register char c;
+
+			    while (c = *str++) {
+			        CORD_ec_append(result, c);
+			    }
+			    goto done;
+			}
+			break;
+            	    default:
+            	        break;
+            	}
+            	/* Use standard sprintf to perform conversion */
+            	{
+            	    register char * buf;
+            	    va_list vsprintf_args = args;
+            	    	/* The above does not appear to be sanctioned	*/
+            	    	/* by the ANSI C standard.			*/
+            	    int max_size = 0;
+            	    int res;
+            	    	
+            	    if (width == VARIABLE) width = va_arg(args, int);
+            	    if (prec == VARIABLE) prec = va_arg(args, int);
+            	    if (width != NONE) max_size = width;
+            	    if (prec != NONE && prec > max_size) max_size = prec;
+            	    max_size += CONV_RESULT_LEN;
+            	    if (max_size >= CORD_BUFSZ) {
+            	        buf = GC_MALLOC_ATOMIC(max_size + 1);
+            	    } else {
+            	        if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf)
+            	            < max_size) {
+            	            CORD_ec_flush_buf(result);
+            	        }
+            	        buf = result[0].ec_bufptr;
+            	    }
+            	    switch(current) {
+            	        case 'd':
+            	        case 'i':
+            	        case 'o':
+            	        case 'u':
+            	        case 'x':
+            	        case 'X':
+            	        case 'c':
+            	            if (long_arg <= 0) {
+            	              (void) va_arg(args, int);
+            	            } else if (long_arg > 0) {
+            	              (void) va_arg(args, long);
+            	            }
+            	            break;
+            	        case 's':
+            	        case 'p':
+            	            (void) va_arg(args, char *);
+            	            break;
+            	        case 'f':
+            	        case 'e':
+            	        case 'E':
+            	        case 'g':
+            	        case 'G':
+            	            (void) va_arg(args, double);
+            	            break;
+            	        default:
+            	            return(-1);
+            	    }
+            	    res = vsprintf(buf, conv_spec, vsprintf_args);
+            	    len = (size_t)res;
+            	    if ((char *)(GC_word)res == buf) {
+            	    	/* old style vsprintf */
+            	    	len = strlen(buf);
+            	    } else if (res < 0) {
+            	        return(-1);
+            	    }
+            	    if (buf != result[0].ec_bufptr) {
+            	        register char c;
+
+			while (c = *buf++) {
+			    CORD_ec_append(result, c);
+		        }
+		    } else {
+		        result[0].ec_bufptr = buf + len;
+		    }
+            	}
+              done:;
+            }
+        } else {
+            CORD_ec_append(result, current);
+        }
+    }
+    count = ec_len(result);
+    *out = CORD_balance(CORD_ec_to_cord(result));
+    return(count);
+}
+
+int CORD_sprintf(CORD * out, CORD format, ...)
+{
+    va_list args;
+    int result;
+    
+    va_start(args, format);
+    result = CORD_vsprintf(out, format, args);
+    va_end(args);
+    return(result);
+}
+
+int CORD_fprintf(FILE * f, CORD format, ...)
+{
+    va_list args;
+    int result;
+    CORD out;
+    
+    va_start(args, format);
+    result = CORD_vsprintf(&out, format, args);
+    va_end(args);
+    if (result > 0) CORD_put(out, f);
+    return(result);
+}
+
+int CORD_vfprintf(FILE * f, CORD format, va_list args)
+{
+    int result;
+    CORD out;
+    
+    result = CORD_vsprintf(&out, format, args);
+    if (result > 0) CORD_put(out, f);
+    return(result);
+}
+
+int CORD_printf(CORD format, ...)
+{
+    va_list args;
+    int result;
+    CORD out;
+    
+    va_start(args, format);
+    result = CORD_vsprintf(&out, format, args);
+    va_end(args);
+    if (result > 0) CORD_put(out, stdout);
+    return(result);
+}
+
+int CORD_vprintf(CORD format, va_list args)
+{
+    int result;
+    CORD out;
+    
+    result = CORD_vsprintf(&out, format, args);
+    if (result > 0) CORD_put(out, stdout);
+    return(result);
+}
diff --git a/src/mzscheme/gc/cord/cordtest.c b/src/mzscheme/gc/cord/cordtest.c
new file mode 100644
index 0000000..d11d7dd
--- /dev/null
+++ b/src/mzscheme/gc/cord/cordtest.c
@@ -0,0 +1,228 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, August 24, 1994 11:58 am PDT */
+# include "cord.h"
+# include <string.h>
+# include <stdio.h>
+/* This is a very incomplete test of the cord package.  It knows about	*/
+/* a few internals of the package (e.g. when C strings are returned)	*/
+/* that real clients shouldn't rely on.					*/
+
+# define ABORT(string) \
+{ int x = 0; fprintf(stderr, "FAILED: %s\n", string); x = 1 / x; abort(); }
+
+int count;
+
+int test_fn(char c, void * client_data)
+{
+    if (client_data != (void *)13) ABORT("bad client data");
+    if (count < 64*1024+1) {
+        if ((count & 1) == 0) {
+            if (c != 'b') ABORT("bad char");
+        } else {
+            if (c != 'a') ABORT("bad char");
+        }
+        count++;
+        return(0);
+    } else {
+        if (c != 'c') ABORT("bad char");
+        count++;
+        return(1);
+    }
+}
+
+char id_cord_fn(size_t i, void * client_data)
+{
+    return((char)i);
+}
+
+void test_basics()
+{
+    CORD x = CORD_from_char_star("ab");
+    register int i;
+    char c;
+    CORD y;
+    CORD_pos p;
+    
+    x = CORD_cat(x,x);
+    if (!CORD_IS_STRING(x)) ABORT("short cord should usually be a string");
+    if (strcmp(x, "abab") != 0) ABORT("bad CORD_cat result");
+    
+    for (i = 1; i < 16; i++) {
+        x = CORD_cat(x,x);
+    }
+    x = CORD_cat(x,"c");
+    if (CORD_len(x) != 128*1024+1) ABORT("bad length");
+    
+    count = 0;
+    if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) {
+        ABORT("CORD_iter5 failed");
+    }
+    if (count != 64*1024 + 2) ABORT("CORD_iter5 failed");
+    
+    count = 0;
+    CORD_set_pos(p, x, 64*1024-1);
+    while(CORD_pos_valid(p)) {
+       	(void) test_fn(CORD_pos_fetch(p), (void *)13);
+	CORD_next(p);
+    }
+    if (count != 64*1024 + 2) ABORT("Position based iteration failed");
+    
+    y = CORD_substr(x, 1023, 5);
+    if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
+    if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result");
+    
+    y = CORD_substr(x, 1024, 8);
+    if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
+    if (strcmp(y, "abababab") != 0) ABORT("bad CORD_substr result");
+    
+    y = CORD_substr(x, 128*1024-1, 8);
+    if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
+    if (strcmp(y, "bc") != 0) ABORT("bad CORD_substr result");
+    
+    x = CORD_balance(x);
+    if (CORD_len(x) != 128*1024+1) ABORT("bad length");
+    
+    count = 0;
+    if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) {
+        ABORT("CORD_iter5 failed");
+    }
+    if (count != 64*1024 + 2) ABORT("CORD_iter5 failed");
+    
+    y = CORD_substr(x, 1023, 5);
+    if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
+    if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result");
+    y = CORD_from_fn(id_cord_fn, 0, 13);
+    i = 0;
+    CORD_set_pos(p, y, i);
+    while(CORD_pos_valid(p)) {
+        c = CORD_pos_fetch(p);
+       	if(c != i) ABORT("Traversal of function node failed");
+	CORD_next(p); i++;
+    }
+    if (i != 13) ABORT("Bad apparent length for function node");
+}
+
+void test_extras()
+{
+#   if defined(__OS2__)
+#	define FNAME1 "tmp1"
+#	define FNAME2 "tmp2"
+#   elif defined(AMIGA)
+#	define FNAME1 "T:tmp1"
+#	define FNAME2 "T:tmp2"
+#   else
+#	define FNAME1 "/tmp/cord_test"
+#	define FNAME2 "/tmp/cord_test2"
+#   endif
+    register int i;
+    CORD y = "abcdefghijklmnopqrstuvwxyz0123456789";
+    CORD x = "{}";
+    CORD w, z;
+    FILE *f;
+    FILE *f1a, *f1b, *f2;
+    
+    w = CORD_cat(CORD_cat(y,y),y);
+    z = CORD_catn(3,y,y,y);
+    if (CORD_cmp(w,z) != 0) ABORT("CORD_catn comparison wrong");
+    for (i = 1; i < 100; i++) {
+        x = CORD_cat(x, y);
+    }
+    z = CORD_balance(x);
+    if (CORD_cmp(x,z) != 0) ABORT("balanced string comparison wrong");
+    if (CORD_cmp(x,CORD_cat(z, CORD_nul(13))) >= 0) ABORT("comparison 2");
+    if (CORD_cmp(CORD_cat(x, CORD_nul(13)), z) <= 0) ABORT("comparison 3");
+    if (CORD_cmp(x,CORD_cat(z, "13")) >= 0) ABORT("comparison 4");
+    if ((f = fopen(FNAME1, "w")) == 0) ABORT("open failed");
+    if (CORD_put(z,f) == EOF) ABORT("CORD_put failed");
+    if (fclose(f) == EOF) ABORT("fclose failed");
+    w = CORD_from_file(f1a = fopen(FNAME1, "rb"));
+    if (CORD_len(w) != CORD_len(z)) ABORT("file length wrong");
+    if (CORD_cmp(w,z) != 0) ABORT("file comparison wrong");
+    if (CORD_cmp(CORD_substr(w, 50*36+2, 36), y) != 0)
+    	ABORT("file substr wrong");
+    z = CORD_from_file_lazy(f1b = fopen(FNAME1, "rb"));
+    if (CORD_cmp(w,z) != 0) ABORT("File conversions differ");
+    if (CORD_chr(w, 0, '9') != 37) ABORT("CORD_chr failed 1");
+    if (CORD_chr(w, 3, 'a') != 38) ABORT("CORD_chr failed 2");
+    if (CORD_rchr(w, CORD_len(w) - 1, '}') != 1) ABORT("CORD_rchr failed");
+    x = y;
+    for (i = 1; i < 14; i++) {
+        x = CORD_cat(x,x);
+    }
+    if ((f = fopen(FNAME2, "w")) == 0) ABORT("2nd open failed");
+    if (CORD_put(x,f) == EOF) ABORT("CORD_put failed");
+    if (fclose(f) == EOF) ABORT("fclose failed");
+    w = CORD_from_file(f2 = fopen(FNAME2, "rb"));
+    if (CORD_len(w) != CORD_len(x)) ABORT("file length wrong");
+    if (CORD_cmp(w,x) != 0) ABORT("file comparison wrong");
+    if (CORD_cmp(CORD_substr(w, 1000*36, 36), y) != 0)
+    	ABORT("file substr wrong");
+    if (strcmp(CORD_to_char_star(CORD_substr(w, 1000*36, 36)), y) != 0)
+    	ABORT("char * file substr wrong");
+    if (strcmp(CORD_substr(w, 1000*36, 2), "ab") != 0)
+    	ABORT("short file substr wrong");
+    if (CORD_str(x,1,"9a") != 35) ABORT("CORD_str failed 1");
+    if (CORD_str(x,0,"9abcdefghijk") != 35) ABORT("CORD_str failed 2");
+    if (CORD_str(x,0,"9abcdefghijx") != CORD_NOT_FOUND)
+    	ABORT("CORD_str failed 3");
+    if (CORD_str(x,0,"9>") != CORD_NOT_FOUND) ABORT("CORD_str failed 4");
+    if (remove(FNAME1) != 0) {
+    	/* On some systems, e.g. OS2, this may fail if f1 is still open. */
+    	if ((fclose(f1a) == EOF) & (fclose(f1b) == EOF))
+    		ABORT("fclose(f1) failed");
+    	if (remove(FNAME1) != 0) ABORT("remove 1 failed");
+    }
+    if (remove(FNAME2) != 0) {
+    	if (fclose(f2) == EOF) ABORT("fclose(f2) failed");
+    	if (remove(FNAME2) != 0) ABORT("remove 2 failed");
+    }
+}
+
+void test_printf()
+{
+    CORD result;
+    char result2[200];
+    long l;
+    short s;
+    CORD x;
+    
+    if (CORD_sprintf(&result, "%7.2f%ln", 3.14159F, &l) != 7)
+    	ABORT("CORD_sprintf failed 1");
+    if (CORD_cmp(result, "   3.14") != 0)ABORT("CORD_sprintf goofed 1");
+    if (l != 7) ABORT("CORD_sprintf goofed 2");
+    if (CORD_sprintf(&result, "%-7.2s%hn%c%s", "abcd", &s, 'x', "yz") != 10)
+    	ABORT("CORD_sprintf failed 2");
+    if (CORD_cmp(result, "ab     xyz") != 0)ABORT("CORD_sprintf goofed 3");
+    if (s != 7) ABORT("CORD_sprintf goofed 4");
+    x = "abcdefghij";
+    x = CORD_cat(x,x);
+    x = CORD_cat(x,x);
+    x = CORD_cat(x,x);
+    if (CORD_sprintf(&result, "->%-120.78r!\n", x) != 124)
+    	ABORT("CORD_sprintf failed 3");
+    (void) sprintf(result2, "->%-120.78s!\n", CORD_to_char_star(x));
+    if (CORD_cmp(result, result2) != 0)ABORT("CORD_sprintf goofed 5");
+}
+
+main()
+{
+#   ifdef THINK_C
+        printf("cordtest:\n");
+#   endif
+    test_basics();
+    test_extras();
+    test_printf();
+    CORD_fprintf(stderr, "SUCCEEDED\n");
+    return(0);
+}
diff --git a/src/mzscheme/gc/cord/cordxtra.c b/src/mzscheme/gc/cord/cordxtra.c
new file mode 100644
index 0000000..8566e14
--- /dev/null
+++ b/src/mzscheme/gc/cord/cordxtra.c
@@ -0,0 +1,619 @@
+/*
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Author: Hans-J. Boehm (boehm@parc.xerox.com)
+ */
+/*
+ * These are functions on cords that do not need to understand their
+ * implementation.  They serve also serve as example client code for
+ * cord_basics.
+ */
+/* Boehm, December 8, 1995 1:53 pm PST */
+# include <stdio.h>
+# include <string.h>
+# include <stdlib.h>
+# include <stdarg.h>
+# include "cord.h"
+# include "ec.h"
+# define I_HIDE_POINTERS	/* So we get access to allocation lock.	*/
+				/* We use this for lazy file reading, 	*/
+				/* so that we remain independent 	*/
+				/* of the threads primitives.		*/
+# include "gc.h"
+
+/* For now we assume that pointer reads and writes are atomic, 	*/
+/* i.e. another thread always sees the state before or after	*/
+/* a write.  This might be false on a Motorola M68K with	*/
+/* pointers that are not 32-bit aligned.  But there probably	*/
+/* aren't too many threads packages running on those.		*/
+# define ATOMIC_WRITE(x,y) (x) = (y)
+# define ATOMIC_READ(x) (*(x))
+
+/* The standard says these are in stdio.h, but they aren't always: */
+# ifndef SEEK_SET
+#   define SEEK_SET 0
+# endif
+# ifndef SEEK_END
+#   define SEEK_END 2
+# endif
+
+# define BUFSZ 2048	/* Size of stack allocated buffers when		*/
+			/* we want large buffers.			*/
+
+typedef void (* oom_fn)(void);
+
+# define OUT_OF_MEMORY {  if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \
+			  ABORT("Out of memory\n"); }
+# define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); }
+
+CORD CORD_cat_char(CORD x, char c)
+{
+    register char * string;
+    
+    if (c == '\0') return(CORD_cat(x, CORD_nul(1)));
+    string = GC_MALLOC_ATOMIC(2);
+    if (string == 0) OUT_OF_MEMORY;
+    string[0] = c;
+    string[1] = '\0';
+    return(CORD_cat_char_star(x, string, 1));
+}
+
+CORD CORD_catn(int nargs, ...)
+{
+    register CORD result = CORD_EMPTY;
+    va_list args;
+    register int i;
+
+    va_start(args, nargs);
+    for (i = 0; i < nargs; i++) {
+        register CORD next = va_arg(args, CORD);
+        result = CORD_cat(result, next);
+    }
+    va_end(args);
+    return(result);
+}
+
+typedef struct {
+	size_t len;
+	size_t count;
+	char * buf;
+} CORD_fill_data;
+
+int CORD_fill_proc(char c, void * client_data)
+{
+    register CORD_fill_data * d = (CORD_fill_data *)client_data;
+    register size_t count = d -> count;
+    
+    (d -> buf)[count] = c;
+    d -> count = ++count;
+    if (count >= d -> len) {
+    	return(1);
+    } else {
+    	return(0);
+    }
+}
+
+int CORD_batched_fill_proc(const char * s, void * client_data)
+{
+    register CORD_fill_data * d = (CORD_fill_data *)client_data;
+    register size_t count = d -> count;
+    register size_t max = d -> len;
+    register char * buf = d -> buf;
+    register const char * t = s;
+    
+    while((buf[count] = *t++) != '\0') {
+        count++;
+        if (count >= max) {
+            d -> count = count;
+            return(1);
+        }
+    }
+    d -> count = count;
+    return(0);
+}
+
+/* Fill buf with len characters starting at i.  			*/
+/* Assumes len characters are available.				*/ 
+void CORD_fill_buf(CORD x, size_t i, size_t len, char * buf)
+{
+    CORD_fill_data fd;
+    
+    fd.len = len;
+    fd.buf = buf;
+    fd.count = 0;
+    (void)CORD_iter5(x, i, CORD_fill_proc, CORD_batched_fill_proc, &fd);
+}
+
+int CORD_cmp(CORD x, CORD y)
+{
+    CORD_pos xpos;
+    CORD_pos ypos;
+    register size_t avail, yavail;
+    
+    if (y == CORD_EMPTY) return(x != CORD_EMPTY);
+    if (x == CORD_EMPTY) return(-1);
+    if (CORD_IS_STRING(y) && CORD_IS_STRING(x)) return(strcmp(x,y));
+    CORD_set_pos(xpos, x, 0);
+    CORD_set_pos(ypos, y, 0);
+    for(;;) {
+        if (!CORD_pos_valid(xpos)) {
+            if (CORD_pos_valid(ypos)) {
+            	return(-1);
+            } else {
+                return(0);
+            }
+        }
+        if (!CORD_pos_valid(ypos)) {
+            return(1);
+        }
+        if ((avail = CORD_pos_chars_left(xpos)) <= 0
+            || (yavail = CORD_pos_chars_left(ypos)) <= 0) {
+            register char xcurrent = CORD_pos_fetch(xpos);
+            register char ycurrent = CORD_pos_fetch(ypos);
+            if (xcurrent != ycurrent) return(xcurrent - ycurrent);
+            CORD_next(xpos);
+            CORD_next(ypos);
+        } else {
+            /* process as many characters as we can	*/
+            register int result;
+            
+            if (avail > yavail) avail = yavail;
+            result = strncmp(CORD_pos_cur_char_addr(xpos),
+            		     CORD_pos_cur_char_addr(ypos), avail);
+            if (result != 0) return(result);
+            CORD_pos_advance(xpos, avail);
+            CORD_pos_advance(ypos, avail);
+        }
+    }
+}
+
+int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len)
+{
+    CORD_pos xpos;
+    CORD_pos ypos;
+    register size_t count;
+    register long avail, yavail;
+    
+    CORD_set_pos(xpos, x, x_start);
+    CORD_set_pos(ypos, y, y_start);
+    for(count = 0; count < len;) {
+        if (!CORD_pos_valid(xpos)) {
+            if (CORD_pos_valid(ypos)) {
+            	return(-1);
+            } else {
+                return(0);
+            }
+        }
+        if (!CORD_pos_valid(ypos)) {
+            return(1);
+        }
+        if ((avail = CORD_pos_chars_left(xpos)) <= 0
+            || (yavail = CORD_pos_chars_left(ypos)) <= 0) {
+            register char xcurrent = CORD_pos_fetch(xpos);
+            register char ycurrent = CORD_pos_fetch(ypos);
+            if (xcurrent != ycurrent) return(xcurrent - ycurrent);
+            CORD_next(xpos);
+            CORD_next(ypos);
+            count++;
+        } else {
+            /* process as many characters as we can	*/
+            register int result;
+            
+            if (avail > yavail) avail = yavail;
+            count += avail;
+            if (count > len) avail -= (count - len);
+            result = strncmp(CORD_pos_cur_char_addr(xpos),
+            		     CORD_pos_cur_char_addr(ypos), (size_t)avail);
+            if (result != 0) return(result);
+            CORD_pos_advance(xpos, (size_t)avail);
+            CORD_pos_advance(ypos, (size_t)avail);
+        }
+    }
+    return(0);
+}
+
+char * CORD_to_char_star(CORD x)
+{
+    register size_t len = CORD_len(x);
+    char * result = GC_MALLOC_ATOMIC(len + 1);
+    
+    if (result == 0) OUT_OF_MEMORY;
+    CORD_fill_buf(x, 0, len, result);
+    result[len] = '\0';
+    return(result);
+}
+
+CORD CORD_from_char_star(const char *s)
+{
+    char * result;
+    size_t len = strlen(s);
+
+    if (0 == len) return(CORD_EMPTY);
+    result = GC_MALLOC_ATOMIC(len + 1);
+    if (result == 0) OUT_OF_MEMORY;
+    memcpy(result, s, len+1);
+    return(result);
+}
+
+const char * CORD_to_const_char_star(CORD x)
+{
+    if (x == 0) return("");
+    if (CORD_IS_STRING(x)) return((const char *)x);
+    return(CORD_to_char_star(x));
+}
+
+char CORD_fetch(CORD x, size_t i)
+{
+    CORD_pos xpos;
+    
+    CORD_set_pos(xpos, x, i);
+    if (!CORD_pos_valid(xpos)) ABORT("bad index?");
+    return(CORD_pos_fetch(xpos));
+}
+
+
+int CORD_put_proc(char c, void * client_data)
+{
+    register FILE * f = (FILE *)client_data;
+    
+    return(putc(c, f) == EOF);
+}
+
+int CORD_batched_put_proc(const char * s, void * client_data)
+{
+    register FILE * f = (FILE *)client_data;
+    
+    return(fputs(s, f) == EOF);
+}
+    
+
+int CORD_put(CORD x, FILE * f)
+{
+    if (CORD_iter5(x, 0, CORD_put_proc, CORD_batched_put_proc, f)) {
+        return(EOF);
+    } else {
+    	return(1);
+    }
+}
+
+typedef struct {
+    size_t pos;		/* Current position in the cord */
+    char target;	/* Character we're looking for	*/
+} chr_data;
+
+int CORD_chr_proc(char c, void * client_data)
+{
+    register chr_data * d = (chr_data *)client_data;
+    
+    if (c == d -> target) return(1);
+    (d -> pos) ++;
+    return(0);
+}
+
+int CORD_rchr_proc(char c, void * client_data)
+{
+    register chr_data * d = (chr_data *)client_data;
+    
+    if (c == d -> target) return(1);
+    (d -> pos) --;
+    return(0);
+}
+
+int CORD_batched_chr_proc(const char *s, void * client_data)
+{
+    register chr_data * d = (chr_data *)client_data;
+    register char * occ = strchr(s, d -> target);
+    
+    if (occ == 0) {
+      	d -> pos += strlen(s);
+      	return(0);
+    } else {
+    	d -> pos += occ - s;
+    	return(1);
+    }
+}
+
+size_t CORD_chr(CORD x, size_t i, int c)
+{
+    chr_data d;
+    
+    d.pos = i;
+    d.target = c;
+    if (CORD_iter5(x, i, CORD_chr_proc, CORD_batched_chr_proc, &d)) {
+        return(d.pos);
+    } else {
+    	return(CORD_NOT_FOUND);
+    }
+}
+
+size_t CORD_rchr(CORD x, size_t i, int c)
+{
+    chr_data d;
+    
+    d.pos = i;
+    d.target = c;
+    if (CORD_riter4(x, i, CORD_rchr_proc, &d)) {
+        return(d.pos);
+    } else {
+    	return(CORD_NOT_FOUND);
+    }
+}
+
+/* Find the first occurrence of s in x at position start or later.	*/
+/* This uses an asymptotically poor algorithm, which should typically 	*/
+/* perform acceptably.  We compare the first few characters directly,	*/
+/* and call CORD_ncmp whenever there is a partial match.		*/
+/* This has the advantage that we allocate very little, or not at all.	*/
+/* It's very fast if there are few close misses.			*/
+size_t CORD_str(CORD x, size_t start, CORD s)
+{
+    CORD_pos xpos;
+    size_t xlen = CORD_len(x);
+    size_t slen;
+    register size_t start_len;
+    const char * s_start;
+    unsigned long s_buf = 0;	/* The first few characters of s	*/
+    unsigned long x_buf = 0;	/* Start of candidate substring.	*/
+    				/* Initialized only to make compilers	*/
+    				/* happy.				*/
+    unsigned long mask = 0;
+    register size_t i;
+    register size_t match_pos;
+    
+    if (s == CORD_EMPTY) return(start);
+    if (CORD_IS_STRING(s)) {
+        s_start = s;
+        slen = strlen(s);
+    } else {
+        s_start = CORD_to_char_star(CORD_substr(s, 0, sizeof(unsigned long)));
+        slen = CORD_len(s);
+    }
+    if (xlen < start || xlen - start < slen) return(CORD_NOT_FOUND);
+    start_len = slen;
+    if (start_len > sizeof(unsigned long)) start_len = sizeof(unsigned long);
+    CORD_set_pos(xpos, x, start);
+    for (i = 0; i < start_len; i++) {
+        mask <<= 8;
+        mask |= 0xff;
+        s_buf <<= 8;
+        s_buf |= s_start[i];
+        x_buf <<= 8;
+        x_buf |= CORD_pos_fetch(xpos);
+        CORD_next(xpos);
+    }
+    for (match_pos = start; match_pos < xlen - slen; match_pos++) {
+    	if ((x_buf & mask) == s_buf) {
+    	    if (slen == start_len ||
+    	     	CORD_ncmp(x, match_pos + start_len,
+    	     	 	  s, start_len, slen - start_len) == 0) {
+    	        return(match_pos);
+    	    }
+    	}
+    	x_buf <<= 8;
+        x_buf |= CORD_pos_fetch(xpos);
+        CORD_next(xpos);
+    }
+    return(CORD_NOT_FOUND);
+}
+
+void CORD_ec_flush_buf(CORD_ec x)
+{
+    register size_t len = x[0].ec_bufptr - x[0].ec_buf;
+    char * s;
+
+    if (len == 0) return;
+    s = GC_MALLOC_ATOMIC(len+1);
+    memcpy(s, x[0].ec_buf, len);
+    s[len] = '\0';
+    x[0].ec_cord = CORD_cat_char_star(x[0].ec_cord, s, len);
+    x[0].ec_bufptr = x[0].ec_buf;
+}
+
+void CORD_ec_append_cord(CORD_ec x, CORD s)
+{
+    CORD_ec_flush_buf(x);
+    x[0].ec_cord = CORD_cat(x[0].ec_cord, s);
+}
+
+/*ARGSUSED*/
+char CORD_nul_func(size_t i, void * client_data)
+{
+    return((char)(unsigned long)client_data);
+}
+
+
+CORD CORD_chars(char c, size_t i)
+{
+    return(CORD_from_fn(CORD_nul_func, (void *)(unsigned long)c, i));
+}
+
+CORD CORD_from_file_eager(FILE * f)
+{
+    register int c;
+    CORD_ec ecord;
+    
+    CORD_ec_init(ecord);
+    for(;;) {
+        c = getc(f);
+        if (c == 0) {
+          /* Append the right number of NULs	*/
+          /* Note that any string of NULs is rpresented in 4 words,	*/
+          /* independent of its length.					*/
+            register size_t count = 1;
+            
+            CORD_ec_flush_buf(ecord);
+            while ((c = getc(f)) == 0) count++;
+            ecord[0].ec_cord = CORD_cat(ecord[0].ec_cord, CORD_nul(count));
+        }
+        if (c == EOF) break;
+        CORD_ec_append(ecord, c);
+    }
+    (void) fclose(f);
+    return(CORD_balance(CORD_ec_to_cord(ecord)));
+}
+
+/* The state maintained for a lazily read file consists primarily	*/
+/* of a large direct-mapped cache of previously read values.		*/
+/* We could rely more on stdio buffering.  That would have 2		*/
+/* disadvantages:							*/
+/*  	1) Empirically, not all fseek implementations preserve the	*/
+/*	   buffer whenever they could.					*/
+/*	2) It would fail if 2 different sections of a long cord		*/
+/*	   were being read alternately.					*/
+/* We do use the stdio buffer for read ahead.				*/
+/* To guarantee thread safety in the presence of atomic pointer		*/
+/* writes, cache lines are always replaced, and never modified in	*/
+/* place.								*/
+
+# define LOG_CACHE_SZ 14
+# define CACHE_SZ (1 << LOG_CACHE_SZ)
+# define LOG_LINE_SZ 9
+# define LINE_SZ (1 << LOG_LINE_SZ)
+
+typedef struct {
+    size_t tag;
+    char data[LINE_SZ];
+    	/* data[i%LINE_SZ] = ith char in file if tag = i/LINE_SZ	*/
+} cache_line;
+
+typedef struct {
+    FILE * lf_file;
+    size_t lf_current;	/* Current file pointer value */
+    cache_line * volatile lf_cache[CACHE_SZ/LINE_SZ];
+} lf_state;
+
+# define MOD_CACHE_SZ(n) ((n) & (CACHE_SZ - 1))
+# define DIV_CACHE_SZ(n) ((n) >> LOG_CACHE_SZ)
+# define MOD_LINE_SZ(n) ((n) & (LINE_SZ - 1))
+# define DIV_LINE_SZ(n) ((n) >> LOG_LINE_SZ)
+# define LINE_START(n) ((n) & ~(LINE_SZ - 1))
+
+typedef struct {
+    lf_state * state;
+    size_t file_pos;	/* Position of needed character. */
+    cache_line * new_cache;
+} refill_data;
+
+/* Executed with allocation lock. */
+static char refill_cache(client_data)
+refill_data * client_data;
+{
+    register lf_state * state = client_data -> state;
+    register size_t file_pos = client_data -> file_pos;
+    FILE *f = state -> lf_file;
+    size_t line_start = LINE_START(file_pos);
+    size_t line_no = DIV_LINE_SZ(MOD_CACHE_SZ(file_pos));
+    cache_line * new_cache = client_data -> new_cache;
+    
+    if (line_start != state -> lf_current
+        && fseek(f, line_start, SEEK_SET) != 0) {
+    	    ABORT("fseek failed");
+    }
+    if (fread(new_cache -> data, sizeof(char), LINE_SZ, f)
+    	<= file_pos - line_start) {
+    	ABORT("fread failed");
+    }
+    new_cache -> tag = DIV_LINE_SZ(file_pos);
+    /* Store barrier goes here. */
+    ATOMIC_WRITE(state -> lf_cache[line_no], new_cache);
+    state -> lf_current = line_start + LINE_SZ;
+    return(new_cache->data[MOD_LINE_SZ(file_pos)]);
+}
+
+char CORD_lf_func(size_t i, void * client_data)
+{
+    register lf_state * state = (lf_state *)client_data;
+    register cache_line * volatile * cl_addr =
+		&(state -> lf_cache[DIV_LINE_SZ(MOD_CACHE_SZ(i))]);
+    register cache_line * cl = (cache_line *)ATOMIC_READ(cl_addr);
+    
+    if (cl == 0 || cl -> tag != DIV_LINE_SZ(i)) {
+    	/* Cache miss */
+    	refill_data rd;
+    	
+        rd.state = state;
+        rd.file_pos =  i;
+        rd.new_cache = GC_NEW_ATOMIC(cache_line);
+        if (rd.new_cache == 0) OUT_OF_MEMORY;
+        return((char)(GC_word)
+        	  GC_call_with_alloc_lock((GC_fn_type) refill_cache, &rd));
+    }
+    return(cl -> data[MOD_LINE_SZ(i)]);
+}    
+
+/*ARGSUSED*/
+void CORD_lf_close_proc(void * obj, void * client_data)  
+{
+    if (fclose(((lf_state *)obj) -> lf_file) != 0) {
+    	ABORT("CORD_lf_close_proc: fclose failed");
+    }
+}			
+
+CORD CORD_from_file_lazy_inner(FILE * f, size_t len)
+{
+    register lf_state * state = GC_NEW(lf_state);
+    register int i;
+    
+    if (state == 0) OUT_OF_MEMORY;
+    if (len != 0) {
+	/* Dummy read to force buffer allocation.  	*/
+	/* This greatly increases the probability	*/
+	/* of avoiding deadlock if buffer allocation	*/
+	/* is redirected to GC_malloc and the		*/
+	/* world is multithreaded.			*/
+	char buf[1];
+
+	(void) fread(buf, 1, 1, f); 
+	rewind(f);
+    }
+    state -> lf_file = f;
+    for (i = 0; i < CACHE_SZ/LINE_SZ; i++) {
+        state -> lf_cache[i] = 0;
+    }
+    state -> lf_current = 0;
+    GC_register_finalizer(state, CORD_lf_close_proc, 0, 0, 0);
+    return(CORD_from_fn(CORD_lf_func, state, len));
+}
+
+CORD CORD_from_file_lazy(FILE * f)
+{
+    register long len;
+    
+    if (fseek(f, 0l, SEEK_END) != 0) {
+        ABORT("Bad fd argument - fseek failed");
+    }
+    if ((len = ftell(f)) < 0) {
+        ABORT("Bad fd argument - ftell failed");
+    }
+    rewind(f);
+    return(CORD_from_file_lazy_inner(f, (size_t)len));
+}
+
+# define LAZY_THRESHOLD (128*1024 + 1)
+
+CORD CORD_from_file(FILE * f)
+{
+    register long len;
+    
+    if (fseek(f, 0l, SEEK_END) != 0) {
+        ABORT("Bad fd argument - fseek failed");
+    }
+    if ((len = ftell(f)) < 0) {
+        ABORT("Bad fd argument - ftell failed");
+    }
+    rewind(f);
+    if (len < LAZY_THRESHOLD) {
+        return(CORD_from_file_eager(f));
+    } else {
+        return(CORD_from_file_lazy_inner(f, (size_t)len));
+    }
+}
diff --git a/src/mzscheme/gc/cord/de.c b/src/mzscheme/gc/cord/de.c
new file mode 100644
index 0000000..18625d2
--- /dev/null
+++ b/src/mzscheme/gc/cord/de.c
@@ -0,0 +1,604 @@
+/*
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Author: Hans-J. Boehm (boehm@parc.xerox.com)
+ */
+/*
+ * A really simple-minded text editor based on cords.
+ * Things it does right:
+ * 	No size bounds.
+ *	Inbounded undo.
+ *	Shouldn't crash no matter what file you invoke it on (e.g. /vmunix)
+ *		(Make sure /vmunix is not writable before you try this.)
+ *	Scrolls horizontally.
+ * Things it does wrong:
+ *	It doesn't handle tabs reasonably (use "expand" first).
+ *	The command set is MUCH too small.
+ *	The redisplay algorithm doesn't let curses do the scrolling.
+ *	The rule for moving the window over the file is suboptimal.
+ */
+/* Boehm, February 6, 1995 12:27 pm PST */
+
+/* Boehm, May 19, 1994 2:20 pm PDT */
+#include <stdio.h>
+#include "gc.h"
+#include "cord.h"
+
+#ifdef THINK_C
+#define MACINTOSH
+#include <ctype.h>
+#endif
+
+#if defined(__BORLANDC__) && !defined(WIN32)
+    /* If this is DOS or win16, we'll fail anyway.	*/
+    /* Might as well assume win32.			*/
+#   define WIN32
+#endif
+
+#if defined(WIN32)
+#  include <windows.h>
+#  include "de_win.h"
+#elif defined(MACINTOSH)
+#	include <console.h>
+/* curses emulation. */
+#	define initscr()
+#	define endwin()
+#	define nonl()
+#	define noecho() csetmode(C_NOECHO, stdout)
+#	define cbreak() csetmode(C_CBREAK, stdout)
+#	define refresh()
+#	define addch(c) putchar(c)
+#	define standout() cinverse(1, stdout)
+#	define standend() cinverse(0, stdout)
+#	define move(line,col) cgotoxy(col + 1, line + 1, stdout)
+#	define clrtoeol() ccleol(stdout)
+#	define de_error(s) { fprintf(stderr, s); getchar(); }
+#	define LINES 25
+#	define COLS 80
+#else
+#  include <curses.h>
+#  define de_error(s) { fprintf(stderr, s); sleep(2); }
+#endif
+#include "de_cmds.h"
+
+/* List of line number to position mappings, in descending order. */
+/* There may be holes.						  */
+typedef struct LineMapRep {
+    int line;
+    size_t pos;
+    struct LineMapRep * previous;
+} * line_map;
+
+/* List of file versions, one per edit operation */
+typedef struct HistoryRep {
+    CORD file_contents;
+    struct HistoryRep * previous;
+    line_map map;	/* Invalid for first record "now" */
+} * history;
+
+history now = 0;
+CORD current;		/* == now -> file_contents.	*/
+size_t current_len;	/* Current file length.		*/
+line_map current_map = 0;	/* Current line no. to pos. map	 */
+size_t current_map_size = 0;	/* Number of current_map entries.	*/
+				/* Not always accurate, but reset	*/
+				/* by prune_map.			*/
+# define MAX_MAP_SIZE 3000
+
+/* Current display position */
+int dis_line = 0;
+int dis_col = 0;
+
+# define ALL -1
+# define NONE - 2
+int need_redisplay = 0;	/* Line that needs to be redisplayed.	*/
+
+
+/* Current cursor position. Always within file. */
+int line = 0; 
+int col = 0;
+size_t file_pos = 0;	/* Character position corresponding to cursor.	*/
+
+/* Invalidate line map for lines > i */
+void invalidate_map(int i)
+{
+    while(current_map -> line > i) {
+        current_map = current_map -> previous;
+        current_map_size--;
+    }
+}
+
+/* Reduce the number of map entries to save space for huge files. */
+/* This also affects maps in histories.				  */
+void prune_map()
+{
+    line_map map = current_map;
+    int start_line = map -> line;
+    
+    current_map_size = 0;
+    for(; map != 0; map = map -> previous) {
+    	current_map_size++;
+    	if (map -> line < start_line - LINES && map -> previous != 0) {
+    	    map -> previous = map -> previous -> previous;
+    	}
+    }
+}
+/* Add mapping entry */
+void add_map(int line, size_t pos)
+{
+    line_map new_map = GC_NEW(struct LineMapRep);
+    
+    if (current_map_size >= MAX_MAP_SIZE) prune_map();
+    new_map -> line = line;
+    new_map -> pos = pos;
+    new_map -> previous = current_map;
+    current_map = new_map;
+    current_map_size++;
+}
+
+
+
+/* Return position of column *c of ith line in   */
+/* current file. Adjust *c to be within the line.*/
+/* A 0 pointer is taken as 0 column.		 */
+/* Returns CORD_NOT_FOUND if i is too big.	 */
+/* Assumes i > dis_line.			 */
+size_t line_pos(int i, int *c)
+{
+    int j;
+    size_t cur;
+    size_t next;
+    line_map map = current_map;
+    
+    while (map -> line > i) map = map -> previous;
+    if (map -> line < i - 2) /* rebuild */ invalidate_map(i);
+    for (j = map -> line, cur = map -> pos; j < i;) {
+	cur = CORD_chr(current, cur, '\n');
+        if (cur == current_len-1) return(CORD_NOT_FOUND);
+        cur++;
+        if (++j > current_map -> line) add_map(j, cur);
+    }
+    if (c != 0) {
+        next = CORD_chr(current, cur, '\n');
+        if (next == CORD_NOT_FOUND) next = current_len - 1;
+        if (next < cur + *c) {
+            *c = next - cur;
+        }
+        cur += *c;
+    }
+    return(cur);
+}
+
+void add_hist(CORD s)
+{
+    history new_file = GC_NEW(struct HistoryRep);
+    
+    new_file -> file_contents = current = s;
+    current_len = CORD_len(s);
+    new_file -> previous = now;
+    if (now != 0) now -> map = current_map;
+    now = new_file;
+}
+
+void del_hist(void)
+{
+    now = now -> previous;
+    current = now -> file_contents;
+    current_map = now -> map;
+    current_len = CORD_len(current);
+}
+
+/* Current screen_contents; a dynamically allocated array of CORDs	*/
+CORD * screen = 0;
+int screen_size = 0;
+
+# ifndef WIN32
+/* Replace a line in the curses stdscr.	All control characters are	*/
+/* displayed as upper case characters in standout mode.  This isn't	*/
+/* terribly appropriate for tabs.									*/
+void replace_line(int i, CORD s)
+{
+    register int c;
+    CORD_pos p;
+    size_t len = CORD_len(s);
+    
+    if (screen == 0 || LINES > screen_size) {
+        screen_size = LINES;
+    	screen = (CORD *)GC_MALLOC(screen_size * sizeof(CORD));
+    }
+#   if !defined(MACINTOSH)
+        /* A gross workaround for an apparent curses bug: */
+        if (i == LINES-1 && len == COLS) {
+            s = CORD_substr(s, 0, CORD_len(s) - 1);
+        }
+#   endif
+    if (CORD_cmp(screen[i], s) != 0) {
+        move(i, 0); clrtoeol(); move(i,0);
+
+        CORD_FOR (p, s) {
+            c = CORD_pos_fetch(p) & 0x7f;
+            if (iscntrl(c)) {
+            	standout(); addch(c + 0x40); standend();
+            } else {
+    	        addch(c);
+    	    }
+    	}
+    	screen[i] = s;
+    }
+}
+#else
+# define replace_line(i,s) invalidate_line(i)
+#endif
+
+/* Return up to COLS characters of the line of s starting at pos,	*/
+/* returning only characters after the given column.			*/
+CORD retrieve_line(CORD s, size_t pos, unsigned column)
+{
+    CORD candidate = CORD_substr(s, pos, column + COLS);
+    			/* avoids scanning very long lines	*/
+    int eol = CORD_chr(candidate, 0, '\n');
+    int len;
+    
+    if (eol == CORD_NOT_FOUND) eol = CORD_len(candidate);
+    len = (int)eol - (int)column;
+    if (len < 0) len = 0;
+    return(CORD_substr(s, pos + column, len));
+}
+
+# ifdef WIN32
+#   define refresh();
+
+    CORD retrieve_screen_line(int i)
+    {
+    	register size_t pos;
+    	
+    	invalidate_map(dis_line + LINES);	/* Prune search */
+    	pos = line_pos(dis_line + i, 0);
+    	if (pos == CORD_NOT_FOUND) return(CORD_EMPTY);
+    	return(retrieve_line(current, pos, dis_col));
+    }
+# endif
+
+/* Display the visible section of the current file	 */
+void redisplay(void)
+{
+    register int i;
+    
+    invalidate_map(dis_line + LINES);	/* Prune search */
+    for (i = 0; i < LINES; i++) {
+        if (need_redisplay == ALL || need_redisplay == i) {
+            register size_t pos = line_pos(dis_line + i, 0);
+            
+            if (pos == CORD_NOT_FOUND) break;
+            replace_line(i, retrieve_line(current, pos, dis_col));
+            if (need_redisplay == i) goto done;
+        }
+    }
+    for (; i < LINES; i++) replace_line(i, CORD_EMPTY);
+done:
+    refresh();
+    need_redisplay = NONE;
+}
+
+int dis_granularity;
+
+/* Update dis_line, dis_col, and dis_pos to make cursor visible.	*/
+/* Assumes line, col, dis_line, dis_pos are in bounds.			*/
+void normalize_display()
+{
+    int old_line = dis_line;
+    int old_col = dis_col;
+    
+    dis_granularity = 1;
+    if (LINES > 15 && COLS > 15) dis_granularity = 2;
+    while (dis_line > line) dis_line -= dis_granularity;
+    while (dis_col > col) dis_col -= dis_granularity;
+    while (line >= dis_line + LINES) dis_line += dis_granularity;
+    while (col >= dis_col + COLS) dis_col += dis_granularity;
+    if (old_line != dis_line || old_col != dis_col) {
+        need_redisplay = ALL;
+    }
+}
+
+# if defined(WIN32)
+# elif defined(MACINTOSH)
+#		define move_cursor(x,y) cgotoxy(x + 1, y + 1, stdout)
+# else
+#		define move_cursor(x,y) move(y,x)
+# endif
+
+/* Adjust display so that cursor is visible; move cursor into position	*/
+/* Update screen if necessary.						*/
+void fix_cursor(void)
+{
+    normalize_display();
+    if (need_redisplay != NONE) redisplay();
+    move_cursor(col - dis_col, line - dis_line);
+    refresh();
+#   ifndef WIN32
+      fflush(stdout);
+#   endif
+}
+
+/* Make sure line, col, and dis_pos are somewhere inside file.	*/
+/* Recompute file_pos.	Assumes dis_pos is accurate or past eof	*/
+void fix_pos()
+{
+    int my_col = col;
+    
+    if ((size_t)line > current_len) line = current_len;
+    file_pos = line_pos(line, &my_col);
+    if (file_pos == CORD_NOT_FOUND) {
+        for (line = current_map -> line, file_pos = current_map -> pos;
+             file_pos < current_len;
+             line++, file_pos = CORD_chr(current, file_pos, '\n') + 1);
+    	line--;
+        file_pos = line_pos(line, &col);
+    } else {
+    	col = my_col;
+    }
+}
+
+#if defined(WIN32)
+#  define beep() Beep(1000 /* Hz */, 300 /* msecs */) 
+#elif defined(MACINTOSH)
+#	define beep() SysBeep(1)
+#else
+/*
+ * beep() is part of some curses packages and not others.
+ * We try to match the type of the builtin one, if any.
+ */
+#ifdef __STDC__
+    int beep(void)
+#else
+    int beep()
+#endif
+{
+    putc('\007', stderr);
+    return(0);
+}
+#endif
+
+#   define NO_PREFIX -1
+#   define BARE_PREFIX -2
+int repeat_count = NO_PREFIX;	/* Current command prefix. */
+
+int locate_mode = 0;			/* Currently between 2 ^Ls	*/
+CORD locate_string = CORD_EMPTY;	/* Current search string.	*/
+
+char * arg_file_name;
+
+#ifdef WIN32
+/* Change the current position to whatever is currently displayed at	*/
+/* the given SCREEN coordinates.					*/
+void set_position(int c, int l)
+{
+    line = l + dis_line;
+    col = c + dis_col;
+    fix_pos();
+    move_cursor(col - dis_col, line - dis_line);
+}
+#endif /* WIN32 */
+
+/* Perform the command associated with character c.  C may be an	*/
+/* integer > 256 denoting a windows command, one of the above control	*/
+/* characters, or another ASCII character to be used as either a 	*/
+/* character to be inserted, a repeat count, or a search string, 	*/
+/* depending on the current state.					*/
+void do_command(int c)
+{
+    int i;
+    int need_fix_pos;
+    FILE * out;
+    
+    if ( c == '\r') c = '\n';
+    if (locate_mode) {
+        size_t new_pos;
+          
+        if (c == LOCATE) {
+              locate_mode = 0;
+              locate_string = CORD_EMPTY;
+              return;
+        }
+        locate_string = CORD_cat_char(locate_string, (char)c);
+        new_pos = CORD_str(current, file_pos - CORD_len(locate_string) + 1,
+          		   locate_string);
+        if (new_pos != CORD_NOT_FOUND) {
+            need_redisplay = ALL;
+            new_pos += CORD_len(locate_string);
+            for (;;) {
+              	file_pos = line_pos(line + 1, 0);
+              	if (file_pos > new_pos) break;
+              	line++;
+            }
+            col = new_pos - line_pos(line, 0);
+            file_pos = new_pos;
+            fix_cursor();
+        } else {
+            locate_string = CORD_substr(locate_string, 0,
+              				CORD_len(locate_string) - 1);
+            beep();
+        }
+        return;
+    }
+    if (c == REPEAT) {
+      	repeat_count = BARE_PREFIX; return;
+    } else if (c < 0x100 && isdigit(c)){
+        if (repeat_count == BARE_PREFIX) {
+          repeat_count = c - '0'; return;
+        } else if (repeat_count != NO_PREFIX) {
+          repeat_count = 10 * repeat_count + c - '0'; return;
+        }
+    }
+    if (repeat_count == NO_PREFIX) repeat_count = 1;
+    if (repeat_count == BARE_PREFIX && (c == UP || c == DOWN)) {
+      	repeat_count = LINES - dis_granularity;
+    }
+    if (repeat_count == BARE_PREFIX) repeat_count = 8;
+    need_fix_pos = 0;
+    for (i = 0; i < repeat_count; i++) {
+        switch(c) {
+          case LOCATE:
+            locate_mode = 1;
+            break;
+          case TOP:
+            line = col = file_pos = 0;
+            break;
+     	  case UP:
+     	    if (line != 0) {
+     	        line--;
+     	        need_fix_pos = 1;
+     	    }
+     	    break;
+     	  case DOWN:
+     	    line++;
+     	    need_fix_pos = 1;
+     	    break;
+     	  case LEFT:
+     	    if (col != 0) {
+     	        col--; file_pos--;
+     	    }
+     	    break;
+     	  case RIGHT:
+     	    if (CORD_fetch(current, file_pos) == '\n') break;
+     	    col++; file_pos++;
+     	    break;
+     	  case UNDO:
+     	    del_hist();
+     	    need_redisplay = ALL; need_fix_pos = 1;
+     	    break;
+     	  case BS:
+     	    if (col == 0) {
+     	        beep();
+     	        break;
+     	    }
+     	    col--; file_pos--;
+     	    /* fall through: */
+     	  case DEL:
+     	    if (file_pos == current_len-1) break;
+     	    	/* Can't delete trailing newline */
+     	    if (CORD_fetch(current, file_pos) == '\n') {
+     	        need_redisplay = ALL; need_fix_pos = 1;
+     	    } else {
+     	        need_redisplay = line - dis_line;
+     	    }
+     	    add_hist(CORD_cat(
+     	    		CORD_substr(current, 0, file_pos),
+     	    		CORD_substr(current, file_pos+1, current_len)));
+     	    invalidate_map(line);
+     	    break;
+     	  case WRITE:
+	    {
+  		CORD name = CORD_cat(CORD_from_char_star(arg_file_name),
+				     ".new");
+
+    	        if ((out = fopen(CORD_to_const_char_star(name), "wb")) == NULL
+  	            || CORD_put(current, out) == EOF) {
+        	    de_error("Write failed\n");
+        	    need_redisplay = ALL;
+                } else {
+                    fclose(out);
+                }
+	    }
+            break;
+     	  default:
+     	    {
+     	        CORD left_part = CORD_substr(current, 0, file_pos);
+     	        CORD right_part = CORD_substr(current, file_pos, current_len);
+     	        
+     	        add_hist(CORD_cat(CORD_cat_char(left_part, (char)c),
+     	        		  right_part));
+     	        invalidate_map(line);
+     	        if (c == '\n') {
+     	            col = 0; line++; file_pos++;
+     	            need_redisplay = ALL;
+     	        } else {
+     	            col++; file_pos++;
+     	            need_redisplay = line - dis_line;
+     	    	}
+     	        break;
+     	    }
+        }
+    }
+    if (need_fix_pos) fix_pos();
+    fix_cursor();
+    repeat_count = NO_PREFIX;
+}
+
+/* OS independent initialization */
+
+void generic_init(void)
+{
+    FILE * f;
+    CORD initial;
+    
+    if ((f = fopen(arg_file_name, "rb")) == NULL) {
+     	initial = "\n";
+    } else {
+        initial = CORD_from_file(f);
+        if (initial == CORD_EMPTY
+            || CORD_fetch(initial, CORD_len(initial)-1) != '\n') {
+            initial = CORD_cat(initial, "\n");
+        }
+    }
+    add_map(0,0);
+    add_hist(initial);
+    now -> map = current_map;
+    now -> previous = now;  /* Can't back up further: beginning of the world */
+    need_redisplay = ALL;
+    fix_cursor();
+}
+
+#ifndef WIN32
+
+main(argc, argv)
+int argc;
+char ** argv;
+{
+    int c;
+    CORD initial;
+
+#if defined(MACINTOSH)
+	console_options.title = "\pDumb Editor";
+	cshow(stdout);
+	GC_init();
+	argc = ccommand(&argv);
+#endif
+    
+    if (argc != 2) goto usage;
+    arg_file_name = argv[1];
+    setvbuf(stdout, GC_MALLOC_ATOMIC(8192), _IOFBF, 8192);
+    initscr();
+    noecho(); nonl(); cbreak();
+    generic_init();
+    while ((c = getchar()) != QUIT) {
+		if (c == EOF) break;
+	    do_command(c);
+    }
+done:
+    move(LINES-1, 0);
+    clrtoeol();
+    refresh();
+    nl();
+    echo();
+    endwin();
+    exit(0);
+usage:
+    fprintf(stderr, "Usage: %s file\n", argv[0]);
+    fprintf(stderr, "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n");
+    fprintf(stderr, "Undo: ^U    Write to <file>.new: ^W");
+    fprintf(stderr, "Quit:^D  Repeat count: ^R[n]\n");
+    fprintf(stderr, "Top: ^T   Locate (search, find): ^L text ^L\n");
+    exit(1);
+}
+
+#endif  /* !WIN32 */
diff --git a/src/mzscheme/gc/cord/de_cmds.h b/src/mzscheme/gc/cord/de_cmds.h
new file mode 100644
index 0000000..f42ddcf
--- /dev/null
+++ b/src/mzscheme/gc/cord/de_cmds.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, May 19, 1994 2:24 pm PDT */
+
+#ifndef DE_CMDS_H
+
+# define DE_CMDS_H
+
+# define UP     16	/* ^P */
+# define DOWN   14	/* ^N */
+# define LEFT   2	/* ^B */
+# define RIGHT  6	/* ^F */
+# define DEL	127	/* ^? */
+# define BS     8	/* ^H */
+# define UNDO   21	/* ^U */
+# define WRITE  23	/* ^W */
+# define QUIT   4	/* ^D */
+# define REPEAT 18	/* ^R */
+# define LOCATE 12	/* ^L */
+# define TOP    20	/* ^T */
+
+#endif
+
diff --git a/src/mzscheme/gc/cord/de_win.ICO b/src/mzscheme/gc/cord/de_win.ICO
new file mode 100755
index 0000000..b20ac3e
Binary files /dev/null and b/src/mzscheme/gc/cord/de_win.ICO differ
diff --git a/src/mzscheme/gc/cord/de_win.RC b/src/mzscheme/gc/cord/de_win.RC
new file mode 100644
index 0000000..554a300
--- /dev/null
+++ b/src/mzscheme/gc/cord/de_win.RC
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to copy this garbage collector for any purpose,
+ * provided the above notices are retained on all copies.
+ */
+/* Boehm, May 13, 1994 9:50 am PDT */
+
+#include "windows.h"
+#include "de_cmds.h"
+#include "de_win.h"
+
+
+
+ABOUTBOX DIALOG 19, 21, 163, 47
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "About Demonstration Text Editor"
+BEGIN
+	ICON "DE", -1, 8, 8, 13, 13, WS_CHILD | WS_VISIBLE
+	LTEXT "Demonstration Text Editor", -1, 44, 8, 118, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+	LTEXT "Version 4.1", -1, 44, 16, 60, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
+	PUSHBUTTON "OK", IDOK, 118, 27, 24, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP
+END
+
+
+DE MENU 
+BEGIN
+	POPUP "&File"
+	BEGIN
+		MENUITEM "&Save\t^W", IDM_FILESAVE
+		MENUITEM "E&xit\t^D", IDM_FILEEXIT
+	END
+
+	POPUP "&Edit"
+	BEGIN
+	    MENUITEM "Page &Down\t^R^N", IDM_EDITPDOWN
+	    MENUITEM "Page &Up\t^R^P", IDM_EDITPUP
+		MENUITEM "U&ndo\t^U", IDM_EDITUNDO
+		MENUITEM "&Locate\t^L ... ^L", IDM_EDITLOCATE
+		MENUITEM "D&own\t^N", IDM_EDITDOWN
+	    MENUITEM "U&p\t^P", IDM_EDITUP
+	    MENUITEM "Le&ft\t^B", IDM_EDITLEFT
+	    MENUITEM "&Right\t^F", IDM_EDITRIGHT
+	    MENUITEM "Delete &Backward\tBS", IDM_EDITBS
+	    MENUITEM "Delete F&orward\tDEL", IDM_EDITDEL
+	    MENUITEM "&Top\t^T", IDM_EDITTOP
+	END
+	
+	POPUP "&Help"
+	BEGIN
+		MENUITEM "&Contents", IDM_HELPCONTENTS
+		MENUITEM "&About...", IDM_HELPABOUT
+	END
+	
+	MENUITEM "Page_&Down", IDM_EDITPDOWN
+	MENUITEM "Page_&Up", IDM_EDITPUP
+END
+
+
+DE ACCELERATORS 
+BEGIN
+    "^R", IDM_EDITREPEAT
+    "^N", IDM_EDITDOWN
+    "^P", IDM_EDITUP
+    "^L", IDM_EDITLOCATE
+    "^B", IDM_EDITLEFT
+    "^F", IDM_EDITRIGHT
+    "^T", IDM_EDITTOP
+	VK_DELETE, IDM_EDITDEL, VIRTKEY
+	VK_BACK, IDM_EDITBS, VIRTKEY
+END
+
+
+DE ICON cord\de_win.ICO
+
diff --git a/src/mzscheme/gc/cord/de_win.c b/src/mzscheme/gc/cord/de_win.c
new file mode 100644
index 0000000..119d0fa
--- /dev/null
+++ b/src/mzscheme/gc/cord/de_win.c
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 6, 1995 12:29 pm PST */
+
+/*
+ * The MS Windows specific part of de.  
+ * This started as the generic Windows application template
+ * made available by Rob Haack (rhaack@polaris.unm.edu), but
+ * significant parts didn't survive to the final version.
+ *
+ * This was written by a nonexpert windows programmer.
+ */
+
+
+#include "windows.h"
+#include "gc.h"
+#include "cord.h"
+#include "de_cmds.h"
+#include "de_win.h"
+
+int LINES = 0;
+int COLS = 0;
+
+char       szAppName[]     = "DE";
+char       FullAppName[]   = "Demonstration Editor";
+
+HWND        hwnd;
+
+void de_error(char *s)
+{
+    MessageBox( hwnd, (LPSTR) s,
+                (LPSTR) FullAppName,
+                MB_ICONINFORMATION | MB_OK );
+    InvalidateRect(hwnd, NULL, TRUE);
+}
+
+int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                      LPSTR command_line, int nCmdShow)
+{
+   MSG         msg;
+   WNDCLASS    wndclass;
+   HANDLE      hAccel;
+
+   if (!hPrevInstance)
+   {
+      wndclass.style          = CS_HREDRAW | CS_VREDRAW;
+      wndclass.lpfnWndProc    = WndProc;
+      wndclass.cbClsExtra     = 0;
+      wndclass.cbWndExtra     = DLGWINDOWEXTRA;
+      wndclass.hInstance      = hInstance;
+      wndclass.hIcon          = LoadIcon (hInstance, szAppName);
+      wndclass.hCursor        = LoadCursor (NULL, IDC_ARROW);
+      wndclass.hbrBackground  = GetStockObject(WHITE_BRUSH);
+      wndclass.lpszMenuName   = "DE";
+      wndclass.lpszClassName  = szAppName;
+
+      if (RegisterClass (&wndclass) == 0) {
+          char buf[50];
+   	
+   	  sprintf(buf, "RegisterClass: error code: 0x%X", GetLastError());
+   	  de_error(buf);
+   	  return(0);
+      }
+   }
+   
+   /* Empirically, the command line does not include the command name ...
+   if (command_line != 0) {
+       while (isspace(*command_line)) command_line++;
+       while (*command_line != 0 && !isspace(*command_line)) command_line++;
+       while (isspace(*command_line)) command_line++;
+   } */
+   
+   if (command_line == 0 || *command_line == 0) {
+        de_error("File name argument required");
+        return( 0 );
+   } else {
+        char *p = command_line;
+        
+        while (*p != 0 && !isspace(*p)) p++;
+   	arg_file_name = CORD_to_char_star(
+   			    CORD_substr(command_line, 0, p - command_line));
+   }
+
+   hwnd = CreateWindow (szAppName,
+   			FullAppName,
+   			WS_OVERLAPPEDWINDOW | WS_CAPTION, /* Window style */
+   			CW_USEDEFAULT, 0, /* default pos. */
+   			CW_USEDEFAULT, 0, /* default width, height */
+   			NULL,	/* No parent */
+   			NULL, 	/* Window class menu */
+   			hInstance, NULL);
+   if (hwnd == NULL) {
+   	char buf[50];
+   	
+   	sprintf(buf, "CreateWindow: error code: 0x%X", GetLastError());
+   	de_error(buf);
+   	return(0);
+   }
+
+   ShowWindow (hwnd, nCmdShow);
+
+   hAccel = LoadAccelerators( hInstance, szAppName );
+   
+   while (GetMessage (&msg, NULL, 0, 0))
+   {
+      if( !TranslateAccelerator( hwnd, hAccel, &msg ) )
+      {
+         TranslateMessage (&msg);
+         DispatchMessage (&msg);
+      }
+   }
+   return msg.wParam;
+}
+
+/* Return the argument with all control characters replaced by blanks.	*/
+char * plain_chars(char * text, size_t len)
+{
+    char * result = GC_MALLOC_ATOMIC(len + 1);
+    register size_t i;
+    
+    for (i = 0; i < len; i++) {
+       if (iscntrl(text[i])) {
+           result[i] = ' ';
+       } else {
+           result[i] = text[i];
+       }
+    }
+    result[len] = '\0';
+    return(result);
+}
+
+/* Return the argument with all non-control-characters replaced by 	*/
+/* blank, and all control characters c replaced by c + 32.		*/
+char * control_chars(char * text, size_t len)
+{
+    char * result = GC_MALLOC_ATOMIC(len + 1);
+    register size_t i;
+    
+    for (i = 0; i < len; i++) {
+       if (iscntrl(text[i])) {
+           result[i] = text[i] + 0x40;
+       } else {
+           result[i] = ' ';
+       }
+    }
+    result[len] = '\0';
+    return(result);
+}
+
+int char_width;
+int char_height;
+
+void get_line_rect(int line, int win_width, RECT * rectp)
+{
+    rectp -> top = line * char_height;
+    rectp -> bottom = rectp->top + char_height;
+    rectp -> left = 0;
+    rectp -> right = win_width;
+}
+
+int caret_visible = 0;	/* Caret is currently visible.	*/
+
+int screen_was_painted = 0;/* Screen has been painted at least once.	*/
+
+void update_cursor(void);
+
+LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
+                          WPARAM wParam, LPARAM lParam)
+{
+   static FARPROC lpfnAboutBox;
+   static HANDLE  hInstance;
+   HDC dc;
+   PAINTSTRUCT ps;
+   RECT client_area;
+   RECT this_line;
+   RECT dummy;
+   TEXTMETRIC tm;
+   register int i;
+   int id;
+
+   switch (message)
+   {
+      case WM_CREATE:
+           hInstance = ( (LPCREATESTRUCT) lParam)->hInstance;
+           lpfnAboutBox = MakeProcInstance( (FARPROC) AboutBox, hInstance );
+           dc = GetDC(hwnd);
+           SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT));
+           GetTextMetrics(dc, &tm);
+           ReleaseDC(hwnd, dc);
+           char_width = tm.tmAveCharWidth;
+           char_height = tm.tmHeight + tm.tmExternalLeading;
+           GetClientRect(hwnd, &client_area);
+      	   COLS = (client_area.right - client_area.left)/char_width;
+      	   LINES = (client_area.bottom - client_area.top)/char_height;
+      	   generic_init();
+           return(0);
+
+      case WM_CHAR:
+      	   if (wParam == QUIT) {
+      	       SendMessage( hwnd, WM_CLOSE, 0, 0L );
+      	   } else {
+      	       do_command(wParam);
+      	   }
+      	   return(0);
+      
+      case WM_SETFOCUS:
+      	   CreateCaret(hwnd, NULL, char_width, char_height);
+      	   ShowCaret(hwnd);
+      	   caret_visible = 1;
+      	   update_cursor();
+      	   return(0);
+      	   
+      case WM_KILLFOCUS:
+      	   HideCaret(hwnd);
+      	   DestroyCaret();
+      	   caret_visible = 0;
+      	   return(0);
+      	   
+      case WM_LBUTTONUP:
+      	   {
+      	       unsigned xpos = LOWORD(lParam);	/* From left	*/
+      	       unsigned ypos = HIWORD(lParam);	/* from top */
+      	       
+      	       set_position( xpos/char_width, ypos/char_height );
+      	       return(0);
+      	   }
+      	   
+      case WM_COMMAND:
+      	   id = LOWORD(wParam);
+      	   if (id & EDIT_CMD_FLAG) {
+               if (id & REPEAT_FLAG) do_command(REPEAT);
+               do_command(CHAR_CMD(id));
+               return( 0 );
+           } else {
+             switch(id) {
+               case IDM_FILEEXIT:
+                  SendMessage( hwnd, WM_CLOSE, 0, 0L );
+                  return( 0 );
+
+               case IDM_HELPABOUT:
+                  if( DialogBox( hInstance, "ABOUTBOX",
+                                 hwnd, lpfnAboutBox ) );
+                     InvalidateRect( hwnd, NULL, TRUE );
+                  return( 0 );
+	       case IDM_HELPCONTENTS:
+	     	  de_error(
+	     	       "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n"
+	     	       "Undo: ^U    Write: ^W   Quit:^D  Repeat count: ^R[n]\n"
+	     	       "Top: ^T   Locate (search, find): ^L text ^L\n");
+	     	  return( 0 );
+	     }
+	   }
+           break;
+
+      case WM_CLOSE:
+           DestroyWindow( hwnd );
+           return 0;
+
+      case WM_DESTROY:
+           PostQuitMessage (0);
+           return 0;
+      
+      case WM_PAINT:
+      	   dc = BeginPaint(hwnd, &ps);
+      	   GetClientRect(hwnd, &client_area);
+      	   COLS = (client_area.right - client_area.left)/char_width;
+      	   LINES = (client_area.bottom - client_area.top)/char_height;
+      	   SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT));
+      	   for (i = 0; i < LINES; i++) {
+      	       get_line_rect(i, client_area.right, &this_line);
+      	       if (IntersectRect(&dummy, &this_line, &ps.rcPaint)) {
+      	           CORD raw_line = retrieve_screen_line(i);
+      	           size_t len = CORD_len(raw_line);
+      	           char * text = CORD_to_char_star(raw_line);
+      	           		/* May contain embedded NULLs	*/
+      	           char * plain = plain_chars(text, len);
+      	           char * blanks = CORD_to_char_star(CORD_chars(' ',
+      	           				                COLS - len));
+      	           char * control = control_chars(text, len);
+#		   define RED RGB(255,0,0)
+      	           
+      	           SetBkMode(dc, OPAQUE);
+      	           SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
+      	           
+      	           TextOut(dc, this_line.left, this_line.top,
+      	           	   plain, len);
+      	           TextOut(dc, this_line.left + len * char_width, this_line.top,
+      	           	   blanks, COLS - len);
+      	           SetBkMode(dc, TRANSPARENT);
+      	           SetTextColor(dc, RED);
+      	           TextOut(dc, this_line.left, this_line.top,
+      	           	   control, strlen(control));
+      	       }
+      	   }
+      	   EndPaint(hwnd, &ps);
+      	   screen_was_painted = 1;
+      	   return 0;
+   }
+   return DefWindowProc (hwnd, message, wParam, lParam);
+}
+
+int last_col;
+int last_line;
+
+void move_cursor(int c, int l)
+{
+    last_col = c;
+    last_line = l;
+    
+    if (caret_visible) update_cursor();
+}
+
+void update_cursor(void)
+{
+    SetCaretPos(last_col * char_width, last_line * char_height);
+    ShowCaret(hwnd);
+}
+
+void invalidate_line(int i)
+{
+    RECT line;
+    
+    if (!screen_was_painted) return;
+    	/* Invalidating a rectangle before painting seems result in a	*/
+    	/* major performance problem.					*/
+    get_line_rect(i, COLS*char_width, &line);
+    InvalidateRect(hwnd, &line, FALSE);
+}
+
+LRESULT CALLBACK AboutBox( HWND hDlg, UINT message,
+                           WPARAM wParam, LPARAM lParam )
+{
+   switch( message )
+   {
+      case WM_INITDIALOG:
+           SetFocus( GetDlgItem( hDlg, IDOK ) );
+           break;
+
+      case WM_COMMAND:
+           switch( wParam )
+           {
+              case IDOK:
+                   EndDialog( hDlg, TRUE );
+                   break;
+           }
+           break;
+
+      case WM_CLOSE:
+           EndDialog( hDlg, TRUE );
+           return TRUE;
+
+   }
+   return FALSE;
+}
+
diff --git a/src/mzscheme/gc/cord/de_win.h b/src/mzscheme/gc/cord/de_win.h
new file mode 100644
index 0000000..57a47b4
--- /dev/null
+++ b/src/mzscheme/gc/cord/de_win.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, May 19, 1994 2:25 pm PDT */
+
+/* cord.h, de_cmds.h, and windows.h should be included before this. */
+
+
+# define OTHER_FLAG	0x100
+# define EDIT_CMD_FLAG	0x200
+# define REPEAT_FLAG	0x400
+
+# define CHAR_CMD(i) ((i) & 0xff)
+
+/* MENU: DE */
+#define IDM_FILESAVE		(EDIT_CMD_FLAG + WRITE)
+#define IDM_FILEEXIT		(OTHER_FLAG + 1)
+#define IDM_HELPABOUT		(OTHER_FLAG + 2)
+#define IDM_HELPCONTENTS	(OTHER_FLAG + 3)
+
+#define IDM_EDITPDOWN		(REPEAT_FLAG + EDIT_CMD_FLAG + DOWN)
+#define IDM_EDITPUP		(REPEAT_FLAG + EDIT_CMD_FLAG + UP)
+#define IDM_EDITUNDO		(EDIT_CMD_FLAG + UNDO)
+#define IDM_EDITLOCATE		(EDIT_CMD_FLAG + LOCATE)
+#define IDM_EDITDOWN		(EDIT_CMD_FLAG + DOWN)
+#define IDM_EDITUP		(EDIT_CMD_FLAG + UP)
+#define IDM_EDITLEFT		(EDIT_CMD_FLAG + LEFT)
+#define IDM_EDITRIGHT		(EDIT_CMD_FLAG + RIGHT)
+#define IDM_EDITBS		(EDIT_CMD_FLAG + BS)
+#define IDM_EDITDEL		(EDIT_CMD_FLAG + DEL)
+#define IDM_EDITREPEAT		(EDIT_CMD_FLAG + REPEAT)
+#define IDM_EDITTOP		(EDIT_CMD_FLAG + TOP)
+
+
+
+
+/* Windows UI stuff	*/
+
+LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
+			  UINT wParam, LONG lParam);
+
+LRESULT CALLBACK AboutBox( HWND hDlg, UINT message,
+			   UINT wParam, LONG lParam );
+
+
+/* Screen dimensions.  Maintained by de_win.c.	*/
+extern int LINES;
+extern int COLS;
+
+/* File being edited.	*/
+extern char * arg_file_name;
+
+/* Current display position in file.  Maintained by de.c	*/
+extern int dis_line;
+extern int dis_col;
+
+/* Current cursor position in file.				*/
+extern int line;
+extern int col;
+
+/*
+ *  Calls from de_win.c to de.c
+ */
+  
+CORD retrieve_screen_line(int i);
+			/* Get the contents of i'th screen line.	*/
+			/* Relies on COLS.				*/
+
+void set_position(int x, int y);
+			/* Set column, row.  Upper left of window = (0,0). */
+
+void do_command(int);
+			/* Execute an editor command.			*/
+			/* Agument is a command character or one	*/
+			/* of the IDM_ commands.			*/
+
+void generic_init(void);
+			/* OS independent initialization */
+
+
+/*
+ * Calls from de.c to de_win.c
+ */
+ 
+void move_cursor(int column, int line);
+			/* Physically move the cursor on the display,	*/
+			/* so that it appears at			*/
+			/* (column, line).				*/
+
+void invalidate_line(int line);
+			/* Invalidate line i on the screen.	*/
+
+void de_error(char *s);
+			/* Display error message.	*/
\ No newline at end of file
diff --git a/src/mzscheme/gc/cord/ec.h b/src/mzscheme/gc/cord/ec.h
new file mode 100644
index 0000000..c829b83
--- /dev/null
+++ b/src/mzscheme/gc/cord/ec.h
@@ -0,0 +1,70 @@
+# ifndef EC_H
+# define EC_H
+
+# ifndef CORD_H
+#  include "cord.h"
+# endif
+
+/* Extensible cords are strings that may be destructively appended to.	*/
+/* They allow fast construction of cords from characters that are	*/
+/* being read from a stream.						*/
+/*
+ * A client might look like:
+ *
+ *	{
+ *	    CORD_ec x;
+ *	    CORD result;
+ *	    char c;
+ *	    FILE *f;
+ *
+ *	    ...
+ *	    CORD_ec_init(x);
+ *	    while(...) {
+ *		c = getc(f);
+ *		...
+ *		CORD_ec_append(x, c);
+ *	    }
+ *	    result = CORD_balance(CORD_ec_to_cord(x));
+ *
+ * If a C string is desired as the final result, the call to CORD_balance
+ * may be replaced by a call to CORD_to_char_star.
+ */
+
+# ifndef CORD_BUFSZ
+#   define CORD_BUFSZ 128
+# endif
+
+typedef struct CORD_ec_struct {
+    CORD ec_cord;
+    char * ec_bufptr;
+    char ec_buf[CORD_BUFSZ+1];
+} CORD_ec[1];
+
+/* This structure represents the concatenation of ec_cord with		*/
+/* ec_buf[0 ... (ec_bufptr-ec_buf-1)]					*/
+
+/* Flush the buffer part of the extended chord into ec_cord.	*/
+/* Note that this is almost the only real function, and it is	*/
+/* implemented in 6 lines in cordxtra.c				*/
+void CORD_ec_flush_buf(CORD_ec x);
+      
+/* Convert an extensible cord to a cord. */
+# define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord)
+
+/* Initialize an extensible cord. */
+# define CORD_ec_init(x) ((x)[0].ec_cord = 0, (x)[0].ec_bufptr = (x)[0].ec_buf)
+
+/* Append a character to an extensible cord.	*/
+# define CORD_ec_append(x, c) \
+    {  \
+	if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
+	  	CORD_ec_flush_buf(x); \
+	} \
+	*((x)[0].ec_bufptr)++ = (c); \
+    }
+
+/* Append a cord to an extensible cord.  Structure remains shared with 	*/
+/* original.								*/
+void CORD_ec_append_cord(CORD_ec x, CORD s);
+
+# endif /* EC_H */
diff --git a/src/mzscheme/gc/cord/gc.h b/src/mzscheme/gc/cord/gc.h
new file mode 100644
index 0000000..16070cc
--- /dev/null
+++ b/src/mzscheme/gc/cord/gc.h
@@ -0,0 +1,647 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * Note that this defines a large number of tuning hooks, which can
+ * safely be ignored in nearly all cases.  For normal use it suffices
+ * to call only GC_MALLOC and perhaps GC_REALLOC.
+ * For better performance, also look at GC_MALLOC_ATOMIC, and
+ * GC_enable_incremental.  If you need an action to be performed
+ * immediately before an object is collected, look at GC_register_finalizer.
+ * If you are using Solaris threads, look at the end of this file.
+ * Everything else is best ignored unless you encounter performance
+ * problems.
+ */
+ 
+#ifndef _GC_H
+
+# define _GC_H
+# define __GC
+# include <stddef.h>
+
+
+#if defined(_MSC_VER) && defined(_DLL)
+#ifdef GC_BUILD
+#define GC_API __declspec(dllexport)
+#else
+#define GC_API __declspec(dllimport)
+#endif
+#endif
+
+#ifndef GC_API
+#define GC_API extern
+#endif
+
+# if defined(__STDC__) || defined(__cplusplus)
+#   define GC_PROTO(args) args
+    typedef void * GC_PTR;
+# else
+#   define GC_PROTO(args) ()
+    typedef char * GC_PTR;
+#  endif
+
+# ifdef __cplusplus
+    extern "C" {
+# endif
+
+
+/* Define word and signed_word to be unsigned and signed types of the 	*/
+/* size as char * or void *.  There seems to be no way to do this	*/
+/* even semi-portably.  The following is probably no better/worse 	*/
+/* than almost anything else.						*/
+/* The ANSI standard suggests that size_t and ptr_diff_t might be 	*/
+/* better choices.  But those appear to have incorrect definitions	*/
+/* on may systems.  Notably "typedef int size_t" seems to be both	*/
+/* frequent and WRONG.							*/
+typedef unsigned long GC_word;
+typedef long GC_signed_word;
+
+/* Public read-only variables */
+
+GC_API GC_word GC_gc_no;/* Counter incremented per collection.  	*/
+			/* Includes empty GCs at startup.		*/
+			
+
+/* Public R/W variables */
+
+GC_API void * (*GC_oom_fn) GC_PROTO((size_t bytes_requested));
+			/* When there is insufficient memory to satisfy */
+			/* an allocation request, we return		*/
+			/* (*GC_oom_fn)().  By default this just	*/
+			/* returns 0.					*/
+			/* If it returns, it must return 0 or a valid	*/
+			/* pointer to a previously allocated heap 	*/
+			/* object.					*/
+
+GC_API int GC_quiet;	/* Disable statistics output.  Only matters if	*/
+			/* collector has been compiled with statistics	*/
+			/* enabled.  This involves a performance cost,	*/
+			/* and is thus not the default.			*/
+
+GC_API int GC_dont_gc;	/* Dont collect unless explicitly requested, e.g. */
+			/* because it's not safe.			  */
+
+GC_API int GC_dont_expand;
+			/* Dont expand heap unless explicitly requested */
+			/* or forced to.				*/
+
+GC_API int GC_full_freq;    /* Number of partial collections between	*/
+			    /* full collections.  Matters only if	*/
+			    /* GC_incremental is set.			*/
+			
+GC_API GC_word GC_non_gc_bytes;
+			/* Bytes not considered candidates for collection. */
+			/* Used only to control scheduling of collections. */
+
+GC_API GC_word GC_free_space_divisor;
+			/* We try to make sure that we allocate at 	*/
+			/* least N/GC_free_space_divisor bytes between	*/
+			/* collections, where N is the heap size plus	*/
+			/* a rough estimate of the root set size.	*/
+			/* Initially, GC_free_space_divisor = 4.	*/
+			/* Increasing its value will use less space	*/
+			/* but more collection time.  Decreasing it	*/
+			/* will appreciably decrease collection time	*/
+			/* at the expense of space.			*/
+			/* GC_free_space_divisor = 1 will effectively	*/
+			/* disable collections.				*/
+
+GC_API GC_word GC_max_retries;
+			/* The maximum number of GCs attempted before	*/
+			/* reporting out of memory after heap		*/
+			/* expansion fails.  Initially 0.		*/
+			
+			
+/* Public procedures */
+/*
+ * general purpose allocation routines, with roughly malloc calling conv.
+ * The atomic versions promise that no relevant pointers are contained
+ * in the object.  The nonatomic versions guarantee that the new object
+ * is cleared.  GC_malloc_stubborn promises that no changes to the object
+ * will occur after GC_end_stubborn_change has been called on the
+ * result of GC_malloc_stubborn. GC_malloc_uncollectable allocates an object
+ * that is scanned for pointers to collectable objects, but is not itself
+ * collectable.  GC_malloc_uncollectable and GC_free called on the resulting
+ * object implicitly update GC_non_gc_bytes appropriately.
+ */
+GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes));
+
+/* The following is only defined if the library has been suitably	*/
+/* compiled:								*/
+GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
+
+/* Explicitly deallocate an object.  Dangerous if used incorrectly.     */
+/* Requires a pointer to the base of an object.				*/
+/* If the argument is stubborn, it should not be changeable when freed. */
+/* An object should not be enable for finalization when it is 		*/
+/* explicitly deallocated.						*/
+/* GC_free(0) is a no-op, as required by ANSI C for free.		*/
+GC_API void GC_free GC_PROTO((GC_PTR object_addr));
+
+/*
+ * Stubborn objects may be changed only if the collector is explicitly informed.
+ * The collector is implicitly informed of coming change when such
+ * an object is first allocated.  The following routines inform the
+ * collector that an object will no longer be changed, or that it will
+ * once again be changed.  Only nonNIL pointer stores into the object
+ * are considered to be changes.  The argument to GC_end_stubborn_change
+ * must be exacly the value returned by GC_malloc_stubborn or passed to
+ * GC_change_stubborn.  (In the second case it may be an interior pointer
+ * within 512 bytes of the beginning of the objects.)
+ * There is a performance penalty for allowing more than
+ * one stubborn object to be changed at once, but it is acceptable to
+ * do so.  The same applies to dropping stubborn objects that are still
+ * changeable.
+ */
+GC_API void GC_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
+
+/* Return a pointer to the base (lowest address) of an object given	*/
+/* a pointer to a location within the object.				*/
+/* Return 0 if displaced_pointer doesn't point to within a valid	*/
+/* object.								*/
+GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer));
+
+/* Given a pointer to the base of an object, return its size in bytes.	*/
+/* The returned size may be slightly larger than what was originally	*/
+/* requested.								*/
+GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
+
+/* For compatibility with C library.  This is occasionally faster than	*/
+/* a malloc followed by a bcopy.  But if you rely on that, either here	*/
+/* or with the standard C library, your code is broken.  In my		*/
+/* opinion, it shouldn't have been invented, but now we're stuck. -HB	*/
+/* The resulting object has the same kind as the original.		*/
+/* If the argument is stubborn, the result will have changes enabled.	*/
+/* It is an error to have changes enabled for the original object.	*/
+/* Follows ANSI comventions for NULL old_object.			*/
+GC_API GC_PTR GC_realloc GC_PROTO((GC_PTR old_object,
+				   size_t new_size_in_bytes));
+				   
+/* Explicitly increase the heap size.	*/
+/* Returns 0 on failure, 1 on success.  */
+GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes));
+
+/* Limit the heap size to n bytes.  Useful when you're debugging, 	*/
+/* especially on systems that don't handle running out of memory well.	*/
+/* n == 0 ==> unbounded.  This is the default.				*/
+GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
+
+/* Clear the set of root segments.  Wizards only. */
+GC_API void GC_clear_roots GC_PROTO((void));
+
+/* Add a root segment.  Wizards only. */
+GC_API void GC_add_roots GC_PROTO((char * low_address,
+				   char * high_address_plus_1));
+
+/* Add a displacement to the set of those considered valid by the	*/
+/* collector.  GC_register_displacement(n) means that if p was returned */
+/* by GC_malloc, then (char *)p + n will be considered to be a valid	*/
+/* pointer to n.  N must be small and less than the size of p.		*/
+/* (All pointers to the interior of objects from the stack are		*/
+/* considered valid in any case.  This applies to heap objects and	*/
+/* static data.)							*/
+/* Preferably, this should be called before any other GC procedures.	*/
+/* Calling it later adds to the probability of excess memory		*/
+/* retention.								*/
+/* This is a no-op if the collector was compiled with recognition of	*/
+/* arbitrary interior pointers enabled, which is now the default.	*/
+GC_API void GC_register_displacement GC_PROTO((GC_word n));
+
+/* The following version should be used if any debugging allocation is	*/
+/* being done.								*/
+GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
+
+/* Explicitly trigger a full, world-stop collection. 	*/
+GC_API void GC_gcollect GC_PROTO((void));
+
+/* Trigger a full world-stopped collection.  Abort the collection if 	*/
+/* and when stop_func returns a nonzero value.  Stop_func will be 	*/
+/* called frequently, and should be reasonably fast.  This works even	*/
+/* if virtual dirty bits, and hence incremental collection is not 	*/
+/* available for this architecture.  Collections can be aborted faster	*/
+/* than normal pause times for incremental collection.  However,	*/
+/* aborted collections do no useful work; the next collection needs	*/
+/* to start from the beginning.						*/
+typedef int (* GC_stop_func) GC_PROTO((void));
+GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func));
+
+/* Return the number of bytes in the heap.  Excludes collector private	*/
+/* data structures.  Includes empty blocks and fragmentation loss.	*/
+/* Includes some pages that were allocated but never written.		*/
+GC_API size_t GC_get_heap_size GC_PROTO((void));
+
+/* Return the number of bytes allocated since the last collection.	*/
+GC_API size_t GC_get_bytes_since_gc GC_PROTO((void));
+
+/* Enable incremental/generational collection.	*/
+/* Not advisable unless dirty bits are 		*/
+/* available or most heap objects are		*/
+/* pointerfree(atomic) or immutable.		*/
+/* Don't use in leak finding mode.		*/
+/* Ignored if GC_dont_gc is true.		*/
+GC_API void GC_enable_incremental GC_PROTO((void));
+
+/* Perform some garbage collection work, if appropriate.	*/
+/* Return 0 if there is no more work to be done.		*/
+/* Typically performs an amount of work corresponding roughly	*/
+/* to marking from one page.  May do more work if further	*/
+/* progress requires it, e.g. if incremental collection is	*/
+/* disabled.  It is reasonable to call this in a wait loop	*/
+/* until it returns 0.						*/
+GC_API int GC_collect_a_little GC_PROTO((void));
+
+/* Allocate an object of size lb bytes.  The client guarantees that	*/
+/* as long as the object is live, it will be referenced by a pointer	*/
+/* that points to somewhere within the first 256 bytes of the object.	*/
+/* (This should normally be declared volatile to prevent the compiler	*/
+/* from invalidating this assertion.)  This routine is only useful	*/
+/* if a large array is being allocated.  It reduces the chance of 	*/
+/* accidentally retaining such an array as a result of scanning an	*/
+/* integer that happens to be an address inside the array.  (Actually,	*/
+/* it reduces the chance of the allocator not finding space for such	*/
+/* an array, since it will try hard to avoid introducing such a false	*/
+/* reference.)  On a SunOS 4.X or MS Windows system this is recommended */
+/* for arrays likely to be larger than 100K or so.  For other systems,	*/
+/* or if the collector is not configured to recognize all interior	*/
+/* pointers, the threshold is normally much higher.			*/
+GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb));
+GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
+
+/* Debugging (annotated) allocation.  GC_gcollect will check 		*/
+/* objects allocated in this way for overwrites, etc.			*/
+GC_API GC_PTR GC_debug_malloc
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_atomic
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_uncollectable
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_stubborn
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr));
+GC_API GC_PTR GC_debug_realloc
+	GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes,
+  		  char * descr_string, int descr_int));
+  			 	 
+GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
+# ifdef GC_DEBUG
+#   define GC_MALLOC(sz) GC_debug_malloc(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \
+							__FILE__, __LINE__)
+#   define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, __FILE__, \
+							       __LINE__)
+#   define GC_FREE(p) GC_debug_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_debug_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_debug_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, __FILE__, \
+							       __LINE__)
+#   define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, GC_base(obj))
+#   define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n)
+# else
+#   define GC_MALLOC(sz) GC_malloc(sz)
+#   define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz)
+#   define GC_REALLOC(old, sz) GC_realloc(old, sz)
+#   define GC_FREE(p) GC_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz)
+#   define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, obj)
+#   define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n)
+# endif
+/* The following are included because they are often convenient, and	*/
+/* reduce the chance for a misspecifed size argument.  But calls may	*/
+/* expand to something syntactically incorrect if t is a complicated	*/
+/* type expression.  							*/
+# define GC_NEW(t) (t *)GC_MALLOC(sizeof (t))
+# define GC_NEW_ATOMIC(t) (t *)GC_MALLOC_ATOMIC(sizeof (t))
+# define GC_NEW_STUBBORN(t) (t *)GC_MALLOC_STUBBORN(sizeof (t))
+# define GC_NEW_UNCOLLECTABLE(t) (t *)GC_MALLOC_UNCOLLECTABLE(sizeof (t))
+
+/* Finalization.  Some of these primitives are grossly unsafe.		*/
+/* The idea is to make them both cheap, and sufficient to build		*/
+/* a safer layer, closer to PCedar finalization.			*/
+/* The interface represents my conclusions from a long discussion	*/
+/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, 		*/
+/* Christian Jacobi, and Russ Atkinson.  It's not perfect, and		*/
+/* probably nobody else agrees with it.	    Hans-J. Boehm  3/13/92	*/
+typedef void (*GC_finalization_proc)
+  	GC_PROTO((GC_PTR obj, GC_PTR client_data));
+
+GC_API void GC_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+	/* When obj is no longer accessible, invoke		*/
+	/* (*fn)(obj, cd).  If a and b are inaccessible, and	*/
+	/* a points to b (after disappearing links have been	*/
+	/* made to disappear), then only a will be		*/
+	/* finalized.  (If this does not create any new		*/
+	/* pointers to b, then b will be finalized after the	*/
+	/* next collection.)  Any finalizable object that	*/
+	/* is reachable from itself by following one or more	*/
+	/* pointers will not be finalized (or collected).	*/
+	/* Thus cycles involving finalizable objects should	*/
+	/* be avoided, or broken by disappearing links.		*/
+	/* All but the last finalizer registered for an object  */
+	/* is ignored.						*/
+	/* Finalization may be removed by passing 0 as fn.	*/
+	/* Finalizers are implicitly unregistered just before   */
+	/* they are invoked.					*/
+	/* The old finalizer and client data are stored in	*/
+	/* *ofn and *ocd.					*/ 
+	/* Fn is never invoked on an accessible object,		*/
+	/* provided hidden pointers are converted to real 	*/
+	/* pointers only if the allocation lock is held, and	*/
+	/* such conversions are not performed by finalization	*/
+	/* routines.						*/
+	/* If GC_register_finalizer is aborted as a result of	*/
+	/* a signal, the object may be left with no		*/
+	/* finalization, even if neither the old nor new	*/
+	/* finalizer were NULL.					*/
+	/* Obj should be the nonNULL starting address of an 	*/
+	/* object allocated by GC_malloc or friends.		*/
+	/* Note that any garbage collectable object referenced	*/
+	/* by cd will be considered accessible until the	*/
+	/* finalizer is invoked.				*/
+
+/* Another versions of the above follow.  It ignores		*/
+/* self-cycles, i.e. pointers from a finalizable object to	*/
+/* itself.  There is a stylistic argument that this is wrong,	*/
+/* but it's unavoidable for C++, since the compiler may		*/
+/* silently introduce these.  It's also benign in that specific	*/
+/* case.							*/
+GC_API void GC_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+
+/* The following routine may be used to break cycles between	*/
+/* finalizable objects, thus causing cyclic finalizable		*/
+/* objects to be finalized in the correct order.  Standard	*/
+/* use involves calling GC_register_disappearing_link(&p),	*/
+/* where p is a pointer that is not followed by finalization	*/
+/* code, and should not be considered in determining 		*/
+/* finalization order.						*/
+GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Link should point to a field of a heap allocated 	*/
+	/* object obj.  *link will be cleared when obj is	*/
+	/* found to be inaccessible.  This happens BEFORE any	*/
+	/* finalization code is invoked, and BEFORE any		*/
+	/* decisions about finalization order are made.		*/
+	/* This is useful in telling the finalizer that 	*/
+	/* some pointers are not essential for proper		*/
+	/* finalization.  This may avoid finalization cycles.	*/
+	/* Note that obj may be resurrected by another		*/
+	/* finalizer, and thus the clearing of *link may	*/
+	/* be visible to non-finalization code.  		*/
+	/* There's an argument that an arbitrary action should  */
+	/* be allowed here, instead of just clearing a pointer. */
+	/* But this causes problems if that action alters, or 	*/
+	/* examines connectivity.				*/
+	/* Returns 1 if link was already registered, 0		*/
+	/* otherwise.						*/
+	/* Only exists for backward compatibility.  See below:	*/
+	
+GC_API int GC_general_register_disappearing_link
+	GC_PROTO((GC_PTR * /* link */, GC_PTR obj));
+	/* A slight generalization of the above. *link is	*/
+	/* cleared when obj first becomes inaccessible.  This	*/
+	/* can be used to implement weak pointers easily and	*/
+	/* safely. Typically link will point to a location	*/
+	/* holding a disguised pointer to obj.  (A pointer 	*/
+	/* inside an "atomic" object is effectively  		*/
+	/* disguised.)   In this way soft			*/
+	/* pointers are broken before any object		*/
+	/* reachable from them are finalized.  Each link	*/
+	/* May be registered only once, i.e. with one obj	*/
+	/* value.  This was added after a long email discussion */
+	/* with John Ellis.					*/
+	/* Obj must be a pointer to the first word of an object */
+	/* we allocated.  It is unsafe to explicitly deallocate */
+	/* the object containing link.  Explicitly deallocating */
+	/* obj may or may not cause link to eventually be	*/
+	/* cleared.						*/
+GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Returns 0 if link was not actually registered.	*/
+	/* Undoes a registration by either of the above two	*/
+	/* routines.						*/
+
+/* Auxiliary fns to make finalization work correctly with displaced	*/
+/* pointers introduced by the debugging allocators.			*/
+GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data));
+GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data));
+
+/* GC_set_warn_proc can be used to redirect or filter warning messages.	*/
+/* p may not be a NULL pointer.						*/
+typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg));
+GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
+    /* Returns old warning procedure.	*/
+	
+/* The following is intended to be used by a higher level	*/
+/* (e.g. cedar-like) finalization facility.  It is expected	*/
+/* that finalization code will arrange for hidden pointers to	*/
+/* disappear.  Otherwise objects can be accessed after they	*/
+/* have been collected.						*/
+/* Note that putting pointers in atomic objects or in 		*/
+/* nonpointer slots of "typed" objects is equivalent to 	*/
+/* disguising them in this way, and may have other advantages.	*/
+# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS)
+    typedef GC_word GC_hidden_pointer;
+#   define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
+#   define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
+    /* Converting a hidden pointer to a real pointer requires verifying	*/
+    /* that the object still exists.  This involves acquiring the  	*/
+    /* allocator lock to avoid a race with the collector.		*/
+# endif /* I_HIDE_POINTERS */
+
+typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data));
+GC_API GC_PTR GC_call_with_alloc_lock
+        	GC_PROTO((GC_fn_type fn, GC_PTR client_data));
+
+/* Check that p and q point to the same object.  		*/
+/* Fail conspicuously if they don't.				*/
+/* Returns the first argument.  				*/
+/* Succeeds if neither p nor q points to the heap.		*/
+/* May succeed if both p and q point to between heap objects.	*/
+GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
+
+/* Checked pointer pre- and post- increment operations.  Note that	*/
+/* the second argument is in units of bytes, not multiples of the	*/
+/* object size.  This should either be invoked from a macro, or the	*/
+/* call should be automatically generated.				*/
+GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
+GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
+
+/* Check that p is visible						*/
+/* to the collector as a possibly pointer containing location.		*/
+/* If it isn't fail conspicuously.					*/
+/* Returns the argument in all cases.  May erroneously succeed		*/
+/* in hard cases.  (This is intended for debugging use with		*/
+/* untyped allocations.  The idea is that it should be possible, though	*/
+/* slow, to add such a call to all indirect pointer stores.)		*/
+/* Currently useless for multithreaded worlds.				*/
+GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
+
+/* Check that if p is a pointer to a heap page, then it points to	*/
+/* a valid displacement within a heap object.				*/
+/* Fail conspicuously if this property does not hold.			*/
+/* Uninteresting with ALL_INTERIOR_POINTERS.				*/
+/* Always returns its argument.						*/
+GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR	p));
+
+/* Safer, but slow, pointer addition.  Probably useful mainly with 	*/
+/* a preprocessor.  Useful only for heap pointers.			*/
+#ifdef GC_DEBUG
+#   define GC_PTR_ADD3(x, n, type_of_result) \
+	((type_of_result)GC_same_obj((x)+(n), (x)))
+#   define GC_PRE_INCR3(x, n, type_of_result) \
+	((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x))
+#   define GC_POST_INCR2(x, type_of_result) \
+	((type_of_result)GC_post_incr(&(x), sizeof(*x))
+#   ifdef __GNUC__
+#       define GC_PTR_ADD(x, n) \
+	    GC_PTR_ADD3(x, n, typeof(x))
+#   define GC_PRE_INCR(x, n) \
+	    GC_PRE_INCR3(x, n, typeof(x))
+#   define GC_POST_INCR(x, n) \
+	    GC_POST_INCR3(x, typeof(x))
+#   else
+	/* We can't do this right without typeof, which ANSI	*/
+	/* decided was not sufficiently useful.  Repeatedly	*/
+	/* mentioning the arguments seems too dangerous to be	*/
+	/* useful.  So does not casting the result.		*/
+#   	define GC_PTR_ADD(x, n) ((x)+(n))
+#   endif
+#else	/* !GC_DEBUG */
+#   define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n))
+#   define GC_PTR_ADD(x, n) ((x)+(n))
+#   define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n))
+#   define GC_PRE_INCR(x, n) ((x) += (n))
+#   define GC_POST_INCR2(x, n, type_of_result) ((x)++)
+#   define GC_POST_INCR(x, n) ((x)++)
+#endif
+
+/* Safer assignment of a pointer to a nonstack location.	*/
+#ifdef GC_DEBUG
+# ifdef __STDC__
+#   define GC_PTR_STORE(p, q) \
+	(*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# else
+#   define GC_PTR_STORE(p, q) \
+	(*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# endif
+#else /* !GC_DEBUG */
+#   define GC_PTR_STORE(p, q) *((p) = (q))
+#endif
+
+/* Fynctions called to report pointer checking errors */
+GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
+
+GC_API void (*GC_is_valid_displacement_print_proc)
+	GC_PROTO((GC_PTR p));
+
+GC_API void (*GC_is_visible_print_proc)
+	GC_PROTO((GC_PTR p));
+
+#ifdef SOLARIS_THREADS
+/* We need to intercept calls to many of the threads primitives, so 	*/
+/* that we can locate thread stacks and stop the world.			*/
+/* Note also that the collector cannot see thread specific data.	*/
+/* Thread specific data should generally consist of pointers to		*/
+/* uncollectable objects, which are deallocated using the destructor	*/
+/* facility in thr_keycreate.						*/
+# include <thread.h>
+# include <signal.h>
+  int GC_thr_create(void *stack_base, size_t stack_size,
+                    void *(*start_routine)(void *), void *arg, long flags,
+                    thread_t *new_thread);
+  int GC_thr_join(thread_t wait_for, thread_t *departed, void **status);
+  int GC_thr_suspend(thread_t target_thread);
+  int GC_thr_continue(thread_t target_thread);
+  void * GC_dlopen(const char *path, int mode);
+
+# define thr_create GC_thr_create
+# define thr_join GC_thr_join
+# define thr_suspend GC_thr_suspend
+# define thr_continue GC_thr_continue
+# define dlopen GC_dlopen
+
+# endif /* SOLARIS_THREADS */
+
+#ifdef IRIX_THREADS
+/* We treat these similarly. */
+# include <pthread.h>
+# include <signal.h>
+
+  int GC_pthread_create(pthread_t *new_thread,
+                        const pthread_attr_t *attr,
+		        void *(*start_routine)(void *), void *arg);
+  int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);
+  int GC_pthread_join(pthread_t thread, void **retval);
+
+# define pthread_create GC_pthread_create
+# define pthread_sigmask GC_pthread_sigmask
+# define pthread_join GC_pthread_join
+
+#endif /* IRIX_THREADS */
+
+#if defined(SOLARIS_THREADS) || defined(IRIX_THREADS)
+/* This returns a list of objects, linked through their first		*/
+/* word.  Its use can greatly reduce lock contention problems, since	*/
+/* the allocation lock can be acquired and released many fewer times.	*/
+GC_PTR GC_malloc_many(size_t lb);
+#define GC_NEXT(p) (*(GC_PTR *)(p)) 	/* Retrieve the next element	*/
+					/* in returned list.		*/
+
+#endif /* SOLARIS_THREADS */
+
+/*
+ * If you are planning on putting
+ * the collector in a SunOS 5 dynamic library, you need to call GC_INIT()
+ * from the statically loaded program section.
+ * This circumvents a Solaris 2.X (X<=4) linker bug.
+ */
+#if defined(sparc) || defined(__sparc)
+#   define GC_INIT() { extern end, etext; \
+		       GC_noop(&end, &etext); }
+#else
+#   define GC_INIT()
+#endif
+
+#ifdef __cplusplus
+    }  /* end of extern "C" */
+#endif
+
+#endif /* _GC_H */
diff --git a/src/mzscheme/gc/cord/private/cord_pos.h b/src/mzscheme/gc/cord/private/cord_pos.h
new file mode 100644
index 0000000..d2b24bb
--- /dev/null
+++ b/src/mzscheme/gc/cord/private/cord_pos.h
@@ -0,0 +1,118 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, May 19, 1994 2:23 pm PDT */
+# ifndef CORD_POSITION_H
+
+/* The representation of CORD_position.  This is private to the	*/
+/* implementation, but the size is known to clients.  Also	*/
+/* the implementation of some exported macros relies on it.	*/
+/* Don't use anything defined here and not in cord.h.		*/
+
+# define MAX_DEPTH 48
+	/* The maximum depth of a balanced cord + 1.		*/
+	/* We don't let cords get deeper than MAX_DEPTH.	*/
+
+struct CORD_pe {
+    CORD pe_cord;
+    size_t pe_start_pos;
+};
+
+/* A structure describing an entry on the path from the root 	*/
+/* to current position.						*/
+typedef struct CORD_Pos {
+    size_t cur_pos;
+    int path_len;
+#	define CORD_POS_INVALID (0x55555555)
+		/* path_len == INVALID <==> position invalid */
+    const char *cur_leaf;	/* Current leaf, if it is a string.	*/
+    				/* If the current leaf is a function,	*/
+    				/* then this may point to function_buf	*/
+    				/* containing the next few characters.	*/
+    				/* Always points to a valid string	*/
+    				/* containing the current character 	*/
+    				/* unless cur_end is 0.			*/
+    size_t cur_start;	/* Start position of cur_leaf	*/
+    size_t cur_end;	/* Ending position of cur_leaf	*/
+    			/* 0 if cur_leaf is invalid.	*/
+    struct CORD_pe path[MAX_DEPTH + 1];
+    	/* path[path_len] is the leaf corresponding to cur_pos	*/
+    	/* path[0].pe_cord is the cord we point to.		*/
+#   define FUNCTION_BUF_SZ 8
+    char function_buf[FUNCTION_BUF_SZ];	/* Space for next few chars	*/
+    					/* from function node.		*/
+} CORD_pos[1];
+
+/* Extract the cord from a position:	*/
+CORD CORD_pos_to_cord(CORD_pos p);
+	
+/* Extract the current index from a position:	*/
+size_t CORD_pos_to_index(CORD_pos p);
+	
+/* Fetch the character located at the given position:	*/
+char CORD_pos_fetch(CORD_pos p);
+	
+/* Initialize the position to refer to the give cord and index.	*/
+/* Note that this is the most expensive function on positions:	*/
+void CORD_set_pos(CORD_pos p, CORD x, size_t i);
+	
+/* Advance the position to the next character.	*/
+/* P must be initialized and valid.		*/
+/* Invalidates p if past end:			*/
+void CORD_next(CORD_pos p);
+
+/* Move the position to the preceding character.	*/
+/* P must be initialized and valid.			*/
+/* Invalidates p if past beginning:			*/
+void CORD_prev(CORD_pos p);
+	
+/* Is the position valid, i.e. inside the cord?		*/
+int CORD_pos_valid(CORD_pos p);
+
+char CORD__pos_fetch(CORD_pos);
+void CORD__next(CORD_pos);
+void CORD__prev(CORD_pos);
+
+#define CORD_pos_fetch(p)	\
+    (((p)[0].cur_end != 0)? \
+     	(p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
+     	: CORD__pos_fetch(p))
+
+#define CORD_next(p)	\
+    (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \
+    	(p)[0].cur_pos++ \
+    	: (CORD__next(p), 0))
+
+#define CORD_prev(p)	\
+    (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \
+    	(p)[0].cur_pos-- \
+    	: (CORD__prev(p), 0))
+
+#define CORD_pos_to_index(p) ((p)[0].cur_pos)
+
+#define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
+
+#define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
+
+/* Some grubby stuff for performance-critical friends:	*/
+#define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos))
+	/* Number of characters in cache.  <= 0 ==> none	*/
+
+#define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
+	/* Advance position by n characters	*/
+	/* 0 < n < CORD_pos_chars_left(p)	*/
+
+#define CORD_pos_cur_char_addr(p) \
+	(p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start)
+	/* address of current character in cache.	*/
+
+#endif
diff --git a/src/mzscheme/gc/dbg_mlc.c b/src/mzscheme/gc/dbg_mlc.c
new file mode 100644
index 0000000..cd6ad35
--- /dev/null
+++ b/src/mzscheme/gc/dbg_mlc.c
@@ -0,0 +1,565 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 9, 1995 1:16 pm PDT */
+# include "gc_priv.h"
+
+/* Do we want to and know how to save the call stack at the time of	*/
+/* an allocation?  How much space do we want to use in each object?	*/
+
+# define START_FLAG ((word)0xfedcedcb)
+# define END_FLAG ((word)0xbcdecdef)
+	/* Stored both one past the end of user object, and one before	*/
+	/* the end of the object as seen by the allocator.		*/
+
+
+/* Object header */
+typedef struct {
+    char * oh_string;		/* object descriptor string	*/
+    word oh_int;		/* object descriptor integers	*/
+#   ifdef SAVE_CALL_CHAIN
+      struct callinfo oh_ci[NFRAMES];
+#   endif
+    word oh_sz;			/* Original malloc arg.		*/
+    word oh_sf;			/* start flag */
+} oh;
+/* The size of the above structure is assumed not to dealign things,	*/
+/* and to be a multiple of the word length.				*/
+
+#define DEBUG_BYTES (sizeof (oh) + sizeof (word))
+#undef ROUNDED_UP_WORDS
+#define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1)
+
+
+#ifdef SAVE_CALL_CHAIN
+#   define ADD_CALL_CHAIN(base) GC_save_callers(((oh *)(base)) -> oh_ci)
+#   define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci)
+#else
+#   define ADD_CALL_CHAIN(base)
+#   define PRINT_CALL_CHAIN(base)
+#endif
+
+/* Check whether object with base pointer p has debugging info	*/ 
+/* p is assumed to point to a legitimate object in our part	*/
+/* of the heap.							*/
+bool GC_has_debug_info(p)
+ptr_t p;
+{
+    register oh * ohdr = (oh *)p;
+    register ptr_t body = (ptr_t)(ohdr + 1);
+    register word sz = GC_size((ptr_t) ohdr);
+    
+    if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body)
+        || sz < sizeof (oh)) {
+        return(FALSE);
+    }
+    if (ohdr -> oh_sz == sz) {
+    	/* Object may have had debug info, but has been deallocated	*/
+    	return(FALSE);
+    }
+    if (ohdr -> oh_sf == (START_FLAG ^ (word)body)) return(TRUE);
+    if (((word *)ohdr)[BYTES_TO_WORDS(sz)-1] == (END_FLAG ^ (word)body)) {
+        return(TRUE);
+    }
+    return(FALSE);
+}
+
+/* Store debugging info into p.  Return displaced pointer. */
+/* Assumes we don't hold allocation lock.		   */
+ptr_t GC_store_debug_info(p, sz, string, integer)
+register ptr_t p;	/* base pointer */
+word sz; 	/* bytes */
+char * string;
+word integer;
+{
+    register word * result = (word *)((oh *)p + 1);
+    DCL_LOCK_STATE;
+    
+    /* There is some argument that we should dissble signals here.	*/
+    /* But that's expensive.  And this way things should only appear	*/
+    /* inconsistent while we're in the handler.				*/
+    LOCK();
+    ((oh *)p) -> oh_string = string;
+    ((oh *)p) -> oh_int = integer;
+    ((oh *)p) -> oh_sz = sz;
+    ((oh *)p) -> oh_sf = START_FLAG ^ (word)result;
+    ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] =
+         result[ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result;
+    UNLOCK();
+    return((ptr_t)result);
+}
+
+/* Check the object with debugging info at p 		*/
+/* return NIL if it's OK.  Else return clobbered	*/
+/* address.						*/
+ptr_t GC_check_annotated_obj(ohdr)
+register oh * ohdr;
+{
+    register ptr_t body = (ptr_t)(ohdr + 1);
+    register word gc_sz = GC_size((ptr_t)ohdr);
+    if (ohdr -> oh_sz + DEBUG_BYTES > gc_sz) {
+        return((ptr_t)(&(ohdr -> oh_sz)));
+    }
+    if (ohdr -> oh_sf != (START_FLAG ^ (word)body)) {
+        return((ptr_t)(&(ohdr -> oh_sf)));
+    }
+    if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) {
+        return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1));
+    }
+    if (((word *)body)[ROUNDED_UP_WORDS(ohdr -> oh_sz)]
+        != (END_FLAG ^ (word)body)) {
+        return((ptr_t)((word *)body + ROUNDED_UP_WORDS(ohdr -> oh_sz)));
+    }
+    return(0);
+}
+
+void GC_print_obj(p)
+ptr_t p;
+{
+    register oh * ohdr = (oh *)GC_base(p);
+    
+    GC_err_printf1("0x%lx (", (unsigned long)ohdr + sizeof(oh));
+    GC_err_puts(ohdr -> oh_string);
+    GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
+        			      (unsigned long)(ohdr -> oh_sz));
+    PRINT_CALL_CHAIN(ohdr);
+}
+void GC_print_smashed_obj(p, clobbered_addr)
+ptr_t p, clobbered_addr;
+{
+    register oh * ohdr = (oh *)GC_base(p);
+    
+    GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr,
+    					        (unsigned long)p);
+    if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz))
+        || ohdr -> oh_string == 0) {
+        GC_err_printf1("<smashed>, appr. sz = %ld)\n",
+        	       GC_size((ptr_t)ohdr) - DEBUG_BYTES);
+    } else {
+        if (ohdr -> oh_string[0] == '\0') {
+            GC_err_puts("EMPTY(smashed?)");
+        } else {
+            GC_err_puts(ohdr -> oh_string);
+        }
+        GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
+        			          (unsigned long)(ohdr -> oh_sz));
+        PRINT_CALL_CHAIN(ohdr);
+    }
+}
+
+void GC_check_heap_proc();
+
+void GC_start_debugging()
+{
+    GC_check_heap = GC_check_heap_proc;
+    GC_debugging_started = TRUE;
+    GC_register_displacement((word)sizeof(oh));
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    void GC_debug_register_displacement(GC_word offset)
+# else
+    void GC_debug_register_displacement(offset) 
+    GC_word offset;
+# endif
+{
+    GC_register_displacement(offset);
+    GC_register_displacement((word)sizeof(oh) + offset);
+}
+
+# ifdef __STDC__
+    GC_PTR GC_debug_malloc(size_t lb, char * s, int i)
+# else
+    GC_PTR GC_debug_malloc(lb, s, i)
+    size_t lb;
+    char * s;
+    int i;
+# endif
+{
+    GC_PTR result = GC_malloc(lb + DEBUG_BYTES);
+    
+    if (result == 0) {
+        GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
+        	       (unsigned long) lb);
+        GC_err_puts(s);
+        GC_err_printf1(":%ld)\n", (unsigned long)i);
+        return(0);
+    }
+    if (!GC_debugging_started) {
+    	GC_start_debugging();
+    }
+    ADD_CALL_CHAIN(result);
+    return (GC_store_debug_info(result, (word)lb, s, (word)i));
+}
+
+#ifdef STUBBORN_ALLOC
+# ifdef __STDC__
+    GC_PTR GC_debug_malloc_stubborn(size_t lb, char * s, int i)
+# else
+    GC_PTR GC_debug_malloc_stubborn(lb, s, i)
+    size_t lb;
+    char * s;
+    int i;
+# endif
+{
+    GC_PTR result = GC_malloc_stubborn(lb + DEBUG_BYTES);
+    
+    if (result == 0) {
+        GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
+        	       (unsigned long) lb);
+        GC_err_puts(s);
+        GC_err_printf1(":%ld)\n", (unsigned long)i);
+        return(0);
+    }
+    if (!GC_debugging_started) {
+    	GC_start_debugging();
+    }
+    ADD_CALL_CHAIN(result);
+    return (GC_store_debug_info(result, (word)lb, s, (word)i));
+}
+
+void GC_debug_change_stubborn(p)
+GC_PTR p;
+{
+    register GC_PTR q = GC_base(p);
+    register hdr * hhdr;
+    
+    if (q == 0) {
+        GC_err_printf1("Bad argument: 0x%lx to GC_debug_change_stubborn\n",
+        	       (unsigned long) p);
+        ABORT("GC_debug_change_stubborn: bad arg");
+    }
+    hhdr = HDR(q);
+    if (hhdr -> hb_obj_kind != STUBBORN) {
+        GC_err_printf1("GC_debug_change_stubborn arg not stubborn: 0x%lx\n",
+        	       (unsigned long) p);
+        ABORT("GC_debug_change_stubborn: arg not stubborn");
+    }
+    GC_change_stubborn(q);
+}
+
+void GC_debug_end_stubborn_change(p)
+GC_PTR p;
+{
+    register GC_PTR q = GC_base(p);
+    register hdr * hhdr;
+    
+    if (q == 0) {
+        GC_err_printf1("Bad argument: 0x%lx to GC_debug_end_stubborn_change\n",
+        	       (unsigned long) p);
+        ABORT("GC_debug_end_stubborn_change: bad arg");
+    }
+    hhdr = HDR(q);
+    if (hhdr -> hb_obj_kind != STUBBORN) {
+        GC_err_printf1("debug_end_stubborn_change arg not stubborn: 0x%lx\n",
+        	       (unsigned long) p);
+        ABORT("GC_debug_end_stubborn_change: arg not stubborn");
+    }
+    GC_end_stubborn_change(q);
+}
+
+#endif /* STUBBORN_ALLOC */
+
+# ifdef __STDC__
+    GC_PTR GC_debug_malloc_atomic(size_t lb, char * s, int i)
+# else
+    GC_PTR GC_debug_malloc_atomic(lb, s, i)
+    size_t lb;
+    char * s;
+    int i;
+# endif
+{
+    GC_PTR result = GC_malloc_atomic(lb + DEBUG_BYTES);
+    
+    if (result == 0) {
+        GC_err_printf1("GC_debug_malloc_atomic(%ld) returning NIL (",
+        	      (unsigned long) lb);
+        GC_err_puts(s);
+        GC_err_printf1(":%ld)\n", (unsigned long)i);
+        return(0);
+    }
+    if (!GC_debugging_started) {
+        GC_start_debugging();
+    }
+    ADD_CALL_CHAIN(result);
+    return (GC_store_debug_info(result, (word)lb, s, (word)i));
+}
+
+# ifdef __STDC__
+    GC_PTR GC_debug_malloc_uncollectable(size_t lb, char * s, int i)
+# else
+    GC_PTR GC_debug_malloc_uncollectable(lb, s, i)
+    size_t lb;
+    char * s;
+    int i;
+# endif
+{
+    GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES);
+    
+    if (result == 0) {
+        GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (",
+        	      (unsigned long) lb);
+        GC_err_puts(s);
+        GC_err_printf1(":%ld)\n", (unsigned long)i);
+        return(0);
+    }
+    if (!GC_debugging_started) {
+        GC_start_debugging();
+    }
+    ADD_CALL_CHAIN(result);
+    return (GC_store_debug_info(result, (word)lb, s, (word)i));
+}
+
+
+# ifdef __STDC__
+    void GC_debug_free(GC_PTR p)
+# else
+    void GC_debug_free(p)
+    GC_PTR p;
+# endif
+{
+    register GC_PTR base = GC_base(p);
+    register ptr_t clobbered;
+    
+    if (base == 0) {
+        GC_err_printf1("Attempt to free invalid pointer %lx\n",
+        	       (unsigned long)p);
+        if (p != 0) ABORT("free(invalid pointer)");
+    }
+    if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
+        GC_err_printf1(
+        	  "GC_debug_free called on pointer %lx wo debugging info\n",
+        	  (unsigned long)p);
+    } else {
+      clobbered = GC_check_annotated_obj((oh *)base);
+      if (clobbered != 0) {
+        if (((oh *)base) -> oh_sz == GC_size(base)) {
+            GC_err_printf0(
+                  "GC_debug_free: found previously deallocated (?) object at ");
+        } else {
+            GC_err_printf0("GC_debug_free: found smashed object at ");
+        }
+        GC_print_smashed_obj(p, clobbered);
+      }
+      /* Invalidate size */
+      ((oh *)base) -> oh_sz = GC_size(base);
+    }
+#   ifdef FIND_LEAK
+        GC_free(base);
+#   else
+	{
+	    register hdr * hhdr = HDR(p);
+	    bool uncollectable = FALSE;
+
+	    if (hhdr ->  hb_obj_kind == UNCOLLECTABLE) {
+		uncollectable = TRUE;
+	    }
+#	    ifdef ATOMIC_UNCOLLECTABLE
+		if (hhdr ->  hb_obj_kind == AUNCOLLECTABLE) {
+		    uncollectable = TRUE;
+		}
+#	    endif
+	    if (uncollectable) GC_free(base);
+	}
+#   endif
+}
+
+# ifdef __STDC__
+    GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, char *s, int i)
+# else
+    GC_PTR GC_debug_realloc(p, lb, s, i)
+    GC_PTR p;
+    size_t lb;
+    char *s;
+    int i;
+# endif
+{
+    register GC_PTR base = GC_base(p);
+    register ptr_t clobbered;
+    register GC_PTR result = GC_debug_malloc(lb, s, i);
+    register size_t copy_sz = lb;
+    register size_t old_sz;
+    register hdr * hhdr;
+    
+    if (p == 0) return(GC_debug_malloc(lb, s, i));
+    if (base == 0) {
+        GC_err_printf1(
+              "Attempt to free invalid pointer %lx\n", (unsigned long)p);
+        ABORT("realloc(invalid pointer)");
+    }
+    if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
+        GC_err_printf1(
+        	"GC_debug_realloc called on pointer %lx wo debugging info\n",
+        	(unsigned long)p);
+        return(GC_realloc(p, lb));
+    }
+    hhdr = HDR(base);
+    switch (hhdr -> hb_obj_kind) {
+#    ifdef STUBBORN_ALLOC
+      case STUBBORN:
+        result = GC_debug_malloc_stubborn(lb, s, i);
+        break;
+#    endif
+      case NORMAL:
+        result = GC_debug_malloc(lb, s, i);
+        break;
+      case PTRFREE:
+        result = GC_debug_malloc_atomic(lb, s, i);
+        break;
+      case UNCOLLECTABLE:
+	result = GC_debug_malloc_uncollectable(lb, s, i);
+ 	break;
+      default:
+        GC_err_printf0("GC_debug_realloc: encountered bad kind\n");
+        ABORT("bad kind");
+    }
+    clobbered = GC_check_annotated_obj((oh *)base);
+    if (clobbered != 0) {
+        GC_err_printf0("GC_debug_realloc: found smashed object at ");
+        GC_print_smashed_obj(p, clobbered);
+    }
+    old_sz = ((oh *)base) -> oh_sz;
+    if (old_sz < copy_sz) copy_sz = old_sz;
+    if (result == 0) return(0);
+    BCOPY(p, result,  copy_sz);
+    return(result);
+}
+
+/* Check all marked objects in the given block for validity */
+/*ARGSUSED*/
+void GC_check_heap_block(hbp, dummy)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+word dummy;
+{
+    register struct hblkhdr * hhdr = HDR(hbp);
+    register word sz = hhdr -> hb_sz;
+    register int word_no;
+    register word *p, *plim;
+    
+    p = (word *)(hbp->hb_body);
+    word_no = HDR_WORDS;
+    plim = (word *)((((word)hbp) + HBLKSIZE)
+		   - WORDS_TO_BYTES(sz));
+
+    /* go through all words in block */
+	do {
+	    if( mark_bit_from_hdr(hhdr, word_no)
+	        && GC_has_debug_info((ptr_t)p)) {
+	        ptr_t clobbered = GC_check_annotated_obj((oh *)p);
+	        
+	        if (clobbered != 0) {
+	            GC_err_printf0(
+	                "GC_check_heap_block: found smashed object at ");
+        	    GC_print_smashed_obj((ptr_t)p, clobbered);
+	        }
+	    }
+	    word_no += sz;
+	    p += sz;
+	} while( p <= plim );
+}
+
+
+/* This assumes that all accessible objects are marked, and that	*/
+/* I hold the allocation lock.	Normally called by collector.		*/
+void GC_check_heap_proc()
+{
+#   ifndef SMALL_CONFIG
+	if (sizeof(oh) & (2 * sizeof(word) - 1) != 0) {
+	    ABORT("Alignment problem: object header has inappropriate size\n");
+	}
+#   endif
+    GC_apply_to_all_blocks(GC_check_heap_block, (word)0);
+}
+
+struct closure {
+    GC_finalization_proc cl_fn;
+    GC_PTR cl_data;
+};
+
+# ifdef __STDC__
+    void * GC_make_closure(GC_finalization_proc fn, void * data)
+# else
+    GC_PTR GC_make_closure(fn, data)
+    GC_finalization_proc fn;
+    GC_PTR data;
+# endif
+{
+    struct closure * result =
+    		(struct closure *) GC_malloc(sizeof (struct closure));
+    
+    result -> cl_fn = fn;
+    result -> cl_data = data;
+    return((GC_PTR)result);
+}
+
+# ifdef __STDC__
+    void GC_debug_invoke_finalizer(void * obj, void * data)
+# else
+    void GC_debug_invoke_finalizer(obj, data)
+    char * obj;
+    char * data;
+# endif
+{
+    register struct closure * cl = (struct closure *) data;
+    
+    (*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data);
+} 
+
+
+# ifdef __STDC__
+    void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn,
+    				     GC_PTR cd, GC_finalization_proc *ofn,
+				     GC_PTR *ocd)
+# else
+    void GC_debug_register_finalizer(obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc *ofn;
+    GC_PTR *ocd;
+# endif
+{
+    ptr_t base = GC_base(obj);
+    if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
+        GC_err_printf1(
+	    "GC_register_finalizer called with non-base-pointer 0x%lx\n",
+	    obj);
+    }
+    GC_register_finalizer(base, GC_debug_invoke_finalizer,
+    			  GC_make_closure(fn,cd), ofn, ocd);
+}
+
+# ifdef __STDC__
+    void GC_debug_register_finalizer_ignore_self
+    				    (GC_PTR obj, GC_finalization_proc fn,
+    				     GC_PTR cd, GC_finalization_proc *ofn,
+				     GC_PTR *ocd)
+# else
+    void GC_debug_register_finalizer_ignore_self
+    				    (obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc *ofn;
+    GC_PTR *ocd;
+# endif
+{
+    ptr_t base = GC_base(obj);
+    if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
+        GC_err_printf1(
+	    "GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n",
+	    obj);
+    }
+    GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer,
+    			  	      GC_make_closure(fn,cd), ofn, ocd);
+}
diff --git a/src/mzscheme/gc/dyn_load.c b/src/mzscheme/gc/dyn_load.c
new file mode 100644
index 0000000..0fbee5b
--- /dev/null
+++ b/src/mzscheme/gc/dyn_load.c
@@ -0,0 +1,750 @@
+/*
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Original author: Bill Janssen
+ * Heavily modified by Hans Boehm and others
+ */
+/* Boehm, September 21, 1995 5:57 pm PDT */
+
+/*
+ * This is incredibly OS specific code for tracking down data sections in
+ * dynamic libraries.  There appears to be no way of doing this quickly
+ * without groveling through undocumented data structures.  We would argue
+ * that this is a bug in the design of the dlopen interface.  THIS CODE
+ * MAY BREAK IN FUTURE OS RELEASES.  If this matters to you, don't hesitate
+ * to let your vendor know ...
+ *
+ * None of this is safe with dlclose and incremental collection.
+ * But then not much of anything is safe in the presence of dlclose.
+ */
+#ifndef MACOS
+#  include <sys/types.h>
+#endif
+#include "gc_priv.h"
+
+/* BTL: avoid circular redefinition of dlopen if SOLARIS_THREADS defined */
+# if defined(SOLARIS_THREADS) && defined(dlopen)
+    /* To support threads in Solaris, gc.h interposes on dlopen by       */
+    /* defining "dlopen" to be "GC_dlopen", which is implemented below.  */
+    /* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the   */
+    /* real system dlopen() in their implementation. We first remove     */
+    /* gc.h's dlopen definition and restore it later, after GC_dlopen(). */
+#   undef dlopen
+#   define GC_must_restore_redefined_dlopen
+# else
+#   undef GC_must_restore_redefined_dlopen
+# endif
+
+#if (defined(DYNAMIC_LOADING) || defined(MSWIN32)) && !defined(PCR)
+#if !defined(SUNOS4) && !defined(SUNOS5DL) && !defined(IRIX5) && !defined(MSWIN32) && !(defined(ALPHA) && defined(OSF1)) &&!defined(HP_PA) && (!defined(LINUX) && !defined(__ELF__))
+ --> We only know how to find data segments of dynamic libraries for the
+ --> above.  Additional SVR4 variants might not be too
+ --> hard to add.
+#endif
+
+#include <stdio.h>
+#ifdef SUNOS5DL
+#   include <sys/elf.h>
+#   include <dlfcn.h>
+#   include <link.h>
+#endif
+#ifdef SUNOS4
+#   include <dlfcn.h>
+#   include <link.h>
+#   include <a.out.h>
+  /* struct link_map field overrides */
+#   define l_next	lm_next
+#   define l_addr	lm_addr
+#   define l_name	lm_name
+#endif
+
+
+#ifdef SUNOS5DL
+
+#ifdef LINT
+    Elf32_Dyn _DYNAMIC;
+#endif
+
+static struct link_map *
+GC_FirstDLOpenedLinkMap()
+{
+    extern Elf32_Dyn _DYNAMIC;
+    Elf32_Dyn *dp;
+    struct r_debug *r;
+    static struct link_map * cachedResult = 0;
+    static Elf32_Dyn *dynStructureAddr = 0;
+    			/* BTL: added to avoid Solaris 5.3 ld.so _DYNAMIC bug */
+
+#   ifdef SUNOS53_SHARED_LIB
+	/* BTL: Avoid the Solaris 5.3 bug that _DYNAMIC isn't being set	*/
+	/* up properly in dynamically linked .so's. This means we have	*/
+	/* to use its value in the set of original object files loaded	*/
+	/* at program startup.						*/
+	if( dynStructureAddr == 0 ) {
+	  void* startupSyms = dlopen(0, RTLD_LAZY);
+	  dynStructureAddr = (Elf32_Dyn*)dlsym(startupSyms, "_DYNAMIC");
+		}
+#   else
+	dynStructureAddr = &_DYNAMIC;
+#   endif
+
+    if( dynStructureAddr == 0) {
+        return(0);
+    }
+    if( cachedResult == 0 ) {
+        int tag;
+        for( dp = ((Elf32_Dyn *)(&_DYNAMIC)); (tag = dp->d_tag) != 0; dp++ ) {
+            if( tag == DT_DEBUG ) {
+                struct link_map *lm
+                        = ((struct r_debug *)(dp->d_un.d_ptr))->r_map;
+                if( lm != 0 ) cachedResult = lm->l_next; /* might be NIL */
+                break;
+            }
+        }
+    }
+    return cachedResult;
+}
+
+#endif
+
+#ifdef SUNOS4
+
+#ifdef LINT
+    struct link_dynamic _DYNAMIC;
+#endif
+
+static struct link_map *
+GC_FirstDLOpenedLinkMap()
+{
+    extern struct link_dynamic _DYNAMIC;
+
+    if( &_DYNAMIC == 0) {
+        return(0);
+    }
+    return(_DYNAMIC.ld_un.ld_1->ld_loaded);
+}
+
+/* Return the address of the ld.so allocated common symbol	*/
+/* with the least address, or 0 if none.			*/
+static ptr_t GC_first_common()
+{
+    ptr_t result = 0;
+    extern struct link_dynamic _DYNAMIC;
+    struct rtc_symb * curr_symbol;
+    
+    if( &_DYNAMIC == 0) {
+        return(0);
+    }
+    curr_symbol = _DYNAMIC.ldd -> ldd_cp;
+    for (; curr_symbol != 0; curr_symbol = curr_symbol -> rtc_next) {
+        if (result == 0
+            || (ptr_t)(curr_symbol -> rtc_sp -> n_value) < result) {
+            result = (ptr_t)(curr_symbol -> rtc_sp -> n_value);
+        }
+    }
+    return(result);
+}
+
+#endif
+
+# if defined(SUNOS4) || defined(SUNOS5DL)
+/* Add dynamic library data sections to the root set.		*/
+# if !defined(PCR) && !defined(SOLARIS_THREADS) && defined(THREADS)
+#   ifndef SRC_M3
+	--> fix mutual exclusion with dlopen
+#   endif  /* We assume M3 programs don't call dlopen for now */
+# endif
+
+# ifdef SOLARIS_THREADS
+  /* Redefine dlopen to guarantee mutual exclusion with	*/
+  /* GC_register_dynamic_libraries.			*/
+  /* assumes that dlopen doesn't need to call GC_malloc	*/
+  /* and friends.					*/
+# include <thread.h>
+# include <synch.h>
+  
+void * GC_dlopen(const char *path, int mode)
+{
+    void * result;
+    
+    mutex_lock(&GC_allocate_ml);
+    result = dlopen(path, mode);
+    mutex_unlock(&GC_allocate_ml);
+    return(result);
+}
+# endif
+
+/* BTL: added to fix circular dlopen definition if SOLARIS_THREADS defined */
+# if defined(GC_must_restore_redefined_dlopen)
+#   define dlopen GC_dlopen
+# endif
+
+void GC_register_dynamic_libraries()
+{
+  /* MATTHEW: I have no idea why this crashes for me. Since there
+     are no collectable dynamic libraries in SunOS MzScheme/MrEd, 
+     I just punt for SunOS4. */
+#ifndef SUNOS4
+
+  struct link_map *lm = GC_FirstDLOpenedLinkMap();
+  
+  for (lm = GC_FirstDLOpenedLinkMap();
+       lm != (struct link_map *) 0;  lm = lm->l_next)
+    {
+#     ifdef SUNOS4
+	struct exec *e;
+	 
+        e = (struct exec *) lm->lm_addr;
+        GC_add_roots_inner(
+      		    ((char *) (N_DATOFF(*e) + lm->lm_addr)),
+		    ((char *) (N_BSSADDR(*e) + e->a_bss + lm->lm_addr)),
+		    TRUE);
+#     endif
+#     ifdef SUNOS5DL
+	Elf32_Ehdr * e;
+        Elf32_Phdr * p;
+        unsigned long offset;
+        char * start;
+        register int i;
+        
+	e = (Elf32_Ehdr *) lm->l_addr;
+        p = ((Elf32_Phdr *)(((char *)(e)) + e->e_phoff));
+        offset = ((unsigned long)(lm->l_addr));
+        for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
+          switch( p->p_type ) {
+            case PT_LOAD:
+              {
+                if( !(p->p_flags & PF_W) ) break;
+                start = ((char *)(p->p_vaddr)) + offset;
+                GC_add_roots_inner(
+                  start,
+                  start + p->p_memsz,
+                  TRUE
+                );
+              }
+              break;
+            default:
+              break;
+          }
+	}
+#     endif
+    }
+#   ifdef SUNOS4
+      {
+      	static ptr_t common_start = 0;
+      	ptr_t common_end;
+      	extern ptr_t GC_find_limit();
+      	
+      	if (common_start == 0) common_start = GC_first_common();
+      	if (common_start != 0) {
+      	    common_end = GC_find_limit(common_start, TRUE);
+      	    GC_add_roots_inner((char *)common_start, (char *)common_end, TRUE);
+      	}
+      }
+#   endif
+
+#endif /* MATTHEW */
+}
+
+# endif /* SUNOS */
+
+#if defined(LINUX) && defined(__ELF__)
+
+/* Dynamic loading code for Linux running ELF. Somewhat tested on
+ * Linux/x86, untested but hopefully should work on Linux/Alpha. 
+ * This code was derived from the Solaris/ELF support. Thanks to
+ * whatever kind soul wrote that.  - Patrick Bridges */
+
+#include <elf.h>
+#include <link.h>
+
+/* Newer versions of Linux/Alpha and Linux/x86 define this macro.  We
+ * define it for those older versions that don't.  */
+#  ifndef ElfW
+#   ifndef ELF_CLASS
+#    define ElfW(type) Elf32_##type
+#   else
+#    if ELF_CLASS == ELFCLASS32
+#      define ElfW(type) Elf32_##type
+#    else
+#      define ElfW(type) Elf64_##type
+#    endif
+#  endif
+#  endif
+
+static struct link_map *
+GC_FirstDLOpenedLinkMap()
+{
+    extern ElfW(Dyn) _DYNAMIC[];
+    ElfW(Dyn) *dp;
+    struct r_debug *r;
+    static struct link_map *cachedResult = 0;
+
+    if( cachedResult == 0 ) {
+        int tag;
+        for( dp = _DYNAMIC; (tag = dp->d_tag) != 0; dp++ ) {
+            if( tag == DT_DEBUG ) {
+                struct link_map *lm
+                        = ((struct r_debug *)(dp->d_un.d_ptr))->r_map;
+                if( lm != 0 ) cachedResult = lm->l_next; /* might be NIL */
+                break;
+            }
+        }
+    }
+    return cachedResult;
+}
+
+
+void GC_register_dynamic_libraries()
+{
+  struct link_map *lm = GC_FirstDLOpenedLinkMap();
+  
+
+  for (lm = GC_FirstDLOpenedLinkMap();
+       lm != (struct link_map *) 0;  lm = lm->l_next)
+    {
+	ElfW(Ehdr) * e;
+        ElfW(Phdr) * p;
+        unsigned long offset;
+        char * start;
+        register int i;
+        
+	e = (ElfW(Ehdr) *) lm->l_addr;
+        p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff));
+        offset = ((unsigned long)(lm->l_addr));
+        for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
+          switch( p->p_type ) {
+            case PT_LOAD:
+              {
+                if( !(p->p_flags & PF_W) ) break;
+                start = ((char *)(p->p_vaddr)) + offset;
+                GC_add_roots_inner(start, start + p->p_memsz, TRUE);
+              }
+              break;
+            default:
+              break;
+          }
+	}
+    }
+}
+
+#endif
+
+#ifdef IRIX5
+
+#include <sys/procfs.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <elf.h>
+#include <errno.h>
+
+extern void * GC_roots_present();
+
+extern ptr_t GC_scratch_last_end_ptr; /* End of GC_scratch_alloc arena	*/
+
+/* We use /proc to track down all parts of the address space that are	*/
+/* mapped by the process, and throw out regions we know we shouldn't	*/
+/* worry about.  This may also work under other SVR4 variants.		*/
+void GC_register_dynamic_libraries()
+{
+    static int fd = -1;
+    char buf[30];
+    static prmap_t * addr_map = 0;
+    static int current_sz = 0;	/* Number of records currently in addr_map */
+    static int needed_sz;	/* Required size of addr_map		*/
+    register int i;
+    register long flags;
+    register ptr_t start;
+    register ptr_t limit;
+    ptr_t heap_start = (ptr_t)HEAP_START;
+    ptr_t heap_end = heap_start;
+
+    if (fd < 0) {
+      sprintf(buf, "/proc/%d", getpid());
+      fd = open(buf, O_RDONLY);
+      if (fd < 0) {
+    	ABORT("/proc open failed");
+      }
+    }
+    if (ioctl(fd, PIOCNMAP, &needed_sz) < 0) {
+	GC_err_printf2("fd = %d, errno = %d\n", fd, errno);
+    	ABORT("/proc PIOCNMAP ioctl failed");
+    }
+    if (needed_sz >= current_sz) {
+        current_sz = needed_sz * 2 + 1;
+        		/* Expansion, plus room for 0 record */
+        addr_map = (prmap_t *)GC_scratch_alloc(current_sz * sizeof(prmap_t));
+    }
+    if (ioctl(fd, PIOCMAP, addr_map) < 0) {
+	GC_err_printf2("fd = %d, errno = %d\n", fd, errno);
+    	ABORT("/proc PIOCMAP ioctl failed");
+    };
+    if (GC_n_heap_sects > 0) {
+    	heap_end = GC_heap_sects[GC_n_heap_sects-1].hs_start
+    			+ GC_heap_sects[GC_n_heap_sects-1].hs_bytes;
+    	if (heap_end < GC_scratch_last_end_ptr) heap_end = GC_scratch_last_end_ptr; 
+    }
+    for (i = 0; i < needed_sz; i++) {
+        flags = addr_map[i].pr_mflags;
+        if ((flags & (MA_BREAK | MA_STACK | MA_PHYS)) != 0) goto irrelevant;
+        if ((flags & (MA_READ | MA_WRITE)) != (MA_READ | MA_WRITE))
+            goto irrelevant;
+          /* The latter test is empirically useless.  Other than the	*/
+          /* main data and stack segments, everything appears to be	*/
+          /* mapped readable, writable, executable, and shared(!!).	*/
+          /* This makes no sense to me.	- HB				*/
+        start = (ptr_t)(addr_map[i].pr_vaddr);
+        if (GC_roots_present(start)) goto irrelevant;
+        if (start < heap_end && start >= heap_start)
+        	goto irrelevant;
+        limit = start + addr_map[i].pr_size;
+	if (addr_map[i].pr_off == 0 && strncmp(start, ELFMAG, 4) == 0) {
+	    /* Discard text segments, i.e. 0-offset mappings against	*/
+	    /* executable files which appear to have ELF headers.	*/
+	    caddr_t arg;
+	    int obj;
+#	    define MAP_IRR_SZ 10
+	    static ptr_t map_irr[MAP_IRR_SZ];
+	    				/* Known irrelevant map entries	*/
+	    static int n_irr = 0;
+	    struct stat buf;
+	    register int i;
+	    
+	    for (i = 0; i < n_irr; i++) {
+	        if (map_irr[i] == start) goto irrelevant;
+	    }
+	    arg = (caddr_t)start;
+	    obj = ioctl(fd, PIOCOPENM, &arg);
+	    if (obj >= 0) {
+	        fstat(obj, &buf);
+	        close(obj);
+	        if ((buf.st_mode & 0111) != 0) {
+	            if (n_irr < MAP_IRR_SZ) {
+	                map_irr[n_irr++] = start;
+	            }
+	            goto irrelevant;
+	        }
+	    }
+	}
+        GC_add_roots_inner(start, limit, TRUE);
+      irrelevant: ;
+    }
+    /* Dont keep cached descriptor, for now.  Some kernels don't like us */
+    /* to keep a /proc file descriptor around during kill -9.		 */
+    	if (close(fd) < 0) ABORT("Couldnt close /proc file");
+	fd = -1;
+}
+
+#endif  /* IRIX5 */
+
+# ifdef MSWIN32
+
+# define WIN32_LEAN_AND_MEAN
+# define NOSERVICE
+# include <windows.h>
+# include <stdlib.h>
+
+  /* We traverse the entire address space and register all segments 	*/
+  /* that could possibly have been written to.				*/
+  DWORD GC_allocation_granularity;
+  
+  extern bool GC_is_heap_base (ptr_t p);
+
+# ifdef WIN32_THREADS
+    extern void GC_get_next_stack(char *start, char **lo, char **hi);
+# endif
+  
+  void GC_cond_add_roots(char *base, char * limit)
+  {
+    char dummy;
+    char * stack_top
+           = (char *) ((word)(&dummy) & ~(GC_allocation_granularity-1));
+    if (base == limit) return;
+#   ifdef WIN32_THREADS
+    {
+        char * curr_base = base;
+	char * next_stack_lo;
+	char * next_stack_hi;
+	
+	for(;;) {
+	    GC_get_next_stack(curr_base, &next_stack_lo, &next_stack_hi);
+	    if (next_stack_lo >= limit) break;
+	    GC_add_roots_inner(curr_base, next_stack_lo, TRUE);
+	    curr_base = next_stack_hi;
+	}
+	if (curr_base < limit) GC_add_roots_inner(curr_base, limit);
+    }
+#   else
+        if (limit > stack_top && base < GC_stackbottom) {
+    	    /* Part of the stack; ignore it. */
+    	    return;
+        }
+        GC_add_roots_inner(base, limit, TRUE);
+#   endif
+  }
+  
+  extern bool GC_win32s;
+  
+  void GC_register_dynamic_libraries()
+  {
+    MEMORY_BASIC_INFORMATION buf;
+    SYSTEM_INFO sysinfo;
+    DWORD result;
+    DWORD protect;
+    LPVOID p;
+    char * base;
+    char * limit, * new_limit;
+    
+    if (GC_win32s) return;
+    GetSystemInfo(&sysinfo);
+    base = limit = p = sysinfo.lpMinimumApplicationAddress;
+    GC_allocation_granularity = sysinfo.dwAllocationGranularity;
+    while (p < sysinfo.lpMaximumApplicationAddress) {
+        result = VirtualQuery(p, &buf, sizeof(buf));
+        if (result != sizeof(buf)) {
+            ABORT("Weird VirtualQuery result");
+        }
+        new_limit = (char *)p + buf.RegionSize;
+        protect = buf.Protect;
+        if (buf.State == MEM_COMMIT
+            && (protect == PAGE_EXECUTE_READWRITE
+                || protect == PAGE_READWRITE)
+            && !GC_is_heap_base(buf.AllocationBase)) {
+            if ((char *)p == limit) {
+                limit = new_limit;
+            } else {
+                GC_cond_add_roots(base, limit);
+                base = p;
+                limit = new_limit;
+            }
+        }
+        if (p > (LPVOID)new_limit /* overflow */) break;
+        p = (LPVOID)new_limit;
+    }
+    GC_cond_add_roots(base, limit);
+  }
+
+#endif /* MSWIN32 */
+
+#if defined(ALPHA) && defined(OSF1)
+
+#include <loader.h>
+
+void GC_register_dynamic_libraries()
+{
+  int status;
+  ldr_process_t mypid;
+
+  /* module */
+    ldr_module_t moduleid = LDR_NULL_MODULE;
+    ldr_module_info_t moduleinfo;
+    size_t moduleinfosize = sizeof(moduleinfo);
+    size_t modulereturnsize;    
+
+  /* region */
+    ldr_region_t region; 
+    ldr_region_info_t regioninfo;
+    size_t regioninfosize = sizeof(regioninfo);
+    size_t regionreturnsize;
+
+  /* Obtain id of this process */
+    mypid = ldr_my_process();
+  
+  /* For each module */
+    while (TRUE) {
+
+      /* Get the next (first) module */
+        status = ldr_next_module(mypid, &moduleid);
+
+      /* Any more modules? */
+        if (moduleid == LDR_NULL_MODULE)
+            break;    /* No more modules */
+
+      /* Check status AFTER checking moduleid because */
+      /* of a bug in the non-shared ldr_next_module stub */
+        if (status != 0 ) {
+            GC_printf1("dynamic_load: status = %ld\n", (long)status);
+            {
+                extern char *sys_errlist[];
+                extern int sys_nerr;
+                extern int errno;
+                if (errno <= sys_nerr) {
+                    GC_printf1("dynamic_load: %s\n", (long)sys_errlist[errno]);
+               } else {
+                    GC_printf1("dynamic_load: %d\n", (long)errno);
+                }
+        }
+            ABORT("ldr_next_module failed");
+         }
+
+      /* Get the module information */
+        status = ldr_inq_module(mypid, moduleid, &moduleinfo,
+                                moduleinfosize, &modulereturnsize); 
+        if (status != 0 )
+            ABORT("ldr_inq_module failed");
+
+      /* is module for the main program (i.e. nonshared portion)? */
+          if (moduleinfo.lmi_flags & LDR_MAIN)
+              continue;    /* skip the main module */
+
+#     ifdef VERBOSE
+          GC_printf("---Module---\n");
+          GC_printf("Module ID            = %16ld\n", moduleinfo.lmi_modid);
+          GC_printf("Count of regions     = %16d\n", moduleinfo.lmi_nregion);
+          GC_printf("flags for module     = %16lx\n", moduleinfo.lmi_flags); 
+          GC_printf("pathname of module   = \"%s\"\n", moduleinfo.lmi_name);
+#     endif
+
+      /* For each region in this module */
+        for (region = 0; region < moduleinfo.lmi_nregion; region++) {
+
+          /* Get the region information */
+            status = ldr_inq_region(mypid, moduleid, region, &regioninfo,
+                                    regioninfosize, &regionreturnsize);
+            if (status != 0 )
+                ABORT("ldr_inq_region failed");
+
+          /* only process writable (data) regions */
+            if (! (regioninfo.lri_prot & LDR_W))
+                continue;
+
+#         ifdef VERBOSE
+              GC_printf("--- Region ---\n");
+              GC_printf("Region number    = %16ld\n",
+              	        regioninfo.lri_region_no);
+              GC_printf("Protection flags = %016x\n",  regioninfo.lri_prot);
+              GC_printf("Virtual address  = %16p\n",   regioninfo.lri_vaddr);
+              GC_printf("Mapped address   = %16p\n",   regioninfo.lri_mapaddr);
+              GC_printf("Region size      = %16ld\n",  regioninfo.lri_size);
+              GC_printf("Region name      = \"%s\"\n", regioninfo.lri_name);
+#         endif
+
+          /* register region as a garbage collection root */
+            GC_add_roots_inner (
+                (char *)regioninfo.lri_mapaddr,
+                (char *)regioninfo.lri_mapaddr + regioninfo.lri_size,
+                TRUE);
+
+        }
+    }
+}
+#endif
+
+#if defined(HP_PA)
+
+#include <dl.h>
+
+#if 0
+/* MATTHEW: c89 needs this?: */
+#include <errno.h>
+#endif
+
+extern int errno;
+extern char *sys_errlist[];
+extern int sys_nerr;
+
+void GC_register_dynamic_libraries()
+{
+  int status;
+  int index = 1; /* Ordinal position in shared library search list */
+  struct shl_descriptor *shl_desc; /* Shared library info, see dl.h */
+
+  /* For each dynamic library loaded */
+    while (TRUE) {
+
+      /* Get info about next shared library */
+        status = shl_get(index, &shl_desc);
+
+      /* Check if this is the end of the list or if some error occured */
+        if (status != 0) {
+          if (errno == EINVAL) {
+              break; /* Moved past end of shared library list --> finished */
+          } else {
+              if (errno <= sys_nerr) {
+                    GC_printf1("dynamic_load: %s\n", (long) sys_errlist[errno]);
+              } else {
+                    GC_printf1("dynamic_load: %d\n", (long) errno);
+	      }
+              ABORT("shl_get failed");
+          }
+        }
+
+#     ifdef VERBOSE
+          GC_printf0("---Shared library---\n");
+          GC_printf1("\tfilename        = \"%s\"\n", shl_desc->filename);
+          GC_printf1("\tindex           = %d\n", index);
+          GC_printf1("\thandle          = %08x\n",
+					(unsigned long) shl_desc->handle);
+          GC_printf1("\ttext seg. start = %08x\n", shl_desc->tstart);
+          GC_printf1("\ttext seg. end   = %08x\n", shl_desc->tend);
+          GC_printf1("\tdata seg. start = %08x\n", shl_desc->dstart);
+          GC_printf1("\tdata seg. end   = %08x\n", shl_desc->dend);
+          GC_printf1("\tref. count      = %lu\n", shl_desc->ref_count);
+#     endif
+
+      /* register shared library's data segment as a garbage collection root */
+        GC_add_roots_inner((char *) shl_desc->dstart,
+			   (char *) shl_desc->dend, TRUE);
+
+        index++;
+    }
+}
+#endif /* HP_PA */
+
+
+#else /* !DYNAMIC_LOADING */
+
+#ifdef PCR
+
+#   include "il/PCR_IL.h"
+#   include "th/PCR_ThCtl.h"
+#   include "mm/PCR_MM.h"
+
+void GC_register_dynamic_libraries()
+{
+    /* Add new static data areas of dynamically loaded modules.	*/
+        {
+          PCR_IL_LoadedFile * p = PCR_IL_GetLastLoadedFile();
+          PCR_IL_LoadedSegment * q;
+          
+          /* Skip uncommited files */
+          while (p != NIL && !(p -> lf_commitPoint)) {
+              /* The loading of this file has not yet been committed	*/
+              /* Hence its description could be inconsistent.  		*/
+              /* Furthermore, it hasn't yet been run.  Hence its data	*/
+              /* segments can't possibly reference heap allocated	*/
+              /* objects.						*/
+              p = p -> lf_prev;
+          }
+          for (; p != NIL; p = p -> lf_prev) {
+            for (q = p -> lf_ls; q != NIL; q = q -> ls_next) {
+              if ((q -> ls_flags & PCR_IL_SegFlags_Traced_MASK)
+                  == PCR_IL_SegFlags_Traced_on) {
+                GC_add_roots_inner
+                	((char *)(q -> ls_addr), 
+                	 (char *)(q -> ls_addr) + q -> ls_bytes,
+                	 TRUE);
+              }
+            }
+          }
+        }
+}
+
+
+#else /* !PCR */
+
+void GC_register_dynamic_libraries(){}
+
+int GC_no_dynamic_loading;
+
+#endif /* !PCR */
+#endif /* !DYNAMIC_LOADING */
diff --git a/src/mzscheme/gc/finalize.c b/src/mzscheme/gc/finalize.c
new file mode 100644
index 0000000..187e51d
--- /dev/null
+++ b/src/mzscheme/gc/finalize.c
@@ -0,0 +1,920 @@
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1996 by Xerox Corporation.  All rights reserved.
+
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 1, 1996 1:19 pm PST */
+# define I_HIDE_POINTERS
+# include "gc_priv.h"
+# include "gc_mark.h"
+
+/* Type of mark procedure used for marking from finalizable object.	*/
+/* This procedure normally does not mark the object, only its		*/
+/* descendents.								*/
+typedef void finalization_mark_proc(/* ptr_t finalizable_obj_ptr */); 
+
+# define HASH3(addr,size,log_size) \
+    ((((word)(addr) >> 3) ^ ((word)(addr) >> (3+(log_size)))) \
+    & ((size) - 1))
+#define HASH2(addr,log_size) HASH3(addr, 1 << log_size, log_size)
+
+struct hash_chain_entry {
+    word hidden_key;
+    struct hash_chain_entry * next;
+};
+
+unsigned GC_finalization_failures = 0;
+	/* Number of finalization requests that failed for lack of memory. */
+
+/* MATTHEW: */
+void (*GC_custom_finalize)(void);
+
+static struct disappearing_link {
+    struct hash_chain_entry prolog;
+#   define dl_hidden_link prolog.hidden_key
+				/* Field to be cleared.		*/
+#   define dl_next(x) (struct disappearing_link *)((x) -> prolog.next)
+#   define dl_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
+
+    word dl_hidden_obj;		/* Pointer to object base	*/
+
+    /* MATTHEW: for restoring: */
+    word dl_value; /* old value when zeroed */
+    struct disappearing_link *restore_next;
+} **dl_head = 0;
+
+static signed_word log_dl_table_size = -1;
+			/* Binary log of				*/
+			/* current size of array pointed to by dl_head.	*/
+			/* -1 ==> size is 0.				*/
+
+word GC_dl_entries = 0;	/* Number of entries currently in disappearing	*/
+			/* link table.					*/
+
+static struct finalizable_object {
+    struct hash_chain_entry prolog;
+#   define fo_hidden_base prolog.hidden_key
+				/* Pointer to object base.	*/
+				/* No longer hidden once object */
+				/* is on finalize_now queue.	*/
+#   define fo_next(x) (struct finalizable_object *)((x) -> prolog.next)
+#   define fo_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
+    GC_finalization_proc fo_fn;	/* Finalizer.			*/
+    ptr_t fo_client_data;
+    word fo_object_size;	/* In bytes.			*/
+    finalization_mark_proc * fo_mark_proc;	/* Mark-through procedure */
+    int eager; /* MATTHEW: eager finalizers don't care about cycles */
+} **fo_head = 0;
+
+struct finalizable_object * GC_finalize_now = 0;
+	/* LIst of objects that should be finalized now.	*/
+
+static signed_word log_fo_table_size = -1;
+
+word GC_fo_entries = 0;
+
+# ifdef SRC_M3
+void GC_push_finalizer_structures()
+{
+    GC_push_all((ptr_t)(&dl_head), (ptr_t)(&dl_head) + sizeof(word));
+    GC_push_all((ptr_t)(&fo_head), (ptr_t)(&fo_head) + sizeof(word));
+}
+# endif
+
+/* Double the size of a hash table. *size_ptr is the log of its current	*/
+/* size.  May be a noop.						*/
+/* *table is a pointer to an array of hash headers.  If we succeed, we	*/
+/* update both *table and *log_size_ptr.				*/
+/* Lock is held.  Signals are disabled.					*/
+void GC_grow_table(table, log_size_ptr)
+struct hash_chain_entry ***table;
+signed_word * log_size_ptr;
+{
+    register word i;
+    register struct hash_chain_entry *p;
+    int log_old_size = *log_size_ptr;
+    register int log_new_size = log_old_size + 1;
+    word old_size = ((log_old_size == -1)? 0: (1 << log_old_size));
+    register word new_size = 1 << log_new_size;
+    struct hash_chain_entry **new_table = (struct hash_chain_entry **)
+    	GC_generic_malloc_inner_ignore_off_page(
+    		(size_t)new_size * sizeof(struct hash_chain_entry *), NORMAL);
+    
+    if (new_table == 0) {
+    	if (table == 0) {
+    	    ABORT("Insufficient space for initial table allocation");
+    	} else {
+    	    return;
+    	}
+    }
+    for (i = 0; i < old_size; i++) {
+      p = (*table)[i];
+      while (p != 0) {
+        register ptr_t real_key = (ptr_t)REVEAL_POINTER(p -> hidden_key);
+        register struct hash_chain_entry *next = p -> next;
+        register int new_hash = HASH3(real_key, new_size, log_new_size);
+        
+        p -> next = new_table[new_hash];
+        new_table[new_hash] = p;
+        p = next;
+      }
+    }
+    *log_size_ptr = log_new_size;
+    *table = new_table;
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    int GC_register_disappearing_link(GC_PTR * link)
+# else
+    int GC_register_disappearing_link(link)
+    GC_PTR * link;
+# endif
+{
+    ptr_t base;
+    
+    base = (ptr_t)GC_base((GC_PTR)link);
+    if (base == 0)
+    	ABORT("Bad arg to GC_register_disappearing_link");
+    return(GC_general_register_disappearing_link(link, base));
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    int GC_general_register_disappearing_link(GC_PTR * link,
+    					      GC_PTR obj)
+# else
+    int GC_general_register_disappearing_link(link, obj)
+    GC_PTR * link;
+    GC_PTR obj;
+# endif
+
+{
+    struct disappearing_link *curr_dl;
+    int index;
+    struct disappearing_link * new_dl;
+    DCL_LOCK_STATE;
+    
+#if 1
+    /* MATTHEW: If wxObjects are sometimes stack-allocated, 
+       MrEd needs this. Keeping it for now just-in-case, though
+       it should be eliminated in the future. */
+    if (!GC_base(link))
+      return 1;
+#endif
+
+    if ((word)link & (ALIGNMENT-1))
+    	ABORT("Bad arg to GC_general_register_disappearing_link");
+#   ifdef THREADS
+    	DISABLE_SIGNALS();
+    	LOCK();
+#   endif
+    if (log_dl_table_size == -1
+        || GC_dl_entries > ((word)1 << log_dl_table_size)) {
+#	ifndef THREADS
+	    DISABLE_SIGNALS();
+#	endif
+    	GC_grow_table((struct hash_chain_entry ***)(&dl_head),
+    		      &log_dl_table_size);
+#	ifdef PRINTSTATS
+	    GC_printf1("Grew dl table to %lu entries\n",
+	    		(unsigned long)(1 << log_dl_table_size));
+#	endif
+#	ifndef THREADS
+	    ENABLE_SIGNALS();
+#	endif
+    }
+    index = HASH2(link, log_dl_table_size);
+    curr_dl = dl_head[index];
+    for (curr_dl = dl_head[index]; curr_dl != 0; curr_dl = dl_next(curr_dl)) {
+        if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
+            curr_dl -> dl_hidden_obj = HIDE_POINTER(obj);
+#	    ifdef THREADS
+                UNLOCK();
+    	        ENABLE_SIGNALS();
+#	    endif
+            return(1);
+        }
+    }
+#   ifdef THREADS
+      new_dl = (struct disappearing_link *)
+    	GC_generic_malloc_inner(sizeof(struct disappearing_link),NORMAL);
+#   else
+      new_dl = (struct disappearing_link *)
+	GC_malloc(sizeof(struct disappearing_link));
+#   endif
+    if (new_dl != 0) {
+        new_dl -> dl_hidden_obj = HIDE_POINTER(obj);
+        new_dl -> dl_hidden_link = HIDE_POINTER(link);
+	new_dl -> dl_value = obj ? (word)0 : (word)1; /* MATTHEW: Set flag */
+        dl_set_next(new_dl, dl_head[index]);
+        dl_head[index] = new_dl;
+        GC_dl_entries++;
+    } else {
+        GC_finalization_failures++;
+    }
+#   ifdef THREADS
+        UNLOCK();
+        ENABLE_SIGNALS();
+#   endif
+    return(0);
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    int GC_unregister_disappearing_link(GC_PTR * link)
+# else
+    int GC_unregister_disappearing_link(link)
+    GC_PTR * link;
+# endif
+{
+    struct disappearing_link *curr_dl, *prev_dl;
+    int index;
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    index = HASH2(link, log_dl_table_size);
+    if (((unsigned long)link & (ALIGNMENT-1))) goto out;
+    prev_dl = 0; curr_dl = dl_head[index];
+    while (curr_dl != 0) {
+        if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
+            if (prev_dl == 0) {
+                dl_head[index] = dl_next(curr_dl);
+            } else {
+                dl_set_next(prev_dl, dl_next(curr_dl));
+            }
+            GC_dl_entries--;
+            UNLOCK();
+    	    ENABLE_SIGNALS();
+            GC_free((GC_PTR)curr_dl);
+            return(1);
+        }
+        prev_dl = curr_dl;
+        curr_dl = dl_next(curr_dl);
+    }
+out:
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return(0);
+}
+
+/* Possible finalization_marker procedures.  Note that mark stack	*/
+/* overflow is handled by the caller, and is not a disaster.		*/
+void GC_normal_finalize_mark_proc(p)
+ptr_t p;
+{
+    hdr * hhdr = HDR(p);
+    
+    PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top,
+	     &(GC_mark_stack[GC_mark_stack_size]));
+}
+
+/* This only pays very partial attention to the mark descriptor.	*/
+/* It does the right thing for normal and atomic objects, and treats	*/
+/* most others as normal.						*/
+void GC_ignore_self_finalize_mark_proc(p)
+ptr_t p;
+{
+    hdr * hhdr = HDR(p);
+    word descr = hhdr -> hb_descr;
+    ptr_t q, r;
+    ptr_t scan_limit;
+    ptr_t target_limit = p + WORDS_TO_BYTES(hhdr -> hb_sz) - 1;
+    
+    if ((descr & DS_TAGS) == DS_LENGTH) {
+       scan_limit = p + descr - sizeof(word);
+    } else {
+       scan_limit = target_limit + 1 - sizeof(word);
+    }
+    for (q = p; q <= scan_limit; q += ALIGNMENT) {
+    	r = *(ptr_t *)q;
+    	if (r < p || r > target_limit) {
+    	    GC_PUSH_ONE_HEAP((word)r);
+    	}
+    }
+}
+
+/*ARGSUSED*/
+void GC_null_finalize_mark_proc(p)
+ptr_t p;
+{
+}
+
+
+
+/* Register a finalization function.  See gc.h for details.	*/
+/* in the nonthreads case, we try to avoid disabling signals,	*/
+/* since it can be expensive.  Threads packages typically	*/
+/* make it cheaper.						*/
+void GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, mp, eager) /* MATTHEW: eager */
+GC_PTR obj;
+GC_finalization_proc fn;
+GC_PTR cd;
+GC_finalization_proc * ofn;
+GC_PTR * ocd;
+finalization_mark_proc * mp;
+int eager; /* MATTHEW */
+{
+    ptr_t base;
+    struct finalizable_object * curr_fo, * prev_fo;
+    int index;
+    struct finalizable_object *new_fo;
+    DCL_LOCK_STATE;
+
+#   ifdef THREADS
+	DISABLE_SIGNALS();
+	LOCK();
+#   endif
+    if (log_fo_table_size == -1
+        || GC_fo_entries > ((word)1 << log_fo_table_size)) {
+#	ifndef THREADS
+    	    DISABLE_SIGNALS();
+#	endif
+    	GC_grow_table((struct hash_chain_entry ***)(&fo_head),
+    		      &log_fo_table_size);
+#	ifdef PRINTSTATS
+	    GC_printf1("Grew fo table to %lu entries\n",
+	    		(unsigned long)(1 << log_fo_table_size));
+#	endif
+#	ifndef THREADS
+	    ENABLE_SIGNALS();
+#	endif
+    }
+    /* in the THREADS case signals are disabled and we hold allocation	*/
+    /* lock; otherwise neither is true.  Proceed carefully.		*/
+    base = (ptr_t)obj;
+    index = HASH2(base, log_fo_table_size);
+    prev_fo = 0; curr_fo = fo_head[index];
+    while (curr_fo != 0) {
+        if (curr_fo -> fo_hidden_base == HIDE_POINTER(base)) {
+            /* Interruption by a signal in the middle of this	*/
+            /* should be safe.  The client may see only *ocd	*/
+            /* updated, but we'll declare that to be his	*/
+            /* problem.						*/
+            if (ocd) *ocd = (GC_PTR) curr_fo -> fo_client_data;
+            if (ofn) *ofn = curr_fo -> fo_fn;
+            /* Delete the structure for base. */
+                if (prev_fo == 0) {
+                  fo_head[index] = fo_next(curr_fo);
+                } else {
+                  fo_set_next(prev_fo, fo_next(curr_fo));
+                }
+            if (fn == 0) {
+                GC_fo_entries--;
+                  /* May not happen if we get a signal.  But a high	*/
+                  /* estimate will only make the table larger than	*/
+                  /* necessary.						*/
+#		ifndef THREADS
+                  GC_free((GC_PTR)curr_fo);
+#		endif
+            } else {
+                curr_fo -> fo_fn = fn;
+                curr_fo -> fo_client_data = (ptr_t)cd;
+                curr_fo -> fo_mark_proc = mp;
+		curr_fo -> eager = eager; /* MATTHEW */
+		/* Reinsert it.  We deleted it first to maintain	*/
+		/* consistency in the event of a signal.		*/
+		if (prev_fo == 0) {
+                  fo_head[index] = curr_fo;
+                } else {
+                  fo_set_next(prev_fo, curr_fo);
+                }
+            }
+#	    ifdef THREADS
+                UNLOCK();
+    	    	ENABLE_SIGNALS();
+#	    endif
+            return;
+        }
+        prev_fo = curr_fo;
+        curr_fo = fo_next(curr_fo);
+    }
+    if (ofn) *ofn = 0;
+    if (ocd) *ocd = 0;
+    if (fn == 0) {
+
+      /* MATTHEW: */
+      /* If this item is already queued, de-queue it. */
+#if 1
+      if (GC_finalize_now) {
+	ptr_t real_ptr;
+	register struct finalizable_object * curr_fo, *prev_fo;
+	
+	prev_fo = NULL;
+	curr_fo = GC_finalize_now;
+	while (curr_fo != 0) {
+	  real_ptr = (ptr_t)(curr_fo -> fo_hidden_base);
+	  if (real_ptr == obj) {
+	    if (prev_fo)
+	      fo_set_next(prev_fo, fo_next(curr_fo));
+	    else
+	      GC_finalize_now = fo_next(curr_fo);
+	    GC_free((GC_PTR)curr_fo);
+	    break;
+	  }
+	  prev_fo = curr_fo;
+	  curr_fo = fo_next(curr_fo);
+	}
+      }
+#endif
+
+#	ifdef THREADS
+            UNLOCK();
+    	    ENABLE_SIGNALS();
+#	endif
+        return;
+    }
+#   ifdef THREADS
+      new_fo = (struct finalizable_object *)
+    	GC_generic_malloc_inner(sizeof(struct finalizable_object),NORMAL);
+#   else
+      new_fo = (struct finalizable_object *)
+	GC_malloc(sizeof(struct finalizable_object));
+#   endif
+    if (new_fo != 0) {
+        new_fo -> fo_hidden_base = (word)HIDE_POINTER(base);
+	new_fo -> fo_fn = fn;
+	new_fo -> fo_client_data = (ptr_t)cd;
+	new_fo -> fo_object_size = GC_size(base);
+	new_fo -> fo_mark_proc = mp;
+	new_fo -> eager = eager; /* MATTHEW */
+	fo_set_next(new_fo, fo_head[index]);
+	GC_fo_entries++;
+	fo_head[index] = new_fo;
+    } else {
+     	GC_finalization_failures++;
+    }
+#   ifdef THREADS
+        UNLOCK();
+    	ENABLE_SIGNALS();
+#   endif
+}
+
+# if defined(__STDC__)
+    void GC_register_finalizer(void * obj,
+			       GC_finalization_proc fn, void * cd,
+			       GC_finalization_proc *ofn, void ** ocd)
+# else
+    void GC_register_finalizer(obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc * ofn;
+    GC_PTR * ocd;
+# endif
+{
+    GC_register_finalizer_inner(obj, fn, cd, ofn,
+    				ocd, GC_normal_finalize_mark_proc, 
+				0); /* MATTHEW */
+}
+
+/* MATTHEW: eager finalizers */
+# if defined(__STDC__)
+    void GC_register_eager_finalizer(void * obj,
+			            GC_finalization_proc fn, void * cd,
+			            GC_finalization_proc *ofn, void ** ocd)
+# else
+    void GC_register_eager_finalizer(obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc * ofn;
+    GC_PTR * ocd;
+# endif
+{
+    GC_register_finalizer_inner(obj, fn, cd, ofn,
+    				ocd, GC_normal_finalize_mark_proc, 1);
+}
+
+# if defined(__STDC__)
+    void GC_register_finalizer_ignore_self(void * obj,
+			       GC_finalization_proc fn, void * cd,
+			       GC_finalization_proc *ofn, void ** ocd)
+# else
+    void GC_register_finalizer_ignore_self(obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc * ofn;
+    GC_PTR * ocd;
+# endif
+{
+    GC_register_finalizer_inner(obj, fn, cd, ofn,
+    				ocd, GC_ignore_self_finalize_mark_proc, 
+				0); /* MATTHEW */
+}
+
+# if defined(__STDC__)
+    void GC_register_finalizer_no_order(void * obj,
+			       GC_finalization_proc fn, void * cd,
+			       GC_finalization_proc *ofn, void ** ocd)
+# else
+    void GC_register_finalizer_no_order(obj, fn, cd, ofn, ocd)
+    GC_PTR obj;
+    GC_finalization_proc fn;
+    GC_PTR cd;
+    GC_finalization_proc * ofn;
+    GC_PTR * ocd;
+# endif
+{
+    GC_register_finalizer_inner(obj, fn, cd, ofn,
+    				ocd, GC_null_finalize_mark_proc, 
+				0); /* MATTHEW */
+}
+
+
+/* Called with world stopped.  Cause disappearing links to disappear,	*/
+/* and invoke finalizers.						*/
+void GC_finalize()
+{
+    struct disappearing_link * curr_dl, * prev_dl, * next_dl;
+    struct finalizable_object * curr_fo, * prev_fo, * next_fo;
+    struct finalizable_object * end_eager_mark; /* MATTHEW */
+    ptr_t real_ptr, real_link;
+    register int i;
+    int dl_size = (log_dl_table_size == -1 ) ? 0 : (1 << log_dl_table_size);
+    int fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
+    /* MATTHEW: for resetting the disapearing link */
+    struct disappearing_link *done_dl = NULL, *last_done_dl = NULL;
+
+  /* Make disappearing links disappear */
+    /* MATTHEW: handle NULL real_link and remember old values */
+    for (i = 0; i < dl_size; i++) {
+      curr_dl = dl_head[i];
+      prev_dl = 0;
+      while (curr_dl != 0) {
+	/* MATTHEW: reorder and set real_ptr based on real_link: */
+        real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
+        real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj);
+	if (!real_ptr)
+	  real_ptr = (ptr_t)GC_base(*(GC_PTR *)real_link);
+	/* MATTHEW: keep the dl entry if dl_value: */
+        if (real_ptr && !GC_is_marked(real_ptr)) {
+	  if (curr_dl->dl_value)
+  	    curr_dl->dl_value = *(word *)real_link;
+	  *(word *)real_link = 0;
+
+	  next_dl = dl_next(curr_dl);
+
+          if (curr_dl->dl_value) {
+	    if (!last_done_dl)
+	      done_dl = curr_dl;
+	    else
+	      last_done_dl->restore_next = curr_dl;
+	    last_done_dl = curr_dl;
+	  } else {
+	    if (prev_dl == 0)
+	      dl_head[i] = next_dl;
+	    else
+	      dl_set_next(prev_dl, next_dl);
+
+	    GC_clear_mark_bit((ptr_t)curr_dl);
+ 	    GC_dl_entries--;
+	  }
+	  curr_dl = next_dl;
+	} else {
+            prev_dl = curr_dl;
+            curr_dl = dl_next(curr_dl);
+        }
+      }
+    }
+
+    /* MATTHEW: set NULL terminator: */
+    if (last_done_dl)
+      last_done_dl->restore_next = NULL;
+
+  /* MATTHEW: All eagers first [cut-n-paste: yuck] */
+  /* Enqueue for finalization all EAGER objects that are still		*/
+  /* unreachable.							*/
+    GC_words_finalized = 0;
+    end_eager_mark = GC_finalize_now; /* MATTHEW */
+    for (i = 0; i < fo_size; i++) {
+      curr_fo = fo_head[i];
+      prev_fo = 0;
+      while (curr_fo != 0) {
+	if (curr_fo -> eager) {
+	  real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
+	  if (!GC_is_marked(real_ptr)) {
+	    /* We assume that (non-eager) finalization orders do not
+	       need to take into account connections through memory
+	       with eager finalizations. Otherwise, this mark bit
+	       could break the chain from one (non-eager) finalizeable
+	       to another. */
+            GC_set_mark_bit(real_ptr);
+
+            /* Delete from hash table */
+	    next_fo = fo_next(curr_fo);
+	    if (prev_fo == 0) {
+	      fo_head[i] = next_fo;
+	    } else {
+	      fo_set_next(prev_fo, next_fo);
+	    }
+	    GC_fo_entries--;
+            /* Add to list of objects awaiting finalization.	*/
+	    fo_set_next(curr_fo, GC_finalize_now);
+	    GC_finalize_now = curr_fo;
+	    /* unhide object pointer so any future collections will	*/
+	    /* see it.						*/
+	    curr_fo -> fo_hidden_base = 
+	      (word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
+	    GC_words_finalized +=
+	      ALIGNED_WORDS(curr_fo -> fo_object_size)
+	      + ALIGNED_WORDS(sizeof(struct finalizable_object));
+#	    ifdef PRINTSTATS
+	    if (!GC_is_marked((ptr_t)curr_fo)) {
+	      ABORT("GC_finalize: found accessible unmarked object\n");
+	    }
+#	    endif
+            curr_fo = next_fo;
+	  } else {
+            prev_fo = curr_fo;
+            curr_fo = fo_next(curr_fo);
+	  }
+	} else {
+	  prev_fo = curr_fo;
+	  curr_fo = fo_next(curr_fo);
+	}
+      }
+    }
+
+
+  /* Mark all objects reachable via chains of 1 or more pointers	*/
+  /* from finalizable objects.						*/
+  /* MATTHEW: non-eager finalizations only (eagers already marked) */
+#   ifdef PRINTSTATS
+        if (GC_mark_state != MS_NONE) ABORT("Bad mark state");
+#   endif
+    for (i = 0; i < fo_size; i++) {
+      for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
+	if (!(curr_fo -> eager)) { /* MATTHEW */
+	  real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
+	  if (!GC_is_marked(real_ptr)) {
+            (*(curr_fo -> fo_mark_proc))(real_ptr);
+            while (!GC_mark_stack_empty()) GC_mark_from_mark_stack();
+            if (GC_mark_state != MS_NONE) {
+	      /* Mark stack overflowed. Very unlikely. */
+#		ifdef PRINTSTATS
+	      if (GC_mark_state != MS_INVALID) ABORT("Bad mark state");
+	      GC_printf0("Mark stack overflowed in finalization!!\n");
+#		endif
+	      /* Make mark bits consistent again.  Forget about	*/
+	      /* finalizing this object for now.			*/
+	      GC_set_mark_bit(real_ptr);
+	      while (!GC_mark_some());
+            }
+#if 0
+            if (GC_is_marked(real_ptr)) {
+	      /* MATTHEW: we have some ok cycles (below a parent) */
+	      printf("Finalization cycle involving %lx\n", real_ptr);
+            }
+#endif
+	  }
+	}
+      }
+    }
+  /* Enqueue for finalization all objects that are still		*/
+  /* unreachable.							*/
+    /* GC_words_finalized = 0; */ /* MATTHEW: done above */
+    for (i = 0; i < fo_size; i++) {
+      curr_fo = fo_head[i];
+      prev_fo = 0;
+      while (curr_fo != 0) {
+        real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
+        if (!GC_is_marked(real_ptr)) {
+            GC_set_mark_bit(real_ptr);
+
+            /* Delete from hash table */
+              next_fo = fo_next(curr_fo);
+              if (prev_fo == 0) {
+                fo_head[i] = next_fo;
+              } else {
+                fo_set_next(prev_fo, next_fo);
+              }
+              GC_fo_entries--;
+            /* Add to list of objects awaiting finalization.	*/
+              fo_set_next(curr_fo, GC_finalize_now);
+              GC_finalize_now = curr_fo;
+              /* unhide object pointer so any future collections will	*/
+              /* see it.						*/
+              curr_fo -> fo_hidden_base = 
+              		(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
+              GC_words_finalized +=
+                 	ALIGNED_WORDS(curr_fo -> fo_object_size)
+              		+ ALIGNED_WORDS(sizeof(struct finalizable_object));
+#	    ifdef PRINTSTATS
+              if (!GC_is_marked((ptr_t)curr_fo)) {
+                ABORT("GC_finalize: found accessible unmarked object\n");
+              }
+#	    endif
+            curr_fo = next_fo;
+        } else {
+            prev_fo = curr_fo;
+            curr_fo = fo_next(curr_fo);
+        }
+      }
+    }
+
+    /* MATTHEW: Mark from queued eagers: */
+    for (curr_fo = GC_finalize_now; curr_fo != end_eager_mark; curr_fo = fo_next(curr_fo)) {
+      /* MATTHEW: if this is an eager finalization, then objects
+	 accessible from real_ptr need to be marked */
+      if (curr_fo -> eager) {
+	(*(curr_fo -> fo_mark_proc))(curr_fo -> fo_hidden_base);
+	while (!GC_mark_stack_empty()) GC_mark_from_mark_stack();
+	if (GC_mark_state != MS_NONE) {
+	  /* Mark stack overflowed. Very unlikely. 
+	     Everything's ok, though. Just mark from scratch. */
+	  while (!GC_mark_some());
+	}
+      }
+    }
+
+    /* MATTHEW: Restore disappeared links. */
+    curr_dl = done_dl;
+    while (curr_dl != 0) {
+      real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
+      *(word *)real_link = curr_dl->dl_value;
+      curr_dl->dl_value = (word)1;
+      prev_dl = curr_dl;
+      curr_dl = curr_dl->restore_next;
+      prev_dl->restore_next = NULL;
+    }
+
+    /* Remove dangling disappearing links. */
+    for (i = 0; i < dl_size; i++) {
+      curr_dl = dl_head[i];
+      prev_dl = 0;
+      while (curr_dl != 0) {
+        real_link = GC_base((ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link));
+        if (real_link != 0 && !GC_is_marked(real_link)) {
+            next_dl = dl_next(curr_dl);
+            if (prev_dl == 0) {
+                dl_head[i] = next_dl;
+            } else {
+                dl_set_next(prev_dl, next_dl);
+            }
+            GC_clear_mark_bit((ptr_t)curr_dl);
+            GC_dl_entries--;
+            curr_dl = next_dl;
+        } else {
+            prev_dl = curr_dl;
+            curr_dl = dl_next(curr_dl);
+        }
+      }
+    }
+
+    /* MATTHEW: */
+    if (GC_custom_finalize)
+      GC_custom_finalize();
+}
+
+#ifdef JAVA_FINALIZATION
+
+/* Enqueue all remaining finalizers to be run - Assumes lock is
+ * held, and signals are disabled */
+void GC_enqueue_all_finalizers()
+{
+    struct finalizable_object * curr_fo, * prev_fo, * next_fo;
+    ptr_t real_ptr, real_link;
+    register int i;
+    int fo_size;
+    
+    fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
+    GC_words_finalized = 0;
+    for (i = 0; i < fo_size; i++) {
+        curr_fo = fo_head[i];
+        prev_fo = 0;
+      while (curr_fo != 0) {
+          real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
+          GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc);
+          GC_set_mark_bit(real_ptr);
+ 
+          /* Delete from hash table */
+          next_fo = fo_next(curr_fo);
+          if (prev_fo == 0) {
+              fo_head[i] = next_fo;
+          } else {
+              fo_set_next(prev_fo, next_fo);
+          }
+          GC_fo_entries--;
+
+          /* Add to list of objects awaiting finalization.	*/
+          fo_set_next(curr_fo, GC_finalize_now);
+          GC_finalize_now = curr_fo;
+
+          /* unhide object pointer so any future collections will	*/
+          /* see it.						*/
+          curr_fo -> fo_hidden_base = 
+        		(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
+
+          GC_words_finalized +=
+           	ALIGNED_WORDS(curr_fo -> fo_object_size)
+        		+ ALIGNED_WORDS(sizeof(struct finalizable_object));
+          curr_fo = next_fo;
+        }
+    }
+
+    return;
+}
+
+/* Invoke all remaining finalizers that haven't yet been run. 
+ * This is needed for strict compliance with the Java standard, 
+ * which can make the runtime guarantee that all finalizers are run.
+ * Unfortunately, the Java standard implies we have to keep running
+ * finalizers until there are no more left, a potential infinite loop.
+ * YUCK.  * This routine is externally callable, so is called without 
+ * the allocation lock 
+ */
+void GC_finalize_all()
+{
+    DCL_LOCK_STATE;
+
+    DISABLE_SIGNALS();
+    LOCK();
+    while (GC_fo_entries > 0) {
+      GC_enqueue_all_finalizers();
+      UNLOCK();
+      ENABLE_SIGNALS();
+      GC_invoke_finalizers();
+      DISABLE_SIGNALS();
+      LOCK();
+    }
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+#endif
+
+/* Invoke finalizers for all objects that are ready to be finalized.	*/
+/* Should be called without allocation lock.				*/
+void GC_invoke_finalizers()
+{
+    static int doing = 0; /* MATTHEW */
+    register struct finalizable_object * curr_fo;
+    DCL_LOCK_STATE;
+
+    /* MATTHEW: don't allow nested finalizations */
+    if (doing)
+      return;
+    doing++;
+    
+    while (GC_finalize_now != 0) {
+#	ifdef THREADS
+	    DISABLE_SIGNALS();
+	    LOCK();
+#	endif
+    	curr_fo = GC_finalize_now;
+#	ifdef THREADS
+ 	    if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo);
+	    UNLOCK();
+	    ENABLE_SIGNALS();
+	    if (curr_fo == 0) break;
+#	else
+	    GC_finalize_now = fo_next(curr_fo);
+#	endif
+ 	fo_set_next(curr_fo, 0);
+    	(*(curr_fo -> fo_fn))((ptr_t)(curr_fo -> fo_hidden_base),
+    			      curr_fo -> fo_client_data);
+    	curr_fo -> fo_client_data = 0;
+#	ifdef UNDEFINED
+	    /* This is probably a bad idea.  It throws off accounting if */
+	    /* nearly all objects are finalizable.  O.w. it shouldn't	 */
+	    /* matter.							 */
+    	    GC_free((GC_PTR)curr_fo);
+#	endif
+    }
+
+    doing--; /* MATTHEW */
+}
+
+# ifdef __STDC__
+    GC_PTR GC_call_with_alloc_lock(GC_fn_type fn,
+    					 GC_PTR client_data)
+# else
+    GC_PTR GC_call_with_alloc_lock(fn, client_data)
+    GC_fn_type fn;
+    GC_PTR client_data;
+# endif
+{
+    GC_PTR result;
+    DCL_LOCK_STATE;
+    
+#   ifdef THREADS
+      DISABLE_SIGNALS();
+      LOCK();
+      SET_LOCK_HOLDER();
+#   endif
+    result = (*fn)(client_data);
+#   ifdef THREADS
+      UNSET_LOCK_HOLDER();
+      UNLOCK();
+      ENABLE_SIGNALS();
+#   endif
+    return(result);
+}
+
diff --git a/src/mzscheme/gc/gc.h b/src/mzscheme/gc/gc.h
new file mode 100644
index 0000000..82d6ebf
--- /dev/null
+++ b/src/mzscheme/gc/gc.h
@@ -0,0 +1,656 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * Note that this defines a large number of tuning hooks, which can
+ * safely be ignored in nearly all cases.  For normal use it suffices
+ * to call only GC_MALLOC and perhaps GC_REALLOC.
+ * For better performance, also look at GC_MALLOC_ATOMIC, and
+ * GC_enable_incremental.  If you need an action to be performed
+ * immediately before an object is collected, look at GC_register_finalizer.
+ * If you are using Solaris threads, look at the end of this file.
+ * Everything else is best ignored unless you encounter performance
+ * problems.
+ */
+ 
+#ifndef _GC_H
+
+# define _GC_H
+# define __GC
+# include <stddef.h>
+
+
+#if defined(_MSC_VER) && defined(_DLL)
+#ifdef GC_BUILD
+#define GC_API __declspec(dllexport)
+#else
+#define GC_API __declspec(dllimport)
+#endif
+#endif
+
+#ifndef GC_API
+#define GC_API extern
+#endif
+
+# if defined(__STDC__) || defined(__cplusplus)
+#   define GC_PROTO(args) args
+    typedef void * GC_PTR;
+# else
+#   define GC_PROTO(args) ()
+    typedef char * GC_PTR;
+#  endif
+
+# ifdef __cplusplus
+    extern "C" {
+# endif
+
+
+/* Define word and signed_word to be unsigned and signed types of the 	*/
+/* size as char * or void *.  There seems to be no way to do this	*/
+/* even semi-portably.  The following is probably no better/worse 	*/
+/* than almost anything else.						*/
+/* The ANSI standard suggests that size_t and ptr_diff_t might be 	*/
+/* better choices.  But those appear to have incorrect definitions	*/
+/* on may systems.  Notably "typedef int size_t" seems to be both	*/
+/* frequent and WRONG.							*/
+typedef unsigned long GC_word;
+typedef long GC_signed_word;
+
+/* Public read-only variables */
+
+GC_API GC_word GC_gc_no;/* Counter incremented per collection.  	*/
+			/* Includes empty GCs at startup.		*/
+			
+
+/* Public R/W variables */
+
+GC_API void * (*GC_oom_fn) GC_PROTO((size_t bytes_requested));
+			/* When there is insufficient memory to satisfy */
+			/* an allocation request, we return		*/
+			/* (*GC_oom_fn)().  By default this just	*/
+			/* returns 0.					*/
+			/* If it returns, it must return 0 or a valid	*/
+			/* pointer to a previously allocated heap 	*/
+			/* object.					*/
+
+GC_API int GC_quiet;	/* Disable statistics output.  Only matters if	*/
+			/* collector has been compiled with statistics	*/
+			/* enabled.  This involves a performance cost,	*/
+			/* and is thus not the default.			*/
+
+GC_API int GC_dont_gc;	/* Dont collect unless explicitly requested, e.g. */
+			/* because it's not safe.			  */
+
+GC_API int GC_dont_expand;
+			/* Dont expand heap unless explicitly requested */
+			/* or forced to.				*/
+
+GC_API int GC_full_freq;    /* Number of partial collections between	*/
+			    /* full collections.  Matters only if	*/
+			    /* GC_incremental is set.			*/
+			
+GC_API GC_word GC_non_gc_bytes;
+			/* Bytes not considered candidates for collection. */
+			/* Used only to control scheduling of collections. */
+
+GC_API GC_word GC_free_space_divisor;
+			/* We try to make sure that we allocate at 	*/
+			/* least N/GC_free_space_divisor bytes between	*/
+			/* collections, where N is the heap size plus	*/
+			/* a rough estimate of the root set size.	*/
+			/* Initially, GC_free_space_divisor = 4.	*/
+			/* Increasing its value will use less space	*/
+			/* but more collection time.  Decreasing it	*/
+			/* will appreciably decrease collection time	*/
+			/* at the expense of space.			*/
+			/* GC_free_space_divisor = 1 will effectively	*/
+			/* disable collections.				*/
+
+GC_API GC_word GC_max_retries;
+			/* The maximum number of GCs attempted before	*/
+			/* reporting out of memory after heap		*/
+			/* expansion fails.  Initially 0.		*/
+			
+			
+/* Public procedures */
+/*
+ * general purpose allocation routines, with roughly malloc calling conv.
+ * The atomic versions promise that no relevant pointers are contained
+ * in the object.  The nonatomic versions guarantee that the new object
+ * is cleared.  GC_malloc_stubborn promises that no changes to the object
+ * will occur after GC_end_stubborn_change has been called on the
+ * result of GC_malloc_stubborn. GC_malloc_uncollectable allocates an object
+ * that is scanned for pointers to collectable objects, but is not itself
+ * collectable.  GC_malloc_uncollectable and GC_free called on the resulting
+ * object implicitly update GC_non_gc_bytes appropriately.
+ */
+GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes));
+
+/* The following is only defined if the library has been suitably	*/
+/* compiled:								*/
+GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
+
+/* Explicitly deallocate an object.  Dangerous if used incorrectly.     */
+/* Requires a pointer to the base of an object.				*/
+/* If the argument is stubborn, it should not be changeable when freed. */
+/* An object should not be enable for finalization when it is 		*/
+/* explicitly deallocated.						*/
+/* GC_free(0) is a no-op, as required by ANSI C for free.		*/
+GC_API void GC_free GC_PROTO((GC_PTR object_addr));
+
+/*
+ * Stubborn objects may be changed only if the collector is explicitly informed.
+ * The collector is implicitly informed of coming change when such
+ * an object is first allocated.  The following routines inform the
+ * collector that an object will no longer be changed, or that it will
+ * once again be changed.  Only nonNIL pointer stores into the object
+ * are considered to be changes.  The argument to GC_end_stubborn_change
+ * must be exacly the value returned by GC_malloc_stubborn or passed to
+ * GC_change_stubborn.  (In the second case it may be an interior pointer
+ * within 512 bytes of the beginning of the objects.)
+ * There is a performance penalty for allowing more than
+ * one stubborn object to be changed at once, but it is acceptable to
+ * do so.  The same applies to dropping stubborn objects that are still
+ * changeable.
+ */
+GC_API void GC_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
+
+/* Return a pointer to the base (lowest address) of an object given	*/
+/* a pointer to a location within the object.				*/
+/* Return 0 if displaced_pointer doesn't point to within a valid	*/
+/* object.								*/
+GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer));
+
+/* Given a pointer to the base of an object, return its size in bytes.	*/
+/* The returned size may be slightly larger than what was originally	*/
+/* requested.								*/
+GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
+
+/* For compatibility with C library.  This is occasionally faster than	*/
+/* a malloc followed by a bcopy.  But if you rely on that, either here	*/
+/* or with the standard C library, your code is broken.  In my		*/
+/* opinion, it shouldn't have been invented, but now we're stuck. -HB	*/
+/* The resulting object has the same kind as the original.		*/
+/* If the argument is stubborn, the result will have changes enabled.	*/
+/* It is an error to have changes enabled for the original object.	*/
+/* Follows ANSI comventions for NULL old_object.			*/
+GC_API GC_PTR GC_realloc GC_PROTO((GC_PTR old_object,
+				   size_t new_size_in_bytes));
+				   
+/* Explicitly increase the heap size.	*/
+/* Returns 0 on failure, 1 on success.  */
+GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes));
+
+/* Limit the heap size to n bytes.  Useful when you're debugging, 	*/
+/* especially on systems that don't handle running out of memory well.	*/
+/* n == 0 ==> unbounded.  This is the default.				*/
+GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
+
+/* Clear the set of root segments.  Wizards only. */
+GC_API void GC_clear_roots GC_PROTO((void));
+
+/* Add a root segment.  Wizards only. */
+GC_API void GC_add_roots GC_PROTO((char * low_address,
+				   char * high_address_plus_1));
+
+/* Add a displacement to the set of those considered valid by the	*/
+/* collector.  GC_register_displacement(n) means that if p was returned */
+/* by GC_malloc, then (char *)p + n will be considered to be a valid	*/
+/* pointer to n.  N must be small and less than the size of p.		*/
+/* (All pointers to the interior of objects from the stack are		*/
+/* considered valid in any case.  This applies to heap objects and	*/
+/* static data.)							*/
+/* Preferably, this should be called before any other GC procedures.	*/
+/* Calling it later adds to the probability of excess memory		*/
+/* retention.								*/
+/* This is a no-op if the collector was compiled with recognition of	*/
+/* arbitrary interior pointers enabled, which is now the default.	*/
+GC_API void GC_register_displacement GC_PROTO((GC_word n));
+
+/* The following version should be used if any debugging allocation is	*/
+/* being done.								*/
+GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
+
+/* Explicitly trigger a full, world-stop collection. 	*/
+GC_API void GC_gcollect GC_PROTO((void));
+
+/* Trigger a full world-stopped collection.  Abort the collection if 	*/
+/* and when stop_func returns a nonzero value.  Stop_func will be 	*/
+/* called frequently, and should be reasonably fast.  This works even	*/
+/* if virtual dirty bits, and hence incremental collection is not 	*/
+/* available for this architecture.  Collections can be aborted faster	*/
+/* than normal pause times for incremental collection.  However,	*/
+/* aborted collections do no useful work; the next collection needs	*/
+/* to start from the beginning.						*/
+typedef int (* GC_stop_func) GC_PROTO((void));
+GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func));
+
+/* Return the number of bytes in the heap.  Excludes collector private	*/
+/* data structures.  Includes empty blocks and fragmentation loss.	*/
+/* Includes some pages that were allocated but never written.		*/
+GC_API size_t GC_get_heap_size GC_PROTO((void));
+
+/* Return the number of bytes allocated since the last collection.	*/
+GC_API size_t GC_get_bytes_since_gc GC_PROTO((void));
+
+/* Enable incremental/generational collection.	*/
+/* Not advisable unless dirty bits are 		*/
+/* available or most heap objects are		*/
+/* pointerfree(atomic) or immutable.		*/
+/* Don't use in leak finding mode.		*/
+/* Ignored if GC_dont_gc is true.		*/
+GC_API void GC_enable_incremental GC_PROTO((void));
+
+/* Perform some garbage collection work, if appropriate.	*/
+/* Return 0 if there is no more work to be done.		*/
+/* Typically performs an amount of work corresponding roughly	*/
+/* to marking from one page.  May do more work if further	*/
+/* progress requires it, e.g. if incremental collection is	*/
+/* disabled.  It is reasonable to call this in a wait loop	*/
+/* until it returns 0.						*/
+GC_API int GC_collect_a_little GC_PROTO((void));
+
+/* Allocate an object of size lb bytes.  The client guarantees that	*/
+/* as long as the object is live, it will be referenced by a pointer	*/
+/* that points to somewhere within the first 256 bytes of the object.	*/
+/* (This should normally be declared volatile to prevent the compiler	*/
+/* from invalidating this assertion.)  This routine is only useful	*/
+/* if a large array is being allocated.  It reduces the chance of 	*/
+/* accidentally retaining such an array as a result of scanning an	*/
+/* integer that happens to be an address inside the array.  (Actually,	*/
+/* it reduces the chance of the allocator not finding space for such	*/
+/* an array, since it will try hard to avoid introducing such a false	*/
+/* reference.)  On a SunOS 4.X or MS Windows system this is recommended */
+/* for arrays likely to be larger than 100K or so.  For other systems,	*/
+/* or if the collector is not configured to recognize all interior	*/
+/* pointers, the threshold is normally much higher.			*/
+GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb));
+GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
+
+/* Debugging (annotated) allocation.  GC_gcollect will check 		*/
+/* objects allocated in this way for overwrites, etc.			*/
+GC_API GC_PTR GC_debug_malloc
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_atomic
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_uncollectable
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_stubborn
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr));
+GC_API GC_PTR GC_debug_realloc
+	GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes,
+  		  char * descr_string, int descr_int));
+  			 	 
+GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
+# ifdef GC_DEBUG
+#   define GC_MALLOC(sz) GC_debug_malloc(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \
+							__FILE__, __LINE__)
+#   define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, __FILE__, \
+							       __LINE__)
+#   define GC_FREE(p) GC_debug_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_debug_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_debug_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, __FILE__, \
+							       __LINE__)
+#   define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, GC_base(obj))
+#   define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n)
+# else
+#   define GC_MALLOC(sz) GC_malloc(sz)
+#   define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz)
+#   define GC_REALLOC(old, sz) GC_realloc(old, sz)
+#   define GC_FREE(p) GC_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz)
+#   define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, obj)
+#   define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n)
+# endif
+/* The following are included because they are often convenient, and	*/
+/* reduce the chance for a misspecifed size argument.  But calls may	*/
+/* expand to something syntactically incorrect if t is a complicated	*/
+/* type expression.  							*/
+# define GC_NEW(t) (t *)GC_MALLOC(sizeof (t))
+# define GC_NEW_ATOMIC(t) (t *)GC_MALLOC_ATOMIC(sizeof (t))
+# define GC_NEW_STUBBORN(t) (t *)GC_MALLOC_STUBBORN(sizeof (t))
+# define GC_NEW_UNCOLLECTABLE(t) (t *)GC_MALLOC_UNCOLLECTABLE(sizeof (t))
+
+/* Finalization.  Some of these primitives are grossly unsafe.		*/
+/* The idea is to make them both cheap, and sufficient to build		*/
+/* a safer layer, closer to PCedar finalization.			*/
+/* The interface represents my conclusions from a long discussion	*/
+/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, 		*/
+/* Christian Jacobi, and Russ Atkinson.  It's not perfect, and		*/
+/* probably nobody else agrees with it.	    Hans-J. Boehm  3/13/92	*/
+typedef void (*GC_finalization_proc)
+  	GC_PROTO((GC_PTR obj, GC_PTR client_data));
+
+GC_API void GC_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+	/* When obj is no longer accessible, invoke		*/
+	/* (*fn)(obj, cd).  If a and b are inaccessible, and	*/
+	/* a points to b (after disappearing links have been	*/
+	/* made to disappear), then only a will be		*/
+	/* finalized.  (If this does not create any new		*/
+	/* pointers to b, then b will be finalized after the	*/
+	/* next collection.)  Any finalizable object that	*/
+	/* is reachable from itself by following one or more	*/
+	/* pointers will not be finalized (or collected).	*/
+	/* Thus cycles involving finalizable objects should	*/
+	/* be avoided, or broken by disappearing links.		*/
+	/* All but the last finalizer registered for an object  */
+	/* is ignored.						*/
+	/* Finalization may be removed by passing 0 as fn.	*/
+	/* Finalizers are implicitly unregistered just before   */
+	/* they are invoked.					*/
+	/* The old finalizer and client data are stored in	*/
+	/* *ofn and *ocd.					*/ 
+	/* Fn is never invoked on an accessible object,		*/
+	/* provided hidden pointers are converted to real 	*/
+	/* pointers only if the allocation lock is held, and	*/
+	/* such conversions are not performed by finalization	*/
+	/* routines.						*/
+	/* If GC_register_finalizer is aborted as a result of	*/
+	/* a signal, the object may be left with no		*/
+	/* finalization, even if neither the old nor new	*/
+	/* finalizer were NULL.					*/
+	/* Obj should be the nonNULL starting address of an 	*/
+	/* object allocated by GC_malloc or friends.		*/
+	/* Note that any garbage collectable object referenced	*/
+	/* by cd will be considered accessible until the	*/
+	/* finalizer is invoked.				*/
+
+/* Another versions of the above follow.  It ignores		*/
+/* self-cycles, i.e. pointers from a finalizable object to	*/
+/* itself.  There is a stylistic argument that this is wrong,	*/
+/* but it's unavoidable for C++, since the compiler may		*/
+/* silently introduce these.  It's also benign in that specific	*/
+/* case.							*/
+GC_API void GC_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+
+/* MATTHEW: eager finalizers do not care about cycles at all.
+   The intent is for guardian-like and will-like uses where
+   the object will always be made immediately live again, but
+   some action needed to be triggered by the object's (possibly
+   temporary) unreachableness. */
+GC_API void GC_register_eager_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+
+/* The following routine may be used to break cycles between	*/
+/* finalizable objects, thus causing cyclic finalizable		*/
+/* objects to be finalized in the correct order.  Standard	*/
+/* use involves calling GC_register_disappearing_link(&p),	*/
+/* where p is a pointer that is not followed by finalization	*/
+/* code, and should not be considered in determining 		*/
+/* finalization order.						*/
+GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Link should point to a field of a heap allocated 	*/
+	/* object obj.  *link will be cleared when obj is	*/
+	/* found to be inaccessible.  This happens BEFORE any	*/
+	/* finalization code is invoked, and BEFORE any		*/
+	/* decisions about finalization order are made.		*/
+	/* This is useful in telling the finalizer that 	*/
+	/* some pointers are not essential for proper		*/
+	/* finalization.  This may avoid finalization cycles.	*/
+	/* Note that obj may be resurrected by another		*/
+	/* finalizer, and thus the clearing of *link may	*/
+	/* be visible to non-finalization code.  		*/
+	/* There's an argument that an arbitrary action should  */
+	/* be allowed here, instead of just clearing a pointer. */
+	/* But this causes problems if that action alters, or 	*/
+	/* examines connectivity.				*/
+	/* Returns 1 if link was already registered, 0		*/
+	/* otherwise.						*/
+	/* Only exists for backward compatibility.  See below:	*/
+	
+GC_API int GC_general_register_disappearing_link
+	GC_PROTO((GC_PTR * /* link */, GC_PTR obj));
+	/* A slight generalization of the above. *link is	*/
+	/* cleared when obj first becomes inaccessible.  This	*/
+	/* can be used to implement weak pointers easily and	*/
+	/* safely. Typically link will point to a location	*/
+	/* holding a disguised pointer to obj.  (A pointer 	*/
+	/* inside an "atomic" object is effectively  		*/
+	/* disguised.)   In this way soft			*/
+	/* pointers are broken before any object		*/
+	/* reachable from them are finalized.  Each link	*/
+	/* May be registered only once, i.e. with one obj	*/
+	/* value.  This was added after a long email discussion */
+	/* with John Ellis.					*/
+	/* Obj must be a pointer to the first word of an object */
+	/* we allocated.  It is unsafe to explicitly deallocate */
+	/* the object containing link.  Explicitly deallocating */
+	/* obj may or may not cause link to eventually be	*/
+	/* cleared.						*/
+GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Returns 0 if link was not actually registered.	*/
+	/* Undoes a registration by either of the above two	*/
+	/* routines.						*/
+
+/* Auxiliary fns to make finalization work correctly with displaced	*/
+/* pointers introduced by the debugging allocators.			*/
+GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data));
+GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data));
+
+/* GC_set_warn_proc can be used to redirect or filter warning messages.	*/
+/* p may not be a NULL pointer.						*/
+typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg));
+GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
+    /* Returns old warning procedure.	*/
+	
+/* The following is intended to be used by a higher level	*/
+/* (e.g. cedar-like) finalization facility.  It is expected	*/
+/* that finalization code will arrange for hidden pointers to	*/
+/* disappear.  Otherwise objects can be accessed after they	*/
+/* have been collected.						*/
+/* Note that putting pointers in atomic objects or in 		*/
+/* nonpointer slots of "typed" objects is equivalent to 	*/
+/* disguising them in this way, and may have other advantages.	*/
+# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS)
+    typedef GC_word GC_hidden_pointer;
+#   define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
+#   define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
+    /* Converting a hidden pointer to a real pointer requires verifying	*/
+    /* that the object still exists.  This involves acquiring the  	*/
+    /* allocator lock to avoid a race with the collector.		*/
+# endif /* I_HIDE_POINTERS */
+
+typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data));
+GC_API GC_PTR GC_call_with_alloc_lock
+        	GC_PROTO((GC_fn_type fn, GC_PTR client_data));
+
+/* Check that p and q point to the same object.  		*/
+/* Fail conspicuously if they don't.				*/
+/* Returns the first argument.  				*/
+/* Succeeds if neither p nor q points to the heap.		*/
+/* May succeed if both p and q point to between heap objects.	*/
+GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
+
+/* Checked pointer pre- and post- increment operations.  Note that	*/
+/* the second argument is in units of bytes, not multiples of the	*/
+/* object size.  This should either be invoked from a macro, or the	*/
+/* call should be automatically generated.				*/
+GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
+GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
+
+/* Check that p is visible						*/
+/* to the collector as a possibly pointer containing location.		*/
+/* If it isn't fail conspicuously.					*/
+/* Returns the argument in all cases.  May erroneously succeed		*/
+/* in hard cases.  (This is intended for debugging use with		*/
+/* untyped allocations.  The idea is that it should be possible, though	*/
+/* slow, to add such a call to all indirect pointer stores.)		*/
+/* Currently useless for multithreaded worlds.				*/
+GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
+
+/* Check that if p is a pointer to a heap page, then it points to	*/
+/* a valid displacement within a heap object.				*/
+/* Fail conspicuously if this property does not hold.			*/
+/* Uninteresting with ALL_INTERIOR_POINTERS.				*/
+/* Always returns its argument.						*/
+GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR	p));
+
+/* Safer, but slow, pointer addition.  Probably useful mainly with 	*/
+/* a preprocessor.  Useful only for heap pointers.			*/
+#ifdef GC_DEBUG
+#   define GC_PTR_ADD3(x, n, type_of_result) \
+	((type_of_result)GC_same_obj((x)+(n), (x)))
+#   define GC_PRE_INCR3(x, n, type_of_result) \
+	((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x))
+#   define GC_POST_INCR2(x, type_of_result) \
+	((type_of_result)GC_post_incr(&(x), sizeof(*x))
+#   ifdef __GNUC__
+#       define GC_PTR_ADD(x, n) \
+	    GC_PTR_ADD3(x, n, typeof(x))
+#   define GC_PRE_INCR(x, n) \
+	    GC_PRE_INCR3(x, n, typeof(x))
+#   define GC_POST_INCR(x, n) \
+	    GC_POST_INCR3(x, typeof(x))
+#   else
+	/* We can't do this right without typeof, which ANSI	*/
+	/* decided was not sufficiently useful.  Repeatedly	*/
+	/* mentioning the arguments seems too dangerous to be	*/
+	/* useful.  So does not casting the result.		*/
+#   	define GC_PTR_ADD(x, n) ((x)+(n))
+#   endif
+#else	/* !GC_DEBUG */
+#   define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n))
+#   define GC_PTR_ADD(x, n) ((x)+(n))
+#   define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n))
+#   define GC_PRE_INCR(x, n) ((x) += (n))
+#   define GC_POST_INCR2(x, n, type_of_result) ((x)++)
+#   define GC_POST_INCR(x, n) ((x)++)
+#endif
+
+/* Safer assignment of a pointer to a nonstack location.	*/
+#ifdef GC_DEBUG
+# ifdef __STDC__
+#   define GC_PTR_STORE(p, q) \
+	(*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# else
+#   define GC_PTR_STORE(p, q) \
+	(*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# endif
+#else /* !GC_DEBUG */
+#   define GC_PTR_STORE(p, q) *((p) = (q))
+#endif
+
+/* Fynctions called to report pointer checking errors */
+GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
+
+GC_API void (*GC_is_valid_displacement_print_proc)
+	GC_PROTO((GC_PTR p));
+
+GC_API void (*GC_is_visible_print_proc)
+	GC_PROTO((GC_PTR p));
+
+#ifdef SOLARIS_THREADS
+/* We need to intercept calls to many of the threads primitives, so 	*/
+/* that we can locate thread stacks and stop the world.			*/
+/* Note also that the collector cannot see thread specific data.	*/
+/* Thread specific data should generally consist of pointers to		*/
+/* uncollectable objects, which are deallocated using the destructor	*/
+/* facility in thr_keycreate.						*/
+# include <thread.h>
+# include <signal.h>
+  int GC_thr_create(void *stack_base, size_t stack_size,
+                    void *(*start_routine)(void *), void *arg, long flags,
+                    thread_t *new_thread);
+  int GC_thr_join(thread_t wait_for, thread_t *departed, void **status);
+  int GC_thr_suspend(thread_t target_thread);
+  int GC_thr_continue(thread_t target_thread);
+  void * GC_dlopen(const char *path, int mode);
+
+# define thr_create GC_thr_create
+# define thr_join GC_thr_join
+# define thr_suspend GC_thr_suspend
+# define thr_continue GC_thr_continue
+# define dlopen GC_dlopen
+
+# endif /* SOLARIS_THREADS */
+
+#ifdef IRIX_THREADS
+/* We treat these similarly. */
+# include <pthread.h>
+# include <signal.h>
+
+  int GC_pthread_create(pthread_t *new_thread,
+                        const pthread_attr_t *attr,
+		        void *(*start_routine)(void *), void *arg);
+  int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);
+  int GC_pthread_join(pthread_t thread, void **retval);
+
+# define pthread_create GC_pthread_create
+# define pthread_sigmask GC_pthread_sigmask
+# define pthread_join GC_pthread_join
+
+#endif /* IRIX_THREADS */
+
+#if defined(SOLARIS_THREADS) || defined(IRIX_THREADS)
+/* This returns a list of objects, linked through their first		*/
+/* word.  Its use can greatly reduce lock contention problems, since	*/
+/* the allocation lock can be acquired and released many fewer times.	*/
+GC_PTR GC_malloc_many(size_t lb);
+#define GC_NEXT(p) (*(GC_PTR *)(p)) 	/* Retrieve the next element	*/
+					/* in returned list.		*/
+
+#endif /* SOLARIS_THREADS */
+
+/*
+ * If you are planning on putting
+ * the collector in a SunOS 5 dynamic library, you need to call GC_INIT()
+ * from the statically loaded program section.
+ * This circumvents a Solaris 2.X (X<=4) linker bug.
+ */
+#if defined(sparc) || defined(__sparc)
+#   define GC_INIT() { extern end, etext; \
+		       GC_noop(&end, &etext); }
+#else
+#   define GC_INIT()
+#endif
+
+#ifdef __cplusplus
+    }  /* end of extern "C" */
+#endif
+
+#endif /* _GC_H */
diff --git a/src/mzscheme/gc/gc.mak b/src/mzscheme/gc/gc.mak
new file mode 100644
index 0000000..fdd0c9c
--- /dev/null
+++ b/src/mzscheme/gc/gc.mak
@@ -0,0 +1,2087 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+!IF "$(CFG)" == ""
+CFG=cord - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to cord - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "gc - Win32 Release" && "$(CFG)" != "gc - Win32 Debug" &&\
+ "$(CFG)" != "gctest - Win32 Release" && "$(CFG)" != "gctest - Win32 Debug" &&\
+ "$(CFG)" != "cord - Win32 Release" && "$(CFG)" != "cord - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "gc.mak" CFG="cord - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "gc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "gc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "gctest - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "gctest - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "cord - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "cord - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "gctest - Win32 Debug"
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : ".\Release\gc.dll" ".\Release\gc.bsc"
+
+CLEAN : 
+	-@erase ".\Release\allchblk.obj"
+	-@erase ".\Release\allchblk.sbr"
+	-@erase ".\Release\alloc.obj"
+	-@erase ".\Release\alloc.sbr"
+	-@erase ".\Release\blacklst.obj"
+	-@erase ".\Release\blacklst.sbr"
+	-@erase ".\Release\checksums.obj"
+	-@erase ".\Release\checksums.sbr"
+	-@erase ".\Release\dbg_mlc.obj"
+	-@erase ".\Release\dbg_mlc.sbr"
+	-@erase ".\Release\dyn_load.obj"
+	-@erase ".\Release\dyn_load.sbr"
+	-@erase ".\Release\finalize.obj"
+	-@erase ".\Release\finalize.sbr"
+	-@erase ".\Release\gc.bsc"
+	-@erase ".\Release\gc.dll"
+	-@erase ".\Release\gc.exp"
+	-@erase ".\Release\gc.lib"
+	-@erase ".\Release\headers.obj"
+	-@erase ".\Release\headers.sbr"
+	-@erase ".\Release\mach_dep.obj"
+	-@erase ".\Release\mach_dep.sbr"
+	-@erase ".\Release\malloc.obj"
+	-@erase ".\Release\malloc.sbr"
+	-@erase ".\Release\mallocx.obj"
+	-@erase ".\Release\mallocx.sbr"
+	-@erase ".\Release\mark.obj"
+	-@erase ".\Release\mark.sbr"
+	-@erase ".\Release\mark_rts.obj"
+	-@erase ".\Release\mark_rts.sbr"
+	-@erase ".\Release\misc.obj"
+	-@erase ".\Release\misc.sbr"
+	-@erase ".\Release\new_hblk.obj"
+	-@erase ".\Release\new_hblk.sbr"
+	-@erase ".\Release\obj_map.obj"
+	-@erase ".\Release\obj_map.sbr"
+	-@erase ".\Release\os_dep.obj"
+	-@erase ".\Release\os_dep.sbr"
+	-@erase ".\Release\ptr_chck.obj"
+	-@erase ".\Release\ptr_chck.sbr"
+	-@erase ".\Release\reclaim.obj"
+	-@erase ".\Release\reclaim.sbr"
+	-@erase ".\Release\stubborn.obj"
+	-@erase ".\Release\stubborn.sbr"
+	-@erase ".\Release\typd_mlc.obj"
+	-@erase ".\Release\typd_mlc.sbr"
+	-@erase ".\Release\win32_threads.obj"
+	-@erase ".\Release\win32_threads.sbr"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D\
+ "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
+ "WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\Release/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS= \
+	".\Release\allchblk.sbr" \
+	".\Release\alloc.sbr" \
+	".\Release\blacklst.sbr" \
+	".\Release\checksums.sbr" \
+	".\Release\dbg_mlc.sbr" \
+	".\Release\dyn_load.sbr" \
+	".\Release\finalize.sbr" \
+	".\Release\headers.sbr" \
+	".\Release\mach_dep.sbr" \
+	".\Release\malloc.sbr" \
+	".\Release\mallocx.sbr" \
+	".\Release\mark.sbr" \
+	".\Release\mark_rts.sbr" \
+	".\Release\misc.sbr" \
+	".\Release\new_hblk.sbr" \
+	".\Release\obj_map.sbr" \
+	".\Release\os_dep.sbr" \
+	".\Release\ptr_chck.sbr" \
+	".\Release\reclaim.sbr" \
+	".\Release\stubborn.sbr" \
+	".\Release\typd_mlc.sbr" \
+	".\Release\win32_threads.sbr"
+
+".\Release\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\
+ /pdb:"$(OUTDIR)/gc.pdb" /machine:I386 /out:"$(OUTDIR)/gc.dll"\
+ /implib:"$(OUTDIR)/gc.lib" 
+LINK32_OBJS= \
+	".\Release\allchblk.obj" \
+	".\Release\alloc.obj" \
+	".\Release\blacklst.obj" \
+	".\Release\checksums.obj" \
+	".\Release\dbg_mlc.obj" \
+	".\Release\dyn_load.obj" \
+	".\Release\finalize.obj" \
+	".\Release\headers.obj" \
+	".\Release\mach_dep.obj" \
+	".\Release\malloc.obj" \
+	".\Release\mallocx.obj" \
+	".\Release\mark.obj" \
+	".\Release\mark_rts.obj" \
+	".\Release\misc.obj" \
+	".\Release\new_hblk.obj" \
+	".\Release\obj_map.obj" \
+	".\Release\os_dep.obj" \
+	".\Release\ptr_chck.obj" \
+	".\Release\reclaim.obj" \
+	".\Release\stubborn.obj" \
+	".\Release\typd_mlc.obj" \
+	".\Release\win32_threads.obj"
+
+".\Release\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=.\Debug
+INTDIR=.\Debug
+
+ALL : ".\Debug\gc.dll" ".\Debug\gc.bsc"
+
+CLEAN : 
+	-@erase ".\Debug\allchblk.obj"
+	-@erase ".\Debug\allchblk.sbr"
+	-@erase ".\Debug\alloc.obj"
+	-@erase ".\Debug\alloc.sbr"
+	-@erase ".\Debug\blacklst.obj"
+	-@erase ".\Debug\blacklst.sbr"
+	-@erase ".\Debug\checksums.obj"
+	-@erase ".\Debug\checksums.sbr"
+	-@erase ".\Debug\dbg_mlc.obj"
+	-@erase ".\Debug\dbg_mlc.sbr"
+	-@erase ".\Debug\dyn_load.obj"
+	-@erase ".\Debug\dyn_load.sbr"
+	-@erase ".\Debug\finalize.obj"
+	-@erase ".\Debug\finalize.sbr"
+	-@erase ".\Debug\gc.bsc"
+	-@erase ".\Debug\gc.dll"
+	-@erase ".\Debug\gc.exp"
+	-@erase ".\Debug\gc.lib"
+	-@erase ".\Debug\gc.map"
+	-@erase ".\Debug\gc.pdb"
+	-@erase ".\Debug\headers.obj"
+	-@erase ".\Debug\headers.sbr"
+	-@erase ".\Debug\mach_dep.obj"
+	-@erase ".\Debug\mach_dep.sbr"
+	-@erase ".\Debug\malloc.obj"
+	-@erase ".\Debug\malloc.sbr"
+	-@erase ".\Debug\mallocx.obj"
+	-@erase ".\Debug\mallocx.sbr"
+	-@erase ".\Debug\mark.obj"
+	-@erase ".\Debug\mark.sbr"
+	-@erase ".\Debug\mark_rts.obj"
+	-@erase ".\Debug\mark_rts.sbr"
+	-@erase ".\Debug\misc.obj"
+	-@erase ".\Debug\misc.sbr"
+	-@erase ".\Debug\new_hblk.obj"
+	-@erase ".\Debug\new_hblk.sbr"
+	-@erase ".\Debug\obj_map.obj"
+	-@erase ".\Debug\obj_map.sbr"
+	-@erase ".\Debug\os_dep.obj"
+	-@erase ".\Debug\os_dep.sbr"
+	-@erase ".\Debug\ptr_chck.obj"
+	-@erase ".\Debug\ptr_chck.sbr"
+	-@erase ".\Debug\reclaim.obj"
+	-@erase ".\Debug\reclaim.sbr"
+	-@erase ".\Debug\stubborn.obj"
+	-@erase ".\Debug\stubborn.sbr"
+	-@erase ".\Debug\typd_mlc.obj"
+	-@erase ".\Debug\typd_mlc.sbr"
+	-@erase ".\Debug\vc40.idb"
+	-@erase ".\Debug\vc40.pdb"
+	-@erase ".\Debug\win32_threads.obj"
+	-@erase ".\Debug\win32_threads.sbr"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "SILENT" /D "GC_BUILD"\
+ /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
+ "WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\Debug/
+CPP_SBRS=.\Debug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS= \
+	".\Debug\allchblk.sbr" \
+	".\Debug\alloc.sbr" \
+	".\Debug\blacklst.sbr" \
+	".\Debug\checksums.sbr" \
+	".\Debug\dbg_mlc.sbr" \
+	".\Debug\dyn_load.sbr" \
+	".\Debug\finalize.sbr" \
+	".\Debug\headers.sbr" \
+	".\Debug\mach_dep.sbr" \
+	".\Debug\malloc.sbr" \
+	".\Debug\mallocx.sbr" \
+	".\Debug\mark.sbr" \
+	".\Debug\mark_rts.sbr" \
+	".\Debug\misc.sbr" \
+	".\Debug\new_hblk.sbr" \
+	".\Debug\obj_map.sbr" \
+	".\Debug\os_dep.sbr" \
+	".\Debug\ptr_chck.sbr" \
+	".\Debug\reclaim.sbr" \
+	".\Debug\stubborn.sbr" \
+	".\Debug\typd_mlc.sbr" \
+	".\Debug\win32_threads.sbr"
+
+".\Debug\gc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /incremental:no /map /debug /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /dll /incremental:no\
+ /pdb:"$(OUTDIR)/gc.pdb" /map:"$(INTDIR)/gc.map" /debug /machine:I386\
+ /out:"$(OUTDIR)/gc.dll" /implib:"$(OUTDIR)/gc.lib" 
+LINK32_OBJS= \
+	".\Debug\allchblk.obj" \
+	".\Debug\alloc.obj" \
+	".\Debug\blacklst.obj" \
+	".\Debug\checksums.obj" \
+	".\Debug\dbg_mlc.obj" \
+	".\Debug\dyn_load.obj" \
+	".\Debug\finalize.obj" \
+	".\Debug\headers.obj" \
+	".\Debug\mach_dep.obj" \
+	".\Debug\malloc.obj" \
+	".\Debug\mallocx.obj" \
+	".\Debug\mark.obj" \
+	".\Debug\mark_rts.obj" \
+	".\Debug\misc.obj" \
+	".\Debug\new_hblk.obj" \
+	".\Debug\obj_map.obj" \
+	".\Debug\os_dep.obj" \
+	".\Debug\ptr_chck.obj" \
+	".\Debug\reclaim.obj" \
+	".\Debug\stubborn.obj" \
+	".\Debug\typd_mlc.obj" \
+	".\Debug\win32_threads.obj"
+
+".\Debug\gc.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "gctest\Release"
+# PROP BASE Intermediate_Dir "gctest\Release"
+# PROP BASE Target_Dir "gctest"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "gctest\Release"
+# PROP Intermediate_Dir "gctest\Release"
+# PROP Target_Dir "gctest"
+OUTDIR=.\gctest\Release
+INTDIR=.\gctest\Release
+
+ALL : "gc - Win32 Release" ".\Release\gctest.exe"
+
+CLEAN : 
+	-@erase ".\gctest\Release\test.obj"
+	-@erase ".\Release\gctest.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS"\
+ /Fp"$(INTDIR)/gctest.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\gctest\Release/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/gctest.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/gctest.pdb" /machine:I386 /out:"Release/gctest.exe" 
+LINK32_OBJS= \
+	".\gctest\Release\test.obj" \
+	".\Release\gc.lib"
+
+".\Release\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "gctest\Debug"
+# PROP BASE Intermediate_Dir "gctest\Debug"
+# PROP BASE Target_Dir "gctest"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "gctest\Debug"
+# PROP Intermediate_Dir "gctest\Debug"
+# PROP Target_Dir "gctest"
+OUTDIR=.\gctest\Debug
+INTDIR=.\gctest\Debug
+
+ALL : "gc - Win32 Debug" ".\Debug\gctest.exe" ".\gctest\Debug\gctest.bsc"
+
+CLEAN : 
+	-@erase ".\Debug\gctest.exe"
+	-@erase ".\gctest\Debug\gctest.bsc"
+	-@erase ".\gctest\Debug\gctest.map"
+	-@erase ".\gctest\Debug\gctest.pdb"
+	-@erase ".\gctest\Debug\test.obj"
+	-@erase ".\gctest\Debug\test.sbr"
+	-@erase ".\gctest\Debug\vc40.idb"
+	-@erase ".\gctest\Debug\vc40.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
+ /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "WIN32_THREADS" /FR"$(INTDIR)/"\
+ /Fp"$(INTDIR)/gctest.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\gctest\Debug/
+CPP_SBRS=.\gctest\Debug/
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gctest.bsc" 
+BSC32_SBRS= \
+	".\gctest\Debug\test.sbr"
+
+".\gctest\Debug\gctest.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /incremental:no /map /debug /machine:I386 /out:"Debug/gctest.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/gctest.pdb" /map:"$(INTDIR)/gctest.map" /debug /machine:I386\
+ /out:"Debug/gctest.exe" 
+LINK32_OBJS= \
+	".\Debug\gc.lib" \
+	".\gctest\Debug\test.obj"
+
+".\Debug\gctest.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "cord\Release"
+# PROP BASE Intermediate_Dir "cord\Release"
+# PROP BASE Target_Dir "cord"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "cord\Release"
+# PROP Intermediate_Dir "cord\Release"
+# PROP Target_Dir "cord"
+OUTDIR=.\cord\Release
+INTDIR=.\cord\Release
+
+ALL : "gc - Win32 Release" ".\Release\de.exe"
+
+CLEAN : 
+	-@erase ".\cord\Release\cordbscs.obj"
+	-@erase ".\cord\Release\cordxtra.obj"
+	-@erase ".\cord\Release\de.obj"
+	-@erase ".\cord\Release\de_win.obj"
+	-@erase ".\cord\Release\de_win.res"
+	-@erase ".\Release\de.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\cord\Release/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/de.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no /pdb:"$(OUTDIR)/de.pdb"\
+ /machine:I386 /out:"Release/de.exe" 
+LINK32_OBJS= \
+	".\cord\Release\cordbscs.obj" \
+	".\cord\Release\cordxtra.obj" \
+	".\cord\Release\de.obj" \
+	".\cord\Release\de_win.obj" \
+	".\cord\Release\de_win.res" \
+	".\Release\gc.lib"
+
+".\Release\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "cord\Debug"
+# PROP BASE Intermediate_Dir "cord\Debug"
+# PROP BASE Target_Dir "cord"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "cord\Debug"
+# PROP Intermediate_Dir "cord\Debug"
+# PROP Target_Dir "cord"
+OUTDIR=.\cord\Debug
+INTDIR=.\cord\Debug
+
+ALL : "gc - Win32 Debug" ".\Debug\de.exe"
+
+CLEAN : 
+	-@erase ".\cord\Debug\cordbscs.obj"
+	-@erase ".\cord\Debug\cordxtra.obj"
+	-@erase ".\cord\Debug\de.obj"
+	-@erase ".\cord\Debug\de.pdb"
+	-@erase ".\cord\Debug\de_win.obj"
+	-@erase ".\cord\Debug\de_win.res"
+	-@erase ".\cord\Debug\vc40.idb"
+	-@erase ".\cord\Debug\vc40.pdb"
+	-@erase ".\Debug\de.exe"
+	-@erase ".\Debug\de.ilk"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /D "_DEBUG" /D "WIN32" /D\
+ "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /Fp"$(INTDIR)/cord.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\cord\Debug/
+CPP_SBRS=.\.
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+MTL=mktyplib.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+RSC=rc.exe
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+RSC_PROJ=/l 0x809 /fo"$(INTDIR)/de_win.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/cord.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"Debug/de.exe"
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:yes\
+ /pdb:"$(OUTDIR)/de.pdb" /debug /machine:I386 /out:"Debug/de.exe" 
+LINK32_OBJS= \
+	".\cord\Debug\cordbscs.obj" \
+	".\cord\Debug\cordxtra.obj" \
+	".\cord\Debug\de.obj" \
+	".\cord\Debug\de_win.obj" \
+	".\cord\Debug\de_win.res" \
+	".\Debug\gc.lib"
+
+".\Debug\de.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+################################################################################
+# Begin Target
+
+# Name "gc - Win32 Release"
+# Name "gc - Win32 Debug"
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\reclaim.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_RECLA=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_RECLA=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+".\Release\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_RECLA=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_RECLA=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+".\Debug\reclaim.sbr" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\os_dep.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_OS_DE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OS_DE=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	".\vd\PCR_VD.h"\
+	
+
+".\Release\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+".\Release\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_OS_DE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OS_DE=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	".\vd\PCR_VD.h"\
+	
+
+".\Debug\os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+".\Debug\os_dep.sbr" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\misc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MISC_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MISC_=\
+	".\il\PCR_IL.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+".\Release\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MISC_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MISC_=\
+	".\il\PCR_IL.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+".\Debug\misc.sbr" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mark_rts.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MARK_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+".\Release\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MARK_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+".\Debug\mark_rts.sbr" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mach_dep.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MACH_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MACH_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+".\Release\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MACH_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MACH_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+".\Debug\mach_dep.sbr" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\headers.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_HEADE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_HEADE=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+".\Release\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_HEADE=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_HEADE=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+".\Debug\headers.sbr" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\alloc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_ALLOC=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLOC=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+".\Release\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_ALLOC=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLOC=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+".\Debug\alloc.sbr" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\allchblk.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_ALLCH=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLCH=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+".\Release\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_ALLCH=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_ALLCH=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+".\Debug\allchblk.sbr" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\stubborn.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_STUBB=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_STUBB=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+".\Release\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_STUBB=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_STUBB=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+".\Debug\stubborn.sbr" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\obj_map.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_OBJ_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OBJ_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+".\Release\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_OBJ_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_OBJ_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+".\Debug\obj_map.sbr" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\new_hblk.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_NEW_H=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_NEW_H=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+".\Release\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_NEW_H=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_NEW_H=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\new_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+".\Debug\new_hblk.sbr" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mark.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MARK_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+".\Release\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MARK_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MARK_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mark.obj" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+".\Debug\mark.sbr" : $(SOURCE) $(DEP_CPP_MARK_C) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\malloc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MALLO=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLO=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+".\Release\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MALLO=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLO=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+".\Debug\malloc.sbr" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mallocx.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_MALLX=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLX=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+".\Release\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_MALLX=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MALLX=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+".\Debug\mallocx.sbr" : $(SOURCE) $(DEP_CPP_MALLX) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\finalize.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_FINAL=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_FINAL=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+".\Release\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_FINAL=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_FINAL=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+".\Debug\finalize.sbr" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dbg_mlc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_DBG_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DBG_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+".\Release\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_DBG_M=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DBG_M=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\dbg_mlc.obj" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+".\Debug\dbg_mlc.sbr" : $(SOURCE) $(DEP_CPP_DBG_M) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\blacklst.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_BLACK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_BLACK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+".\Release\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_BLACK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_BLACK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+".\Debug\blacklst.sbr" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\typd_mlc.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_TYPD_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TYPD_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+".\Release\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_TYPD_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TYPD_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\typd_mlc.obj" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+".\Debug\typd_mlc.sbr" : $(SOURCE) $(DEP_CPP_TYPD_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\ptr_chck.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_PTR_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_PTR_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+".\Release\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_PTR_C=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_mark.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_PTR_C=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\ptr_chck.obj" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+".\Debug\ptr_chck.sbr" : $(SOURCE) $(DEP_CPP_PTR_C) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dyn_load.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_DYN_L=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DYN_L=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+".\Release\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_DYN_L=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_DYN_L=\
+	".\il\PCR_IL.h"\
+	".\mm\PCR_MM.h"\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+".\Debug\dyn_load.sbr" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\win32_threads.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_WIN32=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_WIN32=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+".\Release\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_WIN32=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_WIN32=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\win32_threads.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+".\Debug\win32_threads.sbr" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\checksums.c
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+DEP_CPP_CHECK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_CHECK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Release\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+".\Release\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+DEP_CPP_CHECK=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_CHECK=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+".\Debug\checksums.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+".\Debug\checksums.sbr" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+################################################################################
+# Begin Target
+
+# Name "gctest - Win32 Release"
+# Name "gctest - Win32 Debug"
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Project Dependency
+
+# Project_Dep_Name "gc"
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+"gc - Win32 Release" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" 
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+"gc - Win32 Debug" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" 
+
+!ENDIF 
+
+# End Project Dependency
+################################################################################
+# Begin Source File
+
+SOURCE=.\test.c
+DEP_CPP_TEST_=\
+	".\config.h"\
+	".\gc.h"\
+	".\gc_hdrs.h"\
+	".\gc_priv.h"\
+	".\gc_typed.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_TEST_=\
+	".\th\PCR_Th.h"\
+	".\th\PCR_ThCrSec.h"\
+	".\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gctest - Win32 Release"
+
+
+".\gctest\Release\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "gctest - Win32 Debug"
+
+
+".\gctest\Debug\test.obj" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+".\gctest\Debug\test.sbr" : $(SOURCE) $(DEP_CPP_TEST_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+################################################################################
+# Begin Target
+
+# Name "cord - Win32 Release"
+# Name "cord - Win32 Debug"
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Project Dependency
+
+# Project_Dep_Name "gc"
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+"gc - Win32 Release" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Release" 
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+"gc - Win32 Debug" : 
+   $(MAKE) /$(MAKEFLAGS) /F ".\gc.mak" CFG="gc - Win32 Debug" 
+
+!ENDIF 
+
+# End Project Dependency
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de_win.c
+DEP_CPP_DE_WI=\
+	".\cord\cord.h"\
+	".\cord\de_cmds.h"\
+	".\cord\de_win.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_DE_WI=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de_win.obj" : $(SOURCE) $(DEP_CPP_DE_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de.c
+DEP_CPP_DE_C2e=\
+	".\cord\cord.h"\
+	".\cord\de_cmds.h"\
+	".\cord\de_win.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_DE_C2e=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de.obj" : $(SOURCE) $(DEP_CPP_DE_C2e) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\cordxtra.c
+DEP_CPP_CORDX=\
+	".\cord\cord.h"\
+	".\cord\ec.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_CORDX=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\cordxtra.obj" : $(SOURCE) $(DEP_CPP_CORDX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\cordbscs.c
+DEP_CPP_CORDB=\
+	".\cord\cord.h"\
+	".\cord\private\cord_pos.h"\
+	
+NODEP_CPP_CORDB=\
+	".\cord\gc.h"\
+	
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\cordbscs.obj" : $(SOURCE) $(DEP_CPP_CORDB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cord\de_win.RC
+
+!IF  "$(CFG)" == "cord - Win32 Release"
+
+
+".\cord\Release\de_win.res" : $(SOURCE) "$(INTDIR)"
+   $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "NDEBUG" $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "cord - Win32 Debug"
+
+
+".\cord\Debug\de_win.res" : $(SOURCE) "$(INTDIR)"
+   $(RSC) /l 0x809 /fo"$(INTDIR)/de_win.res" /i "cord" /d "_DEBUG" $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/mzscheme/gc/gc.man b/src/mzscheme/gc/gc.man
new file mode 100644
index 0000000..5409e70
--- /dev/null
+++ b/src/mzscheme/gc/gc.man
@@ -0,0 +1,80 @@
+.TH GC_MALLOC 1L "12 February 1996"
+.SH NAME
+GC_malloc, GC_malloc_atomic, GC_free, GC_realloc, GC_enable_incremental, GC_register_finalizer, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_set_warn_proc \- Garbage collecting malloc replacement
+.SH SYNOPSIS
+#include "gc.h"
+.br
+# define malloc(n) GC_malloc(n)
+.br
+... malloc(...) ...
+.br
+.sp
+cc ... gc.a
+.LP
+.SH DESCRIPTION
+.I GC_malloc
+and
+.I GC_free
+are plug-in replacements for standard malloc and free.  However,
+.I
+GC_malloc
+will attempt to reclaim inaccessible space automatically by invoking a conservative garbage collector at appropriate points.  The collector traverses all data structures accessible by following pointers from the machines registers, stack(s), data, and bss segments.  Inaccessible structures will be reclaimed.  A machine word is considered to be a valid pointer if it is an address inside an object allocated by
+.I
+GC_malloc
+or friends.
+.LP
+See the documentation in the include file gc_cpp.h for an alternate, C++ specific interface to the garbage collector.
+.LP
+Unlike the standard implementations of malloc,
+.I
+GC_malloc
+clears the newly allocated storage.
+.I
+GC_malloc_atomic
+does not.  Furthermore, it informs the collector that the resulting object will never contain any pointers, and should therefore not be scanned by the collector.
+.LP
+.I
+GC_free
+can be used to deallocate objects, but its use is optional, and generally discouraged.
+.I
+GC_realloc
+has the standard realloc semantics.  It preserves pointer-free-ness.
+.I
+GC_register_finalizer
+allows for registration of functions that are invoked when an object becomes inaccessible.
+.LP
+The garbage collector tries to avoid allocating memory at locations that already appear to be referenced before allocation.  (Such apparent ``pointers'' are usually large integers and the like that just happen to look like an address.)  This may make it hard to allocate very large objects.  An attempt to do so may generate a warning.
+.LP
+.I
+GC_malloc_ignore_off_page
+and
+.I
+GC_malloc_atomic_ignore_off_page
+inform the collector that the client code will always maintain a pointer to near the beginning of the object (within the first 512 bytes), and that pointers beyond that can be ignored by the collector.  This makes it much easier for the collector to place large objects.  These are recommended for large object allocation.  (Objects expected to be larger than about 100KBytes should be allocated this way.)
+.LP
+It is also possible to use the collector to find storage leaks in programs destined to be run with standard malloc/free.  The collector can be compiled for thread-safe operation.  Unlike standard malloc, it is safe to call malloc after a previous malloc call was interrupted by a signal, provided the original malloc call is not resumed.
+.LP
+The collector may, on rare occasion produce warning messages.  On UNIX machines these appear on stderr.  Warning messages can be filtered, redirected, or ignored with
+.I
+GC_set_warn_proc.
+This is recommended for production code.  See gc.h for details.
+.LP
+Debugging versions of many of the above routines are provided as macros.  Their names are identical to the above, but consist of all capital letters.  If GC_DEBUG is defined before gc.h is included, these routines do additional checking, and allow the leak detecting version of the collector to produce slightly more useful output.  Without GC_DEBUG defined, they behave exactly like the lower-case versions.
+.LP
+On some machines, collection will be performed incrementally after a call to
+.I
+GC_enable_incremental.
+This may temporarily write protect pages in the heap.  See the README file for more information on how this interacts with system calls that write to the heap.
+.LP
+Other facilities not discussed here include limited facilities to support incremental collection on machines without appropriate VM support, provisions for providing more explicit object layout information to the garbage collector, more direct support for ``weak'' pointers, support for ``abortable'' garbage collections during idle time, etc.
+.LP
+.SH "SEE ALSO"
+The README and gc.h files in the distribution.  More detailed definitions of the functions exported by the collector are given there.  (The above list is not complete.)
+.LP
+Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment",
+\fISoftware Practice & Experience\fP, September 1988, pp. 807-820.
+.LP
+The malloc(3) man page.
+.LP
+.SH AUTHOR
+Hans-J. Boehm (boehm@parc.xerox.com).  Some of the code was written by others, most notably Alan Demers.
diff --git a/src/mzscheme/gc/gc_alloc.h b/src/mzscheme/gc/gc_alloc.h
new file mode 100644
index 0000000..f64c112
--- /dev/null
+++ b/src/mzscheme/gc/gc_alloc.h
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+//
+// This is a C++ header file that is intended to replace the SGI STL
+// alloc.h.
+//
+// This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
+// and -DALL_INTERIOR_POINTERS.  We also recommend
+// -DREDIRECT_MALLOC=GC_uncollectable_malloc.
+//
+// Some of this could be faster in the explicit deallocation case.  In particular,
+// we spend too much time clearing objects on the free lists.  That could be avoided.
+//
+// This uses template classes with static members, and hence soes not work
+// with g++ 2.7.2 and earlier.
+//
+
+#ifndef GC_ALLOC_H
+
+#define GC_ALLOC_H
+#define __ALLOC_H	// Prevent inclusion of the default version.  Ugly.
+
+#ifndef __ALLOC
+#   define __ALLOC alloc
+#endif
+
+#include <stddef.h>
+#include <string.h>
+
+// The following is just replicated from the conventional SGI alloc.h:
+
+template<class T, class alloc>
+class simple_alloc {
+
+public:
+    static T *allocate(size_t n)
+                { return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
+    static T *allocate(void)
+                { return (T*) alloc::allocate(sizeof (T)); }
+    static void deallocate(T *p, size_t n)
+                { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
+    static void deallocate(T *p)
+                { alloc::deallocate(p, sizeof (T)); }
+};
+
+#include "gc.h"
+
+// The following need to match collector data structures.
+// We can't include gc_priv.h, since that pulls in way too much stuff.
+// This should eventually be factored out into another include file.
+
+extern "C" {
+    extern void ** const GC_objfreelist_ptr;
+    extern void ** const GC_aobjfreelist_ptr;
+    extern void ** const GC_uobjfreelist_ptr;
+    extern void ** const GC_auobjfreelist_ptr;
+
+    extern void GC_incr_words_allocd(size_t words);
+    extern void GC_incr_mem_freed(size_t words);
+
+    extern char * GC_generic_malloc_words_small(size_t word, int kind);
+ 
+    extern void * GC_malloc_atomic_uncollectable(size_t bytes);
+}
+
+// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
+// AUNCOLLECTABLE in gc_priv.h.
+
+enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
+       GC_AUNCOLLECTABLE = 3 };
+
+enum { GC_max_fast_bytes = 255 };
+
+enum { GC_bytes_per_word = sizeof(char *) };
+
+enum { GC_byte_alignment = 8 };
+
+enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
+
+inline void * &GC_obj_link(void * p)
+{   return *(void **)p;  }
+
+// Compute a number of words >= n+1 bytes.
+// The +1 allows for pointers one past the end.
+inline GC_round_up(size_t n)
+{
+    return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
+}
+
+// The same but don't allow for extra byte.
+inline GC_round_up_uncollectable(size_t n)
+{
+    return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
+}
+
+template <int dummy>
+class GC_aux_template {
+public:
+  // File local count of allocated words.  Occasionally this is
+  // added into the global count.  A separate count is necessary since the
+  // real one must be updated with a procedure call.
+  static size_t GC_words_recently_allocd;
+
+  // Same for uncollectable mmory.  Not yet reflected in either
+  // GC_words_recently_allocd or GC_non_gc_bytes.
+  static size_t GC_uncollectable_words_recently_allocd;
+
+  // Similar counter for explicitly deallocated memory.
+  static size_t GC_mem_recently_freed;
+
+  // Again for uncollectable memory.
+  static size_t GC_uncollectable_mem_recently_freed;
+
+  static void * GC_out_of_line_malloc(size_t nwords, int kind);
+};
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
+
+template <int dummy>
+void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
+{
+    GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
+    GC_non_gc_bytes +=
+                GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
+    GC_uncollectable_words_recently_allocd = 0;
+
+    GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
+    GC_non_gc_bytes -= 
+                GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
+    GC_uncollectable_mem_recently_freed = 0;
+
+    GC_incr_words_allocd(GC_words_recently_allocd);
+    GC_words_recently_allocd = 0;
+
+    GC_incr_mem_freed(GC_mem_recently_freed);
+    GC_mem_recently_freed = 0;
+
+    return GC_generic_malloc_words_small(nwords, kind);
+}
+
+typedef GC_aux_template<0> GC_aux;
+
+// A fast, single-threaded, garbage-collected allocator
+// We assume the first word will be immediately overwritten.
+// In this version, deallocation is not a noop, and explicit
+// deallocation is likely to help performance.
+template <int dummy>
+class single_client_gc_alloc_template {
+    public:
+     	static void * allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc(n);
+	    flh = GC_objfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_words_recently_allocd += nwords;
+	    return op;
+        }
+     	static void * ptr_free_allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
+	    flh = GC_aobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_words_recently_allocd += nwords;
+	    return op;
+        }
+	static void deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes)  {
+		GC_free(p);
+	    } else {
+	        flh = GC_objfreelist_ptr + nwords;
+	        GC_obj_link(p) = *flh;
+		memset((char *)p + GC_bytes_per_word, 0,
+		       GC_bytes_per_word * (nwords - 1));
+	        *flh = p;
+	        GC_aux::GC_mem_recently_freed += nwords;
+	    }
+	}
+	static void ptr_free_deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes) {
+		GC_free(p);
+	    } else {
+	    	flh = GC_aobjfreelist_ptr + nwords;
+	    	GC_obj_link(p) = *flh;
+	    	*flh = p;
+	    	GC_aux::GC_mem_recently_freed += nwords;
+	    }
+	}
+};
+
+typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
+
+// Once more, for uncollectable objects.
+template <int dummy>
+class single_client_alloc_template {
+    public:
+     	static void * allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up_uncollectable(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
+	    flh = GC_uobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+	    return op;
+        }
+     	static void * ptr_free_allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up_uncollectable(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
+	    flh = GC_auobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+	    return op;
+        }
+	static void deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes)  {
+		GC_free(p);
+	    } else {
+	        flh = GC_uobjfreelist_ptr + nwords;
+	        GC_obj_link(p) = *flh;
+	        *flh = p;
+	        GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+	    }
+	}
+	static void ptr_free_deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes) {
+		GC_free(p);
+	    } else {
+	    	flh = GC_auobjfreelist_ptr + nwords;
+	    	GC_obj_link(p) = *flh;
+	    	*flh = p;
+	    	GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+	    }
+	}
+};
+
+typedef single_client_alloc_template<0> single_client_alloc;
+
+template < int dummy >
+class gc_alloc_template {
+    public:
+     	static void * allocate(size_t n) { return GC_malloc(n); }
+     	static void * ptr_free_allocate(size_t n)
+		{ return GC_malloc_atomic(n); }
+	static void deallocate(void *p, size_t n) { }
+	static void ptr_free_deallocate(void *p, size_t n) { }
+};
+
+typedef gc_alloc_template < 0 > gc_alloc;
+
+template < int dummy >
+class alloc_template {
+    public:
+     	static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
+     	static void * ptr_free_allocate(size_t n)
+		{ return GC_malloc_atomic_uncollectable(n); }
+	static void deallocate(void *p, size_t n) { GC_free(p); }
+	static void ptr_free_deallocate(void *p, size_t n) { GC_free(p); }
+};
+
+typedef alloc_template < 0 > alloc;
+
+#ifdef _SGI_SOURCE
+
+// We want to specialize simple_alloc so that it does the right thing
+// for all pointerfree types.  At the moment there is no portable way to
+// even approximate that.  The following approximation should work for
+// SGI compilers, and perhaps some others.
+
+# define __GC_SPECIALIZE(T,alloc) \
+class simple_alloc<T, alloc> { \
+public: \
+    static T *allocate(size_t n) \
+	{ return 0 == n? 0 : \
+			 (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
+    static T *allocate(void) \
+	{ return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
+    static void deallocate(T *p, size_t n) \
+	{ if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
+    static void deallocate(T *p) \
+	{ alloc::ptr_free_deallocate(p, sizeof (T)); } \
+};
+
+__GC_SPECIALIZE(char, gc_alloc)
+__GC_SPECIALIZE(int, gc_alloc)
+__GC_SPECIALIZE(unsigned, gc_alloc)
+__GC_SPECIALIZE(float, gc_alloc)
+__GC_SPECIALIZE(double, gc_alloc)
+
+__GC_SPECIALIZE(char, alloc)
+__GC_SPECIALIZE(int, alloc)
+__GC_SPECIALIZE(unsigned, alloc)
+__GC_SPECIALIZE(float, alloc)
+__GC_SPECIALIZE(double, alloc)
+
+__GC_SPECIALIZE(char, single_client_gc_alloc)
+__GC_SPECIALIZE(int, single_client_gc_alloc)
+__GC_SPECIALIZE(unsigned, single_client_gc_alloc)
+__GC_SPECIALIZE(float, single_client_gc_alloc)
+__GC_SPECIALIZE(double, single_client_gc_alloc)
+
+__GC_SPECIALIZE(char, single_client_alloc)
+__GC_SPECIALIZE(int, single_client_alloc)
+__GC_SPECIALIZE(unsigned, single_client_alloc)
+__GC_SPECIALIZE(float, single_client_alloc)
+__GC_SPECIALIZE(double, single_client_alloc)
+
+#endif _SGI_SOURCE
+
+#endif /* GC_ALLOC_H */
diff --git a/src/mzscheme/gc/gc_cpp.cc b/src/mzscheme/gc/gc_cpp.cc
new file mode 100644
index 0000000..86417d3
--- /dev/null
+++ b/src/mzscheme/gc/gc_cpp.cc
@@ -0,0 +1,79 @@
+/*************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+    Last modified on Sat Nov 19 19:31:14 PST 1994 by ellis
+                  on Sat Jun  8 15:10:00 PST 1994 by boehm
+
+Permission is hereby granted to copy this code for any purpose,
+provided the above notices are retained on all copies.
+
+This implementation module for gc_c++.h provides an implementation of
+the global operators "new" and "delete" that calls the Boehm
+allocator.  All objects allocated by this implementation will be
+non-collectable but part of the root set of the collector.
+
+You should ensure (using implementation-dependent techniques) that the
+linker finds this module before the library that defines the default
+built-in "new" and "delete".
+
+Authors: John R. Ellis and Jesse Hull
+
+MATTHEW: This file is greatly modified from the distributed version
+for MrEd
+
+**************************************************************************/
+/* Boehm, December 20, 1994 7:26 pm PST */
+
+#include "gc_cpp.h"
+
+/* Zeroing object doesn't seem to make a difference: */
+#if 0
+void GC_cpp_delete( void* obj ) 
+{
+  if (obj) {
+    void *b = (void *)GC_base(obj);
+    
+    if (b == obj) {
+      *(long *)b = 0x23051423;
+
+      size_t l = GC_size(b);
+      
+      memset(b, 0, l);
+    }
+  }
+}
+#endif
+
+void* operator new( size_t size ) {
+  /* MATTHEW: Collect everything.*/
+  return GC_MALLOC /* _UNCOLLECTABLE */ ( size );
+}
+  
+void operator delete( void* obj ) {
+  /* MATTHEW: No GC_FREE */
+#if 0
+  GC_cpp_delete(obj);
+#endif
+}
+  
+
+#ifdef OPERATOR_NEW_ARRAY
+
+void* operator new[]( size_t size ) {
+  /* MATTHEW: Collect everything.*/
+  return GC_MALLOC /* _UNCOLLECTABLE */( size );
+}
+  
+void operator delete[]( void* obj ) {
+  /* MATTHEW: No GC_FREE */
+#if 0
+  GC_cpp_delete(obj);
+#endif
+}
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+
diff --git a/src/mzscheme/gc/gc_cpp.h b/src/mzscheme/gc/gc_cpp.h
new file mode 100644
index 0000000..58a2b35
--- /dev/null
+++ b/src/mzscheme/gc/gc_cpp.h
@@ -0,0 +1,334 @@
+#ifndef GC_CPP_H
+#define GC_CPP_H
+#if 0
+/****************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+Permission is hereby granted to use or copy this program for any
+purpose, provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is
+granted, provided the above notices are retained, and a notice that
+the code was modified is included with the above copyright notice.
+****************************************************************************
+
+C++ Interface to the Boehm Collector
+
+    John R. Ellis and Jesse Hull 
+    Last modified on Wed Jan  4 16:30:20 PST 1995 by ellis
+
+MATTHEW: This file is greatly modified from the distributed version
+for MrEd
+
+This interface provides access to the Boehm collector.  It provides
+basic facilities similar to those described in "Safe, Efficient
+Garbage Collection for C++", by John R. Elis and David L. Detlefs
+(ftp.parc.xerox.com:/pub/ellis/gc).
+
+All heap-allocated objects are either "collectable" or
+"uncollectable".  Programs must explicitly delete uncollectable
+objects, whereas the garbage collector will automatically delete
+collectable objects when it discovers them to be inaccessible.
+Collectable objects may freely point at uncollectable objects and vice
+versa.
+
+Objects allocated with the built-in "::operator new" are uncollectable.
+
+Objects derived from class "gc" are collectable.  For example:
+
+    class A: gc {...};
+    A* a = new A;       // a is collectable. 
+
+Collectable instances of non-class types can be allocated using the GC
+placement:
+
+    typedef int A[ 10 ];
+    A* a = new (GC) A;
+
+Uncollectable instances of classes derived from "gc" can be allocated
+using the NoGC placement:
+
+    class A: gc {...};
+    A* a = new (NoGC) A;   // a is uncollectable.
+
+Both uncollectable and collectable objects can be explicitly deleted
+with "delete", which invokes an object's destructors and frees its
+storage immediately.
+
+A collectable object may have a clean-up function, which will be
+invoked when the collector discovers the object to be inaccessible.
+An object derived from "gc_cleanup" or containing a member derived
+from "gc_cleanup" has a default clean-up function that invokes the
+object's destructors.  Explicit clean-up functions may be specified as
+an additional placement argument:
+
+    A* a = ::new (GC, MyCleanup) A;
+
+An object is considered "accessible" by the collector if it can be
+reached by a path of pointers from static variables, automatic
+variables of active functions, or from some object with clean-up
+enabled; pointers from an object to itself are ignored.
+
+Thus, if objects A and B both have clean-up functions, and A points at
+B, B is considered accessible.  After A's clean-up is invoked and its
+storage released, B will then become inaccessible and will have its
+clean-up invoked.  If A points at B and B points to A, forming a
+cycle, then that's considered a storage leak, and neither will be
+collectable.  See the interface gc.h for low-level facilities for
+handling such cycles of objects with clean-up.
+
+The collector cannot guarrantee that it will find all inaccessible
+objects.  In practice, it finds almost all of them.
+
+
+Cautions:
+
+1. Be sure the collector has been augmented with "make c++".
+
+2.  If your compiler supports the new "operator new[]" syntax, then
+add -DOPERATOR_NEW_ARRAY to the Makefile.
+
+If your compiler doesn't support "operator new[]", beware that an
+array of type T, where T is derived from "gc", will by default be
+allocated as an uncollectable object.  Use the explicit GC placement
+to make the array collectable.  For example:
+
+    class A: gc {...};
+    A* a1 = new A[ 10 ];        // uncollectable
+    A* a2 = new (GC) A[ 10 ];   // collectable
+
+3. Arrays of objects derived from "gc_cleanup" do not have default
+clean-up functions.  For example:
+
+    class A: gc_cleanup {...};
+    A* a = new (GC) A[ 10 ];
+
+The elements of "a" will not have their destructors invoked when the
+collector frees "a".  You must supply an explicit clean-up function
+for that to occur.
+
+4. Compiler bugs:
+
+    Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the
+    destructors of classes derived from gc_cleanup won't be invoked.
+    You'll have to explicitly register a clean-up function with
+    new-placement syntax.
+
+    Evidently cfront 3.0 does not allow destructors to be explicitly
+    invoked using the ANSI-conforming syntax t->~T().  If you're using
+    cfront 3.0, you'll have to comment out the class gc_cleanup, which
+    uses explicit invocation.
+
+****************************************************************************/
+#endif
+
+#include "gc.h"
+
+#ifndef THINK_CPLUS
+#define _cdecl
+#endif
+
+#if __BORLANDC__ >= 0x450 && !defined(OPERATOR_NEW_ARRAY)
+#   define OPERATOR_NEW_ARRAY
+#endif
+
+/* MATTHEW: GC => UseGC, Added AtomicGC */
+enum GCPlacement {UseGC, AtomicGC, NoGC};
+
+class gc {public:
+    inline void* operator new( size_t size );
+    inline void* operator new( size_t size, GCPlacement gcp );
+    inline void operator delete( void* obj );
+
+#ifdef OPERATOR_NEW_ARRAY
+    inline void* operator new[]( size_t size );
+    inline void* operator new[]( size_t size, GCPlacement gcp );
+    inline void operator delete[]( void* obj );
+#endif /* OPERATOR_NEW_ARRAY */
+    };    
+    /*
+    Instances of classes derived from "gc" will be allocated in the 
+    collected heap by default, unless an explicit NoGC placement is
+    specified. */
+
+/* MATTHEW: gcc 2.5.8 doesn't like "virtual" here: */
+class gc_cleanup: /* virtual */ public gc {public:
+    void *__gc_external; /* MATTHEW: Need a pointer for MzScheme/MrEd */					    
+    inline gc_cleanup();
+    inline gc_cleanup(int cleanup);
+    inline virtual ~gc_cleanup();
+    inline void install_cleanup();
+private:
+    inline static void _cdecl cleanup( void* obj, void* clientData );
+};
+    /*
+    Instances of classes derived from "gc_cleanup" will be allocated
+    in the collected heap by default.  When the collector discovers an
+    inaccessible object derived from "gc_cleanup" or containing a
+    member derived from "gc_cleanup", its destructors will be
+    invoked. */
+
+extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    Allocates a collectable or uncollected object, according to the
+    value of "gcp".
+
+    For collectable objects, if "cleanup" is non-null, then when the
+    allocated object "obj" becomes inaccessible, the collector will
+    invoke the function "cleanup( obj, clientData )" but will not
+    invoke the object's destructors.  It is an error to explicitly
+    delete an object allocated with a non-null "cleanup".
+
+    It is an error to specify a non-null "cleanup" with NoGC or for
+    classes derived from "gc_cleanup" or containing members derived
+    from "gc_cleanup". */
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[](
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    The operator new for arrays, identical to the above. */
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+/****************************************************************************
+
+Inline implementation
+
+****************************************************************************/
+inline void* gc::operator new( size_t size ) {
+    return GC_MALLOC( size );
+}
+    
+inline void* gc::operator new( size_t size, GCPlacement gcp ) {
+  /* MATTHEW: Added AtomicGC */
+  if (gcp == AtomicGC) 
+    return GC_MALLOC_ATOMIC( size );
+  else if (gcp == UseGC) 
+    return GC_MALLOC( size );
+  else
+    return GC_MALLOC_UNCOLLECTABLE( size );
+}
+
+#if 0
+/* MATTHEW */
+extern void GC_cpp_delete(void *);
+#endif
+
+inline void gc::operator delete( void * /* obj */) {
+  /* MATTHEW: Don't GC_free */
+#if 0
+  GC_cpp_delete(obj); /* zero it */
+#endif
+}
+    
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* gc::operator new[]( size_t size ) {
+    return gc::operator new(size);
+}
+    
+inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
+    return gc::operator new(size, gcp);
+}
+
+inline void gc::operator delete[]( void* obj ) {
+    gc::operator delete( obj );
+}
+    
+#endif /* OPERATOR_NEW_ARRAY */
+
+extern "C" {
+  extern void gc_mark_external_invalid(void *);
+};
+
+inline gc_cleanup::~gc_cleanup(void) {
+  GC_REGISTER_FINALIZER_IGNORE_SELF(this, 0, 0, 0, 0);
+  if (__gc_external) gc_mark_external_invalid(__gc_external);
+}
+
+inline void gc_cleanup::cleanup( void* obj, void* displ ) {
+  gc_cleanup *clean = ((gc_cleanup*) ((char *)obj + (ptrdiff_t)displ));
+  clean->~gc_cleanup();
+#if 0
+  GC_cpp_delete((void *)obj); /* zero it */
+#endif
+}
+
+inline void gc_cleanup::install_cleanup(void) {
+  register void *base = GC_base((void *)this);
+
+  if (base) {
+    GC_finalization_proc old_fn;
+    void *old_data;
+    GC_REGISTER_FINALIZER_IGNORE_SELF(base, cleanup,
+				      (void *)((char *)this - (char *)base), 
+				      &old_fn, &old_data);
+    if (old_fn)
+      /* MATTHEW: Put the old one back. We don't need to register. */
+      GC_REGISTER_FINALIZER_IGNORE_SELF(base, old_fn, old_data, 
+					&old_fn, &old_data);
+  }
+}
+
+inline gc_cleanup::gc_cleanup(void) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  install_cleanup();
+}
+
+inline gc_cleanup::gc_cleanup(int cleanup) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  if (cleanup)
+    install_cleanup();
+}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+  void* obj;
+  
+  if (gcp == UseGC) { /* MATTHEW: GC => UseGC */
+    obj = GC_MALLOC(size);
+    if (cleanup != 0) 
+      GC_REGISTER_FINALIZER_IGNORE_SELF(obj, cleanup, clientData, 0, 0);
+  } if (gcp == AtomicGC) /* MATTHEW: Added AtomicGC */
+    obj = GC_MALLOC_ATOMIC( size );
+  else
+    obj = GC_MALLOC_UNCOLLECTABLE( size );
+
+  return obj;
+}
+        
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[]( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+    return ::operator new( size, gcp, cleanup, clientData );
+  }
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+
+#endif /* GC_CPP_H */
+
diff --git a/src/mzscheme/gc/gc_hdrs.h b/src/mzscheme/gc/gc_hdrs.h
new file mode 100644
index 0000000..2f2d1bf
--- /dev/null
+++ b/src/mzscheme/gc/gc_hdrs.h
@@ -0,0 +1,133 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, July 11, 1995 11:54 am PDT */
+# ifndef GC_HEADERS_H
+# define GC_HEADERS_H
+typedef struct hblkhdr hdr;
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ < 36
+	--> Get a real machine.
+# endif
+
+/*
+ * The 2 level tree data structure that is used to find block headers.
+ * If there are more than 32 bits in a pointer, the top level is a hash
+ * table.
+ */
+
+# if CPP_WORDSZ > 32
+#   define HASH_TL
+# endif
+
+/* Define appropriate out-degrees for each of the two tree levels	*/
+# ifdef SMALL_CONFIG
+#   define LOG_BOTTOM_SZ 11
+	/* Keep top index size reasonable with smaller blocks. */
+# else
+#   define LOG_BOTTOM_SZ 10
+# endif
+# ifndef HASH_TL
+#   define LOG_TOP_SZ (WORDSZ - LOG_BOTTOM_SZ - LOG_HBLKSIZE)
+# else
+#   define LOG_TOP_SZ 11
+# endif
+# define TOP_SZ (1 << LOG_TOP_SZ)
+# define BOTTOM_SZ (1 << LOG_BOTTOM_SZ)
+
+typedef struct bi {
+    hdr * index[BOTTOM_SZ];
+	/*
+ 	 * The bottom level index contains one of three kinds of values:
+	 * 0 means we're not responsible for this block.
+	 * 1 < (long)X <= MAX_JUMP means the block starts at least
+	 *        X * HBLKSIZE bytes before the current address.
+	 * A valid pointer points to a hdr structure. (The above can't be
+	 * valid pointers due to the GET_MEM return convention.)
+	 */
+    struct bi * asc_link;	/* All indices are linked in	*/
+    				/* ascending order.		*/
+    word key;			/* high order address bits.	*/
+# ifdef HASH_TL
+    struct bi * hash_link;	/* Hash chain link.		*/
+# endif
+} bottom_index;
+
+/* extern bottom_index GC_all_nils; - really part of GC_arrays */
+
+/* extern bottom_index * GC_top_index []; - really part of GC_arrays */
+				/* Each entry points to a bottom_index.	*/
+				/* On a 32 bit machine, it points to 	*/
+				/* the index for a set of high order	*/
+				/* bits equal to the index.  For longer	*/
+				/* addresses, we hash the high order	*/
+				/* bits to compute the index in 	*/
+				/* GC_top_index, and each entry points	*/
+				/* to a hash chain.			*/
+				/* The last entry in each chain is	*/
+				/* GC_all_nils.				*/
+
+
+# define MAX_JUMP (HBLKSIZE - 1)
+
+# define HDR_FROM_BI(bi, p) \
+		((bi)->index[((word)(p) >> LOG_HBLKSIZE) & (BOTTOM_SZ - 1)])
+# ifndef HASH_TL
+#   define BI(p) (GC_top_index \
+		[(word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE)])
+#   define HDR_INNER(p) HDR_FROM_BI(BI(p),p)
+#   ifdef SMALL_CONFIG
+#	define HDR(p) GC_find_header((ptr_t)(p))
+#   else
+#	define HDR(p) HDR_INNER(p)
+#   endif
+#   define GET_BI(p, bottom_indx) (bottom_indx) = BI(p)
+#   define GET_HDR(p, hhdr) (hhdr) = HDR(p)
+#   define SET_HDR(p, hhdr) HDR_INNER(p) = (hhdr)
+#   define GET_HDR_ADDR(p, ha) (ha) = &(HDR_INNER(p))
+# else /* hash */
+/*  Hash function for tree top level */
+#   define TL_HASH(hi) ((hi) & (TOP_SZ - 1))
+/*  Set bottom_indx to point to the bottom index for address p */
+#   define GET_BI(p, bottom_indx) \
+	{ \
+	    register word hi = \
+	        (word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); \
+	    register bottom_index * _bi = GC_top_index[TL_HASH(hi)]; \
+	    \
+	    while (_bi -> key != hi && _bi != GC_all_nils) \
+	    	_bi = _bi -> hash_link; \
+	    (bottom_indx) = _bi; \
+	}
+#   define GET_HDR_ADDR(p, ha) \
+	{ \
+	    register bottom_index * bi; \
+	    \
+	    GET_BI(p, bi);	\
+	    (ha) = &(HDR_FROM_BI(bi, p)); \
+	}
+#   define GET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
+			      (hhdr) = *_ha; }
+#   define SET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
+			      *_ha = (hhdr); }
+#   define HDR(p) GC_find_header((ptr_t)(p))
+# endif
+			    
+/* Is the result a forwarding address to someplace closer to the	*/
+/* beginning of the block or NIL?					*/
+# define IS_FORWARDING_ADDR_OR_NIL(hhdr) ((unsigned long) (hhdr) <= MAX_JUMP)
+
+/* Get an HBLKSIZE aligned address closer to the beginning of the block */
+/* h.  Assumes hhdr == HDR(h) and IS_FORWARDING_ADDR(hhdr).		*/
+# define FORWARDED_ADDR(h, hhdr) ((struct hblk *)(h) - (unsigned long)(hhdr))
+# endif /*  GC_HEADERS_H */
diff --git a/src/mzscheme/gc/gc_mark.h b/src/mzscheme/gc/gc_mark.h
new file mode 100644
index 0000000..72c3854
--- /dev/null
+++ b/src/mzscheme/gc/gc_mark.h
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+/* Boehm, November 7, 1994 4:56 pm PST */
+
+/*
+ * Declarations of mark stack.  Needed by marker and client supplied mark
+ * routines.  To be included after gc_priv.h.
+ */
+#ifndef GC_MARK_H
+# define GC_MARK_H
+
+/* A client supplied mark procedure.  Returns new mark stack pointer.	*/
+/* Primary effect should be to push new entries on the mark stack.	*/
+/* Mark stack pointer values are passed and returned explicitly.	*/
+/* Global variables decribing mark stack are not necessarily valid.	*/
+/* (This usually saves a few cycles by keeping things in registers.)	*/
+/* Assumed to scan about PROC_BYTES on average.  If it needs to do	*/
+/* much more work than that, it should do it in smaller pieces by	*/
+/* pushing itself back on the mark stack.				*/
+/* Note that it should always do some work (defined as marking some	*/
+/* objects) before pushing more than one entry on the mark stack.	*/
+/* This is required to ensure termination in the event of mark stack	*/
+/* overflows.								*/
+/* This procedure is always called with at least one empty entry on the */
+/* mark stack.								*/
+/* Currently we require that mark procedures look for pointers in a	*/
+/* subset of the places the conservative marker would.  It must be safe	*/
+/* to invoke the normal mark procedure instead.				*/
+# define PROC_BYTES 100
+typedef struct ms_entry * (*mark_proc)(/* word * addr, mark_stack_ptr,
+					  mark_stack_limit, env */);
+					  
+# define LOG_MAX_MARK_PROCS 6
+# define MAX_MARK_PROCS (1 << LOG_MAX_MARK_PROCS)
+extern mark_proc GC_mark_procs[MAX_MARK_PROCS];
+extern word GC_n_mark_procs;
+
+/* Object descriptors on mark stack or in objects.  Low order two	*/
+/* bits are tags distinguishing among the following 4 possibilities	*/
+/* for the high order 30 bits.						*/
+#define DS_TAG_BITS 2
+#define DS_TAGS   ((1 << DS_TAG_BITS) - 1)
+#define DS_LENGTH 0	/* The entire word is a length in bytes that	*/
+			/* must be a multiple of 4.			*/
+#define DS_BITMAP 1	/* 30 bits are a bitmap describing pointer	*/
+			/* fields.  The msb is 1 iff the first word	*/
+			/* is a pointer.				*/
+			/* (This unconventional ordering sometimes	*/
+			/* makes the marker slightly faster.)		*/
+			/* Zeroes indicate definite nonpointers.  Ones	*/
+			/* indicate possible pointers.			*/
+			/* Only usable if pointers are word aligned.	*/
+#   define BITMAP_BITS (WORDSZ - DS_TAG_BITS)
+#define DS_PROC   2
+			/* The objects referenced by this object can be */
+			/* pushed on the mark stack by invoking		*/
+			/* PROC(descr).  ENV(descr) is passed as the	*/
+			/* last argument.				*/
+#   define PROC(descr) \
+		(GC_mark_procs[((descr) >> DS_TAG_BITS) & (MAX_MARK_PROCS-1)])
+#   define ENV(descr) \
+		((descr) >> (DS_TAG_BITS + LOG_MAX_MARK_PROCS))
+#   define MAX_ENV \
+  	      (((word)1 << (WORDSZ - DS_TAG_BITS - LOG_MAX_MARK_PROCS)) - 1)
+#   define MAKE_PROC(proc_index, env) \
+	    (((((env) << LOG_MAX_MARK_PROCS) | (proc_index)) << DS_TAG_BITS) \
+	    | DS_PROC)
+#define DS_PER_OBJECT 3	/* The real descriptor is at the		*/
+			/* byte displacement from the beginning of the	*/
+			/* object given by descr & ~DS_TAGS		*/
+			
+typedef struct ms_entry {
+    word * mse_start;   /* First word of object */
+    word mse_descr;	/* Descriptor; low order two bits are tags,	*/
+    			/* identifying the upper 30 bits as one of the	*/
+    			/* following:					*/
+} mse;
+
+extern word GC_mark_stack_size;
+
+extern mse * GC_mark_stack_top;
+
+extern mse * GC_mark_stack;
+
+word GC_find_start();
+
+mse * GC_signal_mark_stack_overflow();
+
+# ifdef GATHERSTATS
+#   define ADD_TO_ATOMIC(sz) GC_atomic_in_use += (sz)
+#   define ADD_TO_COMPOSITE(sz) GC_composite_in_use += (sz)
+# else
+#   define ADD_TO_ATOMIC(sz)
+#   define ADD_TO_COMPOSITE(sz)
+# endif
+
+/* Push the object obj with corresponding heap block header hhdr onto 	*/
+/* the mark stack.							*/
+# define PUSH_OBJ(obj, hhdr, mark_stack_top, mark_stack_limit) \
+{ \
+    register word _descr = (hhdr) -> hb_descr; \
+        \
+    if (_descr == 0) { \
+    	ADD_TO_ATOMIC((hhdr) -> hb_sz); \
+    } else { \
+        ADD_TO_COMPOSITE((hhdr) -> hb_sz); \
+        mark_stack_top++; \
+        if (mark_stack_top >= mark_stack_limit) { \
+          mark_stack_top = GC_signal_mark_stack_overflow(mark_stack_top); \
+        } \
+        mark_stack_top -> mse_start = (obj); \
+        mark_stack_top -> mse_descr = _descr; \
+    } \
+}
+
+/* Push the contenst of current onto the mark stack if it is a valid	*/
+/* ptr to a currently unmarked object.  Mark it.			*/
+# define PUSH_CONTENTS(current, mark_stack_top, mark_stack_limit) \
+{ \
+    register int displ;  /* Displacement in block; first bytes, then words */ \
+    register hdr * hhdr; \
+    register map_entry_type map_entry; \
+    \
+    GET_HDR(current,hhdr); \
+    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { \
+         current = GC_find_start(current, hhdr); \
+         if (current == 0) continue; \
+         hhdr = HDR(current); \
+    } \
+    displ = HBLKDISPL(current); \
+    map_entry = MAP_ENTRY((hhdr -> hb_map), displ); \
+    if (map_entry == OBJ_INVALID) { \
+        GC_ADD_TO_BLACK_LIST_NORMAL(current); continue; \
+    } \
+    displ = BYTES_TO_WORDS(displ); \
+    displ -= map_entry; \
+	\
+    { \
+        register word * mark_word_addr = hhdr -> hb_marks + divWORDSZ(displ); \
+        register word mark_word = *mark_word_addr; \
+        register word mark_bit = (word)1 << modWORDSZ(displ); \
+          \
+        if (mark_word & mark_bit) { \
+	      /* Mark bit is already set */ \
+	      continue; \
+        } \
+        *mark_word_addr = mark_word | mark_bit; \
+    } \
+    PUSH_OBJ(((word *)(HBLKPTR(current)) + displ), hhdr, \
+    	     mark_stack_top, mark_stack_limit) \
+}
+
+
+/*
+ * Push a single value onto mark stack. Mark from the object pointed to by p.
+ * GC_push_one is normally called by GC_push_regs, and thus must be defined.
+ * P is considered valid even if it is an interior pointer.
+ * Previously marked objects are not pushed.  Hence we make progress even
+ * if the mark stack overflows.
+ */
+# define GC_PUSH_ONE_STACK(p) \
+    if ((ptr_t)(p) >= GC_least_plausible_heap_addr 	\
+	 && (ptr_t)(p) < GC_greatest_plausible_heap_addr) {	\
+	 GC_push_one_checked(p,TRUE);	\
+    }
+
+/*
+ * As above, but interior pointer recognition as for
+ * normal for heap pointers.
+ */
+# ifdef ALL_INTERIOR_POINTERS
+#   define AIP TRUE
+# else
+#   define AIP FALSE
+# endif
+# define GC_PUSH_ONE_HEAP(p) \
+    if ((ptr_t)(p) >= GC_least_plausible_heap_addr 	\
+	 && (ptr_t)(p) < GC_greatest_plausible_heap_addr) {	\
+	 GC_push_one_checked(p,AIP);	\
+    }
+
+/*
+ * Mark from one finalizable object using the specified
+ * mark proc. May not mark the object pointed to by 
+ * real_ptr. That is the job of the caller, if appropriate
+ */
+# define GC_MARK_FO(real_ptr, mark_proc) \
+{ \
+    (*(mark_proc))(real_ptr); \
+    while (!GC_mark_stack_empty()) GC_mark_from_mark_stack(); \
+    if (GC_mark_state != MS_NONE) { \
+        GC_set_mark_bit(real_ptr); \
+        while (!GC_mark_some()); \
+    } \
+}
+
+extern bool GC_mark_stack_too_small;
+				/* We need a larger mark stack.  May be	*/
+				/* set by client supplied mark routines.*/
+
+typedef int mark_state_t;	/* Current state of marking, as follows:*/
+				/* Used to remember where we are during */
+				/* concurrent marking.			*/
+
+				/* We say something is dirty if it was	*/
+				/* written since the last time we	*/
+				/* retrieved dirty bits.  We say it's 	*/
+				/* grungy if it was marked dirty in the	*/
+				/* last set of bits we retrieved.	*/
+				
+				/* Invariant I: all roots and marked	*/
+				/* objects p are either dirty, or point */
+				/* objects q that are either marked or	*/
+				/* a pointer to q appears in a range	*/
+				/* on the mark stack.			*/
+
+# define MS_NONE 0		/* No marking in progress. I holds.	*/
+				/* Mark stack is empty.			*/
+
+# define MS_PUSH_RESCUERS 1	/* Rescuing objects are currently 	*/
+				/* being pushed.  I holds, except	*/
+				/* that grungy roots may point to 	*/
+				/* unmarked objects, as may marked	*/
+				/* grungy objects above scan_ptr.	*/
+
+# define MS_PUSH_UNCOLLECTABLE 2
+				/* I holds, except that marked 		*/
+				/* uncollectable objects above scan_ptr */
+				/* may point to unmarked objects.	*/
+				/* Roots may point to unmarked objects	*/
+
+# define MS_ROOTS_PUSHED 3	/* I holds, mark stack may be nonempty  */
+
+# define MS_PARTIALLY_INVALID 4	/* I may not hold, e.g. because of M.S. */
+				/* overflow.  However marked heap	*/
+				/* objects below scan_ptr point to	*/
+				/* marked or stacked objects.		*/
+
+# define MS_INVALID 5		/* I may not hold.			*/
+
+extern mark_state_t GC_mark_state;
+
+#endif  /* GC_MARK_H */
+
diff --git a/src/mzscheme/gc/gc_priv.h b/src/mzscheme/gc/gc_priv.h
new file mode 100644
index 0000000..58372ee
--- /dev/null
+++ b/src/mzscheme/gc/gc_priv.h
@@ -0,0 +1,1425 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 16, 1996 2:30 pm PST */
+ 
+
+# ifndef GC_PRIVATE_H
+# define GC_PRIVATE_H
+
+#if defined(mips) && defined(SYSTYPE_BSD) && defined(sony_news)
+    /* sony RISC NEWS, NEWSOS 4 */
+#   define BSD_TIME
+    typedef long ptrdiff_t;
+#endif
+
+#if defined(mips) && defined(SYSTYPE_BSD43)
+    /* MIPS RISCOS 4 */
+#   define BSD_TIME
+#endif
+
+#ifdef BSD_TIME
+#   include <sys/types.h>
+#   include <sys/time.h>
+#   include <sys/resource.h>
+#endif /* BSD_TIME */
+
+# ifndef GC_H
+#   include "gc.h"
+# endif
+
+typedef GC_word word;
+typedef GC_signed_word signed_word;
+
+# ifndef CONFIG_H
+#   include "config.h"
+# endif
+
+# ifndef HEADERS_H
+#   include "gc_hdrs.h"
+# endif
+
+# if !defined(bool) && !defined(__cplusplus)
+    typedef int bool;
+    /* This is problematic with C++ implementations that do not define bool. */
+    /* By now they should.						     */
+# else
+#   if defined(_SGI_SOURCE) && !defined(_BOOL)
+	typedef int bool;
+#   endif
+#   if defined(__cplusplus) && defined(_MSC_VER) && _MSC_VER <= 1020
+	/* Visual C++ 4.2 does not have bool type. */
+        typedef int bool;
+#   endif
+# endif
+# define TRUE 1
+# define FALSE 0
+
+typedef char * ptr_t;	/* A generic pointer to which we can add	*/
+			/* byte displacements.				*/
+			/* Preferably identical to caddr_t, if it 	*/
+			/* exists.					*/
+			
+#if defined(__STDC__)
+#   include <stdlib.h>
+#   if !(defined( sony_news ) )
+#       include <stddef.h>
+#   endif
+#   define VOLATILE volatile
+#   define CONST const
+#else
+#   ifdef MSWIN32
+#   	include <stdlib.h>
+#   endif
+#   define VOLATILE
+#   define CONST
+#endif
+
+#ifdef AMIGA
+#   define GC_FAR __far
+#else
+# if defined(__MC68K__)
+/* MATTHEW: Always put this as far data for Mac 68k */
+#    define GC_FAR far
+# else
+#    define GC_FAR
+# endif
+#endif
+
+/*********************************/
+/*                               */
+/* Definitions for conservative  */
+/* collector                     */
+/*                               */
+/*********************************/
+
+/*********************************/
+/*                               */
+/* Easily changeable parameters  */
+/*                               */
+/*********************************/
+
+#define STUBBORN_ALLOC	/* Define stubborn allocation primitives	*/
+#if defined(SRC_M3) || defined(SMALL_CONFIG)
+# undef STUBBORN_ALLOC
+#endif
+
+
+/* #define ALL_INTERIOR_POINTERS */
+		    /* Forces all pointers into the interior of an 	*/
+		    /* object to be considered valid.  Also causes the	*/
+		    /* sizes of all objects to be inflated by at least 	*/
+		    /* one byte.  This should suffice to guarantee	*/
+		    /* that in the presence of a compiler that does	*/
+		    /* not perform garbage-collector-unsafe		*/
+		    /* optimizations, all portable, strictly ANSI	*/
+		    /* conforming C programs should be safely usable	*/
+		    /* with malloc replaced by GC_malloc and free	*/
+		    /* calls removed.  There are several disadvantages: */
+		    /* 1. There are probably no interesting, portable,	*/
+		    /*    strictly ANSI	conforming C programs.		*/
+		    /* 2. This option makes it hard for the collector	*/
+		    /*    to allocate space that is not ``pointed to''  */
+		    /*    by integers, etc.  Under SunOS 4.X with a 	*/
+		    /*    statically linked libc, we empiricaly		*/
+		    /*    observed that it would be difficult to 	*/
+		    /*	  allocate individual objects larger than 100K.	*/
+		    /* 	  Even if only smaller objects are allocated,	*/
+		    /*    more swap space is likely to be needed.       */
+		    /*    Fortunately, much of this will never be	*/
+		    /*    touched.					*/
+		    /* If you can easily avoid using this option, do.	*/
+		    /* If not, try to keep individual objects small.	*/
+		    
+#define PRINTSTATS  /* Print garbage collection statistics          	*/
+		    /* For less verbose output, undefine in reclaim.c 	*/
+
+#define PRINTTIMES  /* Print the amount of time consumed by each garbage   */
+		    /* collection.                                         */
+
+#define PRINTBLOCKS /* Print object sizes associated with heap blocks,     */
+		    /* whether the objects are atomic or composite, and    */
+		    /* whether or not the block was found to be empty      */
+		    /* duing the reclaim phase.  Typically generates       */
+		    /* about one screenful per garbage collection.         */
+#undef PRINTBLOCKS
+
+#define PRINTBLACKLIST 	/* Print black listed blocks, i.e. values that     */
+			/* cause the allocator to avoid allocating certain */
+			/* blocks in order to avoid introducing "false	   */
+			/* hits".					   */
+#undef PRINTBLACKLIST
+
+#ifdef SILENT
+#  ifdef PRINTSTATS
+#    undef PRINTSTATS
+#  endif
+#  ifdef PRINTTIMES
+#    undef PRINTTIMES
+#  endif
+#  ifdef PRINTNBLOCKS
+#    undef PRINTNBLOCKS
+#  endif
+#endif
+
+#if defined(PRINTSTATS) && !defined(GATHERSTATS)
+#   define GATHERSTATS
+#endif
+
+#define MERGE_SIZES /* Round up some object sizes, so that fewer distinct */
+		    /* free lists are actually maintained.  This applies  */
+		    /* only to the top level routines in misc.c, not to   */
+		    /* user generated code that calls GC_allocobj and     */
+		    /* GC_allocaobj directly.                             */
+		    /* Slows down average programs slightly.  May however */
+		    /* substantially reduce fragmentation if allocation   */
+		    /* request sizes are widely scattered.                */
+		    /* May save significant amounts of space for obj_map  */
+		    /* entries.						  */
+
+/* ALIGN_DOUBLE requires MERGE_SIZES at present. */
+# if defined(ALIGN_DOUBLE) && !defined(MERGE_SIZES)
+#   define MERGE_SIZES
+# endif
+
+#if defined(ALL_INTERIOR_POINTERS) && !defined(DONT_ADD_BYTE_AT_END)
+# define ADD_BYTE_AT_END
+#endif
+
+
+# ifndef LARGE_CONFIG
+#   define MINHINCR 16	/* Minimum heap increment, in blocks of HBLKSIZE  */
+#   define MAXHINCR 512	/* Maximum heap increment, in blocks              */
+# else
+#   define MINHINCR 64
+#   define MAXHINCR 4096
+# endif
+
+# define TIME_LIMIT 50	   /* We try to keep pause times from exceeding	 */
+			   /* this by much. In milliseconds.		 */
+
+# define BL_LIMIT GC_black_list_spacing
+			   /* If we need a block of N bytes, and we have */
+			   /* a block of N + BL_LIMIT bytes available, 	 */
+			   /* and N > BL_LIMIT,				 */
+			   /* but all possible positions in it are 	 */
+			   /* blacklisted, we just use it anyway (and	 */
+			   /* print a warning, if warnings are enabled). */
+			   /* This risks subsequently leaking the block	 */
+			   /* due to a false reference.  But not using	 */
+			   /* the block risks unreasonable immediate	 */
+			   /* heap growth.				 */
+
+/*********************************/
+/*                               */
+/* Stack saving for debugging	 */
+/*                               */
+/*********************************/
+
+/*
+ * Number of frames and arguments to save in objects allocated by
+ * debugging allocator.
+ */
+#   define NFRAMES 6	/* Number of frames to save. Even for		*/
+			/* alignment reasons.				*/
+#   define NARGS 2	/* Mumber of arguments to save for each call.	*/
+
+
+#ifdef SAVE_CALL_CHAIN
+    struct callinfo {
+	word ci_pc;
+	word ci_arg[NARGS];	/* bit-wise complement to avoid retention */
+    };
+
+/* Fill in the pc and argument information for up to NFRAMES of my	*/
+/* callers.  Ignore my frame and my callers frame.			*/
+void GC_save_callers (/* struct callinfo info[NFRAMES] */);
+
+void GC_print_callers (/* struct callinfo info[NFRAMES] */);
+
+#endif
+
+
+/*********************************/
+/*                               */
+/* OS interface routines	 */
+/*                               */
+/*********************************/
+
+#ifdef BSD_TIME
+#   undef CLOCK_TYPE
+#   undef GET_TIME
+#   undef MS_TIME_DIFF
+#   define CLOCK_TYPE struct timeval
+#   define GET_TIME(x) { struct rusage rusage; \
+			 getrusage (RUSAGE_SELF,  &rusage); \
+			 x = rusage.ru_utime; }
+#   define MS_TIME_DIFF(a,b) ((double) (a.tv_sec - b.tv_sec) * 1000.0 \
+                               + (double) (a.tv_usec - b.tv_usec) / 1000.0)
+#else /* !BSD_TIME */
+#   include <time.h>
+#   if !defined(__STDC__) && defined(SPARC) && defined(SUNOS4)
+      clock_t clock();	/* Not in time.h, where it belongs	*/
+#   endif
+#   if defined(FREEBSD) && !defined(CLOCKS_PER_SEC)
+#     include <machine/limits.h>
+#     define CLOCKS_PER_SEC CLK_TCK
+#   endif
+#   if !defined(CLOCKS_PER_SEC)
+#     define CLOCKS_PER_SEC 1000000
+/*
+ * This is technically a bug in the implementation.  ANSI requires that
+ * CLOCKS_PER_SEC be defined.  But at least under SunOS4.1.1, it isn't.
+ * Also note that the combination of ANSI C and POSIX is incredibly gross
+ * here. The type clock_t is used by both clock() and times().  But on
+ * some machines these use different notions of a clock tick,  CLOCKS_PER_SEC
+ * seems to apply only to clock.  Hence we use it here.  On many machines,
+ * including SunOS, clock actually uses units of microseconds (which are
+ * not really clock ticks).
+ */
+#   endif
+#   define CLOCK_TYPE clock_t
+#   define GET_TIME(x) x = clock()
+#   define MS_TIME_DIFF(a,b) ((unsigned long) \
+		(1000.0*(double)((a)-(b))/(double)CLOCKS_PER_SEC))
+#endif /* !BSD_TIME */
+
+/* We use bzero and bcopy internally.  They may not be available.	*/
+# if defined(SPARC) && defined(SUNOS4)
+#   define BCOPY_EXISTS
+# endif
+# if defined(M68K) && defined(AMIGA)
+#   define BCOPY_EXISTS
+# endif
+# if defined(M68K) && defined(NEXT)
+#   define BCOPY_EXISTS
+# endif
+# if defined(VAX)
+#   define BCOPY_EXISTS
+# endif
+# if defined(AMIGA)
+#   include <string.h>
+#   define BCOPY_EXISTS
+# endif
+
+# ifndef BCOPY_EXISTS
+#   include <string.h>
+#   define BCOPY(x,y,n) memcpy(y, x, (size_t)(n))
+#   define BZERO(x,n)  memset(x, 0, (size_t)(n))
+# else
+#   define BCOPY(x,y,n) bcopy((char *)(x),(char *)(y),(int)(n))
+#   define BZERO(x,n) bzero((char *)(x),(int)(n))
+# endif
+
+/* HBLKSIZE aligned allocation.  0 is taken to mean failure 	*/
+/* space is assumed to be cleared.				*/
+# ifdef PCR
+    char * real_malloc();
+#   define GET_MEM(bytes) HBLKPTR(real_malloc((size_t)bytes + HBLKSIZE) \
+				  + HBLKSIZE-1)
+# else
+#   ifdef OS2
+      void * os2_alloc(size_t bytes);
+#     define GET_MEM(bytes) HBLKPTR((ptr_t)os2_alloc((size_t)bytes + HBLKSIZE) \
+                                    + HBLKSIZE-1)
+#   else
+#     if defined(AMIGA) || defined(NEXT)
+#       define GET_MEM(bytes) HBLKPTR((size_t) \
+				      calloc(1, (size_t)bytes + HBLKSIZE) \
+                                      + HBLKSIZE-1)
+#     else
+#	ifdef MSWIN32
+          extern ptr_t GC_win32_get_mem();
+#         define GET_MEM(bytes) (struct hblk *)GC_win32_get_mem(bytes)
+#	else
+#	  ifdef MACOS
+#	    if defined(USE_TEMPORARY_MEMORY)
+		extern Ptr GC_MacTemporaryNewPtr(size_t size,
+						 Boolean clearMemory);
+#               define GET_MEM(bytes) HBLKPTR( \
+		    GC_MacTemporaryNewPtr(bytes + HBLKSIZE, true) + HBLKSIZE-1)
+#	    else
+#         	    define GET_MEM(bytes) HBLKPTR( \
+			NewPtrClear(bytes + HBLKSIZE) + HBLKSIZE-1)
+#	    endif
+#	  else
+            extern ptr_t GC_unix_get_mem();
+#           define GET_MEM(bytes) (struct hblk *)GC_unix_get_mem(bytes)
+#	  endif
+#	endif
+#     endif
+#   endif
+# endif
+
+/*
+ * Mutual exclusion between allocator/collector routines.
+ * Needed if there is more than one allocator thread.
+ * FASTLOCK() is assumed to try to acquire the lock in a cheap and
+ * dirty way that is acceptable for a few instructions, e.g. by
+ * inhibiting preemption.  This is assumed to have succeeded only
+ * if a subsequent call to FASTLOCK_SUCCEEDED() returns TRUE.
+ * FASTUNLOCK() is called whether or not FASTLOCK_SUCCEEDED().
+ * If signals cannot be tolerated with the FASTLOCK held, then
+ * FASTLOCK should disable signals.  The code executed under
+ * FASTLOCK is otherwise immune to interruption, provided it is
+ * not restarted.
+ * DCL_LOCK_STATE declares any local variables needed by LOCK and UNLOCK
+ * and/or DISABLE_SIGNALS and ENABLE_SIGNALS and/or FASTLOCK.
+ * (There is currently no equivalent for FASTLOCK.)
+ */  
+# ifdef THREADS
+#  ifdef PCR_OBSOLETE	/* Faster, but broken with multiple lwp's	*/
+#    include  "th/PCR_Th.h"
+#    include  "th/PCR_ThCrSec.h"
+     extern struct PCR_Th_MLRep GC_allocate_ml;
+#    define DCL_LOCK_STATE  PCR_sigset_t GC_old_sig_mask
+#    define LOCK() PCR_Th_ML_Acquire(&GC_allocate_ml) 
+#    define UNLOCK() PCR_Th_ML_Release(&GC_allocate_ml)
+#    define FASTLOCK() PCR_ThCrSec_EnterSys()
+     /* Here we cheat (a lot): */
+#        define FASTLOCK_SUCCEEDED() (*(int *)(&GC_allocate_ml) == 0)
+		/* TRUE if nobody currently holds the lock */
+#    define FASTUNLOCK() PCR_ThCrSec_ExitSys()
+#  endif
+#  ifdef PCR
+#    include <base/PCR_Base.h>
+#    include <th/PCR_Th.h>
+     extern PCR_Th_ML GC_allocate_ml;
+#    define DCL_LOCK_STATE \
+	 PCR_ERes GC_fastLockRes; PCR_sigset_t GC_old_sig_mask
+#    define LOCK() PCR_Th_ML_Acquire(&GC_allocate_ml)
+#    define UNLOCK() PCR_Th_ML_Release(&GC_allocate_ml)
+#    define FASTLOCK() (GC_fastLockRes = PCR_Th_ML_Try(&GC_allocate_ml))
+#    define FASTLOCK_SUCCEEDED() (GC_fastLockRes == PCR_ERes_okay)
+#    define FASTUNLOCK()  {\
+        if( FASTLOCK_SUCCEEDED() ) PCR_Th_ML_Release(&GC_allocate_ml); }
+#  endif
+#  ifdef SRC_M3
+     extern word RT0u__inCritical;
+#    define LOCK() RT0u__inCritical++
+#    define UNLOCK() RT0u__inCritical--
+#  endif
+#  ifdef SOLARIS_THREADS
+#    include <thread.h>
+#    include <signal.h>
+     extern mutex_t GC_allocate_ml;
+#    define LOCK() mutex_lock(&GC_allocate_ml);
+#    define UNLOCK() mutex_unlock(&GC_allocate_ml);
+#  endif
+#  ifdef IRIX_THREADS
+#    include <pthread.h>
+#    include <mutex.h>
+
+#    if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
+#         define __test_and_set(l,v) test_and_set(l,v)
+#    endif
+     extern unsigned long GC_allocate_lock;
+	/* This is not a mutex because mutexes that obey the (optional) 	*/
+	/* POSIX scheduling rules are subject to convoys in high contention	*/
+	/* applications.  This is basically a spin lock.			*/
+     extern pthread_t GC_lock_holder;
+     extern void GC_lock(void);
+	/* Allocation lock holder.  Only set if acquired by client through */
+	/* GC_call_with_alloc_lock.					   */
+#    define SET_LOCK_HOLDER() GC_lock_holder = pthread_self()
+#    define NO_THREAD (pthread_t)(-1)
+#    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
+#    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
+#    ifdef UNDEFINED
+#    	define LOCK() pthread_mutex_lock(&GC_allocate_ml)
+#    	define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
+#    else
+#	define LOCK() { if (__test_and_set(&GC_allocate_lock, 1)) GC_lock(); }
+#       if __mips >= 3 && (defined (_ABIN32) || defined(_ABI64))
+#	    define UNLOCK() __lock_release(lock)
+#	else
+#           define UNLOCK() GC_allocate_lock = 0
+#	endif
+#    endif
+     extern bool GC_collecting;
+#    define ENTER_GC() \
+		{ \
+		    GC_collecting = 1; \
+		}
+#    define EXIT_GC() GC_collecting = 0;
+#  endif
+#  ifdef WIN32_THREADS
+#    include <windows.h>
+     GC_API CRITICAL_SECTION GC_allocate_ml;
+#    define LOCK() EnterCriticalSection(&GC_allocate_ml);
+#    define UNLOCK() LeaveCriticalSection(&GC_allocate_ml);
+#  endif
+#  ifndef SET_LOCK_HOLDER
+#      define SET_LOCK_HOLDER()
+#      define UNSET_LOCK_HOLDER()
+#      define I_HOLD_LOCK() FALSE
+		/* Used on platforms were locks can be reacquired,	*/
+		/* so it doesn't matter if we lie.			*/
+#  endif
+# else
+#    define LOCK()
+#    define UNLOCK()
+# endif
+# ifndef SET_LOCK_HOLDER
+#   define SET_LOCK_HOLDER()
+#   define UNSET_LOCK_HOLDER()
+#   define I_HOLD_LOCK() FALSE
+		/* Used on platforms were locks can be reacquired,	*/
+		/* so it doesn't matter if we lie.			*/
+# endif
+# ifndef ENTER_GC
+#   define ENTER_GC()
+#   define EXIT_GC()
+# endif
+
+# ifndef DCL_LOCK_STATE
+#   define DCL_LOCK_STATE
+# endif
+# ifndef FASTLOCK
+#   define FASTLOCK() LOCK()
+#   define FASTLOCK_SUCCEEDED() TRUE
+#   define FASTUNLOCK() UNLOCK()
+# endif
+
+/* Delay any interrupts or signals that may abort this thread.  Data	*/
+/* structures are in a consistent state outside this pair of calls.	*/
+/* ANSI C allows both to be empty (though the standard isn't very	*/
+/* clear on that point).  Standard malloc implementations are usually	*/
+/* neither interruptable nor thread-safe, and thus correspond to	*/
+/* empty definitions.							*/
+# ifdef PCR
+#   define DISABLE_SIGNALS() \
+		 PCR_Th_SetSigMask(PCR_allSigsBlocked,&GC_old_sig_mask)
+#   define ENABLE_SIGNALS() \
+		PCR_Th_SetSigMask(&GC_old_sig_mask, NIL)
+# else
+#   if defined(SRC_M3) || defined(AMIGA) || defined(SOLARIS_THREADS) \
+	|| defined(MSWIN32) || defined(MACOS) || defined(DJGPP) \
+	|| defined(NO_SIGNALS) || defined(IRIX_THREADS)
+			/* Also useful for debugging.		*/
+	/* Should probably use thr_sigsetmask for SOLARIS_THREADS. */
+#     define DISABLE_SIGNALS()
+#     define ENABLE_SIGNALS()
+#   else
+#     define DISABLE_SIGNALS() GC_disable_signals()
+	void GC_disable_signals();
+#     define ENABLE_SIGNALS() GC_enable_signals()
+	void GC_enable_signals();
+#   endif
+# endif
+
+/*
+ * Stop and restart mutator threads.
+ */
+# ifdef PCR
+#     include "th/PCR_ThCtl.h"
+#     define STOP_WORLD() \
+ 	PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_stopNormal, \
+ 				   PCR_allSigsBlocked, \
+ 				   PCR_waitForever)
+#     define START_WORLD() \
+	PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_null, \
+ 				   PCR_allSigsBlocked, \
+ 				   PCR_waitForever);
+# else
+#   if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(IRIX_THREADS)
+      void GC_stop_world();
+      void GC_start_world();
+#     define STOP_WORLD() GC_stop_world()
+#     define START_WORLD() GC_start_world()
+#   else
+#     define STOP_WORLD()
+#     define START_WORLD()
+#   endif
+# endif
+
+/* Abandon ship */
+# ifdef PCR
+#   define ABORT(s) PCR_Base_Panic(s)
+# else
+#   ifdef SMALL_CONFIG
+#	define ABORT(msg) abort();
+#   else
+	GC_API void GC_abort();
+#       define ABORT(msg) GC_abort(msg);
+#   endif
+# endif
+
+/* Exit abnormally, but without making a mess (e.g. out of memory) */
+# ifdef PCR
+#   define EXIT() PCR_Base_Exit(1,PCR_waitForever)
+# else
+#   define EXIT() (void)exit(1)
+# endif
+
+/* Print warning message, e.g. almost out of memory.	*/
+# define WARN(msg,arg) (*GC_current_warn_proc)(msg, (GC_word)(arg))
+extern GC_warn_proc GC_current_warn_proc;
+
+/*********************************/
+/*                               */
+/* Word-size-dependent defines   */
+/*                               */
+/*********************************/
+
+#if CPP_WORDSZ == 32
+#  define WORDS_TO_BYTES(x)   ((x)<<2)
+#  define BYTES_TO_WORDS(x)   ((x)>>2)
+#  define LOGWL               ((word)5)    /* log[2] of CPP_WORDSZ */
+#  define modWORDSZ(n) ((n) & 0x1f)        /* n mod size of word	    */
+#  if ALIGNMENT != 4
+#	define UNALIGNED
+#  endif
+#endif
+
+#if CPP_WORDSZ == 64
+#  define WORDS_TO_BYTES(x)   ((x)<<3)
+#  define BYTES_TO_WORDS(x)   ((x)>>3)
+#  define LOGWL               ((word)6)    /* log[2] of CPP_WORDSZ */
+#  define modWORDSZ(n) ((n) & 0x3f)        /* n mod size of word	    */
+#  if ALIGNMENT != 8
+#	define UNALIGNED
+#  endif
+#endif
+
+#define WORDSZ ((word)CPP_WORDSZ)
+#define SIGNB  ((word)1 << (WORDSZ-1))
+#define BYTES_PER_WORD      ((word)(sizeof (word)))
+#define ONES                ((word)(-1))
+#define divWORDSZ(n) ((n) >> LOGWL)	   /* divide n by size of word      */
+
+/*********************/
+/*                   */
+/*  Size Parameters  */
+/*                   */
+/*********************/
+
+/*  heap block size, bytes. Should be power of 2 */
+
+#ifdef SMALL_CONFIG
+#   define CPP_LOG_HBLKSIZE 10
+#else
+# if CPP_WORDSZ == 32
+#   define CPP_LOG_HBLKSIZE 12
+# else
+#   define CPP_LOG_HBLKSIZE 13
+# endif
+#endif
+#define LOG_HBLKSIZE   ((word)CPP_LOG_HBLKSIZE)
+#define CPP_HBLKSIZE (1 << CPP_LOG_HBLKSIZE)
+#define HBLKSIZE ((word)CPP_HBLKSIZE)
+
+
+/*  max size objects supported by freelist (larger objects may be   */
+/*  allocated, but less efficiently)                                */
+
+#define CPP_MAXOBJSZ    BYTES_TO_WORDS(CPP_HBLKSIZE/2)
+#define MAXOBJSZ ((word)CPP_MAXOBJSZ)
+		
+# define divHBLKSZ(n) ((n) >> LOG_HBLKSIZE)
+
+# define HBLK_PTR_DIFF(p,q) divHBLKSZ((ptr_t)p - (ptr_t)q)
+	/* Equivalent to subtracting 2 hblk pointers.	*/
+	/* We do it this way because a compiler should	*/
+	/* find it hard to use an integer division	*/
+	/* instead of a shift.  The bundled SunOS 4.1	*/
+	/* o.w. sometimes pessimizes the subtraction to	*/
+	/* involve a call to .div.			*/
+ 
+# define modHBLKSZ(n) ((n) & (HBLKSIZE-1))
+ 
+# define HBLKPTR(objptr) ((struct hblk *)(((word) (objptr)) & ~(HBLKSIZE-1)))
+
+# define HBLKDISPL(objptr) (((word) (objptr)) & (HBLKSIZE-1))
+
+/* Round up byte allocation requests to integral number of words, etc. */
+# ifdef ADD_BYTE_AT_END
+#   define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1))
+#   ifdef ALIGN_DOUBLE
+#       define ALIGNED_WORDS(n) (BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2)) & ~1)
+#   else
+#       define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
+#   endif
+#   define SMALL_OBJ(bytes) ((bytes) < WORDS_TO_BYTES(MAXOBJSZ))
+#   define ADD_SLOP(bytes) ((bytes)+1)
+# else
+#   define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + (WORDS_TO_BYTES(1) - 1))
+#   ifdef ALIGN_DOUBLE
+#       define ALIGNED_WORDS(n) \
+			(BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2) - 1) & ~1)
+#   else
+#       define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
+#   endif
+#   define SMALL_OBJ(bytes) ((bytes) <= WORDS_TO_BYTES(MAXOBJSZ))
+#   define ADD_SLOP(bytes) (bytes)
+# endif
+
+
+/*
+ * Hash table representation of sets of pages.  This assumes it is
+ * OK to add spurious entries to sets.
+ * Used by black-listing code, and perhaps by dirty bit maintenance code.
+ */
+ 
+# ifdef LARGE_CONFIG
+#   define LOG_PHT_ENTRIES  17
+# else
+#   define LOG_PHT_ENTRIES  14	/* Collisions are likely if heap grows	*/
+				/* to more than 16K hblks = 64MB.	*/
+				/* Each hash table occupies 2K bytes.   */
+# endif
+# define PHT_ENTRIES ((word)1 << LOG_PHT_ENTRIES)
+# define PHT_SIZE (PHT_ENTRIES >> LOGWL)
+typedef word page_hash_table[PHT_SIZE];
+
+# define PHT_HASH(addr) ((((word)(addr)) >> LOG_HBLKSIZE) & (PHT_ENTRIES - 1))
+
+# define get_pht_entry_from_index(bl, index) \
+		(((bl)[divWORDSZ(index)] >> modWORDSZ(index)) & 1)
+# define set_pht_entry_from_index(bl, index) \
+		(bl)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index)
+# define clear_pht_entry_from_index(bl, index) \
+		(bl)[divWORDSZ(index)] &= ~((word)1 << modWORDSZ(index))
+	
+
+
+/********************************************/
+/*                                          */
+/*    H e a p   B l o c k s                 */
+/*                                          */
+/********************************************/
+
+/*  heap block header */
+#define HBLKMASK   (HBLKSIZE-1)
+
+#define BITS_PER_HBLK (HBLKSIZE * 8)
+
+#define MARK_BITS_PER_HBLK (BITS_PER_HBLK/CPP_WORDSZ)
+	   /* upper bound                                    */
+	   /* We allocate 1 bit/word.  Only the first word   */
+	   /* in each object is actually marked.             */
+
+# ifdef ALIGN_DOUBLE
+#   define MARK_BITS_SZ (((MARK_BITS_PER_HBLK + 2*CPP_WORDSZ - 1) \
+			  / (2*CPP_WORDSZ))*2)
+# else
+#   define MARK_BITS_SZ ((MARK_BITS_PER_HBLK + CPP_WORDSZ - 1)/CPP_WORDSZ)
+# endif
+	   /* Upper bound on number of mark words per heap block  */
+
+struct hblkhdr {
+    word hb_sz;  /* If in use, size in words, of objects in the block. */
+		 /* if free, the size in bytes of the whole block      */
+    struct hblk * hb_next; 	/* Link field for hblk free list	 */
+    				/* and for lists of chunks waiting to be */
+    				/* reclaimed.				 */
+    word hb_descr;   		/* object descriptor for marking.  See	*/
+    				/* mark.h.				*/
+    char* hb_map;	/* A pointer to a pointer validity map of the block. */
+    		      	/* See GC_obj_map.				     */
+    		     	/* Valid for all blocks with headers.		     */
+    		     	/* Free blocks point to GC_invalid_map.		     */
+    unsigned char hb_obj_kind;
+    			 /* Kind of objects in the block.  Each kind 	*/
+    			 /* identifies a mark procedure and a set of 	*/
+    			 /* list headers.  Sometimes called regions.	*/
+    unsigned char hb_flags;
+#	define IGNORE_OFF_PAGE	1	/* Ignore pointers that do not	*/
+					/* point to the first page of 	*/
+					/* this object.			*/
+    unsigned short hb_last_reclaimed;
+    				/* Value of GC_gc_no when block was	*/
+    				/* last allocated or swept. May wrap.   */
+    word hb_marks[MARK_BITS_SZ];
+			    /* Bit i in the array refers to the             */
+			    /* object starting at the ith word (header      */
+			    /* INCLUDED) in the heap block.                 */
+			    /* The lsb of word 0 is numbered 0.		    */
+};
+
+/*  heap block body */
+
+# define DISCARD_WORDS 0
+	/* Number of words to be dropped at the beginning of each block	*/
+	/* Must be a multiple of WORDSZ.  May reasonably be nonzero	*/
+	/* on machines that don't guarantee longword alignment of	*/
+	/* pointers, so that the number of false hits is minimized.	*/
+	/* 0 and WORDSZ are probably the only reasonable values.	*/
+
+# define BODY_SZ ((HBLKSIZE-WORDS_TO_BYTES(DISCARD_WORDS))/sizeof(word))
+
+struct hblk {
+#   if (DISCARD_WORDS != 0)
+        word garbage[DISCARD_WORDS];
+#   endif
+    word hb_body[BODY_SZ];
+};
+
+# define HDR_WORDS ((word)DISCARD_WORDS)
+# define HDR_BYTES ((word)WORDS_TO_BYTES(DISCARD_WORDS))
+
+# define OBJ_SZ_TO_BLOCKS(sz) \
+    divHBLKSZ(HDR_BYTES + WORDS_TO_BYTES(sz) + HBLKSIZE-1)
+    /* Size of block (in units of HBLKSIZE) needed to hold objects of	*/
+    /* given sz (in words).						*/
+
+/* Object free list link */
+# define obj_link(p) (*(ptr_t *)(p))
+
+/*  lists of all heap blocks and free lists	*/
+/* These are grouped together in a struct	*/
+/* so that they can be easily skipped by the	*/
+/* GC_mark routine.				*/
+/* The ordering is weird to make GC_malloc	*/
+/* faster by keeping the important fields	*/
+/* sufficiently close together that a		*/
+/* single load of a base register will do.	*/
+/* Scalars that could easily appear to		*/
+/* be pointers are also put here.		*/
+/* The main fields should precede any 		*/
+/* conditionally included fields, so that	*/
+/* gc_inl.h will work even if a different set	*/
+/* of macros is defined when the client is	*/
+/* compiled.					*/
+
+struct _GC_arrays {
+  word _heapsize;
+  word _max_heapsize;
+  ptr_t _last_heap_addr;
+  ptr_t _prev_heap_addr;
+  word _words_allocd_before_gc;
+		/* Number of words allocated before this	*/
+		/* collection cycle.				*/
+  word _words_allocd;
+  	/* Number of words allocated during this collection cycle */
+  word _words_wasted;
+  	/* Number of words wasted due to internal fragmentation	 */
+  	/* in large objects allocated since last gc. Approximate.*/
+  word _words_finalized;
+  	/* Approximate number of words in objects (and headers)	*/
+  	/* That became ready for finalization in the last 	*/
+  	/* collection.						*/
+  word _non_gc_bytes_at_gc;
+  	/* Number of explicitly managed bytes of storage 	*/
+  	/* at last collection.					*/
+  word _mem_freed;
+  	/* Number of explicitly deallocated words of memory	*/
+  	/* since last collection.				*/
+  	
+  ptr_t _objfreelist[MAXOBJSZ+1];
+			  /* free list for objects */
+  ptr_t _aobjfreelist[MAXOBJSZ+1];
+			  /* free list for atomic objs 	*/
+
+  ptr_t _uobjfreelist[MAXOBJSZ+1];
+			  /* uncollectable but traced objs 	*/
+			  /* objects on this and auobjfreelist  */
+			  /* are always marked, except during   */
+			  /* garbage collections.		*/
+# ifdef ATOMIC_UNCOLLECTABLE
+    ptr_t _auobjfreelist[MAXOBJSZ+1];
+# endif
+			  /* uncollectable but traced objs 	*/
+
+# ifdef GATHERSTATS
+    word _composite_in_use;
+   		/* Number of words in accessible composite	*/
+		/* objects.					*/
+    word _atomic_in_use;
+   		/* Number of words in accessible atomic		*/
+		/* objects.					*/
+# endif
+# ifdef MERGE_SIZES
+    unsigned _size_map[WORDS_TO_BYTES(MAXOBJSZ+1)];
+    	/* Number of words to allocate for a given allocation request in */
+    	/* bytes.							 */
+# endif 
+
+# ifdef STUBBORN_ALLOC
+    ptr_t _sobjfreelist[MAXOBJSZ+1];
+# endif
+  			  /* free list for immutable objects	*/
+  ptr_t _obj_map[MAXOBJSZ+1];
+                       /* If not NIL, then a pointer to a map of valid  */
+    		       /* object addresses. _obj_map[sz][i] is j if the	*/
+    		       /* address block_start+i is a valid pointer      */
+    		       /* to an object at				*/
+    		       /* block_start+i&~3 - WORDS_TO_BYTES(j).		*/
+    		       /* (If ALL_INTERIOR_POINTERS is defined, then	*/
+    		       /* instead ((short *)(hbh_map[sz])[i] is j if	*/
+    		       /* block_start+WORDS_TO_BYTES(i) is in the	*/
+    		       /* interior of an object starting at		*/
+    		       /* block_start+WORDS_TO_BYTES(i-j)).		*/
+    		       /* It is OBJ_INVALID if				*/
+    		       /* block_start+WORDS_TO_BYTES(i) is not		*/
+    		       /* valid as a pointer to an object.              */
+    		       /* We assume all values of j <= OBJ_INVALID.	*/
+    		       /* The zeroth entry corresponds to large objects.*/
+#   ifdef ALL_INTERIOR_POINTERS
+#	define map_entry_type short
+#       define OBJ_INVALID 0x7fff
+#	define MAP_ENTRY(map, bytes) \
+		(((map_entry_type *)(map))[BYTES_TO_WORDS(bytes)])
+#	define MAP_ENTRIES BYTES_TO_WORDS(HBLKSIZE)
+#	define MAP_SIZE (MAP_ENTRIES * sizeof(map_entry_type))
+#	define OFFSET_VALID(displ) TRUE
+#	define CPP_MAX_OFFSET (HBLKSIZE - HDR_BYTES - 1)
+#	define MAX_OFFSET ((word)CPP_MAX_OFFSET)
+#   else
+#	define map_entry_type char
+#       define OBJ_INVALID 0x7f
+#	define MAP_ENTRY(map, bytes) \
+		(map)[bytes]
+#	define MAP_ENTRIES HBLKSIZE
+#	define MAP_SIZE MAP_ENTRIES
+#	define CPP_MAX_OFFSET (WORDS_TO_BYTES(OBJ_INVALID) - 1)	
+#	define MAX_OFFSET ((word)CPP_MAX_OFFSET)
+# 	define VALID_OFFSET_SZ \
+	  (CPP_MAX_OFFSET > WORDS_TO_BYTES(CPP_MAXOBJSZ)? \
+	   CPP_MAX_OFFSET+1 \
+	   : WORDS_TO_BYTES(CPP_MAXOBJSZ)+1)
+  	char _valid_offsets[VALID_OFFSET_SZ];
+				/* GC_valid_offsets[i] == TRUE ==> i 	*/
+				/* is registered as a displacement.	*/
+#	define OFFSET_VALID(displ) GC_valid_offsets[displ]
+  	char _modws_valid_offsets[sizeof(word)];
+				/* GC_valid_offsets[i] ==>		  */
+				/* GC_modws_valid_offsets[i%sizeof(word)] */
+#   endif
+# ifdef STUBBORN_ALLOC
+      page_hash_table _changed_pages;
+        /* Stubborn object pages that were changes since last call to	*/
+	/* GC_read_changed.						*/
+      page_hash_table _prev_changed_pages;
+        /* Stubborn object pages that were changes before last call to	*/
+	/* GC_read_changed.						*/
+# endif
+# if defined(PROC_VDB) || defined(MPROTECT_VDB)
+      page_hash_table _grungy_pages; /* Pages that were dirty at last 	   */
+				     /* GC_read_dirty.			   */
+# endif
+# ifdef LARGE_CONFIG
+#   if CPP_WORDSZ > 32
+#     define MAX_HEAP_SECTS 4096 	/* overflows at roughly 64 GB	   */
+#   else
+#     define MAX_HEAP_SECTS 768		/* Separately added heap sections. */
+#   endif
+# else
+#   define MAX_HEAP_SECTS 256
+# endif
+  struct HeapSect {
+      ptr_t hs_start; word hs_bytes;
+  } _heap_sects[MAX_HEAP_SECTS];
+# ifdef MSWIN32
+    ptr_t _heap_bases[MAX_HEAP_SECTS];
+    		/* Start address of memory regions obtained from kernel. */
+# endif
+  /* Block header index; see gc_headers.h */
+  bottom_index * _all_nils;
+  bottom_index * _top_index [TOP_SZ];
+#ifdef SAVE_CALL_CHAIN
+  struct callinfo _last_stack[NFRAMES];	/* Stack at last garbage collection.*/
+  					/* Useful for debugging	mysterious  */
+  					/* object disappearances.	    */
+  					/* In the multithreaded case, we    */
+  					/* currently only save the calling  */
+  					/* stack.			    */
+#endif
+};
+
+GC_API GC_FAR struct _GC_arrays GC_arrays; 
+
+# define GC_objfreelist GC_arrays._objfreelist
+# define GC_aobjfreelist GC_arrays._aobjfreelist
+# define GC_uobjfreelist GC_arrays._uobjfreelist
+# ifdef ATOMIC_UNCOLLECTABLE
+#   define GC_auobjfreelist GC_arrays._auobjfreelist
+# endif
+# define GC_sobjfreelist GC_arrays._sobjfreelist
+# define GC_valid_offsets GC_arrays._valid_offsets
+# define GC_modws_valid_offsets GC_arrays._modws_valid_offsets
+# ifdef STUBBORN_ALLOC
+#    define GC_changed_pages GC_arrays._changed_pages
+#    define GC_prev_changed_pages GC_arrays._prev_changed_pages
+# endif
+# define GC_obj_map GC_arrays._obj_map
+# define GC_last_heap_addr GC_arrays._last_heap_addr
+# define GC_prev_heap_addr GC_arrays._prev_heap_addr
+# define GC_words_allocd GC_arrays._words_allocd
+# define GC_words_wasted GC_arrays._words_wasted
+# define GC_words_finalized GC_arrays._words_finalized
+# define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc
+# define GC_mem_freed GC_arrays._mem_freed
+# define GC_heapsize GC_arrays._heapsize
+# define GC_max_heapsize GC_arrays._max_heapsize
+# define GC_words_allocd_before_gc GC_arrays._words_allocd_before_gc
+# define GC_heap_sects GC_arrays._heap_sects
+# define GC_last_stack GC_arrays._last_stack
+# ifdef MSWIN32
+#   define GC_heap_bases GC_arrays._heap_bases
+# endif
+# define GC_all_nils GC_arrays._all_nils
+# define GC_top_index GC_arrays._top_index
+# if defined(PROC_VDB) || defined(MPROTECT_VDB)
+#   define GC_grungy_pages GC_arrays._grungy_pages
+# endif
+# ifdef GATHERSTATS
+#   define GC_composite_in_use GC_arrays._composite_in_use
+#   define GC_atomic_in_use GC_arrays._atomic_in_use
+# endif
+# ifdef MERGE_SIZES
+#   define GC_size_map GC_arrays._size_map
+# endif
+
+# define beginGC_arrays ((ptr_t)(&GC_arrays))
+# define endGC_arrays (((ptr_t)(&GC_arrays)) + (sizeof GC_arrays))
+
+GC_API word GC_fo_entries;
+
+# define MAXOBJKINDS 16
+
+/* Object kinds: */
+extern struct obj_kind {
+   ptr_t *ok_freelist;	/* Array of free listheaders for this kind of object */
+   			/* Point either to GC_arrays or to storage allocated */
+   			/* with GC_scratch_alloc.			     */
+   struct hblk **ok_reclaim_list;
+   			/* List headers for lists of blocks waiting to be */
+   			/* swept.					  */
+   word ok_descriptor;  /* Descriptor template for objects in this	*/
+   			/* block.					*/
+   bool ok_relocate_descr;
+   			/* Add object size in bytes to descriptor 	*/
+   			/* template to obtain descriptor.  Otherwise	*/
+   			/* template is used as is.			*/
+   bool ok_init;     /* Clear objects before putting them on the free list. */
+} GC_obj_kinds[MAXOBJKINDS];
+/* Predefined kinds: */
+# define PTRFREE 0
+# define NORMAL  1
+# define UNCOLLECTABLE 2
+# ifdef ATOMIC_UNCOLLECTABLE
+#   define AUNCOLLECTABLE 3
+#   define STUBBORN 4
+#   define IS_UNCOLLECTABLE(k) (((k) & ~1) == UNCOLLECTABLE)
+# else
+#   define STUBBORN 3
+#   define IS_UNCOLLECTABLE(k) ((k) == UNCOLLECTABLE)
+# endif
+
+extern int GC_n_kinds;
+
+extern word GC_n_heap_sects;	/* Number of separately added heap	*/
+				/* sections.				*/
+
+# ifdef MSWIN32
+extern word GC_n_heap_bases;	/* See GC_heap_bases.	*/
+# endif
+
+extern word GC_total_black_listed;
+			/* Number of bytes on stack blacklist. 	*/
+
+extern word GC_black_list_spacing;
+			/* Average number of bytes between blacklisted	*/
+			/* blocks. Approximate.				*/
+
+extern char * GC_invalid_map;
+			/* Pointer to the nowhere valid hblk map */
+			/* Blocks pointing to this map are free. */
+
+extern struct hblk * GC_hblkfreelist;
+				/* List of completely empty heap blocks	*/
+				/* Linked through hb_next field of 	*/
+				/* header structure associated with	*/
+				/* block.				*/
+
+extern bool GC_is_initialized;		/* GC_init() has been run.	*/
+
+extern bool GC_objects_are_marked;	/* There are marked objects in  */
+					/* the heap.			*/
+
+extern int GC_incremental;  /* Using incremental/generational collection. */
+
+extern bool GC_dirty_maintained;/* Dirty bits are being maintained, 	*/
+				/* either for incremental collection,	*/
+				/* or to limit the root set.		*/
+
+# ifndef PCR
+    extern ptr_t GC_stackbottom;	/* Cool end of user stack	*/
+# endif
+
+extern word GC_root_size;	/* Total size of registered root sections */
+
+extern bool GC_debugging_started;	/* GC_debug_malloc has been called. */ 
+
+extern ptr_t GC_least_plausible_heap_addr;
+extern ptr_t GC_greatest_plausible_heap_addr;
+			/* Bounds on the heap.  Guaranteed valid	*/
+			/* Likely to include future heap expansion.	*/
+			
+/* Operations */
+# ifndef abs
+#   define abs(x)  ((x) < 0? (-(x)) : (x))
+# endif
+
+
+/*  Marks are in a reserved area in                          */
+/*  each heap block.  Each word has one mark bit associated  */
+/*  with it. Only those corresponding to the beginning of an */
+/*  object are used.                                         */
+
+
+/* Mark bit perations */
+
+/*
+ * Retrieve, set, clear the mark bit corresponding
+ * to the nth word in a given heap block.
+ *
+ * (Recall that bit n corresponds to object beginning at word n
+ * relative to the beginning of the block, including unused words)
+ */
+
+# define mark_bit_from_hdr(hhdr,n) (((hhdr)->hb_marks[divWORDSZ(n)] \
+			    >> (modWORDSZ(n))) & (word)1)
+# define set_mark_bit_from_hdr(hhdr,n) (hhdr)->hb_marks[divWORDSZ(n)] \
+				|= (word)1 << modWORDSZ(n)
+
+# define clear_mark_bit_from_hdr(hhdr,n) (hhdr)->hb_marks[divWORDSZ(n)] \
+				&= ~((word)1 << modWORDSZ(n))
+
+/* Important internal collector routines */
+
+void GC_apply_to_all_blocks(/*fn, client_data*/);
+			/* Invoke fn(hbp, client_data) for each 	*/
+			/* allocated heap block.			*/
+struct hblk * GC_next_block(/* struct hblk * h */);
+void GC_mark_init();
+void GC_clear_marks();	/* Clear mark bits for all heap objects. */
+void GC_invalidate_mark_state();	/* Tell the marker that	marked 	   */
+					/* objects may point to	unmarked   */
+					/* ones, and roots may point to	   */
+					/* unmarked objects.		   */
+					/* Reset mark stack.		   */
+void GC_mark_from_mark_stack(); /* Mark from everything on the mark stack. */
+				/* Return after about one pages worth of   */
+				/* work.				   */
+bool GC_mark_stack_empty();
+bool GC_mark_some();	/* Perform about one pages worth of marking	*/
+			/* work of whatever kind is needed.  Returns	*/
+			/* quickly if no collection is in progress.	*/
+			/* Return TRUE if mark phase finished.		*/
+void GC_initiate_gc();		/* initiate collection.			*/
+				/* If the mark state is invalid, this	*/
+				/* becomes full colleection.  Otherwise */
+				/* it's partial.			*/
+void GC_push_all(/*b,t*/);	/* Push everything in a range 		*/
+				/* onto mark stack.			*/
+void GC_push_dirty(/*b,t*/);      /* Push all possibly changed	 	*/
+				  /* subintervals of [b,t) onto		*/
+				  /* mark stack.			*/
+#ifndef SMALL_CONFIG
+  void GC_push_conditional(/* ptr_t b, ptr_t t, bool all*/);
+#else
+# define GC_push_conditional(b, t, all) GC_push_all(b, t)
+#endif
+                                /* Do either of the above, depending	*/
+				/* on the third arg.			*/
+void GC_push_all_stack(/*b,t*/);    /* As above, but consider		*/
+				    /*  interior pointers as valid  	*/
+void GC_push_roots(/* bool all */); /* Push all or dirty roots.	*/
+extern void (*GC_push_other_roots)();
+			/* Push system or application specific roots	*/
+			/* onto the mark stack.  In some environments	*/
+			/* (e.g. threads environments) this is		*/
+			/* predfined to be non-zero.  A client supplied */
+			/* replacement should also call the original	*/
+			/* function.					*/
+void GC_push_regs();	/* Push register contents onto mark stack.	*/
+void GC_remark();	/* Mark from all marked objects.  Used	*/
+		 	/* only if we had to drop something.	*/
+void GC_push_one(/*p*/);	/* If p points to an object, mark it	*/
+				/* and push contents on the mark stack	*/
+void GC_push_one_checked(/*p*/); /* Ditto, omits plausibility test	*/
+void GC_push_marked(/* struct hblk h, hdr * hhdr */);
+		/* Push contents of all marked objects in h onto	*/
+		/* mark stack.						*/
+#ifdef SMALL_CONFIG
+# define GC_push_next_marked_dirty(h) GC_push_next_marked(h)
+#else
+  struct hblk * GC_push_next_marked_dirty(/* h */);
+		/* Invoke GC_push_marked on next dirty block above h.	*/
+		/* Return a pointer just past the end of this block.	*/
+#endif /* !SMALL_CONFIG */
+struct hblk * GC_push_next_marked(/* h */);
+		/* Ditto, but also mark from clean pages.	*/
+struct hblk * GC_push_next_marked_uncollectable(/* h */);
+		/* Ditto, but mark only from uncollectable pages.	*/
+bool GC_stopped_mark(); /* Stop world and mark from all roots	*/
+			/* and rescuers.			*/
+void GC_clear_hdr_marks(/* hhdr */);  /* Clear the mark bits in a header */
+void GC_set_hdr_marks(/* hhdr */);  /* Set the mark bits in a header */
+void GC_add_roots_inner();
+bool GC_is_static_root(/* ptr_t p */);
+		/* Is the address p in one of the registered static	*/
+		/* root sections?					*/
+void GC_register_dynamic_libraries();
+		/* Add dynamic library data sections to the root set. */
+
+/* Machine dependent startup routines */
+ptr_t GC_get_stack_base();
+void GC_register_data_segments();
+
+/* Black listing: */
+void GC_bl_init(); 	
+# ifndef ALL_INTERIOR_POINTERS
+    void GC_add_to_black_list_normal(/* bits */);
+			/* Register bits as a possible future false	*/
+			/* reference from the heap or static data	*/
+#   define GC_ADD_TO_BLACK_LIST_NORMAL(bits) GC_add_to_black_list_normal(bits)
+# else
+#   define GC_ADD_TO_BLACK_LIST_NORMAL(bits) GC_add_to_black_list_stack(bits)
+# endif
+
+void GC_add_to_black_list_stack(/* bits */);
+struct hblk * GC_is_black_listed(/* h, len */);
+			/* If there are likely to be false references	*/
+			/* to a block starting at h of the indicated    */
+			/* length, then return the next plausible	*/
+			/* starting location for h that might avoid	*/
+			/* these false references.			*/
+void GC_promote_black_lists();
+			/* Declare an end to a black listing phase.	*/
+void GC_unpromote_black_lists();
+			/* Approximately undo the effect of the above.	*/
+			/* This actually loses some information, but	*/
+			/* only in a reasonably safe way.		*/
+word GC_number_stack_black_listed(/*struct hblk *start, struct hblk *endp1 */);
+			/* Return the number of (stack) blacklisted	*/
+			/* blocks in the range for statistical		*/
+			/* purposes.					*/
+		 	
+ptr_t GC_scratch_alloc(/*bytes*/);
+				/* GC internal memory allocation for	*/
+				/* small objects.  Deallocation is not  */
+				/* possible.				*/
+	
+/* Heap block layout maps: */			
+void GC_invalidate_map(/* hdr */);
+				/* Remove the object map associated	*/
+				/* with the block.  This identifies	*/
+				/* the block as invalid to the mark	*/
+				/* routines.				*/
+bool GC_add_map_entry(/*sz*/);
+				/* Add a heap block map for objects of	*/
+				/* size sz to obj_map.			*/
+				/* Return FALSE on failure.		*/
+void GC_register_displacement_inner(/*offset*/);
+				/* Version of GC_register_displacement	*/
+				/* that assumes lock is already held	*/
+				/* and signals are already disabled.	*/
+
+/*  hblk allocation: */		
+void GC_new_hblk(/*size_in_words, kind*/);
+				/* Allocate a new heap block, and build */
+				/* a free list in it.			*/				
+struct hblk * GC_allochblk(/*size_in_words, kind*/);
+				/* Allocate a heap block, clear it if	*/
+				/* for composite objects, inform	*/
+				/* the marker that block is valid	*/
+				/* for objects of indicated size.	*/
+				/* sz < 0 ==> atomic.			*/ 
+void GC_freehblk();		/* Deallocate a heap block and mark it  */
+				/* as invalid.				*/
+				
+/*  Misc GC: */
+void GC_init_inner();
+bool GC_expand_hp_inner();
+void GC_start_reclaim(/*abort_if_found*/);
+				/* Restore unmarked objects to free	*/
+				/* lists, or (if abort_if_found is	*/
+				/* TRUE) report them.			*/
+				/* Sweeping of small object pages is	*/
+				/* largely deferred.			*/
+void GC_continue_reclaim(/*size, kind*/);
+				/* Sweep pages of the given size and	*/
+				/* kind, as long as possible, and	*/
+				/* as long as the corr. free list is    */
+				/* empty.				*/
+void GC_reclaim_or_delete_all();
+				/* Arrange for all reclaim lists to be	*/
+				/* empty.  Judiciously choose between	*/
+				/* sweeping and discarding each page.	*/
+bool GC_reclaim_all(/* GC_stop_func f*/);
+				/* Reclaim all blocks.  Abort (in a	*/
+				/* consistent state) if f returns TRUE. */
+bool GC_block_empty(/* hhdr */); /* Block completely unmarked? 	*/
+bool GC_never_stop_func();	/* Returns FALSE.		*/
+bool GC_try_to_collect_inner(/* GC_stop_func f */);
+				/* Collect; caller must have acquired	*/
+				/* lock and disabled signals.		*/
+				/* Collection is aborted if f returns	*/
+				/* TRUE.  Returns TRUE if it completes	*/
+				/* successfully.			*/
+# define GC_gcollect_inner() \
+	(void) GC_try_to_collect_inner(GC_never_stop_func)
+void GC_finish_collection();	/* Finish collection.  Mark bits are	*/
+				/* consistent and lock is still held.	*/
+bool GC_collect_or_expand(/* needed_blocks */);
+				/* Collect or expand heap in an attempt */
+				/* make the indicated number of free	*/
+				/* blocks available.  Should be called	*/
+				/* until the blocks are available or	*/
+				/* until it fails by returning FALSE.	*/
+void GC_init();			/* Initialize collector.		*/
+void GC_collect_a_little_inner(/* int n */);
+				/* Do n units worth of garbage 		*/
+				/* collection work, if appropriate.	*/
+				/* A unit is an amount appropriate for  */
+				/* HBLKSIZE bytes of allocation.	*/
+ptr_t GC_generic_malloc(/* bytes, kind */);
+				/* Allocate an object of the given	*/
+				/* kind.  By default, there are only	*/
+				/* two kinds: composite, and atomic.	*/
+				/* We claim it's possible for clever	*/
+				/* client code that understands GC	*/
+				/* internals to add more, e.g. to	*/
+				/* communicate object layout info	*/
+				/* to the collector.			*/
+ptr_t GC_generic_malloc_inner(/* bytes, kind */);
+				/* Ditto, but I already hold lock, etc.	*/
+ptr_t GC_generic_malloc_words_small GC_PROTO((size_t words, int kind));
+				/* As above, but size in units of words */
+				/* Bypasses MERGE_SIZES.  Assumes	*/
+				/* words <= MAXOBJSZ.			*/
+ptr_t GC_generic_malloc_inner_ignore_off_page(/* bytes, kind */);
+				/* Allocate an object, where		*/
+				/* the client guarantees that there	*/
+				/* will always be a pointer to the 	*/
+				/* beginning of the object while the	*/
+				/* object is live.			*/
+ptr_t GC_allocobj(/* sz_inn_words, kind */);
+				/* Make the indicated 			*/
+				/* free list nonempty, and return its	*/
+				/* head.				*/
+
+void GC_init_headers();
+bool GC_install_header(/*h*/);
+				/* Install a header for block h.	*/
+				/* Return FALSE on failure.		*/
+bool GC_install_counts(/*h, sz*/);
+				/* Set up forwarding counts for block	*/
+				/* h of size sz.			*/
+				/* Return FALSE on failure.		*/
+void GC_remove_header(/*h*/);
+				/* Remove the header for block h.	*/
+void GC_remove_counts(/*h, sz*/);
+				/* Remove forwarding counts for h.	*/
+hdr * GC_find_header(/*p*/);	/* Debugging only.			*/
+
+void GC_finalize();	/* Perform all indicated finalization actions	*/
+			/* on unmarked objects.				*/
+			/* Unreachable finalizable objects are enqueued	*/
+			/* for processing by GC_invoke_finalizers.	*/
+			/* Invoked with lock.				*/
+void GC_invoke_finalizers(); 	/* Run eligible finalizers.	*/
+				/* Invoked without lock.	*/	
+			
+void GC_add_to_heap(/*p, bytes*/);
+			/* Add a HBLKSIZE aligned chunk to the heap.	*/
+
+void GC_print_obj(/* ptr_t p */);
+			/* P points to somewhere inside an object with	*/
+			/* debugging info.  Print a human readable	*/
+			/* description of the object to stderr.		*/
+extern void (*GC_check_heap)();
+			/* Check that all objects in the heap with 	*/
+			/* debugging info are intact.  Print 		*/
+			/* descriptions of any that are not.		*/
+			
+/* Virtual dirty bit implementation:		*/
+/* Each implementation exports the following:	*/
+void GC_read_dirty();	/* Retrieve dirty bits.	*/
+bool GC_page_was_dirty(/* struct hblk * h  */);
+			/* Read retrieved dirty bits.	*/
+bool GC_page_was_ever_dirty(/* struct hblk * h  */);
+			/* Could the page contain valid heap pointers?	*/
+void GC_is_fresh(/* struct hblk * h, word number_of_blocks  */);
+			/* Assert the region currently contains no	*/
+			/* valid pointers.				*/
+void GC_write_hint(/* struct hblk * h  */);
+			/* h is about to be written.	*/
+void GC_dirty_init();
+
+/* Slow/general mark bit manipulation: */
+bool GC_is_marked();
+void GC_clear_mark_bit();
+void GC_set_mark_bit();
+
+/* Stubborn objects: */
+void GC_read_changed();	/* Analogous to GC_read_dirty */
+bool GC_page_was_changed(/* h */);	/* Analogous to GC_page_was_dirty */
+void GC_clean_changing_list();	/* Collect obsolete changing list entries */
+void GC_stubborn_init();
+
+/* Debugging print routines: */
+void GC_print_block_list();
+void GC_print_hblkfreelist();
+void GC_print_heap_sects();
+void GC_print_static_roots();
+void GC_dump();
+
+/* Make arguments appear live to compiler */
+GC_API void GC_noop();
+void GC_noop1(/* word arg */);
+
+/* Logging and diagnostic output: 	*/
+GC_API void GC_printf GC_PROTO((char * format, long, long, long, long, long, long));
+			/* A version of printf that doesn't allocate,	*/
+			/* is restricted to long arguments, and		*/
+			/* (unfortunately) doesn't use varargs for	*/
+			/* portability.  Restricted to 6 args and	*/
+			/* 1K total output length.			*/
+			/* (We use sprintf.  Hopefully that doesn't	*/
+			/* allocate for long arguments.)  		*/
+# define GC_printf0(f) GC_printf(f, 0l, 0l, 0l, 0l, 0l, 0l)
+# define GC_printf1(f,a) GC_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
+# define GC_printf2(f,a,b) GC_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
+# define GC_printf3(f,a,b,c) GC_printf(f, (long)a, (long)b, (long)c, 0l, 0l, 0l)
+# define GC_printf4(f,a,b,c,d) GC_printf(f, (long)a, (long)b, (long)c, \
+					    (long)d, 0l, 0l)
+# define GC_printf5(f,a,b,c,d,e) GC_printf(f, (long)a, (long)b, (long)c, \
+					      (long)d, (long)e, 0l)
+# define GC_printf6(f,a,b,c,d,e,g) GC_printf(f, (long)a, (long)b, (long)c, \
+						(long)d, (long)e, (long)g)
+
+void GC_err_printf(/* format, a, b, c, d, e, f */);
+# define GC_err_printf0(f) GC_err_puts(f)
+# define GC_err_printf1(f,a) GC_err_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
+# define GC_err_printf2(f,a,b) GC_err_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
+# define GC_err_printf3(f,a,b,c) GC_err_printf(f, (long)a, (long)b, (long)c, \
+						  0l, 0l, 0l)
+# define GC_err_printf4(f,a,b,c,d) GC_err_printf(f, (long)a, (long)b, \
+						    (long)c, (long)d, 0l, 0l)
+# define GC_err_printf5(f,a,b,c,d,e) GC_err_printf(f, (long)a, (long)b, \
+						      (long)c, (long)d, \
+						      (long)e, 0l)
+# define GC_err_printf6(f,a,b,c,d,e,g) GC_err_printf(f, (long)a, (long)b, \
+							(long)c, (long)d, \
+							(long)e, (long)g)
+			/* Ditto, writes to stderr.			*/
+			
+void GC_err_puts(/* char *s */);
+			/* Write s to stderr, don't buffer, don't add	*/
+			/* newlines, don't ...				*/
+
+# endif /* GC_PRIVATE_H */
diff --git a/src/mzscheme/gc/gc_private.h b/src/mzscheme/gc/gc_private.h
new file mode 100644
index 0000000..3dd7c85
--- /dev/null
+++ b/src/mzscheme/gc/gc_private.h
@@ -0,0 +1 @@
+# include "gc_priv.h"
diff --git a/src/mzscheme/gc/gc_typed.h b/src/mzscheme/gc/gc_typed.h
new file mode 100644
index 0000000..ea20e76
--- /dev/null
+++ b/src/mzscheme/gc/gc_typed.h
@@ -0,0 +1,88 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996 Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/*
+ * Some simple primitives for allocation with explicit type information.
+ * Facilities for dynamic type inference may be added later.
+ * Should be used only for extremely performance critical applications,
+ * or if conservative collector leakage is otherwise a problem (unlikely).
+ * Note that this is implemented completely separately from the rest
+ * of the collector, and is not linked in unless referenced.
+ * This does not currently support GC_DEBUG in any interesting way.
+ */
+/* Boehm, May 19, 1994 2:13 pm PDT */
+
+#ifndef _GC_TYPED_H
+# define _GC_TYPED_H
+# ifndef _GC_H
+#   include "gc.h"
+# endif
+
+typedef GC_word * GC_bitmap;
+	/* The least significant bit of the first word is one if	*/
+	/* the first word in the object may be a pointer.		*/
+	
+# define GC_get_bit(bm, index) \
+		(((bm)[divWORDSZ(index)] >> modWORDSZ(index)) & 1)
+# define GC_set_bit(bm, index) \
+		(bm)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index)
+
+typedef GC_word GC_descr;
+
+GC_API GC_descr GC_make_descriptor GC_PROTO((GC_bitmap bm, size_t len));
+		/* Return a type descriptor for the object whose layout	*/
+		/* is described by the argument.			*/
+		/* The least significant bit of the first word is one	*/
+		/* if the first word in the object may be a pointer.	*/
+		/* The second argument specifies the number of		*/
+		/* meaningful bits in the bitmap.  The actual object 	*/
+		/* may be larger (but not smaller).  Any additional	*/
+		/* words in the object are assumed not to contain 	*/
+		/* pointers.						*/
+		/* Returns a conservative approximation in the		*/
+		/* (unlikely) case of insufficient memory to build	*/
+		/* the descriptor.  Calls to GC_make_descriptor		*/
+		/* may consume some amount of a finite resource.  This	*/
+		/* is intended to be called once per type, not once	*/
+		/* per allocation.					*/
+
+GC_API void * GC_malloc_explicitly_typed
+			GC_PROTO((size_t size_in_bytes, GC_descr d));
+		/* Allocate an object whose layout is described by d.	*/
+		/* The resulting object MAY NOT BE PASSED TO REALLOC.	*/
+		
+GC_API void * GC_calloc_explicitly_typed
+			GC_PROTO((size_t nelements,
+  				  size_t element_size_in_bytes,
+  				  GC_descr d));
+  	/* Allocate an array of nelements elements, each of the	*/
+  	/* given size, and with the given descriptor.		*/
+  	/* The elemnt size must be a multiple of the byte	*/
+  	/* alignment required for pointers.  E.g. on a 32-bit	*/
+  	/* machine with 16-bit aligned pointers, size_in_bytes	*/
+  	/* must be a multiple of 2.				*/
+
+#ifdef GC_DEBUG
+#   define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) GC_MALLOC(bytes)
+#   define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) GC_MALLOC(n*bytes)
+#else
+#  define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) \
+	GC_malloc_explicitly_typed(bytes, d)
+#  define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) \
+	GC_calloc_explicitly_typed(n, bytes, d)
+#endif /* !GC_DEBUG */
+
+
+#endif /* _GC_TYPED_H */
+
diff --git a/src/mzscheme/gc/gcc_support.c b/src/mzscheme/gc/gcc_support.c
new file mode 100644
index 0000000..e8a7b82
--- /dev/null
+++ b/src/mzscheme/gc/gcc_support.c
@@ -0,0 +1,516 @@
+/***************************************************************************
+
+Interface between g++ and Boehm GC
+
+    Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+
+    THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+    OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+    Permission is hereby granted to copy this code for any purpose,
+    provided the above notices are retained on all copies.
+
+    Last modified on Sun Jul 16 23:21:14 PDT 1995 by ellis
+
+This module provides runtime support for implementing the
+Ellis/Detlefs GC proposal, "Safe, Efficient Garbage Collection for
+C++", within g++, using its -fgc-keyword extension.  It defines
+versions of __builtin_new, __builtin_new_gc, __builtin_vec_new,
+__builtin_vec_new_gc, __builtin_delete, and __builtin_vec_delete that
+invoke the Bohem GC.  It also implements the WeakPointer.h interface.
+
+This module assumes the following configuration options of the Boehm GC:
+
+    -DALL_INTERIOR_POINTERS
+    -DDONT_ADD_BYTE_AT_END   
+
+This module adds its own required padding to the end of objects to
+support C/C++ "one-past-the-object" pointer semantics.
+
+****************************************************************************/
+
+#include <stddef.h>
+#include "gc.h"
+
+#if defined(__STDC__) 
+#   define PROTO( args ) args
+#else
+#    define PROTO( args ) ()
+#    endif
+
+#define BITSPERBYTE 8     
+    /* What's the portable way to do this? */
+
+
+typedef void (*vfp) PROTO(( void ));
+extern vfp __new_handler;
+extern void __default_new_handler PROTO(( void ));
+
+
+/* A destructor_proc is the compiler generated procedure representing a 
+C++ destructor.  The "flag" argument is a hidden argument following some
+compiler convention. */
+
+typedef (*destructor_proc) PROTO(( void* this, int flag ));
+
+
+/***************************************************************************
+
+A BI_header is the header the compiler adds to the front of
+new-allocated arrays of objects with destructors.  The header is
+padded out to a double, because that's what the compiler does to
+ensure proper alignment of array elements on some architectures.  
+
+int NUM_ARRAY_ELEMENTS (void* o)
+    returns the number of array elements for array object o.
+
+char* FIRST_ELEMENT_P (void* o)
+    returns the address of the first element of array object o.
+
+***************************************************************************/
+
+typedef struct BI_header {
+    int nelts;
+    char padding [sizeof( double ) - sizeof( int )]; 
+        /* Better way to do this? */
+} BI_header;
+
+#define NUM_ARRAY_ELEMENTS( o ) \
+  (((BI_header*) o)->nelts)
+
+#define FIRST_ELEMENT_P( o ) \
+  ((char*) o + sizeof( BI_header ))
+
+
+/***************************************************************************
+
+The __builtin_new routines add a descriptor word to the end of each
+object.   The descriptor serves two purposes.  
+
+First, the descriptor acts as padding, implementing C/C++ pointer
+semantics.  C and C++ allow a valid array pointer to be incremented
+one past the end of an object.  The extra padding ensures that the
+collector will recognize that such a pointer points to the object and
+not the next object in memory.
+
+Second, the descriptor stores three extra pieces of information,
+whether an object has a registered finalizer (destructor), whether it
+may have any weak pointers referencing it, and for collectible arrays,
+the element size of the array.  The element size is required for the
+array's finalizer to iterate through the elements of the array.  (An
+alternative design would have the compiler generate a finalizer
+procedure for each different array type.  But given the overhead of
+finalization, there isn't any efficiency to be gained by that.)
+
+The descriptor must be added to non-collectible as well as collectible
+objects, since the Ellis/Detlefs proposal allows "pointer to gc T" to
+be assigned to a "pointer to T", which could then be deleted.  Thus,
+__builtin_delete must determine at runtime whether an object is
+collectible, whether it has weak pointers referencing it, and whether
+it may have a finalizer that needs unregistering.  Though
+GC_REGISTER_FINALIZER doesn't care if you ask it to unregister a
+finalizer for an object that doesn't have one, it is a non-trivial
+procedure that does a hash look-up, etc.  The descriptor trades a
+little extra space for a significant increase in time on the fast path
+through delete.  (A similar argument applies to
+GC_UNREGISTER_DISAPPEARING_LINK).
+
+For non-array types, the space for the descriptor could be shrunk to a
+single byte for storing the "has finalizer" flag.  But this would save
+space only on arrays of char (whose size is not a multiple of the word
+size) and structs whose largest member is less than a word in size
+(very infrequent).  And it would require that programmers actually
+remember to call "delete[]" instead of "delete" (which they should,
+but there are probably lots of buggy programs out there).  For the
+moment, the space savings seems not worthwhile, especially considering
+that the Boehm GC is already quite space competitive with other
+malloc's.
+
+
+Given a pointer o to the base of an object:
+
+Descriptor* DESCRIPTOR (void* o) 
+     returns a pointer to the descriptor for o.
+
+The implementation of descriptors relies on the fact that the GC
+implementation allocates objects in units of the machine's natural
+word size (e.g. 32 bits on a SPARC, 64 bits on an Alpha).
+
+**************************************************************************/
+
+typedef struct Descriptor {
+    unsigned has_weak_pointers: 1;
+    unsigned has_finalizer: 1;
+    unsigned element_size: BITSPERBYTE * sizeof( unsigned ) - 2; 
+} Descriptor;
+
+#define DESCRIPTOR( o ) \
+  ((Descriptor*) ((char*)(o) + GC_size( o ) - sizeof( Descriptor )))
+
+
+/**************************************************************************
+
+Implementations of global operator new() and operator delete()
+
+***************************************************************************/
+
+
+void* __builtin_new( size ) 
+    size_t size;
+    /* 
+    For non-gc non-array types, the compiler generates calls to
+    __builtin_new, which allocates non-collected storage via
+    GC_MALLOC_UNCOLLECTABLE.  This ensures that the non-collected
+    storage will be part of the collector's root set, required by the
+    Ellis/Detlefs semantics. */
+{
+    vfp handler = __new_handler ? __new_handler : __default_new_handler;
+
+    while (1) {
+        void* o = GC_MALLOC_UNCOLLECTABLE( size + sizeof( Descriptor ) );
+        if (o != 0) return o;
+        (*handler) ();}}
+
+
+void* __builtin_vec_new( size ) 
+    size_t size;
+    /* 
+    For non-gc array types, the compiler generates calls to
+    __builtin_vec_new. */
+{
+    return __builtin_new( size );}
+
+
+void* __builtin_new_gc( size )
+    size_t size;
+    /* 
+    For gc non-array types, the compiler generates calls to
+    __builtin_new_gc, which allocates collected storage via
+    GC_MALLOC. */
+{
+    vfp handler = __new_handler ? __new_handler : __default_new_handler;
+
+    while (1) {
+        void* o = GC_MALLOC( size + sizeof( Descriptor ) );
+        if (o != 0) return o;
+        (*handler) ();}}
+
+
+void* __builtin_new_gc_a( size )
+    size_t size;
+    /* 
+    For non-pointer-containing gc non-array types, the compiler
+    generates calls to __builtin_new_gc_a, which allocates collected
+    storage via GC_MALLOC_ATOMIC. */
+{
+    vfp handler = __new_handler ? __new_handler : __default_new_handler;
+
+    while (1) {
+        void* o = GC_MALLOC_ATOMIC( size + sizeof( Descriptor ) );
+        if (o != 0) return o;
+        (*handler) ();}}
+
+
+void* __builtin_vec_new_gc( size )
+    size_t size;
+    /*
+    For gc array types, the compiler generates calls to
+    __builtin_vec_new_gc. */
+{
+    return __builtin_new_gc( size );}
+
+
+void* __builtin_vec_new_gc_a( size )
+    size_t size;
+    /*
+    For non-pointer-containing gc array types, the compiler generates
+    calls to __builtin_vec_new_gc_a. */
+{
+    return __builtin_new_gc_a( size );}
+
+
+static void call_destructor( o, data )
+    void* o;
+    void* data;
+    /* 
+    call_destructor is the GC finalizer proc registered for non-array
+    gc objects with destructors.  Its client data is the destructor
+    proc, which it calls with the magic integer 2, a special flag
+    obeying the compiler convention for destructors. */
+{
+    ((destructor_proc) data)( o, 2 );}
+
+
+void* __builtin_new_gc_dtor( o, d )
+    void* o;
+    destructor_proc d;
+    /* 
+    The compiler generates a call to __builtin_new_gc_dtor to register
+    the destructor "d" of a non-array gc object "o" as a GC finalizer.
+    The destructor is registered via
+    GC_REGISTER_FINALIZER_IGNORE_SELF, which causes the collector to
+    ignore pointers from the object to itself when determining when
+    the object can be finalized.  This is necessary due to the self
+    pointers used in the internal representation of multiply-inherited
+    objects. */
+{
+    Descriptor* desc = DESCRIPTOR( o );
+
+    GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_destructor, d, 0, 0 );
+    desc->has_finalizer = 1;}
+
+
+static void call_array_destructor( o, data )
+    void* o;
+    void* data;
+    /*
+    call_array_destructor is the GC finalizer proc registered for gc
+    array objects whose elements have destructors. Its client data is
+    the destructor proc.  It iterates through the elements of the
+    array in reverse order, calling the destructor on each. */
+{
+    int num = NUM_ARRAY_ELEMENTS( o );
+    Descriptor* desc = DESCRIPTOR( o );
+    size_t size = desc->element_size;
+    char* first_p = FIRST_ELEMENT_P( o );
+    char* p = first_p + (num - 1) * size;
+
+    if (num > 0) {
+        while (1) {
+            ((destructor_proc) data)( p, 2 );
+            if (p == first_p) break;
+            p -= size;}}}
+
+
+void* __builtin_vec_new_gc_dtor( first_elem, d, element_size )
+    void* first_elem;
+    destructor_proc d;
+    size_t element_size;
+    /* 
+    The compiler generates a call to __builtin_vec_new_gc_dtor to
+    register the destructor "d" of a gc array object as a GC
+    finalizer.  "first_elem" points to the first element of the array,
+    *not* the beginning of the object (this makes the generated call
+    to this function smaller).  The elements of the array are of size
+    "element_size".  The destructor is registered as in
+    _builtin_new_gc_dtor. */
+{
+    void* o = (char*) first_elem - sizeof( BI_header );
+    Descriptor* desc = DESCRIPTOR( o );
+
+    GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_array_destructor, d, 0, 0 );
+    desc->element_size = element_size;
+    desc->has_finalizer = 1;}
+
+
+void __builtin_delete( o )
+    void* o;
+    /* 
+    The compiler generates calls to __builtin_delete for operator
+    delete().  The GC currently requires that any registered
+    finalizers be unregistered before explicitly freeing an object.
+    If the object has any weak pointers referencing it, we can't
+    actually free it now. */
+{
+  if (o != 0) { 
+      Descriptor* desc = DESCRIPTOR( o );
+      if (desc->has_finalizer) GC_REGISTER_FINALIZER( o, 0, 0, 0, 0 );
+      if (! desc->has_weak_pointers) GC_FREE( o );}}
+
+
+void __builtin_vec_delete( o )
+    void* o;
+    /* 
+    The compiler generates calls to __builitn_vec_delete for operator
+    delete[](). */
+{
+  __builtin_delete( o );}
+
+
+/**************************************************************************
+
+Implementations of the template class WeakPointer from WeakPointer.h
+
+***************************************************************************/
+
+typedef struct WeakPointer {
+    void* pointer; 
+} WeakPointer;
+
+
+void* _WeakPointer_New( t )
+    void* t;
+{
+    if (t == 0) {
+        return 0;}
+    else {
+        void* base = GC_base( t );
+        WeakPointer* wp = 
+            (WeakPointer*) GC_MALLOC_ATOMIC( sizeof( WeakPointer ) );
+        Descriptor* desc = DESCRIPTOR( base );
+
+        wp->pointer = t;
+        desc->has_weak_pointers = 1;
+        GC_general_register_disappearing_link( &wp->pointer, base );
+        return wp;}}
+
+
+static void* PointerWithLock( wp ) 
+    WeakPointer* wp;
+{
+    if (wp == 0 || wp->pointer == 0) {
+      return 0;}
+    else {
+        return (void*) wp->pointer;}}
+
+
+void* _WeakPointer_Pointer( wp )
+    WeakPointer* wp;
+{
+    return (void*) GC_call_with_alloc_lock( PointerWithLock, wp );}
+
+
+typedef struct EqualClosure {
+    WeakPointer* wp1;
+    WeakPointer* wp2;
+} EqualClosure;
+
+
+static void* EqualWithLock( ec )
+    EqualClosure* ec;
+{
+    if (ec->wp1 == 0 || ec->wp2 == 0) {
+        return (void*) (ec->wp1 == ec->wp2);}
+    else {
+      return (void*) (ec->wp1->pointer == ec->wp2->pointer);}}
+
+
+int _WeakPointer_Equal( wp1,  wp2 )
+    WeakPointer* wp1;
+    WeakPointer* wp2;
+{
+    EqualClosure ec;
+
+    ec.wp1 = wp1;
+    ec.wp2 = wp2;
+    return (int) GC_call_with_alloc_lock( EqualWithLock, &ec );}
+
+
+int _WeakPointer_Hash( wp )
+    WeakPointer* wp;
+{
+    return (int) _WeakPointer_Pointer( wp );}
+
+
+/**************************************************************************
+
+Implementations of the template class CleanUp from WeakPointer.h
+
+***************************************************************************/
+
+typedef struct Closure {
+    void (*c) PROTO(( void* d, void* t ));
+    ptrdiff_t t_offset; 
+    void* d;
+} Closure;
+
+
+static void _CleanUp_CallClosure( obj, data ) 
+    void* obj;
+    void* data;
+{
+    Closure* closure = (Closure*) data;
+    closure->c( closure->d, (char*) obj + closure->t_offset );}
+
+
+void _CleanUp_Set( t, c, d ) 
+    void* t;
+    void (*c) PROTO(( void* d, void* t ));
+    void* d;
+{
+    void* base = GC_base( t );
+    Descriptor* desc = DESCRIPTOR( t );
+
+    if (c == 0) {
+        GC_REGISTER_FINALIZER_IGNORE_SELF( base, 0, 0, 0, 0 );
+        desc->has_finalizer = 0;}
+    else {
+        Closure* closure = (Closure*) GC_MALLOC( sizeof( Closure ) );
+        closure->c = c;
+        closure->t_offset = (char*) t - (char*) base;
+        closure->d = d;
+        GC_REGISTER_FINALIZER_IGNORE_SELF( base, _CleanUp_CallClosure, 
+                                           closure, 0, 0 );
+        desc->has_finalizer = 1;}}
+
+
+void _CleanUp_Call( t ) 
+    void* t;
+{
+      /* ? Aren't we supposed to deactivate weak pointers to t too? 
+         Why? */
+    void* base = GC_base( t );
+    void* d;
+    GC_finalization_proc f;
+
+    GC_REGISTER_FINALIZER( base, 0, 0, &f, &d );
+    f( base, d );}
+
+
+typedef struct QueueElem {
+    void* o;
+    GC_finalization_proc f;
+    void* d;
+    struct QueueElem* next; 
+} QueueElem;
+
+
+void* _CleanUp_Queue_NewHead()
+{
+    return GC_MALLOC( sizeof( QueueElem ) );}
+    
+     
+static void _CleanUp_Queue_Enqueue( obj, data )
+    void* obj; 
+    void* data;
+{
+    QueueElem* q = (QueueElem*) data;
+    QueueElem* head = q->next;
+
+    q->o = obj;
+    q->next = head->next;
+    head->next = q;}
+    
+    
+void _CleanUp_Queue_Set( h, t ) 
+    void* h;
+    void* t;
+{
+    QueueElem* head = (QueueElem*) h;
+    void* base = GC_base( t );
+    void* d;
+    GC_finalization_proc f;
+    QueueElem* q = (QueueElem*) GC_MALLOC( sizeof( QueueElem ) );
+     
+    GC_REGISTER_FINALIZER( base, _CleanUp_Queue_Enqueue, q, &f, &d );
+    q->f = f;
+    q->d = d;
+    q->next = head;}
+    
+
+int _CleanUp_Queue_Call( h ) 
+    void* h;
+{
+    QueueElem* head = (QueueElem*) h;
+    QueueElem* q = head->next;
+
+    if (q == 0) {
+        return 0;}
+    else {
+        head->next = q->next;
+        q->next = 0;
+        if (q->f != 0) q->f( q->o, q->d );
+        return 1;}}
+
+
+
diff --git a/src/mzscheme/gc/headers.c b/src/mzscheme/gc/headers.c
new file mode 100644
index 0000000..a7b6030
--- /dev/null
+++ b/src/mzscheme/gc/headers.c
@@ -0,0 +1,286 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+ 
+/*
+ * This implements:
+ * 1. allocation of heap block headers
+ * 2. A map from addresses to heap block addresses to heap block headers
+ *
+ * Access speed is crucial.  We implement an index structure based on a 2
+ * level tree.
+ */
+ 
+# include "gc_priv.h"
+
+bottom_index * GC_all_bottom_indices = 0;
+ 
+/* Non-macro version of header location routine */
+hdr * GC_find_header(h)
+ptr_t h;
+{
+#   ifdef HASH_TL
+	register hdr * result;
+	GET_HDR(h, result);
+	return(result);
+#   else
+	return(HDR_INNER(h));
+#   endif
+}
+ 
+/* Routines to dynamically allocate collector data structures that will */
+/* never be freed.							 */
+ 
+static ptr_t scratch_free_ptr = 0;
+ 
+ptr_t GC_scratch_end_ptr = 0;
+
+ptr_t GC_scratch_last_end_ptr = 0;
+		/* End point of last obtained scratch area */
+ 
+ptr_t GC_scratch_alloc(bytes)
+register word bytes;
+{
+    register ptr_t result = scratch_free_ptr;
+    register word bytes_needed = bytes;
+
+#   ifdef ALIGN_DOUBLE
+#	define GRANULARITY (2 * sizeof(word))
+#   else
+#	define GRANULARITY sizeof(word)
+#   endif
+    bytes += GRANULARITY-1;
+    bytes &= ~(GRANULARITY-1);
+    scratch_free_ptr += bytes;
+    if (scratch_free_ptr <= GC_scratch_end_ptr) {
+        return(result);
+    }
+    {
+        word bytes_to_get = MINHINCR * HBLKSIZE;
+         
+        if (bytes_to_get <= bytes) {
+          /* Undo the damage, and get memory directly */
+   	    ptr_t result = (ptr_t)GET_MEM(bytes);
+            scratch_free_ptr -= bytes;
+	    GC_scratch_last_end_ptr = result + bytes;
+            return(result);
+        }
+        result = (ptr_t)GET_MEM(bytes_to_get);
+        if (result == 0) {
+#	    ifdef PRINTSTATS
+                GC_printf0("Out of memory - trying to allocate less\n");
+#	    endif
+            scratch_free_ptr -= bytes;
+            return((ptr_t)GET_MEM(bytes));
+        }
+        scratch_free_ptr = result;
+        GC_scratch_end_ptr = scratch_free_ptr + bytes_to_get;
+        GC_scratch_last_end_ptr = GC_scratch_end_ptr;
+        return(GC_scratch_alloc(bytes));
+    }
+}
+
+static hdr * hdr_free_list = 0;
+
+/* Return an uninitialized header */
+static hdr * alloc_hdr()
+{
+    register hdr * result;
+    
+    if (hdr_free_list == 0) {
+        result = (hdr *) GC_scratch_alloc((word)(sizeof(hdr)));
+    } else {
+        result = hdr_free_list;
+        hdr_free_list = (hdr *) (result -> hb_next);
+    }
+    return(result);
+}
+
+static void free_hdr(hhdr)
+hdr * hhdr;
+{
+    hhdr -> hb_next = (struct hblk *) hdr_free_list;
+    hdr_free_list = hhdr;
+}
+ 
+void GC_init_headers()
+{
+    register int i;
+    
+    GC_all_nils = (bottom_index *)GC_scratch_alloc((word)sizeof(bottom_index));
+    BZERO(GC_all_nils, sizeof(bottom_index));
+    for (i = 0; i < TOP_SZ; i++) {
+        GC_top_index[i] = GC_all_nils;
+    }
+}
+
+/* Make sure that there is a bottom level index block for address addr  */
+/* Return FALSE on failure.						*/
+static bool get_index(addr)
+register word addr;
+{
+    register word hi =
+    		(word)(addr) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
+    register bottom_index * r;
+    register bottom_index * p;
+    register bottom_index ** prev;
+#   ifdef HASH_TL
+      register unsigned i = TL_HASH(hi);
+      register bottom_index * old;
+      
+      old = p = GC_top_index[i];
+      while(p != GC_all_nils) {
+          if (p -> key == hi) return(TRUE);
+          p = p -> hash_link;
+      }
+      r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index)));
+      if (r == 0) return(FALSE);
+      BZERO(r, sizeof (bottom_index));
+      r -> hash_link = old;
+      GC_top_index[i] = r;
+#   else
+      if (GC_top_index[hi] != GC_all_nils) return(TRUE);
+      r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index)));
+      if (r == 0) return(FALSE);
+      GC_top_index[hi] = r;
+      BZERO(r, sizeof (bottom_index));
+# endif
+    r -> key = hi;
+    /* Add it to the list of bottom indices */
+      prev = &GC_all_bottom_indices;
+      while ((p = *prev) != 0 && p -> key < hi) prev = &(p -> asc_link);
+      r -> asc_link = p;
+      *prev = r;
+    return(TRUE);
+}
+
+/* Install a header for block h.  */
+/* The header is uninitialized.	  */
+/* Returns FALSE on failure.	  */
+bool GC_install_header(h)
+register struct hblk * h;
+{
+    hdr * result;
+    
+    if (!get_index((word) h)) return(FALSE);
+    result = alloc_hdr();
+    SET_HDR(h, result);
+    return(result != 0);
+}
+
+/* Set up forwarding counts for block h of size sz */
+bool GC_install_counts(h, sz)
+register struct hblk * h;
+register word sz; /* bytes */
+{
+    register struct hblk * hbp;
+    register int i;
+    
+    for (hbp = h; (char *)hbp < (char *)h + sz; hbp += BOTTOM_SZ) {
+        if (!get_index((word) hbp)) return(FALSE);
+    }
+    if (!get_index((word)h + sz - 1)) return(FALSE);
+    for (hbp = h + 1; (char *)hbp < (char *)h + sz; hbp += 1) {
+        i = HBLK_PTR_DIFF(hbp, h);
+        SET_HDR(hbp, (hdr *)(i > MAX_JUMP? MAX_JUMP : i));
+    }
+    return(TRUE);
+}
+
+/* Remove the header for block h */
+void GC_remove_header(h)
+register struct hblk * h;
+{
+    hdr ** ha;
+    
+    GET_HDR_ADDR(h, ha);
+    free_hdr(*ha);
+    *ha = 0;
+}
+
+/* Remove forwarding counts for h */
+void GC_remove_counts(h, sz)
+register struct hblk * h;
+register word sz; /* bytes */
+{
+    register struct hblk * hbp;
+    
+    for (hbp = h+1; (char *)hbp < (char *)h + sz; hbp += 1) {
+        SET_HDR(hbp, 0);
+    }
+}
+
+/* Apply fn to all allocated blocks */
+/*VARARGS1*/
+void GC_apply_to_all_blocks(fn, client_data)
+void (*fn)(/* struct hblk *h, word client_data */);
+word client_data;
+{
+    register int j;
+    register bottom_index * index_p;
+    
+    for (index_p = GC_all_bottom_indices; index_p != 0;
+         index_p = index_p -> asc_link) {
+        for (j = BOTTOM_SZ-1; j >= 0;) {
+            if (!IS_FORWARDING_ADDR_OR_NIL(index_p->index[j])) {
+                if (index_p->index[j]->hb_map != GC_invalid_map) {
+                    (*fn)(((struct hblk *)
+                  	      (((index_p->key << LOG_BOTTOM_SZ) + (word)j)
+                  	       << LOG_HBLKSIZE)),
+                          client_data);
+                }
+                j--;
+             } else if (index_p->index[j] == 0) {
+                j--;
+             } else {
+                j -= (word)(index_p->index[j]);
+             }
+         }
+     }
+}
+
+/* Get the next valid block whose address is at least h	*/
+/* Return 0 if there is none.				*/
+struct hblk * GC_next_block(h)
+struct hblk * h;
+{
+    register bottom_index * bi;
+    register word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1);
+    
+    GET_BI(h, bi);
+    if (bi == GC_all_nils) {
+        register word hi = (word)h >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
+        bi = GC_all_bottom_indices;
+        while (bi != 0 && bi -> key < hi) bi = bi -> asc_link;
+        j = 0;
+    }
+    while(bi != 0) {
+        while (j < BOTTOM_SZ) {
+            if (IS_FORWARDING_ADDR_OR_NIL(bi -> index[j])) {
+                j++;
+            } else {
+                if (bi->index[j]->hb_map != GC_invalid_map) {
+                    return((struct hblk *)
+                  	      (((bi -> key << LOG_BOTTOM_SZ) + j)
+                  	       << LOG_HBLKSIZE));
+                } else {
+                    j += divHBLKSZ(bi->index[j] -> hb_sz);
+                }
+            }
+        }
+        j = 0;
+        bi = bi -> asc_link;
+    }
+    return(0);
+}
diff --git a/src/mzscheme/gc/if_mach.c b/src/mzscheme/gc/if_mach.c
new file mode 100644
index 0000000..f6ffc22
--- /dev/null
+++ b/src/mzscheme/gc/if_mach.c
@@ -0,0 +1,40 @@
+/* Conditionally execute a command based on machine and OS from config.h */
+/* Boehm, November 21, 1994 1:40 pm PST */
+# include "config.h"
+# include <stdio.h>
+
+/* MATTHEW: added (an optional) NOT flag to invert the test,
+   doesn't try to execute ":" */
+
+int main(argc, argv, envp)
+int argc;
+char ** argv;
+char ** envp;
+{
+    if (argc < 4) goto Usage;
+    if (strcmp(MACH_TYPE, argv[1]) != 0) goto notmach;
+    if (strcmp(OS_TYPE, "") != 0 && strcmp(argv[2], "") != 0
+        && strcmp(OS_TYPE, argv[2]) != 0) goto notmach;
+    if (strcmp("NOT", argv[3])) {
+      if (!strcmp(argv[3], ":")) return 0;
+      execvp(argv[3], argv+3);
+    } else
+      return(0);
+    perror("Couldn't execute");
+    
+notmach:
+    if (!strcmp("NOT", argv[3])) {
+      if (!strcmp(argv[4], ":")) return 0;
+      execvp(argv[4], argv+4);
+    } else
+      return(0);
+    perror("Couldn't execute");
+
+    
+Usage:
+    fprintf(stderr, "Usage: %s mach_type os_type [NOT] command\n", argv[0]);
+    fprintf(stderr, "Currently mach_type = %s, os_type = %s\n",
+    	    MACH_TYPE, OS_TYPE);
+    return(1);
+}
+
diff --git a/src/mzscheme/gc/if_not_there.c b/src/mzscheme/gc/if_not_there.c
new file mode 100644
index 0000000..392393c
--- /dev/null
+++ b/src/mzscheme/gc/if_not_there.c
@@ -0,0 +1,25 @@
+/* Conditionally execute a command based if the file argv[1] doesn't exist */
+/* Except for execvp, we stick to ANSI C.				   */
+# include "config.h"
+# include <stdio.h>
+
+int main(argc, argv, envp)
+int argc;
+char ** argv;
+char ** envp;
+{
+    FILE * f;
+    if (argc < 3) goto Usage;
+    if ((f = fopen(argv[1], "rb")) != 0
+        || (f = fopen(argv[1], "r")) != 0) {
+        fclose(f);
+        return(0);
+    }
+    execvp(argv[2], argv+2);
+    exit(1);
+    
+Usage:
+    fprintf(stderr, "Usage: %s file_name command\n", argv[0]);
+    return(1);
+}
+
diff --git a/src/mzscheme/gc/include/cord.h b/src/mzscheme/gc/include/cord.h
new file mode 100644
index 0000000..584112f
--- /dev/null
+++ b/src/mzscheme/gc/include/cord.h
@@ -0,0 +1,327 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Author: Hans-J. Boehm (boehm@parc.xerox.com)
+ */
+/* Boehm, October 5, 1995 4:20 pm PDT */
+ 
+/*
+ * Cords are immutable character strings.  A number of operations
+ * on long cords are much more efficient than their strings.h counterpart.
+ * In particular, concatenation takes constant time independent of the length
+ * of the arguments.  (Cords are represented as trees, with internal
+ * nodes representing concatenation and leaves consisting of either C
+ * strings or a functional description of the string.)
+ *
+ * The following are reasonable applications of cords.  They would perform
+ * unacceptably if C strings were used:
+ * - A compiler that produces assembly language output by repeatedly
+ *   concatenating instructions onto a cord representing the output file.
+ * - A text editor that converts the input file to a cord, and then
+ *   performs editing operations by producing a new cord representing
+ *   the file after echa character change (and keeping the old ones in an
+ *   edit history)
+ *
+ * For optimal performance, cords should be built by
+ * concatenating short sections.
+ * This interface is designed for maximum compatibility with C strings.
+ * ASCII NUL characters may be embedded in cords using CORD_from_fn.
+ * This is handled correctly, but CORD_to_char_star will produce a string
+ * with embedded NULs when given such a cord. 
+ *
+ * This interface is fairly big, largely for performance reasons.
+ * The most basic constants and functions:
+ *
+ * CORD - the type fo a cord;
+ * CORD_EMPTY - empty cord;
+ * CORD_len(cord) - length of a cord;
+ * CORD_cat(cord1,cord2) - concatenation of two cords;
+ * CORD_substr(cord, start, len) - substring (or subcord);
+ * CORD_pos i;  CORD_FOR(i, cord) {  ... CORD_pos_fetch(i) ... } -
+ *    examine each character in a cord.  CORD_pos_fetch(i) is the char.
+ * CORD_fetch(int i) - Retrieve i'th character (slowly).
+ * CORD_cmp(cord1, cord2) - compare two cords.
+ * CORD_from_file(FILE * f) - turn a read-only file into a cord.
+ * CORD_to_char_star(cord) - convert to C string.
+ *   (Non-NULL C constant strings are cords.)
+ * CORD_printf (etc.) - cord version of printf. Use %r for cords.
+ */
+# ifndef CORD_H
+
+# define CORD_H
+# include <stddef.h>
+# include <stdio.h>
+/* Cords have type const char *.  This is cheating quite a bit, and not	*/
+/* 100% portable.  But it means that nonempty character string		*/
+/* constants may be used as cords directly, provided the string is	*/
+/* never modified in place.  The empty cord is represented by, and	*/
+/* can be written as, 0.						*/
+
+typedef const char * CORD;
+
+/* An empty cord is always represented as nil 	*/
+# define CORD_EMPTY 0
+
+/* Is a nonempty cord represented as a C string? */
+#define CORD_IS_STRING(s) (*(s) != '\0')
+
+/* Concatenate two cords.  If the arguments are C strings, they may 	*/
+/* not be subsequently altered.						*/
+CORD CORD_cat(CORD x, CORD y);
+
+/* Concatenate a cord and a C string with known length.  Except for the	*/
+/* empty string case, this is a special case of CORD_cat.  Since the	*/
+/* length is known, it can be faster.					*/
+/* The string y is shared with the resulting CORD.  Hence it should	*/
+/* not be altered by the caller.					*/
+CORD CORD_cat_char_star(CORD x, const char * y, size_t leny);
+
+/* Compute the length of a cord */
+size_t CORD_len(CORD x);
+
+/* Cords may be represented by functions defining the ith character */
+typedef char (* CORD_fn)(size_t i, void * client_data);
+
+/* Turn a functional description into a cord. 	*/
+CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len);
+
+/* Return the substring (subcord really) of x with length at most n,	*/
+/* starting at position i.  (The initial character has position 0.)	*/
+CORD CORD_substr(CORD x, size_t i, size_t n);
+
+/* Return the argument, but rebalanced to allow more efficient   	*/
+/* character retrieval, substring operations, and comparisons.		*/
+/* This is useful only for cords that were built using repeated 	*/
+/* concatenation.  Guarantees log time access to the result, unless	*/
+/* x was obtained through a large number of repeated substring ops	*/
+/* or the embedded functional descriptions take longer to evaluate.	*/
+/* May reallocate significant parts of the cord.  The argument is not	*/
+/* modified; only the result is balanced.				*/
+CORD CORD_balance(CORD x);
+
+/* The following traverse a cord by applying a function to each 	*/
+/* character.  This is occasionally appropriate, especially where	*/
+/* speed is crucial.  But, since C doesn't have nested functions,	*/
+/* clients of this sort of traversal are clumsy to write.  Consider	*/
+/* the functions that operate on cord positions instead.		*/
+
+/* Function to iteratively apply to individual characters in cord.	*/
+typedef int (* CORD_iter_fn)(char c, void * client_data);
+
+/* Function to apply to substrings of a cord.  Each substring is a 	*/
+/* a C character string, not a general cord.				*/
+typedef int (* CORD_batched_iter_fn)(const char * s, void * client_data);
+# define CORD_NO_FN ((CORD_batched_iter_fn)0)
+
+/* Apply f1 to each character in the cord, in ascending order,		*/
+/* starting at position i. If						*/
+/* f2 is not CORD_NO_FN, then multiple calls to f1 may be replaced by	*/
+/* a single call to f2.  The parameter f2 is provided only to allow	*/
+/* some optimization by the client.  This terminates when the right	*/
+/* end of this string is reached, or when f1 or f2 return != 0.  In the	*/
+/* latter case CORD_iter returns != 0.  Otherwise it returns 0.		*/
+/* The specified value of i must be < CORD_len(x).			*/
+int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1,
+	       CORD_batched_iter_fn f2, void * client_data);
+
+/* A simpler version that starts at 0, and without f2:	*/
+int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data);
+# define CORD_iter(x, f1, cd) CORD_iter5(x, 0, f1, CORD_NO_FN, cd)
+
+/* Similar to CORD_iter5, but end-to-beginning.	No provisions for	*/
+/* CORD_batched_iter_fn.						*/
+int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data);
+
+/* A simpler version that starts at the end:	*/
+int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data);
+
+/* Functions that operate on cord positions.  The easy way to traverse	*/
+/* cords.  A cord position is logically a pair consisting of a cord	*/
+/* and an index into that cord.  But it is much faster to retrieve a	*/
+/* charcter based on a position than on an index.  Unfortunately,	*/
+/* positions are big (order of a few 100 bytes), so allocate them with	*/
+/* caution.								*/
+/* Things in cord_pos.h should be treated as opaque, except as		*/
+/* described below.  Also note that					*/
+/* CORD_pos_fetch, CORD_next and CORD_prev have both macro and function	*/
+/* definitions.  The former may evaluate their argument more than once. */
+# include "private/cord_pos.h"
+
+/*
+	Visible definitions from above:
+	
+	typedef <OPAQUE but fairly big> CORD_pos[1];
+	
+	* Extract the cord from a position:
+	CORD CORD_pos_to_cord(CORD_pos p);
+	
+	* Extract the current index from a position:
+	size_t CORD_pos_to_index(CORD_pos p);
+	
+	* Fetch the character located at the given position:
+	char CORD_pos_fetch(CORD_pos p);
+	
+	* Initialize the position to refer to the given cord and index.
+	* Note that this is the most expensive function on positions:
+	void CORD_set_pos(CORD_pos p, CORD x, size_t i);
+	
+	* Advance the position to the next character.
+	* P must be initialized and valid.
+	* Invalidates p if past end:
+	void CORD_next(CORD_pos p);
+	
+	* Move the position to the preceding character.
+	* P must be initialized and valid.
+	* Invalidates p if past beginning:
+	void CORD_prev(CORD_pos p);
+	
+	* Is the position valid, i.e. inside the cord?
+	int CORD_pos_valid(CORD_pos p);
+*/
+# define CORD_FOR(pos, cord) \
+    for (CORD_set_pos(pos, cord, 0); CORD_pos_valid(pos); CORD_next(pos))
+
+			
+/* An out of memory handler to call.  May be supplied by client.	*/
+/* Must not return.							*/
+extern void (* CORD_oom_fn)(void);
+
+/* Dump the representation of x to stdout in an implementation defined	*/
+/* manner.  Intended for debugging only.				*/
+void CORD_dump(CORD x);
+
+/* The following could easily be implemented by the client.  They are	*/
+/* provided in cordxtra.c for convenience.				*/
+
+/* Concatenate a character to the end of a cord.	*/
+CORD CORD_cat_char(CORD x, char c);
+
+/* Concatenate n cords.	*/
+CORD CORD_catn(int n, /* CORD */ ...);
+
+/* Return the character in CORD_substr(x, i, 1)  	*/
+char CORD_fetch(CORD x, size_t i);
+
+/* Return < 0, 0, or > 0, depending on whether x < y, x = y, x > y	*/
+int CORD_cmp(CORD x, CORD y);
+
+/* A generalization that takes both starting positions for the 		*/
+/* comparison, and a limit on the number of characters to be compared.	*/
+int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len);
+
+/* Find the first occurrence of s in x at position start or later.	*/
+/* Return the position of the first character of s in x, or		*/
+/* CORD_NOT_FOUND if there is none.					*/
+size_t CORD_str(CORD x, size_t start, CORD s);
+
+/* Return a cord consisting of i copies of (possibly NUL) c.  Dangerous	*/
+/* in conjunction with CORD_to_char_star.				*/
+/* The resulting representation takes constant space, independent of i.	*/
+CORD CORD_chars(char c, size_t i);
+# define CORD_nul(i) CORD_chars('\0', (i))
+
+/* Turn a file into cord.  The file must be seekable.  Its contents	*/
+/* must remain constant.  The file may be accessed as an immediate	*/
+/* result of this call and/or as a result of subsequent accesses to 	*/
+/* the cord.  Short files are likely to be immediately read, but	*/
+/* long files are likely to be read on demand, possibly relying on 	*/
+/* stdio for buffering.							*/
+/* We must have exclusive access to the descriptor f, i.e. we may	*/
+/* read it at any time, and expect the file pointer to be		*/
+/* where we left it.  Normally this should be invoked as		*/
+/* CORD_from_file(fopen(...))						*/
+/* CORD_from_file arranges to close the file descriptor when it is no	*/
+/* longer needed (e.g. when the result becomes inaccessible).		*/ 
+/* The file f must be such that ftell reflects the actual character	*/
+/* position in the file, i.e. the number of characters that can be 	*/
+/* or were read with fread.  On UNIX systems this is always true.  On	*/
+/* MS Windows systems, f must be opened in binary mode.			*/
+CORD CORD_from_file(FILE * f);
+
+/* Equivalent to the above, except that the entire file will be read	*/
+/* and the file pointer will be closed immediately.			*/
+/* The binary mode restriction from above does not apply.		*/
+CORD CORD_from_file_eager(FILE * f);
+
+/* Equivalent to the above, except that the file will be read on demand.*/
+/* The binary mode restriction applies.					*/
+CORD CORD_from_file_lazy(FILE * f);
+
+/* Turn a cord into a C string.	The result shares no structure with	*/
+/* x, and is thus modifiable.						*/
+char * CORD_to_char_star(CORD x);
+
+/* Turn a C string into a CORD.  The C string is copied, and so may	*/
+/* subsequently be modified.						*/
+CORD CORD_from_char_star(const char *s);
+
+/* Identical to the above, but the result may share structure with	*/
+/* the argument and is thus not modifiable.				*/
+const char * CORD_to_const_char_star(CORD x); 
+
+/* Write a cord to a file, starting at the current position.  No	*/
+/* trailing NULs are newlines are added.				*/
+/* Returns EOF if a write error occurs, 1 otherwise.			*/
+int CORD_put(CORD x, FILE * f);
+
+/* "Not found" result for the following two functions.			*/
+# define CORD_NOT_FOUND ((size_t)(-1))
+
+/* A vague analog of strchr.  Returns the position (an integer, not	*/
+/* a pointer) of the first occurrence of (char) c inside x at position 	*/
+/* i or later. The value i must be < CORD_len(x).			*/
+size_t CORD_chr(CORD x, size_t i, int c);
+
+/* A vague analog of strrchr.  Returns index of the last occurrence	*/
+/* of (char) c inside x at position i or earlier. The value i		*/
+/* must be < CORD_len(x).						*/
+size_t CORD_rchr(CORD x, size_t i, int c);
+
+
+/* The following are also not primitive, but are implemented in 	*/
+/* cordprnt.c.  They provide functionality similar to the ANSI C	*/
+/* functions with corresponding names, but with the following		*/
+/* additions and changes:						*/
+/* 1. A %r conversion specification specifies a CORD argument.  Field	*/
+/*    width, precision, etc. have the same semantics as for %s.		*/
+/*    (Note that %c,%C, and %S were already taken.)			*/
+/* 2. The format string is represented as a CORD.		        */
+/* 3. CORD_sprintf and CORD_vsprintf assign the result through the 1st	*/ 	/*    argument.	Unlike their ANSI C versions, there is no need to guess	*/
+/*    the correct buffer size.						*/
+/* 4. Most of the conversions are implement through the native 		*/
+/*    vsprintf.  Hence they are usually no faster, and 			*/
+/*    idiosyncracies of the native printf are preserved.  However,	*/
+/*    CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied;	*/
+/*    the result shares the original structure.  This may make them	*/
+/*    very efficient in some unusual applications.			*/
+/*    The format string is copied.					*/
+/* All functions return the number of characters generated or -1 on	*/
+/* error.  This complies with the ANSI standard, but is inconsistent	*/
+/* with some older implementations of sprintf.				*/
+
+/* The implementation of these is probably less portable than the rest	*/
+/* of this package.							*/
+
+#ifndef CORD_NO_IO
+
+#include <stdarg.h>
+
+int CORD_sprintf(CORD * out, CORD format, ...);
+int CORD_vsprintf(CORD * out, CORD format, va_list args);
+int CORD_fprintf(FILE * f, CORD format, ...);
+int CORD_vfprintf(FILE * f, CORD format, va_list args);
+int CORD_printf(CORD format, ...);
+int CORD_vprintf(CORD format, va_list args);
+
+#endif /* CORD_NO_IO */
+
+# endif /* CORD_H */
diff --git a/src/mzscheme/gc/include/ec.h b/src/mzscheme/gc/include/ec.h
new file mode 100644
index 0000000..c829b83
--- /dev/null
+++ b/src/mzscheme/gc/include/ec.h
@@ -0,0 +1,70 @@
+# ifndef EC_H
+# define EC_H
+
+# ifndef CORD_H
+#  include "cord.h"
+# endif
+
+/* Extensible cords are strings that may be destructively appended to.	*/
+/* They allow fast construction of cords from characters that are	*/
+/* being read from a stream.						*/
+/*
+ * A client might look like:
+ *
+ *	{
+ *	    CORD_ec x;
+ *	    CORD result;
+ *	    char c;
+ *	    FILE *f;
+ *
+ *	    ...
+ *	    CORD_ec_init(x);
+ *	    while(...) {
+ *		c = getc(f);
+ *		...
+ *		CORD_ec_append(x, c);
+ *	    }
+ *	    result = CORD_balance(CORD_ec_to_cord(x));
+ *
+ * If a C string is desired as the final result, the call to CORD_balance
+ * may be replaced by a call to CORD_to_char_star.
+ */
+
+# ifndef CORD_BUFSZ
+#   define CORD_BUFSZ 128
+# endif
+
+typedef struct CORD_ec_struct {
+    CORD ec_cord;
+    char * ec_bufptr;
+    char ec_buf[CORD_BUFSZ+1];
+} CORD_ec[1];
+
+/* This structure represents the concatenation of ec_cord with		*/
+/* ec_buf[0 ... (ec_bufptr-ec_buf-1)]					*/
+
+/* Flush the buffer part of the extended chord into ec_cord.	*/
+/* Note that this is almost the only real function, and it is	*/
+/* implemented in 6 lines in cordxtra.c				*/
+void CORD_ec_flush_buf(CORD_ec x);
+      
+/* Convert an extensible cord to a cord. */
+# define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord)
+
+/* Initialize an extensible cord. */
+# define CORD_ec_init(x) ((x)[0].ec_cord = 0, (x)[0].ec_bufptr = (x)[0].ec_buf)
+
+/* Append a character to an extensible cord.	*/
+# define CORD_ec_append(x, c) \
+    {  \
+	if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
+	  	CORD_ec_flush_buf(x); \
+	} \
+	*((x)[0].ec_bufptr)++ = (c); \
+    }
+
+/* Append a cord to an extensible cord.  Structure remains shared with 	*/
+/* original.								*/
+void CORD_ec_append_cord(CORD_ec x, CORD s);
+
+# endif /* EC_H */
diff --git a/src/mzscheme/gc/include/gc.h b/src/mzscheme/gc/include/gc.h
new file mode 100644
index 0000000..82d6ebf
--- /dev/null
+++ b/src/mzscheme/gc/include/gc.h
@@ -0,0 +1,656 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * Note that this defines a large number of tuning hooks, which can
+ * safely be ignored in nearly all cases.  For normal use it suffices
+ * to call only GC_MALLOC and perhaps GC_REALLOC.
+ * For better performance, also look at GC_MALLOC_ATOMIC, and
+ * GC_enable_incremental.  If you need an action to be performed
+ * immediately before an object is collected, look at GC_register_finalizer.
+ * If you are using Solaris threads, look at the end of this file.
+ * Everything else is best ignored unless you encounter performance
+ * problems.
+ */
+ 
+#ifndef _GC_H
+
+# define _GC_H
+# define __GC
+# include <stddef.h>
+
+
+#if defined(_MSC_VER) && defined(_DLL)
+#ifdef GC_BUILD
+#define GC_API __declspec(dllexport)
+#else
+#define GC_API __declspec(dllimport)
+#endif
+#endif
+
+#ifndef GC_API
+#define GC_API extern
+#endif
+
+# if defined(__STDC__) || defined(__cplusplus)
+#   define GC_PROTO(args) args
+    typedef void * GC_PTR;
+# else
+#   define GC_PROTO(args) ()
+    typedef char * GC_PTR;
+#  endif
+
+# ifdef __cplusplus
+    extern "C" {
+# endif
+
+
+/* Define word and signed_word to be unsigned and signed types of the 	*/
+/* size as char * or void *.  There seems to be no way to do this	*/
+/* even semi-portably.  The following is probably no better/worse 	*/
+/* than almost anything else.						*/
+/* The ANSI standard suggests that size_t and ptr_diff_t might be 	*/
+/* better choices.  But those appear to have incorrect definitions	*/
+/* on may systems.  Notably "typedef int size_t" seems to be both	*/
+/* frequent and WRONG.							*/
+typedef unsigned long GC_word;
+typedef long GC_signed_word;
+
+/* Public read-only variables */
+
+GC_API GC_word GC_gc_no;/* Counter incremented per collection.  	*/
+			/* Includes empty GCs at startup.		*/
+			
+
+/* Public R/W variables */
+
+GC_API void * (*GC_oom_fn) GC_PROTO((size_t bytes_requested));
+			/* When there is insufficient memory to satisfy */
+			/* an allocation request, we return		*/
+			/* (*GC_oom_fn)().  By default this just	*/
+			/* returns 0.					*/
+			/* If it returns, it must return 0 or a valid	*/
+			/* pointer to a previously allocated heap 	*/
+			/* object.					*/
+
+GC_API int GC_quiet;	/* Disable statistics output.  Only matters if	*/
+			/* collector has been compiled with statistics	*/
+			/* enabled.  This involves a performance cost,	*/
+			/* and is thus not the default.			*/
+
+GC_API int GC_dont_gc;	/* Dont collect unless explicitly requested, e.g. */
+			/* because it's not safe.			  */
+
+GC_API int GC_dont_expand;
+			/* Dont expand heap unless explicitly requested */
+			/* or forced to.				*/
+
+GC_API int GC_full_freq;    /* Number of partial collections between	*/
+			    /* full collections.  Matters only if	*/
+			    /* GC_incremental is set.			*/
+			
+GC_API GC_word GC_non_gc_bytes;
+			/* Bytes not considered candidates for collection. */
+			/* Used only to control scheduling of collections. */
+
+GC_API GC_word GC_free_space_divisor;
+			/* We try to make sure that we allocate at 	*/
+			/* least N/GC_free_space_divisor bytes between	*/
+			/* collections, where N is the heap size plus	*/
+			/* a rough estimate of the root set size.	*/
+			/* Initially, GC_free_space_divisor = 4.	*/
+			/* Increasing its value will use less space	*/
+			/* but more collection time.  Decreasing it	*/
+			/* will appreciably decrease collection time	*/
+			/* at the expense of space.			*/
+			/* GC_free_space_divisor = 1 will effectively	*/
+			/* disable collections.				*/
+
+GC_API GC_word GC_max_retries;
+			/* The maximum number of GCs attempted before	*/
+			/* reporting out of memory after heap		*/
+			/* expansion fails.  Initially 0.		*/
+			
+			
+/* Public procedures */
+/*
+ * general purpose allocation routines, with roughly malloc calling conv.
+ * The atomic versions promise that no relevant pointers are contained
+ * in the object.  The nonatomic versions guarantee that the new object
+ * is cleared.  GC_malloc_stubborn promises that no changes to the object
+ * will occur after GC_end_stubborn_change has been called on the
+ * result of GC_malloc_stubborn. GC_malloc_uncollectable allocates an object
+ * that is scanned for pointers to collectable objects, but is not itself
+ * collectable.  GC_malloc_uncollectable and GC_free called on the resulting
+ * object implicitly update GC_non_gc_bytes appropriately.
+ */
+GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes));
+GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes));
+
+/* The following is only defined if the library has been suitably	*/
+/* compiled:								*/
+GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
+
+/* Explicitly deallocate an object.  Dangerous if used incorrectly.     */
+/* Requires a pointer to the base of an object.				*/
+/* If the argument is stubborn, it should not be changeable when freed. */
+/* An object should not be enable for finalization when it is 		*/
+/* explicitly deallocated.						*/
+/* GC_free(0) is a no-op, as required by ANSI C for free.		*/
+GC_API void GC_free GC_PROTO((GC_PTR object_addr));
+
+/*
+ * Stubborn objects may be changed only if the collector is explicitly informed.
+ * The collector is implicitly informed of coming change when such
+ * an object is first allocated.  The following routines inform the
+ * collector that an object will no longer be changed, or that it will
+ * once again be changed.  Only nonNIL pointer stores into the object
+ * are considered to be changes.  The argument to GC_end_stubborn_change
+ * must be exacly the value returned by GC_malloc_stubborn or passed to
+ * GC_change_stubborn.  (In the second case it may be an interior pointer
+ * within 512 bytes of the beginning of the objects.)
+ * There is a performance penalty for allowing more than
+ * one stubborn object to be changed at once, but it is acceptable to
+ * do so.  The same applies to dropping stubborn objects that are still
+ * changeable.
+ */
+GC_API void GC_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
+
+/* Return a pointer to the base (lowest address) of an object given	*/
+/* a pointer to a location within the object.				*/
+/* Return 0 if displaced_pointer doesn't point to within a valid	*/
+/* object.								*/
+GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer));
+
+/* Given a pointer to the base of an object, return its size in bytes.	*/
+/* The returned size may be slightly larger than what was originally	*/
+/* requested.								*/
+GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
+
+/* For compatibility with C library.  This is occasionally faster than	*/
+/* a malloc followed by a bcopy.  But if you rely on that, either here	*/
+/* or with the standard C library, your code is broken.  In my		*/
+/* opinion, it shouldn't have been invented, but now we're stuck. -HB	*/
+/* The resulting object has the same kind as the original.		*/
+/* If the argument is stubborn, the result will have changes enabled.	*/
+/* It is an error to have changes enabled for the original object.	*/
+/* Follows ANSI comventions for NULL old_object.			*/
+GC_API GC_PTR GC_realloc GC_PROTO((GC_PTR old_object,
+				   size_t new_size_in_bytes));
+				   
+/* Explicitly increase the heap size.	*/
+/* Returns 0 on failure, 1 on success.  */
+GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes));
+
+/* Limit the heap size to n bytes.  Useful when you're debugging, 	*/
+/* especially on systems that don't handle running out of memory well.	*/
+/* n == 0 ==> unbounded.  This is the default.				*/
+GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
+
+/* Clear the set of root segments.  Wizards only. */
+GC_API void GC_clear_roots GC_PROTO((void));
+
+/* Add a root segment.  Wizards only. */
+GC_API void GC_add_roots GC_PROTO((char * low_address,
+				   char * high_address_plus_1));
+
+/* Add a displacement to the set of those considered valid by the	*/
+/* collector.  GC_register_displacement(n) means that if p was returned */
+/* by GC_malloc, then (char *)p + n will be considered to be a valid	*/
+/* pointer to n.  N must be small and less than the size of p.		*/
+/* (All pointers to the interior of objects from the stack are		*/
+/* considered valid in any case.  This applies to heap objects and	*/
+/* static data.)							*/
+/* Preferably, this should be called before any other GC procedures.	*/
+/* Calling it later adds to the probability of excess memory		*/
+/* retention.								*/
+/* This is a no-op if the collector was compiled with recognition of	*/
+/* arbitrary interior pointers enabled, which is now the default.	*/
+GC_API void GC_register_displacement GC_PROTO((GC_word n));
+
+/* The following version should be used if any debugging allocation is	*/
+/* being done.								*/
+GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
+
+/* Explicitly trigger a full, world-stop collection. 	*/
+GC_API void GC_gcollect GC_PROTO((void));
+
+/* Trigger a full world-stopped collection.  Abort the collection if 	*/
+/* and when stop_func returns a nonzero value.  Stop_func will be 	*/
+/* called frequently, and should be reasonably fast.  This works even	*/
+/* if virtual dirty bits, and hence incremental collection is not 	*/
+/* available for this architecture.  Collections can be aborted faster	*/
+/* than normal pause times for incremental collection.  However,	*/
+/* aborted collections do no useful work; the next collection needs	*/
+/* to start from the beginning.						*/
+typedef int (* GC_stop_func) GC_PROTO((void));
+GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func));
+
+/* Return the number of bytes in the heap.  Excludes collector private	*/
+/* data structures.  Includes empty blocks and fragmentation loss.	*/
+/* Includes some pages that were allocated but never written.		*/
+GC_API size_t GC_get_heap_size GC_PROTO((void));
+
+/* Return the number of bytes allocated since the last collection.	*/
+GC_API size_t GC_get_bytes_since_gc GC_PROTO((void));
+
+/* Enable incremental/generational collection.	*/
+/* Not advisable unless dirty bits are 		*/
+/* available or most heap objects are		*/
+/* pointerfree(atomic) or immutable.		*/
+/* Don't use in leak finding mode.		*/
+/* Ignored if GC_dont_gc is true.		*/
+GC_API void GC_enable_incremental GC_PROTO((void));
+
+/* Perform some garbage collection work, if appropriate.	*/
+/* Return 0 if there is no more work to be done.		*/
+/* Typically performs an amount of work corresponding roughly	*/
+/* to marking from one page.  May do more work if further	*/
+/* progress requires it, e.g. if incremental collection is	*/
+/* disabled.  It is reasonable to call this in a wait loop	*/
+/* until it returns 0.						*/
+GC_API int GC_collect_a_little GC_PROTO((void));
+
+/* Allocate an object of size lb bytes.  The client guarantees that	*/
+/* as long as the object is live, it will be referenced by a pointer	*/
+/* that points to somewhere within the first 256 bytes of the object.	*/
+/* (This should normally be declared volatile to prevent the compiler	*/
+/* from invalidating this assertion.)  This routine is only useful	*/
+/* if a large array is being allocated.  It reduces the chance of 	*/
+/* accidentally retaining such an array as a result of scanning an	*/
+/* integer that happens to be an address inside the array.  (Actually,	*/
+/* it reduces the chance of the allocator not finding space for such	*/
+/* an array, since it will try hard to avoid introducing such a false	*/
+/* reference.)  On a SunOS 4.X or MS Windows system this is recommended */
+/* for arrays likely to be larger than 100K or so.  For other systems,	*/
+/* or if the collector is not configured to recognize all interior	*/
+/* pointers, the threshold is normally much higher.			*/
+GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb));
+GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
+
+/* Debugging (annotated) allocation.  GC_gcollect will check 		*/
+/* objects allocated in this way for overwrites, etc.			*/
+GC_API GC_PTR GC_debug_malloc
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_atomic
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_uncollectable
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API GC_PTR GC_debug_malloc_stubborn
+	GC_PROTO((size_t size_in_bytes, char * descr_string, int descr_int));
+GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr));
+GC_API GC_PTR GC_debug_realloc
+	GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes,
+  		  char * descr_string, int descr_int));
+  			 	 
+GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR));
+GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
+# ifdef GC_DEBUG
+#   define GC_MALLOC(sz) GC_debug_malloc(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, __FILE__, __LINE__)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \
+							__FILE__, __LINE__)
+#   define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, __FILE__, \
+							       __LINE__)
+#   define GC_FREE(p) GC_debug_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_debug_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_debug_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, __FILE__, \
+							       __LINE__)
+#   define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, GC_base(obj))
+#   define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n)
+# else
+#   define GC_MALLOC(sz) GC_malloc(sz)
+#   define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz)
+#   define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz)
+#   define GC_REALLOC(old, sz) GC_realloc(old, sz)
+#   define GC_FREE(p) GC_free(p)
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+	GC_register_finalizer(p, f, d, of, od)
+#   define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
+	GC_register_finalizer_ignore_self(p, f, d, of, od)
+#   define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz)
+#   define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p)
+#   define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p)
+#   define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
+	GC_general_register_disappearing_link(link, obj)
+#   define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n)
+# endif
+/* The following are included because they are often convenient, and	*/
+/* reduce the chance for a misspecifed size argument.  But calls may	*/
+/* expand to something syntactically incorrect if t is a complicated	*/
+/* type expression.  							*/
+# define GC_NEW(t) (t *)GC_MALLOC(sizeof (t))
+# define GC_NEW_ATOMIC(t) (t *)GC_MALLOC_ATOMIC(sizeof (t))
+# define GC_NEW_STUBBORN(t) (t *)GC_MALLOC_STUBBORN(sizeof (t))
+# define GC_NEW_UNCOLLECTABLE(t) (t *)GC_MALLOC_UNCOLLECTABLE(sizeof (t))
+
+/* Finalization.  Some of these primitives are grossly unsafe.		*/
+/* The idea is to make them both cheap, and sufficient to build		*/
+/* a safer layer, closer to PCedar finalization.			*/
+/* The interface represents my conclusions from a long discussion	*/
+/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, 		*/
+/* Christian Jacobi, and Russ Atkinson.  It's not perfect, and		*/
+/* probably nobody else agrees with it.	    Hans-J. Boehm  3/13/92	*/
+typedef void (*GC_finalization_proc)
+  	GC_PROTO((GC_PTR obj, GC_PTR client_data));
+
+GC_API void GC_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+	/* When obj is no longer accessible, invoke		*/
+	/* (*fn)(obj, cd).  If a and b are inaccessible, and	*/
+	/* a points to b (after disappearing links have been	*/
+	/* made to disappear), then only a will be		*/
+	/* finalized.  (If this does not create any new		*/
+	/* pointers to b, then b will be finalized after the	*/
+	/* next collection.)  Any finalizable object that	*/
+	/* is reachable from itself by following one or more	*/
+	/* pointers will not be finalized (or collected).	*/
+	/* Thus cycles involving finalizable objects should	*/
+	/* be avoided, or broken by disappearing links.		*/
+	/* All but the last finalizer registered for an object  */
+	/* is ignored.						*/
+	/* Finalization may be removed by passing 0 as fn.	*/
+	/* Finalizers are implicitly unregistered just before   */
+	/* they are invoked.					*/
+	/* The old finalizer and client data are stored in	*/
+	/* *ofn and *ocd.					*/ 
+	/* Fn is never invoked on an accessible object,		*/
+	/* provided hidden pointers are converted to real 	*/
+	/* pointers only if the allocation lock is held, and	*/
+	/* such conversions are not performed by finalization	*/
+	/* routines.						*/
+	/* If GC_register_finalizer is aborted as a result of	*/
+	/* a signal, the object may be left with no		*/
+	/* finalization, even if neither the old nor new	*/
+	/* finalizer were NULL.					*/
+	/* Obj should be the nonNULL starting address of an 	*/
+	/* object allocated by GC_malloc or friends.		*/
+	/* Note that any garbage collectable object referenced	*/
+	/* by cd will be considered accessible until the	*/
+	/* finalizer is invoked.				*/
+
+/* Another versions of the above follow.  It ignores		*/
+/* self-cycles, i.e. pointers from a finalizable object to	*/
+/* itself.  There is a stylistic argument that this is wrong,	*/
+/* but it's unavoidable for C++, since the compiler may		*/
+/* silently introduce these.  It's also benign in that specific	*/
+/* case.							*/
+GC_API void GC_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_debug_register_finalizer_ignore_self
+	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+
+/* MATTHEW: eager finalizers do not care about cycles at all.
+   The intent is for guardian-like and will-like uses where
+   the object will always be made immediately live again, but
+   some action needed to be triggered by the object's (possibly
+   temporary) unreachableness. */
+GC_API void GC_register_eager_finalizer
+    	GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
+		  GC_finalization_proc *ofn, GC_PTR *ocd));
+
+/* The following routine may be used to break cycles between	*/
+/* finalizable objects, thus causing cyclic finalizable		*/
+/* objects to be finalized in the correct order.  Standard	*/
+/* use involves calling GC_register_disappearing_link(&p),	*/
+/* where p is a pointer that is not followed by finalization	*/
+/* code, and should not be considered in determining 		*/
+/* finalization order.						*/
+GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Link should point to a field of a heap allocated 	*/
+	/* object obj.  *link will be cleared when obj is	*/
+	/* found to be inaccessible.  This happens BEFORE any	*/
+	/* finalization code is invoked, and BEFORE any		*/
+	/* decisions about finalization order are made.		*/
+	/* This is useful in telling the finalizer that 	*/
+	/* some pointers are not essential for proper		*/
+	/* finalization.  This may avoid finalization cycles.	*/
+	/* Note that obj may be resurrected by another		*/
+	/* finalizer, and thus the clearing of *link may	*/
+	/* be visible to non-finalization code.  		*/
+	/* There's an argument that an arbitrary action should  */
+	/* be allowed here, instead of just clearing a pointer. */
+	/* But this causes problems if that action alters, or 	*/
+	/* examines connectivity.				*/
+	/* Returns 1 if link was already registered, 0		*/
+	/* otherwise.						*/
+	/* Only exists for backward compatibility.  See below:	*/
+	
+GC_API int GC_general_register_disappearing_link
+	GC_PROTO((GC_PTR * /* link */, GC_PTR obj));
+	/* A slight generalization of the above. *link is	*/
+	/* cleared when obj first becomes inaccessible.  This	*/
+	/* can be used to implement weak pointers easily and	*/
+	/* safely. Typically link will point to a location	*/
+	/* holding a disguised pointer to obj.  (A pointer 	*/
+	/* inside an "atomic" object is effectively  		*/
+	/* disguised.)   In this way soft			*/
+	/* pointers are broken before any object		*/
+	/* reachable from them are finalized.  Each link	*/
+	/* May be registered only once, i.e. with one obj	*/
+	/* value.  This was added after a long email discussion */
+	/* with John Ellis.					*/
+	/* Obj must be a pointer to the first word of an object */
+	/* we allocated.  It is unsafe to explicitly deallocate */
+	/* the object containing link.  Explicitly deallocating */
+	/* obj may or may not cause link to eventually be	*/
+	/* cleared.						*/
+GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */));
+	/* Returns 0 if link was not actually registered.	*/
+	/* Undoes a registration by either of the above two	*/
+	/* routines.						*/
+
+/* Auxiliary fns to make finalization work correctly with displaced	*/
+/* pointers introduced by the debugging allocators.			*/
+GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data));
+GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data));
+
+/* GC_set_warn_proc can be used to redirect or filter warning messages.	*/
+/* p may not be a NULL pointer.						*/
+typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg));
+GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
+    /* Returns old warning procedure.	*/
+	
+/* The following is intended to be used by a higher level	*/
+/* (e.g. cedar-like) finalization facility.  It is expected	*/
+/* that finalization code will arrange for hidden pointers to	*/
+/* disappear.  Otherwise objects can be accessed after they	*/
+/* have been collected.						*/
+/* Note that putting pointers in atomic objects or in 		*/
+/* nonpointer slots of "typed" objects is equivalent to 	*/
+/* disguising them in this way, and may have other advantages.	*/
+# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS)
+    typedef GC_word GC_hidden_pointer;
+#   define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
+#   define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
+    /* Converting a hidden pointer to a real pointer requires verifying	*/
+    /* that the object still exists.  This involves acquiring the  	*/
+    /* allocator lock to avoid a race with the collector.		*/
+# endif /* I_HIDE_POINTERS */
+
+typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data));
+GC_API GC_PTR GC_call_with_alloc_lock
+        	GC_PROTO((GC_fn_type fn, GC_PTR client_data));
+
+/* Check that p and q point to the same object.  		*/
+/* Fail conspicuously if they don't.				*/
+/* Returns the first argument.  				*/
+/* Succeeds if neither p nor q points to the heap.		*/
+/* May succeed if both p and q point to between heap objects.	*/
+GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
+
+/* Checked pointer pre- and post- increment operations.  Note that	*/
+/* the second argument is in units of bytes, not multiples of the	*/
+/* object size.  This should either be invoked from a macro, or the	*/
+/* call should be automatically generated.				*/
+GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
+GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
+
+/* Check that p is visible						*/
+/* to the collector as a possibly pointer containing location.		*/
+/* If it isn't fail conspicuously.					*/
+/* Returns the argument in all cases.  May erroneously succeed		*/
+/* in hard cases.  (This is intended for debugging use with		*/
+/* untyped allocations.  The idea is that it should be possible, though	*/
+/* slow, to add such a call to all indirect pointer stores.)		*/
+/* Currently useless for multithreaded worlds.				*/
+GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
+
+/* Check that if p is a pointer to a heap page, then it points to	*/
+/* a valid displacement within a heap object.				*/
+/* Fail conspicuously if this property does not hold.			*/
+/* Uninteresting with ALL_INTERIOR_POINTERS.				*/
+/* Always returns its argument.						*/
+GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR	p));
+
+/* Safer, but slow, pointer addition.  Probably useful mainly with 	*/
+/* a preprocessor.  Useful only for heap pointers.			*/
+#ifdef GC_DEBUG
+#   define GC_PTR_ADD3(x, n, type_of_result) \
+	((type_of_result)GC_same_obj((x)+(n), (x)))
+#   define GC_PRE_INCR3(x, n, type_of_result) \
+	((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x))
+#   define GC_POST_INCR2(x, type_of_result) \
+	((type_of_result)GC_post_incr(&(x), sizeof(*x))
+#   ifdef __GNUC__
+#       define GC_PTR_ADD(x, n) \
+	    GC_PTR_ADD3(x, n, typeof(x))
+#   define GC_PRE_INCR(x, n) \
+	    GC_PRE_INCR3(x, n, typeof(x))
+#   define GC_POST_INCR(x, n) \
+	    GC_POST_INCR3(x, typeof(x))
+#   else
+	/* We can't do this right without typeof, which ANSI	*/
+	/* decided was not sufficiently useful.  Repeatedly	*/
+	/* mentioning the arguments seems too dangerous to be	*/
+	/* useful.  So does not casting the result.		*/
+#   	define GC_PTR_ADD(x, n) ((x)+(n))
+#   endif
+#else	/* !GC_DEBUG */
+#   define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n))
+#   define GC_PTR_ADD(x, n) ((x)+(n))
+#   define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n))
+#   define GC_PRE_INCR(x, n) ((x) += (n))
+#   define GC_POST_INCR2(x, n, type_of_result) ((x)++)
+#   define GC_POST_INCR(x, n) ((x)++)
+#endif
+
+/* Safer assignment of a pointer to a nonstack location.	*/
+#ifdef GC_DEBUG
+# ifdef __STDC__
+#   define GC_PTR_STORE(p, q) \
+	(*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# else
+#   define GC_PTR_STORE(p, q) \
+	(*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
+# endif
+#else /* !GC_DEBUG */
+#   define GC_PTR_STORE(p, q) *((p) = (q))
+#endif
+
+/* Fynctions called to report pointer checking errors */
+GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
+
+GC_API void (*GC_is_valid_displacement_print_proc)
+	GC_PROTO((GC_PTR p));
+
+GC_API void (*GC_is_visible_print_proc)
+	GC_PROTO((GC_PTR p));
+
+#ifdef SOLARIS_THREADS
+/* We need to intercept calls to many of the threads primitives, so 	*/
+/* that we can locate thread stacks and stop the world.			*/
+/* Note also that the collector cannot see thread specific data.	*/
+/* Thread specific data should generally consist of pointers to		*/
+/* uncollectable objects, which are deallocated using the destructor	*/
+/* facility in thr_keycreate.						*/
+# include <thread.h>
+# include <signal.h>
+  int GC_thr_create(void *stack_base, size_t stack_size,
+                    void *(*start_routine)(void *), void *arg, long flags,
+                    thread_t *new_thread);
+  int GC_thr_join(thread_t wait_for, thread_t *departed, void **status);
+  int GC_thr_suspend(thread_t target_thread);
+  int GC_thr_continue(thread_t target_thread);
+  void * GC_dlopen(const char *path, int mode);
+
+# define thr_create GC_thr_create
+# define thr_join GC_thr_join
+# define thr_suspend GC_thr_suspend
+# define thr_continue GC_thr_continue
+# define dlopen GC_dlopen
+
+# endif /* SOLARIS_THREADS */
+
+#ifdef IRIX_THREADS
+/* We treat these similarly. */
+# include <pthread.h>
+# include <signal.h>
+
+  int GC_pthread_create(pthread_t *new_thread,
+                        const pthread_attr_t *attr,
+		        void *(*start_routine)(void *), void *arg);
+  int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);
+  int GC_pthread_join(pthread_t thread, void **retval);
+
+# define pthread_create GC_pthread_create
+# define pthread_sigmask GC_pthread_sigmask
+# define pthread_join GC_pthread_join
+
+#endif /* IRIX_THREADS */
+
+#if defined(SOLARIS_THREADS) || defined(IRIX_THREADS)
+/* This returns a list of objects, linked through their first		*/
+/* word.  Its use can greatly reduce lock contention problems, since	*/
+/* the allocation lock can be acquired and released many fewer times.	*/
+GC_PTR GC_malloc_many(size_t lb);
+#define GC_NEXT(p) (*(GC_PTR *)(p)) 	/* Retrieve the next element	*/
+					/* in returned list.		*/
+
+#endif /* SOLARIS_THREADS */
+
+/*
+ * If you are planning on putting
+ * the collector in a SunOS 5 dynamic library, you need to call GC_INIT()
+ * from the statically loaded program section.
+ * This circumvents a Solaris 2.X (X<=4) linker bug.
+ */
+#if defined(sparc) || defined(__sparc)
+#   define GC_INIT() { extern end, etext; \
+		       GC_noop(&end, &etext); }
+#else
+#   define GC_INIT()
+#endif
+
+#ifdef __cplusplus
+    }  /* end of extern "C" */
+#endif
+
+#endif /* _GC_H */
diff --git a/src/mzscheme/gc/include/gc_alloc.h b/src/mzscheme/gc/include/gc_alloc.h
new file mode 100644
index 0000000..f64c112
--- /dev/null
+++ b/src/mzscheme/gc/include/gc_alloc.h
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+//
+// This is a C++ header file that is intended to replace the SGI STL
+// alloc.h.
+//
+// This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
+// and -DALL_INTERIOR_POINTERS.  We also recommend
+// -DREDIRECT_MALLOC=GC_uncollectable_malloc.
+//
+// Some of this could be faster in the explicit deallocation case.  In particular,
+// we spend too much time clearing objects on the free lists.  That could be avoided.
+//
+// This uses template classes with static members, and hence soes not work
+// with g++ 2.7.2 and earlier.
+//
+
+#ifndef GC_ALLOC_H
+
+#define GC_ALLOC_H
+#define __ALLOC_H	// Prevent inclusion of the default version.  Ugly.
+
+#ifndef __ALLOC
+#   define __ALLOC alloc
+#endif
+
+#include <stddef.h>
+#include <string.h>
+
+// The following is just replicated from the conventional SGI alloc.h:
+
+template<class T, class alloc>
+class simple_alloc {
+
+public:
+    static T *allocate(size_t n)
+                { return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
+    static T *allocate(void)
+                { return (T*) alloc::allocate(sizeof (T)); }
+    static void deallocate(T *p, size_t n)
+                { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
+    static void deallocate(T *p)
+                { alloc::deallocate(p, sizeof (T)); }
+};
+
+#include "gc.h"
+
+// The following need to match collector data structures.
+// We can't include gc_priv.h, since that pulls in way too much stuff.
+// This should eventually be factored out into another include file.
+
+extern "C" {
+    extern void ** const GC_objfreelist_ptr;
+    extern void ** const GC_aobjfreelist_ptr;
+    extern void ** const GC_uobjfreelist_ptr;
+    extern void ** const GC_auobjfreelist_ptr;
+
+    extern void GC_incr_words_allocd(size_t words);
+    extern void GC_incr_mem_freed(size_t words);
+
+    extern char * GC_generic_malloc_words_small(size_t word, int kind);
+ 
+    extern void * GC_malloc_atomic_uncollectable(size_t bytes);
+}
+
+// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
+// AUNCOLLECTABLE in gc_priv.h.
+
+enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
+       GC_AUNCOLLECTABLE = 3 };
+
+enum { GC_max_fast_bytes = 255 };
+
+enum { GC_bytes_per_word = sizeof(char *) };
+
+enum { GC_byte_alignment = 8 };
+
+enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
+
+inline void * &GC_obj_link(void * p)
+{   return *(void **)p;  }
+
+// Compute a number of words >= n+1 bytes.
+// The +1 allows for pointers one past the end.
+inline GC_round_up(size_t n)
+{
+    return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
+}
+
+// The same but don't allow for extra byte.
+inline GC_round_up_uncollectable(size_t n)
+{
+    return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
+}
+
+template <int dummy>
+class GC_aux_template {
+public:
+  // File local count of allocated words.  Occasionally this is
+  // added into the global count.  A separate count is necessary since the
+  // real one must be updated with a procedure call.
+  static size_t GC_words_recently_allocd;
+
+  // Same for uncollectable mmory.  Not yet reflected in either
+  // GC_words_recently_allocd or GC_non_gc_bytes.
+  static size_t GC_uncollectable_words_recently_allocd;
+
+  // Similar counter for explicitly deallocated memory.
+  static size_t GC_mem_recently_freed;
+
+  // Again for uncollectable memory.
+  static size_t GC_uncollectable_mem_recently_freed;
+
+  static void * GC_out_of_line_malloc(size_t nwords, int kind);
+};
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
+
+template <int dummy>
+void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
+{
+    GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
+    GC_non_gc_bytes +=
+                GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
+    GC_uncollectable_words_recently_allocd = 0;
+
+    GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
+    GC_non_gc_bytes -= 
+                GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
+    GC_uncollectable_mem_recently_freed = 0;
+
+    GC_incr_words_allocd(GC_words_recently_allocd);
+    GC_words_recently_allocd = 0;
+
+    GC_incr_mem_freed(GC_mem_recently_freed);
+    GC_mem_recently_freed = 0;
+
+    return GC_generic_malloc_words_small(nwords, kind);
+}
+
+typedef GC_aux_template<0> GC_aux;
+
+// A fast, single-threaded, garbage-collected allocator
+// We assume the first word will be immediately overwritten.
+// In this version, deallocation is not a noop, and explicit
+// deallocation is likely to help performance.
+template <int dummy>
+class single_client_gc_alloc_template {
+    public:
+     	static void * allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc(n);
+	    flh = GC_objfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_words_recently_allocd += nwords;
+	    return op;
+        }
+     	static void * ptr_free_allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
+	    flh = GC_aobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_words_recently_allocd += nwords;
+	    return op;
+        }
+	static void deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes)  {
+		GC_free(p);
+	    } else {
+	        flh = GC_objfreelist_ptr + nwords;
+	        GC_obj_link(p) = *flh;
+		memset((char *)p + GC_bytes_per_word, 0,
+		       GC_bytes_per_word * (nwords - 1));
+	        *flh = p;
+	        GC_aux::GC_mem_recently_freed += nwords;
+	    }
+	}
+	static void ptr_free_deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes) {
+		GC_free(p);
+	    } else {
+	    	flh = GC_aobjfreelist_ptr + nwords;
+	    	GC_obj_link(p) = *flh;
+	    	*flh = p;
+	    	GC_aux::GC_mem_recently_freed += nwords;
+	    }
+	}
+};
+
+typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
+
+// Once more, for uncollectable objects.
+template <int dummy>
+class single_client_alloc_template {
+    public:
+     	static void * allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up_uncollectable(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
+	    flh = GC_uobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+	    return op;
+        }
+     	static void * ptr_free_allocate(size_t n)
+        {
+	    size_t nwords = GC_round_up_uncollectable(n);
+	    void ** flh;
+	    void * op;
+
+  	    if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
+	    flh = GC_auobjfreelist_ptr + nwords;
+	    if (0 == (op = *flh)) {
+		return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
+	    }
+	    *flh = GC_obj_link(op);
+	    GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+	    return op;
+        }
+	static void deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes)  {
+		GC_free(p);
+	    } else {
+	        flh = GC_uobjfreelist_ptr + nwords;
+	        GC_obj_link(p) = *flh;
+	        *flh = p;
+	        GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+	    }
+	}
+	static void ptr_free_deallocate(void *p, size_t n)
+	{
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+	   
+	    if (n > GC_max_fast_bytes) {
+		GC_free(p);
+	    } else {
+	    	flh = GC_auobjfreelist_ptr + nwords;
+	    	GC_obj_link(p) = *flh;
+	    	*flh = p;
+	    	GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+	    }
+	}
+};
+
+typedef single_client_alloc_template<0> single_client_alloc;
+
+template < int dummy >
+class gc_alloc_template {
+    public:
+     	static void * allocate(size_t n) { return GC_malloc(n); }
+     	static void * ptr_free_allocate(size_t n)
+		{ return GC_malloc_atomic(n); }
+	static void deallocate(void *p, size_t n) { }
+	static void ptr_free_deallocate(void *p, size_t n) { }
+};
+
+typedef gc_alloc_template < 0 > gc_alloc;
+
+template < int dummy >
+class alloc_template {
+    public:
+     	static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
+     	static void * ptr_free_allocate(size_t n)
+		{ return GC_malloc_atomic_uncollectable(n); }
+	static void deallocate(void *p, size_t n) { GC_free(p); }
+	static void ptr_free_deallocate(void *p, size_t n) { GC_free(p); }
+};
+
+typedef alloc_template < 0 > alloc;
+
+#ifdef _SGI_SOURCE
+
+// We want to specialize simple_alloc so that it does the right thing
+// for all pointerfree types.  At the moment there is no portable way to
+// even approximate that.  The following approximation should work for
+// SGI compilers, and perhaps some others.
+
+# define __GC_SPECIALIZE(T,alloc) \
+class simple_alloc<T, alloc> { \
+public: \
+    static T *allocate(size_t n) \
+	{ return 0 == n? 0 : \
+			 (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
+    static T *allocate(void) \
+	{ return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
+    static void deallocate(T *p, size_t n) \
+	{ if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
+    static void deallocate(T *p) \
+	{ alloc::ptr_free_deallocate(p, sizeof (T)); } \
+};
+
+__GC_SPECIALIZE(char, gc_alloc)
+__GC_SPECIALIZE(int, gc_alloc)
+__GC_SPECIALIZE(unsigned, gc_alloc)
+__GC_SPECIALIZE(float, gc_alloc)
+__GC_SPECIALIZE(double, gc_alloc)
+
+__GC_SPECIALIZE(char, alloc)
+__GC_SPECIALIZE(int, alloc)
+__GC_SPECIALIZE(unsigned, alloc)
+__GC_SPECIALIZE(float, alloc)
+__GC_SPECIALIZE(double, alloc)
+
+__GC_SPECIALIZE(char, single_client_gc_alloc)
+__GC_SPECIALIZE(int, single_client_gc_alloc)
+__GC_SPECIALIZE(unsigned, single_client_gc_alloc)
+__GC_SPECIALIZE(float, single_client_gc_alloc)
+__GC_SPECIALIZE(double, single_client_gc_alloc)
+
+__GC_SPECIALIZE(char, single_client_alloc)
+__GC_SPECIALIZE(int, single_client_alloc)
+__GC_SPECIALIZE(unsigned, single_client_alloc)
+__GC_SPECIALIZE(float, single_client_alloc)
+__GC_SPECIALIZE(double, single_client_alloc)
+
+#endif _SGI_SOURCE
+
+#endif /* GC_ALLOC_H */
diff --git a/src/mzscheme/gc/include/gc_cpp.h b/src/mzscheme/gc/include/gc_cpp.h
new file mode 100644
index 0000000..58a2b35
--- /dev/null
+++ b/src/mzscheme/gc/include/gc_cpp.h
@@ -0,0 +1,334 @@
+#ifndef GC_CPP_H
+#define GC_CPP_H
+#if 0
+/****************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+Permission is hereby granted to use or copy this program for any
+purpose, provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is
+granted, provided the above notices are retained, and a notice that
+the code was modified is included with the above copyright notice.
+****************************************************************************
+
+C++ Interface to the Boehm Collector
+
+    John R. Ellis and Jesse Hull 
+    Last modified on Wed Jan  4 16:30:20 PST 1995 by ellis
+
+MATTHEW: This file is greatly modified from the distributed version
+for MrEd
+
+This interface provides access to the Boehm collector.  It provides
+basic facilities similar to those described in "Safe, Efficient
+Garbage Collection for C++", by John R. Elis and David L. Detlefs
+(ftp.parc.xerox.com:/pub/ellis/gc).
+
+All heap-allocated objects are either "collectable" or
+"uncollectable".  Programs must explicitly delete uncollectable
+objects, whereas the garbage collector will automatically delete
+collectable objects when it discovers them to be inaccessible.
+Collectable objects may freely point at uncollectable objects and vice
+versa.
+
+Objects allocated with the built-in "::operator new" are uncollectable.
+
+Objects derived from class "gc" are collectable.  For example:
+
+    class A: gc {...};
+    A* a = new A;       // a is collectable. 
+
+Collectable instances of non-class types can be allocated using the GC
+placement:
+
+    typedef int A[ 10 ];
+    A* a = new (GC) A;
+
+Uncollectable instances of classes derived from "gc" can be allocated
+using the NoGC placement:
+
+    class A: gc {...};
+    A* a = new (NoGC) A;   // a is uncollectable.
+
+Both uncollectable and collectable objects can be explicitly deleted
+with "delete", which invokes an object's destructors and frees its
+storage immediately.
+
+A collectable object may have a clean-up function, which will be
+invoked when the collector discovers the object to be inaccessible.
+An object derived from "gc_cleanup" or containing a member derived
+from "gc_cleanup" has a default clean-up function that invokes the
+object's destructors.  Explicit clean-up functions may be specified as
+an additional placement argument:
+
+    A* a = ::new (GC, MyCleanup) A;
+
+An object is considered "accessible" by the collector if it can be
+reached by a path of pointers from static variables, automatic
+variables of active functions, or from some object with clean-up
+enabled; pointers from an object to itself are ignored.
+
+Thus, if objects A and B both have clean-up functions, and A points at
+B, B is considered accessible.  After A's clean-up is invoked and its
+storage released, B will then become inaccessible and will have its
+clean-up invoked.  If A points at B and B points to A, forming a
+cycle, then that's considered a storage leak, and neither will be
+collectable.  See the interface gc.h for low-level facilities for
+handling such cycles of objects with clean-up.
+
+The collector cannot guarrantee that it will find all inaccessible
+objects.  In practice, it finds almost all of them.
+
+
+Cautions:
+
+1. Be sure the collector has been augmented with "make c++".
+
+2.  If your compiler supports the new "operator new[]" syntax, then
+add -DOPERATOR_NEW_ARRAY to the Makefile.
+
+If your compiler doesn't support "operator new[]", beware that an
+array of type T, where T is derived from "gc", will by default be
+allocated as an uncollectable object.  Use the explicit GC placement
+to make the array collectable.  For example:
+
+    class A: gc {...};
+    A* a1 = new A[ 10 ];        // uncollectable
+    A* a2 = new (GC) A[ 10 ];   // collectable
+
+3. Arrays of objects derived from "gc_cleanup" do not have default
+clean-up functions.  For example:
+
+    class A: gc_cleanup {...};
+    A* a = new (GC) A[ 10 ];
+
+The elements of "a" will not have their destructors invoked when the
+collector frees "a".  You must supply an explicit clean-up function
+for that to occur.
+
+4. Compiler bugs:
+
+    Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the
+    destructors of classes derived from gc_cleanup won't be invoked.
+    You'll have to explicitly register a clean-up function with
+    new-placement syntax.
+
+    Evidently cfront 3.0 does not allow destructors to be explicitly
+    invoked using the ANSI-conforming syntax t->~T().  If you're using
+    cfront 3.0, you'll have to comment out the class gc_cleanup, which
+    uses explicit invocation.
+
+****************************************************************************/
+#endif
+
+#include "gc.h"
+
+#ifndef THINK_CPLUS
+#define _cdecl
+#endif
+
+#if __BORLANDC__ >= 0x450 && !defined(OPERATOR_NEW_ARRAY)
+#   define OPERATOR_NEW_ARRAY
+#endif
+
+/* MATTHEW: GC => UseGC, Added AtomicGC */
+enum GCPlacement {UseGC, AtomicGC, NoGC};
+
+class gc {public:
+    inline void* operator new( size_t size );
+    inline void* operator new( size_t size, GCPlacement gcp );
+    inline void operator delete( void* obj );
+
+#ifdef OPERATOR_NEW_ARRAY
+    inline void* operator new[]( size_t size );
+    inline void* operator new[]( size_t size, GCPlacement gcp );
+    inline void operator delete[]( void* obj );
+#endif /* OPERATOR_NEW_ARRAY */
+    };    
+    /*
+    Instances of classes derived from "gc" will be allocated in the 
+    collected heap by default, unless an explicit NoGC placement is
+    specified. */
+
+/* MATTHEW: gcc 2.5.8 doesn't like "virtual" here: */
+class gc_cleanup: /* virtual */ public gc {public:
+    void *__gc_external; /* MATTHEW: Need a pointer for MzScheme/MrEd */					    
+    inline gc_cleanup();
+    inline gc_cleanup(int cleanup);
+    inline virtual ~gc_cleanup();
+    inline void install_cleanup();
+private:
+    inline static void _cdecl cleanup( void* obj, void* clientData );
+};
+    /*
+    Instances of classes derived from "gc_cleanup" will be allocated
+    in the collected heap by default.  When the collector discovers an
+    inaccessible object derived from "gc_cleanup" or containing a
+    member derived from "gc_cleanup", its destructors will be
+    invoked. */
+
+extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    Allocates a collectable or uncollected object, according to the
+    value of "gcp".
+
+    For collectable objects, if "cleanup" is non-null, then when the
+    allocated object "obj" becomes inaccessible, the collector will
+    invoke the function "cleanup( obj, clientData )" but will not
+    invoke the object's destructors.  It is an error to explicitly
+    delete an object allocated with a non-null "cleanup".
+
+    It is an error to specify a non-null "cleanup" with NoGC or for
+    classes derived from "gc_cleanup" or containing members derived
+    from "gc_cleanup". */
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[](
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    The operator new for arrays, identical to the above. */
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+/****************************************************************************
+
+Inline implementation
+
+****************************************************************************/
+inline void* gc::operator new( size_t size ) {
+    return GC_MALLOC( size );
+}
+    
+inline void* gc::operator new( size_t size, GCPlacement gcp ) {
+  /* MATTHEW: Added AtomicGC */
+  if (gcp == AtomicGC) 
+    return GC_MALLOC_ATOMIC( size );
+  else if (gcp == UseGC) 
+    return GC_MALLOC( size );
+  else
+    return GC_MALLOC_UNCOLLECTABLE( size );
+}
+
+#if 0
+/* MATTHEW */
+extern void GC_cpp_delete(void *);
+#endif
+
+inline void gc::operator delete( void * /* obj */) {
+  /* MATTHEW: Don't GC_free */
+#if 0
+  GC_cpp_delete(obj); /* zero it */
+#endif
+}
+    
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* gc::operator new[]( size_t size ) {
+    return gc::operator new(size);
+}
+    
+inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
+    return gc::operator new(size, gcp);
+}
+
+inline void gc::operator delete[]( void* obj ) {
+    gc::operator delete( obj );
+}
+    
+#endif /* OPERATOR_NEW_ARRAY */
+
+extern "C" {
+  extern void gc_mark_external_invalid(void *);
+};
+
+inline gc_cleanup::~gc_cleanup(void) {
+  GC_REGISTER_FINALIZER_IGNORE_SELF(this, 0, 0, 0, 0);
+  if (__gc_external) gc_mark_external_invalid(__gc_external);
+}
+
+inline void gc_cleanup::cleanup( void* obj, void* displ ) {
+  gc_cleanup *clean = ((gc_cleanup*) ((char *)obj + (ptrdiff_t)displ));
+  clean->~gc_cleanup();
+#if 0
+  GC_cpp_delete((void *)obj); /* zero it */
+#endif
+}
+
+inline void gc_cleanup::install_cleanup(void) {
+  register void *base = GC_base((void *)this);
+
+  if (base) {
+    GC_finalization_proc old_fn;
+    void *old_data;
+    GC_REGISTER_FINALIZER_IGNORE_SELF(base, cleanup,
+				      (void *)((char *)this - (char *)base), 
+				      &old_fn, &old_data);
+    if (old_fn)
+      /* MATTHEW: Put the old one back. We don't need to register. */
+      GC_REGISTER_FINALIZER_IGNORE_SELF(base, old_fn, old_data, 
+					&old_fn, &old_data);
+  }
+}
+
+inline gc_cleanup::gc_cleanup(void) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  install_cleanup();
+}
+
+inline gc_cleanup::gc_cleanup(int cleanup) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  if (cleanup)
+    install_cleanup();
+}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+  void* obj;
+  
+  if (gcp == UseGC) { /* MATTHEW: GC => UseGC */
+    obj = GC_MALLOC(size);
+    if (cleanup != 0) 
+      GC_REGISTER_FINALIZER_IGNORE_SELF(obj, cleanup, clientData, 0, 0);
+  } if (gcp == AtomicGC) /* MATTHEW: Added AtomicGC */
+    obj = GC_MALLOC_ATOMIC( size );
+  else
+    obj = GC_MALLOC_UNCOLLECTABLE( size );
+
+  return obj;
+}
+        
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[]( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+    return ::operator new( size, gcp, cleanup, clientData );
+  }
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+
+#endif /* GC_CPP_H */
+
diff --git a/src/mzscheme/gc/include/gc_inl.h b/src/mzscheme/gc/include/gc_inl.h
new file mode 100644
index 0000000..700843b
--- /dev/null
+++ b/src/mzscheme/gc/include/gc_inl.h
@@ -0,0 +1,103 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 3, 1995 2:07 pm PDT */
+ 
+# ifndef GC_PRIVATE_H
+#   include "private/gc_priv.h"
+# endif
+
+/* USE OF THIS FILE IS NOT RECOMMENDED unless the collector has been	*/
+/* compiled without -DALL_INTERIOR_POINTERS or with			*/
+/* -DDONT_ADD_BYTE_AT_END, or the specified size includes a pointerfree	*/
+/* word at the end.  In the standard collector configuration,		*/
+/* the final word of each object may not be scanned.			*/
+/* This is most useful for compilers that generate C.			*/
+/* Manual use is hereby discouraged.					*/
+
+/* Allocate n words (NOT BYTES).  X is made to point to the result.	*/
+/* It is assumed that n < MAXOBJSZ, and					*/
+/* that n > 0.  On machines requiring double word alignment of some	*/
+/* data, we also assume that n is 1 or even.  This bypasses the		*/
+/* MERGE_SIZES mechanism.  In order to minimize the number of distinct	*/
+/* free lists that are maintained, the caller should ensure that a 	*/
+/* small number of distinct values of n are used.  (The MERGE_SIZES	*/
+/* mechanism normally does this by ensuring that only the leading three	*/
+/* bits of n may be nonzero.  See misc.c for details.)  We really 	*/
+/* recommend this only in cases in which n is a constant, and no	*/
+/* locking is required.							*/
+/* In that case it may allow the compiler to perform substantial	*/
+/* additional optimizations.						*/
+# define GC_MALLOC_WORDS(result,n) \
+{	\
+    register ptr_t op;	\
+    register ptr_t *opp;	\
+    DCL_LOCK_STATE;	\
+	\
+    opp = &(GC_objfreelist[n]);	\
+    FASTLOCK();	\
+    if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {	\
+        FASTUNLOCK();	\
+        (result) = GC_generic_malloc_words_small((n), NORMAL);	\
+    } else { 	\
+        *opp = obj_link(op);	\
+        obj_link(op) = 0;	\
+        GC_words_allocd += (n);	\
+        FASTUNLOCK();	\
+        (result) = (GC_PTR) op;	\
+    }	\
+}
+
+
+/* The same for atomic objects:	*/
+# define GC_MALLOC_ATOMIC_WORDS(result,n) \
+{	\
+    register ptr_t op;	\
+    register ptr_t *opp;	\
+    DCL_LOCK_STATE;	\
+	\
+    opp = &(GC_aobjfreelist[n]);	\
+    FASTLOCK();	\
+    if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {	\
+        FASTUNLOCK();	\
+        (result) = GC_generic_malloc_words_small((n), PTRFREE);	\
+    } else { 	\
+        *opp = obj_link(op);	\
+        obj_link(op) = 0;	\
+        GC_words_allocd += (n);	\
+        FASTUNLOCK();	\
+        (result) = (GC_PTR) op;	\
+    }	\
+}
+
+/* And once more for two word initialized objects: */
+# define GC_CONS(result, first, second) \
+{	\
+    register ptr_t op;	\
+    register ptr_t *opp;	\
+    DCL_LOCK_STATE;	\
+	\
+    opp = &(GC_objfreelist[2]);	\
+    FASTLOCK();	\
+    if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {	\
+        FASTUNLOCK();	\
+        op = GC_generic_malloc_words_small(2, NORMAL);	\
+    } else {	\
+        *opp = obj_link(op);	\
+        GC_words_allocd += 2;	\
+        FASTUNLOCK();	\
+    } \
+    ((word *)op)[0] = (word)(first);	\
+    ((word *)op)[1] = (word)(second);	\
+    (result) = (GC_PTR) op;	\
+}
diff --git a/src/mzscheme/gc/include/gc_inline.h b/src/mzscheme/gc/include/gc_inline.h
new file mode 100644
index 0000000..db62d1d
--- /dev/null
+++ b/src/mzscheme/gc/include/gc_inline.h
@@ -0,0 +1 @@
+# include "gc_inl.h"
diff --git a/src/mzscheme/gc/include/gc_typed.h b/src/mzscheme/gc/include/gc_typed.h
new file mode 100644
index 0000000..ea20e76
--- /dev/null
+++ b/src/mzscheme/gc/include/gc_typed.h
@@ -0,0 +1,88 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996 Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/*
+ * Some simple primitives for allocation with explicit type information.
+ * Facilities for dynamic type inference may be added later.
+ * Should be used only for extremely performance critical applications,
+ * or if conservative collector leakage is otherwise a problem (unlikely).
+ * Note that this is implemented completely separately from the rest
+ * of the collector, and is not linked in unless referenced.
+ * This does not currently support GC_DEBUG in any interesting way.
+ */
+/* Boehm, May 19, 1994 2:13 pm PDT */
+
+#ifndef _GC_TYPED_H
+# define _GC_TYPED_H
+# ifndef _GC_H
+#   include "gc.h"
+# endif
+
+typedef GC_word * GC_bitmap;
+	/* The least significant bit of the first word is one if	*/
+	/* the first word in the object may be a pointer.		*/
+	
+# define GC_get_bit(bm, index) \
+		(((bm)[divWORDSZ(index)] >> modWORDSZ(index)) & 1)
+# define GC_set_bit(bm, index) \
+		(bm)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index)
+
+typedef GC_word GC_descr;
+
+GC_API GC_descr GC_make_descriptor GC_PROTO((GC_bitmap bm, size_t len));
+		/* Return a type descriptor for the object whose layout	*/
+		/* is described by the argument.			*/
+		/* The least significant bit of the first word is one	*/
+		/* if the first word in the object may be a pointer.	*/
+		/* The second argument specifies the number of		*/
+		/* meaningful bits in the bitmap.  The actual object 	*/
+		/* may be larger (but not smaller).  Any additional	*/
+		/* words in the object are assumed not to contain 	*/
+		/* pointers.						*/
+		/* Returns a conservative approximation in the		*/
+		/* (unlikely) case of insufficient memory to build	*/
+		/* the descriptor.  Calls to GC_make_descriptor		*/
+		/* may consume some amount of a finite resource.  This	*/
+		/* is intended to be called once per type, not once	*/
+		/* per allocation.					*/
+
+GC_API void * GC_malloc_explicitly_typed
+			GC_PROTO((size_t size_in_bytes, GC_descr d));
+		/* Allocate an object whose layout is described by d.	*/
+		/* The resulting object MAY NOT BE PASSED TO REALLOC.	*/
+		
+GC_API void * GC_calloc_explicitly_typed
+			GC_PROTO((size_t nelements,
+  				  size_t element_size_in_bytes,
+  				  GC_descr d));
+  	/* Allocate an array of nelements elements, each of the	*/
+  	/* given size, and with the given descriptor.		*/
+  	/* The elemnt size must be a multiple of the byte	*/
+  	/* alignment required for pointers.  E.g. on a 32-bit	*/
+  	/* machine with 16-bit aligned pointers, size_in_bytes	*/
+  	/* must be a multiple of 2.				*/
+
+#ifdef GC_DEBUG
+#   define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) GC_MALLOC(bytes)
+#   define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) GC_MALLOC(n*bytes)
+#else
+#  define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) \
+	GC_malloc_explicitly_typed(bytes, d)
+#  define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) \
+	GC_calloc_explicitly_typed(n, bytes, d)
+#endif /* !GC_DEBUG */
+
+
+#endif /* _GC_TYPED_H */
+
diff --git a/src/mzscheme/gc/include/private/config.h b/src/mzscheme/gc/include/private/config.h
new file mode 100644
index 0000000..62492c3
--- /dev/null
+++ b/src/mzscheme/gc/include/private/config.h
@@ -0,0 +1,687 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 3, 1995 6:39 pm PDT */
+ 
+#ifndef CONFIG_H
+
+# define CONFIG_H
+
+/* Machine dependent parameters.  Some tuning parameters can be found	*/
+/* near the top of gc_private.h.					*/
+
+/* Machine specific parts contributed by various people.  See README file. */
+
+/* Determine the machine type: */
+# if defined(sun) && defined(mc68000)
+#    define M68K
+#    define SUNOS4
+#    define mach_type_known
+# endif
+# if defined(hp9000s300)
+#    define M68K
+#    define HP
+#    define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(m68k)
+#    define M68K
+#    define NETBSD
+#    define mach_type_known
+# endif
+# if defined(vax)
+#    define VAX
+#    ifdef ultrix
+#	define ULTRIX
+#    else
+#	define BSD
+#    endif
+#    define mach_type_known
+# endif
+# if defined(mips) || defined(__mips)
+#    define MIPS
+#    if defined(ultrix) || defined(__ultrix)
+#	define ULTRIX
+#    else
+#	if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__)
+#	  define IRIX5
+#	else
+#	  define RISCOS  /* or IRIX 4.X */
+#	endif
+#    endif
+#    define mach_type_known
+# endif
+# if defined(sequent) && defined(i386)
+#    define I386
+#    define SEQUENT
+#    define mach_type_known
+# endif
+# if defined(sun) && defined(i386)
+#    define I386
+#    define SUNOS5
+#    define mach_type_known
+# endif
+# if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
+#    define I386
+#    define OS2
+#    define mach_type_known
+# endif
+# if defined(ibm032)
+#   define RT
+#   define mach_type_known
+# endif
+# if defined(sun) && (defined(sparc) || defined(__sparc))
+#   define SPARC
+    /* Test for SunOS 5.x */
+#     include <errno.h>
+#     ifdef ECHRNG
+#       define SUNOS5
+#     else
+#	define SUNOS4
+#     endif
+#   define mach_type_known
+# endif
+# if defined(sparc) && defined(unix) && !defined(sun)
+#   define SPARC
+#   define DRSNX
+#   define mach_type_known
+# endif
+# if defined(_IBMR2)
+#   define RS6000
+#   define mach_type_known
+# endif
+# if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
+	/* The above test may need refinement	*/
+#   define I386
+#   define SCO
+#   define mach_type_known
+# endif
+# if defined(_AUX_SOURCE)
+#   define M68K
+#   define SYSV
+#   define mach_type_known
+# endif
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1)
+#   define HP_PA
+#   define mach_type_known
+# endif
+# if defined(linux) && defined(i386)
+#    define I386
+#    define LINUX
+#    define mach_type_known
+# endif
+# if defined(__alpha)
+#   define ALPHA
+#   define mach_type_known
+# endif
+# if defined(_AMIGA)
+#   define M68K
+#   define AMIGA
+#   define mach_type_known
+# endif
+# if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
+#   define M68K
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(__MWERKS__) && defined(__powerc)
+#   define POWERPC
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(mc68000)
+#   define M68K
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(i386)
+#   define I386
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(__FreeBSD__) && defined(i386)
+#   define I386
+#   define FREEBSD
+#   define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(i386)
+#   define I386
+#   define NETBSD
+#   define mach_type_known
+# endif
+# if defined(bsdi) && defined(i386)
+#    define I386
+#    define BSDI
+#    define mach_type_known
+# endif
+# if !defined(mach_type_known) && defined(__386BSD__)
+#   define I386
+#   define THREE86BSD
+#   define mach_type_known
+# endif
+# if defined(_CX_UX) && defined(_M88K)
+#   define M88K
+#   define CX_UX
+#   define mach_type_known
+# endif
+# if defined(DGUX)
+#   define M88K
+    /* DGUX defined */
+#   define mach_type_known
+# endif
+# if defined(_MSDOS) && (_M_IX86 == 300) || (_M_IX86 == 400)
+#   define I386
+#   define MSWIN32	/* or Win32s */
+#   define mach_type_known
+# endif
+# if defined(GO32)
+#   define I386
+#   define DJGPP  /* MSDOS running the DJGPP port of GCC */
+#   define mach_type_known
+# endif
+# if defined(__BORLANDC__)
+#   define I386
+#   define MSWIN32
+#   define mach_type_known
+# endif
+
+/* Feel free to add more clauses here */
+
+/* Or manually define the machine type here.  A machine type is 	*/
+/* characterized by the architecture.  Some				*/
+/* machine types are further subdivided by OS.				*/
+/* the macros ULTRIX, RISCOS, and BSD to distinguish.			*/
+/* Note that SGI IRIX is treated identically to RISCOS.			*/
+/* SYSV on an M68K actually means A/UX.					*/
+/* The distinction in these cases is usually the stack starting address */
+# ifndef mach_type_known
+	--> unknown machine type
+# endif
+		    /* Mapping is: M68K       ==> Motorola 680X0	*/
+		    /*		   (SUNOS4,HP,NEXT, and SYSV (A/UX),	*/
+		    /*		   MACOS and AMIGA variants)		*/
+		    /*             I386       ==> Intel 386	 	*/
+		    /*		    (SEQUENT, OS2, SCO, LINUX, NETBSD,	*/
+		    /*		     FREEBSD, THREE86BSD, MSWIN32,	*/
+		    /* 		     BSDI, SUNOS5, NEXT	variants)	*/
+                    /*             NS32K      ==> Encore Multimax 	*/
+                    /*             MIPS       ==> R2000 or R3000	*/
+                    /*			(RISCOS, ULTRIX variants)	*/
+                    /*		   VAX	      ==> DEC VAX		*/
+                    /*			(BSD, ULTRIX variants)		*/
+                    /*		   RS6000     ==> IBM RS/6000 AIX3.X	*/
+                    /*		   RT	      ==> IBM PC/RT		*/
+                    /*		   HP_PA      ==> HP9000/700 & /800	*/
+                    /*				  HP/UX			*/
+		    /*		   SPARC      ==> SPARC under SunOS	*/
+		    /*			(SUNOS4, SUNOS5,		*/
+		    /*			 DRSNX variants)		*/
+		    /* 		   ALPHA      ==> DEC Alpha OSF/1	*/
+		    /* 		   M88K       ==> Motorola 88XX0        */
+		    /* 		        (CX_UX and DGUX)		*/
+
+
+/*
+ * For each architecture and OS, the following need to be defined:
+ *
+ * CPP_WORD_SZ is a simple integer constant representing the word size.
+ * in bits.  We assume byte addressibility, where a byte has 8 bits.
+ * We also assume CPP_WORD_SZ is either 32 or 64.
+ * (We care about the length of pointers, not hardware
+ * bus widths.  Thus a 64 bit processor with a C compiler that uses
+ * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
+ *
+ * MACH_TYPE is a string representation of the machine type.
+ * OS_TYPE is analogous for the OS.
+ *
+ * ALIGNMENT is the largest N, such that
+ * all pointer are guaranteed to be aligned on N byte boundaries.
+ * defining it to be 1 will always work, but perform poorly.
+ *
+ * DATASTART is the beginning of the data segment.
+ * On UNIX systems, the collector will scan the area between DATASTART
+ * and &end for root pointers.
+ *
+ * STACKBOTTOM is the cool end of the stack, which is usually the
+ * highest address in the stack.
+ * Under PCR or OS/2, we have other ways of finding thread stacks.
+ * For each machine, the following should:
+ * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
+ * 2) define exactly one of
+ *	STACKBOTTOM (should be defined to be an expression)
+ *	HEURISTIC1
+ *	HEURISTIC2
+ * If either of the last two macros are defined, then STACKBOTTOM is computed
+ * during collector startup using one of the following two heuristics:
+ * HEURISTIC1:  Take an address inside GC_init's frame, and round it up to
+ *		the next multiple of STACK_GRAN.
+ * HEURISTIC2:  Take an address inside GC_init's frame, increment it repeatedly
+ *		in small steps (decrement if STACK_GROWS_UP), and read the value
+ *		at each location.  Remember the value when the first
+ *		Segmentation violation or Bus error is signalled.  Round that
+ *		to the nearest plausible page boundary, and use that instead
+ *		of STACKBOTTOM.
+ *
+ * If no expression for STACKBOTTOM can be found, and neither of the above
+ * heuristics are usable, the collector can still be used with all of the above
+ * undefined, provided one of the following is done:
+ * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
+ *    without reference to STACKBOTTOM.  This is appropriate for use in
+ *    conjunction with thread packages, since there will be multiple stacks.
+ *    (Allocating thread stacks in the heap, and treating them as ordinary
+ *    heap data objects is also possible as a last resort.  However, this is
+ *    likely to introduce significant amounts of excess storage retention
+ *    unless the dead parts of the thread stacks are periodically cleared.)
+ * 2) Client code may set GC_stackbottom before calling any GC_ routines.
+ *    If the author of the client code controls the main program, this is
+ *    easily accomplished by introducing a new main program, setting
+ *    GC_stackbottom to the address of a local variable, and then calling
+ *    the original main program.  The new main program would read something
+ *    like:
+ *
+ *		# include "gc_private.h"
+ *
+ *		main(argc, argv, envp)
+ *		int argc;
+ *		char **argv, **envp;
+ *		{
+ *		    int dummy;
+ *
+ *		    GC_stackbottom = (ptr_t)(&dummy);
+ *		    return(real_main(argc, argv, envp));
+ *		}
+ *
+ *
+ * Each architecture may also define the style of virtual dirty bit
+ * implementation to be used:
+ *   MPROTECT_VDB: Write protect the heap and catch faults.
+ *   PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
+ *
+ * An architecture may define DYNAMIC_LOADING if dynamic_load.c
+ * defined GC_register_dynamic_libraries() for the architecture.
+ */
+
+
+# define STACK_GRAN 0x1000000
+# ifdef M68K
+#   define MACH_TYPE "M68K"
+#   define ALIGNMENT 2
+#   ifdef NETBSD
+#	define OS_TYPE "NETBSD"
+#	define HEURISTIC2
+	extern char etext;
+#	define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef SUNOS4
+#	define OS_TYPE "SUNOS4"
+	extern char etext;
+#	define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
+#	define HEURISTIC1	/* differs	*/
+#	define DYNAMIC_LOADING
+#   endif
+#   ifdef HP
+#	define OS_TYPE "HP"
+	extern char etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0xffeffffc)
+			      /* empirically determined.  seems to work. */
+#   endif
+#   ifdef SYSV
+#	define OS_TYPE "SYSV"
+	extern etext;
+#   	define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+				   & ~0x3fffff) \
+				  +((word)&etext & 0x1fff))
+	/* This only works for shared-text binaries with magic number 0413.
+	   The other sorts of SysV binaries put the data at the end of the text,
+	   in which case the default of &etext would work.  Unfortunately,
+	   handling both would require having the magic-number available.
+	   	   		-- Parag
+	   */
+#	define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
+			/* The stack starts at the top of memory, but   */
+			/* 0x0 cannot be used as setjump_test complains */
+			/* that the stack direction is incorrect.  Two  */
+			/* bytes down from 0x0 should be safe enough.   */
+			/* 		--Parag				*/
+#   endif
+#   ifdef AMIGA
+#	define OS_TYPE "AMIGA"
+ 	    	/* STACKBOTTOM and DATASTART handled specially	*/
+ 	    	/* in os_dep.c					*/
+# 	define DATAEND	/* not needed */
+#   endif
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+			/* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND	/* not needed */
+#   endif
+#   ifdef NEXT
+#	define OS_TYPE "NEXT"
+#	define DATASTART ((ptr_t) get_etext())
+#	define STACKBOTTOM ((ptr_t) 0x4000000)
+#	define DATAEND	/* not needed */
+#   endif
+# endif
+
+# ifdef POWERPC
+#   define MACH_TYPE "POWERPC"
+#   define ALIGNMENT 2
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+			/* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND  /* not needed */
+#   endif
+# endif
+
+# ifdef VAX
+#   define MACH_TYPE "VAX"
+#   define ALIGNMENT 4	/* Pointers are longword aligned by 4.2 C compiler */
+    extern char etext;
+#   define DATASTART ((ptr_t)(&etext))
+#   ifdef BSD
+#	define OS_TYPE "BSD"
+#	define HEURISTIC1
+			/* HEURISTIC2 may be OK, but it's hard to test. */
+#   endif
+#   ifdef ULTRIX
+#	define OS_TYPE "ULTRIX"
+#	define STACKBOTTOM ((ptr_t) 0x7fffc800)
+#   endif
+# endif
+
+# ifdef RT
+#   define MACH_TYPE "RT"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t) 0x10000000)
+#   define STACKBOTTOM ((ptr_t) 0x1fffd800)
+# endif
+
+# ifdef SPARC
+#   define MACH_TYPE "SPARC"
+#   define ALIGNMENT 4	/* Required by hardware	*/
+    extern int etext;
+#   ifdef SUNOS5
+#	define OS_TYPE "SUNOS5"
+	extern int _etext;
+	extern int _end;
+	extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#	define DATAEND (&_end)
+#	define PROC_VDB
+#	define HEURISTIC1
+#   endif
+#   ifdef SUNOS4
+#	define OS_TYPE "SUNOS4"
+	/* [If you have a weak stomach, don't read this.]		*/
+	/* We would like to use:					*/
+/* #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
+	/* This fails occasionally, due to an ancient, but very 	*/
+	/* persistent ld bug.  &etext is set 32 bytes too high.		*/
+	/* We instead read the text segment size from the a.out		*/
+	/* header, which happens to be mapped into our address space	*/
+	/* at the start of the text segment.  The detective work here	*/
+	/* was done by Robert Ehrlich, Manuel Serrano, and Bernard	*/
+	/* Serpette of INRIA.						*/
+	/* This assumes ZMAGIC, i.e. demand-loadable executables.	*/
+#	define TEXTSTART 0x2000
+#       define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
+#	define MPROTECT_VDB
+#	define HEURISTIC1
+#   endif
+#   ifdef DRSNX
+#       define CPP_WORDSZ 32
+#	define OS_TYPE "DRSNX"
+	extern char * GC_SysVGetDataStart();
+	extern int etext;
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#	define MPROTECT_VDB
+#       define STACKBOTTOM ((ptr_t) 0xdfff0000)
+#   endif
+#   define DYNAMIC_LOADING
+# endif
+
+# ifdef I386
+#   define MACH_TYPE "I386"
+#   define ALIGNMENT 4	/* Appears to hold for all "32 bit" compilers	*/
+			/* except Borland.  The -a4 option fixes 	*/
+			/* Borland.					*/
+#   ifdef SEQUENT
+#	define OS_TYPE "SEQUENT"
+	extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0x3ffff000) 
+#   endif
+#   ifdef SUNOS5
+#	define OS_TYPE "SUNOS5"
+  	extern int etext, _start;
+  	extern char * GC_SysVGetDataStart();
+#       define DATASTART GC_SysVGetDataStart(0x1000, &etext)
+#	define STACKBOTTOM ((ptr_t)(&_start))
+#	define PROC_VDB
+#   endif
+#   ifdef SCO
+#	define OS_TYPE "SCO"
+	extern int etext;
+#   	define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+				  & ~0x3fffff) \
+				 +((word)&etext & 0xfff))
+#	define STACKBOTTOM ((ptr_t) 0x7ffffffc)
+#   endif
+#   ifdef LINUX
+#	define OS_TYPE "LINUX"
+	extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#	define STACKBOTTOM ((ptr_t)0xc0000000)
+#	define MPROTECT_VDB
+#   endif
+#   ifdef OS2
+#	define OS_TYPE "OS2"
+ 	    	/* STACKBOTTOM and DATASTART are handled specially in 	*/
+		/* os_dep.c. OS2 actually has the right			*/
+		/* system call!						*/
+#	define DATAEND	/* not needed */
+#   endif
+#   ifdef MSWIN32
+#	define OS_TYPE "MSWIN32"
+		/* STACKBOTTOM and DATASTART are handled specially in 	*/
+		/* os_dep.c.						*/
+#	define MPROTECT_VDB
+#       define DATAEND  /* not needed */
+#   endif
+#   ifdef DJGPP
+#       define OS_TYPE "DJGPP"
+        extern int etext;
+#       define DATASTART ((ptr_t)(&etext))
+#       define STACKBOTTOM ((ptr_t)0x00080000)
+#   endif
+#   ifdef FREEBSD
+#	define OS_TYPE "FREEBSD"
+#	define MPROTECT_VDB
+#   endif
+#   ifdef NETBSD
+#	define OS_TYPE "NETBSD"
+#   endif
+#   ifdef THREE86BSD
+#	define OS_TYPE "THREE86BSD"
+#   endif
+#   ifdef BSDI
+#	define OS_TYPE "BSDI"
+#   endif
+#   if defined(FREEBSD) || defined(NETBSD) \
+        || defined(THREE86BSD) || defined(BSDI)
+#	define HEURISTIC2
+	extern char etext;
+#	define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NEXT
+#	define OS_TYPE "NEXT"
+#	define DATASTART ((ptr_t) get_etext())
+#	define STACKBOTTOM ((ptr_t)0xc0000000)
+#	define DATAEND	/* not needed */
+#   endif
+# endif
+
+# ifdef NS32K
+#   define MACH_TYPE "NS32K"
+#   define ALIGNMENT 4
+    extern char **environ;
+#   define DATASTART ((ptr_t)(&environ))
+			      /* hideous kludge: environ is the first   */
+			      /* word in crt0.o, and delimits the start */
+			      /* of the data segment, no matter which   */
+			      /* ld options were passed through.        */
+#   define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
+# endif
+
+# ifdef MIPS
+#   define MACH_TYPE "MIPS"
+#   define ALIGNMENT 4	/* Required by hardware	*/
+#   define DATASTART 0x10000000
+			      /* Could probably be slightly higher since */
+			      /* startup code allocates lots of junk     */
+#   define HEURISTIC2
+#   ifdef ULTRIX
+#	define OS_TYPE "ULTRIX"
+#   endif
+#   ifdef RISCOS
+#	define OS_TYPE "RISCOS"
+#   endif
+#   ifdef IRIX5
+#	define OS_TYPE "IRIX5"
+#	define MPROTECT_VDB
+		/* The above is dubious.  Mprotect and signals do work,	*/
+		/* and dirty bits are implemented under IRIX5.  But,	*/
+		/* at least under IRIX5.2, mprotect seems to be so	*/
+		/* slow relative to the hardware that incremental	*/
+		/* collection is likely to be rarely useful.		*/
+#	define DYNAMIC_LOADING
+#   endif
+# endif
+
+# ifdef RS6000
+#   define MACH_TYPE "RS6000"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t)0x20000000)
+#   define STACKBOTTOM ((ptr_t)0x2ff80000)
+# endif
+
+# ifdef HP_PA
+#   define MACH_TYPE "HP_PA"
+#   define ALIGNMENT 4
+    extern int __data_start;
+#   define DATASTART ((ptr_t)(&__data_start))
+#   define HEURISTIC2
+#   define STACK_GROWS_UP
+# endif
+
+# ifdef ALPHA
+#   define MACH_TYPE "ALPHA"
+#   define ALIGNMENT 8
+#   define DATASTART ((ptr_t) 0x140000000)
+#   define HEURISTIC2
+	/* Normally HEURISTIC2 is too conervative, since		*/
+	/* the text segment immediately follows the stack.		*/
+	/* Hence we give an upper pound.				*/
+    extern __start;
+#   define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
+#   define CPP_WORDSZ 64
+#   define MPROTECT_VDB
+#   define DYNAMIC_LOADING
+# endif
+
+# ifdef M88K
+#   define MACH_TYPE "M88K"
+#   define ALIGNMENT 4
+#   ifdef CX_UX
+#       define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
+#   endif
+#   ifdef  DGUX
+	extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#   endif
+#   define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
+# endif
+
+# ifndef STACK_GROWS_UP
+#   define STACK_GROWS_DOWN
+# endif
+
+# ifndef CPP_WORDSZ
+#   define CPP_WORDSZ 32
+# endif
+
+# ifndef OS_TYPE
+#   define OS_TYPE ""
+# endif
+
+# ifndef DATAEND
+    extern int end;
+#   define DATAEND (&end)
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX)
+    /* OS has SVR4 generic features.  Probably others also qualify.	*/
+#   define SVR4
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX)
+    /* OS has SUNOS5 style semi-undocumented interface to dynamic 	*/
+    /* loader.								*/
+#   define SUNOS5DL
+    /* OS has SUNOS5 style signal handlers.				*/
+#   define SUNOS5SIGS
+# endif
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
+   -> bad word size
+# endif
+
+# ifdef PCR
+#   undef DYNAMIC_LOADING
+#   undef STACKBOTTOM
+#   undef HEURISTIC1
+#   undef HEURISTIC2
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+#   define PCR_VDB
+# endif
+
+# ifdef SRC_M3
+/* Postponed for now. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# ifdef SMALL_CONFIG
+/* Presumably not worth the space it takes. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
+#   define DEFAULT_VDB
+# endif
+
+# if defined(SPARC)
+#   define SAVE_CALL_CHAIN
+# endif
+
+# endif
diff --git a/src/mzscheme/gc/include/private/cord_pos.h b/src/mzscheme/gc/include/private/cord_pos.h
new file mode 100644
index 0000000..d2b24bb
--- /dev/null
+++ b/src/mzscheme/gc/include/private/cord_pos.h
@@ -0,0 +1,118 @@
+/* 
+ * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, May 19, 1994 2:23 pm PDT */
+# ifndef CORD_POSITION_H
+
+/* The representation of CORD_position.  This is private to the	*/
+/* implementation, but the size is known to clients.  Also	*/
+/* the implementation of some exported macros relies on it.	*/
+/* Don't use anything defined here and not in cord.h.		*/
+
+# define MAX_DEPTH 48
+	/* The maximum depth of a balanced cord + 1.		*/
+	/* We don't let cords get deeper than MAX_DEPTH.	*/
+
+struct CORD_pe {
+    CORD pe_cord;
+    size_t pe_start_pos;
+};
+
+/* A structure describing an entry on the path from the root 	*/
+/* to current position.						*/
+typedef struct CORD_Pos {
+    size_t cur_pos;
+    int path_len;
+#	define CORD_POS_INVALID (0x55555555)
+		/* path_len == INVALID <==> position invalid */
+    const char *cur_leaf;	/* Current leaf, if it is a string.	*/
+    				/* If the current leaf is a function,	*/
+    				/* then this may point to function_buf	*/
+    				/* containing the next few characters.	*/
+    				/* Always points to a valid string	*/
+    				/* containing the current character 	*/
+    				/* unless cur_end is 0.			*/
+    size_t cur_start;	/* Start position of cur_leaf	*/
+    size_t cur_end;	/* Ending position of cur_leaf	*/
+    			/* 0 if cur_leaf is invalid.	*/
+    struct CORD_pe path[MAX_DEPTH + 1];
+    	/* path[path_len] is the leaf corresponding to cur_pos	*/
+    	/* path[0].pe_cord is the cord we point to.		*/
+#   define FUNCTION_BUF_SZ 8
+    char function_buf[FUNCTION_BUF_SZ];	/* Space for next few chars	*/
+    					/* from function node.		*/
+} CORD_pos[1];
+
+/* Extract the cord from a position:	*/
+CORD CORD_pos_to_cord(CORD_pos p);
+	
+/* Extract the current index from a position:	*/
+size_t CORD_pos_to_index(CORD_pos p);
+	
+/* Fetch the character located at the given position:	*/
+char CORD_pos_fetch(CORD_pos p);
+	
+/* Initialize the position to refer to the give cord and index.	*/
+/* Note that this is the most expensive function on positions:	*/
+void CORD_set_pos(CORD_pos p, CORD x, size_t i);
+	
+/* Advance the position to the next character.	*/
+/* P must be initialized and valid.		*/
+/* Invalidates p if past end:			*/
+void CORD_next(CORD_pos p);
+
+/* Move the position to the preceding character.	*/
+/* P must be initialized and valid.			*/
+/* Invalidates p if past beginning:			*/
+void CORD_prev(CORD_pos p);
+	
+/* Is the position valid, i.e. inside the cord?		*/
+int CORD_pos_valid(CORD_pos p);
+
+char CORD__pos_fetch(CORD_pos);
+void CORD__next(CORD_pos);
+void CORD__prev(CORD_pos);
+
+#define CORD_pos_fetch(p)	\
+    (((p)[0].cur_end != 0)? \
+     	(p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
+     	: CORD__pos_fetch(p))
+
+#define CORD_next(p)	\
+    (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \
+    	(p)[0].cur_pos++ \
+    	: (CORD__next(p), 0))
+
+#define CORD_prev(p)	\
+    (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \
+    	(p)[0].cur_pos-- \
+    	: (CORD__prev(p), 0))
+
+#define CORD_pos_to_index(p) ((p)[0].cur_pos)
+
+#define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
+
+#define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
+
+/* Some grubby stuff for performance-critical friends:	*/
+#define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos))
+	/* Number of characters in cache.  <= 0 ==> none	*/
+
+#define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
+	/* Advance position by n characters	*/
+	/* 0 < n < CORD_pos_chars_left(p)	*/
+
+#define CORD_pos_cur_char_addr(p) \
+	(p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start)
+	/* address of current character in cache.	*/
+
+#endif
diff --git a/src/mzscheme/gc/include/private/gc_hdrs.h b/src/mzscheme/gc/include/private/gc_hdrs.h
new file mode 100644
index 0000000..2f2d1bf
--- /dev/null
+++ b/src/mzscheme/gc/include/private/gc_hdrs.h
@@ -0,0 +1,133 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, July 11, 1995 11:54 am PDT */
+# ifndef GC_HEADERS_H
+# define GC_HEADERS_H
+typedef struct hblkhdr hdr;
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ < 36
+	--> Get a real machine.
+# endif
+
+/*
+ * The 2 level tree data structure that is used to find block headers.
+ * If there are more than 32 bits in a pointer, the top level is a hash
+ * table.
+ */
+
+# if CPP_WORDSZ > 32
+#   define HASH_TL
+# endif
+
+/* Define appropriate out-degrees for each of the two tree levels	*/
+# ifdef SMALL_CONFIG
+#   define LOG_BOTTOM_SZ 11
+	/* Keep top index size reasonable with smaller blocks. */
+# else
+#   define LOG_BOTTOM_SZ 10
+# endif
+# ifndef HASH_TL
+#   define LOG_TOP_SZ (WORDSZ - LOG_BOTTOM_SZ - LOG_HBLKSIZE)
+# else
+#   define LOG_TOP_SZ 11
+# endif
+# define TOP_SZ (1 << LOG_TOP_SZ)
+# define BOTTOM_SZ (1 << LOG_BOTTOM_SZ)
+
+typedef struct bi {
+    hdr * index[BOTTOM_SZ];
+	/*
+ 	 * The bottom level index contains one of three kinds of values:
+	 * 0 means we're not responsible for this block.
+	 * 1 < (long)X <= MAX_JUMP means the block starts at least
+	 *        X * HBLKSIZE bytes before the current address.
+	 * A valid pointer points to a hdr structure. (The above can't be
+	 * valid pointers due to the GET_MEM return convention.)
+	 */
+    struct bi * asc_link;	/* All indices are linked in	*/
+    				/* ascending order.		*/
+    word key;			/* high order address bits.	*/
+# ifdef HASH_TL
+    struct bi * hash_link;	/* Hash chain link.		*/
+# endif
+} bottom_index;
+
+/* extern bottom_index GC_all_nils; - really part of GC_arrays */
+
+/* extern bottom_index * GC_top_index []; - really part of GC_arrays */
+				/* Each entry points to a bottom_index.	*/
+				/* On a 32 bit machine, it points to 	*/
+				/* the index for a set of high order	*/
+				/* bits equal to the index.  For longer	*/
+				/* addresses, we hash the high order	*/
+				/* bits to compute the index in 	*/
+				/* GC_top_index, and each entry points	*/
+				/* to a hash chain.			*/
+				/* The last entry in each chain is	*/
+				/* GC_all_nils.				*/
+
+
+# define MAX_JUMP (HBLKSIZE - 1)
+
+# define HDR_FROM_BI(bi, p) \
+		((bi)->index[((word)(p) >> LOG_HBLKSIZE) & (BOTTOM_SZ - 1)])
+# ifndef HASH_TL
+#   define BI(p) (GC_top_index \
+		[(word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE)])
+#   define HDR_INNER(p) HDR_FROM_BI(BI(p),p)
+#   ifdef SMALL_CONFIG
+#	define HDR(p) GC_find_header((ptr_t)(p))
+#   else
+#	define HDR(p) HDR_INNER(p)
+#   endif
+#   define GET_BI(p, bottom_indx) (bottom_indx) = BI(p)
+#   define GET_HDR(p, hhdr) (hhdr) = HDR(p)
+#   define SET_HDR(p, hhdr) HDR_INNER(p) = (hhdr)
+#   define GET_HDR_ADDR(p, ha) (ha) = &(HDR_INNER(p))
+# else /* hash */
+/*  Hash function for tree top level */
+#   define TL_HASH(hi) ((hi) & (TOP_SZ - 1))
+/*  Set bottom_indx to point to the bottom index for address p */
+#   define GET_BI(p, bottom_indx) \
+	{ \
+	    register word hi = \
+	        (word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); \
+	    register bottom_index * _bi = GC_top_index[TL_HASH(hi)]; \
+	    \
+	    while (_bi -> key != hi && _bi != GC_all_nils) \
+	    	_bi = _bi -> hash_link; \
+	    (bottom_indx) = _bi; \
+	}
+#   define GET_HDR_ADDR(p, ha) \
+	{ \
+	    register bottom_index * bi; \
+	    \
+	    GET_BI(p, bi);	\
+	    (ha) = &(HDR_FROM_BI(bi, p)); \
+	}
+#   define GET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
+			      (hhdr) = *_ha; }
+#   define SET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
+			      *_ha = (hhdr); }
+#   define HDR(p) GC_find_header((ptr_t)(p))
+# endif
+			    
+/* Is the result a forwarding address to someplace closer to the	*/
+/* beginning of the block or NIL?					*/
+# define IS_FORWARDING_ADDR_OR_NIL(hhdr) ((unsigned long) (hhdr) <= MAX_JUMP)
+
+/* Get an HBLKSIZE aligned address closer to the beginning of the block */
+/* h.  Assumes hhdr == HDR(h) and IS_FORWARDING_ADDR(hhdr).		*/
+# define FORWARDED_ADDR(h, hhdr) ((struct hblk *)(h) - (unsigned long)(hhdr))
+# endif /*  GC_HEADERS_H */
diff --git a/src/mzscheme/gc/include/private/gc_priv.h b/src/mzscheme/gc/include/private/gc_priv.h
new file mode 100644
index 0000000..58372ee
--- /dev/null
+++ b/src/mzscheme/gc/include/private/gc_priv.h
@@ -0,0 +1,1425 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 16, 1996 2:30 pm PST */
+ 
+
+# ifndef GC_PRIVATE_H
+# define GC_PRIVATE_H
+
+#if defined(mips) && defined(SYSTYPE_BSD) && defined(sony_news)
+    /* sony RISC NEWS, NEWSOS 4 */
+#   define BSD_TIME
+    typedef long ptrdiff_t;
+#endif
+
+#if defined(mips) && defined(SYSTYPE_BSD43)
+    /* MIPS RISCOS 4 */
+#   define BSD_TIME
+#endif
+
+#ifdef BSD_TIME
+#   include <sys/types.h>
+#   include <sys/time.h>
+#   include <sys/resource.h>
+#endif /* BSD_TIME */
+
+# ifndef GC_H
+#   include "gc.h"
+# endif
+
+typedef GC_word word;
+typedef GC_signed_word signed_word;
+
+# ifndef CONFIG_H
+#   include "config.h"
+# endif
+
+# ifndef HEADERS_H
+#   include "gc_hdrs.h"
+# endif
+
+# if !defined(bool) && !defined(__cplusplus)
+    typedef int bool;
+    /* This is problematic with C++ implementations that do not define bool. */
+    /* By now they should.						     */
+# else
+#   if defined(_SGI_SOURCE) && !defined(_BOOL)
+	typedef int bool;
+#   endif
+#   if defined(__cplusplus) && defined(_MSC_VER) && _MSC_VER <= 1020
+	/* Visual C++ 4.2 does not have bool type. */
+        typedef int bool;
+#   endif
+# endif
+# define TRUE 1
+# define FALSE 0
+
+typedef char * ptr_t;	/* A generic pointer to which we can add	*/
+			/* byte displacements.				*/
+			/* Preferably identical to caddr_t, if it 	*/
+			/* exists.					*/
+			
+#if defined(__STDC__)
+#   include <stdlib.h>
+#   if !(defined( sony_news ) )
+#       include <stddef.h>
+#   endif
+#   define VOLATILE volatile
+#   define CONST const
+#else
+#   ifdef MSWIN32
+#   	include <stdlib.h>
+#   endif
+#   define VOLATILE
+#   define CONST
+#endif
+
+#ifdef AMIGA
+#   define GC_FAR __far
+#else
+# if defined(__MC68K__)
+/* MATTHEW: Always put this as far data for Mac 68k */
+#    define GC_FAR far
+# else
+#    define GC_FAR
+# endif
+#endif
+
+/*********************************/
+/*                               */
+/* Definitions for conservative  */
+/* collector                     */
+/*                               */
+/*********************************/
+
+/*********************************/
+/*                               */
+/* Easily changeable parameters  */
+/*                               */
+/*********************************/
+
+#define STUBBORN_ALLOC	/* Define stubborn allocation primitives	*/
+#if defined(SRC_M3) || defined(SMALL_CONFIG)
+# undef STUBBORN_ALLOC
+#endif
+
+
+/* #define ALL_INTERIOR_POINTERS */
+		    /* Forces all pointers into the interior of an 	*/
+		    /* object to be considered valid.  Also causes the	*/
+		    /* sizes of all objects to be inflated by at least 	*/
+		    /* one byte.  This should suffice to guarantee	*/
+		    /* that in the presence of a compiler that does	*/
+		    /* not perform garbage-collector-unsafe		*/
+		    /* optimizations, all portable, strictly ANSI	*/
+		    /* conforming C programs should be safely usable	*/
+		    /* with malloc replaced by GC_malloc and free	*/
+		    /* calls removed.  There are several disadvantages: */
+		    /* 1. There are probably no interesting, portable,	*/
+		    /*    strictly ANSI	conforming C programs.		*/
+		    /* 2. This option makes it hard for the collector	*/
+		    /*    to allocate space that is not ``pointed to''  */
+		    /*    by integers, etc.  Under SunOS 4.X with a 	*/
+		    /*    statically linked libc, we empiricaly		*/
+		    /*    observed that it would be difficult to 	*/
+		    /*	  allocate individual objects larger than 100K.	*/
+		    /* 	  Even if only smaller objects are allocated,	*/
+		    /*    more swap space is likely to be needed.       */
+		    /*    Fortunately, much of this will never be	*/
+		    /*    touched.					*/
+		    /* If you can easily avoid using this option, do.	*/
+		    /* If not, try to keep individual objects small.	*/
+		    
+#define PRINTSTATS  /* Print garbage collection statistics          	*/
+		    /* For less verbose output, undefine in reclaim.c 	*/
+
+#define PRINTTIMES  /* Print the amount of time consumed by each garbage   */
+		    /* collection.                                         */
+
+#define PRINTBLOCKS /* Print object sizes associated with heap blocks,     */
+		    /* whether the objects are atomic or composite, and    */
+		    /* whether or not the block was found to be empty      */
+		    /* duing the reclaim phase.  Typically generates       */
+		    /* about one screenful per garbage collection.         */
+#undef PRINTBLOCKS
+
+#define PRINTBLACKLIST 	/* Print black listed blocks, i.e. values that     */
+			/* cause the allocator to avoid allocating certain */
+			/* blocks in order to avoid introducing "false	   */
+			/* hits".					   */
+#undef PRINTBLACKLIST
+
+#ifdef SILENT
+#  ifdef PRINTSTATS
+#    undef PRINTSTATS
+#  endif
+#  ifdef PRINTTIMES
+#    undef PRINTTIMES
+#  endif
+#  ifdef PRINTNBLOCKS
+#    undef PRINTNBLOCKS
+#  endif
+#endif
+
+#if defined(PRINTSTATS) && !defined(GATHERSTATS)
+#   define GATHERSTATS
+#endif
+
+#define MERGE_SIZES /* Round up some object sizes, so that fewer distinct */
+		    /* free lists are actually maintained.  This applies  */
+		    /* only to the top level routines in misc.c, not to   */
+		    /* user generated code that calls GC_allocobj and     */
+		    /* GC_allocaobj directly.                             */
+		    /* Slows down average programs slightly.  May however */
+		    /* substantially reduce fragmentation if allocation   */
+		    /* request sizes are widely scattered.                */
+		    /* May save significant amounts of space for obj_map  */
+		    /* entries.						  */
+
+/* ALIGN_DOUBLE requires MERGE_SIZES at present. */
+# if defined(ALIGN_DOUBLE) && !defined(MERGE_SIZES)
+#   define MERGE_SIZES
+# endif
+
+#if defined(ALL_INTERIOR_POINTERS) && !defined(DONT_ADD_BYTE_AT_END)
+# define ADD_BYTE_AT_END
+#endif
+
+
+# ifndef LARGE_CONFIG
+#   define MINHINCR 16	/* Minimum heap increment, in blocks of HBLKSIZE  */
+#   define MAXHINCR 512	/* Maximum heap increment, in blocks              */
+# else
+#   define MINHINCR 64
+#   define MAXHINCR 4096
+# endif
+
+# define TIME_LIMIT 50	   /* We try to keep pause times from exceeding	 */
+			   /* this by much. In milliseconds.		 */
+
+# define BL_LIMIT GC_black_list_spacing
+			   /* If we need a block of N bytes, and we have */
+			   /* a block of N + BL_LIMIT bytes available, 	 */
+			   /* and N > BL_LIMIT,				 */
+			   /* but all possible positions in it are 	 */
+			   /* blacklisted, we just use it anyway (and	 */
+			   /* print a warning, if warnings are enabled). */
+			   /* This risks subsequently leaking the block	 */
+			   /* due to a false reference.  But not using	 */
+			   /* the block risks unreasonable immediate	 */
+			   /* heap growth.				 */
+
+/*********************************/
+/*                               */
+/* Stack saving for debugging	 */
+/*                               */
+/*********************************/
+
+/*
+ * Number of frames and arguments to save in objects allocated by
+ * debugging allocator.
+ */
+#   define NFRAMES 6	/* Number of frames to save. Even for		*/
+			/* alignment reasons.				*/
+#   define NARGS 2	/* Mumber of arguments to save for each call.	*/
+
+
+#ifdef SAVE_CALL_CHAIN
+    struct callinfo {
+	word ci_pc;
+	word ci_arg[NARGS];	/* bit-wise complement to avoid retention */
+    };
+
+/* Fill in the pc and argument information for up to NFRAMES of my	*/
+/* callers.  Ignore my frame and my callers frame.			*/
+void GC_save_callers (/* struct callinfo info[NFRAMES] */);
+
+void GC_print_callers (/* struct callinfo info[NFRAMES] */);
+
+#endif
+
+
+/*********************************/
+/*                               */
+/* OS interface routines	 */
+/*                               */
+/*********************************/
+
+#ifdef BSD_TIME
+#   undef CLOCK_TYPE
+#   undef GET_TIME
+#   undef MS_TIME_DIFF
+#   define CLOCK_TYPE struct timeval
+#   define GET_TIME(x) { struct rusage rusage; \
+			 getrusage (RUSAGE_SELF,  &rusage); \
+			 x = rusage.ru_utime; }
+#   define MS_TIME_DIFF(a,b) ((double) (a.tv_sec - b.tv_sec) * 1000.0 \
+                               + (double) (a.tv_usec - b.tv_usec) / 1000.0)
+#else /* !BSD_TIME */
+#   include <time.h>
+#   if !defined(__STDC__) && defined(SPARC) && defined(SUNOS4)
+      clock_t clock();	/* Not in time.h, where it belongs	*/
+#   endif
+#   if defined(FREEBSD) && !defined(CLOCKS_PER_SEC)
+#     include <machine/limits.h>
+#     define CLOCKS_PER_SEC CLK_TCK
+#   endif
+#   if !defined(CLOCKS_PER_SEC)
+#     define CLOCKS_PER_SEC 1000000
+/*
+ * This is technically a bug in the implementation.  ANSI requires that
+ * CLOCKS_PER_SEC be defined.  But at least under SunOS4.1.1, it isn't.
+ * Also note that the combination of ANSI C and POSIX is incredibly gross
+ * here. The type clock_t is used by both clock() and times().  But on
+ * some machines these use different notions of a clock tick,  CLOCKS_PER_SEC
+ * seems to apply only to clock.  Hence we use it here.  On many machines,
+ * including SunOS, clock actually uses units of microseconds (which are
+ * not really clock ticks).
+ */
+#   endif
+#   define CLOCK_TYPE clock_t
+#   define GET_TIME(x) x = clock()
+#   define MS_TIME_DIFF(a,b) ((unsigned long) \
+		(1000.0*(double)((a)-(b))/(double)CLOCKS_PER_SEC))
+#endif /* !BSD_TIME */
+
+/* We use bzero and bcopy internally.  They may not be available.	*/
+# if defined(SPARC) && defined(SUNOS4)
+#   define BCOPY_EXISTS
+# endif
+# if defined(M68K) && defined(AMIGA)
+#   define BCOPY_EXISTS
+# endif
+# if defined(M68K) && defined(NEXT)
+#   define BCOPY_EXISTS
+# endif
+# if defined(VAX)
+#   define BCOPY_EXISTS
+# endif
+# if defined(AMIGA)
+#   include <string.h>
+#   define BCOPY_EXISTS
+# endif
+
+# ifndef BCOPY_EXISTS
+#   include <string.h>
+#   define BCOPY(x,y,n) memcpy(y, x, (size_t)(n))
+#   define BZERO(x,n)  memset(x, 0, (size_t)(n))
+# else
+#   define BCOPY(x,y,n) bcopy((char *)(x),(char *)(y),(int)(n))
+#   define BZERO(x,n) bzero((char *)(x),(int)(n))
+# endif
+
+/* HBLKSIZE aligned allocation.  0 is taken to mean failure 	*/
+/* space is assumed to be cleared.				*/
+# ifdef PCR
+    char * real_malloc();
+#   define GET_MEM(bytes) HBLKPTR(real_malloc((size_t)bytes + HBLKSIZE) \
+				  + HBLKSIZE-1)
+# else
+#   ifdef OS2
+      void * os2_alloc(size_t bytes);
+#     define GET_MEM(bytes) HBLKPTR((ptr_t)os2_alloc((size_t)bytes + HBLKSIZE) \
+                                    + HBLKSIZE-1)
+#   else
+#     if defined(AMIGA) || defined(NEXT)
+#       define GET_MEM(bytes) HBLKPTR((size_t) \
+				      calloc(1, (size_t)bytes + HBLKSIZE) \
+                                      + HBLKSIZE-1)
+#     else
+#	ifdef MSWIN32
+          extern ptr_t GC_win32_get_mem();
+#         define GET_MEM(bytes) (struct hblk *)GC_win32_get_mem(bytes)
+#	else
+#	  ifdef MACOS
+#	    if defined(USE_TEMPORARY_MEMORY)
+		extern Ptr GC_MacTemporaryNewPtr(size_t size,
+						 Boolean clearMemory);
+#               define GET_MEM(bytes) HBLKPTR( \
+		    GC_MacTemporaryNewPtr(bytes + HBLKSIZE, true) + HBLKSIZE-1)
+#	    else
+#         	    define GET_MEM(bytes) HBLKPTR( \
+			NewPtrClear(bytes + HBLKSIZE) + HBLKSIZE-1)
+#	    endif
+#	  else
+            extern ptr_t GC_unix_get_mem();
+#           define GET_MEM(bytes) (struct hblk *)GC_unix_get_mem(bytes)
+#	  endif
+#	endif
+#     endif
+#   endif
+# endif
+
+/*
+ * Mutual exclusion between allocator/collector routines.
+ * Needed if there is more than one allocator thread.
+ * FASTLOCK() is assumed to try to acquire the lock in a cheap and
+ * dirty way that is acceptable for a few instructions, e.g. by
+ * inhibiting preemption.  This is assumed to have succeeded only
+ * if a subsequent call to FASTLOCK_SUCCEEDED() returns TRUE.
+ * FASTUNLOCK() is called whether or not FASTLOCK_SUCCEEDED().
+ * If signals cannot be tolerated with the FASTLOCK held, then
+ * FASTLOCK should disable signals.  The code executed under
+ * FASTLOCK is otherwise immune to interruption, provided it is
+ * not restarted.
+ * DCL_LOCK_STATE declares any local variables needed by LOCK and UNLOCK
+ * and/or DISABLE_SIGNALS and ENABLE_SIGNALS and/or FASTLOCK.
+ * (There is currently no equivalent for FASTLOCK.)
+ */  
+# ifdef THREADS
+#  ifdef PCR_OBSOLETE	/* Faster, but broken with multiple lwp's	*/
+#    include  "th/PCR_Th.h"
+#    include  "th/PCR_ThCrSec.h"
+     extern struct PCR_Th_MLRep GC_allocate_ml;
+#    define DCL_LOCK_STATE  PCR_sigset_t GC_old_sig_mask
+#    define LOCK() PCR_Th_ML_Acquire(&GC_allocate_ml) 
+#    define UNLOCK() PCR_Th_ML_Release(&GC_allocate_ml)
+#    define FASTLOCK() PCR_ThCrSec_EnterSys()
+     /* Here we cheat (a lot): */
+#        define FASTLOCK_SUCCEEDED() (*(int *)(&GC_allocate_ml) == 0)
+		/* TRUE if nobody currently holds the lock */
+#    define FASTUNLOCK() PCR_ThCrSec_ExitSys()
+#  endif
+#  ifdef PCR
+#    include <base/PCR_Base.h>
+#    include <th/PCR_Th.h>
+     extern PCR_Th_ML GC_allocate_ml;
+#    define DCL_LOCK_STATE \
+	 PCR_ERes GC_fastLockRes; PCR_sigset_t GC_old_sig_mask
+#    define LOCK() PCR_Th_ML_Acquire(&GC_allocate_ml)
+#    define UNLOCK() PCR_Th_ML_Release(&GC_allocate_ml)
+#    define FASTLOCK() (GC_fastLockRes = PCR_Th_ML_Try(&GC_allocate_ml))
+#    define FASTLOCK_SUCCEEDED() (GC_fastLockRes == PCR_ERes_okay)
+#    define FASTUNLOCK()  {\
+        if( FASTLOCK_SUCCEEDED() ) PCR_Th_ML_Release(&GC_allocate_ml); }
+#  endif
+#  ifdef SRC_M3
+     extern word RT0u__inCritical;
+#    define LOCK() RT0u__inCritical++
+#    define UNLOCK() RT0u__inCritical--
+#  endif
+#  ifdef SOLARIS_THREADS
+#    include <thread.h>
+#    include <signal.h>
+     extern mutex_t GC_allocate_ml;
+#    define LOCK() mutex_lock(&GC_allocate_ml);
+#    define UNLOCK() mutex_unlock(&GC_allocate_ml);
+#  endif
+#  ifdef IRIX_THREADS
+#    include <pthread.h>
+#    include <mutex.h>
+
+#    if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
+#         define __test_and_set(l,v) test_and_set(l,v)
+#    endif
+     extern unsigned long GC_allocate_lock;
+	/* This is not a mutex because mutexes that obey the (optional) 	*/
+	/* POSIX scheduling rules are subject to convoys in high contention	*/
+	/* applications.  This is basically a spin lock.			*/
+     extern pthread_t GC_lock_holder;
+     extern void GC_lock(void);
+	/* Allocation lock holder.  Only set if acquired by client through */
+	/* GC_call_with_alloc_lock.					   */
+#    define SET_LOCK_HOLDER() GC_lock_holder = pthread_self()
+#    define NO_THREAD (pthread_t)(-1)
+#    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
+#    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
+#    ifdef UNDEFINED
+#    	define LOCK() pthread_mutex_lock(&GC_allocate_ml)
+#    	define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
+#    else
+#	define LOCK() { if (__test_and_set(&GC_allocate_lock, 1)) GC_lock(); }
+#       if __mips >= 3 && (defined (_ABIN32) || defined(_ABI64))
+#	    define UNLOCK() __lock_release(lock)
+#	else
+#           define UNLOCK() GC_allocate_lock = 0
+#	endif
+#    endif
+     extern bool GC_collecting;
+#    define ENTER_GC() \
+		{ \
+		    GC_collecting = 1; \
+		}
+#    define EXIT_GC() GC_collecting = 0;
+#  endif
+#  ifdef WIN32_THREADS
+#    include <windows.h>
+     GC_API CRITICAL_SECTION GC_allocate_ml;
+#    define LOCK() EnterCriticalSection(&GC_allocate_ml);
+#    define UNLOCK() LeaveCriticalSection(&GC_allocate_ml);
+#  endif
+#  ifndef SET_LOCK_HOLDER
+#      define SET_LOCK_HOLDER()
+#      define UNSET_LOCK_HOLDER()
+#      define I_HOLD_LOCK() FALSE
+		/* Used on platforms were locks can be reacquired,	*/
+		/* so it doesn't matter if we lie.			*/
+#  endif
+# else
+#    define LOCK()
+#    define UNLOCK()
+# endif
+# ifndef SET_LOCK_HOLDER
+#   define SET_LOCK_HOLDER()
+#   define UNSET_LOCK_HOLDER()
+#   define I_HOLD_LOCK() FALSE
+		/* Used on platforms were locks can be reacquired,	*/
+		/* so it doesn't matter if we lie.			*/
+# endif
+# ifndef ENTER_GC
+#   define ENTER_GC()
+#   define EXIT_GC()
+# endif
+
+# ifndef DCL_LOCK_STATE
+#   define DCL_LOCK_STATE
+# endif
+# ifndef FASTLOCK
+#   define FASTLOCK() LOCK()
+#   define FASTLOCK_SUCCEEDED() TRUE
+#   define FASTUNLOCK() UNLOCK()
+# endif
+
+/* Delay any interrupts or signals that may abort this thread.  Data	*/
+/* structures are in a consistent state outside this pair of calls.	*/
+/* ANSI C allows both to be empty (though the standard isn't very	*/
+/* clear on that point).  Standard malloc implementations are usually	*/
+/* neither interruptable nor thread-safe, and thus correspond to	*/
+/* empty definitions.							*/
+# ifdef PCR
+#   define DISABLE_SIGNALS() \
+		 PCR_Th_SetSigMask(PCR_allSigsBlocked,&GC_old_sig_mask)
+#   define ENABLE_SIGNALS() \
+		PCR_Th_SetSigMask(&GC_old_sig_mask, NIL)
+# else
+#   if defined(SRC_M3) || defined(AMIGA) || defined(SOLARIS_THREADS) \
+	|| defined(MSWIN32) || defined(MACOS) || defined(DJGPP) \
+	|| defined(NO_SIGNALS) || defined(IRIX_THREADS)
+			/* Also useful for debugging.		*/
+	/* Should probably use thr_sigsetmask for SOLARIS_THREADS. */
+#     define DISABLE_SIGNALS()
+#     define ENABLE_SIGNALS()
+#   else
+#     define DISABLE_SIGNALS() GC_disable_signals()
+	void GC_disable_signals();
+#     define ENABLE_SIGNALS() GC_enable_signals()
+	void GC_enable_signals();
+#   endif
+# endif
+
+/*
+ * Stop and restart mutator threads.
+ */
+# ifdef PCR
+#     include "th/PCR_ThCtl.h"
+#     define STOP_WORLD() \
+ 	PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_stopNormal, \
+ 				   PCR_allSigsBlocked, \
+ 				   PCR_waitForever)
+#     define START_WORLD() \
+	PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_null, \
+ 				   PCR_allSigsBlocked, \
+ 				   PCR_waitForever);
+# else
+#   if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(IRIX_THREADS)
+      void GC_stop_world();
+      void GC_start_world();
+#     define STOP_WORLD() GC_stop_world()
+#     define START_WORLD() GC_start_world()
+#   else
+#     define STOP_WORLD()
+#     define START_WORLD()
+#   endif
+# endif
+
+/* Abandon ship */
+# ifdef PCR
+#   define ABORT(s) PCR_Base_Panic(s)
+# else
+#   ifdef SMALL_CONFIG
+#	define ABORT(msg) abort();
+#   else
+	GC_API void GC_abort();
+#       define ABORT(msg) GC_abort(msg);
+#   endif
+# endif
+
+/* Exit abnormally, but without making a mess (e.g. out of memory) */
+# ifdef PCR
+#   define EXIT() PCR_Base_Exit(1,PCR_waitForever)
+# else
+#   define EXIT() (void)exit(1)
+# endif
+
+/* Print warning message, e.g. almost out of memory.	*/
+# define WARN(msg,arg) (*GC_current_warn_proc)(msg, (GC_word)(arg))
+extern GC_warn_proc GC_current_warn_proc;
+
+/*********************************/
+/*                               */
+/* Word-size-dependent defines   */
+/*                               */
+/*********************************/
+
+#if CPP_WORDSZ == 32
+#  define WORDS_TO_BYTES(x)   ((x)<<2)
+#  define BYTES_TO_WORDS(x)   ((x)>>2)
+#  define LOGWL               ((word)5)    /* log[2] of CPP_WORDSZ */
+#  define modWORDSZ(n) ((n) & 0x1f)        /* n mod size of word	    */
+#  if ALIGNMENT != 4
+#	define UNALIGNED
+#  endif
+#endif
+
+#if CPP_WORDSZ == 64
+#  define WORDS_TO_BYTES(x)   ((x)<<3)
+#  define BYTES_TO_WORDS(x)   ((x)>>3)
+#  define LOGWL               ((word)6)    /* log[2] of CPP_WORDSZ */
+#  define modWORDSZ(n) ((n) & 0x3f)        /* n mod size of word	    */
+#  if ALIGNMENT != 8
+#	define UNALIGNED
+#  endif
+#endif
+
+#define WORDSZ ((word)CPP_WORDSZ)
+#define SIGNB  ((word)1 << (WORDSZ-1))
+#define BYTES_PER_WORD      ((word)(sizeof (word)))
+#define ONES                ((word)(-1))
+#define divWORDSZ(n) ((n) >> LOGWL)	   /* divide n by size of word      */
+
+/*********************/
+/*                   */
+/*  Size Parameters  */
+/*                   */
+/*********************/
+
+/*  heap block size, bytes. Should be power of 2 */
+
+#ifdef SMALL_CONFIG
+#   define CPP_LOG_HBLKSIZE 10
+#else
+# if CPP_WORDSZ == 32
+#   define CPP_LOG_HBLKSIZE 12
+# else
+#   define CPP_LOG_HBLKSIZE 13
+# endif
+#endif
+#define LOG_HBLKSIZE   ((word)CPP_LOG_HBLKSIZE)
+#define CPP_HBLKSIZE (1 << CPP_LOG_HBLKSIZE)
+#define HBLKSIZE ((word)CPP_HBLKSIZE)
+
+
+/*  max size objects supported by freelist (larger objects may be   */
+/*  allocated, but less efficiently)                                */
+
+#define CPP_MAXOBJSZ    BYTES_TO_WORDS(CPP_HBLKSIZE/2)
+#define MAXOBJSZ ((word)CPP_MAXOBJSZ)
+		
+# define divHBLKSZ(n) ((n) >> LOG_HBLKSIZE)
+
+# define HBLK_PTR_DIFF(p,q) divHBLKSZ((ptr_t)p - (ptr_t)q)
+	/* Equivalent to subtracting 2 hblk pointers.	*/
+	/* We do it this way because a compiler should	*/
+	/* find it hard to use an integer division	*/
+	/* instead of a shift.  The bundled SunOS 4.1	*/
+	/* o.w. sometimes pessimizes the subtraction to	*/
+	/* involve a call to .div.			*/
+ 
+# define modHBLKSZ(n) ((n) & (HBLKSIZE-1))
+ 
+# define HBLKPTR(objptr) ((struct hblk *)(((word) (objptr)) & ~(HBLKSIZE-1)))
+
+# define HBLKDISPL(objptr) (((word) (objptr)) & (HBLKSIZE-1))
+
+/* Round up byte allocation requests to integral number of words, etc. */
+# ifdef ADD_BYTE_AT_END
+#   define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1))
+#   ifdef ALIGN_DOUBLE
+#       define ALIGNED_WORDS(n) (BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2)) & ~1)
+#   else
+#       define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
+#   endif
+#   define SMALL_OBJ(bytes) ((bytes) < WORDS_TO_BYTES(MAXOBJSZ))
+#   define ADD_SLOP(bytes) ((bytes)+1)
+# else
+#   define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + (WORDS_TO_BYTES(1) - 1))
+#   ifdef ALIGN_DOUBLE
+#       define ALIGNED_WORDS(n) \
+			(BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2) - 1) & ~1)
+#   else
+#       define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
+#   endif
+#   define SMALL_OBJ(bytes) ((bytes) <= WORDS_TO_BYTES(MAXOBJSZ))
+#   define ADD_SLOP(bytes) (bytes)
+# endif
+
+
+/*
+ * Hash table representation of sets of pages.  This assumes it is
+ * OK to add spurious entries to sets.
+ * Used by black-listing code, and perhaps by dirty bit maintenance code.
+ */
+ 
+# ifdef LARGE_CONFIG
+#   define LOG_PHT_ENTRIES  17
+# else
+#   define LOG_PHT_ENTRIES  14	/* Collisions are likely if heap grows	*/
+				/* to more than 16K hblks = 64MB.	*/
+				/* Each hash table occupies 2K bytes.   */
+# endif
+# define PHT_ENTRIES ((word)1 << LOG_PHT_ENTRIES)
+# define PHT_SIZE (PHT_ENTRIES >> LOGWL)
+typedef word page_hash_table[PHT_SIZE];
+
+# define PHT_HASH(addr) ((((word)(addr)) >> LOG_HBLKSIZE) & (PHT_ENTRIES - 1))
+
+# define get_pht_entry_from_index(bl, index) \
+		(((bl)[divWORDSZ(index)] >> modWORDSZ(index)) & 1)
+# define set_pht_entry_from_index(bl, index) \
+		(bl)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index)
+# define clear_pht_entry_from_index(bl, index) \
+		(bl)[divWORDSZ(index)] &= ~((word)1 << modWORDSZ(index))
+	
+
+
+/********************************************/
+/*                                          */
+/*    H e a p   B l o c k s                 */
+/*                                          */
+/********************************************/
+
+/*  heap block header */
+#define HBLKMASK   (HBLKSIZE-1)
+
+#define BITS_PER_HBLK (HBLKSIZE * 8)
+
+#define MARK_BITS_PER_HBLK (BITS_PER_HBLK/CPP_WORDSZ)
+	   /* upper bound                                    */
+	   /* We allocate 1 bit/word.  Only the first word   */
+	   /* in each object is actually marked.             */
+
+# ifdef ALIGN_DOUBLE
+#   define MARK_BITS_SZ (((MARK_BITS_PER_HBLK + 2*CPP_WORDSZ - 1) \
+			  / (2*CPP_WORDSZ))*2)
+# else
+#   define MARK_BITS_SZ ((MARK_BITS_PER_HBLK + CPP_WORDSZ - 1)/CPP_WORDSZ)
+# endif
+	   /* Upper bound on number of mark words per heap block  */
+
+struct hblkhdr {
+    word hb_sz;  /* If in use, size in words, of objects in the block. */
+		 /* if free, the size in bytes of the whole block      */
+    struct hblk * hb_next; 	/* Link field for hblk free list	 */
+    				/* and for lists of chunks waiting to be */
+    				/* reclaimed.				 */
+    word hb_descr;   		/* object descriptor for marking.  See	*/
+    				/* mark.h.				*/
+    char* hb_map;	/* A pointer to a pointer validity map of the block. */
+    		      	/* See GC_obj_map.				     */
+    		     	/* Valid for all blocks with headers.		     */
+    		     	/* Free blocks point to GC_invalid_map.		     */
+    unsigned char hb_obj_kind;
+    			 /* Kind of objects in the block.  Each kind 	*/
+    			 /* identifies a mark procedure and a set of 	*/
+    			 /* list headers.  Sometimes called regions.	*/
+    unsigned char hb_flags;
+#	define IGNORE_OFF_PAGE	1	/* Ignore pointers that do not	*/
+					/* point to the first page of 	*/
+					/* this object.			*/
+    unsigned short hb_last_reclaimed;
+    				/* Value of GC_gc_no when block was	*/
+    				/* last allocated or swept. May wrap.   */
+    word hb_marks[MARK_BITS_SZ];
+			    /* Bit i in the array refers to the             */
+			    /* object starting at the ith word (header      */
+			    /* INCLUDED) in the heap block.                 */
+			    /* The lsb of word 0 is numbered 0.		    */
+};
+
+/*  heap block body */
+
+# define DISCARD_WORDS 0
+	/* Number of words to be dropped at the beginning of each block	*/
+	/* Must be a multiple of WORDSZ.  May reasonably be nonzero	*/
+	/* on machines that don't guarantee longword alignment of	*/
+	/* pointers, so that the number of false hits is minimized.	*/
+	/* 0 and WORDSZ are probably the only reasonable values.	*/
+
+# define BODY_SZ ((HBLKSIZE-WORDS_TO_BYTES(DISCARD_WORDS))/sizeof(word))
+
+struct hblk {
+#   if (DISCARD_WORDS != 0)
+        word garbage[DISCARD_WORDS];
+#   endif
+    word hb_body[BODY_SZ];
+};
+
+# define HDR_WORDS ((word)DISCARD_WORDS)
+# define HDR_BYTES ((word)WORDS_TO_BYTES(DISCARD_WORDS))
+
+# define OBJ_SZ_TO_BLOCKS(sz) \
+    divHBLKSZ(HDR_BYTES + WORDS_TO_BYTES(sz) + HBLKSIZE-1)
+    /* Size of block (in units of HBLKSIZE) needed to hold objects of	*/
+    /* given sz (in words).						*/
+
+/* Object free list link */
+# define obj_link(p) (*(ptr_t *)(p))
+
+/*  lists of all heap blocks and free lists	*/
+/* These are grouped together in a struct	*/
+/* so that they can be easily skipped by the	*/
+/* GC_mark routine.				*/
+/* The ordering is weird to make GC_malloc	*/
+/* faster by keeping the important fields	*/
+/* sufficiently close together that a		*/
+/* single load of a base register will do.	*/
+/* Scalars that could easily appear to		*/
+/* be pointers are also put here.		*/
+/* The main fields should precede any 		*/
+/* conditionally included fields, so that	*/
+/* gc_inl.h will work even if a different set	*/
+/* of macros is defined when the client is	*/
+/* compiled.					*/
+
+struct _GC_arrays {
+  word _heapsize;
+  word _max_heapsize;
+  ptr_t _last_heap_addr;
+  ptr_t _prev_heap_addr;
+  word _words_allocd_before_gc;
+		/* Number of words allocated before this	*/
+		/* collection cycle.				*/
+  word _words_allocd;
+  	/* Number of words allocated during this collection cycle */
+  word _words_wasted;
+  	/* Number of words wasted due to internal fragmentation	 */
+  	/* in large objects allocated since last gc. Approximate.*/
+  word _words_finalized;
+  	/* Approximate number of words in objects (and headers)	*/
+  	/* That became ready for finalization in the last 	*/
+  	/* collection.						*/
+  word _non_gc_bytes_at_gc;
+  	/* Number of explicitly managed bytes of storage 	*/
+  	/* at last collection.					*/
+  word _mem_freed;
+  	/* Number of explicitly deallocated words of memory	*/
+  	/* since last collection.				*/
+  	
+  ptr_t _objfreelist[MAXOBJSZ+1];
+			  /* free list for objects */
+  ptr_t _aobjfreelist[MAXOBJSZ+1];
+			  /* free list for atomic objs 	*/
+
+  ptr_t _uobjfreelist[MAXOBJSZ+1];
+			  /* uncollectable but traced objs 	*/
+			  /* objects on this and auobjfreelist  */
+			  /* are always marked, except during   */
+			  /* garbage collections.		*/
+# ifdef ATOMIC_UNCOLLECTABLE
+    ptr_t _auobjfreelist[MAXOBJSZ+1];
+# endif
+			  /* uncollectable but traced objs 	*/
+
+# ifdef GATHERSTATS
+    word _composite_in_use;
+   		/* Number of words in accessible composite	*/
+		/* objects.					*/
+    word _atomic_in_use;
+   		/* Number of words in accessible atomic		*/
+		/* objects.					*/
+# endif
+# ifdef MERGE_SIZES
+    unsigned _size_map[WORDS_TO_BYTES(MAXOBJSZ+1)];
+    	/* Number of words to allocate for a given allocation request in */
+    	/* bytes.							 */
+# endif 
+
+# ifdef STUBBORN_ALLOC
+    ptr_t _sobjfreelist[MAXOBJSZ+1];
+# endif
+  			  /* free list for immutable objects	*/
+  ptr_t _obj_map[MAXOBJSZ+1];
+                       /* If not NIL, then a pointer to a map of valid  */
+    		       /* object addresses. _obj_map[sz][i] is j if the	*/
+    		       /* address block_start+i is a valid pointer      */
+    		       /* to an object at				*/
+    		       /* block_start+i&~3 - WORDS_TO_BYTES(j).		*/
+    		       /* (If ALL_INTERIOR_POINTERS is defined, then	*/
+    		       /* instead ((short *)(hbh_map[sz])[i] is j if	*/
+    		       /* block_start+WORDS_TO_BYTES(i) is in the	*/
+    		       /* interior of an object starting at		*/
+    		       /* block_start+WORDS_TO_BYTES(i-j)).		*/
+    		       /* It is OBJ_INVALID if				*/
+    		       /* block_start+WORDS_TO_BYTES(i) is not		*/
+    		       /* valid as a pointer to an object.              */
+    		       /* We assume all values of j <= OBJ_INVALID.	*/
+    		       /* The zeroth entry corresponds to large objects.*/
+#   ifdef ALL_INTERIOR_POINTERS
+#	define map_entry_type short
+#       define OBJ_INVALID 0x7fff
+#	define MAP_ENTRY(map, bytes) \
+		(((map_entry_type *)(map))[BYTES_TO_WORDS(bytes)])
+#	define MAP_ENTRIES BYTES_TO_WORDS(HBLKSIZE)
+#	define MAP_SIZE (MAP_ENTRIES * sizeof(map_entry_type))
+#	define OFFSET_VALID(displ) TRUE
+#	define CPP_MAX_OFFSET (HBLKSIZE - HDR_BYTES - 1)
+#	define MAX_OFFSET ((word)CPP_MAX_OFFSET)
+#   else
+#	define map_entry_type char
+#       define OBJ_INVALID 0x7f
+#	define MAP_ENTRY(map, bytes) \
+		(map)[bytes]
+#	define MAP_ENTRIES HBLKSIZE
+#	define MAP_SIZE MAP_ENTRIES
+#	define CPP_MAX_OFFSET (WORDS_TO_BYTES(OBJ_INVALID) - 1)	
+#	define MAX_OFFSET ((word)CPP_MAX_OFFSET)
+# 	define VALID_OFFSET_SZ \
+	  (CPP_MAX_OFFSET > WORDS_TO_BYTES(CPP_MAXOBJSZ)? \
+	   CPP_MAX_OFFSET+1 \
+	   : WORDS_TO_BYTES(CPP_MAXOBJSZ)+1)
+  	char _valid_offsets[VALID_OFFSET_SZ];
+				/* GC_valid_offsets[i] == TRUE ==> i 	*/
+				/* is registered as a displacement.	*/
+#	define OFFSET_VALID(displ) GC_valid_offsets[displ]
+  	char _modws_valid_offsets[sizeof(word)];
+				/* GC_valid_offsets[i] ==>		  */
+				/* GC_modws_valid_offsets[i%sizeof(word)] */
+#   endif
+# ifdef STUBBORN_ALLOC
+      page_hash_table _changed_pages;
+        /* Stubborn object pages that were changes since last call to	*/
+	/* GC_read_changed.						*/
+      page_hash_table _prev_changed_pages;
+        /* Stubborn object pages that were changes before last call to	*/
+	/* GC_read_changed.						*/
+# endif
+# if defined(PROC_VDB) || defined(MPROTECT_VDB)
+      page_hash_table _grungy_pages; /* Pages that were dirty at last 	   */
+				     /* GC_read_dirty.			   */
+# endif
+# ifdef LARGE_CONFIG
+#   if CPP_WORDSZ > 32
+#     define MAX_HEAP_SECTS 4096 	/* overflows at roughly 64 GB	   */
+#   else
+#     define MAX_HEAP_SECTS 768		/* Separately added heap sections. */
+#   endif
+# else
+#   define MAX_HEAP_SECTS 256
+# endif
+  struct HeapSect {
+      ptr_t hs_start; word hs_bytes;
+  } _heap_sects[MAX_HEAP_SECTS];
+# ifdef MSWIN32
+    ptr_t _heap_bases[MAX_HEAP_SECTS];
+    		/* Start address of memory regions obtained from kernel. */
+# endif
+  /* Block header index; see gc_headers.h */
+  bottom_index * _all_nils;
+  bottom_index * _top_index [TOP_SZ];
+#ifdef SAVE_CALL_CHAIN
+  struct callinfo _last_stack[NFRAMES];	/* Stack at last garbage collection.*/
+  					/* Useful for debugging	mysterious  */
+  					/* object disappearances.	    */
+  					/* In the multithreaded case, we    */
+  					/* currently only save the calling  */
+  					/* stack.			    */
+#endif
+};
+
+GC_API GC_FAR struct _GC_arrays GC_arrays; 
+
+# define GC_objfreelist GC_arrays._objfreelist
+# define GC_aobjfreelist GC_arrays._aobjfreelist
+# define GC_uobjfreelist GC_arrays._uobjfreelist
+# ifdef ATOMIC_UNCOLLECTABLE
+#   define GC_auobjfreelist GC_arrays._auobjfreelist
+# endif
+# define GC_sobjfreelist GC_arrays._sobjfreelist
+# define GC_valid_offsets GC_arrays._valid_offsets
+# define GC_modws_valid_offsets GC_arrays._modws_valid_offsets
+# ifdef STUBBORN_ALLOC
+#    define GC_changed_pages GC_arrays._changed_pages
+#    define GC_prev_changed_pages GC_arrays._prev_changed_pages
+# endif
+# define GC_obj_map GC_arrays._obj_map
+# define GC_last_heap_addr GC_arrays._last_heap_addr
+# define GC_prev_heap_addr GC_arrays._prev_heap_addr
+# define GC_words_allocd GC_arrays._words_allocd
+# define GC_words_wasted GC_arrays._words_wasted
+# define GC_words_finalized GC_arrays._words_finalized
+# define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc
+# define GC_mem_freed GC_arrays._mem_freed
+# define GC_heapsize GC_arrays._heapsize
+# define GC_max_heapsize GC_arrays._max_heapsize
+# define GC_words_allocd_before_gc GC_arrays._words_allocd_before_gc
+# define GC_heap_sects GC_arrays._heap_sects
+# define GC_last_stack GC_arrays._last_stack
+# ifdef MSWIN32
+#   define GC_heap_bases GC_arrays._heap_bases
+# endif
+# define GC_all_nils GC_arrays._all_nils
+# define GC_top_index GC_arrays._top_index
+# if defined(PROC_VDB) || defined(MPROTECT_VDB)
+#   define GC_grungy_pages GC_arrays._grungy_pages
+# endif
+# ifdef GATHERSTATS
+#   define GC_composite_in_use GC_arrays._composite_in_use
+#   define GC_atomic_in_use GC_arrays._atomic_in_use
+# endif
+# ifdef MERGE_SIZES
+#   define GC_size_map GC_arrays._size_map
+# endif
+
+# define beginGC_arrays ((ptr_t)(&GC_arrays))
+# define endGC_arrays (((ptr_t)(&GC_arrays)) + (sizeof GC_arrays))
+
+GC_API word GC_fo_entries;
+
+# define MAXOBJKINDS 16
+
+/* Object kinds: */
+extern struct obj_kind {
+   ptr_t *ok_freelist;	/* Array of free listheaders for this kind of object */
+   			/* Point either to GC_arrays or to storage allocated */
+   			/* with GC_scratch_alloc.			     */
+   struct hblk **ok_reclaim_list;
+   			/* List headers for lists of blocks waiting to be */
+   			/* swept.					  */
+   word ok_descriptor;  /* Descriptor template for objects in this	*/
+   			/* block.					*/
+   bool ok_relocate_descr;
+   			/* Add object size in bytes to descriptor 	*/
+   			/* template to obtain descriptor.  Otherwise	*/
+   			/* template is used as is.			*/
+   bool ok_init;     /* Clear objects before putting them on the free list. */
+} GC_obj_kinds[MAXOBJKINDS];
+/* Predefined kinds: */
+# define PTRFREE 0
+# define NORMAL  1
+# define UNCOLLECTABLE 2
+# ifdef ATOMIC_UNCOLLECTABLE
+#   define AUNCOLLECTABLE 3
+#   define STUBBORN 4
+#   define IS_UNCOLLECTABLE(k) (((k) & ~1) == UNCOLLECTABLE)
+# else
+#   define STUBBORN 3
+#   define IS_UNCOLLECTABLE(k) ((k) == UNCOLLECTABLE)
+# endif
+
+extern int GC_n_kinds;
+
+extern word GC_n_heap_sects;	/* Number of separately added heap	*/
+				/* sections.				*/
+
+# ifdef MSWIN32
+extern word GC_n_heap_bases;	/* See GC_heap_bases.	*/
+# endif
+
+extern word GC_total_black_listed;
+			/* Number of bytes on stack blacklist. 	*/
+
+extern word GC_black_list_spacing;
+			/* Average number of bytes between blacklisted	*/
+			/* blocks. Approximate.				*/
+
+extern char * GC_invalid_map;
+			/* Pointer to the nowhere valid hblk map */
+			/* Blocks pointing to this map are free. */
+
+extern struct hblk * GC_hblkfreelist;
+				/* List of completely empty heap blocks	*/
+				/* Linked through hb_next field of 	*/
+				/* header structure associated with	*/
+				/* block.				*/
+
+extern bool GC_is_initialized;		/* GC_init() has been run.	*/
+
+extern bool GC_objects_are_marked;	/* There are marked objects in  */
+					/* the heap.			*/
+
+extern int GC_incremental;  /* Using incremental/generational collection. */
+
+extern bool GC_dirty_maintained;/* Dirty bits are being maintained, 	*/
+				/* either for incremental collection,	*/
+				/* or to limit the root set.		*/
+
+# ifndef PCR
+    extern ptr_t GC_stackbottom;	/* Cool end of user stack	*/
+# endif
+
+extern word GC_root_size;	/* Total size of registered root sections */
+
+extern bool GC_debugging_started;	/* GC_debug_malloc has been called. */ 
+
+extern ptr_t GC_least_plausible_heap_addr;
+extern ptr_t GC_greatest_plausible_heap_addr;
+			/* Bounds on the heap.  Guaranteed valid	*/
+			/* Likely to include future heap expansion.	*/
+			
+/* Operations */
+# ifndef abs
+#   define abs(x)  ((x) < 0? (-(x)) : (x))
+# endif
+
+
+/*  Marks are in a reserved area in                          */
+/*  each heap block.  Each word has one mark bit associated  */
+/*  with it. Only those corresponding to the beginning of an */
+/*  object are used.                                         */
+
+
+/* Mark bit perations */
+
+/*
+ * Retrieve, set, clear the mark bit corresponding
+ * to the nth word in a given heap block.
+ *
+ * (Recall that bit n corresponds to object beginning at word n
+ * relative to the beginning of the block, including unused words)
+ */
+
+# define mark_bit_from_hdr(hhdr,n) (((hhdr)->hb_marks[divWORDSZ(n)] \
+			    >> (modWORDSZ(n))) & (word)1)
+# define set_mark_bit_from_hdr(hhdr,n) (hhdr)->hb_marks[divWORDSZ(n)] \
+				|= (word)1 << modWORDSZ(n)
+
+# define clear_mark_bit_from_hdr(hhdr,n) (hhdr)->hb_marks[divWORDSZ(n)] \
+				&= ~((word)1 << modWORDSZ(n))
+
+/* Important internal collector routines */
+
+void GC_apply_to_all_blocks(/*fn, client_data*/);
+			/* Invoke fn(hbp, client_data) for each 	*/
+			/* allocated heap block.			*/
+struct hblk * GC_next_block(/* struct hblk * h */);
+void GC_mark_init();
+void GC_clear_marks();	/* Clear mark bits for all heap objects. */
+void GC_invalidate_mark_state();	/* Tell the marker that	marked 	   */
+					/* objects may point to	unmarked   */
+					/* ones, and roots may point to	   */
+					/* unmarked objects.		   */
+					/* Reset mark stack.		   */
+void GC_mark_from_mark_stack(); /* Mark from everything on the mark stack. */
+				/* Return after about one pages worth of   */
+				/* work.				   */
+bool GC_mark_stack_empty();
+bool GC_mark_some();	/* Perform about one pages worth of marking	*/
+			/* work of whatever kind is needed.  Returns	*/
+			/* quickly if no collection is in progress.	*/
+			/* Return TRUE if mark phase finished.		*/
+void GC_initiate_gc();		/* initiate collection.			*/
+				/* If the mark state is invalid, this	*/
+				/* becomes full colleection.  Otherwise */
+				/* it's partial.			*/
+void GC_push_all(/*b,t*/);	/* Push everything in a range 		*/
+				/* onto mark stack.			*/
+void GC_push_dirty(/*b,t*/);      /* Push all possibly changed	 	*/
+				  /* subintervals of [b,t) onto		*/
+				  /* mark stack.			*/
+#ifndef SMALL_CONFIG
+  void GC_push_conditional(/* ptr_t b, ptr_t t, bool all*/);
+#else
+# define GC_push_conditional(b, t, all) GC_push_all(b, t)
+#endif
+                                /* Do either of the above, depending	*/
+				/* on the third arg.			*/
+void GC_push_all_stack(/*b,t*/);    /* As above, but consider		*/
+				    /*  interior pointers as valid  	*/
+void GC_push_roots(/* bool all */); /* Push all or dirty roots.	*/
+extern void (*GC_push_other_roots)();
+			/* Push system or application specific roots	*/
+			/* onto the mark stack.  In some environments	*/
+			/* (e.g. threads environments) this is		*/
+			/* predfined to be non-zero.  A client supplied */
+			/* replacement should also call the original	*/
+			/* function.					*/
+void GC_push_regs();	/* Push register contents onto mark stack.	*/
+void GC_remark();	/* Mark from all marked objects.  Used	*/
+		 	/* only if we had to drop something.	*/
+void GC_push_one(/*p*/);	/* If p points to an object, mark it	*/
+				/* and push contents on the mark stack	*/
+void GC_push_one_checked(/*p*/); /* Ditto, omits plausibility test	*/
+void GC_push_marked(/* struct hblk h, hdr * hhdr */);
+		/* Push contents of all marked objects in h onto	*/
+		/* mark stack.						*/
+#ifdef SMALL_CONFIG
+# define GC_push_next_marked_dirty(h) GC_push_next_marked(h)
+#else
+  struct hblk * GC_push_next_marked_dirty(/* h */);
+		/* Invoke GC_push_marked on next dirty block above h.	*/
+		/* Return a pointer just past the end of this block.	*/
+#endif /* !SMALL_CONFIG */
+struct hblk * GC_push_next_marked(/* h */);
+		/* Ditto, but also mark from clean pages.	*/
+struct hblk * GC_push_next_marked_uncollectable(/* h */);
+		/* Ditto, but mark only from uncollectable pages.	*/
+bool GC_stopped_mark(); /* Stop world and mark from all roots	*/
+			/* and rescuers.			*/
+void GC_clear_hdr_marks(/* hhdr */);  /* Clear the mark bits in a header */
+void GC_set_hdr_marks(/* hhdr */);  /* Set the mark bits in a header */
+void GC_add_roots_inner();
+bool GC_is_static_root(/* ptr_t p */);
+		/* Is the address p in one of the registered static	*/
+		/* root sections?					*/
+void GC_register_dynamic_libraries();
+		/* Add dynamic library data sections to the root set. */
+
+/* Machine dependent startup routines */
+ptr_t GC_get_stack_base();
+void GC_register_data_segments();
+
+/* Black listing: */
+void GC_bl_init(); 	
+# ifndef ALL_INTERIOR_POINTERS
+    void GC_add_to_black_list_normal(/* bits */);
+			/* Register bits as a possible future false	*/
+			/* reference from the heap or static data	*/
+#   define GC_ADD_TO_BLACK_LIST_NORMAL(bits) GC_add_to_black_list_normal(bits)
+# else
+#   define GC_ADD_TO_BLACK_LIST_NORMAL(bits) GC_add_to_black_list_stack(bits)
+# endif
+
+void GC_add_to_black_list_stack(/* bits */);
+struct hblk * GC_is_black_listed(/* h, len */);
+			/* If there are likely to be false references	*/
+			/* to a block starting at h of the indicated    */
+			/* length, then return the next plausible	*/
+			/* starting location for h that might avoid	*/
+			/* these false references.			*/
+void GC_promote_black_lists();
+			/* Declare an end to a black listing phase.	*/
+void GC_unpromote_black_lists();
+			/* Approximately undo the effect of the above.	*/
+			/* This actually loses some information, but	*/
+			/* only in a reasonably safe way.		*/
+word GC_number_stack_black_listed(/*struct hblk *start, struct hblk *endp1 */);
+			/* Return the number of (stack) blacklisted	*/
+			/* blocks in the range for statistical		*/
+			/* purposes.					*/
+		 	
+ptr_t GC_scratch_alloc(/*bytes*/);
+				/* GC internal memory allocation for	*/
+				/* small objects.  Deallocation is not  */
+				/* possible.				*/
+	
+/* Heap block layout maps: */			
+void GC_invalidate_map(/* hdr */);
+				/* Remove the object map associated	*/
+				/* with the block.  This identifies	*/
+				/* the block as invalid to the mark	*/
+				/* routines.				*/
+bool GC_add_map_entry(/*sz*/);
+				/* Add a heap block map for objects of	*/
+				/* size sz to obj_map.			*/
+				/* Return FALSE on failure.		*/
+void GC_register_displacement_inner(/*offset*/);
+				/* Version of GC_register_displacement	*/
+				/* that assumes lock is already held	*/
+				/* and signals are already disabled.	*/
+
+/*  hblk allocation: */		
+void GC_new_hblk(/*size_in_words, kind*/);
+				/* Allocate a new heap block, and build */
+				/* a free list in it.			*/				
+struct hblk * GC_allochblk(/*size_in_words, kind*/);
+				/* Allocate a heap block, clear it if	*/
+				/* for composite objects, inform	*/
+				/* the marker that block is valid	*/
+				/* for objects of indicated size.	*/
+				/* sz < 0 ==> atomic.			*/ 
+void GC_freehblk();		/* Deallocate a heap block and mark it  */
+				/* as invalid.				*/
+				
+/*  Misc GC: */
+void GC_init_inner();
+bool GC_expand_hp_inner();
+void GC_start_reclaim(/*abort_if_found*/);
+				/* Restore unmarked objects to free	*/
+				/* lists, or (if abort_if_found is	*/
+				/* TRUE) report them.			*/
+				/* Sweeping of small object pages is	*/
+				/* largely deferred.			*/
+void GC_continue_reclaim(/*size, kind*/);
+				/* Sweep pages of the given size and	*/
+				/* kind, as long as possible, and	*/
+				/* as long as the corr. free list is    */
+				/* empty.				*/
+void GC_reclaim_or_delete_all();
+				/* Arrange for all reclaim lists to be	*/
+				/* empty.  Judiciously choose between	*/
+				/* sweeping and discarding each page.	*/
+bool GC_reclaim_all(/* GC_stop_func f*/);
+				/* Reclaim all blocks.  Abort (in a	*/
+				/* consistent state) if f returns TRUE. */
+bool GC_block_empty(/* hhdr */); /* Block completely unmarked? 	*/
+bool GC_never_stop_func();	/* Returns FALSE.		*/
+bool GC_try_to_collect_inner(/* GC_stop_func f */);
+				/* Collect; caller must have acquired	*/
+				/* lock and disabled signals.		*/
+				/* Collection is aborted if f returns	*/
+				/* TRUE.  Returns TRUE if it completes	*/
+				/* successfully.			*/
+# define GC_gcollect_inner() \
+	(void) GC_try_to_collect_inner(GC_never_stop_func)
+void GC_finish_collection();	/* Finish collection.  Mark bits are	*/
+				/* consistent and lock is still held.	*/
+bool GC_collect_or_expand(/* needed_blocks */);
+				/* Collect or expand heap in an attempt */
+				/* make the indicated number of free	*/
+				/* blocks available.  Should be called	*/
+				/* until the blocks are available or	*/
+				/* until it fails by returning FALSE.	*/
+void GC_init();			/* Initialize collector.		*/
+void GC_collect_a_little_inner(/* int n */);
+				/* Do n units worth of garbage 		*/
+				/* collection work, if appropriate.	*/
+				/* A unit is an amount appropriate for  */
+				/* HBLKSIZE bytes of allocation.	*/
+ptr_t GC_generic_malloc(/* bytes, kind */);
+				/* Allocate an object of the given	*/
+				/* kind.  By default, there are only	*/
+				/* two kinds: composite, and atomic.	*/
+				/* We claim it's possible for clever	*/
+				/* client code that understands GC	*/
+				/* internals to add more, e.g. to	*/
+				/* communicate object layout info	*/
+				/* to the collector.			*/
+ptr_t GC_generic_malloc_inner(/* bytes, kind */);
+				/* Ditto, but I already hold lock, etc.	*/
+ptr_t GC_generic_malloc_words_small GC_PROTO((size_t words, int kind));
+				/* As above, but size in units of words */
+				/* Bypasses MERGE_SIZES.  Assumes	*/
+				/* words <= MAXOBJSZ.			*/
+ptr_t GC_generic_malloc_inner_ignore_off_page(/* bytes, kind */);
+				/* Allocate an object, where		*/
+				/* the client guarantees that there	*/
+				/* will always be a pointer to the 	*/
+				/* beginning of the object while the	*/
+				/* object is live.			*/
+ptr_t GC_allocobj(/* sz_inn_words, kind */);
+				/* Make the indicated 			*/
+				/* free list nonempty, and return its	*/
+				/* head.				*/
+
+void GC_init_headers();
+bool GC_install_header(/*h*/);
+				/* Install a header for block h.	*/
+				/* Return FALSE on failure.		*/
+bool GC_install_counts(/*h, sz*/);
+				/* Set up forwarding counts for block	*/
+				/* h of size sz.			*/
+				/* Return FALSE on failure.		*/
+void GC_remove_header(/*h*/);
+				/* Remove the header for block h.	*/
+void GC_remove_counts(/*h, sz*/);
+				/* Remove forwarding counts for h.	*/
+hdr * GC_find_header(/*p*/);	/* Debugging only.			*/
+
+void GC_finalize();	/* Perform all indicated finalization actions	*/
+			/* on unmarked objects.				*/
+			/* Unreachable finalizable objects are enqueued	*/
+			/* for processing by GC_invoke_finalizers.	*/
+			/* Invoked with lock.				*/
+void GC_invoke_finalizers(); 	/* Run eligible finalizers.	*/
+				/* Invoked without lock.	*/	
+			
+void GC_add_to_heap(/*p, bytes*/);
+			/* Add a HBLKSIZE aligned chunk to the heap.	*/
+
+void GC_print_obj(/* ptr_t p */);
+			/* P points to somewhere inside an object with	*/
+			/* debugging info.  Print a human readable	*/
+			/* description of the object to stderr.		*/
+extern void (*GC_check_heap)();
+			/* Check that all objects in the heap with 	*/
+			/* debugging info are intact.  Print 		*/
+			/* descriptions of any that are not.		*/
+			
+/* Virtual dirty bit implementation:		*/
+/* Each implementation exports the following:	*/
+void GC_read_dirty();	/* Retrieve dirty bits.	*/
+bool GC_page_was_dirty(/* struct hblk * h  */);
+			/* Read retrieved dirty bits.	*/
+bool GC_page_was_ever_dirty(/* struct hblk * h  */);
+			/* Could the page contain valid heap pointers?	*/
+void GC_is_fresh(/* struct hblk * h, word number_of_blocks  */);
+			/* Assert the region currently contains no	*/
+			/* valid pointers.				*/
+void GC_write_hint(/* struct hblk * h  */);
+			/* h is about to be written.	*/
+void GC_dirty_init();
+
+/* Slow/general mark bit manipulation: */
+bool GC_is_marked();
+void GC_clear_mark_bit();
+void GC_set_mark_bit();
+
+/* Stubborn objects: */
+void GC_read_changed();	/* Analogous to GC_read_dirty */
+bool GC_page_was_changed(/* h */);	/* Analogous to GC_page_was_dirty */
+void GC_clean_changing_list();	/* Collect obsolete changing list entries */
+void GC_stubborn_init();
+
+/* Debugging print routines: */
+void GC_print_block_list();
+void GC_print_hblkfreelist();
+void GC_print_heap_sects();
+void GC_print_static_roots();
+void GC_dump();
+
+/* Make arguments appear live to compiler */
+GC_API void GC_noop();
+void GC_noop1(/* word arg */);
+
+/* Logging and diagnostic output: 	*/
+GC_API void GC_printf GC_PROTO((char * format, long, long, long, long, long, long));
+			/* A version of printf that doesn't allocate,	*/
+			/* is restricted to long arguments, and		*/
+			/* (unfortunately) doesn't use varargs for	*/
+			/* portability.  Restricted to 6 args and	*/
+			/* 1K total output length.			*/
+			/* (We use sprintf.  Hopefully that doesn't	*/
+			/* allocate for long arguments.)  		*/
+# define GC_printf0(f) GC_printf(f, 0l, 0l, 0l, 0l, 0l, 0l)
+# define GC_printf1(f,a) GC_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
+# define GC_printf2(f,a,b) GC_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
+# define GC_printf3(f,a,b,c) GC_printf(f, (long)a, (long)b, (long)c, 0l, 0l, 0l)
+# define GC_printf4(f,a,b,c,d) GC_printf(f, (long)a, (long)b, (long)c, \
+					    (long)d, 0l, 0l)
+# define GC_printf5(f,a,b,c,d,e) GC_printf(f, (long)a, (long)b, (long)c, \
+					      (long)d, (long)e, 0l)
+# define GC_printf6(f,a,b,c,d,e,g) GC_printf(f, (long)a, (long)b, (long)c, \
+						(long)d, (long)e, (long)g)
+
+void GC_err_printf(/* format, a, b, c, d, e, f */);
+# define GC_err_printf0(f) GC_err_puts(f)
+# define GC_err_printf1(f,a) GC_err_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
+# define GC_err_printf2(f,a,b) GC_err_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
+# define GC_err_printf3(f,a,b,c) GC_err_printf(f, (long)a, (long)b, (long)c, \
+						  0l, 0l, 0l)
+# define GC_err_printf4(f,a,b,c,d) GC_err_printf(f, (long)a, (long)b, \
+						    (long)c, (long)d, 0l, 0l)
+# define GC_err_printf5(f,a,b,c,d,e) GC_err_printf(f, (long)a, (long)b, \
+						      (long)c, (long)d, \
+						      (long)e, 0l)
+# define GC_err_printf6(f,a,b,c,d,e,g) GC_err_printf(f, (long)a, (long)b, \
+							(long)c, (long)d, \
+							(long)e, (long)g)
+			/* Ditto, writes to stderr.			*/
+			
+void GC_err_puts(/* char *s */);
+			/* Write s to stderr, don't buffer, don't add	*/
+			/* newlines, don't ...				*/
+
+# endif /* GC_PRIVATE_H */
diff --git a/src/mzscheme/gc/include/weakpointer.h b/src/mzscheme/gc/include/weakpointer.h
new file mode 100644
index 0000000..84906b0
--- /dev/null
+++ b/src/mzscheme/gc/include/weakpointer.h
@@ -0,0 +1,221 @@
+#ifndef	_weakpointer_h_
+#define	_weakpointer_h_
+
+/****************************************************************************
+
+WeakPointer and CleanUp
+
+    Copyright (c) 1991 by Xerox Corporation.  All rights reserved.
+
+    THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+    OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+    Permission is hereby granted to copy this code for any purpose,
+    provided the above notices are retained on all copies.
+
+    Last modified on Mon Jul 17 18:16:01 PDT 1995 by ellis
+
+****************************************************************************/
+
+/****************************************************************************
+
+WeakPointer
+
+A weak pointer is a pointer to a heap-allocated object that doesn't
+prevent the object from being garbage collected. Weak pointers can be
+used to track which objects haven't yet been reclaimed by the
+collector. A weak pointer is deactivated when the collector discovers
+its referent object is unreachable by normal pointers (reachability
+and deactivation are defined more precisely below). A deactivated weak
+pointer remains deactivated forever.
+
+****************************************************************************/
+
+
+template< class T > class WeakPointer {
+public:
+
+WeakPointer( T* t = 0 )
+    /* Constructs a weak pointer for *t. t may be null. It is an error
+       if t is non-null and *t is not a collected object. */
+    {impl = _WeakPointer_New( t );}
+
+T* Pointer()
+    /* wp.Pointer() returns a pointer to the referent object of wp or
+       null if wp has been deactivated (because its referent object
+       has been discovered unreachable by the collector). */
+    {return (T*) _WeakPointer_Pointer( this->impl );}
+
+int operator==( WeakPointer< T > wp2 )
+    /* Given weak pointers wp1 and wp2, if wp1 == wp2, then wp1 and
+       wp2 refer to the same object. If wp1 != wp2, then either wp1
+       and wp2 don't refer to the same object, or if they do, one or
+       both of them has been deactivated. (Note: If objects t1 and t2
+       are never made reachable by their clean-up functions, then
+       WeakPointer<T>(t1) == WeakPointer<T>(t2) if and only t1 == t2.) */
+    {return _WeakPointer_Equal( this->impl, wp2.impl );}
+
+int Hash()
+    /* Returns a hash code suitable for use by multiplicative- and
+       division-based hash tables. If wp1 == wp2, then wp1.Hash() ==
+       wp2.Hash(). */
+    {return _WeakPointer_Hash( this->impl );}
+
+private:
+void* impl;
+};
+
+/*****************************************************************************
+
+CleanUp
+
+A garbage-collected object can have an associated clean-up function
+that will be invoked some time after the collector discovers the
+object is unreachable via normal pointers. Clean-up functions can be
+used to release resources such as open-file handles or window handles
+when their containing objects become unreachable.  If a C++ object has
+a non-empty explicit destructor (i.e. it contains programmer-written
+code), the destructor will be automatically registered as the object's
+initial clean-up function.
+
+There is no guarantee that the collector will detect every unreachable
+object (though it will find almost all of them). Clients should not
+rely on clean-up to cause some action to occur immediately -- clean-up
+is only a mechanism for improving resource usage.
+
+Every object with a clean-up function also has a clean-up queue. When
+the collector finds the object is unreachable, it enqueues it on its
+queue. The clean-up function is applied when the object is removed
+from the queue. By default, objects are enqueued on the garbage
+collector's queue, and the collector removes all objects from its
+queue after each collection. If a client supplies another queue for
+objects, it is his responsibility to remove objects (and cause their
+functions to be called) by polling it periodically.
+
+Clean-up queues allow clean-up functions accessing global data to
+synchronize with the main program. Garbage collection can occur at any
+time, and clean-ups invoked by the collector might access data in an
+inconsistent state. A client can control this by defining an explicit
+queue for objects and polling it at safe points.
+
+The following definitions are used by the specification below:
+
+Given a pointer t to a collected object, the base object BO(t) is the
+value returned by new when it created the object. (Because of multiple
+inheritance, t and BO(t) may not be the same address.)
+
+A weak pointer wp references an object *t if BO(wp.Pointer()) ==
+BO(t).
+
+***************************************************************************/
+
+template< class T, class Data > class CleanUp {
+public:
+
+static void Set( T* t, void c( Data* d, T* t ), Data* d = 0 )
+    /* Sets the clean-up function of object BO(t) to be <c, d>,
+       replacing any previously defined clean-up function for BO(t); c
+       and d can be null, but t cannot. Sets the clean-up queue for
+       BO(t) to be the collector's queue. When t is removed from its
+       clean-up queue, its clean-up will be applied by calling c(d,
+       t). It is an error if *t is not a collected object. */ 
+       {_CleanUp_Set( t, c, d );}
+
+static void Call( T* t )
+    /* Sets the new clean-up function for BO(t) to be null and, if the
+       old one is non-null, calls it immediately, even if BO(t) is
+       still reachable. Deactivates any weak pointers to BO(t). */
+       {_CleanUp_Call( t );}
+
+class Queue {public:
+    Queue()
+        /* Constructs a new queue. */
+            {this->head = _CleanUp_Queue_NewHead();}
+
+    void Set( T* t )
+        /* q.Set(t) sets the clean-up queue of BO(t) to be q. */
+            {_CleanUp_Queue_Set( this->head, t );}
+
+    int Call()
+        /* If q is non-empty, q.Call() removes the first object and
+           calls its clean-up function; does nothing if q is
+           empty. Returns true if there are more objects in the
+           queue. */
+           {return _CleanUp_Queue_Call( this->head );}
+
+    private:
+    void* head;
+    };
+};
+
+/**********************************************************************
+
+Reachability and Clean-up
+
+An object O is reachable if it can be reached via a non-empty path of
+normal pointers from the registers, stacks, global variables, or an
+object with a non-null clean-up function (including O itself),
+ignoring pointers from an object to itself.
+
+This definition of reachability ensures that if object B is accessible
+from object A (and not vice versa) and if both A and B have clean-up
+functions, then A will always be cleaned up before B. Note that as
+long as an object with a clean-up function is contained in a cycle of
+pointers, it will always be reachable and will never be cleaned up or
+collected.
+
+When the collector finds an unreachable object with a null clean-up
+function, it atomically deactivates all weak pointers referencing the
+object and recycles its storage. If object B is accessible from object
+A via a path of normal pointers, A will be discovered unreachable no
+later than B, and a weak pointer to A will be deactivated no later
+than a weak pointer to B.
+
+When the collector finds an unreachable object with a non-null
+clean-up function, the collector atomically deactivates all weak
+pointers referencing the object, redefines its clean-up function to be
+null, and enqueues it on its clean-up queue. The object then becomes
+reachable again and remains reachable at least until its clean-up
+function executes.
+
+The clean-up function is assured that its argument is the only
+accessible pointer to the object. Nothing prevents the function from
+redefining the object's clean-up function or making the object
+reachable again (for example, by storing the pointer in a global
+variable).
+
+If the clean-up function does not make its object reachable again and
+does not redefine its clean-up function, then the object will be
+collected by a subsequent collection (because the object remains
+unreachable and now has a null clean-up function). If the clean-up
+function does make its object reachable again and a clean-up function
+is subsequently redefined for the object, then the new clean-up
+function will be invoked the next time the collector finds the object
+unreachable.
+
+Note that a destructor for a collected object cannot safely redefine a
+clean-up function for its object, since after the destructor executes,
+the object has been destroyed into "raw memory". (In most
+implementations, destroying an object mutates its vtbl.)
+
+Finally, note that calling delete t on a collected object first
+deactivates any weak pointers to t and then invokes its clean-up
+function (destructor).
+
+**********************************************************************/
+
+extern "C" {
+    void* _WeakPointer_New( void* t );
+    void* _WeakPointer_Pointer( void* wp );
+    int _WeakPointer_Equal( void* wp1, void* wp2 );
+    int _WeakPointer_Hash( void* wp );
+    void _CleanUp_Set( void* t, void (*c)( void* d, void* t ), void* d );
+    void _CleanUp_Call( void* t );
+    void* _CleanUp_Queue_NewHead ();
+    void _CleanUp_Queue_Set( void* h, void* t );
+    int _CleanUp_Queue_Call( void* h );
+}
+
+#endif /* _weakpointer_h_ */
+
+
diff --git a/src/mzscheme/gc/irix_threads.c b/src/mzscheme/gc/irix_threads.c
new file mode 100644
index 0000000..d33e1c9
--- /dev/null
+++ b/src/mzscheme/gc/irix_threads.c
@@ -0,0 +1,559 @@
+/* 
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/*
+ * Support code for Irix (>=6.2) Pthreads.  This relies on properties
+ * not guaranteed by the Pthread standard.  It may or may not be portable
+ * to other implementations.
+ */
+
+# if defined(IRIX_THREADS)
+
+# include "gc_priv.h"
+# include <pthread.h>
+# include <time.h>
+# include <errno.h>
+# include <unistd.h>
+# include <sys/mman.h>
+# include <sys/time.h>
+
+#undef pthread_create
+#undef pthread_sigmask
+#undef pthread_join
+
+#ifdef UNDEFINED
+void GC_print_sig_mask()
+{
+    sigset_t blocked;
+    int i;
+
+    if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0)
+    	ABORT("pthread_sigmask");
+    GC_printf0("Blocked: ");
+    for (i = 1; i <= MAXSIG; i++) {
+        if (sigismember(&blocked, i)) { GC_printf1("%ld ",(long) i); }
+    }
+    GC_printf0("\n");
+}
+#endif
+
+/* We use the allocation lock to protect thread-related data structures. */
+
+/* The set of all known threads.  We intercept thread creation and 	*/
+/* joins.  We never actually create detached threads.  We allocate all 	*/
+/* new thread stacks ourselves.  These allow us to maintain this	*/
+/* data structure.							*/
+/* Protected by GC_thr_lock.						*/
+/* Some of this should be declared volatile, but that's incosnsistent	*/
+/* with some library routine declarations.  		 		*/
+typedef struct GC_Thread_Rep {
+    struct GC_Thread_Rep * next;  /* More recently allocated threads	*/
+				  /* with a given pthread id come 	*/
+				  /* first.  (All but the first are	*/
+				  /* guaranteed to be dead, but we may  */
+				  /* not yet have registered the join.) */
+    pthread_t id;
+    word flags;
+#	define FINISHED 1   	/* Thread has exited.	*/
+#	define DETACHED 2	/* Thread is intended to be detached.	*/
+#	define CLIENT_OWNS_STACK	4
+				/* Stack was supplied by client.	*/
+    ptr_t stack;
+    ptr_t stack_ptr;  		/* Valid only when stopped. */
+				/* But must be within stack region at	*/
+				/* all times.				*/
+    size_t stack_size;		/* 0 for original thread.	*/
+    void * status;		/* Used only to avoid premature 	*/
+				/* reclamation of any data it might 	*/
+				/* reference.				*/
+} * GC_thread;
+
+GC_thread GC_lookup_thread(pthread_t id);
+
+/*
+ * The only way to suspend threads given the pthread interface is to send
+ * signals.  Unfortunately, this means we have to reserve
+ * SIGUSR2, and intercept client calls to change the signal mask.
+ */
+# define SIG_SUSPEND SIGUSR2
+
+pthread_mutex_t GC_suspend_lock = PTHREAD_MUTEX_INITIALIZER;
+volatile unsigned GC_n_stopped = 0;
+				/* Number of threads stopped so far	*/
+pthread_cond_t GC_suspend_ack_cv = PTHREAD_COND_INITIALIZER;
+pthread_cond_t GC_continue_cv = PTHREAD_COND_INITIALIZER;
+
+void GC_suspend_handler(int sig)
+{
+    int dummy;
+    GC_thread me;
+    sigset_t all_sigs;
+    sigset_t old_sigs;
+    int i;
+
+    if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler");
+    pthread_mutex_lock(&GC_suspend_lock);
+    me = GC_lookup_thread(pthread_self());
+    /* The lookup here is safe, since I'm doing this on behalf  */
+    /* of a thread which holds the allocation lock in order	*/
+    /* to stop the world.  Thus concurrent modification of the	*/
+    /* data structure is impossible.				*/
+    me -> stack_ptr = (ptr_t)(&dummy);
+    GC_n_stopped++;
+    pthread_cond_signal(&GC_suspend_ack_cv);
+    pthread_cond_wait(&GC_continue_cv, &GC_suspend_lock);
+    pthread_mutex_unlock(&GC_suspend_lock);
+    /* GC_printf1("Continuing 0x%x\n", pthread_self()); */
+}
+
+
+bool GC_thr_initialized = FALSE;
+
+size_t GC_min_stack_sz;
+
+size_t GC_page_sz;
+
+# define N_FREE_LISTS 25
+ptr_t GC_stack_free_lists[N_FREE_LISTS] = { 0 };
+		/* GC_stack_free_lists[i] is free list for stacks of 	*/
+		/* size GC_min_stack_sz*2**i.				*/
+		/* Free lists are linked through first word.		*/
+
+/* Return a stack of size at least *stack_size.  *stack_size is	*/
+/* replaced by the actual stack size.				*/
+/* Caller holds allocation lock.				*/
+ptr_t GC_stack_alloc(size_t * stack_size)
+{
+    register size_t requested_sz = *stack_size;
+    register size_t search_sz = GC_min_stack_sz;
+    register int index = 0;	/* = log2(search_sz/GC_min_stack_sz) */
+    register ptr_t result;
+    
+    while (search_sz < requested_sz) {
+        search_sz *= 2;
+        index++;
+    }
+    if ((result = GC_stack_free_lists[index]) == 0
+        && (result = GC_stack_free_lists[index+1]) != 0) {
+        /* Try next size up. */
+        search_sz *= 2; index++;
+    }
+    if (result != 0) {
+        GC_stack_free_lists[index] = *(ptr_t *)result;
+    } else {
+        result = (ptr_t) GC_scratch_alloc(search_sz + 2*GC_page_sz);
+        result = (ptr_t)(((word)result + GC_page_sz) & ~(GC_page_sz - 1));
+        /* Protect hottest page to detect overflow. */
+        /* mprotect(result, GC_page_sz, PROT_NONE); */
+        result += GC_page_sz;
+    }
+    *stack_size = search_sz;
+    return(result);
+}
+
+/* Caller holds allocation lock.					*/
+void GC_stack_free(ptr_t stack, size_t size)
+{
+    register int index = 0;
+    register size_t search_sz = GC_min_stack_sz;
+    
+    while (search_sz < size) {
+        search_sz *= 2;
+        index++;
+    }
+    if (search_sz != size) ABORT("Bad stack size");
+    *(ptr_t *)stack = GC_stack_free_lists[index];
+    GC_stack_free_lists[index] = stack;
+}
+
+
+
+# define THREAD_TABLE_SZ 128	/* Must be power of 2	*/
+volatile GC_thread GC_threads[THREAD_TABLE_SZ];
+
+/* Add a thread to GC_threads.  We assume it wasn't already there.	*/
+/* Caller holds allocation lock.					*/
+GC_thread GC_new_thread(pthread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    GC_thread result;
+    static struct GC_Thread_Rep first_thread;
+    static bool first_thread_used = FALSE;
+    
+    if (!first_thread_used) {
+    	result = &first_thread;
+    	first_thread_used = TRUE;
+    	/* Dont acquire allocation lock, since we may already hold it. */
+    } else {
+        result = (struct GC_Thread_Rep *)
+        	 GC_generic_malloc_inner(sizeof(struct GC_Thread_Rep), NORMAL);
+    }
+    if (result == 0) return(0);
+    result -> id = id;
+    result -> next = GC_threads[hv];
+    GC_threads[hv] = result;
+    /* result -> flags = 0; */
+    return(result);
+}
+
+/* Delete a thread from GC_threads.  We assume it is there.	*/
+/* (The code intentionally traps if it wasn't.)			*/
+/* Caller holds allocation lock.				*/
+void GC_delete_thread(pthread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    register GC_thread p = GC_threads[hv];
+    register GC_thread prev = 0;
+    
+    while (!pthread_equal(p -> id, id)) {
+        prev = p;
+        p = p -> next;
+    }
+    if (prev == 0) {
+        GC_threads[hv] = p -> next;
+    } else {
+        prev -> next = p -> next;
+    }
+}
+
+/* If a thread has been joined, but we have not yet		*/
+/* been notified, then there may be more than one thread 	*/
+/* in the table with the same pthread id.			*/
+/* This is OK, but we need a way to delete a specific one.	*/
+void GC_delete_gc_thread(pthread_t id, GC_thread gc_id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    register GC_thread p = GC_threads[hv];
+    register GC_thread prev = 0;
+
+    while (p != gc_id) {
+        prev = p;
+        p = p -> next;
+    }
+    if (prev == 0) {
+        GC_threads[hv] = p -> next;
+    } else {
+        prev -> next = p -> next;
+    }
+}
+
+/* Return a GC_thread corresponding to a given thread_t.	*/
+/* Returns 0 if it's not there.					*/
+/* Caller holds  allocation lock or otherwise inhibits 		*/
+/* updates.							*/
+/* If there is more than one thread with the given id we 	*/
+/* return the most recent one.					*/
+GC_thread GC_lookup_thread(pthread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    register GC_thread p = GC_threads[hv];
+    
+    while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
+    return(p);
+}
+
+
+/* Caller holds allocation lock.	*/
+void GC_stop_world()
+{
+    pthread_t my_thread = pthread_self();
+    register int i;
+    register GC_thread p;
+    register int n_live_threads = 0;
+    register int result;
+    
+    GC_n_stopped = 0;
+    for (i = 0; i < THREAD_TABLE_SZ; i++) {
+      for (p = GC_threads[i]; p != 0; p = p -> next) {
+        if (p -> id != my_thread) {
+            if (p -> flags & FINISHED) continue;
+            n_live_threads++;
+            result = pthread_kill(p -> id, SIG_SUSPEND);
+	    /* GC_printf1("Sent signal to 0x%x\n", p -> id); */
+	    switch(result) {
+                case ESRCH:
+                    /* Not really there anymore.  Possible? */
+                    n_live_threads--;
+                    break;
+                case 0:
+                    break;
+                default:
+                    ABORT("thr_kill failed");
+            }
+        }
+      }
+    }
+    pthread_mutex_lock(&GC_suspend_lock);
+    while(GC_n_stopped < n_live_threads) {
+    	pthread_cond_wait(&GC_suspend_ack_cv, &GC_suspend_lock);
+    }
+    pthread_mutex_unlock(&GC_suspend_lock);
+    /* GC_printf1("World stopped 0x%x\n", pthread_self()); */
+}
+
+/* Caller holds allocation lock.	*/
+void GC_start_world()
+{
+    /* GC_printf0("World starting\n"); */
+    pthread_mutex_lock(&GC_suspend_lock);
+    /* All other threads are at pthread_cond_wait in signal handler.	*/
+    /* Otherwise we couldn't have acquired the lock.			*/
+    pthread_mutex_unlock(&GC_suspend_lock);
+    pthread_cond_broadcast(&GC_continue_cv);
+}
+
+
+extern ptr_t GC_approx_sp();
+
+/* We hold allocation lock.  We assume the world is stopped.	*/
+void GC_push_all_stacks()
+{
+    register int i;
+    register GC_thread p;
+    register ptr_t sp = GC_approx_sp();
+    register ptr_t lo, hi;
+    pthread_t me = pthread_self();
+    
+    if (!GC_thr_initialized) GC_thr_init();
+    /* GC_printf1("Pushing stacks from thread 0x%x\n", me); */
+    for (i = 0; i < THREAD_TABLE_SZ; i++) {
+      for (p = GC_threads[i]; p != 0; p = p -> next) {
+        if (p -> flags & FINISHED) continue;
+        if (pthread_equal(p -> id, me)) {
+	    lo = GC_approx_sp();
+	} else {
+	    lo = p -> stack_ptr;
+	}
+        if (p -> stack_size != 0) {
+            hi = p -> stack + p -> stack_size;
+        } else {
+            /* The original stack. */
+            hi = GC_stackbottom;
+        }
+        GC_push_all_stack(lo, hi);
+      }
+    }
+}
+
+
+/* We hold the allocation lock.	*/
+GC_thr_init()
+{
+    GC_thread t;
+
+    GC_thr_initialized = TRUE;
+    GC_min_stack_sz = HBLKSIZE;
+    GC_page_sz = sysconf(_SC_PAGESIZE);
+    if (sigset(SIG_SUSPEND, GC_suspend_handler) != SIG_DFL)
+    	ABORT("Previously installed SIG_SUSPEND handler");
+    /* Add the initial thread, so we can stop it.	*/
+      t = GC_new_thread(pthread_self());
+      t -> stack_size = 0;
+      t -> stack_ptr = (ptr_t)(&t);
+      t -> flags = DETACHED;
+}
+
+int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
+{
+    sigset_t fudged_set;
+    
+    if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) {
+        fudged_set = *set;
+        sigdelset(&fudged_set, SIG_SUSPEND);
+        set = &fudged_set;
+    }
+    return(pthread_sigmask(how, set, oset));
+}
+
+struct start_info {
+    void *(*start_routine)(void *);
+    void *arg;
+};
+
+void GC_thread_exit_proc(void *dummy)
+{
+    GC_thread me;
+
+    LOCK();
+    me = GC_lookup_thread(pthread_self());
+    if (me -> flags & DETACHED) {
+    	GC_delete_thread(pthread_self());
+    } else {
+	me -> flags != FINISHED;
+    }
+    UNLOCK();
+}
+
+int GC_pthread_join(pthread_t thread, void **retval)
+{
+    int result;
+    GC_thread thread_gc_id;
+    
+    LOCK();
+    thread_gc_id = GC_lookup_thread(thread);
+    /* This is guaranteed to be the intended one, since the thread id	*/
+    /* cant have been recycled by pthreads.				*/
+    UNLOCK();
+    result = pthread_join(thread, retval);
+    LOCK();
+    /* Here the pthread thread id may have been recycled. */
+    GC_delete_gc_thread(thread, thread_gc_id);
+    UNLOCK();
+    return result;
+}
+
+void * GC_start_routine(void * arg)
+{
+    struct start_info * si = arg;
+    void * result;
+    GC_thread me;
+
+    LOCK();
+    me = GC_lookup_thread(pthread_self());
+    UNLOCK();
+    pthread_cleanup_push(GC_thread_exit_proc, 0);
+    result = (*(si -> start_routine))(si -> arg);
+    me -> status = result;
+    me -> flags |= FINISHED;
+    pthread_cleanup_pop(1);
+	/* This involves acquiring the lock, ensuring that we can't exit */
+	/* while a collection that thinks we're alive is trying to stop  */
+	/* us.								 */
+    return(result);
+}
+
+int
+GC_pthread_create(pthread_t *new_thread,
+		  const pthread_attr_t *attr,
+                  void *(*start_routine)(void *), void *arg)
+{
+    int result;
+    GC_thread t;
+    pthread_t my_new_thread;
+    void * stack;
+    size_t stacksize;
+    pthread_attr_t new_attr;
+    int detachstate;
+    word my_flags = 0;
+    struct start_info * si = GC_malloc(sizeof(struct start_info)); 
+
+    if (0 == si) return(ENOMEM);
+    si -> start_routine = start_routine;
+    si -> arg = arg;
+    LOCK();
+    if (!GC_thr_initialized) GC_thr_init();
+    if (NULL == attr) {
+        stack = 0;
+	(void) pthread_attr_init(&new_attr);
+    } else {
+        new_attr = *attr;
+	pthread_attr_getstackaddr(&new_attr, &stack);
+    }
+    pthread_attr_getstacksize(&new_attr, &stacksize);
+    pthread_attr_getdetachstate(&new_attr, &detachstate);
+    if (stacksize < GC_min_stack_sz) ABORT("Stack too small");
+    if (0 == stack) {
+     	stack = (void *)GC_stack_alloc(&stacksize);
+     	if (0 == stack) {
+     	    UNLOCK();
+     	    return(ENOMEM);
+     	}
+	pthread_attr_setstackaddr(&new_attr, stack);
+    } else {
+    	my_flags |= CLIENT_OWNS_STACK;
+    }
+    if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
+    result = pthread_create(&my_new_thread, &new_attr, GC_start_routine, si);
+    /* No GC can start until the thread is registered, since we hold	*/
+    /* the allocation lock.						*/
+    if (0 == result) {
+        t = GC_new_thread(my_new_thread);
+        t -> flags = my_flags;
+        t -> stack = stack;
+        t -> stack_size = stacksize;
+	t -> stack_ptr = (ptr_t)stack + stacksize - sizeof(word);
+        if (0 != new_thread) *new_thread = my_new_thread;
+    } else if (!(my_flags & CLIENT_OWNS_STACK)) {
+      	GC_stack_free(stack, stacksize);
+    }        
+    UNLOCK();  
+    /* pthread_attr_destroy(&new_attr); */
+    return(result);
+}
+
+bool GC_collecting = 0; /* A hint that we're in the collector and       */
+                        /* holding the allocation lock for an           */
+                        /* extended period.                             */
+
+/* Reasonably fast spin locks.  Basically the same implementation */
+/* as STL alloc.h.  This isn't really the right way to do this.   */
+/* but until the POSIX scheduling mess gets straightened out ...  */
+
+unsigned long GC_allocate_lock = 0;
+
+void GC_lock()
+{
+#   define low_spin_max 30  /* spin cycles if we suspect uniprocessor */
+#   define high_spin_max 1000 /* spin cycles for multiprocessor */
+    static unsigned spin_max = low_spin_max;
+    unsigned my_spin_max;
+    static unsigned last_spins = 0;
+    unsigned my_last_spins;
+    unsigned junk;
+#   define PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk
+    int i;
+
+    if (!__test_and_set(&GC_allocate_lock, 1)) {
+        return;
+    }
+    my_spin_max = spin_max;
+    my_last_spins = last_spins;
+    for (i = 0; i < my_spin_max; i++) {
+        if (GC_collecting) goto yield;
+        if (i < my_last_spins/2 || GC_allocate_lock) {
+            PAUSE; 
+            continue;
+        }
+        if (!__test_and_set(&GC_allocate_lock, 1)) {
+	    /*
+             * got it!
+             * Spinning worked.  Thus we're probably not being scheduled
+             * against the other process with which we were contending.
+             * Thus it makes sense to spin longer the next time.
+	     */
+            last_spins = i;
+            spin_max = high_spin_max;
+            return;
+        }
+    }
+    /* We are probably being scheduled against the other process.  Sleep. */
+    spin_max = low_spin_max;
+yield:
+    for (;;) {
+        if (!__test_and_set(&GC_allocate_lock, 1)) {
+            return;
+        }
+        sched_yield();
+    }
+}
+
+
+
+# else
+
+#ifndef LINT
+  int GC_no_Irix_threads;
+#endif
+
+# endif /* IRIX_THREADS */
+
diff --git a/src/mzscheme/gc/mach_dep.c b/src/mzscheme/gc/mach_dep.c
new file mode 100644
index 0000000..ea1c1fb
--- /dev/null
+++ b/src/mzscheme/gc/mach_dep.c
@@ -0,0 +1,412 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, November 17, 1995 12:13 pm PST */
+# include "gc_priv.h"
+# include <stdio.h>
+# include <setjmp.h>
+# if defined(OS2) || defined(CX_UX)
+#   define _setjmp(b) setjmp(b)
+#   define _longjmp(b,v) longjmp(b,v)
+# endif
+# ifdef AMIGA
+#   include <dos.h>
+# endif
+
+#if defined(__MWERKS__) && !defined(POWERPC)
+
+asm static void PushMacRegisters()
+{
+    sub.w   #4,sp                   // reserve space for one parameter.
+    move.l  a2,(sp)
+    jsr		GC_push_one
+    move.l  a3,(sp)
+    jsr		GC_push_one
+    move.l  a4,(sp)
+    jsr		GC_push_one
+#   if !__option(a6frames)
+	// <pcb> perhaps a6 should be pushed if stack frames are not being used.    
+  	move.l	a6,(sp)
+  	jsr		GC_push_one
+#   endif
+	// skip a5 (globals), a6 (frame pointer), and a7 (stack pointer)
+    move.l  d2,(sp)
+    jsr		GC_push_one
+    move.l  d3,(sp)
+    jsr		GC_push_one
+    move.l  d4,(sp)
+    jsr		GC_push_one
+    move.l  d5,(sp)
+    jsr		GC_push_one
+    move.l  d6,(sp)
+    jsr		GC_push_one
+    move.l  d7,(sp)
+    jsr		GC_push_one
+    add.w   #4,sp                   // fix stack.
+    rts
+}
+
+#endif /* __MWERKS__ */
+
+/* Routine to mark from registers that are preserved by the C compiler. */
+/* This must be ported to every new architecture.  There is a generic   */
+/* version at the end, that is likely, but not guaranteed to work       */
+/* on your architecture.  Run the test_setjmp program to see whether    */
+/* there is any chance it will work.                                    */
+
+void GC_push_regs()
+{
+#       ifdef RT
+	  register long TMP_SP; /* must be bound to r11 */
+#       endif
+#       ifdef VAX
+	  /* VAX - generic code below does not work under 4.2 */
+	  /* r1 through r5 are caller save, and therefore     */
+	  /* on the stack or dead.                            */
+	  asm("pushl r11");     asm("calls $1,_GC_push_one");
+	  asm("pushl r10"); 	asm("calls $1,_GC_push_one");
+	  asm("pushl r9");	asm("calls $1,_GC_push_one");
+	  asm("pushl r8");	asm("calls $1,_GC_push_one");
+	  asm("pushl r7");	asm("calls $1,_GC_push_one");
+	  asm("pushl r6");	asm("calls $1,_GC_push_one");
+#       endif
+#       if defined(M68K) && (defined(SUNOS4) || defined(NEXT))
+	/*  M68K SUNOS - could be replaced by generic code */
+	  /* a0, a1 and d1 are caller save          */
+	  /*  and therefore are on stack or dead.   */
+	
+	  asm("subqw #0x4,sp");		/* allocate word on top of stack */
+
+	  asm("movl a2,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl a3,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl a4,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl a5,sp@");	asm("jbsr _GC_push_one");
+	  /* Skip frame pointer and stack pointer */
+	  asm("movl d1,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d2,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d3,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d4,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d5,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d6,sp@");	asm("jbsr _GC_push_one");
+	  asm("movl d7,sp@");	asm("jbsr _GC_push_one");
+
+	  asm("addqw #0x4,sp");		/* put stack back where it was	*/
+#       endif
+
+#       if defined(M68K) && defined(HP)
+	/*  M68K HP - could be replaced by generic code */
+	  /* a0, a1 and d1 are caller save.  */
+	
+	  asm("subq.w &0x4,%sp");	/* allocate word on top of stack */
+
+	  asm("mov.l %a2,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %a3,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %a4,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %a5,(%sp)"); asm("jsr _GC_push_one");
+	  /* Skip frame pointer and stack pointer */
+	  asm("mov.l %d1,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d2,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d3,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d4,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d5,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d6,(%sp)"); asm("jsr _GC_push_one");
+	  asm("mov.l %d7,(%sp)"); asm("jsr _GC_push_one");
+
+	  asm("addq.w &0x4,%sp");	/* put stack back where it was	*/
+#       endif /* M68K HP */
+
+#       ifdef AMIGA
+	/*  AMIGA - could be replaced by generic code 			*/
+	  /* a0, a1, d0 and d1 are caller save */
+	  GC_push_one(getreg(REG_A2));
+	  GC_push_one(getreg(REG_A3));
+	  GC_push_one(getreg(REG_A4));
+	  GC_push_one(getreg(REG_A5));
+	  GC_push_one(getreg(REG_A6));
+	  /* Skip stack pointer */
+	  GC_push_one(getreg(REG_D2));
+	  GC_push_one(getreg(REG_D3));
+	  GC_push_one(getreg(REG_D4));
+	  GC_push_one(getreg(REG_D5));
+	  GC_push_one(getreg(REG_D6));
+	  GC_push_one(getreg(REG_D7));
+#       endif
+
+#	if defined(M68K) && defined(MACOS)
+#	if defined(THINK_C)
+#         define PushMacReg(reg) \
+              move.l  reg,(sp) \
+              jsr             GC_push_one
+	  asm {
+              sub.w   #4,sp                   ; reserve space for one parameter.
+              PushMacReg(a2);
+              PushMacReg(a3);
+              PushMacReg(a4);
+              ; skip a5 (globals), a6 (frame pointer), and a7 (stack pointer)
+              PushMacReg(d2);
+              PushMacReg(d3);
+              PushMacReg(d4);
+              PushMacReg(d5);
+              PushMacReg(d6);
+              PushMacReg(d7);
+              add.w   #4,sp                   ; fix stack.
+	  }
+#	  undef PushMacReg
+#	endif /* THINK_C */
+#	if defined(__MWERKS__)
+	  PushMacRegisters();
+#	endif	/* __MWERKS__ */
+#   endif	/* MACOS */
+
+#       if defined(I386) &&!defined(OS2) &&!defined(SVR4) &&!defined(MSWIN32) && !defined(SCO) && (!defined(LINUX) || !defined(__ELF__))
+	/* I386 code, generic code does not appear to work */
+	/* It does appear to work under OS2, and asms dont */
+	/* This is used for some 38g UNIX variants and for CYGWIN32 */
+	  asm("pushl %eax");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ecx");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edx");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebp");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %esi");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edi");  asm("call _GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebx");  asm("call _GC_push_one"); asm("addl $4,%esp");
+#       endif
+
+#	if defined(I386) && defined(LINUX) && defined(__ELF__)
+	/* This is modified for Linux with ELF (Note: _ELF_ only) */
+	  asm("pushl %eax");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ecx");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edx");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebp");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %esi");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edi");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebx");  asm("call GC_push_one"); asm("addl $4,%esp");
+#	endif
+
+#       if defined(I386) && defined(MSWIN32) && !defined(USE_GENERIC)
+	/* I386 code, Microsoft variant		*/
+	  __asm  push eax
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push ebx
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push ecx
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push edx
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push ebp
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push esi
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+	  __asm  push edi
+	  __asm  call GC_push_one
+	  __asm  add esp,4
+#       endif
+
+#       if defined(I386) && (defined(SVR4) || defined(SCO))
+	/* I386 code, SVR4 variant, generic code does not appear to work */
+	  asm("pushl %eax");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebx");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ecx");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edx");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %ebp");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %esi");  asm("call GC_push_one"); asm("addl $4,%esp");
+	  asm("pushl %edi");  asm("call GC_push_one"); asm("addl $4,%esp");
+#       endif
+
+#       ifdef NS32K
+	  asm ("movd r3, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
+	  asm ("movd r4, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
+	  asm ("movd r5, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
+	  asm ("movd r6, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
+	  asm ("movd r7, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
+#       endif
+
+#       ifdef SPARC
+	  {
+	      word GC_save_regs_in_stack();
+	      
+	      /* generic code will not work */
+	      (void)GC_save_regs_in_stack();
+	  }
+#       endif
+
+#	ifdef RT
+	    GC_push_one(TMP_SP);    /* GC_push_one from r11 */
+
+	    asm("cas r11, r6, r0"); GC_push_one(TMP_SP);	/* r6 */
+	    asm("cas r11, r7, r0"); GC_push_one(TMP_SP);	/* through */
+	    asm("cas r11, r8, r0"); GC_push_one(TMP_SP);	/* r10 */
+	    asm("cas r11, r9, r0"); GC_push_one(TMP_SP);
+	    asm("cas r11, r10, r0"); GC_push_one(TMP_SP);
+
+	    asm("cas r11, r12, r0"); GC_push_one(TMP_SP); /* r12 */
+	    asm("cas r11, r13, r0"); GC_push_one(TMP_SP); /* through */
+	    asm("cas r11, r14, r0"); GC_push_one(TMP_SP); /* r15 */
+	    asm("cas r11, r15, r0"); GC_push_one(TMP_SP);
+#       endif
+
+#       if defined(M68K) && defined(SYSV)
+  	/*  Once again similar to SUN and HP, though setjmp appears to work.
+  		--Parag
+  	 */
+#        ifdef __GNUC__
+  	  asm("subqw #0x4,%sp");	/* allocate word on top of stack */
+  
+  	  asm("movl %a2,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %a3,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %a4,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %a5,%sp@");	asm("jbsr GC_push_one");
+  	  /* Skip frame pointer and stack pointer */
+  	  asm("movl %d1,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d2,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d3,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d4,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d5,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d6,%sp@");	asm("jbsr GC_push_one");
+  	  asm("movl %d7,%sp@");	asm("jbsr GC_push_one");
+  
+  	  asm("addqw #0x4,%sp");	/* put stack back where it was	*/
+#        else /* !__GNUC__*/
+  	  asm("subq.w &0x4,%sp");	/* allocate word on top of stack */
+  
+  	  asm("mov.l %a2,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %a3,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %a4,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %a5,(%sp)"); asm("jsr GC_push_one");
+  	  /* Skip frame pointer and stack pointer */
+  	  asm("mov.l %d1,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %d2,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %d3,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %d4,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %d5,(%sp)"); asm("jsr GC_push_one");
+   	  asm("mov.l %d6,(%sp)"); asm("jsr GC_push_one");
+  	  asm("mov.l %d7,(%sp)"); asm("jsr GC_push_one");
+  
+  	  asm("addq.w &0x4,%sp");	/* put stack back where it was	*/
+#        endif /* !__GNUC__ */
+#       endif /* M68K/SYSV */
+
+/* MATTHEW: Add RS6000 to this list for using generic: */
+#     if defined(HP_PA) || defined(M88K) || defined(POWERPC) || (defined(I386) && (defined(OS2) || defined(USE_GENERIC))) || defined(UTS4) || defined(RS6000)
+	/* Generic code                          */
+	/* The idea is due to Parag Patel at HP. */
+	/* We're not sure whether he would like  */
+	/* to be he acknowledged for it or not.  */
+	{
+	    static jmp_buf regs;
+	    register word * i = (word *) regs;
+	    register ptr_t lim = (ptr_t)(regs) + (sizeof regs);
+
+	    /* Setjmp on Sun 3s doesn't clear all of the buffer.  */
+	    /* That tends to preserve garbage.  Clear it.         */
+		for (; (char *)i < lim; i++) {
+		    *i = 0;
+		}
+#	    if defined(POWERPC) || defined(MSWIN32)
+		(void) setjmp(regs);
+#	    else
+	        (void) _setjmp(regs);
+#	    endif
+	    GC_push_all_stack((ptr_t)regs, lim);
+	}
+#     endif
+
+      /* other machines... */
+#       if !(defined M68K) && !(defined VAX) && !(defined RT) 
+#	if !(defined SPARC) && !(defined I386) && !(defined NS32K)
+#	if !defined(HP_PA) && !defined(M88K) && !defined(POWERPC)
+#	if !defined(UTS4)
+/* MATTHEW: RS6000 ok */
+#       if !defined(RS6000) 
+	    --> bad news <--
+#       endif
+# 	endif
+#       endif
+#       endif
+#       endif
+}
+
+/* On register window machines, we need a way to force registers into 	*/
+/* the stack.	Return sp.						*/
+# ifdef SPARC
+    asm("	.seg 	\"text\"");
+#   ifdef SVR4
+      asm("	.globl	GC_save_regs_in_stack");
+      asm("GC_save_regs_in_stack:");
+      asm("	.type GC_save_regs_in_stack,#function");
+#   else
+      asm("	.globl	_GC_save_regs_in_stack");
+      asm("_GC_save_regs_in_stack:");
+#   endif
+    asm("	ta	0x3   ! ST_FLUSH_WINDOWS");
+    asm("	mov	%sp,%o0");
+    asm("	retl");
+    asm("	nop");
+#   ifdef SVR4
+      asm("	.GC_save_regs_in_stack_end:");
+      asm("	.size GC_save_regs_in_stack,.GC_save_regs_in_stack_end-GC_save_regs_in_stack");
+#   endif
+#   ifdef LINT
+	word GC_save_regs_in_stack() { return(0 /* sp really */);}
+#   endif
+# endif
+
+
+/* GC_clear_stack_inner(arg, limit) clears stack area up to limit and	*/
+/* returns arg.  Stack clearing is crucial on SPARC, so we supply	*/
+/* an assembly version that's more careful.  Assumes limit is hotter	*/
+/* than sp, and limit is 8 byte aligned.				*/
+#if defined(ASM_CLEAR_CODE) && !defined(THREADS)
+#ifndef SPARC
+	--> fix it
+#endif
+# ifdef SUNOS4
+    asm(".globl _GC_clear_stack_inner");
+    asm("_GC_clear_stack_inner:");
+# else
+    asm(".globl GC_clear_stack_inner");
+    asm("GC_clear_stack_inner:");
+    asm(".type GC_save_regs_in_stack,#function");
+# endif
+  asm("mov %sp,%o2");		/* Save sp	*/
+  asm("add %sp,-8,%o3");	/* p = sp-8	*/
+  asm("clr %g1");		/* [g0,g1] = 0	*/
+  asm("add %o1,-0x60,%sp");	/* Move sp out of the way,	*/
+  				/* so that traps still work.	*/
+  				/* Includes some extra words	*/
+  				/* so we can be sloppy below.	*/
+  asm("loop:");
+  asm("std %g0,[%o3]");		/* *(long long *)p = 0	*/
+  asm("cmp %o3,%o1");
+  asm("bgu loop	");		/* if (p > limit) goto loop	*/
+    asm("add %o3,-8,%o3");	/* p -= 8 (delay slot) */
+  asm("retl");
+    asm("mov %o2,%sp");		/* Restore sp., delay slot	*/
+  /* First argument = %o0 = return value */
+#   ifdef SVR4
+      asm("	.GC_clear_stack_inner_end:");
+      asm("	.size GC_clear_stack_inner,.GC_clear_stack_inner_end-GC_clear_stack_inner");
+#   endif
+  
+# ifdef LINT
+    /*ARGSUSED*/
+    ptr_t GC_clear_stack_inner(arg, limit)
+    ptr_t arg; word limit;
+    { return(arg); }
+# endif
+#endif  
diff --git a/src/mzscheme/gc/makefile.depend b/src/mzscheme/gc/makefile.depend
new file mode 100644
index 0000000..e69de29
diff --git a/src/mzscheme/gc/malloc.c b/src/mzscheme/gc/malloc.c
new file mode 100644
index 0000000..1596e05
--- /dev/null
+++ b/src/mzscheme/gc/malloc.c
@@ -0,0 +1,419 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 7, 1996 4:32 pm PST */
+ 
+#include <stdio.h>
+#include "gc_priv.h"
+
+extern ptr_t GC_clear_stack();	/* in misc.c, behaves like identity */
+void GC_extend_size_map();	/* in misc.c. */
+
+/* Allocate reclaim list for kind:	*/
+/* Return TRUE on success		*/
+bool GC_alloc_reclaim_list(kind)
+register struct obj_kind * kind;
+{
+    struct hblk ** result = (struct hblk **)
+    		GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
+    if (result == 0) return(FALSE);
+    BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
+    kind -> ok_reclaim_list = result;
+    return(TRUE);
+}
+
+/* allocate lb bytes for an object of kind.	*/
+/* Should not be used to directly to allocate	*/
+/* objects such as STUBBORN objects that	*/
+/* require special handling on allocation.	*/
+/* First a version that assumes we already	*/
+/* hold lock:					*/
+ptr_t GC_generic_malloc_inner(lb, k)
+register word lb;
+register int k;
+{
+register word lw;
+register ptr_t op;
+register ptr_t *opp;
+
+    if( SMALL_OBJ(lb) ) {
+        register struct obj_kind * kind = GC_obj_kinds + k;
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+	  if (lw == 0) lw = 1;
+#       endif
+	opp = &(kind -> ok_freelist[lw]);
+        if( (op = *opp) == 0 ) {
+#	    ifdef MERGE_SIZES
+	      if (GC_size_map[lb] == 0) {
+	        if (!GC_is_initialized)  GC_init_inner();
+	        if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
+	        return(GC_generic_malloc_inner(lb, k));
+	      }
+#	    else
+	      if (!GC_is_initialized) {
+	        GC_init_inner();
+	        return(GC_generic_malloc_inner(lb, k));
+	      }
+#	    endif
+	    if (kind -> ok_reclaim_list == 0) {
+	    	if (!GC_alloc_reclaim_list(kind)) goto out;
+	    }
+	    op = GC_allocobj(lw, k);
+	    if (op == 0) goto out;
+        }
+        /* Here everything is in a consistent state.	*/
+        /* We assume the following assignment is	*/
+        /* atomic.  If we get aborted			*/
+        /* after the assignment, we lose an object,	*/
+        /* but that's benign.				*/
+        /* Volatile declarations may need to be added	*/
+        /* to prevent the compiler from breaking things.*/
+        *opp = obj_link(op);
+        obj_link(op) = 0;
+    } else {
+	register struct hblk * h;
+	register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
+					   + HDR_BYTES + HBLKSIZE-1);
+	
+	if (!GC_is_initialized) GC_init_inner();
+	/* Do our share of marking work */
+          if(GC_incremental && !GC_dont_gc)
+		GC_collect_a_little_inner((int)n_blocks);
+	lw = ROUNDED_UP_WORDS(lb);
+	while ((h = GC_allochblk(lw, k, 0)) == 0
+		&& GC_collect_or_expand(n_blocks, FALSE));
+	if (h == 0) {
+	    op = 0;
+	} else {
+	    op = (ptr_t) (h -> hb_body);
+	    GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
+	}
+    }
+    GC_words_allocd += lw;
+    
+out:
+    return((ptr_t)op);
+}
+
+ptr_t GC_generic_malloc(lb, k)
+register word lb;
+register int k;
+{
+    ptr_t result;
+    DCL_LOCK_STATE;
+
+    GC_invoke_finalizers();
+    DISABLE_SIGNALS();
+    LOCK();
+    result = GC_generic_malloc_inner(lb, k);
+    UNLOCK();
+    ENABLE_SIGNALS();
+    if (0 == result) {
+        return((*GC_oom_fn)(lb));
+    } else {
+        return(result);
+    }
+}   
+
+
+#define GENERAL_MALLOC(lb,k) \
+    (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
+/* We make the GC_clear_stack_call a tail call, hoping to get more of	*/
+/* the stack.								*/
+
+/* Allocate lb bytes of atomic (pointerfree) data */
+# ifdef __STDC__
+    GC_PTR GC_malloc_atomic(size_t lb)
+# else
+    GC_PTR GC_malloc_atomic(lb)
+    size_t lb;
+# endif
+{
+register ptr_t op;
+register ptr_t * opp;
+register word lw;
+DCL_LOCK_STATE;
+
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_aobjfreelist[lw]);
+	FASTLOCK();
+        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
+            FASTUNLOCK();
+            return(GENERAL_MALLOC((word)lb, PTRFREE));
+        }
+        /* See above comment on signals.	*/
+        *opp = obj_link(op);
+        GC_words_allocd += lw;
+        FASTUNLOCK();
+        return((GC_PTR) op);
+   } else {
+       return(GENERAL_MALLOC((word)lb, PTRFREE));
+   }
+}
+
+/* Allocate lb bytes of composite (pointerful) data */
+# ifdef __STDC__
+    GC_PTR GC_malloc(size_t lb)
+# else
+    GC_PTR GC_malloc(lb)
+    size_t lb;
+# endif
+{
+register ptr_t op;
+register ptr_t *opp;
+register word lw;
+DCL_LOCK_STATE;
+
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_objfreelist[lw]);
+	FASTLOCK();
+        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
+            FASTUNLOCK();
+            return(GENERAL_MALLOC((word)lb, NORMAL));
+        }
+        /* See above comment on signals.	*/
+        *opp = obj_link(op);
+        obj_link(op) = 0;
+        GC_words_allocd += lw;
+        FASTUNLOCK();
+        return((GC_PTR) op);
+   } else {
+       return(GENERAL_MALLOC((word)lb, NORMAL));
+   }
+}
+
+# ifdef REDIRECT_MALLOC
+# ifdef __STDC__
+    GC_PTR malloc(size_t lb)
+# else
+    GC_PTR malloc(lb)
+    size_t lb;
+# endif
+  {
+    /* It might help to manually inline the GC_malloc call here.	*/
+    /* But any decent compiler should reduce the extra procedure call	*/
+    /* to at most a jump instruction in this case.			*/
+    return(REDIRECT_MALLOC(lb));
+  }
+
+# ifdef __STDC__
+    GC_PTR calloc(size_t n, size_t lb)
+# else
+    GC_PTR calloc(n, lb)
+    size_t n, lb;
+# endif
+  {
+    return(REDIRECT_MALLOC(n*lb));
+  }
+# endif /* REDIRECT_MALLOC */
+
+GC_PTR GC_generic_or_special_malloc(lb,knd)
+word lb;
+int knd;
+{
+    switch(knd) {
+#     ifdef STUBBORN_ALLOC
+	case STUBBORN:
+	    return(GC_malloc_stubborn((size_t)lb));
+#     endif
+	case PTRFREE:
+	    return(GC_malloc_atomic((size_t)lb));
+	case NORMAL:
+	    return(GC_malloc((size_t)lb));
+	case UNCOLLECTABLE:
+	    return(GC_malloc_uncollectable((size_t)lb));
+#       ifdef ATOMIC_UNCOLLECTABLE
+	  case AUNCOLLECTABLE:
+	    return(GC_malloc_atomic_uncollectable((size_t)lb));
+#	endif /* ATOMIC_UNCOLLECTABLE */
+	default:
+	    return(GC_generic_malloc(lb,knd));
+    }
+}
+
+
+/* Change the size of the block pointed to by p to contain at least   */
+/* lb bytes.  The object may be (and quite likely will be) moved.     */
+/* The kind (e.g. atomic) is the same as that of the old.	      */
+/* Shrinking of large blocks is not implemented well.                 */
+# ifdef __STDC__
+    GC_PTR GC_realloc(GC_PTR p, size_t lb)
+# else
+    GC_PTR GC_realloc(p,lb)
+    GC_PTR p;
+    size_t lb;
+# endif
+{
+register struct hblk * h;
+register hdr * hhdr;
+register word sz;	 /* Current size in bytes	*/
+register word orig_sz;	 /* Original sz in bytes	*/
+int obj_kind;
+
+    if (p == 0) return(GC_malloc(lb));	/* Required by ANSI */
+    h = HBLKPTR(p);
+    hhdr = HDR(h);
+    sz = hhdr -> hb_sz;
+    obj_kind = hhdr -> hb_obj_kind;
+    sz = WORDS_TO_BYTES(sz);
+    orig_sz = sz;
+
+    if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
+	/* Round it up to the next whole heap block */
+	  register word descr;
+	  
+	  sz = (sz+HDR_BYTES+HBLKSIZE-1)
+		& (~HBLKMASK);
+	  sz -= HDR_BYTES;
+	  hhdr -> hb_sz = BYTES_TO_WORDS(sz);
+	  descr = GC_obj_kinds[obj_kind].ok_descriptor;
+          if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
+          hhdr -> hb_descr = descr;
+	  if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
+	  /* Extra area is already cleared by allochblk. */
+    }
+    if (ADD_SLOP(lb) <= sz) {
+	if (lb >= (sz >> 1)) {
+#	    ifdef STUBBORN_ALLOC
+	        if (obj_kind == STUBBORN) GC_change_stubborn(p);
+#	    endif
+	    if (orig_sz > lb) {
+	      /* Clear unneeded part of object to avoid bogus pointer */
+	      /* tracing.					      */
+	      /* Safe for stubborn objects.			      */
+	        BZERO(((ptr_t)p) + lb, orig_sz - lb);
+	    }
+	    return(p);
+	} else {
+	    /* shrink */
+	      GC_PTR result =
+	      		GC_generic_or_special_malloc((word)lb, obj_kind);
+
+	      if (result == 0) return(0);
+	          /* Could also return original object.  But this 	*/
+	          /* gives the client warning of imminent disaster.	*/
+	      BCOPY(p, result, lb);
+#	      ifndef IGNORE_FREE
+	        GC_free(p);
+#	      endif
+	      return(result);
+	}
+    } else {
+	/* grow */
+	  GC_PTR result =
+	  	GC_generic_or_special_malloc((word)lb, obj_kind);
+
+	  if (result == 0) return(0);
+	  BCOPY(p, result, sz);
+#	  ifndef IGNORE_FREE
+	    GC_free(p);
+#	  endif
+	  return(result);
+    }
+}
+
+# ifdef REDIRECT_MALLOC
+# ifdef __STDC__
+    GC_PTR realloc(GC_PTR p, size_t lb)
+# else
+    GC_PTR realloc(p,lb)
+    GC_PTR p;
+    size_t lb;
+# endif
+  {
+    return(GC_realloc(p, lb));
+  }
+# endif /* REDIRECT_MALLOC */
+
+/* Explicitly deallocate an object p.				*/
+# ifdef __STDC__
+    void GC_free(GC_PTR p)
+# else
+    void GC_free(p)
+    GC_PTR p;
+# endif
+{
+    register struct hblk *h;
+    register hdr *hhdr;
+    register signed_word sz;
+    register ptr_t * flh;
+    register int knd;
+    register struct obj_kind * ok;
+    DCL_LOCK_STATE;
+
+    if (p == 0) return;
+    	/* Required by ANSI.  It's not my fault ...	*/
+    h = HBLKPTR(p);
+    hhdr = HDR(h);
+    knd = hhdr -> hb_obj_kind;
+    sz = hhdr -> hb_sz;
+    ok = &GC_obj_kinds[knd];
+    if (sz <= MAXOBJSZ) {
+#	ifdef THREADS
+	    DISABLE_SIGNALS();
+	    LOCK();
+#	endif
+	GC_mem_freed += sz;
+	/* A signal here can make GC_mem_freed and GC_non_gc_bytes	*/
+	/* inconsistent.  We claim this is benign.			*/
+	if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+		/* Its unnecessary to clear the mark bit.  If the 	*/
+		/* object is reallocated, it doesn't matter.  O.w. the	*/
+		/* collector will do it, since it's on a free list.	*/
+	if (ok -> ok_init) {
+	    BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
+	}
+	flh = &(ok -> ok_freelist[sz]);
+	obj_link(p) = *flh;
+	*flh = (ptr_t)p;
+#	ifdef THREADS
+	    UNLOCK();
+	    ENABLE_SIGNALS();
+#	endif
+    } else {
+    	DISABLE_SIGNALS();
+        LOCK();
+        GC_mem_freed += sz;
+	if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+        GC_freehblk(h);
+        UNLOCK();
+        ENABLE_SIGNALS();
+    }
+}
+
+# ifdef REDIRECT_MALLOC
+#   ifdef __STDC__
+      void free(GC_PTR p)
+#   else
+      void free(p)
+      GC_PTR p;
+#   endif
+  {
+#   ifndef IGNORE_FREE
+      GC_free(p);
+#   endif
+  }
+# endif  /* REDIRECT_MALLOC */
diff --git a/src/mzscheme/gc/mallocx.c b/src/mzscheme/gc/mallocx.c
new file mode 100644
index 0000000..6d1d5d1
--- /dev/null
+++ b/src/mzscheme/gc/mallocx.c
@@ -0,0 +1,366 @@
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * These are extra allocation routines which are likely to be less
+ * frequently used than those in malloc.c.  They are separate in the
+ * hope that the .o file will be excluded from statically linked
+ * executables.  We should probably break this up further.
+ */
+
+#include <stdio.h>
+#include "gc_priv.h"
+
+extern ptr_t GC_clear_stack();  /* in misc.c, behaves like identity */
+void GC_extend_size_map();      /* in misc.c. */
+
+/* Some externally visible but unadvertised variables to allow access to */
+/* free lists from inlined allocators without including gc_priv.h	 */
+/* or introducing dependencies on internal data structure layouts.	 */
+ptr_t * CONST GC_objfreelist_ptr = GC_objfreelist;
+ptr_t * CONST GC_aobjfreelist_ptr = GC_aobjfreelist;
+ptr_t * CONST GC_uobjfreelist_ptr = GC_uobjfreelist;
+# ifdef ATOMIC_UNCOLLECTABLE
+    ptr_t * CONST GC_auobjfreelist_ptr = GC_auobjfreelist;
+# endif
+
+/* Allocate a composite object of size n bytes.  The caller guarantees  */
+/* that pointers past the first page are not relevant.  Caller holds    */
+/* allocation lock.                                                     */
+ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
+register size_t lb;
+register int k;
+{
+    register struct hblk * h;
+    register word n_blocks;
+    register word lw;
+    register ptr_t op;
+
+    if (lb <= HBLKSIZE)
+        return(GC_generic_malloc_inner((word)lb, k));
+    n_blocks = divHBLKSZ(ADD_SLOP(lb) + HDR_BYTES + HBLKSIZE-1);
+    if (!GC_is_initialized) GC_init_inner();
+    /* Do our share of marking work */
+    if(GC_incremental && !GC_dont_gc)
+        GC_collect_a_little_inner((int)n_blocks);
+    lw = ROUNDED_UP_WORDS(lb);
+    while ((h = GC_allochblk(lw, k, IGNORE_OFF_PAGE)) == 0
+           && GC_collect_or_expand(n_blocks, TRUE));
+    if (h == 0) {
+        op = 0;
+    } else {
+        op = (ptr_t) (h -> hb_body);
+        GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
+    }
+    GC_words_allocd += lw;
+    return((ptr_t)op);
+}
+
+ptr_t GC_generic_malloc_ignore_off_page(lb, k)
+register size_t lb;
+register int k;
+{
+    register ptr_t result;
+    DCL_LOCK_STATE;
+    
+    GC_invoke_finalizers();
+    DISABLE_SIGNALS();
+    LOCK();
+    result = GC_generic_malloc_inner_ignore_off_page(lb,k);
+    UNLOCK();
+    ENABLE_SIGNALS();
+    if (0 == result) {
+        return((*GC_oom_fn)(lb));
+    } else {
+        return(result);
+    }
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+  void * GC_malloc_ignore_off_page(size_t lb)
+# else
+  char * GC_malloc_ignore_off_page(lb)
+  register size_t lb;
+# endif
+{
+    return((GC_PTR)GC_generic_malloc_ignore_off_page(lb, NORMAL));
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+  void * GC_malloc_atomic_ignore_off_page(size_t lb)
+# else
+  char * GC_malloc_atomic_ignore_off_page(lb)
+  register size_t lb;
+# endif
+{
+    return((GC_PTR)GC_generic_malloc_ignore_off_page(lb, PTRFREE));
+}
+
+/* Increment GC_words_allocd from code that doesn't have direct access 	*/
+/* to GC_arrays.							*/
+# ifdef __STDC__
+void GC_incr_words_allocd(size_t n)
+{
+    GC_words_allocd += n;
+}
+
+/* The same for GC_mem_freed.				*/
+void GC_incr_mem_freed(size_t n)
+{
+    GC_mem_freed += n;
+}
+# endif /* __STDC__ */
+
+/* Analogous to the above, but assumes a small object size, and 	*/
+/* bypasses MERGE_SIZES mechanism.  Used by gc_inline.h.		*/
+#ifdef __STDC__
+     ptr_t GC_generic_malloc_words_small(size_t lw, int k)
+#else 
+     ptr_t GC_generic_malloc_words_small(lw, k)
+     register size_t lw;
+     register int k;
+#endif
+{
+register ptr_t op;
+register ptr_t *opp;
+register struct obj_kind * kind = GC_obj_kinds + k;
+DCL_LOCK_STATE;
+
+    GC_invoke_finalizers();
+    DISABLE_SIGNALS();
+    LOCK();
+    opp = &(kind -> ok_freelist[lw]);
+    if( (op = *opp) == 0 ) {
+        if (!GC_is_initialized) {
+            GC_init_inner();
+        }
+	if (kind -> ok_reclaim_list != 0 || GC_alloc_reclaim_list(kind)) {
+	    op = GC_clear_stack(GC_allocobj(lw, k));
+	}
+	if (op == 0) {
+	    UNLOCK();
+	    ENABLE_SIGNALS();
+	    return ((*GC_oom_fn)(WORDS_TO_BYTES(lw)));
+	}
+    }
+    *opp = obj_link(op);
+    obj_link(op) = 0;
+    GC_words_allocd += lw;
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return((ptr_t)op);
+}
+
+#if defined(THREADS) && !defined(SRC_M3)
+/* Return a list of 1 or more objects of the indicated size, linked	*/
+/* through the first word in the object.  This has the advantage that	*/
+/* it acquires the allocation lock only once, and may greatly reduce	*/
+/* time wasted contending for the allocation lock.  Typical usage would */
+/* be in a thread that requires many items of the same size.  It would	*/
+/* keep its own free list in thread-local storage, and call		*/
+/* GC_malloc_many or friends to replenish it.  (We do not round up	*/
+/* object sizes, since a call indicates the intention to consume many	*/
+/* objects of exactly this size.)					*/
+/* Note that the client should usually clear the link field.		*/
+ptr_t GC_generic_malloc_many(lb, k)
+register word lb;
+register int k;
+{
+ptr_t op;
+register ptr_t p;
+ptr_t *opp;
+word lw;
+register word my_words_allocd;
+DCL_LOCK_STATE;
+
+    if (!SMALL_OBJ(lb)) {
+        op = GC_generic_malloc(lb, k);
+        if(0 != op) obj_link(op) = 0;
+        return(op);
+    }
+    lw = ALIGNED_WORDS(lb);
+    GC_invoke_finalizers();
+    DISABLE_SIGNALS();
+    LOCK();
+    opp = &(GC_obj_kinds[k].ok_freelist[lw]);
+    if( (op = *opp) == 0 ) {
+        if (!GC_is_initialized) {
+            GC_init_inner();
+        }
+	op = GC_clear_stack(GC_allocobj(lw, k));
+	if (op == 0) {
+	    UNLOCK();
+	    ENABLE_SIGNALS();
+	    op = (*GC_oom_fn)(lb);
+	    if(0 != op) obj_link(op) = 0;
+            return(op);
+	}
+    }
+    *opp = 0;
+    my_words_allocd = 0;
+    for (p = op; p != 0; p = obj_link(p)) {
+        my_words_allocd += lw;
+        if (my_words_allocd >= BODY_SZ) {
+            *opp = obj_link(p);
+            obj_link(p) = 0;
+            break;
+        }
+    }
+    GC_words_allocd += my_words_allocd;
+    
+out:
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return(op);
+
+}
+
+void * GC_malloc_many(size_t lb)
+{
+    return(GC_generic_malloc_many(lb, NORMAL));
+}
+
+/* Note that the "atomic" version of this would be unsafe, since the	*/
+/* links would not be seen by the collector.				*/
+# endif
+
+/* Allocate lb bytes of pointerful, traced, but not collectable data */
+# ifdef __STDC__
+    GC_PTR GC_malloc_uncollectable(size_t lb)
+# else
+    GC_PTR GC_malloc_uncollectable(lb)
+    size_t lb;
+# endif
+{
+register ptr_t op;
+register ptr_t *opp;
+register word lw;
+DCL_LOCK_STATE;
+
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+#	  ifdef ADD_BYTE_AT_END
+	    if (lb != 0) lb--;
+	    	  /* We don't need the extra byte, since this won't be	*/
+	    	  /* collected anyway.					*/
+#	  endif
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_uobjfreelist[lw]);
+	FASTLOCK();
+        if( FASTLOCK_SUCCEEDED() && (op = *opp) != 0 ) {
+            /* See above comment on signals.	*/
+            *opp = obj_link(op);
+            obj_link(op) = 0;
+            GC_words_allocd += lw;
+            /* Mark bit ws already set on free list.  It will be	*/
+	    /* cleared only temporarily during a collection, as a 	*/
+	    /* result of the normal free list mark bit clearing.	*/
+            GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+            FASTUNLOCK();
+            return((GC_PTR) op);
+        }
+        FASTUNLOCK();
+        op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
+    } else {
+	op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
+    }
+    if (0 == op) return(0);
+    /* We don't need the lock here, since we have an undisguised 	*/
+    /* pointer.  We do need to hold the lock while we adjust		*/
+    /* mark bits.							*/
+    {
+	register struct hblk * h;
+	
+	h = HBLKPTR(op);
+	lw = HDR(h) -> hb_sz;
+	
+	DISABLE_SIGNALS();
+	LOCK();
+	GC_set_mark_bit(op);
+	GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+	UNLOCK();
+	ENABLE_SIGNALS();
+	return((GC_PTR) op);
+    }
+}
+
+# ifdef ATOMIC_UNCOLLECTABLE
+/* Allocate lb bytes of pointerfree, untraced, uncollectable data 	*/
+/* This is normally roughly equivalent to the system malloc.		*/
+/* But it may be useful if malloc is redefined.				*/
+# ifdef __STDC__
+    GC_PTR GC_malloc_atomic_uncollectable(size_t lb)
+# else
+    GC_PTR GC_malloc_atomic_uncollectable(lb)
+    size_t lb;
+# endif
+{
+register ptr_t op;
+register ptr_t *opp;
+register word lw;
+DCL_LOCK_STATE;
+
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+#	  ifdef ADD_BYTE_AT_END
+	    if (lb != 0) lb--;
+	    	  /* We don't need the extra byte, since this won't be	*/
+	    	  /* collected anyway.					*/
+#	  endif
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_auobjfreelist[lw]);
+	FASTLOCK();
+        if( FASTLOCK_SUCCEEDED() && (op = *opp) != 0 ) {
+            /* See above comment on signals.	*/
+            *opp = obj_link(op);
+            obj_link(op) = 0;
+            GC_words_allocd += lw;
+	    /* Mark bit was already set while object was on free list. */
+            GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+            FASTUNLOCK();
+            return((GC_PTR) op);
+        }
+        FASTUNLOCK();
+        op = (ptr_t)GC_generic_malloc((word)lb, AUNCOLLECTABLE);
+    } else {
+	op = (ptr_t)GC_generic_malloc((word)lb, AUNCOLLECTABLE);
+    }
+    if (0 == op) return(0);
+    /* We don't need the lock here, since we have an undisguised 	*/
+    /* pointer.  We do need to hold the lock while we adjust		*/
+    /* mark bits.							*/
+    {
+	register struct hblk * h;
+	
+	h = HBLKPTR(op);
+	lw = HDR(h) -> hb_sz;
+	
+	DISABLE_SIGNALS();
+	LOCK();
+	GC_set_mark_bit(op);
+	GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+	UNLOCK();
+	ENABLE_SIGNALS();
+	return((GC_PTR) op);
+    }
+}
+
+#endif /* ATOMIC_UNCOLLECTABLE */
diff --git a/src/mzscheme/gc/mark.c b/src/mzscheme/gc/mark.c
new file mode 100644
index 0000000..32e3970
--- /dev/null
+++ b/src/mzscheme/gc/mark.c
@@ -0,0 +1,1069 @@
+
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+# include <stdio.h>
+# include "gc_priv.h"
+# include "gc_mark.h"
+
+/* We put this here to minimize the risk of inlining. */
+/*VARARGS*/
+void GC_noop() {}
+
+/* Single argument version, robust against whole program analysis. */
+void GC_noop1(x)
+word x;
+{
+    static VOLATILE word sink;
+
+    sink = x;
+}
+
+mark_proc GC_mark_procs[MAX_MARK_PROCS] = {0};
+word GC_n_mark_procs = 0;
+
+/* Initialize GC_obj_kinds properly and standard free lists properly.  	*/
+/* This must be done statically since they may be accessed before 	*/
+/* GC_init is called.							*/
+/* It's done here, since we need to deal with mark descriptors.		*/
+struct obj_kind GC_obj_kinds[MAXOBJKINDS] = {
+/* PTRFREE */ { &GC_aobjfreelist[0], 0 /* filled in dynamically */,
+		0 | DS_LENGTH, FALSE, FALSE },
+/* NORMAL  */ { &GC_objfreelist[0], 0,
+#		if defined(ADD_BYTE_AT_END) && ALIGNMENT > DS_TAGS
+		(word)(-ALIGNMENT) | DS_LENGTH,
+#		else
+		0 | DS_LENGTH,
+#		endif
+		TRUE /* add length to descr */, TRUE },
+/* UNCOLLECTABLE */
+	      { &GC_uobjfreelist[0], 0,
+		0 | DS_LENGTH, TRUE /* add length to descr */, TRUE },
+# ifdef ATOMIC_UNCOLLECTABLE
+   /* AUNCOLLECTABLE */
+	      { &GC_auobjfreelist[0], 0,
+		0 | DS_LENGTH, FALSE /* add length to descr */, FALSE },
+# endif
+# ifdef STUBBORN_ALLOC
+/*STUBBORN*/ { &GC_sobjfreelist[0], 0,
+		0 | DS_LENGTH, TRUE /* add length to descr */, TRUE },
+# endif
+};
+
+# ifdef ATOMIC_UNCOLLECTABLE
+#   ifdef STUBBORN_ALLOC
+      int GC_n_kinds = 5;
+#   else
+      int GC_n_kinds = 4;
+#   endif
+# else
+#   ifdef STUBBORN_ALLOC
+      int GC_n_kinds = 4;
+#   else
+      int GC_n_kinds = 3;
+#   endif
+# endif
+
+
+# define INITIAL_MARK_STACK_SIZE (1*HBLKSIZE)
+		/* INITIAL_MARK_STACK_SIZE * sizeof(mse) should be a 	*/
+		/* multiple of HBLKSIZE.				*/
+
+/*
+ * Limits of stack for GC_mark routine.
+ * All ranges between GC_mark_stack(incl.) and GC_mark_stack_top(incl.) still
+ * need to be marked from.
+ */
+
+word GC_n_rescuing_pages;	/* Number of dirty pages we marked from */
+				/* excludes ptrfree pages, etc.		*/
+
+mse * GC_mark_stack;
+
+word GC_mark_stack_size = 0;
+ 
+mse * GC_mark_stack_top;
+
+static struct hblk * scan_ptr;
+
+mark_state_t GC_mark_state = MS_NONE;
+
+bool GC_mark_stack_too_small = FALSE;
+
+bool GC_objects_are_marked = FALSE;	/* Are there collectable marked	*/
+					/* objects in the heap?		*/
+
+bool GC_collection_in_progress()
+{
+    return(GC_mark_state != MS_NONE);
+}
+
+/* clear all mark bits in the header */
+void GC_clear_hdr_marks(hhdr)
+register hdr * hhdr;
+{
+    BZERO(hhdr -> hb_marks, MARK_BITS_SZ*sizeof(word));
+}
+
+/* Set all mark bits in the header.  Used for uncollectable blocks. */
+void GC_set_hdr_marks(hhdr)
+register hdr * hhdr;
+{
+    register int i;
+
+    for (i = 0; i < MARK_BITS_SZ; ++i) {
+    	hhdr -> hb_marks[i] = ONES;
+    }
+}
+
+/*
+ * Clear all mark bits associated with block h.
+ */
+/*ARGSUSED*/
+static void clear_marks_for_block(h, dummy)
+struct hblk *h;
+word dummy;
+{
+    register hdr * hhdr = HDR(h);
+    
+    if (IS_UNCOLLECTABLE(hhdr -> hb_obj_kind)) return;
+        /* Mark bit for these is cleared only once the object is 	*/
+        /* explicitly deallocated.  This either frees the block, or	*/
+        /* the bit is cleared once the object is on the free list.	*/
+    GC_clear_hdr_marks(hhdr);
+}
+
+/* Slow but general routines for setting/clearing/asking about mark bits */
+void GC_set_mark_bit(p)
+ptr_t p;
+{
+    register struct hblk *h = HBLKPTR(p);
+    register hdr * hhdr = HDR(h);
+    register int word_no = (word *)p - (word *)h;
+    
+    set_mark_bit_from_hdr(hhdr, word_no);
+}
+
+void GC_clear_mark_bit(p)
+ptr_t p;
+{
+    register struct hblk *h = HBLKPTR(p);
+    register hdr * hhdr = HDR(h);
+    register int word_no = (word *)p - (word *)h;
+    
+    clear_mark_bit_from_hdr(hhdr, word_no);
+}
+
+bool GC_is_marked(p)
+ptr_t p;
+{
+    register struct hblk *h = HBLKPTR(p);
+    register hdr * hhdr = HDR(h);
+    register int word_no = (word *)p - (word *)h;
+    
+    return(mark_bit_from_hdr(hhdr, word_no));
+}
+
+
+/*
+ * Clear mark bits in all allocated heap blocks.  This invalidates
+ * the marker invariant, and sets GC_mark_state to reflect this.
+ * (This implicitly starts marking to reestablish the invariant.)
+ */
+void GC_clear_marks()
+{
+    GC_apply_to_all_blocks(clear_marks_for_block, (word)0);
+    GC_objects_are_marked = FALSE;
+    GC_mark_state = MS_INVALID;
+    scan_ptr = 0;
+#   ifdef GATHERSTATS
+	/* Counters reflect currently marked objects: reset here */
+        GC_composite_in_use = 0;
+        GC_atomic_in_use = 0;
+#   endif
+
+}
+
+/* Initiate a garbage collection.  Initiates a full collection if the	*/
+/* mark	state is invalid.						*/
+/*ARGSUSED*/
+void GC_initiate_gc()
+{
+    if (GC_dirty_maintained) GC_read_dirty();
+#   ifdef STUBBORN_ALLOC
+    	GC_read_changed();
+#   endif
+#   ifdef CHECKSUMS
+	{
+	    extern void GC_check_dirty();
+	    
+	    if (GC_dirty_maintained) GC_check_dirty();
+	}
+#   endif
+#   ifdef GATHERSTATS
+	GC_n_rescuing_pages = 0;
+#   endif
+    if (GC_mark_state == MS_NONE) {
+        GC_mark_state = MS_PUSH_RESCUERS;
+    } else if (GC_mark_state != MS_INVALID) {
+    	ABORT("unexpected state");
+    } /* else this is really a full collection, and mark	*/
+      /* bits are invalid.					*/
+    scan_ptr = 0;
+}
+
+
+static void alloc_mark_stack();
+
+/* Perform a small amount of marking.			*/
+/* We try to touch roughly a page of memory.		*/
+/* Return TRUE if we just finished a mark phase.	*/
+bool GC_mark_some()
+{
+    switch(GC_mark_state) {
+    	case MS_NONE:
+    	    return(FALSE);
+    	    
+    	case MS_PUSH_RESCUERS:
+    	    if (GC_mark_stack_top
+    	        >= GC_mark_stack + INITIAL_MARK_STACK_SIZE/4) {
+    	        GC_mark_from_mark_stack();
+    	        return(FALSE);
+    	    } else {
+    	        scan_ptr = GC_push_next_marked_dirty(scan_ptr);
+    	        if (scan_ptr == 0) {
+#		    ifdef PRINTSTATS
+			GC_printf1("Marked from %lu dirty pages\n",
+				   (unsigned long)GC_n_rescuing_pages);
+#		    endif
+    	    	    GC_push_roots(FALSE);
+    	    	    GC_objects_are_marked = TRUE;
+    	    	    if (GC_mark_state != MS_INVALID) {
+    	    	        GC_mark_state = MS_ROOTS_PUSHED;
+    	    	    }
+    	    	}
+    	    }
+    	    return(FALSE);
+    	
+    	case MS_PUSH_UNCOLLECTABLE:
+    	    if (GC_mark_stack_top
+    	        >= GC_mark_stack + INITIAL_MARK_STACK_SIZE/4) {
+    	        GC_mark_from_mark_stack();
+    	        return(FALSE);
+    	    } else {
+    	        scan_ptr = GC_push_next_marked_uncollectable(scan_ptr);
+    	        if (scan_ptr == 0) {
+    	    	    GC_push_roots(TRUE);
+    	    	    GC_objects_are_marked = TRUE;
+    	    	    if (GC_mark_state != MS_INVALID) {
+    	    	        GC_mark_state = MS_ROOTS_PUSHED;
+    	    	    }
+    	    	}
+    	    }
+    	    return(FALSE);
+    	
+    	case MS_ROOTS_PUSHED:
+    	    if (GC_mark_stack_top >= GC_mark_stack) {
+    	        GC_mark_from_mark_stack();
+    	        return(FALSE);
+    	    } else {
+    	        GC_mark_state = MS_NONE;
+    	        if (GC_mark_stack_too_small) {
+    	            alloc_mark_stack(2*GC_mark_stack_size);
+    	        }
+    	        return(TRUE);
+    	    }
+    	    
+    	case MS_INVALID:
+    	case MS_PARTIALLY_INVALID:
+	    if (!GC_objects_are_marked) {
+		GC_mark_state = MS_PUSH_UNCOLLECTABLE;
+		return(FALSE);
+	    }
+    	    if (GC_mark_stack_top >= GC_mark_stack) {
+    	        GC_mark_from_mark_stack();
+    	        return(FALSE);
+    	    }
+    	    if (scan_ptr == 0
+    	        && (GC_mark_state == MS_INVALID || GC_mark_stack_too_small)) {
+    	        alloc_mark_stack(2*GC_mark_stack_size);
+		GC_mark_state = MS_PARTIALLY_INVALID;
+    	    }
+    	    scan_ptr = GC_push_next_marked(scan_ptr);
+    	    if (scan_ptr == 0 && GC_mark_state == MS_PARTIALLY_INVALID) {
+    	    	GC_push_roots(TRUE);
+    	    	GC_objects_are_marked = TRUE;
+    	    	if (GC_mark_state != MS_INVALID) {
+    	    	    GC_mark_state = MS_ROOTS_PUSHED;
+    	    	}
+    	    }
+    	    return(FALSE);
+    	default:
+    	    ABORT("GC_mark_some: bad state");
+    	    return(FALSE);
+    }
+}
+
+
+bool GC_mark_stack_empty()
+{
+    return(GC_mark_stack_top < GC_mark_stack);
+}	
+
+#ifdef PROF_MARKER
+    word GC_prof_array[10];
+#   define PROF(n) GC_prof_array[n]++
+#else
+#   define PROF(n)
+#endif
+
+/* Given a pointer to someplace other than a small object page or the	*/
+/* first page of a large object, return a pointer either to the		*/
+/* start of the large object or NIL.					*/
+/* In the latter case black list the address current.			*/
+/* Returns NIL without black listing if current points to a block	*/
+/* with IGNORE_OFF_PAGE set.						*/
+/*ARGSUSED*/
+word GC_find_start(current, hhdr)
+register word current;
+register hdr * hhdr;
+{
+#   ifdef ALL_INTERIOR_POINTERS
+	if (hhdr != 0) {
+	    register word orig = current;
+	    
+	    current = (word)HBLKPTR(current) + HDR_BYTES;
+	    do {
+	      current = current - HBLKSIZE*(word)hhdr;
+	      hhdr = HDR(current);
+	    } while(IS_FORWARDING_ADDR_OR_NIL(hhdr));
+	    /* current points to the start of the large object */
+	    if (hhdr -> hb_flags & IGNORE_OFF_PAGE) return(0);
+	    if ((word *)orig - (word *)current
+	         >= (ptrdiff_t)(hhdr->hb_sz)) {
+	        /* Pointer past the end of the block */
+	        GC_ADD_TO_BLACK_LIST_NORMAL(orig);
+	        return(0);
+	    }
+	    return(current);
+	} else {
+	    GC_ADD_TO_BLACK_LIST_NORMAL(current);
+	    return(0);
+        }
+#   else
+        GC_ADD_TO_BLACK_LIST_NORMAL(current);
+        return(0);
+#   endif
+}
+
+void GC_invalidate_mark_state()
+{
+    GC_mark_state = MS_INVALID;
+    GC_mark_stack_top = GC_mark_stack-1;
+}
+
+mse * GC_signal_mark_stack_overflow(msp)
+mse * msp;
+{
+    GC_mark_state = MS_INVALID;
+#   ifdef PRINTSTATS
+	GC_printf1("Mark stack overflow; current size = %lu entries\n",
+	    	    GC_mark_stack_size);
+#    endif
+     return(msp-INITIAL_MARK_STACK_SIZE/8);
+}
+
+
+/*
+ * Mark objects pointed to by the regions described by
+ * mark stack entries between GC_mark_stack and GC_mark_stack_top,
+ * inclusive.  Assumes the upper limit of a mark stack entry
+ * is never 0.  A mark stack entry never has size 0.
+ * We try to traverse on the order of a hblk of memory before we return.
+ * Caller is responsible for calling this until the mark stack is empty.
+ */
+void GC_mark_from_mark_stack()
+{
+  mse * GC_mark_stack_reg = GC_mark_stack;
+  mse * GC_mark_stack_top_reg = GC_mark_stack_top;
+  mse * mark_stack_limit = &(GC_mark_stack[GC_mark_stack_size]);
+  int credit = HBLKSIZE;	/* Remaining credit for marking work	*/
+  register word * current_p;	/* Pointer to current candidate ptr.	*/
+  register word current;	/* Candidate pointer.			*/
+  register word * limit;	/* (Incl) limit of current candidate 	*/
+  				/* range				*/
+  register word descr;
+  register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+  register ptr_t least_ha = GC_least_plausible_heap_addr;
+# define SPLIT_RANGE_WORDS 128  /* Must be power of 2.		*/
+
+  GC_objects_are_marked = TRUE;
+# ifdef OS2 /* Use untweaked version to circumvent compiler problem */
+  while (GC_mark_stack_top_reg >= GC_mark_stack_reg && credit >= 0) {
+# else
+  while ((((ptr_t)GC_mark_stack_top_reg - (ptr_t)GC_mark_stack_reg) | credit)
+  	>= 0) {
+# endif
+    current_p = GC_mark_stack_top_reg -> mse_start;
+  retry:
+    descr = GC_mark_stack_top_reg -> mse_descr;
+    if (descr & ((~(WORDS_TO_BYTES(SPLIT_RANGE_WORDS) - 1)) | DS_TAGS)) {
+      word tag = descr & DS_TAGS;
+      
+      switch(tag) {
+        case DS_LENGTH:
+          /* Large length.					        */
+          /* Process part of the range to avoid pushing too much on the	*/
+          /* stack.							*/
+          GC_mark_stack_top_reg -> mse_start =
+         	limit = current_p + SPLIT_RANGE_WORDS-1;
+          GC_mark_stack_top_reg -> mse_descr -=
+          		WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1);
+          /* Make sure that pointers overlapping the two ranges are	*/
+          /* considered. 						*/
+          limit = (word *)((char *)limit + sizeof(word) - ALIGNMENT);
+          break;
+        case DS_BITMAP:
+          GC_mark_stack_top_reg--;
+          descr &= ~DS_TAGS;
+          credit -= WORDS_TO_BYTES(WORDSZ/2); /* guess */
+          while (descr != 0) {
+            if ((signed_word)descr < 0) {
+              current = *current_p++;
+              descr <<= 1;
+              if ((ptr_t)current < least_ha) continue;
+              if ((ptr_t)current >= greatest_ha) continue;
+              PUSH_CONTENTS(current, GC_mark_stack_top_reg, mark_stack_limit);
+            } else {
+              descr <<= 1;
+              current_p++;
+            }
+          }
+          continue;
+        case DS_PROC:
+          GC_mark_stack_top_reg--;
+          credit -= PROC_BYTES;
+          GC_mark_stack_top_reg =
+              (*PROC(descr))
+              	    (current_p, GC_mark_stack_top_reg,
+              	    mark_stack_limit, ENV(descr));
+          continue;
+        case DS_PER_OBJECT:
+          GC_mark_stack_top_reg -> mse_descr =
+			*(word *)((ptr_t)current_p + descr - tag);
+          goto retry;
+      }
+    } else {
+      GC_mark_stack_top_reg--;
+      limit = (word *)(((ptr_t)current_p) + (word)descr);
+    }
+    /* The simple case in which we're scanning a range.	*/
+    credit -= (ptr_t)limit - (ptr_t)current_p;
+    limit -= 1;
+    while (current_p <= limit) {
+      current = *current_p;
+      current_p = (word *)((char *)current_p + ALIGNMENT);
+      if ((ptr_t)current < least_ha) continue;
+      if ((ptr_t)current >= greatest_ha) continue;
+      PUSH_CONTENTS(current, GC_mark_stack_top_reg, mark_stack_limit);
+    }
+  }
+  GC_mark_stack_top = GC_mark_stack_top_reg;
+}
+
+/* Allocate or reallocate space for mark stack of size s words  */
+/* May silently fail.						*/
+static void alloc_mark_stack(n)
+word n;
+{
+    mse * new_stack = (mse *)GC_scratch_alloc(n * sizeof(struct ms_entry));
+    
+    GC_mark_stack_too_small = FALSE;
+    if (GC_mark_stack_size != 0) {
+        if (new_stack != 0) {
+          word displ = HBLKDISPL(GC_mark_stack);
+          word size = GC_mark_stack_size * sizeof(struct ms_entry);
+          
+          /* Recycle old space */
+            if (displ == 0) {
+              GC_add_to_heap((struct hblk *)GC_mark_stack, size);
+	    } else {
+	      GC_add_to_heap((struct hblk *)
+	      			((word)GC_mark_stack - displ + HBLKSIZE),
+	      		     size - HBLKSIZE);
+	    }
+          GC_mark_stack = new_stack;
+          GC_mark_stack_size = n;
+#	  ifdef PRINTSTATS
+	      GC_printf1("Grew mark stack to %lu frames\n",
+		    	 (unsigned long) GC_mark_stack_size);
+#	  endif
+        } else {
+#	  ifdef PRINTSTATS
+	      GC_printf1("Failed to grow mark stack to %lu frames\n",
+		    	 (unsigned long) n);
+#	  endif
+        }
+    } else {
+        if (new_stack == 0) {
+            GC_err_printf0("No space for mark stack\n");
+            EXIT();
+        }
+        GC_mark_stack = new_stack;
+        GC_mark_stack_size = n;
+    }
+    GC_mark_stack_top = GC_mark_stack-1;
+}
+
+void GC_mark_init()
+{
+    alloc_mark_stack(INITIAL_MARK_STACK_SIZE);
+}
+
+/*
+ * Push all locations between b and t onto the mark stack.
+ * b is the first location to be checked. t is one past the last
+ * location to be checked.
+ * Should only be used if there is no possibility of mark stack
+ * overflow.
+ */
+void GC_push_all(bottom, top)
+ptr_t bottom;
+ptr_t top;
+{
+    register word length;
+    
+    bottom = (ptr_t)(((word) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1));
+    top = (ptr_t)(((word) top) & ~(ALIGNMENT-1));
+    if (top == 0 || bottom == top) return;
+    GC_mark_stack_top++;
+    if (GC_mark_stack_top >= GC_mark_stack + GC_mark_stack_size) {
+	ABORT("unexpected mark stack overflow");
+    }
+    length = top - bottom;
+#   if DS_TAGS > ALIGNMENT - 1
+	length += DS_TAGS;
+	length &= ~DS_TAGS;
+#   endif
+    GC_mark_stack_top -> mse_start = (word *)bottom;
+    GC_mark_stack_top -> mse_descr = length;
+}
+
+/*
+ * Analogous to the above, but push only those pages that may have been
+ * dirtied.  A block h is assumed dirty if dirty_fn(h) != 0.
+ * We use push_fn to actually push the block.
+ * Will not overflow mark stack if push_fn pushes a small fixed number
+ * of entries.  (This is invoked only if push_fn pushes a single entry,
+ * or if it marks each object before pushing it, thus ensuring progress
+ * in the event of a stack overflow.)
+ */
+void GC_push_dirty(bottom, top, dirty_fn, push_fn)
+ptr_t bottom;
+ptr_t top;
+int (*dirty_fn)(/* struct hblk * h */);
+void (*push_fn)(/* ptr_t bottom, ptr_t top */);
+{
+    register struct hblk * h;
+
+    bottom = (ptr_t)(((long) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1));
+    top = (ptr_t)(((long) top) & ~(ALIGNMENT-1));
+
+    if (top == 0 || bottom == top) return;
+    h = HBLKPTR(bottom + HBLKSIZE);
+    if (top <= (ptr_t) h) {
+  	if ((*dirty_fn)(h-1)) {
+	    (*push_fn)(bottom, top);
+	}
+	return;
+    }
+    if ((*dirty_fn)(h-1)) {
+        (*push_fn)(bottom, (ptr_t)h);
+    }
+    while ((ptr_t)(h+1) <= top) {
+	if ((*dirty_fn)(h)) {
+	    if ((word)(GC_mark_stack_top - GC_mark_stack)
+		> 3 * GC_mark_stack_size / 4) {
+	 	/* Danger of mark stack overflow */
+		(*push_fn)((ptr_t)h, top);
+		return;
+	    } else {
+		(*push_fn)((ptr_t)h, (ptr_t)(h+1));
+	    }
+	}
+	h++;
+    }
+    if ((ptr_t)h != top) {
+	if ((*dirty_fn)(h)) {
+            (*push_fn)((ptr_t)h, top);
+        }
+    }
+    if (GC_mark_stack_top >= GC_mark_stack + GC_mark_stack_size) {
+        ABORT("unexpected mark stack overflow");
+    }
+}
+
+# ifndef SMALL_CONFIG
+void GC_push_conditional(bottom, top, all)
+ptr_t bottom;
+ptr_t top;
+{
+    if (all) {
+      if (GC_dirty_maintained) {
+#	ifdef PROC_VDB
+	    /* Pages that were never dirtied cannot contain pointers	*/
+	    GC_push_dirty(bottom, top, GC_page_was_ever_dirty, GC_push_all);
+#	else
+	    GC_push_all(bottom, top);
+#	endif
+      } else {
+      	GC_push_all(bottom, top);
+      }
+    } else {
+	GC_push_dirty(bottom, top, GC_page_was_dirty, GC_push_all);
+    }
+}
+#endif
+
+# ifdef MSWIN32
+  void __cdecl GC_push_one(p)
+# else
+  void GC_push_one(p)
+# endif
+word p;
+{
+    GC_PUSH_ONE_STACK(p);
+}
+
+# ifdef __STDC__
+#   define BASE(p) (word)GC_base((void *)(p))
+# else
+#   define BASE(p) (word)GC_base((char *)(p))
+# endif
+
+/* As above, but argument passed preliminary test. */
+void GC_push_one_checked(p, interior_ptrs)
+register word p;
+register bool interior_ptrs;
+{
+    register word r;
+    register hdr * hhdr; 
+    register int displ;
+  
+    GET_HDR(p, hhdr);
+    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+        if (hhdr != 0 && interior_ptrs) {
+          r = BASE(p);
+	  hhdr = HDR(r);
+	  displ = BYTES_TO_WORDS(HBLKDISPL(r));
+	} else {
+	  hhdr = 0;
+	}
+    } else {
+        register map_entry_type map_entry;
+        
+        displ = HBLKDISPL(p);
+        map_entry = MAP_ENTRY((hhdr -> hb_map), displ);
+        if (map_entry == OBJ_INVALID) {
+          if (interior_ptrs) {
+            r = BASE(p);
+	    displ = BYTES_TO_WORDS(HBLKDISPL(r));
+	    if (r == 0) hhdr = 0;
+          } else {
+            hhdr = 0;
+          }
+        } else {
+          displ = BYTES_TO_WORDS(displ);
+          displ -= map_entry;
+          r = (word)((word *)(HBLKPTR(p)) + displ);
+        }
+    }
+    /* If hhdr != 0 then r == GC_base(p), only we did it faster. */
+    /* displ is the word index within the block.		 */
+    if (hhdr == 0) {
+    	if (interior_ptrs) {
+	    GC_add_to_black_list_stack(p);
+	} else {
+	    GC_ADD_TO_BLACK_LIST_NORMAL(p);
+	}
+    } else {
+	if (!mark_bit_from_hdr(hhdr, displ)) {
+	    set_mark_bit_from_hdr(hhdr, displ);
+	    PUSH_OBJ((word *)r, hhdr, GC_mark_stack_top,
+	             &(GC_mark_stack[GC_mark_stack_size]));
+	}
+    }
+}
+
+# ifdef TRACE_BUF
+
+# define TRACE_ENTRIES 1000
+
+struct trace_entry {
+    char * kind;
+    word gc_no;
+    word words_allocd;
+    word arg1;
+    word arg2;
+} GC_trace_buf[TRACE_ENTRIES];
+
+int GC_trace_buf_ptr = 0;
+
+void GC_add_trace_entry(char *kind, word arg1, word arg2)
+{
+    GC_trace_buf[GC_trace_buf_ptr].kind = kind;
+    GC_trace_buf[GC_trace_buf_ptr].gc_no = GC_gc_no;
+    GC_trace_buf[GC_trace_buf_ptr].words_allocd = GC_words_allocd;
+    GC_trace_buf[GC_trace_buf_ptr].arg1 = arg1 ^ 0x80000000;
+    GC_trace_buf[GC_trace_buf_ptr].arg2 = arg2 ^ 0x80000000;
+    GC_trace_buf_ptr++;
+    if (GC_trace_buf_ptr >= TRACE_ENTRIES) GC_trace_buf_ptr = 0;
+}
+
+void GC_print_trace(word gc_no, bool lock)
+{
+    int i;
+    struct trace_entry *p;
+    
+    if (lock) LOCK();
+    for (i = GC_trace_buf_ptr-1; i != GC_trace_buf_ptr; i--) {
+    	if (i < 0) i = TRACE_ENTRIES-1;
+    	p = GC_trace_buf + i;
+    	if (p -> gc_no < gc_no || p -> kind == 0) return;
+    	printf("Trace:%s (gc:%d,words:%d) 0x%X, 0x%X\n",
+    		p -> kind, p -> gc_no, p -> words_allocd,
+    		(p -> arg1) ^ 0x80000000, (p -> arg2) ^ 0x80000000);
+    }
+    printf("Trace incomplete\n");
+    if (lock) UNLOCK();
+}
+
+# endif /* TRACE_BUF */
+
+/*
+ * A version of GC_push_all that treats all interior pointers as valid
+ */
+void GC_push_all_stack(bottom, top)
+ptr_t bottom;
+ptr_t top;
+{
+# ifdef ALL_INTERIOR_POINTERS
+    GC_push_all(bottom, top);
+#   ifdef TRACE_BUF
+        GC_add_trace_entry("GC_push_all_stack", bottom, top);
+#   endif
+# else
+    word * b = (word *)(((long) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1));
+    word * t = (word *)(((long) top) & ~(ALIGNMENT-1));
+    register word *p;
+    register word q;
+    register word *lim;
+    register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+    register ptr_t least_ha = GC_least_plausible_heap_addr;
+#   define GC_greatest_plausible_heap_addr greatest_ha
+#   define GC_least_plausible_heap_addr least_ha
+
+    if (top == 0) return;
+    /* check all pointers in range and put in push if they appear */
+    /* to be valid.						  */
+      lim = t - 1 /* longword */;
+      for (p = b; p <= lim; p = (word *)(((char *)p) + ALIGNMENT)) {
+	q = *p;
+	GC_PUSH_ONE_STACK(q);
+      }
+#   undef GC_greatest_plausible_heap_addr
+#   undef GC_least_plausible_heap_addr
+# endif
+}
+
+#ifndef SMALL_CONFIG
+/* Push all objects reachable from marked objects in the given block */
+/* of size 1 objects.						     */
+void GC_push_marked1(h, hhdr)
+struct hblk *h;
+register hdr * hhdr;
+{
+    word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p;
+    word *plim;
+    register int i;
+    register word q;
+    register word mark_word;
+    register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+    register ptr_t least_ha = GC_least_plausible_heap_addr;
+#   define GC_greatest_plausible_heap_addr greatest_ha
+#   define GC_least_plausible_heap_addr least_ha
+    
+    p = (word *)(h->hb_body);
+    plim = (word *)(((word)h) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    i = 0;
+	    while(mark_word != 0) {
+	      if (mark_word & 1) {
+	          q = p[i];
+	          GC_PUSH_ONE_HEAP(q);
+	      }
+	      i++;
+	      mark_word >>= 1;
+	    }
+	    p += WORDSZ;
+	}
+#   undef GC_greatest_plausible_heap_addr
+#   undef GC_least_plausible_heap_addr        
+}
+
+
+#ifndef UNALIGNED
+
+/* Push all objects reachable from marked objects in the given block */
+/* of size 2 objects.						     */
+void GC_push_marked2(h, hhdr)
+struct hblk *h;
+register hdr * hhdr;
+{
+    word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p;
+    word *plim;
+    register int i;
+    register word q;
+    register word mark_word;
+    register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+    register ptr_t least_ha = GC_least_plausible_heap_addr;
+#   define GC_greatest_plausible_heap_addr greatest_ha
+#   define GC_least_plausible_heap_addr least_ha
+    
+    p = (word *)(h->hb_body);
+    plim = (word *)(((word)h) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    i = 0;
+	    while(mark_word != 0) {
+	      if (mark_word & 1) {
+	          q = p[i];
+	          GC_PUSH_ONE_HEAP(q);
+	          q = p[i+1];
+	          GC_PUSH_ONE_HEAP(q);
+	      }
+	      i += 2;
+	      mark_word >>= 2;
+	    }
+	    p += WORDSZ;
+	}
+#   undef GC_greatest_plausible_heap_addr
+#   undef GC_least_plausible_heap_addr        
+}
+
+/* Push all objects reachable from marked objects in the given block */
+/* of size 4 objects.						     */
+/* There is a risk of mark stack overflow here.  But we handle that. */
+/* And only unmarked objects get pushed, so it's not very likely.    */
+void GC_push_marked4(h, hhdr)
+struct hblk *h;
+register hdr * hhdr;
+{
+    word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p;
+    word *plim;
+    register int i;
+    register word q;
+    register word mark_word;
+    register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+    register ptr_t least_ha = GC_least_plausible_heap_addr;
+#   define GC_greatest_plausible_heap_addr greatest_ha
+#   define GC_least_plausible_heap_addr least_ha
+    
+    p = (word *)(h->hb_body);
+    plim = (word *)(((word)h) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    i = 0;
+	    while(mark_word != 0) {
+	      if (mark_word & 1) {
+	          q = p[i];
+	          GC_PUSH_ONE_HEAP(q);
+	          q = p[i+1];
+	          GC_PUSH_ONE_HEAP(q);
+	          q = p[i+2];
+	          GC_PUSH_ONE_HEAP(q);
+	          q = p[i+3];
+	          GC_PUSH_ONE_HEAP(q);
+	      }
+	      i += 4;
+	      mark_word >>= 4;
+	    }
+	    p += WORDSZ;
+	}
+#   undef GC_greatest_plausible_heap_addr
+#   undef GC_least_plausible_heap_addr        
+}
+
+#endif /* UNALIGNED */
+
+#endif /* SMALL_CONFIG */
+
+/* Push all objects reachable from marked objects in the given block */
+void GC_push_marked(h, hhdr)
+struct hblk *h;
+register hdr * hhdr;
+{
+    register int sz = hhdr -> hb_sz;
+    register word * p;
+    register int word_no;
+    register word * lim;
+    register mse * GC_mark_stack_top_reg;
+    register mse * mark_stack_limit = &(GC_mark_stack[GC_mark_stack_size]);
+    
+    /* Some quick shortcuts: */
+        if (hhdr -> hb_obj_kind == PTRFREE) return;
+        if (GC_block_empty(hhdr)/* nothing marked */) return;
+#   ifdef GATHERSTATS
+        GC_n_rescuing_pages++;
+#   endif
+    GC_objects_are_marked = TRUE;
+    if (sz > MAXOBJSZ) {
+        lim = (word *)(h + 1);
+    } else {
+        lim = (word *)(h + 1) - sz;
+    }
+    
+    switch(sz) {
+#   if !defined(SMALL_CONFIG)    
+     case 1:
+       GC_push_marked1(h, hhdr);
+       break;
+#   endif
+#   if !defined(SMALL_CONFIG) && !defined(UNALIGNED)
+     case 2:
+       GC_push_marked2(h, hhdr);
+       break;
+     case 4:
+       GC_push_marked4(h, hhdr);
+       break;
+#   endif       
+     default:
+      GC_mark_stack_top_reg = GC_mark_stack_top;
+      for (p = (word *)h + HDR_WORDS, word_no = HDR_WORDS; p <= lim;
+         p += sz, word_no += sz) {
+         /* This ignores user specified mark procs.  This currently	*/
+         /* doesn't matter, since marking from the whole object		*/
+         /* is always sufficient, and we will eventually use the user	*/
+         /* mark proc to avoid any bogus pointers.			*/
+         if (mark_bit_from_hdr(hhdr, word_no)) {
+           /* Mark from fields inside the object */
+             PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top_reg, mark_stack_limit);
+#	     ifdef GATHERSTATS
+		/* Subtract this object from total, since it was	*/
+		/* added in twice.					*/
+		GC_composite_in_use -= sz;
+#	     endif
+         }
+      }
+      GC_mark_stack_top = GC_mark_stack_top_reg;
+    }
+}
+
+#ifndef SMALL_CONFIG
+/* Test whether any page in the given block is dirty	*/
+bool GC_block_was_dirty(h, hhdr)
+struct hblk *h;
+register hdr * hhdr;
+{
+    register int sz = hhdr -> hb_sz;
+    
+    if (sz < MAXOBJSZ) {
+         return(GC_page_was_dirty(h));
+    } else {
+    	 register ptr_t p = (ptr_t)h;
+         sz += HDR_WORDS;
+         sz = WORDS_TO_BYTES(sz);
+         while (p < (ptr_t)h + sz) {
+             if (GC_page_was_dirty((struct hblk *)p)) return(TRUE);
+             p += HBLKSIZE;
+         }
+         return(FALSE);
+    }
+}
+#endif /* SMALL_CONFIG */
+
+/* Similar to GC_push_next_marked, but return address of next block	*/
+struct hblk * GC_push_next_marked(h)
+struct hblk *h;
+{
+    register hdr * hhdr;
+    
+    h = GC_next_block(h);
+    if (h == 0) return(0);
+    hhdr = HDR(h);
+    GC_push_marked(h, hhdr);
+    return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
+}
+
+#ifndef SMALL_CONFIG
+/* Identical to above, but mark only from dirty pages	*/
+struct hblk * GC_push_next_marked_dirty(h)
+struct hblk *h;
+{
+    register hdr * hhdr = HDR(h);
+    
+    if (!GC_dirty_maintained) { ABORT("dirty bits not set up"); }
+    for (;;) {
+        h = GC_next_block(h);
+        if (h == 0) return(0);
+        hhdr = HDR(h);
+#	ifdef STUBBORN_ALLOC
+          if (hhdr -> hb_obj_kind == STUBBORN) {
+            if (GC_page_was_changed(h) && GC_block_was_dirty(h, hhdr)) {
+                break;
+            }
+          } else {
+            if (GC_block_was_dirty(h, hhdr)) break;
+          }
+#	else
+	  if (GC_block_was_dirty(h, hhdr)) break;
+#	endif
+        h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
+    }
+    GC_push_marked(h, hhdr);
+    return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
+}
+#endif
+
+/* Similar to above, but for uncollectable pages.  Needed since we	*/
+/* do not clear marks for such pages, even for full collections.	*/
+struct hblk * GC_push_next_marked_uncollectable(h)
+struct hblk *h;
+{
+    register hdr * hhdr = HDR(h);
+    
+    for (;;) {
+        h = GC_next_block(h);
+        if (h == 0) return(0);
+        hhdr = HDR(h);
+	if (hhdr -> hb_obj_kind == UNCOLLECTABLE) break;
+        h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
+    }
+    GC_push_marked(h, hhdr);
+    return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
+}
+
+
diff --git a/src/mzscheme/gc/mark_rts.c b/src/mzscheme/gc/mark_rts.c
new file mode 100644
index 0000000..d434430
--- /dev/null
+++ b/src/mzscheme/gc/mark_rts.c
@@ -0,0 +1,393 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 9, 1995 1:06 pm PDT */
+# include <stdio.h>
+# include "gc_priv.h"
+
+# ifdef LARGE_CONFIG
+#   define MAX_ROOT_SETS 4096
+# else
+#   ifdef PCR
+#     define MAX_ROOT_SETS 1024
+#   else
+#     ifdef MSWIN32
+#	define MAX_ROOT_SETS 512
+	    /* Under NT, we add only written pages, which can result 	*/
+	    /* in many small root sets.					*/
+#     else
+#       define MAX_ROOT_SETS 1024 /* MATTHEW: was 64, but extensions add a lot */
+#     endif
+#   endif
+# endif
+
+/* Data structure for list of root sets.				*/
+/* We keep a hash table, so that we can filter out duplicate additions.	*/
+/* Under Win32, we need to do a better job of filtering overlaps, so	*/
+/* we resort to sequential search, and pay the price.			*/
+struct roots {
+	ptr_t r_start;
+	ptr_t r_end;
+#	ifndef MSWIN32
+	  struct roots * r_next;
+#	endif
+	bool r_tmp;
+	  	/* Delete before registering new dynamic libraries */
+};
+
+static struct roots static_roots[MAX_ROOT_SETS];
+
+static int n_root_sets = 0;
+
+	/* static_roots[0..n_root_sets) contains the valid root sets. */
+
+# if !defined(NO_DEBUGGING)
+/* For debugging:	*/
+void GC_print_static_roots()
+{
+    register int i;
+    size_t total = 0;
+    
+    for (i = 0; i < n_root_sets; i++) {
+        GC_printf2("From 0x%lx to 0x%lx ",
+        	   (unsigned long) static_roots[i].r_start,
+        	   (unsigned long) static_roots[i].r_end);
+        if (static_roots[i].r_tmp) {
+            GC_printf0(" (temporary)\n");
+        } else {
+            GC_printf0("\n");
+        }
+        total += static_roots[i].r_end - static_roots[i].r_start;
+    }
+    GC_printf1("Total size: %ld\n", (unsigned long) total);
+    if (GC_root_size != total) {
+     	GC_printf1("GC_root_size incorrect: %ld!!\n",
+     		   (unsigned long) GC_root_size);
+    }
+}
+# endif /* NO_DEBUGGING */
+
+/* Primarily for debugging support:	*/
+/* Is the address p in one of the registered static			*/
+/* root sections?							*/
+bool GC_is_static_root(p)
+ptr_t p;
+{
+    static int last_root_set = 0;
+    register int i;
+    
+    
+    if (p >= static_roots[last_root_set].r_start
+        && p < static_roots[last_root_set].r_end) return(TRUE);
+    for (i = 0; i < n_root_sets; i++) {
+    	if (p >= static_roots[i].r_start
+            && p < static_roots[i].r_end) {
+            last_root_set = i;
+            return(TRUE);
+        }
+    }
+    return(FALSE);
+}
+
+#ifndef MSWIN32
+#   define LOG_RT_SIZE 6
+#   define RT_SIZE (1 << LOG_RT_SIZE)  /* Power of 2, may be != MAX_ROOT_SETS */
+
+    static struct roots * root_index[RT_SIZE];
+	/* Hash table header.  Used only to check whether a range is 	*/
+	/* already present.						*/
+
+static int rt_hash(addr)
+char * addr;
+{
+    word result = (word) addr;
+#   if CPP_WORDSZ > 8*LOG_RT_SIZE
+	result ^= result >> 8*LOG_RT_SIZE;
+#   endif
+#   if CPP_WORDSZ > 4*LOG_RT_SIZE
+	result ^= result >> 4*LOG_RT_SIZE;
+#   endif
+    result ^= result >> 2*LOG_RT_SIZE;
+    result ^= result >> LOG_RT_SIZE;
+    result &= (RT_SIZE-1);
+    return(result);
+}
+
+/* Is a range starting at b already in the table? If so return a	*/
+/* pointer to it, else NIL.						*/
+struct roots * GC_roots_present(b)
+char *b;
+{
+    register int h = rt_hash(b);
+    register struct roots *p = root_index[h];
+    
+    while (p != 0) {
+        if (p -> r_start == (ptr_t)b) return(p);
+        p = p -> r_next;
+    }
+    return(FALSE);
+}
+
+/* Add the given root structure to the index. */
+static void add_roots_to_index(p)
+struct roots *p;
+{
+    register int h = rt_hash(p -> r_start);
+    
+    p -> r_next = root_index[h];
+    root_index[h] = p;
+}
+
+# else /* MSWIN32 */
+
+#   define add_roots_to_index(p)
+
+# endif
+
+
+
+
+word GC_root_size = 0;
+
+void GC_add_roots(b, e)
+char * b; char * e;
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    GC_add_roots_inner(b, e, FALSE);
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+
+/* Add [b,e) to the root set.  Adding the same interval a second time	*/
+/* is a moderately fast noop, and hence benign.  We do not handle	*/
+/* different but overlapping intervals efficiently.  (We do handle	*/
+/* them correctly.)							*/
+/* Tmp specifies that the interval may be deleted before 		*/
+/* reregistering dynamic libraries.					*/ 
+void GC_add_roots_inner(b, e, tmp)
+char * b; char * e;
+bool tmp;
+{
+    struct roots * old;
+    
+    /* We exclude GC data structures from root sets.  It's usually safe	*/
+    /* to mark from those, but it is a waste of time.			*/
+    if ( (ptr_t)b < endGC_arrays && (ptr_t)e > beginGC_arrays) {
+        if ((ptr_t)e <= endGC_arrays) {
+            if ((ptr_t)b >= beginGC_arrays) return;
+            e = (char *)beginGC_arrays;
+        } else if ((ptr_t)b >= beginGC_arrays) {
+            b = (char *)endGC_arrays;
+        } else {
+            GC_add_roots_inner(b, (char *)beginGC_arrays, tmp);
+            GC_add_roots_inner((char *)endGC_arrays, e, tmp);
+            return;
+        }
+    }
+/* MATTHEW: always merge overlapping: */
+#   if 1 || defined(MSWIN32)
+      /* Spend the time to ensure that there are no overlapping	*/
+      /* or adjacent intervals.					*/
+      /* This could be done faster with e.g. a			*/
+      /* balanced tree.  But the execution time here is		*/
+      /* virtually guaranteed to be dominated by the time it	*/
+      /* takes to scan the roots.				*/
+      {
+        register int i;
+        
+        for (i = 0; i < n_root_sets; i++) {
+            old = static_roots + i;
+            if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start
+		&& tmp == old -> r_tmp) { /* MATTHEW: merge only same kinds */
+                if ((ptr_t)b < old -> r_start) {
+                    old -> r_start = (ptr_t)b;
+                    GC_root_size += (old -> r_start - (ptr_t)b);
+                }
+                if ((ptr_t)e > old -> r_end) {
+                    old -> r_end = (ptr_t)e;
+                    GC_root_size += ((ptr_t)e - old -> r_end);
+                }
+                old -> r_tmp &= tmp;
+                break;
+            }
+        }
+        if (i < n_root_sets) {
+          /* merge other overlapping intervals */
+            struct roots *other;
+            
+            for (i++; i < n_root_sets; i++) {
+              other = static_roots + i;
+              b = (char *)(other -> r_start);
+              e = (char *)(other -> r_end);
+	      tmp = other -> r_tmp; /* MATTHEW */
+              if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start
+		  && tmp == old -> r_tmp) {  /* MATTHEW: merge only same kinds */
+                if ((ptr_t)b < old -> r_start) {
+                    old -> r_start = (ptr_t)b;
+                    GC_root_size += (old -> r_start - (ptr_t)b);
+                }
+                if ((ptr_t)e > old -> r_end) {
+                    old -> r_end = (ptr_t)e;
+                    GC_root_size += ((ptr_t)e - old -> r_end);
+                }
+                old -> r_tmp &= other -> r_tmp;
+                /* Delete this entry. */
+                  GC_root_size -= (other -> r_end - other -> r_start);
+                  other -> r_start = static_roots[n_root_sets-1].r_start;
+                  other -> r_end = static_roots[n_root_sets-1].r_end;
+                                  n_root_sets--;
+              }
+            }
+          return;
+        }
+      }
+#   else
+      old = GC_roots_present(b);
+      if (old != 0) {
+        if ((ptr_t)e <= old -> r_end) /* already there */ return;
+        /* else extend */
+        GC_root_size += (ptr_t)e - old -> r_end;
+        old -> r_end = (ptr_t)e;
+        return;
+      }
+#   endif
+    if (n_root_sets == MAX_ROOT_SETS) {
+        ABORT("Too many root sets\n");
+    }
+    static_roots[n_root_sets].r_start = (ptr_t)b;
+    static_roots[n_root_sets].r_end = (ptr_t)e;
+    static_roots[n_root_sets].r_tmp = tmp;
+#   ifndef MSWIN32
+      static_roots[n_root_sets].r_next = 0;
+#   endif
+    add_roots_to_index(static_roots + n_root_sets);
+    GC_root_size += (ptr_t)e - (ptr_t)b;
+    n_root_sets++;
+}
+
+void GC_clear_roots GC_PROTO((void))
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    n_root_sets = 0;
+    GC_root_size = 0;
+#   ifndef MSWIN32
+    {
+    	register int i;
+    	
+    	for (i = 0; i < RT_SIZE; i++) root_index[i] = 0;
+    }
+#   endif
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+/* Internal use only; lock held.	*/
+void GC_remove_tmp_roots()
+{
+    register int i;
+    
+    for (i = 0; i < n_root_sets; ) {
+    	if (static_roots[i].r_tmp) {
+    	    GC_root_size -= (static_roots[i].r_end - static_roots[i].r_start);
+    	    static_roots[i].r_start = static_roots[n_root_sets-1].r_start;
+    	    static_roots[i].r_end = static_roots[n_root_sets-1].r_end;
+    	    static_roots[i].r_tmp = static_roots[n_root_sets-1].r_tmp;
+    	    n_root_sets--;
+    	} else {
+    	    i++;
+    	}
+    }
+#   ifndef MSWIN32
+    {
+    	register int i;
+    	
+    	for (i = 0; i < RT_SIZE; i++) root_index[i] = 0;
+    	for (i = 0; i < n_root_sets; i++) add_roots_to_index(static_roots + i);
+    }
+#   endif
+    
+}
+
+ptr_t GC_approx_sp()
+{
+    word dummy;
+    
+    return((ptr_t)(&dummy));
+}
+
+/*
+ * Call the mark routines (GC_tl_push for a single pointer, GC_push_conditional
+ * on groups of pointers) on every top level accessible pointer.
+ * If all is FALSE, arrange to push only possibly altered values.
+ */
+
+/* MATTHEW: NO_AUTO_STACK_PUSH */
+#ifdef NO_AUTO_STACK_PUSH
+extern GC_push_all_stacks(void);
+#endif
+
+void GC_push_roots(all)
+bool all;
+{
+    register int i;
+
+    /*
+     * push registers - i.e., call GC_push_one(r) for each
+     * register contents r.
+     */
+        GC_push_regs(); /* usually defined in machine_dep.c */
+        
+    /*
+     * Next push static data.  This must happen early on, since it's
+     * not robust against mark stack overflow.
+     */
+     /* Reregister dynamic libraries, in case one got added.	*/
+#      if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(PCR)) \
+           && !defined(SRC_M3)
+         GC_remove_tmp_roots();
+         GC_register_dynamic_libraries();
+#      endif
+     /* Mark everything in static data areas                             */
+       for (i = 0; i < n_root_sets; i++) {
+         GC_push_conditional(static_roots[i].r_start,
+			     static_roots[i].r_end, all);
+       }
+
+    /*
+     * Now traverse stacks.
+     */
+    /* MATTHEW: NO_AUTO_STACK_PUSH - call "user"-defined */
+#  ifndef NO_AUTO_STACK_PUSH
+#   ifndef THREADS
+        /* Mark everything on the stack.           */
+#   	  ifdef STACK_GROWS_DOWN
+	    GC_push_all_stack( GC_approx_sp(), GC_stackbottom );
+#	  else
+	    GC_push_all_stack( GC_stackbottom, GC_approx_sp() );
+#	  endif
+#   endif
+# else
+    GC_push_all_stacks();
+# endif
+
+    if (GC_push_other_roots != 0) (*GC_push_other_roots)();
+    	/* In the threads case, this also pushes thread stacks.	*/
+}
+
diff --git a/src/mzscheme/gc/mips_sgi_mach_dep.s b/src/mzscheme/gc/mips_sgi_mach_dep.s
new file mode 100644
index 0000000..bf7f61a
--- /dev/null
+++ b/src/mzscheme/gc/mips_sgi_mach_dep.s
@@ -0,0 +1,39 @@
+#include <sys/regdef.h>
+#include <sys/asm.h>
+
+# define call_push(x)     move    $4,x;    jal     GC_push_one
+
+    .text
+/* Mark from machine registers that are saved by C compiler */
+#   define FRAMESZ 32
+#   define RAOFF FRAMESZ-SZREG
+#   define GPOFF FRAMESZ-(2*SZREG)
+    NESTED(GC_push_regs, FRAMESZ, ra)
+    move 	t0,gp
+    SETUP_GPX(t8)
+    PTR_SUBU	sp,FRAMESZ
+#   ifdef SETUP_GP64
+      SETUP_GP64(GPOFF, GC_push_regs)
+#   endif
+    SAVE_GP(GPOFF)
+    REG_S 	ra,RAOFF(sp)
+#   if (_MIPS_SIM == _MIPS_SIM_ABI32)
+    	call_push($2)
+    	call_push($3)
+#   endif
+    call_push($16)
+    call_push($17)
+    call_push($18)
+    call_push($19)
+    call_push($20)
+    call_push($21)
+    call_push($22)
+    call_push($23)
+    call_push($30)
+    REG_L	ra,RAOFF(sp)
+#   ifdef RESTORE_GP64
+      RESTORE_GP64
+#   endif
+    PTR_ADDU	sp,FRAMESZ
+    j		ra
+    .end    GC_push_regs
diff --git a/src/mzscheme/gc/mips_ultrix_mach_dep.s b/src/mzscheme/gc/mips_ultrix_mach_dep.s
new file mode 100644
index 0000000..178224e
--- /dev/null
+++ b/src/mzscheme/gc/mips_ultrix_mach_dep.s
@@ -0,0 +1,26 @@
+# define call_push(x)     move    $4,x;    jal     GC_push_one
+
+    .text
+ # Mark from machine registers that are saved by C compiler
+    .globl  GC_push_regs
+    .ent    GC_push_regs
+GC_push_regs:
+    subu    $sp,8       ## Need to save only return address
+    sw      $31,4($sp)
+    .mask   0x80000000,-4
+    .frame  $sp,8,$31
+    call_push($2)
+    call_push($3)
+    call_push($16)
+    call_push($17)
+    call_push($18)
+    call_push($19)
+    call_push($20)
+    call_push($21)
+    call_push($22)
+    call_push($23)
+    call_push($30)
+    lw      $31,4($sp)
+    addu    $sp,8
+    j       $31
+    .end    GC_push_regs
diff --git a/src/mzscheme/gc/misc.c b/src/mzscheme/gc/misc.c
new file mode 100755
index 0000000..de564ff
--- /dev/null
+++ b/src/mzscheme/gc/misc.c
@@ -0,0 +1,783 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, July 31, 1995 5:02 pm PDT */
+
+
+#include <stdio.h>
+#include <signal.h>
+
+#define I_HIDE_POINTERS	/* To make GC_call_with_alloc_lock visible */
+#include "gc_priv.h"
+
+#ifdef SOLARIS_THREADS
+# include <sys/syscall.h>
+#endif
+#ifdef MSWIN32
+# include <windows.h>
+#endif
+
+# ifdef THREADS
+#   ifdef PCR
+#     include "il/PCR_IL.h"
+      PCR_Th_ML GC_allocate_ml;
+#   else
+#     ifdef SRC_M3
+	/* Critical section counter is defined in the M3 runtime 	*/
+	/* That's all we use.						*/
+#     else
+#	ifdef SOLARIS_THREADS
+	  mutex_t GC_allocate_ml;	/* Implicitly initialized.	*/
+#	else
+#          ifdef WIN32_THREADS
+              /* GC_API */ CRITICAL_SECTION GC_allocate_ml;
+#          else
+#             ifdef IRIX_THREADS
+#		ifdef UNDEFINED
+		    pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER;
+#		endif
+	        pthread_t GC_lock_holder = NO_THREAD;
+#	      else
+	        --> declare allocator lock here
+#	      endif
+#	   endif
+#	endif
+#     endif
+#   endif
+# endif
+
+GC_FAR struct _GC_arrays GC_arrays /* = { 0 } */;
+
+
+bool GC_debugging_started = FALSE;
+	/* defined here so we don't have to load debug_malloc.o */
+
+void (*GC_check_heap)() = (void (*)())0;
+
+ptr_t GC_stackbottom = 0;
+
+bool GC_dont_gc = 0;
+
+bool GC_quiet = 0;
+
+/*ARGSUSED*/
+void * GC_default_oom_fn GC_PROTO((size_t bytes_requested))
+{
+    return(0);
+}
+
+void * (*GC_oom_fn) GC_PROTO((size_t bytes_requested)) = GC_default_oom_fn;
+
+extern signed_word GC_mem_found;
+
+# ifdef MERGE_SIZES
+    /* Set things up so that GC_size_map[i] >= words(i),		*/
+    /* but not too much bigger						*/
+    /* and so that size_map contains relatively few distinct entries 	*/
+    /* This is stolen from Russ Atkinson's Cedar quantization		*/
+    /* alogrithm (but we precompute it).				*/
+
+
+    void GC_init_size_map()
+    {
+	register unsigned i;
+
+	/* Map size 0 to 1.  This avoids problems at lower levels. */
+	  GC_size_map[0] = 1;
+	/* One word objects don't have to be 2 word aligned.	   */
+	  for (i = 1; i < sizeof(word); i++) {
+	      GC_size_map[i] = 1;
+	  }
+	  GC_size_map[sizeof(word)] = ROUNDED_UP_WORDS(sizeof(word));
+	for (i = sizeof(word) + 1; i <= 8 * sizeof(word); i++) {
+#           ifdef ALIGN_DOUBLE
+	      GC_size_map[i] = (ROUNDED_UP_WORDS(i) + 1) & (~1);
+#           else
+	      GC_size_map[i] = ROUNDED_UP_WORDS(i);
+#           endif
+	}
+	for (i = 8*sizeof(word) + 1; i <= 16 * sizeof(word); i++) {
+	      GC_size_map[i] = (ROUNDED_UP_WORDS(i) + 1) & (~1);
+	}
+	/* We leave the rest of the array to be filled in on demand. */
+    }
+    
+    /* Fill in additional entries in GC_size_map, including the ith one */
+    /* We assume the ith entry is currently 0.				*/
+    /* Note that a filled in section of the array ending at n always    */
+    /* has length at least n/4.						*/
+    void GC_extend_size_map(i)
+    word i;
+    {
+        word orig_word_sz = ROUNDED_UP_WORDS(i);
+        word word_sz = orig_word_sz;
+    	register word byte_sz = WORDS_TO_BYTES(word_sz);
+    				/* The size we try to preserve.		*/
+    				/* Close to to i, unless this would	*/
+    				/* introduce too many distinct sizes.	*/
+    	word smaller_than_i = byte_sz - (byte_sz >> 3);
+    	word much_smaller_than_i = byte_sz - (byte_sz >> 2);
+    	register word low_limit;	/* The lowest indexed entry we 	*/
+    					/* initialize.			*/
+    	register word j;
+    	
+    	if (GC_size_map[smaller_than_i] == 0) {
+    	    low_limit = much_smaller_than_i;
+    	    while (GC_size_map[low_limit] != 0) low_limit++;
+    	} else {
+    	    low_limit = smaller_than_i + 1;
+    	    while (GC_size_map[low_limit] != 0) low_limit++;
+    	    word_sz = ROUNDED_UP_WORDS(low_limit);
+    	    word_sz += word_sz >> 3;
+    	    if (word_sz < orig_word_sz) word_sz = orig_word_sz;
+    	}
+#	ifdef ALIGN_DOUBLE
+	    word_sz += 1;
+	    word_sz &= ~1;
+#	endif
+	if (word_sz > MAXOBJSZ) {
+	    word_sz = MAXOBJSZ;
+	}
+	/* If we can fit the same number of larger objects in a block,	*/
+	/* do so.							*/ 
+	{
+#	    ifdef ALIGN_DOUBLE
+#	        define INCR 2
+#	    else
+#		define INCR 1
+#	    endif
+	    while (BODY_SZ/word_sz == BODY_SZ/(word_sz + INCR)) word_sz += INCR;
+	}
+    	byte_sz = WORDS_TO_BYTES(word_sz);
+#	ifdef ADD_BYTE_AT_END
+	    /* We need one extra byte; don't fill in GC_size_map[byte_sz] */
+	    byte_sz--;
+#	endif
+
+    	for (j = low_limit; j <= byte_sz; j++) GC_size_map[j] = word_sz;  
+    }
+# endif
+
+
+/*
+ * The following is a gross hack to deal with a problem that can occur
+ * on machines that are sloppy about stack frame sizes, notably SPARC.
+ * Bogus pointers may be written to the stack and not cleared for
+ * a LONG time, because they always fall into holes in stack frames
+ * that are not written.  We partially address this by clearing
+ * sections of the stack whenever we get control.
+ */
+word GC_stack_last_cleared = 0;	/* GC_no when we last did this */
+# define CLEAR_SIZE 213
+# define DEGRADE_RATE 50
+
+word GC_min_sp;		/* Coolest stack pointer value from which we've */
+			/* already cleared the stack.			*/
+			
+# ifdef STACK_GROWS_DOWN
+#   define COOLER_THAN >
+#   define HOTTER_THAN <
+#   define MAKE_COOLER(x,y) if ((word)(x)+(y) > (word)(x)) {(x) += (y);} \
+			    else {(x) = (word)ONES;}
+#   define MAKE_HOTTER(x,y) (x) -= (y)
+# else
+#   define COOLER_THAN <
+#   define HOTTER_THAN >
+#   define MAKE_COOLER(x,y) if ((word)(x)-(y) < (word)(x)) {(x) -= (y);} else {(x) = 0;}
+#   define MAKE_HOTTER(x,y) (x) += (y)
+# endif
+
+word GC_high_water;
+			/* "hottest" stack pointer value we have seen	*/
+			/* recently.  Degrades over time.		*/
+
+word GC_words_allocd_at_reset;
+
+/* MATTHEW: NO_AUTO_STACK_PUSH */
+#if defined(ASM_CLEAR_CODE) && !defined(THREADS) && !defined(NO_AUTO_STACK_PUSH)
+  extern ptr_t GC_clear_stack_inner();
+#endif  
+
+/* MATTHEW: NO_AUTO_STACK_PUSH */
+#if !defined(ASM_CLEAR_CODE) && !defined(THREADS) && !defined(NO_AUTO_STACK_PUSH)
+/* Clear the stack up to about limit.  Return arg. */
+/*ARGSUSED*/
+ptr_t GC_clear_stack_inner(arg, limit)
+ptr_t arg;
+word limit;
+{
+    word dummy[CLEAR_SIZE];
+    
+    BZERO(dummy, CLEAR_SIZE*sizeof(word));
+    if ((word)(dummy) COOLER_THAN limit) {
+        (void) GC_clear_stack_inner(arg, limit);
+    }
+    /* Make sure the recursive call is not a tail call, and the bzero	*/
+    /* call is not recognized as dead code.				*/
+    GC_noop1((word)dummy);
+    return(arg);
+}
+#endif
+
+extern ptr_t GC_approx_sp();	/* in mark_rts.c */
+
+/* Clear some of the inaccessible part of the stack.  Returns its	*/
+/* argument, so it can be used in a tail call position, hence clearing  */
+/* another frame.							*/
+ptr_t GC_clear_stack(arg)
+ptr_t arg;
+{
+    register word sp = (word)GC_approx_sp();  /* Hotter than actual sp */
+    /* MATTHEW: NO_AUTO_STACK_PUSH */
+#   if defined(THREADS) || defined(NO_AUTO_STACK_PUSH)
+        word dummy[CLEAR_SIZE];;
+#   else
+    	register word limit;
+#   endif
+    
+#   define SLOP 400
+	/* Extra bytes we clear every time.  This clears our own	*/
+	/* activation record, and should cause more frequent		*/
+	/* clearing near the cold end of the stack, a good thing.	*/
+#   define GC_SLOP 4000
+	/* We make GC_high_water this much hotter than we really saw   	*/
+	/* saw it, to cover for GC noise etc. above our current frame.	*/
+#   define CLEAR_THRESHOLD 100000
+	/* We restart the clearing process after this many bytes of	*/
+	/* allocation.  Otherwise very heavily recursive programs	*/
+	/* with sparse stacks may result in heaps that grow almost	*/
+	/* without bounds.  As the heap gets larger, collection 	*/
+	/* frequency decreases, thus clearing frequency would decrease, */
+	/* thus more junk remains accessible, thus the heap gets	*/
+	/* larger ...							*/
+    /* MATTHEW: NO_AUTO_STACK_PUSH */
+# if defined(THREADS) || defined(NO_AUTO_STACK_PUSH)
+    BZERO(dummy, CLEAR_SIZE*sizeof(word));
+# else
+    if (GC_gc_no > GC_stack_last_cleared) {
+        /* Start things over, so we clear the entire stack again */
+        if (GC_stack_last_cleared == 0) GC_high_water = (word) GC_stackbottom;
+        GC_min_sp = GC_high_water;
+        GC_stack_last_cleared = GC_gc_no;
+        GC_words_allocd_at_reset = GC_words_allocd;
+    }
+    /* Adjust GC_high_water */
+        MAKE_COOLER(GC_high_water, WORDS_TO_BYTES(DEGRADE_RATE) + GC_SLOP);
+        if (sp HOTTER_THAN GC_high_water) {
+            GC_high_water = sp;
+        }
+        MAKE_HOTTER(GC_high_water, GC_SLOP);
+    limit = GC_min_sp;
+    MAKE_HOTTER(limit, SLOP);
+    if (sp COOLER_THAN limit) {
+        limit &= ~0xf;	/* Make it sufficiently aligned for assembly	*/
+        		/* implementations of GC_clear_stack_inner.	*/
+        GC_min_sp = sp;
+        return(GC_clear_stack_inner(arg, limit));
+    } else if (WORDS_TO_BYTES(GC_words_allocd - GC_words_allocd_at_reset)
+    	       > CLEAR_THRESHOLD) {
+    	/* Restart clearing process, but limit how much clearing we do. */
+    	GC_min_sp = sp;
+    	MAKE_HOTTER(GC_min_sp, CLEAR_THRESHOLD/4);
+    	if (GC_min_sp HOTTER_THAN GC_high_water) GC_min_sp = GC_high_water;
+    	GC_words_allocd_at_reset = GC_words_allocd;
+    }  
+# endif
+  return(arg);
+}
+
+
+/* Return a pointer to the base address of p, given a pointer to a	*/
+/* an address within an object.  Return 0 o.w.				*/
+# ifdef __STDC__
+    GC_PTR GC_base(GC_PTR p)
+# else
+    GC_PTR GC_base(p)
+    GC_PTR p;
+# endif
+{
+    register word r;
+    register struct hblk *h;
+    register bottom_index *bi;
+    register hdr *candidate_hdr;
+    register word limit;
+    
+    r = (word)p;
+    if (!GC_is_initialized) return 0;
+    h = HBLKPTR(r);
+    GET_BI(r, bi);
+    candidate_hdr = HDR_FROM_BI(bi, r);
+    if (candidate_hdr == 0) return(0);
+    /* If it's a pointer to the middle of a large object, move it	*/
+    /* to the beginning.						*/
+	while (IS_FORWARDING_ADDR_OR_NIL(candidate_hdr)) {
+	   h = FORWARDED_ADDR(h,candidate_hdr);
+	   r = (word)h + HDR_BYTES;
+	   candidate_hdr = HDR(h);
+	}
+    if (candidate_hdr -> hb_map == GC_invalid_map) return(0);
+    /* Make sure r points to the beginning of the object */
+	r &= ~(WORDS_TO_BYTES(1) - 1);
+        {
+	    register int offset =
+	        	(char *)r - (char *)(HBLKPTR(r)) - HDR_BYTES;
+	    register signed_word sz = candidate_hdr -> hb_sz;
+	    
+#	    ifdef ALL_INTERIOR_POINTERS
+	      register map_entry_type map_entry;
+	      
+	      map_entry = MAP_ENTRY((candidate_hdr -> hb_map), offset);
+	      if (map_entry == OBJ_INVALID) {
+            	return(0);
+              }
+              r -= WORDS_TO_BYTES(map_entry);
+              limit = r + WORDS_TO_BYTES(sz);
+#	    else
+	      register int correction;
+	      
+	      offset = BYTES_TO_WORDS(offset - HDR_BYTES);
+	      correction = offset % sz;
+	      r -= (WORDS_TO_BYTES(correction));
+	      limit = r + WORDS_TO_BYTES(sz);
+	      if (limit > (word)(h + 1)
+	        && sz <= BYTES_TO_WORDS(HBLKSIZE) - HDR_WORDS) {
+	        return(0);
+	      }
+#	    endif
+	    if ((word)p >= limit) return(0);
+	}
+    return((GC_PTR)r);
+}
+
+
+/* Return the size of an object, given a pointer to its base.		*/
+/* (For small obects this also happens to work from interior pointers,	*/
+/* but that shouldn't be relied upon.)					*/
+# ifdef __STDC__
+    size_t GC_size(GC_PTR p)
+# else
+    size_t GC_size(p)
+    GC_PTR p;
+# endif
+{
+    register int sz;
+    register hdr * hhdr = HDR(p);
+    
+    sz = WORDS_TO_BYTES(hhdr -> hb_sz);
+    if (sz < 0) {
+        return(-sz);
+    } else {
+        return(sz);
+    }
+}
+
+size_t GC_get_heap_size GC_PROTO(())
+{
+    return ((size_t) GC_heapsize);
+}
+
+size_t GC_get_bytes_since_gc GC_PROTO(())
+{
+    return ((size_t) WORDS_TO_BYTES(GC_words_allocd));
+}
+
+bool GC_is_initialized = FALSE;
+
+void GC_init()
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    GC_init_inner();
+    UNLOCK();
+    ENABLE_SIGNALS();
+
+}
+
+#ifdef MSWIN32
+    extern void GC_init_win32();
+#endif
+
+#if defined(SOLARIS_THREADS) || defined(IRIX_THREADS)
+    extern void GC_thr_init();
+#endif
+
+void GC_init_inner()
+{
+#   ifndef THREADS
+        word dummy;
+#   endif
+    
+    if (GC_is_initialized) return;
+#   ifdef MSWIN32
+ 	GC_init_win32();
+#   endif
+#   ifdef SOLARIS_THREADS
+	GC_thr_init();
+	/* We need dirty bits in order to find live stack sections.	*/
+        GC_dirty_init();
+#   endif
+#   ifdef IRIX_THREADS
+	GC_thr_init();
+#   endif
+#   if !defined(THREADS) || defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(IRIX_THREADS)
+      if (GC_stackbottom == 0) {
+	GC_stackbottom = GC_get_stack_base();
+      }
+#   endif
+    if  (sizeof (ptr_t) != sizeof(word)) {
+        ABORT("sizeof (ptr_t) != sizeof(word)\n");
+    }
+    if  (sizeof (signed_word) != sizeof(word)) {
+        ABORT("sizeof (signed_word) != sizeof(word)\n");
+    }
+    if  (sizeof (struct hblk) != HBLKSIZE) {
+        ABORT("sizeof (struct hblk) != HBLKSIZE\n");
+    }
+#   ifndef THREADS
+#     if defined(STACK_GROWS_UP) && defined(STACK_GROWS_DOWN)
+  	ABORT(
+  	  "Only one of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd\n");
+#     endif
+#     if !defined(STACK_GROWS_UP) && !defined(STACK_GROWS_DOWN)
+  	ABORT(
+  	  "One of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd\n");
+#     endif
+#     ifdef STACK_GROWS_DOWN
+        if ((word)(&dummy) > (word)GC_stackbottom) {
+          GC_err_printf0(
+          	"STACK_GROWS_DOWN is defd, but stack appears to grow up\n");
+          GC_err_printf2("sp = 0x%lx, GC_stackbottom = 0x%lx\n",
+          	   	 (unsigned long) (&dummy),
+          	   	 (unsigned long) GC_stackbottom);
+          ABORT("stack direction 3\n");
+        }
+#     else
+        if ((word)(&dummy) < (word)GC_stackbottom) {
+          GC_err_printf0(
+          	"STACK_GROWS_UP is defd, but stack appears to grow down\n");
+          GC_err_printf2("sp = 0x%lx, GC_stackbottom = 0x%lx\n",
+          	       	 (unsigned long) (&dummy),
+          	     	 (unsigned long) GC_stackbottom);
+          ABORT("stack direction 4");
+        }
+#     endif
+#   endif
+#   if !defined(_AUX_SOURCE) || defined(__GNUC__)
+      if ((word)(-1) < (word)0) {
+    	GC_err_printf0("The type word should be an unsigned integer type\n");
+    	GC_err_printf0("It appears to be signed\n");
+    	ABORT("word");
+      }
+#   endif
+    if ((signed_word)(-1) >= (signed_word)0) {
+    	GC_err_printf0(
+    		"The type signed_word should be a signed integer type\n");
+    	GC_err_printf0("It appears to be unsigned\n");
+    	ABORT("signed_word");
+    }
+    
+    /* Add initial guess of root sets.  Do this first, since sbrk(0)	*/
+    /* mightbe used.							*/
+      GC_register_data_segments();
+
+   /* MATTHEW: In case we use near data for 68k Mac, this array is declared FAR */
+#ifdef __MC68K__
+    GC_add_roots_inner((ptr_t)&GC_arrays, 
+                       (ptr_t)(((char *)&GC_arrays) + sizeof(GC_arrays)), 
+                       FALSE);
+#endif
+
+    GC_init_headers();
+        GC_bl_init();
+    GC_mark_init();
+    if (!GC_expand_hp_inner((word)MINHINCR)) {
+        GC_err_printf0("Can't start up: not enough memory\n");
+        EXIT();
+    }
+    /* Preallocate large object map.  It's otherwise inconvenient to 	*/
+    /* deal with failure.						*/
+      if (!GC_add_map_entry((word)0)) {
+        GC_err_printf0("Can't start up: not enough memory\n");
+        EXIT();
+      }
+    GC_register_displacement_inner(0L);
+#   ifdef MERGE_SIZES
+      GC_init_size_map();
+#   endif
+#   ifdef PCR
+      if (PCR_IL_Lock(PCR_Bool_false, PCR_allSigsBlocked, PCR_waitForever)
+          != PCR_ERes_okay) {
+          ABORT("Can't lock load state\n");
+      } else if (PCR_IL_Unlock() != PCR_ERes_okay) {
+          ABORT("Can't unlock load state\n");
+      }
+      PCR_IL_Unlock();
+      GC_pcr_install();
+#   endif
+    /* Get black list set up */
+      GC_gcollect_inner();
+#   ifdef STUBBORN_ALLOC
+    	GC_stubborn_init();
+#   endif
+    GC_is_initialized = TRUE;
+    /* Convince lint that some things are used */
+#   ifdef LINT
+      {
+          extern char * GC_copyright[];
+          extern int GC_read();
+          extern void GC_register_finalizer_no_order();
+          
+          GC_noop(GC_copyright, GC_find_header,
+                  GC_push_one, GC_call_with_alloc_lock, GC_read,
+                  GC_dont_expand,
+#		  ifndef NO_DEBUGGING
+		    GC_dump,
+#		  endif
+                  GC_register_finalizer_no_order);
+      }
+#   endif
+}
+
+void GC_enable_incremental GC_PROTO(())
+{
+    DCL_LOCK_STATE;
+    
+# ifndef FIND_LEAK
+    DISABLE_SIGNALS();
+    LOCK();
+    if (GC_incremental) goto out;
+#   ifdef MSWIN32
+      {
+        extern bool GC_is_win32s();
+
+	/* VirtualProtect is not functional under win32s.	*/
+	if (GC_is_win32s()) goto out;
+      }
+#   endif /* MSWIN32 */
+#   ifndef SOLARIS_THREADS
+        GC_dirty_init();
+#   endif
+    if (!GC_is_initialized) {
+        GC_init_inner();
+    }
+    if (GC_dont_gc) {
+        /* Can't easily do it. */
+        UNLOCK();
+    	ENABLE_SIGNALS();
+    	return;
+    }
+    if (GC_words_allocd > 0) {
+    	/* There may be unmarked reachable objects	*/
+    	GC_gcollect_inner();
+    }   /* else we're OK in assuming everything's	*/
+    	/* clean since nothing can point to an	  	*/
+    	/* unmarked object.			  	*/
+    GC_read_dirty();
+    GC_incremental = TRUE;
+out:
+    UNLOCK();
+    ENABLE_SIGNALS();
+# endif
+}
+
+
+#ifdef MSWIN32
+# define LOG_FILE "gc.log"
+
+  HANDLE GC_stdout = 0, GC_stderr;
+  int GC_tmp;
+  DWORD GC_junk;
+
+  void GC_set_files()
+  {
+    if (!GC_stdout) {
+        GC_stdout = CreateFile(LOG_FILE, GENERIC_WRITE,
+        		       FILE_SHARE_READ | FILE_SHARE_WRITE,
+        		       NULL, CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH,
+        		       NULL); 
+    	if (INVALID_HANDLE_VALUE == GC_stdout) ABORT("Open of log file failed");
+    }
+    if (GC_stderr == 0) {
+	GC_stderr = GC_stdout;
+    }
+  }
+
+#endif
+
+#if defined(OS2) || defined(MACOS)
+FILE * GC_stdout = NULL;
+FILE * GC_stderr = NULL;
+int GC_tmp;  /* Should really be local ... */
+
+  void GC_set_files()
+  {
+      if (GC_stdout == NULL) {
+	GC_stdout = stdout;
+    }
+    if (GC_stderr == NULL) {
+	GC_stderr = stderr;
+    }
+  }
+#endif
+
+#if !defined(OS2) && !defined(MACOS) && !defined(MSWIN32)
+  int GC_stdout = 1;
+  int GC_stderr = 2;
+# if !defined(AMIGA)
+#   include <unistd.h>
+# endif
+#endif
+
+#if !defined(MSWIN32)  && !defined(OS2) && !defined(MACOS)
+int GC_write(fd, buf, len)
+int fd;
+char *buf;
+size_t len;
+{
+     register int bytes_written = 0;
+     register int result;
+     
+     while (bytes_written < len) {
+#	ifdef SOLARIS_THREADS
+	    result = syscall(SYS_write, fd, buf + bytes_written,
+	    			  	    len - bytes_written);
+#	else
+     	    result = write(fd, buf + bytes_written, len - bytes_written);
+#	endif
+	if (-1 == result) return(result);
+	bytes_written += result;
+    }
+    return(bytes_written);
+}
+#endif /* UN*X */
+
+#ifdef MSWIN32
+#   define WRITE(f, buf, len) (GC_set_files(), \
+			       GC_tmp = WriteFile((f), (buf), \
+			       			  (len), &GC_junk, NULL),\
+			       (GC_tmp? 1 : -1))
+#else
+#   if defined(OS2) || defined(MACOS)
+#   define WRITE(f, buf, len) (GC_set_files(), \
+			       GC_tmp = fwrite((buf), 1, (len), (f)), \
+			       fflush(f), GC_tmp)
+#   else
+#     define WRITE(f, buf, len) GC_write((f), (buf), (len))
+#   endif
+#endif
+
+/* A version of printf that is unlikely to call malloc, and is thus safer */
+/* to call from the collector in case malloc has been bound to GC_malloc. */
+/* Assumes that no more than 1023 characters are written at once.	  */
+/* Assumes that all arguments have been converted to something of the	  */
+/* same size as long, and that the format conversions expect something	  */
+/* of that size.							  */
+void GC_printf(format, a, b, c, d, e, f)
+char * format;
+long a, b, c, d, e, f;
+{
+    char buf[1025];
+    
+    if (GC_quiet) return;
+    buf[1024] = 0x15;
+    (void) sprintf(buf, format, a, b, c, d, e, f);
+    if (buf[1024] != 0x15) ABORT("GC_printf clobbered stack");
+    if (WRITE(GC_stdout, buf, strlen(buf)) < 0) ABORT("write to stdout failed");
+}
+
+void GC_err_printf(format, a, b, c, d, e, f)
+char * format;
+long a, b, c, d, e, f;
+{
+    char buf[1025];
+    
+    buf[1024] = 0x15;
+    (void) sprintf(buf, format, a, b, c, d, e, f);
+    if (buf[1024] != 0x15) ABORT("GC_err_printf clobbered stack");
+    if (WRITE(GC_stderr, buf, strlen(buf)) < 0) ABORT("write to stderr failed");
+}
+
+void GC_err_puts(s)
+char *s;
+{
+    if (WRITE(GC_stderr, s, strlen(s)) < 0) ABORT("write to stderr failed");
+}
+
+# if defined(__STDC__) || defined(__cplusplus)
+    void GC_default_warn_proc(char *msg, GC_word arg)
+# else
+    void GC_default_warn_proc(msg, arg)
+    char *msg;
+    GC_word arg;
+# endif
+{
+    GC_err_printf1(msg, (unsigned long)arg);
+}
+
+GC_warn_proc GC_current_warn_proc = GC_default_warn_proc;
+
+# if defined(__STDC__) || defined(__cplusplus)
+    GC_warn_proc GC_set_warn_proc(GC_warn_proc p)
+# else
+    GC_warn_proc GC_set_warn_proc(p)
+    GC_warn_proc p;
+# endif
+{
+    GC_warn_proc result;
+
+    LOCK();
+    result = GC_current_warn_proc;
+    GC_current_warn_proc = p;
+    UNLOCK();
+    return(result);
+}
+
+
+#ifndef PCR
+void GC_abort(msg)
+char * msg;
+{
+    GC_err_printf1("%s\n", msg);
+    (void) abort();
+}
+#endif
+
+# ifdef SRC_M3
+void GC_enable()
+{
+    GC_dont_gc--;
+}
+
+void GC_disable()
+{
+    GC_dont_gc++;
+}
+# endif
+
+#if !defined(NO_DEBUGGING)
+
+void GC_dump()
+{
+    GC_printf0("***Static roots:\n");
+    GC_print_static_roots();
+    GC_printf0("\n***Heap sections:\n");
+    GC_print_heap_sects();
+    GC_printf0("\n***Free blocks:\n");
+    GC_print_hblkfreelist();
+    GC_printf0("\n***Blocks in use:\n");
+    GC_print_block_list();
+}
+
+# endif /* NO_DEBUGGING */
diff --git a/src/mzscheme/gc/new_hblk.c b/src/mzscheme/gc/new_hblk.c
new file mode 100644
index 0000000..af657f4
--- /dev/null
+++ b/src/mzscheme/gc/new_hblk.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * This file contains the functions:
+ *	ptr_t GC_build_flXXX(h, old_fl)
+ *	void GC_new_hblk(n)
+ */
+/* Boehm, May 19, 1994 2:09 pm PDT */
+
+
+# include <stdio.h>
+# include "gc_priv.h"
+
+#ifndef SMALL_CONFIG
+/*
+ * Build a free list for size 1 objects inside hblk h.  Set the last link to
+ * be ofl.  Return a pointer tpo the first free list entry.
+ */
+ptr_t GC_build_fl1(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1);
+    
+    p[0] = (word)ofl;
+    p[1] = (word)(p);
+    p[2] = (word)(p+1);
+    p[3] = (word)(p+2);
+    p += 4;
+    for (; p < lim; p += 4) {
+        p[0] = (word)(p-1);
+        p[1] = (word)(p);
+        p[2] = (word)(p+1);
+        p[3] = (word)(p+2);
+    };
+    return((ptr_t)(p-1));
+}
+
+/* The same for size 2 cleared objects */
+ptr_t GC_build_fl_clear2(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1);
+    
+    p[0] = (word)ofl;
+    p[1] = 0;
+    p[2] = (word)p;
+    p[3] = 0;
+    p += 4;
+    for (; p < lim; p += 4) {
+        p[0] = (word)(p-2);
+        p[1] = 0;
+        p[2] = (word)p;
+        p[3] = 0;
+    };
+    return((ptr_t)(p-2));
+}
+
+/* The same for size 3 cleared objects */
+ptr_t GC_build_fl_clear3(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1) - 2;
+    
+    p[0] = (word)ofl;
+    p[1] = 0;
+    p[2] = 0;
+    p += 3;
+    for (; p < lim; p += 3) {
+        p[0] = (word)(p-3);
+        p[1] = 0;
+        p[2] = 0;
+    };
+    return((ptr_t)(p-3));
+}
+
+/* The same for size 4 cleared objects */
+ptr_t GC_build_fl_clear4(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1);
+    
+    p[0] = (word)ofl;
+    p[1] = 0;
+    p[2] = 0;
+    p[3] = 0;
+    p += 4;
+    for (; p < lim; p += 4) {
+        p[0] = (word)(p-4);
+        p[1] = 0;
+        p[2] = 0;
+        p[3] = 0;
+    };
+    return((ptr_t)(p-4));
+}
+
+/* The same for size 2 uncleared objects */
+ptr_t GC_build_fl2(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1);
+    
+    p[0] = (word)ofl;
+    p[2] = (word)p;
+    p += 4;
+    for (; p < lim; p += 4) {
+        p[0] = (word)(p-2);
+        p[2] = (word)p;
+    };
+    return((ptr_t)(p-2));
+}
+
+/* The same for size 4 uncleared objects */
+ptr_t GC_build_fl4(h, ofl)
+struct hblk *h;
+ptr_t ofl;
+{
+    register word * p = (word *)h;
+    register word * lim = (word *)(h + 1);
+    
+    p[0] = (word)ofl;
+    p[4] = (word)p;
+    p += 8;
+    for (; p < lim; p += 8) {
+        p[0] = (word)(p-4);
+        p[4] = (word)p;
+    };
+    return((ptr_t)(p-4));
+}
+
+#endif /* !SMALL_CONFIG */
+
+/*
+ * Allocate a new heapblock for small objects of size n.
+ * Add all of the heapblock's objects to the free list for objects
+ * of that size.
+ * Set all mark bits if objects are uncollectable.
+ * Will fail to do anything if we are out of memory.
+ */
+void GC_new_hblk(sz, kind)
+register word sz;
+int kind;
+{
+    register word *p,
+		  *prev;
+    word *last_object;		/* points to last object in new hblk	*/
+    register struct hblk *h;	/* the new heap block			*/
+    register bool clear = GC_obj_kinds[kind].ok_init;
+
+#   ifdef PRINTSTATS
+	if ((sizeof (struct hblk)) > HBLKSIZE) {
+	    ABORT("HBLK SZ inconsistency");
+        }
+#   endif
+
+  /* Allocate a new heap block */
+    h = GC_allochblk(sz, kind, 0);
+    if (h == 0) return;
+
+  /* Mark all objects if appropriate. */
+      if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(HDR(h));
+
+  /* Handle small objects sizes more efficiently.  For larger objects 	*/
+  /* the difference is less significant.				*/
+#  ifndef SMALL_CONFIG
+    switch (sz) {
+        case 1: GC_obj_kinds[kind].ok_freelist[1] =
+        	  GC_build_fl1(h, GC_obj_kinds[kind].ok_freelist[1]);
+        	return;
+        case 2: if (clear) {
+         	    GC_obj_kinds[kind].ok_freelist[2] =
+        	      GC_build_fl_clear2(h, GC_obj_kinds[kind].ok_freelist[2]);
+        	} else {
+        	    GC_obj_kinds[kind].ok_freelist[2] =
+        	      GC_build_fl2(h, GC_obj_kinds[kind].ok_freelist[2]);
+        	}
+        	return;
+        case 3: if (clear) {
+         	    GC_obj_kinds[kind].ok_freelist[3] =
+        	      GC_build_fl_clear3(h, GC_obj_kinds[kind].ok_freelist[3]);
+        	    return;
+        	} else {
+        	    /* It's messy to do better than the default here. */
+        	    break;
+        	}
+        case 4: if (clear) {
+        	    GC_obj_kinds[kind].ok_freelist[4] =
+        	      GC_build_fl_clear4(h, GC_obj_kinds[kind].ok_freelist[4]);
+        	} else {
+        	    GC_obj_kinds[kind].ok_freelist[4] =
+        	      GC_build_fl4(h, GC_obj_kinds[kind].ok_freelist[4]);
+        	}
+        	return;
+        default:
+        	break;
+    }
+#  endif /* !SMALL_CONFIG */
+    
+  /* Clear the page if necessary. */
+    if (clear) BZERO(h, HBLKSIZE);
+    
+  /* Add objects to free list */
+    p = &(h -> hb_body[sz]);	/* second object in *h	*/
+    prev = &(h -> hb_body[0]);       	/* One object behind p	*/
+    last_object = (word *)((char *)h + HBLKSIZE);
+    last_object -= sz;
+			    /* Last place for last object to start */
+
+  /* make a list of all objects in *h with head as last object */
+    while (p <= last_object) {
+      /* current object's link points to last object */
+        obj_link(p) = (ptr_t)prev;
+	prev = p;
+	p += sz;
+    }
+    p -= sz;			/* p now points to last object */
+
+  /*
+   * put p (which is now head of list of objects in *h) as first
+   * pointer in the appropriate free list for this size.
+   */
+      obj_link(h -> hb_body) = GC_obj_kinds[kind].ok_freelist[sz];
+      GC_obj_kinds[kind].ok_freelist[sz] = ((ptr_t)p);
+}
+
diff --git a/src/mzscheme/gc/obj_map.c b/src/mzscheme/gc/obj_map.c
new file mode 100644
index 0000000..ee00db0
--- /dev/null
+++ b/src/mzscheme/gc/obj_map.c
@@ -0,0 +1,142 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991, 1992 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 9, 1995 1:09 pm PDT */
+  
+/* Routines for maintaining maps describing heap block
+ * layouts for various object sizes.  Allows fast pointer validity checks
+ * and fast location of object start locations on machines (such as SPARC)
+ * with slow division.
+ */
+ 
+# include "gc_priv.h"
+
+char * GC_invalid_map = 0;
+
+/* Invalidate the object map associated with a block.	Free blocks	*/
+/* are identified by invalid maps.					*/
+void GC_invalidate_map(hhdr)
+hdr *hhdr;
+{
+    register int displ;
+    
+    if (GC_invalid_map == 0) {
+        GC_invalid_map = GC_scratch_alloc(MAP_SIZE);
+        if (GC_invalid_map == 0) {
+            GC_err_printf0(
+            	"Cant initialize GC_invalid_map: insufficient memory\n");
+            EXIT();
+        }
+        for (displ = 0; displ < HBLKSIZE; displ++) {
+            MAP_ENTRY(GC_invalid_map, displ) = OBJ_INVALID;
+        }
+    }
+    hhdr -> hb_map = GC_invalid_map;
+}
+
+/* Consider pointers that are offset bytes displaced from the beginning */
+/* of an object to be valid.                                            */
+
+# if defined(__STDC__) || defined(__cplusplus)
+    void GC_register_displacement(GC_word offset)
+# else
+    void GC_register_displacement(offset) 
+    GC_word offset;
+# endif
+{
+# ifndef ALL_INTERIOR_POINTERS
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    GC_register_displacement_inner(offset);
+    UNLOCK();
+    ENABLE_SIGNALS();
+# endif
+}
+
+void GC_register_displacement_inner(offset) 
+word offset;
+{
+# ifndef ALL_INTERIOR_POINTERS
+    register unsigned i;
+    
+    if (offset > MAX_OFFSET) {
+        ABORT("Bad argument to GC_register_displacement");
+    }
+    if (!GC_valid_offsets[offset]) {
+      GC_valid_offsets[offset] = TRUE;
+      GC_modws_valid_offsets[offset % sizeof(word)] = TRUE;
+      for (i = 0; i <= MAXOBJSZ; i++) {
+          if (GC_obj_map[i] != 0) {
+             if (i == 0) {
+               GC_obj_map[i][offset + HDR_BYTES] = (char)BYTES_TO_WORDS(offset);
+             } else {
+               register unsigned j;
+               register unsigned lb = WORDS_TO_BYTES(i);
+               
+               if (offset < lb) {
+                 for (j = offset + HDR_BYTES; j < HBLKSIZE; j += lb) {
+                   GC_obj_map[i][j] = (char)BYTES_TO_WORDS(offset);
+                 }
+               }
+             }
+          }
+      }
+    }
+# endif
+}
+
+
+/* Add a heap block map for objects of size sz to obj_map.	*/
+/* Return FALSE on failure.					*/
+bool GC_add_map_entry(sz)
+word sz;
+{
+    register unsigned obj_start;
+    register unsigned displ;
+    register char * new_map;
+    
+    if (sz > MAXOBJSZ) sz = 0;
+    if (GC_obj_map[sz] != 0) {
+        return(TRUE);
+    }
+    new_map = GC_scratch_alloc(MAP_SIZE);
+    if (new_map == 0) return(FALSE);
+#   ifdef PRINTSTATS
+        GC_printf1("Adding block map for size %lu\n", (unsigned long)sz);
+#   endif
+    for (displ = 0; displ < HBLKSIZE; displ++) {
+        MAP_ENTRY(new_map,displ) = OBJ_INVALID;
+    }
+    if (sz == 0) {
+        for(displ = 0; displ <= MAX_OFFSET; displ++) {
+            if (OFFSET_VALID(displ)) {
+                MAP_ENTRY(new_map,displ+HDR_BYTES) = BYTES_TO_WORDS(displ);
+            }
+        }
+    } else {
+        for (obj_start = HDR_BYTES;
+             obj_start + WORDS_TO_BYTES(sz) <= HBLKSIZE;
+             obj_start += WORDS_TO_BYTES(sz)) {
+             for (displ = 0; displ < WORDS_TO_BYTES(sz); displ++) {
+                 if (OFFSET_VALID(displ)) {
+                     MAP_ENTRY(new_map, obj_start + displ) =
+                     				BYTES_TO_WORDS(displ);
+                 }
+             }
+        }
+    }
+    GC_obj_map[sz] = new_map;
+    return(TRUE);
+}
diff --git a/src/mzscheme/gc/os_dep.c b/src/mzscheme/gc/os_dep.c
new file mode 100644
index 0000000..c8a1401
--- /dev/null
+++ b/src/mzscheme/gc/os_dep.c
@@ -0,0 +1,2156 @@
+/*
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, March 8, 1996 12:00 pm PST */
+
+# include "gc_priv.h"
+# if defined(LINUX) && !defined(POWERPC)
+#   include <linux/version.h>
+#   if (LINUX_VERSION_CODE <= 0x10400)
+      /* Ugly hack to get struct sigcontext_struct definition.  Required      */
+      /* for some early 1.3.X releases.  Will hopefully go away soon. */
+      /* in some later Linux releases, asm/sigcontext.h may have to   */
+      /* be included instead.                                         */
+#     define __KERNEL__
+#     include <asm/signal.h>
+#     undef __KERNEL__
+#   elif (LINUX_VERSION_CODE < 0x20020) /* MATTHEW: was 0x20100 */
+#     include <asm/sigcontext.h>
+#   endif
+# endif
+# if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS)
+#   include <sys/types.h>
+# endif
+# include <stdio.h>
+# include <signal.h>
+
+/* Blatantly OS dependent routines, except for those that are related 	*/
+/* dynamic loading.							*/
+
+# if !defined(THREADS) && !defined(STACKBOTTOM) && defined(HEURISTIC2)
+#   define NEED_FIND_LIMIT
+# endif
+
+# if defined(IRIX_THREADS)
+#   define NEED_FIND_LIMIT
+# endif
+
+# if (defined(SUNOS4) & defined(DYNAMIC_LOADING)) && !defined(PCR)
+#   define NEED_FIND_LIMIT
+# endif
+
+# if (defined(SVR4) || defined(AUX) || defined(DGUX)) && !defined(PCR)
+#   define NEED_FIND_LIMIT
+# endif
+
+#ifdef NEED_FIND_LIMIT
+#   include <setjmp.h>
+#endif
+
+#ifdef FREEBSD
+#  include <machine/trap.h>
+#endif
+
+#ifdef AMIGA
+# include <proto/exec.h>
+# include <proto/dos.h>
+# include <dos/dosextens.h>
+# include <workbench/startup.h>
+#endif
+
+#ifdef MSWIN32
+# define WIN32_LEAN_AND_MEAN
+# define NOSERVICE
+# include <windows.h>
+#endif
+
+#ifdef MACOS
+# include <Processes.h>
+#endif
+
+#ifdef IRIX5
+# include <sys/uio.h>
+# include <sys/types.h>
+# include <sys/mman.h>
+# include <sys/stat.h>
+# include <fcntl.h>
+# include <malloc.h>	/* for locking */
+#endif
+
+#ifdef SUNOS5SIGS
+# include <sys/siginfo.h>
+# undef setjmp
+# undef longjmp
+# define setjmp(env) sigsetjmp(env, 1)
+# define longjmp(env, val) siglongjmp(env, val)
+# define jmp_buf sigjmp_buf
+#endif
+
+#ifdef DJGPP
+  /* Apparently necessary for djgpp 2.01.  May casuse problems with	*/
+  /* other versions.							*/
+  typedef caddr_t long unsigned int;
+#endif
+
+#ifdef PCR
+# include "il/PCR_IL.h"
+# include "th/PCR_ThCtl.h"
+# include "mm/PCR_MM.h"
+#endif
+
+#if defined(PROT_EXEC) && !defined(NO_EXECUTE_PERMISSION)
+# define OPT_PROT_EXEC PROT_EXEC
+#else
+# define OPT_PROT_EXEC 0
+#endif
+
+# ifdef OS2
+
+# include <stddef.h>
+
+# ifndef __IBMC__ /* e.g. EMX */
+
+struct exe_hdr {
+    unsigned short      magic_number;
+    unsigned short      padding[29];
+    long                new_exe_offset;
+};
+
+#define E_MAGIC(x)      (x).magic_number
+#define EMAGIC          0x5A4D  
+#define E_LFANEW(x)     (x).new_exe_offset
+
+struct e32_exe {
+    unsigned char       magic_number[2]; 
+    unsigned char       byte_order; 
+    unsigned char       word_order; 
+    unsigned long       exe_format_level;
+    unsigned short      cpu;       
+    unsigned short      os;
+    unsigned long       padding1[13];
+    unsigned long       object_table_offset;
+    unsigned long       object_count;    
+    unsigned long       padding2[31];
+};
+
+#define E32_MAGIC1(x)   (x).magic_number[0]
+#define E32MAGIC1       'L'
+#define E32_MAGIC2(x)   (x).magic_number[1]
+#define E32MAGIC2       'X'
+#define E32_BORDER(x)   (x).byte_order
+#define E32LEBO         0
+#define E32_WORDER(x)   (x).word_order
+#define E32LEWO         0
+#define E32_CPU(x)      (x).cpu
+#define E32CPU286       1
+#define E32_OBJTAB(x)   (x).object_table_offset
+#define E32_OBJCNT(x)   (x).object_count
+
+struct o32_obj {
+    unsigned long       size;  
+    unsigned long       base;
+    unsigned long       flags;  
+    unsigned long       pagemap;
+    unsigned long       mapsize; 
+    unsigned long       reserved;
+};
+
+#define O32_FLAGS(x)    (x).flags
+#define OBJREAD         0x0001L
+#define OBJWRITE        0x0002L
+#define OBJINVALID      0x0080L
+#define O32_SIZE(x)     (x).size
+#define O32_BASE(x)     (x).base
+
+# else  /* IBM's compiler */
+
+/* A kludge to get around what appears to be a header file bug */
+# ifndef WORD
+#   define WORD unsigned short
+# endif
+# ifndef DWORD
+#   define DWORD unsigned long
+# endif
+
+# define EXE386 1
+# include <newexe.h>
+# include <exe386.h>
+
+# endif  /* __IBMC__ */
+
+# define INCL_DOSEXCEPTIONS
+# define INCL_DOSPROCESS
+# define INCL_DOSERRORS
+# define INCL_DOSMODULEMGR
+# define INCL_DOSMEMMGR
+# include <os2.h>
+
+
+/* Disable and enable signals during nontrivial allocations	*/
+
+void GC_disable_signals(void)
+{
+    ULONG nest;
+    
+    DosEnterMustComplete(&nest);
+    if (nest != 1) ABORT("nested GC_disable_signals");
+}
+
+void GC_enable_signals(void)
+{
+    ULONG nest;
+    
+    DosExitMustComplete(&nest);
+    if (nest != 0) ABORT("GC_enable_signals");
+}
+
+
+# else
+
+/* MATTHEW: !RS6000 */
+#  if !defined(PCR) && !defined(AMIGA) && !defined(MSWIN32) \
+      && !defined(MACOS) && !defined(DJGPP) && !defined(RS6000)
+
+#   if defined(sigmask) && !defined(UTS4)
+	/* Use the traditional BSD interface */
+#	define SIGSET_T int
+#	define SIG_DEL(set, signal) (set) &= ~(sigmask(signal))
+#	define SIG_FILL(set)  (set) = 0x7fffffff
+    	  /* Setting the leading bit appears to provoke a bug in some	*/
+    	  /* longjmp implementations.  Most systems appear not to have	*/
+    	  /* a signal 32.						*/
+#	define SIGSETMASK(old, new) (old) = sigsetmask(new)
+#   else
+	/* Use POSIX/SYSV interface	*/
+#	define SIGSET_T sigset_t
+#	define SIG_DEL(set, signal) sigdelset(&(set), (signal))
+#	define SIG_FILL(set) sigfillset(&set)
+#	define SIGSETMASK(old, new) sigprocmask(SIG_SETMASK, &(new), &(old))
+#   endif
+
+static bool mask_initialized = FALSE;
+
+static SIGSET_T new_mask;
+
+static SIGSET_T old_mask;
+
+static SIGSET_T dummy;
+
+#if defined(PRINTSTATS) && !defined(THREADS)
+# define CHECK_SIGNALS
+  int GC_sig_disabled = 0;
+#endif
+
+void GC_disable_signals()
+{
+    if (!mask_initialized) {
+    	SIG_FILL(new_mask);
+
+	SIG_DEL(new_mask, SIGSEGV);
+	SIG_DEL(new_mask, SIGILL);
+	SIG_DEL(new_mask, SIGQUIT);
+#	ifdef SIGBUS
+	    SIG_DEL(new_mask, SIGBUS);
+#	endif
+#	ifdef SIGIOT
+	    SIG_DEL(new_mask, SIGIOT);
+#	endif
+#	ifdef SIGEMT
+	    SIG_DEL(new_mask, SIGEMT);
+#	endif
+#	ifdef SIGTRAP
+	    SIG_DEL(new_mask, SIGTRAP);
+#	endif 
+	mask_initialized = TRUE;
+    }
+#   ifdef CHECK_SIGNALS
+	if (GC_sig_disabled != 0) ABORT("Nested disables");
+	GC_sig_disabled++;
+#   endif
+    SIGSETMASK(old_mask,new_mask);
+}
+
+void GC_enable_signals()
+{
+#   ifdef CHECK_SIGNALS
+	if (GC_sig_disabled != 1) ABORT("Unmatched enable");
+	GC_sig_disabled--;
+#   endif
+    SIGSETMASK(dummy,old_mask);
+}
+
+#  endif  /* !PCR */
+
+# endif /*!OS/2 */
+
+/*
+ * Find the base of the stack.
+ * Used only in single-threaded environment.
+ * With threads, GC_mark_roots needs to know how to do this.
+ * Called with allocator lock held.
+ */
+# ifdef MSWIN32
+
+/* Get the page size.	*/
+word GC_page_size = 0;
+
+word GC_getpagesize()
+{
+    SYSTEM_INFO sysinfo;
+    
+    if (GC_page_size == 0) {
+        GetSystemInfo(&sysinfo);
+        GC_page_size = sysinfo.dwPageSize;
+    }
+    return(GC_page_size);
+}
+
+# define is_writable(prot) ((prot) == PAGE_READWRITE \
+			    || (prot) == PAGE_WRITECOPY \
+			    || (prot) == PAGE_EXECUTE_READWRITE \
+			    || (prot) == PAGE_EXECUTE_WRITECOPY)
+/* Return the number of bytes that are writable starting at p.	*/
+/* The pointer p is assumed to be page aligned.			*/
+/* If base is not 0, *base becomes the beginning of the 	*/
+/* allocation region containing p.				*/
+word GC_get_writable_length(ptr_t p, ptr_t *base)
+{
+    MEMORY_BASIC_INFORMATION buf;
+    word result;
+    word protect;
+    
+    result = VirtualQuery(p, &buf, sizeof(buf));
+    if (result != sizeof(buf)) ABORT("Weird VirtualQuery result");
+    if (base != 0) *base = (ptr_t)(buf.AllocationBase);
+    protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE));
+    if (!is_writable(protect)) {
+        return(0);
+    }
+    if (buf.State != MEM_COMMIT) return(0);
+    return(buf.RegionSize);
+}
+
+ptr_t GC_get_stack_base()
+{
+    int dummy;
+    ptr_t sp = (ptr_t)(&dummy);
+    ptr_t trunc_sp = (ptr_t)((word)sp & ~(GC_getpagesize() - 1));
+    word size = GC_get_writable_length(trunc_sp, 0);
+   
+    return(trunc_sp + size);
+}
+
+
+# else
+
+# ifdef OS2
+
+ptr_t GC_get_stack_base()
+{
+    PTIB ptib;
+    PPIB ppib;
+    
+    if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
+    	GC_err_printf0("DosGetInfoBlocks failed\n");
+    	ABORT("DosGetInfoBlocks failed\n");
+    }
+    return((ptr_t)(ptib -> tib_pstacklimit));
+}
+
+# else
+
+# ifdef AMIGA
+
+ptr_t GC_get_stack_base()
+{
+    extern struct WBStartup *_WBenchMsg;
+    extern long __base;
+    extern long __stack;
+    struct Task *task;
+    struct Process *proc;
+    struct CommandLineInterface *cli;
+    long size;
+
+    if ((task = FindTask(0)) == 0) {
+	GC_err_puts("Cannot find own task structure\n");
+	ABORT("task missing");
+    }
+    proc = (struct Process *)task;
+    cli = BADDR(proc->pr_CLI);
+
+    if (_WBenchMsg != 0 || cli == 0) {
+	size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
+    } else {
+	size = cli->cli_DefaultStack * 4;
+    }
+    return (ptr_t)(__base + GC_max(size, __stack));
+}
+
+# else
+
+
+
+# ifdef NEED_FIND_LIMIT
+  /* Some tools to implement HEURISTIC2	*/
+#   define MIN_PAGE_SIZE 256	/* Smallest conceivable page size, bytes */
+    /* static */ jmp_buf GC_jmp_buf;
+    
+    /*ARGSUSED*/
+    void GC_fault_handler(sig)
+    int sig;
+    {
+        longjmp(GC_jmp_buf, 1);
+    }
+
+#   ifdef __STDC__
+	typedef void (*handler)(int);
+#   else
+	typedef void (*handler)();
+#   endif
+
+#   ifdef SUNOS5SIGS
+	static struct sigaction oldact;
+#   else
+        static handler old_segv_handler, old_bus_handler;
+#   endif
+    
+    void GC_setup_temporary_fault_handler()
+    {
+#	ifdef SUNOS5SIGS
+	  struct sigaction	act;
+
+	  act.sa_handler	= GC_fault_handler;
+          act.sa_flags          = SA_RESTART | SA_SIGINFO | SA_NODEFER;
+          /* The presence of SA_NODEFER represents yet another gross    */
+          /* hack.  Under Solaris 2.3, siglongjmp doesn't appear to     */
+          /* interact correctly with -lthread.  We hide the confusion   */
+          /* by making sure that signal handling doesn't affect the     */
+          /* signal mask.                                               */
+
+	  (void) sigemptyset(&act.sa_mask);
+	  (void) sigaction(SIGSEGV, &act, &oldact);
+#	else
+    	  old_segv_handler = signal(SIGSEGV, GC_fault_handler);
+#	  ifdef SIGBUS
+	    old_bus_handler = signal(SIGBUS, GC_fault_handler);
+#	  endif
+#	endif
+    }
+    
+    void GC_reset_fault_handler()
+    {
+#       ifdef SUNOS5SIGS
+	  (void) sigaction(SIGSEGV, &oldact, 0);
+#       else
+  	  (void) signal(SIGSEGV, old_segv_handler);
+#	  ifdef SIGBUS
+	    (void) signal(SIGBUS, old_bus_handler);
+#	  endif
+#       endif
+    }
+
+    /* Return the first nonaddressible location > p (up) or 	*/
+    /* the smallest location q s.t. [q,p] is addressible (!up).	*/
+    ptr_t GC_find_limit(p, up)
+    ptr_t p;
+    bool up;
+    {
+        static VOLATILE ptr_t result;
+    		/* Needs to be static, since otherwise it may not be	*/
+    		/* preserved across the longjmp.  Can safely be 	*/
+    		/* static since it's only called once, with the		*/
+    		/* allocation lock held.				*/
+
+
+	GC_setup_temporary_fault_handler();
+	if (setjmp(GC_jmp_buf) == 0) {
+	    result = (ptr_t)(((word)(p))
+			      & ~(MIN_PAGE_SIZE-1));
+	    for (;;) {
+ 	        if (up) {
+		    result += MIN_PAGE_SIZE;
+ 	        } else {
+		    result -= MIN_PAGE_SIZE;
+ 	        }
+		GC_noop1((word)(*result));
+	    }
+	}
+	GC_reset_fault_handler();
+ 	if (!up) {
+	    result += MIN_PAGE_SIZE;
+ 	}
+	return(result);
+    }
+# endif
+
+
+ptr_t GC_get_stack_base()
+{
+    word dummy;
+    ptr_t result;
+
+#   define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
+
+#   ifdef STACKBOTTOM
+	return(STACKBOTTOM);
+#   else
+#	ifdef HEURISTIC1
+#	   ifdef STACK_GROWS_DOWN
+	     result = (ptr_t)((((word)(&dummy))
+	     		       + STACKBOTTOM_ALIGNMENT_M1)
+			      & ~STACKBOTTOM_ALIGNMENT_M1);
+#	   else
+	     result = (ptr_t)(((word)(&dummy))
+			      & ~STACKBOTTOM_ALIGNMENT_M1);
+#	   endif
+#	endif /* HEURISTIC1 */
+#	ifdef HEURISTIC2
+#	    ifdef STACK_GROWS_DOWN
+		result = GC_find_limit((ptr_t)(&dummy), TRUE);
+#           	ifdef HEURISTIC2_LIMIT
+		    if (result > HEURISTIC2_LIMIT
+		        && (ptr_t)(&dummy) < HEURISTIC2_LIMIT) {
+		            result = HEURISTIC2_LIMIT;
+		    }
+#	        endif
+#	    else
+		result = GC_find_limit((ptr_t)(&dummy), FALSE);
+#           	ifdef HEURISTIC2_LIMIT
+		    if (result < HEURISTIC2_LIMIT
+		        && (ptr_t)(&dummy) > HEURISTIC2_LIMIT) {
+		            result = HEURISTIC2_LIMIT;
+		    }
+#	        endif
+#	    endif
+
+#	endif /* HEURISTIC2 */
+    	return(result);
+#   endif /* STACKBOTTOM */
+}
+
+# endif /* ! AMIGA */
+# endif /* ! OS2 */
+# endif /* ! MSWIN32 */
+
+/*
+ * Register static data segment(s) as roots.
+ * If more data segments are added later then they need to be registered
+ * add that point (as we do with SunOS dynamic loading),
+ * or GC_mark_roots needs to check for them (as we do with PCR).
+ * Called with allocator lock held.
+ */
+
+# ifdef OS2
+
+void GC_register_data_segments()
+{
+    PTIB ptib;
+    PPIB ppib;
+    HMODULE module_handle;
+#   define PBUFSIZ 512
+    UCHAR path[PBUFSIZ];
+    FILE * myexefile;
+    struct exe_hdr hdrdos;	/* MSDOS header.	*/
+    struct e32_exe hdr386;	/* Real header for my executable */
+    struct o32_obj seg;	/* Currrent segment */
+    int nsegs;
+    
+    
+    if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
+    	GC_err_printf0("DosGetInfoBlocks failed\n");
+    	ABORT("DosGetInfoBlocks failed\n");
+    }
+    module_handle = ppib -> pib_hmte;
+    if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) {
+    	GC_err_printf0("DosQueryModuleName failed\n");
+    	ABORT("DosGetInfoBlocks failed\n");
+    }
+    myexefile = fopen(path, "rb");
+    if (myexefile == 0) {
+        GC_err_puts("Couldn't open executable ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Failed to open executable\n");
+    }
+    if (fread((char *)(&hdrdos), 1, sizeof hdrdos, myexefile) < sizeof hdrdos) {
+        GC_err_puts("Couldn't read MSDOS header from ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Couldn't read MSDOS header");
+    }
+    if (E_MAGIC(hdrdos) != EMAGIC) {
+        GC_err_puts("Executable has wrong DOS magic number: ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Bad DOS magic number");
+    }
+    if (fseek(myexefile, E_LFANEW(hdrdos), SEEK_SET) != 0) {
+        GC_err_puts("Seek to new header failed in ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Bad DOS magic number");
+    }
+    if (fread((char *)(&hdr386), 1, sizeof hdr386, myexefile) < sizeof hdr386) {
+        GC_err_puts("Couldn't read MSDOS header from ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Couldn't read OS/2 header");
+    }
+    if (E32_MAGIC1(hdr386) != E32MAGIC1 || E32_MAGIC2(hdr386) != E32MAGIC2) {
+        GC_err_puts("Executable has wrong OS/2 magic number:");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Bad OS/2 magic number");
+    }
+    if ( E32_BORDER(hdr386) != E32LEBO || E32_WORDER(hdr386) != E32LEWO) {
+        GC_err_puts("Executable %s has wrong byte order: ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Bad byte order");
+    }
+    if ( E32_CPU(hdr386) == E32CPU286) {
+        GC_err_puts("GC can't handle 80286 executables: ");
+        GC_err_puts(path); GC_err_puts("\n");
+        EXIT();
+    }
+    if (fseek(myexefile, E_LFANEW(hdrdos) + E32_OBJTAB(hdr386),
+    	      SEEK_SET) != 0) {
+        GC_err_puts("Seek to object table failed: ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Seek to object table failed");
+    }
+    for (nsegs = E32_OBJCNT(hdr386); nsegs > 0; nsegs--) {
+      int flags;
+      if (fread((char *)(&seg), 1, sizeof seg, myexefile) < sizeof seg) {
+        GC_err_puts("Couldn't read obj table entry from ");
+        GC_err_puts(path); GC_err_puts("\n");
+        ABORT("Couldn't read obj table entry");
+      }
+      flags = O32_FLAGS(seg);
+      if (!(flags & OBJWRITE)) continue;
+      if (!(flags & OBJREAD)) continue;
+      if (flags & OBJINVALID) {
+          GC_err_printf0("Object with invalid pages?\n");
+          continue;
+      } 
+      GC_add_roots_inner(O32_BASE(seg), O32_BASE(seg)+O32_SIZE(seg), FALSE);
+    }
+}
+
+# else
+
+# ifdef MSWIN32
+  /* Unfortunately, we have to handle win32s very differently from NT, 	*/
+  /* Since VirtualQuery has very different semantics.  In particular,	*/
+  /* under win32s a VirtualQuery call on an unmapped page returns an	*/
+  /* invalid result.  Under GC_register_data_segments is a noop and	*/
+  /* all real work is done by GC_register_dynamic_libraries.  Under	*/
+  /* win32s, we cannot find the data segments associated with dll's.	*/
+  /* We rgister the main data segment here.				*/
+  bool GC_win32s = FALSE;	/* We're running under win32s.	*/
+  
+  bool GC_is_win32s()
+  {
+      DWORD v = GetVersion();
+      
+      /* Check that this is not NT, and Windows major version <= 3	*/
+      return ((v & 0x80000000) && (v & 0xff) <= 3);
+  }
+  
+  void GC_init_win32()
+  {
+      GC_win32s = GC_is_win32s();
+  }
+  
+  /* Return the smallest address a such that VirtualQuery		*/
+  /* returns correct results for all addresses between a and start.	*/
+  /* Assumes VirtualQuery returns correct information for start.	*/
+  ptr_t GC_least_described_address(ptr_t start)
+  {  
+    MEMORY_BASIC_INFORMATION buf;
+    SYSTEM_INFO sysinfo;
+    DWORD result;
+    LPVOID limit;
+    ptr_t p;
+    LPVOID q;
+    
+    GetSystemInfo(&sysinfo);
+    limit = sysinfo.lpMinimumApplicationAddress;
+    p = (ptr_t)((word)start & ~(GC_getpagesize() - 1));
+    for (;;) {
+    	q = (LPVOID)(p - GC_getpagesize());
+    	if ((ptr_t)q > (ptr_t)p /* underflow */ || q < limit) break;
+    	result = VirtualQuery(q, &buf, sizeof(buf));
+    	if (result != sizeof(buf) || buf.AllocationBase == 0) break;
+    	p = (ptr_t)(buf.AllocationBase);
+    }
+    return(p);
+  }
+  
+  /* Is p the start of either the malloc heap, or of one of our */
+  /* heap sections?						*/
+  bool GC_is_heap_base (ptr_t p)
+  {
+     
+     register unsigned i;
+     
+#    ifndef REDIRECT_MALLOC
+       static ptr_t malloc_heap_pointer = 0;
+     
+       if (0 == malloc_heap_pointer) {
+         MEMORY_BASIC_INFORMATION buf;
+         register DWORD result = VirtualQuery(malloc(1), &buf, sizeof(buf));
+         
+         if (result != sizeof(buf)) {
+             ABORT("Weird VirtualQuery result");
+         }
+         malloc_heap_pointer = (ptr_t)(buf.AllocationBase);
+       }
+       if (p == malloc_heap_pointer) return(TRUE);
+#    endif
+     for (i = 0; i < GC_n_heap_bases; i++) {
+         if (GC_heap_bases[i] == p) return(TRUE);
+     }
+     return(FALSE);
+  }
+  
+  void GC_register_root_section(ptr_t static_root)
+  {
+      MEMORY_BASIC_INFORMATION buf;
+      SYSTEM_INFO sysinfo;
+      DWORD result;
+      DWORD protect;
+      LPVOID p;
+      char * base;
+      char * limit, * new_limit;
+    
+      if (!GC_win32s) return;
+      p = base = limit = GC_least_described_address(static_root);
+      GetSystemInfo(&sysinfo);
+      while (p < sysinfo.lpMaximumApplicationAddress) {
+        result = VirtualQuery(p, &buf, sizeof(buf));
+        if (result != sizeof(buf) || buf.AllocationBase == 0
+            || GC_is_heap_base(buf.AllocationBase)) break;
+        new_limit = (char *)p + buf.RegionSize;
+        protect = buf.Protect;
+        if (buf.State == MEM_COMMIT
+            && is_writable(protect)) {
+            if ((char *)p == limit) {
+                limit = new_limit;
+            } else {
+                if (base != limit) GC_add_roots_inner(base, limit, FALSE);
+                base = p;
+                limit = new_limit;
+            }
+        }
+        if (p > (LPVOID)new_limit /* overflow */) break;
+        p = (LPVOID)new_limit;
+      }
+      if (base != limit) GC_add_roots_inner(base, limit, FALSE);
+  }
+  
+  void GC_register_data_segments()
+  {
+      static char dummy;
+      
+      GC_register_root_section((ptr_t)(&dummy));
+  }
+# else
+# ifdef AMIGA
+
+  void GC_register_data_segments()
+  {
+    extern struct WBStartup *_WBenchMsg;
+    struct Process	*proc;
+    struct CommandLineInterface *cli;
+    BPTR myseglist;
+    ULONG *data;
+
+    if ( _WBenchMsg != 0 ) {
+	if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
+	    GC_err_puts("No seglist from workbench\n");
+	    return;
+	}
+    } else {
+	if ((proc = (struct Process *)FindTask(0)) == 0) {
+	    GC_err_puts("Cannot find process structure\n");
+	    return;
+	}
+	if ((cli = BADDR(proc->pr_CLI)) == 0) {
+	    GC_err_puts("No CLI\n");
+	    return;
+	}
+	if ((myseglist = cli->cli_Module) == 0) {
+	    GC_err_puts("No seglist from CLI\n");
+	    return;
+	}
+    }
+
+    for (data = (ULONG *)BADDR(myseglist); data != 0;
+         data = (ULONG *)BADDR(data[0])) {
+#        ifdef AMIGA_SKIP_SEG
+           if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
+           ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
+#	 else
+      	   {
+#	 endif /* AMIGA_SKIP_SEG */
+          GC_add_roots_inner((char *)&data[1],
+          		     ((char *)&data[1]) + data[-1], FALSE);
+         }
+    }
+  }
+
+
+# else
+
+# if (defined(SVR4) || defined(AUX) || defined(DGUX)) && !defined(PCR)
+char * GC_SysVGetDataStart(max_page_size, etext_addr)
+int max_page_size;
+int * etext_addr;
+{
+    word text_end = ((word)(etext_addr) + sizeof(word) - 1)
+    		    & ~(sizeof(word) - 1);
+    	/* etext rounded to word boundary	*/
+    word next_page = ((text_end + (word)max_page_size - 1)
+    		      & ~((word)max_page_size - 1));
+    word page_offset = (text_end & ((word)max_page_size - 1));
+    VOLATILE char * result = (char *)(next_page + page_offset);
+    /* Note that this isnt equivalent to just adding		*/
+    /* max_page_size to &etext if &etext is at a page boundary	*/
+    
+    GC_setup_temporary_fault_handler();
+    if (setjmp(GC_jmp_buf) == 0) {
+    	/* Try writing to the address.	*/
+    	*result = *result;
+    } else {
+    	/* We got here via a longjmp.  The address is not readable.	*/
+    	/* This is known to happen under Solaris 2.4 + gcc, which place	*/
+    	/* string constants in the text segment, but after etext.	*/
+    	/* Use plan B.  Note that we now know there is a gap between	*/
+    	/* text and data segments, so plan A bought us something.	*/
+    	result = (char *)GC_find_limit((ptr_t)(DATAEND) - MIN_PAGE_SIZE, FALSE);
+    }
+    GC_reset_fault_handler();
+    return((char *)result);
+}
+# endif
+
+
+void GC_register_data_segments()
+{
+#   if !defined(PCR) && !defined(SRC_M3) && !defined(NEXT) && !defined(MACOS)
+#     if defined(REDIRECT_MALLOC) && defined(SOLARIS_THREADS)
+	/* As of Solaris 2.3, the Solaris threads implementation	*/
+	/* allocates the data structure for the initial thread with	*/
+	/* sbrk at process startup.  It needs to be scanned, so that	*/
+	/* we don't lose some malloc allocated data structures		*/
+	/* hanging from it.  We're on thin ice here ...			*/
+        extern caddr_t sbrk();
+
+	GC_add_roots_inner(DATASTART, (char *)sbrk(0), FALSE);
+#     else
+	GC_add_roots_inner(DATASTART, (char *)(DATAEND), FALSE);
+#     endif
+#   endif
+#   if !defined(PCR) && defined(NEXT)
+      GC_add_roots_inner(DATASTART, (char *) get_end(), FALSE);
+#   endif
+#   if defined(MACOS)
+    {
+#   if defined(THINK_C)
+	extern void* GC_MacGetDataStart(void);
+	/* globals begin above stack and end at a5. */
+	GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
+			   (ptr_t)LMGetCurrentA5(), FALSE);
+#   else
+#     if defined(__MWERKS__)
+#       if !__POWERPC__
+	  extern void* GC_MacGetDataStart(void);
+	  /* globals begin above stack and end at a5. */
+	  GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
+          		     (ptr_t)LMGetCurrentA5(), FALSE);
+#       else
+	  extern char __data_start__[], __data_end__[];
+	  GC_add_roots_inner((ptr_t)&__data_start__,
+	  		     (ptr_t)&__data_end__, FALSE);
+#       endif /* __POWERPC__ */
+#     endif /* __MWERKS__ */
+#   endif /* !THINK_C */
+    }
+#   endif /* MACOS */
+
+    /* Dynamic libraries are added at every collection, since they may  */
+    /* change.								*/
+}
+
+# endif  /* ! AMIGA */
+# endif  /* ! MSWIN32 */
+# endif  /* ! OS2 */
+
+/*
+ * Auxiliary routines for obtaining memory from OS.
+ */
+ 
+# if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \
+	&& !defined(MSWIN32) && !defined(MACOS)
+
+extern caddr_t sbrk();
+# ifdef __STDC__
+#   define SBRK_ARG_T ptrdiff_t
+# else
+#   define SBRK_ARG_T int
+# endif
+
+# ifdef RS6000
+/* The compiler seems to generate speculative reads one past the end of	*/
+/* an allocated object.  Hence we need to make sure that the page 	*/
+/* following the last heap page is also mapped.				*/
+ptr_t GC_unix_get_mem(bytes)
+word bytes;
+{
+    caddr_t cur_brk = sbrk(0);
+    caddr_t result;
+    SBRK_ARG_T lsbs = (word)cur_brk & (HBLKSIZE-1);
+    static caddr_t my_brk_val = 0;
+    
+    if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
+    if (lsbs != 0) {
+        if(sbrk(HBLKSIZE - lsbs) == (caddr_t)(-1)) return(0);
+    }
+    if (cur_brk == my_brk_val) {
+    	/* Use the extra block we allocated last time. */
+        result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
+        if (result == (caddr_t)(-1)) return(0);
+        result -= HBLKSIZE;
+    } else {
+        result = (ptr_t)sbrk(HBLKSIZE + (SBRK_ARG_T)bytes);
+        if (result == (caddr_t)(-1)) return(0);
+    }
+    my_brk_val = result + bytes + HBLKSIZE;	/* Always HBLKSIZE aligned */
+    return((ptr_t)result);
+}
+
+#else  /* Not RS6000 */
+
+#if defined(USE_MMAP)
+/* Tested only under IRIX5 */
+
+ptr_t GC_unix_get_mem(bytes)
+word bytes;
+{
+    static bool initialized = FALSE;
+    static int fd;
+    void *result;
+    static ptr_t last_addr = HEAP_START;
+    static size_t page_size;
+
+    if (!initialized) {
+	fd = open("/dev/zero", O_RDONLY);
+	page_size = getpagesize();
+	initialized = TRUE;
+    }
+    result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC,
+		  MAP_PRIVATE | MAP_FIXED, fd, 0/* offset */);
+    if (result == MAP_FAILED) return(0);
+    last_addr = (ptr_t)result + bytes + page_size - 1;
+    last_addr = (ptr_t)((word)last_addr & ~(page_size - 1));
+    return((ptr_t)result);
+}
+
+#else /* Not RS6000, USE_MMAP */
+ptr_t GC_unix_get_mem(bytes)
+word bytes;
+{
+#if defined(sun)
+  /* MATTHEW: My SunOS man page says not use to sbrk() with malloc().
+     Xt definitely breaks if I use sbrk. */
+  ptr_t mem;
+
+  mem = malloc(bytes + HBLKSIZE - 1);
+
+  if ((long)mem % HBLKSIZE)
+    return mem + (HBLKSIZE - ((long)mem % HBLKSIZE));
+  else
+    return mem;
+#else
+  caddr_t result;
+# ifdef IRIX5
+    /* Bare sbrk isn't thread safe.  Play by malloc rules.	*/
+    /* The equivalent may be needed on other systems as well. 	*/
+    __LOCK_MALLOC();
+# endif
+  {
+    caddr_t cur_brk = sbrk(0);
+    SBRK_ARG_T lsbs = (word)cur_brk & (HBLKSIZE-1);
+    
+    if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
+    if (lsbs != 0) {
+        if(sbrk(HBLKSIZE - lsbs) == (caddr_t)(-1)) return(0);
+    }
+    result = sbrk((SBRK_ARG_T)bytes);
+    if (result == (caddr_t)(-1)) result = 0;
+  }
+# ifdef IRIX5
+    __UNLOCK_MALLOC();
+# endif
+  return((ptr_t)result);
+#endif
+}
+
+#endif /* Not USE_MMAP */
+#endif /* Not RS6000 */
+
+# endif /* UN*X */
+
+# ifdef OS2
+
+void * os2_alloc(size_t bytes)
+{
+    void * result;
+
+    if (DosAllocMem(&result, bytes, PAG_EXECUTE | PAG_READ |
+    				    PAG_WRITE | PAG_COMMIT)
+		    != NO_ERROR) {
+	return(0);
+    }
+    if (result == 0) return(os2_alloc(bytes));
+    return(result);
+}
+
+# endif /* OS2 */
+
+
+# ifdef MSWIN32
+word GC_n_heap_bases = 0;
+
+ptr_t GC_win32_get_mem(bytes)
+word bytes;
+{
+    ptr_t result;
+    
+    /* MATTHEW: VirtualAlloc works fine for me in Win32s */
+    if (0 && GC_win32s) {
+    	/* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE.	*/
+    	/* There are also unconfirmed rumors of other		*/
+    	/* problems, so we dodge the issue.			*/
+        result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE);
+        result = (ptr_t)(((word)result + HBLKSIZE) & ~(HBLKSIZE-1));
+    } else {
+        /* MATTHEW: PAGE_READWRITE works better for MrEd (because I don't need execute?) */
+        result = (ptr_t) VirtualAlloc(NULL, bytes,
+    				      MEM_COMMIT | MEM_RESERVE,
+				      PAGE_READWRITE
+    				      /* PAGE_EXECUTE_READWRITE */);
+    }
+    if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
+    	/* If I read the documentation correctly, this can	*/
+    	/* only happen if HBLKSIZE > 64k or not a power of 2.	*/
+    if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
+    GC_heap_bases[GC_n_heap_bases++] = result;
+    return(result);			  
+}
+
+# endif
+
+/* Routine for pushing any additional roots.  In THREADS 	*/
+/* environment, this is also responsible for marking from 	*/
+/* thread stacks.  In the SRC_M3 case, it also handles		*/
+/* global variables.						*/
+#ifndef THREADS
+void (*GC_push_other_roots)() = 0;
+#else /* THREADS */
+
+# ifdef PCR
+PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy)
+{
+    struct PCR_ThCtl_TInfoRep info;
+    PCR_ERes result;
+    
+    info.ti_stkLow = info.ti_stkHi = 0;
+    result = PCR_ThCtl_GetInfo(t, &info);
+    GC_push_all_stack((ptr_t)(info.ti_stkLow), (ptr_t)(info.ti_stkHi));
+    return(result);
+}
+
+/* Push the contents of an old object. We treat this as stack	*/
+/* data only becasue that makes it robust against mark stack	*/
+/* overflow.							*/
+PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data)
+{
+    GC_push_all_stack((ptr_t)p, (ptr_t)p + size);
+    return(PCR_ERes_okay);
+}
+
+
+void GC_default_push_other_roots()
+{
+    /* Traverse data allocated by previous memory managers.		*/
+	{
+	  extern struct PCR_MM_ProcsRep * GC_old_allocator;
+	  
+	  if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false,
+	  					   GC_push_old_obj, 0)
+	      != PCR_ERes_okay) {
+	      ABORT("Old object enumeration failed");
+	  }
+	}
+    /* Traverse all thread stacks. */
+	if (PCR_ERes_IsErr(
+                PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0))
+              || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) {
+              ABORT("Thread stack marking failed\n");
+	}
+}
+
+# endif /* PCR */
+
+# ifdef SRC_M3
+
+# ifdef ALL_INTERIOR_POINTERS
+    --> misconfigured
+# endif
+
+
+extern void ThreadF__ProcessStacks();
+
+void GC_push_thread_stack(start, stop)
+word start, stop;
+{
+   GC_push_all_stack((ptr_t)start, (ptr_t)stop + sizeof(word));
+}
+
+/* Push routine with M3 specific calling convention. */
+GC_m3_push_root(dummy1, p, dummy2, dummy3)
+word *p;
+ptr_t dummy1, dummy2;
+int dummy3;
+{
+    word q = *p;
+    
+    if ((ptr_t)(q) >= GC_least_plausible_heap_addr
+	 && (ptr_t)(q) < GC_greatest_plausible_heap_addr) {
+	 GC_push_one_checked(q,FALSE);
+    }
+}
+
+/* M3 set equivalent to RTHeap.TracedRefTypes */
+typedef struct { int elts[1]; }  RefTypeSet;
+RefTypeSet GC_TracedRefTypes = {{0x1}};
+
+/* From finalize.c */
+extern void GC_push_finalizer_structures();
+
+/* From stubborn.c: */
+# ifdef STUBBORN_ALLOC
+    extern GC_PTR * GC_changing_list_start;
+# endif
+
+
+void GC_default_push_other_roots()
+{
+    /* Use the M3 provided routine for finding static roots.	*/
+    /* This is a bit dubious, since it presumes no C roots.	*/
+    /* We handle the collector roots explicitly.		*/
+       {
+# 	 ifdef STUBBORN_ALLOC
+           GC_push_one(GC_changing_list_start);
+#	 endif
+      	 GC_push_finalizer_structures();
+      	 RTMain__GlobalMapProc(GC_m3_push_root, 0, GC_TracedRefTypes);
+       }
+	if (GC_words_allocd > 0) {
+	    ThreadF__ProcessStacks(GC_push_thread_stack);
+	}
+	/* Otherwise this isn't absolutely necessary, and we have	*/
+	/* startup ordering problems.					*/
+}
+
+# endif /* SRC_M3 */
+
+# if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(IRIX_THREADS)
+
+extern void GC_push_all_stacks();
+
+void GC_default_push_other_roots()
+{
+    GC_push_all_stacks();
+}
+
+# endif /* SOLARIS_THREADS || ... */
+
+void (*GC_push_other_roots)() = GC_default_push_other_roots;
+
+#endif
+
+/*
+ * Routines for accessing dirty  bits on virtual pages.
+ * We plan to eventaually implement four strategies for doing so:
+ * DEFAULT_VDB:	A simple dummy implementation that treats every page
+ *		as possibly dirty.  This makes incremental collection
+ *		useless, but the implementation is still correct.
+ * PCR_VDB:	Use PPCRs virtual dirty bit facility.
+ * PROC_VDB:	Use the /proc facility for reading dirty bits.  Only
+ *		works under some SVR4 variants.  Even then, it may be
+ *		too slow to be entirely satisfactory.  Requires reading
+ *		dirty bits for entire address space.  Implementations tend
+ *		to assume that the client is a (slow) debugger.
+ * MPROTECT_VDB:Protect pages and then catch the faults to keep track of
+ *		dirtied pages.  The implementation (and implementability)
+ *		is highly system dependent.  This usually fails when system
+ *		calls write to a protected page.  We prevent the read system
+ *		call from doing so.  It is the clients responsibility to
+ *		make sure that other system calls are similarly protected
+ *		or write only to the stack.
+ */
+ 
+bool GC_dirty_maintained = FALSE;
+
+# ifdef DEFAULT_VDB
+
+/* All of the following assume the allocation lock is held, and	*/
+/* signals are disabled.					*/
+
+/* The client asserts that unallocated pages in the heap are never	*/
+/* written.								*/
+
+/* Initialize virtual dirty bit implementation.			*/
+void GC_dirty_init()
+{
+    GC_dirty_maintained = TRUE;
+}
+
+/* Retrieve system dirty bits for heap to a local buffer.	*/
+/* Restore the systems notion of which pages are dirty.		*/
+void GC_read_dirty()
+{}
+
+/* Is the HBLKSIZE sized page at h marked dirty in the local buffer?	*/
+/* If the actual page size is different, this returns TRUE if any	*/
+/* of the pages overlapping h are dirty.  This routine may err on the	*/
+/* side of labelling pages as dirty (and this implementation does).	*/
+/*ARGSUSED*/
+bool GC_page_was_dirty(h)
+struct hblk *h;
+{
+    return(TRUE);
+}
+
+/*
+ * The following two routines are typically less crucial.  They matter
+ * most with large dynamic libraries, or if we can't accurately identify
+ * stacks, e.g. under Solaris 2.X.  Otherwise the following default
+ * versions are adequate.
+ */
+ 
+/* Could any valid GC heap pointer ever have been written to this page?	*/
+/*ARGSUSED*/
+bool GC_page_was_ever_dirty(h)
+struct hblk *h;
+{
+    return(TRUE);
+}
+
+/* Reset the n pages starting at h to "was never dirty" status.	*/
+void GC_is_fresh(h, n)
+struct hblk *h;
+word n;
+{
+}
+
+/* A call hints that h is about to be written.	*/
+/* May speed up some dirty bit implementations.	*/
+/*ARGSUSED*/
+void GC_write_hint(h)
+struct hblk *h;
+{
+}
+
+# endif /* DEFAULT_VDB */
+
+
+# ifdef MPROTECT_VDB
+
+/*
+ * See DEFAULT_VDB for interface descriptions.
+ */
+
+/*
+ * This implementation maintains dirty bits itself by catching write
+ * faults and keeping track of them.  We assume nobody else catches
+ * SIGBUS or SIGSEGV.  We assume no write faults occur in system calls
+ * except as a result of a read system call.  This means clients must
+ * either ensure that system calls do not touch the heap, or must
+ * provide their own wrappers analogous to the one for read.
+ * We assume the page size is a multiple of HBLKSIZE.
+ * This implementation is currently SunOS 4.X and IRIX 5.X specific, though we
+ * tried to use portable code where easily possible.  It is known
+ * not to work under a number of other systems.
+ */
+
+# ifndef MSWIN32
+
+#   include <sys/mman.h>
+#   include <signal.h>
+#   include <sys/syscall.h>
+
+#   define PROTECT(addr, len) \
+    	  if (mprotect((caddr_t)(addr), (int)(len), \
+    	      	       PROT_READ | OPT_PROT_EXEC) < 0) { \
+    	    ABORT("mprotect failed"); \
+    	  }
+#   define UNPROTECT(addr, len) \
+    	  if (mprotect((caddr_t)(addr), (int)(len), \
+    	  	       PROT_WRITE | PROT_READ | OPT_PROT_EXEC ) < 0) { \
+    	    ABORT("un-mprotect failed"); \
+    	  }
+    	  
+# else
+
+#   include <signal.h>
+
+    static DWORD protect_junk;
+#   define PROTECT(addr, len) \
+	  if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
+	  		      &protect_junk)) { \
+	    DWORD last_error = GetLastError(); \
+	    GC_printf1("Last error code: %lx\n", last_error); \
+	    ABORT("VirtualProtect failed"); \
+	  }
+#   define UNPROTECT(addr, len) \
+	  if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READWRITE, \
+	  		      &protect_junk)) { \
+	    ABORT("un-VirtualProtect failed"); \
+	  }
+	  
+# endif
+
+VOLATILE page_hash_table GC_dirty_pages;
+				/* Pages dirtied since last GC_read_dirty. */
+
+word GC_page_size;
+
+bool GC_just_outside_heap(addr)
+word addr;
+{
+    register unsigned i;
+    register word start;
+    register word end;
+    word mask = GC_page_size-1;
+    
+    for (i = 0; i < GC_n_heap_sects; i++) {
+    	start = (word) GC_heap_sects[i].hs_start;
+    	end = start + (word)GC_heap_sects[i].hs_bytes;
+        if (addr < ((start + mask) & ~mask) && addr >= (start & ~mask)
+            || addr >= (end & ~mask) && addr < ((end + mask) & ~mask)) {
+            return(TRUE);
+        }
+    }
+    return(FALSE);
+}
+
+#if defined(SUNOS4) || defined(FREEBSD)
+    typedef void (* SIG_PF)();
+#endif
+#if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX)
+    typedef void (* SIG_PF)(int);
+#endif
+#if defined(MSWIN32)
+    typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF;
+#   undef SIG_DFL
+#   define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
+#endif
+
+#if defined(IRIX5) || defined(OSF1)
+    typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
+#endif
+#if defined(SUNOS5SIGS)
+    typedef void (* REAL_SIG_PF)(int, struct siginfo *, void *);
+#endif
+#if defined(LINUX)
+    typedef void (* REAL_SIG_PF)(int, struct sigcontext_struct);
+# endif
+
+SIG_PF GC_old_bus_handler;
+SIG_PF GC_old_segv_handler;	/* Also old MSWIN32 ACCESS_VIOLATION filter */
+
+/*ARGSUSED*/
+# if defined (SUNOS4) || defined(FREEBSD)
+    void GC_write_fault_handler(sig, code, scp, addr)
+    int sig, code;
+    struct sigcontext *scp;
+    char * addr;
+#   ifdef SUNOS4
+#     define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
+#     define CODE_OK (FC_CODE(code) == FC_PROT \
+              	    || (FC_CODE(code) == FC_OBJERR \
+              	       && FC_ERRNO(code) == FC_PROT))
+#   endif
+#   ifdef FREEBSD
+#     define SIG_OK (sig == SIGBUS)
+#     define CODE_OK (code == BUS_PAGE_FAULT)
+#   endif
+# endif
+# if defined(IRIX5) || defined(OSF1)
+#   include <errno.h>
+    void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
+#   define SIG_OK (sig == SIGSEGV)
+#   ifdef OSF1
+#     define CODE_OK (code == 2 /* experimentally determined */)
+#   endif
+#   ifdef IRIX5
+#     define CODE_OK (code == EACCES)
+#   endif
+# endif
+# if defined(LINUX)
+    void GC_write_fault_handler(int sig, struct sigcontext_struct sc)
+#   define SIG_OK (sig == SIGSEGV)
+#   define CODE_OK TRUE
+	/* Empirically c.trapno == 14, but is that useful?      */
+	/* We assume Intel architecture, so alignment		*/
+	/* faults are not possible.				*/
+# endif
+# if defined(SUNOS5SIGS)
+    void GC_write_fault_handler(int sig, struct siginfo *scp, void * context)
+#   define SIG_OK (sig == SIGSEGV)
+#   define CODE_OK (scp -> si_code == SEGV_ACCERR)
+# endif
+# if defined(MSWIN32)
+    LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info)
+#   define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
+			EXCEPTION_ACCESS_VIOLATION)
+#   define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
+			/* Write fault */
+# endif
+{
+    register unsigned i;
+#   ifdef IRIX5
+	char * addr = (char *) (scp -> sc_badvaddr);
+#   endif
+#   if defined(OSF1) && defined(ALPHA)
+	char * addr = (char *) (scp -> sc_traparg_a0);
+#   endif
+#   ifdef SUNOS5SIGS
+	char * addr = (char *) (scp -> si_addr);
+#   endif
+#   ifdef LINUX
+#     ifdef I386
+	char * addr = (char *) (sc.cr2);
+#     else
+        char * addr = /* As of 1.3.90 there seemed to be no way to do this. */;
+#     endif
+#   endif
+#   if defined(MSWIN32)
+	char * addr = (char *) (exc_info -> ExceptionRecord
+				-> ExceptionInformation[1]);
+#	define sig SIGSEGV
+#   endif
+    
+    if (SIG_OK && CODE_OK) {
+        register struct hblk * h =
+        		(struct hblk *)((word)addr & ~(GC_page_size-1));
+        bool in_allocd_block;
+        
+#	ifdef SUNOS5SIGS
+	    /* Address is only within the correct physical page.	*/
+	    in_allocd_block = FALSE;
+            for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
+              if (HDR(h+i) != 0) {
+                in_allocd_block = TRUE;
+              }
+            }
+#	else
+	    in_allocd_block = (HDR(addr) != 0);
+#	endif
+        if (!in_allocd_block && !GC_just_outside_heap((word)addr)) {
+            SIG_PF old_handler;
+            
+            if (sig == SIGSEGV) {
+            	old_handler = GC_old_segv_handler;
+            } else {
+                old_handler = GC_old_bus_handler;
+            }
+            if (old_handler == SIG_DFL) {
+#		ifndef MSWIN32
+                    ABORT("Unexpected bus error or segmentation fault");
+#		else
+		    return(EXCEPTION_CONTINUE_SEARCH);
+#		endif
+            } else {
+#		if defined (SUNOS4) || defined(FREEBSD)
+		    (*old_handler) (sig, code, scp, addr);
+		    return;
+#		endif
+#		if defined (SUNOS5SIGS)
+		    (*(REAL_SIG_PF)old_handler) (sig, scp, context);
+		    return;
+#		endif
+#		if defined (LINUX)
+		    (*(REAL_SIG_PF)old_handler) (sig, sc);
+		    return;
+#		endif
+#		if defined (IRIX5) || defined(OSF1)
+		    (*(REAL_SIG_PF)old_handler) (sig, code, scp);
+		    return;
+#		endif
+#		ifdef MSWIN32
+		    return((*old_handler)(exc_info));
+#		endif
+            }
+        }
+        for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
+            register int index = PHT_HASH(h+i);
+            
+            set_pht_entry_from_index(GC_dirty_pages, index);
+        }
+        UNPROTECT(h, GC_page_size);
+#	if defined(IRIX5) || defined(OSF1) || defined(LINUX)
+	    /* These reset the signal handler each time by default. */
+	    signal(SIGSEGV, (SIG_PF) GC_write_fault_handler);
+#	endif
+    	/* The write may not take place before dirty bits are read.	*/
+    	/* But then we'll fault again ...				*/
+#	ifdef MSWIN32
+	    return(EXCEPTION_CONTINUE_EXECUTION);
+#	else
+	    return;
+#	endif
+    }
+#ifdef MSWIN32
+    return EXCEPTION_CONTINUE_SEARCH;
+#else
+    ABORT("Unexpected bus error or segmentation fault");
+#endif
+}
+
+/*
+ * We hold the allocation lock.  We expect block h to be written
+ * shortly.
+ */
+void GC_write_hint(h)
+struct hblk *h;
+{
+    register struct hblk * h_trunc;
+    register unsigned i;
+    register bool found_clean;
+    
+    if (!GC_dirty_maintained) return;
+    h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1));
+    found_clean = FALSE;
+    for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
+        register int index = PHT_HASH(h_trunc+i);
+            
+        if (!get_pht_entry_from_index(GC_dirty_pages, index)) {
+            found_clean = TRUE;
+            set_pht_entry_from_index(GC_dirty_pages, index);
+        }
+    }
+    if (found_clean) {
+    	UNPROTECT(h_trunc, GC_page_size);
+    }
+}
+
+#if defined(SVR4)
+#include <unistd.h>
+int
+GC_getpagesize()
+{
+    return sysconf(_SC_PAGESIZE);
+}
+#else
+# ifdef MSWIN32
+   /* GC_getpagesize() defined above */
+# else
+#  define GC_getpagesize() getpagesize()
+# endif
+#endif
+				 
+void GC_dirty_init()
+{
+#if defined(SUNOS5SIGS)
+    struct sigaction	act, oldact;
+    act.sa_sigaction	= GC_write_fault_handler;
+    act.sa_flags	= SA_RESTART | SA_SIGINFO;
+    (void)sigemptyset(&act.sa_mask); 
+#endif
+#   ifdef PRINTSTATS
+	GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n");
+#   endif
+    GC_dirty_maintained = TRUE;
+    GC_page_size = GC_getpagesize();
+    if (GC_page_size % HBLKSIZE != 0) {
+        GC_err_printf0("Page size not multiple of HBLKSIZE\n");
+        ABORT("Page size not multiple of HBLKSIZE");
+    }
+#   if defined(SUNOS4) || defined(FREEBSD)
+      GC_old_bus_handler = signal(SIGBUS, GC_write_fault_handler);
+      if (GC_old_bus_handler == SIG_IGN) {
+        GC_err_printf0("Previously ignored bus error!?");
+        GC_old_bus_handler = SIG_DFL;
+      }
+      if (GC_old_bus_handler != SIG_DFL) {
+#	ifdef PRINTSTATS
+          GC_err_printf0("Replaced other SIGBUS handler\n");
+#	endif
+      }
+#   endif
+#   if defined(IRIX5) || defined(OSF1) || defined(SUNOS4) || defined(LINUX)
+      GC_old_segv_handler = signal(SIGSEGV, (SIG_PF)GC_write_fault_handler);
+      if (GC_old_segv_handler == SIG_IGN) {
+        GC_err_printf0("Previously ignored segmentation violation!?");
+        GC_old_segv_handler = SIG_DFL;
+      }
+      if (GC_old_segv_handler != SIG_DFL) {
+#	ifdef PRINTSTATS
+          GC_err_printf0("Replaced other SIGSEGV handler\n");
+#	endif
+      }
+#   endif
+#   if defined(SUNOS5SIGS)
+      sigaction(SIGSEGV, &act, &oldact);
+      if (oldact.sa_flags & SA_SIGINFO) {
+          GC_old_segv_handler = (SIG_PF)(oldact.sa_sigaction);
+      } else {
+          GC_old_segv_handler = oldact.sa_handler;
+      }
+      if (GC_old_segv_handler == SIG_IGN) {
+	     GC_err_printf0("Previously ignored segmentation violation!?");
+	     GC_old_segv_handler = SIG_DFL;
+      }
+      if (GC_old_segv_handler != SIG_DFL) {
+#       ifdef PRINTSTATS
+	  GC_err_printf0("Replaced other SIGSEGV handler\n");
+#       endif
+      }
+#    endif
+#   if defined(MSWIN32)
+      GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler);
+      if (GC_old_segv_handler != NULL) {
+#	ifdef PRINTSTATS
+          GC_err_printf0("Replaced other UnhandledExceptionFilter\n");
+#	endif
+      } else {
+          GC_old_segv_handler = SIG_DFL;
+      }
+#   endif
+}
+
+
+
+void GC_protect_heap()
+{
+    word ps = GC_page_size;
+    word pmask = (ps-1);
+    ptr_t start;
+    word offset;
+    word len;
+    unsigned i;
+    
+    for (i = 0; i < GC_n_heap_sects; i++) {
+        offset = (word)(GC_heap_sects[i].hs_start) & pmask;
+        start = GC_heap_sects[i].hs_start - offset;
+        len = GC_heap_sects[i].hs_bytes + offset;
+        len += ps-1; len &= ~pmask;
+        PROTECT(start, len);
+    }
+}
+
+/* We assume that either the world is stopped or its OK to lose dirty	*/
+/* bits while this is happenning (as in GC_enable_incremental).		*/
+void GC_read_dirty()
+{
+    BCOPY((word *)GC_dirty_pages, GC_grungy_pages,
+          (sizeof GC_dirty_pages));
+    BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages));
+    GC_protect_heap();
+}
+
+bool GC_page_was_dirty(h)
+struct hblk * h;
+{
+    register word index = PHT_HASH(h);
+    
+    return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index));
+}
+
+/*
+ * Acquiring the allocation lock here is dangerous, since this
+ * can be called from within GC_call_with_alloc_lock, and the cord
+ * package does so.  On systems that allow nested lock acquisition, this
+ * happens to work.
+ * On other systems, SET_LOCK_HOLDER and friends must be suitably defined.
+ */
+ 
+void GC_begin_syscall()
+{
+    if (!I_HOLD_LOCK()) LOCK();
+}
+
+void GC_end_syscall()
+{
+    if (!I_HOLD_LOCK()) UNLOCK();
+}
+
+void GC_unprotect_range(addr, len)
+ptr_t addr;
+word len;
+{
+    struct hblk * start_block;
+    struct hblk * end_block;
+    register struct hblk *h;
+    ptr_t obj_start;
+    
+    if (!GC_incremental) return;
+    obj_start = GC_base(addr);
+    if (obj_start == 0) return;
+    if (GC_base(addr + len - 1) != obj_start) {
+        ABORT("GC_unprotect_range(range bigger than object)");
+    }
+    start_block = (struct hblk *)((word)addr & ~(GC_page_size - 1));
+    end_block = (struct hblk *)((word)(addr + len - 1) & ~(GC_page_size - 1));
+    end_block += GC_page_size/HBLKSIZE - 1;
+    for (h = start_block; h <= end_block; h++) {
+        register word index = PHT_HASH(h);
+        
+        set_pht_entry_from_index(GC_dirty_pages, index);
+    }
+    UNPROTECT(start_block,
+    	      ((ptr_t)end_block - (ptr_t)start_block) + HBLKSIZE);
+}
+
+#ifndef MSWIN32
+/* Replacement for UNIX system call.	 */
+/* Other calls that write to the heap	 */
+/* should be handled similarly.		 */
+# ifndef LINT
+  int read(fd, buf, nbyte)
+# else
+  int GC_read(fd, buf, nbyte)
+# endif
+int fd;
+char *buf;
+int nbyte;
+{
+    int result;
+    
+    GC_begin_syscall();
+    GC_unprotect_range(buf, (word)nbyte);
+#   ifdef IRIX5
+	/* Indirect system call exists, but is undocumented, and	*/
+	/* always seems to return EINVAL.  There seems to be no		*/
+	/* general way to wrap system calls, since the system call	*/
+	/* convention appears to require an immediate argument for	*/
+	/* the system call number, and building the required code	*/
+	/* in the data segment also seems dangerous.  We can fake it	*/
+	/* for read; anything else is up to the client.			*/
+	{
+	    struct iovec iov;
+
+	    iov.iov_base = buf;
+	    iov.iov_len = nbyte;
+	    result = readv(fd, &iov, 1);
+	}
+#   else
+    	result = syscall(SYS_read, fd, buf, nbyte);
+#   endif
+    GC_end_syscall();
+    return(result);
+}
+#endif /* !MSWIN32 */
+
+/*ARGSUSED*/
+bool GC_page_was_ever_dirty(h)
+struct hblk *h;
+{
+    return(TRUE);
+}
+
+/* Reset the n pages starting at h to "was never dirty" status.	*/
+/*ARGSUSED*/
+void GC_is_fresh(h, n)
+struct hblk *h;
+word n;
+{
+}
+
+# endif /* MPROTECT_VDB */
+
+# ifdef PROC_VDB
+
+/*
+ * See DEFAULT_VDB for interface descriptions.
+ */
+ 
+/*
+ * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
+ * from which we can read page modified bits.  This facility is far from
+ * optimal (e.g. we would like to get the info for only some of the
+ * address space), but it avoids intercepting system calls.
+ */
+
+#include <sys/types.h>
+#include <sys/signal.h>
+#include <sys/fault.h>
+#include <sys/syscall.h>
+#include <sys/procfs.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#define INITIAL_BUF_SZ 4096
+word GC_proc_buf_size = INITIAL_BUF_SZ;
+char *GC_proc_buf;
+
+page_hash_table GC_written_pages = { 0 };	/* Pages ever dirtied	*/
+
+#ifdef SOLARIS_THREADS
+/* We don't have exact sp values for threads.  So we count on	*/
+/* occasionally declaring stack pages to be fresh.  Thus we 	*/
+/* need a real implementation of GC_is_fresh.  We can't clear	*/
+/* entries in GC_written_pages, since that would declare all	*/
+/* pages with the given hash address to be fresh.		*/
+#   define MAX_FRESH_PAGES 8*1024	/* Must be power of 2 */
+    struct hblk ** GC_fresh_pages;	/* A direct mapped cache.	*/
+    					/* Collisions are dropped.	*/
+
+#   define FRESH_PAGE_SLOT(h) (divHBLKSZ((word)(h)) & (MAX_FRESH_PAGES-1))
+#   define ADD_FRESH_PAGE(h) \
+	GC_fresh_pages[FRESH_PAGE_SLOT(h)] = (h)
+#   define PAGE_IS_FRESH(h) \
+	(GC_fresh_pages[FRESH_PAGE_SLOT(h)] == (h) && (h) != 0)
+#endif
+
+/* Add all pages in pht2 to pht1 */
+void GC_or_pages(pht1, pht2)
+page_hash_table pht1, pht2;
+{
+    register int i;
+    
+    for (i = 0; i < PHT_SIZE; i++) pht1[i] |= pht2[i];
+}
+
+int GC_proc_fd;
+
+void GC_dirty_init()
+{
+    int fd;
+    char buf[30];
+
+    GC_dirty_maintained = TRUE;
+    if (GC_words_allocd != 0 || GC_words_allocd_before_gc != 0) {
+    	register int i;
+    
+        for (i = 0; i < PHT_SIZE; i++) GC_written_pages[i] = (word)(-1);
+#       ifdef PRINTSTATS
+	    GC_printf1("Allocated words:%lu:all pages may have been written\n",
+	    	       (unsigned long)
+	    	      		(GC_words_allocd + GC_words_allocd_before_gc));
+#	endif       
+    }
+    sprintf(buf, "/proc/%d", getpid());
+    fd = open(buf, O_RDONLY);
+    if (fd < 0) {
+    	ABORT("/proc open failed");
+    }
+    GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0);
+    if (GC_proc_fd < 0) {
+    	ABORT("/proc ioctl failed");
+    }
+    GC_proc_buf = GC_scratch_alloc(GC_proc_buf_size);
+#   ifdef SOLARIS_THREADS
+	GC_fresh_pages = (struct hblk **)
+	  GC_scratch_alloc(MAX_FRESH_PAGES * sizeof (struct hblk *));
+	if (GC_fresh_pages == 0) {
+	    GC_err_printf0("No space for fresh pages\n");
+	    EXIT();
+	}
+	BZERO(GC_fresh_pages, MAX_FRESH_PAGES * sizeof (struct hblk *));
+#   endif
+}
+
+/* Ignore write hints. They don't help us here.	*/
+/*ARGSUSED*/
+void GC_write_hint(h)
+struct hblk *h;
+{
+}
+
+#ifdef SOLARIS_THREADS
+#   define READ(fd,buf,nbytes) syscall(SYS_read, fd, buf, nbytes)
+#else
+#   define READ(fd,buf,nbytes) read(fd, buf, nbytes)
+#endif
+
+void GC_read_dirty()
+{
+    unsigned long ps, np;
+    int nmaps;
+    ptr_t vaddr;
+    struct prasmap * map;
+    char * bufp;
+    ptr_t current_addr, limit;
+    int i;
+int dummy;
+
+    BZERO(GC_grungy_pages, (sizeof GC_grungy_pages));
+    
+    bufp = GC_proc_buf;
+    if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
+#	ifdef PRINTSTATS
+            GC_printf1("/proc read failed: GC_proc_buf_size = %lu\n",
+            	       GC_proc_buf_size);
+#	endif       
+        {
+            /* Retry with larger buffer. */
+            word new_size = 2 * GC_proc_buf_size;
+            char * new_buf = GC_scratch_alloc(new_size);
+            
+            if (new_buf != 0) {
+                GC_proc_buf = bufp = new_buf;
+                GC_proc_buf_size = new_size;
+            }
+            if (syscall(SYS_read, GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
+                WARN("Insufficient space for /proc read\n", 0);
+                /* Punt:	*/
+        	memset(GC_grungy_pages, 0xff, sizeof (page_hash_table));
+#		ifdef SOLARIS_THREADS
+		    BZERO(GC_fresh_pages,
+		    	  MAX_FRESH_PAGES * sizeof (struct hblk *)); 
+#		endif
+		return;
+            }
+        }
+    }
+    /* Copy dirty bits into GC_grungy_pages */
+    	nmaps = ((struct prpageheader *)bufp) -> pr_nmap;
+	/* printf( "nmaps = %d, PG_REFERENCED = %d, PG_MODIFIED = %d\n",
+		     nmaps, PG_REFERENCED, PG_MODIFIED); */
+	bufp = bufp + sizeof(struct prpageheader);
+	for (i = 0; i < nmaps; i++) {
+	    map = (struct prasmap *)bufp;
+	    vaddr = (ptr_t)(map -> pr_vaddr);
+	    ps = map -> pr_pagesize;
+	    np = map -> pr_npage;
+	    /* printf("vaddr = 0x%X, ps = 0x%X, np = 0x%X\n", vaddr, ps, np); */
+	    limit = vaddr + ps * np;
+	    bufp += sizeof (struct prasmap);
+	    for (current_addr = vaddr;
+	         current_addr < limit; current_addr += ps){
+	        if ((*bufp++) & PG_MODIFIED) {
+	            register struct hblk * h = (struct hblk *) current_addr;
+	            
+	            while ((ptr_t)h < current_addr + ps) {
+	                register word index = PHT_HASH(h);
+	                
+	                set_pht_entry_from_index(GC_grungy_pages, index);
+#			ifdef SOLARIS_THREADS
+			  {
+			    register int slot = FRESH_PAGE_SLOT(h);
+			    
+			    if (GC_fresh_pages[slot] == h) {
+			        GC_fresh_pages[slot] = 0;
+			    }
+			  }
+#			endif
+	                h++;
+	            }
+	        }
+	    }
+	    bufp += sizeof(long) - 1;
+	    bufp = (char *)((unsigned long)bufp & ~(sizeof(long)-1));
+	}
+    /* Update GC_written_pages. */
+        GC_or_pages(GC_written_pages, GC_grungy_pages);
+#   ifdef SOLARIS_THREADS
+      /* Make sure that old stacks are considered completely clean	*/
+      /* unless written again.						*/
+	GC_old_stacks_are_fresh();
+#   endif
+}
+
+#undef READ
+
+bool GC_page_was_dirty(h)
+struct hblk *h;
+{
+    register word index = PHT_HASH(h);
+    register bool result;
+    
+    result = get_pht_entry_from_index(GC_grungy_pages, index);
+#   ifdef SOLARIS_THREADS
+	if (result && PAGE_IS_FRESH(h)) result = FALSE;
+	/* This happens only if page was declared fresh since	*/
+	/* the read_dirty call, e.g. because it's in an unused  */
+	/* thread stack.  It's OK to treat it as clean, in	*/
+	/* that case.  And it's consistent with 		*/
+	/* GC_page_was_ever_dirty.				*/
+#   endif
+    return(result);
+}
+
+bool GC_page_was_ever_dirty(h)
+struct hblk *h;
+{
+    register word index = PHT_HASH(h);
+    register bool result;
+    
+    result = get_pht_entry_from_index(GC_written_pages, index);
+#   ifdef SOLARIS_THREADS
+	if (result && PAGE_IS_FRESH(h)) result = FALSE;
+#   endif
+    return(result);
+}
+
+/* Caller holds allocation lock.	*/
+void GC_is_fresh(h, n)
+struct hblk *h;
+word n;
+{
+
+    register word index;
+    
+#   ifdef SOLARIS_THREADS
+      register word i;
+      
+      if (GC_fresh_pages != 0) {
+        for (i = 0; i < n; i++) {
+          ADD_FRESH_PAGE(h + i);
+        }
+      }
+#   endif
+}
+
+# endif /* PROC_VDB */
+
+
+# ifdef PCR_VDB
+
+# include "vd/PCR_VD.h"
+
+# define NPAGES (32*1024)	/* 128 MB */
+
+PCR_VD_DB  GC_grungy_bits[NPAGES];
+
+ptr_t GC_vd_base;	/* Address corresponding to GC_grungy_bits[0]	*/
+			/* HBLKSIZE aligned.				*/
+
+void GC_dirty_init()
+{
+    GC_dirty_maintained = TRUE;
+    /* For the time being, we assume the heap generally grows up */
+    GC_vd_base = GC_heap_sects[0].hs_start;
+    if (GC_vd_base == 0) {
+   	ABORT("Bad initial heap segment");
+    }
+    if (PCR_VD_Start(HBLKSIZE, GC_vd_base, NPAGES*HBLKSIZE)
+	!= PCR_ERes_okay) {
+	ABORT("dirty bit initialization failed");
+    }
+}
+
+void GC_read_dirty()
+{
+    /* lazily enable dirty bits on newly added heap sects */
+    {
+        static int onhs = 0;
+        int nhs = GC_n_heap_sects;
+        for( ; onhs < nhs; onhs++ ) {
+            PCR_VD_WriteProtectEnable(
+                    GC_heap_sects[onhs].hs_start,
+                    GC_heap_sects[onhs].hs_bytes );
+        }
+    }
+
+
+    if (PCR_VD_Clear(GC_vd_base, NPAGES*HBLKSIZE, GC_grungy_bits)
+        != PCR_ERes_okay) {
+	ABORT("dirty bit read failed");
+    }
+}
+
+bool GC_page_was_dirty(h)
+struct hblk *h;
+{
+    if((ptr_t)h < GC_vd_base || (ptr_t)h >= GC_vd_base + NPAGES*HBLKSIZE) {
+	return(TRUE);
+    }
+    return(GC_grungy_bits[h - (struct hblk *)GC_vd_base] & PCR_VD_DB_dirtyBit);
+}
+
+/*ARGSUSED*/
+void GC_write_hint(h)
+struct hblk *h;
+{
+    PCR_VD_WriteProtectDisable(h, HBLKSIZE);
+    PCR_VD_WriteProtectEnable(h, HBLKSIZE);
+}
+
+# endif /* PCR_VDB */
+
+/*
+ * Call stack save code for debugging.
+ * Should probably be in mach_dep.c, but that requires reorganization.
+ */
+#if defined(SPARC)
+#   if defined(SUNOS4)
+#     include <machine/frame.h>
+#   else
+#     if defined (DRSNX)
+#	include <sys/sparc/frame.h>
+#     else
+#       include <sys/frame.h>
+#     endif
+#   endif
+#   if NARGS > 6
+	--> We only know how to to get the first 6 arguments
+#   endif
+
+/* Fill in the pc and argument information for up to NFRAMES of my	*/
+/* callers.  Ignore my frame and my callers frame.			*/
+void GC_save_callers (info) 
+struct callinfo info[NFRAMES];
+{
+  struct frame *frame;
+  struct frame *fp;
+  int nframes = 0;
+  word GC_save_regs_in_stack();
+
+  frame = (struct frame *) GC_save_regs_in_stack ();
+  
+  for (fp = frame -> fr_savfp; fp != 0 && nframes < NFRAMES;
+       fp = fp -> fr_savfp, nframes++) {
+      register int i;
+      
+      info[nframes].ci_pc = fp->fr_savpc;
+      for (i = 0; i < NARGS; i++) {
+	info[nframes].ci_arg[i] = ~(fp->fr_arg[i]);
+      }
+  }
+  if (nframes < NFRAMES) info[nframes].ci_pc = 0;
+}
+
+#endif /* SPARC */
+
+#ifdef SAVE_CALL_CHAIN
+
+void GC_print_callers (info)
+struct callinfo info[NFRAMES];
+{
+    register int i,j;
+    
+    GC_err_printf0("\tCall chain at allocation:\n");
+    for (i = 0; i < NFRAMES; i++) {
+     	if (info[i].ci_pc == 0) break;
+     	GC_err_printf0("\t\targs: ");
+     	for (j = 0; j < NARGS; j++) {
+     	    if (j != 0) GC_err_printf0(", ");
+     	    GC_err_printf2("%d (0x%X)", ~(info[i].ci_arg[j]),
+     	    				~(info[i].ci_arg[j]));
+     	}
+     	GC_err_printf1("\n\t\t##PC##= 0x%X\n", info[i].ci_pc);
+    }
+}
+
+#endif /* SAVE_CALL_CHAIN */
+
+
diff --git a/src/mzscheme/gc/pc_excludes b/src/mzscheme/gc/pc_excludes
new file mode 100644
index 0000000..52da431
--- /dev/null
+++ b/src/mzscheme/gc/pc_excludes
@@ -0,0 +1,15 @@
+solaris_threads.c
+pcr_interface.c
+real_malloc.c
+mips_mach_dep.s
+rs6000_mach_dep.s
+alpha_mach_dep.s
+sparc_mach_dep.s
+PCR-Makefile
+setjmp_t.c
+callprocs
+gc.man
+pc_excludes
+barrett_diagram
+include/gc_c++.h
+include/gc_inline.h
\ No newline at end of file
diff --git a/src/mzscheme/gc/pcr_interface.c b/src/mzscheme/gc/pcr_interface.c
new file mode 100644
index 0000000..12e3181
--- /dev/null
+++ b/src/mzscheme/gc/pcr_interface.c
@@ -0,0 +1,173 @@
+/* 
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 7, 1996 11:09 am PST */
+# include "gc_priv.h"
+
+# ifdef PCR
+/*
+ * Note that POSIX PCR requires an ANSI C compiler.  Hence we are allowed
+ * to make the same assumption here.
+ * We wrap all of the allocator functions to avoid questions of
+ * compatibility between the prototyped and nonprototyped versions of the f
+ */
+# include "config/PCR_StdTypes.h"
+# include "mm/PCR_MM.h"
+# include <errno.h>
+
+# define MY_MAGIC 17L
+# define MY_DEBUGMAGIC 42L
+
+void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
+{
+    if (ptrFree) {
+        void * result = (void *)GC_malloc_atomic(size);
+        if (clear && result != 0) BZERO(result, size);
+        return(result);
+    } else {
+        return((void *)GC_malloc(size));
+    }
+}
+
+void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
+{
+    if (ptrFree) {
+        void * result = (void *)GC_debug_malloc_atomic(size, __FILE__,
+        						     __LINE__);
+        if (clear && result != 0) BZERO(result, size);
+        return(result);
+    } else {
+        return((void *)GC_debug_malloc(size, __FILE__, __LINE__));
+    }
+}
+
+# define GC_ReallocProc GC_realloc
+void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes)
+{
+    return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__));
+}
+
+# define GC_FreeProc GC_free
+# define GC_DebugFreeProc GC_debug_free
+
+typedef struct {
+  PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
+  bool ed_pointerfree;
+  PCR_ERes ed_fail_code;
+  PCR_Any ed_client_data;
+} enumerate_data;
+
+void GC_enumerate_block(h, ed)
+register struct hblk *h;
+enumerate_data * ed;
+{
+    register hdr * hhdr;
+    register int sz;
+    word *p;
+    word * lim;
+    
+    hhdr = HDR(h);
+    sz = hhdr -> hb_sz;
+    if (sz >= 0 && ed -> ed_pointerfree
+    	|| sz <= 0 && !(ed -> ed_pointerfree)) return;
+    if (sz < 0) sz = -sz;
+    lim = (word *)(h+1) - sz;
+    p = (word *)h;
+    do {
+        if (PCR_ERes_IsErr(ed -> ed_fail_code)) return;
+        ed -> ed_fail_code =
+            (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data);
+        p+= sz;
+    } while (p <= lim);
+}
+
+struct PCR_MM_ProcsRep * GC_old_allocator = 0;
+
+PCR_ERes GC_EnumerateProc(
+    PCR_Bool ptrFree,
+    PCR_ERes (*proc)(void *p, size_t size, PCR_Any data),
+    PCR_Any data
+)
+{
+    enumerate_data ed;
+    
+    ed.ed_proc = proc;
+    ed.ed_pointerfree = ptrFree;
+    ed.ed_fail_code = PCR_ERes_okay;
+    ed.ed_client_data = data;
+    GC_apply_to_all_blocks(GC_enumerate_block, &ed);
+    if (ed.ed_fail_code != PCR_ERes_okay) {
+        return(ed.ed_fail_code);
+    } else {
+    	/* Also enumerate objects allocated by my predecessors */
+    	return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data));
+    }
+}
+
+void GC_DummyFreeProc(void *p) {}
+
+void GC_DummyShutdownProc(void) {}
+
+struct PCR_MM_ProcsRep GC_Rep = {
+	MY_MAGIC,
+	GC_AllocProc,
+	GC_ReallocProc,
+	GC_DummyFreeProc,  	/* mmp_free */
+	GC_FreeProc,  		/* mmp_unsafeFree */
+	GC_EnumerateProc,
+	GC_DummyShutdownProc	/* mmp_shutdown */
+};
+
+struct PCR_MM_ProcsRep GC_DebugRep = {
+	MY_DEBUGMAGIC,
+	GC_DebugAllocProc,
+	GC_DebugReallocProc,
+	GC_DummyFreeProc,  	/* mmp_free */
+	GC_DebugFreeProc,  		/* mmp_unsafeFree */
+	GC_EnumerateProc,
+	GC_DummyShutdownProc	/* mmp_shutdown */
+};
+
+bool GC_use_debug = 0;
+
+void GC_pcr_install()
+{
+    PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator);
+}
+
+PCR_ERes
+PCR_GC_Setup(void)
+{
+    return PCR_ERes_okay;
+}
+
+PCR_ERes
+PCR_GC_Run(void)
+{
+
+    if( !PCR_Base_TestPCRArg("-nogc") ) {
+        GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
+        GC_use_debug = (bool)PCR_Base_TestPCRArg("-debug_alloc");
+        GC_init();
+        if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
+            /*
+             * awful hack to test whether VD is implemented ...
+             */
+            if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
+	        GC_enable_incremental();
+	    }
+	}
+    }
+    return PCR_ERes_okay;
+}
+
+# endif
diff --git a/src/mzscheme/gc/ptr_chck.c b/src/mzscheme/gc/ptr_chck.c
new file mode 100644
index 0000000..d7fe4e1
--- /dev/null
+++ b/src/mzscheme/gc/ptr_chck.c
@@ -0,0 +1,326 @@
+/* 
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, September 19, 1995 1:26 pm PDT */
+
+#include "gc_priv.h"
+#include "gc_mark.h"
+
+#ifdef __STDC__
+void GC_default_same_obj_print_proc(GC_PTR p, GC_PTR q)
+#else
+void GC_default_same_obj_print_proc (p, q)
+GC_PTR p, q;
+#endif
+{
+    GC_err_printf2("0x%lx and 0x%lx are not in the same object\n",
+    		   (unsigned long)p, (unsigned long)q);
+    ABORT("GC_same_obj test failed");
+}
+
+void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR, GC_PTR))
+		= GC_default_same_obj_print_proc;
+
+/* Check that p and q point to the same object.  Call		*/
+/* *GC_same_obj_print_proc if they don't.			*/
+/* Returns the first argument.  (Return value may be hard 	*/
+/* to use,due to typing issues.  But if we had a suitable 	*/
+/* preprocessor ...)						*/
+/* Succeeds if neither p nor q points to the heap.		*/
+/* We assume this is performance critical.  (It shouldn't	*/
+/* be called by production code, but this can easily make	*/
+/* debugging intolerably slow.)					*/
+#ifdef __STDC__
+  GC_PTR GC_same_obj(register void *p, register void *q)
+#else
+  GC_PTR GC_same_obj(p, q)
+  register char *p, *q;
+#endif
+{
+    register struct hblk *h;
+    register hdr *hhdr;
+    register ptr_t base, limit;
+    register word sz;
+    
+    if (!GC_is_initialized) GC_init();
+    hhdr = HDR((word)p);
+    if (hhdr == 0) {
+   	if (divHBLKSZ((word)p) != divHBLKSZ((word)q)
+   	    && HDR((word)q) != 0) {
+   	    goto fail;
+   	}
+   	return(p);
+    }
+    /* If it's a pointer to the middle of a large object, move it	*/
+    /* to the beginning.						*/
+    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+    	h = HBLKPTR(p) - (word)hhdr;
+    	hhdr = HDR(h);
+	while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+	   h = FORWARDED_ADDR(h, hhdr);
+	   hhdr = HDR(h);
+	}
+	limit = (ptr_t)((word *)h + HDR_WORDS + hhdr -> hb_sz);
+	if ((ptr_t)p >= limit || (ptr_t)q >= limit || (ptr_t)q < (ptr_t)h ) {
+	    goto fail;
+	}
+	return(p);
+    }
+    sz = WORDS_TO_BYTES(hhdr -> hb_sz);
+    if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
+      base = (ptr_t)HBLKPTR(p);
+      limit = base + sz;
+      if ((ptr_t)p >= limit) {
+        goto fail;
+      }
+    } else {
+#     ifdef ALL_INTERIOR_POINTERS
+	register map_entry_type map_entry;
+	register int pdispl;
+	
+	pdispl = HBLKDISPL(p);
+	map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);
+	if (map_entry == OBJ_INVALID) {
+            goto fail;
+        } else {
+            base = (char *)((word)p & ~(WORDS_TO_BYTES(1) - 1));
+            base -= WORDS_TO_BYTES(map_entry);
+	}
+#     else
+	register int offset = HBLKDISPL(p) - HDR_BYTES;
+	register word correction = offset % sz;
+	
+	if (HBLKPTR(p) != HBLKPTR(q)) {
+	    /* The following computation otherwise fails in this case */
+	    goto fail;
+	}
+	base = (ptr_t)p - correction;
+#     endif
+      limit = base + sz;
+    }
+    /* [base, limit) delimits the object containing p, if any.	*/
+    /* If p is not inside a valid object, then either q is	*/
+    /* also outside any valid object, or it is outside 		*/
+    /* [base, limit).						*/
+    if ((ptr_t)q >= limit || (ptr_t)q < base) {
+    	goto fail;
+    }
+    return(p);
+fail:
+    (*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q);
+    return(p);
+}
+
+#ifdef __STDC__
+void GC_default_is_valid_displacement_print_proc (GC_PTR p)
+#else
+void GC_default_is_valid_displacement_print_proc (p)
+GC_PTR p;
+#endif
+{
+    GC_err_printf1("0x%lx does not point to valid object displacement\n",
+    		   (unsigned long)p);
+    ABORT("GC_is_valid_displacement test failed");
+}
+
+void (*GC_is_valid_displacement_print_proc) GC_PROTO((GC_PTR)) = 
+	GC_default_is_valid_displacement_print_proc;
+
+/* Check that if p is a pointer to a heap page, then it points to	*/
+/* a valid displacement within a heap object.				*/
+/* Uninteresting with ALL_INTERIOR_POINTERS.				*/
+/* Always returns its argument.						*/
+/* Note that we don't lock, since nothing relevant about the header	*/
+/* should change while we have a valid object pointer to the block.	*/
+#ifdef __STDC__
+  void * GC_is_valid_displacement(void *p)
+#else
+  char *GC_is_valid_displacement(p)
+  char *p;
+#endif
+{
+    register hdr *hhdr;
+    register word pdispl;
+    register struct hblk *h;
+    register map_entry_type map_entry;
+    register word sz;
+    
+    if (!GC_is_initialized) GC_init();
+    hhdr = HDR((word)p);
+    if (hhdr == 0) return(p);
+    h = HBLKPTR(p);
+#   ifdef ALL_INTERIOR_POINTERS
+	while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+	   h = FORWARDED_ADDR(h, hhdr);
+	   hhdr = HDR(h);
+	}
+#   endif
+    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+    	goto fail;
+    }
+    sz = WORDS_TO_BYTES(hhdr -> hb_sz);
+    pdispl = HBLKDISPL(p);
+    map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);
+    if (map_entry == OBJ_INVALID
+    	|| sz > MAXOBJSZ && (ptr_t)p >= (ptr_t)h + sz) {
+    	goto fail;
+    }
+    return(p);
+fail:
+    (*GC_is_valid_displacement_print_proc)((ptr_t)p);
+    return(p);
+}
+
+#ifdef __STDC__
+void GC_default_is_visible_print_proc(GC_PTR p)
+#else
+void GC_default_is_visible_print_proc(p)
+GC_PTR p;
+#endif
+{
+    GC_err_printf1("0x%lx is not a GC visible pointer location\n",
+    		   (unsigned long)p);
+    ABORT("GC_is_visible test failed");
+}
+
+void (*GC_is_visible_print_proc) GC_PROTO((GC_PTR p)) = 
+	GC_default_is_visible_print_proc;
+
+/* Could p be a stack address? */
+bool GC_on_stack(p)
+ptr_t p;
+{
+#   ifdef THREADS
+	return(TRUE);
+#   else
+	int dummy;
+#   	ifdef STACK_GROWS_DOWN
+	    if ((ptr_t)p >= (ptr_t)(&dummy) && (ptr_t)p < GC_stackbottom ) {
+	    	return(TRUE);
+	    }
+#	else
+	    if ((ptr_t)p <= (ptr_t)(&dummy) && (ptr_t)p > GC_stackbottom ) {
+	    	return(TRUE);
+	    }
+#	endif
+	return(FALSE);
+#   endif
+}
+
+/* Check that p is visible						*/
+/* to the collector as a possibly pointer containing location.		*/
+/* If it isn't invoke *GC_is_visible_print_proc.			*/
+/* Returns the argument in all cases.  May erroneously succeed		*/
+/* in hard cases.  (This is intended for debugging use with		*/
+/* untyped allocations.  The idea is that it should be possible, though	*/
+/* slow, to add such a call to all indirect pointer stores.)		*/
+/* Currently useless for multithreaded worlds.				*/
+#ifdef __STDC__
+  void * GC_is_visible(void *p)
+#else
+  char *GC_is_visible(p)
+  char *p;
+#endif
+{
+    register hdr *hhdr;
+    
+    if ((word)p & (ALIGNMENT - 1)) goto fail;
+    if (!GC_is_initialized) GC_init();
+#   ifdef THREADS
+	hhdr = HDR((word)p);
+        if (hhdr != 0 && GC_base(p) == 0) {
+            goto fail;
+        } else {
+            /* May be inside thread stack.  We can't do much. */
+            return(p);
+        }
+#   else
+	/* Check stack first: */
+	  if (GC_on_stack(p)) return(p);
+	hhdr = HDR((word)p);
+    	if (hhdr == 0) {
+    	    bool result;
+    	    
+    	    if (GC_is_static_root(p)) return(p);
+    	    /* Else do it again correctly:	*/
+#           if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(PCR)) \
+                && !defined(SRC_M3)
+    	        DISABLE_SIGNALS();
+    	        GC_register_dynamic_libraries();
+    	        result = GC_is_static_root(p);
+    	        ENABLE_SIGNALS();
+    	        if (result) return(p);
+#	    endif
+    	    goto fail;
+    	} else {
+    	    /* p points to the heap. */
+    	    word descr;
+    	    ptr_t base = GC_base(p);	/* Should be manually inlined? */
+    	    
+    	    if (base == 0) goto fail;
+    	    if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p);
+    	    descr = hhdr -> hb_descr;
+    retry:
+    	    switch(descr & DS_TAGS) {
+    	        case DS_LENGTH:
+    	            if ((word)((ptr_t)p - (ptr_t)base) > (word)descr) goto fail;
+    	            break;
+    	        case DS_BITMAP:
+    	            if ((ptr_t)p - (ptr_t)base
+    	                 >= WORDS_TO_BYTES(BITMAP_BITS)
+    	                 || ((word)p & (sizeof(word) - 1))) goto fail;
+    	            if (!((1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1))
+    	            	  & descr)) goto fail;
+    	            break;
+    	        case DS_PROC:
+    	            /* We could try to decipher this partially. 	*/
+    	            /* For now we just punt.				*/
+    	            break;
+    	        case DS_PER_OBJECT:
+    	            descr = *(word *)((ptr_t)base + (descr & ~DS_TAGS));
+    	            goto retry;
+    	    }
+    	    return(p);
+    	}
+#   endif
+fail:
+    (*GC_is_visible_print_proc)((ptr_t)p);
+    return(p);
+}
+
+
+GC_PTR GC_pre_incr (p, how_much)
+GC_PTR *p;
+size_t how_much;
+{
+    GC_PTR initial = *p;
+    GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);
+    
+#   ifndef ALL_INTERIOR_POINTERS
+    	(void) GC_is_valid_displacement(result);
+#   endif
+    return (*p = result);
+}
+
+GC_PTR GC_post_incr (p, how_much)
+GC_PTR *p;
+size_t how_much;
+{
+    GC_PTR initial = *p;
+    GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);
+ 
+#   ifndef ALL_INTERIOR_POINTERS
+    	(void) GC_is_valid_displacement(result);
+#   endif   
+    *p = result;
+    return(initial);
+}
diff --git a/src/mzscheme/gc/real_malloc.c b/src/mzscheme/gc/real_malloc.c
new file mode 100644
index 0000000..dece9fd
--- /dev/null
+++ b/src/mzscheme/gc/real_malloc.c
@@ -0,0 +1,36 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, May 19, 1994 2:04 pm PDT */
+
+
+# ifdef PCR
+/*
+ * This definition should go in its own file that includes no other
+ * header files.  Otherwise, we risk not getting the underlying system
+ * malloc.
+ */
+# define PCR_NO_RENAME
+# include <stdlib.h>
+
+# ifdef __STDC__
+    char * real_malloc(size_t size)
+# else 
+    char * real_malloc()
+    int size;
+# endif
+{
+    return((char *)malloc(size));
+}
+#endif /* PCR */
+
diff --git a/src/mzscheme/gc/reclaim.c b/src/mzscheme/gc/reclaim.c
new file mode 100644
index 0000000..2a505f4
--- /dev/null
+++ b/src/mzscheme/gc/reclaim.c
@@ -0,0 +1,723 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, February 15, 1996 2:41 pm PST */
+
+#include <stdio.h>
+#include "gc_priv.h"
+
+signed_word GC_mem_found = 0;
+			/* Number of longwords of memory GC_reclaimed     */
+
+# ifdef FIND_LEAK
+static report_leak(p, sz)
+ptr_t p;
+word sz;
+{
+    if (HDR(p) -> hb_obj_kind == PTRFREE) {
+        GC_err_printf0("Leaked atomic object at ");
+    } else {
+        GC_err_printf0("Leaked composite object at ");
+    }
+    if (GC_debugging_started && GC_has_debug_info(p)) {
+        GC_print_obj(p);
+    } else {
+        GC_err_printf2("0x%lx (appr. size = %ld)\n",
+       		      (unsigned long)p,
+       		      (unsigned long)WORDS_TO_BYTES(sz));
+    }
+}
+
+#   define FOUND_FREE(hblk, word_no) \
+      if (abort_if_found) { \
+         report_leak((long)hblk + WORDS_TO_BYTES(word_no), \
+         	     HDR(hblk) -> hb_sz); \
+      }
+# else
+#   define FOUND_FREE(hblk, word_no)
+# endif
+
+/*
+ * reclaim phase
+ *
+ */
+
+
+/*
+ * Test whether a block is completely empty, i.e. contains no marked
+ * objects.  This does not require the block to be in physical
+ * memory.
+ */
+ 
+bool GC_block_empty(hhdr)
+register hdr * hhdr;
+{
+    register word *p = (word *)(&(hhdr -> hb_marks[0]));
+    register word * plim =
+	    		(word *)(&(hhdr -> hb_marks[MARK_BITS_SZ]));
+    while (p < plim) {
+	if (*p++) return(FALSE);
+    }
+    return(TRUE);
+}
+
+# ifdef GATHERSTATS
+#   define INCR_WORDS(sz) n_words_found += (sz)
+# else
+#   define INCR_WORDS(sz)
+# endif
+/*
+ * Restore unmarked small objects in h of size sz to the object
+ * free list.  Returns the new list.
+ * Clears unmarked objects.
+ */
+/*ARGSUSED*/
+ptr_t GC_reclaim_clear(hbp, hhdr, sz, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+register hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+register word sz;
+{
+    register int word_no;
+    register word *p, *q, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif        
+    
+    p = (word *)(hbp->hb_body);
+    word_no = HDR_WORDS;
+    plim = (word *)((((word)hbp) + HBLKSIZE)
+		   - WORDS_TO_BYTES(sz));
+
+    /* go through all words in block */
+	while( p <= plim )  {
+	    if( mark_bit_from_hdr(hhdr, word_no) ) {
+		p += sz;
+	    } else {
+		FOUND_FREE(hbp, word_no);
+		INCR_WORDS(sz);
+		/* object is available - put on list */
+		    obj_link(p) = list;
+		    list = ((ptr_t)p);
+		/* Clear object, advance p to next object in the process */
+		    q = p + sz;
+                    p++; /* Skip link field */
+                    while (p < q) {
+			*p++ = 0;
+		    }
+	    }
+	    word_no += sz;
+	}
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+}
+
+#ifndef SMALL_CONFIG
+
+/*
+ * A special case for 2 word composite objects (e.g. cons cells):
+ */
+/*ARGSUSED*/
+ptr_t GC_reclaim_clear2(hbp, hhdr, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+{
+    register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    register word mark_word;
+    register int i;
+#   define DO_OBJ(start_displ) \
+	if (!(mark_word & ((word)1 << start_displ))) { \
+	    FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
+	    p[start_displ] = (word)list; \
+	    list = (ptr_t)(p+start_displ); \
+	    p[start_displ+1] = 0; \
+	    INCR_WORDS(2); \
+	}
+    
+    p = (word *)(hbp->hb_body);
+    plim = (word *)(((word)hbp) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    for (i = 0; i < WORDSZ; i += 8) {
+		DO_OBJ(0);
+		DO_OBJ(2);
+		DO_OBJ(4);
+		DO_OBJ(6);
+		p += 8;
+		mark_word >>= 8;
+	    }
+	}	        
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+#   undef DO_OBJ
+}
+
+/*
+ * Another special case for 4 word composite objects:
+ */
+/*ARGSUSED*/
+ptr_t GC_reclaim_clear4(hbp, hhdr, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+{
+    register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    register word mark_word;
+#   define DO_OBJ(start_displ) \
+	if (!(mark_word & ((word)1 << start_displ))) { \
+	    FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
+	    p[start_displ] = (word)list; \
+	    list = (ptr_t)(p+start_displ); \
+	    p[start_displ+1] = 0; \
+	    p[start_displ+2] = 0; \
+	    p[start_displ+3] = 0; \
+	    INCR_WORDS(4); \
+	}
+    
+    p = (word *)(hbp->hb_body);
+    plim = (word *)(((word)hbp) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    DO_OBJ(0);
+	    DO_OBJ(4);
+	    DO_OBJ(8);
+	    DO_OBJ(12);
+	    DO_OBJ(16);
+	    DO_OBJ(20);
+	    DO_OBJ(24);
+	    DO_OBJ(28);
+#	    if CPP_WORDSZ == 64
+	      DO_OBJ(32);
+	      DO_OBJ(36);
+	      DO_OBJ(40);
+	      DO_OBJ(44);
+	      DO_OBJ(48);
+	      DO_OBJ(52);
+	      DO_OBJ(56);
+	      DO_OBJ(60);
+#	    endif
+	    p += WORDSZ;
+	}	        
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+#   undef DO_OBJ
+}
+
+#endif /* !SMALL_CONFIG */
+
+/* The same thing, but don't clear objects: */
+/*ARGSUSED*/
+ptr_t GC_reclaim_uninit(hbp, hhdr, sz, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+register hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+register word sz;
+{
+    register int word_no;
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    
+    p = (word *)(hbp->hb_body);
+    word_no = HDR_WORDS;
+    plim = (word *)((((word)hbp) + HBLKSIZE)
+		   - WORDS_TO_BYTES(sz));
+
+    /* go through all words in block */
+	while( p <= plim )  {
+	    if( !mark_bit_from_hdr(hhdr, word_no) ) {
+		FOUND_FREE(hbp, word_no);
+		INCR_WORDS(sz);
+		/* object is available - put on list */
+		    obj_link(p) = list;
+		    list = ((ptr_t)p);
+	    }
+	    p += sz;
+	    word_no += sz;
+	}
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+}
+
+#ifndef SMALL_CONFIG
+/*
+ * Another special case for 2 word atomic objects:
+ */
+/*ARGSUSED*/
+ptr_t GC_reclaim_uninit2(hbp, hhdr, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+{
+    register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    register word mark_word;
+    register int i;
+#   define DO_OBJ(start_displ) \
+	if (!(mark_word & ((word)1 << start_displ))) { \
+	    FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
+	    p[start_displ] = (word)list; \
+	    list = (ptr_t)(p+start_displ); \
+	    INCR_WORDS(2); \
+	}
+    
+    p = (word *)(hbp->hb_body);
+    plim = (word *)(((word)hbp) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    for (i = 0; i < WORDSZ; i += 8) {
+		DO_OBJ(0);
+		DO_OBJ(2);
+		DO_OBJ(4);
+		DO_OBJ(6);
+		p += 8;
+		mark_word >>= 8;
+	    }
+	}	        
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+#   undef DO_OBJ
+}
+
+/*
+ * Another special case for 4 word atomic objects:
+ */
+/*ARGSUSED*/
+ptr_t GC_reclaim_uninit4(hbp, hhdr, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+{
+    register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    register word mark_word;
+#   define DO_OBJ(start_displ) \
+	if (!(mark_word & ((word)1 << start_displ))) { \
+	    FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
+	    p[start_displ] = (word)list; \
+	    list = (ptr_t)(p+start_displ); \
+	    INCR_WORDS(4); \
+	}
+    
+    p = (word *)(hbp->hb_body);
+    plim = (word *)(((word)hbp) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    DO_OBJ(0);
+	    DO_OBJ(4);
+	    DO_OBJ(8);
+	    DO_OBJ(12);
+	    DO_OBJ(16);
+	    DO_OBJ(20);
+	    DO_OBJ(24);
+	    DO_OBJ(28);
+#	    if CPP_WORDSZ == 64
+	      DO_OBJ(32);
+	      DO_OBJ(36);
+	      DO_OBJ(40);
+	      DO_OBJ(44);
+	      DO_OBJ(48);
+	      DO_OBJ(52);
+	      DO_OBJ(56);
+	      DO_OBJ(60);
+#	    endif
+	    p += WORDSZ;
+	}	        
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+#   undef DO_OBJ
+}
+
+/* Finally the one word case, which never requires any clearing: */
+/*ARGSUSED*/
+ptr_t GC_reclaim1(hbp, hhdr, list, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+hdr * hhdr;
+bool abort_if_found;		/* Abort if a reclaimable object is found */
+register ptr_t list;
+{
+    register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
+    register word *p, *plim;
+#   ifdef GATHERSTATS
+        register int n_words_found = 0;
+#   endif
+    register word mark_word;
+    register int i;
+#   define DO_OBJ(start_displ) \
+	if (!(mark_word & ((word)1 << start_displ))) { \
+	    FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
+	    p[start_displ] = (word)list; \
+	    list = (ptr_t)(p+start_displ); \
+	    INCR_WORDS(1); \
+	}
+    
+    p = (word *)(hbp->hb_body);
+    plim = (word *)(((word)hbp) + HBLKSIZE);
+
+    /* go through all words in block */
+	while( p < plim )  {
+	    mark_word = *mark_word_addr++;
+	    for (i = 0; i < WORDSZ; i += 4) {
+		DO_OBJ(0);
+		DO_OBJ(1);
+		DO_OBJ(2);
+		DO_OBJ(3);
+		p += 4;
+		mark_word >>= 4;
+	    }
+	}	        
+#   ifdef GATHERSTATS
+	GC_mem_found += n_words_found;
+#   endif
+    return(list);
+#   undef DO_OBJ
+}
+
+#endif /* !SMALL_CONFIG */
+
+/*
+ * Restore unmarked small objects in the block pointed to by hbp
+ * to the appropriate object free list.
+ * If entirely empty blocks are to be completely deallocated, then
+ * caller should perform that check.
+ */
+void GC_reclaim_small_nonempty_block(hbp, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+int abort_if_found;		/* Abort if a reclaimable object is found */
+{
+    hdr * hhdr;
+    register word sz;		/* size of objects in current block	*/
+    register struct obj_kind * ok;
+    register ptr_t * flh;
+    register int kind;
+    
+    hhdr = HDR(hbp);
+    sz = hhdr -> hb_sz;
+    hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no;
+    kind = hhdr -> hb_obj_kind;
+    ok = &GC_obj_kinds[kind];
+    flh = &(ok -> ok_freelist[sz]);
+    GC_write_hint(hbp);
+
+    if (ok -> ok_init) {
+      switch(sz) {
+#      ifndef SMALL_CONFIG
+        case 1:
+            *flh = GC_reclaim1(hbp, hhdr, *flh, abort_if_found);
+            break;
+        case 2:
+            *flh = GC_reclaim_clear2(hbp, hhdr, *flh, abort_if_found);
+            break;
+        case 4:
+            *flh = GC_reclaim_clear4(hbp, hhdr, *flh, abort_if_found);
+            break;
+#      endif
+        default:
+            *flh = GC_reclaim_clear(hbp, hhdr, sz, *flh, abort_if_found);
+            break;
+      }
+    } else {
+      switch(sz) {
+#      ifndef SMALL_CONFIG
+        case 1:
+            *flh = GC_reclaim1(hbp, hhdr, *flh, abort_if_found);
+            break;
+        case 2:
+            *flh = GC_reclaim_uninit2(hbp, hhdr, *flh, abort_if_found);
+            break;
+        case 4:
+            *flh = GC_reclaim_uninit4(hbp, hhdr, *flh, abort_if_found);
+            break;
+#      endif
+        default:
+            *flh = GC_reclaim_uninit(hbp, hhdr, sz, *flh, abort_if_found);
+            break;
+      }
+    } 
+    if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(hhdr);
+}
+
+/*
+ * Restore an unmarked large object or an entirely empty blocks of small objects
+ * to the heap block free list.
+ * Otherwise enqueue the block for later processing
+ * by GC_reclaim_small_nonempty_block.
+ * If abort_if_found is TRUE, then process any block immediately.
+ */
+void GC_reclaim_block(hbp, abort_if_found)
+register struct hblk *hbp;	/* ptr to current heap block		*/
+word abort_if_found;		/* Abort if a reclaimable object is found */
+{
+    register hdr * hhdr;
+    register word sz;		/* size of objects in current block	*/
+    register struct obj_kind * ok;
+    struct hblk ** rlh;
+
+    hhdr = HDR(hbp);
+    sz = hhdr -> hb_sz;
+    ok = &GC_obj_kinds[hhdr -> hb_obj_kind];
+
+    if( sz > MAXOBJSZ ) {  /* 1 big object */
+        if( !mark_bit_from_hdr(hhdr, HDR_WORDS) ) {
+	    FOUND_FREE(hbp, HDR_WORDS);
+#	    ifdef GATHERSTATS
+	        GC_mem_found += sz;
+#	    endif
+	    GC_freehblk(hbp);
+	}
+    } else {
+        bool empty = GC_block_empty(hhdr);
+        if (abort_if_found) {
+    	  GC_reclaim_small_nonempty_block(hbp, (int)abort_if_found);
+        } else if (empty) {
+#	  ifdef GATHERSTATS
+            GC_mem_found += BYTES_TO_WORDS(HBLKSIZE);
+#	  endif
+          GC_freehblk(hbp);
+        } else {
+          /* group of smaller objects, enqueue the real work */
+          rlh = &(ok -> ok_reclaim_list[sz]);
+          hhdr -> hb_next = *rlh;
+          *rlh = hbp;
+        }
+    }
+}
+
+#if !defined(NO_DEBUGGING)
+/* Routines to gather and print heap block info 	*/
+/* intended for debugging.  Otherwise should be called	*/
+/* with lock.						*/
+static size_t number_of_blocks;
+static size_t total_bytes;
+
+/* Number of set bits in a word.  Not performance critical.	*/
+static int set_bits(n)
+word n;
+{
+    register word m = n;
+    register int result = 0;
+    
+    while (m > 0) {
+    	if (m & 1) result++;
+    	m >>= 1;
+    }
+    return(result);
+}
+
+/* Return the number of set mark bits in the given header	*/
+int GC_n_set_marks(hhdr)
+hdr * hhdr;
+{
+    register int result = 0;
+    register int i;
+    
+    for (i = 0; i < MARK_BITS_SZ; i++) {
+        result += set_bits(hhdr -> hb_marks[i]);
+    }
+    return(result);
+}
+
+/*ARGSUSED*/
+void GC_print_block_descr(h, dummy)
+struct hblk *h;
+word dummy;
+{
+    register hdr * hhdr = HDR(h);
+    register size_t bytes = WORDS_TO_BYTES(hhdr -> hb_sz);
+    
+    GC_printf3("(%lu:%lu,%lu)", (unsigned long)(hhdr -> hb_obj_kind),
+    			        (unsigned long)bytes,
+    			        (unsigned long)(GC_n_set_marks(hhdr)));
+    bytes += HDR_BYTES + HBLKSIZE-1;
+    bytes &= ~(HBLKSIZE-1);
+    total_bytes += bytes;
+    number_of_blocks++;
+}
+
+void GC_print_block_list()
+{
+    GC_printf0("(kind(0=ptrfree,1=normal,2=unc.,3=stubborn):size_in_bytes, #_marks_set)\n");
+    number_of_blocks = 0;
+    total_bytes = 0;
+    GC_apply_to_all_blocks(GC_print_block_descr, (word)0);
+    GC_printf2("\nblocks = %lu, bytes = %lu\n",
+    	       (unsigned long)number_of_blocks,
+    	       (unsigned long)total_bytes);
+}
+
+#endif /* NO_DEBUGGING */
+
+/*
+ * Do the same thing on the entire heap, after first clearing small object
+ * free lists (if we are not just looking for leaks).
+ */
+void GC_start_reclaim(abort_if_found)
+int abort_if_found;		/* Abort if a GC_reclaimable object is found */
+{
+    int kind;
+    
+    /* Clear reclaim- and free-lists */
+      for (kind = 0; kind < GC_n_kinds; kind++) {
+        register ptr_t *fop;
+        register ptr_t *lim;
+        register struct hblk ** rlp;
+        register struct hblk ** rlim;
+        register struct hblk ** rlist = GC_obj_kinds[kind].ok_reclaim_list;
+        
+        if (rlist == 0) continue;	/* This kind not used.	*/
+        if (!abort_if_found) {
+            lim = &(GC_obj_kinds[kind].ok_freelist[MAXOBJSZ+1]);
+	    for( fop = GC_obj_kinds[kind].ok_freelist; fop < lim; fop++ ) {
+	      *fop = 0;
+	    }
+	} /* otherwise free list objects are marked, 	*/
+	  /* and its safe to leave them			*/
+	rlim = rlist + MAXOBJSZ+1;
+	for( rlp = rlist; rlp < rlim; rlp++ ) {
+	    *rlp = 0;
+	}
+      }
+    
+#   ifdef PRINTBLOCKS
+        GC_printf0("GC_reclaim: current block sizes:\n");
+        GC_print_block_list();
+#   endif
+
+  /* Go through all heap blocks (in hblklist) and reclaim unmarked objects */
+  /* or enqueue the block for later processing.				   */
+    GC_apply_to_all_blocks(GC_reclaim_block, (word)abort_if_found);
+    
+}
+
+/*
+ * Sweep blocks of the indicated object size and kind until either the
+ * appropriate free list is nonempty, or there are no more blocks to
+ * sweep.
+ */
+void GC_continue_reclaim(sz, kind)
+word sz;	/* words */
+int kind;
+{
+    register hdr * hhdr;
+    register struct hblk * hbp;
+    register struct obj_kind * ok = &(GC_obj_kinds[kind]);
+    struct hblk ** rlh = ok -> ok_reclaim_list;
+    ptr_t *flh = &(ok -> ok_freelist[sz]);
+    
+    if (rlh == 0) return;	/* No blocks of this kind.	*/
+    rlh += sz;
+    while ((hbp = *rlh) != 0) {
+        hhdr = HDR(hbp);
+        *rlh = hhdr -> hb_next;
+        GC_reclaim_small_nonempty_block(hbp, FALSE);
+        if (*flh != 0) break;
+    }
+}
+
+/*
+ * Reclaim all small blocks waiting to be reclaimed.
+ * Abort and return FALSE when/if (*stop_func)() returns TRUE.
+ * If this returns TRUE, then it's safe to restart the world
+ * with incorrectly cleared mark bits.
+ * If ignore_old is TRUE, then reclain only blocks that have been 
+ * recently reclaimed, and discard the rest.
+ * Stop_func may be 0.
+ */
+bool GC_reclaim_all(stop_func, ignore_old)
+GC_stop_func stop_func;
+bool ignore_old;
+{
+    register word sz;
+    register int kind;
+    register hdr * hhdr;
+    register struct hblk * hbp;
+    register struct obj_kind * ok;
+    struct hblk ** rlp;
+    struct hblk ** rlh;
+#   ifdef PRINTTIMES
+	CLOCK_TYPE start_time;
+	CLOCK_TYPE done_time;
+	
+	GET_TIME(start_time);
+#   endif
+    
+    for (kind = 0; kind < GC_n_kinds; kind++) {
+    	ok = &(GC_obj_kinds[kind]);
+    	rlp = ok -> ok_reclaim_list;
+    	if (rlp == 0) continue;
+    	for (sz = 1; sz <= MAXOBJSZ; sz++) {
+    	    rlh = rlp + sz;
+    	    while ((hbp = *rlh) != 0) {
+    	        if (stop_func != (GC_stop_func)0 && (*stop_func)()) {
+    	            return(FALSE);
+    	        }
+        	hhdr = HDR(hbp);
+        	*rlh = hhdr -> hb_next;
+        	if (!ignore_old || hhdr -> hb_last_reclaimed == GC_gc_no - 1) {
+        	    /* It's likely we'll need it this time, too	*/
+        	    /* It's been touched recently, so this	*/
+        	    /* shouldn't trigger paging.		*/
+        	    GC_reclaim_small_nonempty_block(hbp, FALSE);
+        	}
+            }
+        }
+    }
+#   ifdef PRINTTIMES
+	GET_TIME(done_time);
+	GC_printf1("Disposing of reclaim lists took %lu msecs\n",
+	           MS_TIME_DIFF(done_time,start_time));
+#   endif
+    return(TRUE);
+}
diff --git a/src/mzscheme/gc/rs6000_mach_dep.s b/src/mzscheme/gc/rs6000_mach_dep.s
new file mode 100644
index 0000000..e0dbe80
--- /dev/null
+++ b/src/mzscheme/gc/rs6000_mach_dep.s
@@ -0,0 +1,105 @@
+    .csect
+    .set   r0,0
+    .set   r1,1
+    .set   r2,2
+    .set   r3,3
+    .set   r4,4
+    .set   r5,5
+    .set   r6,6
+    .set   r7,7
+    .set   r8,8
+    .set   r9,9
+    .set   r10,10
+    .set   r11,11
+    .set   r12,12
+    .set   r13,13
+    .set   r14,14
+    .set   r15,15
+    .set   r16,16
+    .set   r17,17
+    .set   r18,18
+    .set   r19,19
+    .set   r20,20
+    .set   r21,21
+    .set   r22,22
+    .set   r23,23
+    .set   r24,24
+    .set   r25,25
+    .set   r26,26
+    .set   r27,27
+    .set   r28,28
+    .set   r29,29
+    .set   r30,30
+    .set   r31,31
+
+ # Mark from machine registers that are saved by C compiler
+    .globl  .GC_push_regs
+.GC_push_regs:
+    .extern .GC_push_one
+    stu	    r1,-64(r1)  # reserve stack frame
+    mflr    r0		# save link register
+    st      r0,0x48(r1)
+    oril    r3,r2,0x0   # mark from r2
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r13,0x0   # mark from r13-r31
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r14,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r15,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r16,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r17,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r18,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r19,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r20,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r21,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r22,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r23,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r24,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r25,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r26,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r27,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r28,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r29,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r30,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    oril    r3,r31,0x0
+    bl 	    .GC_push_one
+    cror    15,15,15
+    l       r0,0x48(r1)
+    mtlr    r0
+    ai      r1,r1,64
+    br
diff --git a/src/mzscheme/gc/setjmp_t.c b/src/mzscheme/gc/setjmp_t.c
new file mode 100644
index 0000000..df30b7b
--- /dev/null
+++ b/src/mzscheme/gc/setjmp_t.c
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, September 21, 1995 5:39 pm PDT */
+ 
+/* Check whether setjmp actually saves registers in jmp_buf. */
+/* If it doesn't, the generic mark_regs code won't work.     */
+/* Compilers vary as to whether they will put x in a 	     */
+/* (callee-save) register without -O.  The code is	     */
+/* contrived such that any decent compiler should put x in   */
+/* a callee-save register with -O.  Thus it is is 	     */
+/* recommended that this be run optimized.  (If the machine  */
+/* has no callee-save registers, then the generic code is    */
+/* safe, but this will not be noticed by this piece of       */
+/* code.)						     */
+#include <stdio.h>
+#include <setjmp.h>
+#include <string.h>
+#include "config.h"
+
+#ifdef __hpux
+#include <unistd.h>
+int
+getpagesize()
+{
+    return sysconf(_SC_PAGE_SIZE);
+}
+#endif
+
+#if defined(SVR4)
+#include <unistd.h>
+int
+getpagesize()
+{
+    return sysconf(_SC_PAGESIZE);
+}
+#endif
+
+#ifdef _AUX_SOURCE
+#include <sys/mmu.h>
+int
+getpagesize()
+{
+   return PAGESIZE;
+}
+#endif
+
+#if defined(AMIGA) || defined(MACOS)
+int
+getpagesize()
+{
+    return(4096);
+}
+#endif
+
+#ifdef OS2
+#define INCL_DOSFILEMGR
+#define INCL_DOSMISC
+#define INCL_DOSERRORS
+#include <os2.h>
+
+int
+getpagesize()
+{
+    ULONG result[1];
+    
+    if (DosQuerySysInfo(QSV_PAGE_SIZE, QSV_PAGE_SIZE,
+    		        (void *)result, sizeof(ULONG)) != NO_ERROR) {
+    	fprintf(stderr, "DosQuerySysInfo failed\n");
+    	result[0] = 4096;
+    }
+    return((int)(result[0]));
+}
+#endif
+
+struct {char a_a; char * a_b;} a;
+
+int * nested_sp()
+{
+    int dummy;
+    
+    return(&dummy);
+}
+
+main()
+{
+	int dummy;
+	long ps = getpagesize();
+	jmp_buf b;
+	register int x = (int)strlen("a");  /* 1, slightly disguised */
+	static int y = 0;
+
+	printf("This appears to be a %s running %s\n", MACH_TYPE, OS_TYPE);
+	if (nested_sp() < &dummy) {
+	  printf("Stack appears to grow down, which is the default.\n");
+	  printf("A good guess for STACKBOTTOM on this machine is 0x%X.\n",
+	         ((long)(&dummy) + ps) & ~(ps-1));
+	} else {
+	  printf("Stack appears to grow up.\n");
+	  printf("Define STACK_GROWS_UP in gc_private.h\n");
+	  printf("A good guess for STACKBOTTOM on this machine is 0x%X.\n",
+	         ((long)(&dummy) + ps) & ~(ps-1));
+	}
+	printf("Note that this may vary between machines of ostensibly\n");
+	printf("the same architecture (e.g. Sun 3/50s and 3/80s).\n");
+	printf("On many machines the value is not fixed.\n");
+	printf("A good guess for ALIGNMENT on this machine is %d.\n",
+	       (unsigned long)(&(a.a_b))-(unsigned long)(&a));
+	
+	/* Encourage the compiler to keep x in a callee-save register */
+	x = 2*x-1;
+	printf("");
+	x = 2*x-1;
+	setjmp(b);
+	if (y == 1) {
+	    if (x == 2) {
+		printf("Generic mark_regs code probably wont work\n");
+#		if defined(SPARC) || defined(RS6000) || defined(VAX) || defined(MIPS) || defined(M68K) || defined(I386) || defined(NS32K) || defined(RT)
+		    printf("Assembly code supplied\n");
+#		else
+		    printf("Need assembly code\n");
+#		endif
+	    } else if (x == 1) {
+		printf("Generic mark_regs code may work\n");
+	    } else {
+		printf("Very strange setjmp implementation\n");
+	    }
+	}
+	y++;
+	x = 2;
+	if (y == 1) longjmp(b,1);
+	return(0);
+}
+
+int g(x)
+int x;
+{
+	return(x);
+}
diff --git a/src/mzscheme/gc/solaris_threads.c b/src/mzscheme/gc/solaris_threads.c
new file mode 100644
index 0000000..01e631f
--- /dev/null
+++ b/src/mzscheme/gc/solaris_threads.c
@@ -0,0 +1,749 @@
+/* 
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/*
+ * Support code for Solaris threads.  Provides functionality we wish Sun
+ * had provided.  Relies on some information we probably shouldn't rely on.
+ */
+/* Boehm, September 14, 1994 4:44 pm PDT */
+
+# if defined(SOLARIS_THREADS)
+
+# include "gc_priv.h"
+# include <thread.h>
+# include <synch.h>
+# include <signal.h>
+# include <fcntl.h>
+# include <sys/types.h>
+# include <sys/mman.h>
+# include <sys/time.h>
+# include <sys/resource.h>
+# include <sys/stat.h>
+# include <sys/syscall.h>
+# include <sys/procfs.h>
+# include <sys/lwp.h>
+# include <sys/reg.h>
+# define _CLASSIC_XOPEN_TYPES
+# include <unistd.h>
+
+# define MAX_LWPS	32
+
+#undef thr_join
+#undef thr_create
+#undef thr_suspend
+#undef thr_continue
+
+cond_t GC_prom_join_cv;		/* Broadcast when any thread terminates	*/
+cond_t GC_create_cv;		/* Signalled when a new undetached	*/
+				/* thread starts.			*/
+				
+
+/* We use the allocation lock to protect thread-related data structures. */
+
+/* We stop the world using /proc primitives.  This makes some	*/
+/* minimal assumptions about the threads implementation.	*/
+/* We don't play by the rules, since the rules make this	*/
+/* impossible (as of Solaris 2.3).  Also note that as of	*/
+/* Solaris 2.3 the various thread and lwp suspension		*/
+/* primitives failed to stop threads by the time the request	*/
+/* is completed.						*/
+
+
+static sigset_t old_mask;
+# define MAX_LWPS	32
+
+/* Sleep for n milliseconds, n < 1000	*/
+void GC_msec_sleep(int n)
+{
+    struct timespec ts;
+                            
+    ts.tv_sec = 0;
+    ts.tv_nsec = 1000000*n;
+    if (syscall(SYS_nanosleep, &ts, 0) < 0) {
+	ABORT("nanosleep failed");
+    }
+}
+/* Turn off preemption;  gross but effective.  		*/
+/* Caller has allocation lock.				*/
+/* Actually this is not needed under Solaris 2.3 and	*/
+/* 2.4, but hopefully that'll change.			*/
+void preempt_off()
+{
+    sigset_t set;
+
+    (void)sigfillset(&set);
+    syscall(SYS_sigprocmask, SIG_SETMASK, &set, &old_mask);
+}
+
+void preempt_on()
+{
+    syscall(SYS_sigprocmask, SIG_SETMASK, &old_mask, NULL);
+}
+
+int GC_main_proc_fd = -1;
+
+struct lwp_cache_entry {
+    lwpid_t lc_id;
+    int lc_descr;	/* /proc file descriptor.	*/
+} GC_lwp_cache[MAX_LWPS];
+
+prgregset_t GC_lwp_registers[MAX_LWPS];
+
+/* Return a file descriptor for the /proc entry corresponding	*/
+/* to the given lwp.  The file descriptor may be stale if the	*/
+/* lwp exited and a new one was forked.				*/
+static int open_lwp(lwpid_t id)
+{
+    int result;
+    static int next_victim = 0;
+    register int i;
+    
+    for (i = 0; i < MAX_LWPS; i++) {
+    	if (GC_lwp_cache[i].lc_id == id) return(GC_lwp_cache[i].lc_descr);
+    }
+    if ((result = syscall(SYS_ioctl, GC_main_proc_fd, PIOCOPENLWP, &id)) < 0) {
+        return(-1) /* exited? */;
+    }
+    if (GC_lwp_cache[next_victim].lc_id != 0)
+        (void)syscall(SYS_close, GC_lwp_cache[next_victim].lc_descr);
+    GC_lwp_cache[next_victim].lc_id = id;
+    GC_lwp_cache[next_victim].lc_descr = result;
+    next_victim++;
+    return(result);
+}
+
+static void uncache_lwp(lwpid_t id)
+{
+    register int i;
+    
+    for (i = 0; i < MAX_LWPS; i++) {
+    	if (GC_lwp_cache[i].lc_id == id) {
+    	    (void)syscall(SYS_close, GC_lwp_cache[id].lc_descr);
+    	    GC_lwp_cache[i].lc_id = 0;
+    	    break;
+    	}
+    }
+}
+
+lwpid_t GC_current_ids[MAX_LWPS + 1];	/* Sequence of current lwp ids	*/
+
+/* Stop all lwps in process.  Assumes preemption is off.	*/
+/* Caller has allocation lock (and any other locks he may	*/
+/* need).							*/
+static void stop_all_lwps()
+{
+    int lwp_fd;
+    char buf[30];
+    prstatus_t status;
+    lwpid_t last_ids[MAX_LWPS + 1];
+    register int i;
+    bool changed;
+    lwpid_t me = _lwp_self();
+
+    if (GC_main_proc_fd == -1) {
+    	sprintf(buf, "/proc/%d", getpid());
+    	GC_main_proc_fd = syscall(SYS_open, buf, O_RDONLY);
+        if (GC_main_proc_fd < 0) {
+    	    ABORT("/proc open failed");
+        }
+    }
+    if (syscall(SYS_ioctl, GC_main_proc_fd, PIOCSTATUS, &status) < 0)
+    	ABORT("Main PIOCSTATUS failed");
+    if (status.pr_nlwp < 1 || status.pr_nlwp > MAX_LWPS) {
+    	ABORT("Too many lwps");
+    	/* Only a heuristic.  There seems to be no way to do this right, */
+    	/* since there can be intervening forks.			 */
+    }
+    BZERO(GC_lwp_registers, sizeof GC_lwp_registers);
+    for (i = 0; i <= MAX_LWPS; i++) last_ids[i] = 0;
+    for (;;) {
+        if (syscall(SYS_ioctl, GC_main_proc_fd, PIOCLWPIDS, GC_current_ids) < 0) {
+            ABORT("PIOCLWPIDS failed");
+        }
+        changed = FALSE;
+        for (i = 0; GC_current_ids[i] != 0; i++) {
+            if (GC_current_ids[i] != last_ids[i]) {
+                changed = TRUE;
+                if (GC_current_ids[i] != me) {
+		    /* PIOCSTOP doesn't work without a writable		*/
+		    /* descriptor.  And that makes the process		*/
+		    /* undebuggable.					*/
+                    if (_lwp_suspend(GC_current_ids[i]) < 0) {
+                        /* Could happen if the lwp exited */
+                        uncache_lwp(GC_current_ids[i]);
+                        GC_current_ids[i] = me; /* ignore */
+                    }
+                }
+            }
+            if (i >= MAX_LWPS) ABORT("Too many lwps");
+        }
+        /* All lwps in GC_current_ids != me have been suspended.  Note	*/
+        /* that _lwp_suspend is idempotent.				*/
+        for (i = 0; GC_current_ids[i] != 0; i++) {
+            if (GC_current_ids[i] != last_ids[i]) {
+                if (GC_current_ids[i] != me) {
+                    lwp_fd = open_lwp(GC_current_ids[i]);
+		    /* LWP should be stopped.  Empirically it sometimes	*/
+		    /* isn't, and more frequently the PR_STOPPED flag	*/
+		    /* is not set.  Wait for PR_STOPPED.		*/
+                    if (syscall(SYS_ioctl, lwp_fd,
+                                PIOCSTATUS, &status) < 0) {
+			/* Possible if the descriptor was stale, or */
+			/* we encountered the 2.3 _lwp_suspend bug. */
+			uncache_lwp(GC_current_ids[i]);
+                        GC_current_ids[i] = me; /* handle next time. */
+                    } else {
+                        while (!(status.pr_flags & PR_STOPPED)) {
+                            GC_msec_sleep(1);
+			    if (syscall(SYS_ioctl, lwp_fd,
+				    	PIOCSTATUS, &status) < 0) {
+                            	ABORT("Repeated PIOCSTATUS failed");
+			    }
+			    if (status.pr_flags & PR_STOPPED) break;
+			    
+			    GC_msec_sleep(20);
+			    if (syscall(SYS_ioctl, lwp_fd,
+				    	PIOCSTATUS, &status) < 0) {
+                            	ABORT("Repeated PIOCSTATUS failed");
+			    }
+                        }
+                        if (status.pr_who !=  GC_current_ids[i]) {
+                            ABORT("Wrong lwp");
+                        }
+                        /* Save registers where collector can */
+			/* find them.			  */
+			    BCOPY(status.pr_reg, GC_lwp_registers[i],
+				  sizeof (prgregset_t));
+                    }
+                }
+            }
+        }
+        if (!changed) break;
+        for (i = 0; i <= MAX_LWPS; i++) last_ids[i] = GC_current_ids[i];
+    }
+}
+
+/* Restart all lwps in process.  Assumes preemption is off.	*/
+static void restart_all_lwps()
+{
+    int lwp_fd;
+    register int i;
+    bool changed;
+    lwpid_t me = _lwp_self();
+#   define PARANOID
+
+    for (i = 0; GC_current_ids[i] != 0; i++) {
+#	ifdef PARANOID
+	  if (GC_current_ids[i] != me) {
+	    int lwp_fd = open_lwp(GC_current_ids[i]);
+	    prstatus_t status;
+	    gwindows_t windows;
+	    
+	    if (lwp_fd < 0) ABORT("open_lwp failed");
+	    if (syscall(SYS_ioctl, lwp_fd,
+			PIOCSTATUS, &status) < 0) {
+                ABORT("PIOCSTATUS failed in restart_all_lwps");
+	    }
+	    if (memcmp(status.pr_reg, GC_lwp_registers[i],
+		       sizeof (prgregset_t)) != 0) {
+		ABORT("Register contents changed");
+	    }
+	    if (!status.pr_flags & PR_STOPPED) {
+	    	ABORT("lwp no longer stopped");
+	    }
+	    if (syscall(SYS_ioctl, lwp_fd,
+			PIOCGWIN, &windows) < 0) {
+                ABORT("PIOCSTATUS failed in restart_all_lwps");
+	    }
+	    if (windows.wbcnt > 0) ABORT("unsaved register windows");
+	  }
+#	endif /* PARANOID */
+	if (GC_current_ids[i] == me) continue;
+        if (_lwp_continue(GC_current_ids[i]) < 0) {
+            ABORT("Failed to restart lwp");
+        }
+    }
+    if (i >= MAX_LWPS) ABORT("Too many lwps");
+}
+
+bool GC_multithreaded = 0;
+
+void GC_stop_world()
+{
+    preempt_off();
+    if (GC_multithreaded)
+        stop_all_lwps();
+}
+
+void GC_start_world()
+{
+    if (GC_multithreaded)
+        restart_all_lwps();
+    preempt_on();
+}
+
+void GC_thr_init();
+
+bool GC_thr_initialized = FALSE;
+
+size_t GC_min_stack_sz;
+
+size_t GC_page_sz;
+
+
+# define N_FREE_LISTS 25
+ptr_t GC_stack_free_lists[N_FREE_LISTS] = { 0 };
+		/* GC_stack_free_lists[i] is free list for stacks of 	*/
+		/* size GC_min_stack_sz*2**i.				*/
+		/* Free lists are linked through first word.		*/
+
+/* Return a stack of size at least *stack_size.  *stack_size is	*/
+/* replaced by the actual stack size.				*/
+/* Caller holds allocation lock.				*/
+ptr_t GC_stack_alloc(size_t * stack_size)
+{
+    register size_t requested_sz = *stack_size;
+    register size_t search_sz = GC_min_stack_sz;
+    register int index = 0;	/* = log2(search_sz/GC_min_stack_sz) */
+    register ptr_t result;
+    
+    while (search_sz < requested_sz) {
+        search_sz *= 2;
+        index++;
+    }
+    if ((result = GC_stack_free_lists[index]) == 0
+        && (result = GC_stack_free_lists[index+1]) != 0) {
+        /* Try next size up. */
+        search_sz *= 2; index++;
+    }
+    if (result != 0) {
+        GC_stack_free_lists[index] = *(ptr_t *)result;
+    } else {
+        result = (ptr_t) GC_scratch_alloc(search_sz + 2*GC_page_sz);
+        result = (ptr_t)(((word)result + GC_page_sz) & ~(GC_page_sz - 1));
+        /* Protect hottest page to detect overflow. */
+#	ifdef SOLARIS23_MPROTECT_BUG_FIXED
+            mprotect(result, GC_page_sz, PROT_NONE);
+#	endif
+        GC_is_fresh((struct hblk *)result, divHBLKSZ(search_sz));
+        result += GC_page_sz;
+    }
+    *stack_size = search_sz;
+    return(result);
+}
+
+/* Caller holds  allocationlock.					*/
+void GC_stack_free(ptr_t stack, size_t size)
+{
+    register int index = 0;
+    register size_t search_sz = GC_min_stack_sz;
+    
+    while (search_sz < size) {
+        search_sz *= 2;
+        index++;
+    }
+    if (search_sz != size) ABORT("Bad stack size");
+    *(ptr_t *)stack = GC_stack_free_lists[index];
+    GC_stack_free_lists[index] = stack;
+}
+
+void GC_my_stack_limits();
+
+/* Notify virtual dirty bit implementation that known empty parts of	*/
+/* stacks do not contain useful data.					*/ 
+/* Caller holds allocation lock.					*/
+void GC_old_stacks_are_fresh()
+{
+    register int i;
+    register ptr_t p;
+    register size_t sz;
+    register struct hblk * h;
+    int dummy;
+    
+    GC_thr_init();
+    for (i = 0, sz= GC_min_stack_sz; i < N_FREE_LISTS;
+         i++, sz *= 2) {
+         for (p = GC_stack_free_lists[i]; p != 0; p = *(ptr_t *)p) {
+             h = (struct hblk *)(((word)p + HBLKSIZE-1) & ~(HBLKSIZE-1));
+             if ((ptr_t)h == p) {
+                 GC_is_fresh((struct hblk *)p, divHBLKSZ(sz));
+             } else {
+                 GC_is_fresh((struct hblk *)p, divHBLKSZ(sz) - 1);
+                 BZERO(p, (ptr_t)h - p);
+             }
+         }
+    }
+    GC_my_stack_limits();
+}
+
+/* The set of all known threads.  We intercept thread creation and 	*/
+/* joins.  We never actually create detached threads.  We allocate all 	*/
+/* new thread stacks ourselves.  These allow us to maintain this	*/
+/* data structure.							*/
+/* Protected by GC_thr_lock.						*/
+/* Some of this should be declared vaolatile, but that's incosnsistent	*/
+/* with some library routine declarations.  In particular, the 		*/
+/* definition of cond_t doesn't mention volatile!			*/
+typedef struct GC_Thread_Rep {
+    struct GC_Thread_Rep * next;
+    thread_t id;
+    word flags;
+#	define FINISHED 1   	/* Thread has exited.	*/
+#	define DETACHED 2	/* Thread is intended to be detached.	*/
+#	define CLIENT_OWNS_STACK	4
+				/* Stack was supplied by client.	*/
+#	define SUSPENDED 8	/* Currently suspended.	*/	
+    ptr_t stack;
+    size_t stack_size;
+    cond_t join_cv;
+    void * status;
+} * GC_thread;
+
+# define THREAD_TABLE_SZ 128	/* Must be power of 2	*/
+volatile GC_thread GC_threads[THREAD_TABLE_SZ];
+
+/* Add a thread to GC_threads.  We assume it wasn't already there.	*/
+/* Caller holds allocation lock.					*/
+GC_thread GC_new_thread(thread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    GC_thread result;
+    static struct GC_Thread_Rep first_thread;
+    static bool first_thread_used = FALSE;
+    
+    if (!first_thread_used) {
+    	result = &first_thread;
+    	first_thread_used = TRUE;
+    	/* Dont acquire allocation lock, since we may already hold it. */
+    } else {
+        result = (struct GC_Thread_Rep *)
+        	 GC_generic_malloc_inner(sizeof(struct GC_Thread_Rep), NORMAL);
+    }
+    if (result == 0) return(0);
+    result -> id = id;
+    result -> next = GC_threads[hv];
+    GC_threads[hv] = result;
+    /* result -> finished = 0; */
+    (void) cond_init(&(result->join_cv), USYNC_THREAD, 0);
+    return(result);
+}
+
+/* Delete a thread from GC_threads.  We assume it is there.	*/
+/* (The code intentionally traps if it wasn't.)			*/
+/* Caller holds allocation lock.				*/
+void GC_delete_thread(thread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    register GC_thread p = GC_threads[hv];
+    register GC_thread prev = 0;
+    
+    while (p -> id != id) {
+        prev = p;
+        p = p -> next;
+    }
+    if (prev == 0) {
+        GC_threads[hv] = p -> next;
+    } else {
+        prev -> next = p -> next;
+    }
+}
+
+/* Return the GC_thread correpsonding to a given thread_t.	*/
+/* Returns 0 if it's not there.					*/
+/* Caller holds  allocation lock.				*/
+GC_thread GC_lookup_thread(thread_t id)
+{
+    int hv = ((word)id) % THREAD_TABLE_SZ;
+    register GC_thread p = GC_threads[hv];
+    
+    while (p != 0 && p -> id != id) p = p -> next;
+    return(p);
+}
+
+/* Notify dirty bit implementation of unused parts of my stack. */
+/* Caller holds allocation lock.				*/
+void GC_my_stack_limits()
+{
+    int dummy;
+    register ptr_t hottest = (ptr_t)((word)(&dummy) & ~(HBLKSIZE-1));
+    register GC_thread me = GC_lookup_thread(thr_self());
+    register size_t stack_size = me -> stack_size;
+    register ptr_t stack;
+    
+    if (stack_size == 0) {
+      /* original thread */
+        struct rlimit rl;
+         
+        if (getrlimit(RLIMIT_STACK, &rl) != 0) ABORT("getrlimit failed");
+        /* Empirically, what should be the stack page with lowest	*/
+        /* address is actually inaccessible.				*/
+        stack_size = ((word)rl.rlim_cur & ~(HBLKSIZE-1)) - GC_page_sz;
+        stack = GC_stackbottom - stack_size + GC_page_sz;
+    } else {
+        stack = me -> stack;
+    }
+    if (stack > hottest || stack + stack_size < hottest) {
+    	ABORT("sp out of bounds");
+    }
+    GC_is_fresh((struct hblk *)stack, divHBLKSZ(hottest - stack));
+}
+
+
+extern ptr_t GC_approx_sp();
+
+/* We hold allocation lock.  We assume the world is stopped.	*/
+void GC_push_all_stacks()
+{
+    register int i;
+    register GC_thread p;
+    register ptr_t sp = GC_approx_sp();
+    register ptr_t bottom, top;
+    struct rlimit rl;
+    
+#   define PUSH(bottom,top) \
+      if (GC_dirty_maintained) { \
+	GC_push_dirty((bottom), (top), GC_page_was_ever_dirty, \
+		      GC_push_all_stack); \
+      } else { \
+        GC_push_all_stack((bottom), (top)); \
+      }
+    GC_thr_init();
+    for (i = 0; i < THREAD_TABLE_SZ; i++) {
+      for (p = GC_threads[i]; p != 0; p = p -> next) {
+        if (p -> stack_size != 0) {
+            bottom = p -> stack;
+            top = p -> stack + p -> stack_size;
+        } else {
+            /* The original stack. */
+            if (getrlimit(RLIMIT_STACK, &rl) != 0) ABORT("getrlimit failed");
+            bottom = GC_stackbottom - rl.rlim_cur + GC_page_sz;
+            top = GC_stackbottom;
+        }
+        if ((word)sp > (word)bottom && (word)sp < (word)top) bottom = sp;
+        PUSH(bottom, top);
+      }
+    }
+}
+
+/* The only thread that ever really performs a thr_join.	*/
+void * GC_thr_daemon(void * dummy)
+{
+    void *status;
+    thread_t departed;
+    register GC_thread t;
+    register int i;
+    register int result;
+    
+    for(;;) {
+      start:
+        result = thr_join((thread_t)0, &departed, &status);
+    	LOCK();
+    	if (result != 0) {
+    	    /* No more threads; wait for create. */
+    	    for (i = 0; i < THREAD_TABLE_SZ; i++) {
+    	        for (t = GC_threads[i]; t != 0; t = t -> next) {
+                    if (!(t -> flags & (DETACHED | FINISHED))) {
+                      UNLOCK();
+                      goto start; /* Thread started just before we */
+                      		  /* acquired the lock.		   */
+                    }
+                }
+            }
+            cond_wait(&GC_create_cv, &GC_allocate_ml);
+            UNLOCK();
+    	} else {
+    	    t = GC_lookup_thread(departed);
+	    GC_multithreaded--;
+    	    if (!(t -> flags & CLIENT_OWNS_STACK)) {
+    	    	GC_stack_free(t -> stack, t -> stack_size);
+    	    }
+    	    if (t -> flags & DETACHED) {
+    	    	GC_delete_thread(departed);
+    	    } else {
+    	        t -> status = status;
+    	    	t -> flags |= FINISHED;
+    	    	cond_signal(&(t -> join_cv));
+    	    	cond_broadcast(&GC_prom_join_cv);
+    	    }
+    	    UNLOCK();
+    	}
+    }
+}
+
+/* We hold the allocation lock.	*/
+void GC_thr_init()
+{
+    GC_thread t;
+
+    if (GC_thr_initialized) return;
+    GC_thr_initialized = TRUE;
+    GC_min_stack_sz = ((thr_min_stack() + 128*1024 + HBLKSIZE-1)
+    		       & ~(HBLKSIZE - 1));
+    GC_page_sz = sysconf(_SC_PAGESIZE);
+    cond_init(&GC_prom_join_cv, USYNC_THREAD, 0);
+    cond_init(&GC_create_cv, USYNC_THREAD, 0);
+    /* Add the initial thread, so we can stop it.	*/
+      t = GC_new_thread(thr_self());
+      t -> stack_size = 0;
+      t -> flags = DETACHED | CLIENT_OWNS_STACK;
+    if (thr_create(0 /* stack */, 0 /* stack_size */, GC_thr_daemon,
+    		   0 /* arg */, THR_DETACHED | THR_DAEMON,
+    		   0 /* thread_id */) != 0) {
+    	ABORT("Cant fork daemon");
+    }
+    
+}
+
+/* We acquire the allocation lock to prevent races with 	*/
+/* stopping/starting world.					*/
+/* This is no more correct than the underlying Solaris 2.X	*/
+/* implementation.  Under 2.3 THIS IS BROKEN.			*/
+int GC_thr_suspend(thread_t target_thread)
+{
+    GC_thread t;
+    int result;
+    
+    LOCK();
+    result = thr_suspend(target_thread);
+    if (result == 0) {
+    	t = GC_lookup_thread(target_thread);
+    	if (t == 0) ABORT("thread unknown to GC");
+        t -> flags |= SUSPENDED;
+    }
+    UNLOCK();
+    return(result);
+}
+
+int GC_thr_continue(thread_t target_thread)
+{
+    GC_thread t;
+    int result;
+    
+    LOCK();
+    result = thr_continue(target_thread);
+    if (result == 0) {
+    	t = GC_lookup_thread(target_thread);
+    	if (t == 0) ABORT("thread unknown to GC");
+        t -> flags &= ~SUSPENDED;
+    }
+    UNLOCK();
+    return(result);
+}
+
+int GC_thr_join(thread_t wait_for, thread_t *departed, void **status)
+{
+    register GC_thread t;
+    int result = 0;
+    
+    LOCK();
+    if (wait_for == 0) {
+        register int i;
+        register bool thread_exists;
+    
+    	for (;;) {
+    	  thread_exists = FALSE;
+    	  for (i = 0; i < THREAD_TABLE_SZ; i++) {
+    	    for (t = GC_threads[i]; t != 0; t = t -> next) {
+              if (!(t -> flags & DETACHED)) {
+                if (t -> flags & FINISHED) {
+                  goto found;
+                }
+                thread_exists = TRUE;
+              }
+            }
+          }
+          if (!thread_exists) {
+              result = ESRCH;
+    	      goto out;
+          }
+          cond_wait(&GC_prom_join_cv, &GC_allocate_ml);
+        }
+    } else {
+        t = GC_lookup_thread(wait_for);
+    	if (t == 0 || t -> flags & DETACHED) {
+    	    result = ESRCH;
+    	    goto out;
+    	}
+    	if (wait_for == thr_self()) {
+    	    result = EDEADLK;
+    	    goto out;
+    	}
+    	while (!(t -> flags & FINISHED)) {
+            cond_wait(&(t -> join_cv), &GC_allocate_ml);
+    	}
+    	
+    }
+  found:
+    if (status) *status = t -> status;
+    if (departed) *departed = t -> id;
+    cond_destroy(&(t -> join_cv));
+    GC_delete_thread(t -> id);
+  out:
+    UNLOCK();
+    return(result);
+}
+
+
+int
+GC_thr_create(void *stack_base, size_t stack_size,
+              void *(*start_routine)(void *), void *arg, long flags,
+              thread_t *new_thread)
+{
+    int result;
+    GC_thread t;
+    thread_t my_new_thread;
+    word my_flags = 0;
+    void * stack = stack_base;
+   
+    LOCK();
+    GC_thr_init();
+    GC_multithreaded++;
+    if (stack == 0) {
+     	if (stack_size == 0) stack_size = GC_min_stack_sz;
+     	stack = (void *)GC_stack_alloc(&stack_size);
+     	if (stack == 0) {
+     	    UNLOCK();
+     	    return(ENOMEM);
+     	}
+    } else {
+    	my_flags |= CLIENT_OWNS_STACK;
+    }
+    if (flags & THR_DETACHED) my_flags |= DETACHED;
+    if (flags & THR_SUSPENDED) my_flags |= SUSPENDED;
+    result = thr_create(stack, stack_size, start_routine,
+   		        arg, flags & ~THR_DETACHED, &my_new_thread);
+    if (result == 0) {
+        t = GC_new_thread(my_new_thread);
+        t -> flags = my_flags;
+        if (!(my_flags & DETACHED)) cond_init(&(t -> join_cv), USYNC_THREAD, 0);
+        t -> stack = stack;
+        t -> stack_size = stack_size;
+        if (new_thread != 0) *new_thread = my_new_thread;
+        cond_signal(&GC_create_cv);
+    } else {
+	GC_multithreaded--;
+        if (!(my_flags & CLIENT_OWNS_STACK)) {
+      	    GC_stack_free(stack, stack_size);
+	}
+    }        
+    UNLOCK();  
+    return(result);
+}
+
+# else
+
+#ifndef LINT
+  int GC_no_sunOS_threads;
+#endif
+
+# endif /* SOLARIS_THREADS */
+
diff --git a/src/mzscheme/gc/sparc_mach_dep.s b/src/mzscheme/gc/sparc_mach_dep.s
new file mode 100644
index 0000000..a6a0a24
--- /dev/null
+++ b/src/mzscheme/gc/sparc_mach_dep.s
@@ -0,0 +1,38 @@
+!	SPARCompiler 3.0 and later apparently no loner handles
+!	asm outside functions.  So we need a separate .s file
+!	This is only set up for SunOS 5, not SunOS 4.
+!	Assumes this is called before the stack contents are
+!	examined.
+
+	.seg 	"text"
+	.globl	GC_save_regs_in_stack
+	.globl 	GC_push_regs
+GC_save_regs_in_stack:
+GC_push_regs:
+	ta	0x3   ! ST_FLUSH_WINDOWS
+	mov	%sp,%o0
+	retl
+	nop
+	
+	.globl	GC_clear_stack_inner
+GC_clear_stack_inner:
+	mov	%sp,%o2		! Save sp
+	add	%sp,-8,%o3	! p = sp-8
+	clr	%g1		! [g0,g1] = 0
+	add	%o1,-0x60,%sp	! Move sp out of the way,
+				! so that traps still work.
+				! Includes some extra words
+				! so we can be sloppy below.
+loop:
+	std	%g0,[%o3]	! *(long long *)p = 0
+	cmp	%o3,%o1
+	bgu	loop		! if (p > limit) goto loop
+	  add	%o3,-8,%o3	! p -= 8 (delay slot)
+	retl
+	  mov	%o2,%sp		! Restore sp., delay slot
+	
+		
+		
+		
+		
+	
\ No newline at end of file
diff --git a/src/mzscheme/gc/stubborn.c b/src/mzscheme/gc/stubborn.c
new file mode 100644
index 0000000..ab228fb
--- /dev/null
+++ b/src/mzscheme/gc/stubborn.c
@@ -0,0 +1,317 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, July 31, 1995 5:02 pm PDT */
+
+
+#include "gc_priv.h"
+
+# ifdef STUBBORN_ALLOC
+/* Stubborn object (hard to change, nearly immutable) allocation. */
+
+extern ptr_t GC_clear_stack();	/* in misc.c, behaves like identity */
+
+#define GENERAL_MALLOC(lb,k) \
+    (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
+
+/* Data structure representing immutable objects that 	*/
+/* are still being initialized.				*/
+/* This is a bit baroque in order to avoid acquiring	*/
+/* the lock twice for a typical allocation.		*/
+
+GC_PTR * GC_changing_list_start;
+
+# ifdef THREADS
+  VOLATILE GC_PTR * VOLATILE GC_changing_list_current;
+# else
+  GC_PTR * GC_changing_list_current;
+# endif
+	/* Points at last added element.  Also (ab)used for		*/
+	/* synchronization.  Updates and reads are assumed atomic.	*/
+
+GC_PTR * GC_changing_list_limit;
+	/* Points at the last word of the buffer, which is always 0	*/
+	/* All entries in (GC_changing_list_current,			*/
+	/* GC_changing_list_limit] are 0				*/
+
+
+void GC_stubborn_init()
+{
+#   define INIT_SIZE 10
+
+    GC_changing_list_start = (GC_PTR *)
+    			GC_generic_malloc_inner(
+    				(word)(INIT_SIZE * sizeof(GC_PTR)),
+    				PTRFREE);
+    BZERO(GC_changing_list_start,
+    	  INIT_SIZE * sizeof(GC_PTR));
+    if (GC_changing_list_start == 0) {
+        GC_err_printf0("Insufficient space to start up\n");
+        ABORT("GC_stubborn_init: put of space");
+    }
+    GC_changing_list_current = GC_changing_list_start;
+    GC_changing_list_limit = GC_changing_list_start + INIT_SIZE - 1;
+    * GC_changing_list_limit = 0;
+}
+
+/* Compact and possibly grow GC_uninit_list.  The old copy is		*/
+/* left alone.	Lock must be held.					*/
+/* When called GC_changing_list_current == GC_changing_list_limit	*/
+/* which is one past the current element.				*/
+/* When we finish GC_changing_list_current again points one past last	*/
+/* element.								*/
+/* Invariant while this is running: GC_changing_list_current    	*/
+/* points at a word containing 0.					*/
+/* Returns FALSE on failure.						*/
+bool GC_compact_changing_list()
+{
+    register GC_PTR *p, *q;
+    register word count = 0;
+    word old_size = (char **)GC_changing_list_limit
+    		    - (char **)GC_changing_list_start+1;
+    		    /* The casts are needed as a workaround for an Amiga bug */
+    register word new_size = old_size;
+    GC_PTR * new_list;
+    
+    for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {
+        if (*p != 0) count++;
+    }
+    if (2 * count > old_size) new_size = 2 * count;
+    new_list = (GC_PTR *)
+    		GC_generic_malloc_inner(
+    				new_size * sizeof(GC_PTR), PTRFREE);
+    		/* PTRFREE is a lie.  But we don't want the collector to  */
+    		/* consider these.  We do want the list itself to be  	  */
+    		/* collectable.						  */
+    if (new_list == 0) return(FALSE);
+    BZERO(new_list, new_size * sizeof(GC_PTR));
+    q = new_list;
+    for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {
+        if (*p != 0) *q++ = *p;
+    }
+    GC_changing_list_start = new_list;
+    GC_changing_list_limit = new_list + new_size - 1;
+    GC_changing_list_current = q;
+    return(TRUE);
+}
+
+/* Add p to changing list.  Clear p on failure.	*/
+# define ADD_CHANGING(p) \
+	{	\
+	    register struct hblk * h = HBLKPTR(p);	\
+	    register word index = PHT_HASH(h);	\
+	    \
+	    set_pht_entry_from_index(GC_changed_pages, index);	\
+	}	\
+	if (*GC_changing_list_current != 0 \
+	    && ++GC_changing_list_current == GC_changing_list_limit) { \
+	    if (!GC_compact_changing_list()) (p) = 0; \
+	} \
+	*GC_changing_list_current = p;
+
+void GC_change_stubborn(p)
+GC_PTR p;
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    ADD_CHANGING(p);
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+void GC_end_stubborn_change(p)
+GC_PTR p;
+{
+#   ifdef THREADS
+      register VOLATILE GC_PTR * my_current = GC_changing_list_current;
+#   else
+      register GC_PTR * my_current = GC_changing_list_current;
+#   endif
+    register bool tried_quick;
+    DCL_LOCK_STATE;
+    
+    if (*my_current == p) {
+        /* Hopefully the normal case.					*/
+        /* Compaction could not have been running when we started.	*/
+        *my_current = 0;
+#	ifdef THREADS
+          if (my_current == GC_changing_list_current) {
+            /* Compaction can't have run in the interim. 	*/
+            /* We got away with the quick and dirty approach.   */
+            return;
+          }
+          tried_quick = TRUE;
+#	else
+	  return;
+#	endif
+    } else {
+        tried_quick = FALSE;
+    }
+    DISABLE_SIGNALS();
+    LOCK();
+    my_current = GC_changing_list_current;
+    for (; my_current >= GC_changing_list_start; my_current--) {
+        if (*my_current == p) {
+            *my_current = 0;
+            UNLOCK();
+            ENABLE_SIGNALS();
+            return;
+        }
+    }
+    if (!tried_quick) {
+        GC_err_printf1("Bad arg to GC_end_stubborn_change: 0x%lx\n",
+        	       (unsigned long)p);
+        ABORT("Bad arg to GC_end_stubborn_change");
+    }
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+/* Allocate lb bytes of composite (pointerful) data	*/
+/* No pointer fields may be changed after a call to	*/
+/* GC_end_stubborn_change(p) where p is the value	*/
+/* returned by GC_malloc_stubborn.			*/
+# ifdef __STDC__
+    GC_PTR GC_malloc_stubborn(size_t lb)
+# else
+    GC_PTR GC_malloc_stubborn(lb)
+    size_t lb;
+# endif
+{
+register ptr_t op;
+register ptr_t *opp;
+register word lw;
+ptr_t result;
+DCL_LOCK_STATE;
+
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_sobjfreelist[lw]);
+	FASTLOCK();
+        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
+            FASTUNLOCK();
+            result = GC_generic_malloc((word)lb, STUBBORN);
+            goto record;
+        }
+        *opp = obj_link(op);
+        obj_link(op) = 0;
+        GC_words_allocd += lw;
+        result = (GC_PTR) op;
+        ADD_CHANGING(result);
+        FASTUNLOCK();
+        return((GC_PTR)result);
+   } else {
+       result = (GC_PTR)
+          	GC_generic_malloc((word)lb, STUBBORN);
+   }
+record:
+   DISABLE_SIGNALS();
+   LOCK();
+   ADD_CHANGING(result);
+   UNLOCK();
+   ENABLE_SIGNALS();
+   return((GC_PTR)GC_clear_stack(result));
+}
+
+
+/* Functions analogous to GC_read_dirty and GC_page_was_dirty.	*/
+/* Report pages on which stubborn objects were changed.		*/
+void GC_read_changed()
+{
+    register GC_PTR * p = GC_changing_list_start;
+    register GC_PTR q;
+    register struct hblk * h;
+    register word index;
+    
+    if (p == 0) /* initializing */ return;
+    BCOPY(GC_changed_pages, GC_prev_changed_pages,
+          (sizeof GC_changed_pages));
+    BZERO(GC_changed_pages, (sizeof GC_changed_pages));
+    for (; p <= GC_changing_list_current; p++) {
+        if ((q = *p) != 0) {
+            h = HBLKPTR(q);
+            index = PHT_HASH(h);
+            set_pht_entry_from_index(GC_changed_pages, index);
+        }
+    }
+}
+
+bool GC_page_was_changed(h)
+struct hblk * h;
+{
+    register word index = PHT_HASH(h);
+    
+    return(get_pht_entry_from_index(GC_prev_changed_pages, index));
+}
+
+/* Remove unreachable entries from changed list. Should only be	*/
+/* called with mark bits consistent and lock held.		*/
+void GC_clean_changing_list()
+{
+    register GC_PTR * p = GC_changing_list_start;
+    register GC_PTR q;
+    register ptr_t r;
+    register unsigned long count = 0;
+    register unsigned long dropped_count = 0;
+    
+    if (p == 0) /* initializing */ return;
+    for (; p <= GC_changing_list_current; p++) {
+        if ((q = *p) != 0) {
+            count++;
+            r = (ptr_t)GC_base(q);
+            if (r == 0 || !GC_is_marked(r)) {
+                *p = 0;
+                dropped_count++;
+	    }
+        }
+    }
+#   ifdef PRINTSTATS
+      if (count > 0) {
+        GC_printf2("%lu entries in changing list: reclaimed %lu\n",
+                  (unsigned long)count, (unsigned long)dropped_count);
+      }
+#   endif
+}
+
+#else /* !STUBBORN_ALLOC */
+
+# ifdef __STDC__
+    GC_PTR GC_malloc_stubborn(size_t lb)
+# else
+    GC_PTR GC_malloc_stubborn(lb)
+    size_t lb;
+# endif
+{
+    return(GC_malloc(lb));
+}
+
+/*ARGSUSED*/
+void GC_end_stubborn_change(p)
+GC_PTR p;
+{
+}
+
+/*ARGSUSED*/
+void GC_change_stubborn(p)
+GC_PTR p;
+{
+}
+
+
+#endif
diff --git a/src/mzscheme/gc/test.c b/src/mzscheme/gc/test.c
new file mode 100644
index 0000000..eae7243
--- /dev/null
+++ b/src/mzscheme/gc/test.c
@@ -0,0 +1,1126 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* An incomplete test for the garbage collector.  		*/
+/* Some more obscure entry points are not tested at all.	*/
+
+# if defined(mips) && defined(SYSTYPE_BSD43)
+    /* MIPS RISCOS 4 */
+# else
+#   include <stdlib.h>
+# endif
+# include <stdio.h>
+# include <assert.h>	/* Not normally used, but handy for debugging. */
+# include "gc.h"
+# include "gc_typed.h"
+# include "gc_priv.h"	/* For output and some statistics	*/
+# include "config.h"
+
+# ifdef MSWIN32
+#   include <windows.h>
+# endif
+
+# ifdef PCR
+#   include "th/PCR_ThCrSec.h"
+#   include "th/PCR_Th.h"
+#   undef GC_printf0
+#   define GC_printf0 printf
+#   undef GC_printf1
+#   define GC_printf1 printf
+# endif
+
+# ifdef SOLARIS_THREADS
+#   include <thread.h>
+#   include <synch.h>
+# endif
+
+# ifdef IRIX_THREADS
+#   include <pthread.h>
+# endif
+
+# ifdef WIN32_THREADS
+#   include <process.h>
+    static CRITICAL_SECTION incr_cs;
+# endif
+# if defined(PCR) || defined(SOLARIS_THREADS) || defined(WIN32_THREADS)
+#   define THREADS
+# endif
+
+# ifdef AMIGA
+   long __stack = 200000;
+# endif
+
+# define FAIL (void)abort()
+
+/* AT_END may be defined to excercise the interior pointer test	*/
+/* if the collector is configured with ALL_INTERIOR_POINTERS.   */
+/* As it stands, this test should succeed with either		*/
+/* configuration.  In the FIND_LEAK configuration, it should	*/
+/* find lots of leaks, since we free almost nothing.		*/
+
+struct SEXPR {
+    struct SEXPR * sexpr_car;
+    struct SEXPR * sexpr_cdr;
+};
+
+
+typedef struct SEXPR * sexpr;
+
+# define INT_TO_SEXPR(x) ((sexpr)(unsigned long)(x))
+
+# undef nil
+# define nil (INT_TO_SEXPR(0))
+# define car(x) ((x) -> sexpr_car)
+# define cdr(x) ((x) -> sexpr_cdr)
+# define is_nil(x) ((x) == nil)
+
+
+int extra_count = 0;        /* Amount of space wasted in cons node */
+
+/* Silly implementation of Lisp cons. Intentionally wastes lots of space */
+/* to test collector.                                                    */
+sexpr cons (x, y)
+sexpr x;
+sexpr y;
+{
+    register sexpr r;
+    register int *p;
+    register int my_extra = extra_count;
+    
+    r = (sexpr) GC_MALLOC_STUBBORN(sizeof(struct SEXPR) + my_extra);
+    if (r == 0) {
+        (void)GC_printf0("Out of memory\n");
+        exit(1);
+    }
+    for (p = (int *)r;
+         ((char *)p) < ((char *)r) + my_extra + sizeof(struct SEXPR); p++) {
+	if (*p) {
+	    (void)GC_printf1("Found nonzero at 0x%lx - allocator is broken\n",
+	    		     (unsigned long)p);
+	    FAIL;
+        }
+        *p = 13;
+    }
+#   ifdef AT_END
+	r = (sexpr)((char *)r + (my_extra & ~7));
+#   endif
+    r -> sexpr_car = x;
+    r -> sexpr_cdr = y;
+    my_extra++;
+    if ( my_extra >= 5000 ) {
+        extra_count = 0;
+    } else {
+        extra_count = my_extra;
+    }
+    GC_END_STUBBORN_CHANGE((char *)r);
+    return(r);
+}
+
+sexpr small_cons (x, y)
+sexpr x;
+sexpr y;
+{
+    register sexpr r;
+    
+    r = (sexpr) GC_MALLOC(sizeof(struct SEXPR));
+    if (r == 0) {
+        (void)GC_printf0("Out of memory\n");
+        exit(1);
+    }
+    r -> sexpr_car = x;
+    r -> sexpr_cdr = y;
+    return(r);
+}
+
+sexpr small_cons_uncollectable (x, y)
+sexpr x;
+sexpr y;
+{
+    register sexpr r;
+    
+    r = (sexpr) GC_MALLOC_UNCOLLECTABLE(sizeof(struct SEXPR));
+assert(GC_is_marked(r));
+    if (r == 0) {
+        (void)GC_printf0("Out of memory\n");
+        exit(1);
+    }
+    r -> sexpr_car = x;
+    r -> sexpr_cdr = (sexpr)(~(unsigned long)y);
+    return(r);
+}
+
+/* Return reverse(x) concatenated with y */
+sexpr reverse1(x, y)
+sexpr x, y;
+{
+    if (is_nil(x)) {
+        return(y);
+    } else {
+        return( reverse1(cdr(x), cons(car(x), y)) );
+    }
+}
+
+sexpr reverse(x)
+sexpr x;
+{
+    return( reverse1(x, nil) );
+}
+
+sexpr ints(low, up)
+int low, up;
+{
+    if (low > up) {
+	return(nil);
+    } else {
+        return(small_cons(small_cons(INT_TO_SEXPR(low), nil), ints(low+1, up)));
+    }
+}
+
+/* To check uncollectable allocation we build lists with disguised cdr	*/
+/* pointers, and make sure they don't go away.				*/
+sexpr uncollectable_ints(low, up)
+int low, up;
+{
+    if (low > up) {
+	return(nil);
+    } else {
+        return(small_cons_uncollectable(small_cons(INT_TO_SEXPR(low), nil),
+               uncollectable_ints(low+1, up)));
+    }
+}
+
+void check_ints(list, low, up)
+sexpr list;
+int low, up;
+{
+    if ((int)(GC_word)(car(car(list))) != low) {
+        (void)GC_printf0(
+           "List reversal produced incorrect list - collector is broken\n");
+        FAIL;
+    }
+    if (low == up) {
+        if (cdr(list) != nil) {
+           (void)GC_printf0("List too long - collector is broken\n");
+           FAIL;
+        }
+    } else {
+        check_ints(cdr(list), low+1, up);
+    }
+}
+
+# define UNCOLLECTABLE_CDR(x) (sexpr)(~(unsigned long)(cdr(x)))
+
+void check_uncollectable_ints(list, low, up)
+sexpr list;
+int low, up;
+{
+assert(GC_is_marked(list));
+    if ((int)(GC_word)(car(car(list))) != low) {
+        (void)GC_printf0(
+           "Uncollectable list corrupted - collector is broken\n");
+        FAIL;
+    }
+    if (low == up) {
+        if (UNCOLLECTABLE_CDR(list) != nil) {
+           (void)GC_printf0("Uncollectable list too long - collector is broken\n");
+           FAIL;
+        }
+    } else {
+        check_uncollectable_ints(UNCOLLECTABLE_CDR(list), low+1, up);
+    }
+}
+
+/* Not used, but useful for debugging: */
+void print_int_list(x)
+sexpr x;
+{
+    if (is_nil(x)) {
+        (void)GC_printf0("NIL\n");
+    } else {
+        (void)GC_printf1("(%ld)", (long)(car(car(x))));
+        if (!is_nil(cdr(x))) {
+            (void)GC_printf0(", ");
+            (void)print_int_list(cdr(x));
+        } else {
+            (void)GC_printf0("\n");
+        }
+    }
+}
+
+/* Try to force a to be strangely aligned */
+struct {
+  char dummy;
+  sexpr aa;
+} A;
+#define a A.aa
+
+/*
+ * Repeatedly reverse lists built out of very different sized cons cells.
+ * Check that we didn't lose anything.
+ */
+void reverse_test()
+{
+    int i;
+    sexpr b;
+    sexpr c;
+    sexpr d;
+    sexpr e;
+    sexpr *f, *g, *h;
+#   if defined(MSWIN32) || defined(MACOS)
+      /* Win32S only allows 128K stacks */
+#     define BIG 1000
+#   else
+#     if defined PCR
+	/* PCR default stack is 100K.  Stack frames are up to 120 bytes. */
+#	define BIG 700
+#     else
+#       define BIG 4500
+#     endif
+#   endif
+
+    A.dummy = 17;
+    a = ints(1, 49);
+    b = ints(1, 50);
+    c = ints(1, BIG);
+    d = uncollectable_ints(1, 100);
+    e = uncollectable_ints(1, 1);
+    /* Check that realloc updates object descriptors correctly */
+    f = (sexpr *)GC_malloc(4 * sizeof(sexpr));
+    f = (sexpr *)GC_realloc((GC_PTR)f, 6 * sizeof(sexpr));
+    f[5] = ints(1,17);
+    g = (sexpr *)GC_malloc(513 * sizeof(sexpr));
+    g = (sexpr *)GC_realloc((GC_PTR)g, 800 * sizeof(sexpr));
+    g[799] = ints(1,18);
+    h = (sexpr *)GC_malloc(1025 * sizeof(sexpr));
+    h = (sexpr *)GC_realloc((GC_PTR)h, 2000 * sizeof(sexpr));
+    h[1999] = ints(1,19);
+    /* Try to force some collections and reuse of small list elements */
+      for (i = 0; i < 10; i++) {
+        (void)ints(1, BIG);
+      }
+    /* Superficially test interior pointer recognition on stack */
+    c = (sexpr)((char *)c + sizeof(char *));
+    d = (sexpr)((char *)d + sizeof(char *));
+
+#   ifdef __STDC__
+        GC_FREE((void *)e);
+#   else
+        GC_FREE((char *)e);
+#   endif
+    check_ints(b,1,50);
+    check_ints(a,1,49);
+    for (i = 0; i < 50; i++) {
+        check_ints(b,1,50);
+        b = reverse(reverse(b));
+    }
+    check_ints(b,1,50);
+    check_ints(a,1,49);
+    for (i = 0; i < 60; i++) {
+    	/* This maintains the invariant that a always points to a list of */
+    	/* 49 integers.  Thus this is thread safe without locks,	  */
+    	/* assuming atomic pointer assignments.				  */
+        a = reverse(reverse(a));
+#	if !defined(AT_END) && !defined(THREADS)
+	  /* This is not thread safe, since realloc explicitly deallocates */
+          if (i & 1) {
+            a = (sexpr)GC_REALLOC((GC_PTR)a, 500);
+          } else {
+            a = (sexpr)GC_REALLOC((GC_PTR)a, 8200);
+          }
+#	endif
+    }
+    check_ints(a,1,49);
+    check_ints(b,1,50);
+    c = (sexpr)((char *)c - sizeof(char *));
+    d = (sexpr)((char *)d - sizeof(char *));
+    check_ints(c,1,BIG);
+    check_uncollectable_ints(d, 1, 100);
+    check_ints(f[5], 1,17);
+    check_ints(g[799], 1,18);
+    check_ints(h[1999], 1,19);
+#   ifndef THREADS
+	a = 0;
+#   endif  
+    b = c = 0;
+}
+
+/*
+ * The rest of this builds balanced binary trees, checks that they don't
+ * disappear, and tests finalization.
+ */
+typedef struct treenode {
+    int level;
+    struct treenode * lchild;
+    struct treenode * rchild;
+} tn;
+
+int finalizable_count = 0;
+int finalized_count = 0;
+VOLATILE int dropped_something = 0;
+
+# ifdef __STDC__
+  void finalizer(void * obj, void * client_data)
+# else
+  void finalizer(obj, client_data)
+  char * obj;
+  char * client_data;
+# endif
+{
+  tn * t = (tn *)obj;
+
+# ifdef PCR
+     PCR_ThCrSec_EnterSys();
+# endif
+# ifdef SOLARIS_THREADS
+    static mutex_t incr_lock;
+    mutex_lock(&incr_lock);
+# endif
+# ifdef IRIX_THREADS
+    static pthread_mutex_t incr_lock = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_lock(&incr_lock);
+# endif
+# ifdef WIN32_THREADS
+    EnterCriticalSection(&incr_cs);
+# endif
+  if ((int)(GC_word)client_data != t -> level) {
+     (void)GC_printf0("Wrong finalization data - collector is broken\n");
+     FAIL;
+  }
+  finalized_count++;
+# ifdef PCR
+    PCR_ThCrSec_ExitSys();
+# endif
+# ifdef SOLARIS_THREADS
+    mutex_unlock(&incr_lock);
+# endif
+# ifdef IRIX_THREADS
+    pthread_mutex_unlock(&incr_lock);
+# endif
+# ifdef WIN32_THREADS
+    LeaveCriticalSection(&incr_cs);
+# endif
+}
+
+size_t counter = 0;
+
+# define MAX_FINALIZED 8000
+
+# if !defined(MACOS)
+  GC_FAR GC_word live_indicators[MAX_FINALIZED] = {0};
+#else
+  /* Too big for THINK_C. have to allocate it dynamically. */
+  GC_word *live_indicators = 0;
+#endif
+
+int live_indicators_count = 0;
+
+tn * mktree(n)
+int n;
+{
+    tn * result = (tn *)GC_MALLOC(sizeof(tn));
+    
+#if defined(MACOS)
+	/* get around static data limitations. */
+	if (!live_indicators)
+		live_indicators =
+		    (GC_word*)NewPtrClear(MAX_FINALIZED * sizeof(GC_word));
+	if (!live_indicators) {
+        (void)GC_printf0("Out of memory\n");
+        exit(1);
+    }
+#endif
+    if (n == 0) return(0);
+    if (result == 0) {
+        (void)GC_printf0("Out of memory\n");
+        exit(1);
+    }
+    result -> level = n;
+    result -> lchild = mktree(n-1);
+    result -> rchild = mktree(n-1);
+    if (counter++ % 17 == 0 && n >= 2) {
+        tn * tmp = result -> lchild -> rchild;
+        
+        result -> lchild -> rchild = result -> rchild -> lchild;
+        result -> rchild -> lchild = tmp;
+    }
+    if (counter++ % 119 == 0) {
+        int my_index;
+        
+        {
+#	  ifdef PCR
+ 	    PCR_ThCrSec_EnterSys();
+#	  endif
+#	  ifdef SOLARIS_THREADS
+	    static mutex_t incr_lock;
+	    mutex_lock(&incr_lock);
+#	  endif
+#         ifdef IRIX_THREADS
+            static pthread_mutex_t incr_lock = PTHREAD_MUTEX_INITIALIZER;
+            pthread_mutex_lock(&incr_lock);
+#         endif
+#         ifdef WIN32_THREADS
+            EnterCriticalSection(&incr_cs);
+#         endif
+		/* Losing a count here causes erroneous report of failure. */
+          finalizable_count++;
+          my_index = live_indicators_count++;
+#	  ifdef PCR
+ 	    PCR_ThCrSec_ExitSys();
+#	  endif
+#	  ifdef SOLARIS_THREADS
+	    mutex_unlock(&incr_lock);
+#	  endif
+#	  ifdef IRIX_THREADS
+	    pthread_mutex_unlock(&incr_lock);
+#	  endif
+#         ifdef WIN32_THREADS
+            LeaveCriticalSection(&incr_cs);
+#         endif
+	}
+
+        GC_REGISTER_FINALIZER((GC_PTR)result, finalizer, (GC_PTR)(GC_word)n,
+        		      (GC_finalization_proc *)0, (GC_PTR *)0);
+        if (my_index >= MAX_FINALIZED) {
+		GC_printf0("live_indicators overflowed\n");
+		FAIL;
+	}
+        live_indicators[my_index] = 13;
+        if (GC_GENERAL_REGISTER_DISAPPEARING_LINK(
+         	(GC_PTR *)(&(live_indicators[my_index])),
+         	(GC_PTR)result) != 0) {
+         	GC_printf0("GC_general_register_disappearing_link failed\n");
+         	FAIL;
+        }
+        if (GC_unregister_disappearing_link(
+         	(GC_PTR *)
+         	   (&(live_indicators[my_index]))) == 0) {
+         	GC_printf0("GC_unregister_disappearing_link failed\n");
+         	FAIL;
+        }
+        if (GC_GENERAL_REGISTER_DISAPPEARING_LINK(
+         	(GC_PTR *)(&(live_indicators[my_index])),
+         	(GC_PTR)result) != 0) {
+         	GC_printf0("GC_general_register_disappearing_link failed 2\n");
+         	FAIL;
+        }
+    }
+    return(result);
+}
+
+void chktree(t,n)
+tn *t;
+int n;
+{
+    if (n == 0 && t != 0) {
+        (void)GC_printf0("Clobbered a leaf - collector is broken\n");
+        FAIL;
+    }
+    if (n == 0) return;
+    if (t -> level != n) {
+        (void)GC_printf1("Lost a node at level %lu - collector is broken\n",
+        		 (unsigned long)n);
+        FAIL;
+    }
+    if (counter++ % 373 == 0) (void) GC_MALLOC(counter%5001);
+    chktree(t -> lchild, n-1);
+    if (counter++ % 73 == 0) (void) GC_MALLOC(counter%373);
+    chktree(t -> rchild, n-1);
+}
+
+# ifdef SOLARIS_THREADS
+thread_key_t fl_key;
+
+void * alloc8bytes()
+{
+    void ** my_free_list_ptr;
+    void * my_free_list;
+    
+    if (thr_getspecific(fl_key, (void **)(&my_free_list_ptr)) != 0) {
+    	(void)GC_printf0("thr_getspecific failed\n");
+    	FAIL;
+    }
+    if (my_free_list_ptr == 0) {
+        my_free_list_ptr = GC_NEW_UNCOLLECTABLE(void *);
+        if (thr_setspecific(fl_key, my_free_list_ptr) != 0) {
+    	    (void)GC_printf0("thr_setspecific failed\n");
+    	    FAIL;
+        }
+    }
+    my_free_list = *my_free_list_ptr;
+    if (my_free_list == 0) {
+        my_free_list = GC_malloc_many(8);
+        if (my_free_list == 0) {
+            (void)GC_printf0("alloc8bytes out of memory\n");
+    	    FAIL;
+        }
+    }
+    *my_free_list_ptr = GC_NEXT(my_free_list);
+    GC_NEXT(my_free_list) = 0;
+    return(my_free_list);
+}
+
+#else
+# define alloc8bytes() GC_MALLOC_ATOMIC(8)
+#endif
+
+void alloc_small(n)
+int n;
+{
+    register int i;
+    
+    for (i = 0; i < n; i += 8) {
+        if (alloc8bytes() == 0) {
+            (void)GC_printf0("Out of memory\n");
+            FAIL;
+        }
+    }
+}
+
+# if defined(THREADS) && defined(GC_DEBUG)
+#   define TREE_HEIGHT 15
+# else
+#   define TREE_HEIGHT 16
+# endif
+void tree_test()
+{
+    tn * root;
+    register int i;
+    
+    root = mktree(TREE_HEIGHT);
+    alloc_small(5000000);
+    chktree(root, TREE_HEIGHT);
+    if (finalized_count && ! dropped_something) {
+        (void)GC_printf0("Premature finalization - collector is broken\n");
+        FAIL;
+    }
+    dropped_something = 1;
+    GC_noop(root);	/* Root needs to remain live until	*/
+    			/* dropped_something is set.		*/
+    root = mktree(TREE_HEIGHT);
+    chktree(root, TREE_HEIGHT);
+    for (i = TREE_HEIGHT; i >= 0; i--) {
+        root = mktree(i);
+        chktree(root, i);
+    }
+    alloc_small(5000000);
+}
+
+unsigned n_tests = 0;
+
+GC_word bm_huge[10] = {
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0xffffffff,
+    0x00ffffff,
+};
+
+
+/* A very simple test of explicitly typed allocation	*/
+void typed_test()
+{
+    GC_word * old, * new;
+    GC_word bm3 = 0x3;
+    GC_word bm2 = 0x2;
+    GC_word bm_large = 0xf7ff7fff;
+    GC_descr d1 = GC_make_descriptor(&bm3, 2);
+    GC_descr d2 = GC_make_descriptor(&bm2, 2);
+#   ifndef LINT
+      GC_descr dummy = GC_make_descriptor(&bm_large, 32);
+#   endif
+    GC_descr d3 = GC_make_descriptor(&bm_large, 32);
+    GC_descr d4 = GC_make_descriptor(bm_huge, 320);
+    GC_word * x = GC_malloc_explicitly_typed(2000, d4);
+    register int i;
+    
+    old = 0;
+    for (i = 0; i < 4000; i++) {
+        new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d1);
+        new[0] = 17;
+        new[1] = (GC_word)old;
+        old = new;
+        new = (GC_word *) GC_malloc_explicitly_typed(4 * sizeof(GC_word), d2);
+        new[0] = 17;
+        new[1] = (GC_word)old;
+        old = new;
+        new = (GC_word *) GC_malloc_explicitly_typed(33 * sizeof(GC_word), d3);
+        new[0] = 17;
+        new[1] = (GC_word)old;
+        old = new;
+        new = (GC_word *) GC_calloc_explicitly_typed(4, 2 * sizeof(GC_word),
+        					     d1);
+        new[0] = 17;
+        new[1] = (GC_word)old;
+        old = new;
+        if (i & 0xff) {
+          new = (GC_word *) GC_calloc_explicitly_typed(7, 3 * sizeof(GC_word),
+        					     d2);
+        } else {
+          new = (GC_word *) GC_calloc_explicitly_typed(1001,
+          					       3 * sizeof(GC_word),
+        					       d2);
+        }
+        new[0] = 17;
+        new[1] = (GC_word)old;
+        old = new;
+    }
+    for (i = 0; i < 20000; i++) {
+        if (new[0] != 17) {
+            (void)GC_printf1("typed alloc failed at %lu\n",
+            		     (unsigned long)i);
+            FAIL;
+        }
+        new[0] = 0;
+        old = new;
+        new = (GC_word *)(old[1]);
+    }
+    GC_gcollect();
+    GC_noop(x);
+}
+
+int fail_count = 0;
+
+#ifndef __STDC__
+/*ARGSUSED*/
+void fail_proc1(x)
+GC_PTR x;
+{
+    fail_count++;
+}
+
+#else
+
+/*ARGSUSED*/
+void fail_proc1(GC_PTR x)
+{
+    fail_count++;
+}   
+
+#endif /* __STDC__ */
+
+#ifdef THREADS
+#   define TEST_FAIL_COUNT(n) 1
+#else 
+#   define TEST_FAIL_COUNT(n) (fail_count >= (n))
+#endif
+
+void run_one_test()
+{
+    char *x;
+#   ifdef LINT
+    	char *y = 0;
+#   else
+    	char *y = (char *)(size_t)fail_proc1;
+#   endif
+    DCL_LOCK_STATE;
+    
+#   ifdef FIND_LEAK
+	(void)GC_printf0(
+		"This test program is not designed for leak detection mode\n");
+	(void)GC_printf0("Expect lots of problems.\n");
+#   endif
+    if (GC_size(GC_malloc(7)) != 8
+	|| GC_size(GC_malloc(15)) != 16) {
+	    (void)GC_printf0("GC_size produced unexpected results\n");
+	    FAIL;
+    }
+    if (GC_size(GC_malloc(0)) != 4 && GC_size(GC_malloc(0)) != 8) {
+    	(void)GC_printf0("GC_malloc(0) failed\n");
+	    FAIL;
+    }
+    if (GC_size(GC_malloc_uncollectable(0)) != 4
+        && GC_size(GC_malloc_uncollectable(0)) != 8) {
+    	(void)GC_printf0("GC_malloc_uncollectable(0) failed\n");
+	    FAIL;
+    }
+    GC_is_valid_displacement_print_proc = fail_proc1;
+    GC_is_visible_print_proc = fail_proc1;
+    x = GC_malloc(16);
+    if (GC_base(x + 13) != x) {
+    	(void)GC_printf0("GC_base(heap ptr) produced incorrect result\n");
+	FAIL;
+    }
+#   ifndef PCR
+      if (GC_base(y) != 0) {
+    	(void)GC_printf0("GC_base(fn_ptr) produced incorrect result\n");
+	FAIL;
+      }
+#   endif
+    if (GC_same_obj(x+5, x) != x + 5) {
+    	(void)GC_printf0("GC_same_obj produced incorrect result\n");
+	FAIL;
+    }
+    if (GC_is_visible(y) != y || GC_is_visible(x) != x) {
+    	(void)GC_printf0("GC_is_visible produced incorrect result\n");
+	FAIL;
+    }
+    if (!TEST_FAIL_COUNT(1)) {
+#	if!(defined(RS6000) || defined(POWERPC))
+	  /* ON RS6000s function pointers point to a descriptor in the	*/
+	  /* data segment, so there should have been no failures.	*/
+    	  (void)GC_printf0("GC_is_visible produced wrong failure indication\n");
+    	  FAIL;
+#	endif
+    }
+    if (GC_is_valid_displacement(y) != y
+        || GC_is_valid_displacement(x) != x
+        || GC_is_valid_displacement(x + 3) != x + 3) {
+    	(void)GC_printf0(
+    		"GC_is_valid_displacement produced incorrect result\n");
+	FAIL;
+    }
+#   ifndef ALL_INTERIOR_POINTERS
+#    if defined(RS6000) || defined(POWERPC)
+      if (!TEST_FAIL_COUNT(1)) {
+#    else
+      if (!TEST_FAIL_COUNT(2)) {
+#    endif
+    	(void)GC_printf0("GC_is_valid_displacement produced wrong failure indication\n");
+    	FAIL;
+      }
+#   endif
+    /* Test floating point alignment */
+	*(double *)GC_MALLOC(sizeof(double)) = 1.0;
+	*(double *)GC_MALLOC(sizeof(double)) = 1.0;
+    /* Repeated list reversal test. */
+	reverse_test();
+#   ifdef PRINTSTATS
+	GC_printf0("-------------Finished reverse_test\n");
+#   endif
+    typed_test();
+#   ifdef PRINTSTATS
+	GC_printf0("-------------Finished typed_test\n");
+#   endif
+    tree_test();
+    LOCK();
+    n_tests++;
+    UNLOCK();
+    /* GC_printf1("Finished %x\n", pthread_self());    */
+}
+
+void check_heap_stats()
+{
+    unsigned long max_heap_sz;
+    register int i;
+    int still_live;
+    
+    if (sizeof(char *) > 4) {
+        max_heap_sz = 13000000;
+    } else {
+    	max_heap_sz = 11000000;
+    }
+#   ifdef GC_DEBUG
+	max_heap_sz *= 2;
+#       ifdef SPARC
+	    max_heap_sz *= 2;
+#       endif
+#   endif
+    /* Garbage collect repeatedly so that all inaccessible objects	*/
+    /* can be finalized.						*/
+      while (GC_collect_a_little()) { }
+      for (i = 0; i < 16; i++) {
+        GC_gcollect();
+      }
+    (void)GC_printf1("Completed %lu tests\n", (unsigned long)n_tests);
+    (void)GC_printf2("Finalized %lu/%lu objects - ",
+    		     (unsigned long)finalized_count,
+    		     (unsigned long)finalizable_count);
+    if (finalized_count > finalizable_count
+        || finalized_count < finalizable_count/2) {
+        (void)GC_printf0("finalization is probably broken\n");
+        FAIL;
+    } else {
+        (void)GC_printf0("finalization is probably ok\n");
+    }
+    still_live = 0;
+    for (i = 0; i < MAX_FINALIZED; i++) {
+    	if (live_indicators[i] != 0) {
+    	    still_live++;
+    	}
+    }
+    i = finalizable_count - finalized_count - still_live;
+    if (0 != i) {
+        (void)GC_printf2
+            ("%lu disappearing links remain and %lu more objects "
+	     "were not finalized\n",
+             (unsigned long) still_live, (unsigned long)i);
+        if (i > 10) {
+	    GC_printf0("\tVery suspicious!\n");
+	} else {
+	    GC_printf0("\tSlightly suspicious, but probably OK.\n");
+	}
+    }
+    (void)GC_printf1("Total number of bytes allocated is %lu\n",
+    		(unsigned long)
+    	           WORDS_TO_BYTES(GC_words_allocd + GC_words_allocd_before_gc));
+    (void)GC_printf1("Final heap size is %lu bytes\n",
+    		     (unsigned long)GC_get_heap_size());
+    if (WORDS_TO_BYTES(GC_words_allocd + GC_words_allocd_before_gc)
+        < 33500000*n_tests) {
+        (void)GC_printf0("Incorrect execution - missed some allocations\n");
+        FAIL;
+    }
+    if (GC_get_heap_size() > max_heap_sz*n_tests) {
+        (void)GC_printf0("Unexpected heap growth - collector may be broken\n");
+        FAIL;
+    }
+    (void)GC_printf0("Collector appears to work\n");
+}
+
+#if defined(MACOS)
+void SetMinimumStack(long minSize)
+{
+	long newApplLimit;
+
+	if (minSize > LMGetDefltStack())
+	{
+		newApplLimit = (long) GetApplLimit()
+				- (minSize - LMGetDefltStack());
+		SetApplLimit((Ptr) newApplLimit);
+		MaxApplZone();
+	}
+}
+
+#define cMinStackSpace (512L * 1024L)
+
+#endif
+
+#ifdef __STDC__
+    void warn_proc(char *msg, GC_word p)
+#else
+    void warn_proc(msg, p)
+    char *msg;
+    GC_word p;
+#endif
+{
+    GC_printf1(msg, (unsigned long)p);
+    FAIL;
+}
+
+
+#if !defined(PCR) && !defined(SOLARIS_THREADS) && !defined(WIN32_THREADS) && !defined(IRIX_THREADS) || defined(LINT)
+#ifdef MSWIN32
+  int APIENTRY WinMain(HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int n)
+#else
+  int main()
+#endif
+{
+    n_tests = 0;
+    
+#   if defined(MACOS)
+	/* Make sure we have lots and lots of stack space. 	*/
+	SetMinimumStack(cMinStackSpace);
+	/* Cheat and let stdio initialize toolbox for us.	*/
+	printf("Testing GC Macintosh port.\n");
+#   endif
+    GC_INIT();	/* Only needed if gc is dynamic library.	*/
+    (void) GC_set_warn_proc(warn_proc);
+#   if defined(MPROTECT_VDB) || defined(PROC_VDB)
+      GC_enable_incremental();
+      (void) GC_printf0("Switched to incremental mode\n");
+#     if defined(MPROTECT_VDB)
+	(void)GC_printf0("Emulating dirty bits with mprotect/signals\n");
+#     else
+	(void)GC_printf0("Reading dirty bits from /proc\n");
+#      endif
+#   endif
+    run_one_test();
+    check_heap_stats();
+    (void)fflush(stdout);
+#   ifdef LINT
+	/* Entry points we should be testing, but aren't.		   */
+	/* Some can be tested by defining GC_DEBUG at the top of this file */
+	/* This is a bit SunOS4 specific.				   */			
+	GC_noop(GC_expand_hp, GC_add_roots, GC_clear_roots,
+	        GC_register_disappearing_link,
+	        GC_register_finalizer_ignore_self,
+		GC_debug_register_displacement,
+	        GC_print_obj, GC_debug_change_stubborn,
+	        GC_debug_end_stubborn_change, GC_debug_malloc_uncollectable,
+	        GC_debug_free, GC_debug_realloc, GC_generic_malloc_words_small,
+	        GC_init, GC_make_closure, GC_debug_invoke_finalizer,
+	        GC_page_was_ever_dirty, GC_is_fresh,
+		GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page,
+		GC_set_max_heap_size, GC_get_bytes_since_gc,
+		GC_pre_incr, GC_post_incr);
+#   endif
+    return(0);
+}
+# endif
+
+#ifdef WIN32_THREADS
+
+unsigned __stdcall thr_run_one_test(void *arg)
+{
+  run_one_test();
+  return 0;
+}
+
+#define NTEST 2 
+
+int APIENTRY WinMain(HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int n)
+{
+# if NTEST > 0
+   HANDLE h[NTEST];
+# endif
+  int i;
+  unsigned thread_id;
+# if 0
+    GC_enable_incremental();
+# endif
+  InitializeCriticalSection(&incr_cs);
+  (void) GC_set_warn_proc(warn_proc);
+  for (i = 0; i < NTEST; i++) {
+    h[i] = (HANDLE)_beginthreadex(NULL, 0, thr_run_one_test, 0, 0, &thread_id);
+    if (h[i] == (HANDLE)-1) {
+      (void)GC_printf1("Thread creation failed %lu\n", (unsigned long)GetLastError());
+      FAIL;
+    }
+  }
+  run_one_test();
+  for (i = 0; i < NTEST; i++)
+    if (WaitForSingleObject(h[i], INFINITE) != WAIT_OBJECT_0) {
+      (void)GC_printf1("Thread wait failed %lu\n", (unsigned long)GetLastError());
+      FAIL;
+    }
+  check_heap_stats();
+  (void)fflush(stdout);
+  return(0);
+}
+
+#endif /* WIN32_THREADS */
+
+
+#ifdef PCR
+test()
+{
+    PCR_Th_T * th1;
+    PCR_Th_T * th2;
+    int code;
+
+    n_tests = 0;
+    /* GC_enable_incremental(); */
+    (void) GC_set_warn_proc(warn_proc);
+    th1 = PCR_Th_Fork(run_one_test, 0);
+    th2 = PCR_Th_Fork(run_one_test, 0);
+    run_one_test();
+    if (PCR_Th_T_Join(th1, &code, NIL, PCR_allSigsBlocked, PCR_waitForever)
+        != PCR_ERes_okay || code != 0) {
+        (void)GC_printf0("Thread 1 failed\n");
+    }
+    if (PCR_Th_T_Join(th2, &code, NIL, PCR_allSigsBlocked, PCR_waitForever)
+        != PCR_ERes_okay || code != 0) {
+        (void)GC_printf0("Thread 2 failed\n");
+    }
+    check_heap_stats();
+    (void)fflush(stdout);
+    return(0);
+}
+#endif
+
+#if defined(SOLARIS_THREADS) || defined(IRIX_THREADS)
+void * thr_run_one_test(void * arg)
+{
+    run_one_test();
+    return(0);
+}
+
+#ifdef GC_DEBUG
+#  define GC_free GC_debug_free
+#endif
+
+#ifdef SOLARIS_THREADS
+main()
+{
+    thread_t th1;
+    thread_t th2;
+    int code;
+
+    n_tests = 0;
+    GC_INIT();	/* Only needed if gc is dynamic library.	*/
+    GC_enable_incremental();
+    (void) GC_set_warn_proc(warn_proc);
+    if (thr_keycreate(&fl_key, GC_free) != 0) {
+        (void)GC_printf1("Key creation failed %lu\n", (unsigned long)code);
+    	FAIL;
+    }
+    if ((code = thr_create(0, 1024*1024, thr_run_one_test, 0, 0, &th1)) != 0) {
+    	(void)GC_printf1("Thread 1 creation failed %lu\n", (unsigned long)code);
+    	FAIL;
+    }
+    if ((code = thr_create(0, 1024*1024, thr_run_one_test, 0, THR_NEW_LWP, &th2)) != 0) {
+    	(void)GC_printf1("Thread 2 creation failed %lu\n", (unsigned long)code);
+    	FAIL;
+    }
+    run_one_test();
+    if ((code = thr_join(th1, 0, 0)) != 0) {
+        (void)GC_printf1("Thread 1 failed %lu\n", (unsigned long)code);
+        FAIL;
+    }
+    if (thr_join(th2, 0, 0) != 0) {
+        (void)GC_printf1("Thread 2 failed %lu\n", (unsigned long)code);
+        FAIL;
+    }
+    check_heap_stats();
+    (void)fflush(stdout);
+    return(0);
+}
+#else /* pthreads */
+main()
+{
+    pthread_t th1;
+    pthread_t th2;
+    pthread_attr_t attr;
+    int code;
+
+#   ifdef IRIX_THREADS
+	/* Force a larger stack to be preallocated      */
+	/* Since the initial cant always grow later.	*/
+	*((char *)&code - 1024*1024) = 0;      /* Require 1 Mb */
+#   endif /* IRIX_THREADS */
+    pthread_attr_init(&attr);
+    pthread_attr_setstacksize(&attr, 1000000);
+    n_tests = 0;
+    GC_enable_incremental();
+    (void) GC_set_warn_proc(warn_proc);
+    if ((code = pthread_create(&th1, &attr, thr_run_one_test, 0)) != 0) {
+    	(void)GC_printf1("Thread 1 creation failed %lu\n", (unsigned long)code);
+    	FAIL;
+    }
+    if ((code = pthread_create(&th2, &attr, thr_run_one_test, 0)) != 0) {
+    	(void)GC_printf1("Thread 2 creation failed %lu\n", (unsigned long)code);
+    	FAIL;
+    }
+    run_one_test();
+    if ((code = pthread_join(th1, 0)) != 0) {
+        (void)GC_printf1("Thread 1 failed %lu\n", (unsigned long)code);
+        FAIL;
+    }
+    if (pthread_join(th2, 0) != 0) {
+        (void)GC_printf1("Thread 2 failed %lu\n", (unsigned long)code);
+        FAIL;
+    }
+    check_heap_stats();
+    (void)fflush(stdout);
+    pthread_attr_destroy(&attr);
+    GC_printf1("Completed %d collections\n", GC_gc_no);
+    return(0);
+}
+#endif /* pthreads */
+#endif /* SOLARIS_THREADS || IRIX_THREADS */
diff --git a/src/mzscheme/gc/test_cpp.cc b/src/mzscheme/gc/test_cpp.cc
new file mode 100644
index 0000000..6eb8f7a
--- /dev/null
+++ b/src/mzscheme/gc/test_cpp.cc
@@ -0,0 +1,246 @@
+/****************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+Permission is hereby granted to use or copy this program for any
+purpose, provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is
+granted, provided the above notices are retained, and a notice that
+the code was modified is included with the above copyright notice.
+****************************************************************************
+Last modified on Mon Jul 10 21:06:03 PDT 1995 by ellis
+     modified on December 20, 1994 7:27 pm PST by boehm
+
+usage: test_cpp number-of-iterations
+
+This program tries to test the specific C++ functionality provided by
+gc_c++.h that isn't tested by the more general test routines of the
+collector.
+
+A recommended value for number-of-iterations is 10, which will take a
+few minutes to complete.
+
+***************************************************************************/
+
+#include "gc_cpp.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef __GNUC__
+#   include "gc_alloc.h"
+#endif
+extern "C" {
+#include "gc_priv.h"
+}
+# ifdef MSWIN32
+#     include <windows.h>
+#     endif
+
+
+#define my_assert( e ) \
+    if (! (e)) { \
+        GC_printf1( "Assertion failure in " __FILE__ ", line %d: " #e "\n", \
+                    __LINE__ ); \
+        exit( 1 ); }
+
+
+class A {public:
+    /* An uncollectable class. */
+
+    A( int iArg ): i( iArg ) {}
+    void Test( int iArg ) {
+        my_assert( i == iArg );} 
+    int i;};
+
+
+class B: public gc, public A {public:
+    /* A collectable class. */
+
+    B( int j ): A( j ) {}
+    ~B() {
+        my_assert( deleting );}
+    static void Deleting( int on ) {
+        deleting = on;}
+    static int deleting;};
+
+int B::deleting = 0;
+
+
+class C: public gc_cleanup, public A {public:
+    /* A collectable class with cleanup and virtual multiple inheritance. */
+
+    C( int levelArg ): A( levelArg ), level( levelArg ) {
+        nAllocated++;
+        if (level > 0) {
+            left = new C( level - 1 );
+            right = new C( level - 1 );}
+        else {
+            left = right = 0;}}
+    ~C() {
+        this->A::Test( level );
+        nFreed++;
+        my_assert( level == 0 ? 
+                   left == 0 && right == 0 :
+                   level == left->level + 1 && level == right->level + 1 );
+        left = right = 0;
+        level = -123456;}
+    static void Test() {
+        my_assert( nFreed <= nAllocated && nFreed >= .8 * nAllocated );}
+
+    static int nFreed;
+    static int nAllocated;
+    int level;
+    C* left;
+    C* right;};
+
+int C::nFreed = 0;
+int C::nAllocated = 0;
+
+
+class D: public gc {public:
+    /* A collectable class with a static member function to be used as
+    an explicit clean-up function supplied to ::new. */
+
+    D( int iArg ): i( iArg ) {
+        nAllocated++;}
+    static void CleanUp( void* obj, void* data ) {
+        D* self = (D*) obj;
+        nFreed++;
+        my_assert( self->i == (int) (long) data );}
+    static void Test() {
+        my_assert( nFreed >= .8 * nAllocated );}
+       
+    int i;
+    static int nFreed;
+    static int nAllocated;};
+
+int D::nFreed = 0;
+int D::nAllocated = 0;
+
+
+class E: public gc_cleanup {public:
+    /* A collectable class with clean-up for use by F. */
+
+    E() {
+        nAllocated++;}
+    ~E() {
+        nFreed++;}
+
+    static int nFreed;
+    static int nAllocated;};
+    
+int E::nFreed = 0;
+int E::nAllocated = 0;
+   
+
+class F: public E {public:
+    /* A collectable class with clean-up, a base with clean-up, and a
+    member with clean-up. */
+
+    F() {
+        nAllocated++;}
+    ~F() {
+        nFreed++;}
+    static void Test() {
+        my_assert( nFreed >= .8 * nAllocated );
+        my_assert( 2 * nFreed == E::nFreed );}
+       
+    E e;
+    static int nFreed;
+    static int nAllocated;};
+    
+int F::nFreed = 0;
+int F::nAllocated = 0;
+   
+
+long Disguise( void* p ) {
+    return ~ (long) p;}
+
+void* Undisguise( long i ) {
+    return (void*) ~ i;}
+
+
+#ifdef MSWIN32
+int APIENTRY WinMain(
+    HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int cmdShow ) 
+{
+    int argc;
+    char* argv[ 3 ];
+
+    for (argc = 1; argc < sizeof( argv ) / sizeof( argv[ 0 ] ); argc++) {
+        argv[ argc ] = strtok( argc == 1 ? cmd : 0, " \t" );
+        if (0 == argv[ argc ]) break;}
+
+#else
+int main( int argc, char* argv[] ) {
+#endif
+
+    int i, iters, n;
+#   ifndef __GNUC__
+      int *x = (int *)alloc::allocate(sizeof(int));
+
+      *x = 29;
+      x -= 3;
+#   endif
+    if (argc != 2 || (0 >= (n = atoi( argv[ 1 ] )))) {
+        GC_printf0( "usage: test_cpp number-of-iterations\n" );
+        exit( 1 );}
+        
+    for (iters = 1; iters <= n; iters++) {
+        GC_printf1( "Starting iteration %d\n", iters );
+
+            /* Allocate some uncollectable As and disguise their pointers.
+            Later we'll check to see if the objects are still there.  We're
+            checking to make sure these objects really are uncollectable. */
+        long as[ 1000 ];
+        long bs[ 1000 ];
+        for (i = 0; i < 1000; i++) {
+            as[ i ] = Disguise( new (NoGC) A( i ) );
+            bs[ i ] = Disguise( new (NoGC) B( i ) );}
+
+            /* Allocate a fair number of finalizable Cs, Ds, and Fs.
+            Later we'll check to make sure they've gone away. */
+        for (i = 0; i < 1000; i++) {
+            C* c = new C( 2 );
+            C c1( 2 );           /* stack allocation should work too */
+            D* d = ::new (GC, D::CleanUp, (void*) i) D( i );
+            F* f = new F;
+            if (0 == i % 10) delete c;}
+
+            /* Allocate a very large number of collectable As and Bs and
+            drop the references to them immediately, forcing many
+            collections. */
+        for (i = 0; i < 1000000; i++) {
+            A* a = new (GC) A( i );
+            B* b = new B( i );
+            b = new (GC) B( i );
+            if (0 == i % 10) {
+                B::Deleting( 1 );
+                delete b;
+                B::Deleting( 0 );}}
+
+            /* Make sure the uncollectable As and Bs are still there. */
+        for (i = 0; i < 1000; i++) {
+            A* a = (A*) Undisguise( as[ i ] );
+            B* b = (B*) Undisguise( bs[ i ] );
+            a->Test( i );
+            delete a;
+            b->Test( i );
+            B::Deleting( 1 );
+            delete b;
+            B::Deleting( 0 );}
+
+            /* Make sure most of the finalizable Cs, Ds, and Fs have
+            gone away. */
+        C::Test();
+        D::Test();
+        F::Test();}
+
+#   ifndef __GNUC__
+      my_assert (29 == x[3]);
+#   endif
+    GC_printf0( "The test appears to have succeeded.\n" );
+    return( 0 );}
+    
+
diff --git a/src/mzscheme/gc/threadlibs.c b/src/mzscheme/gc/threadlibs.c
new file mode 100644
index 0000000..bd54917
--- /dev/null
+++ b/src/mzscheme/gc/threadlibs.c
@@ -0,0 +1,14 @@
+# include "config.h"
+# include <stdio.h>
+
+int main()
+{
+#   ifdef IRIX_THREADS
+	printf("-lpthread\n");
+#   endif
+#   ifdef SOLARIS_THREADS
+        printf("-lthread -ldl\n");
+#   endif
+    return 0;
+}
+
diff --git a/src/mzscheme/gc/typd_mlc.c b/src/mzscheme/gc/typd_mlc.c
new file mode 100644
index 0000000..310f764
--- /dev/null
+++ b/src/mzscheme/gc/typd_mlc.c
@@ -0,0 +1,766 @@
+/*
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+/* Boehm, July 31, 1995 5:02 pm PDT */
+
+
+/*
+ * Some simple primitives for allocation with explicit type information.
+ * Simple objects are allocated such that they contain a GC_descr at the
+ * end (in the last allocated word).  This descriptor may be a procedure
+ * which then examines an extended descriptor passed as its environment.
+ *
+ * Arrays are treated as simple objects if they have sufficiently simple
+ * structure.  Otherwise they are allocated from an array kind that supplies
+ * a special mark procedure.  These arrays contain a pointer to a
+ * complex_descriptor as their last word.
+ * This is done because the environment field is too small, and the collector
+ * must trace the complex_descriptor.
+ *
+ * Note that descriptors inside objects may appear cleared, if we encounter a
+ * false refrence to an object on a free list.  In the GC_descr case, this
+ * is OK, since a 0 descriptor corresponds to examining no fields.
+ * In the complex_descriptor case, we explicitly check for that case.
+ *
+ * MAJOR PARTS OF THIS CODE HAVE NOT BEEN TESTED AT ALL and are not testable,
+ * since they are not accessible through the current interface.
+ */
+
+#include "gc_priv.h"
+#include "gc_mark.h"
+#include "gc_typed.h"
+
+# ifdef ADD_BYTE_AT_END
+#   define EXTRA_BYTES (sizeof(word) - 1)
+# else
+#   define EXTRA_BYTES (sizeof(word))
+# endif
+
+bool GC_explicit_typing_initialized = FALSE;
+
+int GC_explicit_kind;	/* Object kind for objects with indirect	*/
+			/* (possibly extended) descriptors.		*/
+
+int GC_array_kind;	/* Object kind for objects with complex		*/
+			/* descriptors and GC_array_mark_proc.		*/
+
+/* Extended descriptors.  GC_typed_mark_proc understands these.	*/
+/* These are used for simple objects that are larger than what	*/
+/* can be described by a BITMAP_BITS sized bitmap.		*/
+typedef struct {
+	word ed_bitmap;	/* lsb corresponds to first word.	*/
+	bool ed_continued;	/* next entry is continuation.	*/
+} ext_descr;
+
+/* Array descriptors.  GC_array_mark_proc understands these.	*/
+/* We may eventually need to add provisions for headers and	*/
+/* trailers.  Hence we provide for tree structured descriptors, */
+/* though we don't really use them currently.			*/
+typedef union ComplexDescriptor {
+    struct LeafDescriptor {	/* Describes simple array	*/
+        word ld_tag;
+#	define LEAF_TAG 1
+	word ld_size;		/* bytes per element	*/
+				/* multiple of ALIGNMENT	*/
+	word ld_nelements;	/* Number of elements.	*/
+	GC_descr ld_descriptor; /* A simple length, bitmap,	*/
+				/* or procedure descriptor.	*/
+    } ld;
+    struct ComplexArrayDescriptor {
+        word ad_tag;
+#	define ARRAY_TAG 2
+	word ad_nelements;
+	union ComplexDescriptor * ad_element_descr;
+    } ad;
+    struct SequenceDescriptor {
+        word sd_tag;
+#	define SEQUENCE_TAG 3
+	union ComplexDescriptor * sd_first;
+	union ComplexDescriptor * sd_second;
+    } sd;
+} complex_descriptor;
+#define TAG ld.ld_tag
+
+ext_descr * GC_ext_descriptors;	/* Points to array of extended 	*/
+				/* descriptors.			*/
+
+word GC_ed_size = 0;	/* Current size of above arrays.	*/
+# define ED_INITIAL_SIZE 100;
+
+word GC_avail_descr = 0;	/* Next available slot.		*/
+
+int GC_typed_mark_proc_index;	/* Indices of my mark		*/
+int GC_array_mark_proc_index;	/* procedures.			*/
+
+/* Add a multiword bitmap to GC_ext_descriptors arrays.  Return	*/
+/* starting index.						*/
+/* Returns -1 on failure.					*/
+/* Caller does not hold allocation lock.			*/
+signed_word GC_add_ext_descriptor(bm, nbits)
+GC_bitmap bm;
+word nbits;
+{
+    register size_t nwords = divWORDSZ(nbits + WORDSZ-1);
+    register signed_word result;
+    register word i;
+    register word last_part;
+    register int extra_bits;
+    DCL_LOCK_STATE;
+
+    DISABLE_SIGNALS();
+    LOCK();
+    while (GC_avail_descr + nwords >= GC_ed_size) {
+    	ext_descr * new;
+    	size_t new_size;
+    	word ed_size = GC_ed_size;
+    	
+    	UNLOCK();
+        ENABLE_SIGNALS();
+    	if (ed_size == 0) {
+    	    new_size = ED_INITIAL_SIZE;
+    	} else {
+    	    new_size = 2 * ed_size;
+    	    if (new_size > MAX_ENV) return(-1);
+    	} 
+    	new = (ext_descr *) GC_malloc_atomic(new_size * sizeof(ext_descr));
+    	if (new == 0) return(-1);
+    	DISABLE_SIGNALS();
+        LOCK();
+        if (ed_size == GC_ed_size) {
+            if (GC_avail_descr != 0) {
+    	        BCOPY(GC_ext_descriptors, new,
+    	              GC_avail_descr * sizeof(ext_descr));
+    	    }
+    	    GC_ed_size = new_size;
+    	    GC_ext_descriptors = new;
+    	}  /* else another thread already resized it in the meantime */
+    }
+    result = GC_avail_descr;
+    for (i = 0; i < nwords-1; i++) {
+        GC_ext_descriptors[result + i].ed_bitmap = bm[i];
+        GC_ext_descriptors[result + i].ed_continued = TRUE;
+    }
+    last_part = bm[i];
+    /* Clear irrelevant bits. */
+    extra_bits = nwords * WORDSZ - nbits;
+    last_part <<= extra_bits;
+    last_part >>= extra_bits;
+    GC_ext_descriptors[result + i].ed_bitmap = last_part;
+    GC_ext_descriptors[result + i].ed_continued = FALSE;
+    GC_avail_descr += nwords;
+    UNLOCK();
+    ENABLE_SIGNALS();
+    return(result);
+}
+
+/* Table of bitmap descriptors for n word long all pointer objects.	*/
+GC_descr GC_bm_table[WORDSZ/2];
+	
+/* Return a descriptor for the concatenation of 2 nwords long objects,	*/
+/* each of which is described by descriptor.				*/
+/* The result is known to be short enough to fit into a bitmap		*/
+/* descriptor.								*/
+/* Descriptor is a DS_LENGTH or DS_BITMAP descriptor.			*/
+GC_descr GC_double_descr(descriptor, nwords)
+register GC_descr descriptor;
+register word nwords;
+{
+    if (descriptor && DS_TAGS == DS_LENGTH) {
+        descriptor = GC_bm_table[BYTES_TO_WORDS((word)descriptor)];
+    };
+    descriptor |= (descriptor & ~DS_TAGS) >> nwords;
+    return(descriptor);
+}
+
+complex_descriptor * GC_make_sequence_descriptor();
+
+/* Build a descriptor for an array with nelements elements,	*/
+/* each of which can be described by a simple descriptor.	*/
+/* We try to optimize some common cases.			*/
+/* If the result is COMPLEX, then a complex_descr* is returned  */
+/* in *complex_d.							*/
+/* If the result is LEAF, then we built a LeafDescriptor in	*/
+/* the structure pointed to by leaf.				*/
+/* The tag in the leaf structure is not set.			*/
+/* If the result is SIMPLE, then a GC_descr			*/
+/* is returned in *simple_d.					*/
+/* If the result is NO_MEM, then				*/
+/* we failed to allocate the descriptor.			*/
+/* The implementation knows that DS_LENGTH is 0.		*/
+/* *leaf, *complex_d, and *simple_d may be used as temporaries	*/
+/* during the construction.					*/
+# define COMPLEX 2
+# define LEAF 1
+# define SIMPLE 0
+# define NO_MEM (-1)
+int GC_make_array_descriptor(nelements, size, descriptor,
+			     simple_d, complex_d, leaf)
+word size;
+word nelements;
+GC_descr descriptor;
+GC_descr *simple_d;
+complex_descriptor **complex_d;
+struct LeafDescriptor * leaf;
+{
+#   define OPT_THRESHOLD 50
+	/* For larger arrays, we try to combine descriptors of adjacent	*/
+	/* descriptors to speed up marking, and to reduce the amount	*/
+	/* of space needed on the mark stack.				*/
+    if ((descriptor & DS_TAGS) == DS_LENGTH) {
+      if ((word)descriptor == size) {
+    	*simple_d = nelements * descriptor;
+    	return(SIMPLE);
+      } else if ((word)descriptor == 0) {
+        *simple_d = (GC_descr)0;
+        return(SIMPLE);
+      }
+    }
+    if (nelements <= OPT_THRESHOLD) {
+      if (nelements <= 1) {
+        if (nelements == 1) {
+            *simple_d = descriptor;
+            return(SIMPLE);
+        } else {
+            *simple_d = (GC_descr)0;
+            return(SIMPLE);
+        }
+      }
+    } else if (size <= BITMAP_BITS/2
+    	       && (descriptor & DS_TAGS) != DS_PROC
+    	       && (size & (sizeof(word)-1)) == 0) {
+      int result =      
+          GC_make_array_descriptor(nelements/2, 2*size,
+      				   GC_double_descr(descriptor,
+      				   		   BYTES_TO_WORDS(size)),
+      				   simple_d, complex_d, leaf);
+      if ((nelements & 1) == 0) {
+          return(result);
+      } else {
+          struct LeafDescriptor * one_element =
+              (struct LeafDescriptor *)
+        	GC_malloc_atomic(sizeof(struct LeafDescriptor));
+          
+          if (result == NO_MEM || one_element == 0) return(NO_MEM);
+          one_element -> ld_tag = LEAF_TAG;
+          one_element -> ld_size = size;
+          one_element -> ld_nelements = 1;
+          one_element -> ld_descriptor = descriptor;
+          switch(result) {
+            case SIMPLE:
+            {
+              struct LeafDescriptor * beginning =
+                (struct LeafDescriptor *)
+        	  GC_malloc_atomic(sizeof(struct LeafDescriptor));
+              if (beginning == 0) return(NO_MEM);
+              beginning -> ld_tag = LEAF_TAG;
+              beginning -> ld_size = size;
+              beginning -> ld_nelements = 1;
+              beginning -> ld_descriptor = *simple_d;
+              *complex_d = GC_make_sequence_descriptor(
+              			(complex_descriptor *)beginning,
+              			(complex_descriptor *)one_element);
+              break;
+            }
+            case LEAF:
+            {
+              struct LeafDescriptor * beginning =
+                (struct LeafDescriptor *)
+        	  GC_malloc_atomic(sizeof(struct LeafDescriptor));
+              if (beginning == 0) return(NO_MEM);
+              beginning -> ld_tag = LEAF_TAG;
+              beginning -> ld_size = leaf -> ld_size;
+              beginning -> ld_nelements = leaf -> ld_nelements;
+              beginning -> ld_descriptor = leaf -> ld_descriptor;
+              *complex_d = GC_make_sequence_descriptor(
+              			(complex_descriptor *)beginning,
+              			(complex_descriptor *)one_element);
+              break;
+            }
+            case COMPLEX:
+              *complex_d = GC_make_sequence_descriptor(
+              			*complex_d,
+              			(complex_descriptor *)one_element);
+              break;
+          }
+          return(COMPLEX);
+      }
+    }
+    {
+        leaf -> ld_size = size;
+        leaf -> ld_nelements = nelements;
+        leaf -> ld_descriptor = descriptor;
+        return(LEAF);
+    }
+}
+
+complex_descriptor * GC_make_sequence_descriptor(first, second)
+complex_descriptor * first;
+complex_descriptor * second;
+{
+    struct SequenceDescriptor * result =
+        (struct SequenceDescriptor *)
+        	GC_malloc(sizeof(struct SequenceDescriptor));
+    /* Can't result in overly conservative marking, since tags are	*/
+    /* very small integers. Probably faster than maintaining type	*/
+    /* info.								*/    
+    if (result != 0) {
+    	result -> sd_tag = SEQUENCE_TAG;
+        result -> sd_first = first;
+        result -> sd_second = second;
+    }
+    return((complex_descriptor *)result);
+}
+
+#ifdef UNDEFINED
+complex_descriptor * GC_make_complex_array_descriptor(nelements, descr)
+word nelements;
+complex_descriptor * descr;
+{
+    struct ComplexArrayDescriptor * result =
+        (struct ComplexArrayDescriptor *)
+        	GC_malloc(sizeof(struct ComplexArrayDescriptor));
+    
+    if (result != 0) {
+    	result -> ad_tag = ARRAY_TAG;
+        result -> ad_nelements = nelements;
+        result -> ad_element_descr = descr;
+    }
+    return((complex_descriptor *)result);
+}
+#endif
+
+ptr_t * GC_eobjfreelist;
+
+ptr_t * GC_arobjfreelist;
+
+mse * GC_typed_mark_proc();
+
+mse * GC_array_mark_proc();
+
+GC_descr GC_generic_array_descr;
+
+/* Caller does not hold allocation lock. */
+void GC_init_explicit_typing()
+{
+    register int i;
+    DCL_LOCK_STATE;
+
+    
+#   ifdef PRINTSTATS
+     	if (sizeof(struct LeafDescriptor) % sizeof(word) != 0)
+     	    ABORT("Bad leaf descriptor size");
+#   endif
+    DISABLE_SIGNALS();
+    LOCK();
+    if (GC_explicit_typing_initialized) {
+      UNLOCK();
+      ENABLE_SIGNALS();
+      return;
+    }
+    GC_explicit_typing_initialized = TRUE;
+    /* Set up object kind with simple indirect descriptor. */
+      GC_eobjfreelist = (ptr_t *)
+          GC_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
+      if (GC_eobjfreelist == 0) ABORT("Couldn't allocate GC_eobjfreelist");
+      BZERO(GC_eobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
+      GC_explicit_kind = GC_n_kinds++;
+      GC_obj_kinds[GC_explicit_kind].ok_freelist = GC_eobjfreelist;
+      GC_obj_kinds[GC_explicit_kind].ok_reclaim_list = 0;
+      GC_obj_kinds[GC_explicit_kind].ok_descriptor =
+    		(((word)WORDS_TO_BYTES(-1)) | DS_PER_OBJECT);
+      GC_obj_kinds[GC_explicit_kind].ok_relocate_descr = TRUE;
+      GC_obj_kinds[GC_explicit_kind].ok_init = TRUE;
+    		/* Descriptors are in the last word of the object. */
+      GC_typed_mark_proc_index = GC_n_mark_procs;
+      GC_mark_procs[GC_typed_mark_proc_index] = GC_typed_mark_proc;
+      GC_n_mark_procs++;
+        /* Moving this up breaks DEC AXP compiler.      */
+    /* Set up object kind with array descriptor. */
+      GC_arobjfreelist = (ptr_t *)
+          GC_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
+      if (GC_arobjfreelist == 0) ABORT("Couldn't allocate GC_arobjfreelist");
+      BZERO(GC_arobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
+      if (GC_n_mark_procs >= MAX_MARK_PROCS)
+      		ABORT("No slot for array mark proc");
+      GC_array_mark_proc_index = GC_n_mark_procs++;
+      if (GC_n_kinds >= MAXOBJKINDS)
+      		ABORT("No kind available for array objects");
+      GC_array_kind = GC_n_kinds++;
+      GC_obj_kinds[GC_array_kind].ok_freelist = GC_arobjfreelist;
+      GC_obj_kinds[GC_array_kind].ok_reclaim_list = 0;
+      GC_obj_kinds[GC_array_kind].ok_descriptor =
+    		MAKE_PROC(GC_array_mark_proc_index, 0);;
+      GC_obj_kinds[GC_array_kind].ok_relocate_descr = FALSE;
+      GC_obj_kinds[GC_array_kind].ok_init = TRUE;
+    		/* Descriptors are in the last word of the object. */
+            GC_mark_procs[GC_array_mark_proc_index] = GC_array_mark_proc;
+      for (i = 0; i < WORDSZ/2; i++) {
+          GC_descr d = (((word)(-1)) >> (WORDSZ - i)) << (WORDSZ - i);
+          d |= DS_BITMAP;
+          GC_bm_table[i] = d;
+      }
+      GC_generic_array_descr = MAKE_PROC(GC_array_mark_proc_index, 0); 
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+mse * GC_typed_mark_proc(addr, mark_stack_ptr, mark_stack_limit, env)
+register word * addr;
+register mse * mark_stack_ptr;
+mse * mark_stack_limit;
+word env;
+{
+    register word bm = GC_ext_descriptors[env].ed_bitmap;
+    register word * current_p = addr;
+    register word current;
+    register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+    register ptr_t least_ha = GC_least_plausible_heap_addr;
+    
+    for (; bm != 0; bm >>= 1, current_p++) {
+    	if (bm & 1) {
+    	    current = *current_p;
+    	    if ((ptr_t)current >= least_ha && (ptr_t)current <= greatest_ha) {
+    	        PUSH_CONTENTS(current, mark_stack_ptr, mark_stack_limit);
+    	    }
+    	}
+    }
+    if (GC_ext_descriptors[env].ed_continued) {
+        /* Push an entry with the rest of the descriptor back onto the	*/
+        /* stack.  Thus we never do too much work at once.  Note that	*/
+        /* we also can't overflow the mark stack unless we actually 	*/
+        /* mark something.						*/
+        mark_stack_ptr++;
+        if (mark_stack_ptr >= mark_stack_limit) {
+            mark_stack_ptr = GC_signal_mark_stack_overflow(mark_stack_ptr);
+        }
+        mark_stack_ptr -> mse_start = addr + WORDSZ;
+        mark_stack_ptr -> mse_descr =
+        	MAKE_PROC(GC_typed_mark_proc_index, env+1);
+    }
+    return(mark_stack_ptr);
+}
+
+/* Return the size of the object described by d.  It would be faster to	*/
+/* store this directly, or to compute it as part of			*/
+/* GC_push_complex_descriptor, but hopefully it doesn't matter.		*/
+word GC_descr_obj_size(d)
+register complex_descriptor *d;
+{
+    switch(d -> TAG) {
+      case LEAF_TAG:
+      	return(d -> ld.ld_nelements * d -> ld.ld_size);
+      case ARRAY_TAG:
+        return(d -> ad.ad_nelements
+               * GC_descr_obj_size(d -> ad.ad_element_descr));
+      case SEQUENCE_TAG:
+        return(GC_descr_obj_size(d -> sd.sd_first)
+               + GC_descr_obj_size(d -> sd.sd_second));
+      default:
+        ABORT("Bad complex descriptor");
+        /*NOTREACHED*/ return 0; /*NOTREACHED*/
+    }
+}
+
+/* Push descriptors for the object at addr with complex descriptor d	*/
+/* onto the mark stack.  Return 0 if the mark stack overflowed.  	*/
+mse * GC_push_complex_descriptor(addr, d, msp, msl)
+word * addr;
+register complex_descriptor *d;
+register mse * msp;
+mse * msl;
+{
+    register ptr_t current = (ptr_t) addr;
+    register word nelements;
+    register word sz;
+    register word i;
+    
+    switch(d -> TAG) {
+      case LEAF_TAG:
+        {
+          register GC_descr descr = d -> ld.ld_descriptor;
+          
+          nelements = d -> ld.ld_nelements;
+          if (msl - msp <= (ptrdiff_t)nelements) return(0);
+          sz = d -> ld.ld_size;
+          for (i = 0; i < nelements; i++) {
+              msp++;
+              msp -> mse_start = (word *)current;
+              msp -> mse_descr = descr;
+              current += sz;
+          }
+          return(msp);
+        }
+      case ARRAY_TAG:
+        {
+          register complex_descriptor *descr = d -> ad.ad_element_descr;
+          
+          nelements = d -> ad.ad_nelements;
+          sz = GC_descr_obj_size(descr);
+          for (i = 0; i < nelements; i++) {
+              msp = GC_push_complex_descriptor((word *)current, descr,
+              					msp, msl);
+              if (msp == 0) return(0);
+              current += sz;
+          }
+          return(msp);
+        }
+      case SEQUENCE_TAG:
+        {
+          sz = GC_descr_obj_size(d -> sd.sd_first);
+          msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_first,
+          				   msp, msl);
+          if (msp == 0) return(0);
+          current += sz;
+          msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_second,
+          				   msp, msl);
+          return(msp);
+        }
+      default:
+        ABORT("Bad complex descriptor");
+        /*NOTREACHED*/ return 0; /*NOTREACHED*/
+   }
+}
+
+/*ARGSUSED*/
+mse * GC_array_mark_proc(addr, mark_stack_ptr, mark_stack_limit, env)
+register word * addr;
+register mse * mark_stack_ptr;
+mse * mark_stack_limit;
+word env;
+{
+    register hdr * hhdr = HDR(addr);
+    register word sz = hhdr -> hb_sz;
+    register complex_descriptor * descr = (complex_descriptor *)(addr[sz-1]);
+    mse * orig_mark_stack_ptr = mark_stack_ptr;
+    mse * new_mark_stack_ptr;
+    
+    if (descr == 0) {
+    	/* Found a reference to a free list entry.  Ignore it. */
+    	return(orig_mark_stack_ptr);
+    }
+    /* In use counts were already updated when array descriptor was	*/
+    /* pushed.  Here we only replace it by subobject descriptors, so 	*/
+    /* no update is necessary.						*/
+    new_mark_stack_ptr = GC_push_complex_descriptor(addr, descr,
+    						    mark_stack_ptr,
+    						    mark_stack_limit-1);
+    if (new_mark_stack_ptr == 0) {
+    	/* Doesn't fit.  Conservatively push the whole array as a unit	*/
+    	/* and request a mark stack expansion.				*/
+    	/* This cannot cause a mark stack overflow, since it replaces	*/
+    	/* the original array entry.					*/
+    	GC_mark_stack_too_small = TRUE;
+    	new_mark_stack_ptr = orig_mark_stack_ptr + 1;
+    	new_mark_stack_ptr -> mse_start = addr;
+    	new_mark_stack_ptr -> mse_descr = WORDS_TO_BYTES(sz) | DS_LENGTH;
+    } else {
+        /* Push descriptor itself */
+        new_mark_stack_ptr++;
+        new_mark_stack_ptr -> mse_start = addr + sz - 1;
+        new_mark_stack_ptr -> mse_descr = sizeof(word) | DS_LENGTH;
+    }
+    return(new_mark_stack_ptr);
+}
+
+#if defined(__STDC__) || defined(__cplusplus)
+  GC_descr GC_make_descriptor(GC_bitmap bm, size_t len)
+#else
+  GC_descr GC_make_descriptor(bm, len)
+  GC_bitmap bm;
+  size_t len;
+#endif
+{
+    register signed_word last_set_bit = len - 1;
+    register word result;
+    register int i;
+#   define HIGH_BIT (((word)1) << (WORDSZ - 1))
+    
+    if (!GC_explicit_typing_initialized) GC_init_explicit_typing();
+    while (last_set_bit >= 0 && !GC_get_bit(bm, last_set_bit)) last_set_bit --;
+    if (last_set_bit < 0) return(0 /* no pointers */);
+#   if ALIGNMENT == CPP_WORDSZ/8
+    {
+      register bool all_bits_set = TRUE;
+      for (i = 0; i < last_set_bit; i++) {
+    	if (!GC_get_bit(bm, i)) {
+    	    all_bits_set = FALSE;
+    	    break;
+    	}
+      }
+      if (all_bits_set) {
+    	/* An initial section contains all pointers.  Use length descriptor. */
+        return(WORDS_TO_BYTES(last_set_bit+1) | DS_LENGTH);
+      }
+    }
+#   endif
+    if (last_set_bit < BITMAP_BITS) {
+    	/* Hopefully the common case.			*/
+    	/* Build bitmap descriptor (with bits reversed)	*/
+    	result = HIGH_BIT;
+    	for (i = last_set_bit - 1; i >= 0; i--) {
+    	    result >>= 1;
+    	    if (GC_get_bit(bm, i)) result |= HIGH_BIT;
+    	}
+    	result |= DS_BITMAP;
+    	return(result);
+    } else {
+    	signed_word index;
+    	
+    	index = GC_add_ext_descriptor(bm, (word)last_set_bit+1);
+    	if (index == -1) return(WORDS_TO_BYTES(last_set_bit+1) | DS_LENGTH);
+    				/* Out of memory: use conservative	*/
+    				/* approximation.			*/
+    	result = MAKE_PROC(GC_typed_mark_proc_index, (word)index);
+    	return(result);
+    }
+}
+
+ptr_t GC_clear_stack();
+
+#define GENERAL_MALLOC(lb,k) \
+    (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
+    
+#if defined(__STDC__) || defined(__cplusplus)
+  extern void * GC_malloc_explicitly_typed(size_t lb, GC_descr d)
+#else
+  extern void * GC_malloc_explicitly_typed(lb, d)
+  size_t lb;
+  GC_descr d;
+#endif
+{
+register ptr_t op;
+register ptr_t * opp;
+register word lw;
+DCL_LOCK_STATE;
+
+    lb += EXTRA_BYTES;
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_eobjfreelist[lw]);
+	FASTLOCK();
+        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
+            FASTUNLOCK();
+            op = (ptr_t)GENERAL_MALLOC((word)lb, GC_explicit_kind);
+	    if (0 == op) return(0);
+#	    ifdef MERGE_SIZES
+		lw = GC_size_map[lb];	/* May have been uninitialized.	*/            
+#	    endif
+        } else {
+            *opp = obj_link(op);
+            GC_words_allocd += lw;
+            FASTUNLOCK();
+        }
+   } else {
+       op = (ptr_t)GENERAL_MALLOC((word)lb, GC_explicit_kind);
+       if (0 == op) return(0);
+       lw = BYTES_TO_WORDS(GC_size(op));
+   }
+   ((word *)op)[lw - 1] = d;
+   return((GC_PTR) op);
+}
+
+#if defined(__STDC__) || defined(__cplusplus)
+  void * GC_calloc_explicitly_typed(size_t n,
+  				    size_t lb,
+  				    GC_descr d)
+#else
+  void * GC_calloc_explicitly_typed(n, lb, d)
+  size_t n;
+  size_t lb;
+  GC_descr d;
+#endif
+{
+register ptr_t op;
+register ptr_t * opp;
+register word lw;
+GC_descr simple_descr;
+complex_descriptor *complex_descr;
+register int descr_type;
+struct LeafDescriptor leaf;
+DCL_LOCK_STATE;
+
+    descr_type = GC_make_array_descriptor((word)n, (word)lb, d,
+    					  &simple_descr, &complex_descr, &leaf);
+    switch(descr_type) {
+    	case NO_MEM: return(0);
+    	case SIMPLE: return(GC_malloc_explicitly_typed(n*lb, simple_descr));
+    	case LEAF:
+    	    lb *= n;
+    	    lb += sizeof(struct LeafDescriptor) + EXTRA_BYTES;
+    	    break;
+    	case COMPLEX:
+    	    lb *= n;
+    	    lb += EXTRA_BYTES;
+    	    break;
+    }
+    if( SMALL_OBJ(lb) ) {
+#       ifdef MERGE_SIZES
+	  lw = GC_size_map[lb];
+#	else
+	  lw = ALIGNED_WORDS(lb);
+#       endif
+	opp = &(GC_arobjfreelist[lw]);
+	FASTLOCK();
+        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
+            FASTUNLOCK();
+            op = (ptr_t)GENERAL_MALLOC((word)lb, GC_array_kind);
+	    if (0 == op) return(0);
+#	    ifdef MERGE_SIZES
+		lw = GC_size_map[lb];	/* May have been uninitialized.	*/            
+#	    endif
+        } else {
+            *opp = obj_link(op);
+            GC_words_allocd += lw;
+            FASTUNLOCK();
+        }
+   } else {
+       op = (ptr_t)GENERAL_MALLOC((word)lb, GC_array_kind);
+       if (0 == op) return(0);
+       lw = BYTES_TO_WORDS(GC_size(op));
+   }
+   if (descr_type == LEAF) {
+       /* Set up the descriptor inside the object itself. */
+       VOLATILE struct LeafDescriptor * lp =
+           (struct LeafDescriptor *)
+               ((word *)op
+                + lw - (BYTES_TO_WORDS(sizeof(struct LeafDescriptor)) + 1));
+                
+       lp -> ld_tag = LEAF_TAG;
+       lp -> ld_size = leaf.ld_size;
+       lp -> ld_nelements = leaf.ld_nelements;
+       lp -> ld_descriptor = leaf.ld_descriptor;
+       ((VOLATILE word *)op)[lw - 1] = (word)lp;
+   } else {
+       extern unsigned GC_finalization_failures;
+       unsigned ff = GC_finalization_failures;
+       
+       ((word *)op)[lw - 1] = (word)complex_descr;
+       /* Make sure the descriptor is cleared once there is any danger	*/
+       /* it may have been collected.					*/
+       (void)
+         GC_general_register_disappearing_link((GC_PTR *)
+         					  ((word *)op+lw-1),
+       					          (GC_PTR) op);
+       if (ff != GC_finalization_failures) {
+	   /* Couldn't register it due to lack of memory.  Punt.	*/
+	   /* This will probably fail too, but gives the recovery code  */
+	   /* a chance.							*/
+	   return(GC_malloc(n*lb));
+       }			          
+   }
+   return((GC_PTR) op);
+}
diff --git a/src/mzscheme/gc/weakpointer.h b/src/mzscheme/gc/weakpointer.h
new file mode 100644
index 0000000..84906b0
--- /dev/null
+++ b/src/mzscheme/gc/weakpointer.h
@@ -0,0 +1,221 @@
+#ifndef	_weakpointer_h_
+#define	_weakpointer_h_
+
+/****************************************************************************
+
+WeakPointer and CleanUp
+
+    Copyright (c) 1991 by Xerox Corporation.  All rights reserved.
+
+    THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+    OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+    Permission is hereby granted to copy this code for any purpose,
+    provided the above notices are retained on all copies.
+
+    Last modified on Mon Jul 17 18:16:01 PDT 1995 by ellis
+
+****************************************************************************/
+
+/****************************************************************************
+
+WeakPointer
+
+A weak pointer is a pointer to a heap-allocated object that doesn't
+prevent the object from being garbage collected. Weak pointers can be
+used to track which objects haven't yet been reclaimed by the
+collector. A weak pointer is deactivated when the collector discovers
+its referent object is unreachable by normal pointers (reachability
+and deactivation are defined more precisely below). A deactivated weak
+pointer remains deactivated forever.
+
+****************************************************************************/
+
+
+template< class T > class WeakPointer {
+public:
+
+WeakPointer( T* t = 0 )
+    /* Constructs a weak pointer for *t. t may be null. It is an error
+       if t is non-null and *t is not a collected object. */
+    {impl = _WeakPointer_New( t );}
+
+T* Pointer()
+    /* wp.Pointer() returns a pointer to the referent object of wp or
+       null if wp has been deactivated (because its referent object
+       has been discovered unreachable by the collector). */
+    {return (T*) _WeakPointer_Pointer( this->impl );}
+
+int operator==( WeakPointer< T > wp2 )
+    /* Given weak pointers wp1 and wp2, if wp1 == wp2, then wp1 and
+       wp2 refer to the same object. If wp1 != wp2, then either wp1
+       and wp2 don't refer to the same object, or if they do, one or
+       both of them has been deactivated. (Note: If objects t1 and t2
+       are never made reachable by their clean-up functions, then
+       WeakPointer<T>(t1) == WeakPointer<T>(t2) if and only t1 == t2.) */
+    {return _WeakPointer_Equal( this->impl, wp2.impl );}
+
+int Hash()
+    /* Returns a hash code suitable for use by multiplicative- and
+       division-based hash tables. If wp1 == wp2, then wp1.Hash() ==
+       wp2.Hash(). */
+    {return _WeakPointer_Hash( this->impl );}
+
+private:
+void* impl;
+};
+
+/*****************************************************************************
+
+CleanUp
+
+A garbage-collected object can have an associated clean-up function
+that will be invoked some time after the collector discovers the
+object is unreachable via normal pointers. Clean-up functions can be
+used to release resources such as open-file handles or window handles
+when their containing objects become unreachable.  If a C++ object has
+a non-empty explicit destructor (i.e. it contains programmer-written
+code), the destructor will be automatically registered as the object's
+initial clean-up function.
+
+There is no guarantee that the collector will detect every unreachable
+object (though it will find almost all of them). Clients should not
+rely on clean-up to cause some action to occur immediately -- clean-up
+is only a mechanism for improving resource usage.
+
+Every object with a clean-up function also has a clean-up queue. When
+the collector finds the object is unreachable, it enqueues it on its
+queue. The clean-up function is applied when the object is removed
+from the queue. By default, objects are enqueued on the garbage
+collector's queue, and the collector removes all objects from its
+queue after each collection. If a client supplies another queue for
+objects, it is his responsibility to remove objects (and cause their
+functions to be called) by polling it periodically.
+
+Clean-up queues allow clean-up functions accessing global data to
+synchronize with the main program. Garbage collection can occur at any
+time, and clean-ups invoked by the collector might access data in an
+inconsistent state. A client can control this by defining an explicit
+queue for objects and polling it at safe points.
+
+The following definitions are used by the specification below:
+
+Given a pointer t to a collected object, the base object BO(t) is the
+value returned by new when it created the object. (Because of multiple
+inheritance, t and BO(t) may not be the same address.)
+
+A weak pointer wp references an object *t if BO(wp.Pointer()) ==
+BO(t).
+
+***************************************************************************/
+
+template< class T, class Data > class CleanUp {
+public:
+
+static void Set( T* t, void c( Data* d, T* t ), Data* d = 0 )
+    /* Sets the clean-up function of object BO(t) to be <c, d>,
+       replacing any previously defined clean-up function for BO(t); c
+       and d can be null, but t cannot. Sets the clean-up queue for
+       BO(t) to be the collector's queue. When t is removed from its
+       clean-up queue, its clean-up will be applied by calling c(d,
+       t). It is an error if *t is not a collected object. */ 
+       {_CleanUp_Set( t, c, d );}
+
+static void Call( T* t )
+    /* Sets the new clean-up function for BO(t) to be null and, if the
+       old one is non-null, calls it immediately, even if BO(t) is
+       still reachable. Deactivates any weak pointers to BO(t). */
+       {_CleanUp_Call( t );}
+
+class Queue {public:
+    Queue()
+        /* Constructs a new queue. */
+            {this->head = _CleanUp_Queue_NewHead();}
+
+    void Set( T* t )
+        /* q.Set(t) sets the clean-up queue of BO(t) to be q. */
+            {_CleanUp_Queue_Set( this->head, t );}
+
+    int Call()
+        /* If q is non-empty, q.Call() removes the first object and
+           calls its clean-up function; does nothing if q is
+           empty. Returns true if there are more objects in the
+           queue. */
+           {return _CleanUp_Queue_Call( this->head );}
+
+    private:
+    void* head;
+    };
+};
+
+/**********************************************************************
+
+Reachability and Clean-up
+
+An object O is reachable if it can be reached via a non-empty path of
+normal pointers from the registers, stacks, global variables, or an
+object with a non-null clean-up function (including O itself),
+ignoring pointers from an object to itself.
+
+This definition of reachability ensures that if object B is accessible
+from object A (and not vice versa) and if both A and B have clean-up
+functions, then A will always be cleaned up before B. Note that as
+long as an object with a clean-up function is contained in a cycle of
+pointers, it will always be reachable and will never be cleaned up or
+collected.
+
+When the collector finds an unreachable object with a null clean-up
+function, it atomically deactivates all weak pointers referencing the
+object and recycles its storage. If object B is accessible from object
+A via a path of normal pointers, A will be discovered unreachable no
+later than B, and a weak pointer to A will be deactivated no later
+than a weak pointer to B.
+
+When the collector finds an unreachable object with a non-null
+clean-up function, the collector atomically deactivates all weak
+pointers referencing the object, redefines its clean-up function to be
+null, and enqueues it on its clean-up queue. The object then becomes
+reachable again and remains reachable at least until its clean-up
+function executes.
+
+The clean-up function is assured that its argument is the only
+accessible pointer to the object. Nothing prevents the function from
+redefining the object's clean-up function or making the object
+reachable again (for example, by storing the pointer in a global
+variable).
+
+If the clean-up function does not make its object reachable again and
+does not redefine its clean-up function, then the object will be
+collected by a subsequent collection (because the object remains
+unreachable and now has a null clean-up function). If the clean-up
+function does make its object reachable again and a clean-up function
+is subsequently redefined for the object, then the new clean-up
+function will be invoked the next time the collector finds the object
+unreachable.
+
+Note that a destructor for a collected object cannot safely redefine a
+clean-up function for its object, since after the destructor executes,
+the object has been destroyed into "raw memory". (In most
+implementations, destroying an object mutates its vtbl.)
+
+Finally, note that calling delete t on a collected object first
+deactivates any weak pointers to t and then invokes its clean-up
+function (destructor).
+
+**********************************************************************/
+
+extern "C" {
+    void* _WeakPointer_New( void* t );
+    void* _WeakPointer_Pointer( void* wp );
+    int _WeakPointer_Equal( void* wp1, void* wp2 );
+    int _WeakPointer_Hash( void* wp );
+    void _CleanUp_Set( void* t, void (*c)( void* d, void* t ), void* d );
+    void _CleanUp_Call( void* t );
+    void* _CleanUp_Queue_NewHead ();
+    void _CleanUp_Queue_Set( void* h, void* t );
+    int _CleanUp_Queue_Call( void* h );
+}
+
+#endif /* _weakpointer_h_ */
+
+
diff --git a/src/mzscheme/gc/win32_threads.c b/src/mzscheme/gc/win32_threads.c
new file mode 100755
index 0000000..eb485bd
--- /dev/null
+++ b/src/mzscheme/gc/win32_threads.c
@@ -0,0 +1,168 @@
+#ifdef WIN32_THREADS
+
+#include "gc_priv.h"
+
+#define STRICT
+#include <windows.h>
+
+#define MAX_THREADS 64
+
+struct thread_entry {
+  DWORD id;
+  HANDLE handle;
+  void *stack;   /* The cold end of the stack. */
+  CONTEXT context;
+};
+
+struct thread_entry thread_table[MAX_THREADS];
+
+void GC_stop_world()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack != 0 && thread_table[i].id != thread_id) {
+      if (SuspendThread(thread_table[i].handle) == (DWORD)-1)
+	ABORT("SuspendThread failed");
+    }
+}
+
+void GC_start_world()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack != 0 && thread_table[i].id != thread_id) {
+      if (ResumeThread(thread_table[i].handle) == (DWORD)-1)
+	ABORT("ResumeThread failed");
+    }
+}
+
+ptr_t GC_current_stackbottom()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack && thread_table[i].id == thread_id)
+      return thread_table[i].stack;
+  ABORT("no thread table entry for current thread");
+}
+
+ptr_t GC_get_lo_stack_addr(ptr_t s)
+{
+    ptr_t bottom;
+    MEMORY_BASIC_INFORMATION info;
+    VirtualQuery(s, &info, sizeof(info));
+    do {
+	bottom = info.BaseAddress;
+	VirtualQuery(bottom - 1, &info, sizeof(info));
+    } while ((info.Protect & PAGE_READWRITE) && !(info.Protect & PAGE_GUARD));
+    return(bottom);
+}
+
+void GC_push_all_stacks()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack) {
+      ptr_t bottom = GC_get_lo_stack_addr(thread_table[i].stack);
+      if (thread_table[i].id == thread_id)
+	GC_push_all(&i, thread_table[i].stack);
+      else {
+	thread_table[i].context.ContextFlags
+			= (CONTEXT_INTEGER|CONTEXT_CONTROL);
+	if (!GetThreadContext(thread_table[i].handle,
+	    		      &thread_table[i].context))
+	  ABORT("GetThreadContext failed");
+	if (thread_table[i].context.Esp >= (DWORD)thread_table[i].stack
+	    || thread_table[i].context.Esp < (DWORD)bottom)
+	    ABORT("Thread stack pointer out of range");
+	GC_push_all_stack(thread_table[i].context.Esp, thread_table[i].stack);
+      }
+    }
+}
+
+void GC_get_next_stack(char *start, char **lo, char **hi)
+{
+    int i;
+#   define ADDR_LIMIT (char *)(-1L)
+    char * current_min = ADDR_LIMIT;
+
+    for (i = 0; i < MAX_THREADS; i++) {
+    	char * s = (char *)thread_table[i].stack;
+
+	if (0 != s && s > start && s < current_min) {
+	    current_min = s;
+	}
+    }
+    *hi = current_min;
+    if (current_min == ADDR_LIMIT) {
+    	*lo = ADDR_LIMIT;
+	return;
+    }
+    *lo = GC_get_lo_stack_addr(current_min);
+    if (*lo < start) *lo = start;
+}
+
+LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info);
+
+/*
+ * This isn't generally safe, since DllMain is not premptible.
+ * If another thread holds the lock while this runs we're in trouble.
+ * Pontus Rydin suggests wrapping the thread start routine instead.
+ */
+BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved)
+{
+  switch (reason) {
+  case DLL_PROCESS_ATTACH:
+    InitializeCriticalSection(&GC_allocate_ml);
+    /* fall through */
+  case DLL_THREAD_ATTACH:
+    {
+      int i;
+      LOCK();
+      /* The following should be a noop according to the win32	*/
+      /* documentation.  There is empirical evidence that it	*/
+      /* isn't.		- HB					*/
+      if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler);
+      for (i = 0; thread_table[i].stack != 0; i++) {
+	if (i == MAX_THREADS - 1)
+	  ABORT("too many threads");
+      }
+      thread_table[i].stack = GC_get_stack_base();
+      thread_table[i].id = GetCurrentThreadId();
+      if (!DuplicateHandle(GetCurrentProcess(),
+	                   GetCurrentThread(),
+			   GetCurrentProcess(),
+			   &thread_table[i].handle,
+			   0,
+			   0,
+			   DUPLICATE_SAME_ACCESS)) {
+	    DWORD last_error = GetLastError();
+	    GC_printf1("Last error code: %lx\n", last_error);
+	    ABORT("DuplicateHandle failed");
+      }
+      UNLOCK();
+    }
+    break;
+  case DLL_PROCESS_DETACH:
+  case DLL_THREAD_DETACH:
+    {
+      int i;
+      DWORD thread_id = GetCurrentThreadId();
+      LOCK();
+      for (i = 0; thread_table[i].stack == 0 || thread_table[i].id != thread_id; i++)
+	if (i == MAX_THREADS - 1)
+	  ABORT("thread not found on detach");
+      thread_table[i].stack = 0;
+      CloseHandle(thread_table[i].handle);
+      BZERO(&thread_table[i].context, sizeof(CONTEXT));
+      UNLOCK();
+    }
+    break;
+  }
+  return TRUE;
+}
+
+#endif /* WIN32_THREADS */
diff --git a/src/mzscheme/gc/winthred.c b/src/mzscheme/gc/winthred.c
new file mode 100755
index 0000000..eb485bd
--- /dev/null
+++ b/src/mzscheme/gc/winthred.c
@@ -0,0 +1,168 @@
+#ifdef WIN32_THREADS
+
+#include "gc_priv.h"
+
+#define STRICT
+#include <windows.h>
+
+#define MAX_THREADS 64
+
+struct thread_entry {
+  DWORD id;
+  HANDLE handle;
+  void *stack;   /* The cold end of the stack. */
+  CONTEXT context;
+};
+
+struct thread_entry thread_table[MAX_THREADS];
+
+void GC_stop_world()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack != 0 && thread_table[i].id != thread_id) {
+      if (SuspendThread(thread_table[i].handle) == (DWORD)-1)
+	ABORT("SuspendThread failed");
+    }
+}
+
+void GC_start_world()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack != 0 && thread_table[i].id != thread_id) {
+      if (ResumeThread(thread_table[i].handle) == (DWORD)-1)
+	ABORT("ResumeThread failed");
+    }
+}
+
+ptr_t GC_current_stackbottom()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack && thread_table[i].id == thread_id)
+      return thread_table[i].stack;
+  ABORT("no thread table entry for current thread");
+}
+
+ptr_t GC_get_lo_stack_addr(ptr_t s)
+{
+    ptr_t bottom;
+    MEMORY_BASIC_INFORMATION info;
+    VirtualQuery(s, &info, sizeof(info));
+    do {
+	bottom = info.BaseAddress;
+	VirtualQuery(bottom - 1, &info, sizeof(info));
+    } while ((info.Protect & PAGE_READWRITE) && !(info.Protect & PAGE_GUARD));
+    return(bottom);
+}
+
+void GC_push_all_stacks()
+{
+  DWORD thread_id = GetCurrentThreadId();
+  int i;
+  for (i = 0; i < MAX_THREADS; i++)
+    if (thread_table[i].stack) {
+      ptr_t bottom = GC_get_lo_stack_addr(thread_table[i].stack);
+      if (thread_table[i].id == thread_id)
+	GC_push_all(&i, thread_table[i].stack);
+      else {
+	thread_table[i].context.ContextFlags
+			= (CONTEXT_INTEGER|CONTEXT_CONTROL);
+	if (!GetThreadContext(thread_table[i].handle,
+	    		      &thread_table[i].context))
+	  ABORT("GetThreadContext failed");
+	if (thread_table[i].context.Esp >= (DWORD)thread_table[i].stack
+	    || thread_table[i].context.Esp < (DWORD)bottom)
+	    ABORT("Thread stack pointer out of range");
+	GC_push_all_stack(thread_table[i].context.Esp, thread_table[i].stack);
+      }
+    }
+}
+
+void GC_get_next_stack(char *start, char **lo, char **hi)
+{
+    int i;
+#   define ADDR_LIMIT (char *)(-1L)
+    char * current_min = ADDR_LIMIT;
+
+    for (i = 0; i < MAX_THREADS; i++) {
+    	char * s = (char *)thread_table[i].stack;
+
+	if (0 != s && s > start && s < current_min) {
+	    current_min = s;
+	}
+    }
+    *hi = current_min;
+    if (current_min == ADDR_LIMIT) {
+    	*lo = ADDR_LIMIT;
+	return;
+    }
+    *lo = GC_get_lo_stack_addr(current_min);
+    if (*lo < start) *lo = start;
+}
+
+LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info);
+
+/*
+ * This isn't generally safe, since DllMain is not premptible.
+ * If another thread holds the lock while this runs we're in trouble.
+ * Pontus Rydin suggests wrapping the thread start routine instead.
+ */
+BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved)
+{
+  switch (reason) {
+  case DLL_PROCESS_ATTACH:
+    InitializeCriticalSection(&GC_allocate_ml);
+    /* fall through */
+  case DLL_THREAD_ATTACH:
+    {
+      int i;
+      LOCK();
+      /* The following should be a noop according to the win32	*/
+      /* documentation.  There is empirical evidence that it	*/
+      /* isn't.		- HB					*/
+      if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler);
+      for (i = 0; thread_table[i].stack != 0; i++) {
+	if (i == MAX_THREADS - 1)
+	  ABORT("too many threads");
+      }
+      thread_table[i].stack = GC_get_stack_base();
+      thread_table[i].id = GetCurrentThreadId();
+      if (!DuplicateHandle(GetCurrentProcess(),
+	                   GetCurrentThread(),
+			   GetCurrentProcess(),
+			   &thread_table[i].handle,
+			   0,
+			   0,
+			   DUPLICATE_SAME_ACCESS)) {
+	    DWORD last_error = GetLastError();
+	    GC_printf1("Last error code: %lx\n", last_error);
+	    ABORT("DuplicateHandle failed");
+      }
+      UNLOCK();
+    }
+    break;
+  case DLL_PROCESS_DETACH:
+  case DLL_THREAD_DETACH:
+    {
+      int i;
+      DWORD thread_id = GetCurrentThreadId();
+      LOCK();
+      for (i = 0; thread_table[i].stack == 0 || thread_table[i].id != thread_id; i++)
+	if (i == MAX_THREADS - 1)
+	  ABORT("thread not found on detach");
+      thread_table[i].stack = 0;
+      CloseHandle(thread_table[i].handle);
+      BZERO(&thread_table[i].context, sizeof(CONTEXT));
+      UNLOCK();
+    }
+    break;
+  }
+  return TRUE;
+}
+
+#endif /* WIN32_THREADS */
diff --git a/src/mzscheme/guile/Makefile b/src/mzscheme/guile/Makefile
new file mode 100644
index 0000000..859f3ab
--- /dev/null
+++ b/src/mzscheme/guile/Makefile
@@ -0,0 +1,59 @@
+
+CC = gcc
+RANLIB=ranlib
+
+CFLAGS_NODBG = $(OPT) $(WARN) $(OPTIONS) -I../include
+CFLAGS = $(DEBUGFLAGS) $(CFLAGS_NODBG)
+
+LIBDIR = lib/sys$(MZPLATFORMSUFFIX)
+
+OBJDIR = objects/sys$(MZPLATFORMSUFFIX)
+
+OBJECTS = $(OBJDIR)/guile.o
+
+HEADERS =  gh.h
+
+# LINKEXTRA for AIX
+LINKEXTRA = 
+# LINKEXTRA = -lld ../lib/sys/libdl.a 
+
+libguile: ../$(LIBDIR)/libguile.a
+
+../$(LIBDIR)/libguile.a: $(OBJECTS) ../$(LIBDIR)/libmzscheme.a ../$(LIBDIR)/libgc.a 
+	@echo repackaging libmzscheme.a and libgc.a into libguile.a...
+	cd tmp; $(AR) x ../../$(LIBDIR)/libmzscheme.a
+	cd tmp; $(AR) x ../../$(LIBDIR)/libgc.a
+	$(AR) ruv ../$(LIBDIR)/libguile.a $(OBJECTS) tmp/*.o
+	$(RANLIB) ../$(LIBDIR)/libguile.a
+	rm -rf tmp/*.o
+
+test: ../$(LIBDIR)/libguile.a $(OBJDIR)/test.o
+	$(CC) -o test $(OBJDIR)/test.o ../$(LIBDIR)/libguile.a -lm $(LINKEXTRA)
+
+$(OBJDIR)/guile.o: objects $(OBJDIR) guile.c guileinc.c wrap.inc $(HEADERS)
+
+$(OBJDIR)/guile.o: guile.c
+	$(CC) $(CFLAGS) -c guile.c -o $(OBJDIR)/guile.o
+
+$(OBJDIR)/test.o: test.c $(HEADERS)
+	$(CC) $(CFLAGS) -c test.c -o $(OBJDIR)/test.o
+
+guileinc.c: mkghsrc
+	mkghsrc
+
+gh.h: ghbase.h mkghsrc
+	mkghsrc
+
+wrap.inc: mkghsrc
+	mkghsrc
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+objects:
+	mkdir objects
+
+clean:
+	rm -rf *.o *~ #*#
+	rm -rf test
+	rm -rf tmp/*
diff --git a/src/mzscheme/guile/NOTES b/src/mzscheme/guile/NOTES
new file mode 100644
index 0000000..888d4cd
--- /dev/null
+++ b/src/mzscheme/guile/NOTES
@@ -0,0 +1,72 @@
+
+Additions/deviations from the current libguile spec:
+----------------------------------------------------
+
+   void gh_new_argv_procedure(char* name,
+	 		  SCM (*fn)(int argc, SCM argv[]),
+			  int required,
+			  int optional)
+
+    fn receives args in an array. optional < 0 => no maximum number
+    of arguments.
+
+   void gh_make_argv_subr(SCM (*fn)(int argc, SCM argv[]),
+			   int required,
+			   int optional,
+			   int varp,
+			   char* doc)
+
+    fn receives args in an array. optional < 0 => no maximum number
+    of arguments.
+
+
+   SCM gh_apply_argv(SCM rator, int num_rands, SCM rands[])
+
+    Applies `rator' to the `num_rands' arguments in the `rands'
+    array.
+
+   int gh_obj_length(SCM obj)
+
+    Always returns -1.
+
+   int gh_string_p(SCM x)
+
+     Predicate.
+
+   void gh_lock(SCM v)
+
+    Keeps v from begin GCed. Can be applied any number of times to
+    the same v, but gc_unlock() must be called once per gc_lock().
+
+   void gh_unlock(SCM v)
+
+    Undoes one gc_lock() on v.
+
+   SCM gh_catch(SCM key, SCM thunk, SCM handler)
+   SCM gh_throw(SCM key, SCM args)
+
+    Not yet implemented.
+
+   int gh_fits_C_long_p(SCM x)
+   int gh_fits_C_unsigned_long_p(SCM x)
+
+     Predicates.
+
+Memory
+------
+
+   All SCM values are garbage-collected. References to gc'ed memory
+   from registers or from the stack are recognized by the collector.
+   Static variables and malloc'ed memory are not. All collection is
+   "conservative": the collector does not know which memory locations
+   hold pointers and which hold non-pointers, so all word-aligned
+   locations are assumed to hold pointers. GC'ed values are never
+   relocated by the collector.
+
+SCM -> X conversion
+-------------------
+
+   No typechecks are performed by the gh_scm2X() procedures. For
+   example, the argument to gh_scm2long() must be a value that fits
+   into a signed long int.
+
diff --git a/src/mzscheme/guile/README b/src/mzscheme/guile/README
new file mode 100644
index 0000000..69af189
--- /dev/null
+++ b/src/mzscheme/guile/README
@@ -0,0 +1,7 @@
+
+This directory contains support files for a libguile implementation
+using MzScheme. Libguile implements GNU's emerging high-level GUILE
+interface specification. This work is still experimental.
+
+To compile libguile, go to the directory above this one and run
+`mzmake libguile'.
diff --git a/src/mzscheme/guile/gh.h b/src/mzscheme/guile/gh.h
new file mode 100644
index 0000000..f017ec3
--- /dev/null
+++ b/src/mzscheme/guile/gh.h
@@ -0,0 +1,117 @@
+
+/* libguile header for MzScheme implementation */
+
+#ifdef _UsesMzScheme_
+typedef Scheme_Object *SCM;
+#else
+typedef struct {} *SCM;
+
+extern SCM scheme_true, scheme_false, scheme_null, scheme_void;
+#endif
+
+#define SCM_BOOL_T scheme_true
+#define SCM_BOOL_F scheme_false
+#define SCM_EOL scheme_null
+#define SCM_UNSPECIFIED scheme_void
+
+#define GH_EOL_MARKER 0L
+
+typedef SCM (*SCM_FN)();
+typedef SCM (*SCM_ARGV_FN)(int argc, SCM argv[]);
+typedef void (*SCM_MAIN_FN)(int argc, char *argv[]);
+
+#define GH_DEFER_INTS /**/
+#define GH_ALLOW_INTS /**/
+
+/* Remainder is generated by mkghsrc */
+
+void gh_enter(int argc , char **argv , SCM_MAIN_FN prc );
+SCM gh_eval_str(char* s );
+SCM gh_eval_file(char* file );
+void gh_new_procedure(char* name , SCM_FN fn , int required , int optional , int restp );
+SCM gh_bool(int x );
+SCM gh_long2scm(long x );
+SCM gh_ulong2scm(unsigned long x );
+SCM gh_double2scm(double x );
+SCM gh_char2scm(char x );
+SCM gh_str2scm(char* x , int len );
+SCM gh_str02scm(char* x );
+void gh_set_substr(char* x , SCM dst , int start , int len );
+SCM gh_symbol2scm(char* x );
+int gh_scm2bool(SCM x );
+int gh_scm2char(SCM x );
+unsigned long gh_scm2ulong(SCM x );
+long gh_scm2long(SCM x );
+double gh_scm2double(SCM x );
+char* gh_scm2newstr(SCM x , int* len );
+void gh_get_substr(SCM s , char* x , int start , int len );
+char* gh_symbol2newstr(SCM x , int* len );
+int gh_boolean_p(SCM x );
+int gh_symbol_p(SCM x );
+int gh_char_p(SCM x );
+int gh_vector_p(SCM x );
+int gh_pair_p(SCM x );
+int gh_procedure_p(SCM x );
+int gh_string_p(SCM x );
+int gh_exact_p(SCM x );
+int gh_inexact_p(SCM x );
+int gh_eq_p(SCM x , SCM y );
+int gh_eqv_p(SCM x , SCM y );
+int gh_equal_p(SCM x , SCM y );
+void gh_define(char* name , SCM v );
+SCM gh_cons(SCM car , SCM cdr );
+SCM gh_list(SCM v , ...);
+int gh_ilength(SCM ls );
+void gh_set_car(SCM pr , SCM val );
+void gh_set_cdr(SCM pr , SCM val );
+SCM gh_caaaar(SCM pr );
+SCM gh_caaadr(SCM pr );
+SCM gh_caadar(SCM pr );
+SCM gh_caaddr(SCM pr );
+SCM gh_caaar(SCM pr );
+SCM gh_caadr(SCM pr );
+SCM gh_cadaar(SCM pr );
+SCM gh_cadadr(SCM pr );
+SCM gh_caddar(SCM pr );
+SCM gh_cadddr(SCM pr );
+SCM gh_cadar(SCM pr );
+SCM gh_caddr(SCM pr );
+SCM gh_caar(SCM pr );
+SCM gh_cadr(SCM pr );
+SCM gh_cdaaar(SCM pr );
+SCM gh_cdaadr(SCM pr );
+SCM gh_cdadar(SCM pr );
+SCM gh_cdaddr(SCM pr );
+SCM gh_cdaar(SCM pr );
+SCM gh_cdadr(SCM pr );
+SCM gh_cddaar(SCM pr );
+SCM gh_cddadr(SCM pr );
+SCM gh_cdddar(SCM pr );
+SCM gh_cddddr(SCM pr );
+SCM gh_cddar(SCM pr );
+SCM gh_cdddr(SCM pr );
+SCM gh_cdar(SCM pr );
+SCM gh_cddr(SCM pr );
+SCM gh_car(SCM pr );
+SCM gh_cdr(SCM pr );
+SCM gh_vector(int len , SCM fill );
+SCM gh_vref(SCM v , int i );
+SCM gh_vset(SCM v , int i , SCM x );
+int gh_vector_length(SCM v );
+SCM gh_make_subr(SCM_FN fn , int required , int optional , int varp , char* doc );
+SCM gh_apply(SCM rator , SCM rands );
+SCM gh_call0(SCM proc );
+SCM gh_call1(SCM proc , SCM arg );
+SCM gh_call2(SCM proc , SCM arg1 , SCM arg2 );
+SCM gh_call3(SCM proc , SCM arg1 , SCM arg2 , SCM arg3 );
+int lgh_obj_length(SCM obj );
+SCM gh_catch(SCM key , SCM thunk , SCM handler );
+SCM gh_throw(SCM key , SCM args );
+SCM gh_curry(SCM proc , SCM first );
+void gh_new_argv_procedure(char* name , SCM_ARGV_FN fn , int required , int optional );
+SCM gh_make_argv_subr(SCM_ARGV_FN fn , int required , int optional , char* doc );
+SCM gh_apply_argv(SCM rator , int argc , SCM* argv );
+void gh_lock(SCM v );
+void gh_unlock(SCM v );
+int gh_fits_C_long_p(SCM x );
+int gh_fits_C_unsigned_long_p(SCM x );
diff --git a/src/mzscheme/guile/ghbase.h b/src/mzscheme/guile/ghbase.h
new file mode 100644
index 0000000..b023780
--- /dev/null
+++ b/src/mzscheme/guile/ghbase.h
@@ -0,0 +1,27 @@
+
+/* libguile header for MzScheme implementation */
+
+#ifdef _UsesMzScheme_
+typedef Scheme_Object *SCM;
+#else
+typedef struct {} *SCM;
+
+extern SCM scheme_true, scheme_false, scheme_null, scheme_void;
+#endif
+
+#define SCM_BOOL_T scheme_true
+#define SCM_BOOL_F scheme_false
+#define SCM_EOL scheme_null
+#define SCM_UNSPECIFIED scheme_void
+
+#define GH_EOL_MARKER 0L
+
+typedef SCM (*SCM_FN)();
+typedef SCM (*SCM_ARGV_FN)(int argc, SCM argv[]);
+typedef void (*SCM_MAIN_FN)(int argc, char *argv[]);
+
+#define GH_DEFER_INTS /**/
+#define GH_ALLOW_INTS /**/
+
+/* Remainder is generated by mkghsrc */
+
diff --git a/src/mzscheme/guile/guile.c b/src/mzscheme/guile/guile.c
new file mode 100644
index 0000000..0a17356
--- /dev/null
+++ b/src/mzscheme/guile/guile.c
@@ -0,0 +1,247 @@
+
+/* 
+ * guile.c
+ * libguile implementation for MzScheme
+ * Matthew 08/10/96
+ */
+
+#ifdef _MzSchemeExtension_
+#include "escheme.h"
+#else
+#include "scheme.h"
+#endif
+
+#define scheme_env scheme_get_env(scheme_config)
+
+/* _UsesMzScheme_ equates SCM and SchemeObject* */
+#define _UsesMzScheme_
+#include "gh.h"
+
+char *strdup_sized(char *s, int len)
+{
+  char *n;
+  n = malloc(len);
+  memcpy(n, s, len);
+  return n;
+}
+
+#include "guileinc.c"
+
+void gh_enter(int argc, char **argv, SCM_MAIN_FN proc)
+{
+#ifndef _MzSchemeExtension_
+  (void)scheme_basic_env();
+#endif
+  proc(argc, argv);
+}
+
+/*************** Procedures *********************/
+
+typedef struct {
+  SCM_FN f;
+  int n;
+} WrappedProc;
+
+typedef struct {
+  SCM f;
+  SCM a;
+} CurriedProc;
+
+Scheme_Object *wrapper(void *wp, int argc, Scheme_Object *argv[])
+{
+  SCM_FN f = ((WrappedProc *)wp)->f;
+  int n = ((WrappedProc *)wp)->n;
+  Scheme_Object *v2[11], *rest;
+  
+  if (argc > n) {
+    rest = scheme_build_list(argc - n, argv + n);
+  } else if (argc < n) {
+    int i;
+    for (i = 0; i < n; i++)
+      if (i < argc)
+	v2[i] = argv[i];
+      else
+	v2[i] = NULL;
+    argv = v2;
+    rest = scheme_null;
+  } else
+    rest = scheme_null;
+
+  switch (n) {
+# include "wrap.inc"
+  }
+
+  return NULL;
+}
+
+SCM gh_make_subr (SCM_FN fn, int req, int opt, int varp, char *doc)
+{
+  WrappedProc *wp;
+
+  wp = (WrappedProc *)scheme_malloc(sizeof(WrappedProc));
+
+  wp->f = fn;
+  wp->n = req + opt;
+
+  return scheme_make_closed_prim_w_arity(wrapper, (void *)wp, NULL,
+					 req, varp ? -1 : req + opt);
+}
+
+#define CURRY_QUICK_SIZE 5
+
+static Scheme_Object *do_curry(void *c, int argc, Scheme_Object *argv[])
+{
+  Scheme_Object **argv2, *quick[CURRY_QUICK_SIZE];
+  int i;
+
+  if (argc < CURRY_QUICK_SIZE)
+    argv2 = quick;
+  else
+    argv2 = (Scheme_Object **)scheme_malloc((argc + 1) * sizeof(Scheme_Object *));
+
+  argv2[0] = ((CurriedProc *)c)->a;
+  for (i = 0; i < argc; i++)
+    argv2[i] = argv[i + 1];
+
+  return scheme_apply(((CurriedProc *)c)->f, argc + 1, argv2);
+}
+
+SCM gh_curry(SCM f, SCM a)
+{
+  CurriedProc *c;
+
+  c = (CurriedProc *)scheme_malloc(sizeof(CurriedProc));
+  c->f = f;
+  c->a = a;
+
+  return scheme_make_closed_prim(do_curry, (void *)c);
+}
+
+SCM gh_call1(SCM proc, SCM arg1)
+{
+  SCM args[1];
+  args[0] = arg1;
+  return _scheme_apply(proc, 1, args);
+}
+
+SCM gh_call2(SCM proc, SCM arg1, SCM arg2)
+{
+  SCM args[2];
+  args[0] = arg1;
+  args[1] = arg2;
+  return _scheme_apply(proc, 2, args);
+}
+
+SCM gh_call3(SCM proc, SCM arg1, SCM arg2, SCM arg3)
+{
+  SCM args[3];
+  args[0] = arg1;
+  args[1] = arg2;
+  args[2] = arg3;
+  return _scheme_apply(proc, 3, args);
+}
+
+/*************** Catch/Throw *********************/
+
+SCM gh_catch(SCM key, SCM thunk, SCM handler)
+{
+  
+}
+
+SCM gh_throw (SCM key, SCM args)
+{
+}
+
+/*************** Numbers *********************/
+
+int gh_fits_C_long_p(SCM x)
+{
+  long v;
+
+  if (SCHEME_INTP(x) || SCHEME_BIGNUMP(x))
+    return scheme_get_int_val(x, &v);
+  else if (SCHEME_DBLP(x)) {
+    double d = SCHEME_DBL_VAL(x);
+    if (d == (long)d)
+      return 1;
+  } 
+
+  return 0;
+}
+
+int gh_fits_C_unsigned_long_p(SCM x)
+{
+  unsigned long v;
+
+  if (SCHEME_INTP(x) || SCHEME_BIGNUMP(x))
+    return scheme_get_unsigned_int_val(x, &v);
+  else if (SCHEME_DBLP(x)) {
+    double d = SCHEME_DBL_VAL(x);
+    if (d == (unsigned long)d)
+      return 1;
+  } 
+
+  return 0;
+}
+
+long gh_scm2long(SCM x)
+{
+  long v;
+
+  if (SCHEME_DBLP(x))
+    return SCHEME_DBL_VAL(x);
+  else
+    scheme_get_int_val(x, &v);
+
+  return v;
+}
+
+unsigned long gh_scm2ulong(SCM x)
+{
+  unsigned long v;
+
+  if (SCHEME_DBLP(x))
+    return SCHEME_DBL_VAL(x);
+  else
+    scheme_get_unsigned_int_val(x, &v);
+
+  return v;
+}
+
+double gh_scm2double(SCM x)
+{
+  if (SCHEME_DBLP(x))
+    return SCHEME_DBL_VAL(x);
+  else if (SCHEME_INTP(x))
+    return SCHEME_INT_VAL(x);
+  else if (SCHEME_BIGNUMP(x))
+    return scheme_bignum_to_float(x);
+  else if (SCHEME_RATIONALP(x))
+    return scheme_rational_to_float(x);
+  else
+    return 0;
+}
+
+SCM gh_list(SCM x, ...)
+{
+  Scheme_Object *first, *last, *pair;
+  va_list args;
+
+  va_start(args, x);
+
+  first = last = scheme_make_pair(x, scheme_null);
+  while(1) {
+    x = va_arg(args, Scheme_Object*);
+    if (x) {
+      pair = scheme_make_pair(x, scheme_null);
+      SCHEME_CDR(last) = pair;
+      last = pair;
+    } else
+      break;
+  }
+
+  va_end(args);
+
+  return first;
+}
+
diff --git a/src/mzscheme/guile/guileinc.c b/src/mzscheme/guile/guileinc.c
new file mode 100644
index 0000000..0a13aa4
--- /dev/null
+++ b/src/mzscheme/guile/guileinc.c
@@ -0,0 +1,380 @@
+SCM gh_eval_str(char* s )
+{
+  return scheme_eval_string(s, scheme_env);
+}
+
+SCM gh_eval_file(char* file )
+{
+  return scheme_load(file);
+}
+
+void gh_new_procedure(char* name , SCM_FN fn , int required , int optional , int restp )
+{
+  scheme_add_global(name, gh_make_subr(fn, required, optional, restp, NULL), scheme_env);
+}
+
+SCM gh_bool(int x )
+{
+  return x ? scheme_true : scheme_false;
+}
+
+SCM gh_long2scm(long x )
+{
+  return scheme_make_integer_value(x);
+}
+
+SCM gh_ulong2scm(unsigned long x )
+{
+  return scheme_make_integer_value_from_unsigned(x);
+}
+
+SCM gh_double2scm(double x )
+{
+  return scheme_make_double(x);
+}
+
+SCM gh_char2scm(char x )
+{
+  return scheme_make_char(x);
+}
+
+SCM gh_str2scm(char* x , int len )
+{
+  return scheme_make_sized_string(x, len, 1);
+}
+
+SCM gh_str02scm(char* x )
+{
+  return scheme_make_string(x);
+}
+
+void gh_set_substr(char* x , SCM dst , int start , int len )
+{
+  if (start + len >= SCHEME_STRTAG_VAL(dst)) { scheme_signal_error("gh_set_substr: out-of-range"); } {memcpy(SCHEME_STR_VAL(dst) + start, x, len); };
+}
+
+SCM gh_symbol2scm(char* x )
+{
+  return scheme_intern_symbol(x);
+}
+
+int gh_scm2bool(SCM x )
+{
+  return SCHEME_TRUEP(x);
+}
+
+int gh_scm2char(SCM x )
+{
+  return SCHEME_CHAR_VAL(x);
+}
+
+char* gh_scm2newstr(SCM x , int* len )
+{
+  return (*len = SCHEME_STRTAG_VAL(x), strdup_sized(SCHEME_STR_VAL(x), *len));
+}
+
+void gh_get_substr(SCM s , char* x , int start , int len )
+{
+  if (start + len >= SCHEME_STRTAG_VAL(s)) { scheme_signal_error("gh_get_substr: out-of-range"); } {memcpy(x, SCHEME_STR_VAL(s) + start, len); };
+}
+
+char* gh_symbol2newstr(SCM x , int* len )
+{
+  return (*len = SCHEME_SYM_LEN(x), strdup_sized(SCHEME_STR_VAL(x), *len));
+}
+
+int gh_boolean_p(SCM x )
+{
+  return SCHEME_BOOLP(x);
+}
+
+int gh_symbol_p(SCM x )
+{
+  return SCHEME_SYMBOLP(x);
+}
+
+int gh_char_p(SCM x )
+{
+  return SCHEME_CHARP(x);
+}
+
+int gh_vector_p(SCM x )
+{
+  return SCHEME_VECTORP(x);
+}
+
+int gh_pair_p(SCM x )
+{
+  return SCHEME_PAIRP(x);
+}
+
+int gh_procedure_p(SCM x )
+{
+  return SCHEME_PROCP(x);
+}
+
+int gh_string_p(SCM x )
+{
+  return SCHEME_STRINGP(x);
+}
+
+int gh_exact_p(SCM x )
+{
+  return scheme_is_exact(x);
+}
+
+int gh_inexact_p(SCM x )
+{
+  return scheme_is_inexact(x);
+}
+
+int gh_eq_p(SCM x , SCM y )
+{
+  return scheme_eq(x, y);
+}
+
+int gh_eqv_p(SCM x , SCM y )
+{
+  return scheme_eqv(x, y);
+}
+
+int gh_equal_p(SCM x , SCM y )
+{
+  return scheme_equal(x, y);
+}
+
+void gh_define(char* name , SCM v )
+{
+  scheme_add_global(name, v, scheme_env);
+}
+
+SCM gh_cons(SCM car , SCM cdr )
+{
+  return scheme_make_pair(car, cdr);
+}
+
+int gh_ilength(SCM ls )
+{
+  return scheme_proper_list_length(ls);
+}
+
+void gh_set_car(SCM pr , SCM val )
+{
+  SCHEME_CAR(pr) = val;
+}
+
+void gh_set_cdr(SCM pr , SCM val )
+{
+  SCHEME_CDR(pr) = val;
+}
+
+SCM gh_caaaar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CAR(SCHEME_CAR(pr))));
+}
+
+SCM gh_caaadr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CAR(SCHEME_CDR(pr))));
+}
+
+SCM gh_caadar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(pr))));
+}
+
+SCM gh_caaddr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(pr))));
+}
+
+SCM gh_caaar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CAR(pr)));
+}
+
+SCM gh_caadr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(SCHEME_CDR(pr)));
+}
+
+SCM gh_cadaar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cadadr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(pr))));
+}
+
+SCM gh_caddar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cadddr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(pr))));
+}
+
+SCM gh_cadar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(pr)));
+}
+
+SCM gh_caddr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(pr)));
+}
+
+SCM gh_caar(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CAR(pr));
+}
+
+SCM gh_cadr(SCM pr )
+{
+  return SCHEME_CAR(SCHEME_CDR(pr));
+}
+
+SCM gh_cdaaar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CAR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cdaadr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CAR(SCHEME_CDR(pr))));
+}
+
+SCM gh_cdadar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cdaddr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(pr))));
+}
+
+SCM gh_cdaar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CAR(pr)));
+}
+
+SCM gh_cdadr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(pr)));
+}
+
+SCM gh_cddaar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cddadr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(pr))));
+}
+
+SCM gh_cdddar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(pr))));
+}
+
+SCM gh_cddddr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(pr))));
+}
+
+SCM gh_cddar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CAR(pr)));
+}
+
+SCM gh_cdddr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(pr)));
+}
+
+SCM gh_cdar(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CAR(pr));
+}
+
+SCM gh_cddr(SCM pr )
+{
+  return SCHEME_CDR(SCHEME_CDR(pr));
+}
+
+SCM gh_car(SCM pr )
+{
+  return SCHEME_CAR(pr);
+}
+
+SCM gh_cdr(SCM pr )
+{
+  return SCHEME_CDR(pr);
+}
+
+SCM gh_vector(int len , SCM fill )
+{
+  return scheme_make_vector(len, fill);
+}
+
+SCM gh_vref(SCM v , int i )
+{
+  return SCHEME_VEC_ELS(v)[i];
+}
+
+SCM gh_vset(SCM v , int i , SCM x )
+{
+  return SCHEME_VEC_ELS(v)[i] = x;
+}
+
+int gh_vector_length(SCM v )
+{
+  return SCHEME_VEC_SIZE(v);
+}
+
+SCM gh_apply(SCM rator , SCM rands )
+{
+  return scheme_apply_to_list(rator, rands);
+}
+
+SCM gh_call0(SCM proc )
+{
+  return _scheme_apply(proc, 0, NULL);
+}
+
+int lgh_obj_length(SCM obj )
+{
+  return -1;
+}
+
+void gh_new_argv_procedure(char* name , SCM_ARGV_FN fn , int required , int optional )
+{
+  scheme_add_global(name, scheme_make_prim_w_arity(fn, name, required, optional), scheme_env);
+}
+
+SCM gh_make_argv_subr(SCM_ARGV_FN fn , int required , int optional , char* doc )
+{
+  return scheme_make_prim_w_arity(fn, NULL, required, optional);
+}
+
+SCM gh_apply_argv(SCM rator , int argc , SCM* argv )
+{
+  return _scheme_apply(rator, argc, argv);
+}
+
+void gh_lock(SCM v )
+{
+  scheme_dont_gc_ptr(v);
+}
+
+void gh_unlock(SCM v )
+{
+  scheme_gc_ptr_ok(v);
+}
+
diff --git a/src/mzscheme/guile/mkghsrc b/src/mzscheme/guile/mkghsrc
new file mode 100755
index 0000000..50f41e0
--- /dev/null
+++ b/src/mzscheme/guile/mkghsrc
@@ -0,0 +1,262 @@
+#!/bin/sh
+string=? ; exec /home/mflatt/bin/mzscheme -rg $0 "$@"
+
+;; Generates the most machanical parts of gh_ -> scheme_ for MzScheme
+;; Writes gh.h (copying from ghbase.h), guileinc.c, and wrap.inc
+;;
+;; Matthew 08/10/96
+;; Revised 04/30/97
+
+(define
+  GUILE_HIGH_LEVEL
+  `((void gh_enter ([int argc][ char **argv][SCM_MAIN_FN prc]))
+
+    (SCM gh_eval_str ([char* s]) (scheme_eval_string s scheme_env))
+    (SCM gh_eval_file ([char* file]) (scheme_load file))
+    
+    (void gh_new_procedure ([char* name] 
+			    [SCM_FN fn]
+			    [int required]
+			    [int optional]
+			    [int restp])
+	  (scheme_add_global 
+	   name 
+	   (gh_make_subr fn required optional restp NULL)
+	   scheme_env))
+
+    (SCM gh_bool ([int x]) (? x scheme_true scheme_false))
+    (SCM gh_long2scm ([long x]) (scheme_make_integer_value x))
+    (SCM gh_ulong2scm ([unsigned long x]) (scheme_make_integer_value_from_unsigned x))
+    (SCM gh_double2scm ([double x]) (scheme_make_double x))
+    (SCM gh_char2scm ([char x]) (scheme_make_char x))
+    (SCM gh_str2scm ([char* x][int len]) (scheme_make_sized_string x len 1))
+    (SCM gh_str02scm ([char* x]) (scheme_make_string x))
+
+    (void gh_set_substr ([char* x][SCM dst][int start][int len])
+	  (if (>= (+ start len) (SCHEME_STRTAG_VAL dst))
+	      (scheme_signal_error "\"gh_set_substr: out-of-range\"")
+	      (memcpy (+ (SCHEME_STR_VAL dst) start) x len)))
+
+    (SCM gh_symbol2scm ([char* x]) (scheme_intern_symbol x))
+
+    (int gh_scm2bool ([SCM x]) (SCHEME_TRUEP x))
+    (int gh_scm2char ([SCM x]) (SCHEME_CHAR_VAL x))
+
+    ("unsigned long" gh_scm2ulong ([SCM x]))
+    (long gh_scm2long ([SCM x]))
+    (double gh_scm2double ([SCM x]))
+
+    (char* gh_scm2newstr ([SCM x][int* len])
+	   (begin
+	     (= *len (SCHEME_STRTAG_VAL x))
+	     (strdup_sized (SCHEME_STR_VAL x) *len)))
+
+    (void gh_get_substr ([SCM s][char* x][int start][int len])
+	  (if (>= (+ start len) (SCHEME_STRTAG_VAL s))
+	      (scheme_signal_error "\"gh_get_substr: out-of-range\"")
+	      (memcpy x (+ (SCHEME_STR_VAL s) start) len)))
+
+    (char* gh_symbol2newstr ([SCM x][int* len])
+	   (begin
+	     (= *len (SCHEME_SYM_LEN x))
+	     (strdup_sized (SCHEME_STR_VAL x) *len)))
+
+    (int gh_boolean_p ([SCM x]) (SCHEME_BOOLP x)) 
+    (int gh_symbol_p ([SCM x]) (SCHEME_SYMBOLP x)) 
+    (int gh_char_p ([SCM x]) (SCHEME_CHARP x)) 
+    (int gh_vector_p ([SCM x]) (SCHEME_VECTORP x)) 
+    (int gh_pair_p ([SCM x]) (SCHEME_PAIRP x)) 
+    (int gh_procedure_p ([SCM x]) (SCHEME_PROCP x)) 
+    (int gh_string_p ([SCM x]) (SCHEME_STRINGP x)) 
+    (int gh_exact_p ([SCM x]) (scheme_is_exact x))
+    (int gh_inexact_p ([SCM x]) (scheme_is_inexact x))
+
+    (int gh_eq_p ([SCM x][SCM y]) (scheme_eq x y))
+    (int gh_eqv_p ([SCM x][SCM y]) (scheme_eqv x y))
+    (int gh_equal_p ([SCM x][SCM y]) (scheme_equal x y))
+
+    (void gh_define ([char* name][SCM v]) (scheme_add_global name v scheme_env))
+    (SCM gh_cons ([SCM car][SCM cdr]) (scheme_make_pair car cdr))
+    (SCM gh_list ([SCM v] ...))
+    (int gh_ilength ([SCM ls]) (scheme_proper_list_length ls))
+    (void gh_set_car ([SCM pr][SCM val]) (= (SCHEME_CAR pr) val))
+    (void gh_set_cdr ([SCM pr][SCM val]) (= (SCHEME_CDR pr) val))
+
+    ,@(let loop ([n 4])
+	(if (zero? n)
+	    null
+	    (let ([l (loop (sub1 n))]
+		  [add-layer
+		   (lambda (letter op)
+		     (lambda (proto)
+		       (let* ([old-name (symbol->string (cadr proto))]
+			      [new-name (string->symbol
+					 (string-append
+					  "gh_c"
+					  letter
+					  (substring old-name
+						     4
+						     (string-length old-name))))]
+			      [old-body (cadddr proto)])
+			 (list 'SCM new-name (caddr proto)
+			       (list op old-body)))))])
+	      (append
+	       (map (add-layer "a" 'SCHEME_CAR) l)
+	       (map (add-layer "d" 'SCHEME_CDR) l)
+	       '((SCM gh_car ([SCM pr]) (SCHEME_CAR pr))
+		 (SCM gh_cdr ([SCM pr]) (SCHEME_CDR pr)))))))
+
+    (SCM gh_vector ([int len][SCM fill]) (scheme_make_vector len fill))
+    (SCM gh_vref ([SCM v][int i]) (@ (SCHEME_VEC_ELS v) i))
+    (SCM gh_vset ([SCM v][int i][SCM x]) (= (@ (SCHEME_VEC_ELS v) i) x))
+    (int gh_vector_length ([SCM v]) (SCHEME_VEC_SIZE v))
+
+    (SCM gh_make_subr ([SCM_FN fn]
+		       [int required]
+		       [int optional]
+		       [int varp]
+		       [char* doc]))
+
+    (SCM gh_apply ([SCM rator][SCM rands]) (scheme_apply_to_list rator rands))
+
+    (SCM gh_call0 ([SCM proc]) (_scheme_apply proc 0 NULL))
+    (SCM gh_call1 ([SCM proc][SCM arg]))
+    (SCM gh_call2 ([SCM proc][SCM arg1][SCM arg2]))
+    (SCM gh_call3 ([SCM proc][SCM arg1][SCM arg2][SCM arg3]))
+
+    (int lgh_obj_length ([SCM obj]) -1)
+
+    (SCM gh_catch ([SCM key][SCM thunk][SCM handler]))
+    (SCM gh_throw ([SCM key][SCM args]))
+
+    ;; Non-standard:
+
+    (SCM gh_curry ([SCM proc][SCM first]))
+
+    (void gh_new_argv_procedure ([char* name] 
+				 [SCM_ARGV_FN fn]
+				 [int required]
+				 [int optional])
+	  (scheme_add_global
+	   name
+	   (scheme_make_prim_w_arity fn name required optional)
+	   scheme_env))
+    (SCM gh_make_argv_subr ([SCM_ARGV_FN fn]
+			    [int required]
+			    [int optional]
+			    [char* doc])
+	 (scheme_make_prim_w_arity fn NULL required optional))
+    (SCM gh_apply_argv ([SCM rator][int argc][SCM* argv]) (_scheme_apply rator argc argv))
+
+    (void gh_lock ([SCM v]) (scheme_dont_gc_ptr v))
+    (void gh_unlock ([SCM v]) (scheme_gc_ptr_ok v))
+
+    (int gh_fits_C_long_p ([SCM x]))
+    (int gh_fits_C_unsigned_long_p ([SCM x]))))
+
+(define (write-proto f)
+  (let ([first-done? #f])
+    (printf "~a ~a(" (car f) (cadr f))
+    (for-each
+     (lambda (arg)
+       (when first-done? (display ", "))
+       (set! first-done? #t)
+       (if (pair? arg)
+	   (for-each (lambda (x) (display x) (display " ")) arg)
+	   (display arg)))
+     (caddr f))
+    (printf ")")))
+
+(with-output-to-file "gh.h"
+  (lambda ()
+    (with-input-from-file "ghbase.h"
+      (lambda ()
+	(let loop ()
+	  (let ([v (read-line)])
+	    (unless (eof-object? v) (display v) (newline) (loop))))))
+    (for-each
+     (lambda (f)
+       (write-proto f)
+       (printf ";~n"))
+     GUILE_HIGH_LEVEL))
+  'replace)
+
+(define (write-body b)
+  (cond
+   [(pair? b)
+    (case (car b)
+      [begin (display "(")
+	     (write-body (cadr b))
+	     (for-each (lambda (e)
+			 (printf ", ")
+			 (write-body e))
+		       (cddr b))
+	     (display ")")]
+      [begin-with
+       (printf "~s ~s;~n" (caadr b) (cadadr b))
+       (write-body (cons 'begin (cddr b)))]
+      [= (write-bin " = " b)]
+      [>= (write-bin " >= " b)]
+      [+ (write-bin " + " b)]
+      [@ (write-body (cadr b))
+	 (display "[")
+	 (write-body (caddr b))
+	 (display "]")]
+      [if (display "if (")
+	  (write-body (cadr b))
+	 (display ") { ")
+	 (write-body (caddr b))
+	 (display "; } {")
+	 (write-body (cadddr b))
+	 (display "; }")]
+      [? (write-body (cadr b))
+	 (display " ? ")
+	 (write-body (caddr b))
+	 (display " : ")
+	 (write-body (cadddr b))]
+      [void (void)]
+      [else (write-body (car b))
+	    (display "(")
+	    (unless (null? (cdr b))
+		    (write-body (cadr b))
+		    (for-each
+		     (lambda (e)
+		       (display ", ")
+		       (write-body e))
+		     (cddr b)))
+	    (display ")")])]
+   [else (display b)]))
+
+(define (write-bin str b)
+  (write-body (cadr b))
+  (display str)
+  (write-body (caddr b)))
+
+(with-output-to-file "guileinc.c"
+  (lambda ()
+    (for-each
+     (lambda (f)
+       (unless (null? (cdddr f))
+	       (write-proto f)
+	       (printf "~n{~n  ")
+	       (unless (eq? (car f) 'void)
+		       (display "return "))
+	       (write-body (cadddr f))
+	       (printf ";~n}~n~n")))
+     GUILE_HIGH_LEVEL))
+  'replace)
+
+(define MAX-DIRECT-ARGS 10)
+
+(with-output-to-file "wrap.inc"
+  (lambda ()
+    (let loop ([n 0])
+      (printf "  case ~s:~n    return f(" n)
+      (let loop ([i 0])
+	(unless (= i n)
+		(printf "argv[~s], " i)
+		(loop (add1 i))))
+      (printf "rest);~n")
+      (unless (= n MAX-DIRECT-ARGS)
+	      (loop (add1 n)))))
+  'replace)
diff --git a/src/mzscheme/guile/test.c b/src/mzscheme/guile/test.c
new file mode 100644
index 0000000..675fed7
--- /dev/null
+++ b/src/mzscheme/guile/test.c
@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <math.h>
+
+#include "gh.h"
+
+SCM c_factorial(SCM s_n);
+SCM c_sin(SCM s_x);
+SCM c_vector_test(SCM s_length);
+
+void real_main(int argc, char *argv[])
+{
+  int done;
+  char input_str[1000];
+     
+  gh_eval_str("(display \"hello guile\n\")");
+     
+  gh_eval_str("(define (square x) (* x x))");
+  gh_eval_str("(define (factorial n) (if (= n 1) 1 (* n (factorial (- n 1)))))");
+     
+  gh_eval_str("(square 9)");
+  gh_eval_str("(factorial 100)");
+     
+  /* now define some new primitives in C */
+  gh_new_procedure("c_factorial", c_factorial, 1, 0, 0);
+  gh_new_procedure("c_sin", c_sin, 1, 0, 0);
+  gh_new_procedure("c_vector_test", c_vector_test, 1, 0, 0);
+     
+  /* now sit in a Scheme eval loop: I input the expressions, have guile
+   * evaluate them, and then get another expression.
+   */
+  done = 0;
+  while (!done) {
+    if (gets(input_str) == NULL || strcmp(input_str, "(quit)") == 0) {
+      done = 1;
+    } else {
+      gh_eval_str(input_str);
+    }
+  }
+}
+
+int main(int argc, char *argv[])
+{
+  gh_enter(argc, argv, real_main);
+
+  return 0;
+}
+
+SCM c_factorial(SCM s_n)
+{
+  int i, n;
+  unsigned long result = 1;
+     
+  n = gh_scm2ulong(s_n);
+     
+  for (i = 1; i <= n; ++i) {
+    result = result*i;
+  }
+  return gh_ulong2scm(result);
+}
+
+/* a sin routine in C, callable from Scheme.  it is named c_sin()
+ * to distinguish it from the default Scheme sin function
+ */
+SCM c_sin(SCM s_x)
+{
+  double x = gh_scm2double(s_x);
+     
+  return gh_double2scm(sin(x));
+}
+
+/* play around with vectors in guile: this routine creates a
+ * vector of the given length, initializes it all to zero except
+ * element 2 which is set to 1.9.
+ */
+SCM c_vector_test(SCM s_length)
+{
+  SCM xvec;
+  unsigned long c_length;
+     
+  c_length = gh_scm2ulong(s_length);
+  printf("requested length for vector: %ld\n", c_length);
+     
+  /* create a vector filled witth 0.0 entries */
+  xvec = gh_vector(c_length, gh_double2scm(0.0));
+  /* set the second element in it to some floating point value */
+  gh_vset(xvec, 2, gh_double2scm(1.9));
+     
+  return xvec;
+}
diff --git a/src/mzscheme/guile/wrap.inc b/src/mzscheme/guile/wrap.inc
new file mode 100644
index 0000000..526048b
--- /dev/null
+++ b/src/mzscheme/guile/wrap.inc
@@ -0,0 +1,22 @@
+  case 0:
+    return f(rest);
+  case 1:
+    return f(argv[0], rest);
+  case 2:
+    return f(argv[0], argv[1], rest);
+  case 3:
+    return f(argv[0], argv[1], argv[2], rest);
+  case 4:
+    return f(argv[0], argv[1], argv[2], argv[3], rest);
+  case 5:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], rest);
+  case 6:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], rest);
+  case 7:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], rest);
+  case 8:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], rest);
+  case 9:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], rest);
+  case 10:
+    return f(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], rest);
diff --git a/src/mzscheme/ifaix b/src/mzscheme/ifaix
new file mode 100755
index 0000000..db94fe7
--- /dev/null
+++ b/src/mzscheme/ifaix
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+if [ `uname -s` = "AIX" ] ; then
+  exec "$@"
+else
+  exit 0
+fi
diff --git a/src/mzscheme/ifnotaix b/src/mzscheme/ifnotaix
new file mode 100755
index 0000000..2b593c9
--- /dev/null
+++ b/src/mzscheme/ifnotaix
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+if [ `uname -s` != "AIX" ] ; then
+  exec "$@"
+else
+  exit 0
+fi
diff --git a/src/mzscheme/include/escheme.h b/src/mzscheme/include/escheme.h
new file mode 100644
index 0000000..f0c442a
--- /dev/null
+++ b/src/mzscheme/include/escheme.h
@@ -0,0 +1,34 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* This file should be included by MzScheme dynamically-loaded
+   extenstion files */
+
+#ifndef E_SCHEME_H
+#define E_SCHEME_H
+
+#define SCHEME_DIRECT_EMBEDDED 0
+
+#include "scheme.h"
+
+#ifdef CODEFRAGMENT_DYNAMIC_LOAD
+#pragma export on
+#endif
+
+extern Scheme_Object *scheme_initialize(Scheme_Env *global_env);
+
+#ifdef CODEFRAGMENT_DYNAMIC_LOAD
+#pragma export off
+#endif
+
+#endif /* ! E_SCHEME_H */
+
diff --git a/src/mzscheme/include/ext.exp b/src/mzscheme/include/ext.exp
new file mode 100644
index 0000000..9a09e43
--- /dev/null
+++ b/src/mzscheme/include/ext.exp
@@ -0,0 +1,4 @@
+#!
+scheme_initialize_internal
+scheme_initialize
+scheme_reload
diff --git a/src/mzscheme/include/mzscheme.exp b/src/mzscheme/include/mzscheme.exp
new file mode 100644
index 0000000..f76967f
--- /dev/null
+++ b/src/mzscheme/include/mzscheme.exp
@@ -0,0 +1,289 @@
+#!
+scheme_init_jmpup_buf
+scheme_setjmpup_relative
+scheme_longjmpup
+scheme_setjmp
+scheme_longjmp
+scheme_make_config
+scheme_branch_config
+scheme_new_param
+scheme_param_config
+scheme_register_parameter
+scheme_get_env
+scheme_current_process
+scheme_fuel_counter
+scheme_current_process_ptr
+scheme_fuel_counter_ptr
+scheme_make_namespace
+scheme_thread
+scheme_break_thread
+scheme_kill_thread
+scheme_process_block
+scheme_swap_process
+scheme_block_until
+scheme_in_main_thread
+scheme_tls_allocate
+scheme_tls_set
+scheme_tls_get
+scheme_add_namespace_option
+scheme_make_manager
+scheme_add_managed
+scheme_remove_managed
+scheme_close_managed
+scheme_signal_error
+scheme_raise_exn
+scheme_warning
+scheme_wrong_count
+scheme_case_lambda_wrong_count
+scheme_wrong_type
+scheme_wrong_return_arity
+scheme_unbound_global
+scheme_dynamic_wind
+scheme_make_type
+scheme_install_type_reader
+scheme_install_type_writer
+scheme_eof
+scheme_null
+scheme_true
+scheme_false
+scheme_void
+scheme_undefined
+scheme_tail_call_waiting
+scheme_multiple_values
+scheme_eval
+scheme_eval_multi
+scheme_eval_compiled
+scheme_eval_compiled_multi
+_scheme_eval_compiled
+_scheme_eval_compiled_multi
+scheme_apply
+scheme_apply_multi
+scheme_apply_to_list
+scheme_eval_string
+scheme_eval_string_all
+_scheme_apply_known_closed_prim
+_scheme_apply_known_closed_prim_multi
+scheme_values
+scheme_check_one_value
+scheme_tail_apply
+scheme_tail_apply_no_copy
+scheme_tail_apply_to_list
+scheme_tail_eval_expr
+scheme_set_tail_buffer_size
+scheme_force_value
+scheme_do_eval
+GC_malloc
+GC_malloc_atomic
+GC_malloc_stubborn
+GC_malloc_uncollectable
+scheme_malloc_eternal
+scheme_end_stubborn_change
+scheme_calloc
+scheme_strdup
+scheme_strdup_eternal
+scheme_malloc_fail_ok
+scheme_weak_reference
+scheme_weak_reference_indirect
+scheme_add_finalizer
+scheme_add_scheme_finalizer
+scheme_register_finalizer
+scheme_dont_gc_ptr
+scheme_gc_ptr_ok
+scheme_collect_garbage
+scheme_hash_table
+scheme_add_to_table
+scheme_change_in_table
+scheme_lookup_in_table
+scheme_bucket_from_table
+scheme_make_prim
+scheme_make_noneternal_prim
+scheme_make_closed_prim
+scheme_make_prim_w_arity
+scheme_make_folding_prim
+scheme_make_noneternal_prim_w_arity
+scheme_make_closed_prim_w_arity
+scheme_make_folding_closed_prim
+scheme_make_closure
+scheme_make_pair
+scheme_make_string
+scheme_make_sized_string
+scheme_make_string_without_copying
+scheme_alloc_string
+scheme_append_string
+scheme_make_vector
+scheme_make_integer_value
+scheme_make_integer_value_from_unsigned
+scheme_make_double
+scheme_make_float
+scheme_make_char
+scheme_make_promise
+scheme_make_promise_from_thunk
+scheme_make_sema
+scheme_post_sema
+scheme_wait_sema
+scheme_char_constants
+scheme_get_int_val
+scheme_get_unsigned_int_val
+scheme_get_proc_name
+scheme_make_bignum
+scheme_make_bignum_from_unsigned
+scheme_bignum_to_double
+scheme_bignum_from_double
+scheme_bignum_to_float
+scheme_bignum_from_float
+scheme_bignum_to_string
+scheme_read_bignum
+scheme_bignum_normalize
+scheme_double_to_int
+scheme_make_rational
+scheme_rational_to_double
+scheme_rational_from_double
+scheme_rational_to_float
+scheme_rational_from_float
+scheme_rational_normalize
+scheme_rational_numerator
+scheme_rational_denominator
+scheme_make_complex
+scheme_complex_normalize
+scheme_complex_real_part
+scheme_complex_imaginary_part
+scheme_is_exact
+scheme_is_inexact
+scheme_expand
+scheme_compile
+scheme_make_promise_value
+scheme_read
+scheme_write
+scheme_display
+scheme_write_w_max
+scheme_display_w_max
+scheme_write_string
+scheme_write_to_string
+scheme_display_to_string
+scheme_write_to_string_w_max
+scheme_display_to_string_w_max
+scheme_debug_print
+scheme_flush_output
+scheme_format
+scheme_printf
+scheme_getc
+scheme_ungetc
+scheme_char_ready
+scheme_need_wakeup
+scheme_get_chars
+scheme_tell
+scheme_output_tell
+scheme_tell_line
+scheme_close_input_port
+scheme_close_output_port
+scheme_are_all_chars_ready
+scheme_make_port_type
+scheme_make_input_port
+scheme_make_output_port
+scheme_make_file_input_port
+scheme_make_named_file_input_port
+scheme_make_file_output_port
+scheme_make_string_input_port
+scheme_make_sized_string_input_port
+scheme_make_string_output_port
+scheme_get_string_output
+scheme_get_sized_string_output
+scheme_pipe
+scheme_file_exists
+scheme_directory_exists
+scheme_expand_filename
+scheme_getcwd
+scheme_setcwd
+scheme_getdrive
+scheme_split_pathname
+scheme_build_pathname
+scheme_alloc_fdset_array
+scheme_init_fdset_array
+scheme_get_fdset
+scheme_fdzero
+scheme_fdset
+scheme_fdclr
+scheme_fdisset
+scheme_add_global
+scheme_add_global_constant
+scheme_add_global_keyword
+scheme_remove_global
+scheme_remove_global_constant
+scheme_add_global_symbol
+scheme_remove_global_symbol
+scheme_add_global_constant_symbol
+scheme_constant
+scheme_set_keyword
+scheme_make_envunbox
+scheme_lookup_global
+scheme_global_bucket
+scheme_set_global_bucket
+scheme_intern_symbol
+scheme_intern_exact_symbol
+scheme_make_symbol
+scheme_make_exact_symbol
+scheme_symbol_name
+scheme_symbol_name_and_size
+scheme_intern_type_symbol
+scheme_make_type_symbol
+scheme_make_struct_values
+scheme_make_struct_names
+scheme_make_struct_type
+scheme_make_struct_instance
+scheme_is_struct_instance
+scheme_make_class
+scheme_add_method
+scheme_add_method_w_arity
+scheme_made_class
+scheme_make_object
+scheme_make_uninited_object
+scheme_find_ivar
+scheme_is_subclass
+scheme_is_implementation
+scheme_is_interface_extension
+scheme_is_a
+scheme_get_class_name
+scheme_get_interface_name
+scheme_make_class_assembly
+scheme_create_class
+scheme_make_interface_assembly
+scheme_create_interface
+scheme_apply_generic_data
+scheme_get_generic_data
+scheme_invoke_unit
+scheme_assemble_compound_unit
+scheme_make_compound_unit
+scheme_get_unit_name
+scheme_eq
+scheme_eqv
+scheme_equal
+scheme_build_list
+scheme_list_length
+scheme_proper_list_length
+scheme_alloc_list
+scheme_map_1
+scheme_car
+scheme_cdr
+scheme_cadr
+scheme_caddr
+scheme_vector_to_list
+scheme_list_to_vector
+scheme_append
+scheme_box
+scheme_unbox
+scheme_set_box
+scheme_make_weak_box
+scheme_load
+scheme_load_extension
+scheme_register_extension_global
+scheme_get_milliseconds
+scheme_get_process_milliseconds
+scheme_rep
+scheme_banner
+scheme_version
+scheme_check_proc_arity
+scheme_secure_exceptions
+scheme_make_provided_string
+scheme_make_args_string
+scheme_no_dumps
+scheme_system_library_subpath
diff --git a/src/mzscheme/include/scheme.h b/src/mzscheme/include/scheme.h
new file mode 100644
index 0000000..7243837
--- /dev/null
+++ b/src/mzscheme/include/scheme.h
@@ -0,0 +1,1063 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#ifndef SCHEME_H
+#define SCHEME_H
+
+/* The next line is used and set during installation: */
+/*III*/
+
+#ifdef INCLUDE_WITHOUT_PATHS
+# include "sconfig.h"
+#else
+# include "../sconfig.h"
+#endif
+
+#define AGRESSIVE_ZERO_FOR_GC
+#define AGRESSIVE_ZERO_TB
+
+#if SGC_STD_DEBUGGING
+# ifndef USE_SENORA_GC
+#  define USE_SENORA_GC
+# endif
+# define USE_MEMORY_TRACING 
+#endif
+
+#ifdef USE_SENORA_GC
+# define MUST_REGISTER_GLOBALS
+# undef UNIX_IMAGE_DUMPS
+#endif
+
+#ifdef USE_SINGLE_FLOATS
+# define MZ_USE_SINGLE_FLOATS
+#endif
+
+#include <stdio.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef SCHEME_DIRECT_EMBEDDED
+#define SCHEME_DIRECT_EMBEDDED 1
+#endif
+
+#ifndef MSC_IZE
+# define MSC_IZE(x) x
+#endif
+
+#ifdef SIGSET_IS_SIGNAL
+# define MZ_SIGSET(s, f) signal(s, f)
+#else
+# define MZ_SIGSET(s, f) sigset(s, f)
+#endif
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+typedef short Scheme_Type;
+
+typedef struct Scheme_Bucket
+{
+  Scheme_Type type;
+  void *val;
+  char *key;
+} Scheme_Bucket;
+
+typedef struct Scheme_Hash_Table
+{
+  Scheme_Type type;
+  int size, count, step;
+  Scheme_Bucket **buckets;
+  char has_constants, forever, weak;
+  void (*make_hash_indices)(void *v, int *h1, int *h2);
+  int (*compare)(void *v1, void *v2);
+#ifdef MZ_REAL_THREADS
+  void *mutex;
+#endif
+} Scheme_Hash_Table;
+
+/* Hash tablekey types, used with scheme_hash_table */
+enum {
+  SCHEME_hash_string,
+  SCHEME_hash_ptr,
+  SCHEME_hash_weak_ptr
+};
+
+typedef struct Scheme_Env
+{
+  Scheme_Type type; /* scheme_namespace_type */
+  Scheme_Hash_Table *globals;
+  Scheme_Hash_Table *loaded_libraries;
+  struct Scheme_Object *nonempty_cond; /* hack used when !scheme_allow_cond_auto_else */
+  struct Scheme_Comp_Env *init; /* initial compilation environment */
+} Scheme_Env;
+
+typedef struct Scheme_Object *
+(Scheme_Prim)(int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object *
+(Scheme_Closed_Prim)(void *d, int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object *
+(Scheme_Method_Prim)(struct Scheme_Object *o, 
+		     int argc, struct Scheme_Object *argv[]);
+
+typedef struct Scheme_Object
+{
+  Scheme_Type type; /* Anything that starts with a type field
+		       can be a Scheme_Object */
+  union
+    {
+      struct { char *string_val; int tag_val; } str_val;
+      struct { void *ptr1, *ptr2; } two_ptr_val;
+      struct { int int1; int int2; } two_int_val;
+      struct { void *ptr; int pint; } ptr_int_val;
+      struct { void *ptr; long pint; } ptr_long_val;
+      struct {
+	Scheme_Closed_Prim *f;
+	void *d; } clsd_prim_val;
+      struct { struct Scheme_Object *car, *cdr; } pair_val;
+      struct { struct Scheme_Env *env; struct Scheme_Object *code; } closure_val;
+      struct { short len; short *vec; } svector_val;
+      struct Scheme_Debugging_Info *debug_val;
+    } u;
+} Scheme_Object;
+
+typedef struct {
+  Scheme_Type type;
+  union {
+    char char_val;
+    Scheme_Object *ptr_value;
+    long int_val;
+    Scheme_Object *ptr_val;
+    Scheme_Prim *prim_val;
+  } u;
+} Scheme_Small_Object;  
+
+typedef struct {
+  Scheme_Type type;
+  double double_val;
+} Scheme_Double;
+
+#ifdef MZ_USE_SINGLE_FLOATS
+typedef struct {
+  Scheme_Type type;
+  float float_val;
+} Scheme_Float;
+#endif
+
+#define SCHEME_PRIM_IS_FOLDING 1
+#define SCHEME_PRIM_IS_PRIMITIVE 2
+#define SCHEME_PRIM_IS_STRUCT_PROC 4
+#define SCHEME_PRIM_IS_STRUCT_SETTER 8
+#define SCHEME_PRIM_IS_PARAMETER 16
+#define SCHEME_PRIM_IS_STRUCT_GETTER 32
+#define SCHEME_PRIM_IS_STRUCT_PRED 64
+#define SCHEME_PRIM_IS_STRUCT_CONSTR 128
+#define SCHEME_PRIM_IS_MULTI_RESULT 256
+#define SCHEME_PRIM_IS_GENERIC 512
+#define SCHEME_PRIM_IS_USER_PARAMETER 1024
+
+typedef struct {
+  Scheme_Type type;
+  short flags; /* keep flags at same place as in closed */
+  Scheme_Prim *prim_val;
+  const char *name;
+  short mina, maxa;
+} Scheme_Primitive_Proc;
+
+typedef struct {
+  Scheme_Primitive_Proc p;
+  short minr, maxr;
+} Scheme_Prim_W_Result_Arity;
+
+typedef struct {
+  Scheme_Type type;
+  short flags; /* keep flags at same place as in unclosed */
+  Scheme_Closed_Prim *prim_val;
+  void *data;
+  const char *name;
+  short mina, maxa; /* mina == -2 => maxa is negated case count and
+		       record is a Scheme_Closed_Case_Primitive_Proc */
+} Scheme_Closed_Primitive_Proc;
+
+typedef struct {
+  Scheme_Closed_Primitive_Proc p;
+  short minr, maxr;
+} Scheme_Closed_Prim_W_Result_Arity;
+
+typedef struct {
+  Scheme_Closed_Primitive_Proc p;
+  short *cases;
+} Scheme_Closed_Case_Primitive_Proc;
+
+#define _scheme_fill_prim_closure(rec, cfunc, dt, nm, amin, amax) \
+  ((rec)->type = scheme_closed_prim_type, \
+   (rec)->prim_val = cfunc, \
+   (rec)->data = (void *)(dt), \
+   (rec)->name = nm, \
+   (rec)->mina = amin, \
+   (rec)->maxa = amax, \
+   rec)
+   
+#define _scheme_fill_prim_case_closure(rec, cfunc, dt, nm, ccount, cses) \
+  ((rec)->p.type = scheme_closed_prim_type, \
+   (rec)->p.prim_val = cfunc, \
+   (rec)->p.data = (void *)(dt), \
+   (rec)->p.name = nm, \
+   (rec)->p.mina = -2, \
+   (rec)->p.maxa = -(ccount), \
+   (rec)->cases = cses, \
+   rec)
+
+typedef struct Scheme_Debugging_Info {
+  Scheme_Object *src;
+} Scheme_Debugging_Info;
+
+typedef struct Scheme_Sema {
+  Scheme_Type type;
+#ifdef MZ_REAL_THREADS
+  void *sema;
+#else
+  long value;  
+#endif
+} Scheme_Sema;
+
+typedef struct Scheme_Symbol {
+  Scheme_Type type;
+  short len;
+  char s[1];
+} Scheme_Symbol;
+
+typedef struct Scheme_Vector {
+  Scheme_Type type;
+  int size;
+  Scheme_Object *els[1];
+} Scheme_Vector;
+
+typedef void Scheme_Close_Manager_Client(Scheme_Object *o, void *data);
+typedef struct Scheme_Manager *Scheme_Manager_Reference;
+
+typedef struct Scheme_Manager {
+  Scheme_Type type;
+  short count, alloc;
+  Scheme_Object ***boxes;
+  Scheme_Manager_Reference **mrefs;
+  Scheme_Close_Manager_Client **closers;
+  void **data;
+
+  /* atomic indirections: */
+  struct Scheme_Manager **parent;
+  struct Scheme_Manager **sibling;
+  struct Scheme_Manager **children;
+} Scheme_Manager;
+
+typedef struct Scheme_Input_Port
+{
+  Scheme_Type type;
+  short closed;
+  Scheme_Object *sub_type;
+  Scheme_Manager_Reference *mref;
+  void *port_data;
+  int (*getc_fun) (struct Scheme_Input_Port *port);
+  int (*char_ready_fun) (struct Scheme_Input_Port *port);
+  void (*close_fun) (struct Scheme_Input_Port *port);
+  void (*need_wakeup_fun)(struct Scheme_Input_Port *, void *);
+  Scheme_Object *read_handler;
+  char *name;
+  char *ungotten;
+  int ungotten_count, ungotten_allocated;
+  long position, lineNumber, charsSinceNewline;
+  int eoffound;
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *sema;
+#endif
+} Scheme_Input_Port;
+
+typedef struct Scheme_Output_Port
+{
+  Scheme_Type type;
+  short closed;
+  Scheme_Object *sub_type;
+  Scheme_Manager_Reference *mref;
+  void *port_data;
+  void (*write_string_fun)(char *str, long len, struct Scheme_Output_Port *);
+  void (*close_fun) (struct Scheme_Output_Port *);
+  long pos;
+  Scheme_Object *display_handler;
+  Scheme_Object *write_handler;
+  Scheme_Object *print_handler;
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *sema;
+#endif
+} Scheme_Output_Port;
+
+typedef struct {
+  Scheme_Type type;
+  struct Scheme_Object *sclass;
+  /* The following fields are only here for instances of classes
+     created with scheme_make_class(): */
+  void *primdata;
+  short primflag;
+  short inited;
+} Scheme_Class_Object;
+
+typedef struct Scheme_Unit {
+  Scheme_Type type;        /* scheme_unit_type */
+  short num_imports;       /* num expected import args */
+  short num_exports;       /* num exported vars */
+  Scheme_Object **exports; /* names of exported */
+  Scheme_Object **export_debug_names; /* internal names; NULL => no debugging */
+  Scheme_Object *(*init_func)(Scheme_Object **boxes, Scheme_Object **anchors,
+			      struct Scheme_Unit *m,
+			      void *debug_request);
+  Scheme_Object *data;
+} Scheme_Unit;
+
+typedef void Scheme_Instance_Init_Proc(Scheme_Object **init_boxes,
+				       Scheme_Object **extract_boxes,
+				       Scheme_Object *super_init,
+				       int argc,
+				       Scheme_Object **argv,
+				       Scheme_Object *instance,
+				       void *data);
+
+/* Like setjmp & longjmp, but you can jmp to a deeper stack position */
+/* Intialize a Scheme_Jumpup_Buf record before using it */
+typedef struct Scheme_Jumpup_Buf {
+  void *stack_from, *stack_copy;
+  long stack_size, stack_max_size;
+  struct Scheme_Jumpup_Buf *cont;
+  jmp_buf buf;
+} Scheme_Jumpup_Buf;
+
+enum {
+  MZCONFIG_ENV,
+  MZCONFIG_INPUT_PORT,
+  MZCONFIG_OUTPUT_PORT,
+  MZCONFIG_ERROR_PORT,
+
+  MZCONFIG_USER_BREAK_POLL_HANDLER,
+  MZCONFIG_ENABLE_BREAK,
+  MZCONFIG_ENABLE_EXCEPTION_BREAK,
+
+  MZCONFIG_ERROR_DISPLAY_HANDLER,
+  MZCONFIG_ERROR_PRINT_VALUE_HANDLER,
+
+  MZCONFIG_EXIT_HANDLER,
+
+  MZCONFIG_EXN_HANDLER,
+  MZCONFIG_DEBUG_INFO_HANDLER,
+
+  MZCONFIG_EVAL_HANDLER,
+  MZCONFIG_LOAD_HANDLER,
+
+  MZCONFIG_PRINT_HANDLER,
+  MZCONFIG_PROMPT_READ_HANDLER,
+
+  MZCONFIG_CAN_READ_GRAPH,
+  MZCONFIG_CAN_READ_COMPILED,
+  MZCONFIG_CAN_READ_BOX,
+  MZCONFIG_CAN_READ_TYPE_SYMBOL,
+  MZCONFIG_CAN_READ_PIPE_QUOTE,
+
+  MZCONFIG_PRINT_GRAPH,
+  MZCONFIG_PRINT_STRUCT,
+  MZCONFIG_PRINT_BOX,
+
+  MZCONFIG_CASE_SENS,
+  MZCONFIG_SQUARE_BRACKETS_ARE_PARENS,
+  MZCONFIG_CURLY_BRACES_ARE_PARENS,
+
+  MZCONFIG_ERROR_PRINT_WIDTH,
+
+  MZCONFIG_CONFIG_BRANCH_HANDLER,
+
+  MZCONFIG_WILL_EXECUTOR,
+
+  MZCONFIG_ALLOW_SET_UNDEFINED,
+  MZCONFIG_COND_AUTO_ELSE,
+
+  MZCONFIG_MANAGER,
+
+  MZCONFIG_REQ_LIB_USE_COMPILED,
+
+  MZCONFIG_LOAD_DIRECTORY,
+
+  MZCONFIG_COLLECTION_PATHS,
+
+  MZCONFIG_PORT_PRINT_HANDLER,
+
+  MZCONFIG_REQUIRE_COLLECTION,
+
+  MZCONFIG_LOAD_EXTENSION_HANDLER,
+
+  __MZCONFIG_BUILTIN_COUNT__
+};
+
+
+typedef struct Scheme_Config {
+  Scheme_Type type;
+  Scheme_Hash_Table *extensions;
+
+  /* For sharing as-yet uncreated parameters: */
+  struct Scheme_Config **parent;
+  struct Scheme_Config **child;
+  struct Scheme_Config **sibling;
+
+  Scheme_Object **configs[1];
+} Scheme_Config;
+
+#define scheme_set_param(c, pos, o) (*((c)->configs[pos]) = o)
+#define scheme_get_param(c, pos) (*((c)->configs[pos]))
+
+typedef struct Scheme_Saved_Stack {
+  Scheme_Object **runstack_start;
+  Scheme_Object **runstack;
+  long runstack_size;
+  struct Scheme_Saved_Stack *prev;
+} Scheme_Saved_Stack;
+
+typedef struct Scheme_Process {
+  Scheme_Type type;
+
+  jmp_buf error_buf;
+  int jumping_to_continuation;
+
+  Scheme_Config *config;
+
+  Scheme_Object **runstack;
+  Scheme_Object **runstack_start;
+  long runstack_size;
+  Scheme_Saved_Stack *runstack_saved;
+  Scheme_Object **runstack_tmp_keep;
+
+  long engine_weight;
+
+  void *stack_start, *stack_end;
+  Scheme_Jumpup_Buf jmpup_buf;
+#if defined(USE_WIN32_THREADS) || defined(SPAWN_NEW_STACK)
+  void *stack_current;
+#ifdef NEW_STACK_VIA_THREAD
+  void *threadinfo;
+#endif
+#endif
+#ifdef USE_WIN32_THREADS
+  void *thread;
+  void *sem;
+#endif
+#ifdef MZ_REAL_THREADS
+  void *thread;
+#endif  
+
+  void *cc_start;
+  long *cc_ok;
+  struct Scheme_Dynamic_Wind *dw;
+
+  struct Scheme_Process *next;
+
+  int running;
+#ifdef ERROR_ON_OVERFLOW
+  int stack_overflow;
+#endif
+
+  float sleep_time; /* blocker has starting sleep time */
+  int block_descriptor;
+  Scheme_Object *blocker; /* semaphore or port */
+  int (*block_check)(Scheme_Object *blocker);
+  void (*block_needs_wakeup)(Scheme_Object *blocker, void *fds);
+  int ran_some;
+
+#ifndef ERROR_ON_OVERFLOW
+  struct Scheme_Overflow *overflow;
+  jmp_buf overflow_buf;
+#endif
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  short wd_inited;
+  short vrefnum;
+  long dirid;
+#else
+  char *working_directory;
+  int wd_len;
+#endif
+
+  struct Scheme_Comp_Env *current_local_env;
+
+  Scheme_Object *error_escape_proc; /* Per-thread paramaterization */
+
+  /* These are used to lock in values during `read': */
+  char quick_can_read_type_symbol;
+  char quick_can_read_compiled;
+  char quick_can_read_pipe_quote;
+  char quick_can_read_box;
+  char quick_can_read_graph;
+  char quick_case_sens;
+  char quick_square_brackets_are_parens;
+  char quick_curly_braces_are_parens;
+
+  /* Used during `display' and `write': */
+  char *print_buffer;
+  long print_position;
+  long print_allocated;
+  long print_maxlen;
+  Scheme_Object *print_port;
+  jmp_buf print_escape;
+
+  char exn_raised;
+  char error_invoked;
+  char err_val_str_invoked;
+
+#ifndef ERROR_ON_OVERFLOW
+  Scheme_Object *(*overflow_k)(void);
+  Scheme_Object *overflow_reply;
+  Scheme_Jumpup_Buf overflow_cont;
+#endif
+
+  Scheme_Object **tail_buffer;
+  int tail_buffer_size;
+
+  union {
+    struct {
+      Scheme_Object *wait_expr;
+    } eval;
+    struct {
+      Scheme_Object *tail_rator;
+      Scheme_Object **tail_rands;
+      int tail_num_rands;
+    } apply;
+    struct {
+      Scheme_Object **array;
+      int count;
+    } multiple;
+    struct {
+      void *p1, *p2, *p3, *p4;
+      long i1, i2;
+    } k;
+  } ku;
+
+  short checking_break;
+  short external_break;
+
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *done_sema;
+  long fuel_counter;
+#define scheme_fuel_counter (scheme_current_process->fuel_counter)
+#define scheme_stack_boundary ((unsigned long)scheme_current_process->stack_end)
+#endif
+
+  Scheme_Object *list_stack;
+  int list_stack_pos;
+
+  long block_start_sleep;
+
+#ifdef AGRESSIVE_ZERO_TB
+  int tail_buffer_set;
+#endif
+
+  void (*on_kill)(struct Scheme_Process *p);
+  void *kill_data;
+
+  void **user_tls;
+  int user_tls_size;
+
+  Scheme_Manager_Reference *mref;
+} Scheme_Process;
+
+/* Type readers & writers for compiled code data */
+typedef Scheme_Object *(*Scheme_Type_Reader)(Scheme_Object *list);
+typedef Scheme_Object *(*Scheme_Type_Writer)(Scheme_Object *obj);
+
+/* This file defines all the built-in types */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "stypes.h"
+#else
+#include "../src/stypes.h"
+#endif
+
+/* This file includes the MZEXN constants */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schexn.h"
+#else
+#include "../src/schexn.h"
+#endif
+
+#if defined(USE_FAR_MZ_FDCALLS) || defined(DETECT_WIN32_CONSOLE_STDIN) || defined(WINDOWS_PROCESSES)
+# define MZ_GET_FDSET(p, n) scheme_get_fdset(p, n)
+#else
+# define MZ_GET_FDSET(p, n) ((void *)(((fd_set *)p) + n))
+#endif
+
+#ifdef USE_FAR_MZ_FDCALLS
+# define MZ_FD_ZERO(p) scheme_fdzero(p)
+# define MZ_FD_SET(n, p) scheme_fdset(p, n)
+# define MZ_FD_CLR(n, p) scheme_fdclr(p, n)
+# define MZ_FD_ISSET(n, p) scheme_fdisset(p, n)
+#else
+# define MZ_FD_ZERO(p) FD_ZERO(p)
+# define MZ_FD_SET(n, p) FD_SET(n, p)
+# define MZ_FD_CLR(n, p) FD_CLR(n, p)
+# define MZ_FD_ISSET(n, p) FD_ISSET(n, p)
+#endif
+
+/* Exploit the fact that these should never be dereferenced: */
+#ifndef FIRST_TWO_BYTES_ARE_LEGAL_ADDRESSES
+# define MZ_EVAL_WAITING_CONSTANT ((Scheme_Object *)0x2)
+# define MZ_APPLY_WAITING_CONSTANT ((Scheme_Object *)0x4)
+# define MZ_MULTIPLE_VALUES_CONSTANT ((Scheme_Object *)0x6)
+#endif
+
+#ifdef MZ_EVAL_WAITING_CONSTANT
+# define SCHEME_EVAL_WAITING MZ_EVAL_WAITING_CONSTANT
+# define SCHEME_TAIL_CALL_WAITING MZ_APPLY_WAITING_CONSTANT
+# define SCHEME_MULTIPLE_VALUES MZ_MULTIPLE_VALUES_CONSTANT
+#else
+# define SCHEME_TAIL_CALL_WAITING scheme_tail_call_waiting
+# define SCHEME_EVAL_WAITING scheme_eval_waiting
+# define SCHEME_MULTIPLE_VALUES scheme_multiple_values
+#endif
+
+#define FAST_NUMBERS /* Force fast numbers */
+
+/* Value-access macros */
+#ifdef FAST_NUMBERS
+#define SCHEME_TYPE(obj)     (SCHEME_INTP(obj)?(Scheme_Type)scheme_integer_type:(obj)->type)
+#define _SCHEME_TYPE(obj) ((obj)->type) /* unsafe version */
+#else
+#define SCHEME_TYPE(obj)     ((obj)->type)
+#define _SCHEME_TYPE SCHEME_TYPE
+#endif
+
+
+#define SCHEME_CHAR_VAL(obj) (((Scheme_Small_Object *)(obj))->u.char_val)
+#ifdef FAST_NUMBERS
+#define SCHEME_INT_VAL(obj)  (((long)(obj))>>1)
+#else
+#define SCHEME_INT_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.int_val)
+#endif
+#define SCHEME_DBL_VAL(obj)  (((Scheme_Double *)(obj))->double_val)
+#ifdef MZ_USE_SINGLE_FLOATS
+# define SCHEME_FLT_VAL(obj)  (((Scheme_Float *)(obj))->float_val)
+# define SCHEME_FLOAT_VAL(obj) (SCHEME_DBLP(obj) ? SCHEME_DBL_VAL(obj) : SCHEME_FLT_VAL(obj))
+#else
+# define SCHEME_FLT_VAL SCHEME_DBL_VAL
+# define SCHEME_FLOAT_VAL SCHEME_DBL_VAL
+#endif
+#define SCHEME_STR_VAL(obj)  ((obj)->u.str_val.string_val)
+#define SCHEME_STRTAG_VAL(obj)  ((obj)->u.str_val.tag_val)
+#define SCHEME_STRLEN_VAL(obj)  ((obj)->u.str_val.tag_val)
+#define SCHEME_SYM_VAL(obj)  (((Scheme_Symbol *)(obj))->s)
+#define SCHEME_SYM_LEN(obj)  (((Scheme_Symbol *)(obj))->len)
+#define SCHEME_TSYM_VAL(obj)  (SCHEME_SYM_VAL(SCHEME_PTR_VAL(obj)))
+#define SCHEME_BOX_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.ptr_val)
+#define SCHEME_PTR_VAL(obj)  (((Scheme_Small_Object *)(obj))->u.ptr_val)
+#define SCHEME_PTR1_VAL(obj) ((obj)->u.two_ptr_val.ptr1)
+#define SCHEME_PTR2_VAL(obj) ((obj)->u.two_ptr_val.ptr2)
+#define SCHEME_IPTR_VAL(obj) ((obj)->u.ptr_int_val.ptr)
+#define SCHEME_LPTR_VAL(obj) ((obj)->u.ptr_long_val.ptr)
+#define SCHEME_INT1_VAL(obj) ((obj)->u.two_int_val.int1)
+#define SCHEME_INT2_VAL(obj) ((obj)->u.two_int_val.int2)
+#define SCHEME_PINT_VAL(obj) ((obj)->u.ptr_int_val.pint)
+#define SCHEME_PLONG_VAL(obj) ((obj)->u.ptr_long_val.pint)
+#define SCHEME_PRIM(obj)     (((Scheme_Primitive_Proc *)(obj))->prim_val)
+#define SCHEME_CLSD_PRIM(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->prim_val)
+#define SCHEME_CLSD_PRIM_DATA(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->data)
+#define SCHEME_CAR(obj)      ((obj)->u.pair_val.car)
+#define SCHEME_CDR(obj)      ((obj)->u.pair_val.cdr)
+#define SCHEME_VEC_SIZE(obj) (((Scheme_Vector *)(obj))->size)
+#define SCHEME_VEC_ELS(obj)  (((Scheme_Vector *)(obj))->els)
+#define SCHEME_VEC_BASE   SCHEME_VEC_ELS
+#define SCHEME_CLOS_ENV(obj) ((obj)->u.closure_val.env)
+#define SCHEME_CLOS_CODE(obj) ((obj)->u.closure_val.code)
+#define SCHEME_DEBUG(obj)    ((obj)->u.debug_val)
+#define SCHEME_OBJ_CLASS(obj) ((Scheme_Object *)((Scheme_Class_Object *)(obj))->sclass)
+#define SCHEME_OBJ_DATA(obj)  (((Scheme_Class_Object *)(obj))->primdata)
+#define SCHEME_OBJ_FLAG(obj)  (((Scheme_Class_Object *)(obj))->primflag)
+#define SCHEME_INPORT_VAL(obj) (((Scheme_Input_Port)(obj))->port_data)
+#define SCHEME_OUTPORT_VAL(obj) (((Scheme_Output_Port)(obj))->port_data)
+#define SCHEME_VAR_BUCKET(obj) ((Scheme_Bucket *)(obj))
+#define SCHEME_ENVBOX_VAL(obj)  (*((Scheme_Object **)(obj)))
+
+#define SCHEME_ASSERT(expr,msg) ((expr) ? 1 : (scheme_signal_error(msg), 0))
+
+#if !SCHEME_DIRECT_EMBEDDED
+#ifdef MZ_REAL_THREADS
+#define scheme_current_process (scheme_get_current_process())
+#else
+#ifdef LINK_EXTENSIONS_BY_TABLE
+#define scheme_current_process (*scheme_current_process_ptr)
+#endif
+#endif
+#endif
+
+#define scheme_eval_wait_expr (scheme_current_process->ku.eval.wait_expr)
+#define scheme_tail_rator (scheme_current_process->ku.apply.tail_rator)
+#define scheme_tail_num_rands (scheme_current_process->ku.apply.tail_num_rands)
+#define scheme_tail_rands (scheme_current_process->ku.apply.tail_rands)
+#define scheme_overflow_k (scheme_current_process->overflow_k)
+#define scheme_overflow_reply (scheme_current_process->overflow_reply)
+#define scheme_overflow_cont (scheme_current_process->overflow_cont)
+
+#define scheme_error_buf (scheme_current_process->error_buf)
+#define scheme_jumping_to_continuation (scheme_current_process->jumping_to_continuation)
+#define scheme_config (scheme_current_process->config)
+
+#define scheme_multiple_count (scheme_current_process->ku.multiple.count)
+#define scheme_multiple_array (scheme_current_process->ku.multiple.array)
+
+#define scheme_setjmpup(b, s) scheme_setjmpup_relative(b, s, NULL)
+
+#ifdef MZ_REAL_THREADS
+#define scheme_do_eval(r,n,e,f) scheme_do_eval_w_process(r,n,e,f,scheme_current_process)
+#else
+#define scheme_do_eval_w_process(r,n,e,f,p) scheme_do_eval(r,n,e,f)
+#endif
+#ifdef MZ_REAL_THREADS
+#define scheme_apply(r,n,a) scheme_apply_wp(r,n,a,scheme_current_process)
+#define scheme_apply_multi(r,n,a) scheme_apply_multi_wp(r,n,a,scheme_current_process)
+#else
+#define scheme_apply_wp(r,n,a,p) scheme_apply(r,n,a)
+#define scheme_apply_multi_wp(r,n,a,p) scheme_apply_multi(r,n,a)
+#endif
+
+#define _scheme_apply(r,n,rs) scheme_do_eval(r,n,rs,1)
+#define _scheme_apply_multi(r,n,rs) scheme_do_eval(r,n,rs,-1)
+#define _scheme_apply_wp(r,n,rs,p) scheme_do_eval_w_process(r,n,rs,1,p)
+#define _scheme_apply_multi_wp(r,n,rs,p) scheme_do_eval_w_process(r,n,rs,-1,p)
+#define _scheme_tail_apply scheme_tail_apply
+#define _scheme_tail_apply_wp scheme_tail_apply_wp
+
+#define _scheme_tail_eval scheme_tail_eval
+#define _scheme_tail_eval_wp scheme_tail_eval_wp
+
+#define _scheme_direct_apply_primitive_multi(prim, argc, argv) \
+    (((Scheme_Primitive_Proc *)prim)->prim_val(argc, argv))
+#define _scheme_direct_apply_primitive(prim, argc, argv) \
+    scheme_check_one_value(_scheme_direct_apply_primitive_multi(prim, argc, argv))
+#define _scheme_direct_apply_closed_primitive_multi(prim, argc, argv) \
+    (((Scheme_Closed_Primitive_Proc *)prim)->prim_val(((Scheme_Closed_Primitive_Proc *)prim)->data, argc, argv))
+#define _scheme_direct_apply_closed_primitive(prim, argc, argv) \
+    scheme_check_one_value(_scheme_direct_apply_closed_primitive_multi(prim, argc, argv))
+
+#define _scheme_force_value(v) ((v == SCHEME_TAIL_CALL_WAITING) ? scheme_force_value(v) : v)
+
+#ifdef AGRESSIVE_ZERO_TB
+#define scheme_tail_apply_buffer_wp(n, p) ((p)->tail_buffer_set = n, (p)->tail_buffer)
+#else
+#define scheme_tail_apply_buffer_wp(n, p) ((p)->tail_buffer)
+#endif
+#define scheme_tail_apply_buffer(n) scheme_tail_apply_buffer_wp(n, scheme_current_process)
+
+#define _scheme_tail_apply_no_copy_wp_tcw(f, n, args, p, tcw) (p->ku.apply.tail_rator = f, p->ku.apply.tail_rands = args, p->ku.apply.tail_num_rands = n, tcw)
+#define _scheme_tail_apply_no_copy_wp(f, n, args, p) _scheme_tail_apply_no_copy_wp_tcw(f, n, args, p, SCHEME_TAIL_CALL_WAITING)
+#define _scheme_tail_apply_no_copy(f, n, args) _scheme_tail_apply_no_copy_wp(f, n, args, scheme_current_process)
+
+#ifndef MZ_REAL_THREADS
+#define scheme_process_block_w_process(t,p) scheme_process_block(t)
+#else
+#define scheme_process_block(t) scheme_process_block_w_process(t,scheme_current_process)
+#endif
+
+#if !SCHEME_DIRECT_EMBEDDED
+#ifndef MZ_REAL_THREADS
+#ifdef LINK_EXTENSIONS_BY_TABLE
+#define scheme_fuel_counter (*scheme_fuel_counter_ptr)
+#endif
+#endif
+#endif
+
+#ifdef MZ_REAL_THREADS
+#define _scheme_check_for_break_wp(penalty, p) \
+   { if (((p)->fuel_counter -= penalty) <= 0) scheme_process_block_w_process(0, p); }
+#else
+#define _scheme_check_for_break_wp(penalty, p) \
+   { if ((scheme_fuel_counter -= penalty) <= 0) scheme_process_block_w_process(0, p); }
+#endif
+#define _scheme_check_for_break(penalty) _scheme_check_for_break_wp(penalty, scheme_current_process)
+
+#if SCHEME_DIRECT_EMBEDDED
+extern Scheme_Object *scheme_eval_waiting;
+#define scheme_tail_eval(obj) \
+ (scheme_eval_wait_expr = obj, SCHEME_EVAL_WAITING)
+#endif
+
+#define scheme_break_waiting(p) (p->external_break)
+
+/* Allocation */
+#define scheme_alloc_object() \
+   ((Scheme_Object *) scheme_malloc_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_small_object() \
+   ((Scheme_Object *) scheme_malloc_tagged(sizeof(Scheme_Small_Object)))
+#define scheme_alloc_stubborn_object() \
+   ((Scheme_Object *) scheme_malloc_stubborn_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_stubborn_small_object() \
+   ((Scheme_Object *) scheme_malloc_stubborn_tagged(sizeof(Scheme_Small_Object)))
+#define scheme_alloc_eternal_object() \
+   ((Scheme_Object *) scheme_malloc_eternal_tagged(sizeof(Scheme_Object)))
+#define scheme_alloc_eternal_small_object() \
+   ((Scheme_Object *) scheme_malloc_eternal_tagged(sizeof(Scheme_Small_Object)))
+
+#ifdef SCHEME_NO_GC
+void *scheme_malloc(size_t size);
+#define scheme_malloc_atomic scheme_malloc
+#define scheme_malloc_stubborn scheme_malloc
+#define scheme_malloc_uncollectable scheme_malloc
+#else
+#define scheme_malloc GC_malloc
+#define scheme_malloc_atomic GC_malloc_atomic
+#define scheme_malloc_stubborn GC_malloc_stubborn
+#define scheme_malloc_uncollectable GC_malloc_uncollectable
+#endif
+
+#ifdef USE_MEMORY_TRACING
+#define USE_TAGGED_ALLOCATION
+#define MEMORY_COUNTING_ON
+#endif
+
+#ifdef USE_TAGGED_ALLOCATION
+extern void *scheme_malloc_tagged(size_t);
+extern void *scheme_malloc_atomic_tagged(size_t);
+extern void *scheme_malloc_stubborn_tagged(size_t);
+extern void *scheme_malloc_eternal_tagged(size_t);
+extern void *scheme_malloc_uncollectable_tagged(size_t);
+extern void *scheme_malloc_envunbox(size_t);
+#else
+#define scheme_malloc_tagged scheme_malloc
+#define scheme_malloc_atomic_tagged scheme_malloc_atomic
+#define scheme_malloc_stubborn_tagged scheme_malloc_stubborn
+#define scheme_malloc_eternal_tagged scheme_malloc_eternal
+#define scheme_malloc_uncollectable_tagged scheme_malloc_uncollectable
+#define scheme_malloc_envunbox scheme_malloc
+#endif
+
+#ifdef FAST_NUMBERS
+#define scheme_make_integer(i) ((Scheme_Object *)((((long)i) << 1) | 0x1))
+#else
+#define scheme_make_integer scheme_make_integer_value
+#endif
+#define scheme_make_character(ch) (scheme_char_constants[(unsigned char)(ch)])
+
+#define scheme_new_frame(n) scheme_new_special_frame(n, 0)
+#define scheme_extend_env(f, e) (f->basic.next = e, f)
+#define scheme_next_frame(e) ((e)->basic.next)
+#define scheme_settable_frame(f, s) ((f)->basic.has_set_bang = (s))
+#define scheme_get_frame_settable(f) ((f)->basic.has_set_bang)
+#define scheme_get_binding(f, n) ((f)->values[n])
+
+#define SNF_FOR_TS 0x1
+#define SNF_PIPE_QUOTE 0x2
+#define SNF_NO_PIPE_QUOTE 0x4
+
+#if SCHEME_DIRECT_EMBEDDED
+
+#if defined(_IBMR2)
+extern long scheme_stackbottom;
+#endif
+
+extern int scheme_defining_primitives;
+
+/* These flags must be set before MzScheme is started: */
+extern int scheme_case_sensitive; /* Defaults to 0 */
+extern int scheme_constant_builtins; /* Defaults to 0 */
+extern int scheme_no_keywords; /* Defaults to 0 */
+extern int scheme_allow_set_undefined; /* Defaults to 0 */
+extern int scheme_escape_continuations_only; /* Defaults to 0 */
+extern int scheme_secure_primitive_exn; /* Defaults to 0 */
+extern int scheme_allow_cond_auto_else; /* Defaults to 1 */
+extern int scheme_square_brackets_are_parens; /* Defaults to 1 */
+extern int scheme_curly_braces_are_parens; /* Defaults to 1 */
+extern int scheme_hash_percent_syntax_only; /* Defaults to 0 */
+
+#ifdef MZ_REAL_THREADS
+Scheme_Process *scheme_get_current_process();
+#define scheme_current_process (SCHEME_GET_CURRENT_PROCESS())
+#else
+extern Scheme_Process *scheme_current_process;
+#endif
+extern Scheme_Process *scheme_first_process;
+
+/* Set these global hooks: */
+extern void (*scheme_exit)(int v);
+extern void (*scheme_console_printf)(char *str, ...);
+extern void (*scheme_sleep)(float seconds, void *fds);
+extern void (*scheme_notify_multithread)(int on);
+extern void (*scheme_wakeup_on_input)(void *fds);
+extern int (*scheme_check_for_break)(void);
+#ifdef USE_WIN32_THREADS
+extern void (*scheme_suspend_main_thread)(void);
+int scheme_set_in_main_thread(void);
+void scheme_restore_nonmain_thread(void);
+#endif
+#ifdef MAC_FILE_SYSTEM
+extern long scheme_creator_id;
+#endif
+extern void *(*scheme_get_sema_callback_context)(void);
+
+extern Scheme_Object *(*scheme_make_stdin)(void);
+extern Scheme_Object *(*scheme_make_stdout)(void);
+extern Scheme_Object *(*scheme_make_stderr)(void);
+
+/* Initialization */
+Scheme_Env *scheme_basic_env(void);
+
+void scheme_check_threads(void);
+void *scheme_check_sema_callbacks(int (*)(void *, void*), void *, int check_only);
+void scheme_remove_sema_callbacks(int (*)(void *, void*), void *);
+void scheme_wake_up(void);
+
+/* image dump enabling startup: */
+int scheme_image_main(int argc, char **argv);
+extern int (*scheme_actual_main)(int argc, char **argv);
+
+/* All functions & global constants prototyped here */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemef.h"
+#else
+#include "../src/schemef.h"
+#endif
+
+#else
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+/* Constants and function prototypes as function pointers in a struct: */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemex.h"
+#else
+#include "../src/schemex.h"
+#endif
+
+extern Scheme_Extension_Table *scheme_extension_table;
+
+/* Macro mapping names to record access */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemexm.h"
+#else
+#include "../src/schemexm.h"
+#endif
+
+#else
+
+/* Not LINK_EXTENSIONS_BY_TABLE */
+#ifdef INCLUDE_WITHOUT_PATHS
+#include "schemef.h"
+#else
+#include "../src/schemef.h"
+#endif
+
+#endif
+
+#endif
+
+#ifndef USE_MZ_SETJMP
+#ifdef WIN32_SETJMP_HACK    /* See comment in setjmpup.c */
+#define scheme_longjmp(b, v) \
+    { jmp_buf hack; setjmp(hack); (b)->j_excep = hack->j_excep; \
+      longjmp(b, v); }
+#else
+#define scheme_longjmp(b, v) longjmp(b, v)
+#endif
+#define scheme_setjmp(b) setjmp(b)
+#endif
+
+#define SAME_PTR(a, b) ((a) == (b))
+#define NOT_SAME_PTR(a, b) ((a) != (b))
+
+#define SCHEME_STRUCT_NO_TYPE 0x01
+#define SCHEME_STRUCT_NO_CONSTR 0x02
+#define SCHEME_STRUCT_NO_PRED 0x04
+#define SCHEME_STRUCT_NO_GET 0x08
+#define SCHEME_STRUCT_NO_SET 0x10
+
+#define SAME_OBJ SAME_PTR
+#define NOT_SAME_OBJ NOT_SAME_PTR
+
+#define SAME_TYPE(a, b) ((Scheme_Type)(a) == (Scheme_Type)(b))
+#define NOT_SAME_TYPE(a, b) ((Scheme_Type)(a) != (Scheme_Type)(b))
+
+/* convenience macros */
+#define SCHEME_CHARP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_char_type)
+#ifdef FAST_NUMBERS
+#define SCHEME_INTP(obj)     (((long)obj) & 0x1)
+#else
+#define SCHEME_INTP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_integer_type)
+#endif
+#define SCHEME_DBLP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_double_type)
+#ifdef MZ_USE_SINGLE_FLOATS
+# define SCHEME_FLTP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_float_type)
+# define SCHEME_FLOATP(obj)     (SCHEME_FLTP(obj) || SCHEME_DBLP(obj))
+#else
+# define SCHEME_FLTP SCHEME_DBLP
+# define SCHEME_FLOATP SCHEME_DBLP
+#endif
+#define SCHEME_BIGNUMP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_bignum_type)
+#define SCHEME_RATIONALP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_rational_type)
+#define SCHEME_COMPLEXP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_complex_type)
+#define SCHEME_EXACT_INTEGERP(obj)  (SCHEME_INTP(obj) || (_SCHEME_TYPE(obj) == scheme_bignum_type))
+#define SCHEME_EXACT_REALP(obj)  (SCHEME_INTP(obj) || (_SCHEME_TYPE(obj) == scheme_bignum_type) || (_SCHEME_TYPE(obj) == scheme_rational_type))
+#define SCHEME_REALP(obj)  (SCHEME_INTP(obj) || ((_SCHEME_TYPE(obj) >= scheme_bignum_type) && (_SCHEME_TYPE(obj) <= scheme_double_type)))
+#define SCHEME_NUMBERP(obj)  (SCHEME_INTP(obj) || ((_SCHEME_TYPE(obj) >= scheme_bignum_type) && (_SCHEME_TYPE(obj) <= scheme_complex_type)))
+#define SCHEME_STRINGP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_string_type)
+#define SCHEME_SYMBOLP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_symbol_type)
+#define SCHEME_TSYMBOLP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_type_symbol_type)
+#define SCHEME_BOOLP(obj)    (SAME_OBJ(obj, scheme_true) || SAME_OBJ(obj, scheme_false))
+#define SCHEME_FALSEP(obj)     SAME_OBJ((obj), scheme_false)
+#define SCHEME_TRUEP(obj)     (!SCHEME_FALSEP(obj))
+#define SCHEME_SYNTAXP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_syntax_compiler_type)
+#define SCHEME_PRIMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_prim_type)
+#define SCHEME_CLSD_PRIMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_closed_prim_type)
+#define SCHEME_CONTP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_cont_type)
+#define SCHEME_ECONTP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_escaping_cont_type)
+#define SCHEME_NULLP(obj)    SAME_OBJ(obj, scheme_null)
+#define SCHEME_PAIRP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_pair_type)
+#define SCHEME_LISTP(obj)    (SCHEME_NULLP(obj) || SCHEME_PAIRP(obj))
+#define SCHEME_BOXP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_box_type)
+#define SCHEME_HASHTP(obj) SAME_TYPE(SCHEME_TYPE(obj),scheme_hash_table_type)
+#define SCHEME_VECTORP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_vector_type)
+#define SCHEME_STRUCT_PROCP(obj) (SCHEME_CLSD_PRIMP(obj) && (((Scheme_Closed_Primitive_Proc *)obj)->flags & SCHEME_PRIM_IS_STRUCT_PROC))
+#define SCHEME_GENERICP(obj) (SCHEME_CLSD_PRIMP(obj) && (((Scheme_Closed_Primitive_Proc *)obj)->flags & SCHEME_PRIM_IS_GENERIC))
+#define SCHEME_STRUCTP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_structure_type)
+#define SCHEME_STRUCT_TYPEP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_struct_type_type)
+#define SCHEME_CLOSUREP(obj) (SAME_TYPE(SCHEME_TYPE(obj), scheme_closure_type) || SAME_TYPE(SCHEME_TYPE(obj), scheme_linked_closure_type) || SAME_TYPE(SCHEME_TYPE(obj), scheme_case_closure_type))
+#define SCHEME_PROCP(obj)    (SCHEME_PRIMP(obj) || SCHEME_CLSD_PRIMP(obj) || SCHEME_CLOSUREP(obj) || SCHEME_CONTP(obj) || SCHEME_ECONTP(obj))
+#define SCHEME_INPORTP(obj)  SAME_TYPE(SCHEME_TYPE(obj), scheme_input_port_type)
+#define SCHEME_OUTPORTP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_output_port_type)
+#define SCHEME_EOFP(obj)     SAME_OBJ((obj), scheme_eof)
+#define SCHEME_PROMP(obj)    SAME_TYPE(SCHEME_TYPE(obj), scheme_promise_type)
+#define SCHEME_DEBUGP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_debug_handle_type)
+#define SCHEME_PROCESSP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_process_type)
+#define SCHEME_MANAGERP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_manager_type)
+#define SCHEME_SEMAP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_sema_type)
+#define SCHEME_OBJP(obj)     SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)
+#define SCHEME_CLASSP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_class_type)
+#define SCHEME_INTERFACEP(obj)   SAME_TYPE(SCHEME_TYPE(obj), scheme_interface_type)
+#define SCHEME_VOIDP(obj)     SAME_OBJ((obj), scheme_void)
+#define SCHEME_DIVARP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_delayed_ivar_type)
+#define SCHEME_WEAKP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_weak_box_type)
+#define SCHEME_GENDATAP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_generic_data_type)
+#define SCHEME_UNITP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_unit_type)
+#define SCHEME_CONFIGP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_config_type)
+
+/* other */
+#define SCHEME_CADR(obj)     (SCHEME_CAR (SCHEME_CDR (obj)))
+#define SCHEME_CAAR(obj)     (SCHEME_CAR (SCHEME_CAR (obj)))
+#define SCHEME_CDDR(obj)     (SCHEME_CDR (SCHEME_CDR (obj)))
+#define SCHEME_IPORT_NAME(obj) (((Scheme_Input_Port *)obj)->name)
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* ! SCHEME_H */
+
diff --git a/src/mzscheme/mac.sit.hqx b/src/mzscheme/mac.sit.hqx
new file mode 100644
index 0000000..44dd53b
--- /dev/null
+++ b/src/mzscheme/mac.sit.hqx
@@ -0,0 +1,1242 @@
+(This file must be converted with BinHex 4.0)
+
+:"feKBbjcDA3!8dP84&0*9#%!!!!!jP-!!!&'eAY6593K!!%!!1C6FNaKG3+d!!!
+!&J)i)#!$E@&M!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!&jB!!!"(3!G!M!
+"Z`!!!"!!!!!!!!!!!!!!!!!!!!#'!!!(!2rrrrm"!+eK`+D`3&0a!!!!!!!$Rdm
+!!!!!!!$Pc3!!!!!!!!!!!!"hP3d0$N&#6e98)%eD8d0)48e&!!!!!!!!!!!!!!!
+!!!!!!!!%&!!!!!!!!!!!!!!!!!!!!!!!&J!!"JJ!!!!@rrrrre4&@&4$9dP&!3k
+[),`dVdld9`!!!CS!!!VX!!!!f3!!"$R[Fqip!!!!!!!!,f84!!JFe"b#')"*9C5
+#A#P21#*-UUbepP10YPJTR)[Q6fM9Z9X)qhX&@lG,mLF&26TiCFp3kalYNe"q*bk
+TSQkr$q%,k`,NQHbd[L9*GlVd-0-[U,@ZVBa@Vl9Y!iefSGDkqaKYMGCkUKQY5@Z
+pHMfBe0&S[fHd&Ufpq3LMVGIDpSM49KR0h&A9@Yq8l%&8m2Sj)bRmJkhLMiGB'!0
+&2$8p@E2iR5dl&FMH%G&aReR#iC`6%kbE)Jqp-VVdF%HKcRd4Ib$BeG%NIip@V4c
+ZLjNbjdViU8B,DQd5#dijH3##$'!bBZZae[$Nq)!``Qk06$KC15h##GHAX2A)86)
+&k&e2q3U3!"F(q2@6%r5M&kKZRFJLE)d2*-I)F6,K"!@F$$NC8F*AXUVRf69[G+"
+DHe9&jhG814ZPYS%@fUK!9UPDe43G"YX1)h6lkkaU9+YSiEbiPGApV+#TfbSrRC!
+!Y$@pHVfLcVZIS3FLR+H*Up@$p&lMl3e*VdLDi+K4AK9#c2Nl6A8Z"&e#)CDfHA9
+XcRTPeaPGbDLG(3Y"p0@3!'3J5Cf"A`3RqJhA@2"eAQ$l18L5NGB"eTk%XBV3`)1
+DM#kp"!CBMeqjMXQ$),'QhPRCkSV8Be3fX"D`XP%fbB)'AT5pb-Yle@cT03%BSQr
+qFf@[#j!!UFI11!h!*Qp[Vibf+ffALCJRNrE631hlMl03#1l#ZZZFMj!!ZG'5"B&
+23j9N0`B`aUk#!2m2fKJY@lTE$U(PkTQ!(r"hJ%bEQVf1F&BDCdr-MikT`h!YR$&
+ZHh"DDFaiQNiQ!Up)R6(M`AZ@&EmF0!`!cj!!%T2(%D!h42)Jq2#ATIQ@h1)$IE8
+1d@Y%!-JSGfR0p0fF!1TlADASfMU`*0X1rPbi#b$)8UN1$YBdF0EXD)UB2-BMm"0
+ih'KNl$$j"af3!$!)XFERN!!RR$Uq2Kp!(95G`(X+(!lm3`jZ39QbIZX"$AJlTpC
+)(1MmbeTq2&[l#Fd2!p@L"D[`L*E++LrM14%,k#Z`i2G3l-&1+FBka'AaRNMM*&X
+X,9*0fKfj&#4p(1mM%9%$Lf[%JjI,&NNI4UN5A)30N!"F)cEB+b3*BLZ9KQb61+"
+8)P&lh*!!3H69,fY8,i33XN6@Y@Ejd[aQX9C",,aVk9C&cdeV&FEL#rVZE[BM64*
+elh4*01MR-C%hMp-D,$Nqd#b,`iS`TL'8h$kmApZjEKAVq#3$'b)f(,k6)La(I3Y
+)ClMhd6+%!U"#CH!H!G)BL6bX`T!!fR@)c',+PbG5YifbT#2(FkEeFhdjjL[bkp!
+CF`dl%rdm3@2jZcqQ3[G(5a0rYM3%bpl(&*9p(RljEb$HE*6IaBD,NM+JFppa8SN
+p3j,lPUm[e6FlNENK)@iq9jaeB*&p"f8L'BqBb1iV$9YjlM6(Ch&h2lmC%i)N#FN
+THDQ[E+*e-9%#CrK-`!,4RY3T!%kmrp2HRJr)JjR+lI5(#4X%2*N[EEP4jM)K5iI
+1%&6N2N(VMNm@Z5@K9b$93`@XUkB3GeLIJq-B,EAUP+d$3FDh9q81mbqdM5p#NAM
+K%`feXX)GBP%dKd`9Z#1N0%a*L%DL(r-Q0LE$`NDF1ME'@-5LK3CpkX##F`0KGil
+BP0BR5Tm5SD!(6Zk6bTc[r3NSA6X!BciCMHKPl4LFPp3a*4(-9,4"Jj!!B"cph0,
+mIR+0PA"$E('$S0)VZFTY8[T5,YNIBp,jUU#hdY25Z")RTT4&#iec!K[rk[92KIJ
+I!!d0&f4jEQ9iEA"X+'0QE5YPH(3T,R"`Bbke!!!!!!!!!!$J!3!!!!!!!!!!!!!
+!!!!!!!!!KJ!!&'B!!!!@rrrrrde08&*$9dP&!3LY("[AX%"5SJ!!,dB!!!YU!!!
+*M3!!"'(@,JrR!!!!!!!!(+m0`2MV-RY,1GedXbhKhUClC3hFl0IYbYbRQa+kGC2
+0eXkHHh)UTh)kh'p-2-96222`Y(9#9Spbc@i6YYE@fq3fZ5eKj$EC4rK&YS4h4Qk
+6I@`cYa+fMqh6ff56BeG(ENYZ5rJ6hYQ!EF*+F[c)EI+EX*lF2L1FX-df2H#Vl,S
+fl6EYj'Sq@q2Cd518NpY+H'CNNdeiE12*"XDI[YIC!h!!i(`8B"Aq69[i+!!II3V
+i)6[`1khichYZ*lh*Mh([k0iDP!B#BIm+F92!+3fS+ehKX1Jkb#-+VpIAU,dmE4Y
+U11XS'SC0f2$5*6m$+1J$@&dl1MU#1IljeiK,@Zlc!&BVJ0d-i%"fGSb1RQ,FM[p
+(-3RNk%LXB)URjc%-Z$,!l$Q#De!1Tm%D`0L(0rJFGC@YPHJbBqf3!*R"92)GI(m
++mQ0*mR0pJVKCk*%ZS#L)aEZ8VB&cmB90@a99#RMmJU*)bTrM,9Ap`@lr0$bb0A%
+f-Ze$0cf,E5,IYA2jLm'%LI$2MHIEJjhQErP6aL-+RFhr'R&44brXGD&qG5D6@bY
+Yl4&lYh"lZ$aqfqNm*BM'bId+(ZC2`A'!YIF$9,d6imV!3Q#E"l8dcB-F'EP+%a9
+bppd!kdETBb(%6*l&'`S+BLM&SKP@3$lh),Cfr6e*mj,GN!"Mp`TL3j2$jr-ikZA
+JCLPb*Y(,'DkUp2RUreGfRIL[$)IpaJ!i[0lkUQbH4I9bPf0$)"b+U%6Yq4aHAhf
+Y33#10Nqe-3#[M8f08`"I`p&FdpjXFRAeLSS5"90l"43rqUeiJU+pcI5d93PqIbJ
+8G+bAr,VJ-j8G1%*[rX5pM%r#`E[%0&kEYmhK@Hea1UHV3m0KGSP1Tb%!$T0,6"2
+b+SkdcRf9eh!+b!)1D5!m8kr3+!hUpDU(*ZTellj%[IDq9Drf1)l-'+!3FIJ%446
+m5@)eAX2#T(ap!iHBBME,+`NN`Q%K($1GD"i(lcUVNdkE"A&JbDCcD$L8G*qf)!f
+95Z#PZYIkG,ZRB9E(f#P*E8E*G)I%rLb1V*(qL#L4M'LB`k(dqVZbH4EjDLkbLMM
+8IS-!('4Q&eE*IhMe85eULVZmiQEM%X@0e*l2F8Pa6q-`$&$F$99eMPNq[,kf,"p
+'(mVp!UZAP(X'ai*bRm8aTpaRHCe6lPNF,b[h1Z&f`8K!Z8ram3rP2NhXDmSpLf0
+1Z8r"H&fjCh!B"bKhXdZ4HLlA[I'(iLk[f(`qabA&I3%(Q8'!iQk6JcHmcc&38Ik
+5iLliZf*#)1R1-+qB-MJ@P-iX(h0+*iYM[T02iALpNfG`Q&bCVQG&(&MiD@QZm4U
+4&+GcZT-A%JK*L68V,I5-iSjhUKNF1,D)+bBpG&`48+I5F2MP92XFRj!!*#Z@F)5
+kF2FXLD1KUbq,)mplB5dNCQrce,FdJDYEfR44#b@RQ([hdDU0eqYCRfkrFmCQ995
+*-hbFQc'GU@JfUc)%`-&Q6&NFNc1Q0fBk9Ua@eMPR1alfUG5-D9*,Rq1$CMV'!$L
+3!!prDYC`"I&+Uh!16bJ3P[eRZP&#%BKK``!q`UQCcJ)1l)ZAqeN-aeXD1$%EbXb
+B&R!`"CG86*1cSDRk`"Q683#1Y$,0pX8*CIV[ZNrd)6A9c[jU"@ai0+1p#YQ@`"p
+fPb)$5H8eDH2++liPB!L!`q0A&-"1MRek'NFZ9P"b+KC6AM6G0`6JJdhP$3&`k&2
+j&)ljUAb1U`rC6q*iT6jL8d`jT9"-kHQMKS-fQB%@[LrA+jYL'J,8'CYL'J,J),-
+B![3K-V-K3(fJami@L'NeqR(mh`LHcqM*E[CJ[JGkSIV`LpTlZ0a8TRQqX43Xm5c
+[S8c@&G$b%p`3TJb((,$fa11QXX0hmAqX)'''GKqMRf)334eB4Ra`B+!6IIZ2aib
+3!'$Z)kDb)hX`&@krh'HM[#1dbFj[rb,KiRZZ[*UiSJM`20f1c`mPG")b@Il)RDD
+bSi[jNbGB2GaDI8-erlR+2I`,all-@'BF(%)1MYU"'cEa*`qHiNpqfiar+rk"b`F
+HDk!$NA3Z[4-kR#@D$`$,TX-GrH8)rTpe4ph4icqrVK-2+a6G-Sb3!(C#%8!V!Da
+h$phc-(4FEiAEIYm*d5FIJqLZ!AIdmrNX*RS($Vd)LBE2BAF286lhd"HHK)rqBZH
+IX+!RqXQ[[YKF-d5mk@q1VAYMIX)hCZkKrDAZSIZILH2$TIGEKSXRm1ak"MV@2B9
+[T"SM(Q+BI`Z('02&Q"84BdhCX,S,QQ3m-#%jUL6*X1AX![BC)jJLB&B#C[dZ`1N
+,#[R-MAm@Y!KbfB8&PS*&r)"83PjJbqSH8C@8e%@$'9Z(TQdG@U(pl$@"0r(%RDh
+)l$lZHL*Xa`K`(AG3N!$@BXGX$8,AH,F'""&[VVKkHj@r$+a36BbeNjq1A6D*YaJ
+M)0Zi89%&IIR"U-&+@'A(fpjBrE1c'V%'LGh`3@4,$XUU,2MP`I5*P'N6Hk@!Y0%
+I%VVr95fU&!R)38&p%ckb@B*AHFjf-UYqNXL)T-(-ff%8$Pbm$Z438,P4GdSZFC2
+S%M!*UBpAGYN-#)`EdchREX@iQ&EKaaA,48$)YT&,XBqC9M(jU#36YB(ra$N[lS9
+P[b[GML&,Z@2!Kb1iH1'!Um+Y0$hR[Y,8h(J0[Jq!*A'SblbI2I2S-G!#G,0R#IN
+qB)99Q+Z"I0Z@!Dk2F@hNLq`(R2Pa'mRhX4m",RC`*mLRfZ&f*1JkPQ-%GU2[rH6
+lq"Vi,2TZ)prfVm'Ad-Hf!PU2!'jrQR,*Yq&HH!"p,5ch3IJKqYJpU292`#2S`j`
+!0Ih`Br3pah`PF!cJA9[*YlB2IJf`l02N@r`EH"EJQR[)9hSAR%6I3I+Yq`KAJ,l
+[NfpPL&Z-[LI)pm%Gh09ifSRPkhL-Hbrk@*cUiA!CkpURbCF6jQi#@2ipmMQfF8h
+SBcRkGh%SLjDc((P@$Jm9[I[Vj#YHcQd"@-'`hKVQ2S')KmLh)m,KV((P0eQe286
+eYqTSV!3,mIpfFTLHCh(I*Cr0&`Re5D,Um-U+@+3lXC!!&@ch0MCYM39Gk49kC0(
+K%F)6kd&iBN%2e$BSVNJ%a()Aa4C,p*5k[df)"19JMl+)V3l'``YSHG36kTCZNS,
+jL895&KC$Y%LRUQC!M3L+TDCE9N-4FfdSU&UDK8L2T0SU49&#QRb#fS[a,%d"hB'
+)!E16VeT@N!"++G#&U2-64b*B(KfTYS5LFa0ckmaC2,9H6&C!*jedB13l$5aalbQ
+AA,L-br,&!0UdXb0)9&$bfh#A))ler`!,3!$V-jhd([0bd"[KH2k%N9X*Il)56LB
+XbLH%bXjVjI6iVFH8F(U%h8T'A$c&*fdpGZZ%V"k0d1G(MUeN`1h)M*-**e0+RKr
+Kj$MK+eXji66VbI1h)mF**i`FRj!!idSS*`0'MT%4*mr)J"mjIQ6#bI%9Z-Z1(UH
+FF%+jdH0VadmP)hi%#C`-16N16!$1X,SXV96+!f"d$J#"Ri$J!HUPk263QB8,$p)
+Cm4qI0I@LN5X9di1qqa$["q+FF#ee6F%H)XPbfEa%EUUL9R+kN4j%l&`9$fX+(J,
+FMheb'B1V2',a-b)B6p`GKRZ0jj-mrpqmGAfH5EUN*62LcDLQUKFc0f5Y+IUj2&c
+H,rlpa42&JR$6qCh92$)#$(U"4*JP6X4Z38`(HIRMLjh*q3NYUaIdD,QX4Gqp5Zq
+VjjLBX`@@5,f*"c"-5TEC!)Bjqd)$)q`J'lM3B0IKKSIZbr$`2RAS2Cd,dS,6,$&
+H43!Mp*lc)GrIP1qT0hkDUb0P"i8UrTj8d8P%54d#ZRXilZbh5!J0#q4I32Vh%R9
+1%ZNV4JR"RRUCr"Z2#IrFB$%DR-GIDamVQRTP@Y9d'TrI*Z@0m9GMV'UB-e1m!jH
+J2Zp0UQCf%fK4[lKiPDMCr"6[`-fTMhiGRZ$-TfH+CSiQDJ0I@rc!aDV*9#,11r!
+)V61G4dp-M#R$5LSeV0b@A,[mm8e,+qpJMk@e2AP+#YfdL46k*C8kD1-TGHU43'D
+ZU-m@b[QSpVZ[Pikm%'(9bH2T5Gk"Pe12(I)A9%dV&DHMfFeTU)@#1B[+1r!*Kcl
+X5+VDU+jQp)T"eYjfk2el88dQKdG&abmFZYq['eBJE@QY+r9R,Dfm3r-[U,il806
+[Z[LCT&)(3Hl3dC!!ec!cZ9)6LYV3THpKqFSllC)kGel0'c[8aHYMNXSl(4E9CqM
+Qf8+jLDd0eGqcY9+RdkDD'E9bjKpUb+,kRlQ$IIh6d)T&&Ch`UYCmEQT(krSdl(@
+SP9ca6iI@U9emANrH)ZTF@GmHSRV[M58jVp4"Yk@e6H4UFr"qeEV2bMa[BCj5Eb[
+`4+*F@E%6jFS+HLb(r*3SjbQkQMR8SciTUG4"Vk#kL%SjQ@Z13eejDp,@qRB$IIB
+d8(V0&VHRS@rj&8QP$[VjERcXN!#2Tr*dBCZU,"ffY5iGa[j9AbNTQePHleXdE+f
+,"JjB'd$Bf4-TbU1NHN2V[,9Ym!lY['RDP,qNKeeLMaIP%Th@"Z*8Qlcla(E!d#%
+5MU&6hS0LaKR#mVjAhV[P[9fN,d0)C"b$Aq`,$2eL'KLmBPGK#)L0J''rm*ZK6m`
+B3bqI9EThL34Lq(c6ceDk1,A[Acrrml&(j01'Rh'-ZVqKZrKH@20cGr0ebZCZk@M
+Yh8lCml5PSl8G1mAr,(CdY(CcTpbl[ZlZh8lC2e"rq,'EU%la[bpl9(kijahLadR
+FFkPihV$H+26Mi[f)CfiUBCKV!dUr2R#P*[3cMBEcL2jKA"(qKXrGr`!!!!d0&Q4
+jEQ9iEA"X+(0dC'9iG#NZF("M,V@e!!!!!!!!!!$Hl!!!!!!!!!!!!!!!!!!!!!!
+'#!!!)U!!!!!@rrrrrde08&*$9dP&!3LY("[AX%"5U`!!,dB!!!VX!!!*M3!!"$e
+FE1MX!!!!!!!!Pad0`2MVf*UC[Gac-m,2Mqk9A@HaAlFVFhYZ5ZMfb'DhG[Em0'@
+kkC!!Nfe-2-96222`l0B*@6f@*RF6YYEfh13fZ5eKj$EC4lD4,GP[j$ECacCc5`N
+VYNp[NddfZcTb@h*E`Lr#Vr-kYJNl`XRa)lI*B,1Hh#Bm`JRE(MhJUqbk0ZdflH6
+k2P[MfG%MP*2E5RKQC*00H'cMb3E'RllAf30`!1"k('!9rNhEq4J!(hX'q$i(m,Z
+Yq-ppB6HpbBpa#cYhK+5HB#5`3P%lT4jeT6X5%Gd(h6bLm2RmpGV,fl+qLV-1S@(
+BU28[@I`dJ1eh!+ZVKiB'-FFrraTaNjEc)S$9#Z!`!cL4R9e$3km`ENIq3jJ%jZP
+)V'"+T1Fa$,J5`1cc"(H[(%Q$0B#afpElR6APcHAS-Q2YN!#C`96dIAar"Qca*,B
+F[b"Z&EUN#bMbi[&ZC8I`A(aq``j&PB,HJ+!SN[,RH%[&YP"RB!)HfCS%'jRfSCZ
+Ha6kDlpUCr22"K)R`cihNfiZGjQrj8mBM#Th0raTa88-[l(AKEHT8*Sp@fYSMrQl
+LpR+jr*fRma3K'KGh!KlPAiAM!$Fr!&"a0FD9J)A!0[CUD4Tl16*b&5FVj0jl!GB
+0dFG#L*PFLbmF%X4`LN8cV!!Epc#fG[dp4[2L26$2i42%ZJDRhqpeeXUKV9,d6+,
+A-b`UprYVreGflIJ[Md3#aJ!iI,lDLQbHJPUj`lNq'!P(9D,fI!kI[lED)!"(LlI
+5')$AqSEkFB"[i@LXDQddZ6Zk48@*JDQe$1BrrYe%JX*pMI5d9`L"3$JFFYiU"A6
+"CbSjF)6Hr-Q[-$i*"qm@dhMY[KDRGlAAjCUS$Jf(f5fkA)B!1%aZ-8h)QcM51[G
+0AL-T)(-iT*l)9,e#[G5VekXHQUcAIIZ6pGVpAVdk%MJbBi"ma1%A&&%)6"+Vm4S
+4aZ6V1cM%&,0CANNJ%3i,iCMU4,-iH2GCRA6D,)J$5cDG3m1KT2Zd"@NS9i+[eEh
+@TeZpGG-kaN&*UM0+TM-XEX[Lb"VTMkJ5cBL''4a+Gk!MQkI!Ah@49F5KEM-)`%&
+QGQ19r)GA2p@LTVK,bcBBPbKZT2CmMNZ+H`+(BB$LVUZSF8lciI1hC2N`qP$Z&eL
+pT0`c11D8qc51'H8qcHZ-FXrLH&fje`Kh#%B#bRfFMhmSp`PLhe,Z@4`cbRdFaY[
++2B2$1%#jQpf+e(@jlSdr&(GTfGEc15iTlJXib!`#&(H,(,Va"QG2@HPVLM[[liS
+*JD3l`kaLbZ#B8cV6I-`SR5b1f8iqMZ2Y6Tl"BA*RZTi9F@$KTk@jaQY88PbZL8k
+H6b!N*GkXY0!cLM[4UDC`i0JLSCMdd"&&3*e+`a'3!&2YFf4#-PQaK#2FX5@&Skj
+M5aC(VZr#@NMF&RKVQaV!h5PY[UL&*UHBqrE6USh2jldehAjRM-fUU"+Rq$JhBcT
+6d@a@C3L!JmfBXMM'CNc[c(5X@+fXFdjh21a6U4R6Q*Bqa`I0G)`"F#!IJG5Xi3V
+LP9EKR0j`-#)(cR5MT#)3)iB"I%45-jdj(0JA,rHc1)lh0("b0T5C-FhKB!TZ8M'
+0cBE'k`0R6%B"10,+00XA4jAT[qXqfBI89$[lUq@aiG'8pXTR@`*rh&1-$%`UVc%
+E89k*,3&$!"cHJ+)!GR,Xda-iFV##*UGLFH9&dhe$!$lB90i3!)FqP8rKQ*h+ch0
+[3IBRFEa4(r%TTTa5++Edp&($3C[-3![IPqZ966%0!HU-66%0!A#3!&N-!IS3QGN
+3S$l3if!,a,3Dr36qE`,[jr4N'lbBlk&ZU$cmX[EZ,c@9D*l[,!&,)XX(+C0e"66
+p!MH%+F-K*pammJP6bH%[mUq@N6"$Zjr46c')S!BXJhiid011[S(MF5-NQ2Z)UH6
+)ANb&fbrhfbR[)'fbmcZr5VMiVLZA%9F8!GjR@r'j0UQ6N!$*dXIZ-C8FAFLI1XR
+Ui@190eEbAbMIblpdl1Z-CFE")H6JU!1iIK0rkZ!Vr+R[QI&[a6p`0Z#a"YS35IZ
+5Hk$09D6j!,"XfMbah`cLrhP2c"-lrU[PlAKBSA"M2d,D$B8!c35`eY0hhk23GVd
+9E[p$1m41r"aLGrGiBPqbXCMBA6Md)L3D2UI$ddIj2(eI2J%IrrAZ2f&"6qc6hhb
+jXDU2H02I(&[ha[b%EpJmI32&RVi(RN[J`kAhMIhc4r(Fr4bdVAX'hdJe4Mc#-2m
+H$M'Qjf0@4)`eCFIUcQZ3!2(!K15XN!!N`jDc#pKRM'#+J&N4Q2@l!+F[+0LB'rm
+XU!"bf)8&PS*&r)483Qj`qqSZ8C@8e%@$+9Z(TQdG@U(el$@"Gr%NR-h)l(lZHL*
+Xeb"`EAG4N!$@BSGY$8,AH-m0#U)B$QefGbYr'9LKQKKZ*dm0AcC*Y"JM)0Zd59%
+&IIR"U-'+@'8RfYj`rE1c'[%'LGh`B@4,$XQU,!6Nh[5*P!N6Zk@JY#N3&MVr95f
+U&!h+)8&p&ckb@B4AHFjf-UYqNXL)T-(-fQ%8$PbL$Z4`5,P*GdTZFE2S&M!*UBm
+hGYN-#)`EeMhREX@iQ9EK4a6,48$)YT&,X3qE9M%f9*,*fX"rmT`App,5JH+G',+
+%1`Cm*)U,&djB&'QQk6RhMBE'qQ[`I3!Xb80GjJ(fc+9(6a23cCl&j2Z)&9CKVMV
+bhEN8F(f-Db&IG!"`jXGY)YmRIJDif-'G**rUJ$Z3!+$P,-FJl%(IKmRhb6A`HI6
+G6VkGhi+[SBpY"63I!Gcq01@3!+qM"aj#Aa2jVPS!2d8IZ`I9GK8mKMl-L9XA6m1
+6k(Z"I0d2`M'!pqmJRfXAr"CJk@I*el!@RJHijMlbHG[J&2S1NUqiP-Y$hir*&pc
+!,86I,eQq*lPPH0U*jE[Y4pb(d-ILmTlLF"RVfQI*9pE(h3*`h3r*YiEM'Y$(FQa
+Fbk%XZSlP@(!$KiH+2["Y9MI,Z1d!+aM@Ucr+I3TJC4rj9LrRF0DimN&@EBp3rDd
+k'Lr"I2brMabQ&eRF$mKRpdI$@b44GITN45c8R9M)#VCl1jZfaS1Zp!PGXZMd#T(
+4p5!mXD!(DKX89b3$iVN,iiXPHNVGhb*%3h+S5bPJUi1*m$aD([@'1k9ET*!!,EP
+)bX,LL!TdUUTke+LJ@+SkC68F09H(3kUP8BKf5DUpA"3PT-N[U0dBcp,Nd4f)1$!
+(q5TP"DQ8JKf)fTBm%X(bk%Le*45GQlKECmlLVICKXM`kkD3$)ppTB-Pl6cRN`Q9
+FPLm1d+kG(8'L3P,!MVX%#Dcr"`Y!!1Xc2@[J-5qrJCc`0AjNX2)"SB56#B[b#D'
+bePSj2AlV-I'%db2X*#-ZRZ+6hAVXeV-MUdFMp)Sm`j2RCdHHNZIN1H&N`XP6m[`
+)*mGYC5XR4iq6jq6j'hP11'(Nq)3F9m+2$"Jj4NDF2#-$IZ6iN3NR6i'lA+9bbTm
+`q9(*bLjY*50q"!QF$$Nj$N`!$JJ!#pJX[93U!'"d$J&KKmlA592T$0#CJ`m2d4P
+A$LrBKQRP5qEXD1KqT2B#+8kiV&k1B4H4C2RU[(4qVU*9mSBe1iV%D3H2k$%m$2J
+Irh39SaXmB[%c,KK2$8IKEr"#NUImcG[X,c"$PeR*M!HcQUdCC[DUV%C([e5!YrH
+VIlGjSPJRr(6qi)S(ai(4)*!!MV,dNF4eL1NJ,hpqZ5GcGPV2'89MT&c@4pkr41q
+Gddc-f6*,UqrL355TNc8fK#4RRe[(1$[!KXkYXb[`)d$h035i6JUpTh0C@R#FTDF
+FK$&1lcNIm[deqCkdUH1m1qVXJ1L+[kHZk#5LT)i"IIdFGqTlT%82bq4I@2Vh#LP
+(LI3efdp[RhQ0r*Y+#2rmB!NDR#IHkTSdED0b3Y-0'TqY5APRkXd%FbalISiVm!R
+ULm'-CZHfJ5lebr1AL*SVc(%&INjpl0[S0'Fq1frDHCUS'rMUbNFqjQ68G)SVj"*
+4McdDcLkDaN+aA"M4rqceiX'AiXbC16`l`a@DAD)qHCG5e(5pC*iBb@dl9)edjPd
+U9p!K(2Ui1k2T%iD@05U@ULDhU#XIhJXRNdP1##8S((T!-5`h**UpeQ+ejpeHZ8)
+C+DLK(5KUGjrrA&**JF)G1K3*@RBfAfT"84flq#0FAlN5PY6&-eV"ZN9GZ6)TU9c
+TG+NKbl"2&FXYE(@XpN'p9e+kkP3lUe91rN2YGUR+Fc[BYcq,I105KG+cd@XK2hH
+VemeTL(M85Ylmbk&0DT62kp(V4&dX'cH(U$C`p6djVk4JYpYVKmLkeZ$phQZ[QhR
+"iPP+[@EJZBRLH)RLS-pe5+&%1824eFUKIZeT558&H`694e6+bAaV('Ua#m2eALm
+-Slmq$C4H#qE0D4KFHd055F(!KN18H3ZYAJGAPqV8e58-ZY5`T"DEf0qSHm@1-Yp
+ck-MdC#`CSb#2rE'U9&FrZHEZ+&c"2RG(kFSFN`[+pRT$QiNLUD63pKUP,H!VHYJ
+V0R*42U'dpaD[q$E*Ud2X&!bG)KFCZZ4G%FR!d#2[%ARI,HpKNGN-h5)C'B*Lbf$
+B*6BEKT!!f"mB"X4d-!c+HlqB6)BpBUiCSL+h',lBpV1G59lerZ[RIclfL95li@F
++%rl[k#iq#KTqhYPK[DTcQhfd0fL[k[28l+1p(A[PhqQMRAYHdBI3E9r[*+&AqaS
+@rh62Um42d4G+5Nd9,2I0I5r3Y#haV&66PYdB,2ThJ8qG0NkZVhZ2k#I%&qG[q,c
+m$`!J)"C&H(4bB5"0HP0MD'9YC5"6Eh9bBf9c!!!!!!!!!!!!VqF!!!"9!AF#6J+
+f!!!!"J!!&'B!!$UI!!!!&J!!)a!!!!F!rrrrr`%'X%"1HE"!6Ud!!!!!!!!fR3!
+!!!!!!"H2rr$rq!!!!!!!!(dK$3!)E@&MBfCY,QK6BfKPE@8J8fpeFQ0PFl8!!!!
+!!!!!!#NA!!!!!!!!!!!!!!!!!!!!!#+J!!!NLJ!!)U$rrrrr9%9B9%0A588""Um
+JY5q[),8P!!!"QJ!!!$8!!!$9!!!!08kNp8`!!!!!!!"9""%!#"c8())BZ0JK-+Q
+L8MKQ6ir4LV4fKjCJ8Q@91i1NT262m+@PD,H@e$28ZNIl**461BmCQ#RP'AmI`QI
+AG'LjdrS@h@Q4dmqaBfl6Ve4V[jIGY8aVAlV0D)V@[M("D)ZepXfYMEE%dCbjp(!
+`UCl@5V0p&9Slj`DM,GADjGKSbl5fjcLMRDfeYcZ+#PirCb5&Il"9r2%3#qRJ4EG
+idQEa$b@r1-jaBM'M(0i45b&DX'k++eJ2Pp+P+E3"j!m%ZcUDj1r4UTA$I6&6jP`
+*2p9S3De0!L0NC@CTEQ8J69T63dK&689I590I3dp%48C538G048j8$50TEQ0XG@4
+P)#*YB@0MEfjQ,QJL$3d*E@&MBfpZCLjSBfKPE@8J8fpeFQ0PFl8!!!!!!!!!!,&
+p!!!!!!!!!!!!!!!!!!!!!#-3!!!Qf!!!)U$rrrrr9%9B9%0A588""UbqNTqY$`Y
+T!!!"QJ!!!J-!!!#P!!!"18@LXrB!!!!!!!"NNa%!#"c8())Bk$e$2lmMaCqrkKY
+[D*0E2dm'58RKV,m[cD-M9rB-YHl42JRP9-jM"QC+HFEIdB[h2X)*iTh@YlbKRp%
+ieXmp5ddr`flZmhrj&rI@Epc%"P("kqH-T2!2YSSr(Q+K&m5L'cdTXrLG,4-(1-l
+C$[kQMX!lBLP%#pC0N9I,29!f[k03D!2)(`KfG66*hk09+iIlBUE-Z4*qUY'#@TX
+%!&'e[,i-ImJ(c$DpTB2"f+Z6fGA'hX(9bk&cY8N6#Q[j-`J!H[@bGM)kfkAekX8
+R)*ITL([eBQ(8Kc`5NJSp3FlV!dfYENmERp[V3f'(3ppF@-XA$2[@aEI8lIKik29
+Ra&qC3J%`i`[lJ"[jiTEJcR6l3i$mRAYkXFJI5@D5KE@i%0p,epR"',mGk#aT4Pi
+KUl4ZXI3bfea'TpRZl1@`jja-`$qSkF&J%%E$4#[a)6p%J)8j*dlF8VjTYKKYVKc
+JpB2m%!)28A!pf!p$)-XA$VXcI33qdfrBEDjH1S1K9kXZ,Q-[RDZAd@CBLKqk[9j
+r+(-TdV6bR4PfQmRFHTAaL*m&K,2Fa$S'M-r0,UlU3CUaPmYSGGLG1QHAAPDMeHl
+XXJb-Xm0kSc!$X#q,KFL0XNPT!iLbNiAl!3!0$3PYHR"bC5j`BfKMD'9YC5"6Eh9
+bBf9cY3!!!!!!!!!!$!3!!!!!!!!!!!!!!!!!!!!!*)S!!#K5!!!LS2rrrrp849K
+83eG*43%'VjL(aV"!6rm!!!'D!!!!Q3!!!+d!!!"G0f(CaJ!!!!!!!$Xk%3!)(03
+FJKMSe+06lA!dKF8iiX6cC!b,#ZU,TU4jG16+RU(@2GSRSCc+HFc!6#R2q2[3J6Y
+GjG$h1+e[QHFMP6G"6[[Qm+#8rTqeMbEjG&+S4k"V8YIBEj,QC#He4aR,q9Q)#Pi
+rCb5&IeQ%KeJB#DGk-Q2bcq*hYJaSCr&-01k)T4!Y@$G&AUd5@kDKSe"S!mJI#(C
+e0-RISe8VKrYLTXbj%RkUdB*DQ`3!!!"4YI`CAPm'B'(8Kca#!'Uab*fCj3BXmRP
+J&ZX2qRTK0mVdB5$5C[8R+CeP25*K,9m`l2XFYk81m,M3kmm3#Q[j3jiJjr8"8CE
+Eii'KM'5'K2-3pc!XmNIi%0X2!!!0!!e0HP0MD'9YC5jbFh*MC5"6Eh9bBf9cY3!
+!!!!!!!!!D0i!!!!!!!!!!!!!!!!!!!!!*YJ!!#mV!!!LS2rrrrpbFh*M8P0&4!%
+'V4,!Hl!jY!J!!"4(!!!!!!!!"QN!!!!!qLd!!!!!!!!!!1)`$!#V(6[ap!J,cr$
+X2F)PaeI#aC096VKVh*9,+&RPj$NP4c[al,dk)bb6X#I2bA2bc$bl*%F(%ITeIT+
+M(V[)FFQ)46MKC-$)M%YQR"`RamL-N3NMP,#9Nq0NX,+9Na%RR($#66cK0-)**lm
+52&N*kmK66LJr+P"pJkkcc)XFj32+#6pbR"`R8dlQR&$#J9F!$kYVJ)qa#'0XfdE
+'YZ+0l"[)'-R-Z61MBa22$`f16aLlM91MIHGEQ``M1C5C-**2[(VKH1rTc("QppM
+i@+m#EFU2(HrZLQbX)"l@kr(aeUQh4DAj*CMU'6l9ef-N4hU'-ke0MBdRNhfCrX'
+4M*%L`NLq16VBepS+dZ!4YSCk`L2CFqE-d2QQ4Xp,DL!c-RjqH*`d8hCbX"rZcJi
+0GFk,0cEZ6-+Gk(me6Z)ej-[BAYB`Ykqc-Y0H+E0BPV'B(FNUKr%q'mdU1k0-fIB
+Z8lB8@Ha+L@fiFT%eGTeM69dAfGD%bjV06pNcfbjRNdp'TPl@XZ@MmHc&pbEXcJm
+rX6HIM%ljMQP1eRF)G2AKQ2iA,Am)Q2%e!qDDJ6ApUKAHM&Q+N!""a%dCm#,3f5V
+'05K-kJ9Ajf+FH@38!VreR6c1DjMcHS#jb9pi[+)I(&rQ@G`EVY#*ciF#[2'2H#(
+JfjK[$hpT$1VZ!2)*iblN@#h+H`)dC!rP!i2%cqZ(m#cKm&m6%0i%$lcHAbN[qbq
+m9`@N2"@#eJ39Aej!B8eBm1@T,Hdq,cH',`rDE2H(K1ma[QZ%20'Bk"V2)4J@mQ,
+HDkYXhB#J@ql[%*G4%0%&3'PE%q54B-ae(9j**#b%S6'Q*4)Q5L!5CKYcRDL96L3
+#H@h"LZB4AJXFM9Qe1R2JJc%VU#YTUNX$$JbB"SX5ip8K!%6kJb#c%TkFTP%G6I(
+N01U!BRN0Gq#IkT)AmSkCP[DKK[ShPZFADZ3IkN,!`6KS86,,%j)(fXBc+*)m-p-
+hU)iH'#4[@VHJ3jaP3GkN+H*eaE,3,!@qA2HIbDlI`N(8GlPhRRQ,5&j0FGT-`I8
+N$bGamALh#ZTL1rYeV1ZiIk[`h3E!FbcZ0Rm4Nep4PhZAed%,3,4$ERpNiQKVjjM
+BXraSNYYdm35K`*8IK$IT*%6E#ZXTlETm49P-Fl!k-''DJj'Qh$80'PcA9G)NM2e
+'Ud&c)%$ckfM6ECKdc#2d,16@,@`AbiQQD95p*80KijeLYY0Cb@rARp*hh0K6hZ[
+dP`GZjZ0hVPklr1Fh!fqB'rBG2ATBH'Ti$L'T%pf[Rq!E2m*f91DBcU*iP5aH'kq
+"9`FcSc1QLRF+VkhU6UHU9r+U[PeAd4B9M9(e2@99hqZSHMrbJCZURSqVqTfVURl
+YXY4HIAG8+M2N(cQp@Ea6H"fmCF'ZKr$+Vaq2KmL2bUl&U!NmiRm-"CEj8'#&$`3
+Hmll!FRr#,Lla8Z9IhScrcVHB+c`fZH$PYE$%ekk(*Ap`d-*E`,0PRZZZmR4Y#)d
+PRMU`LemIUc`j$"TFikQrJPr4&cc8!i(jr[2@m[jj&ZXm[fD%`1*mF,a&fPLCRh8
+#jRpp$[lA8iPrrGMX%f@1E#ji)55#qXpF)+cI@kMI*B&UR34#2paL8%HXeY-,G61
+XZk9#J5j5[bi[8eq[@%S9mUP![eLbjZZZQB+DAhIGffPZf+qAV)kJALc"3-LM2Ye
+K"AlF3J(qb*!!9lGZP3U@hip52PdX&@i(rIQVrqXCe+Y,J%qd29QfYp[0pY1fBPm
+kV"aiX2pkprj$e`qpMcTqNh16jFQCbCq3!$rqmD1l[PU#c55!X-k[YbT2#V90&Y6
+&15$UmS`+HA%fKAASND+Xch)Jd#I"N!#RZi(HUYqkrpAkiME0LY'5)rGC@HEhC&i
+Tbe(N1GB,FQ`18Cr'YU#me0&"HE'BjebT+1UPI#N[G$hp@Ki-FiVqU))mF["Bpd(
+qU51,iFbKFZR3J51Q6p$UcpAr"42,h6pYBTTC2**QkQ$[q)X3H!@jLI`8mKH3!&m
+Bl"fLr(hNa(r%I8ABlIe(ZZL6bjHb!pr+$MaJ@CU*KNfah0I[X"c9p#1ah0fii03
+2BVRT0b6A"+j$FMTU5F&Y14E,I98@h!D9EaI1D4["r5#iL2Jc"qHD&(Kk6h!b1+I
+1JHX5h*E2iBrqp)*3[i!24rUq#kjCkRd(lMkla'[IJpZN[IE@5'E-'-Z-MjiGkmh
+m$`!0$3acD@e`E'9NFQp`,Q0MC5"6Eh9bBf9cY3!!!!!!!!!!IIF!!!!!!!!!!!!
+!!!!!!!!!+&)!!$LT!!!LS2rrrrp849K83eG*43%'V@'UcV"!53J!!!'D!!!@N!!
+!!!$*!!!)4BH5S&)!!!!!!!$`La%!#"c8())B!+L-FdCP4RpICY5M65YlKPVhD*q
+N8r"j-b-CdA3D&McU5`QrNb!Sjk9eqhf!R(!632%a6ZYEY*lYi$cX&9P-4M+SMqY
+1keYhEZ-2"$%#0!jGSe2Q9G*XbKd!KHGfZD2+M!Y2kP+2I0!5AmC`-ql*&f[0U!T
+H2fFNKAq@a4i2XG!65RUkHX+cq*dYffm%N!"VH$BkKTQU$UFa%kbE)Uq@(efQSD0
+3jlk)Xf[)d54rMeDY(1k,Q6,R5[LT4JYUE4)!!!!-6[(N9i)-!,Bb3KrIC8@6Rq3
+f'lJP+k&R@dSfj63h@ePNNdhSTS352-@Ik`0XLTm3J&ml6VG+d)pBS+jITACHhfC
+E`XRab'fb#BYXXXPdNa%RNdhf5PB2D"Dqp959D6l0T(LcTh*TRNeqffS`EC01C#'
+I6GTcM#VUA'DkUQpaEe*l9B-+r+Ud`M'I&NPkUQ@5AIAQL%528l%Y0PqhdNQL4EG
+lKleih@SCQeL9#SGr2e'QApH(55(MLdTPRGB285YLl1,AeG*-FpX6h8cTekhSlA#
+JGB5Ie26k5&HT0'Dr(&A[C"T&#LmDf&"UPH5(dq*-kLLGkU2K)F"$UlGH[,L6H6B
+GM53*)UZcA*C`M#6#e0p*Zc29@TE@UiTARC31FC!!i'Geim+",-Gf!PUMrLUV8Aa
+R%#K['5N!i,T4hf#4Mf%Y+9D(hadFh2Ta)dSAL&99"NpkBT8dN!$19S6%N!!4,ST
+MDG2,,#BY2E(CBe%pmCbBb'mLXKS[BV!kHTFm!'-AfXiXe(PH)GHf+P3D1qq10dr
+%1JF(MbbUN!"&@Pr&)Ej3K3IJll'HYqG632cK(934RH-jALSpFBh$6YQT,SAMHGf
+kRV80GBZS%fhND9S949*QZ5UPpp2dI"XCRIB%"6r*XUT%&l@%4pVUR*b4C8Ea&%b
+59P-m36Si#H1B[,cM,lG1%&8KQ*P#445A%e5aL*dFXEU+4,')0q,,V8j(r0#+)Nq
+KM+Q69(SUB2PjI4df4fSNiLFH+-j3`ZF"jB9YEiZepTV6)jaTF!!3i['@1#RA3ZC
+'LJAhRpFHb)(j1rXY$h+)pb%%l#l&NdQ*mL%"XD1Q9aleC0[*kA4!k(iI2X$b'G'
+6C6UBkGDDaY(JC2#AUf,KSbG%rPNH#M!YDQ4clQ*2Y&G@fMkPd4GGm8l@18`3+b[
+L8U(U4q4X58AHrB)SlN-!HB[-HF%,TG4X&--9T2!4rIbN`r"A2U5hAYaBJDD9UDh
+d9I!MP&fA&JC0*%[&4@qDdVr6fN($HL#XSJU1)NVjcd0!KHD2)Y2-$XM)TR8MidD
+ckBJ0mCa4SIh)Gh1X6UJ,b'JZ!V@ai93GXm43q`!JVc3M-%@pEJ!55i"&#0I&PQ1
+i$bGRJSU!k`XJUJBKVY%8%IAi`mKp$M@Z[YG&c)Y"I!h3+l%*L8[#LbBeLpM%5fA
+G-"Ppb$kUiBS3mrA-,*L"&"l+K9"B&@`2AUf[8eA3[PhUQ#ATjdJ[bN&a-9$'@C*
+,hbGP63*"bS'LpB6Uma2VSbFK91`,PqCLb!eYSLh+a1H*52eZ3hjSYXfkV48Yca8
+8A0lV0++BMd[d-Gj8#2m*m6+bpparLbcUP#FVhX$Mac$FV(j1$AX$FpJe)9$p3mP
+E`N+Bkre*BT!!58k)'1A*f($rqhf+lAbmYIR9Ec"1!GRE2aL)lJJL4e@0J(ZI-(9
+dQpcKHiJcMTV@*AINYD0ZF%X`02alJM6ea-L4!TRQPC'Ji[HS98FGe+$8Rkj4aa-
+!-@I%%lGRd,GqU6!h4cPhVrL"0J9SUFSG+Na+FcF0$Be#`"%TARP,TKq*q&dqAbH
+hj2QFfacR0&e1h#TN$4XEhLc)1FkEj0#fB*3cPHBTGNpJ4Blr*$(0&)j1&Bje2V,
+iHcKDJ'D@8ikc#a6L3d+GcQ[5HBerAh5,9[(#(dV2&FcAA+58-+`CRR,rDf$13-j
+bU4#9'bU2c8P6JPaf[L[AAD%12a,bFQK[l,9GR$mhmIA0bU$1'9FPRH6SS2&8M6)
+j%UHRDCe2$Ifhj2G@iY,8hQNM5NpaQ9!Me,G(qIjbUXqQ+XpB1l8ch3IL[5%Ip,S
+'6fkiM0@&,%rGaHe4l6936Q0`U%j-QZ6#6#TYa@je@+(rbh%-3h-jJ"BVZMeapcD
+[bM'2)hmPJl10iei2AeA&@f`"iPBBdEJT$Ld1EVp)il+Kj,K9j62%8bU-0RpiG*&
+VERErF'02dHeR&r8b&bi[F&"mF%+`&Ih"VM6TJ6)fbLTqKQ+#qhf2B`&k#4M1%+i
+,4*jN-Z[R2"5hUEG*`RYF[mNPHJDN2rLp[,UXG"DGicN$`X8jLND'*X[mH0hY8ZB
+*4EadX%ed8T!!U*LpJi*G[Y+m2IX,RRU#,Zhp!CQ&!kkhMC,5(qb3!'Il9KBi1hX
+J+0K*)Q#GrjkRk15'q+H6!5@BA6ZdNb1VEh6M-%Y1`AKi`$(!Xip)6m3Jkk`L$5j
+Ld1d5dJ%*!AMhXQ&diCPGL"k,dSN)AB&%+e0M9h+!j[(iA$bXQ1i4hRPrKb1kAAc
+cF2S11!A4pcbI@fSSlAIe(kE+ISZ$I$+@[r3P#bG@RL#IC2,*Blr%fc`2(dRieK,
+i%S"k+R`5d"pi(PEk$5e'UH2cR8Sll6Yj3S%kl`m@&Br2!14PIc#RT@m,iSp,!$(
+'bCY$q9r9+2&T!4332fQHpIf[BSmdPY8reFkfdkp++F$r#Y1b)KV&#$ZRR1X!KG[
+ABa26,U6E&LDL,h9kHq%q5`Kp`$FeIjUBVhbH-1(SadlJUa1-&L(T(C&'$2eMSZ`
+KCLY6a"-eRKb!`9RqE@,18GR-f"-E+2h0!hrcSlTPh,2,5B+2),E&q6Hhh%'kSr*
+FKI1Gk0D1$Yi,Ipq1Zc(2YQl(DB8QU9(N4*-@@El'jj@`UCTVY`P$9@$$q'SaVqK
+d%VMH)c$5lZqk+f*!68ZMaUA-h&M8%ZFVrY!Ri&hDXX3Q$BEHrRJPM9pXEVUEVrZ
+jVfLqH[RbCB2TTkQXl9e'iPAqi!6$#3k3!%#mFar'c&8I0eqi"0LRQfC!2eb-R,C
+QH$XHrrA'c#%8C[MHb%q9f1A4-p,PP[kjNjVC&Jip4-)&G3r&9erAVIm$$3d-FfP
+YF'aPC(*[F#jSBf8J8fpeFQ0PFl8!!!!!!!!!!!G5!!!!!!!!!!!!!!!!!!!!!#m
+V!!!k,`!!)U$rrrrr9%9B9%0A588""UeKTkL`3$3k!!!"QJ!!!2-!!!#G!!!!HDq
+'+C`!!!!!!!$pra%!#"c8())BF2$9jmf-C%66D9M`U#mYl0'a+hZ'@[GSRi4b+ZH
+PGIYpJ"`rcU&rjl5qj6hV*JIldY,lI6G#9L#T$@kI%H9#i[S0"hkFd5HcIZV"Q!T
+H2fFNKAqCa%-Xp),$2(dmdfIa1e[@2pea0Xp%iijB#Y'#G92NeA,RP@RS+05j,q)
+2",XkQZ6[dDU9`hda8qCF#6r9D%'Y63*43S88k0h")-!3K,%EB5f3!#U%[RlBKd)
+J![eHB%#3!1h9fSGe+$-XpSF`N!$+J)Ga)b#95L90K,c!eb!(`Kc,"V2AdcYF#2Z
+cI1)B9J0%!p&211pbILcQcq59TXQBHaKIPUpAPY[6#rRFhZ`%qMTXS8a2)T[+AXA
+(4'`*)5%$E@&M!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"(3!G!M!
+"Z`!!!!%!!$LT!!!!!!!!)U!!!!#'!!!(!2rrrrm"!+eK`+D`3&0a!!!!!!!!Z!8
+!!!!!!!!j13!!!!!!!!!!!!#%JJd0'dek8f0SC@eP+'&`F#"fD@%JBfCY+5j`F'-
+ZY3!!!!$5#!!!!!!!!!!!!!!!!!!!!!!LS!!!53N!!!!@rrrrrde08&*$9dP&!3U
+V,jHZX%"62`!!,dB!!!cb!!!*!3!!"2R1QMGI!!!!!!!!&,!0`+fI[Fr-h(3IfAT
+&0jkR9qaA`['drFB)*I[*TRCbHYb2bUQ%IJiif5`26r%8cccCV32*DQaJqmKQkl(
+Y@@56EB4YXXNQQl"0YKhCC-$**Lc,5lIAK'bbfIBNqaMjr4ijIKhCZSp&0VNYZAe
+N`#m*Mr!)*rX*1q#VlmUmSRQE$NbqYYrS%4DjVB3RiH4i4hKX!j!!$B`rIDqc"f!
+!i(m)B$AqRE[JD(d'dKLdpr3T$$aRbd*lfY8",DDY9(4GfKP4*(9VE*@XkkTmRi0
+R#)A#EF'Zp8h-FaVYH34heRlZU`#qC`"UQc'HFTcrQrL*R0H-mK12DA"#jXriGq1
+r"2qP(i1-K2qGjK[!!5Ai+V'aPQ&#bpJDF''N)Zq*k+m6)8La'pH(T3d0R3hSFQ&
+"NER!@Id0I(m#2&B56fPB8EFVrGSN#Um9,aZ$XI2aLpS(MC3@#dB9`p#-jq2GM6[
+LIG%TH'6AC0Ri4fZaXrK'mLfIcem&6Nb%IhBQh`(X-IpZEEBj%)A0jRq0Z0K!,qa
+eL4fTQ8`"Xl60KrAHb!k`FXH(Kr08)aSrqb9mcqQ#N`$[[aZJm@dBY`EF",CMMjQ
+QB`mM)eG0VN)1(J5S2ddI$b&QbYfK4&a4%hN@AE!521`"4cVl(U0jfAiSU3`TDQZ
+l&!i(TCC)I,Z@(%hde`a,'m,KP[q9h4Em0qKk9!b!)a4UD5cQU@L*p%VVBhSLQ5*
+Uah1%`Lh0JJ!FAF&Va3#mYV@h63"m'8G(8hH(8qiG8!d$*@&h(93pp29XJX@(1ZM
+TDe5Ld83L,Uh6SVEJFkkjpbLp(8pqLI0*1"bb1S[A&qU5JV9"[hqU1N`F,PReqi8
+!1*bb1N[)5cKQGHj,[1Tj)"G`D,Xj$[EBXB9DCqU4TrRlLZhmEGEV`"[e@TR&84J
+$,%)FBF93PHJdX5D[ZM)QAer&SHDC,I*+!SP`Z!R(6#GD`1'3!-rTT'&c)iifcC*
+q-hA[N!#0f6lY4KSDM"M[dhESD*rZ$VE1kCK+5Y*F8$*p#AA(3ZqC00)I550C%!h
+c1)b"D'ma6d@ik39@%8GUKb!!"jP,aLVj$kpKUN96FDqYZejFSVL4f[%F&aAh&!j
+KJ1*ZEG`JcI%4#RF9q4"p+2G*9LmUp`+1#mTp$XHmFTrMG9kj&h')&j6l""rr8Zj
+6a,kXh)XijTAl")aAP(X"KcK!ZEYN3qZr92IL$m@pYQllH)k,LRX5"jNJ3(&h4H,
+[HEHdZflYAa5hpjq+#B(-GSB&a96!F8(Tc2%aVh5+1"Bkq3519cTj!BG6,R5p-X5
+"K6mVc8eHNjVKpdmTlN8%3M1XCQ@'MLVZE+HD`B&MLkaLXN0c1!iGTNjPiSK'mZh
+cc)4NZQ)*4k*h@aj(Dqqf)Slbd14DL'9[#VCXE!Hj6pXk-l-!&&668ma$KfR9*K3
++VTYY[r2'Ce98L60mR*maM9BdRe8*!A$`'9-4apL-kG@C6KP@+qqFFad2qe4qaM5
+QTFrc36-G-3!1j#1DRc8X)9jT&8i+*Q*k*$VDMA++30@&!AcSZL!!"rE&5rh-`['
+'"Xl0KJScTJXiZ)+E9NaMXk'*qX!CNbJ!ak`b,IE&%@AkHYhRqP!UhmjH01m'CDH
+5eek,q*E!RrEA)!26bQ[-cLL[l*D!%!"(-'SBJ*dFqr38MP+X)%lXc$i,Rqi,!IM
+J8hNK!!jl+Tr(X6#9,j'h)I[612jH(pB8-j*A+%j8h%8FY-N-Y2"pU9lj&&-)8'G
+mLLN%`%(Q&J,d)6+A%+!qd&2*&iKT0GU$rrG"$rShRISLp+cqVHN$`*3pJI3[6Z(
+rU8!kN!!qqI-9Qr!i`'*i&$2[`cGd%S5@31Ef(d(2eHYJdaqf32VaKb&pbqj!q[-
+H(T1q'3FqK-6%*e8'-T3[N!$j`Z2`SFFqIKB,HY+hIQ9)!TR[*dcL1EiK#f6ZU3P
+NlXCS#ap8h352iRmBcbe23%rpVr"p2mGbR'0q"JjbTUX`+b,''R"B0E$PmNp"Mlr
+Dp)hA`"DUJ4[Z'Uq"XV%D+"ZZ!F3h8J2lcQ)aDq#jMUB-V8cEEmEA[9qX!EMKVUS
+42%-eJ&L`"JMclq&ER'QV"V!Rq-!0h[C)6)pU8U1Q#9[1,Q"2&-%8!EGUF0Ph!BB
+[+*!!BZ!K2+J#5[Q&"Ck#4ac$2J,PX9fer@T+-r)A$@DX(XhF1Lb$lR2A"&l$Nh9
+f)V1(fG9%f0j6`(TZTL#ca3lC03MGY2+BSUU*q&Cj`2ME`!V9a&!lq9RZTNQZaBL
+!E20Q)kABb`qL"U[QPFeEiA#*8hr-0FKM82+!%)4Y9Xe2pBKSl0XN(*CN6c2455C
+Df$klid2KYTSarb34Z[P84R43YN1kTa0[i6c#,U-S9$d3q#CkC%k%iiaLH3'3!%X
+B)er-L['JNXc9"[jcjlcBXmZ2ep4Jb1AX"$Md*#jH5,"8lk6T1EZM[D2Y5RcI#fj
+qU!X9-bV3HrK#!djZ!2V["lVCXiamPlPK0HCU*Crh#'"VB9hNZkS1F1E(0T0[Da4
+`XB-p5ElVEi@G50!+mUhi!Ha(hh[*YqJUq#ckF,D(XpB+q$,kq&E!4qq!`mKB+IN
+'(`6X#mk0j+[G"cp%(lm(jIXar!4pQ"2J)dIK%I6pMRbE[JBR!0iq5,i2I"*q!h$
+&EH4Eqb`m"A$PlH5V[a(qL,llb+FFC&ld28LqNSIC@p$h8r*pm02X(AMDLHH,GE0
+hSBr(hE5Ai6,@mPq6lmfhXHZ3!2A[NQrT+YD12TkMq56V3ar2S6l(m&$41qrN(!b
+bA3!V1GDf%``2MUh+F(bIB3I3Gi3AlA'U[pAI(be[jp-mlM[N@aa1*VCTDNV#fM8
+LLEM2pSFLKZVMdeBViUdKT6qL5N&&(eN2`K-,GU#j3E%N&f$PAQ`YPYJTEAqANSa
+(i[e'"9mGc)ClDANdQ1M6VY2LRY`L+3qc%&AB2$AY6L89`ph8&dNPNUlQ4$cPlP#
+5r9V+ek#U'Y)89P)$'-r6H1N1K!@XNRcA4JbN8S[e)QT2lNJ%cf-M0CG3E'iXYmf
+F1pJF`Q4H1ZPN!b2I-,$F[DG5FZ%b,XpR!I5CCdH3!+Li&[AK,N%@krm"!!!!#m#
+h2[-m6Qf@JhcCb3Rcb&&bA,)5IQ6+#IXe[TCNV9Z2VFH2(YFMaimF26ceT)pRV@I
+(9k[1)`1fmL22b*56#5H-F$+KK*m46[J4+PXj19U%%dki4YK&Z)366Siri@G+f%@
+H45JCm!(K4Tj6lNAiNH2N9q$%ZdS*Pe$#,%U1fY@[K"01RT%T*dMJK!-6J!-#`!,
+fZU,*C"`!N!$1$J$h#6TI*Le#Ti21Nf#("m%'2BjB1TPk$hF#ASRK14KeTe#$,S!
+P3HUQ8jE0C[+FS@1$d5NeSH)Alq-cS*L2*F5qbR-&YI'dNYC8iaVA-Q'P4!rrm,#
+h$L"3*CNpP6%PSkKk$)3Ij1p8i@FI%)'VhU)+crrP`6,2G+2NRd2BThT6UDMhRI-
+B2*Kp#VQ('3a'hS4Gi!Fl,Q!(q1QYlhJ"qV!G1iiAm$*PaN(h"A!)R44k6qH-l'X
+-Jq%Xh!Gpp&l`3EjIP1p*#iq*lULcGZj+[+HZk#5LT1i&D'`5Z--r3*!!HjLj$Y3
+93#FiIhf"P%0%qKcEk1f"&mQrX)rpX`2kb0L(VpD%K[f26HXC,D&k+D#hlFr0RIX
++R`Y&J[e#!4Y6,e5(P'K!9@*UfSK%r+ZK)GC1b)C#rJ!VGN(YVDdd-M%YkCeD(a5
+j[DG[3RCShmJ3+`j*2AT%L4ZEe,R,!j)UP#dQe8QpaVAa%RDPe`U,QYEdbA[8bL*
+9c4a1T$DTqINLP44RNDT0kNVmEUmhV&j[J)Z6peRei%$im4%[T@iYVT!!1r2"#'B
+jVk43rSPkb&D48$6G'bf0k(cVmkmJpbS8U",8i3HF"Zm$*BIb1djm,+QNJ(XjH8V
+kESCZTD(DT,T'rm5qm9(Y&C2+5JhlHTek2CT50iC$[[RD@p)K8U$@T,T-AbI@XIQ
+@18055D%GJM0%e+3qSC8FbRHqAC!!9&+JAUCK@YI)fAYTD*!!-bmUI2eM8LjCXf%
+*'S9$MhKF#58U2&VRjQUV00-KSF"@dHXHZh2I%9A2E'3SYq0(Rqa9+%h5)A-1E6J
+8qlj#8SA5,&01pKM*H-PCbX"C+`eRSF9dU,*ILfq'('E[cjihUDbdQQP`'eSL&9I
+&&Vb'cLR[lTGT)!@fV9*rRjHR2EZH-+P#J6D6@PhFREeT)hd(Qr[PkAR-LVG#JIE
+Lp#,QXrV'p'TC1&@F3`ZRD0[RAZZXAX85%*e)h*j$mcFaDdc&ai8#(T'KhG-e[3F
+("cVpRF6XA0[ccPaF0+P#JHe-IFdpS'I8p)359GH@$CJ0[qSMDQCkA#Ld,$["#CI
+SB32r6h$C@#RRbUTYmYl!N`fKK610B100%U'5jb5#@plY[)NKE*(h#RPhm$D)8-h
+l!N)Mccb%+Yj9%'TjYL1dFlB3kRKU)l6b0%#SiBd"i42i&#lC[b&PaG&bjUfLhC[
+V5eM-QNS2Z##&EF1cG-l3H4)S0RFU-2SkGHfC(E[JSAYB1[QNG$+8'rP`$pdIcHd
+q*KbGP-j&FPdMhA6[K`"&N[['KbjQaGdl48Cp$Gr#Gr5ZbIVGNBk@Yd5Va2q#U'D
+HdJKEH60BcDL60eH%*Yi"rXjX[Acrh`(CT36!IXlZLY2P'@S9rFY`,AGLrB5CRC6
+r6k`U6Sq06[kDd&CjbTf8TlC9fmZGP(mEV(,GX[URlJ"ed%m6C5M5(cI-0eeADFU
+p*(D%50$),00XIH)5'93R#iAIFQIV%@p%E[i($3d66AT6BfKPE@8SBA"`+5if1'X
+ZY@dT,R"`Bbke!!!!!2c2!!!!!!!!!!!!!!!!!!!!!$UI!!"@p`!!!"Errrrr68e
+38N0A588"#UX[Pkk`3&0#!!![4`!!$5B!!!N&!!!%H8*(T``!!!!!!!$Uq`h!VCq
+pf5@RR",Hq@CiRQl2A,GiGRZJQj(pj+LGR&k$6H986Se6QIYC(TlL+Cl6XpD"C$A
+fjTBF@irYBh9N(cP1'0N$XJQVPr#1r#DEh2CLYipXQj!!66EKK"&'pNQHNddif8S
+iiGBTiH3jZAeNNhd56[D4I@5666CK"hcee*l6kl6,JFrAb2B)ME$)mC2`MQab[#-
+mGJ"N!q02dmmZ!!B![XF"9Z2IZ4XHDFT#"LrY2A85,jk1bi2$BA9!LfZV&&fr59k
+hISImX!2["B1KcN"N8fXZ`cbR--iJq0DD,hdES2B'J$8Em$l9b2p0r%61[i2U%im
+CF%,flrKhilm#rj@IJ+b%rehQ'F!"&ALUX,&@B8%Vf&T`i8e&(SlUEa)K5)Q2E!T
+*QjZlQc(P3N&4Z-$Cq!-mI`Bm9K&2C8K4GbMpfLb+'ZZqE1b*jqrAK[FBD5dHL#Q
+'S4PRlVYEGLEkBR2`+'k"DP[FVc(XR5LiFJP!!cLa%2lC@,d$f'6qdp[XF#!+@ec
+r#q*L-jf`f59hTKFUq8eYQ`IVI!Fl`+SG(aq[diKSI1`i!fFe2!2``8-!,GIJ[EA
+J*V"G`fDCVQ&'3DN91B8F2!M3G)SqIS@BUAB(N`P&64CBG-%Um,!MMXc)HBVQUqq
+"L[UJSRD%TAAV2bbe4a-lY04N)EY#+"3i@q'UjP#SrC,XYZ1r@GGMBJ!F`@"l5lP
+1AAZd9pS8ej1T0&%lA5-BDQm6"1#)"'i9!r$D'HkF!IJkMUl@,9e1ZAG!jBhJq0&
+m(@q,%SXPN`PTSaDc(4rE*KhQjq@22FXl&Z*`b"c&A(L$%5Q`*Z$ccDR$a1'59Cp
+2#)$$+DY&3Pl&865kVr+U&i#Fak%0F4aRpCU2R&kI`SQ'VGH"Yr4D2i+M0!HS44`
+Ka9#9f$ba*Uqk-Z9Iri9$,6"EjT8-%Z&`%ik&6R31Kd-qlC2'`idi1MA,qLhShL%
+Ea6lY4KUDM6M[dfGdErET,B'144p66dAD5NkQ,kRZ20GlCS2m4mT)P8c$%JjM)0C
+EVP-ADRf*9F54hLN)`%(KNP%Prq8e4&SXHh)"L10'DUGVA($FFcL%!BklSf@cY-K
+(-"3Tmb(kF1kcV&j`lL8Fjjhl)SiPjll)kj*c,q-3,cMh'6lqkGcRL(hGZCGa,$R
+h'4K[12F5$R'!FhI*KYCr8IIL$mH05c(605iilPNF&))!aaf**Yll(QPSrEUcMV[
+Q0FH%3)UGiCaM+Z%ilh3@q9Kb1Q8FjcVj$)ih1RN*Ke-ZGEdUa)(#,eTcNpH8C[K
+mKm(af5'iiY!A4LkrVIXB(@X*K'CBcFUmkZcDr`)rhbFp-0kT&R$Jf',%-GPAFcM
+Hp3"e+K0(,&TSRf-6NRR&%SjNlf!"4dI[B"P(GA"f,F5+b`2YGi4"lY2Z-SajjY&
+3E9Cf+@06c$(QDG8Q'!aX,,EITH#c+P,L!Krj'G1NS[QX5JL!JmqBbMLQCNb61&j
+f+&@S9Yij&cXHpUN&2[*H1Xm(cA6%!$L3!)pBBGC`'I&+Zh"5)"RASl(*ET4c"+S
+Z$1"$e`8"1,![AZaR&Skh2("Z0P5D-Ch(`4hF['1DQJh0k!0R6+)!(%9R@Zk,%ml
+d6GhRqP#kd-jHL4TZQ"Dm9bhI%VMfmbH3!)&jjc89BmjVC%Y!#)!M%$--`%k1IAS
+14b8UD0i*@Xk,T[Y#!$li9&i)J-1HbKG`j+Ibq8j9)3mLqr-iAYD(0F@-&Kb+XqL
+i64bdbJbdmAe4Vhb++363'CpL#J&`8,L&!(f)`L8%d!HZ,pIc"@*DMIEJr`23JrQ
+Y*qq(RY@r0A-!M`$dq$1r1SRrjrdCIqDCTpkj&9m(@!D%FaqHSCXJY2ZcAhd-HQl
+H#&[rXKdb*ak(c2iKIqBq$lq6q531I!L*L8qUpfHTRMrlP42`XH1IIK%,CM+IqZD
+S"6,2cjR%FhbMiFmHAZ(2(X,E&MjSZ"11iAmFcrlRS+IT@6arRf0jP'2q)acN6$G
+J985-'R"B'YLqr&lSm6@DZ@N0E#F0h2E3Y!DUTM430Di"a$HKJAd[BM%em0HZeLb
+Y60YRaYHpAp%!h2C3``5H83dJ&Y3!BIi6r)JcE@N!Hi)Ah&!6MXEeQ#DeD*U`jGd
+&l)NL'"(`D!5AqCi%1S5a*a6)-G!GmaQ&1UMN,bc`#[c'8H`M1*Q`ALXTlP,-"j8
+hY`kVB!XfYd[4K$'5l!BAHj!!h8b%lF@h6[`rT%YQLaf0pb&d-kVMLUSQ%hI*!mB
+r"PES*NEEbC1j4deb,8B%&0Zf'@R&ARi3083M+CZh`NRpmhCT0FLM8(&%#-)fDq4
+[pBKSiXGN('VMZpIdUfR01,ZX6Hl$GM2QRbb#'-$AP'8lkRZkm5fF*pL9P()1i6c
+hhCL3!$N4MM((mK)JPc$'[TL+mD#6c'N$rlRh[0LI9ajEX3+[,'G2Jd02iH+&"&I
+Th63pCpm)Gh9HMqI[JTZre)@1'4hSBEl3J*-EJ#[I$r4Qcp@8#dGJ0GEUS0bbA`2
+f&aDKR(i+ZM#hMA+0H`!A1pJI+#Ir(RBK3IM1&m#(IJRhB)i[8l9[K5pLlNl+hId
+lq"VQZ+ABqaei%"RMEYIh-d!hl15MSqB@q$RQ%T4EHcIm!R0ITecNBAJ#FhbQH2Z
+0m$6!YA`p0A80r!EJZRXjTLr$m`$Ahdmjp`$m$A-dJB0KLG9JMQqSHJEC&CKlNR)
+01RX(2ZeNeZYMf*Y@mRY0ec&FaPV*Ci$D%EB"i)DI8UjY2`YMMYIik1GB(qCiMGX
+6$"mUZK(j4'6eE$I!+SkeUShKLf-hlH0kZS8G`0chZ'JI*IfY2Qh4R#r`HcrKQJZ
+PNS1DQTC3ZdBdQI$Dq@$88,emfQVGH(Y3kBqU8N$4*pD$m)N&qk+j3A&ClS*9HjQ
+e@'+AY2-4*C@)*[U01Vik1(+pKTC(!mNqEB1@m13@5INe#e'Gc92V8$UP'1l@[QJ
+kQA+e*40TGjH5kYI5hQC9eC!!TT!!NKl!qla-$Ed$B3'VTpbY831Te1+pL0U6Hb5
+#el'4QNXS0MG@fQE1(@J,BV%DHY,*"NDjF@#jpjiU+BA,Z,bH"G"V2MZ#4#@dQ"G
+h#8D`rKm!!![!VFr@3@q@fFVHSLNIH)4b`SqXl!JMM2!cchk0dflPkl'Sl&C19KB
+j5JD--)+RHR`0cfqGN!$9Z)466JDFFX,*FA,mb)b6#51F2#Gc6[M++CiF28ii18j
+B4eCqK"(Z4Bi66LJRaer#bA-bj8Ii%dlibZd)*mr*8q$XNJkiehQCDeHdP4qC-2+
+Fc$K"!#-FB&9A,'!(!0P5+3m!$,qh!A5mKGr2F*E'V`Hrjr#f!e``i0%VTI*lV"I
+BHChp!NGQ%Z`%E!9SF0)fr-VMFJQH2r9d*MYZ&)c)MM2LRf2EB5HdXI,"8r1dHCl
+VS@%A1rlmB@#IRi%C'"UIqcN'Db6%Z`J8[-#)19E4+UCKI8&RFDHPik,[[rX4ckG
+V9FdSkQ+ljRiHM[Z2plGql*8l!1jj6QTb#`SH[l(biCI*6fjJ-44fhjZ"P*BpQSR
+QcE'VmYHQkkIBXkRd5*a2F!rmlA[#@p$-BM6EY,!Gfq9RNmF1M4lM%h$cAIHq'm4
+G%iDQ'aAV[Yd2ApReR8kB6+@'%c6aF'Frf"FSD0PXUIKBG2a2K8,YTYL96c!K8+(
+p1Ep&@AB0#[EJ-bp+KA!#AUl38-KR9A@ce)4#lF$V2i,BP8pmNMTa8XYE+p6T6j+
+5bLGq3I9E4[Aa3VQ*V4fBHY[C&5F"KeV9Y8VZ*V908!-R9V'[IKJk,kJdDCrI&B0
+KCGFP0h3SDX8XAPGSL4SN[fj&kN6C@$D4IHFMFp+[1)&133d)PcHc`GkEH%P5F3)
+KN9j)a6`aQa*0IIT#6&$j",SFAFeF8FYIer@#d[8#V*A8*iXQfZLQAlXjGErEIqL
+N8D`ZZk(@rd0-8[PNRFbK62,SSk-V1D4rkj982ZQ4e#ahhPqCee#k0Q#p9#KP&%U
+9L5EfYGXRki*+Nc!eJ)q$3L&-rbLfPmZlcTcYBC280R!#'f4kS9fY8VkT%6VRY2,
+3DGJS&2,&cIa+S&a5D*0S'd'R"8FV9Z9b`E%IQ-&Q`rr,*p!VU"f@@5MR$GkirfK
+&GLbTqP$5$jYrTek4#E[6(Y@LpQ$E*fTE,NX'ZPECl'eI(aFHiK2S%p3ZTHY9YKd
+EH805F3*EZ)F'Tm*$4c,*b-!ZFrYZrHl)m'r'V8er`k4IF3,pe#Nr#+HdkMKLN!$
+QX#p5k`f(@Qp!a'N!U-p6aH8'F,pq9VS"*`$Z@3M!U2Y,I!RKEb&dA$4TH9LG6I,
+q2TaceQEh$Y6K)jM&8IHP[9SZ9kGAhRXS-4PXT)4Ki+CHbm"2@FmJ)1pHDN)-fZ@
+p3pjpe"FCY&%VBq#KKXYJ$A9@"Th8DKK%b"%-3Y4A''bQ['!3T+l%i$[i(Y8)dd[
+*JTkY&Uq1`pe!qFUJQeV([*lVTEk1VPh8J"LXSjlaMmjVjIp[(D"h("+8#aIeEQ@
+J1RhblZcKrR@29J+VJqpc5h[`plQ&29VTUXk@'h[Fb&YeqPIhD,8cGF+VHl6HP04
+4qBUMRqkbN4r(9+URihP,rZFVh!EIqYbck4'VZK")"rNPR6&bFh1,ER-0m2r`[Ii
+(!!!0$400HP0MD'9YC5KKF(!T,R"`BbkeE5NZF("M,V8!!!!!Z5-!!!!!!!!!!!!
+!!!!!!!!!53N!!'1G!!!!&[rrrrp069"53eG*43%+UbqAVV"!8d3!!#3)!!!0hJ!
+!"`%!!!8e+ATFVJ!!!!!!!#Yq$F$i-YRDY6+6fmVNjqA*mBb`*mG5lXSLI#"KHB3
+6DLIcZ"r&-b9V%MVJK!dd2-8c[Flhb'UXSi354SkYar))2m,*mbFM6PMR%hjN`Sm
+F2k0(MK0qK$qC--))La`I5*k6ia*'D%RB%8kH4BiIHAk%%6iNa`Jpi+ZNPTRmp,*
+INke(1$P1Ml$)FBq`b,%)*ia``Jp21$$Hmrd%%!r!!F#F)!#2TfNRl#f03`b,Y[6
+fB1&3h#ade)Kq+53Ym#R+(3j&%4e[Q,"1%0`H9pfULQ5'bqr&q"R"+iZII3eJbM'
+!H9DXTajR6`drNA-pU$ra')-FL*r%di*R,Tk6(S-iMqFMfKe*KebmjHTBVGK3MrX
+J,j'j3S4YX+%GmbAF%3j-Am*4J1@G!1@cXHiZX&!MEiI@aY["89#U@,Y5l0J"80T
+,(bYCM9Mb,))FpSPbLJ-c,)"mETmTeRFI$%*MYd0ZSH!6UfYiYp[&9`A#E9*N#%Q
+f`m`bYl[UEkdQSK(2-NA"1@3%J%-3UXScI3UU!NhmUT!!)NHL41e`$m&G9@N3J+2
+1YF)BJ&G2M@F%i"8FhSTkEikMb5mZrb3'T[Hl`IjCPlrh"kH*m[CG,i#pFl1Yh"F
+-bR+BAbN&&Ha*-arVZkLHqkPS,jYBL-2N%02$8+MMABYG*5AReD(K-$[%NK*$!"`
+j$R'-N!$IF4$YaJ#m+LNJPh&)l3`(GhMrK0BjmI86l$kRMGde[IVrd@YK(iiaHF!
+8a1(fUD)[H)&BM9I&TaS&i""6c'Ci*B0%1#b%iq)NQX"KFJcjT)'`)!k2P,"q&h9
+[FUKMFpU#0*5T)6DRUHIC19h[UXlkQ%*U8TPf-XfbZ'PLpS`'qBq)'NQEKR%FUMr
+BP1P6i+kia#VLL'ib#-""BADJ5Ql`kLBYDSjlbG+(M%XF0e)lh11Uick2`c$!F9H
+AVqDcI!MZZJ`I4Kr1IC69UmipMH1bFmrL'(IZ@9l(RAX'Kr'#FarKidrRITlB+mi
+pJf2FZBr!Z1EFdcL-!jblfD&+,IrUh[M$F5pCfMEFikVM(X9"B4$JZ1X#iA[ZjYZ
+A,MRRZ22qF%`)C'`b6$LQ0)l,6LI,alM6bH#BQ13M1+j0mM51(%GkkPN4"`SrDmh
+0MQ!J0Dj1[8KF8!MKN!#E@P-iUTYD-cMbK0%eM$j5"GI+'q0`30'CL@G&0TJ5,q(
+!#40-HF@E#%I3TkUm5`iTJH!CGR9&ikbA0KS#m2UICdKkkE3RRm#4QC`CR58RAM3
+PXr%`&H,q%+d)F9`qRXZJ!I2VHRC$`m,2Y4`!2L-e1'0(H[$mbKPcaSjfceq(QeY
+6i5"fhSThU#8)9FliVJ23X'JPV2Zq%@,(2S,BpRCRl,Pm9K2EKZ13!*!!D2Mi3QH
+FqMRM1ir"fX02R-D#QGMM,rF6VYf2Xc[f4hcpiBah&6[MR9LG`!I6eX0"2!I`E$m
+1$D@Ii[e0KZ8pK[PVf-'BRSCG%6&U`*63311XTk#Ka+lPKMA35"TBXfGB!pCI0'!
+Gd!$L'p6!eY0B0!hmk+f)d`+AIZG)VEpT!0EXQ6D)Tem$L!8e3*LrJEFCd`N0i%b
+`J38Qe`4#5P$Lbb8TrBCNB")i%ieJ4-$#$QCp5c'jVBK"MS'9X+)#Q%3f3Q["+[E
+M()'md+1,@m5ST%D[Jbr&d(BJV&!rY0Yi(8pIXKDCIC9E4)4Yk3'ZB4X9D51f2qj
+&k&VNKAbL+)Fh1[cUVhB3h86r1$R8[h$D0f+-J',$"MAULr`eA)`#`Xk8c8EKJ-4
+T2LB(j(l)h@F)`MD(Qm3')B2$H#$H)H0JdrIQcff18ERZCV56,%)pfp3a1T!!EEr
+[UB8FlQ0Z"P@Kk`(R@jKa-#*-Tac,*8"Q`aMlSLNQ(jeN8KYi*[qe`(dhhePFM#@
+cZ!i`+4&meV`9CLUep2,*9GCi2A2alJ%,qiX#1QCdS&hXZ4"IEJ!#1i(q)(!EjH4
+Z)+rUCB#2`!0iEDEF[0e!1i+E+9Fd#fV`fN@jqfG!29lC(alDRSB0!01,+$Ir!d"
+QEPP)Z6YI"(a(R,'-FP2Q`KE-H4L1*q%Cc,&A*RcpH"jcl+@f)!)[i9SLkfFr"2L
+D0P1Vki9h-FFFHRdV(%#k(kDF6B4Zc,%HdSI`"HCB$r0Xq"CJ0RZr,ZU%NrJV")C
+edb%1aq,YT"GBZiZEMMPDfm$A+Y)([rk-r(*1X$VL'DDk)h+V*%Cje*BDN!$$0Md
+["&4aDQ*$5Apfe[0e[NJi%'j4#r4Q&Hh4L%qe9$3(SR,%A#Q(SaD[,p)L4@ePSLM
+K`lAE&r9M2@XcQ9BhAA+cp+!8,U6FLS#+MpY5U!NKjLIh1PQI"-)#ED0"*b+4eRQ
+`Z#S&E$DCrX+J!k2F!,$N,aSQ83VhCeLr"%#EYLQ-4)@PS!dhQ2U`rJm!#m#Ycr4
+l'qAe$[)iS8q1NZGN*D`MR"`Rh)YH+fXY#CAIHQb94HYFb60bp2$8NhUb@bGNYHS
+m-U!bm[`)Ir+FF-,*Fm,*M*)"*jc`)e41*FH1$$MK*U&&@)6b)mIILh!Pl#,2Mc!
+bi!0br-KcbZd)*mq2h!VF)1PaSi3H0cflqT9`-Q&NbJN511%!"-!,UmX+Te*a!#"
+iY`'i-RJrMcd&Ea[Hlf'e#bc3DiYN8ZPh5"H3!#X4FJj'UY0%Kfk!"8VU`9XFLiA
+c()'6`q'BPY$)TaI)%k$ba`*LAH9CSQ%,'6p5#FL$Am!A+rlN!BH!1"Gjb')mTem
+IbkJCA6-qBfH*m0ZKQT&RMkKC98Y'U$id@f(kkJ5MAY+SjrrbB*((h5MjBD0fD1j
+d1ZaqFjEi$q51%DCKL[L9!Y`0AV#5HG)'ARcVQ5c#!'NPEC0&FKPRaSEe20KS(c[
+i(ZmTS@Z8q)-jU)3"I%rj)0jI%qqa&abPkP"C+e0&hk-U[*%SU(X"'TXSlZKhi'F
+DTVi"9!A3#BkIAm$1idMkK,6JfdGH3[q#(ZDI&BJ(MHh,eZ`l-1cVp,S9aH['!9f
+a2hqQp9jb+U$i"fN(,)ckDV8[QG8bifTBZmN%Q!kqiL'RM1c%'1f!P9,hA+d*(2B
+q1T(-kJRYPYE6jli3@V%$0UEe+AY!cFCZbH4D,cipLeTMm6(DJ5e-khPA3!d2D@T
+%baKSl5S9&AC",K$`$V&1"DAZUl8EfBLHFXI@YHEh[[%$j!lY$aeL(EZJRMLZaSe
+0kZR,2N'P(3HR1P"VA"mVBCHe1L8eSbHMGkL9*PA,(NfN0kNcEjY8l&5C9$fD911
+hY9kA@Up$0CZmMeh$[Z"MS9+JB+,-K8L1*mTF#&bBhCDqBa8*98qk`k@PS1#jcd'
+B9YU"'NVYMcS-YV'8(#Sm12QFS')(DKFR6mhFRU%Ede$(UFk4[l#[Ie"lK90CTji
+je)0D6k5eMA!SG"dX#SH`!`fFkZ5qMUpM#hZ'AK48l%!MRb'NTT,MHXQKQIPR2Ca
++1l"96-0%8NGRlda$NmLm-2Aeck4FN!$CX!$0G+YlU0fC8-28Sh9Z[VC+j`l4$Qb
+M@[ZYM[h(Y@4fBiEb(GplK&EDf5iFiMQdi9$Nf`T"TCdGBXV4(L-9,cQ,-h"@6X0
+CD1%1f3Ieq1D3!-2dAEPC6Q@G9Mi0eBDH5-FeZUIrJFDNfbdcEcGZqb[8QhPCm2K
+N8[SFd-kT,R1lGfH-c1rB`J0RN!"+hp)1l1681NQPFBlEbSV@A3V2FYU"$NkYM)E
+AH#DeZFqN0[IKTLU5%T8qQGa)b[XMFm*Al1"LrJaZYjI`B32l#f((`MVP#C%(Yfj
+fQPK'%@KKddPJ#pX*#95ba#03+qS+YP-4F)MD+@SlfqX)e,(N*p$-dSY!$GXk#$5
+`P#E3bC`Md-MbPd!VQfX#p5cl#A`%PkaIBEhXChPfj@NApHG`,FFl[IJ6NbBYKkI
+aRX,lCC!!Ac3hcY$)DkLkIAVdI$[@3H(M%H&M)"pk[arVJrQqNapL(FfVEcf-YC,
+[$[9J23K$(U'Eh20ZMYBc&r(GPr!eR5ljLb6m,1pkmVK%[B0P,B&Y,0pAjl1+lCm
+%YV-NrfGHYiVhrad`YqJrQpYPRm[T+Fp18CXkj'mEee(18hNkPR@BIee#4rQ[4ai
+cIpCdP(prj$(RB8e(q@G((T1llZ[IrdVbQ(1eTU2mFb&2pG+Sr0Kp!IQ$Q'UcbQ$
+F%'qZiKGS"Ge4&,q4A4U)!9SS`eUd@2ae#l(ddMGdl[i(!!!!$3d66AT6BfKPE@8
+SBfCY+5j`F'-ZY@dT,R"`Bbke!!!!!"JE!!!!!!!!!!!!!!!!!!!!!&Eh!!"[L`!
+!!"Errrrr68e38N0A588"#UX[Pkk`3&0'!!![4J!!"Ki!!!N"!!!#ICU$kad!!!!
+!!!#093h!VCqpb8a11Ge(0Z&HG+rmc(dX*3c2ETmA)ia`0cQfGM+2dfj62+F5qMR
+BC,-"RZ)TRRPi'VkAV&CREV)*@irRZBpXFMc#b'#IK'fb[FJQJrf%CAQ%Afb2b#E
+(-dEf-I+Em)[FYL1E&H&(0VR0b1d"1Hk@l#-mXXPq3J1qqUlNp)S10KhiHffI&ce
+#1EQYK#IKC0X4(YYiXS(aTqpepJ!-!'SH"eL2IrFKH'4E#T)BG16#-!CHXU[&S9D
+j6iNSkq6pN4X&ACH&8bk-%m9`5kKM4hh'`h`Ad&j!F0r'Zlm)i+d'f0L!mC4MmQr
+L*h*H0mT22#E"$DNriGq,rb,m&hmB8J(m(c6I!#iS`PH4ME8%%eV'0S%()b9K50A
+I)-)KaGkr)acB@GYHLbi2&K5C"pa9Am(ham"R*I%9KbAjJ05Vc+!SXq)&ih"N-Rj
+&kf%MS84#QQ3BL[&#[,GZ)0UMcF)MZcR0aYpELjh&2jE[KXAmPH$'42KR&r-G`al
+clpCQQ`Y4f'cqeiL,RI6#AKFE5-aR#TUPE6kXpbjfM*@k2MLDT`V4e,#cF0Ee+hJ
++B1X$!(AABY`Qm",BYL%c6GX3)b0AGDC#MKm(f(D"2Kj#c*4ka9K8NQ0C&Mf`$Rc
+X89FbrCkJHG94++S3*EQj04!1K`*0D[5!%Kp2p0F-ep5'`dhr+lYpq+r9GFdC!)F
+S0Y89mT3hUGf"(4%p&Nm3Y9-ja("6Jd-!MSl3GQF!APYD@kB"[S+MVEkcc5edpmQ
+'JC+`F`Y82[kPG)+9*pVSkDq60#d@L`BD&Fd@I1j0$ce#EpFcRq&m%JkA)1I`qX@
+13'KMU+CQYMT-("j"VUPa"-$K&Z3F)5rMb1RFPhR9Xd#@F5L$(!FlHhUTeTRmm,2
+mIGd"rMEVYHr0HUe)imL2!9BJMV"Nb*)f4kc*Ubj0b0IAF-KCCJZmNN!L(&l#-Gq
+*PR#iK%XkDG5mL+0&XD6II0fl"#2ATle)3kd4iAhD$Kh[djfKjJ8G8d&*'[*+TLF
+Q$bceRKNMr4%hiRR4X)M$k01k#hR+`r9rB49a*!BF!R#3!(N%V*,rm"UQ@M39pqB
+Ylh-Z8Ga)l951biTl&SGMJ1*ZVYXC@1"$$(F8q($k81icV&j@lRNFbmTp!FHLFPr
+JG9'j&h!i,bMhD6lqUGaRLAe&Z4G`,#VhD4L[+[Fm$ZF!jHi4$+Ah5YdlIbMZc9X
+161@iV,KRF*!!133SlJieHY1l!i0E0[pCFCIp3c%KN!"FCeK56(NFbdTRJBp&T92
+!XG6*Th'mfXRc10a#[ZZ9)!iXr*`d0hQ0+dC0cDcLAN%J&-0U9QESZ1*1GkTj($L
+f5#XQ1c5$im4*kP3Q$Nh0YXq,%j+jLL8FXHlq,)lQl[i#MP*aCLh%XUY$6EYD3HK
+4pXr2,!!&eG`8mm4*@V84a9"MV[dZ'Tp985A1mc%jBaU[D$kVFJ6!`@G-"4`6-kE
+ACMSP@+fmFbjd21a6f4R6K*DHj)0Q1Xi!1*!!$bdlDlL+H+99Z%!S&Y&9EE`EC45
+"V$X'm+(V$J%iX#pHk@F@MMFeF'BfP*ma,H2J#Qj1-8h-KUEV!fG-6J%iFXUdd"I
+(P1NEGCrT3iPX1h[*bRC+"k@XpPV"Y`6qH,3D'CK6AK0f8AQPY`3F!A#%0--!l16
+BTfGa&'-&F@,RpeRiG0m4J!mqPAF%`'&2jE-iPUEb48)rXMq(imAkX+DBDPDKZ&&
+a&h$3*M23`[H9HZ966%H!1Z066%F!('4H4i!q41Ca"+J2p&6`"@*DMIEKraES3[r
+ZiAZKDrd[6"m!TZ`+*RmbM2rc`@3`qG52eql'i`!Vi3R-I$ZqSCdJ0!96ph`2ZMB
+d`ZlIlB2Ndpq(j*f$`H5RI$`QH3F1I!L*L5p3%8a4[Q$Uddr$"mjqp(NXk%Pqj!X
+M%XKmRc1*jrK',*KkX$UBHJ#M,Aa3Z3HH`2mSRM[23GHfRq,lbac,'Blj0h#F-ef
+*@4%aeS$,US&pUcm1A699TQqU"[C4$Gafre30P%c83-PS$5#qX4UirANXCJhm[Ud
+q45[6pT[aGHqADJ"ZZlpb$-p)$5!@V!(#r&[i'QIDUJ(X#Al`3PQV'Y%e*9#R+)i
+YCaH`*cV"&!'h+[$BG`&',bL3!',J)6bS()VjK3@HJNHFaMi#TC&$'h[PK'*N,aV
+-fcBdFqZ`"$S[A40i(8rDfBl-RQ3EL,!M`m#klU!JXm@1f-d)hE65L#6,XHKqSFr
+ifm!+eF4)1rP4jUC*TX8i!GRH[8C#XTFIR"UXLPFfEi@M*8lp-G-J6d24SmL@'P8
+6UU5T3lN6+8i'eC*3iK%e+LAq"Cp9iCQHNElQ)'0I4q(!+Zc66!,ZDJYiRQNX#DQ
+2&hIC(!L-MHLHb9Xa!UpTeh*Pib6#+8DqQ"AM3b@CU3hmCmjjXHI@0PEMU5eBcCi
+%Pal(aBX!A+1hdr5FIDkeV@80[Km#,cr8KBSC&HL$I+%"*cF!Jp9!0hY@N@r$(PL
+2ZCV*Yrd-i2SBkb$I`4$Jc)rY*Cri5F$&$[B-qIDHKi0)d&VbGHT`&(h[iA%$m!R
+di@`2!Gm,Rd8Ih`UiD5ZF4-D+bAFN"&p&hblb[H8FI"Gp[*QeDr!BqM!R`)IZJKq
+JlpINDlNERJ4iqf(blEiHIJj`h9hNkfq%m`"VlL'Im4Mm!AfRb(I,"9D'[Qq66p[
+1hSUq(j*[chIBpAMDLHGEFiUp#hdm6ZeMZ)ae`mr)ThbHh3V`MQq5lpT'eSSqRU2
+2chV3ah1XhXV`80%llb2IHrhX%-!kMV9cQ1("X4Y6j)[mNKe$hm1mD-p3rDhreRK
+jZjrPFGmJhmT`20D[b)N!eUkKaU*qfbqUKZcRdeBViQfLe+[+JC!!T)qY"q'*"6[
+3h+#i+K0Jj9jT,CEB+@erKa52UY&HSjb[$UE$bfKj0"6V8@j9SVl-)LN2Xa#9fcc
+9$bELNZ'Yle%6XELR)4C0H0ZNH+q5m0I+XS)dKD9%(mEc0'9d"m)#9N'qlDU"9#U
+4EN6Ybab*i(PXT1B5LXf0jEDCmiBD4%a@4LHGE'$N'`@@ZIG86#jFaZAj,)"qmq`
+)%K990$rZ%U5arKm+3+ef1@!55PC'''&N`*54@mNcmLYj4PE#b$%bCfZY4eC#CH*
+,#C8F1c*Jj#QHi5QHqZc@6,+HP$"bP!bSM##"N@H%%8CQ+d%!*H`)Hc*JC-*@mZc
+)N!#4!6[*-r+-(#8M4Tk4Bi54!52Xb$(*iB%EV0)M0()d`JKE#Bd-f-V)V33&M##
+#!41!J,82lkb[0`%3[bNJmTMI9lbcq!hcq`!',L#%6+bm@AAUlTT,Eer3EGLX"H[
+8'2TED53[9(0#Y(Sp!HCK$k@krb@(Q'E%Ir$LCZ0'aqidh1il13H%lb-m6hJdP`6
+Q6fKQ*VTLHlEE@K&jF0L@c)-*FNi'9*(j2alfH5U0irc#)Mihffilf@F$-KGlYdK
+kk*0T2F*jj'(3$U@3!'GYEXY(J@BTYHA6'qjBQ,ph%"ClhV#HhllfY8aQTBF%#U`
+AI'MpVYEcVV)Xh,'c@HP+k0N9[dc8e%[!UG-#Gr-661QKr`(X#NJMpZdZEkibk6@
+GBHh#IFk[NT2j'D#F[!A6TCERGPCYaq9kMLT!GlVHKK+(&$9DYVhkEq#3!&T[+S)
+KEX$PXmRK4FTD9MlE2-)rc,8r8UpXQ8@aiC3N09&c4Ma0[ELdTkQm3844CqB@Uk9
+d2XhNp-qJYTqqh+@"5%KX-+@Sdq9V5aXYVl%fDX2fNqGa6H80SUS0bDVSJJCRIj&
+93[SJcL#++mCl[Z(LLLZ0h)`E%Xc`IKFaVjd-,lYf-Ql0d6hFGa,m'bJRN`ZK)Ki
+lQ9b0`lq8BbIMGJF6qC[ZRmB(-c9f-VN#FU+(TIPmlKili-Y!QeDafG@DVecaJEJ
+8PYRe$ST4%"p@eDhjIL$LIiG34QK%!rm$!!!!$3d86AT6BfKPE@8SBfCY+bNZF("
+M,V8T,R"`Bbke!!!!!0K[!!!!!!!!!!!!!!!!!!!!!'1G!!"pD3!!!"Errrrr68e
+38N0A588"#UX[Pkk`3&0*!!![4J!!#fB!!!N&!!!%D6Ga9hd!!!!!!!!Zr3h!VCp
+Gkc-cNfbbMf9dVcc2IHaA`[$XpV&1`[BaFTZYRFcMrPlP9%+rmcIC,!p2m4622$b
+lG5"CVEcFC"1q(KqiMfabq`JMJrf%4EC20KPXXSpPHB5lE83i1CiaFTYYXSr`Lpb
+f)jX9iGH4ficF2V,*FEGN(pN$XXrcJ+qq+cQpSS00"rjHfqG&Me"1EL[K56MCGS6
+(0TjXB2cTHjdp!!1!`+-!Dr$[l)1(YQ3JM8%hR6q(J4HY4KaSNAZ8Q,*+hKF,V"B
+d64BH%"`B+BU4jP#EpGlH`$cRdCj(F2Hk6hd"`,X2B&dMaP11XEq"RmKjc5JrmCJ
+'*f5H`EmErfAi,lm&-Rlm(c6H!!iS`eHCKE8#%jV'eS-,)b9K309H*m)QaGkr2H,
+I8EHV$PdZ,#Jb&cKV[Sc[Mi,(61)TMdMb!DPEQ86K0H-&r9"X,(jabb%pTF4#88R
+A&IhjH(GpEl`V1J@2l0SX'hp[,9B@hh#qDqEb9i-6%q'IAFKh"([-[eZEC3j%BE(
+jAb-ZGY!,HefL0c@6+@L8Y[%`hc[C%EE)mF'K2$@)*X"1`fR(,q%*J-hh!Y4ILA(
+V`8eJ@`H-0+d$M)aFYEN+1AS8B-YjqRJ)-E2),5ELNTc)XqL#9H"K$c[5fIFSc9F
+FKV)U8C+E@[b45-JI9Z-(P14)SVpQ@&iALB6r9hClm9qRD9&l!"bL'+i[jDN-Ujh
+ql6%YN8`4YH-ja%Lid5B!4eYSUcd!VmdYc4-!AmE4fY$HkK3kHf4G4dRB[JQU(re
+L0X'5Bkhdp09,d@JL%IG[8k+@i(1Z[rmKHMZHZS[c56JFJPc!ka2Er+&eS8"JUMS
+-(#j"$J4X!A!i"EP!b%Xi#MVh*9ke2*!!"4a+2mI"6TqFVh8QRhLD[kmk`0p'[ID
+m8Dp9@4c&-F"La"'4G&Q+6K0Vm+T*Sr,e94abRYN5Vb53!!L(Qh$-G+*j(!lKSNi
+D-MILD&C-k6G6p`j",r4T0p*3TmGiRlC#4rTdHkKT9XG88C,'ST,T5XLpmleRdNK
+r*29N866-iG"lSTfP2*@4KVq`LMK5[6B"1-KF!PE*IhL08#dDLR[MT[ICPbKZT(B
+mabA&2BA$0N"a0pA[m-rb)8ED5RcBI5Mh59B[+IFLMJAP2SYM6VR2mMURh%Xil"H
+8q`3Ire6Z8m5qV0a,11D8q`5-9j4l%BGpJ(*h#EV5IERZl6m8pmC0"mCcA&,FNcM
+)E!)8GjXDhr!ZIrqQMAp@h0jr+#B%8ZJ-miUTL'0"kFcb-DGd5MMQ1rN%MPFkH4'
+(8bKf[3V%JB9IN!$Q"Up*43m%TK6hBJ+Kk'Dc-N*(&(Hf8mhJ`,&&9M&CS6NFaij
+6Tc*`409mql``)CQZ@-+4k0bIap(8ZEq%Bj%iZ4CLfV*3H'F,#&h+[TQC"D#JQTj
+L(MY1UcDL'0T@D,pcaQG99)NcI)c0Q%BUQXqUE!&`m"P6#FISM1R9Q8i&9L[[R,-
+G$rY8IXBdUUA(q+#CMMd!$Z3MQTme,#9HD4A1(dV%0$8kdSebLN$@E!2id$5E!"c
+B&brh-a2('aSi0aXUcTJ@F(!&0kfB4QG$%r@"-bDl!"`&C9VULm2+p2@kcr@K9,k
+G[@MH(G*"+Dqp&[-YJ6mGVN8'TTAAU&e3AYNY!9X!(+'SVJ0fFZc68cM+XB)iX62
+l,(bkE`[!"jr+f`,JX+EbH4cc8rNbB6qb2ihMKIS`TjKUAU%i8A'AF0!Q-p$#pq9
+kj90-@i!kie0-@`!FC'jEJ$j%jV)&U!rd92%&BPU0pZ$r2G#"rYhRlS510Em`I!#
+BXL1Br[%jr*m0TS2T*hkdFMFH"eJ#Mf(QQr%0Z`K#1*Ljil[3XABEl2lGANJrq6e
+)hpBI60rZi6(T@h(J3dJ-I2kUB)Eb"61IIK)qF2SMcf&"6rV$RaZ83-ElM%%macG
+S`FapYF(-[4KYiS2U'q%ar!rKZHd-G'cj+Ekra,'FiTKr$8Fjdp@B&4&M$6M-'YL
+liZ23%DJaI1-eX*GUi)ClaQZJBV3'+SCU!2%0em$0cf%aDZ!2V3dC@TQfhSb[Hlp
+B!h$$2GA$H!CV!,&J$4$Qhm"A1G0Q$@"2m)%E[#eU6)XUrRT&X@djZi!pd3kQ#,M
+9J-Zk#c"d3B%8!`rK3C93cLmXm"3miL6f%9J8ke[A,DF82Ar4B-DfS"PEKaA3I['
+D`'YiXXjGb1aaYTB)ZqNFX)jE+FKSXB0f,8)hV#)QbAKc4HMTdImfX%)e-GK1ITL
+lDC*V-AC!YQH2RT+Xj3Hl"U[KPFeEi9#*8hr-0FL682B`XUA'eC3U4G@"`SN81i0
+U55R*Q"UA8[q#cfV`6-pJAl14XDqKF'"9eQNQ!AHe"C3+`dP)IEb`bfC$B'a3pic
+GLK&i66X@+KXR%ABamX@S'!mUb9aYi$phcS[pGQ9&E5f'V'#2Jd0,iZ+&(jCVZfK
+kcMlEdYTm0El["cFre)@+'4ASIAbK!5Fh!2fe3$GlVL$IfKYK$HCU)Yr@8i$VB`b
+2I3%F$!(1r0JHmSQI"&cXB%q4EmpC1)J%V54IZ`D(dAFGMqZ&6k!2ChX)q%li$2V
+i9X#'cA!F'5XRAr*fq!VkGT*[44bqK6lHc2Uf`52S`j`!lcd$hdIIVmMhlJIKFB#
+h(L,ImXr$c`'ZqKMj2[361!Y`p4hN@rB-r"&p$h!Z[mfmk2XQqDjFbGk%[Kq3!1m
+Y6[Bf21h%mefhM,d6I6aZ`b--Pl'Zq4Rj0[qHA3r`pJI*9hf#YD#2jqLlKA@KMqF
+)2m[`80%llLEIdZq`2S"9('[EA3`2MUh1N!"[G6mlJUm6['K28IfYqFC)H6ZIjR&
+I*pq55$+aAj&6IUaGA8h%ICCI9(ACakHYCX5E4DPEPIdK54YH$m)6#eDJX8'a0"G
+JjPjL,TCB+5erQj5-Ur&Z[C+[$QE$[E3m'NTd+GFVF8pZNC5(QBJU,CiDqP0*5AF
+hG+QT40,9Q)LRh+e5XPY*qHTN@8'D)P+U"q0j'LrGJ6#"9C&[UkSMP8UX%e&lFNF
+LH"i,UE'%BR&MZLhQh+&'%C0jkD56"Bam3m"bpjl+bBA,Z$bI#G"RR"e"SZ*+e)H
+l"&QXr`F,`+hI1HQpXVAV2$PK+b1F--)TH8E`K*0Mj"KjeT'MaYIi5YCU25DHX*8
+4rZ3j15kHil-"DcdlXRT-V[@%VC`-1*Pb-Z'%(aQYj2L4#5GXCAKqC1856MMKK"X
+Pcip`-Q#4#9I##5I2b$%biV51(#HFF-U2F(,m*,F#0qL+X!EN11&VH&U%*RP+8-!
+*)MJ!`3-E9YIMeAUp#J!%[h'!d+m!i8R8C2ckm2X'H1&Km-"X)(FaVjDeQNDqrT5
+m!!Vf![Eaja8eEI&`RUHNHNMaQ4!J$ql!BVRh5a)#!K,Xmj!!aAM"E1@jTY+XD-C
+0pMB*[crUHBp(jU-!QE"Jc[S,LUPSHS(QJ@(,,!mNX$IZ8'RQrr'Jcq0TZ2RjD(b
+De'LSdSHV*(ZUp6aK(YSN+lm,4b%&AV*'iT!!`YlNT4iXN!!C%Vr8)cG`aRaBVi'
+2kUKJ2hlE`YGCNPeU33J@X*rb3I6I%[fS,CfPlY$C$(0&qp%9IT%SU(-!%c'+1rF
+$C*Q(pRHi&,!K!B(IAN2P554p5DDapiRA-EqP*-[2#b6*GX()SQjUcD+LDMLHJa%
+JVaMQHGlXi94r6M(,fd#E@UjbJTIZJ-FHL0SE5C,PP&6p#fmP'pq69Nl1TUQ#+6&
+UU+31H)*kl23G388&KMKeE2j8IM'45L!jmAG3RIFrZd9@D8*8J@&1(FNpGIUmEPC
+UJfRSG$m*#LSUi1I6%-h6@4"Jk4mb6iK*!HVejH&!B8AA,TL51TJIkr$%Yk4ej['
+Rce!&0c",+&"69,9BNmTEe-69)i++#XirS`BTYDiAYl#G5,M#U95"--pe0+HS'8d
+TD%d$afKJZ*A,T6*-'H'j"Jfeh'K@PVHm@SqqGe3NK!U--QSkJ&5k'GaF(p&[#bS
+U-%DT,rk)AM(95XReHZc0YU#L!K'Dkhc%EjL&5Yfe#Tfj+cm"R`DU4!9eC9QT'[H
+Sh4Z,JNU9F8i0'*TjVYC`XCdjkf2E+bVlE+TC8*TZV(p5*cJeq1`1pThVNDmiP5R
+lqejaYplcHRFDBJke@G(r6HJZG9,X2-0FD@ME3f40hV`UjK89Q,+TZ"XZk0[8%qP
+VJSS+(1M[)G`SlXkc6Kb[fp6MG6MBTblM`R1TbFXp388&TLReTBGmH+1iLi&5TBr
+XABi+c23RVl!G%*fK$@H'0L$1Yh)N95pSkDC5UQQkZC86Sh,*XiiAacS+-IE2J2F
+`CIF#FClp&b"qqA"V&9f%1peV$f)pcVB2JAfLRQ%j%BL`Q5H`Ap3a88ICCL3``IB
+2JHNVYpqbX!kb@i9!L&dI"%DY3kpqJI8"DkTVB$eP6DfpMI@)GHMLjeJIY',+5Dc
+(V-3(2D`RfEBJN!#'M2FEV2r)HIIZG*lp9m6fBImY%6jf,e(RfImBE"r1haEZBqr
+QCXr1FH"Ml`VRZ"dIZlHbmiEZjhVrHREHm)k2[AZD2IrQU2am"2HG"brXSA8jA69
+icqaeA&i5hB&beM!h"f+"&R*H+r9k6K2qJr(-dKikGrm$!!d0%dek8f0SC@eP+'a
+TBLNZ0MKV,V@e+5j`F'-ZY3!!!!"p`!!!!!!!!!!!!!!!!!!!!!"[L`!!Mkm!!!!
+@rrrrrde08&*$9dP&!3UV,jHZX%"66!!!,dF!!#'L!!!)p3!!#1'$iQDT!!!!!!!
+!hAF0`2JqHlr,,VTCXF&QiARDaD,Z`e2H3!RE6jkYRFcVl*3TS4kRPjYY0X"62-8
+c6kB6XPUGR'lbI$ffMh80b*B`F[[**Lbb6m)lmTYXF[Z-(GPNcmJQQh$##51h*Fr
+*2ND1(f'%r5EX##22bHdRYeQ%N6dMq`Nli+ZRpRQGGMR`q4VC(U%4&MRfK1dMQac
+E4hKX!j!!$B`rIDqc"a!!`(d8S!EreVh`h0SdT$$SX3[R-I#5hH8E##JpDN4G&3j
+e2LLYAY-VIGH#F6kI[pAEhY53!2%)MJYSPa&mSrD,h`+ipkX!YHXaRR*NrcTq)ZG
+I4[Q*aa4B)Idhr0[aAi,rdSp$@X6r([d0B)%5I*@B@-X`S@(#3f$$5&ND#-9[%m&
+*XBmdqF@0G@eek,*K3C(C`&VpIAar'Ka'%NHTAeCkj@je#SA6L*Hd4b2Cq)V!SeT
+5MAM$XUDTfZ9iHheIY#Xm$BrXB5JhLrXk`kl4K#[R!5`#+bE#[c#Fl`!fQArh0Y-
+XL-)XV[mDFE'4AYMXBRh*f8`H[EEeKr&q4$JJP&Xq0T+R'Y'iKC1@KCEcF!VJ`iF
+!kYq"F3q"RF!'"r3d`3'"M&`V-K9bm#$!fJ[dX4"LTYcZLd9P*CCMd3DV`#%mEdN
+0[XGTA[BiP&6jC+8P)+jHXdPX$N9leF4B)M1$hqqpNQ&TRGrIr,qbfiRrZRJmc!I
+!iI-eeaIc9$D(1X@Q5$b@5"+e%cPmrZC'6J#1GZmk2J#[VB(@5B!hF!3EYJ5Y8QH
+2`KV"L52C2+jk14b1aD,L"M9X+MjKKhLB[CHrL!TCaf'4')TTFrRD4@qYeqfHVJi
+GKde5h'iZ!!kVT13*H40(AZLqb@Xm"q3D$V@IiEK5VeR,e1[aSAVYHDYHU`Ca&1B
+!&BM$,fZ+(*iK9ZFe,SrVehrL8(,-&RNPJ83il)4MYK0Ga@'4,ZQN%E-MMPE9N!"
+qXh9[NE4mRlBM$A9DK2ATbh@[pqNYhTBj(90&54S,5UBVT[4Gl6e64[SMS58+SQ%
+HKpB6lLcQUI3h[-BUiNMfF3*`N!$C*+b5rr$UTeSXDR)1L1*'DLGbh&6FdcLi!BU
+lTAkM1-H(cppHj)-VSGc2d2ZkFTpLpDCb,q#iTYcRF-`VpcPHjj9l%3Gr3EP2m[%
+2j6j0l!hPAX3aVp`RBGa5lJ8Fr!$PET-dYIY1hI-r&$FZa8cNZ+QiTh#3!(%#&(G
+l+2VqpiRpDeCI8Gc1kiS*JH3l`eA&9-"a6HR-m6'[G)SiVREb54bh1RN"Ke8UG,d
+ba)'&RjIQ1Um*9A1l$i2P-rf`q0$R"i2[ERZCRK8%3Y@-CU@(@S2lcl(h8q)c)je
+U&JH1,3B9NaQD`I(ZCkK6k6K`ibcA1BFQ*$-95cKLREYc1&SkGaGaP2ZQeN)-Zm[
+Er%J!T#jePkE0-)q#DU1m4akHBJic6kXf2Tph3llpcKZE99%Pc[+4R6'0965E9A%
+"F,!C8a((q)aT$-IV#U8-Uj9ecVQ1KheUPSqXPXlb36-G2J!1j#1FQc8X*&jT&dl
+daL,a8(LX'f88J4,R"[!4Mh-#F'"I[022$"a[DH$-E+J`BlU'JbQi'F8d2KZDV!q
+F-I%#F159DE%[MLV6fh@Ik82*A$Yl`ja---eUV`Uf*A$2jdiM!c2+Dpb'PGIJPJ!
+A!)FhV'Q!R4clp$518UbJ'59S+#qDlR-"q'"6H5i!$R-URm14RFTR1e@*Y"[CRm(
+aHRdB8ma36U&BmiTEad'Vc%!EhhIUP8daZ3"eaUDBA!!FC(BZ3"mLXh%"kJ2APk[
+B!M'Y4M[`rb(S32qfmdp$4mf[G"r!F`!GRY3[cZ2r98r+NcTer2jYH"eJ!4$1IIL
+'0S,3l%Prq8ASH-m'f2E(RC!!1Rd88[[l2DQR(#`Qp3NFq"!5(CpBj8P62Nrk5kI
+KSbFqH4%,HP*2I(e)!ZR[9h6L'EiKmk32Vr#N$f'dJ3m@EBHAm6q#CrmVd,(f$,k
+ral#m`$$r&JibTKGK9N5-0@!aDQ$RmLHK`efYqbCUB#I9`1CR*fUJE,`'bNCU!2'
+0eX#qLeMd'[KcX#&0+p2Q@f$VhQr8!'aqGY%SRU%D3#aB!i6jGr"$aV44!pJ6A'!
+(Cb!8LBG9X9j9Z5eh&l!RmQ#+J&Nef2#H"*d'-1m%k%D+JF@aQ%SSC4F@@!B@F36
+lL,A+[&D#KdSfdIaiE[rLSUdeM"p!jJL@l0@%brB"2%LL@hPN)*iJ*RZe[`qX8%d
+-YC0MQD-QQ4E$!l)G1l5NE#irm"UXQLUEYF+aqQIYdQL3!%HJj(NZ#0Y#0E[9`k1
+a(j(UVSMXVHe@NUTfC9QEe)Hq3df5J[iN%EDJD1FIP1f3!1jT`eXi,`P,b'AYahR
+ZHp%K-5)X`iVP08!fESamd5['!EC-19bmjbAmBHA[9kc!N!$P`NQ`S(lF"5)XMEI
+4p&ci@L$BHKqq[`efGUR,6[PYKpP#!djZ!*Em"ZKQcc,bV8T$$HCU)9p[(@"r%GV
+*plBR))Lq(H462J@if#'F*GrLVE!(#AU!I-jI`q2SBmY85hI"&p#hRAch0m&Ad-F
+NaE+cm%eNM+RGKhm12d!I'adYNH'Rk)Z5$pIEIiBq["f'rDX2AN)IQbPqF$qF",L
+(VDGZDi4IiRfa*aPRIi9A!HjlQRb9YI!Ap0%%$TSq+cM4acC8&eZ&aHJl4Vi(YJV
+[a001,*qr3F$HY*,&1G-#,Q1YC$2!N!",@)qCIN+qNMm*!I5a(0YY3KIk@)kYM`P
+iU1KGb#I@iM&K,c,"X-CV",`ipZ!qmYfl9cL![Zq`SRf"kUrQNN5cRQ0a2bEI!Rm
+LYPY9NL,@VKD+49fQhaI5&"HEYKS4ErI*h5&&p-VadI8J2,&J"ZSE&!Xc!8EZ"FC
+LLCR5p,I,L@JSfUe9XYA"`A!R,BpkBehUHMAUb#b5XM!$8DA*8d0r-L&VpSDZ8$+
+@X$A'SNPl8%jdUdPARD+S5*0I6[CJ2%[MT$X3"V!UmUd,D8LP'ZP%e)l-N3L@ad5
+U,k'Bh"KZNcQlYp'(bCaddXN%4Vi4B*Pl6kAN`Q9FPXm!k0,2ML"486AX`Pf#3Dc
+r"`h!H0SlkVbb-aYSD9kGPaG0lR@HhGTepQCHjh9ZPQ36YKRjcF46I0,cZ1Z%ijm
+HTdqHRj[3I@`ILp`qbI'6E-*ZNpq56AkrC,-c*FI*-I+XFa2qK*(EK"%HiB4(EKr
+C5SjI6cJCX8di'E!qFTXem)#lJ,XfBEGfR"`rr+"Hpj(IAQ5`MI`Q#0KN!a1mVN#
+IekeD1Td!!!@rL`&UeZ0h(rDkm6XE[c%SJJEmVLKZep@SEV`"44IIR2h6%B$bMQY
+3[UX5-@i@iC9fM6bLaI5N[V6KJ[h$hM@`&XU961Z*'h"&(20IH!VKPAA'H`h9L1[
+Qfl`QGA$dq#HHmT1c!+XZ%ZD+NUKUUASUDU2jr'BcH[r&qiFH2ek'HS`+2Ilh""j
+l+CPG2`,PdJ@BKIj4"%@EPjIfa[Y6!mPkcC8r@aYp4cQbImH"rDc$-"PUF5qDN!#
+2b9%l*'S(XV94YCKUj&((6klqJih+1ZKQYN,4iC3qC!8+,Gcr(H++(CKMSml48i0
+jUT!!MA3h%LTfS0K',G%0)jfA+,ZXSSp3X3-PT+XqU%j23f6[FF&elh%S*BAk"P,
+6#LdmY%$SHQJ"P"(AQ'V'TVJfMEa#U0L"FN*0a-eJJK"ehFE(#48l8%'6KmE3U`I
+MN!"Y'RaAF"em&qB5DVVh89h,cf[Yk)M`KY%4Q%F+CG,'Y%)Y$Df%LKfST(R0'2&
+8(MBE!H&Hf)%U'l8XBk3eh63ph'ccFhmP91c!I!Fe'6Ge$hAm0crm%lNAGZ!@dYA
+!&$DPkkB2Va"Al-!#QL&$lpH(-MiZqZ0EdLRIJPX*e936LE3@6&jNhc%a$IZ1`@d
+fDVQT@imQ-`-H@jb"kh)DVX0#`GA#dHX2Z#iDf%QSf)(E(G5"[$ING&dN8)H6[IQ
+mNGhdmDLBSBp(i3k*QV,8S3"ebEb6K)SGZ*1Qh*SKQe2S,TTbDcMM'`2h[)0AKHF
+G[!ThNd+$k*2jZ*&GI9NN'qc!iKD-ST&AjR@TQKhYcI@0Zcp&(A[KPj9`T+YVHc[
+[9,-m[Dfk,+PU@MV99arlR1YB98AFjXSkX)3Ve&pUmS6[J@)#H2)TN3#HI!VZB3T
+YV5SaV@JmlB2#f*Bc(i$0PA@@%ZS`TLJcMrV#EcX)PA9UE045flemf,%YiqF&9q`
+X%kK@9$Ak[d5YY9(,$Xh!rZ,A9Eqh8AQRcZ'DL2IQZGkBKZ85PI[V&kMh5Rp&)`U
+'+&[l0H(Pf)(lb22X+IHp)4YTIdENK[CRF*1!U-f(%4Ap*1j,02klBbhNP0L"P8*
+Ah$GJ@XlVqVl8pAfiRe!(8KKJSer1kbT(9`b)JlkZcFpGNXRQ%U`Q(p+iQ8qjea@
+Td"9i`%BY6UT@,!#&XHJlVB6+1[@13S0Sj)&#&hZ%3KGlB!fI[*r2lYIb6((bkPr
+m-ddHGU$"mD&S-136NrHJSa"'"erDXCHZRU(FJ"eBblKZRPADT5I6aV$2pA60NCG
+YVVbcMQE)LZHcaU6R283+iCB#&3TQ+,,b[(#[PHIKB8,9dXP-3[IMB6C5Ge5JeKf
+&pC59$G@+TjPrZ9QjGXrV`Prh[!iE#$8jBPU(YGKK9k+a6jiSSaR#$M55$q%Z+M@
+6SYk6dr!HE+3C-Lh9QTUK8hmm6ULXXiRbDemm-CeI@qUZLHe,h6@)f&0HdSDSqF5
+@Qr)QN9%`E3bPJSbb)ISViSSGD#D&6$fTcZcB6XNGfbRB6+LB'kDh5Y8I[N'Sf)%
+YMN*D*TLL-aHH2fLMXJkdL$f+&M-'8VKRqa`h@re4TH$k859X&8kTD[ZhG`HZI,+
+TKHD9GECae,IR4&06Le3irI4M,p(NXFjfQq[FR6Uk3m,DmGM!ChacmpTUSjB4UTm
+![['"8)KeGYJ+cGmDM4UiBcZ3!1#113PqkX92+"fb$V6p,@h%8hkmb6CIINhNSFZ
+[`8kD2!hphdMA)l#(qUT%I4ADEG35j0SA4%SBrhjQ,k8Sl%#(M6TABjD#)GCPQih
+d2#YmU1GCf#@f,b-C3kr2D&j@2[(Gdm391l#EAAG)e2@0KceAl[b@`MFpV!1G0p,
+m8*!!KrDHP8jj&VTXe!U"kJi4BTf6U1GJMq0jMmG6rKL0rq$T'Y)91`#9*k!'AXB
+IcZIh+lciI3@%%b*V&ldAmqf@!M8mm5Z`M0lhm'bS3"fpPp0l+GmD+9$,Gc-+92-
+pP`*,q1C+JI[iEN1"*Tik&&M&G`)+V1$E#`AZj4X6"3CK#0QccEr3MbXChP()%VU
+[jYX$"4lJq`!&eR,2GA6Dc@IDd5%&'84PG`ShH)HA',)%VTJ(`@m$cj`+2-McZm1
+h$bq*J&p6h14EZ1'3!$8VTr0AZSEjA0E$lMajI*q!)faF*qHhF'8LLpeBX@VJ@a)
+&e[!GLm1cNlZU!PhF*ahHpAb$imp9H+mLD`kpGr)Xir"ZiiR)iIY0k1&UjAL'&bk
+bLZNYq%hiSZZ$i5f-V"*k#pm,rDL&TfB&MX,hQ$e-mLjX-'4Yb[P&K2K[j2X3"GD
+42pj2HF,c%AHq`UXH@DAd&R`Rq(Rc9EMrN9@@deR-f83HQZ$pG6M!hAZ#Gq'#5&C
+jcMF%,hGZ`aXM@4@ZckmN(rCdIBK[rIkHDm+V*9PcAGqDm+QI`I1)`UkEEXj4iFj
+*eMakEq-E(!8DqCC2J9DqC9&J1r(Ib[G#cM`)hpV"pbU12ZemLq(SY)FRFMm2KCG
+9XX3pUCIcK*p[iEZb6hhGpER`4NY@9Fj(KIkHlL,2ZciAARR*QZrkR*YR`mfa,,c
+RrFcR2,rfmP$KlNc@,6QqBQrbRcRfI,9`b5CV!Eh&rQCL6e(`Lr$f6GDY1Im@19l
+`RFMcB5iUl+9P0EYqiHE)m#T2eQdjAPriDhLr*fYKcKr#r#Mf(1kmK"H!XQlrYlq
+'0i+b&RfPTkrMc(@KV$YF(Ehm8EJrP(@Rbm[Efa8Z&'AGPI0(ciHpI@6KiN,@CRT
+hm$ejX-F5HGUE`m)0TDblhAR"8[j5pfhNdiDKcZTZ5jMdQcFaP*aM1q[Z6Y0bL"5
+eXNIh)hVrpH[b4rK2$%8Vf'mBSrm$!!!!$3d66AT6BfKPE@8SE'PL+5j`F'-ZYE8
+T,R"`Bbke!!!!!$JX!!!!!!!!!!!!!!!!!!!!!(eT!!#LQ3!!!"Errrrr68e38N0
+A588"#UX[Pkk`3&01!!![4`!!)H!!!!N"!!!*H61F6T)!!!!!!!"$93h!VCqpf@8
+A*@`IiESTApR@,[EV&XrUM4&'H13f@cXj[3DEiMQ9d*26bhdk`&-maA0keMT`VmE
+HM'c#eQ1EA4hC4ii6YXPqXJQ,l$-lFPZbb@hI)rYY3MECK"%H)rXNcmJQ2,)PR'`
+[`Sj`mT`FM`bfK*0pC*YNNdhB!9ppeh2D4Hdi(CKmECp(D)4&MLAK(H(NH%GiE!1
+3!!f-2hf[X`GJ!1"r&'!erTeli2Mk$+3aD2rC-aKihUk5KcV8ILfQVBa'HPC*ZUj
++$cN`6TC$lF'Z6Fdj$r1F4AX*`AI@I19"J192!DcCJ2'8)rmhm4-jEaRP*al6i)6
+-hr$[aRmCrXXr$4NIrRHEE`!(P1'Vc-CDJ3NYBcH##b-9D5LL[df%)-8q[LRNfpc
+BfBJZ&aB8Q3ZFG6r%pqI!BbAaP)F8GDI5TdfKU,,L*@0[,"pIhE(A5'QaB&3a$-e
+i+GlGY#[H'jf'4rCKU,5,qa,$hV'%+aB!,!%R*X)r'mPh'*[-[hZEE3j%B4IAIif
+if%`[E(D*ADRC6!'cYXf(pEk0(@D9MRfMHHS3MCqGFLaf2!qR!$jb&+$T24Kh)lJ
+*E(M)6"-HBQ6NDXK9b*%M!1[2dXG$L*P+Yjb)+fUL`+),9S+(2Ha)CprM0#ql%mT
+UC89Ykr#&3N&IDb5q8dZH5r6h$&FhKN+YrbZl(IK[e2@S'!#(,,FfPI,8Y%CkI*Y
+LHL+C)QSRFXLKeKC"!)kZi#eL!&lE1pSR!Ek")pbm*Hb8H[T9hJLH1*(2ife5SY&
+%)ZlEU%9YaFHfqilaGre*e+`Q$SI%88bE9qlb"GF%rIlTkM"aZ#69laF#i("+kK`
+KVq1B%lU[mkSAJ&c%S3eb(#rADpkBqVhRq([j6[ifklArRAUYcH)ScJ'U%8G)-93
+P1N1XbDZZM1[AIq&3#mb@H#@"4$MFK'1f%eh!iC!!cZZN8A-MMRE0NRkcGHq3!)b
+j2Ze''KU0'1r6fESIkp0EJQhc1UD@NV38P8a[3YeeSIG-'HQ2T*%XLSB&(%CrY+H
+8TbE8r!UVL#1e5a#!Jm`PBCAmKpF3eD+TZ0HZqjLi4(%MY4-j,L[ZD4c#!-AGeV6
+C0mq((1SUm5'%81kQH+`rH5qp,bRh+9B[+rFLMS[+I4l(JR+Ijh9"ZCG`L"H8qb3
+Ire6Zdm5qSGa,1"D8qb5-0j9l%BFi3,Ql*%2VZe,hiJr&[AEGcSNFPaAh&!ib3B$
+LlSV%2r4"hq#kY5mVlUT,LJQ"c(@'#iUTL11LdTRRBd(TP("Fk15610lXj%8F6UR
+Bp5S3"aEqR$3hH8eUKYpr$"bI(i5P4lq8$AjAjf2dV#B3QQ%e+c28'6l%1lMcEKp
+Ah0P10BX$aaCCa@5(jR#mrelU9#B1h$JVG-lK#FP-a4+14-p!!8GEcd!*4k8mY4C
+Lf9A"eYXk31V9lM#-'HC48'e@GLXM8m`4jQR94TD$'qIDli,a@499iL`Iq4R6ZBV
+QXbSK!!iqBbVK'*maRF2aUN+T`'VPRA1qif'IQZ8MVkAcI0"-4`b!!rQ)&QB0LiP
+AfSAc"4-a24)peiebLN$9K3&mk,SJ!!Ifa5[pc-,aMJE1cBD+-kD,1,L#Qe&-il1
+KbIV!'C-S!-HF-Lhea6&PqREGjrT3UY$1AV-U,TKQY9Feha+ijSZRNB%Cj69Z)mS
+VZb8J"-!4M"S'B#I(2Mf0Sa`VD%B*@XU,T[Y#!$li9&i)J-1HbKG`j+Ibq8j9*Jd
+Jqc-iAUd2DiSC+5J8jjcL0R(3+M23a[H9HZ966#&!RI%TTK!!"jPE#0#(b&a#J2V
+!pH9D[N"-Up%Hr0m-hHMIHZBHk&lpHp-(F"bJ1j!!rYdCr$mE5!I5Thjlh9Dm$V!
+)#1F"I%-R3@J0C,jf%VT[f!KERpm"kG123[V3B#"pYiI(T!rL`)H3!*MiI,@"$18
+,C,jk'QjriV-[BN&2qM2I(TC!j[YTNhL1EpJ#Q@-0JFa4M,E``C*Ym"Mq4r%FHKU
+kecq&lap`,)p`c(q%)jcT*CJ9%@-01+`Df&&r&h6lkdcI4!hXS"UipB'*'UJBVi'
++d4T!I'-eF1"&,'B0[""ZcY$+Y2eQI0hlY4U!@apB-SCRZ!B3#pB!BIi6r*JcEG8
+!pJ3[Z+'U)a,6SjU[5G1%,AFAX#H+B)U!@afil,X!SaF85$(`%"j8!qAm`J*2`50
+1B"q"bYLH0AeU5M-+&`eQE6fDZA9B!9[1Aa0i#dr@fBR-hXpZ)-,fR`(@IC!!JX`
+@1f`h)A66+Q0$HP+MNb['2`C@U#D'fmRMZD-QZ4BM!V,Yfif8BLmrL"UXMPFfG6i
+f@Z,8(h-0mJ5825`%BC[9m9Xp)KVl#ChEUE9[-dQiUcfq,82UBe5"#"6+GKKerPD
+-a,@+Bd5a[!,)*Bb4,fE&H&"*jQS$rlPlAZc2+ejSD-#3!(Vf*$K32pi"2VKDlk6
+T1EZ[)paq,Ekr#fjqU3X9-bV3BhbK!5Fh!)N(J@lf,#0Il4GJ0HCU)pqfV`1ZMl%
+ZmMA83"KpfmRRr`AJBJIl!rQUGGL0"&e2[VT2`ChSimY8+`EJbqME4Vi0qq%Ek11
+5`[eVZ"mCifTAf3Xr3KmI(I9r%Rk*[MMjj(h`+r4pNhc,![!Ep2'CiV8Ri%Q!DrK
+kkXhh`60iAq`ZmPhr8AJ@SqmKhbIkiDrSS`NFh,519I'XD-CIf&,d28kqID[BHj%
+KRZrfEl%2S)r(E9R1F"PV"Cm"ZKpL'a$CcmMAdXBkd-GcV0*C,rTiMZXU'4iUHKr
+bL3H2$V)p!#XjeXM2'9iF@h@!I2A(f@(dICmAl508Ik[25c6RFccZTq4E&%SQ"M3
+ejF2D05+*Z0Ifba&$pI*TUaAaEPRTLkLqS++2V3IKL38ld0bJ@*`,X()[XKC,l*5
+f[dY*aL2a2U1'V`jQ`kYSH65Bk08fD(&2ET'8KeQ)DQbHQJG65F9`0rG'8SQNUb8
+46lR$5V*25hNE999$QN*+UKrMHCSUZJ0K!DXPhbd4!kR8BMf)fT-l%X(cf%M0*45
+E'mYY-qF1YXLBV)T11YR!b$F+,(I[UCaFZ)c,meN![HEC%53UVN@pZ%Z3!-AkI`!
+!!!h!d@&HARQC[@FGcHZLG8Bjj9l[B1fkPCf$2+i$YbIKK'e'IM-0Rr4PYdii[Z[
+bbA-PamKQqeMNpV%)2`NRA$,B8M,C*q%1P"b2F(,E0m*2`XKY`JJr`XNqXYN4(L2
+(Vj0`-Q,l*-qZMpaQf92J,Z"ZCC[bYH-4Y[(CPEV*EA*F-YPX%d4X`S(*#L!HU(2
+3USA$!3"Jq,X%S$+'[mpJci1rHIME$cP3Klme"DfkekFEcC!!FqD2"blQ0*rC1A%
+D&J-FqV@*V)V`LMT'(YIkpD$1cTpQHm&,hjU9Ha@1Ir-I[2ba&i#YrN81ha6L&EI
+lH`b[iGHM(iUkZJ'c@10CJ,DAD)lrJi#Ajc2#N91X#YMl2[BQl#U0-$p8!ecL6&S
+qb3r3Db-4VIBhEl(fcY%p62"XM,9liV!+'L'AR@0,S"'rGHqEJ#DfQ#hC0m(1)JI
+bm(d1mRJI1rJprSl490fX[@X8jN!6IXraJElrL,l(APFhR`iR@bbQiYrM92L,L)5
+k#@$"3Jkhqb+dLaR'rJSi&F$G8(6P'H`mJ8KrB(ILYpZHareeZFAqFS'jFDqZYqG
+fH$96++)H6q-dCq$i+fp@`@K(4f1Vk14`e-hPKG'BcaqZlIm@Me!hRIJF4VFhlpJ
+Z1VQ%1McS$83cU+qFE508hXP$jZ8dr#U[6dY$BShA[[iA*P"j"r,0@BY`3ckpedE
+'[AbQ0[3C&#43!rkH'G4rl,A34#f)qB0kCNG*e#)eUq%2pGfBY9LLkV(G`8J'GIb
+N4-A1()kk-EHS3`q'M@%Ep9MPk&XQUZL8b&RpI5&[i!D(5MPI0bi[kN(8J@#YCU(
+'Uh`IQhcP(CKVSKEdS+fa-39UQd*YJc*#eIUp4JCer-LU2j%fB!I+D81qiC!!2K4
+,EfMKpKr6V0L"H5CU[KiDc)`+FCGR(D&L"fia83Ye``KR9K4I9Y*,U0L"qE4A(C9
+bKJfZVX0beUl$X)!fe$X3ZVkKKE[QblhZQJqhdUcphQMrc+ce)fm6+RCJ)D%'r0%
+dJa"ecIUpK)SGZ)fBKm,3SkIT%+mIr%611[J*,#,8F-pZAF[`Y@VrL05'r50`1fd
+S%MDZEmKGed5Sf)%lL+m4&18-E0`&8Vf`!hHDU-84)kcTd@J+0pl`iYm*&6[S`K9
+Ud"r98kMM[hrq)e)[l+"R0rGUS&fEfHZ',bl4V0L"#Z+3!+(hk8-4'aIem31PP"r
+!8N+0HJ1"X*CQRZZaJj)0Maf%Zdc81DC('8K0LabB8'bB3+G+XjTqb*jedF"@3X8
+19#C3"c,DN!$Fkc+*1KcXbIL0q)B[pdX1IENId2F5DLMQ(8UM,TelK&#aJeQ#bI,
+Bl,$*$5dRPXH')lB`#-hEH9PUhXl,X))f0)JkQE%Em98AT,2"$Y`M82Z+SL,(XAe
+H[(lIde+9pcd003Q[l$9Qr1ZN%eeTSKE[QS9pqGhbpde8dEPAX4cTN!#1$Z*92j!
+!LS)GZ)qBCql9$J(LVYCRTAUe2SYC$U)fl%(8F+MAEfpSr0a"0r%91h!rX@%JK)E
+)Gi-0YBN0SH%BY$I8m1*jTC6Ri3(+863K$M2TbbAPbbp"RBPD%26'qQG5#Yr(6B6
++1`mQ0M5)i9"k3fHkjBE1G-2U"'V3UpRM(RrMmJN6PAGJ$D'L1d68p+bZP5FPAeH
+HK)F3&EC8&#-NCk`pDhQ*RfE&$Ma-XfVKB#5Jff)HGe8IN!#c9Kq!4mMC'0kB2m`
+c%F[C9(@q*h@SmceB5kM"N@KXMpDraeV4mDqH+UB0B3I@%9qM-@pXKUp(rhbBq-S
+lkdNE-'m)c5CcRbTYq"3fN!$Ek28(VVX0GrAAdLYAI`dZ-e8UE%(86*kA6*AUTCD
+M+Jq&dPUqe[GEQK8ld%!ELZT"lf`LFP3P)NGK)k'L+Pr2!#Uqq"fKBJI69,8K,C,
+QhSR6,qdd8AN(h$*MmfVE'ceT"h#NhNh-ijh0![A$I&pS*X##BiHHI)-ia$YEc&P
+,YqUS$S&Bmj-$eqC0-Ur44#dQ9&XTIrLjh"$[0*NEQVICjc-`fpJ4%0Sh$AldpDr
+)$r%1i,f"d$`0CGN)erT$U3cJ`LRT'bkFJKC#4HBC!b&-P[keSRM&P6,*ebYPX2@
+Ufm""dalP`MYUeRHJe83Y406HY''$mCp&ZXMRB3ID6045M8X+"U2@CZ1ZlZHN$R8
+r"ip11Y'KY,2THP@TekZ`c83YNDJ@L4$V0BAk'ZErLN0lr5&lYH-r2e4*Hm81G%J
+A04)am-a"5lRH&hjbM&#a!jhIS%C5,XUpp$J6e`1m!efQ$T8hKRekLq(Y#qUKf$r
+p3e+pS'`-dajmBa,,EdP%QBFQcYC8GG#EL5X'"XA#K61SSAH1b0JC&0#lL0kjiK+
+"`8U44M"i5(K)"[H)*)6"I5)jB&![[!U$@Z(6'D`5f3#$Hd8H`@!3KR$k3R8I!q)
+U"TbXA&8T[4m3MTj"RI$S$1B)KL6fe#PiPYK$##+)@M!eYj1fUjT,EmN(1GpDi93
+CV"Eq26&[,piIiHA2p,cCR&j9@A,20rIUZ(T9$eYm5Xel!(l+aj[QErD53&8j[EZ
+)VrRLBJ)[FF605Q,H4iAq-pJQ&$dari-LAE(jjG`QU*T(lfEKZK*cEaA1+$([Mk!
+E8IJ&cZ5FcM@$UP[S,HHEdNG,$jfl"eAck5hecp'P&Z%AE4ilqBHU$8RGF0(mkd3
+'`k#3!(6bI[)9+6faq19FF+KD3'mjlp4m+AjPEce8hCVFXq6CP#qDQ[X*f)'SZG0
+cCkp&9)PEYUZkiHK[pTj%e@f@hTH3!!kRpVT'*)hrpMI1KBUU4CCZ6HR8,i(I+I,
+EU'piP,eT8A8l[6H,e)M"HT(f-@J8b3k$,65r@f44#6j)h@S5@8jL2kdL!dRXU9e
+N"`bHJP'qrQQIN!#pSP&e4j+A8rb6HVj**'hIkVUPFmipMLUmLjc88ERre0kPVlG
+dcVRS8B9hZ0Gdc[+e6ZkXkK&,jflk@ZI'5*@m)jEcb[cNIca1k@VfDNP9KB40jMI
+Iq5,RcNR9dU4q5am[jjhbmii[bUEDUKSX[E"mT(1"THUZj&cIkDYcUkAUlU3q12j
+4jK`@AjaV,e@9rp9Ajaj-eE+Eql6h1(Y*TUV+fQ2+If4[c96KRIZeZ9,jAIBD6C@
+mQjr+#flNNYPl$98EkGdQ8[CdMLApG)U(fAXj95XX[Q#a[bf[`hPD-&alfG-5L*V
+Ie,b,)G9&RPelfU2i(`eUlLEqm$bZpde-U)r34HA8m'ri40m$!!d0%@pP+'0QE5Y
+PH(3T,R"`Bbke,V@e+5j`F'-ZY3!!!!!eQ!!!!!!!!!!!!!!!!!!!!!#2V`!!X"m
+!!!!@rrrrrde08&*$9dP&!3LY("[AX%"5X!!!,dB!!!Q`!!!**3!!!r%m8PrN!!!
+!!!!!'C!!$F$iRUhCf53jhAD%r@ClhEl&IL8Fckjd-d)*McaEmcJplQmUdddr,cI
+KEKUHiLQHUHc`R8G@Mlh2)pZeYZH@E,+I-$,Jj0NQfijX-YKN%lVC%5jKqfa%pT&
+pE"rC([Rp(VPY!phR%8k1(lPpC-!(C"rKN8hf%bE`eIFGTaA0irSq@q0jd518NpY
++H'CNNdeiE12*"XDI[YIC!h!!%(`!B$hqhBGFD3"AqM&`$GH#kl!2rq92(kBhq6&
+ZZ5UY&IFQJY+!XBlA0*'reiAjSp&B@k4V@a2R'r10SQ(`K*eBYI,R!18R!6BdMik
+Ha4crr*[%c9VC-`!qT+2@!a"!MQiE(IdcihEX2iT*B*Q0a!IZ6(SAKJ'h%6$l-S%
+INV8#@!FBqm#f@'"lBfFMZMaB1f3HF0Gr&GmIJ`SV589C6"$h#rh5"44q+jlA"a2
+Rik[D"h9$5N383GFPr5rah[#"C*mb!ipX8iD0B[Z`cFj51C([QSAmGH$'42MRa[)
+Ga8lcYrajFb%+Qmhr'R'aR9lBkp3$aPbQN!"CfZE$HZrNMR,PVP[(mp3MQL$h-*a
+b23Z2!,ch(S$`fc&Z)hJ*E-H3!*QQBiJM)pIUE)8F1`D`CC3q&N,-P(ZMDP)3e6b
+,(PJ,&GaTE1hfHj,QP8GJ@@e8%&[E!l&B*0!L*rG,UA1*AXb`SM%@DrPIfHh"Ik1
+Q+Fi!1+,4PR!T6h@,h"[BPY$8P%(86Z@)aPUD(3*`G%9ZFJEJYDfpE4VJUcJkQRC
+eZ2RHZ+MVDA$[DS#k"lkF59!cdN(2bV#J++UD$'b9&&[`Z6HHqJkpA8pqP[&*1&b
+m@-"E'Hd+4$C%JX'CkM"aH(Ja'(3%`1(Qa3)KVq!Sk0aAH0Ab3*C`5!2DA,e#Qc4
+NekXGQUhANH2CHSfr@Dqe'4c&-8!9iSJ*ZLJSXm5D['V#T(ap(BHBClE%+`NN`Z%
+P((1GD"'(LhpH*ifE&h&Jb4CbQ$Md3Trf)Jf0HZ+&ZMIlp+j)klb1UD8Nc88PdkH
++"dSi5NEk)k@RLU*K!BFH9hT,HDTM64GC44c'!BF!('3H(U[N2lc'U"C0aEfjiAh
+1*BSEUCh+F8Pacq"`$&$FVH(YJANqSV'Z%Kp1(mVp!UZAP(X4aj*bRmHaS0cRH9e
+3lL8F,bVhlF*"`8P!Z8rcm3rP2N2XUmUpK'0"Z8r$H%fj&h%i"bKh$kp,rCIVh[P
+$F@pZf$q9ij,L[S#$c#&!FAI*b4[H(4KSf2b#i[ErA6%KN!"#CeK86%8F5dTRRSm
+&T92#XGM*Th'meXQ,10amXH[j%!F@IN'DQlbQ*$dBR1RN934#dUeQCBDH8pbC6M@
+(!mF@'F9NKiiT!ZT8*Jj&cVI2X3R*E-85$V9hAaj(Dqqq%Slbk)@e%-ZZL,6XE!H
+q6pTl83[06M&(MY1U663Df9TS[`['CP98LA0mR*maRDYS0UYb"-$"CN`P(*-cTYG
+R1MkX9YBjjcXHpURmM'P55jrRJfBkcJ!iN!!2*6pV@%kmdLTF)+)Q0&NjeifbLN$
+8(!2id2)cR58Ff"F[pc-,ajXD1$XE+XkBPR!`"6HVQ#CR3p2eJ6-QT`!F"@9DkSX
+6b[6IGCrY3dDqREeXIMBmQY0H9@a,i%p(9L-$XmTVdXD89fC,`"%!4d64GF"1MRe
+k"NFC9Y$X9-a5AM6GG`6JJdhP(3&`f&2j2)l&UI`bIKqb2i[MTIU`TTKbAU'i#p0
+(%`GY-J-YI&qZ9cE&G!5S-cE&G!6!3HCe"1K$C"j(J2T!6beE)+E9k!Vmh`MGk0p
+ppM23[IihTJm!8hD(dVmmLrqR3ZP3qT&IV0Q04`9Ui#(-I"MId%N3@N,$Grm3ZUr
+E#VYr[`I5Mci)k6X'3ZP29E#Bp1dim#%N*Vj!E@LBmS@'2rdSh2,`RFpK38rkSer
+)55$crB4*2-1AXp$`bG@KiAX`fX)(G4q%Kr!rMZH1*k"lbf2irJV$FMr$r&XiaTL
+Z`kb)''[!CGA!RP@IK1jJ[HQEUS%p9!-l6Nc9J'qb"RcM0B$i*QVJm(0Bc"Vi3dI
+6-+e-ffq1VAZrA!1`id6G"*jF$5!@V!(#r$[i1Q2DUJ(X#CAJ"AqlR0!8+4#@*-H
+@X`[B%jeJLS"C2AMXZ`$M&a4)-E!3&P30CHc#!N[")Vk2I36+%iFfp)Z'T1F['Xc
+C&M4ckp!(Zjkr*[!'RSbc%jNpcPe(K0ef&VMZfbR)E,%jfi636Gjp#8(%bbYm2+l
+rG@#&DL,A6Rk@Zfb5D6&130E6SaZ#[IcJe'$eV,)cE5pArqbXKY8JX4ZH4VENT'c
+)JL)2&8kNc*JBPa*5Mk)+IIqU&N0+*H5NB,`"(pQXcalVbCU[Ec!T$D"BFL*T-)[
+f$431R%Z9m#U6P04P0DRIU%TQ88LmZ&IN"8a#kZ1PA6B(!Z0bZZImV4LHD4AAQ'+
+j#!MCGR)TpTbC&91"5M*E'rM2R[2LRPhhmG8I`T!!9G`CF'NTA,`)`!UYNkERh1I
+E1pUZa[FTm'B2GAR`-"GD16fZ1J&dXfFPqEBGKr@BUj9mfSm!emHi,[*G2`)imq0
+kb,IM2X$&$Zj*mPhj+cL)"+dKha9K1)+qpj!!ljBih)8qR1d"G,d92SFqYK8JPJ&
+ZIlV,b'H%i@[SfdNqT42Z3aql"c9i*r`BICJ6i&Brr!4p6j2[fK%i!r#13I*GA31
+r"RMR*mMhi6A`&%EF6Elhr`$qL,jlbGGcQ[1Mlh[N%ll0ABQqRj+[i5lZ+McYa2,
+G)($ASir&pFJF,Q0GmcMjk[UiQa(aYmJA2XQeSirPD(f3!%0CG#h,XH*a$Jm9[HZ
+,j0ZmJ6X%X*CK24MR2J+`ETKmQdjc4p(h*9CYpe2pVIqZ9B*9q(m,1Gc2X,K[NUm
+bPP,h5D)4L-Uk@'-lXC!!UGeAXQQV&I5fU0![Li')S%fX"q'*"6[3h+"BRJf`FYG
+BLb9f5Y[I*D55FV*IVfDVJjP`2bf24Y3qk@BT@C&G*'9K&U*UQkUQ!5-Pk0kQ2YP
+38jjQ0@Pi1i48[f480SULK$6&"#11m5b0Rqj!@-"UbAH6V#198U)A89GNMd5`2$C
+5F`R&jXCbfmaj)me461DRNdif-2+0!m[HHbSM&blMXR`@`%Vcl!J5PC585Y`Pb'$
+p2`!!#d!!kdP2Mdkm2Um)e`KI)i``FL[K6eE#bB3Ij30bp()JTrcaFBSRR%VS58D
+FiLNqk5Np"j(91#A-iq6C5LDFF$,MC-,*Fc+Kj&FbiH4S+bG-6XPcm[b0$2K,MKp
+KNH1ZK"mC-(,mb)56ij)"2h,mb)56Tm"GG[55RdRifeUG86,M"$'FF!!#%"!!9Yr
+KVA+j!)$4234SNh3[N!"Qd+h3R8F)Mp#Gd+E19qf5kj4,f4(e3D6Z!e+FF-@i%NF
+ENH3*q6cG@DbB&FGfXb-B@khKF5Z1ai$`8aqpMC&p(V(iR9$6Ql0@hLlDi31H+RR
+DECjJ2$dF`dhHS6mP3apCb8a%FQE9Y%Zjkr)F1,Tj&'l[jrcqjSR$1K'QqhY2I*3
+k0")"p"M6Raql!G%1b[+R9h[mM*0VDeEbRF[d[VE+4-qfQ'kmKBFa38kDE!J6R(e
+K$j2X&"ZkX-HZ)3b&[TY3Z%i+[DGl5dD``25C'MS`5Hmj(r,p9r)pD6-,h"dj1b9
+FmIINLQiL5ZSSd$r!F5[I34FHYLLr$TRIDk6-%HPcGMqpIHjebQpQ613A"KZMiMc
+jC@`f6lejiD95eD'85IUP+GXlliGB,@hS+Dj3ciJkIVSV25q4YiQ5UV(,EVk`b"9
+b+kKDdE5XFQNTQIqMPG[46SI9-P2C$&HJL)3qk%kEeV4YjZb+DaJ6[hPpl`aUkI6
+%Y&$DZ0IjKc6EpBTlafXMhRMCmmS9Y(Y8p4i8M3GHq94558'%*h3Z'R'V1DIFJQ*
+lp1)2m(,PLLUT'qYQ`Ee,hERfM+4b4I1SUQYA9iTV,HcfD10GhbXT(6keQM-Vbrp
+51cfUpZ)pl*ZI4,r`U%,Tf[GDF"E[HMeX3hG!V6LP[a)kT2E`[XlG)1V'QRe8SXE
+Jp9hC9e)3&5er)P,Fc'f8NYDIc@[%,eheCm1PUiKjAM@D$HXdK&S6CF"m9P**3Hm
+qP5C+DqBe6ZkiNNS+qVb%P,*p&!qGLfpmIFDMFJAphRb0"GX+$FUNY96m0GIG69E
+M8jNV1#%5#P&#0*1G9[@S!jQJ$4N-q-dMTqG,4mdlfDclZ6EV'16lk[KTP@m!5m8
+MDRchV1pepbbYGHXdccqMKheLhr9@3k%FGcJi8IQYL1f!34-6MU&$INI%2'(SNYr
+GmPX98jHK8m`fKMDa*c!-LQ3B`Q*(B@JAQ`"$VqJ[`i$)Qb%QTJ$$#G%DKKiaJ4J
+qa-H84ZqY2)mE(jbqrfc)meD1+8b([k&[XAl[jhLm6`E(crq1Mq-0-cJq0iA8lhR
+m-a1$dam%mq0`RHJTUPMG5"9FldfFp[EfErP%-R5hHQ#IrKdJC-cDbhYl`52DjN-
+*rSDRr$m0$4"[C5KcG'4PH(3T,R"`BbkeY5keY5NZF("M,V8!!!!!k$B!!!!!!!!
+!!!!!!!!!!!!!STN!!,ep!!!!&[rrrrp069"53eG*43%)V4`Eel"!8UF!!#p'!!!
+*0!!!#5N!!!2&CqDra`!!!!!!!2S1$F$iRUhCfl9bbZRf)YcEV*AE)*BViAKfA@`
+c`MEGj0RDbHPaE91C%[UGZ8mh1cc&8`$QiGQYlj(9SeacflR@pYa(0VPpK*("*Xm
+ffAD%Npp(0Q&jK"rKREdGfH6fXAhNq*(E!lE*2VBRGLc#bI%MYim-q)$X)cbbbAl
+#",lk[Z1dfh6!pAffa[1L4bJRYjA`c-JQQr$BaT-0M$p02lX!"!!)R3"BMArh2PF
+D`*9q(&a$!A!Gm1'rr*N$G+BmhJZSE*9Zp,!"ihT4df6a3G'&pD24@&ZNXlP4m)h
+NKM(`mPJF@llXC`$Pk`$@0!d2RmBDrrbEa-e%fE-!2U3Mi!%))NGh$!rrQA-lmKr
+')V$%4Z)$GkDm#kq"X"D`qK**(&5d!PJ(Q(K[FbbiZAjE2DBmU"d+$lKV[i,RMd'
+&9D5L,#E*Hk9HGJj&TA9Ie2FR*ZjAYHrA$CD)a#9GCrTIlRXEqT-pm@Pi&1XbE"6
+EKaef&IpB[@[QkpH!'`[KAaLTG`JlcGrUjm1&+'`fra[%a@BkBDp6qihC5Q&6fZE
+"1Qm9$JRPVJq-eUP&0#(K&(c1p4bF!RMhI3!0Em0lDm&,B$X'c6)GJ`)&T9CN&A,
+i--$'BIVi&@+Qh"Y9Nj+XjPRd`#US%)jMDlI2ic3[1`K,!P&*EQd2aQ+4B)Z5h-Y
+5C`Up@1'+qPLXjAqbfiArHNf,1`2JL%CE'NTeUPZ8lQ"c3P06"P%l@5-DDfPb#-$
+4'ERC'B$AY[Df+B#[iZKSh0lK&V[lC&e2Jh[l"UJjmD9-JD9(1ZMSEj!!iR&963B
+hXEKYq0aV(rJQR9e2ICEc56KFSPc!kipf"L0V)U(3Y$T-("j4$S8F!A#i4EP!b#X
+i#Mlh&9ke2*!!44aX3*[9+l5a39Z[pY@XASmFcHUeldfp"M)iLQ1!+X34Nh4CLXm
+3Dr+U5H2fpA8FFTlC%UpNN!!)KjG`c(DL"4`ZmDa2'Jd[iN$*&QUB124#RrBL$I9
+kiJAGQhekHk4ecXF%U%K6dFRdU(*r#8FTb(qNp&640-cMd2[LhD8keE('mk`L$U2
+I)3!(K8G%PIb(eaKTdA6FkcHmalR%F51eNc8Z11jT()i"MVZeBA0`MSpSV,2%Kp1
+(Fcr(kJARAX5ak0cRF-`lpcPHjjel#FH,cRfcG*[N*1$FTrMiKh1I*[C9jel#-Hr
+FTf#mjYb,1*`$R,Y(e&R[4GdlIcMZp4[f6YDii,M2iD"`#($FR8Vb(6F&"cDXIm&
+a9rlG-5'3!%*R@("-44b,6QH1MhQR8m+ad-QRF,c@bBXih'+akrN3"`UrB-e0AP0
+-$i@Q1hN9J@#keDc-UfFFGkC6cH,!X8A'-GPA4a`"G5S64ec*Ymq4#FQ-BJQ(fVd
+RMk1eHdm*4hRdh&U)&CG'@VDfJpM$GTrh3M06c#0(DG8Q'SeX+V6IqH#c+P,L,"m
+6-kBcLZDc+NF!((c'9-)a2Q0kIDEM3lAbcMRAmE"2j@G-iejkJJqDk6J$i%!qi[P
+C`bA%+kh#"50U3P2LClT4eK()QQ-!(eTqTV1)!r[LaAjQiAM6!fGR3m8Cdb)1lZ"
+Q(02iE'K+(cKMFJV!8A#QTEiijNcrVIYX(c,blHcPU16$SeR[9F@h"2jdF!8b-11
+maQ2%H@@f""`"F%6LZJlBbE&26q-S3`A06-8XjdA6I8F!2[K8hK%!Kcf9cq0BQ-S
+[%IFJqc-iAY+(0F98mJl&ACJqQMKSNaPSiIZLA[N8da&!Chb+k3L!Jm,V#0#(+$b
+1!2V!6)![%00UG!Aqkk!,mcY1I`Dk9[r'c!&JbDj`qTHRmIpd1"e1RrVjY6[`8B'
+PF")V(m!cE#-),H'KZlm(A6GXJKfrh`ATahi)kEX'`ZP29I!lk6Yai%0)6(c"3(L
+)kS@(2[dBh2U,Mck2"62TMh`KCi(-mj-Qm4aI,X*$pkm)$pf(Ybem820q1)Rr86a
+h23PG'ar(mjFjPNFijYr#BFjd$9C&a+J"Pk@"AFXr!9fK@M-hUB&GT)%YabBei"[
+AJ'p8!iK[6!-(RXGLDZ!2(Be$Y$*YR`@ql[fb"Q$,XCSa2$N0)"E8!'(q(6c%QEB
+dJ$h"$ekSE&F5@T`&'aKcE(Pf!AZL%i`)H05#ahiAB23&"A)-r!Ur9!ePr)8&AS,
+Iq!lf%5K2l&[6+aY-clpS-"XE-FbY3apX2rZD`"Yi-XPYb1a4i3BLl)l6)(6G5CI
+-&TZ,G3MGj,dm)FQbQY`YpZPr(9LKQmLeNjrQAME*Y"JRS0Lj8cFNHrR"U5&UZE)
+cE5qRIrkXKY8JX4XH4lD8T')S8P`C,$b4-Keb(dZ`RA&9k[QA@Jb@5LK*bAJ$2V*
+CLkrbR1eN[Tlp56D!CXQ*T-%Xa0I31!JZPH'c6#bT+fT5Ve1C+3SQbVYP8F)Lj$j
+HfQ9c)!JKjhXQhSS4Z9GaM6L@mi#3!'dR&l(R`P4-"6V*V$E`Rhh15hKZjFN9Yq1
+9jF+Mi0*5Z(J4K#ZdE63p&clIhY&f0CiI!'rfS5l2rIaB6SH9ai$Hl&P'ZHDMX"T
+VY9*1qclJqTM35ENEM`$1r)5GP0[b-1"LKr!8j5ll&Gb'"&e,Z8XEi#$QhNQj@r[
+JNjM$f4j!jq9`$qEi9S"F"VMpk5kMh,lEiDZBfdUjbj[KBFcapk$UC2J"jV!Q3(m
+Gr"Kcce"1r4%m#R$PIXj"&(i0F0A(+HHr%Ti'Z2TZbJAH"hr%h)18#pmV9',Zfj6
+li)"`'HCq3VR%)@%P2Zh%kc8r*0b)1Ak[lJN"Pl'ZHB*b0heAZ!AJZQp3EXGkS4e
+c[-C9p`KSLkicDa`Am+'LYpp,Z3qp5pJ(X)TM(6`KI"MJqL(+qAB,Kc$h4Dkf4dK
+rUlpP5E!+rfqKK2YCIZrVR-YB5Yh$C#-B9A4jUCe%)91lpr0TUhATV9'T9j'$%8N
+E@`r#*aEXLqB'a5AC#eEYTGCLL9h5cRG+UD55l0@VqHTJjRSP,Bp'e"jf#dY@C"G
+*q68,8E909H1!NC*dEf12BUJT6j1D0,`G8UUA'Ijk@@C)8d`bq[!q,e0*ld"B`!+
+8ZeR4N8U@k%E8&GP()RJG'kQjK'*cBk9YjVb4TLJ@Uk3RR@aJP"X&PRh[UBa5Z)c
+,keN!rHDc)dK8NXApZ%Z3!-(kI`!,3!"G6-qZpcVCND1%RH5C(@(ND%FBSB54#6X
+ME+$XePUC%BD2L@IR%AD5%G-mQFVd,,)D1d)[-U#5'H[)K*-**e0+TT`Fj96#DB3
+6&RRq(KQ`Pa`McmLaNl!M!dD1N@IN'$PfC-#1($XbBH4Ai#kV#-d)1h,-[!CN*60
+'%--)!eJ"!J,!kVXeA5MN!$#kfi(!,ESINfE3lD-l#`@lk1l8MNb860Za#[C3Gf!
+(%Qe!JK2QMIR0@%FNH452TeXMa964-TfKEX6'bYLEhS`pJ,VrjK9d,r+)aHp1`6M
+D%B(kKKH3!$cY$FpPIZ3YqI-0dXH3!-IcCe+PP'PR(XUcl-Jl2Kl(frbqmX4K)DK
+d[h$&hEe!Yar3)d`r%AX'd3l+m[APjZ5PJA6@c*YGiq2TVRqZdI[b'"-pQfDk8F&
+1a-R*!QY(R,1RUZKPQeMl9*AGJ`SII5r!ah95k$hGdc+#BDEhPa&%,lhRI-MhMq4
+ld[U(Z6YbYNQiiZr*&Ge%P03H),U"imirKbim6&0q3CRIEk5F*Y*GYT(H([qGmZZ
+2LIa8X"J9Cpq$b%#@HR2UJPfb+'@5PTXb-rHr`XT*3dp`KAT'[d-4,Cp+T`[fZDl
+Xahl0K%-@+`mH'4VN#P6KpAT6-TAZ-e-CXqJB4[`$GHkrV5JRNr%qSILiei1MQZQ
+i&9ca1YX4IHTkj3Te9e!$hk#Sl*rkeD9b"3dmS80K[e2+@)99+'CkrR`*0eHZq#9
+emQ)UjhbQcYdl*UPF#EM8J'1@cZI(9l%c2E2rHPj*d6aU+C-UMRkR"PfUG[BEpSr
+EiIXZ95LK4DmjDq5cek8f00DS4F[qNY!5Y8RdG4Y4*mI0Y4*9YTkXbVk5JQC"RI$
+R,f8QlDldTqE0GV6P[GR3PNIBpDV4E,K)3qL6fFU"q@(TP44%A+qqJVPQP(YpHIJ
+[kC88Y($UJ6(b5R25@Uh$l-)[-8NP"DeH'fKk6GKVEGL6Z5N6)JA4a9aTjNfXjVU
+[rfp**3AVA@T38[-V@'*GV9'[BS1l0c3QcmLPiIh1)2F'MC@GE'k%+l5JlD*jISF
+HYSV0e9hbK&,[F1ddbfp9E!F-!6(K'$6jh5$Q#80)IMI+ElqBZJa"-GYSqa&l!S-
+LGK1'G@)$B)L+9M#X&cNcY)TZ-B6&&'"S%3ePD")6L1%'D2HQRLrR@Cm6Y42jB81
+Hlh*-S%pp`[P[Fka[KVAMjErLSciTDNIXXG,5Uqhd6i+5S$EC4L,RZ'qfh!BDV["
+CBZK1DC'Qd2i1a4J`4k[9fL2DU*91rSERma-!$3d,EfePCf%Z0MKV,V9`F'-ZYE8
+ZYE8T,R"`Bbke!!!!!(K!!!!!!!!!!!!!!!!!!!!!!,!I!!$)B`!!!"Errrrr68e
+38N0A588"#UX[Pfq`3&04!!![4`!!!Ui!!!NP!!!"8Gk,AM3!!!!!!!$a23h!VCr
+-eN(*hA6E%4EGP12hXFlYdGYXCEH2TCX4IZ6CHXPXXUQFZUR(2%ijfH`-6`h2D@Z
+YiAq[9QHAQr#epV%ZXTp``XMYNfc#)Mbc)lm**lGCX51El,FRQq`RR$"b@l)**jY
+`FYZ6m*G`#5I2b1+4`6E*2V+2E,,*Xi#[RYVRFEA,LFIAb2%M0%)j1Hi4[NJ'Qfc
+##GX!C!1[*r$lf3A!!+$Z@B"Dr(IZeh4TEAqS)4cbqreVDL@rK-%rlT!!`PT+5hZ
+eAU9E$Y4[f"[iX3-l4b,4PR$EYNEQH4d$#mBV,X6heha6!h$m!'$0&Z@HT+T)(G[
+8I8Sk`r%4qY#kpAlrbLkVZ%@48d1Pp81P@j4-V+mc,RHQ&,2idd2&1r3Z1D0%Nrd
+4QA-D@VIK)UHEN!!3"j6K9aN+JD3!jH#dU@*V`B@9FZ"J8Vp)T&JQlYi@PED(@N1
+BFU'J+&cJV(S5[lm#(UZ*CiNZ*rE+hFS8#Up9(c!1p1EVrE%$4NET$DGN`e#-LrA
+ZKMke+c80Mf)p,,A&r5l$[Y''0bd!@!j1E)6rE,MI84`b9`JB$`HLX-8P!SMYa!J
+11kd[-pXPD'VEr,#qGl#ME+RMhT%q9BKQ06[$kKeRi'@!1di!0(`%kpD#QiL2(c6
+Ea!mb#NV9j"4bl"M!aYITadZ)QDAZL+E+#E31-q'#@m$$RR*N"lp(Jp$FF$q898E
+N4(0-UYr`'DNTUHj9dQ10l!l4D2K5Ka@KD,6T[j,EMImKA8q*!A"%)Nd0T6i96FP
+1D9Z[VU8c41e%MdLdDE-J!%GEQ0b9!)$APPM,*-!V11+0Gm@GJFip#6i)AMb9lq0
+VN!"6+8e6TDe+bRCmV%-kbEqVRhQ&6bc%i3K`&02KLl4*i6AKZVTTGCJiA)&%ACd
+3!)FcN!!S%2)1MS,4IBGAI3l))JkPRq1iT0Gmj26k!QidE,hZH9q[PB-iLRX!2q+
+)bNC#6Xd3Dr+Ubq2qp9mi%R2-PRJPJd3ih)4MGK*GaZ%)[1'64X+01&S8brV0kYi
+4-!TcfSddK)aH2UF[kYkFdhH&QqGp6#8ef9ad-PeDSZrbl*N+mKpT)edd$3XiM$f
+TcP+ILQMMQk`LMNbI)!!(K5Z!+[N2Ve(5BXQ6#d!F0e)ldH1Uijl')3a`h-d0fk9
+j2L,4YK)ISJrR2XAU9HGHa,(Sh1Ga,$MhH9iAR(X*KhM"Z8rbmIr1ICVB+mkpK'2
+"Z8r#H-qj&h')!jbl+f!ShGGd,rj`h(JF-p(MUZ1H`N%K#($FE8PehDHNrJhePab
+hpeh(K%!+Nq'bBbVL@(3kmh`X1*d5MXZ6I",(Hj1mL--C+%kpFX5"`LpBFj2AY',
+8eCd%aeIliIS6haJXrP$VFr6T*a#+B3dVXp3C2r)DrhjBHQaN8XhL`,A&S'1b5h-
+i2[%B65S64bSj0ck(0b3cLL8F@QI2()lQcTi5MU@4UE-3+ci3EYS4J`$HSKR'$20
+SU,E,qq6K,HB`mh4U%iQ%YaE'ld,`A48TFCD2r)jT60&m9b8%`-&h6#8FicZQ-4a
+[1C4b9#ZIR2-6$qI8,"pj,jhRJhBkBJ!Fb%GUEYG`(I&+Yh"iQYQV*e0MdbMR#"+
+k-)!2A4F%i-#jH'fH@6MHpm#jh9"aal5)JcZi'FFd[KZDe!IZQ%3"1!V1Y$3A4jh
+T[h@IQd1CZA(fGRLjBCVeARjq*A$MemmL!c21Dcb'RGIJPB!3!%FiC4L!NacRp$5
+1*DLJ'5GS15rDlJX"q1"EH5%!$RXV2iFM[jA26kUb3!qb2i2M,AeB@mcNR%0a&Kb
+hLB01QB%Z[UrTP@maK3!kieY-)3!1#VF3B!j4Z)3!qX$cj8Tq3%bRd4lm[ahD-Er
+cr+23A[Y(-`I`Di$fB2E-HIar0CJ0CPpqiHDGq+V!-L#FKr%E@JP#8h$J@mp!qqU
+YX22[Zb&lpPR)(ZN2CKrfm*VXPh$K3dK-I&*PF)$k"3FH13ZIHr(,&l"J*[[!id-
+@b2`qCa,2m3e&F1"N6A$J"&CEq'$j,RJ1rdI`($N(l4YI`HqIF#a2FmarJ@1FkHA
+B&4'M"Kb@"RCA2`MYG99QEN)$ZdN$GciaSB(bF3f8MfJ!mBeUi2!&,+B'rK&[(+#
+6DIZEmA2[Yc8!GckaI"62N!!'%!YUJ$$r&Al'QEBdJ$2""fl`aT+p1VlTd+!S`TC
+h&h!QLQ"%`+-+A1Cl%ZJ3KTp3)-G!0HBc#K@`K,q``$[`LP-i4jcqh'XPZ$`ZV)m
+RBU-9iJ!b4l#dJSXGCkXTjHc(XAVV4-[Em%%5-bViJ@4(3P2[5AE2Vkc363b0Np1
+j4deb)dB%&"dG4NDfMap%$9(&P8fMF%crI&aD!r)8P$dP"''E9I'hHN3dmA0kEQF
+C2RJN+fTA!%qemmFbiJ%hXbME)G6NHSl!RkRU[[1i1rJTCJ,FUcL'(FZEJ&c#'2Y
+L+XD$QXTT!rpclhQa[pdFVkR"NQVf%MMd0"jH5,"#EkAY1IYH,0kb%Vpr#'lq8TH
+EqVY1mS-'h0`!p+d!HV2R"Plh*04LVfE+VImmi2NBDk0Fa3-3ae`(j6ll+m$$$[B
+RbM8r![Z3!+"9P![&iAl-m@1U'MFmK,PGP!ZA`AF`abh&J9e`("RMETGp%(!Z12R
+UU2SSr!Cc+Z9ZqaVm$R2ITCcrYr"lc2'GiYh2`dX!0r,ce0ZIKcm!I24"bKek#&i
+&@2NSj@,liCqBS`dFp$c1[*MM&kTIU'EABqidjHll0[XB2Zh%qadkcMk*19khFLr
+$BkbEq!j32m5f!+ck*HA8rf-ac2%Hpc,@K6RHBp9TKJm9I4cja,hd1EBIi"D109l
+"[JK`kf(+E3*f&(-riU*pQ[4AqiC&Fll'khj"Z@A4Y0DM*$)5DYG)DUV2cNH54X,
+(Yke@aBFMFRFb)BAahE-,jd(ia)*GD&j3A*FVX(S[X`j,l*Cf[Ne1UdQefkMJTi1
+$j9ik(JeVAFS@4IAN$NPjQB@S`ZDTX6q6PJehBeFbSk9GQc8eiil,k@iPi`XP%JV
+5&*8cHl#HYr(51a!@X%V+E8SD5+A5LfqpT6fj4b*i(aZTHB4LFf1PEHEFiFd4E1D
+P*jeXB*3E!CCllfN*TI!BPrHc!2V-CdH3!#K95IR`PQ!3krm!!!!!3@fa@!63e&X
+!HS9kceHXAVf+HUZ8X`*GH5r6IU+lY@FZq*hfc"LI,hA*G1h(Xqj4#628+fRhUBP
+,FYi5qUdA(%jqEUHJeRqG0XSeFecK8"E[#)aTajeI&fUVEc)D'LU0fR"dXaNrQ-+
+MITQ3!1I[kE'ADBXFhC,[J$&pMfXPA`kmP8@12YEiFcj6LhTV'KTUE5DVlH-qCae
+4X#R@'fd2aEG[M(@ERD(LYVDh3prhk1JC@UUjHPfc66!6[jQM4MN,Zk!Y&Zd)GaC
+hrDAUHhpdk4I5UC5!bkHkRRAA5*8D082YCMbaF2'aIlZJphhT'k0)eG99"KbLT$I
+N(pc3FcfY$3@(0N5[iL+e@lTVaERpa1N#rhAAcJPCXqcXJH"fQZ(&X'db0hPPjMi
+e&5TdIm2+5#,Y1FfHRV4h8&qE5"iXK(mJd"ZDc%l,'M+KKf"lD#-"!!!0$3adD'8
+JCf-Z0MKV,V9`BbkeY5keY5NZF("M,V8!!!!!%J%!!!!!!!!!!!!!!!!!!!!![Ad
+!!0FK!!!!&[rrrrp069"53eG*43%+UbqAD,"!8e-!!#p(!!!89J!!#BN!!!6&kaR
+Mi3!!!!!!!'T%$F$9*6Y0C[EVCPIX0cXm2bqM+4I2,Uq6X'hN0PXlQ9Hq-Yhdj23
+ihB5PiDRKkFYZc5HVaBrfQpaHDl12h(l#Bq6fNheH!m+6h$l#bI%R6,+0P4hCC"1
+f'@'EE-V*8Ak%l@H%%GC&D&hN1$P1IVmCfFIfK($#9q#VklXf2DkAR!jmYND14fL
+%FR,F)l`MJddifB4Y20R!q01![V-,J!'!ia4!#Ij0pmHEQhYk`"l(md-2`BISh0`
+-mqQmEKdXL0ZLVBVBiT2@EpJM(C-%a(Dl2G@ZZLhPc"V(Z*JIM-GAIk89`&i,X(V
+cM35!r'kL-r*ETJ-ZlqRKi$I6'I9B3@I8iaBk)eiaR4&[*Cd4Vk3(!c-11L2HVA4
+#[&9d4Mb*cSLhQYm'@%1h%Hmf5JU3!)HR2#`%+J@B#DD%9'`0Q2'Q,1hcKbm+D5`
+6RpcL%EH@eTCLbS`&4@%'NrhlH2iX@(83kib`l0XMYbLM,!Vdqj+kYfhirUbD[@T
+8DA-&C&99e)[h,@AY`DE!'$f+1b!r8Gc[+@`E!&`q4@!ZQ"!)rk`Il`JfQDX#$)@
+!,",&C333@dN4E(DKpZJ%LP1VEHfJRqpQ4eLqX2m#MKhC1&J[Zehi'r3#I1`S30P
+(m0iDX*!!m0jp'Sah(k1Je**8K@$VKSeaq[J98LEIiJi&C9mSVD!CLX(+6JLaj(N
+JL-fL`j!!9q5@I98ei[S0fm4+Ih#2%KN%5L"i2+kh%4D@HMb9rbZjAIJ[$BF$aJ!
+mh1l+XKa1BD@r8Gc5&Jj&SL6Y*3bhTl,#))"(R@Z6-B#Ze6A9)`5[m[#@hq-e5Bf
+Y2Yi)AMJjM'-VN`1"8#JShU8%%Sk20BJma4Eh2-)l&[)3*-jL,'cZ1Y'efZ9`M&@
+(aX-Xq4`13`!H*XQA%H4G(KQMqkkZi654D4j+KeCm)r8k(1cH[Drcmk+eBUTHFH6
+`J4j&54lC1F!Xj1'49CmF'"G@dc8X$rRAIr2`TCA0k8S'LAKBL-G%*lV#3j!!h[*
+*&m+#2+S9hIT0e,dJUCNqE8%C5Y8fhUH6G6r3Tqpa98hkQ#)#UFJkQDD3!+rp5Zm
+C$I)I%6@503e6206@3'-1Tp"6IPP9j"&Y0`MJ3@'@X%Sqd09$YCMcj!BJMKZP[B4
+acA'2m6!-F0a9C9ZjFmVSiIE8jI3`qR$ZSkTHFqjC(Y21IC,(P(1Ie(A+ZHGi'#m
+ipa%prZAFai5pkYac2+DFq`L0pjelPSGaJ(-h5kV5FVhZM6mF0ql'A-+ijVK(H9!
+B"$MZ1Rp`h9UaBm2kYaeh`AZ1#BPN1X-9aj6P-Hed*[@BFMSj(PFkq3L2pcYjPSG
+*bRDpQFJ$#cpMc69G)iVUF(5"m,N1Q(rd5mR,#fT2dh%@N9"8[9PT9dhH3lb6Qai
+@ZH01GUS*(MLf5$UQa088MeXIS8kPm3MidqfcId)bAV(%)p5i1mfMUR&hMNHqHh3
+Y4)pjVXUlDd"U8TT9G9aj0&4EjI[NrLPQ[r+dDZ0fZql+Y0qTi,-UUX3*2BCR6)-
+9c@G9KJ!mq)`Taf0SaM6)iaf(-K1VPAI1bBk(I@T#Mf%[2D`(cA5-!ALJ(S(dV'%
+1k8UlF+)Ve"Ef"`Dl8FS4q-+'!AU%``B"2,![AZpR1SrrHZ$8E#JlBjVQ`4hFZ'-
+DQJf0e!I1Q)`#H'5FDDi[$MM6rp4pUJp&dqhXRe(!$G1%pjV&Y`5@I[%F+M$Z[)D
+LhhNPY`3-!ALi!US+f-Qa6iraQ)%901i%GHG&dhe$!$hi90i3J%GL+TrQ-6b9(qj
+8HG*Z9(qFac[eS8mar@Q(BXSiESd(V6)$EAaIVeFqa63%U$-qa63%i%&K-36S3a4
+Q3i$k`2AP)Vj!V+e'-hER+C'GQE0G+$R&Gib&NTq["rZhZf"4S!Yc-Ebh"Mf*#$F
+FES92P$J*Lh$L2hRJH5MEGK$kAKY!V$I`6l)IKhQrIJEaGf!q6(cLThZM#"A(I!b
+%Cmr'6hrKmq`[ajiPD5L2plkUiaq2GrmQ!20kcqUFMR-pjVedqYKMIIRjQcYBkmY
+@+"9+i-0rk'(RrY649iBfGVli12klfIRP1pMj%fL'PLc4pI8)kXD$B&pB6'GQ"B(
+G#I9B%lX@2`Me$VZ@)`QKhKRleC[iImdCFmCkcpkm#l@H[Ie*T(%!CJ2JB`V!+Tf
+GhqL"qP8ciGirli,BZ9-31p6KM$eXjAGL"h(S48`dIQ+4Xj2`R*eI2`FlAMM`$bk
+BL6h`f&qpjCfd-Tdi-llZMIM%VbqFR9e,R*e(AdRb`kAhl8r1(H"ck"@ShrJbRTm
+Q,Y$01Im4IX#9RSZSb"LV`JB@++MaYi8$LPLQ+)BYlbjJ6c5#+3)HGM"VldQJ3qK
+r3X'UZ`EY'B9#Q-&Y"%IJ0djL(c&Cq8XPfbj2MXGMSal'!@*Hi&),C[B%@d@#IIT
+0l+,2A)+m(4mNdD+3!#p)0[K#`@Crbq6)#Ye%AcXjNhV8*09LM)#LS8'0bSRP"k1
+'X&0PmeBi@2qmAHS0mL6NR6!%8C[Cq9Xp4M6a3hTZaiaZ4ji!-4j`-p0PfmHDA-m
+Kq$fP6$3RZ3rr%[FU3VpMZ8c)E"KMAl5+X@S2mHLeJIr8HeiiHISYRcFYCLq#%)l
+JiS8)#m1e0$eRhkRa9Lr$mhI"`QGR&X)hGr'&"TcFi$$p*0#E2BXSer38P#"@&HA
+ZH!j`IBc98HlM[`![jKSSYh-ri')(qah(F&&Y#bXSTli%Kc((PkRmTI"Pc1fNA&N
+&I!Ych&,XrbNmJBTaYl[p"+!E0[(4NEmGISDj)19f[!V2Bqj4bQhUK9pLMXm8ehE
+$L`",qAVU`MIJ9B!E(k4F5`'m"V$XQj4EpbMm(A028kk`N!!9B)j[U%BXE$lQcR#
+mFRB62Zh%mCEfXYX`aqqCRf)iNeb1%blF#hL1E3CBm@2+cINSUm%Far!pcTS`ac%
+D[XE`SD*E8%qmB@2h!a4cV[Nlf@F!9KkJh+F@X#1Bqai[fQkU[j+h,*VTGAl[4j5
+ElBQ%GLZqU)LeUrT$39XLlrDV2KZIYZShER$,,AkIk*,$!qY"q-4#iU+f36%RG8(
+(RUd[PL3J%rNk14,d"e[83VikQ,aH3-ZMVP#6XPN*@P1,T2bDcUJ`S90j4c3LUjE
+b*Rmd&$&AK)*4LeH1Y#K4@kR2Tk"-(MRDL[Fj6!'p!k%6+k,F*Vq+8LTYMFMDQRS
+NJZ-NQ'T,+!PYp(4#1BZV`SeJ"I5N8i)Bj5i35lhh0)05Z)c,mA5#0ZhC%43UU!4
+XZ%Z3!16kI`!!!!c!V9ekIHYeV9hRpHDJNdXS2m)**Cb5!5H8($m[HQ6PP*m46L9
+mM5Yj6MKKj&D1ck5H6(aR"(maLh)bSCa`-Z"NcXRc*jc`Nr!MR(,*8ljHj#Jj5KJ
+j4ZLeFJNR%diBH6iLR!`j'I+9m*--@%G'R"`$ET!!P&0b+j0,q+h29NEB+KPa)fM
+"%`j-m!+Y@-"H[kUQD3!!`Hm!3%mCS,F0Y4Kq@r%lLEpm!R``i(XqmS1[PC6IqB@
+8`e06+qqI*0mppL85RXD[Mhb&,eE%4h8BFh3J2bEjZbF$kc"+cSAla5qhmE[ISH!
+hR)6@lULL[R4fq-R*&iGRpHbLCXNq4$Q%@#a5*I40jh,88Q`UBPaL3R$TDc)hqG-
+ZK858p6[N2qXer%j$#rVL!pqTccS8`e$6#@0aA2dE9abr-N(HR*pjCCiUP%QTIU5
+DDKA*UCZ5ZSRGmPi6KU)Z'RDq#[lme&Yq6U8+TT46&r5XBZK[D$@(9Tpp925+#Zc
+Me2DdTL3ebkjj90Lim3fR8JAD4+mC48h(NeUZRSDYkik[@pI",p,!JRXr$B@S3be
+%)F#TJFb$%"8ZcHD&3kK!1kHfC45VPP9',IdF%&48S%2kDLh'VA`Y$XAaDh113pI
+QS02T9EFE)BILHc-cJSS+6McHDeDl''p-P-+R588iK!S%49l0a2Pi4UN&$pBqQ[L
+$8kN#)C%KdfkNPITDZZRi@VS*AD*A5e-04Fr8Cm-R[di+Ke#"EZ'VREq3!%LB9VD
++ABX-[5dF3J8181VT8)M0KVKUCKIde(Mk,qUh(a6*#U1L!Z%Th$+HqL+)e$0mJ1(
+#F(G5EQb(B#8DMCaK5JqP6RIjlAa50qmfk9#I+I`'V&HQp!VUmT*Lf!hUa[F[##T
+9$SS-TG4icY+ADPbFMbhF9kV!)8jY6DRh'QA8Uf@(HV8-IGbK!2UDe"EUC(6cP[6
+e&[5,f9$2(+permFG[&HU`1%GAp0*h"ZUf,@ajEM)+bT`C-FK3drFGfJhH8FjY5f
+[Cl4'(LV8!GQVT@I[q9UK(Y[aPDd19@`KX[SUpj8U-1MdUZA2Ch+0ASYE6UqS$&(
+UkCE1PcAE['#T@M9&Db-V*8jPbM#R"U*DaV5@kle@U#1#1QYH42"$kR((9cf&5qA
+$LA*#q"Uc6$69rYIA8C%m[ZHpAYmf,NqF%mP$"D!cKV[$CIaKN!$G$PMjQ1,ZkV)
+FETKY"`6kQ)X%HYK%)("%[!I%qkKipl)*6k#I683#KpJ8*R#Bc6S#"pNX*h#!l5S
+%9[rabEd1b+)A&@m%Rci%HLhC[jHRjMe#9N[9*mq$(,QA$eRdRZ8Yi-maYJ2mPb2
+heL*VRqG"MJTiK`1m$Gc*8I1U)i[H"hIp'@4EMCI"A0U'%REE[6FrQrFN@Ala(Q(
+l"T'q$3Yp5,`p&qDrHpQ5&I"`f&2Bbph-C)ek*[K8R9rZc8p@ZfH"6l9pS,Dh0+q
+0XMUm(h,ei,iTUl2Ldh(KNqI#A(8[Ul+Fraji0Zc9lLeA9Y$cB"rFK#[BAGIHIY+
+m'XX+9I`j)IBTciEmZhGV@9eH$rPh,q@bZMd2mSp&IRrNFA`0iV,mEZ`j`qDr'EZ
+"8f#6hYTLXhCqaa##ra3#AqbXPVTp@ri)Id1!rSCfp$m!!!d0$(4SC5"RBbj`F'-
+ZYA"M,V@e,V@e+5j`F'-ZY3!!!!"*)J!!!!!!!!!!!!!!!!!!!!$)B`!!jH-!!!!
+@rrrrrde08&*$9dP&!3UV,jG[X%"69J!!,dF!!"4@!!!*N3!!"-&YE,JP!!!!!!!
+!AUm0`+fIl$5[l,c0YV(I,2c#[B@IdGZZYBpGG$2#McaE,cR0,#V668rQFES*lfK
+iDRK16hCikNP@Ue[C4Ck[YGP(pKRK-E*RAJ2#1l)RC"q,-2H4IHC&0YQ%E8BBZFd
+f1ESPG*20##1XLp!fff3cFT[m2Lqf#BpYXXNQQc#"VllVZA,kbHP)[VB*Mp!)jH6
+B%pk4`5DEF-)fRQaJr1PlR6d!!i#5(S"Lr&Yh4a9KEF*El[1kA+l5BX%PS2((hB)
+[+NGMcRLE*,5'h)S5FRr2EF(FIRqJeYG39F%FI@M$rL(l9ZPRSJ"&p3#PPG)$iBJ
+N0&9&GNQa1-G(k,hVlR5j9VAS`E@5+2H(P[@(9NVaZSlQS0JX5eV`HrZ$YbNYBP`
++K"0qNA2UAEGKQ00lN!!3#q6J+`F,J8S"&S,9S)UY"4Y'LZkpB@@B5(-CHhp930M
+LVIHLbiB&4@B$Dp(hmId4F1K*(!X8-E46E*A'8H6Tm@je6rYS[+YZMaUAfRfbU+U
+51Ka[,qq)Y-J6m-MZK&bMZ+mbl,b8F28FJ#9Ja86iC`2j$Q'6Z8E!L&N3K9&FCJ#
+fK4M"CKIYL%pPm@LeV6hdpcCfL19D(Kc-8i4S5PJ[@frTKCF!lMi#82j1M&X,GL)
+qZ&G,%pc,b-Le-PdKMcd'X,'22Kj#c16DrG')'%,T-'Nf@!-1GXb56,d['D&CIK"
+b#[aLU+C1#!4m3R8iXP1+$5AkHiCPhN#JqVmPYahrAN@4c3&`q2h9jGNmqGAKCU'
+UABR'iN6Yj4cq328QN`!F$6j59bB![0E@eBi"[)BM@(&Id1TZEJ[a4[$FmG%mcR*
+4PU24L,"CNJh&ajU%,[jHdAf@Gbc%BA&c&"2Qp$F)[P*I5FP%G@JiE1j35BNT!!k
+V1c4$b"XiCS6Z'l`Udd$QF8J*MZ29HKfeG,fHaSQ'8DpYEp9V33T(CJlJ3K`"83f
+*mL5a'Uq+1+*Iri8M0-eXPPF55)6$6MLQ1Y%9("Eh+cTTd1b)SeE5TGp8h9[FkNb
+IYL-0AV@GpqRKZYIkp(fqQPNG8d"*0Q@86%Xde('Ppi`EkBqB'XZ)KMNFDT[FR-f
+6(kKiM9A%%Hm`#F""CR0MPIb(e`$9SUDibcEFDekLZ*(DbcQZ+qi*(+B"LVZQI)X
+`biFrd*!!jF-83VPViR&&pa2d[UVFaeQpVY`c11D9qbb11H8qbqZFFXrL-&p3lQ0
+mr&1j6a"l6EPRFF`Tpc%BEbVh$!lc!19ZFkY5kifk0rp3h'8EGPl1F9eaMq-J-`P
+3h!hKb,Vh#)N0CDmUlVbVLJQ"c(5'+iSTJf0HkFcb-DGdXMLZG2)a('pfmJ`1Uc[
+6p4BL$Lcm'@QZm4U6e*+5,V!mNS#P4ckC#Rjlr8PkZJL%T1V05JZe"JqFjqr("Dk
+i8jeU#JH1,9++b3K0ihMA%p5T0"abH,Tp$Na)*LZ@F%5EGdcMU'RHNF@4kapI#p'
+Yd&HpV3lFZ)ZQUT2-Sk$D)Zi5"kDB!mc6UShIlpXmdhlRM-qUU"+Rq"LG-3e90*p
+9Q3,Ji$1Q,)k4'G-3MYF9bN+X9YijCcXHpUNT2NDep#JI00-a"m#"I-M6XiE&a#[
+Y`Z&UCVX5PSHk89S4K"66!$i8a53!"rE&'re-ar'@"Nl2KM)cTRNFA-&0+UD4fG"
+BIH#-b5`!ai`bcIE&5mVdhh@IlN2akAEf$m[MJQP+HlRiPX$0RcL$$%`UVa%E8&k
+T,3&6!"`q@98"1cRfk3NF#l##*T@JVVaSZQm+`!HIbTX#i$#QmY-i4UIbSjdUald
+$fCr%mATpk&2-m,4#XFiSEJd(V6)$EAcIU&Fqa63&U$-qa63&`%&Q0`AS3f3f8i$
+k`2AP!Vj!V+e'-hCAMm"1,GjU+HlK1mD@iTqA3G&AZf#jh)@q*-DY48dL`%d(fq"
+pa4l+4ARkI[c`Xe"qlhlS[cD!ZIk'Ik,p+"6qqQR-Icrk&F,6Gl)hMURkd*m%bdp
+2pjhmf%GCAmk(L4VbBpaRpIa(qdlm6SE#hY-kTU1FMm*IRFa"@CAb,ke-X,Dc$["
+DLZ%GIqaQCrk8k#p$*lZ`UK[rAm(r#AEK')UKP5YeIJ-@GH0q+&UfKYl-!4Cf&c4
+L6@aIm5JdPK4T2U)3'Mh*Ael%riZHT#ICHrVrYb2ALlBqL6$f`5)!2+B!V0V6qB9
+ZD,aM)AcJcpXKHDB(NJF5RZ6M$Kk6h)p$,d+Li4-+2*f8cp2jq60`rh2lAXD#RZ6
+$hrK,X++69UD00q2VhTLIm2@ETl0VTDIcb,N82PakhrVNNNYi$Tb$aSeRmId8BB%
+6(20,m!aRHJPQ4F4B&8k`3ejGZ&h"Q`lPNQ6DFRF"Hk)C6"&`+`+EF4GJm)+#3eF
+0fKQ&I&M!C342`511BaqajVE[,X9M*CR"mC4Ye-dmJ-a",2A)l'&f"lQXU"KXYep
+1Z4i2NQL@caFNQd,4b!2KeYQ4&DU*rRCb+Rh8*0eLc)#XU8Q0LmEbJeQ$&I(+jUe
+`X-5T2kBEj(()1@B+`MBViVGkc'MX"h4Zai&5"lHd*q51qB#DQ5rEIY5NHJl!(bM
+USBXi1hJD2@kZ95`$LZ8e3$E6'2QL9B`$DbTG'rK2hr0L&eDIjr1Q&HajX#JaA,`
+3B*P56p0cpV@kB1dUI(m(l(afCUImYLkqd)#6'i#(+S"ZpL`RAr$68)bjDXLhjqZ
+!kf1XJAa9Kb')[LCHh#f!LahX"I+eIJjf)8'hNXrlE6L)2Vj-jFb&6k([Jq5V@3C
+I3KqA&1X,i6!baYAZjQF!qi+9MilL(iHIS#p#[YV9m#ck[XbjZ3eqJ6iq8qcB"mm
+$h-cA8aqm"Ai,m(q2NUriQr!L`+S[NZpY[iHrSZmTmZefXccdm3h9QNIB8[5G)Pr
+68RB,RRELq4Dr`0k02KiA2FG`*VND*e`S`b9@#A$VMcMhjeJGqRL1`%A@JMkHBmp
+QKSH+EN-qNBrIX0d!DcM@`-rBK`"ZhdHqA6hX%2Uqbi[f"09Im5X5cAUHarf3!(b
+,!V(S$LN8&l"feA!diM6mrV!DF[*TUajaNepX$BF%(pipHhNp#%mX')(D"XALG)#
+HHj'q@'+N02`0BL`5MV5UqAae-"@H4mZM[QL,9#P&(1P&8KkQ)mShH+T)a'1LDUp
+S#FHM-GZQD#4Z$iUa9LRZp)C#%Y)8%10Y'-r6j0%G#"eB!IRZ#DY)TG51YpjLM[5
+4#*l(3+SYS4MFk'k$1EY[Naq6jG&**`-Bq3D"THmp,5!A,Z2bI$T!ThCf")Q+5,)
+6G`P5@2m($-#YAAV0E0"j[AQ@4cLKr-L[r#JR%dDH8m*TC1@8(q@%VdIib[))*ja
+``XQY(*p*2CRi6NV`&rXS*a2+#5F$6ZDF2(r##6m*2m)TBH6THB`FjB355Si4fUf
+%%8iQR(!bi"0br-L)Nb'RK*q%Nq0'4T3F"@k3!*3Ii5Xc#EreNa'fbXQ%'d%,RR"
+JXJ)!iE'![Aj96G-!!)+r3`"p@`$p,DM&mEFCIdrKPiq"$iCmcd5qp6@6VEGr)PZ
+pdp0,lce%[RlN-b3mJEmqmMQq@"%Ie@%#YRGqi4pm6bPBZ8e3iA'Lp3mk,0%M3'm
++QS-a4AhqE#JHMi5LHQjHXhkRF03rK)(6#`[861R&e)Y"*Sb@IL#2IMVl"iY-24H
+k`fIe+[kHMXHM9'Y#pkQIi&F-`e6$kPp%V'*iBjfmF@lQTA0835DMYL804Cdhl(`
+&[$VeTTp6UB,GFZUFRP--rA@Y3LdZ2r@`k"896"#MYQBd*D9CGY@M`YSAAh)U9H#
+3!1JeUkLC4%TEU2BDhVcTq,Tj%eT%'PJ3lk@K%(1SK4Mi16@3!,dISX,PD&iiK!S
+%1,8PUeMc"ke#SI4M3&"4J9ETUc@IX2,91"6$0mii$Ydi!fe1VlTG$cN8hjfC%94
+8S&hdQY-Z*6**SqT5iC18)Ka#"6T%AXhNq84@U3B29MkFh1C8UN#Rb*!!DGI65Rd
+YhA*m,Gf#,Y'VTDQ'SQGVXq(MRdm*Ke#"EZ'VREq3!%bD9Uk#ABQ-[#8F3J@#R0V
+&CN0#0A0cHMUFZ8[pk[dL@@*89+"RQP%lN6V,"aL1pre*ZACp$*CLXFJX8hU&VfN
+eX@$T&rIEG+CA%qq9+Y$(UFeTY3S8e'YE$[AD&[4cK`*f2TA5jQVNe5F,[`+M-Z8
+`TrSA,bU'IG$ZkYShc`SU9Bk)P0I5`qZUrk-flK"9B'!h$CN8EJ!9l-V%BN)N$a8
+Bh2A9d*2hI,dYIEd04cQe*DpRYAU+bY4MXPG,cahi@UBH&aP#Kh5cRU%rU81lD@#
+V3i9EL#brc00!&6MK1+6PcfFAkJi90jeH84RQe2BA00ZmB+PD*AXVSdXP6QA+L1J
+eTQ90Dl(@DjND%Y5SH3R"$kLMMUpk'TI+"p2VT2!eETPSU[f[Vf0LEm!e6kh[3lJ
+K6cVcG@-5aN9HqAEi@Qe(Z6,jLXJV+Y3Ek)%VG(9JY`Y@2UDiZlSXKp[$GJS#rFa
+l!XIC(#%`+0l(a2ZSH"pQXjV!%6Cp#I5a2B(!!*ZV"(VCYN%Jb$BF!Kr!CHbbiij
+2lR9!&X[([NrH!IiXrjdMp`iKUmPc`*mK0T(rbj&lqC!!a@p0AJBj+X"9l+jV,dH
+0'iZX3f9r6V!G`mYJ,Pf(%RBEh*ZIMHZ1,(SRT"9Ldjp)hdD%2LcHhJAq9HD@HfH
+5jIG-Q2phI@)[Gq140HkCi&0PIVNA1&N"c`+IU[Y!G@pTh2jNYASrj1VqY9&@@pQ
+R8H'6jm*FGHqFXYUp([CUpl)UUm2cB"pFK`hXVRY[2fRFF'9eP[dj+IBTciEmZeG
+N@9eH$rPhlpDbZMd2mPqGSihlQ+`aci3FBC(IaVr$ec!ZaHr%RcCXrXh%0NkVGAT
+VLdIYr+ia"2mT",li@5fpXb-r`Qm)d'pS4rm$!!!K)30YB@-!!!!!!!!!!!!!!!!
+!!!!!!!!!!!!!!!!!!!!!!!!!!!%G!"d#-!'l!!!!!3!!eb%!!!!!!!!!&J!!!)B
+!!!F!rrrrr`%!V@(!TV"!8h%!!!!!!!1I6`!!!!!!!14p!!!!!!!!!!!!!"-Ek(m
+!!!%!!!!"&!!!!"3!!!!brf4J!!1+3UhrB($r+d$rC%*R,`X`4Lm),c`U+LSU5'i
+(E@&M,R0TG!)!!J"6594%8dP8)3!!!!!!!!!!!!*"G`)!8dP84&0*9#%!!!!!!!!
+!!!!!!!!!!!!!!!!!!!!!!!#`3&1e!!$Q8`!!!8CcG2lBCMC)EIpJ5'lrm%kkk#J
+J,IpJFJVMU#Y!rf!JEIpJ3HMq!#!)8)pX"N+Yrf"J0J5Y!!!#!2pJB#`-VR0kC@l
+qf'BL5'hrC%KZrr"1ZZIS)#hrC()+ikJV32pN"Ud!!!(rrf43Me+%Z+lrl'm!rfa
+J!!+X3Ulrp($r,8$rm%*R!!!!%!!V!!8"'!(f!!!!!!!!!`!!!!%!!!!"&!!!!"3
+!!!!b!MI+q"jm!!!!(!!b!!"6CA4R!!!!#J!!rrm!!!!!!MJ-r"#e:
diff --git a/src/mzscheme/main.c b/src/mzscheme/main.c
new file mode 100644
index 0000000..6bf7dce
--- /dev/null
+++ b/src/mzscheme/main.c
@@ -0,0 +1,710 @@
+/*
+  MzScheme
+  Copyright (c) 1995-97 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "scheme.h"
+
+#ifdef FILES_HAVE_FDS
+# include <sys/types.h>
+# include <sys/time.h>
+# ifdef SELECT_INCLUDE
+#  include <sys/select.h>
+# endif
+#endif
+#ifndef NO_USER_BREAK_HANDLER
+# include <signal.h>
+#endif
+#ifdef UNISTD_INCLUDE
+# include <unistd.h>
+#endif
+#ifdef USE_LOCALE
+# include <locale.h>
+#endif
+#ifdef MACINTOSH_EVENTS
+# include <Events.h>
+#endif
+#ifdef MACINTOSH_SIOUX
+# include <console.h>
+# include <SIOUX.h>
+#endif
+#ifdef MACINTOSH_SET_STACK
+# include <Memory.h>
+#endif
+#ifdef MACINTOSH_EVENTS
+# include "simpledrop.h"
+#endif
+
+/* #define NO_GCING */
+
+#if defined(_IBMR2)
+static void dangerdanger(int ignored)
+{
+  char *s = "mzscheme: danger - paging space low\n";
+  write(2, s, strlen(s));
+  scheme_collect_garbage();
+}
+#endif
+
+#ifndef NO_USER_BREAK_HANDLER
+
+#ifdef MACINTOSH_EVENTS
+static int break_flag;
+static Scheme_Object *orig_evaluator;
+#endif
+
+#ifndef MACINTOSH_EVENTS
+extern Scheme_Process *scheme_main_process;
+ 
+static void user_break_hit(int ignore)
+{
+  Scheme_Process *p = scheme_main_process;
+
+  scheme_break_thread(p);
+
+# ifdef SIGSET_NEEDS_REINSTALL
+  MZ_SIGSET(SIGINT, user_break_hit);
+# endif
+}
+#endif
+
+#ifdef MACINTOSH_EVENTS
+static int check_break_flag()
+{
+  QHdrPtr start;
+  EvQEl *q;
+  EventRecord event;
+  
+  start = GetEvQHdr();
+  q = (EvQEl *)start->qHead;
+  while (q) {
+    if (q->evtQWhat == keyDown) {
+      if ((((q->evtQMessage & charCodeMask) == '.') 
+	   && (q->evtQModifiers & cmdKey))
+      	  || (((q->evtQMessage & charCodeMask) == 3) 
+	      && (q->evtQModifiers & controlKey))) {
+        Dequeue((QElemPtr)q, (QHdrPtr)start);
+        return 1;
+      }
+    }
+    q = (EvQEl *)q->qLink;
+  }
+#ifdef MACINTOSH_GIVE_TIME
+  WaitNextEvent(0, &event, 0, NULL);
+#endif
+  return 0;
+}
+
+static Scheme_Object *adjust_break_flag_and_eval(int argc, Scheme_Object **argv)
+{
+  break_flag = 0;
+  return _scheme_tail_apply(orig_evaluator, argc, argv);
+}
+#endif
+
+#endif
+
+#define GDESC "Identifiers and symbols are initially case-sensitive.\n"
+#define KDESC "Built-in globals are constant.\n"
+#define UDESC "Primitive exceptions are secure.\n"
+#define SDESC "Set! works on undefined identifiers.\n"
+#define EDESC "Call/cc is replaced with call/ec.\n"
+#define ADESC "Fall-through cond or case is an error.\n"
+#define NDESC "Keywords are not enforced.\n"
+#define YDESC "Only #%% syntactic forms are present.\n"
+
+#ifdef MZ_STACK_START_HACK
+void *mzscheme_stack_start;
+#endif
+
+#ifdef MACINTOSH_EVENTS
+void Drop_Runtime(char **argv, int argc)
+{
+  int i;
+	
+  for (i = 0; i < argc; i++)
+    scheme_load(argv[i]);
+}
+
+void Drop_Quit()
+{
+  exit(0);
+}
+#endif
+
+static int is_number_arg(const char *s)
+{
+  while (*s) {
+    if (*s < '0' || *s > '9') {
+      if (*s == '.') {
+	s++;
+	while (*s) {
+	  if (*s < '0' || *s > '9')
+	    return 0;
+	  else
+	    s++;
+	}
+	return 1;
+      } else
+	return 0;
+    } else
+      s++;
+  }
+
+  return 1;
+}
+
+static char *make_load_cd(char *file)
+{
+  char *s;
+  
+  s = (char *)malloc(strlen(file) + 13);
+  strcpy(s, "(load/cd \"");
+  strcat(s, file);
+  strcat(s, "\")");
+  return s;
+}
+
+static char *make_require_lib(char *file)
+{
+  char *s;
+  
+  s = (char *)malloc(strlen(file) + 21);
+  strcpy(s, "(require-library \"");
+  strcat(s, file);
+  strcat(s, "\")");
+  return s;
+}
+
+#ifdef SPECIALIZE_STANDALONE
+extern Scheme_Object *scheme_initialize(Scheme_Env *env);
+#endif
+
+#ifdef NO_GCING
+extern int GC_free_space_divisor;
+#endif
+
+int actual_main(int argc, char *argv[])
+{
+  Scheme_Env *global_env;
+  char *prog, **evals_and_loads, *real_switch = NULL;
+  int *is_load, num_enl;
+  int i;
+  int no_more_switches = 0;
+  int script_mode = 0;
+  int no_rep = 0;
+  int no_init_file = 0;
+  int no_lib_path = 0;
+  int mute_banner = 0;
+  Scheme_Object *sch_argv;
+  char *filename;
+  int exit_val = 0;
+
+#ifdef NO_GCING
+  GC_free_space_divisor = 1;
+#endif
+
+#ifdef MACINTOSH_SET_STACK
+  long calcLimit;
+  THz zone;
+	
+  zone = GetZone();
+  calcLimit = ((long)LMGetCurStackBase()-(*(long *)zone)-sizeof(Zone))*3/4;
+  if (calcLimit % 2)
+    calcLimit++;
+  SetApplLimit((Ptr)((*(long *)zone)+sizeof(Zone)+calcLimit));
+#endif
+
+#ifdef MACINTOSH_EVENTS
+  MaxApplZone();
+	
+  InitGraf(&qd.thePort);		/* initialize Mac stuff */
+  InitFonts();
+  InitWindows();
+  InitMenus();
+  TEInit();
+  InitDialogs(NULL);
+  
+  MoreMasters();
+  MoreMasters();
+	
+#ifdef MACINTOSH_SIOUX
+  SIOUXSettings.initializeTB = 0;
+#endif
+
+  Drop_GetArgs(&argc, &argv);
+#endif
+
+#ifdef MACINTOSH_SIOUX
+  if (argc == 1) {
+    char *pname = argv[0];
+    argc = ccommand(&argv);
+    argv[0] = pname;
+  }
+  
+  /* When not using far globals under 68k, CW may not be able to link this.
+     Just comment it out. */
+  SIOUXSettings.autocloseonquit = 0;
+  SIOUXSettings.asktosaveonclose = 0;
+#endif
+
+#ifdef USE_LOCALE
+  setlocale( LC_ALL, "" );
+#endif
+  
+  if (argc) {
+    prog = argv[0];
+    argv++;
+    --argc;
+  } else
+    prog = "MzScheme";
+
+  if (argc && (!strcmp(argv[0], "--restore")
+	       || ((argv[0][0] == '-') && (argv[0][1] == 'R')))) {
+    printf("Image loading (with --restore or -R<file>) is not supported.\n");
+    exit(-1);
+  }
+
+
+  evals_and_loads = (char **)malloc(sizeof(char *) * argc);
+  is_load = (int *)malloc(sizeof(int) * argc);
+  num_enl = 0;
+
+  while (!no_more_switches && argc && argv[0][0] == '-' && !is_number_arg(argv[0] + 1)) {
+    real_switch = argv[0];
+
+    if (!strcmp("--help", argv[0]))
+      argv[0] = "-h";
+    else if (!strcmp("--case-sens", argv[0]))
+      argv[0] = "-g";
+    else if (!strcmp("--const-globs", argv[0]))
+      argv[0] = "-k";
+    else if (!strcmp("--secure-exns", argv[0]))
+      argv[0] = "-u";
+    else if (!strcmp("--esc-cont", argv[0]))
+      argv[0] = "-c";
+    else if (!strcmp("--set-undef", argv[0]))
+      argv[0] = "-s";
+    else if (!strcmp("--no-auto-else", argv[0]))
+      argv[0] = "-a";
+    else if (!strcmp("--no-key", argv[0]))
+      argv[0] = "-n";
+    else if (!strcmp("--hash-percent-syntax", argv[0]))
+      argv[0] = "-y";
+    else if (!strcmp("--script", argv[0]))
+      argv[0] = "-r";
+    else if (!strcmp("--script-cd", argv[0]))
+      argv[0] = "-i";
+    else if (!strcmp("--no-lib-path", argv[0]))
+      argv[0] = "-x";
+    else if (!strcmp("--version", argv[0]))
+      argv[0] = "-v";
+    else if (!strcmp("--no-init-file", argv[0]))
+      argv[0] = "-q";
+    else if (!strcmp("--mute-banner", argv[0]))
+      argv[0] = "-m";
+    else if (!strcmp("--awk", argv[0]))
+      argv[0] = "-w";
+#if defined(_IBMR2)
+    else if (!strcmp("--persistent", argv[0]))
+      argv[0] = "-p";
+#endif
+    else if (!strcmp("--restore", argv[0])) {
+      printf("--restore or -R<file> must be the first (and only) switch.\n");
+      goto show_need_help;
+    }
+    
+    if (!argv[0][1] || (argv[0][1] == '-' && argv[0][2])) {
+      goto bad_switch;
+    } else {
+      char *str;
+      for (str = argv[0] + 1; *str; str++) {
+	switch (*str) {
+	case 'h':
+	  goto show_help;
+	  break;
+	case 'g':
+	  scheme_case_sensitive = 1;
+	  break;
+	case 'c':
+	  scheme_escape_continuations_only = 1;
+	  break;
+	case 'k':
+	  scheme_constant_builtins = 1;
+	  break;
+	case 'u':
+	  scheme_secure_primitive_exn = 1;
+	  break;
+	case 's':
+	  scheme_allow_set_undefined = 1;
+	  break;
+	case 'a':
+	  scheme_allow_cond_auto_else = 0;
+	  break;
+	case 'n':
+	  scheme_no_keywords = 1;
+	  break;
+	case 'y':
+	  scheme_hash_percent_syntax_only = 1;
+	  break;
+	case 'e':
+	  if (argc < 2) {
+	    printf("%s: Missing expression after %s switch.\n", 
+		   prog, real_switch);
+	    goto show_need_help;
+	  }
+	  argv++;
+	  --argc;
+	  evals_and_loads[num_enl] = argv[0];
+	  is_load[num_enl++] = 0;
+	  break;
+	case 'x':
+	  no_lib_path = 1;
+	  break;
+	case 'r':
+	  script_mode = 1;
+	  no_more_switches = 1;
+	case 'f':
+	  if (argc < 2) {
+	    printf("%s: Missing file name after %s switch.\n", 
+		   prog, real_switch);
+	    goto show_need_help;
+	  }
+	  argv++;
+	  --argc;
+	  evals_and_loads[num_enl] = argv[0];
+	  is_load[num_enl++] = 1;
+	  break;
+	case 'i':
+	  script_mode = 1;
+	  no_more_switches = 1;
+	case 'd':
+	  if (argc < 2) {
+	    printf("%s: Missing file name after %s switch.\n", 
+		   prog, real_switch);
+	    goto show_need_help;
+	  }
+	  argv++;
+	  --argc;
+	  evals_and_loads[num_enl] = make_load_cd(argv[0]);
+	  is_load[num_enl++] = 0;
+	  break;
+	case 'F':
+	  while (argc > 1) {
+	    argv++;
+	    --argc;
+	    evals_and_loads[num_enl] = argv[0];
+	    is_load[num_enl++] = 1;
+	  }
+	  break;
+	case 'D':
+	  while (argc > 1) {
+	    argv++;
+	    --argc;
+	    evals_and_loads[num_enl] = make_load_cd(argv[0]);
+	    is_load[num_enl++] = 0;
+	  }
+	  break;
+	case 'l':
+	  if (argc < 2) {
+	    printf("%s: Missing file after %s switch.\n", 
+		   prog, real_switch);
+	    goto show_need_help;
+	  }
+	  argv++;
+	  --argc;
+	  evals_and_loads[num_enl] = make_require_lib(argv[0]);
+	  is_load[num_enl++] = 0;
+	  break;
+	case 'w':
+	  evals_and_loads[num_enl] = make_require_lib("awk.ss");
+	  is_load[num_enl++] = 0;
+	  break;
+	case 'q':
+	  no_init_file = 1;
+	  break;
+	case 'v':
+	  no_rep = 1;
+	  break;
+	case 'm':
+	  mute_banner = 1;
+	  break;
+	case '-':
+	  no_more_switches = 1;
+	  break;
+#if defined(_IBMR2)
+	case 'p':
+	  sigset(SIGDANGER, dangerdanger);
+	  break;
+#endif
+	case 'R':
+	  printf("--restore or -R<file> must be the first (and only) switch.\n");
+	  goto show_need_help;
+	  break;
+	default:
+	  goto bad_switch;
+	}
+      }
+    }
+    argv++;
+    --argc;
+  }
+  
+  if (!script_mode && !mute_banner) {
+    printf(scheme_banner());
+    if (scheme_case_sensitive)
+      printf(GDESC);
+    if (scheme_escape_continuations_only)
+      printf(EDESC);
+    if (scheme_constant_builtins)
+      printf(KDESC);
+    if (scheme_secure_primitive_exn)
+      printf(UDESC);
+    if (scheme_allow_set_undefined)
+      printf(SDESC);
+    if (!scheme_allow_cond_auto_else)
+      printf(ADESC);
+    if (scheme_no_keywords)
+      printf(NDESC);
+    if (scheme_hash_percent_syntax_only)
+      printf(YDESC);
+#ifdef MACINTOSH_EVENTS
+    printf("Warning: reading stdin may block threads.\n");
+#endif
+#ifdef DOS_FILE_SYSTEM
+#if !defined(DETECT_WIN32_CONSOLE_STDIN)
+    printf("Warning: reading stdin may block threads.\n");
+#endif
+#endif
+  }
+  
+  global_env = scheme_basic_env();
+
+  sch_argv = scheme_make_vector(argc, scheme_null);
+  for (i = 0; i < argc; i++)
+    SCHEME_VEC_ELS(sch_argv)[i] = scheme_make_string(argv[i]);
+
+  scheme_add_global("argv", sch_argv, global_env);
+  scheme_add_global("program", scheme_make_string(prog),
+		    global_env);
+
+#ifndef NO_FILE_SYSTEM_UTILS
+  /* Setup path for "collects" collection directory: */
+  if (!no_lib_path) {
+    scheme_eval_string("(#%current-library-collection-paths "
+		        "(#%path-list-string->path-list "
+		         "(#%or (#%getenv \"PLTCOLLECTS\") \"\")"
+		         "(#%or"
+		          "(#%ormap"
+		           "(#%lambda (f) (#%let ([p (f)]) (#%and p (#%directory-exists? p) (#%list p))))"
+		           "(#%list"
+		            "(#%lambda () (#%let ((v (#%getenv \"PLTHOME\")))"
+		                          "(#%and v (#%build-path v \"collects\"))))"
+		            "(#%lambda () (#%find-executable-path program \"collects\"))"
+#ifdef UNIX_FILE_SYSTEM
+		            "(#%lambda () \"/usr/local/lib/plt/collects\")"
+#endif
+#ifdef DOS_FILE_SYSTEM
+		            "(#%lambda () \"c:\\plt\\collects\")"
+#endif
+		          ")) #%null)))",
+		       global_env);
+  }
+#endif
+
+  if (!no_init_file) {
+#ifdef EXPAND_FILENAME_TILDE
+    filename = "~/.mzschemerc";
+#else
+    filename = "mzscheme.rc";
+#endif
+    filename = scheme_expand_filename(filename, -1, "startup", NULL);
+    if (scheme_file_exists(filename))
+      scheme_load(filename);
+  }
+
+  for (i = 0; i < num_enl; i++) {
+    if (is_load[i]) {
+      if (!scheme_load(evals_and_loads[i])) {
+	exit_val = -1;
+	break;
+      }
+    } else if (!scheme_setjmp(scheme_error_buf))
+      scheme_eval_string_all(evals_and_loads[i], global_env, 0);
+    else {
+      exit_val = -1;
+      break;
+    }
+  }
+
+#ifdef SPECIALIZE_STANDALONE
+  scheme_initialize(global_env);
+#endif
+
+#ifndef MACINTOSH_EVENTS
+  MZ_SIGSET(SIGINT, user_break_hit);
+#else
+  scheme_check_for_break = check_break_flag;
+#endif
+
+  if (!no_rep && !script_mode) {
+#ifndef NO_USER_BREAK_HANDLER
+#ifdef MACINTOSH_EVENTS
+    scheme_set_param(scheme_config, MZCONFIG_ENABLE_BREAK, scheme_true);
+    
+    orig_evaluator = scheme_get_param(scheme_config, MZCONFIG_EVAL_HANDLER);
+    scheme_set_param(scheme_config, MZCONFIG_EVAL_HANDLER, scheme_make_prim(adjust_break_flag_and_eval));
+#endif
+#endif
+
+    /* enter read-eval-print loop */
+    scheme_rep();
+    printf("\n");
+    exit_val = 0;
+  }
+
+  return exit_val;
+
+ show_help:
+  printf("%s Startup file and expression switches:\n"
+	 "  -e <expr> : Evaluates <expr> after MzScheme starts.\n"
+	 "  -f <file> : Loads <file> after MzScheme starts.\n"
+	 "  -d <file> : Load/cds <file> after MzScheme starts.\n"
+	 "  -F : Loads all remaining arguments after MzScheme starts.\n"
+	 "  -D : Load/cds all remaining arguments after MzScheme starts.\n"
+	 "  -l <file> : Same as -e '(require-library \"<file>\")'.\n"
+	 "  -r, --script : Script mode: use as last switch for scripts. Same as -fmv-.\n" 
+	 "  -i, --script-cd : Like -r, but also sets the directory. Same as -dmv-.\n"
+	 "  -w, --awk : Same as -l awk.ss.\n"
+	 " Initialization switches:\n"
+         "  -x, --no-lib-path : Does not try to set current-library-collection-paths.\n"
+	 "  -q, --no-init-file : Does not try to load "
+#ifdef EXPAND_FILENAME_TILDE
+	 "\"~/.mzschemerc\""
+#else
+	 "\"mzscheme.rc\""
+#endif
+	 ".\n"
+	 " Language setting switches:\n"
+	 "  -g, --case-sens : " GDESC
+	 "  -c, --esc-cont : " EDESC
+	 "  -k, --const-globs: " KDESC
+	 "  -s, --set-undef : " SDESC
+	 "  -a, --no-auto-else : " ADESC
+	 "  -n, --no-key : " NDESC
+	 "  -y, --hash-percent-syntax : " YDESC
+	 " Miscellaneous switches:\n"
+	 "  -- : No argument following this switch is used as a switch.\n"
+#if defined(_IBMR2)
+	 "  -p, --persistent : Catches SIGDANGER (low page space) signal.\n"
+#endif
+	 "  -m, --mute-banner : Suppresses the startup banner text.\n"
+	 "  -v, --version : Suppresses the read-eval-print loop.\n"
+	 "  -h, --help : Shows this information and exits; ignores other switches.\n"
+	 "  -R<file>, --restore <file> : restores an image; must be the only switch.\n"
+	 "Multiple single-letter switches can be collapsed, with arguments placed\n"
+	 " after the collapsed switches; the first collapsed switch cannot be --.\n"
+	 " E.g.: `-vfme file expr' is the same as `-v -f file -m -e expr'.\n"
+	 "Extra arguments following the last switch are put into the Scheme global\n"
+	 " variable `argv' as a vector of strings. The name used to start MzScheme\n"
+	 " is put into the global variable `program' as a string.\n"
+	 "Extra arguments after a `--restore' file are returned as a vector of\n"
+	 " strings to the continuation of the `write-image-to-file' call that created\n"
+	 " the image. Images are not supported on all platforms.\n"
+         "Expressions/files are evaluated/loaded in order as provided.\n"
+	 "The current-library-collection-paths is automatically set before any\n"
+	 "  expressions/files are evaluated/loaded, unless the -x or --no-lib-path\n"
+	 "  switch is used.\n"
+	 "The file "
+#ifdef EXPAND_FILENAME_TILDE
+	 "\"~/.mzschemerc\""
+#else
+	 "\"mzscheme.rc\""
+#endif
+	 " is loaded before any provided expressions/files\n"
+	 " are evaluated/loaded, unless the -q or --no-init-file switch is used.\n"
+#ifdef UNIX_FILE_SYSTEM
+	 " (Under Windows and MacOS, \"mzscheme.rc\" is loaded from the start-up\n"
+         " working directory.)\n"
+#else
+         " The file \"mzscheme.rc\" is read from the start-up working directory.\n"
+#endif
+#ifdef WINDOWS_FILE_SYSTEM
+	 " (MacOS is like Windows. Under Unix, \"~/.mzschemerc\" is loaded.)\n"
+#endif
+#ifdef WINDOWS_FILE_SYSTEM
+	 " (Windows is like MacOS. Under Unix, \"~/.mzschemerc\" is loaded.)\n"
+#endif
+#ifdef MACINTOSH_EVENTS
+	 "\n"
+	 "Macintosh Startup files are alphabetized and put after the -F switch\n"
+	 " on the command line.\n"
+	 "If a single startup file is provided and it begins with #!, it\n"
+	 " is handled specially. Starting with the next whitespace, the rest\n"
+	 " of the line is used as command line arguments. Unless #!! is used,\n"
+	 " the startup file name is added to the end of this command line.\n"
+#endif
+	 "For general information about MzScheme, see:\n"
+	 "  http://www.cs.rice.edu/CS/PLT/packages/mzscheme/\n"
+#if 0
+	 "Submit bug reports via the web interface (encouraged):\n"
+	 "  http://www.cs.rice.edu/CS/PLT/Bugs/\n"
+	 "or via e-mail (discouraged):\n"
+	 "  plt-bugs@cs.rice.edu\n"
+#endif
+         , scheme_banner());
+  return exit_val;
+ bad_switch:
+  printf("%s: Bad switch %s.\n", prog, real_switch);
+ show_need_help:
+  printf("Use the --help or -h flag for help.\n");
+  return -1;
+}
+
+int main(int argc, char **argv)
+{
+#ifdef USE_SENORA_GC
+  void *mzscheme_stack_start;
+#endif
+#if defined(MZ_STACK_START_HACK) || defined(USE_SENORA_GC)
+  long start2;
+
+  mzscheme_stack_start = (void *)&start2;
+#endif
+
+#ifdef USE_SENORA_GC
+  GC_set_stack_base(mzscheme_stack_start);
+#endif
+
+#if defined(_IBMR2) && !defined(USE_SENORA_GC)
+  {
+    int dummy;
+    if ((unsigned long)&dummy > (unsigned long)0x2ff23000)
+      scheme_stackbottom = 0x2ff80000;
+    else
+      scheme_stackbottom = 0x2ff23000;
+  }
+#endif
+
+  scheme_actual_main = actual_main;
+
+  return scheme_image_main(argc, argv);
+}
diff --git a/src/mzscheme/mkmzlib.ss b/src/mzscheme/mkmzlib.ss
new file mode 100644
index 0000000..68458a3
--- /dev/null
+++ b/src/mzscheme/mkmzlib.ss
@@ -0,0 +1,59 @@
+
+; Utilities for distributing pre-compiled MzLib
+
+(current-library-collection-paths (list (build-path (current-directory) 'up "collects")))
+
+(require-library "compile.ss")
+
+(define flags '(ignore-require-library
+		preserve-elaborations))
+(define suffix ".zo")
+
+; Compiles large mzlib files to .zo files
+(define (make-zo)
+  (define (go f)
+    (printf "Compiling ~a.ss to ~a~a~n" f f suffix)
+    (compile-file (build-path 'up "collects" "mzlib" (string-append f ".ss"))
+		  (build-path 'up "collects" "mzlib" "compiled" (string-append f suffix))
+		  flags))
+  
+  (define (go-unit suffix)
+    (lambda (f)
+      (require-library (string-append f "s.ss"))
+      (go (string-append f suffix))))
+  
+  (define go-r (go-unit "r"))
+  (define go-u (go-unit "u"))
+  
+  (go "matchr")
+  
+  (go "letplus")
+  (go "macro")
+  (go "synrule")
+  (go "shared")
+  
+  (require-library "macro.ss")
+  
+  (go-r "compile")
+  (go-r "pretty")
+  (go-r "functio")
+  (go-r "compat")
+  (go "compatm")
+  (go-r "zmath")
+  (go-r "string")
+  (go-r "file")
+  (go-r "date")
+  (go-r "inflate")
+  (go-r "pconver"))
+
+; Expand letplsrc.ss to letplus.ss
+(define (make-let+)
+  (require-library "match.ss")
+  
+  (begin
+    (define e (with-input-from-file "../collects/mzlib/letplsrc.ss" read))
+    (with-output-to-file "../collects/mzlib/letplus.ss" 
+      (lambda () (write (expand-defmacro e)))
+      'replace)))
+
+  
diff --git a/src/mzscheme/mzmake b/src/mzscheme/mzmake
new file mode 100755
index 0000000..124fae0
--- /dev/null
+++ b/src/mzscheme/mzmake
@@ -0,0 +1,74 @@
+#!/bin/sh
+
+# Makefile-level configurations for some known platforms
+
+if [ "${USESGCDEBUG}" = "yes" ] ; then
+  GCOPTS="GCDIR='sgc' OPTIONS='-DSGC_STD_DEBUGGING=1'"
+elif [ "${USESGC}" = "yes" ] ; then
+  GCOPTS="GCDIR='sgc' OPTIONS='-DUSE_SENORA_GC'"
+else
+  GCOPTS=""
+fi
+
+OS=`uname -s`
+case $OS in
+  SunOS)
+    case `uname -r` in
+      5.*)
+       if [ "${USESOLTH}" = "yes" ] ; then
+	 SOLTHTFLAGS="THREADFLAGS='-DSOLARIS_THREADS'"
+	 SOLTHLIBS="-lthread"
+       else
+	 SOLTHTFLAGS=""
+	 SOLTHLIBS=""
+       fi
+       STATICLINK="-Wl,-Bstatic" # after -ldl
+       make RANLIB=':' LIBS="-ldl -lm -lsocket -lnsl -lintl $SOLTHLIBS" $GCOPTS $SOLTHTFLAGS "$@"
+       ;;
+      *)
+       make $GCOPTS "$@"
+       ;;
+    esac
+    ;;
+  AIX)
+    if [ "${AIXUSEGCC}" = "yes" ]; then
+      make "$@" $GCOPTS RANLIB=':'
+    else
+      make "$@" $GCOPTS RANLIB=':' CC='cc' WARN='' 
+    fi
+    ;;
+  FreeBSD)
+    gmake 'CC=gcc' $GCOPTS "$@"
+    ;;
+  IRIX)
+    if [ "${USEIRIXSPROC}" = "yes" ] ; then
+      IRIXTFLAGS="THREADFLAGS='-DIRIX_SPROCS'"
+      IRIXTLIBS="lib/sys$MZPLATFORMSUFFIX$MZTHREADSUFFIX/sproc.o"
+      IRIXGCEXTRA="GCLIBMAKEEXTRA=sproc-extra-lib"
+    else
+      IRIXTFLAGS=""
+      IRIXTLIBS=""
+      IRIXGCEXTRA=""
+    fi
+    STATICLINK="/usr/lib/libC.a /usr/lib/libmalloc.a"
+    make SHELL=/bin/sh RANLIB=':' CC='cc' CXX='CC' AS='as' WARN='' DEBUGFLAGS='' $IRIXTFLAGS LIBS="-lm $IRIXTLIBS" $IRIXGCEXTRA "$@"
+    ;;
+  Linux)
+    if [ `file /bin/ls | grep ELF | wc -l` = 1 ]; then
+      make $GCOPTS LIBS='-lm -ldl -rdynamic' "$@"
+    else
+      make $GCOPTS "$@"
+    fi
+    ;;
+  OSF1)
+    make $GCOPTS CC=cc NONLINKOPTIONS=-iee_with_inexact RANLIB=':' DEBUGFLAGS='' WARN='' $*
+    ;;
+  HP-UX)
+    make CC=cc OPT=-O WARN='' OPTIONS='-Aa -D_HPUX_SOURCE +k' AR='ar' LIBS='-lm -Wl,-E' DYNOPTIONS='+z' $GCOPTS DEBUGFLAGS='' "$@"
+    # gcc:
+    # make AR='ar' LIBS='-Wl,-E' DYNOPTIONS='-fPIC' $GCOPTS DEBUGFLAGS='' "$@"
+    ;;
+  *)
+    make $GCOPTS "$@"
+    ;;
+esac
diff --git a/src/mzscheme/mzscheme.init b/src/mzscheme/mzscheme.init
new file mode 100644
index 0000000..27eeb4a
--- /dev/null
+++ b/src/mzscheme/mzscheme.init
@@ -0,0 +1,304 @@
+;"Template.scm" configuration template of *features* for Scheme	-*-scheme-*-
+; Copyright (C) 1991, 1992, 1993 Aubrey Jaffer.
+
+; Compatibility file for MzScheme --
+;   http://www.cs.rice.edu/CS/PLT/packages/mzscheme/
+; -- and DrScheme --
+;   http://www.cs.rice.edu/CS/PLT/packages/drscheme/
+; -- produced by Shriram Krishnamurthi <shriram@cs.rice.edu>,
+; Mon Feb 10 12:03:53 CST 1997
+;
+; To configure for DrScheme instead of MzScheme, delete the
+;   (require-library "pretty.ss")
+; below, then follow remaining instructions.
+
+(require-library "pretty.ss")
+
+; Set appropriate values for
+; 1. default-software-type
+; 2. implementation-vicinity
+; 3. library-vicinity
+; 
+; There are two system dependencies:
+; a. current-time is bound to a platform-dependent function, so it 
+;    may not work on non-Unix (or even all Unix) systems.
+; b. most-positive-fixnum is bound to a 32-bit-specific value.
+;
+; Nothing else should require changing.
+;
+; If you have problems or comments, please use the above email address.
+; Do NOT contact Aubrey Jaffer with problems in this file!
+
+; Now, for the rest of the spiel ...
+
+;Permission to copy this software, to redistribute it, and to use it
+;for any purpose is granted, subject to the following restrictions and
+;understandings.
+;
+;1.  Any copy made of this software must include this copyright notice
+;in full.
+;
+;2.  I have made no warrantee or representation that the operation of
+;this software will be error-free, and I am under no obligation to
+;provide any services, by way of maintenance, update, or otherwise.
+;
+;3.  In conjunction with products arising from the use of this
+;material, there shall be no use of my name in any advertising,
+;promotional, or sales literature without prior written consent in
+;each case.
+
+;;; (software-type) should be set to the generic operating system type.
+;;; UNIX, VMS, MACOS, AMIGA and MS-DOS are supported.
+
+(define (software-type) 'UNIX)
+
+;;; (scheme-implementation-type) should return the name of the scheme
+;;; implementation loading this file.
+
+(define (scheme-implementation-type) '|MzScheme|)
+
+;;; (scheme-implementation-version) should return a string describing
+;;; the version the scheme implementation loading this file.
+
+(define scheme-implementation-version version)
+
+;;; (implementation-vicinity) should be defined to be the pathname of
+;;; the directory where any auxillary files to your Scheme
+;;; implementation reside.
+
+(define (implementation-vicinity)
+  (case (software-type)
+    ((UNIX)     (or (getenv "PLTHOME")
+		  "/usr/local/lib/plt"))
+    ((VMS)	"scheme$src:")
+    ((MS-DOS)	"C:\\scheme\\")))
+
+;;; (library-vicinity) should be defined to be the pathname of the
+;;; directory where files of Scheme library functions reside.
+
+(define library-vicinity
+  (let ((library-path
+	 (or
+	  ;; Use this getenv if your implementation supports it.
+	  (getenv "SCHEME_LIBRARY_PATH")
+	  ;; Use this path if your scheme does not support GETENV
+	  ;; or if SCHEME_LIBRARY_PATH is not set.
+	  (case (software-type)
+	    ((UNIX) "/home/shriram/slib/")
+	    ((UNIX) "/usr/local/lib/slib/")
+	    ((VMS) "lib$scheme:")
+	    ((MS-DOS) "C:\\SLIB\\")
+	    (else "")))))
+    (lambda () library-path)))
+
+;;; *FEATURES* should be set to a list of symbols describing features
+;;; of this implementation.  Suggestions for features are:
+
+(define *features*
+      '(
+	source				;can load scheme source files
+					;(slib:load-source "filename")
+	compiled			;can load compiled files
+					;(slib:load-compiled "filename")
+	rev4-report			;conforms to
+;	rev3-report			;conforms to
+;	ieee-p1178			;conforms to
+;	sicp				;runs code from Structure and
+					;Interpretation of Computer
+					;Programs by Abelson and Sussman.
+	rev4-optional-procedures	;LIST-TAIL, STRING->LIST,
+					;LIST->STRING, STRING-COPY,
+					;STRING-FILL!, LIST->VECTOR,
+					;VECTOR->LIST, and VECTOR-FILL!
+;	rev2-procedures			;SUBSTRING-MOVE-LEFT!,
+					;SUBSTRING-MOVE-RIGHT!,
+					;SUBSTRING-FILL!,
+					;STRING-NULL?, APPEND!, 1+,
+					;-1+, <?, <=?, =?, >?, >=?
+	multiarg/and-			;/ and - can take more than 2 args.
+	multiarg-apply			;APPLY can take more than 2 args.
+	rationalize
+	delay				;has DELAY and FORCE
+	with-file			;has WITH-INPUT-FROM-FILE and
+					;WITH-OUTPUT-FROM-FILE
+	string-port			;has CALL-WITH-INPUT-STRING and
+					;CALL-WITH-OUTPUT-STRING
+	transcript			;TRANSCRIPT-ON and TRANSCRIPT-OFF
+	char-ready?
+;	macro				;has R4RS high level macros
+	defmacro			;has Common Lisp DEFMACRO
+	eval				;SLIB:EVAL is single argument eval
+;	record				;has user defined data structures
+	values				;proposed multiple values
+	dynamic-wind			;proposed dynamic-wind
+	ieee-floating-point		;conforms to
+	full-continuation		;can return multiple times
+;	object-hash			;has OBJECT-HASH
+
+;	sort
+;	queue				;queues
+	pretty-print
+;	object->string
+	format
+;	trace				;has macros: TRACE and UNTRACE
+;	compiler			;has (COMPILER)
+;	ed				;(ED) is editor
+	system				;posix (system <string>)
+	getenv				;posix (getenv <string>)
+	program-arguments		;returns list of strings (argv)
+;	Xwindows			;X support
+;	curses				;screen management package
+;	termcap				;terminal description package
+;	terminfo			;sysV terminal description
+;	current-time			;returns time in seconds since 1/1/1970
+	))
+
+;;; Compatibility code added by Shriram.
+
+(define-macro defmacro
+  (lambda (name params . body)
+    `(define-macro ,name
+       (lambda ,params
+	 ,@body))))
+
+(define program-arguments
+  (lambda ()
+    (vector->list argv)))
+
+(define current-time current-seconds)
+
+;;; Remainder is modifications of existing code in Template.scm.
+
+;;; (OUTPUT-PORT-WIDTH <port>)
+(define (output-port-width . arg) 79)
+
+;;; (OUTPUT-PORT-HEIGHT <port>)
+(define (output-port-height . arg) 24)
+
+;;; (CURRENT-ERROR-PORT)
+
+;;; (TMPNAM) makes a temporary file name.
+(define tmpnam (let ((cntr 100))
+		 (lambda () (set! cntr (+ 1 cntr))
+			 (string-append "slib_" (number->string cntr)))))
+
+;;; (FILE-EXISTS? <string>)
+
+;;; (DELETE-FILE <string>)
+
+;;; FORCE-OUTPUT flushes any pending output on optional arg output port
+;;; use this definition if your system doesn't have such a procedure.
+(define force-output flush-output)
+
+;;; CALL-WITH-INPUT-STRING and CALL-WITH-OUTPUT-STRING are the string
+;;; port versions of CALL-WITH-*PUT-FILE.
+
+(define call-with-input-string
+  (lambda (string thunk)
+    (parameterize ((current-input-port (open-input-string string)))
+      (thunk))))
+
+(define call-with-output-string
+  (lambda (receiver)
+    (let ((sp (open-output-string)))
+      (receiver sp))))
+
+;;; CHAR-CODE-LIMIT is one greater than the largest integer which can
+;;; be returned by CHAR->INTEGER.
+(define char-code-limit 256)
+
+;;; MOST-POSITIVE-FIXNUM is used in modular.scm
+(define most-positive-fixnum #x3FFFFFFFF) ; 30 bits on 32-bit machines
+
+;;; Return argument
+(define (identity x) x)
+
+;;; If your implementation provides eval SLIB:EVAL is single argument
+;;; eval using the top-level (user) environment.
+(define slib:eval eval)
+
+;;; If your implementation provides R4RS macros:
+;(define macro:eval slib:eval)
+;(define macro:load load)
+
+(define gentemp
+  (let ((*gensym-counter* -1))
+    (lambda ()
+      (set! *gensym-counter* (+ *gensym-counter* 1))
+      (string->symbol
+       (string-append "slib:G" (number->string *gensym-counter*))))))
+
+(define defmacro? macro?)
+
+(define macroexpand-1 expand-defmacro-once)
+
+(define macroexpand expand-defmacro)
+
+(define base:eval slib:eval)
+(define (defmacro:expand* x)
+  (require 'defmacroexpand) (apply defmacro:expand* x '()))
+(define (defmacro:eval x) (base:eval (defmacro:expand* x)))
+
+(define (defmacro:load <pathname>)
+  (slib:eval-load <pathname> defmacro:eval))
+
+(define (slib:eval-load <pathname> evl)
+  (if (not (file-exists? <pathname>))
+      (set! <pathname> (string-append <pathname> (scheme-file-suffix))))
+  (call-with-input-file <pathname>
+    (lambda (port)
+      (let ((old-load-pathname *load-pathname*))
+	(set! *load-pathname* <pathname>)
+	(do ((o (read port) (read port)))
+	    ((eof-object? o))
+	  (evl o))
+	(set! *load-pathname* old-load-pathname)))))
+
+;;; define an error procedure for the library
+(define slib:error error)
+
+;;; define these as appropriate for your system.
+(define slib:tab (integer->char 9))
+(define slib:form-feed (integer->char 12))
+
+;;; Support for older versions of Scheme.  Not enough code for its own file.
+(define (last-pair l) (if (pair? (cdr l)) (last-pair (cdr l)) l))
+(define t #t)
+(define nil #f)
+
+;;; Define these if your implementation's syntax can support it and if
+;;; they are not already defined.
+
+(define (1+ n) (+ n 1))
+(define (-1+ n) (+ n -1))
+(define 1- -1+)
+
+(define in-vicinity string-append)
+
+;;; Define SLIB:EXIT to be the implementation procedure to exit or
+;;; return if exitting not supported.
+(define slib:exit exit)
+
+;;; Here for backward compatability
+(define scheme-file-suffix
+  (let ((suffix (case (software-type)
+		  ((NOSVE) "_scm")
+		  (else ".scm"))))
+    (lambda () suffix)))
+
+;;; (SLIB:LOAD-SOURCE "foo") should load "foo.scm" or with whatever
+;;; suffix all the module files in SLIB have.  See feature 'SOURCE.
+
+(define (slib:load-source f) (load (string-append f ".scm")))
+
+;;; (SLIB:LOAD-COMPILED "foo") should load the file that was produced
+;;; by compiling "foo.scm" if this implementation can compile files.
+;;; See feature 'COMPILED.
+
+(define (slib:load-compiled f) (load (string-append f ".zo")))
+
+;;; At this point SLIB:LOAD must be able to load SLIB files.
+
+(define slib:load slib:load-source)
+
+(slib:load (in-vicinity (library-vicinity) "require"))
diff --git a/src/mzscheme/mzscheme.sh b/src/mzscheme/mzscheme.sh
new file mode 100755
index 0000000..7699a83
--- /dev/null
+++ b/src/mzscheme/mzscheme.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# This script picks the right binary for a mutli-platform
+#  configuration
+
+if [ "$PLTHOME" = '' ] ; then
+  PLTHOME=/usr/local/lib/plt
+  export PLTHOME
+fi
+
+SYS=`${PLTHOME}/bin/archsys z`
+
+exec ${PLTHOME}/.bin/${SYS}/mzscheme ${1+"$@"}
+
diff --git a/src/mzscheme/openbugs b/src/mzscheme/openbugs
new file mode 100644
index 0000000..edd8b8c
--- /dev/null
+++ b/src/mzscheme/openbugs
@@ -0,0 +1,29 @@
+
+(let loop ([x 0]) (call/cc loop)) accumulates memory
+
+"synrule.ss" is missing `let-syntax' and `letrec-syntax'
+
+On Alpha machines, floating-point overflow is not handled properly
+ (so +inf.0, -inf.0, and +nan.0 are messed up)
+
+Under MacOS, `tcp-listen' does not work reliably
+
+Under MacOS, in the standalone MzScheme application, a blocking read 
+ from stdin blocks all MzScheme threads
+
+Under Unix, (execute s) is just (exit (if (system s) 0 -1)), while
+ execute* replaces the current process like it is supposed to
+
+Under Windows, the `system' procedure blocks all MzScheme threads
+ (`system*' works correctly)
+
+Under AIX, write to tcp output port blocks when the low-level
+  buffer is full
+
+Under FreeBSD, if the descripters limit is greater than 256, then
+  it is automatically reduced to 256 within MzScheme/MrEd/DrScheme
+
+Still to be added to support R5RS:
+  (scheme-report-environment n)
+  (null-environment)
+  (interaction-environment)
diff --git a/src/mzscheme/relbin b/src/mzscheme/relbin
new file mode 100755
index 0000000..d90b83b
--- /dev/null
+++ b/src/mzscheme/relbin
@@ -0,0 +1,40 @@
+#!/bin/sh
+
+RDIST=rdist
+
+if [ "-r" = "$1" ] ; then
+  shift
+  RDIST=$1
+  shift
+fi
+
+if [ "-self" = "$1" ] ; then
+  shift
+  FARHOST=`hostname`
+else
+  FARHOST=asia
+fi
+
+MZSYS=`/home/scheme/plt/bin/archsys -`$1
+
+MZDEST=/home/scheme/plt/.bin/${MZSYS}/mzscheme
+MZDYNDEST=/home/scheme/plt/collects/mzscheme/lib/${MZSYS}
+
+echo strip binary
+strip ${MZBUILDDIR}mzscheme
+
+echo ${MZBUILDDIR}mzscheme to ${MZDEST}
+
+echo "${MZBUILDDIR}mzscheme -> ${FARHOST} install $MZDEST ;" | $RDIST -f -
+
+echo objects/sys${MZPLATFORMSUFFIX}/mzdyn.o to ${MZDYNDEST}/mzdyn.o
+
+echo "lib/sys${MZPLATFORMSUFFIX}/mzdyn.o -> ${FARHOST} install ${MZDYNDEST}/mzdyn.o ;" | $RDIST -f -
+
+echo objects/sys${MZPLATFORMSUFFIX}/libmzscheme.a to ${MZDYNDEST}/libmzscheme.a
+
+echo "lib/sys${MZPLATFORMSUFFIX}/libmzscheme.a -> ${FARHOST} install ${MZDYNDEST}/libmzscheme.a ;" | $RDIST -f -
+
+echo objects/sys${MZPLATFORMSUFFIX}/libgc.a to ${MZDYNDEST}/libgc.a
+
+echo "lib/sys${MZPLATFORMSUFFIX}/libgc.a -> ${FARHOST} install ${MZDYNDEST}/libgc.a ;" | $RDIST -f -
diff --git a/src/mzscheme/sconfig.h b/src/mzscheme/sconfig.h
new file mode 100644
index 0000000..2118a74
--- /dev/null
+++ b/src/mzscheme/sconfig.h
@@ -0,0 +1,962 @@
+
+/* 
+   Configuration for compiling MzScheme
+
+   If you want to set all the flags externally (on the command line
+   with -D or some other compiler-dependent way), then define
+   FLAGS_ALREADY_SET, and this file will be ignored.
+
+   One flag cannot be set in this file: INCLUDE_WITHOUT_PATHS.
+   Define this flag if your compiler doesn't like #include
+   statements with relative paths using ".." and "/". (You will
+   have to #define this for Macintosh CodeWarrior in the project 
+   header.)
+
+   The best flag settings are already provided for some auto-detected
+   architecture/system/compilers. Otherwise, the default settings 
+   are generic Unix.  Send other architecture/system/compiler-specific 
+   info to "plt-bugs@cs.rice.edu".
+*/
+
+#ifndef FLAGS_ALREADY_SET
+
+/*************** (BEGIN PLATFORM-INDEPENDENT OPTIONS) *************/
+
+  /***********************/
+ /* Language Extensions */
+/***********************/
+
+ /* NO_FILE_SYSTEM_UTILS removes most file system utilities. */
+
+ /* NO_OBJECT_SYSTEM removes MzScheme's object system. */
+
+ /* NO_REGEXP_UTILS removes MzScheme's regular expression utilities. */
+
+ /* NO_SCHEME_THREADS removes MzScheme's threads from the Scheme user. */
+
+ /* NO_SCHEME_EXNS removes MzScheme's exception system. */
+
+  /*******************************/
+ /* Evaluator Tuning Parameters */
+/*******************************/
+
+#define SCHEME_STACK_SIZE 5000
+
+ /* SCHEME_STACK_SIZE <X> sets the limit for the internal stack
+    for Scheme variables. */
+
+/**************** (END PLATFORM-INDEPENDENT OPTIONS) **************/
+
+
+
+/******** (BEGIN KNOWN ARCHITECTURE/SYSTEM CONFIGURATIONS) ********/
+
+  /************** SunOS/Solaris with gcc ****************/
+
+#if defined(sun)
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define USE_EXPLICT_FP_FORM_CHECK
+# define POW_HANDLES_INF_CORRECTLY
+
+# include <errno.h>
+# ifdef ECHRNG
+/* Solaris */
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "sparc-solaris"
+#  define DIRENT_NO_NAMLEN
+#  define RAND_NOT_RANDOM
+#  define NO_USLEEP
+#  define USE_ULIMIT
+#  define USE_FCNTL_O_NONBLOCK
+
+#  ifdef SOLARIS_THREADS
+#   define MZ_REAL_THREADS
+#   define MZ_USE_SOLARIS_THREADS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_solaris_init_threads(void);
+void scheme_solaris_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void scheme_solaris_exit_thread();
+void scheme_solaris_break_thread(void *th);
+struct Scheme_Process *scheme_solaris_get_current_process();
+void scheme_solaris_set_current_process(struct Scheme_Process *);
+void *scheme_solaris_make_mutex();
+void scheme_solaris_free_mutex(void *);
+void scheme_solaris_lock_mutex(void *);
+void scheme_solaris_unlock_mutex(void *);
+void *scheme_solaris_make_semaphore(int init);
+void scheme_solaris_free_semaphore(void *);
+int scheme_solaris_semaphore_up(void *);
+int scheme_solaris_semaphore_down_breakable(void *);
+int scheme_solaris_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_solaris_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_solaris_create_thread(f, data, slimit, thp)
+#define SCHEME_EXIT_THREAD() scheme_solaris_exit_thread()
+#define SCHEME_BREAK_THREAD(th) scheme_solaris_break_thread(th)
+#define SCHEME_GET_CURRENT_PROCESS() scheme_solaris_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_solaris_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_solaris_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_solaris_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_solaris_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_solaris_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_solaris_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_solaris_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_solaris_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_solaris_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_solaris_semaphore_try_down(s)
+#  endif
+# else
+/* SunOS4 */
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "sparc-sunos4"
+# define SIGSET_IS_SIGNAL
+# endif
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** RS6000/AIX with gcc or xlc ****************/
+
+# if defined(_IBMR2)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "rs6k-aix"
+
+# include "uconfig.h"
+# undef UNIX_DYNAMIC_LOAD
+# undef USE_FCHDIR
+
+# define STACK_GROWS_DOWN
+# define UNIX_LIMIT_STACK 33554944
+
+# define AIX_DYNAMIC_LOAD
+
+# define SELECT_INCLUDE
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** x86/Linux with gcc ****************/
+
+#if defined(linux)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "i386-linux"
+
+# include "uconfig.h"
+# undef HAS_STANDARD_IOB
+#ifndef __ELF__
+# undef UNIX_DYNAMIC_LOAD
+#endif
+
+# define DIRENT_NO_NAMLEN
+
+# define HAS_LINUX_IOB
+
+# define STACK_GROWS_DOWN
+
+# define USE_IEEE_FP_PREDS
+# define LINUX_CONTROL_387
+# define USE_EXPLICT_FP_FORM_CHECK
+
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** x86/FreeBSD with gcc ****************/
+
+# if defined(__FreeBSD__) && defined(i386)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "i386-freebsd"
+
+# include "uconfig.h"
+# undef HAS_STANDARD_IOB
+
+# define HAS_BSD_IOB
+
+# define STACK_GROWS_DOWN
+
+# define UNDERSCORE_DYNLOAD_SYMBOL_PREFIX
+
+# define USE_IEEE_FP_PREDS
+# define FREEBSD_CONTROL_387
+# define POW_HANDLES_INF_CORRECTLY
+
+# define UNIX_LIMIT_FDSET_SIZE
+
+# define SIGSET_IS_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** SGI/IRIX with SGI cc ****************/
+
+#if  (defined(mips) || defined(__mips)) \
+     && !(defined(ultrix) || defined(__ultrix))
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "mips-irix"
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define DIRENT_NO_NAMLEN
+
+# define BSTRING_INCLUDE
+# define RAND_NOT_RANDOM
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define NO_USLEEP
+# define USE_FCNTL_O_NONBLOCK
+
+#  ifdef MZ_X_THREADS
+#    ifndef MZ_FAKE_THREADS
+#      define MZ_FAKE_THREADS
+#    endif
+#  endif
+
+#  ifndef MZ_FAKE_THREADS
+#    ifdef IRIX_SPROCS
+#      define MZ_REAL_THREADS
+#      define MZ_USE_IRIX_SPROCS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_sproc_init_threads(void);
+void  scheme_sproc_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void  scheme_sproc_exit_thread();
+void  scheme_sproc_break_thread(void *);
+struct Scheme_Process *scheme_sproc_get_current_process();
+void  scheme_sproc_set_current_process(struct Scheme_Process *);
+void *scheme_sproc_make_mutex();
+void  scheme_sproc_free_mutex(void *);
+void scheme_sproc_lock_mutex(void *);
+void scheme_sproc_unlock_mutex(void *);
+void *scheme_sproc_make_semaphore(int init);
+void  scheme_sproc_free_semaphore(void *);
+int   scheme_sproc_semaphore_up(void *);
+int   scheme_sproc_semaphore_down_breakable(void *);
+int   scheme_sproc_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_sproc_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_sproc_create_thread(f, data, slimit, thp)
+#define SCHEME_EXIT_THREAD() scheme_sproc_exit_thread()
+#define SCHEME_BREAK_THREAD(th) scheme_sproc_break_thread(th)
+#define SCHEME_GET_CURRENT_PROCESS() scheme_sproc_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_sproc_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_sproc_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_sproc_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_sproc_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_sproc_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_sproc_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_sproc_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_sproc_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_sproc_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_sproc_semaphore_try_down(s)
+#    endif /* IRIX_SPROCS */
+#  endif /* !MZ_FAKE_THREADS */
+
+#  define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** Ultrix with gcc ****************/
+
+#if defined(ultrix) || defined(__ultrix)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "mips-ultrix"
+
+# include "uconfig.h"
+# undef UNIX_DYNAMIC_LOAD
+# undef USE_FCHDIR
+
+# define DIRENT_NO_NAMLEN
+
+# define STACK_GROWS_DOWN
+
+# define RAND_NOT_RANDOM
+
+# define NO_USLEEP
+# define USE_FCNTL_O_NONBLOCK
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** ALPHA/OSF1 with gcc ****************/
+
+# if defined(__alpha)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "alpha-osf1"
+
+# include "uconfig.h"
+
+# define STACK_GROWS_DOWN
+
+# define RAND_NOT_RANDOM
+
+# define SIXTY_FOUR_BIT_INTEGERS
+
+# define ALPHA_CONTROL_FP
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** HP/UX with gcc ****************/
+
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "parisc-hpux"
+
+# include "uconfig.h"
+
+# undef UNIX_DYNAMIC_LOAD
+# define SHL_DYNAMIC_LOAD
+
+# define STACK_GROWS_UP
+
+# define USE_SYSCALL_GETRUSAGE
+
+# define USE_DIVIDE_MAKE_INFINITY
+# define USE_IEEE_FP_PREDS
+# define USE_EXPLICT_FP_FORM_CHECK
+
+# define USE_ULIMIT
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /********* with Borland C++ or MS Visual C++ ************/
+  /* See the "windows" directory for more MSVC details.   */
+  /* MzScheme is probably no longer Borland-friendly,     */
+  /* since it currently relies on one MSVC-style inline   */
+  /* assembly file. Nevertheless, the old flags and       */
+  /* instructions have been preserved.                    */
+  /*                                                      */
+  /* Old Borland instructions:                            */
+  /*   To compile a standalone MzScheme, first #define    */
+  /*   MZWINCONSOLE.                                      */
+  /*   To compile for Windows95, first #define MZWIN95.   */
+  /*   Windows95 version also works under Windows NT, but */
+  /*   not under Win32s. A Win32s version will also work  */
+  /*   under Windows NT.                                  */
+
+#if (defined(__BORLANDC__) || defined(_MSC_VER)) \
+    && (defined(__WIN32__) || defined(WIN32) || defined(_WIN32))
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "win32\\i386"
+
+# define SYSTEM_TYPE_NAME "windows"
+# define DOS_FILE_SYSTEM
+# if defined(_MSC_VER)
+#  define USE_GETDRIVE
+#  define NO_READDIR
+#  define USE_FINDFIRST
+# else
+#  define USE_GETDISK
+#  define DIRENT_NO_NAMLEN
+# endif
+# define NO_READLINK
+# define MKDIR_NO_MODE_FLAG
+
+# define TIME_SYNTAX
+# define USE_FTIME
+# define GETENV_FUNCTION
+# define DIR_FUNCTION
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+
+# if defined(_MSC_VER)
+#  define WINDOWS_FIND_STACK_BOUNDS
+# else
+#  define USE_STACKAVAIL
+# endif
+
+# if defined(_MSC_VER)
+#  define USE_MZ_SETJMP
+# endif
+# define STACK_SAFETY_MARGIN 20000
+
+# define WINDOWS_DYNAMIC_LOAD
+# define LINK_EXTENSIONS_BY_TABLE
+
+# define IGNORE_BY_CONTROL_387
+# if defined(_MSC_VER)
+#  define NAN_EQUALS_ANYTHING
+# endif
+# define POW_HANDLES_INF_CORRECTLY
+
+# define IO_INCLUDE
+# define RAND_NOT_RANDOM
+# define NO_SLEEP
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define PROCESS_FUNCTION
+# define WINDOWS_PROCESSES
+# define DETECT_WIN32_CONSOLE_STDIN
+
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+# define USE_WINSOCK_TCP
+
+# ifdef WIN32_THREADS
+#  define MZ_REAL_THREADS
+#  define MZ_USE_WIN32_THREADS
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *scheme_win32_init_threads(void);
+void scheme_win32_create_thread(void (*f)(void *), void *data, unsigned long *stackend, void **thp);
+void scheme_win32_exit_thread();
+void scheme_win32_break_thread(void *th);
+struct Scheme_Process *scheme_win32_get_current_process();
+void scheme_win32_set_current_process(struct Scheme_Process *);
+void *scheme_win32_make_mutex();
+void scheme_win32_free_mutex(void *s);
+void scheme_win32_lock_mutex(void *);
+void scheme_win32_unlock_mutex(void *);
+void *scheme_win32_make_semaphore(int init);
+void scheme_win32_free_semaphore(void *s);
+int scheme_win32_semaphore_up(void *);
+int scheme_win32_semaphore_down_breakable(void *);
+int scheme_win32_semaphore_try_down(void *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SCHEME_INIT_THREADS() scheme_win32_init_threads()
+#define SCHEME_CREATE_THREAD(f, data, slimit, thp) scheme_win32_create_thread(f, data, slimit, thp)
+#define SCHEME_BREAK_THREAD(th) scheme_win32_break_thread(th)
+#define SCHEME_EXIT_THREAD() scheme_win32_exit_thread()
+#define SCHEME_GET_CURRENT_PROCESS() scheme_win32_get_current_process()
+#define SCHEME_SET_CURRENT_PROCESS(p) scheme_win32_set_current_process(p)
+#define SCHEME_MAKE_MUTEX() scheme_win32_make_mutex()
+#define SCHEME_FREE_MUTEX(m) scheme_win32_free_mutex(m)
+#define SCHEME_LOCK_MUTEX(m) scheme_win32_make_mutex(m)
+#define SCHEME_UNLOCK_MUTEX(m) scheme_win32_make_mutex(m)
+#define SCHEME_MAKE_SEMA(init) scheme_win32_make_semaphore(init)
+#define SCHEME_FREE_SEMA(s) scheme_win32_free_semaphore(s)
+#define SCHEME_SEMA_UP(s) scheme_win32_semaphore_up(s)
+#define SCHEME_SEMA_DOWN_BREAKABLE(s) scheme_win32_semaphore_down_breakable(s)
+#define SCHEME_SEMA_TRY_DOWN(s) scheme_win32_semaphore_try_down(s)
+# endif
+
+/* MS Visual C++ likes underscore prefixes */
+#if defined(_MSC_VER)
+# define MSC_IZE(x) _ ## x
+# define DIRECT_INCLUDE
+#endif
+
+#if defined(__BORLANDC__)
+# define DIR_INCLUDE
+#endif
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************ Macintosh with CodeWarrior *************/
+
+#if defined(__MWERKS__)
+
+# if defined(__powerc)
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "ppc-mac"
+# else
+#  define SCHEME_PLATFORM_LIBRARY_SUBPATH "68k-mac"
+# endif
+
+# define SYSTEM_TYPE_NAME "macos"
+# define MAC_FILE_SYSTEM
+
+#define NO_READDIR
+#define NO_READLINK
+#define USE_MAC_FILE_TOOLBOX
+
+# define MACINTOSH_EVENTS
+# define MACINTOSH_GIVE_TIME
+# define MACINTOSH_SIOUX
+
+# if !defined(__powerc)
+#  define MACINTOSH_SET_STACK
+# else
+#  define CODEFRAGMENT_DYNAMIC_LOAD
+# endif
+
+# ifndef MZSCHEME_IS_CODEFRAGMENT
+#  define LINK_EXTENSIONS_BY_TABLE
+# endif
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+# define MACOS_STACK_LIMIT
+# define STACK_SAFETY_MARGIN 10000
+
+# define TIME_SYNTAX
+# define USE_DIFFTIME
+# define DIR_FUNCTION
+# define TIME_TYPE_IS_UNSIGNED
+
+# define RAND_NOT_RANDOM
+# define NO_SYS_INCLUDE_SUBDIR
+# define NO_USLEEP
+# define UNISTD_INCLUDE
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define POW_HANDLES_INF_CORRECTLY
+
+# define USE_MAC_TCP
+
+# define SIGSET_IS_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+  /************** DOS with Borland C++ ****************/
+  /*          (Never successfully supported)          */
+
+#if defined(__BORLANDC__) && defined(__MSDOS__)
+
+# define SCHEME_PLATFORM_LIBRARY_SUBPATH "dos\\i386"
+
+# define USE_SENORA_GC
+# define DOS_FAR_POINTERS
+# define SMALL_HASH_TABLES
+
+# define SYSTEM_TYPE_NAME "dos"
+# define DOS_FILE_SYSTEM
+# define USE_GETDISK
+# define DIRENT_NO_NAMLEN
+# define NO_READLINK
+# define MKDIR_NO_MODE_FLAG
+
+# define TIME_SYNTAX
+# define USE_FTIME
+# define GETENV_FUNCTION
+# define DIR_FUNCTION
+
+# define STACK_GROWS_DOWN
+
+# define DO_STACK_CHECK
+# define USE_STACKAVAIL
+# define STACK_SAFETY_MARGIN 15000
+
+# define IGNORE_BY_CONTROL_387
+
+# define DIR_INCLUDE
+# define IO_INCLUDE
+# define RAND_NOT_RANDOM
+# define NO_SLEEP
+# define DONT_IGNORE_PIPE_SIGNAL
+
+# define FLAGS_ALREADY_SET
+
+#endif
+
+/************** (END KNOWN ARCHITECTURE/SYSTEMS) ****************/
+
+
+/***** (BEGIN CONFIGURATION FLAG DESCRPTIONS AND DEFAULTS) ******/
+
+#ifndef FLAGS_ALREADY_SET
+
+  /*********************/
+ /* Operating System  */
+/*********************/
+
+#define SYSTEM_TYPE_NAME "unix"
+
+  /* SYSTEM_TYPE_NAME must be a string; this will be converted into
+     a symbol for the result of (system-type) */
+
+  /* SCHEME_PLATFORM_LIBRARY_SUBPATH must be a string; if it is 
+     undefined, it is automatically generated into a file named
+     "schsys.h" into the same directory as .o files and #included
+     by string.c. This string is returned by (system-library-subpath) */
+
+  /*********************/
+ /* Language Features */
+/*********************/
+
+#define TIME_SYNTAX
+#define PROCESS_FUNCTION
+#define DIR_FUNCTION
+#define GETENV_FUNCTION
+
+ /* TIME_SYNTAX adds the (time ...) syntax; this may need to be
+     turned off for compilation on some systems.
+    CLOCKS_PER_SEC relates the values returned by clock() to
+     real seconds. (The difference between two clock() calls is
+     devided by this number.) Usually, this is defined in <time.h>;
+     it defaults to 1000000 */
+
+ /* USE_FTIME uses ftime instead of gettimeofday; only for TIME_SYNTAX */
+ 
+ /* USE_DIFFTIME uses time and difftime; only for TIME_SYNTAX */
+
+ /* TIME_TYPE_IS_UNSIGNED converts time_t values as unsigned. */
+
+ /* PROCESS_FUNCTION adds (process ...) and (system ...) functions */
+
+ /* DIR_FUNCTION adds (current-directory ...) function */
+
+ /* GETENV_FUNCTION adds (getenv ...) function */
+
+  /*******************/
+ /*   Filesystem    */
+/*******************/
+
+#define UNIX_FILE_SYSTEM
+#define EXPAND_FILENAME_TILDE
+
+ /* UNIX_FILE_SYSTEM indicates that filenames are as in Unix, with
+    forward slash separators, ".." as the parent directory, "/" 
+    as the root directory, and case-sensitivity */
+
+ /* DOS_FILE_SYSTEM indicates that filenames are as in DOS, with 
+    slash or backward slash separators, ".." as the parent directory, 
+    "X:\", "X:/", "\", or "/" as a root directory (for some letter X),
+    and case insensitivity */
+
+ /* MAC_FILE_SYSTEM indicates that filenames are as on the Macintosh,
+    with colon separators, "" as the parent directory, a volume name 
+    (followed by a colon) as a root directory, and case insensitivity. */
+
+ /* EXPAND_FILENAME_TILDE expands ~ in a filename with a user's home
+     directory. */
+
+ /* NO_STAT_PROC means that there is no stat() function. */
+
+ /* NO_MKDIR means that there is no mkdir() function. */
+
+ /* NO_READLINK means that there is no readlink() function. */
+
+ /* USE_GETDISK uses getdisk() and setdisk() to implement the
+     filesystem-root-list primitive under DOS. */
+
+ /* NO_READDIR means that there is no opendir() and readdir() for
+     implementing directory-list. */
+
+ /* DIRENT_NO_NAMLEN specifies that dirent entries do not have a
+     d_namlen field; this is used only when NO_READDIR is not
+     specified. */
+     
+ /* MKDIR_NO_MODE_FLAG specifies that mkdir() takes only one argument,
+     instead of a directory name and mode flags. */
+
+  /***********************/
+ /*       Ports         */
+/***********************/
+
+/* These are flags about the implementation of char-ready? for FILE*s
+   None of these flags are required, but char-ready? may return
+   spurious #ts if they are set up incorrectly. */
+
+#define HAS_STANDARD_IOB
+#define FILES_HAVE_FDS
+#define USE_UNIX_SOCKETS_TCP
+
+ /* HAS_STANDARD_IOB, HAS_GNU_IOB, HAS_LINUX_IOB, and HAS_BSD_IOB
+     are mutually exclusive; they describe how to read the FILE* 
+     structure to determine if there are available cached characters. */
+
+ /* FILES_HAVE_FDS means that a FILE* is always associated with a
+    file desciptor, which can be select-ed to see if there are
+    pending bytes. Don't use this unless one of the HAS_<X>_IOB
+    flags is used. */
+
+ /* USE_UNIX_SOCKETS_TCP means that the tcp- procedures can be implemented
+    with the standard Unix socket functions. */
+
+ /* USE_WINSOCK_TCP means that the tcp- procedures can be implemented
+    with the Winsock toolbox. */
+
+ /* USE_MAC_TCP means that the tcp- procedures can be implemented
+    with the Mac TCP toolbox. */
+
+ /* DETECT_WIN32_CONSOLE_STDIN notices character reads from console
+    stdin so that char-ready? and blocking reads can be implemented
+    correctly (so that Scheme thredas are not blocked when no input
+    is ready). */
+
+ /* USE_FCNTL_O_NONBLOCK uses O_NONBLOCK instead of FNDELAY for
+    fcntl on Unix TCP sockets. (Posix systems need this flag). */
+
+ /* USE_ULIMIT uses ulimit instead of getdtablesize (Unix). */
+
+ /* USE_DYNAMIC_FDSET_SIZE allocates fd_set records based on the
+    current fd limit instead of relying on the compile-time size
+    of fd_set. [This is not known to be actually helpful anywhere
+    currently, particularly not for FreeBSD.] */
+
+ /* UNIX_LIMIT_FDSET_SIZE insures that the fd limit at start-up is
+    no greater than FD_SETSIZE */
+
+  /***********************/
+ /* Processes & Signals */
+/***********************/
+
+/* These are flags about the implementation of system, process, etc. */
+
+# define UNIX_PROCESSES
+# define SIGSET_IS_SIGNAL
+# define SIGSET_NEEDS_REINSTALL
+
+ /* UNIX_PROCESSES implements the process functions for Unix; uses
+    sigset() to install the signal handler. */
+
+ /* WINDOWS_PROCESSES implements the process functions for Windows. */
+
+ /* SIGSET_IS_SIGNAL uses signal() in place of sigset() for Unix. This 
+    flag is often paired with SIGSET_NEEDS_REINSTALL for traditional
+    Unix systems. */
+
+ /* SIGSET_NEEDS_REINSTALL reinstalls a signal handler when it
+    is called to handle a signal. The expected semantics of sigset()
+    (when this flags is not defined) is that a signal handler is NOT
+    reset to SIG_DFL after a handler is called to handle a signal. */
+
+ /* DONT_IGNORE_FPE_SIGNAL stops MzScheme from ignoring floating-point 
+    exception signals. */
+
+ /* DONT_IGNORE_PIPE_SIGNAL stops MzScheme from ignoring SIGPIPE
+    signals. */
+
+  /**********************/
+ /* Inexact Arithmetic */
+/**********************/
+
+ /* USE_SINGLE_FLOATS turns on support for single-precision
+    floating point numbers. Otherwise, floating point numbers
+    are always represented in double-precision. */
+
+ /* USE_SINGLE_FLOATS_AS_DEFAULT, when used with
+    USE_SINGLE_FLOATS, causes exact->inexact coercions to
+    use single-precision numbers as the result rather
+    than double-precision numbers. */
+
+ /* INEXACT_PRINT_DIGITS "<X>" uses <X> as the number of digits to
+     use for printing floating-points. Defaults to "14". */
+
+ /* USE_INFINITY uses infinity() to get the infinity floating-point
+     constant instead of using HUGE_VAL. */
+
+ /* USE_DIVIDE_MAKE_INFINITY creates +inf.0 by dvividing by zero instead
+    of using HUGE_VAL. */
+
+ /* USE_IEEE_FP_PREDS uses isinf() and isnan() to implement tests for
+    infinity. */
+
+ /* IGNORE_BY_CONTROL_387 turns off floating-point error for
+    Intel '387 with _control87. DONT_IGNORE_PIPE_SIGNAL can be on or
+    off. */
+
+ /* FREEBSD_CONTROL_387 controls the floating-point processor under i386
+    FreeBSD */
+
+ /* LINUX_CONTROL_387 controls the floating-point processor under i386
+    Linux */
+
+ /* APLHA_CONTROL_FP controls the floating-point processor for Alpha
+    OSF1 */
+
+ /* NAN_EQUALS_ANYTHING indicates that the compiler is broken and
+    equality comparisons with +nan.0 always return #t. Currently
+    used for MSVC++ */
+
+ /* USE_EXPLICT_FP_FORM_CHECK circumvents bugs in strtod() under Linux,
+    SunOS/Solaris, and HP/UX by explicit pre-checking the form of the 
+    number and looking for values that are obviously +inf.0 or -inf.0 */
+
+ /* POW_HANDLES_INF_CORRECTLY inidicates that thw pow() library procedure
+    handles +/-inf.0 correctly. Otherwise, code in inserted to specifically
+    check for infinite arguments. */
+
+  /***********************/
+ /* Stack Maniuplations */
+/***********************/
+
+# define DO_STACK_CHECK
+# define UNIX_FIND_STACK_BOUNDS
+# define STACK_SAFETY_MARGIN 50000
+
+ /* STACK_GROWS_UP means that deeper stack values have higher
+     numbered addresses.
+    STACK_GROWS_DOWN means that deeper stack values have lower
+     numbered addresses. This is usually the case (Sparc and
+     Intel platforms, for example, use this).
+    Use only one or none of these. (It's faster if you know which
+     one applies, but it can also be figured it out dynamically.) */
+
+ /* DO_STACK_CHECK checks for stack overflow during execution.
+     Requires either UNIX_FIND_STACK_BOUNDS, USE_STACKAVAIL,
+     MACOS_STACK_LIMIT, or ASSUME_FIXED_STACK_SIZE. */
+
+ /* UNIX_FIND_STACK_BOUNDS figures out the maximum stack position
+     on Unix systems, using getrlimit() and the GC_find_stack_base()
+     defined in the conservative garbage collector.
+    USE_STACKAVIL uses stackavail() function for checking stack
+     overflow; works with Borland C++, maybe other compilers.
+    WINDOWS_FIND_STACK_BOUNDS figures out the maximum stack position
+     under Windows (uses GC_find_stack_base())
+    MACOS_STACK_LIMIT figures out the stack limit on the Mac.
+    ASSUME_FIXED_STACK_SIZE assumes that the main stack size is
+     always FIXED_STACK_SIZE.
+    Use only one of these if DO_STACK_CHECK is used, or none otherwise. */
+
+ /* FIXED_STACK_SIZE <X> sets the stack size to <X> when the
+     ASSUME_FIXED_STACK_SIZE stack-checking mode is on. */
+
+ /* STACK_SAFETY_MARGIN <X> sets the number of bytes that should be
+     available on the stack for "safety" to <X>. Used only if
+     DO_STACK_CHECK is used. STACK_SAFETY_MARGIN defaults to 50000. */
+
+ /* ERROR_ON_OVERFLOW causes MzScheme to produce an error if the
+     stack is overflowed. Normally, it would copy out the current
+     stack and try to continue the computation. Used only if
+     DO_STACK_CHECK is used. */
+
+ /* PROCESS_STACK_SIZE <X> sets the size of the allocated stack when
+     SPAWN_NEW_STACK is used. Stack-checking and copying works on these
+     stacks, so that arbitrary computaions can be performed with any
+     size stack. (Well, it can't be *too* small...) */
+
+ /* UNIX_LIMIT_STACK <X> limits stack usage to <X> bytes. This may
+     be necessary to avoid GC-setup traversal over too much memory
+     (with GC flag HEURISTIC2?). */
+
+  /***********************/
+ /*   Dynamic Loading   */
+/***********************/
+
+#define UNIX_DYNAMIC_LOAD
+
+ /* UNIX_DYNAMIC_LOAD implements dynamic extensions under Unix
+     using dlopen(); you may have to add the -ldl flag in the LIBS 
+     Makefile variable. The library doesn't exist under Linux without 
+     ELF, so it won't work. If you get linker errors about dlopen(), etc., 
+     this flag and the -ldl linker flag are the things to adjust.
+    SHL_DYNAMIC_LOAD implement HP/UX dynamic loading.
+    WINDOWS_DYNAMIC_LOAD implements dynamic extensions under Windows
+     (Thanks to Patrick Barta).
+    CODEFRAGMENT_DYNAMIC_LOAD implements dynamic extensions with
+     MacOS's Code Fragment Manager (thanks to William Ng).
+    Use only one or none of these. */
+
+ /* UNDERSCORE_DYNLOAD_SYMBOL_PREFIX with UNIX_DYNAMIC_LOAD menas that
+    an extra underscore ("_") must be placed in front of the name passed 
+    to dlopen(). */
+
+ /* LINK_EXTENSIONS_BY_TABLE specifies that the MzScheme functions
+    used by an extension must be manually linked via a table of
+    function pointers. Windows dynamic linking uses this method. */
+
+ /* MZSCHEME_IS_CODEFRAGMENT exploits improved CFM linking when
+    MzScheme is itself a shared library instead of embedded in
+    an application */
+
+  /***********************/
+ /*     Heap Images     */
+/***********************/
+
+ /* UNIX_IMAGE_DUMPS turns on image save and restore for Unix systems. 
+     This will only work if the final application is statically linked. 
+     (As an exception, the dynamic-linking library itself can be 
+     dynamically linked. This works because loading an extension in 
+     MzScheme automatically turns off image saving.) */
+
+  /*****************************/
+ /*   Macintosh Standalone    */
+/*****************************/
+
+ /* MACINTOSH_EVENTS checks for a user break on the Mac. This should always
+     be defined for MacOS. */
+
+ /* MACINTOSH_GIVE_TIME lets background processes run when checking for
+     a user break. */
+
+ /* MACINTOSH_SIOUX interfaces with Metrowerks's SIOUX library */
+
+ /* MACINTOSH_SET_STACK sets the stack to be 1/4 of the heap. This should
+     be used for 68k machines, where the stack is not user-configurable. */
+
+  /***********************/
+ /*    Miscellaneous    */
+/***********************/
+
+#define UNISTD_INCLUDE
+#define RAND_NOT_RANDOM
+
+ /* SIXTY_FOUR_BIT_INTEGERS indicates that 'long's are 64-bits wide. */
+
+ /* RAND_NOT_RANDOM uses the function rand() instead of random()
+     for random numbers. Some systems don't have random(). */
+
+ /* NO_USER_BREAK_HANDLER turns off handling of INT signal in main.c */
+
+ /* DIR_INCLUDE if there's a <dir.h> file (mainly for Windows). */
+
+ /* DIRECT_INCLUDE if there's a <direct.h> file (mainly for Windows). */
+
+ /* IO_INCLUDE if there's a <io.h> file (mainly for Windows). */
+
+ /* UNISTD_INCLUDE if there's a <unistd.h> file (mainly for Unix). */
+
+ /* SELECT_INCLUDE if there's a <sys/select.h> file (mainly for Unix) 
+     to be used with FILES_HAVE_FDS. */
+
+ /* BSTRING_INCLUDE if there's a <bstring.h> file (mainly for Unix) 
+     to be used with FILES_HAVE_FDS. */
+
+ /* NO_SYS_INCLUDE_SUBDIR if include files should all be <XXX.h>; no
+     includes of the form <sys/XXX.h>. Mainly used for <sys/stat.h>
+     for MacOS. */
+
+ /* USE_FCHDIR uses fchdir() to improve thread context switches when
+    a small number of threads are active. */
+
+ /* USE_GETRUSAGE uses getrusage() to for timing info; otherwise clock()
+    is used. */
+
+ /* USE_SYSCALL_GETRUSAGE uses syscall() to implement getrusage() for
+    timing info. Used with USE_GETRUSAGE. */
+
+ /* NO_SLEEP means that there is no sleep() function. Used only in
+    standalone MzScheme. */
+
+ /* NO_USLEEP means that there is no usleep() function. Used only in 
+    standalone MzScheme. Used only if NO_SLEEP is undefined. */
+
+ /* WIN32S_HACK uses a special hack to implement threads under Win32s
+    with some compilers. Obsolete. */
+
+#endif  /* FLAGS_ALREADY_SET */
+
+/****** (END CONFIGURATION FLAG DESCRPTIONS AND DEFAULTS) *******/
+
+#endif  /* FLAGS_ALREADY_SET */
diff --git a/src/mzscheme/sgc/Makefile b/src/mzscheme/sgc/Makefile
new file mode 100644
index 0000000..eb309d6
--- /dev/null
+++ b/src/mzscheme/sgc/Makefile
@@ -0,0 +1,74 @@
+#
+# Makefile for SenoraGC
+#
+
+# This must be an ANSI C compiler.
+CC=gcc
+CXX=gcc
+AS=gcc -c -x assembler-with-cpp
+
+# Debugging flags
+DEBUGFLAGS = -g
+
+# Other options; mainly used to import other options
+OPTIONS =
+
+# Optimization
+OPT = -O 
+
+# Warnings
+WARN = -Wall 
+
+OBJDIR = objects/sys$(MZPLATFORMSUFFIX)
+
+CFLAGS_NODBG = $(OPT) $(WARN) $(OPTIONS) -I.
+CFLAGS = $(DEBUGFLAGS) $(CFLAGS_NODBG)
+
+OBJS =  $(OBJDIR)/sgc.o
+
+SRCS =  sgc.c
+
+wrong:
+	# Make from the directory above this one
+
+test: $(OBJS) $(OBJDIR)/test.o $(OBJDIR)/sgc.o
+	$(CC) $(CFLAGS_NODBG) -o test $(OBJS) $(OBJDIR)/test.o
+
+$(OBJDIR)/gc.a: objects $(OBJDIR) $(OBJS)
+	$(MAKE) gcobjects
+	$(AR) ruv $(OBJDIR)/gc.a $(OBJS)
+
+gcobjects: $(OBJS)
+
+c++: $(OBJDIR)/gc_cpp.o
+	$(AR) ruv $(OBJDIR)/gc.a gc_cpp.o
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+$(OBJDIR)/sgc.o: sgc.c
+	$(CC) $(CFLAGS) -c sgc.c -o $(OBJDIR)/sgc.o
+
+$(OBJDIR)/test.o: test.c
+	$(CC) $(CFLAGS) -c test.c -o $(OBJDIR)/test.o
+
+$(OBJDIR)/gc_cpp.o: gc_cpp.cc
+	$(CXX) $(CFLAGS) -c gc_cpp.cc -o $(OBJDIR)/gc_cpp.o
+
+depend:
+	makedepend -- $(CFLAGS) -- $(SRCS)
+
+clean:
+	/bin/rm -f $(OBJS) objects/*/* test *~ Makefile.bak
+
+# Note: 'make depend' is no longer required. As distributed, the below
+#       dependencies have been trimmed to include only dependencies
+#       on MzScheme files
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+$(OBJDIR)/sgc.o: sgc.h
+
+$(OBJDIR)/test.o: sgc.h
diff --git a/src/mzscheme/sgc/checkreg b/src/mzscheme/sgc/checkreg
new file mode 100755
index 0000000..910f72d
--- /dev/null
+++ b/src/mzscheme/sgc/checkreg
@@ -0,0 +1,179 @@
+#!/bin/sh
+string=? ; exec ${PLTHOME}/bin/mzscheme -gqr $0 "$@"
+
+; Script to check that global and static variables are registered
+
+(define ignore-types (list "int" "long" "short" "double" "float" "DWORD"))
+
+(define-struct decl (type file))
+
+(define declared (make-hash-table))
+(define registered (make-hash-table))
+
+(define spaces (string #\[ #\space #\tab #\] #\*))
+(define id "[a-zA-Z0-9_]+")
+(define type-suffix "[*]+")
+
+(define open-comment-regexp (regexp "/\\*(.*)"))
+(define close-comment-regexp (regexp "\\*/(.*)"))
+
+(define quote-regexp (regexp "((^[^\"]*|^[^\"]*[^\\]))\"(.*)"))
+(define char-regexp (regexp "(.*)'.'(.*)"))
+(define open-regexp (regexp "^([^{}]*){(.*)"))
+(define close-regexp (regexp "^([^{}]*)}(.*)"))
+(define id-regexp (regexp id))
+(define prefixed-id-regexp (regexp (format "(~a)~a(~a)" type-suffix spaces id)))
+(define extern-regexp (regexp (format "~aextern~a[^;]*;(.*)"
+				       spaces
+				       spaces)))
+(define typedef-regexp (regexp (format "~atypedef~a[^;]*;(.*)"
+				       spaces
+				       spaces)))
+(define declare-regexp (regexp (format "~a(~a)~a([^();]*);(.*)"
+				       spaces
+				       id
+				       spaces)))
+(define static-regexp (regexp (format "~astatic~a(~a)~a([^();]*);(.*)"
+				      spaces
+				      spaces
+				      id
+				      spaces)))
+(define register-regexp (regexp (format "(.*)REGISTER_SO[(](~a)[)](.*)"
+					id)))
+
+(define comma-regexp (regexp "(.*),(.*)"))
+(define equal-regexp (regexp "(.*)=(.*)"))
+
+(define starts-close-comment
+  (lambda (l)
+    (let ([m (regexp-match close-comment-regexp l)])
+      (if m
+	  (let ([post (cadr m)]
+		[pre (substring l 0 (- (string-length l)
+				       (string-length (car m))))])
+	    (list l pre post))
+	  #f))))
+
+(define starts-open-comment
+  (lambda (l)
+    (let ([m (regexp-match open-comment-regexp l)])
+      (if m
+	  (let ([post (cadr m)]
+		[pre (substring l 0 (- (string-length l)
+				       (string-length (car m))))])
+	    (if (or (regexp-match quote-regexp pre)
+		    (regexp-match open-comment-regexp pre)
+		    (regexp-match close-comment-regexp pre))
+		#f
+		(list l pre post)))
+	  #f))))
+
+(define (declare type vars orig file)
+  (cond
+   [(regexp-match comma-regexp vars)
+    => (lambda (m) 
+	 (declare type (cadr m) orig file)
+	 (declare type (caddr m) orig file))]
+   [(regexp-match equal-regexp vars)
+    => (lambda (m) 
+	 (declare type (cadr m) orig file))]
+   [(regexp-match prefixed-id-regexp vars)
+    => (lambda (m)
+	 (declare (string-append type (cadr m))
+		  (caddr m) orig file))]
+   [(regexp-match id-regexp vars)
+    => (lambda (m)
+	 (unless (member type ignore-types)
+		 (hash-table-put! declared (string->symbol (car m)) 
+				  (make-decl type file))))]
+   [else
+    '(fprintf (current-error-port)
+	     "Warning: no variable in ~s of ~s"
+	     vars orig)]))
+
+(define (check-file file)
+  (let loop ([depth 0][comment? #f][string? #f])
+    (let ([l (read-line)])
+      (unless (eof-object? l)
+	 (let parse ([l l][depth depth][comment? comment?][string? string?][k loop])
+	   (cond
+	    [(and comment? (starts-close-comment l))
+	     => (lambda (m)
+		  (parse (caddr m) depth #f #f k))]
+	    [comment?
+	     (k depth #t #f)]
+	    [(and (not string?) (starts-open-comment l))
+	     => (lambda (m)
+		  (parse (cadr m) depth #f #f
+			 (lambda (depth comment? string?)
+			   (parse (caddr m) depth #t #f k))))]
+	    [(regexp-match quote-regexp l)
+	     => (lambda (m)
+		  (parse (cadr m) depth #f string?
+			 (lambda (depth comment? string?)
+			   (parse (cadddr m) depth #f string? k))))]
+	    [string? (k depth #f #t)]
+	    [(regexp-match char-regexp l)
+	     => (lambda (m)
+		  (parse (cadr m) depth #f #f
+			 (lambda (depth comment? string?)
+			   (parse (caddr m) depth #f #f k))))]
+	    [(regexp-match open-regexp l)
+	     => (lambda (m)
+		  (parse (cadr m) depth #f #f void)
+		  (parse (caddr m) (add1 depth) #f #f k))]
+	    [(regexp-match close-regexp l)
+	     => (lambda (m)
+		  (unless (positive? depth)
+			  (error 'imbalance "in ~s in ~a at ~a" file
+				 l
+				 (file-position (current-input-port))))
+		  (parse (cadr m) depth #f #f void)
+		  (parse (caddr m) (sub1 depth) #f #f k))]
+	    [(or (regexp-match extern-regexp l)
+		 (regexp-match typedef-regexp l))
+	     => (lambda (m) 
+		  (parse (cadr m) depth #f #f k))]
+	    [(or (regexp-match static-regexp l)
+		 (and (zero? depth) (regexp-match declare-regexp l)))
+	     => (lambda (m) 
+		  (declare (cadr m) (caddr m) l file)
+		  (parse (cadddr m) depth #f #f k))]
+	    [(regexp-match register-regexp l)
+	     => (lambda (m)
+		  (parse (cadr m) depth #f #f void)
+		  (hash-table-put! registered (string->symbol (caddr m)) #t)
+		  (parse (cadddr m) depth #f #f k))]
+	    [else (k depth #f #f)]))))))
+
+(for-each
+ (lambda (file)
+   (with-input-from-file file
+     (lambda ()
+       (check-file file))))
+ (vector->list argv))
+
+#|
+(printf "Declared: ~n")
+(hash-table-for-each declared
+		     (lambda (k v)
+		       (printf "  ~a:   ~a : ~a~n" 
+			       (decl-file v) k (decl-type v))))
+
+(printf "Registered: ~n")
+(hash-table-for-each registered
+		     (lambda (k v)
+		       (printf "  ~a~n" k)))
+
+|#
+
+(printf "Declared but not registered: ~n")
+(hash-table-for-each declared
+		     (lambda (k v)
+		       (hash-table-get registered
+				       k
+				       (lambda ()
+					 (printf "  ~a:   ~a : ~a~n" 
+						 (decl-file v) k 
+						 (decl-type v))))))
+
diff --git a/src/mzscheme/sgc/gc.h b/src/mzscheme/sgc/gc.h
new file mode 100644
index 0000000..f02b2e2
--- /dev/null
+++ b/src/mzscheme/sgc/gc.h
@@ -0,0 +1,3 @@
+
+/* gc.h -> sgc.h */
+#include "sgc.h"
diff --git a/src/mzscheme/sgc/gc_cpp.cc b/src/mzscheme/sgc/gc_cpp.cc
new file mode 100644
index 0000000..a1f483b
--- /dev/null
+++ b/src/mzscheme/sgc/gc_cpp.cc
@@ -0,0 +1,102 @@
+/*************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+    Last modified on Sat Nov 19 19:31:14 PST 1994 by ellis
+                  on Sat Jun  8 15:10:00 PST 1994 by boehm
+
+Permission is hereby granted to copy this code for any purpose,
+provided the above notices are retained on all copies.
+
+This implementation module for gc_c++.h provides an implementation of
+the global operators "new" and "delete" that calls the Boehm
+allocator.  All objects allocated by this implementation will be
+non-collectable but part of the root set of the collector.
+
+You should ensure (using implementation-dependent techniques) that the
+linker finds this module before the library that defines the default
+built-in "new" and "delete".
+
+Authors: John R. Ellis and Jesse Hull
+
+MATTHEW: This file is greatly modified from the distributed version
+for MrEd
+
+**************************************************************************/
+/* Boehm, December 20, 1994 7:26 pm PST */
+
+#include <stdlib.h>
+#include "gc_cpp.h"
+
+struct GC_Set *wx_objects, *cpp_objects;
+
+#ifdef USE_WXOBJECT_TRACE_COUNTER
+extern void wxTraceCount(void *, int);
+extern void wxTracePath(void *, unsigned long, void *);
+extern void wxTraceInit(void);
+extern void wxTraceDone(void);
+extern void wxObjectFinalize(void *);
+#endif
+
+void *GC_cpp_malloc(size_t size)
+{
+  if (!wx_objects)
+    wx_objects = GC_new_set("wxObjects", 
+#ifdef USE_WXOBJECT_TRACE_COUNTER
+			    wxTraceInit,
+			    wxTraceDone,
+			    wxTraceCount,
+			    wxTracePath,
+			    wxObjectFinalize,
+#else
+			    NULL, NULL, NULL, NULL, NULL,
+#endif
+			    0);
+
+  return GC_malloc_specific(size, wx_objects);
+}
+
+void GC_cpp_delete(void*) 
+{
+}
+
+void* operator new(size_t size) 
+{
+  if (!cpp_objects)
+    cpp_objects = GC_new_set("C++", NULL, NULL, NULL, NULL, NULL, 0);
+
+  return GC_malloc_specific(size, cpp_objects);
+}
+  
+void operator delete( void* obj ) {
+}
+  
+
+#ifdef OPERATOR_NEW_ARRAY
+
+void* operator new[](size_t size)
+{
+  if (!cpp_objects)
+    cpp_objects = GC_new_set("C++", NULL, NULL, NULL, NULL, NULL, 0);
+
+  return GC_malloc_specific(size, cpp_objects);
+}
+  
+void operator delete[](void*) {
+}
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+
+void GC_cpp_for_each(void (*f)(void *, int, void *), void *data)
+{
+  if (wx_objects)
+    GC_for_each_element(wx_objects, f, data);
+}
+
+int GC_is_wx_object(void *v)
+{
+  return wx_objects && (GC_set(v) == wx_objects);
+}
diff --git a/src/mzscheme/sgc/gc_cpp.h b/src/mzscheme/sgc/gc_cpp.h
new file mode 100644
index 0000000..25664e2
--- /dev/null
+++ b/src/mzscheme/sgc/gc_cpp.h
@@ -0,0 +1,323 @@
+#ifndef GC_CPP_H
+#define GC_CPP_H
+#if 0
+/****************************************************************************
+Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ 
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ 
+Permission is hereby granted to use or copy this program for any
+purpose, provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is
+granted, provided the above notices are retained, and a notice that
+the code was modified is included with the above copyright notice.
+****************************************************************************
+
+C++ Interface to the Boehm Collector
+
+    John R. Ellis and Jesse Hull 
+    Last modified on Wed Jan  4 16:30:20 PST 1995 by ellis
+
+MATTHEW: This file is greatly modified from the distributed version
+for MrEd
+
+This interface provides access to the Boehm collector.  It provides
+basic facilities similar to those described in "Safe, Efficient
+Garbage Collection for C++", by John R. Elis and David L. Detlefs
+(ftp.parc.xerox.com:/pub/ellis/gc).
+
+All heap-allocated objects are either "collectable" or
+"uncollectable".  Programs must explicitly delete uncollectable
+objects, whereas the garbage collector will automatically delete
+collectable objects when it discovers them to be inaccessible.
+Collectable objects may freely point at uncollectable objects and vice
+versa.
+
+Objects allocated with the built-in "::operator new" are uncollectable.
+
+Objects derived from class "gc" are collectable.  For example:
+
+    class A: gc {...};
+    A* a = new A;       // a is collectable. 
+
+Collectable instances of non-class types can be allocated using the GC
+placement:
+
+    typedef int A[ 10 ];
+    A* a = new (GC) A;
+
+Uncollectable instances of classes derived from "gc" can be allocated
+using the NoGC placement:
+
+    class A: gc {...};
+    A* a = new (NoGC) A;   // a is uncollectable.
+
+Both uncollectable and collectable objects can be explicitly deleted
+with "delete", which invokes an object's destructors and frees its
+storage immediately.
+
+A collectable object may have a clean-up function, which will be
+invoked when the collector discovers the object to be inaccessible.
+An object derived from "gc_cleanup" or containing a member derived
+from "gc_cleanup" has a default clean-up function that invokes the
+object's destructors.  Explicit clean-up functions may be specified as
+an additional placement argument:
+
+    A* a = ::new (GC, MyCleanup) A;
+
+An object is considered "accessible" by the collector if it can be
+reached by a path of pointers from static variables, automatic
+variables of active functions, or from some object with clean-up
+enabled; pointers from an object to itself are ignored.
+
+Thus, if objects A and B both have clean-up functions, and A points at
+B, B is considered accessible.  After A's clean-up is invoked and its
+storage released, B will then become inaccessible and will have its
+clean-up invoked.  If A points at B and B points to A, forming a
+cycle, then that's considered a storage leak, and neither will be
+collectable.  See the interface gc.h for low-level facilities for
+handling such cycles of objects with clean-up.
+
+The collector cannot guarrantee that it will find all inaccessible
+objects.  In practice, it finds almost all of them.
+
+
+Cautions:
+
+1. Be sure the collector has been augmented with "make c++".
+
+2.  If your compiler supports the new "operator new[]" syntax, then
+add -DOPERATOR_NEW_ARRAY to the Makefile.
+
+If your compiler doesn't support "operator new[]", beware that an
+array of type T, where T is derived from "gc", will by default be
+allocated as an uncollectable object.  Use the explicit GC placement
+to make the array collectable.  For example:
+
+    class A: gc {...};
+    A* a1 = new A[ 10 ];        // uncollectable
+    A* a2 = new (GC) A[ 10 ];   // collectable
+
+3. Arrays of objects derived from "gc_cleanup" do not have default
+clean-up functions.  For example:
+
+    class A: gc_cleanup {...};
+    A* a = new (GC) A[ 10 ];
+
+The elements of "a" will not have their destructors invoked when the
+collector frees "a".  You must supply an explicit clean-up function
+for that to occur.
+
+4. Compiler bugs:
+
+    Solaris 2's CC (SC3.0) doesn't implement t->~T() correctly, so the
+    destructors of classes derived from gc_cleanup won't be invoked.
+    You'll have to explicitly register a clean-up function with
+    new-placement syntax.
+
+    Evidently cfront 3.0 does not allow destructors to be explicitly
+    invoked using the ANSI-conforming syntax t->~T().  If you're using
+    cfront 3.0, you'll have to comment out the class gc_cleanup, which
+    uses explicit invocation.
+
+****************************************************************************/
+#endif
+
+#include "sgc.h"
+
+#ifndef THINK_CPLUS
+#define _cdecl
+#endif
+
+#if __BORLANDC__ >= 0x450 && !defined(OPERATOR_NEW_ARRAY)
+#   define OPERATOR_NEW_ARRAY
+#endif
+
+/* MATTHEW: GC => UseGC, Added AtomicGC */
+enum GCPlacement {UseGC, AtomicGC, NoGC};
+
+class gc {public:
+    inline void* operator new( size_t size );
+    inline void* operator new( size_t size, GCPlacement gcp );
+    inline void operator delete( void* obj );
+
+#ifdef OPERATOR_NEW_ARRAY
+    inline void* operator new[]( size_t size );
+    inline void* operator new[]( size_t size, GCPlacement gcp );
+    inline void operator delete[]( void* obj );
+#endif /* OPERATOR_NEW_ARRAY */
+    };    
+    /*
+    Instances of classes derived from "gc" will be allocated in the 
+    collected heap by default, unless an explicit NoGC placement is
+    specified. */
+
+/* MATTHEW: gcc 2.5.8 doesn't like "virtual" here: */
+class gc_cleanup: /* virtual */ public gc {public:
+    void *__gc_external; /* MATTHEW: Need a pointer for MzScheme/MrEd */					    
+    inline gc_cleanup();
+    inline gc_cleanup(int cleanup);
+    inline virtual ~gc_cleanup();
+    inline void install_cleanup();
+private:
+    inline static void _cdecl cleanup( void* obj, void* clientData );
+};
+    /*
+    Instances of classes derived from "gc_cleanup" will be allocated
+    in the collected heap by default.  When the collector discovers an
+    inaccessible object derived from "gc_cleanup" or containing a
+    member derived from "gc_cleanup", its destructors will be
+    invoked. */
+
+extern "C" {typedef void (*GCCleanUpFunc)( void* obj, void* clientData );}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    Allocates a collectable or uncollected object, according to the
+    value of "gcp".
+
+    For collectable objects, if "cleanup" is non-null, then when the
+    allocated object "obj" becomes inaccessible, the collector will
+    invoke the function "cleanup( obj, clientData )" but will not
+    invoke the object's destructors.  It is an error to explicitly
+    delete an object allocated with a non-null "cleanup".
+
+    It is an error to specify a non-null "cleanup" with NoGC or for
+    classes derived from "gc_cleanup" or containing members derived
+    from "gc_cleanup". */
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[](
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup = 0,
+    void* clientData = 0 );
+    /*
+    The operator new for arrays, identical to the above. */
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+/****************************************************************************
+
+Inline implementation
+
+****************************************************************************/
+
+extern void *GC_cpp_malloc(size_t);
+extern void GC_cpp_delete(void *);
+
+inline void* gc::operator new( size_t size ) {
+  return GC_cpp_malloc( size );
+}
+    
+inline void gc::operator delete( void *obj ) {
+#if SGC_STD_DEBUGGING
+  GC_cpp_delete(obj);
+#endif
+}
+    
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* gc::operator new[]( size_t size ) {
+    return gc::operator new(size);
+}
+    
+inline void* gc::operator new[]( size_t size, GCPlacement gcp ) {
+    return gc::operator new(size, gcp);
+}
+
+inline void gc::operator delete[]( void* obj ) {
+    gc::operator delete( obj );
+}
+    
+#endif /* OPERATOR_NEW_ARRAY */
+
+extern "C" {
+  extern void gc_mark_external_invalid(void *);
+};
+
+inline gc_cleanup::~gc_cleanup(void) {
+  GC_register_finalizer_ignore_self(this, 0, 0, 0, 0);
+  if (__gc_external) gc_mark_external_invalid(__gc_external);
+}
+
+inline void gc_cleanup::cleanup( void* obj, void* displ ) {
+  gc_cleanup *clean = ((gc_cleanup*) ((char *)obj + (unsigned long)displ));
+  clean->~gc_cleanup();
+
+#if SGC_STD_DEBUGGING
+  GC_cpp_delete((void *)obj);
+#endif
+}
+
+inline void gc_cleanup::install_cleanup(void) {
+  register void *base = GC_base((void *)this);
+
+  if (base) {
+    void (*old_fn)(void *, void*);
+    void *old_data;
+    GC_register_finalizer_ignore_self(base, cleanup,
+				      (void *)((char *)this - (char *)base), 
+				      &old_fn, &old_data);
+    if (old_fn)
+      /* MATTHEW: Put the old one back. We don't need to register. */
+      GC_register_finalizer_ignore_self(base, old_fn, old_data, 
+					&old_fn, &old_data);
+  }
+}
+
+inline gc_cleanup::gc_cleanup(void) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  install_cleanup();
+}
+
+inline gc_cleanup::gc_cleanup(int cleanup) {
+  __gc_external = NULL; /* MATTHEW: Initialize my hack */
+  if (cleanup)
+    install_cleanup();
+}
+
+inline void* operator new( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+  void* obj;
+  
+  if (gcp == UseGC) { /* MATTHEW: GC => UseGC */
+    obj = GC_malloc(size);
+    if (cleanup != 0) 
+      GC_register_finalizer_ignore_self(obj, cleanup, clientData, 0, 0);
+  } if (gcp == AtomicGC) /* MATTHEW: Added AtomicGC */
+    obj = GC_malloc_atomic( size );
+  else
+    obj = GC_malloc_uncollectable( size );
+
+  return obj;
+}
+        
+
+#ifdef OPERATOR_NEW_ARRAY
+
+inline void* operator new[]( 
+    size_t size, 
+    GCPlacement gcp,
+    GCCleanUpFunc cleanup,
+    void* clientData )
+{
+    return ::operator new( size, gcp, cleanup, clientData );
+  }
+
+#endif /* OPERATOR_NEW_ARRAY */
+
+
+#endif /* GC_CPP_H */
+
diff --git a/src/mzscheme/sgc/sgc.c b/src/mzscheme/sgc/sgc.c
new file mode 100644
index 0000000..ec5d48d
--- /dev/null
+++ b/src/mzscheme/sgc/sgc.c
@@ -0,0 +1,4750 @@
+/*
+  SenoraGC, a relatively portable conservative GC for a slightly
+    cooperative environment
+  Copyright (c) 1996-97 Matthew Flatt
+  All rights reserved.
+
+  After Boehm et al.
+
+  Please see the full copyright in the documentation.
+
+  This collector is intended mainly for debugging and memory tracing,
+  but it can also act as a reasonbaly effecient, general-purpose
+  conservative collector.
+
+  It's probably still a little hardwired for 32-bit addresses.
+
+  The stack base must be manually identified with GC_set_stack_base();
+  no garbage collection will occur before this function is called.
+
+  All non-stack/register roots (i.e., global variables) must be
+  registered with GC_add_roots(). For certain platforms, this is
+  actually done automatically for static variables, but it can't be 
+  done portably in general. (See AUTO_STATIC_ROOTS_IF_POSSIBLE in
+  the flags section.)
+
+  GC space is allocated using malloc() and free(). Alternatively, the
+  GC can define malloc() and free() itself if platform-specific
+  allocation routines are supported.  
+  
+  This collector is not recommended as a replacement for Boehm's GC if
+  you can get Boehm's to work at all. SenoraGC MIGHT be useful if, for
+  some reason, Boehm's collector does not work for your platform.
+  SenoraGC MIGHT be useful as a debugging collector if you can figure
+  out the [undocumented] debugging utilities. */
+
+#include <stdlib.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <memory.h>
+#include "../sconfig.h"
+#include "sgc.h"
+
+/****************************************************************************/
+/* Option bundles                                                           */
+/****************************************************************************/
+
+#ifndef SGC_STD_DEBUGGING
+# define SGC_STD_DEBUGGING 0
+#endif
+
+#ifdef WIN32
+# define SGC_STD_DEBUGGING_UNIX 0
+# define SGC_STD_DEBUGGING_WINDOWS SGC_STD_DEBUGGING
+#else
+# define SGC_STD_DEBUGGING_UNIX SGC_STD_DEBUGGING
+# define SGC_STD_DEBUGGING_WINDOWS 0
+#endif
+
+/****************************************************************************/
+/* Options and debugging flags                                              */
+/****************************************************************************/
+
+#define NO_COLLECTIONS 0
+/* Disable all collections */
+
+#define NO_DISAPPEARING 0
+/* Never perform disappearing link */
+
+#define NO_FINALIZING 0
+/* Never invoke queued finalizers */
+
+#define NO_ATOMIC 0
+/* Never treat allocated data as atomic */
+
+#define NO_FREE_BLOCKS 0
+/* Keep small-chunk assignment of a block forever */
+
+#define NO_STACK_OFFBYONE 0
+/* Don't notice a stack-based pointer just past the end of an object */
+
+#define WATCH_FOR_FINALIZATION_CYCLES 0
+/* Report cycles in finalizable chunks */
+
+#define PROVIDE_GC_FREE 0
+/* Provide GC_free; automatically implies DISTINGUISH_FREE_FROM_UNMARKED */
+
+#define PROVIDE_MALLOC_AND_FREE SGC_STD_DEBUGGING_UNIX
+/* Defines malloc(), realloc(), calloc(), and  free() in terms of 
+   the collector. Platform-specific allocation routines (e.g., sbrk())
+   must then be used for low-level allocations by the collector;
+   turn on one of: GET_MEM_VIA_SBRK.
+   This will not work if fprintf uses malloc of free. Turing on
+   FPRINTF_USE_PRIM_STRINGOUT can solve this problem.
+   Automatically implies PROVIDE_GC_FREE, but adds extra checks to
+   CHECK_FREES if PROVIDE_GC_FREE was not otherwise on */
+
+#define GET_MEM_VIA_SBRK SGC_STD_DEBUGGING_UNIX
+/* Instead of calling malloc() to get low-level memory, use
+   sbrk() directly. (Unix) */
+
+#define GET_MEM_VIA_VIRTUAL_ALLOC SGC_STD_DEBUGGING_WINDOWS
+/* Instead of calling malloc() to get low-level memory, use
+   VirtualAlloc() directly. (Win32) */
+
+#define DISTINGUISH_FREE_FROM_UNMARKED 0
+/* Don't let conservatism resurrect a previously-collected block */
+
+#define TERSE_MEMORY_TRACING 0
+/* Automatically implies ALLOW_TRACE_COUNT, ALLOW_TRACE_PATH,
+   ALLOW_SET_FINALIZER, and CHECK_WATCH_FOR_PTR_ALLOC */
+
+#define STD_MEMORY_TRACING SGC_STD_DEBUGGING
+/* Automatically implies TERSE_MEMORY_TRACING and 
+   DUMP_BLOCK_COUNTS */
+
+#define DETAIL_MEMORY_TRACING 1
+/* Automatically implies STD_MEMORY_TRACING, DUMP_BLOCK_MAPS, 
+   STAMP_AND_REMEMBER_SOURCE, and KEEP_DETAIL_PATH */
+
+#define STAMP_AND_REMEMBER_SOURCE 0
+/* Keep timestamps and source of marking from collection */
+
+#define ALLOW_TRACE_COUNT 0
+/* Support collection-based trace count callbacks */
+
+#define ALLOW_TRACE_PATH 0
+/* Support collection-based trace path callbacks */
+
+#define KEEP_DETAIL_PATH 0
+/* Keep source offsets for path traces */
+
+#define ALLOW_SET_LOCKING 0
+/* Enables locking out collections for a specific set. */
+
+#define ALLOW_SET_FINALIZER 0
+/* Support the per-set custom "de-allocation" callback. */
+
+#define CHECK_WATCH_FOR_PTR_ALLOC SGC_STD_DEBUGGING
+/* Set GC_watch_for_ptr to be ~(ptr value);
+   there are 3 places where the ptr is checked, 
+   unless USE_WATCH_FOUND_FUNC is on */
+
+#define USE_WATCH_FOUND_FUNC SGC_STD_DEBUGGING
+/* Calls GC_found_watch when the watch-for ptr is found. */
+
+#define PAD_BOUNDARY_BYTES 0
+/* Put a known padding pattern around every allocated
+   block to test for array overflow/underflow.
+   Pad-testing is performed at the beginning of every GC.
+   Automatically implies CHECK_SIMPLE_INTERIOR_POINTERS */
+
+#define CHECK_SIMPLE_INTERIOR_POINTERS 0
+/* Recognize pointers into the middle of an allocated
+   block, (but do not recognize pointers just past the
+   end of an allocated block, as is generally performed
+   for stack-based pointers). */
+
+#define DUMP_BLOCK_COUNTS SGC_STD_DEBUGGING
+/* GC_dump prints detail information about block and
+   set size contents. */
+
+#define DUMP_BLOCK_MAPS 0
+/* GC_dump prints detail information about block and
+   set address contents. Automatically implies
+   DUMP_BLOCK_COUNTS. */
+
+#define CHECK_FREES SGC_STD_DEBUGGING
+/* Print an error for redundant frees by calling free_error */
+
+#define FPRINTF_USE_PRIM_STRINGOUT SGC_STD_DEBUGGING_WINDOWS
+/* Avoids using fprintf while the GC is running, printing
+   messages instead as pure strings passed to
+    void GC_prim_stringout(char *s, int len);
+   which must be provided at link time, or one of
+   PRIM_STRINGOUT_AS_FWRITE or PRIM_STRINGOUT_AS_WINDOWS_CONSOLE */
+
+#define PRIM_STRINGOUT_AS_FWRITE 0
+/* Implements GC_prim_stringout using fwrite. Not likely to
+   solve any problems, but useful for debugging FPRINTF. */
+
+#define PRIM_STRINGOUT_AS_WINDOWS_CONSOLE SGC_STD_DEBUGGING_WINDOWS
+/* Implements GC_prim_stringout using Windows console
+   functions. */
+
+#define AUTO_STATIC_ROOTS_IF_POSSIBLE 1
+/* Automatically registers static C variables as roots if
+   platform-specific code is porvided */
+
+/****************************************************************************/
+/* Parameters and platform-specific settings                                */
+/****************************************************************************/
+
+/* GC frequency: MEM_USE_FACTOR is max factor between current
+   allocated bytes and alocated bytes after last GC. */
+#ifdef SMALL_HASH_TABLES
+# define FIRST_GC_LIMIT 20000
+# define MEM_USE_FACTOR 1.40
+#else
+# define FIRST_GC_LIMIT 100000
+# define MEM_USE_FACTOR 2
+#endif
+
+#ifdef DOS_FAR_POINTERS
+# include <dos.h>
+# include <alloc.h>
+# define PTR_TO_INT(v) (((((long)FP_SEG(v)) & 0xFFFF) << 4) + FP_OFF(v))
+# define INT_TO_PTR(v) ((void *)((((v) >> 4) << 16) + ((v) & 0xF)))
+# if !PROVIDE_MALLOC_AND_FREE
+#  define MALLOC farmalloc
+#  define FREE farfree
+# endif
+#else
+# define PTR_TO_INT(v) ((unsigned long)(v))
+# define INT_TO_PTR(v) ((void *)(v))
+# if !PROVIDE_MALLOC_AND_FREE
+#  define MALLOC malloc
+#  define FREE free
+# endif
+#endif
+
+#if GET_MEM_VIA_SBRK
+# include <unistd.h>
+#endif
+#ifdef WIN32
+# include <windows.h>
+#endif
+
+/* System-specific alignment of pointers. */
+#define PTR_ALIGNMENT 4
+#define LOG_PTR_SIZE 2
+#define PTR_SIZE (1 << LOG_PTR_SIZE)
+
+/* SECTOR_SEGMENT_SIZE determines the alignment of collector blocks.
+   Since it should be a power of 2, LOG_SECTOR_SEGMENT_SIZE is
+   specified directly. A larger block size speeds up GC, but wastes
+   more unallocated bytes in same-size buckets. */
+# define LOG_SECTOR_SEGMENT_SIZE 12
+#define SECTOR_SEGMENT_SIZE (1 << LOG_SECTOR_SEGMENT_SIZE)
+#define SECTOR_SEGMENT_MASK (~(SECTOR_SEGMENT_SIZE-1))
+
+/* MAX_COMMON_SIZE is maximum size of allocated blocks
+   using relatively efficient memory layouts. */
+#define MAX_COMMON_SIZE (SECTOR_SEGMENT_SIZE >> 2)
+
+#define NUM_COMMON_SIZE ((2 * LOG_SECTOR_SEGMENT_SIZE) + 8)
+
+/* Number of sector segments to be allocated at once with
+   malloc() to avoid waste when obtaining the proper alignment. */
+#define SECTOR_SEGMENT_GROUP_SIZE 32
+
+/* Number of bits used in first level table for checking existance of
+   a sector. Creates a table of (1 << SECTOR_LOOKUP_SHIFT) pointers
+   to individual page tables of size SECTOR_LOOKUP_PAGESIZE. */
+#define SECTOR_LOOKUP_PAGESETBITS 12
+
+#define SECTOR_LOOKUP_SHIFT ((PTR_SIZE*8) - SECTOR_LOOKUP_PAGESETBITS)
+#define LOG_SECTOR_LOOKUP_PAGESIZE ((PTR_SIZE*8) - SECTOR_LOOKUP_PAGESETBITS - LOG_SECTOR_SEGMENT_SIZE)
+#define SECTOR_LOOKUP_PAGESIZE (1 << LOG_SECTOR_LOOKUP_PAGESIZE)
+#define SECTOR_LOOKUP_PAGEMASK (SECTOR_LOOKUP_PAGESIZE - 1)
+
+#define SECTOR_LOOKUP_PAGETABLE(x) (x >> SECTOR_LOOKUP_SHIFT)
+#define SECTOR_LOOKUP_PAGEPOS(x) ((x >> LOG_SECTOR_SEGMENT_SIZE) & SECTOR_LOOKUP_PAGEMASK)
+
+#define LOG_SECTOR_PAGEREC_SIZE (LOG_PTR_SIZE + 1)
+
+/***************************************************************************/
+
+/* Implementation Terminology:
+    "sector" - A low-level block of memory. Given an arbitrary
+               pointer value, whether it is contained in a sector and
+	       the starting point of the sector can be determined in
+	       constant time.
+    "segment" - A portion of a sector, aligned on SECTOR_SEGMENT_SIZE 
+               boundaries.
+    "page" - part of a table for a (partial) mapping from addresses to 
+               segments
+    "block" or "common block" - A block for small memory allocations. Blocks
+               provide allocation by partitioning a sector.
+    "chunk" - A block of memory too large to be a common block. Each chunk
+               is allocated in its own sector.
+    "set" - A collection of blocks & chunks asscoaited with a particular
+               name, "deallocation" function, trace function, etc.
+*/
+
+/***************************************************************************/
+
+/* Debugging the collector: */
+#define CHECK 0
+#define PRINT 0
+#define TIME 0
+#define ALWAYS_TRACE 0
+#define CHECK_COLLECTING 0
+
+#if DETAIL_MEMORY_TRACING
+# undef STD_MEMORY_TRACING
+# undef STAMP_AND_REMEMBER_SOURCE
+# undef DUMP_BLOCK_MAPS
+# undef KEEP_DETAIL_PATH
+# define STD_MEMORY_TRACING 1
+# define STAMP_AND_REMEMBER_SOURCE 1
+# define DUMP_BLOCK_MAPS 1
+# define KEEP_DETAIL_PATH 1
+#endif
+
+#if STD_MEMORY_TRACING
+# undef TERSE_MEMORY_TRACING
+# undef DUMP_BLOCK_COUNTS
+# define TERSE_MEMORY_TRACING 1
+# define DUMP_BLOCK_COUNTS 1
+#endif
+
+#if TERSE_MEMORY_TRACING
+# undef ALLOW_TRACE_COUNT
+# undef ALLOW_TRACE_PATH
+# undef ALLOW_SET_FINALIZER
+# undef CHECK_WATCH_FOR_PTR_ALLOC
+# define ALLOW_TRACE_COUNT 1
+# define ALLOW_TRACE_PATH 1
+# define ALLOW_SET_FINALIZER 1
+# define CHECK_WATCH_FOR_PTR_ALLOC 1
+#endif
+
+#if PAD_BOUNDARY_BYTES
+# undef CHECK_SIMPLE_INTERIOR_POINTERS
+# define CHECK_SIMPLE_INTERIOR_POINTERS 1
+#endif
+
+#if DUMP_BLOCK_MAPS
+# undef DUMP_BLOCK_COUNTS
+# define DUMP_BLOCK_COUNTS 1
+#endif
+
+#if PROVIDE_MALLOC_AND_FREE
+# if !PROVIDE_GC_FREE
+#  define EXTRA_FREE_CHECKS 1
+# endif
+# undef PROVIDE_GC_FREE
+# define PROVIDE_GC_FREE 1
+#else
+# define EXTRA_FREE_CHECKS 0
+#endif
+
+#if PROVIDE_GC_FREE
+# undef DISTINGUISH_FREE_FROM_UNMARKED
+# define DISTINGUISH_FREE_FROM_UNMARKED 1
+#endif
+
+#if ALLOW_TRACE_COUNT || ALLOW_TRACE_PATH || PROVIDE_GC_FREE
+# define KEEP_SET_NO 1
+#else
+# define KEEP_SET_NO 0
+#endif
+
+#if PROVIDE_GC_FREE
+# define KEEP_PREV_PTR 1
+#else
+# define KEEP_PREV_PTR 0
+#endif
+
+#ifndef NULL
+# define NULL 0L
+#endif
+
+#if PAD_BOUNDARY_BYTES
+# define PAD_START_SIZE (2 * sizeof(long))
+# define PAD_END_SIZE sizeof(long)
+# define PAD_PATTERN 0x7c7c7c7c
+# define PAD_FILL_PATTERN 0xc7
+# define SET_PAD(p, s, os) set_pad(p, s, os)
+# define PAD_FORWARD(p) ((void *)(((char *)p) + PAD_START_SIZE))
+# define PAD_BACKWARD(p) ((void *)(((char *)p) - PAD_START_SIZE))
+#else
+# define PAD_FORWARD(p) (p)
+# define PAD_BACKWARD(p) (p)
+#endif
+
+
+void (*GC_out_of_memory)(void);
+
+/* Sector types: */
+enum {
+  sector_kind_free,
+  sector_kind_block,
+  sector_kind_chunk,
+  sector_kind_managed,
+  sector_kind_other
+};
+
+typedef struct MemoryBlock {
+  struct Finalizer *finalizers;
+  unsigned long start;
+  unsigned long end;
+  unsigned long top;
+  short size;
+  short atomic;
+  short elem_per_block;
+#if KEEP_SET_NO
+  short set_no;
+#endif
+  struct MemoryBlock *next;
+#if STAMP_AND_REMEMBER_SOURCE
+  long make_time;
+  long use_time;
+  unsigned long low_marker;
+  unsigned long high_marker;
+#endif
+  unsigned char free[1];
+} MemoryBlock;
+
+#if DISTINGUISH_FREE_FROM_UNMARKED
+
+# define FREE_BIT_PER_ELEM 4
+# define LOG_FREE_BIT_PER_ELEM 2
+# define FREE_BIT_SIZE (8 >> LOG_FREE_BIT_PER_ELEM)
+# define FREE_BIT_START 0x2 
+# define UNMARK_BIT_START 0x1
+
+# define POS_TO_FREE_INDEX(p) (p >> LOG_FREE_BIT_PER_ELEM)
+# define POS_TO_UNMARK_INDEX(p) (p >> LOG_FREE_BIT_PER_ELEM)
+# define POS_TO_FREE_BIT(p) (FREE_BIT_START << ((p & (FREE_BIT_PER_ELEM - 1)) << 1))
+# define POS_TO_UNMARK_BIT(p) (UNMARK_BIT_START << ((p & (FREE_BIT_PER_ELEM - 1)) << 1))
+
+# define ALL_UNMARKED 0x55
+# define ALL_FREE 0xAA
+
+# define _NOT_FREE(x) NOT_FREE(x)
+
+# define SHIFT_UNMARK_TO_FREE(x) ((x & ALL_UNMARKED) << 1)
+# define SHIFT_COPY_FREE_TO_UNMARKED(x) ((x & ALL_FREE) | ((x & ALL_FREE) >> 1))
+
+#else /* !DISTINGUISH_FREE_FROM_UNMARKED */
+
+# define FREE_BIT_PER_ELEM 8
+# define LOG_FREE_BIT_PER_ELEM 3
+# define FREE_BIT_SIZE (8 >> LOG_FREE_BIT_PER_ELEM)
+# define FREE_BIT_START 0x1
+# define UNMARK_BIT_START 0x1
+
+# define POS_TO_FREE_INDEX(p) (p >> LOG_FREE_BIT_PER_ELEM)
+# define POS_TO_UNMARK_INDEX(p) (p >> LOG_FREE_BIT_PER_ELEM)
+# define POS_TO_FREE_BIT(p) (FREE_BIT_START << (p & (FREE_BIT_PER_ELEM - 1)))
+# define POS_TO_UNMARK_BIT(p) (UNMARK_BIT_START << (p & (FREE_BIT_PER_ELEM - 1)))
+
+# define ALL_UNMARKED 0xFF
+
+# define _NOT_FREE(x) 1
+
+#endif /* DISTINGUISH_FREE_FROM_UNMARKED */
+
+#define NOT_FREE(x) (!(x))
+#define IS_FREE(x) (x)
+#define NOT_MARKED(x) (x)
+#define IS_MARKED(x) (!(x))
+
+#define ELEM_PER_BLOCK(b) b->elem_per_block
+
+typedef struct MemoryChunk {
+  struct Finalizer *finalizers;
+  unsigned long start;
+  unsigned long end;
+  struct MemoryChunk *next;
+#if KEEP_PREV_PTR
+  struct MemoryChunk **prev_ptr;
+#endif
+  short atomic;
+  short marked;
+#if STAMP_AND_REMEMBER_SOURCE
+  long make_time;
+  unsigned long marker;
+#endif
+#if KEEP_SET_NO
+  int set_no;
+#endif
+  char data[1];
+} MemoryChunk;
+
+/* If this changes size from 2 ptrs, change LOG_SECTOR_PAGEREC_SIZE */
+typedef struct {
+  long kind;  /* sector_kind_other, etc. */
+  unsigned long start; /* Sector start; may not be accurate if the segment
+                          is deallocated, but 0 => not in any sector */
+} SectorPage;
+
+static SectorPage **sector_pagetables;
+
+typedef struct SectorFreepage {
+  long size; 
+  unsigned long start; /* Sector start */
+  unsigned long end; /* start of next */
+  struct SectorFreepage *next;
+  struct SectorFreepage *prev;
+} SectorFreepage;
+
+static SectorFreepage *sector_freepage_start, *sector_freepage_end;
+
+#define TABLE_HI_SHIFT LOG_SECTOR_SEGMENT_SIZE
+#define TABLE_LO_MASK (SECTOR_SEGMENT_SIZE-1)
+#define EACH_TABLE_COUNT (1 << (LOG_SECTOR_SEGMENT_SIZE - LOG_PTR_SIZE))
+
+typedef struct GC_Set {
+  short atomic, uncollectable;
+#if ALLOW_SET_LOCKING
+  short locked;
+#endif
+  char *name;
+  MemoryBlock **blocks;
+  MemoryBlock **block_ends;
+  MemoryChunk **othersptr;
+#if DUMP_BLOCK_COUNTS
+  unsigned long total;
+#endif
+#if ALLOW_TRACE_COUNT
+  GC_count_tracer count_tracer;
+#endif
+#if ALLOW_TRACE_PATH
+  GC_path_tracer path_tracer;
+#endif
+#if ALLOW_TRACE_COUNT || ALLOW_TRACE_PATH
+  GC_trace_init trace_init;
+  GC_trace_done trace_done;
+#endif
+#if KEEP_SET_NO
+  int no;
+#endif
+#if ALLOW_SET_FINALIZER
+  GC_set_elem_finalizer finalizer;
+#endif
+} GC_Set;
+
+typedef struct GC_SetWithOthers {
+  GC_Set c;
+  MemoryChunk *others;
+} GC_SetWithOthers;
+
+static GC_Set **common_sets;
+static int num_common_sets;
+
+static MemoryBlock *common[NUM_COMMON_SIZE];
+static MemoryBlock *common_ends[NUM_COMMON_SIZE];
+static MemoryBlock *atomic_common[NUM_COMMON_SIZE];
+static MemoryBlock *atomic_common_ends[NUM_COMMON_SIZE];
+static MemoryBlock *uncollectable_common[NUM_COMMON_SIZE];
+static MemoryBlock *uncollectable_common_ends[NUM_COMMON_SIZE];
+static MemoryBlock *uncollectable_atomic_common[NUM_COMMON_SIZE];
+static MemoryBlock *uncollectable_atomic_common_ends[NUM_COMMON_SIZE];
+static MemoryChunk *others, *atomic_others;
+static MemoryChunk *uncollectable_others, *uncollectable_atomic_others;
+
+#if PROVIDE_MALLOC_AND_FREE
+static MemoryBlock *sys_malloc[NUM_COMMON_SIZE];
+static MemoryBlock *sys_malloc_ends[NUM_COMMON_SIZE];
+static MemoryChunk *sys_malloc_others;
+#endif
+
+int GC_dl_entries;
+int GC_fo_entries;
+
+void (*GC_push_other_roots)(void);
+
+typedef struct DisappearingLink {
+  void *watch;
+  void **disappear;
+  void *saved_value;
+  struct DisappearingLink *prev, *next;
+} DisappearingLink;
+
+typedef struct Finalizer {
+  union {
+    void *watch; /* pointer to finalized block; used after queued */
+    int pos;     /* position within common block; used before queued */
+  } u;
+  short eager;
+  short ignore_self;
+  void *data;
+  void (*f)(void *p, void *data);
+  struct Finalizer *prev, *next; /* also not needed for chunks */
+} Finalizer;
+
+static DisappearingLink *disappearing;
+static Finalizer *queued_finalizers, *last_queued_finalizer;
+
+static unsigned long sector_low_plausible, sector_high_plausible;
+static unsigned long low_plausible, high_plausible;
+
+void *GC_stackbottom;
+
+static long mem_use, mem_limit = FIRST_GC_LIMIT;
+
+static long mem_real_use, mem_uncollectable_use;
+
+static long sector_mem_use, sector_admin_mem_use, sector_free_mem_use;
+static long manage_mem_use, manage_real_mem_use;
+
+static long collect_mem_use;
+
+static long num_sector_allocs, num_sector_frees;
+
+static int collect_off;
+
+#if ALLOW_TRACE_COUNT
+static long mem_traced;
+#endif
+
+static long num_chunks;
+static long num_blocks;
+
+void (*GC_collect_start_callback)(void);
+void (*GC_collect_end_callback)(void);
+void (*GC_custom_finalize)(void);
+
+static long roots_count;
+static long roots_size;
+static unsigned long *roots;
+
+#if STAMP_AND_REMEMBER_SOURCE
+static long stamp_clock = 0;
+#endif
+
+static long *size_index_map; /* (1/PTR_SIZE)th of requested size to alloc index */
+static long *size_map; /* alloc index to alloc size */
+
+#if CHECK_COLLECTING
+static int collecting_now;
+#endif
+
+#if FPRINTF_USE_PRIM_STRINGOUT
+static void sgc_fprintf(int, const char *, ...);
+# define FPRINTF sgc_fprintf
+# define STDERR 0
+#else
+# define FPRINTF fprintf
+# define STDERR stderr
+#endif
+
+#if CHECK_FREES
+static void free_error(const char *msg)
+{
+  FPRINTF(STDERR, msg);
+}
+#endif
+
+/*************************************************************/
+
+/* 
+   The kinds of allocation:
+   
+     malloc_sector = returns new SECTOR_SEGMENT_SIZE-aligned memory;
+                     relies on nothing else; the memeory blocks must
+		     be explicitly freed with free_sector; all GC
+		     allocation is perfomed via sectors
+     
+     malloc_managed = malloc "atomic" block used by GC implementation
+                      itself; no GCing should occur during the malloc;
+		      the block is freed with free_managed
+
+     realloc_collect_temp = temporary structures used during gc;
+                            no other allocation can take place
+			    during gc, and all memory will be freed
+                            when GC is done with free_collect_temp
+*/
+
+#if GET_MEM_VIA_SBRK
+static void *platform_plain_sector(int count)
+{
+  caddr_t cur_brk = (caddr_t)sbrk(0);
+  long lsbs = (unsigned long)cur_brk & TABLE_LO_MASK;
+  void *result;
+    
+  if (lsbs != 0) {
+    if ((caddr_t)sbrk(SECTOR_SEGMENT_SIZE - lsbs) == (caddr_t)(-1)) 
+      return 0;
+  }
+
+  result = (caddr_t)sbrk((count << LOG_SECTOR_SEGMENT_SIZE));
+
+  if (result == (caddr_t)(-1)) 
+    return 0;
+
+  return result;
+}
+#else
+# if GET_MEM_VIA_VIRTUAL_ALLOC
+static void *platform_plain_sector(int count)
+{
+  /* Since 64k blocks are used up by each call to VirtualAlloc,
+     use roughly the same trick as in the malloc-based alloc to
+     avoid wasting ther address space. */
+
+  static int prealloced;
+  static void *preallocptr;
+  
+  if (!prealloced && (count < SECTOR_SEGMENT_GROUP_SIZE)) {
+    prealloced = SECTOR_SEGMENT_GROUP_SIZE;
+    preallocptr = VirtualAlloc(NULL, prealloced << LOG_SECTOR_SEGMENT_SIZE,
+			       MEM_COMMIT | MEM_RESERVE,
+			       PAGE_READWRITE);		
+  }
+  
+  if (count <= prealloced) {
+    void *result = preallocptr;
+    preallocptr = ((char *)preallocptr) + (count << LOG_SECTOR_SEGMENT_SIZE);
+    prealloced -= count;
+    return result;
+  }
+  
+  return VirtualAlloc(NULL, count << LOG_SECTOR_SEGMENT_SIZE,
+		      MEM_COMMIT | MEM_RESERVE,
+		      PAGE_READWRITE);
+}
+# else
+
+#  if PROVIDE_MALLOC_AND_FREE
+  >> 
+  Error: you must pick a platform-specific allocation mechanism
+  to support malloc() and free() 
+  <<
+#  endif
+
+static void *platform_plain_sector(int count)
+{
+  static int prealloced;
+  static void *preallocptr;
+
+  if (!prealloced) {
+    unsigned long d;
+
+    if (count <= (SECTOR_SEGMENT_GROUP_SIZE-1))
+      prealloced = SECTOR_SEGMENT_GROUP_SIZE-1;
+    else
+      prealloced = count;
+
+    preallocptr = MALLOC((prealloced + 1) << LOG_SECTOR_SEGMENT_SIZE);
+
+    d = ((unsigned long)preallocptr) & TABLE_LO_MASK;
+    if (d)
+      preallocptr = ((char *)preallocptr) + (SECTOR_SEGMENT_SIZE - d);
+  }
+
+  if (prealloced >= count) {
+    void *r = preallocptr;
+
+    prealloced -= count;
+    preallocptr = ((char *)preallocptr) + (count << LOG_SECTOR_SEGMENT_SIZE);
+    
+    return r;
+  }
+
+  {
+    unsigned long d;
+    void *r;
+
+    r = MALLOC((count + 1) << LOG_SECTOR_SEGMENT_SIZE);
+
+    d = ((unsigned long)r) & TABLE_LO_MASK;
+    if (d)
+      r = ((char *)r) + (SECTOR_SEGMENT_SIZE - d);
+
+    return r;
+  }
+}
+# endif
+#endif
+
+static void *malloc_plain_sector(int count)
+{
+  void *m;
+
+  m = platform_plain_sector(count);
+
+  if (!m) {
+    if (GC_out_of_memory)
+      GC_out_of_memory();
+    FPRINTF(STDERR, "out of memory\n");	
+    exit(-1);
+  }
+
+  return m;
+}
+
+static void register_sector(void *naya, int need, long kind)
+{
+  unsigned long ns, orig_ns;
+  int pagetableindex, pageindex, i;
+  SectorPage *pagetable;
+
+  orig_ns = ns = PTR_TO_INT(naya);
+  if (!sector_low_plausible || (ns < sector_low_plausible))
+    sector_low_plausible = ns;
+  if (!sector_high_plausible 
+      || (ns + (need << LOG_SECTOR_SEGMENT_SIZE) > sector_high_plausible))
+    sector_high_plausible = ns + (need << LOG_SECTOR_SEGMENT_SIZE);
+
+  /* Register pages as existing: */
+  for (i = need; i--; ns += SECTOR_SEGMENT_SIZE) {
+    pagetableindex = SECTOR_LOOKUP_PAGETABLE(ns);
+    pagetable = sector_pagetables[pagetableindex];
+    if (!pagetable) {
+      int c = (LOG_SECTOR_LOOKUP_PAGESIZE + LOG_SECTOR_PAGEREC_SIZE) - LOG_SECTOR_SEGMENT_SIZE;
+      int j;
+      
+      if (c < 0)
+	c = 0;
+      c = 1 << c;
+      pagetable = (SectorPage *)malloc_plain_sector(c);
+      sector_pagetables[pagetableindex] = pagetable;
+      sector_admin_mem_use += (c << LOG_SECTOR_SEGMENT_SIZE);
+      for (j = 0; j < SECTOR_LOOKUP_PAGESIZE; j++) {
+	pagetable[j].start = 0; 
+	pagetable[j].kind = sector_kind_free;
+      }
+    }
+
+    pageindex = SECTOR_LOOKUP_PAGEPOS(ns);
+    pagetable[pageindex].kind = kind;
+    pagetable[pageindex].start = orig_ns;
+  }
+}
+
+static void *malloc_sector(long size, long kind)
+{
+  long need, i;
+  void *naya;
+  SectorFreepage *fp;
+
+#if CHECK_COLLECTING
+  if (collecting_now) {
+    free_error("alloc while collecting\n");
+    return NULL;
+  }
+#endif
+
+  num_sector_allocs++;
+
+  if (!sector_pagetables) {
+    int c = (SECTOR_LOOKUP_PAGESETBITS + LOG_PTR_SIZE) - LOG_SECTOR_SEGMENT_SIZE;
+    if (c < 0)
+      c = 0;
+    c = 1 << c;
+    sector_pagetables = (SectorPage **)malloc_plain_sector(c);
+    sector_admin_mem_use += (c << LOG_SECTOR_SEGMENT_SIZE);
+    for (i = 0; i < (1 << SECTOR_LOOKUP_PAGESETBITS); i++)
+      sector_pagetables[i] = NULL;
+  }
+
+  need = (size + SECTOR_SEGMENT_SIZE - 1) / SECTOR_SEGMENT_SIZE;
+
+  /* This is best fit because the free-list is sorted: */
+  fp = sector_freepage_start;
+  while (fp) {
+    if (fp->size >= need) {
+      naya = INT_TO_PTR(fp->start);
+      register_sector(naya, need, kind);
+      if (fp->size > need) {
+	/* Move freepage info and shrink */
+	SectorFreepage *naya;
+	unsigned long nfp;
+	nfp = fp->start + (need << LOG_SECTOR_SEGMENT_SIZE);
+	naya = (SectorFreepage *)INT_TO_PTR(nfp);
+	naya->size = fp->size - need;
+	naya->start = nfp;
+	naya->end = fp->end;
+	naya->prev = fp->prev;
+	naya->next = fp->next;
+	if (fp->prev)
+	  fp->prev->next = naya;
+	else
+	  sector_freepage_start = naya;
+	if (fp->next)
+	  fp->next->prev = naya;
+	else
+	  sector_freepage_end = naya;
+      } else {
+	/* Remove freepage */
+	if (fp->prev)
+	  fp->prev->next = fp->next;
+	else
+	  sector_freepage_start = fp->next;
+	if (fp->next)
+	  fp->next->prev = fp->prev;
+	else
+	  sector_freepage_end = fp->prev;
+      }
+
+      sector_free_mem_use -= (need << LOG_SECTOR_SEGMENT_SIZE);
+      return naya;
+    } else
+      fp = fp->next;
+  }
+
+  naya = malloc_plain_sector(need);
+  sector_mem_use += (need << LOG_SECTOR_SEGMENT_SIZE);
+  register_sector(naya, need, kind);
+
+  return naya;
+}
+
+static void free_sector(void *p)
+{
+  unsigned long s = PTR_TO_INT(p), t;
+  int c = 0;
+  SectorFreepage *fp, *ifp;
+
+  num_sector_frees++;
+  
+  /* Determine the size: */
+  t = s;
+  while(1) {
+    long pagetableindex = SECTOR_LOOKUP_PAGETABLE(t);
+    long pageindex = SECTOR_LOOKUP_PAGEPOS(t);
+    if (sector_pagetables[pagetableindex]
+	&& (sector_pagetables[pagetableindex][pageindex].start == s)) {
+      sector_pagetables[pagetableindex][pageindex].kind = sector_kind_free;
+      sector_pagetables[pagetableindex][pageindex].start = 0;
+      c++;
+      t += SECTOR_SEGMENT_SIZE;
+    } else
+      break;
+  }
+
+#if CHECK_FREES
+  if (!c) {
+    free_error("bad sector free!\n");
+    return;
+  }
+#endif
+
+  sector_free_mem_use += (c << LOG_SECTOR_SEGMENT_SIZE);
+
+  /* Try merge with a predecessor: */
+  ifp = sector_freepage_start;
+  while (ifp) {
+    if (ifp->end == s) {
+      /* Remove predecessor freepage */
+      if (ifp->prev)
+	ifp->prev->next = ifp->next;
+      else
+	sector_freepage_start = ifp->next;
+      if (ifp->next)
+	ifp->next->prev = ifp->prev;
+      else
+	sector_freepage_end = ifp->prev;
+
+      c += ifp->size;
+      s = ifp->start;
+
+      break;
+    }
+    ifp = ifp->next;
+  }
+
+  /* Try merge with a successor: */
+  ifp = sector_freepage_start;
+  while (ifp) {
+    if (ifp->start == t) {
+      /* Remove successor freepage */
+      if (ifp->prev)
+	ifp->prev->next = ifp->next;
+      else
+	sector_freepage_start = ifp->next;
+      if (ifp->next)
+	ifp->next->prev = ifp->prev;
+      else
+	sector_freepage_end = ifp->prev;
+
+      c += ifp->size;
+      t = ifp->end;
+
+      break;
+    }
+    ifp = ifp->next;
+  }
+  
+  /* Insert after smaller: */
+  ifp = sector_freepage_start;
+  while (ifp && (ifp->size < c))
+    ifp = ifp->next;
+
+  fp = (SectorFreepage *)p;
+  fp->start = s;
+  fp->end = t;
+  fp->size = c;
+  if (ifp) {
+    fp->prev = ifp->prev;
+    if (!ifp->prev)
+      sector_freepage_start = fp;
+    else
+      ifp->prev->next = fp;
+    ifp->prev = fp;
+    fp->next = ifp;
+  } else {
+    fp->prev = sector_freepage_end;
+    if (sector_freepage_end)
+      sector_freepage_end->next = fp;
+    fp->next = NULL;
+    sector_freepage_end = fp;
+    if (!sector_freepage_start)
+      sector_freepage_start = fp;
+  }
+}
+
+#ifdef WIN32
+static int is_sector_segment(void *p)
+{
+  unsigned long s = PTR_TO_INT(p);
+  long pagetableindex = SECTOR_LOOKUP_PAGETABLE(s);
+  long pageindex = SECTOR_LOOKUP_PAGEPOS(s);
+
+  return (sector_pagetables[pagetableindex]
+          && sector_pagetables[pagetableindex][pageindex].start);
+}
+#endif
+
+#if GET_MEM_VIA_SBRK
+static int c_refcount;
+static char *save_brk;
+#endif
+
+static void prepare_collect_temp()
+{
+#if GET_MEM_VIA_SBRK
+  save_brk = (char *)sbrk(0);
+#else
+  collect_mem_use = 0;
+#endif
+}
+
+static void *realloc_collect_temp(void *v, long oldsize, long newsize)
+{
+#if GET_MEM_VIA_SBRK
+  void *naya;
+
+  naya = (void *)sbrk(newsize);
+  memcpy(naya, v, oldsize);
+  if (!v)
+    c_refcount++;
+  return naya;
+#else
+# if GET_MEM_VIA_VIRTUAL_ALLOC
+  void *naya;
+
+  naya = VirtualAlloc(NULL, newsize, 
+		      MEM_COMMIT | MEM_RESERVE,
+		      PAGE_READWRITE);
+  memcpy(naya, v, oldsize);
+  if (v)
+    VirtualFree(v, 0, MEM_RELEASE);
+
+  return naya;
+# else
+  void *naya;
+
+  naya = MALLOC(newsize);
+  memcpy(naya, v, oldsize);
+  FREE(v);
+  collect_mem_use += newsize;
+  return naya;
+# endif
+#endif
+}
+
+static void free_collect_temp(void *v)
+{
+#if GET_MEM_VIA_SBRK
+  if (!(--c_refcount)) {
+    collect_mem_use = (unsigned long)(sbrk(0)) - (unsigned long)save_brk;
+    brk(save_brk);
+  }
+#else
+# if GET_MEM_VIA_VIRTUAL_ALLOC
+  VirtualFree(v, 0, MEM_RELEASE);
+# else
+  FREE(v);
+# endif
+#endif
+}
+
+typedef struct {
+  struct ManagedBlock *next;
+  struct ManagedBlock *prev;
+  long count;
+  long size; /* Use size to find bucket */
+  unsigned long end;
+} ManagedBlockHeader;
+
+typedef struct ManagedBlock {
+  ManagedBlockHeader head;
+  char free[1];
+} ManagedBlock;
+
+typedef struct {
+  long size;
+  long perblock;
+  long offset;
+  ManagedBlock *block;
+} ManagedBucket;
+
+typedef struct {
+  int num_buckets;
+  ManagedBucket buckets[1];
+} Managed;
+
+static Managed *managed;
+
+static void *malloc_managed(long size)
+{
+  /* A naive strategy is sufficient here.
+     There will be many disappearing links, many
+     finalizations, and very little of anything else. */
+  int i, j;
+  long perblock, offset;
+  ManagedBlock *mb;
+  
+  if (size & PTR_SIZE)
+    size += PTR_SIZE - (size & PTR_SIZE);
+
+  if (!managed) {
+    managed = (Managed *)malloc_sector(SECTOR_SEGMENT_SIZE, sector_kind_other);
+    managed->num_buckets = 0;
+    manage_real_mem_use += SECTOR_SEGMENT_SIZE;
+  }
+
+  for (i = 0; i < managed->num_buckets; i++) {
+    if (managed->buckets[i].size == size)
+      break;
+  }
+
+  if (i >= managed->num_buckets) {
+    managed->num_buckets++;
+    managed->buckets[i].size = size;
+    if (size < MAX_COMMON_SIZE) {
+      int c;
+
+      mb = (ManagedBlock *)malloc_sector(SECTOR_SEGMENT_SIZE, sector_kind_managed);
+      manage_real_mem_use += SECTOR_SEGMENT_SIZE;
+      managed->buckets[i].block = mb;
+
+      c = (SECTOR_SEGMENT_SIZE - sizeof(ManagedBlockHeader)) / size;
+      if (c & (PTR_SIZE - 1))
+	c += (PTR_SIZE - (c & (PTR_SIZE - 1)));
+      managed->buckets[i].perblock = (SECTOR_SEGMENT_SIZE - sizeof(ManagedBlockHeader) - c) / size;
+      managed->buckets[i].offset = c + sizeof(ManagedBlockHeader);
+    } else {
+      long l = size + sizeof(ManagedBlockHeader) + PTR_SIZE;
+      mb = (ManagedBlock *)malloc_sector(l, sector_kind_managed);
+      manage_real_mem_use += l;
+      managed->buckets[i].block = mb;
+      managed->buckets[i].perblock = 1;
+      managed->buckets[i].offset = sizeof(ManagedBlockHeader) + PTR_SIZE;
+    }
+    mb->head.count = 0;
+    mb->head.size = size;
+    mb->head.next = NULL;
+    mb->head.prev = NULL;
+    perblock = managed->buckets[i].perblock;
+    for (j = perblock; j--; )
+      mb->free[j] = 1;
+    mb->head.end = PTR_TO_INT(mb) + managed->buckets[i].offset + size * perblock;
+  }
+
+  perblock = managed->buckets[i].perblock;
+  offset = managed->buckets[i].offset;
+  mb = managed->buckets[i].block;
+  while ((mb->head.count == perblock) && mb->head.next)
+    mb = mb->head.next;
+  if (mb->head.count == perblock) {
+    long l = offset + size * perblock;
+    mb->head.next = (ManagedBlock *)malloc_sector(l, sector_kind_managed);
+    manage_real_mem_use += l;
+    mb->head.next->head.prev = mb;
+    mb = mb->head.next;
+    mb->head.count = 0;
+    mb->head.size = size;
+    mb->head.next = NULL;
+    for (j = perblock; j--; )
+      mb->free[j] = 1;
+    mb->head.end = PTR_TO_INT(mb) + offset + size * perblock;
+  }
+
+  manage_mem_use += size;
+
+  mb->head.count++;
+  for (j = perblock; j--; )
+    if (mb->free[j]) {
+      mb->free[j] = 0;
+      return (((char *)mb) + offset) + size * j;
+    }
+
+  FPRINTF(STDERR, "error allocating managed\n");
+  return NULL;
+}
+
+void free_managed(void *s)
+{
+  int i;
+  unsigned long p;
+  ManagedBucket *bucket;
+  ManagedBlock *mb;
+
+  p = PTR_TO_INT(s);
+
+  /* Assume that s really is an allocated managed pointer: */
+  mb = (ManagedBlock *)INT_TO_PTR((p & SECTOR_SEGMENT_MASK));
+  
+  for (i = 0; i < managed->num_buckets; i++) {
+    bucket = managed->buckets + i;
+    if (bucket->size == mb->head.size) {
+      /* Found bucket */
+      int which;
+      which = (p - PTR_TO_INT(mb) - bucket->offset) / bucket->size;
+      if ((which >= 0) && (which < bucket->perblock)) {
+	if (mb->free[which]) {
+	  FPRINTF(STDERR, "error freeing managed\n");
+	  return;
+	}
+	mb->free[which] = 1;
+	--mb->head.count;
+	manage_mem_use -= bucket->size;
+	if (!mb->head.count) {
+	  if (mb->head.prev) {
+	    if (mb->head.next)
+	      mb->head.next->head.prev = mb->head.prev;
+	    mb->head.prev->head.next = mb->head.next;
+	  } else {
+	    if (mb->head.next) {
+	      bucket->block = mb->head.next;
+	      bucket->block->head.prev = NULL;
+	    } else {
+	      /* Empty bucket */
+	      int j;
+	      --managed->num_buckets;
+	      for (j = i; j < managed->num_buckets; j++)
+		memcpy(&(managed->buckets[j]), &(managed->buckets[j + 1]), sizeof(ManagedBucket));
+	    }
+	  }
+
+	  manage_real_mem_use -= (bucket->offset + bucket->size * bucket->perblock);
+
+	  free_sector(mb);
+	}
+	return;
+      }
+    }
+  }
+  
+  FPRINTF(STDERR, "error freeing managed\n");
+}
+
+/*************************************************************/
+
+static void init_size_map()
+{
+  int i, j, find_half;
+  long k, next;
+
+  size_index_map = (long *)malloc_sector(MAX_COMMON_SIZE, sector_kind_other);
+  size_map = malloc_sector(NUM_COMMON_SIZE * sizeof(long), sector_kind_other);
+
+  i = 0;
+  while (i < 8) {
+    size_index_map[i] = i;
+    size_map[i] = (i + 1) * PTR_SIZE;
+    i++;
+  }
+
+  k = 8;
+  next = 12;
+  j = i;
+  find_half = 1;
+  while (j < (MAX_COMMON_SIZE >> 2)) {
+    size_index_map[j] = i;
+    if ((j + 1) == next) {
+      size_map[i] = next * PTR_SIZE;
+      i++;
+      if (find_half) {
+	next = 2 * k;
+      } else {
+	next = 3 * k;
+	k = 2 * k;
+      }
+      find_half = !find_half;
+    }
+    j++;
+  }
+  if (i < NUM_COMMON_SIZE)
+    size_map[i] = next * PTR_SIZE;
+
+#if 0
+  FPRINTF(STDERR, "max: %d  num: %d\n", MAX_COMMON_SIZE, NUM_COMMON_SIZE);
+  for (i = 0; i < (MAX_COMMON_SIZE >> 2); i++) {
+    FPRINTF(STDERR, "%d->%d=%d;", i, 
+	    size_index_map[i], 
+	    size_map[size_index_map[i]]);
+  }
+  FPRINTF(STDERR, "\n");
+#endif
+}
+
+/*************************************************************/
+
+void GC_add_roots(void *start, void *end)
+{
+  if (roots_count >= roots_size) {
+    unsigned long *naya;
+
+    mem_real_use -= (sizeof(unsigned long) * roots_size);
+
+    roots_size = roots_size ? 2 * roots_size : 500;
+    naya = (unsigned long *)malloc_managed(sizeof(unsigned long) * (roots_size + 1));
+
+    mem_real_use += (sizeof(unsigned long) * roots_size);
+
+    memcpy((void *)naya, (void *)roots, 
+	   sizeof(unsigned long) * roots_count);
+
+    if (roots)
+      free_managed(roots);
+
+    roots = naya;
+  }
+
+  roots[roots_count++] = PTR_TO_INT(start);
+  roots[roots_count++] = PTR_TO_INT(end) - PTR_ALIGNMENT;
+}
+
+#if AUTO_STATIC_ROOTS_IF_POSSIBLE
+
+#if defined(_IBMR2)
+  extern int end;
+# define DATASTART ((void *)0x20000000)
+# define DATAEND ((void *)(&end))
+# define USE_DATASTARTEND 1
+#endif
+
+#if defined(__FreeBSD__) && defined(i386)
+  extern char etext;
+  extern int end;
+# define DATASTART ((void *)(&etext))
+# define DATAEND ((void *)(&end))
+# define USE_DATASTARTEND 1
+#endif
+
+#if defined(sun)
+# include <errno.h>
+# ifdef ECHRNG
+/* Solaris */
+  extern char _etext;
+  extern int _end;
+#  define DATASTART sysv_GetDataStart(0x10000, (int)&_etext)
+#  define DATAEND (void *)(&_end)
+#  define NEED_SYSV_GET_START
+# else
+#  define TEXTSTART 0x2000
+#  define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
+# endif
+# define USE_DATASTARTEND 1
+#endif
+
+#ifndef USE_DATASTARTEND
+# define USE_DATASTARTEND 0
+#endif
+
+#ifdef WIN32
+/* Mostly borrowed from conservative GC, Boehm et al. */
+static void cond_add_roots(char *base, char * limit, long allocation_granularity)
+{
+  char dummy;
+  char * stack_top;
+  
+  if (base == limit) return;
+  
+  stack_top = (char *) ((long)(&dummy) & ~(allocation_granularity-1));
+  
+  if (limit > stack_top && base < (char *)GC_stackbottom) {
+    /* Part of the stack; ignore it. */
+    return;
+  }
+  GC_add_roots(base, limit);
+}
+  
+void register_static_variables()
+{
+  MEMORY_BASIC_INFORMATION buf;
+  SYSTEM_INFO sysinfo;
+  DWORD result;
+  DWORD protect;
+  LPVOID p;
+  char * base;
+  char * limit, * new_limit;
+  long allocation_granularity;
+  
+  GetSystemInfo(&sysinfo);
+  base = limit = p = sysinfo.lpMinimumApplicationAddress;
+  allocation_granularity = sysinfo.dwAllocationGranularity;
+  while (p < sysinfo.lpMaximumApplicationAddress) {
+    result = VirtualQuery(p, &buf, sizeof(buf));
+    new_limit = (char *)p + buf.RegionSize;
+    protect = buf.Protect;
+    if (buf.State == MEM_COMMIT
+	&& (protect == PAGE_EXECUTE_READWRITE
+	    || protect == PAGE_READWRITE
+	    || protect == PAGE_WRITECOPY
+	    || protect == PAGE_EXECUTE_WRITECOPY)
+	&& !is_sector_segment(buf.AllocationBase)) {
+      if ((char *)p == limit) {
+	limit = new_limit;
+      } else {
+	cond_add_roots(base, limit, allocation_granularity);
+	base = p;
+	limit = new_limit;
+      }
+    }
+    if (p > (LPVOID)new_limit /* overflow */) break;
+    p = (LPVOID)new_limit;
+  }
+  cond_add_roots(base, limit, allocation_granularity);
+}
+
+long total_memory_use()
+{
+  /* Try to count total used bytes in the heap. */
+  MEMORY_BASIC_INFORMATION buf;
+  SYSTEM_INFO sysinfo;
+  LPVOID p;
+  char * new_limit;
+  long allocation_granularity;
+  long total = 0;
+    
+  GetSystemInfo(&sysinfo);
+  p = sysinfo.lpMinimumApplicationAddress;
+  allocation_granularity = sysinfo.dwAllocationGranularity;
+  while (p < sysinfo.lpMaximumApplicationAddress) {
+    VirtualQuery(p, &buf, sizeof(buf));
+    new_limit = (char *)p + buf.RegionSize;
+    if (buf.State != MEM_FREE)
+      total += buf.RegionSize;
+    if (p > (LPVOID)new_limit /* overflow */) break;
+    p = (LPVOID)new_limit;
+  }
+  
+  return total;
+}
+#endif /* Win32 */
+
+#ifdef NEED_SYSV_GET_START
+/* Also borrowed conservative GC, Boehm et al. */
+#include <signal.h>
+# define MIN_PAGE_SIZE 256	/* Smallest conceivable page size, bytes */
+static jmp_buf sysv_jb;
+    
+void sysv_fault_handler(int sig)
+{
+  longjmp(sysv_jb, 1);
+}
+
+typedef void (*handler)(int);
+# ifdef sun
+static struct sigaction oldact;
+# else
+static handler old_segv_handler, old_bus_handler;
+# endif
+
+static void sysv_setup_temporary_fault_handler()
+{
+# ifdef sun
+  struct sigaction act;
+
+  act.sa_handler = sysv_fault_handler;
+  act.sa_flags = SA_RESTART | SA_SIGINFO | SA_NODEFER;
+  /* The presence of SA_NODEFER represents yet another gross    */
+  /* hack.  Under Solaris 2.3, siglongjmp doesn't appear to     */
+  /* interact correctly with -lthread.  We hide the confusion   */
+  /* by making sure that signal handling doesn't affect the     */
+  /* signal mask.                                               */
+
+  (void) sigemptyset(&act.sa_mask);
+  (void) sigaction(SIGSEGV, &act, &oldact);
+# else
+  old_segv_handler = signal(SIGSEGV, sysv_fault_handler);
+# ifdef SIGBUS
+ old_bus_handler = signal(SIGBUS, sysv_fault_handler);
+# endif
+# endif
+}
+    
+void sysv_reset_fault_handler()
+{
+# ifdef sun
+  (void) sigaction(SIGSEGV, &oldact, 0);
+# else
+  (void) signal(SIGSEGV, old_segv_handler);
+# ifdef SIGBUS
+  (void) signal(SIGBUS, old_bus_handler);
+# endif
+# endif
+}
+
+/* Return the first nonaddressible location > p (up) or 	*/
+/* the smallest location q s.t. [q,p] is addressible (!up).	*/
+void *sysv_find_limit(void *p, int up)
+{
+  static void *result;
+  static char dummy;
+  /* Needs to be static, since otherwise it may not be	*/
+  /* preserved across the longjmp.  Can safely be 	*/
+  /* static since it's only called once, with the       */
+  /* allocation lock held.				*/
+  
+  sysv_setup_temporary_fault_handler();
+  if (setjmp(sysv_jb) == 0) {
+    result = (void *)(((unsigned long)(p)) & ~(MIN_PAGE_SIZE-1));
+    while(1) {
+      if (up)
+	result += MIN_PAGE_SIZE;
+      else
+	result -= MIN_PAGE_SIZE;
+
+      dummy = *(char *)result;
+    }
+  }
+  sysv_reset_fault_handler();
+  if (!up)
+    result += MIN_PAGE_SIZE;
+  return result;
+}
+
+void *sysv_GetDataStart(int max_page_size, int etext_addr)
+{
+  unsigned long text_end = (((unsigned long)(etext_addr) + sizeof(unsigned long) - 1)
+			    & ~(sizeof(unsigned long) - 1));
+  /* etext rounded to word boundary	*/
+  unsigned long next_page = ((text_end + (unsigned long)max_page_size - 1)
+			     & ~((unsigned long)max_page_size - 1));
+  unsigned long page_offset = (text_end & ((unsigned long)max_page_size - 1));
+  char * result = (char *)(next_page + page_offset);
+  /* Note that this isnt equivalent to just adding		*/
+  /* max_page_size to &etext if &etext is at a page boundary	*/
+  
+  sysv_setup_temporary_fault_handler();
+  if (setjmp(sysv_jb) == 0) {
+    /* Try writing to the address.	*/
+    *result = *result;
+  } else {
+    /* We got here via a longjmp.  The address is not readable.	*/
+    /* This is known to happen under Solaris 2.4 + gcc, which place	*/
+    /* string constants in the text segment, but after etext.	*/
+    /* Use plan B.  Note that we now know there is a gap between	*/
+    /* text and data segments, so plan A bought us something.	*/
+    result = (char *)sysv_find_limit((void *)(DATAEND) - MIN_PAGE_SIZE, 0);
+  }
+  sysv_reset_fault_handler();
+  return (void *)result;
+}
+#endif /* SysV */
+
+#endif  /* AUTO_STATIC_ROOTS_IF_POSSIBLE */
+
+static int statics_setup = 0;
+
+static void init_static_variables(void)
+{
+#if AUTO_STATIC_ROOTS_IF_POSSIBLE
+# if USE_DATASTARTEND
+  GC_add_roots(DATASTART, DATAEND);
+# endif
+# ifdef WIN32
+  register_static_variables();
+# endif
+#endif
+
+  statics_setup = 1;
+}
+
+static int initialized = 0;
+
+void GC_initialize(void)
+{
+  int i;
+
+#if PROVIDE_MALLOC_AND_FREE
+  num_common_sets = 5;
+#else
+  num_common_sets = 4;
+#endif
+  common_sets = (GC_Set **)malloc_managed(sizeof(GC_Set*) * num_common_sets);
+
+  common_sets[0] = (GC_Set *)malloc_managed(sizeof(GC_Set));
+  common_sets[0]->atomic = 0;
+  common_sets[0]->uncollectable = 0;
+  common_sets[0]->blocks = common;
+  common_sets[0]->block_ends = common_ends;
+  common_sets[0]->othersptr = &others;
+
+  common_sets[1] = (GC_Set *)malloc_managed(sizeof(GC_Set));
+  common_sets[1]->atomic = 1;
+  common_sets[1]->uncollectable = 0;
+  common_sets[1]->blocks = atomic_common;
+  common_sets[1]->block_ends = atomic_common_ends;
+  common_sets[1]->othersptr = &atomic_others;
+
+  common_sets[2] = (GC_Set *)malloc_managed(sizeof(GC_Set));
+  common_sets[2]->atomic = 0;
+  common_sets[2]->uncollectable = 1;
+  common_sets[2]->blocks = uncollectable_common;
+  common_sets[2]->block_ends = uncollectable_common_ends;
+  common_sets[2]->othersptr = &uncollectable_others;
+
+  common_sets[3] = (GC_Set *)malloc_managed(sizeof(GC_Set));
+  common_sets[3]->atomic = 1;
+  common_sets[3]->uncollectable = 1;
+  common_sets[3]->blocks = uncollectable_atomic_common;
+  common_sets[3]->block_ends = uncollectable_atomic_common_ends;
+  common_sets[3]->othersptr = &uncollectable_atomic_others;
+
+#if PROVIDE_MALLOC_AND_FREE
+  common_sets[4] = (GC_Set *)malloc_managed(sizeof(GC_Set));
+  common_sets[4]->atomic = 1;
+  common_sets[4]->uncollectable = 1;
+  common_sets[4]->blocks = sys_malloc;
+  common_sets[4]->block_ends = sys_malloc_ends;
+  common_sets[4]->othersptr = &sys_malloc_others;
+#endif
+
+  for (i = 0; i < num_common_sets; i++) {
+    common_sets[i]->name = "Basic";
+#if ALLOW_SET_LOCKING
+    common_sets[i]->locked = 0;
+#endif
+#if KEEP_SET_NO
+    common_sets[i]->no = i;
+#endif
+#if ALLOW_TRACE_COUNT
+    common_sets[i]->count_tracer = NULL;
+#endif
+#if ALLOW_TRACE_PATH
+    common_sets[i]->path_tracer = NULL;
+#endif
+#if ALLOW_TRACE_COUNT || ALLOW_TRACE_PATH
+    common_sets[i]->trace_init = NULL;
+    common_sets[i]->trace_done = NULL;
+#endif
+#if ALLOW_SET_FINALIZER
+    common_sets[i]->finalizer = NULL;
+#endif    
+  }
+
+#if PROVIDE_MALLOC_AND_FREE
+  common_sets[4]->name = "Sysmalloc";
+#endif
+
+  initialized = 1;
+}
+
+void GC_set_stack_base(void *base)
+{
+  GC_stackbottom = base;
+}
+
+void *GC_get_stack_base(void)
+{
+  return GC_stackbottom;
+}
+
+void *find_ptr(void *d, int *_size,
+	       MemoryBlock **_block, int *_pos,
+	       MemoryChunk **_chunk,
+	       int find_anyway)
+{
+  unsigned long p = PTR_TO_INT(d);
+
+  if (!sector_pagetables)
+    return NULL;
+
+  if (p >= low_plausible && p < high_plausible) {
+    SectorPage *pagetable = sector_pagetables[SECTOR_LOOKUP_PAGETABLE(p)];
+    if (pagetable) {
+      SectorPage *page = pagetable + SECTOR_LOOKUP_PAGEPOS(p);
+      long kind = page->kind;
+
+      if (kind == sector_kind_block) {
+	/* Found common block: */
+	MemoryBlock *block = (MemoryBlock *)INT_TO_PTR(page->start);
+	if (p >= block->start && p < block->top) {
+	  int size = block->size;
+	  int diff = p - block->start;
+	  int pos = (diff / size), apos;
+	  int bit;
+	  unsigned long result;
+	  
+	  apos = POS_TO_UNMARK_INDEX(pos);
+	  bit = POS_TO_UNMARK_BIT(pos);
+	  
+	  if (_size)
+	    *_size = size;
+	  
+	  if (NOT_MARKED(block->free[apos] & bit) && !find_anyway)
+	    return NULL;
+	  
+	  result = block->start + (pos * size);
+	  
+	  if (_block)
+	    *_block = block;
+	  if (_pos)
+	    *_pos = pos;
+	  
+	  return INT_TO_PTR(result);
+	}
+      } else if (kind == sector_kind_chunk) {
+	MemoryChunk *c = (MemoryChunk *)INT_TO_PTR(page->start);
+	if ((p >= c->start) && (p < c->end)) {
+	  if (_size)
+	    *_size = (c->end - c->start);
+	  if (c->marked || find_anyway) {
+	    if (_chunk)
+	      *_chunk = c;
+	    return INT_TO_PTR(c->start);
+	  } else
+	    return NULL;
+	}
+      }
+    }
+  }
+
+  return NULL;
+}
+
+void *GC_base(void *d)
+{
+  void *p;
+
+  p = find_ptr(d, NULL, NULL, NULL, NULL, 0);
+
+#if PAD_BOUNDARY_BYTES
+  if (p)
+    p = PAD_FORWARD(p);
+#endif
+  
+  return p;
+}
+
+int GC_size(void *d)
+{
+  int size;
+  
+  if (find_ptr(d, &size, NULL, NULL, NULL, 0)) {
+#if PAD_BOUNDARY_BYTES
+    size -= PAD_START_SIZE + PAD_END_SIZE;
+#endif
+    return size;
+  } else
+    return 0;
+}
+
+int GC_is_atomic(void *d)
+{
+  MemoryBlock *block = NULL;
+  MemoryChunk *chunk = NULL;
+  
+  if (find_ptr(d, NULL, &block, NULL, &chunk, 0)) {
+    if (block)
+      return block->atomic;
+    else
+      return chunk->atomic;
+  } else
+    return 0;
+}
+
+int GC_orig_size(void *d)
+{
+  int size = 0;
+  
+  find_ptr(d, &size, NULL, NULL, NULL, 0);
+  return size;
+}
+
+void *GC_orig_base(void *d)
+{
+  return find_ptr(d, NULL, NULL, NULL, NULL, 1);
+}
+
+struct GC_Set *GC_set(void *d)
+{
+#if KEEP_SET_NO
+  MemoryBlock *block = NULL;
+  MemoryChunk *chunk = NULL;
+  
+  if (!initialized)
+    GC_initialize();
+
+  if (find_ptr(d, NULL, &block, NULL, &chunk, 0)) {
+    int set_no;
+    if (block)
+      set_no = block->set_no;
+    else
+      set_no = chunk->set_no;
+
+    return common_sets[set_no];
+  } else
+    return NULL;
+#else
+  return NULL;
+#endif
+}
+
+#if DUMP_BLOCK_MAPS
+static unsigned long trace_stack_start, trace_stack_end, trace_reg_start, trace_reg_end;
+#endif
+
+void GC_dump(void)
+{
+  FPRINTF(STDERR, "Begin Map\n");
+
+  FPRINTF(STDERR,
+	  "allocated: %ld  collectable: %ld  uncollectable: %ld\n"
+	  "including known overhead: %ld  scheduled gc: %ld  last collect depth: %ld\n"
+	  "managed: %ld  managed including overhead: %ld\n"
+	  "sector used: %ld  sector free: %ld  sector total: %ld\n"
+	  "sector range: %ld  sector administration: %ld\n"
+	  "num sector allocs: %ld  num sector frees: %ld\n"
+#if STAMP_AND_REMEMBER_SOURCE
+	  "current clock: %ld\n"
+#endif
+	  , mem_use + mem_uncollectable_use, mem_use, mem_uncollectable_use, 
+	  mem_real_use, mem_limit, collect_mem_use,
+	  manage_mem_use, manage_real_mem_use,
+	  sector_mem_use - sector_free_mem_use, sector_free_mem_use, sector_mem_use,
+	  sector_high_plausible - sector_low_plausible,
+	  sector_admin_mem_use,
+	  num_sector_allocs, num_sector_frees
+#if STAMP_AND_REMEMBER_SOURCE
+	  , stamp_clock
+#endif
+	  );
+#if DUMP_BLOCK_COUNTS
+  {
+    int i, j;
+    unsigned long total;
+    
+#if DUMP_BLOCK_MAPS
+    FPRINTF(STDERR, "roots: ======================================\n");
+    for (i = 0; i < roots_count; i += 2)
+      FPRINTF(STDERR, ">%lx-%lx", roots[i], roots[i + 1]);
+    FPRINTF(STDERR, "\n");
+
+    FPRINTF(STDERR, "stack: ======================================\n");
+    FPRINTF(STDERR, ">%lx-%lx>%lx-%lx\n",
+	    trace_stack_start, trace_stack_end, trace_reg_start, trace_reg_end);
+#endif
+
+    for (j = 0; j < num_common_sets; j++) {
+      GC_Set *cs = common_sets[j];
+
+      total = 0;
+
+      FPRINTF(STDERR,
+	      "Set: %s [%s/%s]: ======================================\n", 
+	      cs->name,
+	      cs->atomic ? "atomic" : "pointerful",
+	      cs->uncollectable ? "eternal" : "collectable");
+
+      for (i = 0; i < NUM_COMMON_SIZE; i++) {
+	MemoryBlock *block;
+	int counter = 0;
+
+	block = (cs)->blocks[i];
+
+	if (block) {
+	  FPRINTF(STDERR, "%d:", block->size);
+
+#if DUMP_BLOCK_MAPS
+	  FPRINTF(STDERR, "[%lx]", block->start - (unsigned long)block);
+#endif
+
+	  while (block) {
+	    int k, size = block->size;
+
+#if DUMP_BLOCK_MAPS
+	    counter = 0;
+#endif
+
+	    for (k = (block->top - block->start) / block->size; k-- ; ) {
+	      int bit = POS_TO_UNMARK_BIT(k);
+	      int pos = POS_TO_UNMARK_INDEX(k);
+	      
+	      if (IS_MARKED(block->free[pos] & bit)) {
+		total += size;
+		counter++;
+	      }
+	    }
+
+#if DUMP_BLOCK_MAPS
+	    FPRINTF(STDERR,
+		    ">%lxx%d"
+#if STAMP_AND_REMEMBER_SOURCE
+		    "@%ld-%ld:%lx-%lx" 
+#endif
+		    , (unsigned long)block, counter
+#if STAMP_AND_REMEMBER_SOURCE
+		    , block->make_time, 
+		    block->use_time,
+		    block->low_marker,
+		    block->high_marker
+#endif
+		    );
+#endif
+	    block = block->next;
+	  }
+#if DUMP_BLOCK_MAPS
+	  FPRINTF(STDERR, "\n");
+#else
+	  FPRINTF(STDERR, "%d;", counter);
+#endif
+	}
+      }
+
+      /* Print chunks, "sorting" so that same size are printed together: */
+      {
+	MemoryChunk *c, *cnext, *first = NULL, *last = NULL, *t, *next, *prev;
+	int counter = 0;
+	
+	for (c = *(cs->othersptr); c; c = cnext) {
+	  unsigned long size = c->end - c->start;
+	  FPRINTF(STDERR, "%ld:", size);
+
+#if DUMP_BLOCK_MAPS
+	  FPRINTF(STDERR, "[%lx]", c->start - (unsigned long)c);
+#endif
+	  
+	  cnext = c->next;
+	  
+	  prev = NULL;
+	  for (t = c; t; t = next) {
+	    next = t->next;
+	    
+	    if (size == (t->end - t->start)) {
+#if DUMP_BLOCK_MAPS
+	      FPRINTF(STDERR,
+		      ">%lx"
+#if STAMP_AND_REMEMBER_SOURCE
+		      "@%ld:%lx" 
+#endif
+		      , (unsigned long)t
+#if STAMP_AND_REMEMBER_SOURCE
+		      , t->make_time,
+		      t->marker
+#endif
+		      );
+#endif
+	      
+	      counter++;
+
+	      if (last)
+		last->next = t;
+	      else
+		first = t;
+	      last = t;
+	      if (prev)
+		prev->next = t->next;
+	      if (t == cnext)
+		cnext = t->next;
+
+	      total += size;
+	    } else
+	      prev = t;
+	  }
+#if DUMP_BLOCK_MAPS
+	  FPRINTF(STDERR, "\n");
+#else
+	  FPRINTF(STDERR, "%d;", counter);
+	  counter = 0;
+#endif
+	}
+	
+	if (last)
+	  last->next = NULL;
+	*(cs->othersptr) = first;
+      }
+      cs->total = total;
+
+#if KEEP_PREV_PTR
+      /* reset prev pointers: */
+      {
+	MemoryChunk *c, **prev_ptr = (cs->othersptr);
+	for (c = *(cs->othersptr); c; c = c->next) {
+	  c->prev_ptr = prev_ptr;
+	  prev_ptr = &c->next;
+	}
+      }
+#endif
+      
+      FPRINTF(STDERR, "total size: %ld\n", total);
+    }
+
+    FPRINTF(STDERR, "summary: ======================================\n");
+    total = 0;
+    for (j = 0; j < num_common_sets; j++) {
+      GC_Set *cs = common_sets[j];
+      FPRINTF(STDERR,
+	      "%12s: %10ld  [%s/%s]\n",
+	      cs->name, cs->total,
+	      cs->atomic ? "atomic" : "pointerful",
+	      cs->uncollectable ? "eternal" : "collectable");
+      total += cs->total;
+    }
+    FPRINTF(STDERR, "%12s: %10ld\n", "total", total);
+  }
+#endif
+  FPRINTF(STDERR, "End Map\n");
+}
+
+void GC_end_stubborn_change(void *p)
+{
+  /* stubborness is not exploited */
+}
+
+static void *zero_ptr;
+
+#if CHECK_WATCH_FOR_PTR_ALLOC
+void *GC_watch_for_ptr = NULL;
+#define UNHIDE_WATCH(p) ((void *)~((unsigned long)p))
+static int findings;
+
+#if USE_WATCH_FOUND_FUNC
+void GC_found_watch()
+{
+  FPRINTF(STDERR, "found\n");
+  findings++;
+}
+#endif
+#endif
+
+#if PAD_BOUNDARY_BYTES
+static void set_pad(void *p, long s, long os)
+{
+  long diff;
+
+  /* Set start & end pad: */
+  *(long*)p = PAD_PATTERN;
+  *(long*)(((char *)p) + s - PAD_END_SIZE) = PAD_PATTERN;
+  
+  /* Keep giev - requested diff: */
+  diff = (s - os - PAD_START_SIZE - PAD_END_SIZE);
+  ((long *)p)[1] = diff;
+  
+  if (diff) {
+    unsigned char *ps = ((unsigned char *)p) + os + PAD_START_SIZE;
+    while (diff--)
+      *(ps++) = PAD_FILL_PATTERN;
+  }
+}
+#endif
+
+#if KEEP_SET_NO
+#define SET_NO_BACKINFO int set_no,
+#define KEEP_SET_INFO_ARG(x) x, 
+#else
+#define SET_NO_BACKINFO /* empty */
+#define KEEP_SET_INFO_ARG(x) /* empty */
+#endif
+
+void *do_malloc(SET_NO_BACKINFO
+		unsigned long size, 
+		MemoryBlock **common, MemoryBlock **common_ends,
+		MemoryChunk **othersptr,
+		int atomic, int uncollectable)
+{
+  MemoryBlock **find, *block;
+  void *s;
+  long c;
+  unsigned long p;
+  long sizeElemBit;
+  int i, cpos, elem_per_block;
+#if PAD_BOUNDARY_BYTES
+  long origsize;
+#endif
+
+#if CHECK_COLLECTING
+  if (collecting_now) {
+    exit(-1);
+  }
+#endif
+
+  if (!size)
+    return (void *)&zero_ptr;
+
+  if (!size_map)
+    init_size_map();
+
+#if PAD_BOUNDARY_BYTES
+  origsize = size;
+  size += PAD_START_SIZE + PAD_END_SIZE;
+#endif
+
+  /* Round up to ptr-aligned size: */
+  if (size & (PTR_SIZE-1))
+    size += PTR_SIZE - (size & (PTR_SIZE-1));
+
+  if (size < MAX_COMMON_SIZE) {
+    cpos = size_index_map[(size >> LOG_PTR_SIZE) - 1];
+#if 0
+    if (size > size_map[cpos]) {
+      FPRINTF(STDERR, "map error: %d < %d\n", size_map[cpos], size);
+    }
+#endif
+    size = size_map[cpos];
+
+    block = common_ends[cpos];
+    find = NULL;
+
+    while (block) {
+      if (block->top < block->end)
+	goto block_top;
+
+      for (i = block->elem_per_block; i-- ; )
+	if (block->free[i]) {
+	  char *zp;
+	  int v = block->free[i], n;
+	  
+	  c = i * FREE_BIT_PER_ELEM;
+	  n = (FREE_BIT_START | UNMARK_BIT_START);
+	  while (IS_MARKED(v & n)) {
+	    n = n << FREE_BIT_SIZE;
+	    c++;
+	  }
+	  block->free[i] -= n;
+	  
+	  if (uncollectable)
+	    mem_uncollectable_use += size;
+	  else
+	    mem_use += size;
+	  
+	  p = block->start + c * size;
+
+	  zp = INT_TO_PTR(p);
+
+	  if (!atomic) {
+	    void **p = (void **)zp;
+	    unsigned long sz = size >> LOG_PTR_SIZE;
+	    for (; sz--; p++)
+	      *p = 0;
+	  }
+
+#if CHECK_WATCH_FOR_PTR_ALLOC
+	  if (zp == UNHIDE_WATCH(GC_watch_for_ptr)) {
+#if USE_WATCH_FOUND_FUNC
+	    GC_found_watch();
+#else
+	    findings++;
+#endif
+	  }
+#endif
+
+#if PAD_BOUNDARY_BYTES
+	  SET_PAD(zp, size, origsize);
+	  zp = PAD_FORWARD(zp);
+#endif
+
+	  return zp;
+	}
+      
+      find = &block->next;
+
+      block = block->next;
+      common_ends[cpos] = block;
+    }
+
+  } else {
+    void *a;
+    MemoryChunk *c;
+
+    cpos = 0;
+
+    if (!collect_off && (mem_use >= mem_limit))
+      GC_gcollect();
+
+    a = malloc_sector(size + sizeof(MemoryChunk), sector_kind_chunk);
+
+    c = (MemoryChunk *)a;
+    
+    c->finalizers = NULL;
+    c->marked = 1;
+
+#if STAMP_AND_REMEMBER_SOURCE
+    c->make_time = stamp_clock;
+#endif
+#if KEEP_SET_NO
+    c->set_no = set_no;
+#endif
+
+    c->next = *othersptr;
+#if CHECK_FREES
+    if (PTR_TO_INT(c->next) & (SECTOR_SEGMENT_SIZE - 1))
+      free_error("bad next\n");
+#endif
+    *othersptr = c;
+#if KEEP_PREV_PTR
+    c->prev_ptr = othersptr;
+    if (c->next)
+      c->next->prev_ptr = &c->next;
+#endif
+    
+    c->start = PTR_TO_INT(&c->data);
+    c->end = c->start + size;
+    c->atomic = atomic;
+
+    if (uncollectable)
+      mem_uncollectable_use += size;
+    else
+      mem_use += size;
+    mem_real_use += (size + sizeof(MemoryChunk));
+    num_chunks++;
+
+    if (!low_plausible || (c->start < low_plausible))
+      low_plausible = c->start;
+    if (!high_plausible || (c->end > high_plausible))
+      high_plausible = c->end;	
+
+    if (!atomic) {
+      void **p = (void **)&c->data;
+      unsigned long sz = size >> LOG_PTR_SIZE;
+      for (; sz--; p++)
+	*p = 0;
+    }
+
+#if CHECK_WATCH_FOR_PTR_ALLOC
+    if ((&c->data) == UNHIDE_WATCH(GC_watch_for_ptr)) {
+#if USE_WATCH_FOUND_FUNC
+      GC_found_watch();
+#else
+      findings++;
+#endif
+    }
+#endif
+
+    s = (void *)&c->data;
+
+#if PAD_BOUNDARY_BYTES
+    SET_PAD(s, size, origsize);
+    s = PAD_FORWARD(s);
+#endif
+
+    return s;
+  }
+
+  if (!collect_off && (mem_use >= mem_limit)) {
+    GC_gcollect();
+    return do_malloc(KEEP_SET_INFO_ARG(set_no)
+		     size, common, common_ends, othersptr, 
+		     atomic, uncollectable);
+  }
+
+  sizeElemBit = size << LOG_FREE_BIT_PER_ELEM;
+
+  /* upper bound: */
+  elem_per_block = (SECTOR_SEGMENT_SIZE - sizeof(MemoryBlock) - (PTR_SIZE - 2)) / sizeElemBit;
+  /* use this one: */
+  elem_per_block = (SECTOR_SEGMENT_SIZE - sizeof(MemoryBlock) - (PTR_SIZE - 2) - elem_per_block) / sizeElemBit;
+  if (elem_per_block) {
+    /* Small enough to fit into one segment */
+    block = (MemoryBlock *)malloc_sector(SECTOR_SEGMENT_SIZE, sector_kind_block);
+  } else {
+    long alloc_size;
+    elem_per_block = 1;
+    /* Add (PTR_SIZE - 1) to ensure engouh room after alignment: */
+    alloc_size = sizeof(MemoryBlock) + (PTR_SIZE - 1) + sizeElemBit;
+    block = (MemoryBlock *)malloc_sector(alloc_size, sector_kind_block);
+  }
+  
+  block->elem_per_block = elem_per_block;
+
+  block->finalizers = NULL;
+
+#if STAMP_AND_REMEMBER_SOURCE
+  block->make_time = stamp_clock;
+#endif
+#if KEEP_SET_NO
+  block->set_no = set_no;
+#endif
+
+  /* offset for data (4-byte aligned): */
+  c = sizeof(MemoryBlock) + (elem_per_block - 1);
+  if (c & 0x3)
+    c += (4 - (c & 0x3));
+  p = PTR_TO_INT(block) + c;
+
+  if (common_ends[cpos] || (find && !common[cpos])) {
+    /* hey! - GC happened and reset stuff. find may not be alive anymore,
+       so find it again. */
+    find = &common_ends[cpos];
+    while (*find)
+      find = &(*find)->next;
+  }
+
+  if (find)
+    *find = block;
+  else if (!common[cpos])
+    common[cpos] = block;
+
+  if (!common_ends[cpos])
+    common_ends[cpos] = block;
+
+  num_blocks++;
+
+  for (i = ELEM_PER_BLOCK(block); i-- ; )
+    block->free[i] = 0;
+
+  block->start = block->top = p;
+  block->end = block->start + (elem_per_block * sizeElemBit);
+  block->size = (short)size;
+  block->next = NULL;
+  block->atomic = atomic;
+
+  if (!low_plausible || (block->start < low_plausible))
+    low_plausible = block->start;
+  if (!high_plausible || (block->end > high_plausible))
+    high_plausible = block->end;	
+
+  mem_real_use += SECTOR_SEGMENT_SIZE;
+
+ block_top:
+
+#if STAMP_AND_REMEMBER_SOURCE
+  block->use_time = stamp_clock;
+#endif
+
+#if CHECK
+  if (block->end < block->start
+      || block->top < block->start
+      || block->top > block->end)
+    FPRINTF(STDERR,
+	    "bad block: %ld %ld %ld %ld\n",
+	    size, block->start, block->top, block->end);
+#endif      
+
+  s = INT_TO_PTR(block->top);
+  block->top = block->top + size;
+
+  if (uncollectable)
+    mem_uncollectable_use += size;
+  else
+    mem_use += size;
+
+  if (!atomic) {
+    void **p = (void **)s;
+    unsigned long sz = size >> LOG_PTR_SIZE;
+    for (; sz--; p++)
+      *p = 0;
+  }
+
+#if CHECK_WATCH_FOR_PTR_ALLOC
+  if (s == UNHIDE_WATCH(GC_watch_for_ptr)) {
+#if USE_WATCH_FOUND_FUNC
+    GC_found_watch();
+#else
+    findings++;
+#endif
+  }
+#endif
+
+#if PAD_BOUNDARY_BYTES
+    SET_PAD(s, size, origsize);
+    s = PAD_FORWARD(s);
+#endif
+
+  return s;
+}
+
+struct GC_Set *GC_new_set(char *name, 
+			  GC_trace_init trace_init,
+			  GC_trace_done trace_done,
+			  GC_count_tracer count_tracer,
+			  GC_path_tracer path_tracer,
+			  GC_set_elem_finalizer final,
+			  int flags)
+{
+  GC_Set *c, **naya;
+  int i;
+
+  if (!initialized)
+    GC_initialize();
+
+  c = (GC_Set *)malloc_managed(sizeof(GC_SetWithOthers));
+
+  naya = (GC_Set **)malloc_managed(sizeof(GC_Set *) * (num_common_sets + 1));
+  for (i = 0; i < num_common_sets; i++)
+    naya[i] = common_sets[i];
+  
+#if KEEP_SET_NO
+  c->no = num_common_sets;
+#endif
+#if ALLOW_TRACE_COUNT
+  c->count_tracer = count_tracer;
+#endif
+#if ALLOW_TRACE_PATH
+  c->path_tracer = path_tracer;
+#endif
+#if ALLOW_TRACE_COUNT || ALLOW_TRACE_PATH
+  c->trace_init = trace_init;
+  c->trace_done = trace_done;
+#endif
+#if ALLOW_SET_FINALIZER
+  c->finalizer = final;
+#endif    
+
+  naya[num_common_sets++] = c;
+  c->atomic = !!(flags & SGC_ATOMIC_SET);
+  c->uncollectable = !!(flags & SGC_UNCOLLECTABLE_SET);
+#if ALLOW_SET_LOCKING
+  c->locked = 0;
+#endif
+  c->name = name;
+  c->blocks = (MemoryBlock **)malloc_managed(sizeof(MemoryBlock*) * NUM_COMMON_SIZE);
+  memset(c->blocks, 0, sizeof(MemoryBlock*) * NUM_COMMON_SIZE);
+  c->block_ends = (MemoryBlock **)malloc_managed(sizeof(MemoryBlock*) * NUM_COMMON_SIZE);
+  memset(c->block_ends, 0, sizeof(MemoryBlock*) * NUM_COMMON_SIZE);
+
+  ((GC_SetWithOthers *)c)->others = NULL;
+  c->othersptr = &((GC_SetWithOthers *)c)->others;
+
+  free_managed(common_sets);
+  common_sets = naya;
+
+  return c;
+}
+
+void *GC_malloc(size_t size)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(0)
+		   size, common, common_ends, &others, 0, 0);
+}
+
+void *GC_malloc_atomic(size_t size)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(1)
+		   size, atomic_common, atomic_common_ends, 
+		   &atomic_others, !NO_ATOMIC, 0);
+}
+
+void *GC_malloc_uncollectable(size_t size)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(2)
+		   size, uncollectable_common, uncollectable_common_ends, 
+		   &uncollectable_others, 0, 1);
+}
+
+void *GC_malloc_atomic_uncollectable(size_t size)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(3)
+		   size, uncollectable_atomic_common, uncollectable_atomic_common_ends, 
+		   &uncollectable_atomic_others, !NO_ATOMIC, 1);
+}
+
+void *GC_malloc_specific(size_t size, struct GC_Set *set)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(set->no)
+		   size, set->blocks, set->block_ends, set->othersptr, 
+		   set->atomic, set->uncollectable);
+}
+
+void *GC_malloc_stubborn(size_t size)
+{
+  return GC_malloc(size);
+}
+
+#if PROVIDE_MALLOC_AND_FREE
+void *malloc(size_t size)
+{
+  return do_malloc(KEEP_SET_INFO_ARG(4)
+		   size, sys_malloc, sys_malloc_ends, 
+		   &sys_malloc_others, 1, 1);
+}
+
+void *realloc(void *p, size_t size)
+{
+  void *naya;
+  size_t oldsize;
+
+  if (p) {
+    oldsize = (size_t)GC_size(p);
+    if (!oldsize)
+      FPRINTF(STDERR, "illegal realloc\n");
+  } else
+    oldsize = 0;
+  naya = malloc(size);
+  if (oldsize > size)
+    oldsize = size;
+  memcpy(naya, p, oldsize);
+  if (p)
+    free(p);
+  return naya;
+}
+
+void *calloc(size_t n, size_t size)
+{
+  void *p;
+  long c;
+
+  c = n * size;
+  p = malloc(c);
+  memset(p, 0, c);
+
+  return p;
+}
+
+void free(void *p)
+{
+  if (p)
+    GC_free(p);
+}
+
+#ifdef WIN32
+size_t _msize(void *p)
+{
+	return GC_size(p);
+}
+#endif
+
+#endif
+
+void GC_general_register_disappearing_link(void **p, void *a)
+{
+  DisappearingLink *dl;
+    
+  dl = (DisappearingLink *)malloc_managed(sizeof(DisappearingLink));
+  dl->watch = a;
+  dl->disappear = p;
+  dl->saved_value = NULL;
+  dl->prev = NULL;
+  dl->next = disappearing;
+  if (dl->next)
+    dl->next->prev = dl;
+  disappearing = dl;
+
+  GC_dl_entries++;
+
+  mem_real_use += sizeof(DisappearingLink);
+}
+
+DisappearingLink *GC_find_dl(void *p)
+{
+  DisappearingLink *dl;
+
+  for (dl = disappearing; dl; dl = dl->next)
+    if ((dl->watch == p) || (!dl->watch && (*dl->disappear == p)))
+      return dl;
+
+  return NULL;
+}
+
+static void register_finalizer(void *p, void (*f)(void *p, void *data), 
+			       void *data, void (**oldf)(void *p, void *data), 
+			       void **olddata, int eager, int ignore_self)
+{
+  MemoryBlock *block = NULL;
+  MemoryChunk *chunk = NULL;
+  int pos;
+
+  if ((p = find_ptr(p, NULL, &block, &pos, &chunk, 0))) {
+    Finalizer *fn;
+
+    if (block) {
+      fn = block->finalizers;
+      while (fn && (fn->u.pos != pos))
+	fn = fn->next;
+      if (fn && !f) {
+	if (fn->prev)
+	  fn->prev->next = fn->next;
+	else
+	  block->finalizers = fn->next;
+	if (fn->next)
+	  fn->next->prev = fn->prev;
+      }
+    } else {
+      fn = chunk->finalizers;
+      if (fn && !f)
+	chunk->finalizers = NULL;
+    }
+
+    if (oldf)
+      *oldf = (fn ? fn->f : NULL);
+    if (olddata)
+      *olddata = (fn ? fn->data : NULL);
+    
+    if (f) {
+      int isnaya = !fn;
+
+      if (!fn) {
+	fn = (Finalizer *)malloc_managed(sizeof(Finalizer));
+	mem_real_use += sizeof(Finalizer);
+	GC_fo_entries++;
+      }
+
+      fn->u.pos = pos;
+      fn->f = f;
+      fn->data = data;
+      fn->eager = eager;
+      fn->ignore_self = ignore_self;
+      
+      if (isnaya) {
+	fn->prev = NULL;
+	if (block) {
+	  fn->next = block->finalizers;
+	  if (fn->next)
+	    fn->next->prev = fn;
+	  block->finalizers = fn;
+	} else {
+	  chunk->finalizers = fn;
+	  fn->next = NULL;
+	}
+      }
+    } else if (fn) {
+      mem_real_use -= sizeof(Finalizer);
+      free_managed(fn);
+      --GC_fo_entries;
+    }
+  }
+}
+
+void GC_register_finalizer(void *p, void (*f)(void *p, void *data), 
+			   void *data, void (**oldf)(void *p, void *data), 
+			   void **olddata)
+{
+  register_finalizer(PAD_BACKWARD(p), f, data, oldf, olddata, 0, 0);
+}
+
+void GC_register_eager_finalizer(void *p, void (*f)(void *p, void *data), 
+				 void *data, void (**oldf)(void *p, void *data), 
+				 void **olddata)
+{
+  register_finalizer(PAD_BACKWARD(p), f, data, oldf, olddata, 1, 0);
+}
+
+void GC_register_finalizer_ignore_self(void *p, void (*f)(void *p, void *data), 
+				       void *data, void (**oldf)(void *p, void *data), 
+				       void **olddata)
+{
+  register_finalizer(PAD_BACKWARD(p), f, data, oldf, olddata, 0, 1);
+}
+
+/******************************************************************/
+
+void GC_for_each_element(struct GC_Set *set,
+			 void (*f)(void *p, int size, void *data),
+			 void *data)
+{
+  int i;
+  MemoryBlock **blocks = set->blocks;
+  MemoryChunk *c = *(set->othersptr);
+
+#if ALLOW_SET_LOCKING
+  if (!set->uncollectable)
+    set->locked++;
+#endif
+
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock **prev = &blocks[i];
+    MemoryBlock *block = *prev;
+
+    while (block) {
+      int j;
+
+      j = (block->top - block->start) / block->size;
+      
+      while (j--) {
+	int bit = POS_TO_FREE_BIT(j);
+	int pos = POS_TO_FREE_INDEX(j);
+	
+	if (IS_MARKED(block->free[pos] & bit)) {
+	  unsigned long p;
+	  void *s;
+	  
+	  p = block->start + (block->size * j);
+	  s = INT_TO_PTR(p);
+	  
+#if PAD_BOUNDARY_BYTES
+	  s = PAD_FORWARD(s);
+#endif
+	  
+	  f(s, block->size, data);
+	}
+      }
+      block = block->next;
+    }
+  }
+
+  for (; c; c = c->next) {
+    void *s;
+
+    s = INT_TO_PTR(c->start);
+
+#if PAD_BOUNDARY_BYTES
+    s = PAD_FORWARD(s);
+#endif
+
+    f(s, c->end - c->start, data);
+  }
+
+#if ALLOW_SET_LOCKING
+  if (!set->uncollectable)
+    --set->locked;
+#endif
+}
+
+/******************************************************************/
+
+static void free_chunk(MemoryChunk *k, MemoryChunk **prev, struct GC_Set *set)
+{
+  MemoryChunk *next;
+  
+#if ALLOW_SET_FINALIZER
+  if (set->finalizer) {
+    void *s = INT_TO_PTR(k->start);
+#if PAD_BOUNDARY_BYTES
+    s = PAD_FORWARD(s);
+#endif
+    set->finalizer(s);
+  }
+#endif
+  
+  mem_real_use -= (k->end - k->start + sizeof(MemoryChunk));
+  
+#if PRINT && 0
+  FPRINTF(STDERR, "free chunk: %ld (%ld) %d %d\n", 
+	  (unsigned long)k, k->end - k->start,
+	  set->atomic, set->uncollectable);
+#endif
+  
+  next = k->next;
+
+#if KEEP_PREV_PTR
+  if (next)
+    next->prev_ptr = k->prev_ptr;
+#endif
+
+#if CHECK_FREES
+  if (PTR_TO_INT(next) & (SECTOR_SEGMENT_SIZE - 1))
+    free_error("bad next\n");
+#endif
+
+  *prev = next;
+
+  free_sector(k);
+  --num_chunks;
+}
+
+#if PROVIDE_GC_FREE
+void GC_free(void *p) 
+{
+  MemoryBlock *block = NULL;
+  MemoryChunk *chunk = NULL;
+  int fpos;
+  void *found;
+  struct GC_Set *set;
+
+#if CHECK_COLLECTING && CHECK_FREES
+  if (collecting_now)
+    free_error("GC_free during collection\n");
+#endif
+
+  found = find_ptr(p, NULL, &block, &fpos, &chunk, 1);
+  if (!found) {
+#if CHECK_FREES
+    char b[256];
+    sprintf(b, "GC_free failed! %lx\n", (long)p);
+    free_error(b);
+#endif
+    return;
+  }
+
+  if (PAD_FORWARD(found) == p) {
+    if (block) {
+      int i;
+      int pos = POS_TO_FREE_INDEX(fpos);
+      int fbit = POS_TO_FREE_BIT(fpos);
+      int ubit = POS_TO_UNMARK_BIT(fpos);
+
+#if CHECK_FREES
+      if (block->free[pos] & fbit) {
+	char b[256];
+	sprintf(b, "Block element already free! %lx\n", (long)p);
+	return;
+      }
+# if EXTRA_FREE_CHECKS
+      if (block->set_no != 4) {
+	char b[256];
+	sprintf(b, "GC_free on ptr from wrong block! %lx\n", (long)p);
+	free_error(b);
+	return;
+      }
+# endif
+#endif
+
+      block->free[pos] |= (fbit | ubit);
+
+	  if (!initialized)
+		GC_initialize();
+
+      set = common_sets[block->set_no];
+      
+#if ALLOW_SET_FINALIZER
+      if (set->finalizer)
+	set->finalizer(p);
+#endif
+
+      {
+	int size;
+#if PAD_BOUNDARY_BYTES
+	size = block->size - PAD_START_SIZE - PAD_END_SIZE;
+	((long *)found)[1] = 0; /* 0 extra */
+#else
+	size = block->size;
+#endif
+
+	/* Clear, since collection scans whole block. */
+	memset(p, 0, size);
+      }
+
+      /* Make sure this block is reachable from block_ends: */
+      i = size_index_map[(block->size >> LOG_PTR_SIZE) - 1];
+      if (set->block_ends[i] != block)
+	set->block_ends[i] = set->blocks[i];
+
+      if (set->uncollectable)
+	mem_uncollectable_use -= block->size;
+    } else {
+#if CHECK_FREES && EXTRA_FREE_CHECKS
+      if (chunk->set_no != 4) {
+	char b[256];
+	sprintf(b, "GC_free on ptr from wrong block! %lx\n", (long)p);
+	free_error(b);
+	return;
+      }
+#endif
+      set = common_sets[chunk->set_no];
+      if (set->uncollectable)
+	mem_uncollectable_use -= (chunk->end - chunk->start);
+      free_chunk(chunk, chunk->prev_ptr, set);
+    }
+  }
+#if CHECK_FREES
+  else {
+    char b[256];
+    sprintf(b, "GC_free on block interior! %lx != %lx\n", 
+	    (long)p, (long)PAD_FORWARD(found));
+    free_error(b);
+  }
+#endif
+
+}
+#endif
+
+/******************************************************************/
+
+#if CHECK
+static long cmn_count, chk_count;
+#endif
+
+#if ALLOW_TRACE_COUNT
+static int collecting_with_trace_count;
+
+#define TRACE_COLLECT_SWITCH !collecting_with_trace_count
+#else
+#define TRACE_COLLECT_SWITCH 1
+#endif
+
+#if ALLOW_TRACE_PATH
+static int collecting_with_trace_path;
+static char *current_trace_source;
+
+/* Buffer used to store paths, since allocation is not allowed: */
+# define TRACE_PATH_BUFFER_SIZE 1048576
+static void *trace_path_buffer[TRACE_PATH_BUFFER_SIZE];
+static int trace_path_buffer_pos;
+#endif
+
+#if PAD_BOUNDARY_BYTES
+static void bad_pad(char *where, void *s, long sz, long diff, long offset, 
+		    long pd, long expect)
+{
+  FPRINTF(STDERR,
+	  "pad %s violation at %lx, len %ld (diff %ld+%ld): %lx != %lx\n", 
+	  where, (unsigned long)s, sz, diff, offset, pd, expect);
+}
+#endif
+
+static void collect_init_chunk(MemoryChunk *c, int uncollectable)
+{
+  for (; c; c = c->next) {
+    if (uncollectable && TRACE_COLLECT_SWITCH)
+      c->marked = 1;
+    else
+      c->marked = 0;
+
+#if PAD_BOUNDARY_BYTES
+    /* Test padding: */
+    {
+      void *s = INT_TO_PTR(c->start);
+      long pd, sz, diff;
+      sz = c->end - c->start;
+      diff = ((long *)s)[1];
+      pd = *(long *)s;
+      if (pd != PAD_PATTERN)
+	bad_pad("start", s, sz, diff, 0, pd, PAD_PATTERN);
+      pd = *(long *)INT_TO_PTR(c->end - PAD_END_SIZE);
+      if (pd != PAD_PATTERN)
+	bad_pad("end", s, sz, diff, 0, pd, PAD_PATTERN);
+      if (diff) {
+	/* Given was bigger than requested; check extra bytes: */
+	unsigned char *ps = ((unsigned char *)s) + sz - PAD_END_SIZE - diff;
+	long d = 0;
+	while (d < diff) {
+	  if (*ps != PAD_FILL_PATTERN) {
+	    bad_pad("extra", s, sz, diff, d, *ps, PAD_FILL_PATTERN);
+	  }
+	  ps++;
+	  d++;
+	}
+      }
+    }
+#endif
+
+#if CHECK
+    chk_count++;
+    if ((!low_plausible || (c->start < low_plausible))
+	|| (!high_plausible || (c->end > high_plausible)))
+      FPRINTF(STDERR, "implausible chunk!\n");
+#endif
+  }
+}
+
+static void collect_finish_chunk(MemoryChunk **c, struct GC_Set *set)
+{
+  while (*c) {
+    MemoryChunk *k = *c;
+
+    if (k->marked) {
+      c = &k->next;
+
+      if (!low_plausible || (k->start < low_plausible))
+	low_plausible = k->start;
+      if (!high_plausible || (k->end > high_plausible))
+	high_plausible = k->end;	
+    } else
+      free_chunk(k, c, set);
+  }
+}
+
+static void collect_init_common(MemoryBlock **blocks, int uncollectable)
+{
+  int i, j;
+  int boundary, boundary_val = 0;
+
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock *block = blocks[i];
+    long size = size_map[i];
+
+    while (block) {
+#if CHECK
+      cmn_count++;
+      if ((!low_plausible || (block->start < low_plausible))
+	  || (!high_plausible || (block->end > high_plausible)))
+	FPRINTF(STDERR, "implausible block!\n");
+#endif
+
+#if STAMP_AND_REMEMBER_SOURCE
+      block->low_marker = block->high_marker = 0;
+#endif
+
+#if PAD_BOUNDARY_BYTES
+      /* Test padding: */
+      {
+	unsigned long p;
+	
+	for (p = block->start; p < block->top; p += size) {
+	  void *s = INT_TO_PTR(p);
+	  long pd, diff;
+	  pd = *(long *)s;
+	  diff = ((long *)s)[1];
+	  if (pd != PAD_PATTERN)
+	    bad_pad("start", s, size, diff, 0, pd, PAD_PATTERN);
+	  pd = *(long *)INT_TO_PTR(p + size - PAD_END_SIZE);
+	  if (pd != PAD_PATTERN)
+	    bad_pad("end", s, size, diff, 0, pd, PAD_PATTERN);
+	  if (diff) {
+	    /* Given was bigger than requested; check extra bytes: */
+	    unsigned char *ps = ((unsigned char *)s) + size - PAD_END_SIZE - diff;
+	    long d = 0;
+	    while (d < diff) {
+	      if (*ps != PAD_FILL_PATTERN) {
+		bad_pad("extra", s, size, diff, d, *ps, PAD_FILL_PATTERN);
+	      }
+	      ps++;
+	      d++;
+	    }
+	  }
+	}
+      }
+#endif
+
+      if (uncollectable && TRACE_COLLECT_SWITCH) {
+	for (j = ELEM_PER_BLOCK(block); j-- ; ) {
+#if DISTINGUISH_FREE_FROM_UNMARKED
+	  block->free[j] = SHIFT_COPY_FREE_TO_UNMARKED(block->free[j]);
+#else
+	  block->free[j] = 0;
+#endif
+	}
+      } else {
+	if (block->top < block->end) {
+	  unsigned long diff = block->top - block->start;
+	  diff /= size;
+	  boundary = POS_TO_UNMARK_INDEX(diff);
+	  boundary_val = (POS_TO_UNMARK_BIT(diff) - 1) & ALL_UNMARKED;
+	} else
+	  boundary = ELEM_PER_BLOCK(block);
+
+	for (j = ELEM_PER_BLOCK(block); j-- ; ) {
+	  if (j < boundary)
+	    block->free[j] |= ALL_UNMARKED;
+	  else if (j == boundary)
+	    block->free[j] = boundary_val;
+	  else
+	    block->free[j] = 0;
+	}
+      }
+
+      block = block->next;
+    }
+  }
+}
+
+static void collect_finish_common(MemoryBlock **blocks, 
+				  MemoryBlock **block_ends, 
+				  struct GC_Set *set)
+{
+  int i;
+
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock **prev = &blocks[i];
+    MemoryBlock *block = *prev;
+#if CHECK
+    long size = size_map[i];
+#endif
+
+    while (block) {
+      int allfree;
+#if CHECK
+      if (block->end < block->start
+	  || block->top < block->start
+	  || block->top > block->end)
+	FPRINTF(STDERR,
+		"bad block: %ld %ld %ld %ld\n",
+		size, block->start, block->top, block->end);
+#endif
+#if NO_FREE_BLOCKS
+      block->allfree = 0;
+#endif
+
+#if ALLOW_SET_FINALIZER
+      if (set->finalizer) {
+	unsigned long s;
+	int j;
+	for (j = 0, s = block->start; s < block->top; s += block->size, j++) {
+	  int pos = POS_TO_UNMARK_INDEX(j);
+	  int bit = POS_TO_UNMARK_BIT(j);
+
+	  if (NOT_MARKED(block->free[pos] & bit)) {
+	    void *p = INT_TO_PTR(s);
+#if PAD_BOUNDARY_BYTES
+	    p = PAD_FORWARD(p);
+#endif
+	    set->finalizer(p);
+	  }
+	}
+      }
+#endif
+
+      allfree = 1;
+      {
+	int j;
+	for (j = ELEM_PER_BLOCK(block); j-- ; )
+	  if ((block->free[j] & ALL_UNMARKED) != ALL_UNMARKED) {
+	    allfree = 0;
+	    break;
+	  }
+      }
+
+      if (allfree) {
+	--num_blocks;
+	
+	*prev = block->next;
+	free_sector(block);
+	mem_real_use -= SECTOR_SEGMENT_SIZE;
+
+	block = *prev;
+      } else {
+#if DISTINGUISH_FREE_FROM_UNMARKED
+	/* If it's unmarked, free it: */
+	int j;
+
+	for (j = ELEM_PER_BLOCK(block); j-- ; )
+	  block->free[j] |= SHIFT_UNMARK_TO_FREE(block->free[j]);
+#endif
+
+	if (!low_plausible || (block->start < low_plausible))
+	  low_plausible = block->start;
+	if (!high_plausible || (block->end > high_plausible))
+	  high_plausible = block->end;
+
+	prev = &block->next;
+	block = block->next;
+      }
+    }
+
+    block_ends[i] = blocks[i];
+  }
+}
+
+static int collect_stack_count;
+static int collect_stack_size;
+static unsigned long *collect_stack;
+
+static int collect_end_stackbased;
+
+#if KEEP_DETAIL_PATH
+# define PUSH_SRC(src) collect_stack[collect_stack_count++] = src;
+# define COLLECT_STACK_FRAME_SIZE 3
+#else
+# define PUSH_SRC(src) /*empty*/
+# define COLLECT_STACK_FRAME_SIZE 2
+#endif
+
+static void push_collect(unsigned long start, unsigned long end, unsigned long src)
+{
+  if (collect_stack_count >= collect_stack_size) {
+    long oldsize;
+
+    if (collect_stack)
+      oldsize = sizeof(unsigned long) * (collect_stack_size + (COLLECT_STACK_FRAME_SIZE - 1));
+    else
+      oldsize = 0;
+
+    collect_stack_size = collect_stack_size ? 2 * collect_stack_size : 500;
+    collect_stack = (unsigned long *)realloc_collect_temp(collect_stack, 
+							  oldsize, 
+							  sizeof(unsigned long) 
+							  * (collect_stack_size + (COLLECT_STACK_FRAME_SIZE - 1)));
+  }
+
+  collect_stack[collect_stack_count++] = start;
+  collect_stack[collect_stack_count++] = end;
+  PUSH_SRC(src)
+}
+
+#define PUSH_COLLECT(s, e, src) \
+  if (collect_stack_count < collect_stack_size) { \
+    collect_stack[collect_stack_count++] = s; \
+    collect_stack[collect_stack_count++] = e + 1 - PTR_ALIGNMENT; \
+    PUSH_SRC(src) \
+  } else \
+    push_collect(s, e + 1 - PTR_ALIGNMENT, src);
+
+#if ALLOW_TRACE_COUNT
+
+typedef struct {
+  int count, size;
+  unsigned long *stack;
+} TraceStack;
+
+static void init_trace_stack(TraceStack *s)
+{
+  s->size = s->count = 0;
+  s->stack = NULL;
+}
+
+static void done_trace_stack(TraceStack *s)
+{
+  if (s->stack)
+    free_collect_temp(s->stack);
+}
+
+static void push_trace_stack(unsigned long v, TraceStack *s)
+{
+  if (s->count >= s->size) {
+    long oldsize;
+
+    if (s->stack)
+      oldsize = sizeof(unsigned long)*(s->size + 1);
+    else
+      oldsize = 0;
+
+    s->size = s->size ? 2 * s->size : 500;
+    s->stack = (unsigned long *)realloc_collect_temp(s->stack,
+						     oldsize,
+						     sizeof(unsigned long)*(s->size + 1));
+  }
+
+  s->stack[s->count++] = v;
+}
+
+#define PUSH_TS(v, s) \
+  if (s.count < s.size) { \
+    s.stack[s.count++] = (unsigned long)(v); \
+  } else \
+    push_trace_stack((unsigned long)(v), &s);
+
+#define POP_TS(s) (s.stack[--s.count])
+
+#endif
+
+#if ALLOW_TRACE_COUNT
+
+TraceStack collect_trace_stack, collect_wait_trace_stack;
+
+static int collect_start_tracing;
+static int collect_end_tracing;
+static int collect_trace_count;
+
+#define PUSH_TRACE(v) PUSH_TS(v, collect_trace_stack)
+#define PUSH_WAIT_TRACE(v) PUSH_TS(v, collect_wait_trace_stack)
+
+#define POP_TRACE() POP_TS(collect_trace_stack)
+#define POP_WAIT_TRACE() POP_TS(collect_wait_trace_stack)
+
+#endif
+
+#if ALLOW_TRACE_PATH
+
+TraceStack collect_trace_path_stack;
+
+static int collect_end_path_elem;
+
+#define PUSH_PATH_ELEM(v) PUSH_TS(v, collect_trace_path_stack)
+
+#define POP_PATH_ELEM() POP_TS(collect_trace_path_stack)
+
+#define PATH_ELEM_STACK_NONEMPTY() (collect_trace_path_stack.count)
+
+#endif
+
+static void collect()
+{
+  int stack_cycle = 0;
+  int offset = 0; /* for interior */
+  
+  while (collect_stack_count) {
+    unsigned long s, end;
+#if KEEP_DETAIL_PATH
+    unsigned long source;
+#endif
+    int interior;
+
+#if ALLOW_TRACE_COUNT
+    if (collect_stack_count == collect_start_tracing) {
+      void *tracing_for_object;
+      GC_count_tracer count_tracer;
+      int size;
+
+      tracing_for_object = (void *)POP_WAIT_TRACE();
+      count_tracer = (GC_count_tracer)POP_WAIT_TRACE();
+      size = POP_WAIT_TRACE();
+
+      /* Push current trace onto the stack: */
+      PUSH_TRACE(collect_end_tracing);
+      PUSH_TRACE(collect_trace_count);
+      PUSH_TRACE(count_tracer);
+      PUSH_TRACE(tracing_for_object);
+
+      collect_trace_count = size;
+  
+      collect_end_tracing = collect_start_tracing - COLLECT_STACK_FRAME_SIZE;
+
+      collect_start_tracing = POP_WAIT_TRACE();
+    }
+#endif
+
+    if (collect_stack_count == collect_end_stackbased) {
+      interior = 1;
+
+#if KEEP_DETAIL_PATH
+      source = collect_stack[collect_stack_count - (COLLECT_STACK_FRAME_SIZE - 2)];
+#endif
+      end = collect_stack[collect_stack_count - (COLLECT_STACK_FRAME_SIZE - 1)];
+      s = collect_stack[collect_stack_count - COLLECT_STACK_FRAME_SIZE];
+
+#if PRINT && 0
+      FPRINTF(STDERR, "stack at %ld: [%lx,%lx]\n", collect_end_stackbased, s, end);
+#endif
+
+      /* do everything twice, backing up one pointer alignment 
+	 to catch references just past the end of an array. */
+      if (stack_cycle || NO_STACK_OFFBYONE) {
+	collect_stack_count -= COLLECT_STACK_FRAME_SIZE;
+	collect_end_stackbased -= COLLECT_STACK_FRAME_SIZE;
+#if NO_STACK_OFFBYONE
+	offset = 0;
+#else
+	offset = -PTR_ALIGNMENT;
+#endif
+	stack_cycle = 0;
+      } else {
+	offset = 0;
+	stack_cycle = 1;
+      }
+    } else {
+      interior = CHECK_SIMPLE_INTERIOR_POINTERS;
+      offset = 0;
+#if KEEP_DETAIL_PATH
+      source = collect_stack[--collect_stack_count];
+#endif
+      end = collect_stack[--collect_stack_count];
+      s = collect_stack[--collect_stack_count];
+    }
+
+#if ALLOW_TRACE_PATH
+    if (collecting_with_trace_path) {
+      PUSH_PATH_ELEM(collect_end_path_elem);
+      PUSH_PATH_ELEM(s);
+# if KEEP_DETAIL_PATH
+      PUSH_PATH_ELEM(source);
+# else
+      PUSH_PATH_ELEM(0);
+# endif
+      collect_end_path_elem = collect_stack_count;
+    }
+#endif
+
+    for (; s < end; s += PTR_ALIGNMENT) {
+      void *d = *(void **)INT_TO_PTR(s);
+      unsigned long p = PTR_TO_INT(d) + offset;
+
+      if (p >= low_plausible && p < high_plausible) {
+	SectorPage *pagetable = sector_pagetables[SECTOR_LOOKUP_PAGETABLE(p)];
+	if (pagetable) {
+	  SectorPage *page = pagetable + SECTOR_LOOKUP_PAGEPOS(p);
+	  long kind = page->kind;
+	  
+	  if (kind == sector_kind_block) {
+	    /* Found common block: */
+	    MemoryBlock *block = (MemoryBlock *)INT_TO_PTR(page->start);
+	    int size = block->size;
+	    int diff = p - block->start;
+	    int pos = (diff / size);
+	    
+	    if ((diff >= 0) && (p < block->top) 
+		&& ((diff == pos * size) || interior)) {
+	      int bpos;
+	      int bit;
+#if DISTINGUISH_FREE_FROM_UNMARKED
+	      int fbit;
+#endif
+	      
+	      bpos = POS_TO_UNMARK_INDEX(pos);
+	      bit = POS_TO_UNMARK_BIT(pos);
+#if DISTINGUISH_FREE_FROM_UNMARKED
+	      fbit = POS_TO_FREE_BIT(pos);
+#endif
+	      
+	      if (NOT_MARKED(block->free[bpos] & bit)
+		  && _NOT_FREE(block->free[bpos] & fbit)) {
+#if ALLOW_TRACE_COUNT
+		if (collecting_with_trace_count) {
+		  GC_count_tracer count_tracer;
+		  if ((count_tracer = common_sets[block->set_no]->count_tracer)) {
+		    void *o;
+		    if (interior)
+		      p = block->start + (pos * size);
+		    o = INT_TO_PTR(p);
+		    if (block->atomic) {
+		      void *s = o;
+#if PAD_BOUNDARY_BYTES
+		      s = PAD_FORWARD(s);
+#endif
+		      count_tracer(s, size); 
+		      mem_traced += size;
+		    } else {
+		      /* Push new trace onto the stack: */
+		      PUSH_WAIT_TRACE(collect_start_tracing);
+		      PUSH_WAIT_TRACE(size);
+		      PUSH_WAIT_TRACE(count_tracer);
+		      PUSH_WAIT_TRACE(o);
+		      collect_start_tracing = collect_stack_count + COLLECT_STACK_FRAME_SIZE;
+		    }
+		  } else
+		    collect_trace_count += size;
+		}
+#endif
+#if ALLOW_TRACE_PATH
+		if (collecting_with_trace_path) {
+		  GC_path_tracer path_tracer;
+		  if ((path_tracer = common_sets[block->set_no]->path_tracer)) {
+		    void *o;
+		    if (interior)
+		      p = block->start + (pos * size);
+		    o = INT_TO_PTR(p);
+#if PAD_BOUNDARY_BYTES
+		    o = PAD_FORWARD(o);
+#endif
+		    path_tracer(o, s, &collect_trace_path_stack);
+		  }
+		}
+#endif
+		
+#if PRINT && 0
+		if (interior && (diff % size))
+		  FPRINTF(STDERR,
+			  "inexact block: %d for %lx[%d], %d=(%d, %d) {%d} %lx -> %lx\n", 
+			  diff % size, block, size, pos, bpos, bit,
+			  block->free[bpos], p, block->start + (pos * size));
+#endif
+		
+		block->free[bpos] -= bit;
+		
+		mem_use += size;
+		
+		if (!block->atomic) {
+		  if (interior)
+		    p = block->start + (pos * size);
+		  PUSH_COLLECT(p, p + size, s);
+		}
+		
+#if STAMP_AND_REMEMBER_SOURCE
+		if (!block->low_marker || (s < block->low_marker))
+		  block->low_marker = s;
+		if (!block->high_marker || (s > block->high_marker))
+		  block->high_marker = s;
+#endif
+	      }
+	    }
+	  } else if (kind == sector_kind_chunk) {
+	    MemoryChunk *c = (MemoryChunk *)INT_TO_PTR(page->start);
+	    
+	    if (((p == c->start) 
+		 || (interior && (p > c->start) && (p < c->end)))
+		&& !c->marked) {
+#if ALLOW_TRACE_COUNT
+	      if (collecting_with_trace_count) {
+		GC_count_tracer count_tracer;
+		int size = (c->end - c->start);
+		if ((count_tracer = common_sets[c->set_no]->count_tracer)) {
+		  void *o;
+		  o = INT_TO_PTR(c->start);
+		  if (c->atomic) {
+		    void *s = o;
+#if PAD_BOUNDARY_BYTES
+		    s = PAD_FORWARD(s);
+#endif
+		    count_tracer(s, size); 
+		    mem_traced += size;
+		  } else {
+		    /* Push new trace onto the stack: */
+		    PUSH_WAIT_TRACE(collect_start_tracing);
+		    PUSH_WAIT_TRACE(size);
+		    PUSH_WAIT_TRACE(count_tracer);
+		    PUSH_WAIT_TRACE(o);
+		    collect_start_tracing = collect_stack_count + COLLECT_STACK_FRAME_SIZE;
+		  }
+		} else
+		  collect_trace_count += size;
+	      }
+#endif
+#if ALLOW_TRACE_PATH
+	      if (collecting_with_trace_path) {
+		GC_path_tracer path_tracer;
+		if ((path_tracer = common_sets[c->set_no]->path_tracer)) {
+		  void *o;
+		  o = INT_TO_PTR(c->start);
+#if PAD_BOUNDARY_BYTES
+		  o = PAD_FORWARD(o);
+#endif
+		  path_tracer(o, s, &collect_trace_path_stack);
+		}
+	      }
+#endif
+
+#if PRINT && 0
+	      if (interior && (p != c->start))
+		FPRINTF(STDERR, "inexact chunk: %lx != %lx\n", p, c->start);
+#endif
+#if PRINT && 0
+	      FPRINTF(STDERR,
+		      "push %ld (%ld) from %ld\n",
+		      p, (c->end - c->start), s);
+#endif
+	      c->marked = 1;
+	      mem_use += (c->end - c->start);
+	      if (!c->atomic) {
+		PUSH_COLLECT(c->start, c->end, s);
+	      }
+#if STAMP_AND_REMEMBER_SOURCE
+	      c->marker = s;
+#endif
+	    }
+	  }
+	}
+      }
+    }
+
+#if ALLOW_TRACE_COUNT
+    while (collect_stack_count == collect_end_tracing) {
+      void *tracing_for_object, *s;
+      GC_count_tracer count_tracer;
+      
+      tracing_for_object = (void *)POP_TRACE();
+      count_tracer = (GC_count_tracer)POP_TRACE();
+
+      s = tracing_for_object;
+#if PAD_BOUNDARY_BYTES
+      s = PAD_FORWARD(s);
+#endif
+      count_tracer(s, collect_trace_count);
+      mem_traced += collect_trace_count;
+
+      collect_trace_count = POP_TRACE();
+      collect_end_tracing = POP_TRACE();
+    }
+#endif
+#if ALLOW_TRACE_PATH
+    if (collecting_with_trace_path) {
+      while (PATH_ELEM_STACK_NONEMPTY() && (collect_stack_count == collect_end_path_elem)) {
+	(void)POP_PATH_ELEM(); /* source */
+	(void)POP_PATH_ELEM(); /* obj */
+	collect_end_path_elem = POP_PATH_ELEM();
+      }
+    }
+#endif
+  }
+
+#if ALLOW_TRACE_COUNT && CHECK
+  if (collect_trace_stack.count)
+    FPRINTF(STDERR, "BOO-BOO: trace stack not emty: %d\n", collect_trace_stack.count);
+  if (collect_wait_trace_stack.count)
+    FPRINTF(STDERR, "BOO-BOO: wait trace stack not emty: %d\n", collect_wait_trace_stack.count);
+#endif
+}
+
+static jmp_buf buf;
+
+/* Sparc fix borrowed from SCM, so here's the copyright:  */
+/* Scheme implementation intended for JACAL.
+   Copyright (C) 1990, 1991, 1992, 1993, 1994 Aubrey Jaffer. */
+/* James Clark came up with this neat one instruction fix for
+   continuations on the SPARC.  It flushes the register windows so
+   that all the state of the process is contained in the stack. */
+#ifdef sparc
+#define FLUSH_REGISTER_WINDOWS asm("ta 3")
+#else
+#define FLUSH_REGISTER_WINDOWS /* empty */
+#endif
+
+static void push_stack(void *stack_now)
+{
+  unsigned long start, end;
+
+  start = PTR_TO_INT(GC_stackbottom);
+  end = PTR_TO_INT(stack_now);
+
+#if PRINT && STAMP_AND_REMEMBER_SOURCE
+  FPRINTF(STDERR, "stack in [%lx, %lx]\n", start, end);
+#endif
+
+  if (start < end) {
+    PUSH_COLLECT(start, end, 0);
+  } else {
+    PUSH_COLLECT(end, start, 0);
+  }
+
+#if DUMP_BLOCK_MAPS
+  trace_stack_start = collect_stack[collect_stack_count - COLLECT_STACK_FRAME_SIZE];
+  trace_stack_end = collect_stack[collect_stack_count - (COLLECT_STACK_FRAME_SIZE - 1)];
+#endif
+
+  start = PTR_TO_INT((void *)&buf);
+  end = start + sizeof(buf);
+  PUSH_COLLECT(start, end, 0);
+
+#if DUMP_BLOCK_MAPS
+  trace_reg_start = collect_stack[collect_stack_count - COLLECT_STACK_FRAME_SIZE];
+  trace_reg_end = collect_stack[collect_stack_count - (COLLECT_STACK_FRAME_SIZE - 1)];
+#endif
+
+#if PRINT && STAMP_AND_REMEMBER_SOURCE
+  FPRINTF(STDERR, "jmpbuf in [%lx, %lx]\n", start, end);
+#endif
+}
+
+#if ALLOW_SET_LOCKING
+static void push_locked_chunk(MemoryChunk *c, int atomic)
+{
+  for (; c; c = c->next) {
+    unsigned long size = (c->end - c->start);
+    mem_use += size;
+    collect_trace_count += size;
+    if (!atomic) {
+      PUSH_COLLECT(c->start, c->end, 0);
+    }
+  }
+}
+
+static void push_locked_common(MemoryBlock **blocks, int atomic)
+{
+  int i;
+
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock *block = blocks[i];
+    
+    for (; block; block = block->next) {
+      unsigned long size = block->size;
+      unsigned long start = block->start;
+      unsigned long top = block->top;
+      int j;
+      
+      for (j = 0; start < top; start += size, j++) {
+	int bit = POS_TO_UNMARK_BIT(j);
+	int pos = POS_TO_UNMARK_INDEX(j);
+	if (IS_MARKED(block->free[pos] & bit)) {
+	  if (!atomic) {
+	    PUSH_COLLECT(start, start + size, 0);
+	  }
+	  mem_use += size;
+	  collect_trace_count += size;
+	}
+      }
+    }
+  }
+}
+
+#endif
+
+static void push_uncollectable_chunk(MemoryChunk *c, struct GC_Set *set)
+{
+#if ALLOW_TRACE_COUNT
+  if (!collecting_with_trace_count
+      || !c
+      || !set->count_tracer) {
+#endif
+    for (; c; c = c->next) {
+#if ALLOW_TRACE_COUNT
+      if (!c->marked) {
+	if (collecting_with_trace_count) {
+	  c->marked = 1;
+	  collect_trace_count += (c->end - c->start);
+	}
+	if (!set->atomic) {
+#endif      
+	  PUSH_COLLECT(c->start, c->end, 0);
+#if ALLOW_TRACE_COUNT
+	}
+      } else {
+	/* It got marked the normal way; deduct the size. */
+	mem_use -= (c->end - c->start);
+      }
+#endif
+    }
+#if ALLOW_TRACE_COUNT
+  } else {
+    int save_count = collect_trace_count;
+    for (; c; c = c->next) {
+      if (!c->marked) {
+	void *s;
+	c->marked = 1;
+	collect_trace_count = 0;
+	if (!c->atomic) {
+	  PUSH_COLLECT(c->start, c->end, 0);
+	  collect();
+	}
+	collect_trace_count += (c->end - c->start);
+
+	s = INT_TO_PTR(c->start);
+#if PAD_BOUNDARY_BYTES
+	s = PAD_FORWARD(s);
+#endif
+	set->count_tracer(s, collect_trace_count);
+	mem_traced += collect_trace_count;
+      } else {
+	/* It got marked the normal way; deduct the size. */
+	mem_use -= (c->end - c->start);
+      }
+    }
+    collect_trace_count = save_count;
+  }
+#endif
+}
+
+static void push_uncollectable_common(MemoryBlock **blocks, struct GC_Set *set)
+{
+  int i;
+
+#if ALLOW_TRACE_COUNT
+  if (!collecting_with_trace_count) {
+#endif
+    for (i = 0; i < NUM_COMMON_SIZE; i++) {
+      MemoryBlock *block = blocks[i];
+      
+      while (block) {
+	PUSH_COLLECT(block->start, block->top, 0);
+	block = block->next;
+      }
+    }
+#if ALLOW_TRACE_COUNT
+  } else {
+    int save_count = collect_trace_count;
+
+    for (i = 0; i < NUM_COMMON_SIZE; i++) {
+      MemoryBlock *block = blocks[i];
+      
+      while (block) {
+	unsigned long size = block->size;
+	unsigned long start = block->start;
+	unsigned long top = block->top;
+	int j;
+	
+	for (j = 0; start < top; start += size, j++) {
+	  int bit;
+	  int pos;
+	  int fbit;
+
+	  pos = POS_TO_UNMARK_INDEX(j);
+	  bit = POS_TO_UNMARK_BIT(j);
+	  fbit = POS_TO_FREE_BIT(j);
+
+	  if (NOT_MARKED(block->free[pos] & bit)
+	      && _NOT_FREE(block->free[pos] & fbit)) {
+	    block->free[pos] -= bit;
+	    if (set->count_tracer)
+	      collect_trace_count = 0;
+	    else
+	      collect_trace_count += size;
+	    if (!block->atomic) {
+	      PUSH_COLLECT(start, start + size, 0);
+	      collect();
+	    }
+	    if (set->count_tracer) {
+	      void *s;
+	      collect_trace_count += size;
+	      s = INT_TO_PTR(start);
+#if PAD_BOUNDARY_BYTES
+	      s = PAD_FORWARD(s);
+#endif
+	      set->count_tracer(s, collect_trace_count);
+	      mem_traced += collect_trace_count;
+	    }
+	  } else {
+	    /* It got marked the normal way; deduct the size. */
+	    mem_use -= size;
+	  }
+	}
+
+	block = block->next;
+      }
+    }
+
+    if (set->count_tracer)
+      collect_trace_count = save_count;
+  }
+#endif
+}
+
+
+static void push_collect_ignore(unsigned long s, unsigned long e, 
+				unsigned long a)
+/* Like PUSH_COLLECT, but immediate references to `a' are avoided */
+{
+  unsigned long push_from = s;
+
+#if PAD_BOUNDARY_BYTES
+  a = PTR_TO_INT(PAD_FORWARD(INT_TO_PTR(a)));
+#endif
+
+  for (; s < e; s += PTR_ALIGNMENT) {
+    void *d = *(void **)INT_TO_PTR(s);
+    unsigned long p = PTR_TO_INT(d);
+
+    if (p == a) {
+      if (push_from != s) {
+	PUSH_COLLECT(push_from, s, a);
+      }
+      push_from = s + PTR_ALIGNMENT;
+    }
+  }
+
+  if (push_from != s) {
+    PUSH_COLLECT(push_from, s, a);
+  }
+}
+
+static void mark_chunks_for_finalizations(MemoryChunk *c)
+{
+  for (; c; c = c->next) {
+    Finalizer *fn = c->finalizers;
+
+    if (fn) {
+      /* Always mark data associated with finalization: */
+      unsigned long p = PTR_TO_INT(&fn->data);
+      PUSH_COLLECT(p, p + PTR_SIZE, 0);
+
+      /* If not eager, mark data reachable from finalized block: */
+      if (!fn->eager && !c->marked && !c->atomic) {
+	if (fn->ignore_self)
+	  push_collect_ignore(c->start, c->end, c->start);
+	else {
+	  PUSH_COLLECT(c->start, c->end, 0);
+	}
+      }
+    }
+  }
+
+  collect();
+}
+
+static void mark_common_for_finalizations(MemoryBlock **blocks, int atomic)
+{
+  int i;
+
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock *block = blocks[i];
+    for (; block; block = block->next) {
+      Finalizer *fn = block->finalizers;
+      for (; fn ; fn = fn->next) {
+	unsigned long p;
+	  
+	/* Always mark data associated with finalization: */
+	p = PTR_TO_INT(&fn->data);
+	PUSH_COLLECT(p, p + PTR_SIZE, 0);
+
+	/* If not eager, mark data reachable from finalized block: */
+	if (!fn->eager) {
+	  int pos, apos;
+	  int bit, fbit;
+
+	  pos = fn->u.pos;
+	  apos = POS_TO_UNMARK_INDEX(pos);
+	  bit = POS_TO_UNMARK_BIT(pos);
+	  fbit = POS_TO_FREE_BIT(pos);
+	  
+	  if (NOT_MARKED(block->free[apos] & bit)
+	      && _NOT_FREE(block->free[apos] & fbit)) {
+	    int size = block->size;
+	    
+	    if (!atomic) {
+	      p = block->start + (pos * size);
+	      if (fn->ignore_self)
+		push_collect_ignore(p, p + size, p);
+	      else {
+		PUSH_COLLECT(p, p + size, 0);
+	      }
+
+#if WATCH_FOR_FINALIZATION_CYCLES
+	      collect();
+	      if (IS_MARKED(block->free[apos] & bit))
+		FPRINTF(STDERR, "cycle: %lx\n", p);
+#endif
+	    }
+	  }
+	}
+      }
+    }
+  }
+
+  collect();
+}
+
+static void enqueue_fn(Finalizer *fn)
+{
+  /* DO NOT COLLECT FROM collect_stack DURING THIS PROCEDURE */
+
+  unsigned long p;
+
+  if (last_queued_finalizer) {
+    fn->prev = last_queued_finalizer;
+    fn->prev->next = fn;
+    fn->next = NULL;
+  } else {
+    fn->next = queued_finalizers;
+    if (fn->next)
+      fn->next->prev = fn;
+    queued_finalizers = fn;
+  }
+  last_queued_finalizer = fn;
+
+  /* Need to mark watched as in-use, now: */
+  /* (if this finalizer is eager, block contents are now marked too) */
+  p = PTR_TO_INT(&fn->u.watch);
+  PUSH_COLLECT(p, p + PTR_SIZE, 0);
+}
+
+static void queue_chunk_finalizeable(MemoryChunk *c, int eager)
+{
+  /* DO NOT COLLECT FROM collect_stack DURING THIS PROCEDURE */
+
+  for (; c; c = c->next) {
+    if (c->finalizers && !c->marked) {
+      Finalizer *fn = c->finalizers;
+
+      if (fn->eager == eager) {
+	c->finalizers = NULL;
+
+	fn->u.watch = INT_TO_PTR(c->start);
+	enqueue_fn(fn);
+
+	if (eager) {
+	  /* Always mark data associated with finalization: */
+	  unsigned long p = PTR_TO_INT(&fn->data);
+	  PUSH_COLLECT(p, p + PTR_SIZE, 0);
+	}
+      }
+    }
+  }
+}
+
+static void queue_common_finalizeable(MemoryBlock **blocks, int eager)
+{
+  /* DO NOT COLLECT FROM collect_stack DURING THIS PROCEDURE */
+
+  int i;
+  
+  for (i = 0; i < NUM_COMMON_SIZE; i++) {
+    MemoryBlock *block = blocks[i];
+    for (; block; block = block->next) {
+      Finalizer *fn = block->finalizers, *next;
+      
+      for (; fn; fn = next) {
+	int pos, apos;
+	int bit;
+	  
+	next = fn->next;
+
+	pos = fn->u.pos;
+	apos = POS_TO_UNMARK_INDEX(pos);
+	bit = POS_TO_UNMARK_BIT(pos);
+	
+	if (NOT_MARKED(block->free[apos] & bit)) {
+	  unsigned long p;
+	
+	  if (fn->eager == eager) {
+	    if (fn->prev)
+	      fn->prev->next = fn->next;
+	    else
+	      block->finalizers = fn->next;
+	    if (fn->next)
+	      fn->next->prev = fn->prev;
+	    
+	    p = block->start + (pos * block->size);
+	    fn->u.watch = INT_TO_PTR(p);
+	    enqueue_fn(fn);
+
+	    if (eager) {
+	      /* Always mark data associated with finalization: */
+	      p = PTR_TO_INT(&fn->data);
+	      PUSH_COLLECT(p, p + PTR_SIZE, 0);
+	    }
+	  }
+	}
+      }
+    }
+  }
+}
+
+static void do_disappear_and_finals()
+{
+  DisappearingLink *dl, *next;
+  Finalizer *fn;
+  int j;
+
+  /* Mark data in (not-yet-finalized) queued finalizable */
+  for (fn = queued_finalizers; fn; fn = fn->next) {
+    unsigned long p;
+
+    p = PTR_TO_INT(&fn->u.watch);
+    PUSH_COLLECT(p, p + PTR_SIZE, 0);
+
+    p = PTR_TO_INT(&fn->data);
+    PUSH_COLLECT(p, p + PTR_SIZE, 0);
+  }
+  collect();
+
+#if !NO_DISAPPEARING
+  /* Do disappearing: */
+  for (dl = disappearing; dl; dl = next) {
+    void *watch;
+    int size;
+
+    next = dl->next;
+
+    watch = (dl->watch ? dl->watch : *dl->disappear);
+
+    size = 0;
+    if (watch && !find_ptr(watch, &size, NULL, NULL, NULL, 0)) {
+      /* was the pointer allocated at all? */
+      if (size) {
+	/* It's gone: */
+	if (dl->watch) {
+	  /* disappear is done. */
+	  if (dl->prev)
+	    dl->prev->next = dl->next;
+	  else
+	    disappearing = dl->next;
+	  if (dl->next)
+	    dl->next->prev = dl->prev;
+	  *dl->disappear = NULL;
+
+	  mem_real_use -= sizeof(DisappearingLink);
+	  free_managed(dl);
+	  --GC_dl_entries;
+	} else {
+	  /* We'll need to restore this one: */
+	  dl->saved_value = *dl->disappear;
+	  *dl->disappear = NULL;
+	}
+      }
+    }
+  }
+#endif
+
+  /* Queue unreachable eager finalizable: */  
+  /* DO NOT COLLECT FROM collect_stack UNTIL AFTER THIS LOOP */
+  /* (Otherwise, some ready eager finalizations may not be queued.) */
+  for (j = 0; j < num_common_sets; j++) {
+    queue_chunk_finalizeable(*(common_sets[j]->othersptr), 1);
+    queue_common_finalizeable(common_sets[j]->blocks, 1);
+  }
+  collect();
+
+  /* Mark reachable from (non-eager) finalized blocks: */
+  for (j = 0; j < num_common_sets; j++) {
+    mark_chunks_for_finalizations(*(common_sets[j]->othersptr));
+    mark_common_for_finalizations(common_sets[j]->blocks, common_sets[j]->atomic);
+  }
+
+  /* Queue unreachable (non-eager) finalizable: */  
+  for (j = 0; j < num_common_sets; j++) {
+    queue_chunk_finalizeable(*(common_sets[j]->othersptr), 0);
+    queue_common_finalizeable(common_sets[j]->blocks, 0);
+  }
+  collect();
+
+  /* Restore disappeared links where watch value is NULL: */
+  for (dl = disappearing; dl; dl = next) {
+    next = dl->next;
+    if (!dl->watch && dl->saved_value) {
+      /* Restore disappearing value and deregister */
+      *dl->disappear = dl->saved_value;
+      dl->saved_value = NULL;
+    }
+  }
+  
+  /* Deregister dangling disappearings: */
+  for (dl = disappearing; dl; dl = next) {
+    int size;
+
+    next = dl->next;
+    
+    size = 0;
+    if (!find_ptr(dl->disappear, &size, NULL, NULL, NULL, 0) && size) {
+      /* Found it, but it was unmarked. Deregister disappearing. */
+      if (dl->prev)
+	dl->prev->next = dl->next;
+      else
+	disappearing = dl->next;
+      if (dl->next)
+	dl->next->prev = dl->prev;
+
+      mem_real_use -= sizeof(DisappearingLink);
+      free_managed(dl);
+      --GC_dl_entries;
+    }
+  }
+
+  if (GC_custom_finalize)
+    GC_custom_finalize();
+}
+
+static int compare_roots(const void *a, const void *b)
+{
+  if (*(unsigned long *)a < *(unsigned long *)b)
+    return -1;
+  else
+    return 1;
+}
+
+static void sort_and_merge_roots()
+{
+  static int counter = 0;
+  int i, offset, top;
+
+  if (roots_count < 4)
+    return;
+
+  /* Only try this every 5 collections or so: */
+  if (counter--)
+    return;
+  counter = 5;
+
+  qsort(roots, roots_count >> 1, 2 * sizeof(unsigned long), compare_roots);
+  offset = 0;
+  top = roots_count;
+  for (i = 2; i < top; i += 2) {
+    if ((roots[i - 2 - offset] <= roots[i])
+	&& ((roots[i - 1 - offset] + (PTR_ALIGNMENT - 1)) >= roots[i])) {
+      /* merge: */
+      if (roots[i + 1] > roots[i - 1 - offset])
+	roots[i - 1 - offset] = roots[i + 1];
+      offset += 2;
+      roots_count -= 2;
+    } else if (offset) {
+      /* compact: */
+      roots[i - offset] = roots[i];
+      roots[i + 1 - offset] = roots[i + 1];
+    }
+  }
+}
+
+static void run_finalizers(void)
+{
+  static int doing = 0;
+  Finalizer *fn;
+  void *s;
+
+  /* don't allow nested finalizations */
+  if (doing)
+    return;
+  doing++;
+
+#if !NO_FINALIZING
+  while (queued_finalizers) {
+    fn = queued_finalizers;
+    queued_finalizers = fn->next;
+    if (!fn->next)
+      last_queued_finalizer = NULL;
+
+    s = fn->u.watch;
+    
+#if PAD_BOUNDARY_BYTES
+    s = PAD_FORWARD(s);
+#endif
+
+    fn->f(s, fn->data);
+
+    mem_real_use -= sizeof(Finalizer);
+    free_managed(fn);
+    --GC_fo_entries;
+  }
+#endif
+
+  doing--;
+}
+
+#if ALLOW_TRACE_COUNT
+static int traced_from_roots, traced_from_stack, traced_from_uncollectable, traced_from_finals;
+#endif
+
+#if TIME
+# define PRINTTIME(x) FPRINTF x
+#else
+# define PRINTTIME(x) /* empty */
+#endif
+
+/* Immitate Boehm's private GC call; used by MzScheme */
+void GC_push_all_stack(void *sp, void *ep)
+{
+  unsigned long s, e;
+
+  s = PTR_TO_INT(sp);
+  e = PTR_TO_INT(ep);
+
+  PUSH_COLLECT(s, e, 0);
+}
+
+void do_GC_gcollect(void *stack_now)
+{
+  long root_marked;
+  int j;
+
+#if SGC_STD_DEBUGGING
+  long orig_mem_use = mem_use;
+  FPRINTF(STDERR, "gc at %ld (%ld): %ld\n",
+	  mem_use, sector_mem_use, 
+# if GET_MEM_VIA_SBRK
+	  (long)sbrk(0)
+# else
+#  ifdef WIN32
+	  total_memory_use()
+#  else
+	  0
+#  endif
+# endif
+	  );
+#endif
+
+  if (!GC_stackbottom) {
+    /* Stack position not yet initialize; delay collection */
+    if (mem_use)
+      mem_limit = MEM_USE_FACTOR * mem_use;
+    return;
+  }
+
+  if (!initialized)
+    GC_initialize();
+
+  if (!statics_setup)
+    init_static_variables();
+
+  if (GC_collect_start_callback)
+    GC_collect_start_callback();
+
+#if CHECK_COLLECTING
+  collecting_now = 1;
+#endif
+
+#if !NO_COLLECTIONS
+
+# if ALWAYS_TRACE && ALLOW_TRACE_COUNT
+  collecting_with_trace_count = 1;
+# endif
+
+# if CHECK
+  cmn_count = chk_count = 0;
+# endif
+
+  PRINTTIME((STDERR, "gc: common init start: %ld\n", scheme_get_process_milliseconds()));
+
+  for (j = 0; j < num_common_sets; j++) {
+# if ALLOW_SET_LOCKING
+    if (!common_sets[j]->locked) {
+# endif
+      collect_init_chunk(*(common_sets[j]->othersptr),
+			 common_sets[j]->uncollectable);
+      collect_init_common(common_sets[j]->blocks,
+			  common_sets[j]->uncollectable);
+# if ALLOW_SET_LOCKING
+    }
+# endif
+  }
+
+# if CHECK
+  if (num_chunks != chk_count) {
+    FPRINTF(STDERR, "bad chunk count: %ld != %ld\n", num_chunks, chk_count);
+  }
+
+  if (num_blocks != cmn_count) {
+    FPRINTF(STDERR, "bad block count: %ld != %ld\n", num_blocks, cmn_count);
+  }
+# endif
+
+# if PRINT
+  FPRINTF(STDERR, "gc at %ld (%ld)\n", mem_use, mem_real_use);
+  FPRINTF(STDERR,
+	  "low: %lx hi: %lx blocks: %ld chunks: %ld\n", 
+	  low_plausible, high_plausible, 
+	  num_blocks, num_chunks);
+# endif
+
+  mem_use = 0;
+
+  sort_and_merge_roots();
+
+# if ALLOW_TRACE_COUNT
+  init_trace_stack(&collect_trace_stack);
+  init_trace_stack(&collect_wait_trace_stack);
+  collect_start_tracing = 0;
+  collect_end_tracing = -1;
+# endif
+# if ALLOW_TRACE_PATH
+  init_trace_stack(&collect_trace_path_stack);
+# endif
+
+  prepare_collect_temp();
+
+  collect_stack_size = roots_count ? COLLECT_STACK_FRAME_SIZE * roots_count : 10;
+  collect_stack_count = 0;
+  collect_stack = (unsigned long *)realloc_collect_temp(NULL,
+							0,
+							sizeof(unsigned long) 
+							* (collect_stack_size + 1));
+  for (j = 0; j < roots_count; j += 2) {
+    collect_stack[collect_stack_count++] = roots[j];
+    collect_stack[collect_stack_count++] = roots[j + 1];
+    collect_stack[collect_stack_count++] = 0;
+  }
+
+  PRINTTIME((STDERR, "gc: root collect start: %ld\n", scheme_get_process_milliseconds()));
+
+# if ALLOW_TRACE_COUNT
+  collect_trace_count = 0;
+  mem_traced = 0;
+# endif
+
+# if ALLOW_TRACE_PATH
+  current_trace_source = "root";
+# endif
+
+  collect();
+
+# if ALLOW_SET_LOCKING
+  for (j = 0; j < num_common_sets; j++) {
+    if (common_sets[j]->locked) {
+      int a = common_sets[j]->atomic;
+      push_locked_chunk(*(common_sets[j]->othersptr), a);
+      push_locked_common(common_sets[j]->blocks, a);
+    }
+  }
+
+  collect();
+# endif
+
+# if ALLOW_TRACE_COUNT
+  traced_from_roots = collect_trace_count;
+  collect_trace_count = 0;
+# endif
+
+  root_marked = mem_use;
+
+  push_stack(stack_now);
+  
+  collect_end_stackbased = collect_stack_count;
+# if PRINT && 0
+  FPRINTF(STDERR, "stack until: %ld\n", collect_end_stackbased);
+# endif
+
+# if ALLOW_TRACE_PATH
+  current_trace_source = "stack";
+# endif
+
+  PRINTTIME((STDERR, "gc: stack collect start: %ld\n", scheme_get_process_milliseconds()));
+
+  collect();
+
+  PRINTTIME((STDERR, "gc: \"other roots\" start: %ld\n", scheme_get_process_milliseconds()));
+
+  if (GC_push_other_roots) {
+    GC_push_other_roots();
+    collect_end_stackbased = collect_stack_count;
+  }
+
+# if ALLOW_TRACE_PATH
+  current_trace_source = "xstack";
+# endif
+
+  collect();
+
+# if ALLOW_TRACE_COUNT
+  traced_from_stack = collect_trace_count;
+  collect_trace_count = 0;
+# endif
+
+  PRINTTIME((STDERR, "gc: uncollectable start: %ld\n", scheme_get_process_milliseconds()));
+
+  for (j = 0; j < num_common_sets; j++)
+    if (common_sets[j]->uncollectable)
+      if (!common_sets[j]->atomic
+# if ALLOW_TRACE_COUNT
+	  || collecting_with_trace_count
+# endif
+	  ) {
+	push_uncollectable_chunk(*(common_sets[j]->othersptr), common_sets[j]);
+	push_uncollectable_common(common_sets[j]->blocks, common_sets[j]);
+      }
+
+# if ALLOW_TRACE_PATH
+  current_trace_source = "uncollectable";
+# endif
+
+  collect();
+
+# if ALLOW_TRACE_COUNT
+  traced_from_uncollectable = collect_trace_count;
+  collect_trace_count = 0;
+# endif
+  
+  PRINTTIME((STDERR, "gc: queue finalize start: %ld\n", scheme_get_process_milliseconds()));
+
+# if ALLOW_TRACE_PATH
+  current_trace_source = "finalization";
+# endif
+
+  do_disappear_and_finals();
+
+# if ALLOW_TRACE_COUNT
+  traced_from_finals = collect_trace_count;
+# endif
+
+  PRINTTIME((STDERR, "gc: finish start: %ld\n", scheme_get_process_milliseconds()));
+
+  low_plausible = high_plausible = 0;
+
+  for (j = 0; j < num_common_sets; j++) {
+    collect_finish_chunk(common_sets[j]->othersptr, common_sets[j]);
+    collect_finish_common(common_sets[j]->blocks, 
+			  common_sets[j]->block_ends,
+			  common_sets[j]);
+  }
+
+  PRINTTIME((STDERR, "gc: all done: %ld\n", scheme_get_process_milliseconds()));
+
+# if PRINT
+  FPRINTF(STDERR,
+	  "done %ld (%ld), %ld from stack\n", mem_use, mem_real_use,
+	  mem_use - root_marked);
+# endif
+
+  if (mem_use)
+    mem_limit = MEM_USE_FACTOR * mem_use;
+
+  free_collect_temp(collect_stack);
+
+# if ALLOW_TRACE_COUNT
+  done_trace_stack(&collect_trace_stack);
+  done_trace_stack(&collect_wait_trace_stack);
+# endif
+# if ALLOW_TRACE_PATH
+  done_trace_stack(&collect_trace_path_stack);
+# endif
+
+#else
+  if (mem_use)
+    mem_limit = MEM_USE_FACTOR * mem_use;
+#endif
+
+#if SGC_STD_DEBUGGING
+  FPRINTF(STDERR, "done  %ld (%ld); recovered %ld\n",
+	  mem_use, sector_mem_use, orig_mem_use - mem_use);
+#endif
+
+#if STAMP_AND_REMEMBER_SOURCE
+  stamp_clock++;
+#endif
+
+#if CHECK_COLLECTING
+  collecting_now = 0;
+#endif
+
+  if (GC_collect_end_callback)
+    GC_collect_end_callback();
+
+  /* Run queued finalizers. Garbage collections may happen: */
+  PRINTTIME((STDERR, "gc: finalize start: %ld\n", scheme_get_process_milliseconds()));
+  run_finalizers();
+  PRINTTIME((STDERR, "gc: finalize end: %ld\n", scheme_get_process_milliseconds()));
+}
+
+void GC_gcollect(void)
+{
+  long dummy;
+
+  if (!sector_pagetables)
+    return;
+
+  FLUSH_REGISTER_WINDOWS;
+  if (!setjmp(buf))
+    do_GC_gcollect((void *)&dummy);
+}
+
+int GC_trace_count(int *stack, int *roots, int *uncollectable, int *final)
+{
+#if ALLOW_TRACE_COUNT
+  int j;
+
+  if (!sector_pagetables)
+    return 0;
+
+  for (j = 0; j < num_common_sets; j++) {
+    if (common_sets[j]->trace_init)
+      common_sets[j]->trace_init();
+  }
+
+  collecting_with_trace_count = 1;
+  GC_gcollect();
+  collecting_with_trace_count = 0;
+
+  if (stack)
+    *stack = traced_from_stack;
+  if (roots)
+    *roots = traced_from_roots;
+  if (uncollectable)
+    *uncollectable = traced_from_uncollectable;
+  if (final)
+    *final = traced_from_finals;
+
+  for (j = 0; j < num_common_sets; j++) {
+    if (common_sets[j]->trace_done)
+      common_sets[j]->trace_done();
+  }
+
+  return mem_traced;
+#else
+  return 0;
+#endif
+}
+
+void GC_trace_path(void)
+{
+#if ALLOW_TRACE_PATH
+  int j;
+
+  if (!sector_pagetables)
+    return;
+
+  for (j = 0; j < num_common_sets; j++) {
+    if (common_sets[j]->trace_init)
+      common_sets[j]->trace_init();
+  }
+
+  trace_path_buffer_pos = 0;
+
+  collecting_with_trace_path = 1;
+  GC_gcollect();
+  collecting_with_trace_path = 0;
+
+  for (j = 0; j < num_common_sets; j++) {
+    if (common_sets[j]->trace_done)
+      common_sets[j]->trace_done();
+  }
+#endif
+}
+
+void GC_store_path(void *v, unsigned long src, void *path_data)
+{
+#if ALLOW_TRACE_PATH
+  TraceStack *s = (TraceStack *)path_data;
+  int len, i;
+
+  if (trace_path_buffer_pos < 0)
+    return;
+
+  len = s->count / 3;
+  if (len * 2 + 3 > (TRACE_PATH_BUFFER_SIZE - trace_path_buffer_pos - 7)) {
+    trace_path_buffer[trace_path_buffer_pos++] = (void *)2;
+    trace_path_buffer[trace_path_buffer_pos++] = "truncated";
+    trace_path_buffer[trace_path_buffer_pos++] = 0;
+    trace_path_buffer[trace_path_buffer_pos++] = v;
+    trace_path_buffer[trace_path_buffer_pos++] = 0;
+    trace_path_buffer[trace_path_buffer_pos] = 0;
+    trace_path_buffer_pos = -1;
+    return;
+  }
+
+  if (len) {
+    unsigned long prev = 0;
+
+    trace_path_buffer[trace_path_buffer_pos++] = (void *)(len + 2);
+    trace_path_buffer[trace_path_buffer_pos++] = current_trace_source;
+    trace_path_buffer[trace_path_buffer_pos++] = 0;
+    for (i = 1; len--; i += 3) {
+      trace_path_buffer[trace_path_buffer_pos++] = (void *)s->stack[i];
+      trace_path_buffer[trace_path_buffer_pos++] = 0;
+
+      if (i > 1) {
+	unsigned long diff;
+	if (s->stack[i + 1])
+	  diff = ((unsigned long)s->stack[i + 1]) - prev;
+	else
+	  diff = 0;
+	trace_path_buffer[trace_path_buffer_pos - 3] = (void *)diff;
+      }
+      prev = (unsigned long)s->stack[i];
+    }
+
+    trace_path_buffer[trace_path_buffer_pos - 1] = (void *)(src - prev);
+
+    trace_path_buffer[trace_path_buffer_pos++] = v;
+    trace_path_buffer[trace_path_buffer_pos++] = 0;
+    trace_path_buffer[trace_path_buffer_pos] = 0;
+  }
+#endif
+}
+
+void **GC_get_next_path(void **prev, int *len)
+{
+  void **p;
+
+  if (!prev)
+    p = trace_path_buffer;
+  else
+    p = prev + (2 * (((long *)prev)[-1]));
+    
+  *len = *(long *)p;
+  if (!*len)
+    return NULL;
+
+  return p + 1;
+}
+
+void GC_clear_paths(void)
+{
+  int i;
+
+  for (i = 0; i < TRACE_PATH_BUFFER_SIZE; i++)
+    trace_path_buffer[i] = NULL;
+}
+
+/**********************************************************************/
+
+#if FPRINTF_USE_PRIM_STRINGOUT
+
+#if PRIM_STRINGOUT_AS_FWRITE
+void GC_prim_stringout(char *s, int len)
+{
+  fwrite(s, len, 1, stderr);
+}
+#else
+# if PRIM_STRINGOUT_AS_WINDOWS_CONSOLE
+void GC_prim_stringout(char *s, int len)
+{
+  static HANDLE console;
+  DWORD wrote;
+
+  if (!console) {
+	COORD size;
+    AllocConsole();
+    console = GetStdHandle(STD_OUTPUT_HANDLE);
+	size.X = 90;
+	size.Y = 500;
+	SetConsoleScreenBufferSize(console, size);
+  }
+
+  WriteConsole(console, s, len, &wrote, NULL);
+}
+# else
+extern void GC_prim_stringout(char *s, int len);
+# endif
+#endif
+
+#include <stdarg.h>
+#include <ctype.h>
+
+#define NP_BUFSIZE 512
+
+/* Non-allocating printf. */
+static void sgc_fprintf(int ignored, const char *c, ...)
+{
+  char buffer[NP_BUFSIZE];
+  int pos;
+  va_list args;
+
+  va_start(args, c);
+
+  pos = 0;
+  while (*c) {
+    if (*c == '%') {
+      int len = -1, slen;
+      int islong = 0;
+      char *s;
+
+      if (pos) {
+	GC_prim_stringout(buffer, pos);
+	pos = 0;
+      }
+
+      c++;
+      if (isdigit(*c)) {
+	len = 0;
+	while (isdigit(*c)) {
+	  len = (len * 10) + (*c - '0');
+	  c++;
+	}
+      }
+
+      if (*c == 'l') {
+	islong = 1;
+	c++;
+      }
+      
+      switch (*c) {
+      case 'd':
+      case 'x':
+	{
+	  long v;
+	  int d, i;
+
+	  if (islong) {
+	    v = va_arg(args, long);
+	  } else {
+	    v = va_arg(args, int);
+	  }
+	  
+	  if (!v) {
+	    s = "0";
+	    slen = 1;
+	  } else {
+	    int neg = 0;
+
+	    i = NP_BUFSIZE - 2;
+	    
+	    if (v < 0) {
+	      neg = 1;
+	      v = -v;
+	    }
+
+	    d = (((*c) == 'd') ? 10 : 16);
+	    while (v) {
+	      int digit = (v % d);
+	      if (digit < 10)
+		digit += '0';
+	      else
+		digit += 'a' - 10;
+	      buffer[i--] = digit;
+	      v = v / d;
+	    }
+	    if (neg)
+	      buffer[i--] = '-';
+
+	    s = buffer + i + 1;
+	    slen = (NP_BUFSIZE - 2) - i;
+	  }
+	}
+	break;
+      case 's':
+	s = va_arg(args, char*);
+	slen = strlen(s);
+	break;
+      default:
+	s = "???";
+	slen = 3;
+	break;
+      }
+
+      c++;
+
+      if (len != -1) {
+	if (slen > len)
+	  slen = len;
+	else {
+	  int i;
+	  for (i = slen; i < len; i++)
+	    GC_prim_stringout(" ", 1);
+	}
+      }
+      
+      if (slen)
+	GC_prim_stringout(s, slen);
+    } else {
+      if (pos == (NP_BUFSIZE - 1)) {
+	GC_prim_stringout(buffer, pos);
+	pos = 0;
+      }
+      buffer[pos++] = *(c++);
+    }
+  }
+
+  if (pos)
+    GC_prim_stringout(buffer, pos);
+
+  /* Suggest a flush: */
+  GC_prim_stringout(NULL, 0);
+
+  va_end(args);
+}
+
+#endif
+
+
diff --git a/src/mzscheme/sgc/sgc.h b/src/mzscheme/sgc/sgc.h
new file mode 100644
index 0000000..5e76c89
--- /dev/null
+++ b/src/mzscheme/sgc/sgc.h
@@ -0,0 +1,79 @@
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+#define GC_PTR void*
+
+void GC_add_roots(void *start, void *end);
+
+extern void (*GC_start_collect_callback)(void);
+extern void (*GC_end_collect_callback)(void);
+extern void (*GC_custom_finalize)(void);
+
+void GC_set_stack_base(void *base);
+void *GC_get_stack_base(void);
+
+void *GC_base(void *);
+
+void GC_dump(void);
+
+void GC_end_stubborn_change(void *);
+
+void GC_gcollect(void);
+
+void *GC_malloc(size_t size_in_bytes);
+void *GC_malloc_atomic(size_t size_in_bytes);
+void *GC_malloc_stubborn(size_t size_in_bytes);
+void *GC_malloc_uncollectable(size_t size_in_bytes);
+void *GC_malloc_atomic_uncollectable(size_t size_in_bytes);
+
+void GC_free(void *); /* ... but only if it's turned on in sgc.c. */
+
+struct GC_Set;
+void *GC_malloc_specific(size_t size, struct GC_Set *set);
+
+void GC_general_register_disappearing_link(void **p, void *a);
+
+void GC_register_finalizer(void *p, void (*f)(void *p, void *data), 
+			   void *data, void (**oldf)(void *p, void *data), 
+			   void **olddata);
+void GC_register_finalizer_ignore_self(void *p, void (*f)(void *p, void *data), 
+				       void *data, void (**oldf)(void *p, void *data), 
+				       void **olddata);
+void GC_register_eager_finalizer(void *p, void (*f)(void *p, void *data), 
+				 void *data, void (**oldf)(void *p, void *data), 
+				 void **olddata);
+
+typedef void (*GC_count_tracer)(void *v, int);
+typedef void (*GC_path_tracer)(void *v, unsigned long src, void *pdata);
+typedef void (*GC_trace_init)(void);
+typedef void (*GC_trace_done)(void);
+typedef void (*GC_set_elem_finalizer)(void *p);
+
+#define SGC_ATOMIC_SET 1
+#define SGC_UNCOLLECTABLE_SET 2
+struct GC_Set *GC_new_set(char *name, 
+			  GC_trace_init init,
+			  GC_trace_init done,
+			  GC_count_tracer count_tracer,
+			  GC_path_tracer path_tracer,
+			  GC_set_elem_finalizer final,
+			  int flags);
+
+struct GC_Set *GC_set(void *d);
+
+void GC_for_each_element(struct GC_Set *set,
+			 void (*f)(void *p, int size, void *data),
+			 void *data);
+
+int GC_trace_count(int *stack, int *roots, int *uncollectable, int *final);
+void GC_trace_path(void);
+
+void GC_store_path(void *v, unsigned long src, void *path_data);
+void **GC_get_next_path(void **prev, int *len);
+void GC_clear_paths();
+
+# ifdef __cplusplus
+};
+# endif
diff --git a/src/mzscheme/sgc/sgcdiff b/src/mzscheme/sgc/sgcdiff
new file mode 100755
index 0000000..4f4b20c
--- /dev/null
+++ b/src/mzscheme/sgc/sgcdiff
@@ -0,0 +1,233 @@
+#!/bin/sh
+string=? ; exec $PLTHOME/bin/mzscheme -agrq $0 "$@"
+
+;; This script reads a stream of sgc (dump-memory-stats)
+;; output until EOF. Then, the avg change per dump is
+;; reported for all types.
+;;
+;; Use --skip <n> flag to skip the first <n> dumps
+;;
+;; Written by Robby Findler, Rice PLT
+
+(require-library "macro.ss")
+(require-library "functio.ss")
+(require-library "pretty.ss")
+
+(define skip-count 0)
+
+(define (argument-error . args)
+  (apply fprintf (current-error-port) args)
+  (newline (current-error-port))
+  (exit -1))
+
+(let loop ([l (vector->list argv)])
+  (unless (null? l)
+	  (case (string->symbol (car l))
+	    [(--skip)
+	     (if (or (null? (cdr l))
+		     (not (string->number (cadr l))))
+		 (argument-error "expected a number after --skip")
+		 (begin
+		   (set! skip-count (string->number (cadr l)))
+		   (loop (cddr l))))]
+	    [else
+	     (argument-error "bad flag: ~a" (car l))])))
+
+(define re:begin-stats (regexp "^Begin (.*)$"))
+(define re:end-stats (regexp "^End"))
+(define re:end-dump (regexp "^End Dump"))
+(define-values (re:mz-stats re:wx-stats)
+  (let* ([number-or-hyphen "([0-9]+|-)"]
+	 [spaces "[ ]+"]
+	 [name "([^ ]+)"]
+	 [anything ".*"]
+	 [repeat
+	  (lambda (n . args)
+	    (let ([s (apply string-append args)])
+	      (let loop ([n n])
+		(if (= n 0)
+		    ""
+		    (string-append s (loop (sub1 n)))))))]
+	 [mz-stats (string-append spaces name
+				  (repeat 3 spaces number-or-hyphen)
+				  anything)]
+	 [wx-stats (string-append spaces name
+				  (repeat 4 spaces number-or-hyphen)
+				  anything)])
+    '(printf "mz-stats: ~s~nwx-stats: ~s~n" mz-stats wx-stats)
+    (values (regexp mz-stats)
+	    (regexp wx-stats))))
+
+(define (find-begin)
+  (let loop ()
+    (let ([line (read-line)])
+      (when (eof-object? line)
+	    (raise 'no-more))
+      (if (regexp-match re:end-dump line)
+	  #f
+	  (or (regexp-match re:begin-stats line)
+	      (loop))))))
+
+(define gather-stats
+  (lambda (re:stat stat-compile)
+    (let loop ()
+      (let ([line (read-line)])
+	(cond
+	  [(or (eof-object? line)
+	       (regexp-match re:end-stats line))
+	   null]
+	  [(regexp-match re:stat line) => 
+	   (lambda (l)
+	     (cons (stat-compile l)
+		   (loop)))]
+	  [else (loop)])))))
+
+(define stat-compile
+  (let ([get
+	 (lambda (s)
+	   (if (string=? s "-")
+	       'n/a
+	       (string->number s)))])
+    (lambda (l)
+      (cons (string->symbol (cadr l))
+	    (map get (cddr l))))))
+
+(define gather-all-stats
+  (lambda ()
+    (let loop ([l null])
+      (let ([m (find-begin)])
+	(if m
+	    (case (string->symbol (cadr m))
+	      [(MzScheme) 
+	       (loop (append l (gather-stats re:mz-stats stat-compile)))]
+	      [(wxWindows)
+	       (loop (append l (gather-stats re:wx-stats stat-compile)))]
+	      [else (loop l)])
+	    l)))))
+
+(define equalize-two-hash-tables
+  (lambda (before-table after-table)
+    (let ([equalize
+	   (lambda (hash-left hash-right)
+	     (hash-table-for-each 
+	      hash-left
+	      (lambda (key value)
+		(hash-table-get hash-right key
+				(lambda ()
+				  (hash-table-put! hash-right key 
+						   (map (lambda (x) 0)
+							value)))))))])
+      (equalize before-table after-table)
+      (equalize after-table before-table))))
+
+(define equalize-hash-tables
+  (lambda (tables)
+    (if (null? tables)
+	(void)
+	(let* ([table (car tables)]
+	       [go
+		(lambda ()
+		  (let loop ([l (cdr tables)])
+		    (cond
+		      [(null? l) (void)]
+		      [else (equalize-two-hash-tables table (car l))
+			    (loop (cdr l))])))])
+	  (go)
+	  (go)))))
+
+(define build-diff
+  (lambda (stats-before stats-after)
+    
+    (define before-table (make-hash-table))
+    (define after-table (make-hash-table))
+
+    (define final-table (make-hash-table))
+
+    (let ([f
+	   (lambda (table stats)
+	     (for-each (lambda (l)
+			 (let ([id (car l)]
+			       [rest (cdr l)])
+			 (hash-table-put! table id rest)))
+		       stats))])
+      (f before-table stats-before)
+      (f after-table stats-after))
+    
+    (equalize-two-hash-tables before-table after-table)
+
+    (hash-table-for-each
+       before-table
+       (lambda (key before-value)
+	 (let ([after-value (hash-table-get after-table key)])
+	   (hash-table-put! final-table key
+			    (map (lambda (x y)
+				   (if (or (eq? x 'n/a)
+					   (eq? y 'n/a))
+				       x
+				       (- y x)))
+				 before-value
+				 after-value)))))
+    final-table))
+
+(define diffs-count 0)
+
+(let loop ([n skip-count])
+  (unless (zero? n)
+	  (gather-all-stats)
+	  (loop (sub1 n))))
+
+(define diffs
+  (let loop ([stats-before (gather-all-stats)])
+    (with-handlers ([(lambda (x) (eq? x 'no-more))
+		     (lambda (x) null)])
+      (let* ([stats-after (gather-all-stats)]
+	     [new-diff (build-diff stats-before stats-after)])
+	(set! diffs-count (add1 diffs-count))
+	(cons new-diff (loop stats-after))))))
+
+(equalize-hash-tables diffs)
+
+(define avg-diffs
+  (let* ([avg-lists
+	  (lambda (ls)
+	    (apply map (lambda x
+			 (if (ormap (lambda (x) (eq? x 'n/a)) x)
+			     'n/a
+			     (round (/ (apply + x) diffs-count))))
+		   ls))]
+	 [get-avg (lambda (key value)
+		    (list key
+			  (avg-lists
+			   (map (lambda (t) (hash-table-get t key))
+				diffs))))])
+    (hash-table-map (car diffs) get-avg)))
+
+(define remove-zeros
+  (lambda (list)
+    (cond
+      [(null? list) null]
+      [else (if (andmap (lambda (x) (and (number? x)
+					 (= x 0)))
+			(second (car list)))
+		(remove-zeros (cdr list))
+		(cons (car list) (remove-zeros (cdr list))))])))
+
+(define last
+  (lambda (l)
+    (cond
+      [(null? l) (error 'last "empty list")]
+      [(null? (cdr l)) (car l)]
+      [else (last (cdr l))])))
+
+(define compare-entries
+  (lambda (x y)
+    (let ([xl (last (second x))]
+	  [yl (last (second y))])
+      (cond
+	[(eq? xl 'n/a) #f]
+	[(eq? yl 'n/a) #t]
+	[else (<= yl xl)]))))
+
+(pretty-print
+ (map (lambda (x) (apply cons x))
+      (quicksort (remove-zeros avg-diffs) compare-entries)))
diff --git a/src/mzscheme/sgc/test.c b/src/mzscheme/sgc/test.c
new file mode 100644
index 0000000..8a5225a
--- /dev/null
+++ b/src/mzscheme/sgc/test.c
@@ -0,0 +1,127 @@
+
+#include <sys/types.h>
+#include "sgc.h"
+
+void *x;
+void *y;
+
+void work()
+{
+  char *v, *w;
+
+  x = (char *)GC_malloc(20);
+  y = (char *)GC_malloc(2000);
+
+  v = (char *)GC_malloc(2);
+  GC_gcollect();
+  v[0] = 0;
+  v = (char *)GC_malloc(10);
+  GC_gcollect();
+  v[0] = 0;
+  v = (char *)GC_malloc(10000);
+  w = (char *)GC_malloc(11000);
+  GC_gcollect();
+  v[0] = 0;
+  v = (char *)GC_malloc(10);
+  GC_gcollect();
+  v[0] = 0;
+  w[0] = 0;
+}
+
+typedef struct Chained
+{
+  struct Chained *next;
+  int data[1];
+} Chained;
+
+#define MAX_C_SIZE 70
+#define CHAIN_DEPTH 100
+#define NUM_REPEATS 10
+
+#define CHAINS_AS_LOCAL 1
+
+#if !CHAINS_AS_LOCAL
+Chained *chains[MAX_C_SIZE];
+#endif
+
+work2()
+{
+  int broken = 15;
+  int i, j, k, l;
+#if CHAINS_AS_LOCAL
+  Chained *chains[MAX_C_SIZE];
+#endif
+
+#if !CHAINS_AS_LOCAL
+  GC_add_roots((void *)chains, ((char *)chains) + sizeof(chains) + 1);
+#endif
+
+  printf("chains at %lx\n", (long)chains);
+
+  for (l = NUM_REPEATS; l--; ) {
+    printf("cycle: %d\n", NUM_REPEATS - l);
+
+    for (i = 0; i < MAX_C_SIZE; i++)
+      chains[i] = 0L;
+
+    if (l & 1) {
+      /* Same size together: */
+      for (i = 0; i < MAX_C_SIZE; i++) {
+	for (k = CHAIN_DEPTH; k--; ) {
+	  Chained *c;
+	  
+	  c = (Chained *)GC_malloc(sizeof(Chained) + (i - 1) * sizeof(int));
+	  for (j = 0; j < i; j++) {
+	    c->data[j] = i;
+	  }
+	  
+	  c->next = chains[i];
+	  chains[i] = c;
+	}
+      }
+    } else {
+      /* Sizes shuffled: */
+      for (k = CHAIN_DEPTH; k--; ) {
+	for (i = 0; i < MAX_C_SIZE; i++) {
+	  Chained *c;
+	  
+	  c = (Chained *)GC_malloc(sizeof(Chained) + (i - 1) * sizeof(int));
+	  for (j = 0; j < i; j++) {
+	    c->data[j] = i;
+	  }
+	  
+	  c->next = chains[i];
+	  chains[i] = c;
+	}
+      }      
+    }
+
+    for (i = 0; i < MAX_C_SIZE; i++) {
+      Chained *c;
+      
+      c = chains[i];
+      for (k = CHAIN_DEPTH; k--; c = c->next) {
+	for (j = 0; j < i; j++)
+	  if (c->data[j] != i) {
+	    printf("broken: %d[%d][%d] = %d\n", i, (CHAIN_DEPTH - k), j, c->data[j]);
+	    if (!(broken--))
+	      return;
+	  }
+      }
+    }
+  }
+}
+
+main()
+{
+  int dummy;
+
+  GC_set_stack_base((void *)&dummy);
+
+  GC_add_roots((void *)&y, ((char *)&y) + sizeof(y) + 1);
+  GC_add_roots((void *)&x, ((char *)&x) + sizeof(x) + 1);
+
+  work();
+
+  work2();
+}
diff --git a/src/mzscheme/src/Makefile b/src/mzscheme/src/Makefile
new file mode 100644
index 0000000..b9684c6
--- /dev/null
+++ b/src/mzscheme/src/Makefile
@@ -0,0 +1,270 @@
+#
+# Makefile for mzscheme
+#
+# 'make' or 'make bin' - makes mzscheme
+# 'make lib' - make libmzscheme.a
+# 'make dynlib' - make mzdyn.o, for use in extending MzScheme
+
+CFLAGS_NODBG = $(OPT) $(WARN) $(OPTIONS) $(THREADFLAGS) -I../include
+CFLAGS = $(DEBUGFLAGS) $(CFLAGS_NODBG)
+
+OBJS =  $(OBJDIR)/salloc.o \
+	$(OBJDIR)/bignum.o \
+	$(OBJDIR)/bool.o \
+	$(OBJDIR)/char.o \
+	$(OBJDIR)/complex.o \
+	$(OBJDIR)/dynext.o \
+	$(OBJDIR)/env.o \
+	$(OBJDIR)/error.o \
+	$(OBJDIR)/eval.o \
+	$(OBJDIR)/file.o \
+	$(OBJDIR)/fun.o \
+	$(OBJDIR)/hash.o \
+	$(OBJDIR)/image.o \
+	$(OBJDIR)/list.o \
+	$(OBJDIR)/number.o \
+        $(OBJDIR)/object.o \
+	$(OBJDIR)/port.o \
+	$(OBJDIR)/print.o \
+	$(OBJDIR)/process.o \
+	$(OBJDIR)/promise.o \
+        $(OBJDIR)/rational.o \
+	$(OBJDIR)/read.o \
+	$(OBJDIR)/regexp.o \
+	$(OBJDIR)/sema.o \
+	$(OBJDIR)/setjmpup.o \
+	$(OBJDIR)/string.o \
+	$(OBJDIR)/struct.o \
+	$(OBJDIR)/symbol.o \
+	$(OBJDIR)/syntax.o \
+	$(OBJDIR)/tsymbol.o \
+	$(OBJDIR)/type.o \
+        $(OBJDIR)/unit.o \
+	$(OBJDIR)/vector.o
+
+SRCS =  salloc.c \
+	bignum.c \
+	bool.c \
+	char.c \
+	complex.c \
+	dynext.c \
+	env.c \
+	error.c \
+	eval.c \
+	file.c \
+	fun.c \
+	hash.c \
+	image.c \
+	list.c \
+	number.c \
+	object.c \
+	port.c \
+	print.c \
+	process.c \
+	promise.c \
+	rational.c \
+	read.c \
+	regexp.c \
+	sema.c \
+	setjmpup.c \
+	string.c \
+	struct.c \
+	symbol.c \
+	syntax.c \
+	tsymbol.c \
+	type.c \
+        unit.c \
+	vector.c
+
+wrong:
+	# Make from the directory above this one
+
+all: objects $(OBJDIR)
+	$(MAKE) mzheaders
+	$(MAKE) mzobjects
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+objects:
+	mkdir objects
+
+mzheaders: schemex.h schemexm.h schemex.inc schexn.h $(OBJDIR)/schsys.h ../include/mzscheme.exp
+
+mzobjects: $(OBJS)
+
+macro.inc : macro.ss sstoinc
+	sstoinc < macro.ss > macro.inc
+
+unitsig.inc : unitsig.ss sstoinc
+	sstoinc < unitsig.ss > unitsig.inc
+
+schemex.h : schemef.h makex
+	makex < schemef.h > schemex.h
+
+schemexm.h : schemef.h makex
+	makex -list < schemef.h > schemexm.h
+
+schemex.inc : schemef.h makex
+	makex -assign < schemef.h > schemex.inc
+
+../include/mzscheme.exp : schemef.h makex
+	makex -exports < schemef.h > ../include/mzscheme.exp
+
+schexn.h : exnsrc.ss makeexn
+	makeexn < exnsrc.ss > schexn.h
+
+$(OBJDIR)/schsys.h : sysname
+	echo -n "#define SCHEME_PLATFORM_LIBRARY_SUBPATH " > $(OBJDIR)/schsys.h
+	./sysname >> $(OBJDIR)/schsys.h
+
+depend:
+	makedepend -- $(CFLAGS) -- $(SRCS)
+
+clean:
+	/bin/rm -f objects/*/* *~ Makefile.bak $(OBJDIR)/schsys.h
+
+$(OBJDIR)/salloc.o: salloc.c
+	$(CC) $(CFLAGS) -c salloc.c -o $(OBJDIR)/salloc.o
+$(OBJDIR)/bignum.o: bignum.c bgnfloat.inc
+	$(CC) $(CFLAGS) -c bignum.c -o $(OBJDIR)/bignum.o
+$(OBJDIR)/bool.o: bool.c
+	$(CC) $(CFLAGS) -c bool.c -o $(OBJDIR)/bool.o
+$(OBJDIR)/char.o: char.c
+	$(CC) $(CFLAGS) -c char.c -o $(OBJDIR)/char.o
+$(OBJDIR)/complex.o: complex.c
+	$(CC) $(CFLAGS) -c complex.c -o $(OBJDIR)/complex.o
+$(OBJDIR)/dynext.o: dynext.c
+	$(CC) $(CFLAGS) -c dynext.c -o $(OBJDIR)/dynext.o
+$(OBJDIR)/env.o: env.c
+	$(CC) $(CFLAGS) -c env.c -o $(OBJDIR)/env.o
+$(OBJDIR)/error.o: error.c
+	$(CC) $(CFLAGS) -c error.c -o $(OBJDIR)/error.o
+$(OBJDIR)/eval.o: eval.c
+	$(CC) $(CFLAGS) -c eval.c -o $(OBJDIR)/eval.o
+$(OBJDIR)/file.o: file.c
+	$(CC) $(CFLAGS) -c file.c -o $(OBJDIR)/file.o
+$(OBJDIR)/fun.o: fun.c
+	$(CC) $(CFLAGS) -c fun.c -o $(OBJDIR)/fun.o
+$(OBJDIR)/hash.o: hash.c
+	$(CC) $(CFLAGS) -c hash.c -o $(OBJDIR)/hash.o
+$(OBJDIR)/image.o: image.c
+	$(CC) $(CFLAGS) -c image.c -o $(OBJDIR)/image.o
+$(OBJDIR)/list.o: list.c
+	$(CC) $(CFLAGS) -c list.c -o $(OBJDIR)/list.o
+$(OBJDIR)/number.o: number.c
+	$(CC) $(CFLAGS) -c number.c -o $(OBJDIR)/number.o
+$(OBJDIR)/object.o: object.c
+	$(CC) $(CFLAGS) -c object.c -o $(OBJDIR)/object.o
+$(OBJDIR)/port.o: port.c
+	$(CC) $(CFLAGS) -c port.c -o $(OBJDIR)/port.o
+$(OBJDIR)/print.o: print.c
+	$(CC) $(CFLAGS) -c print.c -o $(OBJDIR)/print.o
+$(OBJDIR)/process.o: process.c
+	$(CC) $(CFLAGS) -c process.c -o $(OBJDIR)/process.o
+$(OBJDIR)/promise.o: promise.c
+	$(CC) $(CFLAGS) -c promise.c -o $(OBJDIR)/promise.o
+$(OBJDIR)/rational.o: rational.c ratfloat.inc
+	$(CC) $(CFLAGS) -c rational.c -o $(OBJDIR)/rational.o
+$(OBJDIR)/read.o: read.c
+	$(CC) $(CFLAGS) -c read.c -o $(OBJDIR)/read.o
+$(OBJDIR)/regexp.o: regexp.c
+	$(CC) $(CFLAGS) -c regexp.c -o $(OBJDIR)/regexp.o
+$(OBJDIR)/sema.o: sema.c
+	$(CC) $(CFLAGS) -c sema.c -o $(OBJDIR)/sema.o
+$(OBJDIR)/setjmpup.o: setjmpup.c
+	$(CC) $(CFLAGS) -c setjmpup.c -o $(OBJDIR)/setjmpup.o
+$(OBJDIR)/string.o: string.c
+	$(CC) $(CFLAGS) -I$(OBJDIR) -c string.c -o $(OBJDIR)/string.o
+$(OBJDIR)/struct.o: struct.c
+	$(CC) $(CFLAGS) -c struct.c -o $(OBJDIR)/struct.o
+$(OBJDIR)/symbol.o: symbol.c
+	$(CC) $(CFLAGS) -c symbol.c -o $(OBJDIR)/symbol.o
+$(OBJDIR)/syntax.o: syntax.c
+	$(CC) $(CFLAGS) -c syntax.c -o $(OBJDIR)/syntax.o
+$(OBJDIR)/tsymbol.o: tsymbol.c
+	$(CC) $(CFLAGS) -c tsymbol.c -o $(OBJDIR)/tsymbol.o
+$(OBJDIR)/type.o: type.c
+	$(CC) $(CFLAGS) -c type.c -o $(OBJDIR)/type.o
+$(OBJDIR)/unit.o: unit.c
+	$(CC) $(CFLAGS) -c unit.c -o $(OBJDIR)/unit.o
+$(OBJDIR)/vector.o: vector.c
+	$(CC) $(CFLAGS) -c vector.c -o $(OBJDIR)/vector.o
+
+SCONFIG =   ../sconfig.h ../uconfig.h
+
+# Note: 'make depend' is no longer required. As distributed, the below
+#       dependencies have been trimmed to include only dependencies
+#       on MzScheme files
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+$(OBJDIR)/salloc.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+            ../gc/gc.h
+$(OBJDIR)/bignum.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+          ../src/stypes.h    
+$(OBJDIR)/bool.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+          ../src/stypes.h  
+$(OBJDIR)/char.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/complex.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h  \
+         ../src/stypes.h    
+$(OBJDIR)/dynext.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h  \
+         ../src/stypes.h ../src/schemex.h \
+         schvers.h ../gc/gc.h schemex.h
+$(OBJDIR)/env.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h  \
+        ../src/stypes.h  schminc.h macro.inc cmacro.inc
+$(OBJDIR)/error.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/eval.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h   \
+          schmach.h mzstkchk.h schrunst.h
+$(OBJDIR)/file.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/fun.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h   
+$(OBJDIR)/hash.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/image.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  schvers.h
+$(OBJDIR)/list.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/number.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h   nummacs.h 
+$(OBJDIR)/object.o: ../include/scheme.h  ../src/stypes.h \
+          schpriv.h schexn.h $(SCONFIG) \
+        ../gc/gc.h  schrunst.h
+$(OBJDIR)/unit.o: ../include/scheme.h  ../src/stypes.h  \
+         schpriv.h schexn.h $(SCONFIG) schrunst.h schminc.h \
+         unitsig.inc cunitsig.inc
+$(OBJDIR)/port.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  schfd.h
+$(OBJDIR)/print.o: ../include/scheme.h ../src/stypes.h ../src/schcpt.h \
+          schpriv.h schexn.h $(SCONFIG)
+$(OBJDIR)/process.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  schfd.h
+$(OBJDIR)/promise.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
+$(OBJDIR)/rational.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h    
+$(OBJDIR)/read.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h ../src/schcpt.h \
+        ../src/stypes.h  
+$(OBJDIR)/regexp.o:  schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/setjmpup.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h   schmach.h
+$(OBJDIR)/string.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h    schvers.h
+$(OBJDIR)/struct.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
+$(OBJDIR)/symbol.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h   
+$(OBJDIR)/syntax.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
+$(OBJDIR)/sema.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
+$(OBJDIR)/tsymbol.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
+$(OBJDIR)/type.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+        ../src/stypes.h  
+$(OBJDIR)/vector.o: schpriv.h schexn.h $(SCONFIG) ../include/scheme.h \
+         ../src/stypes.h  
diff --git a/src/mzscheme/src/bgnfloat.inc b/src/mzscheme/src/bgnfloat.inc
new file mode 100644
index 0000000..1136624
--- /dev/null
+++ b/src/mzscheme/src/bgnfloat.inc
@@ -0,0 +1,116 @@
+
+#ifdef _MSC_VER
+#pragma optimize("p", on)
+#endif
+
+FP_TYPE SCHEME_BIGNUM_TO_FLOAT_INFO(const Scheme_Object *n, int skip, int *_skipped)
+{
+  int nl, skipped;
+  bigdig *na;
+  FP_TYPE d;
+
+  nl = SCHEME_BIGLEN(n);
+  na = SCHEME_BIGDIG(n) + nl;
+
+  skipped = nl;
+
+  if (skip >= nl)
+    return 0.0;
+  else
+    nl -= skip;
+
+  d = 0;
+  while (nl--) {
+    d *= (FP_TYPE)BIG_RADIX;
+    d += *(--na);
+    if (MZ_IS_POS_INFINITY(d))
+      break;
+    --skipped;
+  }
+
+  if (_skipped)
+    *_skipped = skipped;
+  
+  if (!SCHEME_BIGPOS(n))
+    d = -d;
+
+  return d;
+}
+
+#ifdef _MSC_VER
+#pragma optimize("p", off)
+#endif
+
+FP_TYPE SCHEME_BIGNUM_TO_FLOAT(const Scheme_Object *n)
+{
+  return SCHEME_BIGNUM_TO_FLOAT_INFO(n, 0, NULL);
+}
+
+Scheme_Object *SCHEME_BIGNUM_FROM_FLOAT(FP_TYPE d)
+{
+  Small_Bignum s1, s2, onesmall;
+  int negate, log, times, i, size = 0;
+  FP_TYPE r;
+  Scheme_Object *n, *m, *one;
+  int toggle = 0;
+  bigdig *buffer;
+
+  SCHEME_CHECK_FLOAT("inexact->exact", d, "integer");
+
+  if (d < 0) {
+    negate = 1;
+    d = -d;
+  } else
+    negate = 0;
+
+  if (d < 1.0)
+    return scheme_make_integer(0);
+
+  r = 1;
+  log = 0;
+  while (r < d) {
+    log++;
+    r *= 2.0;
+  }
+
+  if (log > USE_FLOAT_BITS) {
+    times = log - USE_FLOAT_BITS;
+    log = USE_FLOAT_BITS;
+    for (i = 0; i < times; i++)
+      d /= 2;
+  } else
+    times = 0;
+
+  r = pow(2.0, (FP_TYPE)log);
+
+  n = scheme_make_small_bignum(0, &s1);
+  one = scheme_make_small_bignum(1, &onesmall);
+
+  log++;
+  while (log--) {
+    bignum_double_inplace(n, size);
+    if (d >= r) {
+      d -= r;
+      n = bignum_add(n, &buffer, &size, n, one, 0);
+    }
+    r /= 2;
+  }
+
+  if (times) {
+    m = scheme_make_bignum(1);
+    while (times--)
+      bignum_double_inplace(m, 0);      
+    n = bignum_multiply(toggle ? &s1 : &s2, n, m, 0);
+    toggle = !toggle;
+  }
+
+  if (negate)
+    bignum_negate_inplace(n);
+
+  n = scheme_bignum_normalize(n);
+  if (SCHEME_BIGNUMP(n))
+    n = bignum_copy(n, 0);
+
+  return n;
+}
+
diff --git a/src/mzscheme/src/bignum.c b/src/mzscheme/src/bignum.c
new file mode 100644
index 0000000..ee1c4f7
--- /dev/null
+++ b/src/mzscheme/src/bignum.c
@@ -0,0 +1,1367 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+
+
+  Some algorithms imitate VSCM:
+
+   (C) m.b (Matthias Blume); May 1992, HUB; Jan 1993 PU/CS
+           Humboldt-University of Berlin
+           Princeton University, Dept. of Computer Science
+*/
+
+#include "schpriv.h"
+#include <memory.h>
+#include <ctype.h>
+#include <math.h>
+
+#ifdef SIXTY_FOUR_BIT_INTEGERS
+# define BIG_MAX 0x3FFFFFFFFFFFFFFF
+# define BIG_RADIX 0x4000000000000000
+# define LOG_BIG_RADIX 62
+# define QUICK_DIV_MAX 0x7FFFFFFF
+
+/* Need to work with halves for mult & div: */
+# define BIG_LO_HALF 0x7FFFFFFF
+# define LOG_BIG_LO 31
+
+# define BIG_DIG_DEC_DIG 21
+# define SMALL_NUM_STR_LEN 20 /* conservatively low is OK */
+# define TRANS_DIG_DEC 100000000
+# define TRANS_DIG_DEC_DIG 9
+#else
+# define BIG_MAX 0x3FFFFFFF
+# define BIG_RADIX 0x40000000
+# define LOG_BIG_RADIX 30
+# define QUICK_DIV_MAX 0x7FFF
+
+/* Need to work with halves for mult & div: */
+# define BIG_LO_HALF 0x7FFF
+# define LOG_BIG_LO 15
+
+# define BIG_DIG_DEC_DIG 10
+# define SMALL_NUM_STR_LEN 10 /* conservatively low is OK */
+# define TRANS_DIG_DEC 10000
+# define TRANS_DIG_DEC_DIG 5
+#endif
+
+static Scheme_Object *bignum_none = NULL;
+static Scheme_Object *bignum_one = NULL;
+static Scheme_Object *decimal_digits[17];
+
+#ifdef MUST_REGISTER_GLOBALS
+void scheme_register_bignum()
+{
+  REGISTER_SO(bignum_none);
+  REGISTER_SO(bignum_one);
+  REGISTER_SO(decimal_digits);
+}
+#endif
+  
+Scheme_Object *scheme_make_small_bignum(long v, Small_Bignum *o)
+{
+  if (!o)
+    o = (Small_Bignum *)scheme_malloc(sizeof(Small_Bignum));
+
+  o->o.type = scheme_bignum_type;
+  SCHEME_BIGPOS(&o->o) = (v >= 0);
+  if (v < 0)
+    v = -v;
+
+  if (!v)
+    SCHEME_BIGLEN(&o->o) = 0;
+  else
+    SCHEME_BIGLEN(&o->o) = 1;
+
+  SCHEME_BIGDIG(&o->o) = o->v;
+
+  o->v[0] = v;
+
+  return (Scheme_Object *)o;
+}
+
+Scheme_Object *scheme_make_bignum(long v)
+{
+  if (v <= BIG_MAX && v >= -BIG_MAX)
+    return scheme_make_small_bignum(v, NULL);
+  else {
+    Small_Bignum *o;
+    int bad_neg;
+
+    if ((bad_neg = (v != -(-v))))
+      v++;
+
+    o = (Small_Bignum *)scheme_malloc(sizeof(Small_Bignum) + sizeof(bigdig));
+    o->o.type = scheme_bignum_type;
+
+    SCHEME_BIGDIG(&o->o) = o->v;
+
+    SCHEME_BIGPOS(&o->o) = (v >= 0);
+    if (v < 0)
+      v = -v;
+    
+    o->v[0] = (v & BIG_MAX);
+    o->v[1] = (v >> LOG_BIG_RADIX);
+
+    SCHEME_BIGLEN(&o->o) = 2;
+
+    if (bad_neg) {
+      o->v[0]++;
+      o->v[1] += (o->v[0] >> LOG_BIG_RADIX);
+      o->v[0] = (o->v[0] & BIG_MAX);
+    }
+
+    return (Scheme_Object *)o;
+  }
+}
+
+Scheme_Object *scheme_make_bignum_from_unsigned(unsigned long v)
+{
+  if (v <= BIG_MAX)
+    return scheme_make_small_bignum(v, NULL);
+  else {
+    Small_Bignum *o;
+
+    o = (Small_Bignum *)scheme_malloc(sizeof(Small_Bignum) + sizeof(bigdig));
+    o->o.type = scheme_bignum_type;
+
+    SCHEME_BIGDIG(&o->o) = o->v;
+
+    SCHEME_BIGPOS(&o->o) = 1;
+    
+    o->v[0] = (v & BIG_MAX);
+    o->v[1] = (v >> LOG_BIG_RADIX);
+
+    SCHEME_BIGLEN(&o->o) = 2;
+    
+    return (Scheme_Object *)o;
+  }
+}
+
+int scheme_bignum_get_int_val(const Scheme_Object *o, long *v)
+{
+  long n;
+  bigdig *a;
+
+  if (SCHEME_BIGLEN(o) > 2)
+    return 0;
+
+  a = SCHEME_BIGDIG(o);
+
+  if (a[1] > 0x1)
+    return 0;
+
+  n = (a[1] << LOG_BIG_RADIX) | a[0];
+  if (!SCHEME_BIGPOS(o))
+    n = -n;
+  *v = n;
+
+  return 1;
+}
+
+int scheme_bignum_get_unsigned_int_val(const Scheme_Object *o, unsigned long *v)
+{
+  bigdig *a;
+
+  if ((SCHEME_BIGLEN(o) > 2) || !SCHEME_BIGPOS(o))
+    return 0;
+
+  a = SCHEME_BIGDIG(o);
+
+  if (a[1] > 0x3)
+    return 0;
+
+  *v = (a[1] << LOG_BIG_RADIX) | a[0];
+
+  return 1;
+}
+
+Scheme_Object *scheme_bignum_normalize(const Scheme_Object *o)
+{
+  long v;
+  
+  if (!SCHEME_BIGNUMP(o))
+    return (Scheme_Object *)o;
+
+  v = SCHEME_BIGLEN(o);
+
+  if (v > 1)
+    return (Scheme_Object *)o;
+
+  if (!v)
+    return scheme_make_integer(0);
+
+  v = SCHEME_BIGDIG(o)[0];
+
+  if (!SCHEME_BIGPOS(o))
+    v = -v;
+
+  return scheme_make_integer(v);
+}
+
+int scheme_bignum_eq(const Scheme_Object *a, const Scheme_Object *b)
+{
+  int al, bl;
+  const bigdig *aa, *ba;
+
+  if (SCHEME_BIGPOS(a) != SCHEME_BIGPOS(b))
+    return 0;
+
+  al = SCHEME_BIGLEN(a);
+  bl = SCHEME_BIGLEN(b);
+  if (al != bl)
+    return 0;
+
+  aa = SCHEME_BIGDIG(a);
+  ba = SCHEME_BIGDIG(b);
+  
+  if (al < 0)
+    al = -al;
+
+  while (al--)
+    if (*(aa++) != *(ba++))
+      return 0;
+
+  return 1;
+}
+
+int scheme_bignum_lt(const Scheme_Object *a, const Scheme_Object *b)
+{
+  int ap, bp, al, bl;
+  const bigdig *aa, *ba;
+  bigdig av, bv;
+
+  ap = SCHEME_BIGPOS(a);
+  bp = SCHEME_BIGPOS(b);
+  if (ap && !bp)
+    return 0;
+  if (!ap && bp)
+    return 1;
+
+  if (!ap) {
+    const Scheme_Object *save;
+
+    save = a;
+    a = b;
+    b = save;
+  }
+
+  al = SCHEME_BIGLEN(a);
+  bl = SCHEME_BIGLEN(b);
+  if (al != bl)
+    return (al < bl);
+
+  aa = SCHEME_BIGDIG(a) + al;
+  ba = SCHEME_BIGDIG(b) + al;
+  
+  while (al--) {
+    av = *(--aa);
+    bv = *(--ba);
+    if (av != bv)
+      return (av < bv);
+  }
+
+  return 0;
+}
+
+int scheme_bignum_gt(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_bignum_lt(b, a);
+}
+
+int scheme_bignum_le(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return !scheme_bignum_gt(a, b);
+}
+
+int scheme_bignum_ge(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return !scheme_bignum_lt(a, b);
+}
+
+Scheme_Object *scheme_bignum_negate(const Scheme_Object *n)
+{
+  Scheme_Object *o;
+
+  o = (Scheme_Object *)MALLOC_ONE_TAGGED(Scheme_Bignum);
+
+  o->type = scheme_bignum_type;
+  SCHEME_BIGPOS(o) = !SCHEME_BIGPOS(n);
+  SCHEME_BIGLEN(o) = SCHEME_BIGLEN(n);
+  SCHEME_BIGDIG(o) = SCHEME_BIGDIG(n);
+ 
+  return o;
+}
+
+static void bignum_negate_inplace(Scheme_Object *n)
+{
+  SCHEME_BIGPOS(n) = !SCHEME_BIGPOS(n);
+}
+
+static Scheme_Object *bignum_copy(const Scheme_Object *n, int copy_array)
+{
+  Scheme_Object *o;
+  int c;
+
+  c = SCHEME_BIGLEN(n);
+
+  o = (Scheme_Object *)scheme_malloc(sizeof(Scheme_Bignum));
+
+  o->type = scheme_bignum_type;
+  SCHEME_BIGLEN(o) = c;
+  SCHEME_BIGPOS(o) = SCHEME_BIGPOS(n);
+  if (copy_array) {
+    SCHEME_BIGDIG(o) = (bigdig *)scheme_malloc_atomic(sizeof(bigdig) 
+						      * (c + (copy_array - 1)));
+    memcpy(SCHEME_BIGDIG(o), SCHEME_BIGDIG(n), sizeof(bigdig) * c);
+  } else
+    SCHEME_BIGDIG(o) = SCHEME_BIGDIG(n);
+
+  return o;
+}
+
+static Scheme_Object *bignum_add(Scheme_Object *o, bigdig **buffer, int *size,
+				 const Scheme_Object *a, const Scheme_Object *b, int norm)
+{
+  int ap, bp, vp;
+  int al, bl, vl, i, same;
+  long s, av, bv, carry;
+  bigdig *aa, *ba, *va;
+
+  al = SCHEME_BIGLEN(a);
+  bl = SCHEME_BIGLEN(b);
+  ap = SCHEME_BIGPOS(a);
+  bp = SCHEME_BIGPOS(b);
+
+  /* Because bignum calculations are not bounded: */
+  SCHEME_USE_FUEL(2 * al);
+
+  aa = SCHEME_BIGDIG(a);
+  ba = SCHEME_BIGDIG(b);
+  
+  same = (ap == bp);
+
+  vl = ((al > bl) ? al : bl);
+ 
+  if (!same) {
+    int reverse, sl, sp;
+    bigdig *sa;
+
+    if (al == bl) {
+      reverse = 0;
+      for (i = al; i--; )
+	if (aa[i] != ba[i]) {
+	  reverse = (aa[i] < ba[i]);
+	  break;
+	}
+    } else
+      reverse = (al < bl);
+    
+    if (reverse) {
+      sl = al;
+      al = bl;
+      bl = sl;
+      sa = aa;
+      aa = ba;
+      ba = sa;
+      sp = ap;
+      ap = bp;
+      bp = sp;
+    }
+  } else
+    vl++;
+    
+  if (buffer) {
+    if (*size < vl) {
+      *size = 2 * vl;
+      *buffer = (bigdig *)scheme_malloc_atomic(*size * sizeof(bigdig));
+    }
+    va = *buffer;
+  } else
+    va = (bigdig *)scheme_malloc_atomic(vl * sizeof(bigdig));
+  
+  carry = 0;
+  for (i = 0; i < vl; i++) {
+    av = (i >= al) ? 0 : aa[i];
+    bv = (i >= bl) ? 0 : ba[i];
+      
+    if (same)
+      s = (long)av + (long)bv + carry;
+    else
+      s = (long)av - (long)bv + carry;
+    
+    if (s < 0) {
+      carry = -1;
+      s += BIG_RADIX;
+    } else {
+      carry = (s & BIG_RADIX) ? 1 : 0;
+      s = s & BIG_MAX;
+    }
+    
+    va[i] = s;
+  }
+
+  /* Get rid of leading zeros: */
+  for (i = vl; i--; )
+    if (va[i])
+      break;
+  vl = i + 1;
+
+  vp = ap;
+  
+  if (!o) {
+    o = (Scheme_Object *)scheme_malloc(sizeof(Scheme_Bignum));
+    o->type = scheme_bignum_type;
+  }
+  SCHEME_BIGPOS(o) = vp;
+  SCHEME_BIGLEN(o) = vl;
+  SCHEME_BIGDIG(o) = va;
+
+  if (norm)
+    return scheme_bignum_normalize(o);
+  else
+    return o;
+}
+
+Scheme_Object *scheme_bignum_add(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return bignum_add(NULL, NULL, NULL, a, b, 1);
+}
+
+Scheme_Object *scheme_bignum_subtract(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_bignum_add(a, scheme_bignum_negate(b));
+}
+
+Scheme_Object *scheme_bignum_add1(const Scheme_Object *n)
+{
+  if (!bignum_one)
+    bignum_one = scheme_make_bignum(1);
+
+  return scheme_bignum_add(n, bignum_one);
+}
+
+Scheme_Object *scheme_bignum_sub1(const Scheme_Object *n)
+{
+  if (!bignum_none)
+    bignum_none = scheme_make_bignum(-1);
+
+  return scheme_bignum_add(n, bignum_none);
+}
+
+static void bignum_double_inplace(Scheme_Object *n, int bs)
+{
+  int nl, i;
+  bigdig *na, *naya, carry;
+
+  nl = SCHEME_BIGLEN(n);
+  na = SCHEME_BIGDIG(n);
+  
+  /* Because bignum calculations are not bounded: */
+  SCHEME_USE_FUEL(nl);
+
+  carry = 0;
+  for (i = 0; i < nl; i++) {
+    na[i] = (na[i] << 1) + carry;
+    carry = (na[i] & BIG_RADIX) ? 1 : 0;
+    if (carry)
+      na[i] = na[i] & BIG_MAX;
+  }
+
+  if (carry) {
+    if (bs < nl + 1) {
+      /* expand */
+      naya = (bigdig *)scheme_malloc_atomic(sizeof(bigdig) * (nl + 1));
+      for (i = 0; i < nl; i++)
+	naya[i] = na[i];
+      SCHEME_BIGDIG(n) = naya;
+    } else
+      naya = na;
+
+    naya[nl] = 1;
+
+    SCHEME_BIGLEN(n) = nl + 1;
+  }
+}
+
+static void bignum_half_inplace(Scheme_Object *n)
+{
+  int nl, i;
+  bigdig *na, carry, next;
+  
+  nl = SCHEME_BIGLEN(n);
+  na = SCHEME_BIGDIG(n);
+  
+  carry = 0;
+  for (i = nl; i--; ) {
+    next = (na[i] & 1) ? (BIG_RADIX >> 1) : 0;
+    na[i] = (na[i] >> 1) + carry;
+    carry = next;
+  }
+
+  if (nl && !na[nl - 1]) {
+    --nl;
+    SCHEME_BIGLEN(n) = nl;
+  }
+}
+
+static Scheme_Object *bignum_multiply(Small_Bignum *rsmall,
+				      const Scheme_Object *a, const Scheme_Object *b, 
+				      int norm)
+{
+  Scheme_Object *r;
+  int bl, al, i, k;
+  int size;
+  bigdig *ba, *aa, *buffer;
+  unsigned long carry;
+
+  bl = SCHEME_BIGLEN(b);
+  al = SCHEME_BIGLEN(a);
+
+  /* Because bignum calculations are not bounded: */
+  SCHEME_USE_FUEL(al * bl);
+
+  size = bl + al;
+  buffer = (bigdig *)scheme_malloc_atomic(size * sizeof(bigdig));
+
+  if (al < bl) {
+    const Scheme_Object *aux;
+    int sl;
+
+    aux = a;
+    a = b;
+    b = aux;
+    
+    sl = bl;
+    bl = al;
+    al = sl;
+  }
+
+  aa = SCHEME_BIGDIG(a);
+  ba = SCHEME_BIGDIG(b);
+
+  if ((bl == 1) && (ba[0] < BIG_LO_HALF)) {
+    /* Fast simplified version */
+    unsigned long m = ba[0];
+
+    carry = 0;
+    for (i = 0; i < al; i++) {
+      unsigned long a, loa, mida;
+
+      a = aa[i];
+      loa = a & BIG_LO_HALF;
+      mida = a >> LOG_BIG_LO;
+
+      loa *= m;
+      mida *= m;
+      
+      loa += carry + ((mida & BIG_LO_HALF) << LOG_BIG_LO);
+      carry = mida >> LOG_BIG_LO;
+
+      if (loa > BIG_MAX) {
+	carry += (loa >> LOG_BIG_RADIX);
+	loa = loa & BIG_MAX;
+      }
+      
+      buffer[i] = loa;
+    }
+    buffer[al] = carry;
+  } else {
+    memset(buffer, 0, size * sizeof(bigdig));
+
+    for (i = 0; i < bl; i++) {
+      carry = 0;
+      for (k = 0; k < al; k++) {
+	long a, b, loa, lob, hia, hib;
+	unsigned long los, his, mids;
+	
+	a = aa[k];
+	loa = a & BIG_LO_HALF;
+	hia = a >> LOG_BIG_LO;
+	b = ba[i];
+	lob = b & BIG_LO_HALF;
+	hib = b >> LOG_BIG_LO;
+	
+	los = loa * lob;
+	his = hia * hib;
+	
+	mids = loa * hib + lob * hia;
+	
+	los += ((mids & BIG_LO_HALF) << LOG_BIG_LO) + carry + buffer[i + k];
+	his += (mids >> LOG_BIG_LO);
+	
+	if (los > BIG_MAX) {
+	  his += (los >> LOG_BIG_RADIX);
+	  los = los & BIG_MAX;
+	}
+	carry = his;
+	
+	buffer[i + k] = los;
+      }
+      buffer[i + k] = carry;
+    }
+  }
+
+  while (size && !buffer[size - 1])
+    --size;
+
+  if (rsmall)
+    r = (Scheme_Object *)rsmall;
+  else
+    r = (Scheme_Object *)scheme_malloc(sizeof(Scheme_Bignum));
+  r->type = scheme_bignum_type;
+  SCHEME_BIGPOS(r) = ((SCHEME_BIGPOS(a) && SCHEME_BIGPOS(b))
+		      || (!SCHEME_BIGPOS(a) && !SCHEME_BIGPOS(b)));
+  SCHEME_BIGLEN(r) = size;
+  SCHEME_BIGDIG(r) = buffer;
+
+  if (norm)
+    r = scheme_bignum_normalize(r);
+
+  return r;
+}
+
+Scheme_Object *scheme_bignum_multiply(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return bignum_multiply(NULL, a, b, 1);
+}
+
+Scheme_Object *scheme_bignum_power(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Small_Bignum s1, s2;
+  Scheme_Object *r;
+  int bl, i, toggle = 0;
+  bigdig *ba, v;
+
+  if (!SCHEME_BIGPOS(b)) {
+    scheme_signal_error("positive bignum powers only");
+  }
+  bl = SCHEME_BIGLEN(b);
+  ba = SCHEME_BIGDIG(b);
+  ba += bl;
+
+  r = scheme_make_small_bignum(1, &s1);
+  while (bl--) {
+    v = *(--ba);
+
+    for (i = 0; i < LOG_BIG_RADIX; i++) {
+      r = bignum_multiply(toggle ? &s1 : &s2, r, r, 0);
+      toggle = !toggle;
+      v = v << 1;
+      if (v & BIG_RADIX) {
+	r = bignum_multiply(toggle ? &s1 : &s2, r, a, 0);
+	toggle = !toggle;
+      }
+    }
+  }
+
+  r = scheme_bignum_normalize(r);
+
+  if (SCHEME_BIGNUMP(r))
+    r = bignum_copy(r, 0);
+
+  return r;
+}
+
+Scheme_Object *scheme_bignum_max(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_bignum_normalize((scheme_bignum_lt(a, b)) ? b : a);
+}
+
+Scheme_Object *scheme_bignum_min(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_bignum_normalize((scheme_bignum_lt(a, b)) ? a : b);
+}
+
+static int setup_binop(const Scheme_Object *a, const Scheme_Object *b,
+		       bigdig **nr_out, bigdig **no_out, 
+		       Scheme_Object **r_out)
+{
+  int al, bl, i, aneg, bneg, extra;
+  Scheme_Object *o;
+  bigdig *no;
+  bigdig *na;
+
+  al = SCHEME_BIGLEN(a);
+  aneg = !SCHEME_BIGPOS(a);
+  bl = SCHEME_BIGLEN(b);
+  bneg = !SCHEME_BIGPOS(b);
+  
+  if (al > bl) {
+    const Scheme_Object *aux;
+    int iaux;
+
+    iaux = al;
+    al = bl;
+    bl = iaux;
+    aux = a;
+    a = b;
+    b = aux;
+    iaux = aneg;
+    aneg = bneg;
+    bneg = iaux;
+  }
+
+  o = bignum_copy(b, 2);
+
+  SCHEME_BIGPOS(o) = 1;
+  no = SCHEME_BIGDIG(o);
+  na = SCHEME_BIGDIG(a);
+
+  extra = -1;
+  for (i = 0; i < al; i++) {
+    no[i] = na[i];
+    if (aneg) {
+      no[i] = ~no[i] & BIG_MAX;
+      if (extra) {
+	if (no[i] < BIG_MAX) {
+	  no[i]++;
+	  extra = 0;
+	} else
+	  no[i] = 0;
+      }
+    }
+  }
+  for (; i < bl; i++) {
+    if (aneg)
+      no[i] = BIG_MAX;
+    else
+      no[i] = 0;
+  }
+
+  *nr_out = no;
+
+  if (bneg) {
+    b = bignum_copy(b, 1);
+
+    no = SCHEME_BIGDIG(b);
+
+    extra = -1;
+    for (i = 0; i < bl; i++) {
+      no[i] = ~no[i] & BIG_MAX;
+      if (extra) {
+	if (no[i] < BIG_MAX) {
+	  no[i]++;
+	  extra = 0;
+	} else
+	  no[i] = 0;
+      }
+    }
+
+    *no_out = no;
+  } else
+    *no_out = SCHEME_BIGDIG(b);
+
+  *r_out = o;
+
+  return bl;
+}
+
+static Scheme_Object *done_binop(Scheme_Object *r, bigdig *nr, int l)
+{
+  int i;
+
+  if (!SCHEME_BIGPOS(r)) {
+    int extra = 1;
+
+    /* 2's comp negative: get equiv positive */
+    for (i = 0; i < l; i++) {
+      nr[i] = ~nr[i] & BIG_MAX;
+      if (extra) {
+	if (nr[i] < BIG_MAX) {
+	  nr[i]++;
+	  extra = 0;
+	} else
+	  nr[i] = 0;
+      }
+    }
+    if (extra) {
+      nr[l] = 1;
+      l++;
+    }  
+  }
+
+  for (i = l; i--; ) {
+    if (!nr[i])
+      l--;
+    else
+      break;
+  }
+
+  SCHEME_BIGLEN(r) = l;
+
+  return scheme_bignum_normalize(r);
+}
+
+Scheme_Object *scheme_bignum_and(const Scheme_Object *a, const Scheme_Object *b)
+{
+  int l, i;
+  bigdig *nr, *no;
+  Scheme_Object *r;
+
+  l = setup_binop(a, b, &nr, &no, &r);
+  SCHEME_BIGPOS(r) = !(!SCHEME_BIGPOS(a) && !SCHEME_BIGPOS(b));
+  for (i = l; i--; )
+    nr[i] &= no[i];
+
+  return done_binop(r, nr, l);
+}
+
+Scheme_Object *scheme_bignum_or(const Scheme_Object *a, const Scheme_Object *b)
+{
+  int l, i;
+  bigdig *nr, *no;
+  Scheme_Object *r;
+
+  l = setup_binop(a, b, &nr, &no, &r);
+  SCHEME_BIGPOS(r) = !(!SCHEME_BIGPOS(a) || !SCHEME_BIGPOS(b));
+  for (i = 0; i < l; i++)
+    nr[i] |= no[i];
+
+  return done_binop(r, nr, l);
+}
+
+Scheme_Object *scheme_bignum_xor(const Scheme_Object *a, const Scheme_Object *b)
+{
+  int l, i;
+  bigdig *nr, *no;
+  Scheme_Object *r;
+
+  l = setup_binop(a, b, &nr, &no, &r);
+  SCHEME_BIGPOS(r) = !(!SCHEME_BIGPOS(a) ^ !SCHEME_BIGPOS(b));
+  for (i = l; i--; )
+    nr[i] ^= no[i];
+
+  return done_binop(r, nr, l);
+}
+
+Scheme_Object *scheme_bignum_not(const Scheme_Object *a)
+{
+  int i, l;
+  bigdig *na;
+
+  a = bignum_copy(a, 2);
+
+  l = SCHEME_BIGLEN(a);
+  na = SCHEME_BIGDIG(a);
+  
+  if (SCHEME_BIGPOS(a)) {
+    SCHEME_BIGPOS(a) = 0;
+    for (i = 0; i < l; i++) {
+      if (na[i] == BIG_MAX)
+	na[i] = 0;
+      else {
+	na[i]++;
+	break;
+      }
+    }
+    if (!na[l - 1]) {
+      na[l] = 1;
+      SCHEME_BIGLEN(a) = l + 1;
+    }
+  } else {
+    SCHEME_BIGPOS(a) = 1;
+    for (i = 0; i < l; i++) {
+      if (!na[i])
+	na[i] = BIG_MAX;
+      else {
+	--na[i];
+	break;
+      }
+    }
+    if (!na[l - 1])
+      SCHEME_BIGLEN(a) = l - 1;
+  }
+
+  return scheme_bignum_normalize(a);
+}
+
+Scheme_Object *scheme_bignum_shift(const Scheme_Object *n, long shift)
+{
+  int nl, rl, i, loshift, hishift, offset;
+  bigdig *ra, *na;
+  Scheme_Object *r;
+  int subone = 0;
+
+  na = SCHEME_BIGDIG(n);
+  nl = SCHEME_BIGLEN(n);
+
+  if (shift < 0) {
+    shift = -shift;
+
+    offset = (shift / LOG_BIG_RADIX);
+
+    if (offset >= nl) {
+      if (!SCHEME_BIGPOS(n))
+	return scheme_make_integer(-1);
+      else
+	return scheme_make_integer(0);
+    }
+
+    loshift = (shift % LOG_BIG_RADIX);
+    hishift = (LOG_BIG_RADIX - loshift);
+
+    rl = nl - offset;
+    ra = MALLOC_N(bigdig, rl);
+    
+    for (i = rl - 1; i--; )
+      ra[i] = (na[i + offset] >> loshift) | ((na[i + offset + 1] << hishift) & BIG_MAX);
+    ra[rl - 1] = (na[rl - 1 + offset] >> loshift);
+
+    /* If n is negative and we dropped any bits, sub one from result (2's complement!): */
+    if (!SCHEME_BIGPOS(n)) {
+      for (i = 0; i < offset; i++) {
+	if (na[i]) {
+	  subone = 1;
+	  break;
+	}
+      }
+      if ((i == offset) && ((na[offset] << hishift) & BIG_MAX))
+	subone = 1;
+    }
+  } else {
+    int top;
+
+    offset = (shift / LOG_BIG_RADIX);
+    hishift = (shift % LOG_BIG_RADIX);
+    loshift = (LOG_BIG_RADIX - hishift);
+
+    rl = nl + offset + 1;
+    ra = MALLOC_N(bigdig, rl);
+    
+    top = rl - 1;
+    for (i = 0; i < offset; i++)
+      ra[0] = 0;
+    for (i = offset + 1; i < top; i++)
+      ra[i] = ((na[i - offset] << hishift) & BIG_MAX) | (na[i - offset - 1] >> loshift);
+    ra[rl - 1] = (na[rl - offset - 2] >> loshift);
+    ra[offset] = ((na[0] << hishift) & BIG_MAX);
+  }
+
+  while (rl && !ra[rl - 1])
+    --rl;
+
+  r = (Scheme_Object *)scheme_malloc(sizeof(Scheme_Bignum));
+  r->type = scheme_bignum_type;
+  SCHEME_BIGPOS(r) = SCHEME_BIGPOS(n);
+  SCHEME_BIGLEN(r) = rl;
+  SCHEME_BIGDIG(r) = ra;
+
+  if (subone)
+    return scheme_bignum_sub1(r);
+  else
+    return scheme_bignum_normalize(r);
+}
+
+static void 
+bignum_small_divide_in_place(Scheme_Object *n, bigdig d, bigdig *rp)
+/* d > 0, d <= QUICK_DIV_MAX */
+{
+  int nl, i;
+  long carry;
+  bigdig *na;
+
+  nl = SCHEME_BIGLEN(n);
+  na = SCHEME_BIGDIG(n);
+
+  /* Because bignum calculations are not bounded: */
+  SCHEME_USE_FUEL(nl);
+
+  carry = 0;
+  for (i = nl; i--; ) {
+    long lo, hi;
+
+    lo = na[i] & BIG_LO_HALF;
+    hi = na[i] >> LOG_BIG_LO;
+
+    carry = carry << LOG_BIG_LO;
+    carry += hi;
+    hi = carry / d;
+    carry %= d;
+
+    carry = carry << LOG_BIG_LO;
+    carry += lo;
+    lo = carry / d;
+    carry %= d;
+
+    na[i] = (hi << LOG_BIG_LO) + lo;
+  }
+
+  while (nl && !na[nl - 1])
+    --nl;
+
+  SCHEME_BIGLEN(n) = nl;
+
+  *rp = carry;
+}
+
+static char *scheme_bignum_to_string_10(const Scheme_Object *b)
+{
+  Scheme_Object *r;
+  int nl, sl, p, i;
+  char *s;
+  bigdig a;
+
+  nl = SCHEME_BIGLEN(b);
+  if (!nl)
+    return "0";
+  sl = nl * BIG_DIG_DEC_DIG;
+  s = (char *)scheme_malloc_atomic(sl + 1);
+  p = 0;
+
+  r = bignum_copy(b, 1);
+  while (SCHEME_BIGLEN(r)) {
+    bignum_small_divide_in_place(r, TRANS_DIG_DEC, &a);
+    
+    for (i = 0; i < TRANS_DIG_DEC_DIG - 1; i++) {
+      s[p++] = (a % 10) + '0';
+      a /= 10;
+    }
+  }
+
+  while (s[p - 1] == '0')
+    --p;
+
+  if (!SCHEME_BIGPOS(r))
+    s[p++] = '-';
+
+  s[p] = 0;
+
+  /* reverse the string: */
+  --p;
+  for (i = 0; i < p; i++, --p) {
+    char k = s[i];
+    s[i] = s[p];
+    s[p] = k;
+  }
+
+  return s;
+}
+
+char *scheme_bignum_to_string(const Scheme_Object *b, int radix)
+{
+  char *n;
+  int size, p, i, j;
+  int bl, dig, step, needed;
+  bigdig *ba, v;
+
+  if (radix != 10 && radix != 2 && radix != 8 && radix != 16)
+    scheme_raise_exn(MZEXN_APPLICATION_MATH_RADIX, scheme_make_integer(radix),
+		     "bad bignum radix (%d)", radix);
+
+  if (!SCHEME_BIGLEN(b))
+    return "0";
+
+  if (radix == 10)
+    return scheme_bignum_to_string_10(b);
+  else if (radix == 2)
+    step = 1;
+  else if (radix == 8)
+    step = 3;
+  else if (radix == 16)
+    step = 4;
+  else  {
+    return NULL; /* Doesn't get here */
+  }
+
+  bl = SCHEME_BIGLEN(b);
+  ba = SCHEME_BIGDIG(b);
+
+  size = (bl * ((LOG_BIG_RADIX + step) / step)) + 2;
+  n = (char *)scheme_malloc_atomic(size);
+  p = 0;
+
+  needed = step;
+  dig = 0;
+
+  while (bl--) {
+    v = *(ba++);
+
+    for (j = 0; j < LOG_BIG_RADIX; j++) {
+      dig += (v & 0x1) << (step - needed);
+      v = v >> 1;
+ 
+      if (!(--needed)) {
+	if (dig > 9)
+	  n[p] = 'a' + (dig - 10);
+	else
+	  n[p] = '0' + dig;
+	p++;
+	needed = step;
+	dig = 0;
+      }
+    }
+  }
+
+  if (dig > 9)
+    n[p] = 'a' + (dig - 10);
+  else
+    n[p] = '0' + dig;
+
+  for (i = p; i && (n[i] == '0'); --i);
+  p = i + 1;
+
+  if (!SCHEME_BIGPOS(b))
+    n[p++] = '-';
+
+  /* Reverse the string: */
+  for (i = 0, j = p - 1; i < j; i++, --j) {
+    v = n[i];
+    n[i] = n[j];
+    n[j] = v;
+  }
+
+  n[p] = 0;
+
+  return n;
+}
+
+Scheme_Object *scheme_read_bignum(const char *str, int radix)
+{
+  Small_Bignum s1, s2;
+  Scheme_Object *r;
+  int size = 0, read_valid;
+  int len, i, d, negate;
+  bigdig *buffer;
+
+  if ((radix < 0) || (radix > 16))
+    return scheme_false;
+
+  if (!decimal_digits[0])
+    for (i = 0; i < 17; i++)
+      decimal_digits[i] = scheme_make_bignum(i);
+
+  negate = 0;
+  /* Why would we skip spaces? */
+  while (/* isspace(*str) || */ (*str == '+') || (*str == '-')) {
+    if (*str == '-')
+      negate = !negate;
+    str++;
+  }
+
+  len = strlen(str);
+
+  if (radix == 10 && (len < SMALL_NUM_STR_LEN)) {
+    /* try simple fixnum read first */
+    long fx;
+    if (!*str)
+      return scheme_false;
+    for (fx = 0; *str; str++) {
+      if (*str < '0' || *str > '9')
+	return scheme_false;
+      fx = (fx * 10) + (*str - '0');
+    }
+    if (negate)
+       fx = -fx;
+    return scheme_make_integer(fx);
+  }
+
+  r = scheme_make_small_bignum(0, &s2);
+
+  read_valid = 0;
+
+  while (len--) {
+    d = *(str++);
+    if (isspace(d))
+      break;
+    if (d >= '0' && d <= '9')
+      d -= '0';
+    else if (d >= 'a' && d <= 'z')
+      d -= 'a' - 10;
+    else if (d >= 'A' && d <= 'Z')
+      d -= 'A' - 10;
+    else
+      return scheme_false;
+    if (d < 0 || d >= radix)
+      return scheme_false;
+    read_valid = 1;
+    r = bignum_multiply(&s1, r, decimal_digits[radix], 0);
+    r = bignum_add((Scheme_Object *)&s2, &buffer, &size, 
+		   r, decimal_digits[d], 0);
+  }
+
+  if (!read_valid)
+    /* No digits */
+    return scheme_false;
+
+  if (negate)
+    bignum_negate_inplace(r);
+
+  r = scheme_bignum_normalize(r);
+  if (SCHEME_BIGNUMP(r))
+    r = bignum_copy(r, 0);
+
+  return r;
+}
+
+#define USE_FLOAT_BITS 51
+#define FP_TYPE double
+#define SCHEME_BIGNUM_TO_FLOAT_INFO scheme_bignum_to_double_inf_info
+#define SCHEME_BIGNUM_TO_FLOAT scheme_bignum_to_double
+#define SCHEME_CHECK_FLOAT scheme_check_double
+#define SCHEME_BIGNUM_FROM_FLOAT scheme_bignum_from_double
+#include "bgnfloat.inc"
+
+#ifdef MZ_USE_SINGLE_FLOATS
+# undef USE_FLOAT_BITS
+# undef FP_TYPE
+# undef SCHEME_BIGNUM_TO_FLOAT_INFO
+# undef SCHEME_BIGNUM_TO_FLOAT
+# undef SCHEME_CHECK_FLOAT
+# undef SCHEME_BIGNUM_FROM_FLOAT
+
+# define USE_FLOAT_BITS 22
+# define FP_TYPE float
+# define SCHEME_BIGNUM_TO_FLOAT_INFO scheme_bignum_to_float_inf_info
+# define SCHEME_BIGNUM_TO_FLOAT scheme_bignum_to_float
+# define SCHEME_CHECK_FLOAT scheme_check_float
+# define SCHEME_BIGNUM_FROM_FLOAT scheme_bignum_from_float
+# include "bgnfloat.inc"
+#endif
+
+void scheme_bignum_divide(const Scheme_Object *n, const Scheme_Object *d,
+			  Scheme_Object **qp, Scheme_Object **rp, int norm)
+{
+  Scheme_Object *m, *q, *r, *one;
+  int log, negate_q, rsize = 0, qsize = 0;
+  bigdig *rbuffer, *qbuffer;
+
+  if ((SCHEME_BIGLEN(d) == 1) && (SCHEME_BIGDIG(d)[0] <= BIG_LO_HALF)) {
+    bigdig remain, div;
+
+    div = SCHEME_BIGDIG(d)[0];
+
+    q = bignum_copy(n, 1);
+    bignum_small_divide_in_place(q, div, &remain);
+
+    if (qp) {
+      if (!SCHEME_BIGPOS(d))
+	SCHEME_BIGPOS(q) = !SCHEME_BIGPOS(q);
+    
+      if (norm)
+	q = scheme_bignum_normalize(q);
+
+      *qp = q;
+    }
+
+    if (rp) {
+      if (!SCHEME_BIGPOS(d))
+	remain = -remain;
+
+      if (norm)
+	*rp = scheme_make_integer(remain);
+      else
+	*rp = scheme_make_bignum(remain);
+    }
+
+    return;
+  }
+
+  negate_q = 0;
+  if (!SCHEME_BIGPOS(n)) {
+    n = scheme_bignum_negate(n);
+    negate_q = !negate_q;
+  }
+  if (!SCHEME_BIGPOS(d)) {
+    d = scheme_bignum_negate(d);
+    negate_q = !negate_q;
+  }
+
+  if (scheme_bignum_gt(d, n)) {
+    if (qp)
+      *qp = norm ? scheme_make_integer(0) : scheme_make_bignum(0);
+    if (rp)
+      *rp = norm ? scheme_bignum_normalize(n) : (Scheme_Object *)n;
+    return;
+  }
+
+  log = 0;
+  m = bignum_copy(d, 1);
+  while (scheme_bignum_lt(m, n)) {
+    bignum_double_inplace(m, 0);
+    log++;
+  }
+
+  one = scheme_make_bignum(1);
+
+  q = scheme_make_bignum(0);
+  r = bignum_copy(n, 1);
+  log++;
+  while (log--) {
+    bignum_double_inplace(q, qsize);
+    if (!scheme_bignum_lt(r, m)) {
+      bignum_negate_inplace(m);
+      r = bignum_add(r, &rbuffer, &rsize, r, m, 0);
+      bignum_negate_inplace(m);
+      q = bignum_add(q, &qbuffer, &qsize, q, one, 0);
+    }
+    bignum_half_inplace(m);
+  }
+
+  if (qp) {
+    if (negate_q)
+      bignum_negate_inplace(q);
+    *qp = norm ? scheme_bignum_normalize(q) : q;
+  }
+  if (rp)
+    *rp = norm ? scheme_bignum_normalize(r) : r;
+}
+
+Scheme_Object *scheme_integer_sqrt(const Scheme_Object *n)
+{
+  Scheme_Object *base, *range, *pos, *prev_half;
+  Scheme_Object *zero = scheme_make_integer(0), *one = scheme_make_integer(1);
+  Scheme_Object *two = scheme_make_integer(2);
+  double v;
+
+  if (n == zero)
+    return zero;
+
+  base = zero;
+  range = (Scheme_Object *)n;
+  pos = prev_half = scheme_bin_quotient(range, two);
+  while (1) {
+    Scheme_Object *attempt;
+
+    if (SCHEME_TRUEP(scheme_odd_p(1, &range)))
+      pos = scheme_bin_plus(pos, one);
+
+    attempt = scheme_bin_mult(pos, pos);
+    if (scheme_bin_lt(n, attempt)) {
+      /* Do nothing; range gets cut in half */
+    } else if (scheme_bin_eq(n, attempt)) {
+      return pos;
+    } else {
+      base = pos;
+    }
+    if (range == zero)
+      break;
+    range = prev_half;
+    pos = scheme_bin_plus(base, prev_half = scheme_bin_quotient(range, two));
+  } 
+
+  if (SCHEME_INTP(n))
+    v = (double)SCHEME_INT_VAL(n);
+  else
+    v = scheme_bignum_to_float(n);
+
+  return scheme_make_double(sqrt(v));
+}
diff --git a/src/mzscheme/src/bool.c b/src/mzscheme/src/bool.c
new file mode 100644
index 0000000..2c41c0a
--- /dev/null
+++ b/src/mzscheme/src/bool.c
@@ -0,0 +1,301 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include "schmach.h"
+#include <string.h>
+#ifdef USE_STACKAVAIL
+# include <malloc.c>
+#endif
+#ifdef USE_IEEE_FP_PREDS
+# include <math.h>
+#endif
+
+/* global_constants */
+Scheme_Object *scheme_true;
+Scheme_Object *scheme_false;
+Scheme_Object *scheme_not_prim;
+
+/* locals */
+static Scheme_Object *not_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *boolean_p_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *eq_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *eqv_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *equal_prim (int argc, Scheme_Object *argv[]);
+
+static int vector_equal (Scheme_Object *vec1, Scheme_Object *vec2);
+
+void scheme_init_true_false(void)
+{
+  REGISTER_SO(scheme_true);
+  REGISTER_SO(scheme_false);
+  
+  scheme_true = scheme_alloc_eternal_object();
+  scheme_true->type = scheme_true_type;
+
+  scheme_false = scheme_alloc_eternal_object();
+  scheme_false->type = scheme_false_type;
+}
+
+void scheme_init_bool (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    scheme_not_prim = scheme_make_folding_prim(not_prim, "not", 1, 1, 1);
+
+    REGISTER_SO(scheme_not_prim);
+  }
+
+  scheme_add_global_constant("not", scheme_not_prim, env);
+  scheme_add_global_constant("boolean?", 
+			     scheme_make_folding_prim(boolean_p_prim, 
+						      "boolean?",
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("eq?", 
+			     scheme_make_folding_prim(eq_prim, 
+						      "eq?",
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant("eqv?", 
+			     scheme_make_folding_prim(eqv_prim, 
+						      "eqv?",
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant("equal?", 
+			     scheme_make_prim_w_arity(equal_prim, 
+						      "equal?",
+						      2, 2),
+			     env);
+}
+
+static Scheme_Object *
+not_prim (int argc, Scheme_Object *argv[])
+{
+  return (SAME_OBJ(argv[0], scheme_false) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+boolean_p_prim (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_BOOLP(argv[0]) ? scheme_true : scheme_false);  
+}
+
+static Scheme_Object *
+eq_prim (int argc, Scheme_Object *argv[])
+{
+  return (SAME_OBJ(argv[0], argv[1]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+eqv_prim (int argc, Scheme_Object *argv[])
+{
+  return (scheme_eqv(argv[0], argv[1]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+equal_prim (int argc, Scheme_Object *argv[])
+{
+  return (scheme_equal(argv[0], argv[1]) ? scheme_true : scheme_false);
+}
+
+int scheme_eq (Scheme_Object *obj1, Scheme_Object *obj2)
+{
+  return SAME_OBJ(obj1, obj2);
+}
+
+int scheme_eqv (Scheme_Object *obj1, Scheme_Object *obj2)
+{
+  Scheme_Type t1, t2;
+
+  if (SAME_OBJ(obj1, obj2))
+    return 1;
+
+  t1 = SCHEME_TYPE(obj1);
+  t2 = SCHEME_TYPE(obj2);
+
+  if (NOT_SAME_TYPE(t1, t2)) {
+#ifdef MZ_USE_SINGLE_FLOATS
+    /* One case where different types can be eqv: float & doubles */
+    if (((t1 == scheme_float_type) || (t1 == scheme_double_type))
+	&& ((t2 == scheme_float_type) || (t2 == scheme_double_type))) {
+      double d1, d2;
+      d1 = SCHEME_FLOAT_VAL(obj1);
+      d2 = SCHEME_FLOAT_VAL(obj2);
+      if (MZ_IS_NAN(d1)) {
+	if (MZ_IS_NAN(d2))
+	  return 1;
+	else
+	  return 0;
+      }
+#ifdef NAN_EQUALS_ANYTHING
+      if (MZ_IS_NAN(d2))
+	return 0;
+#endif
+      return d1 == d2;
+    }
+#endif
+    return 0;
+  }
+
+#ifndef FAST_NUMBERS
+  else if (t1 == scheme_integer_type)
+    return SCHEME_INT_VAL(obj1) == SCHEME_INT_VAL(obj2);
+#endif
+#ifdef MZ_USE_SINGLE_FLOATS
+  else if (t1 == scheme_float_type) {
+    float d1, d2;
+    d1 = SCHEME_FLT_VAL(obj1);
+    d2 = SCHEME_FLT_VAL(obj2);
+    if (MZ_IS_NAN(d1)) {
+      if (MZ_IS_NAN(d2))
+	return 1;
+      else
+	return 0;
+    }
+#ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d2))
+      return 0;
+#endif
+    return d1 == d2;
+  }
+#endif
+  else if (t1 == scheme_double_type) {
+    double d1, d2;
+    d1 = SCHEME_DBL_VAL(obj1);
+    d2 = SCHEME_DBL_VAL(obj2);
+    if (MZ_IS_NAN(d1)) {
+      if (MZ_IS_NAN(d2))
+	return 1;
+      else
+	return 0;
+    }
+#ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d2))
+      return 0;
+#endif
+    return d1 == d2;
+  } else if (t1 == scheme_bignum_type)
+    return scheme_bignum_eq(obj1, obj2);
+  else if (t1 == scheme_rational_type)
+    return scheme_rational_eq(obj1, obj2);
+  else if (t1 == scheme_complex_type)
+    return scheme_complex_eq(obj1, obj2);
+  else
+    return 0;
+}
+
+static Scheme_Object *equal_k(void)
+{
+#ifndef ERROR_ON_OVERFLOW
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *v1 = (Scheme_Object *)p->ku.k.p1;
+  Scheme_Object *v2 = (Scheme_Object *)p->ku.k.p2;
+
+  p->ku.k.p1 = p->ku.k.p2 = NULL;
+  
+  return scheme_equal(v1, v2) ? scheme_true : scheme_false;
+#else
+  return scheme_void;
+#endif
+}
+
+int scheme_equal (Scheme_Object *obj1, Scheme_Object *obj2)
+{
+ top:
+  if (scheme_eqv (obj1, obj2))
+    return 1;
+  else if (NOT_SAME_TYPE(SCHEME_TYPE(obj1), SCHEME_TYPE(obj2)))
+    return 0;
+  else if (SCHEME_PAIRP(obj1)) {
+#define EQUAL_COUNT_START 20
+    static int equal_counter = EQUAL_COUNT_START;
+
+    if (!--equal_counter) {
+      equal_counter = EQUAL_COUNT_START;
+      SCHEME_USE_FUEL(EQUAL_COUNT_START);
+    
+#ifdef DO_STACK_CHECK
+      {
+#include "mzstkchk.h"
+	{
+#ifndef ERROR_ON_OVERFLOW
+	  Scheme_Process *p = scheme_current_process;
+	  p->ku.k.p1 = (void *)obj1;
+	  p->ku.k.p2 = (void *)obj2;
+#endif
+	  return SCHEME_TRUEP(scheme_handle_stack_overflow(equal_k));
+	}
+      }
+#endif
+    }
+
+    if (SCHEME_NULLP(obj1) && SCHEME_NULLP(obj2))
+      return 1;
+    if (scheme_equal(SCHEME_CAR(obj1), SCHEME_CAR(obj2))) {
+      obj1 = SCHEME_CDR(obj1);
+      obj2 = SCHEME_CDR(obj2);
+      goto top;
+    } else
+      return 0;
+  } else if (SCHEME_VECTORP(obj1))
+    return vector_equal(obj1, obj2);
+  else if (SCHEME_STRINGP(obj1)) {
+    int l1, l2;
+    l1 = SCHEME_STRTAG_VAL(obj1);
+    l2 = SCHEME_STRTAG_VAL(obj2);
+    return ((l1 == l2) 
+	    && !memcmp(SCHEME_STR_VAL(obj1), SCHEME_STR_VAL(obj2), l1));
+  } else  if (SCHEME_STRUCTP(obj1))
+    return scheme_equal_structs(obj1, obj2);
+  else if (SCHEME_BOXP(obj1)) {
+    SCHEME_USE_FUEL(1);
+    obj1 = SCHEME_BOX_VAL(obj1);
+    obj2 = SCHEME_BOX_VAL(obj2);
+    goto top;
+  } else
+    return 0;
+}
+
+static int vector_equal(Scheme_Object *vec1, Scheme_Object *vec2)
+{
+  int i, len;
+  Scheme_Object **vl1, **vl2;
+
+  len = SCHEME_VEC_SIZE(vec1);
+  if (len != SCHEME_VEC_SIZE(vec2))
+    return 0;
+
+  SCHEME_USE_FUEL(len);
+
+  vl1 = SCHEME_VEC_ELS(vec1);
+  vl2 = SCHEME_VEC_ELS(vec2);  
+
+  for (i = 0; i < len; i++)
+    if (!scheme_equal(vl1[i], vl2[i]))
+      return 0;
+
+  return 1;
+}
+
+
+
diff --git a/src/mzscheme/src/char.c b/src/mzscheme/src/char.c
new file mode 100644
index 0000000..3dba5b0
--- /dev/null
+++ b/src/mzscheme/src/char.c
@@ -0,0 +1,352 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <ctype.h>
+
+/* globals */
+
+/* All characters */
+Scheme_Object **scheme_char_constants;
+
+/* locals */
+static Scheme_Object *char_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_lt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_gt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_lt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_gt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_eq_ci (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_lt_ci (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_gt_ci (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_lt_eq_ci (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_gt_eq_ci (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_alphabetic (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_numeric (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_whitespace (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_upper_case (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_lower_case (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_to_integer (int argc, Scheme_Object *argv[]);
+static Scheme_Object *integer_to_char (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_upcase (int argc, Scheme_Object *argv[]);
+static Scheme_Object *char_downcase (int argc, Scheme_Object *argv[]);
+
+void scheme_init_char (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    int i;
+
+    REGISTER_SO(scheme_char_constants);
+
+    scheme_char_constants = 
+      (Scheme_Object **)scheme_malloc_eternal(256 * sizeof(Scheme_Object*));
+    
+    for (i = 0; i < 256; i++) {
+      Scheme_Object *sc = scheme_alloc_eternal_small_object ();
+      sc->type = scheme_char_type;
+      SCHEME_CHAR_VAL(sc) = i;
+      
+      scheme_char_constants[i] = sc;
+    }
+  }
+
+  scheme_add_global_constant("char?", 
+			     scheme_make_folding_prim(char_p, 
+						      "char?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char=?", 
+			     scheme_make_folding_prim(char_eq, 
+						      "char=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char<?", 
+			     scheme_make_folding_prim(char_lt, 
+						      "char<?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char>?", 
+			     scheme_make_folding_prim(char_gt, 
+						      "char>?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char<=?", 
+			     scheme_make_folding_prim(char_lt_eq, 
+						      "char<=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char>=?", 
+			     scheme_make_folding_prim(char_gt_eq, 
+						      "char>=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-ci=?", 
+			     scheme_make_folding_prim(char_eq_ci, 
+						      "char-ci=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-ci<?", 
+			     scheme_make_folding_prim(char_lt_ci, 
+						      "char-ci<?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-ci>?", 
+			     scheme_make_folding_prim(char_gt_ci, 
+						      "char-ci>?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-ci<=?", 
+			     scheme_make_folding_prim(char_lt_eq_ci, 
+						      "char-ci<=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-ci>=?", 
+			     scheme_make_folding_prim(char_gt_eq_ci, 
+						      "char-ci>=?", 
+						      1, -1, 1), 
+			     env);
+  scheme_add_global_constant("char-alphabetic?", 
+			     scheme_make_folding_prim(char_alphabetic, 
+						      "char-alphabetic?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-numeric?", 
+			     scheme_make_folding_prim(char_numeric, 
+						      "char-numeric?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-whitespace?", 
+			     scheme_make_folding_prim(char_whitespace, 
+						      "char-whitespace?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-upper-case?", 
+			     scheme_make_folding_prim(char_upper_case, 
+						      "char-upper-case?", 
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("char-lower-case?", 
+			     scheme_make_folding_prim(char_lower_case, 
+						      "char-lower-case?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char->integer", 
+			     scheme_make_folding_prim(char_to_integer, 
+						      "char->integer", 
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("integer->char",
+			     scheme_make_folding_prim(integer_to_char, 
+						      "integer->char",
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-upcase", 
+			     scheme_make_folding_prim(char_upcase, 
+						      "char-upcase", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-downcase", 
+			     scheme_make_folding_prim(char_downcase, 
+						      "char-downcase", 
+						      1, 1, 1),
+			     env);
+}
+
+Scheme_Object *scheme_make_char(char ch)
+{
+  return _scheme_make_char(ch);
+}
+
+/* locals */
+
+static Scheme_Object *
+char_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_CHARP(argv[0]) ? scheme_true : scheme_false);
+}
+
+#define CHAR_UN_CHECK(name) \
+ if (!SCHEME_CHARP(argv[0])) \
+   char_un_error(name, argc, argv)
+
+static void char_un_error(char *name, int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_CHARP(argv[0]))
+    scheme_wrong_type(name, "character", 0, argc, argv);
+}
+
+#define GEN_CHAR_COMP(func_name, scheme_name, comp, uc)          \
+ static Scheme_Object *func_name(int argc, Scheme_Object *argv[])     \
+ { int c, prev, i; Scheme_Object *rv = scheme_true; \
+   if (!SCHEME_CHARP(argv[0]))      \
+     scheme_wrong_type(#scheme_name, "character", 0, argc, argv);     \
+   prev = ((unsigned char)SCHEME_CHAR_VAL(argv[0]));     \
+   if (uc) { prev = toupper(prev); }     \
+   for (i = 1; i < argc; i++) {     \
+     if (!SCHEME_CHARP(argv[i]))      \
+       scheme_wrong_type(#scheme_name, "character", i, argc, argv);     \
+     c = ((unsigned char)SCHEME_CHAR_VAL(argv[i]));     \
+     if (uc) { c = toupper(c); }     \
+     if (!(prev comp c)) rv = scheme_false;     \
+     prev = c;     \
+   }     \
+   return rv;     \
+ }
+
+GEN_CHAR_COMP(char_eq, char=?, ==, 0)
+GEN_CHAR_COMP(char_lt, char<?, <, 0)
+GEN_CHAR_COMP(char_gt, char>?, >, 0)
+GEN_CHAR_COMP(char_lt_eq, char<=?, <=, 0)
+GEN_CHAR_COMP(char_gt_eq, char>=?, >=, 0)
+
+GEN_CHAR_COMP(char_eq_ci, char-ci=?, ==, 1)
+GEN_CHAR_COMP(char_lt_ci, char-ci<?, <, 1)
+GEN_CHAR_COMP(char_gt_ci, char-ci>?, >, 1)
+GEN_CHAR_COMP(char_lt_eq_ci, char-ci<=?, <=, 1)
+GEN_CHAR_COMP(char_gt_eq_ci, char-ci>=?, >=, 1)
+
+static Scheme_Object *
+char_alphabetic (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-alphabetic?");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return scheme_false;
+
+  return isalpha(c) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+char_numeric (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-numeric?");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return scheme_false;
+
+  return isdigit(c) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+char_whitespace (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-whitespace?");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return scheme_false;
+
+  return isspace(c) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+char_upper_case (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-upper-case?");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return scheme_false;
+
+  return isupper(c) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+char_lower_case (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-lower-case?");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return scheme_false;
+
+  return islower(c) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+char_to_integer (int argc, Scheme_Object *argv[])
+{
+  unsigned char c;
+
+  CHAR_UN_CHECK("char->integer");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+
+  return scheme_make_integer(c);
+}
+
+static Scheme_Object *
+integer_to_char (int argc, Scheme_Object *argv[])
+{
+  long v;
+
+  if (!SCHEME_INTP(argv[0]))
+    scheme_wrong_type("integer->char", "exact in [0, 255]", 0, argc, argv);
+
+  v = SCHEME_INT_VAL(argv[0]);
+  if ((v < 0) || (v > 255))
+    scheme_wrong_type("integer->char", "exact in [0, 255]", 0, argc, argv);
+
+  return _scheme_make_char(v);
+}
+
+static Scheme_Object *
+char_upcase (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-upcase");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return argv[0];
+
+  return _scheme_make_char(toupper(c));
+}
+
+static Scheme_Object *
+char_downcase (int argc, Scheme_Object *argv[])
+{
+  signed char c;
+
+  CHAR_UN_CHECK("char-downcase");
+
+  c = SCHEME_CHAR_VAL(argv[0]);
+  if (c <= 0)
+    return argv[0];
+
+  return _scheme_make_char(tolower(c));
+}
+
diff --git a/src/mzscheme/src/cmacro.inc b/src/mzscheme/src/cmacro.inc
new file mode 100644
index 0000000..64ec841
--- /dev/null
+++ b/src/mzscheme/src/cmacro.inc
@@ -0,0 +1,872 @@
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 136, 3, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 42, 35, 37, 113, 117, 97, 
+115, 105, 113, 117, 111, 116, 101, 57, 130, 20, 21, 27, 5, 205, 61, 126, 57, 130, 20, 22, 24, 
+36, 110, 111, 114, 109, 97, 108, 205, 56, 127, 232, 14, 253, 37, 1, 0, 0, 177, 178, 56, 127, 
+231, 14, 49, 176, 175, 232, 14, 51, 13, 37, 35, 37, 113, 117, 111, 116, 101, 177, 175, 232, 177, 
+59, 127, 21, 7, 60, 78, 21, 232, 177, 181, 20, 57, 130, 20, 22, 4, 20, 32, 113, 113, 208, 
+4, 3, 0, 61, 126, 57, 130, 20, 22, 4, 13, 37, 113, 113, 45, 108, 105, 115, 116, 207, 2, 
+1, 61, 126, 231, 14, 45, 179, 61, 126, 231, 14, 46, 180, 61, 126, 232, 180, 179, 183, 61, 126, 
+232, 181, 179, 184, 56, 127, 56, 127, 232, 14, 253, 37, 1, 0, 0, 178, 180, 232, 14, 253, 37, 
+1, 0, 0, 177, 179, 7, 181, 233, 14, 51, 13, 36, 35, 37, 99, 111, 110, 115, 232, 185, 181, 
+183, 232, 185, 180, 182, 56, 127, 231, 14, 43, 180, 61, 126, 231, 14, 45, 181, 56, 127, 56, 127, 
+232, 14, 253, 37, 1, 0, 0, 177, 13, 37, 117, 110, 113, 117, 111, 116, 101, 231, 14, 50, 181, 
+7, 61, 126, 231, 14, 46, 182, 55, 77, 56, 127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 
+14, 43, 178, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 49, 231, 14, 46, 179, 
+233, 14, 253, 55, 1, 0, 0, 13, 37, 117, 110, 113, 117, 111, 116, 101, 2, 28, 116, 97, 107, 
+101, 115, 32, 101, 120, 97, 99, 116, 108, 121, 32, 111, 110, 101, 32, 101, 120, 112, 114, 101, 115, 
+115, 105, 111, 110, 232, 14, 51, 13, 40, 113, 117, 97, 115, 105, 113, 117, 111, 116, 101, 185, 53, 
+76, 31, 118, 56, 127, 231, 14, 121, 183, 231, 14, 45, 176, 232, 179, 183, 231, 14, 125, 185, 56, 
+127, 56, 127, 232, 14, 253, 37, 1, 0, 0, 177, 13, 40, 113, 117, 97, 115, 105, 113, 117, 111, 
+116, 101, 231, 14, 50, 181, 7, 232, 178, 182, 231, 14, 124, 184, 56, 127, 56, 127, 232, 14, 253, 
+37, 1, 0, 0, 177, 13, 46, 117, 110, 113, 117, 111, 116, 101, 45, 115, 112, 108, 105, 99, 105, 
+110, 103, 231, 14, 50, 181, 7, 233, 14, 253, 55, 1, 0, 0, 13, 46, 117, 110, 113, 117, 111, 
+116, 101, 45, 115, 112, 108, 105, 99, 105, 110, 103, 2, 33, 105, 110, 118, 97, 108, 105, 100, 32, 
+99, 111, 110, 116, 101, 120, 116, 32, 119, 105, 116, 104, 105, 110, 32, 113, 117, 97, 115, 105, 113, 
+117, 111, 116, 101, 232, 14, 51, 13, 40, 113, 117, 97, 115, 105, 113, 117, 111, 116, 101, 184, 56, 
+127, 56, 127, 231, 14, 43, 176, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 178, 13, 
+46, 117, 110, 113, 117, 111, 116, 101, 45, 115, 112, 108, 105, 99, 105, 110, 103, 231, 14, 50, 176, 
+7, 7, 61, 126, 231, 14, 46, 177, 55, 77, 56, 127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 
+231, 14, 43, 178, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 49, 231, 14, 46, 
+179, 233, 14, 253, 55, 1, 0, 0, 13, 46, 117, 110, 113, 117, 111, 116, 101, 45, 115, 112, 108, 
+105, 99, 105, 110, 103, 2, 28, 116, 97, 107, 101, 115, 32, 101, 120, 97, 99, 116, 108, 121, 32, 
+111, 110, 101, 32, 101, 120, 112, 114, 101, 115, 115, 105, 111, 110, 232, 14, 51, 13, 40, 113, 117, 
+97, 115, 105, 113, 117, 111, 116, 101, 185, 53, 76, 31, 118, 61, 126, 231, 14, 45, 177, 61, 126, 
+231, 14, 46, 184, 61, 126, 232, 183, 231, 14, 46, 187, 187, 56, 127, 231, 14, 121, 186, 61, 126, 
+232, 185, 178, 179, 233, 14, 51, 13, 38, 35, 37, 97, 112, 112, 101, 110, 100, 181, 178, 61, 126, 
+232, 183, 181, 231, 14, 125, 189, 56, 127, 56, 127, 232, 14, 253, 37, 1, 0, 0, 178, 179, 232, 
+14, 253, 37, 1, 0, 0, 177, 181, 7, 185, 233, 14, 51, 13, 36, 35, 37, 99, 111, 110, 115, 
+233, 14, 51, 13, 36, 35, 37, 99, 111, 110, 115, 232, 14, 51, 13, 37, 35, 37, 113, 117, 111, 
+116, 101, 13, 46, 117, 110, 113, 117, 111, 116, 101, 45, 115, 112, 108, 105, 99, 105, 110, 103, 232, 
+15, 16, 183, 187, 232, 188, 181, 182, 232, 178, 182, 183, 56, 127, 231, 14, 253, 6, 1, 0, 0, 
+180, 61, 126, 231, 14, 253, 12, 1, 0, 0, 181, 61, 126, 232, 180, 178, 184, 56, 127, 232, 14, 
+253, 37, 1, 0, 0, 178, 177, 181, 232, 14, 51, 13, 44, 35, 37, 108, 105, 115, 116, 45, 62, 
+118, 101, 99, 116, 111, 114, 177, 56, 127, 231, 14, 95, 180, 61, 126, 231, 14, 96, 181, 61, 126, 
+232, 180, 178, 184, 56, 127, 232, 14, 253, 37, 1, 0, 0, 178, 177, 181, 232, 14, 51, 13, 35, 
+35, 37, 98, 111, 120, 177, 179, 178, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 911);
+    JUST_DEFINED_QQ(quasiquote);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 81, 126, 20, 53, 127, 32, 100, 109, 50, 35, 35, 37, 97, 110, 100, 53, 126, 32, 99, 
+108, 12, 80, 79, 5, 57, 130, 28, 20, 20, 5, 205, 6, 57, 130, 20, 21, 21, 5, 205, 175, 
+57, 130, 21, 22, 4, 12, 5, 205, 232, 14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 179, 
+232, 14, 44, 232, 14, 44, 13, 35, 35, 37, 97, 110, 100, 232, 14, 54, 186, 5, 13, 76, 7, 
+0};
+    EVAL_ONE_SIZED_STR((char *)expr, 84);
+    JUST_DEFINED_KEY(and);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 117, 126, 20, 53, 127, 32, 100, 109, 50, 34, 35, 37, 111, 114, 53, 126, 32, 99, 108, 
+12, 80, 79, 5, 57, 130, 28, 20, 20, 5, 205, 7, 57, 130, 20, 21, 21, 5, 205, 175, 57, 
+130, 21, 22, 4, 21, 5, 205, 61, 126, 230, 14, 39, 232, 14, 44, 13, 35, 35, 37, 108, 101, 
+116, 232, 14, 44, 232, 14, 44, 232, 14, 44, 183, 232, 14, 44, 186, 5, 5, 232, 14, 44, 232, 
+14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 185, 232, 14, 44, 187, 232, 14, 44, 232, 14, 
+44, 13, 34, 35, 37, 111, 114, 232, 14, 54, 15, 20, 5, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 120);
+    JUST_DEFINED_KEY(or);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 152, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 99, 111, 110, 
+100, 57, 130, 21, 21, 24, 5, 205, 61, 126, 57, 130, 20, 22, 29, 36, 115, 101, 114, 114, 111, 
+114, 206, 1, 234, 14, 253, 55, 1, 0, 0, 13, 34, 99, 111, 110, 100, 180, 232, 14, 44, 13, 
+34, 99, 111, 110, 100, 181, 181, 59, 127, 21, 7, 60, 78, 21, 231, 176, 178, 57, 130, 20, 21, 
+4, 26, 34, 108, 111, 111, 112, 207, 1, 0, 56, 127, 231, 14, 49, 178, 56, 127, 230, 14, 253, 
+52, 1, 0, 0, 13, 76, 36, 35, 37, 118, 111, 105, 100, 13, 76, 36, 35, 37, 99, 111, 110, 
+100, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 179, 232, 178, 2, 46, 98, 97, 100, 
+32, 115, 121, 110, 116, 97, 120, 32, 40, 98, 111, 100, 121, 32, 109, 117, 115, 116, 32, 99, 111, 
+110, 116, 97, 105, 110, 32, 97, 32, 108, 105, 115, 116, 32, 111, 102, 32, 112, 97, 105, 114, 115, 
+41, 179, 61, 126, 231, 14, 45, 179, 61, 126, 231, 14, 46, 180, 56, 127, 231, 14, 253, 35, 1, 
+0, 0, 231, 14, 43, 178, 232, 180, 2, 44, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 
+40, 99, 108, 97, 117, 115, 101, 32, 105, 115, 32, 110, 111, 116, 32, 97, 32, 116, 101, 115, 116, 
+45, 118, 97, 108, 117, 101, 32, 112, 97, 105, 114, 41, 178, 61, 126, 231, 14, 45, 178, 61, 126, 
+231, 14, 46, 179, 61, 126, 56, 127, 232, 14, 253, 37, 1, 0, 0, 179, 13, 34, 101, 108, 115, 
+101, 231, 14, 253, 35, 1, 0, 0, 231, 14, 253, 84, 3, 0, 0, 13, 34, 101, 108, 115, 101, 
+7, 55, 77, 56, 127, 56, 127, 175, 231, 14, 43, 179, 7, 232, 183, 2, 39, 98, 97, 100, 32, 
+115, 121, 110, 116, 97, 120, 32, 40, 96, 101, 108, 115, 101, 39, 32, 99, 108, 97, 117, 115, 101, 
+32, 109, 117, 115, 116, 32, 98, 101, 32, 108, 97, 115, 116, 41, 181, 53, 76, 31, 118, 56, 127, 
+56, 127, 231, 14, 43, 177, 56, 127, 232, 14, 253, 37, 1, 0, 0, 13, 32, 61, 62, 231, 14, 
+45, 179, 231, 14, 253, 35, 1, 0, 0, 231, 14, 253, 84, 3, 0, 0, 13, 32, 61, 62, 7, 
+7, 56, 127, 56, 127, 231, 14, 43, 231, 14, 46, 178, 231, 14, 49, 231, 14, 69, 178, 7, 61, 
+126, 56, 127, 176, 6, 178, 61, 126, 230, 14, 39, 232, 14, 44, 13, 35, 35, 37, 108, 101, 116, 
+232, 14, 44, 232, 14, 44, 232, 14, 44, 183, 232, 14, 44, 186, 5, 5, 232, 14, 44, 232, 14, 
+44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 185, 232, 14, 44, 232, 14, 44, 231, 14, 67, 15, 
+18, 232, 14, 44, 15, 16, 5, 232, 14, 44, 231, 15, 22, 15, 20, 5, 5, 232, 183, 2, 36, 
+98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 98, 97, 100, 32, 99, 108, 97, 117, 115, 
+101, 32, 102, 111, 114, 109, 32, 119, 105, 116, 104, 32, 61, 62, 41, 181, 56, 127, 175, 232, 14, 
+44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 178, 56, 127, 231, 14, 49, 177, 61, 126, 230, 14, 
+39, 232, 14, 44, 13, 35, 35, 37, 108, 101, 116, 232, 14, 44, 232, 14, 44, 232, 14, 44, 183, 
+232, 14, 44, 188, 5, 5, 232, 14, 44, 232, 14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 
+185, 232, 14, 44, 187, 232, 14, 44, 231, 15, 21, 15, 19, 5, 5, 234, 14, 51, 13, 34, 35, 
+37, 105, 102, 181, 232, 14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 182, 231, 185, 183, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 671);
+    JUST_DEFINED_COND(cond);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 123, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 99, 97, 115, 
+101, 57, 130, 21, 22, 4, 16, 5, 205, 61, 126, 57, 130, 20, 22, 4, 11, 36, 115, 101, 114, 
+114, 111, 114, 207, 2, 1, 234, 14, 253, 55, 1, 0, 0, 13, 34, 99, 97, 115, 101, 181, 233, 
+14, 52, 13, 34, 99, 97, 115, 101, 182, 183, 182, 61, 126, 230, 14, 39, 232, 14, 44, 13, 35, 
+35, 37, 108, 101, 116, 232, 14, 44, 232, 14, 44, 232, 14, 44, 183, 232, 14, 44, 187, 5, 5, 
+232, 14, 44, 232, 14, 44, 13, 36, 35, 37, 99, 111, 110, 100, 232, 14, 54, 59, 127, 21, 7, 
+60, 78, 21, 231, 176, 15, 15, 57, 130, 20, 21, 4, 18, 34, 108, 111, 111, 112, 208, 12, 11, 
+0, 56, 127, 231, 14, 49, 179, 5, 56, 127, 231, 14, 43, 179, 61, 126, 231, 14, 45, 180, 61, 
+126, 231, 14, 46, 181, 232, 14, 44, 56, 127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 14, 
+43, 181, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 231, 14, 46, 182, 232, 
+183, 2, 44, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 99, 108, 97, 117, 115, 101, 
+32, 105, 115, 32, 110, 111, 116, 32, 97, 32, 116, 101, 115, 116, 45, 118, 97, 108, 117, 101, 32, 
+112, 97, 105, 114, 41, 180, 61, 126, 231, 14, 45, 180, 61, 126, 231, 14, 46, 181, 55, 77, 56, 
+127, 56, 127, 231, 14, 43, 176, 231, 14, 50, 176, 7, 6, 232, 185, 2, 33, 98, 97, 100, 32, 
+115, 121, 110, 116, 97, 120, 32, 40, 105, 109, 112, 114, 111, 112, 101, 114, 32, 99, 108, 97, 117, 
+115, 101, 32, 98, 111, 100, 121, 41, 177, 232, 14, 44, 56, 127, 56, 127, 232, 14, 253, 37, 1, 
+0, 0, 180, 13, 34, 101, 108, 115, 101, 231, 14, 253, 35, 1, 0, 0, 231, 14, 253, 84, 3, 
+0, 0, 13, 34, 101, 108, 115, 101, 7, 56, 127, 231, 14, 49, 182, 13, 34, 101, 108, 115, 101, 
+232, 187, 2, 39, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 96, 101, 108, 115, 101, 
+39, 32, 99, 108, 97, 117, 115, 101, 32, 109, 117, 115, 116, 32, 98, 101, 32, 108, 97, 115, 116, 
+41, 184, 55, 77, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 50, 180, 232, 187, 2, 32, 
+98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 105, 109, 112, 114, 111, 112, 101, 114, 32, 
+100, 97, 116, 117, 109, 32, 108, 105, 115, 116, 41, 180, 53, 76, 31, 118, 232, 14, 44, 13, 34, 
+35, 37, 111, 114, 59, 127, 21, 7, 60, 78, 21, 231, 176, 182, 57, 130, 20, 21, 4, 12, 34, 
+108, 111, 111, 112, 207, 12, 0, 56, 127, 231, 14, 49, 178, 5, 61, 126, 232, 14, 51, 13, 37, 
+35, 37, 113, 117, 111, 116, 101, 231, 14, 45, 181, 232, 14, 44, 232, 14, 44, 13, 36, 35, 37, 
+101, 113, 118, 63, 232, 14, 44, 183, 232, 14, 44, 183, 5, 231, 179, 231, 14, 46, 182, 232, 14, 
+44, 232, 14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 232, 14, 54, 183, 5, 5, 231, 180, 
+178, 232, 179, 2, 46, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 98, 111, 100, 121, 
+32, 109, 117, 115, 116, 32, 99, 111, 110, 116, 97, 105, 110, 32, 97, 32, 108, 105, 115, 116, 32, 
+111, 102, 32, 112, 97, 105, 114, 115, 41, 180, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 642);
+    JUST_DEFINED_KEY(case);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 84, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 34, 35, 37, 100, 111, 57, 
+130, 21, 23, 4, 36, 5, 205, 61, 126, 234, 14, 52, 13, 32, 100, 111, 180, 181, 182, 55, 80, 
+56, 127, 231, 14, 50, 177, 230, 14, 13, 233, 14, 253, 55, 1, 0, 0, 13, 32, 100, 111, 2, 
+33, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 98, 97, 100, 32, 98, 105, 110, 100, 
+105, 110, 103, 32, 115, 101, 113, 117, 101, 110, 99, 101, 41, 178, 232, 14, 3, 57, 130, 20, 21, 
+26, 5, 206, 2, 56, 127, 56, 127, 231, 14, 50, 177, 61, 126, 231, 14, 53, 178, 61, 126, 232, 
+14, 116, 178, 22, 56, 127, 175, 175, 232, 14, 116, 178, 23, 7, 230, 14, 13, 233, 14, 253, 55, 
+1, 0, 0, 13, 32, 100, 111, 2, 24, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 
+98, 97, 100, 32, 98, 105, 110, 100, 105, 110, 103, 41, 178, 178, 56, 127, 231, 14, 50, 178, 230, 
+14, 13, 233, 14, 253, 55, 1, 0, 0, 13, 32, 100, 111, 2, 32, 98, 97, 100, 32, 115, 121, 
+110, 116, 97, 120, 32, 40, 98, 97, 100, 32, 116, 101, 115, 116, 32, 97, 110, 100, 32, 114, 101, 
+115, 117, 108, 116, 41, 178, 56, 127, 231, 14, 50, 179, 230, 14, 13, 233, 14, 253, 55, 1, 0, 
+0, 13, 32, 100, 111, 2, 26, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 105, 109, 
+112, 114, 111, 112, 101, 114, 32, 98, 111, 100, 121, 41, 178, 61, 126, 232, 14, 3, 57, 130, 20, 
+21, 26, 5, 206, 3, 61, 126, 231, 14, 45, 178, 56, 127, 231, 14, 35, 176, 175, 233, 14, 253, 
+55, 1, 0, 0, 13, 32, 100, 111, 2, 43, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 
+40, 118, 97, 114, 105, 97, 98, 108, 101, 32, 109, 117, 115, 116, 32, 98, 101, 32, 97, 110, 32, 
+105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 41, 179, 179, 61, 126, 232, 14, 3, 14, 67, 180, 
+61, 126, 232, 14, 3, 57, 130, 20, 21, 23, 5, 205, 56, 127, 231, 14, 43, 231, 14, 69, 177, 
+231, 14, 76, 176, 231, 14, 45, 176, 181, 61, 126, 56, 127, 231, 14, 43, 182, 231, 14, 45, 182, 
+233, 14, 253, 55, 1, 0, 0, 13, 32, 100, 111, 2, 29, 98, 97, 100, 32, 115, 121, 110, 116, 
+97, 120, 32, 40, 116, 101, 115, 116, 47, 114, 101, 115, 117, 108, 116, 32, 112, 97, 114, 116, 41, 
+182, 61, 126, 56, 127, 231, 14, 49, 231, 14, 46, 184, 231, 14, 51, 13, 76, 36, 35, 37, 118, 
+111, 105, 100, 231, 14, 46, 183, 61, 126, 230, 14, 39, 232, 14, 44, 13, 35, 35, 37, 108, 101, 
+116, 232, 14, 44, 179, 232, 14, 44, 233, 14, 3, 57, 130, 20, 22, 24, 5, 205, 232, 14, 51, 
+177, 178, 189, 188, 232, 14, 44, 232, 14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 189, 232, 
+14, 44, 232, 14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 232, 14, 54, 15, 19, 5, 232, 
+14, 44, 232, 14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 232, 14, 54, 15, 29, 232, 14, 
+44, 232, 14, 44, 15, 24, 232, 14, 54, 15, 29, 5, 5, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 603);
+    JUST_DEFINED_KEY(do);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 215, 1, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 38, 35, 37, 100, 101, 102, 
+105, 110, 101, 57, 130, 21, 21, 4, 16, 5, 205, 61, 126, 232, 14, 44, 13, 36, 100, 101, 102, 
+105, 110, 101, 178, 55, 77, 56, 127, 231, 14, 49, 177, 233, 14, 253, 55, 1, 0, 0, 13, 36, 
+100, 101, 102, 105, 110, 101, 2, 31, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 110, 
+111, 32, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 32, 98, 111, 100, 121, 41, 178, 53, 76, 
+31, 118, 61, 126, 231, 14, 45, 178, 56, 127, 231, 14, 35, 176, 56, 127, 56, 127, 231, 14, 43, 
+231, 14, 46, 179, 231, 14, 49, 231, 14, 69, 179, 7, 232, 14, 44, 13, 45, 35, 37, 100, 101, 
+102, 105, 110, 101, 45, 118, 97, 108, 117, 101, 115, 232, 14, 44, 232, 14, 44, 181, 5, 232, 14, 
+54, 231, 14, 46, 184, 5, 233, 14, 253, 55, 1, 0, 0, 13, 36, 100, 101, 102, 105, 110, 101, 
+2, 58, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 122, 101, 114, 111, 32, 111, 114, 
+32, 109, 117, 108, 116, 105, 112, 108, 101, 32, 101, 120, 112, 114, 101, 115, 115, 105, 111, 110, 115, 
+32, 97, 102, 116, 101, 114, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 41, 179, 56, 127, 
+231, 14, 43, 176, 55, 77, 61, 126, 57, 130, 20, 21, 26, 40, 98, 97, 100, 45, 115, 121, 109, 
+98, 111, 108, 206, 2, 234, 14, 253, 55, 1, 0, 0, 13, 36, 100, 101, 102, 105, 110, 101, 2, 
+14, 98, 97, 100, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 179, 180, 59, 127, 21, 7, 
+60, 78, 21, 231, 176, 178, 57, 130, 20, 21, 25, 34, 108, 111, 111, 112, 207, 1, 0, 56, 127, 
+231, 14, 49, 178, 7, 56, 127, 231, 14, 43, 178, 56, 127, 231, 14, 35, 231, 14, 45, 179, 231, 
+176, 231, 14, 46, 179, 231, 177, 231, 14, 45, 179, 56, 127, 231, 14, 35, 178, 7, 231, 177, 178, 
+232, 14, 44, 13, 45, 35, 37, 100, 101, 102, 105, 110, 101, 45, 118, 97, 108, 117, 101, 115, 232, 
+14, 44, 232, 14, 44, 231, 14, 45, 182, 5, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 
+97, 109, 98, 100, 97, 232, 14, 44, 231, 14, 46, 186, 232, 14, 54, 231, 14, 46, 15, 15, 5, 
+5, 234, 14, 253, 55, 1, 0, 0, 13, 36, 100, 101, 102, 105, 110, 101, 2, 17, 110, 111, 116, 
+32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 180, 179, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 478);
+    JUST_DEFINED_KEY(define);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 96, 1, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 43, 35, 37, 115, 101, 116, 
+33, 45, 118, 97, 108, 117, 101, 115, 57, 130, 20, 22, 4, 13, 5, 205, 55, 77, 56, 127, 61, 
+126, 231, 14, 50, 177, 56, 127, 175, 175, 234, 14, 253, 55, 1, 0, 0, 13, 41, 115, 101, 116, 
+33, 45, 118, 97, 108, 117, 101, 115, 2, 31, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 
+40, 105, 108, 108, 101, 103, 97, 108, 32, 117, 115, 101, 32, 111, 102, 32, 96, 46, 39, 41, 233, 
+14, 51, 13, 41, 115, 101, 116, 33, 45, 118, 97, 108, 117, 101, 115, 183, 184, 180, 232, 14, 5, 
+57, 130, 20, 21, 4, 11, 5, 207, 3, 2, 61, 126, 231, 14, 35, 179, 56, 127, 175, 175, 234, 
+14, 253, 55, 1, 0, 0, 13, 41, 115, 101, 116, 33, 45, 118, 97, 108, 117, 101, 115, 2, 30, 
+98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 110, 111, 116, 32, 97, 110, 32, 105, 100, 
+101, 110, 116, 105, 102, 105, 101, 114, 41, 233, 14, 51, 13, 41, 115, 101, 116, 33, 45, 118, 97, 
+108, 117, 101, 115, 183, 184, 182, 177, 7, 56, 127, 56, 127, 231, 14, 43, 176, 231, 14, 49, 231, 
+14, 46, 177, 7, 232, 14, 44, 13, 36, 35, 37, 115, 101, 116, 33, 232, 14, 44, 231, 14, 45, 
+180, 232, 14, 44, 182, 5, 61, 126, 232, 14, 3, 57, 130, 20, 21, 21, 5, 205, 230, 14, 39, 
+178, 232, 14, 44, 13, 42, 35, 37, 108, 101, 116, 45, 118, 97, 108, 117, 101, 115, 232, 14, 44, 
+232, 14, 44, 232, 14, 44, 183, 232, 14, 44, 187, 5, 5, 232, 14, 54, 56, 127, 231, 14, 49, 
+183, 13, 76, 76, 36, 35, 37, 118, 111, 105, 100, 233, 14, 3, 57, 130, 20, 22, 28, 5, 205, 
+232, 14, 44, 13, 36, 35, 37, 115, 101, 116, 33, 232, 14, 44, 179, 232, 14, 44, 182, 5, 185, 
+184, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 359);
+    JUST_DEFINED_KEY(set!-values);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 69, 126, 20, 53, 127, 32, 100, 109, 50, 37, 35, 37, 100, 101, 108, 97, 121, 57, 130, 
+20, 21, 4, 11, 5, 205, 232, 14, 44, 13, 44, 35, 37, 109, 97, 107, 101, 45, 112, 114, 111, 
+109, 105, 115, 101, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 
+14, 44, 5, 232, 14, 44, 185, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 72);
+    JUST_DEFINED_KEY(delay);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 73, 126, 20, 53, 127, 32, 100, 109, 50, 38, 35, 37, 108, 101, 116, 47, 99, 99, 57, 
+130, 21, 23, 4, 15, 5, 205, 232, 14, 44, 13, 39, 35, 37, 99, 97, 108, 108, 47, 99, 99, 
+232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 232, 14, 
+44, 185, 5, 232, 14, 44, 186, 232, 14, 54, 189, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 76);
+    JUST_DEFINED_KEY(let/cc);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 73, 126, 20, 53, 127, 32, 100, 109, 50, 38, 35, 37, 108, 101, 116, 47, 101, 99, 57, 
+130, 21, 23, 4, 15, 5, 205, 232, 14, 44, 13, 39, 35, 37, 99, 97, 108, 108, 47, 101, 99, 
+232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 232, 14, 
+44, 185, 5, 232, 14, 44, 186, 232, 14, 54, 189, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 76);
+    JUST_DEFINED_KEY(let/ec);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 61, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 119, 104, 101, 110, 57, 130, 21, 
+23, 4, 15, 5, 205, 232, 14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 179, 232, 14, 44, 
+232, 14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 232, 14, 44, 186, 232, 14, 54, 189, 5, 
+5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 64);
+    JUST_DEFINED_KEY(when);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 76, 126, 20, 53, 127, 32, 100, 109, 50, 38, 35, 37, 117, 110, 108, 101, 115, 115, 57, 
+130, 21, 23, 4, 17, 5, 205, 232, 14, 44, 13, 34, 35, 37, 105, 102, 232, 14, 44, 179, 232, 
+14, 44, 13, 76, 36, 35, 37, 118, 111, 105, 100, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 
+98, 101, 103, 105, 110, 232, 14, 44, 188, 232, 14, 54, 15, 16, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 79);
+    JUST_DEFINED_KEY(unless);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 92, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 45, 35, 37, 100, 101, 102, 
+105, 110, 101, 45, 115, 116, 114, 117, 99, 116, 57, 130, 21, 21, 4, 15, 5, 205, 61, 126, 57, 
+130, 21, 22, 4, 10, 42, 115, 121, 110, 116, 97, 120, 45, 101, 114, 114, 111, 114, 206, 1, 235, 
+14, 2, 14, 253, 55, 1, 0, 0, 13, 43, 100, 101, 102, 105, 110, 101, 45, 115, 116, 114, 117, 
+99, 116, 181, 232, 14, 44, 13, 43, 100, 101, 102, 105, 110, 101, 45, 115, 116, 114, 117, 99, 116, 
+182, 182, 61, 126, 57, 130, 20, 22, 4, 14, 48, 98, 117, 105, 108, 100, 45, 115, 116, 114, 117, 
+99, 116, 45, 110, 97, 109, 101, 115, 205, 61, 126, 231, 14, 38, 177, 61, 126, 232, 14, 3, 14, 
+38, 180, 61, 126, 14, 248, 232, 14, 3, 14, 36, 232, 14, 54, 233, 14, 51, 232, 184, 2, 7, 
+115, 116, 114, 117, 99, 116, 58, 186, 232, 184, 2, 5, 109, 97, 107, 101, 45, 186, 232, 184, 186, 
+2, 1, 63, 232, 14, 2, 14, 54, 232, 14, 3, 57, 130, 20, 21, 4, 10, 5, 207, 8, 10, 
+232, 14, 51, 233, 181, 180, 2, 1, 45, 182, 235, 183, 2, 4, 115, 101, 116, 45, 182, 2, 1, 
+45, 184, 2, 1, 33, 184, 55, 81, 61, 126, 231, 14, 43, 179, 56, 127, 175, 175, 231, 178, 2, 
+17, 101, 109, 112, 116, 121, 32, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110, 61, 126, 232, 
+14, 116, 22, 231, 14, 53, 181, 56, 127, 175, 175, 231, 178, 2, 21, 119, 114, 111, 110, 103, 32, 
+110, 117, 109, 98, 101, 114, 32, 111, 102, 32, 112, 97, 114, 116, 115, 61, 126, 231, 14, 35, 231, 
+14, 45, 180, 56, 127, 175, 175, 61, 126, 56, 127, 231, 14, 43, 231, 14, 45, 181, 56, 127, 231, 
+14, 35, 231, 14, 66, 181, 56, 127, 231, 14, 43, 231, 14, 68, 181, 231, 14, 49, 231, 14, 75, 
+181, 7, 7, 7, 56, 127, 175, 175, 231, 179, 2, 62, 102, 105, 114, 115, 116, 32, 112, 97, 114, 
+116, 32, 109, 117, 115, 116, 32, 98, 101, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 
+101, 114, 32, 111, 114, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 45, 101, 120, 112, 114, 
+101, 115, 115, 105, 111, 110, 32, 112, 97, 105, 114, 61, 126, 231, 14, 50, 231, 14, 67, 180, 56, 
+127, 175, 175, 231, 178, 2, 32, 105, 108, 108, 101, 103, 97, 108, 32, 117, 115, 101, 32, 111, 102, 
+32, 96, 46, 39, 32, 105, 110, 32, 102, 105, 101, 108, 100, 32, 108, 105, 115, 116, 232, 14, 4, 
+57, 130, 20, 21, 25, 5, 206, 3, 61, 126, 231, 14, 35, 178, 56, 127, 175, 175, 232, 178, 2, 
+27, 102, 105, 101, 108, 100, 32, 110, 97, 109, 101, 32, 110, 111, 116, 32, 97, 32, 105, 100, 101, 
+110, 116, 105, 102, 105, 101, 114, 179, 231, 14, 67, 180, 61, 126, 56, 127, 231, 14, 35, 231, 14, 
+45, 180, 231, 14, 45, 179, 231, 14, 66, 179, 61, 126, 231, 14, 67, 180, 232, 14, 44, 13, 45, 
+35, 37, 100, 101, 102, 105, 110, 101, 45, 118, 97, 108, 117, 101, 115, 232, 14, 44, 232, 183, 182, 
+181, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 115, 116, 114, 117, 99, 116, 232, 14, 54, 189, 
+5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 611);
+    JUST_DEFINED_KEY(define-struct);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 80, 126, 20, 53, 127, 32, 100, 109, 50, 42, 35, 37, 108, 101, 116, 45, 115, 116, 114, 
+117, 99, 116, 57, 130, 21, 23, 4, 15, 5, 205, 232, 14, 44, 13, 35, 35, 37, 108, 101, 116, 
+232, 14, 44, 5, 232, 14, 44, 232, 14, 44, 13, 45, 35, 37, 100, 101, 102, 105, 110, 101, 45, 
+115, 116, 114, 117, 99, 116, 232, 14, 44, 185, 232, 14, 44, 188, 5, 232, 14, 54, 185, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 83);
+    JUST_DEFINED_KEY(let-struct);
+  }
+#ifndef NO_OBJECT_SYSTEM
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 81, 126, 20, 53, 127, 32, 100, 109, 50, 37, 35, 37, 99, 108, 97, 115, 115, 57, 130, 
+21, 23, 4, 15, 5, 205, 232, 14, 44, 13, 44, 35, 37, 99, 108, 97, 115, 115, 42, 47, 110, 
+97, 109, 101, 115, 232, 14, 44, 13, 77, 34, 116, 104, 105, 115, 40, 115, 117, 112, 101, 114, 45, 
+105, 110, 105, 116, 232, 14, 44, 181, 232, 14, 44, 5, 232, 14, 44, 186, 232, 14, 54, 189, 5, 
+0};
+    EVAL_ONE_SIZED_STR((char *)expr, 84);
+    JUST_DEFINED_KEY(class);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 83, 126, 20, 53, 127, 32, 100, 109, 50, 38, 35, 37, 99, 108, 97, 115, 115, 42, 57, 
+130, 21, 24, 4, 16, 5, 205, 232, 14, 44, 13, 44, 35, 37, 99, 108, 97, 115, 115, 42, 47, 
+110, 97, 109, 101, 115, 232, 14, 44, 13, 77, 34, 116, 104, 105, 115, 40, 115, 117, 112, 101, 114, 
+45, 105, 110, 105, 116, 232, 14, 44, 181, 232, 14, 44, 184, 232, 14, 44, 187, 232, 14, 54, 15, 
+15, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 86);
+    JUST_DEFINED_KEY(class*);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 51, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 115, 101, 110, 100, 57, 130, 21, 
+23, 4, 11, 5, 205, 232, 14, 44, 232, 14, 44, 13, 36, 35, 37, 105, 118, 97, 114, 232, 14, 
+44, 181, 232, 14, 44, 184, 5, 232, 14, 54, 181, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 54);
+    JUST_DEFINED_KEY(send);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 76, 126, 20, 53, 127, 32, 100, 109, 50, 44, 35, 37, 109, 97, 107, 101, 45, 103, 101, 
+110, 101, 114, 105, 99, 57, 130, 20, 22, 4, 12, 5, 205, 232, 14, 44, 13, 47, 35, 37, 117, 
+113, 45, 109, 97, 107, 101, 45, 103, 101, 110, 101, 114, 105, 99, 232, 14, 44, 179, 232, 14, 44, 
+232, 14, 44, 13, 35, 113, 117, 111, 116, 101, 232, 14, 44, 186, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 79);
+    JUST_DEFINED_KEY(make-generic);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 215, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 105, 118, 97, 114, 57, 130, 21, 
+21, 4, 13, 5, 205, 56, 127, 231, 14, 50, 176, 61, 126, 231, 14, 53, 177, 56, 127, 232, 14, 
+116, 177, 22, 232, 14, 44, 13, 39, 35, 37, 117, 113, 45, 105, 118, 97, 114, 232, 14, 44, 231, 
+14, 45, 181, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 
+231, 14, 67, 187, 5, 5, 233, 14, 253, 55, 1, 0, 0, 13, 34, 105, 118, 97, 114, 232, 14, 
+253, 253, 0, 0, 0, 2, 39, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 126, 115, 
+32, 112, 97, 114, 116, 115, 32, 97, 102, 116, 101, 114, 32, 116, 104, 101, 32, 107, 101, 121, 119, 
+111, 114, 100, 41, 180, 232, 14, 44, 13, 34, 105, 118, 97, 114, 181, 233, 14, 253, 55, 1, 0, 
+0, 13, 34, 105, 118, 97, 114, 2, 31, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 
+105, 108, 108, 101, 103, 97, 108, 32, 117, 115, 101, 32, 111, 102, 32, 96, 46, 39, 41, 232, 14, 
+44, 13, 34, 105, 118, 97, 114, 180, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 218);
+    JUST_DEFINED_KEY(ivar);
+  }
+#endif
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 176, 1, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 41, 35, 37, 102, 108, 117, 
+105, 100, 45, 108, 101, 116, 57, 130, 21, 23, 4, 28, 5, 205, 56, 127, 231, 14, 49, 176, 232, 
+14, 44, 13, 37, 35, 37, 98, 101, 103, 105, 110, 232, 14, 44, 180, 232, 14, 54, 183, 5, 61, 
+126, 57, 130, 20, 20, 27, 37, 109, 107, 45, 101, 120, 112, 114, 208, 3, 2, 1, 234, 14, 52, 
+13, 39, 102, 108, 117, 105, 100, 45, 108, 101, 116, 179, 180, 181, 55, 77, 56, 127, 231, 14, 50, 
+177, 230, 14, 13, 234, 14, 253, 55, 1, 0, 0, 13, 39, 102, 108, 117, 105, 100, 45, 108, 101, 
+116, 2, 10, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 230, 179, 180, 61, 126, 232, 14, 3, 
+57, 130, 20, 21, 26, 5, 206, 3, 56, 127, 56, 127, 231, 14, 43, 177, 56, 127, 231, 14, 35, 
+231, 14, 45, 178, 56, 127, 231, 14, 43, 231, 14, 46, 178, 231, 14, 49, 231, 14, 69, 178, 7, 
+7, 7, 230, 14, 39, 234, 14, 253, 55, 1, 0, 0, 13, 39, 102, 108, 117, 105, 100, 45, 108, 
+101, 116, 2, 10, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 230, 179, 180, 179, 232, 14, 44, 
+13, 35, 35, 37, 108, 101, 116, 232, 14, 44, 233, 14, 3, 57, 130, 20, 22, 25, 5, 205, 232, 
+14, 51, 177, 231, 14, 45, 179, 182, 184, 232, 14, 44, 232, 14, 44, 13, 44, 35, 37, 100, 121, 
+110, 97, 109, 105, 99, 45, 119, 105, 110, 100, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 
+97, 109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 54, 232, 14, 3, 57, 130, 20, 21, 28, 5, 
+205, 232, 14, 44, 13, 36, 35, 37, 115, 101, 116, 33, 232, 14, 44, 231, 14, 45, 180, 232, 14, 
+44, 231, 14, 67, 182, 5, 15, 20, 5, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 
+109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 44, 15, 21, 232, 14, 54, 15, 24, 5, 232, 14, 
+44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 54, 
+233, 14, 3, 57, 130, 20, 22, 28, 5, 205, 232, 14, 44, 13, 36, 35, 37, 115, 101, 116, 33, 
+232, 14, 44, 231, 14, 45, 180, 232, 14, 44, 182, 5, 15, 25, 15, 23, 5, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 439);
+    JUST_DEFINED_KEY(fluid-let);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 3, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 44, 35, 37, 112, 97, 114, 
+97, 109, 101, 116, 101, 114, 105, 122, 101, 57, 130, 21, 22, 4, 30, 5, 205, 61, 126, 57, 130, 
+20, 21, 29, 34, 102, 97, 105, 108, 207, 2, 1, 233, 14, 253, 55, 1, 0, 0, 13, 42, 112, 
+97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 101, 180, 233, 14, 52, 13, 42, 112, 97, 114, 97, 
+109, 101, 116, 101, 114, 105, 122, 101, 181, 182, 55, 77, 56, 127, 231, 14, 49, 178, 231, 176, 2, 
+23, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 32, 40, 101, 109, 112, 116, 121, 32, 98, 111, 
+100, 121, 41, 53, 76, 31, 118, 56, 127, 231, 14, 49, 177, 232, 14, 44, 13, 37, 35, 37, 98, 
+101, 103, 105, 110, 232, 14, 54, 181, 5, 56, 127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 
+14, 43, 179, 56, 127, 175, 175, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 231, 14, 
+45, 181, 56, 127, 175, 175, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 231, 14, 68, 
+182, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 49, 231, 14, 75, 182, 231, 176, 
+2, 10, 98, 97, 100, 32, 115, 121, 110, 116, 97, 120, 61, 126, 231, 14, 66, 178, 61, 126, 230, 
+14, 39, 61, 126, 230, 14, 39, 232, 14, 44, 13, 36, 35, 37, 108, 101, 116, 42, 232, 14, 44, 
+232, 14, 44, 232, 14, 44, 183, 232, 14, 44, 232, 14, 44, 13, 1, 21, 35, 37, 105, 110, 45, 
+112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 232, 14, 44, 13, 76, 
+1, 26, 35, 37, 99, 117, 114, 114, 101, 110, 116, 45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 
+105, 122, 97, 116, 105, 111, 110, 232, 14, 44, 15, 18, 5, 5, 232, 14, 44, 232, 14, 44, 186, 
+232, 14, 44, 232, 14, 44, 189, 5, 5, 5, 232, 14, 44, 232, 14, 44, 13, 44, 35, 37, 100, 
+121, 110, 97, 109, 105, 99, 45, 119, 105, 110, 100, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 
+108, 97, 109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 44, 232, 14, 44, 15, 18, 232, 14, 44, 
+231, 14, 72, 15, 25, 5, 5, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 
+100, 97, 232, 14, 44, 5, 232, 14, 44, 232, 14, 44, 13, 42, 112, 97, 114, 97, 109, 101, 116, 
+101, 114, 105, 122, 101, 232, 14, 44, 231, 50, 33, 99, 100, 114, 15, 27, 232, 14, 54, 15, 29, 
+5, 5, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 
+5, 232, 14, 44, 232, 14, 44, 15, 22, 232, 14, 44, 15, 25, 5, 5, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 522);
+    JUST_DEFINED_KEY(parameterize);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 233, 2, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 45, 35, 37, 119, 105, 116, 
+104, 45, 104, 97, 110, 100, 108, 101, 114, 115, 57, 130, 21, 22, 4, 73, 5, 205, 55, 77, 56, 
+127, 56, 127, 231, 14, 50, 176, 56, 127, 232, 14, 5, 57, 130, 20, 21, 23, 5, 205, 56, 127, 
+231, 14, 43, 176, 56, 127, 231, 14, 43, 231, 14, 46, 177, 231, 14, 49, 231, 14, 69, 177, 7, 
+7, 177, 231, 14, 43, 177, 7, 7, 230, 14, 13, 233, 14, 253, 55, 1, 0, 0, 13, 43, 119, 
+105, 116, 104, 45, 104, 97, 110, 100, 108, 101, 114, 115, 2, 10, 98, 97, 100, 32, 115, 121, 110, 
+116, 97, 120, 233, 14, 52, 13, 43, 119, 105, 116, 104, 45, 104, 97, 110, 100, 108, 101, 114, 115, 
+181, 182, 56, 127, 231, 14, 49, 176, 232, 14, 44, 13, 35, 98, 101, 103, 105, 110, 232, 14, 54, 
+180, 5, 61, 126, 230, 14, 39, 61, 126, 230, 14, 39, 61, 126, 230, 14, 39, 232, 14, 44, 232, 
+14, 44, 13, 39, 35, 37, 99, 97, 108, 108, 47, 101, 99, 232, 14, 44, 232, 14, 44, 13, 38, 
+35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 232, 14, 44, 189, 5, 232, 14, 44, 232, 14, 
+44, 13, 35, 35, 37, 108, 101, 116, 232, 14, 44, 232, 14, 44, 232, 14, 44, 15, 20, 232, 14, 
+44, 232, 14, 44, 13, 36, 35, 37, 108, 105, 115, 116, 232, 14, 54, 232, 14, 3, 57, 130, 20, 
+21, 28, 5, 205, 232, 14, 44, 13, 36, 35, 37, 99, 111, 110, 115, 232, 14, 44, 231, 14, 45, 
+180, 232, 14, 44, 231, 14, 67, 182, 5, 15, 31, 5, 5, 5, 232, 14, 44, 232, 14, 44, 13, 
+44, 35, 37, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 101, 232, 14, 44, 232, 14, 44, 
+232, 14, 44, 13, 1, 27, 35, 37, 99, 117, 114, 114, 101, 110, 116, 45, 101, 120, 99, 101, 112, 
+116, 105, 111, 110, 45, 104, 97, 110, 100, 108, 101, 114, 232, 14, 44, 232, 14, 44, 13, 38, 35, 
+37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 13, 76, 31, 101, 232, 14, 44, 232, 14, 44, 15, 
+38, 232, 14, 44, 232, 14, 44, 13, 35, 35, 37, 108, 101, 116, 232, 14, 44, 15, 43, 232, 14, 
+44, 232, 14, 44, 232, 14, 44, 15, 48, 232, 14, 44, 15, 50, 5, 5, 232, 14, 44, 232, 14, 
+44, 13, 36, 35, 37, 99, 111, 110, 100, 232, 14, 44, 232, 14, 44, 232, 14, 44, 13, 37, 35, 
+37, 110, 117, 108, 108, 63, 232, 14, 44, 15, 56, 5, 13, 76, 78, 38, 35, 37, 108, 97, 109, 
+98, 100, 97, 5, 77, 37, 35, 37, 114, 97, 105, 115, 101, 31, 101, 232, 14, 44, 232, 14, 44, 
+232, 14, 44, 232, 14, 44, 13, 36, 35, 37, 99, 97, 97, 114, 232, 14, 44, 15, 60, 5, 13, 
+76, 31, 101, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 
+44, 5, 232, 14, 44, 232, 14, 44, 232, 14, 44, 13, 36, 35, 37, 99, 100, 97, 114, 232, 14, 
+44, 15, 68, 5, 13, 76, 31, 101, 5, 5, 232, 14, 44, 232, 14, 44, 13, 34, 101, 108, 115, 
+101, 232, 14, 44, 232, 14, 44, 15, 61, 232, 14, 44, 232, 14, 44, 13, 35, 35, 37, 99, 100, 
+114, 232, 14, 44, 15, 66, 5, 5, 5, 5, 5, 5, 5, 5, 5, 232, 14, 44, 232, 14, 44, 
+13, 48, 35, 37, 99, 97, 108, 108, 45, 119, 105, 116, 104, 45, 118, 97, 108, 117, 101, 115, 232, 
+14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 
+54, 15, 38, 5, 232, 14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 
+14, 44, 13, 34, 97, 114, 103, 115, 232, 14, 44, 232, 14, 44, 15, 40, 13, 76, 78, 38, 35, 
+37, 108, 97, 109, 98, 100, 97, 5, 78, 37, 35, 37, 97, 112, 112, 108, 121, 38, 35, 37, 118, 
+97, 108, 117, 101, 115, 34, 97, 114, 103, 115, 5, 5, 5, 5, 5, 5, 5, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 752);
+    JUST_DEFINED_KEY(with-handlers);
+  }
+#ifdef USE_STRUCT_CASE
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 220, 1, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 1, 20, 35, 37, 115, 116, 
+114, 117, 99, 116, 45, 99, 97, 115, 101, 45, 108, 97, 109, 98, 100, 97, 57, 130, 21, 22, 4, 
+11, 5, 205, 55, 77, 56, 127, 56, 127, 231, 14, 35, 176, 56, 127, 231, 14, 50, 177, 232, 14, 
+5, 57, 130, 20, 21, 23, 5, 205, 56, 127, 231, 14, 50, 176, 231, 14, 253, 35, 1, 0, 0, 
+231, 14, 49, 177, 7, 178, 7, 7, 230, 14, 13, 233, 14, 253, 55, 1, 0, 0, 13, 48, 115, 
+116, 114, 117, 99, 116, 45, 99, 97, 115, 101, 45, 108, 97, 109, 98, 100, 97, 2, 10, 98, 97, 
+100, 32, 115, 121, 110, 116, 97, 120, 233, 14, 52, 13, 48, 115, 116, 114, 117, 99, 116, 45, 99, 
+97, 115, 101, 45, 108, 97, 109, 98, 100, 97, 181, 182, 59, 127, 23, 7, 58, 129, 23, 20, 7, 
+59, 127, 21, 7, 60, 78, 21, 231, 176, 181, 57, 130, 20, 21, 4, 17, 34, 108, 111, 111, 112, 
+208, 5, 4, 0, 56, 127, 231, 14, 49, 179, 233, 14, 8, 5, 5, 5, 59, 127, 25, 7, 58, 
+129, 23, 20, 7, 231, 181, 231, 14, 46, 185, 58, 129, 21, 23, 7, 231, 14, 66, 184, 58, 129, 
+21, 24, 7, 61, 126, 231, 14, 68, 185, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 
+97, 232, 14, 44, 232, 14, 44, 188, 5, 232, 14, 54, 56, 127, 231, 14, 49, 182, 13, 76, 31, 
+120, 181, 5, 56, 127, 56, 127, 232, 14, 253, 37, 1, 0, 0, 180, 13, 34, 101, 108, 115, 101, 
+231, 14, 253, 35, 1, 0, 0, 231, 14, 253, 84, 3, 0, 0, 13, 34, 101, 108, 115, 101, 7, 
+55, 77, 56, 127, 231, 14, 49, 176, 230, 14, 13, 233, 14, 253, 55, 1, 0, 0, 13, 48, 115, 
+116, 114, 117, 99, 116, 45, 99, 97, 115, 101, 45, 108, 97, 109, 98, 100, 97, 2, 24, 101, 108, 
+115, 101, 32, 99, 108, 97, 117, 115, 101, 32, 109, 117, 115, 116, 32, 98, 101, 32, 108, 97, 115, 
+116, 233, 14, 52, 13, 48, 115, 116, 114, 117, 99, 116, 45, 99, 97, 115, 101, 45, 108, 97, 109, 
+98, 100, 97, 187, 188, 233, 14, 8, 5, 5, 231, 14, 51, 183, 56, 127, 177, 233, 14, 8, 232, 
+14, 44, 183, 180, 232, 14, 44, 184, 181, 180, 53, 126, 31, 101, 7, 234, 14, 52, 13, 48, 35, 
+37, 109, 97, 107, 101, 45, 115, 116, 114, 117, 99, 116, 45, 99, 97, 115, 101, 232, 14, 44, 13, 
+36, 35, 37, 108, 105, 115, 116, 181, 232, 14, 44, 13, 36, 35, 37, 108, 105, 115, 116, 182, 181, 
+0};
+    EVAL_ONE_SIZED_STR((char *)expr, 483);
+    JUST_DEFINED_KEY(struct-case-lambda);
+  }
+#endif
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 249, 126, 20, 53, 127, 31, 100, 76, 50, 1, 21, 119, 105, 116, 104, 45, 112, 97, 114, 
+97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 57, 130, 20, 22, 26, 1, 21, 119, 
+105, 116, 104, 45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 205, 
+55, 78, 56, 127, 231, 14, 253, 10, 3, 0, 0, 176, 230, 14, 13, 233, 14, 253, 56, 1, 0, 
+0, 13, 1, 21, 119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 
+116, 105, 111, 110, 2, 16, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 
+110, 178, 56, 127, 56, 127, 231, 14, 1, 177, 232, 14, 24, 178, 20, 7, 230, 14, 13, 233, 14, 
+253, 56, 1, 0, 0, 13, 1, 21, 119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 101, 116, 101, 
+114, 105, 122, 97, 116, 105, 111, 110, 2, 19, 112, 114, 111, 99, 101, 100, 117, 114, 101, 32, 40, 
+97, 114, 105, 116, 121, 32, 48, 41, 179, 61, 126, 230, 14, 253, 6, 3, 0, 0, 233, 14, 21, 
+57, 130, 20, 20, 22, 5, 206, 4, 231, 14, 253, 6, 3, 0, 0, 176, 57, 130, 20, 20, 21, 
+5, 206, 5, 230, 175, 57, 130, 20, 20, 22, 5, 206, 3, 231, 14, 253, 6, 3, 0, 0, 176, 
+0};
+    EVAL_ONE_SIZED_STR((char *)expr, 252);
+    JUST_DEFINED_FUNC(with-parameterization);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 182, 126, 20, 53, 127, 31, 100, 76, 50, 1, 25, 119, 105, 116, 104, 45, 110, 101, 119, 
+45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 57, 130, 20, 21, 
+24, 1, 25, 119, 105, 116, 104, 45, 110, 101, 119, 45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 
+105, 122, 97, 116, 105, 111, 110, 205, 55, 77, 56, 127, 56, 127, 231, 14, 1, 176, 232, 14, 24, 
+177, 20, 7, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 1, 25, 119, 105, 116, 104, 45, 
+110, 101, 119, 45, 112, 97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 2, 
+19, 112, 114, 111, 99, 101, 100, 117, 114, 101, 32, 40, 97, 114, 105, 116, 121, 32, 48, 41, 178, 
+61, 126, 230, 14, 253, 246, 2, 0, 0, 232, 50, 1, 23, 35, 37, 119, 105, 116, 104, 45, 112, 
+97, 114, 97, 109, 101, 116, 101, 114, 105, 122, 97, 116, 105, 111, 110, 177, 178, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 185);
+    JUST_DEFINED_FUNC(with-new-parameterization);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 143, 1, 0, 0, 126, 22, 53, 127, 31, 100, 76, 50, 37, 108, 111, 97, 100, 47, 
+99, 100, 61, 126, 50, 1, 33, 109, 97, 107, 101, 45, 101, 120, 110, 58, 105, 47, 111, 58, 102, 
+105, 108, 101, 115, 121, 115, 116, 101, 109, 58, 100, 105, 114, 101, 99, 116, 111, 114, 121, 61, 126, 
+50, 48, 100, 101, 98, 117, 103, 45, 105, 110, 102, 111, 45, 104, 97, 110, 100, 108, 101, 114, 57, 
+130, 20, 21, 4, 13, 37, 108, 111, 97, 100, 47, 99, 100, 207, 0, 1, 55, 77, 56, 127, 231, 
+14, 231, 178, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 37, 108, 111, 97, 100, 47, 99, 
+100, 2, 6, 115, 116, 114, 105, 110, 103, 180, 59, 127, 23, 7, 58, 129, 23, 20, 7, 231, 14, 
+253, 46, 3, 0, 0, 181, 56, 127, 177, 231, 14, 253, 242, 2, 0, 0, 233, 182, 232, 14, 253, 
+253, 0, 0, 0, 2, 36, 108, 111, 97, 100, 47, 99, 100, 58, 32, 99, 97, 110, 110, 111, 116, 
+32, 111, 112, 101, 110, 32, 97, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 58, 32, 126, 115, 
+186, 230, 230, 183, 184, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 231, 177, 231, 14, 208, 
+181, 55, 77, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 253, 40, 3, 0, 0, 177, 231, 
+14, 253, 242, 2, 0, 0, 233, 182, 233, 14, 253, 253, 0, 0, 0, 2, 65, 108, 111, 97, 100, 
+47, 99, 100, 58, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 32, 111, 102, 32, 126, 115, 32, 
+100, 111, 101, 115, 32, 110, 111, 116, 32, 101, 120, 105, 115, 116, 32, 40, 99, 117, 114, 114, 101, 
+110, 116, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 32, 105, 115, 32, 126, 115, 41, 187, 230, 
+14, 253, 62, 3, 0, 0, 230, 230, 183, 179, 53, 76, 31, 118, 61, 126, 230, 14, 253, 62, 3, 
+0, 0, 233, 14, 21, 57, 130, 20, 20, 22, 5, 206, 4, 231, 14, 253, 62, 3, 0, 0, 176, 
+57, 130, 20, 20, 22, 5, 206, 5, 231, 14, 208, 176, 57, 130, 20, 20, 22, 5, 206, 3, 231, 
+14, 253, 62, 3, 0, 0, 176, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 406);
+    JUST_DEFINED_FUNC(load/cd);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 53, 1, 0, 0, 126, 20, 53, 127, 31, 100, 76, 50, 1, 20, 114, 101, 97, 100, 
+45, 101, 118, 97, 108, 45, 112, 114, 105, 110, 116, 45, 108, 111, 111, 112, 57, 130, 20, 20, 26, 
+1, 20, 114, 101, 97, 100, 45, 101, 118, 97, 108, 45, 112, 114, 105, 110, 116, 45, 108, 111, 111, 
+112, 205, 59, 127, 23, 7, 58, 129, 21, 20, 7, 53, 127, 31, 98, 20, 7, 58, 129, 21, 21, 
+7, 53, 127, 31, 98, 20, 7, 58, 129, 21, 22, 7, 57, 130, 20, 20, 21, 1, 24, 114, 101, 
+112, 45, 101, 114, 114, 111, 114, 45, 101, 115, 99, 97, 112, 101, 45, 104, 97, 110, 100, 108, 101, 
+114, 206, 1, 230, 190, 233, 14, 21, 57, 130, 20, 20, 23, 5, 207, 5, 3, 58, 129, 21, 20, 
+6, 230, 14, 253, 59, 1, 0, 0, 231, 14, 253, 59, 1, 0, 0, 177, 57, 130, 20, 20, 22, 
+5, 206, 4, 231, 14, 10, 57, 130, 20, 21, 23, 5, 206, 1, 59, 127, 21, 7, 60, 78, 21, 
+230, 175, 57, 130, 20, 20, 24, 34, 108, 111, 111, 112, 208, 1, 2, 0, 55, 77, 231, 14, 10, 
+57, 130, 20, 21, 26, 5, 207, 3, 2, 58, 129, 21, 21, 6, 177, 61, 126, 230, 230, 14, 34, 
+55, 77, 56, 127, 231, 14, 196, 176, 230, 176, 53, 76, 31, 118, 232, 14, 7, 57, 130, 20, 20, 
+22, 5, 206, 2, 231, 230, 14, 253, 50, 1, 0, 0, 176, 57, 130, 21, 21, 23, 5, 205, 232, 
+14, 4, 230, 14, 33, 177, 230, 175, 57, 130, 20, 20, 23, 5, 207, 4, 3, 55, 77, 231, 14, 
+253, 59, 1, 0, 0, 191, 58, 129, 21, 21, 6, 7, 58, 129, 21, 20, 6, 7, 53, 76, 31, 
+118, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 316);
+    JUST_DEFINED_FUNC(read-eval-print-loop);
+  }
+#ifndef NO_FILE_SYSTEM_UTILS
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 154, 2, 0, 0, 126, 24, 53, 127, 31, 100, 76, 50, 47, 108, 111, 97, 100, 47, 
+117, 115, 101, 45, 99, 111, 109, 112, 105, 108, 101, 100, 61, 126, 231, 14, 253, 68, 3, 0, 0, 
+2, 9, 92, 46, 46, 63, 46, 63, 46, 63, 36, 61, 126, 57, 130, 20, 21, 24, 37, 114, 101, 
+115, 111, 108, 118, 101, 205, 56, 127, 231, 14, 253, 49, 3, 0, 0, 176, 175, 61, 126, 230, 14, 
+210, 56, 127, 175, 232, 14, 253, 50, 3, 0, 0, 178, 177, 176, 61, 126, 57, 130, 20, 22, 26, 
+37, 100, 97, 116, 101, 62, 61, 63, 205, 61, 126, 231, 14, 253, 58, 3, 0, 0, 177, 61, 126, 
+56, 127, 231, 14, 253, 35, 1, 0, 0, 179, 176, 7, 56, 127, 175, 175, 56, 127, 176, 56, 127, 
+178, 232, 14, 120, 178, 180, 7, 7, 57, 130, 20, 21, 4, 22, 47, 108, 111, 97, 100, 47, 117, 
+115, 101, 45, 99, 111, 109, 112, 105, 108, 101, 100, 208, 0, 1, 2, 55, 77, 56, 127, 56, 127, 
+231, 14, 231, 179, 61, 126, 231, 14, 253, 47, 3, 0, 0, 180, 56, 127, 175, 175, 231, 14, 253, 
+48, 3, 0, 0, 180, 7, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 47, 108, 111, 97, 
+100, 47, 117, 115, 101, 45, 99, 111, 109, 112, 105, 108, 101, 100, 2, 15, 112, 97, 116, 104, 110, 
+97, 109, 101, 32, 115, 116, 114, 105, 110, 103, 181, 59, 127, 25, 7, 58, 129, 21, 20, 7, 231, 
+182, 184, 58, 129, 23, 21, 7, 231, 14, 253, 46, 3, 0, 0, 176, 58, 129, 21, 24, 7, 56, 
+127, 232, 14, 253, 37, 1, 0, 0, 178, 13, 38, 114, 101, 108, 97, 116, 105, 118, 101, 13, 34, 
+115, 97, 109, 101, 176, 61, 126, 57, 130, 20, 21, 4, 14, 36, 103, 101, 116, 45, 115, 111, 207, 
+6, 5, 235, 14, 253, 45, 3, 0, 0, 180, 2, 8, 99, 111, 109, 112, 105, 108, 101, 100, 2, 
+6, 110, 97, 116, 105, 118, 101, 230, 14, 253, 5, 1, 0, 0, 233, 14, 253, 71, 3, 0, 0, 
+184, 185, 61, 126, 230, 14, 253, 4, 1, 0, 0, 56, 127, 232, 14, 253, 38, 1, 0, 0, 177, 
+13, 37, 119, 105, 110, 100, 111, 119, 115, 2, 4, 46, 100, 108, 108, 2, 3, 46, 115, 111, 61, 
+126, 233, 14, 253, 45, 3, 0, 0, 184, 2, 8, 99, 111, 109, 112, 105, 108, 101, 100, 233, 14, 
+253, 71, 3, 0, 0, 188, 185, 2, 3, 46, 122, 111, 61, 126, 231, 178, 181, 61, 126, 231, 179, 
+2, 10, 95, 108, 111, 97, 100, 101, 114, 46, 115, 115, 61, 126, 231, 14, 253, 58, 3, 0, 0, 
+181, 61, 126, 57, 130, 20, 21, 27, 38, 119, 105, 116, 104, 45, 100, 105, 114, 206, 10, 61, 126, 
+232, 14, 253, 250, 2, 0, 0, 230, 14, 253, 6, 3, 0, 0, 14, 210, 61, 126, 230, 176, 233, 
+14, 21, 57, 130, 20, 20, 24, 5, 207, 5, 4, 231, 176, 56, 127, 231, 14, 231, 178, 177, 230, 
+14, 253, 62, 3, 0, 0, 57, 130, 20, 20, 21, 5, 206, 6, 230, 175, 57, 130, 20, 20, 23, 
+5, 207, 3, 4, 231, 176, 177, 61, 126, 56, 127, 232, 15, 16, 180, 179, 61, 126, 231, 14, 253, 
+64, 3, 0, 0, 180, 231, 176, 231, 14, 36, 233, 14, 253, 71, 3, 0, 0, 15, 18, 15, 15, 
+2, 0, 7, 56, 127, 175, 61, 126, 176, 231, 178, 176, 56, 127, 232, 15, 16, 181, 179, 231, 177, 
+57, 130, 20, 20, 22, 5, 206, 5, 231, 230, 14, 253, 65, 3, 0, 0, 176, 56, 127, 232, 15, 
+16, 182, 179, 231, 177, 57, 130, 20, 20, 22, 5, 206, 6, 231, 230, 14, 209, 176, 231, 14, 208, 
+183, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 673);
+    JUST_DEFINED_FUNC(load/use-compiled);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 219, 126, 25, 53, 127, 31, 100, 77, 50, 43, 108, 111, 97, 100, 45, 114, 101, 108, 97, 
+116, 105, 118, 101, 50, 1, 23, 108, 111, 97, 100, 45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 
+101, 120, 116, 101, 110, 115, 105, 111, 110, 61, 126, 57, 130, 20, 22, 22, 32, 109, 107, 205, 57, 
+130, 20, 21, 27, 5, 207, 1, 0, 55, 77, 56, 127, 56, 127, 231, 14, 231, 178, 61, 126, 231, 
+14, 253, 47, 3, 0, 0, 179, 56, 127, 175, 175, 231, 14, 253, 48, 3, 0, 0, 179, 7, 230, 
+14, 13, 233, 14, 253, 56, 1, 0, 0, 179, 2, 15, 112, 97, 116, 104, 110, 97, 109, 101, 32, 
+115, 116, 114, 105, 110, 103, 180, 56, 127, 231, 14, 253, 49, 3, 0, 0, 178, 231, 176, 178, 61, 
+126, 230, 14, 210, 231, 177, 56, 127, 176, 232, 14, 253, 50, 3, 0, 0, 181, 178, 179, 232, 14, 
+8, 232, 179, 14, 208, 13, 43, 108, 111, 97, 100, 45, 114, 101, 108, 97, 116, 105, 118, 101, 232, 
+179, 14, 253, 64, 3, 0, 0, 13, 1, 23, 108, 111, 97, 100, 45, 114, 101, 108, 97, 116, 105, 
+118, 101, 45, 101, 120, 116, 101, 110, 115, 105, 111, 110, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 222);
+    JUST_DEFINED_FUNC(load-relative);
+    JUST_DEFINED_FUNC(load-relative-extension);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 80, 6, 0, 0, 126, 4, 17, 53, 127, 31, 100, 78, 50, 45, 114, 101, 113, 117, 
+105, 114, 101, 45, 108, 105, 98, 114, 97, 114, 121, 50, 1, 24, 114, 101, 113, 117, 105, 114, 101, 
+45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 108, 105, 98, 114, 97, 114, 121, 50, 45, 99, 111, 
+108, 108, 101, 99, 116, 105, 111, 110, 45, 112, 97, 116, 104, 61, 126, 50, 1, 28, 99, 117, 114, 
+114, 101, 110, 116, 45, 108, 111, 97, 100, 101, 100, 45, 108, 105, 98, 114, 97, 114, 121, 45, 116, 
+97, 98, 108, 101, 61, 126, 231, 50, 33, 98, 111, 120, 20, 61, 126, 231, 14, 233, 3, 0, 61, 
+126, 50, 48, 100, 101, 98, 117, 103, 45, 105, 110, 102, 111, 45, 104, 97, 110, 100, 108, 101, 114, 
+61, 126, 50, 1, 28, 109, 97, 107, 101, 45, 101, 120, 110, 58, 105, 47, 111, 58, 102, 105, 108, 
+101, 115, 121, 115, 116, 101, 109, 58, 112, 97, 116, 104, 61, 126, 57, 130, 20, 22, 4, 11, 35, 
+99, 104, 101, 99, 107, 207, 1, 2, 55, 77, 56, 127, 231, 14, 231, 179, 230, 14, 13, 233, 14, 
+253, 56, 1, 0, 0, 180, 2, 6, 115, 116, 114, 105, 110, 103, 181, 56, 127, 231, 14, 253, 47, 
+3, 0, 0, 179, 230, 14, 13, 231, 14, 253, 242, 2, 0, 0, 233, 180, 233, 14, 253, 253, 0, 
+0, 0, 2, 29, 126, 97, 58, 32, 105, 110, 118, 97, 108, 105, 100, 32, 114, 101, 108, 97, 116, 
+105, 118, 101, 32, 112, 97, 116, 104, 58, 32, 126, 115, 184, 185, 230, 230, 179, 182, 61, 126, 57, 
+130, 20, 21, 24, 39, 119, 105, 116, 104, 45, 110, 117, 108, 108, 206, 4, 59, 127, 21, 7, 60, 
+78, 21, 231, 176, 178, 57, 130, 20, 21, 28, 34, 108, 111, 111, 112, 207, 1, 0, 56, 127, 231, 
+14, 49, 178, 14, 42, 233, 14, 52, 231, 14, 45, 181, 179, 231, 179, 231, 14, 46, 182, 61, 126, 
+50, 1, 34, 109, 97, 107, 101, 45, 101, 120, 110, 58, 105, 47, 111, 58, 102, 105, 108, 101, 115, 
+121, 115, 116, 101, 109, 58, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 61, 126, 50, 1, 28, 
+109, 97, 107, 101, 45, 101, 120, 110, 58, 105, 47, 111, 58, 102, 105, 108, 101, 115, 121, 115, 116, 
+101, 109, 58, 102, 105, 108, 101, 61, 126, 57, 130, 20, 23, 26, 46, 99, 104, 101, 99, 107, 45, 
+99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 206, 4, 55, 77, 232, 177, 178, 179, 232, 14, 4, 
+57, 130, 20, 21, 25, 5, 207, 2, 3, 232, 178, 177, 179, 180, 61, 126, 57, 130, 20, 23, 28, 
+38, 102, 105, 110, 100, 45, 99, 111, 108, 207, 3, 7, 61, 126, 230, 14, 253, 63, 3, 0, 0, 
+59, 127, 21, 7, 60, 78, 21, 231, 176, 177, 57, 130, 20, 21, 4, 16, 34, 108, 111, 111, 112, 
+212, 3, 2, 6, 5, 4, 1, 0, 56, 127, 231, 14, 49, 183, 231, 14, 253, 242, 2, 0, 0, 
+233, 185, 234, 14, 253, 253, 0, 0, 0, 2, 42, 126, 97, 58, 32, 99, 111, 108, 108, 101, 99, 
+116, 105, 111, 110, 32, 110, 111, 116, 32, 102, 111, 117, 110, 100, 58, 32, 126, 115, 32, 105, 110, 
+32, 97, 110, 121, 32, 111, 102, 58, 32, 126, 115, 185, 186, 184, 230, 230, 184, 182, 61, 126, 232, 
+14, 253, 45, 3, 0, 0, 231, 14, 45, 186, 181, 56, 127, 231, 14, 253, 40, 3, 0, 0, 176, 
+61, 126, 233, 14, 2, 14, 253, 45, 3, 0, 0, 179, 184, 56, 127, 231, 14, 253, 40, 3, 0, 
+0, 176, 175, 59, 127, 21, 7, 60, 78, 21, 233, 178, 180, 185, 184, 57, 130, 20, 23, 4, 17, 
+34, 108, 111, 111, 112, 208, 9, 8, 0, 61, 126, 232, 14, 253, 45, 3, 0, 0, 181, 231, 14, 
+45, 183, 61, 126, 232, 14, 253, 45, 3, 0, 0, 184, 231, 14, 45, 184, 56, 127, 231, 14, 253, 
+40, 3, 0, 0, 177, 233, 180, 179, 231, 14, 46, 185, 178, 231, 14, 253, 242, 2, 0, 0, 233, 
+183, 234, 14, 253, 253, 0, 0, 0, 2, 70, 114, 101, 113, 117, 105, 114, 101, 45, 108, 105, 98, 
+114, 97, 114, 121, 58, 32, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 32, 126, 115, 32, 100, 
+111, 101, 115, 32, 110, 111, 116, 32, 104, 97, 118, 101, 32, 115, 117, 98, 45, 99, 111, 108, 108, 
+101, 99, 116, 105, 111, 110, 58, 32, 126, 115, 32, 105, 110, 58, 32, 126, 115, 15, 15, 231, 14, 
+45, 15, 15, 188, 230, 230, 182, 179, 231, 177, 231, 14, 46, 185, 59, 127, 23, 6, 58, 129, 21, 
+20, 6, 57, 130, 21, 22, 27, 45, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 45, 112, 97, 
+116, 104, 207, 3, 4, 55, 77, 233, 178, 13, 45, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 
+45, 112, 97, 116, 104, 180, 181, 233, 179, 13, 45, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 
+45, 112, 97, 116, 104, 180, 181, 58, 129, 21, 21, 6, 57, 130, 21, 22, 4, 17, 1, 24, 114, 
+101, 113, 117, 105, 114, 101, 45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 108, 105, 98, 114, 97, 
+114, 121, 210, 4, 6, 8, 10, 2, 55, 78, 232, 179, 13, 1, 24, 114, 101, 113, 117, 105, 114, 
+101, 45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 108, 105, 98, 114, 97, 114, 121, 182, 233, 182, 
+13, 1, 24, 114, 101, 113, 117, 105, 114, 101, 45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 108, 
+105, 98, 114, 97, 114, 121, 183, 184, 61, 126, 230, 14, 212, 56, 127, 175, 233, 14, 2, 194, 184, 
+232, 14, 54, 180, 187, 231, 14, 253, 242, 2, 0, 0, 233, 183, 233, 14, 253, 253, 0, 0, 0, 
+2, 74, 114, 101, 113, 117, 105, 114, 101, 45, 114, 101, 108, 97, 116, 105, 118, 101, 45, 108, 105, 
+98, 114, 97, 114, 121, 58, 32, 116, 104, 101, 114, 101, 32, 105, 115, 32, 110, 111, 32, 99, 117, 
+114, 114, 101, 110, 116, 32, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 32, 102, 111, 114, 32, 
+108, 105, 98, 114, 97, 114, 121, 58, 32, 126, 115, 126, 97, 188, 56, 127, 231, 14, 49, 15, 15, 
+2, 0, 232, 14, 253, 253, 0, 0, 0, 2, 22, 32, 105, 110, 32, 115, 117, 98, 45, 99, 111, 
+108, 108, 101, 99, 116, 105, 111, 110, 58, 32, 126, 115, 15, 16, 230, 230, 181, 233, 14, 2, 14, 
+253, 45, 3, 0, 0, 188, 189, 58, 129, 21, 22, 6, 53, 126, 32, 99, 108, 12, 80, 78, 45, 
+114, 101, 113, 117, 105, 114, 101, 45, 108, 105, 98, 114, 97, 114, 121, 57, 130, 20, 21, 24, 5, 
+206, 2, 232, 192, 178, 2, 5, 109, 122, 108, 105, 98, 57, 130, 21, 23, 4, 28, 5, 213, 3, 
+4, 5, 7, 8, 10, 12, 13, 55, 78, 232, 180, 13, 45, 114, 101, 113, 117, 105, 114, 101, 45, 
+108, 105, 98, 114, 97, 114, 121, 185, 233, 184, 13, 45, 114, 101, 113, 117, 105, 114, 101, 45, 108, 
+105, 98, 114, 97, 114, 121, 187, 188, 61, 126, 230, 176, 61, 126, 231, 14, 36, 232, 14, 2, 14, 
+248, 231, 185, 233, 14, 52, 15, 17, 15, 18, 15, 19, 61, 126, 233, 14, 102, 180, 179, 57, 130, 
+20, 20, 21, 5, 206, 7, 175, 56, 127, 232, 14, 253, 37, 1, 0, 0, 177, 181, 61, 126, 233, 
+189, 13, 45, 114, 101, 113, 117, 105, 114, 101, 45, 108, 105, 98, 114, 97, 114, 121, 15, 16, 15, 
+17, 61, 126, 232, 14, 253, 45, 3, 0, 0, 178, 15, 15, 61, 126, 56, 127, 231, 14, 253, 39, 
+3, 0, 0, 177, 61, 126, 232, 14, 253, 250, 2, 0, 0, 230, 14, 253, 6, 3, 0, 0, 14, 
+212, 61, 126, 230, 176, 233, 14, 21, 57, 130, 20, 20, 26, 5, 208, 21, 20, 4, 231, 176, 232, 
+14, 44, 179, 180, 57, 130, 20, 20, 23, 5, 206, 6, 232, 14, 7, 57, 130, 20, 20, 22, 5, 
+206, 2, 231, 56, 127, 230, 14, 211, 50, 49, 35, 37, 108, 111, 97, 100, 47, 117, 115, 101, 45, 
+99, 111, 109, 112, 105, 108, 101, 100, 14, 208, 176, 14, 51, 57, 130, 20, 20, 23, 5, 207, 3, 
+4, 231, 176, 177, 231, 14, 253, 242, 2, 0, 0, 233, 15, 15, 234, 14, 253, 253, 0, 0, 0, 
+2, 63, 114, 101, 113, 117, 105, 114, 101, 45, 108, 105, 98, 114, 97, 114, 121, 58, 32, 99, 111, 
+108, 108, 101, 99, 116, 105, 111, 110, 32, 126, 115, 32, 100, 111, 101, 115, 32, 110, 111, 116, 32, 
+104, 97, 118, 101, 32, 108, 105, 98, 114, 97, 114, 121, 58, 32, 126, 115, 32, 105, 110, 58, 32, 
+126, 115, 233, 14, 2, 14, 253, 45, 3, 0, 0, 15, 26, 15, 27, 15, 22, 185, 230, 230, 187, 
+180, 55, 77, 233, 14, 101, 183, 182, 178, 232, 14, 2, 14, 8, 177, 232, 14, 2, 14, 8, 177, 
+233, 14, 8, 195, 194, 193, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 1623);
+    JUST_DEFINED_FUNC(require-library);
+    JUST_DEFINED_FUNC(require-relative-library);
+    JUST_DEFINED_FUNC(collection-path);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 43, 1, 0, 0, 126, 21, 53, 127, 32, 100, 109, 50, 49, 35, 37, 114, 101, 102, 
+101, 114, 101, 110, 99, 101, 45, 108, 105, 98, 114, 97, 114, 121, 59, 127, 21, 6, 58, 129, 21, 
+20, 6, 53, 126, 32, 99, 108, 12, 80, 78, 32, 114, 108, 57, 130, 20, 21, 24, 5, 206, 0, 
+232, 192, 178, 2, 5, 109, 122, 108, 105, 98, 57, 130, 21, 23, 4, 14, 5, 205, 61, 126, 231, 
+14, 253, 43, 1, 0, 0, 177, 61, 126, 231, 14, 253, 43, 1, 0, 0, 179, 61, 126, 57, 130, 
+20, 22, 4, 10, 35, 99, 104, 101, 99, 107, 207, 4, 3, 56, 127, 231, 14, 231, 178, 230, 14, 
+13, 233, 14, 253, 55, 1, 0, 0, 13, 47, 114, 101, 102, 101, 114, 101, 110, 99, 101, 45, 108, 
+105, 98, 114, 97, 114, 121, 232, 14, 253, 253, 0, 0, 0, 2, 23, 126, 115, 32, 110, 97, 109, 
+101, 32, 105, 115, 32, 110, 111, 116, 32, 97, 32, 115, 116, 114, 105, 110, 103, 183, 233, 14, 51, 
+13, 47, 114, 101, 102, 101, 114, 101, 110, 99, 101, 45, 108, 105, 98, 114, 97, 114, 121, 181, 182, 
+55, 79, 232, 177, 179, 2, 7, 108, 105, 98, 114, 97, 114, 121, 232, 177, 178, 2, 10, 99, 111, 
+108, 108, 101, 99, 116, 105, 111, 110, 232, 14, 4, 57, 130, 20, 21, 24, 5, 206, 2, 232, 177, 
+178, 2, 14, 115, 117, 98, 45, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 182, 232, 14, 44, 
+13, 47, 35, 37, 114, 101, 113, 117, 105, 114, 101, 45, 108, 105, 98, 114, 97, 114, 121, 232, 14, 
+44, 181, 232, 14, 44, 182, 232, 14, 54, 188, 5, 190, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 306);
+    JUST_DEFINED_KEY(reference-library);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 160, 1, 0, 0, 126, 28, 53, 127, 31, 100, 76, 50, 1, 27, 112, 97, 116, 104, 
+45, 108, 105, 115, 116, 45, 115, 116, 114, 105, 110, 103, 45, 62, 112, 97, 116, 104, 45, 108, 105, 
+115, 116, 61, 126, 231, 14, 253, 68, 3, 0, 0, 61, 126, 61, 126, 230, 14, 253, 4, 1, 0, 
+0, 56, 127, 232, 14, 253, 38, 1, 0, 0, 177, 13, 34, 117, 110, 105, 120, 2, 1, 58, 56, 
+127, 61, 126, 232, 14, 253, 38, 1, 0, 0, 178, 13, 37, 119, 105, 110, 100, 111, 119, 115, 56, 
+127, 175, 175, 232, 14, 253, 38, 1, 0, 0, 178, 13, 35, 109, 97, 99, 111, 115, 2, 1, 59, 
+53, 126, 31, 101, 7, 233, 14, 253, 253, 0, 0, 0, 2, 14, 40, 91, 94, 126, 97, 93, 42, 
+41, 126, 97, 40, 46, 42, 41, 178, 178, 61, 126, 57, 130, 20, 23, 25, 39, 99, 111, 110, 115, 
+45, 112, 97, 116, 104, 205, 56, 127, 232, 14, 237, 178, 2, 0, 232, 14, 54, 177, 179, 56, 127, 
+61, 126, 231, 14, 253, 47, 3, 0, 0, 178, 56, 127, 175, 175, 231, 14, 253, 48, 3, 0, 0, 
+178, 232, 14, 44, 178, 179, 177, 57, 130, 20, 22, 27, 1, 27, 112, 97, 116, 104, 45, 108, 105, 
+115, 116, 45, 115, 116, 114, 105, 110, 103, 45, 62, 112, 97, 116, 104, 45, 108, 105, 115, 116, 207, 
+0, 1, 55, 78, 56, 127, 231, 14, 231, 178, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 
+1, 27, 112, 97, 116, 104, 45, 108, 105, 115, 116, 45, 115, 116, 114, 105, 110, 103, 45, 62, 112, 
+97, 116, 104, 45, 108, 105, 115, 116, 2, 6, 115, 116, 114, 105, 110, 103, 180, 56, 127, 231, 14, 
+50, 179, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 1, 27, 112, 97, 116, 104, 45, 108, 
+105, 115, 116, 45, 115, 116, 114, 105, 110, 103, 45, 62, 112, 97, 116, 104, 45, 108, 105, 115, 116, 
+2, 4, 108, 105, 115, 116, 181, 59, 127, 21, 7, 60, 78, 21, 231, 176, 179, 57, 130, 20, 21, 
+4, 11, 34, 108, 111, 111, 112, 209, 2, 1, 4, 0, 61, 126, 232, 14, 253, 69, 3, 0, 0, 
+180, 182, 56, 127, 175, 233, 182, 180, 231, 14, 67, 179, 231, 180, 231, 14, 76, 180, 233, 182, 180, 
+183, 14, 42, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 423);
+    JUST_DEFINED_FUNC(path-list-string->path-list);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 171, 1, 0, 0, 126, 20, 53, 127, 31, 100, 76, 50, 1, 20, 102, 105, 110, 100, 
+45, 101, 120, 101, 99, 117, 116, 97, 98, 108, 101, 45, 112, 97, 116, 104, 57, 130, 20, 22, 28, 
+1, 20, 102, 105, 110, 100, 45, 101, 120, 101, 99, 117, 116, 97, 98, 108, 101, 45, 112, 97, 116, 
+104, 205, 55, 78, 56, 127, 231, 14, 231, 176, 230, 14, 13, 233, 14, 253, 56, 1, 0, 0, 13, 
+1, 20, 102, 105, 110, 100, 45, 101, 120, 101, 99, 117, 116, 97, 98, 108, 101, 45, 112, 97, 116, 
+104, 2, 6, 115, 116, 114, 105, 110, 103, 178, 56, 127, 231, 14, 231, 177, 230, 14, 13, 233, 14, 
+253, 56, 1, 0, 0, 13, 1, 20, 102, 105, 110, 100, 45, 101, 120, 101, 99, 117, 116, 97, 98, 
+108, 101, 45, 112, 97, 116, 104, 2, 6, 115, 116, 114, 105, 110, 103, 179, 59, 127, 21, 7, 60, 
+78, 21, 56, 127, 231, 14, 253, 47, 3, 0, 0, 177, 61, 126, 231, 14, 253, 2, 1, 0, 0, 
+2, 4, 80, 65, 84, 72, 59, 127, 21, 7, 60, 78, 21, 231, 176, 56, 127, 177, 232, 50, 1, 
+29, 35, 37, 112, 97, 116, 104, 45, 108, 105, 115, 116, 45, 115, 116, 114, 105, 110, 103, 45, 62, 
+112, 97, 116, 104, 45, 108, 105, 115, 116, 179, 14, 42, 14, 42, 57, 130, 20, 21, 28, 34, 108, 
+111, 111, 112, 208, 3, 2, 0, 56, 127, 231, 14, 49, 179, 7, 61, 126, 231, 14, 253, 50, 3, 
+0, 0, 231, 14, 45, 181, 61, 126, 232, 14, 253, 45, 3, 0, 0, 178, 181, 56, 127, 231, 14, 
+253, 39, 3, 0, 0, 176, 231, 179, 176, 231, 178, 231, 14, 46, 182, 231, 176, 177, 57, 130, 20, 
+21, 4, 11, 40, 102, 111, 117, 110, 100, 45, 101, 120, 101, 99, 207, 2, 0, 59, 127, 23, 7, 
+58, 129, 23, 20, 7, 231, 14, 253, 46, 3, 0, 0, 181, 56, 127, 231, 14, 231, 176, 61, 126, 
+232, 14, 253, 45, 3, 0, 0, 178, 182, 56, 127, 61, 126, 231, 14, 253, 40, 3, 0, 0, 177, 
+56, 127, 175, 175, 231, 14, 253, 39, 3, 0, 0, 177, 175, 61, 126, 231, 14, 253, 51, 3, 0, 
+0, 183, 56, 127, 232, 14, 237, 177, 184, 7, 56, 127, 231, 14, 253, 47, 3, 0, 0, 176, 231, 
+181, 232, 14, 253, 45, 3, 0, 0, 180, 178, 231, 181, 176, 7, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 434);
+    JUST_DEFINED_FUNC(find-executable-path);
+  }
+#endif
+#ifdef TIME_SYNTAX
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 14, 1, 0, 0, 126, 20, 53, 127, 32, 100, 109, 50, 36, 35, 37, 116, 105, 109, 
+101, 57, 130, 21, 22, 4, 26, 5, 205, 232, 14, 44, 13, 42, 35, 37, 108, 101, 116, 45, 118, 
+97, 108, 117, 101, 115, 232, 14, 44, 232, 14, 44, 13, 77, 76, 31, 115, 76, 1, 25, 35, 37, 
+99, 117, 114, 114, 101, 110, 116, 45, 103, 99, 45, 109, 105, 108, 108, 105, 115, 101, 99, 111, 110, 
+100, 115, 232, 14, 44, 232, 14, 44, 13, 78, 31, 118, 33, 99, 112, 117, 34, 117, 115, 101, 114, 
+232, 14, 44, 232, 14, 44, 13, 42, 35, 37, 116, 105, 109, 101, 45, 97, 112, 112, 108, 121, 232, 
+14, 44, 232, 14, 44, 13, 38, 35, 37, 108, 97, 109, 98, 100, 97, 232, 14, 44, 5, 232, 14, 
+44, 15, 22, 232, 14, 54, 15, 25, 5, 5, 5, 5, 13, 77, 80, 38, 35, 37, 112, 114, 105, 
+110, 116, 102, 2, 40, 99, 112, 117, 32, 116, 105, 109, 101, 58, 32, 126, 115, 32, 114, 101, 97, 
+108, 32, 116, 105, 109, 101, 58, 32, 126, 115, 32, 103, 99, 32, 116, 105, 109, 101, 58, 32, 126, 
+115, 126, 110, 33, 99, 112, 117, 34, 117, 115, 101, 114, 78, 33, 35, 37, 45, 76, 1, 25, 35, 
+37, 99, 117, 114, 114, 101, 110, 116, 45, 103, 99, 45, 109, 105, 108, 108, 105, 115, 101, 99, 111, 
+110, 100, 115, 31, 115, 78, 37, 35, 37, 97, 112, 112, 108, 121, 38, 35, 37, 118, 97, 108, 117, 
+101, 115, 31, 118, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 277);
+    JUST_DEFINED_KEY(time);
+  }
+#endif
+#ifndef NO_UNIT_SYSTEM
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 235, 2, 0, 0, 126, 23, 53, 127, 31, 100, 76, 50, 1, 30, 118, 101, 114, 105, 
+102, 121, 45, 108, 105, 110, 107, 97, 103, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 
+109, 97, 116, 99, 104, 61, 126, 14, 253, 56, 2, 0, 0, 61, 126, 14, 253, 60, 2, 0, 0, 
+61, 126, 57, 130, 20, 21, 24, 38, 112, 45, 115, 117, 102, 102, 105, 120, 205, 61, 126, 176, 56, 
+127, 232, 14, 253, 38, 1, 0, 0, 177, 13, 21, 13, 32, 115, 116, 56, 127, 232, 14, 253, 38, 
+1, 0, 0, 177, 13, 22, 13, 32, 110, 100, 56, 127, 232, 14, 253, 38, 1, 0, 0, 177, 13, 
+23, 13, 32, 114, 100, 13, 32, 116, 104, 57, 130, 20, 25, 4, 12, 1, 30, 118, 101, 114, 105, 
+102, 121, 45, 108, 105, 110, 107, 97, 103, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 
+109, 97, 116, 99, 104, 208, 0, 1, 2, 55, 79, 233, 14, 4, 57, 130, 20, 22, 4, 11, 5, 
+207, 3, 6, 56, 127, 231, 14, 253, 103, 1, 0, 0, 178, 230, 14, 13, 231, 14, 253, 242, 2, 
+0, 0, 233, 180, 233, 14, 253, 253, 0, 0, 0, 2, 44, 126, 115, 58, 32, 101, 120, 112, 114, 
+101, 115, 115, 105, 111, 110, 32, 102, 111, 114, 32, 34, 126, 115, 34, 32, 105, 115, 32, 110, 111, 
+116, 32, 97, 32, 115, 105, 103, 110, 101, 100, 32, 117, 110, 105, 116, 182, 185, 230, 230, 14, 253, 
+241, 2, 0, 0, 181, 183, 182, 234, 14, 4, 57, 130, 20, 23, 4, 12, 5, 206, 7, 236, 14, 
+253, 111, 1, 0, 0, 181, 7, 232, 14, 253, 253, 0, 0, 0, 2, 33, 115, 112, 101, 99, 105, 
+102, 105, 101, 100, 32, 101, 120, 112, 111, 114, 116, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 
+32, 102, 111, 114, 32, 126, 97, 185, 184, 232, 14, 253, 253, 0, 0, 0, 2, 39, 101, 120, 112, 
+111, 114, 116, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 102, 111, 114, 32, 97, 99, 116, 
+117, 97, 108, 32, 126, 97, 32, 115, 117, 98, 45, 117, 110, 105, 116, 185, 231, 14, 253, 108, 1, 
+0, 0, 183, 184, 183, 185, 234, 14, 4, 57, 130, 20, 23, 4, 16, 5, 207, 5, 7, 61, 126, 
+231, 14, 53, 231, 14, 253, 106, 1, 0, 0, 180, 61, 126, 231, 14, 53, 182, 56, 127, 232, 14, 
+116, 177, 178, 230, 14, 13, 231, 14, 253, 242, 2, 0, 0, 233, 182, 235, 14, 253, 253, 0, 0, 
+0, 2, 56, 126, 115, 58, 32, 126, 97, 32, 117, 110, 105, 116, 32, 105, 109, 112, 111, 114, 116, 
+115, 32, 126, 97, 32, 117, 110, 105, 116, 115, 44, 32, 98, 117, 116, 32, 126, 97, 32, 117, 110, 
+105, 116, 115, 32, 119, 101, 114, 101, 32, 112, 114, 111, 118, 105, 100, 101, 100, 186, 189, 185, 184, 
+230, 230, 14, 253, 241, 2, 0, 0, 183, 184, 183, 186, 234, 14, 4, 57, 130, 20, 23, 4, 10, 
+5, 207, 6, 7, 59, 127, 21, 7, 60, 78, 21, 233, 178, 183, 231, 14, 253, 106, 1, 0, 0, 
+182, 21, 57, 130, 20, 23, 4, 21, 34, 108, 111, 111, 112, 209, 2, 1, 4, 0, 56, 127, 231, 
+14, 49, 180, 230, 14, 13, 61, 126, 231, 14, 45, 182, 61, 126, 231, 14, 45, 182, 55, 77, 236, 
+14, 253, 111, 1, 0, 0, 185, 6, 235, 14, 253, 253, 0, 0, 0, 2, 36, 126, 97, 32, 117, 
+110, 105, 116, 39, 115, 32, 126, 115, 126, 115, 32, 105, 109, 112, 111, 114, 116, 32, 40, 126, 97, 
+32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 41, 189, 15, 19, 231, 15, 17, 15, 20, 231, 14, 
+45, 188, 231, 14, 46, 183, 235, 14, 253, 253, 0, 0, 0, 2, 34, 126, 115, 126, 115, 32, 108, 
+105, 110, 107, 97, 103, 101, 32, 40, 126, 97, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 41, 
+32, 102, 111, 114, 32, 126, 97, 15, 19, 231, 15, 17, 15, 20, 231, 14, 45, 187, 189, 231, 14, 
+46, 182, 233, 180, 231, 14, 46, 185, 231, 14, 46, 186, 231, 14, 124, 187, 184, 183, 186, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 754);
+    JUST_DEFINED_FUNC(verify-linkage-signature-match);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 89, 126, 23, 53, 127, 31, 100, 78, 50, 39, 117, 110, 105, 116, 47, 115, 105, 103, 63, 
+50, 1, 25, 117, 110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 
+101, 45, 62, 117, 110, 105, 116, 50, 44, 117, 110, 105, 116, 47, 115, 105, 103, 45, 62, 117, 110, 
+105, 116, 233, 50, 36, 118, 97, 108, 117, 101, 115, 14, 253, 103, 1, 0, 0, 14, 253, 104, 1, 
+0, 0, 14, 253, 104, 1, 0, 0, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 92);
+    JUST_DEFINED_FUNC(unit/sig?);
+    JUST_DEFINED_FUNC(unit-with-signature->unit);
+    JUST_DEFINED_FUNC(unit/sig->unit);
+  }
+#endif
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 14, 1, 0, 0, 126, 22, 53, 127, 31, 100, 76, 50, 41, 114, 97, 116, 105, 111, 
+110, 97, 108, 105, 122, 101, 59, 127, 22, 7, 58, 129, 21, 21, 7, 57, 130, 20, 21, 24, 35, 
+99, 104, 101, 99, 107, 205, 56, 127, 231, 14, 111, 176, 230, 14, 13, 233, 14, 253, 56, 1, 0, 
+0, 13, 41, 114, 97, 116, 105, 111, 110, 97, 108, 105, 122, 101, 2, 4, 114, 101, 97, 108, 178, 
+60, 78, 21, 57, 130, 20, 22, 4, 11, 41, 114, 97, 116, 105, 111, 110, 97, 108, 105, 122, 101, 
+207, 0, 1, 55, 78, 231, 176, 178, 231, 176, 179, 61, 126, 231, 14, 134, 180, 61, 126, 232, 14, 
+131, 181, 178, 61, 126, 232, 14, 130, 182, 179, 56, 127, 231, 14, 253, 35, 1, 0, 0, 232, 14, 
+116, 183, 183, 0, 6, 43, 110, 97, 110, 46, 48, 56, 127, 233, 14, 119, 179, 20, 178, 56, 127, 
+231, 14, 114, 181, 20, 0, 3, 48, 46, 48, 56, 127, 231, 14, 123, 177, 231, 14, 131, 232, 182, 
+231, 14, 131, 179, 231, 14, 131, 180, 232, 181, 178, 177, 57, 130, 20, 22, 4, 13, 42, 102, 105, 
+110, 100, 45, 98, 101, 116, 119, 101, 101, 110, 206, 0, 56, 127, 231, 14, 113, 177, 176, 61, 126, 
+231, 14, 145, 178, 61, 126, 231, 14, 145, 180, 56, 127, 232, 14, 117, 178, 177, 231, 14, 124, 177, 
+232, 14, 130, 178, 231, 14, 133, 232, 182, 231, 14, 133, 232, 14, 131, 187, 184, 231, 14, 133, 232, 
+14, 131, 186, 184, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 277);
+    JUST_DEFINED_FUNC(rationalize);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 245, 126, 20, 53, 127, 31, 100, 76, 50, 1, 24, 115, 105, 109, 112, 108, 101, 45, 114, 
+101, 116, 117, 114, 110, 45, 112, 114, 105, 109, 105, 116, 105, 118, 101, 63, 57, 130, 20, 21, 25, 
+1, 24, 115, 105, 109, 112, 108, 101, 45, 114, 101, 116, 117, 114, 110, 45, 112, 114, 105, 109, 105, 
+116, 105, 118, 101, 63, 205, 55, 77, 56, 127, 231, 14, 25, 176, 230, 14, 13, 233, 14, 253, 56, 
+1, 0, 0, 13, 1, 24, 115, 105, 109, 112, 108, 101, 45, 114, 101, 116, 117, 114, 110, 45, 112, 
+114, 105, 109, 105, 116, 105, 118, 101, 63, 2, 19, 112, 114, 105, 109, 105, 116, 105, 118, 101, 45, 
+112, 114, 111, 99, 101, 100, 117, 114, 101, 178, 231, 14, 253, 35, 1, 0, 0, 232, 14, 60, 231, 
+14, 22, 179, 13, 81, 46, 99, 97, 108, 108, 45, 119, 105, 116, 104, 45, 118, 97, 108, 117, 101, 
+115, 35, 97, 112, 112, 108, 121, 35, 101, 114, 114, 111, 114, 1, 30, 99, 97, 108, 108, 45, 119, 
+105, 116, 104, 45, 99, 117, 114, 114, 101, 110, 116, 45, 99, 111, 110, 116, 105, 110, 117, 97, 116, 
+105, 111, 110, 44, 104, 97, 115, 104, 45, 116, 97, 98, 108, 101, 45, 103, 101, 116, 49, 119, 114, 
+105, 116, 101, 45, 105, 109, 97, 103, 101, 45, 116, 111, 45, 102, 105, 108, 101, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 248);
+    JUST_DEFINED_FUNC(simple-return-primitive?);
+  }
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 40, 126, 20, 53, 127, 31, 100, 76, 50, 35, 112, 111, 114, 116, 63, 57, 130, 20, 21, 
+23, 35, 112, 111, 114, 116, 63, 205, 61, 126, 231, 14, 174, 177, 56, 127, 175, 175, 231, 14, 175, 
+177, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 43);
+    JUST_DEFINED_FUNC(port?);
+  }
diff --git a/src/mzscheme/src/complex.c b/src/mzscheme/src/complex.c
new file mode 100644
index 0000000..68bba65
--- /dev/null
+++ b/src/mzscheme/src/complex.c
@@ -0,0 +1,275 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <ctype.h>
+#include <math.h>
+
+static Scheme_Object *zero = scheme_make_integer(0);
+
+static Scheme_Object *make_complex(const Scheme_Object *r, const Scheme_Object *i,
+				   int normalize)
+{
+  Scheme_Complex *c;
+
+  c = MALLOC_ONE_TAGGED(Scheme_Complex);
+  c->type = scheme_complex_type;
+  c->r = (Scheme_Object *)r;
+  c->i = (Scheme_Object *)i;
+  
+  return normalize 
+    ? scheme_complex_normalize((Scheme_Object *)c) 
+      : (Scheme_Object *)c;
+}
+
+Scheme_Object *scheme_make_complex(const Scheme_Object *r, const Scheme_Object *i)
+{
+  return make_complex(r, i, 1);
+}
+
+Scheme_Object *scheme_real_to_complex(const Scheme_Object *n)
+{
+  return make_complex(n, (SCHEME_DBLP(n) 
+			  ? scheme_make_double(0.0) 
+#ifdef MZ_USE_SINGLE_FLOATS
+			  : SCHEME_FLTP(n)
+			  ? scheme_make_float(0.0f)
+#endif
+			  : zero), 
+		      0);
+}
+
+Scheme_Object *scheme_make_small_complex(const Scheme_Object *n, Small_Complex *s)
+{
+  s->type = scheme_complex_type;
+  s->r = (Scheme_Object *)n;
+  s->i = (SCHEME_DBLP(n) 
+	  ? scheme_make_double(0.0) 
+#ifdef MZ_USE_SINGLE_FLOATS
+	  : SCHEME_FLTP(n)
+	  ? scheme_make_float(0.0f)
+#endif
+	  : zero);
+
+  return (Scheme_Object *)s;
+}
+
+int scheme_is_complex_exact(const Scheme_Object *o)
+{
+  Scheme_Complex *c = (Scheme_Complex *)o;
+
+  return !SCHEME_FLOATP(c->r);
+}
+
+Scheme_Object *scheme_complex_normalize(const Scheme_Object *o)
+{
+  Scheme_Complex *c = (Scheme_Complex *)o;
+
+  if (SCHEME_DBLP(c->i)) {
+    if (SCHEME_DBL_VAL(c->i) == 0.0)
+      return c->r;
+#ifdef MZ_USE_SINGLE_FLOATS
+  } else if (SCHEME_FLTP(c->i)) {
+    if (SCHEME_FLT_VAL(c->i) == 0.0f)
+      return c->r;
+#endif
+  } else if (c->i == zero)
+    return c->r;
+
+  return (Scheme_Object *)o;
+}
+
+Scheme_Object *scheme_complex_real_part(const Scheme_Object *n)
+{
+  return ((Scheme_Complex *)n)->r;
+}
+
+Scheme_Object *scheme_complex_imaginary_part(const Scheme_Object *n)
+{
+  return ((Scheme_Complex *)n)->i;
+}
+
+int scheme_complex_eq(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Complex *ca = (Scheme_Complex *)a;
+  Scheme_Complex *cb = (Scheme_Complex *)b;
+  return scheme_bin_eq(ca->r, cb->r) && scheme_bin_eq(ca->i, cb->i);
+}
+
+Scheme_Object *scheme_complex_negate(const Scheme_Object *o)
+{
+  Scheme_Complex *c = (Scheme_Complex *)o;
+
+  return make_complex(scheme_bin_minus(scheme_make_integer(0),
+				       c->r), 
+		      scheme_bin_minus(scheme_make_integer(0),
+				       c->i),
+		      0);
+}
+
+Scheme_Object *scheme_complex_add(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Complex *ca = (Scheme_Complex *)a;
+  Scheme_Complex *cb = (Scheme_Complex *)b;
+
+  return scheme_make_complex(scheme_bin_plus(ca->r, cb->r),
+			     scheme_bin_plus(ca->i, cb->i));
+}
+
+Scheme_Object *scheme_complex_subtract(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Complex *ca = (Scheme_Complex *)a;
+  Scheme_Complex *cb = (Scheme_Complex *)b;
+
+  return scheme_make_complex(scheme_bin_minus(ca->r, cb->r),
+			     scheme_bin_minus(ca->i, cb->i));
+}
+
+Scheme_Object *scheme_complex_add1(const Scheme_Object *n)
+{
+  Small_Complex s;
+
+  return scheme_complex_add(scheme_make_small_complex(scheme_make_integer(1), &s), 
+			    n);
+}
+
+Scheme_Object *scheme_complex_sub1(const Scheme_Object *n)
+{
+  Small_Complex s;
+
+  return scheme_complex_add(n, scheme_make_small_complex(scheme_make_integer(-1), 
+							 &s));
+}
+
+Scheme_Object *scheme_complex_multiply(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Complex *ca = (Scheme_Complex *)a;
+  Scheme_Complex *cb = (Scheme_Complex *)b;
+
+  return scheme_make_complex(scheme_bin_minus(scheme_bin_mult(ca->r, cb->r),
+					      scheme_bin_mult(ca->i, cb->i)),
+			     scheme_bin_plus(scheme_bin_mult(ca->r, cb->i),
+					     scheme_bin_mult(ca->i, cb->r)));
+  
+}
+
+static int zero_p(const Scheme_Object *v)
+{
+  return ((v == zero) 
+#ifdef MZ_USE_SINGLE_FLOATS
+	  || (SCHEME_FLTP(v) && SCHEME_FLT_VAL(v) == 0.0f)
+#endif
+	  || (SCHEME_DBLP(v) && SCHEME_DBL_VAL(v) == 0.0));
+}
+
+Scheme_Object *scheme_complex_divide(const Scheme_Object *n, const Scheme_Object *d)
+{ 
+  Scheme_Complex *cn = (Scheme_Complex *)n;
+  Scheme_Complex *cd = (Scheme_Complex *)d;
+  Scheme_Object *a_sq_p_b_sq, *r, *i;
+  
+  if (zero_p(cn->r) && zero_p(cn->i))
+    return zero;
+
+  a_sq_p_b_sq = scheme_bin_plus(scheme_bin_mult(cd->r, cd->r), 
+				scheme_bin_mult(cd->i, cd->i));
+  
+  r = scheme_bin_div(scheme_bin_plus(scheme_bin_mult(cd->r, cn->r),
+				     scheme_bin_mult(cd->i, cn->i)),
+		     a_sq_p_b_sq);
+  i = scheme_bin_div(scheme_bin_minus(scheme_bin_mult(cd->r, cn->i),
+				      scheme_bin_mult(cd->i, cn->r)),
+		     a_sq_p_b_sq);
+  
+  return scheme_make_complex(r, i);
+}
+
+Scheme_Object *scheme_complex_power(const Scheme_Object *base, const Scheme_Object *exponent)
+{
+  Scheme_Complex *cb = (Scheme_Complex *)base;
+  Scheme_Complex *ce = (Scheme_Complex *)exponent;
+  double a, b, c, d, bm, ba, nm, na, r1, r2;
+
+  if (ce->i == zero)
+    return scheme_generic_power(base, ce->r);
+
+  a = scheme_get_val_as_double(cb->r);
+  b = scheme_get_val_as_double(cb->i);
+  c = scheme_get_val_as_double(ce->r);
+  d = scheme_get_val_as_double(ce->i);
+
+  bm = sqrt(a * a + b * b);
+  ba = atan2(b, a);
+
+  /* New mag & angle */
+  nm = pow(bm, c) * exp(-(ba * d));
+  na = log(bm) * d + ba * c;
+
+  r1 = nm * cos(na);
+  r2 = nm * sin(na);
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  /* Coerce to double or float? */
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+  if (!SCHEME_DBLP(cb->r) && !SCHEME_DBLP(cb->i)
+      && !SCHEME_DBLP(ce->r) && !SCHEME_DBLP(ce->i))
+#else
+  if (SCHEME_FLTP(cb->r) && SCHEME_FLTP(cb->i)
+      && SCHEME_FLTP(ce->r) && SCHEME_FLTP(ce->i))
+#endif
+    return scheme_make_complex(scheme_make_float((float)r1), 
+			       scheme_make_float((float)r2));
+#endif
+
+  return scheme_make_complex(scheme_make_double(r1), 
+			     scheme_make_double(r2));
+}
+
+Scheme_Object *scheme_complex_sqrt(const Scheme_Object *o)
+{
+  Scheme_Complex *c = (Scheme_Complex *)o;
+  Scheme_Object *r, *i, *ssq, *srssq, *nrsq, *nr, *ni;
+
+  r = c->r;
+  i = c->i;
+
+  ssq = scheme_bin_plus(scheme_bin_mult(r, r),
+			scheme_bin_mult(i, i));
+
+  srssq = scheme_sqrt(1, &ssq);
+
+  nrsq = scheme_bin_div(scheme_bin_minus(srssq, r),
+			scheme_make_integer(2));
+
+  nr = scheme_sqrt(1, &nrsq);
+  
+  ni = scheme_bin_div(i, scheme_bin_mult(nr,
+					 scheme_make_integer(2)));
+
+  /* Choose root with positive real part: */
+  if (scheme_bin_lt(ni, zero)) {
+    return scheme_make_complex(scheme_bin_minus(zero, ni), 
+			       scheme_bin_minus(zero, nr));
+  } else
+    return scheme_make_complex(ni, nr);
+}
diff --git a/src/mzscheme/src/cunitsig.inc b/src/mzscheme/src/cunitsig.inc
new file mode 100644
index 0000000..b5d8f2d
--- /dev/null
+++ b/src/mzscheme/src/cunitsig.inc
@@ -0,0 +1,651 @@
+  {
+    static MZCOMPILED_STRING_FAR unsigned char expr[] = {35, 96, 253, 252, 52, 0, 0, 126, 20, 53, 126, 32, 105, 109, 12, 86, 80, 20, 20, 7, 205, 
+53, 126, 31, 109, 12, 82, 128, 20, 20, 12, 83, 10, 253, 129, 1, 0, 0, 4, 81, 4, 88, 
+205, 4, 46, 5, 21, 237, 14, 253, 8, 1, 0, 0, 16, 53, 16, 54, 16, 62, 16, 82, 16, 
+85, 16, 86, 16, 87, 20, 57, 130, 21, 21, 4, 28, 1, 25, 117, 110, 105, 116, 45, 62, 117, 
+110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 215, 123, 42, 
+121, 40, 117, 36, 112, 31, 106, 25, 61, 126, 232, 14, 44, 193, 188, 55, 77, 56, 127, 56, 127, 
+231, 14, 43, 187, 56, 127, 231, 14, 43, 231, 14, 46, 188, 56, 127, 231, 14, 50, 231, 14, 67, 
+188, 56, 127, 231, 14, 43, 231, 14, 69, 188, 231, 14, 49, 231, 14, 77, 188, 7, 7, 7, 7, 
+230, 14, 13, 233, 196, 194, 178, 2, 13, 105, 109, 112, 114, 111, 112, 101, 114, 32, 102, 111, 114, 
+109, 61, 126, 231, 14, 45, 188, 61, 126, 232, 14, 3, 57, 130, 20, 21, 4, 10, 5, 210, 12, 
+9, 5, 5, 4, 234, 197, 195, 179, 7, 184, 231, 14, 67, 15, 16, 61, 126, 234, 202, 198, 182, 
+7, 231, 14, 76, 15, 19, 232, 14, 44, 13, 1, 26, 35, 37, 109, 97, 107, 101, 45, 117, 110, 
+105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 232, 14, 44, 181, 
+232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 231, 16, 23, 
+187, 5, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 231, 
+16, 23, 188, 5, 5, 21, 1, 25, 117, 110, 105, 116, 45, 62, 117, 110, 105, 116, 45, 119, 105, 
+116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 80, 7, 20, 57, 130, 21, 21, 4, 
+19, 1, 31, 105, 110, 118, 111, 107, 101, 45, 111, 112, 101, 110, 45, 117, 110, 105, 116, 45, 119, 
+105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 213, 158, 77, 157, 76, 112, 31, 109, 
+28, 61, 126, 232, 14, 44, 193, 186, 55, 77, 56, 127, 56, 127, 231, 14, 43, 185, 61, 126, 231, 
+14, 49, 231, 14, 46, 187, 56, 127, 175, 175, 56, 127, 231, 14, 43, 231, 14, 46, 187, 231, 14, 
+50, 231, 14, 69, 187, 7, 7, 230, 14, 13, 233, 196, 194, 178, 2, 13, 105, 109, 112, 114, 111, 
+112, 101, 114, 32, 102, 111, 114, 109, 56, 127, 231, 14, 49, 231, 14, 46, 186, 235, 202, 196, 13, 
+48, 35, 37, 105, 110, 118, 111, 107, 101, 45, 111, 112, 101, 110, 45, 117, 110, 105, 116, 231, 14, 
+45, 15, 15, 14, 42, 14, 42, 61, 126, 231, 14, 45, 186, 61, 126, 231, 14, 67, 187, 61, 126, 
+233, 201, 197, 231, 14, 69, 15, 16, 181, 235, 16, 15, 199, 13, 48, 35, 37, 105, 110, 118, 111, 
+107, 101, 45, 111, 112, 101, 110, 45, 117, 110, 105, 116, 182, 180, 231, 14, 51, 182, 21, 1, 31, 
+105, 110, 118, 111, 107, 101, 45, 111, 112, 101, 110, 45, 117, 110, 105, 116, 45, 119, 105, 116, 104, 
+45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 79, 7, 20, 57, 130, 21, 21, 4, 17, 1, 
+26, 105, 110, 118, 111, 107, 101, 45, 117, 110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 213, 158, 77, 157, 76, 112, 31, 108, 27, 61, 126, 232, 14, 44, 193, 
+186, 55, 77, 56, 127, 56, 127, 231, 14, 43, 185, 231, 14, 50, 231, 14, 46, 186, 7, 230, 14, 
+13, 233, 196, 194, 178, 2, 13, 105, 109, 112, 114, 111, 112, 101, 114, 32, 102, 111, 114, 109, 61, 
+126, 231, 14, 45, 186, 61, 126, 233, 200, 196, 231, 14, 46, 15, 15, 180, 235, 204, 198, 13, 43, 
+35, 37, 105, 110, 118, 111, 107, 101, 45, 117, 110, 105, 116, 181, 180, 14, 42, 21, 1, 26, 105, 
+110, 118, 111, 107, 101, 45, 117, 110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 
+116, 117, 114, 101, 4, 78, 7, 20, 57, 130, 20, 25, 4, 37, 47, 98, 117, 105, 108, 100, 45, 
+105, 110, 118, 111, 107, 101, 45, 117, 110, 105, 116, 211, 126, 45, 123, 42, 111, 30, 231, 191, 232, 
+14, 44, 13, 33, 108, 101, 116, 232, 14, 44, 232, 14, 44, 232, 14, 44, 13, 31, 117, 232, 14, 
+44, 15, 19, 5, 5, 232, 14, 44, 232, 14, 44, 13, 1, 32, 35, 37, 118, 101, 114, 105, 102, 
+121, 45, 108, 105, 110, 107, 97, 103, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 109, 
+97, 116, 99, 104, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 
+44, 15, 21, 5, 232, 14, 44, 13, 77, 37, 35, 37, 113, 117, 111, 116, 101, 76, 36, 105, 110, 
+118, 111, 107, 101, 232, 14, 44, 13, 77, 36, 35, 37, 108, 105, 115, 116, 31, 117, 232, 14, 44, 
+13, 77, 37, 35, 37, 113, 117, 111, 116, 101, 76, 11, 0, 232, 14, 44, 232, 14, 44, 13, 37, 
+35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 232, 14, 44, 231, 16, 28, 15, 35, 5, 5, 5, 
+232, 14, 44, 232, 14, 44, 15, 18, 232, 14, 44, 13, 77, 1, 26, 35, 37, 117, 110, 105, 116, 
+45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 117, 110, 105, 116, 31, 
+117, 232, 14, 54, 15, 25, 232, 14, 54, 231, 16, 22, 15, 27, 5, 5, 21, 47, 98, 117, 105, 
+108, 100, 45, 105, 110, 118, 111, 107, 101, 45, 117, 110, 105, 116, 4, 77, 7, 20, 57, 130, 20, 
+23, 4, 10, 47, 112, 97, 114, 115, 101, 45, 105, 110, 118, 111, 107, 101, 45, 118, 97, 114, 115, 
+207, 134, 53, 235, 195, 182, 6, 7, 184, 183, 21, 47, 112, 97, 114, 115, 101, 45, 105, 110, 118, 
+111, 107, 101, 45, 118, 97, 114, 115, 4, 76, 7, 20, 57, 130, 21, 21, 4, 11, 1, 28, 99, 
+111, 109, 112, 111, 117, 110, 100, 45, 117, 110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 211, 155, 74, 111, 30, 107, 26, 61, 126, 232, 14, 44, 193, 184, 231, 
+194, 232, 198, 178, 185, 21, 1, 28, 99, 111, 109, 112, 111, 117, 110, 100, 45, 117, 110, 105, 116, 
+45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 75, 7, 20, 57, 130, 
+20, 22, 4, 95, 49, 112, 97, 114, 115, 101, 45, 99, 111, 109, 112, 111, 117, 110, 100, 45, 117, 
+110, 105, 116, 17, 52, 153, 72, 151, 70, 149, 68, 147, 66, 146, 65, 144, 63, 142, 61, 140, 59, 
+138, 57, 134, 53, 130, 49, 126, 45, 125, 44, 123, 42, 122, 41, 121, 40, 118, 37, 117, 36, 115, 
+34, 112, 31, 107, 26, 90, 9, 86, 5, 84, 3, 83, 2, 82, 1, 55, 77, 56, 127, 56, 127, 
+231, 14, 43, 15, 54, 56, 127, 231, 14, 43, 231, 14, 45, 15, 55, 232, 14, 253, 37, 1, 0, 
+0, 13, 36, 105, 109, 112, 111, 114, 116, 231, 14, 66, 15, 56, 7, 7, 230, 14, 13, 233, 16, 
+15, 203, 15, 55, 2, 24, 101, 120, 112, 101, 99, 116, 101, 100, 32, 96, 105, 109, 112, 111, 114, 
+116, 39, 32, 99, 108, 97, 117, 115, 101, 61, 126, 235, 16, 38, 16, 16, 7, 6, 15, 58, 231, 
+14, 68, 15, 60, 61, 126, 231, 14, 46, 15, 56, 55, 78, 56, 127, 56, 127, 231, 14, 43, 176, 
+56, 127, 231, 14, 43, 231, 14, 45, 177, 232, 14, 253, 37, 1, 0, 0, 13, 34, 108, 105, 110, 
+107, 231, 14, 66, 178, 7, 7, 230, 14, 13, 233, 16, 17, 16, 15, 15, 57, 2, 21, 101, 120, 
+112, 101, 99, 116, 100, 32, 96, 108, 105, 110, 107, 39, 32, 99, 108, 97, 117, 115, 101, 56, 127, 
+231, 14, 50, 231, 14, 45, 177, 230, 14, 13, 233, 16, 17, 16, 15, 15, 57, 2, 27, 105, 109, 
+112, 114, 111, 112, 101, 114, 32, 96, 108, 105, 110, 107, 39, 32, 99, 108, 97, 117, 115, 101, 32, 
+102, 111, 114, 109, 61, 126, 57, 130, 20, 22, 4, 13, 33, 98, 97, 100, 210, 26, 15, 20, 13, 
+55, 234, 197, 195, 179, 232, 14, 253, 253, 0, 0, 0, 2, 20, 98, 97, 100, 32, 96, 108, 105, 
+110, 107, 39, 32, 101, 108, 101, 109, 101, 110, 116, 126, 97, 186, 185, 61, 126, 232, 14, 3, 57, 
+130, 20, 21, 4, 18, 5, 213, 40, 40, 22, 22, 23, 16, 58, 3, 55, 77, 56, 127, 56, 127, 
+231, 14, 43, 184, 56, 127, 61, 126, 231, 14, 35, 231, 14, 45, 186, 56, 127, 175, 175, 232, 178, 
+2, 31, 58, 32, 108, 105, 110, 107, 32, 116, 97, 103, 32, 105, 115, 32, 110, 111, 116, 32, 97, 
+110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 186, 56, 127, 61, 126, 56, 127, 231, 14, 
+43, 231, 14, 46, 186, 232, 14, 253, 37, 1, 0, 0, 231, 14, 67, 187, 13, 31, 58, 7, 56, 
+127, 175, 175, 232, 178, 2, 14, 58, 32, 101, 120, 112, 101, 99, 116, 101, 100, 32, 34, 58, 34, 
+186, 56, 127, 61, 126, 231, 14, 43, 231, 14, 69, 186, 56, 127, 175, 175, 232, 178, 2, 20, 58, 
+32, 101, 120, 112, 101, 99, 116, 101, 100, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 186, 56, 
+127, 61, 126, 231, 14, 43, 231, 14, 77, 186, 56, 127, 175, 175, 232, 178, 2, 36, 58, 32, 101, 
+120, 112, 101, 99, 116, 101, 100, 32, 117, 110, 105, 116, 32, 101, 120, 112, 114, 101, 115, 115, 105, 
+111, 110, 32, 97, 110, 100, 32, 108, 105, 110, 107, 115, 186, 56, 127, 61, 126, 231, 14, 49, 231, 
+14, 78, 186, 56, 127, 175, 175, 232, 178, 2, 33, 58, 32, 101, 120, 116, 114, 97, 32, 101, 120, 
+112, 114, 101, 115, 115, 105, 111, 110, 115, 32, 105, 110, 32, 115, 117, 98, 45, 99, 108, 97, 117, 
+115, 101, 186, 56, 127, 61, 126, 231, 14, 43, 231, 14, 79, 186, 56, 127, 175, 175, 232, 178, 2, 
+44, 58, 32, 117, 110, 105, 116, 32, 101, 120, 112, 114, 101, 115, 115, 105, 111, 110, 32, 97, 110, 
+100, 32, 108, 105, 110, 107, 115, 32, 110, 111, 116, 32, 97, 32, 115, 117, 98, 45, 99, 108, 97, 
+117, 115, 101, 186, 61, 126, 231, 14, 50, 231, 14, 80, 231, 14, 46, 187, 56, 127, 175, 175, 232, 
+178, 2, 37, 58, 32, 117, 110, 105, 116, 32, 101, 120, 112, 114, 101, 115, 115, 105, 111, 110, 32, 
+97, 110, 100, 32, 108, 105, 110, 107, 32, 115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 186, 7, 
+7, 7, 7, 7, 7, 7, 230, 14, 13, 232, 177, 2, 0, 185, 234, 200, 231, 14, 45, 188, 234, 
+202, 200, 184, 7, 231, 14, 76, 15, 17, 231, 14, 83, 231, 14, 46, 189, 231, 14, 80, 231, 14, 
+46, 189, 231, 14, 68, 180, 61, 126, 231, 14, 46, 179, 61, 126, 14, 42, 61, 126, 181, 61, 126, 
+57, 130, 20, 22, 26, 39, 102, 105, 110, 100, 45, 108, 105, 110, 107, 207, 44, 44, 59, 127, 21, 
+7, 60, 78, 21, 231, 176, 180, 57, 130, 20, 21, 29, 34, 108, 111, 111, 112, 209, 1, 1, 3, 
+0, 56, 127, 231, 14, 49, 180, 7, 56, 127, 232, 14, 253, 37, 1, 0, 0, 178, 231, 195, 231, 
+14, 45, 183, 231, 14, 45, 180, 231, 176, 231, 14, 46, 181, 61, 126, 57, 130, 20, 22, 28, 38, 
+102, 105, 110, 100, 45, 115, 105, 103, 209, 13, 13, 11, 11, 59, 127, 21, 7, 60, 78, 21, 231, 
+176, 182, 57, 130, 20, 21, 4, 11, 34, 108, 111, 111, 112, 211, 3, 3, 4, 1, 5, 0, 56, 
+127, 231, 14, 49, 182, 7, 56, 127, 56, 127, 231, 193, 231, 14, 45, 183, 232, 14, 253, 37, 1, 
+0, 0, 178, 231, 197, 231, 14, 45, 185, 7, 231, 14, 45, 182, 231, 176, 231, 14, 46, 183, 61, 
+126, 57, 130, 20, 24, 4, 45, 42, 102, 108, 97, 116, 116, 101, 110, 45, 112, 97, 116, 104, 17, 
+26, 48, 48, 46, 46, 47, 40, 30, 30, 26, 26, 33, 22, 27, 20, 18, 18, 16, 16, 14, 14, 
+62, 1, 2, 3, 4, 6, 59, 127, 22, 7, 60, 79, 22, 59, 127, 22, 7, 58, 129, 22, 20, 
+7, 56, 127, 231, 14, 35, 15, 32, 232, 14, 8, 231, 14, 51, 15, 34, 7, 56, 127, 56, 127, 
+231, 14, 43, 15, 32, 56, 127, 231, 14, 35, 231, 14, 45, 15, 33, 56, 127, 231, 14, 43, 231, 
+14, 46, 15, 33, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 67, 15, 34, 13, 31, 58, 
+56, 127, 231, 14, 43, 231, 14, 69, 15, 33, 231, 14, 49, 231, 14, 77, 15, 33, 7, 7, 7, 
+7, 7, 232, 14, 8, 231, 14, 51, 231, 14, 45, 15, 35, 234, 16, 26, 16, 22, 15, 15, 7, 
+231, 14, 76, 15, 38, 56, 127, 56, 127, 231, 14, 43, 15, 32, 56, 127, 231, 14, 50, 231, 14, 
+45, 15, 33, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 49, 231, 14, 45, 15, 34, 56, 
+127, 232, 14, 5, 57, 130, 20, 21, 24, 5, 205, 56, 127, 231, 14, 35, 176, 231, 14, 253, 35, 
+1, 0, 0, 232, 14, 253, 37, 1, 0, 0, 178, 13, 31, 58, 7, 231, 14, 45, 15, 34, 56, 
+127, 231, 14, 43, 231, 14, 46, 15, 33, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 67, 
+15, 34, 13, 31, 58, 56, 127, 231, 14, 43, 231, 14, 69, 15, 33, 231, 14, 49, 231, 14, 77, 
+15, 33, 7, 7, 7, 7, 7, 7, 7, 232, 14, 8, 231, 14, 45, 15, 34, 234, 16, 26, 16, 
+22, 15, 15, 7, 231, 14, 76, 15, 38, 56, 127, 56, 127, 231, 14, 43, 15, 32, 56, 127, 231, 
+14, 50, 15, 32, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 49, 231, 14, 45, 15, 34, 
+232, 14, 5, 57, 130, 20, 21, 24, 5, 205, 56, 127, 231, 14, 35, 176, 231, 14, 253, 35, 1, 
+0, 0, 232, 14, 253, 37, 1, 0, 0, 178, 13, 31, 58, 7, 15, 33, 7, 7, 7, 232, 14, 
+8, 15, 33, 7, 234, 16, 22, 16, 20, 188, 232, 14, 253, 253, 0, 0, 0, 2, 13, 98, 97, 
+100, 32, 96, 126, 97, 39, 32, 112, 97, 116, 104, 15, 36, 15, 35, 56, 127, 56, 127, 231, 14, 
+49, 231, 14, 46, 177, 232, 14, 60, 231, 14, 45, 178, 182, 7, 61, 126, 231, 14, 45, 177, 233, 
+15, 36, 7, 178, 178, 61, 126, 232, 185, 231, 14, 45, 179, 182, 56, 127, 175, 61, 126, 176, 236, 
+186, 231, 16, 35, 182, 231, 14, 45, 184, 184, 7, 231, 16, 37, 182, 231, 14, 46, 184, 61, 126, 
+232, 187, 231, 14, 45, 180, 185, 56, 127, 175, 61, 126, 176, 61, 126, 231, 14, 38, 231, 16, 16, 
+178, 236, 188, 7, 231, 14, 45, 186, 186, 181, 182, 231, 14, 46, 186, 234, 16, 24, 16, 22, 15, 
+15, 233, 14, 253, 253, 0, 0, 0, 2, 29, 98, 97, 100, 32, 96, 126, 97, 39, 32, 112, 97, 
+116, 104, 58, 32, 34, 126, 97, 34, 32, 110, 111, 116, 32, 102, 111, 117, 110, 100, 15, 39, 231, 
+14, 45, 185, 15, 37, 57, 130, 20, 22, 4, 12, 39, 99, 104, 101, 99, 107, 45, 115, 105, 103, 
+214, 20, 20, 16, 16, 14, 14, 10, 10, 7, 56, 127, 185, 230, 231, 14, 10, 57, 130, 20, 21, 
+4, 18, 5, 216, 9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 10, 61, 126, 231, 14, 51, 232, 
+14, 44, 14, 253, 51, 2, 0, 0, 57, 130, 20, 21, 4, 10, 5, 210, 11, 11, 9, 9, 6, 
+233, 196, 194, 178, 231, 14, 253, 113, 1, 0, 0, 184, 61, 126, 232, 14, 253, 250, 2, 0, 0, 
+230, 14, 253, 6, 3, 0, 0, 14, 253, 240, 2, 0, 0, 61, 126, 230, 176, 233, 14, 21, 57, 
+130, 20, 20, 24, 5, 208, 17, 5, 4, 231, 176, 57, 130, 20, 21, 26, 5, 207, 3, 2, 231, 
+177, 59, 127, 21, 7, 60, 78, 21, 231, 176, 178, 57, 130, 20, 21, 25, 33, 103, 52, 54, 207, 
+4, 0, 56, 127, 231, 14, 49, 178, 57, 130, 20, 20, 22, 5, 206, 1, 231, 14, 253, 242, 2, 
+0, 0, 176, 56, 127, 231, 231, 14, 66, 179, 177, 57, 130, 20, 20, 24, 5, 207, 1, 2, 231, 
+231, 14, 68, 177, 177, 231, 176, 231, 14, 46, 179, 57, 130, 20, 20, 4, 11, 5, 214, 15, 15, 
+11, 11, 9, 9, 7, 6, 17, 232, 14, 7, 57, 130, 20, 20, 4, 17, 5, 213, 10, 9, 8, 
+7, 6, 5, 4, 3, 236, 14, 253, 111, 1, 0, 0, 200, 7, 232, 14, 253, 253, 0, 0, 0, 
+2, 12, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 126, 115, 231, 201, 185, 231, 203, 183, 232, 
+14, 253, 253, 0, 0, 0, 2, 12, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 126, 115, 231, 
+201, 184, 231, 203, 182, 57, 130, 21, 21, 23, 5, 206, 2, 231, 176, 57, 130, 20, 20, 23, 5, 
+206, 2, 232, 14, 2, 14, 8, 177, 57, 130, 20, 20, 23, 5, 207, 3, 4, 231, 176, 177, 53, 
+76, 31, 118, 57, 130, 20, 26, 4, 36, 45, 102, 108, 97, 116, 116, 101, 110, 45, 115, 117, 98, 
+112, 97, 116, 104, 223, 22, 22, 16, 16, 14, 14, 12, 12, 11, 8, 7, 6, 31, 30, 29, 28, 
+1, 0, 56, 127, 231, 14, 49, 15, 24, 55, 77, 232, 177, 15, 24, 15, 22, 234, 184, 15, 22, 
+15, 23, 15, 25, 56, 127, 15, 24, 15, 24, 15, 26, 56, 127, 61, 126, 231, 14, 253, 35, 1, 
+0, 0, 231, 14, 43, 15, 26, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 35, 
+231, 14, 45, 15, 27, 234, 16, 18, 16, 16, 186, 232, 14, 253, 253, 0, 0, 0, 2, 13, 98, 
+97, 100, 32, 96, 126, 97, 39, 32, 112, 97, 116, 104, 183, 182, 56, 127, 232, 14, 60, 231, 14, 
+45, 15, 26, 231, 16, 19, 15, 25, 56, 127, 56, 127, 231, 14, 49, 231, 14, 46, 15, 25, 231, 
+14, 253, 35, 1, 0, 0, 15, 21, 7, 61, 126, 231, 14, 45, 15, 25, 61, 126, 56, 127, 15, 
+23, 231, 14, 36, 233, 14, 248, 15, 27, 2, 1, 58, 231, 14, 38, 181, 176, 233, 184, 15, 23, 
+178, 179, 234, 16, 18, 16, 16, 186, 233, 14, 253, 253, 0, 0, 0, 2, 33, 98, 97, 100, 32, 
+96, 126, 97, 39, 32, 112, 97, 116, 104, 58, 32, 34, 126, 97, 34, 32, 105, 115, 32, 97, 32, 
+118, 97, 114, 105, 97, 98, 108, 101, 184, 231, 14, 45, 15, 31, 182, 61, 126, 232, 184, 231, 14, 
+45, 15, 27, 231, 204, 15, 26, 56, 127, 175, 61, 126, 176, 236, 184, 15, 26, 231, 14, 45, 15, 
+32, 15, 28, 61, 126, 231, 14, 38, 231, 16, 19, 184, 56, 127, 15, 30, 233, 14, 248, 15, 33, 
+2, 1, 58, 178, 175, 181, 231, 14, 46, 15, 32, 234, 16, 19, 16, 17, 187, 233, 14, 253, 253, 
+0, 0, 0, 2, 29, 98, 97, 100, 32, 96, 126, 97, 39, 32, 112, 97, 116, 104, 58, 32, 34, 
+126, 97, 34, 32, 110, 111, 116, 32, 102, 111, 117, 110, 100, 185, 231, 14, 45, 15, 32, 183, 55, 
+82, 232, 16, 30, 232, 14, 3, 16, 50, 185, 57, 130, 20, 21, 4, 11, 5, 210, 35, 24, 29, 
+22, 64, 233, 196, 194, 178, 232, 14, 253, 253, 0, 0, 0, 2, 27, 100, 117, 112, 108, 105, 99, 
+97, 116, 101, 32, 115, 117, 98, 45, 117, 110, 105, 116, 32, 116, 97, 103, 32, 34, 126, 115, 34, 
+185, 232, 16, 30, 232, 14, 54, 232, 14, 3, 16, 20, 15, 15, 232, 14, 3, 16, 52, 187, 57, 
+130, 20, 21, 4, 11, 5, 210, 35, 24, 29, 22, 64, 233, 196, 194, 178, 232, 14, 253, 253, 0, 
+0, 0, 2, 48, 110, 97, 109, 101, 32, 34, 126, 115, 34, 32, 105, 115, 32, 98, 111, 116, 104, 
+32, 105, 109, 112, 111, 114, 116, 32, 97, 110, 100, 32, 115, 117, 98, 45, 117, 110, 105, 116, 32, 
+105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 185, 232, 14, 4, 57, 130, 20, 21, 4, 17, 5, 
+216, 58, 58, 56, 56, 54, 54, 38, 38, 39, 26, 2, 232, 199, 188, 232, 14, 3, 57, 130, 20, 
+21, 4, 12, 5, 212, 14, 13, 8, 7, 6, 5, 4, 234, 179, 13, 34, 108, 105, 110, 107, 186, 
+57, 130, 20, 23, 4, 10, 5, 207, 10, 9, 232, 192, 180, 231, 14, 51, 56, 127, 180, 232, 14, 
+51, 182, 183, 181, 57, 130, 20, 24, 4, 17, 5, 211, 10, 9, 8, 7, 6, 5, 232, 196, 232, 
+194, 188, 186, 56, 127, 183, 231, 14, 51, 232, 14, 44, 186, 232, 199, 15, 15, 15, 16, 232, 196, 
+187, 188, 231, 200, 15, 16, 183, 56, 127, 56, 127, 231, 14, 43, 181, 56, 127, 231, 14, 43, 231, 
+14, 45, 182, 232, 14, 253, 37, 1, 0, 0, 13, 36, 101, 120, 112, 111, 114, 116, 231, 14, 66, 
+183, 7, 7, 230, 14, 13, 233, 16, 25, 16, 23, 15, 65, 2, 24, 101, 120, 112, 101, 99, 116, 
+101, 100, 32, 96, 101, 120, 112, 111, 114, 116, 39, 32, 99, 108, 97, 117, 115, 101, 56, 127, 231, 
+14, 50, 231, 14, 45, 182, 230, 14, 13, 233, 16, 25, 16, 23, 15, 65, 2, 24, 98, 97, 100, 
+32, 96, 101, 120, 112, 111, 114, 116, 39, 32, 99, 108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 
+56, 127, 231, 14, 49, 231, 14, 46, 182, 230, 14, 13, 233, 16, 25, 16, 23, 15, 65, 2, 38, 
+97, 110, 111, 116, 104, 101, 114, 32, 99, 108, 97, 117, 115, 101, 32, 102, 111, 108, 108, 111, 119, 
+115, 32, 96, 101, 120, 112, 111, 114, 116, 39, 32, 99, 108, 97, 117, 115, 101, 61, 126, 57, 130, 
+20, 21, 24, 36, 117, 112, 97, 116, 104, 63, 205, 61, 126, 231, 14, 35, 177, 56, 127, 175, 175, 
+56, 127, 231, 14, 50, 177, 232, 14, 5, 14, 35, 178, 7, 61, 126, 232, 14, 3, 57, 130, 20, 
+21, 4, 26, 5, 220, 60, 60, 40, 40, 28, 28, 26, 26, 24, 24, 22, 22, 66, 4, 3, 56, 
+127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 14, 50, 15, 18, 56, 127, 175, 175, 61, 126, 
+231, 14, 253, 35, 1, 0, 0, 233, 14, 119, 22, 231, 14, 53, 15, 22, 23, 56, 127, 175, 175, 
+231, 14, 253, 35, 1, 0, 0, 61, 126, 231, 14, 49, 231, 14, 69, 15, 21, 56, 127, 175, 175, 
+56, 127, 231, 14, 43, 231, 14, 69, 15, 21, 231, 14, 49, 231, 14, 77, 15, 21, 7, 234, 201, 
+199, 181, 2, 23, 98, 97, 100, 32, 96, 101, 120, 112, 111, 114, 116, 39, 32, 115, 117, 98, 45, 
+99, 108, 97, 117, 115, 101, 15, 19, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 15, 
+18, 13, 34, 111, 112, 101, 110, 61, 126, 231, 14, 46, 15, 17, 55, 77, 56, 127, 56, 127, 231, 
+14, 43, 176, 56, 127, 231, 177, 231, 14, 45, 177, 231, 14, 49, 231, 14, 46, 177, 7, 7, 230, 
+14, 13, 234, 202, 200, 182, 2, 33, 98, 97, 100, 32, 96, 111, 112, 101, 110, 39, 32, 115, 117, 
+98, 45, 99, 108, 97, 117, 115, 101, 32, 111, 102, 32, 96, 101, 120, 112, 111, 114, 116, 39, 15, 
+20, 234, 181, 13, 36, 101, 120, 112, 111, 114, 116, 231, 14, 45, 180, 57, 130, 20, 23, 4, 14, 
+5, 211, 12, 12, 10, 10, 7, 20, 234, 198, 196, 180, 2, 36, 96, 111, 112, 101, 110, 39, 32, 
+115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 32, 112, 97, 116, 104, 32, 105, 115, 32, 97, 32, 
+118, 97, 114, 105, 97, 98, 108, 101, 231, 14, 45, 180, 57, 130, 20, 24, 4, 25, 5, 217, 18, 
+18, 16, 16, 12, 12, 10, 10, 8, 8, 7, 20, 56, 127, 187, 232, 202, 231, 195, 15, 18, 232, 
+14, 44, 15, 16, 233, 14, 3, 14, 51, 232, 16, 17, 15, 23, 15, 24, 232, 16, 17, 7, 15, 
+24, 234, 200, 198, 180, 2, 32, 99, 97, 110, 110, 111, 116, 32, 101, 120, 112, 111, 114, 116, 32, 
+105, 109, 112, 111, 114, 116, 101, 100, 32, 118, 97, 114, 105, 97, 98, 108, 101, 115, 179, 56, 127, 
+232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 15, 18, 13, 33, 118, 97, 114, 61, 126, 231, 14, 
+46, 15, 17, 55, 77, 56, 127, 56, 127, 231, 14, 43, 176, 56, 127, 231, 14, 43, 231, 14, 45, 
+177, 56, 127, 231, 177, 231, 14, 66, 177, 56, 127, 231, 14, 43, 231, 14, 68, 177, 56, 127, 231, 
+14, 49, 231, 14, 75, 177, 56, 127, 231, 14, 35, 231, 14, 72, 177, 61, 126, 231, 14, 49, 231, 
+14, 46, 178, 56, 127, 175, 175, 56, 127, 231, 14, 43, 231, 14, 46, 178, 56, 127, 231, 14, 35, 
+231, 14, 67, 178, 231, 14, 49, 231, 14, 69, 178, 7, 7, 7, 7, 7, 7, 7, 7, 230, 14, 
+13, 234, 202, 200, 182, 2, 32, 98, 97, 100, 32, 96, 118, 97, 114, 39, 32, 115, 117, 98, 45, 
+99, 108, 97, 117, 115, 101, 32, 111, 102, 32, 96, 101, 120, 112, 111, 114, 116, 39, 15, 20, 234, 
+181, 13, 36, 101, 120, 112, 111, 114, 116, 61, 126, 231, 14, 66, 181, 61, 126, 231, 14, 72, 182, 
+56, 127, 231, 14, 35, 177, 232, 14, 51, 178, 177, 232, 14, 54, 178, 231, 14, 51, 178, 57, 130, 
+20, 23, 4, 19, 5, 214, 18, 18, 12, 12, 10, 10, 7, 20, 4, 56, 127, 184, 232, 199, 231, 
+14, 51, 56, 127, 231, 14, 49, 231, 14, 46, 180, 189, 231, 14, 67, 179, 232, 14, 51, 188, 56, 
+127, 231, 14, 49, 231, 14, 46, 181, 232, 14, 51, 15, 16, 15, 17, 232, 14, 51, 15, 16, 231, 
+14, 67, 182, 234, 199, 197, 181, 2, 34, 99, 97, 110, 110, 111, 116, 32, 101, 120, 112, 111, 114, 
+116, 101, 100, 32, 105, 109, 112, 111, 114, 116, 101, 100, 32, 118, 97, 114, 105, 97, 98, 108, 101, 
+115, 231, 14, 45, 181, 57, 130, 20, 24, 4, 14, 5, 211, 12, 12, 10, 10, 7, 20, 234, 198, 
+196, 180, 2, 38, 96, 118, 97, 114, 39, 32, 115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 32, 
+112, 97, 116, 104, 32, 115, 112, 101, 99, 105, 102, 105, 101, 115, 32, 97, 32, 117, 110, 105, 116, 
+179, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 15, 18, 13, 34, 117, 110, 105, 116, 
+61, 126, 231, 14, 46, 15, 17, 55, 77, 56, 127, 56, 127, 231, 14, 43, 176, 56, 127, 231, 177, 
+231, 14, 45, 177, 61, 126, 231, 14, 49, 231, 14, 46, 178, 56, 127, 175, 175, 56, 127, 231, 14, 
+43, 231, 14, 46, 178, 56, 127, 231, 14, 35, 231, 14, 67, 178, 231, 14, 49, 231, 14, 69, 178, 
+7, 7, 7, 7, 230, 14, 13, 234, 202, 200, 182, 2, 33, 98, 97, 100, 32, 96, 117, 110, 105, 
+116, 39, 32, 115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 32, 111, 102, 32, 96, 101, 120, 112, 
+111, 114, 116, 39, 15, 20, 234, 181, 13, 36, 101, 120, 112, 111, 114, 116, 231, 14, 45, 180, 57, 
+130, 20, 23, 4, 14, 5, 211, 12, 12, 10, 10, 7, 20, 234, 198, 196, 180, 2, 36, 96, 117, 
+110, 105, 116, 39, 32, 115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 32, 112, 97, 116, 104, 32, 
+105, 115, 32, 97, 32, 118, 97, 114, 105, 97, 98, 108, 101, 231, 14, 45, 180, 57, 130, 20, 24, 
+4, 30, 5, 218, 18, 18, 16, 16, 14, 14, 12, 12, 10, 10, 7, 20, 4, 56, 127, 188, 232, 
+203, 231, 14, 51, 232, 202, 15, 21, 56, 127, 231, 14, 49, 231, 14, 46, 182, 15, 19, 231, 14, 
+67, 181, 61, 126, 232, 204, 15, 20, 15, 21, 232, 14, 44, 15, 18, 233, 14, 3, 14, 51, 180, 
+232, 16, 19, 231, 14, 38, 56, 127, 231, 14, 49, 231, 14, 46, 188, 15, 25, 231, 14, 67, 187, 
+15, 26, 234, 199, 197, 181, 2, 34, 99, 97, 110, 110, 111, 116, 32, 101, 120, 112, 111, 114, 116, 
+101, 100, 32, 105, 109, 112, 111, 114, 116, 101, 100, 32, 118, 97, 114, 105, 97, 98, 108, 101, 115, 
+180, 234, 201, 199, 181, 231, 14, 253, 253, 0, 0, 0, 2, 23, 98, 97, 100, 32, 96, 101, 120, 
+112, 111, 114, 116, 39, 32, 115, 117, 98, 45, 99, 108, 97, 117, 115, 101, 15, 19, 231, 14, 68, 
+185, 55, 77, 232, 16, 32, 232, 14, 3, 57, 130, 20, 21, 26, 5, 209, 20, 20, 18, 18, 56, 
+127, 231, 191, 180, 231, 193, 180, 179, 232, 14, 2, 14, 54, 232, 14, 3, 16, 68, 183, 57, 130, 
+20, 21, 4, 11, 5, 210, 26, 26, 24, 24, 66, 233, 196, 194, 178, 232, 14, 253, 253, 0, 0, 
+0, 2, 31, 116, 104, 101, 32, 110, 97, 109, 101, 32, 34, 126, 115, 34, 32, 105, 115, 32, 101, 
+120, 112, 111, 114, 116, 101, 100, 32, 116, 119, 105, 99, 101, 185, 232, 14, 44, 13, 35, 35, 37, 
+108, 101, 116, 232, 14, 44, 232, 14, 3, 57, 130, 20, 21, 28, 5, 209, 58, 58, 54, 54, 232, 
+14, 51, 231, 193, 182, 231, 195, 182, 189, 232, 14, 44, 232, 14, 44, 13, 1, 32, 35, 37, 118, 
+101, 114, 105, 102, 121, 45, 108, 105, 110, 107, 97, 103, 101, 45, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 45, 109, 97, 116, 99, 104, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 
+116, 101, 232, 14, 44, 16, 36, 5, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 
+116, 101, 232, 14, 44, 232, 14, 3, 16, 66, 15, 26, 5, 232, 14, 44, 232, 14, 44, 13, 36, 
+35, 37, 108, 105, 115, 116, 232, 14, 54, 232, 14, 3, 16, 68, 15, 28, 5, 232, 14, 44, 232, 
+14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 232, 14, 3, 57, 130, 20, 21, 
+27, 5, 209, 72, 72, 54, 54, 231, 191, 231, 194, 181, 15, 30, 5, 232, 14, 44, 232, 14, 44, 
+13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 232, 14, 3, 57, 130, 20, 21, 4, 10, 
+5, 211, 84, 84, 78, 78, 69, 58, 232, 14, 3, 57, 130, 20, 21, 27, 5, 209, 7, 6, 3, 
+2, 231, 191, 231, 194, 181, 231, 195, 184, 15, 32, 5, 5, 232, 14, 44, 232, 14, 44, 13, 1, 
+26, 35, 37, 109, 97, 107, 101, 45, 117, 110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 232, 14, 44, 232, 14, 44, 13, 45, 35, 37, 99, 111, 109, 112, 111, 
+117, 110, 100, 45, 117, 110, 105, 116, 232, 14, 44, 232, 14, 44, 13, 36, 105, 109, 112, 111, 114, 
+116, 232, 14, 54, 231, 16, 61, 15, 32, 5, 232, 14, 44, 232, 14, 44, 13, 34, 108, 105, 110, 
+107, 232, 14, 54, 232, 14, 3, 57, 130, 20, 21, 4, 16, 5, 211, 86, 86, 78, 78, 72, 72, 
+232, 14, 51, 231, 193, 184, 232, 14, 44, 232, 14, 44, 13, 1, 26, 35, 37, 117, 110, 105, 116, 
+45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 117, 110, 105, 116, 232, 
+14, 44, 231, 199, 15, 15, 5, 232, 14, 2, 14, 54, 232, 14, 3, 202, 231, 201, 15, 15, 15, 
+32, 5, 232, 14, 44, 232, 14, 44, 13, 36, 101, 120, 112, 111, 114, 116, 232, 14, 54, 232, 14, 
+3, 16, 88, 15, 26, 5, 5, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 
+101, 232, 14, 44, 231, 16, 55, 15, 30, 5, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 
+117, 111, 116, 101, 232, 14, 44, 231, 16, 53, 234, 16, 37, 13, 35, 100, 117, 109, 109, 121, 13, 
+35, 100, 117, 109, 109, 121, 7, 232, 14, 2, 14, 54, 232, 14, 3, 16, 89, 15, 29, 5, 5, 
+5, 21, 49, 112, 97, 114, 115, 101, 45, 99, 111, 109, 112, 111, 117, 110, 100, 45, 117, 110, 105, 
+116, 4, 74, 7, 20, 53, 126, 31, 107, 12, 76, 81, 20, 22, 46, 115, 105, 103, 45, 101, 120, 
+112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 5, 37, 115, 105, 103, 112, 97, 114, 116, 38, 101, 
+120, 112, 108, 111, 100, 101, 100, 27, 1, 23, 115, 116, 114, 117, 99, 116, 58, 115, 105, 103, 45, 
+101, 120, 112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 4, 67, 7, 1, 21, 109, 97, 107, 101, 
+45, 115, 105, 103, 45, 101, 120, 112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 4, 68, 7, 47, 
+115, 105, 103, 45, 101, 120, 112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 63, 4, 69, 7, 1, 
+24, 115, 105, 103, 45, 101, 120, 112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 45, 115, 105, 103, 
+112, 97, 114, 116, 4, 70, 7, 1, 29, 115, 101, 116, 45, 115, 105, 103, 45, 101, 120, 112, 108, 
+111, 100, 101, 45, 112, 97, 105, 114, 45, 115, 105, 103, 112, 97, 114, 116, 33, 4, 71, 7, 1, 
+25, 115, 105, 103, 45, 101, 120, 112, 108, 111, 100, 101, 45, 112, 97, 105, 114, 45, 101, 120, 112, 
+108, 111, 100, 101, 100, 4, 72, 7, 1, 30, 115, 101, 116, 45, 115, 105, 103, 45, 101, 120, 112, 
+108, 111, 100, 101, 45, 112, 97, 105, 114, 45, 101, 120, 112, 108, 111, 100, 101, 100, 33, 4, 73, 
+7, 20, 53, 126, 31, 107, 12, 76, 83, 20, 24, 34, 108, 105, 110, 107, 5, 34, 110, 97, 109, 
+101, 33, 115, 105, 103, 34, 101, 120, 112, 114, 35, 108, 105, 110, 107, 115, 4, 11, 41, 115, 116, 
+114, 117, 99, 116, 58, 108, 105, 110, 107, 4, 56, 7, 39, 109, 97, 107, 101, 45, 108, 105, 110, 
+107, 4, 57, 7, 35, 108, 105, 110, 107, 63, 4, 58, 7, 39, 108, 105, 110, 107, 45, 110, 97, 
+109, 101, 4, 59, 7, 44, 115, 101, 116, 45, 108, 105, 110, 107, 45, 110, 97, 109, 101, 33, 4, 
+60, 7, 38, 108, 105, 110, 107, 45, 115, 105, 103, 4, 61, 7, 43, 115, 101, 116, 45, 108, 105, 
+110, 107, 45, 115, 105, 103, 33, 4, 62, 7, 39, 108, 105, 110, 107, 45, 101, 120, 112, 114, 4, 
+63, 7, 44, 115, 101, 116, 45, 108, 105, 110, 107, 45, 101, 120, 112, 114, 33, 4, 64, 7, 40, 
+108, 105, 110, 107, 45, 108, 105, 110, 107, 115, 4, 65, 7, 45, 115, 101, 116, 45, 108, 105, 110, 
+107, 45, 108, 105, 110, 107, 115, 33, 4, 66, 7, 20, 57, 130, 21, 21, 4, 51, 49, 117, 110, 
+105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 17, 28, 135, 54, 
+133, 52, 132, 51, 130, 49, 126, 45, 123, 42, 121, 40, 117, 36, 112, 31, 111, 30, 105, 24, 101, 
+20, 97, 16, 95, 14, 61, 126, 232, 14, 44, 199, 15, 31, 55, 77, 56, 127, 231, 14, 43, 15, 
+30, 230, 14, 13, 233, 204, 200, 178, 2, 13, 105, 109, 112, 114, 111, 112, 101, 114, 32, 102, 111, 
+114, 109, 61, 126, 234, 16, 18, 202, 180, 7, 231, 14, 45, 15, 35, 61, 126, 231, 14, 46, 15, 
+32, 61, 126, 232, 16, 32, 180, 178, 55, 77, 235, 16, 33, 182, 180, 231, 202, 181, 16, 15, 183, 
+231, 203, 232, 14, 44, 13, 1, 26, 35, 37, 109, 97, 107, 101, 45, 117, 110, 105, 116, 45, 119, 
+105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 232, 14, 44, 232, 14, 44, 13, 36, 
+35, 37, 117, 110, 105, 116, 232, 14, 44, 232, 14, 44, 13, 36, 105, 109, 112, 111, 114, 116, 232, 
+14, 54, 231, 16, 36, 231, 16, 19, 15, 15, 5, 232, 14, 44, 232, 14, 44, 13, 36, 101, 120, 
+112, 111, 114, 116, 232, 14, 54, 232, 14, 3, 57, 130, 20, 21, 4, 11, 5, 210, 43, 43, 26, 
+23, 17, 232, 14, 51, 232, 197, 184, 231, 196, 180, 182, 231, 16, 42, 15, 20, 5, 232, 14, 54, 
+231, 14, 57, 231, 16, 23, 15, 15, 5, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 
+111, 116, 101, 232, 14, 44, 231, 16, 32, 231, 16, 17, 188, 5, 232, 14, 44, 232, 14, 44, 13, 
+37, 35, 37, 113, 117, 111, 116, 101, 232, 14, 44, 231, 16, 32, 15, 16, 5, 5, 21, 49, 117, 
+110, 105, 116, 45, 119, 105, 116, 104, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 55, 7, 
+20, 57, 130, 20, 22, 4, 21, 40, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 215, 134, 53, 
+118, 37, 112, 31, 105, 24, 93, 12, 55, 77, 56, 127, 56, 127, 231, 14, 43, 187, 56, 127, 231, 
+14, 43, 231, 14, 45, 188, 232, 14, 253, 37, 1, 0, 0, 13, 36, 105, 109, 112, 111, 114, 116, 
+231, 14, 66, 189, 7, 7, 230, 14, 13, 233, 197, 195, 188, 2, 24, 101, 120, 112, 101, 99, 116, 
+101, 100, 32, 96, 105, 109, 112, 111, 114, 116, 39, 32, 99, 108, 97, 117, 115, 101, 61, 126, 235, 
+204, 198, 6, 6, 15, 16, 231, 14, 68, 15, 18, 61, 126, 231, 14, 46, 189, 59, 127, 22, 7, 
+58, 129, 22, 20, 7, 56, 127, 56, 127, 231, 14, 43, 178, 56, 127, 231, 14, 43, 231, 14, 45, 
+179, 232, 14, 253, 37, 1, 0, 0, 13, 36, 114, 101, 110, 97, 109, 101, 231, 14, 66, 180, 7, 
+7, 232, 14, 8, 231, 14, 46, 231, 14, 45, 181, 231, 14, 46, 180, 232, 14, 8, 14, 42, 179, 
+55, 78, 61, 126, 57, 130, 20, 22, 4, 13, 33, 98, 97, 100, 210, 9, 9, 7, 7, 15, 234, 
+197, 195, 179, 232, 14, 253, 253, 0, 0, 0, 2, 21, 98, 97, 100, 32, 96, 114, 101, 110, 97, 
+109, 101, 39, 32, 99, 108, 97, 117, 115, 101, 126, 97, 186, 185, 232, 14, 4, 57, 130, 20, 21, 
+25, 5, 206, 2, 56, 127, 56, 127, 231, 14, 43, 177, 56, 127, 231, 14, 43, 231, 14, 46, 178, 
+56, 127, 231, 14, 49, 231, 14, 69, 178, 56, 127, 61, 126, 231, 14, 35, 231, 14, 45, 179, 56, 
+127, 175, 175, 232, 178, 2, 29, 58, 32, 115, 111, 117, 114, 99, 101, 32, 105, 115, 32, 110, 111, 
+116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 179, 61, 126, 231, 14, 35, 
+231, 14, 67, 179, 56, 127, 175, 175, 232, 178, 2, 34, 58, 32, 100, 101, 115, 116, 105, 110, 97, 
+116, 105, 111, 110, 32, 105, 115, 32, 110, 111, 116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 
+102, 105, 101, 114, 179, 7, 7, 7, 7, 230, 14, 13, 232, 177, 2, 0, 178, 178, 232, 202, 232, 
+14, 3, 14, 45, 179, 57, 130, 20, 21, 4, 11, 5, 210, 10, 10, 8, 8, 16, 233, 196, 194, 
+178, 232, 14, 253, 253, 0, 0, 0, 2, 21, 105, 100, 32, 34, 126, 115, 34, 32, 114, 101, 110, 
+97, 109, 101, 100, 32, 116, 119, 105, 99, 101, 185, 59, 127, 21, 7, 60, 78, 21, 234, 179, 181, 
+14, 42, 14, 42, 14, 42, 57, 130, 20, 24, 4, 32, 34, 108, 111, 111, 112, 215, 9, 9, 7, 
+7, 5, 5, 15, 4, 1, 0, 56, 127, 56, 127, 231, 14, 49, 187, 231, 14, 49, 186, 7, 234, 
+198, 181, 180, 15, 17, 15, 16, 56, 127, 56, 127, 231, 14, 49, 187, 231, 14, 253, 35, 1, 0, 
+0, 231, 14, 43, 187, 7, 233, 201, 199, 181, 2, 23, 105, 109, 112, 114, 111, 112, 101, 114, 32, 
+98, 111, 100, 121, 32, 108, 105, 115, 116, 32, 102, 111, 114, 109, 59, 127, 23, 7, 58, 129, 22, 
+20, 7, 231, 14, 253, 44, 1, 0, 0, 56, 127, 231, 14, 49, 15, 16, 231, 14, 45, 15, 15, 
+231, 14, 192, 231, 14, 45, 15, 17, 58, 129, 21, 22, 7, 56, 127, 231, 14, 49, 15, 15, 231, 
+14, 46, 189, 188, 56, 127, 56, 127, 231, 14, 196, 176, 231, 14, 253, 35, 1, 0, 0, 231, 14, 
+49, 15, 16, 7, 233, 14, 8, 15, 16, 15, 18, 15, 19, 56, 127, 232, 14, 253, 37, 1, 0, 
+0, 178, 13, 45, 35, 37, 100, 101, 102, 105, 110, 101, 45, 118, 97, 108, 117, 101, 115, 55, 77, 
+56, 127, 56, 127, 231, 14, 43, 231, 14, 46, 177, 56, 127, 231, 14, 50, 231, 14, 67, 177, 56, 
+127, 231, 14, 43, 231, 14, 69, 177, 56, 127, 231, 14, 49, 231, 14, 77, 177, 232, 14, 5, 14, 
+35, 231, 14, 67, 178, 7, 7, 7, 7, 230, 14, 13, 234, 16, 15, 203, 185, 2, 36, 105, 109, 
+112, 114, 111, 112, 101, 114, 32, 96, 100, 101, 102, 105, 110, 101, 45, 118, 97, 108, 117, 101, 115, 
+39, 32, 99, 108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 179, 61, 126, 231, 14, 67, 177, 234, 
+183, 182, 15, 19, 232, 14, 44, 182, 15, 22, 232, 14, 54, 181, 15, 23, 56, 127, 232, 14, 253, 
+37, 1, 0, 0, 178, 13, 37, 35, 37, 98, 101, 103, 105, 110, 55, 77, 56, 127, 56, 127, 231, 
+14, 43, 231, 14, 46, 177, 231, 14, 50, 231, 14, 46, 177, 7, 230, 14, 13, 234, 16, 15, 203, 
+185, 2, 28, 105, 109, 112, 114, 111, 112, 101, 114, 32, 96, 98, 101, 103, 105, 110, 39, 32, 99, 
+108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 179, 234, 182, 232, 14, 54, 231, 14, 46, 182, 183, 
+15, 18, 15, 19, 15, 20, 56, 127, 56, 127, 231, 14, 43, 176, 232, 14, 253, 37, 1, 0, 0, 
+231, 14, 45, 178, 13, 37, 105, 110, 99, 108, 117, 100, 101, 7, 61, 126, 231, 14, 253, 43, 1, 
+0, 0, 177, 55, 77, 56, 127, 56, 127, 231, 14, 43, 231, 14, 46, 177, 56, 127, 231, 14, 231, 
+231, 14, 67, 177, 231, 14, 49, 231, 14, 69, 177, 7, 7, 230, 14, 13, 234, 16, 16, 204, 186, 
+2, 30, 105, 109, 112, 114, 111, 112, 101, 114, 32, 96, 105, 110, 99, 108, 117, 100, 101, 39, 32, 
+99, 108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 179, 61, 126, 231, 14, 67, 177, 59, 127, 23, 
+7, 58, 129, 23, 20, 7, 231, 14, 253, 46, 3, 0, 0, 179, 55, 77, 56, 127, 177, 233, 16, 
+19, 16, 17, 189, 232, 14, 253, 253, 0, 0, 0, 2, 29, 99, 97, 110, 110, 111, 116, 32, 105, 
+110, 99, 108, 117, 100, 101, 32, 97, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 32, 126, 115, 
+183, 53, 76, 31, 118, 61, 126, 230, 14, 210, 61, 126, 231, 14, 179, 56, 127, 56, 127, 177, 231, 
+14, 253, 35, 1, 0, 0, 231, 14, 253, 49, 3, 0, 0, 183, 7, 232, 14, 253, 50, 3, 0, 
+0, 183, 179, 181, 59, 127, 23, 7, 58, 129, 23, 20, 7, 61, 126, 232, 14, 253, 250, 2, 0, 
+0, 230, 14, 253, 6, 3, 0, 0, 14, 210, 61, 126, 230, 176, 233, 14, 21, 57, 130, 20, 20, 
+26, 5, 208, 10, 9, 4, 231, 176, 56, 127, 231, 14, 231, 179, 56, 127, 231, 14, 253, 49, 3, 
+0, 0, 179, 178, 232, 14, 253, 50, 3, 0, 0, 180, 56, 127, 179, 179, 230, 14, 253, 62, 3, 
+0, 0, 230, 14, 253, 62, 3, 0, 0, 57, 130, 20, 20, 29, 5, 211, 18, 31, 30, 29, 17, 
+8, 233, 14, 21, 14, 13, 57, 130, 20, 20, 4, 12, 5, 211, 8, 7, 6, 5, 4, 3, 234, 
+184, 180, 232, 14, 44, 181, 183, 182, 183, 57, 130, 20, 20, 22, 5, 206, 3, 231, 14, 184, 176, 
+57, 130, 20, 20, 23, 5, 207, 3, 4, 231, 176, 177, 234, 15, 17, 179, 15, 28, 180, 181, 234, 
+182, 181, 15, 18, 232, 14, 44, 181, 15, 21, 15, 20, 21, 40, 112, 97, 114, 115, 101, 45, 117, 
+110, 105, 116, 4, 54, 7, 20, 57, 130, 20, 25, 4, 14, 43, 112, 97, 114, 115, 101, 45, 105, 
+109, 112, 111, 114, 116, 115, 211, 117, 36, 115, 34, 112, 31, 61, 126, 57, 130, 21, 22, 4, 14, 
+33, 98, 97, 100, 210, 1, 1, 10, 9, 7, 235, 14, 2, 198, 180, 182, 232, 14, 253, 253, 0, 
+0, 0, 56, 127, 183, 2, 21, 98, 97, 100, 32, 96, 105, 109, 112, 111, 114, 116, 39, 32, 99, 
+108, 97, 117, 115, 101, 126, 97, 2, 27, 98, 97, 100, 32, 108, 105, 110, 107, 97, 103, 101, 32, 
+115, 112, 101, 99, 105, 102, 105, 99, 97, 116, 105, 111, 110, 126, 97, 187, 186, 55, 77, 56, 127, 
+56, 127, 231, 14, 50, 187, 232, 14, 5, 57, 130, 20, 21, 4, 11, 5, 207, 10, 2, 61, 126, 
+56, 127, 231, 14, 35, 179, 177, 7, 56, 127, 175, 175, 56, 127, 61, 126, 231, 14, 50, 180, 56, 
+127, 175, 175, 232, 179, 2, 10, 58, 32, 98, 97, 100, 32, 105, 116, 101, 109, 181, 61, 126, 56, 
+127, 61, 126, 231, 14, 49, 181, 56, 127, 175, 175, 61, 126, 231, 14, 49, 231, 14, 46, 183, 56, 
+127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 232, 14, 253, 37, 1, 0, 0, 13, 31, 58, 231, 
+14, 67, 185, 178, 7, 56, 127, 175, 175, 61, 126, 56, 127, 232, 14, 116, 231, 14, 53, 183, 23, 
+232, 14, 253, 37, 1, 0, 0, 13, 31, 58, 231, 14, 67, 183, 7, 56, 127, 175, 175, 232, 180, 
+2, 10, 58, 32, 98, 97, 100, 32, 105, 116, 101, 109, 182, 7, 188, 7, 230, 14, 13, 231, 176, 
+2, 0, 232, 14, 3, 57, 130, 20, 21, 4, 13, 5, 211, 7, 7, 5, 5, 12, 9, 56, 127, 
+61, 126, 231, 14, 35, 183, 56, 127, 175, 175, 231, 14, 253, 35, 1, 0, 0, 56, 127, 232, 14, 
+116, 23, 231, 14, 53, 186, 232, 14, 253, 37, 1, 0, 0, 231, 14, 67, 186, 13, 31, 58, 7, 
+232, 194, 234, 200, 181, 182, 7, 187, 7, 234, 198, 179, 180, 231, 14, 45, 186, 231, 14, 76, 186, 
+188, 21, 43, 112, 97, 114, 115, 101, 45, 105, 109, 112, 111, 114, 116, 115, 4, 53, 7, 20, 57, 
+130, 20, 25, 4, 24, 1, 25, 99, 104, 101, 99, 107, 45, 115, 105, 103, 110, 97, 116, 117, 114, 
+101, 45, 117, 110, 105, 116, 45, 98, 111, 100, 121, 217, 132, 51, 131, 50, 130, 49, 112, 31, 99, 
+18, 86, 5, 61, 126, 231, 194, 15, 15, 55, 77, 232, 14, 4, 57, 130, 20, 21, 4, 22, 5, 
+216, 13, 13, 7, 7, 3, 3, 19, 18, 17, 15, 2, 61, 126, 232, 202, 189, 180, 56, 127, 232, 
+14, 60, 177, 178, 230, 14, 13, 233, 201, 182, 183, 234, 14, 253, 253, 0, 0, 0, 2, 39, 115, 
+105, 103, 110, 97, 116, 117, 114, 101, 32, 34, 126, 115, 34, 32, 114, 101, 113, 117, 105, 114, 101, 
+115, 32, 118, 97, 114, 105, 97, 98, 108, 101, 32, 34, 126, 115, 34, 126, 97, 231, 204, 185, 15, 
+19, 56, 127, 232, 14, 253, 37, 1, 0, 0, 15, 21, 184, 2, 0, 232, 14, 253, 253, 0, 0, 
+0, 2, 13, 32, 114, 101, 110, 97, 109, 101, 100, 32, 34, 126, 115, 34, 184, 231, 200, 15, 16, 
+56, 127, 231, 14, 49, 231, 201, 15, 15, 230, 14, 13, 233, 198, 15, 19, 15, 20, 232, 14, 253, 
+253, 0, 0, 0, 2, 33, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 34, 126, 115, 34, 32, 
+114, 101, 113, 117, 105, 114, 101, 115, 32, 115, 117, 98, 45, 117, 110, 105, 116, 115, 231, 197, 15, 
+19, 21, 1, 25, 99, 104, 101, 99, 107, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 117, 
+110, 105, 116, 45, 98, 111, 100, 121, 4, 52, 7, 20, 57, 130, 20, 22, 24, 39, 100, 111, 45, 
+114, 101, 110, 97, 109, 101, 205, 59, 127, 21, 7, 60, 78, 21, 231, 176, 178, 57, 130, 20, 21, 
+26, 34, 108, 111, 111, 112, 207, 1, 0, 56, 127, 231, 14, 49, 178, 176, 56, 127, 232, 14, 253, 
+37, 1, 0, 0, 231, 14, 72, 180, 178, 231, 14, 66, 178, 231, 176, 231, 14, 46, 179, 21, 39, 
+100, 111, 45, 114, 101, 110, 97, 109, 101, 4, 51, 7, 20, 231, 16, 49, 193, 21, 47, 115, 105, 
+103, 110, 97, 116, 117, 114, 101, 45, 115, 117, 98, 115, 105, 103, 115, 4, 50, 7, 20, 231, 16, 
+49, 14, 35, 21, 44, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 118, 97, 114, 115, 4, 49, 
+7, 20, 57, 130, 20, 21, 23, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 112, 97, 114, 
+116, 115, 207, 90, 9, 57, 130, 20, 21, 27, 5, 208, 1, 0, 2, 59, 127, 21, 7, 60, 78, 
+21, 231, 176, 231, 194, 181, 57, 130, 20, 21, 27, 34, 108, 111, 111, 112, 207, 1, 0, 56, 127, 
+231, 14, 49, 178, 14, 42, 56, 127, 231, 177, 231, 14, 45, 179, 232, 14, 44, 231, 14, 45, 180, 
+231, 178, 231, 14, 46, 181, 231, 176, 231, 14, 46, 179, 21, 45, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 45, 112, 97, 114, 116, 115, 4, 48, 7, 20, 57, 130, 21, 21, 4, 28, 43, 108, 101, 
+116, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 217, 121, 40, 117, 36, 112, 31, 111, 30, 104, 
+23, 103, 22, 61, 126, 232, 14, 44, 193, 15, 15, 55, 77, 56, 127, 56, 127, 231, 14, 43, 189, 
+56, 127, 61, 126, 231, 14, 35, 231, 14, 45, 15, 16, 56, 127, 175, 175, 233, 201, 197, 179, 2, 
+35, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 110, 97, 109, 101, 32, 105, 115, 32, 110, 111, 
+116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 56, 127, 231, 14, 43, 231, 
+14, 46, 15, 15, 231, 14, 43, 231, 14, 69, 15, 15, 7, 7, 7, 230, 14, 13, 233, 200, 196, 
+178, 2, 13, 105, 109, 112, 114, 111, 112, 101, 114, 32, 102, 111, 114, 109, 61, 126, 231, 14, 45, 
+15, 15, 61, 126, 234, 16, 15, 199, 181, 180, 231, 14, 67, 15, 20, 231, 198, 232, 14, 44, 13, 
+1, 20, 35, 37, 108, 101, 116, 45, 101, 120, 112, 97, 110, 115, 105, 111, 110, 45, 116, 105, 109, 
+101, 232, 14, 44, 181, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 
+14, 44, 231, 16, 25, 187, 5, 232, 14, 54, 231, 14, 69, 15, 25, 5, 21, 43, 108, 101, 116, 
+45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 47, 7, 20, 57, 130, 21, 21, 4, 26, 46, 
+100, 101, 102, 105, 110, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 215, 121, 40, 117, 36, 
+112, 31, 111, 30, 103, 22, 61, 126, 232, 14, 44, 193, 188, 55, 77, 56, 127, 56, 127, 231, 14, 
+43, 187, 56, 127, 61, 126, 231, 14, 35, 231, 14, 45, 189, 56, 127, 175, 175, 233, 199, 195, 179, 
+2, 35, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 110, 97, 109, 101, 32, 105, 115, 32, 110, 
+111, 116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 56, 127, 231, 14, 43, 
+231, 14, 46, 188, 231, 14, 49, 231, 14, 69, 188, 7, 7, 7, 230, 14, 13, 233, 198, 194, 178, 
+2, 13, 105, 109, 112, 114, 111, 112, 101, 114, 32, 102, 111, 114, 109, 61, 126, 231, 14, 45, 188, 
+61, 126, 234, 203, 197, 181, 180, 231, 14, 67, 15, 18, 231, 196, 232, 14, 44, 13, 1, 23, 35, 
+37, 100, 101, 102, 105, 110, 101, 45, 101, 120, 112, 97, 110, 115, 105, 111, 110, 45, 116, 105, 109, 
+101, 232, 14, 44, 181, 232, 14, 44, 232, 14, 44, 13, 37, 35, 37, 113, 117, 111, 116, 101, 232, 
+14, 44, 231, 16, 23, 187, 5, 5, 21, 46, 100, 101, 102, 105, 110, 101, 45, 115, 105, 103, 110, 
+97, 116, 117, 114, 101, 4, 46, 7, 20, 57, 130, 20, 21, 29, 48, 102, 108, 97, 116, 116, 101, 
+110, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 115, 209, 125, 44, 84, 3, 232, 14, 2, 14, 
+54, 232, 14, 3, 57, 130, 20, 21, 29, 5, 209, 7, 6, 5, 4, 61, 126, 231, 192, 181, 61, 
+126, 56, 127, 176, 231, 14, 38, 177, 7, 232, 196, 177, 183, 183, 21, 48, 102, 108, 97, 116, 116, 
+101, 110, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 115, 4, 45, 7, 20, 57, 130, 20, 22, 
+4, 13, 47, 102, 108, 97, 116, 116, 101, 110, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 211, 
+125, 44, 90, 9, 84, 3, 232, 14, 2, 14, 54, 232, 14, 3, 57, 130, 20, 21, 4, 13, 5, 
+210, 9, 8, 5, 4, 10, 56, 127, 231, 14, 35, 181, 231, 14, 51, 56, 127, 176, 231, 14, 36, 
+233, 14, 248, 180, 2, 1, 58, 231, 14, 38, 186, 181, 232, 195, 61, 126, 231, 195, 184, 61, 126, 
+56, 127, 176, 231, 14, 38, 177, 7, 56, 127, 56, 127, 179, 175, 7, 233, 14, 248, 182, 2, 1, 
+58, 178, 61, 126, 180, 56, 127, 175, 175, 176, 182, 231, 197, 187, 21, 47, 102, 108, 97, 116, 116, 
+101, 110, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 44, 7, 20, 57, 130, 20, 21, 29, 
+1, 20, 115, 111, 114, 116, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 101, 108, 101, 109, 
+115, 207, 84, 3, 59, 127, 24, 7, 58, 129, 21, 23, 7, 57, 130, 20, 22, 25, 47, 115, 121, 
+109, 98, 111, 108, 45, 108, 101, 115, 115, 45, 116, 104, 97, 110, 63, 205, 232, 14, 239, 231, 14, 
+38, 178, 231, 14, 38, 179, 60, 80, 23, 59, 127, 21, 7, 60, 78, 21, 231, 176, 183, 57, 130, 
+20, 21, 29, 34, 108, 111, 111, 112, 208, 2, 1, 0, 56, 127, 231, 14, 49, 179, 14, 42, 56, 
+127, 231, 14, 49, 231, 14, 46, 180, 178, 59, 127, 22, 7, 58, 129, 22, 20, 7, 233, 181, 183, 
+14, 42, 14, 42, 232, 181, 231, 180, 178, 231, 180, 179, 57, 130, 20, 23, 4, 10, 35, 115, 112, 
+108, 105, 116, 206, 0, 56, 127, 231, 14, 49, 177, 232, 14, 8, 179, 180, 56, 127, 231, 14, 49, 
+231, 14, 46, 178, 232, 14, 8, 232, 14, 44, 231, 14, 45, 181, 181, 180, 233, 178, 231, 14, 69, 
+180, 232, 14, 44, 231, 14, 45, 182, 182, 232, 14, 44, 231, 14, 67, 182, 183, 57, 130, 20, 22, 
+29, 35, 109, 101, 114, 103, 101, 207, 2, 1, 56, 127, 231, 14, 49, 178, 178, 56, 127, 231, 14, 
+49, 179, 177, 56, 127, 232, 178, 231, 14, 45, 181, 231, 14, 45, 180, 232, 14, 44, 231, 14, 45, 
+181, 232, 179, 181, 231, 14, 46, 183, 232, 14, 44, 231, 14, 45, 180, 232, 179, 231, 14, 46, 182, 
+182, 57, 130, 20, 22, 28, 40, 108, 101, 115, 115, 45, 116, 104, 97, 110, 63, 208, 4, 4, 3, 
+56, 127, 231, 14, 35, 179, 56, 127, 231, 14, 35, 180, 232, 177, 180, 181, 6, 56, 127, 231, 14, 
+35, 180, 7, 232, 177, 231, 194, 181, 231, 194, 182, 21, 1, 20, 115, 111, 114, 116, 45, 115, 105, 
+103, 110, 97, 116, 117, 114, 101, 45, 101, 108, 101, 109, 115, 4, 43, 7, 20, 57, 130, 20, 21, 
+25, 48, 101, 120, 112, 108, 111, 100, 101, 45, 110, 97, 109, 101, 100, 45, 115, 105, 103, 115, 207, 
+122, 41, 232, 14, 3, 192, 179, 21, 48, 101, 120, 112, 108, 111, 100, 101, 45, 110, 97, 109, 101, 
+100, 45, 115, 105, 103, 115, 4, 42, 7, 20, 57, 130, 20, 21, 4, 14, 47, 101, 120, 112, 108, 
+111, 100, 101, 45, 110, 97, 109, 101, 100, 45, 115, 105, 103, 213, 121, 40, 110, 29, 86, 5, 84, 
+3, 232, 14, 44, 61, 126, 231, 194, 187, 56, 127, 175, 175, 61, 126, 231, 197, 188, 56, 127, 175, 
+175, 198, 231, 199, 186, 21, 47, 101, 120, 112, 108, 111, 100, 101, 45, 110, 97, 109, 101, 100, 45, 
+115, 105, 103, 4, 41, 7, 20, 57, 130, 20, 21, 4, 11, 41, 101, 120, 112, 108, 111, 100, 101, 
+45, 115, 105, 103, 211, 121, 40, 90, 9, 84, 3, 231, 14, 253, 13, 1, 0, 0, 232, 14, 3, 
+57, 130, 20, 21, 28, 5, 209, 8, 7, 4, 3, 56, 127, 231, 14, 35, 180, 179, 232, 14, 44, 
+231, 193, 182, 231, 195, 182, 231, 196, 185, 21, 41, 101, 120, 112, 108, 111, 100, 101, 45, 115, 105, 
+103, 4, 40, 7, 20, 57, 130, 20, 24, 4, 26, 45, 112, 97, 114, 115, 101, 45, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 221, 124, 43, 119, 38, 118, 37, 117, 36, 112, 31, 90, 9, 84, 3, 
+82, 1, 61, 126, 59, 127, 21, 7, 60, 78, 21, 231, 176, 15, 22, 57, 130, 20, 21, 4, 27, 
+34, 108, 111, 111, 112, 216, 14, 14, 15, 10, 8, 8, 6, 6, 19, 18, 0, 56, 127, 231, 14, 
+49, 187, 14, 42, 56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 188, 233, 198, 179, 180, 
+2, 28, 105, 109, 112, 114, 111, 112, 101, 114, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 
+108, 105, 115, 116, 32, 102, 111, 114, 109, 61, 126, 231, 14, 45, 188, 61, 126, 57, 130, 20, 20, 
+24, 31, 107, 207, 2, 13, 231, 177, 231, 14, 46, 177, 56, 127, 56, 127, 231, 14, 35, 177, 231, 
+14, 253, 35, 1, 0, 0, 232, 14, 253, 37, 1, 0, 0, 179, 13, 31, 58, 7, 232, 14, 44, 
+178, 230, 177, 56, 127, 61, 126, 231, 14, 253, 35, 1, 0, 0, 231, 14, 43, 179, 56, 127, 175, 
+175, 231, 14, 253, 35, 1, 0, 0, 231, 14, 50, 179, 234, 201, 182, 183, 2, 30, 105, 109, 112, 
+114, 111, 112, 101, 114, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 32, 99, 108, 97, 117, 115, 
+101, 32, 102, 111, 114, 109, 180, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 179, 13, 
+36, 115, 116, 114, 117, 99, 116, 61, 126, 231, 14, 46, 178, 61, 126, 57, 130, 20, 21, 4, 12, 
+33, 98, 97, 100, 210, 9, 9, 6, 5, 3, 234, 197, 180, 181, 232, 14, 253, 253, 0, 0, 0, 
+2, 31, 105, 109, 112, 114, 111, 112, 101, 114, 32, 96, 115, 116, 114, 117, 99, 116, 39, 32, 99, 
+108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 126, 97, 186, 179, 55, 77, 56, 127, 56, 127, 232, 
+14, 119, 22, 231, 14, 53, 179, 56, 127, 61, 126, 231, 14, 35, 231, 14, 45, 179, 56, 127, 175, 
+175, 231, 177, 2, 31, 58, 32, 115, 116, 114, 117, 99, 116, 32, 110, 97, 109, 101, 32, 110, 111, 
+116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 56, 127, 231, 14, 50, 231, 
+14, 67, 178, 56, 127, 232, 14, 5, 57, 130, 20, 21, 24, 5, 206, 2, 61, 126, 231, 14, 35, 
+178, 56, 127, 175, 175, 231, 177, 2, 30, 58, 32, 102, 105, 101, 108, 100, 32, 110, 97, 109, 101, 
+32, 110, 111, 116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 231, 14, 67, 
+179, 61, 126, 232, 14, 116, 231, 14, 53, 180, 22, 56, 127, 175, 175, 232, 14, 5, 57, 130, 20, 
+21, 28, 5, 206, 3, 61, 126, 232, 14, 253, 37, 1, 0, 0, 179, 13, 40, 45, 115, 101, 108, 
+101, 99, 116, 111, 114, 115, 56, 127, 175, 175, 61, 126, 232, 14, 253, 37, 1, 0, 0, 180, 13, 
+38, 45, 115, 101, 116, 116, 101, 114, 115, 56, 127, 175, 175, 61, 126, 56, 127, 231, 14, 43, 180, 
+56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 182, 13, 31, 45, 56, 127, 231, 14, 43, 
+231, 14, 46, 181, 56, 127, 231, 14, 35, 231, 14, 67, 181, 231, 14, 49, 231, 14, 69, 181, 7, 
+7, 7, 7, 56, 127, 175, 175, 231, 179, 2, 24, 58, 32, 98, 97, 100, 32, 111, 109, 105, 115, 
+115, 105, 111, 110, 32, 115, 112, 101, 99, 105, 102, 105, 101, 114, 231, 14, 69, 180, 7, 7, 7, 
+7, 230, 14, 13, 231, 176, 2, 0, 61, 126, 231, 14, 45, 178, 61, 126, 231, 14, 67, 179, 61, 
+126, 59, 127, 21, 7, 60, 78, 21, 231, 176, 231, 14, 69, 182, 57, 130, 20, 21, 26, 34, 108, 
+111, 111, 112, 206, 0, 56, 127, 231, 14, 49, 177, 14, 42, 56, 127, 231, 14, 43, 231, 14, 45, 
+178, 232, 14, 44, 231, 14, 72, 179, 231, 178, 231, 14, 46, 180, 231, 176, 231, 14, 46, 178, 61, 
+126, 232, 14, 60, 13, 38, 45, 115, 101, 116, 116, 101, 114, 115, 231, 14, 69, 183, 61, 126, 232, 
+14, 60, 13, 40, 45, 115, 101, 108, 101, 99, 116, 111, 114, 115, 231, 14, 69, 184, 59, 127, 22, 
+6, 58, 129, 21, 20, 6, 234, 16, 24, 185, 184, 181, 182, 58, 129, 21, 21, 6, 57, 130, 20, 
+21, 27, 36, 102, 105, 108, 116, 101, 114, 207, 4, 1, 56, 127, 231, 14, 49, 178, 14, 42, 56, 
+127, 232, 14, 60, 231, 14, 45, 180, 178, 231, 191, 231, 14, 46, 179, 232, 14, 44, 231, 14, 45, 
+180, 231, 193, 231, 14, 46, 181, 232, 14, 54, 56, 127, 231, 14, 49, 182, 192, 231, 194, 193, 230, 
+186, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 179, 13, 34, 117, 110, 105, 116, 61, 
+126, 231, 14, 46, 178, 61, 126, 57, 130, 20, 21, 4, 12, 33, 98, 97, 100, 210, 9, 9, 6, 
+5, 3, 234, 197, 180, 181, 232, 14, 253, 253, 0, 0, 0, 2, 29, 105, 109, 112, 114, 111, 112, 
+101, 114, 32, 96, 117, 110, 105, 116, 39, 32, 99, 108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 
+126, 97, 186, 179, 55, 77, 56, 127, 56, 127, 232, 14, 116, 23, 231, 14, 53, 179, 56, 127, 61, 
+126, 231, 14, 35, 231, 14, 45, 179, 56, 127, 175, 175, 231, 177, 2, 29, 58, 32, 117, 110, 105, 
+116, 32, 110, 97, 109, 101, 32, 110, 111, 116, 32, 97, 110, 32, 105, 100, 101, 110, 116, 105, 102, 
+105, 101, 114, 232, 14, 253, 37, 1, 0, 0, 13, 31, 58, 231, 14, 67, 179, 7, 7, 230, 14, 
+13, 231, 176, 2, 0, 61, 126, 234, 16, 16, 185, 186, 231, 14, 45, 182, 231, 14, 76, 182, 232, 
+14, 44, 177, 230, 180, 56, 127, 232, 14, 253, 37, 1, 0, 0, 231, 14, 45, 179, 13, 34, 111, 
+112, 101, 110, 61, 126, 231, 14, 46, 178, 55, 77, 56, 127, 56, 127, 231, 14, 43, 176, 231, 14, 
+49, 231, 14, 46, 177, 7, 230, 14, 13, 233, 201, 182, 183, 2, 27, 105, 109, 112, 114, 111, 112, 
+101, 114, 32, 96, 111, 112, 101, 110, 39, 32, 99, 108, 97, 117, 115, 101, 32, 102, 111, 114, 109, 
+61, 126, 234, 16, 15, 184, 185, 7, 231, 14, 45, 181, 232, 14, 54, 231, 200, 178, 230, 179, 234, 
+201, 182, 183, 2, 30, 105, 109, 112, 114, 111, 112, 101, 114, 32, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 32, 99, 108, 97, 117, 115, 101, 32, 116, 121, 112, 101, 180, 55, 77, 232, 203, 232, 14, 
+3, 57, 130, 20, 21, 24, 5, 207, 7, 7, 56, 127, 231, 14, 35, 178, 177, 231, 191, 178, 179, 
+57, 130, 20, 21, 4, 10, 5, 209, 9, 9, 20, 19, 233, 195, 178, 179, 232, 14, 253, 253, 0, 
+0, 0, 2, 32, 100, 117, 112, 108, 105, 99, 97, 116, 101, 32, 110, 97, 109, 101, 32, 34, 126, 
+115, 34, 32, 105, 110, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 184, 234, 195, 15, 23, 15, 
+23, 7, 231, 16, 20, 180, 21, 45, 112, 97, 114, 115, 101, 45, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 4, 39, 7, 20, 57, 130, 20, 24, 4, 17, 48, 98, 117, 105, 108, 100, 45, 115, 116, 
+114, 117, 99, 116, 45, 110, 97, 109, 101, 115, 205, 61, 126, 231, 14, 38, 177, 61, 126, 232, 14, 
+3, 14, 38, 180, 61, 126, 14, 248, 232, 14, 3, 14, 36, 233, 14, 54, 233, 14, 51, 232, 185, 
+2, 5, 109, 97, 107, 101, 45, 187, 232, 185, 187, 2, 1, 63, 232, 185, 2, 7, 115, 116, 114, 
+117, 99, 116, 58, 187, 56, 127, 185, 14, 42, 232, 14, 3, 57, 130, 20, 21, 26, 5, 207, 7, 
+9, 233, 179, 178, 2, 1, 45, 180, 183, 56, 127, 186, 14, 42, 232, 14, 3, 57, 130, 20, 21, 
+28, 5, 207, 7, 9, 235, 181, 2, 4, 115, 101, 116, 45, 180, 2, 1, 45, 182, 2, 1, 33, 
+183, 21, 48, 98, 117, 105, 108, 100, 45, 115, 116, 114, 117, 99, 116, 45, 110, 97, 109, 101, 115, 
+4, 38, 7, 20, 57, 130, 20, 22, 27, 42, 99, 104, 101, 99, 107, 45, 117, 110, 105, 113, 117, 
+101, 207, 118, 37, 56, 127, 231, 14, 49, 178, 230, 14, 13, 56, 127, 232, 14, 60, 231, 14, 45, 
+180, 231, 14, 46, 180, 231, 179, 231, 14, 45, 179, 232, 192, 231, 14, 46, 180, 180, 21, 42, 99, 
+104, 101, 99, 107, 45, 117, 110, 105, 113, 117, 101, 4, 37, 7, 20, 57, 130, 20, 24, 4, 25, 
+37, 103, 101, 116, 45, 115, 105, 103, 217, 120, 39, 116, 35, 115, 34, 114, 33, 113, 32, 110, 29, 
+56, 127, 231, 14, 253, 35, 1, 0, 0, 231, 14, 35, 15, 17, 234, 204, 15, 16, 15, 17, 56, 
+127, 15, 18, 15, 18, 194, 15, 19, 61, 126, 230, 231, 14, 10, 57, 130, 20, 21, 4, 12, 5, 
+210, 9, 4, 17, 15, 14, 61, 126, 231, 14, 51, 232, 14, 44, 14, 13, 57, 130, 20, 21, 29, 
+5, 210, 7, 7, 6, 5, 4, 233, 196, 178, 179, 180, 61, 126, 232, 14, 253, 250, 2, 0, 0, 
+230, 14, 253, 6, 3, 0, 0, 14, 253, 240, 2, 0, 0, 61, 126, 230, 176, 233, 14, 21, 57, 
+130, 20, 20, 24, 5, 208, 11, 5, 4, 231, 176, 57, 130, 20, 21, 26, 5, 207, 3, 2, 231, 
+177, 59, 127, 21, 7, 60, 78, 21, 231, 176, 178, 57, 130, 20, 21, 25, 32, 103, 53, 207, 4, 
+0, 56, 127, 231, 14, 49, 178, 57, 130, 20, 20, 22, 5, 206, 1, 231, 14, 253, 242, 2, 0, 
+0, 176, 56, 127, 231, 231, 14, 66, 179, 177, 57, 130, 20, 20, 24, 5, 207, 1, 2, 231, 231, 
+14, 68, 177, 177, 231, 176, 231, 14, 46, 179, 57, 130, 20, 20, 24, 5, 207, 8, 11, 232, 14, 
+7, 57, 130, 20, 20, 22, 5, 206, 3, 231, 14, 253, 82, 3, 0, 0, 176, 57, 130, 21, 21, 
+23, 5, 206, 2, 231, 176, 57, 130, 20, 20, 23, 5, 206, 2, 232, 14, 2, 14, 8, 177, 57, 
+130, 20, 20, 23, 5, 207, 3, 4, 231, 176, 177, 61, 126, 230, 231, 14, 10, 57, 130, 20, 21, 
+28, 5, 206, 18, 61, 126, 231, 14, 51, 232, 14, 44, 14, 13, 57, 130, 28, 21, 21, 5, 205, 
+7, 61, 126, 232, 14, 253, 250, 2, 0, 0, 230, 14, 253, 6, 3, 0, 0, 14, 253, 240, 2, 
+0, 0, 61, 126, 230, 176, 233, 14, 21, 57, 130, 20, 20, 24, 5, 208, 7, 5, 4, 231, 176, 
+57, 130, 20, 21, 26, 5, 207, 3, 2, 231, 177, 59, 127, 21, 7, 60, 78, 21, 231, 176, 178, 
+57, 130, 20, 21, 25, 33, 103, 49, 48, 207, 4, 0, 56, 127, 231, 14, 49, 178, 57, 130, 20, 
+20, 22, 5, 206, 1, 231, 14, 253, 242, 2, 0, 0, 176, 56, 127, 231, 231, 14, 66, 179, 177, 
+57, 130, 20, 20, 24, 5, 207, 1, 2, 231, 231, 14, 68, 177, 177, 231, 176, 231, 14, 46, 179, 
+57, 130, 20, 20, 24, 5, 207, 6, 7, 232, 14, 7, 57, 130, 20, 20, 22, 5, 206, 3, 231, 
+14, 253, 83, 3, 0, 0, 176, 57, 130, 21, 21, 23, 5, 206, 2, 231, 176, 57, 130, 20, 20, 
+23, 5, 206, 2, 232, 14, 2, 14, 8, 177, 57, 130, 20, 20, 23, 5, 207, 3, 4, 231, 176, 
+177, 61, 126, 234, 16, 15, 15, 22, 181, 56, 127, 232, 14, 253, 37, 1, 0, 0, 183, 182, 15, 
+22, 7, 57, 130, 20, 20, 28, 5, 210, 11, 11, 22, 20, 19, 233, 196, 178, 179, 180, 56, 127, 
+15, 17, 232, 201, 177, 15, 19, 175, 21, 37, 103, 101, 116, 45, 115, 105, 103, 4, 36, 7, 20, 
+57, 130, 20, 24, 4, 15, 46, 105, 110, 116, 101, 114, 110, 45, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 209, 116, 35, 82, 1, 234, 194, 183, 183, 185, 56, 127, 231, 14, 253, 6, 1, 0, 0, 
+185, 232, 14, 3, 57, 130, 20, 21, 29, 5, 208, 9, 8, 13, 56, 127, 231, 14, 35, 179, 178, 
+56, 127, 56, 127, 231, 14, 43, 179, 231, 14, 35, 231, 14, 45, 180, 7, 234, 195, 231, 14, 45, 
+183, 231, 14, 46, 183, 7, 179, 230, 175, 231, 14, 253, 12, 1, 0, 0, 187, 230, 186, 21, 46, 
+105, 110, 116, 101, 114, 110, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 35, 7, 20, 57, 
+130, 20, 22, 4, 15, 46, 114, 101, 110, 97, 109, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 
+101, 213, 90, 9, 88, 7, 86, 5, 82, 1, 234, 194, 188, 231, 197, 188, 231, 199, 188, 231, 201, 
+188, 21, 46, 114, 101, 110, 97, 109, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 4, 34, 
+7, 20, 57, 130, 20, 23, 4, 10, 45, 110, 111, 116, 45, 97, 45, 115, 105, 103, 45, 101, 114, 
+114, 111, 114, 207, 112, 31, 233, 193, 180, 181, 232, 14, 253, 253, 0, 0, 0, 2, 23, 34, 126, 
+115, 34, 32, 105, 115, 32, 110, 111, 116, 32, 97, 32, 115, 105, 103, 110, 97, 116, 117, 114, 101, 
+184, 21, 45, 110, 111, 116, 45, 97, 45, 115, 105, 103, 45, 101, 114, 114, 111, 114, 4, 33, 7, 
+20, 57, 130, 20, 23, 4, 10, 45, 117, 110, 100, 101, 102, 45, 115, 105, 103, 45, 101, 114, 114, 
+111, 114, 207, 112, 31, 233, 193, 180, 181, 232, 14, 253, 253, 0, 0, 0, 2, 26, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 32, 34, 126, 115, 34, 32, 110, 111, 116, 32, 100, 101, 102, 105, 110, 
+101, 100, 184, 21, 45, 117, 110, 100, 101, 102, 45, 115, 105, 103, 45, 101, 114, 114, 111, 114, 4, 
+32, 7, 20, 53, 126, 32, 99, 108, 12, 80, 78, 42, 115, 121, 110, 116, 97, 120, 45, 101, 114, 
+114, 111, 114, 57, 130, 20, 24, 28, 5, 205, 234, 14, 253, 55, 1, 0, 0, 179, 181, 180, 182, 
+57, 130, 20, 23, 26, 5, 205, 233, 14, 253, 55, 1, 0, 0, 178, 180, 179, 21, 42, 115, 121, 
+110, 116, 97, 120, 45, 101, 114, 114, 111, 114, 4, 31, 7, 20, 57, 130, 20, 21, 21, 36, 114, 
+101, 115, 117, 108, 116, 205, 175, 21, 36, 114, 101, 115, 117, 108, 116, 4, 30, 7, 20, 13, 39, 
+60, 117, 110, 110, 97, 109, 101, 100, 62, 21, 45, 105, 110, 108, 105, 110, 101, 45, 115, 105, 103, 
+45, 110, 97, 109, 101, 4, 29, 7, 20, 13, 1, 20, 105, 110, 118, 111, 107, 101, 45, 111, 112, 
+101, 110, 45, 117, 110, 105, 116, 47, 115, 105, 103, 21, 1, 20, 105, 110, 118, 111, 107, 101, 45, 
+111, 112, 101, 110, 45, 117, 110, 105, 116, 47, 115, 105, 103, 4, 28, 7, 20, 13, 45, 105, 110, 
+118, 111, 107, 101, 45, 117, 110, 105, 116, 47, 115, 105, 103, 21, 45, 105, 110, 118, 111, 107, 101, 
+45, 117, 110, 105, 116, 47, 115, 105, 103, 4, 27, 7, 20, 13, 47, 99, 111, 109, 112, 111, 117, 
+110, 100, 45, 117, 110, 105, 116, 47, 115, 105, 103, 21, 42, 99, 112, 100, 45, 117, 110, 105, 116, 
+47, 115, 105, 103, 4, 26, 7, 20, 13, 44, 117, 110, 105, 116, 45, 62, 117, 110, 105, 116, 47, 
+115, 105, 103, 21, 38, 117, 45, 62, 117, 47, 115, 105, 103, 4, 25, 7, 20, 13, 38, 117, 110, 
+105, 116, 47, 115, 105, 103, 21, 38, 117, 110, 105, 116, 47, 115, 105, 103, 4, 24, 7, 20, 13, 
+43, 108, 101, 116, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 21, 33, 108, 45, 115, 4, 23, 
+7, 20, 13, 46, 100, 101, 102, 105, 110, 101, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 21, 
+33, 100, 45, 115, 4, 22, 7, 20, 53, 126, 31, 107, 12, 76, 83, 20, 24, 40, 112, 97, 114, 
+115, 101, 45, 117, 110, 105, 116, 5, 37, 105, 109, 112, 111, 114, 116, 115, 37, 114, 101, 110, 97, 
+109, 101, 115, 34, 118, 97, 114, 115, 34, 98, 111, 100, 121, 4, 11, 47, 115, 116, 114, 117, 99, 
+116, 58, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 4, 11, 7, 45, 109, 97, 107, 101, 45, 
+112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 4, 12, 7, 41, 112, 97, 114, 115, 101, 45, 117, 
+110, 105, 116, 63, 4, 13, 7, 48, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 105, 109, 
+112, 111, 114, 116, 115, 4, 14, 7, 1, 23, 115, 101, 116, 45, 112, 97, 114, 115, 101, 45, 117, 
+110, 105, 116, 45, 105, 109, 112, 111, 114, 116, 115, 33, 4, 15, 7, 48, 112, 97, 114, 115, 101, 
+45, 117, 110, 105, 116, 45, 114, 101, 110, 97, 109, 101, 115, 4, 16, 7, 1, 23, 115, 101, 116, 
+45, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 114, 101, 110, 97, 109, 101, 115, 33, 4, 
+17, 7, 45, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 118, 97, 114, 115, 4, 18, 7, 
+1, 20, 115, 101, 116, 45, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 118, 97, 114, 115, 
+33, 4, 19, 7, 45, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 98, 111, 100, 121, 4, 
+20, 7, 1, 20, 115, 101, 116, 45, 112, 97, 114, 115, 101, 45, 117, 110, 105, 116, 45, 98, 111, 
+100, 121, 33, 4, 21, 7, 20, 53, 126, 31, 107, 12, 76, 83, 20, 24, 39, 115, 105, 103, 110, 
+97, 116, 117, 114, 101, 5, 34, 110, 97, 109, 101, 33, 115, 114, 99, 40, 103, 108, 111, 98, 97, 
+108, 45, 115, 114, 99, 35, 101, 108, 101, 109, 115, 4, 11, 46, 115, 116, 114, 117, 99, 116, 58, 
+115, 105, 103, 110, 97, 116, 117, 114, 101, 20, 7, 44, 109, 97, 107, 101, 45, 115, 105, 103, 110, 
+97, 116, 117, 114, 101, 21, 7, 40, 115, 105, 103, 110, 97, 116, 117, 114, 101, 63, 22, 7, 44, 
+115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 110, 97, 109, 101, 23, 7, 49, 115, 101, 116, 45, 
+115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 110, 97, 109, 101, 33, 24, 7, 43, 115, 105, 103, 
+110, 97, 116, 117, 114, 101, 45, 115, 114, 99, 25, 7, 48, 115, 101, 116, 45, 115, 105, 103, 110, 
+97, 116, 117, 114, 101, 45, 115, 114, 99, 33, 26, 7, 1, 20, 115, 105, 103, 110, 97, 116, 117, 
+114, 101, 45, 103, 108, 111, 98, 97, 108, 45, 115, 114, 99, 27, 7, 1, 25, 115, 101, 116, 45, 
+115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 103, 108, 111, 98, 97, 108, 45, 115, 114, 99, 33, 
+28, 7, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 101, 108, 101, 109, 115, 29, 7, 1, 
+20, 115, 101, 116, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 45, 101, 108, 101, 109, 115, 33, 
+4, 10, 7, 5, 7, 0};
+    EVAL_ONE_SIZED_STR((char *)expr, 13571);
+    JUST_DEFINED(unitsig);
+  }
diff --git a/src/mzscheme/src/dynext.c b/src/mzscheme/src/dynext.c
new file mode 100644
index 0000000..d77e3c6
--- /dev/null
+++ b/src/mzscheme/src/dynext.c
@@ -0,0 +1,445 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  Thanks to Patrick Barta for the WINDOWS_DYNAMIC_LOAD code.
+  Thanks to William Ng for the CODEFRAGMENT_DYNAMIC_LOAD code.
+*/
+
+/* Some copilers don't like re-def of GC_malloc in schemef.h: */
+#define SCHEME_NO_GC_PROTO
+
+#include "schpriv.h"
+#include "schvers.h"
+#include "schgc.h"
+
+#ifdef UNIX_DYNAMIC_LOAD
+# include <dlfcn.h>
+#endif
+#ifdef AIX_DYNAMIC_LOAD
+# include  "../aixdlfcn/dlfcn.h"
+# define UNIX_DYNAMIC_LOAD
+#endif
+#if defined(WINDOWS_DYNAMIC_LOAD)
+# include <windows.h>
+#endif
+#if defined(CODEFRAGMENT_DYNAMIC_LOAD)
+# include <CodeFragments.h>
+static Boolean get_ext_file_spec(FSSpec *spec, const char *filename );
+static Boolean load_ext_file_spec(FSSpec *spec, CFragConnectionID *connID);
+#endif
+
+#ifdef SHL_DYNAMIC_LOAD
+#include <dl.h>
+#include <errno.h>
+#define dlopen(file, flag) ((void *)shl_load(file, BIND_IMMEDIATE, 0L))
+void *dlsym(void *_handle, const char *name)
+{
+  void *result;
+  shl_t handle = (shl_t)_handle;
+
+  if (!shl_findsym(&handle, name, TYPE_PROCEDURE, (void *)&result))
+    return result;
+  else
+    return NULL;
+}
+static char *dlerror(void) {
+  static char errbuf[20];
+  sprintf(errbuf, "%d", errno);
+  return errbuf;
+}
+#define UNIX_DYNAMIC_LOAD
+#endif
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+#undef SCHEME_NO_GC_PROTO
+#include "schemex.h"
+#endif
+
+static Scheme_Object *load_extension(int argc, Scheme_Object **argv);
+static Scheme_Object *current_load_extension(int argc, Scheme_Object *argv[]);
+static Scheme_Object *default_load_extension(int argc, Scheme_Object *argv[]);
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+Scheme_Extension_Table *scheme_extension_table;
+
+#define SSI_ARG_TYPES Scheme_Extension_Table *
+#define SSI_ARGS scheme_extension_table
+#else
+#define SSI_ARG_TYPES
+#define SSI_ARGS
+#endif
+
+#ifndef UNIX_DYNAMIC_LOAD
+#ifndef WINDOWS_DYNAMIC_LOAD
+#ifndef CODEFRAGMENT_DYNAMIC_LOAD
+#define NO_DYNAMIC_LOAD
+#endif
+#endif
+#endif
+
+#ifndef NO_DYNAMIC_LOAD
+static Scheme_Hash_Table *loaded_extensions; /* hash on scheme_initialize pointer */
+static Scheme_Hash_Table *fullpath_loaded_extensions; /* hash on full path name */
+#endif
+
+void scheme_init_dynamic_extension(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+#ifndef NO_DYNAMIC_LOAD
+    REGISTER_SO(loaded_extensions);
+    REGISTER_SO(fullpath_loaded_extensions);
+    loaded_extensions = scheme_hash_table(0, SCHEME_hash_ptr, 0, 0);
+    fullpath_loaded_extensions = scheme_hash_table(0, SCHEME_hash_string, 0, 0);
+#endif
+
+#ifdef LINK_EXTENSIONS_BY_TABLE
+    REGISTER_SO(scheme_extension_table);
+    
+    scheme_extension_table = 
+      (Scheme_Extension_Table *)scheme_malloc_atomic(sizeof(Scheme_Extension_Table));
+#include "schemex.inc"
+#endif
+
+    scheme_set_param(scheme_config, MZCONFIG_LOAD_EXTENSION_HANDLER,
+		     scheme_make_prim_w_arity2(default_load_extension,
+					       "default-load-extension-handler",
+					       1, 1,
+					       0, -1));
+  }
+
+  scheme_add_global_constant("load-extension", 
+			     scheme_make_prim_w_arity2(load_extension, 
+						       "load-extension",
+						       1, 1,
+						       0, -1), 
+			     env);
+
+  scheme_add_global_constant("current-load-extension", 
+			     scheme_register_parameter(current_load_extension, 
+						       "current-load-extension",
+						       MZCONFIG_LOAD_EXTENSION_HANDLER), 
+			     env);
+}
+
+static Scheme_Object *
+current_load_extension(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-load-extension", MZCONFIG_LOAD_EXTENSION_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+#ifndef NO_DYNAMIC_LOAD
+
+typedef struct {
+  void *handle;
+  Scheme_Object *(*init_f)(Scheme_Env *);
+  Scheme_Object *(*reload_f)(Scheme_Env *);
+} ExtensionData;
+
+#endif
+
+static Scheme_Object *do_load_extension(const char *filename, Scheme_Env *env)
+{
+#ifndef NO_DYNAMIC_LOAD
+  Scheme_Object *(*init_f)(Scheme_Env *); /* set by platform-specific code */
+  Scheme_Object *(*reload_f)(Scheme_Env *); /* set by platform-specific code */
+  ExtensionData *ed;
+  void *handle;
+  int comppath;
+
+  comppath = scheme_is_complete_path(filename, strlen(filename));
+
+  reload_f = NULL;
+  handle = NULL;
+
+  if (comppath)
+    init_f = scheme_lookup_in_table(fullpath_loaded_extensions, filename);
+  else
+    init_f = NULL;
+
+  if (!init_f) {
+#endif
+
+#ifdef UNIX_DYNAMIC_LOAD
+    void *dl;
+    char *(*f)(SSI_ARG_TYPES), *vers;
+    
+    /* Make sure that filename is not a pathless filename.
+       Some Unix systems don't search as a relative path
+       otherwise. */
+    if (filename[0] != '/') {
+      int l = strlen(filename);
+      char *s = (char *)scheme_malloc_atomic(l + 3);
+      s[0] = '.';
+      s[1] = '/';
+      memcpy(s + 2, filename, l + 1);
+      filename = s;
+    }
+    
+    dl = dlopen((char *)filename, 1);
+    if (!dl)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: couldn't open \"%s\" (%s)",
+		       filename, dlerror());
+    
+    handle = dl;
+    
+#ifdef UNDERSCORE_DYNLOAD_SYMBOL_PREFIX
+# define SO_SYMBOL_PREFIX "_"
+#else
+# define SO_SYMBOL_PREFIX
+#endif
+
+    f = (char*(*)(SSI_ARG_TYPES))dlsym(dl, SO_SYMBOL_PREFIX "scheme_initialize_internal");
+    
+    if (!f)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: \"%s\" is not an extension (%s)", 
+		       filename, dlerror());
+    
+    vers = f(SSI_ARGS);
+    if (!vers || strcmp(vers, VERSION))
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_VERSION,
+		       scheme_make_string(filename),
+		       "load-extension: bad version %s from \"%s\"",
+		       vers, filename);
+    
+    init_f = (Scheme_Object*(*)(Scheme_Env*))dlsym(dl, SO_SYMBOL_PREFIX "scheme_initialize");
+    reload_f = (Scheme_Object*(*)(Scheme_Env*))dlsym(dl, SO_SYMBOL_PREFIX "scheme_reload");
+    
+    if (!init_f)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE,
+		       scheme_make_string(filename),
+		       "load-extension: no initializer in \"%s\" (%s)", 
+		       filename, dlerror());
+#endif
+#if defined(WINDOWS_DYNAMIC_LOAD)
+    HINSTANCE dl;
+    char *(*f)(SSI_ARG_TYPES), *vers;
+  
+    dl = LoadLibrary(filename);
+    if (!dl)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: could not load \"%s\" (%ld)",
+		       filename, GetLastError());
+    
+    handle = (void *)dl;
+    
+    f = (char*(*)(SSI_ARG_TYPES))GetProcAddress(dl, "scheme_initialize_internal");
+    
+    if (!f)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: \"%s\" is not an extension (%ld)",
+		       filename, GetLastError());
+    
+    vers = (f)(SSI_ARGS);
+    if (!vers || strcmp(vers, VERSION))
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_VERSION,
+		       scheme_make_string(filename),
+		       "load-extension: bad version %s from \"%s\"",
+		       vers, filename);
+    
+    init_f = (Scheme_Object*(*)(Scheme_Env*))GetProcAddress(dl,"scheme_initialize");
+    reload_f = (Scheme_Object*(*)(Scheme_Env*))GetProcAddress(dl,"scheme_reload");
+    
+    if (init_f == NULL)
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE,
+		       scheme_make_string(filename),
+		       "load-extension: no initializer in \"%s\"", 
+		       filename);
+#endif
+#if defined(CODEFRAGMENT_DYNAMIC_LOAD)
+    FSSpec spec;
+    char *(*f)(), *vers;
+    CFragConnectionID connID;
+    
+    if (get_ext_file_spec( &spec, filename ) && load_ext_file_spec( &spec, &connID ) )
+      {
+	handle = (void *)connID;
+	
+	OSErr err;
+	err = FindSymbol( connID, "\pscheme_initialize_internal", ( Ptr * )&f, 0 );
+	if ( err != noErr )
+	  scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+			   scheme_make_string(filename),
+			   "load-extension: \"%s\" is not an extension",
+			   filename);
+	
+	vers = (f)(SSI_ARGS);
+	
+	if (!vers || strcmp(vers, VERSION))
+	  scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_VERSION,
+			   scheme_make_string(filename),
+			   "load-extension: bad version %s from \"%s\"",
+			   vers, filename);
+	
+	err = FindSymbol( connID, "\pscheme_initialize", ( Ptr * )&init_f, 0 );
+		
+	if ( err != noErr )
+	  scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE,
+			   scheme_make_string(filename),
+			   "load-extension: no initializer in \"%s\"", 
+			   filename);
+	
+	err = FindSymbol( connID, "\pscheme_initialize", ( Ptr * )&reload_f, 0 );
+	if ( err != noErr )
+	  reload_f = NULL;
+      }
+    else
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: could not load extension: \"%s\"",
+		       filename);
+#endif
+#ifdef NO_DYNAMIC_LOAD
+    scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		     "load-extension: not supported on this platform");
+    return NULL;
+#else
+
+    if (comppath)
+      scheme_add_to_table(fullpath_loaded_extensions, filename, init_f, 0);
+  }
+#endif
+
+#ifndef NO_DYNAMIC_LOAD
+  scheme_no_dumps("a dynamic extension has been loaded");
+
+  ed = (ExtensionData *)scheme_lookup_in_table(loaded_extensions, (const char *)init_f);
+
+  if (ed) {
+    if (!ed->reload_f) {
+      scheme_raise_exn(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+		       scheme_make_string(filename),
+		       "load-extension: the extension is already loaded: \"%s\"",
+		       filename);
+    } else
+      init_f = ed->reload_f;
+  } else {
+    ed = MALLOC_ONE(ExtensionData);
+    ed->handle = handle;
+    ed->init_f = init_f;
+    ed->reload_f = reload_f;
+    scheme_add_to_table(loaded_extensions, (const char *)init_f, ed, 0);
+  }
+
+  return init_f(env);
+#endif
+}
+
+void scheme_register_extension_global(void *ptr, long size)
+{
+  GC_add_roots((char *)ptr, (char *)(((char *)ptr) + size + 1));
+}
+
+static Scheme_Object *load_extension(int argc, Scheme_Object **argv)
+{
+  return scheme_load_with_clrd(argc, argv, "load-extension", MZCONFIG_LOAD_EXTENSION_HANDLER);
+}
+
+static Scheme_Object *default_load_extension(int argc, Scheme_Object **argv)
+{
+  char *filename;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("default-load-extension", "string", 0, argc, argv);
+  
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "default-load-extension",
+				    NULL);
+
+  return scheme_force_value(do_load_extension(filename, scheme_get_env(scheme_config)));
+}
+
+Scheme_Object *scheme_load_extension(const char *filename, Scheme_Env *env)
+{
+  Scheme_Object *a[1];
+
+  a[0] = scheme_make_string(filename);
+  return load_extension(1, a);
+}
+
+#if defined(CODEFRAGMENT_DYNAMIC_LOAD)
+
+static Boolean get_ext_file_spec(FSSpec *spec, const char *filename)
+{
+#ifndef EXTENSIONS_WITHOUT_PATH
+	return scheme_mac_path_to_spec(filename, spec, NULL);
+#else
+	/* William Ng's code for always finding an extension in a particular place. */
+	/* This is a very Mac-like idea, but not MzScheme-like. */
+    ProcessSerialNumber currentPSN;
+    ProcessInfoRec info;
+	Boolean ret = false;
+    currentPSN.highLongOfPSN = 0;
+    currentPSN.lowLongOfPSN = kCurrentProcess;
+    info.processInfoLength = sizeof(ProcessInfoRec);
+    info.processName = NULL;
+    info.processAppSpec = spec;
+    
+	if ( GetProcessInformation(&currentPSN, &info)==noErr )
+	{
+#ifdef EXTENSION_IN_SEPARATE_FOLDER
+		/* call PBGetCatInfoSync to get the folder par id */
+		#define EXTENSION_FOLDER_NAME "\pextensions"
+		HFileInfo file_info = {0};
+		CInfoPBPtr	myCPBPtr;           /* for the PBGetCatInfo call */
+		myCPBPtr = (CInfoPBRec*)&file_info;
+	
+		myCPBPtr->hFileInfo.ioNamePtr 	= EXTENSION_FOLDER_NAME;
+		myCPBPtr->hFileInfo.ioVRefNum 	= spec->vRefNum;
+		myCPBPtr->hFileInfo.ioFDirIndex	= 0;
+		myCPBPtr->hFileInfo.ioDirID		= spec->parID;
+		
+		if (PBGetCatInfoSync(myCPBPtr) == noErr) 
+		{
+			if ((myCPBPtr->hFileInfo.ioFlAttrib & ioDirMask) != 0) 
+			{   /* we have a directory */
+				spec->parID   = myCPBPtr->hFileInfo.ioDirID;
+				strcpy( ( char * )spec->name, filename );
+				c2pstr( ( char * )spec->name );
+				ret = true;
+			}
+		}
+#else
+		/* copy the extension filename to the FSSpec */
+		strcpy( ( char * )spec->name, filename );
+		c2pstr( ( char * )spec->name );
+		ret = true;
+
+#endif
+	}
+			
+	return ret;
+#endif
+}
+
+static Boolean load_ext_file_spec(FSSpec *spec, CFragConnectionID *connID)
+{
+	OSErr err = GetDiskFragment(spec, 0, 0, 0, kLoadNewCopy, connID, 0, 0);
+	return err==noErr;
+}
+
+#endif
+
diff --git a/src/mzscheme/src/dynext.inc b/src/mzscheme/src/dynext.inc
new file mode 100644
index 0000000..03add1f
--- /dev/null
+++ b/src/mzscheme/src/dynext.inc
@@ -0,0 +1,159 @@
+  scheme_extension_table->scheme_current_process_ptr = scheme_current_process_ptr;
+  scheme_extension_table->scheme_init_jmpup_buf = scheme_init_jmpup_buf;
+  scheme_extension_table->scheme_init_jmpup_buf_relative = scheme_init_jmpup_buf_relative;
+  scheme_extension_table->scheme_setjmpup_relative = scheme_setjmpup_relative;
+  scheme_extension_table->scheme_longjmpup = scheme_longjmpup;
+  scheme_extension_table->scheme_spawn = scheme_spawn;
+  scheme_extension_table->scheme_thread = scheme_thread;
+  scheme_extension_table->scheme_process_block = scheme_process_block;
+  scheme_extension_table->scheme_swap_process = scheme_swap_process;
+  scheme_extension_table->scheme_check_threads = scheme_check_threads;
+  scheme_extension_table->scheme_wake_up = scheme_wake_up;
+  scheme_extension_table->scheme_signal_error = scheme_signal_error;
+  scheme_extension_table->scheme_warning = scheme_warning;
+  scheme_extension_table->scheme_wrong_count = scheme_wrong_count;
+  scheme_extension_table->scheme_wrong_type = scheme_wrong_type;
+  scheme_extension_table->scheme_dynamic_wind = scheme_dynamic_wind;
+  scheme_extension_table->scheme_make_type = scheme_make_type;
+  scheme_extension_table->scheme_install_type_reader = scheme_install_type_reader;
+  scheme_extension_table->scheme_install_type_writer = scheme_install_type_writer;
+  scheme_extension_table->scheme_eof = scheme_eof;
+  scheme_extension_table->scheme_null = scheme_null;
+  scheme_extension_table->scheme_true = scheme_true;
+  scheme_extension_table->scheme_false = scheme_false;
+  scheme_extension_table->scheme_void = scheme_void;
+  scheme_extension_table->scheme_eval = scheme_eval;
+  scheme_extension_table->scheme_eval_compiled = scheme_eval_compiled;
+  scheme_extension_table->scheme_apply = scheme_apply;
+  scheme_extension_table->scheme_apply_to_list = scheme_apply_to_list;
+  scheme_extension_table->scheme_eval_string = scheme_eval_string;
+  scheme_extension_table->scheme_tail_apply = scheme_tail_apply;
+  scheme_extension_table->scheme_tail_apply_to_list = scheme_tail_apply_to_list;
+  scheme_extension_table->scheme_tail_eval_expr = scheme_tail_eval_expr;
+  scheme_extension_table->scheme_read = scheme_read;
+  scheme_extension_table->scheme_write = scheme_write;
+  scheme_extension_table->scheme_display = scheme_display;
+  scheme_extension_table->scheme_write_string = scheme_write_string;
+  scheme_extension_table->scheme_write_to_string = scheme_write_to_string;
+  scheme_extension_table->scheme_display_to_string = scheme_display_to_string;
+  scheme_extension_table->scheme_debug_print = scheme_debug_print;
+  scheme_extension_table->scheme_flush_output = scheme_flush_output;
+  scheme_extension_table->GC_malloc = GC_malloc;
+  scheme_extension_table->GC_malloc_atomic = GC_malloc_atomic;
+  scheme_extension_table->GC_malloc_stubborn = GC_malloc_stubborn;
+  scheme_extension_table->GC_malloc_uncollectable = GC_malloc_uncollectable;
+  scheme_extension_table->scheme_malloc_eternal = scheme_malloc_eternal;
+  scheme_extension_table->scheme_end_stubborn_change = scheme_end_stubborn_change;
+  scheme_extension_table->scheme_calloc = scheme_calloc;
+  scheme_extension_table->scheme_strdup = scheme_strdup;
+  scheme_extension_table->scheme_strdup_eternal = scheme_strdup_eternal;
+  scheme_extension_table->scheme_hash_table = scheme_hash_table;
+  scheme_extension_table->scheme_add_to_table = scheme_add_to_table;
+  scheme_extension_table->scheme_change_in_table = scheme_change_in_table;
+  scheme_extension_table->scheme_lookup_in_table = scheme_lookup_in_table;
+  scheme_extension_table->scheme_bucket_from_table = scheme_bucket_from_table;
+  scheme_extension_table->scheme_make_prim = scheme_make_prim;
+  scheme_extension_table->scheme_make_noneternal_prim = scheme_make_noneternal_prim;
+  scheme_extension_table->scheme_make_closed_prim = scheme_make_closed_prim;
+  scheme_extension_table->scheme_make_closure = scheme_make_closure;
+  scheme_extension_table->scheme_make_pair = scheme_make_pair;
+  scheme_extension_table->scheme_make_string = scheme_make_string;
+  scheme_extension_table->scheme_make_sized_string = scheme_make_sized_string;
+  scheme_extension_table->scheme_make_string_without_copying = scheme_make_string_without_copying;
+  scheme_extension_table->scheme_alloc_string = scheme_alloc_string;
+  scheme_extension_table->scheme_append_string = scheme_append_string;
+  scheme_extension_table->scheme_make_vector = scheme_make_vector;
+  scheme_extension_table->scheme_make_integer_value = scheme_make_integer_value;
+  scheme_extension_table->scheme_make_double = scheme_make_double;
+  scheme_extension_table->scheme_make_char = scheme_make_char;
+  scheme_extension_table->scheme_make_compiled_syntax = scheme_make_compiled_syntax;
+  scheme_extension_table->scheme_make_promise = scheme_make_promise;
+  scheme_extension_table->scheme_make_trigger = scheme_make_trigger;
+  scheme_extension_table->scheme_make_bignum = scheme_make_bignum;
+  scheme_extension_table->scheme_bignum_to_float = scheme_bignum_to_float;
+  scheme_extension_table->scheme_bignum_from_float = scheme_bignum_from_float;
+  scheme_extension_table->scheme_bignum_to_string = scheme_bignum_to_string;
+  scheme_extension_table->scheme_read_bignum = scheme_read_bignum;
+  scheme_extension_table->scheme_bignum_normalize = scheme_bignum_normalize;
+  scheme_extension_table->scheme_expand = scheme_expand;
+  scheme_extension_table->scheme_expand_expr = scheme_expand_expr;
+  scheme_extension_table->scheme_expand_list = scheme_expand_list;
+  scheme_extension_table->scheme_expand_block = scheme_expand_block;
+  scheme_extension_table->scheme_expand_simple = scheme_expand_simple;
+  scheme_extension_table->scheme_compile = scheme_compile;
+  scheme_extension_table->scheme_compile_expr = scheme_compile_expr;
+  scheme_extension_table->scheme_compile_simple = scheme_compile_simple;
+  scheme_extension_table->scheme_compile_sequence = scheme_compile_sequence;
+  scheme_extension_table->scheme_compile_block = scheme_compile_block;
+  scheme_extension_table->scheme_compile_list = scheme_compile_list;
+  scheme_extension_table->scheme_init_compile_recs = scheme_init_compile_recs;
+  scheme_extension_table->scheme_merge_compile_recs = scheme_merge_compile_recs;
+  scheme_extension_table->scheme_make_syntax_compilation = scheme_make_syntax_compilation;
+  scheme_extension_table->scheme_make_closure_compilation = scheme_make_closure_compilation;
+  scheme_extension_table->scheme_make_compiled_closure = scheme_make_compiled_closure;
+  scheme_extension_table->scheme_make_promise_compiled = scheme_make_promise_compiled;
+  scheme_extension_table->scheme_make_branch_compilation = scheme_make_branch_compilation;
+  scheme_extension_table->scheme_make_sequence_compilation = scheme_make_sequence_compilation;
+  scheme_extension_table->scheme_register_syntax_executer = scheme_register_syntax_executer;
+  scheme_extension_table->scheme_getc = scheme_getc;
+  scheme_extension_table->scheme_ungetc = scheme_ungetc;
+  scheme_extension_table->scheme_char_ready = scheme_char_ready;
+  scheme_extension_table->scheme_need_wakeup = scheme_need_wakeup;
+  scheme_extension_table->scheme_tell = scheme_tell;
+  scheme_extension_table->scheme_tell_line = scheme_tell_line;
+  scheme_extension_table->scheme_close_input_port = scheme_close_input_port;
+  scheme_extension_table->scheme_close_output_port = scheme_close_output_port;
+  scheme_extension_table->scheme_make_port_type = scheme_make_port_type;
+  scheme_extension_table->scheme_make_file_input_port = scheme_make_file_input_port;
+  scheme_extension_table->scheme_make_named_file_input_port = scheme_make_named_file_input_port;
+  scheme_extension_table->scheme_make_file_output_port = scheme_make_file_output_port;
+  scheme_extension_table->scheme_make_string_input_port = scheme_make_string_input_port;
+  scheme_extension_table->scheme_make_string_output_port = scheme_make_string_output_port;
+  scheme_extension_table->scheme_get_string_output = scheme_get_string_output;
+  scheme_extension_table->scheme_pipe = scheme_pipe;
+  scheme_extension_table->scheme_add_global = scheme_add_global;
+  scheme_extension_table->scheme_add_global_constant = scheme_add_global_constant;
+  scheme_extension_table->scheme_remove_global = scheme_remove_global;
+  scheme_extension_table->scheme_constant = scheme_constant;
+  scheme_extension_table->scheme_new_special_frame = scheme_new_special_frame;
+  scheme_extension_table->scheme_add_binding = scheme_add_binding;
+  scheme_extension_table->scheme_add_frame = scheme_add_frame;
+  scheme_extension_table->scheme_make_envunbox = scheme_make_envunbox;
+  scheme_extension_table->scheme_lookup_value = scheme_lookup_value;
+  scheme_extension_table->scheme_lookup_global = scheme_lookup_global;
+  scheme_extension_table->scheme_global_bucket = scheme_global_bucket;
+  scheme_extension_table->scheme_static_distance = scheme_static_distance;
+  scheme_extension_table->scheme_set_value = scheme_set_value;
+  scheme_extension_table->scheme_intern_symbol = scheme_intern_symbol;
+  scheme_extension_table->scheme_make_symbol = scheme_make_symbol;
+  scheme_extension_table->scheme_intern_exact_symbol = scheme_intern_exact_symbol;
+  scheme_extension_table->scheme_intern_type_symbol = scheme_intern_type_symbol;
+  scheme_extension_table->scheme_make_type_symbol = scheme_make_type_symbol;
+  scheme_extension_table->scheme_make_class = scheme_make_class;
+  scheme_extension_table->scheme_add_method = scheme_add_method;
+  scheme_extension_table->scheme_make_object = scheme_make_object;
+  scheme_extension_table->scheme_make_uninited_object = scheme_make_uninited_object;
+  scheme_extension_table->scheme_find_ivar = scheme_find_ivar;
+  scheme_extension_table->scheme_is_subclass = scheme_is_subclass;
+  scheme_extension_table->scheme_is_a = scheme_is_a;
+  scheme_extension_table->scheme_get_class_name = scheme_get_class_name;
+  scheme_extension_table->scheme_eq = scheme_eq;
+  scheme_extension_table->scheme_eqv = scheme_eqv;
+  scheme_extension_table->scheme_equal = scheme_equal;
+  scheme_extension_table->scheme_list_length = scheme_list_length;
+  scheme_extension_table->scheme_alloc_list = scheme_alloc_list;
+  scheme_extension_table->scheme_map_1 = scheme_map_1;
+  scheme_extension_table->scheme_car = scheme_car;
+  scheme_extension_table->scheme_cdr = scheme_cdr;
+  scheme_extension_table->scheme_cadr = scheme_cadr;
+  scheme_extension_table->scheme_caddr = scheme_caddr;
+  scheme_extension_table->scheme_vector_to_list = scheme_vector_to_list;
+  scheme_extension_table->scheme_list_to_vector = scheme_list_to_vector;
+  scheme_extension_table->scheme_append = scheme_append;
+  scheme_extension_table->scheme_box = scheme_box;
+  scheme_extension_table->scheme_unbox = scheme_unbox;
+  scheme_extension_table->scheme_set_box = scheme_set_box;
+  scheme_extension_table->scheme_load = scheme_load;
+  scheme_extension_table->scheme_rep = scheme_rep;
+  scheme_extension_table->scheme_banner = scheme_banner;
+  scheme_extension_table->scheme_version = scheme_version;
diff --git a/src/mzscheme/src/env.c b/src/mzscheme/src/env.c
new file mode 100644
index 0000000..229d0f2
--- /dev/null
+++ b/src/mzscheme/src/env.c
@@ -0,0 +1,1647 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+#include "schminc.h"
+
+#if defined(UNIX_LIMIT_STACK) || defined(UNIX_LIMIT_FDSET_SIZE)
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
+#ifdef MZ_USE_IRIX_SPROCS
+#include "../gc/gc.h"
+#endif
+
+#ifdef SMALL_HASH_TABLES
+#define GLOBAL_TABLE_SIZE 500
+#define REFERENCES_TABLE_SIZE 500
+#else
+#define GLOBAL_TABLE_SIZE 5313
+#define REFERENCES_TABLE_SIZE 5313
+#endif
+
+/* #define TIME_STARTUP_PROCESS */
+
+/* globals */
+int scheme_constant_builtins;
+int scheme_allow_set_undefined;
+int scheme_no_keywords;
+
+int scheme_starting_up;
+
+int scheme_hash_percent_syntax_only = 0;
+
+Scheme_Object *scheme_local[MAX_CONST_LOCAL_POS][2];
+
+/* locals */
+static Scheme_Env *make_env(void);
+static Scheme_Object *constant_prim(int argc, Scheme_Object *argv[]);
+static Scheme_Object *constant_all_prim(int argc, Scheme_Object *argv[]);
+static Scheme_Object *keyword_prim(int argc, Scheme_Object *argv[]);
+static Scheme_Object *keyword_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *undefine(int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_globals(int argc, Scheme_Object *argv[]);
+static Scheme_Object *defined(int argc, Scheme_Object *argv[]);
+static Scheme_Object *global_defined_value(int, Scheme_Object *[]);
+static Scheme_Object *local_exp_time_value(int argc, Scheme_Object *argv[]);
+static Scheme_Object *global_exp_time_value(int argc, Scheme_Object *argv[]);
+static Scheme_Object *local_exp_time_bound_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *local_exp_top_level_p(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *current_loaded_library_table(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *write_variable(Scheme_Object *obj);
+static Scheme_Object *read_variable(Scheme_Object *obj);
+static Scheme_Object *write_local(Scheme_Object *obj);
+static Scheme_Object *read_local(Scheme_Object *obj);
+static Scheme_Object *read_local_unbox(Scheme_Object *obj);
+
+static void hash_percent(const char *name, Scheme_Object *obj, 
+			 Scheme_Env *, int add);
+static void add_primitive_symbol(Scheme_Object *sym, Scheme_Object *obj, 
+				 Scheme_Env *env);
+
+static int hash_percent_buflen = 0;
+static char *hash_percent_buffer;
+
+static int set_reference_ids = 0;
+static int builtin_ref_counter = 0;
+
+typedef struct Constant_Binding {
+  Scheme_Object *name;
+  Scheme_Object *val;
+  short before;
+  struct Constant_Binding *next;
+} Constant_Binding;
+
+#define ARBITRARY_USE 1
+#define CONSTRAINED_USE 2
+#define NOT_SETTABLE 4
+#define WAS_SET_BANGED 8
+
+typedef struct Compile_Data {
+  char **stat_dists; /* (pos, depth) => used? */
+  int *sd_depths;
+  Constant_Binding *constants;
+  int *use;
+} Compile_Data;
+
+typedef struct Scheme_Full_Comp_Env {
+  Scheme_Comp_Env base;
+  Compile_Data data;
+} Scheme_Full_Comp_Env;
+static void init_compile_data(Scheme_Comp_Env *env);
+
+#define COMPILE_DATA(e) (&((Scheme_Full_Comp_Env *)e)->data)
+
+#ifdef MZ_REAL_THREADS
+void *scheme_global_lock;
+#endif
+
+#if defined(_IBMR2)
+/* Under AIX, we need a hack to set stackbottom. HEURISTIC2
+   doesn't really work, and 3.x is different from 4.x. */
+extern long GC_stackbottom;
+long scheme_stackbottom = 0;
+#endif
+
+Scheme_Env *scheme_basic_env ()
+{
+  Scheme_Process *process;
+  Scheme_Env *env;
+
+#ifdef UNIX_LIMIT_STACK
+  {
+    struct rlimit rl;
+    
+    getrlimit(RLIMIT_STACK, &rl);
+    if (rl.rlim_cur > UNIX_LIMIT_STACK) {
+      rl.rlim_cur = UNIX_LIMIT_STACK;
+      setrlimit(RLIMIT_STACK, &rl);
+    }
+  }
+#endif
+#ifdef UNIX_LIMIT_FDSET_SIZE
+  {
+    struct rlimit rl;
+    
+    getrlimit(RLIMIT_NOFILE, &rl);
+    if (rl.rlim_cur > FD_SETSIZE) {
+      rl.rlim_cur = FD_SETSIZE;
+      setrlimit(RLIMIT_NOFILE, &rl);
+    }
+  }
+#endif
+
+#if defined(_IBMR2)
+  if (scheme_stackbottom)
+    GC_stackbottom = scheme_stackbottom;
+#endif
+
+#ifdef MZ_USE_IRIX_SPROCS
+  GC_INIT();
+#endif
+
+#ifdef TIME_STARTUP_PROCESS
+   printf("#if 0\nbasic @ %ld\n", scheme_get_process_milliseconds());
+#endif
+
+#ifdef MUST_REGISTER_GLOBALS
+  REGISTER_SO(hash_percent_buffer);
+
+  scheme_register_bignum();
+#endif
+
+  scheme_starting_up = 1;
+
+#ifdef MZ_REAL_THREADS
+  scheme_global_lock = SCHEME_MAKE_MUTEX();
+#else
+  scheme_init_stack_check();
+#endif
+
+  {
+    int i, k;
+
+#ifndef USE_TAGGED_ALLOCATION
+    Scheme_Local *all;
+
+    all = (Scheme_Local *)scheme_malloc_eternal(sizeof(Scheme_Local) * 2 * MAX_CONST_LOCAL_POS);
+# ifdef MEMORY_COUNTING_ON
+    scheme_misc_count += sizeof(Scheme_Local) * 2 * MAX_CONST_LOCAL_POS;
+# endif    
+#endif
+
+    for (i = 0; i < MAX_CONST_LOCAL_POS; i++)
+      for (k = 0; k < 2; k++) {
+	Scheme_Object *v;
+	
+#ifndef USE_TAGGED_ALLOCATION
+	v = (Scheme_Object *)(all++);
+#else
+	v = (Scheme_Object *)scheme_malloc_eternal_tagged(sizeof(Scheme_Local));
+#endif
+	v->type = k + scheme_local_type;
+	SCHEME_LOCAL_POS(v) = i;
+	
+	scheme_local[i][k] = v;
+      }
+  }
+
+  scheme_init_true_false();
+
+#ifdef TIME_STARTUP_PROCESS
+  printf("pre-process @ %ld\n", scheme_get_process_milliseconds());
+#endif
+
+  process = scheme_make_process();
+  process->stack_start = NULL;
+
+#ifdef TIME_STARTUP_PROCESS
+  printf("process @ %ld\n", scheme_get_process_milliseconds());
+#endif
+
+  env = scheme_top_level_env();
+  
+  scheme_init_error_escape_proc(process);
+
+  scheme_starting_up = 0;
+
+#ifdef TIME_STARTUP_PROCESS
+  printf("done @ %ld\n#endif\n", scheme_get_process_milliseconds());
+#endif
+
+  return env;
+}
+
+static void primitive_syntax_through_scheme(const char *name, 
+					    Scheme_Env *env)
+{
+  Scheme_Object *hp;
+
+  if (scheme_no_keywords && scheme_hash_percent_syntax_only)
+    return;
+
+  hp = scheme_hash_percent_name(name, -1);
+
+  if (!scheme_no_keywords)
+    scheme_set_keyword(hp, env);
+
+  if (!scheme_hash_percent_syntax_only) {
+    Scheme_Object *sym = scheme_intern_symbol(name);
+
+    scheme_add_global_symbol(sym, scheme_lookup_global(hp, env), env);
+    
+    if (scheme_constant_builtins)
+      scheme_constant(sym, env);
+  }
+}
+
+static void primitive_function_through_scheme(const char *name, 
+					      Scheme_Env *env)
+{
+  Scheme_Object *sym, *hp;
+
+  sym = scheme_intern_symbol(name);
+
+  if (scheme_constant_builtins)
+    scheme_constant(sym, env);
+
+  hp = scheme_hash_percent_name(name, -1);
+  
+  add_primitive_symbol(hp, scheme_lookup_global(sym, env), env);
+
+  if (!scheme_no_keywords)
+    scheme_set_keyword(hp, env);
+}
+
+static void primitive_cond_through_scheme(const char *name, 
+					  Scheme_Env *env)
+{
+  primitive_syntax_through_scheme(name, env);
+  scheme_init_empty_cond(env);
+}
+
+#if USE_COMPILED_MACROS
+Scheme_Object *scheme_eval_compiled_sized_string(const char *str, int len, Scheme_Env *env)
+{
+  Scheme_Object *port, *expr, *saved;
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Config *config = p->config;
+
+  port = scheme_make_sized_string_input_port(str, len);
+
+  saved = scheme_get_param(config, MZCONFIG_ENV);
+  scheme_set_param(config, MZCONFIG_ENV, (Scheme_Object *)env);
+  expr = scheme_internal_read(port, 1, scheme_config
+#ifdef MZ_REAL_THREADS
+			      , p
+#endif
+			      );
+  scheme_set_param(config, MZCONFIG_ENV, saved);
+
+  return _scheme_eval_compiled(expr);
+}
+#endif
+
+/* On the Mac, 68K, store the built-in Scheme code as pc-relative */
+#if defined(__MWERKS__)
+#if !defined(__powerc)
+#pragma pcrelstrings on
+#endif
+#endif
+
+Scheme_Env *scheme_top_level_env(void)
+{
+  Scheme_Env *env;
+  Scheme_Object *q, *qq, *nllt;
+#ifdef TIME_STARTUP_PROCESS
+  long startt;
+#endif
+
+  env = make_env();
+
+  if (scheme_starting_up)
+    scheme_set_param(scheme_current_process->config, MZCONFIG_ENV, 
+		     (Scheme_Object *)env);
+
+  scheme_defining_primitives = 1;
+  set_reference_ids = 1;
+  builtin_ref_counter = 0;
+
+#ifdef TIME_STARTUP_PROCESS
+   printf("init @ %ld\n", scheme_get_process_milliseconds());
+# define MZTIMEIT(n, f) (MARK_START_TIME(), f, DONE_TIME(n))
+# define MARK_START_TIME() startt = scheme_get_process_milliseconds()
+# define DONE_TIME(n) printf(#n ": %ld\n", (long)(scheme_get_process_milliseconds() - startt))
+#else
+# define MZTIMEIT(n, f) f
+# define MARK_START_TIME() /**/
+# define DONE_TIME(n) /**/
+#endif
+
+  /* The ordering of the first few init calls is important.
+	  Add to the end of the list, not the beginning. */
+  MZTIMEIT(symbol-table, scheme_init_symbol_table());
+  MZTIMEIT(type-symbol-table, scheme_init_type_symbol_table());
+  MZTIMEIT(type, scheme_init_type(env));
+  MZTIMEIT(symbol-type, scheme_init_symbol_type(env));
+  MZTIMEIT(fun, scheme_init_fun(env));
+  MZTIMEIT(symbol, scheme_init_symbol(env));
+  MZTIMEIT(type-symbol, scheme_init_type_symbol(env));
+  MZTIMEIT(list, scheme_init_list(env));
+  MZTIMEIT(number, scheme_init_number(env));
+  MZTIMEIT(port, scheme_init_port(env));
+  MZTIMEIT(string, scheme_init_string(env));
+  MZTIMEIT(vector, scheme_init_vector(env));
+  MZTIMEIT(char, scheme_init_char(env));
+  MZTIMEIT(bool, scheme_init_bool(env));
+  MZTIMEIT(syntax, scheme_init_syntax(env));
+  MZTIMEIT(eval, scheme_init_eval(env));
+  MZTIMEIT(error, scheme_init_error(env));
+  MZTIMEIT(promise, scheme_init_promise(env));
+  MZTIMEIT(struct, scheme_init_struct(env));
+#ifndef NO_UNIT_SYSTEM
+  MZTIMEIT(unit, scheme_init_unit(env));
+#endif
+#ifndef NO_SCHEME_EXNS
+  MZTIMEIT(exn, scheme_init_exn(env));
+#endif
+  MZTIMEIT(process, scheme_init_process(env));
+#ifndef NO_SCHEME_THREADS
+  MZTIMEIT(sema, scheme_init_sema(env));
+#endif
+  MZTIMEIT(read, scheme_init_read(env));
+  MZTIMEIT(print, scheme_init_print(env));
+  MZTIMEIT(file, scheme_init_file(env));
+  MZTIMEIT(dynamic-extension, scheme_init_dynamic_extension(env));
+  MZTIMEIT(image, scheme_init_image(env));
+#ifndef NO_REGEXP_UTILS
+  MZTIMEIT(regexp, scheme_regexp_initialize(env));
+#endif
+
+  MARK_START_TIME();
+
+  scheme_add_global_constant("constant-name",
+			     scheme_make_prim_w_arity(constant_prim,
+						      "constant-name",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("constant-name-all-globals",
+			     scheme_make_prim_w_arity(constant_all_prim,
+						      "constant-name-all-globals",
+						      0, -1),
+			     env);
+  scheme_add_global_constant("keyword-name",
+			     scheme_make_prim_w_arity(keyword_prim,
+						      "keyword-name",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("keyword-name?",
+			     scheme_make_prim_w_arity(keyword_p,
+						      "keyword-name?",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("undefine",
+			     scheme_make_prim_w_arity(undefine,
+					      "undefine",
+					      1, 1),
+			     env);
+  scheme_add_global_constant("make-global-value-list",
+			     scheme_make_prim_w_arity(list_globals,
+					      "make-global-value-list",
+					      0, 0),
+			     env);
+  
+  scheme_add_global_constant("defined?", 
+			     scheme_make_prim_w_arity(defined,
+						      "defined?",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("global-defined-value", 
+			     scheme_make_prim_w_arity(global_defined_value,
+						      "global-defined-value",
+						      1, 2),
+			     env);
+  scheme_add_global_constant("local-expansion-time-value", 
+			     scheme_make_prim_w_arity(local_exp_time_value,
+						      "local-expansion-time-value",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("global-expansion-time-value", 
+			     scheme_make_prim_w_arity(global_exp_time_value,
+						      "global-expansion-time-value",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("local-expansion-time-bound?", 
+			     scheme_make_prim_w_arity(local_exp_time_bound_p,
+						      "local-expansion-time-bound?",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("local-expansion-top-level?", 
+			     scheme_make_prim_w_arity(local_exp_top_level_p,
+						      "local-expansion-top-level?",
+						      0, 0),
+			     env);
+  
+
+  DONE_TIME(env);
+
+#ifndef NO_OBJECT_SYSTEM
+  MZTIMEIT(object, scheme_init_object(env));
+#endif
+
+  if (scheme_starting_up) {
+    scheme_install_type_writer(scheme_variable_type, write_variable);
+    scheme_install_type_reader(scheme_variable_type, read_variable);
+    scheme_install_type_writer(scheme_local_type, write_local);
+    scheme_install_type_reader(scheme_local_type, read_local);
+    scheme_install_type_writer(scheme_local_unbox_type, write_local);
+    scheme_install_type_reader(scheme_local_unbox_type, read_local_unbox);
+  }
+
+  MARK_START_TIME();
+
+  set_reference_ids = 0;
+
+  /* It's too painful to implement macros without ` and ', so make
+     sure they're always defined, and then undefine if necessary. */
+
+  nllt = scheme_intern_symbol("current-loaded-library-table");
+  scheme_add_global_symbol(nllt, scheme_make_prim(current_loaded_library_table), env);
+
+  if (scheme_hash_percent_syntax_only) {
+    Scheme_Object *q_hp;
+    q = scheme_intern_symbol("quote");
+    qq = scheme_intern_symbol("quasiquote");
+    q_hp = scheme_intern_symbol("#%quote");
+
+    scheme_add_global_symbol(q, scheme_lookup_global(q_hp, env), env);
+  } else
+    q = qq = NULL;
+
+#define EVAL_ONE_STR(str) scheme_eval_string(str, env)
+#define EVAL_ONE_SIZED_STR(str, len) scheme_eval_compiled_sized_string(str, len, env)
+#define JUST_DEFINED(name) primitive_syntax_through_scheme(#name, env)
+#define JUST_DEFINED_FUNC(name) primitive_function_through_scheme(#name, env)
+#define JUST_DEFINED_KEY(name) primitive_syntax_through_scheme(#name, env)
+#define JUST_DEFINED_COND(name) primitive_cond_through_scheme(#name, env)
+#define JUST_DEFINED_QQ(name) \
+   JUST_DEFINED_KEY(name); \
+   if (qq) { \
+     Scheme_Object *qq_hp = scheme_intern_symbol("#%quasiquote"); \
+     scheme_add_global_symbol(qq, scheme_lookup_global(qq_hp, env), env); \
+   }
+
+#if USE_COMPILED_MACROS
+#include "cmacro.inc"
+#else
+#include "macro.inc"
+#endif
+
+   scheme_remove_global_symbol(nllt, env);
+
+  if (scheme_hash_percent_syntax_only) {
+    scheme_remove_global_symbol(q, env);
+    scheme_remove_global_symbol(qq, env);
+  }
+
+  if (scheme_starting_up) {
+    scheme_init_format_procedure(env);
+    scheme_init_rep(env);
+  }
+
+  if (scheme_secure_primitive_exn)
+    scheme_secure_leftover_exceptions(env);
+
+  DONE_TIME(macro);
+
+  scheme_defining_primitives = 0;
+
+  return env;
+}
+
+Scheme_Env *scheme_make_empty_env(void)
+{
+  return make_env();
+}
+
+#if defined(__MWERKS__)
+#if !defined(__powerc)
+#pragma pcrelstrings reset
+#endif
+#endif
+
+static Scheme_Object *
+undefine(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("undefine", "symbol", 0, argc, argv);
+
+  scheme_remove_global_symbol(argv[0], scheme_get_env(scheme_config));
+  return scheme_void;
+}
+
+static Scheme_Object *
+current_loaded_library_table(int argc, Scheme_Object *argv[])
+{
+  return (Scheme_Object *)scheme_get_env(scheme_config)->loaded_libraries;
+}
+
+static Scheme_Env *make_env (void)
+{
+  Scheme_Hash_Table *globals;
+  Scheme_Env *env;
+
+  globals = scheme_hash_table(GLOBAL_TABLE_SIZE, SCHEME_hash_ptr, 
+			      1, 0 /* scheme_starting_up */);
+
+  env = MALLOC_ONE_TAGGED(Scheme_Env);
+
+  env->type = scheme_namespace_type;
+  env->globals = globals;
+
+  env->loaded_libraries = scheme_hash_table(3, SCHEME_hash_ptr, 0, 0);
+
+  env->init = (Scheme_Comp_Env *)MALLOC_ONE(Scheme_Full_Comp_Env);
+  env->init->basic.num_bindings = 0;
+  env->init->basic.next = NULL;
+  env->init->basic.genv = env;
+  init_compile_data(env->init);
+
+  return env;
+}
+
+Scheme_Env *scheme_min_env(Scheme_Comp_Env *env)
+{
+  return env->basic.genv;
+}
+
+#define get_globals(env) (env->globals)
+
+static void
+do_add_global_symbol(Scheme_Env *env, Scheme_Object *sym, 
+		     Scheme_Object *obj, int constant,
+		     int primitive)
+{
+  Scheme_Hash_Table *globals;
+  Scheme_Bucket *b;
+
+  globals = get_globals(env);
+
+  scheme_add_to_table(globals, (char *)sym, obj, constant);
+  if (primitive) {
+    b = scheme_bucket_from_table(globals, (char *)sym);
+    
+    ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_IS_PRIMITIVE;
+  } else
+    b = NULL;
+
+#if 0
+  if (scheme_starting_up && !scheme_no_reference_id) {
+    if (!b)
+      b = scheme_bucket_from_table(globals, (char *)sym);
+
+    ((Scheme_Bucket_With_Ref_Id *)b)->id = (++builtin_ref_counter);
+    ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_HAS_REF_ID;
+  }
+#endif
+}
+
+static void
+do_add_global(Scheme_Env *env, const char *name, 
+	      Scheme_Object *obj, int constant,
+	      int primitive)
+{
+  Scheme_Object *sym;
+  
+  sym = scheme_intern_symbol(name);
+  do_add_global_symbol(env, sym, obj, constant, primitive);
+}
+
+void
+scheme_add_global(const char *name, Scheme_Object *obj, Scheme_Env *env)
+{
+  do_add_global(env, name, obj, 0, 0);
+}
+
+void
+scheme_add_global_symbol(Scheme_Object *sym, Scheme_Object *obj, 
+			 Scheme_Env *env)
+{
+  do_add_global_symbol(env, sym, obj, 0, 0);
+}
+
+static void
+add_primitive_symbol(Scheme_Object *sym, Scheme_Object *obj, 
+		     Scheme_Env *env)
+{
+  do_add_global_symbol(env, sym, obj, 1, 1);
+}
+
+void
+scheme_remove_global_symbol(Scheme_Object *sym, Scheme_Env *env)
+{
+  Scheme_Bucket *b;
+  Scheme_Hash_Table *globals;
+
+  globals = get_globals(env);
+
+  b = scheme_bucket_from_table(globals, (char *)sym);
+
+  if (!b)
+    return;
+
+  if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST)
+    scheme_raise_exn(MZEXN_MISC_CONSTANT, sym,
+		     "undefine: can't undefine constant %s",
+		     scheme_symbol_name(sym));
+  if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_KEYWORD)
+    scheme_raise_exn(MZEXN_MISC_CONSTANT, sym,
+		     "undefine: can't undefine keyword %s",
+		     scheme_symbol_name(sym));
+  if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_PERMANENT)
+    scheme_raise_exn(MZEXN_MISC_CONSTANT, sym,
+		     "undefine: can't undefine permanent global %s",
+		     scheme_symbol_name(sym));
+
+  b->val = NULL;
+}
+
+void
+scheme_remove_global(const char *name, Scheme_Env *env)
+{
+  Scheme_Object *sym;
+
+  sym = scheme_intern_symbol(name);
+
+  scheme_remove_global_symbol(sym, env);
+}
+
+void
+scheme_remove_global_constant(const char *name, Scheme_Env *env)
+{
+  scheme_remove_global(name, env);
+#ifndef NO_SEPARATE_HASH_PRECENT
+  hash_percent(name, NULL, env, 0);
+#endif
+}
+
+void
+scheme_add_global_constant(const char *name, Scheme_Object *obj, 
+			   Scheme_Env *env)
+{
+  do_add_global(env, name, obj, scheme_constant_builtins, 0);
+#ifndef NO_SEPARATE_HASH_PRECENT
+  hash_percent(name, obj, env, 1);
+#endif
+}
+
+void
+scheme_add_global_constant_symbol(Scheme_Object *name, Scheme_Object *obj, 
+				  Scheme_Env *env)
+{
+  do_add_global_symbol(env, name, obj, scheme_constant_builtins, 0);
+#ifndef NO_SEPARATE_HASH_PRECENT
+  hash_percent(SCHEME_SYM_VAL(name), obj, env, 1);
+#endif
+}
+
+void 
+scheme_set_keyword(Scheme_Object *sym, Scheme_Env *env)
+{
+  Scheme_Bucket *b;
+  Scheme_Hash_Table *globals;
+  
+  globals = get_globals(env);
+  
+  b = scheme_bucket_from_table(globals, (char *)sym);
+  ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_IS_KEYWORD;
+  if (!b->val)
+    b->val = scheme_void;
+}
+
+void
+scheme_add_global_keyword(const char *name, Scheme_Object *obj, 
+			  Scheme_Env *env)
+{
+  Scheme_Object *hp = scheme_hash_percent_name(name, -1);
+
+  do_add_global_symbol(env, hp, obj, 0, 0);
+
+  if (!scheme_no_keywords)
+    scheme_set_keyword(hp, env);
+
+  if (!scheme_hash_percent_syntax_only) {
+    Scheme_Object *sym = scheme_intern_symbol(name);
+
+    scheme_add_global_symbol(sym, scheme_lookup_global(hp, env), env);
+    
+    if (scheme_constant_builtins)
+      scheme_constant(sym, env);
+  }
+}
+
+#ifndef NO_SEPARATE_HASH_PRECENT
+
+Scheme_Object *scheme_hash_percent_name(const char *name, int len)
+{
+  if (len < 0)
+    len = strlen(name);
+  
+  if (len + 2 > hash_percent_buflen) {
+#ifdef MEMORY_COUNTING_ON
+  scheme_misc_count -= hash_percent_buflen;
+#endif
+
+    hash_percent_buflen = 2 * (hash_percent_buflen + len + 2);
+    hash_percent_buffer = (char *)scheme_malloc_atomic(hash_percent_buflen + 1);
+    hash_percent_buffer[0] = '#';
+    hash_percent_buffer[1] = '%';
+
+#ifdef MEMORY_COUNTING_ON
+  scheme_misc_count += hash_percent_buflen;
+#endif
+  }
+
+  memcpy(hash_percent_buffer + 2, name, len + 1);
+
+  return scheme_intern_exact_symbol(hash_percent_buffer, len + 2);
+}
+
+static void hash_percent(const char *name, Scheme_Object *obj,
+			 Scheme_Env *env, int add)
+{
+  Scheme_Object *sym = scheme_hash_percent_name(name, -1);
+
+  if (!add) {
+    Scheme_Bucket *b;
+    Scheme_Hash_Table *globals = get_globals(env);
+
+    b = scheme_bucket_from_table(globals, (char *)sym);
+
+    if (b)
+      b->val = NULL; /* (even if it's constant) */
+  } else {
+    Scheme_Bucket *b;
+
+    Scheme_Hash_Table *globals = get_globals(env);
+    globals->has_constants = 2;
+
+    do_add_global_symbol(env, sym, obj, 1, 1);
+
+    globals->has_constants = 1;
+    
+    if (!scheme_no_keywords)
+      scheme_set_keyword(sym, env);
+    
+#if 1
+    if (set_reference_ids) {
+      b = scheme_bucket_from_table(globals, (char *)sym);
+      ((Scheme_Bucket_With_Ref_Id *)b)->id = (++builtin_ref_counter);
+      ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_HAS_REF_ID;
+    }
+#endif
+  }
+}
+
+#endif
+
+Scheme_Object **scheme_make_builtin_references_table(void)
+{
+  Scheme_Hash_Table *ht;
+  Scheme_Object **t;
+  Scheme_Bucket **bs;
+  long i;
+
+  t = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *)
+				      * (builtin_ref_counter + 1));
+#ifdef MEMORY_COUNTING_ON
+  scheme_misc_count += sizeof(Scheme_Object *) * (builtin_ref_counter + 1);
+#endif
+
+  ht = get_globals(scheme_get_env(scheme_config));
+
+  bs = ht->buckets;
+
+  for (i = ht->size; i--; ) {
+    Scheme_Bucket *b = bs[i];
+    if (b && (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_HAS_REF_ID))
+      t[((Scheme_Bucket_With_Ref_Id *)b)->id] = (Scheme_Object *)b;
+  }
+
+  return t;
+}
+
+void scheme_check_identifier(const char *formname, Scheme_Object *id, 
+			     const char *where, Scheme_Comp_Env *env,
+			     Scheme_Object *form)
+{
+  Scheme_Bucket *b;
+  Scheme_Hash_Table *globals;
+
+  if (!where)
+    where = "";
+
+  if (!SCHEME_SYMBOLP(id))
+    scheme_wrong_syntax(formname, form ? id : NULL, 
+			form ? form : id, 
+			"identifier must be a symbol%s", where);
+  
+  if (scheme_no_keywords)
+    return;
+  
+  globals = get_globals(scheme_min_env(env));
+
+  if (scheme_lookup_in_table(globals, (char *)id)) {
+    b = scheme_bucket_from_table(globals, (char *)id);
+    if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_KEYWORD)
+      scheme_wrong_syntax(formname, form ? id : NULL, 
+			  form ? form : id, "illegal use of keyword");
+  }
+
+  /* Allow #% for whatever if it's not already a keyword */
+/*
+  s = SCHEME_SYM_VAL(id);
+  if (s[0] == '#' && s[1] == '%')
+    scheme_signal_error("%s: illegal use of special identifier `%s'%s",
+			form, s, where);
+*/
+}
+
+static void init_compile_data(Scheme_Comp_Env *env)
+{
+  Compile_Data *data;
+  int i, c;
+
+  data = COMPILE_DATA(env);
+
+  data->stat_dists = NULL;
+  data->sd_depths = NULL;
+  c = env->basic.num_bindings;
+  data->use = MALLOC_N(int, c);
+  for (i = 0; i < c; i++)
+    data->use[i] = 0;
+
+  data->constants = NULL;
+}
+
+Scheme_Comp_Env *scheme_new_compilation_frame(int num_bindings, int flags,
+					 Scheme_Comp_Env *base)
+{
+  Scheme_Comp_Env *frame;
+  int count;
+  
+  count = num_bindings;
+
+  frame = (Scheme_Comp_Env *)MALLOC_ONE(Scheme_Full_Comp_Env);
+
+  frame->values = MALLOC_N(Scheme_Object *, count);
+
+  frame->basic.num_bindings = num_bindings;
+  frame->basic.flags = flags;
+  frame->basic.next = base;
+  frame->basic.genv = base->basic.genv;
+
+  init_compile_data(frame);
+
+  return frame;
+}
+
+int scheme_used_app_only(Scheme_Comp_Env *env, int which)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+
+  if (data->use[which] & ARBITRARY_USE)
+    return 0;
+  else
+    return 1;
+}
+
+int scheme_used_ever(Scheme_Comp_Env *env, int which)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+
+  return !!data->use[which];
+}
+
+int scheme_is_env_variable_boxed(Scheme_Comp_Env *env, int which)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+
+  return !!(data->use[which] & WAS_SET_BANGED);
+}
+
+void scheme_unsettable_variable(Scheme_Comp_Env *env, int which)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+
+  data->use[which] |= NOT_SETTABLE;
+}
+
+void
+scheme_add_compilation_binding(int index, Scheme_Object *val, Scheme_Comp_Env *frame)
+{
+  if ((index >= frame->basic.num_bindings) || (index < 0))
+    scheme_signal_error("internal error: scheme_add_binding: "
+			"index out of range: %d", index);
+  
+  frame->values[index] = val;
+}
+
+void scheme_push_constant(Scheme_Object *name, Scheme_Object *val,
+			  Scheme_Comp_Env *env)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+  Constant_Binding *b;
+  
+  b = (Constant_Binding *)scheme_malloc(sizeof(Constant_Binding));
+
+  b->next = data->constants;
+  b->name = name;
+  b->val = val;
+  b->before = env->basic.num_bindings;
+
+  data->constants = b;
+}
+
+void scheme_pop_constant(Scheme_Comp_Env *env)
+{
+  Compile_Data *data = COMPILE_DATA(env);
+
+  if (!data->constants)
+    scheme_signal_error("internal error: scheme_pop_constant: empty");
+
+  data->constants = data->constants->next;
+}
+
+Scheme_Comp_Env *
+scheme_add_compilation_frame(Scheme_Object *vals, Scheme_Comp_Env *env, int flags)
+{
+  Scheme_Comp_Env *frame;
+  int len, i, count;
+  
+
+  count = len = scheme_list_length(vals);
+
+  frame = scheme_new_compilation_frame(count, flags, env);
+
+  for (i = 0; i < len ; i++)
+    if (SCHEME_SYMBOLP(vals))
+      frame->values[i] = vals;
+    else {
+      frame->values[i] = SCHEME_CAR (vals);
+      vals = SCHEME_CDR (vals);
+    }
+  
+  init_compile_data(frame);
+
+  return frame;
+}
+
+Scheme_Comp_Env *scheme_no_defines(Scheme_Comp_Env *env)
+{
+  if (scheme_is_toplevel(env))
+    return scheme_new_compilation_frame(0, 0, env);
+  else
+    return env;
+}
+
+int scheme_is_toplevel(Scheme_Comp_Env *env)
+{
+  return !env->basic.next || (env->basic.flags & SCHEME_TOPLEVEL_FRAME);
+}
+
+Scheme_Comp_Env *scheme_extend_as_toplevel(Scheme_Comp_Env *env)
+{
+  if (scheme_is_toplevel(env))
+    return env;
+  else
+    return scheme_new_compilation_frame(0, SCHEME_TOPLEVEL_FRAME, env);
+}
+
+
+static Scheme_Object *alloc_local(short type, int pos)
+{
+  Scheme_Object *v;
+
+  v = (Scheme_Object *)scheme_malloc_atomic_tagged(sizeof(Scheme_Local));
+  v->type = type;
+  SCHEME_LOCAL_POS(v) = pos;
+
+  return (Scheme_Object *)v;
+}
+
+Scheme_Object *scheme_make_local(short type, int pos)
+{
+  int k;
+
+  k = type - scheme_local_type;
+
+  if (pos < MAX_CONST_LOCAL_POS)
+    return scheme_local[pos][k];
+
+  return alloc_local(type, pos);
+}
+
+static Scheme_Local *get_frame_loc(Scheme_Comp_Env *frame, Compile_Data *data,
+				   int i, int j, int p, int flags)
+{
+  data->use[i] |= (((flags & (SCHEME_APP_POS | SCHEME_SETTING))
+		    ? CONSTRAINED_USE
+		    : ARBITRARY_USE)
+		   | ((flags & (SCHEME_SETTING | SCHEME_LINKING_REF))
+		      ? WAS_SET_BANGED
+		      : 0));
+  
+  if (!data->stat_dists) {
+    data->stat_dists = MALLOC_N(char*, frame->basic.num_bindings);
+    data->sd_depths = MALLOC_N(int, frame->basic.num_bindings);
+    /* Rely on GC to zero-out array */
+  }
+  
+  if (data->sd_depths[i] <= j) {
+    char *naya, *a;
+    int k;
+    
+    naya = MALLOC_N(char, (j + 1));
+    a = data->stat_dists[i];
+    for (k = data->sd_depths[i]; k--; )
+      naya[k] = a[k];
+    
+    data->stat_dists[i] = naya;
+    data->sd_depths[i] = j + 1;
+  }
+
+  data->stat_dists[i][j] = 1;
+
+  return (Scheme_Local *)scheme_make_local(scheme_local_type, p + i);
+}
+
+Scheme_Object *
+scheme_static_distance(Scheme_Object *symbol, Scheme_Comp_Env *env, int flags)
+{
+  Scheme_Comp_Env *frame;
+  int j = 0, p = 0;
+  Scheme_Bucket *b;
+  Scheme_Object *val;
+  Scheme_Hash_Table *globals;
+  
+  frame = env;
+  for (frame = env; frame->basic.next != NULL; frame = frame->basic.next) {
+    int i;
+    Compile_Data *data = COMPILE_DATA(frame);
+    Constant_Binding *c = data->constants;
+    
+    if (frame->basic.flags & SCHEME_LAMBDA_FRAME)
+      j++;
+
+    for (i = frame->basic.num_bindings; i--; ) {
+      while (c && (c->before > i)) {
+	if (SAME_OBJ(symbol, c->name)) {
+	  val = c->val;
+	  goto found_const;
+	}
+	c = c->next;
+      }
+
+      if (SAME_OBJ(symbol, frame->values[i])) {
+	if ((flags & SCHEME_SETTING) && (data->use[i] & NOT_SETTABLE))
+	  scheme_wrong_syntax("set!", NULL, symbol,
+			      "imported/inherited variable cannot be mutated");
+
+	if (flags & SCHEME_DONT_MARK_USE)
+	  return scheme_make_local(scheme_local_type, 0);
+	else
+	  return (Scheme_Object *)get_frame_loc(frame, data, i, j, p, flags);
+      }
+    }
+
+    while (c) {
+      if (SAME_OBJ(symbol, c->name)) {
+	val = c->val;
+	goto found_const;
+      }
+      c = c->next;
+    }
+
+    p += frame->basic.num_bindings;
+  }
+
+  globals = get_globals(scheme_min_env(env));
+  b = scheme_bucket_from_table(globals, (char *)symbol);
+  if ((flags & SCHEME_ELIM_CONST) && b && b->val 
+      && (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST)
+      && !(flags & SCHEME_GLOB_ALWAYS_REFERENCE))
+    return (Scheme_Object *)b->val;
+
+  /* If the value in this env is syntax, we want the value, not a reference */
+  if (b->val && !(flags & SCHEME_GLOB_ALWAYS_REFERENCE)) {
+    Scheme_Type type = SCHEME_TYPE((Scheme_Object *)b->val);
+
+    if ((type ==  scheme_syntax_compiler_type)
+	|| (type == scheme_macro_type)
+	|| (type == scheme_id_macro_type)
+	|| (type == scheme_exp_time_type))
+      return (Scheme_Object *)b->val;
+  }
+
+  return (Scheme_Object *)b;
+
+ found_const:
+  if (!(flags & SCHEME_ENV_CONSTANTS_OK)) {
+    scheme_wrong_syntax("set!", NULL, symbol,
+			"local constant cannot be mutated");
+    return NULL;
+  }
+  return val;
+}
+
+void scheme_env_make_closure_map(Scheme_Comp_Env *env, short *_size, short **_map)
+{
+  Compile_Data *data;
+  Scheme_Comp_Env *frame;
+  int i, j, pos = 0, lpos = 0;
+  short *map, size;
+
+  /* Count vars used by this closure (skip args): */
+  j = 1;
+  for (frame = env->basic.next; frame; frame = frame->basic.next) {
+    data = COMPILE_DATA(frame);
+
+    if (frame->basic.flags & SCHEME_LAMBDA_FRAME)
+      j++;
+
+    if (data->stat_dists) {
+      for (i = 0; i < frame->basic.num_bindings; i++) {
+	if (data->sd_depths[i] > j) {
+	  if (data->stat_dists[i][j]) {
+	    pos++;
+	    if (frame->basic.flags & SCHEME_ANCHORED_FRAME)
+	      pos++;
+	  }
+	}
+      }
+    }
+  }
+
+  size = pos;
+  *_size = size;
+  map = MALLOC_N(short, size);
+  *_map = map;
+
+  /* Build map, unmarking locals and marking deeper in parent prame */
+  j = 1; pos = 0;
+  for (frame = env->basic.next; frame; frame = frame->basic.next) {
+    data = COMPILE_DATA(frame);
+
+    if (frame->basic.flags & SCHEME_LAMBDA_FRAME)
+      j++;
+
+    if (data->stat_dists) {
+      for (i = 0; i < frame->basic.num_bindings; i++) {
+	if (data->sd_depths[i] > j) {
+	  if (data->stat_dists[i][j]) {
+	    map[pos++] = lpos;
+	    if (frame->basic.flags & SCHEME_ANCHORED_FRAME)
+	      map[pos++] = -(lpos + 1);
+	    data->stat_dists[i][j] = 0; /* This closure's done with these vars... */
+	    data->stat_dists[i][j - 1] = 1; /* ... but insure previous keeps */
+	  }
+	}
+	lpos++;
+      }
+    } else
+      lpos += frame->basic.num_bindings;
+  }
+}
+
+int *scheme_env_get_flags(Scheme_Comp_Env *frame, int start, int count)
+{
+  Compile_Data *data = COMPILE_DATA(frame);
+  int *v, i;
+  
+  v = MALLOC_N(int, count);
+  memcpy(v, data->use + start, sizeof(int) * count);
+
+  for (i = count; i--; ) {
+    int old;
+    old = v[i];
+    v[i] = 0;
+    if (old & (ARBITRARY_USE | CONSTRAINED_USE))
+      v[i] |= SCHEME_WAS_USED;
+    if (old & WAS_SET_BANGED)
+      v[i] |= SCHEME_WAS_SET_BANGED;
+  }
+
+  return v;
+}
+
+Link_Info *scheme_link_info_create(int can_opt)
+{
+  Link_Info *naya;
+
+  naya = MALLOC_ONE(Link_Info);
+  naya->count = 0;
+  naya->next = NULL;
+  naya->can_optimize_constants = can_opt;
+
+  return naya;
+}
+
+Link_Info *scheme_link_info_extend(Link_Info *info, int size, int oldsize, int mapc)
+     /* size = number of appended items in run-time frame */
+     /* oldisze = number of appended items in original compile-time frame */
+     /* mapc = mappings that will be installed */
+{
+  Link_Info *naya;
+
+  naya = MALLOC_ONE(Link_Info);
+  naya->next = info;
+  naya->size = size;
+  naya->oldsize = oldsize;
+  naya->count = mapc;
+  naya->pos = 0;
+  naya->anchor_offset = 0;
+  naya->old_pos = MALLOC_N(short, mapc);
+  naya->new_pos = MALLOC_N(short, mapc);
+  naya->flags = MALLOC_N(int, mapc);
+
+  naya->can_optimize_constants = info->can_optimize_constants;
+
+  return naya;
+}
+
+void scheme_link_info_add_mapping(Link_Info *info, int oldp, int newp, int flags)
+{
+  if (info->pos == info->count) {
+    scheme_signal_error("internal error: add_mapping: "
+			"too many: %d", info->pos);
+  }
+
+  info->old_pos[info->pos] = oldp;
+  info->new_pos[info->pos] = newp;
+  info->flags[info->pos] = flags;
+  
+  info->pos++;
+}
+
+void scheme_link_info_set_anchor_offset(Link_Info *info, int offset)
+{
+  info->anchor_offset = offset;
+}
+
+static int link_info_lookup(Link_Info *info, int pos, int *flags)
+{
+  int i, offset = 0, orig = pos;
+  int get_anchor;
+
+  if (pos < 0) {
+    get_anchor = pos;
+    pos = -(pos + 1);
+  } else
+    get_anchor = 0;
+
+  while (info) {
+    for (i = info->pos; i--; ) {
+      int oldp = info->old_pos[i];
+      if (pos == oldp) {
+	/* not yet mapped anchor */
+	if (flags)
+	  *flags = info->flags[i];
+	return info->new_pos[i] + offset + (get_anchor ? info->anchor_offset : 0);
+      }
+      if (get_anchor && (get_anchor == oldp)) {
+	/* re-mapped anchor */
+	if (flags)
+	  *flags = info->flags[i];
+	return info->new_pos[i] + offset;
+      }
+    }
+
+    pos -= info->oldsize;
+    offset += info->size;
+    info = info->next;
+  }
+
+  scheme_signal_error("internal error: scheme_link_info_lookup: "
+		      "variable %d not found", orig);
+
+  return 0;
+}
+
+int scheme_link_info_flags(Link_Info *info, int pos)
+{
+  int flags;
+
+  link_info_lookup(info, pos, &flags);
+
+  return flags;
+}
+
+int scheme_link_info_lookup(Link_Info *info, int pos, int *flags)
+{
+  return link_info_lookup(info, pos, flags);
+}
+
+int scheme_link_info_lookup_anchor(Link_Info *info, int pos)
+{
+  return link_info_lookup(info, -(pos + 1), NULL);
+}
+
+
+Scheme_Object *
+scheme_lookup_global (Scheme_Object *symbol, Scheme_Env *env)
+{
+  return (Scheme_Object *)scheme_lookup_in_table(get_globals(env), (char *)symbol);
+}
+
+Scheme_Bucket *
+scheme_global_bucket (Scheme_Object *symbol, Scheme_Env *env)
+{
+  return scheme_bucket_from_table(get_globals(env), (char *)symbol);
+}
+
+Scheme_Object *scheme_make_envunbox(Scheme_Object *value)
+{
+  Scheme_Object *obj;
+
+  obj = (Scheme_Object *)scheme_malloc_envunbox(sizeof(Scheme_Object*));
+  SCHEME_ENVBOX_VAL(obj) = value;
+
+  return obj;
+}
+
+void scheme_constant(Scheme_Object *sym, Scheme_Env *env)
+{
+  if (!SCHEME_SYMBOLP(sym))
+    scheme_wrong_type("constant-name", "symbol", 0, 1, &sym);
+
+  do_add_global_symbol(env, sym, NULL, 1, 0);
+}
+
+static Scheme_Object *
+constant_prim(int argc, Scheme_Object *argv[])
+{
+  scheme_constant(argv[0], scheme_get_env(scheme_config));
+  return scheme_void;
+}
+
+static Scheme_Object *
+constant_all_prim (int argc, Scheme_Object *argv[])
+{
+  int i, j;
+  Scheme_Hash_Table *globals;
+  Scheme_Bucket *b;
+
+  for (i = 0; i < argc; i++)
+    if (!SCHEME_SYMBOLP(argv[i]))
+      scheme_wrong_type("constant-name-all-globals", 
+			"symbol", i, argc, argv);
+
+  globals = get_globals(scheme_get_env(scheme_config));
+
+  for (i = 0; i < globals->size; i++) {
+    b = globals->buckets[i];
+    if (b && b->val) {
+      for (j = 0; j < argc; j++)
+	if (b->key == (void *)argv[j])
+	  break;
+      
+      if (j >= argc)
+	((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_IS_CONST;
+    }
+  }
+
+  return scheme_void;
+}
+
+static Scheme_Object *keyword_prim(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("keyword-name", "symbol", 0, argc, argv);
+
+  scheme_set_keyword(argv[0], scheme_get_env(scheme_config));
+  return scheme_void;
+}
+
+static Scheme_Object *keyword_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Bucket *b;
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("keyword-name?", "symbol", 0, argc, argv);
+
+  b = scheme_global_bucket(argv[0], scheme_get_env(scheme_config));
+
+  return ((((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_KEYWORD) 
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+static Scheme_Object *list_globals(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *l = scheme_null;
+  int i;
+  Scheme_Hash_Table *globals;
+  Scheme_Bucket *b;
+
+  globals = get_globals(scheme_get_env(scheme_config));
+
+  for (i = 0; i < globals->size; i++) {
+    b = globals->buckets[i];
+    if (b && b->val)
+      l = scheme_make_pair(scheme_make_pair((Scheme_Object *)b->key, 
+					    (Scheme_Object *)b->val),
+			   l);
+  }
+
+  return l;
+}
+
+static Scheme_Object *defined(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("defined?", "symbol", 0, argc, argv);
+
+  return scheme_lookup_global(argv[0], scheme_get_env(scheme_config))
+    ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+global_defined_value(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Env *env;
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("global-defined-value", "symbol", 0, argc, argv);
+
+  env = scheme_get_env(scheme_config);
+
+  if (argc > 1) {
+    Scheme_Bucket *bucket;
+
+    bucket = scheme_global_bucket(argv[0], env);
+
+    scheme_set_global_bucket("global-defined-value", bucket, argv[1], 1);
+
+    return scheme_void;
+  } else {
+    v = scheme_lookup_global(argv[0], env);
+    
+    if (!v)
+      scheme_raise_exn(MZEXN_VARIABLE, argv[0],
+		       "global-defined-value: %s is not defined",
+		       scheme_symbol_name(argv[0]));
+
+    return v;
+  }
+}
+
+static Scheme_Object *
+local_exp_time_value(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Comp_Env *env;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expansion-time-value: illegal at run-time");
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("local-expansion-time-value", "symbol", 0, argc, argv);
+
+  v = scheme_static_distance(argv[0], env,
+			     (SCHEME_APP_POS + SCHEME_ENV_CONSTANTS_OK
+			      + SCHEME_ELIM_CONST));
+
+  /* Deref globls */
+  if (SAME_TYPE(SCHEME_TYPE(v), scheme_variable_type))
+    v = (Scheme_Object *)(SCHEME_VAR_BUCKET(v))->val;
+
+  if (!v || NOT_SAME_TYPE(SCHEME_TYPE(v), scheme_exp_time_type))
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expansion-time-value: %s is not defined "
+		     "as an expansion-time value",
+		     scheme_symbol_name(argv[0]));
+  
+  return SCHEME_PTR_VAL(v);
+}
+
+
+static Scheme_Object *
+global_exp_time_value(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Comp_Env *env;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "global-expansion-time-value: illegal at run-time");
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("global-expansion-time-value", "symbol", 0, argc, argv);
+
+  v = scheme_lookup_global(argv[0], scheme_min_env(env));
+
+  /* Deref global */
+  if (v && (SAME_TYPE(SCHEME_TYPE(v), scheme_variable_type)))
+    v = (Scheme_Object *)(SCHEME_VAR_BUCKET(v))->val;
+
+  if (!v || NOT_SAME_TYPE(SCHEME_TYPE(v), scheme_exp_time_type))
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "global-expansion-time-value: %s is not defined "
+		     "as an expansion-time value",
+		     scheme_symbol_name(argv[0]));
+  
+  return SCHEME_PTR_VAL(v);
+}
+
+
+static Scheme_Object *
+local_exp_time_bound_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Comp_Env *env;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expansion-time-bound?: illegal at run-time");
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("local-expansion-time-bound?", "symbol", 0, argc, argv);
+
+  v = scheme_static_distance(argv[0], env,
+			     (SCHEME_APP_POS + SCHEME_ENV_CONSTANTS_OK
+			      + SCHEME_ELIM_CONST));
+
+  /* Deref globls */
+  if (SAME_TYPE(SCHEME_TYPE(v), scheme_variable_type))
+    return scheme_false;
+  else
+    return scheme_true;
+}
+
+static Scheme_Object *
+local_exp_top_level_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Comp_Env *env;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expansion-top-level?: illegal at run-time");
+
+  return (scheme_is_toplevel(env)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+/*********************************************************************/
+
+static Scheme_Object *write_variable(Scheme_Object *obj)
+{
+  Scheme_Object *sym;
+
+  sym = (Scheme_Object *)(SCHEME_VAR_BUCKET(obj))->key;
+
+  return sym;
+}
+
+static Scheme_Object *read_variable(Scheme_Object *obj)
+{
+#if 0
+  if (!SCHEME_PAIRP(obj) || !SCHEME_NULLP(SCHEME_CDR(obj))
+      || !SCHEME_SYMBOLP(SCHEME_CAR(obj)))
+    scheme_signal_error("bad compiled global");
+#endif
+
+#define SCHEME_GLOBAL_REFERENCE (Scheme_Object *)scheme_global_bucket
+
+  return SCHEME_GLOBAL_REFERENCE(obj, scheme_get_env(scheme_config));
+}
+
+static Scheme_Object *write_local(Scheme_Object *obj)
+{
+  return scheme_make_integer(SCHEME_LOCAL_POS(obj));
+}
+
+static Scheme_Object *read_local(Scheme_Object *obj)
+{
+  return scheme_make_local(scheme_local_type,
+			   SCHEME_INT_VAL(obj));
+}
+
+static Scheme_Object *read_local_unbox(Scheme_Object *obj)
+{
+  return scheme_make_local(scheme_local_unbox_type,
+			   SCHEME_INT_VAL(obj));
+}
+
diff --git a/src/mzscheme/src/error.c b/src/mzscheme/src/error.c
new file mode 100644
index 0000000..37f1153
--- /dev/null
+++ b/src/mzscheme/src/error.c
@@ -0,0 +1,1315 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+/* globals */
+void (*scheme_console_printf)(char *str, ...);
+void (*scheme_exit)(int v);
+int scheme_secure_primitive_exn;
+
+#ifdef MEMORY_COUNTING_ON
+long scheme_misc_count;
+#endif
+
+/* locals */
+static Scheme_Object *error(int argc, Scheme_Object *argv[]);
+static Scheme_Object *raise_syntax_error(int argc, Scheme_Object *argv[]);
+static Scheme_Object *raise_type_error(int argc, Scheme_Object *argv[]);
+static Scheme_Object *error_escape_handler(int, Scheme_Object *[]);
+static Scheme_Object *error_display_handler(int, Scheme_Object *[]);
+static Scheme_Object *error_value_string_handler(int, Scheme_Object *[]);
+static Scheme_Object *exit_handler(int, Scheme_Object *[]);
+static Scheme_Object *error_print_width(int, Scheme_Object *[]);
+static Scheme_Object *def_error_escape_proc(int, Scheme_Object *[]);
+static Scheme_Object *def_error_display_proc(int, Scheme_Object *[]);
+static Scheme_Object *def_error_value_string_proc(int, Scheme_Object *[]);
+static Scheme_Object *def_exit_handler_proc(int, Scheme_Object *[]);
+static Scheme_Object *sch_exit (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *do_raise(Scheme_Object *arg, int return_ok, int need_debug);
+
+static Scheme_Object *newline_char;
+
+static Scheme_Object *def_err_val_proc;
+
+typedef struct {
+  int args;
+  Scheme_Object *type;
+  Scheme_Object **names;
+  int count;
+} exn_rec;
+
+#define _MZEXN_TABLE
+#include "schexn.h"
+#undef _MZEXN_TABLE
+
+static void default_printf(char *msg, ...)
+{
+  va_list args;
+  va_start(args, msg);
+  vfprintf(stderr, msg, args);
+  va_end(args);
+}
+
+void scheme_init_error_escape_proc(Scheme_Process *p)
+{
+  p->error_escape_proc = 
+    scheme_make_prim_w_arity(def_error_escape_proc,
+			     "default-error-escape-handler",
+			     0, 0);
+}
+
+void scheme_init_format_procedure(Scheme_Env *env)
+{
+  /* No longer needed... */
+}
+
+void scheme_init_error(Scheme_Env *env)
+{
+  if (!scheme_console_printf)
+    scheme_console_printf = default_printf;
+
+  scheme_add_global_constant("error", 
+			     scheme_make_prim_w_arity(error, 
+						      "error",
+						      1, -1), 
+			     env);
+  scheme_add_global_constant("raise-syntax-error", 
+			     scheme_make_prim_w_arity(raise_syntax_error, 
+						      "raise-syntax-error",
+						      2, 4), 
+			     env);
+  scheme_add_global_constant("raise-type-error", 
+			     scheme_make_prim_w_arity(raise_type_error, 
+						      "raise-type-error",
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("error-display-handler", 
+			     scheme_register_parameter(error_display_handler, 
+						       "error-display-handler",
+						       MZCONFIG_ERROR_DISPLAY_HANDLER), 
+			     env);
+  scheme_add_global_constant("error-value->string-handler", 
+			     scheme_register_parameter(error_value_string_handler, 
+						       "error-value->string-handler",
+						       MZCONFIG_ERROR_PRINT_VALUE_HANDLER), 
+			     env);
+  scheme_add_global_constant("error-escape-handler", 
+			     scheme_make_prim_w_arity(error_escape_handler, 
+						      "error-escape-handler",
+						      0, 1),
+			     env);
+  scheme_add_global_constant("exit-handler", 
+			     scheme_register_parameter(exit_handler, 
+						       "exit-handler",
+						       MZCONFIG_EXIT_HANDLER), 
+			     env);
+  scheme_add_global_constant("error-print-width", 
+			     scheme_register_parameter(error_print_width, 
+						       "error-print-width",
+						       MZCONFIG_ERROR_PRINT_WIDTH), 
+			     env);
+  scheme_add_global_constant("exit", 
+			     scheme_make_prim_w_arity(sch_exit, 
+						      "exit", 
+						      0, 1), 
+			     env);
+
+  if (scheme_starting_up) {
+    Scheme_Config *config = scheme_config;
+
+    newline_char = scheme_make_char('\n');
+    
+    scheme_set_param(config, MZCONFIG_EXIT_HANDLER,
+		     scheme_make_prim_w_arity(def_exit_handler_proc, 
+					      "default-exit-handler",
+					      1, 1));
+
+    scheme_set_param(config, MZCONFIG_ERROR_DISPLAY_HANDLER,
+		     scheme_make_prim_w_arity(def_error_display_proc,
+					      "default-error-display-handler",
+					      1, 1));
+
+    REGISTER_SO(def_err_val_proc);
+    def_err_val_proc = scheme_make_prim_w_arity(def_error_value_string_proc,
+						"default-error-value->string-handler",
+						2, 2);
+    scheme_set_param(config, MZCONFIG_ERROR_PRINT_VALUE_HANDLER,
+		     def_err_val_proc);
+  }
+}
+
+#define RAISE_RETURNED "exception handler did not escape"
+
+static void
+call_error(char *buffer, int len)
+{
+  Scheme_Object *p[1];
+  jmp_buf savebuf;
+
+  if (scheme_current_process->error_invoked == 5) {
+    scheme_longjmp (scheme_error_buf, 1);
+  } else if (scheme_current_process->error_invoked == 1) {
+    scheme_console_printf("Error trying to display error: %s\n", buffer);
+    scheme_longjmp (scheme_error_buf, 1);
+  } else if (scheme_current_process->error_invoked == 2) {
+    scheme_console_printf("Error trying to escape from error: %s\n", buffer);
+    scheme_longjmp(scheme_error_buf, 1);
+  } else {
+    scheme_current_process->error_invoked = 1;
+    p[0] = scheme_make_sized_string(buffer, len, 1);
+    memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+    if (scheme_setjmp(scheme_error_buf)) {
+      scheme_current_process->error_invoked = 0;
+      scheme_longjmp(savebuf, 1);
+    } else {
+      if (buffer)
+	scheme_apply_multi(scheme_get_param(scheme_config, MZCONFIG_ERROR_DISPLAY_HANDLER), 1, p);
+      scheme_current_process->error_invoked = 2;
+      /* Typically jumps out of here */
+      scheme_apply_multi(scheme_current_process->error_escape_proc, 0, NULL);
+      scheme_current_process->error_invoked = 0;
+      scheme_longjmp(savebuf, 1); /* force an exit */
+    }
+  }
+}
+
+static long get_print_width(void)
+{
+  long print_width;
+  Scheme_Object *w;
+
+  w = scheme_get_param(scheme_config, MZCONFIG_ERROR_PRINT_WIDTH);
+  if (SCHEME_INTP(w))
+    print_width = SCHEME_INT_VAL(w);
+  else
+    print_width = 10000;
+  
+  return print_width;
+}
+
+static char *init_buf(long *len)
+{
+  long size, print_width;
+
+  print_width = get_print_width();
+  
+  if (len)
+    *len = print_width;
+
+  size = (3 * scheme_max_found_symbol_name + 500
+	  + 2 * print_width);
+  return (char *)scheme_malloc_atomic(size);
+}
+
+void
+scheme_signal_error (char *msg, ...)
+{
+  va_list args;
+  char *buffer = init_buf(NULL);
+
+  va_start(args, msg);
+  vsprintf(buffer, msg, args);
+  va_end(args);
+
+  if (scheme_current_process->current_local_env)
+    strcat(buffer, " [during expansion]");
+
+  if (scheme_starting_up) {
+    scheme_console_printf("%s", buffer);
+    exit(0);
+  }
+
+#ifndef SCHEME_NO_EXN
+  scheme_raise_exn(MZEXN_MISC, "%s", buffer);
+#else
+  call_error(buffer, -1);
+#endif
+}
+
+void scheme_warning(char *msg, ...)
+{
+  va_list args;
+  char *buffer = init_buf(NULL);
+
+  va_start(args, msg);
+  vsprintf(buffer, msg, args);
+  va_end(args);
+
+  strcat(buffer, "\n");
+  scheme_write_string(buffer, strlen(buffer),
+		      scheme_get_param(scheme_config, MZCONFIG_ERROR_PORT));
+}
+
+static void pre_conv(void *v)
+{
+  scheme_current_process->err_val_str_invoked = 1;
+}
+	
+static Scheme_Object *now_do_conv(void *v)
+{
+  Scheme_Object **argv = (Scheme_Object **)v;
+  return _scheme_apply(argv[2], 2, argv);
+}
+
+static void post_conv(void *v)
+{
+  scheme_current_process->err_val_str_invoked = 0;
+}
+	
+static char *error_write_to_string_w_max(Scheme_Object *v, int len, int *lenout)
+{
+  Scheme_Object *o, *args[3];
+
+  o = scheme_get_param(scheme_config, MZCONFIG_ERROR_PRINT_VALUE_HANDLER);
+
+  if (SAME_OBJ(o, def_err_val_proc)
+      || (scheme_current_process->err_val_str_invoked)) {
+    long l;
+    char *s = scheme_write_to_string_w_max(v, &l, len);
+    if (lenout)
+      *lenout = l;
+    return s;
+  } else {
+    args[0] = v;
+    args[1] = scheme_make_integer(len);
+    args[2] = o;
+
+    o = scheme_dynamic_wind(pre_conv, now_do_conv,
+			    post_conv, NULL,
+			    (void *)args);
+
+    if (SCHEME_STRINGP(o)) {
+      char *s = SCHEME_STR_VAL(o);
+      if (SCHEME_STRTAG_VAL(o) > len) {
+	s[len] = 0;
+	if (lenout)
+	  *lenout = len;
+      } else if (lenout)
+	*lenout = SCHEME_STRTAG_VAL(o);
+      return s;
+    } else {
+      if (lenout)
+	*lenout = 3;
+      return "...";
+    }
+  }
+}
+
+static char *make_arity_expect_string(const char *name, int minc, int maxc, 
+				      int argc, Scheme_Object **argv)
+{
+  long len;
+  char *s = init_buf(&len);
+
+  if (!name)
+    name = "#<procedure>";
+  
+  if (minc < 0) {
+    const char *n;
+    if (minc == -2)
+      n = name;
+    else
+      n = scheme_get_proc_name((Scheme_Object *)name, NULL, 1);
+    sprintf(s, "%s: no clause matching %d argument%s",
+	    n ? n : "#<case-lambda-procedure>",
+	    argc, argc == 1 ? "" : "s");
+  } else if (!maxc)
+    sprintf(s, "%s: expects no arguments, given %d",
+	    name, argc);
+  else if (maxc < 0)
+    sprintf(s, "%s: expects at least %d argument%s, given %d",
+	    name, minc, (minc == 1) ? "" : "s", argc);
+  else if (minc == maxc)
+    sprintf(s, "%s: expects %d argument%s, given %d",
+	    name, minc, (minc == 1) ? "" : "s", argc);
+  else
+    sprintf(s, "%s: expects %d to %d arguments, given %d",
+	    name, minc, maxc, argc);
+
+  if (argc && argv) {
+    len /= argc;
+    if ((argc < 50) && (len >= 3)) {
+      int i, pos;
+      
+      strcat(s, ":");
+      pos = strlen(s);
+      
+      for (i = 0; i < argc; i++) {
+	int l;
+	char *o = error_write_to_string_w_max(argv[i], len, &l);
+	memcpy(s + pos, " ", 1);
+	memcpy(s + pos + 1, o, l);
+	pos += l + 1;
+      }
+
+      s[pos] = 0;
+    }
+  }
+
+  return s;
+}
+
+void scheme_wrong_count(const char *name, int minc, int maxc, int argc,
+			Scheme_Object **argv)
+{
+  Scheme_Object *arity; 
+  Scheme_Object *v = scheme_make_integer(argc);
+  char *s;
+
+  s = make_arity_expect_string(name, minc, maxc, argc, argv);
+
+  if (minc >= 0)
+    arity = scheme_make_arity(minc, maxc);
+  else if (minc == -1)
+    arity = scheme_arity((Scheme_Object *)name);
+  else
+    arity = scheme_false; /* BUG! */
+
+  scheme_raise_exn(MZEXN_APPLICATION_ARITY, v, arity, "%s", s);
+}
+
+void scheme_case_lambda_wrong_count(const char *name, 
+				    int argc, Scheme_Object **argv,
+				    int count, ...)
+{
+  Scheme_Object *arity, *a;
+  char *s;
+  va_list args;
+  int i;
+
+  arity = scheme_alloc_list(count);
+
+  va_start(args, count);
+  for (i = 0, a = arity; i < count; i++, a = SCHEME_CDR(a)) {
+    short mina, maxa;
+
+    mina= va_arg(args, int);
+    maxa = va_arg(args, int);
+    
+    SCHEME_CAR(a) = scheme_make_arity(mina, maxa);
+  }
+  va_end(args);
+
+  s = make_arity_expect_string(name, -2, 0, argc, argv);
+
+  scheme_raise_exn(MZEXN_APPLICATION_ARITY, scheme_make_integer(argc), 
+		   arity, "%s", s);
+}
+
+char *scheme_make_arity_expect_string(Scheme_Object *proc,
+				      int argc, Scheme_Object **argv)
+{
+  const char *name;
+  int mina, maxa;
+
+  if (SCHEME_PRIMP(proc)) {
+    name = ((Scheme_Primitive_Proc *)proc)->name;
+    mina = ((Scheme_Primitive_Proc *)proc)->mina;
+    maxa = ((Scheme_Primitive_Proc *)proc)->maxa;
+  } else if (SCHEME_CLSD_PRIMP(proc)) {
+    name = ((Scheme_Closed_Primitive_Proc *)proc)->name;
+    mina = ((Scheme_Closed_Primitive_Proc *)proc)->mina;
+    maxa = ((Scheme_Closed_Primitive_Proc *)proc)->maxa;
+  } else {
+    Scheme_Closure_Compilation_Data *data;
+    
+    data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(proc);
+    mina = maxa = data->num_params;
+    if (data->flags & CLOS_HAS_REST) {
+      --mina;
+      maxa = -1;
+    }
+    name = "#<procedure>";
+  }
+
+  return make_arity_expect_string(name, mina, maxa, argc, argv);
+}
+
+char *scheme_make_args_string(char *s, int which, int argc, Scheme_Object **argv)
+{
+  char *other;
+  long len;
+  
+  other = init_buf(&len);
+  
+  len /= (argc - (((which >= 0) && (argc > 1)) ? 1 : 0));
+  if ((argc < 50) && (len >= 3)) {
+    int i, pos;
+    
+    sprintf(other, "; %sarguments were:", s);
+    pos = strlen(other);
+    for (i = 0; i < argc; i++) {
+      if (i != which) {
+	int l;
+	char *o = error_write_to_string_w_max(argv[i], len, &l);
+	memcpy(other + pos, " ", 1);
+	memcpy(other + pos + 1, o, l);
+	pos += l + 1;
+      }
+    }
+    other[pos] = 0;
+  } else {
+    sprintf(other, "; given %d arguments total", argc);
+  }
+
+  return other;
+}
+
+const char *scheme_number_suffix(int which)
+{
+  static char *ending[] = {"st", "nd", "rd"};
+
+  if (!which)
+    return "th";
+  --which;
+
+  which = which % 100;
+
+  return ((which < 10 || which >= 20)
+	  && ((which % 10) < 3)) ? ending[which % 10] : "th";
+}
+
+void scheme_wrong_type(const char *name, const char *expected, 
+		       int which, int argc,
+		       Scheme_Object **argv)
+{
+  Scheme_Object *o;
+  char *s;
+  Scheme_Object *typesym;
+
+  o = argv[which < 0 ? 0 : which];
+
+  s = scheme_make_provided_string(o, 1, NULL);
+
+  typesym = scheme_intern_symbol(expected);
+
+  if ((which < 0) || (argc == 1))
+    scheme_raise_exn(MZEXN_APPLICATION_TYPE, o, typesym,
+		     "%s: expects argument of type <%s>; "
+		     "given %s",
+		     name, expected, s);
+  else {
+    char *other;
+
+    if ((which >= 0) && (argc > 1))
+      other = scheme_make_args_string("other ", which, argc, argv);
+    else
+      other = "";
+
+    scheme_raise_exn(MZEXN_APPLICATION_TYPE, o, typesym,
+		     "%s: expects type <%s> as %d%s argument, "
+		     "given: %s%s",
+		     name, expected, which + 1,
+		     scheme_number_suffix(which + 1),
+		     s, other);
+  }
+}
+
+void scheme_wrong_syntax(const char *where, 
+			 Scheme_Object *detail_form, 
+			 Scheme_Object *form, 
+			 const char *detail, ...)
+{
+  long len;
+  char *s, *buffer = init_buf(&len);
+  char *v, *dv;
+
+  s = init_buf(&len);
+
+  if (form)
+    v = error_write_to_string_w_max(form, len, NULL);
+  else {
+    form = scheme_false;
+    v = NULL;
+  }
+
+  if (detail_form)
+    dv = error_write_to_string_w_max(detail_form, len, NULL);
+  else
+    dv = NULL;
+
+  if (!detail) {
+    s = "bad syntax";
+  } else {
+    va_list args;
+
+    va_start(args, detail);
+    vsprintf(s, detail, args);
+    va_end(args);
+  }
+  
+  if (v) {
+    if (dv)
+      sprintf(buffer, "%s: %s at: %s in: %s", where, s, dv, v);
+    else
+      sprintf(buffer, "%s: %s in: %s", where, s, v);
+  } else
+    sprintf(buffer, "%s: %s", where, s);
+
+  scheme_raise_exn(MZEXN_SYNTAX, form, "%s", buffer);
+}
+
+void scheme_wrong_rator(Scheme_Object *rator, int argc, Scheme_Object **argv)
+{
+  long len;
+  char *s, *r;
+
+  s = init_buf(&len);
+
+  r = scheme_make_provided_string(rator, 1, NULL);
+
+  if (argc)
+    len /= argc;
+
+  if (argc && (argc < 50) && (len >= 3)) {
+    int i;
+
+    strcpy(s, "; arguments were:");
+    for (i = 0; i < argc; i++) {
+      char *o = error_write_to_string_w_max(argv[i], len, NULL);
+      strcat(s, " ");
+      strcat(s, o);
+    }
+  } else if (argc)
+    sprintf(s, " (%d args)", argc);
+  else
+    s = " (no arguments)";
+
+  scheme_raise_exn(MZEXN_APPLICATION_NON_PROCEDURE, rator,
+		   "procedure application: expected procedure, given: %s%s",
+		   r, s);
+}
+
+void scheme_wrong_return_arity(const char *where, 
+			       int expected, int got,
+			       Scheme_Object **argv,
+			       const char *detail, ...)
+{
+  char *s, *buffer = init_buf(NULL);
+  char *v;
+
+  if (!detail) {
+    s = NULL;
+  } else {
+    va_list args;
+
+    s = init_buf(NULL);
+
+    va_start(args, detail);
+    vsprintf(s, detail, args);
+    va_end(args);
+  }
+
+  if (!got || !argv) {
+    v = "";
+  } else {
+    int i;
+    long len, origlen, maxpos;
+    Scheme_Object **array;
+
+    v = init_buf(&len);
+    v[0] = ':';
+    v[1] = 0;
+
+    array = ((got == 1) ? (Scheme_Object **)&argv : argv);
+
+    origlen = len;
+    len /= got;
+
+    maxpos = got;
+    if (len < 3) {
+      maxpos = origlen / 4;
+      len = 3;
+    }
+
+    for (i = 0; i < got; i++) {
+      char *o = error_write_to_string_w_max(array[i], len, NULL);
+      strcat(v, " ");
+      strcat(v, o);
+    }
+
+    if (maxpos != got)
+      strcat(v, " ...");
+  }
+
+  sprintf(buffer, 
+	  "%s%scontext%s%s%s expected %d value%s,"
+	  " received %d value%s%s",
+	  where ? where : "",
+	  where ? ": " : "",
+	  s ? " (for " : "",
+	  s ? s : "",
+	  s ? ")" : "",
+	  expected,
+	  (expected == 1) ? "" : "s",
+	  got,
+	  (got == 1) ? "" : "s",
+	  v);
+
+  scheme_raise_exn(MZEXN_APPLICATION_ARITY, 
+		   scheme_make_integer(got),
+		   scheme_make_integer(expected),
+		   buffer);
+}
+
+void scheme_raise_out_of_memory(const char *where, const char *msg, ...)
+{
+  char *s;
+
+  if (!msg) {
+    s = "";
+  } else {
+    va_list args;
+
+    s = init_buf(NULL);
+
+    va_start(args, msg);
+    vsprintf(s, msg, args);
+    va_end(args);
+  }
+
+  scheme_raise_exn(MZEXN_MISC_OUT_OF_MEMORY,
+		   "%s%sout of memory %s",
+		   where ? where : "",
+		   where ? ": " : "",
+		   s);
+}
+
+void scheme_raise_else(const char *where, Scheme_Object *v)
+{
+  char *r;
+
+  r = scheme_make_provided_string(v, 1, NULL);
+
+  scheme_raise_exn(MZEXN_ELSE, 
+		   "%s: no match found for %s",
+		   where, r);
+}
+
+void scheme_unbound_global(Scheme_Object *name)
+{
+  scheme_raise_exn(MZEXN_VARIABLE, 
+		   name,
+		   "reference to undefined identifier: %s",
+		   scheme_symbol_name(name));
+}
+
+char *scheme_make_provided_string(Scheme_Object *o, int count, int *lenout)
+{
+  long len;
+
+  len = get_print_width();
+
+  if (count)
+    len /= count;
+
+  return error_write_to_string_w_max(o, len, lenout);
+
+  /* Old style, with type string: */
+#if 0
+  long len;
+  char *s, *r;
+
+  s = init_buf(&len);
+
+  if (count)
+    len /= count;
+
+  r = error_write_to_string_w_max(o, len, lenout);
+
+  if (count == 1)
+    sprintf(s, "%s (type %s)", r, scheme_get_type_name(SCHEME_TYPE(o)));
+  else
+    s = r;
+
+  return s;
+#endif
+}
+
+static Scheme_Object *error(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *newargs[2];
+
+  if (SCHEME_SYMBOLP(argv[0])) {
+    if (argc < 2) {
+      const char *s;
+      int l;
+
+      s = scheme_symbol_name_and_size(argv[0], &l, 0);
+
+      /* Just a symbol */
+      newargs[0] = 
+	scheme_append_string(scheme_make_string("error: "),
+			     scheme_make_sized_string((char *)s, l, 1));
+    } else {
+      char *s, *r;
+      int l, l2;
+      Scheme_Object *port = scheme_make_string_output_port();
+
+      /* Chez-style: symbol, format string, format items... */
+      if (!SCHEME_STRINGP(argv[1]))
+	scheme_wrong_type("error", "string", 1, argc, argv);
+      
+      scheme_do_format("error", port, NULL, -1, 1, 2, argc, argv);
+
+      s = scheme_get_sized_string_output(port, &l);
+
+      l2 = SCHEME_SYM_LEN(argv[0]);
+      r = MALLOC_N_ATOMIC(char, l + l2 + 3);
+      memcpy(r, SCHEME_SYM_VAL(argv[0]), l2);
+      memcpy(r + l2, ": ", 2);
+      memcpy(r + l2 + 2, s, l + 1);
+
+      newargs[0] = scheme_make_sized_string(r, l + l2 + 2, 0);
+    }
+  } else {
+    Scheme_Config *config = scheme_config;
+    Scheme_Object *strout;
+    char *str;
+    int len, i;
+
+    /* String followed by other values: */
+    if (!SCHEME_STRINGP(argv[0]))
+      scheme_wrong_type("error", "string or symbol", 0, argc, argv);
+
+    strout = scheme_make_string_output_port();
+
+    scheme_internal_display(argv[0], strout, config);
+    for (i = 1; i < argc ; i++) {
+      scheme_write_string(" ", 1, strout);
+      scheme_internal_write(argv[i], strout, config);
+    }
+
+    str = scheme_get_sized_string_output(strout, &len);
+    newargs[0] = scheme_make_sized_string(str, len, 0);
+  }
+
+#ifndef NO_SCHEME_EXNS
+  newargs[1] = scheme_void;
+  do_raise(scheme_make_struct_instance(exn_table[MZEXN_USER].type, 
+				       2, newargs), 
+	   0, 1);
+  
+  return scheme_void;
+#else
+  _scheme_apply_multi(scheme_get_param(scheme_config, MZCONFIG_ERROR_DISPLAY_HANDLER), 1, newargs);
+
+  return _scheme_tail_apply(scheme_current_process->error_escape_proc,
+			    0, NULL);
+#endif
+}
+
+static Scheme_Object *raise_syntax_error(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("raise-syntax-error", "symbol", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type("raise-syntax-error", "string", 1, argc, argv);
+
+  scheme_wrong_syntax(scheme_symbol_name(argv[0]), 
+		      (argc > 3) ? argv[3] : NULL,
+		      (argc > 2) ? argv[2] : NULL,
+		      "%s", SCHEME_STR_VAL(argv[1]));
+
+  return NULL;
+}
+
+static Scheme_Object *raise_type_error(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("raise-syntax-error", "symbol", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type("raise-syntax-error", "string", 1, argc, argv);
+
+  scheme_wrong_type(scheme_symbol_name(argv[0]),
+		    SCHEME_STR_VAL(argv[1]),
+		    -1, 0, &argv[2]);
+
+  return NULL;
+}
+
+static Scheme_Object *good_print_width(int c, Scheme_Object **argv)
+{
+  return ((SCHEME_INTP(argv[0]) || (SCHEME_BIGNUMP(argv[0])))
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *error_print_width(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("error-print-width", MZCONFIG_ERROR_PRINT_WIDTH,
+			     argc, argv,
+			     -1, good_print_width, "integer greater than three", 0);
+}
+
+static Scheme_Object *
+def_error_display_proc(int argc, Scheme_Object *argv[])
+{
+  Scheme_Config *config = scheme_config;
+  Scheme_Object *port = scheme_get_param(config, MZCONFIG_ERROR_PORT);
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("default-error-display-handler", "string", 0, argc, argv);
+
+  scheme_write_string(SCHEME_STR_VAL(argv[0]), 
+		      SCHEME_STRTAG_VAL(argv[0]),
+		      port);
+  scheme_write_string("\n", 1, port);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+def_error_value_string_proc(int argc, Scheme_Object *argv[])
+{
+  long origl, len, l;
+  char *s;
+
+  if (!SCHEME_INTP(argv[1]))
+    scheme_wrong_type("default-error-value->string-handler", "number", 1, argc, argv);
+
+  origl = len = SCHEME_INT_VAL(argv[1]);
+
+  if (len < 3)
+    len = 3;
+
+  s = scheme_write_to_string_w_max(argv[0], &l, len);
+
+  if ((origl < 3) && (l > origl))
+    l = origl;
+
+  return scheme_make_sized_string(s, l, 0);
+}
+
+static Scheme_Object *
+def_error_escape_proc(int argc, Scheme_Object *argv[])
+{
+  scheme_longjmp(scheme_error_buf, 1);
+
+  return scheme_void; /* Never get here */
+}
+
+static Scheme_Object *
+error_display_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("error-display-handler", MZCONFIG_ERROR_DISPLAY_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+error_value_string_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("error-value->string-handler", 
+			     MZCONFIG_ERROR_PRINT_VALUE_HANDLER,
+			     argc, argv,
+			     2, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+error_escape_handler(int argc, Scheme_Object *argv[])
+{
+  if (argc) {
+    scheme_check_proc_arity("error-escape-handler", 0,
+			    0, argc, argv);
+    scheme_current_process->error_escape_proc = argv[0];
+    return scheme_void;
+  } else
+    return scheme_current_process->error_escape_proc;
+}
+
+static Scheme_Object *
+exit_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("exit-handler", MZCONFIG_EXIT_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+def_exit_handler_proc(int argc, Scheme_Object *argv[])
+{
+  long status;
+
+  if (SCHEME_INTP(argv[0]))
+    status = SCHEME_INT_VAL(argv[0]);
+  else
+    status = 0;
+
+  if (scheme_exit)
+    scheme_exit(status);
+  else
+    exit(status);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+sch_exit(int argc, Scheme_Object *argv[])
+{
+  long status;
+  Scheme_Object *handler;
+
+  if (argc == 1) {
+    if (SCHEME_INTP(argv[0]))
+      status = SCHEME_INT_VAL(argv[0]);
+    else
+      status = 0;
+  } else
+    status = 0;
+
+  handler = scheme_get_param(scheme_config, MZCONFIG_EXIT_HANDLER);
+
+  if (handler) {
+    Scheme_Object *p[1];
+
+    p[0] = argc ? argv[0] : scheme_make_integer(status);
+    scheme_apply_multi(handler, 1, p);
+  } else if (scheme_exit)
+    scheme_exit(status);
+  else
+    exit(status);
+
+  return scheme_void;
+}
+
+/***********************************************************************/
+
+void
+scheme_raise_exn(int id, ...)
+{
+  va_list args;
+  char *msg;
+  int i, c;
+  Scheme_Object *eargs[MZEXN_MAXARGS];
+  char *buffer = init_buf(NULL);
+
+  va_start(args, id);
+
+  if (id == MZEXN_OTHER)
+    c = 3;
+  else
+    c = exn_table[id].args;
+
+  for (i = 2; i < c; i++)
+    eargs[i] = va_arg(args, Scheme_Object*);
+
+  msg = va_arg(args, char*);
+
+  vsprintf(buffer, msg, args);
+  va_end(args);
+
+#ifndef NO_SCHEME_EXNS
+  eargs[0] = scheme_make_string(buffer);
+  eargs[1] = scheme_void;
+
+  do_raise(scheme_make_struct_instance(exn_table[id].type, 
+				       c, eargs),
+	   0, 1);
+#else
+  call_error(buffer, -1);
+#endif
+}
+
+#ifndef NO_SCHEME_EXNS
+
+static Scheme_Object *
+def_exn_handler(int argc, Scheme_Object *argv[])
+{
+  char *s;
+  int len = -1;
+
+  if (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_structure_type)
+      && scheme_is_struct_instance(exn_table[MZEXN].type, argv[0])) {
+    Scheme_Object *str = ((Scheme_Structure *)argv[0])->slots[0];
+    if (SCHEME_STRINGP(str)) {
+      s = SCHEME_STR_VAL(str);
+      len = SCHEME_STRTAG_VAL(str);
+    } else
+      s = "[exn-message not a string]";
+  } else {
+    char *v;
+
+    v = scheme_make_provided_string(argv[0], 1, &len);
+    s = scheme_malloc_atomic(len + 21);
+    memcpy(s, "uncaught exception: ", 20);
+    memcpy(s + 20, v, len + 1);
+    len += 20;
+  }
+
+  call_error(s, len);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+def_debug_info_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_void;
+}
+
+static Scheme_Object *
+exn_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-exception-handler", MZCONFIG_EXN_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+debug_info_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("debug-info-handler", MZCONFIG_DEBUG_INFO_HANDLER,
+			     argc, argv,
+			     0, NULL, NULL, 0);
+}
+
+static void pre_raise(void *v)
+{
+  scheme_current_process->exn_raised = 1;
+}
+	
+static Scheme_Object *now_do_raise(void *v)
+{
+  Scheme_Object *p[1];
+
+  p[0] = (Scheme_Object *)v;
+
+  return _scheme_apply(scheme_get_param(scheme_config, MZCONFIG_EXN_HANDLER), 
+		       1, (Scheme_Object **)p);
+}
+
+static void post_raise_or_debug(void *v)
+{
+  scheme_current_process->exn_raised = 0;
+}
+	
+static void pre_debug(void *v)
+{
+  scheme_current_process->exn_raised = 2;
+}
+	
+static Scheme_Object *now_do_debug(void *v)
+{
+  Scheme_Config *config = scheme_config;
+
+  return _scheme_apply(scheme_get_param(config, MZCONFIG_DEBUG_INFO_HANDLER), 
+		       0, NULL);
+}
+
+static Scheme_Object *
+do_raise(Scheme_Object *arg, int return_ok, int need_debug)
+{
+ Scheme_Object *v;
+
+ if (scheme_current_process->error_invoked)
+   call_error("exception", -1);
+
+ if (scheme_current_process->exn_raised) {
+   long len;
+   char *buffer = init_buf(&len);
+
+   sprintf(buffer, "exception %s raised by %s",
+	   error_write_to_string_w_max(arg, len, NULL),
+	   (scheme_current_process->exn_raised < 2) 
+	   ? "exception handler"
+	   : "debug info handler");
+
+   call_error(buffer, -1);
+
+   return scheme_void;
+ }
+
+ if (need_debug) {
+   ((Scheme_Structure *)arg)->slots[1] = 
+     scheme_dynamic_wind(pre_debug, now_do_debug,
+			 post_raise_or_debug, NULL,
+			 (void *)arg);
+ }
+
+ v = scheme_dynamic_wind(pre_raise, now_do_raise,
+			 post_raise_or_debug, NULL,
+			 (void *)arg);
+
+ if (return_ok)
+   return v;
+
+ call_error(RAISE_RETURNED, -1);
+
+ return scheme_void;
+}
+
+static Scheme_Object *
+sch_raise(int argc, Scheme_Object *argv[])
+{
+  return do_raise(argv[0], 0, 0);
+}
+
+static Scheme_Object *
+secure_exn_types(int argc, Scheme_Object *argv[])
+{
+  scheme_secure_exceptions(scheme_get_env(scheme_config));
+  
+  return scheme_void;
+}
+
+#define NEEDED_BY_SCHEME_BASED_PRIMS(x) \
+        ((x == MZEXN_SYNTAX) || (x == MZEXN_APPLICATION_TYPE) \
+         || (x == MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS) \
+         || (x == MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT) \
+	 || (x == MZEXN_I_O_FILESYSTEM_DIRECTORY))
+
+void scheme_init_exn(Scheme_Env *env)
+{
+  int i, j;
+  Scheme_Object *s; 
+
+  if (scheme_starting_up) {
+#define _MZEXN_DECL_FIELDS
+#include "schexn.h"
+#undef _MZEXN_DECL_FIELDS
+
+    REGISTER_SO(exn_table);
+
+#ifdef MEMORY_COUNTING_ON
+#ifndef GLOBAL_EXN_TABLE
+    scheme_misc_count += (sizeof(exn_rec) * MZEXN_OTHER);
+#endif
+#endif
+
+#define _MZEXN_PRESETUP
+#include "schexn.h"
+#undef _MZEXN_PRESETUP
+
+#define EXN_PARENT(id) exn_table[id].type
+
+#define EXN_FLAGS SCHEME_STRUCT_NO_SET
+
+#define SETUP_STRUCT(id, parent, name, argc, args) \
+    exn_table[id].type = scheme_make_struct_type_from_string(name, parent, argc); \
+    exn_table[id].names = scheme_make_struct_names_from_array(name, argc, args, EXN_FLAGS, &exn_table[id].count);
+
+#define EXNCONS scheme_make_pair
+#define _MZEXN_SETUP
+#include "schexn.h"
+  }
+
+  for (i = 0; i < MZEXN_OTHER; i++) {
+    if (exn_table[i].count) {
+      Scheme_Object **values;
+      values = scheme_make_struct_values(exn_table[i].type,
+					 exn_table[i].names,
+					 exn_table[i].count,
+					 EXN_FLAGS);
+      for (j = exn_table[i].count; j--; ) {
+	if (!scheme_secure_primitive_exn || (j > 1))
+	  scheme_add_global_constant_symbol(exn_table[i].names[j],
+				     values[j],
+				     env);
+	else if (NEEDED_BY_SCHEME_BASED_PRIMS(i))
+	  scheme_add_global_symbol(exn_table[i].names[j],
+				   values[j],
+				   env);
+      }
+    }
+  }
+
+  scheme_add_global_constant("current-exception-handler", 
+			     scheme_register_parameter(exn_handler, 
+						       "current-exception-handler",
+						       MZCONFIG_EXN_HANDLER), 
+			     env);
+
+  s = scheme_register_parameter(debug_info_handler, 
+				"debug-info-handler",
+				MZCONFIG_DEBUG_INFO_HANDLER);
+
+  if (!scheme_secure_primitive_exn)
+    scheme_add_global_constant("debug-info-handler", s, env);
+  else
+    scheme_add_global("debug-info-handler", s, env);    
+
+  scheme_add_global_constant("raise", 
+			     scheme_make_prim_w_arity(sch_raise, 
+						      "raise", 
+						      1, 1), 
+			     env);
+
+  scheme_add_global_constant("secure-primitive-exception-types",
+			     scheme_make_prim_w_arity(secure_exn_types,
+						      "secure-primitive-exception-types",
+						      0, 0),
+			     env);
+
+  if (scheme_starting_up) {
+    Scheme_Config *config = scheme_config;
+    
+    scheme_set_param(config, MZCONFIG_DEBUG_INFO_HANDLER,
+		     scheme_make_prim_w_arity(def_debug_info_handler,
+					      "default-debug-info-handler",
+					      0, 0));
+
+    scheme_set_param(config, MZCONFIG_EXN_HANDLER,
+		     scheme_make_prim_w_arity(def_exn_handler,
+					      "default-exception-handler",
+					      1, 1));
+  }
+}
+
+static void scheme_do_secure_exceptions(Scheme_Env *env, int leftovers)
+{
+  /* Undefine the struct types and constructors for all prim exceptions */
+  int i;
+
+  for (i = 0; i < MZEXN_OTHER; i++) {
+    if (leftovers) {
+      if (NEEDED_BY_SCHEME_BASED_PRIMS(i))
+	scheme_remove_global(SCHEME_SYM_VAL(exn_table[i].names[1]), 
+			     env);
+    } else {
+      scheme_remove_global_constant(SCHEME_SYM_VAL(exn_table[i].names[0]), 
+				    env);
+      scheme_remove_global_constant(SCHEME_SYM_VAL(exn_table[i].names[1]), 
+				   env);
+    }
+  }
+
+  if (leftovers)
+    scheme_remove_global("debug-info-handler", env);
+  else
+    scheme_remove_global_constant("debug-info-handler", env);
+}
+
+void scheme_secure_exceptions(Scheme_Env *env)
+{
+  scheme_do_secure_exceptions(env, 0);
+}
+
+void scheme_secure_leftover_exceptions(Scheme_Env *env)
+{
+  scheme_do_secure_exceptions(env, 1);
+}
+
+#endif
diff --git a/src/mzscheme/src/eval.c b/src/mzscheme/src/eval.c
new file mode 100644
index 0000000..c047ce9
--- /dev/null
+++ b/src/mzscheme/src/eval.c
@@ -0,0 +1,3151 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include "schrunst.h"
+
+#ifdef USE_STACKAVAIL
+#include <malloc.h>
+#endif
+#ifdef UNIX_FIND_STACK_BOUNDS
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+#include "schmach.h"
+#ifdef MACOS_STACK_LIMIT
+#include <Memory.h>
+#endif
+
+/* Debugging stuff: */
+#define OPT_COMPILE_VISIBLE 0
+
+/* globals */
+
+int scheme_allow_cond_auto_else = 1;
+
+Scheme_Object *scheme_eval_waiting;
+Scheme_Object *scheme_multiple_values;
+Scheme_Object *scheme_null_break_poll;
+
+#ifndef MZ_REAL_THREADS
+int scheme_fuel_counter;
+#endif
+
+int scheme_stack_grows_up;
+
+/* locals */
+static Scheme_Object *eval(int argc, Scheme_Object *argv[]);
+static Scheme_Object *compile(int argc, Scheme_Object *argv[]);
+#if OPT_COMPILE_VISIBLE
+static Scheme_Object *compile_x(int argc, Scheme_Object *argv[]);
+#endif
+static Scheme_Object *expand(int argc, Scheme_Object **argv);
+static Scheme_Object *local_expand(int argc, Scheme_Object **argv);
+static Scheme_Object *local_expand_body_expression(int argc, Scheme_Object **argv);
+static Scheme_Object *expand_once(int argc, Scheme_Object **argv);
+static Scheme_Object *enable_break(int, Scheme_Object *[]);
+static Scheme_Object *exn_enable_break(int, Scheme_Object *[]);
+static Scheme_Object *user_break_poll(int, Scheme_Object *[]);
+static Scheme_Object *dynamic_enable_break(int, Scheme_Object *[]);
+static Scheme_Object *current_eval(int argc, Scheme_Object *[]);
+
+static Scheme_Object *built_in_name(int argc, Scheme_Object **argv);
+
+static Scheme_Object *allow_auto_cond_else(int argc, Scheme_Object **argv);
+static Scheme_Object *allow_set_undefined(int argc, Scheme_Object **argv);
+
+static Scheme_Object *default_eval_handler(int, Scheme_Object *[]);
+static Scheme_Object *default_user_break_poll_proc(int c, Scheme_Object **a);
+
+static Scheme_Object *write_application(Scheme_Object *obj);
+static Scheme_Object *read_application(Scheme_Object *obj);
+static Scheme_Object *write_sequence(Scheme_Object *obj);
+static Scheme_Object *read_sequence(Scheme_Object *obj);
+static Scheme_Object *read_sequence_save_first(Scheme_Object *obj);
+static Scheme_Object *write_branch(Scheme_Object *obj);
+static Scheme_Object *read_branch(Scheme_Object *obj);
+static Scheme_Object *write_syntax(Scheme_Object *obj);
+static Scheme_Object *read_syntax(Scheme_Object *obj);
+
+static Scheme_Object *define_values_symbol, *letrec_star_values_symbol, *lambda_symbol;
+static Scheme_Object *unknown_symbol, *void_link_symbol, *quote_symbol;
+static Scheme_Object *letmacro_symbol, *begin_symbol;
+static Scheme_Object *let_id_macro_symbol;
+static Scheme_Object *let_exp_time_symbol;
+static Scheme_Object *let_symbol;
+
+#define cons(x,y) scheme_make_pair(x,y)
+
+#define TAIL_COPY_THRESHOLD 5
+
+#ifndef MZ_REAL_THREADS
+#define DO_CHECK_FOR_BREAK(p, e) \
+	if ((scheme_fuel_counter--) <= 0) { \
+	  e scheme_process_block(0); \
+          (p)->ran_some = 1; \
+	}
+#else
+#define DO_CHECK_FOR_BREAK(p, e) \
+	if (((p)->fuel_counter--) <= 0) { \
+	  e scheme_process_block_w_process(0, p); \
+	}
+#endif
+
+#if defined(UNIX_FIND_STACK_BOUNDS) || defined(WINDOWS_FIND_STACK_BOUNDS) || defined(ASSUME_FIXED_STACK_SIZE)
+#ifndef MZ_REAL_THREADS
+unsigned long scheme_stack_boundary;
+#endif
+#endif
+
+#define REGISTYPE(f) f ## _type
+
+void
+scheme_init_eval (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    Scheme_Config *config = scheme_config;
+
+    REGISTER_SO(scheme_eval_waiting);
+    REGISTER_SO(scheme_multiple_values);
+    REGISTER_SO(scheme_null_break_poll);
+
+#ifdef MZ_EVAL_WAITING_CONSTANT
+    scheme_eval_waiting = MZ_EVAL_WAITING_CONSTANT;
+#else
+    scheme_eval_waiting = scheme_alloc_eternal_object();
+    scheme_eval_waiting->type = scheme_eval_waiting_type;
+#endif
+
+#ifdef MZ_EVAL_WAITING_CONSTANT
+    scheme_multiple_values = MZ_MULTIPLE_VALUES_CONSTANT;
+#else
+    scheme_multiple_values = scheme_alloc_eternal_object();
+    scheme_multiple_values->type = scheme_multiple_values_type;
+#endif
+
+    REGISTER_SO(define_values_symbol);
+    REGISTER_SO(letrec_star_values_symbol);
+    REGISTER_SO(lambda_symbol);
+    REGISTER_SO(unknown_symbol);
+    REGISTER_SO(void_link_symbol);
+    REGISTER_SO(quote_symbol);
+    REGISTER_SO(letmacro_symbol);
+    REGISTER_SO(begin_symbol);
+    REGISTER_SO(let_id_macro_symbol);
+    REGISTER_SO(let_exp_time_symbol);
+    REGISTER_SO(let_symbol);
+
+    define_values_symbol = scheme_intern_symbol("#%define-values");
+    letrec_star_values_symbol = scheme_intern_symbol("#%letrec*-values");
+    let_symbol = scheme_intern_symbol("#%let");
+    lambda_symbol = scheme_intern_symbol("#%lambda");
+    unknown_symbol = scheme_intern_symbol("unknown");
+    void_link_symbol = scheme_intern_symbol("-v");
+    quote_symbol = scheme_intern_symbol("#%quote");
+    letmacro_symbol = scheme_intern_symbol("#%let-macro");
+    let_id_macro_symbol = scheme_intern_symbol("#%let-id-macro");
+    let_exp_time_symbol = scheme_intern_symbol("#%let-expansion-time");
+    begin_symbol = scheme_intern_symbol("#%begin");
+
+    scheme_install_type_writer(REGISTYPE(scheme_application), write_application);
+    scheme_install_type_reader(REGISTYPE(scheme_application), read_application);
+    scheme_install_type_writer(REGISTYPE(scheme_sequence), write_sequence);
+    scheme_install_type_reader(REGISTYPE(scheme_sequence), read_sequence);
+    scheme_install_type_writer(REGISTYPE(scheme_branch), write_branch);
+    scheme_install_type_reader(REGISTYPE(scheme_branch), read_branch);
+    scheme_install_type_writer(REGISTYPE(scheme_syntax), write_syntax);
+    scheme_install_type_reader(REGISTYPE(scheme_syntax), read_syntax);
+
+    scheme_install_type_writer(scheme_begin0_sequence_type, write_sequence);
+    scheme_install_type_reader(scheme_begin0_sequence_type, read_sequence_save_first);
+
+
+    scheme_null_break_poll 
+      = scheme_make_prim_w_arity(default_user_break_poll_proc, 
+				 "default-user-break-poll-handler",
+				 0, 0);
+
+
+
+    scheme_set_param(config, MZCONFIG_EVAL_HANDLER,
+		     scheme_make_prim_w_arity2(default_eval_handler,
+					       "default-eval-handler",
+					       1, 1,
+					       0, -1));
+    
+    scheme_set_param(config, MZCONFIG_USER_BREAK_POLL_HANDLER,
+		     scheme_null_break_poll);
+  }
+    
+  scheme_add_global_constant("eval", 
+			     scheme_make_prim_w_arity2(eval, 
+						       "eval", 
+						       1, 2,
+						       0, -1), 
+			     env);
+  scheme_add_global_constant("compile", 
+			     scheme_make_prim_w_arity(compile, 
+						      "compile", 
+						      1, 1), 
+			     env);
+#if OPT_COMPILE_VISIBLE
+  scheme_add_global_constant("compile-x", 
+			     scheme_make_prim_w_arity(compile_x, 
+						      "compile-x", 
+						      1, 1), 
+			     env);
+#endif
+  scheme_add_global_constant("expand-defmacro", 
+			     scheme_make_prim_w_arity(expand, 
+						      "expand-defmacro",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("local-expand-defmacro", 
+			     scheme_make_prim_w_arity(local_expand, 
+						      "local-expand-defmacro",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("local-expand-body-expression", 
+			     scheme_make_prim_w_arity2(local_expand_body_expression, 
+						       "local-expand-body-expression",
+						       1, 1,
+						       2, 2), 
+			     env);
+  scheme_add_global_constant("expand-defmacro-once", 
+			     scheme_make_prim_w_arity(expand_once, 
+						      "expand-defmacro-once", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("break-enabled", 
+			     scheme_register_parameter(enable_break, 
+						       "break-enabled",
+						       MZCONFIG_ENABLE_BREAK), 
+			     env);
+  scheme_add_global_constant("exception-break-enabled", 
+			     scheme_register_parameter(exn_enable_break, 
+						       "exception-break-enabled",
+						       MZCONFIG_ENABLE_EXCEPTION_BREAK), 
+			     env);
+  scheme_add_global_constant("dynamic-enable-break", 
+			     scheme_make_prim_w_arity(dynamic_enable_break, 
+						      "dynamic-enable-break", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("user-break-poll-handler", 
+			     scheme_register_parameter(user_break_poll, 
+						       "user-break-poll-handler",
+						       MZCONFIG_USER_BREAK_POLL_HANDLER), 
+			     env);
+  scheme_add_global_constant("current-eval",
+			     scheme_register_parameter(current_eval, 
+						       "current-eval",
+						       MZCONFIG_EVAL_HANDLER),
+			     env);
+
+  scheme_add_global_constant("built-in-name",
+			     scheme_make_prim_w_arity(built_in_name, 
+						      "built-in-name",
+						      1, 1),
+			     env);
+
+  scheme_add_global_constant("compile-allow-cond-fallthrough", 
+			     scheme_register_parameter(allow_auto_cond_else, 
+						       "compile-allow-cond-fallthrough",
+						       MZCONFIG_COND_AUTO_ELSE), 
+			     env);
+  scheme_add_global_constant("compile-allow-set!-undefined", 
+			     scheme_register_parameter(allow_set_undefined, 
+						       "compile-allow-set!-undefined",
+						       MZCONFIG_ALLOW_SET_UNDEFINED), 
+			     env);
+}
+
+Scheme_Object *
+scheme_handle_stack_overflow(Scheme_Object *(*k)(void))
+{
+#ifndef ERROR_ON_OVERFLOW
+  scheme_overflow_k = k;
+  scheme_init_jmpup_buf(&scheme_overflow_cont);
+  scheme_zero_unneeded_rands(scheme_current_process);
+  if (scheme_setjmpup(&scheme_overflow_cont, 
+		      scheme_current_process->cc_start)) {
+    scheme_init_jmpup_buf(&scheme_overflow_cont);
+    if (!scheme_overflow_reply) {
+      scheme_longjmp(scheme_error_buf, 1);
+    } else
+      return scheme_overflow_reply;
+  } else
+    scheme_longjmp(scheme_current_process->overflow_buf, 1);
+#else
+  if (!scheme_current_process->stack_overflow) {
+    scheme_current_process->stack_overflow = 1;
+    scheme_raise_exn(MZEXN_MISC_OUT_OF_MEMORY,
+		      "out of stack space (infinite loop?)");
+  }
+#endif
+}
+
+/* 4 cases => magic number for some compilers doing a switch */
+enum {
+  SCHEME_EVAL_CONSTANT = 0,
+  SCHEME_EVAL_GLOBAL,
+  SCHEME_EVAL_LOCAL,
+  SCHEME_EVAL_LOCAL_UNBOX,
+  SCHEME_EVAL_GENERAL
+};
+
+int scheme_get_eval_type(Scheme_Object *obj)
+{
+  Scheme_Type type;
+
+  type = SCHEME_TYPE(obj);
+
+  if (type > _scheme_values_types_)
+    return SCHEME_EVAL_CONSTANT;
+  else if (SAME_TYPE(type, scheme_local_type))
+    return SCHEME_EVAL_LOCAL;
+  else if (SAME_TYPE(type, scheme_local_unbox_type))
+    return SCHEME_EVAL_LOCAL_UNBOX;
+  else if (SAME_TYPE(type, scheme_variable_type))
+    return SCHEME_EVAL_GLOBAL;
+  else
+    return SCHEME_EVAL_GENERAL;
+}    
+
+static Scheme_Object *make_application(Scheme_Object *orig_app,
+				       Scheme_Object *v,
+				       int can_opt_const,
+				       int final)
+{
+  Scheme_Object *o, *tmp[20], **linked;
+  Scheme_App_Rec *app, *orig;
+  char *evals;
+  int i, n, nv, size;
+
+  orig = (Scheme_App_Rec *)orig_app;
+
+  if (orig) {
+    n = orig->num_args + 1;
+    nv = 0;
+    if (n <= 20)
+      linked = tmp;
+    else
+      linked = (Scheme_Object **)scheme_malloc(n * sizeof(Scheme_Object *));
+
+    for (i = 0; i < n; i++) {
+      Scheme_Type type;
+      linked[i] = orig->args[i];
+      type = SCHEME_TYPE(linked[i]);
+      if ((type < _scheme_compiled_values_types_)
+	  || SAME_TYPE(type, scheme_quote_compilation_type))
+	nv = 1;
+    }
+  } else {
+    o = v;
+    n = 0;
+    nv = 0;
+    while (!SCHEME_NULLP(o)) {
+      Scheme_Type type;
+
+      n++;
+      if (!SCHEME_LISTP(o))
+	scheme_wrong_syntax("application", NULL, NULL, NULL);
+      type = SCHEME_TYPE(SCHEME_CAR(o));
+      if ((type < _scheme_compiled_values_types_)
+	  || SAME_TYPE(type, scheme_quote_compilation_type))
+	nv = 1;
+      o = SCHEME_CDR(o);
+    }
+    linked = NULL;
+  }
+
+  if (!nv && can_opt_const) {
+    /* They're all values. Applying folding prim or closure? */
+    Scheme_Object *f = linked ? linked[0] : SCHEME_CAR(v);
+
+    if ((SCHEME_PRIMP(f) && (((Scheme_Primitive_Proc *)f)->flags & SCHEME_PRIM_IS_FOLDING))
+	|| (SCHEME_CLSD_PRIMP(f) 
+	    && (((Scheme_Closed_Primitive_Proc *)f)->flags & SCHEME_PRIM_IS_FOLDING))
+	|| (SAME_TYPE(SCHEME_TYPE(f), scheme_linked_closure_type)
+	    && (((Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(f))->flags
+		& CLOS_FOLDABLE))) {
+      jmp_buf savebuf;
+
+      /* Apply the procedure. */
+      scheme_current_process->error_invoked = 5;
+      memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+      if (scheme_setjmp(scheme_error_buf))
+	f = NULL;
+      else {
+	if (linked) {
+	  f = linked[0];
+	  if (n > 20) {
+	    /* Have to copy to keep ptr at front for GC */
+	    for (i = 1; i < n; i++)
+	      linked[i - 1] = linked[i];
+	  } else
+	    linked++;
+	  f = _scheme_apply(f, n - 1, linked);
+	} else
+	  f = _scheme_apply_to_list(SCHEME_CAR(v), SCHEME_CDR(v));
+      }
+
+      memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+      scheme_current_process->error_invoked = 0;
+
+      if (f)
+	return f;
+    }
+  }
+
+  size = (sizeof(Scheme_App_Rec) + ((n - 1) 
+				    * sizeof(Scheme_Object *))
+	  + n * sizeof(char));
+  app = (Scheme_App_Rec *)(final 
+			   ? scheme_malloc_stubborn_tagged(size)
+			   : scheme_malloc_tagged(size));
+
+  app->num_args = n - 1;
+
+  evals = (((char *)app) + sizeof(Scheme_App_Rec) 
+	   + (app->num_args * sizeof(Scheme_Object *)));
+
+  if (linked) {
+    for (i = 0; i < n; i++)
+      app->args[i] = linked[i];
+  } else {
+    for (i = 0; i < n; i++, v = SCHEME_CDR(v))
+      app->args[i] = SCHEME_CAR(v);
+  }
+
+  app->type = scheme_application_type;
+
+  if (final) {
+    for (i = 0; i < n; i++)
+      evals[i] = scheme_get_eval_type(app->args[i]);
+
+    scheme_end_stubborn_change((void *)app);
+  }
+
+  return (Scheme_Object *)app;
+}
+
+static Scheme_Object *link_application(Scheme_Object *o, Link_Info *info)
+{
+  Scheme_App_Rec *app;
+  char *evals;
+  int i, n;
+
+  app = (Scheme_App_Rec *)o;
+
+  evals = (((char *)app) + sizeof(Scheme_App_Rec) 
+	   + (app->num_args * sizeof(Scheme_Object *)));
+  
+  n = app->num_args + 1;
+
+  info = scheme_link_info_extend(info, n - 1, 0, 0);
+
+  for (i = 0; i < n; i++)
+    app->args[i] = scheme_link_expr(app->args[i], info);
+
+  for (i = 0; i < n; i++)
+    evals[i] = scheme_get_eval_type(app->args[i]);
+
+  return o;
+}
+
+static Scheme_Object *link_branch(Scheme_Object *o, Link_Info *info)
+{
+  Scheme_Branch_Rec *b;
+
+  b = (Scheme_Branch_Rec *)o;
+
+  b->test = scheme_link_expr(b->test, info);
+  b->tbranch = scheme_link_expr(b->tbranch, info);
+  b->fbranch = scheme_link_expr(b->fbranch, info);
+
+  return o;
+}
+
+static Scheme_Sequence *malloc_sequence(int count)
+{
+  return (Scheme_Sequence *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Sequence)
+							  + (count - 1) 
+							  * sizeof(Scheme_Object *));
+}
+
+static Scheme_Object *look_for_letv_change(Scheme_Sequence *s)
+{
+  int i;
+
+  for (i = 0; i < s->count - 1; i++) {
+    Scheme_Object *v;
+    v = s->array[i];
+    if (SAME_TYPE(SCHEME_TYPE(v), scheme_let_value_type)) {
+      Scheme_Let_Value *lv = (Scheme_Let_Value *)v;
+      if (scheme_omittable_expr(lv->body)) {
+	int esize = s->count - (i + 1);
+	int nsize = i + 1;
+	Scheme_Object *nv, *ev;
+
+	if (nsize > 1) {
+	  Scheme_Sequence *naya;
+
+	  naya = malloc_sequence(nsize);
+	  naya->type = scheme_sequence_type;
+	  naya->count = nsize;
+	  nv = (Scheme_Object *)naya;
+
+	  for (i = 0; i < nsize; i++)
+	    naya->array[i] = s->array[i];
+	} else
+	  nv = (Scheme_Object *)lv;
+
+	if (esize > 1) {
+	  Scheme_Sequence *e;
+	  e = malloc_sequence(esize);
+	  e->type = scheme_sequence_type;
+	  e->count = esize;
+
+	  for (i = 0; i < esize; i++)
+	    e->array[i] = s->array[i + nsize];
+
+	  ev = (Scheme_Object *)look_for_letv_change(e);
+	} else
+	  ev = s->array[nsize]; 
+
+	lv->body = ev;
+
+	return nv;
+      }
+    }
+  }
+
+  return (Scheme_Object *)s;
+}
+
+static Scheme_Object *link_sequence(Scheme_Object *o, Link_Info *info)
+{
+  Scheme_Sequence *s = (Scheme_Sequence *)o;
+  int i;
+
+  for (i = s->count; i--; )
+    s->array[i] = scheme_link_expr(s->array[i], info);
+  
+  return look_for_letv_change(s);
+}
+
+Scheme_Object *scheme_make_syntax_link(Scheme_Syntax_Executer *prim,
+				       Scheme_Object *data)
+{
+  Scheme_Object *v;
+
+  v = scheme_alloc_stubborn_object();
+  v->type = scheme_syntax_type;
+  SCHEME_PTR1_VAL(v) = (void *)prim;
+  SCHEME_PTR2_VAL(v) = (void *)data;
+  scheme_end_stubborn_change((void *)v);
+
+  return v;
+}
+
+Scheme_Object *scheme_make_syntax_compile(Scheme_Syntax_Linker *prim,
+					  Scheme_Object *data)
+{
+  Scheme_Object *v;
+
+  v = scheme_alloc_stubborn_object();
+  v->type = scheme_compiled_syntax_type;
+  SCHEME_PTR1_VAL(v) = (void *)prim;
+  SCHEME_PTR2_VAL(v) = (void *)data;
+  scheme_end_stubborn_change((void *)v);
+
+  return v;  
+}
+
+Scheme_Object *scheme_link_expr(Scheme_Object *expr, Link_Info *info)
+{
+  Scheme_Type type = SCHEME_TYPE(expr);
+
+  switch (type) {
+  case scheme_local_type:
+    {
+      int pos, flags;
+      
+      pos = scheme_link_info_lookup(info, SCHEME_LOCAL_POS(expr), &flags);
+      return scheme_make_local((flags & SCHEME_INFO_BOXED) 
+			       ? scheme_local_unbox_type
+			       : scheme_local_type,
+			       pos);
+    }
+  case scheme_compiled_syntax_type:
+    {
+      Scheme_Syntax_Linker *f;
+	  
+      f = (Scheme_Syntax_Linker *)SCHEME_PTR1_VAL(expr);
+      return f((Scheme_Object *)SCHEME_PTR2_VAL(expr), info);
+    }
+  case scheme_application_type:
+    return link_application(expr, info);
+  case scheme_sequence_type:
+    return link_sequence(expr, info);
+  case scheme_branch_type:
+    return link_branch(expr, info);
+  case scheme_compiled_unclosed_procedure_type:
+    return scheme_link_closure_compilation(expr, info);
+  case scheme_compiled_let_void_type:
+    return scheme_link_lets(expr, info);
+  default:
+    return expr;
+  }
+}
+
+Scheme_Object *scheme_link_list(Scheme_Object *expr, Link_Info *info)
+{
+  Scheme_Object *first = scheme_null, *last = NULL;
+
+  while (SCHEME_PAIRP(expr)) {
+    Scheme_Object *pr;
+
+    pr = scheme_make_pair(scheme_link_expr(SCHEME_CAR(expr), info),
+			  scheme_null);
+
+    if (last)
+      SCHEME_CDR(last) = pr;
+    else
+      first = pr;
+    last = pr;
+
+    expr = SCHEME_CDR(expr);
+  }
+
+  return first;
+}
+
+void scheme_default_compile_rec(Scheme_Compile_Info *rec)
+{
+  rec->max_let_depth = 0;
+}
+
+void scheme_init_compile_recs(Scheme_Compile_Info *src, 
+			      Scheme_Compile_Info *dest, int n)
+{
+  int i;
+
+  for (i = 0; i < n; i++) {
+    dest[i].max_let_depth = 0;
+    dest[i].can_optimize_constants = src->can_optimize_constants;
+    dest[i].globals_must_be_primitive = src->globals_must_be_primitive;
+    dest[i].keep_unit_debug_info = src->keep_unit_debug_info;
+    dest[i].dont_mark_local_use = src->dont_mark_local_use;
+    dest[i].value_name = NULL;
+  }
+}
+
+void scheme_merge_compile_recs(Scheme_Compile_Info *src, 
+			       Scheme_Compile_Info *dest, int n)
+{
+  int i;
+
+  if (!n) {
+    src->max_let_depth = 0;
+    return;
+  }
+  
+  src->max_let_depth = dest[0].max_let_depth;
+
+  for (i = 1; i < n; i++) {
+    if (dest[i].max_let_depth > src->max_let_depth)
+      src->max_let_depth = dest[i].max_let_depth;
+  }
+}
+
+void scheme_init_lambda_rec(Scheme_Compile_Info *src,
+			    Scheme_Compile_Info *lam)
+{
+  lam->max_let_depth = 0;
+  lam->can_optimize_constants = src->can_optimize_constants;
+  lam->globals_must_be_primitive = src->globals_must_be_primitive;
+  lam->keep_unit_debug_info = src->keep_unit_debug_info;
+  lam->dont_mark_local_use = src->dont_mark_local_use;
+  lam->value_name = NULL;
+}
+
+void scheme_merge_lambda_rec(Scheme_Compile_Info *src,
+			     Scheme_Compile_Info *lam)
+{
+}
+
+void scheme_compile_rec_done_local(Scheme_Compile_Info *rec)
+{
+  rec->value_name = NULL;
+}
+
+/* Forward declaration... */
+static Scheme_Object *
+scheme_compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, 
+			   Scheme_Compile_Info *rec, int depth,
+			   int app_position);
+
+static Scheme_Object *
+scheme_inner_compile_list(Scheme_Object *form, Scheme_Comp_Env *env, 
+			  Scheme_Compile_Info *rec, int start_app_position)
+{
+  if (SCHEME_NULLP(form)) {
+    scheme_compile_rec_done_local(rec);
+    scheme_default_compile_rec(rec);
+    return scheme_null;
+  } else if (SCHEME_PAIRP(form)) {
+    Scheme_Compile_Info recs[2];
+    Scheme_Object *c1, *c2, *name, *first, *rest;
+
+    name = rec->value_name;
+    scheme_compile_rec_done_local(rec);
+    scheme_init_compile_recs(rec, recs, 2);
+
+    first = SCHEME_CAR(form);
+    rest = SCHEME_CDR(form);
+    if (SCHEME_NULLP(rest))
+      recs[0].value_name = name;
+    else
+      recs[1].value_name = name;
+
+    c1 = scheme_compile_expand_expr(first, env, &recs[0],
+				    1, start_app_position);
+    /* if (start_app_position)
+      recs[0].is_proc_closure = 0; */
+    c2 = scheme_inner_compile_list(rest, env, &recs[1], 0);
+
+    scheme_merge_compile_recs(rec, recs, 2);
+
+    return scheme_make_pair(c1, c2);
+  } else
+    return scheme_compile_expr(form, env, rec);
+}
+
+static Scheme_Object *compile_application(Scheme_Object *form, Scheme_Comp_Env *env,
+					  Scheme_Compile_Info *rec)
+{
+  int len = scheme_proper_list_length(form);
+
+  if (len < 0)
+    scheme_wrong_syntax("application", NULL, form, NULL);
+  
+  scheme_compile_rec_done_local(rec);
+  form = scheme_inner_compile_list(form, scheme_no_defines(env), rec, 1);
+
+  rec->max_let_depth += (len - 1);
+
+  return make_application(NULL, form, rec->can_optimize_constants, 0);
+}
+
+Scheme_Object *
+scheme_compile_list(Scheme_Object *form, Scheme_Comp_Env *env, 
+		    Scheme_Compile_Info *rec)
+{
+  return scheme_inner_compile_list(form, env, rec, 0);
+}
+
+static void *compile_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *form;
+  int writeable;
+  Scheme_Comp_Env *env;
+  Scheme_Compile_Info rec;
+  Scheme_Object *o;
+  Scheme_Compilation_Top *top;
+  int can_opt;
+
+  form = (Scheme_Object *)p->ku.k.p1;
+  env = (Scheme_Comp_Env *)p->ku.k.p2;
+  writeable = p->ku.k.i1;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  can_opt = !writeable;
+
+  rec.can_optimize_constants = can_opt;
+  rec.globals_must_be_primitive = 0;
+  rec.keep_unit_debug_info = 1;
+  rec.dont_mark_local_use = 0;
+  rec.value_name = NULL;
+
+  o = scheme_link_expr(scheme_compile_expr(form, (Scheme_Comp_Env *)env, &rec),
+		       scheme_link_info_create(can_opt));
+
+  top = MALLOC_ONE_TAGGED(Scheme_Compilation_Top);
+  top->type = scheme_compilation_top_type;
+  top->max_let_depth = rec.max_let_depth;
+  top->code = o;
+
+  return (void *)top;
+}
+
+Scheme_Object *scheme_compile(Scheme_Object *form, Scheme_Env *env, int writeable)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  if (SAME_TYPE(SCHEME_TYPE(form), scheme_compilation_top_type))
+    return form;
+
+  p->ku.k.p1 = form;
+  p->ku.k.p2 = env->init;
+  p->ku.k.i1 = writeable;
+
+  return (Scheme_Object *)scheme_top_level_do(compile_k);
+}
+
+Scheme_Object *scheme_check_immediate_macro(Scheme_Object *first, 
+					    Scheme_Comp_Env *env, 
+					    Scheme_Compile_Info *rec, 
+					    int depth,
+					    Scheme_Object **current_val)
+{
+  Scheme_Object *name, *val;
+
+ check_top:
+  *current_val = NULL;
+
+  name = SCHEME_CAR(first);
+  if (!SCHEME_SYMBOLP(name))
+    return first;
+
+  val = scheme_static_distance(name, env, 
+			       SCHEME_APP_POS + SCHEME_ENV_CONSTANTS_OK
+			       + ((rec && rec->dont_mark_local_use) 
+				  ? SCHEME_DONT_MARK_USE 
+				  : 0));
+
+  *current_val = val;
+
+  if (SAME_TYPE(SCHEME_TYPE(val), scheme_macro_type)) {
+    /* Yep, it's a macro; expand once */
+    first = scheme_expand_expr(first, env, 1);
+  } else if (SAME_TYPE(SCHEME_TYPE(val), scheme_id_macro_type)) {
+    /* id macro */
+    first = scheme_make_pair(SCHEME_PTR_VAL(val), SCHEME_CDR(first));
+  } else
+    return first;
+
+
+  if (SCHEME_PAIRP(first))
+    goto check_top;
+  
+  return first;
+}
+
+Scheme_Object *
+scheme_compile_expand_macro_app(Scheme_Object *macro,
+				Scheme_Object *form, Scheme_Comp_Env *env,
+				Scheme_Compile_Info *rec, int depth)
+{
+  Scheme_Comp_Env *save_env;
+  Scheme_Process *p = scheme_current_process;
+
+  Scheme_Object *rest = SCHEME_CDR(form);
+
+  if (!depth)
+    return form; /* We've gone as deep as requested */
+
+  save_env = p->current_local_env;
+  p->current_local_env = env;
+  form = scheme_apply_macro_to_list((Scheme_Object *)SCHEME_PTR_VAL(macro), 
+				    rest, form);
+  p->current_local_env = save_env;
+
+  if (rec)
+    return scheme_compile_expr(form, env, rec);
+  else {
+    --depth;
+    if (depth)
+      return scheme_expand_expr(form, env, depth);
+    else
+      return form;
+  }
+}
+
+static Scheme_Object *
+get_primitive_global(Scheme_Object *var, Scheme_Env *env, 
+		     int bucket_ok, int can_opt, int signal)
+{
+  Scheme_Object *sym, *orig, *gvar;
+  Scheme_Bucket *b;
+
+  gvar = var;
+
+  if (((Scheme_Bucket_With_Const_Flag *)gvar)->flags & GLOB_IS_PRIMITIVE)
+    return var;
+
+  /* Not prim. Try #% version: */
+  orig = (Scheme_Object *)(SCHEME_VAR_BUCKET(gvar))->key;
+
+  sym = scheme_hash_percent_name(SCHEME_SYM_VAL(orig),
+				 SCHEME_SYM_LEN(orig));
+
+  b = scheme_global_bucket(sym, env);
+
+  if (b && (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_PRIMITIVE)) {
+    if (can_opt)
+      if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST)
+	return (Scheme_Object *)b->val;
+
+    return (Scheme_Object *)b;
+  }
+
+  /* #% doesn't work either. must not be a real primitive */
+  if (signal) {
+    scheme_wrong_syntax("unit", NULL,  orig,
+			"used an unbound or non-primitive global");
+  }
+
+  return NULL;
+}
+
+static Scheme_Object *
+built_in_name(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *o;
+  Scheme_Env *env = scheme_get_env(scheme_config);
+
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("built-in-name", "symbol", 0, argc, argv);
+
+  o = (Scheme_Object *)scheme_global_bucket(argv[0], env);
+  if (o) {
+    if ((o = get_primitive_global(o, env, 1, 0, 0)))
+      return (Scheme_Object *)((Scheme_Bucket *)o)->key;
+  }
+
+  return scheme_false;
+}
+
+static Scheme_Object *compile_expand_expr_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *form = (Scheme_Object *)p->ku.k.p1;
+  Scheme_Comp_Env *env = (Scheme_Comp_Env *)p->ku.k.p2;
+  Scheme_Compile_Info *rec = (Scheme_Compile_Info *)p->ku.k.p3;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+  p->ku.k.p3 = NULL;
+
+  return scheme_compile_expand_expr(form, 
+				    env,
+				    rec,
+				    p->ku.k.i1,
+				    p->ku.k.i2);
+}
+
+static Scheme_Object *
+scheme_compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, 
+			   Scheme_Compile_Info *rec, int depth,
+			   int app_position)
+{
+  Scheme_Object *name, *var, *rest;
+
+#ifdef DO_STACK_CHECK
+#include "mzstkchk.h"
+  {
+#ifndef ERROR_ON_OVERFLOW
+    Scheme_Process *p = scheme_current_process;
+    p->ku.k.p1 = (void *)form;
+    p->ku.k.p2 = (void *)env;
+    p->ku.k.p3 = (void *)rec;
+    p->ku.k.i1 = depth;
+    p->ku.k.i2 = app_position;
+#endif
+    return scheme_handle_stack_overflow(compile_expand_expr_k);
+  }
+#endif
+
+ top:
+
+  DO_CHECK_FOR_BREAK(scheme_current_process, ;);
+
+  if (rec) {
+    scheme_default_compile_rec(rec);
+
+    if (rec->can_optimize_constants) {
+      Scheme_Type type = SCHEME_TYPE(form);
+      if (type == scheme_quote_compilation_type)
+	return SCHEME_PTR_VAL(form);
+    }
+  }
+
+  if (!SCHEME_PAIRP(form)) {
+    if (SCHEME_SYMBOLP(form)) {
+      var = scheme_static_distance(form, env, 
+				   SCHEME_ENV_CONSTANTS_OK
+				   + ((rec && rec->can_optimize_constants
+				       && !rec->globals_must_be_primitive)
+				      ? SCHEME_ELIM_CONST 
+				      : 0)
+				   + (app_position 
+				      ? SCHEME_APP_POS 
+				      : 0)
+				   + ((rec && rec->dont_mark_local_use) ? 
+				      SCHEME_DONT_MARK_USE 
+				      : 0));
+      if (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type))
+	scheme_wrong_syntax("compile", NULL, form, 
+			    "illegal use of a macro name");
+      else if (SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type))
+	scheme_wrong_syntax("compile", NULL, form, 
+			    "illegal use of a syntactic form name");
+      else if (SAME_TYPE(SCHEME_TYPE(var), scheme_id_macro_type)) {
+	form = SCHEME_PTR_VAL(var);
+	if (!rec) {
+	  --depth;
+	  if (!depth)
+	    return form;
+	}	  
+	goto top;
+      } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_exp_time_type))
+	scheme_wrong_syntax("compile", NULL, form, 
+			    "illegal use of an expansion-time value name");
+
+
+      /* Check for global use within unit: */
+      if (rec && rec->globals_must_be_primitive
+	  && (SAME_TYPE(SCHEME_TYPE(var), scheme_variable_type)))
+	var = get_primitive_global(var, scheme_min_env(env), 0, rec->can_optimize_constants, 1);
+
+      if (rec) {
+	scheme_compile_rec_done_local(rec);
+	return var;
+      }
+    } else if (rec && SAME_TYPE(SCHEME_TYPE(form), scheme_closure_type))
+      return scheme_make_closure_compilation(SCHEME_CLOS_ENV(form)->init,
+					     SCHEME_CLOS_CODE(form), 
+					     rec);
+
+    return form;
+  }
+
+  name = SCHEME_CAR(form);
+  rest = SCHEME_CDR(form);
+  if (SCHEME_SYMBOLP(name)) {
+    /* Check for macros: */
+    var = scheme_static_distance(name, env, 
+				 SCHEME_APP_POS
+				 + SCHEME_ENV_CONSTANTS_OK
+				 + ((rec && rec->can_optimize_constants
+				     && !rec->globals_must_be_primitive)
+				    ? SCHEME_ELIM_CONST
+				    : 0)
+				 + ((rec && rec->dont_mark_local_use)
+				    ? SCHEME_DONT_MARK_USE 
+				    : 0));
+    if (SAME_TYPE(SCHEME_TYPE(var), scheme_local_type)
+	|| SAME_TYPE(SCHEME_TYPE(var), scheme_local_unbox_type)) {
+      /* apply to local variable: compile it normally */
+    } else {
+      if (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type)) {
+	return scheme_compile_expand_macro_app(var, form, env, rec, depth);
+      } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_id_macro_type)) {
+	form = scheme_make_pair(SCHEME_PTR_VAL(var), rest);
+	if (!rec) {
+	  --depth;
+	  if (!depth)
+	    return form;
+	} 
+	goto top;
+      } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) {
+	if (rec) {
+	  Scheme_Syntax *f;
+	  f = (Scheme_Syntax *)SCHEME_SYNTAX(var);
+	  return f(form, env, rec);
+	} else {
+	  Scheme_Syntax_Expander *f;
+	  f = (Scheme_Syntax_Expander *)SCHEME_SYNTAX_EXP(var);
+	  return f(form, env, depth);
+	}
+      } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_exp_time_type))
+	scheme_wrong_syntax("compile", NULL, name, 
+			    "illegal use of an expansion-time value name");
+	
+      /* Else: unknown global - must be a function: compile normally */
+
+      /* Check for global use within unit: */
+      if (rec && rec->globals_must_be_primitive
+	  && (SAME_TYPE(SCHEME_TYPE(var), scheme_variable_type)))
+	var = get_primitive_global(var, scheme_min_env(env), 0, rec->can_optimize_constants, 1);
+
+      /* Optimize (void) to just the value void */
+      if (rec && rec->can_optimize_constants && SAME_OBJ(var, scheme_void_func)
+	  && SCHEME_NULLP(rest)) {
+	scheme_compile_rec_done_local(rec);
+	return scheme_void;
+      }
+    }
+    
+    /* Must be an application */
+    if (rec)
+      return compile_application(form, env, rec);
+    else
+      return scheme_expand_list(form, scheme_no_defines(env), depth);
+  } else if (rec) {
+    /* look for ((lambda (x) ...) ...) */
+    if (SCHEME_PAIRP(name) && SCHEME_SYMBOLP(SCHEME_CAR(name))) {
+      Scheme_Object *gval, *origname = name;
+
+      name = scheme_check_immediate_macro(name, env, rec, depth, &gval);
+      
+      if (SAME_OBJ(gval, scheme_lambda_syntax)) {
+	Scheme_Object *argsnbody;
+	
+	argsnbody = SCHEME_CDR(name);
+	if (SCHEME_PAIRP(argsnbody)) {
+	  Scheme_Object *args = SCHEME_CAR(argsnbody);
+	  Scheme_Object *body = SCHEME_CDR(argsnbody);
+	  
+	  if (SCHEME_PAIRP(body)) {
+	    int pl = scheme_proper_list_length(args);
+	    if (pl >= 0) {
+	      Scheme_Object *bindings = NULL, *last = NULL;
+	      int al = scheme_proper_list_length(rest);
+	      
+	      if (al == pl) {	      
+		if (!al) {
+		  if (scheme_is_toplevel(env))
+		    env = scheme_no_defines(env);
+		  return scheme_compile_expand_expr(cons(begin_symbol, body), 
+						    env, rec, depth, 0);
+		}
+		
+		while (!SCHEME_NULLP(args)) {
+		  Scheme_Object *v, *n;
+		  
+		  n = SCHEME_CAR(args);
+		  scheme_check_identifier("lambda", n, NULL, env, form);
+		  
+		  v = cons(cons(n, cons(SCHEME_CAR(rest), scheme_null)), scheme_null);
+		  if (last)
+		    SCHEME_CDR(last) = v;
+		  else
+		    bindings = v;
+		  
+		  last = v;
+		  args = SCHEME_CDR(args);
+		  rest = SCHEME_CDR(rest);
+		}
+		
+		return scheme_compile_expand_expr(cons(let_symbol,
+						       cons(bindings,
+							    body)),
+						  env, rec, depth, 0);
+	      } else {
+#if 0
+ 		scheme_wrong_syntax("application", NULL, form, 
+				    "procedure application: bad ((lambda (...) ...) ...) syntax");
+		return NULL
+#endif
+	      }
+	    }
+	  }
+	}
+      }
+
+      if (NOT_SAME_OBJ(name, origname))
+	form = scheme_make_pair(name, rest);
+    }
+    
+    return compile_application(form, env, rec);
+  } else
+    return scheme_expand_list(form, scheme_no_defines(env), depth);
+}
+
+Scheme_Object *scheme_compile_expr(Scheme_Object *form, Scheme_Comp_Env *env, 
+				   Scheme_Compile_Info *rec)
+{
+  return scheme_compile_expand_expr(form, env, rec, 1, 0);
+}
+
+Scheme_Object *scheme_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, 
+				  int depth)
+{
+  return scheme_compile_expand_expr(form, env, NULL, depth, 0);
+}
+
+static Scheme_Object *
+scheme_compile_expand_block(Scheme_Object *forms, Scheme_Comp_Env *env, 
+			    Scheme_Compile_Info *rec, int depth)
+/* This ugly code parses a block of code, transforming embedded
+  define-values and define-macro into letrec* and let-macro.
+  It is espcailly ugly because we have to expand macros
+  before deciding what we have. */
+{
+  Scheme_Object *first;
+  Scheme_Compile_Info recs[2];
+
+  if (rec)
+    scheme_default_compile_rec(rec);
+
+  if (SCHEME_NULLP(forms)) {
+    if (rec)
+      scheme_compile_rec_done_local(rec);
+    return scheme_null;
+  }
+
+  first = SCHEME_CAR(forms);
+
+  if (SCHEME_PAIRP(first)) {
+    Scheme_Object *name, *gval, *result;
+
+    result = forms;
+
+    /* Check for macro expansion, which could mask the real
+       define-values, define-macro, etc.: */
+    first = scheme_check_immediate_macro(first, env, rec, depth, &gval);
+
+    name = SCHEME_PAIRP(first) ? SCHEME_CAR(first) : scheme_void;
+    if (SAME_OBJ(gval, scheme_define_values_syntax)) {
+      /* Turn defines into a letrec*-values: */
+      Scheme_Object *var, *vars, *v, *link, *l = scheme_null, *start = NULL;
+      
+      while (1) {
+	v = SCHEME_CDR(first);
+	
+	if (!SCHEME_PAIRP(v))
+	  scheme_wrong_syntax("define-values (embedded)", NULL, forms, 
+			      "bad syntax (" IMPROPER_LIST_FORM ")");
+
+	var = NULL;
+	vars = SCHEME_CAR(v);
+	while (SCHEME_PAIRP(vars)) {
+	  var = SCHEME_CAR(vars);
+	  if (!SCHEME_SYMBOLP(var))
+	    scheme_wrong_syntax("define-values (embedded)", var, forms, 
+				"name must be an identifier");
+	  vars = SCHEME_CDR(vars);
+	}
+	
+	link = scheme_make_pair(v, scheme_null);
+	if (!start)
+	  start = link;
+	else
+	  SCHEME_CDR(l) = link;
+	l = link;
+	result = SCHEME_CDR(result);
+	if (!SCHEME_LISTP(result))
+	  scheme_wrong_syntax("define-values (embedded)", NULL, forms, NULL);
+
+	/* Special case: (define-values #%define-values x) */
+	if (SAME_OBJ(define_values_symbol, var))
+	  break;
+
+	if (!SCHEME_NULLP(result)) {
+	  first = SCHEME_CAR(result);
+	  if (SCHEME_PAIRP(first)) {
+	    first = scheme_check_immediate_macro(first, env, rec, depth, &gval);
+	    name = SCHEME_CAR(first);
+	    if (NOT_SAME_OBJ(gval, scheme_define_values_syntax))
+	      break;
+	  } else
+	    break;
+	} else
+	  break;
+      }
+
+      if (SCHEME_PAIRP(result) || rec) {
+	result = scheme_make_pair(letrec_star_values_symbol, scheme_make_pair(start, result));
+      
+	name = NULL;
+      } else {
+	/* Looks illegal, but we're just expanding for now... */
+      }
+    } else if (SAME_OBJ(gval, scheme_begin_exp_time_syntax)) {
+      /* Convert to let-exp-time-macro */
+      Scheme_Object *body, *rest, *var;
+      char *where = "begin-expansion-time (embedded)", buffer[20];
+      static int counter = 1;
+      
+      rest = SCHEME_CDR(result);
+      
+      first = SCHEME_CDR(first);
+      if (!SCHEME_PAIRP(first))
+	scheme_wrong_syntax(where, first, result, NULL);
+      body = first;
+      
+      sprintf(buffer, "g-bet-%d", counter++);
+      var = scheme_make_symbol(buffer);
+      
+      result = cons(let_exp_time_symbol,
+		   cons(var,
+			cons(cons(begin_symbol, body),
+			     rest)));
+      
+       name = NULL;
+    } else if (SAME_OBJ(gval, scheme_defmacro_syntax)
+	       || SAME_OBJ(gval, scheme_def_id_macro_syntax)
+	       || SAME_OBJ(gval, scheme_def_exp_time_syntax)) {
+      /* Convert to let-... */
+      Scheme_Object *var, *body, *rest, *let;
+      char *where;
+      
+      if (SAME_OBJ(gval, scheme_defmacro_syntax)) {
+	where = "define-macro (embedded)";
+	let = letmacro_symbol;
+      } else if (SAME_OBJ(gval, scheme_def_id_macro_syntax)) {
+	where = "define-id-macro (embedded)";
+	let = let_id_macro_symbol;
+      } else {
+	where = "define-non-value (embedded)";
+	let = let_exp_time_symbol;
+      }
+      
+      rest = SCHEME_CDR(result);
+      
+      first = SCHEME_CDR(first);
+      if (!SCHEME_PAIRP(first))
+	scheme_wrong_syntax(where, first, result, NULL);
+      var = SCHEME_CAR(first);
+      first = SCHEME_CDR(first);
+      if (!SCHEME_PAIRP(first))
+	scheme_wrong_syntax(where, first, result, NULL);
+      body = SCHEME_CAR(first);
+      first = SCHEME_CDR(first);
+      if (!SCHEME_NULLP(first))
+	scheme_wrong_syntax(where, first, result, NULL);
+      
+      result = cons(let,
+		   cons(var,
+			cons(body,
+			     rest)));
+      
+      name = NULL;
+    }
+
+    if (!name) {
+      if (rec)
+	result = scheme_compile_expr(result, env, rec);
+      else {
+	--depth;
+	if (depth)
+	  result = scheme_expand_expr(result, env, depth);
+      }
+      
+      return scheme_make_pair(result, scheme_null);
+    }
+  }
+
+  if (rec) {
+    Scheme_Object *vname, *rest;
+
+    vname = rec->value_name;
+    scheme_compile_rec_done_local(rec);
+    scheme_init_compile_recs(rec, recs, 2);
+
+    rest = SCHEME_CDR(forms);
+    if (SCHEME_NULLP(rest))
+      recs[0].value_name = vname;
+    else
+      recs[1].value_name = vname;
+
+    first = scheme_compile_expr(first, env, &recs[0]);
+#if EMBEDDED_DEFINES_START_ANYWHERE
+    forms = scheme_compile_expand_block(rest, env, &recs[1], 1);
+#else
+    forms = scheme_compile_list(rest, env, &recs[1]);
+#endif
+
+    scheme_merge_compile_recs(rec, recs, 2);
+  } else {
+    first = scheme_expand_expr(first, env, depth);
+#if EMBEDDED_DEFINES_START_ANYWHERE
+    forms = scheme_compile_expand_block(SCHEME_CDR(forms), env, rec, depth);
+#else
+    forms = scheme_expand_list(SCHEME_CDR(forms), env, depth);
+#endif
+  }
+
+  return scheme_make_pair(first, forms);
+}
+
+Scheme_Object *
+scheme_compile_block(Scheme_Object *forms, Scheme_Comp_Env *env, 
+		     Scheme_Compile_Info *rec)
+{
+  return scheme_compile_expand_block(forms, env, rec, 1);
+}
+
+Scheme_Object *
+scheme_expand_block(Scheme_Object *forms, Scheme_Comp_Env *env, int depth)
+{
+  return scheme_compile_expand_block(forms, env, NULL, depth);
+}
+
+Scheme_Object *
+scheme_expand_list(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  if (SCHEME_NULLP(form))
+    return scheme_null;
+
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax("expand", NULL, form, 
+			"bad syntax (" IMPROPER_LIST_FORM ")");
+
+  return scheme_make_pair(scheme_expand_expr(SCHEME_CAR(form), env, depth),
+			  scheme_expand_list(SCHEME_CDR(form), env, depth));
+}
+
+Scheme_Object *
+scheme_make_branch(Scheme_Object *test, Scheme_Object *thenp,
+		   Scheme_Object *elsep)
+{
+  Scheme_Branch_Rec *b;
+
+  if (SAME_TYPE(SCHEME_TYPE(test), scheme_quote_compilation_type))
+    test = SCHEME_PTR_VAL(test);
+  
+  if (SCHEME_TYPE(test) > _scheme_compiled_values_types_) {
+    if (SCHEME_FALSEP(test))
+      return elsep;
+    else
+      return thenp;
+  }
+
+  b = (Scheme_Branch_Rec *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Branch_Rec));
+  b->type = scheme_branch_type;
+
+#if 0
+  /* Try optimize: (if (not x) y z) => (if x z y) */
+  if (SAME_TYPE(SCHEME_TYPE(test), scheme_application_type)) {
+    Scheme_App_Rec *app;
+
+    app = (Scheme_App_Rec *)test;
+    if ((app->num_args == 1) && SAME_PTR(scheme_not_prim, app->args[0])) {
+      test = thenp;
+      thenp = elsep;
+      elsep = test;
+      test = app->args[1];
+    }
+  }
+#endif
+
+  b->test = test;
+  b->tbranch = thenp;
+  b->fbranch = elsep;
+
+  scheme_end_stubborn_change((void *)b);
+
+  return (Scheme_Object *)b;
+}
+
+extern Scheme_Object *scheme_compiled_void_code;
+
+int scheme_omittable_expr(Scheme_Object *o)
+{
+  Scheme_Type vtype;
+
+  if (SAME_OBJ(o, scheme_compiled_void_code))
+    return 1;
+
+  vtype = SCHEME_TYPE(o);
+
+  if ((vtype > _scheme_compiled_values_types_) 
+      || (vtype == scheme_local_type)
+      || (vtype == scheme_local_unbox_type)
+      || (vtype == scheme_unclosed_procedure_type)
+      || (vtype == scheme_compiled_unclosed_procedure_type)
+      || (vtype == scheme_quote_compilation_type))
+    return 1;
+
+  if ((vtype == scheme_branch_type)) {
+    Scheme_Branch_Rec *b;
+    b = (Scheme_Branch_Rec *)o;
+    return (scheme_omittable_expr(b->test)
+	    && scheme_omittable_expr(b->tbranch)
+	    && scheme_omittable_expr(b->fbranch));
+  }
+
+  return 0;
+}
+
+int scheme_is_compiled_procedure(Scheme_Object *o, int can_be_closed)
+{
+  if (SAME_TYPE(SCHEME_TYPE(o), scheme_compiled_unclosed_procedure_type)) {
+    if (!can_be_closed) {
+      Scheme_Closure_Compilation_Data *data;
+      data = (Scheme_Closure_Compilation_Data *)o;
+      /* Because == 0 is like a constant */
+      return (data->closure_size > 0);
+    } else
+      return 1;
+  } else
+    return 0;
+}
+
+static Scheme_Object *build_sequence(Scheme_Object *seq, 
+				     int to_linked, 
+				     int opt)
+{
+  Scheme_Object **array, *list, *v, *good, **linked;
+  Scheme_Sequence *o;
+  int count, i, k, total, last, first, setgood;
+  Scheme_Type type;
+
+  type = scheme_sequence_type;
+
+  linked = NULL;
+
+  list = seq;
+  count = i = 0;
+  good = NULL;
+  total = 0;
+  first = 1;
+  setgood = 1;
+  while (!SCHEME_NULLP(list)) {
+    v = SCHEME_CAR(list);
+    list = SCHEME_CDR(list);
+    last = SCHEME_NULLP(list);
+
+    if (((opt > 0) || !first) && SAME_TYPE(SCHEME_TYPE(v), type)) {
+      /* "Inline" nested begins */
+      count += ((Scheme_Sequence *)v)->count;
+      total++;
+    } else if (opt 
+	       && (((opt > 0) && !last) || ((opt < 0) && !first))
+	       && scheme_omittable_expr(v)) {
+      /* A value that is not the result. We'll drop it. */
+      total++;
+    } else {
+      if (setgood)
+	good = v;
+      count++;
+      total++;
+    }
+    i++;
+    if (first) {
+      if (opt < 0)
+	setgood = 0;
+      first = 0;
+    }
+  }
+
+  if (!count)
+    return scheme_compiled_void(to_linked);
+
+  if (count == 1)
+    return good;
+
+  o = malloc_sequence(count);
+
+  o->type = ((opt < 0) ? scheme_begin0_sequence_type : scheme_sequence_type);
+  o->count = count;
+  array = o->array;
+  
+  --total;
+  for (i = k = 0; i < count; k++) {
+    v = SCHEME_CAR(seq);
+    seq = SCHEME_CDR(seq);
+
+    if (((opt > 0) || k) && SAME_TYPE(SCHEME_TYPE(v), type)) {
+      int c, j;
+      Scheme_Object **a;
+
+      c = ((Scheme_Sequence *)v)->count;
+      a = ((Scheme_Sequence *)v)->array;
+      for (j = 0; j < c; j++)
+	array[i++] = a[j];
+    } else if (opt 
+	       && ((opt > 0 && (k < total))
+		   || ((opt < 0) && k))
+	       && scheme_omittable_expr(v)) {
+      /* Value not the result. Do nothing. */
+    } else
+      array[i++] = v;
+  }
+
+  scheme_end_stubborn_change(o);
+
+  return (Scheme_Object *)o;
+}
+
+Scheme_Object *scheme_make_sequence_compilation(Scheme_Object *seq, 
+						int to_linked, int opt)
+{
+  return build_sequence(seq, to_linked, opt);
+}
+
+#ifndef STACK_SAFETY_MARGIN
+#define STACK_SAFETY_MARGIN 50000
+#endif
+
+#if defined(UNIX_FIND_STACK_BOUNDS) || defined(ASSUME_FIXED_STACK_SIZE)
+extern unsigned long GC_get_stack_base();
+#endif
+
+void scheme_init_stack_check()
+{
+  int *v;
+  unsigned long deeper;
+#ifdef UNIX_FIND_STACK_BOUNDS
+  struct rlimit rl;
+#endif
+  
+  deeper = scheme_get_deeper_address();
+  scheme_stack_grows_up = (deeper > (unsigned long)&v);
+
+#ifdef STACK_GROWS_UP
+  if (!scheme_stack_grows_up) {
+    if (scheme_console_printf)
+      scheme_console_printf("Stack grows DOWN, not UP.\n");
+    else
+      printf("Stack grows DOWN, not UP.\n");
+    exit(-1);
+  }
+#endif
+#ifdef STACK_GROWS_DOWN
+  if (scheme_stack_grows_up) {
+    if (scheme_console_printf)
+      scheme_console_printf("Stack grows UP, not DOWN.\n");
+    else
+      printf("Stack grows UP, not DOWN.\n");
+    exit(-1);
+  }
+#endif
+
+#ifdef ASSUME_FIXED_STACK_SIZE
+  scheme_stack_boundary = GC_get_stack_base();
+  if (scheme_stack_grows_up)
+    scheme_stack_boundary += (FIXED_STACK_SIZE - STACK_SAFETY_MARGIN);
+  else
+    scheme_stack_boundary += (STACK_SAFETY_MARGIN - FIXED_STACK_SIZE);
+#endif
+
+#ifdef WINDOWS_FIND_STACK_BOUNDS
+  scheme_stack_boundary = GC_get_stack_base();
+  scheme_stack_boundary += (STACK_SAFETY_MARGIN - 0x100000);
+#endif
+
+#ifdef UNIX_FIND_STACK_BOUNDS
+  getrlimit(RLIMIT_STACK, &rl);
+
+  {
+    unsigned long bnd = (unsigned long)GC_get_stack_base();
+
+    if (scheme_stack_grows_up)
+      bnd += ((unsigned long)rl.rlim_cur - STACK_SAFETY_MARGIN);
+    else
+      bnd += (STACK_SAFETY_MARGIN - (unsigned long)rl.rlim_cur);
+
+# ifndef MZ_REAL_THREADS
+    scheme_stack_boundary = bnd;
+# else
+    scheme_current_process->stack_end = (void *)bnd;
+# endif
+  }
+#endif
+}
+
+static Scheme_Object *do_apply_known_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object **argv = (Scheme_Object **)p->ku.k.p2;
+
+  p->ku.k.p2 = NULL;
+
+  return _scheme_apply_known_closed_prim_multi((Scheme_Object *)p->ku.k.p1, 
+					       p->ku.k.i1, 
+					       argv);
+}
+
+#if 0
+#define DEBUG_CHECK_TYPE(v) if (SCHEME_TYPE(v) > _scheme_last_type_) \
+  { Scheme_Object *o = *(Scheme_Object **)(v); \
+    if (SCHEME_TYPE(o) > _scheme_last_type_) scheme_signal_error("bad type"); }
+#else
+#define DEBUG_CHECK_TYPE(v) /**/
+#endif
+
+Scheme_Object *_scheme_apply_known_closed_prim_multi(Scheme_Object *rator,
+						     int argc,
+						     Scheme_Object **argv)
+{
+  Scheme_Object *v;
+  Scheme_Closed_Primitive_Proc *prim;
+  Scheme_Process *p = scheme_current_process;
+
+#ifdef DO_STACK_CHECK
+#define SCHEME_CURRENT_PROCESS p
+#ifdef MZ_REAL_THREADS
+#define SCHEME_STACK_BOUNDARY ((unsigned long)p->stack_end)
+#endif
+#include "mzstkchk.h"
+  {
+#ifndef ERROR_ON_OVERFLOW
+    Scheme_Process *p = scheme_current_process;
+    p->ku.k.p1 = (void *)rator;
+    p->ku.k.i1 = argc;
+    p->ku.k.p2 = (void *)argv;
+#endif
+    return scheme_handle_stack_overflow(do_apply_known_k);
+  }
+#endif
+
+  DO_CHECK_FOR_BREAK(p, ;);
+
+  prim = (Scheme_Closed_Primitive_Proc *)rator;
+  
+  v = prim->prim_val(prim->data, argc, argv);
+  v = _scheme_force_value(v);
+
+  DEBUG_CHECK_TYPE(v);
+
+  return v;
+}
+
+Scheme_Object *_scheme_apply_known_closed_prim(Scheme_Object *rator,
+					       int argc,
+					       Scheme_Object **argv)
+{
+  Scheme_Object *v;
+
+  v = _scheme_apply_known_closed_prim_multi(rator, argc, argv);
+
+  if (v == SCHEME_MULTIPLE_VALUES)
+    scheme_wrong_return_arity(NULL, 1, scheme_multiple_count, scheme_multiple_array, NULL);
+  return v;
+}
+
+Scheme_Object *scheme_check_one_value(Scheme_Object *v)
+{
+  if (v == SCHEME_MULTIPLE_VALUES)
+    scheme_wrong_return_arity(NULL, 1, scheme_multiple_count, scheme_multiple_array, NULL);
+  return v;
+}
+
+static Scheme_Object *zero_rands_ptr;
+
+static Scheme_Object *do_eval_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *obj = (Scheme_Object *)p->ku.k.p1;
+  Scheme_Object **argv = (Scheme_Object **)p->ku.k.p2;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  return scheme_do_eval(obj, 
+			p->ku.k.i1, 
+			argv,
+			p->ku.k.i2);
+}
+
+int scheme_check_runstack(long size)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  return ((p->runstack - p->runstack_start) >= (size + TAIL_COPY_THRESHOLD));
+}
+
+void *scheme_enlarge_runstack(long size, void *(*k)())
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Saved_Stack *saved = MALLOC_ONE(Scheme_Saved_Stack);
+  void *v;
+
+  saved->prev = p->runstack_saved;
+  saved->runstack = p->runstack;
+  saved->runstack_start = p->runstack_start;
+  saved->runstack_size = p->runstack_size;
+  
+  size += TAIL_COPY_THRESHOLD;
+  if (size < SCHEME_STACK_SIZE)
+    size = SCHEME_STACK_SIZE;
+
+  p->runstack_saved = saved;
+  p->runstack_size = size;
+  p->runstack_start = MALLOC_N(Scheme_Object*, size);
+  p->runstack = p->runstack_start + size;
+  
+  v = k();
+  
+  p->runstack_saved = saved->prev;
+  p->runstack = saved->runstack;
+  p->runstack_start = saved->runstack_start;
+  p->runstack_size = saved->runstack_size;
+
+  return v;
+}
+
+#define USE_LOCAL_RUNSTACK 1
+
+/* Optimization that's helpful on some platforms for some programs, 
+   but not others */
+#define USE_IF_K 0
+#define USE_LET_K 0
+
+#ifdef MZ_REAL_THREADS
+Scheme_Object *
+scheme_do_eval_w_process(Scheme_Object *obj, int num_rands, Scheme_Object **rands, 
+			 int get_value, Scheme_Process *p)
+#else
+Scheme_Object *
+scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, 
+		int get_value)
+#endif
+{
+  Scheme_Type type;
+  Scheme_Object *v, **old_runstack;
+#if USE_LOCAL_RUNSTACK
+  Scheme_Object **runstack;
+#endif
+#ifndef MZ_REAL_THREADS
+  Scheme_Process *p = scheme_current_process;
+#endif
+#if USE_IF_K || USE_LET_K
+  Scheme_Object *ek = NULL;
+#if USE_IF_K
+  Scheme_Object *ek2;
+#endif
+  Scheme_Object **kstack;
+#endif
+
+#ifdef DO_STACK_CHECK
+#define SCHEME_CURRENT_PROCESS p
+#ifdef MZ_REAL_THREADS
+#define SCHEME_STACK_BOUNDARY ((unsigned long)p->stack_end)
+#endif
+#include "mzstkchk.h"
+  {
+#ifndef ERROR_ON_OVERFLOW
+    Scheme_Process *p = scheme_current_process;
+    p->ku.k.p1 = (void *)obj;
+    p->ku.k.i1 = num_rands;
+    if (num_rands >= 0) {
+      /* Copy rands: */
+      p->ku.k.p2 = (void *)MALLOC_N(Scheme_Object*, num_rands);
+      {
+	int i;
+	for (i = num_rands; i--; )
+	  ((Scheme_Object **)p->ku.k.p2)[i] = rands[i];
+      }
+    } else
+      p->ku.k.p2 = (void *)rands;
+    p->ku.k.i2 = get_value;
+#endif
+    return scheme_handle_stack_overflow(do_eval_k);
+  }
+#endif
+
+#if USE_LOCAL_RUNSTACK
+# define RUNSTACK runstack
+# define UPDATE_THREAD_RSPTR() (p->runstack = runstack)
+  runstack = p->runstack;
+#else
+# define RUNSTACK p->runstack
+# define UPDATE_THREAD_RSPTR() /**/
+#endif
+
+#define UPDATE_THREAD_RSPTR_FOR_GC() UPDATE_THREAD_RSPTR()
+
+  old_runstack = p->runstack;
+
+  if (num_rands >= 0) {
+
+    if ((RUNSTACK - p->runstack_start) < TAIL_COPY_THRESHOLD) {
+      /* It's possible that a sequence of primitive _scheme_tail_apply()
+	 calls will exhaust the Scheme stack. Watch out for that. */
+      p->ku.k.p1 = (void *)obj;
+      p->ku.k.i1 = num_rands;
+      p->ku.k.p2 = (void *)rands;
+      p->ku.k.i2 = -1;
+      
+      UPDATE_THREAD_RSPTR();
+      return scheme_enlarge_runstack(100 * TAIL_COPY_THRESHOLD, (void *(*)(void))do_eval_k);
+    }
+
+  apply_top:
+
+    if (SCHEME_INTP(obj)) {
+      scheme_wrong_rator(obj, num_rands, rands);
+      return NULL; /* doesn't get here */
+    }
+
+    type = _SCHEME_TYPE(obj);
+
+    if (type == scheme_prim_type) {
+      Scheme_Primitive_Proc *prim;
+
+      if (rands == p->tail_buffer) {
+	if (num_rands < TAIL_COPY_THRESHOLD) {
+	  int i;
+	  Scheme_Object **quick_rands;
+
+	  quick_rands = PUSH_RUNSTACK(p, RUNSTACK, num_rands);
+
+	  for (i = num_rands; i--; )
+	    quick_rands[i] = rands[i];
+	  rands = quick_rands;
+	} else {
+	  UPDATE_THREAD_RSPTR_FOR_GC();
+	  p->tail_buffer = (Scheme_Object **)scheme_malloc(p->tail_buffer_size 
+							   * sizeof(Scheme_Object *));
+	}
+#ifdef AGRESSIVE_ZERO_TB
+	p->tail_buffer_set = 0;
+#endif
+      } 
+
+      UPDATE_THREAD_RSPTR();
+
+      prim = (Scheme_Primitive_Proc *)obj;
+
+      if (num_rands < prim->mina 
+	  || (num_rands > prim->maxa && prim->maxa >= 0)) {
+	scheme_wrong_count(prim->name, prim->mina, prim->maxa, 
+			   num_rands, rands);
+	return NULL; /* Shouldn't get here */
+      }
+
+      v = prim->prim_val(num_rands, rands);
+
+      DEBUG_CHECK_TYPE(v);
+    } else if (type == scheme_linked_closure_type) {
+      Scheme_Closure_Compilation_Data *data;
+      Scheme_Object **stack, **src;
+      int i, has_rest, num_params;
+      
+      DO_CHECK_FOR_BREAK(p, UPDATE_THREAD_RSPTR_FOR_GC(););
+      
+      data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(obj);
+
+      if ((RUNSTACK - p->runstack_start) < data->max_let_depth) {
+	p->ku.k.p1 = (void *)obj;
+	p->ku.k.i1 = num_rands;
+	p->ku.k.p2 = (void *)rands;
+	p->ku.k.i2 = -1;
+
+	UPDATE_THREAD_RSPTR();
+	v = (Scheme_Object *)scheme_enlarge_runstack(data->max_let_depth, (void *(*)(void))do_eval_k);
+
+	goto returnv;
+      }
+
+      num_params = data->num_params;
+      has_rest = (data->flags & CLOS_HAS_REST);
+      
+      if (num_params) {
+	if (has_rest) {
+	  int extra, n;
+
+	  if (num_rands < (num_params - 1)) {
+	    scheme_wrong_count(scheme_get_proc_name(obj, NULL, 1), 
+			       num_params - 1, -1,
+			       num_rands, rands);
+	    return NULL; /* Doesn't get here */
+	  }
+
+	  n = num_params - has_rest;
+	  
+	  stack = RUNSTACK = old_runstack - num_params;
+	  CHECK_RUNSTACK(p, RUNSTACK);
+
+	  extra = num_rands - n;
+	  if (extra) {
+	    Scheme_Object *rest_vals, *pairs;
+
+	    /* This is a special case: GC may be triggered, but
+	       p->runstack does not point at everything that needs
+	       to be kept if args are lower on the stack. 
+	       That's what runstack_tmp_keep is for. */
+	    UPDATE_THREAD_RSPTR_FOR_GC();
+	    p->runstack_tmp_keep = rands;
+
+	    rest_vals = scheme_null;
+	    for (i = num_rands - 1; i >= n; --i) {
+	      pairs = scheme_alloc_object();
+	      pairs->type = scheme_pair_type;
+	      SCHEME_CDR(pairs) = rest_vals;
+	      SCHEME_CAR(pairs) = rands[i];
+	      rest_vals = pairs;
+	      pairs++;
+	    }
+
+	    p->runstack_tmp_keep = NULL;
+
+	    stack[n] = rest_vals;
+	    while (n--)
+	      stack[n] = rands[n];
+	  } else {
+	    /* Possibly, but not necessarily, rands > stack: */
+	    if ((unsigned long)rands > (unsigned long)stack) {
+	      int i;
+	      for (i = 0; i < n; i++)
+		stack[i] = rands[i];
+	      stack[n] = scheme_null;
+	    } else {
+	      stack[n] = scheme_null;
+	      while (n--)
+		stack[n] = rands[n];
+	    }
+	  }
+	} else {
+	  if (num_rands != num_params) {
+	    if (num_rands < num_params) {
+	      scheme_wrong_count(scheme_get_proc_name(obj, NULL, 1), 
+				 num_params, num_params,
+				 num_rands, rands);
+	      return NULL; /* Doesn't get here */
+	    } else {
+	      scheme_wrong_count(scheme_get_proc_name(obj, NULL, 1), 
+				 num_params, num_params,
+				 num_rands, rands);
+	      return NULL; /* Doesn't get here */
+	    }
+	  }
+	
+	  stack = RUNSTACK = old_runstack - num_params;
+	  CHECK_RUNSTACK(p, RUNSTACK);
+
+	  if (rands != stack) {
+	    int n = num_params; 
+	    while (n--)
+	      stack[n] = rands[n];
+	  }
+	}
+#ifdef AGRESSIVE_ZERO_TB
+	if (rands == p->tail_buffer)
+	  p->tail_buffer_set = 0;
+#endif
+      } else {
+	RUNSTACK = old_runstack;
+	if (num_rands) {
+	  scheme_wrong_count(scheme_get_proc_name(obj, NULL, 1),
+			     0, 0, num_rands, rands);
+	  return NULL; /* Doesn't get here */
+	}
+      }
+      
+      {
+	int n = data->closure_size;
+      
+	if (n) {
+	  src = SCHEME_COMPILED_CLOS_ENV(obj);
+	  stack = PUSH_RUNSTACK(p, RUNSTACK, n);
+	  
+	  while (n--)
+	    stack[n] = src[n];
+	}
+      }
+
+      obj = data->code;
+
+      goto eval_top;
+    } else if (type == scheme_closed_prim_type) {
+      Scheme_Closed_Primitive_Proc *prim;
+      
+      DO_CHECK_FOR_BREAK(p, UPDATE_THREAD_RSPTR_FOR_GC(););
+      
+      if (rands == p->tail_buffer) {
+	if (num_rands < TAIL_COPY_THRESHOLD) {
+	  int i;
+	  Scheme_Object **quick_rands;
+
+	  quick_rands = PUSH_RUNSTACK(p, RUNSTACK, num_rands);
+
+	  for (i = num_rands; i--; )
+	    quick_rands[i] = rands[i];
+	  rands = quick_rands;
+	} else {
+	  UPDATE_THREAD_RSPTR_FOR_GC();
+	  p->tail_buffer = (Scheme_Object **)scheme_malloc(p->tail_buffer_size 
+							   * sizeof(Scheme_Object *));
+	}
+#ifdef AGRESSIVE_ZERO_TB
+	p->tail_buffer_set = 0;
+#endif
+      }
+
+      UPDATE_THREAD_RSPTR();
+
+      prim = (Scheme_Closed_Primitive_Proc *)obj;
+      
+      if (num_rands < prim->mina 
+	  || (num_rands > prim->maxa && prim->maxa >= 0)) {
+	scheme_wrong_count(prim->name, prim->mina, prim->maxa, 
+			   num_rands, rands);
+	return NULL; /* Shouldn't get here */
+      }
+      
+      v = prim->prim_val(prim->data, num_rands, rands);
+
+      DEBUG_CHECK_TYPE(v);
+    } else if (type == scheme_case_closure_type) {
+      Scheme_Case_Lambda *seq;
+      Scheme_Closure_Compilation_Data *data;
+      
+      int i;
+      
+      seq = (Scheme_Case_Lambda *)obj;
+      for (i = 0; i < seq->count; i++) {
+	data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(seq->array[i]);
+	if ((!(data->flags & CLOS_HAS_REST) 
+	     && (data->num_params == num_rands))
+	    || ((data->flags & CLOS_HAS_REST)
+		&& (data->num_params - 1 <= num_rands))) {
+	  obj = seq->array[i];
+	  goto apply_top;
+	}
+      }
+      
+      scheme_wrong_count((char *)seq, -1, -1, num_rands, rands);
+
+      return NULL; /* Doesn't get here. */
+    } else if (type == scheme_cont_type) {
+      Scheme_Cont *c;
+      Scheme_Dynamic_Wind *dw, *common;
+      Scheme_Object *value;
+      
+      if (num_rands != 1) {
+	Scheme_Object **vals;
+	int i;
+
+	UPDATE_THREAD_RSPTR_FOR_GC();
+	vals = MALLOC_N(Scheme_Object *, num_rands);
+	for (i = num_rands; i--; )
+	  vals[i] = rands[i];
+
+	value = (Scheme_Object *)vals;
+      } else
+	value = rands[0];
+#ifdef AGRESSIVE_ZERO_TB
+      if (rands == p->tail_buffer)
+	p->tail_buffer_set = 0;
+#endif
+      
+      c = (Scheme_Cont *)obj;
+      
+      DO_CHECK_FOR_BREAK(p, ;);
+
+      if (!*c->ok)
+	scheme_raise_exn(MZEXN_MISC_CONTINUATION,
+			 "continuation application: attempted to cross a continuation boundary");
+      if (NOT_SAME_OBJ(c->home, p))
+	scheme_raise_exn(MZEXN_MISC_CONTINUATION,
+			 "continuation application: attempted to apply foreign continuation"
+			 " (created in another thread)");
+      
+      /* Find `common', then intersection of dynamic-wind chain for 
+	 the current continuation and the given continuation */
+      common = p->dw;
+      while (common) {
+	dw = c->dw;
+	while (dw && dw != common)
+	  dw = dw->prev;
+	if (dw)
+	  break;
+	common = common->prev;
+      }
+	
+      c->common = common;
+      /* For dynamaic-winds after `common' in this
+	 continuation, execute the post-thunks */
+      for (dw = p->dw; dw != common; dw = dw->prev)
+	if (dw->post) {
+	  p->dw = dw->prev;
+	  dw->post(dw->data);
+	}
+      
+      if (num_rands == 1)
+	c->value = value;
+      else
+	c->value = scheme_values(num_rands, (Scheme_Object **)value);
+      scheme_longjmpup(&c->buf);
+      
+      return NULL;
+    } else if (type == scheme_escaping_cont_type) {
+      Scheme_Object *value;
+
+      if (num_rands != 1) {
+	Scheme_Object **vals;
+	int i;
+
+	UPDATE_THREAD_RSPTR_FOR_GC();
+	vals = MALLOC_N(Scheme_Object *, num_rands);
+	for (i = num_rands; i--; )
+	  vals[i] = rands[i];
+	
+	value = (Scheme_Object *)vals;
+	SCHEME_CONT_NUM_VALS(obj) = num_rands;
+      } else {
+	value = rands[0];
+	SCHEME_CONT_NUM_VALS(obj) = 1;
+      }
+
+#ifdef AGRESSIVE_ZERO_TB
+      if (rands == p->tail_buffer)
+	p->tail_buffer_set = 0;
+#endif
+
+      if (!SCHEME_CONT_HOME(obj))
+	scheme_raise_exn(MZEXN_MISC_CONTINUATION,
+			 "continuation application: attempt to jump into an escape continuation");
+      if (NOT_SAME_OBJ(SCHEME_CONT_HOME(obj), p))
+	scheme_raise_exn(MZEXN_MISC_CONTINUATION,
+			 "continuation application: attempted to apply foreign escape continuation"
+			 " (created in another thread)");
+      SCHEME_CONT_VAL(obj) = value;
+      MZTHREADELEM(p, jumping_to_continuation) = 1;
+      scheme_longjmp(MZTHREADELEM(p, error_buf), 1);
+    } else {
+      scheme_wrong_rator(obj, num_rands, rands);
+      return NULL; /* Doesn't get here. */
+    }
+  } else {
+
+  eval_top:
+
+    if (SCHEME_INTP(obj)) {
+      v = obj;
+      goto returnv;
+    }
+
+    type = _SCHEME_TYPE(obj);
+    switch (type)
+      {
+      case scheme_variable_type:
+	{
+#define global_lookup(prefix, _obj, tmp)                                \
+	  tmp = (Scheme_Object *)(SCHEME_VAR_BUCKET(_obj))->val;        \
+	  if (!tmp) {                                                   \
+	    scheme_unbound_global((Scheme_Object *)                     \
+				  (SCHEME_VAR_BUCKET(_obj))->key);      \
+            return NULL;                                                \
+	  }                                                             \
+	  prefix tmp
+
+	  global_lookup(v = , obj, v);  
+	  goto returnv;
+	}
+      case scheme_local_type:
+	{
+	  v = RUNSTACK[SCHEME_LOCAL_POS(obj)];
+	  goto returnv;
+	}
+      case scheme_local_unbox_type:
+	{
+	  v = SCHEME_ENVBOX_VAL(RUNSTACK[SCHEME_LOCAL_POS(obj)]);
+	  goto returnv;
+	}
+      case scheme_syntax_type:
+	{
+	  Scheme_Syntax_Executer *f;
+
+	  UPDATE_THREAD_RSPTR();
+	  f = (Scheme_Syntax_Executer *)SCHEME_PTR1_VAL(obj);
+	  v = f((Scheme_Object *)SCHEME_PTR2_VAL(obj));
+	  break;
+	}
+      case scheme_application_type:
+	{
+	  Scheme_App_Rec *app;
+	  Scheme_Object **args, *tmpv, **randsp, **stack;
+	  char *evals;
+	  int k;
+
+	  app = (Scheme_App_Rec *)obj;
+	  num_rands = app->num_args;
+	  
+	  evals = ((char *)obj) + sizeof(Scheme_App_Rec)
+	    + (num_rands * sizeof(Scheme_Object *));
+
+	  obj = app->args[0];
+	  
+	  stack = PUSH_RUNSTACK(p, RUNSTACK, num_rands);
+	  UPDATE_THREAD_RSPTR();
+
+	  /* Inline local & global variable lookups for speed */
+	  switch (evals[0]) {
+	  case SCHEME_EVAL_CONSTANT:
+	    break;
+	  case SCHEME_EVAL_GLOBAL:
+	    global_lookup(obj =, obj, tmpv);
+	    break;
+	  case SCHEME_EVAL_LOCAL:
+	    obj = stack[SCHEME_LOCAL_POS(obj)];
+	    break;
+	  case SCHEME_EVAL_LOCAL_UNBOX:
+	    obj = SCHEME_ENVBOX_VAL(stack[SCHEME_LOCAL_POS(obj)]);
+	    break;
+	  default:
+	    obj = _scheme_eval_compiled_expr_wp(obj, p);
+	    break;
+	  }
+
+	  if (num_rands) {
+	    rands = stack;
+	
+	    /* Inline local & global variable lookups for speed */
+	    evals++;
+	    args = app->args + 1;
+	    randsp = rands;
+	    for (k = num_rands; k--; ) {
+	      v = *(args++);
+	      switch (*(evals++)) {
+	      case SCHEME_EVAL_CONSTANT:
+		*(randsp++) = v;
+		break;
+	      case SCHEME_EVAL_GLOBAL:
+		global_lookup(*(randsp++) =, v, tmpv);
+		break;
+	      case SCHEME_EVAL_LOCAL:
+		*(randsp++) = stack[SCHEME_LOCAL_POS(v)];
+		break;
+	      case SCHEME_EVAL_LOCAL_UNBOX:
+		*(randsp++) = SCHEME_ENVBOX_VAL(stack[SCHEME_LOCAL_POS(v)]);
+		break;
+	      default:
+		*(randsp++) = _scheme_eval_compiled_expr_wp(v, p);
+		break;
+	      }
+
+	      DEBUG_CHECK_TYPE(randsp[-1]);
+	    }
+	  } else
+	    rands = &zero_rands_ptr;
+      
+	  goto apply_top;
+	}
+      
+      case scheme_sequence_type:
+	{
+	  Scheme_Object **array;
+	  int i;
+	  
+	  i = ((Scheme_Sequence *)obj)->count;
+	  array = ((Scheme_Sequence *)obj)->array;
+	  
+	  UPDATE_THREAD_RSPTR();
+	  while (--i)
+	    (void)_scheme_eval_compiled_expr_multi_wp(*(array++), p);
+
+	  obj = *array;
+	  goto eval_top;
+	}
+      case scheme_branch_type:
+	{
+	  Scheme_Branch_Rec *b;
+	  b = (Scheme_Branch_Rec *)obj;
+
+#if USE_IF_K
+	  if (!ek) {
+	    kstack = old_runstack;
+	    old_runstack = RUNSTACK;
+	    ek = b->tbranch;
+	    ek2 = b->fbranch;
+	    obj = b->test;
+
+	    goto eval_top;
+	  }
+#endif
+
+	  UPDATE_THREAD_RSPTR();
+	  obj = NOT_SAME_OBJ(_scheme_eval_compiled_expr_wp(b->test, p), scheme_false)
+	    ? b->tbranch : b->fbranch;
+
+	  goto eval_top;
+	}
+      case scheme_unclosed_procedure_type:
+	UPDATE_THREAD_RSPTR();
+	v = scheme_make_linked_closure(p, obj, 1);
+	goto returnv;
+
+      case scheme_let_value_type:
+	{
+	  Scheme_Let_Value *lv;
+	  Scheme_Object *value, **values;
+	  int i, c, ab;
+
+	  lv = (Scheme_Let_Value *)obj;
+
+	  c = lv->count;
+
+#if USE_LET_K
+	  if (!ek && (c == 1)) {
+	    kstack = old_runstack;
+	    old_runstack = RUNSTACK;
+	    ek = (Scheme_Object *)lv;
+#if USE_IF_K
+	    ek2 = NULL;
+#endif
+	    obj = lv->value;
+
+	    goto eval_top;
+	  }
+#endif
+
+	  i = lv->position;
+	  ab = lv->autobox;
+	  value = lv->value;
+	  obj = lv->body;
+
+	  UPDATE_THREAD_RSPTR();
+
+	  if (c == 1) {
+	    value = _scheme_eval_compiled_expr_wp(value, p);
+	    if (ab)
+	      SCHEME_ENVBOX_VAL(RUNSTACK[i]) = value;
+	    else
+	      RUNSTACK[i] = value;
+	  } else {
+	    int c2;
+	    Scheme_Object **stack;
+
+	    value = _scheme_eval_compiled_expr_multi_wp(value, p);
+	    c2 = (SAME_OBJ(value, SCHEME_MULTIPLE_VALUES) ? p->ku.multiple.count : 1);
+	    if (c2 != c) {
+	      scheme_wrong_return_arity(NULL, c, c2, 
+					(c2 == 1) ? (Scheme_Object **)value : p->ku.multiple.array,
+					"local binding");
+	      return NULL;
+	    }
+
+	    values = p->ku.multiple.array;
+#ifdef AGRESSIVE_ZERO_FOR_GC
+	    p->ku.multiple.array = NULL;
+#endif
+	    stack = RUNSTACK;
+	    if (ab) {
+	      while (c--) {
+		SCHEME_ENVBOX_VAL(stack[i]) = *values;
+		values++;
+		i++;
+	      }
+	    } else {
+	      while (c--) {
+		stack[i] = *values;
+		values++;
+		i++;
+	      }
+	    }
+	  }
+
+	  goto eval_top;
+	}
+
+      case scheme_let_void_type:
+	{
+	  Scheme_Let_Void *lv;
+	  int c;
+
+	  lv = (Scheme_Let_Void *)obj;
+	  c = lv->count;
+	  obj = lv->body;
+
+	  PUSH_RUNSTACK(p, RUNSTACK, c);
+
+	  if (lv->autobox) {
+	    Scheme_Object **stack = RUNSTACK;
+
+	    UPDATE_THREAD_RSPTR_FOR_GC();
+
+	    while (c--)
+	      stack[c] = scheme_make_envunbox(scheme_undefined);
+	  }
+
+	  goto eval_top;
+	}
+
+      case scheme_letrec_type:
+	{
+	  Scheme_Letrec *l = (Scheme_Letrec *)obj;
+	  Scheme_Object **a, **dest, **stack;
+	  short *map;
+	  int i;
+
+	  stack = RUNSTACK;
+	  a = l->procs;
+	  i = l->count;
+	  
+	  UPDATE_THREAD_RSPTR_FOR_GC();
+
+	  /* Create unfinished closures */
+	  while (i--)
+	    stack[i] = scheme_make_linked_closure(p, a[i], 0); 
+
+	  /* Close them: */
+	  i = l->count;
+	  while (i--) {
+	    Scheme_Closed_Compiled_Procedure *closure;
+	    Scheme_Closure_Compilation_Data *data;
+	    int j;
+
+	    closure = (Scheme_Closed_Compiled_Procedure *)stack[i];
+	    data = (Scheme_Closure_Compilation_Data *)a[i];
+
+	    map = data->closure_map;
+	    j = data->closure_size;
+	    dest = closure->vals;
+
+	    while (j--) 
+	      dest[j] = stack[map[j]];
+	  }
+
+	  obj = l->body;
+	  goto eval_top;
+	}
+
+      case scheme_let_one_type:
+	{
+	  Scheme_Let_One *lo = (Scheme_Let_One *)obj;
+
+	  PUSH_RUNSTACK(p, RUNSTACK, 1);
+
+	  switch (lo->eval_type) {
+	  case SCHEME_EVAL_CONSTANT:
+	    RUNSTACK[0] = lo->value;
+	    break;
+	  case SCHEME_EVAL_GLOBAL:
+	    {
+	      Scheme_Object *tmpv;
+	      global_lookup(RUNSTACK[0] =, lo->value, tmpv);
+	    }
+	    break;
+	  case SCHEME_EVAL_LOCAL:
+	    RUNSTACK[0] = RUNSTACK[SCHEME_LOCAL_POS(lo->value)];
+	    break;
+	  case SCHEME_EVAL_LOCAL_UNBOX:
+	    RUNSTACK[0] = SCHEME_ENVBOX_VAL(RUNSTACK[SCHEME_LOCAL_POS(lo->value)]);
+	    break;
+	  default:
+	    UPDATE_THREAD_RSPTR();
+	    RUNSTACK[0] = _scheme_eval_compiled_expr_wp(lo->value, p);
+	    break;
+	  }
+
+	  obj = lo->body;
+
+	  goto eval_top;
+	}
+
+      default:
+	v = obj;
+	goto returnv;
+      }
+  }
+
+  if (SAME_OBJ(v, SCHEME_TAIL_CALL_WAITING)) {
+    obj = p->ku.apply.tail_rator;
+    num_rands = p->ku.apply.tail_num_rands;
+    rands = p->ku.apply.tail_rands;
+#ifdef AGRESSIVE_ZERO_FOR_GC
+    p->ku.apply.tail_rands = NULL;
+#endif
+    RUNSTACK = old_runstack;
+    goto apply_top;
+  }
+
+  if (SAME_OBJ(v, SCHEME_EVAL_WAITING)) {
+    obj = p->ku.eval.wait_expr;
+#ifdef AGRESSIVE_ZERO_FOR_GC
+    p->ku.eval.wait_expr = NULL;
+#endif
+    goto eval_top;
+  }
+
+ returnv:
+
+#if USE_IF_K || USE_LET_K
+  if (ek) {
+    if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+      scheme_wrong_return_arity(NULL, 1, p->ku.multiple.count, 
+				p->ku.multiple.array,
+				NULL);
+      return NULL;
+    }
+     
+    RUNSTACK = old_runstack;
+    old_runstack = kstack;
+    
+#if USE_IF_K && USE_LET_K
+    if (ek2) 
+#endif
+#if USE_IF_K
+      { 
+	/* `if' continuation */
+	obj = (SCHEME_FALSEP(v)) ? ek2 : ek;
+      } 
+#endif
+#if USE_IF_K && USE_LET_K
+    else 
+#endif
+#if USE_LET_K
+      {
+	/* `let' continuation */
+	Scheme_Let_Value *lv;
+	int i, ab;
+	
+	lv = (Scheme_Let_Value *)ek;
+	i = lv->position;
+	ab = lv->autobox;
+	
+	if (ab)
+	  SCHEME_ENVBOX_VAL(RUNSTACK[i]) = v;
+	else
+	  RUNSTACK[i] = v;
+	
+	obj = lv->body;
+      }
+#endif
+
+    ek = NULL;
+
+    goto eval_top;
+  }
+#endif
+
+  if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES))
+    if (get_value > 0) {
+      scheme_wrong_return_arity(NULL, 1, p->ku.multiple.count, 
+				p->ku.multiple.array,
+				NULL);
+      return NULL;
+    }
+
+  p->runstack = old_runstack;
+
+  DEBUG_CHECK_TYPE(v);
+
+  return v;
+}
+
+Scheme_Object *scheme_eval(Scheme_Object *obj, Scheme_Env *env)
+{
+  return scheme_eval_compiled(scheme_compile(obj, env, 0));
+}
+
+Scheme_Object *scheme_eval_multi(Scheme_Object *obj, Scheme_Env *env)
+{
+  return scheme_eval_compiled_multi(scheme_compile(obj, env, 0));
+}
+
+static void *eval_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *v;
+
+  v = (Scheme_Object *)p->ku.k.p1;
+
+  if (SAME_TYPE(SCHEME_TYPE(v), scheme_compilation_top_type)) {
+    Scheme_Compilation_Top *top = (Scheme_Compilation_Top *)v;
+    int multi;
+
+    if (!scheme_check_runstack(top->max_let_depth))
+      return (Scheme_Object *)scheme_enlarge_runstack(top->max_let_depth, eval_k);
+
+    v = top->code;
+    
+    p->ku.k.p1 = NULL;
+
+    multi = p->ku.k.i1;
+    
+    if (multi)
+      v = _scheme_eval_compiled_expr_multi_wp(v, p);
+    else
+      v = _scheme_eval_compiled_expr_wp(v, p);
+  } else {
+    p->ku.k.p1 = NULL;
+    v = scheme_void;
+  }
+
+  return (void *)v;
+}
+
+static Scheme_Object *_eval(Scheme_Object *obj, int multi, int top)
+{
+  Scheme_Process *p = scheme_current_process;
+  
+  p->ku.k.p1 = obj;
+  p->ku.k.i1 = multi;
+
+  if (top)
+    return (Scheme_Object *)scheme_top_level_do(eval_k);
+  else
+    return (Scheme_Object *)eval_k();
+}
+
+Scheme_Object *scheme_eval_compiled(Scheme_Object *obj)
+{
+  return _eval(obj, 0, 1);
+}
+
+Scheme_Object *scheme_eval_compiled_multi(Scheme_Object *obj)
+{
+  return _eval(obj, 1, 1);
+}
+
+Scheme_Object *_scheme_eval_compiled(Scheme_Object *obj)
+{
+  return _eval(obj, 0, 0);
+}
+
+Scheme_Object *_scheme_eval_compiled_multi(Scheme_Object *obj)
+{
+  return _eval(obj, 1, 0);
+}
+
+static void *expand_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *obj;
+  Scheme_Comp_Env *env;
+
+  obj = (Scheme_Object *)p->ku.k.p1;
+  env = (Scheme_Comp_Env *)p->ku.k.p2;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  return scheme_expand_expr(obj, env, -1);
+}
+
+Scheme_Object *scheme_expand(Scheme_Object *obj, Scheme_Env *env)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  p->ku.k.p1 = obj;
+  p->ku.k.p2 = env->init;
+
+  return (Scheme_Object *)scheme_top_level_do(expand_k);
+}
+
+Scheme_Object *scheme_tail_eval_expr(Scheme_Object *obj)
+{
+  return scheme_tail_eval(obj);
+}
+
+static Scheme_Object *
+do_default_eval_handler(Scheme_Env *env, int argc, Scheme_Object **argv)
+{
+  Scheme_Object *v;
+
+  v = scheme_compile(argv[0], env, 0);
+
+  return _eval(v, 1, 0);
+}
+
+/* local functions */
+
+typedef struct {
+  Scheme_Config *config;
+  Scheme_Object *e;
+  Scheme_Object *namespace;
+  Scheme_Object *old;
+} Eval_In_Env;
+
+static void pre_eval_in_env(void *e)
+{
+  Eval_In_Env *ee = (Eval_In_Env *)e;
+  ee->old = scheme_get_param(ee->config, MZCONFIG_ENV);
+  scheme_set_param(ee->config, MZCONFIG_ENV, ee->namespace);
+}
+
+static void post_eval_in_env(void *e)
+{
+  Eval_In_Env *ee = (Eval_In_Env *)e;
+  scheme_set_param(ee->config, MZCONFIG_ENV, ee->old);
+}
+
+static Scheme_Object *do_eval_in_env(void *e)
+{
+  Eval_In_Env *ee = (Eval_In_Env *)e;
+  return _scheme_apply_multi(scheme_get_param(ee->config, MZCONFIG_EVAL_HANDLER),
+			     1, &ee->e);
+}
+
+static Scheme_Object *
+eval(int argc, Scheme_Object *argv[])
+{
+  if (argc == 1) {
+    return _scheme_apply_multi(scheme_get_param(scheme_config, MZCONFIG_EVAL_HANDLER),
+			       1, argv);
+  } else {
+    Eval_In_Env *ee;
+    
+    if (SCHEME_TYPE(argv[1]) != scheme_namespace_type)
+      scheme_wrong_type("eval", "namespace", 1, argc, argv);
+
+    ee = MALLOC_ONE(Eval_In_Env);
+    ee->e = argv[0];
+    ee->config = scheme_config;
+    ee->namespace = argv[1];
+
+    return scheme_dynamic_wind(pre_eval_in_env, do_eval_in_env, post_eval_in_env,
+			       NULL, ee);
+  }
+}
+
+static Scheme_Object *
+default_eval_handler(int argc, Scheme_Object **argv)
+{
+  Scheme_Env *env = scheme_get_env(scheme_config);
+
+  return do_default_eval_handler(env, argc, argv);
+}
+
+static Scheme_Object *
+current_eval(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("eval-handler", MZCONFIG_EVAL_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+compile(int argc, Scheme_Object *argv[])
+{
+  return scheme_compile(argv[0], scheme_get_env(scheme_config), 1);
+}
+
+#if OPT_COMPILE_VISIBLE
+static Scheme_Object *
+compile_x(int argc, Scheme_Object *argv[])
+{
+  Scheme_Compile_Info rec;
+
+  rec.can_optimize_constants = 1;
+  rec.globals_must_be_primitive = 0;
+  rec.value_name = NULL;
+  return scheme_link_expr(scheme_compile_expr(argv[0], 
+					      scheme_get_env(scheme_config)->init, 
+					      &rec),
+			  scheme_link_info_create(1));
+}
+#endif
+
+
+
+static Scheme_Object *expand(int argc, Scheme_Object **argv)
+{
+  return scheme_expand_expr(argv[0], scheme_get_env(scheme_config)->init, -1);
+}
+
+static Scheme_Object *
+local_expand(int argc, Scheme_Object **argv)
+{
+  Scheme_Comp_Env *env;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expand-defmacro: illegal at run-time");
+
+  return scheme_expand_expr(argv[0], env, -1);
+}
+
+static Scheme_Object *
+local_expand_body_expression(int argc, Scheme_Object **argv)
+{
+  Scheme_Comp_Env *env;
+  Scheme_Object *expr, *a[2], *gval;
+
+  env = scheme_current_process->current_local_env;
+  if (!env)
+    scheme_raise_exn(MZEXN_MISC_EXPANSION_TIME,
+		     "local-expand-body-expression: illegal at run-time");
+
+  /* Check for macro expansion, which could mask the real define-values */
+  expr = argv[0];
+  if (SCHEME_PAIRP(expr))
+    expr = scheme_check_immediate_macro(argv[0], env, NULL, -1, &gval);
+  else
+    gval = NULL;
+
+  a[0] = expr;
+  if (SAME_OBJ(gval, scheme_begin_syntax)) {
+    a[1] = begin_symbol;
+  } else if (SAME_OBJ(gval, scheme_define_values_syntax)) {
+    a[1] = define_values_symbol;
+  } else {
+    a[1] = scheme_false;
+  }
+
+  return scheme_values(2, a);
+}
+
+static Scheme_Object *
+expand_once(int argc, Scheme_Object **argv)
+{
+  return scheme_expand_expr(argv[0], scheme_get_env(scheme_config)->init, 1);
+}
+
+Scheme_Object *scheme_eval_string_all(const char *str, Scheme_Env *env, int cont)
+{
+  Scheme_Object *port, *expr, *result = scheme_void;
+
+  port = scheme_make_string_input_port(str);
+  do {
+    expr = scheme_read(port);
+    if (SAME_OBJ(expr, scheme_eof))
+      cont = 0;
+    else
+      result = scheme_eval_multi(expr, env);
+  } while (cont);
+
+  return result;
+}
+
+Scheme_Object *scheme_eval_string(const char *str, Scheme_Env *env)
+{
+  return scheme_eval_string_all(str, env, 0);
+}
+
+static Scheme_Object *allow_auto_cond_else(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("compile-auto-cond-else", MZCONFIG_COND_AUTO_ELSE,
+			     argc, argv,
+			     -1, NULL, NULL, 1);
+}
+
+static Scheme_Object *allow_set_undefined(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("compile-allow-set!-undefined", MZCONFIG_ALLOW_SET_UNDEFINED,
+			     argc, argv,
+			     -1, NULL, NULL, 1);
+}
+
+static Scheme_Object *
+enable_break(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Process *p = scheme_current_process;
+
+  v = scheme_param_config("break-enabled", MZCONFIG_ENABLE_BREAK,
+			  argc, argv,
+			  -1, NULL, NULL, 1);
+
+  if (p->external_break && scheme_can_break(p, p->config))
+    scheme_process_block_w_process(0.0, p);
+
+  return v;
+}
+
+static Scheme_Object *
+exn_enable_break(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v;
+  Scheme_Process *p = scheme_current_process;
+
+  v = scheme_param_config("exception-break-enabled", MZCONFIG_ENABLE_EXCEPTION_BREAK,
+			  argc, argv,
+			  -1, NULL, NULL, 1);
+
+  if (p->external_break && scheme_can_break(p, p->config))
+    scheme_process_block_w_process(0.0, p);
+
+  return v;
+}
+
+typedef struct {
+  Scheme_Object *old;
+  Scheme_Config *config;
+  Scheme_Object *f;
+} Enable_Break;
+
+static void pre_enable_br(void *eb)
+{
+  ((Enable_Break *)eb)->old = scheme_get_param(((Enable_Break *)eb)->config, MZCONFIG_ENABLE_BREAK);
+
+  scheme_set_param(((Enable_Break *)eb)->config, MZCONFIG_ENABLE_BREAK,
+		   scheme_true);
+}
+
+static void post_enable_br(void *eb)
+{
+  scheme_set_param(((Enable_Break *)eb)->config, MZCONFIG_ENABLE_BREAK,
+		   ((Enable_Break *)eb)->old);
+}
+
+static Scheme_Object *do_enable_br(void *eb)
+{
+  return _scheme_apply_multi(((Enable_Break *)eb)->f, 0, NULL);
+}
+
+static Scheme_Object *
+dynamic_enable_break(int argc, Scheme_Object *argv[])
+{
+  Enable_Break *eb;
+
+  eb = (Enable_Break *)scheme_malloc(sizeof(Enable_Break));
+  eb->f = argv[0];
+  eb->config = scheme_config;
+
+  return scheme_dynamic_wind(pre_enable_br, do_enable_br, post_enable_br,
+			     NULL, eb);
+}
+
+static Scheme_Object *
+default_user_break_poll_proc(int c, Scheme_Object **a)
+{
+  return scheme_false;
+}
+
+static Scheme_Object *
+user_break_poll(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("user-break-poll-handler", 
+			     MZCONFIG_USER_BREAK_POLL_HANDLER,
+			     argc, argv,
+			     0, NULL, NULL, 0);
+}
+
+/****************************************************/
+
+#define BOOL(x) (x ? scheme_true : scheme_false)
+
+#define RD_TM_OPT 1
+
+static Scheme_Object *write_application(Scheme_Object *obj)
+{
+  Scheme_App_Rec *app;
+  Scheme_Object *l;
+  int i;
+
+  app = (Scheme_App_Rec *)obj;
+
+  l = scheme_null;
+  for (i = app->num_args + 1; i--; )
+    l = cons(app->args[i], l);
+  
+  return l;
+}
+
+static Scheme_Object *read_application(Scheme_Object *obj)
+{
+  /* (void) optimization: */
+  if (SCHEME_PAIRP(obj) && SCHEME_NULLP(SCHEME_CDR(obj))
+      && SAME_OBJ(SCHEME_CAR(obj), scheme_void_func))
+    return scheme_void;
+
+  return make_application(NULL, obj, RD_TM_OPT, 1);
+}
+
+static Scheme_Object *write_sequence(Scheme_Object *obj)
+{
+  Scheme_Object *l, **a;
+  int i;
+
+  i = ((Scheme_Sequence *)obj)->count;
+  a = ((Scheme_Sequence *)obj)->array;
+
+  l = scheme_null;
+  for (; i--; )
+    l = cons(a[i], l);
+  
+  return l;
+}
+
+static Scheme_Object *read_sequence(Scheme_Object *obj)
+{
+  return scheme_make_sequence_compilation(obj, RD_TM_OPT, RD_TM_OPT);
+}
+
+static Scheme_Object *read_sequence_save_first(Scheme_Object *obj)
+{
+  return scheme_make_sequence_compilation(obj, 1, -1);
+}
+
+static Scheme_Object *write_branch(Scheme_Object *obj)
+{
+  Scheme_Branch_Rec *b;
+
+  b = (Scheme_Branch_Rec *)obj;
+
+  return cons(b->test, cons(b->tbranch, b->fbranch));
+}
+
+#define MAKE_BRANCH scheme_make_branch
+
+static Scheme_Object *read_branch(Scheme_Object *obj)
+{
+#if 0
+  if (!SCHEME_PAIRP(obj) || !SCHEME_PAIRP(SCHEME_CDR(obj)))
+    scheme_signal_error("bad compiled branch");
+#endif
+
+  return MAKE_BRANCH(SCHEME_CAR(obj), 
+		     SCHEME_CAR(SCHEME_CDR(obj)),
+		     SCHEME_CDR(SCHEME_CDR(obj)));
+}
+
+static Scheme_Object *write_syntax(Scheme_Object *obj)
+{
+  Scheme_Object *sym;
+  Scheme_Syntax_Registered *f;
+
+  f = (Scheme_Syntax_Registered *)SCHEME_PTR1_VAL(obj);
+  sym = scheme_find_linker_name(f);
+  if (!sym)
+    sym = unknown_symbol;
+
+  return cons(sym, (Scheme_Object *)SCHEME_PTR2_VAL(obj));
+}
+
+static Scheme_Object *read_syntax(Scheme_Object *obj)
+{
+  Scheme_Object *sym;
+  Scheme_Syntax_Registered *f;
+  Scheme_Object *first = NULL, *last = NULL;
+
+#if 0
+  if (!SCHEME_PAIRP(obj) || !SCHEME_SYMBOLP(SCHEME_CAR(obj)))
+    scheme_signal_error("bad compiled syntax");
+#endif
+
+  sym = SCHEME_CAR(obj);
+  if (SAME_OBJ(unknown_symbol, sym))
+    scheme_signal_error("unknown (at write time) compiled syntax");
+
+  if (SAME_OBJ(void_link_symbol, sym))
+    return scheme_void;
+
+  f = scheme_find_linker(sym);
+  if (!f)
+    scheme_signal_error("unknown compiled syntax: %s", SCHEME_SYM_VAL(sym));
+
+  /* Copy obj: */
+  obj = SCHEME_CDR(obj);
+  while (SCHEME_PAIRP(obj)) {
+    Scheme_Object *p = scheme_make_pair(SCHEME_CAR(obj), scheme_null);
+    if (last)
+      SCHEME_CDR(last) = p;
+    else
+      first = p;
+    last = p;
+    obj = SCHEME_CDR(obj);
+  }
+  
+  if (last)
+    SCHEME_CDR(last) = obj;
+  else
+    first = obj;
+
+  return scheme_make_syntax_link(f, first);
+}
diff --git a/src/mzscheme/src/exnsrc.ss b/src/mzscheme/src/exnsrc.ss
new file mode 100644
index 0000000..a3a886a
--- /dev/null
+++ b/src/mzscheme/src/exnsrc.ss
@@ -0,0 +1,195 @@
+
+#|
+
+Initial symbols are struct types. A non-initial symbol is a struct
+type without fields or subtypes. Square brackets are struct fields, *
+indicates MzScheme-specific (the star is not in the name), strings are
+types/comments.  Except for exn:misc, only terminal types are
+instantiated.
+
+|#
+
+(exn [message "string" "error message" 
+	      debug-info "anything" "value returned by the current debug info handler (called immediately after the error is detected)"] -
+     (user [] "raised by calling \\scmfirst{error}")
+     
+     (syntax [expr "S-expression" "illegal expression (or \\scm{\\#f} if unknown)"]
+	     "all syntax errors, but not \\scmfirst{read} errors")
+
+     (variable [id "identifier" "the unbound variable's global identifier"]
+	       "unbound global variable at run-time")
+
+     (application [value "error-specific" "the error-specific inappropriate value"] -
+		  (non-procedure [] "application of a non-procedure")
+		  (arity [expected 
+			  "arity"
+			  "the correct procedure arity as returned by \\scmfirst{arity}"]
+			 "application with the wrong number of arguments")
+		  (type [expected "symbol" "name of the expected type"]
+			"wrong argument type to a procedure, not including divide-by-zero or platform-specific integer range errors")
+		  (range [] -
+			 (bounds [min "integer" "minimum legal index" 
+				       max "integer" "maximum legal index" ] -
+				       (vector [] "illegal vector index; raised by \\scmfirst{vector-ref}, \\scm{vector-set!}\\scmindex{vector-set\"!}")
+				       (string [] "illegal string index; raised by \\scmfirst{string-ref}, \\scm{string-set!}\\scmindex{string-set\"!}, \\scmfirst{substring}")
+				       (struct [] "illegal struct index; raised by \\scmfirst{struct-ref}"))
+			 (list [] "illegal list index; raised by \\scmfirst{list-ref}, \\scmfirst{list-tail}"))
+		  (list-sizes [] "mismatched list sizes; raised by \\scmfirst{map}, \\scmfirst{for-each}, \\scmfirst{make-struct-case}")
+		  (map-arity [provided "non-negative integer" "the number of lists provided for mapping"]
+			     "arity of supplied procedure does not match the number of lists provided to \\scmfirst{map}, \\scmfirst{for-each}, \\scmfirst{andmap}, \\scmfirst{ormap}")
+		  (integer []
+			   "integer out of machine-specific range; raised by \\scmfirst{make-semaphore}, \\scm{set-thread-weight!}\\scmindex{set-thread-weight\"!}, \\scmfirst{seconds->date}")
+		  (list []
+			"encountered a non-pair in a value expected to be a proper list, or a non-pair item in a value expected to be an association list; raised by \\scmfirst{member}, \\scmfirst{memv}, \\scmfirst{memq}, \\scmfirst{assoc}, \\scmfirst{assv}, \\scmfirst{assq}\\footnote{This exception is raised instead of a type exception because an error will not be signalled if a result is determined before processing the entire list.}")
+#|
+		  (*struct-type-conflict [conflicts-with "struct predicate procedure" "previously-specified entailing procedure"] 
+					 "error in the struct predicate list: it cannot be checked in the order given due to sub-typing constraints, or the same predicate is specified twice; raised by \\scmfirst{make-struct-case}")
+|#
+		  (math [] -
+			(zero [] "divide by zero, etc.; raised by \\scmfirst{/}, \\scmfirst{quotient}, \\scmfirst{remainder}, \\scmfirst{modulo}, \\scmfirst{angle}; \\scm{application-value} is always zero")
+			(infinity [] "infinity overflows; never raised by MzScheme")
+			(negative [] "illegal negative input (e.g. \\scmfirst{sqrt}); never raised by MzScheme")
+			(radix [] "unsupported radix (positive fixnum); raised by \\scmfirst{number->string}"))
+		  (*mode-conflict 
+		   [filename "string" "filename being opened"]
+		   "incompatible mode flags; raised by \\scmfirst{open-output-file}, \\scmfirst{call-with-output-file}, \\scmfirst{with-output-to-file}")
+		  (*file-position [] "position was provided, but the port was not a file port; raised by \\scmfirst{file-position}; \\scm{application-value} is the port")
+		  (*fprintf [] -
+			    (*extra-arguments 
+			     [extras "list of values" "arguments without formatting tags"]
+			     "arguments without corresponding formatting tags; \\scm{application-value} is the format string")
+			    (*no-argument 
+			     [] 
+			     "formatting tags without corresponding arguments; \\scm{application-value} is the format string")
+			    (*argument-type
+			     [expected "symbol" "type expected by formatting tag"]
+			     "argument does not match type expected by formatting tag; \\scm{application-value} is the bad value")))
+
+     (*else [] "fall-through in \\scmfirst{cond} or \\scmfirst{case}")
+
+     (*struct [] -
+	     (*struct-type [value "anything except structure type" "the given supertype value"]
+			   "the supertype expression in a \\scmfirst{struct} form returned a value that was not a structure type value"))
+
+     (*object [] -
+	     (*class-type [value "anything except class" "the value provided as a superclass"]
+			  "the superclass expression in \\scmfirst{class*} returned a non-class")
+	     (*interface-type [value "anything except interface" "the value provided as an interface"]
+			 "an interface expression in \\scmfirst{class*} or \scmfirst{interface} returned a non-interface")
+	     (*generic [object "object" "the object"]
+		       "the object was not an instance of the generic's class or interface; raised by generic procedures")
+	     (*inherit [ivar "identifier" "instance variable name"] 
+		      "inherited ivar not found; raised by \\scmfirst{class*}")
+	     (*implement [ivar "identifier" "instance variable name"] 
+			 "ivar required by an interface not found in the implementation; raised by \\scmfirst{class*}")
+	     (*class-ivar [class  "class" "the class"
+				 ivar "identifier" "instance variable name"] 
+			 "instance variable not found in class; raised by \\scmfirst{uq-make-generic}")
+	     (*interface-ivar [interface  "interface" "the interface"
+				 ivar "identifier" "instance variable name"] 
+			 "instance variable not found in interface; raised by \\scmfirst{uq-make-generic}")
+	     (*ivar [object "object" "the object" 
+			   ivar "identifier" "instance variable name"]
+		   "instance variable not found; raised by \\scmfirst{uq-ivar}")
+	     (*private-class [class "class" "the class"] 
+			    "cannot instantiate or derive from this primitive class; raised by \\scmfirst{make-object}, \\scmfirst{class*}")
+	     (*init [object "object" "the object"
+			    class "class" "the class that called a superclass initializer too much or not enough"] -
+		   (*multiple [] "the superclass intialization proc (e.g., \\scmfirst{super-init}) called twice for the class")
+		   (*never [] "the superclass intialization proc (e.g., \\scmfirst{super-init}) never called for the class")))
+     
+     (*unit [] -
+	      (*non-unit [value "anything" "non-unit value"] "attempt to link a non-unit; raised by \\scmfirst{compound-unit}, \\scmfirst{invoke-unit}, \\scmfirst{invoke-open-unit}")
+	      (*arity [unit "unit" "badly linked unit"] 
+		      "attempt to link a unit with the wrong number of imported variables; raised by \\scmfirst{compound-unit}")
+	      (*import [in-unit "unit" "importing unit"
+			     out-unit "unit" "source unit"
+			     in-tag "identifier" "importing unit tag"
+			     out-tag "identifier" "source unit tag"
+			     name "identifier" "import variable name"] 
+		       "cannot find variable to import; raised by \\scmfirst{compound-unit}")
+	      (*export [unit "unit" "source unit"
+			     tag "identifier" "source unit tag"
+			     name "identifier" "source variable name"] 
+		       "cannot find variable to export for compound unit; raised by \\scmfirst{compound-unit}")
+	      (*invoke [] -
+		       (*variable [name "identifier" "bad identifier"]
+				  "cannot invoke with import of an undefined global variable"))
+	      (*signature [] -
+			  (*non-signed-unit [value "anything" "non-signed-unit value"]
+					    "attempt to link a non-signed-unit; raised by \\scmfirst{compound-unit/sig}, \\scmfirst{invoke-unit/sig}, \\scmfirst{invoke-open-unit/sig}")
+			  (*arity [unit "signed-unit" "signed-unit"] "attempt to link signed unit with the wrong number of imported units; raised by \\scmfirst{compound-unit/sig}")
+			  (*match [dest-context "string" "destination context"
+						src-context "string" "source context"
+						variable "string" "mismatch variable name"] -
+				  (*missing [] "signature mismatch (missing variable) detected by \\scmfirst{verify-signature-match}")
+				  (*extra [] "signature mismatch (extra variable) detected by \\scmfirst{verify-signature-match}")
+				  (*kind [] "signature mismatch (mismatched kinds) detected by \\scmfirst{verify-signature-match}"))))
+
+     (read [port "port" "port being read"] -
+	   (+paren [] "unexpected close paren")
+	   (+number [input "string" "input number string"] "bad number syntax")
+	   (+char [input "string" "input character string without \\scmch{}"] 
+		 "bad character constant")
+	   (+eof [expected "string" "expected input"] 
+		"unexpected end of file")
+	   (+dot [] "dot at top-level or illegal use of dot; e.g., \\scm{( .\\ 1)}")
+	   (+unsupported [input "string" "input string without \\scm{\\#}"] 
+			"unsupported \\scm{\\#} tag")
+	   (*vector-length [input "string" "vector length string"]
+			   "bad vector size in vector constant")
+	   (*compiled  [] "illegal MzScheme compiled code")
+	   (*graph [] "bad graph syntax"))
+     
+     (i/o [] -
+	  (read [port "input port" "port with read error"]
+		"error reading from a port")
+	  (write [port "output port" "port with write error"]
+		 "error writing to a port")
+	  (filesystem [pathname "string" "pathname"] -
+		      (+path [] "bad pathname; raised by all file procedures that take a pathname"
+			     (+username [] "bad username (Unix only); raised by all file procedures that take a pathname"))
+		      (+file [] "file not found; raised by procedures that open files")
+		      (+directory [] "directory not found; raised by \\scmfirst{current-directory}, \\scmfirst{current-load-directory}, \\scmfirst{directory-list}, \\scmfirst{load-with-cd}")
+		      (+collection [] "collection not found; raised by \\scmfirst{require-library}, \\scmfirst{require-relative-library}")
+		      (+file-exists [] "cannot overwrite file; raised by \\scmfirst{open-output-file}"))
+	  (port-closed [port "port" "port for attempted operation"]
+		       "attempt to operate on a closed port; raised by \\scmfirst{read}, \\scmfirst{write}, \\scmfirst{display}, \\scmfirst{print}, \\scmfirst{char-ready?}")
+	  (*user-port [port "input port" "user-defined input port"] 
+		      "user-defined input port returned a non-character from the character-getting procedure")
+	  (*tcp [] "TCP errors"
+		(*connect [address "string" "address to connect to"
+				   port-id "integer" "port to connect to"]
+			  "tcp-connect low-level failure")
+		(*listen [port-id "integer" "port to listen on"]
+			 "tcp-listen low-level failure")
+		(*accept [listener "listener" "listener to accept from"]
+			 "tcp-accept low-level failure")
+		(*listener-closed [listener "listener" "listener that has been closed"]
+				  "listener closed for \\scmfirst{tcp-accept}, \\scmfirst{tcp-accept-ready?}, \\scmfirst{tcp-stop}")))
+
+     (misc [] "low-level errors"
+	   (unsupported [] "unsupported feature")
+	   (user-break [] "asynchronous thread break")
+	   (out-of-memory [] "out of memory")
+	   (*parameterization [value "anything except a parameterization" "bad value"]
+			      "the parameterization branch handler or sharing procedure returned a non-parameterization; raised by \\scmfirst{thread}, \\scmfirst{make-parameterization-with-sharing}")
+	   (*defmacro [value "anything except a procedure" "the given macro handler"] 
+		      "macro handler is not a procedure")
+	   (*expansion-time [] "\\scmfirst{local-expansion-time-value}, \\scmfirst{global-expansion-time-value}, \\scmfirst{local-expand-defmacro}, or \\scmfirst{local-expand-body-expression} called at run-time")
+	   (*constant [id "identifier" "constant identifier"] "attempt to change a constant global; raised by \\scm{set!}\\scmindex{set\"!}, \\scmfirst{define}, \\scmfirst{undefine}, \\scmfirst{invoke-open-unit}")
+	   (*continuation [] "attempt to cross a continuation boundary or apply another thread's continuation")
+	   (*thread [] -
+		    (*kill [] "cannot kill the thread; raised by \\scmfirst{kill-thread}"))
+	   (*semaphore [] "a semaphore's maximum internal count has been exceeded")
+	   (*hash-table [key "anything" "key for failed lookup"] "failed hash table lookup")
+	   (*regexp [] "all regular expression errors")
+	   (*process [] "error executing an operating system process")
+	   (*dynamic-extension [name "string" "dynamic extension pathname"] -
+			       (*open [] "cannot open dynamic extension")
+			       (*version [] "dynamic extension is wrong version")
+			       (*initialize [] "cannot initialize dynamic extension"))
+	   (*image [name "string" "image pathname"]
+		   "error dumping or restoring an image; raised by \\scmfirst{write-image-to-file}, \\scmfirst{read-image-from-file}")))
+
+
diff --git a/src/mzscheme/src/file.c b/src/mzscheme/src/file.c
new file mode 100644
index 0000000..b9d29fd
--- /dev/null
+++ b/src/mzscheme/src/file.c
@@ -0,0 +1,2837 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#ifdef UNISTD_INCLUDE
+# include <unistd.h>
+#endif
+#ifndef NO_STAT_PROC
+# ifdef NO_SYS_INCLUDE_SUBDIR
+#  include <stat.h>
+# else
+#  include <sys/types.h>
+#  include <sys/stat.h>
+# endif
+#endif
+#ifdef EXPAND_FILENAME_TILDE
+# include <pwd.h>
+#endif
+#ifndef NO_FILE_SYSTEM_UTILS
+# include <ctype.h>
+# ifndef NO_READDIR
+#  include <dirent.h>
+# endif
+#endif
+#ifdef DIR_INCLUDE
+# include <dir.h>
+#endif
+#ifdef DIRECT_INCLUDE
+# include <direct.h>
+#endif
+#ifdef IO_INCLUDE
+# include <io.h>
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+# include <Files.h>
+#endif
+#ifdef UNIX_FILE_SYSTEM
+# include <fcntl.h>
+# include <grp.h>
+# include <pwd.h>
+#endif
+#ifdef DOS_FILE_SYSTEM
+# include <windows.h>
+#endif
+#ifdef NO_ERRNO_GLOBAL
+# define errno -1
+#else
+# include <errno.h>
+#endif
+
+#if defined(S_IFDIR) && !defined(S_ISDIR)
+# define S_ISDIR(m) ((m) & S_IFDIR)
+#endif
+#if defined(S_IFREG) && !defined(S_ISREG)
+# define S_ISREG(m) ((m) & S_IFREG)
+#endif
+#if defined(S_IFLNK) && !defined(S_ISLNK)
+# define S_ISLNK(m) ((m) & S_IFLNK)
+#endif
+#if defined(_S_IFDIR) && !defined(S_ISDIR)
+# define S_ISDIR(m) ((m) & _S_IFDIR)
+#endif
+#if defined(_S_IFREG) && !defined(S_ISREG)
+# define S_ISREG(m) ((m) & _S_IFREG)
+#endif
+
+#ifdef MAC_FILE_SYSTEM
+long scheme_creator_id = 'MzSc';
+#endif
+
+#ifdef UNIX_FILE_SYSTEM
+# define FN_SEP '/'
+# define IS_A_SEP(x) ((x) == '/')
+#endif
+#ifdef DOS_FILE_SYSTEM
+# define FN_SEP '\\'
+# define IS_A_SEP(x) (((x) == '/') || ((x) == '\\'))
+#endif
+#ifdef MAC_FILE_SYSTEM
+# define FN_SEP ':'
+# define IS_A_SEP(x) ((x) == ':')
+#endif
+
+/* local */
+static Scheme_Object *file_exists(int argc, Scheme_Object **argv);
+static Scheme_Object *directory_exists(int argc, Scheme_Object **argv);
+static Scheme_Object *link_exists(int argc, Scheme_Object **argv);
+
+#ifndef NO_FILE_SYSTEM_UTILS
+static Scheme_Object *delete_file(int argc, Scheme_Object **argv);
+static Scheme_Object *rename_file(int argc, Scheme_Object **argv);
+static Scheme_Object *copy_file(int argc, Scheme_Object **argv);
+static Scheme_Object *directory_list(int argc, Scheme_Object *argv[]);
+static Scheme_Object *filesystem_root_list(int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_directory(int argc, Scheme_Object *argv[]);
+static Scheme_Object *delete_directory(int argc, Scheme_Object *argv[]);
+static Scheme_Object *relative_pathname_p(int argc, Scheme_Object **argv);
+static Scheme_Object *absolute_pathname_p(int argc, Scheme_Object **argv);
+static Scheme_Object *complete_pathname_p(int argc, Scheme_Object **argv);
+static Scheme_Object *path_to_complete_path(int argc, Scheme_Object **argv);
+static Scheme_Object *resolve_path(int argc, Scheme_Object *argv[]);
+static Scheme_Object *expand_path(int argc, Scheme_Object *argv[]);
+static Scheme_Object *current_drive(int argc, Scheme_Object *argv[]);
+static Scheme_Object *normal_path_case(int argc, Scheme_Object *argv[]);
+static Scheme_Object *file_modify_seconds(int argc, Scheme_Object *argv[]);
+static Scheme_Object *file_or_dir_permissions(int argc, Scheme_Object *argv[]);
+static Scheme_Object *file_size(int argc, Scheme_Object *argv[]);
+static Scheme_Object *current_library_collection_paths(int argc, Scheme_Object *argv[]);
+#endif
+
+#ifdef DIR_FUNCTION
+static Scheme_Object *current_directory(int argc, Scheme_Object *argv[]);
+#endif
+
+#ifdef DOS_FILE_SYSTEM
+static char get_cur_drive_id(void);
+#endif
+
+#ifndef NO_FILE_SYSTEM_UTILS
+static Scheme_Object *up_symbol, *relative_symbol;
+static Scheme_Object *same_symbol;
+static Scheme_Object *read_symbol, *write_symbol, *execute_symbol;
+#endif
+
+void scheme_init_file(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+#ifndef NO_FILE_SYSTEM_UTILS
+    REGISTER_SO(up_symbol);
+    REGISTER_SO(relative_symbol);
+    REGISTER_SO(same_symbol);
+    REGISTER_SO(read_symbol);
+    REGISTER_SO(write_symbol);
+    REGISTER_SO(execute_symbol);
+    
+    up_symbol = scheme_intern_symbol("up");
+    relative_symbol = scheme_intern_symbol("relative");
+    same_symbol = scheme_intern_symbol("same");
+
+    read_symbol = scheme_intern_symbol("read");
+    write_symbol = scheme_intern_symbol("write");
+    execute_symbol = scheme_intern_symbol("execute");
+#endif
+    
+    scheme_set_param(scheme_config, MZCONFIG_COLLECTION_PATHS,  scheme_null);
+  }
+
+  scheme_add_global_constant("file-exists?", 
+			     scheme_make_prim_w_arity(file_exists, 
+						      "file-exists?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("directory-exists?", 
+			     scheme_make_prim_w_arity(directory_exists, 
+						      "directory-exists?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("link-exists?", 
+			     scheme_make_prim_w_arity(link_exists, 
+						      "link-exists?", 
+						      1, 1), 
+			     env);
+#ifndef NO_FILE_SYSTEM_UTILS
+  scheme_add_global_constant("delete-file", 
+			     scheme_make_prim_w_arity(delete_file, 
+						      "delete-file", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("rename-file", 
+			     scheme_make_prim_w_arity(rename_file, 
+						      "rename-file", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("copy-file", 
+			     scheme_make_prim_w_arity(copy_file, 
+						      "copy-file", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("build-path", 
+			     scheme_make_prim_w_arity(scheme_build_pathname,
+						      "build-path", 
+						      1, -1), 
+			     env);
+  scheme_add_global_constant("split-path", 
+			     scheme_make_prim_w_arity2(scheme_split_pathname,
+						       "split-path",
+						       1, 1,
+						       3, 3), 
+			     env);
+  scheme_add_global_constant("relative-path?", 
+			     scheme_make_prim_w_arity(relative_pathname_p,
+						      "relative-path?",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("absolute-path?", 
+			     scheme_make_prim_w_arity(absolute_pathname_p,
+						      "absolute-path?",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("complete-path?", 
+			     scheme_make_prim_w_arity(complete_pathname_p,
+						      "complete-path?",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("path->complete-path",
+			     scheme_make_prim_w_arity(path_to_complete_path,
+						      "path->complete-path",
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("resolve-path",
+			     scheme_make_prim_w_arity(resolve_path,
+						      "resolve-path",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("expand-path",
+			     scheme_make_prim_w_arity(expand_path,
+						      "expand-path",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("normal-case-path",
+			     scheme_make_prim_w_arity(normal_path_case,
+						      "normal-case-path",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("directory-list",
+			     scheme_make_prim_w_arity(directory_list,
+						      "directory-list",
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("filesystem-root-list",
+			     scheme_make_prim_w_arity(filesystem_root_list,
+						      "filesystem-root-list",
+						      0, 0), 
+			     env);
+  scheme_add_global_constant("make-directory",
+			     scheme_make_prim_w_arity(make_directory,
+						      "make-directory",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("delete-directory",
+			     scheme_make_prim_w_arity(delete_directory,
+						      "delete-directory",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("file-modify-seconds",
+			     scheme_make_prim_w_arity(file_modify_seconds,
+						      "file-modify-seconds",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("file-or-directory-permissions",
+			     scheme_make_prim_w_arity(file_or_dir_permissions,
+						      "file-or-directory-permissions",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("file-size",
+			     scheme_make_prim_w_arity(file_size,
+						      "file-size",
+						      1, 1), 
+			     env);
+
+  scheme_add_global_constant("current-drive", 
+			     scheme_make_prim_w_arity(current_drive, 
+						      "current-drive", 
+						      0, 0), 
+			     env);
+#endif
+
+#ifdef DIR_FUNCTION
+  scheme_add_global_constant("current-directory", 
+			     scheme_make_prim_w_arity(current_directory, 
+						      "current-directory", 
+						      0, 1), 
+			     env);
+#endif
+
+#ifndef NO_FILE_SYSTEM_UTILS
+  scheme_add_global_constant("current-library-collection-paths",
+			     scheme_register_parameter(current_library_collection_paths,
+						       "current-library-collection-paths",
+						       MZCONFIG_COLLECTION_PATHS),
+			     env);
+#endif
+}
+
+#ifdef USE_MAC_FILE_TOOLBOX
+char *scheme_build_mac_filename(FSSpec *spec, int given_dir);
+#endif
+
+char *scheme_getcwd(char *buf, int buflen, int *actlen, int noexn)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+    char *dir;
+    char nbuf[64];
+    WDPBRec rec;
+    FSSpec spec;
+    
+    rec.ioNamePtr = (StringPtr)nbuf;
+    PBHGetVol(&rec, 0);
+    spec.vRefNum = rec.ioVRefNum;
+    spec.parID = rec.ioWDDirID;
+    
+    dir = scheme_build_mac_filename(&spec, 1);
+
+    if (actlen)
+      *actlen = strlen(dir) + 1;
+
+    return dir;
+#else
+# define GETCWD_BUFSIZE 1024
+    char buffer[GETCWD_BUFSIZE], *r, *gbuf;
+    int obuflen = buflen;
+
+    if (buflen < GETCWD_BUFSIZE) {
+      gbuf = buffer;
+      buflen = GETCWD_BUFSIZE;
+    } else
+      gbuf = buf;
+
+    r = MSC_IZE(getcwd)(gbuf, buflen - 1);
+    if (!r) {
+      char *r2;
+
+      r = MSC_IZE(getcwd)(NULL, 0);
+      if (!r) {
+	/* Something bad happened! */
+	if (noexn) {
+	  if (actlen)
+	    *actlen = 0;
+
+	  if (buf) {
+	    buf[0] = 0;
+	    return buf;
+	  } else {
+	    return "";
+	  }
+	}
+
+	scheme_raise_exn(MZEXN_I_O, "current-directory: unknown failure (%d)", errno);
+      }
+
+      buflen = strlen(r) + 1;
+      r2 = (char *)scheme_malloc_atomic(buflen);
+      memcpy(r2, r, buflen);
+      r2[buflen] = 0;
+      free(r);
+      r = r2;
+
+      if (actlen)
+	*actlen = buflen;
+    } else {
+      int slen = strlen(r) + 1;
+
+      if (actlen)
+	*actlen = slen;
+
+      if (obuflen < slen)
+      	r = scheme_strdup(r);
+      else if (r != buf) {
+	memcpy(buf, r, slen);
+	r = buf;
+      }
+    }
+     
+    return r;
+#endif
+}
+
+int scheme_setcwd(char *expanded, int noexn)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+#endif
+  int err;
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (find_mac_file(expanded, &spec, 1, 0, NULL, NULL, NULL, NULL, NULL, NULL)) {
+    WDPBRec rec;
+    
+    rec.ioNamePtr = NULL;
+    rec.ioVRefNum = spec.vRefNum;
+    rec.ioWDDirID = spec.parID;
+    
+    err = PBHSetVol(&rec, 0);
+  } else
+    err = 1;
+#else
+  err = MSC_IZE(chdir)(expanded);
+#endif
+
+  if (err && !noexn)
+      scheme_raise_exn(MZEXN_I_O_FILESYSTEM_DIRECTORY,
+		       scheme_make_string(expanded),
+		       "current-directory: unable to switch to directory: \"%.255s\"",
+		       expanded);
+
+  return !err;
+}
+
+Scheme_Object *scheme_get_file_directory(const char *filename)
+{
+  Scheme_Object *v = scheme_make_sized_string((char *)filename, strlen(filename), 0);
+  
+  v = path_to_complete_path(1, &v);
+  scheme_split_pathname(1, &v);
+  return scheme_current_process->ku.multiple.array[0];
+}
+
+#if 0
+char *scheme_make_complete_path(const char *filename)
+{
+  Scheme_Object *v = scheme_make_sized_string((char *)filename, strlen(filename), 0);
+  
+  v = path_to_complete_path(1, &v);
+
+  return SCHEME_STR_VAL(v);
+}
+#endif
+
+#ifdef USE_MAC_FILE_TOOLBOX
+static int find_mac_file(const char *filename, FSSpec *spec, int finddir, int findfile,
+			 int *dealiased, int *wasdir, 
+			 long *filedate, int *flags, 
+			 long *type, unsigned long *size) 
+{
+  WDPBRec  wdrec;
+  CInfoPBRec pbrec;
+  char buf[256];
+  short find_vref;
+  long find_dir_id;
+
+  if (dealiased)
+    *dealiased = 0;
+  if (wasdir)
+    *wasdir = 1;
+  if (flags)
+    *flags = 0;
+  if (type)
+    *type = 0;
+  if (size)
+    *size = 0;
+
+  wdrec.ioNamePtr = (StringPtr)buf;
+  if (PBHGetVol(&wdrec, 0))
+    return 0;
+  
+  find_vref = wdrec.ioWDVRefNum;
+  find_dir_id = wdrec.ioWDDirID;
+  
+  /* filename is NULL => Local directory */
+  if (!*filename) {
+    if (!finddir)
+      return 0;
+  } else {
+    const char *p;
+    int has_colon;
+    
+    for (p = filename; *p && (*p != ':'); p++);
+    has_colon = (*p == ':');
+    
+    p = filename;    
+    if (*p == ':') {
+      p++;
+    } else if (has_colon) {
+      char vbuf[256];
+      int len = 0;
+      HParamBlockRec hrec;
+      /* It's an absolute path: get the Volume Name and vRefNum */
+      while (*p && *p != ':') {
+	vbuf[len++] = *(p++);
+	if (len > 32)
+	  return 0;
+      }
+      vbuf[len] = 0;
+      if (*p)
+	p++;
+      
+      strcat(vbuf, ":");
+      hrec.volumeParam.ioNamePtr = c2pstr(vbuf);
+      hrec.volumeParam.ioVRefNum = 0;
+      hrec.volumeParam.ioVolIndex = -1;
+      if (PBHGetVInfo(&hrec, 0))
+	return 0;
+      find_vref = hrec.volumeParam.ioVRefNum;
+      find_dir_id = 0;
+    }
+    while (p && *p) {
+      const char *next = p;
+      int len = 0;
+      Boolean isFolder, wasAlias;
+      
+      while (*next && *next != ':') {
+	buf[len++] = *(next++);
+	if (len > 32)
+	  return 0;
+      }
+      buf[len] = 0;
+      
+      if (*next)
+	next++;
+      if (!*next)
+	next = NULL;
+      
+      if (len > 32)
+	return 0;
+      
+      if (!len) {
+	/* Parent directory */
+	pbrec.hFileInfo.ioNamePtr = spec->name;
+	pbrec.hFileInfo.ioVRefNum = find_vref;
+	pbrec.hFileInfo.ioDirID = find_dir_id;
+	pbrec.hFileInfo.ioFDirIndex = -1;
+	if (PBGetCatInfo(&pbrec, 0))
+	  return 0;	
+	find_dir_id = pbrec.dirInfo.ioDrParID;
+#ifdef MAC_STUPID_STAT
+	if (dealiased) *dealiased = 1;
+#endif
+	if (!next) {
+	  if (findfile)
+	    return 0;
+	  if (wasdir)
+	    *wasdir = 1;
+	}
+      } else {
+	spec->vRefNum = find_vref;
+	spec->parID = find_dir_id;
+	memcpy((void *)spec->name, buf, len);
+	spec->name[len] = 0;
+	c2pstr((char *)spec->name);
+	
+	pbrec.hFileInfo.ioNamePtr = spec->name;
+	pbrec.hFileInfo.ioVRefNum = spec->vRefNum;
+	pbrec.hFileInfo.ioDirID = spec->parID;
+	pbrec.hFileInfo.ioFDirIndex = 0;
+	if (PBGetCatInfo(&pbrec, 0)) {
+	  if (finddir || findfile || next)
+	    return 0;
+	  if (wasdir)
+	    *wasdir = 0;
+	  break;
+	} else {
+	  /* If it's a file, it could be an alias: */
+	  if (!(pbrec.hFileInfo.ioFlAttrib & 0x10)) {
+	    ResolveAliasFile(spec, 1, &isFolder, &wasAlias);
+	    if (!next && (findfile < 0)) {
+	      return wasAlias ? 1 : 0;
+	    }
+	    if (wasAlias && dealiased)
+	      *dealiased = 1;
+	    
+	    if (wasAlias) {
+	      /* Look it up again: */
+	      find_vref = spec->vRefNum;
+	      find_dir_id = spec->parID;
+	      pbrec.hFileInfo.ioNamePtr = spec->name;
+	      pbrec.hFileInfo.ioVRefNum = spec->vRefNum;
+	      pbrec.hFileInfo.ioDirID = spec->parID;
+	      pbrec.hFileInfo.ioFDirIndex = 0;
+	      if (PBGetCatInfo(&pbrec, 0)) {
+	        if (finddir || findfile || next)
+	          return 0;
+	        if (wasdir)
+	          *wasdir = 0;
+	        break;
+	      }
+	    }
+	  }
+	 
+	  if (!(pbrec.hFileInfo.ioFlAttrib & 0x10)) {
+	    if (finddir || next)
+	      return 0; /* Not a directory */
+	    if (wasdir)
+	      *wasdir = 0;
+	    if (filedate)
+	      *filedate = pbrec.hFileInfo.ioFlMdDat;
+	    if (type)
+	      *type = pbrec.hFileInfo.ioFlFndrInfo.fdType;
+	    if (flags)
+	      *flags = pbrec.hFileInfo.ioFlAttrib;
+	    if (size)
+	      *size = (pbrec.hFileInfo.ioFlLgLen
+		       + pbrec.hFileInfo.ioFlRLgLen);
+	  } else {
+	    if (findfile && !next)
+	      return 0;
+	    find_vref = spec->vRefNum;
+	    find_dir_id = pbrec.hFileInfo.ioDirID;
+	    if (!next && flags)
+	      *flags = pbrec.hFileInfo.ioFlAttrib;
+	  }
+        }  
+      }
+      
+      p = next;
+    }
+  }
+  
+  spec->vRefNum = find_vref;
+  spec->parID = find_dir_id;
+  
+  return 1;
+}
+
+char *scheme_build_mac_filename(FSSpec *spec, int given_dir)
+{
+#define QUICK_BUF_SIZE 256
+
+  CInfoPBRec pbrec;
+  char buf[256], qbuf[QUICK_BUF_SIZE], *s;
+  int i, j, size = 0, alloced = QUICK_BUF_SIZE - 1;
+  int vref = spec->vRefNum;
+  long dirID = spec->parID;
+
+  s = qbuf;
+  if (!given_dir) {
+    for (i = spec->name[0]; i; i--)
+      s[size++] = spec->name[i];
+  }
+
+  while (1)  {
+    pbrec.hFileInfo.ioNamePtr = (unsigned char *)buf;
+    pbrec.hFileInfo.ioVRefNum = vref;
+    pbrec.hFileInfo.ioDirID = dirID;
+    pbrec.hFileInfo.ioFDirIndex = -1;
+	if (PBGetCatInfo(&pbrec, 0))
+	  return NULL;
+	
+	if (size + buf[0] + 1 > alloced) {
+	   char *old;
+	   
+	   alloced *= 2;
+	   old = (char *)scheme_malloc_atomic(alloced + 1);
+	   memcpy(old, s, size);
+	}
+
+    s[size++] = ':';
+    for (i = buf[0]; i; i--)
+      s[size++] = buf[i];
+	  
+	dirID = pbrec.dirInfo.ioDrParID;
+	if (dirID == 1)
+	  break;
+  }
+  
+  if (alloced < QUICK_BUF_SIZE) {
+    s = (char *)scheme_malloc_atomic(size + 1);
+    for (j = 0, i = size; i--; j++)
+      s[j] = qbuf[i];
+  } else {
+  	int save;
+  	
+  	for (i = 0, j = size - 1; i < j; i++, j--) {
+  	  save = s[i];
+  	  s[i] = s[j];
+  	  s[j] = save;
+  	}
+  }
+  
+  s[size] = 0;
+  return s;
+}
+
+void scheme_file_create_hook(char *filename)
+{
+  FSSpec spec;
+    
+  if (find_mac_file(filename, &spec, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL)) {
+    FInfo info;
+
+    FSpGetFInfo(&spec, &info);
+    info.fdCreator = scheme_creator_id;
+    info.fdType = 'TEXT';
+    FSpSetFInfo(&spec, &info);
+  }
+}
+
+int scheme_mac_path_to_spec(const char *filename, FSSpec *spec, long *type)
+{
+  return find_mac_file(filename, spec, 0, 1, NULL, NULL, NULL, NULL, type, NULL);
+}
+#endif
+
+static int has_null(const char *s, long l)
+{
+  while (l--)
+    if (!s[l])
+      return 1;
+
+  return 0;
+}
+
+static void raise_null_error(const char *name, Scheme_Object *path, const char *mod)
+{
+  scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+		   path,
+		   "%s: pathname%s contains a null character: %.255s...", 
+		   name, mod, SCHEME_STR_VAL(path));
+}
+
+#ifdef DOS_FILE_SYSTEM
+static int check_dos_slashslash_drive(const char *next, int len, 
+				      int *drive_end, int exact)
+{
+  int j;
+  int is_drive = 0;
+
+  if (drive_end)
+    *drive_end = len;
+
+  if (IS_A_SEP(next[1])) {
+    /* Check for a drive form: //x/y */
+    for (j = 2; j < len; j++)
+      if (!IS_A_SEP(next[j])) {
+	/* Found non-sep */
+	for (; j < len; j++)
+	  if (IS_A_SEP(next[j])) {
+	    /* Found sep again: */
+	    for (; j < len; j++)
+	      if (!IS_A_SEP(next[j])) {
+		/* Found non-sep again */
+		for (; j < len; j++)
+		  if (IS_A_SEP(next[j])) {
+		    /* Found sep again... */
+		    if (drive_end)
+		      *drive_end = j;
+		    if (exact) {
+		      for (; j < len; j++)
+			if (!IS_A_SEP(next[j])) {
+			  /* Found non-sep again 
+			     - not a drive (it's absolute path) */
+			  break;
+			}
+		    } else
+		      is_drive = 1;
+		    break;
+		  }
+		if (j >= len)
+		  is_drive = 1;
+		break;
+	      }
+	    break;
+	  }
+	break;
+      }
+  }
+
+  return is_drive;
+}
+#endif
+
+static char *do_expand_filename(char* filename, int ilen, char *errorin, 
+				int *expanded,
+				int report_bad_user)
+{
+  if (expanded)
+    *expanded = 0;
+
+  if (ilen < 0)
+    ilen = strlen(filename);
+  else  {
+    if (has_null(filename, ilen)) {
+      if (errorin)
+	raise_null_error(errorin, scheme_make_string(filename), "");
+      else 
+	return NULL;
+    }
+  }
+
+#ifdef EXPAND_FILENAME_TILDE
+  /* User home lookup strategy taken from wxWindows: */
+
+  if (filename[0] == '~') {
+    char user[256], *home = NULL, *naya;
+    struct passwd *who = NULL;
+    int u, f, len, flen;
+    
+    for (u = 0, f = 1; 
+	 u < 255 && filename[f] && filename[f] != '/'; 
+	 u++, f++)
+      user[u] = filename[f];
+
+    if (filename[f] && filename[f] != '/') {
+      if (errorin && report_bad_user)
+	scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH_USERNAME,
+			    scheme_make_string(filename),
+			    "%s: bad username in %.255s", errorin, filename);
+      return NULL;
+    }
+    user[u] = 0;
+
+    if (!user[0]) {
+      if (!(home = getenv("HOME"))) {
+	char *ptr;
+
+	ptr = getenv("USER");
+	if (!ptr)
+	  ptr = getenv("LOGNAME");
+
+	who = ptr ? getpwnam(ptr) : NULL;
+
+	if (!who)
+	  who = getpwuid(getuid());
+      }
+    } else
+      who = getpwnam(user);
+
+    if (!home && who)
+      home = who->pw_dir;
+
+    if (!home) {
+      if (errorin && report_bad_user)
+	scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH_USERNAME,
+			    scheme_make_string(filename),
+			    "%s: bad username in %.255s", errorin, filename);
+      return NULL;
+    }
+
+    len = strlen(home);
+    if (f < ilen) 
+      flen = ilen - f - 1;
+    else
+      flen = 0;
+    naya = (char *)scheme_malloc_atomic(len + flen + 2);
+    memcpy(naya, home, len);
+    naya[len] = '/';
+    memcpy(naya + len + 1, filename + f + 1, flen);
+    naya[len + flen + 1] = 0;
+
+    if (expanded)
+      *expanded = 1;
+  
+    return naya;
+  }
+#endif
+#ifdef DOS_FILE_SYSTEM
+  {
+    int fixit = 0, i;
+
+    /* Clean up the name, removing mulitple // and
+       adding "/" after "c:" if necessary */
+    if (isalpha(filename[0])
+	&& (filename[1] == ':') && !IS_A_SEP(filename[2]))
+      fixit = -1;
+    else {
+      int found_slash = 0;
+
+      for (i = ilen; i-- > 1; ) {
+	if (IS_A_SEP(filename[i])) {
+	  if (IS_A_SEP(filename[i - 1])) {
+	    if ((i > 1) || !found_slash)
+	      fixit = 1;
+	    break;
+	  }
+	  found_slash = 1;
+	}
+      }
+    }
+
+    if (fixit) {
+      int allow_leading, pos;
+      char *naya;
+      
+      if (expanded)
+	*expanded = 1;
+
+      /* Allow // at start? */
+      allow_leading = 0;
+      if (IS_A_SEP(filename[0]) && IS_A_SEP(filename[1])) {
+	for (i = 2; i < ilen; i++)
+	  if (!IS_A_SEP(filename[i])) {
+	    /* Found non-sep */
+	    for (; i < ilen; i++)
+	      if (IS_A_SEP(filename[i])) {
+		/* Found sep */
+		for (; i < ilen; i++)
+		  if (!IS_A_SEP(filename[i])) {
+		    /* Found non-sep; allow leading */
+		    allow_leading = 1;
+		    break;
+		  }
+		break;
+	      }
+	    break;
+	  }
+      }
+
+      pos = i = 0;
+      naya = (char *)scheme_malloc_atomic(ilen + 2);
+
+      if (allow_leading) {
+	naya[0] = filename[0];
+	naya[1] = filename[1];
+	pos = i = 2;
+      } else if (fixit == -1) {
+	naya[0] = filename[0];
+	naya[1] = ':';
+	naya[2] = '\\';
+	pos = 3;
+	i = 2;
+      }
+
+      while (i < ilen) {
+	if (IS_A_SEP(filename[i])
+	    && IS_A_SEP(filename[i + 1])) {
+	  i++;
+	} else
+	  naya[pos++] = filename[i++];
+      }
+
+      naya[pos] = 0;
+      filename = naya;
+      ilen = pos;
+    }
+  }
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+  {
+    FSSpec spec;
+    int dealiased, wasdir;
+    
+    if (find_mac_file(filename, &spec, 0, 0, &dealiased, &wasdir, NULL, NULL, NULL, NULL))
+      if (dealiased) {
+        char *s;
+        s = scheme_build_mac_filename(&spec, wasdir);
+	if (s) {
+	  if (expanded)
+	    *expanded = 1;
+	  return s;
+        }
+    }
+  }
+#endif
+
+  return filename;
+}
+
+char *scheme_expand_filename(char* filename, int ilen, char *errorin, int *expanded)
+{
+  return do_expand_filename(filename, ilen, errorin, expanded, 1);
+}
+
+int scheme_file_exists(char *filename)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+  
+  if (!find_mac_file(filename, &spec, 0, 1, NULL, NULL, NULL, NULL, NULL, NULL))
+    return 0;
+  return 1;
+
+#else
+#ifdef NO_STAT_PROC
+  FILE *fp;
+
+  fp = fopen(filename, "r");
+  if (fp) {
+    fclose(fp);
+    return 1;
+  } else
+    return 0;
+#else
+  struct MSC_IZE(stat) buf;
+
+  return !MSC_IZE(stat)(filename, &buf) && !S_ISDIR(buf.st_mode);
+#endif
+#endif
+}
+
+
+#ifdef DOS_FILE_SYSTEM
+static int UNC_dir_exists(char *dirname, int len, int *flags)
+{
+  char *copy;
+  struct _finddata_t fd;
+  long fh;
+  
+  copy = scheme_malloc_atomic(len + 10);
+  memcpy(copy, dirname, len);
+  if (!IS_A_SEP(copy[len - 1])) {
+    copy[len] = '\\';
+    len++;
+  }
+  memcpy(copy + len, "*.*", 4);
+  fh = _findfirst(copy, &fd);
+  if (fh < 0)
+    return 0;
+  else {
+    if (flags)
+      *flags = fd.attrib;
+    _findclose(fh);
+    return 1;
+  }
+}
+#endif
+
+int scheme_directory_exists(char *dirname)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+  
+  if (!find_mac_file(dirname, &spec, 1, 0, NULL, NULL, NULL, NULL, NULL, NULL))
+    return 0;
+
+  return 1;
+#else
+#ifdef NO_STAT_PROC
+  return 0;
+#else
+  struct MSC_IZE(stat) buf;
+  int v;
+
+#ifdef DOS_FILE_SYSTEM
+  int strip_end, strip_char, len;
+
+  len = strlen(dirname);
+
+  if ((len > 1) && IS_A_SEP(dirname[0]) && check_dos_slashslash_drive(dirname, len, NULL, 1)) {
+    /* stat doesn't work with UNC "drive" names */
+    return UNC_dir_exists(dirname, len, NULL);
+  } else if ((len > 1) && (dirname[len - 1] == '\\' || dirname[len - 1] == '/')
+	     && (dirname[len - 2] != ':')) {
+    strip_end = len - 1;
+    strip_char = dirname[strip_end];
+    dirname[strip_end] = 0;
+  } else
+    strip_end = strip_char = 0;
+#endif
+
+  v = !MSC_IZE(stat)(dirname, &buf) && S_ISDIR(buf.st_mode);
+  
+#ifdef DOS_FILE_SYSTEM
+  if (strip_end)
+    dirname[strip_end] = strip_char;
+#endif
+  
+  return v;
+#endif
+#endif
+}
+
+int scheme_is_regular_file(char *filename)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+  return 1;
+#else
+#ifdef NO_STAT_PROC
+  return 0;
+#else
+  struct MSC_IZE(stat) buf;
+
+  return !MSC_IZE(stat)(filename, &buf) && S_ISREG(buf.st_mode);
+#endif  
+#endif
+}
+
+static Scheme_Object *file_exists(int argc, Scheme_Object **argv)
+{
+  char *f;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("file-exists?", "string", 0, argc, argv);
+
+  f = do_expand_filename(SCHEME_STR_VAL(argv[0]),
+			 SCHEME_STRTAG_VAL(argv[0]),
+			 "file-exists?",
+			 NULL,
+			 0);
+
+  return (f && scheme_file_exists(f)) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *directory_exists(int argc, Scheme_Object **argv)
+{
+  char *f;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("directory-exists?", "string", 0, argc, argv);
+
+  f = do_expand_filename(SCHEME_STR_VAL(argv[0]),
+			 SCHEME_STRTAG_VAL(argv[0]),
+			 "directory-exists?",
+			 NULL,
+			 0);
+
+  return (f && scheme_directory_exists(f)) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *link_exists(int argc, Scheme_Object **argv)
+{
+  char *filename;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("link-exists?", "string", 0, argc, argv);
+
+  filename = SCHEME_STR_VAL(argv[0]);
+
+#ifndef UNIX_FILE_SYSTEM
+  if (has_null(filename, SCHEME_STRTAG_VAL(argv[0]))) {
+    raise_null_error("link-exists?", scheme_make_string(filename), "");
+    return NULL;
+  }
+#endif
+
+#ifdef DOS_FILE_SYSTEM
+  return scheme_false;
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+  {
+    FSSpec spec;
+  
+    if (!find_mac_file(filename, &spec, 0, -1, NULL, NULL, NULL, NULL, NULL, NULL))
+      return scheme_false;
+
+    return scheme_true;
+  }
+#endif
+#ifdef UNIX_FILE_SYSTEM
+  {
+    struct MSC_IZE(stat) buf;
+
+    filename = do_expand_filename(filename,
+				  SCHEME_STRTAG_VAL(argv[0]),
+				  "link-exists?",
+				  NULL,
+				  0);
+
+    if (!MSC_IZE(lstat)(filename, &buf) && S_ISLNK(buf.st_mode))
+      return scheme_true;
+    else
+      return scheme_false;
+  }
+#endif
+}
+
+#ifndef NO_FILE_SYSTEM_UTILS
+
+static Scheme_Object *delete_file(int argc, Scheme_Object **argv)
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("delete-file", "string", 0, argc, argv);
+
+  if (!MSC_IZE(unlink)(scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+					      SCHEME_STRTAG_VAL(argv[0]),
+					      "delete-file",
+					      NULL)))
+    return scheme_true;
+  else
+    return scheme_false;
+}
+
+static Scheme_Object *rename_file(int argc, Scheme_Object **argv)
+{
+  char *src, *dest;
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec srcspec, destspec;
+  int swas_dir, dwas_dir;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("rename-file", "string", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type("rename-file", "string", 1, argc, argv);
+
+  src = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+			       SCHEME_STRTAG_VAL(argv[0]),
+			       "rename-file",
+			       NULL);
+  dest = scheme_expand_filename(SCHEME_STR_VAL(argv[1]),
+				SCHEME_STRTAG_VAL(argv[1]),
+				"rename-file",
+				NULL);
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (find_mac_file(src, &srcspec, 0, 0, NULL, &swas_dir, NULL, NULL, NULL, NULL)) {
+    if (find_mac_file(dest, &destspec, 0, 0, NULL, &dwas_dir, NULL, NULL, NULL, NULL)) {
+      /* Directory already exists or different volumes => failure */
+      if (!dwas_dir && (srcspec.vRefNum == destspec.vRefNum)) {
+        int rename;
+        
+        if (swas_dir) {
+          /* Get name of directory to be moved: */
+          CInfoPBRec pb;
+          
+          pb.hFileInfo.ioNamePtr = srcspec.name;
+          pb.hFileInfo.ioVRefNum = srcspec.vRefNum;
+          pb.hFileInfo.ioFDirIndex = -1;
+          pb.hFileInfo.ioDirID = srcspec.parID;
+          if (PBGetCatInfo(&pb, 0))
+            return scheme_false;
+            
+          srcspec.parID = pb.hFileInfo.ioDirID;
+        }
+        
+        rename = ((destspec.name[0] != srcspec.name[0])
+                  || memcmp(destspec.name, srcspec.name, destspec.name[0] + 1));
+        
+        if (srcspec.parID != destspec.parID) {
+          CMovePBRec mv;
+          mv.ioNamePtr = srcspec.name;
+          mv.ioVRefNum = srcspec.vRefNum;
+          mv.ioDirID = srcspec.parID;
+          mv.ioNewName = NULL;
+          mv.ioNewDirID = destspec.parID;
+          if (PBCatMove(&mv, 0))
+            return scheme_false;
+        }
+        
+        if (rename) {
+          srcspec.parID = destspec.parID;
+          if (FSpRename(&srcspec, destspec.name))
+            return scheme_false;
+      	}
+      	
+        return scheme_true;
+      }
+    }
+  }
+  
+  return scheme_false;
+#else
+  if (!rename(src, dest))
+    return scheme_true;
+  else
+    return scheme_false;
+#endif
+}
+
+static Scheme_Object *copy_file(int argc, Scheme_Object **argv)
+{
+  char *src, *dest;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("copy-file", "string", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type("copy-file", "string", 1, argc, argv);
+
+  src = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+			       SCHEME_STRTAG_VAL(argv[0]),
+			       "copy-file",
+			       NULL);
+  dest = scheme_expand_filename(SCHEME_STR_VAL(argv[1]),
+				SCHEME_STRTAG_VAL(argv[1]),
+				"copy-file",
+				NULL);
+
+#ifdef UNIX_FILE_SYSTEM
+  {
+# define COPY_BUFFER_SIZE 2048
+    FILE *s, *d;
+    char b[COPY_BUFFER_SIZE];
+    long len;
+    int ok;
+    struct stat buf;
+
+    if (stat(src, &buf) || S_ISDIR(buf.st_mode))
+      return scheme_false;
+
+    if (!stat(dest, &buf))
+      return scheme_false;
+
+    s = fopen(src, "rb");
+    if (!s)
+      return scheme_false;
+
+    d = fopen(dest, "wb");
+    if (!d) {
+      fclose(s);
+      return scheme_false;
+    }
+    
+    ok = 1;
+    while ((len = fread(b, 1, COPY_BUFFER_SIZE, s))) {
+      if (fwrite(b, 1, len, d) != len) {
+	ok = 0;
+	break;
+      }
+    }
+    if (!feof(s))
+      ok = 0;
+
+    fclose(s);
+    fclose(d);
+
+    if (ok) {
+      if (chmod(dest, buf.st_mode))
+	return scheme_false;
+      return scheme_true;
+    } else
+      return scheme_false;
+  }
+#endif
+#ifdef DOS_FILE_SYSTEM
+  return CopyFile(src, dest, TRUE) ? scheme_true : scheme_false;
+#endif
+
+  return scheme_false;
+}
+
+Scheme_Object *scheme_build_pathname(int argc, Scheme_Object **argv)
+{
+#define PN_BUF_LEN 256
+  int pos, i, len, no_sep;
+  int alloc = PN_BUF_LEN;
+  char buffer[PN_BUF_LEN], *str, *next;
+  int rel;
+#ifdef MAC_FILE_SYSTEM
+  int prev_no_sep;
+#endif
+#ifdef DOS_FILE_SYSTEM
+  int first_was_drive = 0;
+#endif
+
+  str = buffer;
+  pos = 0;
+
+  no_sep = 0; /* This is acutally initialized after we know whether
+		 it's relative or not. */
+  
+  for (i = 0 ; i < argc; i++) {
+    if (SCHEME_STRINGP(argv[i])
+	|| (SCHEME_SYMBOLP(argv[i]) 
+	    && (SAME_OBJ(argv[i], up_symbol)
+		|| SAME_OBJ(argv[i], same_symbol)))) {
+      if (SAME_OBJ(argv[i], up_symbol)) {
+#ifdef UNIX_FILE_SYSTEM
+	next = "..";
+	len = 2;
+#endif
+#ifdef DOS_FILE_SYSTEM
+	next = "..";
+	len = 2;
+#endif
+#ifdef MAC_FILE_SYSTEM
+	next = "";
+	len = 0;
+#endif
+      } else if (SAME_OBJ(argv[i], same_symbol)) {
+#ifdef UNIX_FILE_SYSTEM
+	next = ".";
+	len = 1;
+#endif
+#ifdef DOS_FILE_SYSTEM
+	next = ".";
+	len = 1;
+#endif
+#ifdef MAC_FILE_SYSTEM
+	next = "";
+	len = 0;
+#endif
+      } else {
+	next = SCHEME_STR_VAL(argv[i]);
+	len = SCHEME_STRTAG_VAL(argv[i]);
+#ifdef MAC_FILE_SYSTEM
+	/* ":" is not a legal particle */
+	if ((len == 1) && (next[0] == ':'))
+	  len = 0;
+#endif	
+	if (!len) {
+	  scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+			   scheme_make_string(next),
+			   "build-path: %d%s pathname element is an empty string%s", 
+			   i + 1,
+			   scheme_number_suffix(i + 1),
+			   scheme_make_args_string("other ", i, argc, argv)); 
+	  return scheme_false;
+	}
+
+	if (has_null(next, len)) {
+	  raise_null_error("build-path", argv[i], " element");
+	  return NULL;
+	}
+      }
+
+      /* +3: null term, leading sep, and trailing sep (if up & Mac) */
+      if (pos + len + 3 >= alloc) {
+	char *naya;
+	int newalloc;
+
+	newalloc = 2 * alloc + len + 1;
+	naya = (char *)scheme_malloc_atomic(newalloc);
+	memcpy(naya, str, pos);
+	
+	str = naya;
+      }
+
+#ifdef UNIX_FILE_SYSTEM
+      if (next[0] == '/') {
+	rel = 0;
+	if (i) {
+	  scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+			      scheme_make_string(next),
+			      "build-path: absolute path \"%.255s\" cannot be"
+			      " added to a pathname",
+			   next);
+	  return scheme_false;
+	}
+      } else
+	rel = 1;
+#endif
+#ifdef DOS_FILE_SYSTEM
+      {
+	int is_drive;
+
+	if (IS_A_SEP(next[0])) {
+	  rel = 0;
+	  is_drive = check_dos_slashslash_drive(next, len, NULL, 1);
+	} else if ((len >= 2) 
+		   && isalpha(next[0])
+		   && (next[1] == ':')) {
+	  int j;
+	  rel = 0;
+	  for (j = 2; j < len; j++)
+	    if (!IS_A_SEP(next[j]))
+	      break;
+	  is_drive = (j >= len);
+	} else {
+	  rel = 1;
+	  is_drive = 0;
+	}
+
+	if (!rel) {
+	  if (i && (!first_was_drive || (i > 1) || is_drive)) {
+	    if (pos > 30) {
+	      str[27] = '.';
+	      str[28] = '.';
+	      str[29] = '.';
+	      str[30] = 0;
+	    } else
+	      str[pos] = 0;
+	    scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+			     scheme_make_string(next),
+			     "build-path: %s \"%s\" cannot be"
+			     " added to the pathname \"%.255s\"",
+			     is_drive ? "drive" : "absolute path",
+			     next, str);
+	    return scheme_false;
+	  }
+
+	  if (i == 1) {
+	    /* Absolute path onto a drive: skip separator(s) */
+	    while (len && IS_A_SEP(next[0])) {
+	      next++;
+	      len--;
+	    }
+	  }
+	}
+
+	if (!i)
+	  first_was_drive = is_drive;
+      }
+#endif
+#ifdef MAC_FILE_SYSTEM
+      /* If we're appending a relative path, strip leading sep; otherwise,
+         check for embedded colons */
+      if (next[0] == FN_SEP) {
+	rel = 1;
+	if (i) {
+	  next++;
+	  --len;
+	}
+      } else {
+	/* Except for first, ignore a colon at the end. */
+	int last = i ? len - 1 : len, j;
+	rel = 1;
+	for (j = 0; j < last; j++)
+	  if (next[j] == ':') {
+	    if (i) {
+	      scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+			       scheme_make_string(next),
+			       "build-path: absolute path \"%.255s\" cannot be"
+			       " added to a pathname",
+			       next);
+	      return scheme_false;
+	    } else {
+	      rel = 0;
+	      break;
+	    }
+	  }
+      }
+#endif
+
+      if (!i) {
+#ifdef MAC_FILE_SYSTEM
+	no_sep = !rel || (next[0] == ':');
+#else
+	no_sep = 1;
+#endif
+      }
+      
+#ifdef MAC_FILE_SYSTEM
+      if (SAME_OBJ(argv[i], same_symbol)) {
+	prev_no_sep = no_sep;
+	no_sep = 1;
+      }
+#endif
+
+      if (!no_sep)
+	str[pos++] = FN_SEP;
+
+      memcpy(str + pos, next, len);
+      pos += len;
+
+      /* If last path elem ends in a separator, don't add one: */
+      if (len) {
+	no_sep = IS_A_SEP(next[len - 1]);
+#ifdef MAC_FILE_SYSTEM
+	if (!len)
+	  no_sep = 0;
+#endif
+      } else {
+#ifdef MAC_FILE_SYSTEM
+	if (SAME_OBJ(argv[i], same_symbol))
+	  no_sep = prev_no_sep;
+	else
+	  no_sep = 0;
+#else
+	no_sep = 0;
+#endif
+      }
+    } else {
+      scheme_wrong_type("build-path", "string or 'up or 'same", i, argc, argv);
+      return scheme_false;
+    }
+  }
+
+#ifdef MAC_FILE_SYSTEM
+  if (argc && SAME_OBJ(argv[argc - 1], up_symbol))
+    str[pos++] = ':';
+#endif
+
+  str[pos] = 0;
+
+  return scheme_make_sized_string(str, pos, alloc == PN_BUF_LEN);
+}
+
+Scheme_Object *scheme_split_pathname(int argc, Scheme_Object **argv)
+{
+  char *s;
+  int p, len, last_was_sep = 0, is_dir;
+  Scheme_Object *file, *three[3], *inpath;
+#ifdef DOS_FILE_SYSTEM
+  int allow_double_before, drive_end;
+#endif
+
+  inpath = argv[0];
+
+  if (!SCHEME_STRINGP(inpath))
+    scheme_wrong_type("split-path", "string", 0, argc, argv);
+
+  s = SCHEME_STR_VAL(inpath);
+  len = SCHEME_STRTAG_VAL(inpath);
+
+  if (!len) {
+    scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+		     inpath, "split-path: pathname is an empty string");
+  }
+
+  if (has_null(s, len))
+    raise_null_error("split-path", inpath, "");
+
+#ifdef DOS_FILE_SYSTEM
+  allow_double_before = 0;
+  if ((len > 2) && IS_A_SEP(s[0]) && IS_A_SEP(s[1])) {
+    if (check_dos_slashslash_drive(s, len, &drive_end, 0))
+      allow_double_before = 1;
+    else
+      drive_end = 0;
+  } else if ((len > 1) && isalpha(s[0]) && (s[1] == ':'))
+    drive_end = 2;
+  else
+    drive_end = 0;
+
+  if (drive_end && IS_A_SEP(s[drive_end]))
+    drive_end++;
+#endif
+
+#ifndef MAC_FILE_SYSTEM
+#ifdef DOS_FILE_SYSTEM
+# define ALLOW_DOUBLE_BEFORE allow_double_before
+#else
+# define ALLOW_DOUBLE_BEFORE 0
+#endif
+  /* Look for confusing repeated separators (e.g. "x//y") */
+  for (p = len; p--; ) {
+    if (p > ALLOW_DOUBLE_BEFORE) {
+      if (IS_A_SEP(s[p]) && IS_A_SEP(s[p - 1])) {
+	/* Found it; copy without repeats */
+	int q;
+	char *old = s;
+
+	s = (char *)scheme_malloc_atomic(len);
+	--len;
+
+	for (p = 0, q = 0; p < ALLOW_DOUBLE_BEFORE; p++)
+	  s[q++] = old[p];
+
+	for (; p < len; p++) {
+	  if (!IS_A_SEP(old[p]) || !IS_A_SEP(old[p + 1]))
+	    s[q++] = old[p];
+	}
+	s[q++] = old[len];
+	len = q;
+	break;
+      }
+    }
+  }
+#endif
+
+#ifdef DOS_FILE_SYSTEM
+  if (len <= drive_end)
+    p = -1;
+  else
+#endif
+    {
+      for (p = len; p--; ) {
+	if (IS_A_SEP(s[p])) {
+	  if (p != len - 1)
+	    break;
+	  else
+	    last_was_sep = 1;
+	}
+#ifdef DOS_FILE_SYSTEM
+	if (p < drive_end)
+	  break;
+#endif
+      }
+    }
+
+#define MAKE_SPLIT(x, y, z) \
+  (three[0] = x, three[1] = y, three[2] = z ? scheme_true : scheme_false, \
+   scheme_values(3, three))
+
+  if (p < 0) {
+    Scheme_Object *dir;
+
+    /* No splitting available. 
+       For Unx & DOS, it was relative or exactly root.
+       For Mac, it is relative or root with trailing sep. */
+#ifdef UNIX_FILE_SYSTEM
+    if (s[0] == '/')
+      return MAKE_SPLIT(scheme_false, scheme_make_sized_string(s, len, 1), 1);
+#endif
+#ifdef DOS_FILE_SYSTEM
+    if (IS_A_SEP(s[0]) || drive_end)
+      return MAKE_SPLIT(scheme_false, scheme_make_sized_string(s, len, 1), 1);
+#endif
+
+#ifdef MAC_FILE_SYSTEM
+    dir = last_was_sep ? scheme_false : relative_symbol;
+#else
+    dir = relative_symbol;
+#endif
+
+  /* Check for 'up: */
+#ifndef MAC_FILE_SYSTEM
+  if ((s[0] == '.') && (s[1] == '.')
+      && (2 >= len || IS_A_SEP(s[2])))
+    {
+      file = up_symbol;
+      is_dir = 1;
+    } 
+  else if ((s[0] == '.') && (1 >= len || IS_A_SEP(s[1])))
+    {
+      file = same_symbol;
+      is_dir = 1;
+    } 
+  else
+#endif
+    {
+      file = scheme_make_sized_string(s, len - last_was_sep, 1);
+      is_dir = last_was_sep;
+    }
+
+    return MAKE_SPLIT(dir, file, is_dir);
+  }
+		 
+  /* Check for 'up and 'same: */
+#if defined(UNIX_FILE_SYSTEM) || defined(DOS_FILE_SYSTEM)
+  if ((s[p + 1] == '.') && (s[p + 2] == '.')
+      && (p + 3 >= len || IS_A_SEP(s[p + 3])))
+#endif
+#ifdef MAC_FILE_SYSTEM
+  if ((p == len - 2) && s[p + 1] == ':')
+#endif  
+    {
+      file = up_symbol;
+      is_dir = 1;
+    } 
+#ifndef MAC_FILE_SYSTEM
+  else if ((s[p + 1] == '.') && (p + 2 >= len || IS_A_SEP(s[p + 2])))
+    {
+      file = same_symbol;
+      is_dir = 1;
+    }
+#endif
+  else 
+    {
+      file = scheme_make_sized_string(s + p + 1, 
+				      len - p -last_was_sep-1, 
+				      1);
+      is_dir = last_was_sep;
+    }
+
+  /* Check directory */
+  if (p > 0)
+    return MAKE_SPLIT(scheme_make_sized_string(s, p + 1, 1), 
+		      file, 
+		      is_dir);
+	
+  /* p = 0; for Unix & Dos, this means root dir. For Mac, this means
+     it was relative. */
+#ifdef MAC_FILE_SYSTEM
+  return MAKE_SPLIT(relative_symbol, file, is_dir);
+#else
+  return MAKE_SPLIT(scheme_make_sized_string(s, 1, 1), file, is_dir);
+#endif  
+}
+
+int scheme_is_relative_path(const char *s, long len)
+{
+#ifdef MAC_FILE_SYSTEM
+  int i;
+#endif
+
+  if (!len)
+    return 0;
+
+#ifdef UNIX_FILE_SYSTEM
+  return !((s[0] == '/') || (s[0] == '~'));
+#endif
+#ifdef DOS_FILE_SYSTEM
+  if (IS_A_SEP(s[0])
+      || ((len >= 2) 
+	  && isalpha(s[0])
+	  && (s[1] == ':')))
+    return 0;
+  else
+    return 1;
+#endif
+#ifdef MAC_FILE_SYSTEM
+  if (s[0] != ':')
+    for (i = 1; i < len; i++)
+      if (s[i] == ':')
+	return 0;
+
+  return 1;
+#endif
+}
+
+static Scheme_Object *relative_pathname_p(int argc, Scheme_Object **argv)
+{
+  char *s;
+  int len;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("relative-path?", "string", 0, argc, argv);
+
+  s = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  if (has_null(s, len))
+    return scheme_false;
+
+  return (scheme_is_relative_path(s, len)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+int scheme_is_complete_path(const char *s, long len)
+{
+  if (!len)
+    return 0;
+
+  if (!scheme_is_relative_path(s, len)) {
+#ifdef DOS_FILE_SYSTEM
+    if (IS_A_SEP(s[0]) && IS_A_SEP(s[1])) {
+      if (check_dos_slashslash_drive(s, len, NULL, 0))
+	return 1;
+      else
+	return 0;
+    } else if ((len >= 2) 
+	       && isalpha(s[0])
+	       && (s[1] == ':')) {
+      return 1;
+    } else
+      return 0;
+#else
+    return 1;
+#endif
+  } else 
+    return 0;
+}
+
+static Scheme_Object *path_to_complete_path(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *p, *wrt;
+  char *s;
+  int len;
+
+  p = argv[0];
+  if (!SCHEME_STRINGP(p))
+    scheme_wrong_type("path->complete-path", "string", 0, argc, argv);
+  if (argc > 1) {
+    wrt = argv[1];
+    if (!SCHEME_STRINGP(wrt))
+      scheme_wrong_type("path->complete-path", "string", 1, argc, argv);
+  } else
+    wrt = NULL;
+
+  s = SCHEME_STR_VAL(p);
+  len = SCHEME_STRTAG_VAL(p);
+
+  if (has_null(s, len))
+    raise_null_error("path->complete-path", p, "");
+  if (wrt) {
+    char *s;
+    int len;
+
+    s = SCHEME_STR_VAL(wrt);
+    len = SCHEME_STRTAG_VAL(wrt);
+    
+    if (has_null(s, len))
+      raise_null_error("path->complete-path", p, "");
+
+    if (!scheme_is_complete_path(s, len))
+      scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+		       wrt,
+		       "path->complete-path: second argument is not a complete path: \"%.255s\"",
+		       s);
+  }
+
+  if (!scheme_is_complete_path(s, len)) {
+    Scheme_Object *args[2];
+
+#ifdef DOS_FILE_SYSTEM
+    if (!scheme_is_relative_path(s, len)) {
+      /* Get just the drive: */
+      if (wrt) {
+        char *s;
+        int len;
+      
+        s = SCHEME_STR_VAL(wrt);
+        len = SCHEME_STRTAG_VAL(wrt);
+        if (s[1] == ':') {
+	  wrt = scheme_make_sized_string(s, 2, 0);
+        } else {
+	  int i;
+
+	  /* Skip first slashes: */
+	  for (i = 0; IS_A_SEP(s[i]); i++);
+	  /* Find next slash: */
+	  for (; !IS_A_SEP(s[i]); i++);
+	  /* Skip these slashes: */
+	  for (; IS_A_SEP(s[i]); i++);
+	  /* Find next slash or end-of-string: */
+	  for (; s[i] && !IS_A_SEP(s[i]); i++);
+	
+	  wrt = scheme_make_sized_string(s, i, 0);
+	}
+      } else {
+	char d[4];
+
+        d[0] = get_cur_drive_id();
+        d[1] = ':';
+        d[2] = 0;
+
+        wrt = scheme_make_sized_string(d, 2, 1);
+      }
+    }
+#endif
+
+    if (!wrt) {
+      char *d = scheme_getcwd(NULL, 0, NULL, 0);
+      wrt = scheme_make_string(d);
+    }
+
+    args[0] = wrt;
+    args[1] = p;
+    return scheme_build_pathname(2, args);
+  } else
+    return p;
+}
+
+
+static Scheme_Object *complete_pathname_p(int argc, Scheme_Object **argv)
+{
+  char *s;
+  int len;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("complete-path?", "string", 0, argc, argv);
+
+  s = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  if (has_null(s, len))
+    return scheme_false;
+
+  return (scheme_is_complete_path(s, len)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *absolute_pathname_p(int argc, Scheme_Object **argv)
+{
+  char *s;
+  int len;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("absolute-path?", "string", 0, argc, argv);
+
+  s = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  if (!len || has_null(s, len))
+    return scheme_false;
+
+  return (!scheme_is_relative_path(s, len)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *resolve_path(int argc, Scheme_Object *argv[])
+{
+#ifndef NO_READLINK
+#define SL_NAME_MAX 2048
+  char buffer[SL_NAME_MAX];
+#endif
+#ifndef NO_READLINK
+  long len;
+  int copied = 0;
+#endif
+  char *filename;
+  int expanded;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("resolve-path", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "resolve-path",
+				    &expanded);
+
+#ifndef NO_READLINK
+  /* Make sure pathname doesn't have trailing separator: */
+  len = strlen(filename);
+  while (len && IS_A_SEP(filename[len - 1])) {
+    if (!expanded && !copied) {
+      filename = scheme_strdup(filename);
+      copied = 1;
+    }
+    filename[--len] = 0;
+  }
+
+  if ((len = readlink(filename, buffer, SL_NAME_MAX)) > 0)
+    return scheme_make_sized_string(buffer, len, 1);
+#endif
+
+  if (!expanded)
+    return argv[0];
+  else
+    return scheme_make_sized_string(filename, strlen(filename), 1);
+}
+
+#ifdef DOS_FILE_SYSTEM
+static char get_cur_drive_id(void)
+{
+#ifdef USE_GETDRIVE
+  char cwd[1];
+  int drive = _getdrive();
+  cwd[0] = 'a' + (drive -1);
+#else
+  char buffer[256], *cwd;
+  
+  if (!(cwd = scheme_getcwd(buffer, 256, NULL, 0)))
+    return 'c';
+#endif
+  return cwd[0];
+}
+#endif
+
+char *scheme_getdrive()
+{
+#ifdef DOS_FILE_SYSTEM
+  char *drive = MALLOC_N(char, 4);
+
+  drive[0] = get_cur_drive_id();
+  drive[1] = ':';
+  drive[2] = '\\';
+  drive[3] = 0;
+
+  return drive;
+#else
+  return "";
+#endif
+}
+
+static Scheme_Object *current_drive(int argc, Scheme_Object *argv[])
+{
+#ifdef DOS_FILE_SYSTEM
+  char *drive = scheme_getdrive();
+
+  return scheme_make_sized_string(drive, strlen(drive), 0);
+#else
+  return scheme_false;
+#endif
+}
+
+static Scheme_Object *expand_path(int argc, Scheme_Object *argv[])
+{
+  char *filename;
+  int expanded;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("expand-path", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "expand-path",
+				    &expanded);
+
+#if 0
+  /* Don't prefix a drive anymore. */
+#ifdef DOS_FILE_SYSTEM
+#ifdef DIR_FUNCTION
+  if (IS_A_SEP(filename[0]) && !IS_A_SEP(filename[1])) {
+    /* Put a drive on the filename: */
+    int len;
+    char *old = filename;
+    
+    len = strlen(filename);
+    filename = (char *)scheme_malloc_atomic(len + 4);
+    memcpy(filename + 2, old, len + 1);
+    filename[0] = get_cur_drive_id();
+    filename[1] = ':';
+    filename[2] = '\\';
+    
+    expanded = 1;
+  }
+#endif
+#endif
+#endif
+
+  if (!expanded)
+    return argv[0];
+  else
+    return scheme_make_sized_string(filename, strlen(filename), 1);
+}
+
+char *scheme_normal_path_case(char *si, int len)
+{
+#ifndef UNIX_FILE_SYSTEM
+  int i;
+  char *s;
+
+  s = MALLOC_N_ATOMIC(char, len + 1);
+  memcpy(s, si, len + 1);
+
+  for (i = 0; i < len; i++) {
+    s[i] = tolower(s[i]);
+#ifdef DOS_FILE_SYSTEM
+    if (s[i] == '/')
+      s[i] = '\\';
+#endif
+  }
+
+  return s;
+#else
+  return si;
+#endif
+}
+
+static Scheme_Object *normal_path_case(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("normal-case-path", "string", 0, argc, argv);
+
+#ifdef UNIX_FILE_SYSTEM
+  return argv[0];
+#else
+  {
+    int len = SCHEME_STRTAG_VAL(argv[0]);
+    return scheme_make_sized_string(scheme_normal_path_case(SCHEME_STR_VAL(argv[0]), 
+							    len), len, 0);
+  }
+#endif
+}
+
+static Scheme_Object *directory_list(int argc, Scheme_Object *argv[])
+{
+#if !defined(NO_READDIR) || defined(USE_MAC_FILE_TOOLBOX) || defined(USE_FINDFIRST)
+  char *filename;
+  Scheme_Object *first = scheme_null, *last = NULL, *n, *elem;
+#endif
+#ifndef NO_READDIR
+  DIR *dir;
+  int nlen;
+  struct dirent *e;
+#endif
+#ifdef USE_FINDFIRST
+  char *pattern;
+  int len;
+  long hfile;
+  struct _finddata_t info;
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+  CInfoPBRec pbrec;
+  char buf[256];
+  FSSpec dir;
+  short find_position = 0;
+#else
+  int counter = 0;
+#endif
+
+  if (argc && !SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("directory-list", "string", 0, argc, argv);
+
+#if defined(NO_READDIR) && !defined(USE_MAC_FILE_TOOLBOX) && !defined(USE_FINDFIRST)
+  return scheme_null;
+#else
+
+  if (argc)
+    filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				      SCHEME_STRTAG_VAL(argv[0]),
+				      "directory-list",
+				      NULL);
+  else
+    filename = NULL;
+
+  if (filename && !scheme_directory_exists(filename))
+    scheme_raise_exn(MZEXN_I_O_FILESYSTEM_DIRECTORY,
+		     scheme_make_string(filename),
+		     "directory-list: could not open \"%.255s\"",
+		     filename);
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (!filename)
+    filename = "";
+  if (!find_mac_file(filename, &dir, 1, 0, NULL, NULL, NULL, NULL, NULL, NULL))
+    return scheme_null;
+  
+  while (1) {
+    pbrec.hFileInfo.ioVRefNum = dir.vRefNum;
+    pbrec.hFileInfo.ioDirID = dir.parID;
+    pbrec.hFileInfo.ioFDirIndex = find_position + 1;
+    pbrec.hFileInfo.ioNamePtr = (unsigned char *)buf;
+    if (PBGetCatInfo(&pbrec, 0) || !*buf)
+      break;
+    
+    find_position++;
+
+    if (!(find_position & 0x15))
+      scheme_process_block(0);
+    
+    n = scheme_make_sized_string(buf + 1, buf[0], 1);
+    elem = scheme_make_pair(n, scheme_null);
+    if (last)
+      SCHEME_CDR(last) = elem;
+    else
+      first = elem;
+    last = elem;
+  }
+  
+  return first;
+#else
+#ifdef USE_FINDFIRST
+
+  if (!filename)
+    pattern = "*.*";
+  else {
+    len = strlen(filename);
+    pattern = (char *)scheme_malloc_atomic(len + 5);
+    memcpy(pattern, filename, len);
+    if (len && !IS_A_SEP(pattern[len - 1]))
+      pattern[len++] = '\\';      
+    memcpy(pattern + len, "*.*", 4);
+  }
+
+  if ((hfile = _findfirst(pattern, &info)) < 0)
+    return scheme_null;
+
+  do {
+    if ((info.name[0] == '.')
+	&& (!info.name[1] || ((info.name[1] == '.')
+			      && !info.name[2]))) {
+      /* skip . and .. */
+    } else {
+      n = scheme_make_string(info.name);
+      elem = scheme_make_pair(n, scheme_null);
+      if (last)
+	SCHEME_CDR(last) = elem;
+      else
+	first = elem;
+      last = elem;
+    }
+    counter++;
+    if (!(counter & 0x15))
+      scheme_process_block(0);
+  } while (!_findnext(hfile, &info));
+  _findclose(hfile);
+
+  return first;
+#else
+  
+  dir = opendir(filename ? filename : ".");
+  if (!dir)
+    return scheme_null;
+  
+  while ((e = readdir(dir))) {
+#ifdef DIRENT_NO_NAMLEN
+    nlen = strlen(e->d_name);
+#else
+    nlen = e->d_namlen;
+#endif
+#if defined(UNIX_FILE_SYSTEM) || defined(DOS_FILE_SYSTEM)
+    if (nlen == 1 && e->d_name[0] == '.')
+      continue;
+    if (nlen == 2 && e->d_name[0] == '.' && e->d_name[1] == '.')
+      continue;
+#endif
+    n = scheme_make_sized_string(e->d_name, nlen, 1);
+    elem = scheme_make_pair(n, scheme_null);
+    if (last)
+      SCHEME_CDR(last) = elem;
+    else
+      first = elem;
+    last = elem;
+
+    counter++;
+    if (!(counter & 0x15))
+      scheme_process_block(0);
+  }
+  
+  closedir(dir);
+
+  return first;
+#endif
+#endif
+#endif
+}
+
+static Scheme_Object *filesystem_root_list(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *first = scheme_null;
+#if defined(DOS_FILE_SYSTEM) || defined(USE_MAC_FILE_TOOLBOX)
+  Scheme_Object *last = NULL, *v;
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+  HParamBlockRec rec;
+  int i;
+#endif
+
+#ifdef UNIX_FILE_SYSTEM 
+  first = scheme_make_pair(scheme_make_string("/"), scheme_null);
+#endif
+#ifdef DOS_FILE_SYSTEM
+  {
+    unsigned count, i;
+    char buffer[4];
+#ifdef USE_GETDRIVE
+    int orig_drive = _getdrive();
+    count = 26;
+#else
+#ifdef USE_GETDISK
+    count = setdisk(getdisk());
+#else
+    /* Just guess: */
+    count = 3;
+#endif
+#endif
+
+    buffer[1] = ':';
+    buffer[2] = '\\';
+    buffer[3] = 0;
+
+    for (i = 0; i < count; i++) {
+#ifdef USE_GETDRIVE
+      if (!_chdrive(i + 1))
+#endif
+	{
+	  buffer[0] = i + 'a';
+	  v = scheme_make_pair(scheme_make_string(buffer), scheme_null);
+	  if (last)
+	    SCHEME_CDR(last) = v;
+	  else
+	    first = v;
+	  last = v;
+	}
+    }
+#ifdef USE_GETDRIVE
+    _chdrive(orig_drive);
+#endif
+  }
+#endif
+#ifdef USE_MAC_FILE_TOOLBOX
+  i = 1;
+  while (1) {
+    Str255 name;
+    Scheme_Object *v;
+    
+    rec.volumeParam.ioVolIndex = i;
+    rec.volumeParam.ioNamePtr = name;
+    
+    if (PBHGetVInfo(&rec, 0))
+      break;
+    
+    name[name[0] + 1] = ':';
+    v = scheme_make_pair(scheme_make_sized_string((char *)name + 1, 
+						  name[0] + 1, 1), 
+    	                 scheme_null);
+    if (last)
+      SCHEME_CDR(last) = v;
+    else
+      first = v;
+    last = v;
+    i++;
+   }
+#endif
+
+  return first;
+}
+
+static Scheme_Object *make_directory(int argc, Scheme_Object *argv[])
+{
+#ifdef NO_MKDIR
+  return scheme_false;
+#else
+  char *filename;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("make-directory", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "make-directory",
+				    NULL);
+  
+  if (MSC_IZE(mkdir)(filename
+#ifndef MKDIR_NO_MODE_FLAG
+		     , 0xFFFF
+#endif
+		     ))
+    return scheme_false;
+  else
+    return scheme_true;
+#endif
+}
+
+static Scheme_Object *delete_directory(int argc, Scheme_Object *argv[])
+{
+#ifdef NO_RMDIR
+  return scheme_false;
+#else
+  char *filename;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("delete-directory", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "delete-directory",
+				    NULL);
+  
+  if (MSC_IZE(rmdir)(filename))
+    return scheme_false;
+  else
+    return scheme_true;
+#endif
+}
+
+static Scheme_Object *file_modify_seconds(int argc, Scheme_Object **argv)
+{
+  char *file;
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+  long mtime;
+#else
+  struct MSC_IZE(stat) buf;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("file-modify-seconds", "string", 0, argc, argv);
+
+  file = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				SCHEME_STRTAG_VAL(argv[0]),
+				"file-modify-seconds",
+				NULL);
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (!find_mac_file(file, &spec, 0, 1, NULL, NULL, &mtime, NULL, NULL, NULL))
+    return scheme_false;
+
+  return scheme_make_integer_value_from_time(mtime);
+#else
+  if (MSC_IZE(stat)(file, &buf))
+    return scheme_false;
+
+  if (S_ISDIR(buf.st_mode))
+    return scheme_false;
+
+  return scheme_make_integer_value_from_time(buf.st_mtime);
+#endif
+}
+
+#ifdef UNIX_FILE_SYSTEM
+# define GROUP_CACHE_SIZE 10
+struct {
+  gid_t gid;
+  char set, in;
+} group_mem_cache[GROUP_CACHE_SIZE];
+static int user_in_group(gid_t gid)
+{
+  struct group *g;
+  struct passwd *pw;
+  int i, in;
+
+  for (i = 0; i < GROUP_CACHE_SIZE; i++)
+    if (group_mem_cache[i].set && (group_mem_cache[i].gid == gid))
+      return group_mem_cache[i].in;
+
+  pw = getpwuid(getuid());
+  if (!pw)
+    return 0;
+
+  g = getgrgid(gid);
+  if (!g)
+    return 0;
+
+  for (i = 0; g->gr_mem[i]; i++)
+    if (!strcmp(g->gr_mem[i], pw->pw_name))
+      break;
+
+  in = !!(g->gr_mem[i]);
+
+  for (i = 0; i < GROUP_CACHE_SIZE; i++)
+    if (!group_mem_cache[i].set) {
+      group_mem_cache[i].set = 1;
+      group_mem_cache[i].gid = gid;
+      group_mem_cache[i].in = in;
+    }
+
+  return in;
+}
+#endif
+
+static Scheme_Object *file_or_dir_permissions(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *l = scheme_null;
+  char *filename;
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+  int flags, isdir;
+  long type;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("file-or-directory-permissions", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "file-or-directory-permissions",
+				    NULL);
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (!find_mac_file(filename, &spec, 0, -1, NULL, &isdir, NULL, &flags, &type, NULL))
+    return scheme_null;
+
+  l = scheme_make_pair(read_symbol, l);
+
+  if (type == 'APPL')
+    l = scheme_make_pair(execute_symbol, l);
+
+  if (!(flags & 0x1))
+    l = scheme_make_pair(write_symbol, l);
+
+  return l;
+#else
+#ifdef NO_STAT_PROC
+  return scheme_null;
+#else
+#ifdef UNIX_FILE_SYSTEM
+  {
+    struct stat buf;
+    int read, write, execute;
+
+    if (stat(filename, &buf))
+      return scheme_null;
+
+    if (buf.st_uid == getuid()) {
+      read = !!(buf.st_mode & S_IRUSR);
+      write = !!(buf.st_mode & S_IWUSR);
+      execute = !!(buf.st_mode & S_IXUSR);
+    } else if (user_in_group(buf.st_gid)) {
+      read = !!(buf.st_mode & S_IRGRP);
+      write = !!(buf.st_mode & S_IWGRP);
+      execute = !!(buf.st_mode & S_IXGRP);
+    } else {
+      read = !!(buf.st_mode & S_IROTH);
+      write = !!(buf.st_mode & S_IWOTH);
+      execute = !!(buf.st_mode & S_IXOTH);
+    }
+    
+    if (read)
+      l = scheme_make_pair(read_symbol, l);
+    if (write)
+      l = scheme_make_pair(write_symbol, l);
+    if (execute)
+      l = scheme_make_pair(execute_symbol, l);
+  }
+#endif  
+#ifdef DOS_FILE_SYSTEM
+  {
+    int len = strlen(filename);
+
+    if ((len > 1) && IS_A_SEP(filename[0]) && check_dos_slashslash_drive(filename, len, NULL, 1)) {
+      /* stat doesn't work with UNC "drive" names */
+      int flags;
+      if (UNC_dir_exists(filename, len, &flags)) {
+	l = scheme_make_pair(execute_symbol, scheme_make_pair(read_symbol, l));
+	if (!(flags & _A_RDONLY))
+	  l = scheme_make_pair(write_symbol, l);
+      } else
+	return scheme_null;
+    } else {
+      struct MSC_IZE(stat) buf;
+      
+      if (MSC_IZE(stat)(filename, &buf))
+	return scheme_null;
+      
+      if (buf.st_mode & MSC_IZE(S_IREAD))
+	l = scheme_make_pair(execute_symbol,
+			     scheme_make_pair(read_symbol, l));
+      if (buf.st_mode & MSC_IZE(S_IWRITE))
+	l = scheme_make_pair(write_symbol, l);
+    }
+  }
+#endif
+#endif
+#endif
+
+  return l;
+}
+
+static Scheme_Object *file_size(int argc, Scheme_Object *argv[])
+{
+  char *filename;
+#ifdef USE_MAC_FILE_TOOLBOX
+  FSSpec spec;
+#endif
+  unsigned long len = 0;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("file-size", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "file-size",
+				    NULL);
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  if (!find_mac_file(filename, &spec, 0, 1, NULL, NULL, NULL, NULL, NULL, &len))
+    return scheme_false;
+#endif
+#if defined(UNIX_FILE_SYSTEM) || defined(DOS_FILE_SYSTEM)
+  {
+    struct MSC_IZE(stat) buf;
+
+    if (MSC_IZE(stat)(filename, &buf) || S_ISDIR(buf.st_mode))
+      return scheme_false;
+
+    len = buf.st_size;
+  }
+#endif
+
+  return scheme_make_integer_value_from_unsigned(len);
+}
+
+#endif
+
+#ifdef DIR_FUNCTION
+static Scheme_Object *current_directory(int argc, Scheme_Object **args)
+{
+  if (argc) {
+    char *expanded;
+
+    if (!SCHEME_STRINGP(args[0]))
+      scheme_wrong_type("current-directory", "string", 0, argc, args);
+
+    expanded = scheme_expand_filename(SCHEME_STR_VAL(args[0]),
+				      SCHEME_STRTAG_VAL(args[0]),
+				      "current-directory",
+				      NULL);
+
+    scheme_setcwd(expanded, 0);
+
+    return scheme_void;
+  } else
+    return scheme_make_string_without_copying(scheme_getcwd(NULL, 0, NULL, 0));
+}
+
+#ifdef USE_FCHDIR
+static const char *wd_via_fchdir = "fchdir";
+static int using_fchdir = 0;
+/* File descriptors are a limited resource, so set a max number to be
+   used for tracking thread directories: */
+#define MAX_PROCESSES_USE_FCHDIR 8
+#endif
+
+void scheme_set_process_directory(Scheme_Process *newp, Scheme_Process *oldp)
+{
+#ifdef USE_MAC_FILE_TOOLBOX
+  WDPBRec  wdrec;
+  char buf[256];
+
+  if (oldp->running > 0) {
+    wdrec.ioNamePtr = (StringPtr)buf;
+    if (PBHGetVol(&wdrec, 0))
+      oldp->wd_inited = 0;
+    else {
+      oldp->vrefnum = wdrec.ioWDVRefNum;
+      oldp->dirid = wdrec.ioWDDirID;
+      oldp->wd_inited = 1;
+    }
+  }
+
+  if (newp->wd_inited) {
+    wdrec.ioNamePtr = NULL;
+    wdrec.ioVRefNum = newp->vrefnum;
+    wdrec.ioWDDirID = newp->dirid;
+
+    PBHSetVol(&wdrec, 0);
+  }
+#else
+  int len, old_set = 0;
+
+  if (oldp->running > 0) {
+#ifdef USE_FCHDIR
+    int used_fchdir;
+    
+    if (using_fchdir < MAX_PROCESSES_USE_FCHDIR) {
+      oldp->wd_len = open(".", O_RDONLY, 0);
+      if (oldp->wd_len != -1) {
+	/* printf("open dir: #%d %d\n", using_fchdir, oldp->wd_len); */
+	oldp->working_directory = (char *)wd_via_fchdir;
+	using_fchdir++;
+	used_fchdir = 1;
+      } else
+	used_fchdir = 0;
+    } else
+      used_fchdir = 0;
+    
+    if (!used_fchdir) {
+#endif
+      old_set = 1;
+      
+      if (!oldp->working_directory) {
+	oldp->wd_len = GETCWD_BUFSIZE;
+	oldp->working_directory = (char *)scheme_malloc_atomic(oldp->wd_len);
+      }
+      
+      oldp->working_directory = scheme_getcwd(oldp->working_directory, oldp->wd_len, &len, 1);
+      if (len > oldp->wd_len)
+	oldp->wd_len = len;
+#ifdef USE_FCHDIR
+    }
+#endif
+  }
+
+#ifdef USE_FCHDIR
+  if (newp->working_directory == wd_via_fchdir) {
+    fchdir(newp->wd_len);
+    close(newp->wd_len);
+    --using_fchdir;
+    /* printf("close dir: #%d %d\n", using_fchdir, newp->wd_len); */
+    newp->working_directory = NULL;
+  } else {
+#endif
+    if (newp->working_directory
+	&& (!old_set
+	    || strcmp(oldp->working_directory, newp->working_directory)))
+      MSC_IZE(chdir)(newp->working_directory);
+#ifdef USE_FCHDIR
+  }
+#endif
+#endif
+}
+
+char *scheme_get_thread_current_directory(Scheme_Process *p, int *len, int noexn)
+{
+  if (p == scheme_current_process)
+    return scheme_getcwd(NULL, 0, len, noexn);
+  
+#ifdef USE_MAC_FILE_TOOLBOX
+  {
+    FSSpec spec;
+    char *s;
+
+    spec.vRefNum = p->vrefnum;
+    spec.parID = p->dirid;
+
+    s = scheme_build_mac_filename(&spec, 1);
+    *len = strlen(s);
+
+    return s;
+  }
+#else
+# ifdef USE_FCHDIR
+  if (p->working_directory == wd_via_fchdir) {
+    char *savedir = scheme_getcwd(NULL, 0, NULL, 1);
+    char *result;
+
+    fchdir(p->wd_len);
+    result = scheme_getcwd(NULL, 0, len, noexn);
+    scheme_setcwd(savedir, noexn);
+
+    return result;
+  }
+# endif
+  *len = strlen(p->working_directory);
+  return scheme_strdup(p->working_directory);
+#endif  
+}
+
+void scheme_done_process_directory(Scheme_Process *p)
+{
+#ifdef USE_FCHDIR
+  if (p->working_directory == wd_via_fchdir) {
+    close(p->wd_len);
+    --using_fchdir;
+    /* printf("close dir: #%d %d\n", using_fchdir, p->wd_len); */
+    p->working_directory = NULL;
+  }
+#endif
+}
+#endif
+
+#ifndef NO_FILE_SYSTEM_UTILS
+
+static Scheme_Object *collpaths_p(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *v = argv[0];
+
+  if (scheme_proper_list_length(v) < 0)
+    return scheme_false;
+
+  while (SCHEME_PAIRP(v)) {
+    if (!SCHEME_STRINGP(SCHEME_CAR(v)))
+      return scheme_false;
+    v = SCHEME_CDR(v);
+  }
+
+  return SCHEME_NULLP(v) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *current_library_collection_paths(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-library-collection-paths", MZCONFIG_COLLECTION_PATHS,
+			     argc, argv,
+			     -1, collpaths_p, "list of strings", 0);
+}
+
+#endif
+
+#ifdef MACINTOSH_EVENTS
+int scheme_mac_start_app(char *name, int find_path, Scheme_Object *o)
+{
+  char *s;
+  FSSpec spec;
+
+  if (find_path) {
+    DTPBRec rec;
+    Str255 nm;
+    short vrefnum;
+
+    if (!SCHEME_STRINGP(o) || (SCHEME_STRTAG_VAL(o) != 4))
+      scheme_wrong_type(name, "string of 4 characters", 0, 1, &o);
+    
+    if (GetVol(nm, &vrefnum))
+      return 0;
+    rec.ioNamePtr = NULL;
+    rec.ioVRefNum = vrefnum;
+
+    if (PBDTGetPath(&rec))
+      return 0;
+
+    rec.ioIndex = 0;
+    rec.ioNamePtr = nm;
+    rec.ioFileCreator = *(long *)SCHEME_STR_VAL(o);
+
+    if (PBDTGetAPPL(&rec, 0))
+      return 0;
+  } else {
+    if (!SCHEME_STRINGP(o))
+      scheme_wrong_type(name, "string", 0, 1, &o);
+
+    s = scheme_expand_filename(SCHEME_STR_VAL(o),
+			       SCHEME_STRTAG_VAL(o),
+			       name,
+			       NULL);
+  }
+
+  if (find_mac_file(s, &spec, 0, 1, NULL, NULL, NULL, NULL, NULL, NULL)) {
+    LaunchParamBlockRec rec;
+
+    rec.launchBlockID = extendedBlock;
+    rec.launchEPBLength = extendedBlockLen;
+    rec.launchFileFlags = 0;
+    rec.launchControlFlags = launchContinue | launchNoFileFlags;
+    rec.launchAppSpec = &spec;
+    rec.launchAppParameters = NULL;
+    
+    return !LaunchApplication(&rec);
+  }
+
+  return 0;
+}
+#endif
diff --git a/src/mzscheme/src/fun.c b/src/mzscheme/src/fun.c
new file mode 100644
index 0000000..7a7dbf1
--- /dev/null
+++ b/src/mzscheme/src/fun.c
@@ -0,0 +1,2246 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#ifdef TIME_SYNTAX
+# include <time.h>
+# ifdef USE_FTIME
+#  include <sys/timeb.h>
+# else
+#  ifndef USE_DIFFTIME
+#   include <sys/time.h>
+#  endif /* USE_DIFFTIME */
+# endif /* USE_FTIME */
+# ifdef USE_GETRUSAGE
+#  include <sys/types.h>
+#  include <sys/time.h>
+#  include <sys/resource.h>
+# endif /* USE_GETRUSAGE */
+# ifdef USE_SYSCALL_GETRUSAGE
+#  include <sys/syscall.h>
+#  define getrusage(a, b)  syscall(SYS_GETRUSAGE, a, b)
+#  define USE_GETRUSAGE
+# endif /* USE_SYSCALL_GETRUSAGE */
+#endif /* TIME_SYNTAX */
+
+/* globals */
+int scheme_escape_continuations_only; 
+
+int scheme_defining_primitives;
+
+Scheme_Object *scheme_void;
+Scheme_Object *scheme_void_func;
+
+Scheme_Object *scheme_tail_call_waiting;
+
+/* locals */
+static Scheme_Object *procedure_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *apply (int argc, Scheme_Object *argv[]);
+static Scheme_Object *map (int argc, Scheme_Object *argv[]);
+static Scheme_Object *for_each (int argc, Scheme_Object *argv[]);
+static Scheme_Object *andmap (int argc, Scheme_Object *argv[]);
+static Scheme_Object *ormap (int argc, Scheme_Object *argv[]);
+static Scheme_Object *call_ec (int argc, Scheme_Object *argv[]);
+static Scheme_Object *call_cc (int argc, Scheme_Object *argv[]);
+static Scheme_Object *void_func (int argc, Scheme_Object *argv[]);
+static Scheme_Object *is_void_func (int argc, Scheme_Object *argv[]);
+static Scheme_Object *dynamic_wind (int argc, Scheme_Object *argv[]);
+#ifdef TIME_SYNTAX
+static Scheme_Object *time_apply(int argc, Scheme_Object *argv[]);
+static Scheme_Object *current_milliseconds(int argc, Scheme_Object **argv);
+static Scheme_Object *current_process_milliseconds(int argc, Scheme_Object **argv);
+static Scheme_Object *current_gc_milliseconds(int argc, Scheme_Object **argv);
+static Scheme_Object *current_seconds(int argc, Scheme_Object **argv);
+static Scheme_Object *seconds_to_date(int argc, Scheme_Object **argv);
+#endif
+static Scheme_Object *inferred_name(int argc, Scheme_Object *argv[]);
+static Scheme_Object *arity(int argc, Scheme_Object *argv[]);
+static Scheme_Object *procedure_arity_includes(int argc, Scheme_Object *argv[]);
+static Scheme_Object *primitive_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *primitive_closure_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *primitive_name(int argc, Scheme_Object *argv[]);
+static Scheme_Object *primitive_result_arity (int argc, Scheme_Object *argv[]);
+static Scheme_Object *syntax_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *macro_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *id_macro_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *exp_time_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *call_with_values(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_values(int argc, Scheme_Object *argv[]);
+static Scheme_Object *current_print(int argc, Scheme_Object **argv);
+static Scheme_Object *current_prompt_read(int, Scheme_Object **);
+
+static Scheme_Object *default_print_handler(int, Scheme_Object *[]);
+static Scheme_Object *default_prompt_read_handler(int, Scheme_Object *[]);
+
+static Scheme_Object *get_or_check_arity(Scheme_Object *p, long a);
+
+static Scheme_Object *write_compiled_closure(Scheme_Object *obj);
+static Scheme_Object *read_compiled_closure(Scheme_Object *obj);
+
+static Scheme_Object *rep;
+
+#define CONS(a,b) scheme_make_pair(a,b)
+
+#define DYNAMIC_WIND "dynamic-wind"
+
+#ifdef USE_DIFFTIME
+static time_t base_time;
+#endif
+
+/* See call_cc: */
+typedef struct Scheme_Dynamic_Wind_List {
+  Scheme_Dynamic_Wind *dw;
+  struct Scheme_Dynamic_Wind_List *next;
+} Scheme_Dynamic_Wind_List;
+
+void
+scheme_init_fun (Scheme_Env *env)
+{
+  Scheme_Object *o;
+
+  if (scheme_starting_up) {
+    REGISTER_SO(scheme_void);
+    REGISTER_SO(scheme_void_func);
+    REGISTER_SO(scheme_tail_call_waiting);
+
+#ifdef USE_DIFFTIME
+    base_time = time(NULL);
+#endif
+
+    scheme_void = scheme_alloc_eternal_object();
+    scheme_void->type = scheme_void_type;
+
+#ifdef MZ_APPLY_WAITING_CONSTANT
+    scheme_tail_call_waiting = MZ_APPLY_WAITING_CONSTANT;
+#else
+    scheme_tail_call_waiting = scheme_alloc_eternal_object();
+    scheme_tail_call_waiting->type = scheme_tail_call_waiting_type;
+#endif
+
+    scheme_void_func = scheme_make_folding_prim(void_func, "void", 0, -1, 1);
+  }
+
+  scheme_add_global_constant("procedure?", 
+			     scheme_make_folding_prim(procedure_p, 
+						      "procedure?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("apply", 
+			     scheme_make_prim_w_arity2(apply,  
+						       "apply", 
+						       2, -1,
+						       0, -1), 
+			     env);
+  scheme_add_global_constant("map", 
+			     scheme_make_prim_w_arity(map,  
+						      "map", 
+						      2, -1), 
+			     env);
+  scheme_add_global_constant("for-each", 
+			     scheme_make_prim_w_arity(for_each,  
+						      "for-each", 
+						      2, -1), 
+			     env);
+  scheme_add_global_constant("andmap", 
+			     scheme_make_prim_w_arity(andmap,  
+						      "andmap", 
+						      2, -1), 
+			     env);
+  scheme_add_global_constant("ormap", 
+			     scheme_make_prim_w_arity(ormap,  
+						      "ormap", 
+						      2, -1), 
+			     env);
+  scheme_add_global_constant("call-with-values",
+			     scheme_make_prim_w_arity2(call_with_values,  
+						       "call-with-values",
+						       2, 2,
+						       0, -1),
+			     env);
+  scheme_add_global_constant("values",
+			     scheme_make_prim_w_arity2(scheme_values,  
+						       "values",
+						       0, -1,
+						       0, -1),
+			     env);
+
+  o = scheme_make_prim_w_arity2(call_ec,  
+				"call-with-escaping-continuation",
+				1, 1,
+				0, -1), 
+  scheme_add_global_constant("call-with-escaping-continuation", o, env);
+  scheme_add_global_constant("call/ec", o, env);  
+
+  if (!scheme_escape_continuations_only)
+    o = scheme_make_prim_w_arity2(call_cc,  
+				  "call-with-current-continuation", 
+				  1, 1,
+				  0, -1);
+  
+  scheme_add_global_constant("call-with-current-continuation", o, env);
+  scheme_add_global_constant("call/cc", o, env);  
+
+  scheme_add_global_constant("void", scheme_void_func, env);  
+  scheme_add_global_constant("void?", 
+			     scheme_make_folding_prim(is_void_func,  
+						      "void?", 
+						      1, 1, 1), 
+			     env);  
+#ifdef TIME_SYNTAX
+  scheme_add_global_constant("time-apply", 
+			     scheme_make_prim_w_arity2(time_apply,  
+						       "time-apply", 
+						       1, 1,
+						       3, 3), 
+			     env);
+  scheme_add_global_constant("current-milliseconds",
+			     scheme_make_prim_w_arity(current_milliseconds,
+						      "current-milliseconds",
+						      0, 0),
+			     env);
+  scheme_add_global_constant("current-process-milliseconds",
+			     scheme_make_prim_w_arity(current_process_milliseconds,
+						      "current-process-milliseconds",
+						      0, 0),
+			     env);
+  scheme_add_global_constant("current-gc-milliseconds",
+			     scheme_make_prim_w_arity(current_gc_milliseconds,
+						      "current-gc-milliseconds",
+						      0, 0),
+			     env);
+  scheme_add_global_constant("current-seconds",
+			     scheme_make_prim_w_arity(current_seconds,
+						      "current-seconds",
+						      0, 0),
+			     env);
+  scheme_add_global_constant("seconds->date",
+			     scheme_make_prim_w_arity(seconds_to_date,
+						      "seconds->date",
+						      1, 1),
+			     env);
+#endif
+
+  scheme_add_global_constant(DYNAMIC_WIND, 
+			     scheme_make_prim_w_arity(dynamic_wind,  
+						      DYNAMIC_WIND, 
+						      3, 3), 
+			     env);
+
+  scheme_add_global_constant("inferred-name", 
+			     scheme_make_folding_prim(inferred_name,  
+						      "inferred-name", 
+						      1, 1, 1), 
+			     env);
+
+  scheme_add_global_constant("arity", 
+			     scheme_make_folding_prim(arity,  
+						      "arity", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("procedure-arity-includes?", 
+			     scheme_make_folding_prim(procedure_arity_includes,  
+						      "procedure-arity-includes?", 
+						      2, 2, 1), 
+			     env);
+
+  scheme_add_global_constant("primitive?", 
+			     scheme_make_folding_prim(primitive_p, 
+						      "primitive?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("primitive-closure?", 
+			     scheme_make_folding_prim(primitive_closure_p, 
+						      "primitive-closure?", 
+						      1, 1, 1), 
+			     env);
+
+  scheme_add_global_constant("primitive-name", 
+			     scheme_make_folding_prim(primitive_name, 
+						      "primitive-name", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("primitive-result-arity", 
+			     scheme_make_folding_prim(primitive_result_arity, 
+						      "primitive-result-arity", 
+						      1, 1, 1), 
+			     env);
+
+  scheme_add_global_constant("syntax?", 
+			     scheme_make_folding_prim(syntax_p, 
+						      "syntax?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("macro?", 
+			     scheme_make_folding_prim(macro_p, 
+						      "macro?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("id-macro?", 
+			     scheme_make_folding_prim(id_macro_p, 
+						      "id-macro?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("expansion-time-value?", 
+			     scheme_make_folding_prim(exp_time_p, 
+						      "expansion-time-value?", 
+						      1, 1, 1), 
+			     env);
+  
+  scheme_add_global_constant("current-print",
+			     scheme_register_parameter(current_print, 
+						       "current-print",
+						       MZCONFIG_PRINT_HANDLER),
+			     env);
+  scheme_add_global_constant("current-prompt-read",
+			     scheme_register_parameter(current_prompt_read, 
+						       "current-prompt-read",
+						       MZCONFIG_PROMPT_READ_HANDLER),
+			     env);
+
+
+  if (scheme_starting_up) {
+    Scheme_Config *config = scheme_config;
+    
+    scheme_set_param(config, MZCONFIG_PRINT_HANDLER,
+		     scheme_make_prim_w_arity(default_print_handler,
+					      "default-print-handler",
+					      1, 1));
+
+    scheme_set_param(config, MZCONFIG_PROMPT_READ_HANDLER,
+		     scheme_make_prim_w_arity(default_prompt_read_handler,
+					      "default-prompt-read-handler",
+					      0, 0));
+  
+    scheme_install_type_writer(scheme_unclosed_procedure_type,
+			       write_compiled_closure);
+    scheme_install_type_reader(scheme_unclosed_procedure_type,
+			       read_compiled_closure);
+  }
+}
+
+void scheme_init_rep(Scheme_Env *env)
+{
+  REGISTER_SO(rep);
+  rep = scheme_lookup_global(scheme_intern_symbol("#%read-eval-print-loop"), env);
+}
+
+Scheme_Object *
+scheme_force_value(Scheme_Object *obj)
+{
+  if (SAME_OBJ(obj, SCHEME_TAIL_CALL_WAITING)) {
+    Scheme_Process *p = scheme_current_process;
+    Scheme_Object *v;
+
+    v = _scheme_apply_multi(p->ku.apply.tail_rator, 
+			    p->ku.apply.tail_num_rands, 
+			    p->ku.apply.tail_rands);
+    return v;
+  } else if (SAME_OBJ(obj, SCHEME_EVAL_WAITING)) {
+    Scheme_Process *p = scheme_current_process;
+    return _scheme_eval_compiled_expr(p->ku.eval.wait_expr);
+  } else if (obj)
+    return obj;
+  else
+    return scheme_void;
+}
+
+Scheme_Object *
+scheme_make_prim_w_everything(Scheme_Prim *fun, int eternal,
+			      const char *name,
+			      short mina, short maxa,
+			      short folding,
+			      short minr, short maxr)
+{
+  Scheme_Primitive_Proc *prim;
+  int hasr, size;
+
+  hasr = ((minr != 1) || (maxr != 1));
+  size = hasr ? sizeof(Scheme_Prim_W_Result_Arity) : sizeof(Scheme_Primitive_Proc);
+
+  if (eternal && scheme_starting_up)
+    prim = (Scheme_Primitive_Proc *)scheme_malloc_eternal_tagged(size);
+  else
+    prim = (Scheme_Primitive_Proc *)scheme_malloc_stubborn_tagged(size);
+  prim->type = scheme_prim_type;
+  SCHEME_PRIM(prim) = fun;
+  prim->name = name;
+  prim->mina = mina;
+  prim->maxa = maxa;
+  prim->flags = ((folding ? SCHEME_PRIM_IS_FOLDING : 0)
+		 | (scheme_defining_primitives ? SCHEME_PRIM_IS_PRIMITIVE : 0)
+		 | (hasr ? SCHEME_PRIM_IS_MULTI_RESULT : 0));
+
+  if (!eternal || !scheme_starting_up)
+    scheme_end_stubborn_change(prim);
+
+  if (hasr) {
+    ((Scheme_Prim_W_Result_Arity *)prim)->minr = minr;
+    ((Scheme_Prim_W_Result_Arity *)prim)->maxr = maxr;
+  }
+
+  return (Scheme_Object *)prim;
+}
+
+Scheme_Object *scheme_make_prim(Scheme_Prim *fun)
+{
+  return scheme_make_prim_w_everything(fun, 1, NULL, 0, -1, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_noneternal_prim (Scheme_Prim *fun)
+{
+  return scheme_make_prim_w_everything(fun, 0, NULL, 0, -1, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_prim_w_arity(Scheme_Prim *fun, const char *name, 
+			 short mina, short maxa)
+{
+  return scheme_make_prim_w_everything(fun, 1, name, mina, maxa, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_folding_prim(Scheme_Prim *fun, const char *name, 
+			 short mina, short maxa,
+			 short folding)
+{
+  return scheme_make_prim_w_everything(fun, 1, name, mina, maxa, 
+				       folding, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_noneternal_prim_w_arity(Scheme_Prim *fun, const char *name,
+				    short mina, short maxa)
+{
+  return scheme_make_prim_w_everything(fun, 0, name, mina, maxa, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_closed_prim_w_everything(Scheme_Closed_Prim *fun, 
+				     void *data,
+				     const char *name, 
+				     short mina, short maxa,
+				     short folding,
+				     short minr, short maxr)
+{
+  Scheme_Closed_Primitive_Proc *prim;
+  int hasr, size;
+
+  hasr = ((minr != 1) || (maxr != 1));
+  size = hasr ? sizeof(Scheme_Closed_Prim_W_Result_Arity) : sizeof(Scheme_Closed_Primitive_Proc);
+
+  prim = (Scheme_Closed_Primitive_Proc *)scheme_malloc_tagged(size);
+
+  prim->type = scheme_closed_prim_type;
+  SCHEME_CLSD_PRIM(prim) = fun;
+  SCHEME_CLSD_PRIM_DATA(prim) = data;
+  prim->name = name;
+  prim->mina = mina;
+  prim->maxa = maxa;
+  prim->flags = ((folding ? SCHEME_PRIM_IS_FOLDING : 0)
+		 | (scheme_defining_primitives ? SCHEME_PRIM_IS_PRIMITIVE : 0)
+		 | (hasr ? SCHEME_PRIM_IS_MULTI_RESULT : 0));
+
+  if (hasr) {
+    ((Scheme_Closed_Prim_W_Result_Arity *)prim)->minr = minr;
+    ((Scheme_Closed_Prim_W_Result_Arity *)prim)->maxr = maxr;
+  }
+
+  return (Scheme_Object *)prim;
+}
+
+Scheme_Object *
+scheme_make_folding_closed_prim(Scheme_Closed_Prim *fun, 
+				void *data,
+				const char *name, 
+				short mina, short maxa,
+				short folding)
+{
+  return scheme_make_closed_prim_w_everything(fun, data, name, mina, maxa, folding, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_closed_prim_w_arity(Scheme_Closed_Prim *fun, void *data,
+				const char *name, short mina, short maxa)
+{
+  return scheme_make_closed_prim_w_everything(fun, data, name, mina, maxa, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_closed_prim(Scheme_Closed_Prim *fun, void *data)
+{
+  return scheme_make_closed_prim_w_everything(fun, data, NULL, 0, -1, 0, 1, 1);
+}
+
+Scheme_Object *
+scheme_make_closure (Scheme_Env *env, Scheme_Object *code)
+{
+  Scheme_Object *closure;
+
+  closure = scheme_alloc_stubborn_object();
+
+  closure->type = scheme_closure_type;
+  SCHEME_CLOS_ENV(closure) = env;
+  SCHEME_CLOS_CODE(closure) = code;
+
+  scheme_end_stubborn_change((void *)closure);
+
+  return closure;
+}
+
+Scheme_Object *
+scheme_make_linked_closure(Scheme_Process *p, 
+			   Scheme_Object *linked_code, int close)
+{
+  Scheme_Closure_Compilation_Data *data;
+  Scheme_Closed_Compiled_Procedure *closure;
+  Scheme_Object **runstack, **dest;
+  short *map;
+  int i;
+
+  data = (Scheme_Closure_Compilation_Data *)linked_code;
+
+  i = data->closure_size;
+
+  closure = (Scheme_Closed_Compiled_Procedure *)
+    scheme_malloc_tagged(sizeof(Scheme_Closed_Compiled_Procedure)
+			 + (i - 1) * sizeof(Scheme_Object *));
+
+  closure->type = scheme_linked_closure_type;
+  SCHEME_COMPILED_CLOS_CODE(closure) = linked_code;
+
+  if (!close || !i)
+    return (Scheme_Object *)closure;
+
+  runstack = p->runstack;
+  dest = closure->vals;
+  map = data->closure_map;
+
+  while (i--) 
+    dest[i] = runstack[map[i]];
+
+  return (Scheme_Object *)closure;
+}
+
+typedef struct {
+  int *local_flags;
+  short *real_closure_map;
+} Closure_Info;
+
+Scheme_Object *
+scheme_link_closure_compilation(Scheme_Object *_data, Link_Info *info)
+{
+  Scheme_Closure_Compilation_Data *data;
+  int i;
+  short *oldpos;
+  Closure_Info *cl;
+  Link_Info *new_info;
+
+  data = (Scheme_Closure_Compilation_Data *)_data;
+  cl = (Closure_Info *)data->closure_map;
+  data->closure_map = cl->real_closure_map;
+  data->type = scheme_unclosed_procedure_type;
+
+  /* Set local_flags: */
+  for (i = 0; i < data->num_params; i++) {
+    if (cl->local_flags[i] & SCHEME_WAS_SET_BANGED)
+      cl->local_flags[i] = SCHEME_INFO_BOXED;
+    else
+      cl->local_flags[i] = 0;
+  }
+
+  oldpos = (short *)scheme_malloc_atomic(sizeof(short) * data->closure_size);
+  for (i = data->closure_size; i--; ) {
+    oldpos[i] = data->closure_map[i];
+    data->closure_map[i] = scheme_link_info_lookup(info, oldpos[i], NULL);
+  }
+  
+  new_info = scheme_link_info_extend(info, data->num_params, data->num_params,
+				     data->closure_size + data->num_params);
+  for (i = 0; i < data->num_params; i++)
+    scheme_link_info_add_mapping(new_info, i, i + data->closure_size, 
+				 cl->local_flags[i]);
+  for (i = 0; i < data->closure_size; i++) {
+    int p = oldpos[i];
+
+    if (p < 0)
+      p -= data->num_params;
+    else
+      p += data->num_params;
+
+    scheme_link_info_add_mapping(new_info, p, i,
+				 scheme_link_info_flags(info, oldpos[i]));
+  }
+
+  data->code = scheme_link_expr(data->code, new_info);
+
+  /* Add code to box set!ed variables: */
+  for (i = 0; i < data->num_params; i++) {
+    if (cl->local_flags[i] & SCHEME_INFO_BOXED) {
+      int j = i + data->closure_size;
+      data->code = scheme_make_syntax_link(scheme_bangboxenv_execute, 
+					   scheme_make_pair(scheme_make_integer(j),
+							    data->code));
+    }
+  }
+
+  if ((SCHEME_TYPE(data->code) > _scheme_compiled_values_types_)
+      || (SCHEME_TYPE(data->code) == scheme_quote_compilation_type))
+    data->flags |= CLOS_FOLDABLE;
+
+  if (!data->closure_size && info->can_optimize_constants)
+    /* If only global frame is needed, go ahead and finialize closure */
+    return scheme_make_linked_closure(NULL, (Scheme_Object *)data, 0);
+  else
+    return (Scheme_Object *)data;
+}
+
+Scheme_Object *
+scheme_make_closure_compilation(Scheme_Comp_Env *env, Scheme_Object *code, 
+				Scheme_Compile_Info *rec)
+{
+  Scheme_Object *allparams, *params, *forms, *param, *name, *rest;
+  Scheme_Closure_Compilation_Data *data;
+  Scheme_Compile_Info lam;
+  Scheme_Comp_Env *frame;
+  Closure_Info *cl;
+  int i;
+
+  data  = MALLOC_ONE_TAGGED(Scheme_Closure_Compilation_Data);
+
+  data->type = scheme_compiled_unclosed_procedure_type;
+
+  params = allparams = SCHEME_CAR(SCHEME_CDR(code));
+
+  data->num_params = 0;
+  for (; SCHEME_PAIRP(params); params = SCHEME_CDR(params))
+    data->num_params++;
+  data->flags = 0;
+  if (!SCHEME_NULLP(params)) {
+    data->flags |= CLOS_HAS_REST;
+    data->num_params++;
+  }
+
+  forms = SCHEME_CDR(SCHEME_CDR(code));
+
+  /* Check for duplicate names: */
+  for (params = allparams;
+       SCHEME_PAIRP(params); 
+       params = SCHEME_CDR(params)) {
+    name = SCHEME_CAR(params);
+    for (rest = SCHEME_CDR(params); 
+	 !SCHEME_NULLP(rest); 
+	 rest = SCHEME_CDR(rest)) {
+      if (!SCHEME_PAIRP(rest))
+	param = rest;
+      else
+	param = SCHEME_CAR(rest);
+      if (SCHEME_SYMBOLP(name) && SAME_OBJ(param, name)) {
+	scheme_wrong_syntax("lambda", name, code,
+			    "duplicate argument name");
+      }
+      if (!SCHEME_PAIRP(rest))
+	break;
+    }
+  }
+
+  frame = scheme_new_compilation_frame(data->num_params, SCHEME_LAMBDA_FRAME, env);
+  params = allparams;
+  for (i = 0; i < data->num_params; i++) {
+    if (!SCHEME_PAIRP(params))
+      param = params;
+    else
+      param = SCHEME_CAR(params);
+    scheme_check_identifier("lambda", param, NULL, env, code);
+    scheme_add_compilation_binding(i, param, frame);
+    if (SCHEME_PAIRP(params))
+      params = SCHEME_CDR (params);
+  }
+
+  if (SCHEME_NULLP(forms))
+    scheme_wrong_syntax("lambda", NULL, code, "bad syntax (empty body)");
+
+  data->name = rec->value_name;
+
+  scheme_compile_rec_done_local(rec);
+
+  scheme_init_lambda_rec(rec, &lam);
+
+  data->code = scheme_compile_sequence(forms, 
+				       scheme_no_defines(frame), 
+				       &lam);
+
+  scheme_merge_lambda_rec(rec, &lam);
+
+  cl = MALLOC_ONE(Closure_Info);
+
+  cl->local_flags = scheme_env_get_flags(frame, 0, data->num_params);
+
+  /* Remembers positions of used vars (and unsets usage for this level) */
+  scheme_env_make_closure_map(frame, &data->closure_size, &cl->real_closure_map);
+
+  data->closure_map = (short *)cl;
+
+  data->max_let_depth = lam.max_let_depth + data->num_params + data->closure_size;
+  
+  return (Scheme_Object *)data;
+}
+
+void *scheme_top_level_do(void *(*k)(void))
+{
+  void *v;
+  long *old_cc_ok, *ok;
+  void *old_cc_start;
+  jmp_buf save, oversave;
+#ifdef ERROR_ON_OVERFLOW
+  int orig_overflow;
+#endif
+  Scheme_Stack_State envss;
+  Scheme_Comp_Env *save_current_local_env;
+  Scheme_Process *p = scheme_current_process;
+
+#ifndef MZ_REAL_THREADS
+  if (scheme_active_but_sleeping)
+    scheme_wake_up();
+#endif
+
+  old_cc_ok = p->cc_ok;
+  old_cc_start = p->cc_start;
+
+  p->cc_ok = ok = (long *)scheme_malloc_atomic(sizeof(long));
+  p->cc_start = &v;
+  
+  if (old_cc_ok)
+    *old_cc_ok = 0;
+  *ok = 1;
+
+#ifdef ERROR_ON_OVERFLOW
+  orig_overflow = p->stack_overflow;
+#endif
+  scheme_save_env_stack_w_process(envss, p);
+
+  save_current_local_env = p->current_local_env;
+
+#ifndef ERROR_ON_OVERFLOW
+  memcpy(&oversave, &p->overflow_buf, sizeof(jmp_buf));
+  if (scheme_setjmp(p->overflow_buf)) {
+    while (1) {
+      Scheme_Overflow *overflow;
+
+      overflow = MALLOC_ONE(Scheme_Overflow);
+      
+      memcpy(&overflow->cont, &scheme_overflow_cont, 
+	     sizeof(Scheme_Jumpup_Buf));
+      overflow->prev = p->overflow;
+      p->overflow = overflow;
+      
+      memcpy(&overflow->savebuf, &scheme_error_buf, sizeof(jmp_buf));
+      if (scheme_setjmp(scheme_error_buf)) {
+	scheme_overflow_reply = NULL; /* means "continue the error" */
+      } else {
+	void *p1, *p2, *p3, *p4;
+	int i1, i2;
+	
+	p1 = p->ku.k.p1;
+	p2 = p->ku.k.p2;
+	p3 = p->ku.k.p3;
+	p4 = p->ku.k.p4;
+	i1 = p->ku.k.i1;
+	i2 = p->ku.k.i2;
+	
+	/* stack overflow is a lot of work; force a sleep */
+	scheme_process_block(0);
+	
+	p->ku.k.p1 = p1;
+	p->ku.k.p2 = p2;
+	p->ku.k.p3 = p3;
+	p->ku.k.p4 = p4;
+	p->ku.k.i1 = i1;
+	p->ku.k.i2 = i2;
+	
+	scheme_overflow_reply = scheme_overflow_k();
+      }
+      
+      overflow = p->overflow;
+      memcpy(&scheme_error_buf, &overflow->savebuf, sizeof(jmp_buf));
+      p->overflow = overflow->prev;
+      memcpy(&scheme_overflow_cont, &overflow->cont, 
+	     sizeof(Scheme_Jumpup_Buf));
+      overflow = NULL; /* Maybe helps GC */
+      /* Reset overflow buffer and continue */
+      if (scheme_setjmp(p->overflow_buf)) {
+	/* handle again */
+      } else
+	scheme_longjmpup(&scheme_overflow_cont);
+    }
+  }
+#endif
+
+  memcpy(&save, &p->error_buf, sizeof(jmp_buf));
+
+  if (scheme_setjmp(p->error_buf)) {
+    scheme_restore_env_stack_w_process(envss, p);
+    *ok = 0;
+    if (old_cc_ok)
+      *old_cc_ok = 1;
+    p->cc_ok = old_cc_ok;
+    p->cc_start = old_cc_start;  
+#ifdef ERROR_ON_OVERFLOW
+    p->stack_overflow = orig_overflow;
+#else
+    memcpy(&p->overflow_buf, &oversave, sizeof(jmp_buf));
+#endif
+    scheme_longjmp(save, 1);
+  }
+
+  v = k();
+
+  p->current_local_env = save_current_local_env;
+
+  memcpy(&p->error_buf, &save, sizeof(jmp_buf));
+
+#ifdef ERROR_ON_OVERFLOW
+  p->stack_overflow = orig_overflow;
+#else
+  memcpy(&p->overflow_buf, &oversave, sizeof(jmp_buf));
+#endif
+
+  *ok = 0;
+  if (old_cc_ok)
+    *old_cc_ok = 1;
+  p->cc_ok = old_cc_ok;
+  p->cc_start = old_cc_start;
+
+#ifndef MZ_REAL_THREADS
+  if (scheme_active_but_sleeping)
+    scheme_wake_up();
+#endif
+
+  return v;
+}
+
+static void *apply_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *rator;
+  int num_rands;
+  Scheme_Object **rands;
+
+  rator = (Scheme_Object *)p->ku.k.p1;
+  rands = (Scheme_Object **)p->ku.k.p2;
+  num_rands = p->ku.k.i1;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  if (p->ku.k.i2)
+    return (void *)_scheme_apply_wp(rator, num_rands, rands, p);
+  else
+    return (void *)_scheme_apply_multi_wp(rator, num_rands, rands, p);
+}
+
+static Scheme_Object *
+_apply(Scheme_Object *rator, int num_rands, Scheme_Object **rands, int multi
+#ifdef MZ_REAL_THREADS
+	     , Scheme_Process *p
+#endif
+	     )
+{
+#ifndef MZ_REAL_THREADS
+  Scheme_Process *p = scheme_current_process;
+#endif
+
+  p->ku.k.p1 = rator;
+  p->ku.k.p2 = rands;
+  p->ku.k.i1 = num_rands;
+  p->ku.k.i2 = multi;
+
+  return (Scheme_Object *)scheme_top_level_do(apply_k);
+}
+
+
+#ifndef MZ_REAL_THREADS
+Scheme_Object *
+scheme_apply(Scheme_Object *rator, int num_rands, Scheme_Object **rands)
+#else
+Scheme_Object *
+scheme_apply_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+		Scheme_Process *p)
+#endif
+{
+  return _apply(rator, num_rands, rands, 0
+#ifdef MZ_REAL_THREADS
+		, p
+#endif
+		);
+}
+
+#ifndef MZ_REAL_THREADS
+Scheme_Object *
+scheme_apply_multi(Scheme_Object *rator, int num_rands, Scheme_Object **rands)
+#else
+Scheme_Object *
+scheme_apply_multi_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+		      Scheme_Process *p)
+#endif
+{
+  return _apply(rator, num_rands, rands, 1
+#ifdef MZ_REAL_THREADS
+		, p
+#endif
+		);
+}
+
+ 
+Scheme_Object *
+scheme_tail_apply (Scheme_Object *rator, int num_rands, Scheme_Object **rands)
+{
+  int i;
+  Scheme_Process *p = scheme_current_process;
+
+  p->ku.apply.tail_rator = rator;
+  p->ku.apply.tail_num_rands = num_rands;
+  
+  if (num_rands) {
+    Scheme_Object **a;
+    if (num_rands > p->tail_buffer_size) {
+      p->tail_buffer_size = num_rands;
+      p->tail_buffer = 
+	(Scheme_Object **)scheme_malloc(num_rands * sizeof(Scheme_Object *));
+    }
+    a = p->tail_buffer;
+    p->ku.apply.tail_rands = a;
+    for (i = num_rands; i--; )
+      a[i] = rands[i];
+
+#ifdef AGRESSIVE_ZERO_TB
+    p->tail_buffer_set = num_rands;
+#endif
+  } else
+    p->ku.apply.tail_rands = NULL;
+
+  return SCHEME_TAIL_CALL_WAITING;
+}
+
+Scheme_Object *
+scheme_tail_apply_no_copy (Scheme_Object *rator, int num_rands, 
+			   Scheme_Object **rands)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  p->ku.apply.tail_rator = rator;
+  p->ku.apply.tail_num_rands = num_rands;
+  p->ku.apply.tail_rands = rands;
+
+  return SCHEME_TAIL_CALL_WAITING;
+}
+
+static
+Scheme_Object *
+X_scheme_apply_to_list(Scheme_Object *rator, Scheme_Object *rands, int force,
+		       int top_level, Scheme_Object *macro_apply)
+{
+  int num_rands, i;
+  Scheme_Object **rands_vec;
+
+  num_rands = scheme_list_length(rands);
+  rands_vec = (Scheme_Object **)scheme_malloc(num_rands 
+					      * sizeof(Scheme_Object *));
+
+  if (macro_apply) {
+    /* Check arity now so we can give the right error message: */
+    if (SCHEME_FALSEP(get_or_check_arity(rator, num_rands)))
+      scheme_wrong_syntax("macro application", NULL, macro_apply, 
+			  "bad syntax (wrong number of parts)");
+  }
+
+  for (i = 0; i < num_rands ; i++) {
+    if (!SCHEME_PAIRP(rands)) {
+      if (macro_apply)
+	scheme_wrong_syntax("macro application", NULL, macro_apply, 
+			    "bad syntax (" IMPROPER_LIST_FORM ")");
+      else
+	scheme_signal_error("bad application form");
+    }
+    rands_vec[i] = SCHEME_CAR (rands);
+    rands = SCHEME_CDR (rands);
+  }
+  
+  if (top_level)  {
+    if (force)
+      return scheme_apply(rator, num_rands, rands_vec);
+    else
+      return scheme_tail_apply(rator, num_rands, rands_vec);
+  } else {
+    if (force)
+      return _scheme_apply(rator, num_rands, rands_vec);
+    else
+      return _scheme_tail_apply(rator, num_rands, rands_vec);
+  }
+}
+
+Scheme_Object *
+scheme_apply_to_list (Scheme_Object *rator, Scheme_Object *rands)
+{
+  return X_scheme_apply_to_list(rator, rands, 1, 1, NULL);
+}
+
+Scheme_Object *
+scheme_tail_apply_to_list (Scheme_Object *rator, Scheme_Object *rands)
+{
+  return X_scheme_apply_to_list(rator, rands, 0, 1, NULL);
+}
+
+Scheme_Object *
+_scheme_apply_to_list (Scheme_Object *rator, Scheme_Object *rands)
+{
+  return X_scheme_apply_to_list(rator, rands, 1, 0, NULL);
+}
+
+Scheme_Object *
+_scheme_tail_apply_to_list (Scheme_Object *rator, Scheme_Object *rands)
+{
+  return X_scheme_apply_to_list(rator, rands, 0, 0, NULL);
+}
+
+Scheme_Object *
+scheme_apply_macro_to_list(Scheme_Object *rator, Scheme_Object *rands,
+			   Scheme_Object *code)
+{
+  return X_scheme_apply_to_list(rator, rands, 1, 1, code);
+}
+
+/* locals */
+
+static Scheme_Object *
+procedure_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_PROCP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *primitive_p(int argc, Scheme_Object *argv[])
+{
+  int isprim;
+
+  if (SCHEME_PRIMP(argv[0]))
+    isprim = (((Scheme_Primitive_Proc *)argv[0])->flags & SCHEME_PRIM_IS_PRIMITIVE);
+  else if (SCHEME_CLSD_PRIMP(argv[0]))
+    isprim = (((Scheme_Closed_Primitive_Proc *)argv[0])->flags & SCHEME_PRIM_IS_PRIMITIVE);
+  else
+    isprim = 0;
+
+  return isprim ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *primitive_closure_p(int argc, Scheme_Object *argv[])
+{
+  int isprim;
+
+  if (SCHEME_CLSD_PRIMP(argv[0]))
+    isprim = (((Scheme_Closed_Primitive_Proc *)argv[0])->flags & SCHEME_PRIM_IS_PRIMITIVE);
+  else
+    isprim = 0;
+
+  return isprim ? scheme_true : scheme_false;
+}
+
+
+static Scheme_Object *primitive_name(int argc, Scheme_Object *argv[])
+{
+  const char *s;
+  Scheme_Object *o;
+
+  o = argv[0];
+
+  if (SCHEME_PRIMP(o)
+      && (((Scheme_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_PRIMITIVE))
+    s = ((Scheme_Primitive_Proc *)o)->name;
+  else if (SCHEME_CLSD_PRIMP(o)
+	   && (((Scheme_Closed_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_PRIMITIVE))
+    s = ((Scheme_Closed_Primitive_Proc *)o)->name;
+  else {
+    scheme_wrong_type("primitive-name", "primitive", 0, argc, argv);
+    s = NULL;
+  }
+
+  if (!s) s = "UNKNOWN";
+
+  return scheme_make_string(s);
+}
+
+const char *scheme_get_proc_name(Scheme_Object *p, int *len, int for_error)
+{
+  Scheme_Type type;
+  int dummy;
+  char *s;
+
+  if (!len)
+    len = &dummy;
+
+  type = SCHEME_TYPE(p);
+  if (type == scheme_prim_type) {
+    *len = strlen(((Scheme_Primitive_Proc *)p)->name);
+    return ((Scheme_Primitive_Proc *)p)->name;
+  } else if (type == scheme_closed_prim_type) {
+    *len = strlen(((Scheme_Closed_Primitive_Proc *)p)->name);
+    return ((Scheme_Closed_Primitive_Proc *)p)->name;
+  } else if (type == scheme_cont_type || type == scheme_escaping_cont_type) {
+    return NULL;
+  } else if (type == scheme_case_closure_type) {
+    Scheme_Case_Lambda *seq;
+
+    seq = (Scheme_Case_Lambda *)p;
+    if (seq->name) {
+      *len = SCHEME_SYM_LEN(seq->name);
+      s = SCHEME_SYM_VAL(seq->name);
+    } else
+      return NULL;
+  } else {
+    Scheme_Closure_Compilation_Data *data;
+
+    data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(p);
+    if (data->name) {
+      *len = SCHEME_SYM_LEN(data->name);
+      s = SCHEME_SYM_VAL(data->name);
+    } else
+      return NULL;
+  }
+
+  if (for_error) {
+    char *r;
+    
+    r = (char *)scheme_malloc_atomic(*len + 11);
+    memcpy(r, "procedure ", 10);
+    memcpy(r + 10, s, *len + 1);
+    *len += 11;
+
+    return r;
+  }
+
+  return s;
+}
+
+static Scheme_Object *primitive_result_arity(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o;
+
+  o = argv[0];
+
+  if (SCHEME_PRIMP(o)
+      && (((Scheme_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_PRIMITIVE)) {
+    if (((Scheme_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_MULTI_RESULT) {
+      Scheme_Prim_W_Result_Arity *p = (Scheme_Prim_W_Result_Arity *)o;
+      return scheme_make_arity(p->minr, p->maxr);
+    }
+  } else if (SCHEME_CLSD_PRIMP(o)
+	     && (((Scheme_Closed_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_PRIMITIVE)) {
+    if (((Scheme_Closed_Primitive_Proc *)o)->flags & SCHEME_PRIM_IS_MULTI_RESULT) {
+      Scheme_Closed_Prim_W_Result_Arity *p = (Scheme_Closed_Prim_W_Result_Arity *)o;
+      return scheme_make_arity(p->minr, p->maxr);
+    }
+  } else {
+    scheme_wrong_type("primitive-result_arity", "primitive", 0, argc, argv);
+    return NULL;
+  }
+
+  return scheme_make_integer(1);
+}
+
+static Scheme_Object *syntax_p(int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_SYNTAXP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *macro_p(int argc, Scheme_Object *argv[])
+{
+  return (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_macro_type) 
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *id_macro_p(int argc, Scheme_Object *argv[])
+{
+  return (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_id_macro_type) 
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *exp_time_p(int argc, Scheme_Object *argv[])
+{
+  return (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_exp_time_type) 
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *inferred_name(int argc, Scheme_Object **argv)
+{
+  const char *s;
+  int len;
+  Scheme_Type type;
+
+  if (SCHEME_PROCP(argv[0])) {
+    s = scheme_get_proc_name(argv[0], &len, 0);
+  } else {
+    type = SCHEME_TYPE(argv[0]);
+    
+    switch(type) {
+    case scheme_class_type:
+      s = scheme_get_class_name(argv[0], &len);
+      break;
+    case scheme_interface_type:
+      s = scheme_get_interface_name(argv[0], &len);
+      break;
+    case scheme_unit_type:
+      s = scheme_get_unit_name(argv[0], &len);
+      break;
+    default:
+      return scheme_false;
+    }
+  }
+
+  if (!s)
+    return scheme_false;
+  else
+    return scheme_intern_exact_symbol(s, len);
+}
+
+Scheme_Object *scheme_make_arity(short mina, short maxa)
+{
+  if (mina == maxa)
+    return scheme_make_integer(mina);
+  else if (maxa == -1) {
+    Scheme_Object *p[1];
+    p[0] = scheme_make_integer(mina);
+    return scheme_make_struct_instance(scheme_arity_at_least, 1, p);
+  } else {
+    int i;
+    Scheme_Object *l = scheme_null;
+
+    for (i = maxa; i >= mina; --i)
+      l = scheme_make_pair(scheme_make_integer(i), l);
+
+    return l;
+  }
+}
+
+static Scheme_Object *get_or_check_arity(Scheme_Object *p, long a)
+/* a == -1 => get arity
+   a == -2 => check for allowing varargs */
+{
+  Scheme_Type type;
+  short mina, maxa;
+
+  type = SCHEME_TYPE(p);
+  if (type == scheme_prim_type) {
+    mina = ((Scheme_Primitive_Proc *)p)->mina;
+    maxa = ((Scheme_Primitive_Proc *)p)->maxa;
+  } else if (type == scheme_closed_prim_type) {
+    mina = ((Scheme_Closed_Primitive_Proc *)p)->mina;
+    maxa = ((Scheme_Closed_Primitive_Proc *)p)->maxa;
+
+    if (mina == -2) {
+      short *cases = ((Scheme_Closed_Case_Primitive_Proc *)p)->cases;
+      int count = -maxa, i;
+
+      if (a == -1) {
+	Scheme_Object *arity = scheme_alloc_list(count), *a;
+	
+	for (i = 0, a = arity; i < count; i++, a = SCHEME_CDR(a))
+	  SCHEME_CAR(a) = scheme_make_arity(cases[2 * i], cases[(2 * i) + 1]);
+
+	return arity;
+      }
+
+      if (a == -2) {
+	for (i = 0; i < count; i++)
+	  if (cases[(2 * i) + 1] < 0)
+	    return scheme_true;
+
+	return scheme_false;
+      }
+
+      for (i = 0; i < count; i++) {
+	int na, xa;
+	na = cases[2 * i];
+	xa = cases[(2 * i) + 1];
+	if ((a >= na) && ((xa < 0) || (a <= xa)))
+	  return scheme_true;
+      }
+
+      return scheme_false;
+    }    
+  } else if (type == scheme_cont_type || type == scheme_escaping_cont_type) {
+    mina = 0;
+    maxa = -1;
+  } else if (type == scheme_case_closure_type) {
+    Scheme_Case_Lambda *seq;
+    Scheme_Closure_Compilation_Data *data;
+    int i;
+    Scheme_Object *first, *last = NULL, *v;
+
+    if (a == -1)
+      first = scheme_null;
+    else
+      first = scheme_false;
+
+    seq = (Scheme_Case_Lambda *)p;
+    for (i = 0; i < seq->count; i++) {
+      data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(seq->array[i]);
+      mina = maxa = data->num_params;
+      if (data->flags & CLOS_HAS_REST) {
+	--mina;
+	maxa = -1;
+      } 
+
+      if (a >= 0) {
+	if (a >= mina && (maxa < 0 || a <= maxa))
+	  return scheme_true;
+      } else if (a == -2) {
+	if (maxa < 0)
+	  return scheme_true;
+      } else {
+	v = scheme_make_pair(scheme_make_arity(mina, maxa), scheme_null);
+	if (!last)
+	  first = v;
+	else
+	  SCHEME_CDR(last) = v;
+	last = v;
+      }
+    }
+
+    return first;
+  } else {
+    Scheme_Closure_Compilation_Data *data;
+
+    data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(p);
+    mina = maxa = data->num_params;
+    if (data->flags & CLOS_HAS_REST) {
+      --mina;
+      maxa = -1;
+    }
+  }
+
+  if (a == -1)
+    return scheme_make_arity(mina, maxa);
+
+  if (a == -2)
+    return (maxa < 0) ? scheme_true : scheme_false;
+
+  if (a < mina || (maxa >= 0 && a > maxa))
+    return scheme_false;
+
+  return scheme_true;
+}
+
+int scheme_check_proc_arity(const char *where, int a,
+			     int which, int argc, Scheme_Object **argv)
+{
+  Scheme_Object *p;
+
+  if (which < 0)
+    p = argv[0];
+  else
+    p = argv[which];
+
+  if (!SCHEME_PROCP(p) || SCHEME_FALSEP(get_or_check_arity(p, a))) {
+    if (where) {
+      char buffer[50];
+      
+      sprintf(buffer, "procedure (arity %d)", a);
+      
+      scheme_wrong_type(where, buffer, which, argc, argv);
+    } else
+      return 0;
+  }
+
+  return 1;
+}
+
+Scheme_Object *scheme_arity(Scheme_Object *p)
+{
+  return get_or_check_arity(p, -1);
+}
+
+static Scheme_Object *arity(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_PROCP(argv[0]))
+    scheme_wrong_type("arity", "procedure", 0, argc, argv);
+  
+  return get_or_check_arity(argv[0], -1);
+}
+
+static Scheme_Object *procedure_arity_includes(int argc, Scheme_Object *argv[])
+{
+  long n;
+
+  if (!SCHEME_PROCP(argv[0]))
+    scheme_wrong_type("procedure-arity-includes?", "procedure", 0, argc, argv);
+
+  n = scheme_extract_index("procedure-arity-includes?", 1, argc, argv, -2);
+  
+  return get_or_check_arity(argv[0], n);
+}
+
+static Scheme_Object *
+apply(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *rands, *r;
+  Scheme_Object **rand_vec;
+  int i, num_rands;
+  Scheme_Process *p = scheme_current_process;
+
+  if (!SCHEME_PROCP(argv[0]))
+    scheme_wrong_type("apply", "procedure", 0, argc, argv);
+
+  rands = argv[argc-1];
+
+  num_rands = (argc - 2);
+  r = rands;
+  while (!SCHEME_NULLP(r)) {
+    if (!SCHEME_PAIRP(r))
+      scheme_wrong_type("apply", "proper list", argc - 1, argc, argv);
+    r = SCHEME_CDR(r);
+    num_rands++;
+  }
+  rand_vec = (Scheme_Object **)scheme_malloc(num_rands *
+					     sizeof(Scheme_Object *));
+
+  for (i = argc - 2; i--; )
+    rand_vec[i] = argv[i + 1];
+  
+  for (i = argc - 2; SCHEME_PAIRP(rands); i++, rands = SCHEME_CDR(rands))
+    rand_vec[i] = SCHEME_CAR(rands);
+
+  p->ku.apply.tail_rator = argv[0];
+  p->ku.apply.tail_rands = rand_vec;
+  p->ku.apply.tail_num_rands = num_rands;
+
+  return SCHEME_TAIL_CALL_WAITING;
+}
+
+static Scheme_Object *
+do_map(int argc, Scheme_Object *argv[], char *name, int make_result,
+       int and_mode, int or_mode)
+{
+  int i, size = 0, l;
+  int can_multi;
+  Scheme_Object *quick1[5], *quick2[5], **working;
+  Scheme_Object *pair, *v;
+  Scheme_Object *retfirst, *retlast = NULL;
+  Scheme_Object **args;
+
+  can_multi = (!make_result && !and_mode && !or_mode);
+
+  if (!SCHEME_PROCP(argv[0]))
+    scheme_wrong_type(name, "procedure", 0, argc, argv);
+
+  for (i = 1; i < argc; i++) {
+    if (!SCHEME_LISTP (argv[i]))
+      scheme_wrong_type(name, "list", i, argc, argv);
+
+    l = scheme_proper_list_length(argv[i]);
+
+    if (l < 0)
+      scheme_wrong_type(name, "proper list", i, argc, argv);
+    
+    if (i == 1)
+      size = l;
+    else if (size != l) {
+      char *argstr = scheme_make_args_string("", -1, argc, argv);
+
+      scheme_raise_exn(MZEXN_APPLICATION_LIST_SIZES, argv[i],
+		       "%s: all lists must have same size%s", 
+		       name, argstr);
+      return NULL;
+    }
+  }
+
+  if (SCHEME_FALSEP(get_or_check_arity(argv[0], argc - 1))) {
+    char *s = scheme_make_arity_expect_string(argv[0], argc - 1, NULL);
+
+    scheme_raise_exn(MZEXN_APPLICATION_MAP_ARITY, argv[0],
+		     scheme_make_integer(argc - 1),
+		     "%s: arity mismatch for %s", name, s);
+    return NULL;
+  }
+  
+  if (argc < 6) {
+    args = quick1;
+    working = quick2;
+  } else {
+    args = (Scheme_Object **)scheme_malloc((argc - 1) * sizeof(Scheme_Object *));
+    working = (Scheme_Object **)scheme_malloc((argc - 1) * sizeof(Scheme_Object *));
+  }
+
+  /* Copy argc into working array */
+  for (i = 1; i < argc ; i++)
+    working[i-1] = argv[i];
+
+  --argc;
+
+  if (make_result)
+    retfirst = retlast = scheme_null;
+  else if (and_mode)
+    retfirst = scheme_true;
+  else if (or_mode)
+    retfirst = scheme_false;
+  else
+    retfirst = scheme_void;
+
+  while (!SCHEME_NULLP(working[0])) {
+    /* collect args to apply */
+    for (i = 0; i < argc ; i++) {
+      args[i] = SCHEME_CAR(working[i]);
+      working[i] = SCHEME_CDR(working[i]);
+    }
+
+    if (can_multi)
+      v = _scheme_apply_multi(argv[0], argc, args);
+    else
+      v = _scheme_apply(argv[0], argc, args);
+    
+    if (make_result) {
+      pair = scheme_make_pair(v, scheme_null);
+      if (SCHEME_NULLP (retfirst))
+	retfirst = retlast = pair;
+      else {
+	SCHEME_CDR (retlast) = pair;
+	retlast = pair;
+      }
+    } else if (and_mode) {
+      if (SCHEME_FALSEP(v))
+	return scheme_false;
+      retfirst = v;
+    } else if (or_mode) {
+      if (SCHEME_TRUEP(v))
+	return v;
+    }
+  }
+
+  return retfirst;
+}
+
+static Scheme_Object *
+map (int argc, Scheme_Object *argv[])
+{
+  return do_map(argc, argv, "map", 1, 0, 0);
+}
+
+static Scheme_Object *
+for_each (int argc, Scheme_Object *argv[])
+{
+  return do_map(argc, argv, "for-each", 0, 0, 0);
+}
+
+static Scheme_Object *
+andmap(int argc, Scheme_Object *argv[])
+{
+  return do_map(argc, argv, "andmap", 0, 1, 0);
+}
+
+static Scheme_Object *
+ormap(int argc, Scheme_Object *argv[])
+{
+  return do_map(argc, argv, "ormap", 0, 0, 1);
+}
+
+static Scheme_Object *call_with_values(int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *v;
+
+  scheme_check_proc_arity("call-with-values", 0, 0, argc, argv);
+  if (!SCHEME_PROCP(argv[1]))
+    scheme_wrong_type("call-with-values", "procedure", 1, argc, argv);
+
+  v = _scheme_apply_multi(argv[0], 0, NULL);
+  if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+    /* Careful - get the ordering right! */
+    p->ku.apply.tail_num_rands = p->ku.multiple.count;
+    p->ku.apply.tail_rands = p->ku.multiple.array;
+  } else {
+    p->ku.apply.tail_num_rands = 1;
+    p->ku.apply.tail_rands = p->tail_buffer;
+    p->ku.apply.tail_rands[0] = v;
+#ifdef AGRESSIVE_ZERO_TB
+    p->tail_buffer_set = 1;
+#endif
+  }
+  
+  p->ku.apply.tail_rator = argv[1];
+
+  return SCHEME_TAIL_CALL_WAITING;
+}
+
+Scheme_Object *scheme_values(int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+  int i;
+  Scheme_Object **a;
+
+  if (argc == 1)
+    return argv[0];
+  p->ku.multiple.count = argc;
+  if (argc)
+    a = (Scheme_Object **)scheme_malloc(argc * sizeof(Scheme_Object *));
+  else
+    a = NULL;
+  p->ku.multiple.array = a;
+  
+  for (i = 0; i < argc; i++)
+    a[i] = argv[i];
+
+  return SCHEME_MULTIPLE_VALUES;
+}
+
+static void pre_call_ec(void *ec)
+{
+  SCHEME_CONT_HOME(ec) = scheme_current_process;
+}
+
+static void post_call_ec(void *ec)
+{
+  SCHEME_CONT_HOME(ec) = NULL;
+}
+
+static Scheme_Object *do_call_ec(void *ec)
+{
+  Scheme_Object *p[1], *f;
+
+  p[0] = (Scheme_Object *)ec;
+  f = SCHEME_CONT_VAL(ec);
+  SCHEME_CONT_VALS(ec) = NULL;
+
+  return _scheme_apply_multi(f, 1, p);
+}
+
+static Scheme_Object *handle_call_ec(void *ec)
+{
+  if (SCHEME_CONT_VAL(ec)) {
+    int n;
+    scheme_jumping_to_continuation = 0;
+#ifdef ERROR_ON_OVERFLOW
+    scheme_current_process->stack_overflow = 
+      ((Scheme_Escaping_Cont *)ec)->orig_overflow;
+#endif
+    n = SCHEME_CONT_NUM_VALS(ec);
+    if (n == 1)
+      return SCHEME_CONT_VAL(ec);
+    else
+      return scheme_values(n, SCHEME_CONT_VALS(ec));
+  } else
+    return NULL;
+}
+
+static Scheme_Object *
+call_ec (int argc, Scheme_Object *argv[])
+{
+  Scheme_Escaping_Cont *cont;
+
+  scheme_check_proc_arity("call-with-escaping-continuation", 1, 
+			  0, argc, argv);
+
+  cont = MALLOC_ONE_TAGGED(Scheme_Escaping_Cont);
+  cont->type = scheme_escaping_cont_type;
+  SCHEME_CONT_HOME(cont) = scheme_current_process;
+  cont->u.val = argv[0];
+#ifdef ERROR_ON_OVERFLOW
+  cont->orig_overflow = scheme_current_process->stack_overflow;
+#endif
+
+  return scheme_dynamic_wind(pre_call_ec, do_call_ec, post_call_ec,
+			     handle_call_ec, (void *)cont);
+}
+
+#define TOTAL_STACK_SIZE (sizeof(Scheme_Object*) * SCHEME_STACK_SIZE)
+
+static Scheme_Object *
+call_cc (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *ret;
+  Scheme_Cont *cont;
+  Scheme_Dynamic_Wind *dw;
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Saved_Stack *saved, *isaved, *csaved;
+  long size;
+  
+  scheme_check_proc_arity("call-with-current-continuation", 1, 
+			  0, argc, argv);
+
+  cont = MALLOC_ONE_TAGGED(Scheme_Cont);
+  cont->type = scheme_cont_type;
+  scheme_init_jmpup_buf(&cont->buf);
+  cont->ok = p->cc_ok;
+  cont->dw = p->dw;
+  cont->home = p;
+#ifdef ERROR_ON_OVERFLOW
+  cont->orig_overflow = p->stack_overflow;
+#else
+  cont->save_overflow = p->overflow;
+  memcpy(&cont->save_overflow_buf, &p->overflow_buf, sizeof(jmp_buf));
+#endif
+  cont->current_local_env = p->current_local_env;
+  scheme_save_env_stack_w_process(cont->ss, p);
+
+  /* Hide call/cc's arg off of stack */
+  p->ku.k.p1 = argv[0];
+  argv[0] = NULL;
+
+  /* Copy out stack: */
+  cont->runstack_copied = saved = MALLOC_ONE(Scheme_Saved_Stack);
+  size = p->runstack_size - (p->runstack - p->runstack_start);
+  saved->runstack_size = size;
+  saved->runstack_start = MALLOC_N(Scheme_Object*, size);
+  memcpy(saved->runstack_start, p->runstack, size * sizeof(Scheme_Object *));
+  isaved = saved;
+  for (csaved = p->runstack_saved; csaved; csaved = csaved->prev) {
+    isaved->prev = MALLOC_ONE(Scheme_Saved_Stack);
+    isaved = isaved->prev;
+    size = csaved->runstack_size - (csaved->runstack - csaved->runstack_start);
+    isaved->runstack_size = size;
+    isaved->runstack_start = MALLOC_N(Scheme_Object*, size);
+    memcpy(isaved->runstack_start, csaved->runstack, size * sizeof(Scheme_Object *));
+  }
+  isaved->prev = NULL;
+
+  memcpy(&cont->savebuf, &p->error_buf, sizeof(jmp_buf));
+
+  scheme_zero_unneeded_rands(p);
+
+  if (scheme_setjmpup(&cont->buf, p->cc_start)) {
+    Scheme_Object *result = cont->value;
+    cont->value = NULL;
+
+    p->current_local_env = cont->current_local_env;
+
+    /* For dynamic-winds after the "common" intersection
+       (see eval.c), execute the pre thunks. Make a list
+       of these first because they have to be done in the
+       inverse order of `prev' linkage. */
+    if (cont->dw) {
+      Scheme_Dynamic_Wind_List *dwl = NULL, *last = NULL;
+      
+      for (dw = cont->dw; dw != cont->common; dw = dw->prev) {
+	Scheme_Dynamic_Wind_List *cell;
+
+	cell = MALLOC_ONE(Scheme_Dynamic_Wind_List);
+	cell->dw = dw;
+	cell->next = NULL;
+
+	if (last)
+	  last->next = cell;
+	else
+	  dwl = cell;
+	last = cell;
+      }
+      for (; dwl; dwl = dwl->next)
+	if (dwl->dw->pre) {
+	  p->dw = dwl->dw->prev;
+	  dwl->dw->pre(dwl->dw->data);
+	}
+    }
+    p->dw = cont->dw;
+
+    memcpy(&p->error_buf, &cont->savebuf, sizeof(jmp_buf));
+
+#ifdef ERROR_ON_OVERFLOW
+    p->stack_overflow = cont->orig_overflow;
+#else
+    memcpy(&p->overflow_buf, &cont->save_overflow_buf, sizeof(jmp_buf));
+    p->overflow = cont->save_overflow;
+#endif
+    scheme_restore_env_stack_w_process(cont->ss, p);
+
+    /* Copy stack back in: (p->runstack and p->runstack_saved arrays
+       are already restored, so the shape is certainly the same as 
+       when cont->runstack_copied was made) */
+    isaved = cont->runstack_copied;
+    size = isaved->runstack_size;
+    p->runstack = p->runstack_start + (p->runstack_size - size);
+    memcpy(p->runstack, isaved->runstack_start, size * sizeof(Scheme_Object *));
+    for (csaved = p->runstack_saved; csaved; csaved = csaved->prev) {
+      isaved = isaved->prev;
+      size = isaved->runstack_size;
+      csaved->runstack = csaved->runstack_start + (csaved->runstack_size - size);
+      memcpy(csaved->runstack, isaved->runstack_start, size * sizeof(Scheme_Object *));
+    }
+
+    return result;
+  } else {
+    Scheme_Object *argv2[1];
+
+    /* Restore call/cc's arg to stack. */
+    /* (We aren't actually allowed to modify argv! :) */
+    argv[0] = p->ku.k.p1;
+    p->ku.k.p1 = NULL;
+
+    argv2[0] = (Scheme_Object *)cont;
+    ret = _scheme_tail_apply(argv[0], 1, argv2);
+    return ret;
+  }
+}
+
+typedef struct {
+  Scheme_Object *pre, *act, *post;
+} Dyn_Wind;
+
+static void pre_dyn_wind(void *d)
+{
+  Dyn_Wind *dw;
+  dw = (Dyn_Wind *)d;
+
+  (void)_scheme_apply_multi(dw->pre, 0, NULL);
+}
+
+static Scheme_Object *do_dyn_wind(void *d)
+{
+  Dyn_Wind *dw;
+  dw = (Dyn_Wind *)d;
+
+  return _scheme_apply_multi(dw->act, 0, NULL);
+}
+
+static void post_dyn_wind(void *d)
+{
+  Dyn_Wind *dw;
+  dw = (Dyn_Wind *)d;
+
+  (void)_scheme_apply_multi(dw->post, 0, NULL);
+}
+
+static Scheme_Object *dynamic_wind(int c, Scheme_Object *p[])
+{
+  Dyn_Wind *dw;
+
+  dw = MALLOC_ONE(Dyn_Wind);
+
+  dw->pre = p[0];
+  dw->act = p[1];
+  dw->post = p[2];
+
+  return scheme_dynamic_wind(pre_dyn_wind, do_dyn_wind, post_dyn_wind, NULL,
+			     (void *)dw);
+}
+ 
+Scheme_Object *scheme_dynamic_wind(void (*pre)(void *),
+				   Scheme_Object *(*act)(void *),
+				   void (*post)(void *), 
+				   Scheme_Object *(*jmp_handler)(void *),
+				   void *data)
+{
+  Scheme_Object *v, **save_values;
+  int err;
+  Scheme_Dynamic_Wind *dw;
+  int save_count;
+  Scheme_Process *p = scheme_current_process;
+
+  dw = MALLOC_ONE(Scheme_Dynamic_Wind);
+
+  dw->data = data;
+  dw->pre = pre;
+  dw->post = post;
+  dw->prev = p->dw;
+
+  if (pre)
+    pre(data);
+
+  p->dw = dw;
+
+  memcpy(&dw->saveerr, &scheme_error_buf, sizeof(jmp_buf));
+
+  scheme_save_env_stack_w_process(dw->envss, p);
+
+  dw->current_local_env = p->current_local_env;
+
+  if (scheme_setjmp(p->error_buf)) {
+    scheme_restore_env_stack_w_process(dw->envss, p);
+    p->current_local_env = dw->current_local_env;
+    if (jmp_handler)
+      v = jmp_handler(data);
+    else
+      v = NULL;
+    err = !v;
+  } else {
+    v = act(data);
+
+    err = 0;
+  }
+
+  if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+    save_count = p->ku.multiple.count;
+    save_values = p->ku.multiple.array;
+    p->ku.multiple.array = NULL;
+  } else {
+    save_count = 0;
+    save_values = NULL;
+  }
+
+  p->dw = dw->prev;
+
+  if (post) {
+    if (scheme_setjmp(p->error_buf)) {
+      scheme_restore_env_stack_w_process(dw->envss, p);
+      p->current_local_env = dw->current_local_env;
+      err = 1;
+    } else {
+      post(data);
+    }
+  }
+
+  if (err)
+    scheme_longjmp(dw->saveerr, 1);
+
+  memcpy(&p->error_buf, &dw->saveerr, sizeof(jmp_buf));
+
+  if (save_values) {
+    p->ku.multiple.count = save_count;
+    p->ku.multiple.array = save_values;
+    return SCHEME_MULTIPLE_VALUES;
+  }
+
+  return v;
+}
+
+static Scheme_Object *
+void_func (int argc, Scheme_Object *argv[])
+{
+  return scheme_void;
+}
+
+static Scheme_Object *
+is_void_func (int argc, Scheme_Object *argv[])
+{
+  return SAME_OBJ(argv[0], scheme_void) ? scheme_true : scheme_false;
+}
+
+#ifdef TIME_SYNTAX
+
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 1000000
+#endif
+
+long scheme_get_milliseconds(void)
+{
+#ifdef USE_FTIME
+  struct MSC_IZE(timeb) now;
+  MSC_IZE(ftime)(&now);
+  return now.time * 1000 + now.millitm;
+#else
+#ifdef USE_DIFFTIME
+  time_t now;
+  now = time(NULL);
+  return difftime(now, base_time) * 1000;
+#else
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return now.tv_sec * 1000 + now.tv_usec / 1000;
+#endif
+#endif
+}
+
+long scheme_get_process_milliseconds(void)
+{
+#ifdef USE_GETRUSAGE
+  struct rusage use;
+  long s, u;
+
+  getrusage(RUSAGE_SELF, &use);
+
+  s = use.ru_utime.tv_sec + use.ru_stime.tv_sec;
+  u = use.ru_utime.tv_usec + use.ru_stime.tv_usec;
+
+  return s * 1000 + u / 1000;
+#else
+  return clock()  * 1000 / CLOCKS_PER_SEC;
+#endif
+}
+
+static long get_seconds(void)
+{
+#ifdef USE_FTIME
+  struct MSC_IZE(timeb) now;
+  MSC_IZE(ftime)(&now);
+  return now.time;
+#else
+#ifdef USE_DIFFTIME
+  time_t now;
+  now = time(NULL);
+  return now;
+#else
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return now.tv_sec;
+#endif
+#endif
+}
+
+#ifdef TIME_TYPE_IS_UNSIGNED
+#define scheme_get_time_val(o, v) scheme_get_unsigned_int_val(o, v)
+#define UNBUNDLE_TIME_TYPE unsigned long
+#else
+#define scheme_get_time_val(o, v) scheme_get_int_val(o, v)
+#define UNBUNDLE_TIME_TYPE long
+#endif
+
+static Scheme_Object *seconds_to_date(int argc, Scheme_Object **argv)
+{
+  UNBUNDLE_TIME_TYPE lnow;
+  time_t now;
+  int hour, min, sec, month, day, year, wday, yday, dst;
+  struct tm *localTime;
+  Scheme_Object *p[9], *secs;
+
+  secs = argv[0];
+
+  if (!SCHEME_INTP(secs) && !SCHEME_BIGNUMP(secs)) {
+    scheme_wrong_type("seconds->date", "exact integer", 0, argc, argv);
+    return NULL;
+  }
+
+  if (scheme_get_time_val(secs, &lnow) 
+      && ((UNBUNDLE_TIME_TYPE)(now = (time_t)lnow)) == lnow) {
+    localTime = localtime(&now);
+    if (localTime) {
+      hour = localTime->tm_hour;
+      min = localTime->tm_min;
+      sec = localTime->tm_sec;
+      
+      month = localTime->tm_mon + 1;
+      day = localTime->tm_mday;
+      year = localTime->tm_year + 1900;
+      
+      wday = localTime->tm_wday;
+      yday = localTime->tm_yday;
+      
+      dst = localTime->tm_isdst;
+
+      p[0] = scheme_make_integer(sec);
+      p[1] = scheme_make_integer(min);
+      p[2] = scheme_make_integer(hour);
+      p[3] = scheme_make_integer(day);
+      p[4] = scheme_make_integer(month);
+      p[5] = scheme_make_integer(year);
+      p[6] = scheme_make_integer(wday);
+      p[7] = scheme_make_integer(yday);
+      p[8] = dst ? scheme_true : scheme_false;
+      
+      return scheme_make_struct_instance(scheme_date, 9, p);
+    }
+  }
+    scheme_wrong_type("seconds->date", "date-integer", 0, argc, argv);
+
+  scheme_raise_exn(MZEXN_APPLICATION_INTEGER,
+		   secs,
+		   "seconds->date: integer %s is out-of-range",
+		   scheme_make_provided_string(secs, 0, NULL));
+
+  return NULL;
+}
+
+static Scheme_Object *time_apply(int argc, Scheme_Object *argv[])
+{
+  long start, end;
+  long cpustart, cpuend;
+  long dur, cpudur;
+  Scheme_Object *v, *p[3];
+
+  scheme_check_proc_arity("time-apply", 0, 0, argc, argv);
+
+  start = scheme_get_milliseconds();
+  cpustart = scheme_get_process_milliseconds();
+  v = _scheme_apply_multi(argv[0], 0, NULL);
+  cpuend = scheme_get_process_milliseconds();
+  end = scheme_get_milliseconds();
+  
+  dur = end - start;
+  cpudur = cpuend - cpustart;
+
+  if (v == SCHEME_MULTIPLE_VALUES) {
+    Scheme_Process *p = scheme_current_process;
+    v = scheme_build_list(p->ku.multiple.count,
+			  p->ku.multiple.array);
+  } else
+    v = scheme_make_pair(v, scheme_null);
+
+  p[0] = v;
+  p[1] = scheme_make_integer(cpudur);
+  p[2] = scheme_make_integer(dur);
+
+  return scheme_values(3, p);
+}
+
+static Scheme_Object *current_milliseconds(int argc, Scheme_Object **argv)
+{
+  return scheme_make_integer(scheme_get_milliseconds());
+}
+
+static Scheme_Object *current_process_milliseconds(int argc, Scheme_Object **argv)
+{
+  return scheme_make_integer(scheme_get_process_milliseconds());
+}
+
+static Scheme_Object *current_gc_milliseconds(int argc, Scheme_Object **argv)
+{
+  return scheme_make_integer(scheme_total_gc_time);
+}
+
+static Scheme_Object *current_seconds(int argc, Scheme_Object **argv)
+{
+  return scheme_make_integer_value_from_time(get_seconds());
+}
+
+#endif
+
+
+/****************************************************************/
+
+static Scheme_Object *
+current_print(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("current-print", MZCONFIG_PRINT_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+current_prompt_read(int argc, Scheme_Object **argv)
+{
+  return scheme_param_config("current-prompt-read", MZCONFIG_PROMPT_READ_HANDLER,
+			     argc, argv,
+			     0, NULL, NULL, 0);
+}
+
+static Scheme_Object *
+default_print_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *obj = argv[0];
+
+  if (!SAME_OBJ(obj, scheme_void)) {
+    Scheme_Config *config = scheme_config;
+    Scheme_Object *port = scheme_get_param(config, MZCONFIG_OUTPUT_PORT);
+    Scheme_Object *argv[2];
+    
+    argv[0] = obj;
+    argv[1] = port;
+    _scheme_apply(scheme_print_proc, 2, argv);
+    scheme_write_string("\n", 1, port);
+  }
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+default_prompt_read_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Config *config = scheme_config;
+  Scheme_Object *port = scheme_get_param(config, MZCONFIG_OUTPUT_PORT);
+  Scheme_Object *inport = scheme_get_param(config, MZCONFIG_INPUT_PORT);
+
+  scheme_write_string("> ", 2, port);
+  scheme_flush_output(port);
+    
+  return scheme_read(inport);
+}
+
+
+/****************************************************************/
+
+void scheme_rep()
+{
+  jmp_buf save;
+  Scheme_Process *p = scheme_current_process;
+
+  memcpy(&save, &p->error_buf, sizeof(jmp_buf));
+  if (scheme_setjmp(p->error_buf)) {
+    /* done */
+  } else
+    scheme_apply(rep, 0, NULL);
+  memcpy(&p->error_buf, &save, sizeof(jmp_buf));
+}
+
+/****************************************************************/
+
+#define BOOL(x) (x ? scheme_true : scheme_false)
+
+static Scheme_Object *write_compiled_closure(Scheme_Object *obj)
+{
+  Scheme_Closure_Compilation_Data *data;
+
+  data = (Scheme_Closure_Compilation_Data *)obj;
+  
+  return CONS(scheme_make_integer(data->flags),
+	      CONS(scheme_make_integer(data->num_params),
+		   CONS(scheme_make_integer(data->max_let_depth),
+			CONS(data->name ? data->name : scheme_null,
+			     CONS(scheme_make_svector(data->closure_size,
+						      data->closure_map),
+				  data->code)))));
+}
+
+static Scheme_Object *read_compiled_closure(Scheme_Object *obj)
+{
+  Scheme_Closure_Compilation_Data *data;
+  Scheme_Object *v;
+
+#define BAD_CC "bad compiled closure"
+#define X_SCHEME_ASSERT(x, y)
+
+  data  = (Scheme_Closure_Compilation_Data *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Closure_Compilation_Data));
+
+  data->type = scheme_unclosed_procedure_type;
+
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  data->flags = SCHEME_INT_VAL(v);
+
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  data->num_params = SCHEME_INT_VAL(v);
+
+  data->max_let_depth = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->name = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  if (SCHEME_NULLP(data->name))
+    data->name = NULL;
+  
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  /* v is an svector */
+
+  data->code = obj;
+
+  data->closure_size = SCHEME_SVEC_LEN(v);
+  data->closure_map = SCHEME_SVEC_VEC(v);
+ 
+  scheme_end_stubborn_change((void *)data);
+
+  if (data->flags & CLOS_FOLDABLE)
+    data->flags -= CLOS_FOLDABLE;
+
+  if (SCHEME_TYPE(data->code) > _scheme_values_types_)
+    data->flags |= CLOS_FOLDABLE;
+
+  if (!data->closure_size)
+    return scheme_make_linked_closure(NULL, (Scheme_Object *)data, 0);
+
+  return (Scheme_Object *)data;
+}
diff --git a/src/mzscheme/src/hash.c b/src/mzscheme/src/hash.c
new file mode 100644
index 0000000..4b9cae7
--- /dev/null
+++ b/src/mzscheme/src/hash.c
@@ -0,0 +1,333 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <string.h>
+#include <ctype.h>
+#include <memory.h>
+
+#ifdef DOS_MEMORY
+#include <dos.h>
+
+#define PTR_TO_LONG(p) ((FP_SEG(p) << 4) + FP_OFF(p))
+#else
+#define PTR_TO_LONG(p) ((long)(p))
+#endif
+
+#ifdef SMALL_HASH_TABLES
+#define FILL_FACTOR 1.30
+#else
+#define FILL_FACTOR 2
+#endif
+
+int scheme_hash_primes[] = 
+{7, 31, 127, 257, 521, 1031, 2053, 4099, 8209, 16411, 
+   32779, 65543, 131101, 262147, 425329, 1048583, 2097169,
+   4194319, 8388617, 16777259, 33554467, 67108879, 134217757,
+   268435459, 536870923, 1073741827};
+
+static void string_hash_indices(void *_key, int *_h, int *_h2)
+{
+  const char *key = (char *)_key;
+  int i, h, h2;
+
+  h2 = h = i = 0;
+  while (key[i]) {
+    int c = key[i++];
+    if (!scheme_case_sensitive)
+      if (isupper(c))
+	c = tolower(c);
+    h += (h << 5) + h + c;
+    h2 += c;
+  }
+
+  *_h = h;
+  *_h2 = h2;
+}
+
+Scheme_Hash_Table *
+scheme_hash_table (int size, int type, int has_const, int forever)
+{
+  Scheme_Hash_Table *table;
+  size_t asize;
+
+  table = MALLOC_ONE_TAGGED(Scheme_Hash_Table);
+
+  table->step = 0;
+  while (scheme_hash_primes[table->step] < size)
+    table->step++;
+  table->size = scheme_hash_primes[table->step];
+
+  table->count = 0;
+
+  table->type = scheme_hash_table_type;
+
+  asize = (size_t)table->size * sizeof(Scheme_Bucket *);
+  if (forever) {
+    table->buckets = (Scheme_Bucket **)scheme_malloc_atomic(asize);
+    memset((char *)table->buckets, 0, asize);
+  } else
+    table->buckets = (Scheme_Bucket **)scheme_malloc(asize);
+
+  table->has_constants = has_const;
+  table->forever = forever;
+  table->weak = (type == SCHEME_hash_weak_ptr);
+
+  if (type == SCHEME_hash_string) {
+    table->make_hash_indices = string_hash_indices;
+    table->compare = (int (*)(void*, void*))strcmp;
+  }
+
+#ifdef MZ_REAL_THREADS
+  table->mutex = SCHEME_MAKE_MUTEX();
+#endif
+
+  return table;
+}
+
+typedef int hash_v_t;
+
+static Scheme_Bucket *
+get_bucket (Scheme_Hash_Table *table, const char *key, int add, Scheme_Bucket *b)
+{
+  hash_v_t h, h2;
+  Scheme_Bucket *bucket;
+
+ rehash_key:
+
+  if (table->make_hash_indices) {
+    table->make_hash_indices((void *)key, &h, &h2);
+    h = h % table->size;
+    h2 = h2 % table->size;
+  } else {
+    h = (PTR_TO_LONG(key) >> 2) % table->size;
+    h2 = (PTR_TO_LONG(key) >> 3) % table->size;
+  }
+
+  if (h < 0) h = -h;
+  if (h2 < 0) h2 = -h2;
+  
+  if (!h2)
+    h2 = 2;
+  else if (h2 & 0x1)
+    h2++;
+
+  if (table->weak) {
+    while ((bucket = table->buckets[h])) {
+      if (bucket->key) {
+	void *hk = *(void **)bucket->key;
+	if (!hk) {
+	  /* Re-use a bucket slot whose key is collected: */
+	  /* DON'T increment counter overall... */
+	  --table->count;
+	  break;
+	} else if (SAME_PTR(hk, key))
+	  return bucket;
+      } else if (add)
+	break;
+      h = (h + h2) % table->size;
+    }
+  } else if (table->compare) {
+    while ((bucket = table->buckets[h])) {
+      if (!table->compare(bucket->key, (char *)key))
+	return bucket;
+      h = (h + h2) % table->size;
+    }
+  } else {
+    while ((bucket = table->buckets[h])) {
+      if (SAME_PTR(bucket->key, key))
+	return bucket;
+      h = (h + h2) % table->size;
+    }
+  }
+
+  if (!add)
+    return NULL;
+
+  if (table->count * FILL_FACTOR >= table->size) {
+    /* Rehash */
+    int i, oldsize = table->size;
+    size_t asize;
+    Scheme_Bucket **old = table->buckets;
+
+    table->size = scheme_hash_primes[++table->step];
+    
+    asize = (size_t)table->size * sizeof(Scheme_Bucket *);
+    if (table->forever) {
+      table->buckets = (Scheme_Bucket **)scheme_malloc_atomic(asize);
+      memset((char *)table->buckets, 0, asize);
+    } else
+      table->buckets = (Scheme_Bucket **)scheme_malloc(asize);
+
+    table->count = 0;
+    if (table->weak) {
+      for (i = 0; i < oldsize; i++)
+	if (old[i] && old[i]->key && *(void **)old[i]->key)
+	  get_bucket(table, *(char **)old[i]->key, 1, old[i]);
+    } else {
+      for (i = 0; i < oldsize; i++)
+	if (old[i] && old[i]->key)
+	  get_bucket(table, 
+		     table->weak ? *(char **)old[i]->key : old[i]->key, 
+		     1, old[i]);
+    }
+
+    goto rehash_key;
+  }
+
+  if (b) {
+    bucket = b;
+  } else {
+    size_t bsize;
+
+    if (!table->has_constants)
+      bsize = sizeof(Scheme_Bucket);
+    else if (table->has_constants == 2)
+      bsize = sizeof(Scheme_Bucket_With_Ref_Id);
+    else
+      bsize = sizeof(Scheme_Bucket_With_Const_Flag);
+
+    if (table->forever)
+      bucket = (Scheme_Bucket *)scheme_malloc_uncollectable_tagged(bsize);
+    else
+      bucket = (Scheme_Bucket *)scheme_malloc_tagged(bsize);
+
+    bucket->type = scheme_variable_type;
+
+    if (table->has_constants)
+      ((Scheme_Bucket_With_Const_Flag *)bucket)->flags = 0;
+
+    if (table->weak) {
+      bucket->key = (char *)scheme_malloc_atomic(sizeof(void *));
+      *(void **)bucket->key = (void *)key;
+      scheme_weak_reference_indirect((void **)bucket->key, (void *)key);
+      scheme_weak_reference_indirect((void **)&bucket->val, (void *)key);
+    } else
+      bucket->key = (char *)key;
+    bucket->val = NULL;
+  }
+
+  table->buckets[h] = bucket;
+
+  table->count++;
+
+  return bucket;
+}
+
+Scheme_Bucket *
+scheme_bucket_or_null_from_table (Scheme_Hash_Table *table, const char *key, int add)
+{
+  Scheme_Bucket *b;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(table->mutex);
+#endif
+
+  b = get_bucket(table, key, add, NULL);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(table->mutex);
+#endif
+
+  return b;
+}
+
+Scheme_Bucket *
+scheme_bucket_from_table (Scheme_Hash_Table *table, const char *key)
+{
+  return scheme_bucket_or_null_from_table(table, key, 1);
+}
+
+void 
+scheme_add_to_table (Scheme_Hash_Table *table, const char *key, void *val, 
+		     int constant)
+{
+  Scheme_Bucket *b;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(table->mutex);
+#endif
+
+  b = get_bucket(table, key, 1, NULL);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(table->mutex);
+#endif
+
+  if (table->has_constants
+      && (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST)
+      && b->val)
+    scheme_raise_exn(MZEXN_MISC_CONSTANT, key,
+		     "define: cannot redefine constant %s", 
+		     scheme_symbol_name((Scheme_Object *)key));
+
+  if (val)
+    b->val = val;
+  if (constant && table->has_constants)
+    ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_IS_CONST;
+}
+
+void scheme_add_bucket_to_table(Scheme_Hash_Table *table, Scheme_Bucket *b)
+{
+  get_bucket(table, table->weak ? *(char **)b->key : b->key, 1, b);
+}
+
+void *
+scheme_lookup_in_table (Scheme_Hash_Table *table, const char *key)
+{
+  Scheme_Bucket *bucket;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(table->mutex);
+#endif
+
+  bucket = get_bucket(table, key, 0, NULL);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(table->mutex);
+#endif
+
+  if (bucket)
+    return bucket->val;
+  else
+    return NULL;
+}
+
+void
+scheme_change_in_table (Scheme_Hash_Table *table, const char *key, void *naya)
+{
+  Scheme_Bucket *bucket;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(table->mutex);
+#endif
+
+  bucket = get_bucket(table, key, 0, NULL);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(table->mutex);
+#endif
+
+  if (bucket)
+    bucket->val = naya;
+}
diff --git a/src/mzscheme/src/image.c b/src/mzscheme/src/image.c
new file mode 100644
index 0000000..30c217a
--- /dev/null
+++ b/src/mzscheme/src/image.c
@@ -0,0 +1,753 @@
+/*
+  MzScheme
+  Copyright (c) 1995-97 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+#ifdef UNIX_IMAGE_DUMPS
+#include "schmach.h"
+#include "schvers.h"
+#ifdef FILES_HAVE_FDS
+# include <sys/types.h>
+# include <sys/time.h>
+# ifdef SELECT_INCLUDE
+#  include <sys/select.h>
+# endif
+#endif
+#ifndef NO_USER_BREAK_HANDLER
+# include <signal.h>
+#endif
+#ifdef UNISTD_INCLUDE
+# include <unistd.h>
+#endif
+#include <ctype.h>
+#ifdef UNIX_IMAGE_DUMPS
+# include "schgc.h"
+#endif
+
+extern void *GC_get_stack_base();
+#endif
+
+int (*scheme_actual_main)(int argc, char **argv);
+
+static Scheme_Object *(*scheme_dump_heap)(char *filename) = NULL;
+static Scheme_Object *(*scheme_load_heap)(char *filename, Scheme_Object *argvec) = NULL;
+
+static char *no_dumps;
+extern int scheme_file_open_count;
+#ifdef UNIX_PROCESSES
+extern void *scheme_system_children;
+#endif
+
+static Scheme_Object *dump_heap(int argc, Scheme_Object **argv);
+static Scheme_Object *load_heap(int argc, Scheme_Object **argv);
+
+void scheme_init_image(Scheme_Env *env)
+{
+  scheme_add_global_constant("write-image-to-file", 
+			     scheme_make_prim_w_arity(dump_heap,
+						      "write-image-to-file",
+						      1, 2),
+			     env);
+  scheme_add_global_constant("read-image-from-file", 
+			     scheme_make_prim_w_arity(load_heap,
+						      "read-image-from-file",
+						      2, 2),
+			     env);
+}
+
+void scheme_no_dumps(char *why)
+{
+  if (why && !no_dumps)
+    no_dumps = why;
+}
+
+static Scheme_Object *dump_heap(int argc, Scheme_Object **argv)
+{
+  char *filename;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("write-image-to-file", "string", 0, argc, argv);
+  if (argc > 1)
+    if (!SCHEME_FALSEP(argv[1]))
+      scheme_check_proc_arity("write-image-to-file", 0,
+			      1, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]), 
+				    SCHEME_STRTAG_VAL(argv[0]), 
+				    "write-image-to-file", NULL);
+
+  if (scheme_dump_heap) {
+    if (no_dumps) {
+      scheme_raise_exn(MZEXN_MISC_IMAGE,
+		       scheme_make_string(filename),
+		       "write-image-to-file: image cannot be saved; %s", 
+		       no_dumps);
+      return NULL;
+    } else if (scheme_file_open_count) {
+      scheme_raise_exn(MZEXN_MISC_IMAGE,
+		       scheme_make_string(filename),
+		       "write-image-to-file: a file, process, or TCP port is open (%d)",
+		       scheme_file_open_count);
+      return NULL;
+#ifdef UNIX_FILE_SYSTEM
+    } else if (scheme_system_children) {
+      scheme_raise_exn(MZEXN_MISC_IMAGE,
+		       scheme_make_string(filename),
+		       "write-image-to-file: a subprocess is still active");
+      return NULL;
+#endif
+    } else {
+      Scheme_Object *v = scheme_dump_heap(filename);
+      if (!v) {
+	if (argc > 1) {
+	  if (SCHEME_FALSEP(argv[1]))
+	    exit(0);
+	  else
+	    return _scheme_tail_apply(argv[1], 0, NULL);
+	} else
+	  return scheme_void;
+      } else
+	return v;
+    }
+  } else {
+    scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		     "write-image-to-file: not supported");
+    return NULL;
+  }
+}
+
+static Scheme_Object *load_heap(int argc, Scheme_Object **argv)
+{
+  char *filename;
+  int bad = 0;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("read-image-from-file", "string", 0, argc, argv);
+
+  if (SCHEME_VECTORP(argv[1])) {
+    Scheme_Object **a;
+    int i;
+
+    a = SCHEME_VEC_ELS(argv[1]);
+    for (i = SCHEME_VEC_SIZE(argv[1]); i--; )
+      if (!SCHEME_STRINGP(a[i])) {
+	bad = 1;
+	break;
+      }
+  } else
+    bad = 1;
+      
+  if (bad)
+    scheme_wrong_type("read-image-from-file", "vector of strings", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]), 
+				    SCHEME_STRTAG_VAL(argv[0]), 
+				    "read-image-from-file", NULL);
+
+  if (scheme_load_heap)
+    scheme_load_heap(filename, argv[1]);
+  else
+    scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		     "read-image-from-file: not supported");
+
+  return NULL;
+}
+
+/******************************************************************************/
+
+#ifdef UNIX_IMAGE_DUMPS
+
+/* XXX_SKIP_PLT makes images sortof work for dynamically-linked programs */
+
+#if defined(sun) && defined(ECHRNG)
+# define SOLARIS_SKIP_PLT
+#endif
+
+#if defined(__FreeBSD__)
+# define FREEBSD_SKIP_PLT
+#endif
+
+static char *restore_brk;
+
+static unsigned long stack_base;
+static unsigned long orig_brk;
+static int data_count;
+static unsigned long *data_starts;
+static unsigned long *data_ends;
+typedef unsigned long ptr_t;
+typedef unsigned long word;
+
+static Scheme_Jumpup_Buf **restore_launch_ubuf;
+
+extern char **environ;
+
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/param.h>
+
+#include "../gc/config.h"
+
+static void die_now(char *phase, char *file)
+{
+  printf("Restore from \"%s\" failed at %s (%d).\n", file, phase, errno);
+  exit(-1);
+}
+
+#if defined(linux) || defined(__FreeBSD__)
+# define FIND_WRITEABLE_SECTION
+#endif
+
+#ifdef FIND_WRITEABLE_SECTION
+static unsigned long current_value;
+static jmp_buf goback;
+
+static void bus_error(int ignore)
+{
+  longjmp(goback, 1);
+}
+#endif
+
+static void  do_restore_env_argv(long orig_len, long len, 
+				 char *start, char *carry, jmp_buf b)
+{
+  char buffer[1024];
+
+  if (len < 0) {
+    long l, i;
+    Scheme_Object *v;
+
+    FLUSH_REGISTER_WINDOWS;
+
+    if ((unsigned long)carry < (unsigned long)start)
+      start = carry;
+
+    memcpy(start, restore_brk + sizeof(long), orig_len);
+    brk(restore_brk);
+
+    l = *(long *)start;
+    start += sizeof(long);
+    environ = malloc(sizeof(char *) * (l + 1));
+    environ[l] = NULL;
+    for (i = 0; i < l; i++) {
+      int l = strlen(start);
+      environ[i] = malloc(l + 1);
+      memcpy(environ[i], start, l + 1);
+      start += l + 1;
+    }
+
+    /* align for long */
+    if ((long)start & (sizeof(long) - 1))
+      start += (sizeof(long) - ((long)start & (sizeof(long) - 1)));
+
+    l = *(long *)start;
+    start += sizeof(long);
+    v = scheme_make_vector(l, scheme_null);
+    for (i = 0; i < l; i++) {
+      SCHEME_VEC_ELS(v)[i] = scheme_make_string(start);
+      start += strlen(start) + 1;
+    }
+
+    longjmp(b, (long)v);
+  } else
+    do_restore_env_argv(orig_len, len - 1024, 
+			start ? start : buffer, buffer, b);
+}
+
+static Scheme_Object *restore_env_argv(long len)
+{
+  jmp_buf buf;
+  Scheme_Object *v;
+
+  /* We're going to trash the stack, so we'll need to escape */
+  v = (Scheme_Object *)setjmp(buf);
+  
+  if (!v)
+    do_restore_env_argv(len, len, NULL, NULL, buf);
+
+  return v;
+}
+
+static Scheme_Object *dump_image(char *filename)
+{
+  Scheme_Jumpup_Buf *buf;
+  Scheme_Object *v;
+
+  buf = (Scheme_Jumpup_Buf *)scheme_malloc(sizeof(Scheme_Jumpup_Buf));
+  scheme_init_jmpup_buf(buf);
+
+  if (!scheme_setjmpup(buf, (void *)stack_base)) {
+    unsigned long current_brk = (unsigned long)sbrk(0);
+    int fd;
+
+    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if (fd == -1) {
+      scheme_raise_exn(MZEXN_MISC_IMAGE,
+		       scheme_make_string(filename),
+		       "write-image-to-file: couldn't write file %s", 
+		       filename);
+    } else {
+      int i;
+      const char *machine = scheme_system_library_subpath();
+      unsigned char len = strlen(machine);
+
+      write(fd, (char *)&len, sizeof(char));
+      write(fd, (char *)machine, len);
+
+      len = strlen(VERSION);
+      write(fd, (char *)&len, sizeof(char));
+      write(fd, (char *)VERSION, len);
+      
+      write(fd, (char *)&data_count, sizeof(int));
+      for (i = 0; i < data_count; i++) {
+	write(fd, (char *)&(data_starts[i]), sizeof(unsigned long));
+	write(fd, (char *)&(data_ends[i]), sizeof(unsigned long));
+      }
+      write(fd, (char *)&orig_brk, sizeof(unsigned long));
+      write(fd, (char *)&stack_base, sizeof(unsigned long));
+      
+      for (i = 0; i < data_count; i++)
+	write(fd, (char *)data_starts[i], data_ends[i] - data_starts[i]);
+
+      write(fd, (char *)&current_brk, sizeof(unsigned long));
+      write(fd, (char *)orig_brk, current_brk - orig_brk);
+      write(fd, (char *)&buf, sizeof(Scheme_Jumpup_Buf *));
+  
+      close(fd);
+    }
+
+    v = NULL;
+  } else {
+    /* We've been restored. environ contains a pointer to environment + argv. */
+    long len;
+
+    len = *(long *)restore_brk;
+    v = restore_env_argv(len);
+  }
+
+  /* zero it back out for GC */
+  scheme_init_jmpup_buf(buf);
+
+  return v;
+}
+
+static void mismatch(int which, unsigned long a, unsigned long b, char *file, void (*die)(char *c1, char *c2))
+{
+  char buffer[256];
+  errno = which;
+  sprintf(buffer, "setup mismatch [%lx vs %lx]", a, b);
+  die(buffer, file);
+}
+
+static void do_restore_image(char *file, int argc, char **argv, 
+			     Scheme_Jumpup_Buf **ubuf,
+			     void (*die)(char *c1, char *c2),
+			     long env_len, char *env_space1, char *env_space2)
+{
+# define MACHVERS_MAX_LEN 100
+  int fd;
+  int i, count;
+  long argv_len;
+  unsigned long current_brk;
+  unsigned long saved_data_start, saved_data_end, saved_orig_brk, saved_stack_base;
+  int saved_data_count;
+  const char *machine = scheme_system_library_subpath();
+  char machvers[MACHVERS_MAX_LEN];
+  unsigned char len;
+  char **save_environ;
+
+  if ((fd = open(file, O_RDONLY)) == -1) die("open", file);
+
+  if (read(fd, (char *)&len, sizeof(char)) != sizeof(char)) {
+    close(fd);
+    die("getting machine type", file);
+  }
+  if (len >= MACHVERS_MAX_LEN) {
+    close(fd);
+    die("getting machine type", file);
+  }
+  if (read(fd, (char *)machvers, len) != len) {
+    close(fd);
+    die("getting machine type", file);
+  }
+  machvers[len] = 0;
+  if (strcmp(machvers, machine)) {
+    char buffer[256];
+    sprintf(buffer, "machine type: image is %s, this is %s", machvers, machine);
+    die(buffer, file);
+  }
+
+  
+  if (read(fd, (char *)&len, sizeof(char)) != sizeof(char)) {
+    close(fd);
+    die("getting version", file);
+  }
+  if (len >= MACHVERS_MAX_LEN) {
+    close(fd);
+    die("getting version", file);
+  }
+  if (read(fd, (char *)machvers, len) != len) {
+    close(fd);
+    die("getting version", file);
+  }
+  machvers[len] = 0;
+  if (strcmp(machvers, VERSION)) {
+    char buffer[256];
+    sprintf(buffer, "version: image is %s, this is %s", machvers, machine);
+    die(buffer, file);
+  }
+
+  if (read(fd, (char *)&saved_data_count, sizeof(int)) != sizeof(int)) {
+    close(fd);
+    die("setup", file);
+  }
+  if (saved_data_count != data_count) {
+    close(fd);
+    mismatch(-1, saved_data_count, data_count, file, die);
+  }
+  for (i = 0; i < data_count; i++) {
+    if (read(fd, (char *)&saved_data_start, sizeof(unsigned long)) != sizeof(unsigned long)
+	|| read(fd, (char *)&saved_data_end, sizeof(unsigned long)) != sizeof(unsigned long)) {
+      close(fd);
+      die("setup", file);
+    }
+    if (saved_data_start != data_starts[i]) {
+      close(fd);
+      mismatch(-10 * (i + 1), saved_data_start, data_starts[i], file, die);
+    }
+    if (saved_data_end != data_ends[i]) {
+      close(fd);
+      mismatch(-1000 + -10 * (i + 1), saved_data_end, data_ends[i], file, die);
+    }
+  }
+
+  if (read(fd, (char *)&saved_orig_brk, sizeof(unsigned long)) != sizeof(unsigned long)
+      || read(fd, (char *)&saved_stack_base, sizeof(unsigned long)) != sizeof(unsigned long)) {
+    close(fd);
+    die("setup", file);
+  }
+
+  if (saved_orig_brk != orig_brk) {
+    close(fd);
+    mismatch(-3, saved_orig_brk, orig_brk, file, die);
+  }
+  if (saved_stack_base != stack_base) {
+    close(fd);
+    mismatch(-4, saved_stack_base, stack_base, file, die);
+  }
+
+   if ((unsigned long)env_space1 > (unsigned long)env_space2)
+     env_space1 = env_space2;
+
+  save_environ = (char **)env_space1;
+  for (i = 0; environ[i]; i++);
+  env_space1 += i * sizeof(char *);
+  for (i = 0; environ[i]; i++) {
+    int l;
+    save_environ[i] = env_space1;
+    l = strlen(environ[i]);
+    memcpy(save_environ[i], environ[i], l + 1);
+    env_space1 += l + 1;
+  }
+  count = i;
+
+  for (i = 0; i < data_count; i++) {
+    if (read(fd, (char *)data_starts[i], data_ends[i] - data_starts[i]) != (data_ends[i] - data_starts[i])) 
+      die_now("data", file);
+  }
+  if (read(fd, (char *)&current_brk, sizeof(unsigned long)) != sizeof(unsigned long)) 
+    die_now("data position", file);
+  brk((void *)current_brk);
+  if (read(fd, (char *)orig_brk, current_brk - orig_brk) != (current_brk - orig_brk))
+    die_now("dynamic data", file);
+  if (read(fd, (char *)ubuf, sizeof(Scheme_Jumpup_Buf *)) != sizeof(Scheme_Jumpup_Buf *)) 
+    die_now("stack", file);
+
+  close(fd);
+
+  /* Use sbrk to make room for env and argv; this will have to be restored
+     in a tricky way. */
+
+  argv_len = sizeof(long);
+  for (i = 0; i < argc; i++)
+    argv_len += strlen(argv[i]) + 1;
+
+  env_len += sizeof(long);
+
+  restore_brk = sbrk(env_len + argv_len + 2 * sizeof(long));
+
+  env_space1 = restore_brk;
+  *(long *)env_space1 = env_len + argv_len + sizeof(long);
+  env_space1 += sizeof(long);
+
+  *(long *)env_space1 = count;
+  env_space1 += sizeof(long);
+  for (i = 0; i < count; i++) {
+    int l = strlen(save_environ[i]);
+    memcpy(env_space1, save_environ[i], l + 1);
+    env_space1 += l + 1;
+  }
+
+  /* align for long */
+  if ((long)env_space1 & (sizeof(long) - 1))
+    env_space1 += (sizeof(long) - ((long)env_space1 & (sizeof(long) - 1)));
+
+  *(long *)env_space1 = argc;
+  env_space1 += sizeof(long);
+  for (i = 0; i < argc; i++) {
+    int l = strlen(argv[i]);
+    memcpy(env_space1, argv[i], l + 1);
+    env_space1 += l + 1;
+  }
+
+  scheme_longjmpup(*ubuf);
+}
+
+static void do_restore_image_with_space(char *file, int argc, char **argv, 
+					Scheme_Jumpup_Buf **ubuf,
+					void (*die)(char *c1, char *c2),
+					long orig_len, long len, void *start, void *carry)
+{
+  char buffer[1024];
+
+  if (len < 1024)
+    do_restore_image(file, argc, argv, ubuf, die, orig_len, (char *)start, buffer);
+  else
+    do_restore_image_with_space(file, argc, argv, ubuf, die, orig_len, len - 1024, start, buffer);
+}
+
+static void restore_image(char *file, int argc, char **argv, 
+			  Scheme_Jumpup_Buf **ubuf,
+			  void (*die)(char *c1, char *c2))
+{
+  int i;
+  long len = 0;
+
+  for (i = 0; environ[i]; i++)
+    len += strlen(environ[i]) + 1;
+
+  len += sizeof(char **) * (i + 1);
+
+  do_restore_image_with_space(file, argc, argv, ubuf, die, len, len, &len, &len);
+}
+
+
+static void read_image_exn(char *phase, char *file)
+{
+  scheme_raise_exn(MZEXN_MISC_IMAGE,
+		   scheme_make_string(file),
+		   "read-image-from-file: restore from \"%s\" failed at %s (%d).", 
+		   file, phase, errno);
+}
+
+static Scheme_Object *load_image(char *filename, Scheme_Object *argvec)
+{
+# define MAX_ARGV 20
+# define MAX_ARGLEN 2048
+  char *argv[MAX_ARGV], argspace[MAX_ARGLEN + MAX_ARGV], *s;
+  int i, count;
+  long l;
+  Scheme_Object **a;
+  
+  count = SCHEME_VEC_SIZE(argvec);
+  if (count > MAX_ARGV)
+    scheme_raise_exn(MZEXN_MISC_IMAGE,
+		     scheme_make_string(filename),
+		     "read-image-from-file: too many string arguments; "
+		     "maximum is %d", MAX_ARGV);
+
+  l = 0;
+
+  a = SCHEME_VEC_ELS(argvec);
+  for (i = count; i--; )
+    l += SCHEME_STRTAG_VAL(a[i]);
+
+  if (l > MAX_ARGLEN)
+    scheme_raise_exn(MZEXN_MISC_IMAGE,
+		     scheme_make_string(filename),
+		     "read-image-from-file: string arguments too long; "
+		     "maximum total length is %d", MAX_ARGLEN);
+
+  s = argspace;
+  for (i = 0; i < count; i++) {
+    l = SCHEME_STRTAG_VAL(a[i]);
+    memcpy(s, SCHEME_STR_VAL(a[i]), l + 1);
+    argv[i] = s;
+    s += l + 1;
+  }
+
+  restore_image(filename, count, argv, restore_launch_ubuf, read_image_exn);
+
+  return NULL;
+}
+
+#ifdef SOLARIS_SKIP_PLT
+#include <sys/link.h>
+unsigned long plt_start, plt_end;
+void find_plt()
+{
+  extern Elf32_Dyn _DYNAMIC;
+  Elf32_Dyn *dp;
+  int tag;
+
+  for (dp = ((Elf32_Dyn *)(&_DYNAMIC)); (tag = dp->d_tag) != DT_NULL; dp++) {
+    if (tag == DT_PLTGOT) {
+      plt_start = (unsigned long)dp->d_un.d_val;
+    } else if (tag == DT_PLTRELSZ) {
+      plt_end = (unsigned long)dp->d_un.d_val;
+    }
+  }
+
+  plt_end += plt_start;
+}
+#endif
+
+#ifdef FREEBSD_SKIP_PLT
+#include <sys/types.h>
+#include <nlist.h>
+#include <link.h>
+static unsigned long plt_start, plt_end;
+extern struct _dynamic _DYNAMIC;
+void find_plt()
+{
+  plt_start = _DYNAMIC.d_un.d_sdt->sdt_plt;
+  plt_end = plt_start + _DYNAMIC.d_un.d_sdt->sdt_plt_sz;
+}
+#endif
+
+int scheme_image_main(int argc, char **argv)
+{
+  Scheme_Jumpup_Buf *buf;
+
+  data_count = 1;
+  data_starts = malloc(sizeof(unsigned long));
+  data_ends = malloc(sizeof(unsigned long));
+
+  stack_base = (unsigned long)GC_get_stack_base();
+  data_starts[0] = (unsigned long)DATASTART;
+  data_ends[0] = (unsigned long)DATAEND;
+  orig_brk = data_ends[0];
+
+#if defined(SOLARIS_SKIP_PLT) || defined(FREEBSD_SKIP_PLT)
+  {
+    unsigned long ds, de;
+
+    ds = data_starts[0];
+    de = data_ends[0];
+    data_starts = malloc(2 * sizeof(unsigned long));
+    data_ends = malloc(2 * sizeof(unsigned long));
+    data_count = 2;
+
+    find_plt();
+    
+    data_starts[0] = ds;
+    data_ends[0] = plt_start;
+    data_starts[1] = plt_end;
+    data_ends[1] = de;
+  }
+#endif
+
+  scheme_dump_heap = dump_image;
+  scheme_load_heap = load_image;
+
+#ifdef FIND_WRITEABLE_SECTION
+  /* Find writeable section of text segment: */
+  {
+    unsigned long ds;
+
+    MZ_SIGSET(SIGBUS, bus_error);
+    MZ_SIGSET(SIGSEGV, bus_error);
+
+    ds = data_starts[0];
+
+    if (!setjmp(goback)) {
+      for (current_value = data_ends[0]; (current_value -= sizeof(long)) > ds; )
+	*(unsigned long *)current_value = *(unsigned long *)current_value;
+    }
+    data_starts[0] = current_value + sizeof(long);
+    MZ_SIGSET(SIGBUS, SIG_DFL);
+    MZ_SIGSET(SIGSEGV, SIG_DFL);
+  }
+#endif
+
+  if ((argc > 1) && (!strcmp(argv[1], "--restore")
+		     || !strncmp(argv[1], "-R", 2))) {
+    char *file, *exfile;
+    int startargs;
+    
+    if (argv[1][1] == 'R') {
+      file = argv[1] + 2;
+      if (!*file) {
+	printf("%s: Missing file name for -R.\n", argv[0]);
+	printf("Use the --help or -h flag for help.\n");
+	return -1;
+      }
+      startargs = 2;
+    } else if (argc < 3) {
+      printf("%s: Missing file name for --restore.\n", argv[0]);
+      printf("Use the --help or -h flag for help.\n");
+      return -1;
+    } else {
+      file = argv[2];
+      startargs = 3;
+    }
+
+    exfile = scheme_expand_filename(file, strlen(file), NULL, NULL);
+    if (!exfile)
+      die_now("bad filename", file);
+
+    restore_image(exfile, argc - startargs, argv + startargs, &buf, die_now);
+
+    die_now("stack jump", file);
+  }
+
+  restore_launch_ubuf = &buf;
+
+  {
+    /* Make a copy of argv so that it's definitely in the normal heap: */
+    char **naya_argv;
+    int i;
+    
+    naya_argv = scheme_malloc(argc * sizeof(char *));
+    for (i = 0; i < argc; i++)
+      naya_argv[i] = scheme_strdup(argv[i]);
+
+    /* doesn't support atexit(): */
+    _exit(scheme_actual_main(argc, naya_argv));
+  }
+
+  return -1;
+}
+
+#endif
+
+/******************************************************************************/
+
+#ifndef UNIX_IMAGE_DUMPS
+
+int scheme_image_main(int argc, char **argv)
+{
+  return scheme_actual_main(argc, argv);
+}
+
+#endif
diff --git a/src/mzscheme/src/list.c b/src/mzscheme/src/list.c
new file mode 100644
index 0000000..3e1f6f0
--- /dev/null
+++ b/src/mzscheme/src/list.c
@@ -0,0 +1,1328 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+/* globals */
+Scheme_Object *scheme_null;
+
+/* locals */
+static Scheme_Object *scheme_make_null (void);
+static Scheme_Object *pair_p_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cons_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *car_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *set_car_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *set_cdr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *null_p_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_p_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_star_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *length_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *append_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *append_bang_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *reverse_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *reverse_bang_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_tail_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_ref_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *memv (int argc, Scheme_Object *argv[]);
+static Scheme_Object *memq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *member (int argc, Scheme_Object *argv[]);
+static Scheme_Object *assv (int argc, Scheme_Object *argv[]);
+static Scheme_Object *assq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *assoc (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caaar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cadar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdaar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cddar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdddr_prim (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *cddddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cadddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdaddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cddadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdddar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caaddr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cadadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caddar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdaadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdadar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cddaar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cdaaar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cadaar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caadar_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caaadr_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *caaaar_prim (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *box (int argc, Scheme_Object *argv[]);
+static Scheme_Object *box_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *unbox (int argc, Scheme_Object *argv[]);
+static Scheme_Object *set_box (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *make_hash_table(int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_hash_table_weak(int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_hash_table_weak(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_put(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_get(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_remove(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_map(int argc, Scheme_Object *argv[]);
+static Scheme_Object *hash_table_for_each(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *make_weak_box(int argc, Scheme_Object *argv[]);
+static Scheme_Object *weak_box_value(int argc, Scheme_Object *argv[]);
+static Scheme_Object *weak_boxp(int argc, Scheme_Object *argv[]);
+
+#define BOX "box"
+#define BOXP "box?"
+#define UNBOX "unbox"
+#define SETBOX "set-box!"
+
+void
+scheme_init_list (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(scheme_null);
+
+    scheme_null = scheme_make_null ();
+  }
+
+  scheme_add_global_constant ("null", scheme_null, env);
+
+  scheme_add_global_constant ("pair?", 
+			      scheme_make_folding_prim(pair_p_prim, 
+						       "pair?", 
+						       1, 1, 1), 
+			      env);
+  scheme_add_global_constant ("cons", 
+			      scheme_make_prim_w_arity(cons_prim, 
+						       "cons", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("car", 
+			      scheme_make_prim_w_arity(car_prim, 
+						       "car", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cdr", 
+			      scheme_make_prim_w_arity(cdr_prim,  
+						       "cdr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("set-car!", 
+			      scheme_make_prim_w_arity(set_car_prim, 
+						       "set-car!", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("set-cdr!", 
+			      scheme_make_prim_w_arity(set_cdr_prim, 
+						       "set-cdr!", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("null?", 
+			      scheme_make_folding_prim(null_p_prim, 
+						       "null?", 
+						       1, 1, 1), 
+			      env);
+  scheme_add_global_constant ("list?", 
+			      scheme_make_prim_w_arity(list_p_prim, 
+						       "list?", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("list", 
+			      scheme_make_prim_w_arity(list_prim, 
+						       "list", 
+						       0, -1), 
+			      env);
+  scheme_add_global_constant ("list*", 
+			      scheme_make_prim_w_arity(list_star_prim, 
+						       "list*", 
+						       1, -1), 
+			      env);
+  scheme_add_global_constant ("length", 
+			      scheme_make_prim_w_arity(length_prim, 
+						       "length", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("append", 
+			      scheme_make_prim_w_arity(append_prim, 
+						       "append", 
+						       0, -1), 
+			      env);
+  scheme_add_global_constant ("append!", 
+			      scheme_make_prim_w_arity(append_bang_prim, 
+						       "append!", 
+						       0, -1), 
+			      env);
+  scheme_add_global_constant ("reverse", 
+			      scheme_make_prim_w_arity(reverse_prim, 
+						       "reverse", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("reverse!", 
+			      scheme_make_prim_w_arity(reverse_bang_prim, 
+						       "reverse!", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("list-tail", 
+			      scheme_make_prim_w_arity(list_tail_prim, 
+						       "list-tail", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("list-ref", 
+			      scheme_make_prim_w_arity(list_ref_prim, 
+						       "list-ref", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("memq", 
+			      scheme_make_prim_w_arity(memq, 
+						       "memq", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("memv", 
+			      scheme_make_prim_w_arity(memv, 
+						       "memv", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("member", 
+			      scheme_make_prim_w_arity(member, 
+						       "member", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("assq", 
+			      scheme_make_prim_w_arity(assq, 
+						       "assq", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("assv", 
+			      scheme_make_prim_w_arity(assv, 
+						       "assv", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("assoc", 
+			      scheme_make_prim_w_arity(assoc, 
+						       "assoc", 
+						       2, 2), 
+			      env);
+  scheme_add_global_constant ("caar", 
+			      scheme_make_prim_w_arity(caar_prim,  
+						       "caar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cadr", 
+			      scheme_make_prim_w_arity(cadr_prim, 
+						       "cadr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cdar", 
+			      scheme_make_prim_w_arity(cdar_prim, 
+						       "cdar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cddr", 
+			      scheme_make_prim_w_arity(cddr_prim, 
+						       "cddr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("caaar", 
+			      scheme_make_prim_w_arity(caaar_prim, 
+						       "caaar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("caadr", 
+			      scheme_make_prim_w_arity(caadr_prim, 
+						       "caadr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cadar", 
+			      scheme_make_prim_w_arity(cadar_prim, 
+						       "cadar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cdaar", 
+			      scheme_make_prim_w_arity(cdaar_prim, 
+						       "cdaar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cdadr", 
+			      scheme_make_prim_w_arity(cdadr_prim, 
+						       "cdadr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cddar", 
+			      scheme_make_prim_w_arity(cddar_prim, 
+						       "cddar", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("caddr", 
+			      scheme_make_prim_w_arity(caddr_prim, 
+						       "caddr", 
+						       1, 1), 
+			      env);
+  scheme_add_global_constant ("cdddr", 
+			      scheme_make_prim_w_arity(cdddr_prim, 
+						       "cdddr", 
+						       1, 1), 
+			      env);  
+  scheme_add_global_constant ("cddddr", 
+			      scheme_make_prim_w_arity(cddddr_prim, 
+						       "cddddr", 
+						       1, 1), 
+			      env);  
+  
+  scheme_add_global_constant ("cadddr", 
+			      scheme_make_prim_w_arity(cadddr_prim, 
+						       "cadddr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cdaddr", 
+			      scheme_make_prim_w_arity(cdaddr_prim, 
+						       "cdaddr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cddadr", 
+			      scheme_make_prim_w_arity(cddadr_prim, 
+						       "cddadr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cdddar", 
+			      scheme_make_prim_w_arity(cdddar_prim, 
+						       "cdddar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("caaddr", 
+			      scheme_make_prim_w_arity(caaddr_prim, 
+						       "caaddr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cadadr", 
+			      scheme_make_prim_w_arity(cadadr_prim, 
+						       "cadadr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("caddar", 
+			      scheme_make_prim_w_arity(caddar_prim, 
+						       "caddar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cdaadr", 
+			      scheme_make_prim_w_arity(cdaadr_prim, 
+						       "cdaadr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cdadar", 
+			      scheme_make_prim_w_arity(cdadar_prim, 
+						       "cdadar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cddaar", 
+			      scheme_make_prim_w_arity(cddaar_prim, 
+						       "cddaar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cdaaar", 
+			      scheme_make_prim_w_arity(cdaaar_prim, 
+						       "cdaaar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("cadaar", 
+			      scheme_make_prim_w_arity(cadaar_prim, 
+						       "cadaar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("caadar", 
+			      scheme_make_prim_w_arity(caadar_prim, 
+						       "caadar", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("caaadr", 
+			      scheme_make_prim_w_arity(caaadr_prim, 
+						       "caaadr", 
+						       1, 1), 
+			      env); 
+  scheme_add_global_constant ("caaaar", 
+			      scheme_make_prim_w_arity(caaaar_prim, 
+						       "caaaar", 
+						       1, 1), 
+			      env); 
+  
+  scheme_add_global_constant(BOX, 
+			     scheme_make_prim_w_arity(box, 
+						      BOX, 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant(BOXP, 
+			     scheme_make_folding_prim(box_p, 
+						      BOXP, 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant(UNBOX, 
+			     scheme_make_prim_w_arity(unbox,  
+						      UNBOX, 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant(SETBOX, 
+			     scheme_make_prim_w_arity(set_box, 
+						      SETBOX, 
+						      2, 2), 
+			     env);
+  
+  scheme_add_global_constant("make-hash-table", 
+			     scheme_make_prim_w_arity(make_hash_table, 
+						      "make-hash-table", 
+						      0, 0), 
+			     env);
+  scheme_add_global_constant("make-hash-table-weak", 
+			     scheme_make_prim_w_arity(make_hash_table_weak, 
+						      "make-hash-table-weak", 
+						      0, 0), 
+			     env);
+  scheme_add_global_constant("hash-table?", 
+			     scheme_make_folding_prim(hash_table_p, 
+						      "hash-table?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("hash-table-put!", 
+			     scheme_make_prim_w_arity(hash_table_put, 
+						      "hash-table-put!", 
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("hash-table-get", 
+			     scheme_make_prim_w_arity(hash_table_get, 
+						      "hash-table-get", 
+						      2, 3), 
+			     env);
+  scheme_add_global_constant("hash-table-remove!", 
+			     scheme_make_prim_w_arity(hash_table_remove, 
+						      "hash-table-remove!", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("hash-table-map", 
+			     scheme_make_prim_w_arity(hash_table_map, 
+						      "hash-table-map", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("hash-table-for-each", 
+			     scheme_make_prim_w_arity(hash_table_for_each, 
+						      "hash-table-for-each", 
+						      2, 2), 
+			     env);
+
+  scheme_add_global_constant("make-weak-box",
+			     scheme_make_prim_w_arity(make_weak_box,
+						      "make-weak-box",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("weak-box-value",
+			     scheme_make_prim_w_arity(weak_box_value,
+						      "weak-box-value",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("weak-box?",
+			     scheme_make_folding_prim(weak_boxp,
+						      "weak-box?",
+						      1, 1, 1),
+			     env);
+}
+
+static Scheme_Object *
+scheme_make_null (void)
+{
+  Scheme_Object *null;
+
+  null = scheme_alloc_eternal_object();
+  null->type = scheme_null_type;
+  return (null);
+}
+
+Scheme_Object *
+scheme_make_pair (Scheme_Object *car, Scheme_Object *cdr)
+{
+  Scheme_Object *cons;
+
+#if 0
+  if (!SCHEME_INTP(cdr))
+    scheme_check_home(cdr);
+#endif
+
+  cons = scheme_alloc_object();
+  cons->type = scheme_pair_type;
+  SCHEME_CAR(cons) = car;
+  SCHEME_CDR(cons) = cdr;
+  return cons;
+}
+
+Scheme_Object *scheme_build_list(int size, Scheme_Object **argv)
+{
+  Scheme_Object *first = scheme_null, *last = NULL, *pair;
+  int i;
+
+  for (i = 0; i < size; i++) {
+    pair = scheme_make_pair(argv[i], scheme_null);
+    if (!last)
+      first = pair;
+    else
+      SCHEME_CDR (last) = pair;
+    last = pair;
+  }
+
+  return first;  
+}
+
+Scheme_Object *scheme_alloc_list(int size)
+{
+  Scheme_Object *first = scheme_null, *last = NULL, *pair;
+  int i;
+
+  for (i = 0; i < size; i++) {
+    pair = scheme_make_pair(scheme_false, scheme_null);
+    if (!last)
+      first = pair;
+    else
+      SCHEME_CDR(last) = pair;
+    last = pair;
+  }
+
+  return first;
+}
+
+int
+scheme_list_length (Scheme_Object *list)
+{
+  int len;
+
+  len = 0;
+  while (!SCHEME_NULLP(list)) {
+    len++;
+    if (SCHEME_PAIRP(list))
+      list = SCHEME_CDR(list);
+    else
+      list = scheme_null;
+  }
+
+  return len;
+}
+
+int
+scheme_proper_list_length (Scheme_Object *list)
+{
+  int len;
+  Scheme_Object *turtle;
+
+  len = 0;
+  turtle = list;
+  while (SCHEME_PAIRP(list)) {
+    len++;
+    list = SCHEME_CDR(list);
+    if (!SCHEME_PAIRP(list))
+      break;
+    len++;
+    list = SCHEME_CDR(list);
+
+    if (SAME_OBJ(turtle, list))
+      break;
+
+    turtle = SCHEME_CDR(turtle);
+  }
+  
+  if (SCHEME_NULLP(list))
+    return len;
+
+  return -1;
+}
+
+Scheme_Object *
+scheme_named_map_1 (char *name, Scheme_Object *(*fun)(Scheme_Object*, Scheme_Object*), 
+		    Scheme_Object *lst, Scheme_Object *form)
+{
+  if (SCHEME_NULLP(lst))
+      return (scheme_null);
+  else if (SCHEME_PAIRP(lst)) {
+    return scheme_make_pair(fun(SCHEME_CAR(lst), form), 
+			    scheme_named_map_1(name, fun, 
+					       SCHEME_CDR(lst), form));
+  } else {
+    scheme_wrong_syntax(name, lst, form, "bad syntax (" IMPROPER_LIST_FORM ")");
+    return scheme_void;
+  }
+}
+
+Scheme_Object *
+scheme_map_1 (Scheme_Object *(*fun)(Scheme_Object*), Scheme_Object *lst)
+{
+  return scheme_named_map_1("map", 
+			    (Scheme_Object *(*)(Scheme_Object *, Scheme_Object *))fun, 
+			    lst, NULL);
+}
+
+Scheme_Object *
+scheme_car (Scheme_Object *pair)
+{
+  return (SCHEME_CAR (pair));
+}
+
+Scheme_Object *
+scheme_cdr (Scheme_Object *pair)
+{
+  return (SCHEME_CDR (pair));
+}
+
+Scheme_Object *
+scheme_cadr (Scheme_Object *pair)
+{
+  return (SCHEME_CAR (SCHEME_CDR (pair)));
+}
+
+Scheme_Object *
+scheme_caddr (Scheme_Object *pair)
+{
+  return (SCHEME_CAR (SCHEME_CDR (SCHEME_CDR (pair))));
+}
+
+/* local functions */
+
+static Scheme_Object *
+pair_p_prim (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_PAIRP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+cons_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *cons;
+
+  cons = scheme_make_pair (argv[0], argv[1]);
+  return (cons);
+}
+
+static Scheme_Object *
+car_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_PAIRP(argv[0]))
+    scheme_wrong_type("car", "pair", 0, argc, argv);
+  return (SCHEME_CAR (argv[0]));
+}
+
+static Scheme_Object *
+cdr_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_PAIRP(argv[0]))
+    scheme_wrong_type("cdr", "pair", 0, argc, argv);
+
+  return (SCHEME_CDR (argv[0]));
+}
+
+static Scheme_Object *
+set_car_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_PAIRP(argv[0]))
+    scheme_wrong_type("set-car!", "pair", 0, argc, argv);
+
+  SCHEME_CAR (argv[0]) = argv[1];
+  return scheme_void;
+}
+
+static Scheme_Object *
+set_cdr_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_PAIRP(argv[0]))
+    scheme_wrong_type("set-cdr!", "pair", 0, argc, argv);
+
+  SCHEME_CDR (argv[0]) = argv[1];
+  return scheme_void;
+}
+
+static Scheme_Object *
+null_p_prim (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_NULLP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+list_p_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *obj1, *obj2;
+
+  obj1 = obj2 = argv[0];
+  do {
+    if (SCHEME_NULLP(obj1))
+      return scheme_true;
+    if (!SCHEME_PAIRP(obj1))
+      return (scheme_false);
+    
+    obj1 = SCHEME_CDR (obj1);
+    
+    if (SCHEME_NULLP(obj1))
+      return scheme_true;
+    if (!SCHEME_PAIRP(obj1))
+      return scheme_false;
+    
+    obj1 = SCHEME_CDR(obj1);
+    
+    obj2 = SCHEME_CDR(obj2);
+  } while (NOT_SAME_OBJ(obj1, obj2));
+
+  return scheme_false;
+}
+
+static Scheme_Object *
+list_exec (int argc, Scheme_Object *argv[], int star)
+{
+  int i;
+  Scheme_Object *first, *last, *pair;
+
+  if (star)
+    --argc;
+
+  first = last = scheme_null;
+  for (i = 0; i < argc ; i++) {
+    pair = scheme_make_pair (argv[i], scheme_null);
+    if (SCHEME_NULLP(last))
+      first = last = pair;
+    else {
+      SCHEME_CDR (last) = pair;
+      last = pair;
+    }
+  }
+
+  if (star) {
+    if (SCHEME_NULLP(last))
+      first = argv[argc];
+    else
+      SCHEME_CDR (last) = argv[argc];
+  }
+
+  return first;
+}
+
+static Scheme_Object *
+list_prim (int argc, Scheme_Object *argv[])
+{
+  return list_exec(argc, argv, 0);
+}
+
+static Scheme_Object *
+list_star_prim (int argc, Scheme_Object *argv[])
+{
+  return list_exec(argc, argv, 1);
+}
+
+static Scheme_Object *
+length_prim (int argc, Scheme_Object *argv[])
+{
+  int l;
+
+  if (!SCHEME_LISTP(argv[0]))
+    scheme_wrong_type("length", "proper list", 0, argc, argv);
+
+  l = scheme_proper_list_length(argv[0]);
+
+  if (l < 0)
+    scheme_wrong_type("length", "proper list", 0, argc, argv);
+
+  return scheme_make_integer(l);
+}
+
+Scheme_Object *
+scheme_append (Scheme_Object *lst1, Scheme_Object *lst2)
+{
+  Scheme_Object *first, *last, *orig1, *v;
+
+  orig1 = lst1;
+
+  first = last = NULL;
+  while (SCHEME_PAIRP(lst1)) {
+    v = scheme_make_pair(SCHEME_CAR(lst1), scheme_null);
+    if (!first)
+      first = v;
+    else
+      SCHEME_CDR(last) = v;
+    last = v;
+    lst1 = SCHEME_CDR(lst1);
+
+    SCHEME_USE_FUEL(1);
+  }
+  
+  if (!SCHEME_NULLP(lst1))
+    scheme_wrong_type("append", "proper list", -1, 0, &orig1);
+
+  if (!last)
+    return lst2;
+  
+  SCHEME_CDR(last) = lst2;
+
+  return first;
+}
+
+static Scheme_Object *
+scheme_append_bang (Scheme_Object *lst1, Scheme_Object *lst2)
+{
+  if (SCHEME_NULLP(lst1))
+    return lst2;
+  else {
+    Scheme_Object *prev, *orig;
+
+    orig = lst1;
+
+    do {
+      prev = lst1;
+      if (!SCHEME_PAIRP(lst1))
+	scheme_wrong_type("append!", "proper list", -1, 0, &lst1);
+      lst1 = SCHEME_CDR(lst1);
+
+      SCHEME_USE_FUEL(1);
+    } while (!SCHEME_NULLP(lst1));
+
+    SCHEME_CDR(prev) = lst2;
+
+    return orig;
+  }
+}
+
+static Scheme_Object *
+append_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *res;
+  int i;
+
+  if (!argc)
+    return scheme_null;
+
+  res = argv[argc - 1];
+  for (i = argc - 1; i--;  )
+    res = scheme_append(argv[i], res);
+
+  return res;
+}
+
+static Scheme_Object *
+append_bang_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *res;
+  int i;
+
+  if (!argc)
+    return scheme_null;
+
+  res = argv[argc - 1];
+  for (i = argc - 1; i--; )
+    res = scheme_append_bang(argv[i], res);
+
+  return res;
+}
+
+static Scheme_Object *
+reverse_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *lst, *last;
+
+  last = scheme_null;
+  lst = argv[0];
+  while (!SCHEME_NULLP (lst)) {
+    if (!SCHEME_PAIRP(lst))
+      scheme_wrong_type("reverse", "proper list", 0, argc, argv);
+    last = scheme_make_pair (SCHEME_CAR (lst), last);
+    lst = SCHEME_CDR (lst);
+
+    SCHEME_USE_FUEL(1);
+  }
+  return (last);
+}
+
+static Scheme_Object *
+reverse_bang_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *lst, *prev, *next;
+
+  prev = NULL;
+  lst = argv[0];
+  while (!SCHEME_NULLP(lst)) {
+    if (!SCHEME_PAIRP(lst))
+      scheme_wrong_type("reverse!", "proper list", 0, argc, argv);
+    next = SCHEME_CDR(lst);
+    if (prev)
+      SCHEME_CDR(lst) = prev;
+    else
+      SCHEME_CDR(lst) = scheme_null;
+    prev = lst;
+    lst = next;
+
+    SCHEME_USE_FUEL(1);
+  }
+
+  if (prev)
+    return prev;
+  else
+    return scheme_null;
+}
+
+#define OCCASIONAL_CHECK ((int)0xFF)
+#define LISTREF_BIGNUM_SLICE 1000000
+
+static Scheme_Object *
+do_list_ref(char *name, int takecar, int argc, Scheme_Object *argv[])
+{
+  int i, k;
+  Scheme_Object *lst, *index, *bnindex;
+
+#if 0
+  if (!SCHEME_LISTP(argv[0]))
+    scheme_wrong_type(name, "list", 0, argc, argv);
+#endif
+
+  if (SCHEME_BIGNUMP(argv[1])) {
+    bnindex = argv[1];
+    k = 0;
+#ifdef ALLOW_INEXACT_INDICES
+  } else if (SCHEME_DBLP(argv[1])) {
+    double d;
+    d = SCHEME_DBL_VAL(argv[1]);
+    bnindex = scheme_double_to_integer(name, d);
+    if (!bnindex)
+      scheme_wrong_type(name, "non-negative integer", 1, argc, argv);
+    if (SCHEME_INTP(bnindex)) {
+      k = SCHEME_INT_VAL(bnindex);
+      bnindex = NULL;
+    } else
+      k = 0;
+#endif
+  } else if (!SCHEME_INTP(argv[1])) {
+    scheme_wrong_type(name, "non-negative exact integer", 1, argc, argv);
+    return NULL;
+  } else {
+    bnindex = NULL;
+    k = SCHEME_INT_VAL(argv[1]);
+  }
+
+  lst = argv[0];
+  index = argv[1];
+
+  if ((bnindex && !SCHEME_BIGPOS(bnindex))
+      || (!bnindex && (k < 0))) {
+    scheme_wrong_type(name, "non-negative exact integer", 1, argc, argv);
+    return NULL;
+  }
+
+  do {
+    if (bnindex) {
+      if (SCHEME_INTP(bnindex)) {
+	k = SCHEME_INT_VAL(bnindex);
+	bnindex = 0;
+      } else {
+	k = LISTREF_BIGNUM_SLICE;
+	bnindex = scheme_bin_minus(bnindex, scheme_make_integer(LISTREF_BIGNUM_SLICE));
+      }
+    }
+
+    for (i = 0; i < k; i++) {
+      if (!SCHEME_PAIRP(lst)) {
+	scheme_raise_exn(MZEXN_APPLICATION_RANGE_LIST,
+			 index,
+			 "%s: index %s too large for list%s: %s", name,
+			 scheme_make_provided_string(index, 2, NULL),
+			 SCHEME_NULLP(lst) ? "" : " (not a proper list)",
+			 scheme_make_provided_string(argv[0], 2, NULL));
+	return NULL;
+      }
+      lst = SCHEME_CDR(lst);
+      if (!(i & OCCASIONAL_CHECK))
+	SCHEME_USE_FUEL(OCCASIONAL_CHECK);
+    }
+  } while(bnindex);
+
+  if (takecar) {
+    if (!SCHEME_PAIRP(lst)) {
+      scheme_raise_exn(MZEXN_APPLICATION_RANGE_LIST,
+		       index,
+		       "%s: index %s too large for list%s: %s", name,
+		       scheme_make_provided_string(index, 2, NULL),
+		       SCHEME_NULLP(lst) ? "" : " (not a proper list)",
+		       scheme_make_provided_string(argv[0], 2, NULL));
+      return NULL;
+    }
+    
+    return SCHEME_CAR(lst);
+  } else
+    return lst;
+}
+
+static Scheme_Object *
+list_tail_prim(int argc, Scheme_Object *argv[])
+{
+  return do_list_ref("list-tail", 0, argc, argv);
+}
+
+static Scheme_Object *
+list_ref_prim(int argc, Scheme_Object *argv[])
+{
+  return do_list_ref("list-ref", 1, argc, argv);
+}
+
+
+#define GEN_MEM(name, scheme_name, comp) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  Scheme_Object *list; \
+  list = argv[1]; \
+  while (SCHEME_PAIRP(list)) \
+    { \
+      if (comp (argv[0], SCHEME_CAR (list))) \
+	{ \
+          return (list); \
+	} \
+      list = SCHEME_CDR (list); \
+    } \
+  if (!SCHEME_NULLP(list)) \
+    scheme_raise_exn(MZEXN_APPLICATION_LIST, argv[1], \
+		     "%s: not a proper list: %s", #scheme_name, \
+		     scheme_make_provided_string(argv[1], 0, NULL)); \
+  return (scheme_false); \
+}
+    
+GEN_MEM(memv, memv, scheme_eqv)
+GEN_MEM(memq, memq, scheme_eq)
+GEN_MEM(member, member, scheme_equal)
+
+#define GEN_ASS(name, scheme_name, comp) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  Scheme_Object *pair, *list; \
+  list = argv[1]; \
+  while (SCHEME_PAIRP (list)) \
+    { \
+      pair = SCHEME_CAR (list); \
+      if (!SCHEME_PAIRP (pair)) {\
+	scheme_raise_exn(MZEXN_APPLICATION_LIST, argv[1], \
+			 "%s: non-pair found in list: %s in %s", #scheme_name, \
+			 scheme_make_provided_string(pair, 2, NULL), \
+			 scheme_make_provided_string(argv[1], 2, NULL)); \
+	return NULL; \
+      } \
+      if (comp (argv[0], SCHEME_CAR (pair))) \
+	{ \
+          return (pair); \
+	} \
+      list = SCHEME_CDR (list); \
+    } \
+  if (!SCHEME_NULLP(list))\
+    scheme_raise_exn(MZEXN_APPLICATION_LIST, argv[1], \
+		     "%s: not a proper list: %s", #scheme_name, \
+		     scheme_make_provided_string(argv[1], 0, NULL)); \
+  return (scheme_false); \
+}
+
+GEN_ASS(assv, assv, scheme_eqv)
+GEN_ASS(assq, assq, scheme_eq)
+GEN_ASS(assoc, assoc, scheme_equal)
+
+#define LISTFUNC2(name, C, D) \
+static Scheme_Object * \
+name ## _prim (int argc, Scheme_Object *argv[]) \
+{ \
+  if (!(SCHEME_PAIRP(argv[0]) \
+	&& SCHEME_PAIRP(SCHEME_ ## D (argv[0])))) \
+      scheme_wrong_type(#name, #name "able value", 0, argc, argv); \
+  return SCHEME_ ## C (SCHEME_ ## D (argv[0])); \
+}
+
+LISTFUNC2(cddr, CDR, CDR)
+LISTFUNC2(cadr, CAR, CDR)
+LISTFUNC2(cdar, CDR, CAR)
+LISTFUNC2(caar, CAR, CAR)
+
+#define LISTFUNC3(name, B, C, D) \
+static Scheme_Object * \
+name ## _prim (int argc, Scheme_Object *argv[]) \
+{ \
+  if (!((SCHEME_PAIRP(argv[0])) \
+	&& SCHEME_PAIRP(SCHEME_ ## D (argv[0])) \
+	&& SCHEME_PAIRP(SCHEME_ ## C (SCHEME_ ## D (argv[0]))))) \
+    scheme_wrong_type(#name, #name "able value", 0, argc, argv); \
+  return SCHEME_ ## B (SCHEME_ ## C (SCHEME_ ## D (argv[0]))); \
+}
+
+LISTFUNC3(cdddr, CDR, CDR, CDR)
+
+LISTFUNC3(caddr, CAR, CDR, CDR)
+LISTFUNC3(cdadr, CDR, CAR, CDR)
+LISTFUNC3(cddar, CDR, CDR, CAR)
+
+LISTFUNC3(cdaar, CDR, CAR, CAR)
+LISTFUNC3(cadar, CAR, CDR, CAR)
+LISTFUNC3(caadr, CAR, CAR, CDR)
+
+LISTFUNC3(caaar, CAR, CAR, CAR)
+
+
+#define LISTFUNC4(name, A, B, C, D) \
+static Scheme_Object * \
+name ## _prim (int argc, Scheme_Object *argv[]) \
+{ \
+  if (!(SCHEME_PAIRP(argv[0]) \
+	&& SCHEME_PAIRP(SCHEME_ ## D (argv[0])) \
+	&& SCHEME_PAIRP(SCHEME_ ## C (SCHEME_ ## D (argv[0]))) \
+	&&SCHEME_PAIRP(SCHEME_ ## B (SCHEME_ ## C (SCHEME_ ## D (argv[0]))))))\
+    scheme_wrong_type(#name, #name "able value", 0, argc, argv); \
+  return SCHEME_ ## A (SCHEME_ ## B (SCHEME_ ## C (SCHEME_ ## D (argv[0]))));\
+}
+
+LISTFUNC4(cddddr, CDR, CDR, CDR, CDR)
+
+LISTFUNC4(cadddr, CAR, CDR, CDR, CDR)
+LISTFUNC4(cdaddr, CDR, CAR, CDR, CDR)
+LISTFUNC4(cddadr, CDR, CDR, CAR, CDR)
+LISTFUNC4(cdddar, CDR, CDR, CDR, CAR)
+
+LISTFUNC4(caaddr, CAR, CAR, CDR, CDR)
+LISTFUNC4(cadadr, CAR, CDR, CAR, CDR)
+LISTFUNC4(caddar, CAR, CDR, CDR, CAR)
+LISTFUNC4(cdaadr, CDR, CAR, CAR, CDR)
+LISTFUNC4(cdadar, CDR, CAR, CDR, CAR)
+LISTFUNC4(cddaar, CDR, CDR, CAR, CAR)
+
+LISTFUNC4(cdaaar, CDR, CAR, CAR, CAR)
+LISTFUNC4(cadaar, CAR, CDR, CAR, CAR)
+LISTFUNC4(caadar, CAR, CAR, CDR, CAR)
+LISTFUNC4(caaadr, CAR, CAR, CAR, CDR)
+
+LISTFUNC4(caaaar, CAR, CAR, CAR, CAR)
+
+Scheme_Object *scheme_box(Scheme_Object *v)
+{
+  Scheme_Object *obj;
+
+  obj = scheme_alloc_small_object();
+  obj->type = scheme_box_type;
+  SCHEME_BOX_VAL(obj) = v;
+
+  return obj;
+}
+
+Scheme_Object *scheme_unbox(Scheme_Object *obj)
+{  
+  if (!SCHEME_BOXP(obj))
+      scheme_wrong_type(UNBOX, "box", 0, 1, &obj);
+  return (Scheme_Object *)SCHEME_BOX_VAL(obj);
+}
+
+void scheme_set_box(Scheme_Object *b, Scheme_Object *v)
+{
+  if (!SCHEME_BOXP(b))
+      scheme_wrong_type(SETBOX, "box", 0, 1, &b);
+  SCHEME_BOX_VAL(b) = v;
+}
+
+static Scheme_Object *box(int c, Scheme_Object *p[])
+{
+  return scheme_box(p[0]);
+}
+
+static Scheme_Object *box_p(int c, Scheme_Object *p[])
+{
+  return SCHEME_BOXP(p[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *unbox(int c, Scheme_Object *p[])
+{
+  return scheme_unbox(p[0]);
+}
+
+static Scheme_Object *set_box(int c, Scheme_Object *p[])
+{
+  scheme_set_box(p[0], p[1]);
+  return scheme_void;
+}
+
+static Scheme_Object *do_make_hash_table(int weak)
+{
+  return (Scheme_Object *)scheme_hash_table(20, 
+					    weak
+					    ? SCHEME_hash_weak_ptr
+					    : SCHEME_hash_ptr, 
+					    0, 0);
+}
+
+static Scheme_Object *make_hash_table(int argc, Scheme_Object *argv[])
+{
+  return do_make_hash_table(0);
+}
+
+static Scheme_Object *make_hash_table_weak(int argc, Scheme_Object *argv[])
+{
+  return do_make_hash_table(1);
+}
+
+static Scheme_Object *hash_table_p(int argc, Scheme_Object *argv[])
+{
+  return SCHEME_HASHTP(argv[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *hash_table_put(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_HASHTP(argv[0]))
+    scheme_wrong_type("hash-table-put!", "hash table", 0, argc, argv);
+
+  scheme_add_to_table((Scheme_Hash_Table *)argv[0], (char *)argv[1], 
+		      (void *)argv[2], 0);
+
+  return scheme_void;
+}
+
+static Scheme_Object *hash_table_get(int argc, Scheme_Object *argv[])
+{
+  void *v;
+
+  if (!SCHEME_HASHTP(argv[0]))
+    scheme_wrong_type("hash-table-get", "hash table", 0, argc, argv);
+
+  v = scheme_lookup_in_table((Scheme_Hash_Table *)argv[0], (char *)argv[1]);
+
+  if (v)
+    return (Scheme_Object *)v;
+  else if (argc == 3)
+    return _scheme_tail_apply(argv[2], 0, NULL);
+  else {
+    scheme_raise_exn(MZEXN_MISC_HASH_TABLE,
+		     argv[1],
+		     "hash-table-get: no value found for key: %s",
+		     scheme_make_provided_string(argv[1], 1, NULL));
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *hash_table_remove(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_HASHTP(argv[0]))
+    scheme_wrong_type("hash-table-remove!", "hash table", 0, argc, argv);
+
+  scheme_change_in_table((Scheme_Hash_Table *)argv[0], (char *)argv[1], NULL);
+
+  return scheme_void;
+}
+
+static Scheme_Object *do_map_hash_table(int argc,
+					Scheme_Object *argv[],
+					char *name,
+					int keep)
+{
+  int i;
+  Scheme_Hash_Table *hash;
+  Scheme_Object *f;
+  Scheme_Bucket *bucket;
+  Scheme_Object *first, *last = NULL, *v, *p[2];
+
+  if (!SCHEME_HASHTP(argv[0]))
+    scheme_wrong_type(name, "hash table", 0, argc, argv);
+  scheme_check_proc_arity(name, 2, 1, argc, argv);
+
+  hash = (Scheme_Hash_Table *)argv[0];
+  f = argv[1];
+
+  if (keep)
+    first = scheme_null;
+  else
+    first = scheme_void;
+
+  for (i = hash->size; i--; ) {
+    bucket = hash->buckets[i];
+    if (bucket && bucket->val && bucket->key) {
+      if (hash->weak)
+	p[0] = *(Scheme_Object **)bucket->key;
+      else
+	p[0] = (Scheme_Object *)bucket->key;
+      p[1] = (Scheme_Object *)bucket->val;
+      if (keep) {
+	v = _scheme_apply(f, 2, p);
+	v = scheme_make_pair(v, scheme_null);
+	if (last)
+	  SCHEME_CDR(last) = v;
+	else
+	  first = v;
+	last = v;
+      } else
+	_scheme_apply_multi(f, 2, p);
+    }
+  }
+  
+  return first;
+}
+
+static Scheme_Object *hash_table_map(int argc, Scheme_Object *argv[])
+{
+  return do_map_hash_table(argc, argv, "hash-table-map", 1);
+}
+
+static Scheme_Object *hash_table_for_each(int argc, Scheme_Object *argv[])
+{
+  return do_map_hash_table(argc, argv, "hash-table-for-each", 0);
+}
+
+Scheme_Object *scheme_make_weak_box(Scheme_Object *v)
+{
+  Scheme_Small_Object *obj;
+
+  obj = (Scheme_Small_Object *)
+    scheme_malloc_atomic_tagged(sizeof(Scheme_Small_Object));
+
+  obj->type = scheme_weak_box_type;
+
+  obj->u.ptr_val = v;
+  scheme_weak_reference((void **)&obj->u.ptr_val);
+
+  return (Scheme_Object *)obj;
+}
+
+static Scheme_Object *make_weak_box(int argc, Scheme_Object *argv[])
+{
+  return scheme_make_weak_box(argv[0]);
+}
+
+static Scheme_Object *weak_box_value(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o;
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_weak_box_type))
+    scheme_wrong_type("weak-box-value", "weak-box", 0, argc, argv);
+
+  o = SCHEME_BOX_VAL(argv[0]);
+  if (!o)
+    return scheme_false;
+  else
+    return o;
+}
+
+static Scheme_Object *weak_boxp(int argc, Scheme_Object *argv[])
+{
+  return SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_weak_box_type)
+    ? scheme_true : scheme_false;
+}
diff --git a/src/mzscheme/src/macro.inc b/src/mzscheme/src/macro.inc
new file mode 100644
index 0000000..cf875d2
--- /dev/null
+++ b/src/mzscheme/src/macro.inc
@@ -0,0 +1,1131 @@
+  EVAL_ONE_STR(
+"(#%define-macro #%quasiquote"
+"(#%lambda(form)"
+"(#%let-values"
+"(((normal)"
+"(#%lambda(x old)"
+"(#%if(#%eq? x old)"
+"(#%if(#%null? x) x(#%list(#%quote #%quote) x))"
+" x))))"
+"(normal"
+"(#%letrec*-values"
+"(((qq)"
+"(#%lambda(x level)"
+"(#%let-values"
+"(((qq-list)"
+"(#%lambda(x level)"
+"(#%let-values"
+"(((old-first)(#%car x)))"
+"(#%let-values"
+"(((old-second)(#%cdr x)))"
+"(#%let-values"
+"(((first)(qq old-first level)))"
+"(#%let-values"
+"(((second)(qq old-second level)))"
+"(#%let-values"
+"()"
+"(#%if(#%if(#%eq? first old-first)"
+"(#%eq? second old-second)"
+" #f)"
+" x"
+"(#%list"
+"(#%quote #%cons)"
+"(normal first old-first)"
+"(normal second old-second)))))))))))"
+"(#%if(#%pair? x)"
+"(#%let-values"
+"(((first)(#%car x)))"
+"(#%if(#%if(#%eq? first(#%quote unquote))"
+"(#%list? x)"
+" #f)"
+"(#%let-values"
+"(((rest)(#%cdr x)))"
+"(#%if(#%let-values"
+"(((g35)(#%not(#%pair? rest))))"
+"(#%if g35 g35(#%not(#%null?(#%cdr rest)))))"
+"(#%raise-syntax-error"
+"(#%quote unquote)"
+" \"takes exactly one expression\""
+"(#%list(#%quote quasiquote) form)))"
+"(#%if(#%zero? level)"
+"(#%car rest)"
+"(qq-list x(#%sub1 level))))"
+"(#%if(#%if(#%eq? first(#%quote quasiquote))"
+"(#%list? x)"
+" #f)"
+"(qq-list x(#%add1 level))"
+"(#%if(#%if(#%eq? first(#%quote unquote-splicing))"
+"(#%list? x)"
+" #f)"
+"(#%raise-syntax-error"
+"(#%quote unquote-splicing)"
+" \"invalid context within quasiquote\""
+"(#%list(#%quote quasiquote) form))"
+"(#%if(#%if(#%pair? first)"
+"(#%if(#%eq?(#%car first)"
+"(#%quote unquote-splicing))"
+"(#%list? first)"
+" #f)"
+" #f)"
+"(#%let-values"
+"(((rest)(#%cdr first)))"
+"(#%if(#%let-values"
+"(((g34)(#%not(#%pair? rest))))"
+"(#%if g34"
+" g34"
+"(#%not(#%null?(#%cdr rest)))))"
+"(#%raise-syntax-error"
+"(#%quote unquote-splicing)"
+" \"takes exactly one expression\""
+"(#%list(#%quote quasiquote) form)))"
+"(#%let-values"
+"(((uqsd)(#%car rest))"
+"((old-l)(#%cdr x))"
+"((l)(qq(#%cdr x) level)))"
+"(#%if(#%zero? level)"
+"(#%let-values"
+"(((l)(normal l old-l)))"
+"(#%let-values"
+"()"
+"(#%list(#%quote #%append) uqsd l)))"
+"(#%let-values"
+"(((restx)(qq-list rest(#%sub1 level))))"
+"(#%let-values"
+"()"
+"(#%if(#%if(#%eq? l old-l)"
+"(#%eq? restx rest)"
+" #f)"
+" x"
+"(#%list"
+"(#%quote #%cons)"
+"(#%list"
+"(#%quote #%cons)"
+"(#%list"
+"(#%quote #%quote)"
+"(#%quote unquote-splicing))"
+"(normal restx rest))"
+"(normal l old-l))))))))"
+"(qq-list x level))))))"
+"(#%if(#%vector? x)"
+"(#%let-values"
+"(((l)(#%vector->list x)))"
+"(#%let-values"
+"(((l2)(qq l level)))"
+"(#%let-values"
+"()"
+"(#%if(#%eq? l l2)"
+" x"
+"(#%list(#%quote #%list->vector) l2)))))"
+"(#%if(#%box? x)"
+"(#%let-values"
+"(((v)(#%unbox x)))"
+"(#%let-values"
+"(((qv)(qq v level)))"
+"(#%let-values"
+"()"
+"(#%if(#%eq? v qv)"
+" x"
+"(#%list(#%quote #%box) qv)))))"
+" x)))))))"
+"(qq form 0))"
+" form))))"
+);
+  JUST_DEFINED_QQ(quasiquote);
+  EVAL_ONE_STR(
+"(#%define-macro #%and "
+"(#%case-lambda"
+"(() #t)"
+"((expr) expr)"
+"((expr . exprs)"
+" `(#%if ,expr"
+"(#%and ,@exprs)"
+" #f))))"
+);
+  JUST_DEFINED_KEY(and);
+  EVAL_ONE_STR(
+"(#%define-macro #%or"
+"(#%case-lambda "
+"(() #f)"
+"((expr) expr)"
+"((expr . exprs)"
+"(#%let((temp(#%gensym)))"
+" `(#%let((,temp ,expr))"
+"(#%if ,temp"
+" ,temp"
+"(#%or ,@exprs)))))))"
+);
+  JUST_DEFINED_KEY(or);
+  EVAL_ONE_STR(
+"(#%define-macro #%cond"
+"(#%lambda form"
+"(#%let((serror"
+"(#%lambda(msg at)"
+"(#%raise-syntax-error 'cond msg(#%cons 'cond form) at))))"
+"(#%let loop((tests form))"
+"(#%if(#%null? tests)"
+"(#%if(#%compile-allow-cond-fallthrough)"
+" '(#%void)"
+" '(#%cond))"
+"(#%if(#%not(#%pair? tests))"
+"(serror"
+" \"bad syntax (body must contain a list of pairs)\""
+" tests)"
+"(#%let((line(#%car tests))"
+"(rest(#%cdr tests)))"
+"(#%if(#%not(#%pair? line))"
+"(serror"
+" \"bad syntax (clause is not a test-value pair)\""
+" line)"
+"(#%let*((test(#%car line))"
+"(value(#%cdr line))"
+"(else?(#%and(#%eq? test 'else) "
+"(#%not(#%local-expansion-time-bound? 'else)))))"
+"(#%if(#%and else?(#%pair? rest))"
+" (serror \"bad syntax (`else' clause must be last)\" line))"
+"(#%if(#%and(#%pair? value)"
+"(#%eq? '=>(#%car value))"
+"(#%not(#%local-expansion-time-bound? '=>)))"
+"(#%if(#%and(#%pair?(#%cdr value))"
+"(#%null?(#%cddr value)))"
+"(#%let((test(#%if else?"
+" #t "
+" test))"
+"(gen(#%gensym)))"
+" `(#%let((,gen ,test))"
+"(#%if ,gen"
+"(,(#%cadr value) ,gen)"
+" ,(loop rest))))"
+"(serror"
+" \"bad syntax (bad clause form with =>)\""
+" line))"
+"(#%if else?"
+"(#%cons '#%begin value)"
+"(#%if(#%null? value)"
+"(#%let((gen(#%gensym)))"
+" `(#%let((,gen ,test))"
+"(#%if ,gen ,gen ,(loop rest))))"
+"(#%list"
+" '#%if test"
+"(#%cons '#%begin value)"
+"(loop rest))))))))))))))"
+);
+  JUST_DEFINED_COND(cond);
+  EVAL_ONE_STR(
+"(#%define-macro #%case "
+"(#%lambda(v . tests-in)"
+"(#%let((serror"
+"(#%lambda(msg at)"
+"(#%raise-syntax-error"
+" 'case"
+" msg"
+"(#%list* 'case v tests-in)"
+" at))))"
+"(#%let((gen(#%gensym)))"
+" `(#%let((,gen ,v))"
+"(#%cond"
+" ,@(#%let loop((tests tests-in))"
+"(#%cond"
+"((#%null? tests) `())"
+"((#%pair? tests)"
+"(#%let((test-value(#%car tests))"
+"(rest(#%cdr tests)))"
+"(#%cons"
+"(#%if(#%or(#%not(#%pair? test-value))"
+"(#%not(#%pair?(#%cdr test-value))))"
+"(serror"
+" \"bad syntax (clause is not a test-value pair)\""
+" test-value)"
+"(#%let((test(#%car test-value))"
+"(value(#%cdr test-value)))"
+"(#%if(#%and(#%pair? value)(#%list? value))"
+" #t"
+"(serror"
+" \"bad syntax (improper clause body)\""
+" value))"
+"(#%cons"
+"(#%cond"
+"((#%and(#%eq? test 'else)"
+"(#%not(#%local-expansion-time-bound? 'else)))"
+"(#%if(#%null? rest)"
+" 'else"
+"(serror"
+" \"bad syntax (`else' clause must be last)\""
+" test-value)))"
+"(else"
+"(#%if(#%not(#%list? test))"
+"(serror"
+" \"bad syntax (improper datum list)\""
+" test))"
+"(#%cons "
+" '#%or"
+"(#%let loop((test test))"
+"(#%cond"
+"((#%null? test)())"
+"(else"
+"(#%let((t(#%list '#%quote(#%car test))))"
+"(#%cons `(#%eqv? ,gen ,t)"
+"(loop(#%cdr test))))))))))"
+" `((#%begin ,@value)))))"
+"(loop rest))))"
+"(else(serror"
+" \"bad syntax (body must contain a list of pairs)\""
+" tests))))))))))"
+);
+  JUST_DEFINED_KEY(case);
+  EVAL_ONE_STR(
+"(#%define-macro #%do "
+"(#%lambda(bindings test-and-result . body)"
+"(#%let((code(#%list* 'do bindings test-and-result body)))"
+"(#%if(#%list? bindings)"
+"(#%void)"
+" (#%raise-syntax-error 'do \"bad syntax (bad binding sequence)\" code))"
+"(#%map(#%lambda(binding)"
+"(#%if(#%and(#%list? binding)"
+"(#%let((l(#%length binding)))"
+"(#%or(#%= l 2)(#%= l 3))))"
+"(#%void)"
+" (#%raise-syntax-error 'do \"bad syntax (bad binding)\" code)))"
+" bindings)"
+"(#%if(#%list? test-and-result)(#%void)"
+" (#%raise-syntax-error 'do \"bad syntax (bad test and result)\" code))"
+"(#%if(#%list? body)(#%void)"
+" (#%raise-syntax-error 'do \"bad syntax (improper body)\" code))"
+"(#%let*((vars(#%map(#%lambda(binding)"
+"(#%let((var(#%car binding)))"
+"(#%if(#%symbol? var)"
+" var"
+"(#%raise-syntax-error"
+" 'do \"bad syntax (variable must be an identifier)\""
+" code))))"
+" bindings))"
+"(inits(#%map #%cadr bindings))"
+"(steps(#%map(#%lambda(binding)"
+"(#%cond"
+"((#%pair?(#%cddr binding))"
+"(#%caddr binding))"
+"(else(#%car binding))))"
+" bindings))"
+"(test(#%if(#%pair? test-and-result)"
+"(#%car test-and-result)"
+"(#%raise-syntax-error"
+" 'do \"bad syntax (test/result part)\""
+" code)))"
+"(results(#%if(#%null?(#%cdr test-and-result))"
+"(#%list '(#%void))"
+"(#%cdr test-and-result)))"
+"(loop(#%gensym)))"
+" `(#%let ,loop ,(#%map(#%lambda(var init)"
+"(#%list var init))"
+" vars inits)"
+"(#%if ,test"
+"(#%begin"
+" ,@results)"
+"(#%begin"
+" ,@body"
+"(,loop ,@steps))))))))"
+);
+  JUST_DEFINED_KEY(do);
+  EVAL_ONE_STR(
+"(#%define-macro #%define"
+"(#%lambda body"
+"(#%let((code(#%cons 'define body)))"
+"(#%if(#%null? body)"
+"(#%raise-syntax-error"
+" 'define"
+" \"bad syntax (no definition body)\""
+" code))"
+"(#%let((first(#%car body))) "
+"(#%cond"
+"((#%symbol? first)"
+"(#%if(#%and(#%pair?(#%cdr body))"
+"(#%null?(#%cddr body)))"
+" `(#%define-values(,first) ,@(#%cdr body))"
+"(#%raise-syntax-error"
+" 'define"
+" \"bad syntax (zero or multiple expressions after identifier)\""
+" code)))"
+"((#%pair? first)"
+"(#%let((bad-symbol(#%lambda(s)(#%raise-syntax-error 'define"
+" \"bad identifier\""
+" code"
+" s))))"
+"(#%let loop((l first))"
+"(#%cond"
+"((#%null? l) #f)"
+"((#%pair? l) "
+"(#%if(#%symbol?(#%car l))"
+"(loop(#%cdr l))"
+"(bad-symbol(#%car l))))"
+"((#%symbol? l) #f)"
+"(else(bad-symbol l)))))"
+" "
+" `(#%define-values(,(#%car first))(#%lambda ,(#%cdr first) ,@(#%cdr body))))"
+"(else"
+"(#%raise-syntax-error"
+" 'define"
+" \"not an identifier\""
+" code"
+" first)))))))"
+);
+  JUST_DEFINED_KEY(define);
+  EVAL_ONE_STR(
+"(#%define-macro #%set!-values"
+"(#%lambda(args expr)"
+"(#%and(#%or(#%list? args)"
+"(#%raise-syntax-error"
+" 'set!-values"
+" \"bad syntax (illegal use of `.')\""
+"(#%list 'set!-values args expr)"
+" args))"
+"(#%andmap(#%lambda(arg)"
+"(#%or(#%symbol? arg)"
+"(#%raise-syntax-error"
+" 'set!-values"
+" \"bad syntax (not an identifier)\""
+"(#%list 'set!-values args expr)"
+" arg)))"
+" args))"
+"(#%if(#%and(#%pair? args)(#%null?(#%cdr args)))"
+" `(#%set! ,(#%car args) ,expr)"
+"(#%let((gens(#%map(#%lambda(arg)(#%gensym)) args)))"
+" `(#%let-values((,gens ,expr))"
+" ,@(#%if(#%null? args)"
+" `((#%void))"
+"(#%map(#%lambda(arg gen) `(#%set! ,arg ,gen)) args gens)))))))"
+);
+  JUST_DEFINED_KEY(set!-values);
+  EVAL_ONE_STR(
+"(#%define-macro #%delay"
+"(#%lambda(body)"
+" `(#%make-promise(#%lambda() ,body))))"
+);
+  JUST_DEFINED_KEY(delay);
+  EVAL_ONE_STR(
+"(#%define-macro #%let/cc "
+"(#%lambda(var expr1 . body)"
+" `(#%call/cc(#%lambda(,var) ,expr1 ,@body))))"
+);
+  JUST_DEFINED_KEY(let/cc);
+  EVAL_ONE_STR(
+"(#%define-macro #%let/ec "
+"(#%lambda(var expr1 . body)"
+" `(#%call/ec(#%lambda(,var) ,expr1 ,@body))))"
+);
+  JUST_DEFINED_KEY(let/ec);
+  EVAL_ONE_STR(
+"(#%define-macro #%when "
+"(#%lambda(test expr1 . body)"
+" `(#%if ,test"
+"(#%begin"
+" ,expr1"
+" ,@body))))"
+);
+  JUST_DEFINED_KEY(when);
+  EVAL_ONE_STR(
+"(#%define-macro #%unless "
+"(#%lambda(test expr1 . body)"
+" `(#%if ,test"
+"(#%void)"
+"(#%begin"
+" ,expr1"
+" ,@body))))"
+);
+  JUST_DEFINED_KEY(unless);
+  EVAL_ONE_STR(
+"(#%define-macro #%define-struct"
+"(#%lambda body"
+"(#%let((syntax-error"
+"(#%lambda(s . detail)"
+"(#%apply"
+" #%raise-syntax-error"
+" 'define-struct"
+" s"
+"(#%cons 'define-struct body)"
+" detail)))"
+"(build-struct-names"
+"(#%lambda(name fields)"
+"(#%let((name(#%symbol->string name))"
+"(fields(#%map #%symbol->string fields))"
+"(+ #%string-append))"
+"(#%map #%string->symbol"
+"(#%append"
+"(#%list "
+" (+ \"struct:\" name)"
+" (+ \"make-\" name)"
+" (+ name \"?\"))"
+"(#%apply"
+" #%append"
+"(#%map"
+"(#%lambda(f) "
+"(#%list "
+" (+ name \"-\" f)"
+" (+ \"set-\" name \"-\" f \"!\")))"
+" fields))))))))"
+"(#%or(#%pair? body)"
+" (syntax-error \"empty declaration\"))"
+"(#%or(#%= 2(#%length body))"
+" (syntax-error \"wrong number of parts\"))"
+"(#%or(#%symbol?(#%car body))"
+"(#%and(#%pair?(#%car body))"
+"(#%symbol?(#%caar body))"
+"(#%pair?(#%cdar body))"
+"(#%null?(#%cddar body)))"
+" (syntax-error \"first part must be an identifier or identifier-expression pair\"))"
+"(#%or(#%list?(#%cadr body))"
+" (syntax-error \"illegal use of `.' in field list\"))"
+"(#%for-each(#%lambda(x) "
+"(#%or(#%symbol? x)"
+" (syntax-error \"field name not a identifier\" x)))"
+"(#%cadr body))"
+"(#%let((name(#%if(#%symbol?(#%car body))"
+"(#%car body)"
+"(#%caar body)))"
+"(fields(#%cadr body)))"
+" `(#%define-values ,(build-struct-names name fields)(#%struct ,@body))))))"
+);
+  JUST_DEFINED_KEY(define-struct);
+  EVAL_ONE_STR(
+"(#%define-macro #%let-struct"
+"(#%lambda(base field . body)"
+" `(#%let()(#%define-struct ,base ,field) ,@body)))"
+);
+  JUST_DEFINED_KEY(let-struct);
+#ifndef NO_OBJECT_SYSTEM
+  EVAL_ONE_STR(
+"(#%define-macro #%class "
+"(#%lambda(super args . rest)"
+" `(#%class*/names(this super-init) ,super() ,args ,@rest)))"
+);
+  JUST_DEFINED_KEY(class);
+  EVAL_ONE_STR(
+"(#%define-macro #%class* "
+"(#%lambda(super interfaces args . rest)"
+" `(#%class*/names(this super-init) ,super ,interfaces ,args ,@rest)))"
+);
+  JUST_DEFINED_KEY(class*);
+  EVAL_ONE_STR(
+"(#%define-macro #%send "
+"(#%lambda(obj msg . params)"
+" `((#%ivar ,obj ,msg) ,@params)))"
+);
+  JUST_DEFINED_KEY(send);
+  EVAL_ONE_STR(
+"(#%define-macro #%make-generic "
+"(#%lambda(c% name)"
+" `(#%uq-make-generic ,c%(quote ,name))))"
+);
+  JUST_DEFINED_KEY(make-generic);
+  EVAL_ONE_STR(
+"(#%define-macro #%ivar "
+"(#%lambda args"
+"(#%if(#%list? args)"
+"(#%let((l(#%length args)))"
+"(#%cond"
+"((#%= l 2) `(#%uq-ivar ,(#%car args)(#%quote ,(#%cadr args))))"
+"(else(#%raise-syntax-error"
+" 'ivar"
+" (#%format \"bad syntax (~s parts after the keyword)\" l)"
+"(#%cons 'ivar args)))))"
+"(#%raise-syntax-error"
+" 'ivar"
+" \"bad syntax (illegal use of `.')\""
+"(#%cons 'ivar args)))))"
+);
+  JUST_DEFINED_KEY(ivar);
+#endif
+  EVAL_ONE_STR(
+"(#%define-macro #%fluid-let "
+"(#%lambda(assignments expr1 . body)"
+"(#%if(#%null? assignments)"
+" `(#%begin ,expr1 ,@body)"
+"(#%let((mk-expr(lambda()(#%list* 'fluid-let "
+" assignments "
+" expr1"
+" body))))"
+"(#%unless(#%list? assignments)"
+"(#%raise-syntax-error 'fluid-let"
+" \"bad syntax\" (mk-expr)"
+" assignments))"
+"(#%let((tempnames(#%map(#%lambda(assignment) "
+"(#%cond"
+"((#%and(#%pair? assignment)"
+"(#%symbol?(#%car assignment))"
+"(#%pair?(#%cdr assignment))"
+"(#%null?(#%cddr assignment)))"
+"(#%gensym))"
+"(else"
+"(#%raise-syntax-error"
+" 'fluid-let"
+" \"bad syntax\""
+"(mk-expr)"
+" assignment))))"
+" assignments)))"
+" `(#%let ,(#%map(#%lambda(tempname assignment)"
+"(#%list tempname(#%car assignment)))"
+" tempnames assignments)"
+"(#%dynamic-wind"
+"(#%lambda()"
+" ,@(#%map(#%lambda(assignment)"
+" `(#%set! ,(#%car assignment) ,(#%cadr assignment)))"
+" assignments))"
+"(#%lambda() ,expr1 ,@body)"
+"(#%lambda()"
+" ,@(#%map(#%lambda(assignment tempname)"
+" `(#%set! ,(#%car assignment) ,tempname))"
+" assignments tempnames)))))))))"
+);
+  JUST_DEFINED_KEY(fluid-let);
+  EVAL_ONE_STR(
+"(#%define-macro #%parameterize"
+"(#%lambda(params . body)"
+"(#%let((fail"
+"(#%lambda(msg)"
+"(#%raise-syntax-error"
+" 'parameterize"
+" msg"
+"(#%list* 'parameterize params body)))))"
+" (#%if (#%null? body) (fail \"bad syntax (empty body)\"))"
+"(#%if(#%null? params)"
+" `(#%begin ,@body)"
+"(#%if(#%or(#%not(#%pair? params))"
+"(#%not(#%pair?(#%car params)))"
+"(#%not(#%pair?(#%cdar params)))"
+"(#%not(#%null?(#%cddar params))))"
+" (fail \"bad syntax\")"
+"(#%let((param(#%caar params))"
+"(orig(#%gensym))"
+"(pz(#%gensym)))"
+" `(#%let*((,pz(#%in-parameterization(#%current-parameterization) ,param))"
+"(,orig(,pz)))"
+"(#%dynamic-wind"
+"(#%lambda()(,pz ,(#%cadar params)))"
+"(#%lambda()(parameterize ,(cdr params) ,@body))"
+"(#%lambda()(,pz ,orig))))))))))"
+);
+  JUST_DEFINED_KEY(parameterize);
+  EVAL_ONE_STR(
+"(#%define-macro #%with-handlers"
+"(#%lambda(clauses . body)"
+"(#%if(#%and(#%list? clauses)"
+"(#%andmap(#%lambda(p)"
+"(#%and(#%pair? p)"
+"(#%pair?(#%cdr p))"
+"(#%null?(#%cddr p))))"
+" clauses)"
+"(#%pair? body))"
+"(#%void)"
+" (#%raise-syntax-error 'with-handlers \"bad syntax\""
+"(#%list* 'with-handlers clauses body)))"
+"(if(#%null? clauses)"
+" `(begin ,@body)"
+"(#%let((k(#%gensym))"
+"(loop(#%gensym))"
+"(list(#%gensym)))"
+" `((#%call/ec "
+"(#%lambda(,k)"
+"(#%let((,list(#%list ,@(#%map(#%lambda(p)"
+" `(#%cons ,(#%car p)"
+" ,(#%cadr p)))"
+" clauses))))"
+"(#%parameterize((#%current-exception-handler"
+"(#%lambda(e)"
+"(,k"
+"(#%let ,loop((,list ,list))"
+"(#%cond"
+"((#%null? ,list)"
+"(#%lambda()(#%raise e)))"
+"(((#%caar ,list) e)"
+"(#%lambda()((#%cdar ,list) e)))"
+"(else"
+"(,loop(#%cdr ,list)))))))))"
+"(#%call-with-values"
+"(#%lambda() ,@body)"
+"(#%lambda args(,k(#%lambda()(#%apply #%values args))))))))))))))"
+);
+  JUST_DEFINED_KEY(with-handlers);
+#ifdef USE_STRUCT_CASE
+  EVAL_ONE_STR(
+"(#%define-macro #%struct-case-lambda"
+"(#%lambda(x . pairs)"
+"(#%unless(#%and(#%symbol? x)"
+"(#%list? pairs)"
+"(#%andmap(#%lambda(p)(#%and(#%list? p)(#%not(#%null? p)))) pairs))"
+" (#%raise-syntax-error 'struct-case-lambda \"bad syntax\""
+"(#%list* 'struct-case-lambda x pairs)))"
+"(#%let-values(((predicates functions else)"
+"(#%let loop((l pairs))"
+"(#%if(#%null? l)"
+"(#%values()()())"
+"(#%let-values(((p-rest f-rest else)(loop(#%cdr l)))"
+"((p)(#%caar l))"
+"((f)(#%let((r(#%cdar l)))"
+" `(#%lambda(,x) ,@(#%if(#%null? r)"
+" '(x)"
+" r)))))"
+"(#%cond"
+"((#%and(#%eq? p 'else)"
+"(#%not(#%local-expansion-time-bound? 'else)))"
+"(#%unless(#%null? p-rest)"
+" (#%raise-syntax-error 'struct-case-lambda \"else clause must be last\""
+"(#%list* 'struct-case-lambda x pairs)))"
+"(#%values()()(#%list f)))"
+"(else"
+"(#%values(#%cons p p-rest)"
+"(#%cons f f-rest)"
+" else))))))))"
+"(#%list* '#%make-struct-case "
+"(#%cons '#%list predicates)"
+"(#%cons '#%list functions)"
+" else))))"
+);
+  JUST_DEFINED_KEY(struct-case-lambda);
+#endif
+  EVAL_ONE_STR(
+"(#%define with-parameterization"
+"(#%lambda(p thunk)"
+"(#%unless(#%parameterization? p)"
+" (#%raise-type-error 'with-parameterization \"parameterization\" p))"
+"(#%unless(#%and(#%procedure? thunk)"
+"(#%procedure-arity-includes? thunk 0))"
+" (#%raise-type-error 'with-parameterization \"procedure (arity 0)\" thunk))"
+"(#%let*((orig(#%current-parameterization)))"
+"(#%dynamic-wind"
+"(#%lambda()(#%current-parameterization p))"
+"(#%lambda()(thunk))"
+"(#%lambda()(#%current-parameterization orig))))))"
+);
+  JUST_DEFINED_FUNC(with-parameterization);
+  EVAL_ONE_STR(
+"(#%define with-new-parameterization"
+"(#%lambda(thunk)"
+"(#%unless(#%and(#%procedure? thunk)"
+"(#%procedure-arity-includes? thunk 0))"
+" (#%raise-type-error 'with-new-parameterization \"procedure (arity 0)\" thunk))"
+"(#%let*((naya(#%make-parameterization)))"
+"(#%with-parameterization naya thunk))))"
+);
+  JUST_DEFINED_FUNC(with-new-parameterization);
+  EVAL_ONE_STR(
+"(#%define load/cd"
+"(#%let((make-exn make-exn:i/o:filesystem:directory)"
+"(debug debug-info-handler))"
+"(#%lambda(n)"
+"(#%unless(#%string? n)"
+" (#%raise-type-error 'load/cd \"string\" n))"
+"(#%let-values(((base name dir?)(#%split-path n)))"
+"(#%if dir?"
+"(#%raise"
+"(make-exn"
+" (#%format \"load/cd: cannot open a directory: ~s\" n)"
+"((debug))"
+" n))"
+"(#%if(#%not(#%string? base))"
+"(#%load n)"
+"(#%begin"
+"(#%if(#%not(#%directory-exists? base))"
+"(#%raise"
+"(make-exn"
+"(#%format "
+" \"load/cd: directory of ~s does not exist (current directory is ~s)\" "
+" n(#%current-directory))"
+"((debug))"
+" base)))"
+"(#%let((orig(#%current-directory)))"
+"(#%dynamic-wind"
+"(#%lambda()(#%current-directory base))"
+"(#%lambda()(#%load name))"
+"(#%lambda()(#%current-directory orig)))))))))))"
+);
+  JUST_DEFINED_FUNC(load/cd);
+  EVAL_ONE_STR(
+"(#%define(read-eval-print-loop)"
+"(#%let*((eeh #f)"
+"(jump #f)"
+"(rep-error-escape-handler(lambda()(jump))))"
+"(#%dynamic-wind"
+"(#%lambda()(#%set! eeh(#%error-escape-handler))"
+"(#%error-escape-handler rep-error-escape-handler))"
+"(#%lambda()"
+"(#%let/ec done"
+"(#%let loop()"
+"(#%let/ec k"
+"(#%set! jump k)"
+"(#%let((v((#%current-prompt-read))))"
+"(#%when(#%eof-object? v)(done))"
+"(#%call-with-values"
+"(#%lambda()((#%current-eval) v))"
+"(#%lambda results(#%for-each(#%current-print) results)))))"
+"(loop))))"
+"(#%lambda()(#%error-escape-handler eeh)"
+"(#%set! jump #f)"
+"(#%set! eeh #f)))))"
+);
+  JUST_DEFINED_FUNC(read-eval-print-loop);
+#ifndef NO_FILE_SYSTEM_UTILS
+  EVAL_ONE_STR(
+"(#%define load/use-compiled"
+" (#%let ((re:suffix (#%regexp \"\\\\..?.?.?$\"))"
+"(resolve(#%lambda(s)"
+"(#%if(#%complete-path? s)"
+" s"
+"(#%let((d(#%current-load-relative-directory)))"
+"(#%if d(#%path->complete-path s d) s)))))"
+"(date>=?"
+"(#%lambda(a bm)"
+"(#%let((am(#%file-modify-seconds a)))"
+"(#%or(#%and(#%not bm) am)(#%and am bm(#%>= am bm)))))))"
+"(#%lambda(path)"
+"(#%unless(#%and(#%string? path)(#%or(#%relative-path? path)(#%absolute-path? path)))"
+" (#%raise-type-error 'load/use-compiled \"pathname string\" path))"
+"(#%let*-values(((path)(resolve path))"
+"((base file dir?)(#%split-path path))"
+"((base)(#%if(#%eq? base 'relative) 'same base)))"
+"(#%let*((get-so(#%lambda(file)"
+"(#%build-path base"
+" \"compiled\""
+" \"native\""
+"(#%system-library-subpath)"
+"(#%regexp-replace "
+" re:suffix file"
+"(#%case(#%system-type)"
+" ((windows) \".dll\")"
+" (else \".so\"))))))"
+"(zo(#%build-path base"
+" \"compiled\""
+" (#%regexp-replace re:suffix file \".zo\")))"
+"(so(get-so file))"
+" (_loader-so (get-so \"_loader.ss\"))"
+"(path-d(#%file-modify-seconds path))"
+"(with-dir(#%lambda(t)(#%parameterize((#%current-load-relative-directory "
+"(#%if(#%string? base) base(#%current-directory))))(t)))))"
+"(#%cond"
+"((#%and(date>=? _loader-so path-d)"
+"(#%let((getter(#%load-extension _loader-so)))"
+" (getter (#%string->symbol (#%regexp-replace re:suffix file \"\")))))"
+" =>(#%lambda(loader)(with-dir loader)))"
+"((date>=? so path-d)"
+"(with-dir(#%lambda()((#%current-load-extension) so))))"
+"((date>=? zo path-d)"
+"(with-dir(#%lambda()((#%current-load) zo))))"
+"(else(#%load path))))))))"
+);
+  JUST_DEFINED_FUNC(load/use-compiled);
+  EVAL_ONE_STR(
+"(#%define-values(load-relative load-relative-extension)"
+"(#%let((mk"
+"(#%lambda(load name)"
+"(#%lambda(path)"
+"(#%unless(#%and(#%string? path)(#%or(#%relative-path? path)(#%absolute-path? path)))"
+" (#%raise-type-error name \"pathname string\" path))"
+"(#%if(#%complete-path? path)"
+"(load path)"
+"(#%let((dir(#%current-load-relative-directory)))"
+"(load(#%if dir(#%path->complete-path path dir) path))))))))"
+"(#%values(mk #%load 'load-relative)(mk #%load-extension 'load-relative-extension))))"
+);
+  JUST_DEFINED_FUNC(load-relative);
+  JUST_DEFINED_FUNC(load-relative-extension);
+  EVAL_ONE_STR(
+"(#%define-values(require-library require-relative-library collection-path)"
+"(#%let*((get-table current-loaded-library-table)"
+"(not-found(box 0))"
+"(null-str(#%string #\\nul))"
+"(debug debug-info-handler)"
+"(make-path-exn make-exn:i/o:filesystem:path)"
+"(check(#%lambda(who s)"
+"(#%unless(#%string? s)"
+" (#%raise-type-error who \"string\" s))"
+"(#%unless(#%relative-path? s)"
+"(#%raise(make-path-exn"
+" (#%format \"~a: invalid relative path: ~s\" who s)"
+"((debug)) s)))))"
+"(with-null(#%lambda(l)(#%let loop((l l))"
+"(#%if(#%null? l)"
+" #%null"
+"(#%list*(#%car l) null-str(loop(#%cdr l)))))))"
+"(make-coll-exn make-exn:i/o:filesystem:collection)"
+"(make-file-exn make-exn:i/o:filesystem:file)"
+"(check-collection"
+"(#%lambda(who collection collection-path)"
+"(check who collection)(#%for-each(lambda(p)(check who p)) collection-path)))"
+"(find-col"
+"(#%lambda(who collection collection-path)"
+"(#%let((all-paths(#%current-library-collection-paths)))"
+"(#%let loop((paths all-paths))"
+"(#%if(#%null? paths)"
+"(#%raise"
+"(make-coll-exn"
+" (#%format \"~a: collection not found: ~s in any of: ~s\" "
+" who collection all-paths)"
+"((debug))"
+" collection))"
+"(#%let((dir(#%build-path(#%car paths) collection)))"
+"(#%if(#%directory-exists? dir)"
+"(#%let*((cpath(#%apply #%build-path dir collection-path)))"
+"(#%if(#%directory-exists? cpath)"
+" cpath"
+"(let loop((p dir)(l collection-path)(c collection))"
+"(#%let((np(#%build-path p(#%car l)))"
+"(nc(#%build-path c(#%car l))))"
+"(#%if(#%directory-exists? np)"
+"(loop np(#%cdr l) nc)"
+"(#%raise"
+"(make-coll-exn"
+" (#%format \"require-library: collection ~s does not have sub-collection: ~s in: ~s\""
+" c(#%car l) p)"
+"((debug))"
+" nc)))))))"
+"(loop(#%cdr paths))))))))))"
+"(#%letrec((collection-path(#%lambda(collection . collection-path) "
+"(check-collection 'collection-path collection collection-path)"
+"(find-col 'collection-path collection collection-path)))"
+"(require-relative-library"
+"(#%lambda(file . collection-path)"
+"(check 'require-relative-library file) "
+"(check-collection 'require-relative-library file collection-path)"
+"(#%let((cp(#%current-require-relative-collection)))"
+"(#%if cp"
+"(#%apply require-library file(#%append cp collection-path))"
+"(#%raise"
+"(make-coll-exn"
+" (#%format \"require-relative-library: there is no current collection for library: ~s~a\""
+" file"
+"(#%if(#%null? collection-path)"
+" \"\""
+" (#%format \" in sub-collection: ~s\" collection-path)))"
+"((debug))"
+"(#%apply #%build-path file collection-path)))))))"
+"(require-library"
+"(#%case-lambda"
+" ((file) (require-library file \"mzlib\"))"
+"((file collection . collection-path)"
+"(check 'require-library file)(check-collection 'require-library collection collection-path)"
+"(#%let((table(get-table))"
+"(sym(#%string->symbol(#%apply #%string-append "
+"(with-null(#%list* file collection collection-path))))))"
+"(#%let((found(#%hash-table-get table sym(#%lambda() not-found))))"
+"(#%if(#%eq? found not-found)"
+"(#%let*((c(find-col 'require-library collection collection-path))"
+"(p(#%build-path c file))"
+"(result(#%if(#%file-exists? p)"
+"(#%parameterize((#%current-require-relative-collection"
+"(#%cons collection collection-path)))"
+"(#%call-with-values"
+"(#%lambda()"
+"((#%if(#%require-library-use-compiled)"
+" #%load/use-compiled "
+" #%load)"
+" p))"
+" #%list))"
+"(#%raise"
+"(make-file-exn"
+" (#%format \"require-library: collection ~s does not have library: ~s in: ~s\""
+"(#%apply #%build-path collection collection-path) file c)"
+"((debug))"
+" p)))))"
+"(#%hash-table-put! table sym result)"
+"(#%apply #%values result))"
+"(#%apply #%values found))))))))"
+"(#%values require-library require-relative-library collection-path))))"
+);
+  JUST_DEFINED_FUNC(require-library);
+  JUST_DEFINED_FUNC(require-relative-library);
+  JUST_DEFINED_FUNC(collection-path);
+  EVAL_ONE_STR(
+"(#%define-macro #%reference-library"
+"(#%letrec((rl(#%case-lambda "
+" ((name) (rl name \"mzlib\"))"
+"((name collection . collection-path)"
+"(#%let((name(#%local-expand-defmacro name))"
+"(collection(#%local-expand-defmacro collection))"
+"(check(#%lambda(s kind)"
+"(#%unless(#%string? s)"
+"(#%raise-syntax-error "
+" 'reference-library"
+" (#%format \"~s name is not a string\" kind)"
+"(#%list 'reference-library name collection))))))"
+" (check name \"library\")"
+" (check collection \"collection\")"
+" (#%for-each (#%lambda (c) (check c \"sub-collection\")) collection-path)"
+" `(#%require-library ,name ,collection ,@collection-path))))))"
+" rl))"
+);
+  JUST_DEFINED_KEY(reference-library);
+  EVAL_ONE_STR(
+"(#%define path-list-string->path-list"
+"(#%let((r(#%regexp(#%let((sep(#%case(#%system-type) "
+" ((unix) \":\")"
+" ((windows macos) \";\"))))"
+" (#%format \"([^~a]*)~a(.*)\" sep sep))))"
+"(cons-path(#%lambda(default s l) "
+" (#%if (#%string=? s \"\")"
+"(#%append default l)"
+"(#%if(#%or(#%relative-path? s)(#%absolute-path? s))(#%cons s l) l)))))"
+"(#%lambda(s default)"
+" (#%unless (#%string? s) (#%raise-type-error 'path-list-string->path-list \"string\" s))"
+" (#%unless (#%list? default) (#%raise-type-error 'path-list-string->path-list \"list\" default))"
+"(#%let loop((s s))"
+"(#%let((m(#%regexp-match r s)))"
+"(#%if m"
+"(cons-path default(#%cadr m)(loop(#%caddr m)))"
+"(cons-path default s #%null)))))))"
+);
+  JUST_DEFINED_FUNC(path-list-string->path-list);
+  EVAL_ONE_STR(
+"(#%define find-executable-path"
+"(#%lambda(program libpath)"
+"(#%unless(#%string? program)"
+" (#%raise-type-error 'find-executable-path \"string\" program))"
+"(#%unless(#%string? libpath)"
+" (#%raise-type-error 'find-executable-path \"string\" libpath))"
+"(#%letrec((found-exec"
+"(#%lambda(exec-name)"
+"(#%let-values(((base name isdir?)(#%split-path exec-name)))"
+"(#%if(#%string? base)"
+"(#%let((lib(#%build-path base libpath)))"
+"(#%if(#%or(#%directory-exists? lib) "
+"(#%file-exists? lib))"
+" lib"
+"(#%let((resolved(#%resolve-path exec-name)))"
+"(#%cond"
+"((#%string=? resolved exec-name) #f)"
+"((#%relative-path? resolved)"
+"(found-exec(#%build-path base resolved)))"
+"(else(found-exec resolved))))))"
+" #f)))))"
+"(#%if(#%relative-path? program)"
+" (#%let ((paths-str (#%getenv \"PATH\")))"
+"(#%let loop((paths(#%if paths-str(#%path-list-string->path-list paths-str #%null) #%null)))"
+"(#%if(#%null? paths)"
+" #f"
+"(#%let*((base(#%path->complete-path(#%car paths)))"
+"(name(#%build-path base program)))"
+"(#%if(#%file-exists? name)"
+"(found-exec name)"
+"(loop(#%cdr paths)))))))"
+"(found-exec program)))))"
+);
+  JUST_DEFINED_FUNC(find-executable-path);
+#endif
+#ifdef TIME_SYNTAX
+  EVAL_ONE_STR(
+"(#%define-macro #%time"
+"(#%lambda(expr1 . body)"
+" `(#%let-values(((s)(#%current-gc-milliseconds))"
+"((v cpu user)(#%time-apply(#%lambda() ,expr1 ,@body))))"
+" (#%printf \"cpu time: ~s real time: ~s gc time: ~s~n\""
+" cpu user(#%-(#%current-gc-milliseconds) s))"
+"(#%apply #%values v))))"
+);
+  JUST_DEFINED_KEY(time);
+#endif
+#ifndef NO_UNIT_SYSTEM
+  EVAL_ONE_STR(
+"(#%define verify-linkage-signature-match"
+"(#%let((make-non #%make-exn:unit:signature:non-signed-unit)"
+"(make-arity #%make-exn:unit:signature:arity)"
+"(p-suffix(#%lambda(pos)(#%case pos((1) 'st)((2) 'nd)((3) 'rd)(else 'th)))))"
+"(#%lambda(who tags units esigs isigs)"
+"(#%for-each"
+"(#%lambda(u tag)"
+"(#%unless(#%unit-with-signature? u)"
+"(#%raise"
+"(make-non"
+"(#%format"
+" \"~s: expression for \\\"~s\\\" is not a signed unit\""
+" who tag)"
+"((#%debug-info-handler)) u))))"
+" units tags)"
+"(#%for-each"
+"(#%lambda(u tag esig)"
+"(#%verify-signature-match"
+" who #f"
+" (#%format \"specified export signature for ~a\" tag)"
+" esig"
+" (#%format \"export signature for actual ~a sub-unit\" tag)"
+"(#%unit-with-signature-exports u)))"
+" units tags esigs)"
+"(#%for-each"
+"(#%lambda(u tag isig)"
+"(#%let((n(#%length(#%unit-with-signature-imports u)))"
+"(c(#%length isig)))"
+"(#%unless(#%= c n)"
+"(#%raise"
+"(make-arity"
+"(#%format"
+" \"~s: ~a unit imports ~a units, but ~a units were provided\""
+" who tag n c)"
+"((#%debug-info-handler)) u)))))"
+" units tags isigs)"
+"(#%for-each"
+"(#%lambda(u tag isig)"
+"(#%let loop((isig isig)(expecteds(#%unit-with-signature-imports u))(pos 1))"
+"(#%unless(#%null? isig)"
+"(#%let((expected(#%car expecteds))"
+"(provided(#%car isig)))"
+"(#%verify-signature-match"
+" who #t"
+" (#%format \"~a unit's ~s~s import (~a signature)\" tag"
+" pos(p-suffix pos)"
+"(#%car expected))"
+"(#%cdr expected)"
+" (#%format \"~s~s linkage (~a signature) for ~a\""
+" pos(p-suffix pos)"
+"(#%car provided)"
+" tag)"
+"(#%cdr provided))"
+"(loop(#%cdr isig)(#%cdr expecteds)(#%add1 pos))))))"
+" units tags isigs))))"
+);
+  JUST_DEFINED_FUNC(verify-linkage-signature-match);
+  EVAL_ONE_STR(
+"(#%define-values(unit/sig? unit-with-signature->unit unit/sig->unit)"
+"(values #%unit-with-signature?"
+" #%unit-with-signature-unit"
+" #%unit-with-signature-unit))"
+);
+  JUST_DEFINED_FUNC(unit/sig?);
+  JUST_DEFINED_FUNC(unit-with-signature->unit);
+  JUST_DEFINED_FUNC(unit/sig->unit);
+#endif
+  EVAL_ONE_STR(
+"(#%define rationalize"
+"(#%letrec((check(#%lambda(x) "
+" (#%unless (#%real? x) (#%raise-type-error 'rationalize \"real\" x))))"
+"(find-between "
+"(#%lambda(lo hi)"
+"(#%if(#%integer? lo)"
+" lo"
+"(#%let((lo-int(#%floor lo))"
+"(hi-int(#%floor hi)))"
+"(#%if(#%< lo-int hi-int)"
+"(#%add1 lo-int)"
+"(#%+ lo-int"
+"(#%/(find-between(#%/(#%- hi lo-int))(#%/(#%- lo lo-int)))))))))))"
+"(#%lambda(x within)"
+"(check x)(check within)"
+"(#%let*((delta(#%abs within))"
+"(lo(#%- x delta))"
+"(hi(#%+ x delta)))"
+"(#%cond"
+"((#%not(#%= x x)) +nan.0)"
+"((#%<= lo 0 hi)(#%if(#%exact? x) 0 0.0))"
+"((#%negative? lo)(#%-(find-between(#%- hi)(#%- lo))))"
+"(else(find-between lo hi)))))))"
+);
+  JUST_DEFINED_FUNC(rationalize);
+  EVAL_ONE_STR(
+"(#%define(simple-return-primitive? v)"
+" (#%unless (#%primitive? v) (#%raise-type-error 'simple-return-primitive? \"primitive-procedure\" v))"
+"(#%not(#%memq(#%inferred-name v) '(call-with-values "
+" apply "
+" error"
+" call-with-current-continuation"
+" hash-table-get"
+" write-image-to-file))))"
+);
+  JUST_DEFINED_FUNC(simple-return-primitive?);
+  EVAL_ONE_STR(
+"(#%define(port? x)(#%or(#%input-port? x)(#%output-port? x)))"
+);
+  JUST_DEFINED_FUNC(port?);
diff --git a/src/mzscheme/src/macro.ss b/src/mzscheme/src/macro.ss
new file mode 100644
index 0000000..bc05aaa
--- /dev/null
+++ b/src/mzscheme/src/macro.ss
@@ -0,0 +1,1136 @@
+(#%define-macro #%quasiquote
+  (#%lambda (form)
+    (#%let-values
+      (((normal)
+        (#%lambda (x old)
+          (#%if (#%eq? x old)
+            (#%if (#%null? x) x (#%list (#%quote #%quote) x))
+            x))))
+      (normal
+        (#%letrec*-values
+          (((qq)
+            (#%lambda (x level)
+              (#%let-values
+                (((qq-list)
+                  (#%lambda (x level)
+                    (#%let-values
+                      (((old-first) (#%car x)))
+                      (#%let-values
+                        (((old-second) (#%cdr x)))
+                        (#%let-values
+                          (((first) (qq old-first level)))
+                          (#%let-values
+                            (((second) (qq old-second level)))
+                            (#%let-values
+                              ()
+                              (#%if (#%if (#%eq? first old-first)
+                                      (#%eq? second old-second)
+                                      #f)
+                                x
+                                (#%list
+                                  (#%quote #%cons)
+                                  (normal first old-first)
+                                  (normal second old-second)))))))))))
+                (#%if (#%pair? x)
+                  (#%let-values
+                    (((first) (#%car x)))
+                    (#%if (#%if (#%eq? first (#%quote unquote))
+                            (#%list? x)
+                            #f)
+                      (#%let-values
+                        (((rest) (#%cdr x)))
+                        (#%if (#%let-values
+                                (((g35) (#%not (#%pair? rest))))
+                                (#%if g35 g35 (#%not (#%null? (#%cdr rest)))))
+                          (#%raise-syntax-error
+                            (#%quote unquote)
+                            "takes exactly one expression"
+                            (#%list (#%quote quasiquote) form)))
+                        (#%if (#%zero? level)
+                          (#%car rest)
+                          (qq-list x (#%sub1 level))))
+                      (#%if (#%if (#%eq? first (#%quote quasiquote))
+                              (#%list? x)
+                              #f)
+                        (qq-list x (#%add1 level))
+                        (#%if (#%if (#%eq? first (#%quote unquote-splicing))
+                                (#%list? x)
+                                #f)
+                          (#%raise-syntax-error
+                            (#%quote unquote-splicing)
+                            "invalid context within quasiquote"
+                            (#%list (#%quote quasiquote) form))
+                          (#%if (#%if (#%pair? first)
+                                  (#%if (#%eq? (#%car first)
+                                               (#%quote unquote-splicing))
+                                    (#%list? first)
+                                    #f)
+                                  #f)
+                            (#%let-values
+                              (((rest) (#%cdr first)))
+                              (#%if (#%let-values
+                                      (((g34) (#%not (#%pair? rest))))
+                                      (#%if g34
+                                        g34
+                                        (#%not (#%null? (#%cdr rest)))))
+                                (#%raise-syntax-error
+                                  (#%quote unquote-splicing)
+                                  "takes exactly one expression"
+                                  (#%list (#%quote quasiquote) form)))
+                              (#%let-values
+                                (((uqsd) (#%car rest))
+                                 ((old-l) (#%cdr x))
+                                 ((l) (qq (#%cdr x) level)))
+                                (#%if (#%zero? level)
+                                  (#%let-values
+                                    (((l) (normal l old-l)))
+                                    (#%let-values
+                                      ()
+                                      (#%list (#%quote #%append) uqsd l)))
+                                  (#%let-values
+                                    (((restx) (qq-list rest (#%sub1 level))))
+                                    (#%let-values
+                                      ()
+                                      (#%if (#%if (#%eq? l old-l)
+                                              (#%eq? restx rest)
+                                              #f)
+                                        x
+                                        (#%list
+                                          (#%quote #%cons)
+                                          (#%list
+                                            (#%quote #%cons)
+                                            (#%list
+                                              (#%quote #%quote)
+                                              (#%quote unquote-splicing))
+                                            (normal restx rest))
+                                          (normal l old-l))))))))
+                            (qq-list x level))))))
+                  (#%if (#%vector? x)
+                    (#%let-values
+                      (((l) (#%vector->list x)))
+                      (#%let-values
+                        (((l2) (qq l level)))
+                        (#%let-values
+                          ()
+                          (#%if (#%eq? l l2)
+                            x
+                            (#%list (#%quote #%list->vector) l2)))))
+                    (#%if (#%box? x)
+                      (#%let-values
+                        (((v) (#%unbox x)))
+                        (#%let-values
+                          (((qv) (qq v level)))
+                          (#%let-values
+                            ()
+                            (#%if (#%eq? v qv)
+                              x
+                              (#%list (#%quote #%box) qv)))))
+                      x)))))))
+          (qq form 0))
+        form))))
+
+> qstop quasiquote <
+
+(#%define-macro #%and 
+  (#%case-lambda
+   [() #t]
+   [(expr) expr]
+   [(expr . exprs)
+    `(#%if ,expr
+	 (#%and ,@exprs)
+	 #f)]))
+
+> kstop and <
+
+(#%define-macro #%or
+  (#%case-lambda 
+   [() #f]
+   [(expr) expr]
+   [(expr . exprs)
+    (#%let ([temp (#%gensym)])
+      `(#%let ([,temp ,expr])
+	 (#%if ,temp
+	       ,temp
+	       (#%or ,@exprs))))]))
+
+> kstop or <
+
+(#%define-macro #%cond
+    (#%lambda form
+     (#%let ([serror
+	      (#%lambda (msg at)
+		(#%raise-syntax-error 'cond msg (#%cons 'cond form) at))])
+      (#%let loop ([tests form])
+	(#%if (#%null? tests)
+	    (#%if (#%compile-allow-cond-fallthrough)
+		'(#%void)
+		'(#%cond))
+	    (#%if (#%not (#%pair? tests))
+		(serror
+		 "bad syntax (body must contain a list of pairs)"
+		 tests)
+		(#%let ([line (#%car tests)]
+		        [rest (#%cdr tests)])
+		  (#%if (#%not (#%pair? line))
+		        (serror
+			 "bad syntax (clause is not a test-value pair)"
+			 line)
+		      (#%let* ([test (#%car line)]
+			       [value (#%cdr line)]
+			       [else? (#%and (#%eq? test 'else) 
+					     (#%not (#%local-expansion-time-bound? 'else)))])
+			(#%if (#%and else? (#%pair? rest))
+			      (serror "bad syntax (`else' clause must be last)" line))
+			(#%if (#%and (#%pair? value)
+				     (#%eq? '=> (#%car value))
+				     (#%not (#%local-expansion-time-bound? '=>)))
+			    (#%if (#%and (#%pair? (#%cdr value))
+					 (#%null? (#%cddr value)))
+				(#%let ([test (#%if else?
+						    #t 
+						    test)]
+					[gen (#%gensym)])
+				  `(#%let ([,gen ,test])
+				     (#%if ,gen
+					 (,(#%cadr value) ,gen)
+					 ,(loop rest))))
+				(serror
+				 "bad syntax (bad clause form with =>)"
+				 line))
+			    (#%if else?
+				(#%cons '#%begin value)
+				(#%if (#%null? value)
+				    (#%let ([gen (#%gensym)])
+				      `(#%let ([,gen ,test])
+					 (#%if ,gen ,gen ,(loop rest))))
+				    (#%list
+				     '#%if test
+				     (#%cons '#%begin value)
+				     (loop rest))))))))))))))
+
+> cstop cond <
+
+(#%define-macro #%case 
+    (#%lambda (v . tests-in)
+     (#%let ([serror
+	      (#%lambda (msg at)
+		(#%raise-syntax-error
+		 'case
+		 msg
+		 (#%list* 'case v tests-in)
+		 at))])
+      (#%let ([gen (#%gensym)])
+	`(#%let ([,gen ,v])
+	   (#%cond
+	    ,@(#%let loop ([tests tests-in])
+		(#%cond
+		 [(#%null? tests) `()]
+		 [(#%pair? tests)
+		  (#%let ([test-value (#%car tests)]
+			  [rest (#%cdr tests)])
+		    (#%cons
+		     (#%if (#%or (#%not (#%pair? test-value))
+				 (#%not (#%pair? (#%cdr test-value))))
+			 (serror
+			  "bad syntax (clause is not a test-value pair)"
+			  test-value)
+			 (#%let ([test (#%car test-value)]
+				 [value (#%cdr test-value)])
+			   (#%if (#%and (#%pair? value) (#%list? value))
+				 #t
+				 (serror
+				  "bad syntax (improper clause body)"
+				  value))
+			   (#%cons
+			    (#%cond
+			     [(#%and (#%eq? test 'else)
+				     (#%not (#%local-expansion-time-bound? 'else)))
+			      (#%if (#%null? rest)
+				    'else
+				    (serror
+				     "bad syntax (`else' clause must be last)"
+				     test-value))]
+			     [else
+			      (#%if (#%not (#%list? test))
+				    (serror
+				     "bad syntax (improper datum list)"
+				     test))
+			      (#%cons 
+			       '#%or
+			       (#%let loop ([test test])
+				 (#%cond
+				  [(#%null? test) ()]
+				  [else
+				   (#%let ([t (#%list '#%quote (#%car test))])
+				     (#%cons `(#%eqv? ,gen ,t)
+					     (loop (#%cdr test))))])))])
+			    `((#%begin ,@value)))))
+		     (loop rest)))]
+		 [else (serror
+			"bad syntax (body must contain a list of pairs)"
+			tests)]))))))))
+
+> kstop case <
+
+(#%define-macro #%do 
+    (#%lambda (bindings test-and-result . body)
+      (#%let ([code (#%list* 'do bindings test-and-result body)])
+	(#%if (#%list? bindings)
+	      (#%void)
+	      (#%raise-syntax-error 'do "bad syntax (bad binding sequence)" code))
+	(#%map (#%lambda (binding)
+		 (#%if (#%and (#%list? binding)
+			      (#%let ([l (#%length binding)])
+			        (#%or (#%= l 2) (#%= l 3))))
+		     (#%void)
+		     (#%raise-syntax-error 'do "bad syntax (bad binding)" code)))
+	       bindings)
+	(#%if (#%list? test-and-result) (#%void)
+	      (#%raise-syntax-error 'do "bad syntax (bad test and result)" code))
+	(#%if (#%list? body) (#%void)
+	      (#%raise-syntax-error 'do "bad syntax (improper body)" code))
+	(#%let* ([vars (#%map (#%lambda (binding)
+				(#%let ([var (#%car binding)])
+				  (#%if (#%symbol? var)
+				      var
+				      (#%raise-syntax-error
+				       'do "bad syntax (variable must be an identifier)"
+				       code))))
+			      bindings)]
+		 [inits (#%map #%cadr bindings)]
+		 [steps (#%map (#%lambda (binding)
+				 (#%cond
+				  [(#%pair? (#%cddr binding))
+				   (#%caddr binding)]
+				  [else (#%car binding)]))
+			       bindings)]
+		 [test (#%if (#%pair? test-and-result)
+			   (#%car test-and-result)
+			   (#%raise-syntax-error
+			    'do "bad syntax (test/result part)"
+			    code))]
+	       [results (#%if (#%null? (#%cdr test-and-result))
+			    (#%list '(#%void))
+			    (#%cdr test-and-result))]
+	       [loop (#%gensym)])
+	  `(#%let ,loop ,(#%map (#%lambda (var init)
+				(#%list var init))
+			        vars inits)
+		(#%if ,test
+		    (#%begin
+		      ,@results)
+		    (#%begin
+		      ,@body
+		      (,loop ,@steps))))))))
+
+> kstop do <
+
+(#%define-macro #%define
+     (#%lambda body
+       (#%let ([code (#%cons 'define body)])
+	 (#%if (#%null? body)
+	       (#%raise-syntax-error
+		'define
+		"bad syntax (no definition body)"
+		code))
+	 (#%let ([first (#%car body)]) 
+	  (#%cond
+	   [(#%symbol? first)
+	    (#%if (#%and (#%pair? (#%cdr body))
+			 (#%null? (#%cddr body)))
+		  `(#%define-values (,first) ,@(#%cdr body))
+		  (#%raise-syntax-error
+		   'define
+		   "bad syntax (zero or multiple expressions after identifier)"
+		   code))]
+	   [(#%pair? first)
+	    (#%let ([bad-symbol  (#%lambda (s) (#%raise-syntax-error 'define
+								     "bad identifier"
+								     code
+								     s))])
+		   (#%let loop ([l first])
+			  (#%cond
+			   [(#%null? l) #f]
+			   [(#%pair? l) 
+			    (#%if (#%symbol? (#%car l))
+				  (loop (#%cdr l))
+				  (bad-symbol (#%car l)))]
+			   [(#%symbol? l) #f]
+			   [else (bad-symbol l)])))
+	    
+	    `(#%define-values (,(#%car first)) (#%lambda ,(#%cdr first) ,@(#%cdr body)))]
+	   [else
+	    (#%raise-syntax-error
+	     'define
+	     "not an identifier"
+	     code
+	     first)])))))
+
+> kstop define <
+
+(#%define-macro #%set!-values
+  (#%lambda (args expr)
+    (#%and (#%or (#%list? args)
+		 (#%raise-syntax-error
+			       'set!-values
+			       "bad syntax (illegal use of `.')"
+			       (#%list 'set!-values args expr)
+			       args))
+	   (#%andmap (#%lambda (arg)
+			(#%or (#%symbol? arg)
+			      (#%raise-syntax-error
+			       'set!-values
+			       "bad syntax (not an identifier)"
+			       (#%list 'set!-values args expr)
+			       arg)))
+		     args))
+    (#%if (#%and (#%pair? args) (#%null? (#%cdr args)))
+	  `(#%set! ,(#%car args) ,expr)
+	  (#%let ([gens (#%map (#%lambda (arg) (#%gensym)) args)])
+	     `(#%let-values ([,gens ,expr])
+		 ,@(#%if (#%null? args)
+			 `((#%void))
+			 (#%map (#%lambda (arg gen) `(#%set! ,arg ,gen)) args gens)))))))
+
+> kstop set!-values <
+
+(#%define-macro #%delay
+  (#%lambda (body)
+    `(#%make-promise (#%lambda () ,body))))
+
+> kstop delay <
+
+(#%define-macro #%let/cc 
+  (#%lambda (var expr1 . body)
+    `(#%call/cc (#%lambda (,var) ,expr1 ,@body))))
+
+> kstop let/cc <
+
+(#%define-macro #%let/ec 
+  (#%lambda (var expr1 . body)
+    `(#%call/ec (#%lambda (,var) ,expr1 ,@body))))
+
+> kstop let/ec <
+
+(#%define-macro #%when 
+  (#%lambda (test expr1 . body)
+    `(#%if ,test
+	   (#%begin
+	    ,expr1
+	    ,@body))))
+
+> kstop when <
+
+(#%define-macro #%unless 
+  (#%lambda (test expr1 . body)
+    `(#%if ,test
+	   (#%void)
+	   (#%begin
+	    ,expr1
+	    ,@body))))
+
+> kstop unless <
+
+(#%define-macro #%define-struct
+  (#%lambda body
+     (#%let ([syntax-error
+	      (#%lambda (s . detail)
+		(#%apply
+		 #%raise-syntax-error
+		 'define-struct
+		 s
+		 (#%cons 'define-struct body)
+		 detail))]
+	     [build-struct-names
+	      (#%lambda (name fields)
+		(#%let ([name (#%symbol->string name)]
+			[fields (#%map #%symbol->string fields)]
+			[+ #%string-append])
+		  (#%map #%string->symbol
+			 (#%append
+			  (#%list 
+			   (+ "struct:" name)
+			   (+ "make-" name)
+			   (+ name "?"))
+			  (#%apply
+			   #%append
+			   (#%map
+			    (#%lambda (f) 
+			       (#%list 
+				(+ name "-" f)
+				(+ "set-" name "-" f "!")))
+			   fields))))))])
+	    (#%or (#%pair? body)
+		  (syntax-error "empty declaration"))
+	    (#%or (#%= 2 (#%length body))
+		  (syntax-error "wrong number of parts"))
+	    (#%or (#%symbol? (#%car body))
+		  (#%and (#%pair? (#%car body))
+			 (#%symbol? (#%caar body))
+			 (#%pair? (#%cdar body))
+			 (#%null? (#%cddar body)))
+		  (syntax-error "first part must be an identifier or identifier-expression pair"))
+	    (#%or (#%list? (#%cadr body))
+		  (syntax-error "illegal use of `.' in field list"))
+	    (#%for-each (#%lambda (x) 
+			  (#%or (#%symbol? x)
+				(syntax-error "field name not a identifier" x)))
+		      (#%cadr body))
+	    (#%let ([name (#%if (#%symbol? (#%car body))
+			      (#%car body)
+			      (#%caar body))]
+		  [fields (#%cadr body)])
+	      `(#%define-values ,(build-struct-names name fields) (#%struct ,@body))))))
+
+> kstop define-struct <
+
+(#%define-macro #%let-struct
+  (#%lambda (base field . body)
+    `(#%let () (#%define-struct ,base ,field) ,@body)))
+
+> kstop let-struct <
+
+> literal "#ifndef NO_OBJECT_SYSTEM"
+
+(#%define-macro #%class 
+  (#%lambda (super args . rest)
+    `(#%class*/names (this super-init) ,super () ,args ,@rest)))
+
+> kstop class <
+
+(#%define-macro #%class* 
+  (#%lambda (super interfaces args . rest)
+    `(#%class*/names (this super-init) ,super ,interfaces ,args ,@rest)))
+
+> kstop class* <
+
+(#%define-macro #%send 
+  (#%lambda (obj msg . params)
+    `((#%ivar ,obj ,msg) ,@params)))
+
+> kstop send <
+
+(#%define-macro #%make-generic 
+  (#%lambda (c% name)
+    `(#%uq-make-generic ,c% (quote ,name))))
+
+> kstop make-generic <
+
+(#%define-macro #%ivar 
+    (#%lambda args
+      (#%if (#%list? args)
+	  (#%let ([l (#%length args)])
+	    (#%cond
+	     [(#%= l 2) `(#%uq-ivar ,(#%car args) (#%quote ,(#%cadr args)))]
+	     [else (#%raise-syntax-error
+		    'ivar
+		    (#%format "bad syntax (~s parts after the keyword)" l)
+		    (#%cons 'ivar args))]))
+	  (#%raise-syntax-error
+	   'ivar
+	   "bad syntax (illegal use of `.')"
+	   (#%cons 'ivar args)))))
+
+> kstop ivar <
+
+> literal "#endif"
+
+(#%define-macro #%fluid-let 
+    (#%lambda (assignments expr1 . body)
+     (#%if (#%null? assignments)
+      `(#%begin ,expr1 ,@body)
+      (#%let ([mk-expr (lambda () (#%list* 'fluid-let 
+					      assignments 
+					      expr1
+					      body))])
+	(#%unless (#%list? assignments)
+           (#%raise-syntax-error 'fluid-let
+				 "bad syntax" (mk-expr)
+				 assignments))
+	(#%let ([tempnames (#%map (#%lambda (assignment) 
+				   (#%cond
+				    [(#%and (#%pair? assignment)
+					   (#%symbol? (#%car assignment))
+					   (#%pair? (#%cdr assignment))
+					   (#%null? (#%cddr assignment)))
+				    (#%gensym)]
+				    [else
+				     (#%raise-syntax-error
+				      'fluid-let
+				      "bad syntax"
+				      (mk-expr)
+				      assignment)]))
+				  assignments)])
+	     `(#%let ,(#%map (#%lambda (tempname assignment)
+			     (#%list tempname (#%car assignment)))
+			   tempnames assignments)
+	   (#%dynamic-wind
+	    (#%lambda ()
+	      ,@(#%map (#%lambda (assignment)
+			 `(#%set! ,(#%car assignment) ,(#%cadr assignment)))
+		       assignments))
+	    (#%lambda () ,expr1 ,@body)
+	    (#%lambda ()
+	      ,@(#%map (#%lambda (assignment tempname)
+		       `(#%set! ,(#%car assignment) ,tempname))
+		     assignments tempnames)))))))))
+
+> kstop fluid-let <
+
+(#%define-macro #%parameterize
+    (#%lambda (params . body)
+     (#%let ([fail
+	      (#%lambda (msg)
+	       (#%raise-syntax-error
+		'parameterize
+		msg
+		(#%list* 'parameterize params body)))])
+      (#%if (#%null? body) (fail "bad syntax (empty body)"))
+      (#%if (#%null? params)
+        `(#%begin ,@body)
+	(#%if (#%or (#%not (#%pair? params))
+		    (#%not (#%pair? (#%car params)))
+		    (#%not (#%pair? (#%cdar params)))
+		    (#%not (#%null? (#%cddar params))))
+	      (fail "bad syntax")
+	      (#%let ([param (#%caar params)]
+		      [orig (#%gensym)]
+		      [pz (#%gensym)])
+		 `(#%let* ([,pz (#%in-parameterization (#%current-parameterization) ,param)]
+			   [,orig (,pz)])
+		     (#%dynamic-wind
+		        (#%lambda () (,pz ,(#%cadar params)))
+		        (#%lambda () (parameterize ,(cdr params) ,@body))
+			(#%lambda () (,pz ,orig))))))))))
+
+> kstop parameterize <
+
+(#%define-macro #%with-handlers
+    (#%lambda (clauses . body)
+      (#%if (#%and (#%list? clauses)
+		   (#%andmap (#%lambda (p)
+			       (#%and (#%pair? p)
+				      (#%pair? (#%cdr p))
+				      (#%null? (#%cddr p))))
+			     clauses)
+		   (#%pair? body))
+	  (#%void)
+	  (#%raise-syntax-error 'with-handlers "bad syntax"
+				(#%list* 'with-handlers clauses body)))
+      (if (#%null? clauses)
+	  `(begin ,@body)
+        (#%let ([k (#%gensym)]
+	        [loop (#%gensym)]
+	        [list (#%gensym)])
+	  `((#%call/ec 
+	     (#%lambda (,k)
+	       (#%let ([,list (#%list ,@(#%map (#%lambda (p)
+		  			       `(#%cons ,(#%car p)
+		      				,(#%cadr p)))
+					     clauses))])
+	         (#%parameterize ([#%current-exception-handler
+				   (#%lambda (e)
+				    (,k
+				     (#%let ,loop ([,list ,list])
+				       (#%cond
+				        [(#%null? ,list)
+					 (#%lambda () (#%raise e))]
+					[((#%caar ,list) e)
+					 (#%lambda () ((#%cdar ,list) e))]
+					[else
+					 (,loop (#%cdr ,list))]))))])
+		   (#%call-with-values
+		    (#%lambda () ,@body)
+		    (#%lambda args (,k (#%lambda () (#%apply #%values args))))))))))))))
+
+> kstop with-handlers <
+
+> literal "#ifdef USE_STRUCT_CASE"
+
+(#%define-macro #%struct-case-lambda
+  (#%lambda (x . pairs)
+    (#%unless (#%and (#%symbol? x)
+                     (#%list? pairs)
+                     (#%andmap (#%lambda (p) (#%and (#%list? p) (#%not (#%null? p)))) pairs))
+	      (#%raise-syntax-error 'struct-case-lambda "bad syntax"
+				    (#%list* 'struct-case-lambda x pairs)))
+    (#%let-values ([(predicates functions else)
+		    (#%let loop ([l pairs])
+		      (#%if (#%null? l)
+			    (#%values () () ())
+			    (#%let-values ([(p-rest f-rest else) (loop (#%cdr l))]
+					   [(p) (#%caar l)]
+					   [(f) (#%let ([r (#%cdar l)])
+						  `(#%lambda (,x) ,@(#%if (#%null? r)
+									  '(x)
+									  r)))])
+			     (#%cond
+			      [(#%and (#%eq? p 'else)
+				      (#%not (#%local-expansion-time-bound? 'else)))
+			       (#%unless (#%null? p-rest)
+					 (#%raise-syntax-error 'struct-case-lambda "else clause must be last"
+							       (#%list* 'struct-case-lambda x pairs)))
+			       (#%values () () (#%list f))]
+			      [else
+			       (#%values (#%cons p p-rest)
+					 (#%cons f f-rest)
+					 else)]))))])
+      (#%list* '#%make-struct-case 
+	       (#%cons '#%list predicates)
+	       (#%cons '#%list functions)
+	       else))))
+
+> kstop struct-case-lambda <
+
+> literal "#endif"
+
+(#%define with-parameterization
+  (#%lambda (p thunk)
+     (#%unless (#%parameterization? p)
+	(#%raise-type-error 'with-parameterization "parameterization" p))
+     (#%unless (#%and (#%procedure? thunk)
+		      (#%procedure-arity-includes? thunk 0))
+	(#%raise-type-error 'with-parameterization "procedure (arity 0)" thunk))
+     (#%let* ([orig (#%current-parameterization)])
+       (#%dynamic-wind
+	 (#%lambda () (#%current-parameterization p))
+	 (#%lambda () (thunk))
+	 (#%lambda () (#%current-parameterization orig))))))
+
+> fstop with-parameterization <
+
+(#%define with-new-parameterization
+  (#%lambda (thunk)
+     (#%unless (#%and (#%procedure? thunk)
+		      (#%procedure-arity-includes? thunk 0))
+	(#%raise-type-error 'with-new-parameterization "procedure (arity 0)" thunk))
+     (#%let* ([naya (#%make-parameterization)])
+       (#%with-parameterization naya thunk))))
+
+> fstop with-new-parameterization <
+
+(#%define load/cd
+  (#%let ([make-exn make-exn:i/o:filesystem:directory]
+	  [debug debug-info-handler])
+    (#%lambda (n)
+      (#%unless (#%string? n)
+	(#%raise-type-error 'load/cd "string" n))
+      (#%let-values ([(base name dir?) (#%split-path n)])
+	 (#%if dir?
+	     (#%raise
+	      (make-exn
+	       (#%format "load/cd: cannot open a directory: ~s" n)
+	       ((debug))
+	       n))
+	     (#%if (#%not (#%string? base))
+		 (#%load n)
+		 (#%begin
+		   (#%if (#%not (#%directory-exists? base))
+		       (#%raise
+			(make-exn
+			 (#%format 
+			  "load/cd: directory of ~s does not exist (current directory is ~s)" 
+			  n (#%current-directory))
+			 ((debug))
+			 base)))
+		   (#%let ([orig (#%current-directory)])
+		     (#%dynamic-wind
+		      (#%lambda () (#%current-directory base))
+		      (#%lambda () (#%load name))
+		      (#%lambda () (#%current-directory orig)))))))))))
+  
+> fstop load/cd <
+
+(#%define (read-eval-print-loop)
+  (#%let* ([eeh #f]
+	   [jump #f]
+	   [rep-error-escape-handler (lambda () (jump))])
+    (#%dynamic-wind
+      (#%lambda () (#%set! eeh (#%error-escape-handler))
+		   (#%error-escape-handler rep-error-escape-handler))
+      (#%lambda ()
+	(#%let/ec done
+          (#%let loop ()
+	    (#%let/ec k
+		(#%set! jump k)
+		(#%let ([v ((#%current-prompt-read))])
+		   (#%when (#%eof-object? v) (done))
+		   (#%call-with-values
+		    (#%lambda () ((#%current-eval) v))
+		    (#%lambda results (#%for-each (#%current-print) results)))))
+	    (loop))))
+      (#%lambda () (#%error-escape-handler eeh)
+		   (#%set! jump #f)
+                   (#%set! eeh #f)))))
+
+> fstop read-eval-print-loop <
+
+> literal "#ifndef NO_FILE_SYSTEM_UTILS"
+
+(#%define load/use-compiled
+  (#%let ([re:suffix (#%regexp "\\..?.?.?$")]
+	  [resolve (#%lambda (s)
+		     (#%if (#%complete-path? s)
+			   s
+			   (#%let ([d (#%current-load-relative-directory)])
+			      (#%if d (#%path->complete-path s d) s))))]
+	  [date>=?
+	   (#%lambda (a bm)
+	     (#%let ([am (#%file-modify-seconds a)])
+		(#%or (#%and (#%not bm) am) (#%and am bm (#%>= am bm)))))])
+    (#%lambda (path)
+      (#%unless (#%and (#%string? path) (#%or (#%relative-path? path) (#%absolute-path? path)))
+	(#%raise-type-error 'load/use-compiled "pathname string" path))
+      (#%let*-values ([(path) (resolve path)]
+		      [(base file dir?) (#%split-path path)]
+		      [(base) (#%if (#%eq? base 'relative) 'same base)])
+        (#%let* ([get-so (#%lambda (file)
+			    (#%build-path base
+					  "compiled"
+					  "native"
+					  (#%system-library-subpath)
+					  (#%regexp-replace 
+					   re:suffix file
+					   (#%case (#%system-type)
+					      [(windows) ".dll"]
+					      [else ".so"]))))]
+		 [zo (#%build-path base
+				   "compiled"
+				   (#%regexp-replace re:suffix file ".zo"))]
+		 [so (get-so file)]
+		 [_loader-so (get-so "_loader.ss")]
+		 [path-d (#%file-modify-seconds path)]
+		 [with-dir (#%lambda (t) (#%parameterize ([#%current-load-relative-directory 
+							   (#%if (#%string? base) base (#%current-directory))]) (t)))])
+	    (#%cond
+	     [(#%and (date>=? _loader-so path-d)
+		     (#%let ([getter (#%load-extension _loader-so)])
+			(getter (#%string->symbol (#%regexp-replace re:suffix file "")))))
+	      => (#%lambda (loader) (with-dir loader))]
+	     [(date>=? so path-d)
+	      (with-dir (#%lambda () ((#%current-load-extension) so)))]
+	     [(date>=? zo path-d)
+	      (with-dir (#%lambda () ((#%current-load) zo)))]
+	     [else (#%load path)]))))))
+
+> fstop load/use-compiled <
+
+(#%define-values (load-relative load-relative-extension)
+  (#%let ([mk
+	   (#%lambda (load name)
+             (#%lambda (path)
+               (#%unless (#%and (#%string? path) (#%or (#%relative-path? path) (#%absolute-path? path)))
+                 (#%raise-type-error name "pathname string" path))
+               (#%if (#%complete-path? path)
+           	  (load path)
+           	  (#%let ([dir (#%current-load-relative-directory)])
+           	     (load (#%if dir (#%path->complete-path path dir) path))))))])
+    (#%values (mk #%load 'load-relative) (mk #%load-extension 'load-relative-extension))))
+
+> fstop load-relative load-relative-extension <
+
+(#%define-values (require-library require-relative-library collection-path)
+  (#%let* ([get-table current-loaded-library-table]
+	   [not-found (box 0)]
+	   [null-str (#%string #\nul)]
+	   [debug debug-info-handler]
+	   [make-path-exn make-exn:i/o:filesystem:path]
+	   [check (#%lambda (who s)
+		    (#%unless (#%string? s)
+		      (#%raise-type-error who "string" s))
+		    (#%unless (#%relative-path? s)
+		      (#%raise (make-path-exn
+			       (#%format "~a: invalid relative path: ~s" who s)
+			       ((debug)) s))))]
+	   [with-null (#%lambda (l) (#%let loop ([l l])
+					   (#%if (#%null? l)
+						 #%null
+						 (#%list* (#%car l) null-str (loop (#%cdr l))))))]
+	   [make-coll-exn make-exn:i/o:filesystem:collection]
+	   [make-file-exn make-exn:i/o:filesystem:file]
+	   [check-collection
+	    (#%lambda (who collection collection-path)
+		      (check who collection) (#%for-each (lambda (p) (check who p)) collection-path))]
+	   [find-col
+	    (#%lambda (who collection collection-path)
+	      (#%let ([all-paths (#%current-library-collection-paths)])
+		     (#%let loop ([paths all-paths])
+			    (#%if (#%null? paths)
+				 (#%raise
+				  (make-coll-exn
+				  (#%format "~a: collection not found: ~s in any of: ~s" 
+					    who collection all-paths)
+				  ((debug))
+				  collection))
+				 (#%let ([dir (#%build-path (#%car paths) collection)])
+				    (#%if (#%directory-exists? dir)
+				       (#%let* ([cpath (#%apply #%build-path dir collection-path)])
+					  (#%if (#%directory-exists? cpath)
+						cpath
+						(let loop ([p dir][l collection-path][c collection])
+						  (#%let ([np (#%build-path p (#%car l))]
+							  [nc (#%build-path c (#%car l))])
+							 (#%if (#%directory-exists? np)
+							       (loop np (#%cdr l) nc)
+							       (#%raise
+								(make-coll-exn
+								 (#%format "require-library: collection ~s does not have sub-collection: ~s in: ~s"
+									   c (#%car l) p)
+								 ((debug))
+								 nc)))))))
+				       (loop (#%cdr paths))))))))])
+	  (#%letrec ([collection-path (#%lambda (collection . collection-path) 
+						(check-collection 'collection-path collection collection-path)
+						(find-col 'collection-path collection collection-path))]
+		     [require-relative-library
+		      (#%lambda (file . collection-path)
+			 (check 'require-relative-library file) 
+			 (check-collection 'require-relative-library file collection-path)
+			 (#%let ([cp (#%current-require-relative-collection)])
+			    (#%if cp
+				  (#%apply require-library file (#%append cp collection-path))
+				  (#%raise
+				   (make-coll-exn
+				    (#%format "require-relative-library: there is no current collection for library: ~s~a"
+					      file
+					      (#%if (#%null? collection-path)
+						    ""
+						    (#%format " in sub-collection: ~s" collection-path)))
+				    ((debug))
+				    (#%apply #%build-path file collection-path))))))]
+		     [require-library
+		      (#%case-lambda
+		       [(file) (require-library file "mzlib")]
+		       [(file collection . collection-path)
+			(check 'require-library file) (check-collection 'require-library collection collection-path)
+			(#%let ([table (get-table)]
+				[sym (#%string->symbol (#%apply #%string-append 
+								(with-null (#%list* file collection collection-path))))])
+			       (#%let ([found (#%hash-table-get table sym (#%lambda () not-found))])
+				      (#%if (#%eq? found not-found)
+					    (#%let* ([c (find-col 'require-library collection collection-path)]
+						     [p (#%build-path c file)]
+						     [result (#%if (#%file-exists? p)
+								   (#%parameterize ([#%current-require-relative-collection
+										     (#%cons collection collection-path)])
+								     (#%call-with-values
+								      (#%lambda ()
+										((#%if (#%require-library-use-compiled)
+										       #%load/use-compiled 
+										       #%load)
+										 p))
+								      #%list))
+								   (#%raise
+								    (make-file-exn
+								     (#%format "require-library: collection ~s does not have library: ~s in: ~s"
+									       (#%apply #%build-path collection collection-path) file c)
+								     ((debug))
+								     p)))])
+						    (#%hash-table-put! table sym result)
+						    (#%apply #%values result))
+					    (#%apply #%values found))))])])
+		    (#%values require-library require-relative-library collection-path))))
+
+> fstop require-library require-relative-library collection-path <
+
+(#%define-macro #%reference-library
+  (#%letrec ([rl (#%case-lambda 
+		  [(name) (rl name "mzlib")]
+		  [(name collection . collection-path)
+		   (#%let ([name (#%local-expand-defmacro name)]
+			   [collection (#%local-expand-defmacro collection)]
+			   [check (#%lambda (s kind)
+				     (#%unless (#%string? s)
+					 (#%raise-syntax-error 
+					  'reference-library
+					  (#%format "~s name is not a string" kind)
+					  (#%list 'reference-library name collection))))])
+			  (check name "library")
+			  (check collection "collection")
+			  (#%for-each (#%lambda (c) (check c "sub-collection")) collection-path)
+			  `(#%require-library ,name ,collection ,@collection-path))])])
+       rl))
+
+> kstop reference-library <
+
+(#%define path-list-string->path-list
+  (#%let ((r (#%regexp (#%let ((sep (#%case (#%system-type) 
+					    ((unix) ":")
+					    ((windows macos) ";"))))
+			      (#%format "([^~a]*)~a(.*)" sep sep))))
+	  (cons-path (#%lambda (default s l) 
+			       (#%if (#%string=? s "")
+				     (#%append default l)
+				     (#%if (#%or (#%relative-path? s) (#%absolute-path? s)) (#%cons s l) l)))))
+    (#%lambda (s default)
+      (#%unless (#%string? s) (#%raise-type-error 'path-list-string->path-list "string" s))
+      (#%unless (#%list? default) (#%raise-type-error 'path-list-string->path-list "list" default))
+      (#%let loop ([s s])
+	(#%let ([m (#%regexp-match r s)])
+          (#%if m
+		(cons-path default (#%cadr m) (loop (#%caddr m)))
+		(cons-path default s #%null)))))))
+
+> fstop path-list-string->path-list <
+
+(#%define find-executable-path
+  (#%lambda (program libpath)
+    (#%unless (#%string? program)
+      (#%raise-type-error 'find-executable-path "string" program))
+    (#%unless (#%string? libpath)
+      (#%raise-type-error 'find-executable-path "string" libpath))
+    (#%letrec ([found-exec
+		(#%lambda (exec-name)
+		  (#%let-values ([(base name isdir?) (#%split-path exec-name)])
+		     (#%if (#%string? base)
+		       (#%let ([lib (#%build-path base libpath)])
+			 (#%if (#%or (#%directory-exists? lib) 
+				     (#%file-exists? lib))
+			     lib
+			     (#%let ([resolved (#%resolve-path exec-name)])
+			       (#%cond
+				[(#%string=? resolved exec-name) #f]
+				[(#%relative-path? resolved)
+				 (found-exec (#%build-path base resolved))]
+			       [else (found-exec resolved)]))))
+		       #f)))])
+      (#%if (#%relative-path? program)
+	  (#%let ([paths-str (#%getenv "PATH")])
+	    (#%let loop ([paths (#%if paths-str (#%path-list-string->path-list paths-str #%null) #%null)])
+		  (#%if (#%null? paths)
+			#f
+			(#%let* ([base (#%path->complete-path (#%car paths))]
+				 [name (#%build-path base program)])
+				(#%if (#%file-exists? name)
+				      (found-exec name)
+				      (loop (#%cdr paths)))))))
+	  (found-exec program)))))
+
+> fstop find-executable-path <
+
+> literal "#endif"
+
+> literal "#ifdef TIME_SYNTAX"
+
+(#%define-macro #%time
+  (#%lambda (expr1 . body)
+    `(#%let-values ([(s) (#%current-gc-milliseconds)]
+                    [(v cpu user) (#%time-apply (#%lambda () ,expr1 ,@body))])
+	(#%printf "cpu time: ~s real time: ~s gc time: ~s~n"
+		  cpu user (#%- (#%current-gc-milliseconds) s))
+	(#%apply #%values v))))
+
+> kstop time <
+
+> literal "#endif"
+
+> literal "#ifndef NO_UNIT_SYSTEM"
+
+(#%define verify-linkage-signature-match
+  (#%let ([make-non #%make-exn:unit:signature:non-signed-unit]
+	  [make-arity #%make-exn:unit:signature:arity]
+	  [p-suffix (#%lambda (pos) (#%case pos [(1) 'st][(2) 'nd][(3) 'rd][else 'th]))])
+    (#%lambda (who tags units esigs isigs)
+      (#%for-each
+       (#%lambda (u tag)
+	  (#%unless (#%unit-with-signature? u)
+	     (#%raise
+	      (make-non
+	       (#%format
+		"~s: expression for \"~s\" is not a signed unit"
+		who tag)
+	       ((#%debug-info-handler)) u))))
+       units tags)
+      (#%for-each
+       (#%lambda (u tag esig)
+	 (#%verify-signature-match
+	  who #f
+	  (#%format "specified export signature for ~a" tag)
+	  esig
+	  (#%format "export signature for actual ~a sub-unit" tag)
+	  (#%unit-with-signature-exports u)))
+       units tags esigs)
+      (#%for-each
+       (#%lambda (u tag isig)
+	 (#%let ([n (#%length (#%unit-with-signature-imports u))]
+		 [c (#%length isig)])
+	   (#%unless (#%= c n)
+	      (#%raise
+	       (make-arity
+		(#%format
+		 "~s: ~a unit imports ~a units, but ~a units were provided"
+		 who tag n c)
+		((#%debug-info-handler)) u)))))
+       units tags isigs)
+      (#%for-each
+       (#%lambda (u tag isig)
+	 (#%let loop ([isig isig][expecteds (#%unit-with-signature-imports u)][pos 1])
+	   (#%unless (#%null? isig)
+	     (#%let ([expected (#%car expecteds)]
+		     [provided (#%car isig)])
+	       (#%verify-signature-match
+		who #t
+		(#%format "~a unit's ~s~s import (~a signature)" tag
+			  pos (p-suffix pos)
+			  (#%car expected))
+		(#%cdr expected)
+		(#%format "~s~s linkage (~a signature) for ~a"
+			  pos (p-suffix pos)
+			  (#%car provided)
+			  tag)
+		(#%cdr provided))
+	       (loop (#%cdr isig) (#%cdr expecteds) (#%add1 pos))))))
+       units tags isigs))))
+
+> fstop verify-linkage-signature-match <
+
+; Extra names:
+(#%define-values (unit/sig? unit-with-signature->unit unit/sig->unit)
+       (values #%unit-with-signature?
+	       #%unit-with-signature-unit
+	       #%unit-with-signature-unit))
+
+> fstop unit/sig? unit-with-signature->unit unit/sig->unit <
+
+> literal "#endif"
+
+(#%define rationalize
+  (#%letrec ([check (#%lambda (x) 
+                      (#%unless (#%real? x) (#%raise-type-error 'rationalize "real" x)))]
+	     [find-between 
+	      (#%lambda (lo hi)
+		(#%if (#%integer? lo)
+		    lo
+		    (#%let ([lo-int (#%floor lo)]
+			    [hi-int (#%floor hi)])
+		      (#%if (#%< lo-int hi-int)
+			  (#%add1 lo-int)
+			  (#%+ lo-int
+			     (#%/ (find-between (#%/ (#%- hi lo-int)) (#%/ (#%- lo lo-int)))))))))])
+     (#%lambda (x within)
+       (check x) (check within)
+       (#%let* ([delta (#%abs within)]
+		[lo (#%- x delta)]
+	        [hi (#%+ x delta)])
+	 (#%cond
+	  [(#%not (#%= x x)) +nan.0]
+	  [(#%<= lo 0 hi) (#%if (#%exact? x) 0 0.0)]
+	  [(#%negative? lo) (#%- (find-between (#%- hi) (#%- lo)))]
+	  [else (find-between lo hi)])))))
+
+> fstop rationalize <
+
+(#%define (simple-return-primitive? v)
+  (#%unless (#%primitive? v) (#%raise-type-error 'simple-return-primitive? "primitive-procedure" v))
+  (#%not (#%memq (#%inferred-name v) '(call-with-values 
+				       apply 
+				       error
+				       call-with-current-continuation
+				       hash-table-get
+				       write-image-to-file))))
+
+> fstop simple-return-primitive? <
+
+(#%define (port? x) (#%or (#%input-port? x) (#%output-port? x)))
+
+> fstop port? <
diff --git a/src/mzscheme/src/makeexn b/src/mzscheme/src/makeexn
new file mode 100755
index 0000000..65e381a
--- /dev/null
+++ b/src/mzscheme/src/makeexn
@@ -0,0 +1,215 @@
+#!/bin/sh
+string=? ; exec ${PLTHOME}/bin/mzscheme -gqr $0 "$@"
+
+(define doc? (and (= (vector-length argv) 1)
+		  (string=? (vector-ref argv 0) "doc")))
+
+(define l (read))
+
+(define-struct ex (define string base doc args parent numtotal depth mark))
+(define-struct fld (name type doc))
+
+(define max-exn-args 0)
+
+(define (make-an-ex sym parent parent-name totalargs args doc depth mark)
+  (let* ([s (symbol->string sym)]
+	 [name (string-append parent-name 
+			      (if (string=? "" parent-name) "" ":") 
+			      s)]
+	 [count (+ totalargs (length args))])
+    (when (> count max-exn-args)
+	  (set! max-exn-args count))
+    (make-ex (string-append "MZ"
+			    (list->string
+			     (let loop ([l (string->list name)])
+			       (cond
+				[(null? l) '()]
+				[(or (char=? (car l) #\:)
+				     (char=? (car l) #\/)
+				     (char=? (car l) #\-))
+				 (cons #\_ (loop (cdr l)))]
+				[else
+				 (cons (char-upcase (car l))
+				       (loop (cdr l)))]))))
+	     name
+	     sym
+	     doc
+	     args
+	     parent
+	     count
+	     depth
+	     mark)))
+
+(define (make-arg-list args)
+  (if (null? args)
+      '()
+      (cons (make-fld (car args) (cadr args) (caddr args))
+	    (make-arg-list (cdddr args)))))
+
+(define (make-struct-list v parent parent-name totalargs depth)
+  (cond
+   [(null? v) '()]
+   [else
+    (let*-values ([(s mark)
+		  (let* ([s (symbol->string (car v))]
+			 [c (string-ref s 0)])
+		    (if (or (char=? #\* c)
+			    (char=? #\+ c))
+			(values (string->symbol (substring s 1 (string-length s))) c)
+			(values (car v) #f)))]
+		 [(e) (make-an-ex s parent parent-name totalargs 
+				  (make-arg-list (cadr v))
+				  (caddr v) depth mark)])
+      (cons e
+       (apply append
+	      (map
+	       (lambda (v)
+		 (make-struct-list v 
+				   (ex-define e)
+				   (ex-string e)
+				   (ex-numtotal e)
+				   (add1 depth)))
+	       (cdddr v)))))]))
+
+(define l (make-struct-list l
+			    #f
+			    ""
+			    0
+			    0))
+
+
+(define (symbol-length s)
+  (string-length (symbol->string s)))
+
+(if doc?
+    (begin
+      (printf "% This file was generated by makeexn~n")
+
+      (for-each
+       (lambda (e)
+	 (let ([tab
+		(let loop ([d (ex-depth e)])
+		  (cond
+		   [(zero? d) ""]
+		   [(= d 1) "{\\exninset}"]
+		   [else
+		    (string-append "\\>"
+				   (loop (sub1 d)))]))])
+	   (display tab)
+	   (printf "\\exntype{~a}{~a} " 
+		   (ex-base e)
+		   (case (ex-mark e)
+		     ((#f) "$\\bullet$")
+		     ((#\+) "$\\bullet$")
+		     ((#\*) "$\\bullet$")))
+	   
+	   (if (eq? (ex-doc e) '-)
+	       (printf "\\exnusenone{~a} " tab)
+	       (printf "\\exnuse{~a}{~a}{~a} " tab (ex-doc e)
+		       (- 6.3 (* 0.08 (symbol-length (ex-base e))) (* 0.25 (ex-depth e)))))
+	   
+	   (let ([args (ex-args e)]
+		 [print-one
+		  (lambda (f)
+		    (printf "\\exnfield{~a} \\exnfuse{~s}{~a \\exnftype{~a}} " 
+			    (fld-name f) 
+			    (- 5.4 (* 0.08 (symbol-length (fld-name f))) (* 0.25 (ex-depth e))) (fld-doc f) 
+			    (fld-type f)))])
+	     (unless (null? args)
+		     (printf "\\exnbeginfields{~a} " tab)
+		     (print-one (car args))
+		     (for-each (lambda (f)
+				 (printf "\\exnnextfield{~a}" tab)
+				 (print-one f))
+			       (cdr args))
+		     (printf "\\exnendfields{~a}" tab)))
+	   (printf "\\\\~n")))
+       l))
+    (begin
+      (printf "/* This file was generated by makeexn */~n")
+
+      (printf "#ifndef _MZEXN_DEFINES~n")
+      (printf "#define _MZEXN_DEFINES~n~n")
+      (printf "enum {~n")
+      (for-each
+       (lambda (e)
+	 (printf "  ~a,~n" (ex-define e)))
+       l)
+      (printf "  MZEXN_OTHER~n};~n~n")
+      (printf "#endif~n~n")
+      
+      
+      (printf "#ifdef _MZEXN_TABLE~n~n")
+      (printf "#define MZEXN_MAXARGS ~a~n~n" max-exn-args)
+	
+      (printf "#ifdef GLOBAL_EXN_ARRAY~n")
+
+      (printf "static exn_rec exn_table[] = {~n")
+      (let loop ([l l])
+	(let ([e (car l)])
+	  
+	  (printf "  { ~a, NULL, NULL, 0 }" 
+		  (ex-numtotal e))
+	  
+	  (unless (null? (cdr l))
+		  (printf ",~n")
+		  (loop (cdr l)))))
+      (printf "~n};~n")
+
+      (printf "#else~n")
+      (printf "static exn_rec *exn_table;~n")      
+      (printf "#endif~n")
+
+      (printf "~n#endif~n~n")
+
+      (printf "#ifdef _MZEXN_PRESETUP~n~n")
+      (printf "#ifndef GLOBAL_EXN_ARRAY~n")
+      (printf "  exn_table = (exn_rec *)scheme_malloc(sizeof(exn_rec) * MZEXN_OTHER);~n")
+      (let loop ([l l])
+	(let ([e (car l)])
+	  
+	  (printf "  exn_table[~a].args = ~a;~n"
+		  (ex-define e)
+		  (ex-numtotal e))
+	  (unless (null? (cdr l))
+		  (loop (cdr l)))))
+      (printf "#endif~n")
+      (printf "~n#endif~n~n")      
+      
+      (printf "#ifdef _MZEXN_DECL_FIELDS~n~n")
+      
+      (for-each
+       (lambda (e)
+	 (let ([l (ex-args e)])
+	   (unless (null? l)
+		   (printf "static const char *~a_FIELDS[~s] = { \"~a\"" 
+			   (ex-define e)
+			   (length l) 
+			   (fld-name (car l)))
+		   (for-each
+		    (lambda (field)
+		      (printf ", \"~a\"" (fld-name field)))
+		    (cdr l))
+		   (printf " };~n"))))
+       l)
+
+      (printf "~n#endif~n~n")
+      
+      (printf "#ifdef _MZEXN_SETUP~n~n")
+      
+      (for-each
+       (lambda (e)
+	 (printf "  SETUP_STRUCT(~a, ~a, ~s, ~a, ~a)~n"
+		 (ex-define e)
+		 (let ([p (ex-parent e)])
+		   (if p
+		       (format "EXN_PARENT(~a)" p)
+		       'NULL))
+		 (ex-string e)
+		 (length (ex-args e))
+		 (if (null? (ex-args e))
+		     "NULL"
+		     (format "~a_FIELDS" (ex-define e)))))
+       l)
+
+      (printf "~n#endif~n")))
diff --git a/src/mzscheme/src/makex b/src/mzscheme/src/makex
new file mode 100755
index 0000000..4575d77
--- /dev/null
+++ b/src/mzscheme/src/makex
@@ -0,0 +1,114 @@
+#!/usr/local/bin/perl -s
+
+$list = 1 if ($assign);
+$list = 1 if ($setupassign);
+$list = 1 if ($exports);
+
+while (<>) {
+    chop;
+    if ($_ eq '/* START */') {
+	@exported = ();
+
+	print "typedef struct {\n" unless $list;
+
+	while (<>) {
+	    if (substr($_, 0, 2) eq '/*' || substr($_, 0, 1) eq '#') {
+		print $_ unless $list;
+		if (substr($_, 0, 1) eq '#') {
+		    @exported = (@exported, $_);
+		}
+	    } else {
+		chop;
+		if (!($_ =~ /^ *$/)) {
+		    if ($_ =~ /^extern /) {
+			$_ = substr($_, 7);
+		    }
+		    if ($_ =~ /^const /) {
+			$_ = substr($_, 6);
+			$const = 'const ';
+		    } elsif ($_ =~ /^struct /) {
+			$_ = substr($_, 7);
+			$const = 'struct ';
+		    } else {
+			$const = '';
+		    }
+		    $_ =~ /([a-zA-Z0-9_]*) ([*]*)([a-zA-Z0-9_]*)(.*)/;
+		    if (substr($4, 0, 1) eq '(') {
+			print "$const$1 $2(*$3)$4\n" unless $list;
+		    } else {
+			print "$const$1 $2$3;\n" unless $list;
+		    }
+		    @exported = (@exported, $3);
+
+		    if (&Unbalanced($4)) {
+			do {
+			    $_ = <>;
+			    print $_ unless $list;
+			} while (!($_ =~ /\);/));
+		    }
+		}
+	    }
+	}
+
+	print "#ifndef SCHEME_EX_INLINE\n} Scheme_Extension_Table;\n#endif\n" unless $list;
+    } else {
+	print "$_\n" unless $list;
+    }
+}
+
+$elsesuspend = 0;
+$suspend = 0;
+
+print "#!\n" if $exports;
+
+if ($list) {
+    foreach $f (@exported) {
+	if (substr($f, 0, 1) eq '#') {
+	    if ($exports) {
+		if ($f =~ /#ifdef MZ_REAL_THREADS/) {
+		    $suspend = 1;
+		}
+		if ($f =~ /#ifndef MZ_REAL_THREADS/) {
+		    $elsesuspend = 1;
+		}
+		if ($f =~ /#else/) {
+		    $suspend = 0;
+		    $suspend = 1 if $elsesuspend;
+		    $elsesuspend = 0;
+		}
+		if ($f =~ /#endif/) {
+		    $suspend = $elsesuspend = 0;
+		}
+	    } else {
+		print $f;
+	    }
+	} else {
+	    if ($assign) {
+		print "  scheme_extension_table->$f = $f;\n";
+	    } elsif ($setupassign) {
+		print "  $f = table->$f;\n";
+	    } elsif ($exports) {
+		print "$f\n" unless $suspend;
+	    } else {
+		print "#define $f (scheme_extension_table->$f)\n";
+	    }
+	}
+    }
+}
+
+sub Unbalanced {
+    local ($s) = @_;
+
+    $balance = 0;
+    while ($s ne '') {
+	$char = substr($s, 0, 1);
+	if ($char eq '(') {
+	    $balance += 1;
+	} elsif ($char eq ')') {
+	    $balance -= 1;
+	}
+	$s = substr($s, 1);
+    }
+
+    return $balance;
+}
diff --git a/src/mzscheme/src/mzsj86.c b/src/mzscheme/src/mzsj86.c
new file mode 100644
index 0000000..87afc32
--- /dev/null
+++ b/src/mzscheme/src/mzsj86.c
@@ -0,0 +1,65 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "setjmp.h"
+
+/* Re-implementation of i386 setjmp to avoid Windows-specific work,
+   which messes up MzScheme's (MrEd's, really) threads. */
+
+/* Got this working for MSVC8 non-optimized. I'm too lazy to get it
+   right with optimization. */
+#pragma optimize("", off)
+
+int scheme_setjmp(jmp_buf b)
+{
+  __asm {
+	mov ECX, [EBP+4] ; return address
+	mov EAX, [EBP+8]
+	mov EDX, [EBP] ; old EBP
+	mov [EAX], EDX
+	mov [EAX+4], EBX
+	mov [EAX+8], EDI
+	mov [EAX+12], ESI
+	mov [EAX+16], ESP
+	mov [EAX+20], ECX
+  }
+
+  return 0;
+}
+
+void scheme_longjmp(jmp_buf b, int v)
+{
+  __asm {
+	mov EAX, [EBP+12] ; return value
+	mov ECX, [EBP+8] ; jmp_buf
+	mov ESP, [ECX+16]
+	mov EBP, [ECX] ; old EBP
+	mov [ESP + 12], EBP
+	mov EBP, ESP
+	add EBP, 12
+	mov EBX, [ECX+4]
+	mov [ESP + 8], EBX
+	mov EDI, [ECX+8]
+	mov [ESP], EDI
+	mov ESI, [ECX+12]
+	mov [ESP + 4], ESI
+	mov ECX, [ECX+20] ; return address
+	mov [EBP + 4], ECX
+  }
+}
diff --git a/src/mzscheme/src/mzstkchk.h b/src/mzscheme/src/mzstkchk.h
new file mode 100644
index 0000000..6bb373c
--- /dev/null
+++ b/src/mzscheme/src/mzstkchk.h
@@ -0,0 +1,30 @@
+#ifndef SCHEME_CURRENT_PROCESS
+#define SCHEME_CURRENT_PROCESS scheme_current_process
+#endif
+#ifndef SCHEME_STACK_BOUNDARY
+#define SCHEME_STACK_BOUNDARY scheme_stack_boundary
+#endif
+
+#ifdef SPAWN_NEW_STACK
+  unsigned long _stk_pos;
+
+  _stk_pos = (unsigned long)&_stk_pos;
+  if (STK_COMP(_stk_pos, (unsigned long)SCHEME_CURRENT_PROCESS->stack_end))
+#else
+#ifdef USE_STACKAVAIL
+  if (stackavail() < STACK_SAFETY_MARGIN)
+#endif
+#if defined(UNIX_FIND_STACK_BOUNDS) || defined(WINDOWS_FIND_STACK_BOUNDS) || defined(ASSUME_FIXED_STACK_SIZE)
+  unsigned long _stk_pos;
+
+  _stk_pos = (unsigned long)&_stk_pos;
+
+  if (STK_COMP(_stk_pos, SCHEME_STACK_BOUNDARY))
+#endif
+#ifdef MACOS_STACK_LIMIT
+  if (StackSpace() < STACK_SAFETY_MARGIN)
+#endif
+#endif
+
+#undef SCHEME_CURRENT_PROCESS
+#undef SCHEME_STACK_BOUNDARY
diff --git a/src/mzscheme/src/number.c b/src/mzscheme/src/number.c
new file mode 100644
index 0000000..00d054a
--- /dev/null
+++ b/src/mzscheme/src/number.c
@@ -0,0 +1,3587 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include "nummacs.h"
+#include <math.h>
+#include <string.h>
+#include <ctype.h>
+#ifndef DONT_IGNORE_FPE_SIGNAL
+#include <signal.h>
+#endif
+#ifdef IGNORE_BY_CONTROL_387
+#include <float.h>
+#endif
+
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+# ifndef MZ_USE_SINGLE_FLOATS
+#  undef USE_SINGLE_FLOATS_AS_DEFAULT
+# endif
+#endif
+
+#ifndef INEXACT_PRINT_DIGITS
+#define INEXACT_PRINT_DIGITS "14"
+#endif
+
+#ifdef SIXTY_FOUR_BIT_INTEGERS
+# define MAX_SHIFT_TRY 61
+# define MAX_SHIFT_EVER 64
+#else
+# define MAX_SHIFT_TRY 29
+# define MAX_SHIFT_EVER 32
+#endif
+
+#define REAL_NUMBER_STR "real number"
+
+/* globals */
+double scheme_infinity_val, scheme_minus_infinity_val;
+
+/* locals */
+static Scheme_Object *number_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *complex_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *real_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *rational_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *integer_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *exact_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *inexact_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *lt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *gt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *lt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *gt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *zero_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *positive_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *negative_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *even_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_max (int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_min (int argc, Scheme_Object *argv[]);
+static Scheme_Object *plus (int argc, Scheme_Object *argv[]);
+static Scheme_Object *minus (int argc, Scheme_Object *argv[]);
+static Scheme_Object *mult (int argc, Scheme_Object *argv[]);
+static Scheme_Object *div_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *abs_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *quotient (int argc, Scheme_Object *argv[]);
+static Scheme_Object *rem_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *bitwise_and (int argc, Scheme_Object *argv[]);
+static Scheme_Object *bitwise_or (int argc, Scheme_Object *argv[]);
+static Scheme_Object *bitwise_xor (int argc, Scheme_Object *argv[]);
+static Scheme_Object *bitwise_not (int argc, Scheme_Object *argv[]);
+static Scheme_Object *bitwise_shift (int argc, Scheme_Object *argv[]);
+static Scheme_Object *gcd (int argc, Scheme_Object *argv[]);
+static Scheme_Object *lcm (int argc, Scheme_Object *argv[]);
+static Scheme_Object *floor_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *ceiling (int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_truncate (int argc, Scheme_Object *argv[]);
+static Scheme_Object *round (int argc, Scheme_Object *argv[]);
+static Scheme_Object *numerator (int argc, Scheme_Object *argv[]);
+static Scheme_Object *denominator (int argc, Scheme_Object *argv[]);
+static Scheme_Object *exp_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *log_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *sin_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *cos_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *tan_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *asin_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *acos_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *atan_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_rectangular (int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_polar (int argc, Scheme_Object *argv[]);
+static Scheme_Object *real_part (int argc, Scheme_Object *argv[]);
+static Scheme_Object *imag_part (int argc, Scheme_Object *argv[]);
+static Scheme_Object *magnitude (int argc, Scheme_Object *argv[]);
+static Scheme_Object *angle (int argc, Scheme_Object *argv[]);
+static Scheme_Object *inexact_to_exact (int argc, Scheme_Object *argv[]);
+static Scheme_Object *exact_to_inexact (int argc, Scheme_Object *argv[]);
+static Scheme_Object *number_to_string (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_to_number (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *random_seed(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_random(int argc, Scheme_Object *argv[]);
+
+static int double_to_int(const char *where, double d, long *v);
+
+static double not_a_number_val;
+
+static char *infinity_str = "+inf.0";
+static char *minus_infinity_str = "-inf.0";
+static char *not_a_number_str = "+nan.0";
+static char *other_not_a_number_str = "-nan.0";
+
+static Scheme_Object *inf_object, *minus_inf_object, *nan_object;
+
+#define zeroi scheme_make_integer(0)
+
+static Scheme_Object *zerod, *scheme_pi, *plus_i, *minus_i;
+#ifdef MZ_USE_SINGLE_FLOATS
+static Scheme_Object *zerof, *single_scheme_pi;
+static Scheme_Object *single_inf_object, *single_minus_inf_object, *single_nan_object;
+#endif
+
+double scheme_floating_point_zero = 0.0;
+
+#ifdef FREEBSD_CONTROL_387
+#include <machine/floatingpoint.h>
+#endif
+#ifdef LINUX_CONTROL_387
+#include <fpu_control.h>
+#endif
+#ifdef ALPHA_CONTROL_FP
+#include <machine/fpu.h>
+#endif
+
+void
+scheme_init_number (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(scheme_pi);
+    REGISTER_SO(zerod);
+#ifdef MZ_USE_SINGLE_FLOATS
+    REGISTER_SO(single_scheme_pi);
+    REGISTER_SO(zerof);
+#endif
+    REGISTER_SO(plus_i);
+    REGISTER_SO(minus_i);
+    REGISTER_SO(inf_object);
+    REGISTER_SO(minus_inf_object);
+    REGISTER_SO(nan_object);
+#ifdef MZ_USE_SINGLE_FLOATS
+    REGISTER_SO(single_inf_object);
+    REGISTER_SO(single_minus_inf_object);
+    REGISTER_SO(single_nan_object);
+#endif
+    
+#ifndef DONT_IGNORE_FPE_SIGNAL
+    MZ_SIGSET(SIGFPE, SIG_IGN);
+#endif
+#ifdef FREEBSD_CONTROL_387
+    __fpsetreg(FP_MSKS_FLD, FP_MSKS_REG, FP_MSKS_FLD, FP_MSKS_OFF);
+#endif
+#ifdef LINUX_CONTROL_387
+    __setfpucw(_FPU_EXTENDED + _FPU_RC_NEAREST + 0x3F);
+#endif
+#ifdef IGNORE_BY_CONTROL_387
+    {
+      int bits = 0x3F + _RC_NEAR + _PC_64;
+      _control87(bits, 0xFFFF);
+    }
+#endif
+#ifdef ALPHA_CONTROL_FP
+    {
+      long flags = ieee_get_fp_control();
+      flags |= IEEE_TRAP_ENABLE_MASK;
+      ieee_set_fp_control(flags);
+    }
+#endif
+
+#if defined(HUGE_VAL) && !defined(USE_DIVIDE_MAKE_INFINITY)
+    scheme_infinity_val = HUGE_VAL;
+#else
+#ifndef USE_INFINITY_FUNC
+    scheme_infinity_val = 1.0 / scheme_floating_point_zero;
+#else
+    scheme_infinity_val = infinity();
+#endif
+#endif
+
+    scheme_minus_infinity_val = -scheme_infinity_val;
+    not_a_number_val = scheme_infinity_val + scheme_minus_infinity_val;
+
+    zerod = scheme_make_double(0.0);
+    scheme_pi = scheme_make_double(atan2(0, -1));
+#ifdef MZ_USE_SINGLE_FLOATS
+    zerof = scheme_make_float(0.0f);
+    single_scheme_pi = scheme_make_float((float)atan2(0, -1));
+#endif
+    plus_i = scheme_make_complex(scheme_make_integer(0), scheme_make_integer(1));
+    minus_i = scheme_make_complex(scheme_make_integer(0), scheme_make_integer(-1));
+
+    inf_object = scheme_make_double(scheme_infinity_val);
+    minus_inf_object = scheme_make_double(scheme_minus_infinity_val);
+    nan_object = scheme_make_double(not_a_number_val);
+#ifdef MZ_USE_SINGLE_FLOATS
+    single_inf_object = scheme_make_float((float)scheme_infinity_val);
+    single_minus_inf_object = scheme_make_float((float)scheme_minus_infinity_val);
+    single_nan_object = scheme_make_float((float)not_a_number_val);
+#endif
+  }
+
+  scheme_add_global_constant("number?", 
+			     scheme_make_folding_prim(number_p,
+						      "number?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("complex?", 
+			     scheme_make_folding_prim(complex_p,
+						      "complex?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("real?", 
+			     scheme_make_folding_prim(real_p,
+						      "real?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("rational?", 
+			     scheme_make_folding_prim(rational_p,
+						      "rational?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("integer?", 
+			     scheme_make_folding_prim(integer_p,
+						      "integer?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("exact?", 
+			     scheme_make_folding_prim(exact_p,
+						      "exact?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("inexact?", 
+			     scheme_make_folding_prim(inexact_p,
+						      "inexact?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("=", 
+			     scheme_make_folding_prim(eq,
+						      "=",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("<", 
+			     scheme_make_folding_prim(lt,
+						      "<",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant(">", 
+			     scheme_make_folding_prim(gt,
+						      ">",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("<=", 
+			     scheme_make_folding_prim(lt_eq,
+						      "<=",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant(">=", 
+			     scheme_make_folding_prim(gt_eq,
+						      ">=",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("zero?", 
+			     scheme_make_folding_prim(zero_p,
+						      "zero?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("positive?", 
+			     scheme_make_folding_prim(positive_p,
+						      "positive?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("negative?", 
+			     scheme_make_folding_prim(negative_p,
+						      "negative?",
+						      1, 1, 1),
+			     env);
+
+  scheme_add_global_constant("add1", 
+			     scheme_make_folding_prim(scheme_add1,
+						      "add1",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("sub1", 
+			     scheme_make_folding_prim(scheme_sub1,
+						      "sub1",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("odd?", 
+			     scheme_make_folding_prim(scheme_odd_p,
+						      "odd?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("even?", 
+			     scheme_make_folding_prim(even_p,
+						      "even?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("max", 
+			     scheme_make_folding_prim(sch_max,
+						      "max",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("min", 
+			     scheme_make_folding_prim(sch_min,
+						      "min",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("+", 
+			     scheme_make_folding_prim(plus,
+						      "+", 
+						      0, -1, 1),
+			     env);
+  scheme_add_global_constant("-", 
+			     scheme_make_folding_prim(minus,
+						      "-",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("*", 
+			     scheme_make_folding_prim(mult,
+						      "*", 
+						      0, -1, 1),
+			     env);
+  scheme_add_global_constant("/", 
+			     scheme_make_folding_prim(div_prim,
+						      "/",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("abs", 
+			     scheme_make_folding_prim(abs_prim,
+						      "abs",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("quotient", 
+			     scheme_make_folding_prim(quotient,
+						      "quotient", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("remainder", 
+			     scheme_make_folding_prim(rem_prim,
+						      "remainder", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("modulo", 
+			     scheme_make_folding_prim(scheme_modulo,
+						      "modulo", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("bitwise-and", 
+			     scheme_make_folding_prim(bitwise_and,
+						      "bitwise-and",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("bitwise-ior", 
+			     scheme_make_folding_prim(bitwise_or,
+						      "bitwise-ior",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("bitwise-xor", 
+			     scheme_make_folding_prim(bitwise_xor,
+						      "bitwise-xor",
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("bitwise-not", 
+			     scheme_make_folding_prim(bitwise_not,
+						      "bitwise-not",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("arithmetic-shift", 
+			     scheme_make_folding_prim(bitwise_shift,
+						      "arithmetic-shift",
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("gcd", 
+			     scheme_make_folding_prim(gcd,
+						      "gcd", 
+						      0, -1, 1),
+			     env);
+  scheme_add_global_constant("lcm", 
+			     scheme_make_folding_prim(lcm,
+						      "lcm", 
+						      0, -1, 1),
+			     env);
+  scheme_add_global_constant("floor", 
+			     scheme_make_folding_prim(floor_prim,
+						      "floor",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("ceiling", 
+			     scheme_make_folding_prim(ceiling,
+						      "ceiling",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("truncate", 
+			     scheme_make_folding_prim(sch_truncate,
+						      "truncate",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("round", 
+			     scheme_make_folding_prim(round,
+						      "round",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("numerator", 
+			     scheme_make_folding_prim(numerator,
+						      "numerator",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("denominator", 
+			     scheme_make_folding_prim(denominator,
+						      "denominator",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("exp", 
+			     scheme_make_folding_prim(exp_prim,
+						      "exp",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("log", 
+			     scheme_make_folding_prim(log_prim,
+						      "log",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("sin", 
+			     scheme_make_folding_prim(sin_prim,
+						      "sin",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("cos", 
+			     scheme_make_folding_prim(cos_prim,
+						      "cos",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("tan", 
+			     scheme_make_folding_prim(tan_prim,
+						      "tan",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("asin", 
+			     scheme_make_folding_prim(asin_prim,
+						      "asin",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("acos", 
+			     scheme_make_folding_prim(acos_prim,
+						      "acos",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("atan", 
+			     scheme_make_folding_prim(atan_prim,
+						      "atan",
+						      1, 2, 1),
+			     env);
+  scheme_add_global_constant("sqrt", 
+			     scheme_make_folding_prim(scheme_sqrt,
+						      "sqrt",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("expt", 
+			     scheme_make_folding_prim(scheme_expt,
+						      "expt", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("make-rectangular", 
+			     scheme_make_folding_prim(make_rectangular,
+						      "make-rectangular", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("make-polar", 
+			     scheme_make_folding_prim(make_polar,
+						      "make-polar", 
+						      2, 2, 1),
+			     env);
+  scheme_add_global_constant("real-part", 
+			     scheme_make_folding_prim(real_part,
+						      "real-part",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("imag-part", 
+			     scheme_make_folding_prim(imag_part,
+						      "imag-part",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("angle", 
+			     scheme_make_folding_prim(angle,
+						      "angle",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("magnitude", 
+			     scheme_make_folding_prim(magnitude,
+						      "magnitude",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("random", 
+			     scheme_make_prim_w_arity(sch_random,
+						      "random",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("random-seed", 
+			     scheme_make_prim_w_arity(random_seed,
+						      "random-seed",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("exact->inexact", 
+			     scheme_make_folding_prim(exact_to_inexact,
+						      "exact->inexact",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("inexact->exact", 
+			     scheme_make_folding_prim(inexact_to_exact,
+						      "inexact->exact",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("number->string", 
+			     scheme_make_prim_w_arity(number_to_string,
+						      "number->string",
+						      1, 2),
+			     env);
+  scheme_add_global_constant("string->number", 
+			     scheme_make_folding_prim(string_to_number,
+						      "string->number", 
+						      1, 2, 1),
+			     env);
+}
+
+
+Scheme_Object *
+scheme_make_integer_value(long i)
+{
+  Scheme_Object *o = scheme_make_integer(i);
+  
+  if (SCHEME_INT_VAL(o) == i)
+    return o;
+  else
+    return scheme_make_bignum(i);
+}
+
+Scheme_Object *
+scheme_make_integer_value_from_unsigned(unsigned long i)
+{
+  Scheme_Object *o = scheme_make_integer(i);
+  
+  if (((unsigned long)SCHEME_INT_VAL(o)) == i)
+    return o;
+  else
+    return scheme_make_bignum_from_unsigned(i);
+}
+
+int scheme_get_int_val(Scheme_Object *o, long *v)
+{
+  if (SCHEME_INTP(o)) {
+    *v = SCHEME_INT_VAL(o);
+    return 1;
+  } else if (SCHEME_BIGNUMP(o))
+    return scheme_bignum_get_int_val(o, v);
+  else
+    return 0;
+}
+
+int scheme_get_unsigned_int_val(Scheme_Object *o, unsigned long *v)
+{
+  if (SCHEME_INTP(o)) {
+    long i = SCHEME_INT_VAL(o);
+    if (i < 0)
+      return 0;
+    *v = i;
+    return 1;
+  } else if (SCHEME_BIGNUMP(o))
+    return scheme_bignum_get_unsigned_int_val(o, v);
+  else
+    return 0;
+}
+
+Scheme_Object *scheme_make_double(double d)
+{
+  Scheme_Double *sd;
+
+  sd = (Scheme_Double *)scheme_malloc_atomic_tagged(sizeof(Scheme_Double));
+  sd->type = scheme_double_type;
+  SCHEME_DBL_VAL(sd) = d;
+  return (Scheme_Object *)sd;
+}
+
+#ifdef MZ_USE_SINGLE_FLOATS
+Scheme_Object *scheme_make_float(float f)
+{
+  Scheme_Float *sf;
+
+  sf = (Scheme_Float *)scheme_malloc_atomic_tagged(sizeof(Scheme_Float));
+  sf->type = scheme_float_type;
+  SCHEME_FLT_VAL(sf) = f;
+  return (Scheme_Object *)sf;
+}
+#endif
+
+/* locals */
+
+#define NEED_NUMBER(name) \
+  scheme_wrong_type(#name, "number", 0, argc, argv)
+#define NEED_REAL(name) \
+  scheme_wrong_type(#name, REAL_NUMBER_STR, 0, argc, argv)
+#define NEED_INTEGER(name) \
+  scheme_wrong_type(#name, "integer", 0, argc, argv)
+#define WRONG_TYPE(name, expected, value) \
+  scheme_wrong_type(name, expected, -1, 0, (Scheme_Object **)&value)
+
+static Scheme_Object *
+number_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  return (SCHEME_NUMBERP(o) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+complex_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  return (SCHEME_NUMBERP(o) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+real_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  return (SCHEME_REALP(o) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+rational_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  return (SCHEME_REALP(o) ? scheme_true : scheme_false);
+}
+	  
+static int is_integer(const Scheme_Object *o)
+{
+  if (SCHEME_INTP(o) || SCHEME_BIGNUMP(o))
+    return 1;
+
+  if (SCHEME_FLOATP(o)) {
+    double d;
+    d = SCHEME_FLOAT_VAL(o);
+# ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d))
+      return 0;
+# endif
+    if (floor(d) == d)
+      return 1;
+  }
+
+  return 0;
+}
+
+
+static Scheme_Object *
+integer_p (int argc, Scheme_Object *argv[])
+{
+  return is_integer(argv[0]) ? scheme_true : scheme_false;
+}
+
+int scheme_is_exact(Scheme_Object *n)
+{
+  if (SCHEME_INTP(n)) {
+    return 1;
+  } else {
+    Scheme_Type type = _SCHEME_TYPE(n);
+    if ((type == scheme_bignum_type)
+	|| (type == scheme_rational_type))
+      return 1;
+    else if (type == scheme_complex_type) {
+      return scheme_is_complex_exact(n);
+    } else if (type == scheme_double_type)
+      return 0;
+#ifdef MZ_USE_SINGLE_FLOATS
+    else if (type == scheme_float_type)
+      return 0;
+#endif
+    else {
+      scheme_wrong_type("exact?", "number", 0, 1, &n);
+      return 0;
+    }
+  }
+}
+
+static Scheme_Object *
+exact_p (int argc, Scheme_Object *argv[])
+{
+  return (scheme_is_exact(argv[0])
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+int scheme_is_inexact(Scheme_Object *n)
+{
+  if (SCHEME_INTP(n)) {
+    return 0;
+  } else {
+    Scheme_Type type = _SCHEME_TYPE(n);
+    if ((type == scheme_bignum_type)
+	|| (type == scheme_rational_type))
+      return 0;
+    else if (type == scheme_complex_type) {
+      return !scheme_is_complex_exact(n);
+    } else if (type == scheme_double_type)
+      return 1;
+#ifdef MZ_USE_SINGLE_FLOATS
+    else if (type == scheme_float_type)
+      return 1;
+#endif
+    else {
+      scheme_wrong_type("inexact?", "number", 0, 1, &n);
+      return 0;
+    }
+  }
+}
+
+static Scheme_Object *
+inexact_p (int argc, Scheme_Object *argv[])
+{
+  return (scheme_is_inexact(argv[0])
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+GEN_NARY_COMP(eq, "=", scheme_bin_eq, SCHEME_NUMBERP, "number")
+GEN_NARY_COMP(lt, "<", scheme_bin_lt, SCHEME_REALP, REAL_NUMBER_STR)
+GEN_NARY_COMP(gt, ">", scheme_bin_gt, SCHEME_REALP, REAL_NUMBER_STR)
+GEN_NARY_COMP(lt_eq, "<=", scheme_bin_lt_eq, SCHEME_REALP, REAL_NUMBER_STR)
+GEN_NARY_COMP(gt_eq, ">=", scheme_bin_gt_eq, SCHEME_REALP, REAL_NUMBER_STR)
+
+#define EQUAL(x, y) (x == y)
+#define LESS_THAN(x, y) (x < y)
+#define GREATER_THAN(x, y) (x > y)
+#define LESS_OR_EQUAL(x, y) (x <= y)
+#define GREATER_OR_EQUAL(x, y) (x >= y)
+
+#define COMP_NADA(a, b) 0
+
+GEN_BIN_COMP(scheme_bin_eq, "=", EQUAL, scheme_bignum_eq, scheme_rational_eq, scheme_complex_eq, 0, 0, inexact_p, inexact_p, GEN_IDENT, "number")
+GEN_BIN_COMP(scheme_bin_lt, "<", LESS_THAN, scheme_bignum_lt, scheme_rational_lt, COMP_NADA, 0, 1, positive_p, negative_p, GEN_OMIT, REAL_NUMBER_STR)
+GEN_BIN_COMP(scheme_bin_gt, ">", GREATER_THAN, scheme_bignum_gt, scheme_rational_gt, COMP_NADA, 1, 0, negative_p, positive_p, GEN_OMIT, REAL_NUMBER_STR)
+GEN_BIN_COMP(scheme_bin_lt_eq, "<=", LESS_OR_EQUAL, scheme_bignum_le, scheme_rational_le, COMP_NADA, 0, 1, positive_p, negative_p, GEN_OMIT, REAL_NUMBER_STR)
+GEN_BIN_COMP(scheme_bin_gt_eq, ">=", GREATER_OR_EQUAL, scheme_bignum_ge, scheme_rational_ge, COMP_NADA, 1, 0, negative_p, positive_p, GEN_OMIT, REAL_NUMBER_STR)
+
+static Scheme_Object *
+zero_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o))
+#ifdef FAST_NUMBERS
+    return (o == zeroi) ? scheme_true : scheme_false;
+#else
+    return SCHEME_INT_VAL(o) ? scheme_false : scheme_true;
+#endif
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return SCHEME_FLT_VAL(o) ? scheme_false : scheme_true;
+#endif
+  if (t == scheme_double_type)
+    return SCHEME_DBL_VAL(o) ? scheme_false : scheme_true;
+  if ((t >= scheme_bignum_type) && (t <= scheme_complex_type))
+    return scheme_false;
+ 
+  NEED_NUMBER(zero?);
+
+  return NULL;
+}
+
+static Scheme_Object *
+positive_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o))
+    return (SCHEME_INT_VAL(o) > 0 ? scheme_true : scheme_false);
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type) {
+    float d = SCHEME_FLT_VAL(o);
+# ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d))
+      return scheme_false;
+# endif
+    return (d > 0 ? scheme_true : scheme_false);
+  }
+#endif
+  if (t == scheme_double_type) {
+    double d = SCHEME_DBL_VAL(o);
+#ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d))
+      return scheme_false;
+#endif
+    return (d > 0 ? scheme_true : scheme_false);
+  }
+  if (t == scheme_bignum_type)
+    return (SCHEME_BIGPOS(o) ? scheme_true : scheme_false);
+  if (t == scheme_rational_type)
+    return (scheme_is_rational_positive(o)  ? scheme_true : scheme_false);
+
+  NEED_REAL(positive?);
+
+  return NULL;
+}
+
+static Scheme_Object *
+negative_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o))
+    return (SCHEME_INT_VAL(o) < 0 ? scheme_true : scheme_false);
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type) {
+    float d = SCHEME_FLT_VAL(o);
+# ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d))
+      return scheme_false;
+# endif
+    return (d < 0 ? scheme_true : scheme_false);
+  }
+#endif
+  if (t == scheme_double_type) {
+    double d = SCHEME_DBL_VAL(o);
+#ifdef NAN_EQUALS_ANYTHING
+    if (MZ_IS_NAN(d))
+      return scheme_false;
+#endif
+    return (d < 0 ? scheme_true : scheme_false);
+  }
+  if (t == scheme_bignum_type)
+    return (!SCHEME_BIGPOS(o) ? scheme_true : scheme_false);
+  if (t == scheme_rational_type)
+    return (!scheme_is_rational_positive(o) ? scheme_true : scheme_false);
+
+  NEED_REAL(negative?);
+
+  return NULL;
+}
+
+Scheme_Object *
+scheme_odd_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v = argv[0];
+
+  if (SCHEME_INTP(v))
+    return (SCHEME_INT_VAL(v) & 0x1) ? scheme_true : scheme_false;
+  if (SCHEME_BIGNUMP(v))
+    return (SCHEME_BIGDIG(v)[0] & 0x1) ? scheme_true : scheme_false;
+  
+  if (is_integer(v)) {
+    double d = SCHEME_FLOAT_VAL(v);
+    if (MZ_IS_POS_INFINITY(d) || MZ_IS_NEG_INFINITY(d))
+      return scheme_true;
+    return fmod(d, 2.0) ? scheme_true : scheme_false;
+  }
+
+  NEED_INTEGER(odd?);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+even_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v = argv[0];
+
+  if (SCHEME_INTP(v))
+    return (SCHEME_INT_VAL(v) & 0x1) ? scheme_false : scheme_true;
+  if (SCHEME_BIGNUMP(v))
+    return (SCHEME_BIGDIG(v)[0] & 0x1) ? scheme_false : scheme_true;
+
+  if (is_integer(v)) {
+    double d = SCHEME_FLOAT_VAL(v);
+    if (MZ_IS_POS_INFINITY(d) || MZ_IS_NEG_INFINITY(d))
+      return scheme_true;
+    return fmod(d, 2.0) ? scheme_false : scheme_true;
+  }
+
+  NEED_INTEGER(even?);
+
+  return scheme_void;
+}
+
+Scheme_Object *
+scheme_add1 (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o)) {
+    long v;
+    v = SCHEME_INT_VAL(o);
+    if (v < 0x3FFFFFFF)
+      return scheme_make_integer(v + 1);
+    else
+      return scheme_bignum_add1(scheme_make_bignum(v));
+  }
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return scheme_make_float(SCHEME_FLT_VAL(o) + 1.0f);
+#endif
+  if (t == scheme_double_type)
+    return scheme_make_double(SCHEME_DBL_VAL(o) + 1.0);
+  if (t == scheme_bignum_type)
+    return scheme_bignum_add1(o);
+  if (t == scheme_rational_type)
+    return scheme_rational_add1(o);
+  if (t == scheme_complex_type)
+    return scheme_complex_add1(o);
+
+  NEED_NUMBER(add1);
+
+  return scheme_void;
+}
+
+Scheme_Object *
+scheme_sub1 (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o)) {
+    long v;
+    v = SCHEME_INT_VAL(o);
+    if (v > -(0x3FFFFFFF))
+      return scheme_make_integer(SCHEME_INT_VAL(o) - 1);
+    else
+      return scheme_bignum_sub1(scheme_make_bignum(v));
+  }
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return scheme_make_float(SCHEME_FLT_VAL(o) - 1.0f);
+#endif
+  if (t == scheme_double_type)
+    return scheme_make_double(SCHEME_DBL_VAL(o) - 1.0);
+  if (t == scheme_bignum_type)
+    return scheme_bignum_sub1(o);
+  if (t == scheme_rational_type)
+    return scheme_rational_sub1(o);
+  if (t == scheme_complex_type)
+    return scheme_complex_sub1(o);
+  
+  NEED_NUMBER(sub1);
+
+  return scheme_void;
+}
+
+GEN_BIN_PROT(bin_max);
+GEN_BIN_PROT(bin_min);
+
+#define F_ADD(x,y) scheme_make_double(x + y)
+#define F_SUBTRACT(x,y) scheme_make_double(x - y)
+#define F_MULTIPLY(x,y) scheme_make_double(x * y)
+#define DIVIDE(x,y) scheme_make_fixnum_rational(x, y)
+#define F_DIVIDE(x,y) scheme_make_double((double)x / (double)y)
+#define MAX(n1,n2) scheme_make_integer((n1>n2) ? n1 : n2)
+#define MIN(n1,n2) scheme_make_integer((n1<n2) ? n1 : n2)
+#define F_MAX(n1,n2) scheme_make_double((n1>n2) ? n1 : n2)
+#define F_MIN(n1,n2) scheme_make_double((n1<n2) ? n1 : n2)
+
+#define FS_ADD(x,y) scheme_make_float(x + y)
+#define FS_SUBTRACT(x,y) scheme_make_float(x - y)
+#define FS_MULTIPLY(x,y) scheme_make_float(x * y)
+#define FS_DIVIDE(x,y) scheme_make_float((float)x / (float)y)
+#define FS_MAX(n1,n2) scheme_make_float((n1>n2) ? n1 : n2)
+#define FS_MIN(n1,n2) scheme_make_float((n1<n2) ? n1 : n2)
+
+static Scheme_Object *ADD(long a, long b)
+{
+  long r;
+  Scheme_Object *o;
+
+  r = a + b;
+
+  o = scheme_make_integer(r);
+  r = SCHEME_INT_VAL(o);
+
+  if (b == r - a)
+    return o;
+  else {
+    Small_Bignum sa, sb;
+    return scheme_bignum_add(scheme_make_small_bignum(a, &sa),
+			     scheme_make_small_bignum(b, &sb));
+  }
+}
+
+static Scheme_Object *SUBTRACT(long a, long b)
+{
+  long r;
+  Scheme_Object *o;
+
+  r = a - b;
+
+  o = scheme_make_integer(r);
+  r = SCHEME_INT_VAL(o);
+
+  if (a == r + b)
+    return o;
+  else {
+    Small_Bignum sa, sb;
+    return scheme_bignum_subtract(scheme_make_small_bignum(a, &sa),
+				  scheme_make_small_bignum(b, &sb));
+  }
+}
+
+static Scheme_Object *MULTIPLY(long a, long b)
+{
+  long r;
+  Scheme_Object *o;
+
+  if (!b)
+    return zeroi;
+
+  r = a * b;
+
+  o = scheme_make_integer(r);
+  r = SCHEME_INT_VAL(o);
+
+  if (a == r / b)
+    return o;
+  else {
+    Small_Bignum sa, sb;
+    return scheme_bignum_multiply(scheme_make_small_bignum(a, &sa),
+				  scheme_make_small_bignum(b, &sb));
+  }
+}
+
+static Scheme_Object *scheme_complex_not_real(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_void;
+}
+
+GEN_BIN_OP(scheme_bin_plus, "+", ADD, F_ADD, FS_ADD, scheme_bignum_add, scheme_rational_add, scheme_complex_add, NO_NAN_CHECK, NO_NAN_CHECK)
+GEN_BIN_OP(scheme_bin_minus, "-", SUBTRACT, F_SUBTRACT, FS_SUBTRACT, scheme_bignum_subtract, scheme_rational_subtract, scheme_complex_subtract, NO_NAN_CHECK, NO_NAN_CHECK)
+GEN_BIN_OP(scheme_bin_mult, "*", MULTIPLY, F_MULTIPLY, FS_MULTIPLY, scheme_bignum_multiply, scheme_rational_multiply, scheme_complex_multiply, NO_NAN_CHECK, NO_NAN_CHECK)
+GEN_BIN_DIV_OP(scheme_bin_div, "/", DIVIDE, F_DIVIDE, FS_DIVIDE, scheme_make_rational, scheme_rational_divide, scheme_complex_divide)
+
+static GEN_BIN_OP(bin_max, "max", MAX, F_MAX, FS_MAX, scheme_bignum_max, scheme_rational_max, scheme_complex_not_real, NAN_RETURNS_NAN, NAN_RETURNS_SNAN)
+static GEN_BIN_OP(bin_min, "min", MIN, F_MIN, FS_MIN, scheme_bignum_min, scheme_rational_min, scheme_complex_not_real, NAN_RETURNS_NAN, NAN_RETURNS_SNAN)
+
+GEN_BIN_PROT(bin_bitwise_and);
+GEN_BIN_PROT(bin_bitwise_or);
+GEN_BIN_PROT(bin_bitwise_xor);
+
+GEN_BIN_INT_OP(bin_bitwise_and, "bitwise-and", &, scheme_bignum_and)
+GEN_BIN_INT_OP(bin_bitwise_or, "bitwise-ior", |, scheme_bignum_or)
+GEN_BIN_INT_OP(bin_bitwise_xor, "bitwise-xor", ^, scheme_bignum_xor)
+
+GEN_TWOARY_OP(bitwise_and, "bitwise-and", bin_bitwise_and, SCHEME_EXACT_INTEGERP, "exact integer")
+GEN_TWOARY_OP(bitwise_or, "bitwise-ior", bin_bitwise_or, SCHEME_EXACT_INTEGERP, "exact integer")
+GEN_TWOARY_OP(bitwise_xor, "bitwise-xor", bin_bitwise_xor, SCHEME_EXACT_INTEGERP, "exact integer")
+
+GEN_TWOARY_OP(sch_max, "max", bin_max, SCHEME_REALP, REAL_NUMBER_STR)
+GEN_TWOARY_OP(sch_min, "min", bin_min, SCHEME_REALP, REAL_NUMBER_STR)
+GEN_NARY_OP(plus, "+", scheme_bin_plus, 0, SCHEME_NUMBERP, "number")
+GEN_NARY_OP(mult, "*", scheme_bin_mult, 1, SCHEME_NUMBERP, "number")
+
+static Scheme_Object *
+minus (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *ret;
+  int i;
+
+  ret = argv[0];
+  if (argc == 1) {
+    if (!SCHEME_NUMBERP(ret)) {
+      scheme_wrong_type("-", "number", 0, argc, argv);
+      return NULL;
+    }
+    return scheme_bin_minus(zeroi, ret);
+  }
+  for (i = 1; i < argc; i++) {
+    Scheme_Object *o = argv[i];
+    if (!SCHEME_NUMBERP(o)) {
+      scheme_wrong_type("-", "number", i, argc, argv);
+      return NULL;
+    }
+    ret = scheme_bin_minus(ret, o);
+  }
+  return ret;
+}
+
+static Scheme_Object *
+div_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *ret;
+  int i;
+
+  ret = argv[0];
+  if (!SCHEME_NUMBERP(ret)) {
+    scheme_wrong_type("/", "number", 0, argc, argv);
+    return NULL;
+  }
+  if (argc == 1) {
+    if (ret != zeroi)
+      return scheme_bin_div(scheme_make_integer(1), ret);
+    else {
+      scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, ret,
+		       "/: divide by zero");
+      return NULL;
+    }
+  }
+  for (i = 1; i < argc; i++) {
+    Scheme_Object *o = argv[i];
+
+    if (!SCHEME_NUMBERP(o)) {
+      scheme_wrong_type("/", "number", i, argc, argv);
+      return NULL;
+    }
+
+    if (o != zeroi)
+      ret = scheme_bin_div(ret, o);
+    else {
+      scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, o,
+		       "/: divide by zero");
+      return NULL;
+    }
+  }
+  return ret;
+}
+
+#define ABS(n)  ((n>0) ? n : -n)
+
+static Scheme_Object *
+abs_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Type t;
+  Scheme_Object *o;
+
+  o = argv[0];
+
+  if (SCHEME_INTP(o)) {
+    int n = SCHEME_INT_VAL(o);
+    return scheme_make_integer(ABS(n));
+  } 
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return scheme_make_float(fabs(SCHEME_FLT_VAL(o)));
+#endif
+  if (t == scheme_double_type)
+    return scheme_make_double(fabs(SCHEME_DBL_VAL(o)));
+  if (t == scheme_bignum_type) {
+    if (SCHEME_BIGPOS(o))
+      return o;
+    return scheme_bignum_negate(o);
+  }
+  if (t == scheme_rational_type) {
+    if (scheme_is_rational_positive(o))
+      return o;
+    else
+      return scheme_rational_negate(o);
+  }
+
+  NEED_REAL(abs);
+
+  return scheme_void;
+}
+
+static Scheme_Object *to_bignum(const Scheme_Object *o)
+{
+  if (SCHEME_INTP(o))
+    return scheme_make_bignum(SCHEME_INT_VAL(o));
+  else
+    return (Scheme_Object *)o;
+}
+
+Scheme_Object *
+scheme_bin_quotient (const Scheme_Object *n1, const Scheme_Object *n2)
+{
+  Scheme_Object *q;
+
+  if (!is_integer(n1)) {
+    Scheme_Object *a[2];
+    a[0] = (Scheme_Object *)n1;
+    a[1] = (Scheme_Object *)n2;
+    scheme_wrong_type("quotient", "integer", 0, 2, a);
+  }
+  if (!is_integer(n2)) {
+    Scheme_Object *a[2];
+    a[0] = (Scheme_Object *)n1;
+    a[1] = (Scheme_Object *)n2;
+    scheme_wrong_type("quotient", "integer", 1, 2, a);
+  }
+
+  if (SCHEME_INTP(n2) && !SCHEME_INT_VAL(n2))
+    scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, n2,
+		     "quotient: undefined for 0");
+  if (
+#ifdef MZ_USE_SINGLE_FLOATS
+      (SCHEME_FLTP(n2) && !SCHEME_FLT_VAL(n2)) ||
+#endif
+      (SCHEME_DBLP(n2) && !SCHEME_DBL_VAL(n2)))
+    scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, n2,
+		     "quotient: undefined for 0.0");
+
+  if (SCHEME_INTP(n1) && SCHEME_INTP(n2)) {
+    return (scheme_make_integer (SCHEME_INT_VAL(n1) / SCHEME_INT_VAL(n2)));
+  }
+  if (SCHEME_DBLP(n1) || SCHEME_DBLP(n2)) {
+    Scheme_Object *r = scheme_bin_div(n1, n2);
+    double d = SCHEME_DBL_VAL(r), d2;
+
+    if (d > 0)
+      d2 = floor(d);
+    else
+      d2 = ceil(d);
+
+    if (d2 == d)
+      return r;
+    else
+      return scheme_make_double(d2);
+  }
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (SCHEME_FLTP(n1) || SCHEME_FLTP(n2)) {
+    Scheme_Object *r = scheme_bin_div(n1, n2);
+    float d = SCHEME_FLT_VAL(r), d2;
+
+    if (d > 0)
+      d2 = floor(d);
+    else
+      d2 = ceil(d);
+
+    if (d2 == d)
+      return r;
+    else
+      return scheme_make_float(d2);
+  }
+#endif
+
+  if (SCHEME_RATIONALP(n1))
+    WRONG_TYPE("quotient", "integer", n1);
+  if (SCHEME_RATIONALP(n2))
+    WRONG_TYPE("quotient", "integer", n2);
+  
+  n1 = to_bignum(n1);
+  n2 = to_bignum(n2);
+
+  scheme_bignum_divide(n1, n2, &q, NULL, 1);
+  return q;
+}
+
+static Scheme_Object *
+quotient (int argc, Scheme_Object *argv[])
+{
+  return scheme_bin_quotient(argv[0], argv[1]);
+}
+
+static Scheme_Object *
+rem_mod (int argc, Scheme_Object *argv[], char *name, int first_sign)
+{
+  Scheme_Object *n1, *n2, *r;
+  int negate;
+
+  n1 = argv[0];
+  n2 = argv[1];
+
+  if (!is_integer(n1))
+    scheme_wrong_type(name, "integer", 0, argc, argv);
+  if (!is_integer(n2))
+    scheme_wrong_type(name, "integer", 1, argc, argv);
+
+  if (SCHEME_INTP(n2) && !SCHEME_INT_VAL(n2))
+    scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, n2,
+			"%s: undefined for 0", name);
+  if (
+#ifdef MZ_USE_SINGLE_FLOATS
+      (SCHEME_FLTP(n2) && !SCHEME_FLT_VAL(n2)) ||
+#endif
+      (SCHEME_DBLP(n2) && !SCHEME_DBL_VAL(n2)))
+    scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, n2,
+			"%s: undefined for 0.0", name);
+
+  if (SCHEME_INTP(n1) && SCHEME_INTP(n2)) {
+    long a, b, na, nb, v;
+    int neg1, neg2;
+
+    a = SCHEME_INT_VAL(n1);
+    b = SCHEME_INT_VAL(n2);
+    na =  (a < 0) ? -a : a;
+    nb =  (b < 0) ? -b : b;
+
+    v = na % nb;
+
+    if (v) {
+      if (first_sign) {
+	if (a < 0)
+	  v = -v;
+      } else {
+	neg1 = (a < 0);
+	neg2 = (b < 0);
+	
+	if (neg1 != neg2)
+	  v = nb - v;
+	
+	if (neg2)
+	  v = -v;
+      }
+    }
+
+    return scheme_make_integer(v);
+  }
+
+  if (SCHEME_FLOATP(n1) || SCHEME_FLOATP(n2)) {
+    double a, b, na, nb, v;
+#ifdef MZ_USE_SINGLE_FLOATS
+    int was_single = !(SCHEME_DBLP(n1) || SCHEME_DBLP(n2));
+#endif
+
+    if (SCHEME_INTP(n1))
+      a = SCHEME_INT_VAL(n1);
+#ifdef MZ_USE_SINGLE_FLOATS
+    else if (SCHEME_FLTP(n1))
+      a = SCHEME_FLT_VAL(n1);
+#endif
+    else if (SCHEME_DBLP(n1))
+      a = SCHEME_DBL_VAL(n1);
+    else
+      a = scheme_bignum_to_double(n1);
+
+    if (SCHEME_INTP(n2))
+      b = SCHEME_INT_VAL(n2);
+#ifdef MZ_USE_SINGLE_FLOATS
+    else if (SCHEME_FLTP(n2))
+      b = SCHEME_FLT_VAL(n2);
+#endif
+    else if (SCHEME_DBLP(n2))
+      b = SCHEME_DBL_VAL(n2);
+    else
+      b = scheme_bignum_to_double(n2);
+    na =  (a < 0) ? -a : a;
+    nb =  (b < 0) ? -b : b;
+
+    if (MZ_IS_POS_INFINITY(nb))
+      v = na;
+    else if (MZ_IS_POS_INFINITY(na))
+      return zerod;
+    else
+      v = fmod(na, nb);
+
+    if (v) {
+      if (first_sign) {
+	if (a < 0)
+	  v = -v;
+      } else {
+	int neg1, neg2;
+	
+	neg1 = (a < 0);
+	neg2 = (b < 0);
+	
+	if (neg1 != neg2)
+	  v = nb - v;
+	
+	if (neg2)
+	  v = -v;
+      }
+    }
+
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (was_single)
+      return scheme_make_float((float)v);
+#endif
+
+    return scheme_make_double(v);
+  }
+
+  n1 = to_bignum(n1);
+  n2 = to_bignum(n2);
+
+  scheme_bignum_divide(n1, n2, NULL, &r, 1);
+
+  negate = 0;
+
+  if (!SCHEME_INTP(r) || SCHEME_INT_VAL(r)) {
+    /* Easier if we can assume 'r' is positive: */
+    if (SCHEME_INTP(r)) {
+      if (SCHEME_INT_VAL(r) < 0)
+	r = scheme_make_integer(-SCHEME_INT_VAL(r));
+    } else if (!SCHEME_BIGPOS(r))
+      r = scheme_bignum_negate(r);
+
+    if (first_sign) {
+      if (!SCHEME_BIGPOS(n1))
+	negate = 1;
+    } else {
+      int neg1, neg2;
+      
+      neg1 = !SCHEME_BIGPOS(n1);
+      neg2 = !SCHEME_BIGPOS(n2);
+      
+      if (neg1 != neg2) {
+	if (neg2)
+	  r = scheme_bin_plus(n2, r);
+	else
+	  r = scheme_bin_minus(n2, r);
+      } else if (neg2)
+	negate = 1;
+    }
+    
+    if (negate) {
+      if (SCHEME_INTP(r))
+	r = scheme_make_integer(-SCHEME_INT_VAL(r));
+      else
+	r = scheme_bignum_negate(r);
+    }
+  }
+
+  return r;
+}
+
+static Scheme_Object *
+rem_prim (int argc, Scheme_Object *argv[])
+{
+  return rem_mod(argc, argv, "remainder", 1);
+}
+
+Scheme_Object *
+scheme_modulo(int argc, Scheme_Object *argv[])
+{
+  return rem_mod(argc, argv, "modulo", 0);
+}
+
+static Scheme_Object *bin_lcm (Scheme_Object *n1, Scheme_Object *n2);
+
+GEN_NARY_OP(gcd, "gcd", scheme_bin_gcd, 0, is_integer, "integer")
+GEN_NARY_OP(lcm, "lcm", bin_lcm, 1, is_integer, "integer")
+
+Scheme_Object *
+scheme_bin_gcd (const Scheme_Object *n1, const Scheme_Object *n2)
+{
+  if (SCHEME_INTP(n1) && SCHEME_INTP(n2)) {
+    long i1, i2, a, b, r;
+
+    i1 = SCHEME_INT_VAL(n1);
+    i2 = SCHEME_INT_VAL(n2);
+    if (i1 < 0)
+      i1 = -i1;
+    if (i2 < 0)
+      i2 = -i2;
+    if (i1 > i2) {
+      a = i1;
+      b = i2;
+    } else {
+      a = i2;
+      b = i1;
+    }
+    
+    r = 1;
+    while ((b > 0) && (r > 0))
+      {
+	r = a % b;
+	a = b;
+	b = r;
+      }
+    return (scheme_make_integer(a));
+  } else if (SCHEME_FLOATP(n1) || SCHEME_FLOATP(n2)) {
+    double i1, i2, a, b, r;
+#ifdef MZ_USE_SINGLE_FLOATS
+    int was_single = !(SCHEME_DBLP(n1) || SCHEME_DBLP(n2));
+#endif
+
+    if (SCHEME_INTP(n1))
+      i1 = SCHEME_INT_VAL(n1);
+    else if (SCHEME_FLOATP(n1))
+      i1 = SCHEME_FLOAT_VAL(n1);
+    else
+      i1 = scheme_bignum_to_double(n1);
+
+    if (SCHEME_INTP(n2))
+      i2 = SCHEME_INT_VAL(n2);
+    else if (SCHEME_FLOATP(n2))
+      i2 = SCHEME_FLOAT_VAL(n2);
+    else
+      i2 = scheme_bignum_to_double(n2);
+
+    if (i1 < 0)
+      i1 = -1;
+    if (i2 < 0)
+      i2 = -i2;
+    if (i1 > i2) {
+      a = i1;
+      b = i2;
+    } else {
+      a = i2;
+      b = i1;
+    }
+
+    if (MZ_IS_NAN(a) || MZ_IS_NAN(b))
+      return nan_object;
+    if (MZ_IS_POS_INFINITY(a))
+      return scheme_make_double(b);
+    
+    r = 1;
+    while ((b > 0) && (r > 0)) {
+      r = fmod(a, b);
+      a = b;
+      b = r;
+    }
+
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (was_single)
+      return scheme_make_float((float)a);
+#endif
+
+    return scheme_make_double(a);
+  } else {
+    Scheme_Object *r;
+
+    n1 = to_bignum(n1);
+    n2 = to_bignum(n2);
+
+    if (!SCHEME_BIGPOS(n1))
+      n1 = scheme_bignum_negate(n1);
+    if (!SCHEME_BIGPOS(n2))
+      n2 = scheme_bignum_negate(n2);
+
+    if (scheme_bignum_lt(n1, n2)) {
+      const Scheme_Object *save;
+      save = n1;
+      n1 = n2;
+      n2 = save;
+    }
+    
+    r = scheme_make_bignum(1);
+    while (SCHEME_BIGLEN(n2) && SCHEME_BIGLEN(r)) {
+      scheme_bignum_divide(n1, n2, NULL, &r, 0);
+      n1 = n2;
+      n2 = r;
+    }
+
+    return scheme_bignum_normalize(n1);
+  }
+}
+
+static Scheme_Object *
+bin_lcm (Scheme_Object *n1, Scheme_Object *n2)
+{
+  Scheme_Object *d, *ret;
+
+  d = scheme_bin_gcd(n1, n2);
+  
+  if (NOT_SAME_OBJ(zero_p(1, &d), scheme_false))
+    return d;
+
+  ret = scheme_bin_mult(n1, scheme_bin_quotient(n2, d));
+
+  return abs_prim(1, &ret);
+}
+
+static Scheme_Object *
+floor_prim (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return o;
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return scheme_make_float(floor(SCHEME_FLT_VAL(o)));
+#endif
+  if (t == scheme_double_type)
+    return scheme_make_double(floor(SCHEME_DBL_VAL(o)));
+  if (t == scheme_bignum_type)
+    return o;
+  if (t == scheme_rational_type)
+    return scheme_rational_floor(o);
+
+  NEED_REAL(floor);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+ceiling (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return o;
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return scheme_make_float(ceil(SCHEME_FLT_VAL(o)));
+#endif
+  if (t == scheme_double_type)
+    return scheme_make_double(ceil(SCHEME_DBL_VAL(o)));
+  if (t == scheme_bignum_type)
+    return o;
+  if (t == scheme_rational_type)
+    return scheme_rational_ceiling(o);
+
+  NEED_REAL(ceiling);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+sch_truncate (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return o;
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type) {
+    float v = SCHEME_FLT_VAL(o);
+    if (v > 0)
+      v = floor(v);
+    else
+      v = ceil(v);
+    return scheme_make_float(v);
+  }
+#endif
+  if (t == scheme_double_type) {
+    double v = SCHEME_DBL_VAL(o);
+    if (v > 0)
+      v = floor(v);
+    else
+      v = ceil(v);
+    return scheme_make_double(v);
+  }
+  if (t == scheme_bignum_type)
+    return o;
+  if (t == scheme_rational_type)
+    return scheme_rational_truncate(o);
+
+  NEED_REAL(truncate);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+round (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return o;
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type) {
+    double d = SCHEME_FLT_VAL(o);
+    double i, frac;
+    int invert;
+
+    if (d < 0) {
+      d = -d;
+      invert = 1;
+    } else
+      invert = 0;
+
+    frac = modf(d, &i);
+    if (frac < 0.5)
+      d = i;
+    else if (frac > 0.5)
+      d = i + 1;
+    else if (fmod(i, 2.0))
+	d = i + 1;
+    else
+      d = i;
+
+    if (invert)
+      d = -d;
+
+    return scheme_make_float((float)d);
+  }
+#endif
+  if (t == scheme_double_type) {
+    double d = SCHEME_DBL_VAL(o);
+    double i, frac;
+    int invert;
+
+    if (d < 0) {
+      d = -d;
+      invert = 1;
+    } else
+      invert = 0;
+
+    frac = modf(d, &i);
+    if (frac < 0.5)
+      d = i;
+    else if (frac > 0.5)
+      d = i + 1;
+    else if (fmod(i, 2.0))
+	d = i + 1;
+    else
+      d = i;
+
+    if (invert)
+      d = -d;
+
+    return scheme_make_double(d);
+  }
+  if (t == scheme_bignum_type)
+    return o;
+  if (t == scheme_rational_type)
+    return scheme_rational_round(o);
+
+  NEED_REAL(round);
+
+  return scheme_void;
+}
+
+#ifdef MZ_USE_SINGLE_FLOATS
+static float TO_FLOAT_VAL(const Scheme_Object *n)
+{
+  Scheme_Type t;
+
+  if (SCHEME_INTP(n))
+    return (float)SCHEME_INT_VAL(n);
+  t = _SCHEME_TYPE(n);
+  if (t == scheme_float_type)
+    return SCHEME_FLT_VAL(n);
+  if (t == scheme_double_type)
+    return SCHEME_DBL_VAL(n);
+  if (t == scheme_bignum_type)
+    return scheme_bignum_to_float(n);
+  if (t == scheme_rational_type)
+    return scheme_rational_to_float(n);
+  return 0.0f;
+}
+
+static Scheme_Object *TO_FLOAT(const Scheme_Object *n)
+{
+  if (SCHEME_FLTP(n))
+    return (Scheme_Object *)n;
+  else
+    return scheme_make_float(TO_FLOAT_VAL(n));
+}
+#endif
+
+#define TO_DOUBLE_VAL scheme_get_val_as_double
+
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+
+double TO_DOUBLE_VAL(const Scheme_Object *n)
+{
+  Scheme_Type t;
+
+  if (SCHEME_INTP(n))
+    return (double)SCHEME_INT_VAL(n);
+  t = _SCHEME_TYPE(n);
+  if (t == scheme_float_type)
+    return SCHEME_FLT_VAL(n);
+  if (t == scheme_double_type)
+    return SCHEME_DBL_VAL(n);
+  if (t == scheme_bignum_type)
+    return scheme_bignum_to_double(n);
+  if (t == scheme_rational_type)
+    return scheme_rational_to_double(n);
+}
+static Scheme_Object *TO_DOUBLE(const Scheme_Object *n)
+{
+  if (SCHEME_DBLP(n))
+    return n;
+  else
+    return scheme_make_double(TO_DOUBLE_VAL(n));
+}
+
+#else
+
+static Scheme_Object *TO_DOUBLE(const Scheme_Object *n)
+{
+  return exact_to_inexact(1, (Scheme_Object **)&n);
+}
+double TO_DOUBLE_VAL(const Scheme_Object *n)
+{
+  return SCHEME_DBL_VAL(TO_DOUBLE(n));
+}
+
+#endif
+
+static Scheme_Object *get_frac(char *name, int low_p, 
+			       int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *n = argv[0];
+
+  if (SCHEME_FLOATP(n)) {
+    double d = SCHEME_FLOAT_VAL(n);
+    
+    if (MZ_IS_NAN(d))
+      return n;
+    else if (MZ_IS_POS_INFINITY(d))
+      return low_p ? scheme_make_double(1.0) : n;
+    else if (MZ_IS_NEG_INFINITY(d))
+      return low_p ? scheme_make_double(1.0) : n;
+
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (SCHEME_FLTP(n))
+      n = scheme_rational_from_float((float)d);
+    else
+#endif
+      n = scheme_rational_from_double(d);
+  }
+  
+  if (SCHEME_INTP(n) || SCHEME_BIGNUMP(n))
+    n = low_p ? scheme_make_integer(1) : n;
+  else if (SCHEME_RATIONALP(n)) {
+    if (low_p)
+      n = scheme_rational_denominator(n);
+    else
+      n = scheme_rational_numerator(n);
+  } else {
+    scheme_wrong_type(name, REAL_NUMBER_STR, 0, argc, argv);
+    return scheme_void;   
+  }
+  
+  if (SCHEME_DBLP(argv[0]))
+    return TO_DOUBLE(n);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (SCHEME_FLTP(argv[0]))
+    return TO_FLOAT(n);
+#endif
+  else
+    return n;
+}
+
+static Scheme_Object *numerator(int argc, Scheme_Object *argv[])
+{
+  return get_frac("numerator", 0, argc, argv);
+}
+
+static Scheme_Object *denominator(int argc, Scheme_Object *argv[])
+{
+  return get_frac("denominator", 1, argc, argv);
+}
+
+static Scheme_Object *complex_exp(Scheme_Object *c)
+{
+  Scheme_Object *r = scheme_complex_real_part(c);
+  Scheme_Object *i = scheme_complex_imaginary_part(c);
+  Scheme_Object *cos_a, *sin_a;
+
+  r = exp_prim(1, &r);
+  cos_a = cos_prim(1, &i);
+  sin_a = sin_prim(1, &i);
+
+  return scheme_bin_mult(r, scheme_bin_plus(cos_a, scheme_bin_mult(sin_a, plus_i)));
+}
+
+static Scheme_Object *complex_log(Scheme_Object *c)
+{
+  Scheme_Object *m, *theta;
+
+  m = magnitude(1, &c);
+  theta = angle(1, &c);
+
+  return scheme_bin_plus(log_prim(1, &m), scheme_bin_mult(plus_i, theta));
+}
+
+static Scheme_Object *complex_sin(Scheme_Object *c)
+{
+  Scheme_Object *i_c;
+
+  i_c = scheme_bin_mult(c, plus_i);
+  
+  return scheme_bin_div(scheme_bin_minus(complex_exp(i_c),
+					 complex_exp(scheme_bin_minus(zeroi, i_c))),
+			scheme_bin_mult(scheme_make_integer(2), plus_i));
+}
+
+static Scheme_Object *complex_cos(Scheme_Object *c)
+{
+  Scheme_Object *i_c;
+
+  i_c = scheme_bin_mult(c, plus_i);
+  
+  return scheme_bin_div(scheme_bin_plus(complex_exp(i_c),
+					complex_exp(scheme_bin_minus(zeroi, i_c))),
+			scheme_make_integer(2));
+}
+
+static Scheme_Object *complex_tan(Scheme_Object *c)
+{
+  return scheme_bin_div(complex_sin(c), complex_cos(c));
+}
+
+static Scheme_Object *complex_asin(Scheme_Object *c)
+{
+  Scheme_Object *one_minus_c_sq, *sqrt_1_minus_c_sq;
+
+  one_minus_c_sq = scheme_bin_minus(scheme_make_integer(1),
+				    scheme_bin_mult(c, c));
+  sqrt_1_minus_c_sq = scheme_sqrt(1, &one_minus_c_sq);
+
+  return scheme_bin_mult(minus_i,
+			 complex_log(scheme_bin_plus(scheme_bin_mult(c, plus_i), 
+						     sqrt_1_minus_c_sq)));
+}
+
+static Scheme_Object *complex_acos(Scheme_Object *c)
+{
+  Scheme_Object *one_minus_c_sq, *sqrt_1_minus_c_sq;
+
+  one_minus_c_sq = scheme_bin_minus(scheme_make_integer(1),
+				    scheme_bin_mult(c, c));
+  sqrt_1_minus_c_sq = scheme_sqrt(1, &one_minus_c_sq);
+
+  return scheme_bin_mult(minus_i,
+			 complex_log(scheme_bin_plus(c,
+						     scheme_bin_mult(plus_i,
+								     sqrt_1_minus_c_sq))));
+}
+
+static Scheme_Object *complex_atan(Scheme_Object *c)
+{
+  if (scheme_complex_eq(c, plus_i) || scheme_complex_eq(c, minus_i))
+    return minus_inf_object;
+
+  return scheme_bin_mult(plus_i,
+			 scheme_bin_mult(scheme_make_double(0.5),
+					 complex_log(scheme_bin_div(scheme_bin_plus(plus_i, c),
+								    scheme_bin_plus(plus_i, 
+										    scheme_bin_minus(zeroi, c))))));
+}
+
+#define NEVER_RESORT_TO_COMPLEX(d) 0
+#define NEGATIVE_USES_COMPLEX(d) d < 0.0
+#define OVER_ONE_MAG_USES_COMPLEX(d) (d > 1.0) || (d < -1.0)
+
+GEN_UNARY_OP(exp_prim, exp, exp, inf_object, zerod, nan_object, complex_exp, NEVER_RESORT_TO_COMPLEX)
+GEN_UNARY_OP(log_prim, log, log, inf_object, nan_object, nan_object, complex_log, NEGATIVE_USES_COMPLEX)
+GEN_UNARY_OP(sin_prim, sin, sin, nan_object, nan_object, nan_object, complex_sin, NEVER_RESORT_TO_COMPLEX)
+GEN_UNARY_OP(cos_prim, cos, cos, nan_object, nan_object, nan_object, complex_cos, NEVER_RESORT_TO_COMPLEX)
+GEN_UNARY_OP(tan_prim, tan, tan, nan_object, nan_object, nan_object, complex_tan, NEVER_RESORT_TO_COMPLEX)
+GEN_UNARY_OP(asin_prim, asin, asin, nan_object, nan_object, nan_object, complex_asin, OVER_ONE_MAG_USES_COMPLEX)
+GEN_UNARY_OP(acos_prim, acos, acos, nan_object, nan_object, nan_object, complex_acos, OVER_ONE_MAG_USES_COMPLEX)
+
+static Scheme_Object *
+atan_prim (int argc, Scheme_Object *argv[])
+{
+  double v;
+  Scheme_Object *n1;
+#ifdef MZ_USE_SINGLE_FLOATS
+  int single = 0;
+#endif
+
+  n1 = argv[0];
+
+  if (SCHEME_INTP(n1))
+    v = SCHEME_INT_VAL(n1);
+#ifdef MZ_USE_SINGLE_FLOATS
+  else if (SCHEME_FLTP(n1)) {
+    v = SCHEME_FLT_VAL(n1);
+    single++;
+  }
+#endif
+  else if (SCHEME_DBLP(n1))
+    v = SCHEME_DBL_VAL(n1);
+  else if (SCHEME_BIGNUMP(n1))
+    v = scheme_bignum_to_double(n1);
+  else if (SCHEME_RATIONALP(n1))
+    v = scheme_rational_to_double(n1);
+  else if (SCHEME_COMPLEXP(n1)) {
+    if (argc > 1) {
+      scheme_wrong_type("atan (with two arguments)", REAL_NUMBER_STR, 0, argc, argv);
+      return NULL;
+    } else
+      return complex_atan(n1);
+  } else {
+    NEED_NUMBER(atan);
+    v = 0.0;
+  }
+
+  if (argc == 2) {
+    double v2;
+    Scheme_Object *n2;
+    
+    n2 = argv[1];
+
+    if (SCHEME_INTP(n2))
+      v2 = SCHEME_INT_VAL(n2);
+#ifdef MZ_USE_SINGLE_FLOATS
+    else if (SCHEME_FLTP(n2)) {
+      v2 = SCHEME_FLT_VAL(n2);
+      single++;
+    }
+#endif
+    else if (SCHEME_DBLP(n2))
+      v2 = SCHEME_DBL_VAL(n2);
+    else if (SCHEME_BIGNUMP(n2))
+      v2 = scheme_bignum_to_double(n2);
+    else {
+      scheme_wrong_type("atan", REAL_NUMBER_STR, 1, argc, argv);
+      return NULL;
+    }
+
+    if (!v && !v2) {
+#ifdef MZ_USE_SINGLE_FLOATS
+      if (single == 2)
+	return zerof;
+#endif      
+      return zerod;
+    }
+
+    v = atan2(v, v2);
+  } else {
+    v = atan(v);
+#ifdef MZ_USE_SINGLE_FLOATS
+    single++;
+#endif    
+  }
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (single == 2)
+    return scheme_make_float((float)v);
+#endif
+
+  return scheme_make_double(v);
+}
+
+Scheme_Object *scheme_sqrt (int argc, Scheme_Object *argv[])
+{
+  int imaginary = 0;
+  Scheme_Object *n;
+  
+  n = argv[0];
+
+  if (SCHEME_COMPLEXP(n))
+    return scheme_complex_sqrt(n);
+
+  if (!SCHEME_REALP(n))
+    scheme_wrong_type("sqrt", "number", 0, argc, argv);
+
+  if (SCHEME_TRUEP(negative_p(1, &n))) {
+    n = scheme_bin_minus(zeroi, n);
+    imaginary = 1;
+  }
+
+  if (SCHEME_INTP(n) || SCHEME_BIGNUMP(n))
+    n = scheme_integer_sqrt(n);
+#ifdef MZ_USE_SINGLE_FLOATS
+  else if (SCHEME_FLTP(n))
+    n = scheme_make_float((float)sqrt(SCHEME_FLT_VAL(n)));
+#endif
+  else if (SCHEME_DBLP(n))
+    n = scheme_make_double(sqrt(SCHEME_DBL_VAL(n)));
+  else if (SCHEME_RATIONALP(n))
+    n = scheme_rational_sqrt(n);
+
+  if (imaginary)
+    return scheme_make_complex(SCHEME_DBLP(n) 
+			       ? scheme_make_double(0)
+			       : zeroi, n);
+  else
+    return n;
+}
+
+static Scheme_Object *fixnum_expt(int x, int y)
+{
+  if ((x == 2) && (y <= MAX_SHIFT_TRY))
+    return scheme_make_integer(1 << y);
+  else
+    return scheme_bignum_power(scheme_make_bignum(x), scheme_make_bignum(y));
+}
+
+#ifdef POW_HANDLES_INF_CORRECTLY
+# define F_EXPT(x, y) scheme_make_double(pow((double)x, (double)y))
+# define FS_EXPT(x, y) scheme_make_float((float)pow((double)x, (double)y))
+#else
+static double sch_pow(double x, double y)
+{
+  if (MZ_IS_POS_INFINITY(y)) {
+    return scheme_infinity_val;
+  } else if (MZ_IS_NEG_INFINITY(y)) {
+    return 0.0;
+  } else if (MZ_IS_POS_INFINITY(x)) {
+    if (!y)
+      return 1.0;
+    else
+      return scheme_infinity_val;
+  } else if (MZ_IS_NEG_INFINITY(x)) {
+    if (!y)
+      return 1.0;
+    else {
+      if (fmod(y, 2.0) == 1.0)
+	return scheme_minus_infinity_val;
+      else
+	return scheme_infinity_val;
+    }
+  } else
+    return pow(x, y);
+}
+# define F_EXPT(x, y) scheme_make_double(sch_pow((double)x, (double)y))
+# define FS_EXPT(x, y) scheme_make_float(sch_pow((double)x, (double)y))
+#endif
+
+static GEN_BIN_OP(bin_expt, "expt", fixnum_expt, F_EXPT, FS_EXPT, scheme_bignum_power, scheme_rational_power, scheme_complex_power, NAN_RETURNS_NAN, NAN_RETURNS_SNAN)
+
+Scheme_Object *
+scheme_expt(int argc, Scheme_Object *argv[])
+{
+  int invert = 0;
+  Scheme_Object *e = argv[1], *r, *n;
+
+  n = argv[0];
+
+  if (!SCHEME_NUMBERP(n))
+    scheme_wrong_type("expt", "number", 0, argc, argv);
+
+  if (!SCHEME_FLOATP(n)) {
+    if (SCHEME_INTP(e) || SCHEME_BIGNUMP(e)) {
+      if (SCHEME_FALSEP(positive_p(1, &e))) {
+	e = scheme_bin_minus(zeroi, e);
+	invert = 1;
+      }
+    }
+  }
+
+  r = bin_expt(argv[0], e);
+  if (invert)
+    r = scheme_bin_div(scheme_make_integer(1), r);
+
+  return r;
+}
+
+
+static Scheme_Object *make_rectangular (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *a, *b;
+  int af, bf;
+
+  a = argv[0];
+  b = argv[1];
+  if (!SCHEME_REALP(a))
+    scheme_wrong_type("make-rectangular", REAL_NUMBER_STR, 0, argc, argv);
+  if (!SCHEME_REALP(b))
+    scheme_wrong_type("make-rectangular", REAL_NUMBER_STR, 1, argc, argv);
+
+  af = SCHEME_FLOATP(a);
+  bf = SCHEME_FLOATP(b);
+
+  if (af && !bf)
+    b = exact_to_inexact(1, &b);
+  if (bf && !af)
+    a = exact_to_inexact(1, &a);
+  
+  if (af)
+    if (MZ_IS_NAN(SCHEME_FLOAT_VAL(a))) {
+#ifdef MZ_USE_SINGLE_FLOATS
+      if (SCHEME_FLTP(a) && (!bf || SCHEME_FLTP(b)))
+	return single_nan_object;
+#endif
+      return nan_object;
+    }
+  if (bf)
+    if (MZ_IS_NAN(SCHEME_FLOAT_VAL(b))) {
+#ifdef MZ_USE_SINGLE_FLOATS
+      if (SCHEME_FLTP(b) && (!af || SCHEME_FLTP(a)))
+	return single_nan_object;
+#endif
+      return nan_object;
+    }
+
+  return scheme_make_complex(a, b);
+}
+
+static Scheme_Object *make_polar (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *a, *b;
+  double va, vb;
+#ifdef MZ_USE_SINGLE_FLOATS
+  int single = 0;
+#endif
+
+  a = argv[0];
+  b = argv[1];
+  if (!SCHEME_REALP(a))
+    scheme_wrong_type("make-polar", REAL_NUMBER_STR, 0, argc, argv);
+  if (!SCHEME_REALP(b))
+    scheme_wrong_type("make-polar", REAL_NUMBER_STR, 1, argc, argv);
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (SCHEME_FLTP(b)) {
+    vb = SCHEME_FLT_VAL(b);
+    single++;
+  } else
+#endif
+    { 
+      if (!SCHEME_DBLP(b))
+	vb = TO_DOUBLE_VAL(b);
+      else
+	vb = SCHEME_DBL_VAL(b);
+    }
+
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (SCHEME_FLTP(a)) {
+    va = SCHEME_FLT_VAL(a);
+    single++;
+  } else
+#endif
+    {
+      if (!SCHEME_DBLP(a))
+	va = TO_DOUBLE_VAL(a);
+      else
+	va = SCHEME_DBL_VAL(a);
+    }
+
+  if (MZ_IS_NAN(va) || MZ_IS_NAN(vb)) {
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (single == 2)
+      return single_nan_object;
+#endif
+    return nan_object;
+  }
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (single == 2) {
+    return scheme_make_complex(scheme_make_float(va * cos(vb)),
+			       scheme_make_float(va * sin(vb)));
+  }
+#endif
+
+  return scheme_make_complex(scheme_make_double(va * cos(vb)),
+			     scheme_make_double(va * sin(vb)));
+}
+
+static Scheme_Object *real_part (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (!SCHEME_NUMBERP(o))
+    scheme_wrong_type("imag-part", "number", 0, argc, argv);
+
+  if (SCHEME_COMPLEXP(o))
+    return scheme_complex_real_part(o);
+  else
+    return argv[0];
+}
+
+static Scheme_Object *imag_part (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (!SCHEME_NUMBERP(o))
+    scheme_wrong_type("imag-part", "number", 0, argc, argv);
+
+  if (SCHEME_COMPLEXP(o))
+    return scheme_complex_imaginary_part(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (SCHEME_FLTP(o)) {
+    if (MZ_IS_NAN(SCHEME_FLT_VAL(o)))
+      return single_nan_object;
+    return zerof;
+  }
+#endif
+  if (SCHEME_DBLP(o)) {
+    if (MZ_IS_NAN(SCHEME_DBL_VAL(o)))
+      return nan_object;
+    return zerod;
+  }
+   
+  return zeroi;
+}
+
+static Scheme_Object *magnitude(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (!SCHEME_NUMBERP(o))
+    scheme_wrong_type("magnitude", "number", 0, argc, argv);
+
+  if (SCHEME_COMPLEXP(o)) {
+    Scheme_Object *r = scheme_complex_real_part(o);
+    Scheme_Object *i = scheme_complex_imaginary_part(o);
+    Scheme_Object *m2 = scheme_bin_plus(scheme_bin_mult(r, r),
+					scheme_bin_mult(i, i));
+    
+    return scheme_sqrt(1, &m2);
+  } else
+    return abs_prim(1, argv);
+}
+
+static Scheme_Object *angle (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (!SCHEME_NUMBERP(o))
+    scheme_wrong_type("angle", "number", 0, argc, argv);
+
+  if (SCHEME_COMPLEXP(o)) {
+    Scheme_Object *r = scheme_complex_real_part(o);
+    Scheme_Object *i = scheme_complex_imaginary_part(o);
+
+    return scheme_make_double(atan2(TO_DOUBLE_VAL(i), TO_DOUBLE_VAL(r)));
+  } else {
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (SCHEME_FLTP(o)) {
+      float v = SCHEME_FLT_VAL(o);
+      if (!v)
+	scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, o,
+			 "angle: undefined for 0.0");
+      if (v > 0)
+	return zerof;
+      else
+	return single_scheme_pi;
+    }
+#endif
+    if (SCHEME_DBLP(o)) {
+      double v = SCHEME_DBL_VAL(o);
+      if (!v)
+	scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, o,
+			 "angle: undefined for 0.0");
+      if (v > 0)
+	return zerod;
+      else
+	return scheme_pi;
+    } else if (o == zeroi) {
+      scheme_raise_exn(MZEXN_APPLICATION_MATH_ZERO, o,
+		       "angle: undefined for 0");
+      return scheme_void;
+    } else if (SCHEME_TRUEP(positive_p(1, argv)))
+      return zeroi;
+    else
+      return scheme_pi;
+  }
+}
+
+static Scheme_Object *
+exact_to_inexact (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return scheme_make_double(SCHEME_INT_VAL(o));
+  t = _SCHEME_TYPE(o);
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (t == scheme_float_type)
+    return o;
+#endif
+  if (t == scheme_double_type)
+    return o;
+  if (t == scheme_bignum_type) {
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+    return scheme_make_float(scheme_bignum_to_float(o));
+#else
+    return scheme_make_double(scheme_bignum_to_double(o));
+#endif
+  }
+  if (t == scheme_rational_type) {
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+    return scheme_make_float(scheme_rational_to_float(o));
+#else
+    return scheme_make_double(scheme_rational_to_double(o));
+#endif
+  }
+  if (t == scheme_complex_type) {
+    Scheme_Object *realpart, *imaginarypart;
+
+    realpart = scheme_complex_real_part(o);
+    imaginarypart = scheme_complex_imaginary_part(o);
+
+    realpart = exact_to_inexact(1, &realpart);
+    imaginarypart = exact_to_inexact(1, &imaginarypart);
+
+    return scheme_make_complex(realpart, imaginarypart);
+  }
+
+  NEED_NUMBER(exact->inexact);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+inexact_to_exact (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  Scheme_Type t;
+
+  if (SCHEME_INTP(o))
+    return o;
+  t = _SCHEME_TYPE(o);
+  if (t == scheme_double_type
+#ifdef MZ_USE_SINGLE_FLOATS
+      || t == scheme_float_type
+#endif
+      ) {
+    double d = SCHEME_FLOAT_VAL(o);
+
+    /* Try simple case: */
+    Scheme_Object *i = scheme_make_integer((int)d);
+    if ((double)SCHEME_INT_VAL(i) == d) {
+# ifdef NAN_EQUALS_ANYTHING
+      if (!MZ_IS_NAN(d))
+#endif
+	return i;
+    }
+
+    return scheme_rational_from_double(d);
+  }
+  if (t == scheme_bignum_type)
+    return o;
+  if (t == scheme_rational_type)
+    return o;
+  if (t == scheme_complex_type) {
+    Scheme_Object *realpart, *imaginarypart;
+
+    realpart = scheme_complex_real_part(o);
+    imaginarypart = scheme_complex_imaginary_part(o);
+
+    realpart = inexact_to_exact(1, &realpart);
+    imaginarypart = inexact_to_exact(1, &imaginarypart);
+
+    return scheme_make_complex(realpart, imaginarypart);
+  }
+
+  NEED_NUMBER(inexact->exact);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+number_to_string (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  long radix;
+
+  if (!SCHEME_NUMBERP(o))
+    scheme_wrong_type("number->string", "number", 0, argc, argv);
+  
+  if (argc == 2) {
+    if (!SCHEME_INTP(argv[1]))
+      radix = 0;
+    else
+      radix = SCHEME_INT_VAL(argv[1]);
+
+    if ((radix != 2) && (radix != 8) && (radix != 10)  && (radix != 16)) {
+      scheme_wrong_type("number->string", "2, 8, 10, or 16", 1, argc, argv);
+      return NULL;
+    }
+    
+    radix = SCHEME_INT_VAL(argv[1]);
+  } else
+    radix = 10;
+
+  return scheme_make_string_without_copying(scheme_number_to_string(radix, o));
+}
+
+static char *double_to_string (double d)
+{
+  char buffer[100], *s;
+  int l, i;
+
+  if (MZ_IS_NAN(d))
+    return not_a_number_str;
+  else if (MZ_IS_POS_INFINITY(d))
+    return infinity_str;
+  else if (MZ_IS_NEG_INFINITY(d))
+    return minus_infinity_str;
+
+  sprintf (buffer, "%." INEXACT_PRINT_DIGITS "g", d);
+  l = strlen(buffer);
+  for (i = 0; i < l; i++)
+    if (buffer[i] == '.' || isalpha(buffer[i]))
+      break;
+  if (i == l) {
+    buffer[i] = '.';
+    buffer[i + 1] = '0';
+    buffer[i + 2] = 0;
+    l += 2;
+  }
+  
+  s = (char *)scheme_malloc_atomic(strlen(buffer) + 1);
+  strcpy(s, buffer);
+
+  return s;
+}
+
+char *scheme_number_to_string(int radix, Scheme_Object *obj)
+{
+  char *s;
+
+  if (SCHEME_FLOATP(obj)) {
+    if (radix != 10)
+      scheme_raise_exn(MZEXN_APPLICATION_MATH_RADIX, 
+			  scheme_make_integer(radix),
+			  "number->string: "
+			  "inexact numbers can only be printed in base 10");
+    s = double_to_string(SCHEME_FLOAT_VAL(obj));
+  } else if (SCHEME_RATIONALP(obj)) {
+    Scheme_Object *n, *d;
+    char *ns, *ds;
+    int nlen, dlen;
+
+    n = scheme_rational_numerator(obj);
+    d = scheme_rational_denominator(obj);
+
+    ns = scheme_number_to_string(radix, n);
+    ds = scheme_number_to_string(radix, d);
+
+    nlen = strlen(ns);
+    dlen = strlen(ds);
+
+    s = (char *)scheme_malloc_atomic(nlen + dlen + 2);
+    memcpy(s, ns, nlen);
+    s[nlen] = '/';
+    strcpy(s + nlen + 1, ds);
+  } else if (SCHEME_COMPLEXP(obj)) {
+    Scheme_Object *r, *i;
+    char *rs, *is;
+    int rlen, ilen, offset = 0;
+
+    r = scheme_complex_real_part(obj);
+    i = scheme_complex_imaginary_part(obj);
+
+    rs = scheme_number_to_string(radix, r);
+    is = scheme_number_to_string(radix, i);
+
+    rlen = strlen(rs);
+    ilen = strlen(is);
+    s = (char *)scheme_malloc_atomic(rlen + ilen + 3);
+    memcpy(s, rs, rlen);
+    if (SCHEME_TRUEP(positive_p(1, &i))) {
+      offset = 1;
+      s[rlen] = '+';
+    }
+    memcpy(s + rlen + offset, is, ilen);
+    s[rlen + offset + ilen] = 'i';
+    s[rlen + offset + ilen + 1] = 0;
+  } else {
+    if (SCHEME_INTP(obj))
+      obj = scheme_make_bignum(SCHEME_INT_VAL(obj));
+
+    s = scheme_bignum_to_string(obj, radix);
+  }
+
+  return s;
+}
+
+int scheme_check_double(const char *where, double d, const char *dest)
+{
+  if (MZ_IS_POS_INFINITY(d)
+      || MZ_IS_NEG_INFINITY(d)
+      || MZ_IS_NAN(d)) {
+    if (where)
+      scheme_raise_exn(MZEXN_APPLICATION_TYPE,
+		       scheme_make_double(d),
+		       scheme_intern_symbol("small integer"),
+		       "%s: no %s representation for %s",
+		       where, 
+		       dest,
+		       double_to_string(d));
+    return 0;
+  }
+
+  return 1;
+}
+
+#ifdef MZ_USE_SINGLE_FLOATS
+int scheme_check_float(const char *where, float f, const char *dest)
+{
+  return scheme_check_double(where, f, dest);
+}
+#endif
+
+static int double_to_int(const char *where, double d, long *v)
+{
+  if (scheme_check_double(where, d, "small integer")) {
+    if ((d != floor(d))
+	|| (d > 0 && ((double)(long)d) + 1 < d)
+	|| (d < 0 && ((double)(long)d) - 1 > d)) {
+      if (where)
+	scheme_raise_exn(MZEXN_APPLICATION_TYPE,
+			 scheme_make_double(d),
+			 scheme_intern_symbol("small integer"),
+			 "%s: no fixnum representation for %f",
+			 where, d);
+      return 0;
+    }
+
+    *v = (long)d;
+
+    return 1;
+  } else
+    return 0;
+}
+
+long scheme_double_to_int(const char *where, double d)
+{
+  long l;
+
+  double_to_int(where, d, &l);
+  
+  return l;
+}
+
+Scheme_Object *scheme_double_to_integer(const char *where, double d)
+{
+  long l;
+
+  if (d != floor(d))
+    return NULL;
+
+  scheme_check_double(where, d, "integer");
+
+  if (double_to_int(NULL, d, &l))
+    return scheme_make_integer_value(l);
+
+  return scheme_bignum_from_double(d);
+}
+
+static Scheme_Object *
+string_to_number (int argc, Scheme_Object *argv[])
+{
+  long radix;
+  long len;
+  char *str;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->number", "string", 0, argc, argv);
+  if (argc == 2) {
+    if (SCHEME_INTP(argv[1]))
+      radix = SCHEME_INT_VAL(argv[1]);
+    else
+      radix = 0;
+    
+    if ((radix < 2) || (radix > 16)) {
+      scheme_wrong_type("string->number", "exact integer in [2, 16]", 1, argc, argv);
+      return NULL;
+    }
+  } else
+    radix = 10;
+
+  str = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  return scheme_read_number(str, len, 0, 0, radix, 0, NULL, NULL);
+}
+
+#ifdef USE_EXPLICT_FP_FORM_CHECK
+
+/* Fixes Linux problem of 0e...  => non-number (0 with ptr at e...) */
+/* Fixes SunOS problem with numbers like .3e2666666666666 => 0.0 */
+/* Fixes HP/UX problem with numbers like .3e2666666666666 => non-number */
+
+/* Exponent threshold for obvious infinity: */
+#define CHECK_INF_EXP_THRESHOLD 400
+
+double STRTOD(const char *orig_c, char **f)
+{
+  int neg = 0;
+  int found_dot = 0, is_infinity = 0;
+  const char *c = orig_c;
+
+  *f = (char *)c;
+
+  if (*c == '-') {
+    c++;
+    neg = 1;
+  } else if (*c == '+') {
+    c++;
+  }
+
+  if (!isdigit(*c)) {
+    if (*c == '.') {
+      if (!isdigit(c[1]))
+	return 0; /* no digits - bad! */
+    } else
+      return 0; /* no digits - bad! */
+  }
+
+  for (; *c; c++) {
+    int ch = *c;
+
+    if (isdigit(ch)) {
+      /* ok */
+    } else if ((ch == 'e') || (ch == 'E')) {
+      int e = 0;
+
+      c++;
+      if (*c == '-') {
+	c++;
+      } else if (*c == '+') {
+	c++;
+      }
+      if (!isdigit(*c))
+	return 0; /* no digits - bad! */
+
+      for (; *c; c++) {
+	int ch = *c;
+	if (!isdigit(ch))
+	  return 0; /* not a digit - bad! */
+	else {
+	  e = (e * 10) + (ch - '0');
+	  if (e > CHECK_INF_EXP_THRESHOLD)
+	    is_infinity = 1;
+	}
+      }
+
+      break;
+    } else if (ch == '.') {
+      if (found_dot)
+	return 0; /* two dots - bad! */
+      found_dot = 1;
+    } else
+      return 0; /* unknown non-digit - bad! */
+  }
+  
+  *f = (char *)c;
+
+  if (is_infinity) {
+    if (neg)
+      return scheme_minus_infinity_val;
+    else
+      return scheme_infinity_val;
+  }
+
+  /* It's OK if c is ok: */
+  return strtod(orig_c, NULL);
+}
+#else
+#define STRTOD(x, y) strtod(x, y)
+#endif
+
+#ifdef MZ_USE_SINGLE_FLOATS
+static Scheme_Object *CHECK_SINGLE(Scheme_Object *v, int s)
+{
+  if (s && SCHEME_DBLP(v))
+    return scheme_make_float((float)SCHEME_DBL_VAL(v));
+  else
+    return v;
+}
+#else
+# define CHECK_SINGLE(v, s) v
+#endif
+
+Scheme_Object *scheme_read_number(const char *str, long len,
+				  int is_float, 
+				  int is_not_float,
+				  int radix, int radix_set, 
+				  Scheme_Object *complain,
+				  int *div_by_zero)
+{
+  int i, has_decimal, must_parse, has_slash;
+  int report;
+  Scheme_Object *next_complain;
+  int has_hash, has_expt, has_i, has_sign, has_at, saw_digit;
+  Scheme_Object *o;
+  char *ptr;
+  const char *orig;
+#ifdef MZ_USE_SINGLE_FLOATS
+  int single;
+#endif
+
+  if (len < 0)
+    len = strlen(str);
+
+#if 0
+  /* Why would we want this? */
+  while (isspace(*str)) {
+    str++;
+    --len;
+  }
+#endif
+
+  orig = str;
+
+  while (str[0] == '#') {
+    if (str[1] != 'E' && str[1] != 'e' && str[1] != 'I' && str[1] != 'i') {
+      if (radix_set) {
+	if (complain)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad radix specification: %s",
+			   str);
+	else
+	  return scheme_false;
+      }
+      radix_set = 1;
+    } else {
+      if (is_float || is_not_float) {
+	if (complain)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad exactness specification: %s", 
+			   str);
+	else
+	  return scheme_false;
+      }
+    }
+
+    switch (str[1]) {
+    case 'B':
+    case 'b':
+      radix = 2;
+      break;
+    case 'O':
+    case 'o':
+      radix = 8;
+      break;
+    case 'D':
+    case 'd':
+      radix = 10;
+      break;
+    case 'X':
+    case 'x':
+      radix = 16;
+      break;
+    case 'I':
+    case 'i':
+      is_float = 1;
+      break;
+    case 'E':
+    case 'e':
+      is_not_float = 1;
+      break;
+    default:
+      if (complain)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: bad `#' indicator in %s", str);
+      return scheme_false;
+    }
+    str += 2;
+    len -= 2;
+  }
+
+  must_parse = (radix_set || is_float || is_not_float);
+
+  report = complain && must_parse;
+  next_complain = must_parse ? complain : NULL;
+
+  if (!len) {
+    if (report)
+      scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+		       scheme_make_string(str),
+		       "read-number: no digits");
+    return scheme_false;
+  }
+
+  if (len == 6 && (str[0] == '-' || str[0] == '+') && isalpha(str[1])) {
+    char s[7];
+    int i;
+
+    for (i = 0; i < 6; i++) {
+      if (str[i] > 0)
+	s[i] = tolower(str[i]);
+      else
+	s[i] = str[i];
+    }
+    s[i] = 0;
+
+    if (!strcmp(s, infinity_str)) {
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+      return single_inf_object;
+#else
+      return inf_object;
+#endif
+    }
+    else if (!strcmp(s, minus_infinity_str)) {
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+      return single_minus_inf_object;
+#else
+      return minus_inf_object;
+#endif
+    }
+    else if (!strcmp(s, not_a_number_str)
+	     || !strcmp(s, other_not_a_number_str)) {
+#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+      return single_nan_object;
+#else      
+      return nan_object;
+#endif
+    }
+  }
+      
+#define isinexactmark(ch) ((ch == 'e') || (ch == 'E') \
+			   || (ch == 's') || (ch == 'S') \
+			   || (ch == 'f') || (ch == 'F') \
+			   || (ch == 'd') || (ch == 'D') \
+			   || (ch == 'l') || (ch == 'L'))
+
+  has_i = 0;
+  has_at = 0;
+  has_sign = -1;
+  for (i= 0; i < len; i++) {
+    int ch = str[i];
+    if (!ch) {
+      if (report)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: embedded null character: %s", str);
+      return scheme_false;
+    } else if (isinexactmark(ch)) {
+      /* If a sign follows, don't count it */
+      if (str[i+1] == '+' || str[i+1] == '-')
+	i++;
+    } else if ((ch == '+') || (ch == '-')) {
+      if (has_sign > 0) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: too many signs: %s", str);
+	return scheme_false;
+      }
+      has_sign = i;
+    } else if (((ch == 'I') || (ch == 'i')) && (has_sign >= 0)) {
+      if (has_at) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: cannot mix `@' and `i': %s", str);
+	return scheme_false;
+      }
+      if (i + 1 < len) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: `i' must be at the end: %s", str);
+	return scheme_false;
+      }
+      has_i = i;
+    } else if (ch == '@') {
+      if (has_at) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: too many `@'s: %s", str);
+	return scheme_false;
+      }
+      if (!i) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: `@' cannot be at start: %s", str);
+	return scheme_false;
+      }
+      has_at = i;
+      if (has_sign >= 0)
+	has_sign = -1;
+    }
+  }
+
+  if (has_i) {
+    Scheme_Object *n1, *n2;
+    char *first, *second;
+    int fdbz = 0, sdbz = 0;
+
+    if (has_sign) {
+      first = (char *)scheme_malloc_atomic(has_sign + 1);
+      memcpy(first, str, has_sign);
+      first[has_sign] = 0;
+    } else
+      first = NULL;
+
+    if (has_i - has_sign > 1) {
+      second = (char *)scheme_malloc_atomic(has_i - has_sign + 1);
+      memcpy(second, str + has_sign, has_i - has_sign);
+      second[has_i - has_sign] = 0;
+    } else
+      second = NULL;
+
+    if (first)
+      n1 = scheme_read_number(first, has_sign,
+			      is_float, is_not_float,
+			      radix, 1, next_complain,
+			      &fdbz);
+    else
+      n1 = zeroi;
+
+    if (SAME_OBJ(n1, scheme_false) && !fdbz)
+      return scheme_false;
+    else if (SCHEME_FLOATP(n1)) {
+      double d = SCHEME_FLOAT_VAL(n1);
+      if (MZ_IS_NAN(d))
+	return scheme_false;
+    }
+    
+    if (second)
+      n2 = scheme_read_number(second, has_i - has_sign,
+			      is_float, is_not_float,
+			      radix, 1, next_complain,
+			      &sdbz);
+    else if (str[has_sign] == '-')
+      n2 = scheme_make_integer(-1);
+    else
+      n2 = scheme_make_integer(1);
+    
+    if (SAME_OBJ(n2, scheme_false) && !sdbz)
+      return scheme_false;
+    else if (SCHEME_FLOATP(n2)) {
+      double d = SCHEME_FLOAT_VAL(n2);
+      if (MZ_IS_NAN(d))
+	return scheme_false;
+    }
+
+    if (fdbz || sdbz) {
+      if (div_by_zero)
+	*div_by_zero = 1;
+      if (complain)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: divide by zero in %s", str);
+      return scheme_false;
+    }
+
+    if (!is_not_float && (SCHEME_FLOATP(n1) || is_float))
+      n2 = exact_to_inexact(1, &n2);  /* uses default conversion */
+    else if (is_not_float)
+      n2 = inexact_to_exact(1, &n2);
+
+    if (!is_not_float && (SCHEME_FLOATP(n2) || is_float))
+      n1 = exact_to_inexact(1, &n1); /* uses default conversion */
+    else if (is_not_float)
+      n1 = inexact_to_exact(1, &n1);
+
+    return scheme_make_complex(n1, n2);
+  }
+
+  if (has_at) {
+    Scheme_Object *n1, *n2;
+    double d1, d2, r1, r2;
+    char *first;
+    const char *second;
+    int fdbz = 0, sdbz = 0;
+
+    first = (char *)scheme_malloc_atomic(has_at + 1);
+    memcpy(first, str, has_at);
+    first[has_at] = 0;
+
+    second = str + has_at + 1;
+
+    n2 = scheme_read_number(second, len - has_at - 1,
+			    1, 0,
+			    radix, 1, next_complain,
+			    &fdbz);
+
+    if (!fdbz) {
+      if (SCHEME_FALSEP(n2))
+	return scheme_false;
+
+      d2 = SCHEME_FLOAT_VAL(n2);
+      
+      if (MZ_IS_NAN(d2))
+	return scheme_false;
+
+      /* Special case: angle is zero => real number */
+      if (!d2)
+	return scheme_read_number(first, has_at,
+				  is_float, is_not_float,
+				  radix, 1, next_complain,
+				  div_by_zero);
+      
+      n1 = scheme_read_number(first, has_at, 
+			      1, 0,
+			      radix, 1, next_complain,
+			      &sdbz);
+    } else {
+      n1 = NULL;
+      d2 = 0;
+    }
+
+    if (fdbz || sdbz) {
+      if (div_by_zero)
+	*div_by_zero = 1;
+      if (complain)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: divide by zero in %s", str);
+      return scheme_false;
+    }
+
+    if (SCHEME_FALSEP(n1))
+      return scheme_false;
+
+    d1 = SCHEME_FLOAT_VAL(n1);
+
+    if (MZ_IS_NAN(d1))
+      return scheme_false;
+
+    r1 = d1 * cos(d2);
+    r2 = d1 * sin(d2);
+
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (SCHEME_FLTP(n1) && SCHEME_FLTP(n2))
+      return scheme_make_complex(scheme_make_float((float)r1),
+				 scheme_make_float((float)r2));
+#endif
+
+    return scheme_make_complex(scheme_make_double(r1),
+			       scheme_make_double(r2));
+  }
+
+  has_decimal = has_slash = has_hash = has_expt = saw_digit = 0;
+  for (i= 0; i < len; i++) {
+    int ch = str[i];
+    if (ch == '.') {
+#if 0
+      if (radix != 10) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: decimal point implies base 10: %s",
+			   str);
+	return scheme_false;
+      }
+#endif
+      if (has_decimal) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: multiple decimal points: %s", str);
+	return scheme_false;
+      }
+      if (has_slash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: decimal points and fractions "
+			   "cannot be mixed: %s", str);
+	return scheme_false;
+      }
+      has_decimal = 1;
+    } else if (isinexactmark(ch)) {
+      if (radix <= 10) {
+	if (!i) {
+	  if (report)
+	    scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			     scheme_make_string(str),
+			     "read-number: cannot begin with `%c'", ch);
+	  return scheme_false;
+	}
+	has_expt = i;
+      }
+      break;
+    } else if (ch == '/') {
+      if (!i) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: cannot have slash at start: %s", str);
+	return scheme_false;
+      }
+      if (has_slash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: multiple slashes: %s", str);
+	return scheme_false;
+      }
+      if (has_decimal) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: decimal points and fractions "
+			   "cannot be mixed: %s", str);
+	return scheme_false;
+      }
+      if (has_hash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: misplaced hash: %s", str);
+	return scheme_false;
+      }
+      has_slash = i;
+    } else if ((ch == '-') || (ch == '+')) {
+      if (has_slash || has_decimal || has_hash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: misplaced sign: %s", str);
+	return scheme_false;
+      }
+    } else if (ch == '#') {
+      if (has_slash || /* has_decimal || */ (radix > 10) || !saw_digit) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: misplaced hash: %s", str);
+	return scheme_false;
+      }
+      has_hash = 1;
+    } else if (!isdigit(ch)) {
+      if (has_decimal) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad decimal number: %s", str);
+	return scheme_false;
+      }
+      if (has_hash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: misplaced hash: %s", str);
+	return scheme_false;
+      }
+      break;
+    } else {
+      saw_digit = 1;
+      if (has_hash) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: misplaced hash: %s", str);
+	return scheme_false;
+      }
+    }
+  }
+
+#if 0
+  /* Floting-point in non-base-10? */
+  if (has_decimal && radix != 10) {
+    if (complain)
+      scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+		       scheme_make_string(str),
+		       "read-number: decimal implies base 10 in %s", 
+		       str);
+    return scheme_false;
+  }
+#endif
+
+#ifdef MZ_USE_SINGLE_FLOATS
+  if (has_expt && str[has_expt]) {
+    single = str[has_expt];
+    single = ((single == 'f') || (single == 'F')
+	      || (single == 's') || (single == 'S'));
+  } else {
+# ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+    single = 1;
+# else
+    single = 0;
+# endif
+  }
+#endif
+
+
+  /* When possible, use the standard floating-point parser */
+  if (!is_not_float && !has_slash && !has_hash && (radix == 10) 
+      && (has_decimal || has_expt)) {
+    double d;
+    const char *strcpy;
+    if (has_expt && (str[has_expt] != 'e' && str[has_expt] != 'E')) {
+      char *str2 = (char *)scheme_malloc_atomic(len + 1);
+      memcpy(str2, str, len + 1);
+      str2[has_expt] = 'e';
+      strcpy = str2;
+    } else
+      strcpy = str;
+    d = STRTOD(strcpy, &ptr);
+    if ((ptr - strcpy) < len) {
+      if (report)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: bad decimal number %s", str);
+      return scheme_false;
+    } 
+
+#ifdef MZ_USE_SINGLE_FLOATS
+    if (single)
+      return scheme_make_float((float)d);
+#endif
+    return scheme_make_double(d);
+  }
+
+  if (has_decimal || has_expt || has_hash) {
+    Scheme_Object *mantissa, *exponent, *power, *n;
+    Scheme_Object *args[2];
+
+    if (has_expt) {
+      exponent = scheme_read_bignum(str + has_expt + 1, radix);
+      if (SCHEME_FALSEP(exponent)) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad exponent: %s", str);
+	return scheme_false;
+      }
+    } else
+      exponent = zeroi;
+
+    if (!has_expt)
+      has_expt = len;
+
+    if (!has_hash && (radix == 10) && (!has_decimal || !is_not_float)) {
+      char *s;
+      int dbz;
+
+      s = (char *)scheme_malloc_atomic(has_expt + 1);
+      memcpy(s, str, has_expt);
+      s[has_expt] = 0;
+      
+      mantissa = scheme_read_number(s, has_expt, 0, 0,
+				    radix, 1, next_complain,
+				    &dbz);
+      if (SCHEME_FALSEP(mantissa)) {
+	if (dbz) {
+	  if (div_by_zero)
+	    *div_by_zero = 1;
+	  if (complain)
+	    scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			     scheme_make_string(str),
+			     "read-number: divide by zero in %s", str);
+	}
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad number %s", str);
+	return scheme_false;
+      }
+    } else {
+      int extra_power = 0, dcp = 0, num_ok;
+      char *digits;
+
+      digits = (char *)scheme_malloc_atomic(has_expt + 1);
+
+      i = 0;
+      if (str[i] == '+' || str[i] == '-')
+	digits[dcp++] = str[i++];
+
+      for (; isdigit(str[i]); i++)
+	digits[dcp++] = str[i];
+
+      if (str[i] == '#') {
+	for (; str[i] == '#'; i++)
+	  digits[dcp++] = '0';
+	num_ok = 0;
+      } else
+	num_ok = 1;
+	
+      if (str[i] == '.') {
+	i++;
+	if (num_ok)
+	  for (; isdigit(str[i]); i++) {
+	    digits[dcp++] = str[i];
+	    extra_power++;
+	  }
+
+	for (; str[i] == '#'; i++) {
+	  digits[dcp++] = '0';  
+	  extra_power++;
+	}
+      }
+
+      if ((str[i] && (!has_expt || i != has_expt))
+	  || !dcp || (dcp == 1 && !isdigit(digits[0]))) {
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad decimal number %s", str);
+	return scheme_false;
+      }
+
+      digits[dcp] = 0;
+      mantissa = scheme_read_bignum(digits, radix);
+      if (SCHEME_FALSEP(mantissa)) {
+	/* can get here with bad radix */
+	if (report)
+	  scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			   scheme_make_string(str),
+			   "read-number: bad number %s", digits);
+	return scheme_false;
+      }
+
+      if (extra_power)
+	exponent = scheme_bin_minus(exponent, scheme_make_integer(extra_power));
+    }
+
+    
+    args[0] = scheme_make_integer(radix);
+    args[1] = exponent;
+    power = scheme_expt(2, args);
+
+    n = scheme_bin_mult(mantissa, power);
+
+    if (!is_not_float)
+      return CHECK_SINGLE(TO_DOUBLE(n), single);
+    else
+      return CHECK_SINGLE(n, single);
+  }
+  
+  if (has_slash) {
+    Scheme_Object *n1, *n2;
+    char *first;
+
+    first = (char *)scheme_malloc_atomic(has_slash + 1);
+    memcpy(first, str, has_slash);
+    first[has_slash] = 0;
+
+    n1 = scheme_read_number(first, has_slash, 0, 0,
+			    radix, 1, next_complain,
+			    div_by_zero);
+    if (SAME_OBJ(n1, scheme_false))
+      return scheme_false;
+
+    n2 = scheme_read_number(str + has_slash + 1, len - has_slash - 1,
+			    0, 0, 
+			    radix, 1, next_complain,
+			    div_by_zero);
+
+    if (SAME_OBJ(n2, scheme_false))
+      return scheme_false;
+
+    if (SCHEME_TRUEP(zero_p(1, &n2))) {
+      if (complain)
+	scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+			 scheme_make_string(str),
+			 "read-number: divide by zero in %s", str);
+      if (div_by_zero)
+	*div_by_zero = 1;
+      return scheme_false;
+    }
+
+    n1 = scheme_bin_div(n1, n2);
+
+    if (is_not_float)
+      n1 = inexact_to_exact(1, &n1);
+    else if (is_float)
+      n1 = TO_DOUBLE(n1);
+
+    return CHECK_SINGLE(n1, single);
+  }
+
+  o = scheme_read_bignum(str, radix);
+  if (SAME_OBJ(o, scheme_false)) {
+    if (report)
+      scheme_raise_exn(MZEXN_READ_NUMBER, complain, 
+		       scheme_make_string(str),
+		       "read-number: bad number %s", str);
+  } else if (is_float)
+    return CHECK_SINGLE(TO_DOUBLE(o), single);
+
+  return o;
+}
+
+static Scheme_Object *
+bitwise_not(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (SCHEME_INTP(o)) {
+    long a = SCHEME_INT_VAL(o);
+
+    a = ~a;
+    return scheme_make_integer(a);
+  } else if (_SCHEME_TYPE(o) == scheme_bignum_type)
+    return scheme_bignum_not(o);
+   
+  scheme_wrong_type("bitwise-not", "exact integer", 0, argc, argv);
+  return scheme_void;
+}
+
+static Scheme_Object *
+bitwise_shift(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *v, *so;
+  long shift;
+
+  v = argv[0];
+  
+  if (!SCHEME_EXACT_INTEGERP(v)) {
+    scheme_wrong_type("arithmetic-shift", "exact integer", 1, argc, argv);
+    return NULL;
+  }
+  so = argv[1];
+  if (!SCHEME_INTP(so)) {
+    if (SCHEME_BIGNUMP(so)) {
+      if (!SCHEME_BIGPOS(so)) {
+	if (SCHEME_TRUEP(negative_p(1, &v)))
+	  return scheme_make_integer(-1);
+	else
+	  return scheme_make_integer(0);
+      } else
+	scheme_raise_out_of_memory("arithmetic-shift", NULL);
+    } else
+      scheme_wrong_type("arithmetic-shift", "exact integer", 1, argc, argv);
+    return NULL;
+  }
+  
+  shift = SCHEME_INT_VAL(so);
+  if (!shift)
+    return v;
+
+  if (SCHEME_INTP(v)) {
+    long i = SCHEME_INT_VAL(v);
+
+    if (!i)
+      return v;
+
+    if (i > 0) {
+      if (shift < 0) {
+	int shft = -shift;
+	if (shft <= MAX_SHIFT_EVER) {
+	  i = i >> shft;
+	  return scheme_make_integer(i);
+	} else
+	  return scheme_make_integer(0);
+      } else if (shift <= MAX_SHIFT_TRY) {
+	long n;
+	
+	n = i << shift;
+	if ((n > 0) && (SCHEME_INT_VAL(scheme_make_integer(n)) >> shift == i))
+	  return scheme_make_integer(n);
+      }
+    }
+
+    v = scheme_make_bignum(i);
+  }
+
+  return scheme_bignum_shift(v, shift);
+}
+
+static Scheme_Object *
+random_seed(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+
+  if (!SCHEME_INTP(o))
+    scheme_wrong_type("random-seed", "fixnum", 0, argc, argv);
+
+#ifdef RAND_NOT_RANDOM
+  srand(SCHEME_INT_VAL(o));
+#else
+  srandom(SCHEME_INT_VAL(o));
+#endif
+
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+sch_random(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *o = argv[0];
+  long v, i;
+
+  if (!SCHEME_INTP(o))
+    scheme_wrong_type("random", "non-zero fixnum", 0, argc, argv);
+
+  i = SCHEME_INT_VAL(o);
+  if (!i)
+    scheme_wrong_type("random", "non-zero fixnum", 0, argc, argv);
+    
+
+#ifdef RAND_NOT_RANDOM
+  v = rand() % i;
+#else
+  v = random();
+  if (v < 0)
+    v = -v;
+  v = v % i;
+#endif
+
+  return scheme_make_integer(v);
+}
+
diff --git a/src/mzscheme/src/nummacs.h b/src/mzscheme/src/nummacs.h
new file mode 100644
index 0000000..d35ba20
--- /dev/null
+++ b/src/mzscheme/src/nummacs.h
@@ -0,0 +1,516 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#ifdef MZ_USE_SINGLE_FLOATS
+# define FLOATWRAP(x) x
+# ifdef USE_SINGLE_FLOATS_AS_DEFAULT
+#  define D_FLOATWRAP(x) /* empty */
+#  define S_FLOATWRAP(x) x
+# else
+#  define D_FLOATWRAP(x) x
+#  define S_FLOATWRAP(x) /* empty */
+# endif
+#else
+# define FLOATWRAP(x) /* empty */
+# define D_FLOATWRAP(x) x
+# define S_FLOATWRAP(x) /* empty */
+#endif
+
+#define GEN_BIN_COMP_PROT(name) \
+static int name (Scheme_Object *n1, Scheme_Object *n2)
+
+#define GEN_NARY_COMP(name, scheme_name, bin_name, TYPEP, type) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  int i; \
+  Scheme_Object *p; \
+  p = argv[0]; \
+  if (argc == 1) if (!TYPEP(p)) \
+   scheme_wrong_type(scheme_name, type, 0, argc, argv); \
+  for (i = 1; i < argc; i++) {\
+    Scheme_Object *o = argv[i]; \
+    if (!TYPEP(o)) { \
+      scheme_wrong_type(scheme_name, type, i, argc, argv); \
+      return NULL; \
+    } \
+    if (!bin_name(p, o)) { \
+        for (i++; i < argc; i++) \
+          if (!TYPEP(argv[i])) \
+           scheme_wrong_type(scheme_name, type, i, argc, argv); \
+        return scheme_false; \
+    } \
+    p = o; \
+  } \
+  return scheme_true; \
+}
+
+#define GEN_BIN_PROT(name) \
+static Scheme_Object *name (const Scheme_Object *n1, const Scheme_Object *n2)
+
+/* This macro is used to implement most all binary math and comparison functions (!): */
+#define GEN_BIN_THING(rettype, name, scheme_name, \
+                      iop, fop, fsop, bn_op, rop, cxop, \
+                      wrap, combineinf, \
+                      waybigf, swaybigf, waysmallf, swaysmallf, \
+                      waybigs, swaybigs, waysmalls, swaysmalls, \
+                      combinezero, firstzero, sfirstzero, secondzero, ssecondzero, \
+                      nanchk, snanchk, \
+                      complexwrap, numbertype) \
+rettype \
+name (const Scheme_Object *n1, const Scheme_Object *n2) \
+{ \
+  Small_Bignum sb; \
+  Small_Rational sr; \
+  Scheme_Type t1, t2; \
+  if (SCHEME_INTP(n1)) \
+    { \
+      if (SCHEME_INTP(n2)) \
+	return iop(SCHEME_INT_VAL(n1), SCHEME_INT_VAL(n2)); \
+      t2 = _SCHEME_TYPE(n2); \
+      FLOATWRAP( \
+      if (t2 == scheme_float_type) { \
+        float d = SCHEME_FLT_VAL(n2); \
+        snanchk(d); \
+        return fsop(SCHEME_INT_VAL(n1), d); \
+      } \
+      ) \
+      if (t2 == scheme_double_type) { \
+        double d = SCHEME_DBL_VAL(n2); \
+        nanchk(d); \
+        return fop(SCHEME_INT_VAL(n1), d); \
+      } \
+      if (t2 == scheme_bignum_type) \
+        return bn_op((scheme_make_small_bignum(SCHEME_INT_VAL(n1), \
+					       &sb)), \
+		     (n2)); \
+       if (t2 == scheme_rational_type) \
+        return rop((scheme_make_small_rational(SCHEME_INT_VAL(n1), \
+						      &sr)), \
+		   (n2)); \
+      complexwrap( \
+      if (t2 == scheme_complex_type) { \
+        Small_Complex sc; \
+	return cxop((scheme_make_small_complex(n1, &sc)), \
+		    (n2)); \
+      } \
+      ) \
+      WRONG_TYPE(scheme_name, numbertype, n2); \
+    } \
+  else { \
+   t1 = _SCHEME_TYPE(n1); \
+   FLOATWRAP( \
+   if (t1 == scheme_float_type) \
+    { \
+      float d1 = SCHEME_FLT_VAL(n1); \
+      if (SCHEME_INTP(n2)) { \
+        snanchk(d1); \
+        return fsop(d1, SCHEME_INT_VAL(n2)); \
+      } \
+      t2 = _SCHEME_TYPE(n2); \
+      if (t2 == scheme_float_type) { \
+        float d2 = SCHEME_FLT_VAL(n2); \
+        snanchk(d1); \
+        snanchk(d2); \
+        return fsop(d1, d2); \
+      } \
+      if (t2 == scheme_double_type) { \
+        double d2 = SCHEME_DBL_VAL(n2); \
+        nanchk(d1); \
+        nanchk(d2); \
+        return fop(d1, d2); \
+      } \
+      if (t2 == scheme_bignum_type) { \
+        snanchk(d1); \
+        wrap(if (MZ_IS_POS_INFINITY(d1)) return combineinf(swaybigf, n2);) \
+        wrap(if (MZ_IS_NEG_INFINITY(d1)) return combineinf(swaysmallf, n2);) \
+        return fsop(d1, scheme_bignum_to_float(n2)); \
+      } \
+       if (t2 == scheme_rational_type) { \
+        snanchk(d1); \
+        wrap(if (MZ_IS_POS_INFINITY(d1)) return combineinf(swaybigf, n2);) \
+        wrap(if (MZ_IS_NEG_INFINITY(d1)) return combineinf(swaysmallf, n2);) \
+        wrap(if (!d1) return combinezero(sfirstzero, n2);) \
+	return fop(d1, scheme_rational_to_float(n2)); \
+      } \
+      complexwrap( \
+      if (t2 == scheme_complex_type) { \
+        Small_Complex sc; \
+        snanchk(d1); \
+	return cxop((scheme_make_small_complex(n1, &sc)), \
+		    (n2)); \
+      } \
+      )\
+      WRONG_TYPE(scheme_name, numbertype, n2); \
+    } else \
+   ) \
+   if (t1 == scheme_double_type) \
+    { \
+      double d1 = SCHEME_DBL_VAL(n1); \
+      if (SCHEME_INTP(n2)) { \
+        nanchk(d1); \
+        return fop(d1, SCHEME_INT_VAL(n2)); \
+      } \
+      t2 = _SCHEME_TYPE(n2); \
+      FLOATWRAP( \
+      if (t2 == scheme_float_type) { \
+        double d2 = SCHEME_FLT_VAL(n2); \
+        nanchk(d1); \
+        nanchk(d2); \
+        return fop(d1, d2); \
+      } \
+      ) \
+      if (t2 == scheme_double_type) { \
+        double d2 = SCHEME_DBL_VAL(n2); \
+        nanchk(d1); \
+        nanchk(d2); \
+        return fop(d1, d2); \
+      } \
+      if (t2 == scheme_bignum_type) { \
+        nanchk(d1); \
+        wrap(if (MZ_IS_POS_INFINITY(d1)) return combineinf(waybigf, n2);) \
+        wrap(if (MZ_IS_NEG_INFINITY(d1)) return combineinf(waysmallf, n2);) \
+        return fop(d1, scheme_bignum_to_double(n2)); \
+      } \
+       if (t2 == scheme_rational_type) { \
+        nanchk(d1); \
+        wrap(if (MZ_IS_POS_INFINITY(d1)) return combineinf(waybigf, n2);) \
+        wrap(if (MZ_IS_NEG_INFINITY(d1)) return combineinf(waysmallf, n2);) \
+        wrap(if (!d1) return combinezero(firstzero, n2);) \
+	return fop(d1, scheme_rational_to_double(n2)); \
+      } \
+      complexwrap( \
+      if (t2 == scheme_complex_type) { \
+        Small_Complex sc; \
+        nanchk(d1); \
+	return cxop((scheme_make_small_complex(n1, &sc)), \
+		    (n2)); \
+      } \
+      )\
+      WRONG_TYPE(scheme_name, numbertype, n2); \
+    } \
+  else if (t1 == scheme_bignum_type) \
+    { \
+       if (SCHEME_INTP(n2)) \
+	 return bn_op((n1), \
+		      (scheme_make_small_bignum(SCHEME_INT_VAL(n2), &sb))); \
+      t2 = _SCHEME_TYPE(n2); \
+      FLOATWRAP( \
+      if (t2 == scheme_float_type) { \
+         float d2; \
+         d2 = SCHEME_FLT_VAL(n2); \
+         snanchk(d2); \
+         wrap(if (MZ_IS_POS_INFINITY(d2)) return combineinf(swaysmalls, n1);) \
+         wrap(if (MZ_IS_NEG_INFINITY(d2)) return combineinf(swaybigs, n1);) \
+	 return fsop(scheme_bignum_to_float(n1), d2); \
+      } \
+      ) \
+      if (t2 == scheme_double_type) { \
+         double d2; \
+         d2 = SCHEME_DBL_VAL(n2); \
+         nanchk(d2); \
+         wrap(if (MZ_IS_POS_INFINITY(d2)) return combineinf(waysmalls, n1);) \
+         wrap(if (MZ_IS_NEG_INFINITY(d2)) return combineinf(waybigs, n1);) \
+	 return fop(scheme_bignum_to_double(n1), d2); \
+       } \
+       if (t2 == scheme_bignum_type) \
+         return bn_op((n1), (n2)); \
+       if (t2 == scheme_rational_type) \
+	 return rop((scheme_integer_to_rational(n1)), \
+		    (n2)); \
+       complexwrap( \
+       if (t2 == scheme_complex_type) { \
+         Small_Complex sc; \
+	 return cxop((scheme_make_small_complex(n1, &sc)), \
+		     (n2)); \
+       } \
+       )\
+       WRONG_TYPE(scheme_name, numbertype, n2); \
+    } \
+  else if (t1 == scheme_rational_type) \
+    { \
+       if (SCHEME_INTP(n2)) \
+	 return rop((n1), \
+		    (scheme_make_small_rational(SCHEME_INT_VAL(n2), \
+						       &sr))); \
+      t2 = _SCHEME_TYPE(n2); \
+      FLOATWRAP( \
+      if (t2 == scheme_float_type) { \
+         float d2; \
+         d2 = SCHEME_FLT_VAL(n2); \
+         snanchk(d2); \
+         wrap(if (MZ_IS_POS_INFINITY(d2)) return combineinf(swaysmalls, n1);) \
+         wrap(if (MZ_IS_NEG_INFINITY(d2)) return combineinf(swaybigs, n1);) \
+         wrap(if (!d2) return combinezero(ssecondzero, n1);) \
+	 return fop(scheme_rational_to_float(n1), d2); \
+       } \
+       ) \
+       if (t2 == scheme_double_type) { \
+         double d2; \
+         d2 = SCHEME_DBL_VAL(n2); \
+         nanchk(d2); \
+         wrap(if (MZ_IS_POS_INFINITY(d2)) return combineinf(waysmalls, n1);) \
+         wrap(if (MZ_IS_NEG_INFINITY(d2)) return combineinf(waybigs, n1);) \
+         wrap(if (!d2) return combinezero(secondzero, n1);) \
+	 return fop(scheme_rational_to_double(n1), d2); \
+       } \
+       if (t2 == scheme_bignum_type) \
+         return rop((n1), \
+		    (scheme_integer_to_rational(n2))); \
+       if (t2 == scheme_rational_type) \
+	 return rop((n1), (n2)); \
+       complexwrap( \
+       if (t2 == scheme_complex_type) { \
+         Small_Complex sc; \
+	 return cxop((scheme_make_small_complex(n1, &sc)), (n2)); \
+       } \
+       )\
+       WRONG_TYPE(scheme_name, numbertype, n2); \
+    } \
+  complexwrap( \
+  else if (t1 == scheme_complex_type) \
+    { \
+       Small_Complex sc; \
+       if (SCHEME_INTP(n2)) \
+	 return cxop((n1), \
+		     (scheme_make_small_complex(n2, &sc))); \
+       t2 = _SCHEME_TYPE(n2); \
+       FLOATWRAP( \
+       if (t2 == scheme_float_type) { \
+         snanchk(SCHEME_FLT_VAL(n2)); \
+	 return cxop((n1), \
+		     (scheme_make_small_complex(n2, &sc))); \
+       } \
+       ) \
+       if (t2 == scheme_double_type) { \
+         nanchk(SCHEME_DBL_VAL(n2)); \
+	 return cxop((n1), \
+		     (scheme_make_small_complex(n2, &sc))); \
+       } \
+       if (t2 == scheme_bignum_type) \
+         return cxop((n1), \
+		     (scheme_make_small_complex(n2, &sc))); \
+       if (t2 == scheme_rational_type) \
+         return cxop((n1), \
+		     (scheme_make_small_complex(n2, &sc))); \
+       if (t2 == scheme_complex_type) \
+	 return cxop((n1), (n2)); \
+       WRONG_TYPE(scheme_name, numbertype, n2); \
+    } \
+  ) \
+  else \
+       WRONG_TYPE(scheme_name, numbertype, n1); \
+  } \
+  return 0; \
+}
+
+#define GEN_IDENT(x) x
+#define GEN_OMIT(x) 
+#define GEN_FIRST_ONLY(x, y) x
+#define GEN_APPLY(x, y) x(y)
+#define GEN_SCHEME_BOOL_APPLY(x, y) SCHEME_TRUEP(x(1, (Scheme_Object **)&y))
+
+#define GEN_SAME_INF(x) ((SCHEME_TRUEP(positive_p(1, (Scheme_Object **)&x))) ? inf_object : minus_inf_object)
+#define GEN_OPP_INF(x) ((SCHEME_FALSEP(positive_p(1, (Scheme_Object **)&x))) ? inf_object : minus_inf_object)
+#define GEN_MAKE_ZERO(x) zerod
+
+#define GEN_SAME_SINF(x) ((SCHEME_TRUEP(positive_p(1, (Scheme_Object **)&x))) ? single_inf_object : single_minus_inf_object)
+#define GEN_OPP_SINF(x) ((SCHEME_FALSEP(positive_p(1, (Scheme_Object **)&x))) ? single_inf_object : single_minus_inf_object)
+#define GEN_MAKE_SZERO(x) zerof
+
+#define NO_NAN_CHECK(x) /* empty */
+#define NAN_RETURNS_NAN(x) if (MZ_IS_NAN(x)) return nan_object
+#define NAN_RETURNS_SNAN(x) if (MZ_IS_NAN(x)) return single_nan_object
+
+#ifdef NAN_EQUALS_ANYTHING
+# define NAN_CHECK_0_IF_WEIRD(x) if (MZ_IS_NAN(x)) return 0
+# define NAN_CHECK_NAN_IF_WEIRD(x) if (MZ_IS_NAN(x)) return nan_object
+# define SNAN_CHECK_NAN_IF_WEIRD(x) if (MZ_IS_NAN(x)) return single_nan_object
+#else
+# define NAN_CHECK_0_IF_WEIRD(x) /* empty */
+# define NAN_CHECK_NAN_IF_WEIRD(x) /* empty */
+# define SNAN_CHECK_NAN_IF_WEIRD(x) /* empty */
+#endif
+
+#define GEN_BIN_OP(name, scheme_name, iop, fop, fsop, bn_op, rop, cxop, nanckop, snanckop) \
+  GEN_BIN_THING(Scheme_Object *, name, scheme_name, \
+                iop, fop, fsop, bn_op, rop, cxop, \
+                GEN_OMIT, GEN_FIRST_ONLY, \
+                0, 0, 0, 0, \
+                0, 0, 0, 0, \
+                GEN_SCHEME_BOOL_APPLY, badfunc, badfunc, badfunc, badfunc, \
+                nanckop, snanckop, \
+                GEN_IDENT, "number")
+
+#define GEN_BIN_DIV_OP(name, scheme_name, iop, fop, fsop, bn_op, rop, cxop) \
+  GEN_BIN_THING(Scheme_Object *, name, scheme_name, \
+                iop, fop, fsop, bn_op, rop, cxop, \
+                GEN_IDENT, GEN_APPLY, \
+                GEN_SAME_INF, GEN_SAME_SINF, GEN_OPP_INF, GEN_OPP_SINF, \
+                GEN_MAKE_ZERO, GEN_MAKE_SZERO, GEN_MAKE_ZERO, GEN_MAKE_SZERO, \
+                GEN_APPLY, GEN_MAKE_ZERO, GEN_MAKE_SZERO, GEN_SAME_INF, GEN_SAME_SINF, \
+                NAN_CHECK_NAN_IF_WEIRD, SNAN_CHECK_NAN_IF_WEIRD, \
+                GEN_IDENT, "number")
+
+#define GEN_BIN_COMP(name, scheme_name, ifop, bn_op, rop, cxop, waybig, waysmall, firstzero, secondzero, complexwrap, numbertype) \
+ GEN_BIN_THING(int, name, scheme_name, \
+               ifop, ifop, ifop, bn_op, rop, cxop, \
+               GEN_IDENT, GEN_FIRST_ONLY, \
+               waybig, waybig, waysmall, waysmall, \
+               waybig, waybig, waysmall, waysmall, \
+               GEN_SCHEME_BOOL_APPLY, firstzero, firstzero, secondzero, secondzero, \
+               NAN_CHECK_0_IF_WEIRD, NAN_CHECK_0_IF_WEIRD, \
+               complexwrap, numbertype)
+
+#define GEN_BIN_INT_OP(name, scheme_name, op, bigop) \
+static Scheme_Object * \
+name (const Scheme_Object *n1, const Scheme_Object *n2) \
+{ \
+  Small_Bignum sb; \
+  if (SCHEME_INTP(n1)){ \
+    if (SCHEME_INTP(n2)) { \
+      long a, b; \
+      a = SCHEME_INT_VAL(n1); \
+      b = SCHEME_INT_VAL(n2); \
+      return scheme_make_integer(a op b); \
+    } else if (SCHEME_BIGNUMP(n2)) \
+      return bigop(scheme_make_small_bignum(SCHEME_INT_VAL(n1), &sb), n2); \
+  } else if (SCHEME_BIGNUMP(n1)) { \
+    if (SCHEME_INTP(n2)) \
+      return bigop(n1, scheme_make_small_bignum(SCHEME_INT_VAL(n2), &sb)); \
+    if (SCHEME_BIGNUMP(n2)) \
+      return bigop(n1, n2); \
+  } else { \
+    WRONG_TYPE(scheme_name, "exact integer", n1); \
+    return scheme_void; \
+  } \
+ \
+  WRONG_TYPE(scheme_name, "exact integer", n2); \
+  return scheme_void; \
+}
+
+#define GEN_NARY_OP(name, scheme_name, bin_name, ident, TYPEP, type) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  Scheme_Object *ret; \
+  int i; \
+  if (!argc) return scheme_make_integer(ident); \
+  ret = argv[0]; \
+  if (!TYPEP(ret)) { scheme_wrong_type(scheme_name, type, 0, argc, argv); return NULL; } \
+  if (argc == 2) { \
+    Scheme_Object *b; \
+    b = argv[1]; \
+    if (!TYPEP(b)) { scheme_wrong_type(scheme_name, type, 1, argc, argv); return NULL; } \
+    return bin_name(ret, b); \
+  } \
+  for (i = 1 ; i<argc ; ++i ) { \
+    Scheme_Object *o; \
+    o = argv[i]; \
+    if (!TYPEP(o)) { scheme_wrong_type(scheme_name, type, i, argc, argv); return NULL; } \
+    ret = bin_name (ret, o); \
+  } \
+  return (ret); \
+}
+
+#define GEN_TWOARY_OP(name, scheme_name, bin_name, TYPEP, type) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  Scheme_Object *ret; \
+  int i; \
+  if (!TYPEP(argv[0])) \
+    scheme_wrong_type(scheme_name, type, 0, argc, argv); \
+  if (argc == 1) return argv[0]; \
+  if (argc == 2) { \
+    if (!TYPEP(argv[1])) \
+      scheme_wrong_type(scheme_name, type, 1, argc, argv); \
+    return bin_name(argv[0], argv[1]); \
+  } \
+  ret = argv[0]; \
+  for ( i=1 ; i<argc ; ++i ) { \
+    if (!TYPEP(argv[i])) \
+      scheme_wrong_type(scheme_name, type, i, argc, argv); \
+    ret = bin_name (ret, argv[i]); \
+  } \
+  return ret; \
+}
+
+#define GEN_UNARY_OP(name, scheme_name, c_name, inf_val, neginf_val, nan_val, complex_fun, USE_COMPLEX) \
+static Scheme_Object * \
+name (int argc, Scheme_Object *argv[]) \
+{ \
+  Scheme_Type t; \
+  double d; \
+  FLOATWRAP( \
+  D_FLOATWRAP( int is_single = 0; ) \
+  S_FLOATWRAP( int is_double = 0; ) \
+  ) \
+  Scheme_Object *o = argv[0]; \
+  if (SCHEME_INTP(o)) \
+    d = SCHEME_INT_VAL(o); \
+  else { \
+   t = _SCHEME_TYPE(o); \
+   FLOATWRAP( \
+   if (t == scheme_float_type) { \
+     D_FLOATWRAP( is_single = 1; ) \
+     d = SCHEME_FLT_VAL(o); \
+   } else ) \
+   if (t == scheme_double_type) { \
+     S_FLOATWRAP( is_double = 1; ) \
+     d = SCHEME_DBL_VAL(o); \
+   } else if (t == scheme_bignum_type) { \
+     d = scheme_bignum_to_double(o); \
+   } else if (t == scheme_rational_type) { \
+     d = scheme_rational_to_double(o); \
+   } else if (t == scheme_complex_type) \
+     return complex_fun(o); \
+   else { \
+     scheme_wrong_type(#scheme_name, "number", 0, argc, argv); \
+     return NULL; \
+    } \
+  } \
+  if (MZ_IS_NAN(d)) return nan_val; \
+  if (MZ_IS_POS_INFINITY(d)) return inf_val; \
+  if (MZ_IS_NEG_INFINITY(d)) return neginf_val; \
+  if (USE_COMPLEX(d)) { \
+      Small_Complex sc; \
+      Scheme_Object *o; \
+      FLOATWRAP( \
+      D_FLOATWRAP( if (is_single) ) \
+      S_FLOATWRAP( if (!is_double) ) \
+      FLOATWRAP(    o = scheme_make_float((float)d); \
+        else ) \
+      ) \
+      o = scheme_make_double(d); \
+      return complex_fun(scheme_make_small_complex(o, &sc)); \
+  } \
+  d = c_name(d); \
+  FLOATWRAP( \
+  D_FLOATWRAP( if (is_single) ) \
+  S_FLOATWRAP( if (!is_double) ) \
+    FLOATWRAP(    return scheme_make_float((float)d); ) \
+  ) \
+  return scheme_make_double(d); \
+}
+
diff --git a/src/mzscheme/src/object.c b/src/mzscheme/src/object.c
new file mode 100644
index 0000000..4db1c13
--- /dev/null
+++ b/src/mzscheme/src/object.c
@@ -0,0 +1,3669 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+#include "schrunst.h"
+
+#ifndef NO_OBJECT_SYSTEM
+
+/* For testing handling primitive classes: */
+#define ADD_TEST_PRIM_OBJ 0
+
+#include <memory.h>
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+/* Extra leading slot space needed for Scheme images of C++ objects: */
+#define EXTRA_PRIM_SLOTS 2
+
+#define INTERFACE "interface"
+
+#define CLASS_STAR "class*"
+#define CLASS_STAR_W_NAMES "class*/names"
+#define CREATE_OBJECT "make-object"
+
+#define IVAR "ivar"
+#define UQ_IVAR "uq-ivar"
+
+#define MAKE_GENERIC "make-generic"
+#define UQ_MAKE_GENERIC "uq-make-generic"
+
+#define IS_CLASS "class?"
+#define IS_INTERFACE "interface?"
+#define IS_OBJECT "object?"
+#define IS_A "is-a?"
+#define SUBCLASS "subclass?"
+#define IMPLEMENTATION "implementation?"
+#define INTERFACE_EXTENSION "interface-extension?"
+#define IVAR_IN_CLASS "ivar-in-class?"
+#define OBJECT_CLASS "object-class"
+
+#define SUPER_INIT "super-init"
+
+static Scheme_Object *seq_symbol;
+static Scheme_Object *pub_symbol, *pri_symbol;
+static Scheme_Object *inh_symbol;
+static Scheme_Object *ren_symbol;
+
+static Scheme_Object *class_star_symbol;
+static Scheme_Object *interface_symbol;
+
+#define cons scheme_make_pair
+  
+enum {
+  varPUBLIC,
+  varPRIVATE,
+  varINHERIT,
+  varRENAME,
+  varNOTHING,
+  varINPUT
+};
+
+enum {
+  slot_TYPE_IVAR,
+  slot_TYPE_CMETHOD
+};
+
+enum {
+  generic_KIND_CLASS,
+  generic_KIND_INTERFACE
+};
+
+#define ispublic(c) (((c)->vartype == varPUBLIC))
+#define isreftype(vt) ((vt == varRENAME) || (vt == varINHERIT))
+#define isref(c) isreftype((c)->vartype)
+#define isprivref(c) ((c)->vartype == varRENAME)
+#define isprivate(c) ((c)->vartype == varPRIVATE)
+#define isinput(c) ((c)->vartype == varINPUT)
+
+#define IVAR_INT_NAME(c) (SCHEME_SYMBOLP((c)->name) ? (c)->name : SCHEME_CAR((c)->name))
+#define IVAR_EXT_NAME(c) (SCHEME_SYMBOLP((c)->name) ? (c)->name : SCHEME_CADR((c)->name))
+/* Get external, but know to be external only: */
+#define _IVAR_EXT_NAME(c) ((c)->name)
+
+typedef struct ClassVariable {
+  Scheme_Object *name;
+  short vartype;
+  short index;
+  union {
+    Scheme_Object *value;
+    struct {
+      Scheme_Closed_Prim *f;
+      short mina, maxa;
+    } prim;
+    struct {
+      Scheme_Object *name;
+    } source;
+  } u;
+  struct ClassVariable *next;
+} ClassVariable;
+
+enum {
+  pi_NOT = 0,
+  pi_NOT_OVER_CPP,
+  pi_CPP,
+  pi_COMP,
+  pi_COMP_OVER_CPP
+};
+
+typedef struct {
+  Scheme_Closed_Prim *f;
+  short mina, maxa;
+  char *closed_name;
+} CMethod;
+
+typedef char slotkind;
+
+typedef struct Scheme_Interface {
+  Scheme_Type type;
+  short num_names, num_supers;
+  Scheme_Object **names;
+  short *name_map; /* position in names => interface slot position */
+  struct Scheme_Interface **supers; /* all superinterfaces (flattened hierarchy) */
+  short *super_offsets; /* superinterface => super's slot position offset */
+  Scheme_Object *defname;
+} Scheme_Interface;
+
+typedef struct Interface_Data {
+  Scheme_Type type;
+  short num_names, num_supers;
+  Scheme_Object **names;
+  struct Scheme_Object **super_exprs;
+  Scheme_Object *defname;
+} Interface_Data;
+
+typedef struct Scheme_Interface_Assembly {
+  Interface_Data data;
+} Scheme_Interface_Assembly;
+
+typedef struct Scheme_Class {
+  Scheme_Type type;
+
+  ClassVariable *ivars; /* Order determines order of evaluation */
+
+  union {
+    Scheme_Closed_Prim *initf;
+    struct {
+      Scheme_Instance_Init_Proc *f;
+      void *data;
+    } insti;
+  } piu;
+  short priminit;
+
+  short pos;
+  struct Scheme_Class **heritage;
+  struct Scheme_Class *superclass; /* Redundant, but useful. */
+  Scheme_Object *super_init_name;
+
+  short num_args, num_required_args, num_arg_vars;
+  short num_ivar, num_private, num_ref;
+  short num_public, num_slots; /* num_vslots == num_public */
+  Scheme_Object **public_names;
+  short *public_map; /* position in public_names => virtual slot position */
+  short *vslot_map; /* virtual slot position => slot position or cmethod position */
+  slotkind *vslot_kind; /* virtual slot position => TYPE_CMETHOD | TYPE_IVAR */
+
+  short *ivar_map; /* ivar index => class virtual slot */
+  short *ref_map;  /* ref index => [super]class virtual slot position */
+
+  CMethod **cmethods;
+  short *cmethod_ready_level; /* class level where the cmethod originates */
+  short *cmethod_source_map; /* cmethod position => local cmethod position */
+  short contributes_cmethods;
+
+  short closure_size;
+  Scheme_Object **closure_saved;
+
+  Scheme_Object *defname;
+
+  int max_let_depth;
+
+  short num_interfaces;
+  Scheme_Interface **interfaces;
+  short **interface_maps; /* interface slot position => virtual slot position */
+} Scheme_Class;
+
+typedef struct {
+  Scheme_Type type;
+
+  ClassVariable *ivars;
+
+  short num_args, num_required_args, num_arg_vars;
+  short num_ivar, num_private, num_ref;
+  short num_cmethod;
+  Scheme_Object **ivar_names;
+  Scheme_Object **cmethod_names;
+  CMethod **cmethods;
+
+  short *closure_map;
+  short closure_size;
+
+  int max_let_depth;
+
+  Scheme_Object *super_init_name;
+  Scheme_Object *super_expr;
+
+  int num_interfaces;
+  Scheme_Object **interface_exprs;
+
+  Scheme_Object *defname;
+} Class_Data;
+
+typedef struct Scheme_Class_Assembly {
+  Class_Data data;
+  Scheme_Instance_Init_Proc *init;
+  int mina, maxa;
+} Scheme_Class_Assembly;
+
+typedef struct {
+  Scheme_Object **ivars;
+  Scheme_Object **refs;
+  Scheme_Object **cmethods; /* cached cethod closures */
+} Init_Frame;
+
+typedef struct Internal_Object {
+  struct {
+    Scheme_Type type;
+    Scheme_Object *sclass;
+  } o;
+  Scheme_Object *slots[1];
+} Internal_Object;
+
+typedef struct Init_Object_Rec {
+  short init_level;
+  Init_Frame frames[1];
+} Init_Object_Rec;
+
+typedef struct {
+  Internal_Object *o;
+  Init_Object_Rec *irec;
+  int level;
+} SuperInitData;
+
+typedef struct {
+  Scheme_Type type;
+  short kind;
+  Scheme_Object *clori;
+  int vp;
+} Generic_Data;
+
+static Scheme_Class *null_class = NULL;
+
+static Scheme_Object *MakeSuperInitPrim(Internal_Object *o, Init_Object_Rec *irec, int level);
+static int DoFindName(int count, Scheme_Object **pub, Scheme_Object *symbol);
+static short *find_implementation(Scheme_Object *c, Scheme_Object *n, int *offset);
+
+#define FindName(c, s) DoFindName(c->num_public, c->public_names, s)
+
+/* Stack for object initailization (all boxed, currently):
+
+   last private ivar
+   first private ivar
+
+   last ref ivar
+   first ref ivar
+
+   last public ivar
+   first public ivar
+
+   super-init
+   this
+
+   first init var
+   last init var
+   */
+
+/**********************************************************************/
+
+#endif /* NO_OBJECT_SYSTEM */
+
+#if !defined(NO_OBJECT_SYSTEM) || !defined(NO_UNIT_SYSTEM)
+
+static const char *get_class_name(Scheme_Object *c, const char *mode);
+static const char *get_interface_name(Scheme_Object *i, const char *mode);
+
+DupCheckRecord *scheme_begin_dup_symbol_check(DupCheckRecord *r)
+{
+  long i;
+  
+  if (r && r->scheck_size > 50)
+    r->scheck_size = 0;    
+  else {
+    for (i = r->scheck_size; i--; )
+      r->scheck_hash[i] = NULL;
+  }
+
+  if (!r) {
+    r = (DupCheckRecord *)scheme_malloc(sizeof(DupCheckRecord));
+    r->scheck_size = 0;
+  }
+
+  if (!r->scheck_size) {
+    r->scheck_hash = NULL;
+    r->scheck_step = 17;
+    r->scheck_count = 0;
+  }
+
+  return r;
+}
+
+void scheme_dup_symbol_check(DupCheckRecord *r, char *where,
+			     Scheme_Object *symbol, char *what, 
+			     Scheme_Object *form, int inverted)
+{
+  long pos;
+
+  if (r->scheck_count >= r->scheck_size / 2) {
+    Scheme_Object **old = r->scheck_hash;
+    long oldsize = r->scheck_size, i;
+
+    r->scheck_size = r->scheck_size ? 2 * r->scheck_size : 50;
+    r->scheck_hash = 
+      (Scheme_Object **)scheme_malloc(i = r->scheck_size 
+				      * sizeof(Scheme_Object *));
+    memset(r->scheck_hash, 0, i);
+
+    r->scheck_count = 0;
+    for (i = 0; i < oldsize; i++)
+      if (old[i])
+	scheme_dup_symbol_check(r, where, old[i], what, form, 0);
+  }
+
+  pos = (((long)symbol) >> 2) % r->scheck_size;
+  if (pos < 0)
+    pos = -pos;
+  while(r->scheck_hash[pos]) {
+    if (SAME_OBJ(r->scheck_hash[pos], symbol)) {
+      if (inverted)
+	return;
+      scheme_wrong_syntax(where, symbol, form,
+			  "duplicate %s name", what);
+    }
+    pos = (pos + r->scheck_step) % r->scheck_size;
+  }
+
+  if (inverted > 0)
+    scheme_wrong_syntax(where, symbol, form,
+			"undeclared %s name", what);
+
+  r->scheck_hash[pos] = symbol;
+  r->scheck_count++;
+}
+
+#endif
+
+#ifndef NO_OBJECT_SYSTEM
+
+static Scheme_Object *NullClass(void) 
+{
+  if (!null_class) {
+    null_class = MALLOC_ONE_TAGGED(Scheme_Class);
+    
+    null_class->type = scheme_class_type;
+    
+    null_class->priminit = pi_NOT;
+    
+    null_class->ivars = NULL;
+    
+    null_class->pos = 0;
+    null_class->super_init_name = NULL;
+    null_class->heritage = MALLOC_ONE(Scheme_Class*);
+    null_class->heritage[0] = null_class;
+    null_class->superclass = NULL;
+    
+    null_class->num_args = 0;
+    null_class->num_required_args = 0;
+    null_class->num_arg_vars = 0;
+    null_class->num_public = 0;
+    null_class->num_private = 0;
+    null_class->num_ref = 0;
+    null_class->public_names = NULL;
+    null_class->cmethods = NULL;
+    null_class->cmethod_ready_level = NULL;
+    null_class->cmethod_source_map = NULL;
+    null_class->contributes_cmethods = FALSE;
+
+    null_class->defname = NULL;
+    
+    null_class->closure_saved = NULL;
+    null_class->closure_size = 0;
+    null_class->max_let_depth = 0;
+  }
+
+  return (Scheme_Object *)null_class;
+}
+
+/**********************************************************************/
+
+static int CompareObjectPtrs(Scheme_Object **a, Scheme_Object **b)
+{
+  return ((long)*a) - ((long)*b);
+}
+
+#define SEQUALS(a, b) (((unsigned long)a) == ((unsigned long)b))
+#define SLESSTHAN(a, b) (((unsigned long)a) < ((unsigned long)b))
+
+static int MergeArray(int ac, Scheme_Object **ak, Scheme_Object **a, short *as,
+		      int bc, Scheme_Object **bk, Scheme_Object **b, short *bs,
+		      Scheme_Object **d, short *ds, int nodup)
+{
+  int ai = 0, bi = 0, di = 0;
+
+  while ((ai < ac) || (bi < bc)) {
+    if ((ai < ac) && (bi < bc)) {
+      if (SEQUALS(ak[ai], bk[bi])) {
+	if (d)
+	  d[di] = a[ai];
+	if (ds)
+	  ds[di] = as[ai];
+	ai++;
+	if (nodup)
+	  bi++;
+      } else if (SLESSTHAN(ak[ai], bk[bi])) {
+	if (d)
+	  d[di] = a[ai];
+	if (ds)
+	  ds[di] = as[ai];
+	ai++;
+      } else {
+	if (d)
+	  d[di] = b[bi];
+	if (ds)
+	  ds[di] = bs[bi];
+	bi++;
+      }
+    } else if (ai < ac) {
+      if (d)
+	d[di] = a[ai];
+      if (ds)
+	ds[di] = as[ai];
+      ai++;
+    } else {
+      if (d)
+	d[di] = b[bi];
+      if (ds)
+	ds[di] = bs[bi];
+      bi++;
+    }
+    di++;
+  }
+
+  return di;
+}
+
+/**********************************************************************/
+
+static ClassVariable *ReadItemList(char *what, Scheme_Object *vars, 
+				   int vartype,
+				   ClassVariable *start,
+				   ClassVariable **very_first,
+				   Scheme_Object *form)
+{
+  Scheme_Object *l, *var, *value;
+  ClassVariable *classvar;
+  int alias, seq, input, islast;
+
+  alias = isreftype(vartype);
+  seq = (vartype == varNOTHING);
+  input = (vartype == varINPUT);
+
+  for (; !SCHEME_NULLP(vars); vars = SCHEME_CDR(vars)) {
+    if (input && !SCHEME_PAIRP(vars)) {
+      islast = 1;
+      l = vars;
+    } else {
+      l = SCHEME_CAR(vars);
+      islast = 0;
+    }
+    
+    if (seq) {
+      var = seq_symbol;
+      value = l;
+    } else if (SCHEME_LISTP(l)) {
+      var = SCHEME_CAR(l);
+	
+      l = SCHEME_CDR(l);
+      if (SCHEME_NULLP(l))
+	value = NULL;
+      else
+	value = SCHEME_CAR(l);
+    } else {
+      var = l;
+      value = NULL;
+    }
+
+    if (alias && !value)
+      value = var;
+    if (islast && !value)
+      value = scheme_null;
+
+    classvar = (ClassVariable *)scheme_malloc(sizeof(ClassVariable));
+    classvar->name = var;
+    classvar->vartype = vartype;
+    
+    if (alias)
+      classvar->u.source.name = value;
+    else
+      classvar->u.value = value;
+    classvar->next = NULL;
+
+    if (start)
+      start->next = classvar;
+    else
+      *very_first = classvar;
+
+    start = classvar;
+
+    if (islast)
+      break;
+  }
+
+  return start;
+}
+
+static void CompileItemList(Scheme_Object *form,
+			    ClassVariable *cvars,
+			    Scheme_Comp_Env *env, 
+			    Class_Data *data,
+			    Scheme_Compile_Info *rec)
+{
+  int alias, count;
+  ClassVariable *classvar;
+  Scheme_Compile_Info *recs;
+
+  for (count = 0, classvar = cvars; classvar; classvar = classvar->next) {
+    alias = isref(classvar);
+    if (!alias)
+      count++;
+  }
+
+  recs = MALLOC_N(Scheme_Compile_Info, count);
+  scheme_init_compile_recs(rec, recs, count);
+
+  for (count = 0, classvar = cvars; classvar; classvar = classvar->next) {
+    alias = isref(classvar);
+
+    if (!alias && !classvar->u.value)
+      classvar->u.value = scheme_compiled_void(rec->can_optimize_constants);
+
+    scheme_check_identifier(CLASS_STAR, IVAR_INT_NAME(classvar), NULL, env, form);
+
+    if (!alias) {
+      recs[count].value_name = IVAR_EXT_NAME(classvar);
+      classvar->u.value = scheme_compile_expr(classvar->u.value, env, recs + count);
+      count++;
+    }
+  }
+
+  scheme_merge_compile_recs(rec, recs, count);
+}
+
+#define check_MustPair 0x1
+#define check_MustId 0x2
+#define check_BindingMustId 0x4
+#define check_CanRename 0x8
+
+static void GenCheckIvarList(Scheme_Object *clause, 
+			     Scheme_Object *naya, 
+			     int flags,
+			     Scheme_Object *form)
+{
+  Scheme_Object *l, *p, *n;
+
+  for (l = naya; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
+    p = SCHEME_CAR(l);
+    if (SCHEME_SYMBOLP(p)) {
+      if (flags & check_MustPair)
+	scheme_wrong_syntax(CLASS_STAR, p, form,
+			    "%s clause must contain pairs",
+			    SCHEME_SYM_VAL(clause));
+    } else if (SCHEME_PAIRP(p)) {
+      Scheme_Object *pr = p;
+
+      if (flags & check_MustId) {
+	if (!(flags & check_CanRename)) {
+	  scheme_wrong_syntax(CLASS_STAR, p, form,
+			      "%s clause must contain only identifiers",
+			      SCHEME_SYM_VAL(clause));
+	}
+	n = p;
+	p = scheme_null;
+      } else {
+	n = SCHEME_CAR(p);
+	p = SCHEME_CDR(p);
+      }
+
+      if (!SCHEME_SYMBOLP(n)) {
+	if (flags & check_CanRename) {
+	  if (!SCHEME_PAIRP(n) || !SCHEME_PAIRP(SCHEME_CDR(n))
+	      || !SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(n))))
+	    scheme_wrong_syntax(CLASS_STAR, n, form,
+				"badly formed %s clause (bad internal-external"
+				" identifier pair form)", SCHEME_SYM_VAL(clause));
+	  if (!SCHEME_SYMBOLP(SCHEME_CAR(n)))
+	    scheme_wrong_syntax(CLASS_STAR, SCHEME_CAR(n), form,
+				"badly formed %s clause (internal"
+				" name not an identifier)", SCHEME_SYM_VAL(clause));	  
+	  n = SCHEME_CDR(n);
+	  if (!SCHEME_SYMBOLP(SCHEME_CAR(n)))
+	    scheme_wrong_syntax(CLASS_STAR, SCHEME_CAR(n), form,
+				"badly formed %s clause (external"
+				" name not an identifier)", SCHEME_SYM_VAL(clause));	  
+	} else
+	  scheme_wrong_syntax(CLASS_STAR, n, form,
+			      "badly formed %s clause (name"
+			      " not an identifier)", SCHEME_SYM_VAL(clause));
+      }
+
+      if (!SCHEME_NULLP(p)) {
+	if (!SCHEME_PAIRP(p))
+	scheme_wrong_syntax(CLASS_STAR, pr, form,
+			    "badly formed %s clause (identifier"
+			    " declaration is improper)", 
+			    SCHEME_SYM_VAL(clause));
+	if (!SCHEME_NULLP(SCHEME_CDR(p)))
+	  scheme_wrong_syntax(CLASS_STAR, pr, form,
+			      "badly formed %s clause (identifier"
+			      " declaration not a pair)", 
+			      SCHEME_SYM_VAL(clause));
+	if (flags & check_BindingMustId) {
+	  n = SCHEME_CAR(p);
+	  if (!SCHEME_SYMBOLP(n))
+	    scheme_wrong_syntax(CLASS_STAR, pr, form,
+				"association "
+				"in %s clause "
+				"must be an identifier",
+				SCHEME_SYM_VAL(clause));
+	}
+      } else if (flags & check_MustPair)
+	scheme_wrong_syntax(CLASS_STAR, pr, form,
+			    "%s clause must contain pairs",
+			    SCHEME_SYM_VAL(clause));
+    } else
+      scheme_wrong_syntax(CLASS_STAR, p, form,
+			  "badly formed %s clause (declaration"
+			  " not an identifier or pair)", 
+			  SCHEME_SYM_VAL(clause));
+  }
+  
+  if (!SCHEME_NULLP(l))
+    scheme_wrong_syntax(CLASS_STAR, l, form,
+			"badly formed %s clause (" 
+			IMPROPER_LIST_FORM
+			" for identifiers)", 
+			SCHEME_SYM_VAL(clause));
+  
+}
+
+static void CheckIvarList(Scheme_Object *t, Scheme_Object *l, int flags,
+			  Scheme_Object *form)
+{
+  GenCheckIvarList(t, l, flags, form);
+}
+
+static Scheme_Object *GetNames(ClassVariable *ivar, 
+			       int pblic, int prvate, int ref,
+			       Scheme_Comp_Env *env)
+{
+  Scheme_Object *first = scheme_null, *last = NULL;
+  int offset = 0;
+
+  for (; ivar; ivar = ivar->next) {
+    if ((ispublic(ivar) && pblic)
+	|| (isref(ivar) && ref)
+	|| (isprivate(ivar) && prvate)) {
+      if (env) {
+	scheme_unsettable_variable(env, offset);
+      } else {
+	Scheme_Object *p = cons(IVAR_INT_NAME(ivar), scheme_null);
+	
+	if (last)
+	  SCHEME_CDR(last) = p;
+	else
+	  first = p;
+	
+	last = p;
+      }
+
+      offset++;
+    }
+  }
+
+  return first;
+}
+
+static Scheme_Object *expandall(Scheme_Object *vars, Scheme_Comp_Env *env, int depth,
+				int expand_expr, Scheme_Comp_Env *first_from)
+{
+  Scheme_Object *first, *last;
+  Scheme_Object *name, *var;
+
+  name = SCHEME_CAR(vars);
+  vars = SCHEME_CDR(vars);
+
+  first = last = cons(name, scheme_null);
+
+  if (first_from) {
+    name = SCHEME_CAR(vars);
+    vars = SCHEME_CDR(vars);
+    
+    SCHEME_CDR(first) = last = cons(name, scheme_null);
+  }
+
+  while (!SCHEME_NULLP(vars)) {
+    var = SCHEME_CAR(vars);
+
+    if (!SCHEME_PAIRP(var)) {
+    } else {
+      Scheme_Object *rest, *name;
+    
+      name = SCHEME_CAR(var);
+      rest = SCHEME_CDR(var);
+
+      if (expand_expr)
+	rest = scheme_expand_expr(rest, env, depth);
+      
+      var = cons(name, rest);
+    }
+    
+    var = cons(var, scheme_null);
+
+    SCHEME_CDR(last) = var;
+    last = var;
+
+    vars = SCHEME_CDR(vars);
+  }
+
+  return first;
+}
+
+static short *CheckInherited(Scheme_Class *sclass, ClassVariable *item)
+{
+  short *ref_map;
+  Scheme_Class *superclass = sclass->superclass;
+
+  ref_map = MALLOC_N_ATOMIC(short, sclass->num_ref);
+
+  for (; item; item = item->next) {
+    if (isref(item)) {
+      int p;
+      if ((p = FindName(superclass, item->u.source.name)) < 0) {
+	const char *cl, *sc;
+
+	cl = get_class_name((Scheme_Object *)sclass, " for class: ");
+	sc = get_class_name((Scheme_Object *)superclass, " in superclass: ");
+
+	scheme_raise_exn(MZEXN_OBJECT_INHERIT,
+			 item->u.source.name,
+			 CLASS_STAR ": inherited ivar not found: %s%s%s",
+			 scheme_symbol_name(item->u.source.name),
+			 sc,
+			 cl);
+      } else {
+	ref_map[item->index] = superclass->public_map[p];
+      }
+    }
+  }
+
+  return ref_map;
+}
+
+static short *MapIvars(Scheme_Class *sclass, ClassVariable *item)
+{
+  short *ivar_map;
+
+  ivar_map = MALLOC_N_ATOMIC(short, sclass->num_ivar);
+
+  for (; item; item = item->next) {
+    if (ispublic(item))
+      ivar_map[item->index] = sclass->public_map[FindName(sclass, item->name)];
+  }
+
+  return ivar_map;
+}
+
+static void InsureNamesReady(ClassVariable *ivars, int count, Scheme_Object ***names)
+{
+  int i;
+  ClassVariable *cvar;
+
+  if (count && !*names) {
+    *names = MALLOC_N(Scheme_Object*, count);
+
+    for (i = 0, cvar = ivars; cvar; cvar = cvar->next)
+      if (ispublic(cvar))
+	(*names)[i++] = _IVAR_EXT_NAME(cvar);
+
+    qsort((char *)*names, count,
+	  sizeof(Scheme_Object *), 
+	  (int (*)(const void *, const void *))CompareObjectPtrs); 
+  }
+}
+
+static void InstallHeritage(Scheme_Class *sclass, Scheme_Class *superclass)
+{
+  int i;
+
+  sclass->pos = superclass->pos + 1;
+  sclass->heritage = MALLOC_N_ATOMIC(Scheme_Class*, (sclass->pos + 1));
+  for (i = 0; i < sclass->pos; i++)
+    sclass->heritage[i] = superclass->heritage[i];
+  sclass->heritage[sclass->pos] = sclass;
+  sclass->superclass = sclass->heritage[sclass->pos - 1];
+}
+
+static Scheme_Object *Interface_Execute(Scheme_Object *form)
+{
+  Scheme_Object *il;
+  Interface_Data *data;
+  Scheme_Interface *in, **supers;
+  int num_supers, num_names, i;
+
+  data = (Interface_Data *)form;
+
+  /* Build a list instead of allocating an array immediately.
+     Why? Suppose that the continuation is grabbed during the
+     evaluation of an interface expression... */
+  num_supers = data->num_supers;
+  il = scheme_null;
+  for (i = 0; i < num_supers; i++) {
+    Scheme_Object *in;
+    in = _scheme_eval_compiled_expr(data->super_exprs[i]);
+    if (!SCHEME_INTERFACEP(in)) {
+      scheme_raise_exn(MZEXN_OBJECT_INTERFACE_TYPE,
+		       in,
+		       "interface: interface expression returned "
+		       "a non-interface: %s%s%s",
+		       scheme_make_provided_string(in, 1, NULL),
+		       data->defname ? " for interface: " : "",
+		       data->defname ? scheme_symbol_name(data->defname) : "");
+      return NULL;
+    }
+    il = cons(in, il);
+  }
+
+  in = MALLOC_ONE_TAGGED(Scheme_Interface);
+  in->type = scheme_interface_type;
+
+  in->defname = data->defname;
+
+  supers = MALLOC_N(Scheme_Interface*, num_supers);
+  for (i = data->num_supers; i--; ) {
+    supers[i] = (Scheme_Interface *)SCHEME_CAR(il);
+    il = SCHEME_CDR(il);
+  }
+  in->num_supers = num_supers;
+  in->supers = supers;
+
+  if (num_supers) {
+    Scheme_Object **nbanka, **nbankb;
+    short *mbanka, *mbankb;
+    int total, mode = 1, newcount, offset;
+
+    total = 0;
+    for (i = num_supers; i--; )
+      total += supers[i]->num_names; 
+    
+    nbanka = MALLOC_N(Scheme_Object*, total);
+    nbankb = MALLOC_N(Scheme_Object*, total);
+    mbanka = MALLOC_N(short, total);
+    mbankb = MALLOC_N(short, total);
+
+    num_names = supers[num_supers - 1]->num_names;
+    for (i = num_names; i--; ) {
+      nbanka[i] = supers[num_supers - 1]->names[i];
+      mbanka[i] = supers[num_supers - 1]->name_map[i];
+    }
+
+    /* Merge superclasses, keeping duplicates.
+       Merge name map in parallel.
+       Offset name maps according to superinterface offsets. */
+    for (i = data->num_supers - 1; i--; ) {
+      int j, count;
+      short *mbank;
+
+      count = supers[i]->num_names;
+      mbank = mode ? mbanka : mbankb;
+      for (j = 0; j < num_names; j++)
+	mbank[j] += count;
+
+      MergeArray(num_names, mode ? nbanka : nbankb, mode ? nbanka : nbankb, NULL,
+		 count, supers[i]->names, supers[i]->names, NULL,
+		 mode ? nbankb : nbanka, NULL, 0);
+      num_names = MergeArray(num_names, mode ? nbanka : nbankb, NULL, mode ? mbanka : mbankb, 
+			     count, supers[i]->names, NULL, supers[i]->name_map,
+			     NULL, mode ? mbankb : mbanka, 0);
+
+      mode = !mode;
+    }
+
+    /* Final merge: */
+    if (!mode) {
+      nbanka = nbankb;
+      mbanka = mbankb;
+    }
+
+    total = MergeArray(data->num_names, data->names, NULL, NULL,
+		       num_names, nbanka, NULL, NULL,
+		       NULL, NULL, 1);
+    newcount = total - num_names;
+    
+    mbankb = MALLOC_N(short, data->num_names);
+    /* init to -1; we'll go back and set the numbers later */
+    for (i = data->num_names; i--; )
+      mbankb[i] = -1;
+    /* offset by number of names to be added */
+    for (i = num_names; i--; )
+      mbanka[i] += newcount;
+
+    in->num_names = total;
+    in->names = MALLOC_N(Scheme_Object*, total);
+    in->name_map = MALLOC_N(short, total);
+
+    MergeArray(data->num_names, data->names, data->names, NULL,
+	       num_names, nbanka, nbanka, NULL,
+	       in->names, NULL, 1);
+    MergeArray(data->num_names, data->names, NULL, mbankb, 
+	       num_names, nbanka, NULL, mbanka,
+	       NULL, in->name_map, 1);
+
+    /* renumber -1s to distinct new numbers (0 to newcount): */
+    {
+      int j;
+      j = 0;
+      for (i = total; i--; )
+	if (in->name_map[i] < 0)
+	  in->name_map[i] = j++;
+    }
+
+    /* Count total supers: */
+    total = 0;
+    for (i = num_supers; i--; )
+      total += supers[i]->num_supers + 1;
+    in->num_supers = total;
+    in->supers = MALLOC_N(Scheme_Interface*, total);
+    in->super_offsets = MALLOC_N(short, total);
+    {
+      int j;
+      j = 0;
+      offset = newcount;
+      for (i = 0; i < num_supers; i++) {
+	int k;
+	in->supers[j] = supers[i];
+	in->super_offsets[j] = offset;
+	j++;
+	for (k = 0; k < supers[i]->num_supers; k++) {
+	  in->supers[j] = supers[i]->supers[k];
+	  in->super_offsets[j] = supers[i]->super_offsets[k] + offset;
+	  j++;
+	}
+	offset += supers[i]->num_names;
+      }
+    }
+  } else {
+    num_names = data->num_names;
+    in->num_names = num_names;
+    in->names = data->names;
+    in->name_map = MALLOC_N(short, in->num_names);
+    for (i = num_names; i--; )
+      in->name_map[i] = i;
+    in->num_supers = 0;
+    in->supers = NULL;
+    in->super_offsets = NULL;
+  }
+
+  return (Scheme_Object *)in;
+}
+
+static Scheme_Object *Interface_Link(Scheme_Object *form, Link_Info *info)
+{
+  Interface_Data *data;
+  int i;
+
+  data = (Interface_Data *)form;
+
+  for (i = data->num_supers; i--; )
+    data->super_exprs[i] = scheme_link_expr(data->super_exprs[i], info);
+
+  return scheme_make_syntax_link(Interface_Execute, 
+				 (Scheme_Object *)data);
+}
+
+static Scheme_Object *Do_Interface(Scheme_Object *form, Scheme_Comp_Env *env,
+				   Scheme_Compile_Info *rec, int depth)
+{
+  int i, num_supers, num_names;
+  Scheme_Object *l, *sl, **supers, *nl;
+  DupCheckRecord *r, drec;
+
+  l = SCHEME_CDR(form);
+  
+  if (!SCHEME_LISTP(l))
+    scheme_wrong_syntax(INTERFACE, NULL, form, NULL);
+  if (SCHEME_NULLP(l))
+    scheme_wrong_syntax(INTERFACE, NULL, form, 
+			"missing superinterface specification");
+  
+  sl = SCHEME_CAR(l);
+  num_supers = 0;
+  while (SCHEME_PAIRP(sl)) {
+    sl = SCHEME_CDR(sl);
+    num_supers++;
+  }
+
+  if (!SCHEME_NULLP(sl)) {
+    scheme_wrong_syntax(INTERFACE, sl, form, 
+			"bad superinterface specification");
+    return NULL;
+  }
+
+  supers = MALLOC_N(Scheme_Object*,num_supers);
+  sl = SCHEME_CAR(l);
+  for (i = 0; i < num_supers; i++, sl = SCHEME_CDR(sl))
+    supers[i] = SCHEME_CAR(sl);
+
+  l = SCHEME_CDR(l);
+  nl = l;
+
+  drec.scheck_size = 0;
+  r = scheme_begin_dup_symbol_check(&drec);
+
+  num_names = 0;
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *s = SCHEME_CAR(l);
+    num_names++;
+    scheme_check_identifier(INTERFACE, s, NULL, env, form);
+    scheme_dup_symbol_check(r, INTERFACE, s, "identifier", form, 0);
+    l = SCHEME_CDR(l);
+  }
+
+  if (!SCHEME_NULLP(l)) {
+    scheme_wrong_syntax(INTERFACE, l, form, 
+			"bad name sequence");
+    return NULL;
+  }
+
+  if (!rec) {
+    /* Expanding */
+    for (i = 0; i < num_supers; i++)
+      supers[i] = scheme_expand_expr(supers[i], env, depth);
+    l = scheme_null;
+    for (i = num_supers; i--; )
+      l = cons(supers[i], l);
+
+    return cons(interface_symbol, cons(l, nl));
+  } else {
+    /* Compiling */
+    Interface_Data *data;
+    Scheme_Compile_Info *recs;
+
+    data = MALLOC_ONE_TAGGED(Interface_Data);
+    data->type = scheme_interface_data_type;
+
+    data->defname = rec->value_name;
+    scheme_compile_rec_done_local(rec);
+
+    data->num_names = num_names;
+    data->names = MALLOC_N(Scheme_Object*, num_names);
+    l = nl;
+    for (i = 0; i < num_names; i++, nl = SCHEME_CDR(nl))
+      data->names[i] = SCHEME_CAR(nl);
+
+    /* Sort names: */
+    qsort((char *)data->names, num_names,
+	  sizeof(Scheme_Object *), 
+	  (int (*)(const void *, const void *))CompareObjectPtrs); 
+
+    recs = MALLOC_N(Scheme_Compile_Info, num_supers);
+    scheme_init_compile_recs(rec, recs, num_supers);
+
+    for (i = 0; i < num_supers; i++)
+      supers[i] = scheme_compile_expr(supers[i], env, recs + i);
+
+    scheme_merge_compile_recs(rec, recs, num_supers);
+
+    data->num_supers = num_supers;
+    data->super_exprs = supers;
+
+    return scheme_make_syntax_compile(Interface_Link, 
+				      (Scheme_Object *)data);
+  }
+}
+
+static Scheme_Object *Interface(Scheme_Object *form, Scheme_Comp_Env *env,
+				Scheme_Compile_Info *rec)
+{
+  return Do_Interface(form, env, rec, 0);
+}
+
+static Scheme_Object *Interface_expand(Scheme_Object *form, Scheme_Comp_Env *env,
+				       int depth)
+{
+  return Do_Interface(form, env, NULL, depth);
+}
+
+
+static Scheme_Object *_DefineClass_Execute(Scheme_Object *form, int already_evaled)
+{
+  Scheme_Class *sclass, *superclass;
+  Class_Data *data;
+  Scheme_Interface **interfaces;
+  Scheme_Object *superobj, **temp_array, **public_names, *il;
+  int i, j, num_cmethod, newpos, num_local_interfaces, num_interfaces, num_public;
+  int num_contrib_cmethod;
+  short **imaps;
+  CMethod **tmp_cmethods;
+  short *tmp_cmethod_ready_level, *tmp_cmethod_source_map;
+
+  data = (Class_Data *)form;
+
+  if (!already_evaled)
+    superobj = _scheme_eval_compiled_expr(data->super_expr);
+  else
+    superobj = data->super_expr;
+
+  if (SCHEME_NULLP(superobj))
+    superobj = NullClass();
+  
+  if (!SCHEME_CLASSP(superobj)) {
+    scheme_raise_exn(MZEXN_OBJECT_CLASS_TYPE,
+		     superobj,
+		     CLASS_STAR ": superclass expression returned "
+		     "a non-class: %s%s%s",
+		     scheme_make_provided_string(superobj, 1, NULL),
+		     data->defname ? " for class: " : "",
+		     data->defname ? scheme_symbol_name(data->defname) : "");
+    return NULL;
+  }
+	
+  superclass = (Scheme_Class *)superobj;
+
+  /* Build a list instead of allocating an array immediately.
+     See note in Interface_Execute(). */
+  num_local_interfaces = data->num_interfaces;
+  il = scheme_null;
+  for (i = 0; i < num_local_interfaces; i++) {
+    Scheme_Object *in;
+    in = _scheme_eval_compiled_expr(data->interface_exprs[i]);
+    if (!SCHEME_INTERFACEP(in)) {
+      scheme_raise_exn(MZEXN_OBJECT_INTERFACE_TYPE,
+		       in,
+		       CLASS_STAR ": interface expression returned "
+		       "a non-interface: %s%s%s",
+		       scheme_make_provided_string(in, 1, NULL),
+		       data->defname ? " for class: " : "",
+		       data->defname ? scheme_symbol_name(data->defname) : "");
+      return NULL;
+    }
+    il = cons(in, il);
+  }
+
+  sclass = MALLOC_ONE_TAGGED(Scheme_Class);
+  sclass->type = scheme_class_type;
+  if ((superclass->priminit == pi_CPP) 
+      || (superclass->priminit == pi_NOT_OVER_CPP)
+      || (superclass->priminit == pi_COMP_OVER_CPP))
+    sclass->priminit = pi_NOT_OVER_CPP;
+  else
+    sclass->priminit = pi_NOT;
+  sclass->defname = data->defname;
+
+  if ((superclass->priminit == pi_CPP) 
+      && !superclass->piu.initf) {
+    const char *cl = get_class_name((Scheme_Object *)sclass, " to create class: ");
+    scheme_raise_exn(MZEXN_OBJECT_PRIVATE_CLASS,
+		     superclass,
+		     "can't derive from the class: %s%s", 
+		     scheme_symbol_name(superclass->defname),
+		     cl);
+  }
+  
+  InstallHeritage(sclass, superclass);
+
+  sclass->super_init_name = data->super_init_name;
+
+  num_interfaces = num_local_interfaces + superclass->num_interfaces;
+
+  if (num_interfaces) {
+    interfaces = MALLOC_N(Scheme_Interface*, num_interfaces);
+    for (i = num_local_interfaces; i--; ) {
+      interfaces[i] = (Scheme_Interface *)SCHEME_CAR(il);
+      il = SCHEME_CDR(il);
+    }
+    for (i = superclass->num_interfaces; i--; )
+      interfaces[i + num_local_interfaces] = superclass->interfaces[i];
+  } else
+    interfaces = NULL;
+  sclass->num_interfaces = num_interfaces;
+  sclass->interfaces = interfaces;
+
+  /* Setup public/private */
+  sclass->ivars = data->ivars;
+  sclass->num_args = data->num_args;
+  sclass->num_required_args = data->num_required_args;
+  sclass->num_arg_vars = data->num_arg_vars;
+  sclass->num_private = data->num_private;
+  sclass->num_ref = data->num_ref;
+  sclass->num_ivar = data->num_ivar;
+
+  /* How big is the union? */
+  sclass->num_public = (MergeArray(data->num_ivar, data->ivar_names, NULL, NULL,
+				   superclass->num_public, superclass->public_names, NULL, NULL,
+				   NULL, NULL, 1)
+			+ MergeArray(data->num_cmethod, data->cmethod_names, NULL, NULL,
+				     superclass->num_public, superclass->public_names, NULL, NULL,
+				     NULL, NULL, 1)
+			- superclass->num_public);
+
+  /* Make room for the union */
+  num_public = sclass->num_public;
+  temp_array = MALLOC_N(Scheme_Object*, num_public);
+  public_names = MALLOC_N(Scheme_Object*, num_public);
+  sclass->public_names = public_names;
+  
+  /* Union names: */
+  i = MergeArray(data->num_ivar, data->ivar_names, data->ivar_names, NULL,
+		 superclass->num_public, superclass->public_names, superclass->public_names, NULL,
+		 temp_array, NULL, 1);
+  MergeArray(i, temp_array, temp_array, NULL,
+	     data->num_cmethod, data->cmethod_names, data->cmethod_names, NULL,
+	     public_names, NULL, 1);
+
+  /* Map names to source: */
+  sclass->public_map = MALLOC_N_ATOMIC(short, num_public);
+  sclass->vslot_map = MALLOC_N_ATOMIC(short, num_public);
+  sclass->vslot_kind = MALLOC_N_ATOMIC(slotkind, num_public);
+  sclass->num_slots = ((sclass->priminit == pi_NOT_OVER_CPP) ? EXTRA_PRIM_SLOTS : 0);
+  num_cmethod = 0;
+  num_contrib_cmethod = 0;
+  newpos = superclass->num_public;
+
+  if (!data->num_cmethod) {
+    tmp_cmethods = NULL;
+    tmp_cmethod_ready_level = NULL;
+    tmp_cmethod_source_map = NULL;
+  } else {
+    /* Alloc for largest case */
+    i = data->num_cmethod + superclass->num_public;
+    tmp_cmethods = MALLOC_N(CMethod*, i);
+    tmp_cmethod_ready_level = MALLOC_N_ATOMIC(short, i);
+    tmp_cmethod_source_map = MALLOC_N_ATOMIC(short, i);
+  }
+
+  for (i = num_public; i--; ) {
+    Scheme_Object *s = public_names[i];
+    int cmpos, ipos;
+
+    cmpos = DoFindName(data->num_cmethod, data->cmethod_names, s);
+    if (cmpos < 0)
+      ipos = DoFindName(data->num_ivar, data->ivar_names, s);
+    else
+      ipos = -1;
+
+    j = DoFindName(superclass->num_public, superclass->public_names, s);
+    if (j >= 0) {
+      /* Overriding or inheriting: use superclass-determined vslot position. */
+      int vp = superclass->public_map[j];
+      sclass->public_map[i] = vp;
+      if (ipos >= 0) {
+	/* Override with ivar */
+	sclass->vslot_map[vp] = sclass->num_slots++;
+	sclass->vslot_kind[vp] = slot_TYPE_IVAR;
+      } else if (cmpos >= 0) {
+	/* Override with cmethod */
+	tmp_cmethods[num_cmethod] = data->cmethods[cmpos];
+	tmp_cmethod_ready_level[num_cmethod] = sclass->pos;
+	tmp_cmethod_source_map[num_cmethod] = num_contrib_cmethod++;
+	sclass->vslot_map[vp] = num_cmethod++;
+	sclass->vslot_kind[vp] = slot_TYPE_CMETHOD;
+      } else {
+	/* Inherit */
+	slotkind k = superclass->vslot_kind[vp];
+	sclass->vslot_kind[vp] = k;
+	if (k == slot_TYPE_CMETHOD) {
+	  /* Inherit cmethod */
+	  int cindex = superclass->vslot_map[vp];
+	  if (tmp_cmethods) {
+	    /* Adding cmethods, so re-shuffle: */
+	    tmp_cmethods[num_cmethod] = superclass->cmethods[cindex];
+	    tmp_cmethod_ready_level[num_cmethod] = superclass->cmethod_ready_level[cindex];
+	    tmp_cmethod_source_map[num_cmethod] = -1;
+	    sclass->vslot_map[vp] = num_cmethod++;
+	  } else {
+	    /* No new cmethods; using superclass's array: */
+	    sclass->vslot_map[vp] = superclass->vslot_map[vp];
+	  }
+	} else {
+	  /* Inherit ivar */
+	  sclass->vslot_map[vp] = sclass->num_slots++;
+	}
+      }
+    } else {
+      /* New vars: */
+      int vp = newpos++;
+      if (cmpos >= 0) {
+	/* New cmethod */
+	sclass->public_map[i] = vp;
+	tmp_cmethods[num_cmethod] = data->cmethods[cmpos];
+	tmp_cmethod_ready_level[num_cmethod] = sclass->pos;
+	tmp_cmethod_source_map[num_cmethod] = num_contrib_cmethod++;
+	sclass->vslot_map[vp] = num_cmethod++;
+	sclass->vslot_kind[vp] = slot_TYPE_CMETHOD;
+      } else {
+	/* New ivar */
+	sclass->public_map[i] = vp;
+	sclass->vslot_map[vp] = sclass->num_slots++;
+	sclass->vslot_kind[vp] = slot_TYPE_IVAR;
+      }
+    }
+  }
+
+  sclass->contributes_cmethods = num_contrib_cmethod;
+  if (!data->num_cmethod) {
+    /* Use superclass array: */
+    sclass->cmethods = superclass->cmethods;
+    sclass->cmethod_ready_level = superclass->cmethod_ready_level;
+    sclass->cmethod_source_map = superclass->cmethod_source_map;
+  } else if (num_cmethod) {
+    sclass->cmethods = MALLOC_N(CMethod*, num_cmethod);
+    sclass->cmethod_ready_level = MALLOC_N_ATOMIC(short, num_cmethod);
+    if (num_contrib_cmethod)
+      sclass->cmethod_source_map = MALLOC_N_ATOMIC(short, num_cmethod);
+    else
+      sclass->cmethod_source_map = NULL;
+    for (i = num_cmethod; i--; ) {
+      sclass->cmethods[i] = tmp_cmethods[i];
+      sclass->cmethod_ready_level[i] = tmp_cmethod_ready_level[i];
+      if (num_contrib_cmethod)
+	sclass->cmethod_source_map[i] = tmp_cmethod_source_map[i];
+    }
+  } else {
+    sclass->cmethods = NULL;
+    sclass->cmethod_ready_level = NULL;
+    sclass->cmethod_source_map = NULL;
+  }
+  tmp_cmethods = NULL;
+  tmp_cmethod_ready_level = NULL;
+  tmp_cmethod_source_map = NULL;
+
+  /* Map ref index to instance slot: */
+  sclass->ref_map = CheckInherited(sclass, sclass->ivars);
+
+  /* Map public index to instance slot: */
+  sclass->ivar_map = MapIvars(sclass, sclass->ivars);
+
+  /* Map interface name positions to class positions */
+  if (num_interfaces)
+    imaps = MALLOC_N(short*, num_interfaces);
+  else
+    imaps = NULL;
+  sclass->interface_maps = imaps;
+  for (i = 0; i < num_interfaces; i++) {
+    int j, k = 0;
+    Scheme_Interface *in = (Scheme_Interface *)interfaces[i];
+    imaps[i] = MALLOC_N(short, in->num_names);
+    for (j = 0; j < in->num_names; j++) {
+      while ((k < num_public) && SLESSTHAN(public_names[k], in->names[j]))
+	k++;
+      if ((k >= num_public) || !SEQUALS(public_names[k], in->names[j])) {
+	const char *cl, *inn;
+	char buffer[20], *bf;
+
+	cl = get_class_name((Scheme_Object *)sclass, " by class: ");
+	inn = get_interface_name((Scheme_Object *)in, ": ");
+
+	if (num_interfaces > 1) {
+	  if (i == 0)
+	    bf = "1st ";
+	  else if (i == 1)
+	    bf = "2nd ";
+	  else if (num_interfaces == 2)
+	    bf = "3rd ";
+	  else {
+	    sprintf(buffer, "%dth ", i + 1);
+	    bf = buffer;
+	  }
+	} else
+	  bf = "";
+	
+	scheme_raise_exn(MZEXN_OBJECT_IMPLEMENT,
+			 in->names[j],
+			 CLASS_STAR ": ivar not implemented: %s%s"
+			 " as required by the %sinterface%s",
+			 scheme_symbol_name(in->names[j]),
+			 cl, bf, inn);
+	return NULL;
+      }
+      imaps[i][in->name_map[j]] = sclass->public_map[k];
+    }
+  }
+
+  sclass->max_let_depth = data->max_let_depth;
+
+  i = sclass->closure_size = data->closure_size;
+  if (i) {
+    Scheme_Object **saved, **stack;
+    short *map = data->closure_map;
+
+    saved = sclass->closure_saved = MALLOC_N(Scheme_Object *, i);
+    stack = scheme_current_process->runstack;
+    while (i--)
+      saved[i] = stack[map[i]];
+  }
+
+  return (Scheme_Object *)sclass;
+}
+
+static Scheme_Object *DefineClass_Execute(Scheme_Object *form)
+{
+  return _DefineClass_Execute(form, FALSE);
+}
+
+static Scheme_Object *DefineClass_Link(Scheme_Object *form, Link_Info *info)
+{
+  Class_Data *data;
+  int i;
+  ClassVariable *ivar;
+
+  data = (Class_Data *)form;
+
+  data->super_expr = scheme_link_expr(data->super_expr, info);
+  
+  for (i = data->num_interfaces; i--; )
+    data->interface_exprs[i] = scheme_link_expr(data->interface_exprs[i], info);
+
+  i = data->closure_size;
+  info = scheme_link_info_extend(info, 0, 0, i);
+  while (i--) {
+    int pos = data->closure_map[i], flags;
+    data->closure_map[i] = scheme_link_info_lookup(info, pos, &flags);
+    scheme_link_info_add_mapping(info, pos, i, flags);
+  }
+
+  i = data->num_private;
+  info = scheme_link_info_extend(info, i, i, i);
+  while (i--)
+    scheme_link_info_add_mapping(info, i, i, SCHEME_INFO_BOXED);
+
+  i = data->num_ref;
+  info = scheme_link_info_extend(info, i, i, i);
+  while (i--)
+    scheme_link_info_add_mapping(info, i, i, SCHEME_INFO_BOXED);
+
+  i = data->num_ivar;
+  info = scheme_link_info_extend(info, i, i, i);
+  while (i--)
+    scheme_link_info_add_mapping(info, i, i, SCHEME_INFO_BOXED);
+
+  i = data->num_arg_vars + 2;
+  info = scheme_link_info_extend(info, i, i, i);
+  while (i--)
+    scheme_link_info_add_mapping(info, i, i, SCHEME_INFO_BOXED);
+
+  for (ivar = data->ivars; ivar; ivar = ivar->next) {
+    switch(ivar->vartype) {
+    case varPUBLIC:
+    case varPRIVATE:
+    case varNOTHING:
+    case varINPUT:
+      ivar->u.value = scheme_link_expr(ivar->u.value, info);
+      break;
+    case varINHERIT:
+    case varRENAME:
+      break;
+    }
+  }
+
+  return scheme_make_syntax_link(DefineClass_Execute, 
+				 (Scheme_Object *)data);
+}
+
+static void InitData(Class_Data *data)
+{
+  ClassVariable *item;
+  int pub_index = 0, ref_index = 0, priv_index = 0;
+  int input_index;
+  
+  input_index = data->num_arg_vars;
+  for (item = data->ivars; item; item = item->next) {
+    if (SCHEME_PAIRP(item->name))
+      item->name = IVAR_EXT_NAME(item);
+
+    if (ispublic(item)) {
+      item->index = pub_index++;
+    } else if (isref(item)) {
+      item->index = ref_index++;
+    } else if (isprivate(item)) {
+      item->index = priv_index++;
+    } else if (isinput(item)) {
+      item->index = --input_index;
+    }
+  }
+
+  data->num_ivar = pub_index;
+  data->num_private = priv_index;
+  data->num_ref = ref_index;
+
+  data->num_cmethod = 0;
+  data->cmethod_names = NULL;
+  data->cmethods = NULL;
+
+  data->ivar_names = NULL;
+  
+  InsureNamesReady(data->ivars, data->num_ivar, &data->ivar_names);
+}
+
+static Scheme_Object *Do_DefineClass(Scheme_Object *form, Scheme_Comp_Env *env,
+				     Scheme_Compile_Info *rec, int depth)
+{
+#define BAD_MSG ": bad syntax in class definition"
+
+  DupCheckRecord *r, *er, drec, erec;
+  Scheme_Object *l, *superclass, *vars, *tag;
+  Scheme_Object *superinitname, **interfaces;
+  Scheme_Object *pub, *priv, *ref, *objl;
+  ClassVariable *ivars = NULL, *next = NULL;
+  Scheme_Object *make_args, *thisname;
+  Scheme_Comp_Env *pubenv, *prienv, *refenv, *objenv, *firstenv;
+  Class_Data *data;
+  ClassVariable *item;
+  int num_args, num_required_args, num_arg_vars, num_interfaces;
+
+  drec.scheck_size = 0;
+  erec.scheck_size = 0;
+
+  l = SCHEME_CDR(form);
+
+  if (!SCHEME_LISTP(l))
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, NULL);
+  if (SCHEME_NULLP(l))
+    scheme_wrong_syntax(CLASS_STAR_W_NAMES, NULL, form, 
+			"missing this/super-init specification");
+    
+  vars = SCHEME_CAR(l);
+  if (!SCHEME_PAIRP(vars))
+    scheme_wrong_syntax(CLASS_STAR_W_NAMES, NULL, form, 
+			"bad this/super-init specification");
+  thisname = SCHEME_CAR(vars);
+  scheme_check_identifier(CLASS_STAR_W_NAMES, thisname, NULL, env, form);
+
+  vars = SCHEME_CDR(vars);
+  if (!SCHEME_PAIRP(vars))
+    scheme_wrong_syntax(CLASS_STAR_W_NAMES, NULL, form, 
+			"bad this/super-init specification");
+  superinitname = SCHEME_CAR(vars);
+  scheme_check_identifier(CLASS_STAR_W_NAMES, superinitname, NULL, env, form);
+      
+  vars = SCHEME_CDR(vars);
+  if (!SCHEME_NULLP(vars))
+    scheme_wrong_syntax(CLASS_STAR_W_NAMES, NULL, form, 
+			"bad this/super-init specification (extra syntax after %s)",
+			scheme_symbol_name(superinitname));
+
+  l = SCHEME_CDR(l);
+
+  if (!SCHEME_LISTP(l))
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, NULL);
+  if (SCHEME_NULLP(l))
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, 
+			"missing superclass specification");
+  superclass = SCHEME_CAR(l);
+  
+  l = SCHEME_CDR(l);
+
+  if (!SCHEME_LISTP(l))
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, NULL);
+  if (SCHEME_NULLP(l))
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, 
+			"missing interfaces specification");
+
+  num_interfaces = 0;
+  {
+    Scheme_Object *il = SCHEME_CAR(l);
+
+    while (SCHEME_PAIRP(il)) {
+      num_interfaces++;
+      il = SCHEME_CDR(il);
+    }
+
+    if (!SCHEME_NULLP(il)) {
+      scheme_wrong_syntax(CLASS_STAR, il, form, 
+			  "bad interfaces specification");
+    }
+
+    if (num_interfaces) {
+      int i;
+      interfaces = MALLOC_N(Scheme_Object*, num_interfaces);
+      il = SCHEME_CAR(l);
+      for (i = 0; i < num_interfaces; i++, il = SCHEME_CDR(il))
+	interfaces[i] = SCHEME_CAR(il);
+    } else
+      interfaces = NULL;
+  }
+
+  l = SCHEME_CDR(l);
+
+  num_args = num_arg_vars = num_required_args = 0;
+  if (SCHEME_PAIRP(l)) {
+    int found_nonrequired = 0;
+    Scheme_Object *args = SCHEME_CAR(l);
+
+    l = SCHEME_CDR(l);
+
+    make_args = args;
+
+    while (!SCHEME_NULLP(args)) {
+      if (SCHEME_SYMBOLP(args)) {
+	args = scheme_null;
+	num_args = -1;
+      } else {
+	Scheme_Object *v;
+
+	if (!SCHEME_PAIRP(args))
+	  scheme_wrong_syntax(CLASS_STAR, args, form, 
+			      "bad syntax in argument list");
+
+	v = SCHEME_CAR(args);
+	if (SCHEME_SYMBOLP(v)) {
+	  if (found_nonrequired)
+	    scheme_wrong_syntax(CLASS_STAR, v, form, 
+				"bad syntax in argument list");
+	  num_required_args++;
+	} else {
+	  if (!SCHEME_PAIRP(v) || !SCHEME_SYMBOLP(SCHEME_CAR(v)))
+	    scheme_wrong_syntax(CLASS_STAR, v, form, 
+				"bad syntax in argument list");
+	  found_nonrequired = 1;
+	}
+	args = SCHEME_CDR(args);
+	num_args++;
+      }
+      num_arg_vars++;
+    }
+
+    next = ReadItemList("arguments", make_args, varINPUT, next, &ivars, form);
+  } else {
+    scheme_wrong_syntax(CLASS_STAR, NULL, form, 
+			"missing argument list");
+    return scheme_void;
+  }
+
+  while (1) {
+    if (!SCHEME_LISTP(l))
+      scheme_wrong_syntax(CLASS_STAR, l, form, NULL);
+
+    if (SCHEME_NULLP(l))
+      break;
+    vars = SCHEME_CAR(l);
+
+    if (!SCHEME_PAIRP(vars))
+      scheme_wrong_syntax(CLASS_STAR, vars, form, NULL);
+
+    tag = SCHEME_CAR(vars);
+    vars = SCHEME_CDR(vars);
+
+    if (SAME_OBJ(tag, seq_symbol)) {
+      Scheme_Object *l = vars;
+      while (SCHEME_PAIRP(l))
+	l = SCHEME_CDR(l);
+      if (!SCHEME_NULLP(l))
+	scheme_wrong_syntax(CLASS_STAR, l, form, 
+			    "bad syntax in sequence clause"
+			    " (" IMPROPER_LIST_FORM ")");
+      
+      next = ReadItemList("sequence", vars, varNOTHING, next, &ivars, form);
+    } else if (SAME_OBJ(tag, pub_symbol)) {
+      CheckIvarList(tag, vars, check_CanRename, form);
+      next = ReadItemList("public", vars, varPUBLIC, next, &ivars, form);
+    } else if (SAME_OBJ(tag, pri_symbol)) {
+      CheckIvarList(tag, vars, 0, form);
+      next = ReadItemList("private", vars, varPRIVATE, next, &ivars, form);
+    } else if (SAME_OBJ(tag, inh_symbol)) {
+      CheckIvarList(tag, vars, check_CanRename | check_MustId, form);
+      next = ReadItemList("inherit", vars, varINHERIT, next, &ivars, form);
+    } else if (SAME_OBJ(tag, ren_symbol)) {
+      CheckIvarList(tag, vars, check_MustPair | check_BindingMustId, form);
+      next = ReadItemList("rename", vars, varRENAME, next, &ivars, form);
+    } else {
+      if (SCHEME_SYMBOLP(tag))
+	scheme_wrong_syntax(CLASS_STAR, tag, form, 
+			    "bad syntax (bad clause keyword)");
+      else
+	scheme_wrong_syntax(CLASS_STAR, tag, form, 
+			    "bad syntax (clause keyword missing)");
+    } 
+
+    l = SCHEME_CDR(l);
+  }
+
+  /* Get lists of names (preserves order) */
+  pub = GetNames(ivars, 1, 0, 0, NULL);
+  priv = GetNames(ivars, 0, 1, 0, NULL);
+  ref = GetNames(ivars, 0, 0, 1, NULL);
+
+  prienv = scheme_add_compilation_frame(priv, env, SCHEME_LAMBDA_FRAME | SCHEME_AUTO_UNBOX);
+  firstenv = prienv;
+  refenv = scheme_add_compilation_frame(ref, prienv, SCHEME_AUTO_UNBOX);
+  pubenv = scheme_add_compilation_frame(pub, refenv, SCHEME_AUTO_UNBOX);
+
+  /* References are not settable: */
+  GetNames(ivars, 0, 0, 1, refenv);
+
+  /* Initialize distinct name checks with ivars: */
+  r = scheme_begin_dup_symbol_check(&drec);
+  er = scheme_begin_dup_symbol_check(&erec);
+  item = ivars;
+  while (item) {
+    if (item->vartype != varNOTHING) {
+      scheme_dup_symbol_check(r, CLASS_STAR, IVAR_INT_NAME(item), "internal ivar", form, 0);
+      if (ispublic(item))
+	scheme_dup_symbol_check(er, CLASS_STAR, IVAR_EXT_NAME(item), "external ivar", form, 0);
+    }
+    item = item->next;
+  }
+  
+  /* Add `super-init' */
+  objl = cons(superinitname, scheme_null);
+  scheme_dup_symbol_check(r, CLASS_STAR, superinitname, "ivar", form, 0);
+
+  /* Add `this' */
+  objl = cons(thisname, objl);
+  scheme_dup_symbol_check(r, CLASS_STAR, thisname, "ivar", form, 0);
+
+  /* Add input args (they end up in reverse order in the environment) */
+  item = ivars;
+  while (item && isinput(item)) {
+    objl = cons(item->name, objl);
+    item = item->next;
+  }
+
+  /* scheme_end_dup_symbol_check(); */
+
+  objenv = scheme_add_compilation_frame(objl, pubenv, SCHEME_AUTO_UNBOX);
+
+  if (!rec) {
+    /* Just expanding: */
+    Scheme_Object *first, *last, *il;
+
+    superclass = scheme_expand_expr(superclass, env, depth);
+
+    {
+      int i;
+      for (i = 0; i < num_interfaces; i++)
+	interfaces[i] = scheme_expand_expr(interfaces[i], env, depth);
+      
+      il = scheme_null;
+      for (i = num_interfaces; i--; )
+	il = cons(interfaces[i], il);
+    }
+
+    l = SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(form)))));
+    first = scheme_null;
+    last = NULL;
+    while (!SCHEME_NULLP(l)) {
+      vars = SCHEME_CAR(l);
+
+      tag = SCHEME_CAR(vars);
+
+      if (SAME_OBJ(tag, pub_symbol) 
+	  || SAME_OBJ(tag, pri_symbol))
+	vars = expandall(vars, objenv, depth, 1, NULL);
+      else if (SAME_OBJ(tag, seq_symbol))
+	vars = cons(tag, scheme_expand_list(SCHEME_CDR(vars), objenv, depth));
+      else if (SAME_OBJ(tag, inh_symbol) 
+	       || SAME_OBJ(tag, ren_symbol)) {
+	vars = vars;
+      } else
+	break;
+
+      vars = cons(vars, scheme_null);
+
+      if (!last)
+	first = vars;
+      else
+	SCHEME_CDR(last) = vars;
+
+      last = vars;
+      l = SCHEME_CDR(l);
+    }
+
+    return cons(class_star_symbol, 
+		cons(cons(thisname, 
+			  cons(superinitname, scheme_null)),
+		     cons(superclass,
+			  cons(il,
+			       cons(make_args, first)))));
+  } else {
+    /* Compiling: */
+    Scheme_Compile_Info lam;
+    Scheme_Compile_Info *recs;
+
+    data = MALLOC_ONE_TAGGED(Class_Data);
+    data->type = scheme_class_data_type;
+
+    data->defname = rec->value_name;
+    scheme_compile_rec_done_local(rec);
+
+    recs = MALLOC_N(Scheme_Compile_Info, num_interfaces + 1);
+    scheme_init_compile_recs(rec, recs, num_interfaces + 1);
+
+    data->super_init_name = superinitname;
+    data->super_expr = scheme_compile_expr(superclass, env, recs);
+    
+    {
+      int i;
+      for (i = 0; i < num_interfaces; i++)
+	interfaces[i] = scheme_compile_expr(interfaces[i], env, recs + i + 1);
+    }
+
+    data->num_interfaces = num_interfaces;
+    data->interface_exprs = interfaces;
+
+    scheme_merge_compile_recs(rec, recs, num_interfaces + 1);
+
+    scheme_init_lambda_rec(rec, &lam);
+  
+    CompileItemList(form, ivars, objenv, data, &lam);
+
+    scheme_merge_lambda_rec(rec, &lam);
+
+    data->ivars = ivars;
+
+    data->num_args = num_args;
+    data->num_required_args = num_required_args;
+    data->num_arg_vars = num_arg_vars;
+
+    InitData(data);
+
+    data->max_let_depth = (lam.max_let_depth
+			   + data->num_arg_vars
+			   + data->num_ivar
+			   + data->num_private
+			   + data->num_ref
+			   + 2); /* this + super-init = 2 */
+
+    scheme_env_make_closure_map(firstenv, &data->closure_size, &data->closure_map);
+
+    return scheme_make_syntax_compile(DefineClass_Link, 
+				      (Scheme_Object *)data);
+  }
+}
+
+static Scheme_Object *DefineClass(Scheme_Object *form, Scheme_Comp_Env *env,
+				  Scheme_Compile_Info *rec)
+{
+  return Do_DefineClass(form, env, rec, 0);
+}
+
+static Scheme_Object *DefineClass_expand(Scheme_Object *form, Scheme_Comp_Env *env,
+					 int depth)
+{
+  return Do_DefineClass(form, env, NULL, depth);
+}
+
+/**********************************************************************/
+
+static Scheme_Object *CV_Bundle(ClassVariable *cvar)
+{
+  Scheme_Object *l = scheme_null, *f;
+
+  while (cvar) {
+    if (isref(cvar))
+      f = cvar->u.source.name;
+    else
+      f = cvar->u.value;
+    l = cons(_IVAR_EXT_NAME(cvar),
+	     cons(scheme_make_integer(cvar->vartype),
+		  cons(f, l)));
+    cvar = cvar->next;
+  }
+
+  return l;
+}
+
+#define BAD_CCD "bad compiled class definition"
+
+static ClassVariable *CV_Unbundle(Scheme_Object *l)
+{
+  ClassVariable *cvar = NULL, *prev;
+  Scheme_Object *v;
+
+  while (!SCHEME_NULLP(l)) {
+    prev = cvar;
+    cvar = MALLOC_ONE(ClassVariable);
+    cvar->next = prev;
+
+    cvar->name = SCHEME_CAR(l);
+    l = SCHEME_CDR(l);
+
+    cvar->vartype = SCHEME_INT_VAL(SCHEME_CAR(l));
+    l = SCHEME_CDR(l);
+
+    v = SCHEME_CAR(l);
+    if (isref(cvar)) {
+     cvar->u.source.name = v;
+    } else
+      cvar->u.value = v;
+    l = SCHEME_CDR(l);
+  }
+
+  return cvar;
+}
+
+static Scheme_Object *write_Class_Data(Scheme_Object *obj)
+{
+  Class_Data *data;
+  int i;
+  Scheme_Object *l = scheme_null;
+
+  data = (Class_Data *)obj;
+  
+  for (i = 0; i < data->num_interfaces; i++)
+    l = cons(data->interface_exprs[i], l);
+
+  return cons(CV_Bundle(data->ivars),
+	      cons(data->super_expr,
+		   cons(data->super_init_name,
+			cons(scheme_make_integer(data->num_args),
+			     cons(scheme_make_integer(data->num_required_args),
+				  cons(scheme_make_integer(data->num_arg_vars),
+				       cons(scheme_make_integer(data->max_let_depth),
+					    cons(scheme_make_svector(data->closure_size,
+								     data->closure_map),
+						 cons(data->defname
+						      ? data->defname
+						      : scheme_null,
+						      cons(scheme_make_integer(data->num_interfaces),
+							   l))))))))));
+}
+
+static Scheme_Object *read_Class_Data(Scheme_Object *obj)
+{
+  Scheme_Object *v;
+  Class_Data *data;
+  int i;
+
+  data = MALLOC_ONE_TAGGED(Class_Data);
+  data->type = scheme_class_data_type;
+
+  data->ivars = CV_Unbundle(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->super_expr = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+
+  data->super_init_name = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  
+  data->num_args = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->num_required_args = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->num_arg_vars = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->max_let_depth = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+
+  data->closure_size = SCHEME_SVEC_LEN(v);
+  data->closure_map = SCHEME_SVEC_VEC(v);
+  
+  data->defname = SCHEME_CAR(obj);
+  if (SCHEME_NULLP(data->defname))
+    data->defname = 0;
+  obj = SCHEME_CDR(obj);
+
+  data->num_interfaces = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  data->interface_exprs = MALLOC_N(Scheme_Object*, data->num_interfaces);
+
+  for (i = data->num_interfaces; i--; ) {
+    data->interface_exprs[i] = SCHEME_CAR(obj);
+    obj = SCHEME_CDR(obj);
+  }
+
+  InitData(data);
+
+  return (Scheme_Object *)data;
+}
+
+static Scheme_Object *write_Interface_Data(Scheme_Object *obj)
+{
+  Interface_Data *data;
+  int i;
+  Scheme_Object *l = scheme_null;
+
+  data = (Interface_Data *)obj;
+  
+  for (i = 0; i < data->num_supers; i++)
+    l = cons(data->super_exprs[i], l);
+
+  for (i = 0; i < data->num_names; i++)
+    l = cons(data->names[i], l);
+  
+  return cons(scheme_make_integer(data->num_names),
+	      cons(scheme_make_integer(data->num_supers),
+		   cons(data->defname
+			? data->defname
+			: scheme_null,
+			l)));
+}
+
+static Scheme_Object *read_Interface_Data(Scheme_Object *obj)
+{
+  Interface_Data *data;
+  int i;
+
+  data = MALLOC_ONE_TAGGED(Interface_Data);
+  data->type = scheme_interface_data_type;
+
+  data->num_names = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->num_supers = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  data->defname = SCHEME_CAR(obj);
+  if (SCHEME_NULLP(data->defname))
+    data->defname = 0;
+  obj = SCHEME_CDR(obj);
+
+  data->names = MALLOC_N(Scheme_Object*, data->num_names);
+  data->super_exprs = MALLOC_N(Scheme_Object*, data->num_supers);
+
+  for (i = data->num_names; i--; obj = SCHEME_CDR(obj))
+    data->names[i] = SCHEME_CAR(obj);
+
+  for (i = data->num_supers; i--; obj = SCHEME_CDR(obj))
+    data->super_exprs[i] = SCHEME_CAR(obj);
+
+  /* Sort names: */
+  qsort((char *)data->names, data->num_names,
+	sizeof(Scheme_Object *), 
+	(int (*)(const void *, const void *))CompareObjectPtrs); 
+
+  return (Scheme_Object *)data;
+}
+
+/**********************************************************************/
+
+Scheme_Object *scheme_make_class(const char *name, Scheme_Object *sup, 
+				 Scheme_Method_Prim *initf, int num_methods)
+{
+  Scheme_Class *sclass, *superclass;
+  int i;
+
+  if (sup && !SCHEME_CLASSP(sup))
+    scheme_signal_error("make-prim-class: bad superclass");
+
+  sclass = MALLOC_ONE_TAGGED(Scheme_Class);
+
+  if (!sup)
+    sup = NullClass();
+
+  superclass = (Scheme_Class *)sup;
+
+  InstallHeritage(sclass, superclass);
+
+  num_methods += superclass->num_public;
+
+  sclass->num_public = num_methods;
+  sclass->public_names = MALLOC_N(Scheme_Object*, num_methods);
+  sclass->cmethods = MALLOC_N(CMethod*, num_methods);
+  sclass->cmethod_ready_level = MALLOC_N_ATOMIC(short, num_methods);
+  sclass->cmethod_source_map = MALLOC_N_ATOMIC(short, num_methods);
+  sclass->public_map = MALLOC_N_ATOMIC(short, num_methods);
+  sclass->contributes_cmethods = 0;
+
+  /* Copy superclass methods: */
+  for (i = superclass->num_public; i--; ) {
+    sclass->public_names[i] = superclass->public_names[i];
+    sclass->cmethods[i] = superclass->cmethods[i];
+    sclass->cmethod_ready_level[i] = superclass->cmethod_ready_level[i];
+    sclass->cmethod_source_map[i] = -1;
+    sclass->public_map[i] = superclass->public_map[i];
+  }
+  sclass->num_private = superclass->num_public;
+
+  sclass->super_init_name = NULL;
+
+  sclass->ivars = NULL;
+
+  sclass->type = scheme_class_type;
+
+  sclass->priminit = pi_CPP;
+  sclass->piu.initf = (Scheme_Closed_Prim *)initf;
+
+  sclass->num_args = -1; /* Irrelevant; really defined by initf */
+  sclass->num_required_args = -1;
+  sclass->num_arg_vars = -1;
+
+  sclass->num_ref = 0;
+  sclass->num_ivar = 0;
+  sclass->num_slots = EXTRA_PRIM_SLOTS;
+
+  sclass->closure_size = 0;
+  sclass->closure_saved = NULL;
+  sclass->max_let_depth = 0;
+
+  sclass->defname = scheme_intern_symbol(name);
+
+  return (Scheme_Object *)sclass;
+}
+
+static const char *get_class_name(Scheme_Object *sclass, const char *mode)
+{
+  Scheme_Class *c = (Scheme_Class *)sclass;
+  const char *cl, *dn;
+  char *r;
+  int size;
+
+  if (c->defname) {
+    dn = scheme_symbol_name(c->defname);
+    cl = NULL;
+  } else {
+    dn = NULL;
+    cl = NULL;
+    while (c) {
+      c = c->superclass;
+      if (c && c->defname) {
+	cl = scheme_symbol_name(c->defname);
+	break;
+      }
+    }
+  }
+
+  if (!cl && !dn)
+    return "";
+
+  size = (mode ? strlen(mode) : 0) + (cl ? strlen(cl) : 0) + (dn ? strlen(dn) : 0) + 20;
+  r = (char *)scheme_malloc_atomic(size);
+  
+  sprintf(r, "%s%s%s%s",
+	  mode ? mode : "",
+	  dn ? dn : "",
+	  cl ? "derived from " : "",
+	  cl ? cl : "");
+
+  return r;
+}
+
+static const char *get_interface_name(Scheme_Object *i, const char *mode)
+{
+  Scheme_Object *n;
+
+  n = ((Scheme_Interface *)i)->defname;
+  if (n) {
+    const char *name;
+    char *s;
+    int len;
+    int mlen = strlen(mode);
+
+    name = scheme_symbol_name(n);
+    len = strlen(name);
+    s = (char *)scheme_malloc_atomic(len + mlen + 1);
+    memcpy(s, mode, mlen);
+    memcpy(s + mlen, name, len);
+    s[len + mlen] = 0;
+
+    return s;
+  } else
+    return "";
+}
+
+const char *scheme_get_class_name(Scheme_Object *c, int *len)
+{
+  Scheme_Object *n;
+
+  if (!SCHEME_CLASSP(c))
+    return NULL;
+
+  n = ((Scheme_Class *)c)->defname;
+  if (n) {
+    *len = SCHEME_SYM_LEN(n);
+    return SCHEME_SYM_VAL(n);
+  } else
+    return NULL;
+}
+
+const char *scheme_get_interface_name(Scheme_Object *i, int *len)
+{
+  Scheme_Object *n;
+
+  if (!SCHEME_INTERFACEP(i))
+    return NULL;
+
+  n = ((Scheme_Interface *)i)->defname;
+  if (n) {
+    *len = SCHEME_SYM_LEN(n);
+    return SCHEME_SYM_VAL(n);
+  } else
+    return NULL;
+}
+
+void scheme_add_method_w_arity(Scheme_Object *c, const char *name,
+			       Scheme_Method_Prim *f, 
+			       int mina, int maxa)
+{
+  Scheme_Object *s;
+  Scheme_Class *sclass;
+  CMethod *cmethod;
+  int len, len2, i, count;
+
+  if (!SCHEME_CLASSP(c))
+    return;
+  
+  sclass = (Scheme_Class *)c;
+
+  if (sclass->num_private >= sclass->num_public)
+    scheme_signal_error("add-prim-method: added too many methods");
+
+  cmethod = MALLOC_ONE(CMethod);
+  cmethod->f = (Scheme_Closed_Prim *)f;
+  cmethod->mina = mina;
+  cmethod->maxa = maxa;
+
+  len = SCHEME_SYM_LEN(sclass->defname);
+  len2 =  strlen(name);
+  cmethod->closed_name = (char *)scheme_malloc_atomic(len + len2 + 3);
+  memcpy(cmethod->closed_name, SCHEME_SYM_VAL(sclass->defname), len);
+  cmethod->closed_name[len] = ':';
+  cmethod->closed_name[len + 1] = ':';
+  memcpy(cmethod->closed_name + len + 2, name, len2);
+  cmethod->closed_name[len + len2 + 2] = 0;
+
+  s = scheme_intern_symbol(name);
+
+  count = sclass->num_private;
+
+  for (i = 0; i <= count; i++) {
+    if ((i == count) || SLESSTHAN(s, sclass->public_names[i])) {
+      /* Insert here: */
+      int j;
+      for (j = sclass->num_private; j > i; --j) {
+	sclass->public_names[j] = sclass->public_names[j - 1];
+	sclass->public_map[j] = sclass->public_map[j - 1];
+      }
+      sclass->public_names[i] = s;
+      sclass->public_map[i] = count;
+      sclass->cmethods[count] = cmethod;
+      sclass->cmethod_ready_level[count] = sclass->pos;
+      sclass->cmethod_source_map[count] = sclass->contributes_cmethods;
+      sclass->num_private++;
+      break;
+    } else if (SEQUALS(s, sclass->public_names[i])) {
+      /* Override */
+      int cindex = sclass->public_map[i];
+      sclass->cmethods[cindex] = cmethod;
+      sclass->cmethod_ready_level[cindex] = sclass->pos;
+      sclass->cmethod_source_map[cindex] = sclass->contributes_cmethods;
+      break;
+    }
+  }
+
+  sclass->contributes_cmethods++;
+}
+
+void scheme_add_method(Scheme_Object *c, const char *name,
+		       Scheme_Method_Prim *f)
+{
+  scheme_add_method_w_arity(c, name, f, 0, -1);
+}
+
+void scheme_made_class(Scheme_Object *c)
+{
+  Scheme_Class *sclass;
+  int i, num_methods;
+
+  sclass = (Scheme_Class *)c;
+
+  num_methods = sclass->num_private;
+  sclass->num_private = 0;
+  sclass->num_public = num_methods;
+
+  sclass->vslot_map = MALLOC_N_ATOMIC(short, num_methods);
+  sclass->vslot_kind = MALLOC_N_ATOMIC(slotkind, num_methods);
+
+  for (i = 0; i < num_methods; i++) {
+    sclass->vslot_map[i] = i;
+    sclass->vslot_kind[i] = slot_TYPE_CMETHOD;
+  }
+}
+
+/**********************************************************************/
+
+Scheme_Class_Assembly *
+scheme_make_class_assembly(const char *name, int num_interfaces,
+			   int n_public, Scheme_Object **publics,
+			   int n_inh, Scheme_Object **inheriteds,
+			   int n_ren, Scheme_Object **renames,
+			   int mina, int maxa,
+			   Scheme_Instance_Init_Proc *initproc)
+{
+  Scheme_Class_Assembly *a;
+  int i;
+  ClassVariable *v, *last = NULL;
+
+  a = MALLOC_ONE(Scheme_Class_Assembly);
+  
+  a->mina = mina;
+  a->maxa = maxa;
+  a->init = initproc;
+
+  for (i = 0; i < n_public; i++) {
+    v = MALLOC_ONE(ClassVariable);
+
+    v->vartype = varPUBLIC;
+    v->name = publics[i];
+    v->u.value = scheme_undefined;
+    v->next = last;
+
+    last = v;
+  }
+
+  for (i = 0; i < n_inh; i++) {
+    v = MALLOC_ONE(ClassVariable);
+
+    v->vartype = varINHERIT;
+    
+    v->name = inheriteds[i];
+    v->u.source.name = inheriteds[i];
+    v->next = last;
+
+    last = v;
+  }
+
+  for (i = 0; i < n_ren; i++) {
+    v = MALLOC_ONE(ClassVariable);
+
+    v->vartype = varRENAME;
+    
+    v->name = renames[i];
+    v->u.source.name = renames[i];
+    v->next = last;
+
+    last = v;
+  }
+
+  a->data.type = 0;
+
+  a->data.ivars = last;
+
+  a->data.num_args = a->data.num_required_args = a->data.num_arg_vars = 0;
+  
+  a->data.super_init_name = NULL;
+
+  a->data.num_interfaces = num_interfaces;
+
+  a->data.defname = (name ? scheme_intern_symbol(name) : NULL);
+
+  InitData(&a->data);
+
+  return a;
+}
+
+Scheme_Object *scheme_create_class(Scheme_Class_Assembly *a,
+				   void *data,
+				   Scheme_Object *super,
+				   Scheme_Object **interfaces)
+{
+  Scheme_Object *o;
+  Scheme_Class *cl;
+
+  if (super)
+    a->data.super_expr = super;
+  else
+    a->data.super_expr = NullClass();
+
+  a->data.interface_exprs = interfaces;
+
+  o = _DefineClass_Execute((Scheme_Object *)&a->data, TRUE);
+
+  cl = (Scheme_Class *)o;
+  if (cl->priminit == pi_NOT)
+    cl->priminit = pi_COMP;
+  else
+    cl->priminit = pi_COMP_OVER_CPP;
+  cl->piu.insti.f = a->init;
+  cl->piu.insti.data = data;
+
+  cl->num_required_args = a->mina;
+  cl->num_args = a->maxa;
+
+  return o;
+}
+
+Scheme_Interface_Assembly *
+scheme_make_interface_assembly(const char *name, int n_supers, int n_names, Scheme_Object **names)
+{
+  Scheme_Interface_Assembly *a = MALLOC_ONE(Scheme_Interface_Assembly);
+  int i;
+
+  a->data.num_names = n_names;
+  a->data.names = MALLOC_N(Scheme_Object *, n_names);
+  for (i = n_names; i--; )
+    a->data.names[i] = names[i];
+
+  a->data.num_supers = n_supers;
+  a->data.defname = (name ? scheme_intern_symbol(name) : NULL);
+
+  /* Sort names: */
+  qsort((char *)a->data.names, n_names,
+	sizeof(Scheme_Object *), 
+	(int (*)(const void *, const void *))CompareObjectPtrs); 
+
+  return a;
+}
+
+Scheme_Object *scheme_create_interface(Scheme_Interface_Assembly *a,
+				       Scheme_Object **supers)
+{
+  a->data.super_exprs = supers;
+
+  return Interface_Execute((Scheme_Object *)&a->data);
+}
+
+
+/**********************************************************************/
+
+static Scheme_Object *CloseMethod(CMethod *cmethod, Internal_Object *obj)
+{
+  return scheme_make_closed_prim_w_arity(cmethod->f,
+					 (void *)obj,
+					 cmethod->closed_name,
+					 cmethod->mina,
+					 cmethod->maxa);
+}
+
+static int DoFindName(int num_public, Scheme_Object **pn, Scheme_Object *symbol)
+{
+  int p, w, o;
+  Scheme_Object *n;
+
+  if (!num_public)
+    return -1;
+
+  o = 0;
+  p = num_public >> 1;
+  w = num_public;
+
+  while (1) {
+    n = pn[p];
+    if (SAME_OBJ(n, symbol))
+      return p;
+    if (w == 1)
+      return -1;
+    if (((long)n) < ((long)symbol)) {
+      w = o + w - p;
+      o = p;
+    } else
+      w = p - o;
+    p = o + (w >> 1);
+  }
+
+  return p;
+}
+
+static Scheme_Object *GetIvar(Internal_Object *obj, Init_Object_Rec *irec, Scheme_Object **slots, 
+			      Scheme_Class *oclass, Scheme_Class *mclass, short vp,
+			      int boxed, int force)
+{
+  if (mclass->vslot_kind[vp] == slot_TYPE_IVAR) {
+    Scheme_Object *v = slots[oclass->vslot_map[vp]];
+    if (boxed)
+      return v;
+    else
+      return SCHEME_ENVBOX_VAL(v);
+  } else {
+    if (!force)
+      return NULL;
+    else {
+      /* A cmethod - close it or cache a box */
+      if (irec) {
+	int level = mclass->cmethod_ready_level[mclass->vslot_map[vp]];
+	Scheme_Class *sclass = oclass->heritage[level];
+	Init_Frame *frame = irec->frames + level;
+	int cindex = sclass->vslot_map[vp];
+	int lpos = sclass->cmethod_source_map[cindex];
+
+	if (!frame->cmethods)
+	  frame->cmethods = MALLOC_N(Scheme_Object*, sclass->contributes_cmethods);
+
+	if (!frame->cmethods[lpos]) {
+	  Scheme_Object *box;
+
+	  if (irec->init_level > level) {
+	    /* Not ready yet; return #<undefined> for now. */
+	    box = scheme_make_envunbox(scheme_undefined);
+	  } else
+	    box = scheme_make_envunbox(CloseMethod(sclass->cmethods[cindex], obj));
+	  
+	  frame->cmethods[lpos] = box;
+	}
+
+	if (boxed)
+	  return frame->cmethods[lpos];
+	else
+	  return SCHEME_ENVBOX_VAL(frame->cmethods[lpos]);
+      } else {
+	Scheme_Object *m = CloseMethod(mclass->cmethods[mclass->vslot_map[vp]], obj);
+	if (boxed)
+	  return scheme_make_envunbox(m);
+	else
+	  return m;
+      }
+    }
+  }
+}
+
+static void BuildObjectFrame(Internal_Object *obj,
+			     Init_Object_Rec *irec,
+			     Scheme_Class *oclass,
+			     Scheme_Class *sclass,
+			     Init_Frame *frame,
+			     Scheme_Object **slots)
+{
+  /* Called when object is created (before initialization) for each class,
+     least-specific class first. */
+  ClassVariable *cvar;
+  Scheme_Object *box;
+  Scheme_Object **ivars, **refs;
+
+  if (sclass->num_ivar)
+    ivars = MALLOC_N(Scheme_Object*, sclass->num_ivar);
+  else
+    ivars = NULL;
+  frame->ivars = ivars;
+  
+  if (sclass->num_ref)
+    refs = MALLOC_N(Scheme_Object*, sclass->num_ref);
+  else
+    refs = NULL;
+  frame->refs = refs;
+
+  for (cvar = sclass->ivars; cvar; cvar = cvar->next) {
+    if (ispublic(cvar)) {
+      box = scheme_make_envunbox(scheme_undefined);
+      slots[oclass->vslot_map[sclass->ivar_map[cvar->index]]] = box;
+      ivars[cvar->index] = box;
+    } else if (isprivref(cvar)) {
+      Scheme_Class *superclass = sclass->superclass;
+      int vp = sclass->ref_map[cvar->index];
+      /* If the superclass's ivar is a cmethod, the box will contain
+	 #<undefined>. */
+      refs[cvar->index] = GetIvar(obj, irec, slots, oclass, superclass, vp, 1, 1);
+    }
+  }
+}
+
+static Init_Object_Rec *CreateObjectFrames(Internal_Object *obj, Scheme_Class *sclass)
+{
+  /* Called when object is created (before initialization) */
+  Init_Frame *frames;
+  Scheme_Object **slots;
+  Init_Object_Rec *irec;
+  int i;
+
+  slots = obj->slots;
+  irec = (Init_Object_Rec *)scheme_malloc(sizeof(Init_Object_Rec)
+					  + (sclass->pos /* for +1 total */
+					     * sizeof(Init_Frame)));
+  frames = irec->frames;
+
+  irec->init_level = sclass->pos + 1;
+
+  for (i = 0; i <= sclass->pos; i++)
+    BuildObjectFrame(obj, irec, sclass, sclass->heritage[i], frames + i, slots);
+
+  return irec;
+}
+
+
+static void
+PushFrameVariables(Internal_Object *o, Init_Object_Rec *irec, Scheme_Class *sclass, 
+		   Init_Frame *frame, Scheme_Process *p,
+		   Scheme_Object ***_priv_stack, Scheme_Object ***_obj_stack)
+{
+  /* Called at start of class-specific initialization */
+  Scheme_Object **priv_stack, **pub_stack, **ref_stack, **obj_stack;
+  Scheme_Object **slots;
+  Scheme_Class *oclass;
+  ClassVariable *cvar;
+  int i, count;
+
+  priv_stack = PUSH_RUNSTACK(p, p->runstack, sclass->num_private);
+  ref_stack = PUSH_RUNSTACK(p, p->runstack, sclass->num_ref);
+  pub_stack = PUSH_RUNSTACK(p, p->runstack, sclass->num_ivar);
+  count = sclass->num_arg_vars + 2;
+  obj_stack = PUSH_RUNSTACK(p, p->runstack, count);
+
+  /* Privates: create boxes: */
+  for (i = sclass->num_private; i--; )
+    priv_stack[i] = scheme_make_envunbox(scheme_undefined);
+
+  /* this & super-init */
+  obj_stack[sclass->num_arg_vars] = scheme_make_envunbox((Scheme_Object *)o);
+  obj_stack[sclass->num_arg_vars + 1] = scheme_make_envunbox(MakeSuperInitPrim(o, irec, sclass->pos - 1));
+  
+  slots = o->slots;
+  cvar = sclass->ivars;
+  oclass = (Scheme_Class *)o->o.sclass;
+
+  /* Push boxes for public ivars & refs onto stack */
+  for (i = 0; cvar; cvar = cvar->next) {
+    if (ispublic(cvar)) {
+      pub_stack[cvar->index] = GetIvar(o, irec, slots, oclass, oclass, sclass->ivar_map[cvar->index], 1, 1);
+    } else if (isprivref(cvar)) {
+      ref_stack[cvar->index] = frame->refs[cvar->index];
+    } else if (isref(cvar)) {
+      Scheme_Object *box;
+      /* If the superclass's ivar is a cmethod, the box will contain
+	 #<undefined>. */
+      box = GetIvar(o, irec, slots, oclass, oclass, sclass->ref_map[cvar->index], 1, 1);
+      frame->refs[cvar->index] = box;
+      ref_stack[cvar->index] = box;
+    }
+  }
+
+  *_obj_stack = obj_stack;
+  *_priv_stack = priv_stack;
+}
+
+/**************************************************************************/
+
+static void SetIVarValues(Init_Frame *frame, /* Frame */
+			  Scheme_Object **priv_stack,
+			  Scheme_Object **obj_stack,
+			  ClassVariable *items,  /* Items to be created */
+			  int pthresh) /* threshold for needed init vals */
+{
+  Scheme_Object *box, *v;
+  int i;
+
+  i = 0;
+  while (items) {
+    if (!isref(items)) {
+      if (ispublic(items))
+	box = frame->ivars[items->index];
+      else
+	box = NULL;
+
+      if (isinput(items))
+	v = items->u.value;
+      else
+	v = _scheme_eval_compiled_expr(items->u.value);
+	  
+      if (isprivate(items)) {
+	box = priv_stack[items->index];
+	SCHEME_ENVBOX_VAL(box) = v;
+      } else if (isinput(items)) {
+	if (items->index < pthresh) {
+	  v = _scheme_eval_compiled_expr(items->u.value);
+	  SCHEME_ENVBOX_VAL(obj_stack[items->index]) = v;
+	}
+      } else if (box)
+	SCHEME_ENVBOX_VAL(box) = v;
+    }
+
+    items = items->next;
+  }
+}
+
+
+/* forward decl */
+static void InitObjectFrame(Internal_Object *o, Init_Object_Rec *irec, int level,
+			    int argc, Scheme_Object *argv[]);
+
+static void *init_obj_frame_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Internal_Object *o = (Internal_Object *)p->ku.k.p1;
+  Scheme_Object **argv = (Scheme_Object **)p->ku.k.p2;
+  Init_Object_Rec *irec = (Init_Object_Rec *)p->ku.k.p3;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+  p->ku.k.p3 = NULL;
+
+  InitObjectFrame(o, irec, p->ku.k.i1, p->ku.k.i2, argv);
+
+  return NULL;
+}
+
+static void InitObjectFrame(Internal_Object *o, Init_Object_Rec *irec, int level,
+			    int argc, Scheme_Object *argv[])
+{
+  int skip_cmethods;
+  int i, j, pthresh;
+  Scheme_Object **priv_stack, **obj_stack, **orig_stack;
+  Scheme_Class *sclass;
+  Init_Frame *frame;
+  Scheme_Process *p = scheme_current_process;
+
+  if (level == -1) {
+    level = irec->init_level;
+    skip_cmethods = 1;
+  } else {
+    if (irec->init_level <= level)
+      return;
+    
+    irec->init_level = level;
+
+    skip_cmethods = 0;
+  }
+
+  orig_stack = p->runstack;
+
+  frame = irec->frames + level;
+  sclass = ((Scheme_Class *)o->o.sclass)->heritage[level];
+
+  if (!skip_cmethods && sclass->contributes_cmethods && frame->cmethods) {
+    /* Fill in any cached boxed */
+    int i;
+    for (i = sclass->num_public; i--; ) {
+      if (sclass->vslot_kind[i] == slot_TYPE_CMETHOD) {
+	int cindex = sclass->vslot_map[i];
+	if (sclass->cmethod_ready_level[cindex] == level) {
+	  int lpos = sclass->cmethod_source_map[cindex];
+	  if (frame->cmethods[lpos])
+	    SCHEME_ENVBOX_VAL(frame->cmethods[lpos])
+	      = CloseMethod(sclass->cmethods[cindex], o);
+	}
+      }
+    }
+  }
+
+  if ((sclass->priminit == pi_NOT) || (sclass->priminit == pi_NOT_OVER_CPP)) {
+    Scheme_Object **stack, **saved;
+    short total;
+
+    i = sclass->closure_size;
+    total = i + sclass->max_let_depth;
+
+    if (!scheme_check_runstack(total)) {
+      p->ku.k.p1 = o;
+      p->ku.k.i1 = -1;
+      p->ku.k.i2 = argc;
+      p->ku.k.p2 = (void *)MALLOC_N(Scheme_Object*, argc);
+      p->ku.k.p3 = irec;
+      for (i = argc; i--; )
+	((Scheme_Object **)p->ku.k.p2)[i] = argv[i];
+
+      (void)scheme_enlarge_runstack(total, init_obj_frame_k);
+      return;
+    }
+
+    saved = sclass->closure_saved;
+    stack = PUSH_RUNSTACK(p, p->runstack, i);
+    while (i--)
+      stack[i] = saved[i];
+
+    PushFrameVariables(o, irec, sclass, frame, scheme_current_process,
+		       &priv_stack, &obj_stack);
+
+    /* Set init arg values in environment: */
+    for (i = sclass->num_arg_vars, j = 0; i--; j++) {
+      if (i < argc) {
+	if (!j && (sclass->num_args < 0)) {
+	  /* Turn rest of args into a list */
+	  int k;
+	  Scheme_Object *l = scheme_null;
+	  
+	  for (k = argc; k-- > i; )
+	    l = cons(argv[k], l);
+	  
+	  obj_stack[j] = scheme_make_envunbox(l);
+	} else {
+#if 0
+	  /* Box everything for now: */
+	  if (i < frame->sclass->num_required_args)
+	    obj_stack[j] = argv[i];
+	  else
+#endif
+	    obj_stack[j] = scheme_make_envunbox(argv[i]);
+	}
+      } else
+	obj_stack[j] = scheme_make_envunbox(scheme_undefined);
+    }
+
+    if (argc > sclass->num_arg_vars)
+      pthresh = 0;
+    else
+      pthresh = sclass->num_arg_vars - argc;
+  } else {
+    pthresh = 0;
+    priv_stack = NULL;
+    obj_stack = NULL;
+  }
+
+  SetIVarValues(frame, priv_stack, obj_stack, sclass->ivars, pthresh);
+
+  p->runstack = orig_stack;
+
+  if (sclass->priminit == pi_CPP) {
+    if (sclass->superclass->pos)
+      InitObjectFrame(o, irec, level - 1, 0, NULL);
+    else
+      irec->init_level = 0;
+  } else if (((sclass->priminit == pi_NOT) || (sclass->priminit == pi_NOT_OVER_CPP)) && (irec->init_level >= level)) {
+    if (sclass->superclass->pos) {
+      const char *cl = get_class_name((Scheme_Object *)sclass, " in class: ");
+
+      scheme_raise_exn(MZEXN_OBJECT_INIT_NEVER,
+		       o, 
+		       sclass->superclass,
+		       CREATE_OBJECT ": initialization did not invoke %s%s",
+		       scheme_symbol_name(sclass->super_init_name),
+		       cl);
+    }
+  }
+}
+
+static Scheme_Object *find_ivar(Internal_Object *obj, 
+				Scheme_Object *name,
+				int force)
+{
+  Scheme_Class *oclass = (Scheme_Class *)obj->o.sclass;
+  int sp, vp;
+
+  sp = FindName(oclass, name);
+  if (sp < 0)
+    return NULL;
+
+  vp = oclass->public_map[sp];
+
+  return GetIvar(obj, NULL, obj->slots, oclass, oclass, vp, 0, force);
+}
+
+Scheme_Object *scheme_find_ivar(Scheme_Object *obj, 
+				Scheme_Object *sym,
+				int force)
+{
+  if (!SCHEME_OBJP(obj))
+    scheme_signal_error("ivar: not an object");
+  if (!SCHEME_SYMBOLP(sym))
+    scheme_signal_error("ivar: not an identifier");
+
+  return find_ivar(((Internal_Object *)obj), sym, force);
+}
+
+static Scheme_Class_Object *allocate_object(Scheme_Class *sclass, Init_Object_Rec **irec)
+{
+  Internal_Object *obj;
+
+  if (!sclass)
+    scheme_signal_error("bad primitive class");
+
+  obj = (Internal_Object *)scheme_malloc_tagged(sizeof(Internal_Object) 
+						+ (sizeof(Scheme_Object *) 
+						   * (sclass->num_slots - 1)));
+
+  obj->o.type = scheme_object_type;
+  obj->o.sclass = (Scheme_Object *)sclass;
+
+  *irec = CreateObjectFrames(obj, sclass);
+  
+  return (Scheme_Class_Object *)obj;
+}
+
+Scheme_Object *scheme_make_uninited_object(Scheme_Object *c)
+{
+  Internal_Object *obj;
+  Scheme_Class *sclass;
+  Init_Object_Rec *irec;
+
+  sclass = (Scheme_Class *)c;
+
+  obj = (Internal_Object *)allocate_object(sclass, &irec);
+  InitObjectFrame(obj, irec, irec->init_level - 1, 0, NULL);
+
+  ((Scheme_Class_Object *)obj)->inited = 1;
+
+  return (Scheme_Object *)&obj->o;
+}
+
+static void CallInitFrame(Internal_Object *o, Init_Object_Rec *irec, int level,
+			  int argc, Scheme_Object *argv[])
+{
+  Scheme_Class *sclass;
+  Scheme_Object *initfunc;
+
+  sclass = ((Scheme_Class *)o->o.sclass)->heritage[level];
+
+  if (!sclass->pos) {
+    irec->init_level = 0;
+    return;
+  }
+
+  if (sclass->priminit != pi_CPP) {
+    if ((argc < sclass->num_required_args)
+	|| ((sclass->num_args >= 0) && (argc > sclass->num_args))) {
+      const char *cl;
+
+      cl = get_class_name((Scheme_Object *)sclass, "initialization for class: ");
+      if (!*cl)
+	cl = "class initialization";
+      scheme_wrong_count(cl, 
+			 sclass->num_required_args,
+			 sclass->num_args,
+			 argc, argv);
+    }
+  }
+  
+  InitObjectFrame(o, irec, level, argc, argv);
+    
+  /* Eval intialization function */
+  if (sclass->priminit == pi_CPP) {
+    if (sclass->piu.initf)
+      initfunc = scheme_make_closed_prim(sclass->piu.initf, o);
+    else
+      initfunc = NULL;
+    
+    if (initfunc) {
+      _scheme_apply_multi(initfunc, argc, argv);
+      ((Scheme_Class_Object *)o)->inited = 1;
+    }
+  } else if ((sclass->priminit == pi_COMP)
+	     || (sclass->priminit == pi_COMP_OVER_CPP)) {
+    int i, c;
+    Scheme_Object *superinit, **public_values, **env_values;
+    ClassVariable *cvar;
+    Scheme_Class *oclass;
+    Init_Frame *frame;
+
+    superinit = MakeSuperInitPrim(o, irec, level - 1);
+
+    oclass = (Scheme_Class *)o->o.sclass;
+    frame = irec->frames + level;
+
+    c = sclass->num_ivar + sclass->num_ref;
+    public_values = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *) * c);
+    env_values = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *) * c);
+    for (cvar = sclass->ivars, i = c; i--; cvar = cvar->next) {
+      if (ispublic(cvar)) {
+	env_values[i] = GetIvar(o, irec, o->slots, oclass, oclass, sclass->ivar_map[cvar->index], 1, 1);
+	public_values[i] = frame->ivars[cvar->index];
+      } else if (isprivref(cvar)) {
+	public_values[i] = frame->refs[cvar->index];
+	env_values[i] = public_values[i];
+      } else if (isref(cvar)) {
+	public_values[i] = GetIvar(o, irec, o->slots, oclass, oclass, sclass->ref_map[cvar->index], 1, 1);
+	env_values[i] = public_values[i];
+      }
+    }
+
+    sclass->piu.insti.f(public_values,
+			env_values,
+			superinit,
+			argc, argv,
+			(Scheme_Object *)o,
+			sclass->piu.insti.data);
+  }
+
+  if (!((sclass->priminit == pi_NOT) || (sclass->priminit == pi_NOT_OVER_CPP))) {
+    if (irec->init_level && (irec->init_level >= level)) {
+      if (sclass->superclass->pos) {
+	const char *cl = get_class_name((Scheme_Object *)sclass, " for class: ");
+	
+	scheme_raise_exn(MZEXN_OBJECT_INIT_NEVER,
+			 o,
+			 sclass->superclass,
+			 CREATE_OBJECT ": superclass never initialized%s",
+			 cl);
+      }
+    }
+  }
+}
+
+static Scheme_Class_Object *make_object(Scheme_Class *sclass,
+					int argc,
+					Scheme_Object *argv[])
+{
+  Internal_Object *obj;
+  Init_Object_Rec *irec;
+  
+  obj = (Internal_Object *)allocate_object(sclass, &irec);
+  
+  CallInitFrame(obj, irec, irec->init_level - 1, argc, argv);
+
+  return (Scheme_Class_Object *)obj;
+}
+
+Scheme_Object *scheme_make_object(Scheme_Object *sclass, 
+				  int argc, Scheme_Object **argv)
+{
+  if (!SCHEME_CLASSP(sclass))
+    scheme_signal_error("make-object: not a class");
+
+  return (Scheme_Object *)make_object((Scheme_Class *)sclass, argc, argv);
+}
+
+static Scheme_Object *CreateObject(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *classname;
+  Scheme_Class *sclass;
+  Internal_Object *obj;
+
+  classname = argv[0];
+
+  if (!SAME_TYPE(SCHEME_TYPE(classname), scheme_class_type))
+    scheme_wrong_type(CREATE_OBJECT, "class", 0, argc, argv);
+
+  sclass = (Scheme_Class *)classname;
+
+  if ((sclass->priminit == pi_CPP)
+      && !sclass->piu.initf)
+    scheme_raise_exn(MZEXN_OBJECT_PRIVATE_CLASS,
+		     sclass,
+		     "can't create objects from the class %s",
+		     SCHEME_SYM_VAL(sclass->defname));
+  
+  obj = (Internal_Object *)make_object(sclass, argc  - 1, argv + 1);
+  
+  return (Scheme_Object *)&obj->o;
+}
+
+/************************************************************************/
+
+static Scheme_Object *DoSuperInitPrim(SuperInitData *data,
+				      int argc, Scheme_Object **argv)
+{
+  if (data->irec->init_level <= data->level) {
+    Scheme_Class **heritage = ((Scheme_Class *)data->o->o.sclass)->heritage;
+    const char *cl = get_class_name((Scheme_Object *)heritage[data->level + 1], 
+				    " in class: ");
+    scheme_raise_exn(MZEXN_OBJECT_INIT_MULTIPLE,
+		     data->o,
+		     heritage[data->level],
+		     "multiple intializations of superclass%s",
+		     cl);
+    return NULL;
+  }
+  
+  CallInitFrame(data->o, data->irec, data->level, argc, argv);
+
+  return scheme_void;
+}
+
+static Scheme_Object *MakeSuperInitPrim(Internal_Object *o, Init_Object_Rec *irec, int level)
+{
+  SuperInitData *data;
+
+  data = MALLOC_ONE(SuperInitData);
+
+  data->o = o;
+  data->irec = irec;
+  data->level = level;
+  
+  return scheme_make_closed_prim((Scheme_Closed_Prim *)DoSuperInitPrim, 
+				 (void *)data);
+}
+
+/*****************************************************************************/
+
+Scheme_Object *scheme_get_generic_data(Scheme_Object *clori, 
+				       Scheme_Object *name)
+{
+  short kind;
+  int sp, vp;
+  Generic_Data *data;
+
+  if (SCHEME_CLASSP(clori)) {
+    Scheme_Class *sclass = (Scheme_Class *)clori;
+    
+    sp = FindName(sclass, name);
+    if (sp < 0)
+      return NULL;
+
+    vp = sclass->public_map[sp];
+    kind = generic_KIND_CLASS;
+  } else {
+    Scheme_Interface *in = (Scheme_Interface *)clori;
+    
+    sp = DoFindName(in->num_names, in->names, name);
+
+    if (sp < 0)
+      return NULL;
+
+    vp = in->name_map[sp];
+    kind = generic_KIND_INTERFACE;
+  }
+  
+  data = MALLOC_ONE_TAGGED(Generic_Data);
+
+  data->type = scheme_generic_data_type;
+  data->kind = kind;
+  data->clori = clori;
+  data->vp = vp;
+
+  return (Scheme_Object *)data;
+}
+
+Scheme_Object *scheme_apply_generic_data(Scheme_Object *gdata, 
+					 Scheme_Object *sobj,
+					 int force)
+{
+  Internal_Object *obj;
+  Scheme_Class *sclass;
+  Generic_Data *data;
+  int vp;
+
+  data = (Generic_Data *)gdata;
+
+  obj = (Internal_Object *)sobj;
+
+  sclass = (Scheme_Class *)obj->o.sclass;
+  
+  if (data->kind == generic_KIND_CLASS) {
+    if (NOT_SAME_OBJ((Scheme_Object *)sclass, data->clori)) {
+      if (!scheme_is_subclass((Scheme_Object *)sclass, data->clori)) {
+	const char *cl = get_class_name(data->clori, ": ");
+	scheme_raise_exn(MZEXN_OBJECT_GENERIC,
+			 obj,
+			 "generic" ": object not an instance of the generic's class%s",
+			 cl);
+	return NULL;
+      }
+    }
+    vp = data->vp;
+  } else {
+    short *map;
+    int offset;
+
+    map = find_implementation((Scheme_Object *)sclass, data->clori, &offset);
+    if (!map) {
+      const char *inn = get_interface_name(data->clori, ": ");
+      scheme_raise_exn(MZEXN_OBJECT_GENERIC,
+		       obj,
+		       "generic" ": object not an instance of the generic's interface%s",
+		       inn);
+      return NULL;
+    }
+
+    vp = map[data->vp + offset];
+  }
+
+  return GetIvar(obj, NULL, obj->slots, sclass, sclass, vp, 0, force);
+}
+
+static Scheme_Object *DoGeneric(Generic_Data *data, 
+				int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OBJP(argv[0]))
+    scheme_wrong_type("generic", "object", 0, argc, argv);
+
+  return scheme_apply_generic_data((Scheme_Object *)data, argv[0], 1);
+}
+
+static Scheme_Object *MakeGeneric(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *data;
+  Scheme_Object *prim;
+
+  if (!SCHEME_CLASSP(argv[0]) && !SCHEME_INTERFACEP(argv[0]))
+    scheme_wrong_type(MAKE_GENERIC, "class or interface", 0, argc, argv);
+  if (!SCHEME_SYMBOLP(argv[1]))
+    scheme_wrong_type(MAKE_GENERIC, "symbol", 1, argc, argv);
+
+  data = scheme_get_generic_data(argv[0], argv[1]);
+
+  if (!data) {
+    const char *s;
+
+    if (SCHEME_CLASSP(argv[0]))
+      s = get_class_name(argv[0], " in class: ");
+    else
+      s = get_class_name(argv[0], " in interface: ");
+
+    scheme_raise_exn(MZEXN_OBJECT_CLASS_IVAR,
+		     argv[0],
+		     argv[1],
+		     MAKE_GENERIC ": can't find instance variable: %s%s",
+		     scheme_symbol_name(argv[1]),
+		     s);
+
+    return NULL;
+  }
+
+  prim = scheme_make_closed_prim((Scheme_Closed_Prim *)DoGeneric, (void *)data);
+
+  ((Scheme_Closed_Primitive_Proc *)prim)->name = "generic";
+  ((Scheme_Closed_Primitive_Proc *)prim)->flags |= SCHEME_PRIM_IS_GENERIC;
+
+  return prim;
+}
+
+/*****************************************************************************/
+
+static Scheme_Object *IVar(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *name;
+  Internal_Object *obj = NULL;
+  Scheme_Object *v;
+
+  if (!SCHEME_OBJP(argv[0]))
+    scheme_wrong_type(UQ_IVAR, "object", 0, argc, argv);
+  if (!SCHEME_SYMBOLP(argv[1]))
+    scheme_wrong_type(UQ_IVAR, "symbol", 1, argc, argv);
+
+  obj = (Internal_Object *)argv[0];
+  name = argv[1];
+
+  v = find_ivar(obj, name, 1);
+
+  if (!v) {
+    const char *cl;
+
+    cl = get_class_name(obj->o.sclass, " in class: ");
+    
+    scheme_raise_exn(MZEXN_OBJECT_IVAR,
+		     obj,
+		     name,
+		     IVAR ": instance variable not found: %s%s",
+		     scheme_symbol_name(name),
+		     cl);
+  }
+
+  return v;
+}
+
+/*****************************************************************************/
+
+static Scheme_Object *IsObject(int c, Scheme_Object *p[])
+{
+  return SCHEME_OBJP(p[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *IsClass(int c, Scheme_Object *p[])
+{
+  return SCHEME_CLASSP(p[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *IsInterface(int c, Scheme_Object *p[])
+{
+  return SCHEME_INTERFACEP(p[0]) ? scheme_true : scheme_false;
+}
+
+int scheme_is_subclass(Scheme_Object *c, Scheme_Object *base)
+{
+  Scheme_Class *dclass, *bclass;
+
+  if (!SCHEME_CLASSP(c) || !SCHEME_CLASSP(base))
+    return 0;
+
+  dclass = (Scheme_Class *)c;
+  bclass = (Scheme_Class *)base;
+
+  if (dclass->pos < bclass->pos)
+    return 0;
+
+  return (SAME_OBJ(dclass->heritage[bclass->pos], bclass));
+}
+
+static short *find_implementation(Scheme_Object *c, Scheme_Object *n, int *offset)
+{
+  Scheme_Class *sclass;
+  Scheme_Interface *in, **ins;
+  int i;
+
+  sclass = (Scheme_Class *)c;
+  in = (Scheme_Interface *)n;
+
+  ins = sclass->interfaces;
+  for (i = sclass->num_interfaces; i--; ) {
+    if (SAME_OBJ(ins[i], in)) {
+      *offset = 0;
+      return sclass->interface_maps[i];
+    } else {
+      Scheme_Interface **supers;
+      int j;
+      supers = ins[i]->supers;
+      for (j = ins[i]->num_supers; j--; ) {
+	if (SAME_OBJ(supers[j], in)) {
+	  *offset = ins[i]->super_offsets[j];
+	  return sclass->interface_maps[i];
+	}
+      }
+    }
+  }
+  
+  return NULL;
+}
+
+int scheme_is_implementation(Scheme_Object *c, Scheme_Object *n)
+{
+  int offset;
+
+  if (!SCHEME_CLASSP(c) || !SCHEME_INTERFACEP(n))
+    return 0;
+  
+  return find_implementation(c, n, &offset) ? 1 : 0;
+}
+
+int scheme_is_interface_extension(Scheme_Object *exn, Scheme_Object *basen)
+{
+  int i;
+  Scheme_Interface *ex, *base, **ins;
+
+  if (!SCHEME_INTERFACEP(exn) || !SCHEME_INTERFACEP(basen))
+    return 0;
+
+  ex = (Scheme_Interface *)exn;
+  base = (Scheme_Interface *)basen;
+
+  ins = ex->supers;
+  for (i = ex->num_supers; i--; )
+    if (SAME_OBJ(base, ins[i]))
+      return 1;
+
+  return 0;
+}
+
+static Scheme_Object *IsA(int c, Scheme_Object *p[])
+{
+  if (!SCHEME_CLASSP(p[1]) && !SCHEME_INTERFACEP(p[1]))
+    scheme_wrong_type(IS_A, "class or interface", 1, c, p);
+
+  return scheme_is_a(p[0], p[1]) ? scheme_true : scheme_false;
+}
+
+int scheme_is_a(Scheme_Object *obj, Scheme_Object *base)
+{
+  Scheme_Object *cl;
+
+  if (!SCHEME_OBJP(obj))
+    return 0;
+
+  cl = (Scheme_Object *)((Internal_Object *)obj)->o.sclass;
+
+  if (SCHEME_INTERFACEP(base))
+    return scheme_is_implementation(cl, base);
+  else if (SCHEME_CLASSP(base))
+    return scheme_is_subclass(cl, base);
+  else
+    return 0;
+}
+
+static Scheme_Object *IsSubclass(int c, Scheme_Object *p[])
+{
+  if (!SCHEME_CLASSP(p[1]))
+    scheme_wrong_type(SUBCLASS, "class", 1, c, p);
+
+  if (!SCHEME_CLASSP(p[0]))
+    return scheme_false;
+
+  return scheme_is_subclass(p[0], p[1]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *IsImplementation(int c, Scheme_Object *p[])
+{
+  if (!SCHEME_INTERFACEP(p[1]))
+    scheme_wrong_type(IMPLEMENTATION, "interface", 1, c, p);
+
+  if (!SCHEME_CLASSP(p[0]))
+    return scheme_false;
+
+  return scheme_is_implementation(p[0], p[1]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *IsExtension(int c, Scheme_Object *p[])
+{
+  if (!SCHEME_INTERFACEP(p[1]))
+    scheme_wrong_type(INTERFACE_EXTENSION, "interface", 1, c, p);
+
+  if (!SCHEME_INTERFACEP(p[0]))
+    return scheme_false;
+
+  return scheme_is_interface_extension(p[0], p[1]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *IvarInClass(int c, Scheme_Object *p[])
+{
+  Scheme_Class *sclass;
+
+  if (!SCHEME_SYMBOLP(p[0]))
+    scheme_wrong_type(IVAR_IN_CLASS, "symbol", 0, c, p);
+  if (!SCHEME_CLASSP(p[1]))
+    scheme_wrong_type(IVAR_IN_CLASS, "class", 1, c, p);
+
+  sclass = (Scheme_Class *)p[1];
+  if (FindName(sclass, p[0]) >= 0)
+    return scheme_true;
+
+  return scheme_false;
+}
+
+static Scheme_Object *ObjectClass(int c, Scheme_Object *p[])
+{
+  if (!SCHEME_OBJP(p[0]))
+    scheme_wrong_type(OBJECT_CLASS, "object", 0, c, p);
+
+  return ((Scheme_Class_Object *)p[0])->sclass;
+}
+
+#if ADD_TEST_PRIM_OBJ
+static Scheme_Object *ConstructPObject(Scheme_Object *obj, int argc, Scheme_Object **argv)
+{
+  if (argc != 1) 
+    scheme_wrong_count("primclass%::initialization", 1, 1, argc, argv);
+
+  ((Scheme_Class_Object *)obj)->primdata = argv[0];
+
+  return obj;
+}
+
+static Scheme_Object *PObjectName(Scheme_Object *obj, int argc, Scheme_Object **argv)
+{
+  return (Scheme_Object *)((Scheme_Class_Object *)obj)->primdata;
+}
+
+static Scheme_Object *PObjectClassname(Scheme_Object *obj, int argc, Scheme_Object **argv)
+{
+  return scheme_make_string("primclass%");
+}
+
+static Scheme_Object *PSubObjectClassname(Scheme_Object *obj, int argc, Scheme_Object **argv)
+{
+  return scheme_make_string("primsubclass%");
+}
+
+static Scheme_Object *PSubObjectDetail(Scheme_Object *obj, int argc, Scheme_Object **argv)
+{
+  return (SCHEME_STRINGP((Scheme_Object *)((Scheme_Class_Object *)obj)->primdata)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+
+#endif
+
+void scheme_init_object(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(null_class);
+
+    REGISTER_SO(seq_symbol);
+    REGISTER_SO(pub_symbol);
+    REGISTER_SO(pri_symbol);
+    REGISTER_SO(inh_symbol);
+    REGISTER_SO(ren_symbol);
+    
+    REGISTER_SO(class_star_symbol);
+    REGISTER_SO(interface_symbol);
+
+    seq_symbol = scheme_intern_symbol("sequence");
+    pub_symbol = scheme_intern_symbol("public");
+    pri_symbol = scheme_intern_symbol("private");
+    inh_symbol = scheme_intern_symbol("inherit");
+    ren_symbol = scheme_intern_symbol("rename");
+    
+    class_star_symbol = scheme_intern_symbol("class*/names");
+    interface_symbol = scheme_intern_symbol("interface");
+
+    scheme_register_syntax("dc", DefineClass_Execute);
+    scheme_register_syntax("if", Interface_Execute);
+
+    scheme_install_type_writer(scheme_class_data_type, write_Class_Data);
+    scheme_install_type_reader(scheme_class_data_type, read_Class_Data);
+    scheme_install_type_writer(scheme_interface_data_type, write_Interface_Data);
+    scheme_install_type_reader(scheme_interface_data_type, read_Interface_Data);
+  }
+
+  scheme_add_global_keyword(CLASS_STAR_W_NAMES, 
+			    scheme_make_compiled_syntax(DefineClass, 
+							DefineClass_expand), 
+			    env);
+
+  scheme_add_global_keyword(INTERFACE, 
+			    scheme_make_compiled_syntax(Interface, 
+							Interface_expand), 
+			    env);
+
+  scheme_add_global_constant(CREATE_OBJECT, 
+			     scheme_make_prim_w_arity(CreateObject, 
+						      CREATE_OBJECT,
+						      1, -1), 
+			     env);
+  
+  scheme_add_global_constant(UQ_IVAR, 
+			     scheme_make_prim_w_arity(IVar, 
+						      UQ_IVAR,
+						      2, 2),
+			     env);
+
+  scheme_add_global_constant(UQ_MAKE_GENERIC, 
+			     scheme_make_prim_w_arity(MakeGeneric, 
+						      UQ_MAKE_GENERIC,
+						      2, 2), 
+			     env);
+
+  scheme_add_global_constant(IS_OBJECT, 
+			     scheme_make_folding_prim(IsObject, 
+						      IS_OBJECT,
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant(IS_CLASS, 
+			     scheme_make_folding_prim(IsClass, 
+						      IS_CLASS,
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant(IS_INTERFACE, 
+			     scheme_make_folding_prim(IsInterface, 
+						      IS_INTERFACE,
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant(IS_A, 
+			     scheme_make_folding_prim(IsA, 
+						      IS_A,
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant(SUBCLASS, 
+			     scheme_make_folding_prim(IsSubclass, 
+						      SUBCLASS,
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant(IMPLEMENTATION, 
+			     scheme_make_folding_prim(IsImplementation, 
+						      IMPLEMENTATION,
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant(INTERFACE_EXTENSION, 
+			     scheme_make_folding_prim(IsExtension, 
+						      INTERFACE_EXTENSION,
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant(IVAR_IN_CLASS,
+			     scheme_make_folding_prim(IvarInClass,
+						      IVAR_IN_CLASS,
+						      2, 2, 1), 
+			     env);
+  scheme_add_global_constant(OBJECT_CLASS, 
+			     scheme_make_folding_prim(ObjectClass, 
+						      OBJECT_CLASS,
+						      1, 1, 1), 
+			     env);
+
+#if ADD_TEST_PRIM_OBJ
+  {
+    Scheme_Object *pclass, *psubclass;
+
+    pclass = scheme_make_class("primclass%", NULL, ConstructPObject, 2);
+    scheme_add_method_w_arity(pclass, "name", PObjectName, 0, 0);
+    scheme_add_method_w_arity(pclass, "class-name", PObjectClassname, 0, 0);
+    scheme_made_class(pclass);
+    scheme_add_global_constant("primclass%", pclass, env);
+
+    psubclass = scheme_make_class("primsubclass%", pclass, ConstructPObject, 2);
+    scheme_add_method_w_arity(psubclass, "detail", PSubObjectDetail, 0, 0);
+    scheme_add_method_w_arity(psubclass, "class-name", PSubObjectClassname, 0, 0);
+    scheme_made_class(psubclass);
+    scheme_add_global_constant("primsubclass%", psubclass, env);
+  }
+#endif
+}
+
+#ifdef MEMORY_COUNTING_ON
+
+void scheme_count_object(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht)
+{
+  int count;
+  Internal_Object *obj = (Internal_Object *)o;
+
+  *s = sizeof(Internal_Object);
+  count = ((Scheme_Class *)obj->o.sclass)->num_slots;
+  *s += count * sizeof(Scheme_Object *);
+
+  *e = 0;
+}
+
+static long count_cvars(ClassVariable *cvar, Scheme_Hash_Table *ht)
+{
+  long e = 0;
+
+  while (cvar) {
+    e += scheme_count_memory(cvar->name, ht);
+
+    switch(cvar->vartype) {
+    case varPUBLIC:
+    case varPRIVATE:
+    case varNOTHING:
+    case varINPUT:
+      e += scheme_count_memory(cvar->u.value, ht);
+      break;
+    case varINHERIT:
+    case varRENAME:
+      e += scheme_count_memory(cvar->u.source.name, ht);
+    }
+
+    cvar = cvar->next;
+  }
+
+  return e;
+}
+
+void scheme_count_class(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht)
+{
+  Scheme_Class *sclass = (Scheme_Class *)o;
+
+  *s = sizeof(Scheme_Class)
+    + sclass->num_public * (sizeof(short) + sizeof(short) + sizeof(slotkind))
+    + sclass->num_public * sizeof(Scheme_Object*)
+    + (sclass->pos + 1) * sizeof(Scheme_Class*)
+    + sclass->closure_size * sizeof(int);
+
+  *e += scheme_count_memory((Scheme_Object *)sclass->superclass, ht);
+  
+  *e += count_cvars(sclass->ivars, ht);
+
+  *e += scheme_count_closure(sclass->closure_saved, sclass->closure_size, ht);
+}
+
+void scheme_count_generic(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht)
+{
+  *s = sizeof(Generic_Data);
+  *e = scheme_count_memory(((Generic_Data *)o)->clori, ht);
+}
+
+void scheme_count_class_data(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht)
+{
+  Class_Data *data = (Class_Data *)o;
+
+  *s = (sizeof(Class_Data)
+	+ (data->num_ivar + data->num_private + data->num_ref) * sizeof(ClassVariable)
+	+ data->closure_size * sizeof(short));
+
+  *e += scheme_count_memory(data->super_expr, ht);
+
+  *e = 0;
+}
+
+#endif
+
+#endif
+/* NO_OBJECT_SYSTEM */
diff --git a/src/mzscheme/src/port.c b/src/mzscheme/src/port.c
new file mode 100644
index 0000000..25a13b5
--- /dev/null
+++ b/src/mzscheme/src/port.c
@@ -0,0 +1,5989 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#ifdef UNISTD_INCLUDE
+# include <unistd.h>
+#endif
+#ifdef FILES_HAVE_FDS
+# include <sys/types.h>
+# include <sys/time.h>
+# ifdef BSTRING_INCLUDE
+#  include <bstring.h>
+# endif
+# ifdef SELECT_INCLUDE
+#  include <sys/select.h>
+# endif
+#endif
+#ifdef UNIX_PROCESSES
+# include <signal.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <sys/resource.h>
+#endif
+#ifdef IO_INCLUDE
+# include <io.h>
+#endif
+#ifdef NO_ERRNO_GLOBAL
+static int mzerrno = 0;
+# define errno mzerrno
+#else
+# include <errno.h>
+#endif
+#ifndef DONT_IGNORE_PIPE_SIGNAL
+# include <signal.h>
+#endif
+#include <math.h> /* for fmod , used by default_sleep */
+#include "schfd.h"
+
+#if defined(WINDOWS_PROCESSES) || defined(DETECT_WIN32_CONSOLE_STDIN)
+# define WIN32_FD_HANDLES
+# include <process.h>
+# include <signal.h>
+#endif
+
+typedef struct Scheme_Indexed_String {
+  char *string;
+  int size;
+  int index;
+} Scheme_Indexed_String;
+
+typedef struct {
+  FILE *f;
+  int regfile;
+} Scheme_Input_File;
+
+typedef struct {
+  FILE *f;
+} Scheme_Output_File;
+
+#if defined(USE_UNIX_SOCKETS_TCP) || defined(USE_WINSOCK_TCP)
+# define USE_SOCKETS_TCP
+#endif
+
+#ifdef USE_MAC_TCP
+# include <MacTCP.h>
+# include <dnr.c>
+#endif
+
+#ifdef USE_UNIX_SOCKETS_TCP
+# include <netinet/in.h>
+# include <netdb.h>
+# include <sys/socket.h>
+# include <fcntl.h>
+# define TCP_SOCKSENDBUF_SIZE 32768
+# ifdef USE_FCNTL_O_NONBLOCK
+#  define TCP_NONBLOCKING O_NONBLOCK
+# else
+#  define TCP_NONBLOCKING FNDELAY
+# endif
+#endif
+
+#ifdef USE_WINSOCK_TCP
+# include <winsock.h>
+struct SOCKADDR_IN {
+  short sin_family;
+  unsigned short sin_port;
+  struct in_addr sin_addr;
+  char sin_zero[8];
+};
+#endif
+
+#ifdef USE_TCP
+
+#ifdef USE_MAC_TCP
+# define TCP_BUFFER_SIZE 32768
+#else
+# define TCP_BUFFER_SIZE 512
+#endif
+
+#ifdef USE_UNIX_SOCKETS_TCP
+typedef int tcp_t;
+# define INVALID_SOCKET (-1)
+#define closesocket close
+#endif
+
+#ifdef USE_WINSOCK_TCP
+typedef SOCKET tcp_t;
+#endif
+
+#ifdef USE_SOCKETS_TCP
+typedef struct {
+  Scheme_Type type;
+  tcp_t s;
+  Scheme_Manager_Reference *mref;
+} listener_t;
+#endif
+
+#ifdef USE_MAC_TCP
+typedef struct {
+  void *create_pb;
+  StreamPtr stream;
+  int state;
+  int async_errid;
+} tcp_t;
+
+typedef struct {
+  Scheme_Type type; 
+  int portid;
+  int count;
+  struct Scheme_Tcp **datas;
+  Scheme_Manager_Reference *mref;
+} listener_t;
+# define htons(x) x
+#endif
+
+typedef struct Scheme_Tcp {
+  tcp_t tcp;
+  int refcount;
+  char buffer[TCP_BUFFER_SIZE];
+  short bufpos, bufmax;
+  char *sendbuf;
+  int sendbufsize, sendbuflen;
+  short sendbuftrying;
+  short hiteof;
+} Scheme_Tcp;
+
+#endif
+
+#ifdef UNIX_PROCESSES
+/* For process & system: */
+typedef struct System_Child {
+  pid_t id;
+  short done;
+  int status;
+  struct System_Child *next;
+} System_Child;
+#endif
+
+#ifdef USE_FD_PORTS
+# define MZPORT_FD_BUFFSIZE 2048
+typedef struct Scheme_FD {
+  int fd;
+  int bufcount, buffpos;
+  unsigned char buffer[MZPORT_FD_BUFFSIZE];
+} Scheme_FD;
+#endif
+
+/* globals */
+Scheme_Object *scheme_eof;
+Scheme_Object *scheme_orig_stdout_port;
+Scheme_Object *scheme_orig_stderr_port;
+Scheme_Object *scheme_orig_stdin_port;
+Scheme_Object *scheme_write_proc, *scheme_display_proc, *scheme_print_proc;
+
+Scheme_Object *(*scheme_make_stdin)(void) = NULL;
+Scheme_Object *(*scheme_make_stdout)(void) = NULL;
+Scheme_Object *(*scheme_make_stderr)(void) = NULL;
+
+int scheme_file_open_count;
+
+/* locals */
+#ifdef USE_FD_PORTS
+static Scheme_Object *fd_input_port_type;
+#endif
+static Scheme_Object *file_input_port_type;
+static Scheme_Object *string_input_port_type;
+static Scheme_Object *tcp_input_port_type;
+#ifdef USE_FD_PORTS
+static Scheme_Object *fd_output_port_type;
+#endif
+static Scheme_Object *file_output_port_type;
+static Scheme_Object *string_output_port_type;
+static Scheme_Object *tcp_output_port_type;
+static Scheme_Object *user_input_port_type;
+static Scheme_Object *user_output_port_type;
+static Scheme_Object *pipe_read_port_type;
+static Scheme_Object *pipe_write_port_type;
+#ifdef WIN32_FD_HANDLES
+static Scheme_Object *tested_file_input_port_type;
+#endif
+
+static Scheme_Object *text_symbol, *binary_symbol;
+static Scheme_Object *append_symbol, *error_symbol;
+static Scheme_Object *replace_symbol, *truncate_symbol;
+
+#ifdef USE_MAC_TCP
+static int num_tcp_send_buffers = 0;
+static void **tcp_send_buffers;
+#endif
+
+#ifdef UNIX_PROCESSES
+System_Child *scheme_system_children;
+#endif
+
+/* generic ports */
+
+static Scheme_Object *scheme_make_eof (void);
+static Scheme_Object *input_port_p (int, Scheme_Object *[]);
+static Scheme_Object *output_port_p (int, Scheme_Object *[]);
+static Scheme_Object *current_input_port (int, Scheme_Object *[]);
+static Scheme_Object *current_output_port (int, Scheme_Object *[]);
+static Scheme_Object *current_error_port (int, Scheme_Object *[]);
+static Scheme_Object *make_input_port (int, Scheme_Object *[]);
+static Scheme_Object *make_output_port (int, Scheme_Object *[]);
+static Scheme_Object *open_input_file (int, Scheme_Object *[]);
+static Scheme_Object *open_output_file (int, Scheme_Object *[]);
+static Scheme_Object *close_input_port (int, Scheme_Object *[]);
+static Scheme_Object *close_output_port (int, Scheme_Object *[]);
+static Scheme_Object *call_with_output_file (int, Scheme_Object *[]);
+static Scheme_Object *call_with_input_file (int, Scheme_Object *[]);
+static Scheme_Object *with_input_from_file (int, Scheme_Object *[]);
+static Scheme_Object *with_output_to_file (int, Scheme_Object *[]);
+static Scheme_Object *read_f (int, Scheme_Object *[]);
+static Scheme_Object *read_char (int, Scheme_Object *[]);
+static Scheme_Object *read_line (int, Scheme_Object *[]);
+static Scheme_Object *peek_char (int, Scheme_Object *[]);
+static Scheme_Object *eof_object_p (int, Scheme_Object *[]);
+static Scheme_Object *char_ready_p (int, Scheme_Object *[]);
+static Scheme_Object *sch_write (int, Scheme_Object *[]);
+static Scheme_Object *display (int, Scheme_Object *[]);
+static Scheme_Object *print (int, Scheme_Object *[]);
+static Scheme_Object *newline (int, Scheme_Object *[]);
+static Scheme_Object *write_char (int, Scheme_Object *[]);
+static Scheme_Object *load (int, Scheme_Object *[]);
+static Scheme_Object *current_load (int, Scheme_Object *[]);
+static Scheme_Object *current_load_directory(int argc, Scheme_Object *argv[]);
+static Scheme_Object *default_load (int, Scheme_Object *[]);
+static Scheme_Object *require_library_use_compiled(int, Scheme_Object *[]);
+static Scheme_Object *current_require_relative_collection(int, Scheme_Object *[]);
+static Scheme_Object *transcript_on(int, Scheme_Object *[]);
+static Scheme_Object *transcript_off(int, Scheme_Object *[]);
+/* non-standard */
+static Scheme_Object *flush_output (int, Scheme_Object *[]);
+static Scheme_Object *file_position (int, Scheme_Object *[]);
+static Scheme_Object *open_input_string (int, Scheme_Object *[]);
+static Scheme_Object *open_output_string (int, Scheme_Object *[]);
+static Scheme_Object *get_output_string (int, Scheme_Object *[]);
+static Scheme_Object *sch_pipe(int, Scheme_Object **args);
+static Scheme_Object *port_read_handler(int, Scheme_Object **args);
+static Scheme_Object *port_display_handler(int, Scheme_Object **args);
+static Scheme_Object *port_write_handler(int, Scheme_Object **args);
+static Scheme_Object *port_print_handler(int, Scheme_Object **args);
+static Scheme_Object *global_port_print_handler(int, Scheme_Object **args);
+
+static Scheme_Object *sch_process(int c, Scheme_Object *args[]);
+static Scheme_Object *sch_system(int c, Scheme_Object *args[]);
+static Scheme_Object *sch_execute(int c, Scheme_Object *args[]);
+static Scheme_Object *sch_process_star(int c, Scheme_Object *args[]);
+static Scheme_Object *sch_system_star(int c, Scheme_Object *args[]);
+static Scheme_Object *sch_execute_star(int c, Scheme_Object *args[]);
+
+static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_listen(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_stop(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_accept_ready(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_accept(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_listener_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *tcp_port_send_waiting_p(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *sch_default_read_handler(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_default_display_handler(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_default_write_handler(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_default_print_handler(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_default_global_port_print_handler(int argc, Scheme_Object *argv[]);
+
+static void default_sleep(float v, void *fds);
+
+#ifdef WIN32_FD_HANDLES
+static Scheme_Object *make_tested_file_input_port(FILE *fp, char *name, int tested);
+HANDLE scheme_break_semaphore;
+#else
+# define make_tested_file_input_port(fp, name, t) scheme_make_named_file_input_port(fp, name)
+#endif
+
+#ifdef USE_FD_PORTS
+static Scheme_Object *make_fd_input_port(int fd, const char *filename);
+static Scheme_Object *make_fd_output_port(int fd);
+#endif
+
+static Scheme_Object *default_read_handler;
+static Scheme_Object *default_display_handler;
+static Scheme_Object *default_write_handler;
+static Scheme_Object *default_print_handler;
+
+#ifdef MACINTOSH_EVENTS
+# define MAX_PROCESS_STAR_ARGS 1
+#else
+# define MAX_PROCESS_STAR_ARGS -1
+#endif
+
+#include "schwinfd.h"
+
+void 
+scheme_init_port (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    Scheme_Config *config = scheme_config;
+    
+    REGISTER_SO(scheme_eof);
+    REGISTER_SO(scheme_orig_stdout_port);
+    REGISTER_SO(scheme_orig_stderr_port);
+    REGISTER_SO(scheme_orig_stdin_port);
+#ifdef USE_FD_PORTS
+    REGISTER_SO(fd_input_port_type);
+#endif
+    REGISTER_SO(file_input_port_type);
+    REGISTER_SO(string_input_port_type);
+    REGISTER_SO(tcp_input_port_type);
+#ifdef USE_FD_PORTS
+    REGISTER_SO(fd_output_port_type);
+#endif
+    REGISTER_SO(file_output_port_type);
+    REGISTER_SO(string_output_port_type);
+    REGISTER_SO(tcp_output_port_type);
+    REGISTER_SO(user_input_port_type);
+    REGISTER_SO(user_output_port_type);
+    REGISTER_SO(pipe_read_port_type);
+    REGISTER_SO(pipe_write_port_type);
+#ifdef WIN32_FD_HANDLES
+    REGISTER_SO(tested_file_input_port_type);
+#endif
+    REGISTER_SO(default_read_handler);
+    REGISTER_SO(default_display_handler);
+    REGISTER_SO(default_write_handler);
+    REGISTER_SO(default_print_handler);
+    REGISTER_SO(scheme_write_proc);
+    REGISTER_SO(scheme_display_proc);
+    REGISTER_SO(scheme_print_proc);
+
+#ifdef USE_MAC_TCP
+    REGISTER_SO(tcp_send_buffers);
+#endif
+
+#ifdef UNIX_PROCESSES
+    REGISTER_SO(scheme_system_children);
+#endif
+
+#ifndef DONT_IGNORE_PIPE_SIGNAL
+    MZ_SIGSET(SIGPIPE, SIG_IGN);
+#endif
+
+    if (!scheme_sleep)
+      scheme_sleep = default_sleep;
+
+    scheme_eof = scheme_make_eof();
+
+    string_input_port_type = scheme_make_port_type("<string-input-port>");
+    string_output_port_type = scheme_make_port_type("<string-output-port>");
+
+#ifdef USE_FD_PORTS
+    fd_input_port_type = scheme_make_port_type("<file-desc-input-port>");
+    fd_output_port_type = scheme_make_port_type("<file-desc-output-port>");
+#endif
+
+    file_input_port_type = scheme_make_port_type("<file-input-port>");
+    file_output_port_type = scheme_make_port_type("<file-output-port>");
+
+    user_input_port_type = scheme_make_port_type("<user-input-port>");
+    user_output_port_type = scheme_make_port_type("<user-output-port>");
+
+    pipe_read_port_type = scheme_make_port_type("<pipe-input-port>");
+    pipe_write_port_type = scheme_make_port_type("<pipe-output-port>");
+
+    tcp_input_port_type = scheme_make_port_type("<tcp-input-port>");
+    tcp_output_port_type = scheme_make_port_type("<tcp-output-port>");
+
+#ifdef WIN32_FD_HANDLES
+    tested_file_input_port_type = scheme_make_port_type("<file-input-port>");
+    
+    scheme_break_semaphore = CreateSemaphore(NULL, 0, 1, NULL);
+#endif
+
+    scheme_orig_stdin_port = (scheme_make_stdin
+			      ? scheme_make_stdin()
+#ifdef USE_FD_PORTS
+			      : make_fd_input_port(0, "STDIN")
+#else
+			      : make_tested_file_input_port(stdin, "STDIN", 1)
+#endif
+			      );
+
+    scheme_set_param(config, MZCONFIG_INPUT_PORT,
+		     scheme_orig_stdin_port);
+    scheme_orig_stderr_port = (scheme_make_stdout
+			       ? scheme_make_stdout()
+#ifdef USE_FD_PORTS
+			       : make_fd_output_port(1)
+#else
+			       : scheme_make_file_output_port(stdout)
+#endif
+			       );
+    scheme_set_param(config, MZCONFIG_OUTPUT_PORT,
+		     scheme_orig_stderr_port);
+    scheme_orig_stdout_port = (scheme_make_stderr
+			       ? scheme_make_stderr()
+#ifdef USE_FD_PORTS
+			       : make_fd_output_port(2)
+#else
+			       : scheme_make_file_output_port(stderr)
+#endif
+			       );
+    scheme_set_param(config, MZCONFIG_ERROR_PORT,
+		     scheme_orig_stdout_port);
+
+    scheme_set_param(config, MZCONFIG_LOAD_HANDLER,
+		     scheme_make_prim_w_arity2(default_load,
+					       "default-load-handler",
+					       1, 1,
+					       0, -1));
+
+    scheme_set_param(config, MZCONFIG_LOAD_DIRECTORY, scheme_false);
+
+    scheme_write_proc = scheme_make_prim_w_arity(sch_write, 
+						 "write", 
+						 1, 2);
+    scheme_display_proc = scheme_make_prim_w_arity(display, 
+						   "display", 
+						   1, 2);
+    scheme_print_proc = scheme_make_prim_w_arity(print, 
+						 "print", 
+						 1, 2);
+    
+    REGISTER_SO(text_symbol);
+    REGISTER_SO(binary_symbol);
+    REGISTER_SO(append_symbol); 
+    REGISTER_SO(error_symbol);
+    REGISTER_SO(replace_symbol);
+    REGISTER_SO(truncate_symbol);
+
+    text_symbol = scheme_intern_symbol("text");
+    binary_symbol = scheme_intern_symbol("binary");
+    append_symbol = scheme_intern_symbol("append");
+    error_symbol = scheme_intern_symbol("error");
+    replace_symbol = scheme_intern_symbol("replace");
+    truncate_symbol = scheme_intern_symbol("truncate");
+
+    default_read_handler = scheme_make_prim_w_arity(sch_default_read_handler,
+						    "default-port-read-handler", 
+						    1, 1);
+    default_display_handler = scheme_make_prim_w_arity(sch_default_display_handler,
+						       "default-port-display-handler", 
+						       2, 2);
+    default_write_handler = scheme_make_prim_w_arity(sch_default_write_handler,
+						     "default-port-write-handler", 
+						     2, 2);
+    default_print_handler = scheme_make_prim_w_arity(sch_default_print_handler,
+						     "default-port-print-handler", 
+						     2, 2);
+
+    scheme_set_param(config, MZCONFIG_PORT_PRINT_HANDLER,
+		     scheme_make_prim_w_arity(sch_default_global_port_print_handler,
+					      "default-global-port-print-handler",
+					      2, 2));
+  }
+
+  scheme_add_global_constant("eof", scheme_eof, env);
+
+  scheme_add_global_constant("input-port?", 
+			     scheme_make_folding_prim(input_port_p, 
+						      "input-port?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("output-port?", 
+			     scheme_make_folding_prim(output_port_p, 
+						      "output-port?", 
+						      1, 1, 1), 
+			     env);
+  
+  scheme_add_global_constant("current-input-port", 
+			     scheme_register_parameter(current_input_port,
+						       "current-input-port",
+						       MZCONFIG_INPUT_PORT),
+			     env);
+  scheme_add_global_constant("current-output-port", 
+			     scheme_register_parameter(current_output_port,
+						       "current-output-port",
+						       MZCONFIG_OUTPUT_PORT),
+			     env);
+  scheme_add_global_constant("current-error-port", 
+			     scheme_register_parameter(current_error_port, 
+						       "current-error-port",
+						       MZCONFIG_ERROR_PORT),
+			     env);
+  
+  scheme_add_global_constant("open-input-file", 
+			     scheme_make_prim_w_arity(open_input_file, 
+						      "open-input-file", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("open-input-string", 
+			     scheme_make_prim_w_arity(open_input_string, 
+						      "open-input-string", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("open-output-file", 
+			     scheme_make_prim_w_arity(open_output_file,
+						      "open-output-file",
+						      1, 3), 
+			     env);
+  scheme_add_global_constant("open-output-string", 
+			     scheme_make_prim_w_arity(open_output_string,
+						      "open-output-string", 
+						      0, 0),
+			     env);
+  scheme_add_global_constant("get-output-string", 
+			     scheme_make_prim_w_arity(get_output_string,
+						      "get-output-string",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("close-input-port", 
+			     scheme_make_prim_w_arity(close_input_port,
+						      "close-input-port", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("close-output-port", 
+			     scheme_make_prim_w_arity(close_output_port, 
+						      "close-output-port", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("call-with-output-file",
+			     scheme_make_prim_w_arity2(call_with_output_file,
+						       "call-with-output-file",
+						       2, 4,
+						       0, -1),
+			     env);
+  scheme_add_global_constant("call-with-input-file",
+			     scheme_make_prim_w_arity2(call_with_input_file,
+						       "call-with-input-file",
+						       2, 3,
+						       0, -1),
+			     env);
+  scheme_add_global_constant("with-output-to-file",
+			     scheme_make_prim_w_arity2(with_output_to_file,
+						       "with-output-to-file",
+						       2, 4,
+						       0, -1),
+			     env);
+  scheme_add_global_constant("with-input-from-file",
+			     scheme_make_prim_w_arity2(with_input_from_file,
+						       "with-input-from-file",
+						       2, 3,
+						       0, -1),
+			     env);
+  scheme_add_global_constant("make-input-port", 
+			     scheme_make_prim_w_arity(make_input_port, 
+						      "make-input-port", 
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("make-output-port", 
+			     scheme_make_prim_w_arity(make_output_port, 
+						      "make-output-port", 
+						      2, 2), 
+			     env);
+  
+  scheme_add_global_constant("read", 
+			     scheme_make_prim_w_arity(read_f,
+						      "read", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("read-char", 
+			     scheme_make_prim_w_arity(read_char, 
+						      "read-char", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("read-line", 
+			     scheme_make_prim_w_arity(read_line, 
+						      "read-line", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("peek-char", 
+			     scheme_make_prim_w_arity(peek_char, 
+						      "peek-char", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("eof-object?", 
+			     scheme_make_folding_prim(eof_object_p, 
+						      "eof-object?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("char-ready?", 
+			     scheme_make_prim_w_arity(char_ready_p, 
+						      "char-ready?", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("write", scheme_write_proc, env);
+  scheme_add_global_constant("display", scheme_display_proc, env);
+  scheme_add_global_constant("print", scheme_print_proc, env);
+  scheme_add_global_constant("newline", 
+			     scheme_make_prim_w_arity(newline, 
+						      "newline", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("write-char", 
+			     scheme_make_prim_w_arity(write_char, 
+						      "write-char", 
+						      1, 2), 
+			     env);
+  
+  scheme_add_global_constant("port-read-handler", 
+			     scheme_make_prim_w_arity(port_read_handler, 
+						      "port-read-handler", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("port-display-handler", 
+			     scheme_make_prim_w_arity(port_display_handler, 
+						      "port-display-handler", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("port-write-handler", 
+			     scheme_make_prim_w_arity(port_write_handler, 
+						      "port-write-handler", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("port-print-handler", 
+			     scheme_make_prim_w_arity(port_print_handler, 
+						      "port-print-handler", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("global-port-print-handler",
+			     scheme_register_parameter(global_port_print_handler,
+						       "global-port-print-handler",
+						       MZCONFIG_PORT_PRINT_HANDLER),
+			     env);
+  
+  scheme_add_global_constant("load", 
+			     scheme_make_prim_w_arity2(load, 
+						       "load", 
+						       1, 1,
+						       0, -1),
+			      env);
+  scheme_add_global_constant("current-load", 
+			     scheme_register_parameter(current_load, 
+						       "current-load",
+						       MZCONFIG_LOAD_HANDLER), 
+			     env);
+  scheme_add_global_constant("current-load-relative-directory", 
+			     scheme_register_parameter(current_load_directory, 
+						       "current-load-relative-directory",
+						       MZCONFIG_LOAD_DIRECTORY), 
+			     env);
+
+  scheme_add_global_constant("require-library-use-compiled",
+			     scheme_register_parameter(require_library_use_compiled,
+						       "require-library-use-compiled",
+						       MZCONFIG_REQ_LIB_USE_COMPILED),
+			     env);
+  scheme_add_global_constant("current-require-relative-collection",
+			     scheme_register_parameter(current_require_relative_collection,
+						       "current-require-relative-collection",
+						       MZCONFIG_REQUIRE_COLLECTION),
+			     env);
+
+  scheme_add_global_constant ("transcript-on", 
+			      scheme_make_prim_w_arity(transcript_on,
+						       "transcript-on", 
+						       1, 1),
+			      env);
+  scheme_add_global_constant ("transcript-off", 
+			      scheme_make_prim_w_arity(transcript_off,
+						       "transcript-off", 
+						       0, 0),
+			      env);
+  
+  scheme_add_global_constant("flush-output", 
+			     scheme_make_prim_w_arity(flush_output, 
+						      "flush-output", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("file-position", 
+			     scheme_make_prim_w_arity(file_position, 
+						      "file-position", 
+						      1, 2), 
+			     env);
+  
+  scheme_add_global_constant("make-pipe", 
+			     scheme_make_prim_w_arity2(sch_pipe, 
+						       "make-pipe", 
+						       0, 0,
+						       2, 2), 
+			     env);
+  
+  scheme_add_global_constant("process", 
+			     scheme_make_prim_w_arity(sch_process, 
+						      "process", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("system", 
+			     scheme_make_prim_w_arity(sch_system,
+						      "system", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("execute", 
+			     scheme_make_prim_w_arity(sch_execute, 
+						      "execute", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("process*", 
+			     scheme_make_prim_w_arity(sch_process_star,
+						      "process*",
+						      1, MAX_PROCESS_STAR_ARGS), 
+			     env);
+  scheme_add_global_constant("system*", 
+			     scheme_make_prim_w_arity(sch_system_star,
+						      "system*",
+						      1, MAX_PROCESS_STAR_ARGS), 
+			     env);
+  scheme_add_global_constant("execute*", 
+			     scheme_make_prim_w_arity(sch_execute_star,
+						      "execute*", 
+						      1, MAX_PROCESS_STAR_ARGS), 
+			     env);
+
+  scheme_add_global_constant("tcp-connect", 
+			     scheme_make_prim_w_arity2(tcp_connect,
+						       "tcp-connect", 
+						       2, 2,
+						       2, 2), 
+			     env);
+  scheme_add_global_constant("tcp-listen", 
+			     scheme_make_prim_w_arity(tcp_listen,
+						      "tcp-listen", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("tcp-close", 
+			     scheme_make_prim_w_arity(tcp_stop,
+						      "tcp-close", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("tcp-accept-ready?", 
+			     scheme_make_prim_w_arity(tcp_accept_ready,
+						      "tcp-accept-ready?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("tcp-accept", 
+			     scheme_make_prim_w_arity2(tcp_accept,
+						       "tcp-accept", 
+						       1, 1,
+						       2, 2), 
+			     env);
+  scheme_add_global_constant("tcp-listener?", 
+			     scheme_make_folding_prim(tcp_listener_p,
+						      "tcp-listener?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("tcp-port-send-waiting?",
+			     scheme_make_prim_w_arity(tcp_port_send_waiting_p,
+						      "tcp-port-send-waiting?", 
+						      1, 1), 
+			     env);
+}
+
+
+#ifdef USE_DYNAMIC_FDSET_SIZE
+static int dynamic_fd_size;
+
+void *scheme_alloc_fdset_array(int count, int permanent)
+{
+  if (!dynamic_fd_size) {
+#ifdef USE_ULIMIT
+    dynamic_fd_size = ulimit(4, 0);
+#else
+    dynamic_fd_size = getdtablesize();
+#endif 
+    /* divide by bits-per-byte: */
+    dynamic_fd_size = dynamic_fd_size >> 3;
+    /* word-align: */
+    if (dynamic_fd_size % sizeof(void*))
+      dynamic_fd_size += sizeof(void*) - (dynamic_fd_size % sizeof(void*));
+  }   
+
+  if (permanent)
+    return scheme_malloc_eternal(count * dynamic_fd_size);
+  else
+    return scheme_malloc_atomic(count * dynamic_fd_size);
+}
+
+void *scheme_init_fdset_array(void *fdarray, int count)
+{
+  return fdarray;
+}
+
+void *scheme_get_fdset(void *fdarray, int pos)
+{
+  return ((char *)fdarray) + (pos * dynamic_fd_size);
+}
+
+void scheme_fdzero(void *fd)
+{
+  memset(fd, 0, dynamic_fd_size);
+}
+
+#else
+
+#ifdef WIN32_FD_HANDLES
+# define fdset_type win_extended_fd_set
+#else
+# define fdset_type fd_set
+#endif
+
+void *scheme_alloc_fdset_array(int count, int permanent)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP) || defined(WIN32_FD_HANDLES)
+  void *fdarray;
+  if (permanent)
+    fdarray = scheme_malloc_eternal(count * sizeof(fdset_type));
+  else
+    fdarray = scheme_malloc_atomic(count * sizeof(fdset_type));
+# ifdef WIN32_FD_HANDLES
+  if (count)
+    ((win_extended_fd_set *)fdarray)->num_handles = 0;
+# endif
+  return fdarray;
+#else
+  return NULL;
+#endif
+}
+
+void *scheme_init_fdset_array(void *fdarray, int count)
+{
+#ifdef WIN32_FD_HANDLES
+  if (count)
+    ((win_extended_fd_set *)fdarray)->num_handles = 0;
+#endif
+  return fdarray;
+}
+
+void *scheme_get_fdset(void *fdarray, int pos)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP)
+  return ((fdset_type *)fdarray) + pos;
+#else
+  return NULL;
+#endif
+}
+
+void scheme_fdzero(void *fd)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP)
+  FD_ZERO((fd_set *)fd);
+#endif
+}
+
+#endif
+
+void scheme_fdclr(void *fd, int n)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP)
+  FD_CLR(n, ((fd_set *)fd));
+#endif
+}
+
+void scheme_fdset(void *fd, int n)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP)
+  FD_SET(n, ((fd_set *)fd));
+#endif
+}
+
+int scheme_fdisset(void *fd, int n)
+{
+#if defined(FILES_HAVE_FDS) || defined(USE_SOCKETS_TCP)
+  return FD_ISSET(n, ((fd_set *)fd));
+#endif
+}
+
+#ifdef WIN32_FD_HANDLES
+static void add_fd_handle(HANDLE h, void *fds, int repost)
+{
+  win_extended_fd_set *efd = (win_extended_fd_set *)fds;
+  HANDLE *hs;
+  int i, *rps;
+  
+  i = efd->num_handles;
+  hs = MALLOC_N_ATOMIC(HANDLE, i + 3); /* Leave room for two more. */
+  rps = MALLOC_N_ATOMIC(int, i + 3);
+  hs[i] = h;
+  rps[i] = repost;
+  while (i--) {
+    hs[i] = efd->handles[i];
+    rps[i] = efd->repost_sema[i];
+  }
+  efd->num_handles++;
+  efd->handles= hs;
+  efd->repost_sema = rps;
+}
+#endif
+
+static Scheme_Object *
+scheme_make_eof (void)
+{
+  Scheme_Object *eof;
+
+  eof = scheme_alloc_eternal_object();
+  eof->type = scheme_eof_type;
+  return eof;
+}
+
+Scheme_Object *scheme_make_port_type(const char *name)
+{
+  return scheme_intern_symbol(name);
+}
+
+Scheme_Input_Port *
+_scheme_make_input_port(Scheme_Object *subtype,
+			void *data,
+			int (*getc_fun) (Scheme_Input_Port*),
+			int (*char_ready_fun) (Scheme_Input_Port*),
+			void (*close_fun) (Scheme_Input_Port*),
+			void (*need_wakeup_fun)(Scheme_Input_Port*, void *),
+			int must_close)
+{
+  Scheme_Input_Port *ip;
+
+  ip = MALLOC_ONE_TAGGED(Scheme_Input_Port);
+  ip->type = scheme_input_port_type;
+  ip->sub_type = subtype;
+  ip->port_data = data;
+  ip->getc_fun = getc_fun;
+  ip->char_ready_fun = char_ready_fun;
+  ip->need_wakeup_fun = need_wakeup_fun;
+  ip->close_fun = close_fun;
+  ip->name = "stdin";
+  ip->ungotten = NULL;
+  ip->ungotten_count = 0;
+  ip->ungotten_allocated = 0;
+  ip->position = 0;
+  ip->lineNumber = 1;
+  ip->charsSinceNewline = 1;
+  ip->closed = 0;
+  ip->eoffound = 0;
+  ip->read_handler = NULL;
+
+#ifdef MZ_REAL_THREADS
+  ip->sema = scheme_make_sema(1);
+#endif
+
+  if (must_close)
+    ip->mref = scheme_add_managed(NULL,
+				  (Scheme_Object *)ip, 
+				  (Scheme_Close_Manager_Client *)scheme_close_input_port, 
+				  NULL, must_close);
+  else
+    ip->mref = NULL;
+
+  return (ip);
+}
+
+Scheme_Input_Port *
+scheme_make_input_port(Scheme_Object *subtype,
+		       void *data,
+		       int (*getc_fun) (Scheme_Input_Port*),
+		       int (*char_ready_fun) (Scheme_Input_Port*),
+		       void (*close_fun) (Scheme_Input_Port*),
+		       void (*need_wakeup_fun)(Scheme_Input_Port*, void *),
+		       int must_close)
+{
+  return _scheme_make_input_port(subtype, data,
+				 getc_fun, char_ready_fun, close_fun, 
+				 need_wakeup_fun, must_close);
+}
+
+Scheme_Output_Port *
+scheme_make_output_port(Scheme_Object *subtype,
+			void *data,
+			void (*write_string_fun)(char *str, long,
+						 Scheme_Output_Port*),
+			void (*close_fun) (Scheme_Output_Port*),
+			int must_close)
+{
+  Scheme_Output_Port *op;
+
+  op = MALLOC_ONE_TAGGED(Scheme_Output_Port);
+  op->type = scheme_output_port_type;
+  op->sub_type = subtype;
+  op->port_data = data;
+  op->write_string_fun = write_string_fun;
+  op->close_fun = close_fun;
+  op->closed = 0;
+  op->pos = 0;
+  op->display_handler = NULL;
+  op->write_handler = NULL;
+  op->print_handler = NULL;
+
+#ifdef MZ_REAL_THREADS
+  op->sema = scheme_make_sema(1);
+#endif
+
+  if (must_close)
+    op->mref = scheme_add_managed(NULL,
+				  (Scheme_Object *)op, 
+				  (Scheme_Close_Manager_Client *)scheme_close_output_port, 
+				  NULL, must_close);
+  else
+    op->mref = NULL;
+
+  return op;
+}
+
+#define check_closed(who, kind, port, closed) if (closed) scheme_raise_exn(MZEXN_I_O_PORT_CLOSED, port, "%s: " kind " port is closed", who);
+
+#ifdef MZ_REAL_THREADS
+# define BEGIN_LOCK_PORT(sema) \
+    { jmp_buf savebuf; \
+      scheme_wait_sema(sema, 0); \
+      memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf)); \
+      if (scheme_setjmp(scheme_error_buf)) { \
+        scheme_post_sema(sema); \
+        scheme_longjmp(savebuf, 1); \
+      } else {
+# define END_LOCK_PORT(sema) \
+      memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf)); \
+      scheme_post_sema(sema); } }
+#else
+# define BEGIN_LOCK_PORT(sema) /* empty */
+# define END_LOCK_PORT(sema) /* empty */
+#endif
+
+int
+scheme_getc (Scheme_Object *port)
+{
+  int c;
+  Scheme_Input_Port *ip;
+  
+  SCHEME_USE_FUEL(1);
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  if (ip->ungotten_count)
+    c = (unsigned char)ip->ungotten[--ip->ungotten_count];
+  else {
+    check_closed("#<primitive:get-port-char>", "input", port, ip->closed);
+    c = ip->getc_fun(ip);
+  }
+
+  if (c != EOF) {
+    ip->position++;
+    if (c == '\n' || c == '\r') {
+      ip->charsSinceNewline = 1;
+      ip->lineNumber++;
+    } else
+      ip->charsSinceNewline++;
+  } else
+    ip->eoffound = 1;
+
+  END_LOCK_PORT(ip->sema);
+
+  return c;
+}
+
+long 
+scheme_get_chars(Scheme_Object *port, long size, char *buffer)
+{
+  Scheme_Input_Port *ip;
+  long got = 0, i, c;
+  long orig_size = size;
+  
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  check_closed("#<primitive:get-port-char>", "input", port, ip->closed);
+
+  if (ip->ungotten_count) {
+    long l, i;
+    char *s;
+
+    if (ip->ungotten_count < size)
+      l = ip->ungotten_count;
+    else
+      l = size;
+    
+    i = ip->ungotten_count;
+    s = ip->ungotten;
+    while (l--)
+      buffer[got++] = s[--i];
+    
+    ip->ungotten_count = i;
+    size -= l;
+  }
+
+  if (size) {
+    if (SAME_OBJ(ip->sub_type, file_input_port_type)
+	&& ((Scheme_Input_File *)ip->port_data)->regfile) {
+      FILE *f = ((Scheme_Input_File *)ip->port_data)->f;
+      got += fread(buffer + got, 1, size, f);
+    } else if (SAME_OBJ(ip->sub_type, string_input_port_type)) {
+      Scheme_Indexed_String *is;
+      long l;
+      
+      is = (Scheme_Indexed_String *)ip->port_data;
+      
+      if (is->index + size <= is->size)
+	l = size;
+      else
+	l = (is->size - is->index);
+      
+      memcpy(buffer + got, is->string + is->index, l);
+      is->index += l;
+      
+      got += l;
+    } else {
+      /* use getc: */
+      int c;
+      
+      while (size--) {
+	c = ip->getc_fun(ip);
+	if (c != EOF)
+	  buffer[got++] = c;
+	else
+	  break;
+      }
+    }
+  }
+  
+  /* Adjust position information: */
+  ip->position += got;
+  for (i = got, c = 0; i--; c++) {
+    if (buffer[got] == '\n' || buffer[got] == '\r') {
+      break;
+    }
+  }
+  if (i >= 0) {
+    int n = 0;
+    ip->charsSinceNewline = c + 1;
+    while (i--)
+      if (buffer[got] == '\n' || buffer[got] == '\r')
+	n++;
+    ip->lineNumber += n;
+  } else
+    ip->charsSinceNewline += c;
+
+  if (got < orig_size)
+    ip->eoffound = 1;
+
+  END_LOCK_PORT(ip->sema);
+
+  return got;
+}
+
+int scheme_are_all_chars_ready(Scheme_Object *port)
+{
+  if (SCHEME_INPORTP(port)) {
+    Scheme_Input_Port *ip;
+    ip = (Scheme_Input_Port *)port;
+    if (SAME_OBJ(ip->sub_type, file_input_port_type)
+	&& ((Scheme_Input_File *)ip->port_data)->regfile)
+      return 1;
+    else if (SAME_OBJ(ip->sub_type, string_input_port_type))
+      return 1;
+    else
+      return 0;
+  } else
+    return 0;
+}
+
+void
+scheme_ungetc (int ch, Scheme_Object *port)
+{
+  Scheme_Input_Port *ip;
+
+  if (ch == EOF)
+    return;
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  check_closed("#<primitive:peek-port-char>", "input", port, ip->closed);
+
+  if (ip->ungotten_count == ip->ungotten_allocated) {
+    char *old;
+    int oldc;
+
+    old = ip->ungotten;
+    oldc = ip->ungotten_count;
+    if (oldc)
+      ip->ungotten_allocated = 2 * oldc;
+    else
+      ip->ungotten_allocated = 5;
+
+    ip->ungotten = (char *)scheme_malloc_atomic(ip->ungotten_allocated);
+    if (oldc)
+      memcpy(ip->ungotten, old, oldc);
+  }
+  ip->ungotten[ip->ungotten_count++] = ch;
+
+  if (ip->position)
+    --ip->position;
+  if (!(--ip->charsSinceNewline)) {
+    --ip->lineNumber;
+    /* If you back up over two lines, then lineNumber will be wrong. */
+  }
+
+  END_LOCK_PORT(ip->sema);
+}
+
+int
+scheme_char_ready (Scheme_Object *port)
+{
+  Scheme_Input_Port *ip;
+  int retval;
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  check_closed("char-ready?", "input", port, ip->closed);
+
+  if (ip->ungotten_count)
+    retval = 1;
+  else
+    retval = ip->char_ready_fun(ip);
+
+  END_LOCK_PORT(ip->sema);
+
+  return retval;
+}
+
+void
+scheme_need_wakeup (Scheme_Object *port, void *fds)
+{
+  Scheme_Input_Port *ip;
+
+  ip = (Scheme_Input_Port *)port;
+  
+  if (ip->need_wakeup_fun)
+    ((ip->need_wakeup_fun)(ip, fds));
+}
+
+long
+scheme_tell (Scheme_Object *port)
+{
+  Scheme_Input_Port *ip;
+  long pos;
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  check_closed("#<primitive:get-file-position>", "input", port, ip->closed);
+
+  pos = ip->position;
+
+  END_LOCK_PORT(ip->sema);
+
+  return pos;
+}
+
+long
+scheme_tell_line (Scheme_Object *port)
+{
+  Scheme_Input_Port *ip;
+  long line;
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  check_closed("#<primitive:get-file-line>", "input", port, ip->closed);
+
+  line = ip->lineNumber;
+
+  END_LOCK_PORT(ip->sema);
+
+  return line;
+}
+
+void
+scheme_close_input_port (Scheme_Object *port)
+{
+  Scheme_Input_Port *ip;
+
+  ip = (Scheme_Input_Port *)port;
+
+  BEGIN_LOCK_PORT(ip->sema);
+
+  if (!ip->closed) {
+    if (ip->mref)
+      scheme_remove_managed(ip->mref, (Scheme_Object *)ip);
+
+    if (ip->close_fun)
+      ip->close_fun(ip);
+    ip->closed = 1;
+    ip->ungotten_count = 0;
+  }
+
+  END_LOCK_PORT(ip->sema);
+}
+
+void 
+scheme_write_string(const char *str, long len, Scheme_Object *port)
+{
+  Scheme_Output_Port *op;
+
+  op = (Scheme_Output_Port *)port;
+
+  BEGIN_LOCK_PORT(op->sema);
+
+  check_closed("#<primitive:write-port-string>", "output", port, op->closed);
+
+  (op->write_string_fun)((char *)str, len, op);
+  op->pos += len;
+
+  END_LOCK_PORT(op->sema);
+}
+
+long
+scheme_output_tell(Scheme_Object *port)
+{
+  Scheme_Output_Port *op;
+  long pos;
+
+  op = (Scheme_Output_Port *)port;
+
+  BEGIN_LOCK_PORT(op->sema);
+
+  check_closed("#<primitive:get-file-position>", "output", port, op->closed);
+
+  pos = op->pos;
+
+  END_LOCK_PORT(op->sema);
+
+  return pos;
+}
+
+void
+scheme_close_output_port (Scheme_Object *port)
+{
+  Scheme_Output_Port *op;
+
+  op = (Scheme_Output_Port *)port;
+
+  BEGIN_LOCK_PORT(op->sema);
+
+  if (!op->closed) {
+    if (op->mref)
+      scheme_remove_managed(op->mref, (Scheme_Object *)op);
+
+    if (op->close_fun)
+      op->close_fun(op);
+    op->closed = 1;
+  }
+
+  END_LOCK_PORT(op->sema);
+}
+
+/* file input ports */
+
+#ifdef USE_FD_PORTS
+static void flush_fd(Scheme_Output_Port *op)
+{
+  Scheme_FD *fop = (Scheme_FD *)op->port_data;
+
+  if (fop->bufcount) {
+    long len;
+    len = write(fop->fd, fop->buffer, fop->bufcount);
+    if (len != fop->bufcount) {
+      /* Uh-oh */
+    }
+    fop->bufcount = 0;
+  }
+}
+#endif
+
+static void flush_orig_outputs()
+{
+  /* Flush original output ports: */
+  Scheme_Output_Port *op;
+  
+  op = (Scheme_Output_Port *)scheme_orig_stdout_port;
+#ifdef USE_FD_PORTS
+  if (SAME_OBJ(op->sub_type, fd_output_port_type))
+    flush_fd(op);
+  else
+#endif
+    if (SAME_OBJ(op->sub_type, file_output_port_type))
+      fflush(((Scheme_Output_File *)op->port_data)->f);
+  
+  op = (Scheme_Output_Port *)scheme_orig_stderr_port;
+#ifdef USE_FD_PORTS
+  if (SAME_OBJ(op->sub_type, fd_output_port_type))
+    flush_fd(op);
+  else
+#endif
+    if (SAME_OBJ(op->sub_type, file_output_port_type))
+      fflush(((Scheme_Output_File *)op->port_data)->f);
+}
+
+static int
+file_char_ready (Scheme_Input_Port *port)
+{
+  FILE *fp;
+  Scheme_Input_File *fip;
+
+  fip = (Scheme_Input_File *)port->port_data;
+  fp = fip->f;
+
+  if (fip->regfile)
+    return 1;
+
+#ifdef HAS_STANDARD_IOB  
+  if (fp->_cnt)
+    return 1;
+#endif
+#ifdef HAS_GNU_IOB
+  if (fp->_egptr - fp->_gptr)
+    return 1;
+#endif
+#ifdef HAS_LINUX_IOB
+  if (fp->_IO_read_end - fp->_IO_read_ptr)
+    return 1;
+#endif
+#ifdef HAS_BSD_IOB
+  if (fp->_r > 0)
+    return 1;
+#endif
+
+  if (feof(fp) || ferror(fp))
+    return 1;
+
+#ifdef FILES_HAVE_FDS
+  {
+    int fd;
+    DECL_FDSET(readfds, 1);
+    struct timeval time = {0, 0};
+
+    INIT_DECL_FDSET(readfds, 1);
+
+    fd = fileno(fp);
+    if (fd < 0)
+      return 1; /* No descriptor? Go ahead and read EOF */
+    
+    MZ_FD_ZERO(readfds);
+    MZ_FD_SET(fd, readfds);
+    
+    return select(fd + 1, readfds, NULL, NULL, &time);
+  }
+#else
+  return 1;
+#endif
+}
+
+static int file_getc(Scheme_Input_Port *port)
+{
+  FILE *fp;
+  Scheme_Input_File *fip;
+  int c;
+
+  fip = (Scheme_Input_File *)port->port_data;
+  fp = fip->f;
+
+  if (!fip->regfile && !file_char_ready(port)) {
+#if defined(FILES_HAVE_FDS) || defined(WIN32_FD_HANDLES)
+    scheme_current_process->block_descriptor = PORT_BLOCKED;
+    scheme_current_process->blocker = (Scheme_Object *)port;
+# define FILE_BLOCK_TIME (float)0.0
+#else
+# define FILE_BLOCK_TIME (float)0.5
+#endif
+    do
+      scheme_process_block(FILE_BLOCK_TIME);
+    while (!file_char_ready(port));
+#if defined(FILES_HAVE_FDS) || defined(WIN32_FD_HANDLES)
+    scheme_current_process->block_descriptor = NOT_BLOCKED;
+    scheme_current_process->blocker = NULL;
+#endif
+    scheme_current_process->ran_some = 1;
+  }
+
+  c = getc(fp);
+
+  if (c == EOF) {
+    if (!feof(fp)) {
+      scheme_raise_exn(MZEXN_I_O_READ,
+		       port,
+		       "error reading from file port (%d)",
+		       errno);
+      return 0;
+    }
+#ifndef DONT_CLEAR_FILE_EOF
+    clearerr(fp);
+#endif
+  }
+
+  return c;
+}
+
+static void
+file_close_input(Scheme_Input_Port *port)
+{
+  Scheme_Input_File *fip;
+
+  fip = (Scheme_Input_File *)port->port_data;
+
+  fclose(fip->f);
+  --scheme_file_open_count;
+}
+
+static void
+file_need_wakeup(Scheme_Input_Port *port, void *fds)
+{
+#ifdef FILES_HAVE_FDS
+  Scheme_Input_File *fip;
+  void *fds2;
+  int n;
+
+  fip = (Scheme_Input_File *)port->port_data;
+
+  n = fileno(fip->f);
+  MZ_FD_SET(n, (fd_set *)fds);
+  fds2 = MZ_GET_FDSET(fds, 2);
+  MZ_FD_SET(n, (fd_set *)fds2);
+#endif
+}
+
+Scheme_Object *
+_scheme_make_named_file_input_port(FILE *fp, const char *filename, 
+				   int regfile)
+{
+  Scheme_Input_Port *ip;
+  Scheme_Input_File *fip;
+
+  if (!fp)
+    scheme_signal_error("make-file-input-port(internal): "
+			"null file pointer");
+  
+  fip = (Scheme_Input_File *)scheme_malloc(sizeof(Scheme_Input_File));
+
+  fip->f = fp;
+  fip->regfile = regfile;
+
+  ip = _scheme_make_input_port(file_input_port_type,
+			       fip,
+			       file_getc,
+			       file_char_ready,
+			       file_close_input,
+			       file_need_wakeup,
+			       1);
+
+  ip->name = scheme_strdup(filename);
+
+  return (Scheme_Object *)ip;
+}
+
+Scheme_Object *
+scheme_make_named_file_input_port(FILE *fp, const char *filename)
+{
+  return _scheme_make_named_file_input_port(fp, filename, 0);
+}
+
+Scheme_Object *
+scheme_make_file_input_port(FILE *fp)
+{
+  return scheme_make_named_file_input_port(fp, "FILE");
+}
+
+#ifdef USE_FD_PORTS
+/* fd input ports */
+
+static int
+fd_char_ready (Scheme_Input_Port *port)
+{
+  Scheme_FD *fip;
+
+  fip = (Scheme_FD *)port->port_data;
+
+  if (fip->bufcount)
+    return 1;
+  else {
+    DECL_FDSET(readfds, 1);
+    struct timeval time = {0, 0};
+
+    INIT_DECL_FDSET(readfds, 1);
+
+    MZ_FD_ZERO(readfds);
+    MZ_FD_SET(fip->fd, readfds);
+    
+    return select(fip->fd + 1, readfds, NULL, NULL, &time);
+  }
+}
+
+static int fd_getc(Scheme_Input_Port *port)
+{
+  Scheme_FD *fip;
+
+  fip = (Scheme_FD *)port->port_data;
+
+  if (fip->bufcount) {
+    fip->bufcount--;
+    return fip->buffer[fip->buffpos++];
+  } else {
+    if (!fd_char_ready(port)) {
+      scheme_current_process->block_descriptor = PORT_BLOCKED;
+      scheme_current_process->blocker = (Scheme_Object *)port;
+      do
+	scheme_process_block(0.0);
+      while (!fd_char_ready(port));
+      scheme_current_process->block_descriptor = NOT_BLOCKED;
+      scheme_current_process->blocker = NULL;
+      scheme_current_process->ran_some = 1;
+    }
+
+    fip->bufcount = read(fip->fd, fip->buffer, MZPORT_FD_BUFFSIZE);
+    if (!fip->bufcount) {
+      fip->buffpos = 0;
+      return EOF;
+    } else {
+      fip->buffpos = 1;
+      fip->bufcount--;
+      return fip->buffer[0];
+    }
+  }
+}
+
+static void
+fd_close_input(Scheme_Input_Port *port)
+{
+  Scheme_FD *fip;
+
+  fip = (Scheme_FD *)port->port_data;
+
+  close(fip->fd);
+}
+
+static void
+fd_need_wakeup(Scheme_Input_Port *port, void *fds)
+{
+  Scheme_FD *fip;
+  void *fds2;
+  int n;
+
+  fip = (Scheme_FD *)port->port_data;
+
+  n = fip->fd;
+  MZ_FD_SET(n, (fd_set *)fds);
+  fds2 = MZ_GET_FDSET(fds, 2);
+  MZ_FD_SET(n, (fd_set *)fds2);
+}
+
+static Scheme_Object *
+make_fd_input_port(int fd, const char *filename)
+{
+  Scheme_Input_Port *ip;
+  Scheme_FD *fip;
+
+  fip = MALLOC_ONE(Scheme_FD);
+
+  fip->fd = fd;
+  fip->bufcount = 0;
+
+  ip = _scheme_make_input_port(fd_input_port_type,
+			       fip,
+			       fd_getc,
+			       fd_char_ready,
+			       fd_close_input,
+			       fd_need_wakeup,
+			       1);
+
+  ip->name = scheme_strdup(filename);
+
+  return (Scheme_Object *)ip;
+}
+
+#endif
+
+/* Win32 input ports that could block on reads */
+#ifdef WIN32_FD_HANDLES
+
+typedef struct {
+  FILE *fp;
+  HANDLE th;           /* worker thread */
+  HANDLE ready_sema;   /* hit when a char is ready */
+  HANDLE try_sema;     /* hit when a char is wanted */
+  char trying;         /* indicates that it's already trying to read */
+  char ready;          /* indicates that a character is ready */
+  int c;               /* ready character */
+} Tested_Input_File;
+
+static int tested_file_char_ready(Scheme_Input_Port *p)
+{
+  Tested_Input_File *tip;
+
+  tip = (Tested_Input_File *)p->port_data;
+
+  if (tip->ready)
+    return 1;
+ 
+  if (!tip->trying) {
+    tip->trying = 1;
+    ReleaseSemaphore(tip->try_sema, 1, NULL);
+  }
+
+  if (tip->trying) {
+    if (WaitForSingleObject(tip->ready_sema, 0) == WAIT_OBJECT_0) {
+      tip->ready = 1;
+      tip->trying = 0;
+      return 1;
+    } else
+      return 0;
+  }
+  
+  return 0;
+}
+
+static int tested_file_getc(Scheme_Input_Port *p)
+{
+  Tested_Input_File *tip;
+
+  tip = (Tested_Input_File *)p->port_data;
+
+  if (!tested_file_char_ready(p)) {
+    scheme_current_process->block_descriptor = PORT_BLOCKED;
+    scheme_current_process->blocker = (Scheme_Object *)p;
+    do
+      scheme_process_block((float)0.0);
+    while (!tested_file_char_ready(p));
+    scheme_current_process->block_descriptor = NOT_BLOCKED;
+    scheme_current_process->blocker = NULL;
+    scheme_current_process->ran_some = 1;
+  }
+
+  if (tip->c != EOF)
+    tip->ready = 0;
+    
+  return tip->c;
+}
+
+static void tested_file_close_input(Scheme_Input_Port *p)
+{
+  Tested_Input_File *tip;
+
+  tip = (Tested_Input_File *)p->port_data;
+
+  fclose(tip->fp); /* sends EOF to reader thread */
+  --scheme_file_open_count;
+
+  ReleaseSemaphore(tip->try_sema, 1, NULL);
+
+  WaitForSingleObject(tip->th, INFINITE);
+
+  CloseHandle(tip->th);
+  CloseHandle(tip->ready_sema);
+  CloseHandle(tip->try_sema);
+}
+
+static void tested_file_need_wakeup(Scheme_Input_Port *p, void *fds)
+{
+  Tested_Input_File *tip;
+
+  tip = (Tested_Input_File *)p->port_data;
+
+  add_fd_handle(tip->ready_sema, fds, 1);
+}
+
+static long read_for_tested_file(void *data)
+{
+  Tested_Input_File *tip;
+  int c = 0;
+
+  tip = (Tested_Input_File *)data;
+
+  while (c != EOF) {
+    WaitForSingleObject(tip->try_sema, INFINITE);
+    c = tip->c = fgetc(tip->fp);
+    ReleaseSemaphore(tip->ready_sema, 1, NULL);
+  }
+
+  return 0;
+}
+
+static Scheme_Object *make_tested_file_input_port(FILE *fp, char *name, int tested)
+{
+  Scheme_Input_Port *ip;
+  Tested_Input_File *tip;
+  DWORD id;
+
+  if (!tested)
+    return scheme_make_named_file_input_port(fp, name);
+    
+  tip = (Tested_Input_File *)scheme_malloc(sizeof(Tested_Input_File));
+
+  tip->fp = fp;
+
+  tip->ready = 0;
+  tip->trying = 0;
+  tip->ready_sema = CreateSemaphore(NULL, 0, 1, NULL);
+  tip->try_sema = CreateSemaphore(NULL, 0, 1, NULL);
+
+  tip->th = _beginthreadex(NULL, 5000, 
+			   (LPTHREAD_START_ROUTINE)read_for_tested_file,
+			   tip, 0, &id);
+
+  if (!tip->th) {
+    /* Thread creation failed; give up niceness: */
+    return scheme_make_named_file_input_port(fp, name);
+  }
+
+  ip = _scheme_make_input_port(tested_file_input_port_type,
+			       tip,
+			       tested_file_getc,
+			       tested_file_char_ready,
+			       tested_file_close_input,
+			       tested_file_need_wakeup,
+			       1);
+
+  ip->name = scheme_strdup(name);
+
+  return (Scheme_Object *)ip;
+}
+
+#endif
+
+/* string input ports */
+
+static int 
+string_getc (Scheme_Input_Port *port)
+{
+  Scheme_Indexed_String *is;
+
+  is = (Scheme_Indexed_String *) port->port_data;
+  if (is->index >= is->size)
+    return (EOF);
+  else
+    return (unsigned char)(is->string[is->index++]);
+}
+
+static int
+string_char_ready (Scheme_Input_Port *port)
+{
+  Scheme_Indexed_String *is;
+
+  is = (Scheme_Indexed_String *) port->port_data;
+  return (is->index < is->size);
+}
+
+static void
+string_close_in (Scheme_Input_Port *port)
+{
+  return;
+}
+
+static Scheme_Indexed_String *
+make_indexed_string (const char *str, long len)
+{
+  Scheme_Indexed_String *is;
+
+  is = (Scheme_Indexed_String *)scheme_malloc(sizeof(Scheme_Indexed_String));
+  if (str) {
+    if (len < 0) {
+      is->string = (char *)str;
+      is->size = -len;
+    } else {
+      is->string = (char *)scheme_malloc_atomic(len);
+      memcpy(is->string, str, len);
+      is->size = len;
+    }
+  } else {
+    is->size = 100;
+    is->string = (char *)scheme_malloc_atomic(is->size + 1);
+  }
+  is->index = 0;
+  return (is);
+}
+
+Scheme_Object *
+scheme_make_sized_string_input_port(const char *str, long len)
+{
+  Scheme_Input_Port *ip;
+
+  ip = _scheme_make_input_port(string_input_port_type,
+			       make_indexed_string(str, len),
+			       string_getc,
+			       string_char_ready,
+			       string_close_in,
+			       NULL, 
+			       0);
+
+  ip->name = "STRING";
+
+  return (Scheme_Object *)ip;
+}
+
+Scheme_Object *
+scheme_make_string_input_port(const char *str)
+{
+  return scheme_make_sized_string_input_port(str, strlen(str));
+}
+
+/* string output ports */
+
+static void
+string_write_string(char *str, long len, Scheme_Output_Port *port)
+{
+  Scheme_Indexed_String *is;
+
+  is = (Scheme_Indexed_String *) port->port_data;
+
+  if (is->index + len >= is->size) {
+    char *old;
+
+    old = is->string;
+
+    if (len > is->size)
+      is->size += 2 * len;
+    else
+      is->size *= 2;
+
+    is->string = (char *)scheme_malloc_atomic(is->size + 1);
+    memcpy(is->string, old, is->index);
+  }
+  
+  memcpy(is->string + is->index, str, len);
+  is->index += len;
+}
+
+static void
+string_close_out (Scheme_Output_Port *port)
+{
+  return;
+}
+
+Scheme_Object *
+scheme_make_string_output_port (void)
+{
+  Scheme_Output_Port *op;
+
+  op = scheme_make_output_port (string_output_port_type,
+				make_indexed_string(NULL, 0),
+				string_write_string,
+				string_close_out,
+				0);
+
+  return (Scheme_Object *)op;
+}
+
+char *
+scheme_get_sized_string_output(Scheme_Object *port, int *size)
+{
+  Scheme_Output_Port *op;
+  Scheme_Indexed_String *is;
+  char *v;
+
+  if (!SCHEME_OUTPORTP(port))
+    return NULL;
+
+  op = (Scheme_Output_Port *)port;
+  if (op->sub_type != string_output_port_type)
+    return NULL;
+
+  is = (Scheme_Indexed_String *)op->port_data;
+
+  v = (char *)scheme_malloc_atomic(is->index + 1);
+  memcpy(v, is->string, is->index);
+  v[is->index] = 0;
+  
+  if (size)
+    *size = is->index;
+
+  return v;
+}
+
+char *
+scheme_get_string_output(Scheme_Object *port)
+{
+  return scheme_get_sized_string_output(port, NULL);
+}
+
+/* user input ports */
+
+static int 
+user_getc (Scheme_Input_Port *port)
+{
+  Scheme_Object *fun, *val;
+
+  fun = ((Scheme_Object **) port->port_data)[0];
+  val = _scheme_apply(fun, 0, NULL);
+  if (SCHEME_EOFP(val))
+    return EOF;
+  else {
+    if (!SCHEME_CHARP(val))
+      scheme_raise_exn(MZEXN_I_O_USER_PORT,
+		       port,
+		       "port: user getc returned a non-character");
+    return (unsigned char)SCHEME_CHAR_VAL(val);
+  }
+}
+
+static int
+user_char_ready(Scheme_Input_Port *port)
+{
+  Scheme_Object *fun, *val;
+
+  fun = ((Scheme_Object **) port->port_data)[1];
+  val = _scheme_apply(fun, 0, NULL);
+  return SAME_OBJ(val, scheme_true);
+}
+
+static void
+user_close_input(Scheme_Input_Port *port)
+{
+  Scheme_Object *fun;
+
+  fun = ((Scheme_Object **) port->port_data)[2];
+  _scheme_apply_multi(fun, 0, NULL);
+}
+
+/* file output ports */
+
+static void
+file_write_string(char *str, long len, Scheme_Output_Port *port)
+{
+  FILE *fp;
+
+  if (!len)
+    return;
+
+  fp = ((Scheme_Output_File *)port->port_data)->f;
+
+  if (fwrite(str, len, 1, fp) != 1) {
+    scheme_raise_exn(MZEXN_I_O_WRITE,
+		     port,
+		     "error writing to file port (%d)",
+		     errno);
+    return;
+  }
+
+  while (len--) {
+    if (*str == '\n' || *str == '\r') {
+      fflush(fp);
+      break;
+    }
+    str++;
+  }
+}
+
+static void
+file_close_output(Scheme_Output_Port *port)
+{
+  Scheme_Output_File *fop = (Scheme_Output_File *)port->port_data;
+  FILE *fp = fop->f;
+
+  fclose(fp);
+  --scheme_file_open_count;
+}
+
+Scheme_Object *
+scheme_make_file_output_port(FILE *fp)
+{
+  Scheme_Output_File *fop;
+
+  if (!fp)
+    scheme_signal_error("make-file-out-port(internal): "
+			"null file pointer");
+  
+  fop = (Scheme_Output_File *)scheme_malloc(sizeof(Scheme_Output_File));
+
+  fop->f = fp;
+
+  return (Scheme_Object *)scheme_make_output_port(file_output_port_type,
+						  fop,
+						  file_write_string,
+						  file_close_output,
+						  1);
+}
+
+#ifdef USE_FD_PORTS
+/* fd output ports */
+
+static void
+fd_write_string(char *str, long len, Scheme_Output_Port *port)
+{
+  Scheme_FD *fop;
+  long l;
+
+  if (!len)
+    return;
+
+  fop = (Scheme_FD *)port->port_data;
+
+  l = MZPORT_FD_BUFFSIZE - fop->bufcount;
+  if (len <= l) {
+    memcpy(fop->buffer + fop->bufcount, str, len);
+    fop->bufcount += len;
+  } else {
+    if (fop->bufcount) {
+      if (write(fop->fd, fop->buffer, fop->bufcount) != fop->bufcount) {
+	scheme_raise_exn(MZEXN_I_O_WRITE,
+			 port,
+			 "error writing to file port (%d)",
+			 errno);
+	return;
+      }
+      fop->bufcount = 0;
+    }
+    if (len <= MZPORT_FD_BUFFSIZE) {
+      memcpy(fop->buffer, str, len);
+      fop->bufcount = len;
+    } else {
+      if (write(fop->fd, str, len) != len) {
+	scheme_raise_exn(MZEXN_I_O_WRITE,
+			 port,
+			 "error writing to file port (%d)",
+			 errno);
+	return;
+      }
+      return; /* Don't check for flush */
+    }
+  }
+
+  while (len--) {
+    if (*str == '\n' || *str == '\r') {
+      /* Flush: */
+      if (write(fop->fd, fop->buffer, fop->bufcount) != fop->bufcount) {
+	scheme_raise_exn(MZEXN_I_O_WRITE,
+			 port,
+			 "error writing to file port (%d)",
+			 errno);
+	return;
+      }
+      fop->bufcount = 0;
+      break;
+    }
+    str++;
+  }
+}
+
+static void
+fd_close_output(Scheme_Output_Port *port)
+{
+  Scheme_FD *fop = (Scheme_FD *)port->port_data;
+
+  close(fop->fd);
+}
+
+Scheme_Object *
+make_fd_output_port(int fd)
+{
+  Scheme_FD *fop;
+
+  fop = MALLOC_ONE(Scheme_FD);
+
+  fop->fd = fd;
+  fop->bufcount = 0;
+
+  return (Scheme_Object *)scheme_make_output_port(fd_output_port_type,
+						  fop,
+						  fd_write_string,
+						  fd_close_output,
+						  1);
+}
+#endif
+
+/* user output ports */
+
+static void
+user_write(char *str, long len, Scheme_Output_Port *port)
+{
+  Scheme_Object *fun, *p[1];
+  
+  p[0] = scheme_make_sized_string(str, len, 1);
+
+  fun = ((Scheme_Object **) port->port_data)[0];
+  _scheme_apply_multi(fun, 1, p);
+}
+
+static void
+user_close_output (Scheme_Output_Port *port)
+{
+  Scheme_Object *fun;
+
+  fun = ((Scheme_Object **) port->port_data)[1];
+  _scheme_apply_multi(fun, 0, NULL);
+}
+
+static Scheme_Object *
+input_port_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_INPORTP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+output_port_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_OUTPORTP(argv[0]) ? scheme_true : scheme_false);
+}
+
+#define CURRENT_INPUT_PORT(config) scheme_get_param(config, MZCONFIG_INPUT_PORT)
+#define CURRENT_OUTPUT_PORT(config) scheme_get_param(config, MZCONFIG_OUTPUT_PORT)
+
+static Scheme_Object *current_input_port(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-input-port", MZCONFIG_INPUT_PORT,
+			     argc, argv,
+			     -1, input_port_p, "input-port", 0);
+}
+
+static Scheme_Object *current_output_port(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-output-port", MZCONFIG_OUTPUT_PORT,
+			     argc, argv,
+			     -1, output_port_p, "output-port", 0);
+}
+
+static Scheme_Object *current_error_port(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-error-port", MZCONFIG_ERROR_PORT,
+			     argc, argv,
+			     -1, output_port_p, "error port", 0);
+}
+
+static Scheme_Object *
+make_input_port(int argc, Scheme_Object *argv[])
+{
+  Scheme_Input_Port *ip;
+  Scheme_Object **copy;
+
+  scheme_check_proc_arity("make-input-port", 0, 0, argc, argv);
+  scheme_check_proc_arity("make-input-port", 0, 1, argc, argv);
+  scheme_check_proc_arity("make-input-port", 0, 2, argc, argv);
+  
+  copy = (Scheme_Object **)scheme_malloc_stubborn(3 * sizeof(Scheme_Object *));
+  memcpy(copy, argv, 3 * sizeof(Scheme_Object *));
+  scheme_end_stubborn_change((void *)copy);
+
+  ip = _scheme_make_input_port(user_input_port_type,
+			       copy,
+			       user_getc,
+			       user_char_ready,
+			       user_close_input,
+			       NULL,
+			       0);
+
+  ip->name = "USERPORT";
+
+  return (Scheme_Object *)ip;
+}
+
+static Scheme_Object *
+make_output_port (int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+  Scheme_Object **copy;
+
+  scheme_check_proc_arity("make-output-port", 1, 0, argc, argv);
+  scheme_check_proc_arity("make-output-port", 0, 1, argc, argv);
+
+  copy = (Scheme_Object **)scheme_malloc_stubborn(2 * sizeof(Scheme_Object *));
+  memcpy(copy, argv, 2 * sizeof(Scheme_Object *));
+  scheme_end_stubborn_change((void *)copy);
+
+  op = scheme_make_output_port(user_output_port_type,
+			       copy,
+			       user_write,
+			       user_close_output,
+			       0);
+
+  return (Scheme_Object *)op;
+}
+
+static void filename_exn(char *name, char *msg, char *filename, int err)
+{
+  char *dir, *drive;
+  int len;
+  char *pre, *rel, *post;
+
+  len = strlen(filename);
+
+  if (scheme_is_relative_path(filename, len)) {
+    dir = scheme_getcwd(NULL, 0, NULL, 1);
+    drive = NULL;
+  } else if (scheme_is_complete_path(filename, len)) {
+    dir = NULL;
+    drive = NULL;
+  } else {
+    dir = NULL;
+    drive = scheme_getdrive();
+  }
+  
+  pre = dir ? " in directory \"" : (drive ? " on drive " : "");
+  rel = dir ? dir : (drive ? drive : "");
+  post = dir ? "\"" : "";
+
+  scheme_raise_exn (MZEXN_I_O_FILESYSTEM_FILE,
+		    scheme_make_string(filename),
+		    "%s: %s: \"%.255s\"%s%.255s%s (%d)", 
+		    name, msg, filename,
+		    pre, rel, post,
+		    err);
+}
+
+static Scheme_Object *
+do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[])
+{
+  FILE *fp;
+  char *mode = "rb";
+  char *filename;
+  int regfile;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type(name, "string", offset, argc, argv);
+  if (argc > 1 + offset) {
+    if (!SCHEME_SYMBOLP(argv[offset + 1]))
+      scheme_wrong_type(name, "symbol", offset + 1, argc, argv);
+    
+    if (SAME_OBJ(argv[offset + 1], text_symbol))
+      mode = "rt";
+    else if (SAME_OBJ(argv[offset + 1], binary_symbol)) {
+      /* This is the default */
+    } else
+      scheme_raise_exn(MZEXN_APPLICATION_TYPE,
+		       argv[offset + 1],
+		       scheme_intern_symbol("input file mode"),
+		       "%s: bad mode '%s", name,
+		       scheme_symbol_name(argv[offset + 1]));
+  }
+  
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    name,
+				    NULL);
+
+  if (scheme_directory_exists(filename)) {
+    filename_exn(name, "cannot open directory as a file", filename, errno);
+    return scheme_void;
+  }
+
+  regfile = scheme_is_regular_file(filename);
+
+  fp = fopen(filename, mode);
+  if (!fp)
+    filename_exn(name, "cannot open input file", filename, errno);
+  scheme_file_open_count++;
+  
+  return _scheme_make_named_file_input_port(fp, filename, regfile);
+}
+
+static Scheme_Object *
+open_input_file (int argc, Scheme_Object *argv[])
+{
+  return do_open_input_file("open-input-file", 0, argc, argv);
+}
+
+static Scheme_Object *
+open_input_string (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("open-input-string", "string", 0, argc, argv);
+
+  return scheme_make_sized_string_input_port(SCHEME_STR_VAL(argv[0]), 
+					     SCHEME_STRTAG_VAL(argv[0]));
+}
+
+static Scheme_Object *
+do_open_output_file (char *name, int offset, int argc, Scheme_Object *argv[])
+{
+  FILE *fp;
+  int e_set = 0, m_set = 0, i;
+  int existsok = 0, namelen;
+  char mode[2] = {'w', 'b'}, *filename;
+#ifdef MAC_FILE_SYSTEM
+  int creating = 1;
+#endif
+  
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type(name, "string", 0, argc, argv);
+  
+  for (i = 1 + offset; argc > i; i++) {
+    if (!SCHEME_SYMBOLP(argv[i]))
+      scheme_wrong_type(name, "symbol", i, argc, argv);
+  
+    if (SAME_OBJ(argv[i], append_symbol)) {
+      mode[0] = 'a';
+      existsok = -1;
+      e_set++;
+    } else if (SAME_OBJ(argv[i], replace_symbol)) {
+      existsok = 1;
+      e_set++;
+    } else if (SAME_OBJ(argv[i], truncate_symbol)) {
+      existsok = -1;
+      e_set++;
+    } else if (SAME_OBJ(argv[i], error_symbol)) {
+      /* This is the default */
+      e_set++;
+    } else if (SAME_OBJ(argv[i], text_symbol)) {
+      mode[1] = 't';
+      m_set++;
+    } else if (SAME_OBJ(argv[i], binary_symbol)) {
+      /* This is the default */
+      m_set++;
+    } else
+      scheme_raise_exn(MZEXN_APPLICATION_TYPE,
+		       argv[i],
+		       scheme_intern_symbol("output file mode"),
+		       "%s: bad mode '%s", name,
+		       scheme_symbol_name(argv[i]));
+
+    if (m_set > 1 || e_set > 1)
+      scheme_raise_exn(MZEXN_APPLICATION_MODE_CONFLICT,
+		       argv[i],
+		       argv[0],
+		       "%s: conflicting or redundant "
+		       "file modes given", name);
+  }
+
+  filename = SCHEME_STR_VAL(argv[0]);
+  namelen = SCHEME_STRTAG_VAL(argv[0]);
+
+  filename = scheme_expand_filename(filename, namelen, name, NULL);
+
+  if (scheme_directory_exists(filename)) {
+    filename_exn(name, "cannot open directory as a file", filename, errno);
+    return scheme_void;
+  }
+
+#ifndef MAC_FILE_SYSTEM
+  if (existsok >= 0) {
+#endif
+    if (scheme_file_exists(filename)) {
+      if (!existsok)
+	scheme_raise_exn(MZEXN_I_O_FILESYSTEM_FILE_EXISTS,
+			 argv[0],
+			 "%s: file \"%s\" exists", name, filename);
+#ifdef MAC_FILE_SYSTEM
+      if (existsok > 0) {
+#endif
+	if (MSC_IZE(unlink)(filename))
+	  scheme_raise_exn(MZEXN_I_O_FILESYSTEM_FILE_EXISTS,
+			   argv[0],
+			   "%s: error deleting \"%s\"", 
+			   name, filename);
+#ifdef MAC_FILE_SYSTEM
+      } else
+	creating = 0;
+#endif
+    }
+#ifndef MAC_FILE_SYSTEM
+  }
+#endif
+
+  fp = fopen(filename, mode);
+  if (!fp)
+    filename_exn(name, "cannot open output file", filename, errno);
+  scheme_file_open_count++;
+
+#ifdef MAC_FILE_SYSTEM
+  if (creating)
+    scheme_file_create_hook(filename);
+#endif
+
+  return scheme_make_file_output_port(fp);
+}
+
+static Scheme_Object *
+open_output_file (int argc, Scheme_Object *argv[])
+{
+  return do_open_output_file("open-output-file", 0, argc, argv);
+}
+
+static Scheme_Object *
+open_output_string (int argc, Scheme_Object *argv[])
+{
+  return scheme_make_string_output_port();
+}
+
+static Scheme_Object *
+get_output_string (int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+  Scheme_Indexed_String *is;
+
+  op = (Scheme_Output_Port *)argv[0];
+  if (!SCHEME_OUTPORTP(argv[0]) 
+      || (op->sub_type != string_output_port_type))
+    scheme_wrong_type("get-output-string", "string output port", 0, argc, argv);
+
+  is = (Scheme_Indexed_String *)op->port_data;
+  is->string[is->index] = 0;
+
+  return scheme_make_sized_string(is->string, is->index, 1);
+}
+
+static Scheme_Object *
+close_input_port (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("close-input-port", "input-port", 0, argc, argv);
+
+  scheme_close_input_port (argv[0]);
+  return (scheme_void);
+}
+
+static Scheme_Object *
+close_output_port (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("close-output-port", "output-port", 0, argc, argv);
+
+  scheme_close_output_port (argv[0]);
+  return (scheme_void);
+}
+
+static Scheme_Object *
+call_with_output_file (int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *port, *v, **m;
+
+  scheme_check_proc_arity("call-with-output-file", 1, 1, argc, argv);
+
+  port = do_open_output_file("call-with-output-file", 1, argc, argv);
+  
+  v = _scheme_apply_multi(argv[1], 1, &port);
+
+  m = p->ku.multiple.array;
+  scheme_close_output_port(port);
+  p->ku.multiple.array = m;
+
+  return v;
+}
+
+static Scheme_Object *
+call_with_input_file(int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *port, *v, **m;
+
+  scheme_check_proc_arity("call-with-input-file", 1, 1, argc, argv);
+
+  port = do_open_input_file("call-with-input-file", 1, argc, argv);
+  
+  v = _scheme_apply_multi(argv[1], 1, &port);
+  
+  m = p->ku.multiple.array;
+  scheme_close_input_port(port);
+  p->ku.multiple.array = m;
+
+  return v;
+}
+
+static Scheme_Object *with_call_thunk(void *d)
+{
+  return _scheme_apply_multi(SCHEME_CAR((Scheme_Object *)d), 0, NULL);
+}
+
+static void with_set_output_port(void *d)
+{
+  Scheme_Config *config = scheme_config;
+
+  SCHEME_CDR(SCHEME_CDR((Scheme_Object *)d)) = scheme_get_param(config, MZCONFIG_OUTPUT_PORT);
+  scheme_set_param(config, MZCONFIG_OUTPUT_PORT, SCHEME_CAR(SCHEME_CDR((Scheme_Object *)d)));
+}
+
+static void with_unset_output_port(void *d)
+{
+  Scheme_Config *config = scheme_config;
+
+  scheme_set_param(config, MZCONFIG_OUTPUT_PORT, SCHEME_CDR(SCHEME_CDR((Scheme_Object *)d)));
+}
+
+static Scheme_Object *
+with_output_to_file (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port, *v;
+
+  scheme_check_proc_arity("with-output-to-file", 0, 1, argc, argv);
+
+  port = do_open_output_file("with-output-to-file", 1, argc, argv);
+  
+  v = scheme_dynamic_wind(with_set_output_port,
+			  with_call_thunk,
+			  with_unset_output_port,
+			  NULL,
+			  scheme_make_pair(argv[1], 
+					   scheme_make_pair(port,
+							    scheme_void)));
+
+  scheme_close_output_port(port);
+
+  return v;
+}
+
+static void with_set_input_port(void *d)
+{
+  Scheme_Config *config = scheme_config;
+
+  SCHEME_CDR(SCHEME_CDR((Scheme_Object *)d)) = scheme_get_param(config, MZCONFIG_INPUT_PORT);
+  scheme_set_param(config, MZCONFIG_INPUT_PORT, SCHEME_CAR(SCHEME_CDR((Scheme_Object *)d)));
+}
+
+static void with_unset_input_port(void *d)
+{
+  Scheme_Config *config = scheme_config;
+
+  scheme_set_param(config, MZCONFIG_INPUT_PORT, SCHEME_CDR(SCHEME_CDR((Scheme_Object *)d)));
+}
+
+static Scheme_Object *
+with_input_from_file(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port, *v;
+
+  scheme_check_proc_arity("with-input-from-file", 0, 1, argc, argv);
+
+  port = do_open_input_file("with-input-from-file", 1, argc, argv);
+  
+  v = scheme_dynamic_wind(with_set_input_port,
+			  with_call_thunk,
+			  with_unset_input_port,
+			  NULL,
+			  scheme_make_pair(argv[1], 
+					   scheme_make_pair(port,
+							    scheme_void)));
+
+  scheme_close_input_port(port);
+
+  return v;
+}
+
+static Scheme_Object *sch_default_read_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+
+  if (!SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("default-port-read-handler", "input-port", 0, argc, argv);
+
+  if ((Scheme_Object *)argv[0] == scheme_orig_stdin_port)
+    flush_orig_outputs();
+
+  return scheme_internal_read(argv[0],
+			      SCHEME_TRUEP(scheme_get_param(p->config, MZCONFIG_CAN_READ_COMPILED)),
+			      p->config
+#ifdef MZ_REAL_THREADS
+			      , p
+#endif
+			      );
+}
+
+static Scheme_Object *read_f(int argc, Scheme_Object *argv[])
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *port;
+
+  if (argc && !SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("read", "input-port", 0, argc, argv);
+
+  if (argc)
+    port = argv[0];
+  else
+    port = CURRENT_INPUT_PORT(p->config);
+  
+  if (((Scheme_Input_Port *)port)->read_handler) {
+    Scheme_Object *o[1];
+    o[0] = port;
+    return _scheme_apply(((Scheme_Input_Port *)port)->read_handler, 1, o);
+  } else {
+    if (port == scheme_orig_stdin_port)
+      flush_orig_outputs();
+
+    return scheme_internal_read(port,
+				SCHEME_TRUEP(scheme_get_param(p->config, MZCONFIG_CAN_READ_COMPILED)),
+				p->config
+#ifdef MZ_REAL_THREADS
+				, p
+#endif
+				);
+  }
+}
+
+static Scheme_Object *
+do_read_char(char *name, int argc, Scheme_Object *argv[], int peek)
+{
+  Scheme_Object *port;
+  int ch;
+
+  if (argc && !SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type(name, "input-port", 0, argc, argv);
+
+  if (argc)
+    port = argv[0];
+  else
+    port = CURRENT_INPUT_PORT(scheme_config);
+
+  ch = scheme_getc(port);
+
+  if (ch == EOF)
+    return (scheme_eof);
+  else {
+    if (peek)
+      scheme_ungetc(ch, port);
+    return _scheme_make_char(ch);
+  }
+}
+
+static Scheme_Object *
+read_char (int argc, Scheme_Object *argv[])
+{
+  return do_read_char("read-char", argc, argv, 0);
+}
+
+static Scheme_Object *
+peek_char (int argc, Scheme_Object *argv[])
+{
+  return do_read_char("peek-char", argc, argv, 1);
+}
+
+static Scheme_Object *
+read_line (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port;
+  int ch;
+  char *buf, *oldbuf, onstack[32];
+  long size = 31, oldsize, i = 0;
+
+  if (argc && !SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("read-line", "input-port", 0, argc, argv);
+
+  if (argc)
+    port = argv[0];
+  else
+    port = CURRENT_INPUT_PORT(scheme_config);
+
+  if ((Scheme_Object *)port == scheme_orig_stdin_port)
+    flush_orig_outputs();
+
+  buf = onstack;
+
+  while (1) {
+    ch = scheme_getc(port);
+    if (ch == EOF) {
+      if (!i)
+	return scheme_eof;
+      break;
+    }
+    if (ch == '\r' || ch == '\n')
+      break;
+    
+    if (i >= size) {
+      oldsize = size;
+      oldbuf = buf;
+
+      size *= 2;
+      buf = (char *)scheme_malloc_atomic(size + 1);
+      memcpy(buf, oldbuf, oldsize);
+    }
+    buf[i++] = ch;
+  }
+  buf[i] = '\0';
+
+  return scheme_make_sized_string(buf, i, buf == onstack);
+}
+
+static Scheme_Object *
+eof_object_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_EOFP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+char_ready_p (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port;
+
+  if (argc && !SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("char-ready?", "input-port", 0, argc, argv);
+
+  if (argc)
+    port = argv[0];
+  else
+    port = CURRENT_INPUT_PORT(scheme_config);
+  
+  return (scheme_char_ready(port) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *sch_default_display_handler(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[1]))
+    scheme_wrong_type("default-port-display-handler", "output-port", 1, argc, argv);
+
+  scheme_internal_display(argv[0], argv[1], scheme_config);
+
+  return scheme_void;
+}
+
+static Scheme_Object *sch_default_write_handler(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[1]))
+    scheme_wrong_type("default-port-write-handler", "output-port", 1, argc, argv);
+
+  scheme_internal_write(argv[0], argv[1], scheme_config);
+
+  return scheme_void;
+}
+
+static Scheme_Object *sch_default_print_handler(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[1]))
+    scheme_wrong_type("default-port-print-handler", "output-port", 1, argc, argv);
+
+  return _scheme_apply(scheme_get_param(scheme_config,
+					MZCONFIG_PORT_PRINT_HANDLER),
+		       argc, argv);
+}
+
+static Scheme_Object *sch_default_global_port_print_handler(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[1]))
+    scheme_wrong_type("default-global-port-print-handler", "output-port", 1, argc, argv);
+
+  scheme_internal_write(argv[0], argv[1], scheme_config);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+display_write(char *name, 
+	      int argc, Scheme_Object *argv[], int escape)
+{
+  Scheme_Object *port;
+  Scheme_Config *config = scheme_config;
+
+  if (argc > 1) {
+    if (!SCHEME_OUTPORTP(argv[1]))
+      scheme_wrong_type(name, "output-port", 1, argc, argv);
+    port = argv[1];
+  } else
+    port = CURRENT_OUTPUT_PORT(config);
+  
+  if (escape > 0) {
+    if (!((Scheme_Output_Port *)port)->display_handler) {
+      Scheme_Object *v = argv[0];
+#ifndef MZ_REAL_THREADS
+      if (SCHEME_STRINGP(v)) {
+	Scheme_Output_Port *op = (Scheme_Output_Port *)port;
+	int len = SCHEME_STRTAG_VAL(v);
+	check_closed(name, "output", port, op->closed);
+	(op->write_string_fun)(SCHEME_STR_VAL(v), 
+			       len,
+			       op);
+	op->pos += len;
+      } else
+#endif
+	scheme_internal_display(v, port, config);
+    } else {
+      Scheme_Object *a[2];
+      a[0] = argv[0];
+      a[1] = port;
+      _scheme_apply_multi(((Scheme_Output_Port *)port)->display_handler, 2, a);
+    }
+  } else if (!escape) {
+    Scheme_Object *h;
+
+    h = ((Scheme_Output_Port *)port)->write_handler;
+    
+    if (!h)
+      scheme_internal_write(argv[0], port, config);
+    else {
+      Scheme_Object *a[2];
+      a[0] = argv[0];
+      a[1] = port;
+      _scheme_apply_multi(h, 2, a);      
+    }
+  } else {
+    Scheme_Object *h;
+    Scheme_Object *a[2];
+    
+    a[0] = argv[0];
+    a[1] = port;
+    
+    h = ((Scheme_Output_Port *)port)->print_handler;
+						
+    if (!h)
+      sch_default_print_handler(2, a);
+    else
+      _scheme_apply_multi(h, 2, a);      
+  }
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+sch_write (int argc, Scheme_Object *argv[])
+{
+  return display_write("write", argc, argv, 0);
+}
+
+static Scheme_Object *
+display (int argc, Scheme_Object *argv[])
+{
+  return display_write("display", argc, argv, 1);
+}
+
+static Scheme_Object *
+print (int argc, Scheme_Object *argv[])
+{
+  return display_write("print", argc, argv, -1);
+}
+
+static Scheme_Object *
+newline (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port;
+
+  if (argc && !SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("newline", "output-port", 0, argc, argv);
+
+  if (argc)
+    port = argv[0];
+  else
+    port = CURRENT_OUTPUT_PORT(scheme_config);
+  
+  scheme_write_string("\n", 1, port);
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+write_char (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port;
+  Scheme_Output_Port *op;
+  unsigned char buffer[1];
+
+  if (argc && !SCHEME_CHARP(argv[0]))
+    scheme_wrong_type("write-char", "character", 0, argc, argv);
+  if (argc > 1) {
+    if (!SCHEME_OUTPORTP(argv[1]))
+      scheme_wrong_type("write-char", "output-port", 1, argc, argv);
+    port = argv[1];
+  } else
+    port = CURRENT_OUTPUT_PORT(scheme_config);
+
+  buffer[0] = SCHEME_CHAR_VAL(argv[0]);
+
+  op = (Scheme_Output_Port *)port;
+#ifdef MZ_REAL_THREADS
+  scheme_write_string((char *)buffer, 1, port);
+#else
+  check_closed("write-char", "output", port, op->closed);
+  (op->write_string_fun)((char *)buffer, 1, op);
+  op->pos++;
+#endif
+
+  return scheme_void;
+}
+
+static Scheme_Object *port_read_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Input_Port *ip;
+
+  if (!SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("port-read-handler", "input-port", 0, argc, argv);
+
+  ip = (Scheme_Input_Port *)argv[0];
+  if (argc == 1) {
+    if (ip->read_handler)
+      return ip->read_handler;
+    else
+      return default_read_handler;
+  } else {
+    scheme_check_proc_arity("port-read-handler", 1, 1, argc, argv);
+    if (argv[1] == default_read_handler)
+      ip->read_handler = NULL;
+    else
+      ip->read_handler = argv[1];
+
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *port_display_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+
+  if (!SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("port-display-handler", "output-port", 0, argc, argv);
+
+  op = (Scheme_Output_Port *)argv[0];
+  if (argc == 1) {
+    if (op->display_handler)
+      return op->display_handler;
+    else
+      return default_display_handler;
+  } else {
+    scheme_check_proc_arity("port-display-handler", 2, 1, argc, argv);
+    if (argv[1] == default_display_handler)
+      op->display_handler = NULL;
+    else
+      op->display_handler = argv[1];
+
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *port_write_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+
+  if (!SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("port-write-handler", "output-port", 0, argc, argv);
+
+  op = (Scheme_Output_Port *)argv[0];
+  if (argc == 1) {
+    if (op->write_handler)
+      return op->write_handler;
+    else
+      return default_write_handler;
+  } else {
+    scheme_check_proc_arity("port-write-handler", 2, 1, argc, argv);
+    if (argv[1] == default_write_handler)
+      op->write_handler = NULL;
+    else
+      op->write_handler = argv[1];
+
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *port_print_handler(int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+
+  if (!SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("port-print-handler", "output-port", 0, argc, argv);
+
+  op = (Scheme_Output_Port *)argv[0];
+  if (argc == 1) {
+    if (op->print_handler)
+      return op->print_handler;
+    else
+      return default_print_handler;
+  } else {
+    scheme_check_proc_arity("port-print-handler", 2, 1, argc, argv);
+    if (argv[1] == default_print_handler)
+      op->print_handler = NULL;
+    else
+      op->print_handler = argv[1];
+
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *global_port_print_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("global-port-print-handler", MZCONFIG_PORT_PRINT_HANDLER,
+			     argc, argv,
+			     2, NULL, NULL, 0);
+}
+
+typedef struct {
+  Scheme_Config *config;
+  Scheme_Object *port;
+  Scheme_Process *p;
+} LoadHandlerData;
+
+static void post_load_handler(void *data)
+{
+  LoadHandlerData *lhd = (LoadHandlerData *)data;
+
+  scheme_close_input_port((Scheme_Object *)lhd->port);
+}
+
+static Scheme_Object *do_load_handler(void *data)
+{  
+  LoadHandlerData *lhd = (LoadHandlerData *)data;
+  Scheme_Object *port = lhd->port;
+  Scheme_Process *p = lhd->p;
+  Scheme_Config *config = lhd->config;
+  Scheme_Object *last_val = scheme_void, *obj, **save_array = NULL;
+  int save_count = 0;
+
+  while ((obj = scheme_internal_read(port,
+				     1,
+				     config
+#ifdef MZ_REAL_THREADS
+				     , p
+#endif
+				     )) 
+	 && !SCHEME_EOFP(obj)) {
+    save_array = NULL;
+
+    last_val = _scheme_apply_multi(scheme_get_param(config, MZCONFIG_EVAL_HANDLER),
+				   1, &obj);
+
+    /* If multi, we must save then: */
+    if (last_val == SCHEME_MULTIPLE_VALUES) {
+      save_array = p->ku.multiple.array;
+      save_count = p->ku.multiple.count;
+    }
+  }
+
+  if (save_array) {
+    p->ku.multiple.array = save_array;
+    p->ku.multiple.count = save_count;
+  }
+
+  return last_val;
+}
+
+static Scheme_Object *default_load(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port;
+  char *filename;
+  int ch;
+  FILE *fp;
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Config *config = p->config;
+  LoadHandlerData *lhd;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("default-load-handler", "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    "load", 
+				    NULL);
+  fp = fopen(filename, "rb");
+  if (!fp) {
+    filename_exn("default-load-handler", "cannot open file for input", filename, errno);
+    return NULL;
+  }
+  scheme_file_open_count++;
+
+  port = _scheme_make_named_file_input_port(fp, filename, 
+					    scheme_is_regular_file(filename));
+
+  /* Skip over #! at beginning of file */
+  if ((ch = scheme_getc(port)) == '#') {
+    if ((ch = scheme_getc(port)) == '!') {
+      int oldch;
+    eol_loop:
+      oldch = 0;
+      while (1) {
+	ch = scheme_getc(port);
+	if (ch == '\n' || ch == '\r')
+	  break;
+	oldch = ch;
+      }
+      if (oldch == '\\')
+	goto eol_loop;
+    } else {
+      scheme_ungetc(ch, port);
+      scheme_ungetc('#', port);
+    }
+  } else
+    scheme_ungetc(ch, port);
+
+  lhd = MALLOC_ONE(LoadHandlerData);
+  lhd->p = p;
+  lhd->config = config;
+  lhd->port = port;
+
+  return scheme_dynamic_wind(NULL, do_load_handler, post_load_handler,
+			     NULL, (void *)lhd);
+}
+
+typedef struct {
+  int param;
+  Scheme_Object *filename;
+  Scheme_Config *config;
+  Scheme_Object *load_dir, *old_load_dir;
+} LoadData;
+
+static void pre_load(void *data)
+{
+  LoadData *ld = (LoadData *)data;
+
+  scheme_set_param(ld->config, MZCONFIG_LOAD_DIRECTORY, ld->load_dir);  
+}
+
+static void post_load(void *data)
+{
+  LoadData *ld = (LoadData *)data;
+
+  scheme_set_param(ld->config, MZCONFIG_LOAD_DIRECTORY, ld->old_load_dir);
+}
+
+static Scheme_Object *do_load(void *data)
+{  
+  LoadData *ld = (LoadData *)data;
+  Scheme_Object *argv[1];
+
+  argv[0] = ld->filename;
+  return _scheme_apply_multi(scheme_get_param(ld->config, ld->param), 1, argv);
+}
+
+Scheme_Object *scheme_load_with_clrd(int argc, Scheme_Object *argv[],
+				     char *who, int handler_param)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Config *config = p->config;
+  LoadData *ld;
+  const char *filename;
+  Scheme_Object *load_dir;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type(who, "string", 0, argc, argv);
+
+  filename = scheme_expand_filename(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]),
+				    who,
+				    NULL);
+
+  /* Calculate load directory */
+  load_dir = scheme_get_file_directory(filename);
+
+  ld = MALLOC_ONE(LoadData);
+  ld->param = handler_param;
+  ld->filename = scheme_make_sized_string((char *)filename, -1, 0);
+  ld->config = config;
+  ld->load_dir = load_dir;
+  ld->old_load_dir = scheme_get_param(config, MZCONFIG_LOAD_DIRECTORY);
+
+  return scheme_dynamic_wind(pre_load, do_load, post_load,
+			     NULL, (void *)ld);
+}
+
+static Scheme_Object *load(int argc, Scheme_Object *argv[])
+{
+  return scheme_load_with_clrd(argc, argv, "load", MZCONFIG_LOAD_HANDLER);
+}
+
+static Scheme_Object *
+current_load(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-load", MZCONFIG_LOAD_HANDLER,
+			     argc, argv,
+			     1, NULL, NULL, 0);
+}
+
+static Scheme_Object *abs_directory_p(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *d = argv[0];
+
+  if (!SCHEME_FALSEP(d)) {
+    char *expanded;
+    Scheme_Object *ed;
+    char *s;
+    int len;
+
+    if (!SCHEME_STRINGP(d))
+      return NULL;
+
+    s = SCHEME_STR_VAL(d);
+    len = SCHEME_STRTAG_VAL(d);
+
+    if (!scheme_is_complete_path(s, len))
+      scheme_raise_exn(MZEXN_I_O_FILESYSTEM_PATH,
+		       d,
+		       "current-load-relative-directory: not a complete path: \"%.255s\"",
+		       s);
+
+    expanded = scheme_expand_filename(s, len, "current-load-relative-directory", NULL);
+    ed = scheme_make_sized_string(expanded, strlen(expanded), 1);
+    if (!scheme_directory_exists(expanded)) {
+      scheme_raise_exn(MZEXN_I_O_FILESYSTEM_DIRECTORY,
+		       ed,
+		       "current-load-relative-directory: not a directory: \"%.255s\"",
+		       expanded);
+    }
+
+    return ed;
+  }
+
+  return scheme_false;
+}
+
+static Scheme_Object *
+current_load_directory(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-load-relative-directory", MZCONFIG_LOAD_DIRECTORY,
+			     argc, argv,
+			     -1, abs_directory_p, "string or #f", 1);
+}
+
+Scheme_Object *scheme_load(const char *file)
+{
+  Scheme_Object *p[1];
+  jmp_buf savebuf;
+  Scheme_Object *val;
+
+  p[0] = scheme_make_string(file);
+  memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+  if (scheme_setjmp(scheme_error_buf)) {
+    val = NULL;
+  } else {
+    val = scheme_apply(scheme_make_prim((Scheme_Prim *)load),
+		       1, p);
+  }
+  memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+
+  return val;
+}
+
+static Scheme_Object *require_library_use_compiled(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("require-library-use-compiled",
+			     MZCONFIG_REQ_LIB_USE_COMPILED,
+			     argc, argv,
+			     -1, NULL, NULL, 1);
+}
+
+static Scheme_Object *collection_path_p(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *o;
+
+  if (SCHEME_FALSEP(argv[0]))
+    return scheme_false;
+
+  if (scheme_proper_list_length(argv[0]) < 1)
+    return NULL;
+
+  o = argv[0];
+  while (!SCHEME_NULLP(o)) {
+    Scheme_Object *p = SCHEME_CAR(o);
+    if (!SCHEME_STRINGP(p) || 
+	!scheme_is_relative_path(SCHEME_STR_VAL(p),
+				 SCHEME_STRTAG_VAL(p)))
+      return NULL;
+    o = SCHEME_CDR(o);
+  }
+
+  return argv[0];
+}
+
+static Scheme_Object *current_require_relative_collection(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-require-relative-collection",
+			     MZCONFIG_REQUIRE_COLLECTION,
+			     argc, argv,
+			     -1, collection_path_p, "non-empty list of relative path strings or #f", 1);
+}
+
+static Scheme_Object *
+transcript_on(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("transcript-on", "string", 0, argc, argv);
+
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "transcript-on: not supported");
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+transcript_off(int argc, Scheme_Object *argv[])
+{
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "transcript-off: not supported");
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+_flush_output(int argc, Scheme_Object *argv[])
+{
+  Scheme_Output_Port *op;
+
+  if (argc && !SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("flush-output", "output-port", 0, argc, argv);
+
+  if (argc) 
+    op = (Scheme_Output_Port *)argv[0];
+  else
+    op = (Scheme_Output_Port *)CURRENT_OUTPUT_PORT(scheme_config);
+
+  if (SAME_OBJ(op->sub_type, file_output_port_type))
+    fflush (((Scheme_Output_File *)op->port_data)->f);
+#ifdef USE_FD_PORTS
+  if (SAME_OBJ(op->sub_type, fd_output_port_type))
+    flush_fd(op);
+#endif
+
+  return (scheme_void);
+}
+
+static Scheme_Object *
+flush_output (int argc, Scheme_Object *argv[])
+{
+  return _flush_output(argc, argv);
+}
+
+static Scheme_Object *
+file_position(int argc, Scheme_Object *argv[])
+{
+  FILE *f;
+
+  if (!SCHEME_OUTPORTP(argv[0]) && !SCHEME_INPORTP(argv[0]))
+    scheme_wrong_type("file-position", "port", 0, argc, argv);
+  if (argc == 2 && !SCHEME_INTP(argv[1]))
+    scheme_wrong_type("file-position", "integer", 1, argc, argv);
+
+  f = NULL;
+  if (SCHEME_OUTPORTP(argv[0])) {
+    Scheme_Output_Port *op;
+
+    op = (Scheme_Output_Port *)argv[0];
+    if (SAME_OBJ(op->sub_type, file_output_port_type))
+      f = ((Scheme_Output_File *)op->port_data)->f;
+    else if (argc < 2)
+      return scheme_make_integer(scheme_output_tell(argv[0]));
+  } else if (SCHEME_INPORTP(argv[0])) {
+    Scheme_Input_Port *ip;
+  
+    ip = (Scheme_Input_Port *)argv[0];
+    if (SAME_OBJ(ip->sub_type, file_input_port_type))
+      f = ((Scheme_Input_File *)ip->port_data)->f;
+    else if (argc < 2)
+      return scheme_make_integer(scheme_tell(argv[0]));
+  }
+
+  if (!f)
+    scheme_raise_exn(MZEXN_APPLICATION_FILE_POSITION,
+		     argv[0],
+		     "file-position: cannot move to position %d in a non-file port",
+		     SCHEME_INT_VAL(argv[1]));
+
+  if (argc > 1) {
+    fseek(f, SCHEME_INT_VAL(argv[1]), 0);
+    return scheme_void;
+  } else {
+    int p;
+    p = ftell(f);
+    return scheme_make_integer(p);
+  }
+}
+
+void scheme_flush_output(Scheme_Object *port)
+{
+  (void)_flush_output(1, &port);
+}
+
+typedef struct {
+  char *buf;
+  long buflen;
+  int bufstart, bufend;
+  int eof;
+#ifdef MZ_REAL_THREADS
+  int num_waiting;
+  void *change_mutex;
+  void *wait_sem;
+#endif
+} Scheme_Pipe;
+
+static int pipe_getc(Scheme_Input_Port *p)
+{
+  Scheme_Pipe *pipe;
+  int c;
+
+  pipe = (Scheme_Pipe *)(p->port_data);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(pipe->change_mutex);
+  c = (pipe->bufstart == pipe->bufend && !pipe->eof) ? 0 : 1;
+  if (!c) {
+    pipe->num_waiting++;
+    SCHEME_SEMA_UP(pipe->change_mutex);
+    SCHEME_SEMA_DOWN(pipe->wait_sem);
+    SCHEME_SEMA_DOWN(pipe->change_mutex);
+    scheme_process_block(0);
+  }
+#else
+  scheme_current_process->block_descriptor = PIPE_BLOCKED;
+  scheme_current_process->blocker = (Scheme_Object *)p;
+  while (pipe->bufstart == pipe->bufend && !pipe->eof)
+    scheme_process_block((float)0.0);
+  scheme_current_process->block_descriptor = NOT_BLOCKED;
+  scheme_current_process->ran_some = 1;
+#endif
+
+  if (pipe->bufstart == pipe->bufend)
+    c = EOF;
+  else {
+    c = pipe->buf[pipe->bufstart];
+    
+    pipe->bufstart = (pipe->bufstart + 1) % pipe->buflen;
+  }
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  return c;
+}
+
+static void pipe_write(char *str, long len, Scheme_Output_Port *p)
+{
+  Scheme_Pipe *pipe;
+  long avail, firstpos, firstn, secondn, endpos;
+
+  pipe = (Scheme_Pipe *)(p->port_data);
+  
+  if (pipe->eof)
+    return;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  if (pipe->bufstart <= pipe->bufend) {
+    firstn = pipe->buflen - pipe->bufend;
+    avail = firstn + pipe->bufstart - 1;
+    if (!pipe->bufstart)
+      --firstn;
+  } else {
+    firstn = avail = pipe->bufstart - pipe->bufend - 1;
+  }
+  firstpos = pipe->bufend;
+
+  if (avail < len) {
+    char *old;
+    int newlen;
+
+    old = pipe->buf;
+    newlen = 2 * (pipe->buflen + len);
+
+    pipe->buf = (char *)scheme_malloc_atomic(newlen);
+
+    if (pipe->bufstart <= pipe->bufend) {
+      memcpy(pipe->buf, old + pipe->bufstart, pipe->bufend - pipe->bufstart);
+      pipe->bufend -= pipe->bufstart;
+      pipe->bufstart = 0;
+    } else {
+      int slen;
+      slen = pipe->buflen - pipe->bufstart;
+      memcpy(pipe->buf, old + pipe->bufstart, slen);
+      memcpy(pipe->buf + slen, old, pipe->bufend);
+      pipe->bufstart = 0;
+      pipe->bufend += slen;
+    }
+
+    pipe->buflen = newlen;
+
+    firstpos = pipe->bufend;
+    firstn = len;
+    endpos = firstpos + firstn;
+
+    secondn = 0;
+  } else {
+    if (firstn >= len) {
+      firstn = len;
+      endpos = (firstpos + len) % pipe->buflen;
+      secondn = 0;
+    } else {
+      secondn = len - firstn;
+      endpos = secondn;
+    }
+  }
+
+  if (firstn)
+    memcpy(pipe->buf + firstpos, str, firstn);
+  if (secondn)
+    memcpy(pipe->buf, str + firstn, secondn);
+
+  pipe->bufend = endpos;
+
+#ifdef MZ_REAL_THREADS
+  if (pipe->num_waiting) {
+    --pipe->num_waiting;
+    SCHEME_SEMA_UP(pipe->wait_sem);
+  }
+  SCHEME_UNLOCK_MUTEX(pipe->change_mutex);
+#endif
+}
+
+static int pipe_char_ready(Scheme_Input_Port *p)
+{
+  Scheme_Pipe *pipe;
+  int v;
+
+  pipe = (Scheme_Pipe *)(p->port_data);
+  
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  v = (pipe->bufstart != pipe->bufend || pipe->eof);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  return v;
+}
+
+static void pipe_in_close(Scheme_Input_Port *p)
+{
+  Scheme_Pipe *pipe;
+
+  pipe = (Scheme_Pipe *)(p->port_data);
+  
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  pipe->eof = 1;
+
+#ifdef MZ_REAL_THREADS
+  while (pipe->num_waiting) {
+    --pipe->num_waiting;
+    SCHEME_SEMA_UP(pipe->wait_sem);
+  }
+
+  SCHEME_UNLOCK_MUTEX(pipe->change_mutex);
+#endif
+}
+
+static void pipe_out_close(Scheme_Output_Port *p)
+{
+  Scheme_Pipe *pipe;
+
+  pipe = (Scheme_Pipe *)(p->port_data);
+  
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(pipe->change_mutex);
+#endif
+
+  pipe->eof = 1;
+
+#ifdef MZ_REAL_THREADS
+  while (pipe->num_waiting) {
+    --pipe->num_waiting;
+    SCHEME_SEMA_UP(pipe->wait_sem);
+  }
+
+  SCHEME_UNLOCK_MUTEX(pipe->change_mutex);
+#endif
+}
+
+#ifdef MZ_REAL_THREADS
+static void free_semas(void *p, void *ignored)
+{
+  Scheme_Pipe *pipe;
+
+  pipe = (Scheme_Pipe *)p;
+
+  SCHEME_FREE_SEMA(pipe->wait_sem);
+  SCHEME_FREE_MUTEX(pipe->change_mutex);
+}
+#endif
+
+void scheme_pipe(Scheme_Object **read, Scheme_Object **write)
+{
+  Scheme_Pipe *pipe;
+  Scheme_Input_Port *readp;
+  Scheme_Output_Port *writep;
+
+  pipe = (Scheme_Pipe *)scheme_malloc(sizeof(Scheme_Pipe));
+  pipe->buflen = 100;
+  pipe->buf = (char *)scheme_malloc_atomic(pipe->buflen);
+  pipe->bufstart = pipe->bufend = 0;
+  pipe->eof = 0;
+#ifdef MZ_REAL_THREADS
+  pipe->num_waiting = 0;
+  pipe->change_mutex = SCHEME_MAKE_MUTEX();
+  pipe->wait_sem = SCHEME_MAKE_SEMA(0);
+
+  scheme_add_finalizer(pipe, free_semas, NULL);
+#endif
+
+  readp = _scheme_make_input_port(pipe_read_port_type,
+				  (void *)pipe,
+				  pipe_getc,
+				  pipe_char_ready,
+				  pipe_in_close,
+				  NULL,
+				  0);
+
+  readp->name = "PIPE";
+
+  writep = scheme_make_output_port(pipe_write_port_type,
+				   (void *)pipe,
+				   pipe_write,
+				   pipe_out_close,
+				   0);
+
+  *read = (Scheme_Object *)readp;
+  *write = (Scheme_Object *)writep;
+}
+
+static Scheme_Object *sch_pipe(int argc, Scheme_Object **args)
+{
+  Scheme_Object *v[2];
+
+  scheme_pipe(&v[0], &v[1]);
+
+  return scheme_values(2, v);
+}
+
+#ifdef PROCESS_FUNCTION
+
+#ifdef WINDOWS_PROCESSES
+#include <Process.h>
+#include <fcntl.h>
+#define _EXTRA_PIPE_ARGS , 256, _O_BINARY
+#else
+#define _EXTRA_PIPE_ARGS
+#endif
+
+#endif
+
+#ifdef UNIX_PROCESSES
+
+# define WAITANY(s) waitpid((pid_t)-1, s, WNOHANG)
+
+static void child_done(int ingored)
+{
+  pid_t result;
+  int status;
+  System_Child *sc, *prev;
+
+  do {
+    do {
+      result = WAITANY(&status);
+    } while ((result == -1) && (errno == EINTR));
+    
+    if (result > 0) {
+      if (WIFEXITED(status)) {
+	if (WEXITSTATUS(status))
+	  status = 0;
+	else
+	  status = 1;
+      } else
+	status = 0;
+
+      prev = NULL;
+      for (sc = scheme_system_children; sc; prev = sc, sc = sc->next) {
+	if (sc->id == result) {
+	  sc->done = 1;
+	  sc->status = status;
+	  
+	  if (prev)
+	    prev->next = sc->next;
+	  else
+	    scheme_system_children = sc->next;
+	}
+      }
+    }
+  } while (result > 0);
+
+# ifdef SIGSET_NEEDS_REINSTALL
+  MZ_SIGSET(SIGCHLD, child_done);
+# endif
+}
+
+#endif
+
+#if defined(UNIX_PROCESSES) || defined(WINDOWS_PROCESSES)
+
+static int subp_done(Scheme_Object *sci)
+{
+#ifdef UNIX_PROCESSES
+  System_Child *sc = (System_Child *)sci;
+  return sc->done;
+#endif
+#ifdef WINDOWS_PROCESSES
+  DWORD w;
+  if (sci) {
+    if (GetExitCodeProcess((HANDLE)sci, &w))
+      return w != STILL_ACTIVE;
+  } else
+    return 1;
+#endif
+}
+
+static void subp_needs_wakeup(Scheme_Object *sci, void *fds)
+{
+#ifdef WINDOWS_PROCESSES
+  add_fd_handle((HANDLE)sci, fds, 0);
+#endif
+}
+
+static Scheme_Object *get_process_status(void *sci, int argc, Scheme_Object **argv)
+{
+  if (SAME_OBJ(argv[0], scheme_intern_symbol("status"))) {
+#ifdef UNIX_PROCESSES
+    System_Child *sc = (System_Child *)sci;
+    
+    if (sc->done) {
+      if (sc->status)
+	return scheme_intern_symbol("done-ok");
+      else
+	return scheme_intern_symbol("done-error");	
+    } else
+      return scheme_intern_symbol("running");
+#else
+# ifdef WINDOWS_PROCESSES
+    DWORD w;
+    if (!sci)
+      return scheme_intern_symbol("done-error");
+    
+    if (GetExitCodeProcess((HANDLE)sci, &w)) {
+      if (w == STILL_ACTIVE)
+	return scheme_intern_symbol("running");
+      else if (w)
+	return scheme_intern_symbol("done-error");
+      else
+	return scheme_intern_symbol("done-ok");
+    }
+# endif
+    return scheme_intern_symbol("unknown");
+#endif
+  } else if (SAME_OBJ(argv[0], scheme_intern_symbol("wait")))
+    scheme_block_until(subp_done, subp_needs_wakeup, sci, (float)0.0);
+  else
+    scheme_wrong_type("control-process", "'status or 'wait", 0, argc, argv);
+  return scheme_void;
+}
+#endif
+
+static Scheme_Object *process(int c, Scheme_Object *args[], 
+			      char *name, int shell, int synchonous, 
+			      int as_child)
+{
+#ifdef PROCESS_FUNCTION
+  char *command;
+  int to_subprocess[2], from_subprocess[2], err_subprocess[2];
+  int i, pid;
+  char **argv;
+  Scheme_Object *in, *out, *subpid, *err, *thunk;
+#ifdef UNIX_PROCESSES
+  System_Child *sc;
+#else
+  void *sc = 0;
+#endif
+#ifdef WINDOWS_PROCESSES
+  int spawn_status;
+
+  /* Don't know how to do these, yet */
+  if (shell && (!as_child || !synchonous)) {
+    scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		     "%s: not supported on this platform",
+		     name);
+  }
+#endif
+
+  if (!SCHEME_STRINGP(args[0]) || scheme_string_has_null(args[0]))
+    scheme_wrong_type(name, STRING_W_NO_NULLS, 0, c, args);
+
+  if (shell) {
+    argv = NULL;
+    command = SCHEME_STR_VAL(args[0]);
+  } else  {
+    argv = (char **)scheme_malloc_atomic((c + 1) * sizeof(char *));
+    argv[0] = scheme_expand_filename(SCHEME_STR_VAL(args[0]),
+				     SCHEME_STRTAG_VAL(args[0]),
+				     name, NULL);
+    /* This is for Windows: */
+    argv[0] = scheme_normal_path_case(argv[0], strlen(argv[0]));
+    
+    for (i = 1; i < c; i++) { 
+      if (!SCHEME_STRINGP(args[i]) || scheme_string_has_null(args[i]))
+	scheme_wrong_type(name, STRING_W_NO_NULLS, i, c, args);
+      argv[i] = SCHEME_STR_VAL(args[i]);
+    }
+    argv[c] = NULL;
+
+    command = argv[0];
+  }
+
+  
+  if (!synchonous) {
+    if (MSC_IZE(pipe)(to_subprocess _EXTRA_PIPE_ARGS))
+      scheme_raise_exn(MZEXN_MISC_PROCESS,
+		       "%s: pipe failed", name);
+    if (MSC_IZE(pipe)(from_subprocess _EXTRA_PIPE_ARGS)) {
+      MSC_IZE(close)(to_subprocess[0]);
+      MSC_IZE(close)(to_subprocess[1]);
+      scheme_raise_exn(MZEXN_MISC_PROCESS,
+		       "%s: pipe failed", name);
+    }
+    if (MSC_IZE(pipe)(err_subprocess _EXTRA_PIPE_ARGS)) {
+      MSC_IZE(close)(to_subprocess[0]);
+      MSC_IZE(close)(to_subprocess[1]);
+      MSC_IZE(close)(from_subprocess[0]);
+      MSC_IZE(close)(from_subprocess[1]);
+      scheme_raise_exn(MZEXN_MISC_PROCESS,
+		       "%s: pipe failed", name);
+    }
+  }
+
+#ifdef WINDOWS_PROCESSES
+  MSC_IZE(flushall)();
+
+  if (shell)
+    spawn_status = system(command);
+  else {
+    int type;
+    int save0, save1, save2;
+
+    if (!synchonous)
+      type = _P_NOWAIT;
+    else if (!as_child)
+      type = _P_OVERLAY;
+    else 
+      type = _P_NOWAIT; /* We'll implement waiting ourselves */
+
+    if (!synchonous) {
+      /* Save stdin and stdout */
+      save0 = MSC_IZE(dup)(0);
+      save1 = MSC_IZE(dup)(1);
+      save2 = MSC_IZE(dup)(2);
+
+      /* Copy pipe descriptors to stdin and stdout */
+      MSC_IZE(dup2)(to_subprocess[0], 0);
+      MSC_IZE(dup2)(from_subprocess[1], 1);
+      MSC_IZE(dup2)(err_subprocess[1], 2);
+    }
+
+    spawn_status = MSC_IZE(spawnv)(type, command, argv);
+
+    if (!synchonous) {
+      /* Restore stdin and stdout */
+      MSC_IZE(dup2)(save0, 0);
+      MSC_IZE(dup2)(save1, 1);
+      MSC_IZE(dup2)(save2, 2);
+
+      pid = spawn_status;
+      
+      if (spawn_status != -1)
+        sc = (void *)pid;
+    } else if (spawn_status != -1) {
+      DWORD w;
+
+      sc = (void *)spawn_status;
+
+      scheme_block_until(subp_done, subp_needs_wakeup, (void *)sc, (float)0.0);
+
+      if (GetExitCodeProcess((HANDLE)sc, &w))
+	spawn_status = w;
+      else
+	spawn_status = -1;
+
+      pid = 0;
+    }
+  }
+
+  if (!as_child) {
+    _exit(0);
+  }
+#else
+  if (as_child) {
+    sigset_t sigs;
+
+    {
+      static int sigchld_installed = 0;
+      if (!sigchld_installed) {
+	/* Catch child-done signals */
+	MZ_SIGSET(SIGCHLD, child_done);
+	sigchld_installed = 1;
+      }
+    }
+
+    sc = MALLOC_ONE(System_Child);
+    sc->id = 0;
+    sc->done = 0;
+
+    sigemptyset(&sigs);
+    sigaddset(&sigs, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &sigs, NULL);
+
+    pid = fork();
+
+    if (pid > 0) {
+      sc->next = scheme_system_children;
+      scheme_system_children = sc;
+      sc->id = pid;
+    }
+
+    sigprocmask(SIG_UNBLOCK, &sigs, NULL);
+  } else {
+    sc = NULL;
+    pid = 0;
+  }
+
+  switch (pid)
+    {
+    case -1:
+      scheme_raise_exn(MZEXN_MISC_PROCESS,
+		       "%s: fork failed", name);
+      return scheme_false;
+
+    case 0:			/* child */
+
+      /* Ignore signals here */
+      MZ_SIGSET(SIGCHLD, SIG_IGN);
+
+      if (!synchonous) {
+	/* Copy pipe descriptors to stdin and stdout */
+	MSC_IZE(dup2)(to_subprocess[0], 0);
+	MSC_IZE(dup2)(from_subprocess[1], 1);
+	MSC_IZE(dup2)(err_subprocess[1], 2);
+	
+	/* Close unwanted descriptors */
+	MSC_IZE(close)(to_subprocess[0]);
+	MSC_IZE(close)(to_subprocess[1]);
+	MSC_IZE(close)(from_subprocess[0]);
+	MSC_IZE(close)(from_subprocess[1]);
+	MSC_IZE(close)(err_subprocess[0]);
+	MSC_IZE(close)(err_subprocess[1]);
+      }
+      /* Exec new process */
+
+      if (shell) {
+	int v;
+
+	v = system(command);
+
+	if (!(v & 0xFF))
+	  v = v >> 8;
+
+	if (as_child)
+	  _exit(v);
+	else
+	  return scheme_void;
+      } else {
+	int err;
+
+	err = MSC_IZE(execv)(command, argv);
+
+	/* If we get here it failed; give up */
+
+	if (as_child)
+	  _exit(err ? err : -1);
+	else
+	  return scheme_void;
+      }
+
+    default:		/* parent */
+
+      break;
+    }
+#endif
+
+  /* Close unneeded descriptors */
+
+  if (!synchonous) {
+    MSC_IZE(close)(to_subprocess[0]);
+    MSC_IZE(close)(from_subprocess[1]);
+    MSC_IZE(close)(err_subprocess[1]);
+
+    scheme_file_open_count += 3;
+
+    in = make_tested_file_input_port(MSC_IZE(fdopen)(from_subprocess[0], "r"), "sub-stdout", 1);
+    out = scheme_make_file_output_port(MSC_IZE(fdopen)(to_subprocess[1], "w"));
+    subpid = scheme_make_integer(pid);
+    err = make_tested_file_input_port(MSC_IZE(fdopen)(err_subprocess[0], "r"), "sub-stderr", 1);
+    thunk = scheme_make_closed_prim_w_arity(get_process_status,
+					    sc, "control-process",
+					    1, 1);
+
+#define cons scheme_make_pair
+
+    return cons(in,
+		cons(out,
+		     cons(subpid, 
+			  cons(err, 
+			       cons(thunk,
+				    scheme_null)))));
+  } else {
+    int status;
+
+#ifdef WINDOWS_PROCESSES
+    status = spawn_status;
+#else
+#ifdef UNIX_PROCESSES
+    {
+      scheme_block_until(subp_done, NULL, (void *)sc, 0);
+      status = !sc->status;
+    }
+#else
+ -->> Configuration error <<--
+#endif
+#endif
+
+    return status ? scheme_false : scheme_true;
+  }
+
+#else
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "%s: not supported on this platform",
+		   name);
+  return NULL;
+#endif
+}
+
+#ifdef MACINTOSH_EVENTS
+extern int scheme_mac_start_app(char *name, int find_path, Scheme_Object *s);
+#endif
+
+
+static Scheme_Object *sch_process_star(int c, Scheme_Object *args[])
+{
+  return process(c, args, "process*", 0, 0, 1);
+}
+
+static Scheme_Object *sch_system_star(int c, Scheme_Object *args[])
+{
+#ifdef MACINTOSH_EVENTS
+  return (scheme_mac_start_app("system*", 0, args[0])
+	  ? scheme_true
+	  : scheme_false);
+#else
+  return process(c, args, "system*", 0, 1, 1);
+#endif
+}
+
+static Scheme_Object *sch_execute_star(int c, Scheme_Object *args[])
+{
+#ifdef MACINTOSH_EVENTS
+  if (scheme_mac_start_app("execute*", 0, args[0]))
+    exit(0);
+
+  return scheme_void;
+#else
+  return process(c, args, "execute*", 0, 1, 0);
+#endif
+}
+
+static Scheme_Object *sch_process(int c, Scheme_Object *args[])
+{
+  return process(c, args, "process", 1, 0, 1);
+}
+
+static Scheme_Object *sch_system(int c, Scheme_Object *args[])
+{
+#ifdef MACINTOSH_EVENTS
+  return (scheme_mac_start_app("system", 1, args[0])
+	  ? scheme_true
+	  : scheme_false);
+#else
+  return process(c, args, "system", 1, 1, 1);
+#endif
+}
+
+static Scheme_Object *sch_execute(int c, Scheme_Object *args[])
+{
+#ifdef MACINTOSH_EVENTS
+  if (scheme_mac_start_app("execute", 1, args[0]))
+    exit(0);
+
+  return scheme_void;
+#else
+  return process(c, args, "execute", 1, 1, 0);
+#endif
+}
+
+/******************************************************************************/
+
+#define PORT_ID_TYPE "exact integer in [1, 65535]"
+#define CHECK_PORT_ID(obj) (SCHEME_INTP(obj) && (SCHEME_INT_VAL(obj) >= 1) && (SCHEME_INT_VAL(obj) <= 65535))
+
+#ifdef USE_TCP
+
+#ifdef USE_SOCKETS_TCP
+#define MAKE_TCP_ARG tcp_t tcp, 
+#else
+#define MAKE_TCP_ARG
+#endif
+
+#ifdef USE_UNIX_SOCKETS_TCP
+typedef struct sockaddr_in tcp_address;
+#endif
+#ifdef USE_WINSOCK_TCP
+typedef struct SOCKADDR_IN tcp_address;
+#endif
+
+#ifdef USE_WINSOCK_TCP
+
+/******************************* WinSock ***********************************/
+
+static int winsock_done(void)
+{
+  return WSACleanup();
+}
+
+static void TCP_INIT(char *name)
+{
+  static int started = 0;
+  
+  if (!started) {
+    WSADATA data;
+    if (!WSAStartup(MAKEWORD(1, 1), &data)) {
+      started = 1;
+      _onexit(winsock_done);
+      return;
+    }
+  } else
+    return;
+  
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "%s: not supported on this machine"
+		   " (no winsock driver)",
+		   name);
+}
+#else
+#ifdef USE_MAC_TCP
+
+/***************************** Mac *******************************************/
+
+/* Much of this is derived from (or at least influenced by) GUSI's TCP
+   socket implementation, by Matthias Neeracher, which was derived from
+   a library by Charlie Reiman Tom Milligan */
+
+static short tcpDriverId;
+
+#define	SOCK_STATE_NO_STREAM 0 /* Socket doesn't have a MacTCP stream yet */
+#define	SOCK_STATE_UNCONNECTED 1 /* Socket is unconnected. */
+#define	SOCK_STATE_LISTENING 2 /* Socket is listening for connection. */
+#define	SOCK_STATE_LIS_CON 3 /* Socket is in transition from listen to connected. */
+#define	SOCK_STATE_CONNECTING 4 /* Socket is initiating a connection. */
+#define	SOCK_STATE_CONNECTED 5 /* Socket is connected. */
+#define	SOCK_STATE_CLOSING 6 /* Socket is closing */
+#define	SOCK_STATE_LIS_CLOSE 7 /* Socket closed while listening */
+
+typedef struct TCPiopbX {
+  TCPiopb pb;
+  Scheme_Tcp *data;
+  struct TCPiopbX *next;
+} TCPiopbX;
+
+typedef struct {
+  wdsEntry e[2];
+  TCPiopbX *xpb;
+} WriteData;
+
+static TCPiopbX *active_pbs;
+
+static pascal void dnr_done(struct hostInfo *, int * done)
+{
+  *done = true;
+}
+
+static ResultUPP u_dnr_done;
+
+static pascal void tcp_notify(StreamPtr stream, unsigned short eventCode,
+			      Ptr userDataPtr, unsigned short something,
+			      struct ICMPReport *reportPtr)
+{
+  tcp_t *t = (tcp_t *)userDataPtr;
+
+  switch (eventCode) {
+  case TCPClosing:
+    if (t->state == SOCK_STATE_LISTENING || t->state == SOCK_STATE_LIS_CON)
+      t->state = SOCK_STATE_LIS_CLOSE;
+    else
+      t->state = SOCK_STATE_CLOSING;
+    break;
+    
+  case TCPTerminate:
+    if (t->state != SOCK_STATE_LIS_CLOSE)
+      if (t->state == SOCK_STATE_LISTENING || t->state == SOCK_STATE_LIS_CON)
+	t->state = SOCK_STATE_LIS_CLOSE;
+      else
+	t->state = SOCK_STATE_UNCONNECTED;
+    break;
+  }
+}
+
+static TCPNotifyUPP u_tcp_notify;
+
+static void tcp_connect_done(TCPiopbX *pbx)
+{
+  if (!pbx->pb.ioResult)
+    pbx->data->tcp.state = SOCK_STATE_CONNECTED;
+}
+
+static TCPIOCompletionUPP u_tcp_connect_done;
+
+static void tcp_listen_done(TCPiopbX *pbx)
+{
+  TCPiopb *pb = &pbx->pb;
+  Scheme_Tcp *data = pbx->data;
+
+  switch(pb->ioResult) {
+  case noErr:
+    data->tcp.state = SOCK_STATE_LIS_CON;
+    break;
+    
+  case openFailed:
+  case invalidStreamPtr:
+  case connectionExists:
+  case duplicateSocket:
+  case commandTimeout:
+  default:
+    data->tcp.state = SOCK_STATE_LIS_CLOSE;
+    data->tcp.async_errid = -pb->ioResult;
+    break;
+  }
+}
+
+static TCPIOCompletionUPP u_tcp_listen_done;
+
+static void tcp_recv_done(TCPiopbX *pbx)
+{
+  TCPiopb *pb = &pbx->pb;
+  Scheme_Tcp *data = pbx->data;
+  
+  if (!pb->ioResult)
+    data->bufmax = pb->csParam.receive.rcvBuffLen;
+}
+
+static TCPIOCompletionUPP u_tcp_recv_done;
+
+static void tcp_send_done(TCPiopbX *pbx)
+{
+  TCPiopb *pb = &pbx->pb;
+  Scheme_Tcp *data = pbx->data;
+
+  /* mark it free: */
+  ((WriteData *)(pb->csParam.send.wdsPtr))->xpb = NULL;
+
+  switch (pb->ioResult) {
+  case noErr:
+    break;
+  case ipNoFragMemErr:
+  case connectionClosing:
+  case connectionTerminated:
+  case connectionDoesntExist:
+  case ipDontFragErr:
+  case invalidStreamPtr:
+  case invalidLength:
+  case invalidWDS:
+  default:
+    data->tcp.state = SOCK_STATE_UNCONNECTED;
+    data->tcp.async_errid = -pb->ioResult;
+    break;
+  }
+}
+
+static TCPIOCompletionUPP u_tcp_send_done;
+
+/************** Mac Set-up *****************/
+
+static void tcp_cleanup(void);
+
+static void TCP_INIT(char *name)
+{
+  ParamBlockRec pb;
+  short errNo;
+  struct GetAddrParamBlock pbr;
+	
+  pb.ioParam.ioCompletion = 0L; 
+  pb.ioParam.ioNamePtr = (StringPtr) "\p.IPP"; 
+  pb.ioParam.ioPermssn = fsCurPerm;
+  
+  if ((errNo = PBOpenSync(&pb))
+      || (errNo = OpenResolver(NULL))) {
+    scheme_raise_exn(MZEXN_I_O_TCP,
+		     "%s: TCP initialization error (%d)",
+		     name, (int)errNo);
+  }
+		
+  tcpDriverId = pb.ioParam.ioRefNum; 
+  
+  u_dnr_done = NewResultProc(dnr_done);
+  u_tcp_notify = NewTCPNotifyProc(tcp_notify);
+  u_tcp_connect_done = NewTCPIOCompletionProc(tcp_connect_done);
+  u_tcp_listen_done = NewTCPIOCompletionProc(tcp_listen_done);
+  u_tcp_recv_done = NewTCPIOCompletionProc(tcp_recv_done);
+  u_tcp_send_done = NewTCPIOCompletionProc(tcp_send_done);
+  
+  REGISTER_SO(active_pbs);
+  
+  atexit(tcp_cleanup);
+}
+
+static int tcp_addr(char *address, struct hostInfo *info)
+{
+  long *done = MALLOC_ONE_ATOMIC(long);
+  *done = 0;
+  if (StrToAddr(address, info, u_dnr_done, (char *)done) == cacheFault) {
+    while (!*done) { scheme_process_block(0.25); }
+  }
+  if (info->rtnCode)
+    return info->rtnCode;
+  if (info->cname[0] == 0)
+    return -42;
+  
+  return 0;
+}
+
+/* Forward prototype: */
+static Scheme_Tcp *make_tcp_port_data(MAKE_TCP_ARG int refcount);
+
+#define STREAM_BUFFER_SIZE 8192
+
+static TCPiopbX *mac_make_xpb(Scheme_Tcp *data)
+{
+  TCPiopbX *xpb;
+
+  xpb = (TCPiopbX *)scheme_malloc(sizeof(TCPiopbX));
+  
+  memcpy(xpb, data->tcp.create_pb, sizeof(TCPiopb ));
+
+  xpb->data = data;
+
+  return xpb;
+}
+
+static int mac_tcp_make(TCPiopbX **_xpb, TCPiopb **_pb, Scheme_Tcp **_data)
+{
+  TCPiopbX *xpb;
+  TCPiopb *pb;
+  Scheme_Tcp *data;
+  int errid;
+
+  data = make_tcp_port_data(2);
+  
+  xpb = (TCPiopbX *)scheme_malloc(sizeof(TCPiopbX));
+  xpb->next = active_pbs;
+  active_pbs = xpb;
+  
+  pb = (TCPiopb *)xpb;
+  
+  pb->ioCRefNum = tcpDriverId;
+  pb->csCode = TCPCreate;
+  pb->csParam.create.rcvBuff = (char *)scheme_malloc_atomic(STREAM_BUFFER_SIZE);
+  pb->csParam.create.rcvBuffLen = STREAM_BUFFER_SIZE;
+  pb->csParam.create.notifyProc = u_tcp_notify;
+  pb->csParam.create.userDataPtr = (char *)&data->tcp;
+  
+  xpb->data = data;
+  
+  if ((errid = PBControlSync((ParamBlockRec*)pb)))
+    return errid;
+	
+  data->tcp.create_pb = (void *)pb;
+  data->tcp.stream = pb->tcpStream;
+  data->tcp.async_errid = -1;
+
+  *_xpb = xpb;
+  *_pb = pb;
+  *_data = data;
+
+  return 0;
+}
+
+static void mac_tcp_close(Scheme_Tcp *data)
+{
+  TCPiopb *pb;
+  
+  pb = (TCPiopb *)mac_make_xpb(data);
+  
+  pb->ioCompletion = NULL;
+  pb->csCode = TCPClose;
+  pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
+  pb->csParam.close.ulpTimeoutValue = 60 /* seconds */;
+  pb->csParam.close.ulpTimeoutAction = 1 /* 1:abort 0:report */;
+  PBControlSync((ParamBlockRec*)pb);
+	
+#if 0
+	/* I don't know what this is for: */
+  if (!pb.ioResult) {
+#define TCP_MAX_WDS 10
+    rdsEntry rdsarray[TCP_MAX_WDS+1];
+    int passcount;
+    const int maxpass = 8;
+
+    for (passcount = 0; passcount < maxpass; passcount++) {
+      pb->csCode = TCPNoCopyRcv;
+      pb->csParam.receive.commandTimeoutValue = 1; /* seconds, 0 = blocking */
+      pb->csParam.receive.rdsPtr = (Ptr)rdsarray;
+      pb->csParam.receive.rdsLength = TCP_MAX_WDS;
+      
+      PBControlSync((ParamBlockRec*)pb);
+      
+      if (pb.ioResult)
+	break;
+      
+      pb->csCode = TCPRcvBfrReturn;
+      pb->csParam.receive.rdsPtr = (Ptr)rdsarray;
+      
+      PBControlSync((ParamBlockRec*)pb);
+      
+      if (pb->ioResult)
+	break;
+    }
+  }
+#endif
+  
+  pb->csCode = TCPRelease;
+  PBControlSync((ParamBlockRec*)pb);
+
+ {
+    TCPiopbX *x, *prev = NULL;
+    x = active_pbs;
+    while (x) {
+      if (x->data->tcp.stream == data->tcp.stream) {
+	if (!prev)
+	  active_pbs = x->next;
+	else
+	  prev->next = x->next;
+	break;
+      }
+    }
+  }
+}
+
+static int mac_tcp_listen(int id, Scheme_Tcp **_data)
+{
+  TCPiopbX *xpb;
+  TCPiopb *pb;
+  Scheme_Tcp *data;
+  int errid;
+  
+  if (!(errid = mac_tcp_make(&xpb, &pb, &data))) {
+    data->tcp.state = SOCK_STATE_LISTENING;
+    
+    xpb = mac_make_xpb(data);
+    pb = (TCPiopb *)xpb;
+
+    pb->ioCompletion = u_tcp_listen_done;
+    pb->csCode = TCPPassiveOpen;
+    pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
+    pb->csParam.open.ulpTimeoutValue = 0 /* seconds; 0 = infinity */;
+    pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
+    pb->csParam.open.commandTimeoutValue = 0 /* seconds; 0 = infinity */;
+    pb->csParam.open.remoteHost = 0;
+    pb->csParam.open.remotePort = 0;
+    pb->csParam.open.localHost = 0;
+    pb->csParam.open.localPort = id;
+    pb->csParam.open.dontFrag = 0;
+    pb->csParam.open.timeToLive = 0;
+    pb->csParam.open.security = 0;
+    pb->csParam.open.optionCnt = 0;
+
+    if ((errid = PBControlAsync((ParmBlkPtr)pb))) {
+      data->tcp.state = SOCK_STATE_UNCONNECTED;
+      mac_tcp_close(data);
+      return errid;
+    } else {
+      *_data = data;
+      return 0;
+    }
+  } else
+    return errid;
+}
+
+static void tcp_cleanup(void)
+{
+  while (active_pbs) {
+    TCPiopbX *pb = active_pbs;
+    active_pbs = active_pbs->next;
+    mac_tcp_close(pb->data);
+  }
+}
+
+#else
+#define TCP_INIT(x) /* nothing */
+#endif
+#endif
+
+/*************************** Generic **************************************/
+
+#ifdef USE_SOCKETS_TCP
+#define LISTENER_WAS_CLOSED(x) (((listener_t *)(x))->s == INVALID_SOCKET)
+#endif
+#ifdef USE_MAC_TCP
+#define LISTENER_WAS_CLOSED(x) !((listener_t *)(x))->datas
+#endif
+#ifndef LISTENER_WAS_CLOSED
+#define LISTENER_WAS_CLOSED(x) 0
+#endif
+
+/* Forward declaration */
+static int stop_listener(Scheme_Object *o);
+
+static int tcp_check_accept(Scheme_Object *listener)
+{
+#ifdef USE_SOCKETS_TCP
+  tcp_t s;
+  DECL_FDSET(readfds, 1);
+  struct timeval time = {0, 0};
+
+  INIT_DECL_FDSET(readfds, 1);
+
+  if (LISTENER_WAS_CLOSED(listener))
+    return 1;
+
+  s = ((listener_t *)listener)->s;
+
+  MZ_FD_ZERO(readfds);
+  MZ_FD_SET(s, readfds);
+    
+  return select(s + 1, readfds, NULL, NULL, &time);
+#endif
+#ifdef USE_MAC_TCP
+  int i, count;
+  Scheme_Tcp **datas;
+  count = ((listener_t *)listener)->count;
+  datas = ((listener_t *)listener)->datas;
+
+  if (LISTENER_WAS_CLOSED(listener))
+    return 1;
+
+  for (i = 0; i < count; i++)
+    if (datas[i]->tcp.state == SOCK_STATE_LIS_CON)
+      return 1;
+
+  return 0;
+#endif
+}
+
+static void tcp_accept_needs_wakeup(Scheme_Object *listener, void *fds)
+{
+#ifdef USE_UNIX_SOCKETS_TCP
+  tcp_t s = ((listener_t *)listener)->s;
+  MZ_FD_SET(s, (fd_set *)fds);
+#endif
+}
+
+static int tcp_check_connect(Scheme_Object *connector)
+{
+#ifdef USE_MAC_TCP
+  ((TCPiopb *)connector)->ioResult != inProgress;
+#else
+#ifdef USE_SOCKETS_TCP
+  tcp_t s;
+  DECL_FDSET(writefds, 1);
+  DECL_FDSET(exnfds, 1);
+  struct timeval time = {0, 0};
+
+  INIT_DECL_FDSET(writefds, 1);
+  INIT_DECL_FDSET(exnfds, 1);
+
+  s = (tcp_t)connector;
+
+  MZ_FD_ZERO(writefds);
+  MZ_FD_SET(s, writefds);
+  MZ_FD_ZERO(exnfds);
+  MZ_FD_SET(s, exnfds);
+    
+  if (!select(s + 1, NULL, writefds, exnfds, &time))
+    return 0;
+  if (FD_ISSET(s, exnfds))
+    return -1;
+  else
+    return 1;
+#else
+  return 0;
+#endif
+#endif
+}
+
+static void tcp_connect_needs_wakeup(Scheme_Object *connector, void *fds)
+{
+#ifdef USE_SOCKETS_TCP
+  void *fds1, *fds2;
+  tcp_t s = (tcp_t)connector;
+  
+  fds1 = MZ_GET_FDSET(fds, 1);
+  fds2 = MZ_GET_FDSET(fds, 2);
+
+  MZ_FD_SET(s, (fd_set *)fds1);
+  MZ_FD_SET(s, (fd_set *)fds2);
+#endif
+}
+
+#ifdef USE_MAC_TCP
+static void tcp_read_needs_wakeup(Scheme_Object *connector, void *fds)
+{
+}
+
+static int tcp_check_read(Scheme_Object *connector)
+{
+  return (((TCPiopb *)connector)->ioResult != inProgress);
+}
+#endif
+
+static int tcp_check_write(Scheme_Object *conn)
+{
+  Scheme_Tcp *data = (Scheme_Tcp *)conn;
+
+#ifdef USE_SOCKETS_TCP
+  tcp_t s;
+  DECL_FDSET(writefds, 1);
+  DECL_FDSET(exnfds, 1);
+  struct timeval time = {0, 0};
+
+  INIT_DECL_FDSET(writefds, 1);
+  INIT_DECL_FDSET(exnfds, 1);
+
+  s = data->tcp;
+
+  MZ_FD_ZERO(writefds);
+  MZ_FD_SET(s, writefds);
+  MZ_FD_ZERO(exnfds);
+  MZ_FD_SET(s, exnfds);
+  
+  return select(s + 1, NULL, writefds, exnfds, &time);
+#else
+  TCPiopbX *xpb;
+  TCPiopb *pb;
+  int bytes;
+
+  xpb = mac_make_xpb(data);
+  pb = (TCPiopb *)xpb;
+    
+  pb->csCode = TCPStatus;
+  if (PBControlSync((ParamBlockRec*)pb))
+    bytes = -1;
+  else {
+    bytes = pb->csParam.status.sendWindow - pb->csParam.status.amtUnackedData;
+    if (bytes < 0)
+      bytes = 0;
+  }
+  
+  return !!bytes;
+#endif
+}
+
+static void tcp_write_needs_wakeup(Scheme_Object *conn, void *fds)
+{
+#ifdef USE_SOCKETS_TCP
+  void *fds1, *fds2;
+  tcp_t s = ((Scheme_Tcp *)conn)->tcp;
+  
+  fds1 = MZ_GET_FDSET(fds, 1);
+  fds2 = MZ_GET_FDSET(fds, 2);
+
+  MZ_FD_SET(s, (fd_set *)fds1);
+  MZ_FD_SET(s, (fd_set *)fds2);
+#endif
+}
+
+
+static Scheme_Tcp *make_tcp_port_data(MAKE_TCP_ARG int refcount)
+{
+  Scheme_Tcp *data;
+  
+  data = (Scheme_Tcp *)scheme_malloc_atomic(sizeof(Scheme_Tcp));
+#ifdef USE_SOCKETS_TCP
+  data->tcp = tcp;
+#endif
+  data->bufpos = 0;
+  data->bufmax = 0;
+  data->hiteof = 0;
+  data->refcount = refcount;
+
+  data->sendbuf = NULL;
+  data->sendbuflen = 0;
+  data->sendbufsize = 0;
+  data->sendbuftrying = 0;
+
+#ifndef USE_MAC_TCP
+#ifdef USE_WINSOCK_TCP
+  {
+    unsigned long ioarg = 1;
+    ioctlsocket(tcp, FIONBIO, &ioarg);
+  }
+#else
+  fcntl(tcp, F_SETFL, TCP_NONBLOCKING);
+#endif
+#endif
+
+  return data;
+}
+
+static int tcp_char_ready (Scheme_Input_Port *port)
+{
+  Scheme_Tcp *data;
+#ifdef USE_SOCKETS_TCP
+  DECL_FDSET(readfds, 1);
+  DECL_FDSET(exfds, 1);
+  struct timeval time = {0, 0};
+
+  INIT_DECL_FDSET(readfds, 1);
+  INIT_DECL_FDSET(exfds, 1);
+#endif
+
+  data = (Scheme_Tcp *)port->port_data;
+
+  if (data->hiteof)
+    return 1;
+  if (data->bufpos < data->bufmax)
+    return 1;
+
+#ifdef USE_SOCKETS_TCP
+  MZ_FD_ZERO(readfds);
+  MZ_FD_ZERO(exfds);
+  MZ_FD_SET(data->tcp, readfds);
+  MZ_FD_SET(data->tcp, exfds);
+    
+  return select(data->tcp + 1, readfds, NULL, exfds, &time);
+#endif
+
+#ifdef USE_MAC_TCP
+  if (data->tcp.state == SOCK_STATE_CONNECTED) {
+    /* socket is connected */
+    TCPiopbX *xpb;
+    TCPiopb *pb;
+    
+    xpb = mac_make_xpb(data);
+    pb = (TCPiopb *)xpb;
+    
+    pb->csCode = TCPStatus;
+    pb->ioCompletion = NULL;
+
+    if (PBControlSync((ParamBlockRec*)pb))
+      return 1;
+      
+    if (pb->csParam.status.amtUnreadData)
+      return 1;
+ } else
+   return 1;
+#endif
+
+  return 0;
+}
+
+static int tcp_getc(Scheme_Input_Port *port)
+{
+  int errid;
+  Scheme_Tcp *data;
+
+  data = (Scheme_Tcp *)port->port_data;
+
+  if (data->hiteof)
+    return EOF;
+
+  if (data->bufpos < data->bufmax)
+    return (unsigned char)data->buffer[data->bufpos++];
+
+  if (!tcp_char_ready(port)) {
+#ifdef USE_SOCKETS_TCP
+    scheme_current_process->block_descriptor = PORT_BLOCKED;
+    scheme_current_process->blocker = (Scheme_Object *)port;
+#endif
+    do
+      scheme_process_block((float)0.0);
+    while (!tcp_char_ready(port));
+#ifdef USE_SOCKETS_TCP
+    scheme_current_process->block_descriptor = NOT_BLOCKED;
+    scheme_current_process->blocker = NULL;
+#endif
+    scheme_current_process->ran_some = 1;
+  }
+
+#ifdef USE_SOCKETS_TCP
+  data->bufmax = recv(data->tcp, data->buffer, TCP_BUFFER_SIZE, 0);
+  errid = errno;
+#endif
+#ifdef USE_MAC_TCP
+  if (data->tcp.state == SOCK_STATE_CONNECTED) {
+    /* socket is connected */
+    TCPiopbX *xpb;
+    TCPiopb *pb;
+    
+    xpb = mac_make_xpb(data);
+    pb = (TCPiopb *)xpb;
+    
+    pb->csCode = TCPRcv;
+    pb->ioCompletion = u_tcp_recv_done;
+    pb->csParam.receive.commandTimeoutValue = 0; /* seconds, 0 = blocking */
+    pb->csParam.receive.rcvBuff = data->buffer;
+    pb->csParam.receive.rcvBuffLen = TCP_BUFFER_SIZE;
+
+    PBControlAsync((ParamBlockRec*)pb);
+
+    scheme_block_until(tcp_check_read, tcp_read_needs_wakeup, pb, 0);
+
+    switch((errid = pb->ioResult)) {
+    case noErr:
+    case connectionClosing:
+    case connectionTerminated:
+      errid = 0;
+      break;
+    case commandTimeout:
+    case connectionDoesntExist:
+    case invalidStreamPtr:
+    case invalidLength:
+    case invalidBufPtr:
+    default:
+      break;
+    }
+  } else if (data->tcp.state == SOCK_STATE_CLOSING) {
+    data->bufmax = 0;
+    errid = 0;
+  } else
+    errid = data->tcp.async_errid;
+  
+  if (errid)
+    data->bufmax = -1;
+#endif
+  
+  if (data->bufmax == -1) {
+    scheme_raise_exn(MZEXN_I_O_READ,
+		     port,
+		     "tcp-read: error reading (%d)",
+		     errid);
+  } else if (!data->bufmax) {
+    data->hiteof = 1;
+    return EOF;
+  }
+
+  data->bufpos = 1;
+    
+  return (unsigned char)data->buffer[0];
+}
+
+static void tcp_need_wakeup(Scheme_Input_Port *port, void *fds)
+{
+  Scheme_Tcp *data;
+
+  data = (Scheme_Tcp *)port->port_data;
+
+#ifdef USE_SOCKETS_TCP
+  {
+    void *fds2;
+  
+    fds2 = MZ_GET_FDSET(fds, 2);
+    
+    MZ_FD_SET(data->tcp, (fd_set *)fds);
+    MZ_FD_SET(data->tcp, (fd_set *)fds2);
+  }
+#endif
+}
+
+static void tcp_close_input(Scheme_Input_Port *port)
+{
+  Scheme_Tcp *data;
+
+  data = (Scheme_Tcp *)port->port_data;
+
+  if (--data->refcount)
+    return;
+
+#ifdef USE_SOCKETS_TCP
+  closesocket(data->tcp);
+#endif
+#ifdef USE_MAC_TCP
+  mac_tcp_close(data);
+#endif
+
+  --scheme_file_open_count;
+}
+
+/* forward decls: */
+static void tcp_write_string(char *s, long len, Scheme_Output_Port *port);
+static void tcp_close_output(Scheme_Output_Port *port);
+
+static Scheme_Object *write_when_possible(void *port, int argc, Scheme_Object **argv)
+{
+  Scheme_Tcp *data;
+  char *s;
+  int len, error;
+  jmp_buf savebuf;
+
+  data = (Scheme_Tcp *)((Scheme_Output_Port *)port)->port_data;
+
+  /* Block for writing: */
+  scheme_block_until(tcp_check_write, tcp_write_needs_wakeup, data, (float)1.0);
+
+  /* Ok - try again! */
+  s = data->sendbuf;
+  len = data->sendbuflen;
+
+  data->sendbuf = NULL;
+  data->sendbuflen = 0;
+  data->sendbufsize = 0;
+  data->sendbuftrying = 1;
+
+  memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+
+  if (scheme_setjmp(scheme_error_buf))
+    error = 1;
+  else {
+    tcp_write_string(s, len, (Scheme_Output_Port *)port);
+    error = 0;
+  }
+
+  /* decrement refcount: */
+  tcp_close_output((Scheme_Output_Port *)port);
+
+  if (error)
+    scheme_longjmp(savebuf, 1);
+  else
+    memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+  
+  return scheme_void;
+}
+
+static void tcp_write_string(char *s, long len, Scheme_Output_Port *port)
+{
+  Scheme_Tcp *data;
+  int errid, would_block = 0;
+#ifdef USE_SOCKETS_TCP
+  int sent;
+#endif
+
+  if (!len)
+    return;
+
+  data = (Scheme_Tcp *)port->port_data;
+
+  if (data->sendbuflen) {
+    /* already blocking: */
+    if (data->sendbuflen + len > data->sendbufsize){
+      char *naya;
+      
+      data->sendbufsize = (2 * data->sendbufsize) + len;
+      naya = (char *)scheme_malloc_atomic(data->sendbufsize);
+      memcpy(naya, data->sendbuf, data->sendbuflen);
+      data->sendbuf = naya;
+    }
+
+    memcpy(data->sendbuf + data->sendbuflen, s, len);
+    data->sendbuflen += len;
+
+    return;
+  }
+
+#ifdef USE_SOCKETS_TCP
+  if ((sent = send(data->tcp, s, len, 0)) != len) {
+#ifdef USE_WINSOCK_TCP
+    errid = WSAGetLastError();
+# define SEND_BAD_MSG_SIZE(e) (e == WSAEMSGSIZE)
+# define SEND_WOULD_BLOCK(e) \
+    ((e == WSAEWOULDBLOCK) || (e == WSAEINPROGRESS))
+#else
+    errid = errno;
+# define SEND_BAD_MSG_SIZE(errid) (errid == EMSGSIZE)
+# define SEND_WOULD_BLOCK(errid) \
+   ((errid == EWOULDBLOCK) || (errid == EAGAIN)\
+    || (errid == EINPROGRESS) || (errid == EALREADY))
+#endif
+    if (sent > 0) {
+      /* Some data was sent. Recur to handle the rest */
+      tcp_write_string(s + sent, len - sent, port);
+      errid = 0;
+    } else if ((len > 1) && SEND_BAD_MSG_SIZE(errid)) {
+      /* split the message and try again: */
+      int half = (len / 2);
+      tcp_write_string(s, half, port);
+      tcp_write_string(s + half, len - half, port);
+      errid = 0;
+    } else if (SEND_WOULD_BLOCK(errid)) {
+      errid = 0;
+      would_block = 1;
+    }
+  } else
+    errid = 0;
+#endif
+#ifdef USE_MAC_TCP
+  errid = 0;
+  if (data->tcp.state == SOCK_STATE_CONNECTED) {
+    /* socket is connected */
+    TCPiopbX *xpb;
+    TCPiopb *pb;
+    int bytes;
+
+    xpb = mac_make_xpb(data);
+    pb = (TCPiopb *)xpb;
+    
+    pb->csCode = TCPStatus;
+    if ((errid = PBControlSync((ParamBlockRec*)pb)))
+      bytes = 0;
+    else {
+      bytes = pb->csParam.status.sendWindow - pb->csParam.status.amtUnackedData;
+      if (bytes < 0)
+	bytes = 0;
+    }
+    
+    if (bytes >= len) {
+      WriteData *wd;
+      wdsEntry *e;
+      int i;
+      
+      wd = NULL;
+      for (i = 0; i < num_tcp_send_buffers; i++)
+	if (!((WriteData *)(tcp_send_buffers[i]))->xpb) {
+	  wd = (WriteData *)(tcp_send_buffers[i]);
+	  break;
+	}
+      
+      if (!wd) {
+	void **naya;
+	int nayac;
+	
+	nayac = (2 * num_tcp_send_buffers) + 1;
+	naya = (void *)scheme_malloc(sizeof(void *) * nayac);
+	memcpy(naya, tcp_send_buffers, sizeof(void *) * num_tcp_send_buffers);
+	for (i = num_tcp_send_buffers; i < nayac; i++) {
+	  wd = (WriteData *)scheme_malloc(sizeof(WriteData) * 2);
+	  wd->xpb = NULL;
+	  e = wd->e;
+	  e[0].ptr = NULL;
+	  e[1].ptr = NULL;
+	  e[1].length = 0;
+	  naya[i] = (void *)e;
+	}
+
+	wd = (WriteData *)naya[num_tcp_send_buffers];
+	
+	tcp_send_buffers = naya;
+	num_tcp_send_buffers = nayac;
+      }
+
+      wd->xpb = xpb;
+      e = wd->e;
+
+      e[0].ptr = (Ptr)scheme_malloc_atomic(len);
+      memcpy(e[0].ptr, s, len);
+      e[0].length = len;
+      e[1].ptr = NULL;
+      e[1].length = 0;
+
+      pb->csCode = TCPSend;
+      pb->ioCompletion = u_tcp_send_done;
+      pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
+      pb->csParam.send.ulpTimeoutValue = 60 /* seconds */;
+      pb->csParam.send.ulpTimeoutAction = 1 /* 0:abort 1:report */;
+      pb->csParam.send.pushFlag = 1;
+      pb->csParam.send.urgentFlag = 0;
+      pb->csParam.send.wdsPtr = (Ptr)e;
+      pb->csParam.send.sendFree = 0;
+      pb->csParam.send.sendLength = 0;
+      
+      errid = PBControlAsync((ParamBlockRec*)pb);
+    } else if (!errid) {
+      if (bytes) {
+      	/* Do partial write: */
+        tcp_write_string(s, bytes, port);
+        tcp_write_string(s + bytes, len - bytes, port);
+      } else
+        would_block = 1;
+    }
+  } else
+    errid = data->tcp.async_errid;
+#endif
+
+  if (would_block) {
+    data->sendbuf = (char *)scheme_malloc_atomic(len);
+    data->sendbuflen = data->sendbufsize = len;
+    memcpy(data->sendbuf, s, len);
+
+    data->refcount++;
+
+    scheme_thread_w_manager(scheme_make_closed_prim(write_when_possible, port), 
+			    scheme_config,
+			    *(port->mref));
+  } else
+    data->sendbuftrying = 0;
+
+  if (errid)
+    scheme_raise_exn(MZEXN_I_O_WRITE,
+		     port,
+		     "tcp-write: error writing (%d)",
+		     errid);
+}
+
+static void tcp_close_output(Scheme_Output_Port *port)
+{
+  Scheme_Tcp *data;
+
+  data = (Scheme_Tcp *)port->port_data;
+
+  if (--data->refcount)
+    return;
+
+#ifdef USE_UNIX_SOCKETS_TCP
+  close(data->tcp);
+#endif
+#ifdef USE_MAC_TCP
+  mac_tcp_close(data);
+#endif
+}
+
+static Scheme_Object *
+make_named_tcp_input_port(void *data, const char *name)
+{
+  Scheme_Input_Port *ip;
+
+  ip = _scheme_make_input_port(tcp_input_port_type,
+			       data,
+			       tcp_getc,
+			       tcp_char_ready,
+			       tcp_close_input,
+			       tcp_need_wakeup,
+			       1);
+
+  ip->name = (char *)name;
+
+  return (Scheme_Object *)ip;
+}
+
+static Scheme_Object *
+make_tcp_output_port(void *data)
+{
+  return (Scheme_Object *)scheme_make_output_port(tcp_output_port_type,
+						  data,
+						  tcp_write_string,
+						  tcp_close_output,
+						  1);
+}
+
+
+#endif /* USE_TCP */
+
+static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
+{
+  char *address = "", *errmsg = "";
+  unsigned short origid, id;
+  int errpart = 0, errid = 0;
+#ifdef USE_SOCKETS_TCP
+  struct hostent *host;
+  tcp_address dest_addr;
+  struct protoent *proto;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("tcp-connect", "string", 0, argc, argv);
+  if (!CHECK_PORT_ID(argv[1]))
+    scheme_wrong_type("tcp-connect", PORT_ID_TYPE, 1, argc, argv);
+
+  TCP_INIT("tcp-connect");
+
+  address = SCHEME_STR_VAL(argv[0]);
+  origid = (unsigned short)SCHEME_INT_VAL(argv[1]);
+
+#ifdef USE_TCP
+  /* Set id in network order: */
+  id = htons(origid);
+#endif
+
+#ifdef USE_MAC_TCP
+  {
+    TCPiopbX *xpb;
+    TCPiopb *pb;
+    Scheme_Tcp *data;
+    int errNo;
+    struct hostInfo dest_host;
+    Scheme_Object *v[2];
+    
+    if ((errNo = tcp_addr(address, &dest_host))) {
+      errpart = 1;
+      errmsg = " host not found";
+      goto tcp_error;
+    }
+    
+    if ((errNo = mac_tcp_make(&xpb, &pb, &data))) {
+      errpart = 2;
+      goto tcp_error;
+    }
+
+    data->tcp.state = SOCK_STATE_CONNECTING;
+    
+    pb->ioCompletion = u_tcp_connect_done;
+    pb->csCode = TCPActiveOpen;
+    pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
+    pb->csParam.open.ulpTimeoutValue = 60 /* seconds */;
+    pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
+    pb->csParam.open.commandTimeoutValue = 0;
+    pb->csParam.open.remoteHost = dest_host.addr[0];
+    pb->csParam.open.remotePort = id;
+    pb->csParam.open.localHost = 0;
+    pb->csParam.open.localPort = 0;
+    pb->csParam.open.dontFrag = 0;
+    pb->csParam.open.timeToLive = 0;
+    pb->csParam.open.security = 0;
+    pb->csParam.open.optionCnt = 0;
+
+    if (errNo = PBControlAsync((ParamBlockRec*)pb)) {
+      errpart = 3;
+      goto tcp_close_and_error;
+    }
+    
+    scheme_block_until(tcp_check_connect, tcp_connect_needs_wakeup, pb, 0);
+    
+    if (data->tcp.state != SOCK_STATE_CONNECTED) {
+      errpart = 4;
+      errNo = pb->ioResult;
+      goto tcp_close_and_error;
+    }
+    
+    v[0] = make_named_tcp_input_port(data, address);
+    v[1] = make_tcp_output_port(data);
+    
+    return scheme_values(2, v);
+    
+  tcp_close_and_error:
+    
+    mac_tcp_close(data);
+    
+  tcp_error:
+    
+    errid = errNo;
+  }
+#endif
+
+#ifdef USE_SOCKETS_TCP
+  host = gethostbyname(address);
+  if (host) {
+    dest_addr.sin_family = AF_INET;
+    dest_addr.sin_port = id;
+    memset(&dest_addr.sin_addr, 0, sizeof(dest_addr.sin_addr));
+    memcpy(&dest_addr.sin_addr, host->h_addr_list[0], host->h_length); 
+    memset(&dest_addr.sin_zero, 0, sizeof(dest_addr.sin_zero));
+
+    proto = getprotobyname("tcp");
+    if (proto) {
+      tcp_t s = socket(PF_INET, SOCK_STREAM, proto->p_proto);
+      if (s != INVALID_SOCKET) {
+	int status, inprogress;
+#ifdef USE_WINSOCK_TCP
+	unsigned long ioarg = 1;
+	ioctlsocket(s, FIONBIO, &ioarg);
+#else
+	int size = TCP_SOCKSENDBUF_SIZE;
+	fcntl(s, F_SETFL, TCP_NONBLOCKING);
+	setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&size, sizeof(int));
+#endif
+	status = connect(s, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
+#ifdef USE_UNIX_SOCKETS_TCP
+	if (status)
+	  status = errno;
+	
+	inprogress = (status == EINPROGRESS);
+#endif
+#ifdef USE_WINSOCK_TCP
+	if (status)
+	  status = WSAGetLastError();
+
+	inprogress = (status == WSAEWOULDBLOCK);
+#endif
+
+	scheme_file_open_count++;
+	
+	if (inprogress) {
+	  status = scheme_block_until(tcp_check_connect, tcp_connect_needs_wakeup, (void *)s, (float)0.0);
+	  if (status == 1) {
+#ifdef USE_UNIX_SOCKETS_TCP
+	    status = recv(s, NULL, 0, 0); /* test input */
+	    if (!status)
+	      status = send(s, NULL, 0, 0); /* test output */
+#else
+	    status = send(s, "", 0, 0); /* test output */
+	    if (status)
+	      errno = WSAGetLastError();
+#endif
+	  }
+	}
+	
+	if (!status) {
+	  Scheme_Object *v[2];
+	  Scheme_Tcp *tcp;
+
+	  tcp = make_tcp_port_data(s, 2);
+	  
+	  v[0] = make_named_tcp_input_port(tcp, address);
+	  v[1] = make_tcp_output_port(tcp);
+	  
+	  return scheme_values(2, v);
+	} else {
+	  closesocket(s);
+	  --scheme_file_open_count;
+	  errpart = 4;
+	}
+      } else
+	errpart = 3;
+      errid = errno;
+    } else
+      (errid = 1, errpart = 2);
+  } else {
+    errpart = 1;
+#ifdef USE_WINSOCK_TCP
+    errid = WSAGetLastError();
+#else
+    errid = 0;
+#endif
+    errmsg = " host not found";
+  }
+#endif
+
+#ifdef USE_TCP
+  scheme_raise_exn(MZEXN_I_O_TCP_CONNECT,
+		   scheme_make_string(address), 
+		   scheme_make_integer(origid),
+		   "tcp-connect: connection to %s, port %d failed (%d%s%d%s)",
+		   address, origid, errpart, ":", errid, errmsg);
+#else
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "tcp-connect: not supported on this platform");
+#endif
+
+  return NULL;
+}
+
+static Scheme_Object *
+tcp_listen(int argc, Scheme_Object *argv[])
+{
+  unsigned short id, origid;
+  int backlog, errid;
+#ifdef USE_SOCKETS_TCP
+  struct protoent *proto;
+#endif
+
+  if (!CHECK_PORT_ID(argv[0]))
+    scheme_wrong_type("tcp-listen", PORT_ID_TYPE, 0, argc, argv);
+  if (argc > 1)
+    if (!SCHEME_INTP(argv[1]) || (SCHEME_INT_VAL(argv[1]) < 1))
+      scheme_wrong_type("tcp-listen", "small positive integer", 1, argc, argv);
+    
+  TCP_INIT("tcp-listen");
+
+  origid = (unsigned short)SCHEME_INT_VAL(argv[0]);
+  if (argc > 1)
+    backlog = SCHEME_INT_VAL(argv[1]);
+  else
+    backlog = 4;
+
+#ifdef USE_TCP
+  /* Set id in network order: */
+  id = htons(origid);
+#endif
+
+#ifdef USE_MAC_TCP
+  {
+    int i;
+    Scheme_Tcp **datas, *data;
+
+    datas = (Scheme_Tcp **)scheme_malloc(sizeof(Scheme_Tcp *) * backlog);
+
+    for (i = 0; i < backlog; i++) {
+      if ((errid = mac_tcp_listen(id, &data)))
+	break;
+      datas[i] = data;
+    }
+
+    if (!errid) {
+      listener_t *l = MALLOC_ONE(listener_t);
+
+      l->type = scheme_listener_type;
+      l->portid = id;
+      l->count = backlog;
+      l->datas = datas;
+      l->mref = scheme_add_managed(NULL,
+				   (Scheme_Object *)l,
+				   (Scheme_Close_Manager_Client *)stop_listener,
+				   NULL,
+				   1);
+      
+      return (Scheme_Object *)l;
+    }
+  }
+#endif
+
+#ifdef USE_SOCKETS_TCP
+  proto = getprotobyname("tcp");
+  if (proto) {
+    tcp_address addr;
+    tcp_t s;
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = id;
+    memset(&addr.sin_addr, 0, sizeof(addr.sin_addr));
+    memset(&addr.sin_zero, 0, sizeof(addr.sin_zero));
+
+    s = socket(PF_INET, SOCK_STREAM, proto->p_proto);
+    if (s != INVALID_SOCKET) {
+#ifdef USE_WINSOCK_TCP
+      unsigned long ioarg = 1;
+      ioctlsocket(s, FIONBIO, &ioarg);
+#else
+      fcntl(s, F_SETFL, TCP_NONBLOCKING);
+#endif
+      if (!bind(s, (struct sockaddr *)&addr, sizeof(addr)))
+	if (!listen(s, backlog)) {
+	  listener_t *l = MALLOC_ONE(listener_t);
+
+	  l->type = scheme_listener_type;
+	  l->s = s;
+	  l->mref = scheme_add_managed(NULL,
+				       (Scheme_Object *)l,
+				       (Scheme_Close_Manager_Client *)stop_listener,
+				       NULL,
+				       1);
+
+	  scheme_file_open_count++;
+
+	  return (Scheme_Object *)l;
+	}
+
+      closesocket(s);
+    }
+  }
+  errid = errno;
+#endif
+
+#ifdef USE_TCP
+  scheme_raise_exn(MZEXN_I_O_TCP_LISTEN,
+		   scheme_make_integer(origid),
+		   "tcp-connect: listen on %d failed (%d)",
+		   origid, errid);
+#else
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "tcp-listen: not supported on this platform");
+#endif
+
+  return NULL;
+}
+
+static int stop_listener(Scheme_Object *o)
+{
+  int was_closed = 0;
+
+#ifdef USE_MAC_TCP
+  { 
+    listener_t *l = (listener_t *)o;
+    int i, count = l->count;
+    Scheme_Tcp **datas = l->datas;
+    if (!datas)
+      was_closed = 1;
+    else {
+      l->count = 0;
+      for (i = 0; i < count; i++)
+	mac_tcp_close(datas[i]);
+    }
+ }
+#endif
+
+#ifdef USE_SOCKETS_TCP
+  {
+    tcp_t s = ((listener_t *)o)->s;
+    if (s == INVALID_SOCKET)
+      was_closed = 1;
+    else {
+      closesocket(s);
+      ((listener_t *)o)->s = INVALID_SOCKET;
+      --scheme_file_open_count;
+    }
+  }
+#endif
+
+  return was_closed;
+}
+
+static Scheme_Object *
+tcp_stop(int argc, Scheme_Object *argv[])
+{
+  int was_closed;
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
+    scheme_wrong_type("tcp-close", "tcp-listener", 0, argc, argv);
+
+  TCP_INIT("tcp-close");
+
+  was_closed = stop_listener(argv[0]);
+
+  if (was_closed) {
+    scheme_raise_exn(MZEXN_I_O_TCP_LISTENER_CLOSED,
+		     argv[0],
+		     "tcp-close: listener was already closed");
+    return NULL;
+  }
+
+#ifndef USE_TCP
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "tcp-close: not supported on this platform");
+  return NULL;
+#else
+  return scheme_void;
+#endif
+}
+
+static Scheme_Object *
+tcp_accept_ready(int argc, Scheme_Object *argv[])
+{
+#ifdef USE_TCP
+  int ready;
+#endif
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
+    scheme_wrong_type("tcp-accept-rady?", "tcp-listener", 0, argc, argv);
+
+  TCP_INIT("tcp-accept-ready?");
+
+  if (LISTENER_WAS_CLOSED(argv[0])) {
+    scheme_raise_exn(MZEXN_I_O_TCP_LISTENER_CLOSED,
+		     argv[0],
+		     "tcp-accept-ready?: listener is closed");
+    return NULL;
+  }
+
+#ifdef USE_TCP
+  ready = tcp_check_accept(argv[0]);
+#endif
+
+#ifdef USE_TCP
+  return (ready ? scheme_true : scheme_false);
+#else
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "tcp-accept-ready?: not supported on this platform");
+  return NULL;
+#endif
+}
+
+static Scheme_Object *
+tcp_accept(int argc, Scheme_Object *argv[])
+{
+  int was_closed = 0, errid;
+  Scheme_Object *listener;
+#ifdef USE_SOCKETS_TCP
+  tcp_t s;
+  int l;
+  tcp_address addr;
+#endif
+#ifdef USE_MAC_TCP
+  listener_t *l;
+  int i, count;
+  Scheme_Tcp **datas;
+#endif
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
+    scheme_wrong_type("tcp-accept", "tcp-listener", 0, argc, argv);
+
+  TCP_INIT("tcp-accept?");
+
+  listener = argv[0];
+
+  was_closed = LISTENER_WAS_CLOSED(listener);
+
+#ifdef USE_TCP
+  if (!was_closed) {
+    if (!tcp_check_accept(listener)) {
+      scheme_current_process->block_descriptor = -1;
+      scheme_current_process->blocker = listener;
+      scheme_current_process->block_check = tcp_check_accept;
+      scheme_current_process->block_needs_wakeup = tcp_accept_needs_wakeup;
+      do {
+	scheme_process_block((float)0.0);
+      } while (!tcp_check_accept(listener));
+      scheme_current_process->block_descriptor = NOT_BLOCKED;
+      scheme_current_process->blocker = NULL;
+      scheme_current_process->ran_some = 1;
+    }
+    was_closed = LISTENER_WAS_CLOSED(listener);
+  }
+#endif
+
+  if (was_closed) {
+    scheme_raise_exn(MZEXN_I_O_TCP_LISTENER_CLOSED,
+		     listener,
+		     "tcp-accept: listener is closed");
+    return NULL;
+  }
+  
+#ifdef USE_SOCKETS_TCP
+  s = ((listener_t *)listener)->s;
+
+  l = sizeof(addr);
+  s = accept(s, (struct sockaddr *)&addr, &l);
+  if (s != INVALID_SOCKET) {
+    Scheme_Object *v[2];
+    Scheme_Tcp *tcp = make_tcp_port_data(s, 2);
+    
+#ifdef USE_UNIX_SOCKETS_TCP
+    int size = TCP_SOCKSENDBUF_SIZE;
+    setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&size, sizeof(int));
+#endif
+
+    v[0] = make_named_tcp_input_port(tcp, "TCP");
+    v[1] = make_tcp_output_port(tcp);
+
+    scheme_file_open_count++;
+    
+    return scheme_values(2, v);
+  }
+  errid = errno;
+#endif
+
+#ifdef USE_MAC_TCP
+  l = (listener_t *)listener;
+  count = l->count;
+  datas = l->datas;
+
+  errid = 0;
+  for (i = 0; i < count; i++) {
+    if (datas[i]->tcp.state == SOCK_STATE_LIS_CON) {
+      Scheme_Object *v[2];
+      Scheme_Tcp *data;
+      
+      datas[i]->tcp.state = SOCK_STATE_CONNECTED;
+      
+      v[0] = make_named_tcp_input_port(datas[i], "TCP");
+      v[1] = make_tcp_output_port(datas[i]);
+      
+      if (!(errid = mac_tcp_listen(l->portid, &data))) {
+	/* new listener at the end of the queue: */
+	memcpy(datas + i, datas + i + 1, count - i);
+	datas[count - 1] = data;
+
+	scheme_file_open_count++;
+    
+	return scheme_values(2, v);
+      }
+    }
+  }
+#endif
+
+#ifdef USE_TCP
+  scheme_raise_exn(MZEXN_I_O_TCP_LISTEN,
+		   listener,
+		   "tcp-accept: accept from listener failed (%d)", errid);
+#else
+  scheme_raise_exn(MZEXN_MISC_UNSUPPORTED,
+		   "tcp-accept: not supported on this platform");
+#endif
+
+  return NULL;
+}
+
+static Scheme_Object *tcp_listener_p(int argc, Scheme_Object *argv[])
+{
+   return (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type)
+	   ? scheme_true
+	   : scheme_false);
+}
+
+static Scheme_Object *tcp_port_send_waiting_p(int argc, Scheme_Object *argv[])
+{
+  Scheme_Tcp *data;
+
+  if (!SCHEME_OUTPORTP(argv[0])
+      || (((Scheme_Output_Port *)argv[0])->sub_type != tcp_output_port_type))
+    scheme_wrong_type("tcp-port-send-waiting?", "tcp-output-port", 0, argc, argv);
+
+  data = (Scheme_Tcp *)(((Scheme_Output_Port *)argv[0])->port_data);
+
+  return (data->sendbuflen || data->sendbuftrying) ? scheme_true : scheme_false;
+}
+
+#if defined(WINDOWS_PROCESSES) || defined(DETECT_WIN32_CONSOLE_STDIN)
+typedef struct 
+{
+  fd_set *rd, *wr, *ex;
+} Tcp_Select_Info;
+
+static long select_for_tcp(void *data)
+{
+  Tcp_Select_Info *info = (Tcp_Select_Info *)data;
+  
+  select(0, info->rd, info->wr, info->ex, NULL);  
+
+  return 0;
+}
+#endif
+
+#ifdef WIN32_FD_HANDLES
+static void clean_up_wait(DWORD result, HANDLE *array, int *rps, int count)
+{
+  if ((result >= WAIT_OBJECT_0) && (result < WAIT_OBJECT_0 + count)) {
+    result -= WAIT_OBJECT_0;
+    if (rps[result])
+      ReleaseSemaphore(array[result], 1, NULL);
+  }
+  
+  /* Clear out break semaphore */
+  WaitForSingleObject(scheme_break_semaphore, 0);
+}
+#endif
+
+static void default_sleep(float v, void *fds)
+{
+  if (!fds) {
+#ifndef NO_SLEEP
+#ifndef NO_USLEEP
+    usleep((unsigned)(v * 1000));
+#else
+    sleep(v);
+#endif
+#endif
+  } else {
+#if defined(FILES_HAVE_FDS) || defined(USE_WINSOCK_TCP)
+    int limit;
+    fd_set *rd, *wr, *ex;
+    struct timeval time;
+
+    time.tv_sec = (long)v;
+    time.tv_usec = (long)(fmod(v, 1.0) * 1000000);
+
+#ifdef USE_WINSOCK_TCP
+    limit = 0;
+#else
+#ifdef USE_ULIMIT
+    limit = ulimit(4, 0);
+#else
+    limit = getdtablesize();
+#endif    
+#endif
+
+    rd = (fd_set *)fds;
+    wr = (fd_set *)MZ_GET_FDSET(fds, 1);
+    ex = (fd_set *)MZ_GET_FDSET(fds, 2);
+
+#ifdef WIN32_FD_HANDLES
+    {
+      HANDLE *array, just_two_array[2], break_sema;
+      int count = 0, *rps, just_two_rps[2];
+
+      count = ((win_extended_fd_set *)fds)->num_handles;
+      array = ((win_extended_fd_set *)fds)->handles;
+      rps = ((win_extended_fd_set *)fds)->repost_sema;
+      
+      /* add break semaphore: */
+      if (!count) {
+	array = just_two_array;
+	rps = just_two_rps;
+      }
+      rps[count] = 0;
+#ifdef WIN32_THREADS
+      break_sema = (HANDLE)scheme_win32_get_break_semaphore(scheme_current_process->th);
+#else
+      break_sema = scheme_break_semaphore;
+#endif
+      array[count++] = break_sema;
+
+      if (count && !rd->fd_count && !wr->fd_count && !ex->fd_count) {
+	/* Simple: just wait for HANDLE-based input: */
+	clean_up_wait(WaitForMultipleObjects(count, array, FALSE, v ? (DWORD)(v * 1000) : INFINITE),
+		      array, rps, count);
+	return;
+      } else if (count) {
+	/* What a mess! We must wait for either HANDLE-based input or TCP
+	   status. Use a thread to select() for TCP status, and then
+	   hit a semaphore if the status changes. Meanwhile, in this
+	   thread, wait on both the console input and the semaphore.
+	   When either happens, kill the thread. */
+	HANDLE th;
+	DWORD id;
+	Tcp_Select_Info info; 
+	SOCKET fake;
+
+	fake = socket(PF_INET, SOCK_STREAM, 0);
+	FD_SET(fake, ex);
+
+	info.rd = rd;
+	info.wr = wr;
+	info.ex = ex;
+
+	th = CreateThread(NULL, 5000, 
+			  (LPTHREAD_START_ROUTINE)select_for_tcp,
+			  &info, 0, &id);
+	
+	rps[count] = 0;
+	array[count++] = th;
+
+	clean_up_wait(WaitForMultipleObjects(count, array, FALSE, 
+	                                     v ? (DWORD)(v * 1000) : INFINITE),
+		      array, rps, count);
+
+	closesocket(fake); /* cause selector thread to end */
+
+	CloseHandle(th);
+	
+	return;
+      }
+    }
+#endif
+
+#ifdef USE_WINSOCK_TCP
+    /* Stupid Windows: give select() empty fd_sets and it ignores the timeout. */
+    if (!rd->fd_count && !wr->fd_count && !ex->fd_count) {
+      if (v)
+        Sleep((DWORD)(v * 1000));
+      return;
+    }
+#endif
+
+    select(limit, rd, wr, ex, v ? &time : NULL);
+#endif
+  }
+}
+
+#ifdef MEMORY_COUNTING_ON
+void scheme_count_input_port(Scheme_Object *port, long *s, long *e, 
+			     Scheme_Hash_Table *ht)
+{
+  Scheme_Input_Port *ip = (Scheme_Input_Port *)port;
+
+  *e = scheme_count_memory(ip->read_handler, ht);
+  *s = sizeof(Scheme_Input_Port);
+
+  if (ip->sub_type == file_input_port_type)
+    *s += sizeof(Scheme_Input_File);    
+  else if (ip->sub_type == string_input_port_type) {
+    Scheme_Indexed_String *is;
+    is = (Scheme_Indexed_String *)ip->port_data;
+    *s += (sizeof(Scheme_Indexed_String)
+	   + is->size);
+  } else if (ip->sub_type == tcp_input_port_type) {
+    if (!scheme_lookup_in_table(ht, (const char *)ip->port_data)) {
+      scheme_add_to_table(ht, (const char *)ip->port_data, scheme_true, 0);
+      *s += sizeof(Scheme_Tcp);
+    }
+  } else if (ip->sub_type == user_input_port_type) {
+    Scheme_Object **d;
+    d = (Scheme_Object **)ip->port_data;
+    *s += (3 * sizeof(Scheme_Object *));
+    *e += (scheme_count_memory(d[0], ht)
+	   + scheme_count_memory(d[1], ht)
+	   + scheme_count_memory(d[2], ht));
+  } else if (ip->sub_type == pipe_read_port_type) {
+    if (!scheme_lookup_in_table(ht, (const char *)ip->port_data)) {
+      Scheme_Pipe *p = (Scheme_Pipe *)ip->port_data;
+      scheme_add_to_table(ht, (const char *)ip->port_data, scheme_true, 0);
+      *s += (sizeof(Scheme_Pipe) + p->buflen);
+    }
+  }
+}
+
+void scheme_count_output_port(Scheme_Object *port, long *s, long *e, 
+			     Scheme_Hash_Table *ht)
+{
+  Scheme_Output_Port *op = (Scheme_Output_Port *)port;
+
+  *e = 0;
+  *s = sizeof(Scheme_Output_Port);
+
+  if (op->sub_type == file_output_port_type)
+    *s += sizeof(Scheme_Output_File);    
+  else if (op->sub_type == string_output_port_type) {
+    Scheme_Indexed_String *is;
+    is = (Scheme_Indexed_String *)op->port_data;
+    *s += (sizeof(Scheme_Indexed_String)
+	   + is->size);
+  } else if (op->sub_type == tcp_output_port_type) {
+    if (!scheme_lookup_in_table(ht, (const char *)op->port_data)) {
+      scheme_add_to_table(ht, (const char *)op->port_data, scheme_true, 0);
+      *s += sizeof(Scheme_Tcp);
+    }
+  } else if (op->sub_type == user_output_port_type) {
+    Scheme_Object **d;
+    d = (Scheme_Object **)op->port_data;
+    *s += (2 * sizeof(Scheme_Object *));
+    *e += (scheme_count_memory(d[0], ht)
+	   + scheme_count_memory(d[1], ht));
+  } else if (op->sub_type == pipe_read_port_type) {
+    if (!scheme_lookup_in_table(ht, (const char *)op->port_data)) {
+      Scheme_Pipe *p = (Scheme_Pipe *)op->port_data;
+      scheme_add_to_table(ht, (const char *)op->port_data, scheme_true, 0);
+      *s += (sizeof(Scheme_Pipe) + p->buflen);
+    }
+  }
+}
+#endif
diff --git a/src/mzscheme/src/print.c b/src/mzscheme/src/print.c
new file mode 100644
index 0000000..18e867f
--- /dev/null
+++ b/src/mzscheme/src/print.c
@@ -0,0 +1,1394 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include "schmach.h"
+#include "schcpt.h"
+#include <ctype.h>
+#ifdef USE_STACKAVAIL
+#include <malloc.h>
+#endif
+
+/* Flag for debugging compiled code in printed form: */
+#define NO_COMPACT 0
+
+#define PRINT_MAXLEN_MIN 3
+
+/* locals */
+#define MAX_PRINT_BUFFER 500
+
+#define quick_print_struct quick_can_read_compiled
+#define quick_print_graph quick_can_read_graph
+#define quick_print_box quick_can_read_box
+/* Don't use can_read_pipe_quote! */
+
+static void print_to_port(char *name, Scheme_Object *obj, Scheme_Object *port, 
+			  int escaped, long maxl, Scheme_Process *p,
+			  Scheme_Config *config);
+static int print(Scheme_Object *obj, int escaped, int compact, 
+		 Scheme_Hash_Table *ht, Scheme_Process *p);
+static void print_string(Scheme_Object *string, int escaped, Scheme_Process *p);
+static void print_pair(Scheme_Object *pair, int escaped, int compact, 
+		       Scheme_Hash_Table *ht, Scheme_Process *p);
+static void print_vector(Scheme_Object *vec, int escaped, int compact, 
+			 Scheme_Hash_Table *ht, Scheme_Process *p);
+static void print_char(Scheme_Object *chobj, int escaped, Scheme_Process *p);
+static char *print_to_string(Scheme_Object *obj, long *len, int write,
+			     Scheme_Object *port, long maxl,
+			     Scheme_Process *p, Scheme_Config *config);
+
+static Scheme_Object *quote_link_symbol = NULL;
+static char *quick_buffer = NULL;
+
+static char compacts[_CPT_COUNT_];
+
+#define print_compact(p, v) print_this_string(p, &compacts[v], 1)
+
+#define HAS_SUBSTRUCT(obj) \
+   (SCHEME_PAIRP(obj) || SCHEME_VECTORP(obj) \
+    || (p->quick_print_box && SCHEME_BOXP(obj)) \
+    || (p->quick_print_struct  \
+	&& SAME_TYPE(SCHEME_TYPE(obj), scheme_structure_type)))
+
+void scheme_init_print(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    int i;
+
+    REGISTER_SO(quick_buffer);
+
+    quick_buffer = (char *)scheme_malloc_atomic(100);
+
+    REGISTER_SO(quote_link_symbol);
+
+    quote_link_symbol = scheme_intern_symbol("-q");
+
+    for (i = 0; i < _CPT_COUNT_; i++)
+      compacts[i] = i;
+  }
+}
+
+Scheme_Object *scheme_make_svector(short c, short *a)
+{
+  Scheme_Object *o = scheme_alloc_object();
+
+  o->type = scheme_svector_type;
+  SCHEME_SVEC_LEN(o) = c;
+  SCHEME_SVEC_VEC(o) = a;
+
+  return o;
+}
+
+void
+scheme_debug_print (Scheme_Object *obj)
+{
+  scheme_write(obj, scheme_orig_stdout_port);
+  fflush (stdout);
+}
+
+static void *print_to_port_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *obj, *port;
+
+  port = (Scheme_Object *)p->ku.k.p1;
+  obj = (Scheme_Object *)p->ku.k.p2;
+
+  print_to_port(p->ku.k.i2 ? "write" : "display", 
+		obj, port,
+		p->ku.k.i2, p->ku.k.i1,
+		p, p->config);
+
+  return NULL;
+}
+
+static void do_handled_print(Scheme_Object *obj, Scheme_Object *port,
+			     Scheme_Object *proc, long maxl)
+{
+  Scheme_Object *a[2];
+  a[0] = obj;
+  
+  if (maxl > 0)
+    a[1] = scheme_make_string_output_port();
+  else
+    a[1] = port;
+  
+  scheme_apply(scheme_write_proc, 2, a);
+  
+  if (maxl > 0) {
+    char *s;
+    int len;
+
+    s = scheme_get_sized_string_output(a[1], &len);
+    if (len > maxl)
+      len = maxl;
+
+    scheme_write_string(s, len, port);
+  }
+}
+
+void scheme_write_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl)
+{
+  if (((Scheme_Output_Port *)port)->write_handler)
+    do_handled_print(obj, port, scheme_write_proc, maxl);
+  else {
+    Scheme_Process *p = scheme_current_process;
+    
+    p->ku.k.p1 = port;
+    p->ku.k.p2 = obj;
+    p->ku.k.i1 = maxl;
+    p->ku.k.i2 = 1;
+    
+    (void)scheme_top_level_do(print_to_port_k);
+  }
+}
+
+void scheme_write(Scheme_Object *obj, Scheme_Object *port)
+{
+  scheme_write_w_max(obj, port, -1);
+}
+
+void scheme_display_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl)
+{
+  if (((Scheme_Output_Port *)port)->display_handler)
+    do_handled_print(obj, port, scheme_display_proc, maxl);
+  else {
+    Scheme_Process *p = scheme_current_process;
+    
+    p->ku.k.p1 = port;
+    p->ku.k.p2 = obj;
+    p->ku.k.i1 = maxl;
+    p->ku.k.i2 = 0;
+    
+    (void)scheme_top_level_do(print_to_port_k);
+  }
+}
+
+void scheme_display(Scheme_Object *obj, Scheme_Object *port)
+{
+  scheme_display_w_max(obj, port, -1);
+}
+
+static void *print_to_string_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *obj;
+  long *len, maxl;
+  int iswrite;
+
+  obj = (Scheme_Object *)p->ku.k.p1;
+  len = (long *)p->ku.k.p2;
+  maxl = p->ku.k.i1;
+  iswrite = p->ku.k.i2;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  return (void *)print_to_string(obj, len, iswrite, 
+				 NULL, maxl,
+				 p, p->config);
+}
+
+char *scheme_write_to_string_w_max(Scheme_Object *obj, long *len, long maxl)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  p->ku.k.p1 = obj;
+  p->ku.k.p2 = len;
+  p->ku.k.i1 = maxl;
+  p->ku.k.i2 = 1;
+
+  return (char *)scheme_top_level_do(print_to_string_k);
+}
+
+char *scheme_write_to_string(Scheme_Object *obj, long *len)
+{
+  return scheme_write_to_string_w_max(obj, len, -1);
+}
+
+char *scheme_display_to_string_w_max(Scheme_Object *obj, long *len, long maxl)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  p->ku.k.p1 = obj;
+  p->ku.k.p2 = len;
+  p->ku.k.i1 = maxl;
+  p->ku.k.i2 = 0;
+
+  return (char *)scheme_top_level_do(print_to_string_k);
+}
+
+char *scheme_display_to_string(Scheme_Object *obj, long *len)
+{
+  return scheme_display_to_string_w_max(obj, len, -1);
+}
+
+void
+scheme_internal_write(Scheme_Object *obj, Scheme_Object *port, 
+		      Scheme_Config *config)
+{
+  print_to_port("write", obj, port, 1, -1, scheme_current_process, config);
+}
+
+void
+scheme_internal_display(Scheme_Object *obj, Scheme_Object *port, 
+		      Scheme_Config *config)
+{
+  print_to_port("display", obj, port, 0, -1, scheme_current_process, config);
+}
+
+#ifdef DO_STACK_CHECK
+static int check_cycles(Scheme_Object *, Scheme_Process *);
+
+static Scheme_Object *check_cycle_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *o = (Scheme_Object *)p->ku.k.p1;
+
+  p->ku.k.p1 = NULL;
+
+  return check_cycles(o, p)
+    ? scheme_true : scheme_false;
+}
+#endif
+
+static int check_cycles(Scheme_Object *obj, Scheme_Process *p)
+{
+  Scheme_Type t;
+  int cycle = 0;
+
+  t = SCHEME_TYPE(obj);
+  if (t < 0)
+    return 1;
+
+#ifdef DO_STACK_CHECK
+#define CHECK_COUNT_START 50
+  {
+    static int check_counter = CHECK_COUNT_START;
+
+    if (!--check_counter) {
+      check_counter = CHECK_COUNT_START;
+      SCHEME_USE_FUEL(CHECK_COUNT_START);
+      {
+#include "mzstkchk.h"
+	{
+#ifndef ERROR_ON_OVERFLOW
+	  scheme_current_process->ku.k.p1 = (void *)obj;
+#endif
+	  return SCHEME_TRUEP(scheme_handle_stack_overflow(check_cycle_k));
+	}
+      }
+    }
+  }
+#else
+  SCHEME_USE_FUEL(1);
+#endif
+
+  if (SCHEME_PAIRP(obj)) {
+    obj->type = -t;
+    cycle = check_cycles(SCHEME_CAR(obj), p) || check_cycles(SCHEME_CDR(obj), p);
+    obj->type = t;
+  } else if (p->quick_print_box && SCHEME_BOXP(obj)) {
+    obj->type = -t;
+    cycle = check_cycles(SCHEME_BOX_VAL(obj), p);
+    obj->type = t;
+  } else if (SCHEME_VECTORP(obj)) {
+    int i, len;
+    Scheme_Object **array;
+
+    obj->type = -t;
+    len = SCHEME_VEC_SIZE(obj);
+    array = SCHEME_VEC_ELS(obj);
+    for (i = 0; i < len; i++)
+      if (check_cycles(array[i], p)) {
+	cycle = 1;
+	break;
+      }
+    obj->type = t;
+  } else if (p->quick_print_struct && SAME_TYPE(t, scheme_structure_type)) {
+    Scheme_Object **slots = ((Scheme_Structure *)obj)->slots;
+    int i = SCHEME_STRUCT_NUM_SLOTS(obj);
+
+    obj->type = -t;
+    while (i--)
+      if (check_cycles(slots[i], p)) {
+	cycle = 1;
+	break;
+      }
+    obj->type = t;
+  }  else
+    cycle = 0;
+
+  return cycle;
+}
+
+static void setup_graph_table(Scheme_Object *obj, Scheme_Hash_Table *ht,
+			      int *counter, Scheme_Process *p)
+{
+  if (HAS_SUBSTRUCT(obj)) {
+    Scheme_Bucket *b;
+
+    b = scheme_bucket_from_table(ht, (const char *)obj);
+
+    if (!b->val)
+      b->val = (void *)1;
+    else {
+      if ((long)b->val == 1)
+	b->val = (void *)(long)++(*counter);
+      return;
+    }
+  } else
+    return;
+
+  if (SCHEME_PAIRP(obj)) {
+    setup_graph_table(SCHEME_CAR(obj), ht, counter, p);
+    setup_graph_table(SCHEME_CDR(obj), ht, counter, p);
+  } else if (p->quick_print_box && SCHEME_BOXP(obj)) {
+    setup_graph_table(SCHEME_BOX_VAL(obj), ht, counter, p);
+  } else if (SCHEME_VECTORP(obj)) {
+    int i, len;
+    Scheme_Object **array;
+
+    len = SCHEME_VEC_SIZE(obj);
+    array = SCHEME_VEC_ELS(obj);
+    for (i = 0; i < len; i++)
+      setup_graph_table(array[i], ht, counter, p);
+  } else if (p->quick_print_struct 
+	   && SAME_TYPE(SCHEME_TYPE(obj), scheme_structure_type)) {
+    Scheme_Object **slots = ((Scheme_Structure *)obj)->slots;
+    int i = SCHEME_STRUCT_NUM_SLOTS(obj);
+
+    while (i--)
+      setup_graph_table(slots[i], ht, counter, p);
+  }
+}
+
+static char *
+print_to_string(Scheme_Object *obj, long *len, int write,
+		Scheme_Object *port, long maxl, Scheme_Process *p,
+		Scheme_Config *config)
+{
+  Scheme_Hash_Table *ht;
+
+  p->print_allocated = 50;
+  p->print_buffer = (char *)scheme_malloc_atomic(p->print_allocated);
+  p->print_position = 0;
+  p->print_maxlen = maxl;
+  p->print_port = port;
+
+  p->quick_print_graph = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_PRINT_GRAPH));
+  p->quick_print_box = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_PRINT_BOX));
+  p->quick_print_struct = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_PRINT_STRUCT));
+  p->quick_can_read_pipe_quote = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CAN_READ_PIPE_QUOTE));
+
+  if (p->quick_print_graph || check_cycles(obj, p)) {
+    int counter = 1;
+    ht = scheme_hash_table(101, SCHEME_hash_ptr, 0, 0);
+    setup_graph_table(obj, ht, &counter, p);
+  } else
+    ht = NULL;
+
+  if ((maxl <= PRINT_MAXLEN_MIN) 
+      || !scheme_setjmp(p->print_escape))
+    print(obj, write, 0, ht, p);
+
+  p->print_buffer[p->print_position] = '\0';
+
+  if (len)
+    *len = p->print_position;
+
+  return p->print_buffer;
+}
+
+static void 
+print_to_port(char *name, Scheme_Object *obj, Scheme_Object *port, int escaped,
+	      long maxl, Scheme_Process *p, Scheme_Config *config)
+{
+  Scheme_Output_Port *op;
+  char *str;
+  long len;
+  
+  op = (Scheme_Output_Port *)port;
+  if (op->closed)
+    scheme_raise_exn(MZEXN_I_O_PORT_CLOSED, port, "%s: output port is closed", name);
+
+  str = print_to_string(obj, &len, escaped, port, maxl, p, config);
+
+  (op->write_string_fun)(str, len, op);
+  op->pos += len;
+}
+
+static void print_this_string(Scheme_Process *p, const char *str, int autolen)
+{
+  long len;
+  char *oldstr;
+
+  if (!autolen)
+    return;
+  else if (autolen > 0)
+    len = autolen;
+  else
+    len = strlen(str);
+
+  if (len + p->print_position + 1 > p->print_allocated) {
+    if (len + 1 >= p->print_allocated)
+      p->print_allocated = 2 * p->print_allocated + len + 1;
+    else
+      p->print_allocated = 2 * p->print_allocated;
+
+    oldstr = p->print_buffer;
+    p->print_buffer = (char *)scheme_malloc_atomic(p->print_allocated);
+    memcpy(p->print_buffer, oldstr, p->print_position);
+  }
+
+  memcpy(p->print_buffer + p->print_position, str, len);
+  p->print_position += len;
+
+  SCHEME_USE_FUEL(len);
+  
+  if (p->print_maxlen > PRINT_MAXLEN_MIN)  {
+    if (p->print_position > p->print_maxlen) {
+      long l = p->print_maxlen;
+
+      p->print_buffer[l] = 0;
+      p->print_buffer[l - 1] = '.';
+      p->print_buffer[l - 2] = '.';
+      p->print_buffer[l - 3] = '.';
+
+      p->print_position = l;
+
+      scheme_longjmp(p->print_escape, 1);
+    }
+  } else if (p->print_position > MAX_PRINT_BUFFER) {
+    if (p->print_port) {
+      Scheme_Output_Port *op = (Scheme_Output_Port *)p->print_port;
+
+      p->print_buffer[p->print_position] = 0;
+      (op->write_string_fun)(p->print_buffer, p->print_position, op);
+      op->pos += p->print_position;
+      
+      p->print_position = 0;
+    }
+  }
+}
+
+static void print_compact_number(Scheme_Process *p, int n)
+{
+  unsigned char s[5];
+
+  if (n < 0) {
+    if (n > -256) {
+      s[0] = 254;
+      s[1] = -n;
+      print_this_string(p, (char *)s, 2);
+      return;
+    } else {
+      n = -n;
+      s[0] = 255;
+    }
+  } else if (n < 253) {
+    s[0] = n;
+    print_this_string(p, (char *)s, 1);
+    return;
+  } else
+    s[0] = 253;
+
+  s[1] = n & 0xFF;
+  s[2] = (n >> 8) & 0xFF;
+  s[3] = (n >> 16) & 0xFF;
+  s[4] = (n >> 24) & 0xFF;  
+  
+  print_this_string(p, (char *)s, 5);
+}
+
+static void print_string_in_angle(Scheme_Process *p, const char *start, const char *prefix, int slen)
+{
+  const char *str;
+  int pos;
+
+  str = start;
+  if (slen < 0)
+    slen = strlen(str);
+
+  for (pos = slen; pos--; str++) {
+    if (*str == '<' || *str == '>' || *str == '\\' || *str == '|')
+      break;
+  }
+
+  if (pos >= 0) {
+    int len = 0;
+
+    pos = 0;
+    str = start;
+    print_this_string(p, "|", 1);
+    print_this_string(p, prefix, -1);
+
+    while (pos < slen) {
+      if (*str == '|') {
+	if (len)
+	  print_this_string(p, start, len);
+	print_this_string(p, "\\", 1);
+	print_this_string(p, str, 1);
+	start = str + 1;
+	len = 0;
+      } else
+	len++;
+      str++;
+      pos++;
+    }
+
+    if (len)
+      print_this_string(p, start, len);
+
+    print_this_string(p, "|", 1);
+  } else {
+    print_this_string(p, prefix, -1);
+    print_this_string(p, start, slen);
+  }
+}
+
+#ifdef DO_STACK_CHECK
+
+static Scheme_Object *print_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *o = (Scheme_Object *)p->ku.k.p1;
+  Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p->ku.k.p2;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  return print(o, 
+	       p->ku.k.i1, 
+	       p->ku.k.i2, 
+	       ht,
+	       p) 
+    ? scheme_true : scheme_false;
+}
+#endif
+
+#define SCHEME_VARIABLE_TYPE scheme_variable_type
+
+static int
+print_substring(Scheme_Object *obj, int escaped, int compact, Scheme_Hash_Table *ht,
+		Scheme_Process *p, char **result, long *rlen)
+{
+  int closed;
+  long save_alloc, save_pos, save_maxl;
+  char *save_buf;
+  Scheme_Object *save_port;
+
+  save_alloc = p->print_allocated;
+  save_buf = p->print_buffer;
+  save_pos = p->print_position;
+  save_maxl = p->print_maxlen;
+  save_port = p->print_port;
+  
+  p->print_allocated = 50;
+  p->print_buffer = (char *)scheme_malloc_atomic(p->print_allocated);
+  p->print_position = 0;
+  p->print_port = NULL;
+
+  closed = print(obj, escaped, compact, ht, p);
+
+  *result = p->print_buffer;
+  *rlen = p->print_position;
+
+  p->print_allocated = save_alloc;
+  p->print_buffer = save_buf;
+  p->print_position = save_pos;
+  p->print_maxlen = save_maxl;
+  p->print_port = save_port;
+  
+  return closed;
+}
+
+static void print_escaped(Scheme_Process *p, int escaped, 
+			  Scheme_Object *obj, Scheme_Hash_Table *ht)
+{
+  char *r;
+  long len;
+
+  print_substring(obj, escaped, 0, ht, p, &r, &len);
+
+  print_compact(p, CPT_ESCAPE);
+  print_compact_number(p, len);
+  print_this_string(p, r, len);
+}
+
+#ifdef SGC_STD_DEBUGGING
+static void printaddress(Scheme_Process *p, Scheme_Object *o)
+{
+  char buf[40];
+  sprintf(buf, ":%lx", (long)o);
+  print_this_string(p, buf, -1);
+}
+# define PRINTADDRESS(p, obj) printaddress(p, obj)
+#else
+# define PRINTADDRESS(p, obj) /* empty */
+#endif
+
+static void print_named(Scheme_Object *obj, const char *kind,
+			const char *s, int len, Scheme_Process *p)
+{
+  print_this_string(p, "#<", 2);
+  print_this_string(p, kind, -1);
+
+  if (s) {
+    int i;
+
+    if (len == -1)
+      len = strlen(s);
+
+    print_this_string(p, ":", 1);
+
+    for (i = 0; i < len; i++) {
+      char c = s[i];
+      if (!isalpha(c) && (c != '-') && (c != '!') && !isdigit(c))
+	break;
+    }
+	  
+    if (i < len) {
+      /* Could be messy - better go through the symbol handler: */
+      int l;
+      Scheme_Object *o = scheme_intern_exact_symbol(s, len);
+      const char *s = scheme_symbol_name_and_size(o, &l, SNF_FOR_TS);
+      
+      print_this_string(p, s, l);
+    } else
+      print_this_string(p, s, -1);
+  }
+   
+  PRINTADDRESS(p, obj);
+  print_this_string(p, ">", 1);
+}
+
+static int
+print(Scheme_Object *obj, int escaped, int compact, Scheme_Hash_Table *ht,
+      Scheme_Process *p)
+{
+  int closed = 0;
+
+#if NO_COMPACT
+  compact = 0;
+#endif
+
+#ifdef DO_STACK_CHECK
+#define PRINT_COUNT_START 20
+  {
+    static int check_counter = PRINT_COUNT_START;
+
+    if (!--check_counter) {
+      check_counter = PRINT_COUNT_START;
+      {
+#include "mzstkchk.h"
+	{
+#ifndef ERROR_ON_OVERFLOW
+	  p->ku.k.p1 = (void *)obj;
+	  p->ku.k.i1 = escaped;
+	  p->ku.k.i2 = compact;
+	  p->ku.k.p2 = (void *)ht;
+#endif
+	  return SCHEME_TRUEP(scheme_handle_stack_overflow(print_k));
+	}
+      }
+    }
+  }
+#endif
+
+  if (ht && HAS_SUBSTRUCT(obj)) {
+    Scheme_Bucket *b = scheme_bucket_from_table(ht, (const char *)obj);
+    
+    if ((long)b->val != 1) {
+      if (compact) {
+	print_escaped(p, escaped, obj, ht);
+	return 1;
+      } else {
+	if ((long)b->val > 0) {
+	  sprintf(quick_buffer, "#%ld=", ((long)b->val) - 2);
+	  print_this_string(p, quick_buffer, -1);
+	  b->val = (void *)(-(long)b->val);
+	} else {
+	  sprintf(quick_buffer, "#%ld#", -((long)b->val + 2));
+	  print_this_string(p, quick_buffer, -1);
+	  return 0;
+	}
+      }
+    }
+  }
+
+  if (SCHEME_SYMBOLP(obj))
+    {
+      int l;
+
+      if (compact) {
+	l = SCHEME_SYM_LEN(obj);
+	if (l < CPT_RANGE(SMALL_SYMBOL)) {
+	  unsigned char s[1];
+	  s[0] = l + CPT_SMALL_SYMBOL_START;
+	  print_this_string(p, (char *)s, 1);
+	} else {
+	  print_compact(p, CPT_SYMBOL);
+	  print_compact_number(p, l);
+	}
+	print_this_string(p, SCHEME_SYM_VAL(obj), l);
+      } else if (escaped) {
+	const char *s;
+	
+	s = scheme_symbol_name_and_size(obj, &l, (p->quick_can_read_pipe_quote 
+						  ? SNF_PIPE_QUOTE
+						  : SNF_NO_PIPE_QUOTE));
+	print_this_string(p, s, l);
+      } else {
+	print_this_string(p, SCHEME_SYM_VAL(obj), SCHEME_SYM_LEN(obj));
+      }
+    }
+  else if (SCHEME_TSYMBOLP(obj))
+    { 
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	const char *s;
+	int l;
+
+	s = scheme_symbol_name_and_size((Scheme_Object *)SCHEME_PTR_VAL(obj), 
+					&l, SNF_FOR_TS);
+      
+	print_this_string(p, "#<", 2);
+	print_this_string(p, s, l);
+	print_this_string(p, ">", 1);
+      }
+      closed = 1;
+    }
+  else if (SCHEME_STRINGP(obj))
+    {
+      if (compact) {
+	int l;
+
+	print_compact(p, CPT_STRING);
+	l = SCHEME_STRTAG_VAL(obj);
+	print_compact_number(p, l);
+	print_this_string(p, SCHEME_STR_VAL(obj), l);
+      } else {
+	print_string(obj, escaped, p);
+	closed = 1;
+      }
+    }
+  else if (SCHEME_CHARP(obj))
+    {
+      if (compact) {
+	char s[1];
+	print_compact(p, CPT_CHAR);
+	s[0] = SCHEME_CHAR_VAL(obj);
+	print_this_string(p, s, 1);
+      } else
+	print_char(obj, escaped, p);
+    }
+  else if (SCHEME_INTP(obj))
+    {
+      if (compact) {
+	long v = SCHEME_INT_VAL(obj);
+	if (v >= 0 && v < CPT_RANGE(SMALL_NUMBER)) {
+	  unsigned char s[1];
+	  s[0] = v + CPT_SMALL_NUMBER_START;
+	  print_this_string(p, (char *)s, 1);
+	} else {
+	  print_compact(p, CPT_INT);
+	  print_compact_number(p, v);
+	}
+      } else {
+	sprintf(quick_buffer, "%ld", SCHEME_INT_VAL(obj));
+	print_this_string(p, quick_buffer, -1);
+      }
+    }
+  else if (SCHEME_NUMBERP(obj))
+    {
+      if (compact) {
+	print_escaped(p, escaped, obj, ht);
+	closed = 1;
+      } else
+	print_this_string(p, scheme_number_to_string(10, obj), -1);
+    }
+  else if (SCHEME_NULLP(obj))
+    {
+      if (compact) {
+	print_compact(p, CPT_NULL);
+      } else {
+	print_this_string(p, "()", 2);
+	closed = 1;
+      }
+    }
+  else if (SCHEME_PAIRP(obj))
+    {
+      print_pair(obj, escaped, compact, ht, p);
+      closed = 1;
+    }
+  else if (SCHEME_VECTORP(obj))
+    {
+      print_vector(obj, escaped, compact, ht, p);
+      closed = 1;
+    }
+  else if (p->quick_print_box && SCHEME_BOXP(obj))
+    {
+      if (compact)
+	print_compact(p, CPT_BOX);
+      else
+	print_this_string(p, "#&", 2);
+      closed = print(SCHEME_BOX_VAL(obj), escaped, compact, ht, p);
+    }
+  else if (SAME_OBJ(obj, scheme_true))
+    {
+      if (compact)
+	print_compact(p, CPT_TRUE);
+      else
+	print_this_string(p, "#t", 2);
+    }
+  else if (SAME_OBJ(obj, scheme_false))
+    {
+      if (compact)
+	print_compact(p, CPT_FALSE);
+      else
+	print_this_string(p, "#f", 2);
+    }
+  else if (SAME_TYPE(SCHEME_TYPE(obj), scheme_structure_type))
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	Scheme_Object *name = SCHEME_STRUCT_NAME_SYM(obj);
+
+	print_this_string(p, p->quick_print_struct ? "#(" : "#<", 2);
+	{
+	  int l;
+	  const char *s = scheme_symbol_name_and_size(name, &l, 
+						      (p->quick_print_struct
+						       ? SNF_FOR_TS
+						       : (p->quick_can_read_pipe_quote 
+							  ? SNF_PIPE_QUOTE
+							  : SNF_NO_PIPE_QUOTE)));
+	  print_this_string(p, s, l);
+	}
+
+	if (p->quick_print_struct) {
+	  Scheme_Object **slots = ((Scheme_Structure *)obj)->slots;
+	  int i, count = SCHEME_STRUCT_NUM_SLOTS(obj), no_sp_ok;
+	  
+	  if (count)
+	    print_this_string(p, " ", 1);
+	  
+	  for (i = 0; i < count; i++) {
+	    no_sp_ok = print(slots[i], escaped, compact, ht, p);
+	    if ((i < count - 1) && (!compact || !no_sp_ok))
+	      print_this_string(p, " ", 1);
+	  }
+	  print_this_string(p, ")", 1);
+	} else {
+	  PRINTADDRESS(p, obj);
+	  print_this_string(p, ">", 1);
+	}
+      }
+
+      closed = 1;
+    }
+  else if (SCHEME_PRIMP(obj) && ((Scheme_Primitive_Proc *)obj)->name)
+    {
+      if (compact) {
+	print_escaped(p, escaped, obj, ht);
+      } else {
+	print_this_string(p, "#<", 2);
+	print_string_in_angle(p, ((Scheme_Primitive_Proc *)obj)->name, "primitive:", -1);
+	PRINTADDRESS(p, obj);
+	print_this_string(p, ">", 1);
+      }
+      closed = 1;
+    }
+  else if (SCHEME_CLSD_PRIMP(obj) && ((Scheme_Closed_Primitive_Proc *)obj)->name)
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	if (SCHEME_STRUCT_PROCP(obj)) {
+	  print_named(obj, "struct-procedure", 
+		      ((Scheme_Closed_Primitive_Proc *)obj)->name, 
+		      -1, p);
+	} else {
+	  print_this_string(p, "#<", 2);
+	  if (SCHEME_GENERICP(obj)) {
+	    print_this_string(p, "generic-procedure", -1);
+	  } else {
+	    print_string_in_angle(p, ((Scheme_Closed_Primitive_Proc *)obj)->name, 
+				  "primitive:", -1);
+	  }
+	  
+	  PRINTADDRESS(p, obj);
+	  print_this_string(p, ">", 1);
+	}
+      }
+
+      closed = 1;
+    }
+  else if (SCHEME_CLOSUREP(obj)) 
+    {
+      if (compact) {
+	print_escaped(p, escaped, obj, ht);
+      } else {
+	int len;
+	const char *s = scheme_get_proc_name(obj, &len, 0);
+	
+	print_named(obj, "procedure", s, len, p);
+      }
+      closed = 1;
+    }
+#ifndef NO_OBJECT_SYSTEM
+  else if (SCHEME_OBJP(obj))
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	int len;
+	const char *cl = scheme_get_class_name(((Scheme_Class_Object *)obj)->sclass, &len);
+	
+	print_named(obj, "object", cl, len, p);
+      }
+      closed = 1;
+    }
+  else if (SCHEME_CLASSP(obj))
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	int len;
+	const char *cl = scheme_get_class_name(obj, &len);
+	
+	print_named(obj, "class", cl, len, p);
+      }
+      closed = 1;
+    }
+  else if (SCHEME_INTERFACEP(obj))
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	int len;
+	const char *cl = scheme_get_interface_name(obj, &len);
+	
+	print_named(obj, "interface", cl, len, p);
+      }
+      closed = 1;
+    }
+  else if (SCHEME_UNITP(obj))
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	int len;
+	const char *cl = scheme_get_unit_name(obj, &len);
+	
+	print_named(obj, "unit", cl, len, p);
+      }
+      closed = 1;
+    }
+#endif
+  else if (compact && SAME_TYPE(SCHEME_TYPE(obj), SCHEME_VARIABLE_TYPE)
+	   && (((Scheme_Bucket_With_Const_Flag *)obj)->flags & GLOB_HAS_REF_ID))
+    {
+      int pos;
+      pos = ((Scheme_Bucket_With_Ref_Id *)obj)->id;
+      print_compact(p, CPT_REFERENCE);
+      print_compact_number(p, pos);
+    }   
+  else if (compact 
+	   && (SAME_TYPE(SCHEME_TYPE(obj), scheme_local_type)
+	       || SAME_TYPE(SCHEME_TYPE(obj), scheme_local_unbox_type)))
+    {
+      int unbox = SAME_TYPE(SCHEME_TYPE(obj), scheme_local_unbox_type);
+      Scheme_Local *loc = (Scheme_Local *)obj;
+      if (loc->position < CPT_RANGE(SMALL_LOCAL)) {
+	unsigned char s[1];
+	s[0] = loc->position + (unbox 
+				? CPT_SMALL_LOCAL_UNBOX_START 
+				: CPT_SMALL_LOCAL_START);
+	print_this_string(p, (char *)s, 1);
+      } else {
+	print_compact(p, unbox ? CPT_LOCAL_UNBOX : CPT_LOCAL);
+	print_compact_number(p, loc->position);
+      }
+    }
+  else if (compact && SAME_TYPE(SCHEME_TYPE(obj), scheme_application_type))
+    {
+      Scheme_App_Rec *app;
+      int i;
+
+      app = (Scheme_App_Rec *)obj;
+
+      if (app->num_args < CPT_RANGE(SMALL_APPLICATION)) {
+	unsigned char s[1];
+	s[0] = CPT_SMALL_APPLICATION_START + app->num_args;
+	print_this_string(p, (char *)s, 1);
+      } else {
+	print_compact(p, CPT_APPLICATION);
+	print_compact_number(p, app->num_args);
+      }
+
+      for (i = 0; i < app->num_args + 1; i++)
+	closed = print(app->args[i], escaped, 1, NULL, p);
+    }
+  else if (SAME_TYPE(SCHEME_TYPE(obj), scheme_quote_compilation_type))
+    {
+      Scheme_Hash_Table *q_ht;
+      Scheme_Object *v;
+      int counter = 1;
+
+      v = SCHEME_PTR_VAL(obj);
+
+      /* A quoted expression may have graph structure. We assume that
+	 this structure is local within the quoted expression. */
+      
+      q_ht = scheme_hash_table(101, SCHEME_hash_ptr, 0, 0);
+      setup_graph_table(v, q_ht, &counter, p);
+
+      if (compact)
+	print_compact(p, CPT_QUOTE);
+      else {
+	/* Doesn't happen: */
+	scheme_signal_error("internal error: non-compact quote compilation");
+	return 0;
+      }
+
+      compact = print(v, escaped, 1, q_ht, p);
+    }
+  else if (
+#if !NO_COMPACT
+	   compact && 
+#endif
+	   SAME_TYPE(SCHEME_TYPE(obj), scheme_svector_type))
+    {
+      short l, *v;
+      l = SCHEME_SVEC_LEN(obj);
+      v = (short *)SCHEME_SVEC_VEC(obj);
+      
+#if NO_COMPACT
+      print_this_string(p, "[", 1);
+      {
+	int i; 
+	char s[10];
+
+	for (i = 0; i < l; i++) {
+	  if (i)
+	    print_this_string(p, " ", 1);
+	  sprintf(s, "%d", (int)v[i]);
+	  print_this_string(p, s, -1);
+	}
+      }
+      print_this_string(p, "]", 1);
+#else
+      if (l < CPT_RANGE(SMALL_SVECTOR)) {
+	unsigned char s[1];
+	s[0] = l + CPT_SMALL_SVECTOR_START;
+	print_this_string(p, (char *)s, 1);
+      } else {
+	print_compact(p, CPT_SVECTOR);
+	print_compact_number(p, l);
+      }
+      while (l--) {
+	int n = v[l];
+	print_compact_number(p, n);
+      }
+#endif
+    }
+  else if (scheme_type_writers[SCHEME_TYPE(obj)]
+#if !NO_COMPACT
+	   && (compact || SAME_TYPE(SCHEME_TYPE(obj), scheme_compilation_top_type))
+#endif
+	   )
+    {
+      Scheme_Type t = SCHEME_TYPE(obj);
+      Scheme_Object *v;
+      char *s;
+      long slen;
+      
+      if (t >= _scheme_last_type_) {
+	/* Doesn't happen: */
+	scheme_signal_error("internal error: bad type with writer");
+	return 0;
+      }
+
+      if (compact) {
+	if (t < CPT_RANGE(SMALL_MARSHALLED)) {
+	  unsigned char s[1];
+	  s[0] = t + CPT_SMALL_MARSHALLED_START;
+	  print_this_string(p, (char *)s, 1);
+	} else {
+	  print_compact(p, CPT_MARSHALLED);
+	  print_compact_number(p, t);
+	}
+      } else {
+	print_this_string(p, "#`", 2);
+#if NO_COMPACT
+	if (t < _scheme_last_type_) {
+	  sprintf (quick_buffer, "%ld", (long)SCHEME_TYPE(obj));
+	  print_this_string(p, quick_buffer, -1);
+	} else
+	  print_this_string(p, scheme_get_type_name(t), -1);
+#endif
+      }
+
+      v = (scheme_type_writers[t])(obj);
+
+      if (compact)
+	closed = print(v, escaped, 1, NULL, p);
+      else {
+	closed = print_substring(v, escaped, 1, NULL, p, &s, &slen);
+	
+#if NO_COMPACT
+#else
+	print_compact_number(p, slen);
+#endif
+	print_this_string(p, s, slen);
+      }
+    } 
+  else 
+    {
+      if (compact)
+	print_escaped(p, escaped, obj, ht);
+      else {
+	char *s = scheme_get_type_name((SCHEME_TYPE(obj)));
+	long len = -1;
+	print_this_string(p, "#", 1);
+#ifdef SGC_STD_DEBUGGING
+	len = strlen(s) - 1;
+#endif
+	print_this_string(p, s, len);
+#ifdef SGC_STD_DEBUGGING
+	PRINTADDRESS(p, obj);
+	print_this_string(p, ">", 1);
+#endif
+      }
+
+      closed = 1;
+    }
+
+  return (closed || compact);
+}
+
+static void
+print_string(Scheme_Object *string, int escaped, Scheme_Process *p)
+{
+  char *str, minibuf[2];
+  int simple;
+  int len, i;
+
+  if (escaped)
+    print_this_string(p, "\"", 1);
+
+  simple = 1;
+
+  len = SCHEME_STRTAG_VAL(string);
+
+  if (len) {
+    if (escaped) {
+      str = SCHEME_STR_VAL(string);
+      for (i = 0; i < len; i++, str++)
+	if ((*str == '"') || (*str == '\\')) {
+	  simple = 0;
+	  break;
+	}
+    }
+    
+    if (simple)
+      print_this_string(p, SCHEME_STR_VAL(string), len);
+    else {
+      minibuf[1] = 0;
+      for (str = SCHEME_STR_VAL(string), i = 0; i < len; i++, str++) {
+	if ((*str == '"') || (*str == '\\'))
+	  print_this_string(p, "\\", 1);
+	minibuf[0] = *str;
+	print_this_string(p, minibuf, 1);
+      }
+    }
+  }
+
+  if (escaped)
+    print_this_string(p, "\"", 1);
+}
+
+static void
+print_pair(Scheme_Object *pair, int escaped, int compact, 
+	   Scheme_Hash_Table *ht, Scheme_Process *p)
+{
+  Scheme_Object *cdr;
+  int no_space_ok;
+  int super_compact = 0;
+
+  if (compact) {
+    int c = 0;
+    Scheme_Object *pr;
+
+    pr = pair;
+    while (SCHEME_PAIRP(pr)) {
+      if (ht)
+	if ((long)scheme_lookup_in_table(ht, (const char *)pr) != 1) {
+	  c = -1;
+	  break;
+	}
+      c++;
+      pr = SCHEME_CDR(pr);
+    }
+
+    if (c > -1) {
+      super_compact = 1;
+      if (c < CPT_RANGE(SMALL_LIST)) {
+	unsigned char s[1];
+	s[0] = c + (SCHEME_NULLP(pr) 
+		    ? CPT_SMALL_PROPER_LIST_START
+		    : CPT_SMALL_LIST_START);
+	print_this_string(p, (char *)s, 1);
+      } else {
+	print_compact(p, CPT_LIST);
+	print_compact_number(p, c);
+	super_compact = -1;
+      }
+    }
+  }
+
+  if (compact) {
+    if (!super_compact)
+      print_compact(p, CPT_PAIR);
+  } else
+    print_this_string(p, "(", 1);
+
+  no_space_ok = print(SCHEME_CAR(pair), escaped, compact, ht, p);
+
+  cdr = SCHEME_CDR (pair);
+  while (SCHEME_PAIRP(cdr)) {
+    if (ht && !super_compact) {
+      if ((long)scheme_lookup_in_table(ht, (const char *)cdr) != 1) {
+	/* This needs a tag */
+	if (!compact)
+	  print_this_string(p, " . ", 3);
+	(void)print(cdr, escaped, compact, ht, p);
+	if (!compact)
+	  print_this_string(p, ")", 1);
+	return;
+      }
+    }
+    if (compact && !super_compact)
+      print_compact(p, CPT_PAIR);
+    if (!compact)
+      print_this_string(p, " ", 1);
+    no_space_ok = print(SCHEME_CAR(cdr), escaped, compact, ht, p);
+    cdr = SCHEME_CDR(cdr);
+  }
+
+  if (!SCHEME_NULLP(cdr)) {
+    if (!compact)
+      print_this_string(p, " . ", 3);
+    print(cdr, escaped, compact, ht, p);
+  } else if (compact && (super_compact < 1))
+    print_compact(p, CPT_NULL);
+
+  if (!compact)
+    print_this_string(p, ")", 1);
+}
+
+static void
+print_vector (Scheme_Object *vec, int escaped, int compact, 
+	      Scheme_Hash_Table *ht, Scheme_Process *p)
+{
+  int i, no_space_ok, size;
+  Scheme_Object **elems;
+
+  size = SCHEME_VEC_SIZE(vec);
+  elems = SCHEME_VEC_ELS(vec);
+
+  if (compact) {
+    print_compact(p, CPT_VECTOR);
+    print_compact_number(p, size);
+  } else
+    print_this_string(p, "#(", 2);
+
+  for (i = 0; i < size; i++) {
+    no_space_ok = print(elems[i], escaped, compact, ht, p);
+    if (i < (size - 1))
+      if (!compact)
+	print_this_string(p, " ", 1);
+  }
+
+  if (!compact)
+    print_this_string(p, ")", 1);
+}
+
+static void
+print_char (Scheme_Object *charobj, int escaped, Scheme_Process *p)
+{
+  char ch, minibuf[4], *str;
+  int len = -1;
+
+  ch = SCHEME_CHAR_VAL (charobj);
+  if (escaped) {
+    switch ( ch )
+      {
+      case '\0':
+	str = "#\\nul";
+	break;
+      case '\n':
+	str = "#\\newline";
+	break;
+      case '\t':
+	str = "#\\tab";
+	break;
+      case 0xb:
+	str = "#\\vtab";
+	break;
+      case ' ':
+	str = "#\\space";
+	break;
+      case '\r':
+	str = "#\\return";
+	break;
+      case '\f':
+	str = "#\\page";
+	break;
+      case '\b':
+	str = "#\\backspace";
+	break;
+      case 0x7f:
+	str = "#\\rubout";
+	break;
+      default:
+	minibuf[0] = '#';
+	minibuf[1] = '\\';
+	minibuf[2] = ch;
+	minibuf[3] = 0;
+	str = minibuf;
+	break;
+      }
+  } else {
+    minibuf[0] = ch;
+    minibuf[1] = 0;
+    str = minibuf;
+    len = 1;
+  }
+
+  print_this_string(p, str, len);
+}
diff --git a/src/mzscheme/src/process.c b/src/mzscheme/src/process.c
new file mode 100644
index 0000000..481ae99
--- /dev/null
+++ b/src/mzscheme/src/process.c
@@ -0,0 +1,3734 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Irix SPROCS needs to load some files first, so find out if we're SPROCS. */
+#ifdef INCLUDE_WITHOUT_PATHS
+# include "sconfig.h"
+#else
+# include "../sconfig.h"
+#endif
+
+#ifdef MZ_USE_IRIX_SPROCS
+/* Don't include anything else before this */
+# include "../gc/gc.h"
+# include "../gc/semaphores.h"
+# include "../gc/sproc.h"
+#endif
+
+#include "schpriv.h"
+#include <time.h>
+#ifdef FILES_HAVE_FDS
+# include <sys/types.h>
+# include <sys/time.h>
+# ifdef SELECT_INCLUDE
+#  include <sys/select.h>
+# endif
+#endif
+#ifdef USE_WINSOCK_TCP
+# include <winsock.h>
+#endif
+#ifdef USE_STACKAVAIL
+# include <malloc.h>
+#endif
+#ifdef UNISTD_INCLUDE
+# include <unistd.h>
+#endif
+#if defined(MZ_USE_WIN32_THREADS)
+# include <windows.h>
+# include <process.h>
+#endif
+#ifdef MZ_USE_SOLARIS_THREADS
+# include <thread.h>
+# include <synch.h>
+# include "../gc/gc.h"
+#endif
+#ifdef WIN32_THREADS
+# include <process.h>
+#endif
+
+#if defined(WINDOWS_PROCESSES) || defined(DETECT_WIN32_CONSOLE_STDIN)
+extern HANDLE scheme_break_semaphore;
+#endif
+
+#include "schfd.h"
+
+typedef struct ActiveWill {
+  Scheme_Object *o;
+  Scheme_Object *proc;
+  struct WillExecutor *w;  /* Set to will executor when executed */
+  struct ActiveWill *next;
+} ActiveWill;
+
+typedef struct WillExecutor {
+  Scheme_Type type;
+  short running;
+  ActiveWill *first, *last;
+} WillExecutor;
+
+typedef struct WillRegistration {
+  Scheme_Object *proc;
+  WillExecutor *w;
+} WillRegistration;
+
+#define INIT_TB_SIZE  20
+
+static int buffer_init_size = INIT_TB_SIZE;
+
+#ifndef MZ_REAL_THREADS
+Scheme_Process *scheme_current_process = NULL;
+#endif
+Scheme_Process *scheme_main_process = NULL;
+Scheme_Process *scheme_first_process = NULL;
+#ifdef LINK_EXTENSIONS_BY_TABLE
+Scheme_Process **scheme_current_process_ptr;
+int *scheme_fuel_counter_ptr;
+#endif
+
+static Scheme_Manager *main_manager;
+
+long scheme_total_gc_time;
+static long start_this_gc_time;
+
+#ifdef MANUAL_STACK_PUSH
+static Scheme_Process *leaving_process;
+#endif
+
+void (*scheme_sleep)(float seconds, void *fds);
+void (*scheme_notify_multithread)(int on);
+void (*scheme_wakeup_on_input)(void *fds);
+int (*scheme_check_for_break)(void);
+void *(*scheme_get_sema_callback_context)(void);
+
+#ifndef MZ_REAL_THREADS
+static int scheme_do_atomic = 0;
+static int have_activity = 0;
+int scheme_active_but_sleeping = 0;
+static int process_ended_with_activity;
+#endif
+
+static int tls_pos = 0;
+
+extern void (*GC_collect_start_callback)(void);
+extern void (*GC_collect_end_callback)(void);
+#ifndef MZ_REAL_THREADS
+extern void (*GC_push_other_roots)(void);
+#endif
+static void get_ready_for_GC(void);
+static void done_with_GC(void);
+
+static Scheme_Object *constants_symbol, *no_constants_symbol;
+static Scheme_Object *keywords_symbol, *no_keywords_symbol;
+static Scheme_Object *callcc_is_callec_symbol, *callcc_is_not_callec_symbol;
+static Scheme_Object *hash_percent_syntax_symbol, *all_syntax_symbol, *empty_symbol;
+
+static Scheme_Sema_Callback *sema_callbacks = NULL;
+static Scheme_Sema_From_Port *port_semas = NULL;
+
+static Scheme_Object *collect_garbage(int argc, Scheme_Object *args[]);
+
+#ifndef NO_SCHEME_THREADS
+static Scheme_Object *sch_thread(int argc, Scheme_Object *args[]);
+static Scheme_Object *sch_sleep(int argc, Scheme_Object *args[]);
+static Scheme_Object *process_weight(int argc, Scheme_Object *args[]);
+static Scheme_Object *processp(int argc, Scheme_Object *args[]);
+static Scheme_Object *process_running_p(int argc, Scheme_Object *args[]);
+static Scheme_Object *process_wait(int argc, Scheme_Object *args[]);
+static Scheme_Object *sch_current(int argc, Scheme_Object *args[]);
+static Scheme_Object *kill_thread(int argc, Scheme_Object *args[]);
+static Scheme_Object *break_thread(int argc, Scheme_Object *args[]);
+
+static Scheme_Object *make_manager(int argc, Scheme_Object *argv[]);
+static Scheme_Object *manager_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *manager_close_all(int argc, Scheme_Object *argv[]);
+static Scheme_Object *current_manager(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *config_p(int argc, Scheme_Object **argv);
+static Scheme_Object *parameter_p(int argc, Scheme_Object **argv);
+static Scheme_Object *make_parameter(int argc, Scheme_Object **argv);
+static Scheme_Object *parameter_procedure_eq(int argc, Scheme_Object **argv);
+static Scheme_Object *namespace_p(int argc, Scheme_Object **argv);
+
+static Scheme_Object *make_config(int argc, Scheme_Object *args[]);
+static Scheme_Object *make_config_with_sharing(int argc, Scheme_Object *args[]);
+static Scheme_Object *current_config(int argc, Scheme_Object *args[]);
+static Scheme_Object *in_config(int argc, Scheme_Object **argv);
+static Scheme_Object *current_namespace(int argc, Scheme_Object *args[]);
+static Scheme_Object *config_branch_handler(int argc, Scheme_Object *args[]);
+
+static Scheme_Object *make_new_config(Scheme_Config *base, Scheme_Object *defshare, Scheme_Object *clist, Scheme_Object *sharef);
+
+static void adjust_manager_family(void *pr, void *ignored);
+#endif
+
+static Scheme_Object *current_will_executor(int argc, Scheme_Object *args[]);
+static Scheme_Object *make_will_executor(int argc, Scheme_Object *args[]);
+static Scheme_Object *will_executor_p(int argc, Scheme_Object *args[]);
+static Scheme_Object *register_will(int argc, Scheme_Object *args[]);
+static Scheme_Object *will_executor_try(int argc, Scheme_Object *args[]);
+
+static Scheme_Object *do_next_will(WillExecutor *w, int tail);
+static Scheme_Config *make_initial_config(void);
+static int do_kill_thread(Scheme_Process *p);
+static int check_distinct_params(Scheme_Object *l);
+
+static Scheme_Config *initial_config;
+
+static Scheme_Object **config_map;
+
+typedef struct {
+  unsigned long key;
+  Scheme_Object *guard;
+  Scheme_Object *defval;
+} ParamData;
+
+typedef struct ParamExtensionRecData {
+  Scheme_Object *p;
+  unsigned long key;
+} ParamExtensionRecData;
+
+typedef struct ParamExtensionRec {
+  ParamExtensionRecData *data; /* atomic */
+  struct ParamExtensionRec *next;
+} ParamExtensionRec;
+
+static ParamExtensionRec *param_ext_recs;
+
+enum {
+  CONFIG_DIRECT,
+  CONFIG_INDIRECT
+};
+
+typedef struct {
+  Scheme_Object *key;
+  void (*f)(Scheme_Env *);
+} Scheme_NSO;
+static int num_nsos = 0;
+static Scheme_NSO *namespace_options = NULL;
+
+
+#ifndef PROCESS_STACK_SIZE
+#define PROCESS_STACK_SIZE 300000
+#endif
+
+#if defined(MZ_REAL_THREADS)
+# define SETJMP(p) 1
+# define LONGJMP(p) 0
+# define CLEARJMP(p)
+#else /* not USE_REAL_THREADS */
+# define SETJMP(p) scheme_setjmpup(&p->jmpup_buf, p->stack_start)
+# define LONGJMP(p) scheme_longjmpup(&p->jmpup_buf)
+# define CLEARJMP(p) scheme_init_jmpup_buf(&p->jmpup_buf)
+#endif
+
+#ifdef MZ_REAL_THREADS
+void *make_namespace_mutex;
+#endif
+
+#ifndef MZ_REAL_THREADS
+#define GET_WILL_LOCK() /* empty */
+#define RELEASE_WILL_LOCK() /* empty */
+
+#define GET_CUST_LOCK() /* empty */
+#define RELEASE_CUST_LOCK() /* empty */
+#else
+static void *will_mutex;
+#define GET_WILL_LOCK() SCHEME_LOCK_MUTEX(will_mutex)
+#define RELEASE_WILL_LOCK()  SCHEME_UNLOCK_MUTEX(will_mutex)
+
+static void *cust_mutex;
+#define GET_CUST_LOCK() SCHEME_LOCK_MUTEX(cust_mutex)
+#define RELEASE_CUST_LOCK()  SCHEME_UNLOCK_MUTEX(cust_mutex)
+#endif
+
+#ifndef MZ_REAL_THREADS
+static void push_other_stacks(void);
+#endif
+
+#ifdef WIN32_THREADS
+/* Only set up for Boehm GC that thinks it's a DLL: */
+# define GC_THINKS_ITS_A_DLL_BUT_ISNT
+
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+extern BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved);
+# endif
+#endif
+
+void scheme_init_process(Scheme_Env *env)
+{
+  scheme_add_global_constant("dump-memory-stats",
+			     scheme_make_prim_w_arity(scheme_dump_gc_stats,
+						      "dump-memory-stats",
+						      0, 1), 
+			     env);
+
+#if 0
+#ifdef MEMORY_COUNTING_ON
+  scheme_add_global_constant("dump-memory-count",
+			     scheme_make_prim_w_arity(scheme_dump_memory_count,
+						      "dump-memory-count",
+						      0, 1),
+			     env);
+#endif
+#endif
+
+#ifndef NO_SCHEME_THREADS
+  scheme_add_global_constant("make-namespace",
+			     scheme_make_prim_w_arity(scheme_make_namespace,
+						      "make-namespace",
+						      0, -1),
+			     env);
+  scheme_add_global_constant("make-parameterization",
+			     scheme_make_prim_w_arity(make_config,
+						      "make-parameterization",
+						      0, 1),
+			     env);
+  scheme_add_global_constant("make-parameterization-with-sharing",
+			     scheme_make_prim_w_arity(make_config_with_sharing,
+						      "make-parameterization-with-sharing",
+						      4, 4),
+			     env);
+  scheme_add_global_constant("thread",
+			     scheme_make_prim_w_arity(sch_thread,
+						      "thread",
+						      1, 1),
+			     env);
+  
+  scheme_add_global_constant("sleep",
+			     scheme_make_prim_w_arity(sch_sleep,
+						      "sleep",
+						      0, 1),
+			     env);
+
+  scheme_add_global_constant("in-parameterization",
+			     scheme_make_prim_w_arity(in_config,
+						      "in-parameterization",
+						      2, 2),
+			     env);
+
+  scheme_add_global_constant("thread-weight",
+			     scheme_make_prim_w_arity(process_weight,
+						      "thread-weight",
+						      1, 2),
+			     env);
+  scheme_add_global_constant("thread?",
+			     scheme_make_folding_prim(processp,
+						      "thread?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("thread-running?",
+			     scheme_make_prim_w_arity(process_running_p,
+						      "thread-running?",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("thread-wait",
+			     scheme_make_prim_w_arity(process_wait,
+						      "thread-wait",
+						      1, 1),
+			     env);
+  
+  scheme_add_global_constant("current-thread", 
+			     scheme_make_prim_w_arity(sch_current,
+						      "current-thread", 
+						      0, 0), 
+			     env);
+
+  scheme_add_global_constant("kill-thread", 
+			     scheme_make_prim_w_arity(kill_thread,
+						      "kill-thread", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("break-thread", 
+			     scheme_make_prim_w_arity(break_thread,
+						      "break-thread", 
+						      1, 1), 
+			     env);
+
+  scheme_add_global_constant("make-custodian",
+			     scheme_make_prim_w_arity(make_manager,
+						      "make-custodian",
+						      0, 1),
+			     env);
+  scheme_add_global_constant("custodian?",
+			     scheme_make_folding_prim(manager_p,
+						      "custodian?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("custodian-shutdown-all",
+			     scheme_make_prim_w_arity(manager_close_all,
+						      "custodian-shutdown-all",
+						      0, 1),
+			     env);
+  scheme_add_global_constant("current-custodian", 
+			     scheme_register_parameter(current_manager,
+						       "current-custodian",
+						       MZCONFIG_MANAGER),
+			     env);
+
+  scheme_add_global_constant("current-parameterization", 
+			     scheme_make_prim_w_arity(current_config,
+						      "current-parameterization", 
+						      0, 1), 
+			     env);
+
+  scheme_add_global_constant("current-namespace", 
+			     scheme_register_parameter(current_namespace,
+						       "current-namespace",
+						       MZCONFIG_ENV),
+			     env);
+
+  scheme_add_global_constant("parameterization-branch-handler", 
+			     scheme_register_parameter(config_branch_handler,
+						       "parameterization-branch-handler",
+						       MZCONFIG_CONFIG_BRANCH_HANDLER),
+			     env);
+
+  scheme_add_global_constant("namespace?", 
+			     scheme_make_prim_w_arity(namespace_p,
+						      "namespace?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("parameterization?", 
+			     scheme_make_prim_w_arity(config_p,
+						      "parameterization?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("parameter?", 
+			     scheme_make_prim_w_arity(parameter_p,
+						      "parameter?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("make-parameter", 
+			     scheme_make_prim_w_arity(make_parameter,
+						      "make-parameter", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("parameter-procedure=?", 
+			     scheme_make_prim_w_arity(parameter_procedure_eq,
+						      "parameter-procedure=?", 
+						      2, 2), 
+			     env);
+#endif
+
+  scheme_add_global_constant("make-will-executor", 
+			     scheme_make_prim_w_arity(make_will_executor,
+						      "make-will-executor", 
+						      0, 0), 
+			     env);
+  scheme_add_global_constant("will-executor?", 
+			     scheme_make_prim_w_arity(will_executor_p,
+						      "will-executor?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("register-will", 
+			     scheme_make_prim_w_arity(register_will,
+						      "register-will", 
+						      2, 3), 
+			     env);
+  scheme_add_global_constant("will-executor-try", 
+			     scheme_make_prim_w_arity(will_executor_try,
+						      "will-executor-try", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("current-will-executor", 
+			     scheme_register_parameter(current_will_executor,
+						       "current-will-executor",
+						       MZCONFIG_WILL_EXECUTOR),
+			     env);
+
+  scheme_add_global_constant("collect-garbage", 
+			     scheme_make_prim_w_arity(collect_garbage, 
+						      "collect-garbage",
+						      0, 0), 
+			     env);
+
+  if (scheme_starting_up) {
+    REGISTER_SO(config_map);
+    REGISTER_SO(namespace_options);
+    REGISTER_SO(sema_callbacks);
+    REGISTER_SO(port_semas);
+    REGISTER_SO(param_ext_recs);
+
+#ifndef NO_SCHEME_THREADS
+#ifdef MZ_REAL_THREADS
+    make_namespace_mutex = SCHEME_MAKE_MUTEX();
+    will_mutex = SCHEME_MAKE_MUTEX();
+#endif
+#endif
+
+    REGISTER_SO(constants_symbol);
+    REGISTER_SO(no_constants_symbol);
+    REGISTER_SO(keywords_symbol);
+    REGISTER_SO(no_keywords_symbol);
+    REGISTER_SO(callcc_is_callec_symbol);
+    REGISTER_SO(callcc_is_not_callec_symbol);
+    REGISTER_SO(hash_percent_syntax_symbol);
+    REGISTER_SO(all_syntax_symbol);
+    REGISTER_SO(empty_symbol);
+
+    constants_symbol = scheme_intern_symbol("constants");
+    no_constants_symbol = scheme_intern_symbol("no-constants");
+    keywords_symbol = scheme_intern_symbol("keywords");
+    no_keywords_symbol = scheme_intern_symbol("no-keywords");
+    callcc_is_callec_symbol = scheme_intern_symbol("call/cc=call/ec");
+    callcc_is_not_callec_symbol = scheme_intern_symbol("call/cc!=call/ec");
+    hash_percent_syntax_symbol = scheme_intern_symbol("hash-percent-syntax");
+    all_syntax_symbol = scheme_intern_symbol("all-syntax");
+    empty_symbol = scheme_intern_symbol("empty");
+
+    GC_collect_start_callback = get_ready_for_GC;
+    GC_collect_end_callback = done_with_GC;
+
+#ifndef MZ_REAL_THREADS
+    GC_push_other_roots = push_other_stacks;
+#endif
+  }
+}
+
+static Scheme_Object *collect_garbage(int c, Scheme_Object *p[])
+{
+  scheme_collect_garbage();
+
+  return scheme_void;
+}
+
+static Scheme_Process *make_process(Scheme_Config *config, Scheme_Manager *mgr)
+{
+  Scheme_Process *process;
+  int prefix = 0;
+
+#ifdef WIN32_THREADS
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+  DllMain(NULL, DLL_PROCESS_ATTACH, NULL);
+# endif
+#endif
+
+  process = MALLOC_ONE_TAGGED(Scheme_Process);
+
+  process->type = scheme_process_type;
+
+  process->stack_start = 0;
+
+  if (!scheme_main_process) {
+#ifndef MZ_REAL_THREADS
+    REGISTER_SO(scheme_current_process);
+#endif
+    REGISTER_SO(scheme_main_process);
+    REGISTER_SO(scheme_first_process);
+#ifdef MANUAL_STACK_PUSH
+    REGISTER_SO(leaving_process);
+#endif
+
+#ifdef MZ_REAL_THREADS
+    process->thread = SCHEME_INIT_THREADS();
+    SCHEME_SET_CURRENT_PROCESS(process);
+#else
+    scheme_current_process = process;
+#endif
+    scheme_first_process = scheme_main_process = process;
+    process->next = NULL;
+
+#ifndef MZ_REAL_THREADS
+#ifdef LINK_EXTENSIONS_BY_TABLE
+    scheme_current_process_ptr = &scheme_current_process;
+    scheme_fuel_counter_ptr = &scheme_fuel_counter;
+#endif
+#endif
+
+#ifdef MZ_REAL_THREADS
+    scheme_init_stack_check();
+#endif
+  } else {
+    prefix = 1;
+  }
+  
+  process->engine_weight = 10000;
+
+  if (!config) {
+    config = process->config = make_initial_config();
+
+    if (scheme_starting_up) {
+      REGISTER_SO(initial_config);
+      initial_config = process->config;
+    }
+  } else
+    process->config = config;
+
+  scheme_init_jmpup_buf(&process->jmpup_buf);
+
+  process->running = 1;
+#ifdef ERROR_ON_OVERFLOW
+  process->stack_overflow = 0;
+#endif
+
+  process->dw = NULL;
+
+  process->block_descriptor = NOT_BLOCKED;
+  process->block_check = NULL;
+  process->block_needs_wakeup = NULL;
+  process->sleep_time = 0;
+
+  process->current_local_env = NULL;
+
+  process->checking_break = 0;
+  process->external_break = 0;
+
+#ifdef MANUAL_STACK_PUSH
+  process->stack_current = 0L;
+#endif
+
+#ifdef USE_MAC_FILE_TOOLBOX
+  process->wd_inited = 0;
+#else
+  process->working_directory = NULL;
+#endif
+
+  process->print_buffer = NULL;
+  process->print_allocated = 0;
+
+#ifndef NO_SCHEME_EXN
+  process->exn_raised = 0;
+#endif
+  process->error_invoked = 0;
+  process->err_val_str_invoked = 0;
+
+  scheme_alloc_list_stack(process);
+
+  SCHEME_GET_LOCK();
+  if (prefix) {
+    process->next = scheme_first_process;
+    scheme_first_process = process;
+  }
+
+  process->tail_buffer = (Scheme_Object **)scheme_malloc(buffer_init_size 
+							 * sizeof(Scheme_Object *));
+  process->tail_buffer_size = buffer_init_size;
+#ifdef AGRESSIVE_ZERO_TB
+  process->tail_buffer_set = 0;
+#endif
+  SCHEME_RELEASE_LOCK();
+
+  process->runstack_size = SCHEME_STACK_SIZE;
+  process->runstack_start = MALLOC_N(Scheme_Object*, SCHEME_STACK_SIZE);
+  process->runstack = process->runstack_start + SCHEME_STACK_SIZE;
+  process->runstack_saved = NULL;
+
+#ifdef MZ_REAL_THREADS
+  process->done_sema = scheme_make_sema(0);
+#endif
+
+  process->on_kill = NULL;
+
+  process->user_tls = NULL;
+  process->user_tls_size = 0;
+
+  process->mref = scheme_add_managed(mgr
+				     ? mgr
+				     : (Scheme_Manager *)scheme_get_param(scheme_config, MZCONFIG_MANAGER),
+				     (Scheme_Object *)process, NULL, NULL, 0);
+
+  return process;
+}
+
+static void ensure_manage_space(Scheme_Manager *m, int k)
+{
+  int i;
+
+  if (m->count + k >= m->alloc) {
+    Scheme_Object ***naya_boxes;
+    Scheme_Manager_Reference **naya_mrefs;
+    Scheme_Close_Manager_Client **naya_closers;
+    void **naya_data;
+
+    m->alloc = (m->alloc ? (2 * m->alloc) : 4);
+    if (m->alloc < k)
+      m->alloc += k;
+    
+    naya_boxes = MALLOC_N(Scheme_Object**, m->alloc);
+    naya_closers = MALLOC_N(Scheme_Close_Manager_Client*, m->alloc);
+    naya_data = MALLOC_N(void*, m->alloc);
+    naya_mrefs = MALLOC_N(Scheme_Manager_Reference*, m->alloc);
+
+    for (i = m->count; i--; ) {
+      naya_boxes[i] = m->boxes[i];
+      m->boxes[i] = NULL;
+      naya_closers[i] = m->closers[i];
+      m->closers[i] = NULL;
+      naya_data[i] = m->data[i];
+      m->data[i] = NULL;
+      naya_mrefs[i] = m->mrefs[i];
+      m->mrefs[i] = NULL;
+    }
+
+    m->boxes = naya_boxes;
+    m->closers = naya_closers;
+    m->data = naya_data;
+    m->mrefs = naya_mrefs;
+  }
+}
+
+static void add_managed_box(Scheme_Manager *m, 
+			    Scheme_Object **box, Scheme_Manager_Reference *mref,
+			    Scheme_Close_Manager_Client *f, void *data)
+{
+  int i;
+
+  for (i = m->count; i--; ) {
+    if (!m->boxes[i]) {
+      m->boxes[i] = box;
+      m->closers[i] = f;
+      m->data[i] = data;
+      m->mrefs[i] = mref;
+
+      return;
+    }
+  }
+
+  ensure_manage_space(m, 1);
+
+  m->boxes[m->count] = box;
+  m->closers[m->count] = f;
+  m->data[m->count] = data;
+  m->mrefs[m->count] = mref;
+
+  m->count++;
+}
+
+static void remove_managed(Scheme_Manager_Reference *mr, Scheme_Object *o,
+			   Scheme_Close_Manager_Client **old_f, void **old_data)
+{
+  Scheme_Manager *m;
+  int i;
+
+  GET_CUST_LOCK();
+
+  m = *mr;
+  if (!m) {
+    RELEASE_CUST_LOCK();
+    return;
+  }
+
+  for (i = m->count; i--; )
+    if (m->boxes[i] && SAME_OBJ((*(m->boxes[i])),  o)) {
+      *(m->boxes[i]) = 0;
+      m->boxes[i] = NULL;
+      *(m->mrefs[i]) = 0;
+      m->mrefs[i] = NULL;
+      if (old_f)
+	*old_f = m->closers[i];
+      if (old_data)
+	*old_data = m->data[i];
+      m->data[i] = NULL;
+      break;
+    }
+
+  while (m->count && !m->boxes[m->count - 1])
+    --m->count;
+
+  RELEASE_CUST_LOCK();
+}
+
+static void adjust_manager_family(void *mgr, void *ignored)
+{
+  /* Threads note: because this function is only called as a
+     finalization callback, it is automatically syncronized by the GC
+     locks. And it is synchronized against all finalizations, so a
+     managee can't try to unregister while we're shuffling its
+     manager. */
+  Scheme_Manager *r = (Scheme_Manager *)mgr, *parent, *m;
+  int i;
+
+  parent = *r->parent;
+
+  GET_CUST_LOCK();
+
+  if (parent) {
+    /* Remove from parent's list of children: */
+    if (*parent->children == r) {
+      *parent->children = *(r->sibling);
+    } else {
+      m = *parent->children;
+      while (m && *m->sibling != r)
+	m = *m->sibling;
+      if (m)
+	*m->sibling = *r->sibling;
+    }
+
+    /* Add children to parent's list: */
+    for (m = *r->children; m; ) {
+      Scheme_Manager *next = *m->sibling;
+      
+      *m->parent = parent;
+      *m->sibling = *parent->children;
+      *parent->children = m;
+
+      m = next;
+    }
+
+    /* Add remaining managed items to parent: */
+    for (i = 0; i < r->count; i++) {
+      if (r->boxes[i]) {
+	*(r->mrefs[i]) = parent;
+	add_managed_box(parent, r->boxes[i], r->mrefs[i], r->closers[i], r->data[i]);
+      }
+    }
+  }
+
+  *r->parent = NULL;
+  *r->sibling = NULL;
+  *r->children = NULL;
+
+  RELEASE_CUST_LOCK();
+}
+
+Scheme_Manager *scheme_make_manager(Scheme_Manager *parent) 
+{
+  Scheme_Manager *m;
+
+  m = MALLOC_ONE_TAGGED(Scheme_Manager);
+
+  m->type = scheme_manager_type;
+
+  m->alloc = m->count = 0;
+
+  m->parent = MALLOC_ONE_ATOMIC(Scheme_Manager*);
+  m->children = MALLOC_ONE_ATOMIC(Scheme_Manager*);
+  m->sibling = MALLOC_ONE_ATOMIC(Scheme_Manager*);
+
+  *(m->children) = NULL;
+  *(m->sibling) = NULL;
+
+  *(m->parent) = parent;
+  if (parent) {
+    *m->sibling = *parent->children;
+    *parent->children = m;
+  } else
+    *(m->sibling) = NULL;
+
+  scheme_add_finalizer(m, adjust_manager_family, NULL);
+
+  return m;
+}
+
+static void rebox_willdone_object(void *o, void *mr)
+{
+  Scheme_Manager *m = *(Scheme_Manager **)mr;
+  Scheme_Close_Manager_Client *f;
+  void *data;
+
+  /* Still needs management? */
+  if (m) {
+    Scheme_Object **b;
+
+    remove_managed(mr, o, &f, &data);
+
+    b = MALLOC_ONE(Scheme_Object*); /* not atomic this time */
+    *b = o;
+    
+    /* Put the manager back: */
+    *(Scheme_Manager **)mr = m;
+
+    add_managed_box(m, b, mr, f, data);
+  }
+}
+
+static void managed_object_gone(void *o, void *mr)
+{
+  Scheme_Manager *m = *(Scheme_Manager **)mr;
+
+  /* Still has management? */
+  if (m)
+    remove_managed(mr, o, NULL, NULL);
+}
+
+
+Scheme_Manager_Reference *scheme_add_managed(Scheme_Manager *m, Scheme_Object *o, 
+					     Scheme_Close_Manager_Client *f, void *data, int must_close)
+{
+  Scheme_Object **b;
+  Scheme_Manager_Reference *mr;
+
+  b = MALLOC_ONE_ATOMIC(Scheme_Object*);
+  *b = o;
+
+  mr = MALLOC_ONE_ATOMIC(Scheme_Manager_Reference);
+
+  if (!m)
+    m = (Scheme_Manager *)scheme_get_param(scheme_config, MZCONFIG_MANAGER);
+
+  *mr = m;
+
+  /* The atomic link via the box `b' allows the execution of wills for
+     o. After this, we should either drop the object or we have to
+     hold on to the object strongly (for when manager-close-all is
+     called). */
+  if (must_close)
+    scheme_add_finalizer(o, rebox_willdone_object, mr);
+  else
+    scheme_add_finalizer(o, managed_object_gone, mr);
+
+#ifdef MZ_REAL_THREADS
+  /* GCing while we have the lock would be bad: */
+  ensure_manage_space(m, 1);
+
+  if (!cust_mutex)
+    cust_mutex = SCHEME_MAKE_MUTEX();
+#endif
+
+  GET_CUST_LOCK();
+  add_managed_box(m, b, mr, f, data);
+  RELEASE_CUST_LOCK();
+
+  return mr;
+}
+
+void scheme_remove_managed(Scheme_Manager_Reference *mr, Scheme_Object *o)
+{
+  remove_managed(mr, o, NULL, NULL);
+}
+
+static Scheme_Process *do_close_managed(Scheme_Manager *m)
+{
+  Scheme_Process *kill_self = NULL, *ks;
+  Scheme_Manager *c, *next;
+
+  /* Kill children first: */
+  for (c = *(m->children); c; c = next) {
+    next = *(c->sibling);
+    ks = do_close_managed(c);
+    if (ks)
+      kill_self = ks;
+  }
+
+  while (m->count) {
+    int i = m->count - 1;
+    if (m->boxes[i]) {
+      Scheme_Object *o;
+      Scheme_Close_Manager_Client *f;
+      void *data;
+
+      o = *(m->boxes[i]);
+
+      f = m->closers[i];
+      data = m->data[i];
+      *(m->boxes[i]) = NULL;
+      m->boxes[i] = NULL;
+      *(m->mrefs[i]) = NULL;
+      m->mrefs[i] = NULL;
+      m->data[i] = NULL;
+      --m->count;
+
+      if (SCHEME_PROCESSP(o)) {
+	Scheme_Process *p = (Scheme_Process *)o;
+
+	if (do_kill_thread(p))
+	  kill_self = p;
+      } else {
+	f(o, data);
+      }
+    } else {
+      --m->count;
+    }
+  }
+
+  return kill_self;
+}
+
+void scheme_close_managed(Scheme_Manager *m)
+/* The trick is that we may need to kill the thread
+   that is running us. If so, delay it to the very
+   end. */
+{
+  Scheme_Process *p;
+
+  if ((p = do_close_managed(m))) {
+    /* Kill self */
+    scheme_kill_thread(p);
+  }
+}
+
+void scheme_set_tail_buffer_size(int s)
+{
+  SCHEME_GET_LOCK();
+  if (s > buffer_init_size) {
+    Scheme_Process *p;
+
+    buffer_init_size = s;
+
+    for (p = scheme_first_process; p; p = p->next)
+      if (p->tail_buffer_size < s) {
+	p->tail_buffer = (Scheme_Object **)scheme_malloc(buffer_init_size 
+							 * sizeof(Scheme_Object *));
+	p->tail_buffer_size = buffer_init_size;
+      }
+  }
+  SCHEME_RELEASE_LOCK();  
+}
+
+Scheme_Process *scheme_make_process()
+{
+  return make_process(NULL, NULL);
+}
+
+int scheme_in_main_thread(void)
+{
+  return !scheme_current_process->next;
+}
+
+#ifdef MZ_REAL_THREADS
+Scheme_Process *scheme_get_current_process()
+{
+  return scheme_current_process;
+}
+#endif
+
+#ifndef NO_SCHEME_THREADS
+
+#ifndef MZ_REAL_THREADS
+
+void scheme_swap_process(Scheme_Process *new_process)
+{
+#ifdef MANUAL_STACK_PUSH
+  int dummy;
+
+  scheme_current_process->stack_current = (void *)&dummy;
+#endif
+
+#ifdef DIR_FUNCTION
+  scheme_set_process_directory(new_process, scheme_current_process);
+#endif
+
+  scheme_zero_unneeded_rands(scheme_current_process);
+
+  if (SETJMP(scheme_current_process)) {
+    CLEARJMP(scheme_current_process);
+    /* We're back! */
+#ifdef MANUAL_STACK_PUSH
+    if (leaving_process) {
+      leaving_process = NULL;
+    }
+#endif
+  } else {
+    /* We're leaving... */
+    scheme_current_process = new_process;
+    LONGJMP(scheme_current_process);
+  }
+}
+
+#endif
+
+static void remove_process(Scheme_Process *r)
+{
+  Scheme_Process *p;
+  Scheme_Saved_Stack *saved;
+
+  r->running = 0;
+
+#ifdef MZ_REAL_THREADS
+  scheme_post_sema(r->done_sema);
+#endif
+
+  if (r == scheme_first_process) {
+    scheme_first_process = r->next;
+  } else {
+    p = scheme_first_process;
+    while (p && p->next != r)
+      p = p->next;
+    if (p)
+      p->next = r->next;
+  }
+
+  memset(r->runstack_start, 0, r->runstack_size * sizeof(Scheme_Object*));
+  r->runstack_start = NULL;
+  for (saved = r->runstack_saved; saved; saved = saved->prev) {
+    memset(saved->runstack_start, 0, saved->runstack_size * sizeof(Scheme_Object*));
+    saved->runstack_start = NULL;
+  }
+
+  scheme_remove_managed(r->mref, (Scheme_Object *)r);
+
+  scheme_done_process_directory(r);
+}
+
+static void start_child(Scheme_Process *child,
+			Scheme_Process *return_to_process,
+			Scheme_Object *child_eval)
+{
+  if (SETJMP(child)) {
+#ifndef MZ_REAL_THREADS
+    if (return_to_process)
+      scheme_swap_process(return_to_process);
+#endif    
+
+    if (!scheme_setjmp(scheme_error_buf))
+      scheme_apply_multi(child_eval, 0, NULL);
+    
+    SCHEME_GET_LOCK();
+    
+#ifdef MANUAL_STACK_PUSH
+    leaving_process = scheme_current_process;
+#endif
+
+    remove_process(scheme_current_process);
+    SCHEME_RELEASE_LOCK();
+    
+#ifndef MZ_REAL_THREADS
+    process_ended_with_activity = 1;
+    
+    if (scheme_notify_multithread && !scheme_first_process->next
+	&& !sema_callbacks && !port_semas) {
+      scheme_notify_multithread(0);
+      have_activity = 0;
+    }
+#endif
+    
+#ifndef MZ_REAL_THREADS
+    if (scheme_current_process->next)
+      scheme_swap_process(scheme_current_process->next);
+    else
+      scheme_swap_process(scheme_first_process);
+    
+    /* Shouldn't get here! */
+    scheme_signal_error("bad process switch");
+#endif
+  }
+}
+
+#if defined(MZ_REAL_THREADS)
+
+typedef struct {
+  Scheme_Process *sc_child, *sc_rtp;
+  Scheme_Object *sc_eval;
+} ThreadStartData;
+
+static void really_start_child(void *data)
+{
+  long dummy;
+  ThreadStartData *th = (ThreadStartData *)data;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_SET_CURRENT_PROCESS(th->sc_child);
+  th->sc_child->stack_start = (void *)&dummy;
+#endif
+
+  start_child(th->sc_child, th->sc_rtp, th->sc_eval);
+}
+
+#endif /* defined(MZ_REAL_THREADS) */
+
+#if defined(MZ_REAL_THREADS)
+
+static void do_start_child(Scheme_Process *child, Scheme_Process *rtp,
+			   Scheme_Object *child_eval)
+{
+  Scheme_Process *sc_child, *sc_rtp;
+  Scheme_Object *sc_eval;
+
+  sc_child = child;
+  sc_rtp = rtp;
+  sc_eval = child_eval;
+
+  start_child(sc_child, sc_rtp, sc_eval);
+  {
+    ThreadStartData *th = scheme_malloc(sizeof(ThreadStartData));
+    
+    th->sc_child = sc_child;
+    th->sc_rtp = sc_rtp;
+    th->sc_eval = sc_eval;
+
+    SCHEME_CREATE_THREAD(really_start_child, (void *)th, 
+			 (unsigned long *)&sc_child->stack_end,
+			 &sc_child->thread);
+  }
+}
+
+#endif
+
+static Scheme_Object *make_subprocess(Scheme_Object *child_thunk,
+				      void *child_start, 
+				      Scheme_Config *config,
+				      Scheme_Manager *mgr)
+{
+  Scheme_Process *child, *return_to_process;
+  int turn_on_multi;
+ 
+  turn_on_multi = !scheme_first_process->next && !sema_callbacks
+    && !port_semas;
+  
+  scheme_ensure_stack_start(scheme_current_process, child_start);
+  
+  child = make_process(config, mgr);
+
+  child->stack_start = child_start;
+
+  scheme_init_error_escape_proc(child);
+  
+#ifndef MZ_REAL_THREADS
+  if (scheme_do_atomic)
+    return_to_process = scheme_current_process;
+  else
+#endif
+    return_to_process = NULL;
+
+#if defined(MZ_REAL_THREADS)
+  do_start_child(child, return_to_process, child_thunk);
+#else
+  start_child(child, return_to_process, child_thunk);
+#endif
+
+#ifndef MZ_REAL_THREADS
+  if (scheme_notify_multithread && turn_on_multi) {
+    scheme_notify_multithread(1);
+    have_activity = 1;
+  }
+
+  scheme_swap_process(child);
+  
+  /* Because that swap just reset our fuel, we'd better check for a break */
+  scheme_process_block((float)-1);
+#endif
+  
+  return (Scheme_Object *)child;
+}
+
+Scheme_Object *scheme_thread(Scheme_Object *thunk, Scheme_Config *config)
+{
+  long dummy;
+
+  return make_subprocess(thunk, (void *)&dummy, config, NULL);
+}
+
+Scheme_Object *scheme_thread_w_manager(Scheme_Object *thunk, Scheme_Config *config, Scheme_Manager *mgr)
+{
+  long dummy;
+
+  return make_subprocess(thunk, (void *)&dummy, config, mgr);
+}
+
+void scheme_break_thread(Scheme_Process *p)
+{
+  if (!p)
+    p = scheme_current_process;
+
+  p->external_break = 1;
+
+#ifndef MZ_REAL_THREADS
+  if (p == scheme_current_process)
+    scheme_fuel_counter = 0;
+# if defined(WINDOWS_PROCESSES) || defined(DETECT_WIN32_CONSOLE_STDIN)
+  if (!p->next)
+    ReleaseSemaphore(scheme_break_semaphore, 1, NULL);
+# endif
+#else
+  p->fuel_counter = 0;
+  SCHEME_BREAK_THREAD(p->thread);
+#endif
+}
+
+void scheme_add_namespace_option(Scheme_Object *key, void (*f)(Scheme_Env *))
+{
+  Scheme_NSO *old = namespace_options;
+  
+  namespace_options = (Scheme_NSO *)scheme_malloc((num_nsos + 1) 
+						  * sizeof(Scheme_NSO));
+
+  memcpy(namespace_options, old, num_nsos * sizeof(Scheme_NSO));
+
+  namespace_options[num_nsos].key = key;
+  namespace_options[num_nsos].f = f;
+  
+  num_nsos++;
+}
+
+Scheme_Object *scheme_make_namespace(int argc, Scheme_Object *argv[])
+{
+  int save_const;
+  int save_no_key, save_ec_only, save_hp_syntax;
+  int i, with_nso = 0;
+  int empty = 0;
+  Scheme_Object *v;
+  Scheme_Env *env;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(make_namespace_mutex);
+#endif
+
+  save_const = scheme_constant_builtins;
+  save_no_key = scheme_no_keywords;
+  save_ec_only = scheme_escape_continuations_only;
+  save_hp_syntax = scheme_hash_percent_syntax_only;
+
+  for (i = 0; i < argc; i++) {
+    v = argv[i];
+    if (v == constants_symbol)
+      scheme_constant_builtins = 1;
+    else if (v == no_constants_symbol)
+      scheme_constant_builtins = 0;
+    else if (v == keywords_symbol)
+      scheme_no_keywords = 0;
+    else if (v == no_keywords_symbol)
+      scheme_no_keywords = 1;
+    else if (v == callcc_is_callec_symbol)
+      scheme_escape_continuations_only = 1;
+    else if (v == callcc_is_not_callec_symbol)
+      scheme_escape_continuations_only = 0;
+    else if (v == hash_percent_syntax_symbol)
+      scheme_hash_percent_syntax_only = 1;
+    else if (v == all_syntax_symbol)
+      scheme_hash_percent_syntax_only = 0;
+    else if (v == empty_symbol)
+      empty = 1;
+    else {
+      int j;
+      for (j = 0; j < num_nsos; j++)
+	if (namespace_options[j].key == v) {
+	  with_nso = 1;
+	  break;
+	}
+      
+      if (j >= num_nsos)
+	scheme_wrong_type("make-namespace", "symbol-flag", i, argc, argv);
+    }
+  }
+  
+#ifndef MZ_REAL_THREADS
+  scheme_do_atomic++;
+#endif
+  env = (empty ? scheme_make_empty_env() : scheme_top_level_env());
+#ifndef MZ_REAL_THREADS
+  --scheme_do_atomic;
+#endif
+
+  scheme_constant_builtins = save_const;    
+  scheme_no_keywords = save_no_key;   
+  scheme_escape_continuations_only = save_ec_only;
+  scheme_hash_percent_syntax_only = save_hp_syntax;
+
+  if (with_nso && !empty) {
+    int j;
+
+    for (i = 0; i < argc; i++) {
+      v = argv[i];
+      for (j = 0; j < num_nsos; j++)
+	if (namespace_options[j].key == v) {
+	  namespace_options[j].f(env);
+	  break;
+	}
+    }
+  }
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(make_namespace_mutex);
+#endif
+
+  return (Scheme_Object *)env;
+}
+
+#endif
+/* NO_SCHEME_THREADS */
+
+void scheme_add_sema_callback(Scheme_Sema_Callback *cb)
+{
+  cb->next = NULL;
+  cb->context = (scheme_get_sema_callback_context
+		 ? scheme_get_sema_callback_context()
+		 : NULL);
+  cb->ready = 0;
+
+  SCHEME_GET_LOCK();
+  if (!sema_callbacks)
+    sema_callbacks = cb;
+  else {
+    Scheme_Sema_Callback *c;
+
+    for (c = sema_callbacks; c->next; c = c->next);
+    c->next = cb;
+  }
+  SCHEME_RELEASE_LOCK();
+#ifndef MZ_REAL_THREADS
+  if (!scheme_first_process->next && !port_semas
+      && scheme_notify_multithread) {
+    scheme_notify_multithread(1);
+    have_activity = 1;
+  }
+#endif
+}
+
+void scheme_add_sema_from_port(Scheme_Sema_From_Port *pt)
+{
+  SCHEME_GET_LOCK();
+  pt->next = port_semas;
+  port_semas = pt;
+  SCHEME_RELEASE_LOCK();
+#ifndef MZ_REAL_THREADS
+  if (!scheme_first_process->next && !sema_callbacks 
+      && scheme_notify_multithread ) {
+    scheme_notify_multithread(1);
+    have_activity = 1;
+  }
+#endif
+}
+
+int scheme_count_sema_callbacks(int kind)
+{
+  int count = 0;
+
+  if (kind) {
+    Scheme_Sema_From_Port *pt;
+    for (pt = port_semas; pt; pt = pt->next)
+      count++;
+  } else {
+    Scheme_Sema_Callback *c;
+    for (c = sema_callbacks; c; c = c->next)
+      count++;
+  }
+
+  return count;
+}
+
+static void port_sema_check(void) 
+{  
+  Scheme_Sema_From_Port *pt, *pprev;
+  
+  SCHEME_GET_LOCK();
+  pt = port_semas;
+  pprev = NULL;
+  while (pt) {
+    if (scheme_char_ready(pt->port)) {
+      if (pprev)
+	pprev->next = pt->next;
+      else {
+	port_semas = pt->next;
+#ifndef MZ_REAL_THREADS
+	if (!port_semas
+	    && !scheme_first_process->next
+	    && !sema_callbacks
+	    && scheme_notify_multithread) {
+	  scheme_notify_multithread(0);
+	  have_activity = 0;
+	}
+#endif
+      }
+      
+#ifndef MZ_REAL_THREADS
+      pt->sema->value++;
+#else
+      SCHEME_SEMA_UP(pt->sema->sema);
+#endif
+    } else
+      pprev = pt;
+    pt = pt->next;
+  }
+  SCHEME_RELEASE_LOCK();
+}
+
+#ifndef MZ_REAL_THREADS
+static int check_sleep(int need_activity, int sleep_now)
+{
+  Scheme_Process *p, *p2;
+  Scheme_Sema_From_Port *pt;
+  int end_with_act;
+  
+#if defined(FILES_HAVE_FDS) || defined(USE_WINSOCK_TCP)
+  DECL_FDSET(set, 3);
+  fd_set *set1, *set2;
+#endif
+  void *fds;
+
+  /* Is everything blocked? */
+  if (!scheme_do_atomic) {
+    p = scheme_first_process;
+    while (p) {
+      if (p->ran_some || p->block_descriptor == NOT_BLOCKED)
+	break;
+      p = p->next;
+    }
+  } else
+    p = NULL;
+  
+  p2 = scheme_first_process;
+  while (p2) {
+    p2->ran_some = 0;
+    p2 = p2->next;
+  }
+  
+  end_with_act = process_ended_with_activity;
+  process_ended_with_activity = 0;
+  
+  if (need_activity && !end_with_act && 
+      (scheme_do_atomic 
+       || (!p && ((!sleep_now && scheme_wakeup_on_input)
+		  || (sleep_now && scheme_sleep))))) {
+    float max_sleep_time = 0;
+
+    /* Poll from top-level process, and all subprocesses are blocked. */
+    /* So, everything is blocked pending external input. */
+    /* Build a list of file descriptors that we're waiting on */
+    /* and turn off polling. */
+    if (have_activity)
+      scheme_active_but_sleeping = 1;
+    if (have_activity && scheme_notify_multithread)
+      scheme_notify_multithread(0);
+    
+#if defined(FILES_HAVE_FDS) || defined(USE_WINSOCK_TCP)
+    INIT_DECL_FDSET(set, 3);
+    set1 = (fd_set *) MZ_GET_FDSET(set, 1);
+    set2 = (fd_set *) MZ_GET_FDSET(set, 2);
+
+    fds = (void *)set;
+    MZ_FD_ZERO(set);
+    MZ_FD_ZERO(set1);
+    MZ_FD_ZERO(set2);
+#else
+    fds = NULL;
+#endif
+    
+    p = scheme_first_process;
+    while (p) {
+      int merge_time = 0;
+
+      if (p->block_descriptor == -1) {
+	if (p->block_needs_wakeup)
+	  (p->block_needs_wakeup)(p->blocker, fds);
+	merge_time = (p->sleep_time > 0.0);
+      } else if (p->block_descriptor == PORT_BLOCKED)
+	scheme_need_wakeup(p->blocker, fds);
+      else if (p->block_descriptor == SLEEP_BLOCKED) {
+	merge_time = 1;
+      }
+
+      if (merge_time) {
+	long d = (long)p->block_start_sleep;
+	float t;
+
+	d = (scheme_get_milliseconds() - d);
+
+	if (d < 0)
+	  d = -d;
+	
+	t = p->sleep_time - (((float)d) / 1000);
+	if (t <= 0)
+	  t = 0.00001;
+	if (!max_sleep_time || (t < max_sleep_time))
+	  max_sleep_time = t;
+      } 
+      p = p->next;
+    }
+    
+    pt = port_semas;
+    while (pt) {
+      scheme_need_wakeup(pt->port, fds);
+      pt = pt->next;
+    }
+    
+    if (sleep_now)
+      scheme_sleep(max_sleep_time, fds);
+    else
+      scheme_wakeup_on_input(fds);
+    
+    return 1;
+  }
+  
+  return 0;
+}
+#endif
+
+void *scheme_check_sema_callbacks(int (*test)(void *, void *), void *cdata, int check_only)
+{
+  Scheme_Sema_Callback *cb, *prev;
+  jmp_buf savebuf;
+  
+  port_sema_check();
+
+  cb = sema_callbacks;
+  while (cb) {
+    int passed;
+#ifdef MZ_REAL_THREADS
+    passed = SCHEME_SEMA_TRY_DOWN(cb->sema->sema);
+#else
+    if (!test || test(cdata, cb->context)) {
+      if (cb->ready)
+	passed = 1;
+      else if (cb->sema->value) {
+	passed = 1;
+	cb->sema->value--;
+	cb->ready = 1;
+      } else
+	passed = 0;
+    } else
+      passed = 0;
+#endif
+    if (passed) {
+      if (check_only)
+	return cb->context;
+      SCHEME_GET_LOCK();
+      /* Remove this callback record from the list: */
+      if (NOT_SAME_PTR(cb, sema_callbacks)) {
+	prev = sema_callbacks;
+	while (prev) {
+	  if (SAME_PTR(prev->next, cb)) {
+	    prev->next = cb->next;
+	    break;
+	  } else
+	    prev = prev->next;
+	}
+      } else {
+	sema_callbacks = cb->next;
+	
+#ifndef MZ_REAL_THREADS
+	if (!sema_callbacks 
+	    && !scheme_first_process->next
+	    && !port_semas
+	    && scheme_notify_multithread) {
+	  scheme_notify_multithread(0);
+	  have_activity = 0;
+	}
+#endif
+      }
+      SCHEME_RELEASE_LOCK();
+
+      memcpy(&savebuf, &scheme_error_buf, sizeof(jmp_buf));
+      if (!scheme_setjmp(scheme_error_buf))
+	scheme_apply_multi(cb->callback, 0, NULL);
+      memcpy(&scheme_error_buf, &savebuf, sizeof(jmp_buf));
+
+      return cb->context;
+    }
+    cb = cb->next;
+  }
+
+  return NULL;
+}
+
+void scheme_remove_sema_callbacks(int (*test)(void *, void *), void *cdata)
+{
+  Scheme_Sema_Callback *cb, *prev;
+
+  prev = NULL;
+  for (cb = sema_callbacks; cb; cb = cb->next) {
+    if (test(cdata, cb->context)) {
+      if (prev)
+	prev->next = cb->next;
+      else
+	sema_callbacks = cb->next;
+    } else
+      prev = cb;
+  }
+}
+
+void scheme_check_threads(void)
+{
+  scheme_check_sema_callbacks(NULL, NULL, 0);
+
+#ifndef MZ_REAL_THREADS
+  scheme_current_process->checking_break = 1;
+  scheme_process_block((float)0);
+  scheme_current_process->checking_break = 0;
+
+  check_sleep(have_activity, 0);
+#endif
+}
+
+void scheme_wake_up(void)
+{
+#ifndef MZ_REAL_THREADS
+  scheme_active_but_sleeping = 0;
+  if (have_activity && scheme_notify_multithread)
+    scheme_notify_multithread(1);
+#endif
+}
+
+void scheme_out_of_fuel(void)
+{
+#ifndef MZ_REAL_THREADS
+  scheme_process_block((float)0);
+  scheme_current_process->ran_some = 1;
+#endif
+}
+
+void scheme_zero_unneeded_rands(Scheme_Process *p)
+{
+  /* Call this procedure before GC or before copying out
+     a thread's stack. */
+}
+
+static void get_ready_for_GC()
+{
+  start_this_gc_time = scheme_get_process_milliseconds();
+
+  scheme_zero_unneeded_rands(scheme_current_process);
+
+#ifndef MZ_REAL_THREADS
+  if (scheme_fuel_counter) {
+    Scheme_Process *p;
+
+    /* zero ununsed part of env stack in each thread */
+    for (p = scheme_first_process; p; p = p->next) {
+      Scheme_Object **o, **e, **e2;
+      Scheme_Saved_Stack *saved;
+
+      o = p->runstack_start;
+      e = p->runstack;
+      e2 = p->runstack_tmp_keep;
+
+      while (o < e && (o != e2))
+	*(o++) = NULL;
+
+      for (saved = p->runstack_saved; saved; saved = saved->prev) {
+	o = saved->runstack_start;
+	e = saved->runstack_start;
+	while (o < e)
+	  *(o++) = NULL;
+      }
+
+# ifdef AGRESSIVE_ZERO_TB
+      {
+	int i;
+	for (i = p->tail_buffer_set; i < p->tail_buffer_size; i++)
+	  p->tail_buffer[i] = NULL;
+      }
+# endif
+    }
+  }
+#endif
+   
+  scheme_fuel_counter = 0;
+}
+
+static void done_with_GC()
+{
+  scheme_total_gc_time += (scheme_get_process_milliseconds() - start_this_gc_time);
+}
+
+int scheme_can_break(Scheme_Process *p, Scheme_Config *config)
+{
+  return (SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_ENABLE_BREAK))
+	  && (!p->exn_raised 
+	      || SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_ENABLE_EXCEPTION_BREAK))));
+}
+
+int scheme_block_until(int (*f)(Scheme_Object *), void (*fdf)(Scheme_Object *,void*), 
+		       void *data, float delay)
+{
+  int result;
+  Scheme_Process *p = scheme_current_process;
+
+  p->block_descriptor = -1;
+  p->blocker = (Scheme_Object *)data;
+  p->block_check = f;
+  p->block_needs_wakeup = fdf;
+  do
+    scheme_process_block(delay);
+  while (!(result = f((Scheme_Object *)data)));
+  p->block_descriptor = NOT_BLOCKED;
+  p->blocker = NULL;
+  p->block_check = NULL;
+  p->block_needs_wakeup = NULL;
+  p->ran_some = 1;
+
+  return result;
+}
+
+static void make_unblocked(Scheme_Process *p)
+{
+  p->block_descriptor = 0;
+  p->blocker = NULL;
+  p->block_check = NULL;
+  p->block_needs_wakeup = NULL;
+  p->ran_some = 1;
+}
+
+#ifndef MZ_REAL_THREADS
+void scheme_process_block(float sleep_time)
+#else
+void scheme_process_block_w_process(float sleep_time, Scheme_Process *p)
+#endif
+/* Auto-resets p's blocking info if an escape occurs. */
+{
+  long start, d;
+#ifndef MZ_REAL_THREADS
+  Scheme_Process *next, *prev, *p = scheme_current_process;
+#endif
+  Scheme_Config *config = p->config;
+
+#ifndef MZ_REAL_THREADS
+  if (p->running < 0) {
+    /* This thread is dead! Give up now. */
+    scheme_swap_process(scheme_first_process);
+  }
+
+  if (scheme_active_but_sleeping)
+    scheme_wake_up();
+#else
+  if (p->running <= 0) {
+    remove_process(p);
+    SCHEME_EXIT_THREAD();
+  }
+#endif
+
+  if (sleep_time > 0)
+    start = scheme_get_milliseconds();
+  else
+    start = 0; /* compiler-friendly */
+
+  if (!p->checking_break) {
+    int breaking;
+    int allow_break = scheme_can_break(p, config);
+
+    if (p->external_break) {
+      if (allow_break) {
+	p->external_break = 0;
+	breaking = 1;
+      } else
+	breaking = 0;
+    } else {
+      Scheme_Object *poll;
+      
+      poll = scheme_get_param(config, MZCONFIG_USER_BREAK_POLL_HANDLER);
+      
+      if (poll && NOT_SAME_OBJ(poll, scheme_null_break_poll)) {
+	Scheme_Object *v;
+	int save_desc = p->block_descriptor;
+	Scheme_Object *save_blocker = p->blocker;
+	int (*save_check)(Scheme_Object *) = p->block_check;
+	void (*save_needs_wakeup)(Scheme_Object *, void *) = p->block_needs_wakeup;
+	int ran_some = p->ran_some;
+
+	make_unblocked(p);
+	
+	p->checking_break = 1;
+	v = scheme_apply_wp(poll, 0, NULL, p);
+	p->checking_break = 0;
+
+	p->block_descriptor = save_desc;
+	p->blocker = save_blocker;
+	p->block_check = save_check;
+	p->block_needs_wakeup = save_needs_wakeup;
+	p->ran_some = ran_some;
+	
+	breaking = SCHEME_TRUEP(v);
+      } else
+	breaking = 0;
+
+      if (breaking && !allow_break) {
+	p->external_break = 1;
+	breaking = 0;
+      }
+    }
+	
+    if (breaking
+	|| (!p->next && scheme_check_for_break && scheme_check_for_break())) {
+      make_unblocked(p);
+      scheme_raise_exn(MZEXN_MISC_USER_BREAK, "user break");
+    }
+  }
+  
+ swap_or_sleep:
+  
+  /* Check for active wills: */
+  {
+    WillExecutor *w;
+    
+    w = (WillExecutor *)scheme_get_param(config, MZCONFIG_WILL_EXECUTOR);
+    while (w->first && !w->running && (p->running >= 0)) {
+      p->ran_some = 1;
+      do_next_will(w, 0);
+      p->ran_some = 1;
+    }
+  }
+
+  port_sema_check();
+  
+#ifndef MZ_REAL_THREADS
+  if (!scheme_do_atomic && (sleep_time >= 0.0)) {
+    /* Find the next process. Skip processes that are definitely
+       blocked. */
+    
+    prev = next = p;
+    while (1) {
+      next = next->next ? next->next : scheme_first_process;
+      if (SAME_PTR(next, p)) {
+	next = NULL;
+	break;
+      }
+      
+      if (next->running < 0) {
+	/* This one has been terminated */
+	remove_process(next);
+      } else if (next->external_break && scheme_can_break(next, next->config)) {
+	break;
+      } else {
+	prev = next;
+	if (next->block_descriptor == -1) {
+	  if (next->block_check)
+	    if ((next->block_check)(next->blocker))
+	      break;
+	} else if (next->block_descriptor == EVENTLOOP_BLOCKED) {
+	  /* Can't use it. */
+	} else if (next->block_descriptor == SEMA_BLOCKED) {
+	  Scheme_Sema *sema = (Scheme_Sema *)next->blocker;
+	  if (sema->value)
+	    break;
+	} else if ((next->block_descriptor == PORT_BLOCKED)
+		   || (next->block_descriptor == PIPE_BLOCKED)) {
+	  if (scheme_char_ready(next->blocker))
+	    break;
+	} else if (next->block_descriptor == SLEEP_BLOCKED) {
+	  d = (scheme_get_milliseconds() - (long)next->block_start_sleep);
+	  if (d < 0)
+	    d = -d;
+	  if (d >= (next->sleep_time * 1000))
+	    break;
+	} else
+	  break;
+
+	/* If the will executor has something, the thread can work: */
+	{
+	  WillExecutor *w;
+
+	  w = (WillExecutor *)scheme_get_param(next->config, MZCONFIG_WILL_EXECUTOR);
+	  if (w->first && !w->running)
+	    break;
+	}
+      }
+    }
+  } else
+    next = NULL;
+  
+  if ((sleep_time > 0.0) && (p->block_descriptor == NOT_BLOCKED)) {
+    p->block_descriptor = SLEEP_BLOCKED;
+    p->block_start_sleep = start;
+    p->sleep_time = sleep_time;
+  }
+
+  if (next) {
+    if (!p->next) {
+      /* This is the main process */
+      scheme_ensure_stack_start(p, (void *)&start);
+    }
+    
+    scheme_swap_process(next);
+  } else {
+    /* If all processes are blocked, check for total process sleeping: */
+    if (p->block_descriptor != NOT_BLOCKED)
+      check_sleep(1, 1);
+  }
+
+  if (p->block_descriptor == SLEEP_BLOCKED) {
+    p->block_descriptor = NOT_BLOCKED;
+    p->sleep_time = 0.0;
+  }
+#else
+  if ((sleep_time > 0) && scheme_sleep)
+    scheme_sleep(sleep_time, NULL);
+#endif
+
+#ifndef MZ_REAL_THREADS
+  /* Killed while I was asleep? */
+  if (p->running < 0) {
+    /* This thread is dead! Give up now. */
+    remove_process(p);
+    scheme_swap_process(scheme_first_process);
+  }
+#else
+  if (p->running <= 0) {
+    remove_process(p);
+    SCHEME_EXIT_THREAD();
+  }
+#endif
+
+  /* Check for external break again after swap or sleep */
+  if (!p->checking_break && p->external_break && scheme_can_break(p, config)) {
+    p->external_break = 0;
+    make_unblocked(p);
+    scheme_raise_exn(MZEXN_MISC_USER_BREAK, "user break");
+  }
+  
+  if (sleep_time > 0) {
+    d = (scheme_get_milliseconds() - start);
+    if (d < 0)
+      d = -d;
+    if (d < (sleep_time * 1000))
+      goto swap_or_sleep;
+  }
+
+#if defined(MZ_REAL_THREADS) && (defined(FILES_HAVE_FDS) || defined(USE_WINSOCK_TCP))
+  if ((p->block_descriptor == PORT_BLOCKED)
+      || (p->block_descriptor == -1)) {
+    DECL_FDSET(set, 3);
+    fd_set *set1, *set2;
+    void *fds;
+    float sleep_time = 0;
+
+    INIT_DECL_FDSET(set, 3);
+    set1 = (fd_set *) MZ_GET_FDSET(set, 1);
+    set2 = (fd_set *) MZ_GET_FDSET(set, 2);
+
+    fds = (void *)set;
+    MZ_FD_ZERO(set);
+    MZ_FD_ZERO(set1);
+    MZ_FD_ZERO(set2);
+    
+    if (p->block_descriptor == -1) {
+	if (p->block_needs_wakeup)
+	  (p->block_needs_wakeup)(p->blocker, fds);
+	sleep_time = p->sleep_time;
+    } else
+      scheme_need_wakeup(p->blocker, fds);
+
+    if (scheme_sleep)
+      scheme_sleep(sleep_time, fds);
+  }
+#endif
+
+  MZTHREADELEM(p, fuel_counter) = p->engine_weight;
+}
+
+#ifndef NO_SCHEME_THREADS
+
+Scheme_Object *scheme_branch_config(void)
+{
+  Scheme_Object *o;
+
+  o = _scheme_apply(scheme_get_param(scheme_config,
+				     MZCONFIG_CONFIG_BRANCH_HANDLER),
+		    0, NULL);
+
+  if (!SCHEME_CONFIGP(o)) {
+    scheme_raise_exn(MZEXN_MISC_PARAMETERIZATION,
+		     o,
+		     "thread: parameterization branch handler returned a non-parameterization: %s",
+		     scheme_make_provided_string(o, 1, NULL));
+    return NULL;
+  }
+
+  return o;
+}
+
+static Scheme_Object *sch_thread(int argc, Scheme_Object *args[])
+{
+  scheme_check_proc_arity("thread", 0, 0, argc, args);
+
+  return scheme_thread(args[0], (Scheme_Config *)scheme_branch_config());
+}
+
+static Scheme_Object *
+sch_sleep(int argc, Scheme_Object *args[])
+{
+  float t;
+
+  if (argc && !SCHEME_REALP(args[0]))
+    scheme_wrong_type("sleep", "real", 0, argc, args);
+
+  if (argc) {
+    if (SCHEME_INTP(args[0]))
+      t = SCHEME_INT_VAL(args[0]);
+    else if (SCHEME_DBLP(args[0]))
+      t = SCHEME_DBL_VAL(args[0]);
+    else if (SCHEME_BIGNUMP(args[0]))
+      t = scheme_bignum_to_float(args[0]);
+    else if (SCHEME_RATIONALP(args[0]))
+      t = scheme_rational_to_float(args[0]);
+    else
+      t = 0;
+  } else
+    t = 0;
+
+  scheme_process_block(t);
+
+  return scheme_void;
+}
+
+static Scheme_Object *sch_current(int argc, Scheme_Object *args[])
+{
+  return (Scheme_Object *)scheme_current_process;
+}
+
+static Scheme_Object *break_thread(int argc, Scheme_Object *args[])
+{
+  Scheme_Process *p;
+
+  if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_process_type))
+    scheme_wrong_type("break-thread", "thread", 0, argc, args);
+
+  p = (Scheme_Process *)args[0];
+
+  scheme_break_thread(p);
+
+  return scheme_void;
+}
+
+static int do_kill_thread(Scheme_Process *p)
+{
+  int kill_self = 0;
+
+  if (!p->next) {
+    if (scheme_exit)
+      scheme_exit(0);
+
+    /* We really have to exit: */
+    exit(0);
+  }
+
+  if (p->running <= 0)
+    return 0;
+
+  if (p->on_kill)
+    p->on_kill(p);
+
+  scheme_remove_managed(p->mref, (Scheme_Object *)p);
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_GET_LOCK();
+  if (p->running) {
+    p->running = -1;
+    if (p == scheme_current_process)
+      kill_self = 1;
+    else
+      p->fuel_counter = 0;
+  }
+  SCHEME_RELEASE_LOCK();
+#else
+  if (p->running)
+    p->running = -1;
+#endif
+
+  return kill_self;
+}
+
+void scheme_kill_thread(Scheme_Process *p)
+{
+  if (do_kill_thread(p)) {
+#ifdef MZ_REAL_THREADS
+    /* Kill self: */
+    SCHEME_EXIT_THREAD();
+#endif
+  }
+
+#ifndef MZ_REAL_THREADS
+  scheme_process_block(0);
+#endif
+}
+
+static Scheme_Object *kill_thread(int argc, Scheme_Object *argv[])
+{
+  Scheme_Manager *m, *current;
+  Scheme_Process *p = (Scheme_Process *)argv[0];
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_process_type))
+    scheme_wrong_type("kill-thread", "thread", 0, argc, argv);
+
+  if (p->running <= 0)
+    return scheme_void;
+
+  /* Check management of the thread: */
+  current = (Scheme_Manager *)scheme_get_param(scheme_config, MZCONFIG_MANAGER);
+  m = *p->mref;
+  while (NOT_SAME_OBJ(m, current)) {
+    m = *m->parent;
+    if (!m) {
+      scheme_raise_exn(MZEXN_MISC_THREAD_KILL,
+		       "kill-thread: the current custodian does not "
+		       "manage the specified thread");
+      return NULL;
+    }
+  }
+
+  scheme_kill_thread(p);
+
+  return scheme_void;
+}
+
+static Scheme_Object *process_weight(int argc, Scheme_Object *args[])
+{
+  if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_process_type))
+    scheme_wrong_type("thread-weight", "thread", 0, argc, args);
+
+  if (argc > 1) {
+    long v;
+    Scheme_Process *p;
+
+    if (!SCHEME_INTP(args[1])) {
+      if (!SCHEME_BIGNUMP(args[1]) || !SCHEME_BIGPOS(args[1]))
+	scheme_wrong_type("thread-weight", "non-negative exact integer", 1, argc, args);
+    }
+
+    if (!scheme_get_int_val(args[1], &v)) {
+      scheme_raise_exn(MZEXN_APPLICATION_INTEGER,
+		       args[1],
+		       "thread-weight: %s is too large",
+		       scheme_make_provided_string(args[1], 0, NULL));
+    } else if (v < 0) {
+      scheme_wrong_type("thread-weight", "non-negative exact integer", 1, argc, args);
+    }
+
+    p = (Scheme_Process *)args[0];
+    
+    p->engine_weight = v;
+    if (p == scheme_current_process && scheme_fuel_counter > v)
+      scheme_fuel_counter = v;
+    
+    return scheme_void;
+  } else
+    return scheme_make_integer(((Scheme_Process *)args[0])->engine_weight);
+}
+
+static Scheme_Object *processp(int argc, Scheme_Object *args[])
+{
+  return SCHEME_PROCESSP(args[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *process_running_p(int argc, Scheme_Object *args[])
+{
+  if (!SCHEME_PROCESSP(args[0]))
+    scheme_wrong_type("thread-running?", "thread", 0, argc, args);
+
+  return ((Scheme_Process *)args[0])->running ? scheme_true : scheme_false;
+}
+
+#ifndef MZ_REAL_THREADS
+static int thread_wait_done(Scheme_Object *p)
+{
+  return !((Scheme_Process *)p)->running;
+}
+#endif
+
+static Scheme_Object *process_wait(int argc, Scheme_Object *args[])
+{
+  Scheme_Process *p;
+
+  if (!SCHEME_PROCESSP(args[0]))
+    scheme_wrong_type("thread-wait", "thread", 0, argc, args);
+
+  p = (Scheme_Process *)args[0];
+
+  if (p->running) {
+#ifndef MZ_REAL_THREADS
+    scheme_block_until(thread_wait_done, NULL, p, 0);
+#else
+    scheme_wait_sema(p->done_sema, 0);
+    scheme_post_sema(p->done_sema);
+#endif
+  }
+
+  return scheme_void;
+}
+
+int scheme_tls_allocate()
+{
+  return tls_pos++;
+}
+
+void scheme_tls_set(int pos, void *v)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  if (p->user_tls_size <= pos) {
+    int oldc = p->user_tls_size;
+    void **old_tls = p->user_tls;
+
+    p->user_tls_size = tls_pos;
+    p->user_tls = MALLOC_N(void*, tls_pos);
+    while (oldc--)
+      p->user_tls[oldc] = old_tls[oldc];
+  }
+
+  p->user_tls[pos] = v;
+}
+
+void *scheme_tls_get(int pos)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  if (p->user_tls_size <= pos)
+    return NULL;
+  else
+    return p->user_tls[pos];
+}
+
+#endif
+/* NO_SCHEME_THREADS */
+
+static Scheme_Object *make_manager(int argc, Scheme_Object *argv[])
+{
+  Scheme_Manager *m;
+
+  if (argc) {
+    if (!SCHEME_MANAGERP(argv[0]))
+      scheme_wrong_type("make-custodian", "custodian", 0, argc, argv);
+    m = (Scheme_Manager *)argv[0];
+  } else
+    m = (Scheme_Manager *)scheme_get_param(scheme_config, MZCONFIG_MANAGER);
+
+  return (Scheme_Object *)scheme_make_manager(m);
+}
+
+static Scheme_Object *manager_p(int argc, Scheme_Object *argv[])
+{
+  return SCHEME_MANAGERP(argv[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *manager_close_all(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_MANAGERP(argv[0]))
+    scheme_wrong_type("custodian-shutdown-all", "custodian", 0, argc, argv);
+
+  scheme_close_managed((Scheme_Manager *)argv[0]);
+
+  return scheme_void;
+}
+
+static Scheme_Object *current_manager(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-custodian", MZCONFIG_MANAGER,
+			     argc, argv,
+			     -1, manager_p, "custodian", 0);
+}
+
+static Scheme_Object *make_config(int argc, Scheme_Object *args[])
+{
+  Scheme_Config *c;
+
+  if (argc) {
+    if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_config_type))
+      scheme_wrong_type("make-parameterization", "parameterization", 0, argc, args);
+    c = (Scheme_Config *)args[0];
+  } else
+    c = NULL;
+    
+  return make_new_config(c, NULL, NULL, NULL);
+}
+
+static Scheme_Object *make_config_with_sharing(int argc, Scheme_Object *args[])
+{
+  Scheme_Config *c;
+  Scheme_Object *p, *l, *tl, *s;
+  char *badlist;
+
+  if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_config_type))
+    scheme_wrong_type("make-parameterization-with-sharing", "parameterization", 0, argc, args);
+  c = (Scheme_Config *)args[0];
+
+  if (SCHEME_FALSEP(args[1])) {
+    s = scheme_false;
+  } else {
+    if (!SAME_TYPE(SCHEME_TYPE(args[1]), scheme_config_type)) {
+      scheme_wrong_type("make-parameterization-with-sharing", "parameterization or #f", 1, argc, args);
+      return NULL;
+    }
+    s = args[1];
+  }
+
+  l = args[2];
+  badlist = NULL;
+  for (tl = l; SCHEME_PAIRP(tl); tl = SCHEME_CDR(tl)) {
+    Scheme_Object *v = SCHEME_CAR(tl);
+    if (!((SCHEME_PRIMP(v) || SCHEME_CLSD_PRIMP(v))
+	  && (((Scheme_Primitive_Proc *)v)->flags & SCHEME_PRIM_IS_PARAMETER)))
+      break;
+  }
+  if (SCHEME_NULLP(tl)) {
+    if (!SCHEME_NULLP(l) && !check_distinct_params(l))
+      badlist = "list of DISTINCT parameter procedures";
+  } else
+    badlist = "list of (distinct) parameter procedures";
+  
+  if (badlist) {
+    scheme_wrong_type("make-parameterization-with-sharing", badlist, 2, argc, args);
+    return NULL;
+  }
+
+  scheme_check_proc_arity("make-parameterization-with-sharing", 1, 3, argc, args);
+  p = args[3];
+  
+  return make_new_config(c, s, l, p);
+}
+
+static Scheme_Object *parameter_p(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *v = argv[0];
+
+  return (((SCHEME_PRIMP(v) || SCHEME_CLSD_PRIMP(v))
+	   && (((Scheme_Primitive_Proc *)v)->flags & SCHEME_PRIM_IS_PARAMETER))
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *do_param(void *data, int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *guard, **argv2;
+
+  if (argc && argv[0]) {
+    guard = ((ParamData *)data)->guard;
+    if (guard) {
+      Scheme_Object *v;
+      long l;
+      
+      v = _scheme_apply(guard, 1, argv);
+      argv2 = (Scheme_Object **)scheme_malloc(l = (argc * sizeof(Scheme_Object **)));
+      memcpy(argv2, argv, l);
+      argv2[0] = v;
+    } else
+      argv2 = argv;
+  } else
+    argv2 = argv;    
+
+  return scheme_param_config("parameter-procedure", 
+			     (long)scheme_make_pair((Scheme_Object *)((ParamData *)data)->key,
+						    ((ParamData *)data)->defval),
+			     argc, argv2,
+			     -2, NULL, NULL, 0);
+}
+
+static Scheme_Object *make_parameter(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *p;
+  ParamData *data;
+  ParamExtensionRec *erec, *prev;
+  void *k = scheme_malloc_atomic(1); /* generates a key */
+
+  if (argc > 1)
+    scheme_check_proc_arity("make-parameter", 1, 1, argc, argv);
+
+  data = MALLOC_ONE(ParamData);
+  data->key = (unsigned long)k;
+  data->defval = argv[0];
+  data->guard = ((argc > 1) ? argv[1] : NULL);
+
+  p = scheme_make_closed_prim_w_arity(do_param, (void *)data, 
+				      "parameter-procedure", 0, 1);
+  ((Scheme_Primitive_Proc *)p)->flags |= SCHEME_PRIM_IS_PARAMETER;
+
+  /* Throw away expired ext recs: */
+  prev = NULL;
+  for (erec = param_ext_recs; erec; erec = erec->next) {
+    if (!erec->data->p) {
+      if (prev)
+	prev->next = erec->next;
+      else
+	param_ext_recs = erec->next;
+    } else
+      prev = erec;
+  }
+
+  erec = MALLOC_ONE(ParamExtensionRec);
+  erec->next = param_ext_recs;
+  param_ext_recs = erec;
+  erec->data = MALLOC_ONE_ATOMIC(ParamExtensionRecData);
+  erec->data->p = p;
+  erec->data->key = (unsigned long)k;
+
+  scheme_weak_reference((void **)&erec->data->p);
+
+  return p;
+}
+
+static Scheme_Object *parameter_procedure_eq(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *a, *b;
+
+  a = argv[0];
+  b = argv[1];
+
+  if (!((SCHEME_PRIMP(a) || SCHEME_CLSD_PRIMP(a))
+	&& (((Scheme_Primitive_Proc *)a)->flags & SCHEME_PRIM_IS_PARAMETER)))
+    scheme_wrong_type("parameter-procedure=?", "parameter-procedure", 0, argc, argv);
+  if (!((SCHEME_PRIMP(b) || SCHEME_CLSD_PRIMP(b))
+	&& (((Scheme_Primitive_Proc *)b)->flags & SCHEME_PRIM_IS_PARAMETER)))
+    scheme_wrong_type("parameter-procedure=?", "parameter-procedure", 1, argc, argv);
+
+  return (SAME_OBJ(a, b)
+	  ? scheme_true
+	  : scheme_false);
+}
+
+static Scheme_Object *do_param_in_config(Scheme_Object *data, int argc, Scheme_Object *args[])
+{
+  Scheme_Object *args2[2], *p;
+
+  if (argc)
+    args2[0] = args[0];
+  else
+    args2[0] = NULL;
+  args2[1] = SCHEME_CDR(data);
+
+  p = SCHEME_CAR(data);
+
+  if (SCHEME_PRIMP(p))
+    return ((Scheme_Primitive_Proc *)p)->prim_val(2, args2);
+  else {
+    Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p;
+
+    return c->prim_val(c->data, 2, args2);
+  }
+}
+
+static Scheme_Object *in_config(int argc, Scheme_Object *args[])
+{
+  char name[256];
+  Scheme_Object *p;
+
+  if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_config_type))
+    scheme_wrong_type("in-parameterization", "parameterization", 0, argc, args);
+  p = args[1];
+  if ((!SCHEME_PRIMP(p) && !SCHEME_CLSD_PRIMP(p))
+      || !(((Scheme_Primitive_Proc *)p)->flags & SCHEME_PRIM_IS_PARAMETER))
+    scheme_wrong_type("in-parameterization", "parameter procedure", 1, argc, args);
+  
+  sprintf(name, "%s in parameterization", 
+	  SCHEME_PRIMP(p) 
+	  ? ((Scheme_Primitive_Proc *)p)->name
+	  : ((Scheme_Closed_Primitive_Proc *)p)->name);
+
+  return scheme_make_closed_prim_w_arity((Scheme_Closed_Prim *)do_param_in_config,
+					 scheme_make_pair(args[1], args[0]),
+					 scheme_strdup(name),
+					 0, 1);
+}
+
+static Scheme_Object *config_p(int argc, Scheme_Object **argv)
+{
+  return ((SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_config_type)) 
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+static Scheme_Object *current_config(int argc, Scheme_Object *args[])
+{
+  if (!argc)
+    return (Scheme_Object *)scheme_config;
+  else {
+    if (!SAME_TYPE(SCHEME_TYPE(args[0]), scheme_config_type))
+      scheme_wrong_type("current-parameterization", "parameterization", 0, argc, args);
+    scheme_config = (Scheme_Config *)args[0];
+    return scheme_void;
+  }
+}
+
+static Scheme_Object *namespace_p(int argc, Scheme_Object **argv)
+{
+  return ((SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_namespace_type)) 
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+static Scheme_Object *current_namespace(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-namespace", MZCONFIG_ENV,
+			     argc, argv,
+			     -1, namespace_p, "namespace", 0);
+}
+
+static Scheme_Object *config_branch_handler(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("parameterization-branch-handler", MZCONFIG_CONFIG_BRANCH_HANDLER,
+			     argc, argv,
+			     0, NULL, NULL, 0);
+}
+
+/****************************************/
+
+static int max_configs = __MZCONFIG_BUILTIN_COUNT__;
+
+static int occurs_in_list(Scheme_Object *v, Scheme_Object *l)
+{
+  Scheme_Object *tl;
+  int count = 0;
+
+  for (tl = l; SCHEME_PAIRP(tl); tl = SCHEME_CDR(tl)) {
+    if (SAME_OBJ(SCHEME_CAR(tl), v))
+      count++;
+  }
+
+  return count;
+}
+
+static int check_distinct_params(Scheme_Object *l)
+{
+  int i;
+  ParamExtensionRec *erec;
+ 
+  for (i = 0; i < max_configs; i++) {
+    if (occurs_in_list(config_map[i], l) > 1)
+      return 0;
+  }
+  
+  for (erec = param_ext_recs; erec; erec = erec->next) {
+    if (erec->data->p && (occurs_in_list(erec->data->p, l) > 1))
+      return 0;
+  }
+  
+  return 1;
+}
+
+int scheme_new_param(void)
+{
+  return max_configs++;
+}
+
+static Scheme_Object *default_config_branch_handler(int argc, Scheme_Object **argv)
+{
+  return scheme_make_config(scheme_config);
+}
+
+static Scheme_Config *make_initial_config(void)
+{
+  Scheme_Config *config;
+  int i;
+
+  config = (Scheme_Config *)scheme_malloc_tagged(sizeof(Scheme_Config) + 
+						 (max_configs - 1) * sizeof(Scheme_Object*));
+  
+  config->type = scheme_config_type;
+  config->parent = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->parent = NULL;
+  config->child = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->child = NULL;
+  config->sibling = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->sibling = NULL;
+
+  for (i = 0; i < max_configs; i++)
+    config->configs[i] = MALLOC_ONE(Scheme_Object *);
+
+  scheme_set_param(config, MZCONFIG_ENABLE_BREAK, scheme_true);
+  scheme_set_param(config, MZCONFIG_ENABLE_EXCEPTION_BREAK, scheme_false);
+  scheme_set_param(config, MZCONFIG_CAN_READ_GRAPH, scheme_true);
+  scheme_set_param(config, MZCONFIG_CAN_READ_COMPILED, scheme_false);
+  scheme_set_param(config, MZCONFIG_CAN_READ_BOX, scheme_true);
+  scheme_set_param(config, MZCONFIG_CAN_READ_TYPE_SYMBOL, scheme_true);
+  scheme_set_param(config, MZCONFIG_CAN_READ_PIPE_QUOTE, scheme_true);
+
+  scheme_set_param(config, MZCONFIG_PRINT_GRAPH, scheme_false);
+  scheme_set_param(config, MZCONFIG_PRINT_STRUCT, scheme_false);
+  scheme_set_param(config, MZCONFIG_PRINT_BOX, scheme_true);
+
+  scheme_set_param(config, MZCONFIG_CASE_SENS, (scheme_case_sensitive ? scheme_true : scheme_false));
+  scheme_set_param(config, MZCONFIG_SQUARE_BRACKETS_ARE_PARENS, (scheme_square_brackets_are_parens
+								 ? scheme_true : scheme_false));
+  scheme_set_param(config, MZCONFIG_CURLY_BRACES_ARE_PARENS, (scheme_curly_braces_are_parens
+							      ? scheme_true : scheme_false));
+
+  scheme_set_param(config, MZCONFIG_ERROR_PRINT_WIDTH, scheme_make_integer(40));
+
+  scheme_set_param(config, MZCONFIG_CONFIG_BRANCH_HANDLER, scheme_make_prim_w_arity(default_config_branch_handler,
+										    "default-parameterization-branch-handler",
+										    0, 0));
+
+  REGISTER_SO(main_manager);
+  main_manager = scheme_make_manager(NULL);
+  scheme_set_param(config, MZCONFIG_MANAGER, (Scheme_Object *)main_manager);
+
+  scheme_set_param(config, MZCONFIG_WILL_EXECUTOR, make_will_executor(0, NULL));
+
+  scheme_set_param(config, MZCONFIG_ALLOW_SET_UNDEFINED, (scheme_allow_set_undefined
+							  ? scheme_true
+							  : scheme_false));
+  scheme_set_param(config, MZCONFIG_COND_AUTO_ELSE, (scheme_allow_cond_auto_else
+						     ? scheme_true
+						     : scheme_false));
+
+  scheme_set_param(config, MZCONFIG_REQ_LIB_USE_COMPILED, scheme_true);
+
+  scheme_set_param(config, MZCONFIG_REQUIRE_COLLECTION, scheme_false);
+
+  config->extensions = NULL;
+
+  return config;
+}
+
+static void adjust_config_family(void *c, void *ignored)
+{
+  Scheme_Config *config = (Scheme_Config *)c;
+  Scheme_Config **p;
+
+  if (*config->parent) {
+
+    p = (*config->parent)->child;
+    while (*p && *p != config)
+      p = (*p)->sibling;
+    
+    if (*p)
+      *p = *config->sibling;
+
+    while (*p)
+      p = (*p)->sibling;
+
+    *p = *config->child;
+
+  }
+
+  p = config->child;
+  while (*p) {
+    *(*p)->parent = *config->parent;
+    p = (*p)->sibling;
+  }
+}
+
+static Scheme_Object *make_new_config(Scheme_Config *base, Scheme_Object *defshare,
+				      Scheme_Object *share_list, Scheme_Object *sharef)
+{
+  Scheme_Config *config;
+  int i;
+  
+  if (!base)
+    base = scheme_config;
+
+  config = (Scheme_Config *)scheme_malloc_tagged(sizeof(Scheme_Config) + 
+						 (max_configs - 1) * sizeof(Scheme_Object**));
+
+  config->type = scheme_config_type;
+  config->extensions = NULL;
+
+  for (i = 0; i < max_configs; i++) {
+    if (defshare) {
+      Scheme_Object *r;
+
+      if (occurs_in_list(config_map[i], share_list))
+	r = _scheme_apply(sharef, 1, config_map + i);
+      else
+	r = defshare;
+
+      if (SCHEME_FALSEP(r)) {
+	config->configs[i] = MALLOC_ONE(Scheme_Object *);
+	*config->configs[i] = *base->configs[i];
+      } else if (SCHEME_CONFIGP(r)) {
+	Scheme_Config *s = (Scheme_Config *)r;
+	config->configs[i] = s->configs[i];
+      } else {
+	scheme_raise_exn(MZEXN_MISC_PARAMETERIZATION,
+			 r,
+			 "make-parameterization: sharing procedure returned a non-parameterization: %s",
+			 scheme_make_provided_string(r, 1, NULL));
+	return NULL;
+      }
+    } else {
+      config->configs[i] = MALLOC_ONE(Scheme_Object *);
+      *config->configs[i] = *base->configs[i];
+    }
+  }
+
+  if (defshare) {
+    ParamExtensionRec *erec;
+
+    if (!config->extensions)
+      config->extensions = scheme_hash_table(2, SCHEME_hash_weak_ptr, 0, 0);
+
+    for (erec = param_ext_recs; erec; erec = erec->next) {
+      if (erec->data->p) {
+	Scheme_Object *r, *defval;
+	unsigned long key;
+	
+	key = erec->data->key;
+	defval = ((ParamData *)((Scheme_Closed_Primitive_Proc *)erec->data->p)->data)->defval;
+
+	if (occurs_in_list(erec->data->p, share_list)) {
+	  Scheme_Object *p = erec->data->p;
+	  r = _scheme_apply(sharef, 1, &p);
+	} else
+	  r = defshare;
+	
+	if (!SCHEME_FALSEP(r)) {
+	  if (SCHEME_CONFIGP(r)) {
+	    Scheme_Config *s = (Scheme_Config *)r;
+	    Scheme_Bucket *b;
+
+	    if (!s->extensions)
+	      s->extensions = scheme_hash_table(2, SCHEME_hash_weak_ptr, 0, 0);
+
+	    b = scheme_bucket_from_table(s->extensions, (const char *)key);
+	    if (!b->val)
+	      b->val = defval;
+
+	    scheme_add_bucket_to_table(config->extensions, b);
+	  } else {
+	    scheme_raise_exn(MZEXN_MISC_PARAMETERIZATION,
+			     r,
+			     "make-parameterization: "
+			     "sharing procedure returned a non-parameterization: %s",
+			     scheme_make_provided_string(r, 1, NULL));
+	    return NULL;
+	  }
+	} else if (!SCHEME_FALSEP(defshare))
+	  scheme_add_to_table(config->extensions, (const char *)key, defval, 0);
+      }
+    }
+  }
+
+  config->parent = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->parent = NULL;
+  config->child = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->child = NULL;
+  config->sibling = MALLOC_ONE_ATOMIC(Scheme_Config*);
+  *config->sibling = NULL;
+
+  if (defshare && !SCHEME_FALSEP(defshare)) {
+    Scheme_Config *d = (Scheme_Config *)defshare;
+    *config->sibling = *d->child;
+    *d->child = config;
+    *config->parent = d;
+  }
+
+  scheme_add_finalizer(config, adjust_config_family, NULL);
+
+  return (Scheme_Object *)config;
+}
+
+Scheme_Object *scheme_make_config(Scheme_Config *base)
+{
+  return make_new_config(base, NULL, NULL, NULL);
+}
+
+Scheme_Object *scheme_register_parameter(Scheme_Prim *function, char *name, int which)
+{
+  Scheme_Object *o;
+
+  if (!config_map)
+    config_map = MALLOC_N(Scheme_Object*, max_configs);
+
+  if (config_map[which])
+    return config_map[which];
+
+  o = scheme_make_prim_w_arity(function, name, 0, 1);
+  ((Scheme_Primitive_Proc *)o)->flags |= SCHEME_PRIM_IS_PARAMETER;
+
+  config_map[which] = o;
+
+  return o;
+}
+
+static Scheme_Bucket *get_ext_bucket(Scheme_Config *config, const char *key, Scheme_Object *defval)
+{
+  Scheme_Config *c = config;
+  Scheme_Bucket *b;
+  
+  while (1) {
+    b = scheme_bucket_or_null_from_table(c->extensions, key, 0);
+    if (b) {
+      if (c != config)
+	scheme_add_bucket_to_table(config->extensions, b);
+      
+      return b;
+    } else if (*c->parent)
+      c = *c->parent;
+    else
+      break;
+  }
+
+  b = scheme_bucket_from_table(c->extensions, key);
+  b->val = (char *)defval;
+  if (c != config)
+    scheme_add_bucket_to_table(c->extensions, b);
+
+  return b;
+}
+
+Scheme_Object *scheme_param_config(char *name, long pos,
+				   int argc, Scheme_Object **argv,
+				   int arity,
+				   /* -2 => user paramter; pos is (cons key defval)
+				      -1 => try check, etc. 
+				      0+ => check argument for this arity */
+				   Scheme_Object *(*check)(int, Scheme_Object **), char *expected,
+				   int isboolorfilter)
+{
+  int set = 0;
+  Scheme_Config *config;
+
+  if (argc < 2) {
+    config = scheme_config;
+    if (argc == 1)
+      set = 1;
+  } else {
+    config = (Scheme_Config *)argv[1];
+    if (argv[0]) {
+      set = 1;
+      argc = 1;
+    } else {
+      argc = 0;
+    }
+  }
+
+  if (!set) {
+    if (arity == -2) {
+      Scheme_Object *defval = SCHEME_CDR((Scheme_Object *)pos);
+      if (config->extensions) {
+	const char *key = (const char *)SCHEME_CAR((Scheme_Object *)pos);
+	Scheme_Bucket *b;
+	
+	b = get_ext_bucket(config, key, defval);
+	return (Scheme_Object *)b->val;
+      }
+      return defval;
+    } else
+      return scheme_get_param(config, pos);
+  } else {
+    Scheme_Object *naya = argv[0];
+
+    if (arity != -2) {
+      if (arity < 0) {
+	if (check) {
+	  Scheme_Object *r = check(1, argv);
+	  
+	  if (!isboolorfilter && SCHEME_FALSEP(r))
+	    r = NULL;
+	  
+	  if (!r) {
+	    scheme_wrong_type(name, expected, 0, argc, argv);
+	    return NULL;
+	  }
+	  
+	  if (isboolorfilter)
+	    naya = r;
+	}
+      } else 
+	scheme_check_proc_arity(name, arity, 0, argc, argv);
+
+      if (isboolorfilter && !check)
+	scheme_set_param(config, pos, ((SCHEME_TRUEP(naya)) ? scheme_true : scheme_false));
+      else
+	scheme_set_param(config, pos, naya);
+    } else {
+      const char *key = (const char *)SCHEME_CAR((Scheme_Object *)pos);
+      Scheme_Bucket *b;
+
+      if (!config->extensions)
+	config->extensions = scheme_hash_table(2, SCHEME_hash_weak_ptr, 0, 0);
+      
+      b = get_ext_bucket(config, key, NULL);
+      b->val = naya;
+    }
+  
+    return scheme_void;
+  }
+}
+
+Scheme_Env *scheme_get_env(Scheme_Config *c)
+{
+  Scheme_Object *o = scheme_get_param(c, MZCONFIG_ENV);
+  return (Scheme_Env *)o;
+}
+
+/****************************************/
+
+static void activate_will(void *o, void *data) 
+{
+  WillRegistration *r = (WillRegistration *)data;
+  ActiveWill *a;
+  WillExecutor *w;
+    
+  a = MALLOC_ONE(ActiveWill);
+  a->o = (Scheme_Object *)o;
+  a->proc = r->proc;
+  
+  GET_WILL_LOCK();
+  w = r->w;
+  if (w->last)
+    w->last->next = a;
+  else
+    w->first = a;
+  w->last = a;
+  RELEASE_WILL_LOCK();
+}
+
+static Scheme_Object *now_do_will(void *v)
+{
+  ActiveWill *a = (ActiveWill *)v;
+  Scheme_Object *o[1];
+
+  o[0] = a->o;
+  a->o = NULL;
+
+  return scheme_apply(a->proc, 1, o);
+}
+
+static void post_will(void *v)
+{
+  ActiveWill *a = (ActiveWill *)v;
+
+  a->w->running = 0;
+}
+
+static Scheme_Object *do_next_will(WillExecutor *w, int tail)
+{
+  ActiveWill *a;
+
+  GET_WILL_LOCK();
+  if (w->running || !w->first) {
+    RELEASE_WILL_LOCK();
+    return scheme_false;
+  }
+  a = w->first;
+  w->first = a->next;
+  if (!w->first)
+    w->last = NULL;
+  w->running = 1;
+  RELEASE_WILL_LOCK();
+  
+  a->w = w;
+
+  return scheme_dynamic_wind(NULL, now_do_will, post_will, NULL, a);
+}
+
+static Scheme_Object *current_will_executor(int argc, Scheme_Object *argv[])
+{
+  return scheme_param_config("current-will-executor", MZCONFIG_WILL_EXECUTOR,
+			     argc, argv,
+			     -1, will_executor_p, "will-executor", 0);
+}
+
+static Scheme_Object *make_will_executor(int argc, Scheme_Object **argv)
+{
+  WillExecutor *w = MALLOC_ONE_TAGGED(WillExecutor);
+
+  w->type = scheme_will_executor_type;
+  w->first = NULL;
+  w->last = NULL;
+  w->running = 0;
+
+  return (Scheme_Object *)w;
+}
+
+static Scheme_Object *will_executor_p(int argc, Scheme_Object **argv)
+{
+  return ((SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_will_executor_type)) 
+	  ? scheme_true 
+	  : scheme_false);
+}
+
+static Scheme_Object *register_will(int argc, Scheme_Object **argv)
+{
+  WillRegistration *r;
+
+  scheme_check_proc_arity("register-will", 1, 1, argc, argv);
+  if ((argc > 2) && NOT_SAME_TYPE(SCHEME_TYPE(argv[2]), scheme_will_executor_type))
+    scheme_wrong_type("register-will", "will-executor", 2, argc, argv);
+
+  r = MALLOC_ONE(WillRegistration);
+  r->proc = argv[1];
+  r->w = (WillExecutor *)((argc > 2)
+			  ? argv[2]
+			  : scheme_get_param(scheme_config, MZCONFIG_WILL_EXECUTOR));
+
+  scheme_add_scheme_finalizer(argv[0], activate_will, (void *)r);
+
+  return scheme_void;
+}
+
+static Scheme_Object *will_executor_try(int argc, Scheme_Object **argv)
+{
+  WillExecutor *w;
+
+  if (NOT_SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_will_executor_type))
+    scheme_wrong_type("will-executor-try", "will-executor", 0, argc, argv);
+  
+  w = (WillExecutor *)argv[0];
+
+  if (w->first && !w->running)
+    return do_next_will(w, 1);
+  else
+    return scheme_false;
+}
+
+/****************************************/
+
+#ifdef MZ_REAL_THREADS
+
+/* Implementing support for new thread systems:
+
+   MzScheme needs implementations for the following functions (usually
+   these are macros mapped to actual function names in sconfig.h):
+
+   void* SCHEME_INIT_THREADS(void) - initializes thread system, returns
+     the id of the initial (main) thread
+
+   void SCHEME_CREATE_THREAD(void (*f)(void*), void* data, 
+     unsigned long *slimit, void** thp) - starts a new thread, applying `f' 
+     to `data' in the new thread. BEFORE `f' is applied to `data', the id 
+     for the new thread must be in `*thp'. If Unix-style stack-checking is 
+     used, the hottest allowable stack address (with the safely margin 
+     already removed) must be put into `slimit' before `f' is applied; 
+     `slimit' may be NULL, in which case the stack limit is not needed.
+
+   void SCHEME_EXIT_THREAD() - exits the current thread
+
+   void SCHEME_BREAK_THREAD(void* th) - signals a break in the thread `th'.
+     If `th' is waiting on a semaphore or selecting a file descriptor, this
+     breaking signal must cause that wait or select to break.
+
+   void SCHEME_SET_CURRENT_PROCESS(Scheme_Process* p) - stores `p' as the
+     Scheme thread pointer for the current thread.
+
+   Scheme_Process* SCHEME_GET_CURRENT_PROCESS() - retrieves the Scheme thread
+     pointer for the current thread.
+
+   void* SCHEME_MAKE_MUTEX(int init) - creates a new mutex.
+
+   void SCHEME_FREE_MUTEX(void* m) - destroys the mutex `m'.
+
+   void SCHEME_LOCK_MUTEX(void* m) - locks the mutex `m', blocking until
+     it is available.
+
+   void SCHEME_UNLOCK_MUTEX(void* m) - unlocks the mutex `m'.
+
+   int SCHEME_SEMA_DOWN_BREAKABLE(void* s) - waits on `s' but allows the
+     wait to be terminated by a break, returing 1 if the wait was sucessful
+     (i.e., no break occurred) or 0 if unsuccessful.
+
+   void* SCHEME_MAKE_SEMA(int init) - creates a new semaphore with initial
+     count `init'.
+
+   void SCHEME_FREE_SEMA(void* s) - destroys the semaphore `s'.
+
+   int SCHEME_SEMA_UP(void* s) - posts to the semaphore `s', returning 0 if
+     an error occurred.
+
+   int SCHEME_SEMA_DOWN_BREAKABLE(void* s) - waits on `s' but allows the
+     wait to be terminated by a break, returing 1 if the wait was sucessful
+     (i.e., no break occurred) or 0 if unsuccessful.
+
+   int SCHEME_SEMA_TRY_DOWN(void* s) - attempts a non-blocking wait on the
+     semaphore `s', immediately returning 1 if the wait was successful or
+     0 if unsuccessful.
+*/
+
+void scheme_real_sema_down(void *sema)
+{
+  if (!SCHEME_SEMA_DOWN_BREAKABLE(sema)) {
+    Scheme_Process *p = scheme_current_process;
+    do {
+      scheme_process_block_w_process(0, p);
+    } while (!SCHEME_SEMA_DOWN_BREAKABLE(sema));
+  }
+}
+
+#endif
+
+/****************************************/
+
+#ifdef MZ_USE_SOLARIS_THREADS
+
+static thread_key_t cp_key;
+typedef struct {
+  void (*f)(void *);
+  void *data;
+  void *stack;
+} solaris_closure;
+
+void *scheme_solaris_init_threads(void)
+{
+  if (thr_keycreate(&cp_key, NULL)) {
+    printf("init failed\n");
+    exit(-1);
+  }
+
+  return (void *)thr_self();
+}
+
+static void do_nothing(int ignored)
+{
+}
+
+static void *start_solaris_thread(void *cl)
+{
+  sigset(SIGINT, do_nothing);
+
+  ((solaris_closure *)cl)->f(((solaris_closure *)cl)->data);
+
+  return NULL;
+}
+
+void scheme_solaris_create_thread(void (*f)(void *), void *data, 
+				  unsigned long *stackend, void **thp)
+{
+  void *stack;
+  size_t size;
+  thread_t naya;
+  solaris_closure *cl = scheme_malloc(sizeof(solaris_closure));
+
+  cl->f = f;
+  cl->data = data;
+
+  if (stackend) {
+    size = 2 * STACK_SAFETY_MARGIN;
+    if (thr_min_stack() > size)
+      size = thr_min_stack();
+    stack = scheme_malloc_atomic(size);
+  
+    *stackend = ((unsigned long)stack) + STACK_SAFETY_MARGIN;
+  } else {
+    stack = NULL;
+    size = 0;
+  }
+
+  cl->stack = stack; /* weird trick: as long as the stack is needed,
+			cl will be on it, so let GC decide whether 
+			the stack is active and therefore whether
+			"stack" is still active. */
+
+  thr_create(stack, size,
+	     start_solaris_thread, (void *)cl, 
+	     THR_SUSPENDED, &naya);
+
+  *thp = (void *)naya;
+  
+  thr_continue(naya);
+}
+
+void scheme_solaris_exit_thread()
+{
+  thr_exit(0);
+}
+
+void scheme_solaris_break_thread(void *th)
+{
+  thr_kill((thread_t)th, SIGINT);
+}
+
+Scheme_Process *scheme_solaris_get_current_process()
+{
+  Scheme_Process *p;
+
+  thr_getspecific(cp_key, (void **)&p);
+
+  return p;
+}
+
+void scheme_solaris_set_current_process(Scheme_Process *p)
+{
+  thr_setspecific(cp_key, (void *)p);
+}
+
+void *scheme_solaris_make_mutex(int v)
+{
+  mutex_t *m;
+  m = (mutex_t *)scheme_malloc_atomic(sizeof(mutex_t));
+  mutex_init(m, USYNC_THREAD, NULL);
+
+  return (void *)m;
+}
+
+void scheme_solaris_free_mutex(void *m)
+{
+  mutex_destroy(m);
+}
+
+void scheme_solaris_lock_mutex(void *m)
+{
+  mutex_lock(m);
+}
+
+void scheme_solaris_unlock_mutex(void *m)
+{
+  mutex_unlock(m);
+}
+
+void *scheme_solaris_make_semaphore(int v)
+{
+  sema_t *s;
+  s = (sema_t *)scheme_malloc_atomic(sizeof(sema_t));
+  sema_init(s, v, USYNC_THREAD, NULL);
+
+  return (void *)s;
+}
+
+void scheme_solaris_free_semaphore(void *s)
+{
+  sema_destroy(s);
+}
+
+int scheme_solaris_semaphore_up(void *s)
+{
+  return !sema_post((sema_t *)s);
+}
+
+int scheme_solaris_semaphore_down_breakable(void *s)
+{
+  return !sema_wait((sema_t *)s);
+}
+
+int scheme_solaris_semaphore_try_down(void *s)
+{
+  return !sema_trywait((sema_t *)s);
+}
+
+#endif /* MZ_USE_SOLARIS_THREADS */
+
+/****************************************************************/
+
+#ifdef MZ_USE_WIN32_THREADS
+
+typedef struct {
+  long th;
+  HANDLE break_sema;
+} Win32SchemeThread;
+
+typedef struct {
+  void (*f)(void *);
+  void *data;
+  void *stack;
+  HANDLE stack_set;
+  HANDLE thread_go;
+} thread_closure;
+
+static DWORD tls;
+
+void *scheme_win32_init_threads(void)
+{
+  Win32SchemeThread *th = MALLOC_ONE_ATOMIC(Win32SchemeThread);
+
+  tls = TlsAlloc();
+
+  th->th = 0;
+  th->break_sema = NULL; /* use scheme_break_semaphore */
+
+  return th;
+}
+
+static unsigned __stdcall run_win32_thread(void *data)
+{
+  long dummy;
+  thread_closure *cl = (thread_closure *)data;
+
+  cl->stack = (void *)&dummy;
+  
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+  DllMain(NULL, DLL_THREAD_ATTACH, NULL);
+# endif
+
+  ReleaseSemaphore(cl->stack_set, 1, NULL);
+  WaitForSingleObject(cl->thread_go, INFINITE);
+
+  cl->f(cl->data);
+
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+  DllMain(NULL, DLL_THREAD_DETACH, NULL);
+# endif
+
+  return 0;
+}
+
+static void free_win32_break_sema(void *th, void *ignored)
+{
+  CloseHandle(((Win32SchemeThread *)th)->break_sema);
+}
+
+void scheme_win32_create_thread(void (*f)(void *), void *data, 
+				unsigned long *stackend, void **thp)
+{
+  Win32SchemeThread *th = MALLOC_ONE_ATOMIC(Win32SchemeThread);
+  thread_closure *cl = MALLOC_ONE(thread_closure);
+  unsigned id;
+
+  cl->f = f;
+  cl->data = data;
+
+  th->break_sema = CreateSemaphore(NULL, 0, 1, NULL);
+  cl->thread_go = th->break_sema;
+  cl->stack_set = stackend ? CreateSemaphore(NULL, 0, 1, NULL) : NULL;
+
+  th->th = _beginthreadex(NULL, 0, run_win32_thread, cl, 0, &id);
+
+  *thp = (void *)th;
+
+  if (stackend) {
+    WaitForSingleObject(cl->stack_set, INFINITE);
+
+# ifdef WINDOWS_FIND_STACK_BOUNDS
+    *stackend = ((unsigned long)cl->stack + (STACK_SAFETY_MARGIN - 0x100000));
+# else
+    >> not implemented <<
+# endif
+
+    CloseHandle(cl->stack_set);
+  }
+
+  ReleaseSemaphore(cl->thread_go, 1, NULL);
+
+  ResumeThread((HANDLE)th->th);
+
+  scheme_add_finalizer(th, free_win32_break_sema, NULL);
+
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+  DllMain(NULL, DLL_THREAD_DETACH, NULL);
+# endif
+}
+
+void scheme_win32_exit_thread()
+{
+# ifdef GC_THINKS_ITS_A_DLL_BUT_ISNT
+  DllMain(NULL, DLL_THREAD_DETACH, NULL);
+# endif
+
+  _endthreadex(0);
+}
+
+void *scheme_win32_get_break_semaphore(void *th)
+{
+  HANDLE s;
+
+  s = ((Win32SchemeThread *)th)->break_sema;
+  if (!s)
+    s = scheme_break_semaphore;
+
+  return (void *)s;
+}
+
+void scheme_win32_break_thread(void *th)
+{
+  HANDLE s = (HANDLE)scheme_win32_get_break_semaphore(th);
+
+  ReleaseSemaphore(s, 1, NULL);
+}
+
+struct Scheme_Process *scheme_win32_get_current_process()
+{
+  return (Scheme_Process *)TlsGetValue(tls);
+}
+
+void scheme_win32_set_current_process(struct Scheme_Process *p)
+{
+  TlsSetValue(tls, (LPVOID)p);
+}
+
+void *scheme_win32_make_semaphore(int init)
+{
+  return (void *)CreateSemaphore(NULL, init, 256, NULL);
+}
+
+void scheme_win32_free_semaphore(void *s)
+{
+  CloseHandle((HANDLE)s);
+}
+
+int scheme_win32_semaphore_up(void *s)
+{
+  return ReleaseSemaphore((HANDLE)s, 1, NULL);
+}
+
+int scheme_win32_semaphore_down_breakable(void *s)
+{
+  int c;
+  HANDLE a[2];
+
+  a[0] = (HANDLE)s;
+  a[1] = scheme_win32_get_break_semaphore((Win32SchemeThread *)scheme_current_process->thread);
+
+  c = !a[1] ? 1 : 2;
+
+  return WaitForMultipleObjects(c, a, FALSE, INFINITE) == WAIT_OBJECT_0;
+}
+
+int scheme_win32_semaphore_try_down(void *s)
+{
+  return !WaitForSingleObject((HANDLE)s, 0);
+}
+
+#endif /* MZ_USE_WIN32_THREADS */
+
+/****************************************************************/
+
+#ifdef MZ_USE_IRIX_SPROCS
+
+/* Irix sprocs implementation contributed by Fernando D. Mato Mira */
+/* 
+   NOTE TO IMPLEMENTORS:
+   IRIX semaphores are awfully slow to awake a process. 
+   It's better to use ulocks or abilocks, if a count is not really needed.
+   There're are macros in semaphores.h that homogeneize the interfaces
+   for locking, eg:
+
+   SLOW:   slock --> usema_t
+   MEDIUM: ulock --> ulock_t   (good response)
+   QUICK:  qlock --> abilock_t (eats a bit of CPU time, 'cause it spins/nanosleeps)
+
+   --fdmm
+*/
+
+#include <ulocks.h>
+
+static thread_key_t cp_key;
+typedef struct {
+  void (*f)(void *);
+  void *data;
+#ifdef MZ_PRIVATE_SPAWN_MUTEX
+  mutex_t *mutex;
+#endif
+  void *stack;
+} sproc_closure;
+
+void *scheme_sproc_init_threads(void)
+{
+  if (thr_keycreate(&cp_key, NULL)) {
+    printf("init failed\n");
+    exit(-1);
+  }
+
+  return (void *)getpid(); /* retrurn the main thread (= current thread) */
+}
+
+static void do_nothing(int ignored)
+{
+}
+
+static void start_sproc_thread(void *cl, size_t ignored)
+{
+  sproc_closure *scl = (sproc_closure *)cl;
+
+  sigset(SIGINT, do_nothing);
+
+  /* wait until `*stackend' and `*thp' have been set. */
+#ifdef MZ_PRIVATE_SPAWN_MUTEX
+  qlock_1(scl->mutex, "scheme_sproc_mutex_down");
+  freemutex(scl->mutex);
+#else
+  /* (parent does not release the allocation lock */
+  /*  until that is done) */
+  sproc_lock();
+  sproc_unlock();
+#endif
+
+  scl->f(scl->data);
+}
+
+void scheme_sproc_create_thread(void (*f)(void *), void *data, 
+				unsigned long *stackend, void **thp)
+{
+  int naya;
+  void *stack;
+  size_t size;
+  sproc_closure *cl = scheme_malloc(sizeof(sproc_closure));
+
+  cl->f = f;
+  cl->data = data;
+
+  if (stackend) {
+    size = 2 * STACK_SAFETY_MARGIN;
+    stack = scheme_malloc(size); /*scheme_malloc_atomic(size);*/
+    
+    *stackend = ((unsigned long)stack) + STACK_SAFETY_MARGIN;
+  } else {
+    stack = NULL;
+    size = 0;
+  }
+
+  cl->stack = stack; /* weird trick: as long as the stack is needed,
+			cl will be on it, so let GC decide whether 
+			the stack is active and therefore whether
+			"stack" is still active. */
+#ifdef MZ_PRIVATE_SPAWN_MUTEX
+#define SPROCSP sprocsp
+  cl->mutex = newmutex();
+#else
+#define SPROCSP GC_sprocsp_
+  /* I'll deadlock if I call GC-safe unblockproc() before   */
+  /* GC-safe sproc()  completes its housekeeping.           */
+  /* Worse, because of sproc_lock() a process that tries to */
+  /* GC-safely blockproc() before it gets completely        */
+  /* unblockproc'ed will also cause a deadlock.             */
+
+  /* Solution: we call sprocsp_(), which is GC_safe, but   */
+  /*   does not release the allocation lock.               */
+  /*   We could use _GC_unblockproc() then, but it's less  */
+  /*   redundant to just wait for this lock in the child   */ 
+  /*   Hopefully, this will not cause much more contention */
+  /*   with other threads than if we used a separate lock  */
+  /*   just for this.      */
+#endif
+
+  naya = SPROCSP (start_sproc_thread, PR_SALL, (void *)cl, 
+		 (caddr_t)(((char *)stack) + size), 0);
+
+  *thp = (void *)naya;
+
+  /* let thread run, now */
+#ifdef MZ_PRIVATE_SPAWN_MUTEX
+  qunlock_1(cl->mutex, "scheme_sproc_mutex_up");
+#else
+  sproc_unlock();
+#endif
+
+}
+
+void scheme_sproc_exit_thread()
+{
+  exit(0);
+}
+
+void scheme_sproc_break_thread(void *th)
+{
+  kill((int)th, SIGINT);
+}
+
+Scheme_Process *scheme_sproc_get_current_process()
+{
+  Scheme_Process *p;
+
+  thr_getspecific(cp_key, (void **)&p);
+
+  return p;
+}
+
+void scheme_sproc_set_current_process(Scheme_Process *p)
+{
+  thr_setspecific(cp_key, (void *)p);
+}
+
+void *scheme_sproc_make_semaphore(int v)
+{
+  usema_t *s = usnewsema(semArena, v);
+
+  return (void *)s;
+}
+
+void scheme_sproc_free_semaphore(void *s)
+{
+  usfreesema(s, semArena);
+}
+
+#  ifdef MZ_TASKS
+--> Semaphore/lock routines should be revised
+#  endif
+
+int scheme_sproc_semaphore_up(void *s)
+{
+
+  return !seminc((usema_t *)s,"scheme_sproc_semaphore_up");
+}
+
+int scheme_sproc_semaphore_down_breakable(void *s)
+{
+  return (semdec((sema_t *)s,"scheme_sproc_semaphore_down") == 1);
+}
+
+int scheme_sproc_semaphore_try_down(void *s)
+{
+  return (uscpsema((usema_t *)s) == 1);
+}
+
+void *scheme_sproc_make_mutex()
+{
+  mutex_t *s = usnewlock(semArena);
+
+  return (void *)s;
+}
+
+void scheme_sproc_free_mutex(void *s)
+{
+  usfreelock(s, semArena);
+}
+
+int scheme_sproc_mutex_up(void *s)
+{
+
+  return (!uunlock((mutex_t *)s));
+}
+
+int scheme_sproc_mutex_down_breakable(void *s)
+{
+  return (ulock((mutex_t *)s));
+}
+
+int scheme_sproc_mutex_try_down(void *s)
+{
+  return (utrylock((mutex_t *)s));
+}
+
+#endif /* MZ_USE_IRIX_SPROCS */
+
+/****************************************************************/
+
+/* Special stack handling for GC when multiple stacks are used. */
+/* Must define NO_AUTO_STACK_PUSH for compiling GC */
+
+#ifdef MANUAL_STACK_PUSH
+
+extern void GC_push_all_stack(unsigned long b, unsigned long t);
+extern unsigned long GC_stackbottom;
+
+static void push_process_stack(Scheme_Process *p, unsigned long dummy)
+{
+  unsigned long b, t;
+  
+  if (p == scheme_current_process)
+    t = dummy;
+  else
+    t = (unsigned long)p->stack_current;
+  
+  if (p->next) {
+	 b = (unsigned long)p->stack_start;
+	 if (!b) return; /* process still being initialized */
+  } else
+	 b = GC_stackbottom;
+
+  if (b < t)
+    GC_push_all_stack(b, t);
+  else
+    GC_push_all_stack(t, b);
+}
+
+void GC_push_all_stacks()
+{
+  unsigned long dummy;
+  Scheme_Process *p = NULL;
+
+  dummy = (unsigned long)&dummy;
+
+  if (!leaving_process &&
+		(!scheme_current_process || !scheme_first_process->next)) {
+	 /* Not yet running MzScheme or just one thread: */
+	 if (dummy < GC_stackbottom)
+		GC_push_all_stack(dummy, GC_stackbottom);
+	 else
+		GC_push_all_stack(GC_stackbottom, dummy);
+
+	 return;
+  }
+
+  for (p = scheme_first_process; p; p = p->next)
+	 push_process_stack(p, dummy);
+
+  if (leaving_process)
+	 push_process_stack(leaving_process, dummy);
+}
+
+#endif
+
+#ifndef MZ_REAL_THREADS
+extern GC_push_all_stack(void *, void *);
+static void push_other_stacks(void)
+{
+  Scheme_Process *p;
+  Scheme_Overflow *o;
+  
+  /* Explicitly push saved stacks. This is needed
+     because the saved stack may contain pointers to the
+     interior of collectable objects. */
+
+#define PUSH_JMPUPBUF(b) { if ((b).stack_size) GC_push_all_stack((b).stack_copy, ((char *)(b).stack_copy) + (b).stack_size); }
+
+  p = scheme_first_process;
+  while (p) {
+    if (p != scheme_current_process)
+      PUSH_JMPUPBUF(p->jmpup_buf);
+    for (o = p->overflow; o; o = o->prev)
+      PUSH_JMPUPBUF(o->cont);
+
+    p = p->next;
+  }
+}
+#endif
diff --git a/src/mzscheme/src/promise.c b/src/mzscheme/src/promise.c
new file mode 100644
index 0000000..e43f0f5
--- /dev/null
+++ b/src/mzscheme/src/promise.c
@@ -0,0 +1,159 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+/* globals */
+
+/* locals */
+static Scheme_Object *force(int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_promise(int argc, Scheme_Object *argv[]);
+static Scheme_Object *promise_p(int argc, Scheme_Object *argv[]);
+
+void
+scheme_init_promise (Scheme_Env *env)
+{
+  scheme_add_global_constant("make-promise", 
+			     scheme_make_prim_w_arity(make_promise, 
+						      "make-promise",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("promise?", 
+			     scheme_make_folding_prim(promise_p, 
+						      "promise?",
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant ("force", 
+			      scheme_make_prim_w_arity(force, 
+						       "force",
+						       1, 1), 
+			      env);
+}
+
+static Scheme_Object *
+make_promise_value(Scheme_Object *expr, int is_expr)
+{
+  Scheme_Promise *promise;
+
+  promise = MALLOC_ONE_TAGGED(Scheme_Promise);
+  promise->type = scheme_promise_type;
+  promise->forced = 0;
+  promise->is_expr = is_expr;
+  promise->val = expr;
+  promise->multi_array = NULL;
+
+#ifdef MZ_REAL_THREADS
+  promise->sema = scheme_make_sema(1);
+#endif
+
+  return (Scheme_Object *)promise;
+}
+
+Scheme_Object *
+scheme_make_promise(Scheme_Object *expr, Scheme_Env *env)
+{
+  return make_promise_value(scheme_compile(expr, env, 0), 1);
+}
+
+Scheme_Object *
+scheme_make_promise_value(Scheme_Object *expr)
+{
+  return make_promise_value(expr, 1);
+}
+
+Scheme_Object *
+scheme_make_promise_from_thunk(Scheme_Object *expr)
+{
+  return make_promise_value(expr, 0);
+}
+
+static Scheme_Object *
+make_promise(int argc, Scheme_Object *argv[])
+{
+  scheme_check_proc_arity("make-promise", 0,
+			  0, argc, argv);
+
+  return scheme_make_promise_from_thunk(argv[0]);
+}
+
+static Scheme_Object *
+force (int argc, Scheme_Object *argv[])
+{
+  Scheme_Promise *promise;
+  Scheme_Object *v;
+
+  if (!SCHEME_PROMP(argv[0]))
+    scheme_wrong_type("force", "promise", 0, argc, argv);
+
+  promise = (Scheme_Promise *)argv[0];
+
+#ifdef MZ_REAL_THREADS
+  scheme_wait_sema(promise->sema, 0);
+#endif
+
+  if (!promise->forced) {
+    int is_expr = promise->is_expr;
+    v = promise->val;
+
+#ifdef MZ_REAL_THREADS
+    scheme_post_sema(promise->sema);
+#endif
+
+    if (is_expr)
+      v = _scheme_eval_compiled_expr_multi(v);
+    else
+      v = _scheme_apply_multi(v, 0, NULL);
+
+#ifdef MZ_REAL_THREADS
+    scheme_wait_sema(promise->sema, 0);
+#endif
+
+    if (!promise->forced) {
+      promise->val = v;
+      promise->forced = 1;
+      if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+	promise->multi_count = scheme_multiple_count;
+	promise->multi_array = scheme_multiple_array;
+      }
+    }
+  }
+
+  v = promise->val;
+
+  if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+    scheme_multiple_count = promise->multi_count;
+    scheme_multiple_array = promise->multi_array;
+  }
+
+#ifdef MZ_REAL_THREADS
+  scheme_post_sema(promise->sema);
+#endif
+  
+  return v;
+}
+
+static Scheme_Object *
+promise_p(int argc, Scheme_Object *argv[])
+{
+  return SCHEME_PROMP(argv[0]) ? scheme_true : scheme_false;
+}
diff --git a/src/mzscheme/src/qqsrc.ss b/src/mzscheme/src/qqsrc.ss
new file mode 100644
index 0000000..44f41ab
--- /dev/null
+++ b/src/mzscheme/src/qqsrc.ss
@@ -0,0 +1,90 @@
+
+(define qq
+  (expand-defmacro
+   '(#%define-macro -#%quasiquote
+	(lambda (form)
+	  (let ([normal
+		 (lambda (x old)
+		   (if (#%eq? x old)
+		       (if (#%null? x)
+			   x
+			   (#%list '#%quote x))
+		       x))])
+	    (normal
+	     (let qq ([x form][level 0])
+	       (let ([qq-list
+		      (lambda (x level)
+			(let* ([old-first (#%car x)]
+			       [old-second (#%cdr x)]
+			       [first (qq old-first level)]
+			       [second (qq old-second level)])
+			  (if (and (#%eq? first old-first)
+				   (#%eq? second old-second))
+			      x
+			      (#%list '#%cons 
+				      (normal first old-first)
+				      (normal second old-second)))))])
+		 (#%cond
+		  [(#%pair? x)
+		   (let ([first (#%car x)])
+		     (#%cond
+		      [(and (#%eq? first 'unquote) (#%list? x))
+		       (let ([rest (#%cdr x)])
+			 (if (#%or (#%not (#%pair? rest))
+				   (#%not (#%null? (#%cdr rest))))
+			     (#%raise-syntax-error
+			      'unquote
+			       "takes exactly one expression"
+			       (#%list 'quasiquote form)))
+			 (if (#%zero? level)
+			     (#%car rest)
+			     (qq-list x (#%sub1 level))))]
+		      [(and (#%eq? first 'quasiquote) (#%list? x))
+		       (qq-list x (#%add1 level))]
+		      [(and (#%eq? first 'unquote-splicing) (#%list? x))
+		       (#%raise-syntax-error
+			'unquote-splicing
+			"invalid context within quasiquote"
+			(#%list 'quasiquote form))]
+		      [(and (#%pair? first)
+			    (#%eq? (#%car first) 'unquote-splicing)
+			    (#%list? first))
+		       (let ([rest (#%cdr first)])
+			 (if (or (#%not (#%pair? rest))
+				 (#%not (#%null? (#%cdr rest))))
+			     (#%raise-syntax-error
+			      'unquote-splicing
+			      "takes exactly one expression"
+			      (#%list 'quasiquote form)))
+			 (let ([uqsd (#%car rest)]
+			       [old-l (#%cdr x)]
+			       [l (qq (#%cdr x) level)])
+			   (if (#%zero? level)
+			       (let* ([l (normal l old-l)])
+				 (#%list '#%append uqsd l))
+			       (let* ([restx (qq-list rest (#%sub1 level))])
+				 (if (and (#%eq? l old-l)
+					  (#%eq? restx rest))
+				     x
+				     (#%list '#%cons 
+					     (#%list '#%cons 
+						     (#%list '#%quote 'unquote-splicing)
+						     (normal restx rest))
+					   (normal l old-l)))))))]
+		      [else
+		       (qq-list x level)]))]
+		  [(#%vector? x)
+		   (let* ([l (#%vector->list x)]
+			  [l2 (qq l level)])
+		     (if (#%eq? l l2)
+			 x
+			 (#%list '#%list->vector l2)))]
+		  [(#%box? x)
+		   (let* ([v (#%unbox x)]
+			  [qv (qq v level)])
+		     (if (#%eq? v qv)
+			 x
+			 (#%list '#%box qv)))]
+		  [else x])))
+	     form))))))
+
diff --git a/src/mzscheme/src/ratfloat.inc b/src/mzscheme/src/ratfloat.inc
new file mode 100644
index 0000000..fe729b7
--- /dev/null
+++ b/src/mzscheme/src/ratfloat.inc
@@ -0,0 +1,74 @@
+
+FP_TYPE SCHEME_RATIONAL_TO_FLOAT(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+  FP_TYPE n, d;
+  int ns, ds;
+
+  if (SCHEME_INTP(r->num)) {
+    n = (FP_TYPE)SCHEME_INT_VAL(r->num);
+    ns = 0;
+  } else
+    n = SCHEME_BIGNUM_TO_FLOAT_INF_INFO(r->num, 0, &ns);
+
+  if (SCHEME_INTP(r->denom)) {
+    d = (FP_TYPE)SCHEME_INT_VAL(r->denom);
+    ds = 0;
+  } else
+    d = SCHEME_BIGNUM_TO_FLOAT_INF_INFO(r->denom, 0, &ds);
+
+  if (ns && ds) {
+    /* Dividing now would give NaN. Use ns & ds (number of bignum
+       digits not needed before encountering infinity) to scale num & denom
+       and get a useful value. */
+    int m;
+
+    m = (ns < ds) ? ds : ns;
+
+    n = SCHEME_BIGNUM_TO_FLOAT_INF_INFO(r->num, m, NULL);
+    d = SCHEME_BIGNUM_TO_FLOAT_INF_INFO(r->denom, m, NULL);
+  }
+
+  return n / d;
+}
+
+Scheme_Object *SCHEME_RATIONAL_FROM_FLOAT(FP_TYPE d)
+{
+  double frac, i;
+  int count, exponent, is_neg;
+  Scheme_Object *int_part, *frac_part, *frac_num, *frac_denom, *two;
+
+  SCHEME_CHECK_FLOAT("inexact->exact", d, "rational");
+
+  is_neg = (d < 0);
+
+  frac = modf((double)d, &i);
+  (void)frexp(d, &exponent);
+
+  int_part = SCHEME_BIGNUM_FROM_FLOAT(i);
+
+  if (!frac)
+    return int_part;
+
+  frac_num = scheme_make_integer(0);
+  frac_denom = one;
+  two = scheme_make_integer(2);
+
+  count = 0;
+  while (frac) {
+    count++;
+    frac_num = scheme_bin_mult(frac_num, two);
+    frac_denom = scheme_bin_mult(frac_denom, two);    
+    frac = modf(ldexp(frac, 1), &i);
+    if (i) {
+      if (is_neg)	
+	frac_num = scheme_bin_minus(frac_num, one);
+      else
+	frac_num = scheme_bin_plus(frac_num, one);
+    }
+  }
+
+  frac_part = scheme_bin_div(frac_num, frac_denom);
+
+  return scheme_bin_plus(int_part, frac_part);
+}
diff --git a/src/mzscheme/src/rational.c b/src/mzscheme/src/rational.c
new file mode 100644
index 0000000..4897133
--- /dev/null
+++ b/src/mzscheme/src/rational.c
@@ -0,0 +1,428 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <ctype.h>
+#include <math.h>
+
+static Scheme_Object *one = scheme_make_integer(1);
+
+static Scheme_Object *make_rational(const Scheme_Object *n, const Scheme_Object *d,
+				    int normalize)
+{
+  Scheme_Rational *r;
+
+  r = MALLOC_ONE_TAGGED(Scheme_Rational);
+  r->type = scheme_rational_type;
+  r->num = (Scheme_Object *)n;
+  r->denom = (Scheme_Object *)d;
+  
+  return normalize ? scheme_rational_normalize((Scheme_Object *)r) 
+    : (Scheme_Object *)r;
+}
+
+Scheme_Object *scheme_make_rational(const Scheme_Object *n, const Scheme_Object *d)
+{
+  return make_rational(scheme_bignum_normalize(n), 
+		       scheme_bignum_normalize(d), 1);
+}
+
+Scheme_Object *scheme_integer_to_rational(const Scheme_Object *n)
+{
+  return make_rational(n, one, 0);
+}
+
+Scheme_Object *scheme_make_small_rational(long n, Small_Rational *s)
+{
+  s->type = scheme_rational_type;
+  s->num = scheme_make_integer(n);
+  s->denom = one;
+
+  return (Scheme_Object *)s;
+}
+
+int scheme_is_rational_positive(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+
+  if (SCHEME_INTP(r->num))
+    return (SCHEME_INT_VAL(r->num) > 0);
+  else 
+    return SCHEME_BIGPOS(r->num);
+}
+
+Scheme_Object *scheme_rational_normalize(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+  Scheme_Object *gcd;
+  int negate = 0;
+
+  if (r->num == scheme_make_integer(0))
+    return scheme_make_integer(0);
+
+  if (SCHEME_INTP(r->denom)) {
+    if (SCHEME_INT_VAL(r->denom) < 0) {
+      r->denom = scheme_make_integer(-SCHEME_INT_VAL(r->denom));
+      negate = 1;
+    }
+  } else if (!SCHEME_BIGPOS(r->denom)) {
+    r->denom = scheme_bignum_negate(r->denom);
+    negate = 1;
+  }
+
+  if (negate) {
+    if (SCHEME_INTP(r->num))
+      r->num = scheme_make_integer(-SCHEME_INT_VAL(r->num));
+    else
+      r->num = scheme_bignum_negate(r->num);
+  }
+  
+  if (r->denom == one)
+    return r->num;
+
+  gcd = scheme_bin_gcd(r->num, r->denom);
+
+  if (gcd == one)
+    return (Scheme_Object *)o;
+
+  r->num = scheme_bin_quotient(r->num, gcd);
+  r->denom = scheme_bin_quotient(r->denom, gcd);
+
+  if (r->denom == one)
+    return r->num;
+
+  return (Scheme_Object *)r;
+}
+
+Scheme_Object *scheme_rational_numerator(const Scheme_Object *n)
+{
+  return ((Scheme_Rational *)n)->num;
+}
+
+Scheme_Object *scheme_rational_denominator(const Scheme_Object *n)
+{
+  return ((Scheme_Rational *)n)->denom;
+}
+
+Scheme_Object *scheme_make_fixnum_rational(long n, long d)
+{
+  return scheme_make_rational(scheme_make_integer(n),
+			      scheme_make_integer(d));
+}
+
+int scheme_rational_eq(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Rational *ra = (Scheme_Rational *)a;
+  Scheme_Rational *rb = (Scheme_Rational *)b;
+
+  if (SCHEME_INTP(ra->num) && SCHEME_INTP(rb->num)) {
+    if (ra->num != rb->num)
+      return 0;
+  } else if (SCHEME_BIGNUMP(ra->num) && SCHEME_BIGNUMP(rb->num)) {
+    if (!scheme_bignum_eq(ra->num, rb->num))
+      return 0;
+  } else
+    return 0;
+
+  if (SCHEME_INTP(ra->denom) && SCHEME_INTP(rb->denom)) {
+    if (ra->denom != rb->denom)
+      return 0;
+  } else if (SCHEME_BIGNUMP(ra->denom) && SCHEME_BIGNUMP(rb->denom)) {
+    if (!scheme_bignum_eq(ra->denom, rb->denom))
+      return 0;
+  } else
+    return 0;
+
+  return 1;
+}
+
+int scheme_rational_lt(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Rational *ra = (Scheme_Rational *)a;
+  Scheme_Rational *rb = (Scheme_Rational *)b;
+  Scheme_Object *ma, *mb;
+
+  ma = scheme_bin_mult(ra->num, rb->denom);
+  mb = scheme_bin_mult(rb->num, ra->denom);
+
+  if (SCHEME_INTP(ma) && SCHEME_INTP(mb)) {
+    return (SCHEME_INT_VAL(ma) < SCHEME_INT_VAL(mb));
+  } else if (SCHEME_BIGNUMP(ma) && SCHEME_BIGNUMP(mb)) {
+    return scheme_bignum_lt(ma, mb);
+  } else if (SCHEME_BIGNUMP(mb)) {
+    return SCHEME_BIGPOS(mb);
+  } else
+    return !SCHEME_BIGPOS(ma);
+}
+
+int scheme_rational_gt(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return !scheme_rational_lt(a, b) && !scheme_rational_eq(a, b);
+}
+
+int scheme_rational_le(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return !scheme_rational_gt(a, b);
+}
+
+int scheme_rational_ge(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return !scheme_rational_lt(a, b);
+}
+
+Scheme_Object *scheme_rational_negate(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+
+  return make_rational(scheme_bin_minus(scheme_make_integer(0),
+					r->num), 
+		       r->denom, 0);
+}
+
+Scheme_Object *scheme_rational_add(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Rational *ra = (Scheme_Rational *)a;
+  Scheme_Rational *rb = (Scheme_Rational *)b;
+  Scheme_Object *ac, *bd, *sum, *cd;
+
+  ac = scheme_bin_mult(ra->num, rb->denom);
+  bd = scheme_bin_mult(ra->denom, rb->num);
+  sum = scheme_bin_plus(ac, bd);
+  cd = scheme_bin_mult(ra->denom, rb->denom);
+
+  return scheme_make_rational(sum, cd);
+}
+
+Scheme_Object *scheme_rational_subtract(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_rational_add(a, scheme_rational_negate(b));
+}
+
+Scheme_Object *scheme_rational_add1(const Scheme_Object *n)
+{
+  Small_Rational s;
+
+  return scheme_rational_add(scheme_make_small_rational(1, &s), n);
+}
+
+Scheme_Object *scheme_rational_sub1(const Scheme_Object *n)
+{
+  Small_Rational s;
+
+  return scheme_rational_add(n, scheme_make_small_rational(-1, &s));
+}
+
+Scheme_Object *scheme_rational_multiply(const Scheme_Object *a, const Scheme_Object *b)
+{
+  Scheme_Rational *ra = (Scheme_Rational *)a;
+  Scheme_Rational *rb = (Scheme_Rational *)b;
+  Scheme_Object *ab, *cd;
+
+  ab = scheme_bin_mult(ra->num, rb->num);
+  cd = scheme_bin_mult(ra->denom, rb->denom);
+
+  return scheme_make_rational(ab, cd);  
+}
+
+Scheme_Object *scheme_rational_max(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_rational_normalize(scheme_rational_lt(a, b) ? b : a);
+}
+
+Scheme_Object *scheme_rational_min(const Scheme_Object *a, const Scheme_Object *b)
+{
+  return scheme_rational_normalize(scheme_rational_lt(a, b) ? a : b);
+}
+
+Scheme_Object *scheme_rational_divide(const Scheme_Object *n, const Scheme_Object *d)
+{ 
+  Scheme_Rational *rd = (Scheme_Rational *)d, d_inv;
+  
+  d_inv.type = scheme_rational_type;
+  d_inv.denom = rd->num;
+  d_inv.num = rd->denom;
+
+  return scheme_rational_multiply(n, (Scheme_Object *)&d_inv);
+}
+
+Scheme_Object *scheme_generic_power(const Scheme_Object *o, const Scheme_Object *p)
+{
+  Scheme_Object *r = one, *zero = scheme_make_integer(0);
+  Scheme_Object *two = scheme_make_integer(2);
+  char *bitstream;
+  int bs_size = 0, bs_alloc = 10;
+
+  bitstream = (char *)scheme_malloc_atomic(bs_alloc);
+
+  while (p != zero) {
+    if (bs_size >= bs_alloc) {
+      char *old = bitstream;
+
+      bs_alloc *= 2;
+      bitstream = (char *)scheme_malloc_atomic(bs_alloc);
+      memcpy(bitstream, old, bs_size);
+    }
+
+    if (SCHEME_TRUEP(scheme_odd_p(1, (Scheme_Object **)&p))) {
+      bitstream[bs_size] = 1;
+      p = scheme_sub1(1, (Scheme_Object **)&p);
+    } else
+      bitstream[bs_size] = 0;
+
+    bs_size++;
+    p = scheme_bin_quotient(p, two);
+  }
+
+  while (bs_size--) {
+    r = scheme_bin_mult(r, r);
+    if (bitstream[bs_size])
+      r = scheme_bin_mult(r, o);
+  }
+
+  return r;
+}
+
+Scheme_Object *scheme_rational_power(const Scheme_Object *o, const Scheme_Object *p)
+{
+  double b, e;
+
+  if (((Scheme_Rational *)p)->denom == one)
+    return scheme_generic_power(o, ((Scheme_Rational *)p)->num);
+
+  b = scheme_rational_to_double(o);
+  e = scheme_rational_to_double(p);
+
+  return scheme_make_double(pow(b, e));
+}
+
+Scheme_Object *scheme_rational_truncate(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+
+  return scheme_bin_quotient(r->num, r->denom);
+}
+
+Scheme_Object *scheme_rational_floor(const Scheme_Object *o)
+{
+  if (scheme_is_rational_positive(o))
+    return scheme_rational_truncate(o);
+  else {
+    Scheme_Object *r = scheme_rational_truncate(o);
+    return scheme_sub1(1, &r);
+  }
+}
+
+Scheme_Object *scheme_rational_ceiling(const Scheme_Object *o)
+{
+  if (!scheme_is_rational_positive(o))
+    return scheme_rational_truncate(o);
+  else {
+    Scheme_Object *r = scheme_rational_truncate(o);
+    return scheme_add1(1, &r);
+  }  
+}
+
+Scheme_Object *scheme_rational_round(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+  Scheme_Object *q, *qd, *delta, *half;
+  int more = 0, can_eq_half, negative;
+
+  negative = !scheme_is_rational_positive(o);
+  
+  q = scheme_bin_quotient(r->num, r->denom);
+
+  /* Get remainder absolute value: */
+  qd = scheme_bin_mult(q, r->denom);
+  if (negative)
+    delta = scheme_bin_minus(qd, r->num);
+  else
+    delta = scheme_bin_minus(r->num, qd);
+
+  half = scheme_bin_quotient(r->denom, scheme_make_integer(2));
+  can_eq_half = SCHEME_FALSEP(scheme_odd_p(1, &r->denom));
+
+  if (SCHEME_INTP(half) && SCHEME_INTP(delta)) {
+    if (can_eq_half && (SCHEME_INT_VAL(delta) == SCHEME_INT_VAL(half)))
+      more = SCHEME_TRUEP(scheme_odd_p(1, &q));
+    else
+      more = (SCHEME_INT_VAL(delta) > SCHEME_INT_VAL(half));
+  } else if (SCHEME_BIGNUMP(delta) && SCHEME_BIGNUMP(half)) {
+    if (can_eq_half && (scheme_bignum_eq(delta, half)))
+      more = SCHEME_TRUEP(scheme_odd_p(1, &q));      
+    else
+      more = !scheme_bignum_lt(delta, half);
+  } else
+    more = SCHEME_BIGNUMP(delta);
+
+  if (more) {
+    if (negative)
+      q = scheme_sub1(1, &q);
+    else
+      q = scheme_add1(1, &q);      
+  }
+
+  return q;
+}
+
+
+Scheme_Object *scheme_rational_sqrt(const Scheme_Object *o)
+{
+  Scheme_Rational *r = (Scheme_Rational *)o;
+  Scheme_Object *n, *d;
+
+  n = scheme_integer_sqrt(r->num);
+  if (!SCHEME_DBLP(n)) {
+    d = scheme_integer_sqrt(r->denom);
+    if (!SCHEME_DBLP(d))
+      return make_rational(n, d, 0);
+  }
+
+  return scheme_make_double(sqrt(scheme_rational_to_float(o)));
+}
+
+#define FP_TYPE double
+#define SCHEME_RATIONAL_TO_FLOAT scheme_rational_to_double
+#define SCHEME_RATIONAL_FROM_FLOAT scheme_rational_from_double
+#define SCHEME_BIGNUM_TO_FLOAT_INF_INFO scheme_bignum_to_double_inf_info
+#define SCHEME_CHECK_FLOAT scheme_check_double
+#define SCHEME_BIGNUM_FROM_FLOAT scheme_bignum_from_double
+#include "ratfloat.inc"
+
+#ifdef MZ_USE_SINGLE_FLOATS
+# undef FP_TYPE
+# undef SCHEME_RATIONAL_TO_FLOAT
+# undef SCHEME_RATIONAL_FROM_FLOAT
+# undef SCHEME_BIGNUM_TO_FLOAT_INF_INFO
+# undef SCHEME_BIGNUM_FROM_FLOAT
+# undef SCHEME_CHECK_FLOAT
+
+#define FP_TYPE float
+#define SCHEME_RATIONAL_TO_FLOAT scheme_rational_to_float
+#define SCHEME_RATIONAL_FROM_FLOAT scheme_rational_from_float
+#define SCHEME_BIGNUM_TO_FLOAT_INF_INFO scheme_bignum_to_float_inf_info
+#define SCHEME_CHECK_FLOAT scheme_check_float
+#define SCHEME_BIGNUM_FROM_FLOAT scheme_bignum_from_float
+#include "ratfloat.inc"
+#endif
+
diff --git a/src/mzscheme/src/read.c b/src/mzscheme/src/read.c
new file mode 100644
index 0000000..8d14d46
--- /dev/null
+++ b/src/mzscheme/src/read.c
@@ -0,0 +1,1868 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include "schmach.h"
+#include "schcpt.h"
+#include <stdlib.h>
+#include <ctype.h>
+#ifdef USE_STACKAVAIL
+#include <malloc.h>
+#endif
+
+#define MAX_NUMBER_SIZE 500
+#define MAX_SYMBOL_SIZE 255
+
+int scheme_square_brackets_are_parens = 1;
+int scheme_curly_braces_are_parens = 1;
+
+/* local function prototypes */
+
+static Scheme_Object *read_case_sensitive(int, Scheme_Object *[]);
+static Scheme_Object *read_bracket_as_paren(int, Scheme_Object *[]);
+static Scheme_Object *read_brace_as_paren(int, Scheme_Object *[]);
+static Scheme_Object *read_accept_graph(int, Scheme_Object *[]);
+static Scheme_Object *read_accept_compiled(int, Scheme_Object *[]);
+static Scheme_Object *read_accept_box(int, Scheme_Object *[]);
+static Scheme_Object *read_accept_type_symbol(int, Scheme_Object *[]);
+static Scheme_Object *read_accept_pipe_quote(int, Scheme_Object *[]);
+static Scheme_Object *print_graph(int, Scheme_Object *[]);
+static Scheme_Object *print_struct(int, Scheme_Object *[]);
+static Scheme_Object *print_box(int, Scheme_Object *[]);
+
+#ifndef MZ_REAL_THREADS
+#define CURRENTPROCPRM /* empty */
+#define CURRENTPROCARG /* empty */
+#else
+#define CURRENTPROCPRM , Scheme_Process *p
+#define CURRENTPROCARG , p
+#endif
+
+static Scheme_Object *read_list(Scheme_Object *port, char closer,
+				int vec, int use_stack,
+				Scheme_Hash_Table **ht 
+				CURRENTPROCPRM);
+static Scheme_Object *read_string(Scheme_Object *port CURRENTPROCPRM);
+static Scheme_Object *read_quote(Scheme_Object *port,
+				 Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_vector(Scheme_Object *port, char closer, 
+				  long reqLen, const char *reqBuffer,
+				  Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_type_symbol(Scheme_Object *port CURRENTPROCPRM);
+static Scheme_Object *read_number(Scheme_Object *port, int, int, int, int 
+				  CURRENTPROCPRM);
+static Scheme_Object *read_symbol(Scheme_Object *port, int type_symbol 
+				  CURRENTPROCPRM);
+static Scheme_Object *read_character(Scheme_Object *port CURRENTPROCPRM);
+static Scheme_Object *read_quasiquote(Scheme_Object *port,
+				      Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_unquote(Scheme_Object *port,
+				   Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_unquote_splicing(Scheme_Object *port,
+					    Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_box(Scheme_Object *port,
+			       Scheme_Hash_Table **ht CURRENTPROCPRM);
+static Scheme_Object *read_compiled(Scheme_Object *port,
+				    Scheme_Hash_Table **ht CURRENTPROCPRM);
+
+static int skip_whitespace_comments(Scheme_Object *port);
+static int peek_char(Scheme_Object *port);
+
+#ifndef MZ_REAL_THREADS
+#define local_can_read_type_symbol (scheme_current_process->quick_can_read_type_symbol)
+#define local_can_read_compiled (scheme_current_process->quick_can_read_compiled)
+#define local_can_read_pipe_quote (scheme_current_process->quick_can_read_pipe_quote)
+#define local_can_read_box (scheme_current_process->quick_can_read_box)
+#define local_can_read_graph (scheme_current_process->quick_can_read_graph)
+#define local_case_sensitive (scheme_current_process->quick_case_sens)
+#define local_square_brackets_are_parens (scheme_current_process->quick_square_brackets_are_parens)
+#define local_curly_braces_are_parens (scheme_current_process->quick_curly_braces_are_parens)
+
+#define local_list_stack (scheme_current_process->list_stack)
+#define local_list_stack_pos (scheme_current_process->list_stack_pos)
+#else
+#define local_can_read_type_symbol (p->quick_can_read_type_symbol)
+#define local_can_read_compiled (p->quick_can_read_compiled)
+#define local_can_read_pipe_quote (p->quick_can_read_pipe_quote)
+#define local_can_read_box (p->quick_can_read_box)
+#define local_can_read_graph (p->quick_can_read_graph)
+#define local_case_sensitive (p->quick_case_sens)
+#define local_square_brackets_are_parens (p->quick_square_brackets_are_parens)
+#define local_curly_braces_are_parens (p->quick_curly_braces_are_parens)
+
+#define local_list_stack (p->list_stack)
+#define local_list_stack_pos (p->list_stack_pos)
+#endif
+
+#define NUM_CELLS_PER_STACK 500
+
+typedef struct {
+  int pos;
+  Scheme_Object *stack;
+} ListStackRec;
+
+#define STACK_START(r) (r.pos = local_list_stack_pos, r.stack = local_list_stack)
+#define STACK_END(r) (local_list_stack_pos = r.pos, local_list_stack = r.stack)
+
+static Scheme_Object *quote_symbol;
+static Scheme_Object *quasiquote_symbol;
+static Scheme_Object *unquote_symbol;
+static Scheme_Object *unquote_splicing_symbol;
+
+static Scheme_Object **variable_references;
+
+void scheme_init_read(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(variable_references);
+
+    REGISTER_SO(quote_symbol);
+    REGISTER_SO(quasiquote_symbol);
+    REGISTER_SO(unquote_symbol);
+    REGISTER_SO(unquote_splicing_symbol);
+    
+    quote_symbol = scheme_intern_symbol("quote");
+    quasiquote_symbol = scheme_intern_symbol("quasiquote");
+    unquote_symbol = scheme_intern_symbol("unquote");
+    unquote_splicing_symbol = scheme_intern_symbol("unquote-splicing");
+  }
+
+  scheme_add_global_constant("read-case-sensitive", 
+			     scheme_register_parameter(read_case_sensitive, 
+						       "read-case-sensitive",
+						       MZCONFIG_CASE_SENS), 
+			     env);
+  scheme_add_global_constant("read-square-bracket-as-paren", 
+			     scheme_register_parameter(read_bracket_as_paren, 
+						       "read-square-bracket-as-paren",
+						       MZCONFIG_SQUARE_BRACKETS_ARE_PARENS), 
+			     env);
+  scheme_add_global_constant("read-curly-brace-as-paren", 
+			     scheme_register_parameter(read_brace_as_paren, 
+						       "read-curly-brace-as-paren",
+						       MZCONFIG_CURLY_BRACES_ARE_PARENS), 
+			     env);
+  scheme_add_global_constant("read-accept-graph", 
+			     scheme_register_parameter(read_accept_graph, 
+						       "read-accept-graph",
+						       MZCONFIG_CAN_READ_GRAPH), 
+			     env);
+  scheme_add_global_constant("read-accept-compiled", 
+			     scheme_register_parameter(read_accept_compiled, 
+						       "read-accept-compiled",
+						       MZCONFIG_CAN_READ_COMPILED), 
+			     env);
+  scheme_add_global_constant("read-accept-box", 
+			     scheme_register_parameter(read_accept_box, 
+						       "read-accept-box",
+						       MZCONFIG_CAN_READ_BOX), 
+			     env);
+  scheme_add_global_constant("read-accept-type-symbol", 
+			     scheme_register_parameter(read_accept_type_symbol, 
+						       "read-accept-type-symbol",
+						       MZCONFIG_CAN_READ_TYPE_SYMBOL), 
+			     env);
+  scheme_add_global_constant("read-accept-bar-quote",
+			     scheme_register_parameter(read_accept_pipe_quote,
+						       "read-accept-bar-quote",
+						       MZCONFIG_CAN_READ_PIPE_QUOTE), 
+			     env);
+  scheme_add_global_constant("print-graph", 
+			     scheme_register_parameter(print_graph, 
+						       "print-graph",
+						       MZCONFIG_PRINT_GRAPH), 
+			     env);
+  scheme_add_global_constant("print-struct", 
+			     scheme_register_parameter(print_struct, 
+						       "print-struct",
+						       MZCONFIG_PRINT_STRUCT), 
+			     env);
+  scheme_add_global_constant("print-box", 
+			     scheme_register_parameter(print_box, 
+						       "print-box",
+						       MZCONFIG_PRINT_BOX), 
+			     env);
+}
+
+void scheme_alloc_list_stack(Scheme_Process *process)
+{
+  process->list_stack_pos = 0;
+  process->list_stack = (Scheme_Object *)scheme_malloc(NUM_CELLS_PER_STACK
+						       * sizeof(Scheme_Object));
+}
+
+#define DO_CHAR_PARAM(name, pos) \
+  return scheme_param_config(name, pos, argc, argv, -1, NULL, NULL, 1)
+
+static Scheme_Object *
+read_case_sensitive(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-case-sensitive", MZCONFIG_CASE_SENS);
+}
+
+static Scheme_Object *
+read_bracket_as_paren(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-square-bracket-as-paren", MZCONFIG_SQUARE_BRACKETS_ARE_PARENS);
+}
+
+static Scheme_Object *
+read_brace_as_paren(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-curly-brace-as-paren", MZCONFIG_CURLY_BRACES_ARE_PARENS);
+}
+
+static Scheme_Object *
+read_accept_graph(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-accept-graph", MZCONFIG_CAN_READ_GRAPH);
+}
+
+static Scheme_Object *
+read_accept_compiled(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-accept-compiled", MZCONFIG_CAN_READ_COMPILED);
+}
+
+static Scheme_Object *
+read_accept_box(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-accept-box", MZCONFIG_CAN_READ_BOX);
+}
+
+static Scheme_Object *
+read_accept_type_symbol(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-accept-type-symbol", MZCONFIG_CAN_READ_TYPE_SYMBOL);
+}
+
+static Scheme_Object *
+read_accept_pipe_quote(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("read-accept-pipe-quote", MZCONFIG_CAN_READ_PIPE_QUOTE);
+}
+
+static Scheme_Object *
+print_graph(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("print-graph", MZCONFIG_PRINT_GRAPH);
+}
+
+static Scheme_Object *
+print_struct(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("print-struct", MZCONFIG_PRINT_STRUCT);
+}
+
+static Scheme_Object *
+print_box(int argc, Scheme_Object *argv[])
+{
+  DO_CHAR_PARAM("print-box", MZCONFIG_PRINT_BOX);
+}
+
+#ifdef DO_STACK_CHECK
+
+static Scheme_Object *scheme_read_inner(Scheme_Object *port, Scheme_Hash_Table **ht 
+					CURRENTPROCPRM);
+
+static Scheme_Object *read_k(void)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *o = (Scheme_Object *)p->ku.k.p1;
+  Scheme_Hash_Table **ht = (Scheme_Hash_Table **)p->ku.k.p2;
+
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+
+  return scheme_read_inner(o, 
+			   ht
+#ifdef MZ_REAL_THREADS
+			   , p
+#endif
+			   );
+}
+#endif
+
+#define MAX_GRAPH_ID_DIGITS 8
+
+static Scheme_Object *
+scheme_read_inner(Scheme_Object *port, Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  int ch, ch2, depth;
+
+
+#ifdef DO_STACK_CHECK
+  {
+#include "mzstkchk.h"
+    {
+#ifndef ERROR_ON_OVERFLOW
+#ifndef MZ_REAL_THREADS
+      Scheme_Process *p = scheme_current_process;
+#endif
+      p->ku.k.p1 = (void *)port;
+      p->ku.k.p2 = (void *)ht;
+#endif
+      return scheme_handle_stack_overflow(read_k);
+    }
+  }
+#endif
+
+ start_over:
+
+  ch = scheme_getc(port);
+  while (isspace(ch))
+    ch = scheme_getc(port);
+
+  switch ( ch )
+    {
+    case EOF: return (scheme_eof);
+    case ']': 
+      if (!local_square_brackets_are_parens) {
+	scheme_ungetc(ch, port);
+	return read_symbol(port, 0 CURRENTPROCARG);
+      }
+    case '}': 
+      if (!local_curly_braces_are_parens) {
+	scheme_ungetc(ch, port);
+	return read_symbol(port, 0 CURRENTPROCARG);
+      }
+    case ')': 
+      scheme_raise_exn(MZEXN_READ_PAREN,
+		       port,
+		       "read: unexpected '%c' at %ld, "
+		       "line %ld in %s", 
+		       (unsigned char)ch,
+		       scheme_tell(port),
+		       scheme_tell_line(port), 
+		       SCHEME_IPORT_NAME(port));
+    case '(': 
+      return read_list(port, ')', 0, 0, ht CURRENTPROCARG);
+    case '[': 
+      if (!local_square_brackets_are_parens) {
+	scheme_ungetc(ch, port);
+	return read_symbol(port, 0 CURRENTPROCARG);
+      } else
+	return read_list(port, ']', 0, 0, ht CURRENTPROCARG);
+    case '{': 
+      if (!local_curly_braces_are_parens) {
+	scheme_ungetc(ch, port);
+	return read_symbol(port, 0 CURRENTPROCARG);
+      } else
+	return read_list(port, '}', 0, 0, ht CURRENTPROCARG);
+    case '"': return read_string(port CURRENTPROCARG);
+    case '\'': return read_quote(port, ht CURRENTPROCARG);
+    case '`': return read_quasiquote(port, ht CURRENTPROCARG);
+    case ',':
+      if (peek_char(port) == '@') {
+	ch = scheme_getc(port);
+	return read_unquote_splicing(port, ht CURRENTPROCARG);
+      } else
+	return read_unquote(port, ht CURRENTPROCARG);
+    case ';':
+      while (((ch = scheme_getc(port)) != '\n') && (ch != '\r')) {
+	if (ch == EOF)
+	  return scheme_eof;
+      }
+      goto start_over;
+    case '+':
+    case '-':
+    case '.':
+      ch2 = peek_char(port);
+      if (isdigit(ch2) || (ch2 == '.') 
+	  || (ch2 == 'i') || (ch2 == 'I') /* Maybe inf */
+	  || (ch2 == 'n') || (ch2 == 'N') /* Maybe nan*/ ) {
+	scheme_ungetc(ch, port);
+	return read_number(port, 0, 0, 10, 0 CURRENTPROCARG);
+      } else {
+	scheme_ungetc(ch, port);
+	return read_symbol(port, 0 CURRENTPROCARG);
+      }
+    case '#':
+      ch = scheme_getc(port);
+      switch ( ch )
+	{
+	case '%':
+	  scheme_ungetc('%', port);
+	  scheme_ungetc('#', port);
+	  return read_symbol(port, 0 CURRENTPROCARG);
+	case '<': 
+	  if (local_can_read_type_symbol)
+	    return read_type_symbol(port CURRENTPROCARG);
+	  else
+	    scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			     port,
+			     scheme_make_string("<"),
+			     "read: #< expressions not currently enabled");
+	case '(': return read_vector(port, ')', -1, NULL, ht CURRENTPROCARG);
+	case '[': 
+	  if (!local_square_brackets_are_parens) {
+	    scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			     port,
+			     scheme_make_string("["),
+			     "read: bad syntax `#[' at position %ld, "
+			     "line %ld in %s",
+			     scheme_tell(port),
+			     scheme_tell_line(port),
+			     SCHEME_IPORT_NAME(port));
+	    return NULL;
+	  } else
+	    return read_vector(port, ']', -1, NULL, ht CURRENTPROCARG);
+	case '{': 
+	  if (!local_curly_braces_are_parens) {
+	    scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			     port,
+			     scheme_make_string("["),
+			     "read: bad syntax `#[' at position %ld, "
+			     "line %ld in %s",
+			     scheme_tell(port),
+			     scheme_tell_line(port),
+			     SCHEME_IPORT_NAME(port));
+	    return NULL;
+	  } else
+	    return read_vector(port, '}', -1, NULL, ht CURRENTPROCARG);
+	case '\\': return read_character(port CURRENTPROCARG);
+	case 'T':
+	case 't': return scheme_true;
+	case 'F':
+	case 'f': return scheme_false;
+	case 'X':
+	case 'x': return read_number(port, 0, 0, 16, 1 CURRENTPROCARG);
+	case 'B':
+	case 'b': return read_number(port, 0, 0, 2, 1 CURRENTPROCARG);
+	case 'O':
+	case 'o': return read_number(port, 0, 0, 8, 1 CURRENTPROCARG);
+	case 'D':
+	case 'd': return read_number(port, 0, 0, 10, 1 CURRENTPROCARG);
+	case 'E':
+	case 'e': return read_number(port, 0, 1, 10, 0 CURRENTPROCARG);
+	case 'I':
+	case 'i': return read_number(port, 1, 0, 10, 0 CURRENTPROCARG);
+	case '`': 
+	  if (local_can_read_compiled)
+	    return read_compiled(port, ht CURRENTPROCARG);
+	  else
+	    scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			     port,
+			     scheme_make_string("`"),
+			     "read: #` expressions not currently enabled");
+	case '|':
+	  depth = 0;
+	  ch2 = 0;
+	  do {
+	    ch = scheme_getc(port);
+	    if (ch == EOF)
+	      scheme_raise_exn(MZEXN_READ_EOF,
+			       port,
+			       scheme_make_string("|#"),
+			       "read: end of file in #| comment");
+	    if ((ch2 == '|') && (ch == '#')) {
+	      if (!(depth--))
+		goto start_over;
+	    } else if ((ch2 == '#') && (ch == '|'))
+	      depth++;
+	    ch2 = ch;
+	  } while (1);
+	  break;
+	case '&':
+	  if (local_can_read_box)
+	    return read_box(port, ht CURRENTPROCARG);
+	  else {
+	    scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			     port,
+			     scheme_make_string("&"),
+			     "read: #& expressions not currently enabled");
+	    return scheme_void;
+	  }
+	default:
+	  {
+	    int vector_length = -1;
+	    int i = 0, overflow = 0, digits = 0;
+	    char buffer[100]; /* just for errors */
+	    
+	    while (isdigit(ch)) {
+	      if (digits <= MAX_GRAPH_ID_DIGITS)
+		digits++;
+
+	      if (!overflow) {
+		long old_len;
+
+		if (i || (ch != '0') || (digits < MAX_GRAPH_ID_DIGITS))
+		  buffer[i++] = ch;
+
+		if (vector_length < 0)
+		  vector_length = 0;
+	      
+		old_len = vector_length;
+		vector_length = (vector_length * 10) + (ch - 48);
+		if ((vector_length / 10) != old_len) {
+		  buffer[i++] = '.';
+		  buffer[i++] = '.';
+		  buffer[i++] = '.';
+		  buffer[i] = 0;
+		  overflow = 1;
+		}
+	      }
+	      ch = scheme_getc(port);
+	    }
+
+	    if (overflow)
+	      vector_length = -2;
+	    else
+	      buffer[i] = 0;
+
+	    if (ch == '(')
+	      return read_vector(port, ')', vector_length, buffer, ht CURRENTPROCARG);
+	    if (ch == '[' && local_square_brackets_are_parens)
+	      return read_vector(port, ']', vector_length, buffer, ht CURRENTPROCARG);
+	    if (ch == '{' && local_curly_braces_are_parens)
+	      return read_vector(port, '}', vector_length, buffer, ht CURRENTPROCARG);
+	    
+	    if (ch == '#' && (vector_length >= 0)) {
+	      /* Not a vector after all: a graph reference */
+	      Scheme_Object *ph;
+	      
+	      if (!local_can_read_graph)
+		scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+				 port,
+				 scheme_make_string("..#"),
+				 "read: #..# expressions not currently enabled");
+	      
+	      if (digits > MAX_GRAPH_ID_DIGITS)
+		scheme_raise_exn(MZEXN_READ_GRAPH,
+				 port,
+				 "read: graph id too long in #%s#",
+				 buffer);
+	    
+	      if (*ht)
+		ph = (Scheme_Object *)scheme_lookup_in_table(*ht, 
+							     (const char *)vector_length);
+	      else
+		ph = NULL;
+	      
+	      if (!ph) {
+		scheme_raise_exn(MZEXN_READ_GRAPH,
+				 port,
+				 "read: no #%ld= for #%ld#",
+				 vector_length, vector_length);
+		return scheme_void;
+	      }
+	      return ph;
+	    }
+	    if (ch == '=' && (vector_length >= 0)) {
+	      /* Not a vector after all: a graph definition */
+	      Scheme_Object *v, *ph;
+	      
+	      if (!local_can_read_graph)
+		scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+				 port,
+				 scheme_make_string("..="),
+				 "read: #..= expressions not currently enabled");
+	      
+	      if (digits > MAX_GRAPH_ID_DIGITS)
+		scheme_raise_exn(MZEXN_READ_GRAPH,
+				 port,
+				 "read: graph id too long in #%s=",
+				 buffer);
+	      
+	      if (*ht) {
+		if (scheme_lookup_in_table(*ht, (const char *)vector_length)) {
+		  scheme_raise_exn(MZEXN_READ_GRAPH,
+				   port,
+				   "read: multiple #%ld= tags",
+				   vector_length);
+		  return scheme_void;
+		}
+	      } else
+		*ht = scheme_hash_table(100, SCHEME_hash_ptr, 0, 0);
+	      ph = scheme_alloc_small_object();
+	      ph->type = scheme_placeholder_type;
+	      
+	      scheme_add_to_table(*ht, (const char *)vector_length, 
+				  (void *)ph, 0);
+	      
+	      SCHEME_PTR_VAL(ph) = v = scheme_read_inner(port, ht CURRENTPROCARG);
+	      
+	      return v;
+	    }
+	  
+	    {
+	      char lbuffer[200];
+	      
+	      if (ch == EOF)
+		ch = 0;
+	      
+	      if (vector_length < 0) {
+		lbuffer[0] = ch;
+		lbuffer[1] = 0;
+	      } else
+		sprintf(lbuffer, "%s%c", buffer, ch);
+	      
+	      scheme_raise_exn(MZEXN_READ_UNSUPPORTED,
+			       port,
+			       scheme_make_string(buffer),
+			       "read: bad syntax `#%s' at position %ld, "
+			       "line %ld in %s",
+			       lbuffer,
+			       scheme_tell(port),
+			       scheme_tell_line(port),
+			       SCHEME_IPORT_NAME(port));
+
+	      return NULL;
+	    }
+	  }
+	}
+    default:
+      scheme_ungetc(ch, port);
+      if (isdigit (ch))
+	return read_number(port, 0, 0, 10, 0 CURRENTPROCARG);
+      else
+	return read_symbol(port, 0 CURRENTPROCARG);
+    }
+}
+
+static Scheme_Object *resolve_references(Scheme_Object *obj, 
+					 Scheme_Object *port,
+					 Scheme_Hash_Table *ht)
+{
+  Scheme_Object *start = obj;
+
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_placeholder_type)) {
+    obj = (Scheme_Object *)SCHEME_PTR_VAL(obj);
+    while (SAME_TYPE(SCHEME_TYPE(obj), scheme_placeholder_type)) {
+      if (SAME_OBJ(start, obj)) {
+	scheme_raise_exn(MZEXN_READ_GRAPH,
+			 port,
+			 "read: illegal cycle");
+	return scheme_void;
+      }
+      obj = (Scheme_Object *)SCHEME_PTR_VAL(obj);
+    }
+    return obj;
+  }
+
+  if (SCHEME_PAIRP(obj)) {
+    SCHEME_CAR(obj) = resolve_references(SCHEME_CAR(obj), port, ht);
+    SCHEME_CDR(obj) = resolve_references(SCHEME_CDR(obj), port, ht);
+  } else if (SCHEME_BOXP(obj)) {
+    SCHEME_BOX_VAL(obj) = resolve_references(SCHEME_BOX_VAL(obj), port, ht);
+  } else if (SCHEME_VECTORP(obj)) {
+    int i, len;
+    Scheme_Object **array;
+
+    len = SCHEME_VEC_SIZE(obj);
+    array = SCHEME_VEC_ELS(obj);
+    for (i = 0; i < len; i++)
+      array[i] = resolve_references(array[i], port, ht);
+  }
+
+  return obj;
+}
+
+Scheme_Object *
+scheme_internal_read(Scheme_Object *port, int crc, Scheme_Config *config CURRENTPROCPRM)
+{
+  Scheme_Object *v;
+  Scheme_Hash_Table *ht = NULL;
+
+  local_can_read_type_symbol = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CAN_READ_TYPE_SYMBOL));
+  local_can_read_compiled = crc;
+  local_can_read_pipe_quote = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CAN_READ_PIPE_QUOTE));
+  local_can_read_box = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CAN_READ_BOX));
+  local_can_read_graph = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CAN_READ_GRAPH));
+  local_case_sensitive = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CASE_SENS));
+  local_square_brackets_are_parens = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_SQUARE_BRACKETS_ARE_PARENS));
+  local_curly_braces_are_parens = SCHEME_TRUEP(scheme_get_param(config, MZCONFIG_CURLY_BRACES_ARE_PARENS));
+
+  v = scheme_read_inner(port, &ht CURRENTPROCARG);
+
+  if (ht) {
+    /* Resolve placeholders: */
+    v = resolve_references(v, port, ht);
+  }
+
+  return v;
+}
+
+static void *scheme_internal_read_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *port = (Scheme_Object *)p->ku.k.p1;
+
+  p->ku.k.p1 = NULL;
+
+  return (void *)scheme_internal_read(port, local_can_read_compiled,
+				      scheme_current_process->config
+				      CURRENTPROCARG);
+}
+
+Scheme_Object *
+scheme_read(Scheme_Object *port)
+{
+  Scheme_Process *p = scheme_current_process;
+
+  local_can_read_compiled = SCHEME_TRUEP(scheme_get_param(scheme_config, 
+							  MZCONFIG_CAN_READ_COMPILED));
+
+  p->ku.k.p1 = (void *)port;
+  return (Scheme_Object *)scheme_top_level_do(scheme_internal_read_k);
+}
+
+/* "(" has already been read */
+static Scheme_Object *
+read_list(Scheme_Object *port, char closer, int vec, int use_stack,
+	  Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  Scheme_Object *list = NULL, *last = NULL, *car, *cdr, *pair;
+  int ch, next;
+  int brackets = local_square_brackets_are_parens;
+  int braces = local_curly_braces_are_parens;
+  long start, startline;
+
+  start = scheme_tell(port);
+  startline = scheme_tell_line(port);
+
+  while (1) {
+    ch = skip_whitespace_comments(port);
+    if (ch == EOF) {
+      char s[2];
+      s[0] = closer;
+      s[1] = 0;
+      scheme_raise_exn(MZEXN_READ_EOF,
+		       port,
+		       scheme_make_string(s),
+		       "read: expected a '%c'; started at "
+		       "position %ld, line %ld in %s", closer, start, 
+		       startline, SCHEME_IPORT_NAME(port));
+    }
+
+    if (ch == closer)
+      return list ? list : scheme_null;
+
+    scheme_ungetc(ch, port);
+    car = scheme_read_inner(port, ht CURRENTPROCARG);
+
+    if (use_stack) {
+      if (local_list_stack_pos >= NUM_CELLS_PER_STACK) {
+	/* Overflow */
+	local_list_stack_pos = 0;
+	local_list_stack = (Scheme_Object *)scheme_malloc(NUM_CELLS_PER_STACK
+							  * sizeof(Scheme_Object));
+      }
+
+      pair = local_list_stack + (local_list_stack_pos++);
+      pair->type = scheme_pair_type;
+      pair->u.pair_val.car = car;
+      pair->u.pair_val.cdr = scheme_null;
+    } else
+      pair = scheme_make_pair(car, scheme_null);
+
+    ch = skip_whitespace_comments(port);
+    if (ch == closer) {
+      cdr = pair;
+      if (!list)
+	list = cdr;
+      else
+	SCHEME_CDR(last) = cdr;
+      return list;
+    } else if ((ch == '.')
+	       && (next = peek_char(port),
+		   (isspace(next)
+		    || (next == '(')
+		    || (next == ')')
+		    || (next == '"')
+		    || (next == ';')
+		    || (next == '\'')
+		    || (next == '`')
+		    || (next == ',')
+		    || ((next == '[') && brackets)
+		    || ((next == '{') && braces)
+		    || ((next == ']') && brackets)
+		    || ((next == '}') && braces)))) {
+      if (vec)
+	scheme_raise_exn(MZEXN_READ_DOT,
+			 port,
+			 "read: illegal use of \".\" at position %ld line %ld in %s",
+			 scheme_tell(port), scheme_tell_line(port), SCHEME_IPORT_NAME(port));
+      cdr = scheme_read_inner(port, ht CURRENTPROCARG);
+      ch = skip_whitespace_comments (port);
+      if (ch != closer)
+	scheme_raise_exn(MZEXN_READ_DOT,
+			 port,
+			 "read: illegal use of \".\" at position %ld line %ld in %s",
+			 scheme_tell(port), scheme_tell_line(port), SCHEME_IPORT_NAME(port));
+      SCHEME_CDR(pair) = cdr;
+      cdr = pair;
+      if (!list)
+	list = cdr;
+      else
+	SCHEME_CDR(last) = cdr;
+      return list;
+    } else {
+      scheme_ungetc(ch, port);
+      cdr = pair;
+      if (!list)
+	list = cdr;
+      else
+	SCHEME_CDR(last) = cdr;
+      last = cdr;
+    }
+  }
+}
+
+/* '"' has already been read */
+static Scheme_Object *
+read_string(Scheme_Object *port CURRENTPROCPRM)
+{
+  char *buf, *oldbuf, onstack[32];
+  int i, ch;
+  long start, startline;
+  long size = 31, oldsize;
+
+  i = 0;
+  start = scheme_tell(port);
+  startline = scheme_tell_line(port);
+  buf = onstack;
+  while ((ch = scheme_getc (port)) != '"') {
+    if (ch == EOF)
+      scheme_raise_exn(MZEXN_READ_EOF,
+		       port,
+		       scheme_make_string("\""),
+		       "read: expected a '\"'; started at position %ld"
+		       ", line %ld in %s", 
+		       start, startline, SCHEME_IPORT_NAME(port));
+    if (ch == '\\')
+      ch = scheme_getc (port);
+
+    if (i >= size)
+      { 
+	oldsize = size;
+	oldbuf = buf;
+
+	size *= 2;
+	buf = (char *)scheme_malloc_atomic(size + 1);
+	memcpy(buf, oldbuf, oldsize);
+      }
+    buf[i++] = ch;
+  }
+  buf[i] = '\0';
+
+  return scheme_make_sized_string(buf, i, i <= 31);
+}
+
+/* "'" has been read */
+static Scheme_Object *
+read_quote(Scheme_Object *port, Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  Scheme_Object *obj;
+
+  obj = scheme_read_inner(port, ht CURRENTPROCARG);
+  return (scheme_make_pair(quote_symbol, 
+			   scheme_make_pair(obj, scheme_null)));
+}
+
+/* "#(" has been read */
+static Scheme_Object *
+read_vector (Scheme_Object *port, char closer, 
+	     long requestLength, const char *reqBuffer,
+	     Scheme_Hash_Table **ht CURRENTPROCPRM)
+/* requestLength == -1 => no request
+   requestLength == -2 => overflow */
+{
+  Scheme_Object *obj, *vec, **els;
+  int len, i;
+  ListStackRec r;
+
+  STACK_START(r);
+  obj = read_list(port, closer, 1, 1, ht CURRENTPROCARG);
+  STACK_END(r);
+
+  if (requestLength == -2) {
+    scheme_raise_out_of_memory("read", "making vector of size %s", reqBuffer);
+    return NULL;
+  }
+
+  len = scheme_list_length(obj);
+  if (requestLength >= 0 && len > requestLength) {
+    char buffer[20];
+    sprintf(buffer, "%ld", requestLength);
+    scheme_raise_exn(MZEXN_READ_VECTOR_LENGTH,
+		     port,
+		     scheme_make_string(buffer),
+		     "read: vector length %ld is too small, "
+		     "%d values provided",
+		     requestLength, len);
+  }
+  if (requestLength < 0)
+    requestLength = len;
+  vec = scheme_make_vector(requestLength, NULL);
+  els = SCHEME_VEC_ELS(vec);
+  for (i = 0; i < len ; i++) {
+    els[i] = SCHEME_CAR(obj);
+    obj = SCHEME_CDR(obj);
+  }
+  if (i < requestLength) {
+    if (len)
+      obj = els[len - 1];
+    else
+      obj = scheme_make_integer(0);
+    for (; i < requestLength; i++)
+      els[i] = obj;
+  }
+  return (vec);
+}
+
+/* nothing has been read, except maybe some flags */
+static Scheme_Object  *
+read_number_or_symbol(Scheme_Object *port, int is_float, int is_not_float, 
+		      int radix, int radix_set, 
+		      int is_symbol, int type_symbol, int pipe_quote CURRENTPROCPRM)
+{
+  char *buf, *oldbuf, onstack[MAX_SYMBOL_SIZE];
+  int size, oldsize;
+  int nvdeep = 0;
+  int i, ch, quoted, quoted_ever = 0, running_quote = 0;
+  int rq_pos = 0, rq_line = 0;
+  int case_sens = local_case_sensitive;
+  int brackets = local_square_brackets_are_parens;
+  int braces = local_curly_braces_are_parens;
+  Scheme_Object *o;
+
+  i = 0;
+  size = MAX_SYMBOL_SIZE - 1;
+  buf = onstack;
+
+  while (((ch = scheme_getc (port)) != EOF)
+	 && (running_quote
+	     || ((!isspace(ch) || (type_symbol && (ch == ' ')))
+		 && (ch != '(')
+		 && (ch != ')')
+		 && (ch != '"')
+		 && (ch != ';')
+		 && (ch != '\'')
+		 && (ch != '`')
+		 && (ch != ',')
+		 && ((ch != '[') || !brackets)
+		 && ((ch != '{') || !braces)
+		 && ((ch != ']') || !brackets)
+		 && ((ch != '}') || !braces)
+		 && (!type_symbol || ch != '>' || nvdeep)))) {
+    if (ch == '\\' && !running_quote) {
+      ch = scheme_getc(port);
+      if (ch == EOF) {
+	scheme_raise_exn(MZEXN_READ_EOF,
+			 port,
+			 scheme_make_string("\\"),
+			 "read: EOF following \"\\\"");
+	return scheme_void;
+      }
+      quoted = 1;
+      quoted_ever = 1;
+    } else if (ch == '|' && pipe_quote) {
+      quoted_ever = 1;
+      running_quote = !running_quote;
+      quoted = 0;
+
+      rq_pos = scheme_tell(port);
+      rq_line = scheme_tell_line(port);
+
+      continue;
+    } else 
+      quoted = 0;
+
+    if (i >= size) {
+      oldsize = size;
+      oldbuf = buf;
+      
+      size *= 2;
+      buf = (char *)scheme_malloc_atomic(size + 1);
+      memcpy(buf, oldbuf, oldsize);
+    }
+
+    if (!case_sens)
+      ch = tolower(ch);
+
+    buf[i++] = ch;
+
+#if TSYM_BALANCE_BRAC
+    /* MzScheme 46: brackets are no longer balanced. */
+    if (type_symbol) {
+      if (ch == '>' && !quoted && !running_quote)
+	--nvdeep;
+      else if (ch == '<' && !quoted && !running_quote)
+	nvdeep++;
+    }
+#endif
+  }
+
+  if (ch != EOF)
+    scheme_ungetc(ch, port);
+
+  if (running_quote) {
+    scheme_raise_exn(MZEXN_READ_EOF,
+		     port,
+		     scheme_make_string("|"),
+		     "read: unbalanced `|' at %d, line %d",
+		     rq_pos, rq_line);
+    return scheme_void;
+  }
+
+  buf[i] = '\0';
+
+  if (!quoted_ever && (i == 1) && (buf[0] == '.')) {
+    scheme_raise_exn(MZEXN_READ_DOT,
+		     port,
+		     "read: illegal use of \".\" at position %ld line %ld in %s",
+		     scheme_tell(port), scheme_tell_line(port), SCHEME_IPORT_NAME(port));
+    return NULL;
+  }
+
+  if ((is_symbol || quoted_ever) && !is_float && !is_not_float && !radix_set)
+    o = scheme_false;
+  else
+    o = scheme_read_number(buf, i, is_float, is_not_float, radix, radix_set,
+			   port, NULL);
+
+  if (SAME_OBJ(o, scheme_false)) {
+#ifdef NO_SEPARATE_HASH_PRECENT
+    if ((buf[0] == '#') && (buf[1] == '%')) {
+      Scheme_Object *v = scheme_intern_exact_symbol(buf + 2, i - 2);
+      buf[0] = 0; /* just keeps buf ptr for GC */
+      return v;
+    } else
+#endif
+      return scheme_intern_exact_symbol(buf, i);
+  } else
+    return o;
+}
+
+static Scheme_Object  *
+read_number(Scheme_Object *port, int is_float, int is_not_float, 
+	    int radix, int radix_set CURRENTPROCPRM)
+{
+  return read_number_or_symbol(port, is_float, is_not_float,
+			       radix, radix_set, 0, 0,
+			       local_can_read_pipe_quote
+			       CURRENTPROCARG);
+}
+
+static Scheme_Object  *
+read_symbol(Scheme_Object *port, int type_symbol CURRENTPROCPRM)
+{
+  return read_number_or_symbol(port, 0, 0, 10, 0, 1, type_symbol, 
+			       (type_symbol || local_can_read_pipe_quote)
+			       CURRENTPROCARG);
+}
+
+/* '#<' has been read */
+static Scheme_Object *read_type_symbol(Scheme_Object *port CURRENTPROCPRM)
+{
+  Scheme_Object *sym;
+  long pos, l;
+
+  pos = scheme_tell(port);
+  l = scheme_tell_line(port);
+
+  sym = read_symbol(port, 1 CURRENTPROCARG);
+  if (scheme_getc(port) != '>')
+    scheme_raise_exn(MZEXN_READ_EOF,
+		     port,
+		     scheme_make_string(">"),
+		     "read: expected a `>'; started "
+		     "at %ld, line %ld in %s",
+		     pos, l, SCHEME_IPORT_NAME(port));
+
+  return scheme_intern_type_symbol(sym);
+}
+
+/* "#\" has been read */
+static Scheme_Object *
+read_character(Scheme_Object *port CURRENTPROCPRM)
+{
+  int ch, next;
+
+  ch = scheme_getc(port);
+  next = peek_char(port);
+  
+  if ((ch >= '0' && ch <= '7') && (next >= '0' && next <= '7')) {
+    /* a is the same as next */
+    int last = (scheme_getc(port), scheme_getc(port));
+
+    if (last < '0' || last > '7' || ch > '3') {
+      char buffer[4];
+      buffer[0] = ch;
+      buffer[1] = next;
+      buffer[2] = last;
+      buffer[3] = 0;
+      scheme_raise_exn(MZEXN_READ_CHAR,
+		       port,
+		       scheme_make_string(buffer),
+		       "read: bad character constant #\\%c%c%c",
+		       ch, next, last);
+      return scheme_void;
+    }
+
+    ch = ((ch - '0') << 6) + ((next - '0') << 3) + (last - '0');
+
+    return scheme_make_char(ch);
+  }
+
+  if (isalpha(next)) {
+    char *buf, *oldbuf, onstack[32];
+    int i;
+    long size = 31, oldsize;
+
+    i = 1;
+    buf = onstack;
+    buf[0] = tolower(ch);
+    while (isalpha(ch = scheme_getc(port))) {
+      if (i >= size) {
+	oldsize = size;
+	oldbuf = buf;
+	
+	size *= 2;
+	buf = (char *)scheme_malloc_atomic(size + 1);
+	memcpy(buf, oldbuf, oldsize);
+      }
+      buf[i++] = tolower(ch);
+    }
+    if (ch != EOF)
+      scheme_ungetc(ch, port);
+    buf[i] = '\0';
+    
+    switch (buf[0]) {
+    case 'n': /* maybe `newline' or 'null' or 'nul' */
+      if (!strcmp(buf, "newline"))
+	return scheme_make_char('\n');
+      if (!strcmp(buf, "null") || !strcmp(buf, "nul"))
+	return scheme_make_char('\0');
+      break;
+    case 's': /* maybe `space' */
+      if (!strcmp(buf, "space"))
+	return scheme_make_char(' ');
+      break;
+    case 'r': /* maybe `rubout' or `return' */
+      if (!strcmp(buf, "rubout"))
+	return scheme_make_char(0x7f);
+      if (!strcmp(buf, "return"))
+	return scheme_make_char('\r');
+      break;
+    case 'p': /* maybe `page' */
+      if (!strcmp(buf, "page"))
+	return scheme_make_char('\f');
+      break;
+    case 't': /* maybe `tab' */
+      if (!strcmp(buf, "tab"))
+	return scheme_make_char('\t');
+      break;
+    case 'v': /* maybe `vtab' */
+      if (!strcmp(buf, "vtab"))
+	return scheme_make_char(0xb);
+      break;
+    case 'b': /* maybe `backspace' */
+      if (!strcmp(buf, "backspace"))
+	return scheme_make_char('\b');
+      break;
+    case 'l': /* maybe `linefeed' */
+      if (!strcmp(buf, "linefeed"))
+	return scheme_make_char('\n');
+      break;
+    default:
+      break;
+    }
+
+    scheme_raise_exn(MZEXN_READ_CHAR,
+		     port,
+		     scheme_make_string(buf),
+		     "read: bad character constant: #\\%s",
+		     buf);
+  }
+
+  if (ch == EOF) {
+    long pos = scheme_tell(port);
+    long l = scheme_tell_line(port);
+
+    scheme_raise_exn(MZEXN_READ_EOF,
+		     port,
+		     scheme_make_string("<character>"),
+		     "read: expected a character after #\\"
+		     " at %ld, line %ld in %s",
+		     pos, l, SCHEME_IPORT_NAME(port));
+  }
+
+  return scheme_make_char(ch);
+}
+
+/* "`" has been read */
+static Scheme_Object *
+read_quasiquote(Scheme_Object *port, Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  Scheme_Object *quoted_obj, *ret;
+  
+  quoted_obj = scheme_read_inner(port, ht CURRENTPROCARG);
+  ret = scheme_make_pair(quasiquote_symbol, 
+			 scheme_make_pair (quoted_obj, scheme_null));
+  return (ret);
+}
+
+/* "," has been read */
+static Scheme_Object *
+read_unquote(Scheme_Object *port, Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  Scheme_Object *obj, *ret;
+
+  obj = scheme_read_inner(port, ht CURRENTPROCARG);
+  ret = scheme_make_pair(unquote_symbol, 
+			 scheme_make_pair (obj, scheme_null));
+  return (ret);
+}
+
+/* ",@" has been read */
+static Scheme_Object *
+read_unquote_splicing(Scheme_Object *port, Scheme_Hash_Table **ht CURRENTPROCPRM)
+{
+  Scheme_Object *obj, *ret;
+
+  obj = scheme_read_inner(port, ht CURRENTPROCARG);
+  ret = scheme_make_pair(unquote_splicing_symbol, 
+			 scheme_make_pair (obj, scheme_null));
+  return (ret);
+}
+
+/* "#&" has been read */
+static Scheme_Object *read_box(Scheme_Object *port, Scheme_Hash_Table **ht
+			       CURRENTPROCPRM)
+{
+  Scheme_Object *o;
+
+  o = scheme_read_inner(port, ht CURRENTPROCARG);
+  
+  return scheme_box(o);
+}
+
+/* utilities */
+
+static int
+skip_whitespace_comments(Scheme_Object *port)
+{
+  int ch;
+
+ start_over:
+
+  while (isspace(ch = scheme_getc (port)));
+
+  if (ch == ';') {
+    do
+      ch = scheme_getc (port);
+    while (ch != '\n' && ch != '\r' && ch != EOF);
+    goto start_over;
+  }
+  if (ch == '#' && (peek_char(port) == '|')) {
+    int depth = 0;
+    int ch2 = 0;
+    (void)scheme_getc(port); /* re-read '|' */
+    do {
+      ch = scheme_getc(port);
+      if (ch == EOF)
+	scheme_raise_exn(MZEXN_READ_EOF,
+			 port,
+			 scheme_make_string("|#"),
+			 "read: end of file in #| comment");
+      if ((ch2 == '|') && (ch == '#')) {
+	if (!(depth--))
+	  goto start_over;
+      } else if ((ch2 == '#') && (ch == '|'))
+	depth++;
+      ch2 = ch;
+    } while (1);
+
+    goto start_over;
+  }
+
+  return ch;
+}
+
+static int
+peek_char (Scheme_Object *port)
+{
+  int ch;
+
+  ch = scheme_getc (port);
+  scheme_ungetc (ch, port);
+  return (ch);
+}
+
+/************************************************************************/
+
+#define USE_BUFFERING_CPORT 1
+
+#if USE_BUFFERING_CPORT
+typedef struct CPort {
+  unsigned char *s;
+  unsigned char *start;
+  long base;
+} CPort;
+#define CP_GETC(cp) ((int)*(cp->s++))
+#define CP_TELL(port) (port->s - port->start + port->base)
+#else
+typedef Scheme_Object CPort;
+#define CP_GETC(cp) scheme_getc(cp)
+#define CP_TELL(port) scheme_tell(port)
+#endif
+
+static Scheme_Object *read_marshalled(int type,
+				      CPort *port,
+				      Scheme_Hash_Table **ht
+				      CURRENTPROCPRM);
+static Scheme_Object *read_compact_list(int c, int proper, int use_stack,
+					CPort *port, 
+					Scheme_Hash_Table **ht
+					CURRENTPROCPRM);
+static Scheme_Object *read_compact_quote(CPort *port,
+					 int embedded
+					 CURRENTPROCPRM);
+
+static int read_compact_number(CPort *port)
+{
+  int flag, v, a, b, c, d;
+
+  flag = CP_GETC(port);
+
+  if (flag < 253)
+    return flag;
+  if (flag == 254)
+    return -CP_GETC(port);
+  
+  a = CP_GETC(port);
+  b = CP_GETC(port);
+  c = CP_GETC(port);
+  d = CP_GETC(port);
+
+  v = a
+    + (b << 8)
+    + (c << 16)
+    + (d << 24);
+  
+  if (flag == 253)
+    return v;
+  else
+    return -v;
+}
+
+static char *read_compact_chars(CPort *port, 
+				char *buffer, 
+				int bsize, int l)
+{
+  char *s, *src;
+  int i;
+
+  if (l < bsize)
+    s = buffer;
+  else
+    s = (char *)scheme_malloc_atomic(l + 1);
+
+#if USE_BUFFERING_CPORT
+  src = (char *)port->s;
+  for (i = 0; i < l; i++)
+    s[i] = src[i];
+  port->s += l;
+#else
+  for (i = 0; i < l; i++)
+    s[i] = CP_GETC(port);
+#endif
+
+  s[l] = 0;
+
+  return s;
+}
+
+static Scheme_Object *read_compact_svector(CPort *port, int l)
+{
+  Scheme_Object *o;
+  short *v;
+
+  o = scheme_alloc_object();
+  SCHEME_SVEC_LEN(o) = l;
+  if (l)
+    v = MALLOC_N(short, l);
+  else
+    v = NULL;
+  SCHEME_SVEC_VEC(o) = v;
+
+  while (l--) {
+    v[l] = read_compact_number(port);
+  }
+
+  return o;
+}
+
+static int cpt_branch[256];
+
+static Scheme_Object *read_compact(CPort *port, 
+				   Scheme_Hash_Table **ht,
+				   int use_stack
+				   CURRENTPROCPRM)
+{
+#define BLK_BUF_SIZE 32
+  int ch;
+  int l;
+  char *s, buffer[BLK_BUF_SIZE];
+  int need_car = 0, proper = 0;
+  Scheme_Object *v, *first = NULL, *last = NULL;
+
+  while (1) {
+    ch = CP_GETC(port);
+    switch(cpt_branch[ch]) {
+    case CPT_ESCAPE:
+      {
+	int len = read_compact_number(port);
+	Scheme_Object *ep;
+	char *s;
+
+#if USE_BUFFERING_CPORT
+	s = (char *)port->s;
+	port->s += len;
+#else
+	s = read_compact_chars(port, NULL, 0, len);
+#endif
+
+	ep = scheme_make_sized_string_input_port(s, len);
+
+	v = scheme_read_inner(ep, ht CURRENTPROCARG);
+      }
+      break;
+    case CPT_SYMBOL:
+      l = read_compact_number(port);
+      s = read_compact_chars(port, buffer, BLK_BUF_SIZE, l);
+      v = scheme_intern_exact_symbol(s, l);
+      break;
+    case CPT_STRING:
+      l = read_compact_number(port);
+      s = read_compact_chars(port, buffer, BLK_BUF_SIZE, l);
+      v = scheme_make_sized_string(s, l, l < BLK_BUF_SIZE);
+      break;
+    case CPT_CHAR:
+      v = scheme_make_character(CP_GETC(port));
+      break;
+    case CPT_INT:
+      v = scheme_make_integer(read_compact_number(port));
+      break;
+    case CPT_NULL:
+      v = scheme_null;
+      break;
+    case CPT_TRUE:
+      v = scheme_true;
+      break;
+    case CPT_FALSE:
+      v = scheme_false;
+      break;
+    case CPT_BOX:
+      v = scheme_box(read_compact(port, ht, 0 CURRENTPROCARG));
+      break;
+    case CPT_PAIR:
+      if (need_car) {
+	Scheme_Object *car, *cdr;
+	car = read_compact(port, ht, 0 CURRENTPROCARG);
+	cdr = read_compact(port, ht, 0 CURRENTPROCARG);
+	v = scheme_make_pair(car, cdr);
+      } else {
+	need_car = 1;
+	continue;
+      }
+      break;
+    case CPT_LIST:
+      l = read_compact_number(port);
+      if (need_car) {
+	if (l == 1) {
+	  Scheme_Object *car, *cdr;
+	  car = read_compact(port, ht, 0 CURRENTPROCARG);
+	  cdr = read_compact(port, ht, 0 CURRENTPROCARG);
+	  v = scheme_make_pair(car, cdr);
+	} else
+	  v = read_compact_list(l, 0, 0, port, ht CURRENTPROCARG);
+      } else {
+	need_car = l;
+	continue;
+      }
+      break;
+    case CPT_VECTOR: 
+      {
+	Scheme_Object *vec, **els;
+	int i;
+
+	l = read_compact_number(port);
+	vec = scheme_make_vector(l, NULL);
+	els = SCHEME_VEC_ELS(vec);
+      
+	for (i = 0; i < l; i++)
+	  els[i] = read_compact(port, ht, 0 CURRENTPROCARG);
+
+	v = vec;
+      }
+      break;
+    case CPT_MARSHALLED:
+      v = read_marshalled(read_compact_number(port), port, ht 
+			  CURRENTPROCARG);
+      break;
+    case CPT_QUOTE:
+      v = read_compact_quote(port, 1 CURRENTPROCARG);
+      break;
+    case CPT_REFERENCE:
+      l = read_compact_number(port);
+      v = variable_references[l];
+      break;
+    case CPT_LOCAL:
+      {
+	int p;
+	p = read_compact_number(port);
+	v = scheme_make_local(scheme_local_type, p);
+      }
+      break;
+    case CPT_LOCAL_UNBOX:
+      {
+	int p;
+	p = read_compact_number(port);
+	v = scheme_make_local(scheme_local_unbox_type, p);
+      }
+      break;
+    case CPT_SVECTOR: 
+      {
+	int l;
+	l = read_compact_number(port);
+	v = read_compact_svector(port, l);
+      }
+      break;
+    case CPT_APPLICATION:
+      {
+	int c;
+	Scheme_Object *l;
+	ListStackRec r;
+
+	c = read_compact_number(port) + 1;
+	STACK_START(r);
+	l = read_compact_list(c, 1, 1, port, ht CURRENTPROCARG);
+	STACK_END(r);
+  
+	v = ((scheme_type_readers)[scheme_application_type])(l);
+      }
+      break;
+    case CPT_SMALL_LOCAL_START:
+    case CPT_SMALL_LOCAL_UNBOX_START:
+      {
+	Scheme_Type type;
+	int k;
+	
+	if (CPT_BETWEEN(ch, SMALL_LOCAL_UNBOX)) {
+	  k = 1;
+	  type = scheme_local_unbox_type;
+	  ch -= CPT_SMALL_LOCAL_UNBOX_START;
+	} else {
+	  k = 0;
+	  type = scheme_local_type;
+	  ch -= CPT_SMALL_LOCAL_START;
+	}
+	if (ch < MAX_CONST_LOCAL_POS)
+	  v = scheme_local[ch][k];
+	else
+	  v = scheme_make_local(type, ch);
+      }
+      break;
+    case CPT_SMALL_MARSHALLED_START:
+      {
+	l = ch - CPT_SMALL_MARSHALLED_START;
+	v = read_marshalled(l, port, ht CURRENTPROCARG);
+      }
+      break;
+    case CPT_SMALL_SYMBOL_START:
+      {
+	l = ch - CPT_SMALL_SYMBOL_START;
+	s = read_compact_chars(port, buffer, BLK_BUF_SIZE, l);
+	v = scheme_intern_exact_symbol(s, l);
+      }
+      break;
+    case CPT_SMALL_NUMBER_START:
+      {
+	l = ch - CPT_SMALL_NUMBER_START;
+	v = scheme_make_integer(l);
+      }
+      break;
+    case CPT_SMALL_SVECTOR_START:
+      {
+	l = ch - CPT_SMALL_SVECTOR_START;
+	v = read_compact_svector(port, l);
+      }
+      break;
+    case CPT_SMALL_PROPER_LIST_START:
+    case CPT_SMALL_LIST_START:
+      {
+	int ppr = CPT_BETWEEN(ch, SMALL_PROPER_LIST);
+	l = ch - (ppr ? CPT_SMALL_PROPER_LIST_START : CPT_SMALL_LIST_START);
+      	if (need_car) {
+	  if (l == 1) {
+	    Scheme_Object *car = read_compact(port, ht, 0 CURRENTPROCARG);
+	    v = scheme_make_pair(car,
+				 ppr 
+				 ? scheme_null
+				 : read_compact(port, ht, 0 CURRENTPROCARG));
+	  } else
+	    v = read_compact_list(l, ppr, /* use_stack */ 0, port, ht CURRENTPROCARG);
+	} else {
+	  proper = ppr;
+	  need_car = l;
+	  continue;
+	}  
+      }
+      break;
+    case CPT_SMALL_APPLICATION_START:
+      {
+	int c;
+	Scheme_Object *l;
+	ListStackRec r;
+
+	c = (ch - CPT_SMALL_APPLICATION_START) + 1;
+	STACK_START(r);
+	l = read_compact_list(c, 1, 1, port, ht CURRENTPROCARG);
+	STACK_END(r);
+	v = ((scheme_type_readers)[scheme_application_type])(l);
+      }
+      break;
+    default:
+      {
+	v = NULL;
+	scheme_raise_exn(MZEXN_READ_COMPILED,
+			 port,
+			 "read (compiled): bad #` contents: %d at %ld", ch,
+			 CP_TELL(port));
+      }
+    }
+
+    if (need_car) {
+      Scheme_Object *pair;
+
+      if (use_stack) {
+	if (local_list_stack_pos >= NUM_CELLS_PER_STACK) {
+	  /* Overflow */
+	  local_list_stack_pos = 0;
+	  local_list_stack = (Scheme_Object *)scheme_malloc(NUM_CELLS_PER_STACK
+							    * sizeof(Scheme_Object));
+	}
+	
+	pair = local_list_stack + (local_list_stack_pos++);
+	pair->type = scheme_pair_type;
+	pair->u.pair_val.car = v;
+	pair->u.pair_val.cdr = scheme_null;
+      } else
+	pair = scheme_make_pair(v, scheme_null);
+
+      if (last)
+	SCHEME_CDR(last) = pair;
+      else
+	first = pair;
+      last = pair;
+      --need_car;
+      if (!need_car && proper)
+	break;
+    } else {
+      if (last)
+	SCHEME_CDR(last) = v;
+      break;
+    }
+  }
+
+  return first ? first : v;
+}
+
+static Scheme_Object *read_compact_list(int c, int proper, int use_stack,
+					CPort *port, 
+					Scheme_Hash_Table **ht
+					CURRENTPROCPRM)
+{
+  Scheme_Object *v, *first, *last, *pair;
+
+  v = read_compact(port, ht, 0 CURRENTPROCARG);
+  if (use_stack) {
+    if (local_list_stack_pos >= NUM_CELLS_PER_STACK) {
+      /* Overflow */
+      local_list_stack_pos = 0;
+      local_list_stack = (Scheme_Object *)scheme_malloc(NUM_CELLS_PER_STACK
+							* sizeof(Scheme_Object));
+    }
+    
+    last = local_list_stack + (local_list_stack_pos++);
+    last->type = scheme_pair_type;
+    last->u.pair_val.car = v;
+    last->u.pair_val.cdr = scheme_null;
+  } else
+    last = scheme_make_pair(v, scheme_null);
+
+  first = last;
+
+  while (--c) {
+    v = read_compact(port, ht, 0 CURRENTPROCARG);
+
+    if (use_stack) {
+      if (local_list_stack_pos >= NUM_CELLS_PER_STACK) {
+	/* Overflow */
+	local_list_stack_pos = 0;
+	local_list_stack = (Scheme_Object *)scheme_malloc(NUM_CELLS_PER_STACK
+							  * sizeof(Scheme_Object));
+      }
+      
+      pair = local_list_stack + (local_list_stack_pos++);
+      pair->type = scheme_pair_type;
+      pair->u.pair_val.car = v;
+      pair->u.pair_val.cdr = scheme_null;
+    } else
+      pair = scheme_make_pair(v, scheme_null);
+
+    SCHEME_CDR(last) = pair;
+    last = pair;
+  }
+
+  if (!proper) {
+    v = read_compact(port, ht, 0 CURRENTPROCARG);
+    SCHEME_CDR(last) = v;
+  }
+
+  return first;
+}
+
+static Scheme_Object *read_compact_quote(CPort *port,
+					 int embedded
+					 CURRENTPROCPRM)
+{
+  Scheme_Hash_Table *q_ht;
+  Scheme_Object *v;
+
+  /* Use a new hash table. A compiled quoted form may have graph
+     structure, but only local graph structure is allowed. */
+  q_ht = NULL;
+  v = read_compact(port, &q_ht, 0 CURRENTPROCARG);
+
+  if (q_ht)
+    resolve_references(v, NULL, q_ht);
+  
+  return v;
+}
+
+static Scheme_Object *read_marshalled(int type,
+				      CPort *port,
+				      Scheme_Hash_Table **ht
+				      CURRENTPROCPRM)
+{
+  Scheme_Object *l;
+  ListStackRec r;
+
+  STACK_START(r);
+  l = read_compact(port, ht, 1 CURRENTPROCARG);
+  STACK_END(r);
+
+  if (!scheme_type_readers[type])
+      scheme_raise_exn(MZEXN_READ_COMPILED,
+		       port,
+		       "read (compiled): bad #` type number: %d at %ld",
+		       type, CP_TELL(port));
+
+  return scheme_type_readers[type](l);
+}
+
+#if USE_BUFFERING_CPORT
+static int read_compact_number_from_port(Scheme_Object *port)
+{
+  int flag, v, a, b, c, d;
+
+  flag = scheme_getc(port);
+
+  if (flag < 253)
+    return flag;
+  if (flag == 254)
+    return -scheme_getc(port);
+  
+  a = scheme_getc(port);
+  b = scheme_getc(port);
+  c = scheme_getc(port);
+  d = scheme_getc(port);
+
+  v = a
+    + (b << 8)
+    + (c << 16)
+    + (d << 24);
+  
+  if (flag == 253)
+    return v;
+  else
+    return -v;
+}
+#else
+#define read_compact_number_from_port read_compact_number
+#endif
+
+/* "#`" has been read */
+static Scheme_Object *read_compiled(Scheme_Object *port, 
+				    Scheme_Hash_Table **ht
+				    CURRENTPROCPRM)
+{
+#if USE_BUFFERING_CPORT
+  CPort cp;
+#endif
+  CPort *rp;
+  long size, got;
+
+  if (!cpt_branch[1]) {
+    int i;
+
+    for (i = 0; i < 256; i++)
+      cpt_branch[i] = i;
+
+#define FILL_IN(v) \
+    for (i = CPT_ ## v ## _START; i < CPT_ ## v ## _END; i++) \
+      cpt_branch[i] = CPT_ ## v ## _START;
+    FILL_IN(SMALL_NUMBER);
+    FILL_IN(SMALL_SYMBOL);
+    FILL_IN(SMALL_MARSHALLED);
+    FILL_IN(SMALL_LIST);
+    FILL_IN(SMALL_PROPER_LIST);
+    FILL_IN(SMALL_LOCAL);
+    FILL_IN(SMALL_LOCAL_UNBOX);
+    FILL_IN(SMALL_SVECTOR);
+    FILL_IN(SMALL_APPLICATION);
+  }
+
+  if (!variable_references)
+    variable_references = scheme_make_builtin_references_table();
+
+  size = read_compact_number_from_port(port);
+#if USE_BUFFERING_CPORT
+  cp.s = cp.start = (unsigned char *)scheme_malloc_atomic(size);
+  cp.base = scheme_tell(port);
+  if ((got = scheme_get_chars(port, size, (char *)cp.s)) != size)
+    scheme_raise_exn(MZEXN_READ_COMPILED,
+		     port,
+		     "read (compiled): bad count: %ld != %ld",
+		     got, size);
+  rp = &cp;
+#else
+  rp = port;
+#endif
+
+  return read_marshalled(scheme_compilation_top_type, rp, ht CURRENTPROCARG);
+}
diff --git a/src/mzscheme/src/regexp.c b/src/mzscheme/src/regexp.c
new file mode 100644
index 0000000..13bc52c
--- /dev/null
+++ b/src/mzscheme/src/regexp.c
@@ -0,0 +1,1483 @@
+/*
+ * regcomp and regexec -- regsub and regerror are elsewhere
+ * @(#)regexp.c	1.3 of 18 April 87
+ *
+ *	Copyright (c) 1986 by University of Toronto.
+ *	Written by Henry Spencer.  Not derived from licensed software.
+ *
+ *	Permission is granted to anyone to use this software for any
+ *	purpose on any computer system, and to redistribute it freely,
+ *	subject to the following restrictions:
+ *
+ *	1. The author is not responsible for the consequences of use of
+ *		this software, no matter how awful, even if they arise
+ *		from defects in it.
+ *
+ *	2. The origin of this software must not be misrepresented, either
+ *		by explicit claim or by omission.
+ *
+ *	3. Altered versions must be plainly marked as such, and must not
+ *		be misrepresented as being the original software.
+ *
+ * Beware that some of this code is subtly aware of the way operator
+ * precedence is structured in regular expressions.  Serious changes in
+ * regular-expression syntax might require a total rethink.
+ */
+
+#include "schpriv.h"
+
+#ifndef NO_REGEXP_UTILS
+
+#include <stdio.h>
+#include <string.h>
+
+typedef struct regexp {
+  Scheme_Type type;
+  long nsubexp;
+  char **startp;
+  char **endp;
+  char regstart;		/* Internal use only. */
+  char reganch;			/* Internal use only. */
+  char *regmust;		/* Internal use only. */
+  long regmlen;			/* Internal use only. */
+  char program[1];		/* Unwarranted chumminess with compiler. */
+} regexp;
+
+static regexp *regcomp(char *);
+static int regexec(regexp *, char *);
+
+#define MAGIC   0234
+
+static Scheme_Type regexp_type;
+
+/*
+ * The "internal use only" fields in regexp.h are present to pass info from
+ * compile to execute that permits the execute phase to run lots faster on
+ * simple cases.  They are:
+ *
+ * regstart	char that must begin a match; '\0' if none obvious
+ * reganch	is the match anchored (at beginning-of-line only)?
+ * regmust	string (pointer into program) that match must include, or NULL
+ * regmlen	length of regmust string
+ *
+ * Regstart and reganch permit very fast decisions on suitable starting points
+ * for a match, cutting down the work a lot.  Regmust permits fast rejection
+ * of lines that cannot possibly match.  The regmust tests are costly enough
+ * that regcomp() supplies a regmust only if the r.e. contains something
+ * potentially expensive (at present, the only such thing detected is * or +
+ * at the start of the r.e., which can involve a lot of backup).  Regmlen is
+ * supplied because the test in regexec() needs it and regcomp() is computing
+ * it anyway.
+ */
+
+/*
+ * Structure for regexp "program".  This is essentially a linear encoding
+ * of a nondeterministic finite-state machine (aka syntax charts or
+ * "railroad normal form" in parsing technology).  Each node is an opcode
+ * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
+ * all nodes except BRANCH implement concatenation; a "next" pointer with
+ * a BRANCH on both ends of it is connecting two alternatives.  (Here we
+ * have one of the subtle syntax dependencies:  an individual BRANCH (as
+ * opposed to a collection of them) is never concatenated with anything
+ * because of operator precedence.)  The operand of some types of node is
+ * a literal string; for others, it is a node leading into a sub-FSM.  In
+ * particular, the operand of a BRANCH node is the first node of the branch.
+ * (NB this is *not* a tree structure:  the tail of the branch connects
+ * to the thing following the set of BRANCHes.)  The opcodes are:
+ */
+
+/* definition	number	opnd?	meaning */
+#define	END	0	/* no	End of program. */
+#define	BOL	1	/* no	Match "" at beginning of line. */
+#define	EOL	2	/* no	Match "" at end of line. */
+#define	ANY	3	/* no	Match any one character. */
+#define	ANYOF	4	/* str	Match any character in this string. */
+#define	ANYBUT	5	/* str	Match any character not in this string. */
+#define	BRANCH	6	/* node	Match this alternative, or the next... */
+#define	BACK	7	/* no	Match "", "next" ptr points backward. */
+#define	EXACTLY	8	/* str	Match this string. */
+#define	NOTHING	9	/* no	Match empty string. */
+#define	STAR	10	/* node	Match this (simple) thing 0 or more times. */
+#define	PLUS	11	/* node	Match this (simple) thing 1 or more times. */
+#define	OPEN	20	/* no	Mark this point in input as start of #n. */
+/*	OPEN+1 is number 1, etc. */
+#define	CLOSE	70	/* no	Analogous to OPEN. */
+
+/*
+ * Opcode notes:
+ *
+ * BRANCH	The set of branches constituting a single choice are hooked
+ *		together with their "next" pointers, since precedence prevents
+ *		anything being concatenated to any individual branch.  The
+ *		"next" pointer of the last BRANCH in a choice points to the
+ *		thing following the whole choice.  This is also where the
+ *		final "next" pointer of each individual branch points; each
+ *		branch starts with the operand node of a BRANCH node.
+ *
+ * BACK		Normal "next" pointers all implicitly point forward; BACK
+ *		exists to make loop structures possible.
+ *
+ * STAR,PLUS	'?', and complex '*' and '+', are implemented as circular
+ *		BRANCH structures using BACK.  Simple cases (one character
+ *		per match) are implemented with STAR and PLUS for speed
+ *		and to minimize recursive plunges.
+ *
+ * OPEN,CLOSE	...are numbered at compile time.
+ */
+
+/*
+ * A node is one char of opcode followed by two chars of "next" pointer.
+ * "Next" pointers are stored as two 8-bit pieces, high order first.  The
+ * value is a positive offset from the opcode of the node containing it.
+ * An operand, if any, simply follows the node.  (Note that much of the
+ * code generation knows about this implicit relationship.)
+ *
+ * Using two bytes for the "next" pointer is vast overkill for most things,
+ * but allows patterns to get big without disasters.
+ */
+#define	OP(p)	(*(p))
+#define	NEXT(p)	(((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
+#define	OPERAND(p)	((p) + 3)
+
+/*
+ * See regmagic.h for one further detail of program structure.
+ */
+
+
+/*
+ * Utility definitions.
+ */
+#ifndef CHARBITS
+#define	UCHARAT(p)	((int)*(unsigned char *)(p))
+#else
+#define	UCHARAT(p)	((int)*(p)&CHARBITS)
+#endif
+
+#define	FAIL(m)	{ regerror(m); return(NULL); }
+#define	ISMULT(c)	((c) == '*' || (c) == '+' || (c) == '?')
+#define	META	"^$.[()|?+*\\"
+
+/*
+ * Flags to be passed up and down.
+ */
+#define	HASWIDTH	01	/* Known never to match null string. */
+#define	SIMPLE		02	/* Simple enough to be STAR/PLUS operand. */
+#define	SPSTART		04	/* Starts with * or +. */
+#define	WORST		0	/* Worst case. */
+
+/*
+ * Global work variables for regcomp().
+ */
+static char *regparse;		/* Input-scan pointer. */
+static int regnpar;		/* () count. */
+static char regdummy;
+static char *regcode;		/* Code-emit pointer; &regdummy = don't. */
+static long regsize;		/* Code size. */
+
+/*
+ * Forward declarations for regcomp()'s friends.
+ */
+#ifndef STATIC
+#define	STATIC	static
+#endif
+STATIC char *reg(int, int *);
+STATIC char *regbranch(int *);
+STATIC char *regpiece(int *);
+STATIC char *regatom(int *);
+STATIC char *regnode(char);
+STATIC char *regnext(char *);
+STATIC void regc(char);
+STATIC void reginsert(char, char *);
+STATIC void regtail(char *, char *);
+STATIC void regoptail(char *, char *);
+STATIC int regstrcspn(char *, char *);
+
+static void
+regerror(char *s)
+{
+  scheme_raise_exn(MZEXN_MISC_REGEXP,
+		   "regexp: %s", s);
+}
+
+/*
+ - regcomp - compile a regular expression into internal code
+ *
+ * We can't allocate space until we know how big the compiled form will be,
+ * but we can't compile it (and thus know how big it is) until we've got a
+ * place to put the code.  So we cheat:  we compile it twice, once with code
+ * generation turned off and size counting turned on, and once "for real".
+ * This also means that we don't allocate space until we are sure that the
+ * thing really will compile successfully, and we never have to move the
+ * code and thus invalidate pointers into it.  (Note that it has to be in
+ * one piece because free() must be able to free it all.)
+ *
+ * Beware that the optimization-preparation code in here knows about some
+ * of the structure of the compiled regexp.
+ */
+static regexp *
+regcomp(char *exp)
+{
+  register regexp *r;
+  register char *scan;
+  register char *longest;
+  register int len;
+  int flags;
+  
+  if (exp == NULL)
+    FAIL("NULL argument");
+  
+  /* First pass: determine size, legality. */
+  regparse = exp;
+  regnpar = 1;
+  regsize = 0L;
+  regcode = &regdummy;
+  regc(MAGIC);
+  if (reg(0, &flags) == NULL)
+    return(NULL);
+  
+  /* Small enough for pointer-storage convention? */
+  if (regsize >= 32767L)		/* Probably could be 65535L. */
+    FAIL("regexp too big");
+  
+  /* Allocate space. */
+  r = (regexp *)scheme_malloc_tagged(sizeof(regexp) + (unsigned)regsize);
+  
+  if (r == NULL)
+    FAIL("out of space");
+  
+  r->type = regexp_type;
+  
+  r->nsubexp = regnpar;
+  r->startp = (char **)scheme_malloc_atomic(regnpar * sizeof(char *));
+  r->endp = (char **)scheme_malloc_atomic(regnpar * sizeof(char *));
+  
+  /* Second pass: emit code. */
+  regparse = exp;
+  regnpar = 1;
+  regcode = r->program;
+  regc(MAGIC);
+  if (reg(0, &flags) == NULL)
+    return(NULL);
+  
+  /* Dig out information for optimizations. */
+  r->regstart = '\0';	/* Worst-case defaults. */
+  r->reganch = 0;
+  r->regmust = NULL;
+  r->regmlen = 0;
+  scan = r->program+1;			/* First BRANCH. */
+  if (OP(regnext(scan)) == END) {	/* Only one top-level choice. */
+    scan = OPERAND(scan);
+    
+    /* Starting-point info. */
+    if (OP(scan) == EXACTLY)
+      r->regstart = *OPERAND(scan);
+    else if (OP(scan) == BOL)
+      r->reganch++;
+    
+    /*
+     * If there's something expensive in the r.e., find the
+     * longest literal string that must appear and make it the
+     * regmust.  Resolve ties in favor of later strings, since
+     * the regstart check works with the beginning of the r.e.
+     * and avoiding duplication strengthens checking.  Not a
+     * strong reason, but sufficient in the absence of others.
+     */
+    if (flags&SPSTART) {
+      longest = NULL;
+      len = 0;
+      for (; scan != NULL; scan = regnext(scan))
+	if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
+	  longest = OPERAND(scan);
+	  len = strlen(OPERAND(scan));
+	}
+      r->regmust = longest;
+      r->regmlen = len;
+    }
+  }
+  
+  return(r);
+}
+
+/*
+   - reg - regular expression, i.e. main body or parenthesized thing
+   *
+   * Caller must absorb opening parenthesis.
+   *
+   * Combining parenthesis handling with the base level of regular expression
+   * is a trifle forced, but the need to tie the tails of the branches to what
+   * follows makes it hard to avoid.
+   */
+static char *
+reg(int paren, int *flagp)
+{
+  register char *ret;
+  register char *br;
+  register char *ender;
+  register int parno = 0;
+  int flags;
+
+  *flagp = HASWIDTH;		/* Tentatively. */
+
+  /* Make an OPEN node, if parenthesized. */
+  if (paren) {
+    parno = regnpar;
+    if (OPEN + parno >= CLOSE)
+      regerror("too many subexpressions in regular expression");
+    regnpar++;
+    ret = regnode(OPEN+parno);
+  } else
+    ret = NULL;
+
+  /* Pick up the branches, linking them together. */
+  br = regbranch(&flags);
+  if (br == NULL)
+    return(NULL);
+  if (ret != NULL)
+    regtail(ret, br);		/* OPEN -> first. */
+  else
+    ret = br;
+  if (!(flags&HASWIDTH))
+    *flagp &= ~HASWIDTH;
+  *flagp |= flags&SPSTART;
+  while (*regparse == '|') {
+    regparse++;
+    br = regbranch(&flags);
+    if (br == NULL)
+      return(NULL);
+    regtail(ret, br);		/* BRANCH -> BRANCH. */
+    if (!(flags&HASWIDTH))
+      *flagp &= ~HASWIDTH;
+    *flagp |= flags&SPSTART;
+  }
+
+  /* Make a closing node, and hook it on the end. */
+  ender = regnode((paren) ? CLOSE+parno : END);	
+  regtail(ret, ender);
+
+  /* Hook the tails of the branches to the closing node. */
+  for (br = ret; br != NULL; br = regnext(br))
+    regoptail(br, ender);
+
+  /* Check for proper termination. */
+  if (paren && *regparse++ != ')') {
+    FAIL("unmatched ()");
+  } else if (!paren && *regparse != '\0') {
+    if (*regparse == ')') {
+      FAIL("unmatched ()");
+    } else
+      FAIL("junk on end");	/* "Can't happen". */
+    /* NOTREACHED */
+  }
+
+  return(ret);
+}
+
+/*
+   - regbranch - one alternative of an | operator
+   *
+   * Implements the concatenation operator.
+   */
+static char *
+regbranch(int *flagp)
+{
+  register char *ret;
+  register char *chain;
+  register char *latest;
+  int flags;
+
+  *flagp = WORST;		/* Tentatively. */
+
+  ret = regnode(BRANCH);
+  chain = NULL;
+  while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
+    latest = regpiece(&flags);
+    if (latest == NULL)
+      return(NULL);
+    *flagp |= flags&HASWIDTH;
+    if (chain == NULL)		/* First piece. */
+      *flagp |= flags&SPSTART;
+    else
+      regtail(chain, latest);
+    chain = latest;
+  }
+  if (chain == NULL)		/* Loop ran zero times. */
+    (void) regnode(NOTHING);
+
+  return(ret);
+}
+
+/*
+   - regpiece - something followed by possible [*+?]
+   *
+   * Note that the branching code sequences used for ? and the general cases
+   * of * and + are somewhat optimized:  they use the same NOTHING node as
+   * both the endmarker for their branch list and the body of the last branch.
+   * It might seem that this node could be dispensed with entirely, but the
+   * endmarker role is not redundant.
+   */
+static char *
+regpiece(int *flagp)
+{
+  register char *ret;
+  register char op;
+  register char *next;
+  int flags;
+
+  ret = regatom(&flags);
+  if (ret == NULL)
+    return(NULL);
+
+  op = *regparse;
+  if (!ISMULT(op)) {
+    *flagp = flags;
+    return(ret);
+  }
+
+  if (!(flags&HASWIDTH) && op != '?')
+    FAIL("*+ operand could be empty");
+  *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
+
+  if (op == '*' && (flags&SIMPLE))
+    reginsert(STAR, ret);
+  else if (op == '*') {
+    /* Emit x* as (x&|), where & means "self". */
+    reginsert(BRANCH, ret);	/* Either x */
+    regoptail(ret, regnode(BACK)); /* and loop */
+    regoptail(ret, ret);	/* back */
+    regtail(ret, regnode(BRANCH)); /* or */
+    regtail(ret, regnode(NOTHING)); /* null. */
+  } else if (op == '+' && (flags&SIMPLE))
+    reginsert(PLUS, ret);
+  else if (op == '+') {
+    /* Emit x+ as x(&|), where & means "self". */
+    next = regnode(BRANCH);	/* Either */
+    regtail(ret, next);
+    regtail(regnode(BACK), ret); /* loop back */
+    regtail(next, regnode(BRANCH)); /* or */
+    regtail(ret, regnode(NOTHING)); /* null. */
+  } else if (op == '?') {
+    /* Emit x? as (x|) */
+    reginsert(BRANCH, ret);	/* Either x */
+    regtail(ret, regnode(BRANCH)); /* or */
+    next = regnode(NOTHING);	/* null. */
+    regtail(ret, next);
+    regoptail(ret, next);
+  }
+  regparse++;
+  if (ISMULT(*regparse))
+    FAIL("nested *?+");
+
+  return(ret);
+}
+
+/*
+   - regatom - the lowest level
+   *
+   * Optimization:  gobbles an entire sequence of ordinary characters so that
+   * it can turn them into a single node, which is smaller to store and
+   * faster to run.  Backslashed characters are exceptions, each becoming a
+   * separate node; the code is simpler that way and it's not worth fixing.
+ */
+static char *
+regatom(int *flagp)
+{
+	register char *ret;
+	int flags;
+
+	*flagp = WORST;		/* Tentatively. */
+
+	switch (*regparse++) {
+	case '^':
+	  ret = regnode(BOL);
+	  break;
+	case '$':
+	  ret = regnode(EOL);
+	  break;
+	case '.':
+	  ret = regnode(ANY);
+	  *flagp |= HASWIDTH|SIMPLE;
+	  break;
+	case '[': {
+	  register int xclass;
+	  register int classend;
+
+	  if (*regparse == '^') { /* Complement of range. */
+	    ret = regnode(ANYBUT);
+	    regparse++;
+	  } else
+	    ret = regnode(ANYOF);
+	  if (*regparse == ']' || *regparse == '-')
+	    regc(*regparse++);
+	  while (*regparse != '\0' && *regparse != ']') {
+	    if (*regparse == '-') {
+	      regparse++;
+	      if (*regparse == ']' || *regparse == '\0')
+		regc('-');
+	      else {
+		xclass = UCHARAT(regparse-2)+1;
+		classend = UCHARAT(regparse);
+		if (xclass > classend+1)
+		  FAIL("invalid [] range");
+		for (; xclass <= classend; xclass++)
+		  regc(xclass);
+		regparse++;
+	      }
+	    } else
+	      regc(*regparse++);
+	  }
+	  regc('\0');
+	  if (*regparse != ']')
+	    FAIL("unmatched []");
+	  regparse++;
+	  *flagp |= HASWIDTH|SIMPLE;
+	}
+	  break;
+	case '(':
+	  ret = reg(1, &flags);
+	  if (ret == NULL)
+	    return(NULL);
+	  *flagp |= flags&(HASWIDTH|SPSTART);
+	  break;
+	case '\0':
+	case '|':
+	case ')':
+	  FAIL("internal urp");	/* Supposed to be caught earlier. */
+	  break;
+	case '?':
+	case '+':
+	case '*':
+	  FAIL("?+* follows nothing");
+	  break;
+	case '\\':
+	  if (*regparse == '\0')
+	    FAIL("trailing \\");
+	  ret = regnode(EXACTLY);
+	  regc(*regparse++);
+	  regc('\0');
+	  *flagp |= HASWIDTH|SIMPLE;
+	  break;
+	default: {
+	  register int len;
+	  register char ender;
+
+	  regparse--;
+	  len = regstrcspn(regparse, META);
+	  if (len <= 0)
+	    FAIL("internal disaster");
+	  ender = *(regparse+len);
+	  if (len > 1 && ISMULT(ender))
+	    len--;		/* Back off clear of ?+* operand. */
+	  *flagp |= HASWIDTH;
+	  if (len == 1)
+	    *flagp |= SIMPLE;
+	  ret = regnode(EXACTLY);
+	  while (len > 0) {
+	    regc(*regparse++);
+	    len--;
+	  }
+	  regc('\0');
+	}
+	  break;
+	}
+	
+	return(ret);
+      }
+
+/*
+   - regnode - emit a node
+   */
+static char *			/* Location. */
+regnode(char op)
+{
+  register char *ret;
+  register char *ptr;
+
+  ret = regcode;
+  if (ret == &regdummy) {
+    regsize += 3;
+    return(ret);
+  }
+
+  ptr = ret;
+  *ptr++ = op;
+  *ptr++ = '\0';		/* Null "next" pointer. */
+  *ptr++ = '\0';
+  regcode = ptr;
+
+  return(ret);
+}
+
+/*
+   - regc - emit (if appropriate) a byte of code
+   */
+static void
+regc(char b)
+{
+  if (regcode != &regdummy)
+    *regcode++ = b;
+  else
+    regsize++;
+}
+
+/*
+   - reginsert - insert an operator in front of already-emitted operand
+   *
+   * Means relocating the operand.
+   */
+static void
+reginsert(char op, char *opnd)
+{
+  register char *src;
+  register char *dst;
+  register char *place;
+
+  if (regcode == &regdummy) {
+    regsize += 3;
+    return;
+  }
+
+  src = regcode;
+  regcode += 3;
+  dst = regcode;
+  while (src > opnd)
+    *--dst = *--src;
+
+  place = opnd;			/* Op node, where operand used to be. */
+  *place++ = op;
+  *place++ = '\0';
+  *place++ = '\0';
+}
+
+/*
+   - regtail - set the next-pointer at the end of a node chain
+   */
+static void
+regtail(char *p, char *val)
+{
+  register char *scan;
+  register char *temp;
+  register int offset;
+
+  if (p == &regdummy)
+    return;
+
+  /* Find last node. */
+  scan = p;
+  for (;;) {
+    temp = regnext(scan);
+    if (temp == NULL)
+      break;
+    scan = temp;
+  }
+
+  if (OP(scan) == BACK)
+    offset = scan - val;
+  else
+    offset = val - scan;
+  *(scan+1) = (offset>>8)&0377;
+  *(scan+2) = offset&0377;
+}
+
+/*
+   - regoptail - regtail on operand of first argument; nop if operandless
+   */
+static void
+regoptail(char *p, char *val)
+{
+  /* "Operandless" and "op != BRANCH" are synonymous in practice. */
+  if (p == NULL || p == &regdummy || OP(p) != BRANCH)
+    return;
+  regtail(OPERAND(p), val);
+}
+
+/*
+ * regexec and friends
+ */
+
+/*
+ * Global work variables for regexec().
+ */
+static char *reginput;		/* String-input pointer. */
+static char *regbol;		/* Beginning of input, for ^ check. */
+static char **regstartp;	/* Pointer to startp array. */
+static char **regendp;		/* Ditto for endp. */
+
+/*
+ * Forwards.
+ */
+STATIC int regtry(regexp *, char *);
+STATIC int regmatch(char *);
+STATIC int regrepeat(char *);
+
+#ifdef DEBUG
+int regnarrate = 0;
+void regdump();
+STATIC char *regprop();
+#endif
+
+/*
+   - regexec - match a regexp against a string
+   */
+static int
+regexec(regexp *prog, char *string)
+{
+  register char *s;
+ 
+  /* Be paranoid... */
+  if (prog == NULL || string == NULL) {
+    regerror("NULL parameter");
+    return(0);
+  }
+
+  /* Check validity of program. */
+  if (UCHARAT(prog->program) != MAGIC) {
+    regerror("corrupted program");
+    return(0);
+  }
+
+  /* If there is a "must appear" string, look for it. */
+  if (prog->regmust != NULL) {
+    s = string;
+    while ((s = strchr(s, prog->regmust[0])) != NULL) {
+      if (strncmp(s, prog->regmust, prog->regmlen) == 0)
+	break;			/* Found it. */
+      s++;
+    }
+    if (s == NULL)		/* Not present. */
+      return(0);
+  }
+
+  /* Mark beginning of line for ^ . */
+  regbol = string;
+
+  /* Simplest case:  anchored match need be tried only once. */
+  if (prog->reganch)
+    return(regtry(prog, string));
+
+  /* Messy cases:  unanchored match. */
+  s = string;
+  if (prog->regstart != '\0')
+    /* We know what char it must start with. */
+    while ((s = strchr(s, prog->regstart)) != NULL) {
+      if (regtry(prog, s))
+	return(1);
+      s++;
+    }
+  else
+    /* We don't -- general case. */
+    do {
+      if (regtry(prog, s))
+	return(1);
+    } while (*s++ != '\0');
+
+  /* Failure. */
+  return(0);
+}
+
+/*
+   - regtry - try match at specific point
+   */
+static int			/* 0 failure, 1 success */
+regtry(regexp *prog, char *string)
+{
+  register int i;
+  register char **sp;
+  register char **ep;
+
+  reginput = string;
+  regstartp = prog->startp;
+  regendp = prog->endp;
+
+  sp = prog->startp;
+  ep = prog->endp;
+  for (i = prog->nsubexp; i > 0; i--) {
+    *sp++ = NULL;
+    *ep++ = NULL;
+  }
+  if (regmatch(prog->program + 1)) {
+    prog->startp[0] = string;
+    prog->endp[0] = reginput;
+    return(1);
+  } else
+    return(0);
+}
+
+/*
+   - regmatch - main matching routine
+   *
+   * Conceptually the strategy is simple:  check to see whether the current
+   * node matches, call self recursively to see whether the rest matches,
+   * and then act accordingly.  In practice we make some effort to avoid
+   * recursion, in particular by going through "ordinary" nodes (that don't
+   * need to know whether the rest of the match failed) by a loop instead of
+   * by recursion.
+   */
+static int			/* 0 failure, 1 success */
+regmatch(char *prog)
+{
+  register char *scan;		/* Current node. */
+  char *next;			/* Next node. */
+
+  scan = prog;
+#ifdef DEBUG
+  if (scan != NULL && regnarrate)
+    fprintf(stderr, "%s(\n", regprop(scan));
+#endif
+  while (scan != NULL) {
+#ifdef DEBUG
+    if (regnarrate)
+      fprintf(stderr, "%s...\n", regprop(scan));
+#endif
+    next = regnext(scan);
+
+    switch (OP(scan)) {
+    case BOL:
+      if (reginput != regbol)
+	return(0);
+      break;
+    case EOL:
+      if (*reginput != '\0')
+	return(0);
+      break;
+    case ANY:
+      if (*reginput == '\0')
+	return(0);
+      reginput++;
+      break;
+    case EXACTLY: {
+      register int len;
+      register char *opnd;
+
+      opnd = OPERAND(scan);
+      /* Inline the first character, for speed. */
+      if (*opnd != *reginput)
+	return(0);
+      len = strlen(opnd);
+      if (len > 1 && strncmp(opnd, reginput, len) != 0)
+	return(0);
+      reginput += len;
+    }
+      break;
+    case ANYOF:
+      if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL)
+	return(0);
+      reginput++;
+      break;
+    case ANYBUT:
+      if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL)
+	return(0);
+      reginput++;
+      break;
+    case NOTHING:
+      break;
+    case BACK:
+      break;
+    case BRANCH: {
+      register char *save;
+
+      if (OP(next) != BRANCH)	/* No choice. */
+	next = OPERAND(scan);	/* Avoid recursion. */
+      else {
+	do {
+	  save = reginput;
+	  if (regmatch(OPERAND(scan)))
+	    return(1);
+	  reginput = save;
+	  scan = regnext(scan);
+	} while (scan != NULL && OP(scan) == BRANCH);
+	return(0);
+	/* NOTREACHED */
+      }
+    }
+      break;
+    case STAR:
+    case PLUS: {
+      register char nextch;
+      register int no;
+      register char *save;
+      register int min;
+
+      /*
+       * Lookahead to avoid useless match attempts
+       * when we know what character comes next.
+       */
+      nextch = '\0';
+      if (OP(next) == EXACTLY)
+	nextch = *OPERAND(next);
+      min = (OP(scan) == STAR) ? 0 : 1;
+      save = reginput;
+      no = regrepeat(OPERAND(scan));
+      while (no >= min) {
+	/* If it could work, try it. */
+	if (nextch == '\0' || *reginput == nextch)
+	  if (regmatch(next))
+	    return(1);
+	/* Couldn't or didn't -- back up. */
+	no--;
+	reginput = save + no;
+      }
+      return(0);
+    }
+      break;
+    case END:
+      return(1);		/* Success! */
+      break;
+    default:
+      if (OP(scan) < CLOSE) {
+	register int no;
+	register char *save;
+	
+	no = OP(scan) - OPEN;
+	save = reginput;
+
+	if (regmatch(next)) {
+	  /*
+	   * Don't set startp if some later
+	   * invocation of the same parentheses
+	   * already has.
+	   */
+	  if (regstartp[no] == NULL)
+	    regstartp[no] = save;
+	  return(1);
+	} else
+	  return(0);
+      } else {
+	register int no;
+	register char *save;
+	
+	no = OP(scan) - CLOSE;
+	save = reginput;
+	
+	if (regmatch(next)) {
+	  /*
+	   * Don't set endp if some later
+	   * invocation of the same parentheses
+	   * already has.
+	   */
+	  if (regendp[no] == NULL)
+	    regendp[no] = save;
+	  return(1);
+	} else
+	  return(0);
+      }
+      break;
+    }
+
+    scan = next;
+  }
+
+  /*
+   * We get here only if there's trouble -- normally "case END" is
+   * the terminating point.
+   */
+  regerror("corrupted pointers");
+  return(0);
+}
+
+/*
+   - regrepeat - repeatedly match something simple, report how many
+   */
+static int
+regrepeat(char *p)
+{
+  register int count = 0;
+  register char *scan;
+  register char *opnd;
+
+  scan = reginput;
+  opnd = OPERAND(p);
+  switch (OP(p)) {
+  case ANY:
+    count = strlen(scan);
+    scan += count;
+    break;
+  case EXACTLY:
+    while (*opnd == *scan) {
+      count++;
+      scan++;
+    }
+    break;
+  case ANYOF:
+    while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
+      count++;
+      scan++;
+    }
+    break;
+  case ANYBUT:
+    while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
+      count++;
+      scan++;
+    }
+    break;
+  default:			/* Oh dear.  Called inappropriately. */
+    regerror("internal foulup");
+    count = 0;			/* Best compromise. */
+    break;
+  }
+  reginput = scan;
+
+  return(count);
+}
+
+/*
+   - regnext - dig the "next" pointer out of a node
+   */
+static char *
+regnext(char *p)
+{
+  register int offset;
+
+  if (p == &regdummy)
+    return(NULL);
+
+  offset = NEXT(p);
+  if (offset == 0)
+    return(NULL);
+
+  if (OP(p) == BACK)
+    return(p-offset);
+  else
+    return(p+offset);
+}
+
+#ifdef DEBUG
+
+STATIC char *regprop();
+
+/*
+   - regdump - dump a regexp onto stdout in vaguely comprehensible form
+   */
+static void
+regdump(r)
+     regexp *r;
+{
+  register char *s;
+  register char op = EXACTLY;	/* Arbitrary non-END op. */
+  register char *next;
+  extern char *strchr();
+
+
+  s = r->program + 1;
+  while (op != END) {		/* While that wasn't END last time... */
+    op = OP(s);
+    printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */
+    next = regnext(s);
+    if (next == NULL)		/* Next ptr. */
+      printf("(0)");
+    else 
+      printf("(%d)", (s-r->program)+(next-s));
+    s += 3;
+    if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
+      /* Literal string, where present. */
+      while (*s != '\0') {
+	putchar(*s);
+	s++;
+      }
+      s++;
+    }
+    putchar('\n');
+  }
+
+  /* Header fields of interest. */
+  if (r->regstart != '\0')
+    printf("start `%c' ", r->regstart);
+  if (r->reganch)
+    printf("anchored ");
+  if (r->regmust != NULL)
+    printf("must have \"%s\"", r->regmust);
+  printf("\n");
+}
+
+/*
+   - regprop - printable representation of opcode
+   */
+static char *
+regprop(op)
+     char *op;
+{
+  register char *p;
+  static char buf[50];
+
+  (void) strcpy(buf, ":");
+
+  switch (OP(op)) {
+  case BOL:
+    p = "BOL";
+    break;
+  case EOL:
+    p = "EOL";
+    break;
+  case ANY:
+    p = "ANY";
+    break;
+  case ANYOF:
+    p = "ANYOF";
+    break;
+  case ANYBUT:
+    p = "ANYBUT";
+    break;
+  case BRANCH:
+    p = "BRANCH";
+    break;
+  case EXACTLY:
+    p = "EXACTLY";
+    break;
+  case NOTHING:
+    p = "NOTHING";
+    break;
+  case BACK:
+    p = "BACK";
+    break;
+  case END:
+    p = "END";
+    break;
+  case OPEN+1:
+  case OPEN+2:
+  case OPEN+3:
+  case OPEN+4:
+  case OPEN+5:
+  case OPEN+6:
+  case OPEN+7:
+  case OPEN+8:
+  case OPEN+9:
+    sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
+    p = NULL;
+    break;
+  case CLOSE+1:
+  case CLOSE+2:
+  case CLOSE+3:
+  case CLOSE+4:
+  case CLOSE+5:
+  case CLOSE+6:
+  case CLOSE+7:
+  case CLOSE+8:
+  case CLOSE+9:
+    sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
+    p = NULL;
+    break;
+  case STAR:
+    p = "STAR";
+    break;
+  case PLUS:
+    p = "PLUS";
+    break;
+  default:
+    regerror("corrupted opcode");
+    break;
+  }
+  if (p != NULL)
+    (void) strcat(buf, p);
+  return(buf);
+}
+#endif
+
+/*
+ * strcspn - find length of initial segment of s1 consisting entirely
+ * of characters not from s2
+ */
+
+static int
+regstrcspn(char *s1, char *s2)
+{
+  register char *scan1;
+  register char *scan2;
+  register int count;
+
+  count = 0;
+  for (scan1 = s1; *scan1 != '\0'; scan1++) {
+    for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */
+      if (*scan1 == *scan2++)
+	return(count);
+    count++;
+  }
+  return(count);
+}
+
+/*
+   - regsub - perform substitutions after a regexp match
+   */
+static 
+char *regsub(regexp *prog, char *source, long *lenout)
+{
+  char *dest;
+  register char *src;
+  register char *dst;
+  register char c;
+  register long no;
+  register long len;
+  long destalloc, destlen;
+	
+#ifndef strncpy
+  extern char *strncpy();
+#endif
+
+  destalloc = 2 * strlen(source);
+  destlen = 0;
+  dest = (char *)scheme_malloc(destalloc + 1);
+	
+
+  if (prog == NULL || source == NULL || dest == NULL) {
+    regerror("NULL parm to regsub");
+    return "";
+  }
+	
+  src = source;
+  dst = dest;
+  while ((c = *src++) != '\0') {
+    if (c == '&')
+      no = 0;
+    else if (c == '\\') {
+      if (*src == '\\' || *src == '&')
+	no = -1;
+      else {
+	no = 0;
+	while ('0' <= *src && *src <= '9')
+	  no = (no * 10) + (*src++ - '0');
+      }
+    } else
+      no = -1;
+
+
+    if (no < 0) {		/* Ordinary character. */
+      if (c == '\\' && (*src == '\\' || *src == '&'))
+	c = *src++;
+      if (destlen + 1 >= destalloc) {
+	char *old = dest;
+	destalloc *= 2;
+	dest = (char *)scheme_malloc(destalloc + 1);
+	memcpy(dest, old, destlen);
+	dst = dest + destlen;
+      }
+      *dst++ = c;
+      destlen++;
+    } else if (no >= prog->nsubexp) {
+      /* Number too big; prentend it's the empty string */
+    } else if (prog->startp[no] != NULL && prog->endp[no] != NULL) {
+      len = prog->endp[no] - prog->startp[no];
+      if (len + destlen >= destalloc) {
+	char *old = dest;
+	destalloc = 2 * destalloc + len + destlen;
+	dest = (char *)scheme_malloc(destalloc + 1);
+	memcpy(dest, old, destlen);
+	dst = dest + destlen;
+      }
+      memcpy(dst, prog->startp[no], len);
+      dst += len;
+      destlen += len;
+    }
+  }
+  *dst = '\0';
+
+  if (lenout)
+    *lenout = destlen;
+
+  return dest;
+}
+
+static Scheme_Object *make_regexp(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->regexp", "string", 0, argc, argv);
+
+  return (Scheme_Object *)regcomp(SCHEME_STR_VAL(argv[0]));
+}
+
+static Scheme_Object *gen_compare(char *name, int pos, 
+				  int argc, Scheme_Object *argv[])
+{
+  regexp *r;
+  char *s;
+  
+  if (SCHEME_TYPE(argv[0]) != regexp_type
+      && !SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type(name, "regexp-or-string", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type(name, "string", 1, argc, argv);
+
+  if (SCHEME_STRINGP(argv[0]))
+    r = regcomp(SCHEME_STR_VAL(argv[0]));
+  else
+    r = (regexp *)argv[0];
+
+  s = SCHEME_STR_VAL(argv[1]);
+
+  if (regexec(r, s)) {
+    int i;
+    
+    Scheme_Object *l = scheme_null;
+
+    for (i = r->nsubexp; i--; ) {
+      if (r->startp[i]) {
+	if (pos) {
+	  long startp, endp;
+
+	  startp = r->startp[i] - s;
+	  endp = r->endp[i] - s;
+	
+	  l = 
+	  scheme_make_pair(scheme_make_pair(scheme_make_integer(startp),
+					    scheme_make_integer(endp)),
+			   l);
+	} else
+	  l = 
+	    scheme_make_pair(scheme_make_sized_string(r->startp[i],
+						      r->endp[i] 
+						      - r->startp[i],
+						      1),
+			     l);
+      } else
+	l = scheme_make_pair(scheme_false, l);
+    }
+
+    return l;
+  } else
+    return scheme_false;
+}
+
+static Scheme_Object *compare(int argc, Scheme_Object *argv[])
+{
+  return gen_compare("regexp-match", 0, argc, argv);
+}
+
+static Scheme_Object *positions(int argc, Scheme_Object *argv[])
+{
+  return gen_compare("regexp-match-positions", 1, argc, argv);
+}
+
+static Scheme_Object *gen_replace(int argc, Scheme_Object *argv[], int all)
+{
+  regexp *r;
+  char *source, *prefix = NULL;
+  int prefix_len = 0;
+
+  if (SCHEME_TYPE(argv[0]) != regexp_type
+      && !SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("regexp-replace", "regexp-or-string", 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]))
+    scheme_wrong_type("regexp-replace", "string", 1, argc, argv);
+  if (!SCHEME_STRINGP(argv[2]))
+    scheme_wrong_type("regexp-replace", "string", 2, argc, argv);
+
+  if (SCHEME_STRINGP(argv[0]))
+    r = regcomp(SCHEME_STR_VAL(argv[0]));
+  else
+    r = (regexp *)argv[0];
+
+  source = SCHEME_STR_VAL(argv[1]);
+
+  while (1) {
+    if (regexec(r, source)) {
+      char *insert;
+      long len, end, startp, endp;
+      
+      insert = regsub(r, SCHEME_STR_VAL(argv[2]), &len);
+      
+      end = SCHEME_STRTAG_VAL(argv[1]);
+      
+      startp = (r->startp[0] - source);
+      endp = (r->endp[0] - source);
+      
+      if (!startp && (endp == end) && !prefix)
+	return scheme_make_sized_string(insert, len, 0);
+      else if (!all) {
+	char *result;
+	long total;
+	
+	total = len + startp + (end - endp);
+	
+	result = (char *)scheme_malloc_atomic(total + 1);
+	memcpy(result, source, startp);
+	memcpy(result + startp, insert, len);
+	memcpy(result + startp + len, source + endp, (end - endp) + 1);
+	
+	return scheme_make_sized_string(result, total, 0);
+      } else {
+	char *naya;
+	long total;
+	
+	total = len + prefix_len + startp;
+	
+	naya = (char *)scheme_malloc_atomic(total + 1);
+	memcpy(naya, prefix, prefix_len);
+	memcpy(naya + prefix_len, source, startp);
+	memcpy(naya + prefix_len + startp, insert, len);
+
+	prefix = naya;
+	prefix_len = total;
+
+	source = source + endp;
+      }
+    } else if (!prefix)
+      return argv[1];
+    else {
+      char *result;
+      long total, slen;
+      
+      slen = strlen(source);
+      total = prefix_len + slen;
+      
+      result = (char *)scheme_malloc_atomic(total + 1);
+      memcpy(result, prefix, prefix_len);
+      memcpy(result + prefix_len, source, slen);
+      result[prefix_len + slen] = 0;
+      
+      return scheme_make_sized_string(result, total, 0);
+    }
+  }
+}
+
+static Scheme_Object *replace(int argc, Scheme_Object *argv[])
+{
+  return gen_replace(argc, argv, 0);
+}
+
+static Scheme_Object *replace_star(int argc, Scheme_Object *argv[])
+{
+  return gen_replace(argc, argv, 1);
+}
+
+static Scheme_Object *regexp_p(int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_TYPE(argv[0]) == regexp_type) ? scheme_true : scheme_false;
+}
+
+void scheme_regexp_initialize(Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    regexp_type = scheme_make_type("<regexp>");
+  }
+
+  scheme_add_global_constant("regexp", 
+			     scheme_make_prim_w_arity(make_regexp, 
+						      "regexp", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("regexp-match",
+			     scheme_make_prim_w_arity(compare,
+						      "regexp-match",
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("regexp-match-positions", 
+			     scheme_make_prim_w_arity(positions, 
+						      "regexp-match-positions", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("regexp-replace", 
+			     scheme_make_prim_w_arity(replace, 
+						      "regexp-replace", 
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("regexp-replace*", 
+			     scheme_make_prim_w_arity(replace_star, 
+						      "regexp-replace*", 
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("regexp?", 
+			     scheme_make_prim_w_arity(regexp_p, 
+						      "regexp?", 
+						      1, 1), 
+			     env);
+}
+
+#endif
+/* NO_REGEXP_UTILS */
diff --git a/src/mzscheme/src/salloc.c b/src/mzscheme/src/salloc.c
new file mode 100644
index 0000000..1e95c1c
--- /dev/null
+++ b/src/mzscheme/src/salloc.c
@@ -0,0 +1,1527 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* Some copilers don't like re-def of GC_malloc in schemef.h: */
+#define SCHEME_NO_GC_PROTO
+
+#include "schpriv.h"
+#include <string.h>
+#include <memory.h>
+#include "schgc.h"
+
+#ifdef DOS_FAR_POINTERS
+# include <alloc.h>
+# define MALLOC farmalloc
+#else
+# define MALLOC malloc
+#endif
+
+#ifndef MZ_REAL_THREADS
+# define GET_FIN_LOCK() /* empty */
+# define RELEASE_FIN_LOCK() /* empty */
+#else
+static void *fin_mutex = NULL;
+# define GET_FIN_LOCK() (fin_mutex = (fin_mutex ? fin_mutex : SCHEME_MAKE_MUTEX())); SCHEME_LOCK_MUTEX(fin_mutex)
+# define RELEASE_FIN_LOCK()  SCHEME_UNLOCK_MUTEX(fin_mutex)
+#endif
+
+static void **dgc_array;
+static int *dgc_count;
+static int dgc_size;
+
+extern void (*GC_out_of_memory)(void);
+
+void scheme_dont_gc_ptr(void *p)
+{
+  int i, oldsize;
+  void **naya;
+  int *nayac;
+
+  /* look for existing: */
+  for (i = 0; i < dgc_size; i++)
+    if (dgc_array[i] == p) {
+      dgc_count[i]++;
+      return;
+    }
+
+  /* look for empty slot: */
+  for (i = 0; i < dgc_size; i++)
+    if (!dgc_array[i]) {
+      dgc_array[i] = p;
+      dgc_count[i] = 1;
+      return;
+    }
+
+  /* Make more room: */
+  oldsize = dgc_size;
+  if (!dgc_array) {
+    REGISTER_SO(dgc_array);
+    REGISTER_SO(dgc_count);
+    dgc_size = 50;
+  } else
+    dgc_size *= 2;
+
+  naya = MALLOC_N(void*, dgc_size);
+  nayac = MALLOC_N(int, dgc_size);
+
+  for (i = 0; i < oldsize; i++) {
+    naya[i] = dgc_array[i];
+    nayac[i] = dgc_count[i];
+  }
+
+  for (; i < dgc_size; i++) {
+    naya[i] = NULL;
+    dgc_count[i] = 0;
+  }
+
+  dgc_array = naya;
+
+  dgc_array[oldsize] = p;
+  dgc_count[oldsize] = 1;
+}
+
+void scheme_gc_ptr_ok(void *p)
+{
+  int i;
+  
+  for (i = 0; i < dgc_size; i++)
+    if (dgc_array[i] == p) {
+      if (!(--dgc_count[i]))
+	dgc_array[i] = NULL;
+      break;
+    }
+}
+
+#ifdef NO_GC
+void *
+scheme_malloc (size_t size)
+{
+  void *space;
+
+  space = MALLOC(size);
+  if (!space)
+    scheme_raise_out_of_memory(NULL, NULL);
+
+  return (space);
+}
+#endif
+
+void *
+scheme_calloc (size_t num, size_t size)
+{
+  void *space;
+  
+  space = MALLOC (num*size);
+#ifdef NO_GC
+  memset(space, 0, (num*size));
+#endif
+  if (!space)
+    scheme_raise_out_of_memory(NULL, NULL);
+
+  return (space);
+}
+
+char *
+scheme_strdup(const char *str)
+{
+  char *naya;
+  long len;
+
+  len = strlen (str) + 1;
+  naya = (char *)scheme_malloc_atomic (len * sizeof (char));
+  memcpy (naya, str, len);
+
+  return naya;
+}
+
+char *
+scheme_strdup_eternal(const char *str)
+{
+  char *naya;
+  long len;
+
+  len = strlen (str) + 1;
+  naya = (char *)scheme_malloc_eternal(len * sizeof (char));
+  memcpy (naya, str, len);
+
+  return naya;
+}
+
+static void (*save_oom)(void);
+
+static void raise_out_of_memory()
+{
+  GC_out_of_memory = save_oom;
+  scheme_raise_out_of_memory(NULL, NULL);
+}
+
+void *scheme_malloc_fail_ok(void *(*f)(size_t), size_t s)
+{
+  void *v;
+
+  save_oom = GC_out_of_memory;
+  GC_out_of_memory = raise_out_of_memory;
+  v = f(s);
+  GC_out_of_memory = save_oom;
+
+  return v;
+}
+
+void scheme_end_stubborn_change(void *p)
+{
+  GC_end_stubborn_change(p);
+}
+
+void *scheme_malloc_eternal(size_t n)
+{
+#ifdef USE_SENORA_GC
+  return GC_malloc_atomic_uncollectable(n);
+#else
+  void *s;
+
+  s = MALLOC(n);
+  if (!s) {
+    if (GC_out_of_memory)
+      GC_out_of_memory();
+    else {
+      if (scheme_console_printf)
+	scheme_console_printf("out of memory\n");
+      else
+	printf("out of memory\n");
+      exit(-1);
+    }
+  }
+	
+
+  memset(s, 0, n);
+
+  return s;
+#endif
+}
+
+
+#ifdef USE_TAGGED_ALLOCATION
+
+struct GC_Set *tagged, *real_tagged, *tagged_atomic, *tagged_eternal, *tagged_uncollectable, *envunbox;
+struct GC_Set *tagged_while_counting;
+
+static void trace_count(void *, int);
+static void trace_path(void *, unsigned long, void *);
+static void trace_init(void);
+static void trace_done(void);
+static void finalize_object(void *);
+
+#define TRACE_FUNCTIONS trace_init, trace_done, trace_count, trace_path
+
+static void init_tagged_counting(void)
+{
+  if (!tagged_while_counting)
+    tagged_while_counting = GC_new_set("counting", 
+				       NULL, NULL, NULL, NULL, NULL,
+				       0);
+}
+
+void *scheme_malloc_tagged(size_t s)
+{
+  if (!tagged) {
+    init_tagged_counting();
+    real_tagged = tagged = GC_new_set("tagged", TRACE_FUNCTIONS, 
+				      finalize_object, 
+				      0);
+  }
+
+  return GC_malloc_specific(s, tagged);
+}
+
+void *scheme_malloc_atomic_tagged(size_t s)
+{
+  if (!tagged_atomic) {
+    init_tagged_counting();
+    tagged_atomic = GC_new_set("tagged", TRACE_FUNCTIONS, 
+			       finalize_object, 
+			       SGC_ATOMIC_SET);
+  }
+
+  return GC_malloc_specific(s, tagged_atomic);
+}
+
+void *scheme_malloc_stubborn_tagged(size_t s)
+{
+  return scheme_malloc_tagged(s);
+}
+
+void *scheme_malloc_envunbox(size_t s)
+{
+  if (!envunbox)
+    envunbox = GC_new_set("envunbox", 
+			  NULL, NULL, NULL, NULL, NULL,
+			  0);
+
+  return GC_malloc_specific(s, envunbox);
+}
+
+void *scheme_malloc_eternal_tagged(size_t s)
+{
+  if (!tagged_eternal) {
+    init_tagged_counting();
+    tagged_eternal = GC_new_set("tagged", TRACE_FUNCTIONS,
+				finalize_object,
+				SGC_UNCOLLECTABLE_SET | SGC_ATOMIC_SET);
+  }
+
+  return GC_malloc_specific(s, tagged_eternal);
+}
+
+void *scheme_malloc_uncollectable_tagged(size_t s)
+{
+  if (!tagged_uncollectable) {
+    init_tagged_counting();
+    tagged_uncollectable = GC_new_set("tagged", TRACE_FUNCTIONS, 
+				      finalize_object,
+				      SGC_UNCOLLECTABLE_SET);
+  }
+
+  return GC_malloc_specific(s, tagged_uncollectable);
+}
+
+#endif
+
+typedef struct Finalization {
+  void (*f)(void *o, void *data);
+  void *data;
+  struct Finalization *next;
+} Finalization;
+
+typedef struct {
+  Finalization *scheme;
+  void (*ext_f)(void *o, void *data);
+  void *ext_data;
+  Finalization *prim;
+} Finalizations;
+
+typedef struct {
+  void **p; /* place to zero out */
+  Finalizations *src_fns, *dest_fns; /* Mutual finalizations to adjust */
+  Finalization *src_fn, *dest_fn;
+} ZeroingRecord;
+
+static void do_next_finalization(void *o, void *data)
+{
+  Finalizations *fns = *(Finalizations **)data;
+  Finalization *fn;
+
+  if (fns->scheme) {
+    if (fns->scheme->next || fns->ext_f || fns->prim) {
+      /* Re-install low-level finalizer and run a scheme finalizer */
+      GC_register_eager_finalizer(o, do_next_finalization, data, NULL, NULL);
+    }
+
+    fn = fns->scheme;
+    fns->scheme = fn->next;
+
+    fn->f(o, fn->data);
+    return;
+  }
+
+  if (fns->ext_f)
+    fns->ext_f(o, fns->ext_data);
+
+  for (fn = fns->prim; fn; fn = fn->next)
+    fn->f(o, fn->data);
+}
+
+static void add_finalizer(void *v, void (*f)(void*,void*), void *data, 
+			  int prim, int ext,
+			  void (**ext_oldf)(void *p, void *data),
+			  void **ext_olddata,
+			  Finalizations **_fns,
+			  Finalization **_fn)
+{
+  void (*oldf)(void *p, void *data);
+  void *olddata;
+  Finalizations *fns, **fns_ptr, *prealloced;
+  Finalization *fn;
+
+  if (v != GC_base(v))
+    return;
+
+  /* Allocate everything first so that we're not changing
+     finalizations when finalizations could run: */
+
+  fns_ptr = MALLOC_ONE(Finalizations*);
+
+  if (!ext) {
+    fn = MALLOC_ONE(Finalization);
+    fn->f = f;
+    fn->data = data;
+  } else
+    fn = NULL;
+
+  prealloced = MALLOC_ONE(Finalizations); /* may not need this... */
+
+  GET_FIN_LOCK();
+
+  GC_register_eager_finalizer(v, do_next_finalization, fns_ptr, &oldf, &olddata);
+
+  if (oldf) {
+    if (oldf != do_next_finalization) {
+      /* This happens if an extenal use of GC_ routines conflicts with us. */
+      scheme_warning("warning: non-MzScheme finalization on object dropped!");
+    } else {
+      *fns_ptr = *(Finalizations **)olddata;
+    }
+  }
+
+  if (!(*fns_ptr))
+    *fns_ptr = prealloced;
+  fns = *fns_ptr;
+
+  if (ext) {
+    if (ext_oldf)
+      *ext_oldf = fns->ext_f;
+    fns->ext_f = f;
+    if (ext_olddata)
+      *ext_olddata = fns->ext_data;
+    fns->ext_data = data;
+  } else {
+    if (prim) {
+      fn->next = fns->prim;
+      fns->prim = fn;
+    } else {
+      fn->next = fns->scheme;
+      fns->scheme = fn;
+    }
+  }
+
+  if (_fns)
+    *_fns = fns;
+  if (_fn)
+    *_fn = fn;
+
+  RELEASE_FIN_LOCK();
+}
+
+static void remove_finalizer(Finalizations *fns, Finalization *rfn, int prim)
+{
+  Finalization *fn, *prev;
+
+  GET_FIN_LOCK();
+
+  prev = NULL;
+  for (fn = (prim ? fns->prim : fns->scheme); fn; fn = fn->next) {
+    if (fn == rfn) {
+      if (!prev) {
+	if (prim)
+	  fns->prim = fn->next;
+	else
+	  fns->scheme = fn->next;
+      } else
+	prev->next = fn->next;
+    }
+    prev = fn;
+  }
+
+  RELEASE_FIN_LOCK();
+}
+
+static void z_rmve_finalizers(void *ignore, void *p)
+{
+  ZeroingRecord *z = (ZeroingRecord *)p;
+
+  if (z->src_fn)
+    remove_finalizer(z->src_fns, z->src_fn, 1);
+  if (z->dest_fn)
+    remove_finalizer(z->dest_fns, z->dest_fn, 1);
+}
+
+static void zero_out(void *ignore, void *p)
+{
+  ZeroingRecord *z = (ZeroingRecord *)p;
+
+  *z->p = NULL;
+
+  z_rmve_finalizers(ignore, p);
+}
+
+void scheme_weak_reference(void **p)
+{
+  scheme_weak_reference_indirect(p, *p);
+}
+
+void scheme_weak_reference_indirect(void **p, void *v)
+{
+  if (GC_base(v) == v) {
+    ZeroingRecord *z;
+    void *base;
+
+    z = MALLOC_ONE_ATOMIC(ZeroingRecord);
+
+    z->p = p;
+    add_finalizer(v, zero_out, z, 1, 0, NULL, NULL, &z->src_fns, &z->src_fn);
+
+    if ((base = GC_base(p)))
+      add_finalizer(base, z_rmve_finalizers, z, 1, 0, NULL, NULL, &z->dest_fns, &z->dest_fn);
+    else {
+      z->dest_fn = NULL;
+      z->dest_fns = NULL;
+    }
+  }
+}
+
+void scheme_add_finalizer(void *p, void (*f)(void *p, void *data), void *data)
+{
+  add_finalizer(p, f, data, 1, 0, NULL, NULL, NULL, NULL);
+}
+
+void scheme_add_scheme_finalizer(void *p, void (*f)(void *p, void *data), void *data)
+{
+  add_finalizer(p, f, data, 0, 0, NULL, NULL, NULL, NULL);
+}
+
+void scheme_register_finalizer(void *p, void (*f)(void *p, void *data), 
+			       void *data, void (**oldf)(void *p, void *data), 
+			       void **olddata)
+{
+  add_finalizer(p, f, data, 0, 1, oldf, olddata, NULL, NULL);
+}
+
+void scheme_collect_garbage(void)
+{
+  GC_gcollect();
+}
+
+unsigned long scheme_get_deeper_address(void)
+{
+  int v, *vp;
+  vp = &v;
+  return (unsigned long)vp;
+}
+
+
+
+#ifdef DOS_MEMORY
+
+int scheme_same_pointer(void *a, void *b)
+{
+  long as, ao, bs, bo, areal, breal;
+  
+  as = FP_SEG(a);
+  ao = FP_OFF(a);
+  bs = FP_SEG(b);
+  bo = FP_SEG(b);
+
+  areal = (as << 4) + ao;
+  breal = (bs << 4) + bo;
+
+  return areal == breal;
+}
+
+int scheme_diff_pointer(void *a, void *b)
+{
+  return !scheme_same_pointer(a, b);
+}
+
+#endif
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+  extern void GC_dump(void);
+#ifdef __cplusplus
+};
+#endif
+ 
+
+#ifdef USE_TAGGED_ALLOCATION
+#define NUM_TYPE_SLOTS (_scheme_last_type_ + 1)
+
+static long scheme_memory_count[NUM_TYPE_SLOTS];
+static long scheme_memory_actual_count[NUM_TYPE_SLOTS];
+static long scheme_memory_size[NUM_TYPE_SLOTS];
+static long scheme_memory_actual_size[NUM_TYPE_SLOTS];
+static unsigned long scheme_memory_hi[NUM_TYPE_SLOTS];
+static unsigned long scheme_memory_lo[NUM_TYPE_SLOTS];
+static long scheme_envunbox_count, scheme_envunbox_size;
+static long bad_seeds;
+static Scheme_Hash_Table *smc_ht;
+static int trace_path_type;
+
+void count_tagged(void *p, int size, void *data)
+{
+  int which = SCHEME_TYPE((Scheme_Object *)p);
+  if ((which >= 0) && (which < _scheme_last_type_)) {
+    scheme_count_memory((Scheme_Object *)p, smc_ht);
+  } else if (which >= scheme_num_types())
+    bad_seeds++;
+  else {
+    scheme_memory_count[_scheme_last_type_]++;
+    scheme_memory_size[_scheme_last_type_] += size;
+  }
+}
+
+void count_envunbox(void *p, int size, void *data)
+{
+  scheme_envunbox_count++;
+  scheme_envunbox_size += size;
+}
+
+static void trace_count(void *p, int size)
+{
+  int which = SCHEME_TYPE((Scheme_Object *)p);
+  if ((which >= 0) && (which <= _scheme_last_type_)) {
+    unsigned long s = (unsigned long)p;
+    scheme_memory_actual_count[which]++;
+    scheme_memory_actual_size[which] += size;
+    if (!scheme_memory_lo[which] || (s < scheme_memory_lo[which]))
+      scheme_memory_lo[which] = s;
+    if (!scheme_memory_hi[which] || (s > scheme_memory_hi[which]))
+      scheme_memory_hi[which] = s;
+  } else if (which >= scheme_num_types())
+    bad_seeds++;
+}
+
+static void trace_path(void *p, unsigned long src, void *path_data)
+{
+  if ((trace_path_type > -1)
+      && ((int)SCHEME_TYPE((Scheme_Object *)p) == trace_path_type))
+    GC_store_path(p, src, path_data);
+}
+
+static void trace_init(void)
+{
+  /* do nothing */
+}
+
+static void trace_done(void)
+{
+  /* do nothing */
+}
+
+static void finalize_object(void *p)
+{
+  ((Scheme_Object *)p)->type = _scheme_values_types_;
+}
+
+#endif
+
+void (*scheme_external_dump_info)(void);
+void (*scheme_external_dump_arg)(Scheme_Object *arg);
+char *(*scheme_external_dump_type)(void *v);
+
+static void count_managed(Scheme_Manager *m, int *c, int *a, int *u, int *t,
+			  int *ipt, int *opt, int *th)
+{
+  int i;
+
+  *t += 1;
+  *c += m->count;
+  *a += m->alloc;
+  for (i = m->count; i--; )
+    if (m->boxes[i]) {
+      Scheme_Object *o = (*(m->boxes[i]));
+      (*u)++;
+      if (SCHEME_PROCESSP(o))
+	(*th)++;
+      else if (SCHEME_INPORTP(o))
+	(*ipt)++;
+      else if (SCHEME_OUTPORTP(o))
+	(*opt)++;
+    }
+
+  if (*m->sibling)
+    count_managed(*m->sibling, c, a, u, t, ipt, opt, th);
+  if (*m->children)
+    count_managed(*m->children, c, a, u, t, ipt, opt, th);
+}
+
+Scheme_Object *scheme_dump_gc_stats(int c, Scheme_Object *p[])
+{
+  scheme_console_printf("Begin Dump\n");
+
+  if (scheme_external_dump_arg)
+    scheme_external_dump_arg(c ? p[0] : NULL);
+
+#ifdef USE_TAGGED_ALLOCATION
+  trace_path_type = -1;
+  if (c && SCHEME_SYMBOLP(p[0])) {
+    char *s = SCHEME_SYM_VAL(p[0]);
+    int i;
+
+    for (i = 0; i < _scheme_last_type_; i++) {
+      void *tn = scheme_get_type_name(i);
+      if (tn && !strcmp(tn, s)) {
+	trace_path_type = i;
+	break;
+      }
+    }
+  }
+
+  {
+    int i;
+    int stack_c, roots_c, uncollectable_c, final_c;
+    long total_count = 0, total_size = 0;
+    long total_actual_count = 0, total_actual_size = 0;
+    long traced;
+
+    for (i = 0; i < NUM_TYPE_SLOTS; i++) {
+      scheme_memory_count[i] = scheme_memory_size[i] = 0;
+      scheme_memory_actual_size[i] = scheme_memory_actual_count[i] = 0;
+      scheme_memory_hi[i] = scheme_memory_lo[i] = 0;
+    }
+    scheme_envunbox_count = scheme_envunbox_size = 0;
+    bad_seeds = 0;
+
+    traced = GC_trace_count(&stack_c, &roots_c, &uncollectable_c, &final_c);
+    GC_dump();
+
+    scheme_console_printf("\ntraced: %ld\n", traced);
+
+    tagged = tagged_while_counting;
+    
+    smc_ht = scheme_hash_table(1000, SCHEME_hash_ptr, 0, 0);
+    
+    if (tagged) 
+      GC_for_each_element(real_tagged, count_tagged, NULL);
+    if (tagged_eternal) 
+      GC_for_each_element(tagged_eternal, count_tagged, NULL);
+    if (tagged_uncollectable) 
+      GC_for_each_element(tagged_uncollectable, count_tagged, NULL);
+    if (tagged_atomic)
+      GC_for_each_element(tagged_atomic, count_tagged, NULL);
+    if (envunbox)
+      GC_for_each_element(envunbox, count_envunbox, NULL);
+
+    tagged = real_tagged;
+
+    scheme_console_printf("Begin MzScheme\n");
+    scheme_console_printf("%30.30s %10s %10s %10s %8s - %8s\n",
+			  "TYPE", "COUNT", "ESTM-SIZE", "TRACE-SIZE", 
+			  "LO-LOC", "HI-LOC");
+    for (i = 0; i < NUM_TYPE_SLOTS; i++) {
+      if (scheme_memory_count[i] || scheme_memory_actual_count[i]) {
+	scheme_console_printf("%30.30s %10ld %10ld %10ld %8lx - %8lx\n",
+			      (i < _scheme_last_type_)
+			      ? scheme_get_type_name(i)
+			      : "other",
+			      scheme_memory_count[i],
+			      scheme_memory_size[i],
+			      scheme_memory_actual_size[i],
+			      scheme_memory_lo[i],
+			      scheme_memory_hi[i]);
+	if (scheme_memory_actual_count[i] != scheme_memory_count[i]) {
+	  scheme_console_printf("%30.30s actual count: %10ld\n",
+				"", scheme_memory_actual_count[i]);
+	}
+	total_count += scheme_memory_count[i];
+	total_size += scheme_memory_size[i];
+	total_actual_count += scheme_memory_actual_count[i];
+	total_actual_size += scheme_memory_actual_size[i];
+      }
+    }
+
+    scheme_console_printf("%30.30s %10ld %10ld          -\n",
+			  "envunbox", scheme_envunbox_count, scheme_envunbox_size);
+    total_count += scheme_envunbox_count;
+    total_size += scheme_envunbox_size;
+
+    {
+      int c;
+
+      c = scheme_count_sema_callbacks(0);
+      scheme_console_printf("%30.30s %10ld          -          -\n",
+			    "semaphore-callback", c);
+      total_count += c;
+
+      c = scheme_count_sema_callbacks(1);
+      scheme_console_printf("%30.30s %10ld          -          -\n",
+			    "input-port-post-semaphore", c);
+      total_count += c;
+    }
+
+    scheme_console_printf("%30.30s          - %10ld          -\n",
+			  "miscellaneous", 
+			  scheme_misc_count + scheme_type_table_count);
+    total_size += scheme_misc_count + scheme_type_table_count;
+
+    scheme_console_printf("%30.30s          -          - %10ld\n",
+			  "roots", roots_c);
+    total_actual_size += roots_c;
+
+    scheme_console_printf("%30.30s          -          - %10ld\n",
+			  "stack", stack_c);
+    total_actual_size += stack_c;
+
+    scheme_console_printf("%30.30s          -          - %10ld\n",
+			  "unreached-uncollectable", uncollectable_c);
+    total_actual_size += uncollectable_c;
+
+    scheme_console_printf("%30.30s          -          - %10ld\n",
+			  "finalization", final_c);
+    total_actual_size += final_c;
+
+    scheme_console_printf("%30.30s %10ld %10ld %10ld\n",
+			  "total", total_count, total_size, 
+			  total_actual_size);
+    scheme_console_printf("End MzScheme\n");
+
+    {
+      Scheme_Manager *m = (Scheme_Manager *)scheme_get_param(scheme_config, MZCONFIG_MANAGER);
+      int c = 0, a = 0, u = 0, t = 0, ipt = 0, opt = 0, th = 0;
+
+      while (*m->parent)
+	m = *m->parent;
+
+      count_managed(m, &c, &a, &u, &t, &ipt, &opt, &th);
+
+      scheme_console_printf("custodians: %d  managed: actual: %d   breadth: %d   room: %d\n"
+			    "                        input-ports: %d  output-ports: %d  threads: %d\n", 
+			    t, u, c, a, ipt, opt, th);
+    }
+
+    if (bad_seeds)
+      scheme_console_printf("ERROR: %ld illegal tags found\n", bad_seeds);
+
+    smc_ht = NULL;
+  }
+#else
+  GC_dump();
+#endif
+
+  if (scheme_external_dump_info)
+    scheme_external_dump_info();
+
+#ifdef USE_TAGGED_ALLOCATION
+  {
+    void **ps = NULL;
+    int l;
+    int max_w;
+    Scheme_Object *w;
+
+    GC_trace_path();
+    
+    w = scheme_get_param(scheme_config, MZCONFIG_ERROR_PRINT_WIDTH);
+    if (SCHEME_INTP(w))
+      max_w = SCHEME_INT_VAL(w);
+    else
+      max_w = 10000;
+
+    scheme_console_printf("Begin Paths\n");
+
+    while ((ps = GC_get_next_path(ps, &l))) {
+      int i, j;
+      if (l)
+	scheme_console_printf("$%s", ps[0]);
+      for (i = 1, j = 2; i < l; i++, j += 2) {
+	void *v = ps[j];
+	unsigned long diff = (unsigned long)ps[j + 1];
+	char *type, *sep, diffstr[30];
+	struct GC_Set *home;
+
+	sep = "";
+
+	home = GC_set(v);
+	if ((home == real_tagged)
+	    || (home == tagged_atomic)
+	    || (home == tagged_uncollectable)
+	    || (home == tagged_eternal)) {
+#if 0
+	  type = scheme_get_type_name(SCHEME_TYPE((Scheme_Object *)v));
+	  if (*type)
+	    sep = ":";
+#else
+	  long len;
+	  type = scheme_write_to_string_w_max((Scheme_Object *)v, &len, max_w);
+	  sep = "=";
+#endif
+	} else if (scheme_external_dump_type) {
+	  type = scheme_external_dump_type(v);
+	  if (*type)
+	    sep = ":";
+	} else
+	  type = "";
+
+	if (diff)
+	  sprintf(diffstr, "%lx", diff);
+
+	scheme_console_printf("%s->%lx%s%s%s%s", 
+			      "\n  ",
+			      v, 
+			      sep,
+			      type,
+			      diff ? "+" : "",
+			      diff ? diffstr : "");
+      }
+      scheme_console_printf("\n");
+    }
+
+    GC_clear_paths();
+
+    scheme_console_printf("End Paths\n");
+  }
+#endif
+
+  scheme_console_printf("End Dump\n");
+
+  return scheme_void;
+}
+
+
+
+#ifdef MEMORY_COUNTING_ON
+
+long scheme_count_closure(Scheme_Object **o, short len, Scheme_Hash_Table *ht)
+{
+#if 0
+  int i;
+  int s = 0;
+
+  for (i = 0; i < len; i++) {
+    if (!scheme_lookup_in_table(ht, (const char *)o[i])) {
+      scheme_add_to_table(ht, (const char *)o[i], scheme_true, 0);
+      if (GC_size(o[i]) == sizeof(Scheme_Object *)) {
+	/* May be an environment box */
+	Scheme_Object *d = *(Scheme_Object **)o[i];
+	if (GC_size(d) >= sizeof(Scheme_Type)) {
+	  /* Ok - probably it is a box. */
+	  s += sizeof(Scheme_Object *);
+	  s += scheme_count_memory(d, ht);
+	} else {
+	  /* Not an environment box. */
+	  s += scheme_count_memory(o[i], ht);
+	}
+      } else {
+	s += scheme_count_memory(o[i], ht);
+      }
+    }
+  }
+
+  return s;
+#endif
+  return 0;
+}
+
+
+#if 0
+void scheme_check_home(Scheme_Object *root)
+{
+  struct GC_Set *home;
+  home = GC_set(root);
+  if ((home != real_tagged)
+      && (home != tagged_atomic)
+      && (home != tagged_uncollectable)
+      && (home != tagged_eternal)) {
+    scheme_console_printf("Check: bad Scheme object: %lx\n", (unsigned long)root);
+  }
+}
+#endif
+
+#define FORCE_SUBPARTS 0
+#define FORCE_KNOWN_SUBPARTS 1
+#define CAN_TRACE_HOME 1
+
+long scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht)
+{
+  Scheme_Type type;
+  long s = sizeof(Scheme_Object), e = 0;
+  int need_align = 0;
+  struct GC_Set *home;
+
+  if (!root || SCHEME_INTP(root))
+    return 0;
+
+  type = SCHEME_TYPE(root);
+
+  if (type >= _scheme_last_type_)
+    return 0;
+
+  if (scheme_lookup_in_table(ht, (const char *)root))
+    return 0;
+
+  home = GC_set(root);
+#if CAN_TRACE_HOME
+  if ((home != real_tagged)
+      && (home != tagged_atomic)
+      && (home != tagged_uncollectable)
+      && (home != tagged_eternal)) {
+    scheme_console_printf("Bad Scheme object: %lx\n", (unsigned long)root);
+    return 0;
+  }
+#endif
+
+  scheme_add_to_table(ht, (const char *)root, scheme_true, 0);
+
+#define COUNT(x) scheme_count_memory((Scheme_Object *)x, ht)
+
+  switch (type) {
+  case scheme_variable_type:
+    s = sizeof(Scheme_Bucket);
+#if FORCE_SUBPARTS
+    e = COUNT(((Scheme_Bucket *)root)->key)
+      + COUNT(((Scheme_Bucket *)root)->val);
+#endif
+    break;
+  case scheme_local_type: 
+  case scheme_local_unbox_type:
+    s = sizeof(Scheme_Local);
+    break;
+  case scheme_syntax_type:
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_PTR2_VAL(root));
+#endif
+    break;
+  case scheme_application_type:
+    {
+      Scheme_App_Rec *app = (Scheme_App_Rec *)root;
+      int i;
+
+      s = sizeof(Scheme_App_Rec) + (app->num_args * sizeof(Scheme_Object *))
+	+ (app->num_args + 1);
+      need_align = 1;
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(app->args[0]);
+      for (i = 1; i <= app->num_args; i++)
+	e += COUNT(app->args[i]);
+#endif
+    }
+    break;
+  case scheme_sequence_type:
+  case scheme_case_lambda_sequence_type:
+  case scheme_begin0_sequence_type:
+  case scheme_case_closure_type:
+    {
+      Scheme_Sequence *seq = (Scheme_Sequence *)root;
+      int i;
+
+      s = sizeof(Scheme_Sequence) + (seq->count - 1) * sizeof(Scheme_Object *);
+
+#if FORCE_KNOWN_SUBPARTS
+      for (i = e = 0; i < seq->count; i++)
+	e += COUNT(seq->array[i]);
+#endif
+    }
+    break;
+  case scheme_branch_type:
+    {
+      Scheme_Branch_Rec *rec = (Scheme_Branch_Rec *)root;
+      
+      s = sizeof(Scheme_Branch_Rec);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(rec->test) + COUNT(rec->tbranch) + COUNT(rec->fbranch);
+#endif
+    }
+    break;
+  case scheme_unclosed_procedure_type:
+  case scheme_compiled_unclosed_procedure_type:
+    {
+      Scheme_Closure_Compilation_Data *data = 
+	(Scheme_Closure_Compilation_Data *)root;
+
+      s = sizeof(Scheme_Closure_Compilation_Data);
+      s += data->closure_size * sizeof(short);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(data->code);
+#endif
+    }
+    break;
+  case scheme_let_value_type:
+    {
+      Scheme_Let_Value *let = (Scheme_Let_Value *)root;
+
+      s = sizeof(Scheme_Let_Value);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(let->value) + COUNT(let->body);
+#endif
+    }
+    break;
+  case scheme_compiled_let_value_type:
+    {
+      Scheme_Compiled_Let_Value *let = (Scheme_Compiled_Let_Value *)root;
+
+      s = sizeof(Scheme_Compiled_Let_Value);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(let->value) + COUNT(let->body);
+#endif
+    }
+    break;
+  case scheme_let_void_type:
+    {
+      Scheme_Let_Void *let = (Scheme_Let_Void *)root;
+
+      s = sizeof(Scheme_Let_Void);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(let->body);
+#endif
+    }
+    break;
+  case scheme_compiled_let_void_type:
+    {
+      Scheme_Let_Header *let = (Scheme_Let_Header *)root;
+
+      s = sizeof(Scheme_Let_Header);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(let->body);
+#endif
+    }
+    break;
+  case scheme_letrec_type:
+    {
+      Scheme_Letrec *let = (Scheme_Letrec *)root;
+      int i;
+
+      s = sizeof(Scheme_Letrec);
+      s += let->count * sizeof(Scheme_Object *);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(let->body);
+      for (i = 0; i < let->count; i++)
+	e += COUNT(let->procs[i]);
+#endif
+    }
+    break;
+  case  scheme_quote_compilation_type:
+    s = sizeof(Scheme_Small_Object);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_PTR_VAL(root));
+#endif
+    break;
+  case scheme_char_type:
+    s = sizeof(Scheme_Small_Object);
+    break;
+  case scheme_integer_type:
+    s = 0;
+    break;
+  case scheme_double_type:
+    s = sizeof(Scheme_Double);
+    break;
+  case scheme_float_type:
+    break;
+  case scheme_string_type:
+    s += (SCHEME_STRTAG_VAL(root) + 1);
+    need_align = 1;
+    break;
+  case scheme_symbol_type:
+    s = sizeof(Scheme_Symbol) + SCHEME_SYM_LEN(root) - 1;
+    need_align = 1;
+    break;
+  case scheme_null_type: 
+    break;
+  case scheme_pair_type:
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_CAR(root)) + COUNT(SCHEME_CDR(root));
+#endif
+    break;
+  case scheme_vector_type:
+    {
+      int count = SCHEME_VEC_SIZE(root), i;
+      Scheme_Object **array = SCHEME_VEC_ELS(root);
+
+      s += count * sizeof(Scheme_Object*);
+
+#if FORCE_KNOWN_SUBPARTS
+      for (i = e = 0; i < count; i++)
+	e += COUNT(array[i]);
+#endif
+    }
+    break;
+  case scheme_prim_type:
+    {
+      if (((Scheme_Primitive_Proc *)root)->flags & SCHEME_PRIM_IS_MULTI_RESULT)
+	s = sizeof(Scheme_Prim_W_Result_Arity);
+      else
+	s = sizeof(Scheme_Primitive_Proc);
+    }	
+    break;
+  case scheme_closure_type:
+#if FORCE_KNOWN_SUBPARTS
+    e = (COUNT(SCHEME_CLOS_CODE(root))
+	 + COUNT(SCHEME_CLOS_ENV(root)));
+#endif
+    break;
+  case scheme_linked_closure_type:
+    {
+      Scheme_Closure_Compilation_Data *data;
+      Scheme_Object **vals;
+      
+      data = (Scheme_Closure_Compilation_Data *)SCHEME_COMPILED_CLOS_CODE(root);
+      vals = SCHEME_COMPILED_CLOS_ENV(root);
+
+      s += (data->closure_size * sizeof(Scheme_Object *));
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(data) + scheme_count_closure(vals, data->closure_size, ht);
+#endif
+    }
+    break;
+  case scheme_closed_prim_type:
+    {
+      if (((Scheme_Closed_Primitive_Proc *)root)->flags & SCHEME_PRIM_IS_MULTI_RESULT)
+	s = sizeof(Scheme_Closed_Prim_W_Result_Arity);
+      else
+	s = sizeof(Scheme_Closed_Primitive_Proc);
+    }	
+    break;
+  case scheme_cont_type:
+    {
+      Scheme_Cont *c = (Scheme_Cont *)root;
+      Scheme_Saved_Stack *rs;
+
+      s = sizeof(Scheme_Cont);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(c->home);
+#endif
+
+      for (rs = c->runstack_copied; rs; rs = rs->prev) {
+	s += sizeof(Scheme_Saved_Stack);
+	scheme_count_closure(rs->runstack,
+			     rs->runstack_size
+			     - (rs->runstack
+				- rs->runstack_start),
+			     ht);
+      }
+    }
+    break;
+  case scheme_input_port_type: 
+    scheme_count_input_port(root, &s, &e, ht);
+    break;
+  case scheme_output_port_type:
+    scheme_count_output_port(root, &s, &e, ht);
+    break;
+  case scheme_eof_type:
+  case scheme_true_type: 
+  case scheme_false_type:
+  case scheme_void_type:
+  case scheme_undefined_type:
+    /* Only one */
+    break;
+  case scheme_syntax_compiler_type:
+    break;
+  case scheme_macro_type:
+  case scheme_id_macro_type:
+  case scheme_exp_time_type:
+    s = sizeof(Scheme_Small_Object);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_PTR_VAL(root));
+#endif
+    break;
+  case scheme_promise_type: 
+    s = sizeof(Scheme_Promise);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(((Scheme_Promise *)root)->val);
+#endif
+    break;
+  case scheme_box_type:
+    s = sizeof(Scheme_Small_Object);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_BOX_VAL(root));
+#endif
+    break;
+  case scheme_will_executor_type:
+    s = sizeof(Scheme_Object);
+    break;
+  case scheme_manager_type: 
+    {
+      Scheme_Manager *m = (Scheme_Manager *)root;
+
+      s = sizeof(Scheme_Manager);
+      e = m->alloc * (sizeof(Scheme_Object **)
+		      + sizeof(Scheme_Manager_Reference *)
+		      + sizeof(void *)
+		      + sizeof(void *));
+    }
+    break;
+  case scheme_process_type:
+    {
+      Scheme_Process *p = (Scheme_Process *)root;
+      Scheme_Saved_Stack *saved;
+
+      s = sizeof(Scheme_Process)
+	+ ((p->runstack_size + p->tail_buffer_size) * sizeof(Scheme_Object *));
+
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(p->config);
+#endif
+
+      /* Check stack: */
+      
+      scheme_count_closure(p->runstack,
+			   p->runstack_size
+			   - (p->runstack
+			      - p->runstack_start),
+			   ht);
+      for (saved = p->runstack_saved; saved; saved = saved->prev) {
+	s += (saved->runstack_size * sizeof(Scheme_Object *));
+	scheme_count_closure(saved->runstack,
+			     saved->runstack_size
+			     - (saved->runstack
+				- saved->runstack_start),
+			     ht);
+      }
+    }
+    break;
+  case scheme_namespace_type:
+    {
+      Scheme_Env *env = (Scheme_Env *)root;
+
+      s = sizeof(Scheme_Env);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(env->globals) + COUNT(env->nonempty_cond);
+#endif
+    }
+    break;
+  case scheme_config_type:
+    {
+      s = sizeof(Scheme_Config) + (sizeof(Scheme_Object *) * __MZCONFIG_BUILTIN_COUNT__);
+#if FORCE_SUBPARTS
+      {
+	Scheme_Config *c = (Scheme_Config *)root;
+	int i;
+
+	e = COUNT(c->extensions) + COUNT(c->base);
+
+	for (i = 0; i < __MZCONFIG_BUILTIN_COUNT__; i++)
+	  e += COUNT(*c->configs[i]);
+      }
+#endif
+    }
+    break;
+  case scheme_defaulting_config_type:
+#if FORCE_SUBPARTS
+    e += COUNT(SCHEME_LPTR_VAL(root));
+#endif
+    break;
+#ifndef NO_UNIT_SYSTEM
+  case scheme_unit_type:
+  case scheme_compiled_unit_type:
+  case scheme_unit_body_data_type:
+  case scheme_unit_compound_data_type:
+  case scheme_invoke_unit_data_type:
+    scheme_count_unit(type, root, &s, &e, ht);    
+    break;
+#endif
+#ifndef NO_OBJECT_SYSTEM
+  case scheme_object_type:
+    scheme_count_object(root, &s, &e, ht);
+    break;
+  case scheme_class_type:
+    scheme_count_class(root, &s, &e, ht);
+    break;
+#endif
+  case scheme_structure_type:
+    {
+      Scheme_Object **slots = ((Scheme_Structure *)root)->slots;
+      int i, count = SCHEME_STRUCT_NUM_SLOTS(root);
+
+      s = sizeof(Scheme_Structure) + (count - 1) * sizeof(Scheme_Object *);
+#if FORCE_KNOWN_SUBPARTS
+      for (i = e = 0; i < count; i++)
+	e += COUNT(slots[i]);
+      e += COUNT(((Scheme_Structure *)root)->stype);
+#endif
+    }
+    break;
+  case scheme_generic_type:
+    s = 0; /* Unknown */
+    break;
+  case scheme_type_symbol_type:
+    s = sizeof(Scheme_Small_Object);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(SCHEME_PTR_VAL(root));
+#endif
+    break;
+  case scheme_bignum_type:
+    {
+      int count = SCHEME_BIGLEN(root);
+
+      if (count < 0)
+	count = -count;
+
+      s = sizeof(Small_Bignum) + (count - 1) * sizeof(bigdig);
+    }
+    break;
+  case scheme_escaping_cont_type:
+    s = sizeof(Scheme_Escaping_Cont);
+    break;
+  case scheme_sema_type:
+    s = sizeof(Scheme_Sema);
+    break;
+  case scheme_compilation_top_type:
+    s = sizeof(Scheme_Compilation_Top);
+    break;
+  case scheme_hash_table_type:
+    {
+      Scheme_Hash_Table *ht = (Scheme_Hash_Table *)root;
+
+      s = sizeof(Scheme_Hash_Table)
+	+ ht->size * sizeof(Scheme_Object *);
+      
+#if FORCE_SUBPARTS
+      {
+	int i;
+	for (i = e = 0; i < ht->size; i++)
+	  if (ht->buckets[i]) {
+	    if (ht->by_address)
+	      e += COUNT(ht->buckets[i]);
+	    else
+	      e += COUNT(ht->buckets[i]->val);
+	  }
+      }
+#endif
+    }
+    break;
+#ifndef NO_OBJECT_SYSTEM
+  case scheme_generic_data_type:
+    scheme_count_generic(root, &s, &e, ht);
+    break;
+#endif
+  case scheme_weak_box_type:
+    s = sizeof(Scheme_Small_Object);
+    e = COUNT(SCHEME_BOX_VAL(root));
+    break;
+  case scheme_complex_type:
+    s = sizeof(Scheme_Complex);
+    e = COUNT(((Scheme_Complex *)root)->r) + COUNT(((Scheme_Complex *)root)->i);
+    break;
+  case scheme_rational_type:
+    s = sizeof(Scheme_Rational);
+#if FORCE_KNOWN_SUBPARTS
+    e = COUNT(((Scheme_Rational *)root)->num) 
+      + COUNT(((Scheme_Rational *)root)->denom);
+#endif
+    break;
+  case scheme_struct_type_type:
+    {
+      Scheme_Struct_Type *st = (Scheme_Struct_Type *)root;
+      s = sizeof(Scheme_Struct_Type) + st->name_pos * sizeof(Scheme_Object*);
+#if FORCE_KNOWN_SUBPARTS
+      e = COUNT(st->type_name);
+      if (st->name_pos)
+	e += COUNT(st->parent_types[st->name_pos - 1]);
+#endif
+    }
+    break;
+  case scheme_listener_type:
+    s = sizeof(Scheme_Small_Object);
+    break;
+  case scheme_reserved_4_type:
+    s = 0; /* Not yet used */
+    break;
+  case scheme_eval_waiting_type:
+  case scheme_tail_call_waiting_type:
+    /* Only one */
+    break;
+#ifndef NO_OBJECT_SYSTEM
+  case scheme_class_data_type:
+    scheme_count_class_data(root, &s, &e, ht);
+    break;
+#endif
+  case scheme_struct_info_type:
+    scheme_count_struct_info(root, &s, &e, ht);
+    break;
+  case scheme_multiple_values_type:
+    /* Only one */
+    break;
+  case scheme_placeholder_type:
+    s = 0; /* Infrequent */
+    break;
+  default:
+    s = 0;
+    break;
+  }
+
+  if (need_align) {
+    /* Round up to sizeof(void*) boundary: */
+    if (s & (sizeof(void*) - 1))
+      s += sizeof(void*) - (s & (sizeof(void*) - 1));
+  }
+
+  scheme_memory_count[type]++;
+  scheme_memory_size[type] += s;
+
+  return s;
+}
+
+long scheme_count_envbox(Scheme_Object *root, Scheme_Hash_Table *ht)
+{
+#if CAN_TRACE_HOME
+  if (GC_set(root) != envunbox) {
+    scheme_console_printf("Bad envunbox object: %lx\n", (unsigned long)root);
+    return 0;
+  }
+#endif
+
+  return scheme_count_memory(SCHEME_ENVBOX_VAL(root), ht) + 4;
+}
+
+#if 0
+Scheme_Object *scheme_dump_memory_count(int c, Scheme_Object **a)
+{
+  int i, special = 0;
+  Scheme_Object *root;
+  Scheme_Hash_Table *ht;
+  long total_count = 0, total_local = 0, total_extended = 0;
+
+  ht = scheme_hash_table(1000, SCHEME_hash_ptr, 0, 0);
+
+  if (c) {
+    if (SCHEME_FALSEP(a[0])) {
+      special = 1;
+      root = (Scheme_Object *)scheme_symbol_table;
+    } else
+      root = a[0];
+  } else {
+    root = (Scheme_Object *)scheme_first_process;
+  }
+
+  scheme_count_memory(root, ht);
+
+  for (i = 0; i < _scheme_last_type_; i++) {
+    if (scheme_memory_count[i]) {
+      scheme_console_printf("%30.30s %10ld %10ld %10ld\n",
+			    scheme_get_type_name(i),
+			    scheme_memory_count[i],
+			    scheme_memory_local[i],
+			    scheme_memory_extended[i]);
+      total_count += scheme_memory_count[i];
+      total_local += scheme_memory_local[i];
+      total_extended += scheme_memory_extended[i];
+    }
+  }
+
+  scheme_console_printf("%30.30s %10ld %10ld %10ld\n",
+			"total", 
+			total_count,
+			total_local,
+			total_extended);
+  if (special) {
+    scheme_console_printf("%30.30s %10ld\n",
+			  "type tables", 
+			  scheme_type_table_count);
+    scheme_console_printf("%30.30s %10ld\n",
+			  "miscellaneous", 
+			  scheme_misc_count);
+  }
+
+  return scheme_void;
+}
+#endif
+
+#endif
diff --git a/src/mzscheme/src/schcpt.h b/src/mzscheme/src/schcpt.h
new file mode 100644
index 0000000..624d0ae
--- /dev/null
+++ b/src/mzscheme/src/schcpt.h
@@ -0,0 +1,55 @@
+
+enum {
+  CPT_ESCAPE,
+  CPT_SYMBOL,
+  CPT_STRING,
+  CPT_CHAR,
+  CPT_INT,
+  CPT_NULL,
+  CPT_TRUE,
+  CPT_FALSE,
+  CPT_BOX,
+  CPT_PAIR,
+  CPT_LIST,
+  CPT_VECTOR,
+  CPT_MARSHALLED,
+  CPT_QUOTE,
+  CPT_REFERENCE,
+  CPT_LOCAL,
+  CPT_LOCAL_UNBOX,
+  CPT_SVECTOR,
+  CPT_APPLICATION,
+  _CPT_COUNT_
+};
+
+#define CPT_SMALL_NUMBER_START 20
+#define CPT_SMALL_NUMBER_END   30
+
+#define CPT_SMALL_SYMBOL_START 30
+#define CPT_SMALL_SYMBOL_END   50
+
+#define CPT_SMALL_MARSHALLED_START 50
+#define CPT_SMALL_MARSHALLED_END 75
+
+#define _SMALL_LIST_MAX_ 50
+
+#define CPT_SMALL_PROPER_LIST_START 75
+#define CPT_SMALL_PROPER_LIST_END  (CPT_SMALL_PROPER_LIST_START + _SMALL_LIST_MAX_) 
+
+#define CPT_SMALL_LIST_START CPT_SMALL_PROPER_LIST_END
+#define CPT_SMALL_LIST_END   (CPT_SMALL_LIST_START + _SMALL_LIST_MAX_)
+
+#define CPT_SMALL_LOCAL_START 175
+#define CPT_SMALL_LOCAL_END 190
+#define CPT_SMALL_LOCAL_UNBOX_START 190
+#define CPT_SMALL_LOCAL_UNBOX_END 205
+
+#define CPT_SMALL_SVECTOR_START 205
+#define CPT_SMALL_SVECTOR_END 230
+
+#define CPT_SMALL_APPLICATION_START 230
+#define CPT_SMALL_APPLICATION_END 240
+
+#define CPT_BETWEEN(x, s) ((x >= CPT_ ## s ## _START) && (x < CPT_ ## s ## _END))
+#define CPT_RANGE(s) (CPT_ ## s ## _END - CPT_ ## s ## _START)
+
diff --git a/src/mzscheme/src/schemef.h b/src/mzscheme/src/schemef.h
new file mode 100644
index 0000000..173f382
--- /dev/null
+++ b/src/mzscheme/src/schemef.h
@@ -0,0 +1,558 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* MzScheme function prototypes */
+/* No macros should go in this file; it is used both to
+   prototype functions, and as a parsing source for
+   declaring scheme_extension_table */
+
+/* The scheme_extension_table parser is touchy: don't leave a space
+   between a function name and it's opening parameter parenthesis. */
+
+/* After this START tag, all comments should start & end on same line */
+
+/* START */
+
+/* Call/cc utilities */
+void scheme_init_jmpup_buf(Scheme_Jumpup_Buf *b);
+int scheme_setjmpup_relative(Scheme_Jumpup_Buf *b, void *start, 
+			     Scheme_Jumpup_Buf *cont);
+void scheme_longjmpup(Scheme_Jumpup_Buf *b);
+
+#ifdef USE_MZ_SETJMP
+int scheme_setjmp(jmp_buf b);
+void scheme_longjmp(jmp_buf b, int v);
+#endif
+
+/* Parameters */
+Scheme_Object *scheme_make_config(Scheme_Config *base);
+Scheme_Object *scheme_branch_config(void);
+int scheme_new_param(void);
+
+Scheme_Object *scheme_param_config(char *name, long pos,
+				   int argc, Scheme_Object **argv,
+				   int arity, 
+				   Scheme_Prim *check, char *expected,
+				   int isbool);
+Scheme_Object *scheme_register_parameter(Scheme_Prim *function, char *name, int which);
+Scheme_Env *scheme_get_env(Scheme_Config *config);
+
+/* Processes */
+#ifdef MZ_REAL_THREADS
+Scheme_Process *scheme_get_current_process();
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+extern Scheme_Process *scheme_current_process;
+extern int scheme_fuel_counter;
+#else
+extern Scheme_Process **scheme_current_process_ptr;
+extern int *scheme_fuel_counter_ptr;
+#endif
+#endif
+
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *scheme_make_namespace(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_thread(Scheme_Object *thunk, Scheme_Config *config);
+void scheme_break_thread(Scheme_Process *p);
+void scheme_kill_thread(Scheme_Process *p);
+#endif
+
+#ifndef MZ_REAL_THREADS
+void scheme_process_block(float sleep_time);
+void scheme_swap_process(Scheme_Process *process);
+#else
+void scheme_process_block_w_process(float sleep_time, Scheme_Process *p);
+#endif
+
+int scheme_block_until(int (*f)(Scheme_Object *), void (*fdfd)(Scheme_Object *, void *), void *, float);
+
+int scheme_in_main_thread(void);
+
+int scheme_tls_allocate();
+void scheme_tls_set(int pos, void *v);
+void *scheme_tls_get(int pos);
+
+void scheme_add_namespace_option(Scheme_Object *key, void (*f)(Scheme_Env *));
+
+Scheme_Manager *scheme_make_manager(Scheme_Manager *);
+Scheme_Manager_Reference *scheme_add_managed(Scheme_Manager *m, Scheme_Object *o, 
+					     Scheme_Close_Manager_Client *f, void *data, 
+					     int strong);
+void scheme_remove_managed(Scheme_Manager_Reference *m, Scheme_Object *o);
+void scheme_close_managed(Scheme_Manager *m);
+
+/* error handling */
+void scheme_signal_error(char *msg, ...);
+void scheme_raise_exn(int exnid, ...);
+void scheme_warning(char *msg, ...);
+
+void scheme_wrong_count(const char *name, int minc, int maxc, int argc,
+			Scheme_Object **argv);
+void scheme_case_lambda_wrong_count(const char *name, int argc, 
+				    Scheme_Object **argv, int count, ...);
+void scheme_wrong_type(const char *name, const char *expected, 
+		       int which, int argc,
+		       Scheme_Object **argv);
+void scheme_wrong_return_arity(const char *where, 
+			       int expected, int got,
+			       Scheme_Object **argv,
+			       const char *context_detail, ...);
+void scheme_unbound_global(Scheme_Object *name);
+
+Scheme_Object *scheme_dynamic_wind(void (*pre)(void *),
+				   Scheme_Object *(*act)(void *),
+				   void (*post)(void *), 
+				   Scheme_Object *(*jmp_handler)(void *),
+				   void *data);
+
+/* Types */
+Scheme_Type scheme_make_type(const char *name);
+
+/* Type readers & writers for compiled code data */
+void scheme_install_type_reader(Scheme_Type type, Scheme_Type_Reader f);
+void scheme_install_type_writer(Scheme_Type type, Scheme_Type_Writer f);
+
+/* Constants */
+extern Scheme_Object *scheme_eof;
+extern Scheme_Object *scheme_null;
+extern Scheme_Object *scheme_true;
+extern Scheme_Object *scheme_false;
+extern Scheme_Object *scheme_void;
+extern Scheme_Object *scheme_undefined;
+extern Scheme_Object *scheme_tail_call_waiting;
+extern Scheme_Object *scheme_multiple_values;
+
+/* Basics */
+Scheme_Object *scheme_eval(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *scheme_eval_multi(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *scheme_eval_compiled(Scheme_Object *obj);
+Scheme_Object *scheme_eval_compiled_multi(Scheme_Object *obj);
+Scheme_Object *_scheme_eval_compiled(Scheme_Object *obj);
+Scheme_Object *_scheme_eval_compiled_multi(Scheme_Object *obj);
+#ifndef MZ_REAL_THREADS
+Scheme_Object *scheme_apply(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+Scheme_Object *scheme_apply_multi(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+#else
+Scheme_Object *scheme_apply_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+			       Scheme_Process *p);
+Scheme_Object *scheme_apply_multi_wp(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+				     Scheme_Process *p);
+#endif
+Scheme_Object *scheme_apply_to_list(Scheme_Object *rator, Scheme_Object *argss);
+Scheme_Object *scheme_eval_string(const char *str, Scheme_Env *env);
+Scheme_Object *scheme_eval_string_all(const char *str, Scheme_Env *env, int all);
+
+Scheme_Object *_scheme_apply_known_closed_prim(Scheme_Object *rator, int argc,
+					       Scheme_Object **argv);
+Scheme_Object *_scheme_apply_known_closed_prim_multi(Scheme_Object *rator, int argc,
+						     Scheme_Object **argv);
+
+Scheme_Object *scheme_values(int c, Scheme_Object **v);
+
+Scheme_Object *scheme_check_one_value(Scheme_Object *v);
+
+/* Tail calls - only use these when you're writing new functions/syntax */
+Scheme_Object *scheme_tail_apply(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *scheme_tail_apply_no_copy(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *scheme_tail_apply_to_list(Scheme_Object *f, Scheme_Object *l);
+
+Scheme_Object *scheme_tail_eval_expr(Scheme_Object *obj);
+
+void scheme_set_tail_buffer_size(int s);
+Scheme_Object *scheme_force_value(Scheme_Object *);
+
+/* Internal */
+#ifndef MZ_REAL_THREADS
+Scheme_Object *scheme_do_eval(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val);
+#else
+Scheme_Object *scheme_do_eval_w_process(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val, Scheme_Process *p);
+#endif
+
+/* Allocation */
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+void *GC_malloc(size_t size_in_bytes);
+void *GC_malloc_atomic(size_t size_in_bytes);
+void *GC_malloc_stubborn(size_t size_in_bytes);
+void *GC_malloc_uncollectable(size_t size_in_bytes);
+#endif
+#endif
+
+void *scheme_malloc_eternal(size_t n);
+void scheme_end_stubborn_change(void *p);
+
+void *scheme_calloc(size_t num, size_t size);
+
+char *scheme_strdup(const char *str);
+char *scheme_strdup_eternal(const char *str);
+
+void *scheme_malloc_fail_ok(void *(*f)(size_t), size_t);
+
+void scheme_weak_reference(void **p);
+void scheme_weak_reference_indirect(void **p, void *v);
+void scheme_add_finalizer(void *p, void (*f)(void *p, void *data), void *data);
+void scheme_add_scheme_finalizer(void *p, void (*f)(void *p, void *data), void *data);
+void scheme_register_finalizer(void *p, 
+			       void (*f)(void *p, void *data), void *data,
+			       void (**oldf)(void *p, void *data), 
+			       void **olddata);
+
+void scheme_dont_gc_ptr(void *p);
+void scheme_gc_ptr_ok(void *p);
+
+void scheme_collect_garbage(void);
+
+/* Hash table */
+Scheme_Hash_Table *scheme_hash_table(int size, int type, 
+				      int w_const, int forever);
+void scheme_add_to_table(Scheme_Hash_Table *table, const char *key, void *val, int);
+void scheme_change_in_table(Scheme_Hash_Table *table, const char *key, void *new_val);
+void *scheme_lookup_in_table(Scheme_Hash_Table *table, const char *key);
+Scheme_Bucket *scheme_bucket_from_table(Scheme_Hash_Table *table, const char *key);
+
+/* Constructors */
+Scheme_Object *scheme_make_prim(Scheme_Prim *prim);
+Scheme_Object *scheme_make_noneternal_prim(Scheme_Prim *prim);
+Scheme_Object *scheme_make_closed_prim(Scheme_Closed_Prim *prim, void *data);
+Scheme_Object *scheme_make_prim_w_arity(Scheme_Prim *prim, const char *name,
+					short mina, short maxa);
+Scheme_Object *scheme_make_folding_prim(Scheme_Prim *prim, 
+					const char *name,
+					short mina, short maxa,
+					short functional);
+Scheme_Object *scheme_make_noneternal_prim_w_arity(Scheme_Prim *prim, 
+						   const char *name, 
+						   short mina, short maxa);
+Scheme_Object *scheme_make_closed_prim_w_arity(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa);
+Scheme_Object *scheme_make_folding_closed_prim(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa,
+					       short functional);
+
+Scheme_Object *scheme_make_closure(Scheme_Env *env, Scheme_Object *code);
+Scheme_Object *scheme_make_pair(Scheme_Object *car, Scheme_Object *cdr);
+Scheme_Object *scheme_make_string(const char *chars);
+Scheme_Object *scheme_make_sized_string(char *chars, long len, int copy);
+Scheme_Object *scheme_make_string_without_copying(char *chars);
+Scheme_Object *scheme_alloc_string(int size, char fill);
+Scheme_Object *scheme_append_string(Scheme_Object *, Scheme_Object *);
+Scheme_Object *scheme_make_vector(int size, Scheme_Object *fill);
+Scheme_Object *scheme_make_integer_value(long i);
+Scheme_Object *scheme_make_integer_value_from_unsigned(unsigned long i);
+Scheme_Object *scheme_make_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+Scheme_Object *scheme_make_float(float f);
+#endif
+Scheme_Object *scheme_make_char(char ch);
+Scheme_Object *scheme_make_promise(Scheme_Object *expr, Scheme_Env *env);
+Scheme_Object *scheme_make_promise_from_thunk(Scheme_Object *expr);
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *scheme_make_sema(long v);
+#endif
+void scheme_post_sema(Scheme_Object *o);
+int scheme_wait_sema(Scheme_Object *o, int just_try);
+extern Scheme_Object **scheme_char_constants;
+
+int scheme_get_int_val(Scheme_Object *o, long *v);
+int scheme_get_unsigned_int_val(Scheme_Object *o, unsigned long *v);
+
+const char *scheme_get_proc_name(Scheme_Object *p, int *len, int for_error);
+
+/* Bignums */
+Scheme_Object *scheme_make_bignum(long v);
+Scheme_Object *scheme_make_bignum_from_unsigned(unsigned long v);
+double scheme_bignum_to_double(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_from_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float scheme_bignum_to_float(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_from_float(float d);
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+char *scheme_bignum_to_string(const Scheme_Object *n, int radix);
+Scheme_Object *scheme_read_bignum(const char *str, int radix);
+Scheme_Object *scheme_bignum_normalize(const Scheme_Object *n);
+
+long scheme_double_to_int(const char *where, double d);
+
+/* Rationals */
+Scheme_Object *scheme_make_rational(const Scheme_Object *r, const Scheme_Object *d);
+double scheme_rational_to_double(const Scheme_Object *n);
+Scheme_Object *scheme_rational_from_double(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float scheme_rational_to_float(const Scheme_Object *n);
+Scheme_Object *scheme_rational_from_float(float d);
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+Scheme_Object *scheme_rational_normalize(const Scheme_Object *n);
+Scheme_Object *scheme_rational_numerator(const Scheme_Object *n);
+Scheme_Object *scheme_rational_denominator(const Scheme_Object *n);
+
+/* Complex */
+Scheme_Object *scheme_make_complex(const Scheme_Object *r, const Scheme_Object *i);
+Scheme_Object *scheme_complex_normalize(const Scheme_Object *n);
+Scheme_Object *scheme_complex_real_part(const Scheme_Object *n);
+Scheme_Object *scheme_complex_imaginary_part(const Scheme_Object *n);
+
+/* Exact/inexact: */
+int scheme_is_exact(Scheme_Object *n);
+int scheme_is_inexact(Scheme_Object *n);
+
+/* Macro and syntax expansion */
+Scheme_Object *scheme_expand(Scheme_Object *form, Scheme_Env *env);
+
+/* Compilation */
+Scheme_Object *scheme_compile(Scheme_Object *form, Scheme_Env *env, int writeable);
+Scheme_Object *scheme_make_promise_value(Scheme_Object *compiled_expr);
+
+/* Ports */
+Scheme_Object *scheme_read(Scheme_Object *port);
+void scheme_write(Scheme_Object *obj, Scheme_Object *port);
+void scheme_display(Scheme_Object *obj, Scheme_Object *port);
+void scheme_write_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void scheme_display_w_max(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void scheme_write_string(const char *str, long len, Scheme_Object *port);
+char *scheme_write_to_string(Scheme_Object *obj, long *len);
+char *scheme_display_to_string(Scheme_Object *obj, long *len);
+char *scheme_write_to_string_w_max(Scheme_Object *obj, long *len, long maxl);
+char *scheme_display_to_string_w_max(Scheme_Object *obj, long *len, long maxl);
+void scheme_debug_print(Scheme_Object *obj);
+void scheme_flush_output(Scheme_Object *port);
+
+char *scheme_format(char *format, int flen, int argc, Scheme_Object **argv, int *rlen);
+void scheme_printf(char *format, int flen, int argc, Scheme_Object **argv);
+
+int scheme_getc(Scheme_Object *port);
+void scheme_ungetc(int ch, Scheme_Object *port);
+int scheme_char_ready(Scheme_Object *port);
+void scheme_need_wakeup(Scheme_Object *port, void *fds);
+long scheme_get_chars(Scheme_Object *port, long size, char *buffer);
+long scheme_tell(Scheme_Object *port);
+long scheme_output_tell(Scheme_Object *port);
+long scheme_tell_line(Scheme_Object *port);
+void scheme_close_input_port(Scheme_Object *port);
+void scheme_close_output_port(Scheme_Object *port);
+int scheme_are_all_chars_ready(Scheme_Object *port);
+
+Scheme_Object *scheme_make_port_type(const char *name);
+Scheme_Input_Port *scheme_make_input_port(Scheme_Object *subtype, void *data,
+					  int (*getc_fun)(Scheme_Input_Port*),
+					  int (*char_ready_fun)
+					  (Scheme_Input_Port*),
+					  void (*close_fun)
+					  (Scheme_Input_Port*),
+					  void (*need_wakeup_fun)
+					  (Scheme_Input_Port*, void *),
+					  int must_close);
+Scheme_Output_Port *scheme_make_output_port(Scheme_Object *subtype,
+					    void *data,
+					    void (*write_string_fun)
+					    (char*,long, Scheme_Output_Port*),
+					    void (*close_fun)
+					    (Scheme_Output_Port*),
+					    int must_close);
+
+Scheme_Object *scheme_make_file_input_port(FILE *fp);
+Scheme_Object *scheme_make_named_file_input_port(FILE *fp, const char *filename);
+Scheme_Object *scheme_make_file_output_port(FILE *fp);
+
+Scheme_Object *scheme_make_string_input_port(const char *str);
+Scheme_Object *scheme_make_sized_string_input_port(const char *str, long len);
+Scheme_Object *scheme_make_string_output_port();
+char *scheme_get_string_output(Scheme_Object *);
+char *scheme_get_sized_string_output(Scheme_Object *, int *len);
+
+void scheme_pipe(Scheme_Object **write, Scheme_Object **read);
+
+int scheme_file_exists(char *filename);
+int scheme_directory_exists(char *dirname);
+char *scheme_expand_filename(char* filename, int ilen, char *errorin, int *ex);
+
+char *scheme_getcwd(char *buf, int buflen, int *actlen, int noexn);
+int scheme_setcwd(char *buf, int noexn);
+char *scheme_getdrive(void);
+
+Scheme_Object *scheme_split_pathname(int argc, Scheme_Object **argv);
+Scheme_Object *scheme_build_pathname(int argc, Scheme_Object **argv);
+
+void *scheme_alloc_fdset_array(int count, int permanent);
+void *scheme_init_fdset_array(void *fdarray, int count);
+void *scheme_get_fdset(void *fdarray, int pos);
+void scheme_fdzero(void *fd);
+void scheme_fdset(void *fd, int pos);
+void scheme_fdclr(void *fd, int pos);
+int scheme_fdisset(void *fd, int pos);
+
+/* environment */
+void scheme_add_global(const char *name, Scheme_Object *val, Scheme_Env *env);
+void scheme_add_global_constant(const char *name, Scheme_Object *v, Scheme_Env *env);
+void scheme_add_global_keyword(const char *name, Scheme_Object *v, Scheme_Env *env);
+void scheme_remove_global(const char *name, Scheme_Env *env);
+void scheme_remove_global_constant(const char *name, Scheme_Env *env);
+
+void scheme_add_global_symbol(Scheme_Object *name, Scheme_Object *val, 
+			      Scheme_Env *env);
+void scheme_remove_global_symbol(Scheme_Object *name, Scheme_Env *env);
+void scheme_add_global_constant_symbol(Scheme_Object *name, Scheme_Object *v, Scheme_Env *env);
+
+void scheme_constant(Scheme_Object *sym, Scheme_Env *env);
+void scheme_set_keyword(Scheme_Object *name, Scheme_Env *env);
+
+Scheme_Object *scheme_make_envunbox(Scheme_Object *value);
+
+Scheme_Object *scheme_lookup_global(Scheme_Object *symbol, Scheme_Env *env);
+Scheme_Bucket *scheme_global_bucket(Scheme_Object *symbol, Scheme_Env *env);
+
+void scheme_set_global_bucket(char *proc, Scheme_Bucket *var, Scheme_Object *val,
+			      int set_undef);
+
+/* Symbols */
+Scheme_Object *scheme_intern_symbol(const char *name);
+Scheme_Object *scheme_intern_exact_symbol(const char *name, int len);
+Scheme_Object *scheme_make_symbol(const char *name); /* Make uninterned */
+Scheme_Object *scheme_make_exact_symbol(const char *name, int len); /* Exact case */
+const char *scheme_symbol_name(Scheme_Object *sym);
+const char *scheme_symbol_name_and_size(Scheme_Object *sym, int *l, int flags);
+
+/* Type Symbols */
+Scheme_Object *scheme_intern_type_symbol(Scheme_Object *sym);
+Scheme_Object *scheme_make_type_symbol(Scheme_Object *sym);/*Make uninterned */
+
+/* Structures */
+Scheme_Object **scheme_make_struct_values(Scheme_Object *struct_type,
+					  Scheme_Object **names,
+					  int count, int flags);
+Scheme_Object **scheme_make_struct_names(Scheme_Object *base, 
+					 Scheme_Object *field_names,
+					 int flags, int *count_out);
+Scheme_Object *scheme_make_struct_type(Scheme_Object *base, 
+				       Scheme_Object *parent, 
+				       int num_fields);
+Scheme_Object *scheme_make_struct_instance(Scheme_Object *stype,
+					   int argc,
+					   Scheme_Object **argv);
+int scheme_is_struct_instance(Scheme_Object *type, Scheme_Object *v);
+
+#ifndef NO_OBJECT_SYSTEM
+/* Objects */
+Scheme_Object *scheme_make_class(const char *name, Scheme_Object *sup, 
+				 Scheme_Method_Prim *init, int num_methods);
+void scheme_add_method(Scheme_Object *cl, const char *name, 
+		       Scheme_Method_Prim *f);
+void scheme_add_method_w_arity(Scheme_Object *cl, const char *name, 
+			       Scheme_Method_Prim *f, int mina, int maxa);
+void scheme_made_class(Scheme_Object *cl);
+
+Scheme_Object *scheme_make_object(Scheme_Object *sclass, 
+				  int argc, Scheme_Object **argv);
+Scheme_Object *scheme_make_uninited_object(Scheme_Object *sclass);
+
+Scheme_Object *scheme_find_ivar(Scheme_Object *obj, Scheme_Object *sym, int force);
+
+int scheme_is_subclass(Scheme_Object *sub, Scheme_Object *parent);
+int scheme_is_implementation(Scheme_Object *cl, Scheme_Object *in);
+int scheme_is_interface_extension(Scheme_Object *n1, Scheme_Object *n2);
+int scheme_is_a(Scheme_Object *obj, Scheme_Object *sclass);
+const char *scheme_get_class_name(Scheme_Object *cl, int *len);
+const char *scheme_get_interface_name(Scheme_Object *cl, int *len);
+
+struct Scheme_Class_Assembly *scheme_make_class_assembly(const char *name, int n_interfaces,
+							 int n_public, Scheme_Object **names,
+							 int n_inh, Scheme_Object **inheritd,
+							 int n_ren, Scheme_Object **renames,
+							 int mina, int maxa,
+							 Scheme_Instance_Init_Proc *initproc);
+Scheme_Object *scheme_create_class(struct Scheme_Class_Assembly *a, void *data,
+				   Scheme_Object *super, Scheme_Object **interfaces);
+
+struct Scheme_Interface_Assembly *scheme_make_interface_assembly(const char *name, int n_supers, 
+								 int n_names, 
+								 Scheme_Object **names);
+Scheme_Object *scheme_create_interface(struct Scheme_Interface_Assembly *a,
+				       Scheme_Object **supers);
+
+Scheme_Object *scheme_apply_generic_data(Scheme_Object *gdata, 
+					 Scheme_Object *sobj, int force);
+Scheme_Object *scheme_get_generic_data(Scheme_Object *cl, 
+				       Scheme_Object *name);
+#endif
+
+/* Units */
+Scheme_Object *scheme_invoke_unit(Scheme_Object *functor, int num_ins, 
+				  Scheme_Object **ins, Scheme_Object **anchors,
+				  int open, const char *name, int tail, int multi);
+
+Scheme_Object *scheme_assemble_compound_unit(Scheme_Object *imports,
+					     Scheme_Object *links,
+					     Scheme_Object *exports);
+Scheme_Object *scheme_make_compound_unit(Scheme_Object *data_in, 
+					 Scheme_Object **subs_in);
+
+const char *scheme_get_unit_name(Scheme_Object *cl, int *len);
+
+/* Misc */
+int scheme_eq(Scheme_Object *obj1, Scheme_Object *obj2);
+int scheme_eqv(Scheme_Object *obj1, Scheme_Object *obj2);
+int scheme_equal(Scheme_Object *obj1, Scheme_Object *obj2);
+
+Scheme_Object *scheme_build_list(int argc, Scheme_Object **argv);
+
+int scheme_list_length(Scheme_Object *list);
+int scheme_proper_list_length(Scheme_Object *list);
+
+Scheme_Object *scheme_alloc_list(int size);
+Scheme_Object *scheme_map_1(Scheme_Object *(*f)(Scheme_Object*),
+			    Scheme_Object *l);
+
+Scheme_Object *scheme_car(Scheme_Object *pair);
+Scheme_Object *scheme_cdr(Scheme_Object *pair);
+Scheme_Object *scheme_cadr(Scheme_Object *pair);
+Scheme_Object *scheme_caddr(Scheme_Object *pair);
+
+Scheme_Object *scheme_vector_to_list(Scheme_Object *vec);
+Scheme_Object *scheme_list_to_vector(Scheme_Object *list);
+
+Scheme_Object *scheme_append(Scheme_Object *lstx, Scheme_Object *lsty);
+
+Scheme_Object *scheme_box(Scheme_Object *v);
+Scheme_Object *scheme_unbox(Scheme_Object *obj);
+void scheme_set_box(Scheme_Object *b, Scheme_Object *v);
+
+Scheme_Object *scheme_make_weak_box(Scheme_Object *v);
+
+Scheme_Object *scheme_load(const char *file);
+Scheme_Object *scheme_load_extension(const char *filename, Scheme_Env *env);
+void scheme_register_extension_global(void *ptr, long size);
+
+long scheme_get_milliseconds(void);
+long scheme_get_process_milliseconds(void);
+
+void scheme_rep(void);
+char *scheme_banner(void);
+char *scheme_version(void);
+
+int scheme_check_proc_arity(const char *where, int a,
+			    int which, int argc, Scheme_Object **argv);
+
+void scheme_secure_exceptions(Scheme_Env *env);
+
+char *scheme_make_provided_string(Scheme_Object *o, int count, int *len);
+char *scheme_make_args_string(char *s, int which, int argc, Scheme_Object **argv);
+
+void scheme_no_dumps(char *why);
+
+const char *scheme_system_library_subpath();
diff --git a/src/mzscheme/src/schemex.h b/src/mzscheme/src/schemex.h
new file mode 100644
index 0000000..2ac1158
--- /dev/null
+++ b/src/mzscheme/src/schemex.h
@@ -0,0 +1,468 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* MzScheme function prototypes */
+/* No macros should go in this file; it is used both to
+   prototype functions, and as a parsing source for
+   declaring scheme_extension_table */
+
+/* The scheme_extension_table parser is touchy: don't leave a space
+   between a function name and it's opening parameter parenthesis. */
+
+/* After this START tag, all comments should start & end on same line */
+
+typedef struct {
+/* Call/cc utilities */
+void (*scheme_init_jmpup_buf)(Scheme_Jumpup_Buf *b);
+int (*scheme_setjmpup_relative)(Scheme_Jumpup_Buf *b, void *start, 
+			     Scheme_Jumpup_Buf *cont);
+void (*scheme_longjmpup)(Scheme_Jumpup_Buf *b);
+#ifdef USE_MZ_SETJMP
+int (*scheme_setjmp)(jmp_buf b);
+void (*scheme_longjmp)(jmp_buf b, int v);
+#endif
+/* Parameters */
+Scheme_Object *(*scheme_make_config)(Scheme_Config *base);
+Scheme_Object *(*scheme_branch_config)(void);
+int (*scheme_new_param)(void);
+Scheme_Object *(*scheme_param_config)(char *name, long pos,
+				   int argc, Scheme_Object **argv,
+				   int arity, 
+				   Scheme_Prim *check, char *expected,
+				   int isbool);
+Scheme_Object *(*scheme_register_parameter)(Scheme_Prim *function, char *name, int which);
+Scheme_Env *(*scheme_get_env)(Scheme_Config *config);
+/* Processes */
+#ifdef MZ_REAL_THREADS
+Scheme_Process *(*scheme_get_current_process)();
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+Scheme_Process *scheme_current_process;
+int scheme_fuel_counter;
+#else
+Scheme_Process **scheme_current_process_ptr;
+int *scheme_fuel_counter_ptr;
+#endif
+#endif
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *(*scheme_make_namespace)(int argc, Scheme_Object *argv[]);
+Scheme_Object *(*scheme_thread)(Scheme_Object *thunk, Scheme_Config *config);
+void (*scheme_break_thread)(Scheme_Process *p);
+void (*scheme_kill_thread)(Scheme_Process *p);
+#endif
+#ifndef MZ_REAL_THREADS
+void (*scheme_process_block)(float sleep_time);
+void (*scheme_swap_process)(Scheme_Process *process);
+#else
+void (*scheme_process_block_w_process)(float sleep_time, Scheme_Process *p);
+#endif
+int (*scheme_block_until)(int (*f)(Scheme_Object *), void (*fdfd)(Scheme_Object *, void *), void *, float);
+int (*scheme_in_main_thread)(void);
+int (*scheme_tls_allocate)();
+void (*scheme_tls_set)(int pos, void *v);
+void *(*scheme_tls_get)(int pos);
+void (*scheme_add_namespace_option)(Scheme_Object *key, void (*f)(Scheme_Env *));
+Scheme_Manager *(*scheme_make_manager)(Scheme_Manager *);
+Scheme_Manager_Reference *(*scheme_add_managed)(Scheme_Manager *m, Scheme_Object *o, 
+					     Scheme_Close_Manager_Client *f, void *data, 
+					     int strong);
+void (*scheme_remove_managed)(Scheme_Manager_Reference *m, Scheme_Object *o);
+void (*scheme_close_managed)(Scheme_Manager *m);
+/* error handling */
+void (*scheme_signal_error)(char *msg, ...);
+void (*scheme_raise_exn)(int exnid, ...);
+void (*scheme_warning)(char *msg, ...);
+void (*scheme_wrong_count)(const char *name, int minc, int maxc, int argc,
+			Scheme_Object **argv);
+void (*scheme_case_lambda_wrong_count)(const char *name, int argc, 
+				    Scheme_Object **argv, int count, ...);
+void (*scheme_wrong_type)(const char *name, const char *expected, 
+		       int which, int argc,
+		       Scheme_Object **argv);
+void (*scheme_wrong_return_arity)(const char *where, 
+			       int expected, int got,
+			       Scheme_Object **argv,
+			       const char *context_detail, ...);
+void (*scheme_unbound_global)(Scheme_Object *name);
+Scheme_Object *(*scheme_dynamic_wind)(void (*pre)(void *),
+				   Scheme_Object *(*act)(void *),
+				   void (*post)(void *), 
+				   Scheme_Object *(*jmp_handler)(void *),
+				   void *data);
+/* Types */
+Scheme_Type (*scheme_make_type)(const char *name);
+/* Type readers & writers for compiled code data */
+void (*scheme_install_type_reader)(Scheme_Type type, Scheme_Type_Reader f);
+void (*scheme_install_type_writer)(Scheme_Type type, Scheme_Type_Writer f);
+/* Constants */
+Scheme_Object *scheme_eof;
+Scheme_Object *scheme_null;
+Scheme_Object *scheme_true;
+Scheme_Object *scheme_false;
+Scheme_Object *scheme_void;
+Scheme_Object *scheme_undefined;
+Scheme_Object *scheme_tail_call_waiting;
+Scheme_Object *scheme_multiple_values;
+/* Basics */
+Scheme_Object *(*scheme_eval)(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_multi)(Scheme_Object *obj, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_compiled)(Scheme_Object *obj);
+Scheme_Object *(*scheme_eval_compiled_multi)(Scheme_Object *obj);
+Scheme_Object *(*_scheme_eval_compiled)(Scheme_Object *obj);
+Scheme_Object *(*_scheme_eval_compiled_multi)(Scheme_Object *obj);
+#ifndef MZ_REAL_THREADS
+Scheme_Object *(*scheme_apply)(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+Scheme_Object *(*scheme_apply_multi)(Scheme_Object *rator, int num_rands, Scheme_Object **rands);
+#else
+Scheme_Object *(*scheme_apply_wp)(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+			       Scheme_Process *p);
+Scheme_Object *(*scheme_apply_multi_wp)(Scheme_Object *rator, int num_rands, Scheme_Object **rands,
+				     Scheme_Process *p);
+#endif
+Scheme_Object *(*scheme_apply_to_list)(Scheme_Object *rator, Scheme_Object *argss);
+Scheme_Object *(*scheme_eval_string)(const char *str, Scheme_Env *env);
+Scheme_Object *(*scheme_eval_string_all)(const char *str, Scheme_Env *env, int all);
+Scheme_Object *(*_scheme_apply_known_closed_prim)(Scheme_Object *rator, int argc,
+					       Scheme_Object **argv);
+Scheme_Object *(*_scheme_apply_known_closed_prim_multi)(Scheme_Object *rator, int argc,
+						     Scheme_Object **argv);
+Scheme_Object *(*scheme_values)(int c, Scheme_Object **v);
+Scheme_Object *(*scheme_check_one_value)(Scheme_Object *v);
+/* Tail calls - only use these when you're writing new functions/syntax */
+Scheme_Object *(*scheme_tail_apply)(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *(*scheme_tail_apply_no_copy)(Scheme_Object *f, int n, Scheme_Object **arg);
+Scheme_Object *(*scheme_tail_apply_to_list)(Scheme_Object *f, Scheme_Object *l);
+Scheme_Object *(*scheme_tail_eval_expr)(Scheme_Object *obj);
+void (*scheme_set_tail_buffer_size)(int s);
+Scheme_Object *(*scheme_force_value)(Scheme_Object *);
+/* Internal */
+#ifndef MZ_REAL_THREADS
+Scheme_Object *(*scheme_do_eval)(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val);
+#else
+Scheme_Object *(*scheme_do_eval_w_process)(Scheme_Object *obj, int _num_rands, Scheme_Object **rands, int val, Scheme_Process *p);
+#endif
+/* Allocation */
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+void *(*GC_malloc)(size_t size_in_bytes);
+void *(*GC_malloc_atomic)(size_t size_in_bytes);
+void *(*GC_malloc_stubborn)(size_t size_in_bytes);
+void *(*GC_malloc_uncollectable)(size_t size_in_bytes);
+#endif
+#endif
+void *(*scheme_malloc_eternal)(size_t n);
+void (*scheme_end_stubborn_change)(void *p);
+void *(*scheme_calloc)(size_t num, size_t size);
+char *(*scheme_strdup)(const char *str);
+char *(*scheme_strdup_eternal)(const char *str);
+void *(*scheme_malloc_fail_ok)(void *(*f)(size_t), size_t);
+void (*scheme_weak_reference)(void **p);
+void (*scheme_weak_reference_indirect)(void **p, void *v);
+void (*scheme_add_finalizer)(void *p, void (*f)(void *p, void *data), void *data);
+void (*scheme_add_scheme_finalizer)(void *p, void (*f)(void *p, void *data), void *data);
+void (*scheme_register_finalizer)(void *p, 
+			       void (*f)(void *p, void *data), void *data,
+			       void (**oldf)(void *p, void *data), 
+			       void **olddata);
+void (*scheme_dont_gc_ptr)(void *p);
+void (*scheme_gc_ptr_ok)(void *p);
+void (*scheme_collect_garbage)(void);
+/* Hash table */
+Scheme_Hash_Table *(*scheme_hash_table)(int size, int type, 
+				      int w_const, int forever);
+void (*scheme_add_to_table)(Scheme_Hash_Table *table, const char *key, void *val, int);
+void (*scheme_change_in_table)(Scheme_Hash_Table *table, const char *key, void *new_val);
+void *(*scheme_lookup_in_table)(Scheme_Hash_Table *table, const char *key);
+Scheme_Bucket *(*scheme_bucket_from_table)(Scheme_Hash_Table *table, const char *key);
+/* Constructors */
+Scheme_Object *(*scheme_make_prim)(Scheme_Prim *prim);
+Scheme_Object *(*scheme_make_noneternal_prim)(Scheme_Prim *prim);
+Scheme_Object *(*scheme_make_closed_prim)(Scheme_Closed_Prim *prim, void *data);
+Scheme_Object *(*scheme_make_prim_w_arity)(Scheme_Prim *prim, const char *name,
+					short mina, short maxa);
+Scheme_Object *(*scheme_make_folding_prim)(Scheme_Prim *prim, 
+					const char *name,
+					short mina, short maxa,
+					short functional);
+Scheme_Object *(*scheme_make_noneternal_prim_w_arity)(Scheme_Prim *prim, 
+						   const char *name, 
+						   short mina, short maxa);
+Scheme_Object *(*scheme_make_closed_prim_w_arity)(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa);
+Scheme_Object *(*scheme_make_folding_closed_prim)(Scheme_Closed_Prim *prim, 
+					       void *data, const char *name,
+					       short mina, short maxa,
+					       short functional);
+Scheme_Object *(*scheme_make_closure)(Scheme_Env *env, Scheme_Object *code);
+Scheme_Object *(*scheme_make_pair)(Scheme_Object *car, Scheme_Object *cdr);
+Scheme_Object *(*scheme_make_string)(const char *chars);
+Scheme_Object *(*scheme_make_sized_string)(char *chars, long len, int copy);
+Scheme_Object *(*scheme_make_string_without_copying)(char *chars);
+Scheme_Object *(*scheme_alloc_string)(int size, char fill);
+Scheme_Object *(*scheme_append_string)(Scheme_Object *, Scheme_Object *);
+Scheme_Object *(*scheme_make_vector)(int size, Scheme_Object *fill);
+Scheme_Object *(*scheme_make_integer_value)(long i);
+Scheme_Object *(*scheme_make_integer_value_from_unsigned)(unsigned long i);
+Scheme_Object *(*scheme_make_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+Scheme_Object *(*scheme_make_float)(float f);
+#endif
+Scheme_Object *(*scheme_make_char)(char ch);
+Scheme_Object *(*scheme_make_promise)(Scheme_Object *expr, Scheme_Env *env);
+Scheme_Object *(*scheme_make_promise_from_thunk)(Scheme_Object *expr);
+#ifndef NO_SCHEME_THREADS
+Scheme_Object *(*scheme_make_sema)(long v);
+#endif
+void (*scheme_post_sema)(Scheme_Object *o);
+int (*scheme_wait_sema)(Scheme_Object *o, int just_try);
+Scheme_Object **scheme_char_constants;
+int (*scheme_get_int_val)(Scheme_Object *o, long *v);
+int (*scheme_get_unsigned_int_val)(Scheme_Object *o, unsigned long *v);
+const char *(*scheme_get_proc_name)(Scheme_Object *p, int *len, int for_error);
+/* Bignums */
+Scheme_Object *(*scheme_make_bignum)(long v);
+Scheme_Object *(*scheme_make_bignum_from_unsigned)(unsigned long v);
+double (*scheme_bignum_to_double)(const Scheme_Object *n);
+Scheme_Object *(*scheme_bignum_from_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float (*scheme_bignum_to_float)(const Scheme_Object *n);
+Scheme_Object *(*scheme_bignum_from_float)(float d);
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+char *(*scheme_bignum_to_string)(const Scheme_Object *n, int radix);
+Scheme_Object *(*scheme_read_bignum)(const char *str, int radix);
+Scheme_Object *(*scheme_bignum_normalize)(const Scheme_Object *n);
+long (*scheme_double_to_int)(const char *where, double d);
+/* Rationals */
+Scheme_Object *(*scheme_make_rational)(const Scheme_Object *r, const Scheme_Object *d);
+double (*scheme_rational_to_double)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_from_double)(double d);
+#ifdef MZ_USE_SINGLE_FLOATS
+float (*scheme_rational_to_float)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_from_float)(float d);
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+Scheme_Object *(*scheme_rational_normalize)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_numerator)(const Scheme_Object *n);
+Scheme_Object *(*scheme_rational_denominator)(const Scheme_Object *n);
+/* Complex */
+Scheme_Object *(*scheme_make_complex)(const Scheme_Object *r, const Scheme_Object *i);
+Scheme_Object *(*scheme_complex_normalize)(const Scheme_Object *n);
+Scheme_Object *(*scheme_complex_real_part)(const Scheme_Object *n);
+Scheme_Object *(*scheme_complex_imaginary_part)(const Scheme_Object *n);
+/* Exact/inexact: */
+int (*scheme_is_exact)(Scheme_Object *n);
+int (*scheme_is_inexact)(Scheme_Object *n);
+/* Macro and syntax expansion */
+Scheme_Object *(*scheme_expand)(Scheme_Object *form, Scheme_Env *env);
+/* Compilation */
+Scheme_Object *(*scheme_compile)(Scheme_Object *form, Scheme_Env *env, int writeable);
+Scheme_Object *(*scheme_make_promise_value)(Scheme_Object *compiled_expr);
+/* Ports */
+Scheme_Object *(*scheme_read)(Scheme_Object *port);
+void (*scheme_write)(Scheme_Object *obj, Scheme_Object *port);
+void (*scheme_display)(Scheme_Object *obj, Scheme_Object *port);
+void (*scheme_write_w_max)(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void (*scheme_display_w_max)(Scheme_Object *obj, Scheme_Object *port, long maxl);
+void (*scheme_write_string)(const char *str, long len, Scheme_Object *port);
+char *(*scheme_write_to_string)(Scheme_Object *obj, long *len);
+char *(*scheme_display_to_string)(Scheme_Object *obj, long *len);
+char *(*scheme_write_to_string_w_max)(Scheme_Object *obj, long *len, long maxl);
+char *(*scheme_display_to_string_w_max)(Scheme_Object *obj, long *len, long maxl);
+void (*scheme_debug_print)(Scheme_Object *obj);
+void (*scheme_flush_output)(Scheme_Object *port);
+char *(*scheme_format)(char *format, int flen, int argc, Scheme_Object **argv, int *rlen);
+void (*scheme_printf)(char *format, int flen, int argc, Scheme_Object **argv);
+int (*scheme_getc)(Scheme_Object *port);
+void (*scheme_ungetc)(int ch, Scheme_Object *port);
+int (*scheme_char_ready)(Scheme_Object *port);
+void (*scheme_need_wakeup)(Scheme_Object *port, void *fds);
+long (*scheme_get_chars)(Scheme_Object *port, long size, char *buffer);
+long (*scheme_tell)(Scheme_Object *port);
+long (*scheme_output_tell)(Scheme_Object *port);
+long (*scheme_tell_line)(Scheme_Object *port);
+void (*scheme_close_input_port)(Scheme_Object *port);
+void (*scheme_close_output_port)(Scheme_Object *port);
+int (*scheme_are_all_chars_ready)(Scheme_Object *port);
+Scheme_Object *(*scheme_make_port_type)(const char *name);
+Scheme_Input_Port *(*scheme_make_input_port)(Scheme_Object *subtype, void *data,
+					  int (*getc_fun)(Scheme_Input_Port*),
+					  int (*char_ready_fun)
+					  (Scheme_Input_Port*),
+					  void (*close_fun)
+					  (Scheme_Input_Port*),
+					  void (*need_wakeup_fun)
+					  (Scheme_Input_Port*, void *),
+					  int must_close);
+Scheme_Output_Port *(*scheme_make_output_port)(Scheme_Object *subtype,
+					    void *data,
+					    void (*write_string_fun)
+					    (char*,long, Scheme_Output_Port*),
+					    void (*close_fun)
+					    (Scheme_Output_Port*),
+					    int must_close);
+Scheme_Object *(*scheme_make_file_input_port)(FILE *fp);
+Scheme_Object *(*scheme_make_named_file_input_port)(FILE *fp, const char *filename);
+Scheme_Object *(*scheme_make_file_output_port)(FILE *fp);
+Scheme_Object *(*scheme_make_string_input_port)(const char *str);
+Scheme_Object *(*scheme_make_sized_string_input_port)(const char *str, long len);
+Scheme_Object *(*scheme_make_string_output_port)();
+char *(*scheme_get_string_output)(Scheme_Object *);
+char *(*scheme_get_sized_string_output)(Scheme_Object *, int *len);
+void (*scheme_pipe)(Scheme_Object **write, Scheme_Object **read);
+int (*scheme_file_exists)(char *filename);
+int (*scheme_directory_exists)(char *dirname);
+char *(*scheme_expand_filename)(char* filename, int ilen, char *errorin, int *ex);
+char *(*scheme_getcwd)(char *buf, int buflen, int *actlen, int noexn);
+int (*scheme_setcwd)(char *buf, int noexn);
+char *(*scheme_getdrive)(void);
+Scheme_Object *(*scheme_split_pathname)(int argc, Scheme_Object **argv);
+Scheme_Object *(*scheme_build_pathname)(int argc, Scheme_Object **argv);
+void *(*scheme_alloc_fdset_array)(int count, int permanent);
+void *(*scheme_init_fdset_array)(void *fdarray, int count);
+void *(*scheme_get_fdset)(void *fdarray, int pos);
+void (*scheme_fdzero)(void *fd);
+void (*scheme_fdset)(void *fd, int pos);
+void (*scheme_fdclr)(void *fd, int pos);
+int (*scheme_fdisset)(void *fd, int pos);
+/* environment */
+void (*scheme_add_global)(const char *name, Scheme_Object *val, Scheme_Env *env);
+void (*scheme_add_global_constant)(const char *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_add_global_keyword)(const char *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_remove_global)(const char *name, Scheme_Env *env);
+void (*scheme_remove_global_constant)(const char *name, Scheme_Env *env);
+void (*scheme_add_global_symbol)(Scheme_Object *name, Scheme_Object *val, 
+			      Scheme_Env *env);
+void (*scheme_remove_global_symbol)(Scheme_Object *name, Scheme_Env *env);
+void (*scheme_add_global_constant_symbol)(Scheme_Object *name, Scheme_Object *v, Scheme_Env *env);
+void (*scheme_constant)(Scheme_Object *sym, Scheme_Env *env);
+void (*scheme_set_keyword)(Scheme_Object *name, Scheme_Env *env);
+Scheme_Object *(*scheme_make_envunbox)(Scheme_Object *value);
+Scheme_Object *(*scheme_lookup_global)(Scheme_Object *symbol, Scheme_Env *env);
+Scheme_Bucket *(*scheme_global_bucket)(Scheme_Object *symbol, Scheme_Env *env);
+void (*scheme_set_global_bucket)(char *proc, Scheme_Bucket *var, Scheme_Object *val,
+			      int set_undef);
+/* Symbols */
+Scheme_Object *(*scheme_intern_symbol)(const char *name);
+Scheme_Object *(*scheme_intern_exact_symbol)(const char *name, int len);
+Scheme_Object *(*scheme_make_symbol)(const char *name); /* Make uninterned */
+Scheme_Object *(*scheme_make_exact_symbol)(const char *name, int len); /* Exact case */
+const char *(*scheme_symbol_name)(Scheme_Object *sym);
+const char *(*scheme_symbol_name_and_size)(Scheme_Object *sym, int *l, int flags);
+/* Type Symbols */
+Scheme_Object *(*scheme_intern_type_symbol)(Scheme_Object *sym);
+Scheme_Object *(*scheme_make_type_symbol)(Scheme_Object *sym);/*Make uninterned */
+/* Structures */
+Scheme_Object **(*scheme_make_struct_values)(Scheme_Object *struct_type,
+					  Scheme_Object **names,
+					  int count, int flags);
+Scheme_Object **(*scheme_make_struct_names)(Scheme_Object *base, 
+					 Scheme_Object *field_names,
+					 int flags, int *count_out);
+Scheme_Object *(*scheme_make_struct_type)(Scheme_Object *base, 
+				       Scheme_Object *parent, 
+				       int num_fields);
+Scheme_Object *(*scheme_make_struct_instance)(Scheme_Object *stype,
+					   int argc,
+					   Scheme_Object **argv);
+int (*scheme_is_struct_instance)(Scheme_Object *type, Scheme_Object *v);
+#ifndef NO_OBJECT_SYSTEM
+/* Objects */
+Scheme_Object *(*scheme_make_class)(const char *name, Scheme_Object *sup, 
+				 Scheme_Method_Prim *init, int num_methods);
+void (*scheme_add_method)(Scheme_Object *cl, const char *name, 
+		       Scheme_Method_Prim *f);
+void (*scheme_add_method_w_arity)(Scheme_Object *cl, const char *name, 
+			       Scheme_Method_Prim *f, int mina, int maxa);
+void (*scheme_made_class)(Scheme_Object *cl);
+Scheme_Object *(*scheme_make_object)(Scheme_Object *sclass, 
+				  int argc, Scheme_Object **argv);
+Scheme_Object *(*scheme_make_uninited_object)(Scheme_Object *sclass);
+Scheme_Object *(*scheme_find_ivar)(Scheme_Object *obj, Scheme_Object *sym, int force);
+int (*scheme_is_subclass)(Scheme_Object *sub, Scheme_Object *parent);
+int (*scheme_is_implementation)(Scheme_Object *cl, Scheme_Object *in);
+int (*scheme_is_interface_extension)(Scheme_Object *n1, Scheme_Object *n2);
+int (*scheme_is_a)(Scheme_Object *obj, Scheme_Object *sclass);
+const char *(*scheme_get_class_name)(Scheme_Object *cl, int *len);
+const char *(*scheme_get_interface_name)(Scheme_Object *cl, int *len);
+struct Scheme_Class_Assembly *(*scheme_make_class_assembly)(const char *name, int n_interfaces,
+							 int n_public, Scheme_Object **names,
+							 int n_inh, Scheme_Object **inheritd,
+							 int n_ren, Scheme_Object **renames,
+							 int mina, int maxa,
+							 Scheme_Instance_Init_Proc *initproc);
+Scheme_Object *(*scheme_create_class)(struct Scheme_Class_Assembly *a, void *data,
+				   Scheme_Object *super, Scheme_Object **interfaces);
+struct Scheme_Interface_Assembly *(*scheme_make_interface_assembly)(const char *name, int n_supers, 
+								 int n_names, 
+								 Scheme_Object **names);
+Scheme_Object *(*scheme_create_interface)(struct Scheme_Interface_Assembly *a,
+				       Scheme_Object **supers);
+Scheme_Object *(*scheme_apply_generic_data)(Scheme_Object *gdata, 
+					 Scheme_Object *sobj, int force);
+Scheme_Object *(*scheme_get_generic_data)(Scheme_Object *cl, 
+				       Scheme_Object *name);
+#endif
+/* Units */
+Scheme_Object *(*scheme_invoke_unit)(Scheme_Object *functor, int num_ins, 
+				  Scheme_Object **ins, Scheme_Object **anchors,
+				  int open, const char *name, int tail, int multi);
+Scheme_Object *(*scheme_assemble_compound_unit)(Scheme_Object *imports,
+					     Scheme_Object *links,
+					     Scheme_Object *exports);
+Scheme_Object *(*scheme_make_compound_unit)(Scheme_Object *data_in, 
+					 Scheme_Object **subs_in);
+const char *(*scheme_get_unit_name)(Scheme_Object *cl, int *len);
+/* Misc */
+int (*scheme_eq)(Scheme_Object *obj1, Scheme_Object *obj2);
+int (*scheme_eqv)(Scheme_Object *obj1, Scheme_Object *obj2);
+int (*scheme_equal)(Scheme_Object *obj1, Scheme_Object *obj2);
+Scheme_Object *(*scheme_build_list)(int argc, Scheme_Object **argv);
+int (*scheme_list_length)(Scheme_Object *list);
+int (*scheme_proper_list_length)(Scheme_Object *list);
+Scheme_Object *(*scheme_alloc_list)(int size);
+Scheme_Object *(*scheme_map_1)(Scheme_Object *(*f)(Scheme_Object*),
+			    Scheme_Object *l);
+Scheme_Object *(*scheme_car)(Scheme_Object *pair);
+Scheme_Object *(*scheme_cdr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_cadr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_caddr)(Scheme_Object *pair);
+Scheme_Object *(*scheme_vector_to_list)(Scheme_Object *vec);
+Scheme_Object *(*scheme_list_to_vector)(Scheme_Object *list);
+Scheme_Object *(*scheme_append)(Scheme_Object *lstx, Scheme_Object *lsty);
+Scheme_Object *(*scheme_box)(Scheme_Object *v);
+Scheme_Object *(*scheme_unbox)(Scheme_Object *obj);
+void (*scheme_set_box)(Scheme_Object *b, Scheme_Object *v);
+Scheme_Object *(*scheme_make_weak_box)(Scheme_Object *v);
+Scheme_Object *(*scheme_load)(const char *file);
+Scheme_Object *(*scheme_load_extension)(const char *filename, Scheme_Env *env);
+void (*scheme_register_extension_global)(void *ptr, long size);
+long (*scheme_get_milliseconds)(void);
+long (*scheme_get_process_milliseconds)(void);
+void (*scheme_rep)(void);
+char *(*scheme_banner)(void);
+char *(*scheme_version)(void);
+int (*scheme_check_proc_arity)(const char *where, int a,
+			    int which, int argc, Scheme_Object **argv);
+void (*scheme_secure_exceptions)(Scheme_Env *env);
+char *(*scheme_make_provided_string)(Scheme_Object *o, int count, int *len);
+char *(*scheme_make_args_string)(char *s, int which, int argc, Scheme_Object **argv);
+void (*scheme_no_dumps)(char *why);
+const char *(*scheme_system_library_subpath)();
+#ifndef SCHEME_EX_INLINE
+} Scheme_Extension_Table;
+#endif
diff --git a/src/mzscheme/src/schemex.inc b/src/mzscheme/src/schemex.inc
new file mode 100644
index 0000000..bf2eb6c
--- /dev/null
+++ b/src/mzscheme/src/schemex.inc
@@ -0,0 +1,332 @@
+  scheme_extension_table->scheme_init_jmpup_buf = scheme_init_jmpup_buf;
+  scheme_extension_table->scheme_setjmpup_relative = scheme_setjmpup_relative;
+  scheme_extension_table->scheme_longjmpup = scheme_longjmpup;
+#ifdef USE_MZ_SETJMP
+  scheme_extension_table->scheme_setjmp = scheme_setjmp;
+  scheme_extension_table->scheme_longjmp = scheme_longjmp;
+#endif
+  scheme_extension_table->scheme_make_config = scheme_make_config;
+  scheme_extension_table->scheme_branch_config = scheme_branch_config;
+  scheme_extension_table->scheme_new_param = scheme_new_param;
+  scheme_extension_table->scheme_param_config = scheme_param_config;
+  scheme_extension_table->scheme_register_parameter = scheme_register_parameter;
+  scheme_extension_table->scheme_get_env = scheme_get_env;
+#ifdef MZ_REAL_THREADS
+  scheme_extension_table->scheme_get_current_process = scheme_get_current_process;
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+  scheme_extension_table->scheme_current_process = scheme_current_process;
+  scheme_extension_table->scheme_fuel_counter = scheme_fuel_counter;
+#else
+  scheme_extension_table->scheme_current_process_ptr = scheme_current_process_ptr;
+  scheme_extension_table->scheme_fuel_counter_ptr = scheme_fuel_counter_ptr;
+#endif
+#endif
+#ifndef NO_SCHEME_THREADS
+  scheme_extension_table->scheme_make_namespace = scheme_make_namespace;
+  scheme_extension_table->scheme_thread = scheme_thread;
+  scheme_extension_table->scheme_break_thread = scheme_break_thread;
+  scheme_extension_table->scheme_kill_thread = scheme_kill_thread;
+#endif
+#ifndef MZ_REAL_THREADS
+  scheme_extension_table->scheme_process_block = scheme_process_block;
+  scheme_extension_table->scheme_swap_process = scheme_swap_process;
+#else
+  scheme_extension_table->scheme_process_block_w_process = scheme_process_block_w_process;
+#endif
+  scheme_extension_table->scheme_block_until = scheme_block_until;
+  scheme_extension_table->scheme_in_main_thread = scheme_in_main_thread;
+  scheme_extension_table->scheme_tls_allocate = scheme_tls_allocate;
+  scheme_extension_table->scheme_tls_set = scheme_tls_set;
+  scheme_extension_table->scheme_tls_get = scheme_tls_get;
+  scheme_extension_table->scheme_add_namespace_option = scheme_add_namespace_option;
+  scheme_extension_table->scheme_make_manager = scheme_make_manager;
+  scheme_extension_table->scheme_add_managed = scheme_add_managed;
+  scheme_extension_table->scheme_remove_managed = scheme_remove_managed;
+  scheme_extension_table->scheme_close_managed = scheme_close_managed;
+  scheme_extension_table->scheme_signal_error = scheme_signal_error;
+  scheme_extension_table->scheme_raise_exn = scheme_raise_exn;
+  scheme_extension_table->scheme_warning = scheme_warning;
+  scheme_extension_table->scheme_wrong_count = scheme_wrong_count;
+  scheme_extension_table->scheme_case_lambda_wrong_count = scheme_case_lambda_wrong_count;
+  scheme_extension_table->scheme_wrong_type = scheme_wrong_type;
+  scheme_extension_table->scheme_wrong_return_arity = scheme_wrong_return_arity;
+  scheme_extension_table->scheme_unbound_global = scheme_unbound_global;
+  scheme_extension_table->scheme_dynamic_wind = scheme_dynamic_wind;
+  scheme_extension_table->scheme_make_type = scheme_make_type;
+  scheme_extension_table->scheme_install_type_reader = scheme_install_type_reader;
+  scheme_extension_table->scheme_install_type_writer = scheme_install_type_writer;
+  scheme_extension_table->scheme_eof = scheme_eof;
+  scheme_extension_table->scheme_null = scheme_null;
+  scheme_extension_table->scheme_true = scheme_true;
+  scheme_extension_table->scheme_false = scheme_false;
+  scheme_extension_table->scheme_void = scheme_void;
+  scheme_extension_table->scheme_undefined = scheme_undefined;
+  scheme_extension_table->scheme_tail_call_waiting = scheme_tail_call_waiting;
+  scheme_extension_table->scheme_multiple_values = scheme_multiple_values;
+  scheme_extension_table->scheme_eval = scheme_eval;
+  scheme_extension_table->scheme_eval_multi = scheme_eval_multi;
+  scheme_extension_table->scheme_eval_compiled = scheme_eval_compiled;
+  scheme_extension_table->scheme_eval_compiled_multi = scheme_eval_compiled_multi;
+  scheme_extension_table->_scheme_eval_compiled = _scheme_eval_compiled;
+  scheme_extension_table->_scheme_eval_compiled_multi = _scheme_eval_compiled_multi;
+#ifndef MZ_REAL_THREADS
+  scheme_extension_table->scheme_apply = scheme_apply;
+  scheme_extension_table->scheme_apply_multi = scheme_apply_multi;
+#else
+  scheme_extension_table->scheme_apply_wp = scheme_apply_wp;
+  scheme_extension_table->scheme_apply_multi_wp = scheme_apply_multi_wp;
+#endif
+  scheme_extension_table->scheme_apply_to_list = scheme_apply_to_list;
+  scheme_extension_table->scheme_eval_string = scheme_eval_string;
+  scheme_extension_table->scheme_eval_string_all = scheme_eval_string_all;
+  scheme_extension_table->_scheme_apply_known_closed_prim = _scheme_apply_known_closed_prim;
+  scheme_extension_table->_scheme_apply_known_closed_prim_multi = _scheme_apply_known_closed_prim_multi;
+  scheme_extension_table->scheme_values = scheme_values;
+  scheme_extension_table->scheme_check_one_value = scheme_check_one_value;
+  scheme_extension_table->scheme_tail_apply = scheme_tail_apply;
+  scheme_extension_table->scheme_tail_apply_no_copy = scheme_tail_apply_no_copy;
+  scheme_extension_table->scheme_tail_apply_to_list = scheme_tail_apply_to_list;
+  scheme_extension_table->scheme_tail_eval_expr = scheme_tail_eval_expr;
+  scheme_extension_table->scheme_set_tail_buffer_size = scheme_set_tail_buffer_size;
+  scheme_extension_table->scheme_force_value = scheme_force_value;
+#ifndef MZ_REAL_THREADS
+  scheme_extension_table->scheme_do_eval = scheme_do_eval;
+#else
+  scheme_extension_table->scheme_do_eval_w_process = scheme_do_eval_w_process;
+#endif
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+  scheme_extension_table->GC_malloc = GC_malloc;
+  scheme_extension_table->GC_malloc_atomic = GC_malloc_atomic;
+  scheme_extension_table->GC_malloc_stubborn = GC_malloc_stubborn;
+  scheme_extension_table->GC_malloc_uncollectable = GC_malloc_uncollectable;
+#endif
+#endif
+  scheme_extension_table->scheme_malloc_eternal = scheme_malloc_eternal;
+  scheme_extension_table->scheme_end_stubborn_change = scheme_end_stubborn_change;
+  scheme_extension_table->scheme_calloc = scheme_calloc;
+  scheme_extension_table->scheme_strdup = scheme_strdup;
+  scheme_extension_table->scheme_strdup_eternal = scheme_strdup_eternal;
+  scheme_extension_table->scheme_malloc_fail_ok = scheme_malloc_fail_ok;
+  scheme_extension_table->scheme_weak_reference = scheme_weak_reference;
+  scheme_extension_table->scheme_weak_reference_indirect = scheme_weak_reference_indirect;
+  scheme_extension_table->scheme_add_finalizer = scheme_add_finalizer;
+  scheme_extension_table->scheme_add_scheme_finalizer = scheme_add_scheme_finalizer;
+  scheme_extension_table->scheme_register_finalizer = scheme_register_finalizer;
+  scheme_extension_table->scheme_dont_gc_ptr = scheme_dont_gc_ptr;
+  scheme_extension_table->scheme_gc_ptr_ok = scheme_gc_ptr_ok;
+  scheme_extension_table->scheme_collect_garbage = scheme_collect_garbage;
+  scheme_extension_table->scheme_hash_table = scheme_hash_table;
+  scheme_extension_table->scheme_add_to_table = scheme_add_to_table;
+  scheme_extension_table->scheme_change_in_table = scheme_change_in_table;
+  scheme_extension_table->scheme_lookup_in_table = scheme_lookup_in_table;
+  scheme_extension_table->scheme_bucket_from_table = scheme_bucket_from_table;
+  scheme_extension_table->scheme_make_prim = scheme_make_prim;
+  scheme_extension_table->scheme_make_noneternal_prim = scheme_make_noneternal_prim;
+  scheme_extension_table->scheme_make_closed_prim = scheme_make_closed_prim;
+  scheme_extension_table->scheme_make_prim_w_arity = scheme_make_prim_w_arity;
+  scheme_extension_table->scheme_make_folding_prim = scheme_make_folding_prim;
+  scheme_extension_table->scheme_make_noneternal_prim_w_arity = scheme_make_noneternal_prim_w_arity;
+  scheme_extension_table->scheme_make_closed_prim_w_arity = scheme_make_closed_prim_w_arity;
+  scheme_extension_table->scheme_make_folding_closed_prim = scheme_make_folding_closed_prim;
+  scheme_extension_table->scheme_make_closure = scheme_make_closure;
+  scheme_extension_table->scheme_make_pair = scheme_make_pair;
+  scheme_extension_table->scheme_make_string = scheme_make_string;
+  scheme_extension_table->scheme_make_sized_string = scheme_make_sized_string;
+  scheme_extension_table->scheme_make_string_without_copying = scheme_make_string_without_copying;
+  scheme_extension_table->scheme_alloc_string = scheme_alloc_string;
+  scheme_extension_table->scheme_append_string = scheme_append_string;
+  scheme_extension_table->scheme_make_vector = scheme_make_vector;
+  scheme_extension_table->scheme_make_integer_value = scheme_make_integer_value;
+  scheme_extension_table->scheme_make_integer_value_from_unsigned = scheme_make_integer_value_from_unsigned;
+  scheme_extension_table->scheme_make_double = scheme_make_double;
+#ifdef MZ_USE_SINGLE_FLOATS
+  scheme_extension_table->scheme_make_float = scheme_make_float;
+#endif
+  scheme_extension_table->scheme_make_char = scheme_make_char;
+  scheme_extension_table->scheme_make_promise = scheme_make_promise;
+  scheme_extension_table->scheme_make_promise_from_thunk = scheme_make_promise_from_thunk;
+#ifndef NO_SCHEME_THREADS
+  scheme_extension_table->scheme_make_sema = scheme_make_sema;
+#endif
+  scheme_extension_table->scheme_post_sema = scheme_post_sema;
+  scheme_extension_table->scheme_wait_sema = scheme_wait_sema;
+  scheme_extension_table->scheme_char_constants = scheme_char_constants;
+  scheme_extension_table->scheme_get_int_val = scheme_get_int_val;
+  scheme_extension_table->scheme_get_unsigned_int_val = scheme_get_unsigned_int_val;
+  scheme_extension_table->scheme_get_proc_name = scheme_get_proc_name;
+  scheme_extension_table->scheme_make_bignum = scheme_make_bignum;
+  scheme_extension_table->scheme_make_bignum_from_unsigned = scheme_make_bignum_from_unsigned;
+  scheme_extension_table->scheme_bignum_to_double = scheme_bignum_to_double;
+  scheme_extension_table->scheme_bignum_from_double = scheme_bignum_from_double;
+#ifdef MZ_USE_SINGLE_FLOATS
+  scheme_extension_table->scheme_bignum_to_float = scheme_bignum_to_float;
+  scheme_extension_table->scheme_bignum_from_float = scheme_bignum_from_float;
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+  scheme_extension_table->scheme_bignum_to_string = scheme_bignum_to_string;
+  scheme_extension_table->scheme_read_bignum = scheme_read_bignum;
+  scheme_extension_table->scheme_bignum_normalize = scheme_bignum_normalize;
+  scheme_extension_table->scheme_double_to_int = scheme_double_to_int;
+  scheme_extension_table->scheme_make_rational = scheme_make_rational;
+  scheme_extension_table->scheme_rational_to_double = scheme_rational_to_double;
+  scheme_extension_table->scheme_rational_from_double = scheme_rational_from_double;
+#ifdef MZ_USE_SINGLE_FLOATS
+  scheme_extension_table->scheme_rational_to_float = scheme_rational_to_float;
+  scheme_extension_table->scheme_rational_from_float = scheme_rational_from_float;
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+  scheme_extension_table->scheme_rational_normalize = scheme_rational_normalize;
+  scheme_extension_table->scheme_rational_numerator = scheme_rational_numerator;
+  scheme_extension_table->scheme_rational_denominator = scheme_rational_denominator;
+  scheme_extension_table->scheme_make_complex = scheme_make_complex;
+  scheme_extension_table->scheme_complex_normalize = scheme_complex_normalize;
+  scheme_extension_table->scheme_complex_real_part = scheme_complex_real_part;
+  scheme_extension_table->scheme_complex_imaginary_part = scheme_complex_imaginary_part;
+  scheme_extension_table->scheme_is_exact = scheme_is_exact;
+  scheme_extension_table->scheme_is_inexact = scheme_is_inexact;
+  scheme_extension_table->scheme_expand = scheme_expand;
+  scheme_extension_table->scheme_compile = scheme_compile;
+  scheme_extension_table->scheme_make_promise_value = scheme_make_promise_value;
+  scheme_extension_table->scheme_read = scheme_read;
+  scheme_extension_table->scheme_write = scheme_write;
+  scheme_extension_table->scheme_display = scheme_display;
+  scheme_extension_table->scheme_write_w_max = scheme_write_w_max;
+  scheme_extension_table->scheme_display_w_max = scheme_display_w_max;
+  scheme_extension_table->scheme_write_string = scheme_write_string;
+  scheme_extension_table->scheme_write_to_string = scheme_write_to_string;
+  scheme_extension_table->scheme_display_to_string = scheme_display_to_string;
+  scheme_extension_table->scheme_write_to_string_w_max = scheme_write_to_string_w_max;
+  scheme_extension_table->scheme_display_to_string_w_max = scheme_display_to_string_w_max;
+  scheme_extension_table->scheme_debug_print = scheme_debug_print;
+  scheme_extension_table->scheme_flush_output = scheme_flush_output;
+  scheme_extension_table->scheme_format = scheme_format;
+  scheme_extension_table->scheme_printf = scheme_printf;
+  scheme_extension_table->scheme_getc = scheme_getc;
+  scheme_extension_table->scheme_ungetc = scheme_ungetc;
+  scheme_extension_table->scheme_char_ready = scheme_char_ready;
+  scheme_extension_table->scheme_need_wakeup = scheme_need_wakeup;
+  scheme_extension_table->scheme_get_chars = scheme_get_chars;
+  scheme_extension_table->scheme_tell = scheme_tell;
+  scheme_extension_table->scheme_output_tell = scheme_output_tell;
+  scheme_extension_table->scheme_tell_line = scheme_tell_line;
+  scheme_extension_table->scheme_close_input_port = scheme_close_input_port;
+  scheme_extension_table->scheme_close_output_port = scheme_close_output_port;
+  scheme_extension_table->scheme_are_all_chars_ready = scheme_are_all_chars_ready;
+  scheme_extension_table->scheme_make_port_type = scheme_make_port_type;
+  scheme_extension_table->scheme_make_input_port = scheme_make_input_port;
+  scheme_extension_table->scheme_make_output_port = scheme_make_output_port;
+  scheme_extension_table->scheme_make_file_input_port = scheme_make_file_input_port;
+  scheme_extension_table->scheme_make_named_file_input_port = scheme_make_named_file_input_port;
+  scheme_extension_table->scheme_make_file_output_port = scheme_make_file_output_port;
+  scheme_extension_table->scheme_make_string_input_port = scheme_make_string_input_port;
+  scheme_extension_table->scheme_make_sized_string_input_port = scheme_make_sized_string_input_port;
+  scheme_extension_table->scheme_make_string_output_port = scheme_make_string_output_port;
+  scheme_extension_table->scheme_get_string_output = scheme_get_string_output;
+  scheme_extension_table->scheme_get_sized_string_output = scheme_get_sized_string_output;
+  scheme_extension_table->scheme_pipe = scheme_pipe;
+  scheme_extension_table->scheme_file_exists = scheme_file_exists;
+  scheme_extension_table->scheme_directory_exists = scheme_directory_exists;
+  scheme_extension_table->scheme_expand_filename = scheme_expand_filename;
+  scheme_extension_table->scheme_getcwd = scheme_getcwd;
+  scheme_extension_table->scheme_setcwd = scheme_setcwd;
+  scheme_extension_table->scheme_getdrive = scheme_getdrive;
+  scheme_extension_table->scheme_split_pathname = scheme_split_pathname;
+  scheme_extension_table->scheme_build_pathname = scheme_build_pathname;
+  scheme_extension_table->scheme_alloc_fdset_array = scheme_alloc_fdset_array;
+  scheme_extension_table->scheme_init_fdset_array = scheme_init_fdset_array;
+  scheme_extension_table->scheme_get_fdset = scheme_get_fdset;
+  scheme_extension_table->scheme_fdzero = scheme_fdzero;
+  scheme_extension_table->scheme_fdset = scheme_fdset;
+  scheme_extension_table->scheme_fdclr = scheme_fdclr;
+  scheme_extension_table->scheme_fdisset = scheme_fdisset;
+  scheme_extension_table->scheme_add_global = scheme_add_global;
+  scheme_extension_table->scheme_add_global_constant = scheme_add_global_constant;
+  scheme_extension_table->scheme_add_global_keyword = scheme_add_global_keyword;
+  scheme_extension_table->scheme_remove_global = scheme_remove_global;
+  scheme_extension_table->scheme_remove_global_constant = scheme_remove_global_constant;
+  scheme_extension_table->scheme_add_global_symbol = scheme_add_global_symbol;
+  scheme_extension_table->scheme_remove_global_symbol = scheme_remove_global_symbol;
+  scheme_extension_table->scheme_add_global_constant_symbol = scheme_add_global_constant_symbol;
+  scheme_extension_table->scheme_constant = scheme_constant;
+  scheme_extension_table->scheme_set_keyword = scheme_set_keyword;
+  scheme_extension_table->scheme_make_envunbox = scheme_make_envunbox;
+  scheme_extension_table->scheme_lookup_global = scheme_lookup_global;
+  scheme_extension_table->scheme_global_bucket = scheme_global_bucket;
+  scheme_extension_table->scheme_set_global_bucket = scheme_set_global_bucket;
+  scheme_extension_table->scheme_intern_symbol = scheme_intern_symbol;
+  scheme_extension_table->scheme_intern_exact_symbol = scheme_intern_exact_symbol;
+  scheme_extension_table->scheme_make_symbol = scheme_make_symbol;
+  scheme_extension_table->scheme_make_exact_symbol = scheme_make_exact_symbol;
+  scheme_extension_table->scheme_symbol_name = scheme_symbol_name;
+  scheme_extension_table->scheme_symbol_name_and_size = scheme_symbol_name_and_size;
+  scheme_extension_table->scheme_intern_type_symbol = scheme_intern_type_symbol;
+  scheme_extension_table->scheme_make_type_symbol = scheme_make_type_symbol;
+  scheme_extension_table->scheme_make_struct_values = scheme_make_struct_values;
+  scheme_extension_table->scheme_make_struct_names = scheme_make_struct_names;
+  scheme_extension_table->scheme_make_struct_type = scheme_make_struct_type;
+  scheme_extension_table->scheme_make_struct_instance = scheme_make_struct_instance;
+  scheme_extension_table->scheme_is_struct_instance = scheme_is_struct_instance;
+#ifndef NO_OBJECT_SYSTEM
+  scheme_extension_table->scheme_make_class = scheme_make_class;
+  scheme_extension_table->scheme_add_method = scheme_add_method;
+  scheme_extension_table->scheme_add_method_w_arity = scheme_add_method_w_arity;
+  scheme_extension_table->scheme_made_class = scheme_made_class;
+  scheme_extension_table->scheme_make_object = scheme_make_object;
+  scheme_extension_table->scheme_make_uninited_object = scheme_make_uninited_object;
+  scheme_extension_table->scheme_find_ivar = scheme_find_ivar;
+  scheme_extension_table->scheme_is_subclass = scheme_is_subclass;
+  scheme_extension_table->scheme_is_implementation = scheme_is_implementation;
+  scheme_extension_table->scheme_is_interface_extension = scheme_is_interface_extension;
+  scheme_extension_table->scheme_is_a = scheme_is_a;
+  scheme_extension_table->scheme_get_class_name = scheme_get_class_name;
+  scheme_extension_table->scheme_get_interface_name = scheme_get_interface_name;
+  scheme_extension_table->scheme_make_class_assembly = scheme_make_class_assembly;
+  scheme_extension_table->scheme_create_class = scheme_create_class;
+  scheme_extension_table->scheme_make_interface_assembly = scheme_make_interface_assembly;
+  scheme_extension_table->scheme_create_interface = scheme_create_interface;
+  scheme_extension_table->scheme_apply_generic_data = scheme_apply_generic_data;
+  scheme_extension_table->scheme_get_generic_data = scheme_get_generic_data;
+#endif
+  scheme_extension_table->scheme_invoke_unit = scheme_invoke_unit;
+  scheme_extension_table->scheme_assemble_compound_unit = scheme_assemble_compound_unit;
+  scheme_extension_table->scheme_make_compound_unit = scheme_make_compound_unit;
+  scheme_extension_table->scheme_get_unit_name = scheme_get_unit_name;
+  scheme_extension_table->scheme_eq = scheme_eq;
+  scheme_extension_table->scheme_eqv = scheme_eqv;
+  scheme_extension_table->scheme_equal = scheme_equal;
+  scheme_extension_table->scheme_build_list = scheme_build_list;
+  scheme_extension_table->scheme_list_length = scheme_list_length;
+  scheme_extension_table->scheme_proper_list_length = scheme_proper_list_length;
+  scheme_extension_table->scheme_alloc_list = scheme_alloc_list;
+  scheme_extension_table->scheme_map_1 = scheme_map_1;
+  scheme_extension_table->scheme_car = scheme_car;
+  scheme_extension_table->scheme_cdr = scheme_cdr;
+  scheme_extension_table->scheme_cadr = scheme_cadr;
+  scheme_extension_table->scheme_caddr = scheme_caddr;
+  scheme_extension_table->scheme_vector_to_list = scheme_vector_to_list;
+  scheme_extension_table->scheme_list_to_vector = scheme_list_to_vector;
+  scheme_extension_table->scheme_append = scheme_append;
+  scheme_extension_table->scheme_box = scheme_box;
+  scheme_extension_table->scheme_unbox = scheme_unbox;
+  scheme_extension_table->scheme_set_box = scheme_set_box;
+  scheme_extension_table->scheme_make_weak_box = scheme_make_weak_box;
+  scheme_extension_table->scheme_load = scheme_load;
+  scheme_extension_table->scheme_load_extension = scheme_load_extension;
+  scheme_extension_table->scheme_register_extension_global = scheme_register_extension_global;
+  scheme_extension_table->scheme_get_milliseconds = scheme_get_milliseconds;
+  scheme_extension_table->scheme_get_process_milliseconds = scheme_get_process_milliseconds;
+  scheme_extension_table->scheme_rep = scheme_rep;
+  scheme_extension_table->scheme_banner = scheme_banner;
+  scheme_extension_table->scheme_version = scheme_version;
+  scheme_extension_table->scheme_check_proc_arity = scheme_check_proc_arity;
+  scheme_extension_table->scheme_secure_exceptions = scheme_secure_exceptions;
+  scheme_extension_table->scheme_make_provided_string = scheme_make_provided_string;
+  scheme_extension_table->scheme_make_args_string = scheme_make_args_string;
+  scheme_extension_table->scheme_no_dumps = scheme_no_dumps;
+  scheme_extension_table->scheme_system_library_subpath = scheme_system_library_subpath;
diff --git a/src/mzscheme/src/schemexm.h b/src/mzscheme/src/schemexm.h
new file mode 100644
index 0000000..903eb5d
--- /dev/null
+++ b/src/mzscheme/src/schemexm.h
@@ -0,0 +1,332 @@
+#define scheme_init_jmpup_buf (scheme_extension_table->scheme_init_jmpup_buf)
+#define scheme_setjmpup_relative (scheme_extension_table->scheme_setjmpup_relative)
+#define scheme_longjmpup (scheme_extension_table->scheme_longjmpup)
+#ifdef USE_MZ_SETJMP
+#define scheme_setjmp (scheme_extension_table->scheme_setjmp)
+#define scheme_longjmp (scheme_extension_table->scheme_longjmp)
+#endif
+#define scheme_make_config (scheme_extension_table->scheme_make_config)
+#define scheme_branch_config (scheme_extension_table->scheme_branch_config)
+#define scheme_new_param (scheme_extension_table->scheme_new_param)
+#define scheme_param_config (scheme_extension_table->scheme_param_config)
+#define scheme_register_parameter (scheme_extension_table->scheme_register_parameter)
+#define scheme_get_env (scheme_extension_table->scheme_get_env)
+#ifdef MZ_REAL_THREADS
+#define scheme_get_current_process (scheme_extension_table->scheme_get_current_process)
+#else
+#ifndef LINK_EXTENSIONS_BY_TABLE
+#define scheme_current_process (scheme_extension_table->scheme_current_process)
+#define scheme_fuel_counter (scheme_extension_table->scheme_fuel_counter)
+#else
+#define scheme_current_process_ptr (scheme_extension_table->scheme_current_process_ptr)
+#define scheme_fuel_counter_ptr (scheme_extension_table->scheme_fuel_counter_ptr)
+#endif
+#endif
+#ifndef NO_SCHEME_THREADS
+#define scheme_make_namespace (scheme_extension_table->scheme_make_namespace)
+#define scheme_thread (scheme_extension_table->scheme_thread)
+#define scheme_break_thread (scheme_extension_table->scheme_break_thread)
+#define scheme_kill_thread (scheme_extension_table->scheme_kill_thread)
+#endif
+#ifndef MZ_REAL_THREADS
+#define scheme_process_block (scheme_extension_table->scheme_process_block)
+#define scheme_swap_process (scheme_extension_table->scheme_swap_process)
+#else
+#define scheme_process_block_w_process (scheme_extension_table->scheme_process_block_w_process)
+#endif
+#define scheme_block_until (scheme_extension_table->scheme_block_until)
+#define scheme_in_main_thread (scheme_extension_table->scheme_in_main_thread)
+#define scheme_tls_allocate (scheme_extension_table->scheme_tls_allocate)
+#define scheme_tls_set (scheme_extension_table->scheme_tls_set)
+#define scheme_tls_get (scheme_extension_table->scheme_tls_get)
+#define scheme_add_namespace_option (scheme_extension_table->scheme_add_namespace_option)
+#define scheme_make_manager (scheme_extension_table->scheme_make_manager)
+#define scheme_add_managed (scheme_extension_table->scheme_add_managed)
+#define scheme_remove_managed (scheme_extension_table->scheme_remove_managed)
+#define scheme_close_managed (scheme_extension_table->scheme_close_managed)
+#define scheme_signal_error (scheme_extension_table->scheme_signal_error)
+#define scheme_raise_exn (scheme_extension_table->scheme_raise_exn)
+#define scheme_warning (scheme_extension_table->scheme_warning)
+#define scheme_wrong_count (scheme_extension_table->scheme_wrong_count)
+#define scheme_case_lambda_wrong_count (scheme_extension_table->scheme_case_lambda_wrong_count)
+#define scheme_wrong_type (scheme_extension_table->scheme_wrong_type)
+#define scheme_wrong_return_arity (scheme_extension_table->scheme_wrong_return_arity)
+#define scheme_unbound_global (scheme_extension_table->scheme_unbound_global)
+#define scheme_dynamic_wind (scheme_extension_table->scheme_dynamic_wind)
+#define scheme_make_type (scheme_extension_table->scheme_make_type)
+#define scheme_install_type_reader (scheme_extension_table->scheme_install_type_reader)
+#define scheme_install_type_writer (scheme_extension_table->scheme_install_type_writer)
+#define scheme_eof (scheme_extension_table->scheme_eof)
+#define scheme_null (scheme_extension_table->scheme_null)
+#define scheme_true (scheme_extension_table->scheme_true)
+#define scheme_false (scheme_extension_table->scheme_false)
+#define scheme_void (scheme_extension_table->scheme_void)
+#define scheme_undefined (scheme_extension_table->scheme_undefined)
+#define scheme_tail_call_waiting (scheme_extension_table->scheme_tail_call_waiting)
+#define scheme_multiple_values (scheme_extension_table->scheme_multiple_values)
+#define scheme_eval (scheme_extension_table->scheme_eval)
+#define scheme_eval_multi (scheme_extension_table->scheme_eval_multi)
+#define scheme_eval_compiled (scheme_extension_table->scheme_eval_compiled)
+#define scheme_eval_compiled_multi (scheme_extension_table->scheme_eval_compiled_multi)
+#define _scheme_eval_compiled (scheme_extension_table->_scheme_eval_compiled)
+#define _scheme_eval_compiled_multi (scheme_extension_table->_scheme_eval_compiled_multi)
+#ifndef MZ_REAL_THREADS
+#define scheme_apply (scheme_extension_table->scheme_apply)
+#define scheme_apply_multi (scheme_extension_table->scheme_apply_multi)
+#else
+#define scheme_apply_wp (scheme_extension_table->scheme_apply_wp)
+#define scheme_apply_multi_wp (scheme_extension_table->scheme_apply_multi_wp)
+#endif
+#define scheme_apply_to_list (scheme_extension_table->scheme_apply_to_list)
+#define scheme_eval_string (scheme_extension_table->scheme_eval_string)
+#define scheme_eval_string_all (scheme_extension_table->scheme_eval_string_all)
+#define _scheme_apply_known_closed_prim (scheme_extension_table->_scheme_apply_known_closed_prim)
+#define _scheme_apply_known_closed_prim_multi (scheme_extension_table->_scheme_apply_known_closed_prim_multi)
+#define scheme_values (scheme_extension_table->scheme_values)
+#define scheme_check_one_value (scheme_extension_table->scheme_check_one_value)
+#define scheme_tail_apply (scheme_extension_table->scheme_tail_apply)
+#define scheme_tail_apply_no_copy (scheme_extension_table->scheme_tail_apply_no_copy)
+#define scheme_tail_apply_to_list (scheme_extension_table->scheme_tail_apply_to_list)
+#define scheme_tail_eval_expr (scheme_extension_table->scheme_tail_eval_expr)
+#define scheme_set_tail_buffer_size (scheme_extension_table->scheme_set_tail_buffer_size)
+#define scheme_force_value (scheme_extension_table->scheme_force_value)
+#ifndef MZ_REAL_THREADS
+#define scheme_do_eval (scheme_extension_table->scheme_do_eval)
+#else
+#define scheme_do_eval_w_process (scheme_extension_table->scheme_do_eval_w_process)
+#endif
+#ifndef SCHEME_NO_GC
+#ifndef SCHEME_NO_GC_PROTO
+#define GC_malloc (scheme_extension_table->GC_malloc)
+#define GC_malloc_atomic (scheme_extension_table->GC_malloc_atomic)
+#define GC_malloc_stubborn (scheme_extension_table->GC_malloc_stubborn)
+#define GC_malloc_uncollectable (scheme_extension_table->GC_malloc_uncollectable)
+#endif
+#endif
+#define scheme_malloc_eternal (scheme_extension_table->scheme_malloc_eternal)
+#define scheme_end_stubborn_change (scheme_extension_table->scheme_end_stubborn_change)
+#define scheme_calloc (scheme_extension_table->scheme_calloc)
+#define scheme_strdup (scheme_extension_table->scheme_strdup)
+#define scheme_strdup_eternal (scheme_extension_table->scheme_strdup_eternal)
+#define scheme_malloc_fail_ok (scheme_extension_table->scheme_malloc_fail_ok)
+#define scheme_weak_reference (scheme_extension_table->scheme_weak_reference)
+#define scheme_weak_reference_indirect (scheme_extension_table->scheme_weak_reference_indirect)
+#define scheme_add_finalizer (scheme_extension_table->scheme_add_finalizer)
+#define scheme_add_scheme_finalizer (scheme_extension_table->scheme_add_scheme_finalizer)
+#define scheme_register_finalizer (scheme_extension_table->scheme_register_finalizer)
+#define scheme_dont_gc_ptr (scheme_extension_table->scheme_dont_gc_ptr)
+#define scheme_gc_ptr_ok (scheme_extension_table->scheme_gc_ptr_ok)
+#define scheme_collect_garbage (scheme_extension_table->scheme_collect_garbage)
+#define scheme_hash_table (scheme_extension_table->scheme_hash_table)
+#define scheme_add_to_table (scheme_extension_table->scheme_add_to_table)
+#define scheme_change_in_table (scheme_extension_table->scheme_change_in_table)
+#define scheme_lookup_in_table (scheme_extension_table->scheme_lookup_in_table)
+#define scheme_bucket_from_table (scheme_extension_table->scheme_bucket_from_table)
+#define scheme_make_prim (scheme_extension_table->scheme_make_prim)
+#define scheme_make_noneternal_prim (scheme_extension_table->scheme_make_noneternal_prim)
+#define scheme_make_closed_prim (scheme_extension_table->scheme_make_closed_prim)
+#define scheme_make_prim_w_arity (scheme_extension_table->scheme_make_prim_w_arity)
+#define scheme_make_folding_prim (scheme_extension_table->scheme_make_folding_prim)
+#define scheme_make_noneternal_prim_w_arity (scheme_extension_table->scheme_make_noneternal_prim_w_arity)
+#define scheme_make_closed_prim_w_arity (scheme_extension_table->scheme_make_closed_prim_w_arity)
+#define scheme_make_folding_closed_prim (scheme_extension_table->scheme_make_folding_closed_prim)
+#define scheme_make_closure (scheme_extension_table->scheme_make_closure)
+#define scheme_make_pair (scheme_extension_table->scheme_make_pair)
+#define scheme_make_string (scheme_extension_table->scheme_make_string)
+#define scheme_make_sized_string (scheme_extension_table->scheme_make_sized_string)
+#define scheme_make_string_without_copying (scheme_extension_table->scheme_make_string_without_copying)
+#define scheme_alloc_string (scheme_extension_table->scheme_alloc_string)
+#define scheme_append_string (scheme_extension_table->scheme_append_string)
+#define scheme_make_vector (scheme_extension_table->scheme_make_vector)
+#define scheme_make_integer_value (scheme_extension_table->scheme_make_integer_value)
+#define scheme_make_integer_value_from_unsigned (scheme_extension_table->scheme_make_integer_value_from_unsigned)
+#define scheme_make_double (scheme_extension_table->scheme_make_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_make_float (scheme_extension_table->scheme_make_float)
+#endif
+#define scheme_make_char (scheme_extension_table->scheme_make_char)
+#define scheme_make_promise (scheme_extension_table->scheme_make_promise)
+#define scheme_make_promise_from_thunk (scheme_extension_table->scheme_make_promise_from_thunk)
+#ifndef NO_SCHEME_THREADS
+#define scheme_make_sema (scheme_extension_table->scheme_make_sema)
+#endif
+#define scheme_post_sema (scheme_extension_table->scheme_post_sema)
+#define scheme_wait_sema (scheme_extension_table->scheme_wait_sema)
+#define scheme_char_constants (scheme_extension_table->scheme_char_constants)
+#define scheme_get_int_val (scheme_extension_table->scheme_get_int_val)
+#define scheme_get_unsigned_int_val (scheme_extension_table->scheme_get_unsigned_int_val)
+#define scheme_get_proc_name (scheme_extension_table->scheme_get_proc_name)
+#define scheme_make_bignum (scheme_extension_table->scheme_make_bignum)
+#define scheme_make_bignum_from_unsigned (scheme_extension_table->scheme_make_bignum_from_unsigned)
+#define scheme_bignum_to_double (scheme_extension_table->scheme_bignum_to_double)
+#define scheme_bignum_from_double (scheme_extension_table->scheme_bignum_from_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_bignum_to_float (scheme_extension_table->scheme_bignum_to_float)
+#define scheme_bignum_from_float (scheme_extension_table->scheme_bignum_from_float)
+#else
+# define scheme_bignum_to_float scheme_bignum_to_double
+# define scheme_bignum_from_float scheme_bignum_from_double
+#endif
+#define scheme_bignum_to_string (scheme_extension_table->scheme_bignum_to_string)
+#define scheme_read_bignum (scheme_extension_table->scheme_read_bignum)
+#define scheme_bignum_normalize (scheme_extension_table->scheme_bignum_normalize)
+#define scheme_double_to_int (scheme_extension_table->scheme_double_to_int)
+#define scheme_make_rational (scheme_extension_table->scheme_make_rational)
+#define scheme_rational_to_double (scheme_extension_table->scheme_rational_to_double)
+#define scheme_rational_from_double (scheme_extension_table->scheme_rational_from_double)
+#ifdef MZ_USE_SINGLE_FLOATS
+#define scheme_rational_to_float (scheme_extension_table->scheme_rational_to_float)
+#define scheme_rational_from_float (scheme_extension_table->scheme_rational_from_float)
+#else
+# define scheme_rational_to_float scheme_rational_to_double
+# define scheme_rational_from_float scheme_rational_from_double
+#endif
+#define scheme_rational_normalize (scheme_extension_table->scheme_rational_normalize)
+#define scheme_rational_numerator (scheme_extension_table->scheme_rational_numerator)
+#define scheme_rational_denominator (scheme_extension_table->scheme_rational_denominator)
+#define scheme_make_complex (scheme_extension_table->scheme_make_complex)
+#define scheme_complex_normalize (scheme_extension_table->scheme_complex_normalize)
+#define scheme_complex_real_part (scheme_extension_table->scheme_complex_real_part)
+#define scheme_complex_imaginary_part (scheme_extension_table->scheme_complex_imaginary_part)
+#define scheme_is_exact (scheme_extension_table->scheme_is_exact)
+#define scheme_is_inexact (scheme_extension_table->scheme_is_inexact)
+#define scheme_expand (scheme_extension_table->scheme_expand)
+#define scheme_compile (scheme_extension_table->scheme_compile)
+#define scheme_make_promise_value (scheme_extension_table->scheme_make_promise_value)
+#define scheme_read (scheme_extension_table->scheme_read)
+#define scheme_write (scheme_extension_table->scheme_write)
+#define scheme_display (scheme_extension_table->scheme_display)
+#define scheme_write_w_max (scheme_extension_table->scheme_write_w_max)
+#define scheme_display_w_max (scheme_extension_table->scheme_display_w_max)
+#define scheme_write_string (scheme_extension_table->scheme_write_string)
+#define scheme_write_to_string (scheme_extension_table->scheme_write_to_string)
+#define scheme_display_to_string (scheme_extension_table->scheme_display_to_string)
+#define scheme_write_to_string_w_max (scheme_extension_table->scheme_write_to_string_w_max)
+#define scheme_display_to_string_w_max (scheme_extension_table->scheme_display_to_string_w_max)
+#define scheme_debug_print (scheme_extension_table->scheme_debug_print)
+#define scheme_flush_output (scheme_extension_table->scheme_flush_output)
+#define scheme_format (scheme_extension_table->scheme_format)
+#define scheme_printf (scheme_extension_table->scheme_printf)
+#define scheme_getc (scheme_extension_table->scheme_getc)
+#define scheme_ungetc (scheme_extension_table->scheme_ungetc)
+#define scheme_char_ready (scheme_extension_table->scheme_char_ready)
+#define scheme_need_wakeup (scheme_extension_table->scheme_need_wakeup)
+#define scheme_get_chars (scheme_extension_table->scheme_get_chars)
+#define scheme_tell (scheme_extension_table->scheme_tell)
+#define scheme_output_tell (scheme_extension_table->scheme_output_tell)
+#define scheme_tell_line (scheme_extension_table->scheme_tell_line)
+#define scheme_close_input_port (scheme_extension_table->scheme_close_input_port)
+#define scheme_close_output_port (scheme_extension_table->scheme_close_output_port)
+#define scheme_are_all_chars_ready (scheme_extension_table->scheme_are_all_chars_ready)
+#define scheme_make_port_type (scheme_extension_table->scheme_make_port_type)
+#define scheme_make_input_port (scheme_extension_table->scheme_make_input_port)
+#define scheme_make_output_port (scheme_extension_table->scheme_make_output_port)
+#define scheme_make_file_input_port (scheme_extension_table->scheme_make_file_input_port)
+#define scheme_make_named_file_input_port (scheme_extension_table->scheme_make_named_file_input_port)
+#define scheme_make_file_output_port (scheme_extension_table->scheme_make_file_output_port)
+#define scheme_make_string_input_port (scheme_extension_table->scheme_make_string_input_port)
+#define scheme_make_sized_string_input_port (scheme_extension_table->scheme_make_sized_string_input_port)
+#define scheme_make_string_output_port (scheme_extension_table->scheme_make_string_output_port)
+#define scheme_get_string_output (scheme_extension_table->scheme_get_string_output)
+#define scheme_get_sized_string_output (scheme_extension_table->scheme_get_sized_string_output)
+#define scheme_pipe (scheme_extension_table->scheme_pipe)
+#define scheme_file_exists (scheme_extension_table->scheme_file_exists)
+#define scheme_directory_exists (scheme_extension_table->scheme_directory_exists)
+#define scheme_expand_filename (scheme_extension_table->scheme_expand_filename)
+#define scheme_getcwd (scheme_extension_table->scheme_getcwd)
+#define scheme_setcwd (scheme_extension_table->scheme_setcwd)
+#define scheme_getdrive (scheme_extension_table->scheme_getdrive)
+#define scheme_split_pathname (scheme_extension_table->scheme_split_pathname)
+#define scheme_build_pathname (scheme_extension_table->scheme_build_pathname)
+#define scheme_alloc_fdset_array (scheme_extension_table->scheme_alloc_fdset_array)
+#define scheme_init_fdset_array (scheme_extension_table->scheme_init_fdset_array)
+#define scheme_get_fdset (scheme_extension_table->scheme_get_fdset)
+#define scheme_fdzero (scheme_extension_table->scheme_fdzero)
+#define scheme_fdset (scheme_extension_table->scheme_fdset)
+#define scheme_fdclr (scheme_extension_table->scheme_fdclr)
+#define scheme_fdisset (scheme_extension_table->scheme_fdisset)
+#define scheme_add_global (scheme_extension_table->scheme_add_global)
+#define scheme_add_global_constant (scheme_extension_table->scheme_add_global_constant)
+#define scheme_add_global_keyword (scheme_extension_table->scheme_add_global_keyword)
+#define scheme_remove_global (scheme_extension_table->scheme_remove_global)
+#define scheme_remove_global_constant (scheme_extension_table->scheme_remove_global_constant)
+#define scheme_add_global_symbol (scheme_extension_table->scheme_add_global_symbol)
+#define scheme_remove_global_symbol (scheme_extension_table->scheme_remove_global_symbol)
+#define scheme_add_global_constant_symbol (scheme_extension_table->scheme_add_global_constant_symbol)
+#define scheme_constant (scheme_extension_table->scheme_constant)
+#define scheme_set_keyword (scheme_extension_table->scheme_set_keyword)
+#define scheme_make_envunbox (scheme_extension_table->scheme_make_envunbox)
+#define scheme_lookup_global (scheme_extension_table->scheme_lookup_global)
+#define scheme_global_bucket (scheme_extension_table->scheme_global_bucket)
+#define scheme_set_global_bucket (scheme_extension_table->scheme_set_global_bucket)
+#define scheme_intern_symbol (scheme_extension_table->scheme_intern_symbol)
+#define scheme_intern_exact_symbol (scheme_extension_table->scheme_intern_exact_symbol)
+#define scheme_make_symbol (scheme_extension_table->scheme_make_symbol)
+#define scheme_make_exact_symbol (scheme_extension_table->scheme_make_exact_symbol)
+#define scheme_symbol_name (scheme_extension_table->scheme_symbol_name)
+#define scheme_symbol_name_and_size (scheme_extension_table->scheme_symbol_name_and_size)
+#define scheme_intern_type_symbol (scheme_extension_table->scheme_intern_type_symbol)
+#define scheme_make_type_symbol (scheme_extension_table->scheme_make_type_symbol)
+#define scheme_make_struct_values (scheme_extension_table->scheme_make_struct_values)
+#define scheme_make_struct_names (scheme_extension_table->scheme_make_struct_names)
+#define scheme_make_struct_type (scheme_extension_table->scheme_make_struct_type)
+#define scheme_make_struct_instance (scheme_extension_table->scheme_make_struct_instance)
+#define scheme_is_struct_instance (scheme_extension_table->scheme_is_struct_instance)
+#ifndef NO_OBJECT_SYSTEM
+#define scheme_make_class (scheme_extension_table->scheme_make_class)
+#define scheme_add_method (scheme_extension_table->scheme_add_method)
+#define scheme_add_method_w_arity (scheme_extension_table->scheme_add_method_w_arity)
+#define scheme_made_class (scheme_extension_table->scheme_made_class)
+#define scheme_make_object (scheme_extension_table->scheme_make_object)
+#define scheme_make_uninited_object (scheme_extension_table->scheme_make_uninited_object)
+#define scheme_find_ivar (scheme_extension_table->scheme_find_ivar)
+#define scheme_is_subclass (scheme_extension_table->scheme_is_subclass)
+#define scheme_is_implementation (scheme_extension_table->scheme_is_implementation)
+#define scheme_is_interface_extension (scheme_extension_table->scheme_is_interface_extension)
+#define scheme_is_a (scheme_extension_table->scheme_is_a)
+#define scheme_get_class_name (scheme_extension_table->scheme_get_class_name)
+#define scheme_get_interface_name (scheme_extension_table->scheme_get_interface_name)
+#define scheme_make_class_assembly (scheme_extension_table->scheme_make_class_assembly)
+#define scheme_create_class (scheme_extension_table->scheme_create_class)
+#define scheme_make_interface_assembly (scheme_extension_table->scheme_make_interface_assembly)
+#define scheme_create_interface (scheme_extension_table->scheme_create_interface)
+#define scheme_apply_generic_data (scheme_extension_table->scheme_apply_generic_data)
+#define scheme_get_generic_data (scheme_extension_table->scheme_get_generic_data)
+#endif
+#define scheme_invoke_unit (scheme_extension_table->scheme_invoke_unit)
+#define scheme_assemble_compound_unit (scheme_extension_table->scheme_assemble_compound_unit)
+#define scheme_make_compound_unit (scheme_extension_table->scheme_make_compound_unit)
+#define scheme_get_unit_name (scheme_extension_table->scheme_get_unit_name)
+#define scheme_eq (scheme_extension_table->scheme_eq)
+#define scheme_eqv (scheme_extension_table->scheme_eqv)
+#define scheme_equal (scheme_extension_table->scheme_equal)
+#define scheme_build_list (scheme_extension_table->scheme_build_list)
+#define scheme_list_length (scheme_extension_table->scheme_list_length)
+#define scheme_proper_list_length (scheme_extension_table->scheme_proper_list_length)
+#define scheme_alloc_list (scheme_extension_table->scheme_alloc_list)
+#define scheme_map_1 (scheme_extension_table->scheme_map_1)
+#define scheme_car (scheme_extension_table->scheme_car)
+#define scheme_cdr (scheme_extension_table->scheme_cdr)
+#define scheme_cadr (scheme_extension_table->scheme_cadr)
+#define scheme_caddr (scheme_extension_table->scheme_caddr)
+#define scheme_vector_to_list (scheme_extension_table->scheme_vector_to_list)
+#define scheme_list_to_vector (scheme_extension_table->scheme_list_to_vector)
+#define scheme_append (scheme_extension_table->scheme_append)
+#define scheme_box (scheme_extension_table->scheme_box)
+#define scheme_unbox (scheme_extension_table->scheme_unbox)
+#define scheme_set_box (scheme_extension_table->scheme_set_box)
+#define scheme_make_weak_box (scheme_extension_table->scheme_make_weak_box)
+#define scheme_load (scheme_extension_table->scheme_load)
+#define scheme_load_extension (scheme_extension_table->scheme_load_extension)
+#define scheme_register_extension_global (scheme_extension_table->scheme_register_extension_global)
+#define scheme_get_milliseconds (scheme_extension_table->scheme_get_milliseconds)
+#define scheme_get_process_milliseconds (scheme_extension_table->scheme_get_process_milliseconds)
+#define scheme_rep (scheme_extension_table->scheme_rep)
+#define scheme_banner (scheme_extension_table->scheme_banner)
+#define scheme_version (scheme_extension_table->scheme_version)
+#define scheme_check_proc_arity (scheme_extension_table->scheme_check_proc_arity)
+#define scheme_secure_exceptions (scheme_extension_table->scheme_secure_exceptions)
+#define scheme_make_provided_string (scheme_extension_table->scheme_make_provided_string)
+#define scheme_make_args_string (scheme_extension_table->scheme_make_args_string)
+#define scheme_no_dumps (scheme_extension_table->scheme_no_dumps)
+#define scheme_system_library_subpath (scheme_extension_table->scheme_system_library_subpath)
diff --git a/src/mzscheme/src/schexn.h b/src/mzscheme/src/schexn.h
new file mode 100644
index 0000000..3453803
--- /dev/null
+++ b/src/mzscheme/src/schexn.h
@@ -0,0 +1,515 @@
+/* This file was generated by makeexn */
+#ifndef _MZEXN_DEFINES
+#define _MZEXN_DEFINES
+
+enum {
+  MZEXN,
+  MZEXN_USER,
+  MZEXN_SYNTAX,
+  MZEXN_VARIABLE,
+  MZEXN_APPLICATION,
+  MZEXN_APPLICATION_NON_PROCEDURE,
+  MZEXN_APPLICATION_ARITY,
+  MZEXN_APPLICATION_TYPE,
+  MZEXN_APPLICATION_RANGE,
+  MZEXN_APPLICATION_RANGE_BOUNDS,
+  MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR,
+  MZEXN_APPLICATION_RANGE_BOUNDS_STRING,
+  MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT,
+  MZEXN_APPLICATION_RANGE_LIST,
+  MZEXN_APPLICATION_LIST_SIZES,
+  MZEXN_APPLICATION_MAP_ARITY,
+  MZEXN_APPLICATION_INTEGER,
+  MZEXN_APPLICATION_LIST,
+  MZEXN_APPLICATION_MATH,
+  MZEXN_APPLICATION_MATH_ZERO,
+  MZEXN_APPLICATION_MATH_INFINITY,
+  MZEXN_APPLICATION_MATH_NEGATIVE,
+  MZEXN_APPLICATION_MATH_RADIX,
+  MZEXN_APPLICATION_MODE_CONFLICT,
+  MZEXN_APPLICATION_FILE_POSITION,
+  MZEXN_APPLICATION_FPRINTF,
+  MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS,
+  MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT,
+  MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE,
+  MZEXN_ELSE,
+  MZEXN_STRUCT,
+  MZEXN_STRUCT_STRUCT_TYPE,
+  MZEXN_OBJECT,
+  MZEXN_OBJECT_CLASS_TYPE,
+  MZEXN_OBJECT_INTERFACE_TYPE,
+  MZEXN_OBJECT_GENERIC,
+  MZEXN_OBJECT_INHERIT,
+  MZEXN_OBJECT_IMPLEMENT,
+  MZEXN_OBJECT_CLASS_IVAR,
+  MZEXN_OBJECT_INTERFACE_IVAR,
+  MZEXN_OBJECT_IVAR,
+  MZEXN_OBJECT_PRIVATE_CLASS,
+  MZEXN_OBJECT_INIT,
+  MZEXN_OBJECT_INIT_MULTIPLE,
+  MZEXN_OBJECT_INIT_NEVER,
+  MZEXN_UNIT,
+  MZEXN_UNIT_NON_UNIT,
+  MZEXN_UNIT_ARITY,
+  MZEXN_UNIT_IMPORT,
+  MZEXN_UNIT_EXPORT,
+  MZEXN_UNIT_INVOKE,
+  MZEXN_UNIT_INVOKE_VARIABLE,
+  MZEXN_UNIT_SIGNATURE,
+  MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT,
+  MZEXN_UNIT_SIGNATURE_ARITY,
+  MZEXN_UNIT_SIGNATURE_MATCH,
+  MZEXN_UNIT_SIGNATURE_MATCH_MISSING,
+  MZEXN_UNIT_SIGNATURE_MATCH_EXTRA,
+  MZEXN_UNIT_SIGNATURE_MATCH_KIND,
+  MZEXN_READ,
+  MZEXN_READ_PAREN,
+  MZEXN_READ_NUMBER,
+  MZEXN_READ_CHAR,
+  MZEXN_READ_EOF,
+  MZEXN_READ_DOT,
+  MZEXN_READ_UNSUPPORTED,
+  MZEXN_READ_VECTOR_LENGTH,
+  MZEXN_READ_COMPILED,
+  MZEXN_READ_GRAPH,
+  MZEXN_I_O,
+  MZEXN_I_O_READ,
+  MZEXN_I_O_WRITE,
+  MZEXN_I_O_FILESYSTEM,
+  MZEXN_I_O_FILESYSTEM_PATH,
+  MZEXN_I_O_FILESYSTEM_PATH_USERNAME,
+  MZEXN_I_O_FILESYSTEM_FILE,
+  MZEXN_I_O_FILESYSTEM_DIRECTORY,
+  MZEXN_I_O_FILESYSTEM_COLLECTION,
+  MZEXN_I_O_FILESYSTEM_FILE_EXISTS,
+  MZEXN_I_O_PORT_CLOSED,
+  MZEXN_I_O_USER_PORT,
+  MZEXN_I_O_TCP,
+  MZEXN_I_O_TCP_CONNECT,
+  MZEXN_I_O_TCP_LISTEN,
+  MZEXN_I_O_TCP_ACCEPT,
+  MZEXN_I_O_TCP_LISTENER_CLOSED,
+  MZEXN_MISC,
+  MZEXN_MISC_UNSUPPORTED,
+  MZEXN_MISC_USER_BREAK,
+  MZEXN_MISC_OUT_OF_MEMORY,
+  MZEXN_MISC_PARAMETERIZATION,
+  MZEXN_MISC_DEFMACRO,
+  MZEXN_MISC_EXPANSION_TIME,
+  MZEXN_MISC_CONSTANT,
+  MZEXN_MISC_CONTINUATION,
+  MZEXN_MISC_THREAD,
+  MZEXN_MISC_THREAD_KILL,
+  MZEXN_MISC_SEMAPHORE,
+  MZEXN_MISC_HASH_TABLE,
+  MZEXN_MISC_REGEXP,
+  MZEXN_MISC_PROCESS,
+  MZEXN_MISC_DYNAMIC_EXTENSION,
+  MZEXN_MISC_DYNAMIC_EXTENSION_OPEN,
+  MZEXN_MISC_DYNAMIC_EXTENSION_VERSION,
+  MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE,
+  MZEXN_MISC_IMAGE,
+  MZEXN_OTHER
+};
+
+#endif
+
+#ifdef _MZEXN_TABLE
+
+#define MZEXN_MAXARGS 7
+
+#ifdef GLOBAL_EXN_ARRAY
+static exn_rec exn_table[] = {
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 7, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 5, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 4, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 2, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 },
+  { 3, NULL, NULL, 0 }
+};
+#else
+static exn_rec *exn_table;
+#endif
+
+#endif
+
+#ifdef _MZEXN_PRESETUP
+
+#ifndef GLOBAL_EXN_ARRAY
+  exn_table = (exn_rec *)scheme_malloc(sizeof(exn_rec) * MZEXN_OTHER);
+  exn_table[MZEXN].args = 2;
+  exn_table[MZEXN_USER].args = 2;
+  exn_table[MZEXN_SYNTAX].args = 3;
+  exn_table[MZEXN_VARIABLE].args = 3;
+  exn_table[MZEXN_APPLICATION].args = 3;
+  exn_table[MZEXN_APPLICATION_NON_PROCEDURE].args = 3;
+  exn_table[MZEXN_APPLICATION_ARITY].args = 4;
+  exn_table[MZEXN_APPLICATION_TYPE].args = 4;
+  exn_table[MZEXN_APPLICATION_RANGE].args = 3;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_STRING].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT].args = 5;
+  exn_table[MZEXN_APPLICATION_RANGE_LIST].args = 3;
+  exn_table[MZEXN_APPLICATION_LIST_SIZES].args = 3;
+  exn_table[MZEXN_APPLICATION_MAP_ARITY].args = 4;
+  exn_table[MZEXN_APPLICATION_INTEGER].args = 3;
+  exn_table[MZEXN_APPLICATION_LIST].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_ZERO].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_INFINITY].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_NEGATIVE].args = 3;
+  exn_table[MZEXN_APPLICATION_MATH_RADIX].args = 3;
+  exn_table[MZEXN_APPLICATION_MODE_CONFLICT].args = 4;
+  exn_table[MZEXN_APPLICATION_FILE_POSITION].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS].args = 4;
+  exn_table[MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT].args = 3;
+  exn_table[MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE].args = 4;
+  exn_table[MZEXN_ELSE].args = 2;
+  exn_table[MZEXN_STRUCT].args = 2;
+  exn_table[MZEXN_STRUCT_STRUCT_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT].args = 2;
+  exn_table[MZEXN_OBJECT_CLASS_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT_INTERFACE_TYPE].args = 3;
+  exn_table[MZEXN_OBJECT_GENERIC].args = 3;
+  exn_table[MZEXN_OBJECT_INHERIT].args = 3;
+  exn_table[MZEXN_OBJECT_IMPLEMENT].args = 3;
+  exn_table[MZEXN_OBJECT_CLASS_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_INTERFACE_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_IVAR].args = 4;
+  exn_table[MZEXN_OBJECT_PRIVATE_CLASS].args = 3;
+  exn_table[MZEXN_OBJECT_INIT].args = 4;
+  exn_table[MZEXN_OBJECT_INIT_MULTIPLE].args = 4;
+  exn_table[MZEXN_OBJECT_INIT_NEVER].args = 4;
+  exn_table[MZEXN_UNIT].args = 2;
+  exn_table[MZEXN_UNIT_NON_UNIT].args = 3;
+  exn_table[MZEXN_UNIT_ARITY].args = 3;
+  exn_table[MZEXN_UNIT_IMPORT].args = 7;
+  exn_table[MZEXN_UNIT_EXPORT].args = 5;
+  exn_table[MZEXN_UNIT_INVOKE].args = 2;
+  exn_table[MZEXN_UNIT_INVOKE_VARIABLE].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE].args = 2;
+  exn_table[MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE_ARITY].args = 3;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_MISSING].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_EXTRA].args = 5;
+  exn_table[MZEXN_UNIT_SIGNATURE_MATCH_KIND].args = 5;
+  exn_table[MZEXN_READ].args = 3;
+  exn_table[MZEXN_READ_PAREN].args = 3;
+  exn_table[MZEXN_READ_NUMBER].args = 4;
+  exn_table[MZEXN_READ_CHAR].args = 4;
+  exn_table[MZEXN_READ_EOF].args = 4;
+  exn_table[MZEXN_READ_DOT].args = 3;
+  exn_table[MZEXN_READ_UNSUPPORTED].args = 4;
+  exn_table[MZEXN_READ_VECTOR_LENGTH].args = 4;
+  exn_table[MZEXN_READ_COMPILED].args = 3;
+  exn_table[MZEXN_READ_GRAPH].args = 3;
+  exn_table[MZEXN_I_O].args = 2;
+  exn_table[MZEXN_I_O_READ].args = 3;
+  exn_table[MZEXN_I_O_WRITE].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_PATH].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_PATH_USERNAME].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_FILE].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_DIRECTORY].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_COLLECTION].args = 3;
+  exn_table[MZEXN_I_O_FILESYSTEM_FILE_EXISTS].args = 3;
+  exn_table[MZEXN_I_O_PORT_CLOSED].args = 3;
+  exn_table[MZEXN_I_O_USER_PORT].args = 3;
+  exn_table[MZEXN_I_O_TCP].args = 2;
+  exn_table[MZEXN_I_O_TCP_CONNECT].args = 4;
+  exn_table[MZEXN_I_O_TCP_LISTEN].args = 3;
+  exn_table[MZEXN_I_O_TCP_ACCEPT].args = 3;
+  exn_table[MZEXN_I_O_TCP_LISTENER_CLOSED].args = 3;
+  exn_table[MZEXN_MISC].args = 2;
+  exn_table[MZEXN_MISC_UNSUPPORTED].args = 2;
+  exn_table[MZEXN_MISC_USER_BREAK].args = 2;
+  exn_table[MZEXN_MISC_OUT_OF_MEMORY].args = 2;
+  exn_table[MZEXN_MISC_PARAMETERIZATION].args = 3;
+  exn_table[MZEXN_MISC_DEFMACRO].args = 3;
+  exn_table[MZEXN_MISC_EXPANSION_TIME].args = 2;
+  exn_table[MZEXN_MISC_CONSTANT].args = 3;
+  exn_table[MZEXN_MISC_CONTINUATION].args = 2;
+  exn_table[MZEXN_MISC_THREAD].args = 2;
+  exn_table[MZEXN_MISC_THREAD_KILL].args = 2;
+  exn_table[MZEXN_MISC_SEMAPHORE].args = 2;
+  exn_table[MZEXN_MISC_HASH_TABLE].args = 3;
+  exn_table[MZEXN_MISC_REGEXP].args = 2;
+  exn_table[MZEXN_MISC_PROCESS].args = 2;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_OPEN].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_VERSION].args = 3;
+  exn_table[MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE].args = 3;
+  exn_table[MZEXN_MISC_IMAGE].args = 3;
+#endif
+
+#endif
+
+#ifdef _MZEXN_DECL_FIELDS
+
+static const char *MZEXN_FIELDS[2] = { "message", "debug-info" };
+static const char *MZEXN_SYNTAX_FIELDS[1] = { "expr" };
+static const char *MZEXN_VARIABLE_FIELDS[1] = { "id" };
+static const char *MZEXN_APPLICATION_FIELDS[1] = { "value" };
+static const char *MZEXN_APPLICATION_ARITY_FIELDS[1] = { "expected" };
+static const char *MZEXN_APPLICATION_TYPE_FIELDS[1] = { "expected" };
+static const char *MZEXN_APPLICATION_RANGE_BOUNDS_FIELDS[2] = { "min", "max" };
+static const char *MZEXN_APPLICATION_MAP_ARITY_FIELDS[1] = { "provided" };
+static const char *MZEXN_APPLICATION_MODE_CONFLICT_FIELDS[1] = { "filename" };
+static const char *MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS_FIELDS[1] = { "extras" };
+static const char *MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE_FIELDS[1] = { "expected" };
+static const char *MZEXN_STRUCT_STRUCT_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_CLASS_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_INTERFACE_TYPE_FIELDS[1] = { "value" };
+static const char *MZEXN_OBJECT_GENERIC_FIELDS[1] = { "object" };
+static const char *MZEXN_OBJECT_INHERIT_FIELDS[1] = { "ivar" };
+static const char *MZEXN_OBJECT_IMPLEMENT_FIELDS[1] = { "ivar" };
+static const char *MZEXN_OBJECT_CLASS_IVAR_FIELDS[2] = { "class", "ivar" };
+static const char *MZEXN_OBJECT_INTERFACE_IVAR_FIELDS[2] = { "interface", "ivar" };
+static const char *MZEXN_OBJECT_IVAR_FIELDS[2] = { "object", "ivar" };
+static const char *MZEXN_OBJECT_PRIVATE_CLASS_FIELDS[1] = { "class" };
+static const char *MZEXN_OBJECT_INIT_FIELDS[2] = { "object", "class" };
+static const char *MZEXN_UNIT_NON_UNIT_FIELDS[1] = { "value" };
+static const char *MZEXN_UNIT_ARITY_FIELDS[1] = { "unit" };
+static const char *MZEXN_UNIT_IMPORT_FIELDS[5] = { "in-unit", "out-unit", "in-tag", "out-tag", "name" };
+static const char *MZEXN_UNIT_EXPORT_FIELDS[3] = { "unit", "tag", "name" };
+static const char *MZEXN_UNIT_INVOKE_VARIABLE_FIELDS[1] = { "name" };
+static const char *MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT_FIELDS[1] = { "value" };
+static const char *MZEXN_UNIT_SIGNATURE_ARITY_FIELDS[1] = { "unit" };
+static const char *MZEXN_UNIT_SIGNATURE_MATCH_FIELDS[3] = { "dest-context", "src-context", "variable" };
+static const char *MZEXN_READ_FIELDS[1] = { "port" };
+static const char *MZEXN_READ_NUMBER_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_CHAR_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_EOF_FIELDS[1] = { "expected" };
+static const char *MZEXN_READ_UNSUPPORTED_FIELDS[1] = { "input" };
+static const char *MZEXN_READ_VECTOR_LENGTH_FIELDS[1] = { "input" };
+static const char *MZEXN_I_O_READ_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_WRITE_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_FILESYSTEM_FIELDS[1] = { "pathname" };
+static const char *MZEXN_I_O_PORT_CLOSED_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_USER_PORT_FIELDS[1] = { "port" };
+static const char *MZEXN_I_O_TCP_CONNECT_FIELDS[2] = { "address", "port-id" };
+static const char *MZEXN_I_O_TCP_LISTEN_FIELDS[1] = { "port-id" };
+static const char *MZEXN_I_O_TCP_ACCEPT_FIELDS[1] = { "listener" };
+static const char *MZEXN_I_O_TCP_LISTENER_CLOSED_FIELDS[1] = { "listener" };
+static const char *MZEXN_MISC_PARAMETERIZATION_FIELDS[1] = { "value" };
+static const char *MZEXN_MISC_DEFMACRO_FIELDS[1] = { "value" };
+static const char *MZEXN_MISC_CONSTANT_FIELDS[1] = { "id" };
+static const char *MZEXN_MISC_HASH_TABLE_FIELDS[1] = { "key" };
+static const char *MZEXN_MISC_DYNAMIC_EXTENSION_FIELDS[1] = { "name" };
+static const char *MZEXN_MISC_IMAGE_FIELDS[1] = { "name" };
+
+#endif
+
+#ifdef _MZEXN_SETUP
+
+  SETUP_STRUCT(MZEXN, NULL, "exn", 2, MZEXN_FIELDS)
+  SETUP_STRUCT(MZEXN_USER, EXN_PARENT(MZEXN), "exn:user", 0, NULL)
+  SETUP_STRUCT(MZEXN_SYNTAX, EXN_PARENT(MZEXN), "exn:syntax", 1, MZEXN_SYNTAX_FIELDS)
+  SETUP_STRUCT(MZEXN_VARIABLE, EXN_PARENT(MZEXN), "exn:variable", 1, MZEXN_VARIABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION, EXN_PARENT(MZEXN), "exn:application", 1, MZEXN_APPLICATION_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_NON_PROCEDURE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:non-procedure", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_ARITY, EXN_PARENT(MZEXN_APPLICATION), "exn:application:arity", 1, MZEXN_APPLICATION_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_TYPE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:type", 1, MZEXN_APPLICATION_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE, EXN_PARENT(MZEXN_APPLICATION), "exn:application:range", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS, EXN_PARENT(MZEXN_APPLICATION_RANGE), "exn:application:range:bounds", 2, MZEXN_APPLICATION_RANGE_BOUNDS_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:vector", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_STRING, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:string", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT, EXN_PARENT(MZEXN_APPLICATION_RANGE_BOUNDS), "exn:application:range:bounds:struct", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_RANGE_LIST, EXN_PARENT(MZEXN_APPLICATION_RANGE), "exn:application:range:list", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_LIST_SIZES, EXN_PARENT(MZEXN_APPLICATION), "exn:application:list-sizes", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MAP_ARITY, EXN_PARENT(MZEXN_APPLICATION), "exn:application:map-arity", 1, MZEXN_APPLICATION_MAP_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_INTEGER, EXN_PARENT(MZEXN_APPLICATION), "exn:application:integer", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_LIST, EXN_PARENT(MZEXN_APPLICATION), "exn:application:list", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH, EXN_PARENT(MZEXN_APPLICATION), "exn:application:math", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_ZERO, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:zero", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_INFINITY, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:infinity", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_NEGATIVE, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:negative", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MATH_RADIX, EXN_PARENT(MZEXN_APPLICATION_MATH), "exn:application:math:radix", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_MODE_CONFLICT, EXN_PARENT(MZEXN_APPLICATION), "exn:application:mode-conflict", 1, MZEXN_APPLICATION_MODE_CONFLICT_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_FILE_POSITION, EXN_PARENT(MZEXN_APPLICATION), "exn:application:file-position", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF, EXN_PARENT(MZEXN_APPLICATION), "exn:application:fprintf", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:extra-arguments", 1, MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS_FIELDS)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:no-argument", 0, NULL)
+  SETUP_STRUCT(MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE, EXN_PARENT(MZEXN_APPLICATION_FPRINTF), "exn:application:fprintf:argument-type", 1, MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_ELSE, EXN_PARENT(MZEXN), "exn:else", 0, NULL)
+  SETUP_STRUCT(MZEXN_STRUCT, EXN_PARENT(MZEXN), "exn:struct", 0, NULL)
+  SETUP_STRUCT(MZEXN_STRUCT_STRUCT_TYPE, EXN_PARENT(MZEXN_STRUCT), "exn:struct:struct-type", 1, MZEXN_STRUCT_STRUCT_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT, EXN_PARENT(MZEXN), "exn:object", 0, NULL)
+  SETUP_STRUCT(MZEXN_OBJECT_CLASS_TYPE, EXN_PARENT(MZEXN_OBJECT), "exn:object:class-type", 1, MZEXN_OBJECT_CLASS_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INTERFACE_TYPE, EXN_PARENT(MZEXN_OBJECT), "exn:object:interface-type", 1, MZEXN_OBJECT_INTERFACE_TYPE_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_GENERIC, EXN_PARENT(MZEXN_OBJECT), "exn:object:generic", 1, MZEXN_OBJECT_GENERIC_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INHERIT, EXN_PARENT(MZEXN_OBJECT), "exn:object:inherit", 1, MZEXN_OBJECT_INHERIT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_IMPLEMENT, EXN_PARENT(MZEXN_OBJECT), "exn:object:implement", 1, MZEXN_OBJECT_IMPLEMENT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_CLASS_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:class-ivar", 2, MZEXN_OBJECT_CLASS_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INTERFACE_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:interface-ivar", 2, MZEXN_OBJECT_INTERFACE_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_IVAR, EXN_PARENT(MZEXN_OBJECT), "exn:object:ivar", 2, MZEXN_OBJECT_IVAR_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_PRIVATE_CLASS, EXN_PARENT(MZEXN_OBJECT), "exn:object:private-class", 1, MZEXN_OBJECT_PRIVATE_CLASS_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT, EXN_PARENT(MZEXN_OBJECT), "exn:object:init", 2, MZEXN_OBJECT_INIT_FIELDS)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT_MULTIPLE, EXN_PARENT(MZEXN_OBJECT_INIT), "exn:object:init:multiple", 0, NULL)
+  SETUP_STRUCT(MZEXN_OBJECT_INIT_NEVER, EXN_PARENT(MZEXN_OBJECT_INIT), "exn:object:init:never", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT, EXN_PARENT(MZEXN), "exn:unit", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_NON_UNIT, EXN_PARENT(MZEXN_UNIT), "exn:unit:non-unit", 1, MZEXN_UNIT_NON_UNIT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_ARITY, EXN_PARENT(MZEXN_UNIT), "exn:unit:arity", 1, MZEXN_UNIT_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_IMPORT, EXN_PARENT(MZEXN_UNIT), "exn:unit:import", 5, MZEXN_UNIT_IMPORT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_EXPORT, EXN_PARENT(MZEXN_UNIT), "exn:unit:export", 3, MZEXN_UNIT_EXPORT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_INVOKE, EXN_PARENT(MZEXN_UNIT), "exn:unit:invoke", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_INVOKE_VARIABLE, EXN_PARENT(MZEXN_UNIT_INVOKE), "exn:unit:invoke:variable", 1, MZEXN_UNIT_INVOKE_VARIABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE, EXN_PARENT(MZEXN_UNIT), "exn:unit:signature", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:non-signed-unit", 1, MZEXN_UNIT_SIGNATURE_NON_SIGNED_UNIT_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_ARITY, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:arity", 1, MZEXN_UNIT_SIGNATURE_ARITY_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH, EXN_PARENT(MZEXN_UNIT_SIGNATURE), "exn:unit:signature:match", 3, MZEXN_UNIT_SIGNATURE_MATCH_FIELDS)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_MISSING, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:missing", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_EXTRA, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:extra", 0, NULL)
+  SETUP_STRUCT(MZEXN_UNIT_SIGNATURE_MATCH_KIND, EXN_PARENT(MZEXN_UNIT_SIGNATURE_MATCH), "exn:unit:signature:match:kind", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ, EXN_PARENT(MZEXN), "exn:read", 1, MZEXN_READ_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_PAREN, EXN_PARENT(MZEXN_READ), "exn:read:paren", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_NUMBER, EXN_PARENT(MZEXN_READ), "exn:read:number", 1, MZEXN_READ_NUMBER_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_CHAR, EXN_PARENT(MZEXN_READ), "exn:read:char", 1, MZEXN_READ_CHAR_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_EOF, EXN_PARENT(MZEXN_READ), "exn:read:eof", 1, MZEXN_READ_EOF_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_DOT, EXN_PARENT(MZEXN_READ), "exn:read:dot", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_UNSUPPORTED, EXN_PARENT(MZEXN_READ), "exn:read:unsupported", 1, MZEXN_READ_UNSUPPORTED_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_VECTOR_LENGTH, EXN_PARENT(MZEXN_READ), "exn:read:vector-length", 1, MZEXN_READ_VECTOR_LENGTH_FIELDS)
+  SETUP_STRUCT(MZEXN_READ_COMPILED, EXN_PARENT(MZEXN_READ), "exn:read:compiled", 0, NULL)
+  SETUP_STRUCT(MZEXN_READ_GRAPH, EXN_PARENT(MZEXN_READ), "exn:read:graph", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O, EXN_PARENT(MZEXN), "exn:i/o", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_READ, EXN_PARENT(MZEXN_I_O), "exn:i/o:read", 1, MZEXN_I_O_READ_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_WRITE, EXN_PARENT(MZEXN_I_O), "exn:i/o:write", 1, MZEXN_I_O_WRITE_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM, EXN_PARENT(MZEXN_I_O), "exn:i/o:filesystem", 1, MZEXN_I_O_FILESYSTEM_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_PATH, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:path", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_PATH_USERNAME, EXN_PARENT(MZEXN_I_O_FILESYSTEM_PATH), "exn:i/o:filesystem:path:username", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_FILE, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:file", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_DIRECTORY, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:directory", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_COLLECTION, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:collection", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_FILESYSTEM_FILE_EXISTS, EXN_PARENT(MZEXN_I_O_FILESYSTEM), "exn:i/o:filesystem:file-exists", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_PORT_CLOSED, EXN_PARENT(MZEXN_I_O), "exn:i/o:port-closed", 1, MZEXN_I_O_PORT_CLOSED_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_USER_PORT, EXN_PARENT(MZEXN_I_O), "exn:i/o:user-port", 1, MZEXN_I_O_USER_PORT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP, EXN_PARENT(MZEXN_I_O), "exn:i/o:tcp", 0, NULL)
+  SETUP_STRUCT(MZEXN_I_O_TCP_CONNECT, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:connect", 2, MZEXN_I_O_TCP_CONNECT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_LISTEN, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:listen", 1, MZEXN_I_O_TCP_LISTEN_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_ACCEPT, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:accept", 1, MZEXN_I_O_TCP_ACCEPT_FIELDS)
+  SETUP_STRUCT(MZEXN_I_O_TCP_LISTENER_CLOSED, EXN_PARENT(MZEXN_I_O_TCP), "exn:i/o:tcp:listener-closed", 1, MZEXN_I_O_TCP_LISTENER_CLOSED_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC, EXN_PARENT(MZEXN), "exn:misc", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_UNSUPPORTED, EXN_PARENT(MZEXN_MISC), "exn:misc:unsupported", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_USER_BREAK, EXN_PARENT(MZEXN_MISC), "exn:misc:user-break", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_OUT_OF_MEMORY, EXN_PARENT(MZEXN_MISC), "exn:misc:out-of-memory", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_PARAMETERIZATION, EXN_PARENT(MZEXN_MISC), "exn:misc:parameterization", 1, MZEXN_MISC_PARAMETERIZATION_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_DEFMACRO, EXN_PARENT(MZEXN_MISC), "exn:misc:defmacro", 1, MZEXN_MISC_DEFMACRO_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_EXPANSION_TIME, EXN_PARENT(MZEXN_MISC), "exn:misc:expansion-time", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_CONSTANT, EXN_PARENT(MZEXN_MISC), "exn:misc:constant", 1, MZEXN_MISC_CONSTANT_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_CONTINUATION, EXN_PARENT(MZEXN_MISC), "exn:misc:continuation", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_THREAD, EXN_PARENT(MZEXN_MISC), "exn:misc:thread", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_THREAD_KILL, EXN_PARENT(MZEXN_MISC_THREAD), "exn:misc:thread:kill", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_SEMAPHORE, EXN_PARENT(MZEXN_MISC), "exn:misc:semaphore", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_HASH_TABLE, EXN_PARENT(MZEXN_MISC), "exn:misc:hash-table", 1, MZEXN_MISC_HASH_TABLE_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_REGEXP, EXN_PARENT(MZEXN_MISC), "exn:misc:regexp", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_PROCESS, EXN_PARENT(MZEXN_MISC), "exn:misc:process", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION, EXN_PARENT(MZEXN_MISC), "exn:misc:dynamic-extension", 1, MZEXN_MISC_DYNAMIC_EXTENSION_FIELDS)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_OPEN, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:open", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_VERSION, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:version", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_DYNAMIC_EXTENSION_INITIALIZE, EXN_PARENT(MZEXN_MISC_DYNAMIC_EXTENSION), "exn:misc:dynamic-extension:initialize", 0, NULL)
+  SETUP_STRUCT(MZEXN_MISC_IMAGE, EXN_PARENT(MZEXN_MISC), "exn:misc:image", 1, MZEXN_MISC_IMAGE_FIELDS)
+
+#endif
diff --git a/src/mzscheme/src/schfd.h b/src/mzscheme/src/schfd.h
new file mode 100644
index 0000000..b2e3360
--- /dev/null
+++ b/src/mzscheme/src/schfd.h
@@ -0,0 +1,15 @@
+
+#if defined(DETECT_WIN32_CONSOLE_STDIN) || defined(WINDOWS_PROCESSES)
+#define USE_FAR_MZ_FDINIT
+#endif
+#ifdef USE_DYNAMIC_FDSET_SIZE
+#define USE_FAR_MZ_FDINIT
+#endif
+
+#if defined(USE_FAR_MZ_FDCALLS) || defined(USE_FAR_MZ_FDINIT)
+#define DECL_FDSET(n, c) static fd_set *n
+#define INIT_DECL_FDSET(n, c) (n = (n ? (fd_set *)scheme_init_fdset_array(n, c) : (fd_set *)scheme_alloc_fdset_array(c, 1)))
+#else
+#define DECL_FDSET(n, c) fd_set n[c]
+#define INIT_DECL_FDSET(n, c) /* empty */
+#endif
diff --git a/src/mzscheme/src/schgc.h b/src/mzscheme/src/schgc.h
new file mode 100644
index 0000000..f57dac3
--- /dev/null
+++ b/src/mzscheme/src/schgc.h
@@ -0,0 +1,14 @@
+
+#ifdef INCLUDE_WITHOUT_PATHS
+# ifdef USE_SENORA_GC
+#  include "sgc.h"
+# else
+#  include "gc.h"
+# endif
+#else
+# ifdef USE_SENORA_GC
+#  include "../sgc/sgc.h"
+# else
+#  include "../gc/gc.h"
+# endif
+#endif
diff --git a/src/mzscheme/src/schmach.h b/src/mzscheme/src/schmach.h
new file mode 100644
index 0000000..6e0de6a
--- /dev/null
+++ b/src/mzscheme/src/schmach.h
@@ -0,0 +1,48 @@
+/* Sparc fix borrowed from SCM, so here's the copyright:  */
+/* Scheme implementation intended for JACAL.
+   Copyright (C) 1990, 1991, 1992, 1993, 1994 Aubrey Jaffer. */
+/* James Clark came up with this neat one instruction fix for
+   continuations on the SPARC.  It flushes the register windows so
+   that all the state of the process is contained in the stack. */
+#ifdef sparc
+#define FLUSH_REGISTER_WINDOWS asm("ta 3")
+#else
+#define FLUSH_REGISTER_WINDOWS /* empty */
+#endif
+
+/* If stack is not longword aligned then */
+
+/* #define SHORT_ALIGN */
+#ifdef THINK_C
+#define SHORT_ALIGN
+#endif
+#ifdef MSDOS
+#define SHORT_ALIGN
+#endif
+#ifdef atarist
+#define SHORT_ALIGN
+#endif
+
+/* If stacks grow up then */
+
+#if !defined(STACK_GROWS_UP) && !defined(STACK_GROWS_DOWN)
+#define STACK_GROWS_UNKNOWN
+#endif
+
+#ifdef STACK_GROWS_UP
+#define STK_COMP(a,b) ((a) > (b))
+#else
+#ifdef STACK_GROWS_DOWN
+#define STK_COMP(a,b) ((a) < (b))
+#else
+#define STK_COMP(a,b) (scheme_stack_grows_up == ((a) > (b)))
+#endif
+#endif
+
+#ifdef SHORT_ALIGN
+typedef short stack_val;
+#else
+typedef long stack_val;
+#endif
+
+extern int scheme_stack_grows_up;
diff --git a/src/mzscheme/src/schminc.h b/src/mzscheme/src/schminc.h
new file mode 100644
index 0000000..f61ed07
--- /dev/null
+++ b/src/mzscheme/src/schminc.h
@@ -0,0 +1,12 @@
+
+#define USE_COMPILED_MACROS 1
+
+#if defined(__MWERKS__) && !defined(powerc)
+#define MZCOMPILED_STRING_FAR far
+#else
+#define MZCOMPILED_STRING_FAR /**/
+#endif
+
+#if USE_COMPILED_MACROS
+extern Scheme_Object *scheme_eval_compiled_sized_string(const char *str, int len, Scheme_Env *env);
+#endif
diff --git a/src/mzscheme/src/schpriv.h b/src/mzscheme/src/schpriv.h
new file mode 100644
index 0000000..5cd47e4
--- /dev/null
+++ b/src/mzscheme/src/schpriv.h
@@ -0,0 +1,1025 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+  All rights reserved.
+
+  Please see the full copyright in the documentation.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+/* 
+   MzScheme prototypes for private functions.
+   (The prototypes are in an effectively random order.)
+*/
+
+#ifndef __mzscheme_private__
+#define __mzscheme_private__
+
+#include "scheme.h"
+
+#define GLOB_IS_CONST 1
+#define GLOB_IS_KEYWORD 2
+#define GLOB_IS_PRIMITIVE 4
+#define GLOB_IS_PERMANENT 8
+#define GLOB_HAS_REF_ID 16
+
+typedef struct {
+  Scheme_Bucket bucket;
+  short flags;
+} Scheme_Bucket_With_Const_Flag;
+
+typedef struct {
+  Scheme_Bucket_With_Const_Flag flagged;
+  short id;
+} Scheme_Bucket_With_Ref_Id;
+
+typedef struct Scheme_Basic_Env 
+{
+  short num_bindings;
+  short flags; /* used for expanding/compiling */
+  Scheme_Env *genv;
+  struct Scheme_Comp_Env *next;
+} Scheme_Basic_Env;
+
+typedef struct Scheme_Comp_Env
+{
+  struct Scheme_Basic_Env basic;
+  struct Scheme_Object **values;
+} Scheme_Comp_Env;
+
+
+#define CLOS_HAS_REST 1
+#define CLOS_MUST_ALLOC 2
+#define CLOS_ONLY_LOCALS 4
+#define CLOS_FOLDABLE 8
+
+typedef struct Scheme_Compile_Info
+{
+  int max_let_depth;
+  char can_optimize_constants;
+  char globals_must_be_primitive;
+  char keep_unit_debug_info;
+  char dont_mark_local_use;
+  Scheme_Object *value_name;
+} Scheme_Compile_Info;
+
+typedef struct Link_Info
+{
+  int can_optimize_constants;
+  int size, oldsize, count, pos, anchor_offset;
+  short *old_pos;
+  short *new_pos;
+  int *flags;
+  struct Link_Info *next;
+} Link_Info;
+
+typedef struct Scheme_Object *
+(Scheme_Syntax)(struct Scheme_Object *form, struct Scheme_Comp_Env *env,
+		struct Scheme_Compile_Info *rec);
+
+typedef struct Scheme_Object *
+(Scheme_Syntax_Expander)(struct Scheme_Object *form, struct Scheme_Comp_Env *env,
+			 int depth);
+
+typedef struct Scheme_Object *
+(Scheme_Syntax_Linker)(Scheme_Object *data, Link_Info *link);
+
+typedef struct Scheme_Object *
+(Scheme_Syntax_Executer)(struct Scheme_Object *data);
+
+typedef Scheme_Syntax_Executer Scheme_Syntax_Registered;
+
+typedef struct Scheme_Closure_Compilation_Data
+{
+  Scheme_Type type;
+  /* Scheme_Object *src; */
+  short flags;
+  short num_params; /* includes collecting arg if has_rest */
+  short max_let_depth;
+  short closure_size;
+  short *closure_map;
+  Scheme_Object *code;
+  Scheme_Object *name;
+} Scheme_Closure_Compilation_Data;
+
+typedef struct {
+  Scheme_Type type;
+  Scheme_Object *code;
+  Scheme_Object *vals[1];
+} Scheme_Closed_Compiled_Procedure;
+
+#define SCHEME_COMPILED_CLOS_CODE(c) ((Scheme_Closed_Compiled_Procedure *)c)->code
+#define SCHEME_COMPILED_CLOS_ENV(c) ((Scheme_Closed_Compiled_Procedure *)c)->vals
+
+typedef struct Scheme_Struct_Type {
+  Scheme_Type type;
+  short num_slots;
+  short name_pos;
+  Scheme_Object *type_name;
+  struct Scheme_Struct_Type *parent_types[1];
+} Scheme_Struct_Type;
+
+typedef struct Scheme_Structure
+{
+  Scheme_Type type;
+  Scheme_Struct_Type *stype;
+  Scheme_Object *slots[1];
+} Scheme_Structure;
+
+#define SCHEME_STRUCT_TYPE(o) (((Scheme_Structure *)o)->stype)
+
+#define SCHEME_STRUCT_NUM_SLOTS(o) (SCHEME_STRUCT_TYPE(o)->num_slots)
+#define SCHEME_STRUCT_NAME_SYM(o) (SCHEME_STRUCT_TYPE(o)->type_name)
+
+typedef struct {
+  Scheme_Type type;
+  short num_args;
+  Scheme_Object *args[1];
+  /* After array of f & args, array of chars for eval type */
+} Scheme_App_Rec;
+
+typedef struct {
+  Scheme_Type type;
+  Scheme_Object *test;
+  Scheme_Object *tbranch;
+  Scheme_Object *fbranch;
+} Scheme_Branch_Rec;
+
+typedef struct {
+  Scheme_Type type;
+  short max_let_depth;
+  Scheme_Object *code;
+} Scheme_Compilation_Top;
+
+extern int scheme_starting_up;
+
+
+typedef struct Scheme_Compiled_Let_Value {
+  Scheme_Type type;
+  short count;
+  short position;
+  int *flags;
+  Scheme_Object *value;
+  Scheme_Object *body;
+} Scheme_Compiled_Let_Value;
+
+typedef struct Scheme_Let_Header {
+  Scheme_Type type;
+  short count;
+  short recursive;
+  short num_clauses;
+  Scheme_Object *body;
+} Scheme_Let_Header;
+
+
+/* ininitializarion */
+void scheme_init_stack_check(void);
+Scheme_Process *scheme_make_process();
+Scheme_Env *scheme_top_level_env(void);
+void scheme_init_true_false(void);
+void scheme_init_type_symbol_table(void);
+void scheme_init_symbol_table (void);
+void scheme_init_symbol_type (Scheme_Env *env);
+void scheme_init_type (Scheme_Env *env);
+void scheme_init_list (Scheme_Env *env);
+void scheme_init_port (Scheme_Env *env);
+void scheme_init_file (Scheme_Env *env);
+void scheme_init_proc (Scheme_Env *env);
+void scheme_init_vector (Scheme_Env *env);
+void scheme_init_string (Scheme_Env *env);
+void scheme_init_number (Scheme_Env *env);
+void scheme_init_eval (Scheme_Env *env);
+void scheme_init_promise (Scheme_Env *env);
+void scheme_init_struct (Scheme_Env *env);
+void scheme_init_fun(Scheme_Env *env);
+void scheme_init_symbol(Scheme_Env *env);
+void scheme_init_type_symbol(Scheme_Env *env);
+void scheme_init_char(Scheme_Env *env);
+void scheme_init_bool(Scheme_Env *env);
+void scheme_init_syntax(Scheme_Env *env);
+void scheme_init_error(Scheme_Env *env);
+void scheme_init_exn(Scheme_Env *env);
+void scheme_init_debug(Scheme_Env *env);
+#ifndef NO_OBJECT_SYSTEM
+void scheme_init_object(Scheme_Env *env);
+#endif
+void scheme_init_unit(Scheme_Env *env);
+void scheme_init_process(Scheme_Env *env);
+void scheme_init_read(Scheme_Env *env);
+void scheme_init_print(Scheme_Env *env);
+void scheme_init_image(Scheme_Env *env);
+#ifndef NO_SCHEME_THREADS
+void scheme_init_sema(Scheme_Env *env);
+#endif
+void scheme_init_dynamic_extension(Scheme_Env *env);
+#ifndef NO_REGEXP_UTILS
+extern void scheme_regexp_initialize(Scheme_Env *env);
+#endif
+void scheme_init_empty_cond(Scheme_Env *env);
+void scheme_init_format_procedure(Scheme_Env *env);
+void scheme_init_rep(Scheme_Env *env);
+
+extern Scheme_Type_Reader *scheme_type_readers;
+extern Scheme_Type_Writer *scheme_type_writers;
+
+Scheme_Object *scheme_find_linker_name(Scheme_Syntax_Registered *f);
+Scheme_Syntax_Registered *scheme_find_linker(Scheme_Object *sym);
+
+extern Scheme_Object *scheme_void_func;
+
+#ifndef MZ_REAL_THREADS
+extern int scheme_fuel_counter;
+#endif
+
+void scheme_out_of_fuel(void);
+#define SCHEME_USE_FUEL(n) { \
+  if ((scheme_fuel_counter -= (n)) <= 0) { scheme_out_of_fuel(); }}
+
+Scheme_Object *scheme_handle_stack_overflow(Scheme_Object *(*k)(void));
+
+Scheme_Object *scheme_read_number(const char *str, long len,
+				  int is_float, 
+				  int is_not_float,
+				  int radix, int radix_set, 
+				  Scheme_Object *port,
+				  int *div_by_zero);
+
+typedef long bigdig;
+
+typedef struct {
+  Scheme_Type type;
+  short pos;
+  int len;
+  bigdig *digits;
+} Scheme_Bignum;
+
+#define SCHEME_BIGPOS(b) (((Scheme_Bignum *)b)->pos)
+#define SCHEME_BIGLEN(b) (((Scheme_Bignum *)b)->len)
+#define SCHEME_BIGDIG(b) (((Scheme_Bignum *)b)->digits)
+
+typedef struct {
+  Scheme_Bignum o;
+  bigdig v[1];
+} Small_Bignum;
+  
+typedef struct {
+  Scheme_Type type;
+  Scheme_Object *num;
+  Scheme_Object *denom;
+} Scheme_Rational;
+
+typedef Scheme_Rational Small_Rational;
+
+typedef struct {
+  Scheme_Type type;
+  Scheme_Object *r;
+  Scheme_Object *i;
+} Scheme_Complex;
+
+typedef Scheme_Complex Small_Complex;
+
+Scheme_Object *scheme_make_small_bignum(long v, Small_Bignum *s);
+char *scheme_number_to_string(int radix, Scheme_Object *obj);
+
+Scheme_Object *_scheme_apply_to_list (Scheme_Object *rator, Scheme_Object *rands);
+Scheme_Object *_scheme_tail_apply_to_list (Scheme_Object *rator, Scheme_Object *rands);
+
+void scheme_ensure_stack_start(Scheme_Process *p, void *d);
+
+void *scheme_top_level_do(void *(*k)(void));
+#define scheme_top_level_do_w_process(k, p) scheme_top_level_do(k)
+
+typedef struct Scheme_Stack_State {
+  Scheme_Object **runstack;
+  Scheme_Object **runstack_start;
+  Scheme_Saved_Stack *runstack_saved;
+  long runstack_size;
+} Scheme_Stack_State;
+
+typedef struct Scheme_Dynamic_Wind {
+  void *data;
+  void (*pre)(void *);
+  void (*post)(void *);
+  jmp_buf saveerr;
+  Scheme_Comp_Env *current_local_env;
+  struct Scheme_Stack_State envss;
+  struct Scheme_Cont *cont;
+  struct Scheme_Dynamic_Wind *prev;
+} Scheme_Dynamic_Wind;
+
+
+
+typedef struct Scheme_Cont {
+  Scheme_Type type;
+  Scheme_Object *value;
+  Scheme_Jumpup_Buf buf;
+  long *ok;
+  Scheme_Dynamic_Wind *dw, *common;
+  Scheme_Process *home;
+#ifdef ERROR_ON_OVERFLOW
+  int orig_overflow;
+#else
+  jmp_buf save_overflow_buf;
+#endif
+  Scheme_Stack_State ss;
+  Scheme_Saved_Stack *runstack_copied;
+  struct Scheme_Overflow *save_overflow;
+  Scheme_Comp_Env *current_local_env;
+  jmp_buf savebuf; /* save old error buffer here */
+} Scheme_Cont;
+
+typedef struct Scheme_Escaping_Cont {
+  Scheme_Type type;
+  short num_vals;
+  Scheme_Process *home;
+  union {
+    Scheme_Object **vals;
+    Scheme_Object *val;
+  } u;
+#ifdef ERROR_ON_OVERFLOW
+  int orig_overflow;
+#endif
+} Scheme_Escaping_Cont;
+
+#define SCHEME_CONT_HOME(obj)  (((Scheme_Escaping_Cont *)(obj))->home)
+#define SCHEME_CONT_VAL(obj)  (((Scheme_Escaping_Cont *)(obj))->u.val)
+#define SCHEME_CONT_VALS(obj)  (((Scheme_Escaping_Cont *)(obj))->u.vals)
+#define SCHEME_CONT_NUM_VALS(obj)  (((Scheme_Escaping_Cont *)(obj))->num_vals)
+
+#define _scheme_do_eval(obj, env, v) \
+  ((SCHEME_INTP(obj) || !SCHEME_STRTAG_VAL(_SCHEME_TYPE(obj))) \
+   ? obj : scheme_do_eval(obj, -1, env, v))
+#define q_scheme_eval_compiled(obj) _scheme_do_eval(obj, 1)
+#define q_scheme_tail_eval(obj) scheme_tail_eval(obj)
+
+typedef struct Scheme_Sema_Callback {
+  Scheme_Sema *sema;
+  int ready;
+  Scheme_Object *callback;
+  void *context;
+  struct Scheme_Sema_Callback *next;
+} Scheme_Sema_Callback;
+
+typedef struct Scheme_Sema_From_Port {
+  Scheme_Sema *sema;
+  Scheme_Object *port;
+  struct Scheme_Sema_From_Port *next;
+} Scheme_Sema_From_Port;
+
+typedef struct Scheme_Local {
+  Scheme_Type type;
+  short position;
+} Scheme_Local;
+
+typedef struct Scheme_Let_Value {
+  Scheme_Type type;
+  short count;
+  short position;
+  short autobox;
+  Scheme_Object *value;
+  Scheme_Object *body;
+} Scheme_Let_Value;
+
+typedef struct Scheme_Let_One {
+  Scheme_Type type;
+  short eval_type;
+  Scheme_Object *value;
+  Scheme_Object *body;
+} Scheme_Let_One;
+
+typedef struct Scheme_Let_Void {
+  Scheme_Type type;
+  short count;
+  short autobox;
+  Scheme_Object *body;
+} Scheme_Let_Void;
+
+typedef struct Scheme_Letrec {
+  Scheme_Type type;
+  short count;
+  Scheme_Object **procs;
+  Scheme_Object *body;
+} Scheme_Letrec;
+
+typedef struct {
+  Scheme_Type type;
+  short num_bindings;
+  Scheme_Object *body;
+} Scheme_Let_Frame_Data;
+
+#define SCHEME_LOCAL_POS(obj)    (((Scheme_Local *)(obj))->position)
+
+extern int scheme_active_but_sleeping;
+
+typedef struct {
+  Scheme_Type type;
+  short count;
+  Scheme_Object *array[1];
+} Scheme_Sequence;
+
+typedef struct {
+  Scheme_Type type;
+  short count;
+  Scheme_Object *name;
+  Scheme_Object *array[1];
+} Scheme_Case_Lambda;
+
+typedef struct Scheme_Promise {
+  Scheme_Type type;
+  char forced;
+  char is_expr;
+  Scheme_Object *val;
+  int multi_count;
+  Scheme_Object **multi_array;
+#ifdef MZ_REAL_THREADS
+  Scheme_Object *sema;
+#endif
+} Scheme_Promise;
+
+void scheme_add_sema_callback(Scheme_Sema_Callback *);
+void scheme_add_sema_from_port(Scheme_Sema_From_Port *);
+
+#define NOT_BLOCKED 0
+#define PIPE_BLOCKED 1
+#define PORT_BLOCKED 2
+#define SEMA_BLOCKED 3
+#define EVENTLOOP_BLOCKED 4
+#define SLEEP_BLOCKED 10
+
+#ifdef DO_STACK_CHECK
+void scheme_init_stack_limit (void);
+#endif
+
+extern Scheme_Object *scheme_not_prim;
+extern Scheme_Object *scheme_define_values_syntax, *scheme_defmacro_syntax;
+extern Scheme_Object *scheme_def_id_macro_syntax;
+extern Scheme_Object *scheme_def_exp_time_syntax;
+extern Scheme_Object *scheme_begin_exp_time_syntax;
+extern Scheme_Object *scheme_lambda_syntax;
+extern Scheme_Object *scheme_begin_syntax;
+
+Scheme_Object *scheme_named_map_1(char *, Scheme_Object *(*fun)(Scheme_Object*, Scheme_Object *form), Scheme_Object *lst, Scheme_Object *form);
+
+extern Scheme_Object *scheme_orig_stdout_port;
+
+int scheme_bignum_eq(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_bignum_lt(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_bignum_gt(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_bignum_le(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_bignum_ge(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_negate(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_add(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_subtract(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_add1(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_sub1(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_multiply(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_max(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_min(const Scheme_Object *a, const Scheme_Object *b);
+void scheme_bignum_divide(const Scheme_Object *n, const Scheme_Object *d,
+			  Scheme_Object **qp, Scheme_Object **rp, int norm);
+Scheme_Object *scheme_bignum_power(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_integer_sqrt(const Scheme_Object *n);
+Scheme_Object *scheme_bignum_and(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_or(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_xor(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_bignum_not(const Scheme_Object *a);
+Scheme_Object *scheme_bignum_shift(const Scheme_Object *a, long shift);
+
+Scheme_Object *scheme_make_small_rational(long n, Small_Rational *space);
+Scheme_Object *scheme_integer_to_rational(const Scheme_Object *n);
+Scheme_Object *scheme_make_fixnum_rational(long n, long d);
+int scheme_rational_eq(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_rational_lt(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_rational_gt(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_rational_le(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_rational_ge(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_negate(const Scheme_Object *n);
+Scheme_Object *scheme_rational_add(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_subtract(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_add1(const Scheme_Object *n);
+Scheme_Object *scheme_rational_sub1(const Scheme_Object *n);
+Scheme_Object *scheme_rational_multiply(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_max(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_min(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_rational_divide(const Scheme_Object *n, const Scheme_Object *d);
+Scheme_Object *scheme_rational_power(const Scheme_Object *a, const Scheme_Object *b);
+int scheme_is_rational_positive(const Scheme_Object *o);
+Scheme_Object *scheme_rational_floor(const Scheme_Object *a);
+Scheme_Object *scheme_rational_truncate(const Scheme_Object *a);
+Scheme_Object *scheme_rational_ceiling(const Scheme_Object *a);
+Scheme_Object *scheme_rational_round(const Scheme_Object *a);
+Scheme_Object *scheme_rational_sqrt(const Scheme_Object *n);
+
+Scheme_Object *scheme_make_small_complex(const Scheme_Object *n, Small_Complex *space);
+Scheme_Object *scheme_real_to_complex(const Scheme_Object *n);
+int scheme_complex_eq(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_complex_negate(const Scheme_Object *n);
+Scheme_Object *scheme_complex_add(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_complex_subtract(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_complex_add1(const Scheme_Object *n);
+Scheme_Object *scheme_complex_sub1(const Scheme_Object *n);
+Scheme_Object *scheme_complex_multiply(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_complex_divide(const Scheme_Object *n, const Scheme_Object *d);
+Scheme_Object *scheme_complex_power(const Scheme_Object *a, const Scheme_Object *b);
+Scheme_Object *scheme_complex_sqrt(const Scheme_Object *a);
+Scheme_Object *scheme_complex_real_part(const Scheme_Object *a);
+Scheme_Object *scheme_complex_imaginary_part(const Scheme_Object *a);
+int scheme_is_complex_exact(const Scheme_Object *o);
+
+/* General numeric: */
+Scheme_Object *scheme_bin_gcd(const Scheme_Object *n1, const Scheme_Object *n2);
+Scheme_Object *scheme_bin_quotient(const Scheme_Object *n1, const Scheme_Object *n2);
+Scheme_Object *scheme_bin_mult(const Scheme_Object *n1, const Scheme_Object *n2);
+Scheme_Object *scheme_bin_div(const Scheme_Object *n1, const Scheme_Object *n2);
+Scheme_Object *scheme_bin_plus(const Scheme_Object *n1, const Scheme_Object *n2);
+Scheme_Object *scheme_bin_minus(const Scheme_Object *n1, const Scheme_Object *n2);
+int scheme_bin_eq(const Scheme_Object *n1, const Scheme_Object *n2);
+int scheme_bin_lt(const Scheme_Object *n1, const Scheme_Object *n2);
+int scheme_bin_gt(const Scheme_Object *n1, const Scheme_Object *n2);
+int scheme_bin_gt_eq(const Scheme_Object *n1, const Scheme_Object *n2);
+int scheme_bin_lt_eq(const Scheme_Object *n1, const Scheme_Object *n2);
+
+Scheme_Object *scheme_sub1(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_add1(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_odd_p(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_expt(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_modulo(int argc, Scheme_Object *argv[]);
+Scheme_Object *scheme_sqrt(int argc, Scheme_Object *argv[]);
+double scheme_get_val_as_double(const Scheme_Object *n);
+
+Scheme_Object *scheme_double_to_integer(const char *where, double d);
+
+Scheme_Object *scheme_generic_power(const Scheme_Object *o, const Scheme_Object *p);
+
+#define scheme_add_good_binding(i,v,f) (f->values[i] = v)
+
+int scheme_equal_structs(Scheme_Object *obj1, Scheme_Object *obj2);
+
+Scheme_Object *scheme_compiled_void(int can_be_value);
+
+int scheme_find_type(Scheme_Object *ts);
+
+#define scheme_save_env_stack_w_process(ss, p) \
+    (ss.runstack = p->runstack, ss.runstack_start = p->runstack_start, \
+     ss.runstack_size = p->runstack_size, ss.runstack_saved = p->runstack_saved)
+#define scheme_restore_env_stack_w_process(ss, p) \
+    (p->runstack = ss.runstack, p->runstack_start = ss.runstack_start, \
+     p->runstack_size = ss.runstack_size, p->runstack_saved = ss.runstack_saved)
+#define scheme_save_env_stack(ss) \
+    scheme_save_env_stack_w_process(ss, scheme_current_process)
+#define scheme_restore_env_stack(ss) \
+    scheme_restore_env_stack_w_process(ss, scheme_current_process)
+
+#ifndef ERROR_ON_OVERFLOW
+typedef struct Scheme_Overflow {
+  Scheme_Jumpup_Buf cont; /* continuation after value obtained in overflowed */
+  struct Scheme_Overflow *prev; /* old overflow info */
+  jmp_buf savebuf; /* save old error buffer here */
+} Scheme_Overflow;
+#endif
+
+void scheme_jmpup_free(Scheme_Jumpup_Buf *);
+
+extern Scheme_Object *scheme_arity_at_least;
+
+int scheme_check_double(const char *where, double v, const char *dest);
+#ifdef MZ_USE_SINGLE_FLOATS
+int scheme_check_float(const char *where, float v, const char *dest);
+#else
+# define scheme_check_float scheme_check_double
+#endif
+
+unsigned long scheme_get_deeper_address(void);
+
+#ifdef DIR_FUNCTION
+void scheme_set_process_directory(Scheme_Process *newp, Scheme_Process *oldp);
+void scheme_done_process_directory(Scheme_Process *p);
+#endif
+
+#if defined(UNIX_FIND_STACK_BOUNDS) || defined(WINDOWS_FIND_STACK_BOUNDS) || defined(ASSUME_FIXED_STACK_SIZE)
+#ifndef MZ_REAL_THREADS
+extern unsigned long scheme_stack_boundary;
+#endif
+#endif
+
+#ifdef MEMORY_COUNTING_ON
+extern Scheme_Hash_Table *scheme_symbol_table;
+extern long scheme_type_table_count;
+extern long scheme_misc_count;
+
+Scheme_Object *scheme_dump_memory_count(int c, Scheme_Object *a[]);
+
+long scheme_count_closure(Scheme_Object **o, short len, Scheme_Hash_Table *ht);
+
+long scheme_count_envbox(Scheme_Object *root, Scheme_Hash_Table *ht);
+long scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht);
+void scheme_count_input_port(Scheme_Object *port, long *s, long *e, Scheme_Hash_Table *ht);
+void scheme_count_output_port(Scheme_Object *port, long *s, long *e, Scheme_Hash_Table *ht);
+
+void scheme_count_struct_info(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+
+#ifndef NO_OBJECT_SYSTEM
+void scheme_count_object(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+void scheme_count_class(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+void scheme_count_class_data(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+void scheme_count_generic(Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+#endif
+void scheme_count_unit(Scheme_Type type, Scheme_Object *o, long *s, long *e, Scheme_Hash_Table *ht);
+#endif
+
+void scheme_init_error_escape_proc(Scheme_Process *p);
+
+int scheme_used_app_only(Scheme_Comp_Env *env, int which);
+int scheme_used_ever(Scheme_Comp_Env *env, int which);
+char *scheme_expand_filename(char* filename, int ilen, char *errorin, int *ex);
+
+int scheme_omittable_expr(Scheme_Object *o);
+
+#ifndef MZ_REAL_THREADS
+Scheme_Object *scheme_internal_read(Scheme_Object *port, int crc, Scheme_Config *);
+#else
+Scheme_Object *scheme_internal_read(Scheme_Object *port, int crc, Scheme_Config *, Scheme_Process *p);
+#endif
+void scheme_internal_display(Scheme_Object *obj, Scheme_Object *port, Scheme_Config *);
+void scheme_internal_write(Scheme_Object *obj, Scheme_Object *port, Scheme_Config *);
+
+Scheme_Object *scheme_make_arity(short minc, short maxc);
+Scheme_Object *scheme_arity(Scheme_Object *p);
+
+Scheme_Object *scheme_apply_macro_to_list(Scheme_Object *f, Scheme_Object *argss,
+					  Scheme_Object *code);
+
+void scheme_wrong_syntax(const char *where, 
+			 Scheme_Object *local_form, 
+			 Scheme_Object *form, 
+			 const char *detail, ...);
+void scheme_wrong_rator(Scheme_Object *rator, int argc, Scheme_Object **argv);
+
+void scheme_raise_else(const char *where, Scheme_Object *v);
+void scheme_raise_out_of_memory(const char *where, const char *msg, ...);
+
+extern long scheme_max_found_symbol_name;
+
+Scheme_Object *scheme_compile_expand_macro_app(Scheme_Object *macro,
+					       Scheme_Object *form, Scheme_Comp_Env *env,
+					       Scheme_Compile_Info *rec, int depth);
+
+void scheme_secure_leftover_exceptions(Scheme_Env *);
+
+#define _scheme_make_char(ch) (scheme_char_constants[(unsigned char)(ch)])
+
+#ifdef TIME_SYNTAX
+extern Scheme_Object *scheme_date;
+#endif
+
+typedef struct {
+  Scheme_Object **scheck_hash;
+  long scheck_size, scheck_count, scheck_step;
+} DupCheckRecord;
+
+DupCheckRecord *scheme_begin_dup_symbol_check(DupCheckRecord *r);
+void scheme_dup_symbol_check(DupCheckRecord *r, char *where,
+			     Scheme_Object *symbol, char *what, 
+			     Scheme_Object *form, int inverted);
+
+void scheme_unsettable_variable(Scheme_Comp_Env *env, int which);
+
+Scheme_Object *scheme_hash_percent_name(const char *name, int len);
+
+Scheme_Object *scheme_make_branch(Scheme_Object *test,
+				  Scheme_Object *tbranch,
+				  Scheme_Object *fbranch);
+
+#ifdef MZ_REAL_THREADS
+#define MZTHREADELEM(p, x) p->x
+#else
+#define MZTHREADELEM(p, x) scheme_ ## x
+#endif
+
+extern Scheme_Process *scheme_main_process;
+
+extern Scheme_Object *scheme_null_break_poll;
+
+
+#ifndef MZ_REAL_THREADS
+#define SCHEME_GET_LOCK() /* empty */
+#define SCHEME_RELEASE_LOCK() /* empty */
+#else
+#define SCHEME_SEMA_DOWN(sema) scheme_real_sema_down(sema)
+void scheme_real_sema_down(void *sema);
+
+extern void *scheme_global_lock;
+#define SCHEME_GET_LOCK() SCHEME_LOCK_MUTEX(scheme_global_lock)
+#define SCHEME_RELEASE_LOCK()  SCHEME_UNLOCK_MUTEX(scheme_global_lock)
+#endif
+
+#ifdef MUST_REGISTER_GLOBALS
+void scheme_register_bignum();
+
+#define REGISTER_SO(x)  scheme_register_extension_global((void *)&x, sizeof(x));
+#else
+#define REGISTER_SO(x) 
+#endif
+
+int scheme_is_regular_file(char *filename);
+
+extern int scheme_builtin_ref_counter;
+
+Scheme_Object **scheme_make_builtin_references_table(void);
+Scheme_Object *scheme_make_local(short type, int pos);
+
+#define MAX_CONST_LOCAL_POS 20
+
+extern Scheme_Object *scheme_local[MAX_CONST_LOCAL_POS][2];
+
+#define MAKE_CLOSED_PRIM(f,v,n,mi,ma) \
+  scheme_make_closed_prim_w_arity((Scheme_Closed_Prim *)f, (void *)v, n, mi, ma)
+
+#define _MALLOC_N(x, n, malloc) ((x*)malloc(sizeof(x)*(n)))
+#define MALLOC_ONE(x) _MALLOC_N(x, 1, scheme_malloc)
+#define MALLOC_ONE_TAGGED(x) _MALLOC_N(x, 1, scheme_malloc_tagged)
+#define MALLOC_N(x, n) _MALLOC_N(x, n, scheme_malloc)
+#define MALLOC_ONE_ATOMIC(x) _MALLOC_N(x, 1, scheme_malloc_atomic)
+#define MALLOC_N_ATOMIC(x, n) _MALLOC_N(x, n, scheme_malloc_atomic)
+#define MALLOC_SO_BOX() _MALLOC_ONE(Scheme_Object*, scheme_malloc)
+
+#define CONFIG_DEFAULTING(c, f) (c->base && (c->base->f == c->f))
+
+extern int scheme_no_reference_id;
+
+#ifdef MAC_FILE_SYSTEM
+void scheme_file_create_hook(char *filename);
+#endif
+
+int scheme_bignum_get_int_val(const Scheme_Object *o, long *v);
+int scheme_bignum_get_unsigned_int_val(const Scheme_Object *o, unsigned long *v);
+
+Scheme_Object *scheme_check_immediate_macro(Scheme_Object *first, 
+					    Scheme_Comp_Env *env, 
+					    Scheme_Compile_Info *rec, 
+					    int depth,
+					    Scheme_Object **current_val);
+
+#if defined(USE_UNIX_SOCKETS_TCP) || defined(USE_WINSOCK_TCP) || defined(USE_MAC_TCP)
+#define USE_TCP
+#endif
+
+#ifndef USE_IEEE_FP_PREDS
+extern double scheme_infinity_val, scheme_minus_infinity_val;
+# define MZ_IS_POS_INFINITY(d) ((d) == scheme_infinity_val)
+# define MZ_IS_NEG_INFINITY(d) ((d) == scheme_minus_infinity_val)
+# ifdef NAN_EQUALS_ANYTHING
+#  define MZ_IS_NAN(d) (((d) == 1.0) && ((d) == 2.0))
+# else
+#  define MZ_IS_NAN(d) (!((d) == (d)))
+# endif
+#else
+# define MZ_IS_POS_INFINITY(d) (isinf(d) && (d > 0))
+# define MZ_IS_NEG_INFINITY(d) (isinf(d) && (d < 0))
+# define MZ_IS_NAN(d) isnan(d)
+#endif
+
+double scheme_bignum_to_double_inf_info(const Scheme_Object *n, int just_use, int *only_need);
+#ifdef MZ_USE_SINGLE_FLOATS
+float scheme_bignum_to_float_inf_info(const Scheme_Object *n, int just_use, int *only_need);
+#else
+# define scheme_bignum_to_float_inf_info scheme_bignum_to_double_inf_info
+#endif
+
+void scheme_zero_unneeded_rands(Scheme_Process *p);
+
+#define IMPROPER_LIST_FORM "illegal use of `.'"
+
+extern long scheme_total_gc_time;
+
+Scheme_Object *
+scheme_make_prim_w_everything(Scheme_Prim *fun, int eternal,
+			      const char *name,
+			      short mina, short maxa,
+			      short folding,
+			      short minr, short maxr);
+Scheme_Object *
+scheme_make_closed_prim_w_everything(Scheme_Closed_Prim *fun, 
+				     void *data,
+				     const char *name, 
+				     short mina, short maxa,
+				     short folding,
+				     short minr, short maxr);
+
+#define scheme_make_prim_w_arity2(f, n, mina, maxa, minr, maxr) \
+  scheme_make_prim_w_everything(f, 0, n, mina, maxa, 0, minr, maxr)
+
+int scheme_can_break(Scheme_Process *p, Scheme_Config *config);
+
+int scheme_is_env_variable_boxed(Scheme_Comp_Env *env, int which);
+
+Scheme_Object *scheme_bangboxenv_execute(Scheme_Object *data);
+
+
+void scheme_check_identifier(const char *formname, Scheme_Object *id, 
+			     const char *where,
+			     Scheme_Comp_Env *env,
+			     Scheme_Object *form);
+
+
+Scheme_Comp_Env *scheme_new_compilation_frame(int num_bindings, int flags, Scheme_Comp_Env *env);
+void scheme_add_compilation_binding(int index, Scheme_Object *val, 
+				    Scheme_Comp_Env *frame);
+Scheme_Comp_Env *scheme_add_compilation_frame(Scheme_Object *vals, 
+					 Scheme_Comp_Env *env, int flags);
+
+Scheme_Object *scheme_static_distance(Scheme_Object *symbol, Scheme_Comp_Env *env,
+				      int flags);
+
+void scheme_push_constant(Scheme_Object *name, Scheme_Object *val,
+			  Scheme_Comp_Env *env);
+void scheme_pop_constant(Scheme_Comp_Env *env);
+
+void scheme_env_make_closure_map(Scheme_Comp_Env *frame, short *size, short **map);
+
+Scheme_Object *scheme_make_linked_closure(Scheme_Process *p, 
+					  Scheme_Object *compiled_code,
+					  int close);
+
+/* Linking */
+void scheme_register_syntax(const char *name, Scheme_Syntax_Registered *f);
+
+Scheme_Object *scheme_make_syntax_link(Scheme_Syntax_Executer *prim,
+				       Scheme_Object *data);
+Scheme_Object *scheme_make_syntax_compile(Scheme_Syntax_Linker *prim,
+					  Scheme_Object *data);
+
+Scheme_Object *scheme_link_expr(Scheme_Object *, Link_Info *);
+Scheme_Object *scheme_link_list(Scheme_Object *, Link_Info *);
+
+int scheme_is_compiled_procedure(Scheme_Object *o, int can_be_closed);
+
+Scheme_Object *scheme_link_lets(Scheme_Object *form, Link_Info *info);
+
+Link_Info *scheme_link_info_create(int can_opt);
+Link_Info *scheme_link_info_extend(Link_Info *info, int size, int oldsize, int mapcount);
+void scheme_link_info_add_mapping(Link_Info *info, int oldp, int newp, int flags);
+void scheme_link_info_set_anchor_offset(Link_Info *info, int offset);
+int scheme_link_info_flags(Link_Info *info, int pos);
+int scheme_link_info_lookup(Link_Info *link, int pos, int *flags);
+int scheme_link_info_lookup_anchor(Link_Info *info, int pos);
+
+Scheme_Object *scheme_make_compiled_syntax(Scheme_Syntax *syntax,
+					   Scheme_Syntax_Expander *exp);
+
+Scheme_Object *scheme_compile_expr(Scheme_Object *form, Scheme_Comp_Env *env,
+				   Scheme_Compile_Info *rec);
+Scheme_Object *scheme_compile_sequence(Scheme_Object *forms, Scheme_Comp_Env *env,
+			      Scheme_Compile_Info *rec);
+Scheme_Object *scheme_compile_block(Scheme_Object *forms, Scheme_Comp_Env *env,
+			      Scheme_Compile_Info *rec);
+Scheme_Object *scheme_compile_list(Scheme_Object *form, Scheme_Comp_Env *env,
+			      Scheme_Compile_Info *rec);
+
+void scheme_default_compile_rec(Scheme_Compile_Info *src);
+void scheme_compile_rec_done_local(Scheme_Compile_Info *src);
+void scheme_init_compile_recs(Scheme_Compile_Info *src, 
+			      Scheme_Compile_Info *dest, int n);
+void scheme_merge_compile_recs(Scheme_Compile_Info *src, 
+			       Scheme_Compile_Info *dest, int n);
+void scheme_init_lambda_rec(Scheme_Compile_Info *src,
+			    Scheme_Compile_Info *lam);
+void scheme_merge_lambda_rec(Scheme_Compile_Info *src,
+			    Scheme_Compile_Info *lam);
+
+
+Scheme_Object *scheme_make_closure_compilation(Scheme_Comp_Env *env,
+					       Scheme_Object *uncompiled_code,
+					       Scheme_Compile_Info *rec);
+Scheme_Object *scheme_make_sequence_compilation(Scheme_Object *compiled_list,
+						int to_linked, int strip_values);
+
+
+Scheme_Object *scheme_link_closure_compilation(Scheme_Object *_data, Link_Info *info);
+
+#define SCHEME_SYNTAX(obj)   ((obj)->u.two_ptr_val.ptr1)
+#define SCHEME_SYNTAX_EXP(obj)   ((obj)->u.two_ptr_val.ptr2)
+
+int *scheme_env_get_flags(Scheme_Comp_Env *frame, int start, int count);
+
+
+/* flags reported by scheme_env_get_fags */
+#define SCHEME_WAS_USED 1
+#define SCHEME_WAS_SET_BANGED 2
+
+/* flags reported by scheme_link_info_flags */
+#define SCHEME_INFO_BOXED 1
+#define SCHEME_INFO_ANCHORED 2
+
+/* flags used with scheme_new_frame */
+#define SCHEME_AUTO_UNBOX 1
+#define SCHEME_COMPILE_PTR 2
+#define SCHEME_LAMBDA_FRAME 8
+#define SCHEME_LET_FRAME 16
+#define SCHEME_ANCHORED_FRAME 32
+#define SCHEME_TOPLEVEL_FRAME 64
+
+/* Flags used with scheme_static_distance */
+#define SCHEME_ELIM_CONST 1
+#define SCHEME_APP_POS 2
+#define SCHEME_SETTING 4
+#define SCHEME_ENV_CONSTANTS_OK 8
+#define SCHEME_GLOB_ALWAYS_REFERENCE 16
+#define SCHEME_MUST_INDRECT 32
+#define SCHEME_LINKING_REF 64
+#define SCHEME_DONT_MARK_USE 128
+
+
+Scheme_Env *scheme_min_env(Scheme_Comp_Env *);
+
+void *scheme_enlarge_runstack(long size, void *(*k)());
+int scheme_check_runstack(long size);
+
+Scheme_Object *scheme_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env,
+				  int depth);
+Scheme_Object *scheme_expand_list(Scheme_Object *form, Scheme_Comp_Env *env,
+				  int depth);
+Scheme_Object *scheme_expand_block(Scheme_Object *form, Scheme_Comp_Env *env,
+				   int depth);
+
+Scheme_Object *scheme_make_svector(short v, short *a);
+
+#define SCHEME_SVEC_LEN(obj) ((obj)->u.svector_val.len)
+#define SCHEME_SVEC_VEC(obj) ((obj)->u.svector_val.vec)
+
+Scheme_Object *scheme_dump_gc_stats(int c, Scheme_Object *p[]);
+
+#define _scheme_eval_compiled_expr(obj) scheme_do_eval(obj,-1,NULL,1)
+#define _scheme_eval_compiled_expr_multi(obj) scheme_do_eval(obj,-1,NULL,-1)
+#define _scheme_eval_compiled_expr_wp(obj, p) scheme_do_eval_w_process(obj,-1,NULL,1,p)
+#define _scheme_eval_compiled_expr_multi_wp(obj, p) scheme_do_eval_w_process(obj,-1,NULL,-1,p)
+
+char *scheme_make_args_string(char *s, int which, int argc, Scheme_Object **argv);
+
+Scheme_Object **scheme_make_struct_names_from_array(const char *base, 
+						    int fcount,
+						    const char **field_names,
+						    int flags, int *count_out);
+Scheme_Object *scheme_make_struct_type_from_string(const char *base, 
+						   Scheme_Object *parent, 
+						   int num_fields);
+extern Scheme_Object *scheme_write_proc, *scheme_display_proc, *scheme_print_proc;
+
+int scheme_num_types(void);
+
+void scheme_alloc_list_stack(Scheme_Process *process);
+
+int scheme_get_eval_type(Scheme_Object *obj);
+
+Scheme_Comp_Env *scheme_no_defines(Scheme_Comp_Env *env);
+int scheme_count_sema_callbacks(int kind);
+
+int scheme_is_toplevel(Scheme_Comp_Env *env);
+Scheme_Comp_Env *scheme_extend_as_toplevel(Scheme_Comp_Env *env);
+
+int scheme_is_relative_path(const char *s, long len);
+int scheme_is_complete_path(const char *s, long len);
+
+void scheme_do_format(const char *procname, Scheme_Object *port, 
+		      const unsigned char *format, int flen, 
+		      int fpos, int offset, int argc, Scheme_Object **argv);
+
+char *scheme_make_arity_expect_string(Scheme_Object *proc,
+				      int argc, Scheme_Object **argv);
+
+#ifdef TIME_TYPE_IS_UNSIGNED
+#define scheme_make_integer_value_from_time(t) scheme_make_integer_value_from_unsigned((unsigned long)t)
+#else
+#define scheme_make_integer_value_from_time(t) scheme_make_integer_value((long)t)
+#endif
+
+long scheme_extract_index(const char *name, int pos, int argc, Scheme_Object **argv, long top);
+
+Scheme_Object *scheme_get_file_directory(const char *filename);
+
+char *scheme_normal_path_case(char *s, int len);
+
+Scheme_Object *scheme_thread_w_manager(Scheme_Object *thunk, Scheme_Config *config, Scheme_Manager *mgr);
+
+char *scheme_get_thread_current_directory(Scheme_Process *p, int *len, int noexn);
+
+#ifdef WIN32_THREADS
+void *scheme_win32_get_break_semaphore(void *th);
+#endif
+
+Scheme_Env *scheme_make_empty_env(void);
+
+const char *scheme_number_suffix(int);
+
+void scheme_add_bucket_to_table(Scheme_Hash_Table *table, Scheme_Bucket *b);
+Scheme_Bucket *scheme_bucket_or_null_from_table (Scheme_Hash_Table *table, const char *key, int add);
+
+Scheme_Object *scheme_load_with_clrd(int argc, Scheme_Object *argv[], char *who, int handler_param);
+
+int scheme_string_has_null(Scheme_Object *o);
+#define STRING_W_NO_NULLS "string (with no null characters)"
+
+#endif /* __mzscheme_private__ */
diff --git a/src/mzscheme/src/schrunst.h b/src/mzscheme/src/schrunst.h
new file mode 100644
index 0000000..f04152b
--- /dev/null
+++ b/src/mzscheme/src/schrunst.h
@@ -0,0 +1,13 @@
+
+#if 1
+/* Normal version: */
+# define PUSH_RUNSTACK(p, r, amt) (r -= amt)
+# define CHECK_RUNSTACK(p, r) /**/
+#else
+/* Debugging version: */
+# define PUSH_RUNSTACK(p, r, amt) (r -= amt, CHECK_RUNSTACK(p, r), r)
+# define CHECK_RUNSTACK(p, r) \
+  ((((unsigned long)r) < ((unsigned long)p->runstack_start)) \
+   ? (scheme_signal_error("internal error: runstack overflow!"), 0) \
+   : 0)
+#endif
diff --git a/src/mzscheme/src/schvers.h b/src/mzscheme/src/schvers.h
new file mode 100644
index 0000000..f24d2aa
--- /dev/null
+++ b/src/mzscheme/src/schvers.h
@@ -0,0 +1,2 @@
+
+#define VERSION "51/9"
diff --git a/src/mzscheme/src/schwinfd.h b/src/mzscheme/src/schwinfd.h
new file mode 100644
index 0000000..4d5afdb
--- /dev/null
+++ b/src/mzscheme/src/schwinfd.h
@@ -0,0 +1,9 @@
+
+#if defined(WINDOWS_PROCESSES) || defined(DETECT_WIN32_CONSOLE_STDIN)
+typedef struct {
+  fd_set set;
+  int num_handles;
+  HANDLE *handles;
+  int *repost_sema;
+} win_extended_fd_set;
+#endif
diff --git a/src/mzscheme/src/sema.c b/src/mzscheme/src/sema.c
new file mode 100644
index 0000000..0c004ac
--- /dev/null
+++ b/src/mzscheme/src/sema.c
@@ -0,0 +1,308 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+
+#ifndef NO_SCHEME_THREADS
+
+static Scheme_Object *make_sema(int n, Scheme_Object **p);
+static Scheme_Object *semap(int n, Scheme_Object **p);
+static Scheme_Object *hit_sema(int n, Scheme_Object **p);
+static Scheme_Object *block_sema_p(int n, Scheme_Object **p);
+static Scheme_Object *block_sema(int n, Scheme_Object **p);
+static Scheme_Object *block_sema_breakable(int n, Scheme_Object **p);
+static Scheme_Object *sema_callback(int n, Scheme_Object **p);
+static Scheme_Object *sema_input_port(int n, Scheme_Object **p);
+
+void scheme_init_sema(Scheme_Env *env)
+{
+  scheme_add_global_constant("make-semaphore", 
+			     scheme_make_prim_w_arity(make_sema,
+						      "make-semaphore", 
+						      0, 1), 
+			     env);
+  scheme_add_global_constant("semaphore?", 
+			     scheme_make_folding_prim(semap,
+						      "semaphore?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("semaphore-post", 
+			     scheme_make_prim_w_arity(hit_sema, 
+						      "semaphore-post", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("semaphore-try-wait?", 
+			     scheme_make_prim_w_arity(block_sema_p, 
+						      "semaphore-try-wait?", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("semaphore-wait", 
+			     scheme_make_prim_w_arity(block_sema, 
+						      "semaphore-wait", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("semaphore-wait/enable-break", 
+			     scheme_make_prim_w_arity(block_sema_breakable, 
+						      "semaphore-wait/enable-break", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("semaphore-callback", 
+			     scheme_make_prim_w_arity(sema_callback, 
+						      "semaphore-callback", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("input-port-post-semaphore", 
+			     scheme_make_prim_w_arity(sema_input_port, 
+						      "input-port-post-semaphore", 
+						      2, 2), 
+			     env);
+}
+
+#ifdef MZ_REAL_THREADS
+static void free_sema(void *s, void *ignored)
+{
+  Scheme_Sema *sema;
+
+  sema = (Scheme_Sema *)s;
+
+  SCHEME_FREE_SEMA(sema->sema);
+}
+#endif
+
+Scheme_Object *scheme_make_sema(long v)
+{
+  Scheme_Sema *sema;
+
+#ifdef MZ_REAL_THREADS
+  sema = (Scheme_Sema *)scheme_malloc_tagged(sizeof(Scheme_Sema));
+  sema->sema = SCHEME_MAKE_SEMA(v);
+  scheme_add_finalizer(sema, free_sema, NULL);
+#else
+  sema = (Scheme_Sema *)scheme_malloc_atomic_tagged(sizeof(Scheme_Sema));
+  sema->value = v;
+#endif
+
+  sema->type = scheme_sema_type;
+
+  return (Scheme_Object *)sema;
+}
+
+static Scheme_Object *make_sema(int n, Scheme_Object **p)
+{
+  long v;
+
+  if (n) {
+    if (!SCHEME_INTP(p[0])) {
+      if (!SCHEME_BIGNUMP(p[0]) || !SCHEME_BIGPOS(p[0]))
+	scheme_wrong_type("make-semaphore", "non-negative exact integer", 0, n, p);
+    }
+
+    if (!scheme_get_int_val(p[0], &v)) {
+      scheme_raise_exn(MZEXN_MISC_SEMAPHORE,
+		       "make-semaphore: starting value %s is too large",
+		       scheme_make_provided_string(p[0], 0, NULL));
+    } else if (v < 0)
+      scheme_wrong_type("make-semaphore", "non-negative exact integer", 0, n, p);
+  } else
+    v = 0;
+
+  return scheme_make_sema(v);
+}
+
+static Scheme_Object *semap(int n, Scheme_Object **p)
+{
+  return SCHEME_SEMAP(p[0]) ? scheme_true : scheme_false;
+}
+
+void scheme_post_sema(Scheme_Object *o)
+{
+  Scheme_Sema *t = (Scheme_Sema *)o;
+
+#ifdef MZ_REAL_THREADS
+  if (SCHEME_SEMA_UP(t->sema))
+    return;
+#else
+  int v;
+
+  v = t->value + 1;
+  if (v > t->value) {
+    t->value = v;
+    return;
+  }
+#endif
+
+  scheme_raise_exn(MZEXN_MISC_SEMAPHORE,
+		   "semaphore-post: the maximum post count has already been reached");
+}
+
+static Scheme_Object *hit_sema(int n, Scheme_Object **p)
+{
+  if (!SCHEME_SEMAP(p[0]))
+    scheme_wrong_type("semaphore-post", "semaphore", 0, n, p);
+
+  scheme_post_sema(p[0]);
+
+  return scheme_void;
+}
+
+typedef struct {
+  Scheme_Config *config;
+  Scheme_Object *orig_param_val;
+  Scheme_Object *sema;
+} BreakableWait;
+
+static void pre_breakable_wait(void *data)
+{
+  BreakableWait *bw = (BreakableWait *)data;
+
+  bw->orig_param_val = scheme_get_param(bw->config, MZCONFIG_ENABLE_BREAK);
+  scheme_set_param(bw->config, MZCONFIG_ENABLE_BREAK, scheme_true);
+}
+
+static Scheme_Object *do_breakable_wait(void *data)
+{
+  BreakableWait *bw = (BreakableWait *)data;
+  scheme_wait_sema(bw->sema, 0);
+  return scheme_void;
+}
+
+static void post_breakable_wait(void *data)
+{
+  BreakableWait *bw = (BreakableWait *)data;
+  scheme_set_param(bw->config, MZCONFIG_ENABLE_BREAK, bw->orig_param_val);
+}
+
+int scheme_wait_sema(Scheme_Object *o, int just_try)
+{
+  Scheme_Sema *sema = (Scheme_Sema *)o;
+  int v;
+
+  if (just_try) {
+    if (just_try > 0) {
+#ifdef MZ_REAL_THREADS
+      v = SCHEME_SEMA_TRY_DOWN(sema->sema);
+#else
+      if (sema->value) {
+	--sema->value;
+	v = 1;
+      } else
+	v = 0;
+#endif
+    } else {
+      BreakableWait *bw = MALLOC_ONE(BreakableWait);
+
+      bw->sema = o;
+      bw->config = scheme_config;
+
+      scheme_dynamic_wind(pre_breakable_wait, 
+			  do_breakable_wait, 
+			  post_breakable_wait, 
+			  NULL, bw);
+
+      return 1;
+    }
+  } else {
+#ifdef MZ_REAL_THREADS
+    SCHEME_SEMA_DOWN(sema->sema);
+#else
+    if (sema->value)
+      --sema->value;
+    else {
+      scheme_current_process->block_descriptor = SEMA_BLOCKED;
+      scheme_current_process->blocker = (Scheme_Object *)sema;
+      
+      while (!sema->value)
+	scheme_process_block(0);
+      --sema->value;
+      
+      scheme_current_process->block_descriptor = NOT_BLOCKED;
+      scheme_current_process->blocker = NULL;
+      scheme_current_process->ran_some = 1;
+    }
+    v = 1;
+#endif
+  }
+
+  return v;
+}
+
+static Scheme_Object *block_sema_p(int n, Scheme_Object **p)
+{
+  if (!SCHEME_SEMAP(p[0]))
+    scheme_wrong_type("semaphore-try-wait?", "sema", 0, n, p);
+
+  return scheme_wait_sema(p[0], 1) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *block_sema(int n, Scheme_Object **p)
+{
+  if (!SCHEME_SEMAP(p[0]))
+    scheme_wrong_type("semaphore-wait", "sema", 0, n, p);
+
+  scheme_wait_sema(p[0], 0);
+
+  return scheme_void;
+}
+
+static Scheme_Object *block_sema_breakable(int n, Scheme_Object **p)
+{
+  if (!SCHEME_SEMAP(p[0]))
+    scheme_wrong_type("semaphore-wait/enable-break", "sema", 0, n, p);
+
+  scheme_wait_sema(p[0], -1);
+
+  return scheme_void;
+}
+
+static Scheme_Object *sema_callback(int n, Scheme_Object **p)
+{
+  Scheme_Sema_Callback *cb;
+
+  if (!SCHEME_SEMAP(p[0]))
+    scheme_wrong_type("semaphore-callback", "semaphore", 0, n, p);
+  scheme_check_proc_arity("semaphore-callback", 0, 1, n, p);
+
+  cb = (Scheme_Sema_Callback*)scheme_malloc(sizeof(Scheme_Sema_Callback));
+  cb->sema = (Scheme_Sema *)p[0];
+  cb->callback = p[1];
+  
+  scheme_add_sema_callback(cb);
+
+  return scheme_void;
+}
+
+static Scheme_Object *sema_input_port(int n, Scheme_Object **p)
+{
+  Scheme_Sema_From_Port *cb;
+
+  if (!SCHEME_INPORTP(p[0]))
+    scheme_wrong_type("input-port-post-semaphore", "input port", 0, n, p);
+  if (!SCHEME_SEMAP(p[1]))
+    scheme_wrong_type("input-port-post-semaphore", "semaphore", 1, n, p);
+
+  cb = (Scheme_Sema_From_Port*)scheme_malloc(sizeof(Scheme_Sema_From_Port));
+  cb->sema = (Scheme_Sema *)p[1];
+  cb->port = p[0];
+  
+  scheme_add_sema_from_port(cb);
+
+  return scheme_void;
+}
+
+#endif
diff --git a/src/mzscheme/src/setjmpup.c b/src/mzscheme/src/setjmpup.c
new file mode 100644
index 0000000..f877070
--- /dev/null
+++ b/src/mzscheme/src/setjmpup.c
@@ -0,0 +1,157 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+#include "schmach.h"
+
+#ifdef STACK_GROWS_UP
+#define DEEPPOS(b) ((unsigned long)(b)->stack_from+(unsigned long)(b)->stack_size)
+#else
+#ifdef STACK_GROWS_DOWN
+#define DEEPPOS(b) ((unsigned long)(b)->stack_from)
+#else
+#define DEEPPOS(b) ((unsigned long)(b)->stack_from+ \
+                 (scheme_stack_grows_up ? (unsigned long)(b)->stack_size : 0))
+#endif
+#endif
+
+#ifdef memcpy
+#undef memcpy
+#endif
+
+#define memcpy(dd, ss, ll) \
+{  stack_val *d, *s; long l; \
+   l = ll / sizeof(stack_val); d = (stack_val *)dd; s = (stack_val *)ss; \
+   while (l--) *(d++) = *(s++); }
+
+static void copy_stack(Scheme_Jumpup_Buf *b, void *start)
+{
+  long size;
+  void *here;
+
+  here = &size;
+
+  size = (long)here - (long)start;
+  if (scheme_stack_grows_up) {
+    b->stack_from = start;
+  } else {
+    size = -size;
+    b->stack_from = here;
+  }
+
+  if (size < 0)
+    size = 0;
+
+  if (b->stack_max_size < size) {
+    b->stack_copy = scheme_malloc(size);
+    b->stack_max_size = size;    
+  }
+  b->stack_size = size;
+  
+  memcpy(b->stack_copy,
+	 b->stack_from,
+	 size);
+}
+
+static void uncopy_stack(int ok, Scheme_Jumpup_Buf *b)
+{
+  Scheme_Jumpup_Buf *c;
+
+  if (!ok) {
+    unsigned long z;
+    long junk[200];
+
+    z = (unsigned long)&junk[0];
+
+    uncopy_stack(STK_COMP(z, DEEPPOS(b)), b);
+  }
+
+  FLUSH_REGISTER_WINDOWS;
+
+  c = b;
+  while (c) {
+    memcpy(c->stack_from,
+	   c->stack_copy,
+	   c->stack_size);
+    c = c->cont;
+  }
+
+#ifdef WIN32_SETJMP_HACK
+  /* Mystical hack for Win32 with Borland C++ 4.5 */
+  /* My best guess is that the j_excep field is used by the
+     Win32 kernal to gurantee that longjmp isn't used nastily
+     by jumping across the handling of different events. Or something.
+     Of course, I'm using longjmp nastily, so I have to trick the kernal. */
+  /* That's just a guess. In any case, it seems to work. */
+  {
+    jmp_buf hack;
+    setjmp(hack);
+    b->buf->j_excep = hack->j_excep;
+  }
+#endif
+
+  scheme_longjmp(b->buf, 1);
+}
+
+int scheme_setjmpup_relative(Scheme_Jumpup_Buf *b, void *start, 
+			     Scheme_Jumpup_Buf *c)
+{
+  int local;
+
+  FLUSH_REGISTER_WINDOWS;
+
+  if (STK_COMP((unsigned long)start, (unsigned long)&local))
+    start = (void *)&local;
+
+  if (!(local = scheme_setjmp(b->buf))) {
+    if (c) {
+      b->cont = c;
+      if (scheme_stack_grows_up) {
+	start = (void *)((char *)c->stack_from + c->stack_size);
+      } else {
+	start = c->stack_from;
+      }
+    } else
+      b->cont = NULL;
+    copy_stack(b, start);
+    return 0;
+  }
+
+  return local;
+}
+
+void scheme_longjmpup(Scheme_Jumpup_Buf *b)
+{
+  long z;
+
+  uncopy_stack(STK_COMP((unsigned long)&z, DEEPPOS(b)), b);
+}
+
+void scheme_init_jmpup_buf(Scheme_Jumpup_Buf *b)
+{
+  b->stack_size = b->stack_max_size = 0;
+  b->stack_from = b->stack_copy = NULL;
+}
+
+void scheme_ensure_stack_start(Scheme_Process *p, void *d)
+{
+  if (!p->stack_start 
+      || (STK_COMP((unsigned long)p->stack_start, (unsigned long)d)))
+    p->stack_start = d;
+}
diff --git a/src/mzscheme/src/sstoinc b/src/mzscheme/src/sstoinc
new file mode 100755
index 0000000..af444ff
--- /dev/null
+++ b/src/mzscheme/src/sstoinc
@@ -0,0 +1,90 @@
+#!/usr/local/bin/perl
+
+$ready = 0;
+$n = 1;
+
+while (<>)
+{
+    chop;
+
+    if ((substr($_, 0, 6) eq '> stop')
+	|| (substr($_, 0, 7) eq '> kstop')
+	|| (substr($_, 0, 7) eq '> fstop')
+	|| (substr($_, 0, 7) eq '> qstop')
+	|| (substr($_, 0, 7) eq '> cstop')) {
+
+	# strip " <" at end:
+	$_ = substr($_, 0, length($_) - 2); 
+
+	$is_key = (substr($_, 0, 7) eq '> kstop');
+	$is_cond = (substr($_, 0, 7) eq '> cstop');
+	$is_func = (substr($_, 0, 7) eq '> fstop');
+	$is_qq = (substr($_, 0, 7) eq '> qstop');
+	
+	print ");\n";
+
+	if ($is_key || $is_cond || $is_func || $is_qq) { 
+	    $pos = 8; 
+	} else { 
+	    $pos = 7; 
+	}
+
+	@defined = split(/ /, substr($_, $pos));
+	foreach $def (@defined) {
+	    if ($is_key) {
+		print "  JUST_DEFINED_KEY($def);\n";
+	    } elsif ($is_cond) {
+		print "  JUST_DEFINED_COND($def);\n";
+	    } elsif ($is_func) {
+		print "  JUST_DEFINED_FUNC($def);\n";
+	    } elsif ($is_qq) {
+		print "  JUST_DEFINED_QQ($def);\n";
+	    } else {
+		print "  JUST_DEFINED($def);\n";
+	    }
+	}
+
+	$ready = 0;
+	
+    } elsif (substr($_, 0, 9) eq '> literal') {
+	print substr(substr($_, 0, length($_) - 1), 11);
+	print "\n";
+    } elsif ($_ =~ /^ *$/) {
+	# Just spaces; do nothing
+    } elsif ($_ =~ /^\s*;/) {
+	# comment; do nothing
+    } else {
+
+	if (!$ready) {
+	    print '  EVAL_ONE_STR(';
+	    print "\n";
+	    $ready = 1;
+	}
+
+	if ($_ =~ /\"[^"]*\[[^"]*\"/) {
+	} else {
+	    $_ =~ tr/\[/\(/;
+	    $_ =~ tr/\]/\)/;
+	}
+
+	$_ =~ s/\\/\\\\/g;
+	$_ =~ s/\"/\\\"/g;
+	
+	$_ =~ s/\t/ /g;
+	$_ =~ s/  */ /g;
+
+        if ($_ =~ /\"/) {
+	    # Has a string - can't safely delete more spaces
+	} else {
+	    $_ =~ s/ \(/\(/g;
+	}
+
+	print '"' . $_ . '"';
+	print "\n";
+    }
+}
+
+if ($ready) {
+    print ');';
+    print "\n";
+}
diff --git a/src/mzscheme/src/sstoinc.ss b/src/mzscheme/src/sstoinc.ss
new file mode 100644
index 0000000..419e45b
--- /dev/null
+++ b/src/mzscheme/src/sstoinc.ss
@@ -0,0 +1,59 @@
+
+(define to-zo? (equal? argv #("zo")))
+
+(define DIGS-PER-LINE 20)
+
+(let loop ([s ""])
+  (let ([expr (read)])
+    (unless (eof-object? expr)
+	    (if (eq? expr '>)
+		(let ([tag (read)])
+		  (if (eq? tag 'literal)
+		      (begin
+			(unless to-zo?
+				(display (read))
+				(newline))
+			(loop s))
+		      (let ([args (let loop ()
+				    (let ([v (read)])
+				      (if (or (eof-object? v) (eq? v '<))
+					  null
+					  (cons v (loop)))))]
+			    [prefix
+			     (case tag
+			       [(stop) 'JUST_DEFINED]
+			       [(qstop) 'JUST_DEFINED_QQ]
+			       [(fstop) 'JUST_DEFINED_FUNC]
+			       [(kstop) 'JUST_DEFINED_KEY]
+			       [(cstop) 'JUST_DEFINED_COND])])
+			(if to-zo?
+			    (begin
+			      (display s) 
+			      (newline))
+			    (begin
+			      (printf "  {~n    static MZCOMPILED_STRING_FAR unsigned char expr[] = {")
+			      (let loop ([chars (string->list s)][pos 0])
+				(unless (null? chars)
+					(let ([char (car chars)])
+					  (printf "~a, " (char->integer char)))
+					(loop (cdr chars)
+					      (if (= pos DIGS-PER-LINE)
+						  (begin
+						    (newline)
+						    0)
+						  (add1 pos)))))
+			      (printf "0};~n    EVAL_ONE_SIZED_STR((char *)expr, ~a);~n" (string-length s))
+			      (for-each
+			       (lambda (id)
+				 (printf "    ~a(~a);~n" prefix id))
+			       args)
+			      (printf "  }~n")))
+			(loop ""))))
+		(let ([c (compile expr)]
+		      [p (open-output-string)])
+		  (write c p)
+		  (loop (string-append s (get-output-string p))))))))
+
+
+
+		   
diff --git a/src/mzscheme/src/string.c b/src/mzscheme/src/string.c
new file mode 100644
index 0000000..c221115
--- /dev/null
+++ b/src/mzscheme/src/string.c
@@ -0,0 +1,1090 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <string.h>
+#include <ctype.h>
+
+#include "schvers.h"
+
+#ifndef SCHEME_PLATFORM_LIBRARY_SUBPATH
+# include "schsys.h"
+#endif
+
+/* globals */
+
+/* locals */
+static Scheme_Object *make_string (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_length (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ref (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_set (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ci_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_lt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_gt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_lt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_gt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ci_lt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ci_gt (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ci_lt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_ci_gt_eq (int argc, Scheme_Object *argv[]);
+static Scheme_Object *substring (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_append (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_to_list (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_to_string (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_copy (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_fill (int argc, Scheme_Object *argv[]);
+static Scheme_Object *version(int argc, Scheme_Object *argv[]);
+static Scheme_Object *format(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_printf(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_fprintf(int argc, Scheme_Object *argv[]);
+static Scheme_Object *banner(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_getenv(int argc, Scheme_Object *argv[]);
+static Scheme_Object *sch_putenv(int argc, Scheme_Object *argv[]);
+static Scheme_Object *system_type(int argc, Scheme_Object *argv[]);
+static Scheme_Object *system_library_subpath(int argc, Scheme_Object *argv[]);
+
+static int mz_strcmp(unsigned char *str1, int l1, unsigned char *str2, int l2);
+static int mz_strcmp_ci(unsigned char *str1, int l1, unsigned char *str2, int l2);
+
+static Scheme_Object *sys_symbol;
+static Scheme_Object *platform_path;
+static Scheme_Object *zero_length_string;
+
+static Scheme_Hash_Table *putenv_str_table;
+
+void
+scheme_init_string (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(sys_symbol);
+    sys_symbol = scheme_intern_symbol(SYSTEM_TYPE_NAME);
+
+    REGISTER_SO(zero_length_string);
+    zero_length_string = scheme_alloc_string(0, 0); 
+
+    REGISTER_SO(platform_path);
+    platform_path = scheme_make_string(SCHEME_PLATFORM_LIBRARY_SUBPATH);
+
+    REGISTER_SO(putenv_str_table);
+  }
+
+  scheme_add_global_constant("string?", 
+			     scheme_make_folding_prim(string_p,
+						      "string?",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("make-string", 
+			     scheme_make_prim_w_arity(make_string,
+						      "make-string",
+						      1, 2),
+			     env);
+  scheme_add_global_constant("string", 
+			     scheme_make_prim_w_arity(string,
+						      "string", 
+						      0, -1),
+			     env);
+  scheme_add_global_constant("string-length", 
+			     scheme_make_folding_prim(string_length,
+						      "string-length",
+						      1, 1, 1),
+			     env);
+  scheme_add_global_constant("string-ref", 
+			     scheme_make_prim_w_arity(string_ref,
+						      "string-ref", 
+						      2, 2),
+			     env);
+  scheme_add_global_constant("string-set!", 
+			     scheme_make_prim_w_arity(string_set,
+						      "string-set!", 
+						      3, 3),
+			     env);
+  scheme_add_global_constant("string=?", 
+			     scheme_make_prim_w_arity(string_eq,
+						      "string=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string-ci=?", 
+			     scheme_make_prim_w_arity(string_ci_eq,
+						      "string-ci=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string<?", 
+			     scheme_make_prim_w_arity(string_lt,
+						      "string<?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string>?", 
+			     scheme_make_prim_w_arity(string_gt,
+						      "string>?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string<=?", 
+			     scheme_make_prim_w_arity(string_lt_eq,
+						      "string<=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string>=?", 
+			     scheme_make_prim_w_arity(string_gt_eq,
+						      "string>=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string-ci<?", 
+			     scheme_make_prim_w_arity(string_ci_lt,
+						      "string-ci<?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string-ci>?", 
+			     scheme_make_prim_w_arity(string_ci_gt,
+						      "string-ci>?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string-ci<=?", 
+			     scheme_make_prim_w_arity(string_ci_lt_eq,
+						      "string-ci<=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("string-ci>=?", 
+			     scheme_make_prim_w_arity(string_ci_gt_eq,
+						      "string-ci>=?",
+						      1, -1),
+			     env);
+  scheme_add_global_constant("substring", 
+			     scheme_make_prim_w_arity(substring,
+						      "substring", 
+						      3, 3),
+			     env);
+  scheme_add_global_constant("string-append", 
+			     scheme_make_prim_w_arity(string_append,
+						      "string-append", 
+						      0, -1),
+			     env);
+  scheme_add_global_constant("string->list", 
+			     scheme_make_prim_w_arity(string_to_list,
+						      "string->list",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("list->string", 
+			     scheme_make_prim_w_arity(list_to_string,
+						      "list->string",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("string-copy", 
+			     scheme_make_prim_w_arity(string_copy,
+						      "string-copy",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("string-fill!", 
+			     scheme_make_prim_w_arity(string_fill,
+						      "string-fill!", 
+						      2, 2),
+			     env);
+  
+
+  scheme_add_global_constant("format", 
+			     scheme_make_folding_prim(format,
+						      "format", 
+						      1, -1, 1),
+			     env);
+  scheme_add_global_constant("printf", 
+			     scheme_make_prim_w_arity(sch_printf,
+						      "printf", 
+						      1, -1),
+			     env);
+  scheme_add_global_constant("fprintf", 
+			     scheme_make_prim_w_arity(sch_fprintf,
+						      "fprintf", 
+						      2, -1),
+			     env);
+  
+
+  scheme_add_global_constant("version", 
+			     scheme_make_folding_prim(version,
+						      "version", 
+						      0, 0, 1),
+			     env);
+  scheme_add_global_constant("banner", 
+			     scheme_make_folding_prim(banner,
+						      "banner", 
+						      0, 0, 1),
+			     env);
+  
+  scheme_add_global_constant("getenv", 
+			     scheme_make_prim_w_arity(sch_getenv,
+						      "getenv",
+						      1, 1),
+			     env);
+  scheme_add_global_constant("putenv", 
+			     scheme_make_prim_w_arity(sch_putenv,
+						      "putenv", 
+						      2, 2),
+			     env);
+  
+  scheme_add_global_constant("system-type", 
+			     scheme_make_folding_prim(system_type,
+						      "system-type", 
+						      0, 0, 1),
+			     env);
+  scheme_add_global_constant("system-library-subpath",
+			     scheme_make_folding_prim(system_library_subpath,
+						      "system-library-subpath",
+						      0, 0, 1),
+			     env);
+}
+
+Scheme_Object *
+scheme_make_sized_string(char *chars, long len, int copy)
+{
+  Scheme_Object *str;
+  
+  str = scheme_alloc_stubborn_object();
+  str->type = scheme_string_type;
+  if (len < 0)
+    len = strlen(chars);
+  if (copy) {
+    char *naya;
+
+    SCHEME_STR_VAL(str) = naya = (char *)scheme_malloc_fail_ok(scheme_malloc_atomic, len + 1);
+    memcpy(naya, chars, len);
+    naya[len] = 0;
+  } else
+    SCHEME_STR_VAL(str) = chars;
+  SCHEME_STRTAG_VAL(str) = len;
+  scheme_end_stubborn_change((void *)str);
+  return (str);
+}
+
+Scheme_Object *
+scheme_make_string_without_copying(char *chars)
+{
+  return scheme_make_sized_string(chars, -1, 0);
+}
+
+Scheme_Object *
+scheme_make_string(const char *chars)
+{
+  return scheme_make_string_without_copying(scheme_strdup(chars));
+}
+
+Scheme_Object *
+scheme_alloc_string(int size, char fill)
+{
+  Scheme_Object *str;
+  char *s;
+  int i;
+  
+  if (size < 0) {
+    str = scheme_make_integer(size);
+    scheme_wrong_type("make-string", "non-negative exact integer",
+		      -1, 0, &str);
+  }
+
+  str = scheme_alloc_stubborn_object();
+  str->type = scheme_string_type;
+  s = (char *)scheme_malloc_fail_ok(scheme_malloc_atomic, sizeof(char)*(size + 1));
+  for (i = size; i--; )
+    s[i] = fill;
+  s[size] = '\0';
+  SCHEME_STR_VAL(str) = s;
+  SCHEME_STRTAG_VAL(str) = size;
+
+  scheme_end_stubborn_change((void *)str);
+
+  return str;
+}
+
+static void out_of_string_range(const char *name, const char *which, Scheme_Object *i, 
+				long start, long len)
+{
+  scheme_raise_exn(MZEXN_APPLICATION_RANGE_BOUNDS_STRING,
+		   scheme_make_integer(i),
+		   scheme_make_integer(start),
+		   scheme_make_integer(len),
+		   "%s: %sindex %s out of range [%d, %d]",
+		   name, which,
+		   scheme_make_provided_string(i, 0, NULL), 
+		   start, len);
+}
+
+long scheme_extract_index(const char *name, int pos, int argc, Scheme_Object **argv, long top)
+{
+  long i;
+  int is_top = 0;
+
+  if (SCHEME_INTP(argv[pos])) {
+    i = SCHEME_INT_VAL(argv[pos]);
+  } else if (SCHEME_BIGNUMP(argv[pos])) {
+    if (SCHEME_BIGPOS(argv[pos])) {
+      i = top; /* out-of-bounds */
+      is_top = 1;
+    } else
+      i = -1; /* negative */
+  } else
+    i = -1;
+
+  if (!is_top && (i < 0))
+    scheme_wrong_type(name, "non-negative exact integer", pos, argc, argv);
+  
+  return i;
+}
+
+/* locals */
+
+Scheme_Object *
+string_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_STRINGP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+make_string (int argc, Scheme_Object *argv[])
+{
+  long len;
+  char fill;
+  Scheme_Object *str;
+
+  len = scheme_extract_index("make-string", 0, argc, argv, -1);
+
+  if (len == -1) {
+    scheme_raise_out_of_memory("make-string", "making string of length %s",
+			       scheme_make_provided_string(argv[0], 0, NULL));
+  }
+
+  if (argc == 2) {
+    if (!SCHEME_CHARP(argv[1]))
+      scheme_wrong_type("make-string", "character", 1, argc, argv);
+    fill = SCHEME_CHAR_VAL(argv[1]);
+  } else
+    fill = 0;
+
+  str = scheme_alloc_string(len, fill);
+  return (str);
+}
+
+static Scheme_Object *
+string (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *str;
+  int i;
+
+  str = scheme_alloc_string(argc, 0);
+
+  for ( i=0 ; i<argc ; ++i ) {
+    if (!SCHEME_CHARP (argv[i]))
+      scheme_wrong_type("string", "character", i, argc, argv);
+    SCHEME_STR_VAL(str)[i] = SCHEME_CHAR_VAL(argv[i]);
+  }
+
+  return (str);
+}
+
+static Scheme_Object *
+string_length (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string-length", "string", 0, argc, argv);
+
+  return scheme_make_integer(SCHEME_STRTAG_VAL(argv[0]));
+}
+
+static Scheme_Object *
+string_ref (int argc, Scheme_Object *argv[])
+{
+  long i, len;
+  char *str;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string-ref", "string", 0, argc, argv);
+
+  str = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  i = scheme_extract_index("string-ref", 1, argc, argv, len);
+
+  if (i >= len) {
+    out_of_string_range("string-ref", "", argv[1], 0, len - 1);
+    return NULL;
+  }
+
+  return scheme_make_char(str[i]);
+}
+
+static Scheme_Object *
+string_set (int argc, Scheme_Object *argv[])
+{
+  long i, len;
+  char *str;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string-set!", "string", 0, argc, argv);
+
+  str = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  i = scheme_extract_index("string-set!", 1, argc, argv, len);
+
+  if (!SCHEME_CHARP(argv[2]))
+    scheme_wrong_type("string-set!", "character", 2, argc, argv);
+
+  if (i >= len) {
+    out_of_string_range("string-set!", "", argv[1], 0, len - 1);
+    return NULL;
+  }
+
+  str[i] = SCHEME_CHAR_VAL(argv[2]);
+
+  return scheme_void;
+}
+
+/* comparisons */
+
+#define GEN_STRING_COMP(name, scheme_name, comp, op) \
+static Scheme_Object * name (int argc, Scheme_Object *argv[]) \
+{  char *s, *prev; int i, sl, pl; int falz = 0;\
+   if (!SCHEME_STRINGP(argv[0])) \
+    scheme_wrong_type(scheme_name, "string", 0, argc, argv); \
+   prev = SCHEME_STR_VAL(argv[0]); pl = SCHEME_STRTAG_VAL(argv[0]); \
+   for (i = 1; i < argc; i++) { \
+     if (!SCHEME_STRINGP(argv[i])) \
+      scheme_wrong_type(scheme_name, "string", i, argc, argv); \
+     s = SCHEME_STR_VAL(argv[i]); sl = SCHEME_STRTAG_VAL(argv[i]); \
+     if (!falz) if (!(comp((unsigned char *)prev, pl, \
+                           (unsigned char *)s, sl) op 0)) falz = 1; \
+     prev = s; pl = sl; \
+  } \
+  return falz ? scheme_false : scheme_true; \
+}
+
+GEN_STRING_COMP(string_eq, "string=?", mz_strcmp, ==)
+GEN_STRING_COMP(string_lt, "string<?", mz_strcmp, <)
+GEN_STRING_COMP(string_gt, "string>?", mz_strcmp, >)
+GEN_STRING_COMP(string_lt_eq, "string<=?", mz_strcmp, <=)
+GEN_STRING_COMP(string_gt_eq, "string>=?", mz_strcmp, >=)
+
+GEN_STRING_COMP(string_ci_eq, "string-ci=?", mz_strcmp_ci, ==)
+GEN_STRING_COMP(string_ci_lt, "string-ci<?", mz_strcmp_ci, <)
+GEN_STRING_COMP(string_ci_gt, "string-ci>?", mz_strcmp_ci, >)
+GEN_STRING_COMP(string_ci_lt_eq, "string-ci<=?", mz_strcmp_ci, <=)
+GEN_STRING_COMP(string_ci_gt_eq, "string-ci>=?", mz_strcmp_ci, >=)
+
+static Scheme_Object *
+substring (int argc, Scheme_Object *argv[])
+{
+  long len, start, finish, i;
+  char *chars;
+  Scheme_Object *str;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("substring", "string", 0, argc, argv);
+
+  chars = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+
+  start = scheme_extract_index("substring", 1, argc, argv, len);
+  finish = scheme_extract_index("substring", 2, argc, argv, len + 1);
+
+  if (!(start <= len)) {
+    out_of_string_range("substring", "first ", argv[1], 0, len);
+    return NULL;
+  }
+  if (!(finish >= start && finish <= len)) {
+    out_of_string_range("substring", "second ", argv[2], start, len);
+    return NULL;
+  }
+
+  str = scheme_alloc_string(finish-start, 0);
+  for (i = 0; i < finish-start; i++)
+    SCHEME_STR_VAL(str)[i] = chars[i+start];
+
+  return (str);
+}
+
+static Scheme_Object *
+string_append (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *naya;
+  int i;
+
+  if (argc == 2)
+    return scheme_append_string(argv[0], argv[1]);
+
+  naya = zero_length_string;
+  for (i = 0; i < argc; i++)
+    naya = scheme_append_string(naya, argv[i]);
+
+  return naya;
+}
+
+Scheme_Object *
+scheme_append_string(Scheme_Object *str1, Scheme_Object *str2)
+{
+  int len1, len2, i;
+  char *chars1, *chars2, *r;
+  Scheme_Object *naya;
+
+  if (!SCHEME_STRINGP(str1))
+    scheme_wrong_type("string-append", "string", -1, 0, &str1);
+  if (!SCHEME_STRINGP(str2))
+    scheme_wrong_type("string-append", "string", -1, 0, &str2);
+
+  chars1 = SCHEME_STR_VAL(str1);
+  chars2 = SCHEME_STR_VAL(str2);
+  len1 = SCHEME_STRTAG_VAL(str1);
+  len2 = SCHEME_STRTAG_VAL(str2);
+  naya = scheme_alloc_string(len1 + len2, 0);
+
+  r = SCHEME_STR_VAL(naya);
+  for (i = 0; i < len1; i++, r++)
+    *r = chars1[i];
+
+  for (i = 0; i < len2; i++, r++)
+    *r = chars2[i];
+
+  *r = '\0';
+
+  return naya;
+}
+
+
+static Scheme_Object *
+string_to_list (int argc, Scheme_Object *argv[])
+{
+  int len, i;
+  char *chars;
+  Scheme_Object *first, *last, *pair;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->list", "string", 0, argc, argv);
+
+  chars = SCHEME_STR_VAL(argv[0]);
+  len = SCHEME_STRTAG_VAL(argv[0]);
+  first = last = scheme_null;
+  for ( i=0 ; i<len ; ++i ) {
+    pair = scheme_make_pair (scheme_make_char (chars[i]), scheme_null);
+    if (SCHEME_NULLP(first))
+      first = pair;
+    else
+      SCHEME_CDR (last) = pair;
+    last = pair;
+  }
+
+  return first;
+}
+
+static Scheme_Object *
+list_to_string (int argc, Scheme_Object *argv[])
+{
+  int len, i;
+  Scheme_Object *list, *str, *ch;
+
+  list = argv[0];
+  len = scheme_list_length (list);
+  str = scheme_alloc_string (len, 0);
+  i = 0;
+  while (SCHEME_PAIRP (list))
+    {
+      ch = SCHEME_CAR (list);
+
+      if (!SCHEME_CHARP(ch))
+	scheme_wrong_type("list->string", "proper character list", 0, 
+			  argc, argv);
+
+      SCHEME_STR_VAL(str)[i] = SCHEME_CHAR_VAL(ch);
+      i++;
+      list = SCHEME_CDR (list);
+    }  
+
+  if (!SCHEME_NULLP(list))
+    scheme_wrong_type("list->string", "proper character list", 0, argc, argv);
+
+  return (str);
+}
+
+static Scheme_Object *
+string_copy (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *naya;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string-copy", "string", 0, argc, argv);
+
+  naya = scheme_make_sized_string(SCHEME_STR_VAL(argv[0]), 
+				  SCHEME_STRTAG_VAL(argv[0]), 1);
+  return naya;
+}
+
+static Scheme_Object *
+string_fill (int argc, Scheme_Object *argv[])
+{
+  int len, i;
+  char *chars, ch;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string-fill!", "string", 0, argc, argv);
+  if (!SCHEME_CHARP(argv[1]))
+    scheme_wrong_type("string-fill!", "character", 1, argc, argv);
+  
+  chars = SCHEME_STR_VAL (argv[0]);
+  ch = SCHEME_CHAR_VAL (argv[1]);
+  len = SCHEME_STRTAG_VAL (argv[0]);
+  for (i = 0; i < len; i++)
+    chars[i] = ch;
+
+  return scheme_void;
+}
+
+static int mz_strcmp(unsigned char *str1, int l1, unsigned char *str2, int l2)
+{
+#ifdef USE_LOCALE
+  /* USE_LOCALE contributed by Boris Tobotras, tobotras@jet.msk.su. */
+  /* The problem with using strcoll is that MzScheme strings may
+     contain a null character. In that case, if the strings match up
+     to the first null character but differ afterwards, strcoll will
+     return the wrong result. (This is why we use mz_strcmp instead of
+     strcmp in the first place.) 
+     Caveat emptor. */
+  return strcoll(str1, str2);
+#else  
+  int endres;
+
+  if (l1 > l2) {
+    l1 = l2;
+    endres = 1;
+  } else {
+    if (l2 > l1)
+      endres = -1;
+    else
+      endres = 0;
+  }
+
+  while (l1--) {
+    unsigned int a, b;
+    
+    a = *(str1++);
+    b = *(str2++);
+
+    a = a - b;
+    if (a)
+      return a;
+  }
+
+  return endres;
+#endif
+}
+
+static int mz_strcmp_ci(unsigned char *str1, int l1, unsigned char *str2, int l2)
+{
+  int endres;
+
+  if (l1 > l2) {
+    l1 = l2;
+    endres = 1;
+  } else {
+    if (l2 > l1)
+      endres = -1;
+    else
+      endres = 0;
+  }
+
+  while (l1--) {
+    unsigned int a, b;
+    
+    a = *(str1++);
+    b = *(str2++);
+    a = toupper(a);
+    b = toupper(b);
+
+    a = a - b;
+    if (a)
+      return a;
+  }
+
+  return endres;
+}
+
+void scheme_do_format(const char *procname, Scheme_Object *port, 
+		      const unsigned char *format, int flen, 
+		      int fpos, int offset, int argc, Scheme_Object **argv)
+{
+  int i, start, end;
+  int used = offset;
+  int num_err = 0, char_err = 0;
+  Scheme_Object *a[2];
+
+  if (!format) {
+    if (!SCHEME_STRINGP(argv[fpos])) {
+      scheme_wrong_type(procname, "format-string", fpos, argc, argv);
+      return;
+    }
+    format = (unsigned char *)SCHEME_STR_VAL(argv[fpos]);
+    flen = SCHEME_STRTAG_VAL(argv[fpos]);
+  } else if (flen == -1)
+    flen = strlen((char *)format);
+
+  /* Check string first: */
+  end = flen - 1;
+  for (i = 0; i < end; i++) {
+    if (format[i] == '~') {
+      i++;
+      if (isspace(format[i])) {
+	/* skip spaces... */
+      } else switch (format[i]) {
+      case '~':
+      case '%':
+      case 'n':
+      case 'N':
+	break;
+      case 'a':
+      case 'A':
+      case 's':
+      case 'S':
+      case 'v':
+      case 'V':
+      case 'e':
+      case 'E':
+	used++;
+	break;
+      case 'x':
+      case 'X':
+      case 'o':
+      case 'O':
+      case 'b':
+      case 'B':
+	if (!num_err && !char_err && (used < argc)) {
+	  Scheme_Object *o = argv[used];
+	  if (!SCHEME_EXACT_REALP(o)
+	      && (!SCHEME_COMPLEXP(o)
+		  || !SCHEME_EXACT_REALP(scheme_complex_real_part(o))))
+	    num_err = used + 1;
+	}
+	used++;
+	break;
+      case 'c':
+      case 'C':
+	if (!num_err && !char_err && (used < argc)) {
+	  if (!SCHEME_CHARP(argv[used]))
+	    char_err = used + 1;
+	}
+	used++;
+	break;
+      default:
+	{
+	  char buffer[32];
+	  sprintf(buffer, "pattern-string (tag ~%c not allowed)", format[i]);
+	  scheme_wrong_type(procname, buffer, fpos, argc, argv);
+	  return;
+	}
+      }
+    }
+  }
+  if (format[end] == '~') {
+    scheme_wrong_type(procname, "pattern-string (cannot end in ~)", fpos, argc, argv);
+    return;
+  }
+  if (used != argc) {
+    char *args = scheme_make_args_string("", -1, argc, argv);
+
+    if (used > argc) {
+      scheme_raise_exn(MZEXN_APPLICATION_FPRINTF_NO_ARGUMENT,
+		       argv[fpos],
+		       "%s: format string requires %d arguments, given %d%s",
+		       procname, used - offset, argc - offset, args);
+    } else {
+      scheme_raise_exn(MZEXN_APPLICATION_FPRINTF_EXTRA_ARGUMENTS,
+		       argv[fpos],
+		       scheme_build_list(argc - used, argv + used),
+		       "%s: format string requires %d arguments, given %d%s",
+		       procname, used - offset, argc - offset, args);
+    }
+    return;
+  }
+  if (num_err || char_err) {
+    int pos = (num_err ? num_err : char_err) - 1;
+    char *args = scheme_make_args_string("other ", pos, argc, argv);
+    char *type = (num_err ? "exact-number" : "character");
+    Scheme_Object *bad = argv[pos];
+
+    scheme_raise_exn(MZEXN_APPLICATION_FPRINTF_ARGUMENT_TYPE,
+		     bad,
+		     scheme_intern_symbol(type),
+		     "%s: format string requires argument of type <%s>, given %s%s",
+		     procname, type, 
+		     scheme_make_provided_string(bad, 1, NULL),
+		     args);
+    return;
+  }
+
+  for (used = offset, i = start = 0; i < flen; i++) {
+    if (format[i] == '~') {
+      if (start < i)
+	scheme_write_string((char *)format + start, i - start, port);
+      i++;
+      if (isspace(format[i])) {
+	/* skip spaces (at most one newline) */
+	do {
+	  if ((format[i] == '\n') || (format[i] == '\r')) {
+	    /* got one */
+	    if ((format[i] == '\r') && (format[i + 1] == '\n'))
+	      i++; /* Windows-style CR-NL */
+	    i++;
+	    while (isspace(format[i]) 
+		   && !((format[i] == '\n') || (format[i] == '\r')))
+	      i++;
+	    break;
+	  } else
+	    i++;
+	} while (isspace(format[i]));
+	--i; /* back up over something */
+      } else switch (format[i]) {
+      case '~':
+	scheme_write_string("~", 1, port);
+	break;
+      case '%':
+      case 'n':
+      case 'N':
+	scheme_write_string("\n", 1, port);
+	break;
+      case 'c':
+      case 'C':
+      case 'a':
+      case 'A':
+	a[0] = argv[used++];
+	a[1] = port;
+	_scheme_apply(scheme_display_proc, 2, a);
+	break;
+      case 's':
+      case 'S':
+	a[0] = argv[used++];
+	a[1] = port;
+	_scheme_apply(scheme_write_proc, 2, a);
+	break;
+      case 'v':
+      case 'V':
+	a[0] = argv[used++];
+	a[1] = port;
+	_scheme_apply(scheme_print_proc, 2, a);
+	break;
+      case 'e':
+      case 'E':
+	{
+	  int len;
+	  char *s = scheme_make_provided_string(argv[used++], 0, &len);
+	  scheme_write_string(s, len, port);
+	}
+	break;
+      case 'x':
+      case 'X':
+      case 'o':
+      case 'O':
+      case 'b':
+      case 'B':
+	{
+	  char *s;
+	  int radix;
+
+	  switch(format[i]) {
+	  case 'x':
+	  case 'X':
+	    radix = 16;
+	    break;
+	  case 'o':
+	  case 'O':
+	    radix = 8;
+	    break;
+	  default:
+	  case 'b':
+	  case 'B':
+	    radix = 2;
+	    break;
+	  }
+	  s = scheme_number_to_string(radix, argv[used++]);
+	  
+	  scheme_write_string(s, strlen(s), port);
+	}
+	break;
+      }
+      start = i + 1;
+    }
+  }
+
+  if (start < i)
+    scheme_write_string((char *)format + start, i - start, port);
+}
+
+char *scheme_format(char *format, int flen, int argc, Scheme_Object **argv, int *rlen)
+{
+  Scheme_Object *port = scheme_make_string_output_port();
+  scheme_do_format("format", port, (unsigned char *)format, flen, 0, 0, argc, argv);
+  return scheme_get_sized_string_output(port, rlen);
+}
+
+void scheme_printf(char *format, int flen, int argc, Scheme_Object **argv)
+{
+  scheme_do_format("printf", scheme_get_param(scheme_config, MZCONFIG_OUTPUT_PORT), 
+	    (unsigned char *)format, flen, 0, 0, argc, argv);
+}
+
+static Scheme_Object *
+format(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *port = scheme_make_string_output_port();
+  char *s;
+  int len;
+
+  scheme_do_format("format", port, NULL, 0, 0, 1, argc, argv);
+
+  s = scheme_get_sized_string_output(port, &len);
+  return scheme_make_sized_string(s, len, 0);
+}
+
+static Scheme_Object *
+sch_printf(int argc, Scheme_Object *argv[])
+{
+  scheme_do_format("printf", scheme_get_param(scheme_config, MZCONFIG_OUTPUT_PORT), 
+		   NULL, 0, 0, 1, argc, argv);
+  return scheme_void;
+}
+
+static Scheme_Object *
+sch_fprintf(int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_OUTPORTP(argv[0]))
+    scheme_wrong_type("fprintf", "output-port", 0, argc, argv);
+
+  scheme_do_format("fprintf", argv[0], NULL, 0, 1, 2, argc, argv);
+  return scheme_void;
+}
+
+static Scheme_Object *
+version (int argc, Scheme_Object *argv[])
+{
+  return scheme_make_string(scheme_version());
+}
+
+static Scheme_Object *
+banner (int argc, Scheme_Object *argv[])
+{
+  return scheme_make_string(scheme_banner());
+}
+
+char *scheme_version(void)
+{
+  return VERSION;
+}
+
+#ifdef USE_SENORA_GC
+#define VERSION_SUFFIX " (sgc)"
+#else
+#define VERSION_SUFFIX /* empty */
+#endif
+
+char *scheme_banner(void)
+{
+  return "Welcome to MzScheme version " VERSION VERSION_SUFFIX
+    ", Copyright (c) 1995-97 PLT (Matthew Flatt)\n";
+}
+
+int scheme_string_has_null(Scheme_Object *o)
+{
+  const char *s = SCHEME_STR_VAL(o);
+  int i = SCHEME_STRTAG_VAL(o);
+  while (i--)
+    if (!s[i])
+      return 1;
+  return 0;
+}
+
+static Scheme_Object *sch_getenv(int argc, Scheme_Object *argv[])
+{
+#ifdef GETENV_FUNCTION
+  char *s;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]) || scheme_string_has_null(argv[0]))
+    scheme_wrong_type("getenv", STRING_W_NO_NULLS, 0, argc, argv);
+
+#ifdef GETENV_FUNCTION
+  s = getenv(SCHEME_STR_VAL(argv[0]));
+
+  if (s)
+    return scheme_make_string(s);
+  else
+#endif
+    return scheme_false;
+}
+
+static Scheme_Object *sch_putenv(int argc, Scheme_Object *argv[])
+{
+#ifdef GETENV_FUNCTION
+  char *s, *var, *val;
+  long varlen, vallen;
+#endif
+
+  if (!SCHEME_STRINGP(argv[0]) || scheme_string_has_null(argv[0]))
+    scheme_wrong_type("putenv", STRING_W_NO_NULLS, 0, argc, argv);
+  if (!SCHEME_STRINGP(argv[1]) || scheme_string_has_null(argv[1]))
+    scheme_wrong_type("putenv", STRING_W_NO_NULLS, 1, argc, argv);
+
+#ifdef GETENV_FUNCTION
+  var = SCHEME_STR_VAL(argv[0]);
+  val = SCHEME_STR_VAL(argv[1]);
+
+  varlen = strlen(var);
+  vallen = strlen(val);
+
+  s = (char *)scheme_malloc_atomic(varlen + vallen + 1);
+  memcpy(s, var, varlen);
+  memcpy(s + varlen + 1, val, vallen + 1);
+  s[varlen] = '=';
+
+  SCHEME_GET_LOCK();
+
+  if (!putenv_str_table)
+    putenv_str_table = scheme_hash_table(7, SCHEME_hash_string, 0, 0);
+
+  scheme_add_to_table(putenv_str_table, var, s, 0);
+
+  SCHEME_RELEASE_LOCK();
+
+  return putenv(s) ? scheme_false : scheme_true;
+#else
+  return scheme_false;
+#endif
+}
+
+static Scheme_Object *system_type(int argc, Scheme_Object *argv[])
+{
+  return sys_symbol;
+}
+
+static Scheme_Object *system_library_subpath(int argc, Scheme_Object *argv[])
+{
+  return platform_path;
+}
+
+const char *scheme_system_library_subpath()
+{
+  return SCHEME_PLATFORM_LIBRARY_SUBPATH;
+}
diff --git a/src/mzscheme/src/struct.c b/src/mzscheme/src/struct.c
new file mode 100644
index 0000000..39b3924
--- /dev/null
+++ b/src/mzscheme/src/struct.c
@@ -0,0 +1,1229 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+
+typedef struct {
+  Scheme_Type type;
+  Scheme_Object *name;
+  Scheme_Object *fields;
+  Scheme_Object *parent_type_expr;
+  int num_fields;
+  int count;
+  Scheme_Object **memo_names; /* Memoize name generation */
+} Struct_Info;
+
+typedef enum {
+  SCHEME_CONSTR = 1, 
+  SCHEME_PRED, 
+  SCHEME_GETTER, 
+  SCHEME_SETTER
+} Scheme_ProcT;
+
+typedef struct {
+  Scheme_Struct_Type *struct_type;
+  Scheme_Object *func_name;
+  short field;
+} Struct_Proc_Info;
+
+typedef struct {
+  int num_levels;
+  int *levels;
+  Scheme_Hash_Table **tables;
+  Scheme_Object *elsep;
+} Struct_Case;
+
+/* globals */
+Scheme_Object *scheme_arity_at_least, *scheme_date;
+
+/* locals */
+#ifdef USE_STRUCT_CASE  
+static Scheme_Object *make_struct_case(int argc, Scheme_Object **argv);
+#endif
+
+static Scheme_Object *struct_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *struct_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+
+static Scheme_Object *struct_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_type_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_length(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_ref(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *struct_to_vector(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *struct_setter_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_getter_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_pred_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *struct_constr_p(int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *make_struct_proc(Scheme_Struct_Type *struct_type, Scheme_Object *func_name, Scheme_ProcT proc_type, int field_num);
+
+static Scheme_Object *make_name(const char *pre, const char *tn, int tnl, const char *post1, const char *fn, int fnl, const char *post2);
+
+static Scheme_Object *struct_execute(Scheme_Object *form);
+
+static Scheme_Object *write_struct_info(Scheme_Object *obj);
+static Scheme_Object *read_struct_info(Scheme_Object *obj);
+
+#define cons scheme_make_pair
+#define _intern scheme_intern_symbol
+
+#define BUILTIN_STRUCT_FLAGS 0
+
+static Scheme_Object **as_names;
+static Scheme_Object **as_values;
+static int as_count;
+#ifdef TIME_SYNTAX
+static Scheme_Object **ts_names;
+static Scheme_Object **ts_values;
+static int ts_count;
+#endif
+#ifndef NO_UNIT_SYSTEM
+static Scheme_Object *signature;
+static Scheme_Object **us_names;
+static Scheme_Object **us_values;
+static int us_count;
+#endif
+
+static Scheme_Object *struct_symbol;
+
+void
+scheme_init_struct (Scheme_Env *env)
+{
+  int i;
+
+  if (scheme_starting_up) {
+    static const char *arity_fields[1] = { "value" };
+#ifdef TIME_SYNTAX
+    static const char *date_fields[9] = { "second", "minute", "hour",
+					    "day", "month", "year",
+					    "week-day", "year-day", "dst?" };
+#endif
+#ifndef NO_UNIT_SYSTEM
+    static const char *unit_fields[3] = { "unit", "imports", "exports" };
+#endif
+
+    REGISTER_SO(scheme_arity_at_least);
+    REGISTER_SO(as_names);
+    REGISTER_SO(as_values);
+#ifdef TIME_SYNTAX
+    REGISTER_SO(scheme_date);
+    REGISTER_SO(ts_names);
+    REGISTER_SO(ts_values);
+#endif
+#ifndef NO_UNIT_SYSTEM
+    REGISTER_SO(signature);
+    REGISTER_SO(us_names);
+    REGISTER_SO(us_values);
+#endif
+
+    REGISTER_SO(struct_symbol);
+
+    scheme_register_syntax("k", struct_execute);
+
+    struct_symbol = scheme_intern_symbol("#%struct");
+
+    scheme_install_type_writer(scheme_struct_info_type, write_struct_info);
+    scheme_install_type_reader(scheme_struct_info_type, read_struct_info);
+
+    scheme_arity_at_least = scheme_make_struct_type_from_string("arity-at-least", NULL, 1);
+
+    as_names = scheme_make_struct_names_from_array("arity-at-least",
+						   1, arity_fields,
+						   BUILTIN_STRUCT_FLAGS, 
+						   &as_count);
+
+#ifdef TIME_SYNTAX
+    scheme_date = scheme_make_struct_type_from_string("date", NULL, 9);
+
+    ts_names 
+      = scheme_make_struct_names_from_array("date",
+					    9, date_fields,
+					    BUILTIN_STRUCT_FLAGS, &ts_count);
+#endif
+
+#ifndef NO_UNIT_SYSTEM
+    signature = scheme_make_struct_type_from_string("unit-with-signature", NULL, 3);
+    us_names 
+      = scheme_make_struct_names_from_array("unit-with-signature",
+					    3, unit_fields,
+					    BUILTIN_STRUCT_FLAGS, &us_count);
+#endif
+
+  as_values = scheme_make_struct_values(scheme_arity_at_least, as_names, as_count, 
+					BUILTIN_STRUCT_FLAGS);
+#ifdef TIME_SYNTAX
+  ts_values = scheme_make_struct_values(scheme_date, ts_names, ts_count, 
+					BUILTIN_STRUCT_FLAGS);
+#endif
+#ifndef NO_UNIT_SYSTEM
+  us_values = scheme_make_struct_values(signature, us_names, us_count, 
+					BUILTIN_STRUCT_FLAGS);
+#endif
+  }
+
+  scheme_add_global_keyword("struct", 
+			    scheme_make_compiled_syntax(struct_syntax, 
+							struct_expand), 
+			    env);
+
+  scheme_add_global_constant("struct?",
+			    scheme_make_folding_prim(struct_p,
+						     "struct?",
+						     1, 1, 1),
+			    env);
+  scheme_add_global_constant("struct-type?",
+			    scheme_make_folding_prim(struct_type_p,
+						     "struct-type?",
+						     1, 1, 1),
+			    env);
+  scheme_add_global_constant("struct-length",
+			    scheme_make_folding_prim(struct_length,
+						     "struct-length",
+						     1, 1, 1),
+			    env);
+  scheme_add_global_constant("struct-ref",
+			    scheme_make_prim_w_arity(struct_ref,
+						     "struct-ref",
+						     2, 2),
+			    env);
+
+  scheme_add_global_constant("struct->vector",
+			    scheme_make_prim_w_arity(struct_to_vector,
+						     "struct->vector",
+						     1, 1),
+			    env);
+
+  scheme_add_global_constant("struct-setter-procedure?",
+			     scheme_make_prim_w_arity(struct_setter_p,
+						      "struct-setter-procedure?",
+						      1, 1),
+			    env);
+  scheme_add_global_constant("struct-getter-procedure?",
+			     scheme_make_prim_w_arity(struct_getter_p,
+						      "struct-getter-procedure?",
+						      1, 1),
+			    env);
+  scheme_add_global_constant("struct-predicate-procedure?",
+			     scheme_make_prim_w_arity(struct_pred_p,
+						      "struct-predicate-procedure?",
+						      1, 1),
+			    env);
+  scheme_add_global_constant("struct-constructor-procedure?",
+			     scheme_make_prim_w_arity(struct_constr_p,
+						      "struct-constructor-procedure?",
+						      1, 1),
+			    env);
+  
+#ifdef USE_STRUCT_CASE  
+  scheme_add_global_constant("make-struct-case",
+			     scheme_make_prim_w_arity(make_struct_case,
+						      "make-struct-case",
+						      2, 3),
+			     env);
+#endif
+
+  /* Add arity structure */
+  for (i = 0; i < as_count; i++)
+    scheme_add_global_constant(SCHEME_SYM_VAL(as_names[i]), as_values[i],
+			       env);
+
+#ifdef TIME_SYNTAX
+  for (i = 0; i < ts_count; i++)
+    scheme_add_global_constant(SCHEME_SYM_VAL(ts_names[i]), ts_values[i], 
+			       env);
+#endif
+
+#ifndef NO_UNIT_SYSTEM
+  for (i = 0; i < us_count; i++)
+    scheme_add_global_constant(SCHEME_SYM_VAL(us_names[i]), us_values[i], 
+			       env);  
+#endif
+}
+
+static void wrong_struct_type(Scheme_Object *name, 
+			      Scheme_Object *expected,
+			      Scheme_Object *received,
+			      int which, int argc,
+			      Scheme_Object **argv)
+{
+  if ((SCHEME_SYM_LEN(expected) == SCHEME_SYM_LEN(received))
+      && !strncmp(SCHEME_SYM_VAL(expected), 
+		  SCHEME_SYM_VAL(received),
+		  SCHEME_SYM_LEN(expected)))
+    scheme_raise_exn(MZEXN_APPLICATION_TYPE, argv[which], expected,
+			"%s: expects args of type <%s>; "
+			"given instance of a different <%s>",
+			scheme_symbol_name(name), 
+			scheme_symbol_name(expected), 
+			scheme_symbol_name(received));
+  else
+    scheme_wrong_type(scheme_symbol_name(name), 
+		      scheme_symbol_name(expected), 
+		      which, argc, argv);
+}
+
+#define STRUCT_TYPEP(st, v) \
+        ((st->name_pos <= v->stype->name_pos) \
+	 && (st == v->stype->parent_types[st->name_pos]))
+
+int scheme_is_struct_instance(Scheme_Object *type, Scheme_Object *v)
+{
+  Scheme_Struct_Type *stype =  (Scheme_Struct_Type *)type;
+  Scheme_Structure *s = (Scheme_Structure *)v;
+
+  return STRUCT_TYPEP(stype, s);
+}
+
+Scheme_Object *
+scheme_make_struct_instance(Scheme_Object *_stype, int argc, Scheme_Object **args)
+{
+  Scheme_Structure *inst;
+  Scheme_Struct_Type *stype;
+  int i;
+
+  stype = (Scheme_Struct_Type *)_stype;
+  
+  inst = (Scheme_Structure *)
+    scheme_malloc_tagged(sizeof(Scheme_Structure) 
+			 + ((stype->num_slots - 1) * sizeof(Scheme_Object *)));
+  
+  inst->type = scheme_structure_type;
+  inst->stype = stype;
+
+  for (i = 0; i < argc; i++)
+    inst->slots[i] = args[i];
+  
+  return (Scheme_Object *)inst;
+}
+
+static Scheme_Object *struct_pred(Scheme_Struct_Type *stype, int argc, Scheme_Object **args)
+{
+  if (SAME_TYPE(SCHEME_TYPE(args[0]), scheme_structure_type)
+      && STRUCT_TYPEP(stype, ((Scheme_Structure *)args[0])))
+    return scheme_true;
+  else
+    return scheme_false;
+}
+
+static Scheme_Object *struct_getter(Struct_Proc_Info *i, int argc, Scheme_Object **args)
+{
+  Scheme_Structure *inst;
+
+  if (NOT_SAME_TYPE(SCHEME_TYPE(args[0]), scheme_structure_type))
+    scheme_wrong_type(scheme_symbol_name(i->func_name), 
+		      scheme_symbol_name(i->struct_type->type_name), 
+		      0, argc, args);
+  
+  inst = (Scheme_Structure *)args[0];
+  if (!STRUCT_TYPEP(i->struct_type, inst))
+    wrong_struct_type(i->func_name, 
+		      i->struct_type->type_name, 
+		      SCHEME_STRUCT_NAME_SYM(inst), 
+		      0, argc, args);
+  
+  return inst->slots[i->field];
+}
+
+static Scheme_Object *struct_setter(Struct_Proc_Info *i, int argc, Scheme_Object **args)
+{
+  Scheme_Structure *inst;
+
+  if (NOT_SAME_TYPE(SCHEME_TYPE(args[0]), scheme_structure_type))
+    scheme_wrong_type(scheme_symbol_name(i->func_name), 
+		      scheme_symbol_name(i->struct_type->type_name), 
+		      0, argc, args);
+	
+  inst = (Scheme_Structure *)args[0];
+  if (!STRUCT_TYPEP(i->struct_type, inst))
+    wrong_struct_type(i->func_name, 
+		      i->struct_type->type_name, 
+		      SCHEME_STRUCT_NAME_SYM(inst),
+		      0, argc, args);
+	
+  inst->slots[i->field] = args[1];
+  
+  return scheme_void;
+}
+
+int scheme_equal_structs (Scheme_Object *obj1, Scheme_Object *obj2)
+{
+  Scheme_Structure *s1, *s2;
+  int i;
+
+  if (!SAME_TYPE(SCHEME_TYPE(obj1), scheme_structure_type)
+      || !SAME_TYPE(SCHEME_TYPE(obj2), scheme_structure_type))
+    return 0;
+
+  s1 = (Scheme_Structure *)obj1;
+  s2 = (Scheme_Structure *)obj2;
+
+  if (SCHEME_STRUCT_TYPE(s1) != SCHEME_STRUCT_TYPE(s2))
+    return 0;
+
+  for (i = SCHEME_STRUCT_NUM_SLOTS(s1); i--; )
+    if (!scheme_equal(s1->slots[i], s2->slots[i]))
+      return 0;
+
+  return 1;
+}
+
+static Scheme_Object *
+struct_p(int argc, Scheme_Object *argv[])
+{
+  return SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_structure_type)
+    ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+struct_type_p(int argc, Scheme_Object *argv[])
+{
+  return SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_struct_type_type)
+    ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+struct_length(int argc, Scheme_Object *argv[])
+{
+  Scheme_Structure *s;
+
+  if (NOT_SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_structure_type))
+    scheme_wrong_type("struct-length", "struct", 0, argc, argv);
+
+  s = (Scheme_Structure *)argv[0];
+
+  return scheme_make_integer(SCHEME_STRUCT_NUM_SLOTS(s));
+}
+
+static Scheme_Object *
+struct_ref(int argc, Scheme_Object *argv[])
+{
+  Scheme_Structure *s;
+  long i, m;
+  char *name = "struct-ref";
+
+  if (NOT_SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_structure_type))
+    scheme_wrong_type(name, "struct", 0, argc, argv);
+  
+  s = (Scheme_Structure *)argv[0];
+  m = SCHEME_STRUCT_NUM_SLOTS(s);
+
+  i = scheme_extract_index(name, 1, argc, argv, m);
+
+  if (i >= m)
+    scheme_raise_exn(MZEXN_APPLICATION_RANGE_BOUNDS_STRUCT,
+		     argv[1],
+		     scheme_make_integer(0),
+		     scheme_make_integer(m - 1),
+		     "%s: index %s out of range [%d, %d]",
+		     name, 
+		     scheme_make_provided_string(argv[1], 0, NULL), 
+		     0, m - 1);
+
+  return s->slots[i];
+}
+
+static Scheme_Object *struct_to_vector(int argc, Scheme_Object *argv[])
+{
+  Scheme_Structure *s;
+  Scheme_Object *v, **array;
+  int i, m;
+
+  if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_structure_type))
+    scheme_wrong_type("struct->vector", "struct", 0, argc, argv);
+
+  s = (Scheme_Structure *)argv[0];
+
+  m = SCHEME_STRUCT_NUM_SLOTS(s);
+
+  v = scheme_make_vector(m + 1, scheme_false);
+  array = SCHEME_VEC_ELS(v);
+  array[0] = SCHEME_STRUCT_NAME_SYM(s);
+  array++;
+  for (i = m; i--; )
+    array[i] = s->slots[i];
+
+  return v;
+}
+
+#define STRUCT_PROCP(o, t) \
+    (SCHEME_STRUCT_PROCP(o) && (((Scheme_Closed_Primitive_Proc *)o)->flags & t))
+
+static Scheme_Object *
+struct_setter_p(int argc, Scheme_Object *argv[])
+{
+  return (STRUCT_PROCP(argv[0], SCHEME_PRIM_IS_STRUCT_SETTER)
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+struct_getter_p(int argc, Scheme_Object *argv[])
+{
+  return (STRUCT_PROCP(argv[0], SCHEME_PRIM_IS_STRUCT_GETTER)
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+struct_pred_p(int argc, Scheme_Object *argv[])
+{
+  return (STRUCT_PROCP(argv[0], SCHEME_PRIM_IS_STRUCT_PRED)
+	  ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+struct_constr_p(int argc, Scheme_Object *argv[])
+{
+  return (STRUCT_PROCP(argv[0], SCHEME_PRIM_IS_STRUCT_CONSTR)
+	  ? scheme_true : scheme_false);
+}
+
+#define NUM_BASE_VALUES 3
+#define NUM_VALUES_PER_FIELD 2
+
+#define TYPE_NAME(base, blen) make_name("struct:", base, blen, "", NULL, 0, "")
+#define CSTR_NAME(base, blen) make_name("make-", base, blen, "", NULL, 0, "")
+#define PRED_NAME(base, blen) make_name("", base, blen, "?", NULL, 0, "")
+#define GET_NAME(base, blen, field, flen) make_name("", base, blen, "-", field, flen, "")
+#define SET_NAME(base, blen, field, flen) make_name("set-", base, blen, "-", field, flen, "!")
+
+Scheme_Object **scheme_make_struct_values(Scheme_Object *type,
+					  Scheme_Object **names,
+					  int count,
+					  int flags)
+{
+  Scheme_Struct_Type *struct_type;
+  Scheme_Object **values;
+  int slot_num, pos;
+
+  struct_type = (Scheme_Struct_Type *)type;
+
+  values = (Scheme_Object **)scheme_malloc_stubborn(count * sizeof(Scheme_Object *));
+ 
+#ifdef MEMORY_COUNTING_ON
+  if (scheme_starting_up) {
+    /* We know that these values will be kept (exns, arity-at-least, etc.). */
+    scheme_misc_count += count * sizeof(Scheme_Object *);
+  }
+#endif
+
+  pos = 0;
+  if (!(flags & SCHEME_STRUCT_NO_TYPE))
+    values[pos++] = (Scheme_Object *)struct_type;
+  if (!(flags & SCHEME_STRUCT_NO_CONSTR))
+    values[pos++] = make_struct_proc(struct_type,
+				     names[pos],
+				     SCHEME_CONSTR, 
+				     struct_type->num_slots);
+  if (!(flags & SCHEME_STRUCT_NO_PRED))
+    values[pos++] = make_struct_proc(struct_type,
+				     names[pos],
+				     SCHEME_PRED,
+				     0);
+
+  slot_num = (struct_type->name_pos
+	      ? struct_type->parent_types[struct_type->name_pos - 1]->num_slots 
+	      : 0);
+  while (pos < count) {
+    if (!(flags & SCHEME_STRUCT_NO_GET))
+      values[pos++] = make_struct_proc(struct_type,
+				       names[pos],
+				       SCHEME_GETTER,
+				       slot_num);
+    
+    if (!(flags & SCHEME_STRUCT_NO_SET))
+      values[pos++] = make_struct_proc(struct_type,
+				       names[pos],
+				       SCHEME_SETTER,
+				       slot_num);
+    slot_num++;
+  }
+  
+  scheme_end_stubborn_change((void *)values);
+ 
+  return values;
+}
+
+static Scheme_Object **_make_struct_names(const char *base, int blen,
+					  int fcount,
+					  Scheme_Object *field_symbols,
+					  const char **field_strings,
+					  int flags, int *count_out)
+{
+  Scheme_Object **names;
+  const char *field_name;
+  int count, fnlen;
+  int slot_num, pos;
+
+  count = 0;
+
+  if (!(flags & SCHEME_STRUCT_NO_TYPE))
+    count++;
+  if (!(flags & SCHEME_STRUCT_NO_CONSTR))
+    count++;
+  if (!(flags & SCHEME_STRUCT_NO_PRED))
+    count++;
+  if (!(flags & SCHEME_STRUCT_NO_GET))
+    count += fcount;
+  if (!(flags & SCHEME_STRUCT_NO_SET))
+    count += fcount;
+
+  names = (Scheme_Object **)scheme_malloc_stubborn(count * sizeof(Scheme_Object *));
+
+#ifdef MEMORY_COUNTING_ON
+  if (scheme_starting_up) {
+    /* We know that these names will be kept (exns, arity-at-least, etc.). */
+    scheme_misc_count += count * sizeof(Scheme_Object *);
+  }
+#endif
+
+  pos = 0;
+
+  if (!(flags & SCHEME_STRUCT_NO_TYPE))
+    names[pos++] = TYPE_NAME(base, blen);
+  if (!(flags & SCHEME_STRUCT_NO_CONSTR))
+    names[pos++] = CSTR_NAME(base, blen);
+  if (!(flags & SCHEME_STRUCT_NO_PRED))
+    names[pos++] = PRED_NAME(base, blen);
+
+  if (fcount) {
+    for (slot_num = 0; slot_num < fcount; slot_num++) {
+      if (field_symbols) {
+	Scheme_Object *fn = SCHEME_CAR(field_symbols);
+	field_symbols = SCHEME_CDR(field_symbols);
+
+	field_name = SCHEME_SYM_VAL(fn);
+	fnlen = SCHEME_SYM_LEN(fn);
+      } else {
+	field_name = field_strings[slot_num];
+	fnlen = strlen(field_name);
+      }
+
+      if (!(flags & SCHEME_STRUCT_NO_GET))
+	names[pos++] = GET_NAME(base, blen, field_name, fnlen);
+      if (!(flags & SCHEME_STRUCT_NO_SET))
+	names[pos++] = SET_NAME(base, blen, field_name, fnlen);
+    }
+  }
+
+  scheme_end_stubborn_change((void *)names);
+
+  if (count_out)
+    *count_out = count;
+
+  return names;
+}
+
+Scheme_Object **scheme_make_struct_names(Scheme_Object *base, 
+					 Scheme_Object *field_symbols,
+					 int flags, int *count_out)
+{
+  return _make_struct_names(SCHEME_SYM_VAL(base),
+			    SCHEME_SYM_LEN(base),
+			    field_symbols ? scheme_list_length(field_symbols) : 0,
+			    field_symbols, NULL,
+			    flags, count_out);
+}
+
+Scheme_Object **scheme_make_struct_names_from_array(const char *base, 
+						    int fcount,
+						    const char **fields,
+						    int flags, int *count_out)
+{
+  return _make_struct_names(base,
+			    strlen(base),
+			    fcount,
+			    NULL, fields,
+			    flags, count_out);
+}
+
+static Scheme_Object *_make_struct_type(const char *base, int blen,
+					Scheme_Object *parent,
+					int num_fields)
+{
+  Scheme_Struct_Type *struct_type, *parent_type;
+  int j, depth;
+  
+  parent_type = (Scheme_Struct_Type *)parent;
+
+  depth = parent_type ? (1 + parent_type->name_pos) : 0;
+
+  struct_type =(Scheme_Struct_Type *)scheme_malloc_tagged(sizeof(Scheme_Struct_Type)
+							  + (depth 
+							     * sizeof(Scheme_Struct_Type *)));
+  
+  struct_type->type = scheme_struct_type_type;
+  struct_type->name_pos = depth;
+  struct_type->parent_types[depth] = struct_type;
+  for (j = depth; j--; )
+    struct_type->parent_types[j] = parent_type->parent_types[j];
+
+  struct_type->type_name = TYPE_NAME(base, blen);
+  struct_type->num_slots = num_fields + (parent_type ? parent_type->num_slots : 0);
+
+  return (Scheme_Object *)struct_type;
+}
+
+Scheme_Object *scheme_make_struct_type(Scheme_Object *base,
+				       Scheme_Object *parent,
+				       int num_fields)
+{
+  return _make_struct_type(SCHEME_SYM_VAL(base),
+			   SCHEME_SYM_LEN(base),
+			   parent, num_fields);
+}
+
+Scheme_Object *scheme_make_struct_type_from_string(const char *base,
+						   Scheme_Object *parent,
+						   int num_fields)
+{
+  return _make_struct_type(base, strlen(base), parent, num_fields);
+}
+
+static Scheme_Object *
+struct_execute (Scheme_Object *form)
+{
+  Struct_Info *info;
+  Scheme_Object **values, **names, *parent;
+  Scheme_Object *type;
+
+  info = (Struct_Info *)form;
+
+  parent = (SCHEME_NULLP(info->parent_type_expr)
+	    ? NULL 
+	    : _scheme_eval_compiled_expr(info->parent_type_expr));
+
+  if (parent && !SAME_TYPE(SCHEME_TYPE(parent),
+			   scheme_struct_type_type))
+    scheme_raise_exn(MZEXN_STRUCT_STRUCT_TYPE, parent,
+		     "struct: supertype expression returned "
+		     "a value that is not a struct type value");
+  
+  type = scheme_make_struct_type(info->name, 
+				 parent, 
+				 info->num_fields);
+
+  if (!info->memo_names)
+    info->memo_names = scheme_make_struct_names(info->name,
+						info->fields,
+						0, 
+						&info->count);
+  names = info->memo_names;
+
+  values = scheme_make_struct_values(type, names, info->count, 0);
+
+  return scheme_values(info->count, values);
+}
+
+static Scheme_Object *
+struct_link(Scheme_Object *expr, Link_Info *info)
+{
+  Struct_Info *sinfo;
+
+  sinfo = (Struct_Info *)expr;
+
+  if (sinfo->parent_type_expr)
+    sinfo->parent_type_expr = scheme_link_expr(sinfo->parent_type_expr, info);
+
+  return scheme_make_syntax_link(struct_execute, expr);
+}
+
+static Scheme_Object *
+do_struct_syntax (Scheme_Object *forms, Scheme_Comp_Env *env, 
+		  Scheme_Compile_Info *in_rec, int depth)
+{
+  Struct_Info *info;
+  Scheme_Object *base_symbol, *field_symbols, *l, *form, *parent_expr;
+  int count;
+
+  form = SCHEME_CDR(forms);
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax("struct", form, forms, NULL);
+  base_symbol = SCHEME_CAR (form);
+  form = SCHEME_CDR(form);
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax("struct", form, forms, NULL);
+  field_symbols = SCHEME_CAR (form);
+  form = SCHEME_CDR(form);
+  if (!SCHEME_NULLP(form))
+    scheme_wrong_syntax("struct", form, forms, NULL);
+
+  if (SCHEME_PAIRP(base_symbol)) {
+    parent_expr = SCHEME_CDR(base_symbol);
+    base_symbol = SCHEME_CAR(base_symbol);
+    if (!SCHEME_PAIRP(parent_expr) || !SCHEME_NULLP(SCHEME_CDR(parent_expr))) {
+      scheme_wrong_syntax("struct", parent_expr, forms, "improper name-parent expression");
+      return NULL;
+    }
+    if (in_rec)
+      parent_expr = scheme_compile_expr(SCHEME_CAR(parent_expr), env, in_rec);
+    else
+      parent_expr = scheme_expand_expr(SCHEME_CAR(parent_expr), env, depth);
+  } else {
+    parent_expr = NULL;
+
+    if (in_rec)
+      in_rec->max_let_depth = 0;
+  }
+
+  if (!SCHEME_SYMBOLP(base_symbol))
+    scheme_wrong_syntax("struct", base_symbol, form, "struct name must be an identifier");
+  
+  if (in_rec) {
+    info = (Struct_Info *)scheme_malloc_tagged(sizeof(Struct_Info));
+    info->type = scheme_struct_info_type;
+    
+    info->name = base_symbol;
+    info->fields = field_symbols;
+    info->parent_type_expr = parent_expr ? parent_expr : scheme_null;
+  } else
+    info = NULL;
+
+  count = 0;
+  l = field_symbols;
+  while (!SCHEME_NULLP(l)) {
+    count++;
+    if (!SCHEME_PAIRP(l))
+      scheme_wrong_syntax("struct", l, form, "badly formed field list");
+    if (!SCHEME_SYMBOLP(SCHEME_CAR(l)))
+      scheme_wrong_syntax("struct", SCHEME_CAR(l), 
+			  form, "field name must be an identifier");
+    l = SCHEME_CDR(l);
+  }
+
+  if (in_rec) {
+    info->num_fields = count;
+
+    if (in_rec->can_optimize_constants)
+      info->memo_names = scheme_make_struct_names(info->name,
+						  info->fields,
+						  0, 
+						  &info->count);
+    else
+      info->memo_names = NULL;
+
+    return scheme_make_syntax_compile(struct_link, (Scheme_Object *)info);
+  } else
+    return cons(struct_symbol,
+		cons(parent_expr 
+		     ? cons(base_symbol,
+			    cons(parent_expr, scheme_null))
+		     : base_symbol,
+		     cons(field_symbols, scheme_null)));
+}
+
+static Scheme_Object *
+struct_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		   Scheme_Compile_Info *rec)
+{
+  return do_struct_syntax(form, env, rec, 0);
+}
+
+static Scheme_Object *
+struct_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_struct_syntax(form, env, NULL, depth);
+}
+
+static Scheme_Object *
+make_struct_proc(Scheme_Struct_Type *struct_type, 
+		 Scheme_Object *func_name, 
+		 Scheme_ProcT proc_type, int field_num)
+{
+  Scheme_Object *p;
+  short flags = SCHEME_PRIM_IS_STRUCT_PROC;
+
+  if (proc_type == SCHEME_CONSTR) {
+    p = scheme_make_folding_closed_prim((Scheme_Closed_Prim *)scheme_make_struct_instance,
+					(void *)struct_type,
+					scheme_symbol_name(func_name),
+					struct_type->num_slots,
+					struct_type->num_slots,
+					0);
+    flags |= SCHEME_PRIM_IS_STRUCT_CONSTR;
+  } else if (proc_type == SCHEME_PRED) {
+    p = scheme_make_folding_closed_prim((Scheme_Closed_Prim *)struct_pred,
+					(void *)struct_type,
+					scheme_symbol_name(func_name),
+					1, 1, 1);
+    flags |= SCHEME_PRIM_IS_STRUCT_PRED;
+  } else {
+    Struct_Proc_Info *i;
+
+    i = (Struct_Proc_Info *)scheme_malloc(sizeof(Struct_Proc_Info));
+    i->struct_type = struct_type;
+    i->func_name = func_name;
+    i->field = field_num;
+
+    if (proc_type == SCHEME_GETTER) {
+      p = scheme_make_folding_closed_prim((Scheme_Closed_Prim *)struct_getter,
+					  (void *)i,
+					  scheme_symbol_name(func_name),
+					  1, 1, 1);
+      flags |= SCHEME_PRIM_IS_STRUCT_GETTER;
+    } else {
+      p = scheme_make_folding_closed_prim((Scheme_Closed_Prim *)struct_setter,
+					  (void *)i,
+					  scheme_symbol_name(func_name),
+					  2, 2, 0);
+      flags |= SCHEME_PRIM_IS_STRUCT_SETTER;
+    }
+  }
+
+  ((Scheme_Closed_Primitive_Proc *)p)->flags |= flags;
+
+  return p;
+}
+
+static Scheme_Object *make_name(const char *pre, const char *tn, int ltn,
+				const char *post1, const char *fn, int lfn,
+				const char *post2)
+{
+  int total, lp, lp1, lp2;
+  char *name, buffer[256];
+
+  total = lp = strlen(pre);
+  total += ltn;
+  total += (lp1 = strlen(post1));
+  total += lfn;
+  total += (lp2 = strlen(post2));
+
+  if (total < 256)
+    name = buffer;
+  else
+    name = (char *)scheme_malloc_atomic(sizeof(char)*(total + 1));
+  
+  memcpy(name, pre, lp);
+  total = lp;
+  memcpy(name + total, tn, ltn);
+  total += ltn;
+  memcpy(name + total, post1, lp1);
+  total += lp1;
+  memcpy(name + total, fn, lfn);
+  total += lfn;
+  memcpy(name + total, post2, lp2);
+  total += lp2;
+
+  name[total] = 0;
+
+  return scheme_intern_symbol(name);
+}
+
+#ifdef USE_STRUCT_CASE  
+static Scheme_Object *do_struct_case(void *d, int argc, Scheme_Object **argv)
+{
+  Scheme_Object *s = argv[0];
+  Struct_Case *c = (Struct_Case *)d;
+  Scheme_Struct_Type *t;
+  int level, i, *levels;
+
+  if (!SCHEME_STRUCTP(s)) {
+    scheme_wrong_type("#<struct-case>", "struct", 0, argc, argv);
+    return NULL;
+  }
+  
+  t = SCHEME_STRUCT_TYPE(s);
+  level = t->name_pos;
+
+  levels = c->levels;
+  i = c->num_levels; 
+  while (i--) {
+    if (levels[i] <= level) {
+      do {
+	Scheme_Struct_Type *st = t->parent_types[levels[i]];
+	Scheme_Object *o;
+
+	o = (Scheme_Object *)scheme_lookup_in_table(c->tables[i], 
+						    (const char *)st);
+	if (o) {
+	  Scheme_Object **v;
+	  Scheme_Process *p = scheme_current_process;
+
+	  v = scheme_tail_apply_buffer_wp(1, p);
+	  v[0] = argv[0];
+
+	  return _scheme_tail_apply_no_copy_wp(o, 1, v, p);
+	}
+      } while (i--);
+
+      break;
+    }
+  }
+
+  if (c->elsep) {
+    Scheme_Object **v;
+    Scheme_Process *p = scheme_current_process;
+    
+    v = scheme_tail_apply_buffer_wp(1, p);
+    v[0] = argv[0];
+    
+    return _scheme_tail_apply_no_copy_wp(c->elsep, 1, v, p);
+  }
+  
+  scheme_raise_else("#<struct-case>", argv[0]);
+
+  return NULL;
+}
+
+#define PREDICATE_TYPE(p) ((Scheme_Struct_Type *)((Scheme_Closed_Primitive_Proc *)p)->data)
+
+static Scheme_Object *make_struct_case(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *types, *procs, *l, *conflict_base = NULL, *conflict_sub = NULL;
+  Struct_Case *c;
+  Scheme_Hash_Table **tables;
+  int i, count, *levels, num_levels;
+  
+  types = argv[0];
+  procs = argv[1];
+
+  num_levels = 0;
+  levels = NULL;
+  tables = NULL;
+
+  for (count = 0, l = types; SCHEME_PAIRP(l); l = SCHEME_CDR(l), count++) {
+    Scheme_Object *o = SCHEME_CAR(l);
+    if (!STRUCT_PROCP(o, SCHEME_PRIM_IS_STRUCT_PRED))
+      break;
+  }
+
+  if (!SCHEME_NULLP(l)) {
+    scheme_wrong_type("make-struct-case", "list of struct predicate procedures",
+		      0, argc, argv);
+    return NULL;
+  }
+
+
+  for (i = 0, l = procs; SCHEME_PAIRP(l); l = SCHEME_CDR(l), i++) {
+    Scheme_Object *p = SCHEME_CAR(l);
+    if (!scheme_check_proc_arity(NULL, 1, -1, 0, &p))
+      break;
+  }
+
+  if (!SCHEME_NULLP(l)) {
+    scheme_wrong_type("make-struct-case", "list of procedures (arity 1)",
+		      1, argc, argv);
+    return NULL;
+  }
+
+
+  if (argc == 3)
+    scheme_check_proc_arity("#<struct-case>", 1, 2, argc, argv);
+
+  if (i != count) {
+    scheme_raise_exn(MZEXN_APPLICATION_LIST_SIZES,
+		     procs,
+		     "make-struct-case: given %d struct-type%s and "
+		     "%d procedure%s",
+		     count,
+		     (count == 1) ? "s" : "",
+		     i,
+		     (i == 1) ? "s" : "");
+    return NULL;
+  }
+
+
+  for (count = 0; 
+       SCHEME_PAIRP(types) && SCHEME_PAIRP(procs); 
+       types = SCHEME_CDR(types), procs = SCHEME_CDR(procs), count++) {
+    Scheme_Object *f = SCHEME_CAR(types), *p = SCHEME_CAR(procs);
+    Scheme_Struct_Type *t;
+    int level;
+
+    t = PREDICATE_TYPE(f);
+
+    level = t->name_pos;
+    for (i = 0; i < num_levels; i++)
+      if (levels[i] == level) {
+	if (!conflict_base) {
+	  if (!scheme_lookup_in_table(tables[i], (const char *)t))
+	    scheme_add_to_table(tables[i], (const char *)t, p, 0);
+	  else {
+	    conflict_base = conflict_sub = (Scheme_Object *)f;
+	  }
+	}
+
+	break;
+      }
+    if (i == num_levels) {
+      int *naya, j, k, unset = 1;
+      Scheme_Hash_Table **tnaya, *newtable;
+
+      naya = (int *)scheme_malloc_atomic(sizeof(int) * (num_levels + 1));
+      tnaya = (Scheme_Hash_Table **)scheme_malloc((num_levels + 1) * 
+						  sizeof(Scheme_Hash_Table *));
+
+      newtable = scheme_hash_table(7, SCHEME_hash_ptr, 0, 0);
+      scheme_add_to_table(newtable, (const char *)t, p, 0);
+
+      for (j = k = 0; j < num_levels; j++, k++) {
+	if (unset) {
+	  if (level < levels[j]) {
+	    tnaya[k] = newtable;
+	    naya[k++] = level;
+	    unset = 0;
+	  } else if (!conflict_base) {
+	    Scheme_Struct_Type *st;
+	    st = t->parent_types[levels[j]];
+	    if (scheme_lookup_in_table(tables[j], (const char *)st)) {
+	      conflict_base = (Scheme_Object *)st;
+	      conflict_sub = (Scheme_Object *)f;
+	    }
+	  }
+	}
+	tnaya[k] = tables[j];
+	naya[k] = levels[j];
+      }
+      if (unset) {
+	naya[k] = level;
+	tnaya[k] = newtable;
+      }
+
+      levels = naya;
+      tables = tnaya;
+      num_levels++;
+    }
+  }
+
+  if (conflict_base) {
+    if (SAME_OBJ(conflict_base, conflict_sub)) {
+      scheme_raise_exn(MZEXN_APPLICATION_STRUCT_TYPE_CONFLICT,
+		       conflict_sub,
+		       conflict_base,
+		       "make-struct-case: predicate for %s specified twice",
+		       scheme_symbol_name(PREDICATE_TYPE(conflict_sub)->type_name));
+    } else {
+      /* Need to map conflict_base type back to predicate: */
+      for (l = argv[0]; 1; l = SCHEME_CDR(l)) {
+	Scheme_Object *p = SCHEME_CAR(l);
+	if (SAME_OBJ((Scheme_Object *)PREDICATE_TYPE(p), conflict_base)) {
+	  conflict_base = p;
+	  break;
+	}
+      }
+
+      scheme_raise_exn(MZEXN_APPLICATION_STRUCT_TYPE_CONFLICT,
+		       conflict_sub,
+		       conflict_base,
+		       "make-struct-case: the predicate for %s entails the predicate for %s "
+		       " that was specified later",
+		       scheme_symbol_name(PREDICATE_TYPE(conflict_base)->type_name),
+		       scheme_symbol_name(PREDICATE_TYPE(conflict_sub)->type_name));
+    }
+
+    return NULL;
+  }
+
+  c = MALLOC_ONE(Struct_Case);
+
+  c->num_levels = num_levels;
+  c->levels = levels;
+  c->tables = tables;
+  c->elsep = ((argc == 3) ? argv[2] : NULL);
+
+  return scheme_make_closed_prim_w_arity(do_struct_case,
+					 c, "struct-case",
+					 1, 1);
+}
+#endif
+
+/************************************************************************/
+
+#define cons scheme_make_pair
+
+static Scheme_Object *write_struct_info(Scheme_Object *obj)
+{
+  Struct_Info *info;
+
+  info = (Struct_Info *)obj;
+
+  return cons(scheme_make_integer(info->count),
+	      cons(scheme_make_integer(info->num_fields),
+		   cons(info->name, 
+			cons(info->parent_type_expr,
+			     info->fields))));
+}
+
+#define X_SCHEME_ASSERT(x, y)
+
+static Scheme_Object *read_struct_info(Scheme_Object *obj)
+{
+  Scheme_Object *v, *first = scheme_null, *last = NULL;
+  Struct_Info *info;
+
+#define BAD_CS "bad compiled structure info"
+
+  info = (Struct_Info *)scheme_malloc_stubborn_tagged(sizeof(Struct_Info));
+  info->type = scheme_struct_info_type;
+
+  X_SCHEME_ASSERT(SCHEME_PAIRP(obj), BAD_CS);
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  X_SCHEME_ASSERT(SCHEME_INTP(v), BAD_CS);
+  info->count = SCHEME_INT_VAL(v);
+
+  X_SCHEME_ASSERT(SCHEME_PAIRP(obj), BAD_CS);
+  v = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  X_SCHEME_ASSERT(SCHEME_INTP(v), BAD_CS);
+  info->num_fields = SCHEME_INT_VAL(v);
+
+  X_SCHEME_ASSERT(SCHEME_PAIRP(obj), BAD_CS);
+  info->name = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  
+  X_SCHEME_ASSERT(SCHEME_PAIRP(obj), BAD_CS);
+  info->parent_type_expr = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+  
+  X_SCHEME_ASSERT(SCHEME_LISTP(obj), BAD_CS);
+
+  /* must copy obj */
+  while (SCHEME_PAIRP(obj)) {
+    Scheme_Object *pair = scheme_make_pair(SCHEME_CAR(obj), scheme_null);
+
+    if (last)
+      SCHEME_CDR(last) = pair;
+    else
+      first = pair;
+    last = pair;
+
+    obj = SCHEME_CDR(obj);
+  }
+
+  info->fields = first;
+
+  info->memo_names = NULL;
+  
+  scheme_end_stubborn_change((void *)info);
+
+  return (Scheme_Object *)info;
+}
+
+#ifdef MEMORY_COUNTING_ON
+void scheme_count_struct_info(Scheme_Object *o, long *s, long *e, 
+			      Scheme_Hash_Table *ht)
+{
+  Struct_Info *info = (Struct_Info *)o;
+
+  *s = sizeof(Struct_Info);
+  *e = scheme_count_memory(info->name, ht)
+     + scheme_count_memory(info->parent_type_expr, ht)
+     + scheme_count_memory(info->fields, ht);
+}
+#endif
diff --git a/src/mzscheme/src/stypes.h b/src/mzscheme/src/stypes.h
new file mode 100644
index 0000000..e90fc47
--- /dev/null
+++ b/src/mzscheme/src/stypes.h
@@ -0,0 +1,116 @@
+
+enum {
+
+  /* compiled object types: (internal) */
+  scheme_variable_type,
+  scheme_local_type, 
+  scheme_local_unbox_type,
+  scheme_syntax_type,
+  scheme_application_type,
+  scheme_sequence_type,
+  scheme_branch_type,
+  scheme_unclosed_procedure_type,
+  scheme_let_value_type,
+  scheme_let_void_type,
+  scheme_letrec_type, /* 10 */
+  scheme_let_one_type,
+
+  _scheme_values_types_, /* All following types are values */
+  
+  /* intermediate compiled: */
+  scheme_compiled_unclosed_procedure_type,
+  scheme_compiled_let_value_type,
+  scheme_compiled_let_void_type,
+  scheme_compiled_syntax_type,
+
+  scheme_quote_compilation_type,
+
+  _scheme_compiled_values_types_,
+
+  /* procedure types */
+  scheme_prim_type, /* 19 */
+  scheme_closed_prim_type, /* 20 */
+  scheme_linked_closure_type,
+  scheme_case_closure_type,
+  scheme_cont_type,
+  scheme_escaping_cont_type,
+
+  /* basic types */
+  scheme_char_type, /* 25 */
+  scheme_integer_type,
+  scheme_bignum_type,
+  scheme_rational_type,
+  scheme_float_type,
+  scheme_double_type, /* 30 */
+  scheme_complex_type,
+  scheme_string_type,
+  scheme_symbol_type,
+  scheme_null_type,
+  scheme_pair_type,
+  scheme_vector_type,
+  scheme_closure_type,
+  scheme_input_port_type,
+  scheme_output_port_type,
+  scheme_eof_type,   /* 40 */
+  scheme_true_type,
+  scheme_false_type, 
+  scheme_void_type,
+  scheme_syntax_compiler_type,
+  scheme_macro_type,
+  scheme_promise_type,
+  scheme_box_type,
+  scheme_process_type,
+  scheme_object_type,
+  scheme_class_type,  /* 50 */
+  scheme_structure_type,
+  scheme_generic_type, 
+  scheme_type_symbol_type, 
+  scheme_sema_type,
+  scheme_hash_table_type,
+  scheme_generic_data_type,
+  scheme_weak_box_type, 
+  scheme_struct_type_type,
+  scheme_id_macro_type,
+  scheme_unit_type,  /* 60 */
+  scheme_exp_time_type,
+  scheme_listener_type,
+  scheme_namespace_type, 
+  scheme_config_type,
+  scheme_defaulting_config_type, 
+  scheme_will_executor_type,
+  scheme_interface_type,
+  scheme_manager_type,
+
+  /* These reserved types will let us add types
+     without forcing recompilation of compiled MzScheme code */
+  scheme_reserved_4_type,
+
+  /* more internal types: */
+  scheme_compilation_top_type, /* 70 */
+
+  scheme_envunbox_type,
+  scheme_eval_waiting_type,
+  scheme_tail_call_waiting_type,
+  scheme_class_data_type,
+  scheme_undefined_type, 
+  scheme_struct_info_type,
+  scheme_multiple_values_type,
+  scheme_reserved_5_type,
+  scheme_placeholder_type,
+  scheme_case_lambda_sequence_type, /* 80 */
+  scheme_begin0_sequence_type,
+
+  scheme_compiled_unit_type,
+  scheme_unit_body_data_type,
+  scheme_unit_body_closure_data_type,
+  scheme_unit_compound_data_type,
+  scheme_invoke_unit_data_type,
+
+  scheme_interface_data_type,
+
+  scheme_svector_type,
+
+  _scheme_last_type_
+};
+
+extern char *scheme_get_type_name(Scheme_Type type);
diff --git a/src/mzscheme/src/symbol.c b/src/mzscheme/src/symbol.c
new file mode 100644
index 0000000..38dbc0f
--- /dev/null
+++ b/src/mzscheme/src/symbol.c
@@ -0,0 +1,469 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <string.h>
+#include <ctype.h>
+#include "schgc.h"
+
+#ifdef SMALL_HASH_TABLES
+# define HASH_TABLE_SIZE 2500
+# define FILL_FACTOR 1.30
+#else
+# define HASH_TABLE_SIZE 10313
+# define FILL_FACTOR 2
+#endif
+
+extern void (*GC_custom_finalize)(void);
+#ifndef USE_SENORA_GC
+extern int GC_is_marked(void *);
+#endif
+
+Scheme_Hash_Table *scheme_symbol_table = NULL;
+
+long scheme_max_found_symbol_name;
+
+/* globals */
+int scheme_case_sensitive;
+
+/* locals */
+static Scheme_Object *symbol_p_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_to_symbol_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_to_uninterned_symbol_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *symbol_to_string_prim (int argc, Scheme_Object *argv[]);
+static Scheme_Object *gensym(int argc, Scheme_Object *argv[]);
+
+static int gensym_counter;
+
+/**************************************************************************/
+
+typedef int hash_v_t;
+
+extern int scheme_hash_primes[];
+
+/* Special hashing for symbols: */
+static Scheme_Object *symbol_bucket(Scheme_Hash_Table *table, 
+				    const char *key, int length,
+				    Scheme_Object *naya)
+{
+  hash_v_t h, h2;
+  Scheme_Bucket *bucket;
+
+ rehash_key:
+
+  {
+    int i;
+    h2 = h = i = 0;
+    while (i < length) {
+      int c = key[i++];
+      h += (h << 5) + h + c;
+      h2 += c;
+    }
+    h = h % table->size;
+    h2 = h2 % table->size;
+  }
+
+  if (h < 0) h = -h;
+
+  if (!h2)
+    h2 = 2;
+  else if (h2 & 0x1)
+    h2++;
+
+  if (h2 < 0)
+    h2 = -h2;
+
+  while ((bucket = table->buckets[h])) {
+    if (SAME_OBJ((Scheme_Object *)bucket, scheme_false)) {
+      if (naya)
+	break;
+    } else if ((length == SCHEME_SYM_LEN(bucket))
+	&& !memcmp(key, SCHEME_SYM_VAL(bucket), length))
+      return (Scheme_Object *)bucket;
+    h = (h + h2) % table->size;
+  }
+
+  if (!naya)
+    return NULL;
+
+  if (table->count * FILL_FACTOR >= table->size) {
+    /* Rehash */
+    int i, oldsize = table->size, newsize;
+    size_t asize;
+    Scheme_Bucket **old = table->buckets;
+
+    newsize = scheme_hash_primes[++table->step];
+    
+    asize = (size_t)newsize * sizeof(Scheme_Bucket *);
+    table->buckets = (Scheme_Bucket **)scheme_malloc_atomic(asize);
+    table->size = newsize;
+    memset((char *)table->buckets, 0, asize);
+
+    table->count = 0;
+    for (i = 0; i < oldsize; i++)
+      if (old[i] && !SAME_OBJ((Scheme_Object *)old[i], scheme_false))
+	symbol_bucket(table, SCHEME_SYM_VAL(old[i]), SCHEME_SYM_LEN(old[i]),
+		      (Scheme_Object *)old[i]);
+    
+    goto rehash_key;
+  }
+
+  table->buckets[h] = (Scheme_Bucket *)naya;
+
+  table->count++;
+
+  return naya;
+}
+
+static void clean_symbol_table(void)
+{
+  /* Clean the symbol table by removing pointers to collected
+     symbols. The correct way to do this is to install a GC
+     finalizer on symbol pointers, but that would be expensive. */
+     
+  if (scheme_symbol_table) {
+    Scheme_Object **buckets = (Scheme_Object **)scheme_symbol_table->buckets;
+    int i = scheme_symbol_table->size;
+    void *b;
+    
+    while (i--) {
+      if (buckets[i] && !SAME_OBJ(buckets[i], scheme_false)
+	  && (!(b = GC_base(buckets[i]))
+#ifndef USE_SENORA_GC
+	      || !GC_is_marked(b)
+#endif
+	      ))
+	buckets[i] = scheme_false;
+    }
+  }
+}
+
+/**************************************************************************/
+
+void
+scheme_init_symbol_table ()
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(scheme_symbol_table);
+
+    scheme_symbol_table = scheme_hash_table(HASH_TABLE_SIZE, 
+					    SCHEME_hash_ptr, 0, 1);
+
+    GC_custom_finalize = clean_symbol_table;
+  }
+}
+
+void
+scheme_init_symbol_type (Scheme_Env *env)
+{
+}
+
+void
+scheme_init_symbol (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+  }
+
+  scheme_add_global_constant("symbol?", 
+			     scheme_make_folding_prim(symbol_p_prim, 
+						      "symbol?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("string->symbol", 
+			     scheme_make_prim_w_arity(string_to_symbol_prim,
+						      "string->symbol",
+						      1, 1), env);
+  scheme_add_global_constant("string->uninterned-symbol", 
+			     scheme_make_prim_w_arity(string_to_uninterned_symbol_prim,
+						      "string->uninterned-symbol",
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("symbol->string", 
+			     scheme_make_prim_w_arity(symbol_to_string_prim,
+						      "symbol->string", 
+						      1, 1), 
+			     env);
+  
+  scheme_add_global_constant("gensym", 
+			     scheme_make_prim_w_arity(gensym,
+						      "gensym",
+						      0, 1), 
+			     env);
+}
+
+static Scheme_Object *
+make_a_symbol(const char *name, int len)
+{
+  Scheme_Symbol *sym;
+  
+  sym = (Scheme_Symbol *)scheme_malloc_atomic_tagged(sizeof(Scheme_Type) + 
+						     sizeof(short) +
+						     len + 1);
+  
+  sym->type = scheme_symbol_type;
+  sym->len = len;
+  memcpy(sym->s, name, len);
+  sym->s[len] = 0;
+  
+  return (Scheme_Object *)(sym);
+}
+
+Scheme_Object *
+scheme_make_symbol(const char *name)
+{
+  return make_a_symbol(name, strlen(name));
+}
+
+Scheme_Object *
+scheme_make_exact_symbol(const char *name, int len)
+{
+  return make_a_symbol(name, len);
+}
+
+Scheme_Object *
+scheme_intern_exact_symbol(const char *name, int len)
+{
+  Scheme_Object *sym;
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_LOCK_MUTEX(scheme_symbol_table->mutex);
+#endif
+
+  sym = symbol_bucket(scheme_symbol_table, name, len, NULL);
+
+  if (!sym) {
+    sym = make_a_symbol(name, len);
+    symbol_bucket(scheme_symbol_table, name, len, sym);
+  }
+
+#ifdef MZ_REAL_THREADS
+  SCHEME_UNLOCK_MUTEX(scheme_symbol_table->mutex);
+#endif
+   
+  return sym;
+}
+
+#define MAX_SYMBOL_SIZE 256
+
+Scheme_Object *
+scheme_intern_symbol(const char *name)
+{
+  if (!scheme_case_sensitive) {
+    long i, len;
+    char *naya;
+    char on_stack[MAX_SYMBOL_SIZE];
+    
+    len = strlen(name);
+    if (len >= MAX_SYMBOL_SIZE)
+      naya = (char *)scheme_malloc_atomic(len + 1);
+    else
+      naya = on_stack;
+
+    for (i = 0; i < len; i++) {
+      int c = name[i];
+
+      if (isupper(c))
+	c = tolower(c);
+
+      naya[i] = c;
+    }
+
+    naya[len] = 0;
+
+    return scheme_intern_exact_symbol(naya, len);
+  }
+
+  return scheme_intern_exact_symbol(name, strlen(name));
+}
+
+const char *scheme_symbol_name_and_size(Scheme_Object *sym, int *length, int flags)
+{
+  int has_space = 0, has_special = 0, has_pipe = 0, digit_start;
+  int i, len = SCHEME_SYM_LEN(sym), dz;
+  int total_length;
+  int pipe_quote;
+  char *s = SCHEME_SYM_VAL(sym), *result;
+  
+  if ((flags & SNF_PIPE_QUOTE) || (flags & SNF_FOR_TS))
+    pipe_quote = 1;
+  else if (flags & SNF_NO_PIPE_QUOTE)
+    pipe_quote = 0;
+  else {
+    pipe_quote = SCHEME_TRUEP(scheme_get_param(scheme_config, MZCONFIG_CAN_READ_PIPE_QUOTE));
+  }
+
+#define isSpecial(ch) ((ch == '(') || (ch == '[') || (ch == '{')       \
+		       || (ch == ')') || (ch == ']') || (ch == '}')    \
+		       || (ch == ')') || (ch == '\\')   \
+		       || (ch == '"') || (ch == '\'')   \
+		       || (ch == '`') || (ch == ',')    \
+                       || (ch == ';')                   \
+                       || (((ch == '>') || (ch == '<')) \
+			   && (flags & SNF_FOR_TS)))
+
+  if (len) {
+    digit_start = (isdigit(s[0]) || (s[0] == '.')
+		   || (s[0] == '+') || (s[0] == '-'));
+    if (s[0] == '#' && (len == 1 || s[1] != '%'))
+      has_special = 1;
+    if (s[0] == '.' && len == 1)
+      has_special = 1;
+  } else {
+    digit_start = 0;
+    has_space = 1;
+  }
+
+  for (i = 0; i < len; i++) {
+    if (isspace(s[i]) || !isprint(s[i])) {
+      if ((flags & SNF_FOR_TS) && (s[i] == ' ')) {
+	/* space is OK in type symbols */
+      } else
+	has_space = 1;
+    } else if (isSpecial(s[i]))
+      has_special = 1;
+    else if (s[i] == '|')
+      has_pipe = 1;
+  }
+
+  result = NULL;
+  total_length = 0;
+
+  if (!has_space && !has_special && (!pipe_quote || !has_pipe)) {
+    dz = 0;
+    if (digit_start
+	&& !(flags & SNF_FOR_TS)
+	&& (SCHEME_TRUEP(scheme_read_number(s, len, 0, 0, 10, 0, 0, &dz))
+	    || dz)) {
+      /* Need quoting: */
+      if (pipe_quote)
+	has_space = 1; /* Use normal */
+      else {
+	/* Just need a leading backslash: */
+	result = (char *)scheme_malloc_atomic(len + 2);
+	total_length = len + 1;
+	memcpy(result + 1, s, len);
+	result[0] = '\\';
+	result[len + 1] = 0;
+      }
+    } else {
+      total_length = len;
+      result = s;
+    }
+  }
+
+  if (!result) {
+    if (!has_pipe && pipe_quote) {
+      result = (char *)scheme_malloc_atomic(len + 3);
+      total_length = len + 2;
+      memcpy(result + 1, s, len);
+      result[0] = '|';
+      result[len + 1] = '|';
+      result[len + 2] = 0;
+    } else {
+      int i, p = 0;
+      
+      result = (char *)scheme_malloc_atomic((2 * len) + 1);
+
+      for (i = 0; i < len; i++) {
+	if (isspace(s[i]) 
+	    || isSpecial(s[i]) 
+	    || ((s[i] == '|') && pipe_quote)
+	    || (!i && s[0] == '#'))
+	  result[p++] = '\\';
+	result[p++] = s[i];
+      }
+      
+      result[p] = 0;
+      total_length = p;
+    }
+  }
+
+  if (total_length > scheme_max_found_symbol_name)
+    scheme_max_found_symbol_name = total_length;
+
+  if (length)
+    *length = total_length;
+
+  return result;
+}
+
+const char *scheme_symbol_name(Scheme_Object *sym)
+{
+  return scheme_symbol_name_and_size(sym, NULL, 0);
+}
+
+/* locals */
+
+static Scheme_Object *
+symbol_p_prim (int argc, Scheme_Object *argv[])
+{
+  return SCHEME_SYMBOLP(argv[0]) ? scheme_true : scheme_false;
+}
+
+static Scheme_Object *
+string_to_symbol_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->symbol", "string", 0, argc, argv);
+  return scheme_intern_exact_symbol(SCHEME_STR_VAL(argv[0]),
+				    SCHEME_STRTAG_VAL(argv[0]));
+}
+
+static Scheme_Object *
+string_to_uninterned_symbol_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->uninterned-symbol", "string", 0, argc, argv);
+  return scheme_make_exact_symbol(SCHEME_STR_VAL(argv[0]),
+				  SCHEME_STRTAG_VAL(argv[0]));
+}
+
+static Scheme_Object *
+symbol_to_string_prim (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_SYMBOLP(argv[0]))
+    scheme_wrong_type("symbol->string", "symbol", 0, argc, argv);
+  
+  return scheme_make_sized_string(SCHEME_SYM_VAL(argv[0]),
+				  SCHEME_SYM_LEN(argv[0]),
+				  1);
+}
+
+static Scheme_Object *gensym(int argc, Scheme_Object *argv[])
+{
+  char buffer[100], *str;
+
+  if (argc && !SCHEME_SYMBOLP(argv[0]) && !SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("gensym", "symbol/string", 0, argc, argv);
+  
+  if (argc) {
+    if (SCHEME_STRINGP(argv[0]))
+      str = SCHEME_STR_VAL(argv[0]);
+    else
+      str = SCHEME_SYM_VAL(argv[0]);      
+    sprintf(buffer, "%.80s%d", str, gensym_counter++);
+  } else
+    sprintf(buffer, "g%d", gensym_counter++);
+
+  return scheme_make_symbol(buffer);
+}
diff --git a/src/mzscheme/src/syntax.c b/src/mzscheme/src/syntax.c
new file mode 100644
index 0000000..4349c98
--- /dev/null
+++ b/src/mzscheme/src/syntax.c
@@ -0,0 +1,2581 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+
+/* globals */
+Scheme_Object *scheme_define_values_syntax, *scheme_defmacro_syntax;
+Scheme_Object *scheme_def_id_macro_syntax;
+Scheme_Object *scheme_def_exp_time_syntax;
+Scheme_Object *scheme_begin_exp_time_syntax;
+Scheme_Object *scheme_begin_syntax;
+Scheme_Object *scheme_lambda_syntax;
+Scheme_Object *scheme_compiled_void_code;
+Scheme_Object *scheme_undefined;
+
+/* locals */
+static Scheme_Object *lambda_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *define_values_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *define_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *quote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *quote_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *if_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *if_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *set_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *set_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *case_lambda_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *case_lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *let_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *let_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *let_star_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *letrec_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *letrec_star_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *let_values_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *let_star_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *letrec_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *letrec_star_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *begin_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *begin_expand (Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *begin0_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *begin0_expand (Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+
+static Scheme_Object *empty_cond_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *empty_cond_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+
+static Scheme_Object *unquote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *unquote_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+
+/* non-standard */
+static Scheme_Object *defmacro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *defmacro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *def_id_macro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *def_id_macro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *def_exp_time_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *def_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *begin_exp_time_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *begin_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *letmacro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *letmacro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *let_id_macro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *let_id_macro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+static Scheme_Object *let_exp_time_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec);
+static Scheme_Object *let_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth);
+
+static Scheme_Object *define_values_execute(Scheme_Object *data);
+static Scheme_Object *set_execute(Scheme_Object *data);
+static Scheme_Object *defmacro_execute(Scheme_Object *expr);
+static Scheme_Object *def_id_macro_execute(Scheme_Object *expr);
+static Scheme_Object *def_exp_time_execute(Scheme_Object *expr);
+static Scheme_Object *case_lambda_execute(Scheme_Object *expr);
+static Scheme_Object *void_execute(Scheme_Object *expr);
+static Scheme_Object *empty_cond_execute(Scheme_Object *data);
+static Scheme_Object *begin0_execute(Scheme_Object *data);
+
+static Scheme_Object *bangboxvalue_execute(Scheme_Object *data);
+
+
+static Scheme_Object *named_let_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+					Scheme_Compile_Info *rec, int depth);
+
+static Scheme_Object *write_let_value(Scheme_Object *obj);
+static Scheme_Object *read_let_value(Scheme_Object *obj);
+static Scheme_Object *write_let_void(Scheme_Object *obj);
+static Scheme_Object *read_let_void(Scheme_Object *obj);
+static Scheme_Object *write_letrec(Scheme_Object *obj);
+static Scheme_Object *read_letrec(Scheme_Object *obj);
+static Scheme_Object *write_let_one(Scheme_Object *obj);
+static Scheme_Object *read_let_one(Scheme_Object *obj);
+static Scheme_Object *write_top(Scheme_Object *obj);
+static Scheme_Object *read_top(Scheme_Object *obj);
+static Scheme_Object *write_case_lambda(Scheme_Object *obj);
+static Scheme_Object *read_case_lambda(Scheme_Object *obj);
+
+/* symbols */
+static Scheme_Object *define_values_symbol;
+static Scheme_Object *lambda_symbol;
+static Scheme_Object *letrec_symbol;
+static Scheme_Object *letrec_star_symbol;
+static Scheme_Object *let_star_symbol;
+static Scheme_Object *let_symbol;
+static Scheme_Object *letrec_symbol_nohp;
+static Scheme_Object *letrec_star_symbol_nohp;
+static Scheme_Object *let_star_symbol_nohp;
+static Scheme_Object *letrec_values_symbol;
+static Scheme_Object *letrec_star_values_symbol;
+static Scheme_Object *let_star_values_symbol;
+static Scheme_Object *let_values_symbol;
+static Scheme_Object *letrec_values_symbol_nohp;
+static Scheme_Object *letrec_star_values_symbol_nohp;
+static Scheme_Object *let_star_values_symbol_nohp;
+static Scheme_Object *let_values_symbol_nohp;
+static Scheme_Object *begin_symbol;
+static Scheme_Object *begin0_symbol;
+static Scheme_Object *set_symbol;
+static Scheme_Object *quote_symbol;
+static Scheme_Object *if_symbol;
+static Scheme_Object *case_lambda_symbol;
+
+static Scheme_Object *define_macro_symbol;
+static Scheme_Object *define_id_macro_symbol;
+static Scheme_Object *define_expansion_time_symbol;
+static Scheme_Object *let_macro_symbol;
+static Scheme_Object *let_id_macro_symbol;
+static Scheme_Object *let_expansion_time_symbol;
+static Scheme_Object *begin_expansion_time_symbol;
+
+typedef struct {
+  Scheme_Object *sym;
+  Scheme_Syntax_Registered *f;
+} Linker_Name;
+
+static int num_link_names = 0, link_names_size = 0;
+static Linker_Name *linker_names;
+
+
+#define cons(a,b) scheme_make_pair(a,b)
+
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+void 
+scheme_init_syntax (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(scheme_define_values_syntax);
+    REGISTER_SO(scheme_defmacro_syntax);
+    REGISTER_SO(scheme_def_id_macro_syntax);
+    REGISTER_SO(scheme_def_exp_time_syntax);
+    REGISTER_SO(scheme_begin_exp_time_syntax);
+    REGISTER_SO(scheme_lambda_syntax);
+    REGISTER_SO(scheme_begin_syntax);
+    REGISTER_SO(scheme_undefined);
+    REGISTER_SO(linker_names);
+    REGISTER_SO(scheme_compiled_void_code);
+
+    REGISTER_SO(define_values_symbol);
+    REGISTER_SO(lambda_symbol);
+    REGISTER_SO(letrec_symbol);
+    REGISTER_SO(letrec_star_symbol);
+    REGISTER_SO(let_star_symbol);
+    REGISTER_SO(let_symbol);
+    REGISTER_SO(letrec_symbol_nohp);
+    REGISTER_SO(letrec_star_symbol_nohp);
+    REGISTER_SO(let_star_symbol_nohp);
+    REGISTER_SO(letrec_values_symbol);
+    REGISTER_SO(letrec_star_values_symbol);
+    REGISTER_SO(let_star_values_symbol);
+    REGISTER_SO(let_values_symbol);
+    REGISTER_SO(letrec_values_symbol_nohp);
+    REGISTER_SO(letrec_star_values_symbol_nohp);
+    REGISTER_SO(let_star_values_symbol_nohp);
+    REGISTER_SO(let_values_symbol_nohp);
+    REGISTER_SO(begin_symbol);
+    REGISTER_SO(begin0_symbol);
+    REGISTER_SO(set_symbol);
+    REGISTER_SO(quote_symbol);
+    REGISTER_SO(if_symbol);
+    REGISTER_SO(case_lambda_symbol);
+    
+    REGISTER_SO(define_macro_symbol);
+    REGISTER_SO(define_id_macro_symbol);
+    REGISTER_SO(define_expansion_time_symbol);
+    REGISTER_SO(let_macro_symbol);
+    REGISTER_SO(let_id_macro_symbol);
+    REGISTER_SO(let_expansion_time_symbol);
+    REGISTER_SO(begin_expansion_time_symbol);
+
+    scheme_undefined = scheme_alloc_eternal_object();
+    scheme_undefined->type = scheme_undefined_type;
+
+    define_values_symbol = scheme_intern_symbol("#%define-values");
+    lambda_symbol = scheme_intern_symbol("#%lambda");
+
+    letrec_symbol = scheme_intern_symbol("#%letrec");
+    letrec_star_symbol = scheme_intern_symbol("#%letrec*");
+    let_star_symbol = scheme_intern_symbol("#%let*");
+    let_symbol = scheme_intern_symbol("#%let");
+    letrec_symbol_nohp = scheme_intern_symbol("letrec");
+    letrec_star_symbol_nohp = scheme_intern_symbol("letrec*");
+    let_star_symbol_nohp = scheme_intern_symbol("let*");
+
+    letrec_values_symbol = scheme_intern_symbol("#%letrec-values");
+    letrec_star_values_symbol = scheme_intern_symbol("#%letrec*-values");
+    let_star_values_symbol = scheme_intern_symbol("#%let*-values");
+    let_values_symbol = scheme_intern_symbol("#%let-values");
+    letrec_values_symbol_nohp = scheme_intern_symbol("letrec-values");
+    letrec_star_values_symbol_nohp = scheme_intern_symbol("letrec*-values");
+    let_values_symbol_nohp = scheme_intern_symbol("let-values");
+    let_star_values_symbol_nohp = scheme_intern_symbol("let*-values");
+
+    begin_symbol = scheme_intern_symbol("#%begin");
+    begin0_symbol = scheme_intern_symbol("#%begin0");
+    quote_symbol = scheme_intern_symbol("#%quote");
+    if_symbol = scheme_intern_symbol("#%if");
+    set_symbol = scheme_intern_symbol("#%set!");
+    case_lambda_symbol = scheme_intern_symbol("#%case-lambda");
+
+    define_macro_symbol = scheme_intern_symbol("#%define-macro");
+    define_id_macro_symbol = scheme_intern_symbol("#%define-id-macro");
+    define_expansion_time_symbol = scheme_intern_symbol("#%define-expansion-time");
+    let_macro_symbol = scheme_intern_symbol("#%let-macro");
+    let_id_macro_symbol = scheme_intern_symbol("#%let-id-macro");
+    let_expansion_time_symbol = scheme_intern_symbol("#%let-expansion-time");
+    begin_expansion_time_symbol = scheme_intern_symbol("#%begin-expansion-time");
+
+    scheme_register_syntax("d", define_values_execute);
+    scheme_register_syntax("!", set_execute);
+    scheme_register_syntax("dm", defmacro_execute);
+    scheme_register_syntax("di", def_id_macro_execute);
+    scheme_register_syntax("dn", def_exp_time_execute);
+    scheme_register_syntax("cl", case_lambda_execute);
+    scheme_register_syntax("v", void_execute);
+    scheme_register_syntax("e", empty_cond_execute);
+    scheme_register_syntax("0", begin0_execute);
+
+    scheme_register_syntax("be", scheme_bangboxenv_execute);
+    scheme_register_syntax("b", bangboxvalue_execute);
+
+    scheme_install_type_writer(scheme_let_value_type, write_let_value);
+    scheme_install_type_reader(scheme_let_value_type, read_let_value);
+    scheme_install_type_writer(scheme_let_void_type, write_let_void);
+    scheme_install_type_reader(scheme_let_void_type, read_let_void);
+    scheme_install_type_writer(scheme_letrec_type, write_letrec);
+    scheme_install_type_reader(scheme_letrec_type, read_letrec);
+    scheme_install_type_writer(scheme_let_one_type, write_let_one);
+    scheme_install_type_reader(scheme_let_one_type, read_let_one);
+    scheme_install_type_writer(scheme_case_lambda_sequence_type, write_case_lambda);
+    scheme_install_type_reader(scheme_case_lambda_sequence_type, read_case_lambda);
+
+    scheme_install_type_writer(scheme_compilation_top_type, write_top);
+    scheme_install_type_reader(scheme_compilation_top_type, read_top);
+
+    scheme_define_values_syntax = scheme_make_compiled_syntax(define_values_syntax, 
+							      define_values_expand);
+    scheme_defmacro_syntax = scheme_make_compiled_syntax(defmacro_syntax, 
+							 defmacro_expand);
+    scheme_def_id_macro_syntax = scheme_make_compiled_syntax(def_id_macro_syntax, 
+							     def_id_macro_expand);
+    scheme_def_exp_time_syntax = scheme_make_compiled_syntax(def_exp_time_syntax, 
+							      def_exp_time_expand);
+    scheme_begin_exp_time_syntax = scheme_make_compiled_syntax(begin_exp_time_syntax, 
+							       begin_exp_time_expand);
+    scheme_lambda_syntax = scheme_make_compiled_syntax(lambda_syntax,
+						       lambda_expand);
+    scheme_begin_syntax = scheme_make_compiled_syntax(begin_syntax, 
+						      begin_expand);
+
+    scheme_compiled_void_code = scheme_make_syntax_link(void_execute, scheme_null);
+  }
+
+  scheme_add_global_keyword("lambda", 
+			    scheme_lambda_syntax,
+			    env);
+  scheme_add_global_keyword("define-values", scheme_define_values_syntax, env);
+  scheme_add_global_keyword("quote", 
+			    scheme_make_compiled_syntax(quote_syntax,
+							quote_expand), 
+			    env);
+  scheme_add_global_keyword("if", 
+			    scheme_make_compiled_syntax(if_syntax, 
+							if_expand),
+			    env);
+  scheme_add_global_keyword("set!", 
+			    scheme_make_compiled_syntax(set_syntax, 
+							set_expand), 
+			    env);
+
+  scheme_add_global_keyword("case-lambda", 
+			    scheme_make_compiled_syntax(case_lambda_syntax, 
+							case_lambda_expand), 
+			    env);
+
+  scheme_add_global_keyword("let", 
+			    scheme_make_compiled_syntax(let_syntax, 
+							let_expand), 
+			    env);
+  scheme_add_global_keyword("let*", 
+			    scheme_make_compiled_syntax(let_star_syntax, 
+							let_expand), 
+			    env);
+  scheme_add_global_keyword("letrec", 
+			    scheme_make_compiled_syntax(letrec_syntax, 
+						        let_expand), 
+			    env);  
+  scheme_add_global_keyword("letrec*", 
+			    scheme_make_compiled_syntax(letrec_star_syntax, 
+						        let_expand), 
+			    env);
+  
+  scheme_add_global_keyword("let-values", 
+			    scheme_make_compiled_syntax(let_values_syntax, 
+							let_expand), 
+			    env);
+  scheme_add_global_keyword("let*-values", 
+			    scheme_make_compiled_syntax(let_star_values_syntax, 
+							let_expand), 
+			    env);
+  scheme_add_global_keyword("letrec-values", 
+			    scheme_make_compiled_syntax(letrec_values_syntax, 
+						        let_expand), 
+			    env);  
+  scheme_add_global_keyword("letrec*-values", 
+			    scheme_make_compiled_syntax(letrec_star_values_syntax, 
+						        let_expand), 
+			    env);
+  
+  scheme_add_global_keyword("begin", 
+			    scheme_begin_syntax, 
+			    env);
+
+  scheme_add_global_keyword("begin0", 
+			    scheme_make_compiled_syntax(begin0_syntax, 
+						        begin0_expand), 
+			    env);
+
+  scheme_add_global_keyword("unquote", 
+			    scheme_make_compiled_syntax(unquote_syntax, 
+							unquote_expand), 
+			    env);
+  scheme_add_global_keyword("unquote-splicing", 
+			    scheme_make_compiled_syntax(unquote_syntax, 
+							unquote_expand), 
+			    env);
+
+  scheme_add_global_keyword("define-macro", scheme_defmacro_syntax, env);
+  scheme_add_global_keyword("define-id-macro", scheme_def_id_macro_syntax, env);
+  scheme_add_global_keyword("define-expansion-time", scheme_def_exp_time_syntax, env);
+  scheme_add_global_keyword("begin-expansion-time", scheme_begin_exp_time_syntax, env);
+  scheme_add_global_keyword("let-macro", 
+			    scheme_make_compiled_syntax(letmacro_syntax, 
+							 letmacro_expand), 
+			    env);
+  scheme_add_global_keyword("let-id-macro", 
+			    scheme_make_compiled_syntax(let_id_macro_syntax, 
+							let_id_macro_expand), 
+			    env);
+  scheme_add_global_keyword("let-expansion-time", 
+			    scheme_make_compiled_syntax(let_exp_time_syntax, 
+							let_exp_time_expand), 
+			    env);
+}
+
+void
+scheme_init_empty_cond(Scheme_Env *env)
+{
+  /* Hack: use the usual `cond' macro, but (cond) - an empty
+     cond - is primitive syntax. Why? Because primitive exceptions
+     can only be raised by the system (in the right mode), so you
+     can't expand a (cond ...) into something that raises an error at
+     a final `else'. */
+  Scheme_Bucket *b;
+
+  b = scheme_global_bucket(scheme_intern_symbol("#%cond"), env);
+  
+  env->nonempty_cond = (Scheme_Object *)b->val;
+  b->val = (void *)scheme_make_compiled_syntax(empty_cond_syntax, 
+					       empty_cond_expand);
+}
+
+Scheme_Object *
+scheme_make_compiled_syntax(Scheme_Syntax *proc, 
+			    Scheme_Syntax_Expander *eproc)
+{
+  Scheme_Object *syntax;
+
+  if (scheme_starting_up)
+    syntax = scheme_alloc_eternal_object();
+  else
+    syntax = scheme_alloc_stubborn_object();
+  syntax->type = scheme_syntax_compiler_type;
+  SCHEME_SYNTAX(syntax) = proc;
+  SCHEME_SYNTAX_EXP(syntax) = eproc;
+
+  if (!scheme_starting_up)
+    scheme_end_stubborn_change((void *)syntax);
+
+  return syntax;
+}
+
+static int check_form(char *name, Scheme_Object *form)
+{
+  int i;
+  Scheme_Object *all = form;
+
+  for (i = 0; SCHEME_PAIRP(form); i++)
+    form = SCHEME_CDR(form);
+
+  if (!SCHEME_NULLP(form))
+    scheme_wrong_syntax(name, form, all, "bad syntax (" IMPROPER_LIST_FORM ")");
+
+  return i;
+}
+
+static void bad_form(Scheme_Object *form, char *name, int l)
+{ 
+  scheme_wrong_syntax(name, NULL, form, 
+		      "bad syntax (has %d part%s after keyword)", 
+		      l - 1, (l != 2) ? "s" : "");
+}
+
+/* builtin syntax */
+
+static void lambda_check(Scheme_Object *form)
+{
+  if (!SCHEME_PAIRP(form)
+      || !SCHEME_PAIRP(SCHEME_CDR(form))
+      || !SCHEME_PAIRP(SCHEME_CDDR(form)))
+    scheme_wrong_syntax("lambda", NULL, form, NULL);
+}
+
+static void lambda_check_args(char *who, Scheme_Object *args, Scheme_Object *form)
+{
+  Scheme_Object *v;
+
+  if (!SCHEME_SYMBOLP(args)) {
+    for (v = args; SCHEME_PAIRP(v); v = SCHEME_CDR(v))
+      if (!SCHEME_SYMBOLP(SCHEME_CAR(v)))
+	scheme_wrong_syntax(who, SCHEME_CAR(v), form, "bad identifier");
+    
+    if (!SCHEME_NULLP(v))
+      if (!SCHEME_SYMBOLP(v))
+	scheme_wrong_syntax(who, v, form, "bad identifier");
+  }
+
+}
+
+static Scheme_Object *
+lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  lambda_check(form);
+  return scheme_make_closure_compilation(env, form, rec);
+}
+
+static Scheme_Object *
+lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  Scheme_Object *args;
+
+  lambda_check(form);
+  
+  args = SCHEME_CAR(SCHEME_CDR(form));
+
+  lambda_check_args("lambda", args, form);
+
+  env = scheme_add_compilation_frame(args, env, 0);
+
+  return cons(lambda_symbol,
+	      cons(args,
+		   scheme_expand_block(SCHEME_CDR(SCHEME_CDR(form)),
+				       env,
+				       depth)));
+}
+
+void scheme_set_global_bucket(char *who, Scheme_Bucket *b, Scheme_Object *val,
+			      int set_undef)
+{
+  if ((((Scheme_Bucket_With_Const_Flag *)b)->flags & (GLOB_IS_CONST | GLOB_IS_KEYWORD))
+      && b->val) {
+    Scheme_Object *key = (Scheme_Object *)b->key;
+    scheme_raise_exn(MZEXN_MISC_CONSTANT, key,
+		     "%s: cannot redefine %s: %s", 
+		     who,
+		     (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST)
+		     ? "constant"
+		     : "keyword",
+		     scheme_symbol_name((Scheme_Object *)key));
+  } else if (b->val || set_undef)
+    b->val = val;
+  else {
+    scheme_raise_exn(MZEXN_VARIABLE, b->key,
+		     "%s: cannot set undefined identifier: %s", 
+		     who,
+		     scheme_symbol_name((Scheme_Object *)b->key));
+    
+  }
+}
+
+static Scheme_Object *
+define_values_execute(Scheme_Object *data)
+{
+  Scheme_Object *vars, *vals, *l, *name;
+  int i, g, show_any;
+
+  vars = SCHEME_CAR(data);
+  vals = SCHEME_CDR(data);
+
+  vals = _scheme_eval_compiled_expr_multi(vals);
+  if (SAME_OBJ(vals, SCHEME_MULTIPLE_VALUES)) {
+    Scheme_Object *v, **values;
+
+    for (v = vars, i = 0; SCHEME_PAIRP(v); i++, v = SCHEME_CDR(v));
+    
+    g = scheme_current_process->ku.multiple.count;
+    if (i == g) {
+      values = scheme_current_process->ku.multiple.array;
+      for (i = 0; i < g; i++, vars = SCHEME_CDR(vars))
+	scheme_set_global_bucket("define-values", (Scheme_Bucket *)SCHEME_CAR(vars), 
+				 values[i], 1);
+	
+      return scheme_void;
+    }
+  } else if (SCHEME_PAIRP(vars) && SCHEME_NULLP(SCHEME_CDR(vars))) {
+    scheme_set_global_bucket("define-values", (Scheme_Bucket *)SCHEME_CAR(vars), 
+			     vals, 1);
+
+    return scheme_void;
+  } else
+    g = 1;
+  
+  l = vars;
+  for (i = 0; SCHEME_PAIRP(l); i++, l = SCHEME_CDR(l));
+
+  show_any = i;
+
+  if (show_any)
+    name = (Scheme_Object *)((Scheme_Bucket *)SCHEME_CAR(vars))->key;
+  else
+    name = NULL;
+  
+  scheme_wrong_return_arity("define-values",
+			    i, g,
+			    (g == 1) ? (Scheme_Object **)vals : scheme_current_process->ku.multiple.array,
+			    "%s%s%s",
+			    show_any ? "defining \"" : "0 names",
+			    show_any ? scheme_symbol_name(name) : "",
+			    show_any ? ((i == 1) ? "\"" : "\", ...") : "");
+
+  return NULL;
+}
+
+static Scheme_Object *
+define_values_link(Scheme_Object *data, Link_Info *link)
+{
+  Scheme_Object *var = SCHEME_CAR(data);
+  Scheme_Object *val = SCHEME_CDR(data);
+
+  var = scheme_link_list(var, link);
+  val = scheme_link_expr(val, link);
+
+  return scheme_make_syntax_link(define_values_execute, cons(var, val));
+}
+
+static void define_values_parse(Scheme_Object *form, 
+				Scheme_Object **var, Scheme_Object **val,
+				Scheme_Comp_Env *env)
+{
+  Scheme_Object *vars;
+  int len;
+
+  len = check_form("define-values", form);
+  if (len != 3)
+    bad_form(form, "define-values", len);
+
+  vars = SCHEME_CAR(SCHEME_CDR(form));
+  *val = SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(form)));
+
+  *var = vars;
+
+  while (SCHEME_PAIRP(vars)) {
+    Scheme_Object *name;
+
+    name = SCHEME_CAR(vars);
+    scheme_check_identifier("define-values", name, NULL, env, form);
+
+    vars = SCHEME_CDR(vars);
+  }  
+
+  if (!SCHEME_NULLP(vars))
+    scheme_wrong_syntax("define-values", *var, form, "bad variable list");
+}
+
+static Scheme_Object *
+define_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  Scheme_Object *var, *val, *first = scheme_null, *last = NULL, *variables;
+  Scheme_Env *globals = scheme_min_env(env);
+
+  if (!scheme_is_toplevel(env))
+    scheme_wrong_syntax("define-values", NULL, form, "illegal use (not at top-level)");
+
+  define_values_parse(form, &var, &val, env);
+  variables = var;
+  
+  while (SCHEME_PAIRP(var)) {
+    Scheme_Object *name, *pr;
+
+    name = SCHEME_CAR(var);
+
+    pr = scheme_make_pair((Scheme_Object *)scheme_global_bucket(name, globals), scheme_null);
+    if (last)
+      SCHEME_CDR(last) = pr;
+    else
+      first = pr;
+    last = pr;
+
+    var = SCHEME_CDR(var);
+  }  
+
+  scheme_compile_rec_done_local(rec);
+  if (SCHEME_PAIRP(first) && SCHEME_NULLP(SCHEME_CDR(first)))
+    rec->value_name = SCHEME_CAR(variables);
+
+  val = scheme_compile_expr(val, env, rec);
+
+  return scheme_make_syntax_compile(define_values_link, cons(first, val));
+}
+
+static Scheme_Object *
+define_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  Scheme_Object *var, *val;
+
+  define_values_parse(form, &var, &val, env);
+
+  env = scheme_no_defines(env);
+
+  return cons(define_values_symbol,
+	      cons(var,
+		   cons(scheme_expand_expr(val, env, depth), scheme_null)));
+}
+
+static Scheme_Object *
+quote_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  Scheme_Object *v;
+
+  if (!(SCHEME_PAIRP(SCHEME_CDR(form))
+	&& SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(form)))))
+    scheme_wrong_syntax("quote", NULL, form, "bad syntax (wrong number of parts)");
+
+  scheme_compile_rec_done_local(rec);
+  scheme_default_compile_rec(rec);
+  
+  v = SCHEME_CAR(SCHEME_CDR(form));
+
+  if (rec->can_optimize_constants)
+    return v;
+  else {
+    Scheme_Object *q = scheme_alloc_small_object();
+    q->type = scheme_quote_compilation_type;
+    SCHEME_PTR_VAL(q) = v;
+    return q;
+  }
+}
+
+static Scheme_Object *
+quote_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  if (!(SCHEME_PAIRP(SCHEME_CDR(form))
+	&& SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(form)))))
+    scheme_wrong_syntax("quote", NULL, form, "bad syntax (wrong number of parts)");
+
+  return scheme_make_pair(quote_symbol, SCHEME_CDR(form));
+}
+
+static Scheme_Object *
+if_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  int len, opt;
+  Scheme_Object *test, *thenp, *elsep, *name;
+  Scheme_Compile_Info recs[3];
+
+  len = check_form("if", form);
+  if (!(((len == 3) || (len == 4))))
+    bad_form(form, "if", len);
+
+  name = rec->value_name;
+  scheme_compile_rec_done_local(rec);
+
+  test = SCHEME_CAR(SCHEME_CDR(form));
+  thenp = SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(form)));
+  if (len == 4)
+    elsep = SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(form))));
+  else
+    elsep = scheme_compiled_void(rec->can_optimize_constants);
+
+  scheme_init_compile_recs(rec, recs, 3);
+  recs[1].value_name = name;
+  recs[2].value_name = name;
+
+  test = scheme_compile_expr(test, scheme_no_defines(env), &recs[0]);
+
+  if (SAME_TYPE(SCHEME_TYPE(test), scheme_quote_compilation_type))
+    test = SCHEME_PTR_VAL(test);
+
+  if (SCHEME_TYPE(test) > _scheme_compiled_values_types_) {
+    Scheme_Object *comp, *exp;
+
+    opt = 1;
+    
+    if (SCHEME_FALSEP(test)) {
+      comp = elsep;
+      exp = thenp;
+    } else {
+      comp = thenp;
+      exp = elsep;
+    }
+
+    /* compile other branch only to get syntax checking: */
+    recs[2].dont_mark_local_use = 1;
+    scheme_compile_expr(exp, env, &recs[2]);
+
+    test = scheme_compile_expr(comp, env, &recs[1]);
+  } else {
+    opt = 0;
+    thenp = scheme_compile_expr(thenp, env, &recs[1]);
+    elsep = scheme_compile_expr(elsep, env, &recs[2]);
+  }
+
+  scheme_merge_compile_recs(rec, recs, opt ? 2 : 3);
+
+  if (opt)
+    return test;
+  else
+    return scheme_make_branch(test, thenp, elsep);
+}
+
+static Scheme_Object *
+if_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  Scheme_Object *test, *rest;
+  int len = check_form("if", form);
+
+  if (!(((len == 3) || (len == 4))))
+    bad_form(form, "if", len);
+
+  test = SCHEME_CADR(form);
+  test = scheme_expand_expr(test, scheme_no_defines(env), depth);
+
+  rest = SCHEME_CDR(SCHEME_CDR(form));
+  rest = scheme_expand_list(rest, env, depth);
+
+  return cons(if_symbol, cons(test, rest));
+}
+
+static Scheme_Object *
+set_execute (Scheme_Object *data)
+{
+  Scheme_Object *val, *set_undef;
+
+  set_undef = SCHEME_CAR(data);
+  data = SCHEME_CDR(data);
+  
+  val = _scheme_eval_compiled_expr(SCHEME_CDR(data));
+
+  scheme_set_global_bucket("set!", (Scheme_Bucket *)SCHEME_CAR(data), 
+			   val, SCHEME_TRUEP(set_undef));
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+set_link(Scheme_Object *data, Link_Info *link)
+{
+  Scheme_Object *var, *val, *set_undef;
+
+  set_undef = SCHEME_CAR(data);
+  data = SCHEME_CDR(data);
+  var = SCHEME_CAR(data);
+  val = SCHEME_CDR(data);
+  
+  val = scheme_link_expr(val, link);
+
+  if (SAME_TYPE(SCHEME_TYPE(var), scheme_local_type)) {
+    Scheme_Let_Value *lv;
+    int flags;
+
+    lv = MALLOC_ONE_TAGGED(Scheme_Let_Value);
+    lv->type = scheme_let_value_type;
+    lv->body = scheme_compiled_void(link->can_optimize_constants);
+    lv->count = 1;
+    lv->position = scheme_link_info_lookup(link, SCHEME_LOCAL_POS(var), &flags);
+    lv->autobox = (flags & SCHEME_INFO_BOXED);
+    lv->value = val;
+
+    if (!(flags & SCHEME_INFO_BOXED))
+      scheme_signal_error("internal error: set!: set!ed local variable is not boxed");
+
+    return (Scheme_Object *)lv;
+  }
+
+  var = scheme_link_expr(var, link);
+  
+  return scheme_make_syntax_link(set_execute, cons(set_undef, cons(var, val)));
+}
+
+static Scheme_Object *
+set_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  Scheme_Object *var, *val, *name, *body;
+  int l, set_undef;
+
+  l = check_form("set!", form);
+  if (l != 3)
+    bad_form(form, "set!", l);
+
+  name = SCHEME_CAR(SCHEME_CDR(form));
+  body = SCHEME_CADR(SCHEME_CDR(form));
+  
+  scheme_check_identifier("set!", name, NULL, env, form);
+
+  scheme_compile_rec_done_local(rec);
+  rec->value_name = name;
+
+  var = scheme_static_distance(name, env, 
+			       SCHEME_SETTING 
+			       + SCHEME_GLOB_ALWAYS_REFERENCE
+			       + (rec->can_optimize_constants 
+				  ? SCHEME_ELIM_CONST 
+				  : 0)
+			       + (rec->dont_mark_local_use 
+				  ? SCHEME_DONT_MARK_USE 
+				  : 0));
+
+  val = scheme_compile_expr(body, scheme_no_defines(env), rec);
+
+  /* check for (set! x x) */
+  if (SAME_TYPE(SCHEME_TYPE(var), SCHEME_TYPE(val))) {
+    if (SAME_TYPE(SCHEME_TYPE(var), scheme_local_type)
+	|| SAME_TYPE(SCHEME_TYPE(var), scheme_local_unbox_type)) {
+      /* local */
+      if (SCHEME_LOCAL_POS(var) == SCHEME_LOCAL_POS(val))
+	return scheme_compiled_void(rec->can_optimize_constants);
+    } else {
+      /* global; can't do this b/c var might be undefined or constant */
+#if 0
+      if (SAME_OBJ(var, val))
+	return scheme_compiled_void(rec->can_optimize_constants);
+#endif
+    }
+  }
+  
+  if (SAME_TYPE(SCHEME_TYPE(var), scheme_local_type)) {
+  } else {
+    if (rec->globals_must_be_primitive) {
+      scheme_wrong_syntax("set!", NULL, form,
+			  "cannot mutate a global from within a unit");
+    }
+  } 
+
+  set_undef = SCHEME_TRUEP(scheme_get_param(scheme_config,
+					    MZCONFIG_ALLOW_SET_UNDEFINED));
+  
+  return scheme_make_syntax_compile(set_link, 
+				    cons(set_undef
+					 ? scheme_true
+					 : scheme_false,
+					 cons(var, val)));
+}
+
+static Scheme_Object *
+set_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  int l = check_form("set!", form);
+  if (l != 3)
+    bad_form(form, "set!", l);
+
+  env = scheme_no_defines(env);
+
+  return cons(set_symbol,
+	      cons(SCHEME_CADR(form),
+		   cons(scheme_expand_expr(SCHEME_CADR(SCHEME_CDR(form)), env, depth),
+			scheme_null)));
+}
+
+static Scheme_Object *
+case_lambda_execute(Scheme_Object *expr)
+{
+  Scheme_Case_Lambda *seqin, *seqout;
+  int i;
+  Scheme_Process *p = scheme_current_process;
+
+  seqin = (Scheme_Case_Lambda *)expr;
+
+  seqout = (Scheme_Case_Lambda *)
+    scheme_malloc_stubborn_tagged(sizeof(Scheme_Case_Lambda)
+				  + (seqin->count - 1) * sizeof(Scheme_Object *));
+  seqout->type = scheme_case_closure_type;
+  seqout->count = seqin->count;
+  seqout->name = seqin->name;
+
+  for (i = 0; i < seqin->count; i++) {
+    if (SAME_TYPE(SCHEME_TYPE(seqin->array[i]), scheme_linked_closure_type))
+      seqout->array[i] = seqin->array[i];
+    else
+      seqout->array[i] = scheme_make_linked_closure(p, seqin->array[i], 1);
+  }
+
+  scheme_end_stubborn_change((void *)seqout);
+
+  return (Scheme_Object *)seqout;
+}
+
+static Scheme_Object *
+case_lambda_link(Scheme_Object *expr, Link_Info *link)
+{
+  int i;
+  Scheme_Case_Lambda *seq = (Scheme_Case_Lambda *)expr;
+
+  for (i = 0; i < seq->count; i++)
+    seq->array[i] = scheme_link_expr(seq->array[i], link);
+
+  return scheme_make_syntax_link(case_lambda_execute, expr);
+}
+
+static void case_lambda_check_line(Scheme_Object *line, Scheme_Object *form)
+{
+  Scheme_Object *body, *args;
+
+  if (!SCHEME_PAIRP(line))
+    scheme_wrong_syntax("case-lambda", line, form, NULL);
+  
+  body = SCHEME_CDR(line);
+  args = SCHEME_CAR(line);
+  
+  lambda_check_args("case-lambda", args, form);
+  
+  if (!SCHEME_PAIRP(body))
+    scheme_wrong_syntax("case-lambda", line, form, "bad syntax (%s)",
+			SCHEME_NULLP(body) ? "empty body" : IMPROPER_LIST_FORM);
+}
+
+static Scheme_Object *
+case_lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		    Scheme_Compile_Info *rec)
+{
+  Scheme_Object *list, *last, *c, *orig_form = form, *name;
+  Scheme_Case_Lambda *cl;
+  int i, count = 0;
+  Scheme_Compile_Info *recs;
+  
+  form = SCHEME_CDR(form);
+
+  if (SCHEME_NULLP(form)) {
+    form = (Scheme_Object *)scheme_malloc_tagged(sizeof(Scheme_Case_Lambda)
+						 - sizeof(Scheme_Object*));
+
+    form->type = scheme_case_lambda_sequence_type;
+    ((Scheme_Case_Lambda *)form)->count = 0;
+    ((Scheme_Case_Lambda *)form)->name = rec->value_name;
+
+    scheme_compile_rec_done_local(rec);
+    scheme_default_compile_rec(rec);
+
+    return scheme_make_syntax_compile(case_lambda_link, form);
+  }
+
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax("case-lambda", form, orig_form, NULL);
+  if (SCHEME_NULLP(SCHEME_CDR(form))) {
+    case_lambda_check_line(SCHEME_CAR(form), orig_form);
+    
+    return lambda_syntax(scheme_make_pair(lambda_symbol,
+					  SCHEME_CAR(form)), env, rec);
+  }
+
+  name = rec->value_name;
+  scheme_compile_rec_done_local(rec);
+
+  list = last = NULL;
+  while (SCHEME_PAIRP(form)) {
+    case_lambda_check_line(SCHEME_CAR(form), orig_form);
+
+    c = scheme_make_pair(scheme_make_pair(lambda_symbol, SCHEME_CAR(form)),
+			 scheme_null);
+    if (list)
+      SCHEME_CDR(last) = c;
+    else
+      list = c;
+
+    last = c;
+    form = SCHEME_CDR(form);
+
+    count++;
+  }
+
+  if (!SCHEME_NULLP(form))
+    scheme_wrong_syntax("case-lambda", form, orig_form, NULL);
+
+  cl = (Scheme_Case_Lambda *)
+    scheme_malloc_stubborn_tagged(sizeof(Scheme_Case_Lambda)
+				  + (count - 1) * sizeof(Scheme_Object *));
+  cl->type = scheme_case_lambda_sequence_type;
+  cl->count = count;
+  cl->name = name;
+
+  scheme_compile_rec_done_local(rec);
+  recs = MALLOC_N(Scheme_Compile_Info, count);
+  scheme_init_compile_recs(rec, recs, count);
+
+  for (i = 0; i < count; i++, list = SCHEME_CDR(list))
+    cl->array[i] = scheme_compile_expr(SCHEME_CAR(list), env, recs + i);
+
+  scheme_end_stubborn_change((void *)cl);
+
+  scheme_merge_compile_recs(rec, recs, count);
+
+  return scheme_make_syntax_compile(case_lambda_link, (Scheme_Object *)cl);
+}
+
+static Scheme_Object *
+case_lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  Scheme_Object *first, *last, *args, *body, *c, *orig_form = form;
+
+  last = first = cons(case_lambda_symbol, scheme_null);
+  form = SCHEME_CDR(form);
+
+  while (SCHEME_PAIRP(form)) {
+    args = SCHEME_CAR(form);
+
+    case_lambda_check_line(args, orig_form);
+    
+    body = SCHEME_CDR(args);
+    args = SCHEME_CAR(args);
+    
+    c = cons(cons(args, 
+		  scheme_expand_block(body, 
+				      scheme_add_compilation_frame(args, 
+								   env, 
+								   0), 
+				      depth)),
+	     scheme_null);
+
+    SCHEME_CDR(last) = c;
+    last = c;
+
+    form = SCHEME_CDR(form);
+  }
+
+  if (!SCHEME_NULLP(form))
+    scheme_wrong_syntax("case-lambda", form, orig_form, NULL);
+  
+  return first;
+}
+
+Scheme_Object *scheme_bangboxenv_execute(Scheme_Object *data)
+{
+  int pos = SCHEME_INT_VAL(SCHEME_CAR(data));
+  Scheme_Process *run = scheme_current_process;
+
+  data = SCHEME_CDR(data);
+  
+  run->runstack[pos] = scheme_make_envunbox(run->runstack[pos]);
+
+  return _scheme_tail_eval(data);
+}
+
+static Scheme_Object *
+bangboxvalue_execute(Scheme_Object *data)
+{
+  int pos = SCHEME_INT_VAL(SCHEME_CAR(data));
+  Scheme_Object *val;
+
+  data = SCHEME_CDR(data);
+  
+  val = _scheme_eval_compiled_expr_multi(data);
+
+  if (SAME_OBJ(val, SCHEME_MULTIPLE_VALUES)) {
+    Scheme_Process *p = scheme_current_process;
+    if (pos < p->ku.multiple.count) {
+      Scheme_Object **naya, **a;
+      int i;
+
+      naya = (Scheme_Object **)scheme_malloc(p->ku.multiple.count * sizeof(Scheme_Object *));
+      a = p->ku.multiple.array;
+
+      for (i = p->ku.multiple.count; i--; )
+	naya[i] = a[i];
+      naya[pos] = scheme_make_envunbox(naya[pos]);
+
+      p->ku.multiple.array = naya;
+    }
+  } else if (!pos)
+    val = scheme_make_envunbox(val);
+
+  return val;
+}
+
+Scheme_Object *
+scheme_link_lets(Scheme_Object *form, Link_Info *info)
+{
+  Link_Info *linfo, *val_linfo;
+  Scheme_Let_Header *head = (Scheme_Let_Header *)form;
+  Scheme_Compiled_Let_Value *clv, *pre_body;
+  Scheme_Let_Value *lv, *last = NULL;
+  Scheme_Object *first = NULL, *body;
+  Scheme_Letrec *letrec;
+  int i, pos, opos, rpos, recbox, num_rec_procs = 0, extra_alloc;
+
+  /* Find body: */
+  body = head->body;
+  pre_body = NULL;
+  for (i = head->num_clauses; i--; ) {
+    pre_body = (Scheme_Compiled_Let_Value *)body;
+    body = pre_body->body;
+  }
+
+  recbox = 0;
+  if (head->recursive) {
+    /* Do we need to box vars in a letrec? */
+    clv = (Scheme_Compiled_Let_Value *)head->body;
+    for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) {
+      int is_proc = scheme_is_compiled_procedure(clv->value, 1);
+      
+      if (!(is_proc || (SCHEME_TYPE(clv->value) > _scheme_compiled_values_types_))) {
+	recbox = 1;
+	break;
+      } else {
+	int j;
+
+	for (j = 0; j < clv->count; j++) {
+	  if (clv->flags[j] & SCHEME_WAS_SET_BANGED) {
+	    recbox = 1;
+	    break;
+	  }
+	}
+	if (recbox)
+	  break;
+
+	if (scheme_is_compiled_procedure(clv->value, 0))
+	  num_rec_procs++;
+      }
+    }
+
+    if (recbox)
+      num_rec_procs = 0;
+  } else {
+    /* Sequence of single-value lets? */
+    clv = (Scheme_Compiled_Let_Value *)head->body;
+    for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) {
+      if (clv->count != 1)
+	break;
+      if (clv->flags[0] & SCHEME_WAS_SET_BANGED)
+	break;
+    }
+    if (i < 0) {
+      /* Yes - build chain of Scheme_Let_Ones and we're done: */
+      clv = (Scheme_Compiled_Let_Value *)head->body;
+
+      for (i = 0; i < head->num_clauses; i++, clv = (Scheme_Compiled_Let_Value *)clv->body) {
+	Scheme_Let_One *lo = MALLOC_ONE_TAGGED(Scheme_Let_One);
+	int j;
+
+	lo->type = scheme_let_one_type;
+
+	/* First `i+1' now "exist at runtime". */
+	/* The mapping is complicated because we now push in the order of 
+	   the variables, but it was compiled using the inverse order. */
+	linfo = scheme_link_info_extend(info, i + 1, head->count, i + 1);
+	for (j = 0; j <= i; j++)
+	  scheme_link_info_add_mapping(linfo, j, i - j, 0);
+
+	lo->value = scheme_link_expr(clv->value, linfo);
+	lo->eval_type = scheme_get_eval_type(lo->value);
+
+	if (last)
+	  ((Scheme_Let_One *)last)->body = (Scheme_Object *)lo;
+	else
+	  first = (Scheme_Object *)lo;
+	last = (Scheme_Let_Value *)lo;
+      }
+
+      linfo = scheme_link_info_extend(info, head->count, head->count, head->count);
+      for (i = head->count; i--; )
+	scheme_link_info_add_mapping(linfo, i, head->count - 1 - i, 0);
+      
+      body = scheme_link_expr(body, linfo);
+      if (last)
+	((Scheme_Let_One *)last)->body = body;
+      else
+	first = body;
+      
+      return first;
+    }
+  }
+
+  linfo = scheme_link_info_extend(info, head->count, head->count, head->count);
+
+  /* Build mapping of compile-time indices to run-time indices, shuffling
+     letrecs to fall together: */
+  clv = (Scheme_Compiled_Let_Value *)head->body;
+  pos = num_rec_procs;
+  rpos = 0; opos = 0;
+  for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) {
+    int j;
+
+    for (j = 0; j < clv->count; j++) {
+      int p;
+
+      if (num_rec_procs && scheme_is_compiled_procedure(clv->value, 0))
+	p = rpos++;
+      else
+	p = pos++;
+      
+      scheme_link_info_add_mapping(linfo, opos, p,
+				   ((recbox 
+				     || (clv->flags[j] & SCHEME_WAS_SET_BANGED))
+				    ? SCHEME_INFO_BOXED
+				    : 0));
+
+      opos++;
+    }
+  }
+
+  /* Link body: */
+  body = scheme_link_expr(body, linfo);
+
+  /* Check for collasping let_void: */
+  extra_alloc = 0;
+  val_linfo = linfo;
+  if (!num_rec_procs) {
+    if (SAME_TYPE(SCHEME_TYPE(body), scheme_let_void_type)) {
+      Scheme_Let_Void *lv = (Scheme_Let_Void *)body;
+      
+      if (!!lv->autobox == !!recbox) {
+	/* Do collapse: */
+	extra_alloc = lv->count;
+	body = lv->body;
+	val_linfo = scheme_link_info_extend(linfo, extra_alloc, 0, 0);
+      }
+    }
+  }
+
+  if (num_rec_procs) {
+    letrec = MALLOC_ONE_TAGGED(Scheme_Letrec);
+    letrec->type = scheme_letrec_type;
+    letrec->count = num_rec_procs;
+    letrec->procs = MALLOC_N(Scheme_Object *, num_rec_procs);
+  } else
+    letrec = NULL;
+
+  /* Link values: */
+  clv = (Scheme_Compiled_Let_Value *)head->body;
+  rpos = 0; opos = 0;
+  for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) {
+    int isproc = scheme_is_compiled_procedure(clv->value, 0);
+    Scheme_Object *expr = scheme_link_expr(clv->value, val_linfo);
+    if (num_rec_procs && isproc) {
+      letrec->procs[rpos++] = expr;
+    } else {
+      int j;
+
+      lv = MALLOC_ONE_TAGGED(Scheme_Let_Value);
+      if (last)
+	last->body = (Scheme_Object *)lv;
+      else
+	first = (Scheme_Object *)lv;
+      last = lv;
+      
+      lv->type = scheme_let_value_type;
+      lv->value = expr;
+      if (clv->count)
+	lv->position = scheme_link_info_lookup(linfo, clv->position, NULL) + extra_alloc;
+      else
+	lv->position = 0;
+      lv->count = clv->count;
+      lv->autobox = recbox;
+
+      for (j = lv->count; j--; )
+	if (!recbox
+	    && (scheme_link_info_flags(linfo, opos + j) & SCHEME_INFO_BOXED))
+	  lv->value = scheme_make_syntax_link(bangboxvalue_execute, 
+					      cons(scheme_make_integer(j),
+						   lv->value));
+    }
+    opos += clv->count;
+  }
+  
+  if (letrec) {
+    letrec->body = body;
+    if (last)
+      last->body = (Scheme_Object *)letrec;
+    else
+      first = (Scheme_Object *)letrec;
+  } else
+    last->body = body;
+
+  {
+    Scheme_Let_Void *lv;
+
+    lv = MALLOC_ONE_TAGGED(Scheme_Let_Void);
+    lv->type = scheme_let_void_type;
+    lv->body = first;
+    lv->count = head->count + extra_alloc;
+    lv->autobox = recbox;
+
+    first = (Scheme_Object *)lv;
+  }
+
+  return first;
+}
+
+static Scheme_Object *
+gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *env, char *formname,
+		int star, int recursive, int multi, Scheme_Compile_Info *rec)
+{
+  Scheme_Object *bindings, *l, *binding, *name, **names, *forms, *defname;
+  int num_clauses, num_bindings, i, j, k, m, pre_k;
+  Scheme_Comp_Env *frame;
+  Scheme_Compile_Info *recs;
+  Scheme_Object *first = NULL;
+  Scheme_Compiled_Let_Value *last = NULL, *lv;
+
+  if (scheme_proper_list_length(form) < 3)
+    scheme_wrong_syntax(formname, NULL, form, NULL);
+
+  bindings = SCHEME_CAR(SCHEME_CDR(form));
+  num_clauses = scheme_proper_list_length(bindings);
+
+  if (num_clauses < 0)
+    scheme_wrong_syntax(formname, bindings, form, NULL);
+
+  forms = SCHEME_CDR(SCHEME_CDR(form));
+
+  if (!num_clauses) {
+    env = scheme_no_defines(env);
+    return scheme_compile_sequence(forms, env, rec);
+  }
+  
+  if (multi) {
+    num_bindings = 0;
+    l = bindings;
+    while (!SCHEME_NULLP(l)) {
+      Scheme_Object *clause, *names;
+      int num_names;
+
+      clause = SCHEME_CAR(l);
+      
+      if (!SCHEME_PAIRP(clause)
+	  || !SCHEME_PAIRP(SCHEME_CDR(clause))
+	  || !SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(clause))))
+	scheme_wrong_syntax(formname, clause, form, NULL);
+      
+      names = SCHEME_CAR(clause);
+      
+      num_names = scheme_proper_list_length(names);
+      if (num_names < 0)
+	scheme_wrong_syntax(formname, names, form, NULL);
+     
+      num_bindings += num_names;
+ 
+      l = SCHEME_CDR(l);
+    }
+  } else
+    num_bindings = num_clauses;
+
+
+  names = (Scheme_Object **)scheme_malloc_stubborn(num_bindings
+						   * sizeof(Scheme_Object*));
+
+  env = frame = scheme_new_compilation_frame(num_bindings, SCHEME_LET_FRAME, env);
+
+  recs = (Scheme_Compile_Info *)scheme_malloc((num_clauses + 1)
+					      * sizeof(Scheme_Compile_Info));
+
+  defname = rec->value_name;
+  scheme_compile_rec_done_local(rec);
+  scheme_init_compile_recs(rec, recs, num_clauses + 1);
+
+  for (i = 0, k = 0; i < num_clauses; i++) {
+    if (!SCHEME_PAIRP(bindings))
+      scheme_wrong_syntax(formname, bindings, form, NULL);
+    binding = SCHEME_CAR(bindings);
+    if (!(SCHEME_PAIRP(binding) && SCHEME_PAIRP(SCHEME_CDR(binding))
+	  && SCHEME_NULLP(SCHEME_CDDR(binding))))
+      scheme_wrong_syntax(formname, binding, form, NULL);
+    
+    pre_k = k;
+
+    name = SCHEME_CAR(binding);
+    if (multi) {
+      while (!SCHEME_NULLP(name)) {
+	names[k] = SCHEME_CAR(name);
+	scheme_check_identifier(formname, names[k], NULL, env, form);
+	k++;
+	name = SCHEME_CDR(name);
+      }
+
+      for (j = pre_k; j < k; j++)
+	for (m = j + 1; m < k; m++)
+	  if (SAME_OBJ(names[m], names[j]))
+	    scheme_wrong_syntax(formname, NULL, form,
+				"multiple bindings of \"%s\" in the same clause", 
+				scheme_symbol_name(names[m]));
+
+    } else {
+      scheme_check_identifier(formname, name, NULL, env, form);
+      names[k++] = name;
+    }
+
+    if (!star) {
+      for (j = 0; j < pre_k; j++)
+	for (m = pre_k; m < k; m++)
+	  if (SAME_OBJ(names[m], names[j]))
+	    scheme_wrong_syntax(formname, NULL, form,
+				"multiple bindings of \"%s\"", 
+				scheme_symbol_name(names[m]));
+    }
+
+    lv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value);
+    lv->type = scheme_compiled_let_value_type;
+    if (!last)
+      first = (Scheme_Object *)lv;
+    else
+      last->body = (Scheme_Object *)lv;
+    last = lv;
+    lv->count = (k - pre_k);
+    lv->position = pre_k;
+
+    if (lv->count == 1)
+      recs[i].value_name = names[pre_k];
+
+    if (!recursive)
+      lv->value = scheme_compile_expr(SCHEME_CADR(binding), env, &recs[i]);
+    else
+      lv->value = SCHEME_CADR(binding);
+    
+    if (star || recursive) {
+      for (m = pre_k; m < k; m++)
+	scheme_add_compilation_binding(m, names[m], frame);
+    }
+    
+    bindings = SCHEME_CDR (bindings);
+  }
+  
+  if (!star && !recursive) {
+    for (i = 0; i < num_bindings; i++)
+      scheme_add_compilation_binding(i, names[i], frame);
+  }
+
+  if (recursive) {
+    lv = (Scheme_Compiled_Let_Value *)first;
+    for (i = 0; i < num_clauses; i++, lv = (Scheme_Compiled_Let_Value *)lv->body)
+      lv->value = scheme_compile_expr(lv->value, env, &recs[i]);
+  }
+
+  recs[num_clauses].value_name = defname;
+  last->body = scheme_compile_sequence(forms, env, recs + num_clauses);
+
+  /* Save flags: */
+  lv = (Scheme_Compiled_Let_Value *)first;
+  for (i = 0; i < num_clauses; i++, lv = (Scheme_Compiled_Let_Value *)lv->body)
+    lv->flags = scheme_env_get_flags(env, lv->position, lv->count);
+
+  {
+    Scheme_Let_Header *head;
+    
+    head = MALLOC_ONE_TAGGED(Scheme_Let_Header);
+    head->type = scheme_compiled_let_void_type;
+    head->body = first;
+    head->count = num_bindings;
+    head->num_clauses = num_clauses;
+    head->recursive = recursive;
+
+    first = (Scheme_Object *)head;
+  }
+  
+  scheme_merge_compile_recs(rec, recs, num_clauses + 1);
+
+  scheme_end_stubborn_change((void *)names);
+
+  rec->max_let_depth += num_bindings;
+
+  return first;
+}
+
+static Scheme_Object *
+let_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  int named, letrec = 0, letstar = 0, multi = 0;
+  const char *formname;
+  Scheme_Object *fmname;
+  Scheme_Object *vars, *body, *first, *last, *name, *v, *vs, *vlist;
+  Scheme_Comp_Env *use_env;
+
+  fmname = SCHEME_CAR(form);
+
+  if (SAME_OBJ(fmname, letrec_symbol)
+      || SAME_OBJ(fmname, letrec_symbol_nohp)
+      || SAME_OBJ(fmname, letrec_star_symbol)
+      || SAME_OBJ(fmname, letrec_star_symbol_nohp)) {
+    letrec = 1;
+    formname = "letrec*";
+  } else if (SAME_OBJ(fmname, letrec_values_symbol)
+      || SAME_OBJ(fmname, letrec_values_symbol_nohp)
+      || SAME_OBJ(fmname, letrec_star_values_symbol)
+      || SAME_OBJ(fmname, letrec_star_values_symbol_nohp)) {
+    letrec = 1;
+    multi = 1;
+    formname = "letrec*-values";
+  } else if (SAME_OBJ(fmname, let_star_symbol)
+	     || SAME_OBJ(fmname, let_star_symbol_nohp)) {
+    letstar = 1;
+    formname = "let*";
+  } else if (SAME_OBJ(fmname, let_star_values_symbol)
+	     || SAME_OBJ(fmname, let_star_values_symbol_nohp)) {
+    letstar = 1;
+    multi = 1;
+    formname = "let*-values";
+  } else if (SAME_OBJ(fmname, let_values_symbol)
+	     || SAME_OBJ(fmname, let_values_symbol_nohp)) {
+    multi = 1;
+    formname = "let-values";
+  } else {
+    formname = "let";
+  }
+  
+  vars = SCHEME_CDR(form);
+
+  named = !multi && !letrec && !letstar && SCHEME_PAIRP(vars) && SCHEME_SYMBOLP(SCHEME_CAR(vars));
+  
+  if (named)
+    return named_let_syntax(form, env, NULL, depth);
+
+  if (!SCHEME_PAIRP(vars))
+    scheme_wrong_syntax(formname, vars, form, NULL);
+
+  body = SCHEME_CDR(vars);
+  vars = SCHEME_CAR(vars);
+
+  if (!SCHEME_PAIRP(body))
+    scheme_wrong_syntax(formname, body, form, NULL);
+
+  if (letstar) {
+    if (!SCHEME_NULLP(vars)) {
+      if (!SCHEME_PAIRP(vars))
+	scheme_wrong_syntax(formname, vars, form, NULL);
+
+      body = cons(multi ? let_values_symbol : let_symbol,
+		  cons(cons(SCHEME_CAR(vars), scheme_null),
+		       cons(cons(multi ? let_star_values_symbol : let_star_symbol,
+				 cons(SCHEME_CDR(vars), body)),
+			    scheme_null)));
+    } else
+      body = cons(let_values_symbol, cons(scheme_null, body));
+
+    --depth;
+    if (!depth)
+      return body;
+    else {
+      env = scheme_no_defines(env);
+      return scheme_expand_expr(body, env, depth);
+    }
+  }
+
+  vlist = scheme_null;
+  vs = vars;
+  while (SCHEME_PAIRP(vs)) {
+    v = SCHEME_CAR(vs);
+    if (!SCHEME_PAIRP(v))
+      scheme_wrong_syntax(formname, v, form, NULL);
+
+    name = SCHEME_CAR(v);
+    
+    if (multi) {
+      Scheme_Object *names = name;
+      while (SCHEME_PAIRP(names)) {
+	name = SCHEME_CAR(names);
+
+	scheme_check_identifier(formname, name, NULL, env, form);
+	vlist = cons(name, vlist);
+	
+	names = SCHEME_CDR(names);
+      }
+    } else {
+      scheme_check_identifier(formname, name, NULL, env, form);
+      vlist = cons(name, vlist);
+    }
+
+    vs = SCHEME_CDR(vs);
+  }
+
+  if (!SCHEME_NULLP(vs))
+    scheme_wrong_syntax(formname, vs, form, NULL);
+
+  use_env = env;
+  env = scheme_add_compilation_frame(vlist, env, 0);
+
+  if (letrec)
+    use_env = env;
+
+  first = last = NULL;
+  while (SCHEME_PAIRP(vars)) {
+    v = SCHEME_CAR(vars);
+
+    name = SCHEME_CAR(v);
+    if (!multi)
+      name = cons(name, scheme_null);
+
+    v = scheme_expand_expr(SCHEME_CDR(v), use_env, depth);
+    v = cons(cons(name, v), scheme_null);
+
+    if (!first)
+      first = v;
+    else
+      SCHEME_CDR(last) = v;
+
+    last = v;
+
+    vars = SCHEME_CDR(vars);
+  }
+
+  if (!SCHEME_NULLP(vars))
+    scheme_wrong_syntax(formname, vars, form, NULL);
+  
+  if (!first)
+    first = scheme_null;
+
+  body = scheme_expand_block(body, env, depth);
+
+  if (named)
+    return cons(let_symbol,
+		cons(SCHEME_CADR(form),
+		     cons(first, body)));
+  else
+    return cons((letrec ? letrec_star_values_symbol : let_values_symbol),
+		cons(first, body));
+}
+
+static Scheme_Object *
+let_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  if (!SCHEME_PAIRP(SCHEME_CDR(form)))
+    scheme_wrong_syntax("let", NULL, form, "bad syntax (" IMPROPER_LIST_FORM ")");
+
+  if (SCHEME_SYMBOLP (SCHEME_CAR (SCHEME_CDR (form))))
+    return named_let_syntax (form, env, rec, 0);
+  
+  return gen_let_syntax(form, env, "let", 0, 0, 0, rec);
+}
+
+static Scheme_Object *
+let_star_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		 Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "let*", 1, 0, 0, rec);
+}
+
+static Scheme_Object *
+letrec_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "letrec", 0, 1, 0, rec);
+}
+
+static Scheme_Object *
+letrec_star_syntax(Scheme_Object *form,Scheme_Comp_Env*env,Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "letrec*", 0, 1, 0, rec);
+}
+
+static Scheme_Object *
+let_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		   Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "let-values", 0, 0, 1, rec);
+}
+
+static Scheme_Object *
+let_star_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		 Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "let*-values", 1, 0, 1, rec);
+}
+
+static Scheme_Object *
+letrec_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "letrec-values", 0, 1, 1, rec);
+}
+
+static Scheme_Object *
+letrec_star_values_syntax(Scheme_Object *form,Scheme_Comp_Env*env,Scheme_Compile_Info *rec)
+{
+  return gen_let_syntax(form, env, "letrec*-values", 0, 1, 1, rec);
+}
+
+
+static Scheme_Object *nl_car(Scheme_Object *l, Scheme_Object *form)
+{
+  Scheme_Object *s;
+  
+  if (!SCHEME_PAIRP(l))
+    scheme_wrong_syntax("named let", l, form, 
+			"bad syntax (non-symbol-value-pair)");
+  s = SCHEME_CAR(l);
+  if (!SCHEME_SYMBOLP(s))
+    scheme_wrong_syntax("named let", s, form, 
+			"bad syntax (name not an identifier)");
+
+  return s;
+}
+
+static Scheme_Object *nl_cadr(Scheme_Object *l, Scheme_Object *form)
+{
+  if (!SCHEME_PAIRP(l) || !SCHEME_PAIRP(SCHEME_CDR(l)))
+    scheme_wrong_syntax("named let", l, form, 
+			"bad syntax (non-identifier-value-pair)");
+  
+  if (!SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(l))))
+    scheme_wrong_syntax("named let", l, form, 
+			"bad syntax (extra data in indentifier-value pair)");
+  
+  return SCHEME_CADR(l);
+}
+
+static Scheme_Object *
+named_let_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		  Scheme_Compile_Info *rec, int depth)
+{
+  Scheme_Object *name, *bindings, *vars, *vals, *forms;
+  Scheme_Object *proc, *init, *letrec;
+
+  if (!(SCHEME_PAIRP(SCHEME_CDR (form))
+	&& SCHEME_PAIRP(SCHEME_CDR(SCHEME_CDR (form)))
+	&& SCHEME_PAIRP(SCHEME_CDR(SCHEME_CDR(SCHEME_CDR (form))))))
+    scheme_wrong_syntax("named let", NULL, form, NULL);
+  name = SCHEME_CAR (SCHEME_CDR (form));
+  bindings = SCHEME_CAR (SCHEME_CDR (SCHEME_CDR (form)));
+  if (!SCHEME_LISTP(bindings))
+    scheme_wrong_syntax("named let", bindings, form, NULL);
+
+  vars = scheme_named_map_1("named let", nl_car, bindings, form);
+  vals = scheme_named_map_1("named let", nl_cadr, bindings, form);
+  
+  forms = SCHEME_CDR (SCHEME_CDR (SCHEME_CDR (form)));
+
+  proc = cons(lambda_symbol, cons(vars, forms));
+  init = cons(name, vals);
+  
+  letrec = cons(letrec_symbol,
+		cons(cons(cons(name, cons(proc, scheme_null)), scheme_null),
+		     cons(init,
+			  scheme_null)));
+
+  if (rec)
+    return scheme_compile_expr(letrec, env, rec);
+  else {
+    --depth;
+    if (!depth)
+      return letrec;
+    else
+      return scheme_expand_expr(letrec, env, depth);
+  }
+}
+
+Scheme_Object *scheme_compile_sequence(Scheme_Object *forms,
+				       Scheme_Comp_Env *env, 
+				       Scheme_Compile_Info *rec)
+{
+  if (SCHEME_PAIRP(forms) && SCHEME_NULLP(SCHEME_CDR(forms)))
+    return scheme_compile_expr(SCHEME_CAR(forms), env, rec);
+  else
+    return scheme_compile_expr(cons(begin_symbol, forms), env, rec);
+}
+
+Scheme_Object *scheme_compiled_void(int can_be_value)
+{
+  if (can_be_value)
+    return scheme_void;
+  else
+    return scheme_compiled_void_code;
+}
+
+static Scheme_Object *
+begin0_execute(Scheme_Object *obj)
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object *v, **mv;
+  Scheme_Object **array;
+  int i, mc;
+  
+  i = ((Scheme_Sequence *)obj)->count;
+  array = ((Scheme_Sequence *)obj)->array;
+
+  v = _scheme_eval_compiled_expr_multi_wp(*(array++), p);
+  i--;
+  if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+    mv = p->ku.multiple.array;
+    mc = p->ku.multiple.count;
+  } else
+    mv = NULL;
+
+  while (i--)
+    (void)_scheme_eval_compiled_expr_multi_wp(*(array++), p);
+
+  if (mv) {
+    p->ku.multiple.array = mv;
+    p->ku.multiple.count = mc;
+  }
+
+  return v;
+}
+
+static Scheme_Object *
+begin0_link (Scheme_Object *obj, Link_Info *info)
+{
+  Scheme_Object **array;
+  int i;
+  
+  i = ((Scheme_Sequence *)obj)->count;
+  array = ((Scheme_Sequence *)obj)->array;
+
+  while (i--)
+    array[i] = scheme_link_expr(array[i], info);
+
+  return scheme_make_syntax_link(begin0_execute, obj);
+}
+
+static Scheme_Object *
+do_begin_syntax (char *name,
+		 Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, 
+		 int zero)
+{
+  Scheme_Object *forms, *body;
+
+  forms = SCHEME_CDR (form);
+  
+  if (SCHEME_NULLP(forms)) {
+    scheme_wrong_syntax(name, NULL, form, "bad syntax (empty form)");
+    return NULL;
+  }
+
+  check_form(name, forms);
+
+  if (zero)
+    env = scheme_no_defines(env);
+
+  if (SCHEME_NULLP(SCHEME_CDR(forms)))
+    return scheme_compile_expr(SCHEME_CAR(forms), env, rec);
+
+  if (!scheme_is_toplevel(env)) {
+    /* Not at top-level */
+    if (zero) {
+      /* First expression is not part of the block: */
+      Scheme_Compile_Info recs[2];
+      Scheme_Object *first, *rest, *vname;
+
+      vname = rec->value_name;
+      scheme_compile_rec_done_local(rec);
+
+      scheme_init_compile_recs(rec, recs, 2);
+      recs[0].value_name = vname;
+
+      first = scheme_compile_expr(SCHEME_CAR(forms), env, recs);
+      rest = scheme_compile_block(SCHEME_CDR(forms), env, recs + 1);
+      
+      scheme_merge_compile_recs(rec, recs, 2);
+
+      body = cons(first, rest);
+    } else 
+      body = scheme_compile_block(forms, env, rec);
+  } else
+    /* Top level */
+    body = scheme_compile_list(forms, env, rec);
+
+  forms = scheme_make_sequence_compilation(body, rec->can_optimize_constants, 
+					   zero ? -1 : 1);
+
+  if (!zero || (NOT_SAME_TYPE(SCHEME_TYPE(forms), scheme_begin0_sequence_type)))
+    return forms;
+
+  return scheme_make_syntax_compile(begin0_link, forms);
+}
+
+static Scheme_Object *
+begin_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  return do_begin_syntax("begin", form, env, rec, 0);
+}
+
+static Scheme_Object *
+begin0_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  return do_begin_syntax("begin0", form, env, rec, 1);
+}
+
+static Scheme_Object *
+do_begin_expand(char *name, Scheme_Object *form_name,
+		Scheme_Object *form, Scheme_Comp_Env *env, int depth,
+		int zero)
+{
+  Scheme_Object *rest;
+
+  check_form(name, form);
+
+  rest = SCHEME_CDR(form);
+
+  if (SCHEME_NULLP(rest)) {
+    scheme_wrong_syntax(name, NULL, form, "bad syntax (empty form)");
+    return NULL;
+  }
+
+  if (zero)
+    env = scheme_no_defines(env);
+
+  if (!scheme_is_toplevel(env)) {
+    /* Not at top-level: */
+    if (zero) {
+      form = cons(scheme_expand_expr(SCHEME_CAR(rest), env, depth),
+		  scheme_expand_block(SCHEME_CDR(rest), env, depth));
+    } else {
+      form = scheme_expand_block(rest, env, depth);
+#if 0
+      if (SCHEME_NULLP(SCHEME_CDR(form)))
+	return SCHEME_CAR(form);
+#endif
+    }
+  } else {
+    /* Top level */
+    form =  scheme_expand_list(rest, env, depth);
+  }
+
+  return cons(form_name, form);
+}
+
+static Scheme_Object *
+begin_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_begin_expand("begin", begin_symbol, form, env, depth, 0);
+}
+
+static Scheme_Object *
+begin0_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_begin_expand("begin0", begin0_symbol, form, env, depth, 1);
+}
+
+static Scheme_Object *
+empty_cond_execute (Scheme_Object *expr)
+{
+  scheme_raise_exn(MZEXN_ELSE, "cond or case: no matching clause");
+  return scheme_void;
+}
+
+static Scheme_Object *
+empty_cond_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  Scheme_Env *top = scheme_min_env(env);
+
+  if (SCHEME_FALSEP(scheme_get_param(scheme_config, MZCONFIG_COND_AUTO_ELSE)))
+    if (SCHEME_NULLP(SCHEME_CDR(form))) {
+      return scheme_make_syntax_link(empty_cond_execute, scheme_false);
+    }
+
+  return scheme_compile_expand_macro_app(top->nonempty_cond,
+					 form, env, rec, 1);
+}
+
+static Scheme_Object *
+empty_cond_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  Scheme_Env *top = scheme_min_env(env);
+
+  if (SCHEME_FALSEP(scheme_get_param(scheme_config, MZCONFIG_COND_AUTO_ELSE)))
+    if (SCHEME_NULLP(SCHEME_CDR(form)))
+      return form;
+
+  return scheme_compile_expand_macro_app(top->nonempty_cond,
+					 form, env, NULL, depth);
+}
+
+
+static Scheme_Object *
+unquote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec)
+{
+  int len;
+  char *who;
+
+  if (rec)
+    scheme_compile_rec_done_local(rec);
+
+  who = SCHEME_SYM_VAL(SCHEME_CAR(form));
+
+  len = check_form(who, form);
+  if (len != 2)
+    bad_form(form, who, len);
+
+  scheme_wrong_syntax(who, NULL, form, "not in quasiquote");
+  return NULL;
+}
+
+static Scheme_Object *
+unquote_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return unquote_syntax(form, env, NULL);
+}
+
+
+static Scheme_Object *
+do_def_execute(char *who, Scheme_Object *form, Scheme_Type type, int require_proc)
+{
+  Scheme_Object *name;
+  Scheme_Object *val, *macro;
+  Scheme_Comp_Env *save_env;
+  Scheme_Process *p = scheme_current_process;
+
+  name = SCHEME_CAR(form);
+  val = SCHEME_CDR(form);
+
+  save_env = p->current_local_env;
+  p->current_local_env = scheme_get_env(p->config)->init;
+  val = _scheme_eval_compiled_expr(val);
+  p->current_local_env = save_env;
+
+  if (require_proc)
+    if (!SCHEME_PROCP(val))
+      scheme_raise_exn(MZEXN_MISC_DEFMACRO,
+		       val,
+		       "define-macro: not a procedure");
+
+  if (SCHEME_TRUEP(name)) {
+    macro = scheme_alloc_stubborn_small_object ();
+    macro->type = type;
+    SCHEME_PTR_VAL(macro) = val;
+    scheme_end_stubborn_change((void *)macro);
+      
+    scheme_set_global_bucket(who, (Scheme_Bucket *)name, macro, 1);
+
+    return scheme_void;
+  } else
+    return val;
+}
+
+static void do_def_parse(char *where,
+			 Scheme_Object *form, 
+			 Scheme_Object **name, Scheme_Object **code,
+			 Scheme_Comp_Env *env,
+			 int no_name)
+{
+  if (scheme_proper_list_length(form) != (no_name ? 2 : 3))
+    scheme_wrong_syntax(where, NULL, form, NULL);
+
+  if (!no_name) {
+    *name = SCHEME_CAR (SCHEME_CDR (form));
+    
+    scheme_check_identifier(where, *name, NULL, env, form);
+    
+    *code = SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(form)));
+  } else {
+    *name = scheme_false;
+    *code = SCHEME_CAR(SCHEME_CDR(form));
+  }
+}
+
+static Scheme_Object *do_def_link(Scheme_Syntax_Executer *exec,
+				  Scheme_Object *data,
+				  Link_Info *info)
+{
+  Scheme_Object *name = SCHEME_CAR(data);
+  Scheme_Object *val = SCHEME_CDR(data);
+
+  name = scheme_link_expr(name, info);
+  val = scheme_link_expr(val, info);
+
+  return scheme_make_syntax_link(exec, scheme_make_pair(name, val));
+}
+
+static Scheme_Object *
+do_def_syntax(char *where,
+	      Scheme_Object *form, Scheme_Comp_Env *env, 
+	      Scheme_Compile_Info *rec,
+	      Scheme_Syntax_Linker *link,
+	      int no_name)
+{
+  Scheme_Object *name, *code;
+  Scheme_Object *val;
+
+  if (!scheme_is_toplevel(env))
+    scheme_wrong_syntax(where, NULL, form, "illegal use (not at top-level)");
+  
+  scheme_compile_rec_done_local(rec);
+
+  do_def_parse(where, form, &name, &code, env, no_name);
+
+  val = scheme_compile_expr(code, env, rec);
+  if (!no_name)
+    name = (Scheme_Object *)scheme_global_bucket(name, scheme_min_env(env));
+
+  return scheme_make_syntax_compile(link, scheme_make_pair(name, val));
+}
+
+static Scheme_Object *
+do_def_expand(char *where, Scheme_Object *formname, Scheme_Object *form, 
+	      Scheme_Comp_Env *env, int depth, int no_name)
+{
+  Scheme_Object *name, *code, *fpart;
+
+  do_def_parse(where, form, &name, &code, env, no_name);
+  
+  fpart = scheme_expand_expr(code, env, depth);
+  
+  code = cons(fpart, scheme_null);
+  if (!no_name)
+    code = cons(name, code);
+
+  return cons(formname, code);
+}
+
+
+static Scheme_Object *
+defmacro_execute (Scheme_Object *form)
+{
+  return do_def_execute("define-macro", form, scheme_macro_type, 1);
+}
+
+static Scheme_Object *
+defmacro_link(Scheme_Object *form, Link_Info *info)
+{
+  return do_def_link(defmacro_execute, form, info);
+}
+
+static Scheme_Object *
+defmacro_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		 Scheme_Compile_Info *rec)
+{
+  return do_def_syntax("define-macro", form, env, rec,
+		       defmacro_link, 0);
+}
+
+static Scheme_Object *
+defmacro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_def_expand("define-macro", define_macro_symbol, form, env, depth, 0);
+}
+
+static Scheme_Object *
+def_id_macro_execute (Scheme_Object *form)
+{
+  return do_def_execute("define-id-macro", form, scheme_id_macro_type, 0);
+}
+
+static Scheme_Object *
+def_id_macro_link(Scheme_Object *form, Link_Info *info)
+{
+  return do_def_link(def_id_macro_execute, form, info);
+}
+
+static Scheme_Object *
+def_id_macro_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		     Scheme_Compile_Info *rec)
+{
+  return do_def_syntax("define-id-macro", form, env, rec,
+		       def_id_macro_link, 0);
+}
+
+static Scheme_Object *
+def_id_macro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_def_expand("define-id-macro", 
+		       define_id_macro_symbol, 
+		       form, env, depth, 0);
+}
+
+static Scheme_Object *
+def_exp_time_execute (Scheme_Object *form)
+{
+  return do_def_execute("define-expansion-time", form, scheme_exp_time_type, 0);
+}
+
+static Scheme_Object *
+def_exp_time_link(Scheme_Object *form, Link_Info *info)
+{
+  return do_def_link(def_exp_time_execute, form, info);
+}
+
+static Scheme_Object *
+def_exp_time_syntax (Scheme_Object *form, Scheme_Comp_Env *env, 
+		      Scheme_Compile_Info *rec)
+{
+  return do_def_syntax("define-expansion-time", form, env, rec,
+		       def_exp_time_link, 0);
+}
+
+static Scheme_Object *
+def_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_def_expand("define-expansion-time", 
+		       define_expansion_time_symbol, 
+		       form, env, depth, 0);
+}
+
+static Scheme_Object *
+begin_exp_time_syntax(Scheme_Object *form, Scheme_Comp_Env *env, 
+		      Scheme_Compile_Info *rec)
+{
+  return do_def_syntax("begin-expansion-time", form, env, rec,
+		       def_exp_time_link, 1);
+}
+
+static Scheme_Object *
+begin_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_def_expand("begin-expansion-time", 
+		       begin_expansion_time_symbol,
+		       form, env, depth, 1);
+}
+
+static Scheme_Object *
+do_letmacro(char *where, Scheme_Object *formname,
+	    Scheme_Object *forms, Scheme_Comp_Env *env, 
+	    Scheme_Compile_Info *rec, int depth,
+	    Scheme_Type type, int anything)
+{
+  Scheme_Object *form, *name, *body, *cl, *clf, *v;
+  Scheme_Object *macro;
+  Scheme_Comp_Env *save_env;
+  Scheme_Process *p = scheme_current_process;
+
+  env = scheme_no_defines(env);
+
+  form = SCHEME_CDR(forms);
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax(where, form, forms, NULL);
+  name = SCHEME_CAR(form);
+  form = SCHEME_CDR(form);
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax(where, form, forms, NULL);
+  cl = SCHEME_CAR(form);
+  form = SCHEME_CDR(form);
+  if (!SCHEME_PAIRP(form))
+    scheme_wrong_syntax(where, form, forms, NULL);
+  body = form;
+  
+  scheme_check_identifier(where, name, NULL, env, form);
+
+  save_env = p->current_local_env;
+  p->current_local_env = env;
+  clf = scheme_eval(cl, scheme_min_env(env));
+  p->current_local_env = save_env;
+
+  if (!anything && !SCHEME_PROCP(clf))
+    scheme_raise_exn(MZEXN_MISC_DEFMACRO, clf,
+		     "let-macro: not a procedure");
+
+  macro = scheme_alloc_stubborn_small_object ();
+  macro->type = type;
+  SCHEME_PTR_VAL(macro) = clf;
+  scheme_end_stubborn_change((void *)macro);
+
+  scheme_push_constant(name, macro, env);
+
+  if (rec) {
+    v = scheme_compile_block(body, env, rec);
+    v = scheme_make_sequence_compilation(v, rec->can_optimize_constants, 1);
+  } else {
+    v = scheme_expand_block(body, env, depth);
+    if (depth >= 0)
+      v = cons(formname,
+	       cons(name,
+		    cons(cl, v)));
+    else if (SCHEME_NULLP(SCHEME_CDR(v)))
+      v = SCHEME_CAR(v);
+    else
+      v = cons(begin_symbol, v);
+  }
+
+  scheme_pop_constant(env);
+
+  return v;
+}
+
+static Scheme_Object *
+letmacro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, 
+		Scheme_Compile_Info *rec)
+{
+  return do_letmacro("let-macro", NULL,
+		     form, env, rec, 0, scheme_macro_type, 0);
+}
+
+static Scheme_Object *
+letmacro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_letmacro("let-macro", let_macro_symbol, 
+		     form, env, NULL, depth, scheme_macro_type, 0);
+}
+
+static Scheme_Object *
+let_id_macro_syntax(Scheme_Object *form, Scheme_Comp_Env *env, 
+		Scheme_Compile_Info *rec)
+{
+  return do_letmacro("let-id-macro", NULL,
+		     form, env, rec, 0, scheme_id_macro_type, 1);
+}
+
+static Scheme_Object *
+let_id_macro_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_letmacro("let-id-macro", let_id_macro_symbol, 
+		     form, env, NULL, depth, scheme_id_macro_type, 1);
+}
+
+static Scheme_Object *
+let_exp_time_syntax(Scheme_Object *form, Scheme_Comp_Env *env, 
+		     Scheme_Compile_Info *rec)
+{
+  return do_letmacro("let-expansion-time", NULL,
+		     form, env, rec, 0, scheme_exp_time_type, 1);
+}
+
+static Scheme_Object *
+let_exp_time_expand(Scheme_Object *form, Scheme_Comp_Env *env, int depth)
+{
+  return do_letmacro("let-expansion-time", let_expansion_time_symbol, 
+		     form, env, NULL, depth, scheme_exp_time_type, 1);
+}
+
+static Scheme_Object *void_execute(Scheme_Object *expr)
+{
+  return scheme_void;
+}
+
+/*********************************************************************/
+
+void scheme_register_syntax(const char *name, 
+			    Scheme_Syntax_Registered *f)
+{
+  if (num_link_names == link_names_size) {
+    Linker_Name *old = linker_names;
+
+    link_names_size += 20;
+    linker_names = 
+      (Linker_Name *)scheme_malloc(link_names_size
+				   * sizeof(Linker_Name));
+
+    memcpy(linker_names, old, num_link_names * sizeof(Linker_Name));
+
+#ifdef MEMORY_COUNTING_ON
+    scheme_misc_count += (20 * sizeof(Linker_Name));
+#endif
+  }
+  
+  linker_names[num_link_names].sym = scheme_intern_symbol(name);
+  linker_names[num_link_names].f = f;
+  num_link_names++;
+}
+
+Scheme_Object *scheme_find_linker_name(Scheme_Syntax_Registered *f)
+{
+  int i;
+
+  for (i = 0; i < num_link_names; i++)
+    if (SAME_PTR(linker_names[i].f, f))
+      return linker_names[i].sym;
+
+  return NULL;
+}
+
+Scheme_Syntax_Registered *scheme_find_linker(Scheme_Object *sym)
+{
+  int i;
+
+  for (i = 0; i < num_link_names; i++)
+    if (SAME_OBJ(linker_names[i].sym, sym))
+      return linker_names[i].f;
+
+  return NULL;
+}
+
+/*****************************************************************/
+
+static Scheme_Object *write_let_value(Scheme_Object *obj)
+{
+  Scheme_Let_Value *lv;
+ 
+  lv = (Scheme_Let_Value *)obj;
+
+  return cons(scheme_make_integer(lv->count),
+	      cons(scheme_make_integer(lv->position),
+		   cons(lv->autobox ? scheme_true : scheme_false,
+			cons(lv->value, lv->body))));
+}
+
+static Scheme_Object *read_let_value(Scheme_Object *obj)
+{
+  Scheme_Let_Value *lv;
+ 
+  lv = (Scheme_Let_Value *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Let_Value));
+  lv->type = scheme_let_value_type;
+
+  lv->count = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  lv->position = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  lv->autobox = SCHEME_TRUEP(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  lv->value = SCHEME_CAR(obj);
+  lv->body = SCHEME_CDR(obj);
+
+  scheme_end_stubborn_change((void *)lv);
+
+  return (Scheme_Object *)lv;
+}
+
+static Scheme_Object *write_let_void(Scheme_Object *obj)
+{
+  Scheme_Let_Void *lv;
+ 
+  lv = (Scheme_Let_Void *)obj;
+
+  return cons(scheme_make_integer(lv->count), 
+	      cons(lv->autobox ? scheme_true : scheme_false,
+		   lv->body));
+}
+
+static Scheme_Object *read_let_void(Scheme_Object *obj)
+{
+  Scheme_Let_Void *lv;
+ 
+  lv = (Scheme_Let_Void *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Let_Void));
+  lv->type = scheme_let_void_type;
+
+  lv->count = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+  lv->autobox = SCHEME_TRUEP(SCHEME_CAR(obj));
+  lv->body = SCHEME_CDR(obj);
+
+  scheme_end_stubborn_change((void *)lv);
+
+  return (Scheme_Object *)lv;
+}
+
+static Scheme_Object *write_let_one(Scheme_Object *obj)
+{
+  Scheme_Let_One *lo;
+ 
+  lo = (Scheme_Let_One *)obj;
+
+  return cons(lo->value, lo->body);
+}
+
+static Scheme_Object *read_let_one(Scheme_Object *obj)
+{
+  Scheme_Let_One *lo;
+ 
+  lo = (Scheme_Let_One *)scheme_malloc_stubborn_tagged(sizeof(Scheme_Let_One));
+  lo->type = scheme_let_one_type;
+
+  lo->value = SCHEME_CAR(obj);
+  lo->body = SCHEME_CDR(obj);
+  lo->eval_type = scheme_get_eval_type(lo->value);
+
+  scheme_end_stubborn_change((void *)lo);
+
+  return (Scheme_Object *)lo;
+}
+
+static Scheme_Object *write_letrec(Scheme_Object *obj)
+{
+  Scheme_Letrec *lr = (Scheme_Letrec *)obj;
+  Scheme_Object *l = scheme_null;
+  int i = lr->count;
+  
+  while (i--)
+    l = cons(lr->procs[i], l);
+
+  return cons(scheme_make_integer(lr->count), 
+	      cons(lr->body, l));
+}
+
+static Scheme_Object *read_letrec(Scheme_Object *obj)
+{
+  Scheme_Letrec *lr = MALLOC_ONE_TAGGED(Scheme_Letrec);
+  int i, c;
+
+  lr->type = scheme_letrec_type;
+
+  c = lr->count = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  obj = SCHEME_CDR(obj);
+
+  lr->body = SCHEME_CAR(obj);
+  obj = SCHEME_CDR(obj);
+
+  lr->procs = MALLOC_N(Scheme_Object*, c);
+  for (i = 0; i < c; i++) {
+    lr->procs[i] = SCHEME_CAR(obj);
+    obj = SCHEME_CDR(obj);
+  }
+
+  return (Scheme_Object *)lr;
+}
+
+static Scheme_Object *write_top(Scheme_Object *obj)
+{
+  Scheme_Compilation_Top *top = (Scheme_Compilation_Top *)obj;
+
+  return cons(scheme_make_integer(top->max_let_depth),
+	      top->code);
+}
+
+static Scheme_Object *read_top(Scheme_Object *obj)
+{
+  Scheme_Compilation_Top *top;
+
+  top = MALLOC_ONE_TAGGED(Scheme_Compilation_Top);
+  top->type = scheme_compilation_top_type;
+  top->max_let_depth = SCHEME_INT_VAL(SCHEME_CAR(obj));
+  top->code = SCHEME_CDR(obj);
+
+  return (Scheme_Object *)top;
+}
+
+static Scheme_Object *write_case_lambda(Scheme_Object *obj)
+{
+  Scheme_Case_Lambda *cl = (Scheme_Case_Lambda *)obj;
+  int i;
+  Scheme_Object **a, *l;
+
+  i = cl->count;
+  a = cl->array;
+
+  l = scheme_null;
+  for (; i--; )
+    l = cons(a[i], l);
+  
+  return cons((cl->name ? cl->name : scheme_null),
+	      l);
+}
+
+static Scheme_Object *read_case_lambda(Scheme_Object *obj)
+{
+  Scheme_Object *s;
+  int count, i;
+  Scheme_Case_Lambda *cl;
+
+  s = SCHEME_CDR(obj);
+  for (count = 0; SCHEME_PAIRP(s); s = SCHEME_CDR(s))
+    count++;
+
+  cl = (Scheme_Case_Lambda *)
+    scheme_malloc_stubborn_tagged(sizeof(Scheme_Case_Lambda)
+				  + (count - 1) * sizeof(Scheme_Object *));
+
+  cl->type = scheme_case_lambda_sequence_type;
+  cl->count = count;
+  cl->name = SCHEME_CAR(obj);
+  if (SCHEME_NULLP(cl->name))
+    cl->name = NULL;
+
+  s = SCHEME_CDR(obj);
+  for (i = 0; i < count; i++, s = SCHEME_CDR(s))
+    cl->array[i] = SCHEME_CAR(s);
+  
+  return (Scheme_Object *)cl;
+}
+
diff --git a/src/mzscheme/src/sysname b/src/mzscheme/src/sysname
new file mode 100755
index 0000000..4144acc
--- /dev/null
+++ b/src/mzscheme/src/sysname
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+systype=`uname -s`
+version=`uname -r`
+machine=`uname -p 2> /dev/null`
+if [ "$machine" = "" ] ; then
+  machine=`uname -m`
+fi
+
+echo "\"${machine}-${systype}-${version}\""
diff --git a/src/mzscheme/src/tsymbol.c b/src/mzscheme/src/tsymbol.c
new file mode 100644
index 0000000..65a84c8
--- /dev/null
+++ b/src/mzscheme/src/tsymbol.c
@@ -0,0 +1,108 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+
+#define HASH_TABLE_SIZE 10
+static Scheme_Hash_Table *type_symbol_table = NULL;
+
+/* globals */
+
+/* locals */
+static Scheme_Object *tsymbol_p(int argc, Scheme_Object *argv[]);
+static Scheme_Object *string_to_tsymbol(int argc, Scheme_Object *argv[]);
+
+void
+scheme_init_type_symbol_table ()
+{
+  if (scheme_starting_up) {
+    REGISTER_SO(type_symbol_table);
+    type_symbol_table = scheme_hash_table(HASH_TABLE_SIZE, SCHEME_hash_ptr, 
+					  0, 1);
+  }
+}
+
+void
+scheme_init_type_symbol (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+  }
+
+  scheme_add_global_constant("type-symbol?", 
+			     scheme_make_folding_prim(tsymbol_p, 
+						      "type-symbol?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("string->type-symbol", 
+			     scheme_make_folding_prim(string_to_tsymbol, 
+						      "string->type-symbol", 
+						      1, 1, 1), 
+			     env);
+}
+
+Scheme_Object *
+scheme_make_type_symbol(Scheme_Object *symbol)
+{
+  Scheme_Object *sym;
+
+  sym = scheme_alloc_small_object();
+
+  sym->type = scheme_type_symbol_type;
+
+  SCHEME_PTR_VAL(sym) = symbol;
+    
+  return (sym);
+}
+
+Scheme_Object *
+scheme_intern_type_symbol(Scheme_Object *symbol)
+{
+  Scheme_Object *sym;
+
+  sym = (Scheme_Object *)scheme_lookup_in_table(type_symbol_table, 
+						(char *)symbol);
+
+  if (!sym) {
+    sym = scheme_make_type_symbol(symbol);
+    scheme_add_to_table (type_symbol_table, (char *)symbol, sym, 0);
+  }
+
+  return (sym);
+}
+
+static Scheme_Object *
+tsymbol_p(int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_TSYMBOLP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+string_to_tsymbol(int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *s, *ts;
+
+  if (!SCHEME_STRINGP(argv[0]))
+    scheme_wrong_type("string->type-symbol", "string", 0, argc, argv);
+
+  s = scheme_intern_exact_symbol(SCHEME_STR_VAL(argv[0]), SCHEME_STRTAG_VAL(argv[0]));
+
+  ts = scheme_intern_type_symbol(s);
+
+  return ts;
+}
diff --git a/src/mzscheme/src/type.c b/src/mzscheme/src/type.c
new file mode 100644
index 0000000..5649b3b
--- /dev/null
+++ b/src/mzscheme/src/type.c
@@ -0,0 +1,257 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+#include <string.h>
+#include <memory.h>
+
+Scheme_Type_Reader *scheme_type_readers;
+Scheme_Type_Writer *scheme_type_writers;
+
+static char **type_names;
+static Scheme_Type maxtype, allocmax;
+
+#ifdef MEMORY_COUNTING_ON
+long scheme_type_table_count;
+#endif
+
+void
+scheme_init_type (Scheme_Env *env)
+{
+  long n;
+
+  if (!scheme_starting_up)
+    return;
+
+  REGISTER_SO(type_names);
+  REGISTER_SO(scheme_type_readers);
+  REGISTER_SO(scheme_type_writers);
+  
+  maxtype = _scheme_last_type_;
+  allocmax = maxtype + 10;
+
+  type_names = (char **)scheme_malloc(allocmax * sizeof(char *));
+  scheme_type_readers = 
+    (Scheme_Type_Reader *)scheme_malloc_atomic(n = allocmax
+					       * sizeof(Scheme_Type_Reader));
+  memset((char *)scheme_type_readers, 0, n);
+
+#ifdef MEMORY_COUNTING_ON
+  scheme_type_table_count += n;
+  scheme_misc_count += (allocmax * sizeof(char *));
+#endif
+
+  scheme_type_writers = 
+    (Scheme_Type_Writer *)scheme_malloc_atomic(n = allocmax
+					       * sizeof(Scheme_Type_Writer));
+  memset((char *)scheme_type_writers, 0, n);
+
+#ifdef MEMORY_COUNTING_ON
+  scheme_type_table_count += n;
+#endif
+
+#define set_name(t, n) type_names[t] = n
+
+  set_name(scheme_true_type, "<true>");
+  set_name(scheme_false_type, "<false>");
+  set_name(scheme_char_type, "<char>");
+  set_name(scheme_envunbox_type, "<env-auto-unbox>");
+  set_name(scheme_local_type, "<local-code>");
+  set_name(scheme_local_unbox_type, "<local-unbox-code>");
+  set_name(scheme_variable_type, "<variable-code>");
+  set_name(scheme_application_type, "<application-code>");
+  set_name(scheme_compiled_unclosed_procedure_type, "<procedure-semi-code>");
+  set_name(scheme_unclosed_procedure_type, "<procedure-code>");
+  set_name(scheme_syntax_type, "<syntax-code>");
+  set_name(scheme_compiled_syntax_type, "<syntax-semi-code>");
+  set_name(scheme_branch_type, "<branch-code>");
+  set_name(scheme_sequence_type, "<sequence-code>");
+  set_name(scheme_case_lambda_sequence_type, "<case-lambda-code>");
+  set_name(scheme_begin0_sequence_type, "<begin0-code>");
+
+  set_name(scheme_let_value_type, "<let-value-code>");
+  set_name(scheme_let_void_type, "<let-void-code>");
+  set_name(scheme_compiled_let_value_type, "<let-value-semi-code>");
+  set_name(scheme_compiled_let_void_type, "<let-void-semi-code>");
+  set_name(scheme_letrec_type, "<letrec-code>");
+  set_name(scheme_let_one_type, "<let-one-code>");
+  set_name(scheme_quote_compilation_type, "<quote-code>");
+
+  set_name(scheme_eval_waiting_type, "<eval-waiting>");
+  set_name(scheme_void_type, "<void>");
+  set_name(scheme_prim_type, "<primitive>");
+  set_name(scheme_closed_prim_type, "<primitive-closure>");
+  set_name(scheme_closure_type, "<closure-form>");
+  set_name(scheme_linked_closure_type, "<procedure>");
+  set_name(scheme_cont_type, "<continuation>");
+  set_name(scheme_tail_call_waiting_type, "<tail-call-waiting>");
+  set_name(scheme_null_type, "<empty-list>");
+  set_name(scheme_pair_type, "<pair>");
+  set_name(scheme_box_type, "<box>");
+  set_name(scheme_integer_type, "<fixnum-integer>");
+  set_name(scheme_double_type, "<inexact-number>");
+  set_name(scheme_float_type, "<inexact-number*>");
+  set_name(scheme_object_type, "<object>");
+  set_name(scheme_class_type, "<class>");
+  set_name(scheme_class_data_type, "<class-code>");
+  set_name(scheme_generic_type, "<unknown-external>");
+  set_name(scheme_undefined_type, "<undefined>");
+  set_name(scheme_eof_type, "<eof>");
+  set_name(scheme_input_port_type, "<input-port>");
+  set_name(scheme_output_port_type, "<output-port>");
+  set_name(scheme_process_type, "<thread>");
+  set_name(scheme_promise_type, "<promise>");
+  set_name(scheme_string_type, "<string>");
+  set_name(scheme_struct_info_type, "<struct-info>");
+  set_name(scheme_structure_type, "<struct>");
+  set_name(scheme_symbol_type, "<symbol>");
+  set_name(scheme_syntax_compiler_type, "<syntax>");
+  set_name(scheme_macro_type, "<macro>");
+  set_name(scheme_id_macro_type, "<id-macro>");
+  set_name(scheme_vector_type, "<vector>");
+  set_name(scheme_type_symbol_type, "<type-symbol>");
+  set_name(scheme_bignum_type, "<bignum-integer>");
+  set_name(scheme_escaping_cont_type, "<escape-continuation>");
+  set_name(scheme_sema_type, "<semaphore>");
+  set_name(scheme_hash_table_type, "<hash-table>");
+  set_name(scheme_case_closure_type, "<procedure>");
+  set_name(scheme_generic_data_type, "<generic-data>");
+  set_name(scheme_multiple_values_type, "<multiple-values>");
+  set_name(scheme_placeholder_type, "<placeholder>");
+  set_name(scheme_weak_box_type, "<weak-box>");
+  set_name(scheme_rational_type, "<fractional-number>");
+  set_name(scheme_complex_type, "<complex-number>");
+  set_name(scheme_struct_type_type, "<struct-type>");
+  set_name(scheme_exp_time_type, "<expansion-time-value>");
+  set_name(scheme_listener_type, "<tcp-listener>");
+  set_name(scheme_namespace_type, "<namespace>");
+  set_name(scheme_config_type, "<parameterization>");
+  set_name(scheme_defaulting_config_type, "<parameterization-defaulting-marker>");
+  set_name(scheme_will_executor_type, "<will-executor>");
+  set_name(scheme_interface_type, "<interface>");
+
+  set_name(scheme_unit_type, "<unit>");
+  set_name(scheme_compiled_unit_type, "<unit-code>");
+  set_name(scheme_unit_body_data_type, "<unit-body-code>");
+  set_name(scheme_unit_compound_data_type, "<compound-unit-code>");
+  set_name(scheme_invoke_unit_data_type, "<invoke-unit-code>");
+
+  set_name(scheme_interface_data_type, "<interface-code>");
+
+  set_name(scheme_compilation_top_type, "<compiled-code>");
+  set_name(scheme_svector_type, "<short-vector>");
+
+  set_name(scheme_manager_type, "<custodian>");
+
+  set_name(scheme_reserved_4_type, "<reserved4>");
+  set_name(scheme_reserved_5_type, "<reserved5>");
+
+  set_name(_scheme_values_types_, "<resurrected>");
+  set_name(_scheme_compiled_values_types_, "<internal>");
+}
+
+Scheme_Type scheme_make_type(const char *name)
+{
+  if (maxtype == allocmax) {
+    /* Expand arrays */
+    void *naya;
+    long n;
+    
+    allocmax += 20;
+
+    naya = scheme_malloc(allocmax * sizeof(char *));
+    memcpy(naya, type_names, maxtype * sizeof(char *));
+    type_names = (char **)naya;
+
+    naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Type_Reader));
+    memset((char *)naya, 0, n);
+    memcpy(naya, scheme_type_readers, maxtype * sizeof(Scheme_Type_Reader));
+    scheme_type_readers = (Scheme_Type_Reader *)naya;
+
+    naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Type_Writer));
+    memset((char *)naya, 0, n);
+    memcpy(naya, scheme_type_writers, maxtype * sizeof(Scheme_Type_Writer));
+    scheme_type_writers = (Scheme_Type_Writer *)naya;
+
+#ifdef MEMORY_COUNTING_ON
+  scheme_type_table_count += 20 * (sizeof(Scheme_Type_Reader)
+				   + sizeof(Scheme_Type_Writer));
+  scheme_misc_count += (20 * sizeof(char *));
+#endif
+  }
+  
+  type_names[maxtype] = scheme_strdup(name);
+
+  return maxtype++;
+}
+
+char *scheme_get_type_name(Scheme_Type t)
+{
+  if (t < 0 || t >= maxtype)
+    return "<bad-value>";
+  return type_names[t];
+}
+
+int scheme_find_type(Scheme_Object *ts)
+{
+  int i;
+  char *str;
+
+  str = SCHEME_TSYM_VAL(ts);
+
+  for (i = maxtype; i--; ) {
+    if (type_names[i]) {
+      char *ts = type_names[i] + 1, *s = str;
+      while (*s && *ts && (*s == *ts)) {
+	s++;
+	ts++;
+      }
+      if (!*s && *ts == '>')
+	return i;
+    }
+  }
+
+  scheme_signal_error("bad type name: %s", str);
+  return -1;
+}
+
+void scheme_install_type_reader(Scheme_Type t, Scheme_Type_Reader f)
+{
+  if (t < 0 || t >= maxtype)
+    return;
+
+  scheme_type_readers[t] = f;
+}
+
+void scheme_install_type_writer(Scheme_Type t, Scheme_Type_Writer f)
+{
+  if (t < 0 || t >= maxtype)
+    return;
+
+  scheme_type_writers[t] = f;
+}
+
+int scheme_num_types(void)
+{
+  return maxtype;
+}
diff --git a/src/mzscheme/src/unit.c b/src/mzscheme/src/unit.c
new file mode 100644
index 0000000..359cf0e
--- /dev/null
+++ b/src/mzscheme/src/unit.c
@@ -0,0 +1,3176 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "schpriv.h"
+#include "schrunst.h"
+#include "schminc.h"
+
+#ifndef NO_UNIT_SYSTEM
+
+#define KIND "unit"
+
+#define MAKE_UNIT "unit"
+#define MAKE_COMPOUND_UNIT "compound-unit"
+#define INVOKE_UNIT "invoke-unit"
+#define INVOKE_OPEN_UNIT "invoke-open-unit"
+
+static Scheme_Object *CloseUnit(Scheme_Object *data);
+static Scheme_Object *CloseCompoundUnit(Scheme_Object *data);
+static Scheme_Object *InvokeUnit(Scheme_Object *data);
+
+static Scheme_Object *do_unit(Scheme_Object **boxes, Scheme_Object **anchors, 
+			      Scheme_Unit *m, void *dr);
+static Scheme_Object *do_compound_unit(Scheme_Object **boxes, Scheme_Object **anchors, 
+				       Scheme_Unit *m, void *dr);
+
+static Scheme_Object *import_symbol, *export_symbol, *with_symbol;
+static Scheme_Object *define_values_symbol;
+
+#define cons scheme_make_pair
+
+#define scheme_bind scheme_add_good_binding
+#define scheme_bind_anchored scheme_add_binding_with_anchor
+
+static Scheme_Object *unit_symbol;
+static Scheme_Object *compound_unit_symbol;
+static Scheme_Object *invoke_unit_symbol;
+static Scheme_Object *invoke_open_unit_symbol;
+
+static Scheme_Object *unitsig_macros;
+
+/**********************************************************************/
+/* Debugging tools                                                    */
+/**********************************************************************/
+
+typedef struct {
+  Scheme_Object *const_prefix;
+  Scheme_Object *prefix;
+  Scheme_Env *env;
+  Scheme_Object *path;
+} Scheme_Debug_Request;
+
+static Scheme_Object *build_unit_pathname(Scheme_Object *tag,
+					     Scheme_Object *name)
+{
+#define BUILD_BUF_SIZE 100
+  char buffer[BUILD_BUF_SIZE];
+  char *s;
+  int tl, nl;
+  
+  if (!tag)
+    return name;
+
+  tl = SCHEME_SYM_LEN(tag);
+  nl = SCHEME_SYM_LEN(name);
+
+  if (tl + nl < BUILD_BUF_SIZE - 2)
+    s = buffer;
+  else
+    s = (char *)scheme_malloc_atomic(tl + nl + 2);
+
+  memcpy(s, SCHEME_SYM_VAL(tag), tl);
+  memcpy(s + tl + 1, SCHEME_SYM_VAL(name), nl);
+  s[tl] = ':';
+  s[tl + nl + 1] = 0;
+
+  return scheme_intern_exact_symbol(s, tl + nl + 1);
+}
+
+/**********************************************************************/
+/* Parsing tools                                                      */
+/**********************************************************************/
+
+typedef struct UnitId {
+  Scheme_Object *tag;
+  Scheme_Object *int_id;
+  Scheme_Object *ext_id;
+  struct UnitId *next;
+} UnitId;
+
+typedef struct UnitIds {
+  UnitId *first, *last;
+} UnitIds;
+
+enum {
+  mm_body_def,
+  mm_body_seq
+};
+
+typedef struct BodyVar {
+  Scheme_Object *id;
+  short pos;
+  short exported;
+} BodyVar;
+
+typedef struct BodyExpr {
+  short type;
+  union {
+    struct {
+      short count;
+      Scheme_Object *expr;
+      BodyVar *vars;
+    } def;
+    struct {
+      Scheme_Object *expr;
+    } seq;
+  } u;
+  struct BodyExpr *next;
+} BodyExpr;
+
+typedef struct BodyExprs {
+  BodyExpr *first, *last;
+} BodyExprs;
+
+static void init_ids(UnitIds *ids)
+{
+  ids->first = ids->last = NULL;
+}
+
+static void extend_ids(UnitIds *ids, Scheme_Object *tag, 
+		       Scheme_Object *int_id, Scheme_Object *ext_id)
+{
+  UnitId *naya;
+
+  naya = (UnitId *)scheme_malloc(sizeof(UnitId));
+
+  if (!ids->last)
+    ids->first = naya;
+  else
+    ids->last->next = naya;
+  ids->last = naya;
+
+  naya->tag = tag;
+  naya->int_id = int_id;
+  naya->ext_id = ext_id;
+  naya->next = NULL;
+}
+
+static int count_ids(UnitId *id)
+{
+  int c;
+
+  for (c = 0; id; id = id->next)
+    c++;
+
+  return c;
+}
+
+/**********************************************************************/
+/* Basic syntax checks and parsing                                    */
+/**********************************************************************/
+
+static void check_ext_ids_unique(DupCheckRecord *r, UnitIds *m, 
+				 char *where, Scheme_Object *form)
+{
+  UnitId *id;
+  
+  r->scheck_size = 0;
+  r = scheme_begin_dup_symbol_check(r);
+  for (id = m->first; id; id = id->next)
+    scheme_dup_symbol_check(r, where, id->ext_id, "external", form, 0);
+}
+
+static void check_int_ids_unique(UnitIds *m, 
+				 char *where, Scheme_Object *form,
+				 DupCheckRecord *r,
+				 int continuing,
+				 int inverted,
+				 char *kind)
+{
+  UnitId *id;
+
+  if (!kind)
+    kind = "internal";
+ 
+  if (!r || !continuing)
+    r = scheme_begin_dup_symbol_check(r);
+  for (id = m->first; id; id = id->next)
+    scheme_dup_symbol_check(r, where, id->int_id, kind, form, inverted);
+}
+
+static void check_tags_unique(UnitIds *m, 
+			      char *where, Scheme_Object *form,
+			      DupCheckRecord *r,
+			      int null_id_required,
+			      int inverted,
+			      int cont_check)
+{
+  UnitId *id;
+ 
+  if (!r || !cont_check)
+    r = scheme_begin_dup_symbol_check(r);
+
+  for (id = m->first; id; id = id->next) {
+    if (null_id_required) {
+      if (null_id_required < 0) {
+	if (!id->int_id)
+	  continue;
+      } else {
+	if (id->int_id)
+	  continue;
+      }
+    }
+    if (id->tag)
+      scheme_dup_symbol_check(r, where, id->tag, "tag", form, inverted);
+  }
+}
+
+static void check_id_list(char *where,
+			  Scheme_Object *l, Scheme_Object *form, 
+			  Scheme_Comp_Env *env,
+			  UnitIds *m, Scheme_Object *tag,
+			  int rename_ok)
+{
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *id = SCHEME_CAR(l);
+
+    if (!SCHEME_SYMBOLP(id)) {
+      if (!rename_ok)
+	scheme_wrong_syntax(where, 
+			    id, form,
+			    "bad syntax (id must be an identifier)");
+
+      if (!SCHEME_PAIRP(id)
+	  || !SCHEME_PAIRP(SCHEME_CDR(id))
+	  || !SCHEME_NULLP(SCHEME_CDDR(id))
+	  || !SCHEME_SYMBOLP(SCHEME_CADR(id)))
+	scheme_wrong_syntax(where, 
+			    id, form,
+			    "bad syntax (external id must be an identifier)");
+      scheme_check_identifier(where, SCHEME_CAR(id), NULL, env, form);
+      scheme_check_identifier(where, SCHEME_CADR(id), NULL, env, form);
+      extend_ids(m, tag, SCHEME_CAR(id), SCHEME_CADR(id));
+    } else {
+      scheme_check_identifier(where, id, NULL, env, form);
+      extend_ids(m, tag, id, id);
+    }
+
+    l = SCHEME_CDR(l);
+  }
+
+  if (!SCHEME_NULLP(l))
+    scheme_wrong_syntax(where, l, form, NULL);
+}
+
+static void check_tagged(char *where,
+			 Scheme_Object *l, Scheme_Object *form, 
+			 Scheme_Comp_Env *env,
+			 int check_id, 
+			 UnitIds *m,
+			 int rename_ok,
+			 int name_only_ok,
+			 Scheme_Object *self_check)
+{
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *tag_set = SCHEME_CAR(l);
+    Scheme_Object *tag;
+
+    if (SCHEME_SYMBOLP(tag_set) && name_only_ok) {
+      extend_ids(m, 
+		 (name_only_ok < 0) ? NULL : tag_set, 
+		 (name_only_ok < 0) ? tag_set : NULL, 
+		 NULL);
+    } else {
+      if (!SCHEME_PAIRP(tag_set)
+	  || !SCHEME_SYMBOLP(SCHEME_CAR(tag_set)))
+	scheme_wrong_syntax(where, tag_set, form,
+			    "bad syntax (tag must be an identifier)");
+      
+      tag = SCHEME_CAR(tag_set);
+      
+      if (SAME_OBJ(tag, self_check)) {
+	scheme_wrong_syntax(MAKE_COMPOUND_UNIT, 
+			    tag, form,
+			    "bad syntax (self-import)");
+      }
+
+      if (check_id)
+	check_id_list(where, SCHEME_CDR(tag_set), form, env, 
+		      m, SCHEME_CAR(tag_set), rename_ok);
+      else {
+	if (!SCHEME_PAIRP(SCHEME_CDR(tag_set))
+	    || !SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(tag_set)))
+	    || !SCHEME_PAIRP(SCHEME_CADR(tag_set)))
+	  scheme_wrong_syntax(where, 
+			      tag_set, form, 
+			      "bad syntax (tag must be followed by a single "
+			      KIND " application)");
+	else {
+	  Scheme_Object *app = SCHEME_CADR(tag_set), *expr, *links;
+	  UnitIds ids;
+	  
+	  init_ids(&ids);
+	  
+	  expr = SCHEME_CAR(app);
+	  links = SCHEME_CDR(app);
+	  
+	  check_tagged(where, links, form, env, 1, &ids, 0, -1, tag);
+
+	  extend_ids(m, tag, expr, (Scheme_Object *)ids.first);
+	}
+      }
+    }
+
+    l = SCHEME_CDR(l);
+  }
+
+  if (!SCHEME_NULLP(l))
+    scheme_wrong_syntax(where, l, form, NULL);
+}
+
+static Scheme_Object *check_params(char *where, Scheme_Object *clause, 
+				   Scheme_Object *form,
+				   Scheme_Comp_Env *env,
+				   DupCheckRecord *r,
+				   int keyword_check, int cont_check)
+{
+  Scheme_Object *l;
+  
+  if (keyword_check) {
+    if (!SCHEME_PAIRP(clause)
+	|| !SAME_OBJ(SCHEME_CAR(clause), import_symbol))
+      scheme_wrong_syntax(where, 
+			  clause, form,
+			  "expected `import' keyword");
+    clause = SCHEME_CDR(clause);
+  }
+   
+  l = clause;
+  
+  if (!r || !cont_check)
+    r = scheme_begin_dup_symbol_check(r);
+  
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *s = SCHEME_CAR(l);
+    if (!SCHEME_SYMBOLP(s))
+      scheme_wrong_syntax(MAKE_UNIT, s, form, 
+			  "bad syntax (parameter not an identifier)");
+    else if (env)
+      scheme_check_identifier(where, s, NULL, env, form);
+    
+    scheme_dup_symbol_check(r, where, s, "parameter", form, 0);
+    
+    l = SCHEME_CDR(l);
+  }
+  
+  if (!SCHEME_NULLP(l)) {
+    scheme_wrong_syntax(MAKE_UNIT, NULL, form, 
+			"bad syntax (" IMPROPER_LIST_FORM " for parameters)");
+  }
+
+  return clause;
+}
+
+static Scheme_Object *unit_varlist(BodyExpr *e, 
+				   Scheme_Object *base, 
+				   int exported)
+{
+  Scheme_Object *first = scheme_null, *last = NULL;
+
+  if (!SCHEME_NULLP(base)) {
+    first = base;
+    last = base;
+    while (!SCHEME_NULLP(SCHEME_CDR(last)))
+      last = SCHEME_CDR(last);
+  }
+
+  for (; e; e = e->next) {
+    switch (e->type) {
+    case mm_body_def:
+      {
+	BodyVar *vs, *v;
+	int i, c;
+
+	c = e->u.def.count;
+	vs = e->u.def.vars;
+	for (i = 0; i < c; i++) {
+	  v = vs + i;
+	  if (v->exported == exported) {
+	    Scheme_Object *name;
+	    
+	    name = v->id;
+	    name = cons(name, scheme_null);
+	    if (last)
+	      SCHEME_CDR(last) = name;
+	    else
+	      first = name;
+	    last = name;
+	  }
+	}
+      }
+      break;
+    }
+  }
+
+  return first;
+}
+
+static int check_unit(Scheme_Object *form, Scheme_Comp_Env *env,
+		      UnitIds *exports,
+		      int *num_params,
+		      BodyExprs *body,
+		      Scheme_Compile_Info *rec,
+		      int depth)
+{
+  Scheme_Comp_Env *indirect_env;
+  DupCheckRecord drec;
+  Scheme_Object *l = SCHEME_CDR(form), *export, *params, *bodystack;
+  Scheme_Object *indirect_first = scheme_null, *indirect_last = NULL;
+  UnitId *id;
+  BodyExpr *e;
+  int c, count, import_count, expr_count = 0;
+  int dpos, ipos;
+  int orig_glob_prim;
+  Scheme_Compile_Info *recs;
+  
+  drec.scheck_size = 0;
+
+  init_ids(exports);
+
+  body->first = NULL;
+  body->last = NULL;
+
+  c = scheme_proper_list_length(l);
+  if (c < 0)
+    scheme_wrong_syntax(MAKE_UNIT, NULL, form, "bad syntax (" IMPROPER_LIST_FORM ")");
+  else if (c < 2)
+    scheme_wrong_syntax(MAKE_UNIT, 
+			NULL, form, 
+			"bad syntax (requires at least 3 parts; had %d parts)",
+			c);
+  
+  params = SCHEME_CAR(l);
+  l = SCHEME_CDR(l);
+  export = SCHEME_CAR(l);
+  l = SCHEME_CDR(l);
+
+  params = check_params(MAKE_UNIT, params, form, env, &drec, 1, 0);
+
+  import_count = scheme_list_length(params);
+  *num_params = import_count;
+
+  if (!SCHEME_PAIRP(export)
+      || NOT_SAME_OBJ(SCHEME_CAR(export), export_symbol))
+    scheme_wrong_syntax(MAKE_UNIT, 
+			export, form,
+			"expected `export' keyword");
+  check_id_list(MAKE_UNIT, SCHEME_CDR(export), form, env, exports, NULL, 1);
+
+  check_ext_ids_unique(&drec, exports, MAKE_UNIT, form);
+
+  /* Check for aliases: */
+  check_int_ids_unique(exports, MAKE_UNIT, form, &drec, 0, 0, "exported internal");
+  check_params(MAKE_UNIT, params, form, NULL, &drec, 0, 1);
+
+  bodystack = scheme_null; /* Used to flatten begins */
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *expr = SCHEME_CAR(l);
+    
+    e = MALLOC_ONE(BodyExpr);
+    expr_count++;
+    
+    if (!body->last)
+      body->first = e;
+    else
+      body->last->next = e;
+    body->last = e;
+    e->next = NULL;
+
+    if (SCHEME_PAIRP(expr)) {
+      Scheme_Object *gval;
+
+      /* Check for macro expansion, which could mask the real define-values */
+      expr = scheme_check_immediate_macro(expr, env, rec, depth, &gval);
+
+      if (SAME_OBJ(gval, scheme_begin_syntax) && SCHEME_PAIRP(SCHEME_CDR(expr))) {
+	Scheme_Object *cl;
+
+	/* Flatten it out. */
+	bodystack = cons(SCHEME_CDR(l), bodystack);
+	l = expr;
+
+	/* Check for good begin syntax: */
+	for (cl = l; SCHEME_PAIRP(cl); cl = SCHEME_CDR(cl));
+	if (!SCHEME_NULLP(cl)) {
+	  scheme_wrong_syntax(MAKE_UNIT, 
+			      expr, form,
+			      "bad syntax (bad immediate `begin' form)");
+	  return 0;
+	}
+
+	/* A poor hack: set expr to NULL now, filter it out in a second pass. */
+	e->type = mm_body_seq;
+	e->u.seq.expr = NULL;
+      } else if (SAME_OBJ(gval, scheme_define_values_syntax)) {
+	Scheme_Object *l = SCHEME_CDR(expr);
+	int ok;
+	
+	if (!SCHEME_PAIRP(l)
+	    || !SCHEME_PAIRP(SCHEME_CDR(l))
+	    || !SCHEME_NULLP(SCHEME_CDR(SCHEME_CDR(l))))
+	  ok = 0;
+	else {
+	  Scheme_Object *names = SCHEME_CAR(l), *ns;
+	  Scheme_Object *value = SCHEME_CADR(l);
+	  int count = 0, i;
+
+	  ns = names;
+	  while (SCHEME_PAIRP(ns)) {
+	    count++;
+	    ns = SCHEME_CDR(ns);
+	  }
+	  
+	  if (SCHEME_NULLP(ns)) {
+	    BodyVar *vs;
+	    
+	    e->type = mm_body_def;
+	    e->u.def.expr = value;
+	    e->u.def.count = count;
+
+	    vs = e->u.def.vars = MALLOC_N(BodyVar, count);
+
+	    for (i = 0; i < count; i++, names = SCHEME_CDR(names)) {
+	      vs[i].id = SCHEME_CAR(names);
+	      scheme_check_identifier(MAKE_UNIT, vs[i].id, NULL, env, form);
+	      vs[i].exported = 0;
+	    }
+	    ok = 1;
+	  } else
+	    ok = 0;
+	}
+	
+	if (!ok)
+	  scheme_wrong_syntax(MAKE_UNIT, 
+			      expr, form,
+			      "bad syntax (bad `define' form)");
+      } else {
+	e->type = mm_body_seq;
+	e->u.seq.expr = expr;
+      }
+    } else {
+      e->type = mm_body_seq;
+      e->u.seq.expr = expr;
+    }
+
+    l = SCHEME_CDR(l);
+
+    if (SCHEME_NULLP(l) && SCHEME_PAIRP(bodystack)) {
+      l = SCHEME_CAR(bodystack);
+      bodystack = SCHEME_CDR(bodystack);
+    }
+  }
+
+  /* Get rid of NULL exprs (introduced by begin expansion: */
+  {
+    BodyExpr *prev = NULL, *next;
+    e = body->first;
+    while (e) {
+      next = e->next;
+      if ((e->type == mm_body_seq) && !e->u.seq.expr) {
+	if (!prev)
+	  body->first = e->next;
+	else
+	  prev->next = e->next;
+	if (!next)
+	  body->last = prev;
+	--expr_count;
+      } else
+	prev = e;
+      e = next;
+    }
+  }
+
+  /* Make sure all exported ids are defined and set `exported' flag,
+     set position info, and build list of exported names: */
+  l = params;
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *v = cons(SCHEME_CAR(l), scheme_null);
+    if (indirect_last)
+      SCHEME_CDR(indirect_last) = v;
+    else
+      indirect_first = v;
+    indirect_last = v;
+    l = SCHEME_CDR(l);
+  }
+  ipos = import_count;
+  for (id = exports->first; id; id = id->next) {
+    for (e = body->first; e; e = e->next) {
+      Scheme_Object *name;
+
+      if (e->type == mm_body_def) {
+	int i, c = e->u.def.count;
+	BodyVar *vs = e->u.def.vars;
+	
+	for (i = 0 ; i < c; i++) {
+	  name = vs[i].id;
+	  if (SAME_OBJ(id->int_id, name)) {
+	    Scheme_Object *v = cons(name, scheme_null);
+	    if (indirect_last)
+	      SCHEME_CDR(indirect_last) = v;
+	    else
+	      indirect_first = v;
+	    indirect_last = v;
+	    
+	    vs[i].exported = 1;
+	    vs[i].pos = ipos++;
+	    break;
+	  }
+	}
+
+	if (i < c)
+	  break;
+      }
+    }
+    
+    if (!e)
+      scheme_wrong_syntax(MAKE_UNIT, 
+			  NULL, form,
+			  "cannot export undefined id \"%s\"",
+			  scheme_symbol_name(id->int_id));
+  }
+
+  /* Check that imported ids are not redefined: */
+  check_params(MAKE_UNIT, params, form, NULL, &drec, 0, 0);
+  for (e = body->first; e; e = e->next) {
+    if (e->type == mm_body_def) {
+      int i, c = e->u.def.count;
+      BodyVar *vs = e->u.def.vars;
+
+      for (i = 0; i < c; i++)
+	scheme_dup_symbol_check(&drec, MAKE_UNIT, vs[i].id, "internal", form, 0);
+    }
+  }
+  
+  /* Extend environment: */
+  indirect_env = env = scheme_add_compilation_frame(indirect_first, env, 
+						    SCHEME_AUTO_UNBOX | SCHEME_ANCHORED_FRAME);
+
+  for (c = 0; c < import_count; c++)
+    scheme_unsettable_variable(env, c);
+
+  l = unit_varlist(body->first, scheme_null, 0);
+  count = scheme_list_length(l);
+  env = scheme_add_compilation_frame(l, env, 
+				     SCHEME_AUTO_UNBOX | SCHEME_ANCHORED_FRAME);
+
+  if (rec) {
+    orig_glob_prim = rec->globals_must_be_primitive;
+    rec->globals_must_be_primitive = 1;
+  } else {
+    orig_glob_prim = 0;
+  }
+
+  if (rec) {
+    recs = MALLOC_N(Scheme_Compile_Info, expr_count);
+    scheme_init_compile_recs(rec, recs, expr_count);
+    expr_count = 0;
+  } else
+    recs = NULL;
+
+  /* Expand/compile expressions and set defin positions */
+  dpos = 0;
+  for (e = body->first; e; e = e->next) {
+    Scheme_Object *expr;
+
+    if (e->type == mm_body_def) {
+      int i, c = e->u.def.count;
+      BodyVar *vs = e->u.def.vars;
+
+      for (i = 0; i < c; i++)
+	if (!vs[i].exported)
+	  vs[i].pos = dpos++;
+
+      expr = e->u.def.expr;
+    } else
+      expr = e->u.seq.expr;
+      
+    if (!rec)
+      expr = scheme_expand_expr(expr, env, depth);
+    else {
+      if ((e->type == mm_body_def)
+	  && e->u.def.count == 1) {
+	Scheme_Object *s = e->u.def.vars[0].id;
+
+	/* Look for export renaming */
+	if (e->u.def.vars[0].exported) {
+	  UnitId *id;
+	  for (id = exports->first; id; id = id->next) {
+	    if (SAME_OBJ(id->int_id, s)) {
+	      s = id->ext_id;
+	      break;
+	    }
+	  }
+	}
+	
+	recs[expr_count].value_name = s;
+      }
+      expr = scheme_compile_expr(expr, env, recs + expr_count);
+      expr_count++;
+    }
+
+    if (e->type == mm_body_def)
+      e->u.def.expr = expr;
+    else
+      e->u.seq.expr = expr;
+  }
+
+  if (rec) {
+    scheme_merge_compile_recs(rec, recs, expr_count);
+    rec->max_let_depth += (indirect_env->basic.num_bindings + env->basic.num_bindings);
+
+    rec->globals_must_be_primitive = orig_glob_prim;
+  }
+
+  return count;
+}
+
+static int check_compound_unit(Scheme_Object *form, Scheme_Comp_Env *env,
+				 UnitIds *withs, 
+				 UnitIds *exports,
+				 int *num_params,
+				 Scheme_Compile_Info *rec,
+				 int depth)
+{
+  DupCheckRecord drec;
+  Scheme_Object *l = SCHEME_CDR(form), *with, *export, *params;
+  int c, num_withs = 0;
+  UnitId *id;
+  Scheme_Compile_Info *recs;
+
+  drec.scheck_size = 0;
+
+  init_ids(withs);
+  init_ids(exports);
+
+  c = scheme_proper_list_length(l);
+  if (c < 0)
+    scheme_wrong_syntax(MAKE_COMPOUND_UNIT, NULL, form,
+			"bad syntax (" IMPROPER_LIST_FORM ")");
+  else if (c != 3)
+    scheme_wrong_syntax(MAKE_COMPOUND_UNIT, NULL, form,
+			"bad syntax (requires 3 parts)");
+  
+  params = SCHEME_CAR(l);
+  l = SCHEME_CDR(l);
+  with = SCHEME_CAR(l);
+  l = SCHEME_CDR(l);
+  export = SCHEME_CAR(l);
+
+  params = check_params(MAKE_COMPOUND_UNIT, params, form, env, &drec, 1, 0);
+  *num_params = scheme_list_length(params);
+
+  if (!SCHEME_PAIRP(with)
+      || NOT_SAME_OBJ(SCHEME_CAR(with), with_symbol))
+    scheme_wrong_syntax(MAKE_COMPOUND_UNIT, 
+			with, form, 
+			"expected `link' keyword");
+  check_tagged(MAKE_COMPOUND_UNIT, SCHEME_CDR(with), form, env, 0, withs, 0, 0, NULL);
+
+  if (!SCHEME_PAIRP(export)
+      || NOT_SAME_OBJ(SCHEME_CAR(export), export_symbol))
+    scheme_wrong_syntax(MAKE_COMPOUND_UNIT, 
+			export, form,
+			"expected `export' keyword");
+  check_tagged(MAKE_COMPOUND_UNIT, SCHEME_CDR(export), form, env, 1, exports, 1, 0, NULL);
+
+  check_tags_unique(withs, MAKE_COMPOUND_UNIT, form, &drec, 0, 0, 0);
+  /* Check that export tags were defined by withs: */
+  check_tags_unique(exports, MAKE_COMPOUND_UNIT, form, &drec, 0, 1, 1);
+
+#if 0
+  /* Check that standalone tags used just once (and not also un-standalone): */
+  check_tags_unique(exports, MAKE_COMPOUND_UNIT, form, &drec, 1, 0, 0);
+  check_tags_unique(exports, MAKE_COMPOUND_UNIT, form, &drec, -1, 0, 1);
+#endif
+
+  /* Check uses of tags in links: */
+  check_tags_unique(withs, MAKE_COMPOUND_UNIT, form, &drec, 0, 0, 0);
+  for (id = withs->first; id; id = id->next) {
+    UnitIds tmp;
+    tmp.first = (UnitId *)id->ext_id;
+
+    check_tags_unique(&tmp, MAKE_COMPOUND_UNIT, form, &drec, 0, 1, 1);
+  }
+
+  /* Lookup use of imported in withs */
+  for (id = withs->first; id; id = id->next) {
+    UnitId *sub = (UnitId *)id->ext_id;
+
+    num_withs++;
+
+    for (; sub; sub = sub->next) {
+      if (!sub->tag) {
+	Scheme_Object *l = params;
+	int c;
+	
+	for (c = 0; SCHEME_PAIRP(l); l = SCHEME_CDR(l), c++)
+	  if (SAME_OBJ(SCHEME_CAR(l), sub->int_id)) {
+	    sub->int_id = (Scheme_Object *)(long)c;
+	    break;
+	  }
+
+	if (SCHEME_NULLP(l))
+	  scheme_wrong_syntax(MAKE_COMPOUND_UNIT, 
+			      sub->int_id, form,
+			      "bad syntax (not an imported identifier)");
+	
+      } else if (SAME_OBJ(sub->tag, id->tag))
+	scheme_wrong_syntax(MAKE_COMPOUND_UNIT, 
+			    sub->tag, form,
+			    "bad syntax (self-import)");
+    }
+  }
+
+  check_ext_ids_unique(&drec, exports, MAKE_COMPOUND_UNIT, form);
+
+  if (rec) {
+    recs = MALLOC_N(Scheme_Compile_Info, num_withs);
+    scheme_init_compile_recs(rec, recs, num_withs);
+  } else
+    recs = NULL;
+
+  /* Compile/expand expressions of `link' clause: */
+  for (c = 0, id = withs->first; id; id = id->next, c++) {
+    if (!rec)
+      id->int_id = scheme_expand_expr(id->int_id, env, depth);
+    else
+      id->int_id = scheme_compile_expr(id->int_id, env, rec);
+  }
+
+  if (rec)
+    scheme_merge_compile_recs(rec, recs, num_withs);
+
+  return c;
+}
+
+static int check_invoke_unit(char *where, Scheme_Object *form, Scheme_Comp_Env *env,
+				int with_path, 
+				Scheme_Object **path, Scheme_Object **prefix)
+{
+  Scheme_Object *l;
+  int count = 0;
+
+  if (scheme_proper_list_length(form) < 2)
+    scheme_wrong_syntax(where, NULL, form,
+			"bad syntax (missing parts or " IMPROPER_LIST_FORM ")");
+  
+  l = SCHEME_CDR(SCHEME_CDR(form));
+
+  if (with_path && !SCHEME_NULLP(l)) {
+    Scheme_Object *first = SCHEME_CAR(l);
+
+    l = SCHEME_CDR(l);
+
+    if (SCHEME_SYMBOLP(first) || SCHEME_FALSEP(first)) {
+      if (prefix)
+	*prefix = first;
+      if (path)
+	*path = scheme_null;
+    } else {
+      if (path)
+	*path = first;
+      if (prefix)
+	*prefix = NULL;
+
+      while (SCHEME_PAIRP(first)) {
+	if (!SCHEME_SYMBOLP(SCHEME_CAR(first)))
+	  scheme_wrong_syntax(where, SCHEME_CAR(first), form,
+			      "bad syntax (not an identifier in path)");
+	first = SCHEME_CDR(first);
+      }
+      
+      if (!SCHEME_NULLP(first))
+	scheme_wrong_syntax(where, first, form,
+			    "bad syntax (bad path)");
+    }
+  }
+
+  while (SCHEME_PAIRP(l)) {
+    Scheme_Object *first = SCHEME_CAR(l);
+
+    l = SCHEME_CDR(l);
+    
+    if (!SCHEME_SYMBOLP(first))
+      scheme_wrong_syntax(where, first, form,
+			  "bad syntax (not an identifier)");
+      
+    count++;
+  }
+  
+  return count;
+}
+
+/**********************************************************************/
+/* Compilers and Expanders                                            */
+/**********************************************************************/
+
+/******* unit ********/
+
+typedef struct BodyData {
+  Scheme_Type type; /* scheme_unit_body_data_type  */
+  short max_let_depth;
+  BodyExpr *body;
+  int num_locals;
+  short closure_size;
+  short *closure_map;
+  Scheme_Object *defname;
+} BodyData;
+
+static Scheme_Unit *InitCompiledUnitRec(UnitId *exports, int num_imports,
+					int debuggable)
+{
+  int i;
+  UnitId *id;
+  Scheme_Unit *m;
+
+  m = (Scheme_Unit *)scheme_malloc_tagged(sizeof(Scheme_Unit));
+
+  m->type = scheme_compiled_unit_type;
+
+  m->num_imports = num_imports;
+  for (i = 0, id = exports; id; id = id->next)
+    i++;
+  m->num_exports = i;
+
+  if (m->num_exports)
+    m->exports = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *)
+						 * m->num_exports);
+  else
+    m->exports = NULL;
+
+  if (m->num_exports && debuggable)
+    m->export_debug_names = (Scheme_Object **)scheme_malloc(sizeof(Scheme_Object *)
+							    * m->num_exports);
+  else
+    m->export_debug_names = NULL;
+
+  for (i = 0, id = exports; id; id = id->next, i++) {
+    m->exports[i] = id->ext_id;
+    if (debuggable)
+      m->export_debug_names[i] = id->int_id;
+  }
+  
+  return m;
+}
+
+static Scheme_Object *link_unit(Scheme_Object *o, Link_Info *info)
+{
+  Scheme_Unit *m = (Scheme_Unit *)o;
+  BodyData *label = (BodyData *)m->data;
+  BodyExpr *e;
+  int c, i, j;
+
+  i = label->closure_size;
+  if (i) {
+    info = scheme_link_info_extend(info, 0, 0, i);
+
+    while (i--) {
+      int pos = label->closure_map[i], flags;
+      label->closure_map[i] = scheme_link_info_lookup(info, pos, &flags);
+      scheme_link_info_add_mapping(info, pos, i, flags);
+    }
+  }
+
+  for (j = 0; j < 2; j++) {
+    if (!j)
+      c = m->num_imports + m->num_exports;
+    else
+      c = label->num_locals;
+
+    info = scheme_link_info_extend(info, 2 * c, c, c);
+    scheme_link_info_set_anchor_offset(info, c);
+    for (i = 0; i < c; i++)
+      scheme_link_info_add_mapping(info, i, i, 
+				   SCHEME_INFO_BOXED | SCHEME_INFO_ANCHORED);
+  }
+
+  for (e = label->body; e; e = e->next) {
+    switch (e->type) {
+    case mm_body_def:
+      e->u.def.expr = scheme_link_expr(e->u.def.expr, info);
+      break;
+    case mm_body_seq:
+      e->u.seq.expr = scheme_link_expr(e->u.seq.expr, info);
+      break;
+    }
+  }
+
+  return scheme_make_syntax_link(CloseUnit, (Scheme_Object *)m);
+}
+
+static Scheme_Object *make_unit_syntax(Scheme_Object *form,
+				       Scheme_Comp_Env *env,
+				       Scheme_Compile_Info *rec)
+{
+  UnitIds exports;
+  BodyExprs body;
+  BodyData *label;
+  Scheme_Unit *m;
+  Scheme_Comp_Env *cenv;
+  int count, num_params;
+  Scheme_Compile_Info lam;
+  Scheme_Object *defname;
+
+  defname = rec->value_name;
+  scheme_compile_rec_done_local(rec);
+
+  cenv = scheme_new_compilation_frame(0, SCHEME_LAMBDA_FRAME, env);
+
+  scheme_init_lambda_rec(rec, &lam);
+
+  count = check_unit(form, cenv, &exports, &num_params, &body, &lam, 0);
+
+  scheme_merge_lambda_rec(rec, &lam);
+
+  scheme_default_compile_rec(rec);
+
+  label = MALLOC_ONE_TAGGED(BodyData);
+
+  label->type = scheme_unit_body_data_type;
+  label->body = body.first;
+  label->num_locals = count;
+  label->max_let_depth = lam.max_let_depth;
+  label->defname = defname;
+
+  scheme_env_make_closure_map(cenv, &label->closure_size, &label->closure_map);
+
+  m = InitCompiledUnitRec(exports.first, num_params, 1);
+
+  m->data = (Scheme_Object *)label;
+
+  return scheme_make_syntax_compile(link_unit, (Scheme_Object *)m);
+}
+
+static Scheme_Object *make_unit_expand(Scheme_Object *form,
+					 Scheme_Comp_Env *env,
+					 int depth)
+{
+  int num_params;
+  UnitIds exports;
+  BodyExprs body;
+  BodyExpr *e;
+  Scheme_Object *first = scheme_null, *last = NULL;
+
+  (void)check_unit(form,  env, &exports, &num_params, &body, NULL, depth);
+
+  /* Rebuild the expression: */
+
+  for (e = body.first; e; e = e->next) {
+    Scheme_Object *c = NULL;
+
+    switch (e->type) {
+    case mm_body_def:
+      {
+	int i, count = e->u.def.count;
+	BodyVar *vs = e->u.def.vars;
+	Scheme_Object *ids = scheme_null, *last = NULL;
+	
+	for (i = 0; i < count; i++) {
+	  Scheme_Object *pr = cons(vs[i].id, scheme_null);
+	  if (last)
+	    SCHEME_CDR(last) = pr;
+	  else
+	    ids = pr;
+	  last = pr;
+	}
+
+	c = cons(define_values_symbol,
+		 cons(ids,
+		      cons(e->u.def.expr, scheme_null)));
+	break;
+      }
+    case mm_body_seq:
+      c = e->u.seq.expr;
+      break;
+    }
+
+    if (c) {
+      c = cons(c, scheme_null);
+      if (last)
+	SCHEME_CDR(last) = c;
+      else
+	first = c;
+      last = c;
+    }
+  }
+
+  return cons(unit_symbol,
+	      cons(SCHEME_CADR(form),
+		   cons(SCHEME_CADR(SCHEME_CDR(form)),
+			first)));
+}
+
+/******* compound-unit ********/
+
+typedef struct {
+  int submod_index;
+  Scheme_Object *ext_id;
+} ExportSource;
+
+typedef struct {
+  short index; /* -1 => compound param */
+  union {
+    short pos;
+    Scheme_Object *ext_id;
+  } u;
+} ParamMap;
+
+typedef struct CompoundData {
+  Scheme_Type type; /* scheme_unit_compound_data_type  */
+  short num_exports;
+  ExportSource *exports;
+  Scheme_Object **subunit_exprs;
+  Scheme_Object **tags;
+  int num_subunits;
+  short *param_counts;
+  ParamMap **param_maps;
+  Scheme_Object *defname;
+} CompoundData;
+
+static Scheme_Object *
+make_compound_unit_record(int count, /* subunits */
+			  /* tag; int_id is exp; ext_id is id list (tag checked, int_id): */
+			  UnitId *links,
+			  /* tag, int_id  */
+			  UnitId *exports,
+			  /* symbols */
+			  Scheme_Object *imports,
+			  int num_imports,
+			  Scheme_Object *form,
+			  Scheme_Object *defname,
+			  int promise_ok)
+{
+  CompoundData *data;
+  Scheme_Unit *m;
+  Scheme_Object **tags;
+  ParamMap **param_maps;
+  UnitId *id;
+  int i, j;
+  ExportSource *export_srcs;
+
+  data = (CompoundData *)scheme_malloc_tagged(sizeof(CompoundData));
+
+  data->type = scheme_unit_compound_data_type;
+  data->num_subunits = count;
+  data->subunit_exprs = 
+    (Scheme_Object **)scheme_malloc(count * sizeof(Scheme_Object *));
+  data->param_maps = param_maps = 
+    (ParamMap **)scheme_malloc(count * sizeof(ParamMap *));
+  data->param_counts = 
+    (short *)scheme_malloc(count * sizeof(short));
+  data->defname = defname;
+  
+  tags = (Scheme_Object **)scheme_malloc(count * sizeof(Scheme_Object *));
+  data->tags = tags;
+
+  for (i = 0, id = links; id; id = id->next, i++) {
+    data->subunit_exprs[i] = id->int_id;
+    tags[i] = id->tag;
+
+    j = count_ids((UnitId *)id->ext_id);
+    data->param_counts[i] = j;
+    param_maps[i] = (ParamMap *)scheme_malloc(j * sizeof(ParamMap));
+  }
+
+  /* Fill in param map: */
+  for (i = 0, id = links; id; id = id->next, i++) {
+    UnitId *sub = (UnitId *)id->ext_id;
+    for (j = 0; sub; sub = sub->next, j++) {
+      if (sub->tag) {
+	/* Map to another unit's export */
+	int k;
+	if (SCHEME_INTP(sub->tag))
+	  k = SCHEME_INT_VAL(sub->tag);
+	else
+	  for (k = 0; k < count; k++)
+	    if (SAME_OBJ(sub->tag, tags[k]))
+	      break;
+
+	param_maps[i][j].index = k;
+	param_maps[i][j].u.ext_id = sub->int_id;
+      } else {
+	/* Map to imports */
+	long pos;
+	param_maps[i][j].index = -1;
+	if (imports) {
+	  Scheme_Object *l, *n;
+	  n = sub->int_id;
+	  if (SCHEME_INTP(n)) 
+	    pos = SCHEME_INT_VAL(n);
+	  else {
+	    pos = 0;
+	    for (l = imports; !SAME_OBJ(n, SCHEME_CAR(l)); l = SCHEME_CDR(l))
+	      pos++;
+	  }
+	} else
+	  pos = (long)sub->int_id;
+	param_maps[i][j].u.pos = pos;
+      }
+    }
+  }  
+
+  /* Fill in export map: */
+  i = count_ids(exports);
+  data->num_exports = i;
+  data->exports = (ExportSource *)scheme_malloc(i * sizeof(ExportSource));
+  export_srcs = data->exports;
+  for (i = 0, id = exports; id; id = id->next, i++) {
+    Scheme_Object *tag = id->tag;
+    if (SCHEME_INTP(tag)) 
+      j = SCHEME_INT_VAL(tag);
+    else {
+      for (j = data->num_subunits; j--; )
+	if (SAME_OBJ(tag, tags[j]))
+	  break;
+    }
+    export_srcs[i].submod_index = j;
+    export_srcs[i].ext_id = id->int_id;
+  }
+
+  /* Check that no sub-unit variable is exported twice: */
+  if (!promise_ok) {
+    for (i = data->num_exports; i--; ) {
+      Scheme_Object *id = export_srcs[i].ext_id;
+      int which = export_srcs[i].submod_index, j;
+      for (j = i; j--; )
+	if ((export_srcs[j].submod_index == which)
+	    && SAME_OBJ(export_srcs[j].ext_id, id)) {
+	  scheme_wrong_syntax(MAKE_COMPOUND_UNIT, NULL, form,
+			      "\"%s\" of sub-unit tagged \"%s\" is exported twice",
+			      scheme_symbol_name(id),
+			      scheme_symbol_name(tags[which]));
+	  
+	}
+    }
+  }
+
+  m = InitCompiledUnitRec(exports, num_imports, 1);
+
+  m->data = (Scheme_Object *)data;
+
+  return (Scheme_Object *)m;
+}
+
+static Scheme_Object *link_compound_unit(Scheme_Object *o, Link_Info *info)
+{
+  Scheme_Unit *m = (Scheme_Unit *)o;
+  CompoundData *data = (CompoundData *)m->data;
+  int i;
+
+  for (i = 0; i < data->num_subunits; i++)
+    data->subunit_exprs[i] = scheme_link_expr(data->subunit_exprs[i], info);
+  
+  return scheme_make_syntax_link(CloseCompoundUnit, (Scheme_Object *)m);
+}
+
+static Scheme_Object *make_compound_unit_syntax(Scheme_Object *form,
+						Scheme_Comp_Env *env,
+						Scheme_Compile_Info *rec)
+{
+  UnitIds withs, exports;
+  int num_imports, count;
+  Scheme_Object *m, *defname;
+
+  defname = rec->value_name;
+  scheme_compile_rec_done_local(rec);
+
+  count = check_compound_unit(form, env, &withs, &exports, &num_imports,
+			      rec, 0);
+  
+  m = make_compound_unit_record(count, withs.first, exports.first,
+				NULL, num_imports, form, defname, 0);
+
+  return scheme_make_syntax_compile(link_compound_unit, m);
+}
+
+Scheme_Object *scheme_assemble_compound_unit(Scheme_Object *imports,
+					     Scheme_Object *links,
+					     Scheme_Object *exports)
+{
+  UnitId *last, *link_ids, *export_ids;
+  Scheme_Object *m;
+  int count, num_imports;
+
+  /* printf("ready assemble compound: %ld\n", scheme_get_process_milliseconds()); */
+
+  count = scheme_list_length(links);
+  if (SCHEME_INTP(imports))
+    num_imports = SCHEME_INT_VAL(imports);
+  else
+    num_imports = scheme_list_length(imports);
+
+  last = NULL;
+  link_ids = NULL;
+  for (m = links; SCHEME_PAIRP(m); m = SCHEME_CDR(m)) {
+    UnitId *id, *ilast, *first;
+    Scheme_Object *l = SCHEME_CAR(m);
+
+    id = MALLOC_ONE(UnitId);
+
+    id->tag = SCHEME_CAR(l);
+    id->int_id = NULL;
+    first = NULL;
+    ilast = NULL;
+    for (l = SCHEME_CDR(l); SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
+      UnitId *id = MALLOC_ONE(UnitId);
+      Scheme_Object *i = SCHEME_CAR(l);
+
+      if (ilast)
+	ilast->next = id;
+      else
+	first = id;
+      ilast = id;
+
+      if (!SCHEME_PAIRP(i)) {
+	id->tag = NULL;
+	id->int_id = i;
+      } else {
+	id->tag = SCHEME_CAR(i);
+	id->int_id = SCHEME_CDR(i);
+      }
+    }
+    id->ext_id = (Scheme_Object *)first;
+
+    if (last)
+      last->next = id;
+    else
+      link_ids = id;
+    last = id;
+  }
+
+  last = NULL;
+  export_ids = NULL;
+  for (m = exports; SCHEME_PAIRP(m); m = SCHEME_CDR(m)) {
+    UnitId *id = MALLOC_ONE(UnitId);
+    Scheme_Object *l = SCHEME_CAR(m);
+
+    id->tag = SCHEME_CAR(l);
+    l = SCHEME_CDR(l);
+    if (SCHEME_SYMBOLP(l)) {
+      id->int_id = l;
+      id->ext_id = l;
+    } else {
+      id->int_id = SCHEME_CAR(l);
+      id->ext_id = SCHEME_CDR(l);
+    }
+    
+    if (last)
+      last->next = id;
+    else
+      export_ids = id;
+    last = id;
+  }
+
+  /* printf("start assemble compound: %ld\n", scheme_get_process_milliseconds()); */
+
+  m = make_compound_unit_record(count, link_ids, export_ids,
+				imports, num_imports, NULL, NULL, 
+				1);
+
+  /* printf("end assemble compound: %ld\n", scheme_get_process_milliseconds()); */
+
+  return m;
+}
+
+static Scheme_Object *make_compound_unit_expand(Scheme_Object *form,
+						   Scheme_Comp_Env *env,
+						   int depth)
+{
+  UnitIds withs, exports;
+  UnitId *id;
+  int count, num_params;
+  Scheme_Object *first = scheme_null, *last = NULL, *l;
+
+  count = check_compound_unit(form, env, &withs, &exports, &num_params,
+				NULL, depth);
+
+  l = SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(SCHEME_CDR(form))));
+  for (id = withs.first; id; id = id->next) {
+    Scheme_Object *c = cons(cons(id->tag,
+				 cons(cons(id->int_id, 
+					   SCHEME_CDR(SCHEME_CAR(SCHEME_CDR(SCHEME_CAR(l))))),
+				      scheme_null)),
+			    scheme_null);
+    if (last)
+      SCHEME_CDR(last) = c;
+    else
+      first = c;
+    last = c;
+
+    l = SCHEME_CDR(l);
+  }
+
+  return cons(compound_unit_symbol,
+	      cons(SCHEME_CADR(form),
+		   cons(cons(with_symbol, first),
+			SCHEME_CDR(SCHEME_CDR(SCHEME_CDR(form))))));
+}
+
+/******* invoke-unit ********/
+
+typedef struct {
+  Scheme_Type type; /* scheme_invoke_unit_data_type */
+  short num_exports, num_local_exports;
+  short *anchor_positions; /* one for each local_type export */
+  Scheme_Object **exports;
+  Scheme_Object **anchors;
+  Scheme_Object *expr;
+  Scheme_Object *path;
+  Scheme_Object *const_prefix;
+} InvokeUnitData;
+
+static Scheme_Object *link_invoke_unit(Scheme_Object *o, Link_Info *info)
+{
+  InvokeUnitData *data;
+  int i, num_local = 0, j;
+
+  data = (InvokeUnitData *)o;
+
+  for (i = 0; i < data->num_exports; i++)
+    if (SAME_TYPE(SCHEME_TYPE(data->exports[i]), scheme_local_type))
+      num_local++;
+
+  data->num_local_exports = num_local;
+  if (num_local)
+    data->anchor_positions = MALLOC_N(short, num_local);
+
+  for (i = 0, j = 0; i < data->num_exports; i++) {
+    if (SAME_TYPE(SCHEME_TYPE(data->exports[i]), scheme_local_type)) {
+      int flags = scheme_link_info_flags(info, SCHEME_LOCAL_POS(data->exports[i]));
+      int p;
+
+      if (flags & SCHEME_INFO_ANCHORED)
+	p = scheme_link_info_lookup_anchor(info, SCHEME_LOCAL_POS(data->exports[i]));
+      else
+	p = -1;
+
+      data->anchor_positions[j++] = (short)p;
+    }
+
+    data->exports[i] = scheme_link_expr(data->exports[i], info);
+  }
+
+  data->expr = scheme_link_expr(data->expr, info);
+
+  return scheme_make_syntax_link(InvokeUnit, (Scheme_Object *)data);
+}
+
+static Scheme_Object *do_invoke_unit_syntax(char *where,
+					    Scheme_Object *form,
+					    Scheme_Comp_Env *env,
+					    Scheme_Compile_Info *rec,
+					    int with_path)
+{
+  Scheme_Object *path, *prefix, *l;
+  int c, i;
+  InvokeUnitData *data;
+
+  path = with_path ? scheme_null : NULL;
+  prefix = scheme_false;
+
+  c = check_invoke_unit(where, form, env, with_path, &path, &prefix);
+
+  data = MALLOC_ONE_TAGGED(InvokeUnitData);
+  data->type = scheme_invoke_unit_data_type;
+  data->num_exports = c;
+  data->path = path;
+  data->const_prefix = prefix;
+
+  scheme_compile_rec_done_local(rec);
+
+  data->expr = scheme_compile_expr(SCHEME_CADR(form), env, rec);
+
+  data->anchors = NULL;
+
+  data->num_local_exports = 0;
+  data->anchor_positions = NULL;
+
+  data->exports = (Scheme_Object **)scheme_malloc(c * sizeof(Scheme_Object *));
+  l = SCHEME_CDR(SCHEME_CDR(form));
+  if (with_path && !SCHEME_NULLP(l))
+    l = SCHEME_CDR(l);
+
+  for (i = 0; i < c; i++, l = SCHEME_CDR(l)) {
+    Scheme_Object *s, *v;
+
+    s = SCHEME_CAR(l);
+    v = scheme_static_distance(s, env, 
+			       SCHEME_MUST_INDRECT
+			       + SCHEME_GLOB_ALWAYS_REFERENCE
+			       + SCHEME_LINKING_REF
+			       + (rec->dont_mark_local_use 
+				  ? SCHEME_DONT_MARK_USE 
+				  : 0));
+    
+    data->exports[i] = v;
+  }
+
+  return scheme_make_syntax_compile(link_invoke_unit, (Scheme_Object *)data);
+}
+
+static Scheme_Object *do_invoke_unit_expand(char *where,
+					    Scheme_Object *formname,
+					    Scheme_Object *form,
+					    Scheme_Comp_Env *env,
+					    int depth,
+					    int with_path)
+{
+  (void)check_invoke_unit(where, form, env, with_path, NULL, NULL);
+  
+  return cons(formname,
+	      cons(scheme_expand_expr(SCHEME_CADR(form), env, depth),
+		   SCHEME_CDR(SCHEME_CDR(form))));
+}
+
+static Scheme_Object *invoke_unit_syntax(Scheme_Object *form,
+					 Scheme_Comp_Env *env,
+					 Scheme_Compile_Info *rec)
+{
+  return do_invoke_unit_syntax(INVOKE_UNIT, form, env, rec, 0);
+}
+
+static Scheme_Object *invoke_unit_expand(Scheme_Object *form,
+					 Scheme_Comp_Env *env,
+					 int depth)
+{
+  return do_invoke_unit_expand(INVOKE_UNIT, invoke_unit_symbol, form, env, depth, 0);
+}
+
+static Scheme_Object *invoke_open_unit_syntax(Scheme_Object *form,
+					      Scheme_Comp_Env *env,
+					      Scheme_Compile_Info *rec)
+{
+  return do_invoke_unit_syntax(INVOKE_OPEN_UNIT, form, env, rec, 1);
+}
+
+static Scheme_Object *invoke_open_unit_expand(Scheme_Object *form,
+					      Scheme_Comp_Env *env,
+					      int depth)
+{
+  return do_invoke_unit_expand(INVOKE_OPEN_UNIT, invoke_open_unit_symbol, 
+			       form, env, depth, 1);
+}
+
+/**********************************************************************/
+/* Syntax execution                                                   */
+/**********************************************************************/
+
+typedef struct {
+  Scheme_Object *data;
+  Scheme_Env *env;
+  Scheme_Object **closure_saved;
+  Scheme_Object *defname;
+} UnitDataClosure;
+
+static Scheme_Object *CloseUnit(Scheme_Object *data)
+{
+  Scheme_Unit *orig, *m;
+
+  orig = (Scheme_Unit *)data;
+
+  m = MALLOC_ONE_TAGGED(Scheme_Unit);
+
+  m->type = scheme_unit_type;
+  m->num_imports = orig->num_imports;
+  m->num_exports = orig->num_exports;
+  m->exports = orig->exports;
+  m->export_debug_names = orig->export_debug_names;
+  
+  if (orig->data->type == scheme_unit_body_data_type) {
+    UnitDataClosure *cl;
+    BodyData *data;
+    int i;
+    short *map;
+    Scheme_Object **stack, **saved;
+
+    data = (BodyData *)orig->data;
+
+    cl = MALLOC_ONE(UnitDataClosure);
+    
+    cl->env = scheme_get_env(scheme_config);
+    cl->data = (Scheme_Object *)data;
+    cl->defname = data->defname;
+
+    i = data->closure_size;
+    cl->closure_saved = saved = MALLOC_N(Scheme_Object *, i);
+    map = data->closure_map;
+    stack = scheme_current_process->runstack;
+    while (i--)
+      saved[i] = stack[map[i]];
+    
+    m->data = (Scheme_Object *)cl;
+
+    m->init_func = do_unit;
+  } else {
+    m->data = orig->data;
+    m->init_func = do_compound_unit;
+  }
+
+  return (Scheme_Object *)m;
+}
+
+static void wrong_import(char *where,
+			 Scheme_Object *unit,
+			 Scheme_Object *sunit,
+			 Scheme_Object *tag,
+			 Scheme_Object *stag,
+			 Scheme_Object *id)
+{
+  scheme_raise_exn(MZEXN_UNIT_IMPORT,
+		   unit, sunit, tag, stag, id,
+		   "%s: import at tag \"%s\" failed from tag \"%s\", "
+		   "name \"%s\"",
+		   where,
+		   scheme_symbol_name(tag),
+		   scheme_symbol_name(stag),
+		   scheme_symbol_name(id));
+}
+
+typedef struct {
+  short source; /* -1 => create; -2 => input */
+  short pos;
+} BoxMap;
+
+typedef struct {
+  int num_submods;
+  Scheme_Unit **subunits;
+  BoxMap **boxMapsList;
+  Scheme_Object **tags; /* for debugging */
+  Scheme_Object *defname;
+} CompoundLinkedData;
+
+static int find_exported(int unit_index,
+			 Scheme_Object *id,
+			 
+			 int num_mods,
+			 Scheme_Unit **subunits,
+			 Scheme_Object **tags,
+			 BoxMap **boxesList,
+			 
+			 int insert, short *i_pos)
+{
+  int k, n;
+  Scheme_Object **exports;
+  Scheme_Unit *sm;
+
+  /* Look for exported id */
+
+  k = unit_index;
+   
+  sm = subunits[k];
+  exports = sm->exports;
+
+  for (n = sm->num_exports; n--; ) {
+    if (SAME_OBJ(exports[n], id)) {
+      /* Found exported id in tagged unit: */
+      if (insert) {
+	BoxMap *map = &boxesList[k][n + sm->num_imports];
+	map->source = -2;
+	map->pos = *i_pos;
+	*i_pos = n;
+      } else
+	*i_pos = n + sm->num_imports;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+static Scheme_Object *
+do_close_compound_unit(Scheme_Object *data_in, Scheme_Object **subs_in)
+{
+  Scheme_Unit **subunits, *sm, *m;
+  BoxMap **boxesList, *boxes;
+  CompoundData *data;
+  CompoundLinkedData *linked;
+  int num_mods, i, j, k;
+
+  /* printf("begin link compound: %ld\n", scheme_get_process_milliseconds()); */
+
+  m = (Scheme_Unit *)CloseUnit(data_in);
+
+  data = (CompoundData *)m->data;
+
+  /* copy export_debug_names so we can set! it */
+  if (m->export_debug_names) {
+    Scheme_Object **orig = m->export_debug_names;
+    Scheme_Object **naya;
+    int i;
+
+    i = m->num_exports;
+    naya = (Scheme_Object **)scheme_malloc(i * sizeof(Scheme_Object *));
+    while (i--)
+      naya[i] = orig[i];
+
+    m->export_debug_names = naya;
+  }
+
+  num_mods = data->num_subunits;
+
+  subunits = (Scheme_Unit **)scheme_malloc(num_mods * sizeof(Scheme_Unit *));
+  boxesList = (BoxMap **)scheme_malloc(num_mods * sizeof(BoxMap *));
+
+  /* Evaluate units and create space for sub-exported box lists */
+  for (i = 0; i < num_mods; i++) {
+    Scheme_Object *v;
+    
+    if (subs_in)
+      v = subs_in[i];
+    else
+      v = _scheme_eval_compiled_expr(data->subunit_exprs[i]);
+
+    if (!SCHEME_UNITP(v)) {
+      scheme_raise_exn(MZEXN_UNIT_NON_UNIT,
+		       v,
+		       MAKE_COMPOUND_UNIT ": not a " KIND " for \"%s\" "
+		       "in compound unit; provided %s",
+		       scheme_symbol_name(data->tags[i]),
+		       scheme_make_provided_string(v, 1, NULL));
+      return NULL;
+    }
+    
+    subunits[i] = sm = (Scheme_Unit *)v;
+
+    if (sm->num_imports != data->param_counts[i]) {
+      scheme_raise_exn(MZEXN_UNIT_ARITY,
+		       v,
+		       MAKE_COMPOUND_UNIT ": " KIND " tagged \"%s\" "
+		       "expects %d imports, given %d",
+		       scheme_symbol_name(data->tags[i]),
+		       sm->num_imports,
+		       data->param_counts[i]);
+    }
+
+    boxes = (BoxMap *)scheme_malloc_atomic((sm->num_imports + sm->num_exports)
+					   * sizeof(BoxMap));
+    boxesList[i] = boxes;
+
+    k = sm->num_imports;
+    for (j = sm->num_exports; j--;)
+      boxes[j + k].source = -1;
+  }
+
+  /* Resolve sub-exported with locally exported */
+  for (i = m->num_exports; i--; ) {
+    short pos = m->num_imports + i;
+    if (!find_exported(data->exports[i].submod_index, data->exports[i].ext_id,
+		       num_mods, subunits, data->tags, boxesList,
+		       1, &pos)) {
+      scheme_raise_exn(MZEXN_UNIT_EXPORT,
+		       subunits[data->exports[i].submod_index],
+		       data->tags[data->exports[i].submod_index],
+		       data->exports[i].ext_id,
+		       MAKE_COMPOUND_UNIT ": compound " KIND " exported variable "
+		       "not found for tag \"%s\", name \"%s\"",
+		       scheme_symbol_name(data->tags[data->exports[i].submod_index]),
+		       scheme_symbol_name(data->exports[i].ext_id));
+      return NULL;
+    }
+
+    /* set export debug name to <tag>.<prim-exported-name> */
+    if (m->export_debug_names) {
+      Scheme_Unit *submod = subunits[data->exports[i].submod_index];
+      
+      if (submod->export_debug_names)
+	m->export_debug_names[i] = 
+	  cons(data->tags[data->exports[i].submod_index],
+	       submod->export_debug_names[pos]);
+    }
+  }
+
+  /* Link imports: */
+  for (i = 0; i < num_mods; i++) {
+    ParamMap *map;
+
+    map = data->param_maps[i];
+    for (j = subunits[i]->num_imports; j--; ) {
+      if (map[j].index < 0) {
+	boxesList[i][j].source = -2;
+	boxesList[i][j].pos = map[j].u.pos;
+      } else {
+	Scheme_Object *orig_id = map[j].u.ext_id;
+	short pos, source = map[j].index;
+
+	if (!find_exported(source, orig_id,
+			   num_mods, subunits, data->tags, boxesList,
+			   0, &pos)) {
+	  wrong_import(MAKE_COMPOUND_UNIT,
+		       (Scheme_Object *)subunits[i], 
+		       (Scheme_Object *)subunits[source], 
+		       data->tags[i], 
+		       data->tags[source], 
+		       orig_id);
+	  return NULL;
+	}
+      
+	boxesList[i][j].source = source;
+	boxesList[i][j].pos = pos;
+      }
+    }
+  }
+
+  /* All mappings are set up */
+  linked = (CompoundLinkedData *)scheme_malloc(sizeof(CompoundLinkedData));
+  linked->num_submods = num_mods;
+  linked->subunits = subunits;
+  linked->boxMapsList = boxesList;
+  linked->tags = data->tags;
+  linked->defname = data->defname;
+
+  m->data = (Scheme_Object *)linked;
+
+  /* printf("done link compound: %ld\n", scheme_get_process_milliseconds()); */
+
+  return (Scheme_Object *)m;
+}
+
+static Scheme_Object *CloseCompoundUnit(Scheme_Object *data_in)
+{
+  return do_close_compound_unit(data_in, NULL);
+}
+
+Scheme_Object *
+scheme_make_compound_unit(Scheme_Object *data_in, Scheme_Object **subs_in)
+{
+  return do_close_compound_unit(data_in, subs_in);
+}
+
+static Scheme_Object *debug_bind(Scheme_Debug_Request *request, 
+				 Scheme_Object *name, 
+				 Scheme_Object *export_name,
+				 Scheme_Object *v,
+				 Scheme_Object **anchor)
+{
+  Scheme_Object *full_name, *path;
+  Scheme_Bucket *b;
+
+  *anchor = NULL;
+
+  if (!request || (request->const_prefix && !export_name))
+    return scheme_make_envunbox(v);
+
+  if (request->const_prefix) {
+    if (SCHEME_FALSEP(request->const_prefix))
+      full_name = export_name;
+    else
+      full_name = build_unit_pathname(request->const_prefix, export_name);
+  } else {
+    if (!name)
+      return scheme_make_envunbox(v);
+
+    path = request->path;
+    while (SCHEME_PAIRP(path)) {
+      if (!SCHEME_PAIRP(name)
+	  || NOT_SAME_OBJ(SCHEME_CAR(name), SCHEME_CAR(path)))
+	return scheme_make_envunbox(v);
+      
+      path = SCHEME_CDR(path);
+      name = SCHEME_CDR(name);
+    }
+    
+    full_name = NULL;
+    while (SCHEME_PAIRP(name)) {
+      full_name = build_unit_pathname(full_name, SCHEME_CAR(name));
+      name = SCHEME_CDR(name);
+    }
+    
+    full_name = build_unit_pathname(full_name, name);
+    
+    full_name = build_unit_pathname(request->prefix, full_name);
+  }
+
+  b = scheme_global_bucket(full_name, request->env);
+
+  if (b->val) {
+    if (((Scheme_Bucket_With_Const_Flag *)b)->flags & GLOB_IS_CONST) {
+      scheme_raise_exn(MZEXN_MISC_CONSTANT,
+		       full_name,
+		       INVOKE_OPEN_UNIT ": cannot redefine global constant: %s",
+		       scheme_symbol_name(full_name));
+    }
+  }
+
+  b->val = v;
+  ((Scheme_Bucket_With_Const_Flag *)b)->flags |= GLOB_IS_PERMANENT;
+
+  *anchor = (Scheme_Object *)b;
+
+  return (Scheme_Object *)&b->val;
+}
+
+
+static Scheme_Object *InvokeUnit(Scheme_Object *data_in)
+{
+  Scheme_Unit *unit;
+  InvokeUnitData *data;
+  Scheme_Env *link_env;
+  Scheme_Debug_Request *request, debug_request;
+  Scheme_Object *v, **boxes, **anchors;
+  int c, i, j;
+  Scheme_Process *p = scheme_current_process;
+
+  data = (InvokeUnitData *)data_in;
+
+  link_env = scheme_get_env(scheme_config);
+
+  v = _scheme_eval_compiled_expr(data->expr);
+
+  if (!SCHEME_UNITP(v))
+    scheme_raise_exn(MZEXN_UNIT_NON_UNIT,
+		     v,
+		     INVOKE_UNIT ": not a " KIND "; provided %s",
+		     scheme_make_provided_string(v, 1, NULL));
+  
+  unit = (Scheme_Unit *)v;
+
+  if (unit->num_imports != data->num_exports) {
+    scheme_raise_exn(MZEXN_UNIT_ARITY, v,
+		     "%s : " KIND " "
+		     "expects %d imports, given %d",
+		     data->path ? INVOKE_OPEN_UNIT : INVOKE_UNIT,
+		     unit->num_imports,
+		     data->num_exports);
+  }
+
+  if (data->path)  {
+    debug_request.const_prefix = data->const_prefix;
+    debug_request.prefix = NULL;
+    debug_request.env = link_env;
+    debug_request.path = data->path;
+    request = &debug_request;
+  } else
+    request = NULL;
+
+  c = unit->num_exports + unit->num_imports;
+
+  boxes = MALLOC_N(Scheme_Object *, c);
+  anchors = MALLOC_N(Scheme_Object *, c);
+
+  if (data->anchors) {
+    for (i = data->num_exports; i--; ) {
+      boxes[i] = data->exports[i];
+      anchors[i] = data->anchors[i];
+    }
+  } else {
+    int ap = 0;
+
+    for (i = data->num_exports; i--; ) {
+      Scheme_Object *e = data->exports[i];
+      if (SAME_TYPE(SCHEME_TYPE(e), scheme_variable_type)) {
+	if (!((Scheme_Bucket *)e)->val) {
+	  Scheme_Object *name = (Scheme_Object *)((Scheme_Bucket *)e)->key;
+	  scheme_raise_exn(MZEXN_UNIT_INVOKE_VARIABLE,
+			   name,
+			   INVOKE_UNIT ": cannot link to undefined identifier: %s",
+			   scheme_symbol_name(name));
+	  return NULL;
+	}
+	((Scheme_Bucket_With_Const_Flag *)e)->flags |= GLOB_IS_PERMANENT;
+	boxes[i] = (Scheme_Object *)&((Scheme_Bucket *)e)->val;
+	anchors[i] = e;
+      } else {
+	boxes[i] = p->runstack[SCHEME_LOCAL_POS(e)];
+	if (data->anchor_positions[ap] > 0)
+	  anchors[i] = p->runstack[data->anchor_positions[ap]];
+	ap++;
+      }
+    }
+  }
+
+  for (i = 0, j = data->num_exports; j < c; j++, i++) {
+    if (request)
+      boxes[j] = debug_bind(request,
+			    (unit->export_debug_names
+			     ? unit->export_debug_names[i]
+			     : NULL),
+			    unit->exports[i],
+			    scheme_undefined,
+			    &anchors[j]);
+    else {
+      boxes[j] = scheme_make_envunbox(scheme_undefined);
+      anchors[j] = NULL;
+    }
+  }
+
+  /* Invoke the unit: */
+  return unit->init_func(boxes, anchors, unit, request);
+}
+
+Scheme_Object *scheme_invoke_unit(Scheme_Object *unit, int num_ins, 
+				  Scheme_Object **ins, Scheme_Object **anchors,
+				  int open, const char *prefix,
+				  int tail, int multi)
+{
+  InvokeUnitData data;
+  Scheme_Object *v;
+
+  data.expr = unit;
+
+  data.num_exports = num_ins;
+  data.exports = ins;
+  data.anchors = anchors;
+
+  data.path = (open ? scheme_null : NULL);
+  data.const_prefix = (prefix 
+		       ? scheme_intern_symbol(prefix) 
+		       : scheme_false);
+  
+  v = InvokeUnit((Scheme_Object *)&data);
+
+  if (tail)
+    return v;
+  else {
+    v = _scheme_force_value(v);
+
+    if (!multi && SAME_OBJ(v, SCHEME_MULTIPLE_VALUES))
+      scheme_wrong_return_arity(NULL, 1, scheme_multiple_count, scheme_multiple_array, NULL);
+
+    return v;
+  }
+}
+
+/**********************************************************************/
+/* Unit execution                                                     */
+/**********************************************************************/
+
+static void *do_unit_k()
+{
+  Scheme_Process *p = scheme_current_process;
+  Scheme_Object **boxes;
+  Scheme_Object **anchors;
+  Scheme_Unit *m;
+  void *debug_request;
+  
+  boxes = (Scheme_Object **)p->ku.k.p1;
+  anchors = (Scheme_Object **)p->ku.k.p2;
+  m = (Scheme_Unit *)p->ku.k.p3;
+  debug_request = p->ku.k.p4;
+  
+  p->ku.k.p1 = NULL;
+  p->ku.k.p2 = NULL;
+  p->ku.k.p3 = NULL;
+  p->ku.k.p4 = NULL;
+
+  return (void *)do_unit(boxes, anchors, m, debug_request);
+}
+
+static Scheme_Object *do_unit(Scheme_Object **boxes, Scheme_Object **anchors,
+			      Scheme_Unit *m, void *debug_request)
+{
+  Scheme_Debug_Request *request = (Scheme_Debug_Request *)debug_request;
+  UnitDataClosure *cl;
+  BodyExpr *e;
+  BodyData *data;
+  Scheme_Object **indirect, **direct, **stack;
+  int i, c, total;
+  Scheme_Object *v, *result = scheme_void;
+  Scheme_Process *p = scheme_current_process;
+
+  cl = (UnitDataClosure *)m->data;
+  data = (BodyData *)cl->data;
+
+  c = m->num_imports + m->num_exports;
+  i = data->closure_size;
+
+  total = (2 * c) + (2 * data->num_locals) + i + data->max_let_depth;
+  if (!scheme_check_runstack(total)) {
+    p->ku.k.p1 = boxes;
+    p->ku.k.p2 = anchors;
+    p->ku.k.p3 = m;
+    p->ku.k.p4 = debug_request;
+    return (Scheme_Object *)scheme_enlarge_runstack(total, do_unit_k);
+  }
+
+  stack = PUSH_RUNSTACK(p, p->runstack, i);
+  direct = cl->closure_saved;
+  while (i--)
+    stack[i] = direct[i];
+  
+  indirect = PUSH_RUNSTACK(p, p->runstack, (2 * c));
+  direct = PUSH_RUNSTACK(p, p->runstack, (2 * data->num_locals));
+
+  for (i = 0; i < c; i++) {
+    indirect[i] = boxes[i];
+    indirect[i + c] = anchors[i];
+  }
+
+  for (e = data->body; e; e = e->next) {
+    if (e->type == mm_body_def) {
+      BodyVar *vs = e->u.def.vars;
+      for (i = 0; i < e->u.def.count; i++) {
+	if (!vs[i].exported) {
+	  Scheme_Object *anchor;
+	  
+	  direct[vs[i].pos] = debug_bind(request, vs[i].id, NULL, scheme_undefined, &anchor);
+	  direct[vs[i].pos + data->num_locals] = anchor;
+	}
+      }
+    }
+  }
+
+  for (e = data->body; e; e = e->next) {
+    switch(e->type) {
+    case mm_body_def:
+      {
+	int i, c;
+	BodyVar *vs = e->u.def.vars;
+	Scheme_Object **values;
+
+	v = e->u.def.expr;
+	v = _scheme_eval_compiled_expr_multi(v);
+	if (SAME_OBJ(v, SCHEME_MULTIPLE_VALUES)) {
+	  values = scheme_current_process->ku.multiple.array;
+	  c = scheme_current_process->ku.multiple.count;
+	} else {
+	  values = &v;
+	  c = 1;
+	}
+
+	if (e->u.def.count != c) {
+	  int i = e->u.def.count;
+	  scheme_raise_exn(MZEXN_APPLICATION_ARITY, 
+			   scheme_make_integer(c),
+			   scheme_make_integer(i),
+			   "define-values (in unit): returned %d value%s "
+			   "to a definition context%s%s%s expecting %d value%s",
+			   c, (c == 1) ? "" : "s",
+			   i ? " (" : "",
+			   i ? scheme_symbol_name(vs[0].id) : "",
+			   i ? ((i == 1) ? ")" : ", ...)") : "",
+			   i, (i == 1) ? "" : "s"); 
+
+	}
+
+	for (i = 0; i < c; i++) {
+	  v = values[i];
+	  if (vs[i].exported)
+	    SCHEME_ENVBOX_VAL(boxes[vs[i].pos]) = v;
+	  else
+	    SCHEME_ENVBOX_VAL(direct[vs[i].pos]) = v;
+	}
+	result = scheme_void;
+      }
+      break;
+    case mm_body_seq:
+      result = e->u.seq.expr;
+      result = _scheme_eval_compiled_expr_multi(result);
+      break;
+    }
+  }
+
+  return result;
+}
+
+static void *sub_debug(CompoundLinkedData *data,
+		       Scheme_Unit **subunits,
+		       Scheme_Debug_Request *request,
+		       Scheme_Debug_Request *sub_request,
+		       int i)
+{
+  void *sub_debug_request;
+
+  if (request 
+      && !request->const_prefix
+      && data->tags
+      && (!subunits[i]->exports || subunits[i]->export_debug_names)
+      && (SCHEME_NULLP(request->path)
+	  || SAME_OBJ(SCHEME_CAR(request->path), data->tags[i]))) {
+    sub_request->env = request->env;
+    sub_request->const_prefix = request->const_prefix;
+    if (SCHEME_NULLP(request->path)) {
+      if (!sub_request->const_prefix)
+	sub_request->prefix = (request->prefix
+			       ? build_unit_pathname(request->prefix, data->tags[i])
+			       : data->tags[i]);
+      else
+	sub_request->prefix = request->prefix;
+      sub_request->path = scheme_null;
+    } else {
+      sub_request->prefix = request->prefix;
+      sub_request->path = SCHEME_CDR(request->path);
+    }
+    sub_debug_request = (void *)sub_request;
+  } else
+    sub_debug_request = NULL;
+
+  return sub_debug_request;
+}
+
+static Scheme_Object *do_compound_unit(Scheme_Object **boxes_in, Scheme_Object **anchors_in,
+				       Scheme_Unit *m, void *debug_request)
+{
+  Scheme_Debug_Request *request = (Scheme_Debug_Request *)debug_request;
+  void *sub_debug_request;
+  Scheme_Debug_Request sub_request;
+  Scheme_Unit **subunits, *sm;
+  BoxMap **boxMapsList, *boxMaps;
+  Scheme_Object ***boxesList, **boxes, *v = scheme_void;
+  Scheme_Object ***anchorsList, **anchors;
+  CompoundLinkedData *data;
+  int num_mods, i, j, k;
+
+  data = (CompoundLinkedData *)m->data;
+
+  num_mods = data->num_submods;
+  subunits = data->subunits;
+
+  boxesList = (Scheme_Object ***)scheme_malloc(num_mods * sizeof(Scheme_Object **));
+  anchorsList = (Scheme_Object ***)scheme_malloc(num_mods * sizeof(Scheme_Object **));
+
+  boxMapsList = data->boxMapsList;
+
+  /* Create all boxes: */
+  for (i = 0; i < num_mods; i++) {
+    int c;
+
+    sm = subunits[i];
+
+    c = (sm->num_imports + sm->num_exports);
+    boxes = (Scheme_Object **)scheme_malloc(c * sizeof(Scheme_Object *));
+    anchors = (Scheme_Object **)scheme_malloc(c * sizeof(Scheme_Object *));
+    boxesList[i] = boxes;
+    anchorsList[i] = anchors;
+
+    boxMaps = boxMapsList[i];
+
+    k = sm->num_imports;
+    for (j = sm->num_exports; j--; ) {
+      if (boxMaps[j + k].source == -1) {
+	Scheme_Object *box;
+	Scheme_Object *anchor;
+
+	sub_debug_request = sub_debug(data, subunits, request, &sub_request, i);
+	
+	if (sub_debug_request) {
+	  box = debug_bind((Scheme_Debug_Request *)sub_debug_request, 
+			   sm->export_debug_names[j], 
+			   sm->exports[j], 
+			   scheme_undefined,
+			   &anchor);
+	} else {
+	  box = scheme_make_envunbox(scheme_undefined);
+	  anchor = NULL;
+	}
+	boxes[j + k] = box;
+	anchors[j + k] = anchor;
+      } else if (boxMaps[j + k].source == -2) {
+	int p = boxMaps[j + k].pos;
+	boxes[j + k] = boxes_in[p];
+	anchors[j + k] = anchors_in[p];
+      }
+    }
+  }
+
+  /* Link imports: */
+  for (i = 0; i < num_mods; i++) {
+    sm = subunits[i];
+
+    boxes = boxesList[i];
+    anchors = anchorsList[i];
+    boxMaps = boxMapsList[i];
+
+    for (j = sm->num_imports; j--; ) {
+      Scheme_Object *box, *anchor;
+      
+      if (boxMaps[j].source == -2) {
+	int p = boxMaps[j].pos;
+	box = boxes_in[p];
+	anchor = anchors_in[p];
+      } else {
+	int s = boxMaps[j].source, p = boxMaps[j].pos;
+	box = boxesList[s][p];
+	anchor = anchorsList[s][p];
+      }
+
+      boxes[j] = box;
+      anchors[j] = anchor;
+    }
+  }
+
+  /* All boxes are set up; now initialize units and we're done */
+  for (i = 0; i < num_mods; i++) {
+    sub_debug_request = sub_debug(data, subunits, request, &sub_request, i);
+    v = subunits[i]->init_func(boxesList[i], anchorsList[i], 
+			       subunits[i], sub_debug_request);
+    if (i + 1 < num_mods) {
+      /* could be a tail-call (currently only for foreign init_funcs) */
+      v = _scheme_force_value(v);
+    }
+  }
+
+  return v;
+}
+
+
+static Scheme_Object *unit_p(int argc, Scheme_Object *argv[])
+{
+  return SCHEME_UNITP(argv[0]) ? scheme_true : scheme_false;
+}
+
+/**********************************************************************/
+/* Marshalling                                                        */
+/**********************************************************************/
+
+static Scheme_Object *array_to_list(Scheme_Object **a, int c, Scheme_Object *base)
+{
+  Scheme_Object *l = base;
+
+  while (c--)
+    l = cons(a[c], l);
+  
+  return l;
+}
+
+
+static Scheme_Object **list_to_array(Scheme_Object *l, int c, Scheme_Object **l_back)
+{
+  Scheme_Object **a;
+  int i;
+
+  if (!c)
+    return NULL;
+
+  a = (Scheme_Object **)scheme_malloc(c * sizeof(Scheme_Object *));
+  for (i = 0; i < c; i++, l = SCHEME_CDR(l))
+    a[i] = SCHEME_CAR(l);
+
+  if (l_back)
+    *l_back = l;
+
+  return a;
+}
+
+static Scheme_Object *write_compiled_unit(Scheme_Object *o)
+{
+  Scheme_Unit *m;
+  
+  m = (Scheme_Unit *)o;
+
+  return cons(scheme_make_integer(m->num_imports),
+	      cons(scheme_make_integer(m->num_exports),
+		   cons(m->data,
+			array_to_list(m->exports,
+				      m->num_exports,
+				      (m->export_debug_names
+				       ? array_to_list(m->export_debug_names, 
+						       m->num_exports,
+						       scheme_null)
+				       : scheme_false)))));
+}
+
+static Scheme_Object *read_compiled_unit(Scheme_Object *o)
+{
+  Scheme_Unit *m;
+  int c;
+
+  m = (Scheme_Unit *)scheme_malloc_tagged(sizeof(Scheme_Unit));
+  m->type = scheme_compiled_unit_type;
+
+  m->num_imports = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+  c = m->num_exports = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+
+  m->data = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+
+  m->exports = list_to_array(o, c, &o);
+
+  if (SCHEME_FALSEP(o))
+    m->export_debug_names = NULL;
+  else
+    m->export_debug_names = list_to_array(o, c, NULL);
+
+  if (SAME_TYPE(SCHEME_TYPE(m->data), scheme_unit_body_data_type))
+    m->init_func = do_unit;
+  else
+    m->init_func = do_compound_unit;
+
+  return (Scheme_Object *)m;
+}
+
+static Scheme_Object *write_body_data(Scheme_Object *o)
+{
+  BodyData *data;
+  BodyExpr *body;
+  Scheme_Object *l;
+  int counter = 0;
+
+  data = (BodyData *)o;
+
+  l = scheme_null;
+
+  for (body = data->body; body; body = body->next) {
+    switch (body->type) {
+    case mm_body_def:
+      {
+	int i, count = body->u.def.count;
+	BodyVar *vs = body->u.def.vars;
+	
+	for (i = count; i--; )
+	  l = cons(vs[i].id,
+		   cons(scheme_make_integer(vs[i].pos),
+			cons(vs[i].exported ? scheme_true : scheme_false,
+			     l)));
+
+	l = cons(body->u.def.expr,
+		 cons(scheme_make_integer(body->u.def.count),
+		      l));
+      }
+      break;
+    case mm_body_seq:
+      l = cons(body->u.seq.expr, l);
+      break;
+    }
+    
+    l = cons(scheme_make_integer(body->type), l);
+    counter++;
+  }
+
+  return cons(scheme_make_integer(data->num_locals), 
+	      cons(scheme_make_integer(data->max_let_depth),
+		   cons(scheme_make_svector(data->closure_size,
+					    data->closure_map),
+			cons(scheme_make_integer(counter),
+			     cons(data->defname
+				  ? data->defname
+				  : scheme_null,
+				  l)))));
+}
+
+static Scheme_Object *read_body_data(Scheme_Object *o)
+{
+  BodyData *data;
+  BodyExpr *body;
+  Scheme_Object *v;
+  int counter;
+
+  data = (BodyData *)scheme_malloc_tagged(sizeof(BodyData));
+  data->type = scheme_unit_body_data_type;
+  
+  data->num_locals = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+
+  data->max_let_depth = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+
+  v = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+
+  data->closure_size = SCHEME_SVEC_LEN(v);
+  data->closure_map = SCHEME_SVEC_VEC(v);
+
+  counter = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+
+  data->defname = SCHEME_CAR(o);
+  if (SCHEME_NULLP(data->defname))
+    data->defname = NULL;
+  o = SCHEME_CDR(o);
+
+  data->body = NULL;
+  while (counter--) {
+    body = (BodyExpr *)scheme_malloc(sizeof(BodyExpr));
+    body->next = data->body;
+    data->body = body;
+
+    body->type = SCHEME_INT_VAL(SCHEME_CAR(o));
+    o = SCHEME_CDR(o);
+
+    switch (body->type) {
+    case mm_body_def: 
+      {
+	int i, c;
+	BodyVar *vs;
+	
+	body->u.def.expr = SCHEME_CAR(o);
+	o = SCHEME_CDR(o);
+	body->u.def.count = SCHEME_INT_VAL(SCHEME_CAR(o));
+	o = SCHEME_CDR(o);
+
+	c = body->u.def.count;
+	vs = (BodyVar *)scheme_malloc(c * sizeof(BodyVar));
+	body->u.def.vars = vs;
+
+	for (i = 0; i < c; i++) {
+	  vs[i].id = SCHEME_CAR(o);
+	  o = SCHEME_CDR(o);
+	  vs[i].pos = SCHEME_INT_VAL(SCHEME_CAR(o));
+	  o = SCHEME_CDR(o);
+	  vs[i].exported = SCHEME_TRUEP(SCHEME_CAR(o));
+	  o = SCHEME_CDR(o);
+	}
+      }
+      break;
+    case mm_body_seq:
+      body->u.seq.expr = SCHEME_CAR(o);
+      o = SCHEME_CDR(o);
+      break;
+    }
+  }
+
+  return (Scheme_Object *)data;
+}
+
+static Scheme_Object *write_compound_data(Scheme_Object *o)
+{
+  CompoundData *data;
+  Scheme_Object *exs, *subs, *tags, *counts, *maps;
+  ParamMap *map;
+  int i, j;
+
+  data = (CompoundData *)o;
+  
+  exs = scheme_null;
+  for (i = data->num_exports; i--; )
+    exs = cons(scheme_make_integer(data->exports[i].submod_index),
+	       cons(data->exports[i].ext_id, exs));
+
+  subs = array_to_list(data->subunit_exprs, data->num_subunits, scheme_null);
+
+  tags = array_to_list(data->tags, data->num_subunits, scheme_null);
+
+  counts = scheme_null;
+  for (i = data->num_subunits; i--; )
+    counts = cons(scheme_make_integer(data->param_counts[i]), counts);
+
+  maps = scheme_null;
+  for (i = data->num_subunits; i--; ) {
+    map = data->param_maps[i];
+    for (j = data->param_counts[i]; j--; ) {
+      if (map[j].index < 0)
+	maps = cons(scheme_make_integer(map[j].u.pos), maps);
+      else
+	maps = cons(map[j].u.ext_id, maps);
+      maps = cons(scheme_make_integer(map[j].index), maps);
+    }
+  }
+
+  return cons(scheme_make_integer(data->num_exports),
+	      cons(scheme_make_integer(data->num_subunits),
+		   cons(data->defname
+			? data->defname
+			: scheme_null,
+			cons(exs,
+			     cons(subs,
+				  cons(tags,
+				       cons(counts, maps)))))));
+}
+
+static Scheme_Object *read_compound_data(Scheme_Object *o)
+{
+  CompoundData *data;
+  Scheme_Object *exs, *subs, *counts, *maps, *tags;
+  ParamMap *map;
+  int c, n, i, j;
+
+  data = (CompoundData *)scheme_malloc_tagged(sizeof(CompoundData));
+  data->type = scheme_unit_compound_data_type;
+
+  c = data->num_exports = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+  n = data->num_subunits = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+
+  data->defname = SCHEME_CAR(o);
+  if (SCHEME_NULLP(data->defname))
+    data->defname = NULL;
+  o = SCHEME_CDR(o);
+
+  exs = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+  subs = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+  tags = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+  counts = SCHEME_CAR(o);
+  maps = SCHEME_CDR(o);
+
+  data->exports = (ExportSource *)scheme_malloc(sizeof(ExportSource)
+						* data->num_exports);
+  for (i = 0; i < c; i++) {
+    data->exports[i].submod_index = SCHEME_INT_VAL(SCHEME_CAR(exs));
+    exs = SCHEME_CDR(exs);
+    data->exports[i].ext_id = SCHEME_CAR(exs);
+    exs = SCHEME_CDR(exs);
+  }
+
+  data->tags = list_to_array(tags, n, NULL);
+  data->subunit_exprs = list_to_array(subs, n, NULL);
+
+  data->param_counts = (short *)scheme_malloc(n * sizeof(short));
+  for (i = 0; i < n; i++, counts = SCHEME_CDR(counts))
+    data->param_counts[i] = SCHEME_INT_VAL(SCHEME_CAR(counts));
+
+  data->param_maps = (ParamMap **)scheme_malloc(n * sizeof(ParamMap *));
+  for (i = 0; i < n; i++) {
+    c = data->param_counts[i];
+    map = data->param_maps[i] = (ParamMap *)scheme_malloc(c * sizeof(ParamMap));
+    for (j = 0; j < c; j++, maps = SCHEME_CDR(maps)) {
+      map[j].index = SCHEME_INT_VAL(SCHEME_CAR(maps));
+      maps = SCHEME_CDR(maps);
+      if (map[j].index < 0)
+	map[j].u.pos = SCHEME_INT_VAL(SCHEME_CAR(maps));
+      else
+	map[j].u.ext_id = SCHEME_CAR(maps);
+    }
+  }
+
+  return (Scheme_Object *)data;
+}
+
+static Scheme_Object *write_invoke_data(Scheme_Object *o)
+{
+  InvokeUnitData *data;
+
+  data = (InvokeUnitData *)o;
+
+  return cons(scheme_make_integer(data->num_exports),
+	      cons(data->path ? data->path : scheme_make_integer(0),
+		   cons(data->const_prefix 
+			? data->const_prefix 
+			: scheme_make_integer(0),
+			cons(scheme_make_svector(data->num_local_exports,
+						 data->anchor_positions),
+			     cons(data->expr, array_to_list(data->exports,
+							    data->num_exports,
+							    scheme_null))))));
+}
+
+
+static Scheme_Object *read_invoke_data(Scheme_Object *o)
+{
+  InvokeUnitData *data;
+  Scheme_Object *v;
+
+  data = (InvokeUnitData *)scheme_malloc_tagged(sizeof(InvokeUnitData));
+  data->type = scheme_invoke_unit_data_type;
+
+  data->num_exports = SCHEME_INT_VAL(SCHEME_CAR(o));
+  o = SCHEME_CDR(o);
+  data->path = SCHEME_CAR(o);
+  if (SCHEME_INTP(data->path))
+    data->path = NULL;
+  o = SCHEME_CDR(o);
+  data->const_prefix = SCHEME_CAR(o);
+  if (SCHEME_INTP(data->const_prefix))
+    data->const_prefix = NULL;
+  o = SCHEME_CDR(o);
+
+  v = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+
+  data->num_local_exports = SCHEME_SVEC_LEN(v);
+  data->anchor_positions = SCHEME_SVEC_VEC(v);
+
+  data->expr = SCHEME_CAR(o);
+  o = SCHEME_CDR(o);
+
+  data->exports = list_to_array(o, data->num_exports, NULL);
+
+  data->anchors = NULL;
+
+  return (Scheme_Object *)data;
+}
+
+/**********************************************************************/
+/* Unit/sig                                                           */
+/**********************************************************************/
+
+static void init_unitsig()
+{
+  Scheme_Env *env = scheme_get_env(scheme_config);
+
+#define EVAL_ONE_STR(str) unitsig_macros = scheme_eval_string(str, env)
+#define EVAL_ONE_SIZED_STR(str, len) unitsig_macros = scheme_eval_compiled_sized_string(str, len, env)
+#define JUST_DEFINED(x) /**/
+
+#if USE_COMPILED_MACROS
+#include "cunitsig.inc"
+#else
+#include "unitsig.inc"
+#endif
+}
+
+static Scheme_Object *do_unitsig(void *which, int argc, Scheme_Object **argv)
+{
+  if (!unitsig_macros)
+    init_unitsig();
+
+  return _scheme_apply(SCHEME_VEC_ELS(unitsig_macros)[(int)which],
+		       argc, argv);
+}
+
+static Scheme_Object *make_unitsig_macro(int pos)
+{
+  Scheme_Object *macro, *proc;
+
+  proc = scheme_make_closed_prim_w_arity(do_unitsig, (void *)pos,
+					 "unitsig", 0, -1);
+
+  macro = scheme_alloc_stubborn_small_object();
+  macro->type = scheme_macro_type;
+  SCHEME_PTR_VAL(macro) = proc;
+  scheme_end_stubborn_change((void *)macro);
+
+  return macro;
+}
+
+static int hash_sig(Scheme_Object *src_sig, Scheme_Hash_Table *table)
+{
+  int i, c;
+  Scheme_Object **sv;
+
+  if (!SCHEME_VECTORP(src_sig))
+    return 0;
+
+  c = SCHEME_VEC_SIZE(src_sig);
+  sv = SCHEME_VEC_ELS(src_sig);
+
+  for (i = 0; i < c; i++) {
+    Scheme_Object *s = sv[i];
+
+    if (SCHEME_SYMBOLP(s)) {
+      Scheme_Bucket *b = scheme_bucket_from_table(table, (const char *)s);
+      if (b->val)
+	return 0;
+      b->val = s;
+    } else {
+      Scheme_Hash_Table *t;
+      Scheme_Bucket *b;
+      Scheme_Object *name;
+
+      if (!SCHEME_PAIRP(s) || !SCHEME_SYMBOLP(SCHEME_CAR(s)))
+	return 0;
+
+      name = SCHEME_CAR(s);
+
+      b = scheme_bucket_from_table(table, (const char *)name);
+      if (b->val)
+	return 0;
+
+      t = scheme_hash_table(10, SCHEME_hash_ptr, 0, 0);
+      b->val = t;
+
+      if (!hash_sig(SCHEME_CDR(s), t))
+	return 0;
+    }
+  }
+
+  return 1;
+}
+
+static char *sig_path_name(Scheme_Object *name, Scheme_Object *path)
+{
+  char *s = (char *)scheme_symbol_name(name);
+  int l = strlen(s);
+
+  while (!SCHEME_NULLP(path)) {
+    char *n = (char *)scheme_symbol_name(SCHEME_CAR(path)), *v;
+    int nl;
+    nl = strlen(n);
+    v = scheme_malloc_atomic(nl + l + 2);
+    memcpy(v + nl + 1, s, l);
+    memcpy(v, n, nl);
+    v[nl] = ':';
+    v[l + nl + 2] = 0;
+    l += nl + 1;
+    s = v;
+    path = SCHEME_CDR(path);
+  }
+
+  return s;
+}
+
+static int check_sig_match(Scheme_Hash_Table *table, Scheme_Object *sig, Scheme_Object *path,
+			   int exact, Scheme_Object *who, Scheme_Object *src_context, Scheme_Object *dest_context)
+{
+  int i, c;
+  Scheme_Object **sv;
+
+  if (!SCHEME_VECTORP(sig))
+    return 0;
+
+  c = SCHEME_VEC_SIZE(sig);
+  sv = SCHEME_VEC_ELS(sig);
+
+  for (i = 0; i < c; i++) {
+    Scheme_Object *s = sv[i];
+    
+    if (SCHEME_SYMBOLP(s)) {
+      Scheme_Bucket *b = scheme_bucket_from_table(table, (const char *)s);
+      if (!b->val) {
+	/* Missing value */
+	char *p = sig_path_name(s, path);
+	scheme_raise_exn(MZEXN_UNIT_SIGNATURE_MATCH_MISSING,
+			 dest_context,
+			 src_context,
+			 scheme_make_string(p),
+			 "%s: %.255s is missing a value name \"%.255s\", required by %.255s",
+			 scheme_symbol_name(who),
+			 SCHEME_STR_VAL(src_context),
+			 p,
+			 SCHEME_STR_VAL(dest_context));
+	return 0;
+      } else if (SCHEME_FALSEP((Scheme_Object *)b->val))
+	return 0;
+      else if (!SCHEME_SYMBOLP((Scheme_Object *)b->val)) {
+	/* Kind mismatch */
+	char *p = sig_path_name(s, path);
+	scheme_raise_exn(MZEXN_UNIT_SIGNATURE_MATCH_KIND,
+			 dest_context,
+			 src_context,
+			 scheme_make_string(p),
+			 "%s: %.255s contains \"%.255s\" as a sub-unit name, but %.255s contains \"%.255s\" as a value name",
+			 scheme_symbol_name(who),
+			 SCHEME_STR_VAL(src_context),
+			 p,
+			 SCHEME_STR_VAL(dest_context),
+			 p);
+	return 0;
+      }
+
+      b->val = scheme_false;
+    } else {
+      Scheme_Hash_Table *t;
+      Scheme_Bucket *b;
+      Scheme_Object *name;
+
+      if (!SCHEME_PAIRP(s) || !SCHEME_SYMBOLP(SCHEME_CAR(s)))
+	return 0;
+
+      name = SCHEME_CAR(s);
+
+      b = scheme_bucket_from_table(table, (const char *)name);
+      if (!b->val) {
+	/* Missing sub-unit */
+	char *p = sig_path_name(name, path);
+	scheme_raise_exn(MZEXN_UNIT_SIGNATURE_MATCH_MISSING,
+			 dest_context,
+			 src_context,
+			 scheme_make_string(p),
+			 "%s: %.255s is missing a sub-unit name \"%.255s\", required by %.255s",
+			 scheme_symbol_name(who),
+			 SCHEME_STR_VAL(src_context),
+			 p,
+			 SCHEME_STR_VAL(dest_context));
+      } else if (SCHEME_FALSEP((Scheme_Object *)b->val))
+	return 0;
+      else if (!SCHEME_HASHTP((Scheme_Object *)b->val)) {
+	/* Kind mismatch */
+	char *p = sig_path_name(name, path);
+	scheme_raise_exn(MZEXN_UNIT_SIGNATURE_MATCH_KIND,
+			 dest_context,
+			 src_context,
+			 scheme_make_string(p),
+			 "%s: %.255s contains \"%.255s\" as a value name, but %.255s contains \"%.255s\" as a sub-unit name",
+			 scheme_symbol_name(who),
+			 SCHEME_STR_VAL(src_context),
+			 p,
+			 SCHEME_STR_VAL(dest_context),
+			 p);
+
+      }
+
+      t = (Scheme_Hash_Table *)b->val;
+      b->val = scheme_false;
+
+      if (!check_sig_match(t, SCHEME_CDR(s), scheme_make_pair(name, path),
+			   exact, who, src_context, dest_context))
+	return 0;
+    }
+  }
+
+  if (exact) {
+    Scheme_Bucket **v = table->buckets;
+    int i;
+    for (i = table->size; i--; )
+      if (v[i]) {
+	Scheme_Bucket *b = v[i];
+	if (SCHEME_TRUEP((Scheme_Object *)b->val)) {
+	  /* Extra mismatch */
+	  Scheme_Object *name = (Scheme_Object *)b->key;
+	  char *p = sig_path_name(name, path);
+	  scheme_raise_exn(MZEXN_UNIT_SIGNATURE_MATCH_EXTRA,
+			   dest_context,
+			   src_context,
+			   scheme_make_string(p),
+			   "%s: %.255s contains an extra %s name \"%.255s\" that is not required by %.255s",
+			   scheme_symbol_name(who),
+			   SCHEME_STR_VAL(src_context),
+			   SCHEME_SYMBOLP((Scheme_Object *)b->val) ? "value" : "sub-unit",
+			   p,
+			   SCHEME_STR_VAL(dest_context));
+	}
+      }
+  }
+
+  return 1;
+}
+
+static Scheme_Object *verify_signature_match(int argc, Scheme_Object **argv)
+{
+  Scheme_Object *who, *dest_context, *dest_sig, *src_context, *src_sig;
+  Scheme_Hash_Table *src_table;
+  int exact;
+
+  /* printf("start verify signature: %ld\n", scheme_get_process_milliseconds()); */
+
+  who = argv[0];
+  exact = SCHEME_TRUEP(argv[1]);
+  dest_context = argv[2];
+  dest_sig = argv[3];
+  src_context = argv[4];
+  src_sig = argv[5];
+
+  if (!SCHEME_SYMBOLP(who))
+    scheme_wrong_type("verify-signature-match", "symbol", 0, argc, argv);
+  if (!SCHEME_STRINGP(dest_context))
+    scheme_wrong_type("verify-signature-match", "string", 2, argc, argv);
+  if (!SCHEME_STRINGP(src_context))
+    scheme_wrong_type("verify-signature-match", "string", 4, argc, argv);
+  
+  src_table = scheme_hash_table(10, SCHEME_hash_ptr, 0, 0);
+  if (!hash_sig(src_sig, src_table))
+    scheme_wrong_type("verify-signature-match", "signature", 5, argc, argv);
+
+  if (!check_sig_match(src_table, dest_sig, scheme_null,
+		       exact, who, src_context, dest_context))
+    scheme_wrong_type("verify-signature-match", "signature", 3, argc, argv);
+
+  /* printf("end verify signature: %ld\n", scheme_get_process_milliseconds()); */
+
+  return scheme_void;
+}
+
+/**********************************************************************/
+/* Initialization                                                     */
+/**********************************************************************/
+
+void scheme_init_unit(Scheme_Env *env)
+{
+  Scheme_Object *v;
+
+  if (scheme_starting_up) {
+    REGISTER_SO(unitsig_macros);
+
+    REGISTER_SO(import_symbol);
+    REGISTER_SO(export_symbol);
+    REGISTER_SO(with_symbol);
+    REGISTER_SO(define_values_symbol);
+    REGISTER_SO(unit_symbol);
+    REGISTER_SO(compound_unit_symbol);
+    REGISTER_SO(invoke_unit_symbol);
+    REGISTER_SO(invoke_open_unit_symbol);
+
+    export_symbol = scheme_intern_symbol("export");
+    import_symbol = scheme_intern_symbol("import");
+    with_symbol = scheme_intern_symbol("link");
+
+    define_values_symbol = scheme_intern_symbol("#%define-values");
+
+    unit_symbol = scheme_intern_symbol("#%unit");
+    compound_unit_symbol = scheme_intern_symbol("#%compound-unit");
+    invoke_unit_symbol = scheme_intern_symbol("#%invoke-unit");
+    invoke_open_unit_symbol = scheme_intern_symbol("#%invoke-open-unit");
+
+    scheme_register_syntax("m", CloseUnit);
+    scheme_register_syntax("cm", CloseCompoundUnit);
+    scheme_register_syntax("im", InvokeUnit);
+
+    scheme_install_type_writer(scheme_compiled_unit_type, write_compiled_unit);
+    scheme_install_type_reader(scheme_compiled_unit_type, read_compiled_unit);
+    scheme_install_type_writer(scheme_unit_body_data_type, write_body_data);
+    scheme_install_type_reader(scheme_unit_body_data_type, read_body_data);
+    scheme_install_type_writer(scheme_unit_compound_data_type, write_compound_data);
+    scheme_install_type_reader(scheme_unit_compound_data_type, read_compound_data);
+    scheme_install_type_writer(scheme_invoke_unit_data_type, write_invoke_data);
+    scheme_install_type_reader(scheme_invoke_unit_data_type, read_invoke_data);    
+  }
+
+  scheme_add_global_keyword(MAKE_UNIT, 
+			    scheme_make_compiled_syntax(make_unit_syntax, 
+							make_unit_expand), 
+			    env);
+  scheme_add_global_keyword(MAKE_COMPOUND_UNIT, 
+			    scheme_make_compiled_syntax(make_compound_unit_syntax, 
+							make_compound_unit_expand), 
+			    env);
+  scheme_add_global_keyword(INVOKE_UNIT, 
+			    scheme_make_compiled_syntax(invoke_unit_syntax, 
+							invoke_unit_expand), 
+			    env);
+  scheme_add_global_keyword(INVOKE_OPEN_UNIT, 
+			    scheme_make_compiled_syntax(invoke_open_unit_syntax, 
+							invoke_open_unit_expand), 
+			    env);
+
+  scheme_add_global_constant("unit?", 
+			    scheme_make_folding_prim(unit_p, 
+						     "unit?",
+						     1, 1, 1),
+			    env);
+
+  scheme_add_global_constant("verify-signature-match", 
+			     scheme_make_prim_w_arity(verify_signature_match,
+						      "verify-signature-match",
+						      6, 6),
+			     env);
+
+  /* Signed unit macros: */
+  v = make_unitsig_macro(0);
+  scheme_add_global_keyword("define-signature", v, env);
+  v = make_unitsig_macro(1);
+  scheme_add_global_keyword("let-signature", v, env);
+  v = make_unitsig_macro(2);
+  scheme_add_global_keyword("unit-with-signature", v, env);
+  scheme_add_global_keyword("unit/sig", v, env);
+  v = make_unitsig_macro(3);
+  scheme_add_global_keyword("compound-unit-with-signature", v, env);
+  scheme_add_global_keyword("compound-unit/sig", v, env);
+  v = make_unitsig_macro(4);
+  scheme_add_global_keyword("invoke-unit-with-signature", v, env);
+  scheme_add_global_keyword("invoke-unit/sig", v, env);
+  v = make_unitsig_macro(5);
+  scheme_add_global_keyword("invoke-open-unit-with-signature", v, env);
+  scheme_add_global_keyword("invoke-open-unit/sig", v, env);
+  v = make_unitsig_macro(6);
+  scheme_add_global_keyword("unit->unit-with-signature", v, env);
+  scheme_add_global_keyword("unit->unit/sig", v, env);
+}
+
+const char *scheme_get_unit_name(Scheme_Object *o, int *len)
+{
+  Scheme_Unit *u;
+
+  if (!SCHEME_UNITP(o))
+    return NULL;
+
+  u = (Scheme_Unit *)o;
+  
+  if (u->init_func == do_unit) {
+    Scheme_Object *n;
+
+    n = ((UnitDataClosure *)u->data)->defname;
+    if (n) {
+      *len = SCHEME_SYM_LEN(n);
+      return SCHEME_SYM_VAL(n);
+    }    
+  } else if (u->init_func == do_compound_unit) {
+    Scheme_Object *n;
+
+    n = ((CompoundLinkedData *)u->data)->defname;
+    if (n) {
+      *len = SCHEME_SYM_LEN(n);
+      return SCHEME_SYM_VAL(n);
+    }
+  }
+   
+  return NULL;
+}
+
+/**********************************************************************/
+/* Memory Counting                                                    */
+/**********************************************************************/
+
+#ifdef MEMORY_COUNTING_ON
+void scheme_count_unit(Scheme_Type type, Scheme_Object *o, long *s, long *e, 
+		       Scheme_Hash_Table *ht)
+{
+  switch (type) {
+  case scheme_unit_type:
+  case scheme_compiled_unit_type:
+    {
+      Scheme_Unit *u = (Scheme_Unit *)o;
+
+      *s = (sizeof(Scheme_Unit)
+	    + (u->num_exports * sizeof(Scheme_Object *)));
+      if (u->export_debug_names)
+	*s += (u->num_exports * sizeof(Scheme_Object *));
+      
+#if 0
+      if ((type == scheme_compiled_unit_type)
+	  || (u->init_func == do_unit)
+	  || (u->init_func == do_compound_unit))
+	*e += scheme_count_memory(u->data, ht);
+#endif
+    }
+    break;
+  case scheme_unit_body_data_type:
+    {
+      BodyData *b = (BodyData *)o;
+      BodyExpr *ex;
+
+      *s = sizeof(BodyData) + (b->closure_size * sizeof(short));
+
+      for (ex = b->body; ex; ex = ex->next) {
+	*s += sizeof(BodyExpr);
+
+	switch (ex->type) {
+	case mm_body_def:
+	  {
+#if 0
+	    *e += scheme_count_memory(ex->u.def.expr, ht);
+#endif
+	    *s += (ex->u.def.count * sizeof(BodyVar));
+	  }
+	  break;
+	case mm_body_seq:
+#if 0
+	  *e += scheme_count_memory(ex->u.seq.expr, ht);
+#endif
+	  break;
+	}
+      }
+    }
+    break;
+  case scheme_unit_compound_data_type:
+    {
+      CompoundData *d = (CompoundData *)o;
+      int i;
+
+      *s = (sizeof(CompoundData)
+	    + (sizeof(ExportSource) * d->num_exports)
+	    + (sizeof(Scheme_Object *) * 2 * d->num_subunits)
+	    + ((sizeof(int) + sizeof(ParamMap *)) * d->num_subunits));
+      for (i = d->num_subunits; i--; ) {
+	*s += (sizeof(ParamMap) * d->param_counts[i]);
+	*e += scheme_count_memory(d->subunit_exprs[i], ht);
+      }
+    }
+    break;
+  case scheme_invoke_unit_data_type:
+    {
+      InvokeUnitData *i = (InvokeUnitData *)o;
+      
+      *s = (sizeof(InvokeUnitData)
+	    + (i->num_exports * (sizeof(Scheme_Object *)
+				 + sizeof(Scheme_Object *))));
+#if 0
+      *e += scheme_count_memory(i->expr, ht);
+#endif
+    }
+    break;
+  }
+}
+#endif
+
+#endif /* NO_UNIT_SYSTEM */
+
diff --git a/src/mzscheme/src/unitsig.inc b/src/mzscheme/src/unitsig.inc
new file mode 100644
index 0000000..f6b7cd7
--- /dev/null
+++ b/src/mzscheme/src/unitsig.inc
@@ -0,0 +1,1046 @@
+  EVAL_ONE_STR(
+"(invoke-unit"
+"(unit"
+"(import)"
+"(export)"
+"(define-struct signature(name src global-src elems))"
+"(define-struct parse-unit(imports renames vars body))"
+"(define d-s 'define-signature)"
+"(define l-s 'let-signature)"
+"(define unit/sig 'unit/sig)"
+"(define u->u/sig 'unit->unit/sig)"
+"(define cpd-unit/sig 'compound-unit/sig)"
+"(define invoke-unit/sig 'invoke-unit/sig)"
+"(define invoke-open-unit/sig 'invoke-open-unit/sig)"
+"(define inline-sig-name '<unnamed>)"
+"(define(result x) x)"
+"(define syntax-error"
+"(case-lambda "
+"((who expr msg sub)"
+"(raise-syntax-error who msg expr sub))"
+"((who expr msg)"
+"(raise-syntax-error who msg expr))))"
+"(define undef-sig-error"
+"(lambda(who expr what)"
+"(syntax-error who expr "
+" (format \"signature \\\"~s\\\" not defined\" what))))"
+"(define not-a-sig-error"
+"(lambda(who expr what)"
+"(syntax-error who expr "
+" (format \"\\\"~s\\\" is not a signature\" what))))"
+"(define rename-signature"
+"(lambda(sig name)"
+"(make-signature name "
+"(signature-src sig) "
+"(signature-global-src sig) "
+"(signature-elems sig))))"
+"(define intern-signature"
+"(lambda(name desc global-name error)"
+"(make-signature"
+" name"
+" name"
+" global-name"
+"(if(vector? desc)"
+"(map"
+"(lambda(elem)"
+"(cond"
+"((symbol? elem) elem)"
+"((and(pair? elem)(symbol?(car elem)))"
+"(intern-signature(car elem)(cdr elem) #f error))"
+"(else(error))))"
+"(vector->list desc))"
+"(error)))))"
+"(define get-sig"
+"(lambda(who expr name sigid)"
+"(if(not(symbol? sigid))"
+"(parse-signature who expr "
+"(if name"
+" name"
+" inline-sig-name)"
+" sigid)"
+"(let((v(with-handlers"
+"((void(lambda(x)(undef-sig-error who expr sigid))))"
+"(local-expansion-time-value sigid)))"
+"(gv(with-handlers"
+"((void(lambda(x) #f)))"
+"(global-expansion-time-value sigid))))"
+"(let((s(intern-signature sigid v"
+"(and(eq? v gv) sigid)"
+"(lambda()"
+"(not-a-sig-error who expr sigid)))))"
+"(if name"
+"(rename-signature s name)"
+" s))))))"
+"(define check-unique"
+"(lambda(names error-k)"
+"(cond"
+"((null? names)(void))"
+"((memq(car names)(cdr names))"
+"(error-k(car names)))"
+"(else(check-unique(cdr names) error-k)))))"
+"(define build-struct-names"
+"(lambda(name fields omit-sel? omit-set?)"
+"(let((name(symbol->string name))"
+"(fields(map symbol->string fields))"
+"(+ string-append))"
+"(map string->symbol"
+"(append"
+"(list "
+" (+ \"make-\" name)"
+" (+ name \"?\")"
+" (+ \"struct:\" name))"
+"(if omit-sel?"
+" null"
+"(map"
+"(lambda(f)"
+" (+ name \"-\" f))"
+" fields))"
+"(if omit-set?"
+" null"
+"(map"
+"(lambda(f)"
+" (+ \"set-\" name \"-\" f \"!\"))"
+" fields)))))))"
+"(define parse-signature"
+"(lambda(who expr name body)"
+"(let((elems"
+"(let loop((body body))"
+"(cond"
+"((null? body) null)"
+"((not(pair? body))"
+" (syntax-error who expr \"improper signature list form\"))"
+"(else"
+"(let((first(car body))"
+"(k(lambda()(loop(cdr body)))))"
+"(cond"
+"((and(symbol? first)(not(eq? first ':)))(cons first(k)))"
+"((or(not(pair? first))"
+"(not(list? first))) "
+" (syntax-error who expr \"improper signature clause form\" first))"
+"((eq?(car first) 'struct)"
+"(let((sdef(cdr first))"
+"(bad"
+"(lambda(why)"
+"(syntax-error who expr "
+" (format \"improper `struct' clause form~a\""
+" why)"
+" first))))"
+"(unless(and(<= 2(length sdef))"
+"(or(symbol?(car sdef))"
+" (bad \": struct name not an identifier\"))"
+"(list?(cadr sdef))"
+"(andmap(lambda(s)"
+"(or(symbol? s)"
+" (bad \": field name not an identifier\")))"
+"(cadr sdef))"
+"(or(=(length sdef) 2)"
+"(andmap"
+"(lambda(omit)"
+"(or(eq? omit '-selectors)"
+"(eq? omit '-setters)"
+"(and(pair? omit)"
+"(eq?(car omit) '-)"
+"(pair?(cdr omit))"
+"(symbol?(cadr omit))"
+"(null?(cddr omit)))"
+" (bad \": bad omission specifier\")))"
+"(cddr sdef))))"
+" (bad \"\"))"
+"(let((name(car sdef))"
+"(fields(cadr sdef))"
+"(omit-names"
+"(let loop((l(cddr sdef)))"
+"(cond"
+"((null? l) null)"
+"((pair?(car l))(cons(cadar l)(loop(cdr l))))"
+"(else(loop(cdr l))))))"
+"(omit-setters?(memq '-setters(cddr sdef)))"
+"(omit-selectors?(memq '-selectors(cddr sdef))))"
+"(letrec((names(build-struct-names "
+" name fields "
+" omit-selectors? omit-setters?))"
+"(filter"
+"(lambda(names)"
+"(cond"
+"((null? names) null)"
+"((memq(car names) omit-names)(filter(cdr names)))"
+"(else(cons(car names)(filter(cdr names))))))))"
+" "
+"(append(if(null? omit-names) names(filter names))"
+"(k))))))"
+"((eq?(car first) 'unit)"
+"(let((udef(cdr first))"
+"(bad"
+"(lambda(why)"
+"(syntax-error who expr "
+" (format \"improper `unit' clause form~a\""
+" why)"
+" first))))"
+"(unless(and(= 3(length udef))"
+"(or(symbol?(car udef))"
+" (bad \": unit name not an identifier\"))"
+"(eq? ':(cadr udef)))"
+" (bad \"\"))"
+"(let((s(get-sig who expr(car udef)(caddr udef))))"
+"(cons s(k)))))"
+"((eq?(car first) 'open)"
+"(let((odef(cdr first)))"
+"(unless(and(pair? odef)"
+"(null?(cdr odef)))"
+"(syntax-error who expr "
+" \"improper `open' clause form\"))"
+"(let((s(get-sig who expr #f(car odef))))"
+"(append(signature-elems s)(k)))))"
+"(else"
+" (syntax-error who expr \"improper signature clause type\" first)))))))))"
+"(check-unique(map"
+"(lambda(elem)"
+"(if(symbol? elem)"
+" elem"
+"(signature-name elem)))"
+" elems)"
+"(lambda(name)"
+"(syntax-error who expr"
+" (format \"duplicate name \\\"~s\\\" in signature\""
+" name))))"
+"(make-signature name name #f(sort-signature-elems elems)))))"
+"(define explode-sig"
+"(lambda(sig)"
+"(list->vector"
+"(map "
+"(lambda(v)"
+"(if(symbol? v)"
+" v"
+"(cons"
+"(signature-name v)"
+"(explode-sig v))))"
+"(signature-elems sig)))))"
+"(define explode-named-sig"
+"(lambda(s)"
+"(cons"
+"(cond"
+"((signature-name s))"
+"((signature-src s))"
+"(else inline-sig-name))"
+"(explode-sig s))))"
+"(define explode-named-sigs"
+"(lambda(sigs)"
+"(map explode-named-sig sigs)))"
+"(define sort-signature-elems"
+"(lambda(elems)"
+"(letrec((split"
+"(lambda(l f s)"
+"(cond"
+"((null? l)(values f s))"
+"((null?(cdr l))(values(cons(car l) f) s))"
+"(else(split(cddr l)(cons(car l) f)(cons(cadr l) s))))))"
+"(merge"
+"(lambda(f s)"
+"(cond"
+"((null? f) s)"
+"((null? s) f)"
+"((less-than?(car s)(car f))"
+"(cons(car s)(merge f(cdr s))))"
+"(else"
+"(cons(car f)(merge(cdr f) s))))))"
+"(less-than?"
+"(lambda(a b)"
+"(if(symbol? a)"
+"(if(symbol? b)"
+"(symbol-less-than? a b)"
+" #t)"
+"(if(symbol? b)"
+" #f"
+"(symbol-less-than?(signature-name a)"
+"(signature-name b))))))"
+"(symbol-less-than?"
+"(lambda(a b)"
+"(string<?(symbol->string a)(symbol->string b)))))"
+"(let loop((elems elems))"
+"(cond"
+"((null? elems) null)"
+"((null?(cdr elems)) elems)"
+"(else(let-values(((f s)(split elems null null)))"
+"(merge(loop f)(loop s)))))))))"
+" "
+"(define flatten-signature"
+"(lambda(id sig)"
+"(apply"
+" append"
+"(map"
+"(lambda(elem)"
+"(if(symbol? elem)"
+"(list"
+"(if id"
+" (string->symbol (string-append id \":\" (symbol->string elem)))"
+" elem))"
+"(flatten-signature(let*((n(signature-name elem))"
+"(s(if n"
+"(symbol->string n)"
+" #f)))"
+"(if(and id s)"
+" (string-append id \":\" s)"
+"(or id s)))"
+" elem)))"
+"(signature-elems sig)))))"
+"(define flatten-signatures"
+"(lambda(sigs)"
+"(apply append(map(lambda(s) "
+"(let*((name(signature-name s))"
+"(id(if name"
+"(symbol->string name)"
+" #f)))"
+"(flatten-signature id s)))"
+" sigs))))"
+"(define define-signature"
+"(lambda body"
+"(let((expr(cons d-s body)))"
+"(unless(and(pair? body)"
+"(or(symbol?(car body))"
+" (syntax-error d-s expr \"signature name is not an identifier\"))"
+"(pair?(cdr body))"
+"(null?(cddr body)))"
+" (syntax-error d-s expr \"improper form\"))"
+"(let*((name(car body))"
+"(sig(get-sig d-s expr name(cadr body))))"
+"(result `(#%define-expansion-time ,name"
+"(#%quote ,(explode-sig sig))))))))"
+"(define let-signature"
+"(lambda body"
+"(let((expr(cons d-s body)))"
+"(unless(and(pair? body)"
+"(or(symbol?(car body))"
+" (syntax-error l-s expr \"signature name is not an identifier\"))"
+"(pair?(cdr body))"
+"(pair?(cddr body)))"
+" (syntax-error l-s expr \"improper form\"))"
+"(let*((name(car body))"
+"(sig(get-sig l-s expr name(cadr body))))"
+"(result `(#%let-expansion-time ,name"
+"(#%quote ,(explode-sig sig))"
+" ,@(cddr body)))))))"
+"(define signature-parts"
+"(lambda(q?)"
+"(lambda(sig)"
+"(let loop((elems(signature-elems sig)))"
+"(cond"
+"((null? elems) null)"
+"((q?(car elems))(cons(car elems)(loop(cdr elems))))"
+"(else(loop(cdr elems))))))))"
+"(define signature-vars(signature-parts symbol?))"
+"(define signature-subsigs(signature-parts signature?))"
+"(define do-rename"
+"(lambda(export-name renames)"
+"(let loop((renames renames))"
+"(cond"
+"((null? renames) export-name)"
+"((eq?(cadar renames) export-name)"
+"(caar renames))"
+"(else(loop(cdr renames)))))))"
+"(define check-signature-unit-body"
+"(lambda(sig a-unit renames who expr)"
+"(let((vars(parse-unit-vars a-unit)))"
+"(for-each"
+"(lambda(var)"
+"(let((renamed(do-rename var renames)))"
+"(unless(memq renamed vars)"
+"(syntax-error who expr"
+"(format "
+" \"signature \\\"~s\\\" requires variable \\\"~s\\\"~a\""
+"(signature-src sig)"
+" var"
+"(if(eq? var renamed)"
+" \"\""
+" (format \" renamed \\\"~s\\\"\" renamed)))))))"
+"(signature-vars sig))"
+"(unless(null?(signature-subsigs sig))"
+"(syntax-error who expr"
+"(format "
+" \"signature \\\"~s\\\" requires sub-units\""
+"(signature-src sig)))))))"
+"(define parse-imports"
+"(lambda(who untagged-legal? really-import? expr clause)"
+"(let((bad"
+"(lambda(why . rest)"
+"(apply"
+" syntax-error who expr "
+"(format(if really-import?"
+" \"bad `import' clause~a\" "
+" \"bad linkage specification~a\")"
+" why)"
+" rest))))"
+"(unless(and(list? clause)"
+"(andmap"
+"(lambda(item)"
+"(or(and(symbol? item)"
+" untagged-legal?)"
+"(and"
+"(or(list? item)"
+" (bad \": bad item\" item))"
+"(or(and(or(null? item) "
+"(null?(cdr item))"
+"(not(eq? ':(cadr item))))"
+" untagged-legal?)"
+"(and(=(length item) 3)"
+"(eq? ':(cadr item)))"
+" (bad \": bad item\" item)))))"
+" clause))"
+" (bad \"\"))"
+"(map"
+"(lambda(item)"
+"(if(or(symbol? item)"
+"(not(and(= 3(length item))"
+"(eq?(cadr item) ':))))"
+"(rename-signature(get-sig who expr #f item) #f)"
+"(get-sig who expr(car item)(caddr item))))"
+" clause))))"
+"(define parse-unit"
+"(lambda(expr body)"
+"(unless(and(pair? body)"
+"(pair?(car body))"
+"(eq? 'import(caar body)))"
+"(syntax-error unit/sig expr "
+" \"expected `import' clause\"))"
+"(let*((imports(parse-imports unit/sig #t #t expr(cdar body)))"
+"(body(cdr body)))"
+"(let-values(((renames body)"
+"(if(and(pair? body)"
+"(pair?(car body))"
+"(eq? 'rename(caar body)))"
+"(values(cdr(car body))(cdr body))"
+"(values null body))))"
+"(let((bad"
+"(lambda(why sub)"
+"(syntax-error unit/sig expr "
+" (format \"bad `rename' clause~a\" why)"
+" sub))))"
+"(for-each"
+"(lambda(id)"
+"(unless(and(pair? id) "
+"(pair?(cdr id)) "
+"(null?(cddr id))"
+"(or(symbol?(car id))"
+" (bad \": source is not an identifier\" id))"
+"(or(symbol?(cadr id))"
+" (bad \": destination is not an identifier\" id)))"
+" (bad \"\" id)))"
+" renames))"
+"(check-unique(map car renames)"
+"(lambda(name)"
+"(syntax-error unit/sig expr"
+" (format \"id \\\"~s\\\" renamed twice\" name))))"
+"(let loop((lines body)(ports null)(body null)(vars null))"
+"(cond"
+"((and(null? ports)(null? lines))"
+"(make-parse-unit imports renames vars body))"
+"((and(null? ports)(not(pair? lines)))"
+" (syntax-error unit/sig expr \"improper body list form\"))"
+"(else"
+"(let-values(((line line-kind)(local-expand-body-expression"
+"(if(null? ports)"
+"(car lines)"
+"(read(car ports)))))"
+"((rest-lines)(if(null? ports)"
+"(cdr lines)"
+" lines)))"
+"(cond"
+"((and(eof-object? line)(not(null? ports)))"
+"(values lines body vars))"
+"((eq? line-kind '#%define-values)"
+"(unless(and(pair?(cdr line))"
+"(list?(cadr line))"
+"(pair?(cddr line))"
+"(null?(cdddr line))"
+"(andmap symbol?(cadr line)))"
+"(syntax-error unit/sig expr "
+" \"improper `define-values' clause form\""
+" line))"
+"(let((names(cadr line)))"
+"(loop rest-lines"
+" ports"
+"(cons line body)"
+"(append names vars))))"
+"((eq? line-kind '#%begin)"
+"(unless(and(pair?(cdr line))"
+"(list?(cdr line)))"
+"(syntax-error unit/sig expr "
+" \"improper `begin' clause form\""
+" line))"
+"(loop(append(cdr line) rest-lines)"
+" ports"
+" body"
+" vars))"
+"((and(pair? line)"
+"(eq?(car line) 'include))"
+"(let((line(local-expand-defmacro line)))"
+"(unless(and(pair?(cdr line))"
+"(string?(cadr line))"
+"(null?(cddr line)))"
+"(syntax-error unit/sig expr "
+" \"improper `include' clause form\""
+" line))"
+"(let((file(cadr line)))"
+"(let-values(((base name dir?)(split-path file)))"
+"(when dir?"
+"(syntax-error unit/sig expr "
+" (format \"cannot include a directory ~s\""
+" file)))"
+"(let*((old-dir(current-load-relative-directory))"
+"(p(open-input-file(if(and old-dir(not(complete-path? file)))"
+"(path->complete-path file old-dir)"
+" file))))"
+"(let-values(((lines body vars)"
+"(parameterize((current-load-relative-directory"
+"(if(string? base) "
+"(if(complete-path? base)"
+" base"
+"(path->complete-path base"
+"(if old-dir "
+" old-dir "
+"(current-directory))))"
+"(current-directory))))"
+"(dynamic-wind"
+" void"
+"(lambda()"
+"(loop rest-lines"
+"(cons p ports)"
+" body"
+" vars))"
+"(lambda()"
+"(close-input-port p))))))"
+"(loop lines ports body vars)))))))"
+"(else"
+"(loop rest-lines"
+" ports"
+"(cons line body)"
+" vars)))))))))))"
+"(define unit-with-signature"
+"(lambda body"
+"(let((expr(cons unit/sig body)))"
+"(unless(pair? body)"
+" (syntax-error unit/sig expr \"improper form\"))"
+"(let((sig(get-sig unit/sig expr #f(car body)))"
+"(rest(cdr body)))"
+"(let((a-unit(parse-unit expr rest)))"
+"(check-signature-unit-body sig a-unit(parse-unit-renames a-unit) unit/sig expr)"
+"(result"
+" `(#%make-unit-with-signature"
+"(#%unit"
+"(import ,@(flatten-signatures"
+"(parse-unit-imports a-unit)))"
+"(export ,@(map"
+"(lambda(name)"
+"(list(do-rename name(parse-unit-renames a-unit))"
+" name))"
+"(signature-vars sig)))"
+" ,@(reverse!(parse-unit-body a-unit)))"
+"(#%quote ,(explode-named-sigs(parse-unit-imports a-unit)))"
+"(#%quote ,(explode-sig sig)))))))))"
+"(define-struct link(name sig expr links))"
+"(define-struct sig-explode-pair(sigpart exploded))"
+"(define parse-compound-unit"
+"(lambda(expr body)"
+"(unless(and(pair? body)"
+"(pair?(car body))"
+"(eq? 'import(caar body)))"
+"(syntax-error cpd-unit/sig expr "
+" \"expected `import' clause\"))"
+"(let*((imports(parse-imports cpd-unit/sig #f #t expr(cdar body)))"
+"(body(cdr body)))"
+"(unless(and(pair? body)"
+"(pair?(car body))"
+"(eq? 'link(caar body)))"
+"(syntax-error cpd-unit/sig expr "
+" \"expectd `link' clause\"))"
+"(unless(list?(car body))"
+"(syntax-error cpd-unit/sig expr "
+" \"improper `link' clause form\"))"
+"(let*((bad"
+"(lambda(why sub)"
+"(syntax-error cpd-unit/sig expr "
+" (format \"bad `link' element~a\" why)"
+" sub)))"
+"(links"
+"(map"
+"(lambda(line)"
+"(unless(and(pair? line)"
+"(or(symbol?(car line))"
+" (bad \": link tag is not an identifier\" line))"
+"(or(and(pair?(cdr line))"
+"(eq?(cadr line) ':))"
+" (bad \": expected \\\":\\\"\" line))"
+"(or(pair?(cddr line))"
+" (bad \": expected signature\" line))"
+"(or(pair?(cdddr line))"
+" (bad \": expected unit expression and links\" line))"
+"(or(null?(cddddr line))"
+" (bad \": extra expressions in sub-clause\" line))"
+"(or(pair?(cadddr line))"
+" (bad \": unit expression and links not a sub-clause\" line))"
+"(or(list?(cdaddr(cdr line)))"
+" (bad \": unit expression and link sub-clause\" line)))"
+" (bad \"\" line))"
+"(make-link(car line) "
+"(get-sig cpd-unit/sig expr #f(caddr line))"
+"(caaddr(cdr line))"
+"(cdaddr(cdr line))))"
+"(cdar body)))"
+"(body(cdr body))"
+"(vars null)"
+"(in-sigs imports)"
+"(find-link"
+"(lambda(name links)"
+"(let loop((links links))"
+"(cond"
+"((null? links) #f)"
+"((eq? name(link-name(car links)))"
+"(car links))"
+"(else(loop(cdr links)))))))"
+"(find-sig"
+"(lambda(name sigs)"
+"(let loop((sigs sigs))"
+"(cond"
+"((null? sigs) #f)"
+"((and(signature?(car sigs))"
+"(eq? name(signature-name(car sigs))))"
+"(car sigs))"
+"(else(loop(cdr sigs)))))))"
+"(flatten-path"
+"(lambda(clause path var-k unit-k)"
+"(letrec((check-sig"
+"(lambda(sig use-sig)"
+"(when use-sig"
+"(with-handlers"
+"((exn:unit:signature?"
+"(lambda(exn)"
+"(syntax-error "
+" cpd-unit/sig expr"
+"(exn-message exn)))))"
+"(verify-signature-match"
+" cpd-unit/sig #f"
+" (format \"signature ~s\" (signature-src use-sig))"
+"(explode-sig use-sig)"
+" (format \"signature ~s\" (signature-src sig))"
+"(explode-sig sig))))))"
+"(flatten-subpath"
+"(lambda(base last use-sig name sig p)"
+"(cond"
+"((null? p) "
+"(check-sig sig use-sig)"
+"(unit-k base last name(if use-sig"
+" use-sig"
+" sig)))"
+"((or(not(pair? p))"
+"(not(symbol?(car p))))"
+"(syntax-error cpd-unit/sig expr"
+" (format \"bad `~a' path\" clause)"
+" path))"
+"((memq(car p)(signature-vars sig))"
+"(if(and(null?(cdr p))(not use-sig))"
+"(let*((id-nopath(car p))"
+"(id(if name"
+"(string->symbol "
+"(string-append name"
+" \":\""
+"(symbol->string id-nopath)))"
+" id-nopath)))"
+"(var-k base id id-nopath))"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"bad `~a' path: \\\"~a\\\" is a variable\" "
+" clause"
+"(car p))"
+" path)))"
+"((find-sig(car p)(signature-elems sig))"
+" =>"
+"(lambda(s)"
+"(flatten-subpath base"
+"(car p)"
+" use-sig"
+"(let((n(symbol->string "
+"(signature-name s))))"
+"(if name"
+" (string-append name \":\" n)"
+" n))"
+" s"
+"(cdr p))))"
+"(else"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"bad `~a' path: \\\"~a\\\" not found\""
+" clause"
+"(car p))"
+" path))))))"
+"(let-values(((p use-sig)"
+"(cond"
+"((symbol? path)"
+"(values(list path) #f))"
+"((and(pair? path)"
+"(symbol?(car path))"
+"(pair?(cdr path))"
+"(eq?(cadr path) ':)"
+"(pair?(cddr path))"
+"(null?(cdddr path)))"
+"(values(list(car path))"
+"(get-sig cpd-unit/sig expr"
+" #f"
+"(caddr path))))"
+"((and(pair? path)"
+"(list?(car path))"
+"(not(null?(car path)))"
+"(andmap"
+"(lambda(s)"
+"(and(symbol? s)"
+"(not(eq? s ':))))"
+"(car path))"
+"(pair?(cdr path))"
+"(eq?(cadr path) ':)"
+"(pair?(cddr path))"
+"(null?(cdddr path)))"
+"(values(car path)"
+"(get-sig cpd-unit/sig expr"
+" #f"
+"(caddr path))))"
+"((and(pair? path)"
+"(list? path)"
+"(not(null?(car path)))"
+"(andmap"
+"(lambda(s)"
+"(and(symbol? s)"
+"(not(eq? s ':))))"
+" path))"
+"(values path #f))"
+"(else"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"bad `~a' path\""
+" clause)"
+" path)))))"
+"(cond"
+"((and(null?(cdr p))"
+"(memq(car p) vars))"
+"(let((id(car p)))"
+"(var-k #f id id)))"
+"((find-link(car p) links)"
+" =>(lambda(link) "
+"(flatten-subpath(link-name link)"
+"(car p)"
+" use-sig"
+" #f"
+"(link-sig link)"
+"(cdr p))))"
+"((find-sig(car p) in-sigs)"
+" =>(lambda(sig) "
+"(let((s(symbol->string(signature-name sig))))"
+"(flatten-subpath #f"
+"(car p)"
+" use-sig"
+" s"
+" sig"
+"(cdr p)))))"
+"(else"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"bad `~a' path: \\\"~a\\\" not found\""
+" clause"
+"(car p))"
+" path))))))))"
+"(check-unique(map link-name links)"
+"(lambda(name)"
+"(syntax-error cpd-unit/sig expr"
+" (format \"duplicate sub-unit tag \\\"~s\\\"\" name))))"
+"(check-unique(append(map signature-name imports)"
+"(map link-name links))"
+"(lambda(name)"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"name \\\"~s\\\" is both import and sub-unit identifier\" "
+" name))))"
+"(for-each"
+"(lambda(link)"
+"(set-link-links! "
+" link"
+"(map"
+"(lambda(link)"
+"(flatten-path 'link link"
+"(lambda(base var var-nopath)"
+"(make-sig-explode-pair"
+" var"
+"(list"
+"(if base"
+"(list base var)"
+" var))))"
+"(lambda(base last id sig)"
+"(make-sig-explode-pair"
+"(rename-signature sig last)"
+"(if base"
+"(list(cons base(flatten-signature id sig)))"
+"(flatten-signature id sig))))))"
+"(link-links link))))"
+" links)"
+"(unless(and(pair? body)"
+"(pair?(car body))"
+"(eq? 'export(caar body)))"
+" (syntax-error cpd-unit/sig expr \"expected `export' clause\"))"
+"(unless(list?(car body))"
+"(syntax-error cpd-unit/sig expr "
+" \"bad `export' clause form\"))"
+"(unless(null?(cdr body))"
+"(syntax-error cpd-unit/sig expr "
+" \"another clause follows `export' clause\"))"
+"(let*((upath?(lambda(p)"
+"(or(symbol? p)"
+"(and(list? p)"
+"(andmap symbol? p)))))"
+"(exports "
+"(map"
+"(lambda(export)"
+"(cond"
+"((or(not(list? export))"
+"(not(<= 2(length export) 3))"
+"(not(or(null?(cddr export))"
+"(and(pair?(cddr export))"
+"(null?(cdddr export))))))"
+" (syntax-error cpd-unit/sig expr \"bad `export' sub-clause\""
+" export))"
+"(else"
+"(cond"
+"((eq?(car export) 'open)"
+"(let((odef(cdr export)))"
+"(unless(and(pair? odef)"
+"(upath?(car odef))"
+"(null?(cdr odef)))"
+"(syntax-error cpd-unit/sig expr "
+" \"bad `open' sub-clause of `export'\""
+" export))"
+"(flatten-path 'export"
+"(car odef)"
+"(lambda(base var var-nopath)"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"`open' sub-clause path is a variable\""
+"(car export)))"
+"(lambda(base last name sig)"
+"(if base"
+"(make-sig-explode-pair"
+"(signature-elems sig)"
+"(cons base "
+"(map"
+" list"
+"(flatten-signature name sig)"
+"(flatten-signature #f sig))))"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"cannot export imported variables\""
+" export))))))"
+"((eq?(car export) 'var)"
+"(let((vdef(cdr export)))"
+"(unless(and(pair? vdef)"
+"(pair?(car vdef))"
+"(upath?(caar vdef))"
+"(pair?(cdar vdef))"
+"(null?(cddar vdef))"
+"(symbol?(cadar vdef))"
+"(or(null?(cdr vdef))"
+"(and(pair?(cdr vdef))"
+"(symbol?(cadr vdef))"
+"(null?(cddr vdef)))))"
+"(syntax-error cpd-unit/sig expr "
+" \"bad `var' sub-clause of `export'\""
+" export))"
+"(flatten-path 'export"
+"(let((upath(caar vdef))"
+"(vname(cadar vdef)))"
+"(if(symbol? upath)"
+"(list upath vname)"
+"(append upath(list vname))))"
+"(lambda(base var var-nopath)"
+"(if base"
+"(make-sig-explode-pair"
+"(list(if(null?(cdr vdef))"
+" var-nopath"
+"(cadr vdef)))"
+"(list base"
+"(if(null?(cdr vdef))"
+"(list var var-nopath)"
+"(list var(cadr vdef)))))"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"cannot exported imported variables\""
+"(car export))))"
+"(lambda(base last name var)"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"`var' sub-clause path specifies a unit\""
+" export)))))"
+"((eq?(car export) 'unit)"
+"(let((udef(cdr export)))"
+"(unless(and(pair? udef)"
+"(upath?(car udef))"
+"(or(null?(cdr udef))"
+"(and(pair?(cdr udef))"
+"(symbol?(cadr udef))"
+"(null?(cddr udef)))))"
+"(syntax-error cpd-unit/sig expr "
+" \"bad `unit' sub-clause of `export'\""
+" export))"
+"(flatten-path 'export"
+"(car udef)"
+"(lambda(base var var-nopath)"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"`unit' sub-clause path is a variable\""
+"(car export)))"
+"(lambda(base last name sig)"
+"(if base"
+"(make-sig-explode-pair"
+"(list(rename-signature"
+" sig"
+"(if(null?(cdr udef))"
+" last"
+"(cadr udef))))"
+"(let((flat(flatten-signature name sig)))"
+"(cons base "
+"(map"
+" list"
+" flat"
+"(flatten-signature "
+"(symbol->string(if(null?(cdr udef))"
+" last"
+"(cadr udef)))"
+" sig)))))"
+"(syntax-error "
+" cpd-unit/sig expr "
+" \"cannot exported imported variables\""
+" export))))))"
+"(else"
+"(syntax-error cpd-unit/sig expr "
+"(format "
+" \"bad `export' sub-clause\")"
+" export))))))"
+"(cdar body))))"
+"(check-unique(map"
+"(lambda(s)"
+"(if(signature? s)"
+"(signature-name s)"
+" s))"
+"(apply"
+" append"
+"(map sig-explode-pair-sigpart exports)))"
+"(lambda(name)"
+"(syntax-error cpd-unit/sig expr"
+"(format "
+" \"the name \\\"~s\\\" is exported twice\" "
+" name))))"
+" `(#%let ,(map"
+"(lambda(link)"
+"(list(link-name link)"
+"(link-expr link)))"
+" links)"
+"(#%verify-linkage-signature-match"
+"(#%quote ,cpd-unit/sig)"
+"(#%quote ,(map link-name links))"
+"(#%list ,@(map link-name links))"
+"(#%quote ,(map(lambda(link)(explode-sig(link-sig link))) links))"
+"(#%quote ,(map"
+"(lambda(link)"
+"(map(lambda(sep)"
+"(explode-named-sig(sig-explode-pair-sigpart sep)))"
+"(link-links link)))"
+" links)))"
+"(#%make-unit-with-signature"
+"(#%compound-unit"
+"(import ,@(flatten-signatures"
+" imports))"
+"(link ,@(map"
+"(lambda(link)"
+"(list(link-name link)"
+"(cons `(#%unit-with-signature-unit"
+" ,(link-name link))"
+"(apply"
+" append"
+"(map "
+" sig-explode-pair-exploded "
+"(link-links link))))))"
+" links))"
+"(export ,@(map sig-explode-pair-exploded exports)))"
+"(#%quote ,(explode-named-sigs imports))"
+"(#%quote ,(explode-sig"
+"(make-signature"
+" 'dummy"
+" 'dummy"
+" #f"
+"(apply"
+" append"
+"(map sig-explode-pair-sigpart exports))))))))))))"
+" "
+"(define compound-unit-with-signature"
+"(lambda body"
+"(let((expr(cons cpd-unit/sig body)))"
+"(result(parse-compound-unit expr body)))))"
+"(define parse-invoke-vars"
+"(lambda(who rest expr)"
+"(parse-imports who #t #f expr rest)))"
+"(define build-invoke-unit"
+"(lambda(who invoke-unit u sigs nsl)"
+"(result `(let((u ,u))"
+"(#%verify-linkage-signature-match"
+"(#%quote ,who)"
+"(#%quote(invoke))"
+"(#%list u)"
+"(#%quote(#()))"
+"(#%quote(,(explode-named-sigs sigs))))"
+"(,invoke-unit(#%unit-with-signature-unit u)"
+" ,@nsl"
+" ,@(flatten-signatures"
+" sigs))))))"
+"(define invoke-unit-with-signature"
+"(lambda body"
+"(let((expr(cons invoke-unit/sig body)))"
+"(unless(and(pair? body)"
+"(list?(cdr body)))"
+" (syntax-error invoke-unit/sig expr \"improper form\"))"
+"(let((u(car body))"
+"(sigs(parse-invoke-vars invoke-unit/sig(cdr body) expr)))"
+"(build-invoke-unit invoke-unit/sig '#%invoke-unit u sigs null)))))"
+"(define invoke-open-unit-with-signature"
+"(lambda body"
+"(let((expr(cons invoke-open-unit/sig body)))"
+"(unless(and(pair? body)"
+"(or(null?(cdr body)) "
+"(and(pair?(cdr body))"
+"(list?(cddr body)))))"
+" (syntax-error invoke-open-unit/sig expr \"improper form\"))"
+"(if(null?(cdr body))"
+"(build-invoke-unit invoke-open-unit/sig '#%invoke-open-unit(car body) null null)"
+"(let((u(car body))"
+"(ns(cadr body))"
+"(sigs(parse-invoke-vars invoke-open-unit/sig(cddr body) expr)))"
+"(build-invoke-unit invoke-open-unit/sig '#%invoke-open-unit u sigs(list ns)))))))"
+"(define unit->unit-with-signature"
+"(lambda body"
+"(let((expr(cons u->u/sig body)))"
+"(unless(and(pair? body)"
+"(pair?(cdr body))"
+"(list?(cadr body))"
+"(pair?(cddr body))"
+"(null?(cdddr body)))"
+" (syntax-error u->u/sig expr \"improper form\"))"
+"(let((e(car body))"
+"(im-sigs(map(lambda(sig)"
+"(get-sig u->u/sig expr #f sig))"
+"(cadr body)))"
+"(ex-sig(get-sig u->u/sig expr #f(caddr body))))"
+" `(#%make-unit-with-signature"
+" ,e"
+"(#%quote ,(explode-named-sigs im-sigs))"
+"(#%quote ,(explode-sig ex-sig)))))))"
+"(vector define-signature"
+" let-signature"
+" unit-with-signature"
+" compound-unit-with-signature"
+" invoke-unit-with-signature"
+" invoke-open-unit-with-signature"
+" unit->unit-with-signature)))"
+);
+  JUST_DEFINED(unitsig);
diff --git a/src/mzscheme/src/unitsig.ss b/src/mzscheme/src/unitsig.ss
new file mode 100644
index 0000000..5aac117
--- /dev/null
+++ b/src/mzscheme/src/unitsig.ss
@@ -0,0 +1,1085 @@
+
+(invoke-unit
+ (unit
+  (import)
+  (export)
+  
+  ; Parse-time structs:
+  (define-struct signature (name src global-src elems))
+  (define-struct parse-unit (imports renames vars body))
+  
+  (define d-s 'define-signature)
+  (define l-s 'let-signature)
+  (define unit/sig 'unit/sig)
+  (define u->u/sig 'unit->unit/sig)
+  (define cpd-unit/sig 'compound-unit/sig)
+  (define invoke-unit/sig 'invoke-unit/sig)
+  (define invoke-open-unit/sig 'invoke-open-unit/sig)
+
+  (define inline-sig-name '<unnamed>)
+
+  (define (result x) x)
+
+  (define syntax-error
+    (case-lambda 
+     [(who expr msg sub)
+      (raise-syntax-error who msg expr sub)]
+     [(who expr msg)
+      (raise-syntax-error who msg expr)]))
+
+  (define undef-sig-error
+    (lambda (who expr what)
+      (syntax-error who expr 
+		    (format "signature \"~s\" not defined" what))))
+
+  (define not-a-sig-error
+    (lambda (who expr what)
+      (syntax-error who expr 
+		    (format "\"~s\" is not a signature" what))))
+
+  (define rename-signature
+    (lambda (sig name)
+      (make-signature name 
+		      (signature-src sig) 
+		      (signature-global-src sig) 
+		      (signature-elems sig))))
+
+  (define intern-signature
+    (lambda (name desc global-name error)
+      (make-signature
+       name
+       name
+       global-name
+       (if (vector? desc)
+	   (map
+	    (lambda (elem)
+	      (cond
+	       [(symbol? elem) elem]
+	       [(and (pair? elem) (symbol? (car elem)))
+		(intern-signature (car elem) (cdr elem) #f error)]
+	       [else (error)]))
+	    (vector->list desc))
+	   (error)))))
+
+  (define get-sig
+    (lambda (who expr name sigid)
+      (if (not (symbol? sigid))
+	  (parse-signature who expr 
+			   (if name
+			       name
+			       inline-sig-name)
+			   sigid)
+	  (let ([v (with-handlers
+		    ([void (lambda (x) (undef-sig-error who expr sigid))])
+		    (local-expansion-time-value sigid))]
+		[gv (with-handlers
+		     ([void (lambda (x) #f)])
+		     (global-expansion-time-value sigid))])
+	    (let ([s (intern-signature sigid v
+				       (and (eq? v gv) sigid)
+				       (lambda ()
+					 (not-a-sig-error who expr sigid)))])
+	      (if name
+		  (rename-signature s name)
+		  s))))))
+
+  (define check-unique
+    (lambda (names error-k)
+      (cond
+       [(null? names) (void)]
+       [(memq (car names) (cdr names))
+	(error-k (car names))]
+       [else (check-unique (cdr names) error-k)])))
+
+  (define build-struct-names
+    (lambda (name fields omit-sel? omit-set?)
+      (let ([name (symbol->string name)]
+	    [fields (map symbol->string fields)]
+	    [+ string-append])
+	(map string->symbol
+	     (append
+	      (list 
+	       (+ "make-" name)
+	       (+ name "?")
+	       (+ "struct:" name))
+	      (if omit-sel?
+		  null
+		  (map
+		   (lambda (f)
+		     (+ name "-" f))
+		   fields))
+	      (if omit-set?
+		  null
+		  (map
+		   (lambda (f)
+		     (+ "set-" name "-" f "!"))
+		   fields)))))))
+
+  (define parse-signature
+    (lambda (who expr name body)
+      (let ([elems
+	     (let loop ([body body])
+	       (cond
+		[(null? body) null]
+		[(not (pair? body))
+		 (syntax-error who expr "improper signature list form")]
+		[else
+		 (let ([first (car body)]
+		       [k (lambda () (loop (cdr body)))])
+		   (cond
+		    [(and (symbol? first) (not (eq? first ':))) (cons first (k))]
+		    [(or (not (pair? first))
+			 (not (list? first))) 
+		     (syntax-error who expr "improper signature clause form" first)]
+		    [(eq? (car first) 'struct)
+		     (let ([sdef (cdr first)]
+			   [bad
+			    (lambda (why)
+			      (syntax-error who expr 
+					    (format "improper `struct' clause form~a"
+						    why)
+					    first))])
+		       (unless (and (<= 2 (length sdef))
+				    (or (symbol? (car sdef))
+					(bad ": struct name not an identifier"))
+				    (list? (cadr sdef))
+				    (andmap (lambda (s)
+					      (or (symbol? s)
+						  (bad ": field name not an identifier")))
+					    (cadr sdef))
+				    (or (= (length sdef) 2)
+					(andmap
+					 (lambda (omit)
+					   (or (eq? omit '-selectors)
+					       (eq? omit '-setters)
+					       (and (pair? omit)
+						    (eq? (car omit) '-)
+						    (pair? (cdr omit))
+						    (symbol? (cadr omit))
+						    (null? (cddr omit)))
+					       (bad ": bad omission specifier")))
+					 (cddr sdef))))
+			       (bad ""))
+		       (let ([name (car sdef)]
+			     [fields (cadr sdef)]
+			     [omit-names
+			      (let loop ([l (cddr sdef)])
+				(cond
+				 [(null? l) null]
+				 [(pair? (car l)) (cons (cadar l) (loop (cdr l)))]
+				 [else (loop (cdr l))]))]
+			     [omit-setters? (memq '-setters (cddr sdef))]
+			     [omit-selectors? (memq '-selectors (cddr sdef))])
+			 (letrec ([names (build-struct-names 
+					  name fields 
+					  omit-selectors? omit-setters?)]
+				  [filter
+				   (lambda (names)
+				     (cond
+				      [(null? names) null]
+				      [(memq (car names) omit-names) (filter (cdr names))]
+				      [else (cons (car names) (filter (cdr names)))]))])
+			   
+			   (append (if (null? omit-names) names (filter names))
+				   (k)))))]
+		    [(eq? (car first) 'unit)
+		     (let ([udef (cdr first)]
+			   [bad
+			    (lambda (why)
+			      (syntax-error who expr 
+					    (format "improper `unit' clause form~a"
+						    why)
+					    first))])
+		       (unless (and (= 3 (length udef))
+				    (or (symbol? (car udef))
+					(bad ": unit name not an identifier"))
+				    (eq? ': (cadr udef)))
+			       (bad ""))
+		       (let ([s (get-sig who expr (car udef) (caddr udef))])
+			 (cons s (k))))]
+		    [(eq? (car first) 'open)
+		     (let ([odef (cdr first)])
+		       (unless (and (pair? odef)
+				    (null? (cdr odef)))
+			       (syntax-error who expr 
+					     "improper `open' clause form"))
+		       (let ([s (get-sig who expr #f (car odef))])
+			 (append (signature-elems s) (k))))]
+		    [else
+		     (syntax-error who expr "improper signature clause type" first)]))]))])
+	(check-unique (map
+		       (lambda (elem)
+			 (if (symbol? elem)
+			     elem
+			     (signature-name elem)))
+		       elems)
+		      (lambda (name)
+			(syntax-error who expr
+				      (format "duplicate name \"~s\" in signature"
+					      name))))
+	  (make-signature name name #f (sort-signature-elems elems)))))
+
+  (define explode-sig
+    (lambda (sig)
+      (list->vector
+       (map 
+	(lambda (v)
+	  (if (symbol? v)
+	      v
+	      (cons
+	       (signature-name v)
+	       (explode-sig v))))
+	(signature-elems sig)))))
+
+  (define explode-named-sig
+    (lambda (s)
+      (cons
+       (cond
+	[(signature-name s)]
+	[(signature-src s)]
+	[else inline-sig-name])
+       (explode-sig s))))
+
+  (define explode-named-sigs
+    (lambda (sigs)
+      (map explode-named-sig sigs)))
+
+  (define sort-signature-elems
+    (lambda (elems)
+      (letrec ([split
+		(lambda (l f s)
+		  (cond
+		   [(null? l) (values f s)]
+		   [(null? (cdr l)) (values (cons (car l) f) s)]
+		   [else (split (cddr l) (cons (car l) f) (cons (cadr l) s))]))]
+	       [merge
+		(lambda (f s)
+		  (cond
+		   [(null? f) s]
+		   [(null? s) f]
+		   [(less-than? (car s) (car f))
+		    (cons (car s) (merge f (cdr s)))]
+		   [else
+		    (cons (car f) (merge (cdr f) s))]))]
+	       [less-than?
+		(lambda (a b)
+		  (if (symbol? a)
+		      (if (symbol? b)
+			  (symbol-less-than? a b)
+			  #t)
+		      (if (symbol? b)
+			  #f
+			  (symbol-less-than? (signature-name a)
+					     (signature-name b)))))]
+	       [symbol-less-than?
+		(lambda (a b)
+		  (string<? (symbol->string a) (symbol->string b)))])
+	(let loop ([elems elems])
+	  (cond
+	   [(null? elems) null]
+	   [(null? (cdr elems)) elems]
+	   [else (let-values ([(f s) (split elems null null)])
+		    (merge (loop f) (loop s)))])))))
+		   
+  (define flatten-signature
+    (lambda (id sig)
+      (apply
+       append
+       (map
+	(lambda (elem)
+	  (if (symbol? elem)
+	      (list
+	       (if id
+		   (string->symbol (string-append id ":" (symbol->string elem)))
+		   elem))
+	      (flatten-signature (let* ([n (signature-name elem)]
+					[s (if n
+					       (symbol->string n)
+					       #f)])
+				   (if (and id s)
+				       (string-append id ":" s)
+				       (or id s)))
+				 elem)))
+	(signature-elems sig)))))
+
+  (define flatten-signatures
+    (lambda (sigs)
+      (apply append (map (lambda (s) 
+			   (let* ([name (signature-name s)]
+				  [id (if name
+					  (symbol->string name)
+					  #f)])
+			     (flatten-signature id s)))
+			 sigs))))
+
+  (define define-signature
+    (lambda body
+      (let ([expr (cons d-s body)])
+	(unless (and (pair? body)
+		     (or (symbol? (car body))
+			 (syntax-error d-s expr "signature name is not an identifier"))
+		     (pair? (cdr body))
+		     (null? (cddr body)))
+		(syntax-error d-s expr "improper form"))
+	(let* ([name (car body)]
+	       [sig (get-sig d-s expr name (cadr body))])
+	  (result `(#%define-expansion-time ,name
+		      (#%quote ,(explode-sig sig))))))))
+  
+  (define let-signature
+    (lambda body
+      (let ([expr (cons d-s body)])
+	(unless (and (pair? body)
+		     (or (symbol? (car body))
+			 (syntax-error l-s expr "signature name is not an identifier"))
+		     (pair? (cdr body))
+		     (pair? (cddr body)))
+		(syntax-error l-s expr "improper form"))
+	(let* ([name (car body)]
+	       [sig (get-sig l-s expr name (cadr body))])
+	  (result `(#%let-expansion-time ,name
+		     (#%quote ,(explode-sig sig))
+		     ,@(cddr body)))))))
+  
+  (define signature-parts
+    (lambda (q?)
+      (lambda (sig)
+	(let loop ([elems (signature-elems sig)])
+	  (cond
+	   [(null? elems) null]
+	   [(q? (car elems)) (cons (car elems) (loop (cdr elems)))]
+	   [else (loop (cdr elems))])))))
+  (define signature-vars (signature-parts symbol?))
+  (define signature-subsigs (signature-parts signature?))
+
+  (define do-rename
+    (lambda (export-name renames)
+      (let loop ([renames renames])
+	(cond
+	 [(null? renames) export-name]
+	 [(eq? (cadar renames) export-name)
+	  (caar renames)]
+	 [else (loop (cdr renames))]))))
+      
+  (define check-signature-unit-body
+    (lambda (sig a-unit renames who expr)
+      (let ([vars (parse-unit-vars a-unit)])
+	(for-each
+	 (lambda (var)
+	   (let ([renamed (do-rename var renames)])
+	     (unless (memq renamed vars)
+		     (syntax-error who expr
+				   (format 
+				    "signature \"~s\" requires variable \"~s\"~a"
+				    (signature-src sig)
+				    var
+				    (if (eq? var renamed)
+					""
+					(format " renamed \"~s\"" renamed)))))))
+	 (signature-vars sig))
+	(unless (null? (signature-subsigs sig))
+		(syntax-error who expr
+			      (format 
+			       "signature \"~s\" requires sub-units"
+			       (signature-src sig)))))))
+
+  (define parse-imports
+    (lambda (who untagged-legal? really-import? expr clause)
+      (let ([bad
+	     (lambda (why . rest)
+	       (apply
+		syntax-error who expr 
+		(format (if really-import?
+			    "bad `import' clause~a" 
+			    "bad linkage specification~a")
+			why)
+		rest))])
+	(unless (and (list? clause)
+		     (andmap
+		      (lambda (item)
+			(or (and (symbol? item)
+				 untagged-legal?)
+			    (and
+			     (or (list? item)
+				 (bad ": bad item" item))
+			     (or (and (or (null? item) 
+					  (null? (cdr item))
+					  (not (eq? ': (cadr item))))
+				      untagged-legal?)
+				 (and (= (length item) 3)
+				      (eq? ': (cadr item)))
+				 (bad ": bad item" item)))))
+		      clause))
+		(bad ""))
+	(map
+	 (lambda (item)
+	   (if (or (symbol? item)
+		   (not (and (= 3 (length item))
+			     (eq? (cadr item) ':))))
+	       (rename-signature (get-sig who expr #f item) #f)
+	       (get-sig who expr (car item) (caddr item))))
+	 clause))))
+
+  (define parse-unit
+    (lambda (expr body)
+      (unless (and (pair? body)
+		   (pair? (car body))
+		   (eq? 'import (caar body)))
+	      (syntax-error unit/sig expr 
+			    "expected `import' clause"))
+      (let* ([imports (parse-imports unit/sig #t #t expr (cdar body))]
+	     [body (cdr body)])
+	(let-values ([(renames body)
+		      (if (and (pair? body)
+			       (pair? (car body))
+			       (eq? 'rename (caar body)))
+			  (values (cdr (car body)) (cdr body))
+			  (values null body))])
+	     (let ([bad
+		    (lambda (why sub)
+		      (syntax-error unit/sig expr 
+				    (format "bad `rename' clause~a" why)
+				    sub))])
+	       (for-each
+		(lambda (id)
+		  (unless (and (pair? id) 
+			       (pair? (cdr id)) 
+			       (null? (cddr id))
+			       (or (symbol? (car id))
+				   (bad ": source is not an identifier" id))
+			       (or (symbol? (cadr id))
+				   (bad ": destination is not an identifier" id)))
+			  (bad "" id)))
+		renames))
+	     (check-unique (map car renames)
+			   (lambda (name)
+			     (syntax-error unit/sig expr
+					   (format "id \"~s\" renamed twice" name))))
+	     (let loop ([lines body][ports null][body null][vars null])
+	       (cond
+		[(and (null? ports) (null? lines))
+		 (make-parse-unit imports renames vars body)]
+		[(and (null? ports) (not (pair? lines)))
+		 (syntax-error unit/sig expr "improper body list form")]
+		[else
+		 (let-values ([(line line-kind) (local-expand-body-expression
+						 (if (null? ports)
+						     (car lines)
+						     (read (car ports))))]
+			      [(rest-lines) (if (null? ports)
+						(cdr lines)
+						lines)])
+		   (cond
+		    [(and (eof-object? line) (not (null? ports)))
+		     (values lines body vars)]
+		    [(eq? line-kind '#%define-values)
+		     (unless (and (pair? (cdr line))
+				  (list? (cadr line))
+				  (pair? (cddr line))
+				  (null? (cdddr line))
+				  (andmap symbol? (cadr line)))
+			     (syntax-error unit/sig expr 
+					   "improper `define-values' clause form"
+					   line))
+		     (let ([names (cadr line)])
+		       (loop rest-lines
+			     ports
+			     (cons line body)
+			     (append names vars)))]
+		    [(eq? line-kind '#%begin)
+		     (unless (and (pair? (cdr line))
+				  (list? (cdr line)))
+			     (syntax-error unit/sig expr 
+					   "improper `begin' clause form"
+					   line))
+		     (loop (append (cdr line) rest-lines)
+			   ports
+			   body
+			   vars)]
+		    [(and (pair? line)
+			  (eq? (car line) 'include))
+		     (let ([line (local-expand-defmacro line)])
+		       (unless (and (pair? (cdr line))
+				    (string? (cadr line))
+				    (null? (cddr line)))
+			       (syntax-error unit/sig expr 
+					     "improper `include' clause form"
+					     line))
+		       (let ([file (cadr line)])
+			 (let-values ([(base name dir?) (split-path file)])
+		           (when dir?
+				 (syntax-error unit/sig expr 
+					       (format "cannot include a directory ~s"
+						       file)))
+			   (let* ([old-dir (current-load-relative-directory)]
+				  [p (open-input-file (if (and old-dir (not (complete-path? file)))
+							  (path->complete-path file old-dir)
+							  file))])
+			     (let-values ([(lines body vars)
+					   (parameterize ([current-load-relative-directory
+							   (if (string? base) 
+							       (if (complete-path? base)
+								   base
+								   (path->complete-path base
+											(if old-dir 
+											    old-dir 
+											    (current-directory))))
+							       (current-directory))])
+					       (dynamic-wind
+						void
+						(lambda ()
+						  (loop rest-lines
+							(cons p ports)
+							body
+							vars))
+						(lambda ()
+						  (close-input-port p))))])
+				(loop lines ports body vars))))))]
+		    [else
+		     (loop rest-lines
+			   ports
+			   (cons line body)
+			   vars)]))]))))))
+  
+  
+  (define unit-with-signature
+    (lambda body
+      (let ([expr (cons unit/sig body)])
+	(unless (pair? body)
+		(syntax-error unit/sig expr "improper form"))
+	(let ([sig (get-sig unit/sig expr #f (car body))]
+	      [rest (cdr body)])
+	  (let ([a-unit (parse-unit expr rest)])
+	    (check-signature-unit-body sig a-unit (parse-unit-renames a-unit) unit/sig expr)
+	    (result
+	     `(#%make-unit-with-signature
+	       (#%unit
+		(import ,@(flatten-signatures
+			   (parse-unit-imports a-unit)))
+		(export ,@(map
+			   (lambda (name)
+			     (list (do-rename name (parse-unit-renames a-unit))
+				   name))
+			   (signature-vars sig)))
+		,@(reverse! (parse-unit-body a-unit)))
+	       (#%quote ,(explode-named-sigs (parse-unit-imports a-unit)))
+	       (#%quote ,(explode-sig sig)))))))))
+  
+  (define-struct link (name sig expr links))
+  (define-struct sig-explode-pair (sigpart exploded))
+
+  (define parse-compound-unit
+    (lambda (expr body)
+      (unless (and (pair? body)
+		   (pair? (car body))
+		   (eq? 'import (caar body)))
+	      (syntax-error cpd-unit/sig expr 
+			    "expected `import' clause"))
+      (let* ([imports (parse-imports cpd-unit/sig #f #t expr (cdar body))]
+	     [body (cdr body)])
+	(unless (and (pair? body)
+		     (pair? (car body))
+		     (eq? 'link (caar body)))
+		(syntax-error cpd-unit/sig expr 
+			      "expectd `link' clause"))
+	(unless (list? (car body))
+		(syntax-error cpd-unit/sig expr 
+			      "improper `link' clause form"))
+	(let* ([bad
+		(lambda (why sub)
+		  (syntax-error cpd-unit/sig expr 
+				(format "bad `link' element~a" why)
+				sub))]
+	       [links
+		(map
+		 (lambda (line)
+		   (unless (and (pair? line)
+				(or (symbol? (car line))
+				    (bad ": link tag is not an identifier" line))
+				(or (and (pair? (cdr line))
+					 (eq? (cadr line) ':))
+				    (bad ": expected \":\"" line))
+				(or (pair? (cddr line))
+				    (bad ": expected signature" line))
+				(or (pair? (cdddr line))
+				    (bad ": expected unit expression and links" line))
+				(or (null? (cddddr line))
+				    (bad ": extra expressions in sub-clause" line))
+				(or (pair? (cadddr line))
+				    (bad ": unit expression and links not a sub-clause" line))
+				(or (list? (cdaddr (cdr line)))
+				    (bad ": unit expression and link sub-clause" line)))
+			   (bad "" line))
+		   (make-link (car line) 
+			      (get-sig cpd-unit/sig expr #f (caddr line))
+			      (caaddr (cdr line))
+			      (cdaddr (cdr line))))
+		 (cdar body))]
+	       [body (cdr body)]
+	       [vars null]
+	       [in-sigs imports]
+	       [find-link
+		(lambda (name links)
+		  (let loop ([links links])
+		    (cond
+		     [(null? links) #f]
+		     [(eq? name (link-name (car links)))
+		      (car links)]
+		     [else (loop (cdr links))])))]
+	       [find-sig
+		(lambda (name sigs)
+		  (let loop ([sigs sigs])
+		    (cond
+		     [(null? sigs) #f]
+		     [(and (signature? (car sigs))
+			   (eq? name (signature-name (car sigs))))
+		      (car sigs)]
+		     [else (loop (cdr sigs))])))]
+	       [flatten-path
+		(lambda (clause path var-k unit-k)
+		  (letrec ([check-sig
+			    (lambda (sig use-sig)
+			      (when use-sig
+				    (with-handlers
+				     ([exn:unit:signature?
+				       (lambda (exn)
+					 (syntax-error 
+					  cpd-unit/sig expr
+					  (exn-message exn)))])
+				     (verify-signature-match
+				      cpd-unit/sig #f
+				      (format "signature ~s" (signature-src use-sig))
+				      (explode-sig use-sig)
+				      (format "signature ~s" (signature-src sig))
+				      (explode-sig sig)))))]
+			   [flatten-subpath
+			    (lambda (base last use-sig name sig p)
+			      (cond
+			       [(null? p) 
+				(check-sig sig use-sig)
+				(unit-k base last name (if use-sig
+							   use-sig
+							   sig))]
+			       [(or (not (pair? p))
+				    (not (symbol? (car p))))
+				(syntax-error cpd-unit/sig expr
+					      (format "bad `~a' path" clause)
+					      path)]
+			       [(memq (car p) (signature-vars sig))
+				(if (and (null? (cdr p)) (not use-sig))
+				    (let* ([id-nopath (car p)]
+					   [id (if name
+						   (string->symbol 
+						    (string-append name
+								   ":"
+								   (symbol->string id-nopath)))
+						   id-nopath)])
+				      (var-k base id id-nopath))
+				    (syntax-error cpd-unit/sig expr
+						  (format 
+						   "bad `~a' path: \"~a\" is a variable" 
+						   clause
+						   (car p))
+						  path))]
+			       [(find-sig (car p) (signature-elems sig))
+				=>
+				(lambda (s)
+				  (flatten-subpath base
+						   (car p)
+						   use-sig
+						   (let ([n (symbol->string 
+							     (signature-name s))])
+						     (if name
+							 (string-append name ":" n)
+							 n))
+						   s
+						   (cdr p)))]
+			       [else
+				(syntax-error cpd-unit/sig expr
+					      (format 
+					       "bad `~a' path: \"~a\" not found"
+					       clause
+					       (car p))
+					      path)]))])
+		    (let-values ([(p use-sig)
+				  (cond
+				   [(symbol? path)
+				    (values (list path) #f)]
+				   [(and (pair? path)
+					 (symbol? (car path))
+					 (pair? (cdr path))
+					 (eq? (cadr path) ':)
+					 (pair? (cddr path))
+					 (null? (cdddr path)))
+				    (values (list (car path))
+					    (get-sig cpd-unit/sig expr
+						     #f
+						     (caddr path)))]
+				   [(and (pair? path)
+					 (list? (car path))
+					 (not (null? (car path)))
+					 (andmap
+					  (lambda (s)
+					    (and (symbol? s)
+						 (not (eq? s ':))))
+					  (car path))
+					 (pair? (cdr path))
+					 (eq? (cadr path) ':)
+					 (pair? (cddr path))
+					 (null? (cdddr path)))
+				    (values (car path)
+					    (get-sig cpd-unit/sig expr
+						     #f
+						     (caddr path)))]
+				   [(and (pair? path)
+					 (list? path)
+					 (not (null? (car path)))
+					 (andmap
+					  (lambda (s)
+					    (and (symbol? s)
+						 (not (eq? s ':))))
+					  path))
+				    (values path #f)]
+				   [else
+				    (syntax-error cpd-unit/sig expr
+						  (format 
+						   "bad `~a' path"
+						   clause)
+						  path)])])
+		      (cond
+		       [(and (null? (cdr p))
+			     (memq (car p) vars))
+			(let ([id (car p)])
+			  (var-k #f id id))]
+		       [(find-link (car p) links)
+			=> (lambda (link) 
+			     (flatten-subpath (link-name link)
+					      (car p)
+					      use-sig
+					      #f
+					      (link-sig link)
+					      (cdr p)))]
+		       [(find-sig (car p) in-sigs)
+			=> (lambda (sig) 
+			     (let ([s (symbol->string (signature-name sig))])
+			       (flatten-subpath #f
+						(car p)
+						use-sig
+						s
+						sig
+						(cdr p))))]
+		       [else
+			(syntax-error cpd-unit/sig expr
+				      (format 
+				       "bad `~a' path: \"~a\" not found"
+				       clause
+				       (car p))
+				      path)]))))])
+	  (check-unique (map link-name links)
+			(lambda (name)
+			  (syntax-error cpd-unit/sig expr
+					(format "duplicate sub-unit tag \"~s\"" name))))
+	  (check-unique (append (map signature-name imports)
+				(map link-name links))
+			(lambda (name)
+			  (syntax-error cpd-unit/sig expr
+					(format 
+					 "name \"~s\" is both import and sub-unit identifier" 
+					 name))))
+	  ;; Expand `link' clause using signatures
+	  (for-each
+	   (lambda (link)
+	     (set-link-links! 
+	      link
+	      (map
+	       (lambda (link)
+		 (flatten-path 'link link
+			       (lambda (base var var-nopath)
+				 (make-sig-explode-pair
+				  var
+				  (list
+				   (if base
+				       (list base var)
+				       var))))
+			       (lambda (base last id sig)
+				 (make-sig-explode-pair
+				  (rename-signature sig last)
+				  (if base
+				      (list (cons base (flatten-signature id sig)))
+				      (flatten-signature id sig))))))
+	       (link-links link))))
+	   links)
+	  (unless (and (pair? body)
+		       (pair? (car body))
+		       (eq? 'export (caar body)))
+		  (syntax-error cpd-unit/sig expr "expected `export' clause"))
+	  (unless (list? (car body))
+		  (syntax-error cpd-unit/sig expr 
+				"bad `export' clause form"))
+	  (unless (null? (cdr body))
+		  (syntax-error cpd-unit/sig expr 
+				"another clause follows `export' clause"))
+	  (let* ([upath? (lambda (p)
+			   (or (symbol? p)
+			       (and (list? p)
+				    (andmap symbol? p))))]
+		 [exports 
+		  (map
+		   (lambda (export)
+		     (cond
+		      [(or (not (list? export))
+			   (not (<= 2 (length export) 3))
+			   (not (or (null? (cddr export))
+				    (and (pair? (cddr export))
+					 (null? (cdddr export))))))
+		       (syntax-error cpd-unit/sig expr "bad `export' sub-clause"
+				     export)]
+		      [else
+		       (cond
+			[(eq? (car export) 'open)
+			 (let ([odef (cdr export)])
+			   (unless (and (pair? odef)
+					(upath? (car odef))
+					(null? (cdr odef)))
+				   (syntax-error cpd-unit/sig expr 
+						 "bad `open' sub-clause of `export'"
+						 export))
+			   (flatten-path 'export
+					 (car odef)
+					 (lambda (base var var-nopath)
+					   (syntax-error 
+					    cpd-unit/sig expr 
+					    "`open' sub-clause path is a variable"
+					    (car export)))
+					 (lambda (base last name sig)
+					   (if base
+					       (make-sig-explode-pair
+						(signature-elems sig)
+						(cons base 
+						      (map
+						       list
+						       (flatten-signature name sig)
+						       (flatten-signature #f sig))))
+					       (syntax-error 
+						cpd-unit/sig expr 
+						"cannot export imported variables"
+						export)))))]
+			 [(eq? (car export) 'var)
+			  (let ([vdef (cdr export)])
+			    (unless (and (pair? vdef)
+					 (pair? (car vdef))
+					 (upath? (caar vdef))
+					 (pair? (cdar vdef))
+					 (null? (cddar vdef))
+					 (symbol? (cadar vdef))
+					 (or (null? (cdr vdef))
+					     (and (pair? (cdr vdef))
+						  (symbol? (cadr vdef))
+						  (null? (cddr vdef)))))
+				    (syntax-error cpd-unit/sig expr 
+						  "bad `var' sub-clause of `export'"
+						  export))
+			    (flatten-path 'export
+					  (let ([upath (caar vdef)]
+						[vname (cadar vdef)])
+					    (if (symbol? upath)
+						(list upath vname)
+						(append upath (list vname))))
+					  (lambda (base var var-nopath)
+					    (if base
+						(make-sig-explode-pair
+						 (list (if (null? (cdr vdef))
+							   var-nopath
+							   (cadr vdef)))
+						 (list base
+						       (if (null? (cdr vdef))
+							   (list var var-nopath)
+							   (list var (cadr vdef)))))
+						(syntax-error 
+						 cpd-unit/sig expr 
+						 "cannot exported imported variables"
+						 (car export))))
+					  (lambda (base last name var)
+					    (syntax-error 
+					     cpd-unit/sig expr 
+					     "`var' sub-clause path specifies a unit"
+					     export))))]
+			 [(eq? (car export) 'unit)
+			  (let ([udef (cdr export)])
+			    (unless (and (pair? udef)
+					 (upath? (car udef))
+					 (or (null? (cdr udef))
+					     (and (pair? (cdr udef))
+						  (symbol? (cadr udef))
+						  (null? (cddr udef)))))
+				    (syntax-error cpd-unit/sig expr 
+						  "bad `unit' sub-clause of `export'"
+						  export))
+			    (flatten-path 'export
+					  (car udef)
+					  (lambda (base var var-nopath)
+					    (syntax-error 
+					     cpd-unit/sig expr 
+					     "`unit' sub-clause path is a variable"
+					     (car export)))
+					  (lambda (base last name sig)
+					    (if base
+						(make-sig-explode-pair
+						 (list (rename-signature
+							sig
+							(if (null? (cdr udef))
+							    last
+							    (cadr udef))))
+						 (let ([flat (flatten-signature name sig)])
+						   (cons base 
+							 (map
+							  list
+							  flat
+							  (flatten-signature 
+							   (symbol->string (if (null? (cdr udef))
+									       last
+									       (cadr udef)))
+							   sig)))))
+						(syntax-error 
+						 cpd-unit/sig expr 
+						 "cannot exported imported variables"
+						 export)))))]
+			 [else
+			  (syntax-error cpd-unit/sig expr 
+					(format 
+					 "bad `export' sub-clause")
+					export)])]))
+		   (cdar body))])
+	    (check-unique (map
+			   (lambda (s)
+			     (if (signature? s)
+				 (signature-name s)
+				 s))
+			   (apply
+			    append
+			    (map sig-explode-pair-sigpart exports)))
+			  (lambda (name)
+			    (syntax-error cpd-unit/sig expr
+					  (format 
+					   "the name \"~s\" is exported twice" 
+					   name))))
+	    `(#%let ,(map
+		      (lambda (link)
+			(list (link-name link)
+			      (link-expr link)))
+		      links)
+	       (#%verify-linkage-signature-match
+		(#%quote ,cpd-unit/sig)
+		(#%quote ,(map link-name links))
+		(#%list ,@(map link-name links))
+		(#%quote ,(map (lambda (link) (explode-sig (link-sig link))) links))
+	        (#%quote ,(map
+			   (lambda (link)
+			     (map (lambda (sep)
+				    (explode-named-sig (sig-explode-pair-sigpart sep)))
+				  (link-links link)))
+			   links)))
+	       ; All checks done. Make the unit:
+	       (#%make-unit-with-signature
+		(#%compound-unit
+		 (import ,@(flatten-signatures
+			    imports))
+		 (link ,@(map
+			  (lambda (link)
+			    (list (link-name link)
+				  (cons `(#%unit-with-signature-unit
+					  ,(link-name link))
+					(apply
+					 append
+					 (map 
+					  sig-explode-pair-exploded 
+					  (link-links link))))))
+			  links))
+		 (export ,@(map sig-explode-pair-exploded exports)))
+	        (#%quote ,(explode-named-sigs imports))
+	        (#%quote ,(explode-sig
+			   (make-signature
+			    'dummy
+			    'dummy
+			    #f
+			    (apply
+			     append
+			     (map sig-explode-pair-sigpart exports))))))))))))
+			      
+  (define compound-unit-with-signature
+    (lambda body
+      (let ([expr (cons cpd-unit/sig body)])
+	(result (parse-compound-unit expr body)))))
+
+  (define parse-invoke-vars
+    (lambda (who rest expr)
+      (parse-imports who #t #f expr rest)))
+
+  (define build-invoke-unit
+    (lambda (who invoke-unit u sigs nsl)
+      (result `(let ([u ,u])
+		 (#%verify-linkage-signature-match
+		  (#%quote ,who)
+		  (#%quote (invoke))
+		  (#%list u)
+		  (#%quote (#()))
+		  (#%quote (,(explode-named-sigs sigs))))
+		 (,invoke-unit (#%unit-with-signature-unit u)
+			       ,@nsl
+			       ,@(flatten-signatures
+				  sigs))))))
+      
+
+  (define invoke-unit-with-signature
+    (lambda body
+      (let ([expr (cons invoke-unit/sig body)])
+	(unless (and (pair? body)
+		     (list? (cdr body)))
+		(syntax-error invoke-unit/sig expr "improper form"))
+	(let ([u (car body)]
+	      [sigs (parse-invoke-vars invoke-unit/sig (cdr body) expr)])
+	  (build-invoke-unit invoke-unit/sig '#%invoke-unit u sigs null)))))
+  
+  (define invoke-open-unit-with-signature
+    (lambda body
+      (let ([expr (cons invoke-open-unit/sig body)])
+	(unless (and (pair? body)
+		     (or (null? (cdr body)) 
+			 (and (pair? (cdr body))
+			      (list? (cddr body)))))
+		(syntax-error invoke-open-unit/sig expr "improper form"))
+	(if (null? (cdr body))
+	    (build-invoke-unit invoke-open-unit/sig '#%invoke-open-unit (car body) null null)
+	    (let ([u (car body)]
+		  [ns (cadr body)]
+		  [sigs (parse-invoke-vars invoke-open-unit/sig (cddr body) expr)])
+	      (build-invoke-unit invoke-open-unit/sig '#%invoke-open-unit u sigs (list ns)))))))
+  
+  (define unit->unit-with-signature
+    (lambda body
+      (let ([expr (cons u->u/sig body)])
+	(unless (and (pair? body)
+		     (pair? (cdr body))
+		     (list? (cadr body))
+		     (pair? (cddr body))
+		     (null? (cdddr body)))
+		(syntax-error u->u/sig expr "improper form"))
+	(let ([e (car body)]
+	      [im-sigs (map (lambda (sig)
+			      (get-sig u->u/sig expr #f sig))
+			    (cadr body))]
+	      [ex-sig (get-sig u->u/sig expr #f (caddr body))])
+	  `(#%make-unit-with-signature
+	    ,e
+	    (#%quote ,(explode-named-sigs im-sigs))
+	    (#%quote ,(explode-sig ex-sig)))))))
+
+  (vector define-signature
+	  let-signature
+          unit-with-signature
+          compound-unit-with-signature
+	  invoke-unit-with-signature
+	  invoke-open-unit-with-signature
+	  unit->unit-with-signature)))
+
+> stop unitsig <
diff --git a/src/mzscheme/src/vector.c b/src/mzscheme/src/vector.c
new file mode 100644
index 0000000..31d7e91
--- /dev/null
+++ b/src/mzscheme/src/vector.c
@@ -0,0 +1,307 @@
+/*
+  MzScheme
+  Copyright (c) 1995 Matthew Flatt
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  libscheme
+  Copyright (c) 1994 Brent Benson
+  All rights reserved.
+*/
+
+#include "schpriv.h"
+
+/* global_constants */
+/* locals */
+static Scheme_Object *vector_p (int argc, Scheme_Object *argv[]);
+static Scheme_Object *make_vector (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector_length (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector_ref (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector_set (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector_to_list (int argc, Scheme_Object *argv[]);
+static Scheme_Object *list_to_vector (int argc, Scheme_Object *argv[]);
+static Scheme_Object *vector_fill (int argc, Scheme_Object *argv[]);
+
+static Scheme_Object *vector_append (int argc, Scheme_Object *argv[]);
+
+void
+scheme_init_vector (Scheme_Env *env)
+{
+  if (scheme_starting_up) {
+  }
+
+  scheme_add_global_constant("vector?", 
+			     scheme_make_folding_prim(vector_p, 
+						      "vector?", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("make-vector", 
+			     scheme_make_prim_w_arity(make_vector, 
+						      "make-vector", 
+						      1, 2), 
+			     env);
+  scheme_add_global_constant("vector", 
+			     scheme_make_prim_w_arity(vector, 
+						      "vector", 
+						      0, -1), 
+			     env);
+  scheme_add_global_constant("vector-length", 
+			     scheme_make_folding_prim(vector_length, 
+						      "vector-length", 
+						      1, 1, 1), 
+			     env);
+  scheme_add_global_constant("vector-ref", 
+			     scheme_make_prim_w_arity(vector_ref, 
+						      "vector-ref", 
+						      2, 2), 
+			     env);
+  scheme_add_global_constant("vector-set!", 
+			     scheme_make_prim_w_arity(vector_set, 
+						      "vector-set!", 
+						      3, 3), 
+			     env);
+  scheme_add_global_constant("vector->list", 
+			     scheme_make_prim_w_arity(vector_to_list, 
+						      "vector->list", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("list->vector", 
+			     scheme_make_prim_w_arity(list_to_vector, 
+						      "list->vector", 
+						      1, 1), 
+			     env);
+  scheme_add_global_constant("vector-fill!", 
+			     scheme_make_prim_w_arity(vector_fill, 
+						      "vector-fill!", 
+						      2, 2), 
+			     env);
+}
+
+Scheme_Object *
+scheme_make_vector (int size, Scheme_Object *fill)
+{
+  Scheme_Object *vec;
+  int i;
+
+  if (size < 0) {
+    vec = scheme_make_integer(size);
+    scheme_wrong_type("make-vector", "non-negative exact integer", -1, 0, &vec);
+  }
+
+  vec = (Scheme_Object *)scheme_malloc_fail_ok(scheme_malloc_tagged,
+					       sizeof(Scheme_Vector) 
+					       + (size - 1) * sizeof(Scheme_Object *));
+  vec->type = scheme_vector_type;
+  SCHEME_VEC_SIZE(vec) = size;
+
+  for (i = 0; i < size; i++)
+    SCHEME_VEC_ELS(vec)[i] = fill;
+
+  return vec;
+}
+
+/* locals */
+
+static Scheme_Object *
+vector_p (int argc, Scheme_Object *argv[])
+{
+  return (SCHEME_VECTORP(argv[0]) ? scheme_true : scheme_false);
+}
+
+static Scheme_Object *
+make_vector (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *vec, *fill;
+  long len;
+
+  len = scheme_extract_index("make-vector", 0, argc, argv, -1);
+
+  if (len == -1) {
+    scheme_raise_out_of_memory("make-vector", "making vector of length %s",
+			       scheme_make_provided_string(argv[0], 0, NULL));
+  }
+
+  if (argc == 2)
+    fill = argv[1];
+  else
+    fill = scheme_make_integer(0);
+
+  vec = scheme_make_vector(len, fill);
+
+  return vec;
+}
+
+static Scheme_Object *
+vector (int argc, Scheme_Object *argv[])
+{
+  Scheme_Object *vec;
+  int i;
+
+  vec = scheme_make_vector (argc, 0);
+  for ( i=0 ; i<argc ; ++i )
+    SCHEME_VEC_ELS(vec)[i] = argv[i];
+
+  return (vec);
+}
+
+static Scheme_Object *
+vector_length (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_VECTORP(argv[0]))
+    scheme_wrong_type("vector-length", "vector", 0, argc, argv);
+
+  return scheme_make_integer(SCHEME_VEC_SIZE(argv[0]));
+}
+
+static Scheme_Object *
+bad_index(char *name, Scheme_Object *i, Scheme_Object *vec)
+{
+  int n = SCHEME_VEC_SIZE(vec) - 1;
+
+  if (SCHEME_VEC_SIZE(vec))
+    scheme_raise_exn(MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR,
+		     i,
+		     scheme_make_integer(0),
+		     scheme_make_integer(n),
+		     "%s: index %s out of range [%d, %d]",
+		     name, 
+		     scheme_make_provided_string(i, 0, NULL), 
+		     0, n);
+  else
+    scheme_raise_exn(MZEXN_APPLICATION_RANGE_BOUNDS_VECTOR,
+		     i,
+		     scheme_make_integer(0),
+		     scheme_make_integer(0),
+		     "%s: bad index %s for empty vector",
+		     name,
+		     scheme_make_provided_string(i, 0, NULL));
+  
+  return scheme_void;
+}
+
+static Scheme_Object *
+vector_ref (int argc, Scheme_Object *argv[])
+{
+  long i, len;
+
+  if (!SCHEME_VECTORP(argv[0]))
+    scheme_wrong_type("vector-ref", "vector", 0, argc, argv);
+
+  len = SCHEME_VEC_SIZE(argv[0]);
+
+  i = scheme_extract_index("vector-ref", 1, argc, argv, len);
+
+  if (i >= len)
+    return bad_index("vector-ref", argv[1], argv[0]);
+
+  return (SCHEME_VEC_ELS(argv[0]))[i];
+}
+
+static Scheme_Object *
+vector_set(int argc, Scheme_Object *argv[])
+{
+  long i, len;
+
+  if (!SCHEME_VECTORP(argv[0]))
+    scheme_wrong_type("vector-set!", "vector", 0, argc, argv);
+
+  len = SCHEME_VEC_SIZE(argv[0]);
+
+  i = scheme_extract_index("vector-set!", 1, argc, argv, len);
+
+  if (i >= len)
+    return bad_index("vector-set!", argv[1], argv[0]);
+
+  (SCHEME_VEC_ELS(argv[0]))[i] = argv[2];
+
+  return scheme_void;
+}
+
+static Scheme_Object *
+vector_to_list (int argc, Scheme_Object *argv[])
+{
+  if (!SCHEME_VECTORP(argv[0]))
+    scheme_wrong_type("vector->list", "vector", 0, argc, argv);
+
+  return scheme_vector_to_list(argv[0]);
+}
+
+Scheme_Object *
+scheme_vector_to_list (Scheme_Object *vec)
+{
+  int len, i;
+  Scheme_Object *first, *last, *pair;
+
+  len = SCHEME_VEC_SIZE (vec);
+  first = last = scheme_null;
+  for (i = 0; i < len ; i++) {
+    pair = scheme_make_pair (SCHEME_VEC_ELS(vec)[i], scheme_null);
+    if (SCHEME_NULLP(first))
+      first = last = pair;
+    else {
+      SCHEME_CDR (last) = pair;
+      last = pair;
+    }
+  }
+
+  return first;
+}
+
+static Scheme_Object *
+list_to_vector (int argc, Scheme_Object *argv[])
+{
+  return scheme_list_to_vector(argv[0]);
+}
+
+Scheme_Object *
+scheme_list_to_vector (Scheme_Object *list)
+{
+  int len, i;
+  Scheme_Object *vec, *orig = list;
+
+  /* Technically, we need to worry about the size of the input
+     list. However, we've chosen the vector size limit so that it's
+     unreasonable to expect a list to be too large - we expect to run
+     out of memory, first! */
+
+  len = scheme_proper_list_length(list);
+  if (len < 0)
+    scheme_wrong_type("list->vector", "proper list", -1, 0, &orig);
+
+  vec = scheme_make_vector (len, 0);
+  i = 0;
+  while (SCHEME_PAIRP(list)) {
+    SCHEME_VEC_ELS(vec)[i] = SCHEME_CAR (list);
+    i++;
+    list = SCHEME_CDR (list);
+  }
+
+  return vec;
+}
+
+static Scheme_Object *
+vector_fill (int argc, Scheme_Object *argv[])
+{
+  int i;
+  
+  if (!SCHEME_VECTORP(argv[0]))
+    scheme_wrong_type("vector-fill!", "vector", 0, argc, argv);
+
+  for ( i=0 ; i<SCHEME_VEC_SIZE (argv[0]) ; ++i )
+    SCHEME_VEC_ELS(argv[0])[i] = argv[1];
+
+  return argv[0];
+}
diff --git a/src/mzscheme/uconfig.h b/src/mzscheme/uconfig.h
new file mode 100644
index 0000000..b7bdf41
--- /dev/null
+++ b/src/mzscheme/uconfig.h
@@ -0,0 +1,31 @@
+
+/* Standard settings for Unix platforms. */
+/* Used by sconfig.h for known architectures. */
+
+#define SYSTEM_TYPE_NAME "unix"
+#define UNIX_FILE_SYSTEM
+
+#define TIME_SYNTAX
+#define PROCESS_FUNCTION
+#define DIR_FUNCTION
+#define GETENV_FUNCTION
+
+#define HAS_STANDARD_IOB
+#define FILES_HAVE_FDS
+#define USE_UNIX_SOCKETS_TCP
+
+#define UNIX_PROCESSES
+
+#define EXPAND_FILENAME_TILDE
+
+#define DO_STACK_CHECK
+#define UNIX_FIND_STACK_BOUNDS
+#define STACK_SAFETY_MARGIN 50000
+
+#define UNIX_DYNAMIC_LOAD
+
+#define UNISTD_INCLUDE
+#define USE_FCHDIR
+
+#define USE_GETRUSAGE
+
diff --git a/src/mzscheme/utils/README b/src/mzscheme/utils/README
new file mode 100644
index 0000000..ab9a630
--- /dev/null
+++ b/src/mzscheme/utils/README
@@ -0,0 +1,17 @@
+
+These are utilities for linking external C++ code into MzScheme.
+xctocc is decribed in the manual "PLT xctocc: C++ Glue Generator
+Manual". xcglue.c and xcglue.h are used by the code generated by
+xctocc.
+
+The xctosig script takes any number of .xc file names on its command
+line and writes out type information that can be used by
+MrSpidey. This information needs to be filtered through the sigclean
+script, though. (Edit the path to mzscheme at the top of the script.)
+
+The other two scripts are less useful. The xctotex script takes any
+number of .xc file names and generates a simple table for LaTeX-based
+documentation that enumerates all of the things defined. The xctotest
+script generates some robustness-testing code in the form used by MrEd
+(see mred/tests/setup.ss).
+
diff --git a/src/mzscheme/utils/common.pl b/src/mzscheme/utils/common.pl
new file mode 100644
index 0000000..8d6f90c
--- /dev/null
+++ b/src/mzscheme/utils/common.pl
@@ -0,0 +1,50 @@
+
+sub Desymbol
+{
+    local($t, $e) = @_;
+
+    $e = substr($t, -1);
+    if ($e eq '*') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "P";
+    }
+    if ($e eq '&') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "A";
+    }
+    if ($e eq '?') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "Q";
+    }
+    if ($e eq '!') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "PT";
+    }
+    if ($e eq '^') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "NP";
+    }
+    if ($e eq '%') {
+	substr($t, -1) = '';
+	return &Desymbol($t) . "AD";
+    }
+    if ($e eq ']') {
+	$badflag = 1;
+	return "XXX";
+    }
+
+    return $t;
+}
+
+sub MakeCommonName
+{
+    $commonname = "wxsC_" . &Desymbol($returntype);
+
+    foreach $p (@paramtypes) {
+	$commonname = $commonname . "_" . &Desymbol($p);
+    }
+
+    return $commonname;
+}
+
+1;
diff --git a/src/mzscheme/utils/parse.pl b/src/mzscheme/utils/parse.pl
new file mode 100644
index 0000000..791b033
--- /dev/null
+++ b/src/mzscheme/utils/parse.pl
@@ -0,0 +1,547 @@
+
+# Copyright (c) 1995 Matthew Flatt
+# Parsing for xctocc and xctotex
+
+$key_include = '@INCLUDE ';
+$key_boolean = '@BOOLEAN ';
+$key_classbase = '@CLASSBASE ';
+$key_classid = '@CLASSID ';
+$key_global = '@GLOBAL ';
+$key_common = '@COMMON ';
+$key_header = '@HEADER ';
+$key_end = '@END ';
+$key_stop = '@STOP ';
+$key_creator = '@CREATOR ';
+$key_macro = '@MACRO ';
+$key_var = '@VAR ';
+$key_set = '@SET ';
+$key_define = '@DEFINE ';
+$key_ifdefine = '@IFDEFINE ';
+$key_ivar = '@IVAR ';
+$key_constant = '@CONSTANT ';
+$key_suffix = '@CLASSSUFFIX ';
+$key_test = '@TEST ';
+$key_setmark = '@SETMARK ';
+$key_idfield = '@IDFIELD ';
+
+sub ResetObjParams 
+{
+    @functions = ();
+    @funcnames = ();
+    @vars = ();
+    @ivars = ();
+    @creators = ();
+    @constants = ();
+    %justoneok = ();
+    %justonemin = ();
+    %justonemax = ();
+    $globalname = '';
+    $classid = '';
+    $global = 0;
+    $common = 0;
+    $implementor = "";
+}
+
+&ResetObjParams();
+
+sub ReadFile {
+    @openfiles = ();
+    $stop = 0;
+    $linenum = 0;
+    $testfile = 0;
+    $classsuffix = '';
+    $idfield = '';
+    $bool = 'boolean';
+    %macros = ();
+    %sets = ();
+    %marks = ();
+    $marks{'V'} = 'V';
+    $marks{'H'} = 'H';
+    $marks{'v'} = 'v';
+    $marks{'m'} = 'm';
+    $ifzero = 0;
+    while(!$stop)
+    {
+	$_ = <IN>;
+	$linenum += 1;
+	if ($_ eq undef) {
+	    if ($#openfiles >= 0) {
+		close(IN);
+		$oldin = pop(@openfiles);
+		$p = index($oldin, ":");
+		$linenum = substr($oldin, 0, $p);
+		$oldin = substr($oldin, $p + 1); 
+		$p = index($oldin, ":");
+		$pos = substr($oldin, 0, $p);
+		$thisfile = substr($oldin, $p + 1); 
+		open(IN, "$thisfile");
+		if ($pos > 0) {
+		    seek(IN, $pos, 0);
+		} else {
+		    seek(IN, 0, 2);
+		}
+	    } else {
+		$stop = 1;
+	    }
+	} elsif ($ifzero) {
+           if (/^\#endif/) {
+	       $ifzero -= 1;
+	   } elsif (/^\#if/) {
+	       $ifzero += 1;
+	   }
+        } elsif (/^\@/) {
+	    chop;
+	    $_ = $_ . " ";
+	    if (&StartsWithKey($_, $key_include)) {
+		$_ = &SkipKey($_, $key_include);
+		$incfile = &Wash($_);
+		$oldin = $linenum . ":" . tell(IN) . ":" . $thisfile;
+		if (!open(IN2, $incfile)) {
+		    print STDERR "Couldn't open \"${incfile}\"\n";
+		} else {
+		    $thisfile = $incfile;
+		    $linenum = 0;
+		    push(@openfiles, $oldin);
+		    close(IN);
+		    open(IN, "<&IN2");
+		}
+	    } elsif (&StartsWithKey($_, $key_boolean)) {
+		$bool = &Wash(&SkipKey($_, $key_boolean));
+	    } elsif (&StartsWithKey($_, $key_test)) {
+		$testfile = 1;
+	    } elsif (&StartsWithKey($_, $key_classbase)) {
+		&ResetObjParams();
+		$_ = &Wash(&SkipKey($_, $key_classbase));
+		$pos = index($_, ' ');
+		$base = substr($_, 0, $pos);
+		$classstring = substr($_, $pos);
+		$base = &Wash($base);
+		($classstring,$parentstring) = &SplitColon($classstring);
+		$classstring = '"' . &Unquote(&Wash($classstring))
+		    . &Unquote($classsuffix) . '"';
+		$parentstring = &Wash($parentstring);
+		if ($parentstring ne '') {
+		    $parentstring = '"' . &Unquote($parentstring)
+			. &Unquote($classsuffix) . '"';
+		}
+		$oldclass = $base;
+		$newclass = 'os_' . $base;
+	    } elsif (&StartsWithKey($_, $key_global)) {
+		&ResetObjParams();
+		$global = 1;
+		$globalname = &Wash(&SkipKey($_, $key_global));
+	    } elsif (&StartsWithKey($_, $key_common)) {
+		&ResetObjParams();
+		$common = 1;
+	    } elsif (&StartsWithKey($_, $key_idfield)) {
+		$idfield = &Wash(&SkipKey($_, $key_idfield));
+	    } elsif (&StartsWithKey($_, $key_classid)) {
+		$classid = &Wash(&SkipKey($_, $key_classid));
+	    } elsif (&StartsWithKey($_, $key_header)) {
+		&PrintHeader();
+	    } elsif (&StartsWithKey($_, $key_end)) {
+		&DoPrintClass();
+	    } elsif (&StartsWithKey($_, $key_stop)) {
+		$stop = 1;
+	    } elsif (&StartsWithKey($_, $key_creator)) {
+		$creator = &SkipKey($_, $key_creator);
+		@creators = (@creators, $creator);
+	    } elsif (&StartsWithKey($_, $key_macro)) {
+		$s = &Wash(&SkipKey($_, $key_macro));
+		$eqpos = index($s, '=');
+		$parenpos = index($s, '[');
+		if ($parenpos >= $[ && $parenpos < $eqpos) {
+		    $macro = substr($s, 0, $parenpos);
+		} else {
+		    $macro = substr($s, 0, $eqpos);
+		}
+		$macro = &Wash($macro);
+		$macros{$macro} = $s;
+	    } elsif (&StartsWithKey($_, $key_var)) {
+		@vars = (@vars, &Wash(substr($_, 4)));
+	    } elsif (&StartsWithKey($_, $key_set)) {
+		($var, $val) = split(/=/, &SkipKey($_, $key_set));
+		$var = &Wash($var);
+		$val = &Wash($val);
+		$sets{$var} = $val;
+	    } elsif (&StartsWithKey($_, $key_define)) {
+		($var, $val) = split(/=/, &SkipKey($_, $key_define));
+		$var = &Wash($var);
+		$val = &Wash($val);
+		&DefineVar($var, $val);
+	    } elsif (&StartsWithKey($_, $key_ifdefine)) {
+		($var, $val) = split(/=/, &SkipKey($_, $key_ifdefine), 2);
+		$var = &Wash($var);
+		($test, $val1, $val2) = &SplitColon($val);
+		if ($sets{&Wash($test)} > 0) {
+		    $val = $val1;
+		} else {
+		    $val = $val2;
+		}
+		$val = &Wash($val);
+		&DefineVar($var, $val);
+	    } elsif (&StartsWithKey($_, $key_ivar)) {
+		@ivars = (@ivars, &Wash(&SkipKey($_, $key_ivar)));
+	    } elsif (&StartsWithKey($_, $key_constant)) {
+		@constants = (@constants, &Wash(&SkipKey($_, $key_constant)));
+	    } elsif (&StartsWithKey($_, $key_suffix)) {
+		$classsuffix = &Wash(&SkipKey($_, $key_suffix));
+	    } elsif (&StartsWithKey($_, $key_setmark)) {
+		($mark, $val) = split(/=/, &SkipKey($_, $key_setmark), 2);
+		$mark = &Wash($mark);
+		$marks{$mark} = &Wash($val);
+	    } elsif (substr($_, 1, 1) ne ' ') {
+		print STDERR 
+		    "syntax error at line $linenum of \"$thisfile\".\n"
+		} else {
+		    $function = &Wash(substr($_, 1));
+		    $mark = substr($function, 0, 1);
+		    if ($mark ne '"') {
+			$mark = $marks{$mark};
+			substr($function, 0, 1) = $mark;
+		    }
+		    @functions = ($function, @functions);
+		    &ReadFields($function);
+		    @funcnames = ($func, @funcnames);
+		}
+	} elsif (/^\#if 0/) {
+	    $ifzero = 1;
+	} else {
+	    &IgnoreLine($_);
+	}
+    }
+
+    # Finish up the file
+    while(<IN>) { &IgnoreLine($_); }
+}
+
+sub StartsWithKey
+{
+    return (index($_[0], $_[1]) == $[);
+}
+
+sub SkipKey
+{
+    return substr($_[0], length($_[1]));
+}
+
+sub Wash 
+{
+    $_[0] =~ /^ *(.*[^ ]) *$/;
+    return $1;
+}
+
+sub SplitColon
+{
+    local($s) = @_;
+    local($balance, @ans, $a, $c);
+    
+    $balance = 0;
+    $a = '';
+    @ans = ();
+    while ($s ne '') {
+	$c = substr($s, 0, 1);
+	if (!$balance && $c eq ':') {
+	    @ans = (@ans, $a);
+	    $a = '';
+	} else {
+	    $a = $a . $c;
+	}
+
+	if ($c eq '"') {
+	    $balance = !$balance;
+	} 
+	$s = substr($s, 1);
+    }
+    @ans = (@ans, $a) if ($a ne '');
+
+    return @ans;
+}
+
+sub ReadFields {
+
+    ($s) = @_;
+
+    $virtual = $virtualonly = $hidden = $delegate = $externalmethod = 0;
+
+    $mark = substr($s, 0, 1);
+    if ($mark ne '"') {
+	substr($s, 0, 1) = '';
+    }
+
+    if ($mark eq 'V') {
+	$virtual = $virtualonly = 1;
+    } elsif ($mark eq 'v') {
+	$virtual = 1;
+    } elsif ($mark eq 'H') {
+	$virtual = $virtualonly = $hidden = 1;
+    } elsif ($mark eq 'd') {
+	$virtual = 1;
+    } elsif ($mark eq 'm') {
+	$externalmethod = 1;
+    }
+
+    ($s, $casename) = split(/<>/, $s);
+    if ($casename eq "") {
+	($s, $onlyif) = split(/##/, $s);
+    } else {
+	($casename, $onlyif) = split(/##/, $casename);
+    }
+
+    $casename = &Wash($casename);
+
+    ($fname, $s, $methodpostmacros, $gluepostmacros, $exception, $vexception, $implementor) 
+	= &SplitColon($s);
+    
+    $s = &Wash($s);
+
+    $p = index($s, ' ');
+    $returntype = substr($s, 0, $p);
+    $s = substr($s, $p + 1);
+
+    $p = index($s, '(');
+    $func = substr($s, 0, $p);
+    $s = substr($s, $p + 1);
+
+    $p = rindex($s, ')');
+    $s = substr($s, 0, $p);
+
+    @defvals = ();
+    @bundles = ();
+    @unbundles = ();
+    @typechecks = ();
+    @typeids = ();
+    @schemes = ();
+    @schemeparams = ();
+    @spideytypes = ();
+    @paramtypes = split(/,/, $s);
+    $numschemes = 0;
+    foreach $paramtype (@paramtypes) {
+	($paramtype, $bundle, $unbundle, $typecheck, $typeid, $spideytype) 
+	    = split('/', $paramtype);
+
+	($paramtype, $defval) = split(/=/, $paramtype);
+	$paramtype = &Wash($paramtype);
+	if (substr($paramtype, 0, 1) eq '-') {
+	    $paramtype = substr($paramtype, 1);
+	    $scheme = 0;
+	} else {
+	    $scheme = 1;
+	}
+	$defval = &Wash($defval);
+	$bundle = &Wash($bundle);
+	$unbundle = &Wash($unbundle);
+	$typecheck = &Wash($typecheck);
+	$typeid = &Wash($typeid);
+	$spideytype = &Wash($spideytype);
+
+	@defvals = (@defvals, $defval); 
+	@bundles = (@bundles, $bundle);
+	@unbundles = (@unbundles, $unbundle);
+	@typechecks = (@typechecks, $typecheck);
+	@typeids = (@typeids, $typeid);
+	@spideytypes = (@spideytypes, $spideytype);
+	@schemes = (@schemes, $scheme);
+	if ($scheme) {
+	    @schemeparams = (@schemeparams, $paramtype);
+	    $numschemes += 1;
+	}
+    }
+
+    ($returntype, $returnbundle, $returnunbundle, $returnspideytype) = split('/', $returntype);
+
+    $func = &Wash($func);
+    $fname = &Wash($fname);
+    $returntype = &Wash($returntype);
+    $returnbundle = &Wash($returnbundle);
+    $returnunbundle = &Wash($returnunbundle);
+
+    ($methpre, $methprecall, $methpostcall, $methpost) 
+	= split('/', $methodpostmacros);
+    ($gluepre, $glueprecall, $gluepostcall, $gluepost) 
+	= split('/', $gluepostmacros);
+
+    $methpre = &Wash($methpre);
+    $methprecall = &Wash($methprecall);
+    $methpost = &Wash($methpost);
+    $methpostcall = &Wash($methpostcall);
+
+    $gluepre = &Wash($gluepre);
+    $glueprecall = &Wash($glueprecall);
+    $gluepost = &Wash($gluepost);
+    $gluepostcall = &Wash($gluepostcall);
+
+    if ($virtualonly && ($vexception ne '')) {
+	$exception = &Wash($vexception);
+    } else {
+	$exception = &Wash($exception);
+    }
+    if ($exception eq '') {
+	$exception = 'SUPER';
+    }
+
+    $method = '"' . substr($classstring, 1, length($classstring) - 2)
+	. "::" . substr($fname, 1, length($fname) - 2) . '"';
+}
+
+sub ReadIvarFields
+{
+    local($s) = @_;
+
+    $readonly = 0;
+
+    ($s, $onlyif) = split(/##/, $s);
+
+    if (substr($s, 0, 1) eq 'r') {
+	$readonly = 1;
+    }
+
+    substr($s, 0, 1) = '' if $readonly;
+    
+    ($iname, $itype) = &SplitColon($s);
+    ($itype, $ivarname) = split(/ /, &Wash($itype));
+
+    $iname = &Wash($iname);
+    $getname = substr($iname, 1);
+    substr($getname, -1) = '';
+    $setname = "\"set-" . $getname . "\"";
+    $getname = "\"get-" . $getname . "\"";
+
+    $ivartype = &Wash($itype);
+    $ivarname = &Wash($ivarname);
+
+    $method = '"' . substr($classstring, 1, length($classstring) - 2)
+	. "::" . substr($iname, 1, length($iname) - 2) . '"';
+}
+
+sub ReadConstFields
+{
+    local($s) = @_;
+
+    ($s, $onlyif) = split(/##/, $s);
+
+    ($const, $ctype) = &SplitColon($s);
+    ($ctype, $cname) = split(/ /, &Wash($ctype));
+
+    $const = &Wash($const);
+    $ctype = &Wash($ctype);
+    $cname = &Wash($cname);
+}
+
+sub DefineReplace
+{
+    local($val) = @_;
+
+    while ($val =~ /<([^>]*)>/ ) {
+	$subval = $sets{$1};
+	$val =~ s/<[^>]*>/$subval/;
+    }
+
+    return $val;
+}
+
+sub DefineVar
+{
+    local($var, $val) = @_;
+
+    $val = &DefineReplace($val);
+    &PrintDefine("#define $var $val\n");
+}
+
+sub Unquote
+{
+    return substr($_[0], 1, length($_[0]) - 2);
+}
+
+sub Sprintfify
+{
+    $_[0] =~ s/%/%%/g;
+}
+
+sub ApplyMacro
+{
+    local($name, $var, $var2) = @_;
+
+    if (($name eq '') || ($name eq undef)) {
+	return "";
+    }
+
+    local($pos, @args, @argnames, $arg);
+    $pos = index($name, '[');
+    if ($pos >= $[) {
+	$arg = substr($name, $pos + 1);
+	$name = substr($name, 0, $pos);
+	$pos = index($arg, ']');
+	$arg = substr($arg, 0, $pos);
+	@args = split(/\./, $arg);
+    } else {
+	@args = ();
+    }
+
+    $macro = $macros{$name};
+
+    if ($macro eq undef) {
+	print STDERR "Unknown macro $name in $func.\n";
+	return "";
+    }
+
+    $pos = index($macro, '=');
+
+    $m = substr($macro, $pos + 1);
+    $macro = substr($macro, 0, $pos);
+    $pos = index($macro, '[');
+    if ($pos >= $[) {
+	$arg = substr($macro, $pos + 1);
+	$pos = index($arg, ']');
+	$arg = substr($arg, 0, $pos);
+	@argnames = split(/\./, $arg);
+    } else {
+	@argnames = ();
+    }
+    
+    $m =~ s/{x}/$var/g;
+    $m =~ s/{s}/$var2/g;
+
+    if ($#argnames != $#args) {
+	print STDERR "Bad parameter ("
+	    . ($#args + 1)
+	    . " for "
+	    . ($#argnames + 1)
+	    . ") count to macro $name in $func.\n";
+	return "";
+    }
+
+    foreach $name (@argnames) {
+	$arg = shift(@args);
+	$name = &Wash($name);
+	$arg = &Wash($arg);
+	$m =~ s/<${name}>/$arg/g;
+    }
+
+    $m = &Wash($m);
+
+    while (substr($m, 0, 2) eq '$$') {
+	if (substr($m, 2, 1) eq '>') {
+	    $m = &DefineReplace(substr($m, 3));
+	} else {
+	    $m = &ApplyMacro(substr($m, 2), "", "");
+	}
+    }
+
+    return $m;
+}
+
+sub ApplyMacros
+{
+    local($macrolist, $var, $var2) = @_;
+
+    @macros = split(/\|/, $macrolist);
+    $str = '';
+    foreach $macro (@macros) {
+	$str = $str . &ApplyMacro(&Wash($macro), $var, $var2);
+    }
+
+    return $str;
+}
+    
+1;
diff --git a/src/mzscheme/utils/sigclean b/src/mzscheme/utils/sigclean
new file mode 100755
index 0000000..b8de154
--- /dev/null
+++ b/src/mzscheme/utils/sigclean
@@ -0,0 +1,123 @@
+#!/bin/sh
+
+string=? ; exec /home/mflatt/plt/bin/mzscheme -r $0 "$@"
+
+;; Class with overloaded init => single init w/max args
+;; Class with overloaded method => single method w/union
+;; Multiple top-level function specs => single spec w/union
+
+(require-library "pretty.ss")
+(require-library "functio.ss")
+
+(define globals (make-hash-table))
+(define classes (make-hash-table))
+
+(define-struct cl (super def))
+
+(define (do-class cldef)
+  (let ([name (cadr cldef)]
+	[super (cadr (caddr cldef))]
+	[rest (cddr (caddr cldef))])
+    (let loop ([inits (list (car rest))][rest (cdr rest)][multi? #f])
+      (if (and (pair? (car rest))
+	       (eq? (caar rest) 'public))
+	  (let ([publics (cdar rest)]
+		[init (if multi?
+			  (resolve-multi-inits inits)
+			  (car inits))])
+	    (hash-table-put! classes name
+			     (make-cl
+			      super
+			      `(class ,super ,init
+				       (public ,@(do-publics publics))))))
+	  (loop (append inits (list (car rest))) (cdr rest) #t)))))
+
+(define (resolve-multi-inits i)
+  (if (andmap null? i)
+      null
+      (cons
+       (let loop ([t #f][i i])
+	 (cond
+	  [(null? i) t]
+	  [(null? (car i)) (loop t (cdr i))]
+	  [else 
+	   (let ([v (caar i)])
+	     (loop
+	      (cond
+	       [(symbol? v) 
+		(cond
+		 [(not t) v]
+		 [(symbol? t) (string->symbol
+			       (string-append
+				(symbol->string t)
+				"-or-"
+				(symbol->string v)))]
+		 [else t])]
+	       [(pair? t) 
+		(if (equal? t v)
+		    t
+		    `(,(car v) (type: (union ,(cadadr v) ,(cadadr t)))))]
+	       [else v])
+	      (cdr i)))]))
+       (resolve-multi-inits 
+	(map (lambda (x)
+	       (if (null? x)
+		   null
+		   (cdr x)))
+	     i)))))
+
+(define (do-publics p)
+  (let ([ht (make-hash-table)])
+    (for-each
+     (lambda (pub)
+       (hash-table-put-union! ht (car pub) (cadr pub)))
+     p)
+    (hash-table-map ht list)))
+
+(define (hash-table-put-union! ht k v)
+  (let* ([old-v (hash-table-get ht k (lambda () #f))])
+    (hash-table-put! ht k 
+		     (if old-v
+			 `(type: (union ,(cadr v) ,(cadr old-v)))
+			 v))))
+
+(let loop ()
+  (let ([v (read)])
+    (unless (eof-object? v)
+	    (let ([spec-kind (caaddr v)])
+	      (if (eq? spec-kind 'class)
+		  (do-class v)
+		  (let* ([name (cadr v)]
+			 [type (cadr (caddr v))])
+		    (hash-table-put-union! globals name type))))
+	    (loop))))
+
+(hash-table-for-each
+ globals
+ (lambda (k v)
+   (pretty-print `(define ,k (type: ,v)))))
+
+(map
+ (lambda (i)
+   (let ([name (car i)]
+	 [cl (cdr i)])
+     (newline)
+     (pretty-print `(define ,name ,(cl-def cl)))))
+ ; Sort classes so that superclasses are first
+ (quicksort (hash-table-map classes cons)
+	    (lambda (a b)
+	      (let ([a-name (car a)])
+		(let loop ([cl (cdr b)])
+		  (let ([super (cl-super cl)])
+		    (cond
+		     [(eq? a-name super) #t]
+		     [(eq? 'null super) #f]
+		     [else
+		      (let ([s (hash-table-get classes super
+					       (lambda () #f))])
+			(if s
+			    (loop s)
+			    #f))])))))))
+
+
+			
diff --git a/src/mzscheme/utils/xcglue.c b/src/mzscheme/utils/xcglue.c
new file mode 100644
index 0000000..44c921c
--- /dev/null
+++ b/src/mzscheme/utils/xcglue.c
@@ -0,0 +1,539 @@
+#include "xcglue.h"
+#include "gc.h"
+
+typedef struct {
+  void *realobj;
+  Scheme_Class_Object *obj;
+} ObjectHash;
+
+static ObjectHash *hash;
+long hashsize = 100, hashcount = 0;
+
+typedef struct {
+  long id;
+  Objscheme_Bundler f;
+} BundlerHash;
+
+static BundlerHash *bhash;
+long bhashsize = 201, bhashcount = 0, bhashstep = 17;
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+static long num_objects_allocated = 0;
+
+static Scheme_Object *set_car_prim;
+
+void objscheme_init(Scheme_Env *env)
+{
+  long i;
+  Scheme_Object *set_car_symbol;
+
+  set_car_symbol = scheme_intern_symbol("set-car!");
+  set_car_prim = scheme_lookup_global(set_car_symbol, env);
+  
+  hash = (ObjectHash *)scheme_malloc_atomic(sizeof(ObjectHash) * hashsize);
+  for (i = 0; i < hashsize; i++)
+    hash[i].realobj = NULL;
+  
+  bhash = (BundlerHash *)scheme_malloc_atomic(sizeof(BundlerHash) 
+					      * bhashsize);
+  for (i = 0; i < bhashsize; i++)
+    bhash[i].id = 0;
+}
+
+Scheme_Object *objscheme_def_prim_class(void *global_env, 
+					char *name, char *superclass,
+					Scheme_Method_Prim *initf,
+					int nmethods)
+{
+  Scheme_Object *obj;
+  Scheme_Object *sclass;
+
+  if (superclass)
+    obj = scheme_lookup_xc_global(superclass, global_env);
+  else
+    obj = NULL;
+
+  sclass = scheme_make_class(name, obj, initf, nmethods);
+
+  scheme_install_xc_global(name, sclass, global_env);
+
+  return sclass;
+}
+
+void objscheme_add_global_class(Scheme_Object *sclass, char *name, void *env)
+{
+  scheme_install_xc_global(name, sclass, env);
+}
+
+Scheme_Object *objscheme_find_method(Scheme_Object *obj, Scheme_Object *sclass,
+				     char *name, void **cache)
+{
+  Scheme_Object *gdata;
+
+  if (!obj)
+    return NULL;
+
+  if (*cache)
+    gdata = (Scheme_Object *)*cache;
+  else {
+    Scheme_Object *s;
+    s = scheme_intern_symbol(name);
+    gdata = scheme_get_generic_data(sclass, s);
+    *cache = (void *)gdata;
+  }
+
+  return scheme_apply_generic_data(gdata, obj, 0);
+}
+
+
+/***************************************************************************/
+
+int objscheme_istype_bool(Scheme_Object *obj, const char *stopifbad)
+{
+  return 1; /* Anything can be a boolean */
+}
+
+int objscheme_istype_number(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_INTP(obj) || SCHEME_DBLP(obj) || SCHEME_BIGNUMP(obj)
+      || SCHEME_RATIONALP(obj))
+    return 1;
+  else if (stopifbad) {
+    scheme_wrong_type(stopifbad, "number", -1, 0, &obj);
+  }
+  return 0;
+}
+
+int objscheme_istype_integer(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_INTP(obj))
+    return 1;
+  else if (stopifbad) {
+    scheme_wrong_type(stopifbad, "fixnum", -1, 0, &obj);
+  }
+  return 0;
+}
+
+int objscheme_istype_float(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_DBLP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "flonum", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_pair(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_PAIRP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "pair", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_string(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_STRINGP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "string", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_pathname(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_STRINGP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "pathname string", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_char(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_CHARP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "character", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_generic(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_generic_type))
+    return 1;
+  else if (stopifbad)
+    scheme_signal_error("expected an unknown type in %s", stopifbad);
+  return 0;
+}
+
+int objscheme_istype_closed_prim(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_closed_prim_type))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "procedure", -1, 0, &obj);
+  return 0;
+}
+
+int objscheme_istype_proc2(Scheme_Object *obj, const char *stopifbad)
+{
+  return scheme_check_proc_arity(stopifbad, 2, -1, 0, &obj);
+}
+
+int objscheme_istype_box(Scheme_Object *obj, const char *stopifbad)
+{
+  if (SCHEME_BOXP(obj))
+    return 1;
+  else if (stopifbad)
+    scheme_wrong_type(stopifbad, "box", -1, 0, &obj);
+  return 0;
+}
+
+/************************************************************************/
+
+Scheme_Object *objscheme_box(Scheme_Object *v)
+{
+  return scheme_box(v);
+}
+
+Scheme_Object *objscheme_bundle_generic(void *p)
+{
+  Scheme_Object *obj;
+
+  obj = scheme_alloc_small_object();
+  obj->type = scheme_generic_type;
+  SCHEME_PTR_VAL(obj) = (Scheme_Object *)p;
+
+  return obj;
+}
+
+Scheme_Object *objscheme_bundle_string(char *s)
+{
+  if (!s)
+    return scheme_null;
+  else
+    return scheme_make_string(s);
+}
+
+Scheme_Object *objscheme_bundle_pathname(char *s)
+{
+  return objscheme_bundle_string(s);
+}
+
+/************************************************************************/
+
+void *objscheme_unbundle_generic(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_generic(obj, where);
+  return (void *)SCHEME_PTR_VAL(obj);
+}
+
+long objscheme_unbundle_integer(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_number(obj, where);
+  if (SCHEME_DBLP(obj)) {
+    return (long)SCHEME_DBL_VAL(obj);
+  } else if (SCHEME_RATIONALP(obj)) {
+    return (long)scheme_rational_to_float(obj);
+  } else if (SCHEME_BIGNUMP(obj)) {
+    if (SCHEME_PINT_VAL(obj) < 0)
+      return -1;
+    else
+      return 1;
+  } else
+    return SCHEME_INT_VAL(obj);
+}
+
+long objscheme_unbundle_nonnegative_integer(Scheme_Object *obj, const char *where)
+{
+  long v = objscheme_unbundle_integer(obj, where);
+  if ((v < 0) && where)
+    scheme_wrong_type(where, "non-negative number", -1, 0, &obj);
+  return v;
+}
+
+double objscheme_unbundle_float(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_number(obj, where);
+  if (SCHEME_DBLP(obj))
+    return SCHEME_DBL_VAL(obj);
+  else if (SCHEME_RATIONALP(obj))
+    return scheme_rational_to_float(obj);
+  else if (SCHEME_BIGNUMP(obj))
+    return scheme_bignum_to_float(obj);
+  else
+    return (double)SCHEME_INT_VAL(obj);
+}
+
+double objscheme_unbundle_nonnegative_float(Scheme_Object *obj, const char *where)
+{
+  double v = objscheme_unbundle_float(obj, where);
+  if ((v < 0) && where)
+    scheme_wrong_type(where, "non-negative number", -1, 0, &obj);
+  return v;
+}
+
+int objscheme_unbundle_bool(Scheme_Object *obj, const char *where)
+{  
+  (void)objscheme_istype_bool(obj, where);
+  return NOT_SAME_OBJ(obj, scheme_false);
+}
+
+char *objscheme_unbundle_string(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_string(obj, where);
+  return SCHEME_STR_VAL(obj);
+}
+
+char *objscheme_unbundle_pathname(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_pathname(obj, where);
+  return scheme_expand_filename(SCHEME_STR_VAL(obj), 
+				SCHEME_STRTAG_VAL(obj),
+				(char *)where, NULL);
+}
+
+char *objscheme_unbundle_nullable_string(Scheme_Object *obj, const char *where)
+{
+  if (SCHEME_NULLP(obj))
+    return NULL;
+  else
+    return objscheme_unbundle_string(obj, where);
+}
+
+char *objscheme_unbundle_nullable_pathname(Scheme_Object *obj, const char *where)
+{
+  if (SCHEME_NULLP(obj))
+    return NULL;
+  else
+    return objscheme_unbundle_pathname(obj, where);
+}
+
+char objscheme_unbundle_char(Scheme_Object *obj, const char *where)
+{
+  (void)objscheme_istype_char(obj, where);
+  return SCHEME_CHAR_VAL(obj);
+}
+
+Scheme_Object *objscheme_car(Scheme_Object *obj, const char *where)
+{  
+  (void)objscheme_istype_pair(obj, where);
+  return scheme_car(obj);
+}
+
+Scheme_Object *objscheme_unbox(Scheme_Object *obj, const char *where)
+{  
+  (void)objscheme_istype_box(obj, where);
+  return scheme_unbox(obj);
+}
+
+/************************************************************************/
+
+void objscheme_set_car(Scheme_Object *l, Scheme_Object *v)
+{
+  Scheme_Object *p[2];
+
+  p[0] = l;
+  p[1] = v;
+
+  (void)scheme_apply(set_car_prim, 2, p);
+}
+
+void objscheme_set_box(Scheme_Object *b, Scheme_Object *v)
+{
+  (void)objscheme_istype_box(b, "set-box!");
+  SCHEME_PTR_VAL(b) = v;
+}
+
+/************************************************************************/
+
+void objscheme_note_creation(Scheme_Object *obj)
+{
+  num_objects_allocated++;
+}
+
+#define HASH(realobj) (((long)realobj >> 2) % hashsize)
+
+#define GONE ((void *)1)
+
+void objscheme_save_object(void *realobj, Scheme_Object *obj)
+{
+  int i;
+
+  if (2 * hashcount > hashsize) {
+    long oldsize = hashsize;
+    ObjectHash *old = hash;
+
+    hashsize *= 2;
+    hash = (ObjectHash *)scheme_malloc_atomic(sizeof(ObjectHash) * hashsize);
+
+    for (i = 0; i < hashsize; i++)
+      hash[i].realobj = NULL;
+
+    hashcount = 0;
+    for (i = 0; i < oldsize; i++) {
+      if (old[i].realobj && NOT_SAME_PTR(old[i].realobj, GONE))
+	objscheme_save_object(old[i].realobj, (Scheme_Object *)old[i].obj);
+    }
+  }
+
+  i = HASH(realobj);
+  if (i < 0)
+    i = -i;
+
+  while (hash[i].realobj && NOT_SAME_PTR(hash[i].realobj, GONE)) {
+    i++;
+    if (i >= hashsize)
+      i = 0;
+  }
+
+  hash[i].realobj = realobj;
+  hash[i].obj = (Scheme_Class_Object *)obj;
+
+  hashcount++;
+}
+
+Scheme_Class_Object *objscheme_find_object(void *realobj)
+{
+  int i;
+
+  i = HASH(realobj);
+  if (i < 0)
+    i = -i;
+
+  while (NOT_SAME_PTR(hash[i].realobj, realobj) || SAME_PTR(hash[i].realobj, GONE)) {
+    if (!hash[i].realobj)
+      return NULL;
+    i++;
+    if (i >= hashsize)
+      i = 0;
+  }
+
+  return hash[i].obj;
+}
+
+void objscheme_check_valid(Scheme_Object *o)
+{
+  Scheme_Class_Object *obj = (Scheme_Class_Object *)o;
+
+  if (obj->primflag < 0) {
+    int len;
+    const char *classname = scheme_get_class_name(obj->sclass, &len);
+    scheme_signal_error("attempt to use an %sobject%s (class %s)",
+			(obj->primflag == -2) ? "" : "invalidated ",
+			(obj->primflag == -2) ? " shutdown by custodian" : "",
+			classname ? classname : "unknown");
+  }
+  if (!obj->inited) {
+    int len;
+    const char *classname = scheme_get_class_name(obj->sclass, &len);
+    scheme_signal_error("attempt to use an uninitialized object (class %s)",
+			classname ? classname : "unknown");
+  }
+}
+
+void objscheme_destroy(void *realobj, Scheme_Object *obj_in)
+{
+  int i;
+  Scheme_Class_Object *obj;
+
+  --num_objects_allocated;
+
+  obj = (Scheme_Class_Object *)obj_in;
+
+  if (!obj) {
+    i = HASH(realobj);
+    if (i < 0)
+      i = -i;
+    
+    while (NOT_SAME_PTR(hash[i].realobj, realobj) 
+	   || SAME_PTR(hash[i].realobj, GONE)) {
+      if (!hash[i].realobj)
+	break;
+      i++;
+      if (i >= hashsize)
+	i = 0;
+    }
+    
+    if (hash[i].realobj) {
+      obj = hash[i].obj;
+      hash[i].realobj = GONE;
+    }
+  }
+
+  if (obj) {
+    if (obj->primflag < 0)
+      return;
+
+    obj->primflag = -1;
+    obj->primdata = NULL;
+  }
+}
+
+void objscheme_backpointer(void *obj)
+{
+}
+
+void objscheme_register_primpointer(void *prim_ptr_address)
+{
+  GC_general_register_disappearing_link((void **)prim_ptr_address, NULL);
+}
+
+/***************************************************************/
+
+void objscheme_install_bundler(Objscheme_Bundler f, long id)
+{
+  long i;
+
+  i = id % bhashsize;
+  while(bhash[i].id && bhash[i].id != id) {
+    i = (i + bhashstep) % bhashsize;
+  }
+
+  bhash[i].id = id;
+  bhash[i].f = f;
+  bhashcount++;
+}
+
+Scheme_Object *objscheme_bundle_by_type(void *realobj, long id)
+{
+  long i;
+
+  i = id % bhashsize;
+  while(bhash[i].id && bhash[i].id != id) {
+    i = (i + bhashstep) % bhashsize;
+  }
+
+  if (!bhash[i].id)
+    return NULL;
+
+  return bhash[i].f(realobj);
+}
+
+/************************************************************************/
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+void gc_mark_external_invalid(void *sobj)
+{
+  Scheme_Class_Object *obj = (Scheme_Class_Object *)sobj;
+
+  obj->primflag = -1;
+  obj->primdata = NULL;  
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/src/mzscheme/utils/xcglue.h b/src/mzscheme/utils/xcglue.h
new file mode 100644
index 0000000..2c706d9
--- /dev/null
+++ b/src/mzscheme/utils/xcglue.h
@@ -0,0 +1,142 @@
+
+#ifndef OBJ_SCHEME_H
+#define OBJ_SCHEME_H
+
+#include "scheme.h"
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+/******************************************************************/
+/*                   Utilites used by xctocc                      */
+/******************************************************************/
+
+void objscheme_init(Scheme_Env *env);
+
+void scheme_install_xc_global(char *name, Scheme_Object *val, void *env);
+Scheme_Object *scheme_lookup_xc_global(char *name, void *env);
+
+/* Defining a primitive class: */
+Scheme_Object *
+objscheme_def_prim_class(void *env, char *name, char *superclass,
+			 Scheme_Method_Prim *initf, int nmethods);
+void objscheme_add_global_class(Scheme_Object *sclass, char *name,
+				void *env);
+
+void objscheme_note_creation(Scheme_Object *obj);
+
+/* Maintaining the Scheme - C++ connection */
+void objscheme_save_object(void *, Scheme_Object *);
+Scheme_Class_Object *objscheme_find_object(void *);
+void objscheme_check_valid(Scheme_Object *);
+
+void objscheme_backpointer(void *obj_ptr_address);
+void objscheme_register_primpointer(void *prim_ptr_address);
+
+void objscheme_destroy(void *, Scheme_Object *obj);
+
+/* Finding a method: */
+Scheme_Object *objscheme_find_method(Scheme_Object *obj, 
+				     Scheme_Object *sclass,
+				     char *name, 
+				     void **cache);
+
+/* Checking a class relationship */
+#define objscheme_is_subclass scheme_is_subclass
+
+void objscheme_set_car(Scheme_Object *, Scheme_Object *);
+Scheme_Object *objscheme_unbox(Scheme_Object *, const char *where);
+Scheme_Object *objscheme_box(Scheme_Object *);
+void objscheme_set_box(Scheme_Object *, Scheme_Object *);
+
+int objscheme_istype_bool(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_number(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_integer(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_float(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_pair(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_string(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_pathname(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_char(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_generic(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_closed_prim(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_proc2(Scheme_Object *, const char *stopifbad);
+int objscheme_istype_box(Scheme_Object *, const char *stopifbad);
+
+Scheme_Object *objscheme_car(Scheme_Object *, const char *where);
+Scheme_Object *objscheme_bundle_string(char *);
+Scheme_Object *objscheme_bundle_pathname(char *);
+Scheme_Object *objscheme_bundle_generic(void *);
+
+void *objscheme_unbundle_generic(Scheme_Object *, const char *);
+long objscheme_unbundle_integer(Scheme_Object *, const char *);
+long objscheme_unbundle_nonnegative_integer(Scheme_Object *, const char *);
+double objscheme_unbundle_float(Scheme_Object *, const char *);
+double objscheme_unbundle_nonnegative_float(Scheme_Object *, const char *);
+int objscheme_unbundle_bool(Scheme_Object *, const char *);
+char *objscheme_unbundle_string(Scheme_Object *, const char *);
+char *objscheme_unbundle_nullable_string(Scheme_Object *, const char *);
+char *objscheme_unbundle_pathname(Scheme_Object *, const char *);
+char *objscheme_unbundle_nullable_pathname(Scheme_Object *, const char *);
+char objscheme_unbundle_char(Scheme_Object *, const char *);
+
+#define objscheme_bundle_integer scheme_make_integer
+#define objscheme_bundle_long objscheme_bundle_integer
+#define objscheme_bundle_int objscheme_bundle_integer
+#define objscheme_bundle_float scheme_make_double
+#define objscheme_bundle_bool(x) ((x) ? scheme_true : scheme_false)
+#define objscheme_bundle_char scheme_make_char
+#define objscheme_bundle_pair scheme_make_pair
+
+#define objscheme_bundle_double objscheme_bundle_float
+#define objscheme_unbundle_double objscheme_unbundle_float
+
+#define objscheme_unbundle_long objscheme_unbundle_integer
+#define objscheme_unbundle_int objscheme_unbundle_integer
+
+/* #define OBJSCHEME_PRIM_METHOD(m) SCHEME_CLSD_PRIMP(m) */
+#define OBJSCHEME_PRIM_METHOD(m) 0
+
+#ifndef WXS_CANT_ASSIGN_STRUCTURES
+#define COPY_JMPBUF(dest, src) (dest = src)
+#else
+#define COPY_JMPBUF(dest, src) memcpy(&dest, &src, sizeof(jmp_buf));
+#endif
+
+
+typedef Scheme_Object *(*Objscheme_Bundler)(void *);
+void objscheme_install_bundler(Objscheme_Bundler f, long id);
+Scheme_Object *objscheme_bundle_by_type(void *realobj, long type);
+
+#ifndef _MSC_VER
+typedef char byte;
+#endif
+typedef unsigned char ubyte;
+
+typedef char *xc_string;
+#define string xc_string
+typedef const unsigned char *custring, *ncustring; 
+typedef const char *cstring, *ncstring; 
+typedef char *nstring;
+typedef unsigned char *ustring, *nustring;
+
+typedef char *pathname;
+typedef char *npathname;
+typedef const char *cpathname;
+typedef const char *cnpathname;
+
+typedef int nnint;
+typedef float nnfloat;
+
+#ifdef __GNUG__
+#define WXS_USE_ARGUMENT(x) x = x; /* compiler optimizes it away */
+#else
+#define WXS_USE_ARGUMENT(x) 
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/src/mzscheme/utils/xctocc b/src/mzscheme/utils/xctocc
new file mode 100755
index 0000000..35877d5
--- /dev/null
+++ b/src/mzscheme/utils/xctocc
@@ -0,0 +1,1868 @@
+#!/usr/local/bin/perl
+
+# Copyright (c) 1995 Matthew Flatt
+
+# This file reads C++ class descriptsions from files ending in ".xc".
+# It produces a C++ file suitable for linking with libscheme plus
+# objscheme.cc.
+
+# See xctocc.dvi for information about using this program.
+
+# SORRY, SORRY, SORRY, SORRY, SORRY, SORRY, SORRY, SORRY, SORRY, SORRY.
+# No one should write code like this. It's horrible. It's immoral.
+#
+# Still, it works well enough for now.
+
+# Get the directory where this file is, and add to include path:
+{$0 =~ /^(.*)\/.*$/;  $my_dir = $1; 
+ if ($my_dir !~ ?^/?) {
+     open(DIRNAME, "pwd | ");
+     $pwd = <DIRNAME>;
+     close(DIRNAME);
+     chop($pwd);
+     $my_dir = $pwd . "/" . $my_dir;}
+ if ($my_dir =~ ?/$?) {chop ($my_dir);}}
+push(@INC, $my_dir);
+
+require "parse.pl";
+require "common.pl";
+
+$cc_suffix = "cc";
+
+if ($ARGV[0] eq '-cxx') {
+    $cc_suffix = "cxx";
+    shift(@ARGV);
+}
+
+$file = $infile = $ARGV[0];
+
+if ($file =~ s/.xc$//) {
+} else {
+    print STDERR "Bad extension \"$infile\".\n";
+    exit 1;
+}
+
+if (!open(IN, "$file.xc")) {
+    print STDERR "Couldn't open \"${file}.xc\"\n";
+    exit 1;
+}
+
+if (!open(OUT, ">${file}.${cc_suffix}")) {
+    print STDERR "Couldn't write \"${file}.${cc_suffix}\"\n";
+    exit 1;
+}
+
+if (!open(HEADER, ">${file}.h")) {
+    print STDERR "Couldn't write \"${file}.h\"\n";
+    exit 1;
+}
+
+$setup_d_start = "#ifndef WXS_SETUP_ONLY\n";
+$setup_d_end = "#endif\n";
+
+print HEADER $setup_d_start;
+
+select(OUT);
+
+$base = '';
+
+$dummyfields = " \"initialization\" : x create";
+$scheme_args = "Scheme_Object *obj, int n,  Scheme_Object *p[]";
+$global_scheme_args = "int n,  Scheme_Object *p[]";
+
+print "/* DO NOT EDIT THIS FILE. */\n";
+print "/* This file was generated by xctocc from \"${file}.xc\". */\n\n";
+
+@common_names = ();
+if (open(COMMONL, "common.txt")) {
+    while(<COMMONL>) {
+	chop;
+	push(@common_names, $_);
+    }
+    close(COMMONL);
+}
+
+$thisfile = "$file.xc";
+&ReadFile();
+
+print HEADER $setup_d_end;
+
+close(IN);
+close(OUT);
+close(HEADER);
+
+sub IgnoreLine
+{
+    print $_[0];
+}
+
+sub PrintHeader
+{
+    print "#include \"wxscheme.h\"\n";
+    print "#include \"${file}.h\"\n";
+    print "#include \"wxscomon.h\"\n";
+    print "\n";
+}
+
+sub PrintDefine
+{
+    print $_[0];
+}
+
+sub DoPrintClass 
+{
+
+    if ($common) {
+	if (!open(COMMONL, ">common.txt")) {
+	    print STDERR "Couldn't write \"common.txt\"\n";
+	    exit 1;
+	}
+    }
+
+    if (!$global && !$common) {
+	$globalname = "";
+
+	print "class ${newclass} : public ${oldclass} {\n";
+	print " public:\n";
+	# print "  Scheme_Object *obj;\n";
+	foreach $var (@vars) {
+	    print "  $var\n";
+	}
+
+	print "\n";
+
+	# Print creation prototypes:
+	if ($#creators >= 0) {
+	    foreach $creator (@creators) {
+		&ReadFields($dummyfields . $creator);
+		print "  ${newclass}(Scheme_Object * obj";
+		print ", " if ($#paramtypes >= 0);
+		&PrintParams(1);
+		print ");\n";
+	    }
+	}
+
+	# destruction
+	print "  ~${newclass}();\n"
+    } else {
+	$newclass = "";
+
+	select(HEADER);
+    }
+
+    # Print method prototypes
+    if (!$global && !$common) {
+	$pos = 0;
+	foreach $function (@functions) {
+	    if (!&Overridden($function, $pos)) {
+		&ReadFields($function);
+		if ($virtual) {
+		    &OIStart;
+		    print "  " . &NormalType($returntype) 
+			. " ${globalname}${func}(";
+		    &PrintParams(1);
+		    print ");\n";
+		    &OIEnd;
+		}
+	    }
+	    $pos += 1;
+	}
+    }
+
+    if (!$global && !$common) {
+	print "};\n\n";
+	# End of class definition
+    } else {
+	select(OUT);
+    }
+
+    if (!$global && !$common) {
+	print "Scheme_Object *${newclass}_class;\n\n";
+	
+	#Do creation methods
+	if ($#creators >= 0) {
+	    foreach $creator (@creators) {
+		&ReadFields($dummyfields . $creator);
+		&OIStart;
+		print "${newclass}::${newclass}(Scheme_Object * o";
+		print ", " if ($#paramtypes >= 0);
+		&PrintParams(0);
+		print ")\n";
+		print ": ${oldclass}(";
+		&PrintArgs(1);
+		print ")\n";
+		print "{\n";
+		print "  __gc_external = (void *)o;\n";
+		print "  objscheme_backpointer(&__gc_external);\n";
+		# print "  objscheme_save_object(this, o);\n";
+		print "  objscheme_note_creation(o);\n";
+		print "}\n";
+		&OIEnd;
+		print "\n";
+	    }
+	}
+
+	# destruction
+	print "${newclass}::~${newclass}()\n{\n  ";
+	print "  objscheme_destroy(this, (Scheme_Object *)__gc_external);\n}\n\n";
+    }
+
+    #Do regular methods
+    @funcs = ();
+    $pos = 0;
+    foreach $function (@functions) {
+	if (!&Overridden($function, $pos)) {
+	    &PrintMethod($function);
+	    @l = grep($_ =~ /^$func$/, @funcs);
+	    if ($#l < $[) {
+		@funcs = (@funcs, $func);
+	    }
+	}
+	$pos += 1;
+    }
+
+    ##Regular glue code
+
+    foreach $func (@funcs) {
+	&PrintFunction($func);
+    }
+    
+    foreach $ivar (@ivars) {
+	&ReadIvarFields($ivar);
+	&OIStart;
+	print "static Scheme_Object *objscheme_${oldclass}_Get${ivarname}(";
+	print $scheme_args;
+	print ")\n{\n  ";
+	print "Scheme_Class_Object *cobj;\n  ";
+	print &NormalType($ivartype, 1) . " v;\n\n";
+	print "  objscheme_check_valid(obj);\n";
+	print "  if (n) scheme_wrong_count($getname, 0, 0, n, p);\n";
+	print "  cobj = (Scheme_Class_Object *)obj;\n";
+	print "  if (cobj->primflag)\n";
+	print "    v = ";
+	&PrintIndirect($ivartype);
+	print "(($newclass *)cobj->primdata)->${oldclass}::${ivarname}";
+	print ";\n  else\n    v = ";
+	&PrintIndirect($ivartype);
+	print "(($oldclass *)cobj->primdata)->${ivarname}";
+
+	print ";\n\n  return ";
+	&PrintBundleVar("v", $ivartype, '', 1);
+	print ";\n}\n";
+
+	if (!$readonly) {
+	    print "\nstatic Scheme_Object *objscheme_${oldclass}_Set${ivarname}(";
+	    print $scheme_args;
+	    print ")\n{\n  ";
+	    print "objscheme_check_valid(obj);\n  ";
+	    print "Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;\n  ";
+	    print &NormalType($ivartype, 1) . " v;\n\n";
+	    print "  if (n != 1) scheme_wrong_count($setname, 1, 1, n, p);\n\n";
+	    print "  v = ";
+	    &PrintUnbundleVar("p[0]", $ivartype);
+	    print ";\n  ";
+	    if (substr($ivartype, -1) eq '%' || substr($ivartype, -1) eq '&') {
+		print "memcpy(";
+		print "&(($oldclass *)cobj->primdata)->${ivarname}";
+		print ", v, sizeof(*v));\n";
+	    } else {
+		print "(($oldclass *)cobj->primdata)->${ivarname}";
+		print " = v;\n\n";
+	    }
+	    print "  return scheme_void;\n}\n";
+	}
+	&OIEnd;
+	print "\n";
+    }
+
+    ## General glue code
+
+    if (!$global && !$common) {
+	# Init function
+	if ($#creators >= 0) {
+	    @savefunctions = @functions;
+	    @savefuncnames = @funcnames;
+	    @functions = ();
+	    @funcnames = ();
+	    foreach $creator (@creators) {
+		$function = $dummyfields . $creator;
+		@functions = (@functions, $function);
+		@funcnames = (@funcnames, "create");
+	    }
+	    &PrintFunction("create", 1);
+	    @functions = @savefunctions;
+	    @funcnames = @savefuncnames;
+	}
+
+	# Destroy function
+	if (0) {
+	    print "static Scheme_Object *objscheme_destroy_${newclass}(";
+	    print $scheme_args;
+	    print ")\n{\n";
+	    print "  Scheme_Class_Object *cobj=(Scheme_Class_Object *)obj;\n";
+	    print "  if (n) scheme_signal_error(\"";
+	    print "destroy: method takes no arguments";
+	    print "\");\n";
+	    print "  if (cobj->primflag > 1) return scheme_void;\n";
+	    print "  if (cobj->primflag) {\n";
+	    print "    cobj->primflag = 2;\n\n";
+	    print "    delete (${newclass} *)(cobj->primdata);\n";
+	    print "  } else\n";
+	    print "    delete (${oldclass} *)(cobj->primdata);\n";
+	    print "\n";
+	    print "  cobj->primflag = -1;\n\n";
+	    print "  return scheme_void;\n}\n\n";
+	}
+	
+	# Class Name function
+	print "static Scheme_Object *objscheme_classname_${newclass}(";
+	print $scheme_args;
+	print ")\n{\n";
+	print " WXS_USE_ARGUMENT(obj);\n";
+	print "  if (n) scheme_wrong_count(${classstring} \"::get-class-name\", ";
+	print "0, 0, n, p);\n";
+	print "  return scheme_intern_symbol(${classstring});\n";
+	print "}\n\n";
+    }
+
+    # Setup function
+    if (!$global && !$common) {
+	$proto = "void objscheme_setup_${oldclass}(void *env)";
+        print HEADER $setup_d_end;
+	print HEADER "$proto;\n";
+	print HEADER $setup_d_start;
+	print "$proto\n{\n";
+	
+	if (1) {
+	    print "if (${newclass}_class) {\n";
+	    print "    objscheme_add_global_class(${newclass}_class, ";
+	    print " ${classstring}, env);\n";
+	    print "} else {\n";
+	}
+
+	# Count methods to be installed:
+	@funcs = ();
+	$nmethod = 1; # count get-class-name, first
+	foreach $function (@functions) {
+	    &ReadFields($function);
+	    @l = grep($_ =~ /^$func$/, @funcs);
+	    if ($#l < $[) {
+		@funcs = (@funcs, $func);
+		$nmethod += 1;
+	    }
+	}
+	foreach $ivar (@ivars) {
+	    &ReadIvarFields($ivar);
+	    $nmethod += 1;
+	    if (!$readonly) {
+		$nmethod += 1;
+	    }
+	}
+
+	# Create class:
+	print "  ${newclass}_class = objscheme_def_prim_class(env, ";
+	print "${classstring}, ";
+	if ($parentstring ne '') {
+	    print "${parentstring}";
+	} else {
+	    print "NULL";
+	}
+	print ", ";
+	if ($#creators >= 0) {
+	    print "${newclass}_ConstructScheme";
+	} else {
+	    print "NULL";
+	}
+	print ", ${nmethod})";
+	print ";\n\n";
+
+	# print "  scheme_add_method(${newclass}_class, ";
+	# print "\"destroy\", objscheme_destroy_${newclass});\n\n";
+
+	print "  scheme_add_method_w_arity(${newclass}_class,";
+	print "\"get-class-name\",objscheme_classname_${newclass}, 0, 0);\n\n";
+
+	@funcs = ();
+	foreach $function (@functions) {
+	    &ReadFields($function);
+	    @l = grep($_ =~ /^$func$/, @funcs);
+	    if ($#l < $[) {
+		@funcs = (@funcs, $func);
+		if (!$delegate) {
+		    &OIStart;
+		    if ($justoneok{$func}) {
+			print " scheme_add_method_w_arity";
+		    } else {
+			print " scheme_add_method";
+		    }
+		    print "(${newclass}_class, ";
+		    $cleanfunc = $func;
+		    $cleanfunc = &OperatorClean($cleanfunc);
+		    print "${fname}, ${newclass}${cleanfunc}";
+		    if ($justoneok{$func}) {
+			print ", ";
+			print $justonemin{$func};
+			print ", ";
+			print $justonemax{$func};
+		    }
+		    print ");\n";
+		    &OIEnd;
+		}
+	    }
+	}
+	
+	print "\n";
+
+	foreach $ivar (@ivars) {
+	    &ReadIvarFields($ivar);
+	    &OIStart;
+	    print "  scheme_add_method_w_arity(${newclass}_class,";
+	    print "${getname}, objscheme_${oldclass}_Get${ivarname}, 0, 0);\n";
+	    if (!$readonly) {
+		print "  scheme_add_method_w_arity(${newclass}_class,";
+		print "${setname}, objscheme_${oldclass}_Set${ivarname}, 1, 1);\n";
+	    }
+	    &OIEnd;
+	}
+
+	print "\n";
+
+	print "  scheme_made_class(${newclass}_class);\n\n";
+
+	if ($idfield ne '' && $classid ne '') {
+	    print "  objscheme_install_bundler(";
+	    print "(Objscheme_Bundler)objscheme_bundle_";
+	    print "${oldclass}, ${classid});\n"
+	}
+
+	print "\n";
+	if (1) {
+	    print "}\n";
+	}
+    } elsif (!$common) {
+	$proto = "void objscheme_setup_${globalname}(void *env)";
+        print HEADER $setup_d_end;
+	print HEADER "$proto;\n";
+        print HEADER $setup_d_start;
+	print "$proto\n{\n";
+	@funcs = ();
+	foreach $function (@functions) {
+	    &ReadFields($function);
+	    @l = grep($_ =~ /^$func$/, @funcs);
+	    if ($#l < $[) {
+		@funcs = (@funcs, $func);
+		&OIStart;
+		print "  scheme_install_xc_global(${fname},";
+		if ($justoneok{$func}) {
+		    print " scheme_make_prim_w_arity";
+		} else {
+		    print " scheme_make_prim";
+		}
+		print "(${globalname}${func}";
+		if ($justoneok{$func}) {
+		    print ", ${fname}, ";
+		    print $justonemin{$func};
+		    print ", ";
+		    print $justonemax{$func};
+		}
+		print ")";
+		print ", env);\n";
+		&OIEnd;
+	    }
+	}
+    }
+
+    foreach $constant (@constants) {
+	&ReadConstFields($constant);
+	&OIStart;
+	print "  scheme_install_xc_global(${const}, ";
+	&PrintBundleVar($cname, $ctype);
+	print ", env);\n";
+	&OIEnd;
+    }
+
+    if (!$common) {
+	print "}\n\n";
+    }
+
+    if (!$global && !$common) {
+	$proto="int objscheme_istype_${oldclass}"
+	    . "(Scheme_Object *obj, const char *stop, int nullOK)";
+	print HEADER "$proto;\n";
+	print "$proto\n";
+	print "{\n";
+	print "  if (nullOK && SCHEME_NULLP(obj)) return 1;\n";
+	print "  if (SAME_TYPE(SCHEME_TYPE(obj), scheme_object_type)\n";
+	print "      && scheme_is_subclass(";
+	print "((Scheme_Class_Object *)obj)->sclass,";
+	print "          ${newclass}_class))\n";
+	print "    return 1;\n";
+	print "  else {\n";
+	print "    if (!stop)\n";
+	print "       return 0;\n";
+	$cs = &Unquote($classstring, 1);
+	print "    scheme_wrong_type(stop, \"$cs\", -1, 0, &obj);\n";
+	print "    return 0;\n";
+	print "  }\n";
+	print "}\n\n";
+	
+	# Bundle function
+	$proto="Scheme_Object *objscheme_bundle_${oldclass}"
+	    . "(class ${oldclass} *realobj)";
+	print HEADER "$proto;\n";
+	print "$proto\n";
+	print "{\n  Scheme_Class_Object *obj;\n  Scheme_Object *sobj;\n\n";
+	print "  if (!realobj) return scheme_null;\n\n";
+	print "  if (realobj->__gc_external)\n";
+	print "    return (Scheme_Object *)realobj->__gc_external;\n";
+	if ($idfield ne '') {
+	    print "  if (";
+	    if ($classid ne '') {
+		print "(realobj->${idfield} != ${classid}) && ";
+	    }
+	    print "(sobj = objscheme_bundle_by_type(realobj, ";
+	    print "realobj->${idfield})))\n";
+	    print "    return sobj;\n";
+	}
+	print "  obj = (Scheme_Class_Object *)";
+	print "scheme_make_uninited_object(${newclass}_class);\n\n";
+	print "  obj->primdata = realobj;\n";
+	print "  objscheme_register_primpointer(&obj->primdata);\n";
+	print "  obj->primflag = 0;\n\n";
+	print "  realobj->__gc_external = (void *)obj;\n";
+	print "  objscheme_backpointer(&realobj->__gc_external);\n";
+	# print "  objscheme_note_creation((Scheme_Object *)obj);\n";
+	print "  return (Scheme_Object *)obj;\n}\n\n";
+
+	# Unbundle function
+	$proto = "class ${oldclass} *objscheme_unbundle_${oldclass}"
+	    . "(Scheme_Object *obj, const char *where, int nullOK)";
+	print HEADER "$proto;\n";
+	print "$proto\n";
+	print "{\n";
+	print "  if (nullOK && SCHEME_NULLP(obj)) return NULL;\n\n";
+	print "  (void)objscheme_istype_${oldclass}(obj, where, nullOK);\n";
+
+	print "  Scheme_Class_Object *o = ";
+	print "(Scheme_Class_Object *)obj;\n";
+
+	print "  objscheme_check_valid(obj);\n";
+	print "  if (o->primflag)\n";
+	print "    return (${newclass} *)o->primdata;\n";
+	print "  else\n";
+	print "    return (${oldclass} *)o->primdata;\n";
+	print "}\n\n";
+    }
+
+    if ($common) {
+	close(COMMONL);
+    }
+}
+
+sub CalcNumRequired
+{
+    local($forscheme) = @_;
+
+    $paramnum = 0;
+    @defvs = @defvals;
+    @scms = @schemes;
+    foreach $paramtype (@paramtypes) {
+	$defval = shift(@defvs);
+	$scheme = shift(@scms);
+	if (($defval ne '') && ($defval ne '.')) {
+	    return $paramnum;
+	}
+	if (!$forscheme || $scheme) {
+	    $paramnum += 1;
+	}
+    }
+    return $paramnum;
+}
+
+sub CalcNumPossible
+{
+    local($forscheme) = @_;
+    local($offset);
+
+    $offset = 0;
+    if ($forscheme) {
+	foreach $scheme (@schemes) {
+	    $offset += 1 if (!$scheme);
+	}
+    }
+
+    return $#paramtypes + 1 - $offset;
+}
+
+sub PrintFailureHandling
+{
+    local($callback) = @_;
+
+    if (($exception eq 'SUPER') && !$virtualonly) {
+	print "return " if ($returntype ne 'void');
+	if ($common) {
+	    print "f(real_obj";
+	    if ($#paramtypes >= 0) {
+		print ", ";
+	    }
+	} else {
+	    if ($common) {
+		print "f(";
+	    } else {
+		if ($callback) {
+		    print "obj->";
+		}
+		print "${oldclass}::${func}(";
+	    }
+	}
+	&PrintArgs(1);
+	print ");";
+    } elsif ($exception ne '' && $exception ne 'SUPER') {
+	print &ApplyMacros($exception);
+    } else {
+	print "return;";
+    }
+}
+
+sub PrintMethod
+{
+    ($s) = @_;
+
+    &ReadFields($s);
+
+    $save_onlyif = $onlyif;
+
+    $common_name = &MakeCommonName();
+
+    if (!$common) {
+	@l = grep($_ =~ /^$common_name$/, @common_names);
+	if ($#l >= $[) {
+	    $use_common = 1;
+	} else {
+	    $use_common = 0;
+	}
+
+	if ($use_common) {
+	    # Print callback for Scheme-based calls. This will be used
+	    # by PrintSpecificFunction
+	    print "static ";
+	    print &NormalType($returntype);
+	    $func2 = $func;
+	    $func2 = &OperatorClean($func2);
+	    print " ${newclass}_${func2}_${common_name}_Scb(";
+	    print "Scheme_Object *obj";
+	    if ($#paramtypes >= 0) {
+		print",";
+	    }
+	    &PrintParams(0);
+	    print "){\n";
+	    &PrintCallRealMethod("", "return ", 1);
+	    print "\n}\n\n";
+	}
+    }
+
+    if ($global || (!$virtual && !$common)) {
+	return;
+    }
+
+    &OIStart;
+
+    # Define Class function
+    # 
+    if ($common) {
+	$methodfuncname = $common_name;
+	print COMMONL "$common_name\n";
+    } else {
+	$methodfuncname = "${newclass}::${func}";
+	
+
+	if ($use_common) {
+	    # print callback function
+	    print "static ";
+	    print &NormalType($returntype);
+	    print " ${newclass}_${func}_cb(${newclass} *obj";
+	    if ($#paramtypes >= 0) {
+		print",";
+	    }
+	    &PrintParams(0);
+	    print ") {\n";
+	    &PrintFailureHandling(1);
+	    print "\n}\n\n";
+	}
+    }
+
+    print &NormalType($returntype) . " ${methodfuncname}(";
+    
+    if ($common) {
+	select(HEADER);
+
+	print "typedef ";
+	print &NormalType($returntype);
+	print " (*";
+	print "${methodfuncname}_ftype";
+	print ")(void *";
+	if ($#paramtypes >= 0) {
+	    print",";
+	}
+	&PrintParams(0);
+	print ");\n";
+
+	print "typedef ";
+	print &NormalType($returntype);
+	print " (*";
+	print "${methodfuncname}_Sftype";
+	print ")(Scheme_Object *";
+	if ($#paramtypes >= 0) {
+	    print",";
+	}
+	&PrintParams(0);
+	print ");\n";
+
+	print &NormalType($returntype) . " ${methodfuncname}(";
+	print "void *, Scheme_Object *, char *,";
+	print "${methodfuncname}_ftype f";
+	if ($#paramtypes >= 0) {
+	    print",";
+	}
+	&PrintParams(0);
+	print ");\n";
+
+	print &NormalType($returntype) . " ${methodfuncname}_Scheme(";
+	print "${methodfuncname}_Sftype, char *, Scheme_Object *, int, ";
+	print "Scheme_Object **, int";
+	if ($#paramtypes >= 0) {
+	    print",";
+	}
+	&PrintParams(0, 'd', 1);
+	print ");\n";
+
+	select(OUT);
+
+	print "void *real_obj, Scheme_Object *obj, char *name,\n";
+	print "${methodfuncname}_ftype f";
+	if ($#paramtypes >= 0) {
+	    print",\n";
+	}
+    }
+
+    &PrintParams(0);
+    $pcount = $paramnum;
+
+    print ")\n";
+    print "{\n";
+    
+    if ($hidden) {
+	 print "}\n\n";
+	 return;
+    }
+
+    if (!$common) {
+	if ($use_common) {
+	    if ($returntype ne 'void') {
+		print "return ";
+	    }
+	    print "$common_name((void *)this, (Scheme_Object *)__gc_external, $fname, ";
+	    print "(${common_name}_ftype)${newclass}_${func}_cb";
+	    if ($#paramtypes >= 0) {
+		print", ";
+	    }
+	    &PrintArgs(1);
+	    print ");\n}\n\n";
+	    
+	    return;
+	}
+    }
+
+    # Local variables
+    if ($numschemes > 0) {
+	print "  Scheme_Object *p[${numschemes}];\n";
+    } else {
+	print "  Scheme_Object **p = NULL;\n";
+    }
+    print "  Scheme_Object *v;\n  jmp_buf savebuf;\n";
+    print "  Scheme_Object *method;\n  int sj;\n";
+    print "  static void *mcache = 0;\n\n";
+
+    print "  method = objscheme_find_method((Scheme_Object *)__gc_external, ";
+    if ($common) {
+	print "NULL, ";
+    } else {
+	print "${newclass}_class, ";
+    }
+    if ($common) {
+	print "name";
+    } else {
+	print $fname;
+    }
+    print ", &mcache);\n";
+    print "  if (method && !OBJSCHEME_PRIM_METHOD(method)) {\n";
+    print "    COPY_JMPBUF(savebuf, scheme_error_buf);\n";
+    print "    sj = scheme_setjmp(scheme_error_buf);\n";
+    print "  } else sj = 1;\n";
+    print "  if (sj) {\n";
+
+    print "    if (method && !OBJSCHEME_PRIM_METHOD(method))\n";
+    print "      COPY_JMPBUF(scheme_error_buf, savebuf);\n    ";
+    
+    &PrintFailureHandling();
+
+    print "\n  } else {\n";
+    
+    print "  " . &ApplyMacros($methpre) . "\n";
+
+    # Setup param array:
+    $paramnum = 0;
+    $offset = 0;
+    @bunds = @bundles;
+    @scms = @schemes;
+    foreach $paramtype (@paramtypes) {
+	$bundle = shift(@bunds);
+	$scheme = shift(@scms);
+
+	if ($scheme) {
+	    print "  p[${paramnum}] = ";
+	    $var = "x" . ($paramnum + $offset);
+
+	    &PrintBundleVar($var, $paramtype, $bundle);
+	    
+	    print ";\n";
+
+	    $paramnum += 1;
+	} else {
+	    $offset += 1;
+	}
+    }
+
+    print "  " . &ApplyMacros($methprecall) . "\n";
+
+    print "\n  v = scheme_apply(";
+    print "method, ";
+    print "${numschemes}, p);\n";
+
+    print "  " . &ApplyMacros($methpostcall) . "\n";
+
+    &PrintUnbundledEffects();
+
+    print "  " . &ApplyMacros($methpost) . "\n";
+
+    print "  COPY_JMPBUF(scheme_error_buf, savebuf);\n\n";
+    
+    if ($returntype ne 'void') {
+	print "  return ";
+	&PrintUnbundleVar("v", $returntype, $returnunbundle, 1, &GetMethod(1) . "\", extracting return value\"");
+	print ";\n";
+    }
+    print "  }\n}\n";
+
+    $onlyif = $save_onlyif;
+    &OIEnd;
+    print "\n";
+}
+
+sub PrintFunction 
+{
+    ($thefunc, $iscreator) = @_;
+
+    # Define Scheme callback
+    #
+
+    $numfuncs = 0;
+    $thisfuncs = ();
+    $fp = 0;
+    foreach $func (@funcnames) {
+	if ($thefunc eq $func) {
+	    $function = $functions[$fp];
+	    &ReadFields($function);
+	    if ($numfuncs > 0) {
+		$thefunction = $function;
+		@argtypes = @schemeparams;
+		@argtypeids = @typeids;
+		$numposs = &CalcNumRequired(1);
+		$found = 1;
+		$argpos = 0;
+		$foundpos = 0;
+		$foundlen = $numfuncs; 
+		while ($found && ($argpos < $numposs)) {
+		    $found = 0;
+		    $checkid = ($argtypeids[$argpos] ne '');
+		    foreach $pos (0..($foundlen - 1)) {
+			&ReadFields($thisfuncs[$pos + $foundpos]);
+			$numposs2 = &CalcNumRequired(1);
+			if ($numposs2 > $argpos
+			    && (($checkid &&
+				 ($typeids[$argpos] eq $argtypeids[$argpos]))
+				|| ($schemeparams[$argpos] 
+				    eq $argtypes[$argpos]))) {
+			    if ($found) {
+				$foundlen += 1;
+			    } else {
+				$foundpos = $pos + $foundpos;
+				$foundlen = 1;
+				$found = 1;
+			    }
+			}
+		    }
+		    $argpos += 1;
+		}
+		if (!$found) {
+		    $foundlen = 0;
+		} elsif ($argpos >= $numposs) {
+		    &ReadFields($thisfuncs[$foundpos]);
+		    $numposs2 = &CalcNumRequired(1);
+		    if ($numposs2 == $numposs) {
+			$foundlen = -1;
+			$thisfuncs[$foundpos] = $thefunction;
+		    }
+		}
+		if ($foundlen >= 0) {
+		    splice(@thisfuncs, $foundpos+$foundlen, 0, $thefunction);
+		    $numfuncs += 1;
+		}
+	    } else {
+		$numfuncs = 1;
+		$thisfuncs[0] = $function;
+	    }
+	}
+	$fp += 1;
+    }
+
+    &ReadFields($thisfuncs[0]);
+
+    if ($delegate) {
+	return; # Superclass will dispatch for us
+    }
+
+    if ($numfuncs == 1) {
+	&OIStart;
+    }
+
+    print "#pragma argsused\n";
+
+    if ($iscreator) {
+	print "static Scheme_Object *${newclass}_ConstructScheme(${scheme_args})";
+	print "\n{\n";
+
+	print "  ${newclass} *realobj;\n";
+    } else {
+	if ($common) {
+	    print &NormalType($returntype);
+	    $common_name = &MakeCommonName();
+	    print " ${common_name}_Scheme(";
+	    print "${common_name}_Sftype f, char *name,";
+	    print "Scheme_Object *obj, int n, ";
+	    print "Scheme_Object **p, int req";
+	    if ($#paramtypes >= 0) {
+		print",";
+	    }
+	    &PrintParams(0, 'd', 1);
+	} else {
+	    print "static Scheme_Object *";
+	    $func2 = $func;
+	    $func2 = &OperatorClean($func2);
+	    if ($common) {
+		$common_name = &MakeCommonName();
+		print "${common_name}_Scheme";
+	    } else {
+		print "${globalname}${newclass}${func2}";
+	    }
+	    print "(";
+	    if (!$global) {
+		print "${scheme_args}";
+	    } else {
+		print "${global_scheme_args}";
+	    }
+	}
+
+	print ")\n{\n";
+
+	if (!$common) {
+	    print " WXS_USE_ARGUMENT(n) WXS_USE_ARGUMENT(p)\n";
+	}
+
+	if ($returntype ne 'void') {
+	    print "  " . &NormalType($returntype, 1) . " r;\n";
+	}
+
+	if (!$global && !$common) {
+	    print "  objscheme_check_valid(obj);\n";
+	}
+    }
+
+    if ($numfuncs == 1) {
+	if (!$iscreator) {
+	    $justoneok{$func} = 1;
+	    $justonemin{$func} = &CalcNumRequired(1);
+	    $justonemax{$func} = &CalcNumPossible(1);
+	}
+	&PrintSpecificFunction("", $iscreator, !$iscreator, "");
+    } else {
+	print "  ";
+
+	foreach $pos (0..($numfuncs-2)) {
+	    &ReadFields($thisfuncs[$pos + 1]);
+	    @schemeparams2 = @schemeparams;
+	    @typeids2 = @typeids;
+	    &ReadFields($thisfuncs[$pos]);
+
+	    print "if (";
+
+	    # Figure out how many things we'll check
+	    $pos = 0;
+	    while ($schemeparams[$pos] eq $schemeparams2[$pos]
+		   || (($typeids[$pos] ne '')
+		       && ($typeids[$pos] eq $typeids2[$pos]))) {
+		if ($schemeparams[$pos] eq undef) {
+		    print STDERR "error: duplicate function ${newclass}::$func\n";
+		    exit(-1);
+		}
+		$pos += 1;
+	    }
+	    $checkcount = $pos;
+	    $pos += 1;
+	    print "(n >= $pos)";
+
+	    # Check them:
+	    $pos = 0;
+	    @checks = @typechecks;
+	    @scms = @schemes;
+	    while ($pos < $checkcount) {
+		$scheme = 0;
+		while (!$scheme) {
+		    $check = shift(@checks);
+		    $scheme = shift(@scms);
+		}
+		print " && ";
+		&PrintTypecheck("p[${pos}]", $schemeparams[$pos], $check, 0);
+		$pos += 1;
+	    }
+	    print " && ";
+	    $scheme = 0;
+	    while (!$scheme) {
+		$check = shift(@checks);
+		$scheme = shift(@scms);
+	    }
+	    &PrintTypecheck("p[${pos}]", $schemeparams[$pos], $check, 0);
+	    
+	    print ") {\n";
+	    if ($casename eq "") {
+		print STDERR "Warning: unnamed ${newclass}::$func case\n";
+		$casename = "";
+	    } else {
+		$casename = " ($casename case)";
+	    }
+	    &PrintSpecificFunction("  ", $iscreator, 0, $casename);
+	    print "  } else ";
+	}
+
+	&ReadFields($thisfuncs[$numfuncs - 1]);
+
+	if ($numfuncs > 1) {
+	    if ($casename eq "") {
+		print STDERR "Warning: unnamed ${newclass}::$func case\n";
+		$casename = "";
+	    } else {
+		$casename = " ($casename case)";
+	    }
+   	} else {
+	    $casename = "";
+	}
+
+	print " {\n";
+	&PrintSpecificFunction("  ", $iscreator, 0, $casename);
+	print "  }";
+	print "\n\n";
+    }
+
+    if ($iscreator) {
+	print "  ((Scheme_Class_Object *)obj)->primdata = realobj;\n";
+	print "  objscheme_register_primpointer(&((Scheme_Class_Object *)obj)";
+	print "->primdata);\n";
+	print "  ((Scheme_Class_Object *)obj)->primflag = 1;\n";
+	print "  return obj;\n";
+	print "}\n";
+    } else {
+	print "  return ";
+
+	if ($returntype eq 'void') {
+	    if (!$common) {
+		print "scheme_void";
+	    }
+	} else {
+	    if (!$common) {
+		&PrintBundleVar("r", $returntype, $returnbundle, 1);
+	    } else {
+		if (&CallByRef($returntype)) {
+		    print "*";
+		}
+		print "r";
+	    }
+	}
+	print ";\n}\n";
+    }
+
+    if ($numfuncs == 1) {
+	&OIEnd;
+    }
+
+    print "\n";
+}
+
+sub PrintCallRealMethod
+{
+    local($prefix, $ret_val, $direct) = @_;
+
+    if ($global) {
+	print "$prefix  ";
+	print $ret_val if ($returntype ne 'void');
+	print "${func}(";
+	&PrintArgs($direct);
+	print ");\n\n";
+    } else {
+	print "$prefix  ";
+	if ($virtual) {
+	    print "if (((Scheme_Class_Object *)obj)->primflag)\n";
+	    print "$prefix    ";
+	    print $ret_val if ($returntype ne 'void');
+	    &PrintIndirect($returntype) if (!$direct);
+	    print "(($newclass *)((Scheme_Class_Object *)obj)->primdata)->";
+	    if (!$virtualonly) {
+		if ($implementor ne "") {
+		    print $implementor;
+		} else {
+		    print $oldclass;
+		}
+		print "::";
+	    }
+	    print "${func}(";
+	    &PrintArgs($direct);
+	    print ");\n";
+	    print "$prefix  else\n";
+	    print "$prefix    ";
+	}
+	print $ret_val if ($returntype ne 'void');
+	&PrintIndirect($returntype) if (!$direct);
+	if (!$externalmethod) {
+	    print "(($oldclass *)((Scheme_Class_Object *)obj)->primdata)";
+	    print "->";
+	}
+	print "${func}(";
+	if ($externalmethod) {
+	    print "(($oldclass *)((Scheme_Class_Object *)obj)->primdata)";
+	    print ", " if ($#paramtypes >= 0);
+	}
+	&PrintArgs($direct);
+	print ");\n";
+	print "\n";
+    }
+}
+
+sub PrintSpecificFunction
+{
+    local($prefix, $iscreator, $just_one, $casename) = @_;
+
+    return if ($hidden);
+
+    &OIStart;
+
+    $req = &CalcNumRequired(1);
+    $aname = &Unquote($method);
+    
+    if (!$common) {
+	$common_name = &MakeCommonName();
+	@l = grep($_ =~ /^$common_name$/, @common_names);
+	if ($#l >= $[) {
+	    $use_common = 1;
+	} else {
+	    $use_common = 0;
+	}
+
+	if ($use_common) {
+	    print "r = " if ($returntype ne 'void');
+	    &PrintIndirect($returntype);
+	    print "${common_name}_Scheme(";
+	    print "(${common_name}_Sftype)";
+	    $func2 = $func;
+	    $func2 = &OperatorClean($func2);
+	    print "${newclass}_${func2}_${common_name}_Scb";
+	    print ", \"${aname}${casename}\", ";
+	    if ($global) {
+		print "NULL";
+	    } else {
+		print "obj";
+	    }
+	    print ", n, p, ${req}";
+	    foreach $defv (@defvals) {
+		if (($defval ne '') && ($defval ne '.')) {
+		    print ", $defval";
+		} else {
+		    print ", 0";
+		}
+	    }
+	    print ");\n";
+	    return;
+	}
+    }
+
+    &PrintLocals($prefix);
+    print "\n";
+    print "$prefix  " . &ApplyMacros($gluepre) . "\n";
+
+    if (!$just_one) {
+	$possible = &CalcNumPossible(1);
+	print "$prefix  if (";
+	if (!$common && $req == $possible) {
+	    print "n != $req";
+	    $minimumok = $possible;
+	} else {
+	    if ($common || $req) {
+		if ($common) {
+		    $req_arg = "req";
+		} else {
+		    $req_arg = $req;
+		}
+		print "(n < $req_arg) ||";
+		$minimumok = $req_arg;
+	    } else {
+		$minimumok = "0";
+	    }
+	    print "(n > $possible)";
+	}
+	print ") \n";
+	
+	print "$prefix    scheme_wrong_count(";
+	if ($common) {
+	    print "name";
+	} else {
+	    print "\"${aname}${casename}\"";
+	}
+	
+	print ", ${minimumok}, ${possible}, n, p);\n";
+    }
+
+    &PrintUnbundles($prefix, "\"${aname}${casename}\"");
+    print "\n";
+    print "$prefix  " . &ApplyMacros($glueprecall) . "\n";
+
+    if ($iscreator) {
+	print "$prefix  realobj = new ${newclass}(obj";
+	print ", " if ($#paramtypes >= 0);
+	&PrintArgs();
+	print ");\n";
+    } elsif ($common) {
+	print "$prefix  "; 
+	print "r = " if ($returntype ne 'void');
+	if (&CallByRef($returntype)) {
+	    print "&";
+	}
+	print "f(obj";
+	print ", " if ($#paramtypes >= 0);
+	&PrintArgs(0);
+	print ");\n";
+    } else {
+	&PrintCallRealMethod($prefix, "r = ");
+    }
+
+    print "$prefix  " . &ApplyMacros($gluepostcall) . "\n";
+
+    &PrintBundledEffects($prefix);
+
+    print "$prefix  " . &ApplyMacros($gluepost) . "\n";
+
+    if (($onlyif ne '') && ($returntype ne 'void')) {
+	print "#else\n";
+	print " scheme_signal_error(";
+	print "\"%s: provided arglist unsupported on this platform\"";
+	print ", \"${aname}${casename}\");\n";
+#	print "${prefix}r = ";
+#	if ($exception ne '' && $exception ne 'SUPER') {
+#	    print &ApplyMacros($exception);
+#	} else {
+#	    print "0";
+#	}
+#	print ";\n";
+    }
+
+    &OIEnd;
+}
+
+sub PrintIndirect
+{
+    local($type) = @_;
+
+    if ((substr($type, -1) eq '%') || (substr($type, -1) eq '&')) {
+	print "&";
+    }
+}
+
+sub PrintBundleObject
+{
+    local($var, $paramtype, $nullOK) = @_;
+
+    $nullOK = '0' if ($nullOK eq '');
+
+    print "objscheme_bundle_${paramtype}($var)";
+    print HEADER "extern Scheme_Object *objscheme_bundle_${paramtype}";
+    print HEADER "(class ${paramtype} *);\n";
+}
+
+sub PrintBundleVar
+{
+    local($var, $paramtype, $bundle, $outgoing) = @_;
+
+    if (($bundle ne undef) && ($bundle ne '')) {
+	print &ApplyMacros($bundle, $var);
+    } elsif (substr($paramtype, 0, 7) eq 'unknown') {
+	print "objscheme_bundle_generic((void *)$var)";
+    } elsif (substr($paramtype, -1) eq '*') {
+	substr($paramtype, -1) = '';
+	print "objscheme_box(";
+	&PrintBundleVar("(*$var)", $paramtype);
+	print ")";
+    } elsif (substr($paramtype, -1) eq '?') {
+	substr($paramtype, -1) = '';
+	print "(($var) ? ";
+	print "objscheme_box(";
+	&PrintBundleVar("(*$var)", $paramtype);
+	print ")";
+	print " : scheme_null)";
+    } elsif (substr($paramtype, -1) eq '&') {
+	substr($paramtype, -1) = '';
+	$var = "&$var" unless $outgoing;
+	&PrintBundleVar("$var", $paramtype);
+    } elsif (substr($paramtype, -1) eq '+') {
+	substr($paramtype, -1) = '';
+	print "objscheme_box(";
+	&PrintBundleVar($var, $paramtype);
+	print ")";
+    } elsif ($paramtype eq 'bool') {
+	print "($var ? scheme_true : scheme_false)";
+    } elsif ($paramtype eq 'char') {
+	print "scheme_make_char($var)";
+    } elsif ($paramtype eq 'uchar') {
+	print "scheme_make_char((char)$var)";
+    } elsif ($paramtype eq 'int' 
+	     || $paramtype eq 'nnint' 
+	     || $paramtype eq 'unsigned') {
+	print "scheme_make_integer($var)";
+    } elsif ($paramtype eq 'short') {
+	print "scheme_make_integer($var)";
+    } elsif ($paramtype eq 'byte' || $paramtype eq 'ubyte') {
+	print "scheme_make_integer($var)";
+    } elsif ($paramtype eq 'long' || $paramtype eq 'Long') {
+	print "scheme_make_integer($var)";
+    } elsif (($paramtype eq 'float') || ($paramtype eq 'double')
+	     || ($paramtype eq 'Double')) {
+	print "scheme_make_double($var)";
+    } elsif (($paramtype eq 'string') || ($paramtype eq 'cstring')
+	     || ($paramtype eq 'custring') || ($paramtype eq 'ustring')
+	     || ($paramtype eq 'ncustring') || ($paramtype eq 'nustring')
+	     || ($paramtype eq 'nstring') || ($paramtype eq 'ncstring')) {
+	print "objscheme_bundle_string((char *)$var)";
+    } elsif (($paramtype eq 'pathname') 
+	     || ($paramtype eq 'cpathname')
+	     || ($paramtype eq 'npathname')
+	     || ($paramtype eq 'ncpathname')) {
+	print "objscheme_bundle_pathname((char *)$var)";
+    } elsif (substr($paramtype, -1) eq '!') {
+	substr($paramtype, -1) = '';
+	&PrintBundleObject($var, $paramtype);
+    } elsif (substr($paramtype, -1) eq '^') {
+	substr($paramtype, -1) = '';
+	&PrintBundleObject($var, $paramtype, 1);
+    } elsif (substr($paramtype, -1) eq '%') {
+	substr($paramtype, -1) = '';
+	$var = "&$var" unless $outgoing;
+	&PrintBundleObject($var, $paramtype);
+    } else {
+	print STDERR "Unknown type ${paramtype} in $func.\n";
+    }
+}
+
+sub PrintUnbundleObject
+{
+    local($var, $paramtype, $nullOK, $mname) = @_;
+    local($stop);
+
+    $nullOK = '0' if ($nullOK eq '');
+
+    if (!$common) {
+	if (($mname eq '') || ($mname eq undef)) {
+	    $stop = &GetMethod(1);
+	} else {
+	    $stop = $mname;
+	}
+    } else {
+	$stop = "name";
+    }
+
+    print "objscheme_unbundle_${paramtype}($var, $stop, $nullOK)";
+    print HEADER "extern class ${paramtype} *";
+    print HEADER "objscheme_unbundle_${paramtype}" .
+	"(Scheme_Object *, const char *, int);\n";
+}
+    
+sub PrintUnbundleVar
+{
+    local($var, $paramtype, $unbundle, $outgoing, $mname) = @_;
+    local($stop);
+
+    if (($mname eq "") || ($mname eq undef)) {
+	$stop = &GetMethod(1);
+    } else {
+	$stop = $mname;
+    }
+
+    if (($unbundle ne undef) && ($unbundle ne '')) {
+	print &ApplyMacros($unbundle, $var);
+    } elsif (substr($paramtype, 0, 7) eq 'unknown') {
+	print "(";
+	print substr($paramtype, 8);
+	print ")objscheme_unbundle_generic($var, $stop)";
+    } elsif (substr($paramtype, -1) eq '*' || substr($paramtype, -1) eq '?') {
+	substr($paramtype, -1) = '';
+	&PrintUnbundleVar("objscheme_unbox($var, $stop)", $paramtype, "", "", $stop);
+    } elsif (substr($paramtype, -1) eq '&') {
+	substr($paramtype, -1) = '';
+	print "*" if ($outgoing);
+	&PrintUnbundleVar("$var", $paramtype, "", "", $stop);
+    } elsif (substr($paramtype, -1) eq '+') {
+	substr($paramtype, -1) = '';
+	&PrintUnbundleVar("objscheme_unbox($var, $stop)", $paramtype, "", "", $stop);
+    } elsif ($paramtype eq 'bool') {
+	print "objscheme_unbundle_bool(${var}, $stop)";
+    } elsif ($paramtype eq 'char') {
+	print "objscheme_unbundle_char(${var}, $stop)";
+    } elsif ($paramtype eq 'uchar') {
+	print "((unsigned char)objscheme_unbundle_char(${var}, $stop))";
+    } elsif (($paramtype eq 'int') || ($paramtype eq 'unsigned') 
+	     || ($paramtype eq 'byte')
+	     || ($paramtype eq 'ubyte')
+	     || ($paramtype eq 'short') || ($paramtype eq 'long')
+	     || ($paramtype eq 'Long')) {
+	print "objscheme_unbundle_integer($var, $stop)";
+    } elsif (($paramtype eq 'nnint')) {
+	print "objscheme_unbundle_nonnegative_integer($var, $stop)";
+    } elsif (($paramtype eq 'float') || ($paramtype eq 'double')
+	     || ($paramtype eq 'Double')) {
+	print "objscheme_unbundle_float($var, $stop)";
+    } elsif (($paramtype eq 'nnfloat')) {
+	print "objscheme_unbundle_nonnegative_float($var, $stop)";
+    } elsif ($paramtype eq 'string' || $paramtype eq 'cstring'
+	     || $paramtype eq 'ustring' || $paramtype eq 'custring') {
+	print "(${paramtype})objscheme_unbundle_string(${var}, $stop)";
+    } elsif ($paramtype eq 'nstring' || $paramtype eq 'ncstring'
+	     || $paramtype eq 'nustring' || $paramtype eq 'ncustring') {
+	print "(${paramtype})objscheme_unbundle_nullable_string($var, $stop)";
+    } elsif ($paramtype eq 'pathname' || $paramtype eq 'cpathname') {
+	print "(${paramtype})objscheme_unbundle_pathname(${var}, $stop)";
+    } elsif ($paramtype eq 'npathname' || $paramtype eq 'ncpathname') {
+	print "(${paramtype})objscheme_unbundle_nullable_pathname(${var}, $stop)";
+    } elsif (substr($paramtype, -1) eq '!') {
+	substr($paramtype, -1) = '';
+	&PrintUnbundleObject($var, $paramtype, 0, $mname);
+    } elsif (substr($paramtype, -1) eq '^') {
+	substr($paramtype, -1) = '';
+	&PrintUnbundleObject($var, $paramtype, 1, $mname);
+    } elsif (substr($paramtype, -1) eq '%') {
+	substr($paramtype, -1) = '';
+	print "*" if ($outgoing);
+	&PrintUnbundleObject("$var", $paramtype, 0, $mname);
+    } else {
+	print STDERR "Unknown type ${paramtype} in $func.\n";
+    }
+}
+
+sub NormalType {
+    local($paramtype, $islocal) = @_;
+
+    if (substr($paramtype, -1) eq '*' || substr($paramtype, -1) eq '?') {
+	substr($paramtype, -1) = '';
+	$paramtype = &NormalType($paramtype) . '*';
+    } elsif (substr($paramtype, 0, 7) eq 'unknown') {
+	return substr($paramtype, 8);
+    } elsif (substr($paramtype, -1) eq '!') {
+	substr($paramtype, -1) = '*';
+	$paramtype = "class " . $paramtype;
+    } elsif (substr($paramtype, -1) eq '^') {
+	substr($paramtype, -1) = '*';
+	$paramtype = "class " . $paramtype;
+    } elsif (substr($paramtype, -1) eq '%') {
+	if ($islocal) {
+	    substr($paramtype, -1) = '*';
+	} else {
+	    substr($paramtype, -1) = '&';
+	}
+	$paramtype = "class " . $paramtype;
+    } elsif (substr($paramtype, -1) eq '+') {
+	substr($paramtype, -1) = '';
+	$paramtype = &NormalType($paramtype);
+	if ($islocal) {
+	     $paramtype = $paramtype . '*';
+	} else {
+	     $paramtype = $paramtype . '&';
+	}
+    } elsif (substr($paramtype, -2) eq '[]') {
+	substr($paramtype, -2) = '*';	
+    } elsif ($islocal && (substr($paramtype, -1) eq '&')) {
+	substr($paramtype, -1) = '';
+	$paramtype = &NormalType($paramtype) . '*';
+    } elsif ($paramtype eq 'uchar') {
+	$paramtype = 'unsigned char';
+    } elsif ($paramtype eq 'bool') {
+	$paramtype = $bool;
+    } elsif ($paramtype eq 'Long') {
+	$paramtype = 'long';
+    } elsif ($paramtype eq 'Double') {
+	$paramtype = 'double';
+    }
+
+    return $paramtype;
+}
+
+sub PrintParams {
+
+    ($dodefval, $prefix, $pointify) = @_;
+
+    if ($prefix eq '') {
+	$prefix = 'x';
+    }
+
+    $paramnum = 0;
+    @defvs = @defvals;
+    foreach $paramtype (@paramtypes) {
+	$defval = shift(@defvs);
+
+	print ", " if ($paramnum > 0);
+
+	print &NormalType($paramtype, $pointify) . " ${prefix}${paramnum}";
+	if ($dodefval && ($defval ne '') && ($defval ne '.')) {
+	    print " = ${defval}";
+	}
+	$paramnum += 1;
+    }
+}
+
+sub PrintArgs 
+{
+    local($direct) = @_;
+
+    $paramnum = 0;
+    foreach $paramtype (@paramtypes) {
+	print ", " if ($paramnum > 0);
+	print "*" if (($direct != 1) && &CallByRef($paramtype));
+	print "x${paramnum}";
+	$paramnum += 1;
+    }
+}
+
+sub PrintLocals
+{
+    local($prefix) = @_;
+    
+    $paramnum = 0;
+    foreach $paramtype (@paramtypes) {
+	$pt = $paramtype;
+	if (&NeedsDeref($pt)) {
+	    $temp = $pt;
+	    substr($temp, -1)  = '';
+	    print "$prefix  " . &NormalType($temp) . " _x${paramnum};\n";
+	    $deref = 1;
+	} else {
+	    $deref = 0;
+	}
+	print "$prefix  " . &NormalType($pt, 1) . " x${paramnum}";
+	if ($deref) {
+	    print " = &_x${paramnum}";
+	}
+        print ";\n";
+	$paramnum += 1;
+    }
+}
+
+sub PrintUnbundles
+{
+    local($prefix, $mname) = @_;
+
+    $paramnum = 0;
+    @defvs = @defvals;
+    @unbunds = @unbundles;
+    @scms = @schemes;
+    $offset = 0;
+    foreach $paramtype (@paramtypes) {
+	$defval = shift(@defvs);
+	$unbundle = shift(@unbunds);
+	$scheme = shift(@scms);
+
+	if ($scheme || ($unbundle ne '')) {
+	    print "$prefix  ";
+	    if ((($defval ne '') && ($defval ne '.')) || $common) {
+		print "if (n > " . ($paramnum -  $offset) . ") {\n$prefix    ";
+	    }
+	    $svar = "p[" . ($paramnum - $offset) . "]";
+	    $xvar = "x${paramnum}";
+	    if (&NeedsDeref($paramtype)) {
+		print "if (SCHEME_NULLP($svar))\n";
+		if (&CanBeNull($paramtype)) {
+		    print "$prefix    $xvar = NULL;";
+		} else {
+		    print "$prefix    scheme_wrong_type($mname, ";
+		    print "\"non-null\", ($paramnum - $offset), n, p);"
+		}
+		print "\n$prefix  else\n$prefix    *";
+	    }
+	    print "$xvar = ";
+	    &PrintUnbundleVar($svar, $paramtype, $unbundle, "", $mname);
+	    print ";\n";
+	    if ($common || (($defval ne '') && ($defval ne '.'))) {
+		print "$prefix  } else\n$prefix    ";
+		print "x${paramnum} = ";
+		if ($common) {
+		    print "d${paramnum}";
+		} else {
+		    print "${defval}";
+		}
+		print ";\n";
+	    }
+	} 
+
+	if (!$scheme) {
+	    $offset += 1;
+	}
+	$paramnum += 1;
+    }
+}
+
+sub PrintBundledEffects
+{
+    local($prefix) = @_;
+
+    $paramnum = 0;
+    $offset = 0;
+    foreach $paramtype (@paramtypes) {
+	if ($schemes[$paramnum]) {
+	    if (&NeedsDeref($paramtype)) {
+		$pos = $paramnum - $offset;
+		print "$prefix  if (n > $pos";
+		print " && !SCHEME_NULLP(p[$pos])" if &CanBeNull($paramtype);
+		print ")\n$prefix    objscheme_set_box(p[$pos], ";
+		substr($paramtype, -1) = '';
+		&PrintBundleVar("_x${paramnum}", $paramtype, $bundle);
+		print ");\n";
+	    }
+	} else {
+	    $offset += 1;
+	}
+	$paramnum += 1;
+    }
+}
+
+sub PrintUnbundledEffects
+{
+    local($prefix) = @_;
+
+    $paramnum = 0;
+    $offset = 0;
+    foreach $paramtype (@paramtypes) {
+	if ($schemes[$paramnum]) {
+	    if (&NeedsDeref($paramtype)) {
+		# substr($paramtype, -1) = '';
+		print "$prefix  ";
+		if (!&CallByRef($paramtype)) {
+		    print "if (x${paramnum}) *";
+		}
+		print "x${paramnum} = ";
+		$svar = "p[". ($paramnum - $offset) . "]";
+		&PrintUnbundleVar($svar, $paramtype, undef, undef, &GetMethod(1) . "\", extracting return value via box\"");
+		print ";\n";
+	    }
+	} else {
+	    $offset += 1;
+	}
+	$paramnum += 1;
+    }	
+}
+
+sub PrintTypecheckObj
+{
+    local($var, $paramtype, $stop, $nullOK) = @_;
+
+    $nullOK = '0' if ($nullOK eq '');
+    $stop = &GetMethod($stop);
+
+    print "objscheme_istype_${paramtype}($var, $stop, $nullOK)";
+    print HEADER "extern int objscheme_istype_${paramtype}";
+    print HEADER "(Scheme_Object *, const char *, int);\n";
+}
+
+sub PrintTypecheck
+{
+    local($var, $paramtype, $check, $stop) = @_;
+
+    $stop = &GetMethod($stop);
+
+    if (substr($paramtype, 0, 7) eq 'unknown') {
+	print "objscheme_istype_generic($var, $stop)";
+    } elsif (($check ne undef) && ($check ne '')) {
+	print &ApplyMacros($check, $var, $stop);
+    } elsif (substr($paramtype, -1) eq '*') {
+	print "(objscheme_istype_box($var, $stop) && ";
+	substr($paramtype, -1) = '';
+	&PrintTypecheck("objscheme_unbox($var, $stop)", $paramtype, '', $stop);
+	print ")";
+    } elsif (substr($paramtype, -1) eq '+') {
+	print "(objscheme_istype_box($var, $stop) && ";
+	substr($paramtype, -1) = '';
+	&PrintTypecheck("objscheme_unbox($var, $stop)", $paramtype, '', $stop);
+	print ")";
+    } elsif (substr($paramtype, -1) eq '?') {
+	print "(SCHEME_NULLP($var) || (objscheme_istype_box($var, $stop) && ";
+	substr($paramtype, -1) = '';
+	&PrintTypecheck("objscheme_unbox($var, $stop)", $paramtype, '', $stop);
+	print "))";
+    } elsif (substr($paramtype, -1) eq '&') {
+	substr($paramtype, -1) = '';
+	&PrintTypecheck($var, $paramtype);
+    } elsif ($paramtype eq 'bool') {
+	print "objscheme_istype_bool($var, $stop)";
+    } elsif ($paramtype eq 'char' || $paramtype eq 'uchar') {
+	print "objscheme_istype_char($var, $stop)";
+    } elsif (($paramtype eq 'int') || ($paramtype eq 'unsigned') 
+	     || ($paramtype eq 'nnint') 
+	     || ($paramtype eq 'byte') || ($paramtype eq 'ubyte')
+	     || ($paramtype eq 'short') || ($paramtype eq 'long') 
+	     || ($paramtype eq 'float') || ($paramtype eq 'nnfloat') 
+	     || ($paramtype eq 'double')) {
+	print "objscheme_istype_number($var, $stop)";
+    } elsif (($paramtype eq 'Long')) {
+	print "objscheme_istype_integer($var, $stop)";
+    } elsif (($paramtype eq 'Double')) {
+	print "objscheme_istype_float($var, $stop)";
+    } elsif ($paramtype eq 'string' || $paramtype eq 'cstring'
+	     || $paramtype eq 'ustring' || $paramtype eq 'custring') {
+	print "objscheme_istype_string($var, $stop)";
+    } elsif ($paramtype eq 'nstring' || $paramtype eq 'ncstring'
+	     || $paramtype eq 'nustring' || $paramtype eq 'ncustring') {
+	print "(SCHEME_NULLP($var) || objscheme_istype_string($var, $stop))";
+    } elsif ($paramtype eq 'pathname' || $paramtype eq 'cpathname') {
+	print "objscheme_istype_pathname($var, $stop)";
+    } elsif ($paramtype eq 'npathname' || $paramtype eq 'ncpathname') {
+	print "(SCHEME_NULLP($var) || objscheme_istype_pathname($var, $stop))";
+    } elsif (substr($paramtype, -1) eq '!') {
+	substr($paramtype, -1) = '';
+	&PrintTypecheckObj($var, $paramtype, $stop);
+    } elsif (substr($paramtype, -1) eq '^') {
+	substr($paramtype, -1) = '';
+	&PrintTypecheckObj($var, $paramtype, $stop, 1);
+    } elsif (substr($paramtype, -1) eq '%') {
+	substr($paramtype, -1) = '';
+	&PrintTypecheckObj("$var", $paramtype, $stop);
+    } else {
+	print STDERR "Unknown type ${paramtype} in $func.\n";
+    }
+}
+
+sub NeedsDeref
+{
+    local($paramtype) = @_;
+
+    return ((substr($paramtype,0,7) ne 'unknown')
+	    && ((substr($paramtype, -1) eq '*')
+		|| (substr($paramtype, -1) eq '+')
+		|| (substr($paramtype, -1) eq '?')))
+}
+
+sub CanBeNull
+{
+    return (substr($_[0], -1) eq '?');
+}
+
+sub CallByRef
+{
+    local($paramtype) = @_;
+
+    return ((substr($paramtype, -1) eq '&')
+	    || (substr($paramtype, -1) eq '+')
+	    || (substr($paramtype, -1) eq '%'));
+}
+
+sub GetMethod
+{
+    local ($stop) = @_;
+
+    if ($stop > 0) {
+	return $method;
+    } else {
+	return "NULL";
+    }
+}
+
+sub Overridden
+{
+    local($function, $pos) = @_;
+
+    &ReadFields($function);
+    $thefunc = $func;
+    @theparamtypes = @paramtypes;
+    $thepos = $pos;
+    $fp = 0;
+    foreach $func (@funcnames) {
+	if ($fp >= $thepos) {
+	    return 0;
+	}
+	if ($thefunc eq $func) {
+	    &ReadFields($functions[$fp]);
+	    if ($#paramtypes == $#theparamtypes) {
+		$same = 1;
+		foreach $pos (0 .. $#paramtypes) {
+		    if ($paramtypes[$pos] ne $theparamtypes[$pos]) {
+			$same = 0;
+		    }
+		}
+		if ($same) {
+		    return 1;
+		}
+	    }
+	}
+	$fp += 1;
+    }
+
+    return 0;
+}
+
+sub OperatorClean
+{
+    if (index($_[0], "operator") == $[) {
+	$_[0] =~ s/</LT/g;
+	$_[0] =~ s/>/GT/g;
+	$_[0] =~ s/\*/STAR/g;
+	$_[0] =~ s/\-/MINUS/g;
+	$_[0] =~ s/\+/PLUS/g;
+	$_[0] =~ s/\&/AND/g;
+	$_[0] =~ s/\|/OR/g;
+	$_[0] =~ s/\!/BANG/g;
+	$_[0] =~ s/\:/COLON/g;
+	$_[0] =~ s/\@/AT/g;
+	$_[0] =~ s/\=/EQUAL/g;
+	$_[0] =~ s/\$/DOLLAR/g;
+	$_[0] =~ s/\%/MOD/g;
+	$_[0] =~ s/\#/NUMBER/g;
+	$_[0] =~ s/\~/TILDE/g;
+	$_[0] =~ s/\//SLASH/g;
+    }
+	
+    return $_[0];
+}
+
+sub OIStart
+{
+    if ($onlyif ne '') {
+	print "#if $onlyif\n";
+    }
+}
+
+sub OIEnd
+{
+    if ($onlyif ne '') {
+	print "#endif\n";
+    }
+}
diff --git a/src/mzscheme/utils/xctocmn b/src/mzscheme/utils/xctocmn
new file mode 100755
index 0000000..cce2213
--- /dev/null
+++ b/src/mzscheme/utils/xctocmn
@@ -0,0 +1,90 @@
+#!/usr/local/bin/perl
+
+# Copyright (c) 1995 Matthew Flatt
+
+# Find out what common functions should be created
+
+require "parse.pl";
+require "common.pl";
+
+$threshold = 5;
+
+%common = ();
+$counter = 0;
+
+print "// generated by xctocmn\n";
+print "@INCLUDE wxscomon.xci\n";
+print "@COMMON\n";
+
+while (($file = shift(@ARGV)) ne undef) {
+
+    if ($file =~ s/.xc$//) {
+    } else {
+	print STDERR "Bad extension \"$file\".\n";
+	exit 1;
+    }
+    
+    if (!open(IN, "$file.xc")) {
+	print STDERR "Couldn't open \"${file}.xc\"\n";
+	exit 1;
+    }
+
+    $thisfile = "$file.xc";
+    &ReadFile();
+
+    close(IN);
+}
+
+print "@END\n";
+
+exit(0);
+
+while (@pair = each(%common)) {
+    ($name, $count) = @pair;
+    if ($count >= $threshold) {
+	print "$name $count\n";
+    }
+}
+
+exit(0);
+
+sub DoPrintClass 
+{
+    return if ($testfile);
+
+    foreach $function (@functions) {
+	&ReadFields($function);
+	
+	$badflag = 0;
+	$name = &MakeCommonName();
+	if (!$badflag) {
+	    $common{$name} += 1;
+	    if ($common{$name} == $threshold) {
+		$counter += 1;
+		print "@ \"f-${counter}\" : ${returntype} F${counter}(";
+		$comma = 0;
+		foreach $type (@paramtypes) {
+		    if (!$comma) {
+			$comma = 1;
+		    } else {
+			print ", ";
+		    }
+		    print $type;
+		}
+		print ")\n";
+	    }
+	}
+    }
+}
+
+sub IgnoreLine
+{
+}
+
+sub PrintHeader
+{
+}
+
+sub PrintDefine
+{
+}
diff --git a/src/mzscheme/utils/xctosig b/src/mzscheme/utils/xctosig
new file mode 100755
index 0000000..0b769f1
--- /dev/null
+++ b/src/mzscheme/utils/xctosig
@@ -0,0 +1,248 @@
+#!/usr/local/bin/perl
+
+# Copyright (c) 1996 Matthew Flatt
+#
+# Make Spidey signature files from .xc info
+
+# Get the directory where this file is, and add to include path:
+{$0 =~ /^(.*)\/.*$/;  $my_dir = $1; 
+ if ($my_dir !~ ?^/?) {
+     open(DIRNAME, "pwd | ");
+     $pwd = <DIRNAME>;
+     close(DIRNAME);
+     chop($pwd);
+     $my_dir = $pwd . "/" . $my_dir;}
+ if ($my_dir =~ ?/$?) {chop ($my_dir);}}
+push(@INC, $my_dir);
+
+require "parse.pl";
+require "common.pl";
+
+$dummyfields = " \"initialization\" : x create";
+
+if ($ARGV[0] eq '-v') {
+    shift(@ARGV);
+    $verbose = 1;
+} else {
+    $verbose = 0;
+}
+
+while (($file = shift(@ARGV)) ne undef) {
+
+    print STDERR "$file\n" if ($verbose);
+
+    if ($file =~ s/.xc$//) {
+    } else {
+	print STDERR "Bad extension \"$file\".\n";
+	exit 1;
+    }
+    
+    if (!open(IN, "$file.xc")) {
+	print STDERR "Couldn't open \"${file}.xc\"\n";
+	exit 1;
+    }
+
+    $thisfile = "$file.xc";
+    &ReadFile();
+
+    close(IN);
+}
+
+sub IgnoreLine
+{
+}
+
+sub PrintHeader
+{
+}
+
+sub PrintDefine
+{
+}
+
+sub DoPrintClass 
+{
+    return if ($testfile || $common);
+
+    if ($global) {
+	$define = "\n(define ";
+	$close = ")";
+    } else {
+	$classstring = &StripQuotes($classstring);
+	if ($parentstring eq "") {
+	    $parentstring = "null";
+	} else {
+	    $parentstring = &StripQuotes($parentstring);
+	}
+	print "(define ${classstring}\n  (class $parentstring\n";
+
+	print "    ()\n" if ($#creators < 0);
+	foreach $creator (@creators) {
+	    print "    (";
+	    
+	    &ReadFields($dummyfields . $creator);
+            @scms = @schemes;
+	    @defvs = @defvals;
+	    @spids = @spideytypes;
+	    $pos = 0;
+	    foreach $param (@paramtypes) {
+		$defval = shift(@defvs);
+		$scheme = shift(@scms);
+		$spidey = shift(@spids);
+		
+		if ($scheme) {
+		    if ($pos > 0) {
+			print " ";
+		    }
+		    $pos += 1;
+		    if ($defval ne '') {
+			print "[init${pos} (type: ";
+			&PrintType($param, $spidey);
+			print ")]";
+		    } else {
+			print "|init${pos}-arg-";
+			&PrintType($param, $spidey);
+			print "|";
+		    }
+		}
+	    }
+
+	    print ")\n";
+	}
+
+	print "    (public";
+
+        $define = "\n      [";
+	$close = "]";
+    }
+
+    foreach $function (@functions) {
+	&ReadFields($function);
+	$fname = &StripQuotes($fname);
+	
+	print "${define}${fname} (type: (";
+
+	@scms = @schemes;
+	@defvs = @defvals;
+	@spids = @spideytypes;
+	foreach $param (@paramtypes) {
+	    $defval = shift(@defvs);
+	    $scheme = shift(@scms);
+	    $spidey = shift(@spids);
+	    
+	    if ($scheme) {
+		print "optional " if ($defval ne '');
+		&PrintType($param, $spidey);
+		print " ";
+	    }
+	}
+
+	print "-> ";
+
+	&PrintType($returntype, $returnspideytype);
+
+	print "))${close}";
+    }
+
+    foreach $ivar (@ivars) {
+	&ReadIvarFields($ivar);
+
+	$iname = &StripQuotes($iname);
+
+	print "${define} get-${iname} (type: (-> ";
+	&PrintType($itype, "");
+	print "))${close}";
+	
+	if (!$readonly) {
+	    print "${define} get-${iname} (type: (";
+	    &PrintType($itype, "");
+	    print " -> void))${close}";
+	}
+    }
+
+    if (!$global) {
+	print ")))\n";
+    }
+
+    foreach $constant (@constants) {
+	&ReadConstFields($constant);
+	$const = &StripQuotes($const);
+
+	print "(define $const (type: ";
+	&PrintType($ctype, "");
+	print "))\n";
+    }
+}
+
+sub StripQuotes
+{
+    return substr($_[0], 1, length($_[0]) - 2);
+}
+
+sub PrintType
+{
+    local($type, $macro) = @_;
+
+    if (($macro ne undef) && ($macro ne '')) {
+	print &ApplyMacros($macro, "");
+    } elsif (substr($type, 0, 7) eq 'unknown') {
+	print "anything";
+    } elsif ((substr($type, -1) eq '*')
+	     || (substr($type, -1) eq '&')
+	     || (substr($type, -1) eq '+')) {
+	substr($type, -1) = '';
+	print "(box ";
+	&PrintType($type);
+	print ")";
+    } elsif (substr($type, -1) eq '?') {
+	substr($type, -1) = '';
+	print "(union null (box ";
+	&PrintType($type);
+	print "))";
+    } elsif (substr($type, -2) eq '[]') {
+	substr($type, -2) = '';
+	print "(listof ";
+	&PrintType($type);
+	print ")";
+    } elsif ($type eq 'void') {
+	print "void";
+    } elsif ($type eq 'bool') {
+	print "bool";
+    } elsif (($type eq 'char') || ($type eq 'uchar')) {
+	print "char";
+    } elsif ($type eq 'int' || $type eq 'unsigned') {
+	print "num";
+    } elsif ($type eq 'short') {
+	print "num";
+    } elsif ($type eq 'byte' || $type eq 'ubyte') {
+	print "num";
+    } elsif ($type eq 'long' || $type eq 'Long') {
+	print "num";
+    } elsif (($type eq 'float') || ($type eq 'double')
+	     || ($type eq 'Double')) {
+	print "num";
+    } elsif (($type eq 'string') || ($type eq 'cstring')
+	     || ($type eq 'custring') || ($type eq 'ustring')
+	     || ($type eq 'ncustring') || ($type eq 'nustring')
+	     || ($type eq 'nstring') || ($type eq 'ncstring')) {
+	print "str";
+    } elsif ((substr($type, -1) eq '!') || (substr($type, -1) eq '%')) {
+	substr($type, -1) = '';
+	&PrintObjectType($type);
+    } elsif (substr($type, -1) eq '^') {
+	substr($type, -1) = '';
+	print "(union null ";
+	&PrintObjectType($type);
+	print ")";
+    } else {
+	print STDERR "Unknown type ${type} in $func.\n";
+	print "???";
+    }
+}
+
+sub PrintObjectType
+{
+    local($type) = @_;
+
+    print "${type}-object";
+}
diff --git a/src/mzscheme/utils/xctotest b/src/mzscheme/utils/xctotest
new file mode 100755
index 0000000..f2fd867
--- /dev/null
+++ b/src/mzscheme/utils/xctotest
@@ -0,0 +1,192 @@
+#!/usr/local/bin/perl
+
+# Copyright (c) 1996 Matthew Flatt
+
+# Generate information for automatic testing from .xc files
+
+# Get the directory where this file is, and add to include path:
+{$0 =~ /^(.*)\/.*$/;  $my_dir = $1; 
+ if ($my_dir !~ ?^/?) {
+     open(DIRNAME, "pwd | ");
+     $pwd = <DIRNAME>;
+     close(DIRNAME);
+     chop($pwd);
+     $my_dir = $pwd . "/" . $my_dir;}
+ if ($my_dir =~ ?/$?) {chop ($my_dir);}}
+push(@INC, $my_dir);
+
+$dangerfile = shift(@ARGV);
+
+%danger = ();
+open(DANGER, $dangerfile);
+while (<DANGER>) {
+    chop;
+    if (/^\#/) {
+	; skip
+    } elsif (/^(.*) (.*)/) {
+	$key = $1 . "::" . $2;
+	$danger{$key} = 1;
+    }
+}
+close(DANGER);
+
+require "parse.pl";
+
+@allclasses = ();
+%notest = ();
+$dummyfields = " \"initialization\" : x create";
+
+$notest{wxMetaFileDC} = 1;
+$notest{wxMetaFile} = 1;
+$notest{wxPrinterDC} = 1;
+$notest{wxLayoutConstraints} = 1;
+$notest{wxIndividualLayoutConstraint} = 1;
+$notest{wxForm} = 1;
+$notest{wxFormItem} = 1;
+$notest{wxFormGlobal} = 1;
+$notest{wxHelpInstance} = 1;
+$notest{wxEnhDialogBox} = 1;
+$notest{wxToolBar} = 1;
+$notest{wxToolBarTool} = 1;
+$notest{wxButtonBar} = 1;
+
+while (($file = shift(@ARGV)) ne undef) {
+
+    if ($file =~ s/.xc$//) {
+    } else {
+	print STDERR "Bad extension \"$file\".\n";
+	exit 1;
+    }
+    
+    if (!open(IN, "$file.xc")) {
+	print STDERR "Couldn't open \"${file}.xc\"\n";
+	exit 1;
+    }
+
+    $thisfile = "$file.xc";
+    &ReadFile();
+
+    close(IN);
+}
+
+@allclasses = sort(@allclasses);
+
+print "\n(define classes\n  (list";
+foreach $class (@allclasses)
+{
+    print "\n    $class";
+}
+print "))\n\n";
+
+sub DoPrintClass 
+{
+    return if ($testfile || $common);
+
+    if ($global) {
+	$classstring = ${globalname};
+    
+        if ($notest{$classstring}) {
+	    return;
+	}
+
+    $classstring = "'$classstring";
+
+	$oldclass = "#f";
+    } else {
+	$classstring = &StripQuotes($classstring);
+
+	if ($notest{$oldclass}) {
+	    return;
+	}
+
+	$oldclass = "${oldclass}!-example-list";
+    }
+
+    print "(hash-table-put! classinfo ${classstring}\n";
+    print "  (list ${oldclass} (quote ${classstring})";
+
+    print "\n    (list";
+    foreach $creator (@creators) {
+	&ReadFields($dummyfields . $creator);
+	print "\n      (list";
+        @scms = @schemes;
+	foreach $paramtype (@paramtypes) {
+	    $scheme = shift(@scms);
+	    if ($scheme) { 
+		print " ";
+		&PrintType(${paramtype});
+	    }
+	}
+	print ")";
+    }
+    print ")";
+
+    foreach $function (@functions) {
+	&ReadFields($function);
+	$fname = &StripQuotes($fname);
+        
+        $key = $classstring . "::" . $fname;
+
+        if ($danger{$key}) {
+        } else {
+	    print "\n    (list '$fname ";
+	    
+           &PrintType(${returntype});
+
+	   @scms = @schemes;
+	   foreach $paramtype (@paramtypes) {
+	       $scheme = shift(@scms);
+	       if ($scheme) {
+		   print " ";
+		   &PrintType(${paramtype});
+	       }
+	   } 
+	   print ")";
+        }
+    }
+
+    foreach $ivar (@ivars) {
+	&ReadIvarFields($ivar);
+	$iname = &StripQuotes($iname);
+
+	print "\n    (list 'get-${iname} ";
+	&PrintType(${itype});
+        print ")";
+
+	if (!$readonly) {
+            print "\n    (list 'set-${iname} void-example-list ";
+	    &PrintType(${itype});
+            print ")";
+	}
+    }
+
+   print "))\n";
+
+push(@allclasses, $classstring);
+}
+
+sub PrintType 
+{
+    local($type) = @_;
+    
+    $type =~ s/\[\]/ARRAY/g;
+
+    print "${type}-example-list";
+}
+
+sub StripQuotes
+{
+    return substr($_[0], 1, length($_[0]) - 2);
+}
+
+sub IgnoreLine
+{
+}
+
+sub PrintHeader
+{
+}
+
+sub PrintDefine
+{
+}
diff --git a/src/mzscheme/utils/xctotex b/src/mzscheme/utils/xctotex
new file mode 100755
index 0000000..36ae265
--- /dev/null
+++ b/src/mzscheme/utils/xctotex
@@ -0,0 +1,154 @@
+#!/usr/local/bin/perl
+
+# Copyright (c) 1995 Matthew Flatt
+
+# Create some latex documentation from .xc files
+
+# Get the directory where this file is, and add to include path:
+{$0 =~ /^(.*)\/.*$/;  $my_dir = $1; 
+ if ($my_dir !~ ?^/?) {
+     open(DIRNAME, "pwd | ");
+     $pwd = <DIRNAME>;
+     close(DIRNAME);
+     chop($pwd);
+     $my_dir = $pwd . "/" . $my_dir;}
+ if ($my_dir =~ ?/$?) {chop ($my_dir);}}
+push(@INC, $my_dir);
+
+require "parse.pl";
+
+@allfuncs = @allconstants = @allclasses = ();
+
+while (($file = shift(@ARGV)) ne undef) {
+
+    if ($file =~ s/.xc$//) {
+    } else {
+	print STDERR "Bad extension \"$file\".\n";
+	exit 1;
+    }
+    
+    if (!open(IN, "$file.xc")) {
+	print STDERR "Couldn't open \"${file}.xc\"\n";
+	exit 1;
+    }
+
+    $thisfile = "$file.xc";
+    &ReadFile();
+
+    close(IN);
+}
+
+@allclasses = sort(@allclasses);
+@allfuncs = sort(@allfuncs);
+@allconstants = sort(@allconstants);
+
+print '\index{translation from C++!names!classes}' . "\n";
+print "\\schemetransclasses\n";
+
+$last = '';
+foreach $class (@allclasses)
+{
+    print $class;
+    print "\n";
+}
+
+print "\\schemetransclassesend\n";
+print '\index{translation from C++!names!class members}' . "\n";
+print "\\schemetransmembers\n";
+ 
+$last = '';
+foreach $func(@allfuncs)
+{
+    if ($func ne $last) {
+	$last = $func;
+	print substr($func, index($func, "=>") + 2);
+	print "\n";
+    }
+}
+
+print "\\schemetransmembersend\n";
+print '\index{translation from C++!names!constants}' . "\n";
+print "\\schemetransconstants\n";
+
+foreach $const (@allconstants)
+{
+    print $const;
+    print "\n";
+}
+
+print "\\schemetransconstantsend\n";
+
+sub DoPrintClass 
+{
+    return if ($testfile || $common);
+
+    if ($global) {
+	$oldclass = "";
+    } else {
+	$oldclass = &Texify($oldclass);
+	$classstring = &StripQuotes($classstring);
+	@allclasses = (@allclasses, 
+		       "\\schemetransclass{$oldclass}{$classstring}");
+    }
+
+    foreach $function (@functions) {
+	&ReadFields($function);
+	$fname = &StripQuotes($fname);
+	$func = &Texify($func);
+	$str = "${oldclass}::$func=>\\schemetransfunc{${oldclass}::$func}{$fname}";
+	if ($virtualonly) {
+	    $str = $str . "{pure}";
+	} elsif ($virtual) {
+	    $str = $str . "{virtual}";
+	} else {
+	    $str = $str . "{}";
+	}
+	push(@allfuncs, $str);
+    }
+
+    foreach $ivar (@ivars) {
+	&ReadIvarFields($ivar);
+	$iname = &StripQuotes($iname);
+	$ivarname = &Texify($ivarname);
+	$str = "${oldclass}::$ivarname=>" .
+	    "\\schemetransvar{${oldclass}::$ivarname}{get-${iname}";
+	if (!$readonly) {
+	    $str = $str . "/set-${iname}";
+	}
+	$str = $str . "}";
+	push(@allfuncs, $str);
+    }
+
+    foreach $constant (@constants) {
+	&ReadConstFields($constant);
+	$const = &StripQuotes($const);
+	$cname = &Texify($cname);
+	push(@allconstants, "\\schemetransconst{$cname}{$const}");
+    }
+}
+
+sub StripQuotes
+{
+    return &Texify(substr($_[0], 1, length($_[0]) - 2));
+}
+
+sub Texify
+{
+    $_[0] =~ s/_/\\_/g;
+    $_[0] =~ s/%/\\%/g;
+    $_[0] =~ s/>/\$>\$/g;
+    $_[0] =~ s/</\$<\$/g;
+    return $_[0];
+}
+
+sub IgnoreLine
+{
+}
+
+sub PrintHeader
+{
+}
+
+sub PrintDefine
+{
+}
diff --git a/src/worksp/gc/gc.mak b/src/worksp/gc/gc.mak
new file mode 100644
index 0000000..d07e2b1
--- /dev/null
+++ b/src/worksp/gc/gc.mak
@@ -0,0 +1,1075 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=gc - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to gc - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "gc - Win32 Release" && "$(CFG)" != "gc - Win32 Debug" &&\
+ "$(CFG)" != "gc - Win32 Threads"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "gc.mak" CFG="gc - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "gc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "gc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "gc - Win32 Threads" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "gc - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\gc.lib"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\gc.lib"
+	-@erase "Release\Malloc.obj"
+	-@erase "Release\Headers.obj"
+	-@erase "Release\Reclaim.obj"
+	-@erase "Release\Allchblk.obj"
+	-@erase "Release\Mark.obj"
+	-@erase "Release\Finalize.obj"
+	-@erase "Release\Blacklst.obj"
+	-@erase "Release\Os_dep.obj"
+	-@erase "Release\winthred.obj"
+	-@erase "Release\Obj_map.obj"
+	-@erase "Release\Mach_dep.obj"
+	-@erase "Release\Stubborn.obj"
+	-@erase "Release\Alloc.obj"
+	-@erase "Release\Mark_rts.obj"
+	-@erase "Release\Dyn_load.obj"
+	-@erase "Release\Misc.obj"
+	-@erase "Release\Mallocx.obj"
+	-@erase "Release\New_hblk.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /D "NDEBUG" /D "__STDC__" /D "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /YX /c
+# SUBTRACT CPP /X
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /D "NDEBUG" /D "__STDC__" /D\
+ "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/gc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Malloc.obj" \
+	"$(INTDIR)/Headers.obj" \
+	"$(INTDIR)/Reclaim.obj" \
+	"$(INTDIR)/Allchblk.obj" \
+	"$(INTDIR)/Mark.obj" \
+	"$(INTDIR)/Finalize.obj" \
+	"$(INTDIR)/Blacklst.obj" \
+	"$(INTDIR)/Os_dep.obj" \
+	"$(INTDIR)/winthred.obj" \
+	"$(INTDIR)/Obj_map.obj" \
+	"$(INTDIR)/Mach_dep.obj" \
+	"$(INTDIR)/Stubborn.obj" \
+	"$(INTDIR)/Alloc.obj" \
+	"$(INTDIR)/Mark_rts.obj" \
+	"$(INTDIR)/Dyn_load.obj" \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Mallocx.obj" \
+	"$(INTDIR)/New_hblk.obj"
+
+"$(OUTDIR)\gc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\gc.lib"
+
+CLEAN : 
+	-@erase "Debug\vc40.pdb"
+	-@erase "Debug\gc.lib"
+	-@erase "Debug\Mallocx.obj"
+	-@erase "Debug\Malloc.obj"
+	-@erase "Debug\Allchblk.obj"
+	-@erase "Debug\Finalize.obj"
+	-@erase "Debug\Blacklst.obj"
+	-@erase "Debug\Headers.obj"
+	-@erase "Debug\Mach_dep.obj"
+	-@erase "Debug\Stubborn.obj"
+	-@erase "Debug\Mark_rts.obj"
+	-@erase "Debug\Reclaim.obj"
+	-@erase "Debug\Misc.obj"
+	-@erase "Debug\Dyn_load.obj"
+	-@erase "Debug\Mark.obj"
+	-@erase "Debug\New_hblk.obj"
+	-@erase "Debug\winthred.obj"
+	-@erase "Debug\Alloc.obj"
+	-@erase "Debug\Obj_map.obj"
+	-@erase "Debug\Os_dep.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /GX /Zi /Od /D "_DEBUG" /D "__STDC__" /D "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /YX /c
+# SUBTRACT CPP /X
+CPP_PROJ=/nologo /MTd /W3 /GX /Zi /Od /D "_DEBUG" /D "__STDC__" /D\
+ "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/gc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Mallocx.obj" \
+	"$(INTDIR)/Malloc.obj" \
+	"$(INTDIR)/Allchblk.obj" \
+	"$(INTDIR)/Finalize.obj" \
+	"$(INTDIR)/Blacklst.obj" \
+	"$(INTDIR)/Headers.obj" \
+	"$(INTDIR)/Mach_dep.obj" \
+	"$(INTDIR)/Stubborn.obj" \
+	"$(INTDIR)/Mark_rts.obj" \
+	"$(INTDIR)/Reclaim.obj" \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Dyn_load.obj" \
+	"$(INTDIR)/Mark.obj" \
+	"$(INTDIR)/New_hblk.obj" \
+	"$(INTDIR)/winthred.obj" \
+	"$(INTDIR)/Alloc.obj" \
+	"$(INTDIR)/Obj_map.obj" \
+	"$(INTDIR)/Os_dep.obj"
+
+"$(OUTDIR)\gc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "gc___Win"
+# PROP BASE Intermediate_Dir "gc___Win"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Threads"
+# PROP Intermediate_Dir "Threads"
+# PROP Target_Dir ""
+OUTDIR=Threads
+INTDIR=Threads
+
+ALL : "$(OUTDIR)\gc.lib"
+
+CLEAN : 
+	-@erase "Threads\vc40.pdb"
+	-@erase "Threads\gc.lib"
+	-@erase "Threads\New_hblk.obj"
+	-@erase "Threads\Obj_map.obj"
+	-@erase "Threads\Headers.obj"
+	-@erase "Threads\Misc.obj"
+	-@erase "Threads\Mallocx.obj"
+	-@erase "Threads\Reclaim.obj"
+	-@erase "Threads\Alloc.obj"
+	-@erase "Threads\Allchblk.obj"
+	-@erase "Threads\Finalize.obj"
+	-@erase "Threads\Blacklst.obj"
+	-@erase "Threads\winthred.obj"
+	-@erase "Threads\Mark.obj"
+	-@erase "Threads\Os_dep.obj"
+	-@erase "Threads\Mach_dep.obj"
+	-@erase "Threads\Stubborn.obj"
+	-@erase "Threads\Mark_rts.obj"
+	-@erase "Threads\Malloc.obj"
+	-@erase "Threads\Dyn_load.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /D "NDEBUG" /D "WIN32_THREADS" /D "__STDC__" /D "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /YX /c
+# SUBTRACT CPP /X
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /D "NDEBUG" /D "WIN32_THREADS" /D\
+ "__STDC__" /D "XXX_NO_AUTO_STACK_PUSH" /D "SILENT" /Fp"$(INTDIR)/gc.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Threads/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/gc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/gc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/New_hblk.obj" \
+	"$(INTDIR)/Obj_map.obj" \
+	"$(INTDIR)/Headers.obj" \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Mallocx.obj" \
+	"$(INTDIR)/Reclaim.obj" \
+	"$(INTDIR)/Alloc.obj" \
+	"$(INTDIR)/Allchblk.obj" \
+	"$(INTDIR)/Finalize.obj" \
+	"$(INTDIR)/Blacklst.obj" \
+	"$(INTDIR)/winthred.obj" \
+	"$(INTDIR)/Mark.obj" \
+	"$(INTDIR)/Os_dep.obj" \
+	"$(INTDIR)/Mach_dep.obj" \
+	"$(INTDIR)/Stubborn.obj" \
+	"$(INTDIR)/Mark_rts.obj" \
+	"$(INTDIR)/Malloc.obj" \
+	"$(INTDIR)/Dyn_load.obj"
+
+"$(OUTDIR)\gc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "gc - Win32 Release"
+# Name "gc - Win32 Debug"
+# Name "gc - Win32 Threads"
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Allchblk.c
+DEP_CPP_ALLCH=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_ALLCH=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Allchblk.obj" : $(SOURCE) $(DEP_CPP_ALLCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Alloc.c
+DEP_CPP_ALLOC=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_ALLOC=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Alloc.obj" : $(SOURCE) $(DEP_CPP_ALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Blacklst.c
+DEP_CPP_BLACK=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_BLACK=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Blacklst.obj" : $(SOURCE) $(DEP_CPP_BLACK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Dyn_load.c
+DEP_CPP_DYN_L=\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_DYN_L=\
+	".\..\..\Mzscheme\Gc\il\PCR_IL.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	".\..\..\Mzscheme\Gc\mm\PCR_MM.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Dyn_load.obj" : $(SOURCE) $(DEP_CPP_DYN_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Finalize.c
+DEP_CPP_FINAL=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	".\..\..\Mzscheme\Gc\gc_mark.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_FINAL=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Finalize.obj" : $(SOURCE) $(DEP_CPP_FINAL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Headers.c
+DEP_CPP_HEADE=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_HEADE=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Headers.obj" : $(SOURCE) $(DEP_CPP_HEADE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Mach_dep.c
+DEP_CPP_MACH_=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MACH_=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Mach_dep.obj" : $(SOURCE) $(DEP_CPP_MACH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Malloc.c
+DEP_CPP_MALLO=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MALLO=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Malloc.obj" : $(SOURCE) $(DEP_CPP_MALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Mark.c
+DEP_CPP_MARK_=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	".\..\..\Mzscheme\Gc\gc_mark.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MARK_=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Mark.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Mark.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Mark.obj" : $(SOURCE) $(DEP_CPP_MARK_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Mark_rts.c
+DEP_CPP_MARK_R=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MARK_R=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Mark_rts.obj" : $(SOURCE) $(DEP_CPP_MARK_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Misc.c
+DEP_CPP_MISC_=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MISC_=\
+	".\..\..\Mzscheme\Gc\il\PCR_IL.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\New_hblk.c
+DEP_CPP_NEW_H=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_NEW_H=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\New_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\New_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\New_hblk.obj" : $(SOURCE) $(DEP_CPP_NEW_H) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Obj_map.c
+DEP_CPP_OBJ_M=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_OBJ_M=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Obj_map.obj" : $(SOURCE) $(DEP_CPP_OBJ_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Os_dep.c
+DEP_CPP_OS_DE=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_OS_DE=\
+	".\..\..\Mzscheme\Gc\il\PCR_IL.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	".\..\..\Mzscheme\Gc\mm\PCR_MM.h"\
+	".\..\..\Mzscheme\Gc\vd\PCR_VD.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Os_dep.obj" : $(SOURCE) $(DEP_CPP_OS_DE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Reclaim.c
+DEP_CPP_RECLA=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_RECLA=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Reclaim.obj" : $(SOURCE) $(DEP_CPP_RECLA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Stubborn.c
+DEP_CPP_STUBB=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_STUBB=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Stubborn.obj" : $(SOURCE) $(DEP_CPP_STUBB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Gc\Mallocx.c
+DEP_CPP_MALLOC=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_MALLOC=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\Mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\Mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\Mallocx.obj" : $(SOURCE) $(DEP_CPP_MALLOC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mzscheme\gc\winthred.c
+DEP_CPP_WINTH=\
+	".\..\..\Mzscheme\Gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Gc\gc.h"\
+	".\..\..\Mzscheme\Gc\config.h"\
+	".\..\..\Mzscheme\Gc\gc_hdrs.h"\
+	
+NODEP_CPP_WINTH=\
+	".\..\..\Mzscheme\Gc\th\PCR_Th.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCrSec.h"\
+	".\..\..\Mzscheme\Gc\th\PCR_ThCtl.h"\
+	
+
+!IF  "$(CFG)" == "gc - Win32 Release"
+
+
+"$(INTDIR)\winthred.obj" : $(SOURCE) $(DEP_CPP_WINTH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Debug"
+
+
+"$(INTDIR)\winthred.obj" : $(SOURCE) $(DEP_CPP_WINTH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "gc - Win32 Threads"
+
+
+"$(INTDIR)\winthred.obj" : $(SOURCE) $(DEP_CPP_WINTH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/gc/gc.mdp b/src/worksp/gc/gc.mdp
new file mode 100755
index 0000000..1061c94
Binary files /dev/null and b/src/worksp/gc/gc.mdp differ
diff --git a/src/worksp/mred/mred.ico b/src/worksp/mred/mred.ico
new file mode 100755
index 0000000..0681e69
Binary files /dev/null and b/src/worksp/mred/mred.ico differ
diff --git a/src/worksp/mred/mred.mak b/src/worksp/mred/mred.mak
new file mode 100644
index 0000000..6401f43
--- /dev/null
+++ b/src/worksp/mred/mred.mak
@@ -0,0 +1,3662 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+!IF "$(CFG)" == ""
+CFG=mred - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to mred - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mred - Win32 Release" && "$(CFG)" != "mred - Win32 Debug" &&\
+ "$(CFG)" != "mred - Win32 SGC"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mred.mak" CFG="mred - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mred - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "mred - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "mred - Win32 SGC" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "mred - Win32 Debug"
+CPP=cl.exe
+RSC=rc.exe
+MTL=mktyplib.exe
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\mred.exe"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\mred.exe"
+	-@erase "Release\WX_STYLE.obj"
+	-@erase "Release\WX_MEDIA.obj"
+	-@erase "Release\WX_MEDAD.obj"
+	-@erase "Release\xcglue.obj"
+	-@erase "Release\WX_KEYM.obj"
+	-@erase "Release\mredgcpp.obj"
+	-@erase "Release\WX_MSNIP.obj"
+	-@erase "Release\WX_MPRIV.obj"
+	-@erase "Release\WX_MPBRD.obj"
+	-@erase "Release\WX_SNIP.obj"
+	-@erase "Release\WX_CGREC.obj"
+	-@erase "Release\WX_MBUF.obj"
+	-@erase "Release\MREDMSW.obj"
+	-@erase "Release\MRED.obj"
+	-@erase "Release\WX_MLINE.obj"
+	-@erase "Release\EDJR.obj"
+	-@erase "Release\WX_MEDIO.obj"
+	-@erase "Release\Mred.res"
+	-@erase "Release\mred.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mzscheme\utils" /D "NDEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /YX /c
+CPP_PROJ=/nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mzscheme\utils" /D "NDEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS"\
+ /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED"\
+ /Fp"$(INTDIR)/mred.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /i "..\..\wxwindow\include\msw" /i "..\..\wxwindow\contrib\fafa" /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Mred.res" /i "..\..\wxwindow\include\msw" /i\
+ "..\..\wxwindow\contrib\fafa" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mred.bsc" 
+BSC32_SBRS=
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 ..\wxs\Release\wxs.lib ..\wxutils\Release\wxutils.lib ..\wxwin\Release\wxwin.lib ..\mzsrc\Release\mzsrc.lib ..\gc\Release\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc.lib"
+# SUBTRACT LINK32 /incremental:yes
+LINK32_FLAGS=..\wxs\Release\wxs.lib\
+ ..\wxutils\Release\wxutils.lib\
+ ..\wxwin\Release\wxwin.lib\
+ ..\mzsrc\Release\mzsrc.lib ..\gc\Release\gc.lib\
+ kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib\
+ shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib\
+ winmm.lib /nologo /subsystem:windows /incremental:no /pdb:"$(OUTDIR)/mred.pdb"\
+ /debug /machine:I386 /nodefaultlib:"libc.lib" /out:"$(OUTDIR)/mred.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/WX_STYLE.obj" \
+	"$(INTDIR)/WX_MEDIA.obj" \
+	"$(INTDIR)/WX_MEDAD.obj" \
+	"$(INTDIR)/xcglue.obj" \
+	"$(INTDIR)/WX_KEYM.obj" \
+	"$(INTDIR)/mredgcpp.obj" \
+	"$(INTDIR)/WX_MSNIP.obj" \
+	"$(INTDIR)/WX_MPRIV.obj" \
+	"$(INTDIR)/WX_MPBRD.obj" \
+	"$(INTDIR)/WX_SNIP.obj" \
+	"$(INTDIR)/WX_CGREC.obj" \
+	"$(INTDIR)/WX_MBUF.obj" \
+	"$(INTDIR)/MREDMSW.obj" \
+	"$(INTDIR)/MRED.obj" \
+	"$(INTDIR)/WX_MLINE.obj" \
+	"$(INTDIR)/EDJR.obj" \
+	"$(INTDIR)/WX_MEDIO.obj" \
+	"$(INTDIR)/Mred.res"
+
+"$(OUTDIR)\mred.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=.\Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\mred.exe" "$(OUTDIR)\mred.bsc"
+
+CLEAN : 
+	-@erase "Debug\vc40.pdb"
+	-@erase "Debug\vc40.idb"
+	-@erase ".\Debug\mred.bsc"
+	-@erase "Debug\WX_MEDIA.sbr"
+	-@erase "Debug\EDJR.sbr"
+	-@erase "Debug\mredgcpp.sbr"
+	-@erase "Debug\WX_SNIP.sbr"
+	-@erase "Debug\WX_KEYM.sbr"
+	-@erase "Debug\WX_MPRIV.sbr"
+	-@erase "Debug\WX_MPBRD.sbr"
+	-@erase "Debug\WX_MBUF.sbr"
+	-@erase "Debug\MREDMSW.sbr"
+	-@erase "Debug\WX_CGREC.sbr"
+	-@erase "Debug\WX_STYLE.sbr"
+	-@erase "Debug\WX_MEDAD.sbr"
+	-@erase "Debug\WX_MLINE.sbr"
+	-@erase "Debug\MRED.sbr"
+	-@erase "Debug\WX_MSNIP.sbr"
+	-@erase "Debug\WX_MEDIO.sbr"
+	-@erase "Debug\xcglue.sbr"
+	-@erase ".\Debug\mred.exe"
+	-@erase "Debug\WX_MLINE.obj"
+	-@erase "Debug\MRED.obj"
+	-@erase "Debug\WX_MSNIP.obj"
+	-@erase "Debug\WX_MEDIO.obj"
+	-@erase "Debug\xcglue.obj"
+	-@erase "Debug\WX_MEDIA.obj"
+	-@erase "Debug\EDJR.obj"
+	-@erase "Debug\mredgcpp.obj"
+	-@erase "Debug\WX_SNIP.obj"
+	-@erase "Debug\WX_KEYM.obj"
+	-@erase "Debug\WX_MPRIV.obj"
+	-@erase "Debug\WX_MPBRD.obj"
+	-@erase "Debug\WX_MBUF.obj"
+	-@erase "Debug\MREDMSW.obj"
+	-@erase "Debug\WX_CGREC.obj"
+	-@erase "Debug\WX_STYLE.obj"
+	-@erase "Debug\WX_MEDAD.obj"
+	-@erase "Debug\Mred.res"
+	-@erase ".\Debug\mred.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+"$(INTDIR)" :
+    if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mzscheme\utils" /D "_DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /FR /YX /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mzscheme\utils" /D "_DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS"\
+ /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED"\
+ /FR"$(INTDIR)/" /Fp"$(INTDIR)/mred.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=Debug/
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /i "..\..\wxwindow\include\msw" /i "..\..\wxwindow\contrib\fafa" /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Mred.res" /i "..\..\wxwindow\include\msw" /i\
+ "..\..\wxwindow\contrib\fafa" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mred.bsc" 
+BSC32_SBRS= \
+	"$(INTDIR)/WX_MEDIA.sbr" \
+	"$(INTDIR)/EDJR.sbr" \
+	"$(INTDIR)/mredgcpp.sbr" \
+	"$(INTDIR)/WX_SNIP.sbr" \
+	"$(INTDIR)/WX_KEYM.sbr" \
+	"$(INTDIR)/WX_MPRIV.sbr" \
+	"$(INTDIR)/WX_MPBRD.sbr" \
+	"$(INTDIR)/WX_MBUF.sbr" \
+	"$(INTDIR)/MREDMSW.sbr" \
+	"$(INTDIR)/WX_CGREC.sbr" \
+	"$(INTDIR)/WX_STYLE.sbr" \
+	"$(INTDIR)/WX_MEDAD.sbr" \
+	"$(INTDIR)/WX_MLINE.sbr" \
+	"$(INTDIR)/MRED.sbr" \
+	"$(INTDIR)/WX_MSNIP.sbr" \
+	"$(INTDIR)/WX_MEDIO.sbr" \
+	"$(INTDIR)/xcglue.sbr"
+
+"$(OUTDIR)\mred.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 libc.lib ..\wxs\Debug\wxs.lib ..\wxutils\Debug\wxutils.lib ..\wxwin\Debug\wxwin.lib ..\mzsrc\Debug\mzsrc.lib ..\gc\Debug\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /incremental:no /debug /machine:I386 /nodefaultlib:"libcd.lib"
+# SUBTRACT LINK32 /pdb:none
+LINK32_FLAGS=libc.lib ..\wxs\Debug\wxs.lib\
+ ..\wxutils\Debug\wxutils.lib\
+ ..\wxwin\Debug\wxwin.lib ..\mzsrc\Debug\mzsrc.lib\
+ ..\gc\Debug\gc.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo\
+ /subsystem:windows /incremental:no /pdb:"$(OUTDIR)/mred.pdb" /debug\
+ /machine:I386 /nodefaultlib:"libcd.lib" /out:"$(OUTDIR)/mred.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/WX_MLINE.obj" \
+	"$(INTDIR)/MRED.obj" \
+	"$(INTDIR)/WX_MSNIP.obj" \
+	"$(INTDIR)/WX_MEDIO.obj" \
+	"$(INTDIR)/xcglue.obj" \
+	"$(INTDIR)/WX_MEDIA.obj" \
+	"$(INTDIR)/EDJR.obj" \
+	"$(INTDIR)/mredgcpp.obj" \
+	"$(INTDIR)/WX_SNIP.obj" \
+	"$(INTDIR)/WX_KEYM.obj" \
+	"$(INTDIR)/WX_MPRIV.obj" \
+	"$(INTDIR)/WX_MPBRD.obj" \
+	"$(INTDIR)/WX_MBUF.obj" \
+	"$(INTDIR)/MREDMSW.obj" \
+	"$(INTDIR)/WX_CGREC.obj" \
+	"$(INTDIR)/WX_STYLE.obj" \
+	"$(INTDIR)/WX_MEDAD.obj" \
+	"$(INTDIR)/Mred.res"
+
+"$(OUTDIR)\mred.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "mred___W"
+# PROP BASE Intermediate_Dir "mred___W"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=.\SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\mred.exe" "$(OUTDIR)\mred.bsc"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\vc40.idb"
+	-@erase ".\SGC\mred.bsc"
+	-@erase "SGC\WX_SNIP.sbr"
+	-@erase "SGC\WX_KEYM.sbr"
+	-@erase "SGC\WX_MBUF.sbr"
+	-@erase "SGC\MREDMSW.sbr"
+	-@erase "SGC\xcglue.sbr"
+	-@erase "SGC\WX_MLINE.sbr"
+	-@erase "SGC\WX_STYLE.sbr"
+	-@erase "SGC\EDJR.sbr"
+	-@erase "SGC\WX_MEDAD.sbr"
+	-@erase "SGC\mredgcpp.sbr"
+	-@erase "SGC\WX_MSNIP.sbr"
+	-@erase "SGC\MRED.sbr"
+	-@erase "SGC\WX_MPRIV.sbr"
+	-@erase "SGC\WX_MEDIO.sbr"
+	-@erase "SGC\WX_MPBRD.sbr"
+	-@erase "SGC\WX_MEDIA.sbr"
+	-@erase "SGC\WX_CGREC.sbr"
+	-@erase ".\SGC\mred.exe"
+	-@erase "SGC\MRED.obj"
+	-@erase "SGC\WX_MPRIV.obj"
+	-@erase "SGC\WX_MEDIO.obj"
+	-@erase "SGC\WX_MPBRD.obj"
+	-@erase "SGC\WX_MEDIA.obj"
+	-@erase "SGC\WX_CGREC.obj"
+	-@erase "SGC\WX_SNIP.obj"
+	-@erase "SGC\WX_KEYM.obj"
+	-@erase "SGC\WX_MBUF.obj"
+	-@erase "SGC\MREDMSW.obj"
+	-@erase "SGC\xcglue.obj"
+	-@erase "SGC\WX_MLINE.obj"
+	-@erase "SGC\WX_STYLE.obj"
+	-@erase "SGC\EDJR.obj"
+	-@erase "SGC\WX_MEDAD.obj"
+	-@erase "SGC\mredgcpp.obj"
+	-@erase "SGC\WX_MSNIP.obj"
+	-@erase "SGC\Mred.res"
+	-@erase ".\SGC\mred.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+"$(INTDIR)" :
+    if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /Zi /Od /I "c:\matthew\wxwindow\include\base" /I "c:\Matthew\wxwindow\include\msw" /I "c:\Matthew\mred\mzscheme\include" /I "c:\Matthew\mred\mzscheme\gc" /I "c:\Matthew\mred\wxme" /I "c:\Matthew\mred\mzscheme\utils" /D "_DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /FR /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mred\mzscheme\sgc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mred\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mred\mzscheme\utils" /D "_DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNTER" /FR /YX /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mred\mzscheme\sgc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mred\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mred\mzscheme\utils" /D "_DEBUG" /D "__STDC__" /D "WIN32" /D\
+ "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D\
+ "WXME_FOR_MRED" /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNTER"\
+ /FR"$(INTDIR)/" /Fp"$(INTDIR)/mred.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=SGC/
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE RSC /l 0x409 /i "c:\matthew\wxwindow\include\msw" /i "c:\matthew\wxwindow\contrib\fafa" /d "_DEBUG"
+# ADD RSC /l 0x409 /i "..\..\wxwindow\include\msw" /i "..\..\wxwindow\contrib\fafa" /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/Mred.res" /i "..\..\wxwindow\include\msw" /i\
+ "..\..\wxwindow\contrib\fafa" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mred.bsc" 
+BSC32_SBRS= \
+	"$(INTDIR)/WX_SNIP.sbr" \
+	"$(INTDIR)/WX_KEYM.sbr" \
+	"$(INTDIR)/WX_MBUF.sbr" \
+	"$(INTDIR)/MREDMSW.sbr" \
+	"$(INTDIR)/xcglue.sbr" \
+	"$(INTDIR)/WX_MLINE.sbr" \
+	"$(INTDIR)/WX_STYLE.sbr" \
+	"$(INTDIR)/EDJR.sbr" \
+	"$(INTDIR)/WX_MEDAD.sbr" \
+	"$(INTDIR)/mredgcpp.sbr" \
+	"$(INTDIR)/WX_MSNIP.sbr" \
+	"$(INTDIR)/MRED.sbr" \
+	"$(INTDIR)/WX_MPRIV.sbr" \
+	"$(INTDIR)/WX_MEDIO.sbr" \
+	"$(INTDIR)/WX_MPBRD.sbr" \
+	"$(INTDIR)/WX_MEDIA.sbr" \
+	"$(INTDIR)/WX_CGREC.sbr"
+
+"$(OUTDIR)\mred.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
+    $(BSC32) @<<
+  $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 libc.lib ..\wxs\Debug\wxs.lib ..\wxwin\Debug\wxwin.lib ..\mzsrc\DebugOpt\mzsrc.lib ..\gc\DebugOpt\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /incremental:no /debug /machine:I386 /nodefaultlib:"libcd.lib"
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 ..\wxs\SGC\wxs.lib ..\wxutils\SGC\wxutils.lib ..\wxwin\SGC\wxwin.lib ..\mzsrc\SGC\mzsrc.lib ..\sgc\Debug\sgc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib libc.lib /nologo /subsystem:windows /incremental:no /debug /machine:I386 /nodefaultlib:"libcd.lib"
+# SUBTRACT LINK32 /pdb:none
+LINK32_FLAGS=..\wxs\SGC\wxs.lib\
+ ..\wxutils\SGC\wxutils.lib ..\wxwin\SGC\wxwin.lib\
+ ..\mzsrc\SGC\mzsrc.lib ..\sgc\Debug\sgc.lib\
+ kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib\
+ shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib\
+ winmm.lib libc.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/mred.pdb" /debug /machine:I386 /nodefaultlib:"libcd.lib"\
+ /out:"$(OUTDIR)/mred.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/MRED.obj" \
+	"$(INTDIR)/WX_MPRIV.obj" \
+	"$(INTDIR)/WX_MEDIO.obj" \
+	"$(INTDIR)/WX_MPBRD.obj" \
+	"$(INTDIR)/WX_MEDIA.obj" \
+	"$(INTDIR)/WX_CGREC.obj" \
+	"$(INTDIR)/WX_SNIP.obj" \
+	"$(INTDIR)/WX_KEYM.obj" \
+	"$(INTDIR)/WX_MBUF.obj" \
+	"$(INTDIR)/MREDMSW.obj" \
+	"$(INTDIR)/xcglue.obj" \
+	"$(INTDIR)/WX_MLINE.obj" \
+	"$(INTDIR)/WX_STYLE.obj" \
+	"$(INTDIR)/EDJR.obj" \
+	"$(INTDIR)/WX_MEDAD.obj" \
+	"$(INTDIR)/mredgcpp.obj" \
+	"$(INTDIR)/WX_MSNIP.obj" \
+	"$(INTDIR)/Mred.res"
+
+"$(OUTDIR)\mred.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "mred - Win32 Release"
+# Name "mred - Win32 Debug"
+# Name "mred - Win32 SGC"
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\EDJR.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_EDJR_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+"$(INTDIR)\EDJR.obj" : $(SOURCE) $(DEP_CPP_EDJR_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_EDJR_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\EDJR.obj" : $(SOURCE) $(DEP_CPP_EDJR_) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\EDJR.sbr" : $(SOURCE) $(DEP_CPP_EDJR_) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_EDJR_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+NODEP_CPP_EDJR_=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\EDJR.obj" : $(SOURCE) $(DEP_CPP_EDJR_) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\EDJR.sbr" : $(SOURCE) $(DEP_CPP_EDJR_) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_CGREC.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_CG=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+"$(INTDIR)\WX_CGREC.obj" : $(SOURCE) $(DEP_CPP_WX_CG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_CG=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_CGREC.obj" : $(SOURCE) $(DEP_CPP_WX_CG) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_CGREC.sbr" : $(SOURCE) $(DEP_CPP_WX_CG) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_CG=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+NODEP_CPP_WX_CG=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_CGREC.obj" : $(SOURCE) $(DEP_CPP_WX_CG) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_CGREC.sbr" : $(SOURCE) $(DEP_CPP_WX_CG) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_KEYM.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_KE=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	
+
+"$(INTDIR)\WX_KEYM.obj" : $(SOURCE) $(DEP_CPP_WX_KE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_KE=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_KEYM.obj" : $(SOURCE) $(DEP_CPP_WX_KE) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_KEYM.sbr" : $(SOURCE) $(DEP_CPP_WX_KE) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_KE=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	
+NODEP_CPP_WX_KE=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_KEYM.obj" : $(SOURCE) $(DEP_CPP_WX_KE) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_KEYM.sbr" : $(SOURCE) $(DEP_CPP_WX_KE) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MBUF.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MB=\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+"$(INTDIR)\WX_MBUF.obj" : $(SOURCE) $(DEP_CPP_WX_MB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MB=\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MBUF.obj" : $(SOURCE) $(DEP_CPP_WX_MB) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MBUF.sbr" : $(SOURCE) $(DEP_CPP_WX_MB) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MB=\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+NODEP_CPP_WX_MB=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MBUF.obj" : $(SOURCE) $(DEP_CPP_WX_MB) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MBUF.sbr" : $(SOURCE) $(DEP_CPP_WX_MB) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MEDAD.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\WX_MEDAD.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDAD.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDAD.sbr" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+NODEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDAD.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDAD.sbr" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MEDIA.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MED=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+"$(INTDIR)\WX_MEDIA.obj" : $(SOURCE) $(DEP_CPP_WX_MED) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MED=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDIA.obj" : $(SOURCE) $(DEP_CPP_WX_MED) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDIA.sbr" : $(SOURCE) $(DEP_CPP_WX_MED) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MED=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+NODEP_CPP_WX_MED=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDIA.obj" : $(SOURCE) $(DEP_CPP_WX_MED) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDIA.sbr" : $(SOURCE) $(DEP_CPP_WX_MED) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MEDIO.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MEDI=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_MEDIO.obj" : $(SOURCE) $(DEP_CPP_WX_MEDI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MEDI=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDIO.obj" : $(SOURCE) $(DEP_CPP_WX_MEDI) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDIO.sbr" : $(SOURCE) $(DEP_CPP_WX_MEDI) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MEDI=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+NODEP_CPP_WX_MEDI=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MEDIO.obj" : $(SOURCE) $(DEP_CPP_WX_MEDI) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MEDIO.sbr" : $(SOURCE) $(DEP_CPP_WX_MEDI) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MLINE.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_ML=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+"$(INTDIR)\WX_MLINE.obj" : $(SOURCE) $(DEP_CPP_WX_ML) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_ML=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MLINE.obj" : $(SOURCE) $(DEP_CPP_WX_ML) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MLINE.sbr" : $(SOURCE) $(DEP_CPP_WX_ML) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_ML=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+NODEP_CPP_WX_ML=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MLINE.obj" : $(SOURCE) $(DEP_CPP_WX_ML) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MLINE.sbr" : $(SOURCE) $(DEP_CPP_WX_ML) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MPBRD.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MP=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+"$(INTDIR)\WX_MPBRD.obj" : $(SOURCE) $(DEP_CPP_WX_MP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MP=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MPBRD.obj" : $(SOURCE) $(DEP_CPP_WX_MP) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MPBRD.sbr" : $(SOURCE) $(DEP_CPP_WX_MP) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MP=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+NODEP_CPP_WX_MP=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MPBRD.obj" : $(SOURCE) $(DEP_CPP_WX_MP) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MPBRD.sbr" : $(SOURCE) $(DEP_CPP_WX_MP) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MPRIV.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MPR=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+"$(INTDIR)\WX_MPRIV.obj" : $(SOURCE) $(DEP_CPP_WX_MPR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MPR=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MPRIV.obj" : $(SOURCE) $(DEP_CPP_WX_MPR) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MPRIV.sbr" : $(SOURCE) $(DEP_CPP_WX_MPR) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MPR=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+NODEP_CPP_WX_MPR=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MPRIV.obj" : $(SOURCE) $(DEP_CPP_WX_MPR) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MPRIV.sbr" : $(SOURCE) $(DEP_CPP_WX_MPR) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_MSNIP.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_MS=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+"$(INTDIR)\WX_MSNIP.obj" : $(SOURCE) $(DEP_CPP_WX_MS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_MS=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MSNIP.obj" : $(SOURCE) $(DEP_CPP_WX_MS) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MSNIP.sbr" : $(SOURCE) $(DEP_CPP_WX_MS) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_MS=\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_mpriv.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mred\Wxme\wx_mline.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxme\wx_gclip.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	
+NODEP_CPP_WX_MS=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_MSNIP.obj" : $(SOURCE) $(DEP_CPP_WX_MS) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_MSNIP.sbr" : $(SOURCE) $(DEP_CPP_WX_MS) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_SNIP.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_SN=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+"$(INTDIR)\WX_SNIP.obj" : $(SOURCE) $(DEP_CPP_WX_SN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_SN=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_SNIP.obj" : $(SOURCE) $(DEP_CPP_WX_SN) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_SNIP.sbr" : $(SOURCE) $(DEP_CPP_WX_SN) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_SN=\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\mred\Wxme\wx_gcrct.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	
+NODEP_CPP_WX_SN=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_SNIP.obj" : $(SOURCE) $(DEP_CPP_WX_SN) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_SNIP.sbr" : $(SOURCE) $(DEP_CPP_WX_SN) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxme\WX_STYLE.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	
+
+"$(INTDIR)\WX_STYLE.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_STYLE.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_STYLE.sbr" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxme\wx_ptreq.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	
+NODEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\WX_STYLE.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\WX_STYLE.sbr" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\MRED.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_MRED_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\wxs\wxs_obj.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_MRED_=\
+	".\..\..\mred\simpledrop.h"\
+	".\..\..\mred\boundary.h"\
+	".\..\..\mred\wxscheme.h"\
+	".\..\..\mred\wxsmred.h"\
+	".\..\..\mred\wxs_fram.h"\
+	".\..\..\mred\wxs_obj.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\MRED.obj" : $(SOURCE) $(DEP_CPP_MRED_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_MRED_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\wxs\wxs_obj.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_MRED_=\
+	".\..\..\mred\simpledrop.h"\
+	".\..\..\mred\boundary.h"\
+	".\..\..\mred\wxscheme.h"\
+	".\..\..\mred\wxsmred.h"\
+	".\..\..\mred\wxs_fram.h"\
+	".\..\..\mred\wxs_obj.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\MRED.obj" : $(SOURCE) $(DEP_CPP_MRED_) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\MRED.sbr" : $(SOURCE) $(DEP_CPP_MRED_) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_MRED_=\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\wxme\edjr.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\wxs\wxs_obj.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	
+NODEP_CPP_MRED_=\
+	".\..\..\mred\simpledrop.h"\
+	".\..\..\mred\boundary.h"\
+	".\..\..\mred\wxscheme.h"\
+	".\..\..\mred\wxsmred.h"\
+	".\..\..\mred\wxs_fram.h"\
+	".\..\..\mred\wxs_obj.h"\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	".\..\..\MRED\WXS\xcglue.h"\
+	".\..\..\MZSCHEME\UTILS\scheme.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\MRED.obj" : $(SOURCE) $(DEP_CPP_MRED_) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\MRED.sbr" : $(SOURCE) $(DEP_CPP_MRED_) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\MREDMSW.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_MREDM=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\mzscheme\src\schwinfd.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+NODEP_CPP_MREDM=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\MREDMSW.obj" : $(SOURCE) $(DEP_CPP_MREDM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_MREDM=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\mzscheme\src\schwinfd.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+NODEP_CPP_MREDM=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\MREDMSW.obj" : $(SOURCE) $(DEP_CPP_MREDM) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\MREDMSW.sbr" : $(SOURCE) $(DEP_CPP_MREDM) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_MREDM=\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\mred\mred.h"\
+	".\..\..\mzscheme\src\schwinfd.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\Wxme\Wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxme\Wx_snip.h"\
+	".\..\..\mred\Wxme\Wx_cgrec.h"\
+	".\..\..\mred\Wxme\Wx_medad.h"\
+	".\..\..\mred\Wxme\Wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\Wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+NODEP_CPP_MREDM=\
+	".\..\..\mred\scheme.h"\
+	".\..\..\wxwindow\include\base\gc_cpp.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\MREDMSW.obj" : $(SOURCE) $(DEP_CPP_MREDM) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\MREDMSW.sbr" : $(SOURCE) $(DEP_CPP_MREDM) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\mredgcpp.cxx
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_MREDG=\
+	".\..\..\mzscheme\gc\gc_cpp.cc"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+"$(INTDIR)\mredgcpp.obj" : $(SOURCE) $(DEP_CPP_MREDG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_MREDG=\
+	".\..\..\mzscheme\gc\gc_cpp.cc"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\mredgcpp.obj" : $(SOURCE) $(DEP_CPP_MREDG) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\mredgcpp.sbr" : $(SOURCE) $(DEP_CPP_MREDG) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+NODEP_CPP_MREDG=\
+	".\..\..\mred\gc_cpp.cc"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\mredgcpp.obj" : $(SOURCE) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\mredgcpp.sbr" : $(SOURCE) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Mred.rc
+DEP_RSC_MRED_R=\
+	".\mred.ico"\
+	".\mreddoc.ico"\
+	".\..\..\wxwindow\include\msw\wx.rc"\
+	
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+
+"$(INTDIR)\Mred.res" : $(SOURCE) $(DEP_RSC_MRED_R) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+
+"$(INTDIR)\Mred.res" : $(SOURCE) $(DEP_RSC_MRED_R) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+
+"$(INTDIR)\Mred.res" : $(SOURCE) $(DEP_RSC_MRED_R) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\MFLATT\PROJ\MZSCHEME\UTILS\xcglue.c
+
+!IF  "$(CFG)" == "mred - Win32 Release"
+
+DEP_CPP_XCGLU=\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_XCGLU=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\xcglue.obj" : $(SOURCE) $(DEP_CPP_XCGLU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mred - Win32 Debug"
+
+DEP_CPP_XCGLU=\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_XCGLU=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\xcglue.obj" : $(SOURCE) $(DEP_CPP_XCGLU) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\xcglue.sbr" : $(SOURCE) $(DEP_CPP_XCGLU) "$(INTDIR)"
+   $(BuildCmds)
+
+!ELSEIF  "$(CFG)" == "mred - Win32 SGC"
+
+DEP_CPP_XCGLU=\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	
+NODEP_CPP_XCGLU=\
+	".\..\..\MZSCHEME\UTILS\gc.h"\
+	".\..\..\MZSCHEME\UTILS\scheme.h"\
+	
+
+BuildCmds= \
+	$(CPP) $(CPP_PROJ) $(SOURCE) \
+	
+
+"$(INTDIR)\xcglue.obj" : $(SOURCE) $(DEP_CPP_XCGLU) "$(INTDIR)"
+   $(BuildCmds)
+
+"$(INTDIR)\xcglue.sbr" : $(SOURCE) $(DEP_CPP_XCGLU) "$(INTDIR)"
+   $(BuildCmds)
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/mred/mred.mdp b/src/worksp/mred/mred.mdp
new file mode 100644
index 0000000..8bf4797
Binary files /dev/null and b/src/worksp/mred/mred.mdp differ
diff --git a/src/worksp/mred/mred.rc b/src/worksp/mred/mred.rc
new file mode 100755
index 0000000..c32f451
--- /dev/null
+++ b/src/worksp/mred/mred.rc
@@ -0,0 +1,53 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "wx.rc"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+WXSTD_FRAME             ICON    DISCARDABLE     "mred.ico"
+WXSTD_MDICHILDFRAME     ICON    DISCARDABLE     "mred.ico"
+WXSTD_MDIPARENTFRAME    ICON    DISCARDABLE     "mred.ico"
+APPLICATION             ICON    DISCARDABLE     "mred.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 43,0,0,0
+ PRODUCTVERSION 43,0,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "PLT, Rice University\0"
+            VALUE "FileDescription", "mred\0"
+            VALUE "FileVersion", "43, 0, 0, 0\0"
+            VALUE "InternalName", "mred\0"
+            VALUE "LegalCopyright", "Copyright © 1995-96\0"
+            VALUE "OriginalFilename", "mred.exe\0"
+            VALUE "ProductName", "MrEd\0"
+            VALUE "ProductVersion", "43, 0, 0, 0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
diff --git a/src/worksp/mzscheme/mzscheme.ico b/src/worksp/mzscheme/mzscheme.ico
new file mode 100755
index 0000000..54aafb3
Binary files /dev/null and b/src/worksp/mzscheme/mzscheme.ico differ
diff --git a/src/worksp/mzscheme/mzscheme.mak b/src/worksp/mzscheme/mzscheme.mak
new file mode 100644
index 0000000..3dc4274
--- /dev/null
+++ b/src/worksp/mzscheme/mzscheme.mak
@@ -0,0 +1,459 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+!IF "$(CFG)" == ""
+CFG=mzscheme - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to mzscheme - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mzscheme - Win32 Release" && "$(CFG)" !=\
+ "mzscheme - Win32 Debug" && "$(CFG)" != "mzscheme - Win32 SGC" && "$(CFG)" !=\
+ "mzscheme - Win32 Threads"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mzscheme.mak" CFG="mzscheme - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mzscheme - Win32 Release" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE "mzscheme - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "mzscheme - Win32 SGC" (based on "Win32 (x86) Console Application")
+!MESSAGE "mzscheme - Win32 Threads" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "mzscheme - Win32 Debug"
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "mzscheme - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\mzscheme.exe"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\mzscheme.exe"
+	-@erase "Release\Main.obj"
+	-@erase "Release\mzscheme.res"
+	-@erase "Release\mzscheme.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\mzscheme\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /I "..\..\mzscheme\include" /D "WIN32"\
+ /D "NDEBUG" /D "_CONSOLE" /Fp"$(INTDIR)/mzscheme.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/mzscheme.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzscheme.bsc" 
+BSC32_SBRS=
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\mzsrc\Release\mzsrc.lib ..\gc\Release\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none /incremental:yes
+LINK32_FLAGS=..\mzsrc\Release\mzsrc.lib\
+ ..\gc\Release\gc.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console\
+ /incremental:no /pdb:"$(OUTDIR)/mzscheme.pdb" /debug /machine:I386\
+ /out:"$(OUTDIR)/mzscheme.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/Main.obj" \
+	"$(INTDIR)/mzscheme.res"
+
+"$(OUTDIR)\mzscheme.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\mzscheme.exe"
+
+CLEAN : 
+	-@erase "Debug\vc40.pdb"
+	-@erase "Debug\vc40.idb"
+	-@erase "Debug\mzscheme.exe"
+	-@erase "Debug\Main.obj"
+	-@erase "Debug\mzscheme.res"
+	-@erase "Debug\mzscheme.ilk"
+	-@erase "Debug\mzscheme.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\mzscheme\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\mzscheme\include" /D\
+ "WIN32" /D "_DEBUG" /D "_CONSOLE" /Fp"$(INTDIR)/mzscheme.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/mzscheme.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzscheme.bsc" 
+BSC32_SBRS=
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 ..\mzsrc\Debug\mzsrc.lib ..\gc\Debug\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none
+LINK32_FLAGS=..\mzsrc\Debug\mzsrc.lib\
+ ..\gc\Debug\gc.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console\
+ /incremental:yes /pdb:"$(OUTDIR)/mzscheme.pdb" /debug /machine:I386\
+ /out:"$(OUTDIR)/mzscheme.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/Main.obj" \
+	"$(INTDIR)/mzscheme.res"
+
+"$(OUTDIR)\mzscheme.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "mzscheme"
+# PROP BASE Intermediate_Dir "mzscheme"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\mzscheme.exe"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\vc40.idb"
+	-@erase "SGC\mzscheme.exe"
+	-@erase "SGC\Main.obj"
+	-@erase "SGC\mzscheme.res"
+	-@erase "SGC\mzscheme.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /I "c:\Matthew\mzscheme\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\mzscheme\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D SGC_STD_DEBUGGING=1 /YX /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\..\mzscheme\include" /D\
+ "WIN32" /D "_DEBUG" /D "_CONSOLE" /D SGC_STD_DEBUGGING=1\
+ /Fp"$(INTDIR)/mzscheme.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/mzscheme.res" /d "_DEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzscheme.bsc" 
+BSC32_SBRS=
+LINK32=link.exe
+# ADD BASE LINK32 ..\mzsrc\Debug\mzsrc.lib ..\gc\Debug\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /debug /machine:I386
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 ..\mzsrc\SGC\mzsrc.lib ..\sgc\Debug\sgc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /incremental:no /debug /machine:I386 /nodefaultlib:"libcd.lib"
+# SUBTRACT LINK32 /pdb:none
+LINK32_FLAGS=..\mzsrc\SGC\mzsrc.lib\
+ ..\sgc\Debug\sgc.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console\
+ /incremental:no /pdb:"$(OUTDIR)/mzscheme.pdb" /debug /machine:I386\
+ /nodefaultlib:"libcd.lib" /out:"$(OUTDIR)/mzscheme.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/Main.obj" \
+	"$(INTDIR)/mzscheme.res"
+
+"$(OUTDIR)\mzscheme.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Threads"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "mzscheme"
+# PROP BASE Intermediate_Dir "mzscheme"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Threads"
+# PROP Intermediate_Dir "Threads"
+# PROP Target_Dir ""
+OUTDIR=Threads
+INTDIR=Threads
+
+ALL : "$(OUTDIR)\mzscheme.exe"
+
+CLEAN : 
+	-@erase "Threads\vc40.pdb"
+	-@erase "Threads\mzscheme.exe"
+	-@erase "Threads\Main.obj"
+	-@erase "Threads\mzscheme.res"
+	-@erase "Threads\mzscheme.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Zi /O2 /I "..\..\mzscheme\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\mzscheme\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "WIN32_THREADS" /YX /c
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /I "..\..\mzscheme\include" /D "WIN32"\
+ /D "NDEBUG" /D "_CONSOLE" /D "WIN32_THREADS" /Fp"$(INTDIR)/mzscheme.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Threads/
+CPP_SBRS=
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+RSC_PROJ=/l 0x409 /fo"$(INTDIR)/mzscheme.res" /d "NDEBUG" 
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzscheme.bsc" 
+BSC32_SBRS=
+LINK32=link.exe
+# ADD BASE LINK32 ..\mzsrc\Release\mzsrc.lib ..\gc\Release\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /machine:I386
+# SUBTRACT BASE LINK32 /pdb:none /incremental:yes /debug
+# ADD LINK32 ..\mzsrc\Threads\mzsrc.lib ..\gc\Threads\gc.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none /incremental:yes
+LINK32_FLAGS=..\mzsrc\Threads\mzsrc.lib\
+ ..\gc\Threads\gc.lib kernel32.lib user32.lib gdi32.lib\
+ winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib\
+ uuid.lib odbc32.lib odbccp32.lib wsock32.lib /nologo /subsystem:console\
+ /incremental:no /pdb:"$(OUTDIR)/mzscheme.pdb" /debug /machine:I386\
+ /out:"$(OUTDIR)/mzscheme.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)/Main.obj" \
+	"$(INTDIR)/mzscheme.res"
+
+"$(OUTDIR)\mzscheme.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "mzscheme - Win32 Release"
+# Name "mzscheme - Win32 Debug"
+# Name "mzscheme - Win32 SGC"
+# Name "mzscheme - Win32 Threads"
+
+!IF  "$(CFG)" == "mzscheme - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 SGC"
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Threads"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Main.c
+
+!IF  "$(CFG)" == "mzscheme - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	".\..\..\mzscheme\include\scheme.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_MAIN_=\
+	".\..\..\Mzscheme\simpledrop.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	".\..\..\mzscheme\include\scheme.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MAIN_=\
+	".\..\..\Mzscheme\simpledrop.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 SGC"
+
+DEP_CPP_MAIN_=\
+	".\..\..\mzscheme\include\scheme.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	
+NODEP_CPP_MAIN_=\
+	".\..\..\Mzscheme\simpledrop.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Threads"
+
+DEP_CPP_MAIN_=\
+	".\..\..\mzscheme\include\scheme.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_MAIN_=\
+	".\..\..\Mzscheme\simpledrop.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\mzscheme.rc
+DEP_RSC_MZSCH=\
+	".\mzscheme.ico"\
+	
+
+!IF  "$(CFG)" == "mzscheme - Win32 Release"
+
+
+"$(INTDIR)\mzscheme.res" : $(SOURCE) $(DEP_RSC_MZSCH) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Debug"
+
+
+"$(INTDIR)\mzscheme.res" : $(SOURCE) $(DEP_RSC_MZSCH) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 SGC"
+
+
+"$(INTDIR)\mzscheme.res" : $(SOURCE) $(DEP_RSC_MZSCH) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzscheme - Win32 Threads"
+
+
+"$(INTDIR)\mzscheme.res" : $(SOURCE) $(DEP_RSC_MZSCH) "$(INTDIR)"
+   $(RSC) $(RSC_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/mzscheme/mzscheme.mdp b/src/worksp/mzscheme/mzscheme.mdp
new file mode 100644
index 0000000..859a94f
Binary files /dev/null and b/src/worksp/mzscheme/mzscheme.mdp differ
diff --git a/src/worksp/mzscheme/mzscheme.rc b/src/worksp/mzscheme/mzscheme.rc
new file mode 100755
index 0000000..e286bcb
--- /dev/null
+++ b/src/worksp/mzscheme/mzscheme.rc
@@ -0,0 +1,72 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+APPLICATION             ICON    DISCARDABLE     "mzscheme.ico"
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/src/worksp/mzscheme/resource.h b/src/worksp/mzscheme/resource.h
new file mode 100755
index 0000000..3a35743
--- /dev/null
+++ b/src/worksp/mzscheme/resource.h
@@ -0,0 +1,16 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by mzscheme.rc
+//
+#define APPLICATION                     101
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        102
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/src/worksp/mzsrc/mzsrc.mak b/src/worksp/mzsrc/mzsrc.mak
new file mode 100644
index 0000000..821033f
--- /dev/null
+++ b/src/worksp/mzsrc/mzsrc.mak
@@ -0,0 +1,2523 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=mzsrc - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to mzsrc - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "mzsrc - Win32 Release" && "$(CFG)" != "mzsrc - Win32 Debug" &&\
+ "$(CFG)" != "mzsrc - Win32 SGC" && "$(CFG)" != "mzsrc - Win32 Threads"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "mzsrc.mak" CFG="mzsrc - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "mzsrc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "mzsrc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "mzsrc - Win32 SGC" (based on "Win32 (x86) Static Library")
+!MESSAGE "mzsrc - Win32 Threads" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "mzsrc - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\mzsrc.lib"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\mzsrc.lib"
+	-@erase "Release\Unit.obj"
+	-@erase "Release\Syntax.obj"
+	-@erase "Release\Object.obj"
+	-@erase "Release\Eval.obj"
+	-@erase "Release\Regexp.obj"
+	-@erase "Release\mzsj86.obj"
+	-@erase "Release\Process.obj"
+	-@erase "Release\Symbol.obj"
+	-@erase "Release\Error.obj"
+	-@erase "Release\Bool.obj"
+	-@erase "Release\Env.obj"
+	-@erase "Release\Complex.obj"
+	-@erase "Release\Print.obj"
+	-@erase "Release\Fun.obj"
+	-@erase "Release\Type.obj"
+	-@erase "Release\Hash.obj"
+	-@erase "Release\File.obj"
+	-@erase "Release\String.obj"
+	-@erase "Release\Tsymbol.obj"
+	-@erase "Release\Vector.obj"
+	-@erase "Release\Bignum.obj"
+	-@erase "Release\Struct.obj"
+	-@erase "Release\Sema.obj"
+	-@erase "Release\Char.obj"
+	-@erase "Release\Number.obj"
+	-@erase "Release\Promise.obj"
+	-@erase "Release\Read.obj"
+	-@erase "Release\Salloc.obj"
+	-@erase "Release\Setjmpup.obj"
+	-@erase "Release\Rational.obj"
+	-@erase "Release\Port.obj"
+	-@erase "Release\Dynext.obj"
+	-@erase "Release\List.obj"
+	-@erase "Release\image.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\plt\mzscheme\include" /I "..\..\plt\mzscheme\gc" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /YX /c
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /I "..\..\plt\mzscheme\include" /I\
+ "..\..\plt\mzscheme\gc" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D\
+ "MZWINCONSOLE" /Fp"$(INTDIR)/mzsrc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo /o"DebugOpt/mzsrc.bsc"
+BSC32_FLAGS=/nologo /o"DebugOpt/mzsrc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/mzsrc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Unit.obj" \
+	"$(INTDIR)/Syntax.obj" \
+	"$(INTDIR)/Object.obj" \
+	"$(INTDIR)/Eval.obj" \
+	"$(INTDIR)/Regexp.obj" \
+	"$(INTDIR)/mzsj86.obj" \
+	"$(INTDIR)/Process.obj" \
+	"$(INTDIR)/Symbol.obj" \
+	"$(INTDIR)/Error.obj" \
+	"$(INTDIR)/Bool.obj" \
+	"$(INTDIR)/Env.obj" \
+	"$(INTDIR)/Complex.obj" \
+	"$(INTDIR)/Print.obj" \
+	"$(INTDIR)/Fun.obj" \
+	"$(INTDIR)/Type.obj" \
+	"$(INTDIR)/Hash.obj" \
+	"$(INTDIR)/File.obj" \
+	"$(INTDIR)/String.obj" \
+	"$(INTDIR)/Tsymbol.obj" \
+	"$(INTDIR)/Vector.obj" \
+	"$(INTDIR)/Bignum.obj" \
+	"$(INTDIR)/Struct.obj" \
+	"$(INTDIR)/Sema.obj" \
+	"$(INTDIR)/Char.obj" \
+	"$(INTDIR)/Number.obj" \
+	"$(INTDIR)/Promise.obj" \
+	"$(INTDIR)/Read.obj" \
+	"$(INTDIR)/Salloc.obj" \
+	"$(INTDIR)/Setjmpup.obj" \
+	"$(INTDIR)/Rational.obj" \
+	"$(INTDIR)/Port.obj" \
+	"$(INTDIR)/Dynext.obj" \
+	"$(INTDIR)/List.obj" \
+	"$(INTDIR)/image.obj"
+
+"$(OUTDIR)\mzsrc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\mzsrc.lib"
+
+CLEAN : 
+	-@erase "Debug\vc40.pdb"
+	-@erase "Debug\mzsrc.lib"
+	-@erase "Debug\Syntax.obj"
+	-@erase "Debug\Object.obj"
+	-@erase "Debug\Bool.obj"
+	-@erase "Debug\Error.obj"
+	-@erase "Debug\Type.obj"
+	-@erase "Debug\Hash.obj"
+	-@erase "Debug\File.obj"
+	-@erase "Debug\Regexp.obj"
+	-@erase "Debug\mzsj86.obj"
+	-@erase "Debug\Setjmpup.obj"
+	-@erase "Debug\Symbol.obj"
+	-@erase "Debug\Rational.obj"
+	-@erase "Debug\Dynext.obj"
+	-@erase "Debug\Sema.obj"
+	-@erase "Debug\Char.obj"
+	-@erase "Debug\Fun.obj"
+	-@erase "Debug\String.obj"
+	-@erase "Debug\Read.obj"
+	-@erase "Debug\Process.obj"
+	-@erase "Debug\Vector.obj"
+	-@erase "Debug\Print.obj"
+	-@erase "Debug\Port.obj"
+	-@erase "Debug\Complex.obj"
+	-@erase "Debug\List.obj"
+	-@erase "Debug\Unit.obj"
+	-@erase "Debug\Bignum.obj"
+	-@erase "Debug\Struct.obj"
+	-@erase "Debug\Promise.obj"
+	-@erase "Debug\Number.obj"
+	-@erase "Debug\Eval.obj"
+	-@erase "Debug\Tsymbol.obj"
+	-@erase "Debug\Salloc.obj"
+	-@erase "Debug\Env.obj"
+	-@erase "Debug\image.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /GX /Zi /Od /I "..\..\plt\mzscheme\include" /I "..\..\plt\mzscheme\gc" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /YX /c
+CPP_PROJ=/nologo /MTd /W3 /GX /Zi /Od /I "..\..\plt\mzscheme\include" /I\
+ "..\..\plt\mzscheme\gc" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D\
+ "MZWINCONSOLE" /Fp"$(INTDIR)/mzsrc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzsrc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/mzsrc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Syntax.obj" \
+	"$(INTDIR)/Object.obj" \
+	"$(INTDIR)/Bool.obj" \
+	"$(INTDIR)/Error.obj" \
+	"$(INTDIR)/Type.obj" \
+	"$(INTDIR)/Hash.obj" \
+	"$(INTDIR)/File.obj" \
+	"$(INTDIR)/Regexp.obj" \
+	"$(INTDIR)/mzsj86.obj" \
+	"$(INTDIR)/Setjmpup.obj" \
+	"$(INTDIR)/Symbol.obj" \
+	"$(INTDIR)/Rational.obj" \
+	"$(INTDIR)/Dynext.obj" \
+	"$(INTDIR)/Sema.obj" \
+	"$(INTDIR)/Char.obj" \
+	"$(INTDIR)/Fun.obj" \
+	"$(INTDIR)/String.obj" \
+	"$(INTDIR)/Read.obj" \
+	"$(INTDIR)/Process.obj" \
+	"$(INTDIR)/Vector.obj" \
+	"$(INTDIR)/Print.obj" \
+	"$(INTDIR)/Port.obj" \
+	"$(INTDIR)/Complex.obj" \
+	"$(INTDIR)/List.obj" \
+	"$(INTDIR)/Unit.obj" \
+	"$(INTDIR)/Bignum.obj" \
+	"$(INTDIR)/Struct.obj" \
+	"$(INTDIR)/Promise.obj" \
+	"$(INTDIR)/Number.obj" \
+	"$(INTDIR)/Eval.obj" \
+	"$(INTDIR)/Tsymbol.obj" \
+	"$(INTDIR)/Salloc.obj" \
+	"$(INTDIR)/Env.obj" \
+	"$(INTDIR)/image.obj"
+
+"$(OUTDIR)\mzsrc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "mzsrc___"
+# PROP BASE Intermediate_Dir "mzsrc___"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\mzsrc.lib"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\mzsrc.lib"
+	-@erase "SGC\Dynext.obj"
+	-@erase "SGC\Error.obj"
+	-@erase "SGC\Print.obj"
+	-@erase "SGC\String.obj"
+	-@erase "SGC\Vector.obj"
+	-@erase "SGC\Process.obj"
+	-@erase "SGC\Bignum.obj"
+	-@erase "SGC\Struct.obj"
+	-@erase "SGC\Complex.obj"
+	-@erase "SGC\Port.obj"
+	-@erase "SGC\Number.obj"
+	-@erase "SGC\Unit.obj"
+	-@erase "SGC\Type.obj"
+	-@erase "SGC\Env.obj"
+	-@erase "SGC\Salloc.obj"
+	-@erase "SGC\Eval.obj"
+	-@erase "SGC\Fun.obj"
+	-@erase "SGC\Syntax.obj"
+	-@erase "SGC\Object.obj"
+	-@erase "SGC\Setjmpup.obj"
+	-@erase "SGC\Sema.obj"
+	-@erase "SGC\Rational.obj"
+	-@erase "SGC\Char.obj"
+	-@erase "SGC\Bool.obj"
+	-@erase "SGC\Regexp.obj"
+	-@erase "SGC\Promise.obj"
+	-@erase "SGC\mzsj86.obj"
+	-@erase "SGC\Read.obj"
+	-@erase "SGC\Hash.obj"
+	-@erase "SGC\File.obj"
+	-@erase "SGC\Symbol.obj"
+	-@erase "SGC\Tsymbol.obj"
+	-@erase "SGC\List.obj"
+	-@erase "SGC\image.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Zi /Od /I "c:\Matthew\plt\mzscheme\include" /I "C:\Matthew\plt\mzscheme\gc" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /YX /c
+# ADD CPP /nologo /MTd /W3 /GX /Zi /Od /I "..\..\plt\mzscheme\include" /I "..\..\plt\mzscheme\sgc" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /D SGC_STD_DEBUGGING=1 /YX /c
+CPP_PROJ=/nologo /MTd /W3 /GX /Zi /Od /I "..\..\plt\mzscheme\include" /I\
+ "..\..\plt\mzscheme\sgc" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D\
+ "MZWINCONSOLE" /D SGC_STD_DEBUGGING=1 /Fp"$(INTDIR)/mzsrc.pch" /YX\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/mzsrc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/mzsrc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Dynext.obj" \
+	"$(INTDIR)/Error.obj" \
+	"$(INTDIR)/Print.obj" \
+	"$(INTDIR)/String.obj" \
+	"$(INTDIR)/Vector.obj" \
+	"$(INTDIR)/Process.obj" \
+	"$(INTDIR)/Bignum.obj" \
+	"$(INTDIR)/Struct.obj" \
+	"$(INTDIR)/Complex.obj" \
+	"$(INTDIR)/Port.obj" \
+	"$(INTDIR)/Number.obj" \
+	"$(INTDIR)/Unit.obj" \
+	"$(INTDIR)/Type.obj" \
+	"$(INTDIR)/Env.obj" \
+	"$(INTDIR)/Salloc.obj" \
+	"$(INTDIR)/Eval.obj" \
+	"$(INTDIR)/Fun.obj" \
+	"$(INTDIR)/Syntax.obj" \
+	"$(INTDIR)/Object.obj" \
+	"$(INTDIR)/Setjmpup.obj" \
+	"$(INTDIR)/Sema.obj" \
+	"$(INTDIR)/Rational.obj" \
+	"$(INTDIR)/Char.obj" \
+	"$(INTDIR)/Bool.obj" \
+	"$(INTDIR)/Regexp.obj" \
+	"$(INTDIR)/Promise.obj" \
+	"$(INTDIR)/mzsj86.obj" \
+	"$(INTDIR)/Read.obj" \
+	"$(INTDIR)/Hash.obj" \
+	"$(INTDIR)/File.obj" \
+	"$(INTDIR)/Symbol.obj" \
+	"$(INTDIR)/Tsymbol.obj" \
+	"$(INTDIR)/List.obj" \
+	"$(INTDIR)/image.obj"
+
+"$(OUTDIR)\mzsrc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "mzsrc___"
+# PROP BASE Intermediate_Dir "mzsrc___"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Threads"
+# PROP Intermediate_Dir "Threads"
+# PROP Target_Dir ""
+OUTDIR=Threads
+INTDIR=Threads
+
+ALL : "$(OUTDIR)\mzsrc.lib"
+
+CLEAN : 
+	-@erase "Threads\vc40.pdb"
+	-@erase "Threads\mzsrc.lib"
+	-@erase "Threads\Regexp.obj"
+	-@erase "Threads\Sema.obj"
+	-@erase "Threads\Char.obj"
+	-@erase "Threads\mzsj86.obj"
+	-@erase "Threads\Setjmpup.obj"
+	-@erase "Threads\Rational.obj"
+	-@erase "Threads\Symbol.obj"
+	-@erase "Threads\Read.obj"
+	-@erase "Threads\File.obj"
+	-@erase "Threads\Dynext.obj"
+	-@erase "Threads\Port.obj"
+	-@erase "Threads\List.obj"
+	-@erase "Threads\Unit.obj"
+	-@erase "Threads\String.obj"
+	-@erase "Threads\Env.obj"
+	-@erase "Threads\Vector.obj"
+	-@erase "Threads\Fun.obj"
+	-@erase "Threads\Bignum.obj"
+	-@erase "Threads\Struct.obj"
+	-@erase "Threads\Error.obj"
+	-@erase "Threads\Print.obj"
+	-@erase "Threads\Number.obj"
+	-@erase "Threads\Bool.obj"
+	-@erase "Threads\Salloc.obj"
+	-@erase "Threads\Process.obj"
+	-@erase "Threads\Type.obj"
+	-@erase "Threads\Hash.obj"
+	-@erase "Threads\Complex.obj"
+	-@erase "Threads\Syntax.obj"
+	-@erase "Threads\Object.obj"
+	-@erase "Threads\Promise.obj"
+	-@erase "Threads\Eval.obj"
+	-@erase "Threads\Tsymbol.obj"
+	-@erase "Threads\image.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Zi /O2 /I "..\..\plt\mzscheme\include" /I "..\..\plt\mzscheme\gc" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\..\plt\mzscheme\include" /I "..\..\plt\mzscheme\gc" /D "NDEBUG" /D "WIN32" /D "WIN32_THREADS" /D "_WINDOWS" /D "__STDC__" /D "MZWINCONSOLE" /YX /c
+CPP_PROJ=/nologo /MT /W3 /GX /Zi /O2 /I "..\..\plt\mzscheme\include" /I\
+ "..\..\plt\mzscheme\gc" /D "NDEBUG" /D "WIN32" /D "WIN32_THREADS" /D "_WINDOWS"\
+ /D "__STDC__" /D "MZWINCONSOLE" /Fp"$(INTDIR)/mzsrc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Threads/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo /o"DebugOpt/mzsrc.bsc"
+# ADD BSC32 /nologo /o"DebugOpt/mzsrc.bsc"
+BSC32_FLAGS=/nologo /o"DebugOpt/mzsrc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/mzsrc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Regexp.obj" \
+	"$(INTDIR)/Sema.obj" \
+	"$(INTDIR)/Char.obj" \
+	"$(INTDIR)/mzsj86.obj" \
+	"$(INTDIR)/Setjmpup.obj" \
+	"$(INTDIR)/Rational.obj" \
+	"$(INTDIR)/Symbol.obj" \
+	"$(INTDIR)/Read.obj" \
+	"$(INTDIR)/File.obj" \
+	"$(INTDIR)/Dynext.obj" \
+	"$(INTDIR)/Port.obj" \
+	"$(INTDIR)/List.obj" \
+	"$(INTDIR)/Unit.obj" \
+	"$(INTDIR)/String.obj" \
+	"$(INTDIR)/Env.obj" \
+	"$(INTDIR)/Vector.obj" \
+	"$(INTDIR)/Fun.obj" \
+	"$(INTDIR)/Bignum.obj" \
+	"$(INTDIR)/Struct.obj" \
+	"$(INTDIR)/Error.obj" \
+	"$(INTDIR)/Print.obj" \
+	"$(INTDIR)/Number.obj" \
+	"$(INTDIR)/Bool.obj" \
+	"$(INTDIR)/Salloc.obj" \
+	"$(INTDIR)/Process.obj" \
+	"$(INTDIR)/Type.obj" \
+	"$(INTDIR)/Hash.obj" \
+	"$(INTDIR)/Complex.obj" \
+	"$(INTDIR)/Syntax.obj" \
+	"$(INTDIR)/Object.obj" \
+	"$(INTDIR)/Promise.obj" \
+	"$(INTDIR)/Eval.obj" \
+	"$(INTDIR)/Tsymbol.obj" \
+	"$(INTDIR)/image.obj"
+
+"$(OUTDIR)\mzsrc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "mzsrc - Win32 Release"
+# Name "mzsrc - Win32 Debug"
+# Name "mzsrc - Win32 SGC"
+# Name "mzsrc - Win32 Threads"
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Vector.c
+DEP_CPP_VECTO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_VECTO=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Vector.obj" : $(SOURCE) $(DEP_CPP_VECTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Vector.obj" : $(SOURCE) $(DEP_CPP_VECTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Vector.obj" : $(SOURCE) $(DEP_CPP_VECTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Vector.obj" : $(SOURCE) $(DEP_CPP_VECTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Bool.c
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+DEP_CPP_BOOL_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\mzscheme\gc\malloc.c"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\mzscheme\gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\gc\gc_hdrs.h"\
+	
+NODEP_CPP_BOOL_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\gc\th\PCR_Th.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCrSec.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCtl.h"\
+	
+
+"$(INTDIR)\Bool.obj" : $(SOURCE) $(DEP_CPP_BOOL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+DEP_CPP_BOOL_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\mzscheme\gc\malloc.c"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\mzscheme\gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\gc\gc_hdrs.h"\
+	
+NODEP_CPP_BOOL_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\gc\th\PCR_Th.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCrSec.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCtl.h"\
+	
+
+"$(INTDIR)\Bool.obj" : $(SOURCE) $(DEP_CPP_BOOL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+DEP_CPP_BOOL_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_BOOL_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Bool.obj" : $(SOURCE) $(DEP_CPP_BOOL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+DEP_CPP_BOOL_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\mzscheme\gc\malloc.c"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\mzscheme\gc\gc_priv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\gc\gc_hdrs.h"\
+	
+NODEP_CPP_BOOL_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\gc\th\PCR_Th.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCrSec.h"\
+	".\..\..\mzscheme\gc\th\PCR_ThCtl.h"\
+	
+
+"$(INTDIR)\Bool.obj" : $(SOURCE) $(DEP_CPP_BOOL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Char.c
+DEP_CPP_CHAR_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_CHAR_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Char.obj" : $(SOURCE) $(DEP_CPP_CHAR_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Char.obj" : $(SOURCE) $(DEP_CPP_CHAR_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Char.obj" : $(SOURCE) $(DEP_CPP_CHAR_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Char.obj" : $(SOURCE) $(DEP_CPP_CHAR_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Complex.c
+DEP_CPP_COMPL=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_COMPL=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Complex.obj" : $(SOURCE) $(DEP_CPP_COMPL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Complex.obj" : $(SOURCE) $(DEP_CPP_COMPL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Complex.obj" : $(SOURCE) $(DEP_CPP_COMPL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Complex.obj" : $(SOURCE) $(DEP_CPP_COMPL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Dynext.c
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+DEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\aixdlfcn\dlfcn.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemex.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Dynext.obj" : $(SOURCE) $(DEP_CPP_DYNEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+DEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\aixdlfcn\dlfcn.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemex.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Dynext.obj" : $(SOURCE) $(DEP_CPP_DYNEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+DEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\sgc\gc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\aixdlfcn\dlfcn.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemex.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_DYNEX=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Dynext.obj" : $(SOURCE) $(DEP_CPP_DYNEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+DEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\aixdlfcn\dlfcn.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemex.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_DYNEX=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Dynext.obj" : $(SOURCE) $(DEP_CPP_DYNEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Env.c
+DEP_CPP_ENV_C=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schminc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\Src\cmacro.inc"\
+	".\..\..\Mzscheme\Src\macro.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_ENV_C=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Env.obj" : $(SOURCE) $(DEP_CPP_ENV_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Env.obj" : $(SOURCE) $(DEP_CPP_ENV_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Env.obj" : $(SOURCE) $(DEP_CPP_ENV_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Env.obj" : $(SOURCE) $(DEP_CPP_ENV_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Error.c
+DEP_CPP_ERROR=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_ERROR=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Error.obj" : $(SOURCE) $(DEP_CPP_ERROR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Error.obj" : $(SOURCE) $(DEP_CPP_ERROR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Error.obj" : $(SOURCE) $(DEP_CPP_ERROR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Error.obj" : $(SOURCE) $(DEP_CPP_ERROR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Eval.c
+DEP_CPP_EVAL_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schrunst.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_EVAL_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Eval.obj" : $(SOURCE) $(DEP_CPP_EVAL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Eval.obj" : $(SOURCE) $(DEP_CPP_EVAL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Eval.obj" : $(SOURCE) $(DEP_CPP_EVAL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Eval.obj" : $(SOURCE) $(DEP_CPP_EVAL_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\File.c
+DEP_CPP_FILE_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_FILE_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\File.obj" : $(SOURCE) $(DEP_CPP_FILE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\File.obj" : $(SOURCE) $(DEP_CPP_FILE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\File.obj" : $(SOURCE) $(DEP_CPP_FILE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\File.obj" : $(SOURCE) $(DEP_CPP_FILE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Fun.c
+DEP_CPP_FUN_C=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_FUN_C=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Fun.obj" : $(SOURCE) $(DEP_CPP_FUN_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Fun.obj" : $(SOURCE) $(DEP_CPP_FUN_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Fun.obj" : $(SOURCE) $(DEP_CPP_FUN_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Fun.obj" : $(SOURCE) $(DEP_CPP_FUN_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Hash.c
+DEP_CPP_HASH_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_HASH_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Hash.obj" : $(SOURCE) $(DEP_CPP_HASH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Hash.obj" : $(SOURCE) $(DEP_CPP_HASH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Hash.obj" : $(SOURCE) $(DEP_CPP_HASH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Hash.obj" : $(SOURCE) $(DEP_CPP_HASH_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\List.c
+DEP_CPP_LIST_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_LIST_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\List.obj" : $(SOURCE) $(DEP_CPP_LIST_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\List.obj" : $(SOURCE) $(DEP_CPP_LIST_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\List.obj" : $(SOURCE) $(DEP_CPP_LIST_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\List.obj" : $(SOURCE) $(DEP_CPP_LIST_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Number.c
+DEP_CPP_NUMBE=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\nummacs.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_NUMBE=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Number.obj" : $(SOURCE) $(DEP_CPP_NUMBE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Number.obj" : $(SOURCE) $(DEP_CPP_NUMBE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Number.obj" : $(SOURCE) $(DEP_CPP_NUMBE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Number.obj" : $(SOURCE) $(DEP_CPP_NUMBE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Object.c
+DEP_CPP_OBJEC=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schrunst.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Object.obj" : $(SOURCE) $(DEP_CPP_OBJEC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Object.obj" : $(SOURCE) $(DEP_CPP_OBJEC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Object.obj" : $(SOURCE) $(DEP_CPP_OBJEC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Object.obj" : $(SOURCE) $(DEP_CPP_OBJEC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Port.c
+DEP_CPP_PORT_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Src\schfd.h"\
+	".\..\..\Mzscheme\Src\schwinfd.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_PORT_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Port.obj" : $(SOURCE) $(DEP_CPP_PORT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Port.obj" : $(SOURCE) $(DEP_CPP_PORT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Port.obj" : $(SOURCE) $(DEP_CPP_PORT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Port.obj" : $(SOURCE) $(DEP_CPP_PORT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Print.c
+DEP_CPP_PRINT=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schcpt.h"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_PRINT=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Print.obj" : $(SOURCE) $(DEP_CPP_PRINT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Print.obj" : $(SOURCE) $(DEP_CPP_PRINT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Print.obj" : $(SOURCE) $(DEP_CPP_PRINT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Print.obj" : $(SOURCE) $(DEP_CPP_PRINT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Process.c
+DEP_CPP_PROCE=\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\Mzscheme\Src\schfd.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	
+NODEP_CPP_PROCE=\
+	".\..\..\Mzscheme\Src\sconfig.h"\
+	".\..\..\Mzscheme\gc\semaphores.h"\
+	".\..\..\Mzscheme\gc\sproc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Process.obj" : $(SOURCE) $(DEP_CPP_PROCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Process.obj" : $(SOURCE) $(DEP_CPP_PROCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Process.obj" : $(SOURCE) $(DEP_CPP_PROCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Process.obj" : $(SOURCE) $(DEP_CPP_PROCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Promise.c
+DEP_CPP_PROMI=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_PROMI=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Promise.obj" : $(SOURCE) $(DEP_CPP_PROMI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Promise.obj" : $(SOURCE) $(DEP_CPP_PROMI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Promise.obj" : $(SOURCE) $(DEP_CPP_PROMI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Promise.obj" : $(SOURCE) $(DEP_CPP_PROMI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Rational.c
+DEP_CPP_RATIO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_RATIO=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Rational.obj" : $(SOURCE) $(DEP_CPP_RATIO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Rational.obj" : $(SOURCE) $(DEP_CPP_RATIO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Rational.obj" : $(SOURCE) $(DEP_CPP_RATIO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Rational.obj" : $(SOURCE) $(DEP_CPP_RATIO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Read.c
+DEP_CPP_READ_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schcpt.h"\
+	".\..\..\Mzscheme\Src\mzstkchk.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_READ_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Read.obj" : $(SOURCE) $(DEP_CPP_READ_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Read.obj" : $(SOURCE) $(DEP_CPP_READ_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Read.obj" : $(SOURCE) $(DEP_CPP_READ_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Read.obj" : $(SOURCE) $(DEP_CPP_READ_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Regexp.c
+DEP_CPP_REGEX=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_REGEX=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Regexp.obj" : $(SOURCE) $(DEP_CPP_REGEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Regexp.obj" : $(SOURCE) $(DEP_CPP_REGEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Regexp.obj" : $(SOURCE) $(DEP_CPP_REGEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Regexp.obj" : $(SOURCE) $(DEP_CPP_REGEX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Salloc.c
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+DEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Salloc.obj" : $(SOURCE) $(DEP_CPP_SALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+DEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Salloc.obj" : $(SOURCE) $(DEP_CPP_SALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+DEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\sgc\gc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SALLO=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Salloc.obj" : $(SOURCE) $(DEP_CPP_SALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+DEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SALLO=\
+	".\..\..\Mzscheme\Src\sgc.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\Salloc.obj" : $(SOURCE) $(DEP_CPP_SALLO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Sema.c
+DEP_CPP_SEMA_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SEMA_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Sema.obj" : $(SOURCE) $(DEP_CPP_SEMA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Sema.obj" : $(SOURCE) $(DEP_CPP_SEMA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Sema.obj" : $(SOURCE) $(DEP_CPP_SEMA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Sema.obj" : $(SOURCE) $(DEP_CPP_SEMA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Setjmpup.c
+DEP_CPP_SETJM=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SETJM=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Setjmpup.obj" : $(SOURCE) $(DEP_CPP_SETJM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Setjmpup.obj" : $(SOURCE) $(DEP_CPP_SETJM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Setjmpup.obj" : $(SOURCE) $(DEP_CPP_SETJM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Setjmpup.obj" : $(SOURCE) $(DEP_CPP_SETJM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\String.c
+DEP_CPP_STRIN=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_STRIN=\
+	".\..\..\Mzscheme\Src\schsys.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\String.obj" : $(SOURCE) $(DEP_CPP_STRIN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\String.obj" : $(SOURCE) $(DEP_CPP_STRIN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\String.obj" : $(SOURCE) $(DEP_CPP_STRIN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\String.obj" : $(SOURCE) $(DEP_CPP_STRIN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Struct.c
+DEP_CPP_STRUC=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_STRUC=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Struct.obj" : $(SOURCE) $(DEP_CPP_STRUC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Struct.obj" : $(SOURCE) $(DEP_CPP_STRUC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Struct.obj" : $(SOURCE) $(DEP_CPP_STRUC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Struct.obj" : $(SOURCE) $(DEP_CPP_STRUC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Symbol.c
+DEP_CPP_SYMBO=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SYMBO=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Symbol.obj" : $(SOURCE) $(DEP_CPP_SYMBO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Symbol.obj" : $(SOURCE) $(DEP_CPP_SYMBO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Symbol.obj" : $(SOURCE) $(DEP_CPP_SYMBO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Symbol.obj" : $(SOURCE) $(DEP_CPP_SYMBO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Syntax.c
+DEP_CPP_SYNTA=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_SYNTA=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Syntax.obj" : $(SOURCE) $(DEP_CPP_SYNTA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Syntax.obj" : $(SOURCE) $(DEP_CPP_SYNTA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Syntax.obj" : $(SOURCE) $(DEP_CPP_SYNTA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Syntax.obj" : $(SOURCE) $(DEP_CPP_SYNTA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Tsymbol.c
+DEP_CPP_TSYMB=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_TSYMB=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Tsymbol.obj" : $(SOURCE) $(DEP_CPP_TSYMB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Tsymbol.obj" : $(SOURCE) $(DEP_CPP_TSYMB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Tsymbol.obj" : $(SOURCE) $(DEP_CPP_TSYMB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Tsymbol.obj" : $(SOURCE) $(DEP_CPP_TSYMB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Type.c
+DEP_CPP_TYPE_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_TYPE_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Type.obj" : $(SOURCE) $(DEP_CPP_TYPE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Type.obj" : $(SOURCE) $(DEP_CPP_TYPE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Type.obj" : $(SOURCE) $(DEP_CPP_TYPE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Type.obj" : $(SOURCE) $(DEP_CPP_TYPE_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Unit.c
+DEP_CPP_UNIT_=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schrunst.h"\
+	".\..\..\Mzscheme\Src\schminc.h"\
+	".\..\..\Mzscheme\Src\cunitsig.inc"\
+	".\..\..\Mzscheme\Src\unitsig.inc"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_UNIT_=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Unit.obj" : $(SOURCE) $(DEP_CPP_UNIT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Unit.obj" : $(SOURCE) $(DEP_CPP_UNIT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Unit.obj" : $(SOURCE) $(DEP_CPP_UNIT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Unit.obj" : $(SOURCE) $(DEP_CPP_UNIT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\Bignum.c
+DEP_CPP_BIGNU=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_BIGNU=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\Bignum.obj" : $(SOURCE) $(DEP_CPP_BIGNU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\Bignum.obj" : $(SOURCE) $(DEP_CPP_BIGNU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\Bignum.obj" : $(SOURCE) $(DEP_CPP_BIGNU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\Bignum.obj" : $(SOURCE) $(DEP_CPP_BIGNU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Mzscheme\Src\mzsj86.c
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+
+"$(INTDIR)\mzsj86.obj" : $(SOURCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+
+"$(INTDIR)\mzsj86.obj" : $(SOURCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+
+"$(INTDIR)\mzsj86.obj" : $(SOURCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+
+"$(INTDIR)\mzsj86.obj" : $(SOURCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\MZSCHEME\SRC\image.c
+
+!IF  "$(CFG)" == "mzsrc - Win32 Release"
+
+DEP_CPP_IMAGE=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_IMAGE=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\image.obj" : $(SOURCE) $(DEP_CPP_IMAGE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Debug"
+
+DEP_CPP_IMAGE=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_IMAGE=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\image.obj" : $(SOURCE) $(DEP_CPP_IMAGE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 SGC"
+
+DEP_CPP_IMAGE=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\sgc\gc.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	
+NODEP_CPP_IMAGE=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\image.obj" : $(SOURCE) $(DEP_CPP_IMAGE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "mzsrc - Win32 Threads"
+
+DEP_CPP_IMAGE=\
+	".\..\..\Mzscheme\Src\schpriv.h"\
+	".\..\..\Mzscheme\Src\schmach.h"\
+	".\..\..\Mzscheme\Src\schvers.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\gc\config.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\Mzscheme\Src\stypes.h"\
+	".\..\..\Mzscheme\Src\schexn.h"\
+	".\..\..\Mzscheme\Src\schemef.h"\
+	".\..\..\Mzscheme\Src\schemex.h"\
+	".\..\..\Mzscheme\Src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_IMAGE=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	
+
+"$(INTDIR)\image.obj" : $(SOURCE) $(DEP_CPP_IMAGE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/mzsrc/mzsrc.mdp b/src/worksp/mzsrc/mzsrc.mdp
new file mode 100755
index 0000000..7f5d394
Binary files /dev/null and b/src/worksp/mzsrc/mzsrc.mdp differ
diff --git a/src/worksp/sgc/sgc.mak b/src/worksp/sgc/sgc.mak
new file mode 100644
index 0000000..b9df490
--- /dev/null
+++ b/src/worksp/sgc/sgc.mak
@@ -0,0 +1,183 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=sgc - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to sgc - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "sgc - Win32 Release" && "$(CFG)" != "sgc - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "sgc.mak" CFG="sgc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "sgc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "sgc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "sgc - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "sgc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\sgc.lib"
+
+CLEAN : 
+	-@erase "Release\sgc.lib"
+	-@erase "Release\SGC.OBJ"
+	-@erase "Release\vc40.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /Zi /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D SGC_STD_DEBUGGING=1 /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /Zi /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ SGC_STD_DEBUGGING=1 /Fp"$(INTDIR)/sgc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/"\
+ /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/sgc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/sgc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/SGC.OBJ"
+
+"$(OUTDIR)\sgc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "sgc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\sgc.lib"
+
+CLEAN : 
+	-@erase "Debug\sgc.lib"
+	-@erase "Debug\SGC.OBJ"
+	-@erase "Debug\vc40.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D SGC_STD_DEBUGGING=1 /YX /c
+CPP_PROJ=/nologo /MLd /W3 /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D\
+ SGC_STD_DEBUGGING=1 /Fp"$(INTDIR)/sgc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/"\
+ /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/sgc.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/sgc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/SGC.OBJ"
+
+"$(OUTDIR)\sgc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "sgc - Win32 Release"
+# Name "sgc - Win32 Debug"
+
+!IF  "$(CFG)" == "sgc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "sgc - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\MZSCHEME\SGC\SGC.C
+DEP_CPP_SGC_C=\
+	".\..\..\MZSCHEME\sconfig.h"\
+	".\..\..\MZSCHEME\SGC\sgc.h"\
+	".\..\..\MZSCHEME\uconfig.h"\
+	
+
+"$(INTDIR)\SGC.OBJ" : $(SOURCE) $(DEP_CPP_SGC_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/sgc/sgc.mdp b/src/worksp/sgc/sgc.mdp
new file mode 100755
index 0000000..c274385
Binary files /dev/null and b/src/worksp/sgc/sgc.mdp differ
diff --git a/src/worksp/wxs/wxs.mak b/src/worksp/wxs/wxs.mak
new file mode 100644
index 0000000..542be4c
--- /dev/null
+++ b/src/worksp/wxs/wxs.mak
@@ -0,0 +1,8667 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=wxs - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to wxs - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "wxs - Win32 Release" && "$(CFG)" != "wxs - Win32 Debug" &&\
+ "$(CFG)" != "wxs - Win32 SGC"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "wxs.mak" CFG="wxs - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "wxs - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxs - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxs - Win32 SGC" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "wxs - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\wxs.lib"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\wxs.lib"
+	-@erase "Release\WXS_GAGE.obj"
+	-@erase "Release\WXS_SLID.obj"
+	-@erase "Release\WXS_BUTN.obj"
+	-@erase "Release\WXS_ITEM.obj"
+	-@erase "Release\WXS_LBOX.obj"
+	-@erase "Release\WXS_MPB.obj"
+	-@erase "Release\WXS_DC.obj"
+	-@erase "Release\WXS_MIO.obj"
+	-@erase "Release\WXS_RADO.obj"
+	-@erase "Release\WXSCHEME.obj"
+	-@erase "Release\WXS_MENU.obj"
+	-@erase "Release\WXS_WIN.obj"
+	-@erase "Release\WXS_MISC.obj"
+	-@erase "Release\WXS_MADM.obj"
+	-@erase "Release\WXS_GDI.obj"
+	-@erase "Release\WXS_BMAP.obj"
+	-@erase "Release\WXS_CKBX.obj"
+	-@erase "Release\WXS_PANL.obj"
+	-@erase "Release\WXS_FRAM.obj"
+	-@erase "Release\WXS_TEXT.obj"
+	-@erase "Release\WXS_GLOB.obj"
+	-@erase "Release\WXS_MEDE.obj"
+	-@erase "Release\WXS_CHCE.obj"
+	-@erase "Release\WXS_STYL.obj"
+	-@erase "Release\WXS_OBJ.obj"
+	-@erase "Release\WXS_CNVS.obj"
+	-@erase "Release\WXS_MEDI.obj"
+	-@erase "Release\WXS_EVNT.obj"
+	-@erase "Release\WXS_SNIP.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "NDEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /YX"wx.h" /c
+CPP_PROJ=/nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "NDEBUG" /D\
+ "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT"\
+ /D "__WINDOWS__" /D "WXME_FOR_MRED" /Fp"$(INTDIR)/wxs.pch" /YX"wx.h"\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxs.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxs.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WXS_GAGE.obj" \
+	"$(INTDIR)/WXS_SLID.obj" \
+	"$(INTDIR)/WXS_BUTN.obj" \
+	"$(INTDIR)/WXS_ITEM.obj" \
+	"$(INTDIR)/WXS_LBOX.obj" \
+	"$(INTDIR)/WXS_MPB.obj" \
+	"$(INTDIR)/WXS_DC.obj" \
+	"$(INTDIR)/WXS_MIO.obj" \
+	"$(INTDIR)/WXS_RADO.obj" \
+	"$(INTDIR)/WXSCHEME.obj" \
+	"$(INTDIR)/WXS_MENU.obj" \
+	"$(INTDIR)/WXS_WIN.obj" \
+	"$(INTDIR)/WXS_MISC.obj" \
+	"$(INTDIR)/WXS_MADM.obj" \
+	"$(INTDIR)/WXS_GDI.obj" \
+	"$(INTDIR)/WXS_BMAP.obj" \
+	"$(INTDIR)/WXS_CKBX.obj" \
+	"$(INTDIR)/WXS_PANL.obj" \
+	"$(INTDIR)/WXS_FRAM.obj" \
+	"$(INTDIR)/WXS_TEXT.obj" \
+	"$(INTDIR)/WXS_GLOB.obj" \
+	"$(INTDIR)/WXS_MEDE.obj" \
+	"$(INTDIR)/WXS_CHCE.obj" \
+	"$(INTDIR)/WXS_STYL.obj" \
+	"$(INTDIR)/WXS_OBJ.obj" \
+	"$(INTDIR)/WXS_CNVS.obj" \
+	"$(INTDIR)/WXS_MEDI.obj" \
+	"$(INTDIR)/WXS_EVNT.obj" \
+	"$(INTDIR)/WXS_SNIP.obj"
+
+"$(OUTDIR)\wxs.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\wxs.lib"
+
+CLEAN : 
+	-@erase "Debug\vc40.pdb"
+	-@erase "Debug\vc40.idb"
+	-@erase "Debug\wxs.lib"
+	-@erase "Debug\WXS_MIO.obj"
+	-@erase "Debug\WXS_RADO.obj"
+	-@erase "Debug\WXS_MEDI.obj"
+	-@erase "Debug\WXS_EVNT.obj"
+	-@erase "Debug\WXS_OBJ.obj"
+	-@erase "Debug\WXS_SNIP.obj"
+	-@erase "Debug\WXS_WIN.obj"
+	-@erase "Debug\WXS_GDI.obj"
+	-@erase "Debug\WXS_GAGE.obj"
+	-@erase "Debug\WXS_SLID.obj"
+	-@erase "Debug\WXS_BUTN.obj"
+	-@erase "Debug\WXS_ITEM.obj"
+	-@erase "Debug\WXS_FRAM.obj"
+	-@erase "Debug\WXS_LBOX.obj"
+	-@erase "Debug\WXSCHEME.obj"
+	-@erase "Debug\WXS_MENU.obj"
+	-@erase "Debug\WXS_MISC.obj"
+	-@erase "Debug\WXS_MADM.obj"
+	-@erase "Debug\WXS_BMAP.obj"
+	-@erase "Debug\WXS_DC.obj"
+	-@erase "Debug\WXS_CKBX.obj"
+	-@erase "Debug\WXS_PANL.obj"
+	-@erase "Debug\WXS_TEXT.obj"
+	-@erase "Debug\WXS_MPB.obj"
+	-@erase "Debug\WXS_GLOB.obj"
+	-@erase "Debug\WXS_MEDE.obj"
+	-@erase "Debug\WXS_CHCE.obj"
+	-@erase "Debug\WXS_STYL.obj"
+	-@erase "Debug\WXS_CNVS.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "__DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /YX"wx.h" /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "__DEBUG" /D\
+ "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT"\
+ /D "__WINDOWS__" /D "WXME_FOR_MRED" /Fp"$(INTDIR)/wxs.pch" /YX"wx.h"\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxs.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxs.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WXS_MIO.obj" \
+	"$(INTDIR)/WXS_RADO.obj" \
+	"$(INTDIR)/WXS_MEDI.obj" \
+	"$(INTDIR)/WXS_EVNT.obj" \
+	"$(INTDIR)/WXS_OBJ.obj" \
+	"$(INTDIR)/WXS_SNIP.obj" \
+	"$(INTDIR)/WXS_WIN.obj" \
+	"$(INTDIR)/WXS_GDI.obj" \
+	"$(INTDIR)/WXS_GAGE.obj" \
+	"$(INTDIR)/WXS_SLID.obj" \
+	"$(INTDIR)/WXS_BUTN.obj" \
+	"$(INTDIR)/WXS_ITEM.obj" \
+	"$(INTDIR)/WXS_FRAM.obj" \
+	"$(INTDIR)/WXS_LBOX.obj" \
+	"$(INTDIR)/WXSCHEME.obj" \
+	"$(INTDIR)/WXS_MENU.obj" \
+	"$(INTDIR)/WXS_MISC.obj" \
+	"$(INTDIR)/WXS_MADM.obj" \
+	"$(INTDIR)/WXS_BMAP.obj" \
+	"$(INTDIR)/WXS_DC.obj" \
+	"$(INTDIR)/WXS_CKBX.obj" \
+	"$(INTDIR)/WXS_PANL.obj" \
+	"$(INTDIR)/WXS_TEXT.obj" \
+	"$(INTDIR)/WXS_MPB.obj" \
+	"$(INTDIR)/WXS_GLOB.obj" \
+	"$(INTDIR)/WXS_MEDE.obj" \
+	"$(INTDIR)/WXS_CHCE.obj" \
+	"$(INTDIR)/WXS_STYL.obj" \
+	"$(INTDIR)/WXS_CNVS.obj"
+
+"$(OUTDIR)\wxs.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "wxs___Wi"
+# PROP BASE Intermediate_Dir "wxs___Wi"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\wxs.lib"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\vc40.idb"
+	-@erase "SGC\wxs.lib"
+	-@erase "SGC\WXS_DC.obj"
+	-@erase "SGC\WXS_MENU.obj"
+	-@erase "SGC\WXS_MISC.obj"
+	-@erase "SGC\WXS_OBJ.obj"
+	-@erase "SGC\WXS_BMAP.obj"
+	-@erase "SGC\WXS_SLID.obj"
+	-@erase "SGC\WXS_BUTN.obj"
+	-@erase "SGC\WXS_ITEM.obj"
+	-@erase "SGC\WXS_FRAM.obj"
+	-@erase "SGC\WXS_MEDE.obj"
+	-@erase "SGC\WXS_STYL.obj"
+	-@erase "SGC\WXSCHEME.obj"
+	-@erase "SGC\WXS_MEDI.obj"
+	-@erase "SGC\WXS_MPB.obj"
+	-@erase "SGC\WXS_SNIP.obj"
+	-@erase "SGC\WXS_MADM.obj"
+	-@erase "SGC\WXS_MIO.obj"
+	-@erase "SGC\WXS_CKBX.obj"
+	-@erase "SGC\WXS_PANL.obj"
+	-@erase "SGC\WXS_GAGE.obj"
+	-@erase "SGC\WXS_TEXT.obj"
+	-@erase "SGC\WXS_WIN.obj"
+	-@erase "SGC\WXS_LBOX.obj"
+	-@erase "SGC\WXS_GLOB.obj"
+	-@erase "SGC\WXS_CHCE.obj"
+	-@erase "SGC\WXS_CNVS.obj"
+	-@erase "SGC\WXS_GDI.obj"
+	-@erase "SGC\WXS_RADO.obj"
+	-@erase "SGC\WXS_EVNT.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /Zi /Od /I "c:\matthew\wxwindow\include\base" /I "c:\Matthew\wxwindow\include\msw" /I "c:\Matthew\mzscheme\include" /I "c:\Matthew\mzscheme\gc" /I "c:\Matthew\mred\wxme" /I "c:\Matthew\mzscheme\utils" /D "__DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\sgc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I "..\..\mzscheme\include" /I "..\..\mred\wxme" /I "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "__DEBUG" /D "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT" /D "__WINDOWS__" /D "WXME_FOR_MRED" /D "USE_SENORA_GC" /YX"wx.h" /c
+CPP_PROJ=/nologo /MTd /W3 /Gm /Zi /Od /I "..\..\mzscheme\sgc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ "..\..\mzscheme\include" /I "..\..\mred\wxme" /I\
+ "..\..\mzscheme\utils" /I "..\..\wxwindow\contrib\fafa" /D "__DEBUG" /D\
+ "__STDC__" /D "WIN32" /D "_WINDOWS" /D "WXS_CANT_ASSIGN_STRUCTURES" /D "WINNT"\
+ /D "__WINDOWS__" /D "WXME_FOR_MRED" /D "USE_SENORA_GC" /Fp"$(INTDIR)/wxs.pch"\
+ /YX"wx.h" /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxs.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxs.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WXS_DC.obj" \
+	"$(INTDIR)/WXS_MENU.obj" \
+	"$(INTDIR)/WXS_MISC.obj" \
+	"$(INTDIR)/WXS_OBJ.obj" \
+	"$(INTDIR)/WXS_BMAP.obj" \
+	"$(INTDIR)/WXS_SLID.obj" \
+	"$(INTDIR)/WXS_BUTN.obj" \
+	"$(INTDIR)/WXS_ITEM.obj" \
+	"$(INTDIR)/WXS_FRAM.obj" \
+	"$(INTDIR)/WXS_MEDE.obj" \
+	"$(INTDIR)/WXS_STYL.obj" \
+	"$(INTDIR)/WXSCHEME.obj" \
+	"$(INTDIR)/WXS_MEDI.obj" \
+	"$(INTDIR)/WXS_MPB.obj" \
+	"$(INTDIR)/WXS_SNIP.obj" \
+	"$(INTDIR)/WXS_MADM.obj" \
+	"$(INTDIR)/WXS_MIO.obj" \
+	"$(INTDIR)/WXS_CKBX.obj" \
+	"$(INTDIR)/WXS_PANL.obj" \
+	"$(INTDIR)/WXS_GAGE.obj" \
+	"$(INTDIR)/WXS_TEXT.obj" \
+	"$(INTDIR)/WXS_WIN.obj" \
+	"$(INTDIR)/WXS_LBOX.obj" \
+	"$(INTDIR)/WXS_GLOB.obj" \
+	"$(INTDIR)/WXS_CHCE.obj" \
+	"$(INTDIR)/WXS_CNVS.obj" \
+	"$(INTDIR)/WXS_GDI.obj" \
+	"$(INTDIR)/WXS_RADO.obj" \
+	"$(INTDIR)/WXS_EVNT.obj"
+
+"$(OUTDIR)\wxs.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "wxs - Win32 Release"
+# Name "wxs - Win32 Debug"
+# Name "wxs - Win32 SGC"
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_DC.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_D=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_D=\
+	".\..\..\mred\Wxs\wx_dcpr.h"\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_DC.obj" : $(SOURCE) $(DEP_CPP_WXS_D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_D=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_D=\
+	".\..\..\mred\Wxs\wx_dcpr.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_DC.obj" : $(SOURCE) $(DEP_CPP_WXS_D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_D=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_D=\
+	".\..\..\mred\Wxs\wx_dcpr.h"\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_DC.obj" : $(SOURCE) $(DEP_CPP_WXS_D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_BUTN.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_B=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_B=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BUTN.obj" : $(SOURCE) $(DEP_CPP_WXS_B) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_B=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_B=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BUTN.obj" : $(SOURCE) $(DEP_CPP_WXS_B) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_B=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_B=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BUTN.obj" : $(SOURCE) $(DEP_CPP_WXS_B) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_CHCE.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_C=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_C=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CHCE.obj" : $(SOURCE) $(DEP_CPP_WXS_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_C=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_C=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CHCE.obj" : $(SOURCE) $(DEP_CPP_WXS_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_C=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_C=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CHCE.obj" : $(SOURCE) $(DEP_CPP_WXS_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_CKBX.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_CK=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CK=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CKBX.obj" : $(SOURCE) $(DEP_CPP_WXS_CK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_CK=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CK=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CKBX.obj" : $(SOURCE) $(DEP_CPP_WXS_CK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_CK=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CK=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CKBX.obj" : $(SOURCE) $(DEP_CPP_WXS_CK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_CNVS.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_CN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CNVS.obj" : $(SOURCE) $(DEP_CPP_WXS_CN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_CN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CN=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CNVS.obj" : $(SOURCE) $(DEP_CPP_WXS_CN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_CN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_CN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_CNVS.obj" : $(SOURCE) $(DEP_CPP_WXS_CN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_BMAP.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_BM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_BM=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BMAP.obj" : $(SOURCE) $(DEP_CPP_WXS_BM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_BM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_BM=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BMAP.obj" : $(SOURCE) $(DEP_CPP_WXS_BM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_BM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_BM=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_BMAP.obj" : $(SOURCE) $(DEP_CPP_WXS_BM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_EVNT.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_E=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_E=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_EVNT.obj" : $(SOURCE) $(DEP_CPP_WXS_E) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_E=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_E=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_EVNT.obj" : $(SOURCE) $(DEP_CPP_WXS_E) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_E=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_E=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_EVNT.obj" : $(SOURCE) $(DEP_CPP_WXS_E) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_FRAM.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_F=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_F=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_FRAM.obj" : $(SOURCE) $(DEP_CPP_WXS_F) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_F=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_F=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_FRAM.obj" : $(SOURCE) $(DEP_CPP_WXS_F) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_F=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_F=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_FRAM.obj" : $(SOURCE) $(DEP_CPP_WXS_F) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_GAGE.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_G=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_G=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GAGE.obj" : $(SOURCE) $(DEP_CPP_WXS_G) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_G=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_G=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GAGE.obj" : $(SOURCE) $(DEP_CPP_WXS_G) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_G=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_G=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GAGE.obj" : $(SOURCE) $(DEP_CPP_WXS_G) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_GDI.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GD=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GDI.obj" : $(SOURCE) $(DEP_CPP_WXS_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GD=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GDI.obj" : $(SOURCE) $(DEP_CPP_WXS_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\mred\Wxs\wxs_bmt.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GD=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GDI.obj" : $(SOURCE) $(DEP_CPP_WXS_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_GLOB.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_GL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GL=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GLOB.obj" : $(SOURCE) $(DEP_CPP_WXS_GL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_GL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GL=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GLOB.obj" : $(SOURCE) $(DEP_CPP_WXS_GL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_GL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_GL=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_GLOB.obj" : $(SOURCE) $(DEP_CPP_WXS_GL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_ITEM.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_I=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_I=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_ITEM.obj" : $(SOURCE) $(DEP_CPP_WXS_I) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_I=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_I=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_ITEM.obj" : $(SOURCE) $(DEP_CPP_WXS_I) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_I=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_I=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_ITEM.obj" : $(SOURCE) $(DEP_CPP_WXS_I) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_LBOX.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_L=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_L=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_LBOX.obj" : $(SOURCE) $(DEP_CPP_WXS_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_L=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_L=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_LBOX.obj" : $(SOURCE) $(DEP_CPP_WXS_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_L=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_L=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_LBOX.obj" : $(SOURCE) $(DEP_CPP_WXS_L) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MADM.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_M=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_M=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MADM.obj" : $(SOURCE) $(DEP_CPP_WXS_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_M=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_M=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MADM.obj" : $(SOURCE) $(DEP_CPP_WXS_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_M=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_M=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MADM.obj" : $(SOURCE) $(DEP_CPP_WXS_M) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MEDE.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ME=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDE.obj" : $(SOURCE) $(DEP_CPP_WXS_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ME=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDE.obj" : $(SOURCE) $(DEP_CPP_WXS_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ME=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDE.obj" : $(SOURCE) $(DEP_CPP_WXS_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MEDI.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_MED=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MED=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDI.obj" : $(SOURCE) $(DEP_CPP_WXS_MED) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_MED=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MED=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDI.obj" : $(SOURCE) $(DEP_CPP_WXS_MED) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_MED=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MED=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MEDI.obj" : $(SOURCE) $(DEP_CPP_WXS_MED) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MENU.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MEN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MENU.obj" : $(SOURCE) $(DEP_CPP_WXS_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MEN=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MENU.obj" : $(SOURCE) $(DEP_CPP_WXS_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MEN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MENU.obj" : $(SOURCE) $(DEP_CPP_WXS_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MIO.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_MI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MI=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MIO.obj" : $(SOURCE) $(DEP_CPP_WXS_MI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_MI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MI=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MIO.obj" : $(SOURCE) $(DEP_CPP_WXS_MI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_MI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MI=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MIO.obj" : $(SOURCE) $(DEP_CPP_WXS_MI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MISC.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_MIS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	
+NODEP_CPP_WXS_MIS=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MISC.obj" : $(SOURCE) $(DEP_CPP_WXS_MIS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_MIS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	
+NODEP_CPP_WXS_MIS=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MISC.obj" : $(SOURCE) $(DEP_CPP_WXS_MIS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_MIS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	
+NODEP_CPP_WXS_MIS=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MISC.obj" : $(SOURCE) $(DEP_CPP_WXS_MIS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_MPB.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_MP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MP=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MPB.obj" : $(SOURCE) $(DEP_CPP_WXS_MP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_MP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MP=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MPB.obj" : $(SOURCE) $(DEP_CPP_WXS_MP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_MP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_MP=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_MPB.obj" : $(SOURCE) $(DEP_CPP_WXS_MP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_OBJ.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_O=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_O=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_OBJ.obj" : $(SOURCE) $(DEP_CPP_WXS_O) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_O=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_O=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_OBJ.obj" : $(SOURCE) $(DEP_CPP_WXS_O) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_O=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_O=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_OBJ.obj" : $(SOURCE) $(DEP_CPP_WXS_O) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_PANL.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_P=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_P=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_PANL.obj" : $(SOURCE) $(DEP_CPP_WXS_P) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_P=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_P=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_PANL.obj" : $(SOURCE) $(DEP_CPP_WXS_P) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_P=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_P=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_PANL.obj" : $(SOURCE) $(DEP_CPP_WXS_P) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_RADO.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_R=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_R=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_RADO.obj" : $(SOURCE) $(DEP_CPP_WXS_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_R=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_R=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_RADO.obj" : $(SOURCE) $(DEP_CPP_WXS_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_R=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_R=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_RADO.obj" : $(SOURCE) $(DEP_CPP_WXS_R) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_SLID.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_S=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_S=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SLID.obj" : $(SOURCE) $(DEP_CPP_WXS_S) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_S=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_S=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SLID.obj" : $(SOURCE) $(DEP_CPP_WXS_S) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_S=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_S=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SLID.obj" : $(SOURCE) $(DEP_CPP_WXS_S) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_SNIP.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_SN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_SN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SNIP.obj" : $(SOURCE) $(DEP_CPP_WXS_SN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_SN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_SN=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SNIP.obj" : $(SOURCE) $(DEP_CPP_WXS_SN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_SN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_SN=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_SNIP.obj" : $(SOURCE) $(DEP_CPP_WXS_SN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_STYL.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ST=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_STYL.obj" : $(SOURCE) $(DEP_CPP_WXS_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ST=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_STYL.obj" : $(SOURCE) $(DEP_CPP_WXS_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_ST=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_STYL.obj" : $(SOURCE) $(DEP_CPP_WXS_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_TEXT.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_T=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_T=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_TEXT.obj" : $(SOURCE) $(DEP_CPP_WXS_T) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_T=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_T=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_TEXT.obj" : $(SOURCE) $(DEP_CPP_WXS_T) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_T=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_T=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_TEXT.obj" : $(SOURCE) $(DEP_CPP_WXS_T) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXS_WIN.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXS_W=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_W=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_WIN.obj" : $(SOURCE) $(DEP_CPP_WXS_W) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXS_W=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_W=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_WIN.obj" : $(SOURCE) $(DEP_CPP_WXS_W) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXS_W=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxscomon.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	"..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	"..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	
+NODEP_CPP_WXS_W=\
+	"..\..\wxwindow\include\msw\fafa.h"\
+	"..\..\wxwindow\include\msw\fafapriv.h"\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXS_WIN.obj" : $(SOURCE) $(DEP_CPP_WXS_W) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\mred\Wxs\WXSCHEME.cxx
+
+!IF  "$(CFG)" == "wxs - Win32 Release"
+
+DEP_CPP_WXSCH=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxs_list.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxs_ipc.h"\
+	".\..\..\mred\Wxs\wxs_help.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxs_tbar.h"\
+	".\..\..\mred\Wxs\wxs_cstr.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+NODEP_CPP_WXSCH=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXSCHEME.obj" : $(SOURCE) $(DEP_CPP_WXSCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 Debug"
+
+DEP_CPP_WXSCH=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxs_list.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxs_ipc.h"\
+	".\..\..\mred\Wxs\wxs_help.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxs_tbar.h"\
+	".\..\..\mred\Wxs\wxs_cstr.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+NODEP_CPP_WXSCH=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXSCHEME.obj" : $(SOURCE) $(DEP_CPP_WXSCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxs - Win32 SGC"
+
+DEP_CPP_WXSCH=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mred\wxme\wx_media.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\mred\Wxs\wxscheme.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\mred\Wxs\wxsmred.h"\
+	".\..\..\mred\Wxs\wxs_obj.h"\
+	".\..\..\mred\Wxs\wxs_win.h"\
+	".\..\..\mred\Wxs\wxs_fram.h"\
+	".\..\..\mred\Wxs\wxs_item.h"\
+	".\..\..\mred\Wxs\wxs_butn.h"\
+	".\..\..\mred\Wxs\wxs_text.h"\
+	".\..\..\mred\Wxs\wxs_ckbx.h"\
+	".\..\..\mred\Wxs\wxs_chce.h"\
+	".\..\..\mred\Wxs\wxs_evnt.h"\
+	".\..\..\mred\Wxs\wxs_panl.h"\
+	".\..\..\mred\Wxs\wxs_list.h"\
+	".\..\..\mred\Wxs\wxs_medi.h"\
+	".\..\..\mred\Wxs\wxs_mede.h"\
+	".\..\..\mred\Wxs\wxs_madm.h"\
+	".\..\..\mred\Wxs\wxs_snip.h"\
+	".\..\..\mred\Wxs\wxs_mpb.h"\
+	".\..\..\mred\Wxs\wxs_mio.h"\
+	".\..\..\mred\Wxs\wxs_styl.h"\
+	".\..\..\mred\Wxs\wxs_menu.h"\
+	".\..\..\mred\Wxs\wxs_bmap.h"\
+	".\..\..\mred\Wxs\wxs_ipc.h"\
+	".\..\..\mred\Wxs\wxs_help.h"\
+	".\..\..\mred\Wxs\wxs_misc.h"\
+	".\..\..\mred\Wxs\wxs_rado.h"\
+	".\..\..\mred\Wxs\wxs_slid.h"\
+	".\..\..\mred\Wxs\wxs_gage.h"\
+	".\..\..\mred\Wxs\wxs_lbox.h"\
+	".\..\..\mred\Wxs\wxs_tbar.h"\
+	".\..\..\mred\Wxs\wxs_cstr.h"\
+	".\..\..\mred\Wxs\wxs_glob.h"\
+	".\..\..\mred\Wxs\wxs_gdi.h"\
+	".\..\..\mred\Wxs\wxs_dc.h"\
+	".\..\..\mred\Wxs\wxs_cnvs.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\mred\wxme\wx_keym.h"\
+	".\..\..\mred\wxme\wx_medio.h"\
+	".\..\..\mred\wxme\wx_style.h"\
+	".\..\..\mred\wxme\wx_mtype.h"\
+	".\..\..\mred\wxme\wx_snip.h"\
+	".\..\..\mred\wxme\wx_cgrec.h"\
+	".\..\..\mred\wxme\wx_medad.h"\
+	".\..\..\mred\wxme\wx_medpb.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\mred\wxme\wx_madm.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\mzscheme\utils\xcglue.h"\
+	".\..\..\mzscheme\include\scheme.h"\
+	".\..\..\mzscheme\sconfig.h"\
+	".\..\..\mzscheme\src\stypes.h"\
+	".\..\..\mzscheme\src\schexn.h"\
+	".\..\..\mzscheme\src\schemef.h"\
+	".\..\..\mzscheme\src\schemex.h"\
+	".\..\..\mzscheme\src\schemexm.h"\
+	".\..\..\mzscheme\uconfig.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+NODEP_CPP_WXSCH=\
+	".\..\..\mzscheme\include\sconfig.h"\
+	".\..\..\mzscheme\include\stypes.h"\
+	".\..\..\mzscheme\include\schexn.h"\
+	".\..\..\mzscheme\include\schemef.h"\
+	".\..\..\mzscheme\include\schemex.h"\
+	".\..\..\mzscheme\include\schemexm.h"\
+	
+
+"$(INTDIR)\WXSCHEME.obj" : $(SOURCE) $(DEP_CPP_WXSCH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/wxs/wxs.mdp b/src/worksp/wxs/wxs.mdp
new file mode 100755
index 0000000..9a40963
Binary files /dev/null and b/src/worksp/wxs/wxs.mdp differ
diff --git a/src/worksp/wxutils/wxutils.mak b/src/worksp/wxutils/wxutils.mak
new file mode 100644
index 0000000..3fa9505
--- /dev/null
+++ b/src/worksp/wxutils/wxutils.mak
@@ -0,0 +1,1411 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=wxwin - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to wxwin - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "wxwin - Win32 Release" && "$(CFG)" != "wxwin - Win32 Debug" &&\
+ "$(CFG)" != "wxwin - Win32 SGC"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "wxutils.mak" CFG="wxwin - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "wxwin - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxwin - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxwin - Win32 SGC" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "wxwin - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\wxutils.lib"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\wxutils.lib"
+	-@erase "Release\Check.obj"
+	-@erase "Release\DIB.obj"
+	-@erase "Release\Zyz3d.obj"
+	-@erase "Release\wximgxbm.obj"
+	-@erase "Release\Draw.obj"
+	-@erase "Release\Hashtab.obj"
+	-@erase "Release\Zyzgauge.obj"
+	-@erase "Release\Crifrdat.obj"
+	-@erase "Release\Crifrbuf.obj"
+	-@erase "Release\Misc.obj"
+	-@erase "Release\Crdatfri.obj"
+	-@erase "Release\Wrffri.obj"
+	-@erase "Release\Cont.obj"
+	-@erase "Release\Rdftoi.obj"
+	-@erase "Release\Dumfafa.obj"
+	-@erase "Release\Data.obj"
+	-@erase "Release\Rdftodat.obj"
+	-@erase "Release\Crbuffri.obj"
+	-@erase "Release\Parse.obj"
+	-@erase "Release\Fafa.obj"
+	-@erase "Release\Rgb.obj"
+	-@erase "Release\Dialog.obj"
+	-@erase "Release\Simx.obj"
+	-@erase "Release\Button.obj"
+	-@erase "Release\Scan.obj"
+	-@erase "Release\Wrffrdat.obj"
+	-@erase "Release\Wrffrp.obj"
+	-@erase "Release\Static.obj"
+	-@erase "Release\Create.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /Zi /O2 /I "..\..\mred\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "NDEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /c
+# SUBTRACT CPP /YX
+CPP_PROJ=/nologo /MT /W3 /Zi /O2 /I "..\..\plt\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "NDEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxutils.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxutils.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Check.obj" \
+	"$(INTDIR)/DIB.obj" \
+	"$(INTDIR)/Zyz3d.obj" \
+	"$(INTDIR)/wximgxbm.obj" \
+	"$(INTDIR)/Draw.obj" \
+	"$(INTDIR)/Hashtab.obj" \
+	"$(INTDIR)/Zyzgauge.obj" \
+	"$(INTDIR)/Crifrdat.obj" \
+	"$(INTDIR)/Crifrbuf.obj" \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Crdatfri.obj" \
+	"$(INTDIR)/Wrffri.obj" \
+	"$(INTDIR)/Cont.obj" \
+	"$(INTDIR)/Rdftoi.obj" \
+	"$(INTDIR)/Dumfafa.obj" \
+	"$(INTDIR)/Data.obj" \
+	"$(INTDIR)/Rdftodat.obj" \
+	"$(INTDIR)/Crbuffri.obj" \
+	"$(INTDIR)/Parse.obj" \
+	"$(INTDIR)/Fafa.obj" \
+	"$(INTDIR)/Rgb.obj" \
+	"$(INTDIR)/Dialog.obj" \
+	"$(INTDIR)/Simx.obj" \
+	"$(INTDIR)/Button.obj" \
+	"$(INTDIR)/Scan.obj" \
+	"$(INTDIR)/Wrffrdat.obj" \
+	"$(INTDIR)/Wrffrp.obj" \
+	"$(INTDIR)/Static.obj" \
+	"$(INTDIR)/Create.obj"
+
+"$(OUTDIR)\wxutils.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\wxutils.lib"
+
+CLEAN : 
+	-@erase "Debug\wxutils.lib"
+	-@erase "Debug\Wrffri.obj"
+	-@erase "Debug\Scan.obj"
+	-@erase "Debug\Hashtab.obj"
+	-@erase "Debug\Rgb.obj"
+	-@erase "Debug\Misc.obj"
+	-@erase "Debug\Static.obj"
+	-@erase "Debug\DIB.obj"
+	-@erase "Debug\Rdftoi.obj"
+	-@erase "Debug\Create.obj"
+	-@erase "Debug\Crbuffri.obj"
+	-@erase "Debug\Dialog.obj"
+	-@erase "Debug\Data.obj"
+	-@erase "Debug\wximgxbm.obj"
+	-@erase "Debug\Fafa.obj"
+	-@erase "Debug\Button.obj"
+	-@erase "Debug\Dumfafa.obj"
+	-@erase "Debug\Crifrdat.obj"
+	-@erase "Debug\Parse.obj"
+	-@erase "Debug\Wrffrp.obj"
+	-@erase "Debug\Check.obj"
+	-@erase "Debug\Zyz3d.obj"
+	-@erase "Debug\Cont.obj"
+	-@erase "Debug\Rdftodat.obj"
+	-@erase "Debug\Zyzgauge.obj"
+	-@erase "Debug\Crifrbuf.obj"
+	-@erase "Debug\Simx.obj"
+	-@erase "Debug\Draw.obj"
+	-@erase "Debug\Crdatfri.obj"
+	-@erase "Debug\Wrffrdat.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Z7 /Od /I "..\..\mred\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /c
+# SUBTRACT CPP /YX
+CPP_PROJ=/nologo /MTd /W3 /Z7 /Od /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /Fo"$(INTDIR)/" /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxutils.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxutils.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Wrffri.obj" \
+	"$(INTDIR)/Scan.obj" \
+	"$(INTDIR)/Hashtab.obj" \
+	"$(INTDIR)/Rgb.obj" \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Static.obj" \
+	"$(INTDIR)/DIB.obj" \
+	"$(INTDIR)/Rdftoi.obj" \
+	"$(INTDIR)/Create.obj" \
+	"$(INTDIR)/Crbuffri.obj" \
+	"$(INTDIR)/Dialog.obj" \
+	"$(INTDIR)/Data.obj" \
+	"$(INTDIR)/wximgxbm.obj" \
+	"$(INTDIR)/Fafa.obj" \
+	"$(INTDIR)/Button.obj" \
+	"$(INTDIR)/Dumfafa.obj" \
+	"$(INTDIR)/Crifrdat.obj" \
+	"$(INTDIR)/Parse.obj" \
+	"$(INTDIR)/Wrffrp.obj" \
+	"$(INTDIR)/Check.obj" \
+	"$(INTDIR)/Zyz3d.obj" \
+	"$(INTDIR)/Cont.obj" \
+	"$(INTDIR)/Rdftodat.obj" \
+	"$(INTDIR)/Zyzgauge.obj" \
+	"$(INTDIR)/Crifrbuf.obj" \
+	"$(INTDIR)/Simx.obj" \
+	"$(INTDIR)/Draw.obj" \
+	"$(INTDIR)/Crdatfri.obj" \
+	"$(INTDIR)/Wrffrdat.obj"
+
+"$(OUTDIR)\wxutils.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "wxwin___"
+# PROP BASE Intermediate_Dir "wxwin___"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\wxutils.lib"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\wxutils.lib"
+	-@erase "SGC\Misc.obj"
+	-@erase "SGC\Dialog.obj"
+	-@erase "SGC\Wrffrdat.obj"
+	-@erase "SGC\Button.obj"
+	-@erase "SGC\Cont.obj"
+	-@erase "SGC\Wrffrp.obj"
+	-@erase "SGC\Static.obj"
+	-@erase "SGC\Fafa.obj"
+	-@erase "SGC\Parse.obj"
+	-@erase "SGC\Create.obj"
+	-@erase "SGC\Hashtab.obj"
+	-@erase "SGC\wximgxbm.obj"
+	-@erase "SGC\Rgb.obj"
+	-@erase "SGC\Zyz3d.obj"
+	-@erase "SGC\Simx.obj"
+	-@erase "SGC\DIB.obj"
+	-@erase "SGC\Draw.obj"
+	-@erase "SGC\Zyzgauge.obj"
+	-@erase "SGC\Crifrdat.obj"
+	-@erase "SGC\Crifrbuf.obj"
+	-@erase "SGC\Scan.obj"
+	-@erase "SGC\Crdatfri.obj"
+	-@erase "SGC\Dumfafa.obj"
+	-@erase "SGC\Wrffri.obj"
+	-@erase "SGC\Rdftodat.obj"
+	-@erase "SGC\Crbuffri.obj"
+	-@erase "SGC\Check.obj"
+	-@erase "SGC\Data.obj"
+	-@erase "SGC\Rdftoi.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Z7 /Od /I "c:\Matthew\wxwindow\include\base" /I "c:\Matthew\wxwindow\include\msw" /I ":\Matthew\wxwindow\src\base" /I "c:\Matthew\wxwindow\src\msw" /I "c:\Matthew\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "c:\Matthew\mred\mzscheme\gc" /I "c:\Matthew\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /YX"wx.h" /c
+# ADD CPP /nologo /MTd /W3 /Zi /Od /I "..\..\mred\mzscheme\sgc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNT" /c
+# SUBTRACT CPP /YX
+CPP_PROJ=/nologo /MTd /W3 /Zi /Od /I "..\..\mzscheme\sgc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ":..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNT"\
+ /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxutils.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxutils.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/Misc.obj" \
+	"$(INTDIR)/Dialog.obj" \
+	"$(INTDIR)/Wrffrdat.obj" \
+	"$(INTDIR)/Button.obj" \
+	"$(INTDIR)/Cont.obj" \
+	"$(INTDIR)/Wrffrp.obj" \
+	"$(INTDIR)/Static.obj" \
+	"$(INTDIR)/Fafa.obj" \
+	"$(INTDIR)/Parse.obj" \
+	"$(INTDIR)/Create.obj" \
+	"$(INTDIR)/Hashtab.obj" \
+	"$(INTDIR)/wximgxbm.obj" \
+	"$(INTDIR)/Rgb.obj" \
+	"$(INTDIR)/Zyz3d.obj" \
+	"$(INTDIR)/Simx.obj" \
+	"$(INTDIR)/DIB.obj" \
+	"$(INTDIR)/Draw.obj" \
+	"$(INTDIR)/Zyzgauge.obj" \
+	"$(INTDIR)/Crifrdat.obj" \
+	"$(INTDIR)/Crifrbuf.obj" \
+	"$(INTDIR)/Scan.obj" \
+	"$(INTDIR)/Crdatfri.obj" \
+	"$(INTDIR)/Dumfafa.obj" \
+	"$(INTDIR)/Wrffri.obj" \
+	"$(INTDIR)/Rdftodat.obj" \
+	"$(INTDIR)/Crbuffri.obj" \
+	"$(INTDIR)/Check.obj" \
+	"$(INTDIR)/Data.obj" \
+	"$(INTDIR)/Rdftoi.obj"
+
+"$(OUTDIR)\wxutils.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "wxwin - Win32 Release"
+# Name "wxwin - Win32 Debug"
+# Name "wxwin - Win32 SGC"
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Wrffrp.c
+DEP_CPP_WRFFR=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Wrffrp.obj" : $(SOURCE) $(DEP_CPP_WRFFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Wrffrp.obj" : $(SOURCE) $(DEP_CPP_WRFFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Wrffrp.obj" : $(SOURCE) $(DEP_CPP_WRFFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Crdatfri.c
+DEP_CPP_CRDAT=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Crdatfri.obj" : $(SOURCE) $(DEP_CPP_CRDAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Crdatfri.obj" : $(SOURCE) $(DEP_CPP_CRDAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Crdatfri.obj" : $(SOURCE) $(DEP_CPP_CRDAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Create.c
+DEP_CPP_CREAT=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Create.obj" : $(SOURCE) $(DEP_CPP_CREAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Create.obj" : $(SOURCE) $(DEP_CPP_CREAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Create.obj" : $(SOURCE) $(DEP_CPP_CREAT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Crifrbuf.c
+DEP_CPP_CRIFR=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Crifrbuf.obj" : $(SOURCE) $(DEP_CPP_CRIFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Crifrbuf.obj" : $(SOURCE) $(DEP_CPP_CRIFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Crifrbuf.obj" : $(SOURCE) $(DEP_CPP_CRIFR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Crifrdat.c
+DEP_CPP_CRIFRD=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Crifrdat.obj" : $(SOURCE) $(DEP_CPP_CRIFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Crifrdat.obj" : $(SOURCE) $(DEP_CPP_CRIFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Crifrdat.obj" : $(SOURCE) $(DEP_CPP_CRIFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Data.c
+DEP_CPP_DATA_=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Data.obj" : $(SOURCE) $(DEP_CPP_DATA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Data.obj" : $(SOURCE) $(DEP_CPP_DATA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Data.obj" : $(SOURCE) $(DEP_CPP_DATA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Hashtab.c
+DEP_CPP_HASHT=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Hashtab.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Hashtab.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Hashtab.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Misc.c
+DEP_CPP_MISC_=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Misc.obj" : $(SOURCE) $(DEP_CPP_MISC_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Parse.c
+DEP_CPP_PARSE=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Parse.obj" : $(SOURCE) $(DEP_CPP_PARSE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Parse.obj" : $(SOURCE) $(DEP_CPP_PARSE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Parse.obj" : $(SOURCE) $(DEP_CPP_PARSE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Rdftodat.c
+DEP_CPP_RDFTO=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Rdftodat.obj" : $(SOURCE) $(DEP_CPP_RDFTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Rdftodat.obj" : $(SOURCE) $(DEP_CPP_RDFTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Rdftodat.obj" : $(SOURCE) $(DEP_CPP_RDFTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Rdftoi.c
+DEP_CPP_RDFTOI=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Rdftoi.obj" : $(SOURCE) $(DEP_CPP_RDFTOI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Rdftoi.obj" : $(SOURCE) $(DEP_CPP_RDFTOI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Rdftoi.obj" : $(SOURCE) $(DEP_CPP_RDFTOI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Rgb.c
+DEP_CPP_RGB_C=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\rgbtab.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Rgb.obj" : $(SOURCE) $(DEP_CPP_RGB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Rgb.obj" : $(SOURCE) $(DEP_CPP_RGB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Rgb.obj" : $(SOURCE) $(DEP_CPP_RGB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Scan.c
+DEP_CPP_SCAN_=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Scan.obj" : $(SOURCE) $(DEP_CPP_SCAN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Scan.obj" : $(SOURCE) $(DEP_CPP_SCAN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Scan.obj" : $(SOURCE) $(DEP_CPP_SCAN_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Simx.c
+DEP_CPP_SIMX_=\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Simx.obj" : $(SOURCE) $(DEP_CPP_SIMX_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Simx.obj" : $(SOURCE) $(DEP_CPP_SIMX_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Simx.obj" : $(SOURCE) $(DEP_CPP_SIMX_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Wrffrdat.c
+DEP_CPP_WRFFRD=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Wrffrdat.obj" : $(SOURCE) $(DEP_CPP_WRFFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Wrffrdat.obj" : $(SOURCE) $(DEP_CPP_WRFFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Wrffrdat.obj" : $(SOURCE) $(DEP_CPP_WRFFRD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Wrffri.c
+DEP_CPP_WRFFRI=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Wrffri.obj" : $(SOURCE) $(DEP_CPP_WRFFRI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Wrffri.obj" : $(SOURCE) $(DEP_CPP_WRFFRI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Wrffri.obj" : $(SOURCE) $(DEP_CPP_WRFFRI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\Crbuffri.c
+DEP_CPP_CRBUF=\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\xpm34p.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Crbuffri.obj" : $(SOURCE) $(DEP_CPP_CRBUF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Crbuffri.obj" : $(SOURCE) $(DEP_CPP_CRBUF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Crbuffri.obj" : $(SOURCE) $(DEP_CPP_CRBUF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Utils\Dib\DIB.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_DIB_C=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+"$(INTDIR)\DIB.obj" : $(SOURCE) $(DEP_CPP_DIB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_DIB_C=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+"$(INTDIR)\DIB.obj" : $(SOURCE) $(DEP_CPP_DIB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_DIB_C=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	
+
+"$(INTDIR)\DIB.obj" : $(SOURCE) $(DEP_CPP_DIB_C) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Gauge\Zyz3d.c
+DEP_CPP_ZYZ3D=\
+	".\..\..\Wxwindow\Contrib\Gauge\zyz3d.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Zyz3d.obj" : $(SOURCE) $(DEP_CPP_ZYZ3D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Zyz3d.obj" : $(SOURCE) $(DEP_CPP_ZYZ3D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Zyz3d.obj" : $(SOURCE) $(DEP_CPP_ZYZ3D) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Gauge\Zyzgauge.c
+DEP_CPP_ZYZGA=\
+	".\..\..\Wxwindow\Contrib\Gauge\zyz3d.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Zyzgauge.obj" : $(SOURCE) $(DEP_CPP_ZYZGA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Zyzgauge.obj" : $(SOURCE) $(DEP_CPP_ZYZGA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Zyzgauge.obj" : $(SOURCE) $(DEP_CPP_ZYZGA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Static.c
+DEP_CPP_STATI=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Static.obj" : $(SOURCE) $(DEP_CPP_STATI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Static.obj" : $(SOURCE) $(DEP_CPP_STATI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Static.obj" : $(SOURCE) $(DEP_CPP_STATI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Check.c
+DEP_CPP_CHECK=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Check.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Check.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Check.obj" : $(SOURCE) $(DEP_CPP_CHECK) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Cont.c
+DEP_CPP_CONT_=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Cont.obj" : $(SOURCE) $(DEP_CPP_CONT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Cont.obj" : $(SOURCE) $(DEP_CPP_CONT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Cont.obj" : $(SOURCE) $(DEP_CPP_CONT_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Dialog.c
+DEP_CPP_DIALO=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Dialog.obj" : $(SOURCE) $(DEP_CPP_DIALO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Dialog.obj" : $(SOURCE) $(DEP_CPP_DIALO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Dialog.obj" : $(SOURCE) $(DEP_CPP_DIALO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Draw.c
+DEP_CPP_DRAW_=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Dumfafa.c
+DEP_CPP_DUMFA=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Dumfafa.obj" : $(SOURCE) $(DEP_CPP_DUMFA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Dumfafa.obj" : $(SOURCE) $(DEP_CPP_DUMFA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Dumfafa.obj" : $(SOURCE) $(DEP_CPP_DUMFA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Fafa.c
+DEP_CPP_FAFA_=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Fafa.obj" : $(SOURCE) $(DEP_CPP_FAFA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Fafa.obj" : $(SOURCE) $(DEP_CPP_FAFA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Fafa.obj" : $(SOURCE) $(DEP_CPP_FAFA_) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Contrib\Fafa\Button.c
+DEP_CPP_BUTTO=\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\Button.obj" : $(SOURCE) $(DEP_CPP_BUTTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\Button.obj" : $(SOURCE) $(DEP_CPP_BUTTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\Button.obj" : $(SOURCE) $(DEP_CPP_BUTTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\wximgxbm.cxx
+DEP_CPP_WXIMG=\
+	".\..\..\wxwindow\include\msw\wximgxbm.h"\
+	
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+
+"$(INTDIR)\wximgxbm.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+
+"$(INTDIR)\wximgxbm.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+
+"$(INTDIR)\wximgxbm.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/wxutils/wxutils.mdp b/src/worksp/wxutils/wxutils.mdp
new file mode 100755
index 0000000..355081e
Binary files /dev/null and b/src/worksp/wxutils/wxutils.mdp differ
diff --git a/src/worksp/wxwin/wxwin.mak b/src/worksp/wxwin/wxwin.mak
new file mode 100644
index 0000000..c27e459
--- /dev/null
+++ b/src/worksp/wxwin/wxwin.mak
@@ -0,0 +1,14571 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=wxwin - Win32 Release
+!MESSAGE No configuration specified.  Defaulting to wxwin - Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "wxwin - Win32 Release" && "$(CFG)" != "wxwin - Win32 Debug" &&\
+ "$(CFG)" != "wxwin - Win32 SGC"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "wxwin.mak" CFG="wxwin - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "wxwin - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxwin - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "wxwin - Win32 SGC" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "wxwin - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=Release
+INTDIR=Release
+
+ALL : "$(OUTDIR)\wxwin.lib"
+
+CLEAN : 
+	-@erase "Release\vc40.pdb"
+	-@erase "Release\wxwin.lib"
+	-@erase "Release\WX_WIN.obj"
+	-@erase "Release\WB_SCROL.obj"
+	-@erase "Release\WB_SYSEV.obj"
+	-@erase "Release\WX_DATE.obj"
+	-@erase "Release\WB_DATA.obj"
+	-@erase "Release\WX_FRAC.obj"
+	-@erase "Release\WX_FRAME.obj"
+	-@erase "Release\WX_GDI.obj"
+	-@erase "Release\WB_STDEV.obj"
+	-@erase "Release\WX_BBAR.obj"
+	-@erase "Release\WB_WIN.obj"
+	-@erase "Release\WX_MTXT.obj"
+	-@erase "Release\WX_RBOX.obj"
+	-@erase "Release\WX_DB.obj"
+	-@erase "Release\WX_VLBOX.obj"
+	-@erase "Release\WX_TIME.obj"
+	-@erase "Release\WB_GDI.obj"
+	-@erase "Release\WB_TIMER.obj"
+	-@erase "Release\WX_MEM.obj"
+	-@erase "Release\WX_TEXT.obj"
+	-@erase "Release\wx_pdf.obj"
+	-@erase "Release\WB_FRAME.obj"
+	-@erase "Release\WX_LBOX.obj"
+	-@erase "Release\WX_GAUGE.obj"
+	-@erase "Release\WB_HASH.obj"
+	-@erase "Release\WX_TIMER.obj"
+	-@erase "Release\WX_STAT.obj"
+	-@erase "Release\WB_RES.obj"
+	-@erase "Release\WB_PRINT.obj"
+	-@erase "Release\WB_FORM.obj"
+	-@erase "Release\WX_IPC.obj"
+	-@erase "Release\WX_GROUP.obj"
+	-@erase "Release\WX_BUTTN.obj"
+	-@erase "Release\WB_TEXT.obj"
+	-@erase "Release\WB_OBJ.obj"
+	-@erase "Release\WB_STAT.obj"
+	-@erase "Release\WB_CMDLG.obj"
+	-@erase "Release\WX_TBAR.obj"
+	-@erase "Release\WB_VLBOX.obj"
+	-@erase "Release\WX_MAIN.obj"
+	-@erase "Release\WX_DOC.obj"
+	-@erase "Release\WX_LAY.obj"
+	-@erase "Release\WX_CANVS.obj"
+	-@erase "Release\WB_PANEL.obj"
+	-@erase "Release\WX_UTILS.obj"
+	-@erase "Release\WB_TYPES.obj"
+	-@erase "Release\WX_MENU.obj"
+	-@erase "Release\WB_HELP.obj"
+	-@erase "Release\WX_MESSG.obj"
+	-@erase "Release\WXSTRING.obj"
+	-@erase "Release\WB_MF.obj"
+	-@erase "Release\WX_SCROL.obj"
+	-@erase "Release\WX_SLIDR.obj"
+	-@erase "Release\WX_CMDLG.obj"
+	-@erase "Release\WB_IPC.obj"
+	-@erase "Release\WB_MAIN.obj"
+	-@erase "Release\WX_PANEL.obj"
+	-@erase "Release\WX_TXT.obj"
+	-@erase "Release\WX_MF.obj"
+	-@erase "Release\WX_CHECK.obj"
+	-@erase "Release\WX_CHOIC.obj"
+	-@erase "Release\WX_CLIPB.obj"
+	-@erase "Release\WB_DIALG.obj"
+	-@erase "Release\WX_ITEM.obj"
+	-@erase "Release\WB_DC.obj"
+	-@erase "Release\WX_ENHDG.obj"
+	-@erase "Release\wximgfil.obj"
+	-@erase "Release\WB_CANVS.obj"
+	-@erase "Release\WB_UTILS.obj"
+	-@erase "Release\WB_LIST.obj"
+	-@erase "Release\WB_MGSTR.obj"
+	-@erase "Release\WB_PS.obj"
+	-@erase "Release\WX_DIALG.obj"
+	-@erase "Release\WB_ITEM.obj"
+	-@erase "Release\WX_DC.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "NDEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /YX"wx.h" /c
+CPP_PROJ=/nologo /MT /W3 /Zi /O2 /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "NDEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /Fp"$(INTDIR)/wxwin.pch" /YX"wx.h" /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=Release/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxwin.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxwin.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WX_WIN.obj" \
+	"$(INTDIR)/WB_SCROL.obj" \
+	"$(INTDIR)/WB_SYSEV.obj" \
+	"$(INTDIR)/WX_DATE.obj" \
+	"$(INTDIR)/WB_DATA.obj" \
+	"$(INTDIR)/WX_FRAC.obj" \
+	"$(INTDIR)/WX_FRAME.obj" \
+	"$(INTDIR)/WX_GDI.obj" \
+	"$(INTDIR)/WB_STDEV.obj" \
+	"$(INTDIR)/WX_BBAR.obj" \
+	"$(INTDIR)/WB_WIN.obj" \
+	"$(INTDIR)/WX_MTXT.obj" \
+	"$(INTDIR)/WX_RBOX.obj" \
+	"$(INTDIR)/WX_DB.obj" \
+	"$(INTDIR)/WX_VLBOX.obj" \
+	"$(INTDIR)/WX_TIME.obj" \
+	"$(INTDIR)/WB_GDI.obj" \
+	"$(INTDIR)/WB_TIMER.obj" \
+	"$(INTDIR)/WX_MEM.obj" \
+	"$(INTDIR)/WX_TEXT.obj" \
+	"$(INTDIR)/wx_pdf.obj" \
+	"$(INTDIR)/WB_FRAME.obj" \
+	"$(INTDIR)/WX_LBOX.obj" \
+	"$(INTDIR)/WX_GAUGE.obj" \
+	"$(INTDIR)/WB_HASH.obj" \
+	"$(INTDIR)/WX_TIMER.obj" \
+	"$(INTDIR)/WX_STAT.obj" \
+	"$(INTDIR)/WB_RES.obj" \
+	"$(INTDIR)/WB_PRINT.obj" \
+	"$(INTDIR)/WB_FORM.obj" \
+	"$(INTDIR)/WX_IPC.obj" \
+	"$(INTDIR)/WX_GROUP.obj" \
+	"$(INTDIR)/WX_BUTTN.obj" \
+	"$(INTDIR)/WB_TEXT.obj" \
+	"$(INTDIR)/WB_OBJ.obj" \
+	"$(INTDIR)/WB_STAT.obj" \
+	"$(INTDIR)/WB_CMDLG.obj" \
+	"$(INTDIR)/WX_TBAR.obj" \
+	"$(INTDIR)/WB_VLBOX.obj" \
+	"$(INTDIR)/WX_MAIN.obj" \
+	"$(INTDIR)/WX_DOC.obj" \
+	"$(INTDIR)/WX_LAY.obj" \
+	"$(INTDIR)/WX_CANVS.obj" \
+	"$(INTDIR)/WB_PANEL.obj" \
+	"$(INTDIR)/WX_UTILS.obj" \
+	"$(INTDIR)/WB_TYPES.obj" \
+	"$(INTDIR)/WX_MENU.obj" \
+	"$(INTDIR)/WB_HELP.obj" \
+	"$(INTDIR)/WX_MESSG.obj" \
+	"$(INTDIR)/WXSTRING.obj" \
+	"$(INTDIR)/WB_MF.obj" \
+	"$(INTDIR)/WX_SCROL.obj" \
+	"$(INTDIR)/WX_SLIDR.obj" \
+	"$(INTDIR)/WX_CMDLG.obj" \
+	"$(INTDIR)/WB_IPC.obj" \
+	"$(INTDIR)/WB_MAIN.obj" \
+	"$(INTDIR)/WX_PANEL.obj" \
+	"$(INTDIR)/WX_TXT.obj" \
+	"$(INTDIR)/WX_MF.obj" \
+	"$(INTDIR)/WX_CHECK.obj" \
+	"$(INTDIR)/WX_CHOIC.obj" \
+	"$(INTDIR)/WX_CLIPB.obj" \
+	"$(INTDIR)/WB_DIALG.obj" \
+	"$(INTDIR)/WX_ITEM.obj" \
+	"$(INTDIR)/WB_DC.obj" \
+	"$(INTDIR)/WX_ENHDG.obj" \
+	"$(INTDIR)/wximgfil.obj" \
+	"$(INTDIR)/WB_CANVS.obj" \
+	"$(INTDIR)/WB_UTILS.obj" \
+	"$(INTDIR)/WB_LIST.obj" \
+	"$(INTDIR)/WB_MGSTR.obj" \
+	"$(INTDIR)/WB_PS.obj" \
+	"$(INTDIR)/WX_DIALG.obj" \
+	"$(INTDIR)/WB_ITEM.obj" \
+	"$(INTDIR)/WX_DC.obj"
+
+"$(OUTDIR)\wxwin.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+OUTDIR=Debug
+INTDIR=Debug
+
+ALL : "$(OUTDIR)\wxwin.lib"
+
+CLEAN : 
+	-@erase "Debug\wxwin.lib"
+	-@erase "Debug\WB_FORM.obj"
+	-@erase "Debug\WB_PS.obj"
+	-@erase "Debug\WB_TIMER.obj"
+	-@erase "Debug\WX_DC.obj"
+	-@erase "Debug\WB_LIST.obj"
+	-@erase "Debug\WB_TEXT.obj"
+	-@erase "Debug\WX_CHECK.obj"
+	-@erase "Debug\WX_CHOIC.obj"
+	-@erase "Debug\WX_CLIPB.obj"
+	-@erase "Debug\WX_DATE.obj"
+	-@erase "Debug\WX_ENHDG.obj"
+	-@erase "Debug\WB_CANVS.obj"
+	-@erase "Debug\WB_UTILS.obj"
+	-@erase "Debug\WX_MENU.obj"
+	-@erase "Debug\WB_HELP.obj"
+	-@erase "Debug\wx_pdf.obj"
+	-@erase "Debug\WX_DIALG.obj"
+	-@erase "Debug\WX_BBAR.obj"
+	-@erase "Debug\WX_WIN.obj"
+	-@erase "Debug\WB_SCROL.obj"
+	-@erase "Debug\WB_MAIN.obj"
+	-@erase "Debug\WB_RES.obj"
+	-@erase "Debug\WX_DB.obj"
+	-@erase "Debug\WX_CANVS.obj"
+	-@erase "Debug\WB_PANEL.obj"
+	-@erase "Debug\WX_UTILS.obj"
+	-@erase "Debug\WX_IPC.obj"
+	-@erase "Debug\WX_MTXT.obj"
+	-@erase "Debug\WX_RBOX.obj"
+	-@erase "Debug\WX_GDI.obj"
+	-@erase "Debug\WB_OBJ.obj"
+	-@erase "Debug\WX_SCROL.obj"
+	-@erase "Debug\WX_TIME.obj"
+	-@erase "Debug\WX_DOC.obj"
+	-@erase "Debug\WX_LAY.obj"
+	-@erase "Debug\WB_WIN.obj"
+	-@erase "Debug\WB_IPC.obj"
+	-@erase "Debug\WX_TEXT.obj"
+	-@erase "Debug\WB_ITEM.obj"
+	-@erase "Debug\WB_GDI.obj"
+	-@erase "Debug\WB_HASH.obj"
+	-@erase "Debug\WB_DIALG.obj"
+	-@erase "Debug\WX_STAT.obj"
+	-@erase "Debug\WB_DATA.obj"
+	-@erase "Debug\WX_FRAC.obj"
+	-@erase "Debug\wximgfil.obj"
+	-@erase "Debug\WB_MGSTR.obj"
+	-@erase "Debug\WX_MEM.obj"
+	-@erase "Debug\WB_FRAME.obj"
+	-@erase "Debug\WB_STAT.obj"
+	-@erase "Debug\WX_TBAR.obj"
+	-@erase "Debug\WX_GAUGE.obj"
+	-@erase "Debug\WX_MAIN.obj"
+	-@erase "Debug\WX_TIMER.obj"
+	-@erase "Debug\WB_PRINT.obj"
+	-@erase "Debug\WB_SYSEV.obj"
+	-@erase "Debug\WB_MF.obj"
+	-@erase "Debug\WX_GROUP.obj"
+	-@erase "Debug\WX_BUTTN.obj"
+	-@erase "Debug\WX_FRAME.obj"
+	-@erase "Debug\WB_STDEV.obj"
+	-@erase "Debug\WB_CMDLG.obj"
+	-@erase "Debug\WB_VLBOX.obj"
+	-@erase "Debug\WX_MF.obj"
+	-@erase "Debug\WB_TYPES.obj"
+	-@erase "Debug\WX_MESSG.obj"
+	-@erase "Debug\WXSTRING.obj"
+	-@erase "Debug\WB_DC.obj"
+	-@erase "Debug\WX_SLIDR.obj"
+	-@erase "Debug\WX_CMDLG.obj"
+	-@erase "Debug\WX_VLBOX.obj"
+	-@erase "Debug\WX_PANEL.obj"
+	-@erase "Debug\WX_ITEM.obj"
+	-@erase "Debug\WX_LBOX.obj"
+	-@erase "Debug\WX_TXT.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Z7 /Od /I "..\..\mzscheme\gc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /YX"wx.h" /c
+CPP_PROJ=/nologo /MTd /W3 /Z7 /Od /I "..\..\mzscheme\gc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /Fp"$(INTDIR)/wxwin.pch" /YX"wx.h" /Fo"$(INTDIR)/"\
+ /c 
+CPP_OBJS=Debug/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxwin.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxwin.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WB_FORM.obj" \
+	"$(INTDIR)/WB_PS.obj" \
+	"$(INTDIR)/WB_TIMER.obj" \
+	"$(INTDIR)/WX_DC.obj" \
+	"$(INTDIR)/WB_LIST.obj" \
+	"$(INTDIR)/WB_TEXT.obj" \
+	"$(INTDIR)/WX_CHECK.obj" \
+	"$(INTDIR)/WX_CHOIC.obj" \
+	"$(INTDIR)/WX_CLIPB.obj" \
+	"$(INTDIR)/WX_DATE.obj" \
+	"$(INTDIR)/WX_ENHDG.obj" \
+	"$(INTDIR)/WB_CANVS.obj" \
+	"$(INTDIR)/WB_UTILS.obj" \
+	"$(INTDIR)/WX_MENU.obj" \
+	"$(INTDIR)/WB_HELP.obj" \
+	"$(INTDIR)/wx_pdf.obj" \
+	"$(INTDIR)/WX_DIALG.obj" \
+	"$(INTDIR)/WX_BBAR.obj" \
+	"$(INTDIR)/WX_WIN.obj" \
+	"$(INTDIR)/WB_SCROL.obj" \
+	"$(INTDIR)/WB_MAIN.obj" \
+	"$(INTDIR)/WB_RES.obj" \
+	"$(INTDIR)/WX_DB.obj" \
+	"$(INTDIR)/WX_CANVS.obj" \
+	"$(INTDIR)/WB_PANEL.obj" \
+	"$(INTDIR)/WX_UTILS.obj" \
+	"$(INTDIR)/WX_IPC.obj" \
+	"$(INTDIR)/WX_MTXT.obj" \
+	"$(INTDIR)/WX_RBOX.obj" \
+	"$(INTDIR)/WX_GDI.obj" \
+	"$(INTDIR)/WB_OBJ.obj" \
+	"$(INTDIR)/WX_SCROL.obj" \
+	"$(INTDIR)/WX_TIME.obj" \
+	"$(INTDIR)/WX_DOC.obj" \
+	"$(INTDIR)/WX_LAY.obj" \
+	"$(INTDIR)/WB_WIN.obj" \
+	"$(INTDIR)/WB_IPC.obj" \
+	"$(INTDIR)/WX_TEXT.obj" \
+	"$(INTDIR)/WB_ITEM.obj" \
+	"$(INTDIR)/WB_GDI.obj" \
+	"$(INTDIR)/WB_HASH.obj" \
+	"$(INTDIR)/WB_DIALG.obj" \
+	"$(INTDIR)/WX_STAT.obj" \
+	"$(INTDIR)/WB_DATA.obj" \
+	"$(INTDIR)/WX_FRAC.obj" \
+	"$(INTDIR)/wximgfil.obj" \
+	"$(INTDIR)/WB_MGSTR.obj" \
+	"$(INTDIR)/WX_MEM.obj" \
+	"$(INTDIR)/WB_FRAME.obj" \
+	"$(INTDIR)/WB_STAT.obj" \
+	"$(INTDIR)/WX_TBAR.obj" \
+	"$(INTDIR)/WX_GAUGE.obj" \
+	"$(INTDIR)/WX_MAIN.obj" \
+	"$(INTDIR)/WX_TIMER.obj" \
+	"$(INTDIR)/WB_PRINT.obj" \
+	"$(INTDIR)/WB_SYSEV.obj" \
+	"$(INTDIR)/WB_MF.obj" \
+	"$(INTDIR)/WX_GROUP.obj" \
+	"$(INTDIR)/WX_BUTTN.obj" \
+	"$(INTDIR)/WX_FRAME.obj" \
+	"$(INTDIR)/WB_STDEV.obj" \
+	"$(INTDIR)/WB_CMDLG.obj" \
+	"$(INTDIR)/WB_VLBOX.obj" \
+	"$(INTDIR)/WX_MF.obj" \
+	"$(INTDIR)/WB_TYPES.obj" \
+	"$(INTDIR)/WX_MESSG.obj" \
+	"$(INTDIR)/WXSTRING.obj" \
+	"$(INTDIR)/WB_DC.obj" \
+	"$(INTDIR)/WX_SLIDR.obj" \
+	"$(INTDIR)/WX_CMDLG.obj" \
+	"$(INTDIR)/WX_VLBOX.obj" \
+	"$(INTDIR)/WX_PANEL.obj" \
+	"$(INTDIR)/WX_ITEM.obj" \
+	"$(INTDIR)/WX_LBOX.obj" \
+	"$(INTDIR)/WX_TXT.obj"
+
+"$(OUTDIR)\wxwin.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "wxwin___"
+# PROP BASE Intermediate_Dir "wxwin___"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SGC"
+# PROP Intermediate_Dir "SGC"
+# PROP Target_Dir ""
+OUTDIR=SGC
+INTDIR=SGC
+
+ALL : "$(OUTDIR)\wxwin.lib"
+
+CLEAN : 
+	-@erase "SGC\vc40.pdb"
+	-@erase "SGC\wxwin.lib"
+	-@erase "SGC\WB_DATA.obj"
+	-@erase "SGC\WB_STDEV.obj"
+	-@erase "SGC\WX_DC.obj"
+	-@erase "SGC\WX_FRAC.obj"
+	-@erase "SGC\WB_VLBOX.obj"
+	-@erase "SGC\WX_MEM.obj"
+	-@erase "SGC\WB_STAT.obj"
+	-@erase "SGC\WB_TYPES.obj"
+	-@erase "SGC\WX_MAIN.obj"
+	-@erase "SGC\WX_MESSG.obj"
+	-@erase "SGC\WB_RES.obj"
+	-@erase "SGC\WXSTRING.obj"
+	-@erase "SGC\WX_SLIDR.obj"
+	-@erase "SGC\WX_CMDLG.obj"
+	-@erase "SGC\WX_VLBOX.obj"
+	-@erase "SGC\WX_PANEL.obj"
+	-@erase "SGC\WB_OBJ.obj"
+	-@erase "SGC\WB_TIMER.obj"
+	-@erase "SGC\WX_DB.obj"
+	-@erase "SGC\WX_DOC.obj"
+	-@erase "SGC\WX_CHOIC.obj"
+	-@erase "SGC\WB_FRAME.obj"
+	-@erase "SGC\WX_ENHDG.obj"
+	-@erase "SGC\WB_PRINT.obj"
+	-@erase "SGC\WX_ITEM.obj"
+	-@erase "SGC\WX_LBOX.obj"
+	-@erase "SGC\WX_TXT.obj"
+	-@erase "SGC\WB_UTILS.obj"
+	-@erase "SGC\WX_DIALG.obj"
+	-@erase "SGC\WB_FORM.obj"
+	-@erase "SGC\WB_SCROL.obj"
+	-@erase "SGC\WB_LIST.obj"
+	-@erase "SGC\WB_CMDLG.obj"
+	-@erase "SGC\WB_TEXT.obj"
+	-@erase "SGC\WX_CANVS.obj"
+	-@erase "SGC\WB_PANEL.obj"
+	-@erase "SGC\WX_UTILS.obj"
+	-@erase "SGC\WX_TBAR.obj"
+	-@erase "SGC\WX_DATE.obj"
+	-@erase "SGC\WX_SCROL.obj"
+	-@erase "SGC\WX_MENU.obj"
+	-@erase "SGC\WB_HELP.obj"
+	-@erase "SGC\wx_pdf.obj"
+	-@erase "SGC\WX_BBAR.obj"
+	-@erase "SGC\WX_WIN.obj"
+	-@erase "SGC\WB_MAIN.obj"
+	-@erase "SGC\WB_MF.obj"
+	-@erase "SGC\WX_MTXT.obj"
+	-@erase "SGC\WX_IPC.obj"
+	-@erase "SGC\WX_RBOX.obj"
+	-@erase "SGC\WX_CHECK.obj"
+	-@erase "SGC\WX_CLIPB.obj"
+	-@erase "SGC\WB_DIALG.obj"
+	-@erase "SGC\WX_GDI.obj"
+	-@erase "SGC\WX_TIME.obj"
+	-@erase "SGC\WX_LAY.obj"
+	-@erase "SGC\WX_MF.obj"
+	-@erase "SGC\wximgfil.obj"
+	-@erase "SGC\WB_CANVS.obj"
+	-@erase "SGC\WB_WIN.obj"
+	-@erase "SGC\WB_MGSTR.obj"
+	-@erase "SGC\WB_DC.obj"
+	-@erase "SGC\WX_GAUGE.obj"
+	-@erase "SGC\WX_TIMER.obj"
+	-@erase "SGC\WB_IPC.obj"
+	-@erase "SGC\WB_SYSEV.obj"
+	-@erase "SGC\WX_TEXT.obj"
+	-@erase "SGC\WB_ITEM.obj"
+	-@erase "SGC\WB_GDI.obj"
+	-@erase "SGC\WX_GROUP.obj"
+	-@erase "SGC\WB_HASH.obj"
+	-@erase "SGC\WX_BUTTN.obj"
+	-@erase "SGC\WX_STAT.obj"
+	-@erase "SGC\WX_FRAME.obj"
+	-@erase "SGC\WB_PS.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Z7 /Od /I "c:\Matthew\wxwindow\include\base" /I "c:\Matthew\wxwindow\include\msw" /I ":\Matthew\wxwindow\src\base" /I "c:\Matthew\wxwindow\src\msw" /I "c:\Matthew\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "c:\Matthew\mzscheme\gc" /I "c:\Matthew\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /YX"wx.h" /c
+# ADD CPP /nologo /MTd /W3 /Zi /Od /I "..\..\mzscheme\sgc" /I "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa" /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW" /D WX_NORMALIZED_PS_FONTS=1 /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNT" /YX"wx.h" /c
+CPP_PROJ=/nologo /MTd /W3 /Zi /Od /I "..\..\mzscheme\sgc" /I\
+ "..\..\wxwindow\include\base" /I "..\..\wxwindow\include\msw" /I\
+ ".\..\..\wxwindow\src\base" /I "..\..\wxwindow\src\msw" /I\
+ "..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib" /I "..\..\wxWindow\contrib\fafa"\
+ /D "_DEBUG" /D "WINNT" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "FOR_MSW"\
+ /D WX_NORMALIZED_PS_FONTS=1 /D "USE_SENORA_GC" /D "USE_WXOBJECT_TRACE_COUNT"\
+ /Fp"$(INTDIR)/wxwin.pch" /YX"wx.h" /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
+CPP_OBJS=SGC/
+CPP_SBRS=
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/wxwin.bsc" 
+BSC32_SBRS=
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/wxwin.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)/WB_DATA.obj" \
+	"$(INTDIR)/WB_STDEV.obj" \
+	"$(INTDIR)/WX_DC.obj" \
+	"$(INTDIR)/WX_FRAC.obj" \
+	"$(INTDIR)/WB_VLBOX.obj" \
+	"$(INTDIR)/WX_MEM.obj" \
+	"$(INTDIR)/WB_STAT.obj" \
+	"$(INTDIR)/WB_TYPES.obj" \
+	"$(INTDIR)/WX_MAIN.obj" \
+	"$(INTDIR)/WX_MESSG.obj" \
+	"$(INTDIR)/WB_RES.obj" \
+	"$(INTDIR)/WXSTRING.obj" \
+	"$(INTDIR)/WX_SLIDR.obj" \
+	"$(INTDIR)/WX_CMDLG.obj" \
+	"$(INTDIR)/WX_VLBOX.obj" \
+	"$(INTDIR)/WX_PANEL.obj" \
+	"$(INTDIR)/WB_OBJ.obj" \
+	"$(INTDIR)/WB_TIMER.obj" \
+	"$(INTDIR)/WX_DB.obj" \
+	"$(INTDIR)/WX_DOC.obj" \
+	"$(INTDIR)/WX_CHOIC.obj" \
+	"$(INTDIR)/WB_FRAME.obj" \
+	"$(INTDIR)/WX_ENHDG.obj" \
+	"$(INTDIR)/WB_PRINT.obj" \
+	"$(INTDIR)/WX_ITEM.obj" \
+	"$(INTDIR)/WX_LBOX.obj" \
+	"$(INTDIR)/WX_TXT.obj" \
+	"$(INTDIR)/WB_UTILS.obj" \
+	"$(INTDIR)/WX_DIALG.obj" \
+	"$(INTDIR)/WB_FORM.obj" \
+	"$(INTDIR)/WB_SCROL.obj" \
+	"$(INTDIR)/WB_LIST.obj" \
+	"$(INTDIR)/WB_CMDLG.obj" \
+	"$(INTDIR)/WB_TEXT.obj" \
+	"$(INTDIR)/WX_CANVS.obj" \
+	"$(INTDIR)/WB_PANEL.obj" \
+	"$(INTDIR)/WX_UTILS.obj" \
+	"$(INTDIR)/WX_TBAR.obj" \
+	"$(INTDIR)/WX_DATE.obj" \
+	"$(INTDIR)/WX_SCROL.obj" \
+	"$(INTDIR)/WX_MENU.obj" \
+	"$(INTDIR)/WB_HELP.obj" \
+	"$(INTDIR)/wx_pdf.obj" \
+	"$(INTDIR)/WX_BBAR.obj" \
+	"$(INTDIR)/WX_WIN.obj" \
+	"$(INTDIR)/WB_MAIN.obj" \
+	"$(INTDIR)/WB_MF.obj" \
+	"$(INTDIR)/WX_MTXT.obj" \
+	"$(INTDIR)/WX_IPC.obj" \
+	"$(INTDIR)/WX_RBOX.obj" \
+	"$(INTDIR)/WX_CHECK.obj" \
+	"$(INTDIR)/WX_CLIPB.obj" \
+	"$(INTDIR)/WB_DIALG.obj" \
+	"$(INTDIR)/WX_GDI.obj" \
+	"$(INTDIR)/WX_TIME.obj" \
+	"$(INTDIR)/WX_LAY.obj" \
+	"$(INTDIR)/WX_MF.obj" \
+	"$(INTDIR)/wximgfil.obj" \
+	"$(INTDIR)/WB_CANVS.obj" \
+	"$(INTDIR)/WB_WIN.obj" \
+	"$(INTDIR)/WB_MGSTR.obj" \
+	"$(INTDIR)/WB_DC.obj" \
+	"$(INTDIR)/WX_GAUGE.obj" \
+	"$(INTDIR)/WX_TIMER.obj" \
+	"$(INTDIR)/WB_IPC.obj" \
+	"$(INTDIR)/WB_SYSEV.obj" \
+	"$(INTDIR)/WX_TEXT.obj" \
+	"$(INTDIR)/WB_ITEM.obj" \
+	"$(INTDIR)/WB_GDI.obj" \
+	"$(INTDIR)/WX_GROUP.obj" \
+	"$(INTDIR)/WB_HASH.obj" \
+	"$(INTDIR)/WX_BUTTN.obj" \
+	"$(INTDIR)/WX_STAT.obj" \
+	"$(INTDIR)/WX_FRAME.obj" \
+	"$(INTDIR)/WB_PS.obj"
+
+"$(OUTDIR)\wxwin.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "wxwin - Win32 Release"
+# Name "wxwin - Win32 Debug"
+# Name "wxwin - Win32 SGC"
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_CMDLG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+
+"$(INTDIR)\WB_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WB_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+
+"$(INTDIR)\WB_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WB_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+
+"$(INTDIR)\WB_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WB_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_DATA.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_DATA.obj" : $(SOURCE) $(DEP_CPP_WB_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_DATA.obj" : $(SOURCE) $(DEP_CPP_WB_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_DATA.obj" : $(SOURCE) $(DEP_CPP_WB_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_DC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\Wxwindow\Src\Base\XFSPLINE.cxx"\
+	".\..\..\Wxwindow\Src\base\wxspline.cxx"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_DC.obj" : $(SOURCE) $(DEP_CPP_WB_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\Wxwindow\Src\Base\XFSPLINE.cxx"\
+	".\..\..\Wxwindow\Src\base\wxspline.cxx"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_DC.obj" : $(SOURCE) $(DEP_CPP_WB_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\Wxwindow\Src\Base\XFSPLINE.cxx"\
+	".\..\..\Wxwindow\Src\base\wxspline.cxx"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	
+
+"$(INTDIR)\WB_DC.obj" : $(SOURCE) $(DEP_CPP_WB_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_DIALG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	
+
+"$(INTDIR)\WB_DIALG.obj" : $(SOURCE) $(DEP_CPP_WB_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	
+
+"$(INTDIR)\WB_DIALG.obj" : $(SOURCE) $(DEP_CPP_WB_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	
+
+"$(INTDIR)\WB_DIALG.obj" : $(SOURCE) $(DEP_CPP_WB_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_FORM.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_FO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_form.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WB_FORM.obj" : $(SOURCE) $(DEP_CPP_WB_FO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_FO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_form.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WB_FORM.obj" : $(SOURCE) $(DEP_CPP_WB_FO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_FO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_form.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WB_FORM.obj" : $(SOURCE) $(DEP_CPP_WB_FO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_FRAME.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_FRAME.obj" : $(SOURCE) $(DEP_CPP_WB_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_FRAME.obj" : $(SOURCE) $(DEP_CPP_WB_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_FRAME.obj" : $(SOURCE) $(DEP_CPP_WB_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_GDI.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_GDI.obj" : $(SOURCE) $(DEP_CPP_WB_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_GDI.obj" : $(SOURCE) $(DEP_CPP_WB_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_GDI.obj" : $(SOURCE) $(DEP_CPP_WB_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_HASH.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_HA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\WB_HASH.obj" : $(SOURCE) $(DEP_CPP_WB_HA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_HA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WB_HASH.obj" : $(SOURCE) $(DEP_CPP_WB_HA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_HA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	
+
+"$(INTDIR)\WB_HASH.obj" : $(SOURCE) $(DEP_CPP_WB_HA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_HELP.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_HE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_help.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	
+
+"$(INTDIR)\WB_HELP.obj" : $(SOURCE) $(DEP_CPP_WB_HE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_HE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_help.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	
+
+"$(INTDIR)\WB_HELP.obj" : $(SOURCE) $(DEP_CPP_WB_HE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_HE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_help.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	
+
+"$(INTDIR)\WB_HELP.obj" : $(SOURCE) $(DEP_CPP_WB_HE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_IPC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	
+
+"$(INTDIR)\WB_IPC.obj" : $(SOURCE) $(DEP_CPP_WB_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	
+
+"$(INTDIR)\WB_IPC.obj" : $(SOURCE) $(DEP_CPP_WB_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	
+
+"$(INTDIR)\WB_IPC.obj" : $(SOURCE) $(DEP_CPP_WB_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_ITEM.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_ITEM.obj" : $(SOURCE) $(DEP_CPP_WB_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_ITEM.obj" : $(SOURCE) $(DEP_CPP_WB_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	
+
+"$(INTDIR)\WB_ITEM.obj" : $(SOURCE) $(DEP_CPP_WB_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_LIST.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_LI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WB_LIST.obj" : $(SOURCE) $(DEP_CPP_WB_LI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_LI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WB_LIST.obj" : $(SOURCE) $(DEP_CPP_WB_LI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_LI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	
+
+"$(INTDIR)\WB_LIST.obj" : $(SOURCE) $(DEP_CPP_WB_LI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_MAIN.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_MAIN.obj" : $(SOURCE) $(DEP_CPP_WB_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_MAIN.obj" : $(SOURCE) $(DEP_CPP_WB_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	
+
+"$(INTDIR)\WB_MAIN.obj" : $(SOURCE) $(DEP_CPP_WB_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_MF.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_MF.obj" : $(SOURCE) $(DEP_CPP_WB_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_MF.obj" : $(SOURCE) $(DEP_CPP_WB_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	
+
+"$(INTDIR)\WB_MF.obj" : $(SOURCE) $(DEP_CPP_WB_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_MGSTR.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_MG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WB_MGSTR.obj" : $(SOURCE) $(DEP_CPP_WB_MG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_MG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WB_MGSTR.obj" : $(SOURCE) $(DEP_CPP_WB_MG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_MG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	
+
+"$(INTDIR)\WB_MGSTR.obj" : $(SOURCE) $(DEP_CPP_WB_MG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_OBJ.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_OB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+"$(INTDIR)\WB_OBJ.obj" : $(SOURCE) $(DEP_CPP_WB_OB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_OB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	
+
+"$(INTDIR)\WB_OBJ.obj" : $(SOURCE) $(DEP_CPP_WB_OB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_OB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	
+
+"$(INTDIR)\WB_OBJ.obj" : $(SOURCE) $(DEP_CPP_WB_OB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_PANEL.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	
+
+"$(INTDIR)\WB_PANEL.obj" : $(SOURCE) $(DEP_CPP_WB_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	
+
+"$(INTDIR)\WB_PANEL.obj" : $(SOURCE) $(DEP_CPP_WB_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	
+
+"$(INTDIR)\WB_PANEL.obj" : $(SOURCE) $(DEP_CPP_WB_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_PRINT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_PR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	
+
+"$(INTDIR)\WB_PRINT.obj" : $(SOURCE) $(DEP_CPP_WB_PR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_PR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+
+"$(INTDIR)\WB_PRINT.obj" : $(SOURCE) $(DEP_CPP_WB_PR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_PR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\WB_PRINT.obj" : $(SOURCE) $(DEP_CPP_WB_PR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_PS.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_PS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	
+
+"$(INTDIR)\WB_PS.obj" : $(SOURCE) $(DEP_CPP_WB_PS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_PS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	
+
+"$(INTDIR)\WB_PS.obj" : $(SOURCE) $(DEP_CPP_WB_PS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_PS=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	
+
+"$(INTDIR)\WB_PS.obj" : $(SOURCE) $(DEP_CPP_WB_PS) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_RES.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_RE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_RES.obj" : $(SOURCE) $(DEP_CPP_WB_RE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_RE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_RES.obj" : $(SOURCE) $(DEP_CPP_WB_RE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_RE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_RES.obj" : $(SOURCE) $(DEP_CPP_WB_RE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_SCROL.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_SC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WB_SCROL.obj" : $(SOURCE) $(DEP_CPP_WB_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_SC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	
+
+"$(INTDIR)\WB_SCROL.obj" : $(SOURCE) $(DEP_CPP_WB_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_SC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WB_SCROL.obj" : $(SOURCE) $(DEP_CPP_WB_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_STAT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WB_STAT.obj" : $(SOURCE) $(DEP_CPP_WB_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WB_STAT.obj" : $(SOURCE) $(DEP_CPP_WB_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WB_STAT.obj" : $(SOURCE) $(DEP_CPP_WB_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_STDEV.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_STD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_STDEV.obj" : $(SOURCE) $(DEP_CPP_WB_STD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_STD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_STDEV.obj" : $(SOURCE) $(DEP_CPP_WB_STD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_STD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	
+
+"$(INTDIR)\WB_STDEV.obj" : $(SOURCE) $(DEP_CPP_WB_STD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_SYSEV.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_SY=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_SYSEV.obj" : $(SOURCE) $(DEP_CPP_WB_SY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_SY=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_SYSEV.obj" : $(SOURCE) $(DEP_CPP_WB_SY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_SY=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	
+
+"$(INTDIR)\WB_SYSEV.obj" : $(SOURCE) $(DEP_CPP_WB_SY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_TEXT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_TEXT.obj" : $(SOURCE) $(DEP_CPP_WB_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_TEXT.obj" : $(SOURCE) $(DEP_CPP_WB_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_TEXT.obj" : $(SOURCE) $(DEP_CPP_WB_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_TIMER.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\WB_TIMER.obj" : $(SOURCE) $(DEP_CPP_WB_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\WB_TIMER.obj" : $(SOURCE) $(DEP_CPP_WB_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\WB_TIMER.obj" : $(SOURCE) $(DEP_CPP_WB_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_TYPES.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_TY=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\WB_TYPES.obj" : $(SOURCE) $(DEP_CPP_WB_TY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_TY=\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WB_TYPES.obj" : $(SOURCE) $(DEP_CPP_WB_TY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_TY=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_TYPES.obj" : $(SOURCE) $(DEP_CPP_WB_TY) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_UTILS.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\Wxwindow\Src\Base\glob.inc"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_UTILS.obj" : $(SOURCE) $(DEP_CPP_WB_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\Wxwindow\Src\Base\glob.inc"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_UTILS.obj" : $(SOURCE) $(DEP_CPP_WB_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\Wxwindow\Src\Base\glob.inc"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	
+
+"$(INTDIR)\WB_UTILS.obj" : $(SOURCE) $(DEP_CPP_WB_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_VLBOX.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	
+
+"$(INTDIR)\WB_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WB_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	
+
+"$(INTDIR)\WB_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WB_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	
+
+"$(INTDIR)\WB_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WB_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_WIN.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_WIN.obj" : $(SOURCE) $(DEP_CPP_WB_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_WIN.obj" : $(SOURCE) $(DEP_CPP_WB_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WB_WIN.obj" : $(SOURCE) $(DEP_CPP_WB_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_BBAR.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_BB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_bbar.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_BBAR.obj" : $(SOURCE) $(DEP_CPP_WX_BB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_BB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_bbar.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_BBAR.obj" : $(SOURCE) $(DEP_CPP_WX_BB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_BB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_bbar.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_BBAR.obj" : $(SOURCE) $(DEP_CPP_WX_BB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_DATE.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_DATE.obj" : $(SOURCE) $(DEP_CPP_WX_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_DATE.obj" : $(SOURCE) $(DEP_CPP_WX_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_DA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_DATE.obj" : $(SOURCE) $(DEP_CPP_WX_DA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_DOC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_DO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_doc.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_DOC.obj" : $(SOURCE) $(DEP_CPP_WX_DO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_DO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_doc.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_DOC.obj" : $(SOURCE) $(DEP_CPP_WX_DO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_DO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_doc.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_print.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_DOC.obj" : $(SOURCE) $(DEP_CPP_WX_DO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_ENHDG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_EN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	
+
+"$(INTDIR)\WX_ENHDG.obj" : $(SOURCE) $(DEP_CPP_WX_EN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_EN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	
+
+"$(INTDIR)\WX_ENHDG.obj" : $(SOURCE) $(DEP_CPP_WX_EN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_EN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wx_enhdg.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	
+
+"$(INTDIR)\WX_ENHDG.obj" : $(SOURCE) $(DEP_CPP_WX_EN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_FRAC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_frac.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_FRAC.obj" : $(SOURCE) $(DEP_CPP_WX_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_frac.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_FRAC.obj" : $(SOURCE) $(DEP_CPP_WX_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_FR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_frac.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_FRAC.obj" : $(SOURCE) $(DEP_CPP_WX_FR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_LAY.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_LA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_LAY.obj" : $(SOURCE) $(DEP_CPP_WX_LA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_LA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_LAY.obj" : $(SOURCE) $(DEP_CPP_WX_LA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_LA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_LAY.obj" : $(SOURCE) $(DEP_CPP_WX_LA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_MEM.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MEM.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MEM.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_ME=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MEM.obj" : $(SOURCE) $(DEP_CPP_WX_ME) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_TBAR.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_TB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	
+
+"$(INTDIR)\WX_TBAR.obj" : $(SOURCE) $(DEP_CPP_WX_TB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_TB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_TBAR.obj" : $(SOURCE) $(DEP_CPP_WX_TB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_TB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_tbar.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\WX_TBAR.obj" : $(SOURCE) $(DEP_CPP_WX_TB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WX_TIME.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_time.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_TIME.obj" : $(SOURCE) $(DEP_CPP_WX_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_time.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_TIME.obj" : $(SOURCE) $(DEP_CPP_WX_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_TI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_time.h"\
+	".\..\..\wxwindow\include\base\wx_date.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	
+
+"$(INTDIR)\WX_TIME.obj" : $(SOURCE) $(DEP_CPP_WX_TI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WXSTRING.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	
+NODEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WXSTRING.obj" : $(SOURCE) $(DEP_CPP_WXSTR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	
+NODEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WXSTRING.obj" : $(SOURCE) $(DEP_CPP_WXSTR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	
+NODEP_CPP_WXSTR=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WXSTRING.obj" : $(SOURCE) $(DEP_CPP_WXSTR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Base\WB_CANVS.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WB_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	
+
+"$(INTDIR)\WB_CANVS.obj" : $(SOURCE) $(DEP_CPP_WB_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WB_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	
+
+"$(INTDIR)\WB_CANVS.obj" : $(SOURCE) $(DEP_CPP_WB_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WB_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	
+
+"$(INTDIR)\WB_CANVS.obj" : $(SOURCE) $(DEP_CPP_WB_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_WIN.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_WIN.obj" : $(SOURCE) $(DEP_CPP_WX_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_WIN.obj" : $(SOURCE) $(DEP_CPP_WX_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_WI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_WIN.obj" : $(SOURCE) $(DEP_CPP_WX_WI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_CANVS.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_CANVS.obj" : $(SOURCE) $(DEP_CPP_WX_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_CANVS.obj" : $(SOURCE) $(DEP_CPP_WX_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_CA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\WX_CANVS.obj" : $(SOURCE) $(DEP_CPP_WX_CA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_CHECK.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_CH=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_CHECK.obj" : $(SOURCE) $(DEP_CPP_WX_CH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_CH=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_CHECK.obj" : $(SOURCE) $(DEP_CPP_WX_CH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_CH=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_CHECK.obj" : $(SOURCE) $(DEP_CPP_WX_CH) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_CHOIC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_CHO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	
+
+"$(INTDIR)\WX_CHOIC.obj" : $(SOURCE) $(DEP_CPP_WX_CHO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_CHO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	
+
+"$(INTDIR)\WX_CHOIC.obj" : $(SOURCE) $(DEP_CPP_WX_CHO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_CHO=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	
+
+"$(INTDIR)\WX_CHOIC.obj" : $(SOURCE) $(DEP_CPP_WX_CHO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_CLIPB.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_CL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_CLIPB.obj" : $(SOURCE) $(DEP_CPP_WX_CL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_CL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_CLIPB.obj" : $(SOURCE) $(DEP_CPP_WX_CL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_CL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_CLIPB.obj" : $(SOURCE) $(DEP_CPP_WX_CL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_CMDLG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WX_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WX_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_CM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_CMDLG.obj" : $(SOURCE) $(DEP_CPP_WX_CM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_DB.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_db.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+NODEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WX_DB.obj" : $(SOURCE) $(DEP_CPP_WX_DB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_db.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	
+NODEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WX_DB.obj" : $(SOURCE) $(DEP_CPP_WX_DB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wxstring.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_db.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxregex.h"\
+	".\..\..\wxwindow\include\base\..\\..\\contrib\\wxstring\\wxstrgnu.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	
+NODEP_CPP_WX_DB=\
+	".\..\..\wxwindow\include\base\wxregex.h"\
+	
+
+"$(INTDIR)\WX_DB.obj" : $(SOURCE) $(DEP_CPP_WX_DB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_DC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DC.obj" : $(SOURCE) $(DEP_CPP_WX_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DC.obj" : $(SOURCE) $(DEP_CPP_WX_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_DC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DC.obj" : $(SOURCE) $(DEP_CPP_WX_DC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_DIALG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DIALG.obj" : $(SOURCE) $(DEP_CPP_WX_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DIALG.obj" : $(SOURCE) $(DEP_CPP_WX_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_DI=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_DIALG.obj" : $(SOURCE) $(DEP_CPP_WX_DI) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_FRAME.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_FRA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_FRAME.obj" : $(SOURCE) $(DEP_CPP_WX_FRA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_FRA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_FRAME.obj" : $(SOURCE) $(DEP_CPP_WX_FRA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_FRA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\itsybits\itsybits.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_FRAME.obj" : $(SOURCE) $(DEP_CPP_WX_FRA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_GAUGE.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_GA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GAUGE.obj" : $(SOURCE) $(DEP_CPP_WX_GA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_GA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GAUGE.obj" : $(SOURCE) $(DEP_CPP_WX_GA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_GA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GAUGE.obj" : $(SOURCE) $(DEP_CPP_WX_GA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_GDI.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\msw\wximgxbm.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+"$(INTDIR)\WX_GDI.obj" : $(SOURCE) $(DEP_CPP_WX_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\msw\wximgxbm.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+"$(INTDIR)\WX_GDI.obj" : $(SOURCE) $(DEP_CPP_WX_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_GD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\..\..\utils\dib\dib.h"\
+	".\..\..\wxwindow\contrib\wxxpm\libxpm.34b\lib\xpm34.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\msw\wximgxbm.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\Wxwindow\Contrib\Wxxpm\Libxpm.34b\Lib\simx.h"\
+	
+
+"$(INTDIR)\WX_GDI.obj" : $(SOURCE) $(DEP_CPP_WX_GD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_GROUP.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_GR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GROUP.obj" : $(SOURCE) $(DEP_CPP_WX_GR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_GR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GROUP.obj" : $(SOURCE) $(DEP_CPP_WX_GR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_GR=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_GROUP.obj" : $(SOURCE) $(DEP_CPP_WX_GR) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_IPC.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_IPC.obj" : $(SOURCE) $(DEP_CPP_WX_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_IPC.obj" : $(SOURCE) $(DEP_CPP_WX_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_IP=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_ipc.h"\
+	".\..\..\wxwindow\include\msw\wx_ipcob.h"\
+	".\..\..\wxwindow\include\base\wb_ipcob.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_IPC.obj" : $(SOURCE) $(DEP_CPP_WX_IP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_ITEM.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	
+
+"$(INTDIR)\WX_ITEM.obj" : $(SOURCE) $(DEP_CPP_WX_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	
+
+"$(INTDIR)\WX_ITEM.obj" : $(SOURCE) $(DEP_CPP_WX_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_IT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	
+
+"$(INTDIR)\WX_ITEM.obj" : $(SOURCE) $(DEP_CPP_WX_IT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_LBOX.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_LB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_LBOX.obj" : $(SOURCE) $(DEP_CPP_WX_LB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_LB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+NODEP_CPP_WX_LB=\
+	".\..\..\wxwindow\include\base\wx_priv.h"\
+	
+
+"$(INTDIR)\WX_LBOX.obj" : $(SOURCE) $(DEP_CPP_WX_LB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_LB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_LBOX.obj" : $(SOURCE) $(DEP_CPP_WX_LB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_MAIN.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_MAIN.obj" : $(SOURCE) $(DEP_CPP_WX_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_MAIN.obj" : $(SOURCE) $(DEP_CPP_WX_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_MA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxwindow\include\base\..\..\contrib\gauge\zyzgauge.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	
+
+"$(INTDIR)\WX_MAIN.obj" : $(SOURCE) $(DEP_CPP_WX_MA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_MENU.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MENU.obj" : $(SOURCE) $(DEP_CPP_WX_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MENU.obj" : $(SOURCE) $(DEP_CPP_WX_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_MEN=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MENU.obj" : $(SOURCE) $(DEP_CPP_WX_MEN) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_MESSG.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_MES=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MESSG.obj" : $(SOURCE) $(DEP_CPP_WX_MES) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_MES=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MESSG.obj" : $(SOURCE) $(DEP_CPP_WX_MES) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_MES=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MESSG.obj" : $(SOURCE) $(DEP_CPP_WX_MES) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_MF.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MF.obj" : $(SOURCE) $(DEP_CPP_WX_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MF.obj" : $(SOURCE) $(DEP_CPP_WX_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_MF=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_mf.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_mf.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_MF.obj" : $(SOURCE) $(DEP_CPP_WX_MF) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_MTXT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_MT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MTXT.obj" : $(SOURCE) $(DEP_CPP_WX_MT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_MT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MTXT.obj" : $(SOURCE) $(DEP_CPP_WX_MT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_MT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_MTXT.obj" : $(SOURCE) $(DEP_CPP_WX_MT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_PANEL.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	
+
+"$(INTDIR)\WX_PANEL.obj" : $(SOURCE) $(DEP_CPP_WX_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	
+
+"$(INTDIR)\WX_PANEL.obj" : $(SOURCE) $(DEP_CPP_WX_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_PA=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	
+
+"$(INTDIR)\WX_PANEL.obj" : $(SOURCE) $(DEP_CPP_WX_PA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_RBOX.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_RB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_RBOX.obj" : $(SOURCE) $(DEP_CPP_WX_RB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_RB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_RBOX.obj" : $(SOURCE) $(DEP_CPP_WX_RB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_RB=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_RBOX.obj" : $(SOURCE) $(DEP_CPP_WX_RB) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_SCROL.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_SC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SCROL.obj" : $(SOURCE) $(DEP_CPP_WX_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_SC=\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SCROL.obj" : $(SOURCE) $(DEP_CPP_WX_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_SC=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SCROL.obj" : $(SOURCE) $(DEP_CPP_WX_SC) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_SLIDR.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_SL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SLIDR.obj" : $(SOURCE) $(DEP_CPP_WX_SL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_SL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SLIDR.obj" : $(SOURCE) $(DEP_CPP_WX_SL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_SL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_SLIDR.obj" : $(SOURCE) $(DEP_CPP_WX_SL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_STAT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WX_STAT.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WX_STAT.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_ST=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_stat.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WX_STAT.obj" : $(SOURCE) $(DEP_CPP_WX_ST) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_TEXT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WX_TEXT.obj" : $(SOURCE) $(DEP_CPP_WX_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_TEXT.obj" : $(SOURCE) $(DEP_CPP_WX_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_TE=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_clipb.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\STAT.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	
+
+"$(INTDIR)\WX_TEXT.obj" : $(SOURCE) $(DEP_CPP_WX_TE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_TIMER.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_TIM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_TIMER.obj" : $(SOURCE) $(DEP_CPP_WX_TIM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_TIM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_TIMER.obj" : $(SOURCE) $(DEP_CPP_WX_TIM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_TIM=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	{$(INCLUDE)}"\sys\TYPES.H"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	
+
+"$(INTDIR)\WX_TIMER.obj" : $(SOURCE) $(DEP_CPP_WX_TIM) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_TXT.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_TX=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_TXT.obj" : $(SOURCE) $(DEP_CPP_WX_TX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_TX=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_TXT.obj" : $(SOURCE) $(DEP_CPP_WX_TX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_TX=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_TXT.obj" : $(SOURCE) $(DEP_CPP_WX_TX) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_UTILS.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_UTILS.obj" : $(SOURCE) $(DEP_CPP_WX_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_UTILS.obj" : $(SOURCE) $(DEP_CPP_WX_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_UT=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	
+
+"$(INTDIR)\WX_UTILS.obj" : $(SOURCE) $(DEP_CPP_WX_UT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_VLBOX.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	
+
+"$(INTDIR)\WX_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WX_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	
+
+"$(INTDIR)\WX_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WX_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_VL=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_vlbox.h"\
+	".\..\..\wxwindow\include\msw\wx_scrol.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_vlbox.h"\
+	".\..\..\wxwindow\include\base\wb_scrol.h"\
+	
+
+"$(INTDIR)\WX_VLBOX.obj" : $(SOURCE) $(DEP_CPP_WX_VL) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\WX_BUTTN.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_BU=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_BUTTN.obj" : $(SOURCE) $(DEP_CPP_WX_BU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_BU=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_BUTTN.obj" : $(SOURCE) $(DEP_CPP_WX_BU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_BU=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	
+
+"$(INTDIR)\WX_BUTTN.obj" : $(SOURCE) $(DEP_CPP_WX_BU) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\Wxwindow\Src\Msw\wx_pdf.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WX_PD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\wx_pdf.obj" : $(SOURCE) $(DEP_CPP_WX_PD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WX_PD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\wx_pdf.obj" : $(SOURCE) $(DEP_CPP_WX_PD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WX_PD=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_pdf.h"\
+	".\..\..\wxwindow\include\msw\wx_timer.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_timer.h"\
+	{$(INCLUDE)}"\sys\TIMEB.H"\
+	
+
+"$(INTDIR)\wx_pdf.obj" : $(SOURCE) $(DEP_CPP_WX_PD) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=..\..\WXWINDOW\SRC\MSW\wximgfil.cxx
+
+!IF  "$(CFG)" == "wxwin - Win32 Release"
+
+DEP_CPP_WXIMG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\wximgfil.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 Debug"
+
+DEP_CPP_WXIMG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wx_dcps.h"\
+	".\..\..\wxwindow\include\msw\wx_panel.h"\
+	".\..\..\wxwindow\include\msw\wx_dcpan.h"\
+	".\..\..\wxwindow\include\msw\wx_buttn.h"\
+	".\..\..\wxwindow\include\msw\wx_check.h"\
+	".\..\..\wxwindow\include\msw\wx_choic.h"\
+	".\..\..\wxwindow\include\msw\wx_messg.h"\
+	".\..\..\wxwindow\include\msw\wx_lbox.h"\
+	".\..\..\wxwindow\include\msw\wx_rbox.h"\
+	".\..\..\wxwindow\include\msw\wx_txt.h"\
+	".\..\..\wxwindow\include\msw\wx_mtxt.h"\
+	".\..\..\wxwindow\include\msw\wx_slidr.h"\
+	".\..\..\wxwindow\include\msw\wx_group.h"\
+	".\..\..\wxwindow\include\msw\wx_gauge.h"\
+	".\..\..\wxwindow\include\msw\wx_menu.h"\
+	".\..\..\wxwindow\include\msw\wx_text.h"\
+	".\..\..\wxwindow\include\msw\wx_main.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\wxwindow\include\msw\wx_dialg.h"\
+	".\..\..\wxwindow\include\base\wx_utils.h"\
+	".\..\..\wxwindow\include\msw\wx_cmdlg.h"\
+	".\..\..\wxwindow\include\base\wx_res.h"\
+	".\..\..\wxwindow\include\base\wx_lay.h"\
+	".\..\..\wxwindow\include\msw\wx_wmgr.h"\
+	".\..\..\wxwindow\include\msw\wx_privt.h"\
+	".\..\..\wxwindow\include\msw\wx_itemp.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_panel.h"\
+	".\..\..\wxwindow\include\base\wb_dcpan.h"\
+	".\..\..\wxwindow\include\base\wb_buttn.h"\
+	".\..\..\wxwindow\include\base\wb_check.h"\
+	".\..\..\wxwindow\include\base\wb_choic.h"\
+	".\..\..\wxwindow\include\base\wb_messg.h"\
+	".\..\..\wxwindow\include\base\wb_lbox.h"\
+	".\..\..\wxwindow\include\base\wb_rbox.h"\
+	".\..\..\wxwindow\include\base\wb_txt.h"\
+	".\..\..\wxwindow\include\base\wb_mtxt.h"\
+	".\..\..\wxwindow\include\base\wb_slidr.h"\
+	".\..\..\wxwindow\include\base\wb_group.h"\
+	".\..\..\wxwindow\include\base\wb_gauge.h"\
+	".\..\..\wxwindow\include\base\wb_menu.h"\
+	".\..\..\wxwindow\include\base\wb_text.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_mgstr.h"\
+	".\..\..\wxwindow\include\base\wb_main.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\msw\wx_item.h"\
+	".\..\..\wxwindow\include\base\wb_dialg.h"\
+	".\..\..\wxwindow\include\base\wb_cmdlg.h"\
+	".\..\..\wxWindow\contrib\fafa\fafa.h"\
+	".\..\..\wxWindow\contrib\fafa\fafapriv.h"\
+	".\..\..\wxwindow\include\msw\wx_mnuit.h"\
+	".\..\..\mzscheme\gc\gc_cpp.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wb_item.h"\
+	".\..\..\wxwindow\include\base\wb_mnuit.h"\
+	".\..\..\mzscheme\gc\gc.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	
+
+"$(INTDIR)\wximgfil.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ELSEIF  "$(CFG)" == "wxwin - Win32 SGC"
+
+DEP_CPP_WXIMG=\
+	".\..\..\wxwindow\include\base\wx.h"\
+	".\..\..\wxwindow\include\msw\wx_gdi.h"\
+	".\..\..\wxwindow\include\msw\wx_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dc.h"\
+	".\..\..\wxwindow\include\msw\wx_dcmem.h"\
+	".\..\..\wxwindow\include\msw\wximgfil.h"\
+	".\..\..\wxwindow\include\base\wx_setup.h"\
+	".\..\..\wxwindow\include\base\common.h"\
+	".\..\..\wxwindow\include\base\wx_mem.h"\
+	".\..\..\wxwindow\include\msw\wx_win.h"\
+	".\..\..\wxwindow\include\msw\wx_frame.h"\
+	".\..\..\wxwindow\include\base\wx_ver.h"\
+	".\..\..\wxwindow\include\base\wb_win.h"\
+	".\..\..\wxwindow\include\base\wx_obj.h"\
+	".\..\..\wxwindow\include\base\wx_stdev.h"\
+	".\..\..\wxwindow\include\base\wx_list.h"\
+	".\..\..\mzscheme\sgc\gc_cpp.h"\
+	".\..\..\mzscheme\sgc\sgc.h"\
+	".\..\..\wxwindow\include\base\wx_sysev.h"\
+	".\..\..\wxwindow\include\base\wx_types.h"\
+	".\..\..\wxwindow\include\base\wx_hash.h"\
+	".\..\..\wxwindow\include\base\wb_frame.h"\
+	".\..\..\wxwindow\include\base\wb_gdi.h"\
+	".\..\..\wxwindow\include\base\wb_canvs.h"\
+	".\..\..\wxwindow\include\msw\wx_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dccan.h"\
+	".\..\..\wxwindow\include\base\wb_dc.h"\
+	".\..\..\wxwindow\include\base\wb_dcmem.h"\
+	
+
+"$(INTDIR)\wximgfil.obj" : $(SOURCE) $(DEP_CPP_WXIMG) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/src/worksp/wxwin/wxwin.mdp b/src/worksp/wxwin/wxwin.mdp
new file mode 100755
index 0000000..71f0989
Binary files /dev/null and b/src/worksp/wxwin/wxwin.mdp differ
diff --git a/src/wxmac/README.TXT b/src/wxmac/README.TXT
new file mode 100644
index 0000000..55b71be
--- /dev/null
+++ b/src/wxmac/README.TXT
@@ -0,0 +1,21 @@
+README.TXT
+
+This is the 'alpha-5' release of wxMac161d. Many things have changed since 'a4' so 
+please read the status documents and various README's.
+
+Incompatibilities for existing wxMac Applications:
+   1. Your Canvas method Paint() must be changed to OnPaint().
+   2. Any calls on GetLabel return a ptr to a static global buffer instead of the
+      previous method of a new string. Your code may have to change. I believe
+	  this is the standard wxWindows method.
+   3. wxText::GetValue also returns in the static global buffer.
+
+New features
+   1. wxDirecorySelector().
+   2. all patches to 'a4' releases  - far too many to list here.
+   3. Fixed many memory leaks.
+   4. A New directory 'Porting', contains many notes and all the wxMac
+      documentation.
+	  
+Good Luck
+Cecil Coupe - ccoupe@simplot.com
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/changes b/src/wxmac/contrib/wxxpm/libxpm.34b/changes
new file mode 100644
index 0000000..1cd0e9a
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/changes
@@ -0,0 +1,704 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/**************************************************************************\
+* 									   *
+*  			HISTORY of user-visible changes			   *
+* 									   *
+\**************************************************************************/
+
+3.4b	(94/05/24)
+
+    ENHANCEMENTS:
+	- XPM can now be built under MS Windows. Yes, this is possible and this
+	  entirely comes from:
+		- Hermann Dunkel <hedu@cul-ipn.uni-kiel.de>
+	  See the README.MSW file for details.
+
+	- building the shared library now depends on the SharedLibXpm variable
+	  and no longer on the SharedLibX variable which is private to the X
+	  Window System project.
+		- patch from Stephen Gildea <gildea@x.org>
+	  Other variables can now be set for the various locations needed.
+
+	- lib/parse.c does no longer use a 256x256 array in the stack but
+	  malloc it instead.
+
+	- The Copyright notice which has been re-written from the X11R6's one
+	  should be clearer and is now present in every file.
+
+    BUGS CORRECTED:
+	- lib/xpmP.h does no longer define a Boolean type which conflicts with
+	  the Intrinsic definition. Instead the type Bool defined in Xlib is
+	  used.
+		- neumann@watson.ibm.com (Gustaf Neumann)
+
+3.4a	(94/03/29)
+
+    BUGS CORRECTED:
+	- passing NULL as shapemask_return to XpmReadFileToPixmap and similar
+	  functions was leading to a bus error.
+		- Dean Luick <dean@falcon.natinst.com>
+
+3.4	(94/03/14)
+
+    IMPORTANT NOTE:
+	This version is not compatible with 3.3. Fortunately most people should
+	only need to recompile.
+	I apology for this but CDE/Motif have put heavy pressure to go that
+	way. The point is that I designed and released Xpm 3.3 in order to let
+	OSF include a clean version of Xpm in Motif 2.0. This new version was
+	not fully compatible with 3.2 but I thought it didn't matter since this
+	was going to be the first version used within Motif. Unfortunately CDE
+	was already using xpm-3.2 internally and requires both source and
+	binary backward compatibility. By the way I must say they didn't drop
+	us a single line to let us know they were using it and thus were
+	expecting stability. All this could have been avoided...
+
+	However, since I had to go for a not compatible version I took this as
+	an opportunity to modify the lower level API, which was new in 3.3 and
+	which was somewhat clumsy, in order to provide yet a better API.
+
+	The library has been modified to have both source and binary backward
+	compatibility with xpm-3.2. This implies it is not either source or
+	binary compatible with 3.3. The fields related to the 3.2 XpmInfos
+	mechanism have been put back into the XpmAttributes structure. The new
+	3.3 XpmInfos struct has been renamed as XpmInfo to avoid conflict with
+	the old 3.2 flag which is back too. All the semantic related to the
+	XpmAttributes infos fields is back as well.
+
+	So this new version provides a high level API which is fully
+	compatible with 3.2 and still provides the 3.3 lower level API
+	(XpmImage) with the XpmInfos struct renamed as XpmInfo. This leads to
+	some redundancy but this was the best I could do to satisfy both
+	CDE/Motif people who needed the backward compatibility and myself (who
+	always tries to provide you with the best ;-).
+
+	Tests have been successfully performed with pixmap-2.1, pixmap-2.4, and
+	sxpm.
+
+    ENHANCEMENTS:
+	- The colorTable member of the XpmAttributes structure is now an
+	  (XpmColor*) in order to be compatible with an XpmImage colorTable.
+	  However in order to be backward compatible this field is cast to
+	  (XpmColor **), which is equivalent to (char ***), when it is used
+	  with the old flags XpmInfos and XpmReturnInfos. To handle the new
+	  type the new flags XpmColorTable and XpmReturnColorTable have been
+	  defined.
+	- The XpmInfo struct has been extended to avoid having to deal with an
+	  XpmAttributes at the lower level. The idea is that all the data
+	  stored in an Xpm file can be retreive through both an XpmImage and
+	  an XpmInfo struct. See the documentation for details.
+	- XpmUndefPixel is defined and exported by xpm.h in order to let
+	  clients providing their own colorTable when writting out an Xpm file.
+	  See the documentation for details.
+	- in sxpm/sxpm.c, set attribute XtNinput to True on toplevel widget.
+	  Windows that don't "take" input, never get focus, as mandated by
+	  the ICCM.
+        	patch from Henrique Martins <martins@hplhasm.hpl.hp.com>
+	- lib/Imakefile modified to build the shared library under IRIX 5.
+                patch from simon@lia.di.epfl.ch (Simon Leinen)
+
+    NEW FEATURES:
+	- a new funtion and a new define should help client figuring out with
+	  which Xpm library version they are working. These are
+	  XpmIncludeVersion and XpmLibraryVersion().
+
+3.3	(93/12/20)
+
+    NEW FEATURES:
+	- XPM1 files are now supported.
+	- a new function is provided to get an error string related to the
+	  returned error code.
+		- suggested by Detlef Schmier <detlef@mfr.dec.com>
+
+    ENHANCEMENTS:
+	- gzip and gunzip are called with the -q option (quiet)
+		- patch from Chris P. Ross <cross@eng.umd.edu>
+	- the parser is again more flexible about the way the strings are
+	  distributed on lines. Actually a single line XPM file can be read.
+	- the documentation should be clearer about shapemask generation and
+	  XpmAttributes valuemask.
+
+    BUGS CORRECTED:
+	- reading some binary file was leading to a bus error.
+		- patch from Detlef Schmier <detlef@mfr.dec.com>
+	- the ? character is no longer used when writting an XPM file in order
+	  to avoid possible ANSI trigraphs.
+
+3.3alpha (93/08/13)
+
+    NEW FEATURES:
+	- a new level interface is provided to allow applications to do either
+	  icon editing or data caching.
+	  The XpmAttributes has been changed but most applications will just
+	  need to be recompiled.
+	- new structures are provided to deal with the new lower level:
+		 XpmImage, XpmColor, XpmInfos.
+
+	- a separate distribution called xpm-contrib is available. This
+	  includes the converters which used to be part of this distribution
+	  plus:
+		two new appplications:
+		* nexpm to draw a pixmap in *any* existing window from
+			 Ralph Betza <gnohmon@ssiny.com>
+		* xpmview to display a list of Xpm files from
+			 Jean Michel Leon <leon@sophia.inria.fr>
+
+		a hacky string to pixmap converter, provided by
+			Robert H. Forsman Jr.  <thoth@manatee.cis.ufl.edu>
+
+		The Xpm editor called pixmap will also be part of this contrib.
+		This does not mean it is the best pixmap editor one can find
+		but it is the only one that I know of which tries to handle
+		all the features of this format.
+
+    ENHANCEMENTS:
+	- the code to build XImage data has been optimized by
+		 jules@x.co.uk (Julian Gosnell)
+	  the old code is still available when compiling with the
+	  -DWITHOUT_SPEEDUPS flag.
+
+	- closecolor code was not re-entrant
+		 - dbl@visual.com (David B. Lewis)
+	- fix gzip filename (*.gz and no longer *.z).
+		 - Jason Patterson <jasonp@fitmail.fit.qut.edu.au>
+	- sxpm has 2 new options:
+		 -nom to do not display the mask if there is one
+		 -cp <color> <pixel> to override a color value with a given
+		 pixel, i.e. sxpm plaid.xpm -cp red 4
+
+	  also the '-s' adn '-p' options have been renamed to '-sc' and '-sp'.
+
+	- xpm.h defines XpmFormat, XpmVersion, and XpmRevision numbers.
+
+    BUGS CORRECTED:
+	- closecolor minor fix
+		 - Jason Patterson <jasonp@fitmail.fit.qut.edu.au>
+
+3.2g	(93/04/26)
+
+    ENHANCEMENTS:
+	- much faster close colors
+	- piping from/to compressed files now handles GNU's gzip (.z)  format
+	- added XpmColorKey attribute - ability to specify which visual's
+	  colors to use (ie: now it's possible to read in a pixmap in a
+	  color visual, but use the colors specified for monochrome).
+	- added -mono, -grey4, -grey and -color options to sxpm to demonstrate
+	  the XpmColorKey attribute.
+		- Jason Patterson <jasonp@fitmail.qut.edu.au>
+
+    BUGS CORRECTED:
+	- fixed bug where redefining "None" as a pixel stopped mask generation
+	- minor SVR4 defines for <string.h>
+	- fixed annoying closecolor bug related to read/write color cells
+	- fixed minor bug in color value -> pixel overloading
+	- manual updated to include new red/green/blue closeness attributes
+		- Jason Patterson <jasonp@fitmail.qut.edu.au>
+
+	- the top Imakefile was missing the depend target
+	- sxpm/Imakefile fixed so that -L../lib is set before the standard
+	  library location.
+		- Vivek Khera <khera@cs.duke.edu>
+
+	- lib/xpmP.h now defines bcopy as memcpy for VMS (required by recent
+	  versions of VMS)
+		- J. Daniel Smith <dsmith@ann-arbor.applicon.slb.com>
+
+	- the lib/Imakefile didn't work with X11R4.
+
+
+3.2f		(93/03/17)
+
+    NEW FEATURES:
+	- the library provides four new functions to deal with Xpm files
+	  loaded in memory as single character strings buffers:
+
+			XpmCreateImageFromBuffer
+			XpmCreatePixmapFromBuffer
+			XpmCreateBufferFromImage
+			XpmCreateBufferFromPixmap
+
+	- in addition, as a convenience, two functions are provided to copy a
+	  file in a buffer and to write a file from a buffer:
+
+			XpmReadFileToBuffer
+			XpmWriteFileFromBuffer
+
+    ENHANCEMENTS:
+	- Files are now dispatched in the following sub-directories:
+	  lib, sxpm, and doc.
+	- Imakefiles will let you build a shared library as well as the static
+	  one (with either X11R4 or X11R5).
+	- The documentation has been ported from LaTeX to FrameMaker and is
+	  now included in the distribution in its PostScript form (doc/xpm.ps).
+	  Source files are available on request.
+	  Also the documentation has been reoreganized and includes a table of
+	  contents and an index of the functions (the number of functions
+	  increasing this became a requisite).
+
+    BUGS CORRECTED:
+	- Many warnings have been fixed - patch from Daniel Dardailler 
+	  daniel@osf.org
+
+3.2e		(93/02/05)
+
+    ENHANCEMENTS:
+	- use XpmMalloc, XpmRealloc, XpmCalloc, and XpmFree which are defines
+	in xpmP.h. This should help people wanting to use their own functions.
+
+    BUGS CORRECTED:
+	- Intrinsic.h is no longer included.
+	- bzero is defined as memset on SYSV and SVR4.
+	- some memory initialisation bug concerning XpmAttributes.
+
+3.2d		(93/01/27)
+
+    ENHANCEMENTS:
+    	- compile on Solaris 2.0
+		- patch from Clint Jeffery <cjeffery@cs.arizona.edu>
+
+    BUGS CORRECTED:
+	- shape masks are now set correctly for LSBFirst (Decs).
+	- pixmaps are now set correctly for 2 bit displays (Nexts).
+		- patch from Josef Leherbauer <joe@takeFive.co.at>
+	- isspace was called on getc which fails when EOF is returned.
+		- Marelli Paolo <marelli@colos3.usr.dsi.unimi.it>
+
+3.2c		(92/12/29)
+
+    ENHANCEMENTS:
+    	- parsing optimized for single and double characters color
+		- patch originally from Martin Brunecky 
+				       marbru@build1.auto-trol.com
+
+    BUGS CORRECTED:
+	- XpmFreeExtensions was calling free on some argument without checking
+	it was not NULL.
+	- strdup was not correctly defined for systems which do not provide
+	it.	- Hans-Peter Lichtin <lich@zellweger.ch>
+	- some bug in XpmCrDataFI.c
+	        - Sven Delmas garfield@avalanche.cs.tu-berlin.de
+
+    NOTE:
+    	- there is still a bug with the creation of the clipmask on display of
+	depth 2 but I can't find a fix because unfortunately I don't have such
+	a rendering system and nobody gets the time to investigate for me.
+
+3.2b		(92/10/19)
+
+    ENHANCEMENTS:
+	- Create XpmReadFileToData and XpmWriteFileFromData
+		- Dan Greening <dgreen@sti.com>
+    	- added "close colors" support and ability to redefine color values
+	  as pixels at load time, as well as color names
+		- Jason Patterson <jasonp@fitmail.qut.edu.au>
+	- errors while parsing or allocating colors now revert to other
+	  visual defaults, creating pixmap/image as expected, and returning
+	  XpmSuccess. The old behaviour of XpmColorError being returned and no
+	  pixmap/image being created can be retained by setting the
+	  exactColors attribute.
+		- Jason Patterson <jasonp@fitmail.qut.edu.au>
+
+    BUGS CORRECTED:
+	- SVR4 defines for including <string.h> instead of <strings.h>
+		- Jason Patterson <jasonp@fitmail.qut.edu.au>
+	- attributes->extensions and attributes->nextensions fields were not 
+	  set correctly when no extensions present in file.
+		- Simon_Scott Cornish <cornish@ecr.mu.oz.au>
+
+3.2a		(92/08/17)
+
+    ENHANCEMENTS:
+    	- use the mock lisp hashing function instead of the gnu emacs one,
+	it is faster in some cases and never slower (I've not found any case).
+
+    BUGS CORRECTED:
+	- function prototypes for ansi compilers.
+	- some memory initialization bugs (purify is just great for this).
+	- empty strings in extensions are now correctly handled.
+
+3.2		(92/07/06)
+
+    NEW FEATURES:
+	- both format and functions handle extensions data. This allow people
+	to store additional data related to a pixmap. See documentation for
+	detail.
+	- sxpm supports the new option '-c' to use a private colormap. This is
+	useful when displaying pixmaps using a lot of colors.
+	- sxpm supports the new option '-v' (verbose) to get possible
+	extensions print out on standard error.
+
+    ENHANCEMENTS:
+    	- most of the code has been reworked to be improved and thus almost
+	every function is faster. It takes less than 6 seconds of real time on
+	a sun4 to display, with sxpm, a 487x635 pixmap using 213 colors, while
+	it takes 32 seconds with the old library! It takes 18 seconds to
+	display a 1279x1023 screen dump using 14 colors while xwud takes 10
+	seconds.
+	Of course performance improvements are not always that great, they
+	depend on the size and number of colors but I'm sure everybody will
+	appreciate ;-)
+	I know how to improve it more but this will require changes in the
+	architecture so this is not for now. Some optimizations have been
+	contributed by gregor@kafka.saic.com (gregg hanna) and
+	jnc@csl.biosci.arizona.edu (John N. Calley).
+	- the Imakefile is modified to let you install sxpm - Rainer Klute
+           <klute@irb.informatik.uni-dortmund.de>
+	- xpmP.h declares popen for Sequent platforms - Clinton Jeffery
+	   <cjeffery@cs.arizona.edu>
+	- XpmWriteFileFromImage/Pixmap rather than truncating the pixmap name
+	to the first dot changes dots to underscores to get a valid C syntax
+	name.
+
+
+    BUGS CORRECTED:
+	- there was a bug in the image creation function for some 24 bits
+	displays. It is fixed.
+	- allocated color pixels are now freed when an error occurs -
+	   nusser@dec1.wu-wien.ac.at (Stefan Nusser)
+
+    CHANGES TO THE DOC:
+	- the documentation describes the new XpmExtension structure and how
+	to use it with read and write functions.
+
+3.1		(92/02/03)
+
+    ENHANCEMENTS:
+    	- sxpm now have more standard options (mainly suggested by 
+	Rainer Sinkwitz <sinkwitz@ifi.unizh.ch>):
+
+	Usage:  sxpm [options...]
+	Where options are:
+
+	[-d host:display]            Display to connect to.
+	[-g geom]                    Geometry of window.
+	[-hints]                     Set ResizeInc for window.
+	[-icon filename]             Set pixmap for iconWindow.
+	[-s symbol_name color_name]  Overwrite color defaults.
+	[-p symbol_name pixel_value] Overwrite color defaults.
+	[-plaid]                     Read the included plaid pixmap.
+	[filename]                   Read from file 'filename', and from
+				     standard input if 'filename' is '-'.
+	[-o filename]                Write to file 'filename', and to standard
+				     output if 'filename' is '-'.
+	[-nod]                       Don't display in window.
+	[-rgb filename]              Search color names in the rgb text file
+				     'filename'.
+
+	if no input is specified sxpm reads from stdandard input.
+
+
+	- Xpm functions and Ppm converters now deal with multiword colornames.
+	  patches from Rainer Sinkwitz <sinkwitz@ifi.unizh.ch>.
+
+
+3.0		(91/10/03)
+
+	Functions name and defines have been modified again (sorry for that)
+	as follows:
+
+	     XpmReadPixmapFile    XpmReadFileToPixmap
+	     XpmWritePixmapFile   XpmWriteFileFromPixmap
+
+	     XpmPixmapColorError  XpmColorError
+	     XpmPixmapSuccess     XpmSuccess
+	     XpmPixmapOpenFailed  XpmOpenFailed
+	     XpmPixmapFileInvalid XpmFileInvalid
+	     XpmPixmapNoMemory    XpmNoMemory
+	     XpmPixmapColorFailed XpmColorFailed
+
+	To update code using Xpm you can use the included shell script called
+	rename with the sed commands files name-3.0b-3.0c and name-3.0c-3.0.
+	Old names still valid though.
+
+    NEW FEATURES:
+	- four new functions to work with images instead of pixmaps:
+
+	     XpmReadFileToImage
+	     XpmWriteFileFromImage
+	     XpmCreateImageFromData
+	     XpmCreateDataFromImage
+
+    ENHANCEMENTS:
+    	Algorithms to create and scan images and pixmaps are based on the
+	MIT's R5 code, thus they are much cleaner than old ones and should
+	avoid any problem with any visual (yes, I trust MIT folks :-)
+
+    BUGS CORRECTED:
+	Imakefile use INCDIR instead of ROOTDIR.
+
+    CHANGES TO THE DOC:
+	- the documentation presents the four new functions.
+
+3.0c		(91/09/18)
+
+	In answer to request of people functions, types and defines names have
+	been changed as follows:
+
+	     XCreatePixmapFromData	 XpmCreatePixmapFromData
+	     XCreateDataFromPixmap	 XpmCreateDataFromPixmap
+	     XReadPixmapFile		 XpmReadPixmapFile
+	     XWritePixmapFile		 XpmWritePixmapFile
+	     XFreeXpmAttributes		 XpmFreeAttributes
+
+	     PixmapColorError		 XpmPixmapColorError
+	     PixmapSuccess		 XpmPixmapSuccess
+	     PixmapOpenFailed		 XpmPixmapOpenFailed
+	     PixmapFileInvalid		 XpmPixmapFileInvalid
+	     PixmapNoMemory		 XpmPixmapNoMemory
+	     PixmapColorFailed		 XpmPixmapColorFailed
+
+	     ColorSymbol		 XpmColorSymbol
+
+	Generally speaking every public name begins with 'Xpm' and every
+	private one with 'xpm'. This should avoid any possible conflict.
+
+	Some files have also be renamed accordingly.
+
+    NEW FEATURES:
+	- support for VMS and two new options for sxpm: icon and hints (see
+	manual for details) Richard Hess <rhess%pleione%cimshop@uunet.UU.NET>
+	- DEFINES in Imakefile and Makefile.noXtree allows you to set the
+	following:
+
+	    	 ZPIPE for un/compressing piped feature (default is on)
+		 NEED_STRCASECMP for system which doesn't provide one (default
+				 is off)
+
+	- xpmtoppm.c has is own strstr function which is used if NEED_STRSTR
+	is defined when compiling - Hugues.Leroy@irisa.fr (Hugues Leroy).
+	
+    BUGS CORRECTED:
+	- many bugs have been fixed, especially for ansi compilers -
+	       Doyle C. Davidson (doyle@doyled.b23b.ingr.com) and
+	       Clifford D. Morrison (cdm%bigdaddy%edsr@uunet.UU.NET)
+	- parser is again a little more improved
+
+3.0b		(91/09/12)
+
+	This is a complete new version with a new API and where files and
+	structures have been renamed. So this should be taken as a new
+	starting release.
+	This release should be quickly followed by the 3.0 because I'm planning
+	to send it for X11R5 contrib which ends October 5th.
+
+    NEW FEATURES:
+	- support for transparent color.
+	- support for hotspot.
+	- a new function: XCreateDataFromPixmap to create an XPM data from a
+	pixmap in order to be able to create a new pixmap from this data using
+	the XCreatePixmapFromData function later on.
+	- a new structure: XpmAttributes which replace the XpmInfo structure
+	and which leads to a much simpler API with less arguments.
+	- arguments such as visual, colormap and depth are optionnal, default
+	values are taken if omitted.
+	- parsing and allocating color failures don't simply break anymore. If
+	another default color can be found it is used and a PixmapColorError
+	is returned. In case no color can be found then it breaks and returns
+	PixmapColorFailed.
+	- for this reason the ErrorStatus codes are redefined as follows:
+
+		   null     if full success
+		   positive if partial success
+		   negative if failure
+
+	with:
+		#define PixmapColorError    1
+		#define PixmapSuccess       0
+		#define PixmapOpenFailed   -1
+		#define PixmapFileInvalid  -2
+		#define PixmapNoMemory     -3
+		#define PixmapColorFailed  -4
+
+	- sxpm prints out a warning when a requested color could not be parsed
+	or alloc'ed, and an error when none has been found.
+	- sxpm handles pixmap with transparent color. For this purpose the
+	plaid_mask.xpm is added to the distribution.
+
+    BUGS CORRECTED:
+	- I've again improved the memory management.
+	- the parser is also improved.
+	- when writting a pixmap to a file the variable name could be
+	"plaid.xpm" which is not valid in C. Now the extension name is cut off
+	to give "plaid" as variable name.
+	- reading multiple words colornames such as "peach puff" where leading
+	to non readable Xpm files. They are now skipped to have only single
+	word colorname. Lionel Mallet (mallet@ipvpel.unipv.it).
+	- parser was triggered by the "/" character inside string.
+	Doyle C. Davidson (doyle@doyled.b23b.ingr.com). This is corrected.
+	- sxpm maps the window only if the option "-nod" is not selected. 
+
+    CHANGES TO THE DOC:
+	- the documentation presents the new API and features.
+
+3.0a		(91/04/10)
+
+	This is an alpha version because it supports the new version of XPM,
+	but the library interface is still the same. Indeed it will change in
+	future release to get rid of obsolete stuff such as the type argument
+	of the XWritePixmapFile function.
+
+    ******************************* WARNING *********************************
+	The format is not anymore XPM2, it is XPM version 3 which is XPM2
+	limited to the C syntax with the key word "XPM" in place of "XPM2 C".
+	The interface library has not changed yet but the type argument of
+	XWritePixmapFile and the type member of XpmInfo are not used anymore.
+	Meanwhile the library which is now called libXpm.a is backward
+	compatible as XPM2 files can be read. But the XWritePixmapFile
+	function only writes out XPM version 3 files.
+    *************************************************************************
+
+    NEW FEATURES:
+	- the library doesn't use global variables anymore, thus it should be
+	able to share it.
+	- sxpm has been rewritten on top of Xt, it can be used to convert
+	files from XPM2 to XPM version 3.
+	- xpm1to2c.perl has been upgraded to the new XPM version and renamed
+	as xpm1to3.perl
+	- ppmtoxpm2.c and ppmtoxpm2.1 have been upgraded too and renamed
+	ppmtoxpm.c and ppmtoxpm.1. In addition the xpmtoppm.c and xpmtoppm.1
+	of the pbmplus package have been upgraded too. xpmtoppm can thus
+	convert XPM version 1 and 3 to a portable pixmap. These files should
+	replace the original ones which are part of the pbmplus package. See
+	the ppm.README file for more details.
+	- the library contains RCS variables which allows you to get revision
+	numbers with ident (which is part of the RCS package). The Id number
+	is an internal rcs number for my eyes only. The official one is found
+	in Version.
+
+    BUGS CORRECTED:
+	- the memory management has been much improved in order to avoid
+	memory leaks.
+	- the XImage building algorythm has been changed to support correctly
+	different visual depths. There is special code to handle depths 1, 4,
+	6, 8, 24, and 32 to build the image and send it in one whack, and
+	other depths are supported by building the image with XPutPixel which
+	is slow but sure.
+	- similar algorithms are used to read pixmaps and write them out.
+
+    CHANGES TO THE DOC:
+	- the documentation presents the new XPM format.
+
+
+2.8		(90/12/19)
+
+    ******************************* WARNING *********************************
+        Since the last release two structures have been modified and have now
+	bigger sizes, so ANY CODE USING THE libXPM2 NEEDS TO BE RECOMPILED.
+    *************************************************************************
+
+    NEW FEATURES:
+	- the ColorSymbol struct contains the new member 'pixel' which allow
+	to override default colors by giving a pixel value (in such a case
+	symbol value must be set to NULL),
+	- the XpmInfo struct contains the new member 'rgb_fname' in which one
+	can specify an rgb text file name while writing a pixmap with the 
+	XWritePixmapFile function (otherwise this member should be set to
+	NULL). This way colorname will be searched and written out if found
+	instead of the RGB value,
+	- Imakefile originally provided by stolcke@ICSI.Berkeley.EDU,
+	- the old Makefile is now distributed as Makefile.noXtree and presents
+	install targets,
+	- the demo application is renamed sxpm (Show XPM), creates a window of
+	the size of the pixmap if no geometry is specified, prints out
+	messages instead of status when an error occurs, handles the new
+	option -p for overriding colors by giving a pixel value (not really
+	useful but is just here to show this new feature), handles the new
+	option -rgb for specifying an rgb text file, and ends on
+	keypress as buttonpress,
+	- defines for SYSV have been provided by Paul Breslaw
+	<paul@mecazh.uucp>,
+	- the distribution includes a new directory called converters which
+	contains xpm1to2 and xpm1to2c perl converters and a ppmtoxpm2
+	converter provided by Paul Breslaw who upgraded the original ppmtoxpm
+	written by Mark W. Snitily <mark@zok.uucp>.
+
+    CHANGES TO THE DOC:
+	- this file is created and will give old users a quick reference to
+	changes made from one release to the next one,
+	- documentation is changed to present the new ColorSymbol structure
+	and the way to override colors by giving a pixel value, and to present
+	the new XpmInfo structure and how to use it,
+	- a man page for sxpm is added to the distrib,
+	- the README file talks about sxpm and no more demo, and have
+	reference to the different converters.
+
+2.7		(90/11/12)
+
+    NEW FEATURES:
+	- XReadPixmapFile reads from stdin if filename is NULL,
+	- XWritePixmapFile writes to stdin if filename is NULL,
+	- the demo application handles the new option -nod for no displaying
+	the pixmap in a window (useful when used as converter).
+
+    CHANGES TO THE DOC:
+	- documentation about the new feature.
+
+2.6		(90/10/29)
+
+    NEW FEATURES:
+	- from nazgul@alphalpha.com (Kee Hinckley): changes to make the
+	library usable as C++ code, and on Apollo without any warning.
+
+    BUGS CORRECTED:
+	- from nazgul@alphalpha.com (Kee Hinckley): the xpm include files was
+	declaring XWritePixmapFile as taking in arg a Pixmap pointer instead
+	of a Pixmap.
+
+2.5		(90/10/17)
+
+    BUGS CORRECTED:
+	- XWritePixmapFile was not closing the file while ending normaly.
+
+2.4		(90/09/06)
+
+    NEW FEATURES:
+	- XReadPixmapFile reads from a piped uncompress if the given filename
+	ends by .Z or if filename.Z exists,
+	- XWritePixmapFile writes to a piped compress if the given filename
+	ends by .Z.
+
+    BUGS CORRECTED:
+	- demo now deals with window manager.
+
+    CHANGES TO THE DOC:
+	- documentation about compressed files management.
+
+2.3		(90/08/30)
+
+    BUGS CORRECTED:
+	- handle monochrom display correctly,
+	- comments can be empty.
+
+2.2		(90/08/27)
+
+    BUGS CORRECTED:
+	- when reading some invalid free was dumping core on some machine.
+
+2.1		(90/08/24)
+
+    First distribution of XPM2.
+
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/copyrigh.t b/src/wxmac/contrib/wxxpm/libxpm.34b/copyrigh.t
new file mode 100644
index 0000000..3633944
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/copyrigh.t
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+Arnaud LE HORS      BULL Research FRANCE -- Koala Project 
+                    (XPM - X PixMap format version 2 & 3)
+    Internet:       lehors@sophia.inria.fr
+Surface Mail:       Arnaud LE HORS, INRIA - Sophia Antipolis, 
+                    2004, route des Lucioles, 06565 Valbonne Cedex -- FRANCE
+ Voice phone:       (33) 93.65.77.71, Fax: (33) 93 65 77 66, Telex: 97 00 50 F
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/files b/src/wxmac/contrib/wxxpm/libxpm.34b/files
new file mode 100644
index 0000000..0a98c41
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/files
@@ -0,0 +1,47 @@
+CHANGES
+COPYRIGHT
+FILES
+Imakefile
+Makefile.noXtree
+README
+README.MSW
+namecvt
+lib
+lib/Imakefile
+lib/Makefile.noXtree
+lib/XpmCrBufFrI.c
+lib/XpmCrBufFrP.c
+lib/XpmCrDataFrI.c
+lib/XpmCrDataFrP.c
+lib/XpmCrIFrBuf.c
+lib/XpmCrIFrData.c
+lib/XpmCrPFrBuf.c
+lib/XpmCrPFrData.c
+lib/XpmRdFToData.c
+lib/XpmRdFToI.c
+lib/XpmRdFToP.c
+lib/XpmWrFFrData.c
+lib/XpmWrFFrI.c
+lib/XpmWrFFrP.c
+lib/create.c
+lib/data.c
+lib/hashtable.c
+lib/misc.c
+lib/parse.c
+lib/rgb.c
+lib/rgbtab.h
+lib/scan.c
+lib/simx.h
+lib/simx.c
+lib/xpm.h
+lib/xpmP.h
+doc
+doc/xpm.ps
+sxpm
+sxpm/Imakefile
+sxpm/Makefile.noXtree
+sxpm/plaid.xpm
+sxpm/plaid_ext.xpm
+sxpm/plaid_mask.xpm
+sxpm/sxpm.c
+sxpm/sxpm.man
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffri.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffri.c
new file mode 100644
index 0000000..ea2a64e
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffri.c
@@ -0,0 +1,324 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrBufFrI.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Scan an image and possibly its mask and create an XPM buffer               *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:string.h"
+#else
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+LFUNC(WriteColors, int, (char **dataptr, unsigned int *data_size,
+			 unsigned int *used_size, XpmColor *colors,
+			 unsigned int ncolors, unsigned int cpp));
+
+LFUNC(WritePixels, void, (char *dataptr, unsigned int *used_size,
+			  unsigned int width, unsigned int height,
+			  unsigned int cpp, unsigned int *pixels,
+			  XpmColor *colors));
+
+LFUNC(WriteExtensions, void, (char *dataptr, unsigned int *used_size,
+			      XpmExtension *ext, unsigned int num));
+
+LFUNC(ExtensionsSize, int, (XpmExtension *ext, unsigned int num));
+LFUNC(CommentsSize, int, (XpmInfo *info));
+
+int
+XpmCreateBufferFromImage(Display *display, char **buffer_return, XImage *image,
+  XImage *shapeimage, XpmAttributes *attributes)
+{
+    XpmImage xpmimage;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* initialize return value */
+    if (buffer_return)
+	*buffer_return = NULL;
+
+    /* create an XpmImage from the image */
+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
+					     &xpmimage, attributes);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the buffer from the XpmImage */
+    if (attributes) {
+	xpmSetInfo(&info, attributes);
+	ErrorStatus =
+	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, &info);
+    } else
+	ErrorStatus =
+	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, NULL);
+
+    /* free the XpmImage */
+    XpmFreeXpmImage(&xpmimage);
+
+    return (ErrorStatus);
+}
+
+
+#undef RETURN
+#define RETURN(status) \
+{ \
+    if (ptr) \
+	XpmFree(ptr); \
+    return(status); \
+}
+
+int
+XpmCreateBufferFromXpmImage(char **buffer_return, XpmImage *image, XpmInfo *info)
+{
+    /* calculation variables */
+    int ErrorStatus;
+    char buf[BUFSIZ];
+    unsigned int cmts, extensions, ext_size = 0;
+    unsigned int l, cmt_size = 0;
+    char *ptr = NULL, *p;
+    unsigned int ptr_size, used_size;
+
+    *buffer_return = NULL;
+
+    cmts = info && (info->valuemask & XpmComments);
+    extensions = info && (info->valuemask & XpmExtensions)
+	&& info->nextensions;
+
+    /* compute the extensions and comments size */
+    if (extensions)
+	ext_size = ExtensionsSize(info->extensions, info->nextensions);
+    if (cmts)
+	cmt_size = CommentsSize(info);
+
+    /* write the header line */
+    sprintf(buf, "/* XPM */\nstatic char * image_name[] = {\n");
+    used_size = strlen(buf);
+    ptr_size = used_size + ext_size + cmt_size + 1;
+    ptr = (char *) XpmMallocA(ptr_size);
+    if (!ptr)
+	return XpmNoMemory;
+    strcpy(ptr, buf);
+
+    /* write the values line */
+    if (cmts && info->hints_cmt) {
+	sprintf(ptr + used_size, "/*%s*/\n", info->hints_cmt);
+	used_size += strlen(info->hints_cmt) + 5;
+    }
+    sprintf(buf, "\"%d %d %d %d", image->width, image->height,
+	    image->ncolors, image->cpp);
+    l = strlen(buf);
+
+    if (info && (info->valuemask & XpmHotspot)) {
+	sprintf(buf + l, " %d %d", info->x_hotspot, info->y_hotspot);
+	l = strlen(buf);
+    }
+    if (extensions) {
+	sprintf(buf + l, " XPMEXT");
+	l = strlen(buf);
+    }
+    sprintf(buf + l, "\",\n");
+    l = strlen(buf);
+    ptr_size += l;
+    p = (char *) XpmReallocA(ptr, ptr_size);
+    if (!p)
+	RETURN(XpmNoMemory);
+    ptr = p;
+    strcpy(ptr + used_size, buf);
+    used_size += l;
+
+    /* write colors */
+    if (cmts && info->colors_cmt) {
+	sprintf(ptr + used_size, "/*%s*/\n", info->colors_cmt);
+	used_size += strlen(info->colors_cmt) + 5;
+    }
+    ErrorStatus = WriteColors(&ptr, &ptr_size, &used_size,
+			      image->colorTable, image->ncolors, image->cpp);
+ 
+    if (ErrorStatus != XpmSuccess)
+	RETURN(ErrorStatus);
+
+    /*
+     * now we know the exact size we needed, realloc the data 4 = 1 (for
+     * '"') + 3 (for '",\n') 1 = - 2 is because the last line does not end
+     * with ',\n' + 3 (for '};\n')
+     */
+    ptr_size += image->height * (image->width * image->cpp + 4) + 1;
+
+    p = (char *) XpmReallocA(ptr, ptr_size);
+    if (!p)
+	RETURN(XpmNoMemory);
+    ptr = p;
+
+    /* print pixels */
+    if (cmts && info->pixels_cmt) {
+	sprintf(ptr + used_size, "/*%s*/\n", info->pixels_cmt);
+	used_size += strlen(info->pixels_cmt) + 5;
+    }
+    WritePixels(ptr + used_size, &used_size, image->width, image->height,
+		image->cpp, image->data, image->colorTable);
+
+    /* print extensions */
+    if (extensions)
+	WriteExtensions(ptr + used_size, &used_size,
+			info->extensions, info->nextensions);
+
+    /* close the array */
+    sprintf(ptr + used_size, "};\n");
+
+    *buffer_return = ptr;
+
+    return (XpmSuccess);
+}
+
+static int
+WriteColors(char **dataptr, unsigned int *data_size, unsigned int *used_size,
+   XpmColor *colors, unsigned int ncolors, unsigned int cpp)
+{
+    char buf[BUFSIZ];
+    unsigned int a, key, l;
+    char *s, *s2;
+    char **defaults;
+
+    *buf = '"';
+    for (a = 0; a < ncolors; a++, colors++) {
+
+	defaults = (char **) colors;
+	s = buf + 1;
+	strncpy(s, *defaults++, cpp);
+	s += cpp;
+
+	for (key = 1; key <= NKEYS; key++, defaults++) {
+	    if (s2 = *defaults) {
+		sprintf(s, "\t%s %s", xpmColorKeys[key - 1], s2);
+		s += strlen(s);
+	    }
+	}
+	strcpy(s, "\",\n");
+	l = strlen(buf);
+	s = (char *) XpmReallocA(*dataptr, *data_size + l);
+	if (!s)
+	    return (XpmNoMemory);
+	*data_size += l;
+	strcpy(s + *used_size, buf);
+	*used_size += l;
+	*dataptr = s;
+    }
+    return (XpmSuccess);
+}
+
+static void
+WritePixels(char *dataptr, unsigned int *used_size, unsigned int width, unsigned int height,
+   unsigned int cpp, unsigned int *pixels, XpmColor *colors)
+{
+    char *s = dataptr;
+    unsigned int x, y, h;
+
+    h = height - 1;
+    for (y = 0; y < h; y++) {
+	*s++ = '"';
+	for (x = 0; x < width; x++, pixels++) {
+	    strncpy(s, colors[*pixels].string, cpp);
+	    s += cpp;
+	}
+	strcpy(s, "\",\n");
+	s += 3;
+    }
+    /* duplicate some code to avoid a test in the loop */
+    *s++ = '"';
+    for (x = 0; x < width; x++, pixels++) {
+	strncpy(s, colors[*pixels].string, cpp);
+	s += cpp;
+    }
+    *s++ = '"';
+    *used_size += s - dataptr;
+}
+
+static int
+ExtensionsSize(XpmExtension *ext, unsigned int num)
+{
+    unsigned int x, y, a, size;
+    char **line;
+
+    size = 0;
+    for (x = 0; x < num; x++, ext++) {
+	/* 11 = 10 (for ',\n"XPMEXT ') + 1 (for '"') */
+	size += strlen(ext->name) + 11;
+	a = ext->nlines;
+	for (y = 0, line = ext->lines; y < a; y++, line++)
+	    /* 4 = 3 (for ',\n"') + 1 (for '"') */
+	    size += strlen(*line) + 4;
+    }
+    /* 13 is for ',\n"XPMENDEXT"' */
+    return size + 13;
+}
+
+static void
+WriteExtensions(char *dataptr, unsigned int *used_size, XpmExtension *ext, unsigned int num)
+{
+    unsigned int x, y, a;
+    char **line;
+    char *s = dataptr;
+
+    for (x = 0; x < num; x++, ext++) {
+	sprintf(s, ",\n\"XPMEXT %s\"", ext->name);
+	s += strlen(ext->name) + 11;
+	a = ext->nlines;
+	for (y = 0, line = ext->lines; y < a; y++, line++) {
+	    sprintf(s, ",\n\"%s\"", *line);
+	    s += strlen(*line) + 4;
+	}
+    }
+    strcpy(s, ",\n\"XPMENDEXT\"");
+    *used_size += s - dataptr + 13;
+}
+
+static int
+CommentsSize(XpmInfo *info)
+{
+    int size = 0;
+
+    /* 5 = 2 (for "/_*") + 3 (for "*_/\n") */
+    if (info->hints_cmt)
+	size += 5 + strlen(info->hints_cmt);
+
+    if (info->colors_cmt)
+	size += 5 + strlen(info->colors_cmt);
+
+    if (info->pixels_cmt)
+	size += 5 + strlen(info->pixels_cmt);
+
+    return size;
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffrp.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffrp.c
new file mode 100644
index 0000000..5dbae09
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crbuffrp.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrBufFrP.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Scan a pixmap and possibly its mask and create an XPM buffer               *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:string.h"
+#else
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+int
+XpmCreateBufferFromPixmap(Display *display, char **buffer_return, Pixmap pixmap, Pixmap shapemask,
+			  XpmAttributes *attributes)
+{
+    XImage *ximage = NULL;
+    XImage *shapeimage = NULL;
+    unsigned int width = 0;
+    unsigned int height = 0;
+    int ErrorStatus;
+
+    /* get geometry */
+    if (attributes && attributes->valuemask & XpmSize) {
+	width = attributes->width;
+	height = attributes->height;
+    }
+    /* get the ximages */
+    if (pixmap)
+	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);
+    if (shapemask)
+	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,
+				 &width, &height);
+
+    /* create the buffer */
+    ErrorStatus = XpmCreateBufferFromImage(display, buffer_return, ximage,
+					   shapeimage, attributes);
+
+    /* destroy the ximages */
+    if (ximage)
+	XDestroyImage(ximage);
+    if (shapeimage)
+	XDestroyImage(shapeimage);
+
+    return (ErrorStatus);
+}
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfri.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfri.c
new file mode 100644
index 0000000..06859cc
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfri.c
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrDataFI.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Scan an image and possibly its mask and create an XPM array                *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:string.h"
+#else
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+LFUNC(CreateColors, int, (char **dataptr, unsigned int *data_size,
+			  XpmColor *colors, unsigned int ncolors,
+			  unsigned int cpp));
+
+LFUNC(CreatePixels, void, (char **dataptr, unsigned int width,
+			   unsigned int height, unsigned int cpp,
+			   unsigned int *pixels, XpmColor *colors));
+
+LFUNC(CountExtensions, void, (XpmExtension *ext, unsigned int num,
+			      unsigned int *ext_size,
+			      unsigned int *ext_nlines));
+
+LFUNC(CreateExtensions, void, (char **dataptr, unsigned int offset,
+			       XpmExtension *ext, unsigned int num,
+			       unsigned int ext_nlines));
+
+int
+XpmCreateDataFromImage(Display *display, char ***data_return, XImage *image,
+  XImage *shapeimage, XpmAttributes *attributes)
+{
+    XpmImage xpmimage;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* initialize return value */
+    if (data_return)
+	*data_return = NULL;
+
+    /* create an XpmImage from the image */
+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
+					     &xpmimage, attributes);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the data from the XpmImage */
+    if (attributes) {
+	xpmSetInfo(&info, attributes);
+	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, &info);
+    } else
+	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, NULL);
+
+    /* free the XpmImage */
+    XpmFreeXpmImage(&xpmimage);
+
+    return (ErrorStatus);
+}
+
+#undef RETURN
+#define RETURN(status) \
+{ \
+    if (header) { \
+	for (l = 0; l < header_nlines; l++) \
+	    if (header[l]) \
+		XpmFree(header[l]); \
+		XpmFree(header); \
+    } \
+    return(status); \
+}
+
+int
+XpmCreateDataFromXpmImage(char ***data_return, XpmImage *image, XpmInfo *info)
+{
+    /* calculation variables */
+    int ErrorStatus;
+    char buf[BUFSIZ];
+    char **header = NULL, **data, **sptr, **sptr2, *s;
+    unsigned int header_size, header_nlines;
+    unsigned int data_size, data_nlines;
+    unsigned int extensions = 0, ext_size = 0, ext_nlines = 0;
+    unsigned int offset, l, n;
+
+    *data_return = NULL;
+
+    extensions = info && (info->valuemask & XpmExtensions)
+	&& info->nextensions;
+
+    /* compute the number of extensions lines and size */
+    if (extensions)
+	CountExtensions(info->extensions, info->nextensions,
+			&ext_size, &ext_nlines);
+
+    /*
+     * alloc a temporary array of char pointer for the header section which
+     * is the hints line + the color table lines
+     */
+    header_nlines = 1 + image->ncolors;
+    header_size = sizeof(char *) * header_nlines;
+    header = (char **) XpmCalloc(header_size, sizeof(char *));
+    if (!header)
+	return (XpmNoMemory);
+
+    /* print the hints line */
+    s = buf;
+    sprintf(s, "%d %d %d %d", image->width, image->height,
+	    image->ncolors, image->cpp);
+    s += strlen(s);
+
+    if (info && (info->valuemask & XpmHotspot)) {
+	sprintf(s, " %d %d", info->x_hotspot, info->y_hotspot);
+	s += strlen(s);
+    }
+    if (extensions)
+	sprintf(s, " XPMEXT");
+
+    l = strlen(buf) + 1;
+    *header = (char *) XpmMallocA(l);
+    if (!*header)
+	RETURN(XpmNoMemory);
+    header_size += l;
+    strcpy(*header, buf);
+
+    /* print colors */
+    ErrorStatus = CreateColors(header + 1, &header_size,
+			       image->colorTable, image->ncolors, image->cpp);
+
+    if (ErrorStatus != XpmSuccess)
+	RETURN(ErrorStatus);
+
+    /* now we know the size needed, alloc the data and copy the header lines */
+    offset = image->width * image->cpp + 1;
+    data_size = header_size + (image->height + ext_nlines) * sizeof(char *)
+	+ image->height * offset + ext_size;
+
+    data = (char **) XpmMalloc(data_size);
+    if (!data)
+	RETURN(XpmNoMemory);
+
+    data_nlines = header_nlines + image->height + ext_nlines;
+    *data = (char *) (data + data_nlines);
+    n = image->ncolors;
+    for (l = 0, sptr = data, sptr2 = header; l <= n; l++, sptr++, sptr2++) {
+	strcpy(*sptr, *sptr2);
+	*(sptr + 1) = *sptr + strlen(*sptr2) + 1;
+    }
+
+    /* print pixels */
+    data[header_nlines] = (char *) data + header_size
+	+ (image->height + ext_nlines) * sizeof(char *);
+
+    CreatePixels(data + header_nlines, image->width, image->height,
+		 image->cpp, image->data, image->colorTable);
+
+    /* print extensions */
+    if (extensions)
+	CreateExtensions(data + header_nlines + image->height - 1, offset,
+			 info->extensions, info->nextensions,
+			 ext_nlines);
+
+    *data_return = data;
+
+    RETURN(XpmSuccess);
+}
+
+static int
+CreateColors(char **dataptr, unsigned int *data_size, XpmColor *colors, unsigned int ncolors, unsigned int cpp)
+{
+    char buf[BUFSIZ];
+    unsigned int a, key, l;
+    char *s, *s2;
+    char **defaults;
+
+    for (a = 0; a < ncolors; a++, colors++, dataptr++) {
+
+	defaults = (char **) colors;
+	strncpy(buf, *defaults++, cpp);
+	s = buf + cpp;
+
+	for (key = 1; key <= NKEYS; key++, defaults++) {
+	    if (s2 = *defaults) {
+		sprintf(s, "\t%s %s", xpmColorKeys[key - 1], s2);
+		s += strlen(s);
+	    }
+	}
+	l = strlen(buf) + 1;
+	s = (char *) XpmMallocA(l);
+	if (!s)
+	    return (XpmNoMemory);
+	*data_size += l;
+	strcpy(s, buf);
+	*dataptr = s;
+    }
+    return (XpmSuccess);
+}
+
+static void
+CreatePixels(char **dataptr, unsigned int width, unsigned int height, unsigned int cpp,
+   unsigned int *pixels, XpmColor *colors)
+{
+    char *s;
+    unsigned int x, y, h, offset;
+
+    h = height - 1;
+    offset = width * cpp + 1;
+    for (y = 0; y < h; y++, dataptr++) {
+	s = *dataptr;
+	for (x = 0; x < width; x++, pixels++) {
+	    strncpy(s, colors[*pixels].string, cpp);
+	    s += cpp;
+	}
+	*s = '\0';
+	*(dataptr + 1) = *dataptr + offset;
+    }
+    /* duplicate some code to avoid a test in the loop */
+    s = *dataptr;
+    for (x = 0; x < width; x++, pixels++) {
+	strncpy(s, colors[*pixels].string, cpp);
+	s += cpp;
+    }
+    *s = '\0';
+}
+
+static void
+CountExtensions(XpmExtension *ext, unsigned int num, unsigned int *ext_size, unsigned int *ext_nlines)
+{
+    unsigned int x, y, a, size, nlines;
+    char **line;
+
+    size = 0;
+    nlines = 0;
+    for (x = 0; x < num; x++, ext++) {
+	/* 1 for the name */
+	nlines += ext->nlines + 1;
+	/* 8 = 7 (for "XPMEXT ") + 1 (for 0) */
+	size += strlen(ext->name) + 8;
+	a = ext->nlines;
+	for (y = 0, line = ext->lines; y < a; y++, line++)
+	    size += strlen(*line) + 1;
+    }
+    /* 10 and 1 are for the ending "XPMENDEXT" */
+    *ext_size = size + 10;
+    *ext_nlines = nlines + 1;
+}
+
+static void
+CreateExtensions(char **dataptr, unsigned int offset, XpmExtension *ext, unsigned int num, unsigned int ext_nlines)
+{
+    unsigned int x, y, a, b;
+    char **line;
+
+    *(dataptr + 1) = *dataptr + offset;
+    dataptr++;
+    a = 0;
+    for (x = 0; x < num; x++, ext++) {
+	sprintf(*dataptr, "XPMEXT %s", ext->name);
+	a++;
+	if (a < ext_nlines)
+	    *(dataptr + 1) = *dataptr + strlen(ext->name) + 8;
+	dataptr++;
+	b = ext->nlines;
+	for (y = 0, line = ext->lines; y < b; y++, line++) {
+	    strcpy(*dataptr, *line);
+	    a++;
+	    if (a < ext_nlines)
+		*(dataptr + 1) = *dataptr + strlen(*line) + 1;
+	    dataptr++;
+	}
+    }
+    strcpy(*dataptr, "XPMENDEXT");
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfrp.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfrp.c
new file mode 100644
index 0000000..1fc16ce
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crdatfrp.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrDataFP.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Scan a pixmap and possibly its mask and create an XPM array                *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:string.h"
+#else
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+int
+XpmCreateDataFromPixmap(Display *display, char ***data_return, Pixmap pixmap,
+   Pixmap shapemask, XpmAttributes *attributes)
+{
+    XImage *ximage = NULL;
+    XImage *shapeimage = NULL;
+    unsigned int width = 0;
+    unsigned int height = 0;
+    int ErrorStatus;
+
+    /* get geometry */
+    if (attributes && attributes->valuemask & XpmSize) {
+	width = attributes->width;
+	height = attributes->height;
+    }
+    /* get the ximages */
+    if (pixmap)
+	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);
+    if (shapemask)
+	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,
+				 &width, &height);
+
+    /* create the data */
+    ErrorStatus = XpmCreateDataFromImage(display, data_return, ximage,
+					 shapeimage, attributes);
+
+    /* destroy the ximages */
+    if (ximage)
+	XDestroyImage(ximage);
+    if (shapeimage)
+	XDestroyImage(shapeimage);
+
+    return (ErrorStatus);
+}
+
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/create.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/create.c
new file mode 100644
index 0000000..bc2229a
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/create.c
@@ -0,0 +1,1508 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* create.c:                                                                   *
+*                                                                             *
+*  XPM library                                                                *
+*  Create an X image and possibly its related shape mask                      *
+*  from the given xpmInternAttrib.                                            *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:ctype.h"
+#else
+#include <ctype.h>
+#endif
+#if defined(FOR_MAC)
+extern int strcasecmp(char *s1, char *s2);
+#endif
+LFUNC(xpmVisualType, int, (Visual *visual));
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+LFUNC(SetCloseColor, int, (Display *display, Colormap colormap,
+			   Visual *visual, XColor *col,
+			   Pixel *image_pixel, Pixel *mask_pixel,
+			   Pixel **pixels, unsigned int *npixels,
+			   XpmAttributes *attributes,
+			   XColor *cols, int ncols));
+#else
+/* let the window system take care of close colors */
+#endif
+
+LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,
+		      char *colorname, unsigned int color_index,
+		      Pixel *image_pixel, Pixel *mask_pixel,
+		      unsigned int *mask_pixel_index, Pixel **pixels,
+		      unsigned int *npixels, XpmAttributes *attributes,
+		      XColor *cols, int ncols));
+
+LFUNC(CreateXImage, int, (Display *display, Visual *visual,
+			  unsigned int depth, unsigned int width,
+			  unsigned int height, XImage **image_return));
+
+LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,
+			  XpmColor *ct, unsigned int ncolors, Pixel *ip,
+			  Pixel *mp, unsigned int *mask_pixel,
+			  Pixel **pixels, unsigned int *npixels));
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+/* XImage pixel routines */
+LFUNC(SetImagePixels, void, (XImage *image, unsigned int width,
+			     unsigned int height, unsigned int *pixelindex,
+			     Pixel *pixels));
+
+LFUNC(SetImagePixels32, void, (XImage *image, unsigned int width,
+			       unsigned int height, unsigned int *pixelindex,
+			       Pixel *pixels));
+
+LFUNC(SetImagePixels16, void, (XImage *image, unsigned int width,
+			       unsigned int height, unsigned int *pixelindex,
+			       Pixel *pixels));
+
+LFUNC(SetImagePixels8, void, (XImage *image, unsigned int width,
+			      unsigned int height, unsigned int *pixelindex,
+			      Pixel *pixels));
+
+LFUNC(SetImagePixels1, void, (XImage *image, unsigned int width,
+			      unsigned int height, unsigned int *pixelindex,
+			      Pixel *pixels));
+#else  /* ndef FOR_MSW */
+/* FOR_MSW pixel routine */
+#ifdef FOR_MSW
+LFUNC(MSWSetImagePixels, void, (Display *dc, XImage *image,
+				unsigned int width, unsigned int height,
+				unsigned int *pixelindex, Pixel *pixels));
+#else
+LFUNC(MACSetImagePixels, void, (Display *dc, XImage *image,
+				unsigned int width, unsigned int height,
+				unsigned int *pixelindex, Pixel *pixels));
+#endif
+#endif /* ndef FOR_MSW */
+
+#ifdef NEED_STRCASECMP
+FUNC(strcasecmp, int, (char *s1, char *s2));
+
+/*
+ * in case strcasecmp is not provided by the system here is one
+ * which does the trick
+ */
+int
+strcasecmp(register char *s1, register char *s2)
+{
+    register int c1, c2;
+
+    while (*s1 && *s2) {
+	c1 = tolower(*s1);
+	c2 = tolower(*s2);
+	if (c1 != c2)
+	    return (c1 - c2);
+	s1++;
+	s2++;
+    }
+    return (int) (*s1 - *s2);
+}
+
+#endif
+
+/*
+ * return the default color key related to the given visual
+ */
+static int
+xpmVisualType(Visual *visual)
+{
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+/* Xlib.h defines this to be c_class or class, depending
+ * on whether we're doing C++ or C
+ */
+#if defined(__cplusplus) || defined(c_plusplus)
+    switch (visual->c_class)
+#else
+    switch (visual->class)
+#endif
+    {
+    case StaticGray:
+    case GrayScale:
+	switch (visual->map_entries) {
+	case 2:
+	    return (XPM_MONO);
+	case 4:
+	    return (XPM_GRAY4);
+	default:
+	    return (XPM_GRAY);
+	}
+    default:
+	return (XPM_COLOR);
+    }
+#else
+    /* there should be a similar switch for MSW */
+    return (XPM_COLOR);
+#endif
+}
+
+
+typedef struct {
+    int cols_index;
+    long closeness;
+}      CloseColor;
+
+static int
+closeness_cmp(const void *a, const void *b)
+{
+    CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;
+
+    /* cast to int as qsort requires */
+    return (int) (x->closeness - y->closeness);
+}
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+/*
+ * set a close color in case the exact one can't be set
+ * return 0 if success, 1 otherwise.
+ */
+
+static int
+SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col,
+	      Pixel *image_pixel, Pixel *mask_pixel, Pixel **pixels, unsigned int *npixels, XpmAttributes *attributes,
+	      XColor *cols, int ncols)
+{
+
+    /*
+     * Allocation failed, so try close colors. To get here the visual must
+     * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor?
+     * What about sharing systems like QDSS?). Beware: we have to treat
+     * DirectColor differently.
+     */
+
+
+    long int red_closeness, green_closeness, blue_closeness;
+    int n;
+
+    if (attributes && (attributes->valuemask & XpmCloseness))
+	red_closeness = green_closeness = blue_closeness =
+	    attributes->closeness;
+    else {
+	red_closeness = attributes->red_closeness;
+	green_closeness = attributes->green_closeness;
+	blue_closeness = attributes->blue_closeness;
+    }
+
+
+    /*
+     * We sort the colormap by closeness and try to allocate the color
+     * closest to the target. If the allocation of this close color fails,
+     * which almost never happens, then one of two scenarios is possible.
+     * Either the colormap must have changed (since the last close color
+     * allocation or possibly while we were sorting the colormap), or the
+     * color is allocated as Read/Write by some other client. (Note: X
+     * _should_ allow clients to check if a particular color is Read/Write,
+     * but it doesn't! :-( ). We cannot determine which of these scenarios
+     * occurred, so we try the next closest color, and so on, until no more
+     * colors are within closeness of the target. If we knew that the
+     * colormap had changed, we could skip this sequence.
+     * 
+     * If _none_ of the colors within closeness of the target can be allocated,
+     * then we can finally be pretty sure that the colormap has actually
+     * changed. In this case we try to allocate the original color (again),
+     * then try the closecolor stuff (again)...
+     * 
+     * In theory it would be possible for an infinite loop to occur if another
+     * process kept changing the colormap every time we sorted it, so we set
+     * a maximum on the number of iterations. After this many tries, we use
+     * XGrabServer() to ensure that the colormap remains unchanged.
+     * 
+     * This approach gives particularly bad worst case performance - as many as
+     * <MaximumIterations> colormap reads and sorts may be needed, and as
+     * many as <MaximumIterations> * <ColormapSize> attempted allocations
+     * may fail. On an 8-bit system, this means as many as 3 colormap reads,
+     * 3 sorts and 768 failed allocations per execution of this code!
+     * Luckily, my experiments show that in general use in a typical 8-bit
+     * color environment only about 1 in every 10000 allocations fails to
+     * succeed in the fastest possible time. So virtually every time what
+     * actually happens is a single sort followed by a successful allocate.
+     * The very first allocation also costs a colormap read, but no further
+     * reads are usually necessary.
+     */
+
+#define ITERATIONS 2			/* more than one is almost never
+					 * necessary */
+
+    for (n = 0; n <= ITERATIONS; ++n) {
+	CloseColor *closenesses =
+	    (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor));
+	int i, c;
+
+	for (i = 0; i < ncols; ++i) {	/* build & sort closenesses table */
+#define COLOR_FACTOR       3
+#define BRIGHTNESS_FACTOR  1
+
+	    closenesses[i].cols_index = i;
+	    closenesses[i].closeness =
+		COLOR_FACTOR * (abs((long) col->red - (long) cols[i].red)
+				+ abs((long) col->green - (long) cols[i].green)
+				+ abs((long) col->blue - (long) cols[i].blue))
+		+ BRIGHTNESS_FACTOR * abs(((long) col->red +
+					   (long) col->green +
+					   (long) col->blue)
+					   - ((long) cols[i].red +
+					      (long) cols[i].green +
+					      (long) cols[i].blue));
+	}
+	qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp);
+
+	i = 0;
+	c = closenesses[i].cols_index;
+	while ((long) cols[c].red >= (long) col->red - red_closeness &&
+	       (long) cols[c].red <= (long) col->red + red_closeness &&
+	       (long) cols[c].green >= (long) col->green - green_closeness &&
+	       (long) cols[c].green <= (long) col->green + green_closeness &&
+	       (long) cols[c].blue >= (long) col->blue - blue_closeness &&
+	       (long) cols[c].blue <= (long) col->blue + blue_closeness) {
+	    if (XAllocColor(display, colormap, &cols[c])) {
+		if (n == ITERATIONS)
+		    XUngrabServer(display);
+		XpmFree(closenesses);
+		*image_pixel = cols[c].pixel;
+		*mask_pixel = 1;
+		(*pixels)[*npixels] = cols[c].pixel;
+		(*npixels)++;
+		return (0);
+	    } else {
+		++i;
+		if (i == ncols)
+		    break;
+		c = closenesses[i].cols_index;
+	    }
+	}
+
+	/* Couldn't allocate _any_ of the close colors! */
+
+	if (n == ITERATIONS)
+	    XUngrabServer(display);
+	XpmFree(closenesses);
+
+	if (i == 0 || i == ncols)	/* no color close enough or cannot */
+	    return (1);			/* alloc any color (full of r/w's) */
+
+	if (XAllocColor(display, colormap, col)) {
+	    *image_pixel = col->pixel;
+	    *mask_pixel = 1;
+	    (*pixels)[*npixels] = col->pixel;
+	    (*npixels)++;
+	    return (0);
+	} else {			/* colormap has probably changed, so
+					 * re-read... */
+	    if (n == ITERATIONS - 1)
+		XGrabServer(display);
+
+#if 0
+	    if (visual->c_class == DirectColor) {
+		/* TODO */
+	    } else
+#endif
+		XQueryColors(display, colormap, cols, ncols);
+	}
+    }
+    return (1);
+}
+
+#define USE_CLOSECOLOR attributes && \
+(((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \
+ || ((attributes->valuemask & XpmRGBCloseness) && \
+     attributes->red_closeness != 0 \
+     && attributes->green_closeness != 0 \
+     && attributes->blue_closeness != 0))
+
+#else
+    /* FOR_MSW part */
+    /* nothing to do here, the window system does it */
+#endif
+
+/*
+ * set the color pixel related to the given colorname,
+ * return 0 if success, 1 otherwise.
+ */
+
+static int
+SetColor(Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index,
+	 Pixel *image_pixel, Pixel *mask_pixel, unsigned int *mask_pixel_index,
+	 Pixel **pixels, unsigned int *npixels, XpmAttributes *attributes, XColor *cols, int ncols)
+{
+    XColor xcolor;
+
+    if (strcasecmp(colorname, TRANSPARENT_COLOR)) {
+#if defined(wx_msw) || defined(FOR_MAC)
+	if (!XParseColor(display, (Colormap *)colormap, colorname, &xcolor))
+#else
+	if (!XParseColor(display, (Colormap)colormap, colorname, &xcolor))
+#endif
+	    return (1);
+#if defined(wx_msw) || defined(FOR_MAC)
+	if (!XAllocColor(display, (Colormap *)colormap, &xcolor)) {
+#else
+	if (!XAllocColor(display, (Colormap)colormap, &xcolor)) {
+#endif
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+	    if (USE_CLOSECOLOR)
+		return (SetCloseColor(display, colormap, visual, &xcolor,
+				      image_pixel, mask_pixel, pixels, npixels,
+				      attributes, cols, ncols));
+	    else
+#endif /* ndef FOR_MSW */
+		return (1);
+	}
+	*image_pixel = xcolor.pixel;
+	*mask_pixel = 1;
+	(*pixels)[*npixels] = xcolor.pixel;
+	(*npixels)++;
+    } else {
+	*image_pixel = 0;
+	*mask_pixel = 0;
+	*mask_pixel_index = color_index; /* store the color table index */
+    }
+    return (0);
+}
+
+
+static int
+CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned int ncolors,
+	     Pixel *ip, Pixel *mp, unsigned int *mask_pixel, Pixel **pixels, unsigned int *npixels)
+{
+    /* variables stored in the XpmAttributes structure */
+    Visual *visual;
+    Colormap colormap;
+    XpmColorSymbol *colorsymbols;
+    unsigned int numsymbols;
+
+    char *colorname;
+    unsigned int a, b, l;
+    int pixel_defined;
+    unsigned int key;
+    XpmColorSymbol *symbol;
+    char **defaults;
+    int ErrorStatus = XpmSuccess;
+    char *s;
+    int default_index;
+
+    XColor *cols = NULL;
+    unsigned int ncols = 0;
+
+    /*
+     * retrieve information from the XpmAttributes
+     */
+    if (attributes && attributes->valuemask & XpmColorSymbols) {
+	colorsymbols = attributes->colorsymbols;
+	numsymbols = attributes->numsymbols;
+    } else
+	numsymbols = 0;
+
+    if (attributes && attributes->valuemask & XpmVisual)
+	visual = attributes->visual;
+    else
+	visual = XDefaultVisual(display, XDefaultScreen(display));
+
+    if (attributes && attributes->valuemask & XpmColormap)
+	colormap = attributes->colormap;
+    else
+	colormap = XDefaultColormap(display, XDefaultScreen(display));
+
+    if (attributes && attributes->valuemask & XpmColorKey)
+	key = attributes->color_key;
+    else
+	key = xpmVisualType(visual);
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    if (USE_CLOSECOLOR) {
+	/* originally from SetCloseColor */
+#if 0
+	if (visual->c_class == DirectColor) {
+
+	    /*
+	     * TODO: Implement close colors for DirectColor visuals. This is
+	     * difficult situation. Chances are that we will never get here,
+	     * because any machine that supports DirectColor will probably
+	     * also support TrueColor (and probably PseudoColor). Also,
+	     * DirectColor colormaps can be very large, so looking for close
+	     * colors may be too slow.
+	     */
+	} else {
+#endif
+	    int i;
+
+	    ncols = visual->map_entries;
+	    cols = (XColor *) XpmCallocA(ncols, sizeof(XColor));
+	    for (i = 0; i < ncols; ++i)
+		cols[i].pixel = i;
+	    XQueryColors(display, colormap, cols, ncols);
+#if 0
+	}
+#endif
+    }
+#endif /* ndef FOR_MSW */
+
+    switch (key) {
+    case XPM_MONO:
+	default_index = 2;
+	break;
+    case XPM_GRAY4:
+	default_index = 3;
+	break;
+    case XPM_GRAY:
+	default_index = 4;
+	break;
+    case XPM_COLOR:
+    default:
+	default_index = 5;
+	break;
+    }
+
+    for (a = 0; a < ncolors; a++, ct++, ip++, mp++) {
+	colorname = NULL;
+	pixel_defined = False;
+	defaults = (char **) ct;
+
+	/*
+	 * look for a defined symbol
+	 */
+	if (numsymbols) {
+	    s = defaults[1];
+	    for (l = 0, symbol = colorsymbols; l < numsymbols; l++, symbol++) {
+		if (symbol->name && s && !strcmp(symbol->name, s))
+		    /* override name */
+		    break;
+		if (!symbol->name && symbol->value) {	/* override value */
+		    int def_index = default_index;
+
+		    while (defaults[def_index] == NULL)	/* find defined
+							 * colorname */
+			--def_index;
+		    if (def_index < 2) {/* nothing towards mono, so try
+					 * towards color */
+			def_index = default_index + 1;
+			while (def_index <= 5 && defaults[def_index] == NULL)
+			    ++def_index;
+		    }
+		    if (def_index >= 2 && defaults[def_index] != NULL &&
+			!strcasecmp(symbol->value, defaults[def_index]))
+			break;
+		}
+	    }
+	    if (l != numsymbols) {
+		if (symbol->name && symbol->value)
+		    colorname = symbol->value;
+		else
+		    pixel_defined = True;
+	    }
+	}
+	if (!pixel_defined) {		/* pixel not given as symbol value */
+	    if (colorname) {		/* colorname given as symbol value */
+		if (!SetColor(display, colormap, visual, colorname, a, ip, mp,
+			      mask_pixel, pixels, npixels, attributes,
+			      cols, ncols))
+		    pixel_defined = True;
+		else
+		    ErrorStatus = XpmColorError;
+	    }
+	    b = key;
+	    while (!pixel_defined && b > 1) {
+		if (defaults[b]) {
+		    if (!SetColor(display, colormap, visual, defaults[b],
+				  a, ip, mp, mask_pixel, pixels, npixels,
+				  attributes, cols, ncols)) {
+			pixel_defined = True;
+			break;
+		    } else
+			ErrorStatus = XpmColorError;
+		}
+		b--;
+	    }
+	    b = key + 1;
+	    while (!pixel_defined && b < NKEYS + 1) {
+		if (defaults[b]) {
+		    if (!SetColor(display, colormap, visual, defaults[b],
+				  a, ip, mp, mask_pixel, pixels, npixels,
+				  attributes, cols, ncols)) {
+			pixel_defined = True;
+			break;
+		    } else
+			ErrorStatus = XpmColorError;
+		}
+		b++;
+	    }
+	    if (!pixel_defined) {
+		if (cols)
+		    XpmFree(cols);
+		return (XpmColorFailed);
+	    }
+	} else {
+	    *ip = colorsymbols[l].pixel;
+	    if (symbol->value
+		&& !strcasecmp(symbol->value, TRANSPARENT_COLOR)) {
+		*mp = 0;
+		*mask_pixel = 0;
+	    } else
+		*mp = 1;
+	}
+    }
+    if (cols)
+	XpmFree(cols);
+    return (ErrorStatus);
+}
+
+
+/* function call in case of error, frees only locally allocated variables */
+#undef RETURN
+#define RETURN(status) \
+{ \
+    if (ximage) XDestroyImage(ximage); \
+    if (shapeimage) XDestroyImage(shapeimage); \
+    if (ximage_pixels) XpmFree(ximage_pixels); \
+    if (mask_pixels) XpmFree(mask_pixels); \
+    if (npixels) XFreeColors(display, colormap, pixels, npixels, 0); \
+    if (pixels) XpmFree(pixels); \
+    return (status); \
+}
+
+int
+XpmCreateImageFromXpmImage(Display *display, XpmImage *image,
+			   XImage **image_return, XImage **shapeimage_return, XpmAttributes *attributes)
+{
+    /* variables stored in the XpmAttributes structure */
+    Visual *visual;
+    Colormap colormap;
+    unsigned int depth;
+
+    /* variables to return */
+    XImage *ximage = NULL;
+    XImage *shapeimage = NULL;
+    unsigned int mask_pixel;
+    int ErrorStatus;
+
+    /* calculation variables */
+    Pixel *ximage_pixels = NULL;
+    Pixel *mask_pixels = NULL;
+    Pixel *pixels = NULL;		/* allocated pixels */
+    unsigned int npixels = 0;		/* number of allocated pixels */
+
+    /* initialize return values */
+    if (image_return)
+	*image_return = NULL;
+    if (shapeimage_return)
+	*shapeimage_return = NULL;
+
+    /* retrieve information from the XpmAttributes */
+    if (attributes && (attributes->valuemask & XpmVisual))
+	visual = attributes->visual;
+    else
+	visual = XDefaultVisual(display, XDefaultScreen(display));
+
+    if (attributes && (attributes->valuemask & XpmColormap))
+	colormap = attributes->colormap;
+    else
+	colormap = XDefaultColormap(display, XDefaultScreen(display));
+
+    if (attributes && (attributes->valuemask & XpmDepth))
+	depth = attributes->depth;
+    else
+	depth = XDefaultDepth(display, XDefaultScreen(display));
+
+    ErrorStatus = XpmSuccess;
+
+    /* malloc pixels index tables */
+    ximage_pixels = (Pixel *) XpmMallocA(sizeof(Pixel) * image->ncolors);
+    if (!ximage_pixels)
+	return (XpmNoMemory);
+
+    mask_pixels = (Pixel *) XpmMallocA(sizeof(Pixel) * image->ncolors);
+    if (!mask_pixels)
+	RETURN(XpmNoMemory);
+
+    mask_pixel = XpmUndefPixel;
+
+    /* maximum of allocated pixels will be the number of colors */
+    pixels = (Pixel *) XpmMallocA(sizeof(Pixel) * image->ncolors);
+    if (!pixels)
+	RETURN(XpmNoMemory);
+
+    /* get pixel colors, store them in index tables */
+    ErrorStatus = CreateColors(display, attributes, image->colorTable,
+			       image->ncolors, ximage_pixels, mask_pixels,
+			       &mask_pixel, &pixels, &npixels);
+
+    if (ErrorStatus != XpmSuccess
+	&& (ErrorStatus < 0 || (attributes
+				&& (attributes->valuemask & XpmExactColors)
+				&& attributes->exactColors)))
+	RETURN(ErrorStatus);
+
+    /* create the ximage */
+    if (image_return) {
+	ErrorStatus = CreateXImage(display, visual, depth,
+				   image->width, image->height, &ximage);
+	if (ErrorStatus != XpmSuccess)
+	    RETURN(ErrorStatus);
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+	/*
+	 * set the ximage data
+	 * 
+	 * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use
+	 * optimized functions, otherwise use slower but sure general one.
+	 * 
+	 */
+
+	if (ximage->depth == 1)
+	    SetImagePixels1(ximage, image->width, image->height,
+			    image->data, ximage_pixels);
+	else if (ximage->bits_per_pixel == 8)
+	    SetImagePixels8(ximage, image->width, image->height,
+			    image->data, ximage_pixels);
+	else if (ximage->bits_per_pixel == 16)
+	    SetImagePixels16(ximage, image->width, image->height,
+			     image->data, ximage_pixels);
+	else if (ximage->bits_per_pixel == 32)
+	    SetImagePixels32(ximage, image->width, image->height,
+			     image->data, ximage_pixels);
+	else
+	    SetImagePixels(ximage, image->width, image->height,
+			   image->data, ximage_pixels);
+#else  /* FOR_MSW */
+#ifdef FOR_MSW
+	MSWSetImagePixels(display, ximage, image->width, image->height,
+			  image->data, ximage_pixels);
+#else
+	MACSetImagePixels(display, ximage, image->width, image->height,
+			  image->data, ximage_pixels);
+#endif
+#endif
+    }
+    /* create the shape mask image */
+    if (mask_pixel != XpmUndefPixel && shapeimage_return) {
+	ErrorStatus = CreateXImage(display, visual, 1, image->width,
+				   image->height, &shapeimage);
+	if (ErrorStatus != XpmSuccess)
+	    RETURN(ErrorStatus);
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+	SetImagePixels1(shapeimage, image->width, image->height,
+			image->data, mask_pixels);
+#else
+#ifdef FOR_MSW
+	MSWSetImagePixels(display, shapeimage, image->width, image->height,
+			  image->data, mask_pixels);
+#else
+	MACSetImagePixels(display, ximage, image->width, image->height,
+			  image->data, ximage_pixels);
+#endif
+#endif
+
+    }
+    XpmFree(mask_pixels);
+    XpmFree(pixels);
+
+    /* if requested store alloc'ed pixels in the XpmAttributes structure */
+    if (attributes) {
+	if (attributes->valuemask & XpmReturnPixels ||
+/* 3.2 backward compatibility code */
+	    attributes->valuemask & XpmReturnInfos) {
+/* end 3.2 bc */
+	    if (mask_pixel != XpmUndefPixel) {
+		Pixel *pixels, *p1, *p2;
+		unsigned int a;
+
+		attributes->npixels = image->ncolors - 1;
+		pixels = (Pixel *) XpmMallocA(sizeof(Pixel)
+					     * attributes->npixels);
+		if (pixels) {
+		    p1 = ximage_pixels;
+		    p2 = pixels;
+		    for (a = 0; a < image->ncolors; a++, p1++)
+			if (a != mask_pixel)
+			    *p2++ = *p1;
+		    attributes->pixels = pixels;
+		} else {
+		    /* if error just say we can't return requested data */
+		    attributes->valuemask &= ~XpmReturnPixels;
+/* 3.2 backward compatibility code */
+		    attributes->valuemask &= ~XpmReturnInfos;
+/* end 3.2 bc */
+		    attributes->pixels = NULL;
+		    attributes->npixels = 0;
+		}
+		XpmFree(ximage_pixels);
+	    } else {
+		attributes->pixels = ximage_pixels;
+		attributes->npixels = image->ncolors;
+	    }
+	    attributes->mask_pixel = mask_pixel;
+	} else
+	    XpmFree(ximage_pixels);
+    } else
+	XpmFree(ximage_pixels);
+
+    /* return created images */
+    if (image_return)
+	*image_return = ximage;
+    if (shapeimage_return)
+	*shapeimage_return = shapeimage;
+
+    return (ErrorStatus);
+}
+
+
+/*
+ * Create an XImage
+ */
+static int
+CreateXImage(Display *display, Visual *visual, unsigned int depth,
+  unsigned int width, unsigned int height, XImage **image_return)
+{
+    int bitmap_pad;
+
+    /* first get bitmap_pad */
+    if (depth > 16)
+	bitmap_pad = 32;
+    else if (depth > 8)
+	bitmap_pad = 16;
+    else
+	bitmap_pad = 8;
+
+    /* then create the XImage with data = NULL and bytes_per_line = 0 */
+    *image_return = XCreateImage(display, visual, depth, ZPixmap, 0, 0,
+				 width, height, bitmap_pad, 0);
+    if (!*image_return)
+	return (XpmNoMemory);
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    /* now that bytes_per_line must have been set properly alloc data */
+    (*image_return)->data =
+	(char *) XpmMallocA((*image_return)->bytes_per_line * height);
+
+    if (!(*image_return)->data) {
+	XDestroyImage(*image_return);
+	*image_return = NULL;
+	return (XpmNoMemory);
+    }
+#else
+    /* under FOR_MSW XCreateImage has done it all */
+#endif
+    return (XpmSuccess);
+}
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+/*
+ * The functions below are written from X11R5 MIT's code (XImUtil.c)
+ *
+ * The idea is to have faster functions than the standard XPutPixel function
+ * to build the image data. Indeed we can speed up things by suppressing tests
+ * performed for each pixel. We do the same tests but at the image level.
+ * We also assume that we use only ZPixmap images with null offsets.
+ */
+
+LFUNC(_putbits, void, (register char *src, int dstoffset,
+		       register int numbits, register char *dst));
+
+LFUNC(_XReverse_Bytes, int, (register unsigned char *bpt, register int nb));
+
+static unsigned char Const _reverse_byte[0x100] = {
+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
+};
+
+static int
+_XReverse_Bytes(register unsigned char *bpt, register int nb)
+{
+    do {
+	*bpt = _reverse_byte[*bpt];
+	bpt++;
+    } while (--nb > 0);
+    return 0;
+}
+
+
+void
+xpm_xynormalizeimagebits(register unsigned char *bp, register XImage *img)
+{
+    register unsigned char c;
+
+    if (img->byte_order != img->bitmap_bit_order) {
+	switch (img->bitmap_unit) {
+
+	case 16:
+	    c = *bp;
+	    *bp = *(bp + 1);
+	    *(bp + 1) = c;
+	    break;
+
+	case 32:
+	    c = *(bp + 3);
+	    *(bp + 3) = *bp;
+	    *bp = c;
+	    c = *(bp + 2);
+	    *(bp + 2) = *(bp + 1);
+	    *(bp + 1) = c;
+	    break;
+	}
+    }
+    if (img->bitmap_bit_order == MSBFirst)
+	_XReverse_Bytes(bp, img->bitmap_unit >> 3);
+}
+
+void
+xpm_znormalizeimagebits(register unsigned char *bp, register XImage *img)
+{
+    register unsigned char c;
+
+    switch (img->bits_per_pixel) {
+
+    case 2:
+	_XReverse_Bytes(bp, 1);
+	break;
+
+    case 4:
+	*bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
+	break;
+
+    case 16:
+	c = *bp;
+	*bp = *(bp + 1);
+	*(bp + 1) = c;
+	break;
+
+    case 24:
+	c = *(bp + 2);
+	*(bp + 2) = *bp;
+	*bp = c;
+	break;
+
+    case 32:
+	c = *(bp + 3);
+	*(bp + 3) = *bp;
+	*bp = c;
+	c = *(bp + 2);
+	*(bp + 2) = *(bp + 1);
+	*(bp + 1) = c;
+	break;
+    }
+}
+
+static unsigned char Const _lomask[0x09] = {
+0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
+static unsigned char Const _himask[0x09] = {
+0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
+
+static void
+_putbits(register char *src, int dstoffset, register int numbits, register char *dst)
+
+/*    register char *src; */			/* address of source bit string */
+/*    int dstoffset; */			/* bit offset into destination;
+					 * range is 0-31 */
+/*    register int numbits; */		/* number of bits to copy to
+					 * destination */
+/*    register char *dst; */			/* address of destination bit string */
+{
+    register unsigned char chlo, chhi;
+    int hibits;
+
+    dst = dst + (dstoffset >> 3);
+    dstoffset = dstoffset & 7;
+    hibits = 8 - dstoffset;
+    chlo = *dst & _lomask[dstoffset];
+    for (;;) {
+	chhi = (*src << dstoffset) & _himask[dstoffset];
+	if (numbits <= hibits) {
+	    chhi = chhi & _lomask[dstoffset + numbits];
+	    *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
+	    break;
+	}
+	*dst = chhi | chlo;
+	dst++;
+	numbits = numbits - hibits;
+	chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
+	src++;
+	if (numbits <= dstoffset) {
+	    chlo = chlo & _lomask[numbits];
+	    *dst = (*dst & _himask[numbits]) | chlo;
+	    break;
+	}
+	numbits = numbits - dstoffset;
+    }
+}
+
+/*
+ * Default method to write pixels into a Z image data structure.
+ * The algorithm used is:
+ *
+ *	copy the destination bitmap_unit or Zpixel to temp
+ *	normalize temp if needed
+ *	copy the pixel bits into the temp
+ *	renormalize temp if needed
+ *	copy the temp back into the destination image data
+ */
+
+static void
+SetImagePixels(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
+{
+    register char *src;
+    register char *dst;
+    register unsigned int *iptr;
+    register int x, y, i;
+    register char *data;
+    Pixel pixel, px;
+    int nbytes, depth, ibu, ibpp;
+
+    data = image->data;
+    iptr = pixelindex;
+    depth = image->depth;
+    if (depth == 1) {
+	ibu = image->bitmap_unit;
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		pixel = pixels[*iptr];
+		for (i = 0, px = pixel; i < sizeof(unsigned long);
+		     i++, px >>= 8)
+		    ((unsigned char *) &pixel)[i] = px;
+		src = &data[XYINDEX(x, y, image)];
+		dst = (char *) &px;
+		px = 0;
+		nbytes = ibu >> 3;
+		for (i = nbytes; --i >= 0;)
+		    *dst++ = *src++;
+		XYNORMALIZE(&px, image);
+		_putbits((char *) &pixel, (x % ibu), 1, (char *) &px);
+		XYNORMALIZE(&px, image);
+		src = (char *) &px;
+		dst = &data[XYINDEX(x, y, image)];
+		for (i = nbytes; --i >= 0;)
+		    *dst++ = *src++;
+	    }
+    } else {
+	ibpp = image->bits_per_pixel;
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		pixel = pixels[*iptr];
+		if (depth == 4)
+		    pixel &= 0xf;
+		for (i = 0, px = pixel; i < sizeof(unsigned long); i++,
+		     px >>= 8)
+		    ((unsigned char *) &pixel)[i] = px;
+		src = &data[ZINDEX(x, y, image)];
+		dst = (char *) &px;
+		px = 0;
+		nbytes = (ibpp + 7) >> 3;
+		for (i = nbytes; --i >= 0;)
+		    *dst++ = *src++;
+		ZNORMALIZE(&px, image);
+		_putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
+		ZNORMALIZE(&px, image);
+		src = (char *) &px;
+		dst = &data[ZINDEX(x, y, image)];
+		for (i = nbytes; --i >= 0;)
+		    *dst++ = *src++;
+	    }
+    }
+}
+
+/*
+ * write pixels into a 32-bits Z image data structure
+ */
+
+#ifndef WORD64
+/* this item is static but deterministic so let it slide; doesn't
+ * hurt re-entrancy of this library. Note if it is actually const then would
+ * be OK under rules of ANSI-C but probably not C++ which may not
+ * want to allocate space for it.
+ */
+static unsigned long /* constant */ RTXpm_byteorderpixel = MSBFirst << 24;
+
+#endif
+
+/*
+   WITHOUT_SPEEDUPS is a flag to be turned on if you wish to use the original
+   3.2e code - by default you get the speeded-up version.
+*/
+
+static void
+SetImagePixels32(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
+{
+    unsigned char *data;
+    unsigned int *iptr;
+    int y;
+    Pixel pixel;
+
+#ifdef WITHOUT_SPEEDUPS
+
+    int x;
+    unsigned char *addr;
+
+    data = (unsigned char *) image->data;
+    iptr = pixelindex;
+#ifndef WORD64
+    if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) {
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		*((unsigned long *) addr) = pixels[*iptr];
+	    }
+    } else
+#endif
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		pixel = pixels[*iptr];
+		addr[0] = pixel >> 24;
+		addr[1] = pixel >> 16;
+		addr[2] = pixel >> 8;
+		addr[3] = pixel;
+	    }
+    else
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		pixel = pixels[*iptr];
+		addr[0] = pixel;
+		addr[1] = pixel >> 8;
+		addr[2] = pixel >> 16;
+		addr[3] = pixel >> 24;
+	    }
+
+#else  /* WITHOUT_SPEEDUPS */
+
+    int bpl = image->bytes_per_line;
+    unsigned char *data_ptr, *max_data;
+
+    data = (unsigned char *) image->data;
+    iptr = pixelindex;
+#ifndef WORD64
+    if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) {
+	for (y = 0; y < height; y++) {
+	    data_ptr = data;
+	    max_data = data_ptr + (width << 2);
+
+	    while (data_ptr < max_data) {
+		*((unsigned long *) data_ptr) = pixels[*(iptr++)];
+		data_ptr += (1 << 2);
+	    }
+	    data += bpl;
+	}
+    } else
+#endif
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++) {
+	    data_ptr = data;
+	    max_data = data_ptr + (width << 2);
+
+	    while (data_ptr < max_data) {
+		pixel = pixels[*(iptr++)];
+
+		*data_ptr++ = pixel >> 24;
+		*data_ptr++ = pixel >> 16;
+		*data_ptr++ = pixel >> 8;
+		*data_ptr++ = pixel;
+
+	    }
+	    data += bpl;
+	}
+    else
+	for (y = 0; y < height; y++) {
+	    data_ptr = data;
+	    max_data = data_ptr + (width << 2);
+
+	    while (data_ptr < max_data) {
+		pixel = pixels[*(iptr++)];
+
+		*data_ptr++ = pixel;
+		*data_ptr++ = pixel >> 8;
+		*data_ptr++ = pixel >> 16;
+		*data_ptr++ = pixel >> 24;
+	    }
+	    data += bpl;
+	}
+
+#endif /* WITHOUT_SPEEDUPS */
+}
+
+/*
+ * write pixels into a 16-bits Z image data structure
+ */
+
+static void
+SetImagePixels16(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
+{
+    unsigned char *data;
+    unsigned int *iptr;
+    int y;
+
+#ifdef WITHOUT_SPEEDUPS
+
+    int x;
+    unsigned char *addr;
+
+    data = (unsigned char *) image->data;
+    iptr = pixelindex;
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX16(x, y, image)];
+		addr[0] = pixels[*iptr] >> 8;
+		addr[1] = pixels[*iptr];
+	    }
+    else
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX16(x, y, image)];
+		addr[0] = pixels[*iptr];
+		addr[1] = pixels[*iptr] >> 8;
+	    }
+
+#else  /* WITHOUT_SPEEDUPS */
+
+    Pixel pixel;
+
+    int bpl = image->bytes_per_line;
+    unsigned char *data_ptr, *max_data;
+
+    data = (unsigned char *) image->data;
+    iptr = pixelindex;
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++) {
+	    data_ptr = data;
+	    max_data = data_ptr + (width << 1);
+
+	    while (data_ptr < max_data) {
+		pixel = pixels[*(iptr++)];
+
+		data_ptr[0] = pixel >> 8;
+		data_ptr[1] = pixel;
+
+		data_ptr += (1 << 1);
+	    }
+	    data += bpl;
+	}
+    else
+	for (y = 0; y < height; y++) {
+	    data_ptr = data;
+	    max_data = data_ptr + (width << 1);
+
+	    while (data_ptr < max_data) {
+		pixel = pixels[*(iptr++)];
+
+		data_ptr[0] = pixel;
+		data_ptr[1] = pixel >> 8;
+
+		data_ptr += (1 << 1);
+	    }
+	    data += bpl;
+	}
+
+#endif /* WITHOUT_SPEEDUPS */
+}
+
+/*
+ * write pixels into a 8-bits Z image data structure
+ */
+
+static void
+SetImagePixels8(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
+{
+    char *data;
+    unsigned int *iptr;
+    int y;
+
+#ifdef WITHOUT_SPEEDUPS
+
+    int x;
+
+    data = image->data;
+    iptr = pixelindex;
+    for (y = 0; y < height; y++)
+	for (x = 0; x < width; x++, iptr++)
+	    data[ZINDEX8(x, y, image)] = pixels[*iptr];
+
+#else  /* WITHOUT_SPEEDUPS */
+
+    int bpl = image->bytes_per_line;
+    char *data_ptr, *max_data;
+
+    data = image->data;
+    iptr = pixelindex;
+
+    for (y = 0; y < height; y++) {
+	data_ptr = data;
+	max_data = data_ptr + width;
+
+	while (data_ptr < max_data)
+	    *(data_ptr++) = pixels[*(iptr++)];
+
+	data += bpl;
+    }
+
+#endif /* WITHOUT_SPEEDUPS */
+}
+
+/*
+ * write pixels into a 1-bit depth image data structure and **offset null**
+ */
+
+static void
+SetImagePixels1(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)
+{
+    if (image->byte_order != image->bitmap_bit_order)
+	SetImagePixels(image, width, height, pixelindex, pixels);
+    else {
+	unsigned int *iptr;
+	int y;
+	char *data;
+
+#ifdef WITHOUT_SPEEDUPS
+
+	int x;
+
+	data = image->data;
+	iptr = pixelindex;
+	if (image->bitmap_bit_order == MSBFirst)
+	    for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++, iptr++) {
+		    if (pixels[*iptr] & 1)
+			data[ZINDEX1(x, y, image)] |= 0x80 >> (x & 7);
+		    else
+			data[ZINDEX1(x, y, image)] &= ~(0x80 >> (x & 7));
+		}
+	else
+	    for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++, iptr++) {
+		    if (pixels[*iptr] & 1)
+			data[ZINDEX1(x, y, image)] |= 1 << (x & 7);
+		    else
+			data[ZINDEX1(x, y, image)] &= ~(1 << (x & 7));
+		}
+
+#else  /* WITHOUT_SPEEDUPS */
+
+	char value;
+	char *data_ptr, *max_data;
+	int bpl = image->bytes_per_line;
+	int diff, count;
+
+	data = image->data;
+	iptr = pixelindex;
+
+	diff = width & 7;
+	width >>= 3;
+
+	if (image->bitmap_bit_order == MSBFirst)
+	    for (y = 0; y < height; y++) {
+		data_ptr = data;
+		max_data = data_ptr + width;
+		while (data_ptr < max_data) {
+		    value = 0;
+
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+		    value = (value << 1) | (pixels[*(iptr++)] & 1);
+
+		    *(data_ptr++) = value;
+		}
+		if (diff) {
+		    value = 0;
+		    for (count = 0; count < diff; count++) {
+			if (pixels[*(iptr++)] & 1)
+			    value |= (0x80 >> count);
+		    }
+		    *(data_ptr) = value;
+		}
+		data += bpl;
+	    }
+	else
+	    for (y = 0; y < height; y++) {
+		data_ptr = data;
+		max_data = data_ptr + width;
+		while (data_ptr < max_data) {
+		    value = 0;
+		    iptr += 8;
+
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+		    value = (value << 1) | (pixels[*(--iptr)] & 1);
+
+		    iptr += 8;
+		    *(data_ptr++) = value;
+		}
+		if (diff) {
+		    value = 0;
+		    for (count = 0; count < diff; count++) {
+			if (pixels[*(iptr++)] & 1)
+			    value |= (1 << count);
+		    }
+		    *(data_ptr) = value;
+		}
+		data += bpl;
+	    }
+
+#endif /* WITHOUT_SPEEDUPS */
+    }
+}
+
+int
+XpmCreatePixmapFromXpmImage(Display *display, Drawable d, XpmImage *image,
+			    Pixmap *pixmap_return, Pixmap *shapemask_return, XpmAttributes *attributes)
+{
+    XImage *ximage, *shapeimage;
+    int ErrorStatus;
+
+    /* initialize return values */
+    if (pixmap_return)
+	*pixmap_return = 0;
+    if (shapemask_return)
+	*shapemask_return = 0;
+
+    /* create the ximages */
+    ErrorStatus = XpmCreateImageFromXpmImage(display, image,
+					     (pixmap_return ? &ximage : NULL),
+					     (shapemask_return ?
+					      &shapeimage : NULL),
+					     attributes);
+    if (ErrorStatus < 0)
+	return (ErrorStatus);
+
+    /* create the pixmaps and destroy images */
+    if (pixmap_return && ximage) {
+	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
+	XDestroyImage(ximage);
+    }
+    if (shapemask_return && shapeimage) {
+	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
+	XDestroyImage(shapeimage);
+    }
+    return (ErrorStatus);
+}
+
+#else  /* FOR_MSW, FOR_MAC part follows */
+#ifdef FOR_MSW
+static void
+MSWSetImagePixels(Display *dc, XImage *image, unsigned int width, unsigned int height,
+  unsigned int *pixelindex, Pixel *pixels)
+{
+    unsigned int *data = pixelindex;
+    unsigned int x, y;
+    SelectObject(*dc, image->bitmap);
+    for (y = 0; y < height; y++) {
+	for (x = 0; x < width; x++) {
+	    SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */
+	}
+    }
+}
+#endif
+
+#ifdef FOR_MAC 
+/* Copy the pixels into the GWorld PixMap */
+static void
+MACSetImagePixels(Display *dc, XImage *image, unsigned int width, unsigned int height,
+  unsigned int *pixelindex, Pixel *pixels)
+{
+    unsigned int *data = pixelindex;
+    unsigned int x, y;
+	GDHandle savegd;
+	CGrafPtr saveport;
+	QDErr err;
+	GWorldPtr	newGWorld;
+	Rect	bounds;
+	Pixel 	apix;
+	RGBColor thePixel;
+	SetRect(&bounds, 0, 0, height, width); // CJC correct order?
+	GetGWorld(&saveport, &savegd);
+	SetGWorld(image->bitmap, 0);
+	switch (image->depth) {
+	case 1:
+	case 2:
+	case 8:
+	case 16:
+	case 32:
+	    for (y = 0; y < height; y++) {
+			for (x = 0; x < width; x++) {
+				apix = pixels[*(data++)];
+				thePixel.red = (apix >> 8) & 0xFF00;
+				thePixel.green = apix  & 0xFF00;
+				thePixel.blue = (apix << 8) & 0xFF00;
+			    SetCPixel(x, y, &thePixel); 
+			}
+	    }
+    }
+	// Restore GWorld
+	SetGWorld(saveport, savegd);
+}
+#endif /* FOR_MAC */
+#endif /* FOR_MSW , FOR_MAC */
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrbuf.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrbuf.c
new file mode 100644
index 0000000..62827b8
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrbuf.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrIFrBuf.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an Xpm buffer (file in memory) and create the image and possibly its *
+*  mask                                                                       *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+int
+XpmCreateImageFromBuffer(Display *display, char *buffer, XImage **image_return,
+			 XImage **shapeimage_return, XpmAttributes *attributes)
+{
+    XpmImage image;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* create an XpmImage from the buffer */
+    if (attributes) {
+	xpmInitAttributes(attributes);
+	xpmSetInfoMask(&info, attributes);
+	ErrorStatus = XpmCreateXpmImageFromBuffer(buffer, &image, &info);
+    } else
+	ErrorStatus = XpmCreateXpmImageFromBuffer(buffer, &image, NULL);
+
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the related ximages */
+    ErrorStatus = XpmCreateImageFromXpmImage(display, &image,
+					     image_return, shapeimage_return,
+					     attributes);
+    if (attributes) {
+	if (ErrorStatus >= 0)		/* no fatal error */
+	    xpmSetAttributes(attributes, &image, &info);
+	XpmFreeXpmInfo(&info);
+    }
+    /* free the XpmImage */
+    XpmFreeXpmImage(&image);
+
+    return (ErrorStatus);
+}
+
+int
+XpmCreateXpmImageFromBuffer(char *buffer, XpmImage *image, XpmInfo *info)
+{
+    xpmData mdata;
+    int ErrorStatus;
+
+    /* init returned values */
+    xpmInitXpmImage(image);
+    xpmInitXpmInfo(info);
+
+    /* open buffer to read */
+    xpmOpenBuffer(buffer, &mdata);
+
+    /* create the XpmImage from the XpmData */
+    ErrorStatus = xpmParseData(&mdata, image, info);
+
+    xpmDataClose(&mdata);
+
+    return (ErrorStatus);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrdat.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrdat.c
new file mode 100644
index 0000000..74fa265
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crifrdat.c
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrIFrData.c:                                                             *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an Xpm array and create the image and possibly its mask              *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+int
+XpmCreateImageFromData(Display *display, char **data, XImage **image_return,
+		       XImage **shapeimage_return, XpmAttributes *attributes)
+{
+    XpmImage image;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* create an XpmImage from the file */
+    if (attributes) {
+	xpmInitAttributes(attributes);
+	xpmSetInfoMask(&info, attributes);
+	ErrorStatus = XpmCreateXpmImageFromData(data, &image, &info);
+    } else
+	ErrorStatus = XpmCreateXpmImageFromData(data, &image, NULL);
+
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the related ximages */
+    ErrorStatus = XpmCreateImageFromXpmImage(display, &image,
+					     image_return, shapeimage_return,
+					     attributes);
+    if (attributes) {
+	if (ErrorStatus >= 0)		/* no fatal error */
+	    xpmSetAttributes(attributes, &image, &info);
+	XpmFreeXpmInfo(&info);
+    }
+    XpmFreeXpmImage(&image);
+
+    return (ErrorStatus);
+}
+
+int
+XpmCreateXpmImageFromData(char **data, XpmImage *image, XpmInfo *info)
+{
+    xpmData mdata;
+    int ErrorStatus;
+
+    /* init returned values */
+    xpmInitXpmImage(image);
+    xpmInitXpmInfo(info);
+
+    /* open data */
+    xpmOpenArray(data, &mdata);
+
+    /* create the XpmImage from the XpmData */
+    ErrorStatus = xpmParseData(&mdata, image, info);
+
+    xpmDataClose(&mdata);
+
+    return (ErrorStatus);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrbuf.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrbuf.c
new file mode 100644
index 0000000..a709962
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrbuf.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrPFrBuf.c:                                                              *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an Xpm buffer and create the pixmap and possibly its mask            *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+#include "xpm34p.h"
+
+int
+XpmCreatePixmapFromBuffer(Display *display, Drawable d, char *buffer, Pixmap *pixmap_return,
+			  Pixmap *shapemask_return, XpmAttributes *attributes)
+{
+    XImage *ximage, *shapeimage;
+    int ErrorStatus;
+
+    /* initialize return values */
+    if (pixmap_return)
+	*pixmap_return = 0;
+    if (shapemask_return)
+	*shapemask_return = 0;
+
+    /* create the images */
+    ErrorStatus = XpmCreateImageFromBuffer(display, buffer,
+					   (pixmap_return ? &ximage : NULL),
+					   (shapemask_return ?
+					    &shapeimage : NULL),
+					   attributes);
+
+    if (ErrorStatus < 0)		/* fatal error */
+	return (ErrorStatus);
+
+    /* create the pixmaps and destroy images */
+    if (pixmap_return && ximage) {
+	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
+	XDestroyImage(ximage);
+    }
+    if (shapemask_return && shapeimage) {
+	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
+	XDestroyImage(shapeimage);
+    }
+    return (ErrorStatus);
+}
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrdat.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrdat.c
new file mode 100644
index 0000000..2569e26
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/crpfrdat.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmCrPFrData.c:                                                             *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an Xpm array and create the pixmap and possibly its mask             *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+int
+XpmCreatePixmapFromData(Display *display, Drawable d, char **data, Pixmap *pixmap_return,
+			Pixmap *shapemask_return, XpmAttributes *attributes)
+{
+    XImage *ximage, *shapeimage;
+    int ErrorStatus;
+
+    /* initialize return values */
+    if (pixmap_return)
+	*pixmap_return = 0;
+    if (shapemask_return)
+	*shapemask_return = 0;
+
+    /* create the images */
+    ErrorStatus = XpmCreateImageFromData(display, data,
+					 (pixmap_return ? &ximage : NULL),
+					 (shapemask_return ?
+					  &shapeimage : NULL),
+					 attributes);
+
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    if (ErrorStatus < 0)		/* fatal error */
+	return (ErrorStatus);
+
+    /* create the pixmaps and destroy images */
+    if (pixmap_return && ximage) {
+	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
+	XDestroyImage(ximage);
+    }
+    if (shapemask_return && shapeimage) {
+	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
+	XDestroyImage(shapeimage);
+    }
+    return (ErrorStatus);
+}
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/data.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/data.c
new file mode 100644
index 0000000..9880e37
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/data.c
@@ -0,0 +1,630 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* data.c:                                                                     *
+*                                                                             *
+*  XPM library                                                                *
+*  IO utilities                                                               *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/* Official version number */
+static char *RCS_Version = "$XpmVersion: 3.4b $";
+
+/* Internal version number */
+static char *RCS_Id = "$Id: xpm.shar,v 3.30 1994/05/24 14:00:41 lehors Exp $";
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:stat.h"
+#include "sys$library:ctype.h"
+#elif defined(FOR_MAC) && !defined(GUSI)
+#include <stat.h>
+#include <ctype.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#endif
+
+#include <string.h>
+
+LFUNC(ParseComment, int, (xpmData * mdata));
+
+static int
+ParseComment(xpmData *mdata)
+{
+    if (mdata->type == XPMBUFFER) {
+	register char c;
+	register unsigned int n = 0;
+	unsigned int notend;
+	char *s, *s2;
+
+	s = mdata->Comment;
+	*s = mdata->Bcmt[0];
+
+	/* skip the string beginning comment */
+	s2 = mdata->Bcmt;
+	do {
+	    c = *mdata->cptr++;
+	    *++s = c;
+	    n++;
+	    s2++;
+	} while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
+
+	if (*s2 != '\0') {
+	    /* this wasn't the beginning of a comment */
+	    mdata->cptr -= n;
+	    return 0;
+	}
+	/* store comment */
+	mdata->Comment[0] = *s;
+	s = mdata->Comment;
+	notend = 1;
+	n = 0;
+	while (notend) {
+	    s2 = mdata->Ecmt;
+	    while (*s != *s2 && c && c != mdata->Bos) {
+		c = *mdata->cptr++;
+		*++s = c;
+		n++;
+	    }
+	    mdata->CommentLength = n;
+	    do {
+		c = *mdata->cptr++;
+		n++;
+		*++s = c;
+		s2++;
+	    } while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
+	    if (*s2 == '\0') {
+		/* this is the end of the comment */
+		notend = 0;
+		mdata->cptr--;
+	    }
+	}
+	return 0;
+    } else {
+	FILE *file = mdata->stream.file;
+	register int c;
+	register unsigned int n = 0, a;
+	unsigned int notend;
+	char *s, *s2;
+
+	s = mdata->Comment;
+	*s = mdata->Bcmt[0];
+
+	/* skip the string beginning comment */
+	s2 = mdata->Bcmt;
+	do {
+	    c = getc(file);
+	    *++s = c;
+	    n++;
+	    s2++;
+	} while (c == *s2 && *s2 != '\0'
+		 && c != EOF && c != mdata->Bos);
+
+	if (*s2 != '\0') {
+	    /* this wasn't the beginning of a comment */
+	    /* put characters back in the order that we got them */
+	    for (a = n; a > 0; a--, s--)
+		ungetc(*s, file);
+	    return 0;
+	}
+	/* store comment */
+	mdata->Comment[0] = *s;
+	s = mdata->Comment;
+	notend = 1;
+	n = 0;
+	while (notend) {
+	    s2 = mdata->Ecmt;
+	    while (*s != *s2 && c != EOF && c != mdata->Bos) {
+		c = getc(file);
+		*++s = c;
+		n++;
+	    }
+	    mdata->CommentLength = n;
+	    do {
+		c = getc(file);
+		n++;
+		*++s = c;
+		s2++;
+	    } while (c == *s2 && *s2 != '\0'
+		     && c != EOF && c != mdata->Bos);
+	    if (*s2 == '\0') {
+		/* this is the end of the comment */
+		notend = 0;
+		ungetc(*s, file);
+	    }
+	}
+	return 0;
+    }
+}
+
+/*
+ * skip to the end of the current string and the beginning of the next one
+ */
+int
+xpmNextString(xpmData *mdata)
+{
+    if (!mdata->type)
+	mdata->cptr = (mdata->stream.data)[++mdata->line];
+    else if (mdata->type == XPMBUFFER) {
+	register char c;
+
+	/* get to the end of the current string */
+	if (mdata->Eos)
+	    while ((c = *mdata->cptr++) && c != mdata->Eos);
+
+	/*
+	 * then get to the beginning of the next string looking for possible
+	 * comment
+	 */
+	if (mdata->Bos) {
+	    while ((c = *mdata->cptr++) && c != mdata->Bos)
+		if (mdata->Bcmt && c == mdata->Bcmt[0])
+		    ParseComment(mdata);
+	} else if (mdata->Bcmt) {	/* XPM2 natural */
+	    while ((c = *mdata->cptr++) == mdata->Bcmt[0])
+		ParseComment(mdata);
+	    mdata->cptr--;
+	}
+    } else {
+	register int c;
+	FILE *file = mdata->stream.file;
+
+	/* get to the end of the current string */
+	if (mdata->Eos)
+	    while ((c = getc(file)) != mdata->Eos && c != EOF);
+
+	/*
+	 * then get to the beginning of the next string looking for possible
+	 * comment
+	 */
+	if (mdata->Bos) {
+	    while ((c = getc(file)) != mdata->Bos && c != EOF)
+		if (mdata->Bcmt && c == mdata->Bcmt[0])
+		    ParseComment(mdata);
+
+	} else if (mdata->Bcmt) {	/* XPM2 natural */
+	    while ((c = getc(file)) == mdata->Bcmt[0])
+		ParseComment(mdata);
+	    ungetc(c, file);
+	}
+    }
+    return 0;
+}
+
+
+/*
+ * skip whitespace and compute the following unsigned int,
+ * returns 1 if one is found and 0 if not
+ */
+int
+xpmNextUI(xpmData *mdata, unsigned int *ui_return)
+{
+    char buf[BUFSIZ];
+    int l;
+
+    l = xpmNextWord(mdata, buf, BUFSIZ);
+    return atoui(buf, l, ui_return);
+}
+
+/*
+ * skip whitespace and return the following word
+ */
+unsigned int
+xpmNextWord(xpmData *mdata, char *buf, unsigned int buflen)
+{
+    register unsigned int n = 0;
+    int c;
+
+    if (!mdata->type || mdata->type == XPMBUFFER) {
+	while (isspace(c = *mdata->cptr) && c != mdata->Eos)
+	    mdata->cptr++;
+	do {
+	    c = *mdata->cptr++;
+	    *buf++ = c;
+	    n++;
+	} while (!isspace(c) && c != mdata->Eos && n < buflen);
+	n--;
+	mdata->cptr--;
+    } else {
+	FILE *file = mdata->stream.file;
+
+	while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
+	while (!isspace(c) && c != mdata->Eos && c != EOF && n < buflen) {
+	    *buf++ = c;
+	    n++;
+	    c = getc(file);
+	}
+	ungetc(c, file);
+    }
+    return (n);
+}
+
+/*
+ * return end of string - WARNING: malloc!
+ */
+int
+xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
+{
+    unsigned int i, n = 0;
+    int c;
+    char *p, *q, buf[BUFSIZ];
+
+    if (!mdata->type || mdata->type == XPMBUFFER) {
+	if (mdata->cptr) {
+	    char *start;
+
+	    while (isspace(c = *mdata->cptr) && c != mdata->Eos)
+		mdata->cptr++;
+	    start = mdata->cptr;
+	    while ((c = *mdata->cptr) && c != mdata->Eos)
+		mdata->cptr++;
+	    n = mdata->cptr - start + 1;
+	    p = (char *) XpmMallocA(n);
+	    if (!p)
+		return (XpmNoMemory);
+	    strncpy(p, start, n);
+	    if (mdata->type)		/* XPMBUFFER */
+		p[n - 1] = '\0';
+	}
+    } else {
+	FILE *file = mdata->stream.file;
+
+	while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
+	if (c == EOF)
+	    return (XpmFileInvalid);
+	p = NULL;
+	i = 0;
+	q = buf;
+	p = (char *) XpmMallocA(1);
+	while (c != mdata->Eos && c != EOF) {
+	    if (i == BUFSIZ) {
+		/* get to the end of the buffer */
+		/* malloc needed memory */
+		q = (char *) XpmReallocA(p, n + i);
+		if (!q) {
+		    XpmFree(p);
+		    return (XpmNoMemory);
+		}
+		p = q;
+		q += n;
+		/* and copy what we already have */
+		strncpy(q, buf, i);
+		n += i;
+		i = 0;
+		q = buf;
+	    }
+	    *q++ = c;
+	    i++;
+	    c = getc(file);
+	}
+	if (c == EOF) {
+	    XpmFree(p);
+	    return (XpmFileInvalid);
+	}
+	if (n + i != 0) {
+	    /* malloc needed memory */
+	    q = (char *) XpmReallocA(p, n + i + 1);
+	    if (!q) {
+		XpmFree(p);
+		return (XpmNoMemory);
+	    }
+	    p = q;
+	    q += n;
+	    /* and copy the buffer */
+	    strncpy(q, buf, i);
+	    n += i;
+	    p[n++] = '\0';
+	} else {
+	    *p = '\0';
+	    n = 1;
+	}
+	ungetc(c, file);
+    }
+    *sptr = p;
+    *l = n;
+    return (XpmSuccess);
+}
+
+/*
+ * get the current comment line
+ */
+int
+xpmGetCmt(xpmData *mdata, char **cmt)
+{
+    if (!mdata->type)
+	*cmt = NULL;
+    else if (mdata->CommentLength) {
+	*cmt = (char *) XpmMallocA(mdata->CommentLength + 1);
+	strncpy(*cmt, mdata->Comment, mdata->CommentLength);
+	(*cmt)[mdata->CommentLength] = '\0';
+	mdata->CommentLength = 0;
+    } else
+	*cmt = NULL;
+    return 0;
+}
+
+/*
+ * open the given file to be read as an xpmData which is returned.
+ */
+int
+xpmReadFile(char *filename, xpmData *mdata)
+{
+#ifdef ZPIPE
+    char *compressfile, buf[BUFSIZ];
+    struct stat status;
+
+#endif
+
+    if (!filename) {
+	mdata->stream.file = (stdin);
+	mdata->type = XPMFILE;
+    } else {
+#ifdef ZPIPE
+	if (((int) strlen(filename) > 2) &&
+	    !strcmp(".Z", filename + (strlen(filename) - 2))) {
+	    mdata->type = XPMPIPE;
+	    sprintf(buf, "uncompress -c %s", filename);
+	    if (!(mdata->stream.file = popen(buf, "r")))
+		return (XpmOpenFailed);
+
+	} else if (((int) strlen(filename) > 3) &&
+		   !strcmp(".gz", filename + (strlen(filename) - 3))) {
+	    mdata->type = XPMPIPE;
+	    sprintf(buf, "gunzip -qc %s", filename);
+	    if (!(mdata->stream.file = popen(buf, "r")))
+		return (XpmOpenFailed);
+
+	} else {
+	    if (!(compressfile = (char *) XpmMallocA(strlen(filename) + 4)))
+		return (XpmNoMemory);
+
+	    strcpy(compressfile, filename);
+	    strcat(compressfile, ".Z");
+	    if (!stat(compressfile, &status)) {
+		sprintf(buf, "uncompress -c %s", compressfile);
+		if (!(mdata->stream.file = popen(buf, "r"))) {
+		    XpmFree(compressfile);
+		    return (XpmOpenFailed);
+		}
+		mdata->type = XPMPIPE;
+	    } else {
+		strcpy(compressfile, filename);
+		strcat(compressfile, ".gz");
+		if (!stat(compressfile, &status)) {
+		    sprintf(buf, "gunzip -c %s", compressfile);
+		    if (!(mdata->stream.file = popen(buf, "r"))) {
+			XpmFree(compressfile);
+			return (XpmOpenFailed);
+		    }
+		    mdata->type = XPMPIPE;
+		} else {
+#endif
+		    if (!(mdata->stream.file = fopen(filename, "r"))) {
+#ifdef ZPIPE
+			XpmFree(compressfile);
+#endif
+			return (XpmOpenFailed);
+		    }
+		    mdata->type = XPMFILE;
+#ifdef ZPIPE
+		}
+	    }
+	    XpmFree(compressfile);
+	}
+#endif
+    }
+    mdata->CommentLength = 0;
+    return (XpmSuccess);
+}
+
+/*
+ * open the given file to be written as an xpmData which is returned
+ */
+int
+xpmWriteFile(char *filename, xpmData *mdata)
+{
+#ifdef ZPIPE
+    char buf[BUFSIZ];
+
+#endif
+
+    if (!filename) {
+	mdata->stream.file = (stdout);
+	mdata->type = XPMFILE;
+    } else {
+#ifdef ZPIPE
+	if ((int) strlen(filename) > 2
+	    && !strcmp(".Z", filename + (strlen(filename) - 2))) {
+	    sprintf(buf, "compress > %s", filename);
+	    if (!(mdata->stream.file = popen(buf, "w")))
+		return (XpmOpenFailed);
+
+	    mdata->type = XPMPIPE;
+	} else if ((int) strlen(filename) > 3
+		   && !strcmp(".gz", filename + (strlen(filename) - 3))) {
+	    sprintf(buf, "gzip -q > %s", filename);
+	    if (!(mdata->stream.file = popen(buf, "w")))
+		return (XpmOpenFailed);
+
+	    mdata->type = XPMPIPE;
+	} else {
+#endif
+	    if (!(mdata->stream.file = fopen(filename, "w")))
+		return (XpmOpenFailed);
+
+	    mdata->type = XPMFILE;
+#ifdef ZPIPE
+	}
+#endif
+    }
+    return (XpmSuccess);
+}
+
+/*
+ * open the given array to be read or written as an xpmData which is returned
+ */
+void
+xpmOpenArray(char **data, xpmData *mdata)
+{
+    mdata->type = XPMARRAY;
+    mdata->stream.data = data;
+    mdata->cptr = *data;
+    mdata->line = 0;
+    mdata->CommentLength = 0;
+    mdata->Bcmt = mdata->Ecmt = NULL;
+    mdata->Bos = mdata->Eos = '\0';
+    mdata->format = 0;			/* this can only be Xpm 2 or 3 */
+}
+
+/*
+ * open the given buffer to be read or written as an xpmData which is returned
+ */
+void
+xpmOpenBuffer(char *buffer, xpmData *mdata)
+{
+    mdata->type = XPMBUFFER;
+    mdata->cptr = buffer;
+    mdata->CommentLength = 0;
+}
+
+/*
+ * close the file related to the xpmData if any
+ */
+int
+xpmDataClose(xpmData *mdata)
+{
+    switch (mdata->type) {
+    case XPMARRAY:
+    case XPMBUFFER:
+	break;
+    case XPMFILE:
+	if (mdata->stream.file != (stdout) && mdata->stream.file != (stdin))
+	    fclose(mdata->stream.file);
+	break;
+#ifdef ZPIPE
+    case XPMPIPE:
+	pclose(mdata->stream.file);
+	break;
+#endif
+    }
+    return 0;
+}
+
+xpmDataType xpmDataTypes[] =
+{
+    "", "!", "\n", '\0', '\n', "", "", "", "",	/* Natural type */
+    "C", "/*", "*/", '"', '"', ",\n", "static char *", "[] = {\n", "};\n",
+    "Lisp", ";", "\n", '"', '"', "\n", "(setq ", " '(\n", "))\n",
+#ifdef VMS
+    NULL
+#else
+    NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL
+#endif
+};
+
+/*
+ * parse xpm header
+ */
+int
+xpmParseHeader(xpmData *mdata)
+{
+    char buf[BUFSIZ];
+    int l, n = 0;
+
+    if (mdata->type) {
+	mdata->Bos = '\0';
+	mdata->Eos = '\n';
+	mdata->Bcmt = mdata->Ecmt = NULL;
+	l = xpmNextWord(mdata, buf, BUFSIZ);
+	if (l == 7 && !strncmp("#define", buf, 7)) {
+	    /* this maybe an XPM 1 file */
+	    char *ptr;
+
+	    l = xpmNextWord(mdata, buf, BUFSIZ);
+	    if (!l)
+		return (XpmFileInvalid);
+	    ptr = strchr(buf, '_');
+	    if (!ptr || strncmp("_format", ptr, l - (ptr - buf)))
+		return XpmFileInvalid;
+	    /* this is definitely an XPM 1 file */
+	    mdata->format = 1;
+	    n = 1;			/* handle XPM1 as mainly XPM2 C */
+	} else {
+
+	    /*
+	     * skip the first word, get the second one, and see if this is
+	     * XPM 2 or 3
+	     */
+	    l = xpmNextWord(mdata, buf, BUFSIZ);
+	    if ((l == 3 && !strncmp("XPM", buf, 3)) ||
+		(l == 4 && !strncmp("XPM2", buf, 4))) {
+		if (l == 3)
+		    n = 1;		/* handle XPM as XPM2 C */
+		else {
+		    /* get the type key word */
+		    l = xpmNextWord(mdata, buf, BUFSIZ);
+
+		    /*
+		     * get infos about this type
+		     */
+		    while (xpmDataTypes[n].type
+			   && strncmp(xpmDataTypes[n].type, buf, l))
+			n++;
+		}
+		mdata->format = 0;
+	    } else
+		/* nope this is not an XPM file */
+		return XpmFileInvalid;
+	}
+	if (xpmDataTypes[n].type) {
+	    if (n == 0) {		/* natural type */
+		mdata->Bcmt = xpmDataTypes[n].Bcmt;
+		mdata->Ecmt = xpmDataTypes[n].Ecmt;
+		xpmNextString(mdata);	/* skip the end of the headerline */
+		mdata->Bos = xpmDataTypes[n].Bos;
+		mdata->Eos = xpmDataTypes[n].Eos;
+	    } else {
+		mdata->Bcmt = xpmDataTypes[n].Bcmt;
+		mdata->Ecmt = xpmDataTypes[n].Ecmt;
+		if (!mdata->format) {	/* XPM 2 or 3 */
+		    mdata->Bos = xpmDataTypes[n].Bos;
+		    mdata->Eos = '\0';
+		    /* get to the beginning of the first string */
+		    xpmNextString(mdata);
+		    mdata->Eos = xpmDataTypes[n].Eos;
+		} else			/* XPM 1 skip end of line */
+		    xpmNextString(mdata);
+	    }
+	} else
+	    /* we don't know about that type of XPM file... */
+	    return XpmFileInvalid;
+    }
+    return XpmSuccess;
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/foo b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/foo
new file mode 100644
index 0000000..2d289fa
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/foo
@@ -0,0 +1,5 @@
+for i in *.c
+do
+echo "\$(OBJECTDIR)/$i: libxpm.34b/lib/$i"
+echo "	 \$(CC) -c \$(CPPFLAGS) -o \$@ libxpm.34b/lib/$i"
+done
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/hashtab.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/hashtab.c
new file mode 100644
index 0000000..6efa970
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/hashtab.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* hashtable.c:                                                                *
+*                                                                             *
+*  XPM library                                                                *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+*  this originaly comes from Colas Nahaboo as a part of Wool                  *
+*                                                                             *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+LFUNC(AtomMake, xpmHashAtom, (char *name, void *data));
+LFUNC(HashTableGrows, int, (xpmHashTable * table));
+
+static xpmHashAtom
+AtomMake(char *name, void *data)			/* makes an atom */
+/*    char *name; */				/* WARNING: is just pointed to */
+/*    void *data; */
+{
+    xpmHashAtom object = (xpmHashAtom) XpmMalloc(sizeof(struct _xpmHashAtom));
+
+    if (object) {
+	object->name = name;
+	object->data = data;
+    }
+    return object;
+}
+
+/************************\
+* 			 *
+*  hash table routines 	 *
+* 			 *
+\************************/
+
+/*
+ * Hash function definition:
+ * HASH_FUNCTION: hash function, hash = hashcode, hp = pointer on char,
+ *				 hash2 = temporary for hashcode.
+ * INITIAL_TABLE_SIZE in slots
+ * HASH_TABLE_GROWS how hash table grows.
+ */
+
+/* Mock lisp function */
+#define HASH_FUNCTION 	  hash = (hash << 5) - hash + *hp++;
+/* #define INITIAL_HASH_SIZE 2017 */
+#define INITIAL_HASH_SIZE 256		/* should be enough for colors */
+#define HASH_TABLE_GROWS  size = size * 2;
+
+/* aho-sethi-ullman's HPJ (sizes should be primes)*/
+#ifdef notdef
+#define HASH_FUNCTION	hash <<= 4; hash += *hp++; \
+    if(hash2 = hash & 0xf0000000) hash ^= (hash2 >> 24) ^ hash2;
+#define INITIAL_HASH_SIZE 4095		/* should be 2^n - 1 */
+#define HASH_TABLE_GROWS  size = size << 1 + 1;
+#endif
+
+/* GNU emacs function */
+/*
+#define HASH_FUNCTION 	  hash = (hash << 3) + (hash >> 28) + *hp++;
+#define INITIAL_HASH_SIZE 2017
+#define HASH_TABLE_GROWS  size = size * 2;
+*/
+
+/* end of hash functions */
+
+/*
+ * The hash table is used to store atoms via their NAME:
+ *
+ * NAME --hash--> ATOM |--name--> "foo"
+ *		       |--data--> any value which has to be stored
+ *
+ */
+
+/*
+ * xpmHashSlot gives the slot (pointer to xpmHashAtom) of a name
+ * (slot points to NULL if it is not defined)
+ *
+ */
+
+xpmHashAtom *
+xpmHashSlot(xpmHashTable *table, char *s)
+{
+    xpmHashAtom *atomTable = table->atomTable;
+    unsigned int hash;
+    xpmHashAtom *p;
+    char *hp = s;
+    char *ns;
+
+    hash = 0;
+    while (*hp) {			/* computes hash function */
+	HASH_FUNCTION
+    }
+    p = atomTable + hash % table->size;
+    while (*p) {
+	ns = (*p)->name;
+	if (ns[0] == s[0] && strcmp(ns, s) == 0)
+	    break;
+	p--;
+	if (p < atomTable)
+	    p = atomTable + table->size - 1;
+    }
+    return p;
+}
+
+static int
+HashTableGrows(xpmHashTable *table)
+{
+    xpmHashAtom *atomTable = table->atomTable;
+    int size = table->size;
+    xpmHashAtom *t, *p;
+    int i;
+    int oldSize = size;
+
+    t = atomTable;
+    HASH_TABLE_GROWS
+	table->size = size;
+    table->limit = size / 3;
+    atomTable = (xpmHashAtom *) XpmMalloc(size * sizeof(*atomTable));
+    if (!atomTable)
+	return (XpmNoMemory);
+    table->atomTable = atomTable;
+    for (p = atomTable + size; p > atomTable;)
+	*--p = NULL;
+    for (i = 0, p = t; i < oldSize; i++, p++)
+	if (*p) {
+	    xpmHashAtom *ps = xpmHashSlot(table, (*p)->name);
+
+	    *ps = *p;
+	}
+    XpmFree(t);
+    return (XpmSuccess);
+}
+
+/*
+ * xpmHashIntern(table, name, data)
+ * an xpmHashAtom is created if name doesn't exist, with the given data.
+ */
+
+int
+xpmHashIntern(xpmHashTable *table, char *tag, void *data)
+{
+    xpmHashAtom *slot;
+
+    if (!*(slot = xpmHashSlot(table, tag))) {
+	/* undefined, make a new atom with the given data */
+	if (!(*slot = AtomMake(tag, data)))
+	    return (XpmNoMemory);
+	if (table->used >= table->limit) {
+	    int ErrorStatus;
+
+	    if ((ErrorStatus = HashTableGrows(table)) != XpmSuccess)
+		return (ErrorStatus);
+	    table->used++;
+	    return (XpmSuccess);
+	}
+	table->used++;
+    }
+    return (XpmSuccess);
+}
+
+/*
+ *  must be called before allocating any atom
+ */
+
+int
+xpmHashTableInit(xpmHashTable *table)
+{
+    xpmHashAtom *p;
+    xpmHashAtom *atomTable;
+
+    table->size = INITIAL_HASH_SIZE;
+    table->limit = table->size / 3;
+    table->used = 0;
+    atomTable = (xpmHashAtom *) XpmMalloc(table->size * sizeof(*atomTable));
+    if (!atomTable)
+	return (XpmNoMemory);
+    for (p = atomTable + table->size; p > atomTable;)
+	*--p = NULL;
+    table->atomTable = atomTable;
+    return (XpmSuccess);
+}
+
+/*
+ *   frees a hashtable and all the stored atoms
+ */
+
+void
+xpmHashTableFree(xpmHashTable *table)
+{
+    xpmHashAtom *p;
+    xpmHashAtom *atomTable = table->atomTable;
+
+    for (p = atomTable + table->size; p > atomTable;)
+	if (*--p)
+	    XpmFree(*p);
+    XpmFree(atomTable);
+    table->atomTable = NULL;
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/libxpm headers.h b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/libxpm headers.h
new file mode 100644
index 0000000..46a1f4c
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/libxpm headers.h	
@@ -0,0 +1,14 @@
+/*
+ *	MacHeaders.h
+ *
+ *	Processor independant interface to the MacHeaders<xxx> files ...
+ */
+
+#if __POWERPC__
+	#include <MacHeadersPPC>
+#elif __CFM68K__
+	#include <MacHeadersCFM68K>
+#else
+	#include <MacHeaders68K>
+#endif
+#define FOR_MAC
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/miscellaneous.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/miscellaneous.c
new file mode 100644
index 0000000..77707e4
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/miscellaneous.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* misc.c:                                                                     *
+*                                                                             *
+*  XPM library                                                                *
+*  Miscellaneous utilities                                                    *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+ 
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:stat.h"
+#include "sys$library:fcntl.h"
+#elif defined(FOR_MAC) &!defined(GUSI)
+#include <stat.h>
+#include <stdio.h>
+#include <unix.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#ifdef FOR_MSW
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#endif
+
+/* 3.2 backward compatibility code */
+LFUNC(CreateOldColorTable, int, (XpmColor *ct, int ncolors,
+				 XpmColor ***oldct));
+
+LFUNC(FreeOldColorTable, void, (XpmColor **colorTable, int ncolors));
+
+/*
+ * Create a colortable compatible with the old style colortable
+ */
+static int
+CreateOldColorTable(XpmColor *ct, int ncolors, XpmColor ***oldct)
+{
+    XpmColor **colorTable, **color;
+    int a;
+
+    colorTable = (XpmColor **) XpmMalloc(ncolors * sizeof(XpmColor *));
+    if (!colorTable) {
+	*oldct = NULL;
+	return (XpmNoMemory);
+    }
+    for (a = 0, color = colorTable; a < ncolors; a++, color++, ct++)
+	*color = ct;
+    *oldct = colorTable;
+    return (XpmSuccess);
+}
+
+static void
+FreeOldColorTable(XpmColor **colorTable, int ncolors)
+{
+    int a, b;
+    XpmColor **color;
+    char **sptr;
+
+    if (colorTable) {
+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
+	    for (b = 0, sptr = (char **) *color; b <= NKEYS; b++, sptr++)
+		if (*sptr)
+		    XpmFree(*sptr);
+	}
+	XpmFree(*colorTable);
+	XpmFree(colorTable);
+    }
+}
+
+/* end 3.2 bc */
+
+
+/*
+ * Free the computed color table
+ */
+void
+xpmFreeColorTable(XpmColor *colorTable, int ncolors)
+{
+    int a, b;
+    XpmColor *color;
+    char **sptr;
+
+    if (colorTable) {
+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
+	    for (b = 0, sptr = (char **) color; b <= NKEYS; b++, sptr++)
+		if (*sptr)
+		    XpmFree(*sptr);
+	}
+	XpmFree(colorTable);
+    }
+}
+
+/*
+ * Free array of extensions
+ */
+void
+XpmFreeExtensions(XpmExtension *extensions, int nextensions)
+{
+    unsigned int i, j, nlines;
+    XpmExtension *ext;
+    char **sptr;
+
+    if (extensions) {
+	for (i = 0, ext = extensions; i < nextensions; i++, ext++) {
+	    if (ext->name)
+		XpmFree(ext->name);
+	    nlines = ext->nlines;
+	    for (j = 0, sptr = ext->lines; j < nlines; j++, sptr++)
+		if (*sptr)
+		    XpmFree(*sptr);
+	    if (ext->lines)
+		XpmFree(ext->lines);
+	}
+	XpmFree(extensions);
+    }
+}
+
+
+/*
+ * Return the XpmAttributes structure size
+ */
+
+int
+XpmAttributesSize()
+{
+    return sizeof(XpmAttributes);
+}
+
+/*
+ * Init returned data to free safely later on
+ */
+void
+xpmInitAttributes(XpmAttributes *attributes)
+{
+    if (attributes) {
+	attributes->pixels = NULL;
+	attributes->npixels = 0;
+	attributes->colorTable = NULL;
+	attributes->ncolors = 0;
+/* 3.2 backward compatibility code */
+	attributes->hints_cmt = NULL;
+	attributes->colors_cmt = NULL;
+	attributes->pixels_cmt = NULL;
+/* end 3.2 bc */
+	attributes->extensions = NULL;
+	attributes->nextensions = 0;
+    }
+}
+
+/*
+ * Fill in the XpmAttributes with the XpmImage and the XpmInfo
+ */
+void
+xpmSetAttributes(XpmAttributes *attributes, XpmImage *image, XpmInfo *info)
+{
+    if (attributes->valuemask & XpmReturnColorTable) {
+	attributes->colorTable = image->colorTable;
+	attributes->ncolors = image->ncolors;
+
+	/* avoid deletion of copied data */
+	image->ncolors = 0;
+	image->colorTable = NULL;
+    }
+/* 3.2 backward compatibility code */
+    else if (attributes->valuemask & XpmReturnInfos) {
+	int ErrorStatus;
+
+	ErrorStatus = CreateOldColorTable(image->colorTable, image->ncolors,
+					  (XpmColor ***)
+					  &attributes->colorTable);
+
+	/* if error just say we can't return requested data */
+	if (ErrorStatus != XpmSuccess) {
+	    attributes->valuemask &= ~XpmReturnInfos;
+	    if (!(attributes->valuemask & XpmReturnPixels)) {
+		XpmFree(attributes->pixels);
+		attributes->pixels = NULL;
+		attributes->npixels = 0;
+	    }
+	    attributes->ncolors = 0;
+	} else {
+	    attributes->ncolors = image->ncolors;
+	    attributes->hints_cmt = info->hints_cmt;
+	    attributes->colors_cmt = info->colors_cmt;
+	    attributes->pixels_cmt = info->pixels_cmt;
+
+	    /* avoid deletion of copied data */
+	    image->ncolors = 0;
+	    image->colorTable = NULL;
+	    info->hints_cmt = NULL;
+	    info->colors_cmt = NULL;
+	    info->pixels_cmt = NULL;
+	}
+    }
+/* end 3.2 bc */
+    if (attributes->valuemask & XpmReturnExtensions) {
+	attributes->extensions = info->extensions;
+	attributes->nextensions = info->nextensions;
+
+	/* avoid deletion of copied data */
+	info->extensions = NULL;
+	info->nextensions = 0;
+    }
+    if (info->valuemask & XpmHotspot) {
+	attributes->valuemask |= XpmHotspot;
+	attributes->x_hotspot = info->x_hotspot;
+	attributes->y_hotspot = info->y_hotspot;
+    }
+    attributes->valuemask |= XpmCharsPerPixel;
+    attributes->cpp = image->cpp;
+    attributes->valuemask |= XpmSize;
+    attributes->width = image->width;
+    attributes->height = image->height;
+}
+
+/*
+ * Free the XpmAttributes structure members
+ * but the structure itself
+ */
+void
+XpmFreeAttributes(XpmAttributes *attributes)
+{
+    if (attributes->valuemask & XpmReturnPixels && attributes->npixels) {
+	XpmFree(attributes->pixels);
+	attributes->pixels = NULL;
+	attributes->npixels = 0;
+    }
+    if (attributes->valuemask & XpmReturnColorTable) {
+	xpmFreeColorTable(attributes->colorTable, attributes->ncolors);
+	attributes->colorTable = NULL;
+	attributes->ncolors = 0;
+    }
+/* 3.2 backward compatibility code */
+    else if (attributes->valuemask & XpmInfos) {
+	if (attributes->colorTable) {
+	    FreeOldColorTable((XpmColor **) attributes->colorTable,
+			      attributes->ncolors);
+	    attributes->colorTable = NULL;
+	    attributes->ncolors = 0;
+	}
+	if (attributes->hints_cmt) {
+	    XpmFree(attributes->hints_cmt);
+	    attributes->hints_cmt = NULL;
+	}
+	if (attributes->colors_cmt) {
+	    XpmFree(attributes->colors_cmt);
+	    attributes->colors_cmt = NULL;
+	}
+	if (attributes->pixels_cmt) {
+	    XpmFree(attributes->pixels_cmt);
+	    attributes->pixels_cmt = NULL;
+	}
+	if (attributes->pixels) {
+	    XpmFree(attributes->pixels);
+	    attributes->pixels = NULL;
+	    attributes->npixels = 0;
+	}
+    }
+/* end 3.2 bc */
+    if (attributes->valuemask & XpmReturnExtensions
+	&& attributes->nextensions) {
+	XpmFreeExtensions(attributes->extensions, attributes->nextensions);
+	attributes->extensions = NULL;
+	attributes->nextensions = 0;
+    }
+    attributes->valuemask = 0;
+}
+
+/*
+ * Init returned data to free safely later on
+ */
+void
+xpmInitXpmImage(XpmImage *image)
+{
+    image->ncolors = 0;
+    image->colorTable = NULL;
+    image->data = NULL;
+}
+
+/*
+ * Free the XpmImage data which have been allocated
+ */
+void
+XpmFreeXpmImage(XpmImage *image)
+{
+    if (image->colorTable)
+	xpmFreeColorTable(image->colorTable, image->ncolors);
+    XpmFree(image->data);
+    image->data = NULL;
+}
+
+/*
+ * Init returned data to free safely later on
+ */
+void
+xpmInitXpmInfo(XpmInfo *info)
+{
+    if (info) {
+	info->hints_cmt = NULL;
+	info->colors_cmt = NULL;
+	info->pixels_cmt = NULL;
+	info->extensions = NULL;
+	info->nextensions = 0;
+    }
+}
+
+/*
+ * Free the XpmInfo data which have been allocated
+ */
+void
+XpmFreeXpmInfo(XpmInfo *info)
+{
+    if (info) {
+	if (info->valuemask & XpmComments) {
+	    if (info->hints_cmt) {
+		XpmFree(info->hints_cmt);
+		info->hints_cmt = NULL;
+	    }
+	    if (info->colors_cmt) {
+		XpmFree(info->colors_cmt);
+		info->colors_cmt = NULL;
+	    }
+	    if (info->pixels_cmt) {
+		XpmFree(info->pixels_cmt);
+		info->pixels_cmt = NULL;
+	    }
+	}
+	if (info->valuemask & XpmReturnExtensions && info->nextensions) {
+	    XpmFreeExtensions(info->extensions, info->nextensions);
+	    info->extensions = NULL;
+	    info->nextensions = 0;
+	}
+	info->valuemask = 0;
+    }
+}
+
+/*
+ * Set the XpmInfo valuemask to retrieve required info
+ */
+void
+xpmSetInfoMask(XpmInfo *info, XpmAttributes *attributes)
+{
+    info->valuemask = 0;
+    if (attributes->valuemask & XpmReturnInfos)
+	info->valuemask |= XpmReturnComments;
+    if (attributes->valuemask & XpmReturnExtensions)
+	info->valuemask |= XpmReturnExtensions;
+}
+
+/*
+ * Fill in the XpmInfo with the XpmAttributes
+ */
+void
+xpmSetInfo(XpmInfo *info, XpmAttributes *attributes)
+{
+    info->valuemask = 0;
+    if (attributes->valuemask & XpmInfos) {
+	info->valuemask |= XpmComments | XpmColorTable;
+	info->hints_cmt = attributes->hints_cmt;
+	info->colors_cmt = attributes->colors_cmt;
+	info->pixels_cmt = attributes->pixels_cmt;
+    }
+    if (attributes->valuemask & XpmExtensions) {
+	info->valuemask |= XpmExtensions;
+	info->extensions = attributes->extensions;
+	info->nextensions = attributes->nextensions;
+    }
+    if (attributes->valuemask & XpmHotspot) {
+	info->valuemask |= XpmHotspot;
+	info->x_hotspot = attributes->x_hotspot;
+	info->y_hotspot = attributes->y_hotspot;
+    }
+}
+
+
+#ifdef NEED_STRDUP
+/*
+ * in case strdup is not provided by the system here is one
+ * which does the trick
+ */
+char *
+strdup(char *s1)
+{
+    char *s2;
+    int l = strlen(s1) + 1;
+
+    if (s2 = (char *) XpmMallocA(l))
+	strncpy(s2, s1, l);
+    return s2;
+}
+
+#endif
+
+unsigned int
+atoui(register char *p, unsigned int l, unsigned int *ui_return)
+{
+    register unsigned int n, i;
+
+    n = 0;
+    for (i = 0; i < l; i++)
+	if (*p >= '0' && *p <= '9')
+	    n = n * 10 + *p++ - '0';
+	else
+	    break;
+
+    if (i != 0 && i == l) {
+	*ui_return = n;
+	return 1;
+    } else
+	return 0;
+}
+
+
+/*
+ *  File / Buffer utilities
+ */
+int
+XpmReadFileToBuffer(char *filename, char **buffer_return)
+{
+    int fd, fcheck, len;
+    char *ptr;
+    struct stat stats;
+    FILE *fp;
+
+    *buffer_return = NULL;
+
+    fd = open(filename, O_RDONLY);
+    if (fd < 0)
+	return XpmOpenFailed;
+
+    if (fstat(fd, &stats)) {
+	close(fd);
+	return XpmOpenFailed;
+    }
+    fp = fdopen(fd, "r");
+    if (!fp) {
+	close(fd);
+	return XpmOpenFailed;
+    }
+    len = (int) stats.st_size;
+    ptr = (char *) XpmMallocA(len + 1);
+    if (!ptr) {
+	fclose(fp);
+	return XpmNoMemory;
+    }
+    fcheck = fread(ptr, len, 1, fp);
+    fclose(fp);
+    if (fcheck != 1) {
+	XpmFree(ptr);
+	return XpmOpenFailed;
+    }
+    ptr[len] = '\0';
+    *buffer_return = ptr;
+    return XpmSuccess;
+}
+
+int
+XpmWriteFileFromBuffer(char *filename, char *buffer)
+{
+    int fcheck, len;
+    FILE *fp = fopen(filename, "w");
+
+    if (!fp)
+	return XpmOpenFailed;
+
+    len = strlen(buffer);
+    fcheck = fwrite(buffer, len, 1, fp);
+    fclose(fp);
+    if (fcheck != 1)
+	return XpmOpenFailed;
+
+    return XpmSuccess;
+}
+
+
+/*
+ * Small utility function
+ */
+char *
+XpmGetErrorString(int errcode)
+{
+    switch (errcode) {
+    case XpmColorError:
+	return ("XpmColorError");
+    case XpmSuccess:
+	return ("XpmSuccess");
+    case XpmOpenFailed:
+	return ("XpmOpenFailed");
+    case XpmFileInvalid:
+	return ("XpmFileInvalid");
+    case XpmNoMemory:
+	return ("XpmNoMemory");
+    case XpmColorFailed:
+	return ("XpmColorFailed");
+    default:
+	return ("Invalid XpmError");
+    }
+}
+
+/*
+ * The following function provides a way to figure out if the linked library is
+ * newer or older than the one with which a program has been first compiled.
+ */
+int
+XpmLibraryVersion()
+{
+    return XpmIncludeVersion;
+}
+
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+void
+xpmCreatePixmapFromImage(Display *display, Drawable d, XImage *ximage, Pixmap *pixmap_return)
+{
+    GC gc;
+
+    *pixmap_return = XCreatePixmap(display, d, ximage->width,
+				   ximage->height, ximage->depth);
+    gc = XCreateGC(display, *pixmap_return, 0, NULL);
+
+    XPutImage(display, *pixmap_return, gc, ximage, 0, 0, 0, 0,
+	      ximage->width, ximage->height);
+
+    XFreeGC(display, gc);
+}
+
+void
+xpmCreateImageFromPixmap(Display *display, Pixmap pixmap, XImage **ximage_return, unsigned int *width, unsigned int *height)
+{
+    unsigned int dum;
+    int dummy;
+    Window win;
+
+    if (*width == 0 && *height == 0)
+	XGetGeometry(display, pixmap, &win, &dummy, &dummy,
+		     width, height, &dum, &dum);
+
+    *ximage_return = XGetImage(display, pixmap, 0, 0, *width, *height,
+			       AllPlanes, ZPixmap);
+}
+
+#endif /* FOR_MSW */
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/parse.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/parse.c
new file mode 100644
index 0000000..c90a885
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/parse.c
@@ -0,0 +1,705 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* parse.c:                                                                    *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an XPM file or array and store the found informations                *
+*  in the given XpmImage structure.                                           *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:ctype.h"
+#else
+#include <ctype.h>
+#endif
+
+#ifdef sun
+#ifdef SVR4
+#include <X11/Xfuncs.h> /* bzero, bcopy */
+#endif
+#endif
+
+#include <string.h>
+#ifdef __sgi
+#include <bstring.h>
+#endif
+
+LFUNC(ParseValues, int, (xpmData *data, unsigned int *width,
+			 unsigned int *height, unsigned int *ncolors,
+			 unsigned int *cpp, unsigned int *x_hotspot,
+			 unsigned int *y_hotspot, unsigned int *hotspot,
+			 unsigned int *extensions));
+
+LFUNC(ParseColors, int, (xpmData *data, unsigned int ncolors, unsigned int cpp,
+			 XpmColor **colorTablePtr, xpmHashTable *hashtable));
+
+LFUNC(ParsePixels, int, (xpmData *data, unsigned int width,
+			 unsigned int height, unsigned int ncolors,
+			 unsigned int cpp, XpmColor *colorTable,
+			 xpmHashTable *hashtable, unsigned int **pixels));
+
+LFUNC(ParseExtensions, int, (xpmData *data, XpmExtension **extensions,
+			     unsigned int *nextensions));
+
+char *xpmColorKeys[] = {
+    "s",				/* key #1: symbol */
+    "m",				/* key #2: mono visual */
+    "g4",				/* key #3: 4 grays visual */
+    "g",				/* key #4: gray visual */
+    "c",				/* key #5: color visual */
+};
+
+
+/* function call in case of error, frees only locally allocated variables */
+#undef RETURN
+#define RETURN(status) \
+{ \
+    if (colorTable) xpmFreeColorTable(colorTable, ncolors); \
+    if (pixelindex) XpmFree(pixelindex); \
+    if (hints_cmt)  XpmFree(hints_cmt); \
+    if (colors_cmt) XpmFree(colors_cmt); \
+    if (pixels_cmt) XpmFree(pixels_cmt); \
+    return(status); \
+}
+
+/*
+ * This function parses an Xpm file or data and store the found informations
+ * in an an XpmImage structure which is returned.
+ */
+int
+xpmParseData(xpmData *data, XpmImage *image, XpmInfo *info)
+{
+    /* variables to return */
+    unsigned int width, height, ncolors, cpp;
+    unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
+    XpmColor *colorTable = NULL;
+    unsigned int *pixelindex = NULL;
+    char *hints_cmt = NULL;
+    char *colors_cmt = NULL;
+    char *pixels_cmt = NULL;
+
+    unsigned int cmts;
+    int ErrorStatus;
+    xpmHashTable hashtable;
+
+    cmts = info && (info->valuemask & XpmReturnComments);
+
+    /*
+     * parse the header
+     */
+    ErrorStatus = xpmParseHeader(data);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /*
+     * read values
+     */
+    ErrorStatus = ParseValues(data, &width, &height, &ncolors, &cpp,
+			    &x_hotspot, &y_hotspot, &hotspot, &extensions);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /*
+     * store the hints comment line
+     */
+    if (cmts)
+	xpmGetCmt(data, &hints_cmt);
+
+    /*
+     * init the hastable
+     */
+    if (USE_HASHTABLE) {
+	ErrorStatus = xpmHashTableInit(&hashtable);
+	if (ErrorStatus != XpmSuccess)
+	    return (ErrorStatus);
+    }
+
+    /*
+     * read colors
+     */
+    ErrorStatus = ParseColors(data, ncolors, cpp, &colorTable, &hashtable);
+    if (ErrorStatus != XpmSuccess)
+	RETURN(ErrorStatus);
+
+    /*
+     * store the colors comment line
+     */
+    if (cmts)
+	xpmGetCmt(data, &colors_cmt);
+
+    /*
+     * read pixels and index them on color number
+     */
+    ErrorStatus = ParsePixels(data, width, height, ncolors, cpp, colorTable,
+			      &hashtable, &pixelindex);
+
+    /*
+     * free the hastable
+     */
+    if (USE_HASHTABLE)
+	xpmHashTableFree(&hashtable);
+
+    if (ErrorStatus != XpmSuccess)
+	RETURN(ErrorStatus);
+
+    /*
+     * store the pixels comment line
+     */
+    if (cmts)
+	xpmGetCmt(data, &pixels_cmt);
+
+    /*
+     * parse extensions
+     */
+    if (info && (info->valuemask & XpmReturnExtensions))
+	if (extensions) {
+	    ErrorStatus = ParseExtensions(data, &info->extensions,
+					  &info->nextensions);
+	    if (ErrorStatus != XpmSuccess)
+		RETURN(ErrorStatus);
+	} else {
+	    info->extensions = NULL;
+	    info->nextensions = 0;
+	}
+
+    /*
+     * store found informations in the XpmImage structure
+     */
+    image->width = width;
+    image->height = height;
+    image->cpp = cpp;
+    image->ncolors = ncolors;
+    image->colorTable = colorTable;
+    image->data = pixelindex;
+
+    if (info) {
+	if (cmts) {
+	    info->hints_cmt = hints_cmt;
+	    info->colors_cmt = colors_cmt;
+	    info->pixels_cmt = pixels_cmt;
+	}
+	if (hotspot) {
+	    info->x_hotspot = x_hotspot;
+	    info->y_hotspot = y_hotspot;
+	    info->valuemask |= XpmHotspot;
+	}
+    }
+    return (XpmSuccess);
+}
+
+static int
+ParseValues(xpmData *data, unsigned int *width, unsigned int *height, unsigned int *ncolors, unsigned int *cpp,
+	    unsigned int *x_hotspot, unsigned int *y_hotspot, unsigned int *hotspot, unsigned int *extensions)
+{
+    unsigned int l;
+    char buf[BUFSIZ];
+
+    if (!data->format) {		/* XPM 2 or 3 */
+
+	/*
+	 * read values: width, height, ncolors, chars_per_pixel
+	 */
+	if (!(xpmNextUI(data, width) && xpmNextUI(data, height)
+	      && xpmNextUI(data, ncolors) && xpmNextUI(data, cpp)))
+	    return (XpmFileInvalid);
+
+	/*
+	 * read optional information (hotspot and/or XPMEXT) if any
+	 */
+	l = xpmNextWord(data, buf, BUFSIZ);
+	if (l) {
+	    *extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
+	    if (*extensions)
+		*hotspot = (xpmNextUI(data, x_hotspot)
+			    && xpmNextUI(data, y_hotspot));
+	    else {
+		*hotspot = (atoui(buf, l, x_hotspot)
+			    && xpmNextUI(data, y_hotspot));
+		l = xpmNextWord(data, buf, BUFSIZ);
+		*extensions = (l == 6 && !strncmp("XPMEXT", buf, 6));
+	    }
+	}
+    } else {
+
+	/*
+	 * XPM 1 file read values: width, height, ncolors, chars_per_pixel
+	 */
+	int i;
+	char *ptr;
+
+	for (i = 0; i < 4; i++) {
+	    l = xpmNextWord(data, buf, BUFSIZ);
+	    if (l != 7 || strncmp("#define", buf, 7))
+		return (XpmFileInvalid);
+	    l = xpmNextWord(data, buf, BUFSIZ);
+	    if (!l)
+		return (XpmFileInvalid);
+	    ptr = strchr(buf, '_');
+	    if (!ptr)
+		return (XpmFileInvalid);
+	    switch (l - (ptr - buf)) {
+	    case 6:
+		if (!strncmp("_width", ptr, 6) && !xpmNextUI(data, width))
+		    return (XpmFileInvalid);
+		break;
+	    case 7:
+		if (!strncmp("_height", ptr, 7) && !xpmNextUI(data, height))
+		    return (XpmFileInvalid);
+		break;
+	    case 8:
+		if (!strncmp("_ncolors", ptr, 8) && !xpmNextUI(data, ncolors))
+		    return (XpmFileInvalid);
+		break;
+	    case 16:
+		if (!strncmp("_chars_per_pixel", ptr, 16)
+		    && !xpmNextUI(data, cpp))
+		    return (XpmFileInvalid);
+		break;
+	    default:
+		return (XpmFileInvalid);
+	    }
+	    /* skip the end of line */
+	    xpmNextString(data);
+	}
+	*hotspot = 0;
+	*extensions = 0;
+    }
+    return (XpmSuccess);
+}
+
+static int
+ParseColors(xpmData *data, unsigned int ncolors, unsigned int cpp, XpmColor **colorTablePtr, xpmHashTable *hashtable)
+{
+    unsigned int key, l, a, b;
+    unsigned int curkey;		/* current color key */
+    unsigned int lastwaskey;		/* key read */
+    char buf[BUFSIZ];
+    char curbuf[BUFSIZ];		/* current buffer */
+    char **sptr, *s;
+    XpmColor *color;
+    XpmColor *colorTable;
+    char **defaults;
+    int ErrorStatus;
+
+    colorTable = (XpmColor *) XpmCalloc(ncolors, sizeof(XpmColor));
+    if (!colorTable)
+	return (XpmNoMemory);
+
+    if (!data->format) {		/* XPM 2 or 3 */
+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
+	    xpmNextString(data);	/* skip the line */
+
+	    /*
+	     * read pixel value
+	     */
+	    color->string = (char *) XpmMallocA(cpp + 1);
+	    if (!color->string) {
+		xpmFreeColorTable(colorTable, ncolors);
+		return (XpmNoMemory);
+	    }
+	    for (b = 0, s = color->string; b < cpp; b++, s++)
+		*s = xpmGetC(data);
+	    *s = '\0';
+
+	    /*
+	     * store the string in the hashtable with its color index number
+	     */
+	    if (USE_HASHTABLE) {
+		ErrorStatus =
+		    xpmHashIntern(hashtable, color->string, HashAtomData(a));
+		if (ErrorStatus != XpmSuccess) {
+		    xpmFreeColorTable(colorTable, ncolors);
+		    return (ErrorStatus);
+		}
+	    }
+
+	    /*
+	     * read color keys and values
+	     */
+	    defaults = (char **) color;
+	    curkey = 0;
+	    lastwaskey = 0;
+	    *curbuf = '\0';		/* init curbuf */
+	    while (l = xpmNextWord(data, buf, BUFSIZ)) {
+		if (!lastwaskey) {
+		    for (key = 0, sptr = xpmColorKeys; key < NKEYS; key++,
+			 sptr++)
+			if ((strlen(*sptr) == l) && (!strncmp(*sptr, buf, l)))
+			    break;
+		}
+		if (!lastwaskey && key < NKEYS) {	/* open new key */
+		    if (curkey) {	/* flush string */
+			s = (char *) XpmMallocA(strlen(curbuf) + 1);
+			if (!s) {
+			    xpmFreeColorTable(colorTable, ncolors);
+			    return (XpmNoMemory);
+			}
+			defaults[curkey] = s;
+			strcpy(s, curbuf);
+		    }
+		    curkey = key + 1;	/* set new key  */
+		    *curbuf = '\0';	/* reset curbuf */
+		    lastwaskey = 1;
+		} else {
+		    if (!curkey) {	/* key without value */
+			xpmFreeColorTable(colorTable, ncolors);
+			return (XpmFileInvalid);
+		    }
+		    if (!lastwaskey)
+			strcat(curbuf, " ");	/* append space */
+		    buf[l] = '\0';
+		    strcat(curbuf, buf);/* append buf */
+		    lastwaskey = 0;
+		}
+	    }
+	    if (!curkey) {		/* key without value */
+		xpmFreeColorTable(colorTable, ncolors);
+		return (XpmFileInvalid);
+	    }
+	    s = defaults[curkey] = (char *) XpmMallocA(strlen(curbuf) + 1);
+	    if (!s) {
+		xpmFreeColorTable(colorTable, ncolors);
+		return (XpmNoMemory);
+	    }
+	    strcpy(s, curbuf);
+	}
+    } else {				/* XPM 1 */
+	/* get to the beginning of the first string */
+	data->Bos = '"';
+	data->Eos = '\0';
+	xpmNextString(data);
+	data->Eos = '"';
+	for (a = 0, color = colorTable; a < ncolors; a++, color++) {
+
+	    /*
+	     * read pixel value
+	     */
+	    color->string = (char *) XpmMallocA(cpp + 1);
+	    if (!color->string) {
+		xpmFreeColorTable(colorTable, ncolors);
+		return (XpmNoMemory);
+	    }
+	    for (b = 0, s = color->string; b < cpp; b++, s++)
+		*s = xpmGetC(data);
+	    *s = '\0';
+
+	    /*
+	     * store the string in the hashtable with its color index number
+	     */
+	    if (USE_HASHTABLE) {
+		ErrorStatus =
+		    xpmHashIntern(hashtable, color->string, HashAtomData(a));
+		if (ErrorStatus != XpmSuccess) {
+		    xpmFreeColorTable(colorTable, ncolors);
+		    return (ErrorStatus);
+		}
+	    }
+
+	    /*
+	     * read color values
+	     */
+	    xpmNextString(data);	/* get to the next string */
+	    *curbuf = '\0';		/* init curbuf */
+	    while (l = xpmNextWord(data, buf, BUFSIZ)) {
+		if (*curbuf != '\0')
+		    strcat(curbuf, " ");/* append space */
+		buf[l] = '\0';
+		strcat(curbuf, buf);	/* append buf */
+	    }
+	    s = (char *) XpmMallocA(strlen(curbuf) + 1);
+	    if (!s) {
+		xpmFreeColorTable(colorTable, ncolors);
+		return (XpmNoMemory);
+	    }
+	    strcpy(s, curbuf);
+	    color->c_color = s;
+	    *curbuf = '\0';		/* reset curbuf */
+	    if (a < ncolors - 1)
+		xpmNextString(data);	/* get to the next string */
+	}
+    }
+    *colorTablePtr = colorTable;
+    return (XpmSuccess);
+}
+
+static int
+ParsePixels(xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors,
+  unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, unsigned int **pixels)
+{
+    unsigned int *iptr, *iptr2;
+    unsigned int a, x, y;
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+    iptr2 = (unsigned int *) XpmMallocA(sizeof(unsigned int) * width * height);
+#else
+
+    /*
+     * special treatment to trick DOS malloc(size_t) where size_t is 16 bit!!
+     * XpmMalloc is defined to longMalloc(long) and checks the 16 bit boundary
+     */
+    iptr2 = (unsigned int *)
+	XpmMallocA((long) sizeof(unsigned int) * (long) width * (long) height);
+#endif
+    if (!iptr2)
+	return (XpmNoMemory);
+
+    iptr = iptr2;
+
+    switch (cpp) {
+
+    case (1):				/* Optimize for single character
+					 * colors */
+	{
+	    unsigned short colidx[256];
+
+	    bzero(colidx, 256 * sizeof(short));
+	    for (a = 0; a < ncolors; a++)
+		colidx[colorTable[a].string[0]] = a + 1;
+
+	    for (y = 0; y < height; y++) {
+		xpmNextString(data);
+		for (x = 0; x < width; x++, iptr++) {
+		    int idx = colidx[xpmGetC(data)];
+
+		    if (idx != 0)
+			*iptr = idx - 1;
+		    else {
+			XpmFree(iptr2);
+			return (XpmFileInvalid);
+		    }
+		}
+	    }
+	}
+	break;
+
+    case (2):				/* Optimize for double character
+					 * colors */
+	{
+
+/* free all allocated pointers at all exits */
+#define FREE_CIDX {int f; for (f = 0; f < 256; f++) \
+if (cidx[f]) XpmFree(cidx[f]);}
+
+	    /* array of pointers malloced by need */
+	    unsigned short *cidx[256];
+	    int char1;
+
+	    bzero(cidx, 256 * sizeof(unsigned short *)); /* init */
+	    for (a = 0; a < ncolors; a++) {
+		char1 = colorTable[a].string[0];
+		if (cidx[char1] == NULL) { /* get new memory */
+		    cidx[char1] = (unsigned short *)
+			XpmCallocA(256, sizeof(unsigned short));
+		    if (cidx[char1] == NULL) { /* new block failed */
+			FREE_CIDX;
+			XpmFree(iptr2);
+			return (XpmNoMemory);
+		    }
+		}
+		cidx[char1][colorTable[a].string[1]] = a + 1;
+	    }
+
+	    for (y = 0; y < height; y++) {
+		xpmNextString(data);
+		for (x = 0; x < width; x++, iptr++) {
+		    int cc1 = xpmGetC(data);
+		    int idx = cidx[cc1][xpmGetC(data)];
+
+		    if (idx != 0)
+			*iptr = idx - 1;
+		    else {
+			FREE_CIDX;
+			XpmFree(iptr2);
+			return (XpmFileInvalid);
+		    }
+		}
+	    }
+	    FREE_CIDX;
+	}
+	break;
+
+    default:				/* Non-optimized case of long color
+					 * names */
+	{
+	    char *s;
+	    char buf[BUFSIZ];
+
+	    buf[cpp] = '\0';
+	    if (USE_HASHTABLE) {
+		xpmHashAtom *slot;
+
+		for (y = 0; y < height; y++) {
+		    xpmNextString(data);
+		    for (x = 0; x < width; x++, iptr++) {
+			for (a = 0, s = buf; a < cpp; a++, s++)
+			    *s = xpmGetC(data);
+			slot = xpmHashSlot(hashtable, buf);
+			if (!*slot) {	/* no color matches */
+			    XpmFree(iptr2);
+			    return (XpmFileInvalid);
+			}
+			*iptr = HashColorIndex(slot);
+		    }
+		}
+	    } else {
+		for (y = 0; y < height; y++) {
+		    xpmNextString(data);
+		    for (x = 0; x < width; x++, iptr++) {
+			for (a = 0, s = buf; a < cpp; a++, s++)
+			    *s = xpmGetC(data);
+			for (a = 0; a < ncolors; a++)
+			    if (!strcmp(colorTable[a].string, buf))
+				break;
+			if (a == ncolors) {	/* no color matches */
+			    XpmFree(iptr2);
+			    return (XpmFileInvalid);
+			}
+			*iptr = a;
+		    }
+		}
+	    }
+	}
+	break;
+    }
+    *pixels = iptr2;
+    return (XpmSuccess);
+}
+
+static int
+ParseExtensions(xpmData *data, XpmExtension **extensions, unsigned int *nextensions)
+{
+    XpmExtension *exts = NULL, *ext;
+    unsigned int num = 0;
+    unsigned int nlines, a, l, notstart, notend = 0;
+    int status;
+    char *string, *s, *s2, **sp;
+
+    xpmNextString(data);
+    exts = (XpmExtension *) XpmMalloc(sizeof(XpmExtension));
+    /* get the whole string */
+    status = xpmGetString(data, &string, &l);
+    if (status != XpmSuccess) {
+	XpmFree(exts);
+	return (status);
+    }
+    /* look for the key word XPMEXT, skip lines before this */
+    while ((notstart = strncmp("XPMEXT", string, 6))
+	   && (notend = strncmp("XPMENDEXT", string, 9))) {
+	XpmFree(string);
+	xpmNextString(data);
+	status = xpmGetString(data, &string, &l);
+	if (status != XpmSuccess) {
+	    XpmFree(exts);
+	    return (status);
+	}
+    }
+    if (!notstart)
+	notend = strncmp("XPMENDEXT", string, 9);
+    while (!notstart && notend) {
+	/* there starts an extension */
+	ext = (XpmExtension *)
+	    XpmRealloc(exts, (num + 1) * sizeof(XpmExtension));
+	if (!ext) {
+	    XpmFree(string);
+	    XpmFreeExtensions(exts, num);
+	    return (XpmNoMemory);
+	}
+	exts = ext;
+	ext += num;
+	/* skip whitespace and store its name */
+	s2 = s = string + 6;
+	while (isspace(*s2))
+	    s2++;
+	a = s2 - s;
+	ext->name = (char *) XpmMallocA(l - a - 6);
+	if (!ext->name) {
+	    XpmFree(string);
+	    ext->lines = NULL;
+	    ext->nlines = 0;
+	    XpmFreeExtensions(exts, num + 1);
+	    return (XpmNoMemory);
+	}
+	strncpy(ext->name, s + a, l - a - 6);
+	XpmFree(string);
+	/* now store the related lines */
+	xpmNextString(data);
+	status = xpmGetString(data, &string, &l);
+	if (status != XpmSuccess) {
+	    ext->lines = NULL;
+	    ext->nlines = 0;
+	    XpmFreeExtensions(exts, num + 1);
+	    return (status);
+	}
+	ext->lines = (char **) XpmMalloc(sizeof(char *));
+	nlines = 0;
+	while ((notstart = strncmp("XPMEXT", string, 6))
+	       && (notend = strncmp("XPMENDEXT", string, 9))) {
+	    sp = (char **)
+		XpmRealloc(ext->lines, (nlines + 1) * sizeof(char *));
+	    if (!sp) {
+		XpmFree(string);
+		ext->nlines = nlines;
+		XpmFreeExtensions(exts, num + 1);
+		return (XpmNoMemory);
+	    }
+	    ext->lines = sp;
+	    ext->lines[nlines] = string;
+	    nlines++;
+	    xpmNextString(data);
+	    status = xpmGetString(data, &string, &l);
+	    if (status != XpmSuccess) {
+		ext->nlines = nlines;
+		XpmFreeExtensions(exts, num + 1);
+		return (status);
+	    }
+	}
+	if (!nlines) {
+	    XpmFree(ext->lines);
+	    ext->lines = NULL;
+	}
+	ext->nlines = nlines;
+	num++;
+    }
+    if (!num) {
+	XpmFree(string);
+	XpmFree(exts);
+	exts = NULL;
+    } else if (!notend)
+	XpmFree(string);
+    *nextensions = num;
+    *extensions = exts;
+    return (XpmSuccess);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftodat.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftodat.c
new file mode 100644
index 0000000..28c81ae
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftodat.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmRdFToData.c:                                                             *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an XPM file and create an array of strings corresponding to it.      *
+*                                                                             *
+*  Developed by Dan Greening dgreen@cs.ucla.edu / dgreen@sti.com              *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+int
+XpmReadFileToData(char *filename, char ***data_return)
+{
+    XpmImage image;
+    XpmInfo info;
+    int ErrorStatus;
+
+    info.valuemask = XpmReturnComments | XpmReturnExtensions;
+
+    /*
+     * initialize return value
+     */
+    if (data_return)
+	*data_return = NULL;
+
+    ErrorStatus = XpmReadFileToXpmImage(filename, &image, &info);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    ErrorStatus =
+	XpmCreateDataFromXpmImage(data_return, &image, &info);
+
+    XpmFreeXpmImage(&image);
+    XpmFreeXpmInfo(&info);
+
+    return (ErrorStatus);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftoi.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftoi.c
new file mode 100644
index 0000000..d5aea86
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftoi.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmRdFToI.c:                                                                *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an XPM file and create the image and possibly its mask               *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+int
+XpmReadFileToImage(Display *display, char *filename,
+		   XImage **image_return, XImage **shapeimage_return, XpmAttributes *attributes)
+{
+    XpmImage image;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* create an XpmImage from the file */
+    if (attributes) {
+	xpmInitAttributes(attributes);
+	xpmSetInfoMask(&info, attributes);
+	ErrorStatus = XpmReadFileToXpmImage(filename, &image, &info);
+    } else
+	ErrorStatus = XpmReadFileToXpmImage(filename, &image, NULL);
+
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the related ximages */
+    ErrorStatus = XpmCreateImageFromXpmImage(display, &image,
+					     image_return, shapeimage_return,
+					     attributes);
+    if (attributes) {
+	if (ErrorStatus >= 0)		/* no fatal error */
+	    xpmSetAttributes(attributes, &image, &info);
+	XpmFreeXpmInfo(&info);
+    }
+    /* free the XpmImage */
+    XpmFreeXpmImage(&image);
+
+    return (ErrorStatus);
+}
+
+int
+XpmReadFileToXpmImage(char *filename, XpmImage *image, XpmInfo *info)
+{
+    xpmData mdata;
+    int ErrorStatus;
+
+    /* init returned values */
+    xpmInitXpmImage(image);
+    xpmInitXpmInfo(info);
+
+    /* open file to read */
+    if ((ErrorStatus = xpmReadFile(filename, &mdata)) != XpmSuccess)
+	return (ErrorStatus);
+
+    /* create the XpmImage from the XpmData */
+    ErrorStatus = xpmParseData(&mdata, image, info);
+
+    xpmDataClose(&mdata);
+
+    return (ErrorStatus);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftop.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftop.c
new file mode 100644
index 0000000..6e571bb
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rdftop.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmRdFToP.c:                                                                *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an XPM file and create the pixmap and possibly its mask              *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+
+#include "xpm34p.h"
+
+int
+XpmReadFileToPixmap(Display *display, Drawable d, char *filename, Pixmap *pixmap_return,
+		    Pixmap *shapemask_return, XpmAttributes *attributes)
+{
+    XImage *ximage, *shapeimage;
+    int ErrorStatus;
+
+    /* initialize return values */
+    if (pixmap_return)
+	*pixmap_return = 0;
+    if (shapemask_return)
+	*shapemask_return = 0;
+
+    /* create the images */
+    ErrorStatus = XpmReadFileToImage(display, filename,
+				     (pixmap_return ? &ximage : NULL),
+				     (shapemask_return ? &shapeimage : NULL),
+				     attributes);
+
+    if (ErrorStatus < 0)		/* fatal error */
+	return (ErrorStatus);
+
+    /* create the pixmaps and destroy images */
+    if (pixmap_return && ximage) {
+	xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
+	XDestroyImage(ximage);
+    }
+    if (shapemask_return && shapeimage) {
+	xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
+	XDestroyImage(shapeimage);
+    }
+    return (ErrorStatus);
+}
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgb.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgb.c
new file mode 100644
index 0000000..f46c87f
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgb.c
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+ 
+/*****************************************************************************\
+* rgb.c:                                                                      *
+*                                                                             *
+*  XPM library                                                                *
+*  Rgb file utilities                                                         *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+/*
+ * Part of this code has been taken from the ppmtoxpm.c file written by Mark
+ * W. Snitily but has been modified for my special need
+ */
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:ctype.h"
+#include "sys$library:string.h"
+#else
+#include <ctype.h>
+#if defined(SYSV) || defined(SVR4) || defined(FOR_MAC)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+#if defined(FOR_MAC)
+#include "simx.h"
+extern int strcasecmp(char *s1, char *s2);
+#endif
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+				/* normal part first, MSW part at
+					 * the end, (huge ifdef!) */
+/*
+ * Read a rgb text file.  It stores the rgb values (0->65535)
+ * and the rgb mnemonics (malloc'ed) into the "rgbn" array.  Returns the
+ * number of entries stored.
+ */
+int
+xpmReadRgbNames(char *rgb_fname, xpmRgbName rgbn[])
+{
+    FILE *rgbf;
+    int i, items, red, green, blue;
+    char line[512], name[512], *rgbname, *n, *m;
+    xpmRgbName *rgb;
+
+    /* Open the rgb text file.  Abort if error. */
+    if ((rgbf = fopen(rgb_fname, "r")) == NULL)
+	return 0;
+
+    /* Loop reading each line in the file. */
+    for (i = 0, rgb = rgbn; fgets(line, sizeof(line), rgbf); i++, rgb++) {
+
+	/* Quit if rgb text file is too large. */
+	if (i == MAX_RGBNAMES) {
+	    /* Too many entries in rgb text file, give up here */
+	    break;
+	}
+	/* Read the line.  Skip silently if bad. */
+	items = sscanf(line, "%d %d %d %[^\n]\n", &red, &green, &blue, name);
+	if (items != 4) {
+	    i--;
+	    continue;
+	}
+
+	/*
+	 * Make sure rgb values are within 0->255 range. Skip silently if
+	 * bad.
+	 */
+	if (red < 0 || red > 0xFF ||
+	    green < 0 || green > 0xFF ||
+	    blue < 0 || blue > 0xFF) {
+	    i--;
+	    continue;
+	}
+	/* Allocate memory for ascii name. If error give up here. */
+	if (!(rgbname = (char *) XpmMallocA(strlen(name) + 1)))
+	    break;
+
+	/* Copy string to ascii name and lowercase it. */
+	for (n = name, m = rgbname; *n; n++)
+	    *m++ = tolower(*n);
+	*m = '\0';
+
+	/* Save the rgb values and ascii name in the array. */
+	rgb->r = red * 257;		/* 65535/255 = 257 */
+	rgb->g = green * 257;
+	rgb->b = blue * 257;
+	rgb->name = rgbname;
+    }
+
+    fclose(rgbf);
+
+    /* Return the number of read rgb names. */
+    return i < 0 ? 0 : i;
+}
+
+/*
+ * Return the color name corresponding to the given rgb values
+ */
+char *
+xpmGetRgbName(xpmRgbName rgbn[], int rgbn_max, int red, int green, int blue)
+/*    xpmRgbName rgbn[]; */			/* rgb mnemonics from rgb text file */
+/*    int rgbn_max; */			/* number of rgb mnemonics in table */
+/*    int red, green, blue; */		/* rgb values */
+
+{
+    int i;
+    xpmRgbName *rgb;
+
+    /*
+     * Just perform a dumb linear search over the rgb values of the color
+     * mnemonics.  One could speed things up by sorting the rgb values and
+     * using a binary search, or building a hash table, etc...
+     */
+    for (i = 0, rgb = rgbn; i < rgbn_max; i++, rgb++)
+	if (red == rgb->r && green == rgb->g && blue == rgb->b)
+	    return rgb->name;
+
+    /* if not found return NULL */
+    return NULL;
+}
+
+/*
+ * Free the strings which have been malloc'ed in xpmReadRgbNames
+ */
+void
+xpmFreeRgbNames(xpmRgbName rgbn[], int rgbn_max)
+{
+    int i;
+    xpmRgbName *rgb;
+
+    for (i = 0, rgb = rgbn; i < rgbn_max; i++, rgb++)
+	XpmFree(rgb->name);
+}
+
+#else					/* here comes the MSW part, the
+					 * second part of the  huge ifdef */
+
+#include "rgbtab.h"			/* hard coded rgb.txt table */
+
+int
+xpmReadRgbNames(char *rgb_fname, xpmRgbName rgbn[])
+{
+    /*
+     * check for consistency???
+     * table has to be sorted for calls on strcasecmp
+     */
+    return (numTheRGBRecords);
+}
+
+/*
+ * MSW rgb values are made from 3 BYTEs, this is different from X XColor.red,
+ * which has something like #0303 for one color
+ */
+char *
+xpmGetRgbName(xpmRgbName rgbn[], int rgbn_max, int red, int green, int blue)
+/*    xpmRgbName rgbn[]; */			/* rgb mnemonics from rgb text file
+					 * not used */
+/*    int rgbn_max; */			/* not used */
+/*    int red, green, blue; */		/* rgb values */
+
+{
+    int i;
+    unsigned long rgbVal;
+
+    i = 0;
+    while (i < numTheRGBRecords) {
+	rgbVal = theRGBRecords[i].rgb;
+	if (GetRValue(rgbVal) == red &&
+	    GetGValue(rgbVal) == green &&
+	    GetBValue(rgbVal) == blue)
+	    return (theRGBRecords[i].name);
+	i++;
+    }
+    return (NULL);
+}
+
+#ifdef FOR_MAC
+#ifdef __cplusplus
+char *strdup(char * in);
+#endif
+char *strdup(char * in)
+{
+	int i = strlen(in);
+	char *newstr = (char *)XpmMallocA(i+1);
+	memcpy(newstr, in, i+1);
+	return newstr;
+}
+#endif
+
+/* used in XParseColor in simx.c */
+#ifdef __cplusplus
+int xpmGetRGBfromName(char *inname, int *r, int *g, int *b);
+#endif
+int
+xpmGetRGBfromName(char *inname, int *r, int *g, int *b)
+{
+    int left, right, middle;
+    int cmp;
+    unsigned long rgbVal;
+    char *name;
+    char *grey, *p;
+
+    name = strdup(inname);
+
+    /*
+     * the table in rgbtab.c has no names with spaces, and no grey, but a
+     * lot of gray
+     */
+    /* so first extract ' ' */
+    while (p = strchr(name, ' ')) {
+	while (*(p)) {			/* till eof of string */
+	    *p = *(p + 1);		/* copy to the left */
+	    p++;
+	}
+    }
+    /* fold to lower case */
+    p = name;
+    while (*p) {
+	*p = tolower(*p);
+	p++;
+    }
+
+    /*
+     * substitute Grey with Gray, else rgbtab.h would have more than 100
+     * 'duplicate' entries
+     */
+    if (grey = strstr(name, "grey"))
+	grey[2] = 'a';
+
+    /* binary search */
+    left = 0;
+    right = numTheRGBRecords - 1;
+    do {
+	middle = (left + right) / 2;
+	cmp = strcasecmp(name, theRGBRecords[middle].name);
+	if (cmp == 0) {
+	    rgbVal = theRGBRecords[middle].rgb;
+	    *r = GetRValue(rgbVal);
+	    *g = GetGValue(rgbVal);
+	    *b = GetBValue(rgbVal);
+	    XpmFree(name);
+	    return (1);
+	} else if (cmp < 0) {
+	    right = middle - 1;
+	} else {			/* > 0 */
+	    left = middle + 1;
+	}
+    } while (left <= right);
+
+    /*
+     * I don't like to run in a ColorInvalid error and to see no pixmap at
+     * all, so simply return a red pixel. Should be wrapped in an #ifdef
+     * HeDu
+     */
+
+    *r = 255;
+    *g = 0;
+    *b = 0;				/* red error pixel */
+
+    XpmFree(name);
+    return (1);
+}
+
+void
+xpmFreeRgbNames(xpmRgbName rgbn[], int rgbn_max)
+{
+    /* nothing to do */
+}
+
+#endif					/* MSW part */
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgbtab.h b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgbtab.h
new file mode 100644
index 0000000..e735750
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/rgbtab.h
@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* rgbtab.h                                                                    *
+*                                                                             *
+* A hard coded rgb.txt. To keep it short I removed all colornames with        *
+* trailing numbers, Blue3 etc, except the GrayXX. Sorry Grey-lovers I prefer  *
+* Gray ;-). But Grey is recognized on lookups, only on save Gray will be      *
+* used, maybe you want to do some substitue there too.                        *
+*                                                                             *
+* To save memory the RGBs are coded in one long value, as done by the RGB     *
+* macro.                                                                      *
+*                                                                             *
+* Developed by HeDu 3/94 (hedu@cul-ipn.uni-kiel.de)                           *
+\*****************************************************************************/
+
+#ifdef FOR_MAC
+typedef unsigned long COLORREF;
+#endif
+
+typedef struct {
+    char *name;
+    COLORREF rgb;			/* it's unsigned long */
+}      rgbRecord;
+
+#ifdef FOR_MAC
+#define myRGB(r,g,b) \
+	((unsigned long)r<<16|(unsigned long)g<<8|(unsigned long)b)
+#else
+#define myRGB(r,g,b)	RGB(r,g,b)	/* MSW has this macro */
+#endif
+
+static rgbRecord theRGBRecords[] =
+{
+    {"AliceBlue", myRGB(240, 248, 255)},
+    {"AntiqueWhite", myRGB(250, 235, 215)},
+    {"Aquamarine", myRGB(50, 191, 193)},
+    {"Azure", myRGB(240, 255, 255)},
+    {"Beige", myRGB(245, 245, 220)},
+    {"Bisque", myRGB(255, 228, 196)},
+    {"Black", myRGB(0, 0, 0)},
+    {"BlanchedAlmond", myRGB(255, 235, 205)},
+    {"Blue", myRGB(0, 0, 255)},
+    {"BlueViolet", myRGB(138, 43, 226)},
+    {"Brown", myRGB(165, 42, 42)},
+    {"burlywood", myRGB(222, 184, 135)},
+    {"CadetBlue", myRGB(95, 146, 158)},
+    {"chartreuse", myRGB(127, 255, 0)},
+    {"chocolate", myRGB(210, 105, 30)},
+    {"Coral", myRGB(255, 114, 86)},
+    {"CornflowerBlue", myRGB(34, 34, 152)},
+    {"cornsilk", myRGB(255, 248, 220)},
+    {"Cyan", myRGB(0, 255, 255)},
+    {"DarkGoldenrod", myRGB(184, 134, 11)},
+    {"DarkGreen", myRGB(0, 86, 45)},
+    {"DarkKhaki", myRGB(189, 183, 107)},
+    {"DarkOliveGreen", myRGB(85, 86, 47)},
+    {"DarkOrange", myRGB(255, 140, 0)},
+    {"DarkOrchid", myRGB(139, 32, 139)},
+    {"DarkSalmon", myRGB(233, 150, 122)},
+    {"DarkSeaGreen", myRGB(143, 188, 143)},
+    {"DarkSlateBlue", myRGB(56, 75, 102)},
+    {"DarkSlateGray", myRGB(47, 79, 79)},
+    {"DarkTurquoise", myRGB(0, 166, 166)},
+    {"DarkViolet", myRGB(148, 0, 211)},
+    {"DeepPink", myRGB(255, 20, 147)},
+    {"DeepSkyBlue", myRGB(0, 191, 255)},
+    {"DimGray", myRGB(84, 84, 84)},
+    {"DodgerBlue", myRGB(30, 144, 255)},
+    {"Firebrick", myRGB(142, 35, 35)},
+    {"FloralWhite", myRGB(255, 250, 240)},
+    {"ForestGreen", myRGB(80, 159, 105)},
+    {"gainsboro", myRGB(220, 220, 220)},
+    {"GhostWhite", myRGB(248, 248, 255)},
+    {"Gold", myRGB(218, 170, 0)},
+    {"Goldenrod", myRGB(239, 223, 132)},
+    {"Gray", myRGB(126, 126, 126)},
+    {"Gray0", myRGB(0, 0, 0)},
+    {"Gray1", myRGB(3, 3, 3)},
+    {"Gray10", myRGB(26, 26, 26)},
+    {"Gray100", myRGB(255, 255, 255)},
+    {"Gray11", myRGB(28, 28, 28)},
+    {"Gray12", myRGB(31, 31, 31)},
+    {"Gray13", myRGB(33, 33, 33)},
+    {"Gray14", myRGB(36, 36, 36)},
+    {"Gray15", myRGB(38, 38, 38)},
+    {"Gray16", myRGB(41, 41, 41)},
+    {"Gray17", myRGB(43, 43, 43)},
+    {"Gray18", myRGB(46, 46, 46)},
+    {"Gray19", myRGB(48, 48, 48)},
+    {"Gray2", myRGB(5, 5, 5)},
+    {"Gray20", myRGB(51, 51, 51)},
+    {"Gray21", myRGB(54, 54, 54)},
+    {"Gray22", myRGB(56, 56, 56)},
+    {"Gray23", myRGB(59, 59, 59)},
+    {"Gray24", myRGB(61, 61, 61)},
+    {"Gray25", myRGB(64, 64, 64)},
+    {"Gray26", myRGB(66, 66, 66)},
+    {"Gray27", myRGB(69, 69, 69)},
+    {"Gray28", myRGB(71, 71, 71)},
+    {"Gray29", myRGB(74, 74, 74)},
+    {"Gray3", myRGB(8, 8, 8)},
+    {"Gray30", myRGB(77, 77, 77)},
+    {"Gray31", myRGB(79, 79, 79)},
+    {"Gray32", myRGB(82, 82, 82)},
+    {"Gray33", myRGB(84, 84, 84)},
+    {"Gray34", myRGB(87, 87, 87)},
+    {"Gray35", myRGB(89, 89, 89)},
+    {"Gray36", myRGB(92, 92, 92)},
+    {"Gray37", myRGB(94, 94, 94)},
+    {"Gray38", myRGB(97, 97, 97)},
+    {"Gray39", myRGB(99, 99, 99)},
+    {"Gray4", myRGB(10, 10, 10)},
+    {"Gray40", myRGB(102, 102, 102)},
+    {"Gray41", myRGB(105, 105, 105)},
+    {"Gray42", myRGB(107, 107, 107)},
+    {"Gray43", myRGB(110, 110, 110)},
+    {"Gray44", myRGB(112, 112, 112)},
+    {"Gray45", myRGB(115, 115, 115)},
+    {"Gray46", myRGB(117, 117, 117)},
+    {"Gray47", myRGB(120, 120, 120)},
+    {"Gray48", myRGB(122, 122, 122)},
+    {"Gray49", myRGB(125, 125, 125)},
+    {"Gray5", myRGB(13, 13, 13)},
+    {"Gray50", myRGB(127, 127, 127)},
+    {"Gray51", myRGB(130, 130, 130)},
+    {"Gray52", myRGB(133, 133, 133)},
+    {"Gray53", myRGB(135, 135, 135)},
+    {"Gray54", myRGB(138, 138, 138)},
+    {"Gray55", myRGB(140, 140, 140)},
+    {"Gray56", myRGB(143, 143, 143)},
+    {"Gray57", myRGB(145, 145, 145)},
+    {"Gray58", myRGB(148, 148, 148)},
+    {"Gray59", myRGB(150, 150, 150)},
+    {"Gray6", myRGB(15, 15, 15)},
+    {"Gray60", myRGB(153, 153, 153)},
+    {"Gray61", myRGB(156, 156, 156)},
+    {"Gray62", myRGB(158, 158, 158)},
+    {"Gray63", myRGB(161, 161, 161)},
+    {"Gray64", myRGB(163, 163, 163)},
+    {"Gray65", myRGB(166, 166, 166)},
+    {"Gray66", myRGB(168, 168, 168)},
+    {"Gray67", myRGB(171, 171, 171)},
+    {"Gray68", myRGB(173, 173, 173)},
+    {"Gray69", myRGB(176, 176, 176)},
+    {"Gray7", myRGB(18, 18, 18)},
+    {"Gray70", myRGB(179, 179, 179)},
+    {"Gray71", myRGB(181, 181, 181)},
+    {"Gray72", myRGB(184, 184, 184)},
+    {"Gray73", myRGB(186, 186, 186)},
+    {"Gray74", myRGB(189, 189, 189)},
+    {"Gray75", myRGB(191, 191, 191)},
+    {"Gray76", myRGB(194, 194, 194)},
+    {"Gray77", myRGB(196, 196, 196)},
+    {"Gray78", myRGB(199, 199, 199)},
+    {"Gray79", myRGB(201, 201, 201)},
+    {"Gray8", myRGB(20, 20, 20)},
+    {"Gray80", myRGB(204, 204, 204)},
+    {"Gray81", myRGB(207, 207, 207)},
+    {"Gray82", myRGB(209, 209, 209)},
+    {"Gray83", myRGB(212, 212, 212)},
+    {"Gray84", myRGB(214, 214, 214)},
+    {"Gray85", myRGB(217, 217, 217)},
+    {"Gray86", myRGB(219, 219, 219)},
+    {"Gray87", myRGB(222, 222, 222)},
+    {"Gray88", myRGB(224, 224, 224)},
+    {"Gray89", myRGB(227, 227, 227)},
+    {"Gray9", myRGB(23, 23, 23)},
+    {"Gray90", myRGB(229, 229, 229)},
+    {"Gray91", myRGB(232, 232, 232)},
+    {"Gray92", myRGB(235, 235, 235)},
+    {"Gray93", myRGB(237, 237, 237)},
+    {"Gray94", myRGB(240, 240, 240)},
+    {"Gray95", myRGB(242, 242, 242)},
+    {"Gray96", myRGB(245, 245, 245)},
+    {"Gray97", myRGB(247, 247, 247)},
+    {"Gray98", myRGB(250, 250, 250)},
+    {"Gray99", myRGB(252, 252, 252)},
+    {"Green", myRGB(0, 255, 0)},
+    {"GreenYellow", myRGB(173, 255, 47)},
+    {"honeydew", myRGB(240, 255, 240)},
+    {"HotPink", myRGB(255, 105, 180)},
+    {"IndianRed", myRGB(107, 57, 57)},
+    {"ivory", myRGB(255, 255, 240)},
+    {"Khaki", myRGB(179, 179, 126)},
+    {"lavender", myRGB(230, 230, 250)},
+    {"LavenderBlush", myRGB(255, 240, 245)},
+    {"LawnGreen", myRGB(124, 252, 0)},
+    {"LemonChiffon", myRGB(255, 250, 205)},
+    {"LightBlue", myRGB(176, 226, 255)},
+    {"LightCoral", myRGB(240, 128, 128)},
+    {"LightCyan", myRGB(224, 255, 255)},
+    {"LightGoldenrod", myRGB(238, 221, 130)},
+    {"LightGoldenrodYellow", myRGB(250, 250, 210)},
+    {"LightGray", myRGB(168, 168, 168)},
+    {"LightPink", myRGB(255, 182, 193)},
+    {"LightSalmon", myRGB(255, 160, 122)},
+    {"LightSeaGreen", myRGB(32, 178, 170)},
+    {"LightSkyBlue", myRGB(135, 206, 250)},
+    {"LightSlateBlue", myRGB(132, 112, 255)},
+    {"LightSlateGray", myRGB(119, 136, 153)},
+    {"LightSteelBlue", myRGB(124, 152, 211)},
+    {"LightYellow", myRGB(255, 255, 224)},
+    {"LimeGreen", myRGB(0, 175, 20)},
+    {"linen", myRGB(250, 240, 230)},
+    {"Magenta", myRGB(255, 0, 255)},
+    {"Maroon", myRGB(143, 0, 82)},
+    {"MediumAquamarine", myRGB(0, 147, 143)},
+    {"MediumBlue", myRGB(50, 50, 204)},
+    {"MediumForestGreen", myRGB(50, 129, 75)},
+    {"MediumGoldenrod", myRGB(209, 193, 102)},
+    {"MediumOrchid", myRGB(189, 82, 189)},
+    {"MediumPurple", myRGB(147, 112, 219)},
+    {"MediumSeaGreen", myRGB(52, 119, 102)},
+    {"MediumSlateBlue", myRGB(106, 106, 141)},
+    {"MediumSpringGreen", myRGB(35, 142, 35)},
+    {"MediumTurquoise", myRGB(0, 210, 210)},
+    {"MediumVioletRed", myRGB(213, 32, 121)},
+    {"MidnightBlue", myRGB(47, 47, 100)},
+    {"MintCream", myRGB(245, 255, 250)},
+    {"MistyRose", myRGB(255, 228, 225)},
+    {"moccasin", myRGB(255, 228, 181)},
+    {"NavajoWhite", myRGB(255, 222, 173)},
+    {"Navy", myRGB(35, 35, 117)},
+    {"NavyBlue", myRGB(35, 35, 117)},
+    {"OldLace", myRGB(253, 245, 230)},
+    {"OliveDrab", myRGB(107, 142, 35)},
+    {"Orange", myRGB(255, 135, 0)},
+    {"OrangeRed", myRGB(255, 69, 0)},
+    {"Orchid", myRGB(239, 132, 239)},
+    {"PaleGoldenrod", myRGB(238, 232, 170)},
+    {"PaleGreen", myRGB(115, 222, 120)},
+    {"PaleTurquoise", myRGB(175, 238, 238)},
+    {"PaleVioletRed", myRGB(219, 112, 147)},
+    {"PapayaWhip", myRGB(255, 239, 213)},
+    {"PeachPuff", myRGB(255, 218, 185)},
+    {"peru", myRGB(205, 133, 63)},
+    {"Pink", myRGB(255, 181, 197)},
+    {"Plum", myRGB(197, 72, 155)},
+    {"PowderBlue", myRGB(176, 224, 230)},
+    {"purple", myRGB(160, 32, 240)},
+    {"Red", myRGB(255, 0, 0)},
+    {"RosyBrown", myRGB(188, 143, 143)},
+    {"RoyalBlue", myRGB(65, 105, 225)},
+    {"SaddleBrown", myRGB(139, 69, 19)},
+    {"Salmon", myRGB(233, 150, 122)},
+    {"SandyBrown", myRGB(244, 164, 96)},
+    {"SeaGreen", myRGB(82, 149, 132)},
+    {"seashell", myRGB(255, 245, 238)},
+    {"Sienna", myRGB(150, 82, 45)},
+    {"SkyBlue", myRGB(114, 159, 255)},
+    {"SlateBlue", myRGB(126, 136, 171)},
+    {"SlateGray", myRGB(112, 128, 144)},
+    {"snow", myRGB(255, 250, 250)},
+    {"SpringGreen", myRGB(65, 172, 65)},
+    {"SteelBlue", myRGB(84, 112, 170)},
+    {"Tan", myRGB(222, 184, 135)},
+    {"Thistle", myRGB(216, 191, 216)},
+    {"tomato", myRGB(255, 99, 71)},
+    {"Transparent", myRGB(0, 0, 1)},
+    {"Turquoise", myRGB(25, 204, 223)},
+    {"Violet", myRGB(156, 62, 206)},
+    {"VioletRed", myRGB(243, 62, 150)},
+    {"Wheat", myRGB(245, 222, 179)},
+    {"White", myRGB(255, 255, 255)},
+    {"WhiteSmoke", myRGB(245, 245, 245)},
+    {"Yellow", myRGB(255, 255, 0)},
+    {"YellowGreen", myRGB(50, 216, 56)},
+    NULL
+};
+
+static int numTheRGBRecords = 234;
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/scan.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/scan.c
new file mode 100644
index 0000000..e205cf6
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/scan.c
@@ -0,0 +1,860 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* scan.c:                                                                     *
+*                                                                             *
+*  XPM library                                                                *
+*  Scanning utility for XPM file format                                       *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+#include "xpm34p.h"
+#if defined(FOR_MAC) && defined(__cplusplus)
+extern char *strdup(char *);
+#endif
+#define MAXPRINTABLE 92			/* number of printable ascii chars
+					 * minus \ and " for string compat
+					 * and ? to avoid ANSI trigraphs. */
+
+static char *printable =
+" .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\
+ASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
+
+/*
+ * printable begin with a space, so in most case, due to my algorithm, when
+ * the number of different colors is less than MAXPRINTABLE, it will give a
+ * char follow by "nothing" (a space) in the readable xpm file
+ */
+
+
+typedef struct {
+    Pixel *pixels;
+    unsigned int *pixelindex;
+    unsigned int size;
+    unsigned int ncolors;
+    unsigned int mask_pixel;		/* whether there is or not */
+}      PixelsMap;
+
+LFUNC(storePixel, int, (Pixel pixel, PixelsMap *pmap,
+			unsigned int *index_return));
+
+LFUNC(storeMaskPixel, int, (Pixel pixel, PixelsMap *pmap,
+			    unsigned int *index_return));
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+LFUNC(GetImagePixels, int, (XImage *image, unsigned int width,
+			    unsigned int height, PixelsMap *pmap));
+
+LFUNC(GetImagePixels32, int, (XImage *image, unsigned int width,
+			      unsigned int height, PixelsMap *pmap));
+
+LFUNC(GetImagePixels16, int, (XImage *image, unsigned int width,
+			      unsigned int height, PixelsMap *pmap));
+
+LFUNC(GetImagePixels8, int, (XImage *image, unsigned int width,
+			     unsigned int height, PixelsMap *pmap));
+
+LFUNC(GetImagePixels1, int, (XImage *image, unsigned int width,
+			     unsigned int height, PixelsMap *pmap,
+                             int (*storeFunc) (Pixel,PixelsMap*,
+                                               unsigned int*)));
+
+/*
+			     int (*storeFunc) ()));
+*/
+
+#else  /* ndef FOR_MSW */
+LFUNC(MSWGetImagePixels, int, (Display *d, XImage *image, unsigned int width,
+			       unsigned int height, PixelsMap *pmap));
+#endif
+LFUNC(ScanTransparentColor, int, (XpmColor *color, unsigned int cpp,
+				  XpmAttributes *attributes));
+
+LFUNC(ScanOtherColors, int, (Display *display, XpmColor *colors, int ncolors,
+			     Pixel *pixels, unsigned int mask,
+			     unsigned int cpp, XpmAttributes *attributes));
+
+/*
+ * This function stores the given pixel in the given arrays which are grown
+ * if not large enough.
+ */
+static int
+storePixel(Pixel pixel, PixelsMap *pmap, unsigned int *index_return)
+{
+    unsigned int i;
+    Pixel *p;
+    unsigned int ncolors;
+
+    if (*index_return) {		/* this is a transparent pixel! */
+	*index_return = 0;
+	return 0;
+    }
+    ncolors = pmap->ncolors;
+    p = pmap->pixels + pmap->mask_pixel;
+    for (i = pmap->mask_pixel; i < ncolors; i++, p++)
+	if (*p == pixel)
+	    break;
+    if (i == ncolors) {
+	if (ncolors >= pmap->size) {
+	    pmap->size *= 2;
+	    p = (Pixel *) XpmReallocA(pmap->pixels, sizeof(Pixel) * pmap->size);
+	    if (!p)
+		return (1);
+	    pmap->pixels = p;
+
+	}
+	(pmap->pixels)[ncolors] = pixel;
+	pmap->ncolors++;
+    }
+    *index_return = i;
+    return 0;
+}
+
+static int
+storeMaskPixel(Pixel pixel, PixelsMap *pmap, unsigned int *index_return)
+{
+    if (!pixel) {
+	if (!pmap->ncolors) {
+	    pmap->ncolors = 1;
+	    (pmap->pixels)[0] = 0;
+	    pmap->mask_pixel = 1;
+	}
+	*index_return = 1;
+    } else
+	*index_return = 0;
+    return 0;
+}
+
+/* function call in case of error, frees only locally allocated variables */
+#undef RETURN
+#define RETURN(status) \
+{ \
+    if (pmap.pixelindex) XpmFree(pmap.pixelindex); \
+    if (pmap.pixels) XpmFree(pmap.pixels); \
+    if (colorTable) xpmFreeColorTable(colorTable, pmap.ncolors); \
+    return(status); \
+}
+
+/*
+ * This function scans the given image and stores the found informations in
+ * the given XpmImage structure.
+ */
+int
+XpmCreateXpmImageFromImage(Display *display, XImage *image, XImage *shapeimage,
+			   XpmImage *xpmimage, XpmAttributes *attributes)
+{
+    /* variables stored in the XpmAttributes structure */
+    unsigned int cpp;
+
+    /* variables to return */
+    PixelsMap pmap;
+    XpmColor *colorTable = NULL;
+    int ErrorStatus;
+
+    /* calculation variables */
+    unsigned int width = 0;
+    unsigned int height = 0;
+    unsigned int cppm;			/* minimum chars per pixel */
+    unsigned int c;
+    unsigned int offset;
+
+    /* initialize pmap */
+    pmap.pixels = NULL;
+    pmap.pixelindex = NULL;
+    pmap.size = 256;			/* should be enough most of the time */
+    pmap.ncolors = 0;
+    pmap.mask_pixel = 0;
+
+    /*
+     * get geometry
+     */
+    if (image) {
+	width = image->width;
+	height = image->height;
+    } else if (shapeimage) {
+	width = shapeimage->width;
+	height = shapeimage->height;
+    }
+
+    /*
+     * retrieve information from the XpmAttributes
+     */
+    if (attributes && (attributes->valuemask & XpmCharsPerPixel
+/* 3.2 backward compatibility code */
+		       || attributes->valuemask & XpmInfos))
+/* end 3.2 bc */
+	cpp = attributes->cpp;
+    else
+	cpp = 0;
+
+    pmap.pixelindex =
+	(unsigned int *) XpmCallocA(width * height, sizeof(unsigned int));
+    if (!pmap.pixelindex)
+	RETURN(XpmNoMemory);
+
+    pmap.pixels = (Pixel *) XpmMallocA(sizeof(Pixel) * pmap.size);
+    if (!pmap.pixels)
+	RETURN(XpmNoMemory);
+
+    /*
+     * scan shape mask if any
+     */
+    if (shapeimage) {
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+	ErrorStatus = GetImagePixels1(shapeimage, width, height, &pmap,
+				      storeMaskPixel);
+#else
+	ErrorStatus = MSWGetImagePixels(display, shapeimage, width, height,
+					&pmap);
+#endif
+	if (ErrorStatus != XpmSuccess)
+	    RETURN(ErrorStatus);
+    }
+
+    /*
+     * scan the image data
+     * 
+     * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use optimized
+     * functions, otherwise use slower but sure general one.
+     * 
+     */
+
+    if (image) {
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+	if (image->depth == 1)
+	    ErrorStatus = GetImagePixels1(image, width, height, &pmap,
+					  storePixel);
+	else if (image->bits_per_pixel == 8)
+	    ErrorStatus = GetImagePixels8(image, width, height, &pmap);
+	else if (image->bits_per_pixel == 16)
+	    ErrorStatus = GetImagePixels16(image, width, height, &pmap);
+	else if (image->bits_per_pixel == 32)
+	    ErrorStatus = GetImagePixels32(image, width, height, &pmap);
+	else
+	    ErrorStatus = GetImagePixels(image, width, height, &pmap);
+#else					/* FOR_MSW */
+	ErrorStatus = MSWGetImagePixels(display, image, width, height, &pmap);
+#endif
+	if (ErrorStatus != XpmSuccess)
+	    RETURN(ErrorStatus);
+    }
+
+    /*
+     * get rgb values and a string of char, and possibly a name for each
+     * color
+     */
+
+    colorTable = (XpmColor *) XpmCalloc(pmap.ncolors, sizeof(XpmColor));
+    if (!colorTable)
+	RETURN(XpmNoMemory);
+
+    /* compute the minimal cpp */
+    for (cppm = 1, c = MAXPRINTABLE; pmap.ncolors > c; cppm++)
+	c *= MAXPRINTABLE;
+    if (cpp < cppm)
+	cpp = cppm;
+
+    if (pmap.mask_pixel) {
+	ErrorStatus = ScanTransparentColor(colorTable, cpp, attributes);
+	if (ErrorStatus != XpmSuccess)
+	    RETURN(ErrorStatus);
+	offset = 1;
+    } else
+	offset = 0;
+
+    ErrorStatus = ScanOtherColors(display, colorTable + offset,
+				  pmap.ncolors - offset, pmap.pixels + offset,
+				  pmap.mask_pixel, cpp, attributes);
+    if (ErrorStatus != XpmSuccess)
+	RETURN(ErrorStatus);
+
+    /*
+     * store found informations in the XpmImage structure
+     */
+    xpmimage->width = width;
+    xpmimage->height = height;
+    xpmimage->cpp = cpp;
+    xpmimage->ncolors = pmap.ncolors;
+    xpmimage->colorTable = colorTable;
+    xpmimage->data = pmap.pixelindex;
+
+    XpmFree(pmap.pixels);
+    return (XpmSuccess);
+}
+
+static int
+ScanTransparentColor(XpmColor *color, unsigned int cpp, XpmAttributes *attributes)
+{
+    char *s;
+    unsigned int a, b, c;
+
+    /* first get a character string */
+    a = 0;
+    if (!(s = color->string = (char *) XpmMallocA(cpp + 1)))
+	return (XpmNoMemory);
+    *s++ = printable[c = a % MAXPRINTABLE];
+    for (b = 1; b < cpp; b++, s++)
+	*s = printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];
+    *s = '\0';
+
+    /* then retreive related info from the attributes if any */
+    if (attributes && attributes->mask_pixel != XpmUndefPixel && (
+/* 3.2 backward compatibility code */
+	attributes->valuemask & XpmInfos ||
+/* end 3.2 bc */
+	attributes->valuemask & XpmColorTable)) {
+
+	unsigned int key;
+	char **defaults = (char **) color;
+	char **mask_defaults;
+
+/* 3.2 backward compatibility code */
+	if (attributes->valuemask & XpmInfos)
+	    mask_defaults = (char **)
+		((XpmColor **) attributes->colorTable)[attributes->mask_pixel];
+	else
+/* end 3.2 bc */
+	    mask_defaults = (char **) (
+		attributes->colorTable + attributes->mask_pixel);
+	for (key = 1; key <= NKEYS; key++) {
+	    if (s = mask_defaults[key]) {
+		defaults[key] = (char *) strdup(s);
+		if (!defaults[key])
+		    return (XpmNoMemory);
+	    }
+	}
+    } else {
+	color->c_color = (char *) strdup(TRANSPARENT_COLOR);
+	if (!color->c_color)
+	    return (XpmNoMemory);
+    }
+    return (XpmSuccess);
+}
+
+static int
+ScanOtherColors(Display *display, XpmColor *colors, int ncolors, Pixel *pixels,
+  unsigned int mask, unsigned int cpp, XpmAttributes *attributes)
+{
+    /* variables stored in the XpmAttributes structure */
+    Colormap colormap;
+    char *rgb_fname;
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+    xpmRgbName rgbn[MAX_RGBNAMES];
+#else
+    xpmRgbName *rgbn = NULL; 
+#endif    
+    int rgbn_max = 0;
+    unsigned int i, j, c, i2;
+    XpmColor *color;
+    XColor *xcolors = NULL, *xcolor;
+    char *colorname, *s;
+    XpmColor *colorTable, **oldColorTable = NULL;
+    unsigned int ancolors = 0;
+    Pixel *apixels;
+    unsigned int mask_pixel;
+    int found;
+
+    /* retrieve information from the XpmAttributes */
+    if (attributes && (attributes->valuemask & XpmColormap))
+	colormap = attributes->colormap;
+    else
+	colormap = XDefaultColormap(display, XDefaultScreen(display));
+    if (attributes && (attributes->valuemask & XpmRgbFilename))
+	rgb_fname = attributes->rgb_fname;
+    else
+	rgb_fname = NULL;
+
+    /* first get character strings and rgb values */
+    xcolors = (XColor *) XpmMallocA(sizeof(XColor) * ncolors);
+    if (!xcolors)
+	return (XpmNoMemory);
+
+    for (i = 0, i2 = (mask ? i + 1 : i), color = colors, xcolor = xcolors;
+	 i < ncolors; i++, i2++, color++, xcolor++, pixels++) {
+
+	if (!(s = color->string = (char *) XpmMallocA(cpp + 1))) {
+	    XpmFree(xcolors);
+	    return (XpmNoMemory);
+	}
+	*s++ = printable[c = i2 % MAXPRINTABLE];
+	for (j = 1; j < cpp; j++, s++)
+	    *s = printable[c = ((i2 - c) / MAXPRINTABLE) % MAXPRINTABLE];
+	*s = '\0';
+
+	xcolor->pixel = *pixels;
+    }
+#if defined(wx_msw) || defined(FOR_MAC)
+    XQueryColors(display, (Colormap *)colormap, xcolors, ncolors);
+#else
+    XQueryColors(display, (Colormap)colormap, xcolors, ncolors);
+#endif
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+    /* read the rgb file if any was specified */
+    if (rgb_fname)
+	rgbn_max = xpmReadRgbNames(attributes->rgb_fname, rgbn);
+#else
+    /* FOR_MSW: rgb names and values are hardcoded in rgbtab.h */
+    rgbn_max = xpmReadRgbNames(NULL, NULL);
+#endif
+
+    if (attributes && attributes->valuemask & XpmColorTable) {
+	colorTable = attributes->colorTable;
+	ancolors = attributes->ncolors;
+	apixels = attributes->pixels;
+	mask_pixel = attributes->mask_pixel;
+    }
+/* 3.2 backward compatibility code */
+    else if (attributes && attributes->valuemask & XpmInfos) {
+	oldColorTable = (XpmColor **) attributes->colorTable;
+	ancolors = attributes->ncolors;
+	apixels = attributes->pixels;
+	mask_pixel = attributes->mask_pixel;
+    }
+/* end 3.2 bc */
+
+    for (i = 0, color = colors, xcolor = xcolors; i < ncolors;
+						  i++, color++, xcolor++) {
+
+	/* look for related info from the attributes if any */
+	found = False;
+	if (ancolors) {
+	    unsigned int offset = 0;
+
+	    for (j = 0; j < ancolors; j++) {
+		if (j == mask_pixel) {
+		    offset = 1;
+		    continue;
+		}
+		if (apixels[j - offset] == xcolor->pixel)
+		    break;
+	    }
+	    if (j != ancolors) {
+		unsigned int key;
+		char **defaults = (char **) color;
+		char **adefaults;
+
+/* 3.2 backward compatibility code */
+		if (oldColorTable)
+		    adefaults = (char **) oldColorTable[j];
+		else
+/* end 3.2 bc */
+		    adefaults = (char **) (colorTable + j);
+
+		found = True;
+		for (key = 1; key <= NKEYS; key++) {
+		    if (s = adefaults[key])
+			defaults[key] = (char *) strdup(s);
+		}
+	    }
+	}
+	if (!found) {
+	    /* if nothing found look for a color name */
+	    colorname = NULL;
+	    if (rgbn_max)
+		colorname = xpmGetRgbName(rgbn, rgbn_max, xcolor->red,
+					  xcolor->green, xcolor->blue);
+	    if (colorname)
+		color->c_color = (char *) strdup(colorname);
+	    else {
+		/* at last store the rgb value */
+		char buf[BUFSIZ];
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+		sprintf(buf, "#%04X%04X%04X",
+			xcolor->red, xcolor->green, xcolor->blue);
+#else   
+		sprintf(buf, "#%02x%02x%02x",
+			xcolor->red, xcolor->green, xcolor->blue);
+#endif			
+		color->c_color = (char *) strdup(buf);
+	    }
+	    if (!color->c_color) {
+		XpmFree(xcolors);
+		xpmFreeRgbNames(rgbn, rgbn_max);
+		return (XpmNoMemory);
+	    }
+	}
+    }
+
+    XpmFree(xcolors);
+    xpmFreeRgbNames(rgbn, rgbn_max);
+    return (XpmSuccess);
+}
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+/*
+ * The functions below are written from X11R5 MIT's code (XImUtil.c)
+ *
+ * The idea is to have faster functions than the standard XGetPixel function
+ * to scan the image data. Indeed we can speed up things by suppressing tests
+ * performed for each pixel. We do exactly the same tests but at the image
+ * level. Assuming that we use only ZPixmap images.
+ */
+
+static unsigned long Const low_bits_table[] = {
+    0x00000000, 0x00000001, 0x00000003, 0x00000007,
+    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
+    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
+    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
+    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
+    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
+    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
+    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
+    0xffffffff
+};
+
+/*
+ * Default method to scan pixels of a Z image data structure.
+ * The algorithm used is:
+ *
+ *	copy the source bitmap_unit or Zpixel into temp
+ *	normalize temp if needed
+ *	extract the pixel bits into return value
+ *
+ */
+
+static int
+GetImagePixels(XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap)
+{
+    char *src;
+    char *dst;
+    unsigned int *iptr;
+    char *data;
+    int x, y, i;
+    int bits, depth, ibu, ibpp;
+    unsigned long lbt;
+    Pixel pixel, px;
+
+    data = image->data;
+    iptr = pmap->pixelindex;
+    depth = image->depth;
+    lbt = low_bits_table[depth];
+    ibpp = image->bits_per_pixel;
+    if (image->depth == 1) {
+	ibu = image->bitmap_unit;
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		src = &data[XYINDEX(x, y, image)];
+		dst = (char *) &pixel;
+		pixel = 0;
+		for (i = ibu >> 3; --i >= 0;)
+		    *dst++ = *src++;
+		XYNORMALIZE(&pixel, image);
+		bits = x % ibu;
+		pixel = ((((char *) &pixel)[bits >> 3]) >> (bits & 7)) & 1;
+		if (ibpp != depth)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    } else {
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		src = &data[ZINDEX(x, y, image)];
+		dst = (char *) &px;
+		px = 0;
+		for (i = (ibpp + 7) >> 3; --i >= 0;)
+		    *dst++ = *src++;
+		ZNORMALIZE(&px, image);
+		pixel = 0;
+		for (i = sizeof(unsigned long); --i >= 0;)
+		    pixel = (pixel << 8) | ((unsigned char *) &px)[i];
+		if (ibpp == 4) {
+		    if (x & 1)
+			pixel >>= 4;
+		    else
+			pixel &= 0xf;
+		}
+		if (ibpp != depth)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    }
+    return (XpmSuccess);
+}
+
+/*
+ * scan pixels of a 32-bits Z image data structure
+ */
+
+#ifndef WORD64
+static unsigned long byteorderpixel = MSBFirst << 24;
+
+#endif
+
+static int
+GetImagePixels32(XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap)
+{
+    unsigned char *addr;
+    unsigned char *data;
+    unsigned int *iptr;
+    int x, y;
+    unsigned long lbt;
+    Pixel pixel;
+    int depth;
+
+    data = (unsigned char *) image->data;
+    iptr = pmap->pixelindex;
+    depth = image->depth;
+    lbt = low_bits_table[depth];
+#ifndef WORD64
+    if (*((char *) &byteorderpixel) == image->byte_order) {
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		pixel = *((unsigned long *) addr);
+		if (depth != 32)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    } else
+#endif
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		pixel = ((unsigned long) addr[0] << 24 |
+			 (unsigned long) addr[1] << 16 |
+			 (unsigned long) addr[2] << 8 |
+			 addr[4]);
+		if (depth != 32)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    else
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX32(x, y, image)];
+		pixel = (addr[0] |
+			 (unsigned long) addr[1] << 8 |
+			 (unsigned long) addr[2] << 16 |
+			 (unsigned long) addr[3] << 24);
+		if (depth != 32)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    return (XpmSuccess);
+}
+
+/*
+ * scan pixels of a 16-bits Z image data structure
+ */
+
+static int
+GetImagePixels16(XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap)
+{
+    unsigned char *addr;
+    unsigned char *data;
+    unsigned int *iptr;
+    int x, y;
+    unsigned long lbt;
+    Pixel pixel;
+    int depth;
+
+    data = (unsigned char *) image->data;
+    iptr = pmap->pixelindex;
+    depth = image->depth;
+    lbt = low_bits_table[depth];
+    if (image->byte_order == MSBFirst)
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX16(x, y, image)];
+		pixel = addr[0] << 8 | addr[1];
+		if (depth != 16)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    else
+	for (y = 0; y < height; y++)
+	    for (x = 0; x < width; x++, iptr++) {
+		addr = &data[ZINDEX16(x, y, image)];
+		pixel = addr[0] | addr[1] << 8;
+		if (depth != 16)
+		    pixel &= lbt;
+		if (storePixel(pixel, pmap, iptr))
+		    return (XpmNoMemory);
+	    }
+    return (XpmSuccess);
+}
+
+/*
+ * scan pixels of a 8-bits Z image data structure
+ */
+
+static int
+GetImagePixels8(XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap)
+{
+    unsigned int *iptr;
+    unsigned char *data;
+    int x, y;
+    unsigned long lbt;
+    Pixel pixel;
+    int depth;
+
+    data = (unsigned char *) image->data;
+    iptr = pmap->pixelindex;
+    depth = image->depth;
+    lbt = low_bits_table[depth];
+    for (y = 0; y < height; y++)
+	for (x = 0; x < width; x++, iptr++) {
+	    pixel = data[ZINDEX8(x, y, image)];
+	    if (depth != 8)
+		pixel &= lbt;
+	    if (storePixel(pixel, pmap, iptr))
+		return (XpmNoMemory);
+	}
+    return (XpmSuccess);
+}
+
+/*
+ * scan pixels of a 1-bit depth Z image data structure
+ */
+
+static int
+GetImagePixels1(XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap,
+/*
+  int (*storeFunc)()
+*/
+  int (*storeFunc)(Pixel,PixelsMap*,unsigned int*)
+)
+{
+    unsigned int *iptr;
+    int x, y;
+    char *data;
+    Pixel pixel;
+
+    if (image->byte_order != image->bitmap_bit_order)
+	return (GetImagePixels(image, width, height, pmap));
+    else {
+	data = image->data;
+	iptr = pmap->pixelindex;
+	if (image->bitmap_bit_order == MSBFirst)
+	    for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++, iptr++) {
+		    pixel = (data[ZINDEX1(x, y, image)] & (0x80 >> (x & 7)))
+			? 1 : 0;
+		    if ((*storeFunc) (pixel, pmap, iptr))
+			return (XpmNoMemory);
+		}
+	else
+	    for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++, iptr++) {
+		    pixel = (data[ZINDEX1(x, y, image)] & (1 << (x & 7)))
+			? 1 : 0;
+		    if ((*storeFunc) (pixel, pmap, iptr))
+			return (XpmNoMemory);
+		}
+    }
+    return (XpmSuccess);
+}
+
+#else  /* ndef FOR_MSW */
+static int
+MSWGetImagePixels(Display *display, XImage *image, unsigned int width, unsigned int height, PixelsMap *pmap)
+{
+    unsigned int *iptr;
+    unsigned int x, y;
+    Pixel pixel;
+
+    iptr = pmap->pixelindex;
+
+    for (y = 0; y < height; y++) {
+	for (x = 0; x < width; x++, iptr++) {
+	    /* bitmap must be selected !!! ??? */
+#ifdef FOR_MAC
+		RGBColor	macpixel;
+		GetCPixel(x, y, &macpixel);
+		pixel = (((macpixel.red >> 8) & 0xFF)<<16) | (((macpixel.green >> 8) & 0xFF) << 8) |
+			 ((macpixel.blue >> 8) & 0xFF);
+#else
+	    pixel = GetPixel(*display, x, y);
+#endif
+	    if (storePixel(pixel, pmap, iptr))
+		return (XpmNoMemory);
+	}
+    }
+    return (XpmSuccess);
+}
+
+#endif
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+int
+XpmCreateXpmImageFromPixmap(Display *display, Pixmap pixmap, Pixmap shapemask,
+			    XpmImage *xpmimage, XpmAttributes *attributes)
+{
+    XImage *ximage = NULL;
+    XImage *shapeimage = NULL;
+    unsigned int width = 0;
+    unsigned int height = 0;
+    int ErrorStatus;
+
+    /* get geometry */
+    if (attributes && attributes->valuemask & XpmSize) {
+	width = attributes->width;
+	height = attributes->height;
+    }
+    /* get the ximages */
+    if (pixmap)
+	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);
+    if (shapemask)
+	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,
+				 &width, &height);
+
+    /* create the related XpmImage */
+    ErrorStatus = XpmCreateXpmImageFromImage(display, ximage, shapeimage,
+					     xpmimage, attributes);
+
+    /* destroy the ximages */
+    if (ximage)
+	XDestroyImage(ximage);
+    if (shapeimage)
+	XDestroyImage(shapeimage);
+
+    return (ErrorStatus);
+}
+
+#endif /* ndef FOR_MSW */
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.c
new file mode 100644
index 0000000..51922e8
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.c
@@ -0,0 +1,333 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* simx.c: 0.1a                                                                *
+*                                                                             *
+* This emulates some Xlib functionality for MSW. It's not a general solution, *
+* it is close related to XPM-lib. It is only intended to satisfy what is need *
+* there. Thus allowing to read XPM files under MS windows.                    *
+*                                                                             *
+* Developed by HeDu 3/94 (hedu@cul-ipn.uni-kiel.de)                           *
+\*****************************************************************************/
+
+#if defined(FOR_MSW) || defined(FOR_MAC)
+
+#include "xpm34.h"
+#include "xpm34p.h"			/* for XpmMalloc */
+#ifdef FOR_MAC
+#  include <stdlib.h>
+#  include <Memory.h>
+#  ifdef __cplusplus
+     extern  int xpmGetRGBfromName(char *inname, int *r, int *g, int *b);
+#  endif
+#  define RGB(r, g, b) (((r << 16) | (g << 8) | b) & 0xFFFFFF)
+#endif
+/*
+ * On DOS size_t is only 2 bytes, thus malloc(size_t s) can only malloc
+ * 64K. BUT an expression data=malloc(width*height) may result in an
+ * overflow. So this function takes a long as input, and returns NULL if the
+ * request is larger than 64K, is size_t is only 2 bytes.
+ *
+ * This requires casts like XpmMalloc( (long)width*(long(height)), else it
+ * might have no effect at all.
+ */
+#ifdef FOR_MSW
+void *
+boundCheckingMalloc(long s)
+{
+    if (sizeof(size_t) == sizeof(long)) {	/* same size, just do it */
+	return (XpmMalloc((size_t) s));
+    } else {
+	if (sizeof(size_t) == 2) {
+	    if (s > 0xFFFF)
+		return (NULL);		/* to large, size_t with 2 bytes
+					 * only allows 16 bits */
+	    else
+		return (XpmMalloc((size_t) s));
+	} else {			/* it's not a long, not 2 bytes,
+					 * what is it ??? */
+	    return (XpmMalloc((size_t) s));
+	}
+    }
+}
+void *
+boundCheckingCalloc(long num, long s)
+{
+    if (sizeof(size_t) == sizeof(long)) {	/* same size, just do it */
+	return (calloc((size_t) num, (size_t) s));
+    } else {
+	if (sizeof(size_t) == 2) {
+	    if (s > 0xFFFF || num * s > 0xFFFF)
+		return (NULL);		/* to large, size_t with 2 bytes
+					 * only allows 16 bits */
+	    else
+		return (calloc((size_t) num, (size_t) s));
+	} else {			/* it's not a long, not 2 bytes,
+					 * what is it ??? */
+	    return (calloc((size_t) num, (size_t) s));
+	}
+    }
+}
+void *
+boundCheckingRealloc(void *p, long s)
+{
+    if (sizeof(size_t) == sizeof(long)) {	/* same size, just do it */
+	return (realloc(p, (size_t) s));
+    } else {
+	if (sizeof(size_t) == 2) {
+	    if (s > 0xFFFF)
+		return (NULL);		/* to large, size_t with 2 bytes
+					 * only allows 16 bits */
+	    else
+		return (realloc(p, (size_t) s));
+	} else {			/* it's not a long, not 2 bytes,
+					 * what is it ??? */
+	    return (realloc(p, (size_t) s));
+	}
+    }
+}
+#endif /* FOR_MSW */
+
+/* static Visual theVisual = { 0 }; */
+Visual *
+XDefaultVisual(Display *display, Screen *screen)
+{
+    return (NULL);			/* struct could contain info about
+					 * MONO, GRAY, COLOR */
+}
+
+Screen *
+XDefaultScreen(Display *d)
+{
+    return (NULL);
+}
+
+/* I get only 1 plane but 8 bits per pixel,
+   so I think BITSPIXEL should be depth */
+int 
+XDefaultDepth(Display *display, Screen *screen)
+{
+    int d, b;
+#ifdef FOR_MAC
+	PixMapHandle pmap;
+	GDHandle dev;
+	dev = GetGDevice();
+	pmap = (**dev).gdPMap;
+	b = (**pmap).pixelSize;
+#else
+    b = GetDeviceCaps(*display, BITSPIXEL);
+    d = GetDeviceCaps(*display, PLANES);
+#endif
+    return (b);
+}
+
+Colormap *
+XDefaultColormap(Display *display, Screen *screen)
+{
+    return (NULL);
+}
+
+/* convert hex color names,
+   wrong digits (not a-f,A-F,0-9) are treated as zero */
+static int 
+hexCharToInt(char c)
+{
+    int r;
+
+    if (c >= '0' && c <= '9')
+	r = c - '0';
+    else if (c >= 'a' && c <= 'f')
+	r = c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+	r = c - 'A' + 10;
+    else
+	r = 0;
+
+    return (r);
+}
+
+static int 
+rgbFromHex(char *hex, int *r, int *g, int *b)
+{
+    int len;
+
+    if (hex == NULL || hex[0] != '#')
+	return (0);
+
+    len = strlen(hex);
+    if (len == 3 + 1) {
+	*r = hexCharToInt(hex[1]);
+	*g = hexCharToInt(hex[2]);
+	*b = hexCharToInt(hex[3]);
+    } else if (len == 6 + 1) {
+	*r = hexCharToInt(hex[1]) * 16 + hexCharToInt(hex[2]);
+	*g = hexCharToInt(hex[3]) * 16 + hexCharToInt(hex[4]);
+	*b = hexCharToInt(hex[5]) * 16 + hexCharToInt(hex[6]);
+    } else if (len == 12 + 1) {
+	/* it's like c #32329999CCCC */
+	/* so for now only take two digits */
+	*r = hexCharToInt(hex[1]) * 16 + hexCharToInt(hex[2]);
+	*g = hexCharToInt(hex[5]) * 16 + hexCharToInt(hex[6]);
+	*b = hexCharToInt(hex[9]) * 16 + hexCharToInt(hex[10]);
+    } else
+	return (0);
+
+    return (1);
+}
+
+/* Color related functions */
+int 
+XParseColor(Display *d, Colormap *cmap, char *name, XColor *color)
+{
+    int r, g, b;			/* only 8 bit values used */
+    int okay;
+
+/* TODO: use colormap via PALETTE */
+    /* parse name either in table or #RRGGBB #RGB */
+    if (name == NULL)
+	return (0);
+
+    if (name[0] == '#') {		/* a hex string */
+	okay = rgbFromHex(name, &r, &g, &b);
+    } else {
+	okay = xpmGetRGBfromName(name, &r, &g, &b);
+    }
+
+    if (okay) {
+	color->pixel = RGB(r, g, b);
+	color->red = (BYTE) r;
+	color->green = (BYTE) g;
+	color->blue = (BYTE) b;
+	return (1);
+    } else
+	return (0);			/* --> ColorError */
+}
+
+
+int 
+XAllocColor(Display *d, Colormap *cmap, XColor *color)
+{
+/* colormap not used yet so color->pixel is the real COLORREF (RBG) and not an
+   index in some colormap as in X */
+    return (1);
+}
+void 
+XQueryColors(Display *display, Colormap *colormap,
+	     XColor *xcolors, int ncolors)
+{
+/* under X this fills the rgb values to given .pixel */
+/* since there no colormap use FOR_MSW (not yet!!), rgb is plain encoded */
+    XColor *xc = xcolors;
+    int i;
+
+    for (i = 0; i < ncolors; i++, xc++) {
+	xc->red = GetRValue(xc->pixel);
+	xc->green = GetGValue(xc->pixel);
+	xc->blue = GetBValue(xc->pixel);
+    }
+    return;
+}
+int 
+XFreeColors(Display *d, Colormap cmap,
+	    unsigned long pixels[], int npixels, unsigned long planes)
+{
+    /* no colormap yet */
+    return (0);				/* correct ??? */
+}
+
+/* XImage functions */
+XImage *
+XCreateImage(Display *d, Visual *v,
+	     int depth, int format,
+	     int x, int y, int width, int height,
+	     int pad, int foo)
+{
+    XImage *img = (XImage *) XpmMalloc(sizeof(XImage));
+
+    if (img) {
+	/* *img = CreateCompatibleBitmap(*d, width, height); */
+#ifdef FOR_MAC
+	/* Looks like we need to build a offscreen GWorld to draw the Picture in */
+	GDHandle savegw;
+	CGrafPtr saveport;
+	Rect bounds = {0, 0, height, width};
+	GetGWorld(&saveport, &savegw);
+	QDErr err;
+	GWorldPtr	newGWorld;
+	err = NewGWorld(&newGWorld, 0, &bounds, NULL, NULL, noNewDevice);
+	if (!err) {
+  	  SetGWorld(newGWorld, 0);
+	  ::EraseRect(&bounds);
+	  img->bitmap = newGWorld;	
+	  SetGWorld(saveport, savegw);
+	} else {
+		img->bitmap = NULL;
+		return NULL;
+	}
+#else
+	img->bitmap = CreateBitmap(width, height, 1 /* plane */ ,
+				   depth /* bits per pixel */ , NULL);
+#endif
+	img->width = width;
+	img->height = height;
+	img->depth = depth;
+    }
+    return (img);
+
+}
+
+void 
+XImageFree(XImage *img)
+{
+    if (img) {
+	XpmFree(img);
+    }
+}
+
+void 
+XDestroyImage(XImage *img)
+{
+    if (img) {
+#ifdef FOR_MAC
+	/* I don't believe this is called in wx_mac
+	   What we should do here is destroy the GWorld
+	*/
+		GWorldPtr x_pixmap;
+		if (x_pixmap = img->bitmap) {
+			::DisposeCTable((*x_pixmap->portPixMap)->pmTable);
+			(*x_pixmap->portPixMap)->pmTable = 0;
+			::DisposePtr((Ptr) (*x_pixmap->portPixMap)->baseAddr);
+			(*x_pixmap->portPixMap)->baseAddr = 0;
+			DisposeGWorld(x_pixmap);
+		}
+#else
+		DeleteObject(img->bitmap);	/* check return ??? */
+#endif
+		XImageFree(img);
+    }
+}
+
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.h b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.h
new file mode 100644
index 0000000..631b72c
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/simx.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* simx.h: 0.1a                                                                *
+*                                                                             *
+* This emulates some Xlib functionality for MSW. It's not a general solution, *
+* it is close related to XPM-lib. It is only intended to satisfy what is need *
+* there. Thus allowing to read XPM files under MS windows.                    *
+*                                                                             *
+* Developed by HeDu 3/94 (hedu@cul-ipn.uni-kiel.de)                           *
+\*****************************************************************************/
+
+
+#ifndef _SIMX_H
+#define _SIMX_H
+
+#if defined(FOR_MSW)
+
+#include "windows.h"			/* MS windows GDI types */
+#endif
+#if  defined(FOR_MAC)
+#include <QDOffscreen.h>
+#include <QuickDraw.h>
+/*
+ * minimal portability layer between ansi and KR C
+ */
+/* this comes from xpm.h, and is here again, to avoid complicated
+    includes, since this is included from xpm.h */
+/* these defines get undefed at the end of this file */
+#if __STDC__ || defined(__cplusplus) || defined(c_plusplus)
+ /* ANSI || C++ */
+#define FUNC(f, t, p) extern t f p
+#define LFUNC(f, t, p) static t f p
+#else /* k&R */
+#define FUNC(f, t, p) extern t f()
+#define LFUNC(f, t, p) static t f()
+#endif
+
+
+FUNC(boundCheckingMalloc, void *, (long s));
+FUNC(boundCheckingCalloc, void *, (long num, long s));
+FUNC(boundCheckingRealloc, void *, (void *p, long s));
+
+/* define MSW types for X window types,
+   I don't know much about MSW, but the following defines do the job */
+#ifdef FOR_MAC
+typedef GDPtr Display;		/* ?? */
+#else
+typedef HDC Display;			/* this should be similar */
+#endif
+typedef void *Screen;			/* not used */
+typedef void *Visual;			/* not used yet, is for GRAY, COLOR,
+					 * MONO */
+
+typedef void *Colormap;			/* should be COLORPALETTE, not done
+					 * yet */
+#ifdef FOR_MAC
+typedef unsigned char BYTE;
+typedef unsigned long Pixel;
+#define GetRValue(rgbcolour)  ((rgbcolour >> 16) & 0xFF)
+#define GetGValue(rgbcolour)  ((rgbcolour >> 8) & 0xFF)
+#define GetBValue(rgbcolour)  (rgbcolour & 0xFF)
+#else
+typedef COLORREF Pixel;
+#endif
+
+#define PIXEL_ALREADY_TYPEDEFED		/* to let xpm.h know about it */
+
+typedef struct {
+    Pixel pixel;
+    BYTE red, green, blue;
+}      XColor;
+
+typedef struct {
+#ifdef FOR_MAC
+	GWorldPtr bitmap;
+
+#else
+    HBITMAP bitmap;
+#endif
+    unsigned int width;
+    unsigned int height;
+    unsigned int depth;
+}      XImage;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+/* some replacements for X... functions */
+
+/* XDefaultXXX */
+    FUNC(XDefaultVisual, Visual *, (Display *display, Screen *screen));
+    FUNC(XDefaultScreen, Screen *, (Display *d));
+    FUNC(XDefaultColormap, Colormap *, (Display *display, Screen *screen));
+    FUNC(XDefaultDepth, int, (Display *d, Screen *s));
+
+/* color related */
+    FUNC(XParseColor, int, (Display *, Colormap *, char *, XColor *));
+    FUNC(XAllocColor, int, (Display *, Colormap *, XColor *));
+    FUNC(XQueryColors, void, (Display *display, Colormap *colormap,
+			      XColor *xcolors, int ncolors));
+    FUNC(XFreeColors, int, (Display *d, Colormap cmap,
+			    unsigned long pixels[],
+			    int npixels, unsigned long planes));
+/* XImage */
+    FUNC(XCreateImage, XImage *, (Display *, Visual *, int depth, int format,
+				  int x, int y, int width, int height,
+				  int pad, int foo));
+
+/* free and destroy bitmap */
+    FUNC(XDestroyImage, void /* ? */ , (XImage *));
+/* free only, bitmap remains */
+    FUNC(XImageFree, void, (XImage *));
+#if defined(__cplusplus) || defined(c_plusplus)
+} /* end of extern "C" */
+#endif /* cplusplus */
+
+#define ZPixmap 1			/* not really used */
+
+#ifndef True
+#define True 1
+#define False 0
+#endif
+
+/*
+#ifndef Bool
+typedef BOOL Bool;
+#endif
+*/
+
+/* make these local here, simx.c gets the same from xpm.h */
+#undef LFUNC
+#undef FUNC
+
+#endif /* def FOR_MSW */
+
+#endif /* _SIMX_H */
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrdat.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrdat.c
new file mode 100644
index 0000000..0713d76
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrdat.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmWrFFrData.c:                                                             *
+*                                                                             *
+*  XPM library                                                                *
+*  Parse an Xpm array and write a file that corresponds to it.                *
+*                                                                             *
+*  Developed by Dan Greening dgreen@cs.ucla.edu / dgreen@sti.com              *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+
+int
+XpmWriteFileFromData(char *filename, char **data)
+{
+    XpmImage image;
+    XpmInfo info;
+    int ErrorStatus;
+
+    info.valuemask = XpmReturnComments | XpmReturnExtensions;
+
+    ErrorStatus = XpmCreateXpmImageFromData(data, &image, &info);
+
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    ErrorStatus = XpmWriteFileFromXpmImage(filename, &image, &info);
+
+    XpmFreeXpmImage(&image);
+    XpmFreeXpmInfo(&info);
+
+    return (ErrorStatus);
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffri.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffri.c
new file mode 100644
index 0000000..1d31b2d
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffri.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* XpmWrFFrI.c:                                                                *
+*                                                                             *
+*  XPM library                                                                *
+*  Write an image and possibly its mask to an XPM file                        *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+#ifdef FOR_MSW
+#include "ctype.h"
+#endif
+
+#include <string.h>
+
+LFUNC(WriteColors, void, (FILE *file, XpmColor *colors, unsigned int ncolors));
+
+LFUNC(WritePixels, int, (FILE *file, unsigned int width, unsigned int height,
+			 unsigned int cpp, unsigned int *pixels,
+			 XpmColor *colors));
+
+LFUNC(WriteExtensions, void, (FILE *file, XpmExtension *ext,
+			      unsigned int num));
+
+int
+XpmWriteFileFromImage(Display *display, char *filename, XImage *image, XImage *shapeimage, XpmAttributes *attributes)
+{
+    XpmImage xpmimage;
+    XpmInfo info;
+    int ErrorStatus;
+
+    /* create an XpmImage from the image */
+    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
+					     &xpmimage, attributes);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* write the file from the XpmImage */
+    if (attributes) {
+	xpmSetInfo(&info, attributes);
+	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, &info);
+    } else
+	ErrorStatus = XpmWriteFileFromXpmImage(filename, &xpmimage, NULL);
+
+    /* free the XpmImage */
+    XpmFreeXpmImage(&xpmimage);
+
+    return (ErrorStatus);
+}
+
+int
+XpmWriteFileFromXpmImage(char *filename, XpmImage *image, XpmInfo *info)
+{
+    xpmData mdata;
+    char *name, *dot, *s, new_name[BUFSIZ];
+    int ErrorStatus;
+    int len, i;
+
+    /* open file to write */
+    if ((ErrorStatus = xpmWriteFile(filename, &mdata)) != XpmSuccess)
+	return (ErrorStatus);
+
+    /* figure out a name */
+    if (filename) {
+#ifdef VMS
+	name = filename;
+#else
+#ifdef FOR_MSW
+	if (!(name = strchr(filename, '\\')))
+#else
+	if (!(name = strchr(filename, '/')))
+#endif
+	    name = filename;
+	else
+	    name++;
+#endif
+	if (dot = strchr(name, '.')) {
+	    strcpy(new_name, name);
+#ifdef FOR_MSW
+            // Convert to lower case
+            len = strlen(new_name);
+            for (i = 0; i < len; i++)
+              new_name[i] = tolower(new_name[i]);
+#endif
+	    /* change '.' to '_' to get a valid C syntax name */
+	    name = s = new_name;
+	    while (dot = strchr(s, '.')) {
+		*dot = '_';
+		s = dot;
+	    }
+	}
+    } else
+	name = "image_name";
+
+    /* write the XpmData from the XpmImage */
+    if (ErrorStatus == XpmSuccess)
+	ErrorStatus = xpmWriteData(&mdata, image, name, info);
+
+    xpmDataClose(&mdata);
+
+    return (ErrorStatus);
+}
+
+int
+xpmWriteData(xpmData *mdata, XpmImage *image, char *name, XpmInfo *info)
+{
+    /* calculation variables */
+    unsigned int cmts, extensions;
+    FILE *file;
+    int ErrorStatus;
+
+    /* store this to speed up */
+    file = mdata->stream.file;
+
+    cmts = info && (info->valuemask & XpmComments);
+    extensions = info && (info->valuemask & XpmExtensions)
+	&& info->nextensions;
+
+    /* print the header line */
+    fprintf(file, "/* XPM */\nstatic char * %s[] = {\n", name);
+
+    /* print the hints line */
+    if (cmts && info->hints_cmt)
+	fprintf(file, "/*%s*/\n", info->hints_cmt);
+
+    fprintf(file, "\"%d %d %d %d", image->width, image->height,
+	    image->ncolors, image->cpp);
+
+    if (info && (info->valuemask & XpmHotspot))
+	fprintf(file, " %d %d", info->x_hotspot, info->y_hotspot);
+
+    if (extensions)
+	fprintf(file, " XPMEXT");
+
+    fprintf(file, "\",\n");
+
+    /* print colors */
+    if (cmts && info->colors_cmt)
+	fprintf(file, "/*%s*/\n", info->colors_cmt);
+
+    WriteColors(file, image->colorTable, image->ncolors);
+
+    /* print pixels */
+    if (cmts && info->pixels_cmt)
+	fprintf(file, "/*%s*/\n", info->pixels_cmt);
+
+    ErrorStatus = WritePixels(file, image->width, image->height, image->cpp,
+			      image->data, image->colorTable);
+    if (ErrorStatus != XpmSuccess)
+	return (ErrorStatus);
+
+    /* print extensions */
+    if (extensions)
+	WriteExtensions(file, info->extensions, info->nextensions);
+
+    /* close the array */
+    fprintf(file, "};\n");
+
+    return (XpmSuccess);
+}
+
+static void
+WriteColors(FILE *file, XpmColor *colors, unsigned int ncolors)
+{
+    unsigned int a, key;
+    char *s;
+    char **defaults;
+
+    for (a = 0; a < ncolors; a++, colors++) {
+
+	defaults = (char **) colors;
+	fprintf(file, "\"%s", *defaults++);
+
+	for (key = 1; key <= NKEYS; key++, defaults++) {
+	    if (s = *defaults)
+		fprintf(file, "\t%s %s", xpmColorKeys[key - 1], s);
+	}
+	fprintf(file, "\",\n");
+    }
+}
+
+
+static int
+WritePixels(FILE *file, unsigned int width, unsigned int height, unsigned int cpp, unsigned int *pixels, XpmColor *colors)
+{
+    char *s, *p, *buf;
+    unsigned int x, y, h;
+
+    h = height - 1;
+    p = buf = (char *) XpmMallocA(width * cpp + 3);
+    if (!buf)
+	return (XpmNoMemory);
+    *buf = '"';
+    p++;
+    for (y = 0; y < h; y++) {
+	s = p;
+	for (x = 0; x < width; x++, pixels++) {
+	    strncpy(s, colors[*pixels].string, cpp);
+	    s += cpp;
+	}
+	*s++ = '"';
+	*s = '\0';
+	fprintf(file, "%s,\n", buf);
+    }
+    /* duplicate some code to avoid a test in the loop */
+    s = p;
+    for (x = 0; x < width; x++, pixels++) {
+	strncpy(s, colors[*pixels].string, cpp);
+	s += cpp;
+    }
+    *s++ = '"';
+    *s = '\0';
+    fprintf(file, "%s", buf);
+
+    XpmFree(buf);
+    return (XpmSuccess);
+}
+
+static void
+WriteExtensions(FILE *file, XpmExtension *ext, unsigned int num)
+{
+    unsigned int x, y, n;
+    char **line;
+
+    for (x = 0; x < num; x++, ext++) {
+	fprintf(file, ",\n\"XPMEXT %s\"", ext->name);
+	n = ext->nlines;
+	for (y = 0, line = ext->lines; y < n; y++, line++)
+	    fprintf(file, ",\n\"%s\"", *line);
+    }
+    fprintf(file, ",\n\"XPMENDEXT\"");
+}
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrp.c b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrp.c
new file mode 100644
index 0000000..d3479ed
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/wrffrp.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+
+
+/*****************************************************************************\
+* XpmWrFFrP.c:                                                                *
+*                                                                             *
+*  XPM library                                                                *
+*  Write a pixmap and possibly its mask to an XPM file                        *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+#include "xpm34p.h"
+#ifdef VMS
+#include "sys$library:string.h"
+#else
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+int
+XpmWriteFileFromPixmap(Display *display, char *filename, Pixmap pixmap, Pixmap shapemask, XpmAttributes *attributes)
+{
+    XImage *ximage = NULL;
+    XImage *shapeimage = NULL;
+    unsigned int width = 0;
+    unsigned int height = 0;
+    int ErrorStatus;
+
+    /* get geometry */
+    if (attributes && attributes->valuemask & XpmSize) {
+	width = attributes->width;
+	height = attributes->height;
+    }
+    /* get the ximages */
+    if (pixmap)
+	xpmCreateImageFromPixmap(display, pixmap, &ximage, &width, &height);
+    if (shapemask)
+	xpmCreateImageFromPixmap(display, shapemask, &shapeimage,
+				 &width, &height);
+
+    /* write to the file */
+    ErrorStatus = XpmWriteFileFromImage(display, filename, ximage, shapeimage,
+					attributes);
+
+    /* destroy the ximages */
+    if (ximage)
+	XDestroyImage(ximage);
+    if (shapeimage)
+	XDestroyImage(shapeimage);
+
+    return (ErrorStatus);
+}
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34.h b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34.h
new file mode 100644
index 0000000..c97d14f
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34.h
@@ -0,0 +1,560 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* xpm.h:                                                                      *
+*                                                                             *
+*  XPM library                                                                *
+*  Include file                                                               *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+#ifndef XPM_h
+#define XPM_h
+
+/*
+ * first some identification numbers:
+ * the following revision numbers is determined with the following rule:
+ * SO Major number = LIB minor version number.
+ * SO Minor number = LIB sub-minor version number.
+ * e.g: Xpm version 3.2f
+ *      we forget the 3 which is the format number, 2 gives 2, and f gives 6.
+ *      thus we have XpmVersion = 2 and XpmRevision = 6
+ *      which gives  SOXPMLIBREV = 2.6
+ *
+ * Then the XpmIncludeVersion number is built with the following rule:
+ * (XpmFormat*100 + XpmVersion)*100 + XpmRevision
+ */
+#define XpmFormat 3
+#define XpmVersion 4
+#define XpmRevision 2
+
+#define XpmIncludeVersion 30402
+
+#ifndef XPM_NUMBERS
+
+#ifdef VMS
+#include "decw$include:Xlib.h"
+#include "decw$include:Xutil.h"
+#else /* VMS */
+#ifdef FOR_MSW
+#define SYSV			/* uses memcpy string.h etc. */
+#include <malloc.h>
+#include "simx.h"		/* defines some X stuff using MSW types */
+#define NEED_STRCASECMP		/* at least for MSVC++ */
+#elif defined(FOR_MAC)
+#include <string.h>
+#include <stdlib.h>
+#include "simx.h"		/* defines some X stuff using mac types */
+#else /* FOR_MSW */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdlib.h>	/* HEDU */
+#endif /* FOR_MSW */
+#endif /* VMS */
+
+/* let's define Pixel if it is not done yet */
+#if ! defined(_XtIntrinsic_h) && ! defined(PIXEL_ALREADY_TYPEDEFED)
+typedef unsigned long Pixel;	/* Index into colormap */
+#define PIXEL_ALREADY_TYPEDEFED
+#endif
+
+/* Return ErrorStatus codes:
+ * null     if full success
+ * positive if partial success
+ * negative if failure
+ */
+
+#define XpmColorError    1
+#define XpmSuccess       0
+#define XpmOpenFailed   -1
+#define XpmFileInvalid  -2
+#define XpmNoMemory     -3
+#define XpmColorFailed  -4
+
+/* the following should help people wanting to use their own functions */
+// mflatt: hacked for GC
+void XpmFree(void *ptr);
+
+typedef struct {
+    char *name;			/* Symbolic color name */
+    char *value;		/* Color value */
+    Pixel pixel;		/* Color pixel */
+}      XpmColorSymbol;
+
+typedef struct {
+    char *name;			/* name of the extension */
+    unsigned int nlines;	/* number of lines in this extension */
+    char **lines;		/* pointer to the extension array of strings */
+}      XpmExtension;
+
+typedef struct {
+    char *string;		/* characters string */
+    char *symbolic;		/* symbolic name */
+    char *m_color;		/* monochrom default */
+    char *g4_color;		/* 4 level grayscale default */
+    char *g_color;		/* other level grayscale default */
+    char *c_color;		/* color default */
+}      XpmColor;
+
+typedef struct {
+    unsigned int width;		/* image width */
+    unsigned int height;	/* image height */
+    unsigned int cpp;		/* number of characters per pixel */
+    unsigned int ncolors;	/* number of colors */
+    XpmColor *colorTable;	/* list of related colors */
+    unsigned int *data;		/* image data */
+}      XpmImage;
+
+typedef struct {
+    unsigned long valuemask;	/* Specifies which attributes are defined */
+    char *hints_cmt;		/* Comment of the hints section */
+    char *colors_cmt;		/* Comment of the colors section */
+    char *pixels_cmt;		/* Comment of the pixels section */
+    unsigned int x_hotspot;	/* Returns the x hotspot's coordinate */
+    unsigned int y_hotspot;	/* Returns the y hotspot's coordinate */
+    unsigned int nextensions;	/* number of extensions */
+    XpmExtension *extensions;	/* pointer to array of extensions */
+}      XpmInfo;
+
+typedef struct {
+    unsigned long valuemask;		/* Specifies which attributes are
+					 * defined */
+
+    Visual *visual;			/* Specifies the visual to use */
+    Colormap colormap;			/* Specifies the colormap to use */
+    unsigned int depth;			/* Specifies the depth */
+    unsigned int width;			/* Returns the width of the created
+					 * pixmap */
+    unsigned int height;		/* Returns the height of the created
+					 * pixmap */
+    unsigned int x_hotspot;		/* Returns the x hotspot's
+					 * coordinate */
+    unsigned int y_hotspot;		/* Returns the y hotspot's
+					 * coordinate */
+    unsigned int cpp;			/* Specifies the number of char per
+					 * pixel */
+    Pixel *pixels;			/* List of used color pixels */
+    unsigned int npixels;		/* Number of pixels */
+    XpmColorSymbol *colorsymbols;	/* Array of color symbols to
+					 * override */
+    unsigned int numsymbols;		/* Number of symbols */
+    char *rgb_fname;			/* RGB text file name */
+    unsigned int nextensions;		/* number of extensions */
+    XpmExtension *extensions;		/* pointer to array of extensions */
+
+    unsigned int ncolors;               /* Number of colors */
+    XpmColor *colorTable;               /* Color table pointer */
+/* 3.2 backward compatibility code */
+    char *hints_cmt;                    /* Comment of the hints section */
+    char *colors_cmt;                   /* Comment of the colors section */
+    char *pixels_cmt;                   /* Comment of the pixels section */
+/* end 3.2 bc */
+    unsigned int mask_pixel;            /* Transparent pixel's color table
+                                         * index */
+
+    /* Color Allocation Directives */
+    unsigned int exactColors;		/* Only use exact colors for visual */
+    unsigned int closeness;		/* Allowable RGB deviation */
+    unsigned int red_closeness;		/* Allowable red deviation */
+    unsigned int green_closeness;	/* Allowable green deviation */
+    unsigned int blue_closeness;	/* Allowable blue deviation */
+    int color_key;			/* Use colors from this color set */
+
+}      XpmAttributes;
+
+/* XpmAttributes value masks bits */
+#define XpmVisual	   (1L<<0)
+#define XpmColormap	   (1L<<1)
+#define XpmDepth	   (1L<<2)
+#define XpmSize		   (1L<<3)	/* width & height */
+#define XpmHotspot	   (1L<<4)	/* x_hotspot & y_hotspot */
+#define XpmCharsPerPixel   (1L<<5)
+#define XpmColorSymbols	   (1L<<6)
+#define XpmRgbFilename	   (1L<<7)
+/* 3.2 backward compatibility code */
+#define XpmInfos	   (1L<<8)
+#define XpmReturnInfos	   XpmInfos
+/* end 3.2 bc */
+#define XpmReturnPixels	   (1L<<9)
+#define XpmExtensions      (1L<<10)
+#define XpmReturnExtensions XpmExtensions
+
+#define XpmExactColors     (1L<<11)
+#define XpmCloseness	   (1L<<12)
+#define XpmRGBCloseness	   (1L<<13)
+#define XpmColorKey	   (1L<<14)
+
+#define XpmColorTable      (1L<<15)
+#define XpmReturnColorTable XpmColorTable
+
+/* XpmInfo value masks bits */
+#define XpmComments        XpmInfos
+#define XpmReturnComments  XpmComments
+
+/* XpmAttributes mask_pixel value when there is no mask */
+#ifndef FOR_MSW
+#define XpmUndefPixel 0x80000000
+#else
+/* int is only 16 bit for MSW */
+#define XpmUndefPixel 0x8000
+#endif
+
+/*
+ * color keys for visual type, they must fit along with the number key of
+ * each related element in xpmColorKeys[] defined in xpmP.h
+ */
+#define XPM_MONO	2
+#define XPM_GREY4	3
+#define XPM_GRAY4	3
+#define XPM_GREY 	4
+#define XPM_GRAY 	4
+#define XPM_COLOR	5
+
+
+/*
+ * minimal portability layer between ansi and KR C
+ */
+
+/* forward declaration of functions with prototypes */
+
+#if __STDC__ || defined(__cplusplus) || defined(c_plusplus)
+ /* ANSI || C++ */
+#define FUNC(f, t, p) extern t f p
+#define LFUNC(f, t, p) static t f p
+/* #define LFUNC(f, t, p) t f p */
+#else  /* K&R */
+#define FUNC(f, t, p) extern t f()
+#define LFUNC(f, t, p) static t f()
+/* #define LFUNC(f, t, p) t f() */
+#endif /* end of K&R */
+
+
+/*
+ * functions declarations
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* For Microsoft C++ at any rate, the FUNC macro just doesn't work: it causes
+ * arguments to be corrupted espec. in XpmWriteFileFromXpmImage.
+ * So, define all prototypes explicitly.
+ */
+#if defined(_MSC_VER) || defined(FOR_MAC)
+
+/* FOR_MSW, all ..Pixmap.. are excluded, only the ..XImage.. are used */
+
+    int XpmCreateImageFromData(Display *display,
+				       char **data,
+				       XImage **image_return,
+				       XImage **shapemask_return,
+				       XpmAttributes *attributes);
+
+    int XpmCreateDataFromImage(Display *display,
+				       char ***data_return,
+				       XImage *image,
+				       XImage *shapeimage,
+				       XpmAttributes *attributes);
+
+    int XpmReadFileToImage(Display *display,
+				   char *filename,
+				   XImage **image_return,
+				   XImage **shapeimage_return,
+				   XpmAttributes *attributes);
+
+    int XpmWriteFileFromImage(Display *display,
+				      char *filename,
+				      XImage *image,
+				      XImage *shapeimage,
+				      XpmAttributes *attributes);
+
+    int XpmCreateImageFromBuffer(Display *display,
+					 char *buffer,
+					 XImage **image_return,
+					 XImage **shapemask_return,
+					 XpmAttributes *attributes);
+
+    int XpmReadFileToBuffer(char *filename, char **buffer_return);
+    int XpmWriteFileFromBuffer(char *filename, char *buffer);
+
+    int XpmReadFileToData(char *filename, char ***data_return);
+    int XpmWriteFileFromData(char *filename, char **data);
+
+    int XpmAttributesSize();
+    void XpmFreeAttributes(XpmAttributes *attributes);
+    void XpmFreeExtensions(XpmExtension *extensions,
+				   int nextensions);
+
+    void XpmFreeXpmImage(XpmImage *image);
+    void XpmFreeXpmInfo(XpmInfo *info);
+    char *XpmGetErrorString(int errcode);
+    int XpmLibraryVersion();
+
+    /* XpmImage functions */
+    int XpmReadFileToXpmImage(char *filename,
+				      XpmImage *image,
+				      XpmInfo *info);
+
+    int XpmWriteFileFromXpmImage(char *filename,
+					 XpmImage *image,
+					 XpmInfo *info);
+
+    int XpmWriteFileFromXpmImage(char *filename, XpmImage *image, XpmInfo *info);
+
+    int XpmCreateImageFromXpmImage(Display *display,
+					   XpmImage *image,
+					   XImage **image_return,
+					   XImage **shapeimage_return,
+					   XpmAttributes *attributes);
+
+    int XpmCreateXpmImageFromImage(Display *display,
+					   XImage *image,
+					   XImage *shapeimage,
+					   XpmImage *xpmimage,
+					   XpmAttributes *attributes);
+    int XpmCreateDataFromXpmImage(char ***data_return,
+					  XpmImage *image,
+					  XpmInfo *info);
+
+    int XpmCreateXpmImageFromData(char **data,
+					  XpmImage *image,
+					  XpmInfo *info);
+
+    int XpmCreateXpmImageFromBuffer(char *buffer,
+					    XpmImage *image,
+					    XpmInfo *info);
+
+    int XpmCreateBufferFromXpmImage(char **buffer_return,
+					    XpmImage *image,
+					    XpmInfo *info);
+
+	int XpmCreateBufferFromImage(Display *display, char **buffer_return, 
+						XImage *image,
+  						XImage *shapeimage, 
+  						XpmAttributes *attributes);
+#else // _MSC_VER
+
+/* FOR_MSW, all ..Pixmap.. are excluded, only the ..XImage.. are used */
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    FUNC(XpmCreatePixmapFromData, int, (Display *display,
+					Drawable d,
+					char **data,
+					Pixmap *pixmap_return,
+					Pixmap *shapemask_return,
+					XpmAttributes *attributes));
+
+    FUNC(XpmCreateDataFromPixmap, int, (Display *display,
+					char ***data_return,
+					Pixmap pixmap,
+					Pixmap shapemask,
+					XpmAttributes *attributes));
+
+    FUNC(XpmReadFileToPixmap, int, (Display *display,
+				    Drawable d,
+				    char *filename,
+				    Pixmap *pixmap_return,
+				    Pixmap *shapemask_return,
+				    XpmAttributes *attributes));
+
+    FUNC(XpmWriteFileFromPixmap, int, (Display *display,
+				       char *filename,
+				       Pixmap pixmap,
+				       Pixmap shapemask,
+				       XpmAttributes *attributes));
+#endif  /* ndef FOR_MSW */
+
+    FUNC(XpmCreateImageFromData, int, (Display *display,
+				       char **data,
+				       XImage **image_return,
+				       XImage **shapemask_return,
+				       XpmAttributes *attributes));
+
+    FUNC(XpmCreateDataFromImage, int, (Display *display,
+				       char ***data_return,
+				       XImage *image,
+				       XImage *shapeimage,
+				       XpmAttributes *attributes));
+
+    FUNC(XpmReadFileToImage, int, (Display *display,
+				   char *filename,
+				   XImage **image_return,
+				   XImage **shapeimage_return,
+				   XpmAttributes *attributes));
+
+    FUNC(XpmWriteFileFromImage, int, (Display *display,
+				      char *filename,
+				      XImage *image,
+				      XImage *shapeimage,
+				      XpmAttributes *attributes));
+
+    FUNC(XpmCreateImageFromBuffer, int, (Display *display,
+					 char *buffer,
+					 XImage **image_return,
+					 XImage **shapemask_return,
+					 XpmAttributes *attributes));
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    FUNC(XpmCreatePixmapFromBuffer, int, (Display *display,
+					  Drawable d,
+					  char *buffer,
+					  Pixmap *pixmap_return,
+					  Pixmap *shapemask_return,
+					  XpmAttributes *attributes));
+
+#endif  /* ndef FOR_MSW */
+    FUNC(XpmCreateBufferFromImage, int, (Display *display,
+					 char **buffer_return,
+					 XImage *image,
+					 XImage *shapeimage,
+					 XpmAttributes *attributes));
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    FUNC(XpmCreateBufferFromPixmap, int, (Display *display,
+					  char **buffer_return,
+					  Pixmap pixmap,
+					  Pixmap shapemask,
+					  XpmAttributes *attributes));
+#endif  /* ndef FOR_MSW */
+    FUNC(XpmReadFileToBuffer, int, (char *filename, char **buffer_return));
+    FUNC(XpmWriteFileFromBuffer, int, (char *filename, char *buffer));
+
+    FUNC(XpmReadFileToData, int, (char *filename, char ***data_return));
+    FUNC(XpmWriteFileFromData, int, (char *filename, char **data));
+
+    FUNC(XpmAttributesSize, int, ());
+    FUNC(XpmFreeAttributes, void, (XpmAttributes *attributes));
+    FUNC(XpmFreeExtensions, void, (XpmExtension *extensions,
+				   int nextensions));
+
+    FUNC(XpmFreeXpmImage, void, (XpmImage *image));
+    FUNC(XpmFreeXpmInfo, void, (XpmInfo *info));
+    FUNC(XpmGetErrorString, char *, (int errcode));
+    FUNC(XpmLibraryVersion, int, ());
+
+    /* XpmImage functions */
+    FUNC(XpmReadFileToXpmImage, int, (char *filename,
+				      XpmImage *image,
+				      XpmInfo *info));
+
+    FUNC(XpmWriteFileFromXpmImage, int, (char *filename,
+					 XpmImage *image,
+					 XpmInfo *info));
+
+    FUNC(XpmWriteFileFromXpmImage, int, (char *filename, XpmImage *image, XpmInfo *info));
+/*    extern int XpmWriteFileFromXpmImage(char *filename, XpmImage *image, XpmInfo *info); */
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    FUNC(XpmCreatePixmapFromXpmImage, int, (Display *display,
+					    Drawable d,
+					    XpmImage *image,
+					    Pixmap *pixmap_return,
+					    Pixmap *shapemask_return,
+					    XpmAttributes *attributes));
+#endif
+    FUNC(XpmCreateImageFromXpmImage, int, (Display *display,
+					   XpmImage *image,
+					   XImage **image_return,
+					   XImage **shapeimage_return,
+					   XpmAttributes *attributes));
+
+    FUNC(XpmCreateXpmImageFromImage, int, (Display *display,
+					   XImage *image,
+					   XImage *shapeimage,
+					   XpmImage *xpmimage,
+					   XpmAttributes *attributes));
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+    FUNC(XpmCreateXpmImageFromPixmap, int, (Display *display,
+					    Pixmap pixmap,
+					    Pixmap shapemask,
+					    XpmImage *xpmimage,
+					    XpmAttributes *attributes));
+#endif
+    FUNC(XpmCreateDataFromXpmImage, int, (char ***data_return,
+					  XpmImage *image,
+					  XpmInfo *info));
+
+    FUNC(XpmCreateXpmImageFromData, int, (char **data,
+					  XpmImage *image,
+					  XpmInfo *info));
+
+    FUNC(XpmCreateXpmImageFromBuffer, int, (char *buffer,
+					    XpmImage *image,
+					    XpmInfo *info));
+
+    FUNC(XpmCreateBufferFromXpmImage, int, (char **buffer_return,
+					    XpmImage *image,
+					    XpmInfo *info));
+
+#endif // _MSC_VER
+					    
+#ifdef __cplusplus
+} /* for C++ V2.0 */
+#endif
+
+
+/* backward compatibility */
+
+/* for version 3.0c */
+#define XpmPixmapColorError  XpmColorError
+#define XpmPixmapSuccess     XpmSuccess
+#define XpmPixmapOpenFailed  XpmOpenFailed
+#define XpmPixmapFileInvalid XpmFileInvalid
+#define XpmPixmapNoMemory    XpmNoMemory
+#define XpmPixmapColorFailed XpmColorFailed
+
+#define XpmReadPixmapFile(dpy, d, file, pix, mask, att) \
+    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
+#define XpmWritePixmapFile(dpy, file, pix, mask, att) \
+    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
+
+/* for version 3.0b */
+#define PixmapColorError  XpmColorError
+#define PixmapSuccess     XpmSuccess
+#define PixmapOpenFailed  XpmOpenFailed
+#define PixmapFileInvalid XpmFileInvalid
+#define PixmapNoMemory    XpmNoMemory
+#define PixmapColorFailed XpmColorFailed
+
+#define ColorSymbol XpmColorSymbol
+
+#define XReadPixmapFile(dpy, d, file, pix, mask, att) \
+    XpmReadFileToPixmap(dpy, d, file, pix, mask, att)
+#define XWritePixmapFile(dpy, file, pix, mask, att) \
+    XpmWriteFileFromPixmap(dpy, file, pix, mask, att)
+#define XCreatePixmapFromData(dpy, d, data, pix, mask, att) \
+    XpmCreatePixmapFromData(dpy, d, data, pix, mask, att)
+#define XCreateDataFromPixmap(dpy, data, pix, mask, att) \
+    XpmCreateDataFromPixmap(dpy, data, pix, mask, att)
+
+#endif /* XPM_NUMBERS */
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34p.h b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34p.h
new file mode 100644
index 0000000..5d5126c
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/lib/xpm34p.h
@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+/*****************************************************************************\
+* xpmP.h:                                                                     *
+*                                                                             *
+*  XPM library                                                                *
+*  Private Include file                                                       *
+*                                                                             *
+*  Developed by Arnaud Le Hors                                                *
+\*****************************************************************************/
+
+/*
+ * The code related to FOR_MSW has been added by
+ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
+ */
+
+#ifndef XPMP_h
+#define XPMP_h
+
+#include "xpm34.h"
+
+/*
+ * lets try to solve include files
+ */
+#ifdef VMS
+
+#include "sys$library:stdio.h"
+#include "sys$library:string.h"
+
+#else  /* VMS */
+
+#include <stdio.h>
+/* stdio.h doesn't declare popen on a Sequent DYNIX OS */
+#ifdef sequent
+extern FILE *popen();
+#endif
+
+#if defined(SYSV) || defined(SVR4)
+#include <string.h>
+
+#ifndef index
+#define index strchr
+#endif
+
+#ifndef rindex
+#define rindex strrchr
+#endif
+
+#else  /* defined(SYSV) || defined(SVR4) */
+#include <strings.h>
+#endif
+
+#endif /* VMS */
+
+
+#if defined(SYSV) || defined(SVR4) || defined(VMS) || (defined(FOR_MAC) && !defined(GUSI))
+#define bcopy(source, dest, count) memcpy(dest, source, count)
+#define bzero(b, len) memset(b, 0, len)
+#endif
+
+
+/* the following should help people wanting to use their own functions */
+#ifndef FOR_MSW
+// mflatt: hacked to use GC allocators
+extern void *XpmMalloc(size_t size);
+extern void *XpmMallocA(size_t size);
+extern void *XpmRealloc(void *ptr, size_t size);
+extern void *XpmReallocA(void *ptr, size_t size);
+#define XpmCalloc(nelem, elsize) XpmMalloc((nelem) * (elsize))
+#define XpmCallocA(nelem, elsize) XpmMallocA((nelem) * (elsize))
+#else
+/* checks for mallocs bigger than 64K */
+#define XpmMalloc(size) boundCheckingMalloc((long)(size))/* in simx.[ch] */
+#define XpmRealloc(ptr, size) boundCheckingRealloc((ptr),(long)(size))
+#define XpmCalloc(nelem, elsize) \
+		boundCheckingCalloc((long)(nelem),(long) (elsize))
+#endif
+
+
+typedef struct {
+    unsigned int type;
+    union {
+	FILE *file;
+	char **data;
+    }     stream;
+    char *cptr;
+    unsigned int line;
+    int CommentLength;
+    char Comment[BUFSIZ];
+    char *Bcmt, *Ecmt, Bos, Eos;
+    int format;			/* 1 if XPM1, 0 otherwise */
+}      xpmData;
+
+#define XPMARRAY 0
+#define XPMFILE  1
+#define XPMPIPE  2
+#define XPMBUFFER 3
+
+#define EOL '\n'
+#define TAB '\t'
+#define SPC ' '
+
+typedef struct {
+    char *type;			/* key word */
+    char *Bcmt;			/* string beginning comments */
+    char *Ecmt;			/* string ending comments */
+    char Bos;			/* character beginning strings */
+    char Eos;			/* character ending strings */
+    char *Strs;			/* strings separator */
+    char *Dec;			/* data declaration string */
+    char *Boa;			/* string beginning assignment */
+    char *Eoa;			/* string ending assignment */
+}      xpmDataType;
+
+extern xpmDataType xpmDataTypes[];
+
+/*
+ * rgb values and ascii names (from rgb text file) rgb values,
+ * range of 0 -> 65535 color mnemonic of rgb value
+ */
+typedef struct {
+    int r, g, b;
+    char *name;
+}      xpmRgbName;
+
+/* Maximum number of rgb mnemonics allowed in rgb text file. */
+#define MAX_RGBNAMES 1024
+
+extern char *xpmColorKeys[];
+
+#define TRANSPARENT_COLOR "None"	/* this must be a string! */
+
+/* number of xpmColorKeys */
+#define NKEYS 5
+
+/* XPM private routines */
+
+FUNC(xpmWriteData, int, (xpmData *mdata, XpmImage *image, char *name,
+			 XpmInfo *info));
+
+FUNC(xpmParseData, int, (xpmData *data, XpmImage *image, XpmInfo *info));
+
+FUNC(xpmFreeColorTable, void, (XpmColor *colorTable, int ncolors));
+
+FUNC(xpmInitAttributes, void, (XpmAttributes *attributes));
+
+FUNC(xpmInitXpmImage, void, (XpmImage *image));
+
+FUNC(xpmInitXpmInfo, void, (XpmInfo *info));
+
+FUNC(xpmSetInfoMask, void, (XpmInfo *info, XpmAttributes *attributes));
+FUNC(xpmSetInfo, void, (XpmInfo *info, XpmAttributes *attributes));
+FUNC(xpmSetAttributes, void, (XpmAttributes *attributes, XpmImage *image,
+			      XpmInfo *info));
+
+#if !defined(FOR_MSW) && !defined(FOR_MAC)
+FUNC(xpmCreatePixmapFromImage, void, (Display *display, Drawable d,
+				      XImage *ximage, Pixmap *pixmap_return));
+
+FUNC(xpmCreateImageFromPixmap, void, (Display *display, Pixmap pixmap,
+				      XImage **ximage_return,
+				      unsigned int *width,
+				      unsigned int *height));
+#endif
+
+/* I/O utility */
+
+FUNC(xpmNextString, int, (xpmData *mdata));
+FUNC(xpmNextUI, int, (xpmData *mdata, unsigned int *ui_return));
+FUNC(xpmGetString, int, (xpmData *mdata, char **sptr, unsigned int *l));
+
+#define xpmGetC(mdata) \
+	((!mdata->type || mdata->type == XPMBUFFER) ? \
+	 (*mdata->cptr++) : (getc(mdata->stream.file)))
+
+FUNC(xpmNextWord, unsigned int,
+     (xpmData *mdata, char *buf, unsigned int buflen));
+FUNC(xpmGetCmt, int, (xpmData *mdata, char **cmt));
+FUNC(xpmReadFile, int, (char *filename, xpmData *mdata));
+FUNC(xpmWriteFile, int, (char *filename, xpmData *mdata));
+FUNC(xpmOpenArray, void, (char **data, xpmData *mdata));
+FUNC(xpmDataClose, int, (xpmData *mdata));
+FUNC(xpmParseHeader, int, (xpmData *mdata));
+FUNC(xpmOpenBuffer, void, (char *buffer, xpmData *mdata));
+
+/* RGB utility */
+
+FUNC(xpmReadRgbNames, int, (char *rgb_fname, xpmRgbName *rgbn));
+FUNC(xpmGetRgbName, char *, (xpmRgbName *rgbn, int rgbn_max,
+			     int red, int green, int blue));
+FUNC(xpmFreeRgbNames, void, (xpmRgbName *rgbn, int rgbn_max));
+#ifdef FOR_MSW
+FUNC(xpmGetRGBfromName,int, (char *name, int *r, int *g, int *b));
+#endif
+
+FUNC(xpm_xynormalizeimagebits, void, (register unsigned char *bp,
+				      register XImage *img));
+FUNC(xpm_znormalizeimagebits, void, (register unsigned char *bp,
+				     register XImage *img));
+
+/*
+ * Macros
+ *
+ * The XYNORMALIZE macro determines whether XY format data requires
+ * normalization and calls a routine to do so if needed. The logic in
+ * this module is designed for LSBFirst byte and bit order, so
+ * normalization is done as required to present the data in this order.
+ *
+ * The ZNORMALIZE macro performs byte and nibble order normalization if
+ * required for Z format data.
+ *
+ * The XYINDEX macro computes the index to the starting byte (char) boundary
+ * for a bitmap_unit containing a pixel with coordinates x and y for image
+ * data in XY format.
+ *
+ * The ZINDEX* macros compute the index to the starting byte (char) boundary
+ * for a pixel with coordinates x and y for image data in ZPixmap format.
+ *
+ */
+
+#define XYNORMALIZE(bp, img) \
+    if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \
+	xpm_xynormalizeimagebits((unsigned char *)(bp), img)
+
+#define ZNORMALIZE(bp, img) \
+    if (img->byte_order == MSBFirst) \
+	xpm_znormalizeimagebits((unsigned char *)(bp), img)
+
+#define XYINDEX(x, y, img) \
+    ((y) * img->bytes_per_line) + \
+    (((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)
+
+#define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \
+    (((x) * img->bits_per_pixel) >> 3)
+
+#define ZINDEX32(x, y, img) ((y) * img->bytes_per_line) + ((x) << 2)
+
+#define ZINDEX16(x, y, img) ((y) * img->bytes_per_line) + ((x) << 1)
+
+#define ZINDEX8(x, y, img) ((y) * img->bytes_per_line) + (x)
+
+#define ZINDEX1(x, y, img) ((y) * img->bytes_per_line) + ((x) >> 3)
+
+#if __STDC__
+#define Const const
+#else
+#define Const /**/
+#endif
+
+/*
+ * there are structures and functions related to hastable code
+ */
+
+typedef struct _xpmHashAtom {
+    char *name;
+    void *data;
+}      *xpmHashAtom;
+
+typedef struct {
+    int size;
+    int limit;
+    int used;
+    xpmHashAtom *atomTable;
+}      xpmHashTable;
+
+FUNC(xpmHashTableInit, int, (xpmHashTable *table));
+FUNC(xpmHashTableFree, void, (xpmHashTable *table));
+FUNC(xpmHashSlot, xpmHashAtom *, (xpmHashTable *table, char *s));
+FUNC(xpmHashIntern, int, (xpmHashTable *table, char *tag, void *data));
+
+#define HashAtomData(i) ((void *)i)
+#define HashColorIndex(slot) ((unsigned int)((*slot)->data))
+#define USE_HASHTABLE (cpp > 2 && ncolors > 4)
+
+#ifdef NEED_STRDUP
+FUNC(strdup, char *, (char *s1));
+#endif
+
+#ifdef NEED_STRCASECMP                   
+FUNC(strcasecmp, int, (char *s1, char *s2));
+#endif
+
+FUNC(atoui, unsigned int, (char *p, unsigned int l, unsigned int *ui_return));
+
+#endif
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/readme b/src/wxmac/contrib/wxxpm/libxpm.34b/readme
new file mode 100644
index 0000000..a82660f
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/readme
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 1989-94 GROUPE BULL
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of GROUPE BULL shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from GROUPE BULL.
+ */
+
+
+				XPM Version 3
+
+WHAT IS XPM?
+============
+
+XPM (X PixMap) is a format for storing/retrieving X pixmaps to/from files.
+
+Here is provided a library containing a set of four functions, similar to the
+X bitmap functions as defined in the Xlib: XpmCreatePixmapFromData,
+XpmCreateDataFromPixmap, XpmReadFileToPixmap and XpmWriteFileFromPixmap for
+respectively including, storing, reading and writing this format, plus four
+other: XpmCreateImageFromData, XpmCreateDataFromImage, XpmReadFileToImage and
+XpmWriteFileFromImage for working with images instead of pixmaps.
+
+This new version provides a C includable format, defaults for different types
+of display: monochrome/color/grayscale, hotspot coordinates and symbol names
+for colors for overriding default colors when creating the pixmap. It provides
+a mechanism for storing information while reading a file which is re-used
+while writing. This way comments, default colors and symbol names aren't lost.
+It also handles "transparent pixels" by returning a shape mask in addition to
+the created pixmap.
+
+See the XPM Manual for more details.
+
+HOW TO GET XPM?
+===============
+
+New xpm updates are announced on the comp.windows.x newsgroup, and on the
+"xpm-talk" list. All new "official" xpm releases can be found by ftp on:
+
+    ftp.x.org          (18.112.44.100) contrib	 (Boston, USA)
+    avahi.inria.fr     (192.5.60.47) pub	 (Sophia Antipolis, France)
+
+
+DOCUMENTATION:
+=============
+
+Old users might read the CHANGES file for a history of changes interesting
+the user.
+
+Read the doc. The documentation is in PostScript format (file doc/xpm.ps) and
+has been produced with FrameMaker. The source files are available on request.
+
+
+INSTALLATION:
+============
+
+To obtain the XPM library, first uncompress and untar the compressed tar file
+in an approriate directory.
+
+Then you can either compile xpm via "imake" or in a stand-alone way.
+
+WITH IMAKE:
+
+	Imakefiles are provided to build both shared and unshared libraries.
+	First have a look at the beginning of the lib/Imakefile and see if you
+	need to do some modification to fit with your system.
+	You should know how to use imake to build the XPM Makefiles
+	by executing "xmkmf", then do:
+
+		make Makefiles
+		make depend		(if you want to)
+		make
+
+	which will build the XPM library and the sxpm application. 
+	Then do:
+
+	     	make install
+		make install.man
+
+	which will install the library and the sxpm pregram and man page.
+
+	If it fails, you may edit the Imakefiles to add compilation flags to
+	suit your machine.
+
+WITHOUT IMAKE:
+
+	To compile xpm, in the xpm directory you just created, do:
+
+	        make -f Makefile.noXtree
+
+	Then to install it, do:
+
+		make -f Makefile.noXtree install
+
+SXPM:
+====
+
+In addition to the library the sxpm tool is provided to show XPM file and
+convert them from XPM1 or XPM2 to XPM version 3. If you have previously done
+'make' or 'make all' you should have it yet, otherwise just do:
+
+		      cd sxpm; make
+
+This application shows you most of the features of XPM and its source can be
+used to quickly see how to use the provided functions.
+
+By executing 'sxpm -help' you will get the usage.
+
+Executing 'sxpm -plaid' will show a demo of the XpmCreatePixmapFromData
+function. The pixmap is created from the static variable plaid defined in the
+sxpm.c file. sxpm will end when you press the key 'q' in the created window.
+
+Executing 'sxpm -plaid -sc lines_in_mix blue' will show the feature of
+overriding color symbols giving a colorname, executing 'sxpm -sp lines_in_mix
+1' will show overriding giving a pixel value, and executing 'sxpm -plaid -cp
+red 0' will show overriding giving a color value.
+
+Then you should try 'sxpm -plaid -o output' to get an output file using the
+XpmWriteFileFromPixmap function.
+
+You can now try 'sxpm -plaid -o - -nod -rgb /usr/lib/X11/rgb.txt' to directly
+get the pixmap printed out on the standard output with colornames instead of
+rgb values.
+
+Then you should try 'sxpm plaid.xpm' to use the XpmReadFileToPixmap function,
+and 'cat plaid_mask.xpm|sxpm' to see how "transparent pixels" are handled.
+
+The XpmCreatePixmapFromData function is on purpose called without any XpmInfos
+flag to show the utility of this one. Indeed, compare the color section of the
+two files foo and bar obtained from 'sxpm -nod -plaid -o foo' and 'sxpm -nod
+plaid.xpm -o bar'. All the default colors and also the comments have been
+restored.
+
+To end look at plaid_ext.xpm and try "sxpm -nod plaid_ext.xpm -v" to see how
+extensions are handled.
+
+Of course, other combinations are allowed and should be tried. Thus, 'sxpm
+plaid.xpm -o output -nod' will show you how to convert a file from XPM1 or XPM2
+to a XPM version 3 using sxpm.
+
+See the manual page for more detail.
+
+OTHER TOOLS:
+===========
+
+Several converters dealing with XPM and a pixmap editor can be found in the
+xpm-contrib distribution. Also I recommend the use of netpbm to do any kind of
+general image operations such as scaling, resizing, dithering, and to convert
+from and to any other image format.
+
+DISCUSSION:
+==========
+
+There is a mailing list to discuss about XPM which is xpm-talk@sophia.inria.fr.
+Any request to subscribe should be sent to xpm-talk-request@sophia.inria.fr.
+
+COPYRIGHT:
+==========
+
+  Copyright 1989-94 GROUPE BULL --
+  See license conditions in the COPYRIGHT file of the XPM distribution
+
+Please mail any bug reports or modifications done, comments, suggestions,
+requests for updates or patches to port on another machine to:
+
+lehors@sophia.inria.fr		(INTERNET)
+
+33 (FRANCE) 93.65.77.71		(VOICE PHONE)
+
+Arnaud Le Hors			(SURFACE MAIL)
+Bull c/o Inria BP. 109
+2004, Route des lucioles
+Sophia Antipolis
+06561 Valbonne Cedex
+FRANCE
diff --git a/src/wxmac/contrib/wxxpm/libxpm.34b/readme.msw b/src/wxmac/contrib/wxxpm/libxpm.34b/readme.msw
new file mode 100644
index 0000000..6e97bb5
--- /dev/null
+++ b/src/wxmac/contrib/wxxpm/libxpm.34b/readme.msw
@@ -0,0 +1,83 @@
+
+README.MSW	hedu@cul-ipn.uni-kiel.de	5/94
+
+		The XPM library for MS-Windows
+		
+Motivated by the wxWindows library, which is a (freely available) toolkit
+for developing multi-platform, graphical applications from the same body 
+of C++ code,I wanted to have XPM pixmaps for MS-windows. Instead of rewriting 
+a XPM-parser I managed to port the XPM-library-code to MS-windows.
+Thanks to Anaud Le Hors  this became a part of the official XPM-library.
+
+Until now it's only used together with wxWindows. And even there it's more 
+a kind of beta. But it should be possible to run it as a simple libxpm.a 
+without wxWindows.
+
+The key is a transformation of some X types plus some basic X functions.
+There is not yet a special MSW-API, so you should know the X types used.
+
+The following is done in simx.h:
+
+typedef HDC Display;
+typedef COLORREF Pixel;
+
+typedef struct {
+    Pixel pixel;
+    BYTE red, green, blue;
+}      XColor;
+
+typedef struct {
+    HBITMAP bitmap;
+    unsigned int width;
+    unsigned int height;
+    unsigned int depth;
+}      XImage;
+
+With these defines and the according functions from simx.c you can call
+XPM-functions the way it's done under X windows. It can look like this:
+
+	ErrorStatus=XpmCreateImageFromData(&dc, data, 
+				&ximage,(XImage **)NULL, &xpmAttr);
+	ms_bitmap = ximage->bitmap;
+	// releases the malloc,but do not destroy the bitmap
+	XImageFree(ximage);
+	
+Supported functions are the Xpm*Image* but not the Xpm*Pixmap*.
+
+DRAWBACKS:
+The main drawback is the missing support for Colormaps! There was nothing for
+it in wxWindows, so I did not know how to deal with Colormaps.
+
+The size of the pixmaps is bounded by malloc() (width*height*2 < 64K).
+
+Close colors do not look that close. But that seems to be the window system.
+
+Neither a special API for MSW nor a special MSW documentation other than this.
+(I can only point you to wxxpm as an example , see below.)
+
+INSTALLATION:
+There is not yet a makefile with it. Simply take all the *.c files
+into your project. 
+!!!You MUST set FOR_MSW on the preprocessor options!!!
+(You might uncomment NEED_STRCASECMP in xpm.h if it's in your lib)
+This should compile into libxpm.a. Good luck...
+
+FTP:  
+wxWindows is currently available from the Artificial Intelligence
+Applications Institute (University of Edinburgh) by anonymous FTP.
+	skye.aiai.ed.ac.uk  pub/wxwin/
+or read http://burray.aiai.ed.ac.uk/aiai/aiai.html
+
+wxxpm, XPM support for wxWindows, the latest version is available at
+	yoda.cul-ipn.uni-kiel.de pub/wxxpm/
+	and maybe in the contrib or tools of wxWindows
+	
+Please contact me if you have suggestions, comments or problems!
+
+--
+   ////|\\\\   \\\\\\  Hermann Dunkel
+     O   O     //////  IPN Uni Kiel, Germany
+       |       \\\\\\  Tel: +49 431 / 880 3144
+     \___/     //////  E-mail: hedu@cul-ipn.uni-kiel.de
+      \_/      \\\\\\  X.400 : c=de;a=d400;p=uni-kiel;ou=nw-didaktik;s=dunkel
+
diff --git a/src/wxmac/docs/Area, Margins, Windows Doc b/src/wxmac/docs/Area, Margins, Windows Doc
new file mode 100644
index 0000000..a781246
--- /dev/null
+++ b/src/wxmac/docs/Area, Margins, Windows Doc	
@@ -0,0 +1,74 @@
+
+wxBorderArea ISA wxArea
+	HAS:
+	wxBorder* cBorder; <-- NEW wxRectBorder(this, margin, direction, whitespace)
+						?? why isn't this member of class wxRectBorder ?? it is
+						as of a4p4
+
+wxArea ISA wxObject
+	HAS:
+	wxMargin	cMargin;
+	wxWindow*	cParentWindow; 
+	wxList		cWindows;
+
+wxMargin - is root
+	HAS:
+	int left;
+	int top;
+	int right;
+	int bottom;
+
+wxBorder ISA wxWindow
+
+wxRectBorder ISA wxBorder;
+	HAS:
+	int cWhitespace
+	
+wxScrollArea ISA wxArea
+	HAS:
+	wxScrollBar*	cVScrollBar; 
+	wxScrollBar*	cHScrollBar;
+	long			cStyle;
+	
+wxLabelArea ISA wxArea
+	HAS:
+	wxMessage*	cLabelText; 
+	Direction	cDirection;
+
+wxMessage ISA wxbMessage
+	HAS:
+	char* 	cMessage;
+	wxBitmap*	sBitmap;
+
+wxbMessage ISA wxItem
+
+wxItem ISA wxbItem
+
+wxbItem ISA wxWindow
+
+------
+wxWindow ISA wxbWindow
+	HAS:
+	static wxWindow* gMouseWindow; // mac platform only (window that has captured mouse)
+	Bool 		cColour; 		// use colour for this window?
+	Bool		cActive;		// active window is "highlighted" (mac platform only)
+	Bool		cEnable;		// enabled window accepts mouse/keyboard events
+	long		cStyle;			// mac platform only
+	Direction	cGravitate;		// mac platform only
+	Direction	cJustify;		// mac platform only
+	wxWindow* 	window_parent; 	// Each window always knows its parent
+	wxList* 	children; 		// Window's children
+	wxScroll* 	cScroll; 		// for scroll data and scroll synchronization
+	wxMacDC*	cMacDC;			// mac platform only
+	wxBrush* 	cBrush; 		// foreground brush
+	wxBrush* 	cEraser; 		// background brush
+	Pattern 	cMacPattern; 	// mac platform only (temp work pattern)
+	 // For window rectangle
+ 	int 		cWindowX;
+ 	int 		cWindowY;
+ 	int 		cWindowHeight;
+ 	int 		cWindowWidth;
+	// For window area
+  	wxArea* 	cParentArea; 	// mac platform only
+  	wxList 		cAreas; 		// mac platform only
+  	wxArea* 	cClientArea; 	// mac platform only
diff --git a/src/wxmac/docs/DebugNew.patch b/src/wxmac/docs/DebugNew.patch
new file mode 100644
index 0000000..cb2fcfd
--- /dev/null
+++ b/src/wxmac/docs/DebugNew.patch
@@ -0,0 +1,112 @@
+//
+// Heres some code to add to DebugNew.cp to for it to print out the first 16 bytes of each 
+// leak in hex and ascii.
+// The preprocessor symbol FOR_MAC is used - not the best but it was available.
+// I put this file in :src: along with the precompiled header files.
+// 
+// Cecil Coupe - ccoupe@simplot.com
+//
+#ifdef FOR_MAC
+void DebugNewP16(FILE* f, unsigned char *blk);
+
+void DebugNewP16(FILE* f, unsigned char *blk) 
+{
+	int i;
+	for (i = 0; i < 16; i++)
+		fprintf(f, "%02x ", blk[i]);
+	fprintf(f, " ");
+	for (i = 0; i < 16; i++) {
+		int c = blk[i];
+		if (c > 0x7f)
+			c = c & 0x7f;
+		if (c < ' ' || c == 0x7f)
+			c = ' ';
+		fprintf(f, "%c", c);
+	}
+	fprintf(f, "\n");
+}
+
+#endif
+
+void DebugNewReportLeaks()
+{
+	ProcessSerialNumber psn;
+	OSErr err = GetCurrentProcess(&psn);
+	if (err != noErr) return;
+	
+	ProcessInfoRec info;
+	FSSpec spec;
+	
+	info.processInfoLength = sizeof(info);
+	info.processName = 0;
+	info.processAppSpec = &spec;
+	err = GetProcessInformation(&psn, &info);
+	if (err != noErr) return;
+	
+	StringPtr s = "\pleaks.log";
+	BlockMoveData(s, spec.name, s[0]+1);
+	FILE* f = FSSpecOpen(spec, "w");	
+	if (!f) return;
+
+	long count = 0;
+	long leakCount = 0;
+	unsigned long bytesLeaked = 0;
+	BlockHeader* curr = gBlockList;
+	while (curr)
+	{
+		++count;
+		if (curr->tag == BLOCK_PREFIX_ALLOC)
+		{
+			bytesLeaked += curr->size;
+			++leakCount;
+		}
+		curr = curr->next;
+	}
+	
+	if(count != gDebugNewAllocCount)
+		fprintf(f, "Warning: length of block list different from count of allocated blocks (internal error).\n");
+		
+	fprintf(f, "Maximum #bytes allocated at any point via operator new: %ld\n", gDebugNewAllocMax);
+	
+	if (!leakCount)
+	{
+		fprintf(f, "No memory leaks.\n");
+		fclose(f);
+		return;
+	}
+	if (leakCount == 1)
+		fprintf(f,"There is 1 memory leak of %lu bytes:\n", bytesLeaked);
+	else
+		fprintf(f,"There are %ld memory leaks, totaling %lu bytes:\n", leakCount, bytesLeaked);
+	
+	unsigned long totalAlloc = 0;
+	
+	curr = gBlockList;
+	while (curr)
+	{
+		if (curr->tag == BLOCK_PREFIX_ALLOC)
+		{
+#ifdef FOR_MAC
+			if (curr->file)
+				fprintf(f,"  %12s line: %4d, size: %4lu ", curr->file, curr->line, curr->size);
+			else
+				fprintf(f,"  %12s line: %4d, size: %4lu ", "<unknown>",  0, curr->size);
+			// print first 16 bytes of the block plus newline
+			DebugNewP16(f,  (unsigned char *) curr+BLOCK_HEADER_SIZE);
+#else
+			if (curr->file)
+				fprintf(f,"  %s line: %d, size: %lu\n", curr->file, curr->line, curr->size);
+			else
+				fprintf(f,"  <unknown>, size: %lu\n", curr->size);
+#endif
+		}
+		totalAlloc += curr->size; // count freed blocks, since gDebugNewAllocCurr does
+		curr = curr->next;
+	}
+	if (totalAlloc != gDebugNewAllocCurr)
+		fprintf(f, "Warning: total allocations in block list different from gDebugNewAllocCurr.\n");
+
+	fclose(f);
+}
+#else
+	// leak checking disabled, does nothing
diff --git a/src/wxmac/docs/Debugging Memory Leaks b/src/wxmac/docs/Debugging Memory Leaks
new file mode 100644
index 0000000..a1a72c3
--- /dev/null
+++ b/src/wxmac/docs/Debugging Memory Leaks	
@@ -0,0 +1,60 @@
+How to Setup and Use DebugNew.cp's Leak Detection with wxMac:
+
+Requirements
+    Read all instructions first.
+	CW 7+
+	MPW Shell and the 'Canon' tool
+	MPW Script 'change_new' and file interface.dict - distributed with wxMac in the
+	top level directory.
+	
+1. It is a good idea to create a duplicate of the entire wxMac tree.
+
+2. Run the change_new script 4 times. For each run, modify
+   the script to affect :src:mac, :src:base:, :include:mac:, include:base:
+   (if you have nothing better to do you could modify the script to them all
+   at once). The script changes "new" to "NEW" for all 'TEXT' files
+   
+   NOTE: the script fails for me if a '-' (hyphen) is in any of the path names.
+
+3. Optionally, run change_new across the application to be tested,
+   i.e., Hello.cc or Minimal.cc or your own. Try Hello.cc first before your own -
+   it gives you a baseline of what to expect, and a few hints on what can be done.
+   
+4. Starting with the wxMac161 Debug project, ensure that the preferences, C/C++ Language,
+   precompiled headers field points to a prefix file wxDebugHeadersPPC (or wxDebugHeaders68K).
+
+5. Ensure that the project has a precompiled headers file - either wxDebugHeadersPPC.pch
+   (or wxDebugHeaders78k.pch). The xxx.pch distributed has the proper #defines and #includes
+   to build DebugNew.cp for leak detection. 
+   
+6. A modified DebugNew.cp is included in the :src: folder. Include this in your wxMac library
+   build project. This version of DebugNew dumps the first 16 bytes of the undeleted
+   block in Hex and Ascii. Its not critcal, you can use the regular DebugNew.cp found in
+   {Compiler Ä}...Libraries:DebugNew:, but its handy to have the ascii dump.
+   
+7. Build the library. All should go OK.
+
+8. In the App you want to debug - (Hello.cc for this example), make sure that the
+   preferences, C/C++, precompiled headers point to the same as the Library was build with
+   (wxDebugHeadersPPC or wxDebugHeaders68k). 
+   
+   Ensure that the 'debug' enabled library from step 7 is included in the hello project
+   in place of any other wxMac library.
+   
+9. Compile. If everything links OK, try running the app. Even better, run under the
+   Debugger.
+   
+10. Run the App (hello), and once its windows are up, immediately quit the app.
+    This should produce a 'leaks.log' file in the application's folder. You can
+    open this baseline. You should have no more than 12 leaks (for Hello) or 25 if
+    the DELIBERATE_LEAKS macro is effective in Hello.cc. If so,
+    save the file as leaks.log.base. You'll compare future debugging runs against
+    this file.
+    
+ 11. Run the App again. This time, manipulate the controls or otherwise as the app
+     to do something. Quit. This produces a new 'leaks.log' file. If it differs from
+     the leaks.log.base file, you can use the information to find the 'new' that doesn't
+     have a delete.
+   
+
+   
\ No newline at end of file
diff --git a/src/wxmac/docs/Leaks-Repair.txt b/src/wxmac/docs/Leaks-Repair.txt
new file mode 100644
index 0000000..8aae7d7
--- /dev/null
+++ b/src/wxmac/docs/Leaks-Repair.txt
@@ -0,0 +1,62 @@
+Leak Repair for a4p3+, Minimal Sample with a statusline and a panel with a message.
+
+1. in wx_app destructor
+   add the call to report leaks. 
+
+2. wb_main.cc in wxCommonCleanup(), add 
+
+#ifdef wx_mac
+  delete wxTheCursorList;
+  delete wxTheIconList;
+#endif
+  delete wxThePrintPaperDatabase;
+
+3. wx_frame.cc at the end of the destructor, add
+	if (cControlArea)
+		delete cControlArea;
+	if (cContentArea)
+		delete cContentArea;
+	if (cPlatformArea)
+		delete cPlatformArea;
+
+4. At the end of the destructor in wx_win.cc, add
+	delete cClientArea; - SEE ITEM 6 below - delete cClientArea is not required.
+
+5. Numerous places in wb_gdi:
+	Added a SuffixMap::Cleanup method that deletes the the 'map' array of strings.
+	Add a ~wxFontItemName destructor that calls Cleanup for its three suffix maps.
+	In ~wxFontNameDirectory, add a call to deletecontents() to trigger the above
+
+	SuffixMap::Initialize leaks all over because the return string from SearchResource()
+	is rarely deleted.
+	  
+	These are mostly cosmetic - ie reduces the leaks log from 600+ to 20. 
+	
+6. wxBorderArea leaks (wx_panel, wx_txt for minimal, plus most wxItems in hello):
+   The ~wxBorderArea is never called BUT it's contained wxBorder/wxRectBorder destructor is 
+   called!
+   
+   I think a compiler bug or C++ undefined behaviour is also contributing. The
+   wxWindow.cAreas member (wxList) sometimes does not destroy all wxNodes (the BorderArea)
+   when the destructor is done. It should be automatic.
+   Explicitly forcing the cAreas destruction in ~wxWindow() now causes the ~wxLabelArea 
+   bug to reappear:
+   
+   I think the order of the various Area creations is contributing (acutally it confuses
+   more than anything). What's happening is that the wxMessage contained in a wxLabelArea 
+   object is also a wxItem that gets destructed before the wxLabelArea. I introduced some
+   new wxTYPE_xxxx codes to wx_types.h for the various wxAreas and wxBorder
+   
+7. ~wxRadioBox leaks the buttons. Similar to the wxWindow.cArea problem.
+	Added a cRadioButtons.Clear to the destructor. Also modified wx_list.h, wb_list.cc
+	to not inline a function to make debugging easier.
+	
+8. Hello.cc has lots of changes to help debug leaks in it - including the ability to
+   introduce leaks so that the 'leaks.log' includes readable "brackets". Also I 
+   modified DebugNew to print out the first 16 bytes in hex and ascii for each leak.
+   Makes it easier to see where the leaks come from. This version of DebugNew should be
+   distributed.
+   
+9. After all of the above Hello leaks the same as minimal (12 leaks) and most of those
+   are related to the new font stuff in wb_gdi.cc
+   Still look into xxx::GetValue and xxx::GetLabel though!
\ No newline at end of file
diff --git a/src/wxmac/docs/README.GRW b/src/wxmac/docs/README.GRW
new file mode 100644
index 0000000..23f3287
--- /dev/null
+++ b/src/wxmac/docs/README.GRW
@@ -0,0 +1,63 @@
+Dec 21, 1995
+
+This is a dump of the changes I've made to wxmac161d-a4 (+ Cecil's DialogPanel).
+Some of the work is complete and some isn't... where more work is needed, I've
+tried to include useful notes below.  Each set of changes can be turned on/off with
+the following #define's in wx_setup.h (these should obviously be removed when/if
+they are integrated into the source base): 
+
+// A few random fixes that didn't warrant their own flag.
+#define GRW_FIXES 1
+
+// Support for more window styles, drawing the grow icon, and resizing.
+#define GRW_FIXES_FRAME 1
+
+// Support for the built-in cursors (arrow, ibeam, cross, watch) and adjusting the
+// cursor as the mouse moves.
+#define GRW_FIXES_CURSOR 1
+
+// Incomplete fixes related to getting frames and the elements they contain to
+// respond "in the Mac way" to activate/deactivate events.  There seemed to be some
+// confusion between activation and focus.   Also, in some cases elements were
+// switching to their disabled state when deactivated.  The Frame's grow icon and
+// scrollbars should become outlines, but everything else should stay the same.
+//  Making this work is tricky because of the way scrollbars are implemented: I
+// believe that only the scrollbars placed against the edge the frame (controlling
+//the main content region) should become outlines, but currently they all do.
+#define GRW_FIXES_ACTIVATION 1
+
+// Incomplete fixes related to keyboard focus in panels.  Support for enter/return
+// triggering the default action, and tab/shift-tab cycling through the items that
+// want focus.  Currently, only wxText and wxMultiText accept focus.  wxListBox
+// should be made to (and it should draw a border around itself when it acquires
+// focus).   It would also be nice to introduce the notion of a cancel action (like the
+// default action), so that escape could be mapped to cancel in dialogs.  One open
+// issue is how to handle focus among nested panels (see wxGetTextFromUser).
+// Also, while making these changes, I noticed that wxText doesn't really implement
+// a single line input like it is supposed to (this was a problem when I wanted to
+// steal enter/return from it).  To avoid duplicating code between wxText and
+// wxMultiText/wxTextWindow, I just introduced a flag to wxText that turns on
+// the multiple line behaviour (wxMULTIPLE).   The single line behaviour, on by
+// default, still isn't complete though: word wrap hasn't been disabled.
+#define GRW_FIXES_FOCUS 1
+
+// Incomplete fixes to position scrollbars correctly within a frame.  Scrollbars that
+// are against the edges of a frame should actually overlap the frame by one pixel.
+// Incidentally, these are the same scrollbars that should become outlines when the
+// frame becomes inactive.  Currently all scrollbars are made to overlap their
+// surroundings, which doesn't work well for the text window in the hello sample.
+#define GRW_FIXES_SCROLLBARS 1
+
+// In the spirit of making wxWin adapt to "the Mac look" I switched the order of
+// OK and Cancel in wxMessageBox and wxGetTextFromUser, and added wxSYSTEM
+// to the list of fonts.
+#define GRW_FIXES_OK 1
+#define GRW_FIXES_SYSFONT 1
+
+// Some changes I had to make to get USE_PANEL_CANVAS_IN_MAC working.
+#define GRW_FIXES_PANELCANVAS 1
+
+
+Happy Holidays,
+
+-Greg
diff --git a/src/wxmac/docs/README.mac b/src/wxmac/docs/README.mac
new file mode 100644
index 0000000..6235615
--- /dev/null
+++ b/src/wxmac/docs/README.mac
@@ -0,0 +1,73 @@
+README.mac 
+11/28/95 - Alpha 4 snapshop
+	New with wxMac161d-a4
+	1. Better support for wxBitmaps - now allowed in wxMessage. Bitmaps
+	can be loaded from PICT, GIF, XBM, XPM, and BMP files.
+	2. Print architecture
+	3. Includes 68K and PPC projects (CW 7 though)
+	4. GUSI or Mac Python can supply the unix emulation functions - a new project
+	is provided for building a mac(PPC) wxWindows library for wxPython.
+	5. Bug fixes and attempted bug fixes - please see the wxMac Status files.
+	
+10/3/95 - Alpha 3 snapshot
+    New with wxMac161d-a3
+	1. added wb_dialg.cc back to the project - mostly #if'd out.
+	2. added USE_IMAGE_LOADING_IN_MAC to wx_setup.cc. Restructured
+	   wxBitmap code in wx_gdi.cc to use wx_image.cc.
+	3. Begin conversion of wxImage - much remains to be done.
+	   Can load bitmaps with PICTs or GIFs. (Thanks birk@moonface.com)
+	4. Converted most projects to CodeWarrior 7.
+	5. Added code to actually do wxTextWindow::SaveFile()
+	6. "Fix" for default (-1) height arg for wxText constructor
+	7. CWGUSI 1.60 required by default.
+	8. wxFileSelector returns pathnames and filename (requires GUSI)
+	9. Changes in distribution format:
+	   Binary archives will be self extracting Stuffit archives in binhex.
+	   Removed (msw) and (x) directories from include and src directories and most
+	   deleted non-MPW Makefiles.
+	   Added utils/image and utils/extend - selected files only.
+	10. Has not been tested with MPW - probably won't be for some time.
+	11. New distribution method - diff/patch files plus 68K apps for
+	    GNU-diff and patch. Named wxMac161d-a2-to-a3.sit.hqx. DOES NOT update
+	    CW projects however.
+		
+8/27/95 - Alpha 2 snapshot
+	New with wxMac161d-a2:
+	1. Added wxTimer.
+	
+	2. Cleaned up wb_*.cc and wb_*.h for fewer wx_mac conditionals.
+	
+	3. A "Fix" for placing canvas's on frames positioning (Beware).
+	
+	4. Added code for wxMemoryDC, changed internal handling of wxBitMap.
+	
+	5. Animate demo seems to work.
+
+8/9/95 - Alpha 1 snapshot
+
+This is a snapshot of the wxWindows Macintosh porting effort. It
+*is not* a complete port. There is a large list of bugs still to
+be fixed. This snapshot is a curious mixture of WxWindows 15.0 
+and 16.1 and not everything is implemented properly. 
+
+You will have the best results using the CodeWarrior 6 development 
+tools. MPW makefiles are provided, and some of them work. A 
+Think-C++(7) project is included but is not up to date. You will
+need a 68030/040 or PowerPC Mac running System 7.x and at least
+20MB of free disk.
+
+Please read the wxMac_Status and wxMac_Dev_Guide documents to
+understand what you are getting into. They are provided in
+both text and HTML formats.
+
+The files can found at ftp.aiai.ed.ac.uk, in the 
+/pub/packages/wxwin/incoming  initially, and later in the 
+/pub/packages/wxwin/ports area. There are two files which
+differ only in the archiving mechanism:
+	wxmac161d-a2.tar.gz	(suntar mac to mac format)
+	wxmac161d-a2.sit
+Pick either one, and be sure to enable binary mode in ftp.
+
+Good Luck.
+	Cecil Coupe
+	ccoupe@simplot.com
\ No newline at end of file
diff --git a/src/wxmac/docs/README.tomaso b/src/wxmac/docs/README.tomaso
new file mode 100644
index 0000000..df580b9
--- /dev/null
+++ b/src/wxmac/docs/README.tomaso
@@ -0,0 +1,34 @@
+For a "quick" try of the changes,
+there's an alternate wxMac library project
+(with its own precompiled headers and paths to :modif folder).
+
+Here are the changes to alpha4:
+
+wx_app.cc	: added a missing (and critical) DoIPCIdle call in the event loop 
+wx_ipc.cc	: cleaned up things
+wxMacPPC.c	: removed DEBUGLOG #defines
+wb_utils.cc	: again modified wxLogClass
+				(it looks like some changes to 1.50 have never migrated up to 1.61 )
+				
+--- some notes -----------------------------------------------------------
+In all projects, it would be better to use relative instead of absolute paths
+(some contain paths as "Prog:etc:etc" that simply has no sense on other Macs).
+
+If the close box of the last (and only) frame is clicked, 
+a "simulated" Quit event should be necessary to clean-up things
+(for example, client/server apps clean up connections only when
+ a Quit menu command is received , so clicking the go away
+ does not cause a "gentle" disconnect and the session remains open).
+  
+I still don't understand why menus are not shown if
+the "Failed to make connection to server" error is reported !
+(could be the NULL frame pointer returned as the top frame ?
+are we checking for NULL frames before accessing them? )
+				
+BTW, there's no apparent reason for the PowerPC code not to work.
+Your UPP changes look like the correct solution. Any hint ???
+
+Actually I'm trying to "feed" the Warrior with wxWindows1.63/MSW .
+It seems not so hard... I'll let you know if we really get cross-platform :)
+
+-----------------------------------------------------------------------
\ No newline at end of file
diff --git a/src/wxmac/docs/cjcfixes.txt b/src/wxmac/docs/cjcfixes.txt
new file mode 100644
index 0000000..8c01dbe
--- /dev/null
+++ b/src/wxmac/docs/cjcfixes.txt
@@ -0,0 +1,38 @@
+Here's a few things I need to add to the wxMac161d-a4p4 release
+
+1. in wx_gdi.cc, make sure cMacCursor is null:
+
+wxCursor::wxCursor(int cursor_type)
+{
+  __type = wxTYPE_CURSOR;
+  cMacCursor = NULL;
+
+2. in wx_app, doMacKeyDown(), Matt says to HNoPurge the resource:
+    default:
+      if (!transH) {
+		transH = GetIndResource('KCHR', 1);
+		HNoPurge(transH);
+      }
+
+3. in wx_xbm.cc, GETLINE(), we need to return a value (compiler warning):
+	if (pos < size)
+		b[pos] = 0;
+	return pos;
+
+4. in wx_menu.cc ~wxMenu, I would get crashes on hello sample but not others.
+   comment out the if (title) delete[] title; since wxbMenu now gets these.
+   
+	::DisposeMenu(cMacMenu); // WCH: does this dispose of submenus? I hope not.
+                             // mflatt: it does not dispose of submenus
+
+	// if (title) delete[] title; // WCH: ~wxbMenu should do this - (cjc - it does)
+	wxNode* node = menuItems.First();
+
+5. in wxLabelArea.cc , constructor, I add 5 to the width of a horizontal Label so that
+   labels do not butt up against the control. This hack *used* to be in GetTextExtent.
+   This is a more appropriate place.
+
+	else
+	{
+		SetMargin(labelWidth+5, Direction::wxLeft);
+	}
diff --git a/src/wxmac/docs/matts.txt b/src/wxmac/docs/matts.txt
new file mode 100644
index 0000000..ca25673
--- /dev/null
+++ b/src/wxmac/docs/matts.txt
@@ -0,0 +1,223 @@
+From mflatt@cs.rice.edu Sat Jan 13 16:16:08 1996
+Date: Thu, 11 Jan 1996 17:27:22 -0600 (CST)
+From: Matthew Flatt <mflatt@cs.rice.edu>
+To: hale@mailhost.tcs.tulane.edu, jonto@aiai.ed.ac.uk, ccoupe@simplot.com,
+    birk@moonface.com, maxwell@natasha.jpl.nasa.gov, sarago@dei.unipd.it
+Subject: wxMac changes
+
+
+Below is a description of changes I made to wxMac. I couldn't find a
+good Mac diff program --- and I changed a lot --- so my final code is
+available as:
+  ftp://cs.rice.edu/public/mflatt/wxmac/wxMacAfter.sit.bin
+To make diffs as easy as possible (for someone with a program), my
+starting point is:
+  ftp://cs.rice.edu/public/mflatt/wxmac/wxMacBefore.sit.bin
+
+I tested my changes by compiling the Hello demo. wxMedia works very
+well with this wxMac. Enjoy.
+
+Want to see why I made all these changes? A Macintosh MrEd executable
+is available as
+  ftp://cs.rice.edu/public/mflatt/mred.mac.68k.sit.hqx
+and
+  ftp://cs.rice.edu/public/mflatt/mred.mac.ppc.sit.hqx
+
+Matthew
+
+------------------------------------------------------------------
+
+* Menu System
+
+The menu system has been debugged and improved.
+
+Menu items in a menu and menus in a menu bar can be dynamically added
+and removed. Some constraints are enforced: a menu bar can be inserted
+into only one frame, a menu can be inserted into only one menu bar or
+other menu.
+
+The "Help"/"About" hack remains, but if no such menu item is inserted,
+an "About..." label is obtained from wxApp::GetAboutMenuItem() and
+wxApp::DoAboutMenuItem() is called to handle the "About..." menu item.
+(I think "About..." is usually an application-wide menu item, not
+frame-specific.)
+
+~wxFrame() now calls ~wxMenuBar().
+
+If a menu item ends with "\tAlt+K", then K is used as the command key
+for the menu item. "&" is still recognized. Anything else in a menu
+item name is taken literally (i.e., the item name is installed with
+SetItemText() so that no special Mac characters get in the way).
+
+  !! Is "&&" changed to "&"? I forgot to check this.
+     What about other "\t"-based things? Forgot to check this, too.
+
+* Fonts
+
+The latest font system from Windows/XWindows has been installed. This
+provides access to fonts by name, instead of by a predefined set of
+family ids. Also, this system provides a way to configure the mapping
+from predefined family ids to real font names. (In practice, the
+mapping isn't configurable in wxMac because wxGetResource doesn't have
+a default source for resource values.)
+
+Unlike Windows and X-Windows, wxMac has the wxSYSTEM family.  I set
+wxNORMAL_FONT to use wxSYSTEM instead of wxDEFAULT. Perhaps wxDEFAULT
+should simply mean wxSYSTEM.  The control font would be configurable
+through wxWindows resources if there were a default resource file.
+
+* Activation, Keyboard Focus, and Enable
+
+There was a little bit of confusion between keyboard focus and
+activation, and window enabling was essentially unimplemented.
+These three work together, so I tried to get them all right. All
+of the foundation was in place; the details were just unimplemented.
+
+Activation indicates which window is in the foreground. Only one frame
+can be active, but all windows in an active frame are active. This
+was pretty much done.
+
+Keyboard focus indicates which window within a frame receives keyboard
+commands when the frame is active. Only one window can have the focus
+as a time. Disabled windows cannot have the focus. When a window receives
+a mouse click, it also gets the focus if it wants it (i.e., if it
+returnes TRUE from WantsFocus()). Text items, panels, canvases, and
+list boxes currently accept the keyboard focus.
+
+If a window is disabled, neither the window nor any of its children
+can receieve keyboard and mouse events and disabled frames cannot be
+resized. Windows can be enabled directly by Enable(). When a frame is
+disabled, its menu bar is disabled.  Enabling, SetModal(), and
+CaptureMouse() were previously implemented. Calling a frame's
+SetModal() method means that no other frame can be activated.  Also
+SetModal() causes all other frames to be disabled (this is
+redundant). CaptureMouse() works on any window: only that window and
+its decendents can receive mouse and keyboard events; all other
+windows are disabled.
+
+ !! There is not currently a capture stack. There should be.
+
+(Hiliting --- e.g. a button being pressed --- was already properly
+distinguished from activation.)
+
+* Garbage Collection
+
+Of course, since the goal of my changes was to get MrEd running,
+basic garbage collection support has been installed. None of these
+changes has any effect if WXGARBAGE_COLLECTION_ON is #defined as 0.
+
+wx_obj.h was modified to derive wxObjects from the garbage-collectable
+class. A few WXGC_IGNOREs were thrown in the constructors of various
+class to break finalizatyion cycles.
+
+wxTheXXXList is never used implicitly by a wxXXX constructor. Frames
+are not inserted into the global list of frames until they are shown,
+and they are removed when hidden. Clicking on the close box hides a
+frame instead of deleting it.
+
+* Events
+
+All wxEvent objects now contain a `timeStamp' value. wxMouseEvent and
+wxKeyEvent objects contain a `metaDown' value, which is TRUE when the
+command key is pressed. (It is always FALSE in wxMouseEvent on the Mac
+because command is used to generate a right button click.)
+
+* List Boxes
+
+wxListBox now uses buttonFont, shows keyboard focus with a bold
+border, accepts simple keyboard movement commands, responds to a
+double-click or a carriage return by invoking the panel's
+OnDefaultAction method, and updates properly when the list contents
+are changed.
+
+ !! The keyboard focus display implementation is clumsy.
+
+* Text Items
+
+wxText items should always have a border. This border is outset from
+the text by two pixels. A horizontally-placed label lines up with the
+content of the text box rather than the top of the
+border. wxPROCESS_ENTER works. The default size is based on the label,
+buttonFont, and labelFont.
+
+  !! The border seems clumsily implemented. I just don't understand 
+     wxArea, wxMargin, etc.
+
+* Canvases
+
+wxBORDER implemented.
+
+* Memory DC
+
+The bitmap passed to wxMemoryDC::SelectObject() is now used as the
+destination for all drawing into the DC. A wxBitmap object can be
+installed into at most one wxMemoryDC().
+
+* Image utilities
+
+Error handling was corrected to account for NewGWorld failure.
+(This is hard to test.) The xbm-reading routine now works for
+files using Unix-style newlines.
+
+* Clipboard
+
+The platform-independent wxClipboard and wxClipboardClient
+classes were installed.
+
+* DC Additions
+
+wxDC::GetClippingRegion() was added. When there is no clipping region,
+-1 is returned for the clipping height/width.
+
+GetTextExtent() and DrawText() take a new last optional argument. The
+intent for this argument is to enable drawing in 16-bit fonts, but it
+isn't yet implemented.
+
+* PostScript printing
+
+The latest wb_ps.cc was installed. It works with the new font
+directory to map font names to PostScript names and AFM files.
+
+* SetSize
+
+In Windows and X-Windows, passing -1 as the x or y position to SetSize
+means "don't change the size". This is now true for wxMac. To set the
+position to -1, use the wxPOS_USE_MINUS_ONE flag as the new optional
+last argument.
+
+* Utilities
+
+Added wxBell(), wxGetOsVersion(). Uncommented some code in wb_utils.cc
+that seems to work fine.
+
+The GUSI implementation of wxGetFirstFile() and wxGetNextFile() did not
+work at all for me. I tried upgrading them using the latest unix code,
+but I soon gave up and made minor patches to the Mac Toolbox version.
+
+* Miscellaneous
+
+wxChoice works without a label
+
+wxMessageBox takes wxWindow, not wxFrame
+
+wxScroll: page down doesn't overrun specified maximum
+
+wxGetResource doesn't try to open a file when given NULL for a filename
+
+Many other small things I forgot about
+
+
+!! Other Bugs
+
+I've received reports of crashing in wxDoMacKeyDown. Perhaps the
+handle to the 'KCHR' resource is getting purged?
+
+wxMessage doesn't size correctly
+
+CodeWarrior bug?: When I enable Exceptions, embedded objects are not
+destroyed properly. For example, ~wxWindow calls ~wxList to destroy
+the areas list, but the body of ~wxList is skipped. So is the body of
+~wxObject. It's not just ~wxWindows - it happens anywhere with
+embedded objects. But I can't reproduce this in a small setting! Has
+anyone else seen this? Turing of Exceptions (I don't need them) makes
+things work fine. I saw this for PowerPC; I don't know about 68k.
diff --git a/src/wxmac/docs/wxmac doc/Sample Sytles b/src/wxmac/docs/wxmac doc/Sample Sytles
new file mode 100644
index 0000000..1e62ab8
Binary files /dev/null and b/src/wxmac/docs/wxmac doc/Sample Sytles differ
diff --git a/src/wxmac/docs/wxmac doc/Window Area Runtime b/src/wxmac/docs/wxmac doc/Window Area Runtime
new file mode 100644
index 0000000..0af7f57
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/Window Area Runtime	
@@ -0,0 +1,203 @@
+(This file must be converted with BinHex 4.0)
+:%eGTEQ4[Gb""FQ9K)&*eER4TE@8!4&*A4de%8%`"!!!!)!!!!!fC&#"%8PG(4$)
+!!3!$!!!",!%X!*!%#q!)r2pqri--BJPj!fF&+!2m!!)!!!%X!5`!N!3,i!Mm!!%
+!!!"N!!!!!3!"!3%!!!!"*`m!!3!"!*!0!J!C!C!!!*!&3!#3#3%!N"%)!(d!5!!
+!!%J!N!J"!3#3E`%!"J!'!!%!"J!'!$8!1`!)!*!*!3!"!!!!-!!!!!)!N!QEJ!!
+!ErQF!,b!!!"i"Q3!Si!!!'hjR!$%J!!!GJCN!!!!-!#3"3d!!!!#!!!"PJ!!!KD
+!!!#EJ!!!ErQF!,b!!!"i"Q3!!!!`!*!&$3!!!!)!!!'@!!!#&S!!!*Z!!!"[qC`
+![)!!!(J'C!!!!*!!!!!!5!!!!+J!!!"8!!!!%J#3&i!!!!!)!!!"&!#3#J@8!!!
+#`!!!!!J!N!mV3#)!N!Br[((((((((!!))!#3"!&!"UeDY@V9Ucr@NqNqNqNr!!S
+K!`!!!!%rq!#3"MrP9C!'!!`J!3!!!!%riL4)N5*%L6rm11111111!!%K!`!!!!&
+!(-b3"Fdr`FFFFFFFFJ!8)!#3"!%rcVK4ki8HZ%!3UT!&U`%X)!#3""S!!3!!!!%
+!!3!!!!%!!J!!!!)!!J!!!!%!"!!!!!3!"!!!!!%!"J!!!!B!"J!!!!%!#!!!!!J
+!#!!!!!%!#J!!!!S!#J!!!!%!#3!!!!N!N"8"!"X!!!!*!*!9!3!5!!!!%J#3&3%
+!0J!!!")!N"8"!%J!!!!*!!!!#3!!!!N!N!d"!%J!!!!*!!!!#3!!!!N!!!!*!!!
+!#3#3"3%!!3!-!!!!"!#3"3`!!J!-!!!!!`#3"3%!!`!'!!!!"J#3"3%!"!!-!!!
+!"3#3"3%!"3!&!!!!"3#3"3%!"J!$!!!!!`!!!!`!$!!+!!-!!!!*!*!*!3#3"c!
+!N!X`rj!%!*!0Qi!!!'rjR!#mJ!!!H!CN!!d!!!!#!!!"PJ!!!KD!!*!1Qi!!!'r
+jR!#mJ!!!H!CN!!d!!!!#!!!"PJ!!!KD!!!$NM-!!!!B!N!3)"daKH@9b)c%!!!%
+)!!!!$!!!!!3!N2m-!!!!!3!!!!J!!!%)!!!!C!!!!$`!!!!%!!!!q!!!!6!!!!"
+S!!!!P!!!!-`!!!&F!!!"P!!!!F`!!!)%!!!#-!!!!QJ!!!+8!!!#c!!!![J!!!-
+N!!!%(!!!"&3!!!1-!!!$A!!!!lJ!!!2N!*#Q")`!!!!"!!!!1!!!!!`!N!@!!!-
+!!3!!!$-!C3#!!*!&JIrr!!`!#J!-!!S!$!!+!!`!#J!+!!!!"!!!!#`!!!!)!*!
+&#!!"!!%!!!!)!*!&#Irr!!`!#J!-!!T`-!!!!!-!!!!X!!!!&!#3"3B!!3!"!!!
+!"J#3"3Irr`!-!!S!$!!+GH!!!!!"!!!!1!!#!!)!!C)J!*!&!iCN!#)!!!!$KQ3
+!%qC`!*!&%qC`!!1'C!!6jR!!"`c)!!!!!J!!!#`!!!!B!*!&$3!"!!%!!!!0!*!
+&$[rr!!`!#J!-!!S!N!8"!!!!1!!#!!,rrQhJ!*!&!iCN!"`!!!!$KQ3!$KQ3!!!
+($-J!$KQ3!!!$KQ3!$KQ3!!#3"`%!!!!X!!!!%!#3"3J!!3!"!!!!#!#3"3Rrr`!
+-!!S!$!!+!$J!!!!"!!!!1!!#!!)!!C)J!*!&!iCN!#-!!!!$KQ3!&1C`!*!&&1C
+`!!1'C!!8jR!!"`c)!!!!!3!!!$J!!J!#!!'5)!#3"31'C!!9!!!!!iCN!!EQF!#
+3"3EQF!!$KQ3!"ZC`!!F-b!!!!!%!!!!i!!)!!J!"NL!!N!8$KQ3!&3!!!!1'C!!
+'jR!!N!8'jR!!!iCN!!EQF!!($-J!!!!"!!!!,!!!!"`!N!8,!!%!!3!!!!X!N!8
+-rrm!$!!+!!`!#R!"!!!!!3!!!$J!!J!#rrjYi!#3"31'C!!G!!!!!iCN!!iCN!!
+!"`c)!!iCN!!!!iCN!!iCN!!!N!F"!!!!,!!!!#!!N!8,!!%!!3!!!!X!N!8-rrm
+!$!!+!!`!#J#3"3%!!!!i!!)!!J#3"31'C!#3"31'C!"6!!!!"`c)!%6QF!!$KQ3
+!41C`!*!&41C`!!!!!J!!!#`!!!!N!*!&"J!"!!%!!!!'!*!&"rrr!!`!#J!-!!U
+1X!!!!!%!!!!X!!!!+!#3"3B!!3!"!!!!"J#3"3Irr`!-!!S!$!!+!*!&!3!!!$J
+!!J!#!!'5)!#3"31'C!")!!!!!iCN!$RQF!#3"6RQF!!$KQ3!1HC`!!F-b!!!!!%
+!!!!`!!!!-!#3"4F!!J!"!!!!#!!A!*!&'2rr!!`!#J!-!!S!$!!+!!!!!3!!!#`
+!!!!X!*!&#!!"!!%!!!!)!*!&#Irr!!`!#J!-!!V#m!!!!!%!!!!X!!!!0!#3"@)
+!!3!"!!!!BJ#3"@2rr`!-!!S!$!!+)'d!!!!"!!!!1!!#!!,rrQhJ!*!&!iCN!&J
+!!!!$KQ3!$KQ3!!!($-J!$KQ3!!!$KQ3!$KQ3!!#3"`%!!!!i!!)!!J!"NL!!N!8
+$KQ3!)!!!!!1'C!!4jR!!N!84jR!!!iCN!"(QF!!($-J!!!!"!!!!1!!#!!)!!C)
+J!*!&!iCN!#!!!!!$KQ3!%HC`!*!&%HC`!!1'C!!4jR!!"`c)!!!"#!!!!$J!!!#
+-!!!!"!!!!-3!!!#F!!!!V!!!!03!!!$S!!!!r!!!!3`!!!%m!!!"(!!!!8`!N0)
+"Z!!!!!%!!!#)9'KP)("eFR"[Ff8JEfBJGhK"FQ9K)'pLDQ9MG(-JDA-JG'mJB@a
+XEhFJB5"`BA*PER3JGhKAD@jNEhFJEf*UC@0d)(4[)'KKGQ8JC'PQCQ9bC@jd)'p
+bD@GTER-JCQpb)'PdFb"MD'PXC(*PEL!SGhKAD@jNEhFJ6f*UC@0dFbN!!!!"!!!
+!%(Gi9fPZC'ph!!!!!3!!!""hH%aTFh3!N!8"!!!!'(GTEQ4[Gep`BA*PER6iDe!
+!!!!"!!!!%'0SD@aNFQ9Z!!!!!3!!!"4`BA*PER4IBA*PBA3!!!!"!!!!&'0XD@9
+ZG&pKFQ9K!*!%!3!!!""hH%&bC@%!N!8"!!!!%'0"FQ9KF`#3"3%!!!!JBdeKFQG
+TEJeM8'&bC@jd9fPZC'ph)#S!N!3"!!!!%'0AD@jNEhGc!!!!!3!!!'a&B@0S)(G
+i9fPZC'ph)'0[ER4KD@jc)'jPFh4PC#"hH%&bC@%JEf*UC@0dFbiJ9'KP)'eKFQG
+TEL!JFh"PBfPQD@9c)(GSCA*P)(4SC5"ZCAKd)'&bC@%JDA-JE'pMBA4PC0'`rrJ
+!!!!#!!!!$3!!!"F!!!!a!!!"$3!!3!%!N!N-!*!&CB!!!$U!!!#MJ!!!Qi!!!!-
+"!3!'!!8!N!PSJ!!!Qi!!!'Q!!!$HJ!!!!J%"!!B!N!Y,J!!!fIQF!'L!!!$L"Q4
+!3J%"!!B!N!83!*!&DJ!!!*`!!!"f!!!!iJ!!3!%"!*!))!#3"CU!!!#EJ!!!Qi!
+!!,+!!!!#!3%!"J#3#jU!!!#XqC`![B!!!,8'C%!#!3%!"J#3"4`!N!@1!!!!RJ!
+!!*S!!!$$!!"!!3%!N!J8!*!&mi!!!+b!!!%ZJ!!"%S!!!!-"!3!'!!8!N!PS!!!
+!8J!!!(3!!!#$!!"!!3%!N!J)!*!&d)!!!,2jR!$dJ!!![!CN3!)"!3!'!*!&*!#
+3"I1!!!%lJ!!",S!!!D'!!!!$!3%!"J!&!*!*hS!!!,H!!!$IJ!!"c)!!!!)"!3!
+'!*!,hS!!!86jR!$dJ!!"63CN3!)"!3!'!*!&+!#3"I5!!!'`J!!",i!!!KD!!!!
+$!3%!"J!&!*!*hS!!!FIjR!$dJ!!"d!CN3!)"!3!'!*!&,!#3"I`!!!&B!!!"#!!
+!!BN!!%!"!3#3#!J!N!Al!!!"c!!!!3F!!!(p!!"!!3%!N!J)!*!&D`!!!!)!!!"
+h!!!!1J!!3!%"!*!)-!#3"@U!!!!3J!!!Di!!!$Z!!!!L!3%!"J!!!!-N3!#3"8b
+!!!!0qC`!DS!!!"B'C%"#!3%!"J#3"63!N!9hJ!!!lS!!!*L!!!%qJ!!!!`%"!!B
+!"3#3#ArjR!#EJ!!!L!CN!1q!!%!#!3%!"J#3"6`!N!9j!!!!S3!!!)8!!!$9!!"
+!!3#3#6J!N!9m!!!"!J!!!)J!!!%R!!"!!3%!N!K!!*!&Ki!!!&'!!!#FJ!!!JB!
+!!!-"!3!'!!8!N!QmJ!!!Ri!!!0'!!!$2J!!!'J#3#B!!N!@mJ!!!Ri!!!0'!!!$
+2J!!!!`%"!!B!"3#3#F%!!!#S!!!!c3!!!-J!!%!"!3#3#"J!N!@p!!!!S!!!!0%
+!!!$2!!!!'`#3#B!!N!9k!!!!9`!!!)B!!!"i!!"!!3%!N!K%!*!&ii!!!"'!!!%
+eJ!!!CS!!!!-"!3!'!!8!N!R9!!!!%`!!!1%!!!!i!!"!!3%!N!K!!*!&Qi!!!&I
+jR!$NJ!!!B!CN3!)"!3!'!*!&5!#3"CU!!!"NqC`!Zi!!!'d'C%!#!3%!"J#3"8`
+!N!@-!!!!@`!!!*J!!!"l!!"!!3%!N!JB!*!%!6%!!!$)!!!"23!!!2N!!%!"!3#
+3#!J!N!AT!!!!&!!!!3%!!!"N!!"!!3%!N!KB!*!%!4'!!!!HJ!!"*S!!!%k!!!!
+D!*!*J!#3"!%4J!!!(S!!!5D!!!"1J!!!!`%"!!B!"3#3#!%@!!!!*`!!!5)!!!"
+(!!"!!3%!N!JB!*!%!4)!!!!I!!!"*J!!!%i!!!!E!*!*J!#3"!%'!!!!(`!!!4)
+!!!"-!!"!!3%!N!K8!*!%!BS!!!!E!!!"PJ!!!HJ!!%!"!3#3#&`!N!AjJ!!!CS!
+!!2U!!!#"J!!!)J%"!!B!!!!$*%!!N!@KJ!!!IIQF!2U!!!#'"Q4!3J%"!!B!N!9
+J!*!&pJ!!!,!!!!%#!!!!pJ!!3!%"!*!))!#3"CZ!!!"[qC`![)!!!(J'C%!#!3%
+!"J#3"9!!N!3G-[q3"!!!(8!!!3!!!!Vrrrrp!3#3"!-!!3#3"KeQrj!%!!!GG!!
+"!!!!#[rrrrd"!*!%!`!"rj!%!!!!$!!!!!%!!!!(!!,rrrrq!!!!"!!!!!)!!!!
+#rrrrq`!!!!d!!!!)!!)!!!!1!!!!#`#3"`m!!!"N!!!!!J!#rrrrm3!!!$J!!!!
+)!!3!!!!j!!!!#`#3"cS!!!!,!!!!!J!!!$X!!!!,!!!!"!!!!$`!!!!,!!!!"J!
+#rrrrl!!!!&!!!!!'!!-!!!"4!!!!#J#3"e)!!!!+!!!!!J!!!&-!!!!+!!!!"!!
+#rrrrl3!!!%d!!!!)!!)!!!"1!!!!#`#3"drrrrrX!!!!!J!"rrrrlJ!!!!J!!!!
+)rrrrl3!#rrrrl`!!!%J!!!!3!!3!!!"*!!!!!`#3"dS!!!!,!!!!"!!!!%X!!!!
+,!!!!"J!!!%crrrrZ!!!!#!!!rrrrm!!#rrrrl`!#rrrrmJ!!!$3!!!!b!!m!!!!
+e!!!!CJ#3"cB!!!!,!!!!"!!!!$Irrrra!!!!"J!!!$d!!!!,!!!!$J!!!$i!!!!
+,!!!!%!!!!$m!!!!$!!!!%J!!!%!!!!!$!!!!&J!!!%%!!!!$!!!!'J!!!%)!!!!
+,!!!!(J!!!%-!!!!,!!!!)!!!!%3!!!!,!!!!)J!!!%8!!!!,!!!!*!!!!%B!!!!
+$!!!!*J!!!%Irrrr`!!!!+J!!!&3!!!!$!!!!,J!!rrrrm`!#rrrrmJ!#rrrrkJ!
+!!&X!!!!+!!)!!!"F!!!!#`#3"ehrrrra!!!!!J!!rrrrk`!#rrrrkJ!"rrrrjJ!
+!!!J!!!!"!!!!"J!#rrrrj`!!!'J!!!!)!!%!!!"TrrrrjJ#3"3,rrrrS!!!!B!!
+!!"`!"`!!!'%!!!!,!*!(B[rrrr-!!!!#!!!!B`!!!'F!!!!'!!!!C!!!!'F!!!!
++!!!!C3!!!!X!!!!1!!!!CJ!!!'F!!!!3!!!!CrrrrqF!!!!8!!$rrrrT!!,rrrr
+S!!,rrrrP!!!!E3!!!!3!!J!!!'i!!!!,!*!(E`!!!!X!!!!#!!$rrrrH!!%!!!"
+U!!,rrrrI!!!!MJ!!!"3!"`!!!)m!!!!#!*!(L3!!!!B!!!!%!!!!N!!!!!!(!!!
+!"3!!!*%!!!!+!!!!"J!!!*,rrrrH!!!!#!!!!)S!!!!#!!!!$!!!!*-!!!!#!!!
+!%!!"rrrri!!!!"3!!!!8rrrrh`!#rrrri3!!!)8!!!!J!!J!!!#'!!!!#J#3"iF
+!!!!(!!!!!J!!!)J!!!!'!!!!!`!!!)N!!!!#!!!!"!!!!)S!!!!'!!!!#!!!!)X
+!!!!'!!!!#3!!!)`!!!!+!!!!#J!!!)hrrrrJ!!!!$!!!rrrriJ!"rrrri3!#rrr
+ri`!!!)-!!!"3!"3!!!#%rrrriJ#3"j6rrrrL!!!!"!!!!*ArrrrL!!!!#!!!!*E
+rrrrL!!!!$!!!!*IrrrrL!!!!%!!!!*MrrrrL!!!!&!!!!*RrrrrL!!!!'!!!!*V
+rrrrL!!!!(!!!!*[rrrrL!!!!)!!!!*crrrrL!!!!*!!!!*hrrrrL!!!!+!!!!*l
+rrrrL!!!!,!!!!*rrrrrL!!!!-!!!!+$rrrrL!!!!0!!!!+(rrrrL!!!!1!!!!+,
+rrrrL!!!!2!!!!+2rrrrL!!!!3!!!!+6rrrrL!!!!4!!!!+ArrrrL!!!!5!!!!+E
+rrrrL!!!!6!!!rrrrj!!"rrrri`!#rrrrp!!!!$)!!!"X!#!!!!!3!!!!#`#3"c2
+rrrrc!!!!!J!!!&8!!!!,!!!!"J!!!&B!!!"R!!!!#!!!!&F!!!!,!!!!$!!!!&J
+!!!!,!!!!$J!!!&Rrrrra!!!!%!!!!&VrrrrV!!!!'!!!!&lrrrrV!!!!(!!!!&r
+rrrrT!!!!)!!!!'VrrrrX!!!!*!!!!'[rrrrX!!!!+J!!!'crrrrP!!!!-!!!!($
+rrrrP!!!!0!!!!(%!!!!,!!!!1!!!!(,rrrrT!!!!1J!!!(2rrrrT!!!!2J!!!(3
+!!!!,!!!!3J!!!(8!!!!,!!!!4!!!!(B!!!!'!!!!4J!!!(F!!!!(!!!!4`!!!(J
+!!!!,!!!!5!!!!(N!!!!,!!!!5J!!!(S!!!!$!!!!6!!!!(X!!!!$!!!!8!!!!(`
+!!!!$!!!!9!!!!(d!!!!,!!!!@!!!!(i!!!!,!!!!@J!!!(m!!!"R!!!!A!!!!)!
+!!!"R!!!!B!!!!)%!!!"R!!!!C!!!!),rrrrN!!!!D!!!rrrrp3!"rrrrp!!#rrr
+re3!!!,B!!!!)!!)!!!!1!!!!#`#3"`m!!!"N!!!!!J!!rrrre!!"rrrrq`!#rrr
+reJ!!!,3!!!!3!!-!!!#errrre3#3"lIrrrre!!!!#!!!!,Mrrrr8!!!!$!!!rrr
+re`!"rrrreJ!$rrrrd`!!!,X!"J!%!!!![`#3"li!!!!"!!!![3!!!!)!!!#m!!!
+!!`!#rrrrf!!!!,%!!!#U!!3!!!#brrrrr!#3"l2rrrrA!!!!R!!!!,RrrrrR!!!
+!S!!!!,Vrrrr6!!!!U!!#rrrrf3!!!+m!!!#U!!%!!!#`rrrrf!#3"3,rrrr,!!!
+!cJ!!!#3!#!!!!!crrrrl!*!(c`!!!!-!!!!)!!!!d!!!!!-!!!!-!!!!d3!!!!-
+!!!!3!!!!dJ!!!!-!!!!8!!!!+J!!!!-!!!!B!!!!d`!!!!-!!!!F!!!!e!!!!!-
+!!!!J!!,rrrr-!!!!c!!!!#B!!J!!!-hrrrr,!*!(e3!!!!X!!!!N!!$rrrr0!!(
+rrrr-!!(rrrr'!!!!)!!!!!)!!!!,!!(rrrr&!!!!)!!!!!)!!!!,!!,rrrr(!!!
+!f3!!!%3!!`!!!0Vrrrr'!*!(frrrrm8!!!!J!!!!h2rrrq8!!!"!!!$rrrr)!!,
+rrrr(!!,rrrr*!!!!e`!!!!`!!J!!!!crrrrl!*!(f2rrrmJ!!!!)!!$rrrr+!!(
+rrrr*!!,rrrr1!!!!b!!!!$!!#`!!!!crrrrl!*!(b3!!!!-!!!!)!!!!bJ!!!!-
+!!!!-!!!!brrrrmd!!!!3!!!!e[rrrmS!!!!8!!!!h3!!!'B!!!!B!!!!hJ!!!!-
+!!!!F!!!!h`!!!!-!!!!J!!!!i!!!!'B!!!!N!!!!i3!!!'B!!!!S!!!!i[rrrpi
+!!!!X!!,rrrr%!!!!k!!!!!3!!3!!!'i!!!!$!*!'rrrr``!"rrrrc`!#rrrr[[q
+3"!!!!!3!!J!!!28!!!!$!*!(pJ!!!'B!N!8#rrrr[`!!!2!!!!!F!!B!!!!-rrr
+rq`#3"pVrrrr8!!!!#!!!!2(rrrr!!!!!$!!!!2,rrrr!!!!!%!!!!22rrrr#!!!
+!&!!!!26rrrqq!!!!'!!!rrrr`!!"rrrr[`!#rrrr`3!!!1`!!!!F!!B!!!!-rrr
+rq`#3"qd!!!!$!!!!#!!!!1i!!!!$!!!!$!!!!1rrrrr!!!!!%!!!!2Irrrr!!!!
+!&!!!!2J!!!!#!!!!'!!!rrrr`J!"rrrr`3!#rrrr[!!!!2S!N!Mrrrqp!!(rrrq
+m!!,rrrqi!!!"!*!%&J!'!!!!$2rrrrX!N!B"!3!!!!-!!!!)!!!!83!!!!B!!!!
+-!!!!8`!!!!B!!!!0!!!!8J!!!!B!!!!1!!!"![rrrq`!!!!3!!,rrrqj!!!!rJ!
+!!#B!"!!!!!crrrrl!*!(+J!!!!-!!!!)!!!!,IrrrrF!!!!-!!!!rj!%Z!!!!"!
+!![rrrlS!!!$m!!!!*J!"!!!!rIrrrlN!N!Errrql!!(rrrqk!!,rrrqf!!!"#3#
+3#2rrrlF!!IrrrlB!![rrrmm!!!$'!!!!R!!9!!!!arrrrmi!N!IM!!!!!`!!!$!
+!!!$N!!!!!`!!!$3!!!$P!!!!!`!!!$J!!!$Q!!!!!`!!!$`!!!$Rrrrra!!!!%!
+!!!$Trrrra-Y(!!!"!!!!#p-!!!V6!!!"aTC$l[pb)%P`-+*J2J"QEL!mH'aKG%(
+Zr`BL5+'Y)SK+%eGTEQ4[Gb""FQ9K)&*eER4TE@8#!!!!4&*A4de%8%`!!%459dG
+04&"-3!#3&kdQKD3!N!B0Q@!q!#"Z!!``V[mLB!*qK6!(61i3`2lk6Pj1G8j@ri*
+)j`-)2#i!##KZ!!TqrdKZrrj)abm(6VVr1%T!8%pQ'$PZrri!'#"-F#1LB%T!CJK
+#EJ!1B!!!QVj'CbK)E[rm5-B["Nkkr`T+3&"2CKBjE[rm!"JJ6(!MSQ"+3'B'3Qi
+!$Q!!!!"BC!8##3!T!!-"X!*3!!!!!3!"!!%!!3!#!!)!!3!"!!%!"J!&!!-!#3#
+3"`)!N!9!!LJ!!!,CQCS!!!$'!!!!H3#3#J,CQCS#+!#3"8J!N%X5rj!5!!!!N!!
+!!3!!!!%!!#%!N!`)!!%!!3!!!!%!!#!!!`#3#JS!!J!!3!!!!3!!)3)"!*!+$!!
+$!!%!!!!b!!!J!!-!N!S"!!3!!J!!!!%!!#%!N!`8!!8!!3!!!!%!!#%!N!X",!!
+'!!!!N!!!!3!!!!%!!#!!N!`)!!%!!3!!!!%!!#%!!`#3#JS!!J!!3!!!!3!!)!)
+"!*!+$!!$!!%!!!!b!!!K!!-!N!S"!!3!!J!!!!%!!#!!N!`8!!8!!3!!!!%!!#!
+!N!X",!!'!!!!N!!!!!!V3#)!N!Br[((((((((!!))3#3"!&!"UeDY@V9Ucr@NqN
+qNqNr!!SJ!`!!!!%rq!#3"MrP9C!'!!`K!3!!!!%riL4)N5*%L6rm11111111!!%
+J!`!!!!&!(-b3"Fdr`FFFFFFFFJ!8)3#3"!%rcVK4ki8HZ%!3UT!&U`%X)3#3"$!
+!!3!!!J!!!3!#!!!#!!!#!!3!!!)!!!-!"J!!!J!!"!!)!!!#!!!&!!S!!!)!!!B
+!!!#F!!N!!!!*!*!6!3!E!!!!#3#3%`)!%J!!!")!N"-$!$B!!!!5!*!6"!")!!!
+!#3!!!!N!!!!*!*!,"3")!!!!#3!!!!N!!!!*!!!!#3!!!!N!!!!'!!!!2!!-!!!
+!"!!!!!%!$!!!!!-!!!!#!!B!!!!'!!!!!`!-!!!!"3!!!!3!"3!!!!8!!!!&!!-
+!!!!$!!!!"J!!!"S!!$!!!J3!'`!!!"i!N!6!!*!-#!!!!!%!!!!"!!!!$J!"!!!
+"!!!#!*!*N[q3#!p0B@PZ)%4TBh4TEfjKFRN!N$!29A0PFL"%D@0dD@pZBA*j!*!
+`r"Rm'3!"!*!(#!!!!!-!N!F("NGPEQ9fB3!!!03!N!8&!!!!"J!!!!S!!!!,!!!
+!$!!!!!d!!!!1!!!!$`!!!"!!!!!4!!!!%J!!!"-!!!!8!!!!&3!!!"B!!!!A!!!
+!'!!!!"N!!!!D!!!!'`!!!"`!!!!G!!!!(J!!!"m!!!!J!!!!)3!!!#)!!!!M!!!
+!*!!!!#8!!!!Q!!!!*`!!!#J!!!!T!!!!+J!!!#X!!!!X!!!!,3!!!#i!!!![!!!
+!-!!!!$%!!!!b!!!!-`!!!$3!!!!e!!!!0J!!!$F!!!!i!!!!13!!!$S!!!!l!*!
+%!X3!!!!"H$`H$iI$iI!!!!!"L%3L%BK%)K%!!!!"ZqlGGl[ZhAF!!!!"c$0QQF`
+cCTN!!!!-!*!,(2q3#!!!!!&rrrrrprrrr`!!!!&rrrIrIrrhr`!!!!&hrphrGrr
+Gr`!!!!0hhAIGGpehh3!!!!1U9DT9UP@U93!!!!1))SJLL#+))J!!!!1)!#)!L!!
+L!*!%!i!!#!#!!!J!N!3$J!!!!!J!N!B"J)""2JJ)&1-!!!!"ri#!J2m)#!J!!!!
+"J8)N')&#*"J!!!!"J%!J%!J%!J%!!!!"i(!i(!i(Jm%!!!!"Gl[GlRHlhHi!!!!
+"L%3L%BK%)K%!!!!"QFaQ-jR-CM-!!!!")%#!!!J%!J#3"!(r!2m!r`$r!*!%!Im
+!!!$r!*!'!F`!!!!c!*!'!I#3"!q3"!!!!!(rL)L)riL)L!!!!!'U4+S4UN5U%3!
+!!!%"!J3)%#"!J!!!!!'$"`iF1($J`3!!!!(ZhEYhlYflG`!!!!%4)N5)%5*%L!!
+!!!%cCXbC-fE-Q3!!!!&!S!!!"!S!N!8"UT!)!!!!!BL3#!!!!!%"!4!3!3%3%!!
+!!!%!#"3U95S8#!!!!!(rJ*!(!!!!!B*%+"!S4))"!!!!!B!!N!S"J"!#)!%)3!3
+!!!!"UJ#U!+S!UJ#3"!&9reAr9Ip9r`!!!!(GrhIrhIphr`!!!!'U!)!!L!#!!*!
+%!3JF)X'!!3)%!!!!!E%`!a[B`!b0!!!!!BJ8)N')!+S!N!3"JN3j4))"!3%!!!!
+"!i4)-!`#!3%!!!!"9D"!3&8+"!3!!!!"%#"8U[m#"!J!!!!")&#)N!3&!J!!!!'
+r!,qrX*!%!!!!!IKd)NH2&b*a!!!!!AH*MiphQ2Mi!!!!J!!!!!%!"Iq3"J!!!"i
+!!!!"!!B!N!NK!!!!!3!-h@X)`JDL!!!!c3!!!!%!#J!!J!!4X!!!!98!!!!"!!X
+!N!68!!!!!CN!!!!"!!rm!20p"5m!!!"&!!!!!3!0!N'V91Vr!!!"%3!!!!%!$[,
+A#&D%l!!!!)N!N!IQ!!3!N!!!i!#3"2rrljm'6'&jEh9d%&4eFQiJ3A9dEfGbD@3
+J6fi!N!3,8fK[Gb"5G@aPFR-!N!318fK[Gb"(FQPNE'PZCA-!N!3*8fK[Gb"6DAT
+P!*!%%&0SEhFJ8'&RC5"#FQ9KDh-!N!3",3#3"!G-BAPPFR2*!*!%"e*eE'9bFmN
+!N!3*8'&dG'9bER2*!*!%$&"bC@CPFQ9ZBf9cb3#3"!e%FQ&hD@jR)&0THQA*!*!
+%!5d!N!304QPd)&4[)&GTEQ4[G`"0!!!*8f9d)&CTCAI*!*!)N3!(!&F!X!#3"2r
+rr2m%4QpZG!G$D'PMB@G[!*!%"d0[GA*TCA)!N!3'4f9ZCACK!!!5!!P)C@afCA4
+TBf%!N!3'6@pZB@0[!*!%#%jPGb"CEh*V!*!%"94TE@9c!*!%"PCPEQPMC3#3"!%
+Y!*!%"NC[ER4cb3#3"!P6CA3J8h4jE'8!N!La!!MrN!3!N!6rrphr"&0THQ8(15"
+3EfPZG!!!%JJ#-6!!!!!)!M%b!!!!#!)a0!!!!!J#-6J!!!!)!M)d!!!!#!)c0J!
+!!!J#0$J!!!!)!5d!N!3-8fPZCfaP)&0`B@0P!!!5!!a%Eh9LE'8J8h"KBf8!N!3
+,-L"`G#iJ8h"KBf8!N!3",3#3"!Y'Efjd)&0THQ9cb3#3"!e-D@jP)&0`B@0TEQI
+*!*!(!3!!!![6!!!+d`!!!FB!i'KB'i`!!!!F!FB!%d4TEQB!!!#L4(ChF`!!!+j
+%Fh4X!!!!ZP*cG$)!!!$'8R0PG!!!!0*%8R9X!!!!hP"cCA3!!!$U4(0PG!!!!2C
+"Ff9d!!!"!P"bC@B!!!%1H&"bCJ!!!4T`8(*Q!!!"*R03FQB!!!%b4QedH!!!!6j
+'EQec!!!"5R"KG&)!!!&@BQ&h8!!!!@*$G'*X!!!"EQ0[E&!!!!&k689193!#!BB
+"!2rr!*!&j)Y%!3$rr`!!!&`!j)[!!3$rr`!!!+J!j)Zd!3$rr`!!!,i!N!3"!2r
+r!!!"8J$NLhJ"!2rr!!!"jJ$NLf`"!2rr!!!#HJ$NLj!!!3$rr`!!!Ui!j)[`!3$
+rr`!!!di!j)ZN!3$rr`!!!ii!j)ZB!3$rr`!!!k`!j)Yd!3$rr`!!!lJ!j)Z!!3$
+rr`!!!mS!j)Ym!3$rr`!!"'!!j)c-!3$rr`!!"'`!j)d-!3$rr`!!"(F!j)dF!3$
+rr`!!"8m!j)cX!3$rr`!!#"F!j)c`!3$rr`!!#*X!j)cd!32rr`!!#*m!j)[N!3E
+rr`!!#BN!j)d3!3Irr`!!#Ki!j)dBj18:
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.html b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.html
new file mode 100644
index 0000000..886ccbc
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.html	
@@ -0,0 +1,560 @@
+<html><head><!-- This document was created from RTF source by rtftohtml version
+2.7.5 --><title>WxMac Development Guide</title></head><body><blockquote><i>This
+file is the start of a wxMac Developers Guide.</i>
+<i>Written by Cecil Coupe (ccoupe@simplot.com) with additions from Bill Hale
+and Tomaso Paoletti, and Matthew Flatt</i></blockquote><h2>
+<a name="RTFToC1">I.
+Introduction
+</a></h2>
+<h3>
+<a name="RTFToC2">What
+is wxWindows and wxMac
+</a></h3>
+wxWindows is a cross platform GUI development library with supporting
+applications and demos. wxMac is a port of wxWindows for the Macintosh.
+<h3>
+<a name="RTFToC3">Who
+is this document for?
+</a></h3>
+Part II of this document will help you install and *use* wxWindows for the
+Macintosh. Part III and beyond are intended for alpha and beta testers and for
+those who want to add  to or fix the wxMac code
+<h2>
+<a name="RTFToC4">II.
+Installation
+</a></h2>
+<h3>
+<a name="RTFToC5">Hardware
+and Software requirements
+</a></h3>
+MacOS - System 7 or greater<p>
+Color QuickDraw<p>
+32 bit addressing - so you require a 68030/68040 or PowerPC.<p>
+Floating point hardware will help (probably a lot).<p>
+Enough memory for your C++ compiler to handle large programs.<p>
+You will want 20MB of free space in order to run the sample applications, 40MB
+free would be easier to deal with.
+<h3>
+<a name="RTFToC6">Archives
+and compression
+</a></h3>
+There are several methods for bundling up a directory tree into a single file
+and compressing that file to reduce its size. Depending on how and which
+distribution you got you may need additional helper programs to create a real
+Macintosh folder(s).<p>
+1. If you are lucky, you downloaded a self extracting stuffit archive. Simply
+double click on the icon and StuffIt will ask where to put the Folders and
+files.<p>
+2. If you don't have the .sea or .sit versions of the distribution, but instead
+have a file ending in .tar.Z, .tar.gz, or .ZIP (or .zip), you need to acquire
+the following programs for your Macintosh:
+<ul>
+<li>MacGzip from ....
+<li>Suntar(2.0.2) from ....</ul>Also note, that tar may not preserve some of
+the Mac special characters, in particular the 'pi' character is the Option-p
+keys, and needs to be placed in project files. Parentheses are replaced with
+'+', which is only really a problem for Symantec.<p>
+3. If you don't understand both steps 1 and 2, (and even if you don't need #2)
+you will have a extremely steep learning curve ahead of you. I'm sorry,  but
+that is how it is in the cross platform world.
+<h3>
+<a name="RTFToC7">Chose
+your compiler/environment
+</a></h3>
+<b>Note</b>: Symantec Projects and MPW makefiles are out of date. CodeWarrior
+is the only supported compilers.<p>
+By now you've untarred/unzipped/unstuffed the archive, you might have read the
+README files, and you've already tried to build the system with CodeWarrior or
+Think-C++. MPW aficionados just modified the Makefile and tried it. You
+probably wouldn't be reading this unless you had a problem. Lets try it again,
+from the archive/zip/tar file (you did make a copy, right).<p>
+You should decide whether you want to use MPW, CodeWarrior, or ThinkC++. They
+can all coexist in the same set of folders, but life will be so much better and
+easier if you chose one now and stick with it throughout your wxWindows
+exploration.
+<h3>
+<a name="RTFToC8">Structure
+of distribution directories
+</a></h3>
+There will be a lot of directories/folders and files. The ones you want to deal
+with  are "samples", "src" and "include" in the top-level directory, plus the
+project files and/or Makefile and hopefully the README's and Documentation.
+IGNORE the others. You'll have plenty of time later after you get a decent
+install.
+<h3>
+<a name="RTFToC9">Compiling
+a wxWindows program with Metrowerks C++ (v7)
+</a></h3>
+The wxWindows library (used by all samples and any programs you write) has to
+be built first. In the top level directory, along with the 'src' and "include"
+directories should be a wxMac161-PPC.[[pi]] or wxMac161-68K[[pi]] project.
+Double click, select Make from the "Project" menu and cross your fingers.
+CodeWarrior may complain that some path's are not available, typically this is
+the path to wherever you installed Codewarrior. This error message is corrected
+by setting the project preferences (Edit-&gt;Preferences-&gt;Paths) to your CW
+installation Folder.<p>
+For 68k compilation, you must make sure that the library and all applications
+are compiled with the same prefs settings. As distributed, the projects build
+for 4 byte ints, 8 byte doubles, and no floating pt HW (that is 4i/8d). If you
+wish to change this you will also have to add the appropriate libraries into
+the project in place of the 4i/8d's that are there.<p>
+If all works well (no fatal compile errors) you can try the sample programs
+located in the "samples" directories. Drill down into samples:hello. Loaded it
+- I happen to like using the Finder to open the :samples:hello: folder and
+double clicking on the hello.ppc.[[pi]]. <p>
+Although, the 'minimal' program is even simpler than 'hello', if hello doesn't
+run for you, well its a long and winding road...
+<h3>
+<a name="RTFToC10">Compiling
+a wxWindows program with Symantec C++  or MPW
+</a></h3>
+Symantec and MPW is no longer supported with the alpha-4 snapshot. I'm not
+saying that you couldn't make it work, only that I no longer care to spend the
+copious amounts of time watching MPW compile. Its large enough under
+CodeWarrior as it is!
+<h2>
+<a name="RTFToC11">III.
+WxMac Internals
+</a></h2>
+Aside from curiosity, there are only three reasons to be reading this section
+of the document:<ul>
+<li>Your compiler coughed, rolled over and died on something. 
+<li>The test programs died, probably taking the MacOS with it. 
+<li>You like what you see and want to help it grow.</ul>
+<h3>
+<a name="RTFToC12">A.
+Philosophy and Goals of the wxMac Project [and participants]
+</a></h3>
+The first developer and instigator of the Macintosh port was Bill Hale who
+wanted to learn C++ by porting a "major" piece of code. The second to join was
+Tomaso Paoletti  who wanted (?) The third was Cecil Coupe who just wanted a
+cross-platform GUI for the python language and got sucked into the effort. Bill
+created the Mac specific part of Julian Smarts (jacs@aiai.ed.ac.uk)
+wxWindows.<p>
+Louis Birk, Matthew Flatt, Scott Maxwell and Greg Whitehead joined the project,
+each with real applications that they wanted to port. Each contributed serious
+development effort for wxMac.<p>
+Given the different perspectives it should be no  surprise that there are
+different stylistic tactics taken in various wxMac modules. So be it, We offer
+no apologies.
+<h3>
+<a name="RTFToC13">B.
+Necessary [useful] skills and reference material
+</a></h3>
+See the wxMac_Status document. The bug you found may be known. Also, sometimes
+the wxWindows documentation differs from the actual implementation.
+<h3>
+<a name="RTFToC14">C.
+How the classes are laid out (file/project point of view)
+</a></h3>
+Here is the list of .c and .cc files needed. This could be used to determine
+which files to load into another development environment.
+<dl>
+<dt>Project Name: "Prog:wxmac161d-a4:wxMac161-PPC."
+<dt>Precompiled Headers
+<dt>	wxGWin.pch
+<dt>Base
+<dt>	DebugNew.cp
+<dt>	wb_dc.cc
+<dt>	wb_data.cc
+<dt>	wb_canvs.cc
+<dt>	wb_dialg.cc
+<dt>	wb_gdi.cc
+<dt>	wb_frame.cc
+<dt>	wb_hash.cc
+<dt>	wb_help.cc
+<dt>	wb_ipc.cc
+<dt>	wb_item.cc
+<dt>	wb_list.cc
+<dt>	wb_main.cc
+<dt>	wb_mgstr.cc
+<dt>	wb_obj.cc
+<dt>	wb_panel.cc
+<dt>	wb_ps.cc
+<dt>	wb_mf.cc
+<dt>	wb_stdev.cc
+<dt>	wb_sysev.cc
+<dt>	wb_text.cc
+<dt>	wb_timer.cc
+<dt>	wb_types.cc
+<dt>	wb_utils.cc
+<dt>	wb_win.cc
+<dt>	wxstring.cc
+<dt>	xfspline.cc
+<dt>Mac Core
+<dt>	wx_app.cc
+<dt>	wx_area.cc
+<dt>	wx_buttn.cc
+<dt>	wx_canvs.cc
+<dt>	wx_check.cc
+<dt>	wx_choic.cc
+<dt>	wx_clipb.cc
+<dt>	wx_dc.cc
+<dt>	wx_dccan1.cc
+<dt>	wx_dccan2.cc
+<dt>	wx_dccan3.cc
+<dt>	wx_dcmem.cc
+<dt>	wx_dialg.cc
+<dt>	wx_frame.cc
+<dt>	wx_gdi.cc
+<dt>	wx_ipc.cc
+<dt>	wx_item.cc
+<dt>	wx_main.cc
+<dt>	wx_lbox.cc
+<dt>	wx_menu.cc
+<dt>	wx_messg.cc
+<dt>	wx_mnuit.cc
+<dt>	wx_mtxt.cc
+<dt>	wx_panel.cc
+<dt>	wx_rbox.cc
+<dt>	wx_rbut.cc
+<dt>	wx_sbar.cc
+<dt>	wx_screen.cc
+<dt>	wx_slidr.cc
+<dt>	wx_text.cc
+<dt>	wx_timer.cc
+<dt>	wx_txt.cc
+<dt>	wx_util.cc
+<dt>	wx_win.cc
+<dt>Mac Helpers
+<dt>	wxBorder.cc
+<dt>	wx_comparestrings.c
+<dt>	wx_mac_utils.cc
+<dt>	wxBorderArea.cc
+<dt>	wxGetTxt.cc
+<dt>	wxLabelArea.cc
+<dt>	wxMacDC.cc
+<dt>	wxMacObj.cc
+<dt>	wxMacPPC.c
+<dt>	wxMargin.cc
+<dt>	wxButtonBorder.cc
+<dt>	wxRectBorder.cc
+<dt>	wxScroll.cc
+<dt>	wxScrollArea.cc
+<dt>	wxScrollData.cc
+<dt>Unfinished Core
+<dt>	wx_group.cc
+<dt>	wx_mf.cc
+<dt>Printing
+<dt>	wx_print.cc
+<dt>	wx_dcpr1.cc
+<dt>	wx_dcpr2.cc
+<dt>	wx_dcpr3.cc
+<dt>wxExtend
+<dt>	exdc.cc
+<dt>	exdde.cc
+<dt>	extbar.cc
+<dt>	exutils.cc
+<dt>	exitems.cc
+<dt>	exmisc.cc
+<dt>	exgdi.cc
+<dt>	exwin.cc
+<dt>wxImage
+<dt>	wximgfil.cc
+<dt>	wx_image.cc
+<dt>	wx_xbm.cc
+<dt>	wx_bmp.cc
+<dt>libxpm
+<dt>	crbuffri.c
+<dt>	crdatfri.c
+<dt>	create.c
+<dt>	crifrbuf.c
+<dt>	crifrdat.c
+<dt>	data.c
+<dt>	hashtab.c
+<dt>	misc.c
+<dt>	parse.c
+<dt>	rdftodat.c
+<dt>	rdftoi.c
+<dt>	rgb.c
+<dt>	scan.c
+<dt>	simx.c
+<dt>	wrffrdat.c
+<dt>	wrffri.c</dl>Note: you don't really need the wxExtend unless you want to
+compile a Mac version of WxPython in which case you should contact me
+(ccoupe@simplot.com) to get the "latest" wxPython known to work with the Mac
+(version 3, FYI)
+<h3>
+<a name="RTFToC15">D.
+How the classes really interact (debugging point of view)
+</a></h3>
+The Macintosh platform derives dialogs from wxFrame class, while the other
+platforms derive dialogs from wxPanel class (however, the usage for dialogs
+should be the same). This is no long true since  release 'a4p2'.
+<h3>
+<a name="RTFToC16">E.
+Mac-specific classes, methods, techniques and constraints
+</a></h3>
+<h4>
+<a name="RTFToC17">1.
+Internally generated Mac Menu Id's start at 129
+</a></h4>
+128 is used for the Apple Menu, and that value is hard coded in some places
+(wx_menu.cc, wx_app.cc)
+<h4>
+<a name="RTFToC18">2.
+wxApp, CreateApp(), wx_main.cc, and your program. 
+</a></h4>
+There is a bug, exhibited in some wxWindows applications, that causes the the
+wxTheApp global to not get set.  This problem started with Symantec C++(6.x)
+and <i>shows</i> up in some applications compiled with Code Warrior 6.  There
+is a work-around (from Bill Hale) that involves changing your application code
+slightly:<p>
+You must define a class that is publicly derived from wxApp. You can name this
+derived class whatever you want. For the following, I will name it "MyApp". In
+this class, you must declare a public method which will override the pure
+virtual method "OnInit" that is declared in the  class wxApp. Then, at the
+minimum, we will have the following in a header file called "MyApp.h":
+
+<pre>
+	#include "wx_main.h"   // should really be called "wx_app.h"
+	class MyApp: public wxApp
+	{
+		public:
+			wxFrame* OnInit(void);
+	};
+</pre>
+
+<p>
+You must implement the publicly derived class of wxApp that you have just
+defined. At the minimum, we will have the following in a  source file called
+"MyApp.cc":
+
+<pre>
+	#include "MyApp.h"
+	wxFrame* MyApp::OnInit(void)
+	{
+		...
+		...
+		...
+	}
+
+</pre>
+You
+must finally declare and define a procedure "CreateApp" which the main program
+will call to create the object that you have derived from the class wxApp. You
+must use the name "CreateApp". It should be placed into the source file created
+in step B) above. The code that you need is as follows (where you should
+replace "MyApp" with the name of your derived class):
+
+<pre>
+	void CreateApp(void);
+	void CreateApp(void)
+	{
+		new MyApp;
+	}
+</pre>
+<p>
+As distributed, this workaround is not enabled. If you need it, in wx_main.cc,
+in the main() function is a line
+
+<pre>
+	// CreateApp();	// This procedure initializes the whole application
+</pre>
+Simply
+uncomment this, and apply the work around above to your application.
+<h4>
+<a name="RTFToC19">3.
+How do these "Areas" work? What are Margins?
+</a></h4>
+From: Bill Hale &lt;hale@mailhost.tcs.tulane.edu&gt;<p>
+The purpose of the wxArea objects is to allow a parent wxWindow object to have
+different origins for its children wxWindow objects.<p>
+A wxWindow object contains wxArea objects. These wxArea objects are nested.
+Each wxArea object has margin values (left, top, right, and bottom) which
+specify where the next wxArea object is situated. Each wxArea object contains
+wxWindow objects. These wxWindow objects are positioned within the wxArea by an
+offset value (X, Y). The wxArea object is clipped by the inner sibling wxArea
+objects (not coded yet). The child wxWindow objects are clipped by the parent
+wxArea object.<p>
+The width and height of a wxArea object is calculated from the width and height
+of its parent wxWindow and from the margins of the outer sibling wxAreas.<p>
+Example:
+
+<pre>
+                        width 200
+    ----------------------------------------------
+    |           area A             2              | wxWindow parent
+    |  |---------------------------------------|  |
+    |  |          area B          20           |  |
+    |  |                                       |  |
+    |2 |  |--------------------------------|   | 2|
+    |  |10|           area C               |16 |  | height 100
+    |  |  |                                |   |  |
+    |  |  |--------------------------------|   |  |
+    |  |                           5           |  |
+    |  |---------------------------------------|  |
+    |                              2              |
+    |---------------------------------------------|
+</pre>
+<p>
+Suppose the wxWindow parent has width 200 and height 100.<p>
+Suppose the area A has (l, t, r, b) = (2, 2, 2, 2).<p>
+Suppose the area B has (l, t, r, b) = (10, 20, 16, 5).<p>
+Let area C be the automatically generated client area, with (l, t, r, b) = (0,
+0, 0, 0).<p>
+Then, the width and height of area A is 200 and 100. The width and height of
+area B is 196 and 96. The width and height of area C is 170 and 71.<p>
+Children wxWindow objects of area A are positioned with respect to area A
+origin; children wxWindow objects of area B objects are positioned with respect
+to area B origin; and, likewise, for area C. In effect, these children wxWindow
+objects of the parent wxWindow have different origins within the wxWindow
+parent.<p>
+You can look at the code for wxText (best) and wxFrame for examples of creating
+areas for a wxWindow object in addition to the automatic client area.<p>
+So, wxWindows contain areas and pointers to areas. Some Areas contain pointers
+to wxWindows. Be aware that the order of destructors is somewhat confusing and
+problematical. 
+<h4>
+<a name="RTFToC20">4.
+The Magic 32k Limit
+</a></h4>
+<ul>
+<li>TextEdit
+<li>ListBoxes
+<li>MenuID's
+<li>Anything that scrolls (?)</ul>Matthew Flatt provided the wxMac changes
+neccesary to implement wxMedia which handles the scrolling limits at the
+wxWindows level:<p>
+Up until wxMedia, wxCanvas always managed the scrollbars for you. If your
+drawing extended far enough, the scroll bars kicked in, and scroll bar actions
+were automatically excuted on the drawing area.<p>
+Unfortunately, this doesn't work well enough for editing text documents. The
+first reason is that scroll steps need to be correlated with lines of text. The
+second reaosn is that the size of a text document can easily exceed the
+short-integer-based drawing areas of many platforms. <p>
+SetScrollbars is supposed to configure properties of the scrollbar that are
+used for automatic scrolling. It is also the way to turn scrollbars on or off.
+So, we added the extra Bool flag to SetScrollbars to turn the scrollbars on
+without turning on automatic management.<p>
+The new methods - SetScrollPos, SetScrollRange, etc. - were added to give
+direct control over the scrollbars. Why wasn't SetScrollbars sufficient? I
+don't remember.<p>
+Finally, OnScroll was added to allow manual handling of scrollbar events.<p>
+
+<h4>
+<a name="RTFToC21">5.
+The Apple Menu Hack.
+</a></h4>
+In wx_frame.cc, the Mac menubar is cleared and recreated through the wxWindows
+menu objects. <b>The wxWindows for Macintosh Apple Menu Extension</b> (AKA
+Apple Menu hack) is to:
+<ul>
+<li>Modify the global gMenuLdCnt to start at 129.
+<li>When (re)creating a menu bar, see if we have a menu 128. If not, create one
+with the special characteristics of an Apple menu (ie add 'DRVR' resources).
+<li>If possible, insert the "About" menu item. (See the "About Menu Hack")
+<li>In, wx_app.cc, doMacInMenuBar(), we check to see if Mac MenuID is 128 (i.e.
+the secret reseverved number that ResEdit defaults to when creating a new
+resource which is the only reason I chose 128). Anyway, if it's 128, item != 1,
+then we call OpenDeskACC(), and everything is right with the world. Of course,
+the "incoming" Mac Window--wxWindows Frame, has to have a menubar, otherwise
+there is no menubar shown (at all, for example the graphics canvas in
+hello.cc).</ul><h4>
+<a name="RTFToC22">6.
+The About Menu Item hack.
+</a></h4>
+This is a<b> true </b>hack. It is fragile. It has very specific requirements
+before it kicks in. If you do something close enought to trigger it,  you must
+provide the code it calls. <p>
+In simple terms, this hack detects that your program creates a "Help" menu with
+a wxMenuItem of "About" and that you added this menu to the menubar with
+something like: menubar-&gt;Append(help_menu, "Help"); Yes, this is not
+inter-nationalized, just English. <p>
+When wxMenuBar::Append sees this, it saves away the wxMenu ptr and the Mac Item
+Number. These are used in the wxApp::doMacInMenuBar() [wx_app.cc] to trigger
+whatever callback function you set up to handle Help/About.  I'm actually proud
+of this, but I know that <b>it is weak</b>. You can disable a couple of lines
+in wx_app.cc to remove its effects, although the additional memory lingers.
+<h4>
+<a name="RTFToC23">7.
+wxBitmap implementation
+</a></h4>
+The internal Mac object for a wxBitmap is  a Mac GWorld (and pixmap)"Picture".
+This makes for  easy and quick execution during Update events and for handling
+offscreen bitmaps (wxDCMEM). It is not the clearest of code however. Several
+people have helped me debug this. I also depend on implementing parts of the
+wxImage class (to handle GIF, XPM, XBM, and BMP). USE_XPM_IN_MAC can be toggled
+off in wx_setup.h if you do not need some of these formats. Most of the code is
+in wx_gdi.cc and wxImage.cc.
+<h4>
+<a name="RTFToC24">8.
+Mac Resources.
+</a></h4>
+In each of the sample directories, you should find a resource file to include
+into the project. There is an ALRT and DITL which are required for error
+messages. The 'MENU' resource is no longer used, but it doesn't hurt to keep
+it. There may be PICT resources which are used for bitmapped buttons. Anything
+else is left over from other tests and maybe deleted.
+<h4>
+<a name="RTFToC25">9.
+Memory Managment and PowerPC oddities
+</a></h4>
+The memory manager on PowerMacs is a little more sensitive to some errors. I
+compile and link with Code Warriors DebugNew routines because it helps track
+down some of these errors.  <p>
+If you really want to find leaks (and they are there), and if you have access
+to MPW's canon tool, you can replace calls to 'new' with calls to DebugNew's
+'NEW', set the appropropriate #define and recompile. You should do this on a
+copy of the project, because your doing a global search and replace and they
+can be troublesome to undo. See the CodeWarrior Doc for DebugNew (probably on
+the CD).<p>
+There is a library project, wxMac161 PPC (debug) that can be used for leak
+testing. It uses a different .pch file, 'wxDebugHeaders.pch) which builds the
+library and one of two precompiled headers, either 'wxDebugHeadersPPC' or
+'wxDebugHeaders68K'. Then in the project for  the application set
+preferences/C++ Language/prefix file: to be wxDebugHeadersPPC (or 68K). 12
+leaks is normal for minimal.cc and 25 leaks for hello.cc To help track drown
+other leaks I've included a file of patches to make to Metroworks DebugNew. See
+file DebugNew.patch and Hello.cc which has lots of code that trys force and or
+find leaks. Ugly but effective.
+<h4>
+<a name="RTFToC26">10.
+SetSize,  OnSize - OnClientAreaDSize.
+</a></h4>
+First off, OnSize() is only defined for wxFrame's and wxbWindow (in regular
+16.3 its also defined for wb_item). Since release 'a4p3',  you do not need a
+OnClientAreaDSize() in your <b>application</b>. Myframe::OnSize works fine. You
+app's OnSize will be called when wxApp::OnInit returns to the system. From then
+on it will only be called when the window is maximized/minimized, the growicon
+is dragged or your app calls SetSize() on the app's frame. In fact you do not
+want both OnSize() and OnClientAreaDSize() defined for your app's frames (if so
+they may both be called).<p>
+SetSize() for wxWindows and its subclasses is a little mysterious and has
+significant implications if you want to write or understand the controls
+(wxButtons, wxListBoxs ...) The only SetSize() you need is in wx_win.cc (for
+class wxWindow). wxItems (buttons, etc.) should <b>not</b> define this
+function!!! Instead a window or item needs to define an OnClientAreaDSize()
+method. It works like this - When an application like hello.cc calls SetSize(),
+the method in wxWindow is used (because no one overrides it).
+wxWindow::SetSize() ventures off into the wxArea's code and eventually the
+Window's or Item's OnClientAreaDSize() method is called. This is where the
+control (ie wxItem) needs to modify its position and size according to the
+semantics of wxMac and OnClientAreaDSize(). 
+<h4>
+<a name="RTFToC27">11.
+OnPaint and Paint - when to use
+</a></h4>
+OnPaint is defined for wxbWindow, wxWindow and wxPreviewCanvas (sort of) and is
+overridden as needed by your applications classes for canvas's. OnPaint() is
+called when wxMac wants your app to redraw the contents (ex.  in repsonse to
+the Mac's  Update event).<p>
+Paint() is a method of many classes. By default (wb_win.h,) Paint() calls
+OnPaint() so for the application developer, Paint() is just a way to trigger
+OnPaint().  Starting with the 'a5' release, there should not be any methods
+named Paint() either inside wxMac or your app either. Inside wxmac the various
+wxItems' OnPaint() methods depend upon being able to call wx_win.cc/OnPaint()
+and they do so with an explicit scope operation.
+<h4>
+<a name="RTFToC28">12.
+wxDirectorySelector() - New 
+</a></h4>
+This function is called like wxFileSelector, but instead of selecting files it
+allows the user to select a Directory (not unlike CodeWarriors
+Preferences-&gt;Path dialog). This function is also called from
+wxFileSelector() is the proper flag values are passed in (by default they are
+not). If I remember this is in wx_utils.cc. The code is not mine - proper
+accredidation is in the source code. This function also requires a DLOG and
+appropriate DITL's resources which had better be there when this is called. See
+xpmshow for and example of how this is used.<p>
+</body></html>
\ No newline at end of file
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.msw b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.msw
new file mode 100644
index 0000000..785134b
Binary files /dev/null and b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.msw differ
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.rtf b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.rtf
new file mode 100644
index 0000000..a59b58b
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/wxMac_Dev_Guide.rtf	
@@ -0,0 +1,337 @@
+{\rtf1\mac\deff2 {\fonttbl{\f0\fswiss Chicago;}{\f2\froman New York;}{\f3\fswiss Geneva;}{\f4\fmodern Monaco;}{\f13\fnil Zapf Dingbats;}{\f15\fnil Helvetica Narrow;}{\f16\fnil Palatino;}{\f18\fnil Zapf Chancery;}{\f20\froman Times;}{\f21\fswiss Helvetica;}
+{\f22\fmodern Courier;}{\f23\ftech Symbol;}{\f34\fnil New Century Schoolbook;}{\f128\fnil Bold Monaco;}{\f129\fnil West Monaco;}{\f256\fnil N Helvetica Narrow;}{\f2488\fnil AppleIconTwo;}{\f4788\fnil NewZurica;}{\f5466\fnil NewZuricaBold;}
+{\f5735\fnil MPW;}{\f8516\fnil NewZuricaOblique;}{\f12761\fnil Torino Outline;}{\f32525\fnil VT100;}}{\colortbl\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;
+\red255\green255\blue0;\red255\green255\blue255;}{\stylesheet{\s245\li360\sa120 \f20\fs18\up6 \sbasedon0\snext0 footnote reference;}{\s246\li360\sa120 \f20\fs20 \sbasedon0\snext246 footnote text;}{\s250\li360\sb120\sa120\keepn \b\f20\fs28 
+\sbasedon251\snext0 heading 6;}{\s251\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon252\snext0 heading 5;}{\s252\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon253\snext0 heading 4;}{\s253\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon254\snext0 heading 3;}{
+\s254\li180\sb120\sa120\keepn\brdrb\brdrs \b\f20\fs36 \sbasedon255\snext0 heading 2;}{\s255\li360\sb240\sa240\keepn\brdrb\brdrs \b\f20\fs48 \sbasedon0\snext0 heading 1;}{\li360\sa120 \f20 \sbasedon222\snext0 Normal;}{\s1\fi-540\li900\sa120\tx900 \f20 
+\sbasedon0\snext1 numbered list;}{\s2\fi-540\li1440\sa120\tx1440 \f20 \sbasedon0\snext2 numbered list 1;}{\s3\fi-540\li1980\sa120\tx1980 \f20 \sbasedon0\snext3 numbered list 2;}{\s4\fi-280\li900\sa120\tx900 \f20 \sbasedon1\snext4 bullet list;}{
+\s5\fi-280\li1440\sa120\tx1440 \f20 \sbasedon2\snext5 bullet list 1;}{\s6\fi-280\li1980\sa120\tx1980 \f20 \sbasedon3\snext6 bullet list 2;}{\s7\fi-3960\li4320\sa120\tx4320 \f20 \sbasedon0\snext7 glossary;}{\s8\fi-3960\li4860\sa120\tx4860 \f20 
+\sbasedon7\snext8 glossary 1;}{\s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \sbasedon0\snext9 pre;}{\s10\li360\sa120 \i\f20 \sbasedon0\snext10 address;}{\s11\li1440\ri1440\sa120 \i\f20 \sbasedon0\snext11 blockquote;}{
+\s12\sb120\sa120\brdrb\brdrth \f20 \sbasedon0\snext0 hr;}{\s13\fi360\tx360\tx3600\tx4320\tx7200\tx10700 \f20 \sbasedon0\snext13 dir;}{\s14\fi360\li360\tx720\tx3960\tx4320\tx7560\tx10700 \f20 \sbasedon0\snext14 dir 1;}{
+\s15\fi360\li720\tx1080\tx4320\tx7920\tx10700 \f20 \sbasedon0\snext15 dir 2;}{\s16\fi-720\li1440\tx1440 \f20 \sbasedon10\snext16 menu 1;}{\s17\fi-720\li1080\tx1080 \f20 \sbasedon16\snext17 menu;}{\s18\fi-720\li1800\tx1800 \f20 \sbasedon0\snext18 menu 2;}{
+\s19\fi-3960\li5400\sa120\tx5400 \f20 \sbasedon8\snext19 glossary 2;}{\s20\li360 \f22 \sbasedon0\snext20 HTML;}{\s21\li360\sa120 \f20 \sbasedon7\snext21 TERM;}{\s22\li900\sa120 \f20 \sbasedon7\snext22 DEF;}{\s23\fi-3960\li4860\sa120\tx4860 \f20 
+\sbasedon8\snext23 TERM 1;}{\s24\li1440\sa120 \f20 \sbasedon8\snext24 DEF 1;}{\s25\li1440\sa120 \f20 \sbasedon19\snext25 TERM 2;}{\s26\li1980\sa120 \f20 \sbasedon25\snext26 DEF 2;}}{\info{\title WxMac Development Guide}{\author Cecil Coupe}}
+\margl720\margr720\widowctrl\ftnbj\fracwidth \sectd \linemod0\cols1 \pard\plain \s11\li1440\ri1440\sa120 \i\f20 This file is the start of a wxMac Developers Guide.\par 
+\pard \s11\li1440\ri1440\sa120 Written by Cecil Coupe (ccoupe@simplot.com) with additions from Bill Hale and Tomaso Paoletti, and Matthew Flatt\par 
+\pard\plain \s254\li180\sb120\sa120\keepn\brdrb\brdrs \tx0 \b\f20\fs36 {\f3 I. Introduction\par 
+}\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 What is wxWindows and wxMac\par 
+\pard\plain \li360\sa120 \f20 wxWindows is a cross platform GUI development library with supporting applications and demos. wxMac is a port of wxWindows for the Macintosh.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Who is this document for?\par 
+\pard\plain \li360\sa120 \f20 Part II of this document will help you install and *use* wxWindows for the Macintosh. Part III and beyond are intended for alpha and beta testers and for those who want to add  to or fix the wxMac code\par 
+\pard\plain \s254\li180\sb120\sa120\keepn\brdrb\brdrs \tx0 \b\f20\fs36 {\f3 II. Installation\par 
+}\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Hardware and Software requirements\par 
+\pard\plain \li360\sa120 \f20 MacOS - System 7 or greater\par 
+Color QuickDraw\par 
+32 bit addressing - so you require a 68030/68040 or PowerPC.\par 
+Floating point hardware will help (probably a lot).\par 
+Enough memory for your C++ compiler to handle large programs.\par 
+\pard \li360\sa120 You will want 20MB of free space in order to run the sample applications, 40MB free would be easier to deal with.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Archives and compression\par 
+\pard\plain \li360\sa120 \f20 
+There are several methods for bundling up a directory tree into a single file and compressing that file to reduce its size. Depending on how and which distribution you got you may need additional helper programs to create a real Macintosh folder(s).\par 
+\pard \li360\sa120 1. If you are lucky, you downloaded a self extracting stuffit archive. Simply double click on the icon and StuffIt will ask where to put the Folders and files.\par 
+2. If you don't have the .sea or .sit versions of the distribution, but instead have a file ending in .tar.Z, .tar.gz, or .ZIP (or .zip), you need to acquire the following programs for your Macintosh:\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 MacGzip from ....\par 
+Suntar(2.0.2) from ....\par 
+\pard\plain \li360\sa120 \f20 Also note, that tar may not preserve some of the Mac special characters, in particular the 'pi' character is the Option-p keys, and needs to be placed
+ in project files. Parentheses are replaced with '+', which is only really a problem for Symantec.\par 
+\pard \li360\sa120 3. If you don't understand both steps 1 and 2, (and even if you don't need #2) you will have a extremely steep learning curve ahead of you. I'm sorry,  but that is how it is in the cross platform world.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Chose your compiler/environment\par 
+\pard\plain \li360\sa120 \f20 {\b Note}: Symantec Projects and MPW makefiles are out of date. CodeWarrior is the only supported compilers.\par 
+\pard \li360\sa120 By now you've untarred/unzipped/unstuffed the archive, you might have read
+ the README files, and you've already tried to build the system with CodeWarrior or Think-C++. MPW aficionados just modified the Makefile and tried it. You probably wouldn't be reading this unless you had a problem. Lets try it again, from the archive/zip/
+tar file (you did make a copy, right).\par 
+\pard \li360\sa120 You should decide whether you want to use MPW, CodeWarrior, or ThinkC++. They can all coexist in the same set of folders, but life will be so much better and easier if you chose one now and stick with it throughout yo
+ur wxWindows exploration.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Structure of distribution directories\par 
+\pard\plain \li360\sa120 \f20 
+There will be a lot of directories/folders and files. The ones you want to deal with  are "samples", "src" and "include" in the top-level directory, plus the project files and/or Makefile and hopefully the README's and Documentation. IGNORE the others. You
+'ll have plenty of time later after you get a decent install.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Compiling a wxWindows program with Metrowerks C++ (v7)\par 
+\pard\plain \li360\sa120 \f20 The wxWindows library (used by all samples and any programs you write) has to be built first. In the top level directory, along with the 'src' and "include" directories should be a wxMac161-PPC.\'b9 or wxMac161-68K\'b9
+ project. Double click, select Make from the "Project" menu and cross your fingers. CodeWarrior may complain that some 
+path's are not available, typically this is the path to wherever you installed Codewarrior. This error message is corrected by setting the project preferences (Edit->Preferences->Paths) to your CW installation Folder.\par 
+\pard \li360\sa120 For 68k compilation, you must make sur
+e that the library and all applications are compiled with the same prefs settings. As distributed, the projects build for 4 byte ints, 8 byte doubles, and no floating pt HW (that is 4i/8d). If you wish to change this you will also have to add the appropria
+te libraries into the project in place of the 4i/8d's that are there.\par 
+\pard \li360\sa120 If all works well (no fatal compile errors) you can try the sample programs located in the "samples" directories. Drill down into samples:hello. Loaded it - I happen to like using the Fi
+nder to open the :samples:hello: folder and double clicking on the hello.ppc.\'b9. \par 
+\pard \li360\sa120 Although, the 'minimal' program is even simpler than 'hello', if hello doesn't run for you, well its a long and winding road...\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Compiling a wxWindows program with Symantec C++  or MPW\par 
+\pard\plain \li360\sa120 \f20 
+Symantec and MPW is no longer supported with the alpha-4 snapshot. I'm not saying that you couldn't make it work, only that I no longer care to spend the copious amounts of time watching MPW compile. Its large enough under CodeWarrior as it is!\par 
+\pard\plain \s254\li180\sb120\sa120\keepn\brdrb\brdrs \tx0 \b\f20\fs36 {\f3 III. WxMac Internals\par 
+}\pard\plain \li360\sa120 \f20 Aside from curiosity, there are only three reasons to be reading this section of the document:\par 
+\pard\plain \s5\fi-280\li1440\sa120\tx1440 \f20 Your compiler coughed, rolled over and died on something. \par 
+The test programs died, probably taking the MacOS with it. \par 
+You like what you see and want to help it grow.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 A. Philosophy and Goals of the wxMac Project [and participants]\par 
+\pard\plain \li360\sa120 \f20 The first developer and instigator of the Macintosh port was Bill Hale who wanted to learn C++ by porting a "major" piece of code. The second to join was Tomaso Paolet
+ti  who wanted (?) The third was Cecil Coupe who just wanted a cross-platform GUI for the python language and got sucked into the effort. Bill created the Mac specific part of Julian Smarts (jacs@aiai.ed.ac.uk)  wxWindows.\par 
+\pard \li360\sa120 Louis Birk, Matthew Flatt, Scott Maxwell and Greg Whitehead joined the project, each with real applications that they wanted to port. Each contributed serious development effort for wxMac.\par 
+Given the different perspectives it should be no  surprise that there are different stylistic tactics taken in various wxMac modules. So be it, We offer no apologies.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 {\f3 B. Necessary [useful] skills and reference material\par 
+}\pard\plain \li360\sa120 \f20 See the wxMac_Status document. The bug you found may be known. Also, sometimes the wxWindows documentation differs from the actual implementation.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 {\f3 C. How the classes are laid out (file/project point of view)\par 
+}\pard\plain \li360\sa120 \f20 Here is the list of .c and .cc files needed. This could be used to determine which files to load into another development environment.\par 
+\pard\plain \s21\li360\sa120 \f20 Project Name: "Prog:wxmac161d-a4:wxMac161-PPC."\par 
+Precompiled Headers\par 
+\tab wxGWin.pch\par 
+Base\par 
+\tab DebugNew.cp\par 
+\tab wb_dc.cc\par 
+\tab wb_data.cc\par 
+\tab wb_canvs.cc\par 
+\tab wb_dialg.cc\par 
+\tab wb_gdi.cc\par 
+\tab wb_frame.cc\par 
+\tab wb_hash.cc\par 
+\tab wb_help.cc\par 
+\tab wb_ipc.cc\par 
+\tab wb_item.cc\par 
+\tab wb_list.cc\par 
+\tab wb_main.cc\par 
+\tab wb_mgstr.cc\par 
+\tab wb_obj.cc\par 
+\tab wb_panel.cc\par 
+\tab wb_ps.cc\par 
+\tab wb_mf.cc\par 
+\tab wb_stdev.cc\par 
+\tab wb_sysev.cc\par 
+\tab wb_text.cc\par 
+\tab wb_timer.cc\par 
+\tab wb_types.cc\par 
+\tab wb_utils.cc\par 
+\tab wb_win.cc\par 
+\tab wxstring.cc\par 
+\tab xfspline.cc\par 
+Mac Core\par 
+\tab wx_app.cc\par 
+\tab wx_area.cc\par 
+\tab wx_buttn.cc\par 
+\tab wx_canvs.cc\par 
+\tab wx_check.cc\par 
+\tab wx_choic.cc\par 
+\tab wx_clipb.cc\par 
+\tab wx_dc.cc\par 
+\tab wx_dccan1.cc\par 
+\tab wx_dccan2.cc\par 
+\tab wx_dccan3.cc\par 
+\tab wx_dcmem.cc\par 
+\tab wx_dialg.cc\par 
+\tab wx_frame.cc\par 
+\tab wx_gdi.cc\par 
+\tab wx_ipc.cc\par 
+\tab wx_item.cc\par 
+\tab wx_main.cc\par 
+\tab wx_lbox.cc\par 
+\tab wx_menu.cc\par 
+\tab wx_messg.cc\par 
+\tab wx_mnuit.cc\par 
+\tab wx_mtxt.cc\par 
+\tab wx_panel.cc\par 
+\tab wx_rbox.cc\par 
+\tab wx_rbut.cc\par 
+\tab wx_sbar.cc\par 
+\tab wx_screen.cc\par 
+\tab wx_slidr.cc\par 
+\tab wx_text.cc\par 
+\tab wx_timer.cc\par 
+\tab wx_txt.cc\par 
+\tab wx_util.cc\par 
+\tab wx_win.cc\par 
+Mac Helpers\par 
+\tab wxBorder.cc\par 
+\tab wx_comparestrings.c\par 
+\tab wx_mac_utils.cc\par 
+\tab wxBorderArea.cc\par 
+\tab wxGetTxt.cc\par 
+\tab wxLabelArea.cc\par 
+\tab wxMacDC.cc\par 
+\tab wxMacObj.cc\par 
+\tab wxMacPPC.c\par 
+\tab wxMargin.cc\par 
+\tab wxButtonBorder.cc\par 
+\tab wxRectBorder.cc\par 
+\tab wxScroll.cc\par 
+\tab wxScrollArea.cc\par 
+\tab wxScrollData.cc\par 
+Unfinished Core\par 
+\tab wx_group.cc\par 
+\tab wx_mf.cc\par 
+Printing\par 
+\tab wx_print.cc\par 
+\tab wx_dcpr1.cc\par 
+\tab wx_dcpr2.cc\par 
+\tab wx_dcpr3.cc\par 
+wxExtend\par 
+\tab exdc.cc\par 
+\tab exdde.cc\par 
+\tab extbar.cc\par 
+\tab exutils.cc\par 
+\tab exitems.cc\par 
+\tab exmisc.cc\par 
+\tab exgdi.cc\par 
+\tab exwin.cc\par 
+wxImage\par 
+\tab wximgfil.cc\par 
+\tab wx_image.cc\par 
+\tab wx_xbm.cc\par 
+\tab wx_bmp.cc\par 
+libxpm\par 
+\tab crbuffri.c\par 
+\tab crdatfri.c\par 
+\tab create.c\par 
+\tab crifrbuf.c\par 
+\tab crifrdat.c\par 
+\tab data.c\par 
+\tab hashtab.c\par 
+\tab misc.c\par 
+\tab parse.c\par 
+\tab rdftodat.c\par 
+\tab rdftoi.c\par 
+\tab rgb.c\par 
+\tab scan.c\par 
+\tab simx.c\par 
+\tab wrffrdat.c\par 
+\tab wrffri.c\par 
+\pard\plain \li360\sa120 \f20 Note: you don't really need the wxExtend unless you want to compile a Mac version of WxPython in which case you should contact me (ccoupe@simplot.com) to get the "latest" wxPython known to work with the Mac (version 3, FYI)
+\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 {\f3 D. How the classes really interact (debugging point of view)\par 
+}\pard\plain \li360\sa120 \f20 The Macintosh platform derives dialogs from wxFrame class, while the other platforms derive dialogs from wxPanel class (however, the usage for dialogs should be the same). This is no long true since  release 'a4p2'.\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 {\f3 E. Mac-specific classes, methods, techniques and constraints\par 
+}\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 1. Internally generated Mac Menu Id's start at 129\par 
+\pard\plain \li360\sa120 \f20 128 is used for the Apple Menu, and that value is hard coded in some places (wx_menu.cc, wx_app.cc)\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 2. wxApp, CreateApp(), wx_main.cc, and your program. \par 
+\pard\plain \li360\sa120 \f20 There is a bug, exhibited in some wxWindows applications, that causes the the wxTheApp global to not get set.  This problem started with Symantec C++(6.x) and {\i shows}
+ up in some applications compiled with Code Warrior 6.  There is a work-around (from Bill Hale) that involves changing your application code slightly:\par 
+\pard \li360\sa120 You must define a class t
+hat is publicly derived from wxApp. You can name this derived class whatever you want. For the following, I will name it "MyApp". In this class, you must declare a public method which will override the pure virtual method "OnInit" that is declared in the  
+class wxApp. Then, at the minimum, we will have the following in a header file called "MyApp.h":\par 
+\pard\plain \s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \tab #include "wx_main.h"   // should really be called "wx_app.h"\par 
+\tab class MyApp: public wxApp\par 
+\tab \{\par 
+\tab \tab public:\par 
+\tab \tab \tab wxFrame* OnInit(void);\par 
+\tab \};\par 
+\pard\plain \li360\sa120 \f20 \tab \par 
+\pard \li360\sa120 You must implement the publicly derived class of wxApp that you have just defined. At the minimum, we will have the following in a  source file called "MyApp.cc":\par 
+\pard\plain \s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \tab #include "MyApp.h"\par 
+\tab wxFrame* MyApp::OnInit(void)\par 
+\tab \{\par 
+\tab \tab ...\par 
+\tab \tab ...\par 
+\tab \tab ...\par 
+\tab \}\par 
+\par 
+\pard\plain \li360\sa120 \f20 
+You must finally declare and define a procedure "CreateApp" which the main program will call to create the object that you have derived from the class wxApp. You must use the name "CreateApp". It should be placed into the source file created in step B) abo
+ve. The code that you need is as follows (where you should replace "MyApp" with the name of your derived class):\par 
+\pard\plain \s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \tab void CreateApp(void);\par 
+\tab void CreateApp(void)\par 
+\tab \{\par 
+\tab \tab new MyApp;\par 
+\tab \}\par 
+\pard\plain \li360\sa120 \f20 \par 
+As distributed, this workaround is not enabled. If you need it, in wx_main.cc, in the main() function is a line\par 
+\pard\plain \s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \tab // CreateApp();\tab // This procedure initializes the whole application\par 
+\pard\plain \li360\sa120 \f20 Simply uncomment this, and apply the work around above to your application.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 3. How do these "Areas" work? What are Margins?\par 
+\pard\plain \li360\sa120 \f20 From: Bill Hale <hale@mailhost.tcs.tulane.edu>\par 
+\pard \li360\sa120 The purpose of the wxArea objects is to allow a parent wxWindow object to have different origins for its children wxWindow objects.\par 
+\pard \li360\sa120 
+A wxWindow object contains wxArea objects. These wxArea objects are nested. Each wxArea object has margin values (left, top, right, and bottom) which specify where the next wxArea object is situated. Each wxArea object contains wxWindow objects. These wxWi
+ndow objects are positioned within the wxArea by an offset value (X, Y). The wxArea object is clipped by the inner sibling wxArea objects (not coded yet). The child wxWindow objects are clipped by the parent wxArea object.\par 
+\pard \li360\sa120 The width and height of a wxArea object is calculated from the width and height of its parent wxWindow and from the margins of the outer sibling wxAreas.\par 
+\pard \li360\sa120 Example:\par 
+\pard\plain \s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20                         width 200\par 
+    ----------------------------------------------\par 
+    |           area A             2              | wxWindow parent\par 
+    |  |---------------------------------------|  |\par 
+    |  |          area B          20           |  |\par 
+    |  |                                       |  |\par 
+    |2 |  |--------------------------------|   | 2|\par 
+    |  |10|           area C               |16 |  | height 100\par 
+    |  |  |                                |   |  |\par 
+    |  |  |--------------------------------|   |  |\par 
+    |  |                           5           |  |\par 
+    |  |---------------------------------------|  |\par 
+    |                              2              |\par 
+    |---------------------------------------------|\par 
+\pard\plain \li360\sa120 \f20 \par 
+Suppose the wxWindow parent has width 200 and height 100.\par 
+Suppose the area A has (l, t, r, b) = (2, 2, 2, 2).\par 
+Suppose the area B has (l, t, r, b) = (10, 20, 16, 5).\par 
+Let area C be the automatically generated client area, with (l, t, r, b) = (0, 0, 0, 0).\par 
+\pard \li360\sa120 Then, the width and height of area A is 200 and 100. The width and height of area B is 196 and 96. The width and height of area C is 170 and 71.\par 
+\pard \li360\sa120 Children wxWindow objects of area A are positioned with respect to area A origin; children wxWindow objects of area B objects are positioned with respect to area B
+ origin; and, likewise, for area C. In effect, these children wxWindow objects of the parent wxWindow have different origins within the wxWindow parent.\par 
+\pard \li360\sa120 You can look at the code for wxText (best) and wxFrame for examples of creating areas for a wxWindow object in addition to the automatic client area.\par 
+So, wxWindows contain areas and pointers to areas. Some Areas contain pointers to wxWindows. Be aware that the order of destructors is somewhat confusing and problematical. \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 4. The Magic 32k Limit\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 TextEdit\par 
+ListBoxes\par 
+MenuID's\par 
+Anything that scrolls (?)\par 
+\pard\plain \li360\sa120 \f20 Matthew Flatt provided the wxMac changes neccesary to implement wxMedia which handles the scrolling limits at the wxWindows level:\par 
+Up until wxMedia, wxCanvas always managed the scrollbars for you. If your drawing extended far enough, the scroll bars kicked in, and scroll bar actions were automatically excuted on the drawing area.\par 
+\pard \li360\sa120 Unfortunately, this doesn't work well enough for editing text documents. The first reason is that scroll steps need to be correlated with 
+lines of text. The second reaosn is that the size of a text document can easily exceed the short-integer-based drawing areas of many platforms. \par 
+
+SetScrollbars is supposed to configure properties of the scrollbar that are used for automatic scrolling. It is also the way to turn scrollbars on or off. So, we added the extra Bool flag to SetScrollbars to turn the scrollbars on without turning on automa
+tic management.\par 
+\pard \li360\sa120 The new methods - SetScrollPos, SetScrollRange, etc. - were added to give direct control over the scrollbars. Why wasn't SetScrollbars sufficient? I don't remember.\par 
+\pard \li360\sa120 Finally, OnScroll was added to allow manual handling of scrollbar events.\par 
+\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 5. The Apple Menu Hack.\par 
+\pard\plain \li360\sa120 \f20 In wx_frame.cc, the Mac menubar is cleared and recreated through the wxWindows menu objects. {\b The wxWindows for Macintosh Apple Menu Extension} (AKA Apple Menu hack) is to:\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 Modify the global gMenuLdCnt to start at 129.\par 
+\pard \s4\fi-280\li900\sa120\tx900 When (re)creating a menu bar, see if we have a menu 128. If not, create one with the special characteristics of an Apple menu (ie add 'DRVR' resources).\par 
+\pard \s4\fi-280\li900\sa120\tx900 If possible, insert the "About" menu item. (See the "About Menu Hack")\par 
+\pard \s4\fi-280\li900\sa120\tx900 
+In, wx_app.cc, doMacInMenuBar(), we check to see if Mac MenuID is 128 (i.e. the secret reseverved number that ResEdit defaults to when creating a new resource which is the only reason I chose 128). Anyway, if it's 128, item != 1,  then we call OpenDeskACC(
+), and everything is right with the world. Of course, the "incoming" Mac Window--wxWindows Frame, has to have a menubar, otherwise there is no menubar shown (at all, for example the graphics canvas in hello.cc).\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 6. The About Menu Item hack.\par 
+\pard\plain \li360\sa120 \f20 This is a{\b  true }hack. It is fragile. It has very specific requirements before it kicks in. If you do something close enought to trigger it,  you must provide the code it calls. \par 
+\pard \li360\sa120 
+In simple terms, this hack detects that your program creates a "Help" menu with a wxMenuItem of "About" and that you added this menu to the menubar with something like: menubar->Append(help_menu, "Help"); Yes, this is not inter-nationalized, just Engli
+sh. \par 
+\pard \li360\sa120 
+When wxMenuBar::Append sees this, it saves away the wxMenu ptr and the Mac Item Number. These are used in the wxApp::doMacInMenuBar() [wx_app.cc] to trigger whatever callback function you set up to handle Help/About.  I'm actually proud of this, but I know
+ that {\b it is weak}. You can disable a couple of lines in wx_app.cc to remove its effects, although the additional memory lingers.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 7. wxBitmap implementation\par 
+\pard\plain \li360\sa120 \f20 The internal Mac object for a wxBitmap is  a Mac GWorld (and pixmap)"Picture". This makes for  e
+asy and quick execution during Update events and for handling offscreen bitmaps (wxDCMEM). It is not the clearest of code however. Several people have helped me debug this. I also depend on implementing parts of the wxImage class (to handle GIF, XPM, XBM, 
+and BMP). USE_XPM_IN_MAC can be toggled off in wx_setup.h if you do not need some of these formats. Most of the code is in wx_gdi.cc and wxImage.cc.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8. Mac Resources.\par 
+\pard\plain \li360\sa120 \f20 In each of the sample directories, you should find a resource file to include into the pr
+oject. There is an ALRT and DITL which are required for error messages. The 'MENU' resource is no longer used, but it doesn't hurt to keep it. There may be PICT resources which are used for bitmapped buttons. Anything else is left over from other tests and
+ maybe deleted.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 9. Memory Managment and PowerPC oddities\par 
+\pard\plain \li360\sa120 \f20 The memory manager on PowerMacs is a little more sensitive to some errors. I compile and link with Code Warriors DebugNew routines because it helps track down some of these errors.  \par 
+\pard \li360\sa120 If you really wa
+nt to find leaks (and they are there), and if you have access to MPW's canon tool, you can replace calls to 'new' with calls to DebugNew's 'NEW', set the appropropriate #define and recompile. You should do this on a copy of the project, because your doing 
+a global search and replace and they can be troublesome to undo. See the CodeWarrior Doc for DebugNew (probably on the CD).\par 
+\pard \li360\sa120 There is a library project, wxMac161 PPC (debug) that can be used for leak testing. It uses a different .pch file, 'wxDebugHeaders.p
+ch) which builds the library and one of two precompiled headers, either 'wxDebugHeadersPPC' or 'wxDebugHeaders68K'. Then in the project for  the application set preferences/C++ Language/prefix file: to be wxDebugHeadersPPC (or 68K). 12 leaks is normal for 
+minimal.cc and 25 leaks for hello.cc To help track drown other leaks I've included a file of patches to make to Metroworks DebugNew. See file DebugNew.patch and Hello.cc which has lots of code that trys force and or find leaks. Ugly but effective.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 10. SetSize,  OnSize - OnClientAreaDSize.\par 
+\pard\plain \li360\sa120 \f20 First off, OnSize() is only defined for wxFrame's and wxbWindow (in regular 16.3 its also defined for wb_item). Since release 'a4p3',  you do not need a OnClientAreaDSize() in your {\b application}
+. Myframe::OnSize works fine. You app's OnSize will be called when wxApp::OnInit returns to the system. From then on it will only be called when the window is maximized/minimized, the growicon is dragged or your app calls SetSize() on the app's frame. In f
+act you do not want both OnSize() and OnClientAreaDSize() defined for your app's frames (if so they may both be called).\par 
+\pard \li360\sa120 
+SetSize() for wxWindows and its subclasses is a little mysterious and has significant implications if you want to write or understand the controls (wxButtons, wxListBoxs ...) The only SetSize() you need is in wx_win.cc (for class wxWindow). wxItems (button
+s, etc.) should {\b not} define this function!!! Instead a window or item needs to define an OnClientAreaDSize() method. It works like this - When an application like hel
+lo.cc calls SetSize(), the method in wxWindow is used (because no one overrides it).  wxWindow::SetSize() ventures off into the wxArea's code and eventually the Window's or Item's OnClientAreaDSize() method is called. This is where the control (ie wxItem) 
+needs to modify its position and size according to the semantics of wxMac and OnClientAreaDSize(). \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11. OnPaint and Paint - when to use\par 
+\pard\plain \li360\sa120 \f20 OnPaint is defined for wxbWindow, wxWindow and wxPreviewCanvas (sort of) and is overridden as needed by your application
+s classes for canvas's. OnPaint() is called when wxMac wants your app to redraw the contents (ex.  in repsonse to the Mac's  Update event).\par 
+\pard \li360\sa120 
+Paint() is a method of many classes. By default (wb_win.h,) Paint() calls OnPaint() so for the application developer, Paint() is just a way to trigger OnPaint().  Starting with the 'a5' release, there should not be any methods named Paint() either inside w
+xMac or your app either. Inside wxmac the various wxItems' OnPaint() methods depend upon being able to call wx_win.cc/OnPaint() and they do so with an explicit scope operation.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 12. wxDirectorySelector() - New \par 
+\pard\plain \li360\sa120 \f20 This function is called like wxFileSelector, but instead of selecting files it allows the user to select a Directory (not unlike CodeWarriors Preferences->Path dialog). Th
+is function is also called from wxFileSelector() is the proper flag values are passed in (by default they are not). If I remember this is in wx_utils.cc. The code is not mine - proper accredidation is in the source code. This f
+unction also requires a DLOG and appropriate DITL's resources which had better be there when this is called. See xpmshow for and example of how this is used.\par 
+}
\ No newline at end of file
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Status.html b/src/wxmac/docs/wxmac doc/wxMac_Status.html
new file mode 100644
index 0000000..4364e17
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/wxMac_Status.html	
@@ -0,0 +1,448 @@
+<html><head><!-- This document was created from RTF source by rtftohtml version
+2.7.5 --><title>wxMac Status</title></head><body><h3>
+<a name="RTFToC1">Known
+Bugs and Problems
+</a></h3>
+4. Merged Tomaso's wb_ps.cc with 16.1 distribution wb_ps.cc. MW's DebugNew
+crashes to MacsBug because it found a overwritten block when doing the
+hello/file/print eps. This doesn't happen in all combinations of PPC, 68K, and
+Debugging!<p>
+11.  Things that 16.1 does that wxMac doesn't like (some of these may be new
+functionality since the base 15.x version) :
+<ul>
+<li>	The Get/SetLabel compiler warnings are very annoying.  wx_menu.h seems to
+be a major offender.
+<li>	In wx_text the following methods may have not been fully debugged:<ul>
+<li>	SetSelection
+<li>	Copy
+<li>	Paste
+<li>	Cut</ul></ul>12.  Why can't an app declare a variable called 'frame' like
+most of the distributed sample/test apps do.  - Because frame is declared in an
+apple header, Quickdraw.h<p>
+14. Need a better  scheme for preprocessor symbols Beware: Apple's
+&lt;Windows.h&gt; defines __WINDOWS__<p>
+18. Need real code for these classes: group, toolbar, mf.<p>
+20. Need additional Cursors<p>
+21. Hello.cc creates a popupmenu - how/where does this show up on a real
+wxWindows system and how should the mac do it?<p>
+23. Resources - how to implement ?<p>
+24. Dig into dynamically tracking the thumb in wx_slider.cc. There's code in
+there to try it but it doesn't work. <p>
+25. There is a problem with hello.cc - MyTextWindow can cover parts of the last
+control. Hello should be rewritten so that the TextWindow is not 1/2 of the
+root frame but instead start after the last control. The same problem shows up
+in animate.cc where the sliders panel covers part of the frames statusline.
+This is not a Mac bug per-se - its a consequence of the size of Mac controls,
+Mac screen size and application programming that assumes every thing will fit
+in 1/2 the window.<p>
+26. Maybe StatusLine widget should go on the bottom of a frame with room for a
+GrowIcon and a small horizontal scroll if needed<p>
+28. What I implemented for wxChoice is really a wxWindows PopUpMenu(). This may
+be a problem. Is a wxChoice a keyboard enterable control or are the selections
+fixed (by the program)?<p>
+40. For 'ipc' samples compiled and run on a PowerPC - the 'client's PPC Browser
+windows shows that "server" and "server PPC" are available targets. If you
+select just plain  "server" everything works ok. Usually. May have to compile
+client and server and library with wxDebugHeadersPPC (...68K) to get these to
+work.<p>
+43. Scan for #if 0 , #if 1 code , #ifndef CJC  and other bracketed out code -
+should be removed. <p>
+44. Multiline text doesn't work for me (Cecil)
+<h3>
+<a name="RTFToC2">Completed
+(plus notes)
+</a></h3>
+<h4>
+<a name="RTFToC3">7/9/95</a></h4>
+Have a wxListBox (wx_lbox.h, wx_lbox.cc) see the top of the file for hints on
+writing controls in wxMac. Still to do
+<ul>
+<li>How to set the font for the Lbox?
+<li>Make the cell size a multiple of the font height</ul><h4>
+<a name="RTFToC4">7/22/95
+</a></h4>
+Have a wxChoice - may not respond to OnAreaDSize in the best way. Built w/o
+areas, just Mac ToolBox calls.<p>
+Added wxMultiText::GetValue(void) hack<p>
+Added wxRemoveFile and wxGetTempFileName - these are hacks in :mac:wx_utils.c<p>
+wxPython (v01) Links,  but fails on init with a python error. WxPython sources
+must have the same Code Warrior Language Prefs as the PythonLib, i.e.  Apple
+C++ <i>and</i> don't check prototypes.
+<h4>
+<a name="RTFToC5">7/29/95</a></h4>
+Have a wxSlider - works with the following caveats:
+<ul>
+<li>The usable range is the Mac Control Managers (short int 32k?)
+<li>Does not dynamically track the thumb value - see comments in wxSlider.cc
+<li>#define USE_ACTIONPROC  1 -  can crash the Mac</ul><h4>
+<a name="RTFToC6">7/30/95</a></h4>
+Fixed wx_frame.cc (SetMenuBar)and wx_app.cc (doInMacMenu) to create and handle
+the Apple menu (and desk accessories)
+<h4>
+<a name="RTFToC7">8/6/95</a></h4>
+Fixed wx_menu.cc so that the Title of a Mac Menu can be changed. This involves
+rebuilding the entire Mac Menu and all its items but does allow
+menu_bar-&gt;Append(menu,"Real Title for menu"); which is how most wxWindows
+Programs create menus and menubars. This is also done for wxMenu::SetTitle.<p>
+If a menubar-&gt;Append(menu, "Help") is done and one of the Items in the menu
+is "About", then I save the wxMenu* and the MacItemNum in the menu_bar object.
+When the menu_bar is created (see the applemenu hack) I insert an "About"
+string into the apple menu. If chosen by the user, wx_app.cc notes that its
+applemenu/item 1 and pretends its the Help/About choice. Definately a Hack and
+probably not robust. The wxMenu destructor should deactivate this if the Help
+menu is deleted.
+<h4>
+<a name="RTFToC8">8/7/95</a></h4>
+Added code to wx_buttn.cc and wx_gdi.cc for Bitmap buttons. This is good enough
+for Hello.cc but there is more to be done so that my scheme is usable in
+wxMemoryDC (including fixing/adding code to various DC's). <p>
+With wxMac you can load either named PICT resources or PICT files (pict in the
+data fork), into a wxBitmap. The internal Mac object for a wxBitmap is
+"Picture". Given the wxWindows definition of a bitmap, this *seems* like an ok
+choice because Pictures are relatively independent of bit depth (I believe).
+They might be larger than PixMaps for some images, but they are easy to deal
+with. There are comments in wx_gdi.cc, but its pretty straight-forward. (I said
+they were easy).
+<h4>
+<a name="RTFToC9">8/8/95</a></h4>
+19. with PPCC compiler, linking hello gets a c2pstr undefined - because there
+doesn't seem to be an MPW library with that function. However there is a
+C2PStr, so all the files that need it now call for the mixed case.<p>
+20. PPCC gets very annoying, spitting out warnings about inherited virtual
+functions that is not over-ridden. Fixed the major offenders, not by deep
+thought which what is really required. Instead I just tried a few things.
+CodeWariour  seems to like them as well. This may have some part in the Hello
+(MPW PPPC) bug though.<p>
+21. Hello.cc works with both 68K and PPC Code Warrior compilers. Hello,
+minimal, fractal, and ipc(client &amp; server) have PPC projects. Only Hello
+has a 68k project, but its pretty simple to make 68K projects (4i/8d) out of
+the existing PPC projects.<p>
+
+<h4>
+<a name="RTFToC10">8/9/95</a></h4>
+Released alpha-1 (wxmac161d-a1) to limited group.<p>
+
+<h4>
+<a name="RTFToC11">8/10/95</a></h4>
+31. MPW PPCC version of hello doesn't have working push buttons ! (it used to).
+- left out an<p>
+assignment from ::TrackControl. Depending on stack contents, this might have
+worked (or not) with the other compilers.<p>
+This time, with thought, I got rid of the GetLabel and SetLabel warnings.
+Should not change functionality.<p>
+Re-released 'a1'.  <p>
+Starting the alpha-2 modifications which are directed towards getting the
+source cleaned up and documenting (if not fixing) missing canvas, and DC
+functions.
+<h4>
+<a name="RTFToC12">8/12/95</a></h4>
+13. Scan files for "CJC", "wx_mac", "OLD_HEADERS" - and review modifcations. <p>
+I have made serious cuts and restructuring of the :include:base: files (and
+:src:base:, :src:mac: as needed) to remove most of the passing of 'objectType'
+to<i> wxb* </i>constructors . This was done to bring the wxMac modifications to
+the wb_xxx.* files down to something more reasonable.  More can still be done,
+but this isn't too bad. This also involved moving some lines around to keep the
+style of the wb_xxx files more like the style of the original wxWindows files.
+This does involve code changes to constructors, so beware: It works for me
+(hello.cc, minimal.cc, fractal.cc,animate.cc (CodeWarrior)).<p>
+You can scan for "CJC' and only pickup a few (3) comments. I removed the
+OLD_HEADERS conditionals. You can scan for "wx_mac" as a "word" and (generally
+) only pick up modifications to wb_xxx files.
+<h4>
+<a name="RTFToC13">8/25/95</a></h4>
+In Summary, we now have wxMemoryDC and wxTimer classes working. It is probably
+time to release Alpha-2 Note that PPCC from ETO #17 works, and the new (ETO
+#18) MrCpp fails.<p>
+27. There are functions that appear to do nothing in wx_dccan*, wx_dcmem -
+Started on Blit(). Seems to work with the animate.cc sample, but I need a
+wxTimer that works before we can scratch animate off of the list of todo's. <p>
+2. Now have a somwhat kludgy timer class (good enough for hello.cc and
+animate.cc). It can only "fire" when the event loop is dequeueing events and
+accuracy is in CLOCKS_PER_SEC (ie Ticks) instead of milliseconds (probable
+rounding errors too!) Latency can be highly variable. <p>
+Reworked wxBitmaps to be offscreen GWorlds (wx_gdi.cc, and wx_dcmem.cc) I'm not
+overly confident in the destructor code though.  <p>
+34. Canvas's can not be placed on a frame with (abs) co-ordinates. I've
+implemented a "cure" for this in wx_dccan1.cc(wxCanvasDC::SetMacDC() ). It
+seems to work for animate and hello demos but I believe this could break other
+things (canvas's place in subframes of frames, or canvas's in panels in
+frames).<p>
+Released Alpha-2.
+<h4>
+<a name="RTFToC14">9/10/95</a></h4>
+Started playing again with wxpython (v1), wxMac161d, and python-1.2. Works
+better if the System Folder has a PythonStartup file (I didn't install python
+properly)<p>
+22. With wxPython/wxide.cc, wxTheApp does not get init'd before the call to
+main()  but Hello, Minimal, IPC, Animate do ? - Moved wxide.cc to be the first
+of the cc files in the wxPython project. No clue why there should be this kind
+of dependcy, but there it is.<p>
+Modified wxTextWindow::SaveFile to actually save a file. This also has to
+convert line endings from TextEdits '\015', CR  to '\n'. This should be
+expected to need MPW conditionalization if I ever bother to try MPW again.<p>
+Modified wxText::CreateText (wx_txt.cc) to handle a default (-1) value for the
+height argument. 
+<h4>
+<a name="RTFToC15">9/15/95
+</a></h4>
+Added the wxextend files to the project (from wxPython v2). Lots of things
+missing (toolbar, image classes), missing dialog functions,  and most
+significantly wxextend assumes that wxPanel inheirits from wxCanvas and in
+wxMac,  wxPanel inheirits from wxWindow. I somewhat arbitrarily coded around
+and/or through them, so you should expect some python calls to fail because
+wxMac doesn't <b>really</b> support them.<p>
+Added wb_dialog.cc back into the project but conditionalized most parts out
+since wx_mac handles dialogs in wx_dialg.cc <b>not</b> in <b>wb</b>_dialg.cc<p>
+5.	wb_ps.cc - when should the dialog be called ? When getting the DC. Calling
+it at StartDoc() time does not allow for a cancel in the file dialog.<p>
+Added three stubbed functions to wx_gdi.h so wxExtend can go on.  Also added
+Get/SetColourMap methods to wxBitmap (wx_gdi.h and wx_gdi.cc), also stubbed.
+<h4>
+<a name="RTFToC16">9/30/95</a></h4>
+Added Louis Birk's mods to wx_dccan3.cc(drawtext) to set font, size, and
+colours.<p>
+Louis also supplied imagif.cc and .h. IMHO the best way to incorporate these is
+to meld them into the utils/image/src files, i.e. Implement the wxImage class.
+<p>
+By default, you will need GUSI (CWGUSI), to compile wx_util.cc and a few other
+files too.<p>
+3. Add wxFileSelector* functions in the "proper" place. Modified to return the
+full path name.<b></b>
+<h4>
+<a name="RTFToC17">10/3/95</a></h4>
+Released Alpha-3
+<h4>
+<a name="RTFToC18">10/7/95</a></h4>
+I'm back to getting wxExtend/wxPython(v2) to link. - Added many functions to
+wx_util.cc (which should be renamed to wx_util<b>s</b>.cc). Some of them depend
+on GUSI and the rest are stubbed out! Its likely that Scott Maxwell's mods to
+this file are better than mine, so I'll wait.<p>
+Added conditionalisation (USE_HELP) to wxPython(wxp_module.cc).
+<h4>
+<a name="RTFToC19">10/29/95</a></h4>
+Created a new wxpy project - this is a version of wxMac that must be linked
+with Mac python-1.3. There is also a new prefix file that defines PYLIB instead
+of GUSI. GUSI and Python don't mix.<p>
+Change the defaults on wxTextWindows to add scroll bars and borders. Change the
+defaults in wxExtend to add borders to single and multiline texts.
+<h4>
+<a name="RTFToC20">11/4/95</a></h4>
+Added xpm support via the wxWindows distributed wxxpm - modified for Mac. Test
+program and project in utils/xpmshow folder.<p>
+Fixed more wx_util.cc functions for path handling.<p>
+Added bitmap support wxMessage<p>
+Fixed bug(s) in wx_lbox.cc - was not deleting clientdata.<p>
+38. Tried adding wxPython  wxextend modules to the wxMac Lib. <p>
+Should modify wxExtend to pay attention to common.h/wx_setup.h idioms like
+USE_TOOLBAR<p>
+wxPython Assumes that wxPanels inherit from wxCanvas which is not true for
+wx_mac<p>
+
+<h5>
+<a name="RTFToC21">Added
+these contributions from Louis Birk:
+</a></h5>
+A fix to wx_dcmem that sets the gworld to null after deleting it in
+SelectObject. 	   <p>
+wximgfil.cc has fixes related to code that creates the rectangle for the gif.
+<p>
+In wx_frame.cc I added a Paint() call to the resize because scroll bars would
+come out strange after resizing the window.<p>
+ wx_dccan1.cc I changed the SetCurrentDC() code back to the previous rev
+because the logical window positions were about 30-40 pixels different than
+physical ones. NOTE (from Cecil), these break the animate.cc sample. They can
+be turned on by #defining LkB at the top of wx_dccan1.cc<p>
+The save file routine (wx_utils) needs to initialize a defPath, otherwise it
+gets all garbled data.<p>
+Implement a simple write/read resource file like windows. There is one problem:
+all entry names must have unique names. <p>
+Added wxGetUserHome to wx_utils (wx_util.cc) - returns current dir;<p>
+Added several print related files that make up a partial implementation for
+printing. It does not include the Print preview stuff as I have been unable to
+complete this. Printing appears to work on my QUME ps printer. I am unable to
+test through GX . Note that there is an extra allocation of a THPrint record
+due to the structure of the wx_print classes. I will work on this later.
+<h4>
+<a name="RTFToC22">11/11/95</a></h4>
+Added support for wxBitmaps that can load xbm and bmp (and the previous xpm,
+pict and pict resource). The default is wxBITMAP_TYPE_PICT_RESOURCE. Minimal
+can be compiled to test the various bitmap formats. Additionally utils/xmpshow
+can be compiled and used to browse the bmp's and xpm's. Note that xpmshow has
+some bugs (crashes), in different ways depending on 68K or PowerPC.<p>
+39. It would be nice to implement bmp, xbm, and ico support. - This would make
+porting easier.
+<h4>
+<a name="RTFToC23">11/23/95
+- Start integrating Matt's fixes
+</a></h4>
+wxCanvasDC:SetBackground (wx_dccan1.cc) - some wxCanvas method calls this with
+current_background_brush,  which is initially NULL. This crashes. I added a
+line to return if the parameter is NULL. (I don't know if that's the right
+solution.)<p>
+wxMemoryDC constructor -  If MacCreateGWorld() returns an error, then do not
+attempt to draw a bitmap.<p>
+wxBitmap: If NewGWorld() returns  an error, then set ok to FALSE, set x_pixmap
+to NULL, and don't SetGWorld() - occurs in wx_gdi.cc (wxBitmap::Create).<p>
+wxMemoryDC::SelectObject: After deleting gworldH and cMacDC, set them to NULL.
+(The gworldH problem was already reported.)<p>
+wxCanvasDC: SetCurrentDC() needs to set the logical function, (wx_dccan1.cc)<p>
+wxFont::GetTextExtent: The hack that adds 5 to the width is very bad for MrEd.
+I removed it.<p>
+wx_frame.h - OnChar() , Paint(), and OnCommandEvent() made public.<p>
+wx_panel - AdvanceCursor() made public.
+<h4>
+<a name="RTFToC24">11/26/95
+- Added more of Matt's code
+</a></h4>
+Fixed a problem with wximgfil.cc for 68K (CJC).<p>
+In wx_messg.cc OnPaint() add 1 to clientHeight and clientWidth<p>
+Moved the kludge that adds 5 to the width in wxFont::GetTextExtent(...) to
+wxMessage::CreateWxMessage when the font sytle or weight is not wxNORMAL.<p>
+wxChoice::Create now defaults to a label width of 50 pixels and a value width
+of 60 pixels (when no strings are provided).<p>
+Added enhancements to handle wxMedia and scrolling. (wx_canvs.*). Should not
+change any previous non wxMedia code.<p>
+Added Cut(), Copy(),Paste()... to wx_txt and wx_text - may not be working
+correctly at least for the hello sample.<p>
+9.	wb_utils.cc - lots of places where we need to handle Mac pathnames. Some of
+this sould be moved to :mac:wx_utils.cc <p>
+
+<h4>
+<a name="RTFToC25">11/27/95</a></h4>
+Attempted to add Matts code so that wxDialogBox inherits from wxPanel instead
+of wxFrame. This turned out to be non trivial (unless you have lots of stack
+space for nested event loops). Pressing the button in hello failed to bring up
+the next dialog and started a new event loop - simple dialogs would *appear* to
+be ok. Matts code can be conditionalized in (wx_setup.h - USE_MAC_DIALOG_PANEL)
+but needs to be debugged. The default wx_setup continues for dialogbox to
+inherit from frame.
+<h4>
+<a name="RTFToC26">11/28/95</a></h4>
+Released alpha 4 snapshot.
+<h4>
+<a name="RTFToC27">12/9/95</a></h4>
+1. IPC code doesn't work for PowerPC (15.x) or for either processor (16.1)
+Appears to be server side - try compiling with the Debug logging May be
+registering in the system twice ? (PPC) Also, can't run them twice - not
+deregistering (ppc and 68k)   - This bug is fixed.<p>
+Hacked the wxWindow destructor to NULL out wxPanel-&gt;last_created (if the
+windows parent is a Panel)<p>
+When USE_PANEL_CANVAS_IN_MAC and USE_MAC_DIALOG_PANEL are both defined as '1'
+in wx_setup.h, then wxDialogBox inherits from wxPanel which inherits from
+wxCanvas, just like the MSW and Motif versions of wxWindows. This is the
+default in wx_setup.h. USE_MAC_DIALOG_PANEL will goway in a future release (a5
+or a6).
+<h4>
+<a name="RTFToC28">12/27/95
+Adding Greg's (GRW) fixes:
+</a></h4>
+In the spirit of making wxWin adapt to "the Mac look" I switched the order of
+OK and Cancel in wxMessageBox and wxGetTextFromUser, and added wxSYSTEM to the
+list of fonts. Files modified - common.h, wxGetTxt.cc, wx_dialg.cc,wx_gdi.cc<p>
+In wx_canvs.h and wx_canvs.cc, added two additional constructors needed for
+USE_PANEL_CANVAS_IN_MAC.<p>
+Incomplete, but functional - Improved the visual appearance of controls and
+scrollbars in particular when the "frame" becomes (in)active. Much more Mac
+like. - wb_frame.cc,wx_buttn.cc,wx_buttn.h, wx_check.cc, wx_rbut.cc,wx_sbar.cc
+and wx_win.cc. This introduces a new method of wxButton - Highlight() which is
+used instead of ShowAsActive(). In some controls, ShowAsActive() is now stubbed
+out.<p>
+Initialized variable 'ret' before usage in wximgfil.cc wxGIF::decoder().<p>
+Add additional mouse handling code for wxFrames and remove call to SystemTask()
+- wx_app.cc.<p>
+in wx_gdi.cc wxBitmap::~wxBitmap() - use the short form of Disposing of the
+GWorld - Louis's code can be switched in with a #define LkB<p>
+in wx_txt.cc wxText::CreateWxText,  make a single call to wxScrollArea() not
+two.<p>
+Do a better job of postioning Scrollbars on a frame - wxScrollArea.cc<p>
+Support for the built-in cursors (arrow, ibeam, cross, watch) and adjusting the
+cursor as the mouse moves - wx_app.cc, wx_gdi.h, wx_gdi.cc, wx_main.cc,
+wx_win.h, wx_win.cc<p>
+Support for more window styles, drawing the grow icon, and resizing -
+wx_frame.cc, wx_frame.h add a MacDrawGrowIcon(void) method and new update code
+and drawing code.  Also mods in wx_panel.cc Paint() and wx_win.cc<p>
+Incomplete fixes related to keyboard focus in panels.  Support for enter/return
+triggering the default action, and tab/shift-tab cycling through the items that
+want focus.  Currently, only wxText and wxMultiText accept focus.  Also, while
+making these changes, I noticed that wxText doesn't really implement a single
+line input like it is supposed to (this was a problem when I wanted to steal
+enter/return from it).  To avoid duplicating code between wxText and
+wxMultiText/wxTextWindow, I just introduced a flag to wxText that turns on the
+multiple line behaviour (wxMULTIPLE).   The single line behaviour, on by
+default, still isn't complete though: word wrap hasn't been disabled. Lots of
+files modified - wxGetTxt.cc, wx_dialg.cc, wx_item.cc wx_mtxt.cc, wx_panel.cc,
+wx_panel.h line 123, wx_txt.cc, wx_txt.h, wx_win.cc, wx_win.h.
+<h4>
+<a name="RTFToC29">1/12/96</a></h4>
+Replaced my 'a5p2' (which should have been a4p2) with Matt's (mflatt)
+distribution which includes everything in a5p2(a4p2) plus fixs and changes.
+Uploaded to ftp.aiai.
+<h4>
+<a name="RTFToC30">1/13/96</a></h4>
+Fixed and distributed these errors to a4p3: - (Porting:cjcfixes.txt)<p>
+Added a new function wxDirectorySelector() to wb_utils.h and wx_utils.cc and
+also added to new constants to wb_utils.h - wxDIR_ONLY and wxFILES_ONLY (the
+later is probably not needed). If wxDIR_ONLY is passed to wxFileSelector(), it
+will be handed off to wxDirectorySelector() which takes the same arg list as
+wxFileSelector (most are unused on the Mac). Modified xpmshow to use
+wxDirectorySelector() for testing. wxDirectorySelector() requires a special
+DLOG,DITL resource (see main.[[pi]].rsrc and wx_utils.cc) E-mail with Julian
+concurs that wxDirectorySelector() is a function that should be added to
+wxMotif, wxMSW...
+<h4>
+<a name="RTFToC31">1/21/96</a></h4>
+Eradicated memory leaks - Hello sample has 12 leaks which appear to come from
+startup - see README:Leaks-Repair. Also, these methods now copy to wxBuffer
+instead of copystring():
+<ul>
+<li>wxMessage::GetLabel </ul>
+<h4>
+<a name="RTFToC32">1/27/96</a></h4>
+Cleaned up a confusion with OnSize() which appears to be only a method of
+wxFrame. I adjusted code so that OnSize is only called when the frame is
+maximized(minimized), it is  growzone dragged, or when the app calls
+frame::SetSize().  Then I called OnSize() in wxEntry so that the startup frame
+gets the OnSize when created. Now that I think of it, this behaviour should be
+"delayed" until any frame is given a "Show(TRUE)" although the first wxTheApp
+frame should still be done (ie two calls to OnSize on the first (app) frame).
+<h4>
+<a name="RTFToC33">2/17/96</a></h4>
+Replaced call to Paint() in wx_win.cc with a call to OnPaint(). Applications
+can now defined their canvas painting method as  standard OnPaint(). THIS WILL
+REQUIRE THAT wxMac applications will need to changed.  This fix is
+conditionalized #ifdef CJC_FIXES_PAINT and required modifications in many of
+the internal files wx_buttn, wc_check..... This introduced a bug where canvas
+scrollbars are not drawn when the canvas is positioned with the scrollbar off
+screen, activated and positioned back on screen. Introducded yet more code to
+wxWindow::OnPaint to check for a canvas and make an additional call to paint
+the scroll bars. NOTE This looks like a kludge!<p>
+Repaired wxButton::GetLabel and wxCheckBox::GetLabel , wxMessage::SetLabel ,
+wxScrollBar::GetLabel leaks. Also  wxRadioButton::GetLabel()<p>
+
+<h4>
+<a name="RTFToC34">2/19/96
+- Thomas Fettig's Fixes
+</a></h4>
+Define USE_MAC_GRAY_LABEL_BACKGROUND in wx_setup.h if you like Grey backgrounds
+for your labels. Not defined by default. wxLabelArea.cc<p>
+Define some additional function keys and added some internationalization.
+Modfications to wx_app.cc, wx_txt.cc - Note that Tom points out a
+incompatiblity in wx_txt OnChar() with Matts code.<p>
+Tom doesn't lke the +5 hack in wxMessage::CreateWxMessage - but hello.cc needs
+it? What to do?<p>
+Add code to enable and disable multiline text mode in wx_text.cc,  wx_mtxt.cc -
+Doesn't work for me (Cecil)<p>
+Conditionally, add code to place StatusLines at the bottom of a frame. Visually
+I like it. Note that it resizes improperly in hello.c so its not compiled in by
+default. See wx_setup.h<p>
+Added code to wx_panel.cc to help manage children (windows)
+deletion/destruction.<p>
+Improved AreaSize'ing code in wx_win.  Worked fine for me before and after so
+I'm not sure what the problem or symptom is being fixed.<p>
+Did not add all of Tom's modifications to the wx_win destructor since some of
+them interfered with the plugging of memory leaks that I did. More study is
+needed here.<p>
+Restore lost line in wb_item.cc and a lost patch to wx_util.cc (oops - I know I
+had it once).<p>
+Released wxMac161d-a5 as soon as ftp.aiai cooperates.<p>
+</body></html>
\ No newline at end of file
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Status.msw b/src/wxmac/docs/wxmac doc/wxMac_Status.msw
new file mode 100644
index 0000000..d7f88c5
Binary files /dev/null and b/src/wxmac/docs/wxmac doc/wxMac_Status.msw differ
diff --git a/src/wxmac/docs/wxmac doc/wxMac_Status.rtf b/src/wxmac/docs/wxmac doc/wxMac_Status.rtf
new file mode 100644
index 0000000..0ac479a
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/wxMac_Status.rtf	
@@ -0,0 +1,243 @@
+{\rtf1\mac\deff2 {\fonttbl{\f0\fswiss Chicago;}{\f2\froman New York;}{\f3\fswiss Geneva;}{\f4\fmodern Monaco;}{\f13\fnil Zapf Dingbats;}{\f15\fnil Helvetica Narrow;}{\f16\fnil Palatino;}{\f18\fnil Zapf Chancery;}{\f20\froman Times;}{\f21\fswiss Helvetica;}
+{\f22\fmodern Courier;}{\f23\ftech Symbol;}{\f34\fnil New Century Schoolbook;}{\f128\fnil Bold Monaco;}{\f129\fnil West Monaco;}{\f256\fnil N Helvetica Narrow;}{\f2488\fnil AppleIconTwo;}{\f4788\fnil NewZurica;}{\f5466\fnil NewZuricaBold;}
+{\f5735\fnil MPW;}{\f8516\fnil NewZuricaOblique;}{\f12761\fnil Torino Outline;}{\f32525\fnil VT100;}}{\colortbl\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;
+\red255\green255\blue0;\red255\green255\blue255;}{\stylesheet{\s245\li360\sa120 \f20\fs18\up6 \sbasedon0\snext0 footnote reference;}{\s246\li360\sa120 \f20\fs20 \sbasedon0\snext246 footnote text;}{\s250\li360\sb120\sa120\keepn \b\f20\fs28 
+\sbasedon251\snext0 heading 6;}{\s251\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon252\snext0 heading 5;}{\s252\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon253\snext0 heading 4;}{\s253\li360\sb120\sa120\keepn \b\f20\fs28 \sbasedon254\snext0 heading 3;}{
+\s254\li180\sb120\sa120\keepn\brdrb\brdrs \b\f20\fs36 \sbasedon255\snext0 heading 2;}{\s255\li360\sb240\sa240\keepn\brdrb\brdrs \b\f20\fs48 \sbasedon0\snext0 heading 1;}{\li360\sa120 \f20 \sbasedon222\snext0 Normal;}{\s1\fi-540\li900\sa120\tx900 \f20 
+\sbasedon0\snext1 numbered list;}{\s2\fi-540\li1440\sa120\tx1440 \f20 \sbasedon0\snext2 numbered list 1;}{\s3\fi-540\li1980\sa120\tx1980 \f20 \sbasedon0\snext3 numbered list 2;}{\s4\fi-280\li900\sa120\tx900 \f20 \sbasedon1\snext4 bullet list;}{
+\s5\fi-280\li1440\sa120\tx1440 \f20 \sbasedon2\snext5 bullet list 1;}{\s6\fi-280\li1980\sa120\tx1980 \f20 \sbasedon3\snext6 bullet list 2;}{\s7\fi-3960\li4320\sa120\tx4320 \f20 \sbasedon0\snext7 glossary;}{\s8\fi-3960\li4860\sa120\tx4860 \f20 
+\sbasedon7\snext8 glossary 1;}{\s9\keep\tx880\tx1740\tx2620\tx3480\tx4320\tx5220\tx6060\tx6940\tx7780 \f22\fs20 \sbasedon0\snext9 pre;}{\s10\li360\sa120 \i\f20 \sbasedon0\snext10 address;}{\s11\li1440\ri1440\sa120 \i\f20 \sbasedon0\snext11 blockquote;}{
+\s12\sb120\sa120\brdrb\brdrth \f20 \sbasedon0\snext0 hr;}{\s13\fi360\tx360\tx3600\tx4320\tx7200\tx10700 \f20 \sbasedon0\snext13 dir;}{\s14\fi360\li360\tx720\tx3960\tx4320\tx7560\tx10700 \f20 \sbasedon0\snext14 dir 1;}{
+\s15\fi360\li720\tx1080\tx4320\tx7920\tx10700 \f20 \sbasedon0\snext15 dir 2;}{\s16\fi-720\li1440\tx1440 \f20 \sbasedon10\snext16 menu 1;}{\s17\fi-720\li1080\tx1080 \f20 \sbasedon16\snext17 menu;}{\s18\fi-720\li1800\tx1800 \f20 \sbasedon0\snext18 menu 2;}{
+\s19\fi-3960\li5400\sa120\tx5400 \f20 \sbasedon8\snext19 glossary 2;}{\s20\li360 \f22 \sbasedon0\snext20 HTML;}{\s21\li360\sa120 \f20 \sbasedon7\snext21 TERM;}{\s22\li900\sa120 \f20 \sbasedon7\snext22 DEF;}{\s23\fi-3960\li4860\sa120\tx4860 \f20 
+\sbasedon8\snext23 TERM 1;}{\s24\li1440\sa120 \f20 \sbasedon8\snext24 DEF 1;}{\s25\li1440\sa120 \f20 \sbasedon19\snext25 TERM 2;}{\s26\li1980\sa120 \f20 \sbasedon25\snext26 DEF 2;}}{\info{\title wxMac Status}{\author Cecil Coupe}}
+\margl720\margr720\widowctrl\ftnbj\fracwidth \sectd \sbknone\linemod0\linex0\cols1\endnhere \pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Known Bugs and Problems\par 
+\pard\plain \li360\sa120 \f20 
+4. Merged Tomaso's wb_ps.cc with 16.1 distribution wb_ps.cc. MW's DebugNew crashes to MacsBug because it found a overwritten block when doing the hello/file/print eps. This doesn't happen in all combinations of PPC, 68K, and Debugging!\par 
+11.  Things that 16.1 does that wxMac doesn't like (some of these may be new functionality since the base 15.x version) :\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 \tab The Get/SetLabel compiler warnings are very annoying.  wx_menu.h seems to be a major offender.\par 
+\tab In wx_text the following methods may have not been fully debugged:\par 
+\pard\plain \s5\fi-280\li1440\sa120\tx1440 \f20 \tab SetSelection\par 
+\tab Copy\par 
+\tab Paste\par 
+\tab Cut\par 
+\pard\plain \li360\sa120 \f20 12.  Why can't an app declare a variable called 'frame' like most of the distributed sample/test apps do.  - Because frame is declared in an apple header, Quickdraw.h\par 
+14. Need a better  scheme for preprocessor symbols Beware: Apple's <Windows.h> defines __WINDOWS__\par 
+\pard \li360\sa120 18. Need real code for these classes: group, toolbar, mf.\par 
+20. Need additional Cursors\par 
+\pard \li360\sa120 21. Hello.cc creates a popupmenu - how/where does this show up on a real wxWindows system and how should the mac do it?\par 
+\pard \li360\sa120 23. Resources - how to implement ?\par 
+24. Dig into dynamically tracking the thumb in wx_slider.cc. There's code in there to try it but it doesn't work. \par 
+\pard \li360\sa120 25. There is a problem with hello.cc - MyTextWindow can cover parts of the last 
+control. Hello should be rewritten so that the TextWindow is not 1/2 of the root frame but instead start after the last control. The same problem shows up in animate.cc where the sliders panel covers part of the frames statusline. This is not a Mac bug per
+-se - its a consequence of the size of Mac controls, Mac screen size and application programming that assumes every thing will fit in 1/2 the window.\par 
+\pard \li360\sa120 26. Maybe StatusLine widget should go on the bottom of a frame with room for a GrowIcon and a small horizontal scroll if needed\par 
+28. What I implemented for wxChoice is really a wxWindows PopUpMenu(). This may be a problem. Is a wxChoice a keyboard enterable control or are the selections fixed (by the program)?\par 
+\pard \li360\sa120 
+40. For 'ipc' samples compiled and run on a PowerPC - the 'client's PPC Browser windows shows that "server" and "server PPC" are available targets. If you select just plain  "server" everything works ok. Usually. May have to compile client and server and l
+ibrary with wxDebugHeadersPPC (...68K) to get these to work.\par 
+\pard \li360\sa120 43. Scan for #if 0 , #if 1 code , #ifndef CJC  and other bracketed out code - should be removed. \par 
+44. Multiline text doesn't work for me (Cecil)\par 
+\pard\plain \s253\li360\sb120\sa120\keepn \b\f20\fs28 Completed (plus notes)\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 7/9/95\par 
+\pard\plain \li360\sa120 \f20 Have a wxListBox (wx_lbox.h, wx_lbox.cc) see the top of the file for hints on writing controls in wxMac. Still to do\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 How to set the font for the Lbox?\par 
+Make the cell size a multiple of the font height\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 7/22/95 \par 
+\pard\plain \li360\sa120 \f20 Have a wxChoice - may not respond to OnAreaDSize in the best way. Built w/o areas, just Mac ToolBox calls.\par 
+\pard \li360\sa120 Added wxMultiText::GetValue(void) hack\par 
+Added wxRemoveFile and wxGetTempFileName - these are hacks in :mac:wx_utils.c\par 
+\pard \li360\sa120 wxPython (v01) Links,  but fails on init with a python error. WxPython sources must have the same Code Warrior Language Prefs as the PythonLib, i.e.  Apple C++ {\i and} don't check prototypes.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 7/29/95\par 
+\pard\plain \li360\sa120 \f20 Have a wxSlider - works with the following caveats:\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 The usable range is the Mac Control Managers (short int 32k?)\par 
+Does not dynamically track the thumb value - see comments in wxSlider.cc\par 
+#define USE_ACTIONPROC  1 -  can crash the Mac\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 7/30/95\par 
+\pard\plain \li360\sa120 \f20 Fixed wx_frame.cc (SetMenuBar)and wx_app.cc (doInMacMenu) to create and handle the Apple menu (and desk accessories)\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/6/95\par 
+\pard\plain \li360\sa120 \f20 
+Fixed wx_menu.cc so that the Title of a Mac Menu can be changed. This involves rebuilding the entire Mac Menu and all its items but does allow menu_bar->Append(menu,"Real Title for menu"); which is how most wxWindows Programs create menus and menubars. Thi
+s is also done for wxMenu::SetTitle.\par 
+\pard \li360\sa120 If a menubar->Append(menu, "Help") is done and one of the Items in the menu is "About", then I save the wxMenu
+* and the MacItemNum in the menu_bar object. When the menu_bar is created (see the applemenu hack) I insert an "About" string into the apple menu. If chosen by the user, wx_app.cc notes that its applemenu/item 1 and pretends its the Help/About choice. Defi
+nately a Hack and probably not robust. The wxMenu destructor should deactivate this if the Help menu is deleted.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/7/95\par 
+\pard\plain \li360\sa120 \f20 Added code to wx_buttn.cc and wx_gdi.cc for Bitmap buttons. This is good enough for Hello.cc but there is more to be done so that my scheme is usable in wxMemoryDC (including fixing/adding code to various DC's). \par 
+\pard \li360\sa120 
+With wxMac you can load either named PICT resources or PICT files (pict in the data fork), into a wxBitmap. The internal Mac object for a wxBitmap is "Picture". Given the wxWindows definition of a bitmap, this *seems* like an ok choice because Pictures are
+ relatively independent of bit depth (I believe). They might be larger than PixMaps for some images, but they are easy to deal with. There are comments in wx_gdi.cc, but its pretty straight-forward. (I said they were easy).\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/8/95\par 
+\pard\plain \li360\sa120 \f20 19. with PPCC compiler, linking hello gets a c2pstr undefined - because there doesn't seem to be an MPW library with that function. However there is a C2PStr, so all the files that need it now call for the mixed case.\par 
+\pard \li360\sa120 
+20. PPCC gets very annoying, spitting out warnings about inherited virtual functions that is not over-ridden. Fixed the major offenders, not by deep thought which what is really required. Instead I just tried a few things. CodeWariour  seems 
+to like them as well. This may have some part in the Hello (MPW PPPC) bug though.\par 
+\pard \li360\sa120 
+21. Hello.cc works with both 68K and PPC Code Warrior compilers. Hello, minimal, fractal, and ipc(client & server) have PPC projects. Only Hello has a 68k project, but its pretty simple to make 68K projects (4i/8d) out of the existing PPC projects.\par 
+\pard \li360 \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/9/95\par 
+\pard\plain \li360 \f20 Released alpha-1 (wxmac161d-a1) to limited group.\par 
+\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/10/95\par 
+\pard\plain \li360 \f20 31. MPW PPCC version of hello doesn't have working push buttons ! (it used to). - left out an\par 
+\pard \li360 assignment from ::TrackControl. Depending on stack contents, this might have worked (or not) with the other compilers.\par 
+\pard \li360 This time, with thought, I got rid of the GetLabel and SetLabel warnings. Should not change functionality.\par 
+Re-released 'a1'.  \par 
+\pard \li360 Starting the alpha-2 modifications which are directed towards getting the source cleaned up and documenting (if not fixing) missing canvas, and DC functions.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/12/95\par 
+\pard\plain \li360\sa120 \f20 13. Scan files for "CJC", "wx_mac", "OLD_HEADERS" - and review modifcations. \par 
+\pard \li360\sa120 I have made serious cuts and restructuring of the :include:base: files (and :src:base:, :src:mac: as needed) to remove most of the passing of 'objectType'  to{\i  wxb* }
+constructors . This was done to bring the wxMac modifications to the wb_xxx.* files down to something more reasonable.  More can still be done, but this isn't too bad. This also involved moving some lines around to keep the style of the wb_xxx files more l
+ike the style of the original wxWindows files.  This does involve code changes to constructors, so beware: It works for me (hello.cc, minimal.cc, fractal.cc,animate.cc (CodeWarrior)).\par 
+\pard \li360\sa120 You can scan for "CJC' and only pickup a few (3) comments. I removed the OLD_HEADERS conditionals. You can scan for "wx_mac" as a "word" and (generally ) only pick up modifications to wb_xxx files.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 8/25/95\par 
+\pard\plain \li360\sa120 \f20 In Summary, we now have wxMemoryDC and wxTimer classes working. It is probably time to release Alpha-2 Note that PPCC from ETO #17 works, and the new (ETO #18) MrCpp fails.\par 
+\pard \li360\sa120 27. There are functions that appear to do nothing in wx_dccan*, wx_dcmem - Started on Blit(). Seems to work with the animate.cc sample, but I need a wxTimer that works before we can scratch animate off of the list of todo's. \par 
+
+2. Now have a somwhat kludgy timer class (good enough for hello.cc and animate.cc). It can only "fire" when the event loop is dequeueing events and accuracy is in CLOCKS_PER_SEC (ie Ticks) instead of milliseconds (probable rounding errors too!) Latency can
+ be highly variable. \par 
+\pard \li360\sa120 Reworked wxBitmaps to be offscreen GWorlds (wx_gdi.cc, and wx_dcmem.cc) I'm not overly confident in the destructor code though.  \par 
+\pard \li360\sa120 
+34. Canvas's can not be placed on a frame with (abs) co-ordinates. I've implemented a "cure" for this in wx_dccan1.cc(wxCanvasDC::SetMacDC() ). It seems to work for animate and hello demos but I believe this could break other things (canvas's place in subf
+rames of frames, or canvas's in panels in frames).\par 
+\pard \li360\sa120 Released Alpha-2.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 9/10/95\par 
+\pard\plain \li360\sa120 \f20 Started playing again with wxpython (v1), wxMac161d, and python-1.2. Works better if the System Folder has a PythonStartup file (I didn't install python properly)\par 
+\pard \li360\sa120 
+22. With wxPython/wxide.cc, wxTheApp does not get init'd before the call to main()  but Hello, Minimal, IPC, Animate do ? - Moved wxide.cc to be the first of the cc files in the wxPython project. No clue why there should be this kind of dependcy, but there
+ it is.\par 
+Modified wxTextWindow::SaveFile to actually save a file. This also has to convert line endings from TextEdits '\\015', CR  to '\\n'. This should be expected to need MPW conditionalization if I ever bother to try MPW again.\par 
+\pard \li360\sa120 Modified wxText::CreateText (wx_txt.cc) to handle a default (-1) value for the height argument. \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 9/15/95 \par 
+\pard\plain \li360\sa120 \f20 
+Added the wxextend files to the project (from wxPython v2). Lots of things missing (toolbar, image classes), missing dialog functions,  and most significantly wxextend assumes that wxPanel inheirits from wxCanvas and in wxMac,  wxPanel inheirits from wxWin
+dow. I somewhat arbitrarily coded around and/or through them, so you should expect some python calls to fail because wxMac doesn't {\b really} support them.\par 
+\pard \li360\sa120 Added wb_dialog.cc back into the project but conditionalized most parts out since wx_mac handles dialogs in wx_dialg.cc {\b not} in {\b wb}_dialg.cc\par 
+5.\tab wb_ps.cc - when should the dialog be called ? When getting the DC. Calling it at StartDoc() time does not allow for a cancel in the file dialog.\par 
+Added three stubbed functions to wx_gdi.h so wxExtend can go on.  Also added Get/SetColourMap methods to wxBitmap (wx_gdi.h and wx_gdi.cc), also stubbed.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 9/30/95\par 
+\pard\plain \li360\sa120 \f20 Added Louis Birk's mods to wx_dccan3.cc(drawtext) to set font, size, and colours.\par 
+\pard \li360\sa120 Louis also supplied imagif.cc and .h. IMHO the best way to incorporate these is to meld them into the utils/image/src files, i.e. Implement the wxImage class. \par 
+\pard \li360\sa120 By default, you will need GUSI (CWGUSI), to compile wx_util.cc and a few other files too.\par 
+3. Add wxFileSelector* functions in the "proper" place. Modified to return the full path name.{\b \par 
+}\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 10/3/95\par 
+\pard\plain \li360\sa120 \f20 Released Alpha-3\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 10/7/95\par 
+\pard\plain \li360\sa120 \f20 I'm back to getting wxExtend/wxPython(v2) to link. - Added many functions to wx_util.cc (which should be renamed to wx_util{\b s}
+.cc). Some of them depend on GUSI and the rest are stubbed out! Its likely that Scott Maxwell's mods to this file are better than mine, so I'll wait.\par 
+\pard \li360\sa120 Added conditionalisation (USE_HELP) to wxPython(wxp_module.cc).\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 10/29/95\par 
+\pard\plain \li360\sa120 \f20 Created a new wxpy project - this is a version of wxMac that must be linked with Mac python-1.3. There is also a new prefix file that defines PYLIB instead of GUSI. GUSI and Python don't mix.\par 
+Change the defaults on wxTextWindows to add scroll bars and borders. Change the defaults in wxExtend to add borders to single and multiline texts.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/4/95\par 
+\pard\plain \li360\sa120 \f20 Added xpm support via the wxWindows distributed wxxpm - modified for Mac. Test program and project in utils/xpmshow folder.\par 
+\pard \li360\sa120 Fixed more wx_util.cc functions for path handling.\par 
+Added bitmap support wxMessage\par 
+Fixed bug(s) in wx_lbox.cc - was not deleting clientdata.\par 
+38. Tried adding wxPython  wxextend modules to the wxMac Lib. \par 
+Should modify wxExtend to pay attention to common.h/wx_setup.h idioms like USE_TOOLBAR\par 
+wxPython Assumes that wxPanels inherit from wxCanvas which is not true for wx_mac\par 
+\par 
+\pard\plain \s251\li360\sb120\sa120\keepn \b\f20\fs28 Added these contributions from Louis Birk:\par 
+\pard\plain \li360\sa120 \f20 A fix to wx_dcmem that sets the gworld to null after deleting it in SelectObject. \tab    \par 
+wximgfil.cc has fixes related to code that creates the rectangle for the gif. \par 
+\pard \li360\sa120 In wx_frame.cc I added a Paint() call to the resize because scroll bars would come out strange after resizing the window.\par 
+\pard \li360\sa120  wx_dccan1.cc I changed the SetCurrentDC() code back to the previous rev because the logical window positions were about 30-40 pixe
+ls different than physical ones. NOTE (from Cecil), these break the animate.cc sample. They can be turned on by #defining LkB at the top of wx_dccan1.cc\par 
+\pard \li360\sa120 The save file routine (wx_utils) needs to initialize a defPath, otherwise it gets all garbled data.\par 
+\pard \li360\sa120 Implement a simple write/read resource file like windows. There is one problem: all entry names must have unique names. \par 
+\pard \li360\sa120 Added wxGetUserHome to wx_utils (wx_util.cc) - returns current dir;\par 
+\pard \li360\sa120 Added several print related files that make up a partial implementatio
+n for printing. It does not include the Print preview stuff as I have been unable to complete this. Printing appears to work on my QUME ps printer. I am unable to test through GX . Note that there is an extra allocation of a THPrint record due to the struc
+ture of the wx_print classes. I will work on this later.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/11/95\par 
+\pard\plain \li360\sa120 \f20 Added support for wxBitmaps that can load xbm and bmp (and the previous xpm, pict and pict resource). The default is wxBITMAP_TYPE_PICT_RESOURCE. Minimal can be compiled to test the various 
+bitmap formats. Additionally utils/xmpshow can be compiled and used to browse the bmp's and xpm's. Note that xpmshow has some bugs (crashes), in different ways depending on 68K or PowerPC.\par 
+\pard \li360\sa120 39. It would be nice to implement bmp, xbm, and ico support. - This would make porting easier.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/23/95 - Start integrating Matt's fixes\par 
+\pard\plain \li360\sa120 \f20 wxCanvasDC:SetBackground (wx_dccan1.cc) - some wxCanvas method calls this with current_background_brush,  which is initially NULL. This crashes. I added a line to return if the parameter
+ is NULL. (I don't know if that's the right solution.)\par 
+\pard \li360\sa120\tx11520 wxMemoryDC constructor -  If MacCreateGWorld() returns an error, then do not attempt to draw a bitmap.\par 
+\pard \li360\sa120 wxBitmap: If NewGWorld() returns  an error, then set ok to FALSE, set x_pixmap to NULL, and don't SetGWorld() - occurs in wx_gdi.cc (wxBitmap::Create).\par 
+wxMemoryDC::SelectObject: After deleting gworldH and cMacDC, set them to NULL. (The gworldH problem was already reported.)\par 
+\pard \li360\sa120 wxCanvasDC: SetCurrentDC() needs to set the logical function, (wx_dccan1.cc)\par 
+wxFont::GetTextExtent: The hack that adds 5 to the width is very bad for MrEd. I removed it.\par 
+wx_frame.h - OnChar() , Paint(), and OnCommandEvent() made public.\par 
+wx_panel - AdvanceCursor() made public.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/26/95 - Added more of Matt's code\par 
+\pard\plain \li360\sa120 \f20 Fixed a problem with wximgfil.cc for 68K (CJC).\par 
+In wx_messg.cc OnPaint() add 1 to clientHeight and clientWidth\par 
+\pard \li360\sa120 Moved the kludge that adds 5 to the width in wxFont::GetTextExtent(...) to  wxMessage::CreateWxMessage when the font sytle or weight is not wxNORMAL.\par 
+wxChoice::Create now defaults to a label width of 50 pixels and a value width of 60 pixels (when no strings are provided).\par 
+Added enhancements to handle wxMedia and scrolling. (wx_canvs.*). Should not change any previous non wxMedia code.\par 
+Added Cut(), Copy(),Paste()... to wx_txt and wx_text - may not be working correctly at least for the hello sample.\par 
+9.\tab wb_utils.cc - lots of places where we need to handle Mac pathnames. Some of this sould be moved to :mac:wx_utils.cc \par 
+\pard \li360\sa120 \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/27/95\par 
+\pard\plain \li360\sa120 \f20 Attempted to add Matts code so that wxDialogB
+ox inherits from wxPanel instead of wxFrame. This turned out to be non trivial (unless you have lots of stack space for nested event loops). Pressing the button in hello failed to bring up the next dialog and started a new event loop - simple dialogs would
+ *appear* to be ok. Matts code can be conditionalized in (wx_setup.h - USE_MAC_DIALOG_PANEL) but needs to be debugged. The default wx_setup continues for dialogbox to inherit from frame.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 11/28/95\par 
+\pard\plain \li360\sa120 \f20 Released alpha 4 snapshot.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 12/9/95\par 
+\pard\plain \li360\sa120 \f20 1. IPC code doesn't work 
+for PowerPC (15.x) or for either processor (16.1) Appears to be server side - try compiling with the Debug logging May be registering in the system twice ? (PPC) Also, can't run them twice - not deregistering (ppc and 68k)   - This bug is fixed.\par 
+\pard \li360\sa120 Hacked the wxWindow destructor to NULL out wxPanel->last_created (if the windows parent is a Panel)\par 
+\pard \li360\sa120 When USE_PANEL_CANVAS_IN_MAC and USE_MAC_DIALOG_PANEL are both defined as '1' in wx_setup.h, then wxDialogBox inherits from wxPanel which inherits from wxCanvas, just
+ like the MSW and Motif versions of wxWindows. This is the default in wx_setup.h. USE_MAC_DIALOG_PANEL will goway in a future release (a5 or a6).\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 12/27/95 Adding Greg's (GRW) fixes:\par 
+\pard\plain \li360\sa120 \f20 
+In the spirit of making wxWin adapt to "the Mac look" I switched the order of OK and Cancel in wxMessageBox and wxGetTextFromUser, and added wxSYSTEM to the list of fonts. Files modified - common.h, wxGetTxt.cc, wx_dialg.cc,wx_gdi.cc\par 
+\pard \li360\sa120 In wx_canvs.h and wx_canvs.cc, added two additional constructors needed for USE_PANEL_CANVAS_IN_MAC.\par 
+\pard \li360\sa120 
+Incomplete, but functional - Improved the visual appearance of controls and scrollbars in particular when the "frame" becomes (in)active. Much more Mac like. - wb_frame.cc,wx_buttn.cc,wx_buttn.h, wx_check.cc, wx_rbut.cc,wx_sbar.cc and wx_win.cc. This intro
+duces a new method of wxButton - Highlight() which is used instead of ShowAsActive(). In some controls, ShowAsActive() is now stubbed out.\par 
+\pard \li360\sa120 Initialized variable 'ret' before usage in wximgfil.cc wxGIF::decoder().\par 
+Add additional mouse handling code for wxFrames and remove call to SystemTask() - wx_app.cc.\par 
+\pard \li360\sa120 in wx_gdi.cc wxBitmap::~wxBitmap() - use the short form of Disposing of the GWorld - Louis's code can be switched in with a #define LkB\par 
+\pard \li360\sa120 in wx_txt.cc wxText::CreateWxText,  make a single call to wxScrollArea() not two.\par 
+Do a better job of postioning Scrollbars on a frame - wxScrollArea.cc\par 
+\pard \li360\sa120 Support for the built-in cursors (arrow, ibeam, cross, watch) and adjusting the cursor as the mouse moves - wx_app.cc, wx_gdi.h, wx_gdi.cc, wx_main.cc, wx_win.h, wx_win.cc\par 
+\pard \li360\sa120 Support for more window styles, drawing the grow icon, and resizing - wx_frame.cc, wx_frame.h add a MacDrawGrowIcon(void) method and new update code and drawing code.  Also mods in wx_panel.cc Paint() and wx_win.cc\par 
+\pard \li360\sa120 
+Incomplete fixes related to keyboard focus in panels.  Support for enter/return triggering the default action, and tab/shift-tab cycling through the items that want focus.  Currently, only wxText and wxMultiText accept focus.  Also, while making these chan
+ges, I noticed that wxText doesn't real
+ly implement a single line input like it is supposed to (this was a problem when I wanted to steal enter/return from it).  To avoid duplicating code between wxText and wxMultiText/wxTextWindow, I just introduced a flag to wxText that turns on the multiple 
+line behaviour (wxMULTIPLE).   The single line behaviour, on by default, still isn't complete though: word wrap hasn't been disabled. Lots of files modified - wxGetTxt.cc, wx_dialg.cc, wx_item.cc wx_mtxt.cc, wx_panel.cc, wx_panel.h line 123, wx_txt.cc, wx_
+txt.h, wx_win.cc, wx_win.h.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 1/12/96\par 
+\pard\plain \li360\sa120 \f20 Replaced my 'a5p2' (which should have been a4p2) with Matt's (mflatt) distribution which includes everything in a5p2(a4p2) plus fixs and changes. Uploaded to ftp.aiai.\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 1/13/96\par 
+\pard\plain \li360\sa120 \f20 Fixed and distributed these errors to a4p3: - (Porting:cjcfixes.txt)\par 
+\pard \li360\sa120 Added a new function wxDirectorySelector() to wb_utils.h and wx_utils.cc and also added to new constants to wb_utils.h - wxDIR_ONLY and wxFILES_ONLY (the later is probably not needed). If wxDIR_ONLY is passed to wxFileSelector(), i
+t will be handed off to wxDirectorySelector() which takes the same arg list as wxFileSelector (most are unused on the Mac). Modified xpmshow to use wxDirectorySelector() for testing. wxDirectorySelector() requires a special DLOG,DITL resource (see main.
+\'b9.rsrc and wx_utils.cc) E-mail with Julian concurs that wxDirectorySelector() is a function that should be added to wxMotif, wxMSW...\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 1/21/96\par 
+\pard\plain \li360\sa120 \f20 Eradicated memory leaks - Hello sample has 12 leaks which appear to come from startup - see README:Leaks-Repair. Also, these methods now copy to wxBuffer instead of copystring():\par 
+\pard\plain \s4\fi-280\li900\sa120\tx900 \f20 wxMessage::GetLabel \par 
+\pard\plain \li360\sa120 \f20 \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 1/27/96\par 
+\pard\plain \li360\sa120 \f20 
+Cleaned up a confusion with OnSize() which appears to be only a method of wxFrame. I adjusted code so that OnSize is only called when the frame is maximized(minimized), it is  growzone dragged, or when the app calls frame::SetSize().  Then I called OnSize(
+) in wxEntry so that the startup frame gets the OnSize when created. Now that I think of it, this behaviour should be "delayed" until any frame is given a "Show(TRU
+E)" although the first wxTheApp frame should still be done (ie two calls to OnSize on the first (app) frame).\par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 2/17/96\par 
+\pard\plain \li360\sa120 \f20 
+Replaced call to Paint() in wx_win.cc with a call to OnPaint(). Applications can now defined their canvas painting method as  standard OnPaint(). THIS WILL REQUIRE THAT wxMac applications will need to changed.  This fix is conditionalized #ifdef CJC_FIXES_
+PAINT and required modifications in many of the internal files wx_buttn, wc_check..... This introduced a bug where canvas scrollbars are n
+ot drawn when the canvas is positioned with the scrollbar off screen, activated and positioned back on screen. Introducded yet more code to wxWindow::OnPaint to check for a canvas and make an additional call to paint the scroll bars. NOTE This looks like a
+ kludge!\par 
+\pard \li360\sa120 Repaired wxButton::GetLabel and wxCheckBox::GetLabel , wxMessage::SetLabel , wxScrollBar::GetLabel leaks. Also  wxRadioButton::GetLabel()\par 
+\pard \li360\sa120 \par 
+\pard\plain \s252\li360\sb120\sa120\keepn \b\f20\fs28 2/19/96 - Thomas Fettig's Fixes\par 
+\pard\plain \li360\sa120 \f20 Define USE_MAC_GRAY_LABEL_BACKGROUND in wx_setup.h if you like Grey backgrounds for your labels. Not defined by default. wxLabelArea.cc\par 
+Define some additional function keys and added some internationalization. Modfications to wx_app.cc, wx_txt.cc - Note that Tom points out a incompatiblity in wx_txt OnChar() with Matts code.\par 
+\pard \li360\sa120 Tom doesn't lke the +5 hack in wxMessage::CreateWxMessage - but hello.cc needs it? What to do?\par 
+\pard \li360\sa120 Add code to enable and disable multiline text mode in wx_text.cc,  wx_mtxt.cc - Doesn't work for me (Cecil)\par 
+Conditionally, add code to place StatusLines at the bottom of a frame. Visually I like it. Note that it resizes improperly in hello.c so its not compiled in by default. See wx_setup.h\par 
+\pard \li360\sa120 Added code to wx_panel.cc to help manage children (windows) deletion/destruction.\par 
+\pard \li360\sa120 Improved AreaSize'ing code in wx_win.  Worked fine for me before and after so I'm not sure what the problem or symptom is being fixed.\par 
+\pard \li360\sa120 Did not add all of Tom's modifications to the wx_win destructor since some of them interfered with the plugging of memory leaks that I did. More study is needed here.\par 
+Restore lost line in wb_item.cc and a lost patch to wx_util.cc (oops - I know I had it once).\par 
+\pard \li360\sa120 Released wxMac161d-a5 as soon as ftp.aiai cooperates.\par 
+}
\ No newline at end of file
diff --git a/src/wxmac/docs/wxmac doc/wxwin wxArea Class Inheritance b/src/wxmac/docs/wxmac doc/wxwin wxArea Class Inheritance
new file mode 100644
index 0000000..368b5ec
--- /dev/null
+++ b/src/wxmac/docs/wxmac doc/wxwin wxArea Class Inheritance	
@@ -0,0 +1,206 @@
+(This file must be converted with BinHex 4.0)
+:(RGiGfPZ)(Gi3A*PB5"$E'&cFb"*EQKPFQPdB@jMC3"%8PG(68436!%!!!!J!!!
+!$CQ,Bd459dG%-J!"!!-!!!%X!5`!N!3,i!MmrhlrJ`aL#AN$C`8S!r`!!J!!!5`
+",!#3"![J#2`!!3!!!'3!!!!"!!%"!3!!!!%R$`!"!!%!N!d#!"N"N!!!N!9!!*!
+*!3#3%3J!I3")!!!!5!#3#!%"!*"[!3!'!!B!!J!'!!B!03!l!!J!N!N"!!%!!!!
+b!!!!!J#3#4`!!!"r!!!!-`!!!C`!!!!D!!!!Q`!!!$%!!!'i!*!&-J#3"4`!!!!
+4J!!#*S!!!JQ!!!!F!!!!I`!!!$-!!!'F!*!&-J#3"4`!!!!4J!!#*S!!!JQ!!!!
+F!!!!I`!!!$-!!!'F!*!&N!!!!!")!!!!U!!!!&3!!!!N!*!AJ!!!!!J!!!%8!*!
++"Q`!!!*!!!!!#!#3$bC!)J#3"MqmFFFFFFFF!!JJ!*!%!8!'V9UeDY@V2pD6k6k
+6k6m!#L%$!!!!!6ri!*!'2q99N!B!$#!"!!!!!6rL*%L4)N5*2r`iiiiiiii!!5%
+$!!!!!8!Fc*!&c6r"aaaaaaab!"3J!*!%!6r1Z&(VK4ki3"#UN!@V!5`J!*!%'`!
+"!!!!!3!"!!!!!3!#!!!!!J!#!!!!!3!%!!!!"!!%!!!!!3!'!!!!"J!'!!!!!3!
+)!!!!#!!)!!!!!3!+!!!!#J!+!!!!!3!*!!!!#3#3&3%!'`!!!!N!N"8"!")!!!!
+5!*!9!3!f!!!!%J#3&3%!5!!!!!N!!!!*!!!!#3#3$3%!5!!!!!N!!!!*!!!!#3!
+!!!N!!!!*!*!&!3!"!!`!!!!%!*!&$3!#!!`!!!!$!*!&!3!$!!B!!!!'!*!&!3!
+%!!`!!!!&!*!&!3!&!!8!!!!&!*!&!3!'!!-!!!!$!!!!$`!3!!`!!`!!!!`!N!F
+"!"F!%J!$!!!!%J#3#3%!N!Fb!*!,-[q3"!#3$4`!!!"r!!!!-`!!!C`!!!!F!!!
+!%B!!!LD!!!)*J!#3$K`!!!"r!!!!-`!!!C`!!!!F!!!!%B!!!LD!!!)*J!!!j)c
+S!!!'3!!!!!J(6'&jCA)M-3!!!3J!!!!-!!!!"!#3r``!!!!"!!!!#!!!!3J!!!"
+d!!!!"!!!!$!!!!"F!!!!L!!!!,3!!!$J!!!"$!!!!6J!!!&`!!!"U!!!!H!!!!)
+-!!!#4!!!!R`!!!,J!!!#Y!!!!aJ!!!0%!!!$I!!!!q!!!!1S!!!%$!!!"$J!!!4
+N!!!&$!!!"03!!!5F!*!'"6J!N)i&C!!!!!%!!!!X!!!!#!#3"3B!!3!"!!!!"J#
+3"3Irr`!3!!`!%!!-rrm!!!!"!!!!,!!!!!`!N!8)!!%!!3!!!!J!N!8*rrm!%!!
+-!"!!$2rr!!!!!3!!!#`!!!!3!*!&#!!"!!%!!!!)!*!&#Irr!"!!$!!3!!aam!!
+!!!%!!!!X!!!!&!#3"3J!!3!"!!!!#!#3"3Rrr`!3!!`!%!!-rrm!!!!"!!!!,!!
+!!"J!N!8-!!%!!3!!!!`!N!80rrm!%!!-!"!!$2rr!!!!!3!!!#`!!!!F!*!&$!!
+"!!%!!!!-!*!&$Irr!"!!$!!3!!c3%!!!!!%!!!!X!!!!)!#3"3X!!3!"!!!!#`#
+3"3crr`!3!!`!%!!-&c!!!!!"!!!!1!!#!!)!!C)J!*!&!iCN!"8!!!!$KQ3!"ZC
+`!*!&"ZC`!!1'C!!'jR!!"`c)!!!!!3!!!$J!!J!#!!,2'3#3#4-!!!!h!!!!#a"
+d!!`Y$`!1C@)!$91h!"'k8!!1HPm!!!!"!!!!1!!#!!)!!&6K!*!*&3!!!$d!!!!
+6[N8!,S9*!""T"`![U`F!$42*!$$3a3!!!!%!!!!X!!!!*!#3"3N!!3!"!!!!#3#
+3"3Vrr`!3!!`!%!!-)f!!!!!"!!!!1!!#!!)!!Y$B!*!*'3!!!%S!!!!4*F-!$$V
+C!"4mVJ!0@kd!&p1C!!jmJ3!!!!%!!!!i!!)!!J!!JUm!N!NF!!!!-J!!!"J[Y`!
+MqEJ!&4aI!#@bS!!5#3F!*fZ)!!!!!3!!!$J!!J!#!!'5)!#3"31'C!!B!!!!!iC
+N!!RQF!#3"3RQF!!$KQ3!#HC`!!F-b!!!!!%!!!!X!!!!+!#3"3J!!3!"!!!!#!#
+3"3Rrr`!3!!`!%!!-!*!&!3!!!$J!!J!#!!$U4!#3#4S!!!!8!!!!%2N[!!LEmJ!
+1d[`!#fFc!!bXb3!1-R3!!!!"!!!!,!!!!#`!N!8-!!%!!3!!!!`!N!80rrm!%!!
+-!"!!$!#!!!!!!3!!!$J!!J!#!!'5)!#3"31'C!!8!!!!!iCN!!AQF!#3"3AQF!!
+$KQ3!"HC`!!F-b!!!!!%!!!!X!!!!-!#3"3F!!3!"!!!!"`#3"3Mrr`!3!!`!%!!
+-0K!!!!!"!!!!1!!#!!(rricG!*!*(!!!!$S!!!!5XKd!#bT0!"AHa!!-XT`!'3Y
+V!!ikk`!!!!%!!!!X!!!!0!#3"3B!!3!"!!!!"J#3"3Irr`!3!!`!%!!-hGd!!!!
+"!!!!,!!!!$J!N!8+!!%!!3!!!!S!N!8,rrm!%!!-!"!!$&"!!!!!!3!!!#`!!!!
+m!*!&#3!"!!%!!!!*!*!&#[rr!"!!$!!3!!`!N!8"!!!!1!!#!!)!!C)J!*!&!iC
+N!"3!!!!$KQ3!"HC`!*!&"HC`!!1'C!!&jR!!"`c)!!!!!3!!!$J!!J!#!!'5)!#
+3"31'C!!A!!!!!iCN!!MQF!#3"3MQF!!$KQ3!#1C`!!F-b!!!!!%!!!!i!!)!!J!
+"NL!!N!8$KQ3!&`!!!!1'C!!)jR!!N!8)jR!!!iCN!!MQF!!($-J!!!!"!!!!,!!
+!!%!!N!8)!!%!!3!!!!J!N!8*rrm!%!!-!"!!$&pJ!!!!!3!!!#`!!!"%!*!&(J!
+"!!%!!!!H!!!!!3!Irrm!&`!5!"F!%J#3"!%)!!!!5!!!!!3!!!!8!!!!*!!!!$3
+!!!"%!!!!@!!!!'`!!!#!!!!!P!!!!+3!!!#i!!!!b!!!!0J!!!$X!!!"!!!!!4!
+!N-)"1!!!!!%!!!!3GhK"FQ9Krrm!!!!"!!!!%(Gi9fPZC'ph!!!!!3!!!""hH%e
+KFQGTEJ!!!!%!!!!3GhK2BQTPBh3!!!!"!!!!&(Gi3QpbC'9b3A*PB3!!!!%!!!!
+8GhK6Bh*[E'a"FQ9K!!!!!3!!!"4hH%aKBQ9X3A*PBIm!!!!"!!!!&(GiBPGTEQ4
+[G`#3"J%!!!!3GhK#Eh*NCA)!!!!"!!!!&(Gi8Q9MG%*[FQ4PFJ!!!!%!!!!3GhK
+L5A4PE3#3"!%!!!!3GhK*G'9Y!*!&!3!!!"4hH'*0CA0cB@GP!,3!!!!"!!!!&(G
+i6@9cFf&RC3#3"J%!!!!3GhK0BA*RD@i!!!!"!!!!+&GTEQ4[Gb`J3A*PB5"$E'&
+cFb"*EQKPFQPdC@jMC3!!!!)!!2rN!!!!Ci!!!3@!!!#8J!!"B)!!!!-"!3!'!!8
+!N!QAJ!!!IB!!!-5!!!$BJ!!!'J#3#B!!N!@AJ!!!IB!!!-5!!!$BJ!!!!`%"!!B
+!"3#3#DJ!!!#3!!!!!,J!!!$!!!"!!3%!N!J)!*!&Q!!!!(i!!!$%!!!!f!!!!"X
+!N!Q!!*!&T)!!!AQ!!!$4J!!"e)!!!!-"!3!'!!8!N!PZ!!!!(3!!!(i!!!"C!!"
+!!3#3#4!!N!9`!!!"&!!!!)!!!!&3!!"!!3%!N!J8!*!&ei!!!"+!!!%%J!!!EB!
+!!"S!N!Q!!*!&ei!!!"+!!!%%J!!!EB!!!!-"!3!'!!8!N!RQ!!!!%`!!!2B!!!"
+X!!"!!3#3#4J!N!AB!!!!%`!!!33!!!"Y!!!!'`#3#B!!N!ABJ!!!Hi!!!3@!!!$
+@J!!!'J#3#B!!N!ABJ!!!Hi!!!3@!!!$@J!!!!`%"!!B!"3#3#HF!!!"q!!!!p`!
+!!03!!%!"!3#3#"`!N!AC!!!!I!!!!38!!!$@!!!!'`#3#B!!N!ABJ!!!hi!!!3@
+!!!%kJ!!!'J#3#B!!N!ABJ!!!hi!!!3@!!!%kJ!!!!`%"!!B!"3#3#HF!!!$N!!!
+!p`!!!68!!%!"!3#3##!!N!AC!!!!i!!!!38!!!%k!!!!'`#3#B!!N!A$J!!!T2Q
+F!0Q!!!#Y"Q4!!J%"!!B!N!8N!*!&a)!!!&f!!!$BJ!!!PB!!3#)"!3!'!*!&+!#
+3"F1!!!$0J!!!fB!!!3Z!!%!#!3%!"J#3"5`!N!ASJ!!"H)!!!4@!!!(6J!!!!`%
+"!!B!"3#3#IF!!!'&!!!""`!!!FJ!!%!"!3#3#!`!N!@d!!!"KJ!!!-3!!!(3!!"
+!!3%!N!J`!*!&Ni!!!0L!!!#YJ!!")i!!3#)"!3!'!*!&0!#3"C5!!!&(J!!!XB!
+!!AU!!%!#!3%!"J#3"6J!N!A3J!!"S[QF!1Q!!!'V"Q4!!J%"!!B!N!8m!*!%!5k
+!!!'ZJ!!"@i!!!JQ!!!!$!3%!"J!&!*!)!6m!!!'k!!!"6`!!!Im!!%!"!*!*4!#
+3"!%8J!!"aB!!!5q!!!(DJ!"!!J%"!!B!N!9!!*!%!@k!!!'ZJ!!"Qi!!!JQ!!!!
+$!3%!"J!&!*!)!Ad!!!'`!!!"M3!!!JJ!!%!"!*!*5!#3"!&DJ!!"erQF!@q!!!(
+J"Q4!!J%"!!B!N!9-!*!%!6'!!!%HJ!!"AS!!!AQ!!!!$!3%!"J!&!*!)!8!!!!%
+a!!!"8!!!!@J!!%!"!3#3#&!!N!3"&)!!!8H!!!%aJ!!"JS!!3%)"!3!'!*!&@!#
+3"!&aJ!!"))!!!Ck!!!&lJ!!!!`%"!!B!"3#3#!'!!!!"0J!!!C!!!!!"CJ!!3!%
+"!*!)9!#3"!'eJ!!")B!!!H+!!!&mJ!!!!`%"!!B!"3#3#!(jJ!!")S!!!LD!!!&
+pJ!!!!`%"!!B!"3#3#!(%!!!"+J!!!G3!!!&h!!"!!3#3#9`!N!3#"`!!!6!!!!)
+A!!!"GJ!!3!%"!*!)B!#3"!&GJ!!"5IQF!A+!!!&5"Q4!!J%"!!B!N!9N!*!%!Cq
+!!!&*qC`"Yi!!!9)'C%!#!3%!"J#3"@`!N!3"iB!!!8RjR!(jJ!!"8JCN3!)"!3!
+'!*!&F!#3"9q!!!!4J!!!M)!!!'b!!!!$!3%!"J!&!*!*E`!!!"m!!!"r!!!!@`!
+!3!%"!*!)D!#3"4`!!!"r!!!!-`!!!C`!!%!"!3#3#(J!N!3JE'PZC6SJ-6Jh,#"
+cDATP1L!a$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!d-!dJ)(GLAh9
+dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-6)0)#"hBPpeG'PXFbjMBb"XD@jP1L!
+a1$FX)(0THQ8k)$B0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-0)#"
+hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$%b$5!JGf*IGA4TE(-ZBf-JE'P
+ZC6SJ-6Jh,#"cDATP1L!e$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!
+c-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0
+M)'aTEQ8k)$%i0b`JFfPkC6SJ-6)0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0
+THQ8k)$80)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-c$5!JGf*IGA4
+TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6J
+h,#"cDATP1L!e$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!b-`dJ)(G
+LAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8
+k)$%i0b`JFfPkC6SJ-6)0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$8
+0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-c$5!JGf*IGA4TE(-ZBf-
+JE'PZC6SJ-6Jh,#"cDATP1L!c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDAT
+P1L!a-JdJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ03dJ)(GLAh9dD@a
+c,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-c-0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$F
+X)(0THQ8k)$%0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-0)#"hBPp
+eG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$80)#"hBPpeG'PXFbjMBb"XD@jP1L!
+a1$FX)(0THQ8k)$3a$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c$5!
+JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!a-JdJ)(GLAh9dD@ac,Q0M)'a
+TEQ8k)$%i0b`JFfPkC6SJ03dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6S
+J-c-0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-0)#"hBPpeG'PXFbj
+MBb"XD@jP1L!a1$FX)(0THQ8k)$%b$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"
+cDATP1L!e$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c-`dJ)(GLAh9
+dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%
+i0b`JFfPkC6SJ03dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-M-0)#"
+hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$N0)#"hBPpeG'PXFbjMBb"XD@j
+P1L!a1$FX)(0THQ8k)$N0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$%
+0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$%c$5!JGf*IGA4TE(-ZBf-
+JE'PZC6SJ-6Jh,#"cDATP1L!a-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfP
+kC6SJ0JdJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ13dJ)(GLAh9dD@a
+c,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ13dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`
+JFfPkC6SJ-3dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-6%0)#"hBPp
+eG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-0)#"hBPpeG'PXFbjMBb"XD@jP1L!
+a1$FX)(0THQ8k)$%b$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!e$5!
+JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c-`dJ)(GLAh9dD@ac,Q0M)'a
+TEQ8k)$%i0b`JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6S
+J-6)0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$80)#"hBPpeG'PXFbj
+MBb"XD@jP1L!a1$FX)(0THQ8k)$-c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"
+cDATP1L!c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!e$5!JGf*IGA4
+TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!b-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%
+i0b`JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-6)0)#"
+hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$80)#"hBPpeG'PXFbjMBb"XD@j
+P1L!a1$FX)(0THQ8k)$-c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!
+c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!a-JdJ)(GLAh9dD@ac,Q0
+M)'aTEQ8k)$%i0b`JFfPkC6SJ03dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfP
+kC6SJ-c-0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$%0)#"hBPpeG'P
+XFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$-0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$F
+X)(0THQ8k)$80)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$3a$5!JGf*
+IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c$5!JGf*IGA4TE(-ZBf-JE'PZC6S
+J-6Jh,#"cDATP1L!a-JdJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ03d
+J)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-c-0)#"hBPpeG'PXFbjMBb"
+XD@jP1L!a1$FX)(0THQ8k)$-0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8
+k)$%b$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!e$5!JGf*IGA4TE(-
+ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!c-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`
+JFfPkC6SJ-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ03dJ)(GLAh9
+dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ-M-0)#"hBPpeG'PXFbjMBb"XD@jP1L!
+a1$FX)(0THQ8k)$N0)#"hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$N0)#"
+hBPpeG'PXFbjMBb"XD@jP1L!a1$FX)(0THQ8k)$%0)#"hBPpeG'PXFbjMBb"XD@j
+P1L!a1$FX)(0THQ8k)$%c$5!JGf*IGA4TE(-ZBf-JE'PZC6SJ-6Jh,#"cDATP1L!
+a-`dJ)(GLAh9dD@ac,Q0M)'aTEQ8k)$%i0b`JFfPkC6SJ0JdJ)(GLAh9dD@ac,Q0
+M)'aTEQ8k)(!J!!!"!!!!#p-!!!V6!!!"aJSJQ6&4!!3LAdje5LJ!%'F!!FK)E[r
+FU*LSRNS'C`!!(RGiGfPZ)(Gi3A*PB5"$E'&cFb"*EQKPFQPdB@jMC@N!!%459dG
+04&"-3!#3&kdQG6`!N!B0Q8BJ8b"S!"`J8!a3!!*R1#mZrrS[,[rf5&HSF%K[!!5
+SF&P25'm!"+SR)"p36e92,`")E[r%5'lr[M!m$"QUSNSIC`44l[rr@8qSf#4A,8V
+rBUKk5'lrpUKl)&8J8#mS!"`[#LmS!"bSj'%!!3*+"QF'5'lra+S95'lrpLm%U,)
+JEJ#3"&KN"3)*!#N!!`'`!P!!!!!"!!%!!3!"!!)!!J!"!!%!!3!'!!8!!`!-!*!
+(!J#3"J)S!!!#fCQD!!!!4`!!!8-!N!S#fCQD!LJ!N!9)!*",%[q3%J!!!*!!!!%
+!!!!"!!!K!*!-#!!"!!%!!!!"!!!J!!-!N!S+!!)!!%!!!!%!!#%#!3#3#J`!!`!
+"!!!!-J!!)!!$!*!+!3!%!!)!!!!"!!!K!*!-&!!&!!%!!!!"!!!K!*!,!5`!"J!
+!!*!!!!%!!!!"!!!J!*!-#!!"!!%!!!!"!!!K!!-!N!S+!!)!!%!!!!%!!#!#!3#
+3#J`!!`!"!!!!-J!!)3!$!*!+!3!%!!)!!!!"!!!J!*!-&!!&!!%!!!!"!!!J!*!
+,!5`!"J!!!*!!!!!!*N!L!*!'2laaaaaaaa`!##%!N!3"3!DY@V9UeDXreT2T2T2
+T2`!+)!-!!!!"2rJ!N!Brj9@3"J!-)3%!!!!"2q)N5*%L4)Nrr$MMMMMMMJ!")!-
+!!!!"3"c-N!A02m(((((((()!&#%!N!3"2mki8HZ&(VK!%+U3"DX",#%!N!3`!!%
+!!!)!!!%!!J!!!J!!!J!%!!!#!!!$!!B!!!)!!!3!#!!!!J!!"3!+!!!#!!!'!!!
+!R!!*!!!!#3#3%`%!'`!!!!N!N"-#!")!!!!5!*!6!`!f!!!!%J#3%`3!5!!!!!N
+!!!!*!!!!#3#3#`8!5!!!!!N!!!!*!!!!#3!!!!N!!!!*!!!!"J!!!$`!$!!!!!3
+!!!!"!!`!!!!$!!!!!J!'!!!!"J!!!!-!$!!!!!8!!!!%!!8!!!!&!!!!"3!$!!!
+!!`!!!!B!!!!D!!!`!!)%!"X!!!!H!*!%`!#3$!J!!!!"!!!!!3!!!!i!!3!!!3!
+!!J#3#C,rN!J26@&TEL"%D@0dD@pZBA*j!*!`$e9cCA)J4'PMG'P[EQ&bH3#3-2`
+Cr"N!!3#3"`J!!!!$!*!("`C(C@jPGQ%!!!$8!*!&"3!!!!B!!!!+!!!!#`!!!!`
+!!!!0!!!!$J!!!!m!!!!3!!!!%3!!!")!!!!6!!!!&!!!!"8!!!!@!!!!&`!!!"J
+!!!!C!!!!'J!!!"X!!!!F!!!!(3!!!"i!!!!I!!!!)!!!!#%!!!!L!!!!)`!!!#3
+!!!!P!!!!*J!!!#F!!!!S!!!!+3!!!#S!!!!V!!!!,!!!!#d!!!!Z!!!!,`!!!$!
+!!!!a!!!!-J!!!$-!!!!d!!!!03!!!$B!!!!h!!!!1!!!!$N!!!!k!!!!1`#3"!,
+%!!!!!AJm(Jq(`q(`!!!!!BK%)K')4#)4!!!!!E[ZhAHllYeh!!!!!F`cCTR--fD
+C!!!!%3#3#ahrN!J!!!!"IrrrrrIrrrm!!!!"Irrhrhrrprm!!!!"GrrGrhIrhIm
+!!!!$GpehhAIGGpd!!!!$UP@U9DT9UP8!!!!$L#+))SJLL#)!!!!$L!!L!)J!)J#
+3"!1!!!J!J!!)!*!%!i!!!!!)!*!'!B#!36i)#"6M!!!!!Iq!J)$r#!J)!!!!!B&
+#*"L"3L3B!!!!!B"!)"!)"!)"!!!!!H"`1"`1"i2"!!!!!AHlhHjhZphZ!!!!!BK
+%)K')4#)4!!!!!CR-CM1Cc'Bc!!!!!5"!J!!)"!)!N!3"r`$r!2m!r`#3"!(r!!!
+!r`#3"J(-!!!!-`#3"J(`N!32N!3!!!!"riL)L2q)L)J!!!!"UN5U%DT%UK%!!!!
+"!3)%#"!J3)!!!!!"J`F1($K`i-%!!!!"lYflGqlGZhF!!!!"%5*%L"%L4)J!!!!
+"-fE-Q60Qc*N!!!!"3+!!!!3+!*!&!DU3#!!!!!')N!J!!!!"!3%3%!%"%"!!!!!
+"!!J8+P8U&!J!!!!"ri#3"`!!!!'#4#J3+%5#!3!!!!'!!*!+!B!3!L!"#%!%!!!
+!!DS!UJ#U!+S!N!3"9Ip9reAr9Im!!!!"hIphrphrGrm!!!!"UJ#!!)J!J!#3"!%
+)(#,"J!%#"!!!!!'a-!-Ef-!-M3!!!!')&#*"L!#U!*!%!B*%185#!3%"!!!!!31
+%5$!-!J%"!!!!!9@J3%"9#J3%!!!!!4!J9+Vr!J3)!!!!!5"3L*!%"3)!!!!"[`#
+r[l#3"!!!!!(iG#*(MaFLF3!!!!&hLBq2GjMiq!!!!)!!!!!"!!ArN!B!!!!H!!!
+!!3!'!*!*)3!!!!%!$0eV#-)'SJ!!!-d!!!!"!!S!!)!!%E!!!!&9!!!!!3!,!*!
+%e!!!!!'C!!!!!3!2r!$cI38[!!!!43!!!!%!$3*"Ue6Ur`!!!4%!!!!"!!lbe`K
+@K1`!!!#*!*!(jJ!%!*!!!1!!N!6rrqqI"NaKH@peG""8GA*Z)%&eG'pRFQPN)%p
+Z!*!%#e0SEhFJ8R9XCA*c!*!%$P0SEhFJ4h*TC'aTEQ9c!*!%#90SEhFJ8fPkC3#
+3"""6D'ph)&"KCf8J3R*PB@Yc!*!%!5d!N!3(6'&jCA*cb3#3"!G5G@aPFR2*!*!
+%#9"KG(4PFQjcb3#3"!a3FQ9QCA*PEQ0PFmN!N!304(*KGfPZCb"6DATPb3#3"!%
+Y!*!%$8CTG#"8Eb"AD@jNEhF!63!!#90PG#"@D@9hb3#3#*%!"`"A!,!!N!6rrrc
+r"%C[ER3(3fKTBf&RE`#3"!G$Eh9bD@9b!*!%"NGPEQ9fB3!!%J!*5'9XGQ9dD@0
+K!*!%"Ne[EQ&ME`#3"!K1CAFJ@@pbD`#3"!98D@ePF`#3"!C@C@jTBf8!N!3",3#
+3"!C'EfjdFmN!N!3*8f9d)&0dH@aP!*!)X3!)rj!%!*!%rrrGr`46DATP"cNJ8'p
+TER3!!!!)!M%`!!!!#!)a-J!!%JJ#-63!!!!)!M%i!!!!#!)b0!!!!!J#-cB!!!!
+)!M3i!!!!#!%Y!*!%$&0TEQGXC5"6F'&MC3!!%J!-4'peBQaP)&0`B@0P!*!%#c)
+JF(3Z)&0`B@0P!*!%!5d!N!3,4QpZG#"6DATPFmN!N!306'PZC5"6F'&MD@jRb3#
+3"`%!!!!,d`!!#Y-!!!('!1"S@"S8!!!!(!('!"0%D@jQ!!!!SN4fGh-!!!#Z4(0
+dE!!!!,T5Fh3b!!!!aP*cCA3!!!$54&*eE!!!!0j3Ff9d!!!!kN4cCA3!!!$f3A0
+PG!!!!3*3FQ9Q!!!"$RK3FQB!!!%DF&"bCJ!!!5Cc8(*Q!!!"-NCYG(J!!!%q4Qj
+YF`!!!8T`BA45!!!"9Q*KGe!!!!&L3h4LE!!!!@jMEfa3!!!"HNe&6P8!!J''!3$
+rr`#3"H5+r!%!rrm!!!"F!15-*!%!rrm!!!#S!15,C!%!rrm!!!#q!*!%!3$rr`!
+!!9)!j)[S!3$rr`!!!HB!j)[`!3$rr`!!!RS!j)[d!3$rr`!!!Ui!j)YJ!3$rr`!
+!!di!j)`!!3$rr`!!!ii!j)ai!3$rr`!!!k`!j)[3!3$rr`!!!lJ!j)[B!3$rr`!
+!!mS!j)[)!3$rr`!!"'!!j)cJ!3$rr`!!"'`!j)cF!3$rr`!!"(F!j)c-!3$rr`!
+!"8m!j)c)!3$rr`!!#"F!j)c%!3$rr`!!#*X!j)c!!32rr`!!#*m!j)[!!3Err`!
+!#BN!j)cB!3Irr`!!#Ki!j)c3!4d:
diff --git a/src/wxmac/include/base/common.h b/src/wxmac/include/base/common.h
new file mode 100644
index 0000000..c4cb850
--- /dev/null
+++ b/src/wxmac/include/base/common.h
@@ -0,0 +1,482 @@
+/*
+ * File:	common.h
+ * Purpose:	Declarations/definitions common to all wx source files
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)common.h	1.2 5/9/94" */
+
+#ifndef wxb_commonh
+#define wxb_commonh
+
+#include <stddef.h>
+#include <string.h>
+#include "wx_setup.h"
+#include "wx_ver.h"
+
+//////////////////////////////////////////////////////////////////////////////////
+// Currently Only MS-Windows/NT, XView and Motif are supported
+//
+#if defined(wx_hp) && !defined(wx_motif) && !defined(wx_xview)
+# define wx_motif
+#endif
+#if defined(wx_xview) || defined(wx_motif)
+# define wx_x
+#elif defined(macintosh) || defined(applec) || defined(__MWERKS__)
+	// the Mac test must come before the MS-Windows test because __WINDOWS__
+	// is defined whenever the Apple <Windows.h> file is included
+#	ifndef wx_mac
+#		define wx_mac
+#	endif
+#	ifndef PYLIB
+#		ifndef GUSI
+#			define GUSI
+#		endif
+#	endif
+#elif defined(__WINDOWS__) || defined(__WINDOWS_386__) || defined(__NT__) || defined(__MSDOS__) 
+# ifndef wx_msw
+#  define wx_msw
+# endif
+#endif
+
+// Make sure the environment is set correctly
+#if defined(wx_msw) && defined(wx_x)
+# error "Target can't be both X and Windows"
+#elif defined(wx_xview) && defined(wx_motif)
+# error "Target can't be both XView and Motif!"
+#elif !defined(wx_xview) && !defined(wx_motif) && !defined(wx_msw) && !defined(wx_mac)
+# error "No Target! Use -D[wx_motif|wx_xview|wx_msw|wx_mac]"
+#endif
+
+#ifdef wx_motif
+  typedef int Bool;
+# define TRUE  1
+# define FALSE 0
+# define Bool_DEFINED
+#endif
+#if defined(wx_xview)
+# define Bool int
+# define True  1
+# define False 0
+# define TRUE  1
+# define FALSE 0
+# define Bool_DEFINED
+#endif
+#if defined(wx_msw)
+# include <windows.h>
+# ifndef Bool
+   typedef int Bool;
+#  define Bool_DEFINED
+# endif
+#endif
+#ifdef wx_mac
+typedef int Bool;
+#define Bool_DEFINED
+#endif
+
+#ifndef TRUE
+# define TRUE  1
+# define FALSE 0
+#endif
+
+// wxWindows checks for WIN32, not __WIN32__
+#if (defined(__WIN32__) && !defined(WIN32))
+#define WIN32
+#endif
+
+typedef short int WXTYPE;
+
+// Styles for wxListBox - Yes, all in Multiple , and nothing in Style
+#define wxMULTIPLE_MASK     0x03
+#define wxSINGLE            0x00
+#define wxMULTIPLE          0x01
+#define wxEXTENDED          0x02
+
+#define wxSB_MASK           0x08
+#define wxNEEDED_SB         0x00
+#define wxALWAYS_SB         0x08
+
+// Frame/dialog/subwindow style flags
+#define wxVSCROLL           0x00000001
+#define wxHSCROLL           0x00000002
+#define wxCAPTION           0x00000004
+// Hint to Windowing system not to try anything clever: ***OBSOLETE***
+#define wxABSOLUTE_POSITIONING  8
+
+// Frame/dialog style flags
+#define wxSTAY_ON_TOP       0x00000008
+#define wxICONIZE           0x00000010
+#define wxMINIMIZE          wxICONIZE
+#define wxMAXIMIZE          0x00000020
+#define wxSDI               0x00000040
+#define wxMDI_PARENT        0x00000080
+#define wxMDI_CHILD         0x00000100
+#define wxTHICK_FRAME       0x00000200
+#define wxSYSTEM_MENU       0x00000400
+#define wxMINIMIZE_BOX      0x00000800
+#define wxMAXIMIZE_BOX      0x00001000
+#define wxTINY_CAPTION_HORIZ 0x00002000
+#define wxTINY_CAPTION_VERT 0x00004000
+#define wxRESIZE_BOX       wxMAXIMIZE_BOX
+#define wxRESIZE_BORDER	    0x00800000
+
+#define wxDEFAULT_FRAME    (wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxTHICK_FRAME | wxSYSTEM_MENU | wxCAPTION)
+
+// Subwindow style flags
+#define wxBORDER           0x00000040
+#define wxRETAINED         0x00000080
+#define wxEDITABLE         0x00000200
+#define wxREADONLY         0x00000400
+
+// wxText style flags
+#define wxPROCESS_ENTER    0x00001000
+#define wxPASSWORD         0x00002000
+
+// Use native implementation, e.g. Text EDIT control for wxTextWindow
+// under MSW
+#define wxNATIVE_IMPL      0x01000000
+// Extended (or simply alternative) implementation, e.g. large
+// but not editable wxTextWindow under Windows
+#define wxEXTENDED_IMPL    0x02000000
+// Override CTL3D etc. control colour processing to
+// allow own background colour
+#define wxUSER_COLOURS     0x04000000
+#define wxVERTICAL_LABEL   0x08000000
+
+#ifndef wx_motif
+# define wxFLAT            wxBORDER
+# define wxBACKINGSTORE    0x00000000
+# define wxMOTIF_RESIZE    0x00000000
+#else
+# define wxFLAT            0x00000100
+# define wxBACKINGSTORE    0x00004000
+# define wxMOTIF_RESIZE    0x01000000
+#endif
+
+// Effect of this flags: when creating wxItem with labels and/or value,
+// say new wxText(...,"label",...,"init_value"), the item is created with
+// strings containing only '0' ("00000" and "0000000000" in the exemple),
+// then SetLabel/SetValue are called. This make alignement more easy:
+//
+// LabelPosition(wxHORIZONTAL)
+// new wxText("label    ","initval1")
+// NewLine()
+// new wxText("longlabel","initval2")
+//
+// the 2 texts are EXACTLY aligned...
+//
+// Please note that:
+//   - I choose '0' as constant character, because it has a mean width.
+//   - This style is useful only if LabelPosition is wxHorizontal...
+#define wxFIXED_LENGTH          0x00020000
+
+// Enhanced Dialog styles
+// Command area placment
+#define wxBOTTOM_COMMANDS       0x00000000
+#define wxRIGHT_COMMANDS        0x00040000
+#define wxMASK_COMMANDS         0x00040000
+// Status Area
+#define wxSTATUS_FOOTER         0x00000000
+#define wxNO_STATUS_FOOTER      0x00080000
+#define wxMASK_STATUS           0x00080000
+// Cancel Button/Pushpin Emulation
+#define wxNO_CANCEL_BUTTON      0x00000000
+#define wxCANCEL_BUTTON_FIRST   0x00100000
+#define wxCANCEL_BUTTON_LAST    0x00200000
+#define wxCANCEL_BUTTON_SECOND  0x00300000
+#define wxMASK_CANCEL           0x00300000
+
+#if MOTIF_MANAGE && defined(wx_motif)
+#define wxDEFAULT_DIALOG_STYLE	(wxMOTIF_RESIZE|wxSYSTEM_MENU|wxCAPTION|wxTHICK_FRAME)
+#else
+#define wxDEFAULT_DIALOG_STYLE	(wxSYSTEM_MENU|wxCAPTION|wxTHICK_FRAME)
+#endif
+
+#ifdef wx_motif
+#define       wxENH_DEFAULT   (wxCAPTION|wxMOTIF_RESIZE|wxBOTTOM_COMMANDS|wxSTATUS_FOOTER|wxNO_CANCEL_BUTTON)
+#elif defined(wx_xview)
+# define wxENH_DEFAULT   (wxBOTTOM_COMMANDS|wxSTATUS_FOOTER|wxNO_CANCEL_BUTTON)
+#elif defined(wx_msw)
+# define wxENH_DEFAULT   (wxRIGHT_COMMANDS|wxSTATUS_FOOTER|wxCANCEL_BUTTON_SECOND)
+#elif defined(wx_mac)
+# define wxENH_DEFAULT 0L
+#else
+#error "Only Motif, XView and MS-Windows/Windows-NT platforms are currently supported"
+#endif
+#define wxCOLOURED             0x00400000
+
+
+// GDI descriptions
+
+enum {
+// Text font families
+  wxDEFAULT    = 70,
+  wxDECORATIVE,
+  wxROMAN,
+  wxSCRIPT,
+  wxSWISS,
+  wxMODERN,
+  wxTELETYPE,  /* @@@@ */
+  wxSYSTEM,
+
+// Proportional or Fixed width fonts (not yet used)
+  wxVARIABLE   = 80,
+  wxFIXED,
+
+  wxNORMAL     = 90,
+  wxLIGHT,
+  wxBOLD,
+// Also wxNORMAL for normal (non-italic text)
+  wxITALIC,
+  wxSLANT,
+
+// Pen styles
+  wxSOLID      =   100,
+  wxDOT,
+  wxLONG_DASH,
+  wxSHORT_DASH,
+  wxDOT_DASH,
+  wxUSER_DASH,
+
+  wxTRANSPARENT,
+
+// Brush & Pen Stippling. Note that a stippled pen cannot be dashed!!
+// Note also that stippling a Pen IS meaningfull, because a Line is
+// drawn with a Pen, and without any Brush -- and it can be stippled.
+  wxSTIPPLE =          110,
+  wxBDIAGONAL_HATCH,
+  wxCROSSDIAG_HATCH,
+  wxFDIAGONAL_HATCH,
+  wxCROSS_HATCH,
+  wxHORIZONTAL_HATCH,
+  wxVERTICAL_HATCH,
+#define IS_HATCH(s)	((s)>=wxBDIAGONAL_HATCH && (s)<=wxVERTICAL_HATCH)
+  wxOPAQUE_STIPPLE,
+
+  wxJOIN_BEVEL =     120,
+  wxJOIN_MITER,
+  wxJOIN_ROUND,
+
+  wxCAP_ROUND =      130,
+  wxCAP_PROJECTING,
+  wxCAP_BUTT
+};
+
+
+// Logical ops
+typedef enum {
+  wxCLEAR,      // 0
+  wxXOR,        // src XOR dst
+  wxINVERT,     // NOT dst
+  wxOR_REVERSE, // src OR (NOT dst)
+  wxAND_REVERSE,// src AND (NOT dst)
+  wxCOPY,       // src
+  wxAND,        // src AND dst
+  wxAND_INVERT, // (NOT src) AND dst
+  wxNO_OP,      // dst
+  wxNOR,        // (NOT src) AND (NOT dst)
+  wxEQUIV,      // (NOT src) XOR dst
+  wxSRC_INVERT, // (NOT src)
+  wxOR_INVERT,  // (NOT src) OR dst
+  wxNAND,       // (NOT src) OR (NOT dst)
+  wxOR,         // src OR dst
+  wxSET,        // 1
+  wxSRC_OR,     // source _bitmap_ OR destination
+  wxSRC_AND,     // source _bitmap_ AND destination
+  wxCOLOR
+} form_ops_t;
+
+// Flood styles
+#define  wxFLOOD_SURFACE   1
+#define  wxFLOOD_BORDER    2
+
+// Polygon filling mode
+#define  wxODDEVEN_RULE    1
+#define  wxWINDING_RULE    2
+
+// Directions
+#define wxHORIZONTAL     0x01
+#define wxVERTICAL       0x02
+#define wxBOTH           (wxVERTICAL|wxHORIZONTAL)
+#define wxCENTER_FRAME   0x04  /* centering into frame rather than screen */
+
+// ToolPanel in wxFrame
+#define	wxTOOL_TOP	   1
+#define	wxTOOL_BOTTOM	   2
+#define	wxTOOL_LEFT	   3
+#define	wxTOOL_RIGHT	   4
+
+// Dialog specifiers/return values
+// Unfortunately const's cause too many 'defined but not used'
+// in GCC.
+// messages. So we're returning to defines for now.
+/*
+const wxOK =                0x0001;
+const wxYES_NO =            0x0002;
+const wxCANCEL =            0x0004;
+const wxYES =               0x0008;
+const wxNO =                0x0010;
+
+const wxICON_EXCLAMATION =  0x0020;
+const wxICON_HAND =         0x0040;
+const wxICON_QUESTION =     0x0080;
+const wxICON_INFORMATION =  0x0100;
+*/
+
+#define wxOK                0x0001
+#define wxYES_NO            0x0002
+#define wxCANCEL            0x0004
+#define wxYES               0x0008
+#define wxNO                0x0010
+
+#define wxICON_EXCLAMATION  0x0020
+#define wxICON_HAND         0x0040
+#define wxICON_QUESTION     0x0080
+#define wxICON_INFORMATION  0x0100
+
+#define wxICON_STOP         wxICON_HAND
+#define wxICON_ASTERISK     wxICON_INFORMATION
+#define wxICON_MASK         (0x0020|0x0040|0x0080|0x0100)
+
+#define wxCENTRE            0x0200
+#define wxCENTER wxCENTRE
+
+// Use internally-calculated width if -1
+#define wxSIZE_AUTO_WIDTH       1
+// Use internally-calculated height if -1
+#define wxSIZE_AUTO_HEIGHT      2
+// Use internally-calculated width and height if each is -1
+#define wxSIZE_AUTO             3
+// Use internally-calculated x if -1
+
+// -1 as x/y position really means -1; don't use default
+#define wxPOS_USE_MINUS_ONE 4
+
+// Ignore missing (-1) dimensions (use existing).
+// For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code.
+#define wxSIZE_USE_EXISTING     0
+
+// Clipboard formats
+#ifdef wx_msw
+# define wxCF_TEXT               CF_TEXT
+# define wxCF_BITMAP             CF_BITMAP
+# define wxCF_METAFILE           CF_METAFILEPICT
+# define wxCF_DIB                CF_DIB
+# define wxCF_OEMTEXT            CF_OEMTEXT
+#else
+# define wxCF_TEXT               1
+# define wxCF_BITMAP             2
+# define wxCF_METAFILE           3
+# define wxCF_DIB                4
+# define wxCF_OEMTEXT            5
+#endif
+
+// Virtual keycodes
+enum _Virtual_keycodes {
+ WXK_BACK    =   8,
+ WXK_TAB     =   9,
+ WXK_RETURN  =	13,
+ WXK_ESCAPE  =	27,
+ WXK_SPACE   =	32,
+ WXK_DELETE  = 127,
+
+ WXK_START   = 300,
+ WXK_LBUTTON,
+ WXK_RBUTTON,
+ WXK_CANCEL,
+ WXK_MBUTTON,
+ WXK_CLEAR,
+ WXK_SHIFT,
+ WXK_CONTROL,
+ WXK_MENU,
+ WXK_PAUSE,
+ WXK_CAPITAL,
+ WXK_PRIOR,
+ WXK_NEXT,
+ WXK_END,
+ WXK_HOME,
+ WXK_LEFT,
+ WXK_UP,
+ WXK_RIGHT,
+ WXK_DOWN,
+ WXK_SELECT,
+ WXK_PRINT,
+ WXK_EXECUTE,
+ WXK_SNAPSHOT,
+ WXK_INSERT,
+ WXK_HELP,
+ WXK_NUMPAD0,
+ WXK_NUMPAD1,
+ WXK_NUMPAD2,
+ WXK_NUMPAD3,
+ WXK_NUMPAD4,
+ WXK_NUMPAD5,
+ WXK_NUMPAD6,
+ WXK_NUMPAD7,
+ WXK_NUMPAD8,
+ WXK_NUMPAD9,
+ WXK_MULTIPLY,
+ WXK_ADD,
+ WXK_SEPARATOR,
+ WXK_SUBTRACT,
+ WXK_DECIMAL,
+ WXK_DIVIDE,
+ WXK_F1,
+ WXK_F2,
+ WXK_F3,
+ WXK_F4,
+ WXK_F5,
+ WXK_F6,
+ WXK_F7,
+ WXK_F8,
+ WXK_F9,
+ WXK_F10,
+ WXK_F11,
+ WXK_F12,
+ WXK_F13,
+ WXK_F14,
+ WXK_F15,
+ WXK_F16,
+ WXK_F17,
+ WXK_F18,
+ WXK_F19,
+ WXK_F20,
+ WXK_F21,
+ WXK_F22,
+ WXK_F23,
+ WXK_F24,
+ WXK_NUMLOCK,
+ WXK_SCROLL,
+ WXK_PAGEUP,
+ WXK_PAGEDOWN 
+};
+
+// Colours - see wx_gdi.cc for database
+
+// OS mnemonics -- Identify the running OS (useful for Windows)
+// [Not all platforms are currently available or supported]
+enum {
+  wxCURSES,
+  wxXVIEW_X,	// Sun's XView OpenLOOK toolkit
+  wxMOTIF_X,	// OSF Motif 1.x.x
+  wxCOSE_X,	// OSF Common Desktop Environment
+  wxNEXTSTEP,	// NeXTStep
+  wxMACINTOSH,	// Apple System 7
+  wxGEOS,	// GEOS
+  wxOS2_PM,	// OS/2 Workplace
+  wxWINDOWS,	// Windows or WfW
+  wxPENWINDOWS,	// Windows for Pen Computing
+  wxWINDOWS_NT,	// Windows NT
+  wxWIN32S,	// Windows 32S API
+  wxWIN386	// Watcom 32-bit supervisor modus
+};
+
+const int kActiveControl = 0;
+const int kInactiveControl = 255;
+
+#define IMPLEMENT_DYNAMIC_CLASS(x, y) /* empty */
+
+#endif // wxb_commonh
diff --git a/src/wxmac/include/base/wb_buttn.h b/src/wxmac/include/base/wb_buttn.h
new file mode 100644
index 0000000..86e6a07
--- /dev/null
+++ b/src/wxmac/include/base/wb_buttn.h
@@ -0,0 +1,59 @@
+/*
+ * File:	wb_buttn.h
+ * Purpose:	Buttons
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_buttn.h	1.2 5/9/94" */
+
+#ifndef wxb_buttnh
+#define wxb_buttnh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbButton ;
+#else
+
+// Pushbutton
+class wxBitmap;
+class wxbButton: public wxItem
+{
+ public:
+
+  wxbButton(void);
+  wxbButton(wxPanel *panel, wxFunction func, char *label, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "button");
+  wxbButton(wxPanel *panel, wxFunction func, wxBitmap *bitmap, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "button");
+#ifdef wx_mac
+  wxbButton (wxPanel* parentPanel, int x, int y,
+  		int width, int height, long	style, char* windowName);
+#endif
+  ~wxbButton(void);
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+#ifdef wx_mac
+  virtual void SetDefault(Bool flag = TRUE) = 0;
+#else // wx_mac
+  virtual void SetDefault(void) = 0;
+#endif // wx_mac
+  // Avoids compiler warning
+  inline  void SetLabel(char *label) { wxItem::SetLabel(label) ; }
+  virtual void SetLabel(wxBitmap *bitmap) = 0;
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_buttnh
diff --git a/src/wxmac/include/base/wb_canvs.h b/src/wxmac/include/base/wb_canvs.h
new file mode 100644
index 0000000..36ac285
--- /dev/null
+++ b/src/wxmac/include/base/wb_canvs.h
@@ -0,0 +1,150 @@
+/*
+ * File:	wb_canvs.h
+ * Purpose:	wxCanvas subwindow declarations
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ *  7/3/95 pulled in some 16.2 changes - Cecil Coupe
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_canvs.h	1.2 5/9/94" */
+
+#ifndef wxb_canvsh
+#define wxb_canvsh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef IN_CPROTO
+#	ifndef wx_mac
+#		include <iostream.h>
+#	endif // wx_mac
+#endif
+#include "common.h"
+#include "wx_frame.h"
+#include "wx_gdi.h"
+#include "wx_dccan.h"
+#include "wx_stdev.h"
+
+#ifdef IN_CPROTO
+typedef void *wxbCanvas ;
+#else
+
+// Canvas subwindow for drawing on
+class wxbCanvas: public wxWindow
+{
+ public:
+  wxCanvasDC *wx_dc;    // The canvas's device context
+
+  Bool is_retained;
+  int horiz_units;
+  int vert_units;
+
+#ifndef wx_mac
+  wxbCanvas(void);
+  wxbCanvas(wxWindow *frame, int x=-1, int y=-1, int width=-1, int height=-1,
+           long style = wxRETAINED, char *name = "canvas");
+#endif
+#ifdef wx_mac
+  // Constructor (given parentArea)
+  wxbCanvas(char* windowName, wxArea* parentArea, int x, int y, int width, int height,
+		long		style);
+  // Constructor (given parentWindow)
+  wxbCanvas(char* windowName, wxWindow*	parentWindow, int x, int y, int width, int height,
+		long		style);
+#endif // wx_mac
+
+  virtual ~wxbCanvas(void);
+
+  virtual void AllowDoubleClick(int value) ;
+
+  void OnChar(wxKeyEvent& event);
+
+  // Number of pixels per user unit (0 or -1 for no scrollbar)
+  // Length of virtual canvas in user units
+  // Length of page in user units
+  virtual void SetScrollbars(int horizontal, int vertical,
+                             int x_length, int y_length,
+                             int x_page, int y_page,
+#ifdef wx_mac
+                             int x_pos = 0, int y_pos = 0, Bool automgmt = TRUE
+#else
+                             int x_pos = 0, int y_pos = 0,
+#endif
+           				) = 0;
+
+  // Scroll the canvas
+  virtual void Scroll(int x_pos, int y_pos) = 0;
+  virtual void ViewStart(int *x, int *y) = 0;
+  virtual void GetScrollUnitsPerPage(int *x_page, int *y_page) = 0;
+
+  virtual void BeginDrawing(void) {} ;
+  virtual void EndDrawing(void) {} ;
+
+  virtual void FloodFill(float x1, float y1, wxColour *col, int style=wxFLOOD_SURFACE) ;
+  virtual Bool GetPixel(float x1, float y1, wxColour *col) ;
+
+  virtual void DrawLine(float x1, float y1, float x2, float y2);
+  virtual void IntDrawLine(int x1, int y1, int x2, int y2);
+  virtual void CrossHair(float x, float y) ;
+  virtual void DrawArc(float x1,float y1,float x2,float y2,float xc,float yc);
+  virtual void DrawPoint(float x, float y);
+  virtual void DrawLines(int n, wxPoint points[], float xoffset = 0, float yoffset = 0);
+  virtual void DrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0);
+  virtual void DrawLines(wxList *list, float xoffset = 0, float yoffset = 0);
+  virtual void DrawPolygon(int n, wxPoint points[], float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE);
+  virtual void DrawPolygon(wxList *list, float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE);
+  virtual void DrawRectangle(float x, float y, float width, float height);
+  virtual void DrawRoundedRectangle(float x, float y, float width, float height, float radius = 20);
+  virtual void DrawEllipse(float x, float y, float width, float height);
+
+#if USE_SPLINES
+  // Splines
+  // 3-point spline
+  virtual void DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3);
+  // Any number of control points - a list of pointers to wxPoints
+  virtual void DrawSpline(wxList *points);
+#endif
+
+  virtual void Clear(void);
+  virtual void SetFont(wxFont *font);
+  virtual void SetPen(wxPen *pen);
+  virtual void SetBrush(wxBrush *brush);
+  virtual void SetLogicalFunction(int function);
+  virtual void SetBackground(wxBrush *brush);
+  virtual void SetTextForeground(wxColour *colour);
+  virtual void SetTextBackground(wxColour *colour);
+  virtual void SetClippingRegion(float x, float y, float width, float height);
+  virtual void GetClippingRegion(float *x, float *y, float *width, float *height);
+  virtual void DestroyClippingRegion(void);
+  virtual void DrawText(const char *text, float x, float y, Bool use16 = FALSE);
+
+  // Actual size in pixels when scrolling is taken into account
+  virtual void GetVirtualSize(int *x, int *y) = 0;
+  virtual float GetCharHeight(void);
+  virtual float GetCharWidth(void);
+  virtual void GetTextExtent(const char* string, float* x, float* y, 
+  				float* descent = NULL, float* externalLeading = NULL, wxFont* the_font = NULL, Bool use16=FALSE);
+  // Gets 'context' member
+  virtual wxCanvasDC *GetDC(void);
+
+  virtual void SetColourMap(wxColourMap *cmap) = 0;
+
+  // Enable/disable Windows 3.1 scrolling in either direction.
+  // If TRUE, wxWindows scrolls the canvas and only a bit of
+  // the canvas is invalidated; no Clear() is necessary.
+  // If FALSE, the whole canvas is invalidated and a Clear() is
+  // necessary. Disable for when the scroll increment is used
+  // to actually scroll a non-constant distance
+  virtual void EnableScrolling(Bool x_scrolling, Bool y_scrolling) = 0;
+
+  Bool IsRetained(void) { return is_retained; }
+
+  virtual void WarpPointer(int x_pos, int y_pos) = 0 ;
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_canvsh
diff --git a/src/wxmac/include/base/wb_check.h b/src/wxmac/include/base/wb_check.h
new file mode 100644
index 0000000..556f1a5
--- /dev/null
+++ b/src/wxmac/include/base/wb_check.h
@@ -0,0 +1,61 @@
+/*
+ * File:	wb_check.h
+ * Purpose:	Check boxes
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_check.h	1.2 5/9/94" */
+
+#ifndef wxb_checkh
+#define wxb_checkh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef void  *wxbCheckBox ;
+#else
+
+// Checkbox item (single checkbox)
+class wxBitmap ;
+class wxbCheckBox: public wxItem
+{
+ public:
+
+  wxbCheckBox(void);
+  wxbCheckBox(wxPanel *panel, wxFunction func, char *Title,
+             int x = -1, int y = -1, int width = -1, int height = -1,
+             long style = 0, char *name = "checkBox");
+  wxbCheckBox(wxPanel *panel, wxFunction func, wxBitmap *bitmap,
+             int x = -1, int y = -1, int width = -1, int height = -1,
+             long style = 0, char *name = "checkBox");
+
+#ifdef wx_mac
+  // Constructor (given parentPanel)
+  wxbCheckBox(wxPanel* parentPanel, int x, int y, int width, int height,
+		long style, char* windowName);
+#endif // wx_mac
+
+  ~wxbCheckBox(void);
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+  virtual void SetValue(Bool) = 0;
+  virtual Bool GetValue(void) = 0;
+  // Avoids compiler warning
+  inline void SetLabel(char *label) { wxItem::SetLabel(label) ; }
+  virtual void SetLabel(wxBitmap *bitmap) = 0;
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_checkh
diff --git a/src/wxmac/include/base/wb_choic.h b/src/wxmac/include/base/wb_choic.h
new file mode 100644
index 0000000..26fb47b
--- /dev/null
+++ b/src/wxmac/include/base/wb_choic.h
@@ -0,0 +1,55 @@
+/*
+ * File:	wb_choic.h
+ * Purpose:	Choice items
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_choic.h	1.2 5/9/94" */
+
+#ifndef wxb_choich
+#define wxb_choich
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbChoice ;
+#else
+
+// Choice item
+class wxbChoice: public wxItem
+{
+ public:
+  int no_strings;
+
+  wxbChoice(void);
+  wxbChoice(wxPanel *panel, wxFunction func, char *Title,
+           int x = -1, int y = -1, int width = -1, int height = -1,
+           int N = 0, char **Choices = NULL,
+           long style = 0, char *name = "choice");
+
+  ~wxbChoice(void);
+
+  virtual void Append(char *Item) = 0;
+  virtual void Clear(void) = 0;
+  virtual int GetSelection(void) = 0;
+  virtual void SetSelection(int n) = 0;
+  virtual int FindString(char *s) = 0;
+  virtual char *GetStringSelection(void);
+  virtual Bool SetStringSelection(char *s);
+  virtual char *GetString(int n) = 0;
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_choich
diff --git a/src/wxmac/include/base/wb_dc.h b/src/wxmac/include/base/wb_dc.h
new file mode 100644
index 0000000..7d2b85d
--- /dev/null
+++ b/src/wxmac/include/base/wb_dc.h
@@ -0,0 +1,237 @@
+/*
+ * File:	wb_dc.h
+ * Purpose:	wxDC device context declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_dc.h	1.2 5/9/94" */
+
+
+#ifndef wxb_dch
+#define wxb_dch
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef IN_CPROTO
+#include <fstream.h>
+#endif
+#include "common.h"
+#include "wx_frame.h"
+#include "wx_gdi.h"
+
+#define wxDEVICE_CANVAS  1
+                            // X canvas
+#define wxDEVICE_EPS     2
+                            // Encapsulated PostScript on any platform
+#define wxDEVICE_WINDOWS 3
+                            // MS Windows device (canvas, printer)
+#define wxDEVICE_PIXMAP  4
+                            // X pixmap
+
+#if defined(wx_x) || defined(wx_mac)
+#define MM_TEXT        1
+#define MM_ISOTROPIC   2
+#define MM_ANISOTROPIC 3
+#define MM_LOMETRIC    4
+#define MM_HIMETRIC    5
+#define MM_TWIPS       6
+#endif
+
+#define MM_POINTS      7
+#define MM_METRIC      8
+
+#ifdef IN_CPROTO
+typedef       void    *wxbDC ;
+#else
+
+class wxCanvas;
+class wxCanvasDC;
+class wxDC;
+class wxbDC: public wxObject
+{
+ public:
+  int device;
+  Bool ok;
+  Bool clipping;
+  Bool wx_interactive;
+
+  // Coordinate system variables
+  float logical_origin_x;
+  float logical_origin_y;
+
+  float device_origin_x;
+  float device_origin_y;
+
+  float logical_scale_x;
+  float logical_scale_y;
+
+  float user_scale_x;
+  float user_scale_y;
+
+  int mapping_mode;
+
+  float min_x;          // bounding box
+  float min_y;
+  float max_x;
+  float max_y;
+  char *title;
+
+  Bool Colour;
+
+  int current_logical_function;
+  int current_bk_mode;
+
+  wxPen *current_pen;
+  wxBrush *current_brush;
+  wxBrush *current_background_brush;
+  wxColour current_text_foreground;
+  wxColour current_text_background;
+  wxFont *font;
+  Bool autoSetting ;
+
+  wxbDC(void);
+
+  // Create a printer DC
+//  wxDC(char *driver, char *device, char *output, Bool interactive = TRUE);
+
+  ~wxbDC(void);
+
+  //
+  // This function is intended to improves drawing, by avoiding to
+  // repeatly call ::SetPen/::SetBrush. If set to FALSE, these functions
+  // aren't called when calling ::DrawLine(),...
+  // Please note that this is YOUR responsability to use it, and do it
+  // only when you KNOWN that pen/brush isn't changed between 2 calls to
+  // DrawLine,... !!!
+  // Note also that in X, we don't test autoSetting on brushes, because they
+  // modify Foreground, as pens. So, convention is:
+  //   - call your SetBrush(), THEN your SetPen, THEN AutoSetTools(FALSE)
+  //   - call DrawLine,...
+  // [mainly coded for Windows]
+  inline virtual void AutoSetTools(Bool auto_setting) { autoSetting = auto_setting ; }
+ 
+  inline virtual void BeginDrawing(void) {} ;
+  inline virtual void EndDrawing(void) {} ;
+
+  virtual void FloodFill(float x1, float y1, wxColour *col, int style=wxFLOOD_SURFACE) = 0;
+  virtual Bool GetPixel(float x1, float y1, wxColour *col) = 0;
+
+  virtual void DrawLine(float x1, float y1, float x2, float y2) = 0;
+  virtual void IntDrawLine(int x1, int y1, int x2, int y2) = 0;
+  virtual void CrossHair(float x, float y) = 0;
+  virtual void DrawArc(float x1,float y1,float x2,float y2,float xc,float yc)=0;
+  virtual void DrawPoint(float x, float y) = 0;
+  inline virtual void DrawPoint(wxPoint& point) { DrawPoint(point.x, point.y); }
+  virtual void DrawLines(int n, wxPoint points[], float xoffset = 0, float yoffset = 0) = 0;
+  virtual void DrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0) = 0;
+  virtual void DrawLines(wxList *list, float xoffset = 0, float yoffset = 0);
+  virtual void DrawPolygon(int n, wxPoint points[], float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE) = 0;
+  virtual void DrawPolygon(wxList *list, float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE);
+  virtual void DrawRectangle(float x, float y, float width, float height) = 0;
+  virtual void DrawRoundedRectangle(float x, float y, float width, float height, float radius = 20) = 0;
+  virtual void DrawEllipse(float x, float y, float width, float height) = 0;
+#if USE_SPLINES
+  // Splines
+  // 3-point spline
+  virtual void DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3);
+  // Any number of control points - a list of pointers to wxPoints
+  virtual void DrawSpline(wxList *points);
+  virtual void DrawSpline(int n, wxPoint points[]);
+#endif
+  virtual void DrawIcon(wxIcon *icon, float x, float y) = 0;
+  virtual void DrawText(const char *text, float x, float y, Bool use16 = FALSE) = 0;
+  virtual void Clear(void) = 0;
+
+  virtual Bool StartDoc(char *message) = 0;
+  virtual void EndDoc(void) = 0;
+  virtual void StartPage(void) = 0;
+  virtual void EndPage(void) = 0;
+
+  virtual void SetFont(wxFont *font) = 0;
+  virtual void SetPen(wxPen *pen) = 0;
+  virtual void SetBrush(wxBrush *brush) = 0;
+  virtual void SetLogicalFunction(int function) = 0;
+  virtual void SetBackground(wxBrush *brush) = 0;
+  virtual void SetTextForeground(wxColour *colour);
+  virtual void SetTextBackground(wxColour *colour);
+  virtual void SetBackgroundMode(int mode); // wxSOLID or wxTRANSPARENT
+                                            // for drawing background colour
+  virtual void SetClippingRegion(float x, float y, float width, float height)= 0;
+  virtual void GetClippingRegion(float *x, float *y, float *width, float *height)= 0; // mflatt
+  inline virtual void SetColourMap(wxColourMap *cmap) {};
+  virtual void DestroyClippingRegion(void) = 0;
+
+  virtual float GetCharHeight(void) = 0;
+  virtual float GetCharWidth(void) = 0;
+  virtual void GetTextExtent(const char* string, float* x, float* y, float* descent = NULL,
+  						float* externalLeading = NULL, wxFont* the_font = NULL, Bool use16=FALSE) = 0;
+  inline virtual Bool Ok(void) {return ok;};
+  virtual void SetMapMode(int mode) = 0;
+  inline virtual int  GetMapMode(void) {return mapping_mode;};
+
+  // The following methods provide a cleaner interface
+  inline virtual wxBrush *GetBackground(void)      { return current_background_brush ;}
+  inline virtual wxBrush *GetBrush(void)           { return current_brush ;}
+  inline virtual wxFont  *GetFont(void)            { return font ;}
+  inline virtual int      GetLogicalFunction(void) { return current_logical_function ;}
+  inline virtual wxPen   *GetPen(void)             { return current_pen ;}
+  inline virtual wxColour&GetTextBackground(void)  { return current_text_background ;}
+  inline virtual wxColour&GetTextForeground(void)  { return current_text_background ;}
+ 
+  virtual void SetLogicalOrigin(float x, float y);
+  virtual void SetDeviceOrigin(float x, float y);
+  virtual void SetLogicalScale(float x, float y);
+  virtual void SetUserScale(float x, float y) = 0;
+  virtual float DeviceToLogicalX(int x) = 0;
+  virtual float DeviceToLogicalY(int y) = 0;
+  virtual float DeviceToLogicalXRel(int x) = 0;
+  virtual float DeviceToLogicalYRel(int y) = 0;
+  virtual int LogicalToDeviceX(float x) = 0;
+  virtual int LogicalToDeviceY(float y) = 0;
+  virtual int LogicalToDeviceXRel(float x) = 0;
+  virtual int LogicalToDeviceYRel(float y) = 0;
+  // Only works for PostScript *after* you've printed an image.
+  // Gives width and height of image.
+  virtual void GetSize(float *width, float *height);
+  virtual void CalcBoundingBox(float x, float y);
+  // Get the final bounding box of the PostScript or Metafile picture.
+  virtual inline float MinX(void) { return min_x; }
+  virtual inline float MaxX(void) { return max_x; }
+  virtual inline float MinY(void) { return min_y; }
+  virtual inline float MaxY(void) { return max_y; }
+  virtual Bool Blit(float xdest, float ydest, float width, float height,
+            wxCanvasDC *source, float xsrc, float ysrc, int rop = wxCOPY) = 0;
+            
+    virtual void TryColour(wxColour *src, wxColour *dest);
+};
+
+extern char wx_printer_file[];
+extern float wx_printer_scale_x;
+extern float wx_printer_scale_y;
+extern float wx_printer_translate_x;
+extern float wx_printer_translate_y;
+extern int wxPageNumber;
+
+// Conversion
+#define METRIC_CONVERSION_CONSTANT  0.0393700787
+
+// Scaling factors for various unit conversions
+#define mm2inches (METRIC_CONVERSION_CONSTANT)
+#define inches2mm (1/METRIC_CONVERSION_CONSTANT)
+
+#define mm2twips (METRIC_CONVERSION_CONSTANT*1440)
+#define twips2mm (1/(METRIC_CONVERSION_CONSTANT*1440))
+
+#define mm2pt (METRIC_CONVERSION_CONSTANT*72)
+#define pt2mm (1/(METRIC_CONVERSION_CONSTANT*72))
+
+#define     wx_round(a)    (int)((a)+.5)
+
+
+#endif // IN_CPROTO
+#endif // wxb_dch
diff --git a/src/wxmac/include/base/wb_dccan.h b/src/wxmac/include/base/wb_dccan.h
new file mode 100644
index 0000000..83daf6c
--- /dev/null
+++ b/src/wxmac/include/base/wb_dccan.h
@@ -0,0 +1,41 @@
+/*
+ * File:	wb_dccan.h
+ * Purpose:	Base canvas device context declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_dccan.h	1.2 5/9/94" */
+
+
+#ifndef wxb_dccanh
+#define wxb_dccanh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef IN_CPROTO
+#include <fstream.h>
+#endif
+#include "common.h"
+#include "wx_dc.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbCanvasDC ;
+#else
+
+class wxbCanvasDC: public wxDC
+{
+ public:
+  inline wxbCanvasDC(void) { }
+  inline wxbCanvasDC(wxCanvas *the_canvas) { }
+
+  inline ~wxbCanvasDC(void) { }
+};
+
+#endif // IN_CPROTO
+#endif // wxb_dccanh
+
diff --git a/src/wxmac/include/base/wb_dcmem.h b/src/wxmac/include/base/wb_dcmem.h
new file mode 100644
index 0000000..4cd728f
--- /dev/null
+++ b/src/wxmac/include/base/wb_dcmem.h
@@ -0,0 +1,43 @@
+/*
+ * File:	wb_dcmem.h
+ * Purpose:	Base memory device context declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_dcmem.h	1.2 5/9/94" */
+
+
+#ifndef wxb_dcmemh
+#define wxb_dcmemh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef IN_CPROTO
+#include <fstream.h>
+#endif
+#include "common.h"
+#include "wx_dc.h"
+#include "wx_dccan.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbMemoryDC ;
+#else
+
+class wxbMemoryDC: public wxCanvasDC
+{
+ public:
+  inline wxbMemoryDC(void) { }
+  inline wxbMemoryDC(wxCanvasDC *old_dc) {} // Create compatible DC
+
+  inline ~wxbMemoryDC(void) { }
+  virtual void SelectObject(wxBitmap *bitmap) = 0;
+};
+
+#endif // IN_CPROTO
+#endif // wx_dcmemh
+
diff --git a/src/wxmac/include/base/wb_dialg.h b/src/wxmac/include/base/wb_dialg.h
new file mode 100644
index 0000000..d5d7a81
--- /dev/null
+++ b/src/wxmac/include/base/wb_dialg.h
@@ -0,0 +1,115 @@
+/*
+ * File:	wb_dialg.h
+ * Purpose:	wxDialogBox and common dialog declarations
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_dialg.h	1.2 5/9/94" */
+
+#ifndef wxb_dialgh
+#define wxb_dialgh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbDialogBox ;
+#else
+
+// Dialog boxes
+#ifdef wx_mac
+class wxbDialogBox: public wxFrame
+#else
+class wxbDialogBox: public wxPanel
+#endif
+{
+ public:
+  Bool modal;
+  Bool is_show;
+
+  wxbDialogBox(void);
+  wxbDialogBox(wxWindow *parent, char *title, Bool modal = FALSE,
+              int x = -1, int y = -1,
+              int width = -1, int height = -1, long style = wxDEFAULT_DIALOG_STYLE, char *name = "panel");
+  ~wxbDialogBox();
+
+  Bool Create(wxWindow *window, char *title, Bool modal = FALSE,
+              int x = -1, int y = -1,
+              int width = -1, int height = -1, long style = wxDEFAULT_DIALOG_STYLE, char *name = "panel");
+
+  virtual void Iconize(Bool iconize) = 0;
+  virtual Bool Iconized(void) = 0;
+
+  void Centre(int direction = wxBOTH);
+};
+
+// Handy dialog functions
+char *wxGetTextFromUser(char *message, char *caption = "Input text",
+                        char *default_value = "", wxWindow *parent = NULL,
+                        int x = -1, int y = -1, Bool centre = TRUE);
+
+#define wxCHOICE_HEIGHT 150
+#define wxCHOICE_WIDTH 200
+
+char *wxGetSingleChoice(char *message, char *caption,
+                        int n, char *choices[], wxWindow *parent = NULL,
+                        int x = -1, int y = -1, Bool centre = TRUE,
+                        int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT);
+
+// Same as above but gets position in list of strings, instead of string,
+// or -1 if no selection
+int wxGetSingleChoiceIndex(char *message, char *caption,
+                           int n, char *choices[], wxWindow *parent = NULL,
+                           int x = -1, int y = -1, Bool centre = TRUE,
+                           int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT);
+
+// Return client data instead
+char *wxGetSingleChoiceData(char *message, char *caption,
+                            int n, char *choices[], char *client_data[],
+                            wxWindow *parent = NULL, int x = -1, int y = -1,
+                            Bool centre = TRUE,
+                            int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT);
+                           
+int wxGetMultipleChoice(char *message, char *caption,
+			  int n, char *choices[], 
+			  int nsel, int * selection,
+			  wxWindow *parent = NULL, int x = -1 , int y = -1, Bool centre = TRUE,
+			  int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT);
+
+// type is an 'or' (|) of wxOK, wxCANCEL, wxYES_NO
+// Returns wxYES/NO/OK/CANCEL
+int wxbMessageBox(char *message, char *caption = "Message", long style = wxOK|wxCENTRE,
+  wxWindow *parent = NULL, int x = -1, int y = -1);
+
+#define wxOPEN 1
+#define wxSAVE 2
+#define wxOVERWRITE_PROMPT 4
+#define wxHIDE_READONLY 8
+#define wxDIR_ONLY	16
+#define wxFILES_ONLY 32
+
+// Generic file load dialog
+char * wxLoadFileSelector(char *what = "Text", char *extension = "txt", char *default_name = NULL);
+
+// Generic file save dialog
+char * wxSaveFileSelector(char *what = "Text", char *extension = "txt", char *default_name = NULL);
+// File selector
+char *wxFileSelector(char *message = "Select a file", char *default_path = NULL,
+                     char *default_filename = NULL, char *default_extension = NULL,
+                     char *wildcard = "*.*", int flags = 0,
+                     wxWindow *parent = NULL, int x = -1, int y = -1);
+// Select a Directory
+char *wxDirectorySelector(char *message = "Select a file", char *default_path = NULL,
+                     char *default_filename = NULL, char *default_extension = NULL,
+                     char *wildcard = "*.*", int flags = wxOPEN|wxDIR_ONLY,
+                     wxWindow *parent = NULL, int x = -1, int y = -1);
+
+#endif // IN_CPROTO
+#endif // wxb_dialgh
diff --git a/src/wxmac/include/base/wb_frame.h b/src/wxmac/include/base/wb_frame.h
new file mode 100644
index 0000000..aa91f20
--- /dev/null
+++ b/src/wxmac/include/base/wb_frame.h
@@ -0,0 +1,113 @@
+/*
+ * File:	wb_frame.h
+ * Purpose:	wxFrame declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_frame.h	1.2 5/9/94" */
+
+#ifndef wxb_frameh
+#define wxb_frameh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_win.h"
+#ifdef wx_mac
+#include "wx_screen.h"
+#endif
+#define wxMAX_STATUS   5
+
+#ifdef IN_CPROTO
+typedef       void    *wxbFrame ;
+#else
+
+class wxMenuBar;
+class wxPanel ;
+class wxStatusWnd;
+class wxFrame;
+class wxToolBar;
+class wxbFrame: public wxWindow
+{
+ public:
+  Bool modal_showing;
+  wxMenuBar *wx_menu_bar;
+  wxIcon *icon;
+  Bool status_line_exists;
+  long frame_type;  // SDI, MDI parent/child
+  int nb_status;
+
+  wxWindow *frameToolBar ;
+  
+  void *context;
+
+#ifndef wx_mac
+  wxbFrame(void);
+  wxbFrame(wxFrame *parent, char *title,
+          int x=-1, int y=-1, int width=-1, int height=-1,
+          long type = wxSDI | wxDEFAULT_FRAME, char *name = "frame");
+#endif 
+#ifdef wx_mac
+// Constructor (given parentScreen)
+  wxbFrame (char* windowName, wxScreen* parentScreen,
+		int x, int y, int width, int height, long style);
+#endif // wx_mac
+  ~wxbFrame(void);
+
+#ifndef wx_mac
+  Bool Create(wxFrame *parent, char *title,
+          int x=-1, int y=-1, int width=-1, int height=-1,
+          long type = wxSDI | wxDEFAULT_FRAME, char *name = "frame");
+#endif // wx_mac
+
+  // Override, e.g. to resize subwindows
+  void OnSize(int x, int y);
+
+  // The default thing is to set the focus for the first child window.
+  // Override for your own behaviour.
+  void OnActivate(Bool flag);
+
+  // Default behaviour is to display a help string for the menu item.
+  virtual void OnMenuSelect(int id);
+  inline virtual void OnMenuCommand(int id) {};         // Called on frame menu command ( 16.2)
+
+  // Set menu bar
+  virtual void SetMenuBar(wxMenuBar *menu_bar) = 0;			//  from 16.2
+  virtual wxMenuBar *GetMenuBar(void);
+
+  // Set icon
+  virtual void SetIcon(wxIcon *icon) = 0;
+
+  // Create status line
+  virtual void CreateStatusLine(int number = 1, char *name = "status_line") = 0;
+
+  // Set status line text
+  virtual void SetStatusText(char *text, int number = 0) = 0;
+  virtual Bool StatusLineExists(void);
+
+  void Centre(int direction = wxBOTH);
+
+  // Iconize
+  virtual void Iconize(Bool iconize) = 0;
+  virtual Bool Iconized(void) = 0;
+  // Windos 3.x maximize/restore
+  virtual void Maximize(Bool maximize) = 0;
+
+  virtual void LoadAccelerators(char *table) = 0;
+
+  // Call this to simulate a menu command
+  virtual void Command(int id);
+  virtual void ProcessCommand(int id);
+
+  // Toolbar (currently, for use by Windows MDI parent frames ONLY)
+  virtual inline void SetToolBar(wxToolBar *toolbar) { frameToolBar = (wxWindow *)toolbar; }
+  virtual inline wxToolBar *GetToolBar(void) { return (wxToolBar *)frameToolBar; }
+};
+
+#endif // IN_CPROTO
+#endif // wxb_frameh
diff --git a/src/wxmac/include/base/wb_gauge.h b/src/wxmac/include/base/wb_gauge.h
new file mode 100644
index 0000000..a6dc983
--- /dev/null
+++ b/src/wxmac/include/base/wb_gauge.h
@@ -0,0 +1,45 @@
+/*
+ * File:	wb_gauge.h
+ * Purpose:	Gauge box (experimental)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_group.h	1.2 5/9/94" */
+
+#ifndef wb_gaugeh
+#define wb_gaugeh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbGauge;
+#else
+
+// Group box
+class wxbGauge: public wxItem
+{
+ public:
+  wxbGauge(void);
+  wxbGauge(wxPanel *panel, char *label, int range, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "gauge");
+  ~wxbGauge(void);
+
+  virtual void SetShadowWidth(int w) = 0;
+  virtual void SetBezelFace(int w) = 0;
+  virtual void SetRange(int r) = 0;
+  virtual void SetValue(int pos) = 0;
+//  void SetButtonColour(int w) = 0;
+//  void SetBackgroundColour(int w) = 0;
+};
+
+#endif // IN_CPROTO
+#endif // wb_gaugeh
diff --git a/src/wxmac/include/base/wb_gdi.h b/src/wxmac/include/base/wb_gdi.h
new file mode 100644
index 0000000..c332849
--- /dev/null
+++ b/src/wxmac/include/base/wb_gdi.h
@@ -0,0 +1,463 @@
+/*
+ * File:	wb_gdi.h
+ * Purpose:	Declaration of various graphics objects - fonts, pens, icons etc.
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_gdi.h	1.2 5/9/94" */
+
+#ifndef wxb_gdih
+#define wxb_gdih
+
+#include "wx_obj.h"
+#include "wx_list.h"
+#include "wx_setup.h"
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifdef wx_mac
+#include <QuickDraw.h>
+#endif
+
+// Standard cursors
+typedef enum {
+ wxCURSOR_ARROW =  1,
+ wxCURSOR_BULLSEYE,
+ wxCURSOR_CHAR,
+ wxCURSOR_CROSS,
+ wxCURSOR_HAND,
+ wxCURSOR_IBEAM,
+ wxCURSOR_LEFT_BUTTON,
+ wxCURSOR_MAGNIFIER,
+ wxCURSOR_MIDDLE_BUTTON,
+ wxCURSOR_NO_ENTRY,
+ wxCURSOR_PAINT_BRUSH,
+ wxCURSOR_PENCIL,
+ wxCURSOR_POINT_LEFT,
+ wxCURSOR_POINT_RIGHT,
+ wxCURSOR_QUESTION_ARROW,
+ wxCURSOR_RIGHT_BUTTON,
+ wxCURSOR_SIZENESW,
+ wxCURSOR_SIZENS,
+ wxCURSOR_SIZENWSE,
+ wxCURSOR_SIZEWE,
+ wxCURSOR_SIZING,
+ wxCURSOR_SPRAYCAN,
+ wxCURSOR_WAIT,
+ wxCURSOR_WATCH,
+ wxCURSOR_BLANK
+#ifdef wx_x
+  /* Not yet implemented for Windows */
+  , wxCURSOR_CROSS_REVERSE,
+  wxCURSOR_DOUBLE_ARROW,
+  wxCURSOR_BASED_ARROW_UP,
+  wxCURSOR_BASED_ARROW_DOWN
+#endif
+} _standard_cursors_t;
+
+#ifdef IN_CPROTO
+typedef       void *wxbFont;
+typedef       void *wxColour;
+typedef       void *wxPoint;
+typedef       void *wxbPen;
+typedef       void *wxbBrush;
+typedef       void *wxPenList;
+typedef       void *wxBrushList;
+typedef       void *wxColourDatabase;
+typedef       void *wxGDIList;
+typedef       void *wxDash ;
+#else
+
+#ifdef wx_mac
+typedef    char wxDash ;
+#endif
+
+#ifdef wx_msw
+typedef    DWORD  wxDash ;
+#endif
+
+#ifdef wx_x
+typedef    char wxDash ;
+#endif
+
+// Font
+class wxFont;
+class wxbFont: public wxObject
+{
+ protected:
+  Bool temporary;   // If TRUE, the pointer to the actual font
+                    // is temporary and SHOULD NOT BE DELETED by
+                    // destructor
+  int point_size;
+  int family;
+  int fontid; // mflatt
+  int style;
+  int weight;
+  Bool underlined;
+ public:
+  wxbFont(void);
+  wxbFont(int PointSize, int FontOrFamily, int Style, int Weight, Bool underline = FALSE);
+  ~wxbFont(void);
+
+  inline int GetPointSize(void) { return point_size; }
+  inline int GetFamily(void) { return family; }
+  inline int GetFontId(void) { return fontid; } // mflatt
+  inline int GetStyle(void) { return style; }
+  inline int GetWeight(void) { return weight; }
+  char *GetFamilyString(void);
+  char *GetFaceString(void); // mflatt
+  char *GetStyleString(void);
+  char *GetWeightString(void);
+  inline Bool GetUnderlined(void) { return underlined; }
+};
+
+class wxFontNameDirectory : public wxObject
+{
+  class wxHashTable *table;
+  int nextFontId;
+ public:
+  wxFontNameDirectory(void);
+  ~wxFontNameDirectory();
+  void Initialize(void);
+  char *GetScreenName(int fontid, int weight, int style);
+  char *GetPostScriptName(int fontid, int weight, int style);
+  char *GetAFMName(int fontid, int weight, int style);
+
+  void Initialize(int fontid, int family, const char *name);
+  int GetNewFontId(void);
+  
+  int FindOrCreateFontId(const char *name, int family); 
+
+  int GetFontId(const char *name);
+  char *GetFontName(int fontid);
+  int GetFamily(int fontid);
+};
+
+extern wxFontNameDirectory wxTheFontNameDirectory;
+
+// Colour
+class wxColour: public wxObject
+{
+ private:
+  Bool isInit;
+  unsigned char red;
+  unsigned char blue;
+  unsigned char green;
+ public:
+#ifdef wx_x
+  int pixel;
+#endif
+#ifdef wx_msw
+  COLORREF pixel ;
+#endif
+#ifdef wx_mac
+  RGBColor pixel;
+#endif
+
+  int locked;
+  inline Bool IsMutable(void) { return !locked; }
+  inline void Lock(int d) { locked += d; }
+
+  wxColour(void);
+  wxColour(unsigned char r, unsigned char b, unsigned char g);
+  wxColour(const char *col);
+  ~wxColour(void) ;
+  wxColour& operator =(wxColour& src) ;
+  wxColour& operator =(const char *src) ;
+  inline int Ok(void)
+#ifdef wx_x
+//    { return (isInit && (pixel != -1)) ; } // Can't be right -- pixel can't
+                                             // always be initialized!
+    { return (isInit) ; }
+#else
+    { return (isInit) ; }
+#endif
+
+  void Set(unsigned char r, unsigned char b, unsigned char g);
+  void Get(unsigned char *r, unsigned char *b, unsigned char *g);
+
+  inline unsigned char Red(void) { return red; }
+  inline unsigned char Green(void) { return green; }
+  inline unsigned char Blue(void) { return blue; }
+};
+
+#define wxColor wxColour
+
+class wxColourMap;
+
+
+// Point
+#if (!USE_TYPEDEFS)
+class wxPoint: public wxObject
+{
+ public:
+  float x;
+  float y;
+  wxPoint(void);
+  wxPoint(float the_x, float the_y);
+  ~wxPoint(void);
+};
+#else
+typedef struct {
+                float x ;
+                float y ;
+               } wxPoint ;
+#endif
+
+#if (!USE_TYPEDEFS)
+class wxIntPoint: public wxObject
+{
+ public:
+  int x;
+  int y;
+  wxIntPoint(void);
+  wxIntPoint(int the_x, int the_y);
+  ~wxIntPoint(void);
+};
+#else
+typedef struct {
+                int x ;
+                int y ;
+               } wxIntPoint ;
+#endif
+
+
+// Pen
+class wxPen;
+class wxBitmap;
+class wxbPen: public wxObject
+{
+ protected:
+  int width;
+  int style;
+  int join ;
+  int cap ;
+  wxBitmap *stipple ;
+ public:
+  int nb_dash ;
+  wxDash *dash ;
+  wxColour colour;
+  wxbPen(void);
+  wxbPen(wxColour& col, int width, int style);
+  wxbPen(const char *col, int width, int style);
+  ~wxbPen(void);
+
+  virtual void SetColour(wxColour& col) ;
+  virtual void SetColour(const char *col)  ;
+  virtual void SetColour(char r, char g, char b)  ;
+
+  virtual void SetWidth(int width)  ;
+  virtual void SetStyle(int style)  ;
+  virtual void SetStipple(wxBitmap *stipple)  ;
+  virtual void SetDashes(int nb_dashes, wxDash *dash)  ;
+  virtual void SetJoin(int join)  ;
+  virtual void SetCap(int cap)  ;
+
+  virtual wxColour &GetColour(void);
+  virtual int GetWidth(void);
+  virtual int GetStyle(void);
+  virtual int GetJoin(void);
+  virtual int GetCap(void);
+  virtual int GetDashes(wxDash **dash);
+  virtual wxBitmap *GetStipple(void);
+  
+  int locked;
+  inline Bool IsMutable(void) { return !locked; }
+  inline void Lock(int d) { locked += d; colour.Lock(d); }
+};
+
+// Brush
+class wxBrush;
+class wxbBrush: public wxObject
+{
+ protected:
+  int style;
+  wxBitmap *stipple ;
+ public:
+  wxColour colour;
+  wxbBrush(void);
+  wxbBrush(wxColour& col, int style);
+  wxbBrush(char *col, int style);
+  ~wxbBrush(void);
+
+  virtual void SetColour(wxColour& col)  ;
+  virtual void SetColour(const char *col)  ;
+  virtual void SetColour(char r, char g, char b)  ;
+  virtual void SetStyle(int style)  ;
+  virtual void SetStipple(wxBitmap* stipple=NULL)  ;
+
+  virtual wxColour &GetColour(void);
+  virtual int GetStyle(void);
+  virtual wxBitmap *GetStipple(void);
+  
+  int locked;
+  inline Bool IsMutable(void) { return !locked; }
+  inline void Lock(int d) { locked += d; colour.Lock(d); }
+};
+
+/*
+ * Bitmap flags
+ */
+
+// Hint to discard colourmap if one is loaded
+#define wxBITMAP_DISCARD_COLOURMAP      1
+
+// Hint to indicate filetype
+#define wxBITMAP_TYPE_BMP               2
+#define wxBITMAP_TYPE_BMP_RESOURCE      4
+#define wxBITMAP_TYPE_ICO               8
+#define wxBITMAP_TYPE_ICO_RESOURCE      16
+#define wxBITMAP_TYPE_CUR               32
+#define wxBITMAP_TYPE_CUR_RESOURCE      64
+#define wxBITMAP_TYPE_XBM               128
+#define wxBITMAP_TYPE_XBM_DATA          256
+#define wxBITMAP_TYPE_XPM               1024
+#define wxBITMAP_TYPE_XPM_DATA          2048
+#define wxBITMAP_TYPE_TIF               4096
+#define wxBITMAP_TYPE_GIF               8192
+#ifdef wx_mac
+#define wxBITMAP_TYPE_PICT				16384
+#define wxBITMAP_TYPE_PICT_RESOURCE		32768
+#define wxBITMAP_TYPE_ANY               65536
+
+#define wxBITMAP_TYPE_RESOURCE wxBITMAP_TYPE_PICT_RESOURCE
+#else
+#define wxBITMAP_TYPE_ANY               16384
+
+#define wxBITMAP_TYPE_RESOURCE wxBITMAP_TYPE_BMP_RESOURCE
+#endif
+class wxBitmap;
+class wxCursor;
+class wxIcon;
+
+// Management of pens, brushes and fonts
+class wxPenList: public wxList
+{
+ public:
+  inline wxPenList(void)
+    { }
+  ~wxPenList(void);
+  void AddPen(wxPen *pen);
+  void RemovePen(wxPen *pen);
+  wxPen *FindOrCreatePen(wxColour *colour, int width, int style);
+  wxPen *FindOrCreatePen(char *colour, int width, int style);
+};
+
+class wxBrushList: public wxList
+{
+ public:
+  inline wxBrushList(void)
+    { }
+  ~wxBrushList(void);
+  void AddBrush(wxBrush *brush);
+  void RemoveBrush(wxBrush *brush);
+  wxBrush *FindOrCreateBrush(wxColour *colour, int style);
+  wxBrush *FindOrCreateBrush(char *colour, int style);
+};
+
+class wxFontList: public wxList
+{
+ public:
+  inline wxFontList(void)
+    { }
+  ~wxFontList(void);
+  void AddFont(wxFont *font);
+  void RemoveFont(wxFont *font);
+  wxFont *FindOrCreateFont(int PointSize, int Family, int Style, int Weight, Bool underline = FALSE);
+  wxFont *FindOrCreateFont (int PointSize, const char *Face, int Family, int Style, int Weight, Bool underline = FALSE);
+};
+
+class wxColourDatabase: public wxList
+{
+ public:
+#ifdef wx_mac
+  wxColourDatabase(KeyType type);
+#else
+  wxColourDatabase(int type);
+#endif
+  ~wxColourDatabase(void) ;
+  wxColour *FindColour(const char *colour);
+  char *FindName(wxColour& colour);
+  void Initialize(void);
+};
+
+class wxGDIList: public wxList
+{
+ public:
+   wxGDIList(void);
+  ~wxGDIList(void);
+};
+
+// Lists of GDI objects
+extern wxPenList   *wxThePenList;
+extern wxBrushList *wxTheBrushList;
+extern wxFontList   *wxTheFontList;
+extern wxGDIList   *wxTheBitmapList;
+#ifdef wx_mac
+extern wxGDIList   *wxTheCursorList;
+extern wxGDIList   *wxTheIconList;
+#endif
+
+// Stock objects
+extern wxFont *wxNORMAL_FONT;
+extern wxFont *wxSMALL_FONT;
+extern wxFont *wxITALIC_FONT;
+extern wxFont *wxSWISS_FONT;
+
+extern wxPen *wxRED_PEN;
+extern wxPen *wxCYAN_PEN;
+extern wxPen *wxGREEN_PEN;
+extern wxPen *wxBLACK_PEN;
+extern wxPen *wxWHITE_PEN;
+extern wxPen *wxTRANSPARENT_PEN;
+extern wxPen *wxBLACK_DASHED_PEN;
+extern wxPen *wxGREY_PEN;
+extern wxPen *wxMEDIUM_GREY_PEN;
+extern wxPen *wxLIGHT_GREY_PEN;
+
+extern wxBrush *wxBLUE_BRUSH;
+extern wxBrush *wxGREEN_BRUSH;
+extern wxBrush *wxWHITE_BRUSH;
+extern wxBrush *wxBLACK_BRUSH;
+extern wxBrush *wxGREY_BRUSH;
+extern wxBrush *wxMEDIUM_GREY_BRUSH;
+extern wxBrush *wxLIGHT_GREY_BRUSH;
+extern wxBrush *wxTRANSPARENT_BRUSH;
+extern wxBrush *wxCYAN_BRUSH;
+extern wxBrush *wxRED_BRUSH;
+
+extern wxBrush *wxCONTROL_BACKGROUND_BRUSH;
+
+extern wxColour *wxBLACK;
+extern wxColour *wxWHITE;
+extern wxColour *wxRED;
+extern wxColour *wxBLUE;
+extern wxColour *wxGREEN;
+extern wxColour *wxCYAN;
+extern wxColour *wxLIGHT_GREY;
+
+// Stock cursors types
+extern wxCursor *wxSTANDARD_CURSOR;
+extern wxCursor *wxHOURGLASS_CURSOR;
+extern wxCursor *wxCROSS_CURSOR;
+
+extern wxColourDatabase *wxTheColourDatabase;
+extern void wxInitializeStockObjects(void);
+extern void wxDeleteStockObjects(void);
+
+extern Bool wxColourDisplay(void);
+
+// Returns depth of screen
+extern int wxDisplayDepth(void);
+
+extern void wxDisplaySize(int *width, int *height);
+
+extern void wxSetCursor(wxCursor *cursor);
+
+#endif // IN_CPROTO
+#endif // wxb_gdih
diff --git a/src/wxmac/include/base/wb_group.h b/src/wxmac/include/base/wb_group.h
new file mode 100644
index 0000000..5948891
--- /dev/null
+++ b/src/wxmac/include/base/wb_group.h
@@ -0,0 +1,42 @@
+/*
+ * File:	wb_group.h
+ * Purpose:	Group box
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_group.h	1.2 5/9/94" */
+
+#ifndef wb_grouph
+#define wb_grouph
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbGroupBox;
+#else
+
+// Group box
+class wxbGroupBox: public wxItem
+{
+ public:
+  wxbGroupBox(void);
+  wxbGroupBox(wxPanel *panel, char *label, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "group");
+  ~wxbGroupBox(void);
+/*
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+*/
+};
+
+#endif // IN_CPROTO
+#endif // wb_grouph
diff --git a/src/wxmac/include/base/wb_ipc.h b/src/wxmac/include/base/wb_ipc.h
new file mode 100644
index 0000000..697b5ec
--- /dev/null
+++ b/src/wxmac/include/base/wb_ipc.h
@@ -0,0 +1,181 @@
+/*
+ * File:	wb_ipc.h
+ * Purpose:	
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_ipc.h	1.2 5/9/94" */
+
+/*
+ * Purpose:  Interprocess communication implementation. Uses DDE under
+ *           Windows, sockets to implement DDE subset under UNIX
+ */
+
+
+#ifndef wxb_ipch
+#define wxb_ipch
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_IPC
+
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wx_ipcob.h"
+
+// Message codes
+enum {
+  wxEXECUTE = 1,
+  wxREQUEST,
+  wxPOKE,
+  wxADVISE_START,
+  wxADVISE_REQUEST,
+  wxADVISE,
+  wxADVISE_STOP,
+  wxREQUEST_REPLY,
+  wxFAIL,
+  wxCONNECT,
+  wxDISCONNECT
+};
+
+// Error codes
+#define  wxGENERAL           2
+#define  wxBAD_SERVICE_NAME  3
+
+/*
+ * Mini-DDE implementation
+
+   Most transactions involve a topic name and an item name (choose these
+   as befits your application).
+
+   A client can:
+
+   - ask the server to execute commands (data) associated with a topic
+   - request data from server by topic and item
+   - poke data into the server
+   - ask the server to start an advice loop on topic/item
+   - ask the server to stop an advice loop
+
+   A server can:
+
+   - respond to execute, request, poke and advice start/stop
+   - send advise data to client
+
+   Note that this limits the server in the ways it can send data to the
+   client, i.e. it can't send unsolicited information.
+ *
+ */
+
+// Always call before starting IPC
+void wxIPCInitialize(void);
+
+// Always call before exiting
+void wxIPCCleanUp(void);
+
+#ifdef IN_CPROTO
+typedef       void    *wxbConnection;
+typedef       void    *wxbServer;
+typedef       void    *wxbClient;
+#else
+
+class wxIPCObject;
+
+class wxServer;
+class wxClient;
+class wxConnection;
+
+class wxbConnection: public wxObject
+{
+ public:
+  char *buf_ptr;
+  char *topic_name;
+  int buf_size;
+  wxServer *server;
+  wxClient *client;
+
+  wxbConnection(char *buffer, int size);
+  wxbConnection(void);
+  ~wxbConnection(void);
+
+  // Callbacks to SERVER - override at will
+  virtual Bool OnExecute(char *topic, char *data, int size, int format);
+  virtual char *OnRequest(char *topic, char *item, int *size, int format);
+  virtual Bool OnPoke(char *topic, char *item, char *data, int size, int format);
+  virtual Bool OnStartAdvise(char *topic, char *item);
+  virtual Bool OnStopAdvise(char *topic, char *item);
+
+  // Callbacks to CLIENT - override at will
+  virtual Bool OnAdvise(char *topic, char *item, char *data, int size, int format);
+
+  // Callbacks to BOTH
+
+  // Default behaviour is to delete connection and return TRUE
+  virtual Bool OnDisconnect(void);
+
+  // Calls that CLIENT can make
+  virtual Bool Execute(char *data, int size = -1, int format = wxCF_TEXT) = 0;
+  virtual char *Request(char *item, int *size = NULL, int format = wxCF_TEXT) = 0;
+  virtual Bool Poke(char *item, char *data, int size = -1, int format = wxCF_TEXT) = 0;
+  virtual Bool StartAdvise(char *item) = 0;
+  virtual Bool StopAdvise(char *item) = 0;
+
+  // Calls that SERVER can make
+  virtual Bool Advise(char *item, char *data, int size = -1, int format = wxCF_TEXT) = 0;
+
+  // Calls that both can make
+  virtual Bool Disconnect(void) = 0;
+  virtual void Notify(Bool notify) = 0;  // Internal use only
+};
+
+class wxbServer: public wxIPCObject
+{
+ public:
+  wxbServer(void);
+  ~wxbServer(void);
+  virtual Bool Create(char *server_name) = 0;
+                                  // Returns FALSE if can't create server (e.g. port
+                                  // number is already in use)
+  virtual wxConnection *OnAcceptConnection(char *topic);
+};
+
+class wxbClient: public wxIPCObject
+{
+ public:
+  wxbClient(void);
+  ~wxbClient(void);
+  virtual Bool ValidHost(char *host) = 0;
+  virtual wxConnection *MakeConnection(char *host, char *server, char *topic) = 0;
+                                                // Call this to make a connection.
+                                                // Returns NULL if cannot.
+  virtual wxConnection *OnMakeConnection(void); // Tailor this to return own connection.
+};
+
+/*
+class wxChild: public wxObject
+{
+ public:
+  int the_pid;
+  wxChild(void);
+  virtual Bool Create(char *command, char *argv[]);
+  virtual wxConnection *OnSpawn(int pid);
+  virtual void OnDeath(void);
+};
+*/
+
+#endif // IN_CPROTO
+#ifdef wx_mac
+// Some Mac compilers (CodeWarrior) really want to see these decl's
+extern int wxAddString(int start, char *info, char *buffer, int size);
+extern char *wxGetNextString(char *buffer);
+
+#endif
+#endif // USE_IPC
+#endif // wxb_ipc.h
diff --git a/src/wxmac/include/base/wb_ipcob.h b/src/wxmac/include/base/wb_ipcob.h
new file mode 100644
index 0000000..28e27ab
--- /dev/null
+++ b/src/wxmac/include/base/wb_ipcob.h
@@ -0,0 +1,42 @@
+/*
+ * File:	wb_ipcob.h
+ * Purpose:	IPC object definition
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_ipcob.h	1.2 5/9/94" */
+
+#ifndef wxb_ipcobh
+#define wxb_ipcobh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_IPC
+
+#include "wx_list.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbIPCObject ;
+#else
+
+class wxbIPCObject: public wxObject
+{
+ public:
+  int lastError;
+  char *service_name; // Server only
+  wxList connections;
+  wxbIPCObject(void);
+  ~wxbIPCObject(void);
+};
+
+#endif // IN_CPROTO
+#endif // USE_IPC
+#endif // wxb_ipcob.h
diff --git a/src/wxmac/include/base/wb_item.h b/src/wxmac/include/base/wb_item.h
new file mode 100644
index 0000000..d062392
--- /dev/null
+++ b/src/wxmac/include/base/wb_item.h
@@ -0,0 +1,92 @@
+/*
+ * File:	wb_item.h
+ * Purpose:	Declares panel items base class
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_item.h	1.2 5/9/94" */
+
+#ifndef wxb_itemh
+#define wxb_itemh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_stdev.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbItem ;
+#else
+
+class wxFont ;
+
+// General item class
+class wxbItem: public wxWindow
+{
+ public:
+ 
+    wxbItem(void);
+#ifdef wx_mac
+  // Constructor (given parentArea)
+  wxbItem(char* windowName, wxArea* parentArea, int x, int y, int width, int height,
+		long		style);
+  // Constructor (given parentWindow)
+  wxbItem(char*	windowName, wxWindow* parentWindow, int x, int y, int width, int height,
+  		long style);
+  // Constructor (given objectType; i.e., menu or menuBar)
+  wxbItem(char* windowName);
+#endif // wx_mac
+   ~wxbItem(void);
+
+   wxFont *buttonFont ;
+   wxFont *labelFont ;
+   wxColour *backColour ;
+   wxColour *labelColour;
+   wxColour *buttonColour;
+
+   int labelPosition;
+#ifndef wx_mac
+   virtual void GetSize(int *width, int *height) = 0;
+   virtual void GetPosition(int *x, int *y) = 0;
+   virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO) = 0;
+   // Avoid compiler warning
+   void SetSize(int w, int h) { wxWindow::SetSize(w, h); }
+   virtual void SetClientSize(int width, int height);
+   virtual void SetFocus(void) = 0;
+#endif // wx_mac
+   virtual void SetLabel(char *label) = 0;
+   virtual char *GetLabel(void) = 0;
+
+   inline virtual void Command(wxCommandEvent& event) {};        // Simulates an event
+   inline virtual void ProcessCommand(wxCommandEvent& event) {}; // Calls the callback and 
+
+   // inline virtual void Show(Bool show) {};
+#ifndef wx_mac
+   virtual float GetCharWidth(void) = 0;
+   virtual float GetCharHeight(void) = 0;
+#endif // wx_mac
+   virtual int GetLabelPosition(void);
+   virtual void SetLabelPosition(int pos);
+
+  // Places item in centre of panel - so can't be used BEFORE panel->Fit()
+  void Centre(int direction = wxHORIZONTAL);
+
+  inline virtual wxFont  *GetLabelFont(void)        { return labelFont ; }
+  inline virtual wxFont  *GetButtonFont(void)       { return buttonFont ; }
+  inline virtual wxColour*GetBackgroundColour(void) { return backColour ; }
+  inline virtual wxColour*GetLabelColour(void)      { return labelColour ; }
+  inline virtual wxColour*GetButtonColour(void)     { return buttonColour ; }
+
+  virtual void SetBackgroundColour(wxColour*col) = 0 ;
+  virtual void SetLabelColour(wxColour*col) = 0 ;
+  virtual void SetButtonColour(wxColour*col) = 0 ;
+};
+
+#endif // IN_CPROTO
+#endif // wxb_itemh
diff --git a/src/wxmac/include/base/wb_lbox.h b/src/wxmac/include/base/wb_lbox.h
new file mode 100644
index 0000000..63da6f7
--- /dev/null
+++ b/src/wxmac/include/base/wb_lbox.h
@@ -0,0 +1,80 @@
+/*
+ * File:	wb_lbox.h
+ * Purpose:	List box
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_lbox.h	1.2 5/9/94" */
+
+#ifndef wxb_lboxh
+#define wxb_lboxh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbListBox ;
+#else
+
+// List box item
+class wxbListBox: public wxItem
+{
+ public:
+
+  int no_items;
+  int selected;
+  int *selections;
+  int multiple;
+
+  wxbListBox(void);
+  wxbListBox(wxPanel *panel, wxFunction func, char *Title, Bool Multiple = FALSE,
+             int x = -1, int y = -1, int width = -1, int height = -1,
+             int N = 0, char **Choices = NULL,
+             long style = 0, char *name = "listBox");
+#ifdef wx_mac
+  // Constructor (given parentPanel)
+  wxbListBox(wxPanel*	parentPanel, int x, int y, int width, int height, 
+  	int N, long style, char* windowName);
+#endif // wx_mac
+  ~wxbListBox(void);
+
+  virtual void Append(char *Item) = 0;
+  virtual void Append(char *Item, char *Client_data)= 0;
+  virtual void Set(int N, char *Choices[]) = 0;
+  virtual int FindString(char *s) = 0;
+  virtual void Clear(void) = 0;
+  virtual void SetSelection(int N, Bool select = TRUE) = 0;
+  virtual char *GetClientData(int N) = 0;
+  virtual void Deselect(int N) = 0;
+  virtual int GetSelection(void) = 0;  // For single choice list item only
+  virtual char *GetStringSelection(void);
+  virtual Bool SetStringSelection(char *s);
+  virtual Bool Selected(int N) = 0;
+
+  virtual int Number(void);
+  virtual void Delete(int N) = 0;
+
+  // For single or multiple choice list item
+  virtual int GetSelections(int **list_selections) = 0;
+  virtual char *GetString(int N) = 0;
+
+  // Set the specified item at the first visible item
+  // or scroll to max range.
+  virtual void SetFirstItem(int N)=0 ;
+  virtual void SetFirstItem(char *s) = 0;
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_lboxh
diff --git a/src/wxmac/include/base/wb_main.h b/src/wxmac/include/base/wb_main.h
new file mode 100644
index 0000000..c9dc55e
--- /dev/null
+++ b/src/wxmac/include/base/wb_main.h
@@ -0,0 +1,77 @@
+/*
+ * File:	wb_main.h
+ * Purpose:	wxApp declaration and a few other functions.
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_main.h	1.2 5/9/94" */
+
+#ifndef wxb_mainh
+#define wxb_mainh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+#include "wx_mgstr.h"
+
+// Here's a macro you can use if your compiler
+// really, really wants main() to be in your main program
+// (e.g. hello.cc)
+
+#if defined(AIX) || defined(AIX4)
+#define IMPLEMENT_WXWIN_MAIN int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
+#else
+#define IMPLEMENT_WXWIN_MAIN
+#endif
+
+
+#ifdef IN_CPROTO
+typedef       void    *wxbApp ;
+#else
+
+class wxFrame;
+class wxApp ;
+
+// Represents the application. Derive OnInit and declare
+// a new App object to start application
+class wxbApp: public wxObject
+{
+ public:
+  int wantDebugOutput ;
+  char *wx_class;
+  wxFrame *wx_frame;
+  int argc;
+  char **argv;
+  Bool death_processed;
+  void (*work_proc)(wxApp*app) ; // work procedure
+
+  wxbApp(wxlanguage_t language = wxLANGUAGE_DEFAULT);
+  ~wxbApp(void);
+  virtual wxFrame *OnInit(void);
+  virtual int OnExit(void);
+  virtual int MainLoop(void) = 0;
+  virtual Bool Initialized(void);
+  virtual Bool Pending(void) = 0 ;
+  virtual void Dispatch(void) = 0 ;
+};
+
+extern wxApp *wxTheApp;
+
+void wxCleanUp(void);
+void wxCommonCleanUp(void); // Call this from the platform's wxCleanUp()
+void wxCommonInit(void);    // Call this from the platform's initialization
+
+// Force an exit from main loop
+void wxExit(void);
+
+// Yield to other apps/messages
+Bool wxYield(void);
+
+#endif // IN_CPROTO
+#endif
diff --git a/src/wxmac/include/base/wb_menu.h b/src/wxmac/include/base/wb_menu.h
new file mode 100644
index 0000000..42f5380
--- /dev/null
+++ b/src/wxmac/include/base/wb_menu.h
@@ -0,0 +1,115 @@
+/*
+ * File:	wb_menu.h
+ * Purpose:	Declares panel items (controls/widgets)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wxb_menuh
+#define wxb_menuh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_item.h"
+#include "wx_mnuit.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbMenu ;
+typedef       void    *wxbMenuBar;
+#else
+
+class wxMenuBar;
+class wxMenu;
+
+// Menu
+class wxbMenu: public wxItem
+{
+ public:
+  int no_items;
+  char *title;
+  wxMenu *top_level_menu;
+  wxMenuBar *menu_bar;
+  wxList menuItems;
+
+  wxbMenu(char *Title = NULL, wxFunction func = NULL);
+#ifdef wx_mac
+  // Constructor (given Title)
+  wxbMenu (char* Title, char* windowName);
+#endif
+  ~wxbMenu(void);
+  
+  virtual void AppendSeparator(void) = 0;
+  virtual void Append(int id, char *Label, char *helpString = NULL,Bool checkable=FALSE) = 0;
+  virtual void Append(int id, char *Label, wxMenu *SubMenu, char *helpString = NULL) = 0;
+  // Avoids compiler warning
+  inline void Enable(Bool enable) { wxWindow::Enable(enable) ; }
+  virtual void Enable(int id, Bool Flag) = 0;
+  virtual void Check(int id, Bool Flag) = 0;
+  virtual Bool Checked(int id) = 0;
+  virtual void SetHelpString(int id, char *helpString);
+  virtual char *GetHelpString(int id);
+
+  // Finds the item id matching the given string, -1 if not found.
+  virtual int FindItem(char *itemString);
+
+  // Find wxMenuItem for item ID, and return item's
+  // menu too if itemMenu is non-NULL.
+  wxMenuItem *FindItemForId(int itemId, wxMenu **itemMenu = NULL);
+
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+// Menu Bar (a la Windows)
+class wxFrame;
+class wxbMenuBar: public wxItem
+{
+ public:
+  int n;
+  wxMenu **menus;
+  char **titles;
+  wxFrame *menu_bar_frame;
+
+  wxbMenuBar(void);
+  wxbMenuBar(int n, wxMenu *menus[], char *Titles[]);
+#ifdef wx_mac
+  // Constructor (given objectType)
+  wxbMenuBar(char* windowName);
+  // Constructor (given Menus)
+  wxbMenuBar(int N, wxMenu* Menus[], char* Titles[], char* windowName);
+#endif
+  ~wxbMenuBar(void);
+
+  virtual void Append(wxMenu *menu, char *title);
+  virtual void Delete(wxMenu *menu, int index = 0); // mflatt
+  virtual Bool OnAppend(wxMenu *menu, char *title) = 0; // mflatt
+  virtual Bool OnDelete(wxMenu *menu, int index) = 0; // mflatt
+
+  // Avoids compiler warning
+  inline void Enable(Bool enable) { wxWindow::Enable(enable) ; }
+
+  // Must only be used AFTER menu has been attached to frame,
+  // otherwise use individual menus to enable/disable items
+  virtual void Enable(int Id, Bool Flag) = 0;
+  virtual void EnableTop(int pos, Bool Flag) = 0;
+  virtual void Check(int Id, Bool Flag) = 0;
+  virtual Bool Checked(int id) = 0;
+  virtual void SetHelpString(int Id, char *helpString);
+  virtual char *GetHelpString(int Id);
+
+  virtual int FindMenuItem(char *menuString, char *itemString);
+
+  // Find wxMenuItem for item ID, and return item's
+  // menu too if itemMenu is non-NULL.
+  wxMenuItem *FindItemForId(int itemId, wxMenu **menuItem = NULL);
+};
+
+#endif // IN_CPROTO
+#endif // wxb_menuh
diff --git a/src/wxmac/include/base/wb_messg.h b/src/wxmac/include/base/wb_messg.h
new file mode 100644
index 0000000..09bca6b
--- /dev/null
+++ b/src/wxmac/include/base/wb_messg.h
@@ -0,0 +1,54 @@
+/*
+ * File:	wb_messg.h
+ * Purpose:	Declares panel items (controls/widgets)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_messg.h	1.2 5/9/94" */
+
+#ifndef wxb_messgh
+#define wxb_messgh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_messg.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbMessage ;
+#else
+
+// Message item
+class wxbMessage: public wxItem
+{
+ public:
+
+  wxbMessage(void);
+
+  wxbMessage(wxPanel *panel, char *message, int x = -1, int y = -1, long style = 0,
+             char *name = "message");
+#ifdef wx_mac
+  // Constructor (given parentArea)
+  wxbMessage(wxArea* parentArea, int x, int y, int width, int height, long style,
+		char*		windowName);
+ // Constructor (given parentWindow)
+  wxbMessage(wxWindow* parentWindow,int x, int y, int width, int height, long style,
+		char* windowName);
+#endif // wx_mac
+
+#if USE_BITMAP_MESSAGE
+  wxbMessage(wxPanel *panel, wxBitmap *image, int x = -1, int y = -1, long style = 0,
+             char *name = "message");
+#endif
+  ~wxbMessage(void);
+};
+
+#endif // IN_CPROTO
+#endif // wxb_messgh
diff --git a/src/wxmac/include/base/wb_mf.h b/src/wxmac/include/base/wb_mf.h
new file mode 100644
index 0000000..f1d3495
--- /dev/null
+++ b/src/wxmac/include/base/wb_mf.h
@@ -0,0 +1,60 @@
+/*
+ * File:	wb_mf.h
+ * Purpose:	Metafiles
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_mf.h	1.2 5/9/94" */
+
+
+#ifndef wxb_mfh
+#define wxb_mfh
+#include "wx_setup.h"
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#if USE_METAFILE
+#include "wx_dc.h"
+
+/*
+ * Metafile and metafile device context classes - work in Windows 3.1 only
+ *
+ */
+
+#ifdef IN_CPROTO
+typedef       void    *wxbMetaFile ;
+typedef       void    *wxbMetaFileDC ;
+#else
+
+class wxbMetaFile: public wxObject
+{
+ public:
+    
+  wxbMetaFile(void);
+  ~wxbMetaFile(void);
+
+  // After this is called, the metafile cannot be used for anything
+  // since it is now owned by the clipboard.
+  virtual Bool SetClipboard(int width = 0, int height = 0);
+};
+
+class wxMetaFile;
+class wxbMetaFileDC: public wxDC
+{
+ public:
+  wxbMetaFileDC(char *file = NULL);
+  ~wxbMetaFileDC(void);
+
+  // Should be called at end of drawing
+  virtual wxMetaFile *Close(void);
+  virtual void SetMapMode(int mode);
+};
+
+#endif // IN_CPROTO
+#endif // USE_METAFILE
+#endif // wxb_mfh
diff --git a/src/wxmac/include/base/wb_mnuit.h b/src/wxmac/include/base/wb_mnuit.h
new file mode 100644
index 0000000..3ef1b8c
--- /dev/null
+++ b/src/wxmac/include/base/wb_mnuit.h
@@ -0,0 +1,45 @@
+/*
+ * File:	wb_mnuit.h
+ * Purpose:	Declares menu item class
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_mnuit.h	1.2 5/9/94" */
+
+#ifndef wxb_mnuith
+#define wxb_mnuith
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wbMenuItem ;
+#else
+
+class wxMenu;
+class wxMenuBar;
+class wbMenuItem: public wxObject
+{
+ public:
+  wxMenuBar *menuBar;
+  int itemId;
+  char *itemName;
+  char *helpString;
+  wxMenu *subMenu;
+  wxMenu *topMenu;
+  inline wbMenuItem(void)
+  { itemId = 0; itemName = NULL; topMenu = NULL; subMenu = NULL;
+    menuBar = NULL; helpString = NULL; }
+  inline ~wbMenuItem(void) { if (itemName) delete[] itemName; if (helpString) delete[] helpString; }
+};
+
+#endif // IN_CPROTO
+#endif // wxb_mnuith
+
diff --git a/src/wxmac/include/base/wb_mtxt.h b/src/wxmac/include/base/wb_mtxt.h
new file mode 100644
index 0000000..57e45c5
--- /dev/null
+++ b/src/wxmac/include/base/wb_mtxt.h
@@ -0,0 +1,52 @@
+/*
+ * File:	wb_mtxt.h
+ * Purpose:	Multitext item
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_mtxt.h	1.2 5/9/94" */
+
+#ifndef wxb_mtxth
+#define wxb_mtxth
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_txt.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbMultiText ;
+#else
+
+// Multi-line text item
+class wxbMultiText: public wxText
+{
+ public:
+ 
+  wxbMultiText(void);
+  wxbMultiText(wxPanel *panel, wxFunction func, char *label, char *value = "",
+         int x = -1, int y = -1, int width = -1, int height = 50,
+         long style = 0, char *name = "listBox");
+#ifdef wx_mac
+  // Constructor (given parentTextWindow)
+  wxbMultiText(wxTextWindow* parentTextWindow, wxFunction function, char* label, char* value,
+		int x, int y, int width, int height,
+		long style, char* windowName);
+#endif // wx_mac
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+//  virtual char *GetValue(void) = 0;
+//  virtual void GetValue(char *buffer, int maxLen) = 0;
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_mtxth
diff --git a/src/wxmac/include/base/wb_panel.h b/src/wxmac/include/base/wb_panel.h
new file mode 100644
index 0000000..daad42c
--- /dev/null
+++ b/src/wxmac/include/base/wb_panel.h
@@ -0,0 +1,151 @@
+/*
+ * File:	wb_panel.h
+ * Purpose:	wxPanel subwindow, for panel items (widgets/controls)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_panel.h	1.2 5/9/94" */
+
+#ifndef wxb_panelh
+#define wxb_panelh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_win.h"
+#include "wx_frame.h"
+#include "wx_canvs.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbPanel ;
+#else
+
+class wxItem;
+class wxButton;
+class wxPanel;
+class wxColour;
+class wxBrush;
+
+#if (defined(wx_motif) && USE_PANEL_CANVAS_IN_X) || (defined(wx_msw) && USE_PANEL_CANVAS_IN_MSW) || (defined(wx_mac) && USE_PANEL_CANVAS_IN_MAC)
+class wxbPanel: public wxCanvas
+#else
+class wxbPanel: public wxWindow
+#endif
+{
+ public:
+  Bool new_line;
+  int label_position;
+  wxButton *defaultItem;
+
+  int hSpacing;
+  int vSpacing;
+
+  int current_hspacing ;
+  int current_vspacing ;
+
+  int initial_hspacing ;
+  int initial_vspacing ;
+  Bool has_child ;
+
+  wxFont *labelFont ;
+  wxFont *buttonFont;
+  wxColour *backColour ;
+  wxColour *labelColour;
+  wxColour *buttonColour;
+
+#ifndef wx_mac
+  wxbPanel(void);
+  wxbPanel(wxWindow *window,
+          int x=-1, int y=-1, int width=-1, int height=-1, long style=0,
+          char *name = "panel");
+/*
+  wxbPanel(wxPanel *panel,
+          int x=-1, int y=-1, int width=-1, int height=-1, long style=0,
+          char *name = "panel");
+*/
+#endif // wx_mac
+#ifdef wx_mac
+  // Constructor (given parentArea)
+  wxbPanel(char* windowName, wxArea* parentArea, int x, int y, int width, int height,
+		long style);
+  // Constructor (given parentWindow)
+  wxbPanel(char* windowName, wxWindow* parentWindow, int x, int y, int width, int height,
+		long style);
+#endif // wx_mac
+  ~wxbPanel(void);
+
+  // Set current label position, i.e. will label be on top or to the left
+  void SetLabelPosition(int pos);  // wxHORIZONTAL or wxVERTICAL
+  int GetLabelPosition(void);
+
+  virtual void SetButtonFont(wxFont *font);
+  virtual void SetLabelFont(wxFont *font);
+  virtual void SetButtonColour(wxColour *col);
+  virtual void SetLabelColour(wxColour *col);
+  virtual void SetBackgroundColour(wxColour *col);
+
+  inline virtual wxFont  *GetLabelFont(void)        { return labelFont ; }
+  inline virtual wxFont  *GetButtonFont(void)       { return buttonFont ; }
+  inline virtual wxColour*GetBackgroundColour(void) { return backColour ; }
+  inline virtual wxColour*GetLabelColour(void)      { return labelColour ; }
+  inline virtual wxColour*GetButtonColour(void)     { return buttonColour ; }
+
+  // Start a new line
+  virtual void NewLine(void) = 0;
+  virtual void NewLine(int pixels) = 0;
+
+  // Tab specified number of pixels
+  virtual void Tab(void) = 0;
+  virtual void Tab(int pixels) = 0;
+
+  virtual void GetCursor(int *x, int *y) = 0;
+
+  // Set/get horizontal spacing
+  virtual void SetHorizontalSpacing(int sp) = 0;
+  virtual int GetHorizontalSpacing(void) = 0;
+
+  // Set/get vertical spacing
+  virtual void SetVerticalSpacing(int sp) = 0;
+  virtual int GetVerticalSpacing(void) = 0;
+
+  // Update next cursor position
+  virtual void AdvanceCursor(wxWindow *item) = 0;
+
+#ifndef wx_mac
+  // If x or y are not specified (i.e. < 0), supply
+  // values based on left to right, top to bottom layout.
+  // Internal use only.
+  virtual void GetValidPosition(int *x, int *y) = 0;
+#endif // wx_mac
+
+  inline virtual wxButton *GetDefaultItem(void) { return defaultItem; }
+
+  wxObject *GetChild(int number) ;
+
+  // Override to define new behaviour for default action (e.g. double clicking
+  // on a listbox)
+  virtual void OnDefaultAction(wxItem *initiatingItem);
+
+#if USE_WX_RESOURCES
+  /*
+   * Optional resource loading facility
+   */
+
+  Bool LoadFromResource(wxWindow *parent, char *resourceName);
+#endif
+#ifdef wx_mac
+// Private methods
+private:
+	void InitDefaults(void);
+	void InitMoreDefaults(void); // Poor name for this method
+
+#endif // wx_mac
+};
+
+#endif // IN_CPROTO
+#endif // wxb_panelh
diff --git a/src/wxmac/include/base/wb_rbox.h b/src/wxmac/include/base/wb_rbox.h
new file mode 100644
index 0000000..f70504d
--- /dev/null
+++ b/src/wxmac/include/base/wb_rbox.h
@@ -0,0 +1,77 @@
+/*
+ * File:	wb_rbox.h
+ * Purpose:	Radio box
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_rbox.h	1.2 5/9/94" */
+
+#ifndef wxb_rboxh
+#define wxb_rboxh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifdef IN_CPROTO
+typedef       void    *wxbRadioBox ;
+#else
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+// Radio box item
+class wxBitmap ;
+class wxbRadioBox: public wxItem
+{
+ public:
+  int no_items;
+  int selected;
+
+  wxbRadioBox(void);
+  wxbRadioBox(wxPanel *panel, wxFunction func, char *Title,
+             int x = -1, int y = -1, int width = -1, int height = -1,
+             int N = 0, char **Choices = NULL,
+             int majorDim = 0,
+             long style = 0, char *name = "radioBox");
+#ifdef wx_mac
+  // Constructor (given parentPanel)
+  wxbRadioBox(wxPanel* parentPanel, int x, int y, int width, int height, int N,
+		long style, char* windowName);
+#endif // wx_mac
+#ifndef __BORLANDC__
+  wxbRadioBox(wxPanel *panel, wxFunction func, char *Title,
+             int x = -1, int y = -1, int width = -1, int height = -1,
+             int N = 0, wxBitmap **Choices = NULL,
+             int majorDim = 0,
+             long style = 0, char *name = "radioBox");
+#endif
+
+  ~wxbRadioBox(void);
+
+  virtual int FindString(char *s) = 0;
+  virtual void SetSelection(int N) = 0;
+  virtual int GetSelection(void) = 0;
+  virtual char *GetStringSelection(void);
+  virtual Bool SetStringSelection(char *s);
+  virtual int Number(void);
+  virtual char *GetString(int N) = 0;
+  // Avoids compiler warning
+  inline void Enable(Bool enable) { wxWindow::Enable(enable) ; }
+  virtual void Enable(int item, Bool enable) = 0; // Enable/disable specific item
+  
+  // Avoids compiler warning
+  inline void Show(Bool show) { wxItem::Show(show) ; }
+  virtual void Show(int item, Bool show) = 0; // show/unshow specific item
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_rboxh
diff --git a/src/wxmac/include/base/wb_slidr.h b/src/wxmac/include/base/wb_slidr.h
new file mode 100644
index 0000000..8b34408
--- /dev/null
+++ b/src/wxmac/include/base/wb_slidr.h
@@ -0,0 +1,51 @@
+/*
+ * File:	wb_slidr.h
+ * Purpose:	Slider
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_slidr.h	1.2 5/9/94" */
+
+#ifndef wxb_slidrh
+#define wxb_slidrh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbSlider ;
+#else
+
+// Slider
+class wxbSlider: public wxItem
+{
+ public:
+  wxbSlider(void);
+  wxbSlider(wxPanel *panel, wxFunction func, char *label, int value,
+           int min_value, int max_value, int width, int x = -1, int y = -1,
+           long style = 0, char *name = "slider");
+#ifdef wx_mac
+  wxbSlider (wxPanel * panel, char *label, int value, int min_value, int max_value, 
+		int width, int x, int y, long style, char *windowName);
+#endif
+
+  ~wxbSlider(void);
+
+  virtual int GetValue(void) = 0;
+  virtual void SetValue(int) = 0;
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_slidrh
diff --git a/src/wxmac/include/base/wb_text.h b/src/wxmac/include/base/wb_text.h
new file mode 100644
index 0000000..b8c0b20
--- /dev/null
+++ b/src/wxmac/include/base/wb_text.h
@@ -0,0 +1,98 @@
+/*
+ * File:	wb_text.h
+ * Purpose:	wxTextWindow - simple text subwindow class
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_text.h	1.2 5/9/94" */
+
+#ifndef wxb_texth
+#define wxb_texth
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_frame.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxbTextWindow ;
+#else
+
+/*
+ * I would make this also derived from ostream:
+ *
+ * class wxTextWindow: public wxWindow, public virtual ostream
+ *
+ * but weirdly, the operator << isn't declared virtual in (isn't even
+ * a member of) ostream, so we can't use a wxTextWindow in place of an ostream.
+ *
+ */
+
+class wxbTextWindow: public wxWindow
+{
+ public:
+  char *file_name;
+
+#ifndef wx_mac
+  wxbTextWindow(void);
+  wxbTextWindow(wxWindow *parent, int x=-1, int y=-1, int width=-1, int height=-1,
+               long style=0, char *name = "textWindow");
+#endif // wx_mac
+#ifdef wx_mac
+  // Constructor (given parentArea)
+  wxbTextWindow(WXTYPE objectType, char* windowName, wxArea* parentArea, int x, int y,
+		int width, int height, long style);
+  // Constructor (given parentWindow)
+  wxbTextWindow (WXTYPE objectType, char* windowName, wxWindow*	parentWindow, int x, int y,
+		int width, int height, long style);
+#endif // wx_mac
+
+  ~wxbTextWindow(void);
+
+  virtual Bool LoadFile(char *file) = 0;
+  virtual Bool SaveFile(char *file) = 0;
+  virtual void WriteText(char *text) = 0;
+  virtual void Clear(void) = 0;
+  virtual void DiscardEdits(void) = 0;
+  virtual Bool Modified(void) = 0;
+  virtual char *GetContents(void) = 0;
+  virtual void SetInsertionPoint(long pos) = 0;
+  virtual void SetInsertionPointEnd(void) = 0;
+  virtual long GetInsertionPoint(void) = 0;
+  virtual long GetLastPosition(void) = 0;
+  virtual long XYToPosition(long x, long y) = 0;
+  virtual void PositionToXY(long pos, long *x, long *y) = 0;
+  virtual int GetNumberOfLines(void) = 0;
+  virtual void ShowPosition(long pos) = 0;
+  virtual int GetLineLength(long lineNo) = 0;
+  virtual int GetLineText(long lineNo, char *buf) = 0;
+  virtual void Replace(long from, long to, char *value) = 0;
+  virtual void Remove(long from, long to) = 0;
+  virtual void SetSelection(long from, long to) = 0;
+  virtual void Copy(void) = 0; // Copy selection to clipboard
+  virtual void Paste(void) =0; // Paste clipboard into text window
+  virtual void Cut(void) = 0; // Copy selection to clipboard, then remove selection.
+  virtual void SetEditable(Bool editable) = 0;
+#ifndef wx_mac
+  inline virtual void SetFont(wxFont *theFont) { font = theFont; }
+#endif // wx_mac
+  inline virtual wxFont *GetFont(void) { return font; }
+
+  wxbTextWindow& operator<<(char *s);
+  wxbTextWindow& operator<<(int i);
+  wxbTextWindow& operator<<(long i);
+  wxbTextWindow& operator<<(float f);
+  wxbTextWindow& operator<<(double d);
+  wxbTextWindow& operator<<(char c);
+
+};
+
+#define wxTEXT_MAX_LINES 1000
+
+#endif // IN_CPROTO
+#endif // wxb_texth
diff --git a/src/wxmac/include/base/wb_timer.h b/src/wxmac/include/base/wb_timer.h
new file mode 100644
index 0000000..19b4d18
--- /dev/null
+++ b/src/wxmac/include/base/wb_timer.h
@@ -0,0 +1,54 @@
+/*
+ * File:	wb_timer.h
+ * Purpose:	wxTimer - provides simple timer functionality
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_timer.h	1.2 5/9/94" */
+
+#ifndef wxb_timerh
+#define wxb_timerh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+
+#if (!defined(__SC__) && !defined(__sgi)) && !defined(wx_mac)
+#include <sys/timeb.h>
+#endif
+
+#ifdef IN_CPROTO
+typedef       void    *wxbTimer ;
+#else
+
+class wxbTimer: public wxObject
+{
+ public:
+#if 0
+  Bool oneShot ;
+  int  milli ;
+  int  lastMilli ;
+#else
+  int interval;
+#endif
+  wxbTimer(void);
+  ~wxbTimer(void);
+  virtual Bool Start(int milliseconds = -1,Bool one_shot=FALSE) = 0; // Start timer
+  virtual void Stop(void) = 0;                   // Stop timer
+  virtual void Notify(void);                 // Override this member
+  virtual int Interval(void) ; // Returns the current interval time (0 if stop)
+};
+
+// Timer functions (milliseconds)
+void wxStartTimer(void);
+// Gets time since last wxStartTimer or wxGetElapsedTime
+long wxGetElapsedTime(Bool resetTimer = TRUE);
+
+#endif // IN_CPROTO
+#endif // wxb_timerh
diff --git a/src/wxmac/include/base/wb_txt.h b/src/wxmac/include/base/wb_txt.h
new file mode 100644
index 0000000..86a84f1
--- /dev/null
+++ b/src/wxmac/include/base/wb_txt.h
@@ -0,0 +1,63 @@
+/*
+ * File:	wb_txt.h
+ * Purpose:	Text panel item
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_txt.h	1.2 5/9/94" */
+
+#ifndef wxb_txth
+#define wxb_txth
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifdef wx_mac
+#include "wx_item.h"
+class wxPanel;
+class wxTextWindow;
+#else // wx_mac
+#include "common.h"
+#include "wx_panel.h"
+#include "wx_txt.h"
+#endif // wx_mac
+
+#ifdef IN_CPROTO
+typedef       void    *wxbText ;
+#else
+
+// Single-line text item
+class wxbText: public wxItem
+{
+ public:
+  wxbText(void);
+  wxbText(wxPanel *panel, wxFunction func, char *label, char *value = "",
+         int x = -1, int y = -1, int width = -1, int height = -1,
+         long style = 0, char *name = "text");
+#ifdef wx_mac
+  // Constructor (given parentWindow)
+  wxbText(wxWindow*	parentWindow, int x, int y, int width, int height,
+		long style, char* windowName);
+#endif // wx_mac
+
+  ~wxbText(void);
+
+  virtual char *GetValue(void) = 0;
+  virtual void SetValue(char *value) = 0;
+
+  // Clipboard operations
+  virtual void Copy(void) = 0;
+  virtual void Cut(void) = 0;
+  virtual void Paste(void) = 0;
+
+  void Command(wxCommandEvent& event);
+  void ProcessCommand(wxCommandEvent& event);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_txth
diff --git a/src/wxmac/include/base/wb_win.h b/src/wxmac/include/base/wb_win.h
new file mode 100644
index 0000000..cb933b6
--- /dev/null
+++ b/src/wxmac/include/base/wb_win.h
@@ -0,0 +1,203 @@
+/*
+ * File:	wb_win.h
+ * Purpose:	
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_win.h	1.2 5/9/94" */
+
+/*
+ * Purpose:  wxWindow class declaration. Base class for all windows and
+ *           panel items.
+ */
+
+
+#ifndef wxb_winh
+#define wxb_winh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+#include "wx_stdev.h"
+#include "wx_list.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxFunction ;
+typedef       void    *wxbWindow ;
+#else
+
+class wxCursor;
+class wxFont;
+class wxIcon;
+class wxColourMap;
+class wxMenu;
+class wxWindow;
+
+// Callback function type definition
+typedef void (*wxFunction) (wxObject&, wxEvent&);
+
+/*
+ * Base class for frame, panel, canvas, panel items, dialog box.
+ *
+ */
+
+class wxWindow;
+class wxMenu;
+class wxbWindow: public wxObject
+{
+ protected:
+  // Store the window's style
+  long windowStyle;
+ public:
+  int doubleClickAllowed ;
+  // Font - created on demand, not deleted with window
+  wxFont *font;                               // Window's font
+  wxCursor *wx_cursor;                        // Window's cursor
+
+  char *wx_client_data;                       // Any user client data
+#ifndef wx_mac
+  wxList *children;                           // Window's children
+#endif // wx_mac
+  Bool paintingEnabled;
+  Bool winCaptured;
+
+#ifndef wx_mac
+  wxWindow *window_parent;                     // Each window always knows its parent
+#endif // wx_mac
+
+  char *handle;                                // Pointer to real window
+  char *windowName;                            // Window name
+
+  wxFunction callback;                         // Callback associated with the window
+  virtual void Callback(wxFunction);           // Adds callback
+
+  // Constructors/Destructors
+  wxbWindow(void);
+#ifdef wx_mac
+  wxbWindow(char* windowName);
+#endif 
+
+  virtual ~wxbWindow(void);
+
+  inline virtual void Paint(void) {};             // Called when needs painting
+  inline virtual void OnSize(int width, int height) {}; // Called on resize
+  inline virtual void OnEvent(wxMouseEvent& event) {};  // Called on mouse event
+  inline virtual void OnChar(wxKeyEvent& event) {};     // Called on character event
+  inline virtual Bool OnClose(void) { return TRUE; };  // Delete window if returns TRUE
+  inline virtual void OnActivate(Bool active) {};       // Called on window activation (MSW)
+  inline virtual void OnSetFocus(void) {};              // Called on setting focus
+  inline virtual void OnKillFocus(void) {};             // Called on killing focus
+  inline virtual void OnDropFiles(int n, char *files[], int x, int y) {};
+                                                 // Called when files dropped
+  inline virtual void OnCommand(wxWindow& win, wxCommandEvent& event) {};
+                                                 // Called if child control has no
+                                                 // callback function
+
+  virtual void GetSize(int *width, int *height) = 0;
+  virtual void GetPosition(int *x, int *y) = 0;
+  virtual void GetClientSize(int *width, int *height) = 0; // Size client can use
+  virtual void SetSize(int x, int y, int width, int height, int flags = wxSIZE_AUTO) = 0;
+  virtual void SetClientSize(int width, int size) = 0;
+  virtual void ClientToScreen(int *x, int *y) = 0;
+  virtual void ScreenToClient(int *x, int *y) = 0;
+  virtual void Enable(Bool enable) = 0;
+  virtual void SetFocus(void) = 0;
+  virtual void CaptureMouse(void) = 0;
+  virtual void ReleaseMouse(void) = 0;
+  virtual void DragAcceptFiles(Bool accept) = 0;
+  virtual void MakeModal(Bool modal);
+
+  virtual char *GetHandle(void);
+  char *GetClientData(void);
+#ifdef wx_mac
+  virtual wxWindow *GetParent(void) = 0;
+  virtual wxWindow *GetGrandParent(void) = 0;
+  virtual wxChildList *GetChildren(void) = 0;
+#else // wx_mac
+  virtual wxWindow *GetParent(void);
+  virtual wxWindow *GetGrandParent(void);
+  inline virtual wxList *GetChildren() { return children; }
+#endif // wx_mac
+
+  void SetClientData(char *);
+  virtual void Show(Bool show) = 0;
+  virtual wxCursor *SetCursor(wxCursor *cursor) = 0;
+  virtual void SetColourMap(wxColourMap *cmap) = 0;
+
+  virtual float GetCharWidth(void) = 0;
+  virtual float GetCharHeight(void) = 0;
+#ifdef wx_mac
+  inline virtual void GetTextExtent(const char* string, float* x, float* y, float* descent = NULL,
+  						float* externalLeading = NULL, wxFont* the_font = NULL, Bool use16=FALSE) {};
+#else // wx_mac
+  inline virtual void GetTextExtent(const char *string, float *x, float *y,
+       float *descent = NULL, float *externalLeading = NULL, wxFont *theFont = NULL) {};
+#endif
+  inline virtual void SetTitle(char *title) {};      // Set window title
+  inline virtual char *GetTitle(void) { return NULL; }; // Set window title
+  // Most windows have the concept of a label; for frames, this is the
+  // title; for items, this is the label or button text.
+  inline virtual char *GetLabel(void) { return GetTitle(); }
+
+  inline virtual char *GetName(void) { return windowName; }
+  virtual void SetName(char *name);
+
+  inline virtual void Fit(void) {};                  // Size window to fit contents
+  inline virtual void Centre(int direction) {};      // Centre item on panel,
+                                               // or frame on screen
+  // Renamed from GetWindowStyle since it clashed with a
+  // macro in windowsx.h.
+  inline long GetWindowStyleFlag(void) { return windowStyle; }
+  // A concession to our friends across the pond
+  inline void Center(int direction = wxHORIZONTAL) { Centre(direction); }
+
+  inline virtual void EnablePainting(Bool enable) { paintingEnabled = enable; }
+
+  virtual Bool PopupMenu(wxMenu *menu, float x, float y) = 0;
+
+  // INTERNAL FUNCTIONS
+#ifdef wx_mac
+  virtual void AddChild(wxObject *child) = 0;      // Adds reference to the child object
+  virtual void DestroyChildren(void) = 0;  		   // Removes and destroys all children
+#else // wx_mac
+  virtual void AddChild(wxObject *child);      // Adds reference to the child object
+  virtual void RemoveChild(wxObject *child);   // Removes reference to child
+                                       // (but doesn't delete the child object)
+  virtual void DestroyChildren(void);  // Removes and destroys all children
+#endif // wx_mac
+
+  wxWindow *ContextWindow(void);
+
+#ifdef wx_mac
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void InitDefaults(void);
+
+#endif // wx_mac
+
+};
+
+#if 0
+extern wxList wxTopLevelWindows;
+#else
+extern wxChildList *wxGetTopLevelWindowsList(wxObject*);
+#define wxTopLevelWindows(w) (wxGetTopLevelWindowsList(w))
+#endif
+
+extern void *wxGetContextForFrame();
+
+extern void wxDispatchEventsUntil(int (*f)(void *), void *data);
+extern wxWindow *wxGetModalWindow(wxObject *o);
+extern void wxPutModalWindow(wxObject *o, wxWindow *win);
+
+#endif // IN_CPROTO
+#endif // wxb_winh
diff --git a/src/wxmac/include/base/wx.h b/src/wxmac/include/base/wx.h
new file mode 100644
index 0000000..45ffa60
--- /dev/null
+++ b/src/wxmac/include/base/wx.h
@@ -0,0 +1,57 @@
+/*
+ * File:	wx.h
+ * Purpose:	Window library main include file
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx.h	1.2 5/9/94" */
+
+#ifndef wx_wxh
+#define wx_wxh
+
+#include "wx_setup.h"           // Which features to include - user editable
+#include "common.h"
+// #include "wx_mgstr.h"        // Simple language support: a file of strings
+#include "wx_win.h"
+#include "wx_frame.h"
+#include "wx_dc.h"
+#include "wx_dccan.h"
+#include "wx_dcmem.h"
+#include "wx_dcps.h"
+// #include "wx_mf.h"           // Not included as standard
+#include "wx_canvs.h"
+#include "wx_panel.h"
+#include "wx_buttn.h"
+#include "wx_check.h"
+#include "wx_choic.h"
+#include "wx_lbox.h"
+#include "wx_slidr.h"
+#include "wx_group.h"
+// #include "wx_clipb.h"        // Not included as standard
+#include "wx_messg.h"
+#include "wx_rbox.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#if USE_GAUGE
+#include "wx_gauge.h"
+#endif
+#include "wx_menu.h"
+#ifndef wx_mac	
+#include "wx_text.h"
+#endif
+#include "wx_main.h"
+#include "wx_stdev.h"
+#include "wx_list.h"
+// #include "wx_form.h"         // Not included as standard
+#include "wx_gdi.h"
+#include "wx_dialg.h"
+// #include "wx_enhdg.h"        // Not included as standard
+// #include "wx_ipc.h"          // Not included as standard
+// #include "wx_timer.h"        // Not included as standard
+#include "wx_utils.h"
+#include "wx_res.h"
+
+#endif // wx_wxh
diff --git a/src/wxmac/include/base/wx_clipb.h b/src/wxmac/include/base/wx_clipb.h
new file mode 100644
index 0000000..6c037f3
--- /dev/null
+++ b/src/wxmac/include/base/wx_clipb.h
@@ -0,0 +1,100 @@
+/*
+ * File:	wx_clipb.h
+ * Purpose:	Clipboard functionality
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_clipb.h	1.2 5/9/94" */
+
+#ifndef wx_clipbh
+#define wx_clipbh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_CLIPBOARD
+
+#include "wx_obj.h"
+#include "wx_list.h"
+
+#ifndef IN_CPROTO
+Bool wxOpenClipboard(void);
+Bool wxCloseClipboard(void);
+Bool wxEmptyClipboard(void);
+Bool wxIsClipboardFormatAvailable(int dataFormat);
+Bool wxSetClipboardData(int dataFormat, wxObject *obj, int width = 0, int height = 0);
+wxObject *wxGetClipboardData(int dataFormat, long *size = NULL);
+int  wxEnumClipboardFormats(int dataFormat);
+int  wxRegisterClipboardFormat(char *formatName);
+Bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount);
+
+/* A clipboard client holds data belonging to the clipboard.
+   For plain text, a client is not necessary. */
+class wxClipboardClient : public wxObject
+{
+ public:
+  wxStringList formats;
+  /* This list should be filled in with strings indicating the formats
+     this client can provide. Almost all clients will provide "TEXT".
+     Format names should be 4 characters long, so things will work
+     out on the Macintosh */
+
+  virtual void BeingReplaced(void) = 0;
+  /* This method is called when the client is losing the selection. */
+  virtual char *GetData(char *format, long *size) = 0;
+  /* This method is called when someone wants the data this client is
+     supplying to the clipboard. "format" is a string indicating the
+     format of the data - one of the strings from the "formats"
+     list. "*size" should be filled with the size of the resulting
+     data. In the case of text, "*size" does not count the
+     NULL terminator. */
+};
+
+/* ONE instance of this class: */
+class wxClipboard : public wxObject
+{
+ public:
+  wxClipboardClient *clipOwner;
+  char *cbString, *sentString, *receivedString;
+  void *receivedTargets;
+  long receivedLength;
+#ifdef wx_xview
+  long sel_owner;
+#endif
+
+  wxClipboard();
+  ~wxClipboard();
+
+  void SetClipboardClient(wxClipboardClient *, long time);
+  /* Set the clipboard data owner. "time" comes from the event record. */
+  void SetClipboardString(char *, long time);
+  /* Set the clipboard string; does not require a client. */
+
+  char *GetClipboardString(long time);
+  /* Get data from the clipboard in the format "TEXT". */
+  char *GetClipboardData(char *format, long *length, long time);
+  /* Get data from the clipboard */
+  wxClipboardClient *GetClipboardClient(void);
+  /* Get the clipboard client directly. Will be NULL if clipboard data
+     is a string, or if some other application owns the clipboard. 
+     This can be useful for shortcutting data translation, if the
+     clipboard user can check for a specific client. (This is used
+     by the wxMediaEdit class.) */
+};
+
+void wxInitClipboard(void);
+/* Initialize wxTheClipboard. Can be called repeatedly */
+
+extern wxClipboard *wxTheClipboard;
+/* The clipboard */
+
+#endif // IN_CPROTO
+#endif // USE_CLIPBOARD
+#endif // wx_clipbh
diff --git a/src/wxmac/include/base/wx_dcps.h b/src/wxmac/include/base/wx_dcps.h
new file mode 100644
index 0000000..31045bc
--- /dev/null
+++ b/src/wxmac/include/base/wx_dcps.h
@@ -0,0 +1,324 @@
+/*
+ * File:	wx_dcps.h
+ * Purpose:	PostScript device context
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_dcps.h	1.2 5/9/94" */
+
+
+#ifndef wx_dcpsh
+#define wx_dcpsh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifdef wx_xt
+class wxBitmap;
+class wxBrush;
+class wxColour;
+class wxColourMap;
+class wxFont;
+class wxIcon;
+class wxList;
+class wxPen;
+class ofstream;
+#else
+#include "wx_dc.h"
+#endif
+
+#if USE_POSTSCRIPT
+
+#ifdef IN_CPROTO
+typedef       void    *wxPostScriptDC ;
+#else
+
+#ifndef DECLARE_DYNAMIC_CLASS
+# define DECLARE_DYNAMIC_CLASS(x) /* empty */
+#endif
+
+#ifdef wx_xt
+# define BLIT_DC_TYPE wxDC
+# define DRAW_TEXT_CONST /* empty */
+#else
+# define BLIT_DC_TYPE wxCanvasDC
+# define DRAW_TEXT_CONST const
+#endif
+
+class wxPostScriptDC: public wxDC
+{
+  DECLARE_DYNAMIC_CLASS(wxPostScriptDC)
+
+ public:
+#ifdef wx_xt
+  char *title;
+  Bool clipping;
+#endif
+  int page_number;
+  ofstream *pstream;    // PostScript output stream
+  char *filename;
+  long boundingboxpos;
+  unsigned char currentRed;
+  unsigned char currentGreen;
+  unsigned char currentBlue;
+  /* MATTHEW: [8] */
+  float clipx, clipy, clipw, cliph;
+
+  float paper_x, paper_y, paper_w, paper_h, paper_x_scale, paper_y_scale;
+  Bool landscape, resetFont, level2ok;
+
+  int mode;
+  char *preview_cmd, *print_cmd, *print_opts;
+
+  // Create a printer DC
+  wxPostScriptDC(void);
+  wxPostScriptDC(char *output, Bool interactive = TRUE, wxWindow *parent = NULL);
+
+  ~wxPostScriptDC(void);
+
+  Bool Create(char *output, Bool interactive = TRUE, wxWindow *parent = NULL);
+
+  Bool PrinterDialog(Bool interactive, wxWindow *parent = NULL);
+
+  inline virtual void BeginDrawing(void) {} ;
+  inline virtual void EndDrawing(void) {} ;
+
+  void FloodFill(float x1, float y1, wxColour *col, int style=wxFLOOD_SURFACE) ;
+  Bool GetPixel(float x1, float y1, wxColour *col) ;
+
+  void DrawLine(float x1, float y1, float x2, float y2);
+  void IntDrawLine(int x1, int y1, int x2, int y2);
+  void CrossHair(float x, float y) ;
+  void DrawArc(float x1,float y1,float x2,float y2,float xc,float yc);
+  void DrawPoint(float x, float y);
+  void DrawPoint(wxPoint& point) { DrawPoint(point.x, point.y); }
+  void DrawLines(int n, wxPoint points[], float xoffset = 0, float yoffset = 0);
+  void DrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0);
+#ifdef wx_xt
+  void IntDrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0) 
+    { DrawLines(n, points, xoffset, yoffset); }
+#endif
+  void DrawLines(wxList *lines, float xoffset = 0, float yoffset = 0)
+#ifdef wx_xt
+    ;
+#else
+  { wxbDC::DrawLines(lines, xoffset, yoffset); }
+#endif
+  void DrawPolygon(int n, wxPoint points[], float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE);
+  void DrawPolygon(wxList *lines, float xoffset = 0, float yoffset = 0, int fillStyle=wxODDEVEN_RULE)
+#ifdef wx_xt
+    ;
+#else
+  { wxbDC::DrawPolygon(lines, xoffset, yoffset, fillStyle); }
+#endif
+
+  void DrawRectangle(float x, float y, float width, float height);
+  void DrawRoundedRectangle(float x, float y, float width, float height, float radius = 20);
+  void DrawEllipse(float x, float y, float width, float height);
+  // Splines
+  // 3-point spline
+  void DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3);
+  // Any number of control points - a list of pointers to wxPoints
+  void DrawSpline(wxList *points);
+  void DrawSpline(int n, wxPoint points[]);
+  void DrawIcon(wxIcon *icon, float x, float y);
+  /* MATTHEW: [2] 16-bit fonts */
+  void DrawText(DRAW_TEXT_CONST char *text, float x, float y, Bool use16 = FALSE);
+
+  void Clear(void);
+  void SetFont(wxFont *font);
+  void SetPen(wxPen *pen);
+  void SetBrush(wxBrush *brush);
+  void SetLogicalFunction(int function);
+  void SetBackground(wxBrush *brush);
+  void SetClippingRegion(float x, float y, float width, float height);
+  /* MATTHEW: [8] */
+  void GetClippingRegion(float *x, float *y, float *width, float *height);
+  void DestroyClippingRegion(void);
+
+  Bool StartDoc(char *message);
+  void EndDoc(void);
+  void StartPage(void);
+  void EndPage(void);
+
+  float GetCharHeight(void);
+  float GetCharWidth(void);
+  /* MATTHEW: [2] 16-bit fonts */
+  void GetTextExtent(const char *string, float *x, float *y,
+                     float *descent = NULL, float *externalLeading = NULL, 
+		     wxFont *theFont = NULL, Bool use16 = FALSE);
+  void SetMapMode(int mode);
+  void SetUserScale(float x, float y);
+  float DeviceToLogicalX(int x);
+  float DeviceToLogicalY(int y);
+  float DeviceToLogicalXRel(int x);
+  float DeviceToLogicalYRel(int y);
+  int LogicalToDeviceX(float x);
+  int LogicalToDeviceY(float y);
+  int LogicalToDeviceXRel(float x);
+  int LogicalToDeviceYRel(float y);
+  Bool Blit(float xdest, float ydest, float width, float height,
+            BLIT_DC_TYPE *source, float xsrc, float ysrc, int rop = wxCOPY);
+  inline Bool CanGetTextExtent(void) { return USE_AFM_FOR_POSTSCRIPT; }
+  inline Bool CanDrawBitmap(void) { return TRUE; }
+
+  void GetSize(float *width, float *height);
+  void GetSizeMM(float *width, float *height);
+
+  inline void SetColourMap(wxColourMap *WXUNUSED(cmap)) {}
+
+  void SetBackgroundMode(int mode);
+  void SetTextBackground(wxColour *col);
+  void SetTextForeground(wxColour *col);
+  void TryColour(wxColour *src, wxColour *dest);
+
+  virtual Bool Ok() { return ok; }
+};
+
+void wxSetLevel2Ok(Bool ok);
+Bool wxGetLevel2Ok(void);
+
+#ifndef wx_xt
+
+// Print Orientation (Should also add Left, Right)
+enum {
+  PS_PORTRAIT,
+  PS_LANDSCAPE
+};// ps_orientation = PS_PORTRAIT;
+
+// Print Actions
+enum {
+  PS_PRINTER,
+  PS_FILE,
+  PS_PREVIEW
+};// ps_action = PS_PREVIEW;
+
+// PostScript printer settings
+void wxSetPrinterCommand(char *cmd);
+void wxSetPrintPreviewCommand(char *cmd);
+void wxSetPrinterOptions(char *flags);
+void wxSetPrinterOrientation(int orientation);
+void wxSetPrinterScaling(float x, float y);
+void wxSetPrinterTranslation(float x, float y);
+void wxSetPrinterMode(int mode);
+void wxSetPrinterFile(char *f);
+void wxSetAFMPath(char *f);
+
+// Get current values
+char *wxGetPrinterCommand(void);
+char *wxGetPrintPreviewCommand(void);
+char *wxGetPrinterOptions(void);
+Bool wxGetPrinterOrientation(void);
+void wxGetPrinterScaling(float *x, float *y);
+void wxGetPrinterTranslation(float *x, float *y);
+int wxGetPrinterMode(void);
+char *wxGetPrinterFile(void);
+char *wxGetAFMPath(void);
+
+/*
+ * PostScript print setup information
+ */
+
+class wxPrintSetupData: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxPrintSetupData)
+
+ public:
+  char *printerCommand;
+  char *previewCommand;
+  char *printerFlags;
+  char *printerFile;
+  int printerOrient;
+  float printerScaleX;
+  float printerScaleY;
+  float printerTranslateX;
+  float printerTranslateY;
+  // 1 = Preview, 2 = print to file, 3 = send to printer
+  int printerMode;
+  char *afmPath;
+  // A name in the paper database (see wx_print.h: the printing framework)
+  char *paperName;
+  Bool printColour;
+ public:
+  wxPrintSetupData(void);
+  ~wxPrintSetupData(void);
+
+  void SetPrinterCommand(char *cmd);
+  void SetPaperName(char *paper);
+  void SetPrintPreviewCommand(char *cmd);
+  void SetPrinterOptions(char *flags);
+  void SetPrinterFile(char *f);
+  void SetPrinterOrientation(int orient);
+  void SetPrinterScaling(float x, float y);
+  void SetPrinterTranslation(float x, float y);
+  // 1 = Preview, 2 = print to file, 3 = send to printer
+  void SetPrinterMode(int mode);
+  void SetAFMPath(char *f);
+  void SetColour(Bool col);
+
+  // Get current values
+  char *GetPrinterCommand(void);
+  char *GetPrintPreviewCommand(void);
+  char *GetPrinterOptions(void);
+  char *GetPrinterFile(void);
+  char *GetPaperName(void);
+  int GetPrinterOrientation(void);
+  void GetPrinterScaling(float *x, float *y);
+  void GetPrinterTranslation(float *x, float *y);
+  int GetPrinterMode(void);
+  char *GetAFMPath(void);
+  Bool GetColour(void);
+
+  void operator=(wxPrintSetupData& data);
+};
+
+extern wxPrintSetupData *wxThePrintSetupData;
+extern void wxInitializePrintSetupData(Bool init = TRUE);
+
+
+/*
+ * Again, this only really needed for non-Windows platforms
+ * or if you want to test the PostScript printing under Windows.
+ */
+
+class wxPrintPaperType: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxPrintPaperType)
+
+ public:
+  int widthMM;
+  int heightMM;
+  int widthPixels;
+  int heightPixels;
+  char *pageName;
+
+  wxPrintPaperType(char *name = NULL, int wmm = 0, int hmm = 0, int wp = 0, int hp = 0);
+  ~wxPrintPaperType(void);
+};
+
+class wxPrintPaperDatabase: public wxList
+{
+  DECLARE_DYNAMIC_CLASS(wxPrintPaperDatabase)
+
+ public:
+  wxPrintPaperDatabase(void);
+  ~wxPrintPaperDatabase(void);
+
+  void CreateDatabase(void);
+  void ClearDatabase(void);
+
+  void AddPaperType(char *name, int wmm, int hmm, int wp, int hp);
+  wxPrintPaperType *FindPaperType(char *name);
+};
+
+extern wxPrintPaperDatabase *wxThePrintPaperDatabase;
+
+#endif
+
+#endif // IN_CPROTO
+#endif // USE_POSTSCRIPT
+#endif // wx_dcpsh
diff --git a/src/wxmac/include/base/wx_enhdg.h b/src/wxmac/include/base/wx_enhdg.h
new file mode 100644
index 0000000..edd0599
--- /dev/null
+++ b/src/wxmac/include/base/wx_enhdg.h
@@ -0,0 +1,74 @@
+/*
+ * File:	wx_enhdg.h
+ * Purpose:	wxEnhancedDialogBox
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_enhdg.h	1.2 5/9/94" */
+
+#ifndef wx_enhdgh
+#define wx_enhdgh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_ENHANCED_DIALOG
+#include "wx_item.h"
+#include "wx_check.h"
+#include "wx_messg.h"
+#include "wx_dialg.h"
+
+#ifdef IN_CPROTO
+typedef	void	*wxEnhDialogBox;
+#else
+
+// Enhanced Dialog boxes
+class wxEnhDialogBox: public wxDialogBox
+{
+ public:
+  wxPanel *panel ;
+#ifndef wx_xview
+  wxPanel *pinPanel;
+#endif
+  long style ;
+  Bool pinned ;
+  wxCheckBox *pinCheck ;
+  wxMessage *statusText ;
+  wxPanel *userPanel;
+  wxPanel *secondaryPanel;
+  wxPanel *cmdPanel ;
+  wxPanel *statusPanel;
+  wxFunction unshow ;
+  int userSpacing ;
+  int maxWidth;
+  int maxHeight ;
+
+  // 0,0,10,10 to be sure that resize works.
+  wxEnhDialogBox(wxFrame *frame, char *title, Bool modal = FALSE,
+              wxFunction fun = NULL,int space = -1 ,
+              int x = 0, int y = 0,
+              int width = 10, int height = 10,
+	      long style = wxENH_DEFAULT , char *name = "Shell" );
+  ~wxEnhDialogBox();
+
+  void SetStatus(char *label=NULL) ;
+  wxButton* AddCmd(char *label,wxFunction fun=NULL,int tag = 0) ;
+  wxButton* AddCmd(wxBitmap *bitmap,wxFunction fun=NULL,int tag = 0) ;
+  wxButton *GetCmd(int number) ;
+  void SetPin(Bool flag) ;
+  void Show(Bool show,Bool flag = FALSE) ;
+  void PreFit(void);	 // Get a secondary wxPanel
+  void PrimaryFit(void); // Internal use only
+  void Fit(void);	 // Final Fitting
+} ;
+
+#endif // IN_CPROTO
+#endif // USE_ENHANCED_DIALOG
+#endif // wx_enhdgh
diff --git a/src/wxmac/include/base/wx_form.h b/src/wxmac/include/base/wx_form.h
new file mode 100644
index 0000000..6cd8fcc
--- /dev/null
+++ b/src/wxmac/include/base/wx_form.h
@@ -0,0 +1,284 @@
+/*
+ * File:	wx_form.h
+ * Purpose:	
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+/*
+ * Purpose:  Declaration of the wxForm object and related functions, for
+ *           creating forms with constrained user-editable items.
+ */
+
+
+#ifndef wxb_formh
+#define wxb_formh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_FORM
+
+#include "wx_item.h"
+
+// Data types
+typedef enum { 
+ wxFORM_SHORT = 1,
+ wxFORM_LONG,
+ wxFORM_STRING,
+ wxFORM_BOOL,
+ wxFORM_FLOAT,
+ wxFORM_LIST_OF_LONGS,
+ wxFORM_LIST_OF_STRINGS
+} form_data_types_t;
+
+// Editor types
+typedef enum {
+ wxFORM_DEFAULT = 1, // wxFORM_DEFAULT: use whatever is most suitable
+ wxFORM_SINGLE_LIST,
+ wxFORM_MULTI_LIST,
+ wxFORM_CHOICE,
+ wxFORM_CHECKBOX,
+ wxFORM_TEXT,
+ wxFORM_MULTITEXT,
+ wxFORM_SLIDER,
+ wxFORM_MESSAGE,
+ wxFORM_NEWLINE,
+ wxFORM_BUTTON,
+ wxFORM_DUMB_MESSAGE,
+ wxFORM_RADIOBOX
+} form_editor_types_t;
+
+// Editable or not editable
+typedef enum {
+ wxFORM_NOT_EDITABLE,
+ wxFORM_EDITABLE
+} form_edit_t;
+
+// Constraint types
+typedef enum {
+ wxFORM_CONSTRAINT_ONE_OF  =  1,
+ wxFORM_CONSTRAINT_RANGE,
+ wxFORM_CONSTRAINT_FUNCTION,
+ wxFORM_CONSTRAINT_IS_INT,
+ wxFORM_CONSTRAINT_IS_STRING,
+ wxFORM_CONSTRAINT_IS_REAL,
+ wxFORM_CONSTRAINT_IS_BOOL
+} form_constraint_types_t;
+
+// Form buttons
+#define wxFORM_BUTTON_OK          1
+#define wxFORM_BUTTON_CANCEL      2
+#define wxFORM_BUTTON_UPDATE      4
+#define wxFORM_BUTTON_REVERT      8
+#define wxFORM_BUTTON_HELP        16
+#define wxFORM_BUTTON_ALL (wxFORM_BUTTON_OK|wxFORM_BUTTON_CANCEL|wxFORM_BUTTON_UPDATE|wxFORM_BUTTON_REVERT)
+
+// Form buttons placement
+#define wxFORM_BUTTON_AT_TOP      1
+#define wxFORM_BUTTON_AT_BOTTOM   2
+
+// Returns FALSE if constraint violated, print error to msg_buffer.
+// Cast value to POINTER to appropriate value.
+typedef Bool (*wxConstraintFunction) (int type, char *value, char *label, char *msg_buffer);
+
+// Edits a value with a user-supplied editor, placing result in
+// variable pointed to by value.
+typedef Bool (*wxEditFunction) (int type, char *current_value, char *variable);
+
+#ifdef IN_CPROTO
+typedef       void    *wxRealRange ;
+typedef       void    *wxFormItemConstraint;
+typedef       void    *wxFormItem;
+typedef       void    *wxForm;
+#else
+
+class wxRealRange: public wxObject
+{
+ public:
+  float lo;
+  float hi;
+  wxRealRange(float lo, float hi);
+};
+
+class wxFormItemConstraint: public wxObject
+{
+ public:
+  int Type;
+  Bool localList ; // For remembering to delete (or not) OneOf.
+  union
+  {
+    wxList *OneOf; // List of strings or longs
+    wxConstraintFunction ConstraintFunc;
+    wxRealRange *Range;
+  } Constraint;
+
+  wxFormItemConstraint(int type);
+  ~wxFormItemConstraint(void);
+};
+
+// A form item contains information about the C++ variable
+// containing the data, the type, the constraints, error messages, help
+// information.
+class wxForm;
+class wxFormItem: public wxObject
+{
+ public:
+  long Id;
+  int Type;
+  int ItemType;
+  int Width;
+  int Height;
+  int style;
+  wxForm *Form;
+  wxItem *PanelItem;
+  wxList *Constraints;
+//  wxEditFunction CustomEditor;
+  char *HelpString;
+  char *Label;
+  wxFunction ButtonFunc;
+
+  // Temporary value before user clicks Ok on form
+  union
+  {
+    float FloatValue;
+    long LongIntValue;
+    int ShortIntValue;
+    char *StringValue;
+    Bool BoolValue;
+    wxList *ListValue;
+    wxFunction ButtonFunction;
+  } Value;
+
+  // Pointer to (for example) some C++ object member
+  union
+  {
+    float *FloatValuePtr;
+    long *LongIntValuePtr;
+    int *ShortIntValuePtr;
+    char **StringValuePtr;
+    Bool *BoolValuePtr;
+    wxList **ListValuePtr;
+  } ValuePtr;
+
+   wxFormItem(int type, int item_type);
+   ~wxFormItem(void);
+
+   void MakePanelItem(wxPanel *panel);
+
+   // Checking functions
+   Bool CheckLongValue(long val);
+   Bool CheckBoolValue(Bool val);
+   Bool CheckStringValue(char *val);
+   Bool CheckFloatValue(float val);
+
+   // Set C++ variable to currently edited value(s) if doesn't
+   // violate any constraint. Returns TRUE if successful.
+   Bool UpdateValue(void);
+
+   // Display current C++ variable value
+   void RevertValue(void);
+
+   // Get panel item (only available AFTER association with
+   // panel/dialog)
+   inline wxItem *GetPanelItem(void) { return PanelItem; }
+};
+
+// A form is independent from an actual panel or dialog,
+// but can be associated with one
+class wxForm: public wxObject
+{
+  int buttonUse;
+  int buttonPlace;
+ public:
+  wxList FormItems;
+  wxPanel *wx_form_panel;
+  Bool wx_editable;
+  wxForm(int button_use = wxFORM_BUTTON_ALL, int button_place = wxFORM_BUTTON_AT_TOP);
+  ~wxForm(void);
+  void Add(wxFormItem *item, long id = -1);
+  void MakeAndPlaceButtons(wxPanel *panel);
+  wxNode *FindItem(long id);
+  Bool Set(long id, wxFormItem *item);
+  Bool Delete(long id);
+  void AssociatePanel(wxPanel *panel);
+  void DisassociatePanel(void);
+  Bool UpdateValues(void);
+  void RevertValues(void);
+  inline void SetEditable(Bool editable)
+    { wx_editable = editable; }
+  inline Bool IsEditable(void)
+    { return wx_editable; }
+
+  // Default behaviour for OnOk/OnCancel - delete form and panel/dialog box
+  virtual void OnOk(void);
+  virtual void OnCancel(void);
+  virtual void OnRevert(void);
+  virtual void OnUpdate(void);
+  virtual void OnHelp(void);
+};
+
+// Functions for making wxFormItems
+wxFormItem *wxMakeFormButton(char *label, wxFunction fun);
+
+wxFormItem *wxMakeFormMessage(char *label);
+
+wxFormItem *wxMakeFormNewLine(void);
+
+wxFormItem *wxMakeFormLong(char *label, long *var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+wxFormItem *wxMakeFormShort(char *label, int *var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+wxFormItem *wxMakeFormFloat(char *label, float *var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+wxFormItem *wxMakeFormBool(char *label, Bool *var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+wxFormItem *wxMakeFormString(char *label, char **var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+/* NOT IMPLEMENTED
+// List of strings
+wxFormItem *wxMakeFormStringList(char *label, wxList **var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+
+// List of longs
+wxFormItem *wxMakeFormLongList(char *label, wxList **var,
+  int item_type = wxFORM_DEFAULT, wxList *constraints = NULL,
+  char *help_string = NULL, int style = 0,
+  int width = -1, int height = -1);
+*/
+
+// Functions for making wxFormItemConstraints
+wxFormItemConstraint *wxMakeConstraintStrings(wxList *list);
+wxFormItemConstraint *wxMakeConstraintStrings(char *first ...);
+// wxFormItemConstraint *wxMakeConstraintLongs(wxList *list);
+wxFormItemConstraint *wxMakeConstraintFunction(wxConstraintFunction func);
+wxFormItemConstraint *wxMakeConstraintRange(float lo, float hi);
+
+#endif // IN_CPROTO
+#endif // USE_FORM
+#endif // wxb_formh
diff --git a/src/wxmac/include/base/wx_hash.h b/src/wxmac/include/base/wx_hash.h
new file mode 100644
index 0000000..431103d
--- /dev/null
+++ b/src/wxmac/include/base/wx_hash.h
@@ -0,0 +1,98 @@
+/*
+ * File:	wx_hash.h
+ * Purpose:	Basic hash table implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_hash.h	1.2 5/9/94" */
+
+#ifndef wxb_hashh
+#define wxb_hashh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "wx_obj.h"
+#include "wx_list.h"
+
+/*
+ * A hash table is an array of user-definable size with lists
+ * of data items hanging off the array positions.  Usually there'll
+ * be a hit, so no search is required; otherwise we'll have to run down
+ * the list to find the desired item.
+*/
+
+#ifdef IN_CPROTO
+typedef       void    *wxHashTable ;
+#else
+
+class wxHashTable: public wxObject
+{
+ public:
+  size_t n;
+  int current_position;
+  wxNode *current_node;
+
+  unsigned int key_type;
+  wxList **hash_table;
+
+  wxHashTable(unsigned int the_key_type, size_t size = 1000);
+  ~wxHashTable(void);
+
+  // Note that there are 2 forms of Put, Get.
+  // With a key and a value, the *value* will be checked
+  // when a collision is detected. Otherwise, if there are
+  // 2 items with a different value but the same key,
+  // we'll retrieve the WRONG ONE. So where possible,
+  // supply the required value along with the key.
+  // In fact, the value-only versions make a key, and still store
+  // the value. The use of an explicit key might be required
+  // e.g. when combining several values into one key.
+  // When doing that, it's highly likely we'll get a collision,
+  // e.g. 1 + 2 = 3, 2 + 1 = 3.
+
+  // key and value are NOT necessarily the same
+  void Put(long key, long value, wxObject *object);
+  void Put(long key, char *value, wxObject *object);
+
+  // key and value are the same
+  void Put(long value, wxObject *object);
+  void Put(const char *value, wxObject *object);
+
+  // key and value not the same
+  wxObject *Get(long key, long value);
+  wxObject *Get(long key, char *value);
+
+  // key and value are the same
+  wxObject *Get(long value);
+  wxObject *Get(const char *value);
+
+  // Deletes entry and returns data if found
+  wxObject *Delete(long key);
+  wxObject *Delete(const char *key);
+
+  wxObject *Delete(long key, int value);
+  wxObject *Delete(long key, char *value);
+
+  // Construct your own integer key from a string, e.g. in case
+  // you need to combine it with something
+  long MakeKey(const char *string);
+
+  // Way of iterating through whole hash table (e.g. to delete everything)
+  // Not necessary, of course, if you're only storing pointers to
+  // objects maintained separately
+
+  void BeginFind(void);
+  wxNode *Next(void);
+
+  void DeleteContents(Bool flag);
+  void Clear(void);
+
+};
+
+#endif // IN_CPROTO
+#endif // wxb_hashh
diff --git a/src/wxmac/include/base/wx_help.h b/src/wxmac/include/base/wx_help.h
new file mode 100644
index 0000000..6652fb3
--- /dev/null
+++ b/src/wxmac/include/base/wx_help.h
@@ -0,0 +1,80 @@
+/*
+ * File:	wx_help.h
+ * Purpose:	API for invoking wxHelp
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_help.h	1.2 5/9/94" */
+
+#ifndef wxb_helph
+#define wxb_helph
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include <stdio.h>
+#include "wx.h"
+#if USE_HELP
+
+#include <wx_ipc.h>
+
+#ifdef IN_CPROTO
+typedef       void    *wxHelpConnection ;
+typedef       void    *wxHelpInstance;
+#else
+
+class wxHelpInstance;
+class wxHelpConnection: public wxConnection
+{
+ public:
+  wxHelpInstance *helpInstance;
+  wxHelpConnection(wxHelpInstance *instance);
+  Bool OnDisconnect(void);
+};
+
+// An application can have one or more instances of wxHelp,
+// represented by an object of this class.
+// Nothing happens on initial creation; the application
+// must call a member function to display help.
+// If the instance of wxHelp is already active, that instance
+// will be used for subsequent help.
+
+class wxHelpInstance: public wxClient
+{
+ public:
+  char *helpFile;
+  int  helpServer;
+  char *helpHost;
+  Bool helpRunning;
+  Bool useNative; // Use native help system if possible
+  wxHelpConnection *helpConnection;
+  wxHelpInstance(Bool native = FALSE);
+  ~wxHelpInstance(void);
+
+  // Must call this to set the filename and server name
+  Bool Initialize(char *file, int server = -1);
+  // If file is NULL, reloads file given  in Initialize
+  Bool LoadFile(char *file = NULL);
+  Bool DisplayContents(void);
+  Bool DisplaySection(int sectionNo);
+  Bool DisplayBlock(long blockNo);
+  Bool KeywordSearch(char *k);
+
+  Bool Quit(void);
+  virtual void OnQuit(void);
+
+  // Private
+  Bool Run(void);
+
+  inline wxConnection *OnMakeConnection(void)
+    { return new wxHelpConnection(this); 
+    }
+};
+
+#endif // IN_CPROTO
+#endif // USE_HELP
+#endif // wxb_helph
diff --git a/src/wxmac/include/base/wx_list.h b/src/wxmac/include/base/wx_list.h
new file mode 100644
index 0000000..c10604c
--- /dev/null
+++ b/src/wxmac/include/base/wx_list.h
@@ -0,0 +1,207 @@
+/*								-*- C++ -*-
+ * File:		wx_list.h
+ * Purpose:	wxList implementation much used in wxWindows
+ * Author:		Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+#ifndef wxb_listh
+#define wxb_listh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef wx_xt
+    // wxWindows standard include mechanism
+    /* sccsid[] = "@(#)wx_list.h	1.2 5/9/94" */
+#   include "common.h"
+#   include "wx_obj.h"
+#endif
+
+#ifdef IN_CPROTO
+typedef       void    *wxList ;
+typedef       void    *wxNode;
+typedef       void    *wxStringList;
+#else
+
+class wxList;
+
+enum KeyType {wxKEY_NONE = 0, wxKEY_INTEGER, wxKEY_STRING};
+
+class wxNode
+{
+ private:
+ 
+  wxObject *data;
+  wxNode *next;
+  wxNode *previous;
+
+ public:
+  // Optional key stuff
+  union
+  {
+    long integer;
+    char *string;
+  } key;
+
+  wxNode(wxList *the_list = NULL, wxNode *last_one = NULL, wxNode *next_one = NULL, wxObject *object = NULL);
+  wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
+         wxObject *object, long the_key);
+  wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
+         wxObject *object, const char *the_key);
+
+  void Kill(wxList *list);
+
+  inline wxNode *Next(void) { return next; }
+  inline wxNode *Previous(void) { return previous; }
+  inline wxObject *Data(void) { return data; }
+  inline void SetData(wxObject *the_data) { data = the_data; }
+  /* MATTHEW: [5] */
+  inline void     DataGCIgnored(void)         { WXGC_IGNORE(data); }
+};
+
+// type of compare function for list sort operation (as in 'qsort')
+typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
+
+class wxList: public wxObject
+{
+
+ public:
+#ifdef wx_mac
+  	enum DestroyDataCode {kNoDestroyData = 0, kDestroyData = 1};
+#endif // wx_mac
+  int n;
+  int destroy_data;
+  wxNode *first_node;
+  wxNode *last_node;
+  unsigned int key_type;
+
+#ifdef wx_mac
+  wxList(DestroyDataCode destroyData = kNoDestroyData, Bool clean_up = TRUE);
+#else // wx_mac
+  wxList(void);
+#endif // wx_mac
+  wxList(KeyType the_key_type, Bool clean_up = TRUE);
+  wxList(int N, wxObject *Objects[]);
+  wxList(wxObject *object, ...);
+  ~wxList(void);
+
+  inline int Number(void) { return n; }
+
+  // Append to end of list
+  inline wxNode *Append(wxObject *object)
+  {
+    wxNode *node = new wxNode(this, last_node, NULL, object);
+    if (!first_node)
+      first_node = node;
+    last_node = node;
+    n ++;
+    return node;
+  }
+
+  // Insert at front of list
+  wxNode *Insert(wxObject *object);
+
+  // Insert before given node
+  wxNode *Insert(wxNode *position, wxObject *object);
+
+  // Keyed append
+  wxNode *Append(long key, wxObject *object);
+  wxNode *Append(const char *key, wxObject *object);
+
+  Bool DeleteNode(wxNode *node);
+  Bool DeleteObject(wxObject *object);  // Finds object pointer and
+                                        // deletes node (and object if
+                                        // DeleteContents is on)
+  void Clear(void);                     // Delete all nodes
+
+#ifdef wx_mac
+  Bool OnDeleteObject(wxObject *object); // mac platform only
+  long MemberIndex(wxObject *object); // WCH wx_mac added 8/12/94
+#endif // wx_mac
+
+  inline wxNode *First(void) { return first_node; }
+  inline wxNode *Last(void) { return last_node; }
+  wxNode *Nth(int i);                  // nth node counting from 0
+
+  // Keyed search
+  wxNode *Find(long key);
+  wxNode *Find(const char *key);
+
+  wxNode *Member(wxObject *object);
+
+  inline void DeleteContents(int destroy) { destroy_data = destroy; }
+                                             // Instruct it to destroy user data
+                                             // when deleting nodes
+  // this function allows the sorting of arbitrary lists by giving
+  // a function to compare two list elements.
+  void Sort(wxSortCompareFunction compfunc);
+
+#ifdef MEMORY_USE_METHOD
+  long MemoryUse(void);
+#endif
+};
+
+// String list class. N.B. this always copies strings
+// with Add and deletes them itself.
+class wxStringList: public wxList
+{
+
+ public:
+  wxStringList(void);
+  wxStringList(char *first ...);
+  ~wxStringList(void);
+
+  virtual wxNode *Add(const char *s);
+  virtual void Delete(const char *s);
+  virtual char **ListToArray(Bool new_copies = FALSE);
+  virtual void Sort(void);
+  virtual Bool Member(const char *s);
+};
+
+class wxChildList;
+
+class wxChildNode
+{
+public:
+  wxChildList *owner;
+  wxObject *strong;
+  wxObject **weak; /* atomic-allocated disappearing ptr */
+
+  wxChildNode *Next();
+  wxObject *Data();
+  Bool IsShown();
+};
+
+class wxChildList
+{
+ public:
+  int n;
+  int size;
+  wxChildNode **nodes;
+
+  wxChildList(void);
+  ~wxChildList(void);
+
+  inline int Number(void) { return n; }
+
+  // Append to end of list
+  void Append(wxObject *object);
+
+  Bool DeleteObject(wxObject *object);
+  Bool DeleteNode(wxChildNode *node);
+
+  inline wxChildNode *First(void) { return FindNode(NULL); }
+  
+  wxChildNode *FindNode(wxChildNode *after);
+
+  void Show(wxObject *object, Bool show);
+
+  Bool IsShown(wxObject *object);
+};
+
+#endif // IN_CPROTO
+#endif // wxb_listh
diff --git a/src/wxmac/include/base/wx_mgstr.h b/src/wxmac/include/base/wx_mgstr.h
new file mode 100644
index 0000000..d6a5bb6
--- /dev/null
+++ b/src/wxmac/include/base/wx_mgstr.h
@@ -0,0 +1,63 @@
+/*
+ * File:	wx_mgstr.h
+ * Purpose:	simple language support
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_mgstr.h	1.2 5/9/94" */
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef wx_mgstr
+#define wx_mgstr
+
+typedef enum {
+  wxLANGUAGE_DEFAULT,
+  wxLANGUAGE_GERMAN,
+  wxLANGUAGE_ENGLISH
+} wxlanguage_t;
+
+extern char **wx_msg_str;
+extern void wxSetLanguage(wxlanguage_t language);
+
+#define wxSTR(X)	wx_msg_str[X]
+
+// Generic Message Box titles
+#define wxSTR_ERROR                  wx_msg_str[0]
+#define wxSTR_WARNING                wx_msg_str[1]
+
+// wxForm messages:
+#define wxSTR_YES                    wx_msg_str[2]
+#define wxSTR_NO                     wx_msg_str[3]
+
+#define wxSTR_BUTTON_OK              wx_msg_str[4]
+#define wxSTR_BUTTON_CANCEL          wx_msg_str[5]
+#define wxSTR_BUTTON_REVERT          wx_msg_str[6]
+#define wxSTR_BUTTON_UPDATE          wx_msg_str[7]
+#define wxSTR_CONSTRAINT_VIOLATION   wx_msg_str[8]
+#define wxSTR_VIOLATION_FLOAT        wx_msg_str[9]
+#define wxSTR_VIOLATION_LONG         wx_msg_str[10]
+
+#define wxSTR_MENU_HELP              wx_msg_str[11]
+#define wxSTR_BUTTON_HELP            wx_msg_str[12]
+
+// File Dialog Messages
+#define wxSTR_FILE_SELECTOR          wx_msg_str[13]
+#define wxSTR_OVERWRITE_FILE         wx_msg_str[14]
+#define wxSTR_LOAD_FILE              wx_msg_str[15]
+#define wxSTR_SAVE_FILE              wx_msg_str[16]
+#define wxSTR_ENTER_FILENAME         wx_msg_str[17]
+#define wxSTR_LABEL_FILENAME         wx_msg_str[18]
+#define wxSTR_LABEL_PATH             wx_msg_str[19]
+#define wxSTR_LABEL_FILES            wx_msg_str[20]
+#define wxSTR_LABEL_DIRS             wx_msg_str[21]
+
+// Misc Messages
+#define wxSTR_HELP_TIMEOUT           wx_msg_str[22]
+
+#endif // wx_mgstr.h
diff --git a/src/wxmac/include/base/wx_obj.h b/src/wxmac/include/base/wx_obj.h
new file mode 100644
index 0000000..929cee8
--- /dev/null
+++ b/src/wxmac/include/base/wx_obj.h
@@ -0,0 +1,46 @@
+/*
+ * File:	wx_obj.h
+ * Purpose:	Top level object for wxWindows
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_obj.h	1.2 5/9/94" */
+
+#ifndef wxb_objh
+#define wxb_objh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxObject ;
+#else
+
+#if WXGARBAGE_COLLECTION_ON
+#include "gc_cpp.h"
+#define WXGC_IGNORE(ptr) GC_general_register_disappearing_link((void **)&(ptr), NULL)
+#define WXGC_ATOMIC (AtomicGC)
+#define WXGC_NO_CLEANUP FALSE
+class wxObject : public gc_cleanup
+#else
+#define WXGC_IGNORE(ptr)
+#define WXGC_ATOMIC
+class wxObject
+#endif
+{
+  public:
+  WXTYPE __type;
+  wxObject(void);
+  wxObject(Bool cleanup);
+  wxObject(Bool cleanup, WXTYPE t);
+  virtual ~wxObject(void);
+};
+
+#endif // IN_CPROTO
+#endif // wx_objh
diff --git a/src/wxmac/include/base/wx_res.h b/src/wxmac/include/base/wx_res.h
new file mode 100644
index 0000000..5903682
--- /dev/null
+++ b/src/wxmac/include/base/wx_res.h
@@ -0,0 +1,201 @@
+/*
+ * File:	wb_res.h
+ * Purpose:	Resource processor
+ * Author:	Julian Smart
+ * Created:	1994
+ * Updated:	
+ * Copyright:	(c) 1994, Julian Smart
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wxb_resh
+#define wxb_resh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "wx_setup.h"
+
+#if USE_WX_RESOURCES
+#include <stdio.h>
+
+// A few further types not in wx_types.h
+#define wxRESOURCE_TYPE_SEPARATOR   1000
+#define wxRESOURCE_TYPE_XBM_DATA    1001
+#define wxRESOURCE_TYPE_XPM_DATA    1002
+
+/*
+ * Internal format for control/panel item
+ */
+ 
+class wxItemResource: public wxObject
+{
+ protected:
+  wxList children;
+  WXTYPE itemType;
+  int x, y, width, height;
+  char *title;
+  char *name;
+  long windowStyle;
+  long value1, value2, value3;
+  char *value4;
+  wxStringList *stringValues; // Optional string values
+  wxBitmap *bitmap;
+ public:
+ 
+  wxItemResource(void);
+  ~wxItemResource(void);
+
+  inline void SetType(WXTYPE typ) { itemType = typ; }
+  inline void SetStyle(long styl) { windowStyle = styl; }
+  inline void SetBitmap(wxBitmap *bm) { bitmap = bm; }
+  inline wxBitmap *GetBitmap(void) { return bitmap; }
+  inline void SetSize(int xx, int yy, int ww, int hh)
+  {  x = xx; y = yy; width = ww; height = hh; }
+  void SetTitle(char *t);
+  void SetName(char *n);
+  inline void SetValue1(long v) { value1 = v; }
+  inline void SetValue2(long v) { value2 = v; }
+  inline void SetValue3(long v) { value3 = v; }
+  void SetValue4(char *v);
+  inline void SetStringValues(wxStringList *svalues) { stringValues = svalues; }
+
+  inline WXTYPE GetType(void) { return itemType; }
+  inline int GetX(void) { return x; }
+  inline int GetY(void) { return y; }
+  inline int GetWidth(void) { return width; }
+  inline int GetHeight(void) { return height; }
+
+  inline char *GetTitle(void) { return title; }
+  inline char *GetName(void) { return name; }
+  inline long GetStyle(void) { return windowStyle; }
+
+  inline long GetValue1(void) { return value1; }
+  inline long GetValue2(void) { return value2; }
+  inline long GetValue3(void) { return value3; }
+  inline char *GetValue4(void) { return value4; }
+  inline wxList& GetChildren(void) { return children; }
+  inline wxStringList *GetStringValues(void) { return stringValues; }
+};
+
+/*
+ * Resource table (normally only one of these)
+ */
+ 
+class wxResourceTable: public wxHashTable
+{
+  protected:
+    
+  public:
+    wxResourceTable(void);
+    ~wxResourceTable(void);
+    
+    wxItemResource *FindResource(char *name);
+    void AddResource(wxItemResource *item);
+    Bool DeleteResource(char *name);
+
+    Bool ParseResourceFile(char *filename);
+    Bool ParseResourceData(char *data);
+    Bool SaveResource(char *filename);
+
+    // Register XBM/XPM data
+    Bool RegisterResourceBitmapData(char *name, char bits[], int width, int height);
+    Bool RegisterResourceBitmapData(char *name, char **data);
+
+    void ClearTable(void);
+};
+
+extern wxResourceTable wxDefaultResourceTable;
+
+extern long wxParseWindowStyle(char *style);
+
+class wxMenuBar;
+class wxMenu;
+class wxBitmap;
+class wxIcon;
+extern wxBitmap *wxResourceCreateBitmap(char *resource);
+extern wxIcon *wxResourceCreateIcon(char *resource);
+extern wxMenuBar *wxResourceCreateMenuBar(char *resource);
+extern wxMenu *wxResourceCreateMenu(char *resource);
+extern Bool wxResourceParseData(char *resource);
+extern Bool wxResourceParseFile(char *filename);
+extern void wxResourceClear(void);
+// Register XBM/XPM data
+extern Bool wxResourceRegisterBitmapData(char *name, char bits[], int width, int height);
+extern Bool wxResourceRegisterBitmapData(char *name, char **data);
+#define wxResourceRegisterIconData wxResourceRegisterBitmapData
+
+/*
+ * Resource identifer code: #define storage
+ */
+
+extern Bool wxResourceAddIdentifier(char *name, int value);
+extern int wxResourceGetIdentifier(char *name);
+
+/*
+ * Proposed PROLOGIO resource file format
+ */
+/*
+ * Dialog/panel
+static char *name1 = "dialog(name = \"name\",\
+  title = \"title\",\
+  style = \"wxDEFAULT_DIALOG_STYLE\",\
+  button_font = [12, 'wxSWISS', 'wxITALIC', 'wxBOLD', 0],
+  label_font = [12, 'wxSWISS', 'wxITALIC', 'wxBOLD', 0],
+  modal = 1,
+  x = 0, y = 0, width = 100, height = 200,\
+  control = [wxButton, \"OK\", \"style\", \"name\", 10, 10, 55, 30],\
+  control = [wxButton, \"\", \"style\", \"name\", 10, 10, 55, 30, \"bitmapresource\"],\
+  control = [wxText  , \"Text\", \"style\", \"name\", 10, 10, 55, 30, \"default value\"],\
+  control = [wxMultiText, \"Lines\", \"style\", \"name\", 10, 10, 55, 30, \"default value\"],\
+  control = [wxListBox, \"List\", \"wxHSCROLL\", \"name\", 10, 10, 55, 30, [\"value1\", \"value2\"], wxMULTIPLE],\
+  control = [wxChoice, \"Choice\", \"style\", \"name\", 10, 10, 55, 30, [\"value1\", \"value2\"]],\
+  control = [wxGroupBox, \"Group\", \"style\", \"name\", 10, 10, 55, 30],\
+  control = [wxMessage, \"Hello\", \"style\", \"name\", 10, 10, 55, 30],\
+  control = [wxMessage, \"\", \"style\", \"name\", 10, 10, 55, 30, \"bitmapresource\"],\
+  control = [wxRadioBox, \"Radio\", \"style\", \"name\", 10, 10, 55, 30, [\"value1\", \"value2\"]],\
+  control = [wxCheckBox, \"Checkbox\", \"style\", \"name\", 10, 10, 55, 30, 1]).\
+*/
+/*
+ * Bitmap resource
+ * Allows for different bitmap formats on different platforms.
+ * A bitmap specification:
+ * bitmap = [filename, bitmaptype, platform, colours, xresolution, yresolution]
+ * Everything after 'filename' is optional.
+static char *bitmap1 = "bitmap(name = \"bitmap1\",
+  bitmap = [\"open.bmp\", wxBITMAP_TYPE_BMP, \"WINDOWS\"],
+  bitmap = [\"open\", wxBITMAP_TYPE_RESOURCE, \"WINDOWS\"],
+  bitmap = [\"open.xpm\", wxBITMAP_TYPE_XPM, \"X\", 16, 20, 20],
+  bitmap = [\"open.xbm\", wxBITMAP_TYPE_XBM, \"X\", 2, 20, 20],
+ */
+/*
+ * Menu/menubar
+ * Each menu is a list of lists.
+ * The inner list is a menu item specifier as follows:
+ * [string, identifier, helpString, optionalSubMenu]
+ * or
+ * [] for a separator.
+ 
+static char *menuBar1 = "menubar(name = 'menu1',\
+  menu = [[\"&File\", 'FILE_ID', '',\
+            ['&Open', 'OPEN_FILE_ID', \"Open a file\"],\
+            ['&Close', 'CLOSE_FILE_ID', \"Close a file\"],\
+            [],\
+            ['&Exit', 'EXIT_ID', \"Exit program\"]\
+          ],\
+          [\"&Help\", '', '',\
+           ['&About', 'ABOUT_ID', \"About this program\"]]]).";
+
+ * Problem: how to define the identifiers, e.g. OPEN_FILE_ID, so that
+ * they can be used in switch statements too????
+ * Could have another resource format:
+ * identifiers(\
+ *   'FILE_ID' = 1,\
+ *   'OPEN_FILE_ID' = 2,\
+ *   'CLOSE_FILE_ID' = 3).
+ *
+ */
+#endif
+#endif
diff --git a/src/wxmac/include/base/wx_setup.h b/src/wxmac/include/base/wx_setup.h
new file mode 100644
index 0000000..7c8d992
--- /dev/null
+++ b/src/wxmac/include/base/wx_setup.h
@@ -0,0 +1,275 @@
+/*
+ * File:	wx_setup.h
+ * Purpose:	Window library main include file
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wx_setuph
+#define wx_setuph
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+/*
+ * General features
+ *
+ */
+ 
+
+#define USE_POSTSCRIPT 1	// 0 for no PostScript device context
+#define USE_AFM_FOR_POSTSCRIPT 1 // 1 to use font metric files in GetTextExtent
+#define USE_METAFILE   0	// 0 for no Metafile and metafile device context
+#define USE_FORM       0	// 0 for no wxForm
+#define USE_IPC        0	// 0 for no interprocess comms
+// Note: wxHELP uses IPC under X so these are interdependent!
+#define USE_HELP       0	// 0 for no help facility
+#define USE_ENHANCED_DIALOG 0	// 0 for no enhanced dialog
+#define USE_RESOURCES  1	// 0 for no wxGetResource/wxWriteResource
+#define USE_CLIPBOARD  1	// 0 for no clipboard functions
+#define USE_SPLINES    1	// 0 for no splines
+#define USE_XFIG_SPLINE_CODE  1	// 1 for XFIG spline code, 0 for AIAI spline code.
+// AIAI spline code is slower, but freer of copyright issues.
+#define USE_DRAG_AND_DROP 1	// 0 for no drag and drop
+
+#define USE_GAUGE       1
+                                    // Define 1 to use Microsoft's gauge (Windows)
+                                    // or Bull's gauge (Motif) library (both in contrib).
+                                     
+#define USE_XPM_IN_X    0
+#define USE_XPM_IN_MSW  0
+#define USE_XPM_IN_MAC  1
+                                    // Define 1 to support the XPM package in wxBitmap,
+                                    // separated by platform. If 1, you must link in
+                                    // the XPM library to your applications.
+#define USE_IMAGE_LOADING_IN_X          0
+                                  // Use dynamic icon/bitmap loading/saving code in utils/image under X.
+                                  // If this is 1, you will need to link your applications
+                                  // with image_X.lib. where X is motif, ol, or hp.
+
+#define USE_IMAGE_LOADING_IN_MAC        1
+                                  // Use dynamic icon/bitmap loading/saving code in utils/image under X.
+                                  // If this is 1, you will need to link your applications
+                                  // with the objects in utils/image
+#define USE_IMAGE_LOADING_IN_MSW        0
+                                  // Use dynamic DIB loading/saving code in utils/dib under MSW.
+                                  // If this is 1, you will need to link your applications
+                                  // with dib.lib.
+#define USE_RESOURCE_LOADING_IN_MSW     0
+                                  // Use dynamic icon/cursor loading/saving code in utils/rcparser
+                                  // under MSW.
+                                  // If this is 1, you will need to link your applications
+                                  // with rcparser.lib.
+#define USE_PRINTING_ARCHITECTURE  1
+                                    // Set to 0 to disable print/preview architecture code
+#define USE_WX_RESOURCES        0
+                                  // Use .wxr resource mechanism (requires PrologIO library)
+
+#define USE_TOOLBAR				0
+								  // only really used in wx_mac with wx_extend
+
+#define WXGARBAGE_COLLECTION_ON 1
+                                 // Use automatic garbage-collection (mflatt)
+
+/*
+ * Finer detail
+ *
+ */
+/*
+	Macintosh
+*/
+#define USE_PANEL_CANVAS_IN_MAC 1
+#define USE_MAC_DIALOG_PANEL	1	// Set to 1 for Dialogbox to inherit from Panel, not Frame
+//#define USE_MAC_STATUS_SOUTH		// Put status line at bottom of frame if #defined
+//#define USE_MAC_GRAY_LABEL_BACKGROUND
+/*
+ * Motif and XView
+ *
+ */
+
+#define USE_PANEL_CANVAS_IN_X      1
+                                    // wxPanel inherits from wxCanvas in X
+ 
+#define USE_GADGETS                1
+                                    // More efficient to use gadgets for some
+                                    // widgets in Motif. 0 for no gadgets.
+                                    // Please note: there is no reason to not
+                                    // use it except if you intend to modify
+                                    // color of individuals items.
+#define USE_BUTTON_GADGET          0
+                                    // On JACS's system, gadget buttons
+                                    // interfere with default button setting.
+#define PIXEL0_DISABLE             0
+                                    // Define as 1 to disallow allocation
+                                    // of pixel #0 (wxXOR problem).
+                                    // JACS - I found this caused problems.
+
+#define MOTIF_MENUBAR_DELETE_FIX   0
+                                    // On some systems (Ultrix, OSF), deleting a frame
+                                    // from within a menu callback causes a crash.
+                                    // Set to 1 to avoid deleting the menubar handle directly,
+                                    // which seems to cure it.
+#define	DEFAULT_FILE_SELECTOR_SIZE 0
+				    // Let Motif defines the size of File
+				    // Selector Box (if 1), or fix it to
+				    // wxFSB_WIDTH x wxFSB_HEIGHT (if 0)
+#define	wxFSB_WIDTH                600
+#define wxFSB_HEIGHT               500
+
+#define	MOTIF_MANAGE               1
+				    // Control default style of Dialogs
+				    // 1: use wxMOTIF_RESIZE as default
+				    // 0: do not use wxMOTIF_RESIZE as default
+
+#define USE_NOTICES                1
+                                    // Under XView, use Notice package
+                                    // for small messages instead of
+                                    // home-grown dialog boxes
+
+
+/*
+ * Windows/NT
+ *
+ */
+
+	/*
+	 * Special Note about FAFA_LIB, WINDOWS_LOOK, CTL3D
+	 */
+/****************************************************************************
+
+These 3 #define control how graphic controls are managed. Not all combinations
+are valid.
+
+FAFA_LIB=0
+
+	WINDOWS_LOOK is ignored, and forced to 1.
+	CTL3D controls the 3D-rendering using ctl3d.lib
+	All controls are Microsoft
+
+FAFA_LIB=1
+
+	CTL3D=1
+
+		WINDOWS_LOOK is ignored, and forced to 1.
+		3D-rendering is done via ctl3d.lib
+		Only necessary fafa items are created [wxBitmapped'buttons]
+
+	CTL3D=0
+
+		WINDOWS_LOOK=1
+
+			Idem above, but no 3D-rendering.
+
+		WINDOWS_LOOK=0
+
+			3D-rendering is done via fafa.lib.
+			All controls are Fafa.
+
+Recommended configuration:
+
+FAFA_LIB=1 , CTL3D=1 , WINDOWS_LOOK=1
+
+****************************************************************************/
+
+#define ALS_CHOICE_SIZE	           1
+                                    // Lets you choose one of the 2 forms for
+                                    // wxChoice::SetSize
+                                    // EXPERIMENTAL
+
+#define EDITABLE_TEXT_WINDOW       0
+                                    // Editable text window ONLY (a value of 1 compiles
+                                    // OUT the large file support).
+                                    // The editable text window uses
+                                    // an EDIT control, but files must be < 64K
+                                    // If 0, both types of window are allowed.
+#define FAFA_LIB                   1
+                                    // Define 1 for Fafa lib. Mandatory for pixmapped
+                                    // buttons under Windows. If FAFA_LIB is 1
+                                    // and CTL3D is 1, all controls except wxButton
+                                    // will be CTL3D controls: wxButton will
+                                    // be a FAFA button with optional bitmap.
+#define USE_GREY_BACKGROUND        1
+                                    // If 1, uses grey (gray!) panels
+                                    // in FAFA and non-FAFA, non-CTL3D modes.
+                                    // I (JACS) think the controls look better
+                                    // this way. CTL3D always uses grey panels.
+#ifdef WIN32
+#define CTL3D                      0
+                                    // Don't change this
+#elif __WATCOMC__
+#define CTL3D                      0
+                                    // Added by Chubraev for WATCOM. CTL3D & WATCOM
+                                    // don't mix.
+#else
+#define CTL3D                      1
+                                    // Define 1 to use Microsoft CTL3D library.
+                                    // See note above about using FAFA and CTL3D.
+#endif
+
+#define WINDOWS_LOOK		   1
+				    // Define 1 to use as many as possible
+				    // Microsoft controls.
+#define USE_ITSY_BITSY             1
+                                    // Define 1 to use Microsoft's IstyBitsy
+                                    // small title bar library (in contrib)
+
+#define USE_BITMAP_MESSAGE         1
+                                    // Define 1 to use bitmap messages. Windows only so far.
+
+
+#define PROVIDES_DEFAULT_ICONS     0
+                                  // Define the 3 basic icons std,child,mdi
+                                  // if defined to 1. This is useful
+                                  // to avoid BoundChecker Warnings.
+                                  // Unfortunately it breaks SetIcon.
+                                  
+#define USE_PANEL_CANVAS_IN_MSW      1
+                                    // wxPanel inherits from wxCanvas in MSW
+/*
+ * Any platform
+ *
+ */
+#define USE_COMMON_DIALOGS         1
+                                    // On rare occasions (e.g. using DJGPP) may want
+                                    // to omit common dialogs
+                                    // (e.g. file selector, printer dialog).
+                                    // Switching this off also switches off
+                                    // the printing architecture and interactive
+                                    // wxPrinterDC.
+#define ENHANCED_FONTS             1
+                                    // Define 1 to have predefined fonts in
+                                    // wxEnhDialogBox.
+#define USE_PANEL_IN_PANEL         0
+                                    // 1 to use panel in panel in common dialogs
+                                    // Advantage: neater dialogs. Disadvantage:
+				    // messes up default button and
+				    // tab traversal.
+#define USE_TYPEDEFS               0
+                                    // Use typedefs not classes for wxPoint
+				    // and others, to reduce overhead and avoid
+				    // MS C7 memory bug. Bounds checker
+				    // complains about deallocating
+                                    // arrays of wxPoints if wxPoint is a class.
+
+//#define DEBUGLOG 
+
+/*
+ * DO NOT MODIFY THESE LINES!!
+ */
+#if !FAFA_LIB
+#undef WINDOWS_LOOK
+#define WINDOWS_LOOK	1
+#else
+#if CTL3D
+#undef WINDOWS_LOOK
+#define WINDOWS_LOOK	1
+#endif
+#endif
+
+#endif // wx_setuph
+
diff --git a/src/wxmac/include/base/wx_stdev.h b/src/wxmac/include/base/wx_stdev.h
new file mode 100644
index 0000000..04d5b41
--- /dev/null
+++ b/src/wxmac/include/base/wx_stdev.h
@@ -0,0 +1,213 @@
+/*
+ * File:	wx_stdev.h
+ * Purpose:	Standard wxWindows event classes
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_stdev.h	1.2 5/9/94" */
+
+
+#ifndef wxb_stdevh
+#define wxb_stdevh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+#include "wx_sysev.h"
+
+
+/*
+ * Event types
+ *
+ */
+enum {
+ EVENT_TYPES_FIRST = 10000,
+
+/* Command event types */
+ wxEVENT_TYPE_BUTTON_COMMAND,
+ wxEVENT_TYPE_CHECKBOX_COMMAND,
+ wxEVENT_TYPE_RESERVED1,
+ wxEVENT_TYPE_CHOICE_COMMAND,
+ wxEVENT_TYPE_LISTBOX_COMMAND,
+ wxEVENT_TYPE_RESERVED2,
+ wxEVENT_TYPE_TEXT_COMMAND,
+ wxEVENT_TYPE_MULTITEXT_COMMAND,
+ wxEVENT_TYPE_MENU_COMMAND,
+ wxEVENT_TYPE_SLIDER_COMMAND,
+ wxEVENT_TYPE_RADIOBOX_COMMAND,
+ wxEVENT_TYPE_TEXT_ENTER_COMMAND, /* +12 */
+ wxEVENT_TYPE_SET_FOCUS,
+ wxEVENT_TYPE_KILL_FOCUS,
+
+/* Mouse event types */
+ wxEVENT_TYPE_LEFT_DOWN =  EVENT_TYPES_FIRST + 30,
+ wxEVENT_TYPE_LEFT_UP,
+ wxEVENT_TYPE_MIDDLE_DOWN,
+ wxEVENT_TYPE_MIDDLE_UP,
+ wxEVENT_TYPE_RIGHT_DOWN,
+ wxEVENT_TYPE_RIGHT_UP,
+ wxEVENT_TYPE_MOTION,
+ wxEVENT_TYPE_ENTER_WINDOW,
+ wxEVENT_TYPE_LEAVE_WINDOW,
+ wxEVENT_TYPE_LEFT_DCLICK,
+ wxEVENT_TYPE_MIDDLE_DCLICK,
+ wxEVENT_TYPE_RIGHT_DCLICK, /* +41 */
+
+/* Character input event type  */
+ wxEVENT_TYPE_CHAR = EVENT_TYPES_FIRST + 50
+};
+
+#ifdef IN_CPROTO
+typedef       void    *wxCommandEvent ;
+typedef       void    *wxMouseEvent;
+typedef       void    *wxKeyEvent;
+#else
+
+// Item or menu event class
+class wxCommandEvent: public wxEvent
+{
+ public:
+  char *commandString; // String event argument
+  int commandInt;      // Integer event argument
+  long extraLong;      // Additional information (e.g. select/deselect)
+  char *labelString;   // The label of the item
+  char *clientData;    // Arbitrary client data
+  wxCommandEvent(WXTYPE commandType);
+  inline ~wxCommandEvent(void) {}
+
+  /*
+   * Accessors dependent on context
+   *
+   */
+
+  // Get listbox/choice client data  
+  inline virtual char *GetClientData() { return clientData; }
+
+  // Get listbox selection if single-choice
+  inline virtual int GetSelection() { return commandInt; }
+
+  // Get listbox/choice selection string
+  inline virtual char *GetString() { return commandString; }
+
+  // Get checkbox value
+  inline virtual Bool Checked() { return (Bool)commandInt; }
+
+  // TRUE if the listbox event was a selection.
+  inline virtual Bool IsSelection() { return (Bool)extraLong; }
+
+  Bool ReadEvent(istream&);
+  Bool WriteEvent(ostream&);
+};
+
+// Mouse event class
+class wxMouseEvent: public wxEvent
+{
+ public:
+  float x;
+  float y;
+  Bool leftDown;
+  Bool middleDown;
+  Bool rightDown;
+
+  Bool controlDown;
+  Bool shiftDown;
+  Bool altDown;
+  Bool metaDown; // mflatt
+  
+  wxMouseEvent& operator = (wxMouseEvent &src); 
+  
+  wxMouseEvent(WXTYPE mouseType);
+
+  // Was it a button event?
+  virtual Bool IsButton(void);
+
+  // Was it a down event from button 1, 2 or 3 or any?
+  virtual Bool ButtonDown(int but = -1);
+
+  // Was it a dclick event from button 1, 2 or 3 or any?
+  virtual Bool ButtonDClick(int but = -1);
+
+  // Was it a up event from button 1, 2 or 3 or any?
+  virtual Bool ButtonUp(int but = -1);
+
+  // Was the given button 1,2,3 or any changing state?
+  virtual Bool Button(int but);
+
+  // Was the given button 1,2,3 or any in Down state?
+  virtual Bool ButtonIsDown(int but);
+
+  // Find state of shift/control keys
+  virtual Bool ControlDown(void);
+  virtual Bool ShiftDown(void);
+
+  // Find which event was just generated
+  virtual Bool LeftDown(void);
+  virtual Bool MiddleDown(void);
+  virtual Bool RightDown(void);
+
+  virtual Bool LeftUp(void);
+  virtual Bool MiddleUp(void);
+  virtual Bool RightUp(void);
+
+  virtual Bool LeftDClick(void);
+  virtual Bool MiddleDClick(void);
+  virtual Bool RightDClick(void);
+
+  // Find the current state of the mouse buttons (regardless
+  // of current event type)
+  virtual Bool LeftIsDown(void);
+  virtual Bool MiddleIsDown(void);
+  virtual Bool RightIsDown(void);
+
+  // True if a button is down and the mouse is moving
+  virtual Bool Dragging(void);
+
+  // True if the mouse is moving, and no button is down
+  virtual Bool Moving(void);
+
+  // True if the mouse is just entering the window
+  virtual Bool Entering(void);
+
+  // True if the mouse is just leaving the window
+  virtual Bool Leaving(void);
+
+  // Find the position of the event
+  virtual void Position(float *x, float *y);
+
+  Bool ReadEvent(istream&);
+  Bool WriteEvent(ostream&);
+};
+
+// Keyboard input event class
+class wxKeyEvent: public wxEvent
+{
+ public:
+  float x ;
+  float y ;
+  long keyCode;
+  Bool controlDown;
+  Bool shiftDown;
+  Bool altDown;
+  Bool metaDown;		//mflatt
+  
+  wxKeyEvent(WXTYPE keyType);
+
+  virtual Bool ControlDown(void);
+  virtual Bool ShiftDown(void);
+  virtual long KeyCode(void);
+
+  virtual void Position(float *x,float *y) ;
+
+  Bool ReadEvent(istream&);
+  Bool WriteEvent(ostream&);
+};
+
+#endif // IN_CPROTO
+#endif // wxb_stdevh
+
diff --git a/src/wxmac/include/base/wx_sysev.h b/src/wxmac/include/base/wx_sysev.h
new file mode 100644
index 0000000..09b9b8f
--- /dev/null
+++ b/src/wxmac/include/base/wx_sysev.h
@@ -0,0 +1,182 @@
+/*
+ * File:	wx_sysev.h
+ * Purpose:	System event base declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_sysev.h	1.2 5/9/94" */
+
+
+#ifndef wxb_sysevh
+#define wxb_sysevh
+
+#include "common.h"
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "wx_obj.h"
+#include "wx_types.h"
+#ifndef IN_CPROTO
+#ifndef wx_mac
+#include <iostream.h>
+#else
+class istream;
+class ostream;
+#endif
+#endif
+
+/*
+ * wxWindows events, covering all interesting things that might happen
+ * (button clicking, resizing, setting text in widgets, etc.).
+ *
+ * For each completely new event type, derive a new event class.
+ * An event CLASS represents a C++ class defining a range of similar event TYPES;
+ * examples are canvas events, panel item command events.
+ * An event TYPE is a unique identifier for a particular system event,
+ * such as a button press or a listbox deselection.
+ *
+ */
+
+#ifdef IN_CPROTO
+typedef       void    *wxEvent ;
+typedef       void    *wxSystemEventClassStruc;
+typedef       void    *wxSystemEventNameStruc;
+typedef void  *wxEventHandler;
+typedef void  *wxEventConstructor;
+#else
+
+class wxEvent: public wxObject
+{
+ public:
+  char *eventHandle;         // Handle of an underlying windowing system event
+  WXTYPE   eventType;
+  WXTYPE   eventClass;
+  WXTYPE   objectType;
+  wxObject *eventObject;
+  long timeStamp; // mflatt
+
+  wxEvent(void);
+  ~wxEvent(void);
+
+  // Read event's arguments from any input stream
+  virtual Bool ReadEvent(istream& str) = 0;
+  // Write event's arguments to any output stream
+  virtual Bool WriteEvent(ostream& str) = 0;
+
+  inline WXTYPE GetEventType(void) { return eventType; }
+  inline WXTYPE GetEventClass(void) { return eventClass; }
+  inline WXTYPE GetObjectType(void) { return objectType; }
+  inline wxObject *GetEventObject(void) { return eventObject; }
+  inline virtual long GetTimestamp(void) { return timeStamp; } // mflatt
+};
+
+// Event handler function type
+typedef Bool (*wxEventHandler) (wxEvent *event, Bool external);
+
+// Event constructor function type
+typedef wxEvent * (* wxEventConstructor) (WXTYPE eventType);
+
+class wxSystemEventClassStruc: public wxObject
+{
+  public:
+    WXTYPE eventClass;     // Event class, e.g. command event
+    wxEventConstructor eventConstructor;
+    char *eventDescription;
+    inline wxSystemEventClassStruc(void) {}
+    inline ~wxSystemEventClassStruc(void) { if (eventDescription) delete [] eventDescription ; }
+};
+
+class wxSystemEventNameStruc: public wxObject
+{
+  public:
+    WXTYPE eventClass;     // Event class, e.g. command event
+    WXTYPE eventType;      // Individual event type, e.g. button command
+    char *eventName;
+    inline wxSystemEventNameStruc(void) {}
+    inline ~wxSystemEventNameStruc(void) { if (eventName) delete [] eventName ; }
+};
+
+// Send an event to the system, usually will be external, but specify
+// external = FALSE if calling from within the main application in response
+// to other events.
+Bool wxSendEvent(wxEvent& event, Bool external = TRUE);
+
+// Add a primary event handler - the normal event handler for this
+// event. For built-in events, these would include moving and resizing
+// windows. User-defined primary events might include the code to
+// select an image in a diagram (which could of course be achieved by a series
+// of external events for mouse-clicking, but would be more difficult to specify
+// and less robust).
+// Returns TRUE iff it succeeds.
+Bool wxAddPrimaryEventHandler(wxEventHandler handlerFunc);
+
+// Add a secondary (non-essential) event handler (e.g. for intercepting events).
+// pre = TRUE iff it should be called before the
+// event is executed. override = TRUE iff the handler is allowed to override
+// all subsequent events by returning TRUE.
+// Returns TRUE iff it succeeds.
+Bool wxAddSecondaryEventHandler(wxEventHandler handlerFunc,
+                       Bool pre = FALSE, Bool override = FALSE, Bool append = TRUE);
+
+// Remove event handler. Returns TRUE iff it succeeds.
+Bool wxRemoveSecondaryEventHandler(wxEventHandler handlerFunc, Bool pre = FALSE);
+
+// Register a new event class (derived from wxEvent),
+// giving the new event class type, its superclass, a function for creating
+// a new event object of this class, and an optional description.
+void wxRegisterEventClass(WXTYPE eventClassId, WXTYPE superClassId,
+                          wxEventConstructor constructor, char *description = NULL);
+
+// Register the name of the event. This will allow a simple command language
+// where giving the event type name and some arguments will cause
+// a new event of class eventClassId to be created, with given event type,
+// and some arguments, allows an event to be dynamically constructed and sent.
+void wxRegisterEventName(WXTYPE eventTypeId, WXTYPE eventClassId, char *eventName);
+
+// Notify the system of the event you are about to execute/have just executed.
+// If TRUE is returned and pre = TRUE, calling code should not execute the event
+// (i.e. it's been intercepted by a handler and vetoed).
+Bool wxNotifyEvent(wxEvent& event, Bool pre = FALSE);
+
+// Define this and link before wxWindows library to allow
+// registering events from 'outside' the main application
+void wxRegisterExternalEventHandlers(void);
+
+void wxInitStandardEvents(void);
+
+void wxDeleteEventLists(void) ;
+
+/*
+ * Event reading/writing helper functions
+ *
+ */
+
+void wxWriteString(ostream& out, char *s);
+
+void wxWriteInteger(ostream& out, int i);
+
+void wxWriteLong(ostream& out, long i);
+
+void wxWriteFloat(ostream& out, float f);
+
+void wxWriteSpace(ostream& out);
+
+Bool wxReadWhiteSpace(istream& in);
+
+Bool wxReadString(istream& in, char **s);
+
+Bool wxReadInteger(istream& in, int *theInt);
+
+Bool wxReadLong(istream& in, long *theLong);
+
+Bool wxReadFloat(istream& in, float *theFloat);
+
+#endif // IN_CPROTO
+#endif // wxb_sysevh
+
+
diff --git a/src/wxmac/include/base/wx_types.h b/src/wxmac/include/base/wx_types.h
new file mode 100644
index 0000000..70c3c71
--- /dev/null
+++ b/src/wxmac/include/base/wx_types.h
@@ -0,0 +1,129 @@
+/*
+ * File:	wx_types.h
+ * Purpose:	Explicit type system
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wxb_typesh
+#define wxb_typesh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_obj.h"
+#include "wx_hash.h"
+
+// Types of objects
+#define wxTYPE_ANY             0
+#define wxTYPE_OBJECT          wxTYPE_ANY
+#define wxTYPE_WINDOW          1
+#define wxTYPE_DIALOG_BOX      2
+#define wxTYPE_ITEM            3
+#define wxTYPE_PANEL           4
+#define wxTYPE_CANVAS          5
+#define wxTYPE_TEXT_WINDOW     6
+#define wxTYPE_FRAME           7
+
+#define wxTYPE_BUTTON          8
+#define wxTYPE_TEXT            9
+#define wxTYPE_MESSAGE         10
+#define wxTYPE_CHOICE          11
+#define wxTYPE_LIST_BOX        12
+#define wxTYPE_SLIDER          13
+#define wxTYPE_CHECK_BOX       14
+#define wxTYPE_MENU            15
+#define wxTYPE_MENU_BAR        16
+#define wxTYPE_MULTI_TEXT      17
+#define wxTYPE_RADIO_BOX       18
+#define wxTYPE_GROUP_BOX       19
+#define wxTYPE_GAUGE           20
+
+#ifdef wx_mac
+#define wxTYPE_SCREEN_WINDOW   21
+#endif // wx_mac
+
+#define wxTYPE_EVENT           25
+#define wxTYPE_DC              26
+#define wxTYPE_DC_CANVAS       27
+#define wxTYPE_DC_POSTSCRIPT   28
+#define wxTYPE_DC_PRINTER      29
+#define wxTYPE_DC_METAFILE     30
+#define wxTYPE_DC_MEMORY       31
+#define wxTYPE_MOUSE_EVENT     32
+#define wxTYPE_KEY_EVENT       33
+#define wxTYPE_COMMAND_EVENT   34
+
+#define wxTYPE_PEN             40
+#define wxTYPE_BRUSH           41
+#define wxTYPE_FONT            42
+#define wxTYPE_ICON            42
+#define wxTYPE_BITMAP          43
+#define wxTYPE_METAFILE        44
+#define wxTYPE_TIMER           45
+#define wxTYPE_COLOUR          46
+#define wxTYPE_COLOURMAP       47
+#define wxTYPE_CURSOR          48
+
+#define wxTYPE_DDE_CLIENT      60
+#define wxTYPE_DDE_SERVER      61
+#define wxTYPE_DDE_CONNECTION  62
+
+#define wxTYPE_HELP_INSTANCE   63
+
+#define wxTYPE_LIST            70
+#define wxTYPE_STRING_LIST     71
+#define wxTYPE_HASH_TABLE      72
+#define wxTYPE_NODE            73
+#define wxTYPE_APP             74
+
+#define wxTYPE_ENHANCED_DIALOG 80
+#ifdef wx_mac
+#define wxTYPE_BORDER		   300
+#define wxTYPE_AREA			   301
+#define wxTYPE_LABEL_AREA	   302
+#endif
+
+#define wxTYPE_USER            500
+
+#ifdef IN_CPROTO
+typedef       void    *wxTypeDef ;
+typedef       void    *wxTypeTree ;
+#else
+
+class wxTypeDef: public wxObject
+{
+ public:
+  char *name;
+  WXTYPE type;
+  WXTYPE parent;
+  inline wxTypeDef(void) { name = NULL ; }
+  inline ~wxTypeDef(void) { if (name) delete name ; }
+};
+
+class wxTypeTree: public wxHashTable
+{
+ public:
+  wxTypeTree(void);
+  ~wxTypeTree(void);
+  void AddType(WXTYPE t, WXTYPE parent, char *name);
+  char *GetName(WXTYPE t);
+};
+
+extern wxTypeTree wxAllTypes;
+
+Bool wxSubType(WXTYPE type1, WXTYPE type2);
+
+char *wxGetTypeName(WXTYPE type);
+
+void wxInitStandardTypes(void);
+
+#endif // IN_CPROTO
+#endif // wxb_typesh
+
diff --git a/src/wxmac/include/base/wx_utils.h b/src/wxmac/include/base/wx_utils.h
new file mode 100644
index 0000000..bbb1640
--- /dev/null
+++ b/src/wxmac/include/base/wx_utils.h
@@ -0,0 +1,317 @@
+/*
+ * File:	wx_utils.h
+ * Purpose:	Miscellaneous utilities
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	Oct 7, 1995 - Cecil Coupe, added wxRmdir() prototype
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wxb_utilsh
+#define wxb_utilsh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+#include "wx_setup.h"
+#include "wx_obj.h"
+#include "wx_list.h"
+#include "wx_win.h"
+
+
+// sprintf is often needed, but we don't always want to include the whole
+// of stdio.h!
+#ifdef wx_msw
+extern "C" int sprintf(char *, const char *, ...);
+#elif defined(wx_x) || defined(wx_mac)
+#include <stdio.h>
+#endif
+
+// Forward declaration
+class wxFrame;
+
+// Stupid ASCII macros
+#define   wxToUpper(C)      (((C) >= 'a' && (C) <= 'z')? (C) - 'a' + 'A': (C))
+#define   wxToLower(C)      (((C) >= 'A' && (C) <= 'Z')? (C) - 'A' + 'a': (C))
+
+// Return a string with the current date/time
+char *wxNow(void);
+
+// Make a copy of this string using 'new'
+char *copystring(const char *s);
+
+// Generate a unique ID
+long wxNewId(void);
+#define NewId wxNewId
+
+// Ensure subsequent IDs don't clash with this one
+void wxRegisterId(long id);
+#define RegisterId wxRegisterId
+
+// Return the current ID
+long wxGetCurrentId(void);
+
+// Useful buffer
+extern char *wxBuffer;
+
+// Various conversions
+void StringToFloat(char *s, float *number);
+char *FloatToString(float number);
+void StringToDouble(char *s, double *number);
+char *DoubleToString(double number);
+void StringToInt(char *s, int *number);
+void StringToLong(char *s, long *number);
+char *IntToString(int number);
+char *LongToString(long number);
+
+// Matches string one within string two regardless of case
+#ifndef IN_CPROTO
+Bool StringMatch(char *one, char *two, Bool subString = TRUE, Bool exact = FALSE);
+#endif
+
+// A shorter way of using strcmp
+#define wxStringEq(s1, s2) (s1 && s2 && (strcmp(s1, s2) == 0))
+
+// Some file utilities
+
+#ifdef IN_CPROTO
+typedef       void    *wxPathList ;
+typedef       void    *wxLogClass;
+#else
+// Path searching
+class wxPathList: public wxList
+{
+  public:
+
+  void AddEnvList(char *envVariable);    // Adds all paths in environment variable
+  void Add(char *path);
+  char *FindValidPath(char *filename);   // Find the first full path
+                                         // for which the file exists
+  void EnsureFileAccessible(char *path); // Given full path and filename,
+                                         // add path to list
+  Bool Member(char *path);
+};
+
+Bool wxFileExists(const char *filename);
+#define FileExists wxFileExists
+
+Bool wxDirExists(const char *dir);
+#define DirExists wxDirExists
+
+Bool wxIsAbsolutePath(const char *filename);
+#define IsAbsolutePath wxIsAbsolutePath
+
+// Get filename
+char *wxFileNameFromPath(char *path);
+#define FileNameFromPath wxFileNameFromPath
+
+// Get directory
+char *wxPathOnly(char *path);
+#define PathOnly wxPathOnly
+
+void wxDos2UnixFilename(char *s);
+#define Dos2UnixFilename wxDos2UnixFilename
+
+void wxUnix2DosFilename(char *s);
+#define Unix2DosFilename wxUnix2DosFilename
+
+// Strip the extension, in situ
+void wxStripExtension(char *buffer);
+
+// Get a temporary filename, opening and closing the file.
+char *wxGetTempFileName(const char *prefix, char *buf = NULL);
+
+// Expand file name (~/ and ${OPENWINHOME}/ stuff)
+char *wxExpandPath(char *dest, const char *path);
+
+// Contract w.r.t environment (</usr/openwin/lib, OPENWHOME> -> ${OPENWINHOME}/lib)
+// and make (if under the home tree) relative to home
+// [caller must copy-- volatile]
+char *wxContractPath (const char *filename,
+   const char *envname = NULL, const char *user = NULL);
+
+// Destructive removal of /./ and /../ stuff
+char *wxRealPath(char *path);
+
+// Allocate a copy of the full absolute path
+char *wxCopyAbsolutePath(const char *path);
+
+// Get first file name matching given wild card.
+// Flags are reserved for future use.
+#define wxFILE  1
+#define wxDIR   2
+char *wxFindFirstFile(const char *spec, int flags = wxFILE);
+char *wxFindNextFile(void);
+
+// Does the pattern contain wildcards?
+Bool wxIsWild(const char *pattern);
+
+// Does the pattern match the text (usually a filename)?
+// If dot_special is TRUE, doesn't match * against . (eliminating
+// `hidden' dot files)
+Bool wxMatchWild(const char *pattern,  const char *text, Bool dot_special = TRUE);
+
+// Execute another program. Returns FALSE if there was an error.
+Bool wxExecute(char **argv, Bool Async = FALSE);
+Bool wxExecute(const char *command, Bool Async = FALSE);
+
+// Execute a command in an interactive shell window
+// If no command then just the shell
+Bool wxShell(const char *command = NULL);
+
+// Concatenate two files to form third
+Bool wxConcatFiles(const char *file1, const char *file2, const char *file3);
+
+// Copy file1 to file2
+Bool wxCopyFile(const char *file1, const char *file2);
+
+// Remove file
+Bool wxRemoveFile(const char *file);
+
+// Rename file
+Bool wxRenameFile(const char *file1, const char *file2);
+
+// Get current working directory.
+// If buf is NULL, allocates space using new, else
+// copies into buf.
+char *wxGetWorkingDirectory(char *buf = NULL, int sz = 1000);
+Bool wxSetWorkingDirectory(char *d);
+
+// Sleep for nSecs seconds under UNIX, do nothing under Windows
+void wxSleep(int nSecs);
+
+// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
+long wxGetFreeMemory(void);
+
+// Consume all events until no more left
+void wxFlushEvents(void);
+#ifdef wx_mac
+void wxFlushResources(void);
+#endif // wx_mac
+
+// Make directory
+Bool wxMkdir(const char *dir);
+// Delete directory
+Bool wxRmdir(const char *dir);
+
+/*
+ * Network and username functions.
+ *
+ */
+
+// Get eMail address
+Bool wxGetEmailAddress(char *buf, int maxSize);
+
+// Get hostname.
+Bool wxGetHostName(char *buf, int maxSize);
+
+// Get user ID e.g. jacs
+Bool wxGetUserId(char *buf, int maxSize);
+
+// Get user name e.g. Julian Smart
+Bool wxGetUserName(char *buf, int maxSize);
+
+/*
+ * Strip out any menu codes
+ */
+char *wxStripMenuCodes(char *in, char *out);
+
+// Find the window/widget with the given title or label.
+// Pass a parent to begin the search from, or NULL to look through
+// all windows.
+wxWindow *wxFindWindowByLabel(char *title, wxWindow *parent = NULL);
+
+// Find window by name, and if that fails, by label.
+wxWindow *wxFindWindowByName(char *name, wxWindow *parent = NULL);
+
+// Returns menu item id or -1 if none.
+int wxFindMenuItemId(wxFrame *frame, char *menuString, char *itemString);
+
+// Debug Log
+#ifdef DEBUGLOG
+#include <fstream.h>
+class wxLogClass
+{
+  ofstream *the_stream;
+  char *log_file;
+  public:
+    wxLogClass(const char *file);
+    ~wxLogClass();
+    void Open(void);
+    void Close(void);
+
+    wxLogClass& operator << (char *s);
+    wxLogClass& operator << (int i);
+    wxLogClass& operator << (double i);
+};
+
+extern wxLogClass wxLog;
+#endif
+
+#if (!defined(__MINMAX_DEFINED) && !defined(max))
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
+#define min(a,b)            (((a) < (b)) ? (a) : (b))
+#define __MINMAX_DEFINED 1
+#endif
+
+// Format a message on the standard error (UNIX) or the debugging
+// stream (Windows)
+void wxDebugMsg(const char *fmt ...) ;
+ 
+// Sound the bell
+void wxBell(void) ;
+  
+// Get OS version
+int wxGetOsVersion(int *majorVsn=NULL,int *minorVsn=NULL) ;
+ 
+// Set the cursor to the busy cursor for all windows
+class wxCursor;
+extern wxCursor *wxHOURGLASS_CURSOR;
+void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
+ 
+// Restore cursor to normal
+void wxEndBusyCursor(void);
+ 
+// TRUE if we're between the above two calls
+Bool wxIsBusy(void);
+  
+/* Error message functions used by wxWindows */
+
+// Non-fatal error (continues) 
+void wxError(const char *msg, const char *title = "wxWindows Internal Error");
+
+// Fatal error (exits)
+void wxFatalError(const char *msg, const char *title = "wxWindows Fatal Error");
+
+// Reading and writing resources (eg WIN.INI, .Xdefaults)
+#if USE_RESOURCES
+Bool wxWriteResource(const char *section, const char *entry, char *value, const char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, float value, const char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, long value, const char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, int value, const char *file = NULL);
+
+Bool wxGetResource(const char *section, const char *entry, char **value, const char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, float *value, const char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, long *value, const char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, int *value, const char *file = NULL);
+#endif // USE_RESOURCES
+
+#ifdef wx_x
+// 'X' Only, will soon vanish....
+// Get current Home dir and copy to dest
+char *wxGetHomeDir(char *dest);
+#endif
+// Get the user's home dir (caller must copy--- volatile)
+// returns NULL is no HOME dir is known
+char *wxGetUserHome(const char *user = NULL);
+
+// X only
+#ifdef wx_x
+// Get X display: often needed in the wxWindows implementation.
+Display *wxGetDisplay(void);
+#endif
+
+#endif // IN_CPROTO
+#endif // wxb_utilsh
diff --git a/src/wxmac/include/base/wx_ver.h b/src/wxmac/include/base/wx_ver.h
new file mode 100644
index 0000000..0c67202
--- /dev/null
+++ b/src/wxmac/include/base/wx_ver.h
@@ -0,0 +1,17 @@
+#ifndef WX_VERSION_H
+#define WX_VERSION_H
+
+// Bump-up with each new version
+// Edward, slightly changed names here.
+#define wxMAJOR_VERSION    1
+#define wxMINOR_VERSION    6
+#define wxRELEASE_NUMBER   1
+#define wxVERSION_STRING "wxWindows 1.61"
+#define wxVERSION_NUMBER (wxMAJOR_VERSION * 1000) + (wxMINOR_VERSION * 100) + wxRELEASE_NUMBER
+
+/*
+extern const unsigned short wx_version;
+extern const char *wx_version_string;
+*/
+
+#endif /* WX_VERSION_H */
diff --git a/src/wxmac/include/base/wxstring.h b/src/wxmac/include/base/wxstring.h
new file mode 100644
index 0000000..40d6a0b
--- /dev/null
+++ b/src/wxmac/include/base/wxstring.h
@@ -0,0 +1,146 @@
+/*
+ * File:    wxstring.h
+ * Purpose: String class
+ * Author:  Stefan (steve) Hammes (Julian Smart)
+ * Created: 1994
+ * Updated: 
+ * Copyright:   (c) 1994
+ */
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wx_stringh
+#define wx_stringh
+
+#include "common.h"
+#include "wx_obj.h"
+#if defined(wx_mac) && defined(Length)
+#undef Length
+#endif
+
+/*
+ * String
+ *
+ */
+#define NO_POS ((size_t)(-1)) // undefined position
+
+class wxString 
+// #ifndef wxSTRING_TEST
+: public wxObject
+// #endif
+{
+private:
+  char *stringData_;
+  void assertElement(size_t) const;    // Index in range
+public:
+  void SetData(char *s);
+  enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
+  enum caseCompare {exact, ignoreCase};
+
+  wxString();          // Null string
+  wxString(char *s); // Copy constructor
+  wxString(const wxString& s); // Copy constructor
+  wxString(char);
+  wxString(const char *fmt, ...); // formatted construction (also possible 'wxString s("hello")'
+  ~wxString();
+
+  // formatted construction
+  int sprintf(const char *fmt, ...);
+  
+  // input
+//  char *ReadLine(FILE *inputFile);
+
+  // Type conversion:
+#define NO_CONST_STRING 1
+#if NO_CONST_STRING
+#define const /**/ 
+#endif
+  const char*   Data() const {return stringData_;} // un-CONST in certain environment necessary
+  operator const char*() const {return stringData_;} // dito.
+#if NO_CONST_STRING
+#undef const
+#endif
+  const char* GetData() const {return stringData_;} // this one is alway const!
+  wxString     Copy() const;
+
+  // comparison
+  int          CompareTo(const char* cs,      caseCompare cmp = exact) const;
+  int          CompareTo(const wxString& st, caseCompare cmp = exact) const;
+//  Bool operator ==(const wxString& s2) const { return(CompareTo(s2)==0); }
+  Bool operator ==(char *s2) const { return(CompareTo(s2)==0); }
+//  Bool operator !=(const wxString& s) const { return(CompareTo(s)!=0); }
+  Bool operator !=(char  *s) const { return(CompareTo(s)!=0); }
+  Bool operator <(const wxString& s) const { return(CompareTo(s)<0); }
+  Bool operator <(const char  *s) const { return(CompareTo(s)<0); }
+  Bool operator <=(const wxString& s) const { return(CompareTo(s)<=0); }
+  Bool operator <=(const char  *s) const { return(CompareTo(s)<=0); }
+  Bool operator >(const wxString& s) const { return(CompareTo(s)>0); }
+  Bool operator >(const char  *s) const { return(CompareTo(s)>0); }
+  Bool operator >=(const wxString& s) const { return(CompareTo(s)>=0); }
+  Bool operator >=(const char  *s) const { return(CompareTo(s)>=0); }
+  
+  // Assignment:
+  wxString&    operator=(const char*);     // Replace string
+  wxString&    operator=(const wxString&);    // Replace string
+  wxString&    operator+=(const char*);    // Append string.
+  wxString&    operator+=(const wxString& s);
+
+  // Indexing operators:
+  char&     operator[](int);     // Indexing with bounds checking (must be int!)
+  char&     operator()(size_t);     // Indexing with  bounds checking
+  wxString  operator()(size_t start, size_t len) const;       // Sub-string operator
+  wxString  SubString(const char* pat, size_t start=0) const;     
+  wxString  SubString(const wxString& pat, size_t start=0) const;     
+  
+  // Non-static member functions:
+  wxString operator +(const wxString& s) const;
+  wxString operator +(const char *s) const;
+  wxString&    Append(const char* cs);
+  wxString&    Append(const wxString& s);
+  wxString&    Append(char c, size_t rep=1);   // Append c rep times
+  Bool Contains(const char* pat,      caseCompare cmp = exact) const;
+  Bool Contains(const wxString& pat, caseCompare cmp = exact) const;
+  size_t    First(char c) const;
+  size_t    First(const char* cs) const;
+  size_t    First(const wxString& cs) const;
+  
+  size_t    Index(const char* pat, size_t i=0, caseCompare cmp = exact) const;
+  size_t    Index(const wxString& s, size_t i=0, caseCompare cmp = exact) const;
+              
+  wxString&    Insert(size_t pos, const char*);
+  wxString&    Insert(size_t pos, const wxString&);
+  
+  Bool IsAscii() const;
+  Bool IsNumber() const;
+  Bool IsWord() const;
+  Bool IsNull() const { return(stringData_ == NULL); }
+  size_t    Last(char c) const;
+  size_t    Last(const char* cs) const;
+  size_t    Last(const wxString& cs) const;
+  size_t    Length() const;
+  
+  wxString&    Prepend(const char*);           // Prepend a character string
+  wxString&    Prepend(const wxString& s);
+  wxString&    Prepend(char c, size_t rep=1);  // Prepend c rep times
+  
+  wxString&    Remove(size_t pos);         // Remove pos to end of string
+  wxString&    Remove(size_t pos, size_t n);       // Remove n chars starting at pos
+  wxString&    RemoveLast(void);
+
+  wxString&    Replace(size_t pos, size_t n, const char*);
+  wxString&    Replace(size_t pos, size_t n, const wxString&);
+  wxString  Strip(stripType s=trailing, char c=' ') const;
+  void      LowerCase();              // Change self to lower-case
+  void      UpperCase();              // Change self to upper-case
+
+  // Edward Z.'s additions
+  wxString SubString(size_t from, size_t to);
+//  wxString UpperCase(void);
+//  wxString LowerCase(void);
+};
+
+#endif // wx_stringh
diff --git a/src/wxmac/include/mac/unimp.h b/src/wxmac/include/mac/unimp.h
new file mode 100644
index 0000000..af66002
--- /dev/null
+++ b/src/wxmac/include/mac/unimp.h
@@ -0,0 +1,19 @@
+#ifndef _unimp_h
+#define _unimp_h 1
+
+#define wxOPEN 1
+#define wxSAVE 2
+#define wxOVERWRITE_PROMPT 4
+#define wxHIDE_READONLY 8
+
+Bool wxWriteResource(const char *section, const char *entry, char *value,  char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, float value, const char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, long value, const char *file = NULL);
+Bool wxWriteResource(const char *section, const char *entry, int value, const char *file = NULL);
+
+Bool wxGetResource(const char *section, const char *entry, char **value,  char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, float *value, const char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, long *value, const char *file = NULL);
+Bool wxGetResource(const char *section, const char *entry, int *value, const char *file = NULL);
+
+#endif
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxBorder.h b/src/wxmac/include/mac/wxBorder.h
new file mode 100644
index 0000000..f340273
--- /dev/null
+++ b/src/wxmac/include/mac/wxBorder.h
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxBorder.h
+// Purpose:	Declares wxBorder item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxBorderh
+#define wxBorderh
+
+#include "wx_win.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxBorder ;
+#else
+
+// Border item
+class wxBorder: public wxWindow
+{
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		char*		windowName = "Border",
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		WXTYPE		objectType = wxTYPE_BORDER
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxBorder(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	void ChangeColour(void) ;
+
+	virtual void DoShow(Bool show);
+	virtual void ShowAsActive(Bool flag); // mac platform only
+};
+
+#endif // IN_CPROTO
+#endif // wxBorderh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxBorderArea.h b/src/wxmac/include/mac/wxBorderArea.h
new file mode 100644
index 0000000..6974f10
--- /dev/null
+++ b/src/wxmac/include/mac/wxBorderArea.h
@@ -0,0 +1,29 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxBorderArea.h
+// Purpose:	wxBorderArea (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxBorderAreah
+#define wxBorderAreah
+
+#include "wx_area.h"
+#include "wxDirection.h"
+
+class wxRectBorder;
+
+class wxBorderArea: public wxArea
+{
+  public:
+	wxBorderArea(wxWindow* parentWindow, int margin = 1,
+					Direction direction = Direction::wxAll,
+					int whitespace = 0); // constructor
+	~wxBorderArea(void);		// destructor
+
+	wxRectBorder* cBorder;
+};
+
+#endif // wxBorderAreah
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxButtonBorder.h b/src/wxmac/include/mac/wxButtonBorder.h
new file mode 100644
index 0000000..80c7f2b
--- /dev/null
+++ b/src/wxmac/include/mac/wxButtonBorder.h
@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxButtonBorder.h
+// Purpose:	Declares wxButtonBorder item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxButtonBorderh
+#define wxButtonBorderh
+
+#include "wxBorder.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxButtonBorder ;
+#else
+
+// ButtonBorder item
+class wxButtonBorder: public wxBorder
+{
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxButtonBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int			margin = 0,
+		Direction	direction = Direction::wxAll,
+		char*		windowName = "ButtonBorder",
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		WXTYPE		objectType = wxTYPE_BORDER
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxButtonBorder(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+	virtual void Paint(void);
+};
+
+#endif // IN_CPROTO
+#endif // wxButtonBorderh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxDirection.h b/src/wxmac/include/mac/wxDirection.h
new file mode 100644
index 0000000..be473b2
--- /dev/null
+++ b/src/wxmac/include/mac/wxDirection.h
@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxDirection.h
+// Purpose:	Direction (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxDirectionh
+#define wxDirectionh
+
+class Direction
+{
+  public:
+  	enum {wxTop = 1, wxLeft = 2, wxBottom = 4, wxRight = 8,
+  			wxVertical = wxTop | wxBottom,
+  			wxHorizontal = wxLeft | wxRight,
+  			wxAll = wxVertical | wxHorizontal};
+
+  protected:
+	int v;
+
+  public:
+  	Direction(void) {v = 0;}
+	Direction(int i) {v = i;}
+  	operator int() {return v;}
+
+	Direction operator& (Direction aDirection) { return this->v & aDirection.v; } // 95-02-20
+};
+
+#endif // wxDirectionh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxLabelArea.h b/src/wxmac/include/mac/wxLabelArea.h
new file mode 100644
index 0000000..42bf58b
--- /dev/null
+++ b/src/wxmac/include/mac/wxLabelArea.h
@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxLabelArea.h
+// Purpose:	wxLabelArea (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxLabelAreah
+#define wxLabelAreah
+
+#include "wx_area.h"
+#include "wxDirection.h"
+
+class wxMessage;
+class wxFont;
+
+class wxLabelArea: public wxArea
+{
+  protected:
+	wxMessage*	cLabelText; 
+	Direction	cDirection;
+
+  public:
+	wxLabelArea // constructor
+	(
+		wxWindow*	parentWindow,
+		char*		label,
+		wxFont*		theFont,
+		Direction	direction,
+		int			xoffset = 0,
+		int			yoffset = 0
+	);
+
+	~wxLabelArea(void);		// destructor
+
+	void SetLabel(char* label);
+	char* GetLabel(void);
+
+	inline wxMessage *GetMessage(void) { return cLabelText; }
+
+    void DoShow(Bool on);
+
+  friend class wxMessage;
+};
+
+#endif // wxLabelAreah
diff --git a/src/wxmac/include/mac/wxMacDC.h b/src/wxmac/include/mac/wxMacDC.h
new file mode 100644
index 0000000..f8def71
--- /dev/null
+++ b/src/wxmac/include/mac/wxMacDC.h
@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMacDC.h
+// Purpose:	MacDC (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxMacDCh
+#define wxMacDCh
+
+#include "wxMacObj.h"
+
+class wxMacDC: public wxMacObject
+{
+  protected:
+	CGrafPtr	cMacGrafPort;
+	wxObject*	cCurrentUser;
+
+  public:
+	wxMacDC(CGrafPtr port);		// constructor
+	~wxMacDC(void);				// destructor
+
+	CGrafPtr macGrafPort(void);
+	wxObject* currentUser(void);
+	void setCurrentUser(wxObject* user);
+
+	Bool isCurrentPort(void);
+};
+
+#endif // wxMacDCh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxMacObj.h b/src/wxmac/include/mac/wxMacObj.h
new file mode 100644
index 0000000..3df34e7
--- /dev/null
+++ b/src/wxmac/include/mac/wxMacObj.h
@@ -0,0 +1,28 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMacObj.h
+// Purpose:	Top level object for Macintosh platform
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxMacObjh
+#define wxMacObjh
+
+#include "wx_types.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxMacObject ;
+#else
+
+class wxMacObject
+{
+  public:
+  WXTYPE __type;
+  wxMacObject(void);
+  virtual ~wxMacObject(void);
+};
+
+#endif // IN_CPROTO
+#endif // wxMacObjh
diff --git a/src/wxmac/include/mac/wxMacPPC.h b/src/wxmac/include/mac/wxMacPPC.h
new file mode 100644
index 0000000..2d03d99
--- /dev/null
+++ b/src/wxmac/include/mac/wxMacPPC.h
@@ -0,0 +1,64 @@
+/*
+ * File:	wxMacPPC.h
+ * Purpose:	IPC primitives (Macintosh version)
+ * Author:	Tomaso Paoletti
+ * Created:	1994
+ * Updated:	
+ * Copyright:	(c) 1993-1994, AIAI, University of Edinburgh
+ */
+
+#pragma once
+#include <GestaltEqu.h>
+#include <PPCToolBox.h>
+
+enum { sClosed = 0, sOpening, sOpen, sListening };
+
+extern short gSessionState;
+
+extern Boolean gPBInUse;
+extern Boolean gAsync;
+
+extern PPCReadPBPtr		ReadPBptr;
+extern PPCWritePBPtr	WritePBptr;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Boolean PPCInitialize(void);
+long ipcSyncRead(PPCSessRefNum sess,char * buffer, long size);
+long ipcRead(PPCSessRefNum sess,char * buffer, long size);
+long ipcWrite(PPCSessRefNum sess,char *buffer, long size);
+
+pascal void MyInformCompProc( PPCParamBlockPtr );
+pascal void MyAcceptCompProc(PPCParamBlockPtr);
+pascal void MyRejectCompProc(PPCParamBlockPtr);
+
+
+OSErr  ppcInit(long *ppcAttributes);
+OSErr ppcOpen(PPCPortRefNum *, char *, Boolean *);
+OSErr ppcStart(PortInfoPtr,  LocationNamePtr,  PPCPortRefNum, 
+						PPCSessRefNum *,  long *,  long *);
+OSErr ppcInform(PPCParamBlockPtr,  PPCPortPtr,  LocationNamePtr,
+						StringPtr,  PPCPortRefNum);
+
+OSErr ppcRead(PPCReadPBPtr,PPCSessRefNum,Size,Ptr);
+OSErr ppcStartRead(PPCReadPBPtr,PPCSessRefNum,Size,Ptr);
+OSErr ppcWrite(PPCWritePBPtr,PPCSessRefNum,Size,Ptr);
+
+OSErr ppcClose (PPCPortRefNum);
+OSErr ppcEnd(PPCSessRefNum);
+
+Boolean MyReadComplete(PPCReadPBPtr thePPCReadPBPtr, OSErr *err);
+Boolean MyWriteComplete(PPCWritePBPtr, OSErr *);
+
+void DoPPCAccept(PPCParamBlockPtr);
+void DoPPCReject( PPCParamBlockPtr );
+
+pascal Boolean MyBrowserPortFilter(LocationNameRec,PortInfoRec);
+OSErr ppcBrowser(LocationNameRec *,PortInfoRec *);
+OSErr ipcListPorts(short,short,short *,Str32,Str32,PortInfoArrayPtr);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxMargin.h b/src/wxmac/include/mac/wxMargin.h
new file mode 100644
index 0000000..2cf68bd
--- /dev/null
+++ b/src/wxmac/include/mac/wxMargin.h
@@ -0,0 +1,36 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMargin.h
+// Purpose:	Margin (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxMarginh
+#define wxMarginh
+
+class Direction;
+
+class wxMargin
+{
+  protected:
+	int left;
+	int top;
+	int right;
+	int bottom;
+
+  public:
+  	wxMargin(int margin = 0);
+	wxMargin(int margin, Direction direction);
+	wxMargin(const wxMargin& margin);
+  	~wxMargin(void);
+
+  	wxMargin& operator +=(wxMargin margin);
+
+	void SetMargin(wxMargin margin, Direction direction);
+	void SetMargin(int margin, Direction direction);
+	int Offset(Direction direction);
+};
+
+#endif // wxMarginh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxRectBorder.h b/src/wxmac/include/mac/wxRectBorder.h
new file mode 100644
index 0000000..d6ce35f
--- /dev/null
+++ b/src/wxmac/include/mac/wxRectBorder.h
@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxRectBorder.h
+// Purpose:	Declares wxRectBorder item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxRectBorderh
+#define wxRectBorderh
+
+#include "wxBorder.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxRectBorder ;
+#else
+
+// RectBorder item
+class wxRectBorder: public wxBorder
+{
+private:
+	int cWhitespace; // white border interior width
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxRectBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int			margin = 1,
+		Direction	direction = Direction::wxAll,
+		int			whitespace = 0,
+		char*		windowName = "RectBorder",
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		WXTYPE		objectType = wxTYPE_BORDER 
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxRectBorder(void);
+    
+	void SetBrush(wxBrush *b) { cBrush = b; }
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+	virtual void Paint(void);
+
+	virtual void DoShow(Bool on);
+};
+
+#endif // IN_CPROTO
+#endif // wxRectBorderh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxScroll.h b/src/wxmac/include/mac/wxScroll.h
new file mode 100644
index 0000000..9ce7710
--- /dev/null
+++ b/src/wxmac/include/mac/wxScroll.h
@@ -0,0 +1,101 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScroll.h
+// Purpose:	wxScroll (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxScrollh
+#define wxScrollh
+
+#include "wx_obj.h"
+#include "wx_list.h"
+#include "wxScrollData.h"
+
+class wxWindow;
+
+class wxScroll: public wxObject
+{
+  public:
+
+  protected:
+	wxWindow*		cScrollWindow;	// never NULL
+	wxScroll*		cParentScroll;	// may be NULL
+	wxList			cScrolls;		// list of child wxScroll* objects
+	wxScrollData*	cScrollData;	// root scroll ? !NULL : NULL
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxScroll
+	(
+		wxWindow*		scrollWindow,
+		wxScrollData*	scrollData
+	);
+
+	wxScroll
+	(
+		wxWindow*		scrollWindow,
+		wxWindow*		parentScrollWindow
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+  	~wxScroll(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Getter and setter methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+	wxScrollData* GetScrollData (void);
+
+	void SetScrollData
+	(
+		wxScrollData*		newScrollData,
+		wxWhatScrollData	whatScrollData, // items to be changed
+		wxWindow*			iniatorWindow
+	);
+
+	void SetScrollData
+	(
+		int 				value,			// value for items to be changed
+		wxWhatScrollData	whatScrollData, // items to be changed
+		wxWindow*			iniatorWindow
+	);
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Scroll tree methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+	wxScroll* RootScroll(void);
+
+	void AddChildScrollWindow(wxWindow* childScrollWindow);
+
+	void OnDeleteChildScroll(wxScroll* childScroll);
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Miscellaneous methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+	void OnSetScrollData
+	(
+		wxScrollData*		scrollData,
+		wxWhatScrollData	whatScrollData, // items to be changed
+		wxWindow*			iniatorWindow
+	);
+
+};
+
+#endif // wxScrollh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxScrollArea.h b/src/wxmac/include/mac/wxScrollArea.h
new file mode 100644
index 0000000..90cc968
--- /dev/null
+++ b/src/wxmac/include/mac/wxScrollArea.h
@@ -0,0 +1,37 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScrollArea.h
+// Purpose:	wxScrollArea (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxScrollAreah
+#define wxScrollAreah
+
+#include "wx_area.h"
+
+class wxScrollBar;
+class wxWindow;
+
+class wxScrollArea: public wxArea
+{
+  protected:
+	wxScrollBar*	cVScrollBar; /*NEW*/
+	wxScrollBar*	cHScrollBar; /*NEW*/
+	long			cStyle;
+
+  public:
+	wxScrollArea // constructor
+	(
+		wxWindow*	parentWindow,
+		wxWindow*	parentScrollWindow,
+		long		style
+	);
+
+	~wxScrollArea(void);		// destructor
+
+};
+
+#endif // wxScrollAreah
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxScrollData.h b/src/wxmac/include/mac/wxScrollData.h
new file mode 100644
index 0000000..4d466a8
--- /dev/null
+++ b/src/wxmac/include/mac/wxScrollData.h
@@ -0,0 +1,100 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScrollData.h
+// Purpose:	ScrollData (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wxScrollDatah
+#define wxScrollDatah
+
+class wxWhatScrollData // 95-02-19
+{
+  public:
+  	enum WhatScrollData
+  		{
+  			wxOriginX	= 1,
+  			wxOriginY	= 2,
+  			wxSizeW		= 4,
+  			wxSizeH		= 8,
+  			wxPositionH	= 16,
+  			wxPositionV	= 32,
+  			wxUnitW		= 64,
+  			wxUnitH		= 128,
+  			wxPageW		= 256,
+  			wxPageH		= 512,
+
+			wxOrigin	= wxOriginX | wxOriginY,
+			wxSize		= wxSizeW | wxSizeH,
+			wxPosition	= wxPositionH | wxPositionV,
+			wxUnit		= wxUnitW | wxUnitH,
+			wxPage		= wxPageW | wxPageH,
+			wxAll		= wxOrigin | wxSize | wxPosition | wxUnit | wxPage
+  		};
+
+  protected:
+	long v;
+
+  public:
+	wxWhatScrollData(long w = 0) { v = w; }
+	operator WhatScrollData() { return WhatScrollData(v); }
+	operator long() { return v; }
+	wxWhatScrollData operator |(const wxWhatScrollData& what)
+	{
+		return this->v | what.v;
+	}
+
+	wxWhatScrollData& operator |=(const wxWhatScrollData& what)
+	{
+		*this = *this | what;
+		return *this;
+	}
+};
+
+class wxScrollData
+{
+  protected:
+	int cOriginX;		// min horizontal scroll value
+	int cOriginY;		// min vertical scroll value
+	int cSizeW;			// total number of horizontal scroll units
+	int cSizeH;			// total number of vertical scroll units
+	int cPositionH;		// current horizontal scroll position (starting at cOriginX value)
+	int cPositionV;		// current vertical scroll position (starting at cOriginY value)
+	int cUnitW;			// number of pixels for one horizontal unit scroll
+	int cUnitH;			// number of pixels for one vertical unit scroll
+	int cPageW;			// number of pixels for one horizontal page scroll
+	int cPageH;			// number of pixels for one vertical page scroll
+
+  public:
+  	wxScrollData(void);
+
+	wxScrollData
+	(
+		int					value,			// initial value for selected items
+		wxWhatScrollData	whatScrollData	// what items to initialize with given value
+	);
+
+  	~wxScrollData(void);
+
+	void SetValue
+	(
+		wxScrollData* 		newScrollData,	// may have changes only
+		wxWhatScrollData 	whatScrollData	// items to be changed
+	);
+
+	void SetValue
+	(
+		int 				value,	// value for items to be changed
+		wxWhatScrollData 	whatScrollData	// items to be changed
+	);
+
+	int GetValue
+	(
+		wxWhatScrollData 	whatScrollData	// what item to get
+	);
+
+};
+
+#endif // wxScrollDatah
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wxTimeScale.h b/src/wxmac/include/mac/wxTimeScale.h
new file mode 100644
index 0000000..af2cf70
--- /dev/null
+++ b/src/wxmac/include/mac/wxTimeScale.h
@@ -0,0 +1 @@
+#define SCALE_TIMESTAMP(s) (16 * (s))
diff --git a/src/wxmac/include/mac/wx_area.h b/src/wxmac/include/mac/wx_area.h
new file mode 100644
index 0000000..6f2616a
--- /dev/null
+++ b/src/wxmac/include/mac/wx_area.h
@@ -0,0 +1,103 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_area.h
+// Purpose:	wxArea (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_areah
+#define wx_areah
+
+#include "wx_obj.h"
+#include "wxMargin.h"
+#include "wxDirection.h"
+#include "wx_list.h"
+
+class wxWindow;
+
+class wxArea: public wxObject
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	wxMargin	cMargin;
+	wxWindow*	cParentWindow; /*OLD*/
+	wxChildList		cWindows;
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxArea(wxWindow* parentWindow);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxArea(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMargin Margin(void);
+	wxMargin Margin(wxArea* outerArea); // Margin from this area to outer area
+	wxMargin Margin(wxWindow* outerWindow); // Margin from this area to outer window
+	int Width(void);
+	int Height(void);
+	void AreaToScreen(int* h, int* v); // Convert from this area c.s. to screen c.s.
+	void ScreenToArea(int* h, int* v); // Convert from screen c.s. to this area c.s.
+	Bool WindowPointInArea(int windowH, int windowV);
+	void FrameContentAreaOffset(int* x, int* y); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void SetSize(int width, int height);
+	void SetMargin(int margin, Direction direction = Direction::wxAll);
+	void SetMargin(wxMargin margin, Direction direction = Direction::wxAll);
+	void SetMargin(wxMargin margin, Direction direction,
+					int parentWindowWidth, int parentWindowHeight,
+					int parentWindowX, int parentWindowY);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree (windows and areas) methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxWindow* ParentWindow(void);
+	wxChildList* Windows(void);
+	wxArea* First(void);
+	wxArea* Previous(void);
+	wxArea* Next(void);
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void OnSiblingDSize(int dW, int dH, int dX, int dY);
+	virtual void OnAreaDSize(int dW, int dH, int dX, int dY); // Notify child windows of resize
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree (windows and areas) methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void OnDeleteChildWindow(wxWindow* childWindow);
+
+//=============================================================================
+// Friend classes
+//=============================================================================
+private:
+
+	friend class wxWindow;
+	friend class wxFrame;
+};
+
+#endif // wx_areah
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wx_buttn.h b/src/wxmac/include/mac/wx_buttn.h
new file mode 100644
index 0000000..24ac9e6
--- /dev/null
+++ b/src/wxmac/include/mac/wx_buttn.h
@@ -0,0 +1,120 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_buttn.h
+// Purpose:	wxButton (Macintosh implementation)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_buttnh
+#define wx_buttnh
+
+#include "wb_buttn.h"
+class wxPanel;
+
+#ifdef IN_CPROTO
+typedef       void* wxButton;
+#else
+
+// Pushbutton
+
+class wxBitmap;
+class wxArea;
+
+class wxButton: public wxbButton
+{
+ private:
+  // For window area
+  	wxArea* cBorderArea; // mac platform only
+	CCTabHandle cColorTable; // mac platform only
+
+ public:
+	wxBitmap* buttonBitmap;
+	ControlHandle cMacControl; // mac control for push button
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxButton // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "button",
+		WXTYPE		objectType = wxTYPE_BUTTON
+	);
+
+	wxButton // Constructor (given parentPanel, bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "button",
+		WXTYPE		objectType = wxTYPE_BUTTON
+	);
+
+    void Create // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "button",
+		WXTYPE		objectType = wxTYPE_BUTTON
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxButton(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+//=============================================================================
+// Window coordinate system transformation methods
+//=============================================================================
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY); // mac platform only
+	void SetDefault(Bool flag = TRUE); // WCH wx_mac: original had void as argument
+	virtual void OnSetDefault(Bool flag = TRUE); // WCH wx_mac: addition to original
+	void SetLabel(char*);
+	void SetLabel(wxBitmap* bitmap);
+	char* GetLabel(void);
+	void Command(wxCommandEvent& event);
+
+	void ChangeColour(void);
+
+	virtual void Enable(Bool enable);
+	virtual void Paint(void);
+	virtual void DoShow(Bool show);
+
+	virtual void ShowAsActive(Bool flag); // mac platform only
+	virtual void OnEvent(wxMouseEvent& event); // mac platform only
+ 	virtual void Highlight(Bool flag); // mac platform only, supercedes ShowAsActive
+
+	virtual void ChangeToGray(Bool gray);
+};
+
+#endif // IN_CPROTO
+#endif // wx_buttnh
diff --git a/src/wxmac/include/mac/wx_canvs.h b/src/wxmac/include/mac/wx_canvs.h
new file mode 100644
index 0000000..464bc3d
--- /dev/null
+++ b/src/wxmac/include/mac/wx_canvs.h
@@ -0,0 +1,163 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_canvs.h
+// Purpose:	wxCanvas subwindow declarations (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_canvsh
+#define wx_canvsh
+
+#include "wb_canvs.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxCanvas ;
+#else
+
+class wxFrame;
+
+// Canvas subwindow for drawing on
+class wxCanvas: public wxbCanvas
+{
+ public:
+	int units_per_page_x;
+	int units_per_page_y;
+	int units_x ;
+	int units_y ;
+	int hExtent;   // Actual extent of virtual scrolled canvas
+	int vExtent;
+	Bool hScrollingEnabled;
+	Bool vScrollingEnabled;
+    Bool scrollAutomanaged;
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+ public:
+
+	wxCanvas // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = wxRETAINED,
+		char*		windowName = "canvas",
+		WXTYPE		objectType = wxTYPE_CANVAS
+	);
+
+ 	wxCanvas // Constructor (given parentArea)
+ 	(
+ 		wxArea*		parentArea,
+ 		int 		x = -1,
+ 		int			y = -1,
+ 		int			width = -1,
+ 		int			height = -1,
+ 		long		style = wxRETAINED,
+ 		char*		windowName = "canvas",
+ 		WXTYPE		objectType = wxTYPE_CANVAS
+ 	);
+
+ 	wxCanvas // Constructor (given parentWindow)
+ 	(
+ 		wxWindow*	parentWindow,
+ 		int 		x = -1,
+ 		int			y = -1,
+ 		int			width = -1,
+ 		int			height = -1,
+ 		long		style = wxRETAINED,
+ 		char*		windowName = "canvas",
+ 		WXTYPE		objectType = wxTYPE_CANVAS
+ 	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	virtual ~wxCanvas(void);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void InitDefaults(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+ public:
+
+	virtual void BeginDrawing(void);
+	virtual void EndDrawing(void);
+	inline wxCanvasDC *GetDC(void) { return wx_dc; }
+
+	void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+
+	// Number of pixels per user unit (0 or -1 for no scrollbar)
+	// Length of virtual canvas in user units
+	// Length of page in user units
+	void SetScrollbars(int horizontal, int vertical,
+                             int x_length, int y_length,
+                             int x_page, int y_page,
+                             int x_pos = 0, int y_pos = 0,
+							 Bool automgmt = TRUE 
+						);
+
+	virtual void SetScrollData // mac platform only
+	(
+		wxScrollData*		scrollData,
+		wxWhatScrollData	whatScrollData,
+		wxWindow*			iniatorWindow
+	);
+
+	// Scroll the canvas
+	void Scroll(int xPos, int yPos);
+	void GetScrollUnitsPerPage(int* x_page, int* y_page);
+	virtual int GetScrollsPerPage(int orientation); // mac platform only
+
+	void ViewStart(int* x, int* y);
+
+	// Actual size in pixels when scrolling is taken into account
+	void GetVirtualSize(int* x, int* y);
+
+	void SetColourMap(wxColourMap* cmap);
+	virtual void OnScroll(wxCommandEvent& event) { };
+
+	// Enable/disable Windows 3.1 scrolling in either direction.
+	// If TRUE, wxWindows scrolls the canvas and only a bit of
+	// the canvas is invalidated; no Clear() is necessary.
+	// If FALSE, the whole canvas is invalidated and a Clear() is
+	// necessary. Disable for when the scroll increment is used
+	// to actually scroll a non-constant distance
+	void EnableScrolling(Bool x_scrolling, Bool y_scrolling);
+
+	virtual void WarpPointer(int x_pos, int y_pos) ;
+
+	void DoShow(Bool show);
+
+	virtual void ClientToLogical(int* x, int* y); // mac platform only; testing
+	// some new methods for wxMedia
+	void SetScrollPage(int dir, int val);
+	void SetScrollRange(int dir, int val);
+	int  GetScrollPos(int dir);
+    int  GetScrollPage(int dir);
+    int  GetScrollRange(int dir);
+	void SetScrollPos(int dir, int val);
+
+	virtual void ChangeToGray(Bool gray);
+
+	virtual void Paint(void);
+	virtual void OnPaint(void);
+
+	virtual void AddWhiteRgn(RgnHandle rgn);
+
+	Bool WantsFocus();
+};
+
+#endif // IN_CPROTO
+#endif // wx_canvsh
diff --git a/src/wxmac/include/mac/wx_check.h b/src/wxmac/include/mac/wx_check.h
new file mode 100644
index 0000000..bd49483
--- /dev/null
+++ b/src/wxmac/include/mac/wx_check.h
@@ -0,0 +1,127 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_check.h
+// Purpose:	Declares wxCheckBox panel item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_checkh
+#define wx_checkh
+
+#include "wb_check.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxCheckBox ;
+#else
+
+class wxBitmap;
+
+class wxCheckBox: public wxbCheckBox
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	wxBitmap* 		buttonBitmap ;
+	int  bitmapState;
+	ControlHandle 	cMacControl; // mac control for checkbox
+	char *labelString;
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxCheckBox // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "checkBox",
+		WXTYPE		objectType = wxTYPE_CHECK_BOX
+	);
+
+	void Create // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "checkBox",
+		WXTYPE		objectType = wxTYPE_CHECK_BOX
+	);
+
+	wxCheckBox // Constructor (given parentPanel, bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "checkBox",
+		WXTYPE		objectType = wxTYPE_CHECK_BOX
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxCheckBox(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Item methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void SetValue(Bool value);
+	virtual Bool GetValue(void);
+	void SetLabel(char* label);
+	void SetLabel(wxBitmap* bitmap);
+	char* GetLabel(void) ;
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void DoShow(Bool show);
+	void ChangeColour(void) ;
+	virtual void Command(wxCommandEvent& event); // mac platform only (also xview platform)
+
+	virtual void ChangeToGray(Bool gray);
+
+	virtual void Highlight(Bool flag);
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void Paint(void);
+	virtual void ShowAsActive(Bool flag);
+	virtual void OnEvent(wxMouseEvent& event); // mac platform only
+};
+
+#endif // IN_CPROTO
+#endif // wx_checkh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wx_choic.h b/src/wxmac/include/mac/wx_choic.h
new file mode 100644
index 0000000..73afb33
--- /dev/null
+++ b/src/wxmac/include/mac/wx_choic.h
@@ -0,0 +1,90 @@
+/*
+ * File:	wx_choic.h
+ * Purpose:	Choice panel item
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_choic.h	1.2 5/9/94" */
+
+#ifndef wx_choich
+#define wx_choich
+
+#include "wb_choic.h"
+#include "wxLabelArea.h"
+#include <Controls.h>
+#include <Menus.h>
+
+#ifdef IN_CPROTO
+typedef       void    *wxChoice ;
+#else
+
+// Choice item
+class wxChoice: public wxbChoice
+{
+	Rect		TitleRect;
+	Rect		ValueRect;
+	Rect		CtlRect;
+	MenuHandle 	hDynMenu;
+	StringPtr	sTitle;
+	int			selection;
+	int			labelbase;			// number pixels from top to baseline
+	int			valuebase;			// ""
+	wxFont*		valueFont;
+	short		PopUpID;			// Mac Menu Mgr ID - never reused I hope
+ public:
+
+  wxChoice (void);
+  wxChoice(wxPanel *panel, wxFunction func, char *Title,
+           int x = -1, int y = -1, int width = -1, int height = -1,
+           int N = 0, char **Choices = NULL,
+           long style = 0, char *name = "choice"
+	);
+  ~wxChoice(void);
+
+  Bool Create(wxPanel *panel, wxFunction func, char *Title,
+           int x = -1, int y = -1, int width = -1, int height = -1,
+           int N = 0, char **Choices = NULL,
+           long style = 0, char *name = "choice");
+  void Append(char *Item);
+  void Clear(void);
+  int GetSelection(void);
+  void SetSelection(int n);
+  int FindString(char *s);
+  char *GetString(int n);
+#if 0	// CJC
+  void SetSize(int x, int y, int width, int height, int sizeFlags);
+  void GetSize(int *x, int *y);
+  void GetPosition(int *x, int *y);
+#endif
+  char *GetLabel(void);
+  void SetLabel(char *label);
+
+
+  void SetBackgroundColour(wxColour*col) ;
+  void SetLabelColour(wxColour*col) ;
+  void SetButtonColour(wxColour*col) ;
+
+  void SetColumns(int n = 1 ) { /* no effect */ } ;
+  int GetColumns(void) { return 1 ; };
+  
+  int Number(void);
+  
+  // Mac only methods
+	void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+	void Command(wxCommandEvent& event);
+
+	virtual void ChangeToGray(Bool gray);
+	virtual void Paint(void);
+	virtual void DoShow(Bool show);
+
+	virtual void ShowAsActive(Bool flag); // mac platform only
+	virtual void OnEvent(wxMouseEvent& event); // mac platform only
+	void DrawChoice(Bool flag);
+	void ReCalcRect(void);
+};
+
+#endif // IN_CPROTO
+#endif // wx_choich
diff --git a/src/wxmac/include/mac/wx_cmdlg.h b/src/wxmac/include/mac/wx_cmdlg.h
new file mode 100644
index 0000000..5bc2a24
--- /dev/null
+++ b/src/wxmac/include/mac/wx_cmdlg.h
@@ -0,0 +1,2 @@
+
+/* This dummy header is here for forward-compatibility - mflatt */
diff --git a/src/wxmac/include/mac/wx_dc.h b/src/wxmac/include/mac/wx_dc.h
new file mode 100644
index 0000000..8ca45e7
--- /dev/null
+++ b/src/wxmac/include/mac/wx_dc.h
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dc.h
+// Purpose:	wxDC device context declaration (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_dch
+#define wx_dch
+
+#include "wb_dc.h"
+#include "wx_gdi.h"
+#include "wxMacDC.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxDC ;
+#else
+
+class wxDC: public wxbDC
+{
+ public:
+	wxMacDC* cMacDC; // mac platform only
+	Pattern cMacPattern; // mac platform only (temp work pattern)
+
+	enum wxMacToolType {kNoTool, kPenTool, kBrushTool, kQuillTool, kBlitTool, kColorBlitTool}; // mac platform only
+	wxMacToolType cMacCurrentTool; // mac platform only
+
+ public:
+	wxDC(void);
+	~wxDC(void);
+
+// Mac platform only
+	void wxMacDrawPoint(int x1, int y1);
+	void wxMacDrawLine(int x1, int y1, int x2, int y2);
+};
+
+/*
+ * X
+ * Ok, so all this isn't neat, but it about works.
+ */
+
+#include <math.h>
+
+// Logical to device
+// Absolute
+#define XLOG2DEV(x) (int)floor(((x) - logical_origin_x)*logical_scale_x*user_scale_x + device_origin_x + 0.5)
+#define YLOG2DEV(y) (int)floor(((y) - logical_origin_y)*logical_scale_y*user_scale_y + device_origin_y + 0.5)
+
+// Logical to device without the device translation
+#define XLOG2DEV_2(x) (int)floor(((x) - logical_origin_x)*logical_scale_x*user_scale_x + 0.5)
+#define YLOG2DEV_2(y) (int)floor(((y) - logical_origin_y)*logical_scale_y*user_scale_y + 0.5)
+
+// Relative
+#define XLOG2DEVREL(x) (int)floor((x)*logical_scale_x*user_scale_x + 0.5)
+#define YLOG2DEVREL(y) (int)floor((y)*logical_scale_y*user_scale_y + 0.5)
+
+// Device to logical
+// Absolute
+#define XDEV2LOG(x) (int)(((x) - device_origin_x)/(logical_scale_x*user_scale_x) + logical_origin_x)
+
+#define YDEV2LOG(y) (int)(((y) - device_origin_y)/(logical_scale_y*user_scale_y) + logical_origin_y)
+
+// Relative
+#define XDEV2LOGREL(x) (int)((x)/(logical_scale_x*user_scale_x))
+#define YDEV2LOGREL(y) (int)((y)/(logical_scale_y*user_scale_y))
+
+#endif // IN_CPROTO
+#endif // wx_dch
diff --git a/src/wxmac/include/mac/wx_dccan.h b/src/wxmac/include/mac/wx_dccan.h
new file mode 100644
index 0000000..f418e0d
--- /dev/null
+++ b/src/wxmac/include/mac/wx_dccan.h
@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dccan.h
+// Purpose:	Canvas device context declaration (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_dccanh
+#define wx_dccanh
+
+#include "wx_gdi.h"
+#include "wb_dccan.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxCanvasDC ;
+#else
+
+class wxCanvas;
+class wxCanvasDC: public wxbCanvasDC
+{
+ protected:
+  Bool cMacDoingDrawing;  // mac platform only; internal use only; used by Begin/EndDrawing
+ public:
+  wxCanvas* canvas;
+  // Every time a callback happens, these are set to point to the right values
+  // for drawing calls to work
+
+  PixMapHandle pixmap;
+  int pixmapWidth;
+  int pixmapHeight;
+
+  RgnHandle current_reg,
+			onpaint_reg,
+			user_reg;
+
+  int current_pen_join ;
+  int current_pen_cap ;
+  int current_pen_nb_dash ;
+  char* current_pen_dash ;
+  wxBitmap* current_stipple ;
+
+  wxBitmap* selected_pixmap;
+
+  wxCanvasDC(void);
+  wxCanvasDC(wxCanvas* canvas); // Create a DC corresponding to a canvas
+
+  ~wxCanvasDC(void);
+
+  void SetCanvasClipping() ;
+  void GetClippingBox(float* x,float* y,float* w,float* h) ;
+
+  virtual void BeginDrawing(void);
+  virtual void EndDrawing(void);
+  virtual void SetCurrentDC(void); // mac platform only
+
+  void FloodFill(float x1, float y1, wxColour* col, int style=wxFLOOD_SURFACE) ;
+  Bool GetPixel(float x1, float y1, wxColour* col) ;
+
+  void SetPixel(float x1, float y1, wxColour* col) ;
+  inline void BeginSetPixel() {}
+  inline void EndSetPixel() {}
+
+  void DrawLine(float x1, float y1, float x2, float y2);
+  void IntDrawLine(int x1, int y1, int x2, int y2);
+  void CrossHair(float x, float y) ;
+  void DrawArc(float x1,float y1,float x2,float y2,float xc,float yc);
+  void DrawPoint(float x, float y);
+  void DrawLines(int n, wxPoint points[], float xoffset = 0, float yoffset = 0);
+  void DrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0);
+  void DrawPolygon(int n, wxPoint points[], float xoffset = 0, float yoffset = 0,
+  					int fillStyle=wxODDEVEN_RULE);
+  void DrawRectangle(float x, float y, float width, float height);
+  void DrawRoundedRectangle(float x, float y, float width, float height, float radius = 20);
+  void DrawEllipse(float x, float y, float width, float height);
+  void DrawIcon(wxIcon* icon, float x, float y);
+  void DrawText(const char* text, float x, float y, Bool use16 = FALSE);
+
+  void GetSize(float *width, float *height);
+
+  void Clear(void);
+  void SetFont(wxFont* font);
+  void SetPen(wxPen* pen);
+  void SetBrush(wxBrush* brush);
+  void SetLogicalFunction(int function);
+  void SetBackground(wxBrush* brush);
+  virtual void SetPaintRegion(Rect* paintRect); // mac platform only
+  void SetClippingRegion(float x, float y, float width, float height);
+  void GetClippingRegion(float *x, float *y, float *width, float *height);
+  void DestroyClippingRegion(void);
+
+  float GetCharHeight(void);
+  float GetCharWidth(void);
+  virtual void GetTextExtent(const char* string, float* x, float* y, float* descent = NULL,
+  						float* externalLeading = NULL, wxFont* the_font = NULL, Bool use16 = FALSE);
+  Bool StartDoc(char* message);
+  void EndDoc(void);
+  void StartPage(void);
+  void EndPage(void);
+  void SetMapMode(int mode);
+  void SetUserScale(float x, float y);
+  float DeviceToLogicalX(int x);
+  float DeviceToLogicalY(int y);
+  float DeviceToLogicalXRel(int x);
+  float DeviceToLogicalYRel(int y);
+  int LogicalToDeviceX(float x);
+  int LogicalToDeviceY(float y);
+  int LogicalToDeviceXRel(float x);
+  int LogicalToDeviceYRel(float y);
+
+  Bool Blit(float xdest, float ydest, float width, float height,
+            wxCanvasDC* source, float xsrc, float ysrc, int rop = wxCOPY);
+
+  void wxMacSetClip(void); // Internal only
+  void wxMacSetCurrentTool(wxMacToolType whichTool); // Internal only
+
+  void TryColour(wxColour *src, wxColour *dest);
+};
+
+#endif // IN_CPROTO
+#endif // wx_dccanh
+
diff --git a/src/wxmac/include/mac/wx_dcmem.h b/src/wxmac/include/mac/wx_dcmem.h
new file mode 100644
index 0000000..f06c6bf
--- /dev/null
+++ b/src/wxmac/include/mac/wx_dcmem.h
@@ -0,0 +1,38 @@
+/*
+ * File:	wx_dcmem.h
+ * Purpose:	Memory device context declaration
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+
+#ifndef wx_dcmemh
+#define wx_dcmemh
+
+#include "wb_dcmem.h"
+#include <QDOffscreen.h>
+
+#ifdef IN_CPROTO
+typedef       void    *wxMemoryDC ;
+#else
+
+class wxMemoryDC: public wxbMemoryDC
+{
+ public:
+  GWorldPtr	gworldH;
+  wxMemoryDC(void);
+  wxMemoryDC(wxCanvasDC *old_dc); // Create compatible DC
+
+  ~wxMemoryDC(void);
+  virtual void SelectObject(wxBitmap *bitmap);
+
+  GWorldPtr MacCreateGWorld(int width, int height);
+};
+
+#endif // IN_CPROTO
+#endif // wx_dcmemh
+
diff --git a/src/wxmac/include/mac/wx_dcpr.h b/src/wxmac/include/mac/wx_dcpr.h
new file mode 100644
index 0000000..111ec1c
--- /dev/null
+++ b/src/wxmac/include/mac/wx_dcpr.h
@@ -0,0 +1,121 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dccan.h
+// Purpose:	Canvas device context declaration (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_dcprh
+#define wx_dcprh
+
+#include "wx_gdi.h"
+#include "wb_dccan.h"
+#include "wx_print.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxPrinterDC ;
+#else
+
+//class wxCanvas;
+class wxPrinterDC: public wxbCanvasDC
+{
+ protected:
+  Bool cMacDoingDrawing;  // mac platform only; internal use only; used by Begin/EndDrawing
+ public:
+  //wxCanvas* canvas;
+  TPPrPort prPort;
+  THPrint  prRecHandle;
+
+  // Every time a callback happens, these are set to point to the right values
+  // for drawing calls to work
+
+  PixMapHandle pixmap;
+  int pixmapWidth;
+  int pixmapHeight;
+
+  RgnHandle current_reg,
+			onpaint_reg,
+			user_reg;
+
+  int current_pen_join ;
+  int current_pen_cap ;
+  int current_pen_nb_dash ;
+  char* current_pen_dash ;
+  wxBitmap* current_stipple ;
+
+  wxBitmap* selected_pixmap;
+
+  wxPrinterDC(void);
+  wxPrinterDC(THPrint); // Create a DC corresponding to a canvas
+
+  ~wxPrinterDC(void);
+
+  void SetPrinterClipping() ;
+  void GetClippingBox(float* x,float* y,float* w,float* h) ;
+
+  virtual void BeginDrawing(void);
+  virtual void EndDrawing(void);
+  virtual void SetCurrentDC(void); // mac platform only
+
+  void FloodFill(float x1, float y1, wxColour* col, int style=wxFLOOD_SURFACE) ;
+  Bool GetPixel(float x1, float y1, wxColour* col) ;
+
+  void DrawLine(float x1, float y1, float x2, float y2);
+  void IntDrawLine(int x1, int y1, int x2, int y2);
+  void CrossHair(float x, float y) ;
+  void DrawArc(float x1,float y1,float x2,float y2,float xc,float yc);
+  void DrawPoint(float x, float y);
+  void DrawLines(int n, wxPoint points[], float xoffset = 0, float yoffset = 0);
+  void DrawLines(int n, wxIntPoint points[], int xoffset = 0, int yoffset = 0);
+  void DrawPolygon(int n, wxPoint points[], float xoffset = 0, float yoffset = 0,
+  					int fillStyle=wxODDEVEN_RULE);
+  void DrawRectangle(float x, float y, float width, float height);
+  void DrawRoundedRectangle(float x, float y, float width, float height, float radius = 20);
+  void DrawEllipse(float x, float y, float width, float height);
+  void DrawIcon(wxIcon* icon, float x, float y);
+  void DrawText(const char* text, float x, float y, Bool use16 = FALSE);
+
+  void GetSize(float *width, float *height);
+
+  void Clear(void);
+  void SetFont(wxFont* font);
+  void SetPen(wxPen* pen);
+  void SetBrush(wxBrush* brush);
+  void SetLogicalFunction(int function);
+  void SetBackground(wxBrush* brush);
+  virtual void SetPaintRegion(Rect* paintRect); // mac platform only
+  void SetClippingRegion(float x, float y, float width, float height);
+  void GetClippingRegion(float *x, float *y, float *width, float *height);
+  void DestroyClippingRegion(void);
+
+  float GetCharHeight(void);
+  float GetCharWidth(void);
+  virtual void GetTextExtent(const char* string, float* x, float* y, float* descent = NULL,
+  						float* externalLeading = NULL, wxFont* the_font = NULL, Bool use16 = FALSE);
+  Bool StartDoc(char* message);
+  void EndDoc(void);
+  void StartPage(void);
+  void EndPage(void);
+  void SetMapMode(int mode);
+  void SetUserScale(float x, float y);
+  float DeviceToLogicalX(int x);
+  float DeviceToLogicalY(int y);
+  float DeviceToLogicalXRel(int x);
+  float DeviceToLogicalYRel(int y);
+  int LogicalToDeviceX(float x);
+  int LogicalToDeviceY(float y);
+  int LogicalToDeviceXRel(float x);
+  int LogicalToDeviceYRel(float y);
+
+  Bool Blit(float xdest, float ydest, float width, float height,
+            wxCanvasDC* source, float xsrc, float ysrc, int rop = wxCOPY);
+
+  void wxMacSetClip(void); // Internal only
+  void wxMacSetCurrentTool(wxMacToolType whichTool); // Internal only
+};
+
+#endif // IN_CPROTO
+#endif // wx_dccanh
+
diff --git a/src/wxmac/include/mac/wx_dialg.h b/src/wxmac/include/mac/wx_dialg.h
new file mode 100644
index 0000000..4f06cf0
--- /dev/null
+++ b/src/wxmac/include/mac/wx_dialg.h
@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dlog.h
+// Purpose:	wxDialogBox (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_dlogh
+#define wx_dlogh
+#include "wx_frame.h"
+#include "wb_dialg.h"
+
+#ifdef IN_CPROTO
+typedef void* wxDialogBox;
+#else
+
+class wxPanel;
+class wxButton;
+
+class wxDialogBox: public wxPanel
+{
+ protected:
+	int cButtonPressed;
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+	wxFrame *cFrame;		//mflatt, cjc
+
+	wxDialogBox // Constructor (for dialog window)
+	(
+		wxWindow*	parentFrame,		// this is ignored, used to be wxFrame*
+		char*		windowTitle,
+		Bool		modal = FALSE,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = wxDEFAULT_DIALOG_STYLE,
+		char*		windowName = "Dialog",
+		WXTYPE		objectType = wxTYPE_DIALOG_BOX
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxDialogBox();
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	virtual Bool IsShown(void);
+
+	void Show(Bool show);
+	Bool IsModal(void);
+	void ShowModal(void);
+	int GetButtonPressed(void);
+	void SetButtonPressed(int buttonPressed);
+	Bool OnClose(void);
+
+	virtual void Fit(void);
+	virtual void Centre(int d) { cFrame->Centre(d); }
+
+	void SetIcon(wxIcon* icon) { cFrame->SetIcon(icon); }
+	void Iconize(Bool iconize) { cFrame->Iconize(iconize); }
+	Bool Iconized(void)	   { return cFrame->Iconized(); }
+	
+    char* GetTitle(void) { return cFrame->GetTitle(); }
+	void SetTitle(char* title) { cFrame->SetTitle(title); }
+	wxWindow* GetFocusWindow(void) { return cFrame->GetFocusWindow(); }
+	void SetFocusWindow(wxWindow* window) { cFrame->SetFocusWindow(window); }
+	void LoadAccelerators(char* table) { cFrame->LoadAccelerators(table); }
+	virtual void SetSize(int x, int y, int width, int height, int flags = wxSIZE_AUTO);
+	virtual void OnSize(int w, int h);
+};
+
+void wxDialogOkButton(wxButton& but, wxEvent& event);
+void wxDialogCancelButton(wxButton& but, wxEvent& event);
+void wxDialogYesButton(wxButton& but, wxEvent& event);
+void wxDialogNoButton(wxButton& but, wxEvent& event);
+
+void wxSplitMessage(char *message, wxList *messageList, wxPanel *panel);
+void wxCentreMessage(wxList *messageList);
+
+int wxMessageBox(char *message, char *caption = "Message", long style = wxOK|wxCENTRE,
+  wxWindow* parent = NULL, int x = -1, int y = -1);
+
+#endif // IN_CPROTO
+#endif // wx_dialg.h
diff --git a/src/wxmac/include/mac/wx_frame.h b/src/wxmac/include/mac/wx_frame.h
new file mode 100644
index 0000000..f936a43
--- /dev/null
+++ b/src/wxmac/include/mac/wx_frame.h
@@ -0,0 +1,181 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_frame.h
+// Purpose:	wxFrame declaration (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_frameh
+#define wx_frameh
+
+#include "wb_frame.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxFrame;
+#else
+
+class wxMenuBar;
+class wxCommandEvent;
+class wxPanel;
+class wxText;
+class wxDialogBox;
+
+class wxFrame: public wxbFrame
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	char		cWindowTitle[256];
+	Bool		cMaximized;
+	wxPanel*	cStatusPanel;
+	wxText*		cStatusText;
+  	wxArea* 	cPlatformArea; // mac platform only
+  	wxArea* 	cContentArea; // mac platform only
+  	wxArea* 	cControlArea; // mac platform only
+	wxWindow*	cFocusWindow; // mac platform only
+	MenuHandle	cAppleMenuHandle;
+	Bool		cIsModal;
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+    int         cBusyCursor;
+
+	wxDialogBox* cDialogPanel; //cjc, mflatt
+
+	void NowFront(Bool on);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxFrame // Constructor (for frame window)
+	(
+		wxFrame*	parentFrame,		// this is ignored
+		char*		windowTitle,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = wxSDI | wxDEFAULT_FRAME,
+		char*		windowName = "frame",
+		WXTYPE		objectType = wxTYPE_FRAME
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxFrame(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxArea* PlatformArea(void); // mac platform only
+	wxArea* ContentArea(void); // mac platform only
+	wxArea* ControlArea(void); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void DoSetSize(int x, int y, int width, int height);
+	void Maximize(Bool maximize);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Status line methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void CreateStatusLine(int number = 1, char* name = "status_line");
+	void SetStatusText(char* text, int number = 0);
+ 	void SetStatusEraser(wxBrush* b); // tom
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Menubar methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void SetMenuBar(wxMenuBar* menu_bar);
+	void Command(int id); // Call this to simulate a menu command
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Icon methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void SetIcon(wxIcon* icon);
+	void Iconize(Bool iconize);
+	Bool Iconized(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Platform methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	Bool IsVisible(void);
+	void MacUpdateWindow(void);
+   	void MacDrawGrowIcon(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	char* GetTitle(void);
+	void SetTitle(char* title);
+	void Show(Bool show);
+	Bool IsFrontWindow(void);
+	virtual Bool IsModal(void);
+	void MakeModal(Bool on);
+	wxWindow* GetFocusWindow(void);
+	void SetFocusWindow(wxWindow* window);
+	void LoadAccelerators(char* table);
+	void OnActivate(Bool active);
+	void Enable(Bool on);
+	virtual void ChangeToGray(Bool on);
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void Paint(void);
+	virtual void OnChar(wxKeyEvent& event); // mac platform only
+	virtual void OnCommandEvent(wxCommandEvent& event) {}; // mac platform only
+
+    WindowPtr macWindow(void);
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void wxMacRecalcNewSize(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Menubar methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void ProcessCommand(int id);
+	virtual void ShowAsActive(Bool flag); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Platform methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual Bool IsMacWindow(void);
+	void wxMacStartDrawing(GrafPtr& oldPort, int& savePortH, int& savePortV);
+	void wxMacStopDrawing(GrafPtr oldPort, int savePortH, int savePortV);
+	Rect wxMacGetContRect(void);
+	Rect wxMacGetStrucRect(void);
+	inline wxDialogBox* wxMacGetDialog(void) {return cDialogPanel;} 
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void InitDefaults(void); // used by constructors
+
+//=============================================================================
+// Friend classes
+//=============================================================================
+private:
+
+	friend class wxApp;
+	friend class wxDialogBox;
+};
+
+#endif // IN_CPROTO
+#endif // wx_frameh
diff --git a/src/wxmac/include/mac/wx_gauge.h b/src/wxmac/include/mac/wx_gauge.h
new file mode 100644
index 0000000..3f9b4ee
--- /dev/null
+++ b/src/wxmac/include/mac/wx_gauge.h
@@ -0,0 +1,49 @@
+/*
+ * File:	wx_gauge.h
+ * Purpose:	Gauge box (experimental)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wb_group.h	1.2 5/9/94" */
+
+#ifndef __WX_GAUGE__
+#define __WX_GAUGE__
+
+#include "wb_gauge.h"
+#include "wxLabelArea.h"
+
+// Group box
+class wxGauge: public wxbGauge
+{
+ private:
+  wxLabelArea*	cTitle;
+  ControlHandle	cMacControl;
+  Rect		valueRect;
+  int    range;
+  int    value;
+
+ public:
+  wxGauge(void);
+  wxGauge(wxPanel *panel, char *label, int range, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "gauge");
+  ~wxGauge(void);
+
+  virtual void SetShadowWidth(int w) {}
+  virtual void SetBezelFace(int w) {}
+  virtual void SetRange(int r);
+  virtual void SetValue(int pos);
+  
+  virtual void Paint(void);
+  virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+  virtual char *GetLabel(void);
+  virtual void SetLabel(char *);
+
+  virtual void DoShow(Bool s);
+
+  virtual void ChangeToGray(Bool gray);
+};
+
+#endif
diff --git a/src/wxmac/include/mac/wx_gdi.h b/src/wxmac/include/mac/wx_gdi.h
new file mode 100644
index 0000000..1263cd7
--- /dev/null
+++ b/src/wxmac/include/mac/wx_gdi.h
@@ -0,0 +1,167 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_gdi.h (Macintosh version)
+// Purpose:	Declaration of various graphics objects - fonts, pens, icons etc.
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_gdih
+#define wx_gdih
+
+#include "wb_gdi.h"
+#include <QDOffscreen.h>
+
+#ifdef IN_CPROTO
+typedef       void    *wxFont ;
+typedef       void    *wxColourMap;
+typedef       void    *wxPen;
+typedef       void    *wxBrush;
+typedef       void    *wxIcon;
+typedef       void    *wxCursor;
+typedef       void    *wxBitmap;
+typedef       void    *XFontInfo;
+typedef       void    *XFontPool;
+#else
+
+// Font
+class wxFont: public wxbFont
+{
+ private:
+	short macFontId;
+
+	void Create(int PointSize, int FontId, int Family, int Style, int Weight, Bool underlined);
+
+ public:
+ 	static CGrafPtr gMacFontGrafPort; // mac platform only
+
+ public:
+	wxFont(void);
+	wxFont(int PointSize, int FontOrFamilyId, int Style, int Weight, Bool underlined = FALSE);
+	wxFont(int PointSize, const char *Face, int Family, int Style, int Weight, 
+	 Bool underlined = FALSE);
+	~wxFont(void);
+
+	float GetCharHeight(void);		// Mac Platform Only?
+	float GetCharWidth(void);
+	void  GetTextExtent(char* string, float* x, float* y,
+						float* descent, float* externalLeading, Bool use16 = FALSE);
+
+	int GetMacFontNum(void); // mac platform only
+	Style GetMacFontStyle(void); // mac platform only
+};
+
+class wxColourMap: public wxObject
+{
+ public:
+ 	CGrafPtr cmap;
+
+  wxColourMap(void);
+  ~wxColourMap(void);
+};
+
+#define wxColorMap wxColourMap
+
+// Pen
+class wxPen: public wxbPen
+{
+ public:
+  wxPen(void);
+  wxPen(wxColour& col, int width, int style);
+  wxPen(char *col, int width, int style);
+  ~wxPen(void);
+
+};
+
+// Brush
+class wxBrush: public wxbBrush
+{
+ public:
+  wxBrush(void);
+  wxBrush(wxColour& col, int style);
+  wxBrush(char *col, int style);
+  ~wxBrush(void);
+
+};
+
+
+// Bitmap
+class wxItem;
+class wxBitmap: public wxObject
+{
+ protected:
+  int width;
+  int height;
+  int depth;
+  Bool ok;
+ public:
+  GWorldPtr x_pixmap;
+  Bool freePixmap;
+  class wxMemoryDC *selectedInto; // mflatt
+  Bool selectedIntoDC;
+
+  wxBitmap(void) ;
+  wxBitmap(char bits[], int width, int height, int depth = 1);
+#if USE_XPM_IN_MAC
+  // Initialize with XPM data
+  wxBitmap(char **bits, wxItem *anItem = NULL);
+#endif
+  // Load a file or resource
+  wxBitmap(char *name, long flags = wxBITMAP_DISCARD_COLOURMAP | wxBITMAP_TYPE_RESOURCE);
+
+  // If depth is omitted, will create a bitmap compatible with the display
+  wxBitmap(int width, int height, int depth = -1);
+  ~wxBitmap(void);
+
+  virtual Bool Create(int width, int height, int depth = -1);
+  virtual Bool LoadFile(char *name, long flags = wxBITMAP_DISCARD_COLOURMAP | wxBITMAP_TYPE_RESOURCE);
+  virtual Bool SaveFile(char *name, int type, wxColourMap *cmap = NULL);
+
+  inline Bool Ok(void) { return ok; }
+  inline int GetWidth(void) { return width; }
+  inline int GetHeight(void) { return height; }
+  inline int GetDepth(void) { return depth; }
+  inline void SetWidth(int w) { width = w; }
+  inline void SetHeight(int h) {height = h; }
+  inline void SetDepth(int d) { depth = d; }
+  inline void SetOk(Bool isOk) { ok = isOk; }
+  // Heres a couple of methods used by wxExtend/wxPython exgdi.cc
+  void SetColourMap(wxColourMap *cmap);
+  wxColourMap* GetColourMap(void);
+
+
+  // Some Mac extensions ---- should only be used inside wxWindows, Please.
+  void DrawMac(void);
+  void DrawMac(int x, int y);
+};
+
+// Icon
+class wxIcon: public wxBitmap
+{
+ protected:
+ public:
+  wxIcon(void);
+  wxIcon(char bits[], int width, int height);
+  wxIcon(char *name, int type = wxBITMAP_TYPE_XBM);
+  ~wxIcon(void);
+};
+
+// Cursor
+class wxCursor: public wxObject
+{
+ public:
+  CursHandle cMacCursor;
+
+  wxCursor(void);
+  wxCursor(char bits[], int width, int height, int depth = 1);
+  wxCursor(char *name);
+  wxCursor(int cursor_type);
+  ~wxCursor(void);
+
+  Bool Ok(void);
+};
+
+#endif // IN_CPROTO
+#endif // wx_gdih
+
diff --git a/src/wxmac/include/mac/wx_group.h b/src/wxmac/include/mac/wx_group.h
new file mode 100644
index 0000000..b82fd97
--- /dev/null
+++ b/src/wxmac/include/mac/wx_group.h
@@ -0,0 +1,46 @@
+/*
+ * File:	wx_group.h
+ * Purpose:	wxGroupBox (X implementation)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_group.h	1.2 5/9/94" */
+
+#ifndef wx_grouph
+#define wx_grouph
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_win.h"
+#include "wx_panel.h"
+#include "wb_group.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxGroupBox ;
+#else
+
+// Group box
+class wxGroupBox: public wxbGroupBox
+{
+ public:
+  wxGroupBox(void);
+  wxGroupBox(wxPanel *panel, char *label, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "group");
+  ~wxGroupBox(void);
+
+  Bool Create(wxPanel *panel, char *label, int x = -1, int y = -1,
+           int width = -1, int height = -1, long style = 0, char *name = "group");
+
+//  void SetSize(int x, int y, int width, int height,int sizeFlags);
+  void SetLabel(char *);
+  char *GetLabel(void);
+};
+
+#endif // IN_CPROTO
+#endif // wx_grouph
diff --git a/src/wxmac/include/mac/wx_ipc.h b/src/wxmac/include/mac/wx_ipc.h
new file mode 100644
index 0000000..3ac4e6c
--- /dev/null
+++ b/src/wxmac/include/mac/wx_ipc.h
@@ -0,0 +1,137 @@
+/*
+ * File:	wx_ipc.h
+ * Purpose:	
+ * Author:	Tomaso Paoletti (Macintosh version)
+ * Created:	1994
+ * Updated:	
+ * Copyright:	(c) 1993-1994, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+/*
+ * Purpose:  Interprocess communication implementation. Uses DDE under
+ *           Windows, sockets to implement DDE subset under UNIX
+ *           and PPC Toolbox under Macintosh
+ */
+
+
+#ifndef wx_ipch
+#define wx_ipch
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_IPC
+#include <QuickDraw.h>
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wb_ipc.h"
+#include <PPCToolbox.h>
+
+/*
+ * Mini-DDE implementation
+
+   Most transactions involve a topic name and an item name (choose these
+   as befits your application).
+
+   A client can:
+
+   - ask the server to execute commands (data) associated with a topic
+   - request data from server by topic and item
+   - poke data into the server
+   - ask the server to start an advice loop on topic/item
+   - ask the server to stop an advice loop
+
+   A server can:
+
+   - respond to execute, request, poke and advice start/stop
+   - send advise data to client
+
+   Note that this limits the server in the ways it can send data to the
+   client, i.e. it can't send unsolicited information.
+ *
+ */
+
+#ifdef IN_CPROTO
+typedef       void    *wxConnection ;
+typedef       void    *wxServer;
+typedef       void    *wxClient;
+#else
+
+class wxIPCObject;
+
+extern wxIPCObject * wxTheIPCObj;
+
+class wxServer;
+class wxClient;
+class wxConnection: public wxbConnection
+{
+ public:
+#ifdef wx_motif
+  unsigned long xtInputId;
+#endif
+  PPCSessRefNum input_session;
+  PPCSessRefNum output_session;
+
+  wxConnection(char *buffer, int size);
+  wxConnection(void);
+  ~wxConnection(void);
+
+  // Calls that CLIENT can make
+  virtual Bool Execute(char *data, int size = -1, int format = wxCF_TEXT);
+  virtual char *Request(char *item, int *size = NULL, int format = wxCF_TEXT);
+  virtual Bool Poke(char *item, char *data, int size = -1, int format = wxCF_TEXT);
+  virtual Bool StartAdvise(char *item);
+  virtual Bool StopAdvise(char *item);
+
+  // Calls that SERVER can make
+  virtual Bool Advise(char *item, char *data, int size = -1, int format = wxCF_TEXT);
+
+  // Calls that both can make
+  Bool Disconnect(void);
+	void Notify(Bool notify);  // Internal use only
+};
+
+class wxServer: public wxbServer
+{
+ public:
+
+  PPCPortRefNum server_socket;
+
+  wxServer(void);
+  ~wxServer(void);
+  Bool Create(char *server_name); // Returns FALSE if can't create server (e.g. port
+                                  // number is already in use)
+  void PeriodicTask(void);	 // Mac specific
+};
+
+class wxClient: public wxbClient
+{
+ public:
+  PPCPortRefNum client_socket;
+
+  wxClient(void);
+  ~wxClient(void);
+  Bool ValidHost(char *host);
+  virtual wxConnection *MakeConnection(char *host, char *server, char *topic);
+                                                // Call this to make a connection.
+                                                // Returns NULL if cannot.
+ 	void PeriodicTask(void);	// Mac specific                                          
+};
+
+/*
+class wxChild: public wxObject
+{
+ public:
+  int the_pid;
+  wxChild(void);
+  Bool Create(char *command, char *argv[]);
+  virtual wxConnection *OnSpawn(int pid);
+  virtual void OnDeath(void);
+};
+*/
+
+#endif // IN_CPROTO
+#endif // USE_IPC
+#endif // wx_ipc.h
diff --git a/src/wxmac/include/mac/wx_ipcob.h b/src/wxmac/include/mac/wx_ipcob.h
new file mode 100644
index 0000000..9348b73
--- /dev/null
+++ b/src/wxmac/include/mac/wx_ipcob.h
@@ -0,0 +1,40 @@
+/*
+ * File:	wx_ipcob.h
+ * Purpose:	Interprocess communication implementation, wxIPCObject (Mac)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Modified: Tomaso Paoletti
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wx_ipcobh
+#define wx_ipcobh
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_IPC
+
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wb_ipcob.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxIPCObject ;
+#else
+
+class wxIPCObject: public wxbIPCObject
+{
+ public:
+  wxIPCObject();
+  ~wxIPCObject();
+  
+  virtual void PeriodicTask(void) {};  // Mac specific
+};
+
+#endif // IN_CPROTO
+#endif // USE_IPC
+#endif // wx_ipcob.h
diff --git a/src/wxmac/include/mac/wx_item.h b/src/wxmac/include/mac/wx_item.h
new file mode 100644
index 0000000..3c01c0f
--- /dev/null
+++ b/src/wxmac/include/mac/wx_item.h
@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_item.h
+// Purpose:	Declares panel items (controls/widgets) for Mac
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_itemh
+#define wx_itemh
+
+#include "wb_item.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxItem ;
+#else
+
+class wxItem: public wxbItem
+{
+public:
+	wxItem(void);
+	// Constructor (given parentArea)
+	wxItem (wxArea*	parentArea, int x = -1, int y = -1, int width = -1, int height = -1,
+		long style = 0, char* windowName = "item");
+	// Constructor (given parentWindow)
+	wxItem (wxWindow*	parentWindow, int x = -1, int y = -1, int width = -1, int height = -1,
+		long		style = 0, char* windowName = "item");
+	// Constructor (given objectType; i.e., menu or menuBar)
+	wxItem (char* windowName);
+
+	~wxItem(void);
+
+#if 0 // FIXME - these are from 16.1 below comes from msw, they should be virtual?
+	void GetSize(int *width, int *height);
+	void GetPosition(int *x, int *y);
+	void SetSize(int x, int y, int width, int height);
+	void SetClientSize(int width, int height);
+	void SetFocus(void);
+	char *GetLabel(void);
+#endif
+	void SetLabel(char *label) {};	// This should be overridden in all subclasses
+
+	virtual void SetBackgroundColour(wxColour* col);
+	virtual void SetLabelColour(wxColour* col);
+	virtual void SetButtonColour(wxColour* col);
+	virtual void ChangeColour(void);
+
+	virtual void OnChar(wxKeyEvent& event); // mac platform only
+};
+
+char *wxItemStripLabel(char *label);
+
+#endif // IN_CPROTO
+#endif // wx_itemh
diff --git a/src/wxmac/include/mac/wx_lbox.h b/src/wxmac/include/mac/wx_lbox.h
new file mode 100644
index 0000000..77b002e
--- /dev/null
+++ b/src/wxmac/include/mac/wx_lbox.h
@@ -0,0 +1,133 @@
+/*
+ * File:	wx_lbox.h
+ * Purpose:	List box panel item
+ * Author:	Julian Smart/Cecil Coupe (mac version)
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+#ifndef wx_lboxh
+#define wx_lboxh
+
+#include "wb_lbox.h"
+#include "wxLabelArea.h"
+#include <Lists.h>
+
+#ifdef IN_CPROTO
+typedef       void    *wxListBox ;
+#else
+
+class wxBitmap;
+class wxPanel;
+class wxMessage;
+class wxList;
+
+// List box item
+class wxListBox: public wxbListBox
+{
+ public:
+	wxLabelArea*	cListTitle;
+	ListHandle		cListHandle;
+	int				cHaveVScroll;
+	int				cKeycnt;		// next key (number)
+	wxList*			cDataList;		// List of ClientData(s) per ListBox Entry
+	unsigned long   cLastClickTime;  // mflatt: for double-clicking
+	Cell			cLastClickCell;  // mflatt: for double-clicking
+	wxArea*			cBorderArea; 	// mflatt: for showing keyboard focus
+	wxArea*         cThinBorderArea; // mflatt: box around list
+	
+  wxListBox(
+  		wxPanel *panel, 
+  		wxFunction func, 
+  		char *Title,
+		Bool Multiple = wxSINGLE|wxNEEDED_SB,
+		int x = -1, 
+		int y = -1, 
+		int width = -1, 
+		int height = -1,
+		int N = 0, 
+		char **Choices = NULL,
+		long style = 0, 
+		char *name = "listBox",
+		WXTYPE		objectType = wxTYPE_LIST_BOX
+		);
+		
+  ~wxListBox(void);
+
+  Bool Create(wxPanel *panel, wxFunction func, char *Title, 
+  		Bool Multiple = FALSE,
+		int x = -1, 
+		int y = -1, 
+		int width = -1, 
+		int height = -1,
+		int N = 0, 
+		char **Choices = NULL,
+		long style = 0, 
+		char *name = "listBox"
+	);
+  void Append(char *Item);
+  void Append(char *Item, char *Client_data);
+  void Set(int N, char *Choices[]);
+  int FindString(char *s);
+  void Clear(void);
+  void SetSelection(int N, Bool select = TRUE);
+  void SetString(int N, char *s);
+  // Get client data
+  char *GetClientData(int N);
+  void SetClientData(int N, char *Client_data);
+
+  virtual void ChangeToGray(Bool gray);
+
+  void Deselect(int N);
+
+  // For single choice list item only
+  int GetSelection(void);
+  void Delete(int N);
+  
+  // For single or multiple choice list item
+  int GetSelections(int **list_selections);
+  Bool Selected(int N);
+  char *GetString(int N);
+#if 0 // CJC
+  void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+  void SetSize(int width, int height) { wxItem::SetSize(width, height); }
+  void GetPosition(int *x, int *y);
+#endif
+  void InsertItems(int nItems, char **Items, int pos);
+  // Set the specified item at the first visible item
+  // or scroll to max range.
+  void SetFirstItem(int N) ;
+  void SetFirstItem(char *s) ;
+
+  void SetBackgroundColour(wxColour*col) ;
+  void SetLabelColour(wxColour*col) ;
+  void SetButtonColour(wxColour*col) ;
+  // Windows-specific code to set the horizontal extent of
+  // the listbox, if necessary. If s is non-NULL, it's
+  // used to calculate the horizontal extent.
+  // Otherwise, all strings are used.
+  void SetHorizontalExtent(char *s = NULL);
+
+  void OnSetFocus(void);
+  void OnKillFocus(void);
+  void ShowAsActive(Bool flag);
+  
+  void DoShow(Bool);
+  
+  // For the mac:
+  virtual void Paint(void);
+  virtual void OnEvent(wxMouseEvent& event);
+  virtual void OnChar(wxKeyEvent& event); // mflatt
+  virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+
+  char *GetLabel(void);
+  void SetLabel(char *label);
+
+  virtual Bool WantsFocus(void); // mflatt
+};
+
+#endif // IN_CPROTO
+#endif // wx_lboxh
diff --git a/src/wxmac/include/mac/wx_mac_utils.h b/src/wxmac/include/mac/wx_mac_utils.h
new file mode 100644
index 0000000..1b28ae1
--- /dev/null
+++ b/src/wxmac/include/mac/wx_mac_utils.h
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_mac_utils.h
+// Purpose:	Various utilities (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_mac_utilsh
+#define wx_mac_utilsh
+
+#include "wxMacObj.h"
+#include <Strings.h>
+#include <QuickDraw.h>
+
+class wxMacString: public wxMacObject
+{
+  protected:
+	Str255		pString;
+
+  public:
+	wxMacString(void);						// constructor
+	wxMacString(const char* cString);				// constructor from cString
+	~wxMacString(void);						// destructor
+
+	wxMacString& operator=(char* cString);	// assignment of cString
+	Str255& operator() (void);				// get reference to pascal string
+};
+
+class wxMacString1: public wxMacString
+{
+  public:
+	wxMacString1(void);						// constructor
+	wxMacString1(char* cString);				// constructor from cString
+	wxMacString1& operator=(char* cString);	// assignment of cString
+};
+
+void wxMacCtoPString(char* theCString, Str255 thePString);
+void wxMacPtoCString(Str255 thePString, char* theCString);
+char* macCopyString(char* s);
+char* macCopyString0(char* s);
+char* macCopyString1(char* s);
+
+void macGetHatchPattern(int hatchStyle, Pattern pattern);
+
+#endif // wx_mac_utils
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wx_main.h b/src/wxmac/include/mac/wx_main.h
new file mode 100644
index 0000000..aa83660
--- /dev/null
+++ b/src/wxmac/include/mac/wx_main.h
@@ -0,0 +1,91 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_main.h
+// Purpose:	wxApp declaration and a few other functions (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_mainh
+#define wx_mainh
+
+#include "wb_main.h"
+#include <Events.h>
+#ifdef IN_CPROTO
+typedef       void* wxApp;
+#else
+
+extern int wxEntry(int argc, char *argv[]);
+
+class wxFrame;
+
+// Represents the application. Derive OnInit and declare
+// a new App object to start application
+class wxApp: public wxbApp
+{
+public:
+	int				keep_going;
+ protected:
+ 	EventRecord		cCurrentEvent; // mac platform only
+ 	RgnHandle		cMacCursorRgn; // mac platform only
+	Point			cLastMousePos; // mac platform only
+
+ public:
+	wxApp(wxlanguage_t language = wxLANGUAGE_DEFAULT);
+	~wxApp(void);
+#if USE_MAC_DIALOG_PANEL
+	virtual int MainLoop(void);
+	virtual void ExitMainLoop(void);
+	virtual Bool Initialized(void);
+	virtual Bool Pending(void);
+	virtual void Dispatch(void);
+#else
+	virtual int MainLoop(void);
+	virtual void ExitMainLoop(void);
+	virtual Bool Initialized(void);
+	virtual Bool Pending(void);
+	virtual void Dispatch(void);
+	virtual void DoOneEvent(void);		// used primarily from MainLoop
+#endif
+	virtual void AdjustCursor(void);	//GRW
+
+	virtual char *GetDefaultAboutItemName(void); // mflatt
+	virtual void DoDefaultAboutItem(void); // mflatt
+
+	void doMacPreEvent();
+	void doMacDispatch(EventRecord*);
+	void doMacPostEvent();
+
+ protected:
+  	virtual void DoIdle(void);
+
+	void doMacMouseDown();
+	void doMacMouseUp();
+	void doMacMouseMotion();
+	void doMacKeyDown();
+	void doMacAutoKey();
+	void doMacKeyUp();
+	void doMacActivateEvt();
+	void doMacUpdateEvt();
+	void doMacDiskEvt();
+	void doMacOsEvt();
+	void doMacHighLevelEvent();
+
+	void doMacResumeEvent(void);
+	void doMacSuspendEvent(void);
+	void doMacMouseMovedMessage(void);
+
+	void doMacInMenuBar(long menuResult);
+	void doMacInContent(WindowPtr window);
+	void doMacContentClick(wxFrame* frame);
+	void doMacInDrag(WindowPtr window);
+	void doMacInGrow(WindowPtr window);
+	void doMacInGoAway(WindowPtr window);
+	void doMacInZoom(WindowPtr window, short windowPart);
+
+	wxFrame* findMacWxFrame(WindowPtr theMacWindow);
+};
+
+#endif // IN_CPROTO
+#endif // wx_mainh
diff --git a/src/wxmac/include/mac/wx_menu.h b/src/wxmac/include/mac/wx_menu.h
new file mode 100644
index 0000000..803a912
--- /dev/null
+++ b/src/wxmac/include/mac/wx_menu.h
@@ -0,0 +1,194 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_menu.h
+// Purpose:	Declares menus and menu bars (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_menuh
+#define wx_menuh
+
+#include "wb_menu.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxMenu ;
+typedef       void* wxMenuBar ;
+#else
+
+class wxMenuBar;
+
+//-----------------------------------------------------------------------------
+// Menu
+//-----------------------------------------------------------------------------
+class wxMenu: public wxbMenu
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+friend class wxChoice;
+protected:
+
+	MenuHandle		cMacMenu;		// mac platform
+	short			cMacMenuId;		// mac platform
+	static short	gMenuIdCounter; // mac platform (to give unique menuID's to mac menus)
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMenu // Constructor (given objectType)
+	(
+		char*		Title = NULL,
+		wxFunction	func = NULL,
+		char*		windowName = "menu",
+		WXTYPE		objectType = wxTYPE_MENU
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxMenu(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void AppendSeparator(void);
+	void Append(int Id, char* Label, char* helpString=NULL, Bool checkable=FALSE);
+	void Append(int Id, char* Label, wxMenu* SubMenu, char* helpString = NULL);
+	void Delete(int Id); // mflatt
+	void DeleteByPosition(int pos); // mflatt
+	void Enable(int Id, Bool Flag);
+	void Check(int Id, Bool Flag);
+	Bool Checked(int Id);
+	char* GetTitle(void);
+	void SetTitle(char* label);
+
+	char* GetLabel(void);			// override virtual from superclass
+	char* GetLabel(int id);			// add new method for this class
+
+	void SetLabel(char* label);
+	void SetLabel(int id, char* label);
+	void Break(void) ;
+
+	virtual void SetSize(int x, int y, int width, int height);
+	virtual void DoSetSize(int x, int y, int width, int height);
+	virtual void Enable(Bool enable);
+	virtual void Show(Bool show);
+
+    MenuHandle CreateCopy(char *title, Bool doabouthack);
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	MenuHandle MacMenu(void);
+	short GetMacMenuId(void);
+	virtual wxMenu* wxMacFindSubmenu(int macMenuId);
+	virtual void wxMacInsertSubmenu(void); // used by wxMenuBar::Install
+	void MacChangeMenuText(wxMenu *menu, char *title);
+
+//=============================================================================
+// Friend classes
+//=============================================================================
+private:
+
+	void Delete(wxMenu* menu, int Id, int pos); // mflatt: for removing deleted sunmenus
+
+	friend class wxMenuBar;
+	friend class wxMenuItem;
+	friend class wxFrame;
+    friend class wxWindow;
+};
+
+//-----------------------------------------------------------------------------
+// Menu Bar
+//-----------------------------------------------------------------------------
+
+class wxMenuBar:public wxbMenuBar
+{
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+	wxMenu*	wxHelpHackMenu;
+	short 	iHelpMenuHackNum;
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMenuBar // Constructor (given objectType)
+	(
+		char*		windowName = "menubar",
+		WXTYPE		objectType = wxTYPE_MENU_BAR
+	);
+
+	wxMenuBar // Constructor (given Menus)
+	(
+		int			N,
+		wxMenu*		Menus[],
+		char*		Titles[],
+		char*		windowName = "menubar",
+		WXTYPE		objectType = wxTYPE_MENU_BAR
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxMenuBar(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void Enable(int id, Bool flag);
+	void EnableTop(int pos, Bool flag);
+	void Check(int id, Bool flag);
+	Bool Checked(int Id);
+	char* GetLabel(void);
+	void SetLabel(char* label);
+	void SetLabel(int id, char* label) ;
+	char* GetLabel(int id) ;
+	void SetLabelTop(int pos,char* label) ;
+	char* GetLabelTop(int pos) ;
+
+	virtual void SetSize(int x, int y, int width, int height);
+	virtual void DoSetSize(int x, int y, int width, int height);
+	virtual void Enable(Bool enable);
+	virtual void Show(Bool show);
+
+	virtual Bool OnAppend(wxMenu * menu, char *title); // mflatt
+	virtual Bool OnDelete(wxMenu *menu, int index); // mflatt
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMenu* wxMacFindMenu(int macMenuId);
+
+	void Install(void);
+
+//=============================================================================
+// Friend classes
+//=============================================================================
+private:
+
+	friend class wxApp;
+	friend class wxMenu;
+	friend class wxFrame;
+};
+
+#endif // IN_CPROTO
+#endif // wx_menuh
diff --git a/src/wxmac/include/mac/wx_messg.h b/src/wxmac/include/mac/wx_messg.h
new file mode 100644
index 0000000..47cd049
--- /dev/null
+++ b/src/wxmac/include/mac/wx_messg.h
@@ -0,0 +1,119 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_messg.h
+// Purpose:	Declares message panel item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_messgh
+#define wx_messgh
+
+#include "wb_messg.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxMessage ;
+#else
+
+class wxMessage: public wxbMessage
+{
+ public:
+ 	char* 	cMessage; // mac platform only
+	wxBitmap*	sBitmap;
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxMessage // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		long		style = 0,
+		char*		windowName = "message",
+		WXTYPE		objectType = wxTYPE_MESSAGE
+	);
+
+	wxMessage // Constructor (given parentArea, font)
+	(
+		wxArea*		parentArea,
+		char*		label,
+		wxFont*		theFont,
+		int 		x = -1,
+		int			y = -1,
+		long		style = 0,
+		char*		windowName = "message",
+		WXTYPE		objectType = wxTYPE_MESSAGE
+	);
+
+	wxMessage // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		long		style = 0,
+		char*		windowName = "message",
+		WXTYPE		objectType = wxTYPE_MESSAGE
+	);
+
+	wxMessage // Constructor (given parentPanel, font)
+	(
+		wxPanel*	parentPanel,
+		char*		label,
+		wxFont*		theFont,
+		int 		x = -1,
+		int			y = -1,
+		long		style = 0,
+		char*		windowName = "message",
+		WXTYPE		objectType = wxTYPE_MESSAGE
+	);
+
+	wxMessage // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		wxBitmap*	bitmap,
+		int 		x = -1,
+		int			y = -1,
+		long		style = 0,
+		char*		windowName = "message",
+		WXTYPE		objectType = wxTYPE_MESSAGE
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxMessage(void);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+	void CreateWxMessage(char* label, wxFont* theFont = NULL); // common constructor initialization
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+//=============================================================================
+// Window coordinate system transformation methods
+//=============================================================================
+	virtual char* GetLabel(void); // mac platform only
+	virtual void SetLabel(char* label); // mac platform only
+	virtual void SetLabel(wxBitmap *bitmap);
+	virtual void Paint(void); // mac platform only
+	virtual void DoShow(Bool show); // mac platform only
+
+    virtual void ChangeToGray(Bool gray);
+
+	void ChangeColour(void) ;
+};
+
+#endif // IN_CPROTO
+#endif // wx_messg
diff --git a/src/wxmac/include/mac/wx_mf.h b/src/wxmac/include/mac/wx_mf.h
new file mode 100644
index 0000000..245c323
--- /dev/null
+++ b/src/wxmac/include/mac/wx_mf.h
@@ -0,0 +1,65 @@
+/*
+ * File:	wx_mf.h
+ * Purpose:	Metafile device context declaration (X version)
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_mf.h	1.2 5/9/94" */
+
+
+#ifndef wx_mfh
+#define wx_mfh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_METAFILE
+#include "wb_mf.h"
+
+/*
+ * Metafile and metafile device context classes - work in Windows 3.1 only
+ *
+ */
+
+#ifdef IN_CPROTO
+typedef       void    *wxMetaFile ;
+typedef       void    *wxMetaFileDC ;
+#else
+
+class wxMetaFile: public wxbMetaFile
+{
+  DECLARE_DYNAMIC_CLASS(wxMetaFile)
+
+ public:
+    
+  wxMetaFile(void);
+  ~wxMetaFile(void);
+
+  // After this is called, the metafile cannot be used for anything
+  // since it is now owned by the clipboard.
+  Bool SetClipboard(int width = 0, int height = 0);
+};
+
+class wxMetaFileDC: public wxbMetaFileDC
+{
+  DECLARE_DYNAMIC_CLASS(wxMetaFileDC)
+
+ public:
+  wxMetaFileDC(char *file = NULL);
+  ~wxMetaFileDC(void);
+
+  // Should be called at end of drawing
+  wxMetaFile *Close(void);
+  void SetMapMode(int mode);
+};
+
+#endif // IN_CPROTO
+#endif // USE_METAFILE
+#endif // wx_mfh
diff --git a/src/wxmac/include/mac/wx_mnuit.h b/src/wxmac/include/mac/wx_mnuit.h
new file mode 100644
index 0000000..122e347
--- /dev/null
+++ b/src/wxmac/include/mac/wx_mnuit.h
@@ -0,0 +1,81 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_mnuit.h
+// Purpose:	Declares menu item class (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_mnuith
+#define wx_mnuith
+
+#include "wb_mnuit.h"
+
+#ifdef IN_CPROTO
+typedef       void    *wxMenuItem ;
+#else
+
+class wxMenu;
+
+class wxMenuItem: public wbMenuItem
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	Bool	checkable ;
+	Bool	cIsChecked;
+	Bool	cIsEnabled;
+
+	wxMenu*	parentMenu;
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMenuItem(void);
+	wxMenuItem
+	(
+		wxMenu* theParentMenu,
+		Bool	isCheckable = FALSE
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxMenuItem(void);
+  
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// tree methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMenu* ParentMenu(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void Check(Bool flag);
+	Bool IsChecked(void);
+	Bool IsCheckable(void);
+	void Enable(Bool flag);
+	char* GetHelpString(void);
+	void SetHelpString(char* theHelpString);
+	char* GetLabel(void);
+	void SetLabel(char* label);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	short GetMacItemNumber(void); // mac platform only
+
+	inline Bool IsEnabled(void) { return cIsEnabled; }
+};
+
+#endif // IN_CPROTO
+#endif // wx_mnuith
+
diff --git a/src/wxmac/include/mac/wx_mtxt.h b/src/wxmac/include/mac/wx_mtxt.h
new file mode 100644
index 0000000..0e6420d
--- /dev/null
+++ b/src/wxmac/include/mac/wx_mtxt.h
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_mtxt.h
+// Purpose:	Declares multi-line text panel item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_mtxth
+#define wx_mtxth
+
+#include "wb_mtxt.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxMultiText ;
+#else
+
+class wxMultiText: public wxbMultiText
+{
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxMultiText // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		char*		value = "",
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "multiText",
+		WXTYPE		objectType = wxTYPE_MULTI_TEXT
+	);
+
+	wxMultiText // Constructor (given parentTextWindow)
+	(
+		wxTextWindow*	parentTextWindow,
+		wxFunction		function,
+		char*			label,
+		char*			value = "",
+		int 			x = -1,
+		int				y = -1,
+		int				width = -1,
+		int				height = -1,
+		long			style = 0,
+		char*			windowName = "multiText",
+		WXTYPE			objectType = wxTYPE_MULTI_TEXT
+	);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+	char *GetValue(void);		//  16.x ?
+	void GetValue(char* buffer, int maxLen);
+};
+
+#endif // IN_CPROTO
+#endif // wx_mtxth
diff --git a/src/wxmac/include/mac/wx_panel.h b/src/wxmac/include/mac/wx_panel.h
new file mode 100644
index 0000000..4c501e0
--- /dev/null
+++ b/src/wxmac/include/mac/wx_panel.h
@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_panel.h
+// Purpose:	wxPanel subwindow, for panel items (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_panelh
+#define wx_panelh
+
+#include "wb_panel.h"
+
+#define PANEL_HSPACING  10
+#define PANEL_VSPACING  8
+#define PANEL_LEFT_MARGIN 4
+#define PANEL_TOP_MARGIN  4
+
+#ifdef IN_CPROTO
+typedef       void* wxPanel;
+#else
+
+class wxItem;
+class wxFrame;
+
+class wxPanel: public wxbPanel
+{
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	int			cursor_x;
+	int			cursor_y;
+	int			max_width;
+	int			max_height;
+	int			max_line_height;
+	int 		currentRow;
+	int 		currentCol;
+	wxWindow*	last_created;
+
+    wxArea*     cPanelBorder;
+
+friend class wxWindow;	
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxPanel // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "panel",
+		WXTYPE		objectType = wxTYPE_PANEL
+	);
+
+	wxPanel // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "panel",
+		WXTYPE		objectType = wxTYPE_PANEL
+	);
+
+	wxPanel // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "panel",
+		WXTYPE		objectType = wxTYPE_PANEL
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxPanel(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void Centre(int direction);
+	void Fit(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Item placement methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void NewLine(void);
+	void NewLine(int pixels);
+	void Tab(void);
+	void Tab(int pixels); // Tab specified number of pixels
+	void GetCursor(int* x, int* y);
+	void SetItemCursor(int x, int y);
+	void SetHorizontalSpacing(int sp);
+	int GetHorizontalSpacing(void);
+	void SetVerticalSpacing(int sp);
+	int GetVerticalSpacing(void);
+	void AdvanceCursor(wxWindow* item); // Update next cursor position
+	Bool WantsFocus();
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void SetBackgroundColour(wxColour*col);
+	void SetLabelColour(wxColour*col);
+	void SetButtonColour(wxColour*col);
+	void ChangeColour(void);
+	void DoShow(Bool show);
+	void Paint(void);
+	virtual void OnChar(wxKeyEvent& event); // mac platform only
+
+ 	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 	// Tree methods
+ 	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 	void DestroyChildren() ; // tom
+ 	void OnDeleteChild(wxWindow* win); //tom
+ 
+    virtual void ChangeToGray(Bool gray);
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void AddChild(wxObject* child);
+	//virtual void OnDeleteChildWindow(wxWindow* childWindow); 
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void CreateWxPanel(void); // common constructor initialization
+	void InitDefaults(void); // used by constructors
+};
+
+#endif // IN_CPROTO
+#endif // wx_panelh
diff --git a/src/wxmac/include/mac/wx_print.h b/src/wxmac/include/mac/wx_print.h
new file mode 100644
index 0000000..5d93def
--- /dev/null
+++ b/src/wxmac/include/mac/wx_print.h
@@ -0,0 +1,354 @@
+/*
+ * File:	wx_print.h
+ * Purpose:	Printing-related classes
+ * Author:	Julian Smart
+ * Created:	1995
+ * Updated:	
+ * Copyright:	(c) 1995, AIAI, University of Edinburgh
+ */
+
+#ifndef wx_printh
+#define wx_printh
+
+#include "common.h"
+#include "wx_canvs.h"
+#include "wx_panel.h"
+#include "wx_frame.h"
+#include "wx_dialg.h"
+#include "wx_choic.h"
+
+#ifdef wx_mac
+#include <Printing.h>
+#endif
+
+#ifdef IN_CPROTO
+typedef       void    *wxPrintDialog ;
+typedef       void    *wxPrinter ;
+typedef       void    *wxPrintout ;
+typedef       void    *wxPreviewCanvas ;
+typedef       void    *wxPreviewControlBar ;
+typedef       void    *wxPreviewFrame ;
+typedef       void    *wxPrintPreview ;
+#else
+
+class wxDC;
+class wxPrintout;
+class wxPrinter;
+class wxPrintDialog;
+class wxPrintPreview;
+class wxPreviewCanvas;
+class wxPreviewControlBar;
+class wxPreviewFrame;
+
+/*
+ * wxPrintData
+ * Encapsulates information displayed and edited in the printer dialog box.
+ */
+ 
+class wxPrintData: public wxObject
+{
+ public:
+  // macintosh
+  THPrint macPrData;
+
+  wxPrintData(void);
+  ~wxPrintData(void);
+
+  void SetAbortFlag(void); // set mac abort flag
+  int GetFromPage(void);
+  int GetToPage(void);
+  int GetMinPage(void);
+  int GetMaxPage(void);
+  int GetNoCopies(void);
+  Bool GetAllPages(void);
+  Bool GetCollate(void);
+
+  void SetFromPage(int);
+  void SetToPage(int);
+  void SetMinPage(int);
+  void SetMaxPage(int);
+  void SetNoCopies(int);
+  void SetAllPages(Bool);
+  void SetCollate(Bool);
+  void SetPrintToFile(Bool);
+  void SetSetupDialog(Bool);
+
+  void EnablePrintToFile(Bool);
+  void EnableSelection(Bool);
+  void EnablePageNumbers(Bool);
+  void EnableHelp(Bool);
+
+  void operator=(const wxPrintData& data);
+};
+
+/*
+ * wxPrinterDialog
+ * The common dialog for printing.
+ */
+ 
+class wxPrintDialog: public wxDialogBox
+{
+ private:
+  wxPrintData printData;
+  wxDC *printerDC;
+  Bool destroyDC;
+  char *deviceName;
+  char *driverName;
+  char *portName;
+  wxWindow *dialogParent;
+ public:
+  wxPrintDialog(wxWindow *parent, wxPrintData *data = NULL);
+  ~wxPrintDialog(void);
+
+#ifdef wx_mac
+  virtual void Show(Bool flag);
+#else
+  virtual void Show(Bool flag);
+#endif
+
+  virtual wxPrintData& GetPrintData(void) { return printData; }
+  virtual wxDC *GetPrintDC(void);
+};
+
+/*
+ * Represents the printer: manages printing a wxPrintout object
+ */
+ 
+class wxPrinter: public wxObject
+{
+ private:
+  wxPrintData printData;
+  wxPrintout *currentPrintout;
+#ifndef wx_mac
+  FARPROC lpAbortProc;
+#endif
+ public:
+  static wxWindow *abortWindow;
+  static Bool abortIt;
+
+  wxPrinter(wxPrintData *data = NULL);
+  ~wxPrinter(void);
+
+  virtual Bool Print(wxWindow *parent, wxPrintout *printout, Bool prompt = TRUE);
+  virtual Bool PrintDialog(wxWindow *parent);
+  virtual wxWindow *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
+  virtual Bool Setup(wxWindow *parent);
+  virtual void ReportError(wxWindow *parent, wxPrintout *printout, char *message);
+  virtual wxPrintData &GetPrintData(void);
+  virtual inline Bool Abort(void) { return abortIt; }
+};
+
+/*
+ * wxPrintout
+ * Represents an object via which a document may be printed.
+ * The programmer derives from this, overrides (at least) OnPrintPage,
+ * and passes it to a wxPrinter object for printing, or a wxPrintPreview
+ * object for previewing.
+ */
+ 
+class wxPrintout: public wxObject
+{
+ private:
+   char *printoutTitle;
+   wxDC *printoutDC;
+
+   int pageWidthPixels;
+   int pageHeightPixels;
+
+   int pageWidthMM;
+   int pageHeightMM;
+
+   int PPIScreenX;
+   int PPIScreenY;
+   int PPIPrinterX;
+   int PPIPrinterY;
+
+   Bool isPreview;
+ public:
+  wxPrintout(char *title = "Printout");
+  ~wxPrintout(void);
+
+  virtual Bool OnBeginDocument(int startPage, int endPage);
+  virtual void OnEndDocument(void);
+  virtual void OnBeginPrinting(void);
+  virtual void OnEndPrinting(void);
+
+  // Guaranteed to be before any other functions are called
+  inline virtual void OnPreparePrinting(void) { }
+
+  virtual Bool HasPage(int page);
+  virtual Bool OnPrintPage(int page) = 0;
+  virtual void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo);
+
+  inline virtual char *GetTitle(void) { return printoutTitle; }
+
+  inline wxDC *GetDC(void) { return printoutDC; }
+  inline void SetDC(wxDC *dc) { printoutDC = dc; }
+  inline void SetPageSizePixels(int w, int  h) { pageWidthPixels = w; pageHeightPixels = h; }
+  inline void GetPageSizePixels(int *w, int  *h) { *w = pageWidthPixels; *h = pageHeightPixels; }
+  inline void SetPageSizeMM(int w, int  h) { pageWidthMM = w; pageHeightMM = h; }
+  inline void GetPageSizeMM(int *w, int  *h) { *w = pageWidthMM; *h = pageHeightMM; }
+
+  inline void SetPPIScreen(int x, int y) { PPIScreenX = x; PPIScreenY = y; }
+  inline void GetPPIScreen(int *x, int *y) { *x = PPIScreenX; *y = PPIScreenY; }
+  inline void SetPPIPrinter(int x, int y) { PPIPrinterX = x; PPIPrinterY = y; }
+  inline void GetPPIPrinter(int *x, int *y) { *x = PPIPrinterX; *y = PPIPrinterY; }
+
+  inline virtual Bool IsPreview(void) { return isPreview; }
+
+  inline virtual void SetIsPreview(Bool p) { isPreview = p; }
+};
+
+/*
+ * wxPreviewCanvas
+ * Canvas upon which a preview is drawn.
+ */
+ 
+class wxPreviewCanvas: public wxCanvas
+{
+ private:
+  wxPrintPreview *printPreview;
+  static wxBrush *previewBackgroundBrush;
+ public:
+  wxPreviewCanvas(wxPrintPreview *preview, wxWindow *parent, int x = -1, int y = -1, int w = -1, int h = -1,
+    long style = 0, char *name = "canvas");
+  ~wxPreviewCanvas(void);
+
+  void Paint(void);
+  void OnEvent(wxMouseEvent& event);
+  void OnChar(wxKeyEvent& event);
+};
+
+/*
+ * wxPreviewFrame
+ * Default frame for showing preview.
+ */
+
+class wxPreviewFrame: public wxFrame
+{
+ protected:
+  wxCanvas *previewCanvas;
+  wxPreviewControlBar *controlBar;
+  wxPrintPreview *printPreview;
+ public:
+  wxPreviewFrame(wxPrintPreview *preview, wxFrame *parent, char *title = "Print Preview",
+    int x = -1, int y = -1, int w = -1, int h = -1,
+    long style = wxDEFAULT_FRAME|wxSDI, char *name = "frame");
+  ~wxPreviewFrame(void);
+
+  Bool OnClose(void);
+  virtual void Initialize(void);
+  virtual void CreateCanvas(void);
+  virtual void CreateControlBar(void);
+};
+
+/*
+ * wxPreviewControlBar
+ * A panel with buttons for controlling a print preview.
+ * The programmer may wish to use other means for controlling
+ * the print preview.
+ */
+
+#define wxPREVIEW_PRINT        1
+#define wxPREVIEW_PREVIOUS     2
+#define wxPREVIEW_NEXT         4
+#define wxPREVIEW_ZOOM         8
+
+#define wxPREVIEW_DEFAULT      wxPREVIEW_PREVIOUS|wxPREVIEW_NEXT|wxPREVIEW_ZOOM
+
+class wxPreviewControlBar: public wxPanel
+{
+ protected:
+  wxPrintPreview *printPreview;
+  wxButton *closeButton;
+  wxButton *nextPageButton;
+  wxButton *previousPageButton;
+  wxButton *printButton;
+  wxChoice *zoomControl;
+  static wxFont *buttonFont;
+  long buttonFlags;
+ public:
+  wxPreviewControlBar(wxPrintPreview *preview, long buttons,
+    wxWindow *parent, int x = -1, int y = -1, int w = -1, int h = -1,
+    long style = 0, char *name = "panel");
+  ~wxPreviewControlBar(void);
+
+  virtual void CreateButtons(void);
+  virtual void SetZoomControl(int zoom);
+  virtual int GetZoomControl(void);
+  inline virtual wxPrintPreview *GetPrintPreview(void) { return printPreview; }
+  void Paint(void);
+};
+
+/*
+ * wxPrintPreview
+ * Programmer creates an object of this class to preview a wxPrintout.
+ */
+ 
+class wxPrintPreview: public wxObject
+{
+ private:
+  wxPrintData printData;
+  wxCanvas *previewCanvas;
+  wxFrame *previewFrame;
+  wxBitmap *previewBitmap;
+  wxPrintout *previewPrintout;
+  wxPrintout *printPrintout;
+  int currentPage;
+  int currentZoom;
+  float previewScale;
+  int topMargin;
+  int leftMargin;
+  int pageWidth;
+  int pageHeight;
+  int minPage;
+  int maxPage;
+ public:
+  wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting = NULL, wxPrintData *data = NULL);
+  ~wxPrintPreview(void);
+
+  virtual Bool SetCurrentPage(int pageNum);
+  virtual inline int GetCurrentPage(void) { return currentPage; };
+
+  virtual void SetPrintout(wxPrintout *printout);
+  virtual inline wxPrintout *GetPrintout(void) { return previewPrintout; };
+  virtual inline wxPrintout *GetPrintoutForPrinting(void) { return printPrintout; };
+
+  virtual void SetFrame(wxFrame *frame);
+  virtual void SetCanvas(wxCanvas *canvas);
+
+  inline virtual wxFrame *GetFrame(void) { return previewFrame; }
+  inline virtual wxCanvas *GetCanvas(void) { return previewCanvas; }
+
+  // The preview canvas should call this from Paint
+  virtual Bool PaintPage(wxCanvas *canvas);
+
+  // This draws a blank page onto the preview canvas
+  virtual Bool DrawBlankPage(wxCanvas *canvas);
+
+  // This is called by wxPrintPreview to render a page into
+  // a wxMemoryDC.
+  virtual Bool RenderPage(int pageNum);
+
+  virtual wxPrintData &GetPrintData(void);
+  virtual void SetZoom(int percent);
+  virtual int GetZoom(void);
+
+  // If we own a wxPrintout that can be used for printing, this
+  // will invoke the actual printing procedure. Called
+  // by the wxPreviewControlBar.
+  virtual Bool Print(Bool interactive);
+
+  virtual int GetMaxPage(void) { return maxPage; }
+  virtual int GetMinPage(void) { return minPage; }
+
+ protected:
+ 
+  // Calculate scaling that needs to be done to get roughly
+  // the right scaling for the screen pretending to be
+  // the currently selected printer.
+  virtual void DetermineScaling(void);
+};
+
+#endif // IN_CPROTO
+#endif // wx_printh
diff --git a/src/wxmac/include/mac/wx_privt.h b/src/wxmac/include/mac/wx_privt.h
new file mode 100644
index 0000000..33ab2a7
--- /dev/null
+++ b/src/wxmac/include/mac/wx_privt.h
@@ -0,0 +1,48 @@
+/*
+ * File:	wx_privt.h
+ * Purpose:	Private class declarations.
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_privt.h	1.2 5/9/94" */
+
+#ifndef wx_privth
+#define wx_privth
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifdef wx_motif
+#include <Xm/Xm.h>
+#include "wx_hash.h"
+extern wxHashTable *wxWidgetHashTable;
+
+void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args);
+// void wxWidgetRepaintProc(Widget w, XtPointer clientData, XtPointer);
+#endif
+
+#ifdef wx_xview
+#include <xview/server.h>
+extern Xv_Server xview_server;
+#endif
+
+#define	wxNO_COLORS   0x00
+#define wxBACK_COLORS 0x01
+#define wxFORE_COLORS 0x02
+
+#ifdef wx_motif
+extern XColor itemColors[5] ;
+
+#define wxBACK_INDEX 0
+#define wxFORE_INDEX 1
+#define wxSELE_INDEX 2
+#define wxTOPS_INDEX 3
+#define wxBOTS_INDEX 4
+#endif
+
+#endif // wx_privth
+
diff --git a/src/wxmac/include/mac/wx_rbox.h b/src/wxmac/include/mac/wx_rbox.h
new file mode 100644
index 0000000..feaa8ed
--- /dev/null
+++ b/src/wxmac/include/mac/wx_rbox.h
@@ -0,0 +1,103 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_rbox.h
+// Purpose:	Declares radio box item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_rboxh
+#define wx_rboxh
+
+#include "wb_rbox.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxRadioBox;
+#else
+
+class wxBitmap;
+class wxPanel;
+class wxMessage;
+class wxList;
+
+class wxRadioBox: public wxbRadioBox
+{
+ public:
+	wxPanel*	cRadioPanel;
+	wxMessage*	cRadioTitle;
+	wxList		cRadioButtons; // list of wxRadioButton items
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxRadioBox // Constructor (given parentPanel, label choices)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		Title,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		int			N = 0,
+		char**		Choices = NULL,
+		int			majorDim = 0,
+		long		style = 0,
+		char*		windowName = "radioBox",
+		WXTYPE		objectType = wxTYPE_RADIO_BOX
+	);
+
+	wxRadioBox // Constructor (given parentPanel, bitmap choices)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		Title,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		int			N = 0,
+		wxBitmap**	Choices = NULL,
+		int			majorDim = 0,
+		long		style = 0,
+		char*		windowName = "radioBox",
+		WXTYPE		objectType = wxTYPE_RADIO_BOX
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+  ~wxRadioBox(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+  int FindString(char* s);
+  void SetSelection(int N);
+  int GetSelection(void);
+  char* GetString(int N);
+  void Enable(Bool enable);
+  void Enable(int item, Bool enable);
+  void DoShow(Bool show);
+  void Show(int item, Bool show);
+  char* GetLabel(void);
+  void SetLabel(char* label);
+  void SetLabel(int item, char* label);
+  void SetLabel(int item, wxBitmap* bitmap);
+  char* GetLabel(int item);
+
+  void ChangeColour(void);
+  void ChangeToGray(Bool gray);
+
+  void Command(wxCommandEvent& event); // mac platform only
+};
+
+#endif // IN_CPROTO
+#endif // wx_rboxh
diff --git a/src/wxmac/include/mac/wx_rbut.h b/src/wxmac/include/mac/wx_rbut.h
new file mode 100644
index 0000000..b492ace
--- /dev/null
+++ b/src/wxmac/include/mac/wx_rbut.h
@@ -0,0 +1,111 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_rbut.h
+// Purpose:	Declares wxRadioButton panel item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_rbuth
+#define wx_rbuth
+
+#include "wx_panel.h"
+#include "wx_item.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxRadioButton ;
+#else
+
+class wxBitmap;
+
+class wxRadioButton: public wxItem
+{
+ public:
+	wxBitmap* buttonBitmap ;
+    int bitmapState;
+	ControlHandle cMacControl; // mac control for radioButton
+	char *labelString;
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxRadioButton // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "radioButton",
+		WXTYPE		objectType = wxTYPE_ITEM // WCH: must use wxTYPE_RADIO_BUTTON
+	);
+
+	void Create // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "radioButton",
+		WXTYPE		objectType = wxTYPE_ITEM // WCH: must use wxTYPE_RADIO_BUTTON
+	);
+
+	wxRadioButton // Constructor (given parentPanel, bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "radioButton",
+		WXTYPE		objectType = wxTYPE_ITEM // WCH: must use wxTYPE_RADIO_BUTTON
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxRadioButton(void);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	virtual void SetValue(Bool);
+	virtual Bool GetValue(void);
+	void SetLabel(char*);
+	void SetLabel(wxBitmap* bitmap);
+	char* GetLabel(void) ;
+
+	void ChangeColour(void) ;
+
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY); // mac platform only
+	virtual void ChangeToGray(Bool enable);
+	virtual void Paint(void);
+	virtual void DoShow(Bool show);
+
+	virtual void ShowAsActive(Bool flag);
+	virtual void OnEvent(wxMouseEvent& event); // mac platform only
+	virtual void Command(wxCommandEvent& event); // mac platform only (also xview platform)
+	virtual void ProcessCommand(wxCommandEvent& event);
+
+	virtual void Highlight(Bool flag);
+};
+
+#endif // IN_CPROTO
+#endif // wx_rbuth
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wx_sbar.h b/src/wxmac/include/mac/wx_sbar.h
new file mode 100644
index 0000000..01038b3
--- /dev/null
+++ b/src/wxmac/include/mac/wx_sbar.h
@@ -0,0 +1,108 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_sbar.h
+// Purpose:	Declares wxScrollBar item (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_sbarh
+#define wx_sbarh
+
+#include "wx_win.h"
+#include <Controls.h>
+
+#ifdef IN_CPROTO
+typedef       void* wxScrollBar ;
+#else
+
+class wxScrollBar: public wxWindow
+{
+ public:
+	ControlHandle cMacControl; // mac control for scrollbar
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxScrollBar // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "scrollbar",
+		WXTYPE		objectType = wxTYPE_SLIDER
+	);
+
+	wxScrollBar // Constructor (given parentWindow)
+	(
+		wxWindow*	parentWindow,
+		wxFunction	function,
+		char*		label,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "scrollbar",
+		WXTYPE		objectType = wxTYPE_SLIDER
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxScrollBar(void);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void CreateWxScrollBar(wxFunction function, char* label); // common constructor initialization
+	void InitDefaults(wxFunction function);
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	virtual void SetValue(int val);
+	virtual int GetValue(void);
+	virtual void SetMaxValue(int maxValue);
+	virtual int GetMaxValue(void);
+	void SetLabel(char*);
+	char* GetLabel(void) ;
+
+	void ChangeColour(void) ;
+
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY); // mac platform only
+	virtual void Enable(Bool enable);
+	virtual void Paint(void);
+	virtual void DoShow(Bool show);
+
+	virtual void ShowAsActive(Bool flag);
+	virtual void OnEvent(wxMouseEvent& event); // mac platform only
+	virtual void TrackAction(short part); // mac platform only
+
+	virtual void SetScrollData // adjust scrollBar to match scroll data setting
+	(
+		wxScrollData*		scrollData,
+		wxWhatScrollData	whatScrollData,
+		wxWindow*			iniatorWindow
+	);
+};
+
+const int kVScrollBarWidth = 16;
+const int kHScrollBarHeight = 16;
+
+#endif // IN_CPROTO
+#endif // wx_sbarh
\ No newline at end of file
diff --git a/src/wxmac/include/mac/wx_screen.h b/src/wxmac/include/mac/wx_screen.h
new file mode 100644
index 0000000..6fcc15d
--- /dev/null
+++ b/src/wxmac/include/mac/wx_screen.h
@@ -0,0 +1,61 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_screen.h
+// Purpose:	Declares wxScreen (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_screenh
+#define wx_screenh
+
+#include "wx_win.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxScreen ;
+#else
+class wxScreen: public wxWindow
+{
+ protected:
+
+  // For window area
+  	wxArea* cScreenArea; // mac platform only
+  	wxArea* cMenuArea; // mac platform only
+
+ public:
+	static wxScreen* gScreenWindow;
+
+	wxScreen // Constructor (for screen window)
+	(
+		char*		windowName = "Screen",
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		WXTYPE		objectType = wxTYPE_SCREEN_WINDOW
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxScreen(void);
+
+//=============================================================================
+// Window area methods
+//=============================================================================
+	wxArea* ScreenArea(void); // mac platform only
+	wxArea* MenuArea(void); // mac platform only
+
+//=============================================================================
+// Window coordinate system transformation methods
+//=============================================================================
+	virtual void DoSetSize(int x, int y, int width, int height);
+	virtual void Show(Bool show);
+};
+
+#endif // IN_CPROTO
+#endif // wx_screenh
diff --git a/src/wxmac/include/mac/wx_slidr.h b/src/wxmac/include/mac/wx_slidr.h
new file mode 100644
index 0000000..97dd512
--- /dev/null
+++ b/src/wxmac/include/mac/wx_slidr.h
@@ -0,0 +1,66 @@
+/*
+ * File:	wx_slidr.h
+ * Purpose:	Slider
+ * Author:	Julian Smart (Cecil Coupe)
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_slidr.h	1.2 5/9/94" */
+
+#ifndef wx_slidrh
+#define wx_slidrh
+
+#include "wb_slidr.h"
+#include "wxLabelArea.h"
+#ifdef IN_CPROTO
+typedef       void    *wxSlider ;
+#else
+
+// Slider
+class wxSlider: public wxbSlider
+{
+public:
+  int s_min;
+  int s_max;
+  int page_size;
+  wxLabelArea*	cTitle;
+  ControlHandle	cMacControl;
+  Rect		valueRect;
+  wxFont*	valueFont;
+  int		valuebase;
+
+  wxSlider(wxPanel *panel, wxFunction func, char *label, int value,
+           int min_value, int max_value, int width, int x = -1, int y = -1,
+           long style = 0, char *name = "slider",
+           WXTYPE objectType = wxTYPE_SLIDER);
+  ~wxSlider(void);
+
+  Bool Create(wxPanel *panel, wxFunction func, char *label, int value,
+           int min_value, int max_value, int width, int x = -1, int y = -1,
+           long style = 0, char *name = "slider");
+  virtual int GetValue(void);
+  virtual char *GetLabel(void);
+  virtual void SetValue(int);
+  virtual void SetLabel(char *label);
+#if 0 // CJC
+  void GetSize(int *x, int *y);
+  void SetSize(int x, int y, int width, int height);
+  void GetPosition(int *x, int *y);
+#endif
+  void SetBackgroundColour(wxColour*col) ;
+  void SetLabelColour(wxColour*col) ;
+  void SetButtonColour(wxColour*col) ;
+  // For the mac:
+  virtual void Paint(void);
+  virtual void OnEvent(wxMouseEvent& event);
+  virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+  
+  virtual void DoShow(Bool s);
+  
+  virtual void ChangeToGray(Bool gray);
+};
+
+#endif // IN_CPROTO
+#endif // wx_slidrh
diff --git a/src/wxmac/include/mac/wx_text.h b/src/wxmac/include/mac/wx_text.h
new file mode 100644
index 0000000..91e104b
--- /dev/null
+++ b/src/wxmac/include/mac/wx_text.h
@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_text.h
+// Purpose:	wxTextWindow - simple text subwindow class (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_texth
+#define wx_texth
+
+#include "wb_text.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxTextWindow ;
+#else
+
+class wxFrame;
+class wxMultiText;
+
+class wxTextWindow: public wxbTextWindow
+{
+ public:
+	wxMultiText* cTextBox; // mac platform only
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+
+	wxTextWindow // Constructor (given parentArea)
+	(
+		wxArea*	parentArea,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "textWindow",
+		WXTYPE		objectType = wxTYPE_TEXT_WINDOW
+	);
+
+	wxTextWindow // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "textWindow",
+		WXTYPE		objectType = wxTYPE_TEXT_WINDOW
+	);
+
+	wxTextWindow // Constructor (given parentFrame)
+	(
+		wxPanel*	parentFrame,
+		int 		x = -1,
+		int			y = -1,
+		int			width = -1,
+		int			height = -1,
+		long		style = 0,
+		char*		windowName = "textWindow",
+		WXTYPE		objectType = wxTYPE_TEXT_WINDOW
+	);
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxTextWindow(void);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void CreateWxTextWindow(void); // common constructor initialization
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+//=============================================================================
+// Window coordinate system transformation methods
+//=============================================================================
+	Bool LoadFile(char* file);
+	Bool SaveFile(char* file);
+	void WriteText(char* text);
+	void Clear(void);
+	void DiscardEdits(void);
+	Bool Modified(void);
+	char* GetContents(void);
+	void SetInsertionPoint(long pos);
+	void SetInsertionPointEnd(void);
+	long GetInsertionPoint(void);
+	long GetLastPosition(void);
+	long XYToPosition(long x, long y);
+	void PositionToXY(long pos, long* x, long* y);	
+	int GetNumberOfLines(void);
+	void ShowPosition(long pos);
+	int GetLineLength(long lineNo);
+	int GetLineText(long lineNo, char* buf);
+	void Replace(long from, long to, char* value);
+	void Remove(long from, long to);
+  	virtual void SetSelection(long from, long to);
+ 	virtual void Copy(void); // Copy selection to clipboard
+  	virtual void Paste(void); // Paste clipboard into text window
+ 	virtual void Cut(void); // Copy selection to clipboard, then remove selection.
+	void SetEditable(Bool editable);
+  	virtual void SetFont(wxFont *theFont);
+	// Functions not in wxbTextWindow
+	virtual void Paint(void);
+	virtual void DoShow(Bool show);
+	void Enable(Bool Flag);
+	virtual void SetFocus(void);
+	void Highlight(long from, long to);
+};
+
+#endif // IN_CPROTO
+#endif // wx_texth
diff --git a/src/wxmac/include/mac/wx_timer.h b/src/wxmac/include/mac/wx_timer.h
new file mode 100644
index 0000000..d2113c1
--- /dev/null
+++ b/src/wxmac/include/mac/wx_timer.h
@@ -0,0 +1,47 @@
+/*
+ * File:	wx_timer.h
+ * Purpose:	wxTimer - provides simple timer functionality (dummy version)
+ * Author:	Julian Smart/Cecil Coupe
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* sccsid[] = "@(#)wx_timer.h	1.2 5/9/94" */
+
+#ifndef wx_timerh
+#define wx_timerh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wb_timer.h"
+#include "time.h"
+#include <types.h>
+#ifdef IN_CPROTO
+typedef       void    *wxTimer ;
+#else
+
+class wxTimer: public wxbTimer
+{
+ public:
+#if 0
+ UInt32		fireTime;		// the future Tick when the timer fires
+#else
+ void *context;
+ unsigned long expiration;
+ int one_shot;
+ int interval;
+ wxTimer *prev, *next;
+#endif
+  wxTimer(void);
+  ~wxTimer(void);
+  Bool Start(int milliseconds = -1,Bool one_shot = FALSE ); // Start timer
+  void Stop(void);                   // Stop timer
+  void Dequeue();
+};
+
+#endif // IN_CPROTO
+#endif // wx_timerh
diff --git a/src/wxmac/include/mac/wx_txt.h b/src/wxmac/include/mac/wx_txt.h
new file mode 100644
index 0000000..25046cc
--- /dev/null
+++ b/src/wxmac/include/mac/wx_txt.h
@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_txt.h
+// Purpose:	wxText - simple text subwindow class (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_txth
+#define wx_txth
+
+#include "wb_txt.h"
+
+#ifdef IN_CPROTO
+typedef       void* wxText;
+#else
+
+class wxFrame;
+class wxTextWindow;
+class wxLabelArea;
+
+// Single-line text item
+class wxText: public wxbText
+{
+protected:
+	TEHandle cMacTE; // mac platform only
+	Bool cTextEditable; // mac platform only
+	Bool cTextModified; // mac platform only
+	wxLabelArea* cLabelArea; // mac platform only
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+public:
+	wxText(void);
+	wxText // Constructor (given parentTextWindow)
+	(
+		wxTextWindow*	parentTextWindow,
+		wxFunction		function,
+		char*			label,
+		char*			value = "",
+		int 			x = -1,
+		int				y = -1,
+		int				width = -1,
+		int				height = -1,
+		long			style = 0,
+		char*			windowName = "text",
+		WXTYPE			objectType = wxTYPE_TEXT
+	);
+
+	wxText // Constructor (given parentPanel)
+	(
+		wxPanel*		parentPanel,
+		wxFunction		function,
+		char*			label,
+		char*			value = "",
+		int 			x = -1,
+		int				y = -1,
+		int				width = -1,
+		int				height = -1,
+		long			style = 0,
+		char*			windowName = "text",
+		WXTYPE			objectType = wxTYPE_TEXT
+	);
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+public:
+
+	~wxText(void);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void CreateWxText(char* label, char* value); // common constructor initialization
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+//=============================================================================
+// Window coordinate system transformation methods
+//=============================================================================
+	void WriteText(char* text);
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY);
+	void Clear(void);
+	void DiscardEdits(void);
+	Bool Modified(void);
+	void SetModified(Bool modified); // mac platform only
+	char* GetContents(void);
+	void SetInsertionPoint(long pos);
+	void SetInsertionPointEnd(void);
+	long GetInsertionPoint(void);
+	long GetLastPosition(void);
+	long XYToPosition(long x, long y);
+	void PositionToXY(long* x, long* y);
+	void ShowPosition(long pos);
+	int GetLineLength(long lineNo);
+	int GetLineText(long lineNo, char* buf);
+	int GetNumberOfLines(void);
+	void Replace(long from, long to, char* value);
+	void Remove(long from, long to);
+	void Highlight(long from, long to);
+	void SetEditable(Bool editable);
+	void Paint(void);
+	void DoShow(Bool show);
+	void DoPeriodicAction(void); // mac platform only
+	void OnChar(wxKeyEvent& event); // mac platform only
+	void OnEvent(wxMouseEvent& event); // WCH : mac only ?
+
+	void ChangeToGray(Bool gray);
+
+	void SetTextInfo(void); // mac platform only
+  	virtual void SetFont(wxFont* theFont);
+
+	void SetLabel(char*);
+	char* GetLabel(void) ;
+	char* GetValue(void);
+	void SetValue(char* value);
+	void ChangeColour(void);
+	virtual void Copy(void);
+	virtual void Cut(void);
+	virtual void Paste(void);
+
+	virtual Bool WantsFocus(void);
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Activate methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void OnSetFocus(); // mac platform only
+	void OnKillFocus();
+
+//=============================================================================
+// Protected methods
+//=============================================================================
+protected:
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Scroll methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void macAdjustScrollBars(void); // mac platform only
+	virtual void SetScrollData // adjust text within window to match scroll bar setting
+	(
+		wxScrollData*		newScrollData,
+		wxWhatScrollData	whatScrollData,
+		wxWindow*			iniatorWindow
+	);
+
+};
+
+#endif // IN_CPROTO
+#endif // wx_txth
diff --git a/src/wxmac/include/mac/wx_win.h b/src/wxmac/include/mac/wx_win.h
new file mode 100644
index 0000000..dd01d53
--- /dev/null
+++ b/src/wxmac/include/mac/wx_win.h
@@ -0,0 +1,337 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_win.h
+// Purpose:	wxWindow class declaration (Macintosh version).
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef wx_winh
+#define wx_winh
+
+
+#include "wb_win.h"
+//#include "wx_screen.h"
+#include "wxDirection.h"
+#include "wxScrollData.h"
+#	include <Menus.h>
+#	include <QuickDraw.h>
+#	include <Fonts.h>
+#	include <Events.h>
+#	include <Dialogs.h>
+#	include <TextEdit.h>
+#	include	<Scrap.h>
+#	include	<ToolUtils.h>
+/*
+ * Base class for frame, panel, canvas, panel items, dialog box.
+ * and screen (for the mac)
+ */
+
+#ifdef IN_CPROTO
+typedef       void* wxWindow ;
+#else
+
+class wxMacDC;
+class wxFrame;
+class wxBrush;
+class wxArea;
+class wxMargin;
+class wxPanel;
+class wxScroll;
+class wxScreen;
+
+
+class wxWindow: public wxbWindow
+{
+//=============================================================================
+// Public variables
+//=============================================================================
+public:
+
+	static wxWindow* gMouseWindow; // mac platform only (window that has captured mouse)
+
+//=============================================================================
+// Protected variables
+//=============================================================================
+protected:
+
+	Bool 		cColour; 		// use colour for this window?
+	Bool		cActive;		// active window is "highlighted" (mac platform only)
+	Bool		cEnable;		// enabled window accepts mouse/keyboard events
+	Bool		cHidden;		// Hidden?
+	Bool		cUserHidden;	// Hidden because user asked (not just inherited)?
+	long		cStyle;			// mac platform only
+	Direction	cGravitate;		// mac platform only
+	Direction	cJustify;		// mac platform only
+	wxWindow* 	window_parent; 	// Each window always knows its parent
+	wxChildList* children; 		// Window's children
+	wxScroll* 	cScroll; 		// for scroll data and scroll synchronization
+	wxMacDC*	cMacDC;			// mac platform only
+	wxBrush* 	cBrush; 		// foreground brush
+	wxBrush* 	cEraser; 		// background brush
+	Pattern 	cMacPattern; 	// mac platform only (temp work pattern)
+
+  // For window rectangle
+ 	int 		cWindowX;
+ 	int 		cWindowY;
+ 	int 		cWindowHeight;
+ 	int 		cWindowWidth;
+ 	
+ 	int			internal_gray;
+
+  // For window area
+  	wxArea* 	cParentArea; 	// mac platform only
+  	wxList 		cAreas; 		// mac platform only
+  	wxArea* 	cClientArea; 	// mac platform only
+
+//=============================================================================
+// Public methods
+//=============================================================================
+public:
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxWindow(void);
+
+	wxWindow // Constructor (for screen window)
+	(
+		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	);
+
+	wxWindow // Constructor (given parentScreen; i.e., this is frame)
+	(
+		char*		windowName,
+		wxScreen*	parentScreen,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	);
+
+	wxWindow // Constructor (given parentArea)
+	(
+		char*		windowName,
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	);
+
+	wxWindow // Constructor (given parentWindow)
+	(
+		char*		windowName,
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	);
+
+	wxWindow // Constructor (given objectType; i.e., menu or menuBar)
+	(
+		char*		windowName
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	~wxWindow(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	int Width(void); // mac platform only
+	int Height(void); // mac platform only
+	wxMargin Margin(wxArea* outerArea); // mac platform only
+	wxMargin Margin(wxWindow* outerWindow); // mac platform only
+	virtual void GetPosition(int* windowX, int* windowY);
+	virtual void GetSize(int* width, int* height);
+	virtual void GetClientSize(int* width, int* height); // Size client can use
+	virtual void ClientToScreen(int* x, int* y);
+	virtual void ScreenToClient(int* x, int* y);
+	virtual void ClientToLogical(int* x, int* y); // mac platform only; testing
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void SetWidthHeight(int width, int height); // mac platform only
+	virtual void SetSize(int x, int y, int width, int height, int flags = wxSIZE_AUTO); // mac platform only
+	virtual void DoSetSize(int x, int y, int width, int height); // mac platform only
+	virtual void SetClientSize(int newClientWidth, int newClientHeight);
+	void GravitateJustify(Direction gravitate, Direction justify,
+				int left, int top, int right, int bottom); // mac platform only
+	virtual void Fit(void);  // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Device context methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxMacDC* MacDC(void); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree (windows and areas) methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	wxArea* ParentArea(void); //mac platform only
+	wxList* Areas(void); //mac platform only
+	virtual wxArea* ClientArea(void); // mac platform only
+	virtual wxWindow* GetParent(void);
+	virtual wxChildList* GetChildren(void);
+	virtual wxWindow* GetGrandParent(void);
+	virtual wxFrame* GetRootFrame(void); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Scroll methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void AddChildScrollWindow(wxWindow* childScrollWindow); // mac platform only
+	wxScroll* GetScroll(void); // mac platform only
+	virtual void SetScrollData // Must override if window scrolls
+	(
+		wxScrollData*		scrollData,
+		wxWhatScrollData	whatScrollData,
+		wxWindow*			iniatorWindow
+	);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Mouse methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void CaptureMouse(void);
+	void ReleaseMouse(void);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Keyboard methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void SetFocus(void);
+	virtual void OnSetFocus(void);
+	virtual void OnKillFocus(void);
+	virtual Bool WantsFocus(void); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Quill methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  	virtual void SetFont(wxFont* theFont); // mac platform only
+	float GetCharHeight(void);
+	float GetCharWidth(void);
+	void GetTextExtent(const char* string, float* x, float* y, float* descent = NULL,
+  						float* externalLeading = NULL, wxFont *thefont = NULL,
+  						Bool use16 = FALSE);
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	Bool PopupMenu(wxMenu* menu, float x, float y);
+	wxCursor* SetCursor(wxCursor* cursor);
+	void SetColourMap(wxColourMap* cmap);
+	virtual Bool IsMacWindow(void); // mac platform only
+	virtual void DoPeriodicAction(void); // mac platform only
+//+++++ Begin Macintosh Platform only +++++
+	virtual void Enable(Bool Flag);
+	Bool IsEnable(void);
+	Bool CanAcceptEvent(void);
+	Direction GetGravitate(void);
+	void SetGravitate(Direction direction);
+	Direction GetJustify(void);
+	void SetJustify(Direction direction);
+	virtual void DragAcceptFiles(Bool accept);
+	void SetEraser(wxBrush* eraser);
+	inline wxBrush *GetEraser() { return cEraser; }
+ 	virtual void DestroyFocus(); // tom (fettig@dfki.uni-sb.de)
+//+++++ End Macintosh Platform only +++++
+
+	virtual void AddWhiteRgn(RgnHandle rgn);
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void OnWindowDSize(int dW, int dH, int dX = 0, int dY = 0);  // mac platform only
+	virtual void OnAreaDSize(int dW, int dH, int dX = 0, int dY = 0);  // mac platform only
+	virtual void OnClientAreaDSize(int dW, int dH, int dX, int dY);  // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Device context methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	void SetCurrentMacDCNoMargin(void); // mac platform only
+	virtual void SetCurrentMacDC(void); // mac platform only
+	virtual void SetCurrentDC(void); // mac platform only
+	virtual void MacSetBackground(void); // mac platform only
+	virtual void SetForeground(void); // mac platform only
+	virtual void SetTextInfo(void); // mac platform only
+	virtual void GetClipRect(wxArea* area, Rect* clipRect); // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree (windows and areas) methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void AddChild(wxObject* child); // Adds reference to the child object
+	virtual void OnDeleteChildWindow(wxWindow* childWindow); // mac platform only
+	virtual void OnDeleteChildArea(wxArea* childArea); // mac platform only
+	virtual void DestroyChildren(void); // Removes and destroys all children
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Activate methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void Activate(Bool flag);	 // mac platform only
+	virtual void ShowAsActive(Bool flag); // mac platform only
+	virtual void OnActivate(Bool flag);  // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Mouse methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual Bool SeekMouseEventArea(wxMouseEvent& mouseEvent); // mac platform only
+	virtual Bool AdjustCursor(int mouseX, int mouseY); // mac platform only - GRW
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	virtual void Paint(void);
+	void Refresh(void);
+	
+	virtual Bool PreOnEvent(wxWindow *win, wxMouseEvent *event);
+	virtual Bool PreOnChar(wxWindow *win, wxKeyEvent *event);
+
+	virtual void Show(Bool);
+
+	virtual void DoShow(Bool);
+	Bool CanShow(Bool);
+	
+	inline Bool IsHidden(void) { return cHidden; }
+	inline Bool IsUserHidden(void) { return cUserHidden; }
+	
+	virtual Bool IsShown(void) { return !IsUserHidden(); }
+	
+	virtual void ChangeToGray(Bool gray);
+	
+	void InternalGray(Bool gray);
+	Bool IsGray(void);
+	void ChildrenInternalGray(Bool gray);
+	
+	virtual void Highlight(Bool flag);
+	int Track(Point start);
+
+	void ForEach(void (*foreach)(wxWindow *w, void *data), void *data);
+
+//=============================================================================
+// Private methods
+//=============================================================================
+private:
+
+	void InitDefaults(void); // used by constructors
+	void InitWindowPostion(int x, int y); // used by constructors
+
+//=============================================================================
+// Friend classes
+//=============================================================================
+private:
+
+	friend class wxArea;
+};
+
+#endif // IN_CPROTO
+#endif
diff --git a/src/wxmac/include/mac/wximgfil.h b/src/wxmac/include/mac/wximgfil.h
new file mode 100644
index 0000000..2a115ba
--- /dev/null
+++ b/src/wxmac/include/mac/wximgfil.h
@@ -0,0 +1,171 @@
+/*
+ * File:	imagif.h
+ * Purpose:	Declaration of the Platform Independent GIF Image Class
+ * Author:	Alejandro Aguilar Sierra
+ * Created:	1995
+ * Copyright:	(c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
+ */
+#if !defined(__wximgfil_h)
+#define __wximgfil_h
+#include "wx_gdi.h"
+#include <stdio.h>
+
+
+/* Various error codes used by decoder
+ */
+#define OUT_OF_MEMORY -10
+#define BAD_CODE_SIZE -20
+#define READ_ERROR -1
+#define WRITE_ERROR -2
+#define OPEN_ERROR -3
+#define CREATE_ERROR -4
+
+#define MAX_CODES   4095
+
+#ifndef uchar
+typedef unsigned char uchar;
+#endif
+
+#ifndef ushort
+typedef unsigned short ushort;
+#endif
+
+#ifndef ulong
+typedef unsigned long ulong;
+#endif
+
+#ifndef NULL
+#define NULL 0L
+#endif
+
+typedef unsigned char byte;
+    
+#ifndef HUGE
+#ifdef wx_msw
+#define HUGE huge
+#else
+#define HUGE
+#endif
+#endif
+
+
+#ifndef BOOL
+typedef int BOOL;
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+//#define GIFBUFTAM 16384
+#define GIFBUFTAM 4096
+
+struct rgb { byte  r,g,b; };
+struct rgbq { byte  r,g,b,rv; };
+
+class wxGIF {
+private:
+  void InitInterlaceRow(int);
+public:
+  wxGIF();
+  wxGIF(char * path);
+  ~wxGIF();
+  
+  void Create(ushort width, ushort height, ushort deep);
+
+  FILE *fp;
+  BOOL flag_subir;
+  ushort ibf;
+  uchar buf[GIFBUFTAM];
+  ushort bad_code_count;
+
+  char HUGE* lpbi;  		//  Image data from msw
+  Ptr GetRawImage();
+  char HUGE* RawImage;  		//  Image data
+  ushort ItCount;
+  char HUGE* IterImage;  		//  Image data
+  ushort Deep;	 				// (bits x pixel)
+  ushort Width, Height;    //  Dimensions
+  long EfeWidth;	 // Efective Width
+  wxColourMap* ColourMap;
+// to be moved to wx_gdi.h later
+  ushort numcmapentries;
+  unsigned short red[256];
+  unsigned short green[256];
+  unsigned short blue[256];
+  
+  void Set_VDir(BOOL dir) { flag_subir = dir; }
+  BOOL ReadHeader(FILE *);
+  BOOL Extrae_imagen();
+  wxColourMap *getColorMap();
+
+  ushort GetWidth( void ) { return Width; };
+  ushort GetHeight( void ) { return Height; };
+  ushort GetDeep( void ) { return Deep; };
+// ColorMap settings
+  BOOL SetColourMap(wxColourMap* colourmap);
+  BOOL SetColourMap(ushort n, byte *r, byte *g, byte *b);
+  BOOL SetColourMap(ushort n, ushort array_width, byte **array);
+  wxColourMap* GetColourMap() { return ColourMap; }
+
+
+// Iterators
+  Bool ItOK () { return (0 <= ItCount && ItCount < Height); }
+  void reset ();
+  void upset ();
+  Bool ItNext ();
+  Bool ItPrev ();
+  void SetRow(ushort n, byte *buf);
+  void GetRow(ushort n, byte *buf);
+
+protected:
+  ushort get_byte();
+  ushort  out_line(uchar *pixels, ushort linelen);
+
+ushort curr_size;                     /* The current code size */
+ushort clear;                         /* Value for a clear code */
+ushort ending;                        /* Value for a ending code */
+ushort newcodes;                      /* First available code */
+ushort top_slot;                      /* Highest code for current size */
+ushort slot;                          /* Last read code */
+
+/* The following static variables are used
+ * for seperating out codes
+ */
+ushort navail_bytes;              /* # bytes left in block */
+ushort nbits_left;                /* # bits left in current byte */
+uchar b1;                           /* Current byte */
+uchar byte_buff[257];               /* Current block */
+uchar *pbytes;                      /* Pointer to next byte in block */
+
+long code_mask[13];
+
+ uchar stack[MAX_CODES + 1];            /* Stack for storing pixels */
+ uchar suffix[MAX_CODES + 1];           /* Suffix table */
+ ushort prefix[MAX_CODES + 1];           /* Prefix linked list */
+
+ushort init_exp(ushort);
+ushort get_next_code();
+ushort decoder(ushort linewidth);
+};
+
+Bool wxLoadGifIntoBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+Bool wxLoadPICTIntoBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+Bool wxLoadXPMIntoBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+Bool wxLoadXBMIntoBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+Bool wxLoadBMPIntoBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+
+Bool wxSaveXBMFromBitmap(char *, wxBitmap *, wxColourMap ** = NULL);
+
+void *XpmMalloc(size_t size);
+void *XpmMallocA(size_t size);
+void *XpmRealloc(void *p, size_t size);
+void *XpmReallocA(void *p, size_t size);
+void XpmFree(void *);
+
+#endif
+
diff --git a/src/wxmac/main.¹.rsrc b/src/wxmac/main.¹.rsrc
new file mode 100644
index 0000000..9d6bc3e
--- /dev/null
+++ b/src/wxmac/main.¹.rsrc
@@ -0,0 +1,211 @@
+(This file must be converted with BinHex 4.0)
+:#feKD@iZZ5jbFh*M!(*cFQ058d9%!3#3"bT`YB-!N!3"!!!!+FJ!!#M)!!!!U-"
+E@"*+N!"R!1CD@e!"*5,-KKJXl#m,)&-J8#*S!!a1N3YYB@PZ,VNZFR0bB`)!!!"
+bFh*M8P0&4%!!N!PbFh*M8P0&4%!!N"HU-SU'!*!'+R!S'dT(J!%"IRB4rZJ43K#
+JN!"A+e!"%2*f%IhS,)B"#qTA,43[#b"6)&!LD!%!9#Tf)baf%IcF,&FVQ4+!!!!
+!!A!a9SB"+"jA,e!"%C*C@eJ#)"$NJ&B"F$*@9bpA)e!"%CTA,CN`!A!c9PFM9bp
+3!4'U9bp3!4eUIhi5!**1V4%[+J!!!!`!+!!S!2!"'!"N998!!!!Q!!%!N!@A!&X
+!U`#9"!*25`#3"3`!3`#!!1@)"9i`$9ia!!!!(CaJ$J!!3d4&4J40!*!'3IVrlNj
+a6R&J!!('6[S!(Nlk!#j1qJ!q6[S!9Nlk!)K1qJ#N6[S!`Nlk!0iJAc)B0"L`@&I
+*rrT+3QIq6[!Jr#"I-KJd',#B9mRrqNT#Crj1m#$k)&mb'$3BX%*Z#T!!3@d'd%"
+"m!!#-""RrNl`!!!J,`!%,d%!"#)[!!J[A`!%51Fm!#3!*J&)3X6$+!!U!8K&b-A
+84%K#3N,!`G##60m!2#)I6R8J,`!%,d%!"#)[!!J[A`!%51Fa!%kk!*a-h`#-)Kp
+1G5![!!3[33!%)Lm!##pI!!4)jc%!6VS!I#!"60m!M#)I6R8J,`!%,d%!"#)[!!J
+[A`!%51Fa!%kk!#a-h`#-)Kp1G5![!!3[33!%)Lm!##pI!!4)jc%!6VS!$#!"60m
+!M#)I6R9+J'SF5S&U$%5!4)&1ZJ!J4)&1G85!6VS!&N5!4)&1G8U"DJT%J8kk!!C
+%J%je,M`!!2rrXS"M"L)!F!"1GE#(BJb!`8K!-J"#3%K!6R@bKf)D,J"#3%K!J-&
+)3%K(2J")4il"-!G)4c)(6R8N!#B"iSMLLE+(B[L!`F#(-J2#`#i$5%I1`%K(dSG
+P#*+#BJ4%J8je8d"Jj!"3!!*K"!#3"#*I6R919[rZ3Ulrq%kkrq`LL#m-6VVrj#K
+4)'i!$U"T(8$rlb"Z!!kJ+5"Z!!iJ8%US!"aR+#"Z!!iJ8#"S!"bJD4e!rqiJEJ!
+1)&!JD!!FS#NJEJ!1)&!YD!!Frr!`,J!-$%!!#f)!!3a$qJ&!d%$5m3!!6Y%r,J!
+5,bi!$Nkk!84FMb"Z!!iJ8%US!"aR!!$N)'i!$L"3)'J!(+"T(8$rlL"Z!!iJ8#"
+S!"bJ+@!!!-3r,J!5,bi!$Nkk!R4FMf!!!,)JEJ!1)&"++!!3C`!!T#"Z!!iJ8#"
+S!!4++!"ZC`!!NMmZ!")[,J!16VS#U&b2B!!!J$mZ!")[,J!16VS*`&b2B'iJ,J!
+)FK$LS$e!rr3pEJ!+rrC#*bmZrr3JE[r`)&")D!!1U+e+(fB@3LF[,[rd)'lrm#"
+35'J!"ULY5KpR-(!",8$rq'!S)#i!#!L!!"m[!#"Z!!iJ8%KS!!LShf!3,bi!##"
+Z!!iJ8%KS!!LShb"Z!!iJ8%US!"aR%#"Z!!iJ8"!ZrqiJD!!FS'S3,[r[)'i!$U"
+U+&mYE[ri!"41AL"I6qm!$%l3raMr@[qJrXVr"[r)rmMrb2p+rmMrZ2qi6PB!!%M
+R!c!Z,J!)PFT`-U%L*%JJ#QF!!8SJ5U!TPmXJ8L#,2cbS#dkk'4`F!%S'9)pR!!%
+Z6VS8%#"5%8!!-#"53LJ!-3JZ!!)!$@G!3UFJ4b"32bJ!&+Qr*PmJ#fB83UFJ4b"
+32bJ!&%Kk!2kT-5CIB!JJ8K&m!!%!-8U6Cf)[#b"()&![+!!NU8eJ9%)RUCY#Tbm
+m689195"()&!r+!!8UD!QAamm!!'TQb!,CK"#Tb"()&!r+!!8U8NQAf!L5T0Q(Lm
+,UD0#Tb"()&!r+!!8UEmQAb!,C`JJ8K&m!!%!-8kk'#3J8M&!!#iJ8L#,)%FJ8#*
+5-fJ!&!!%)%FJ8#*5-fJ!%J!H)%FJ8#*5-fJ!&J!J)&)#D!$r!#!J4b"3-#J!&J*
+!r`!J8M&!!#)J4b"3)8S!(#"()&!aI!!"!"4#Cbm,U9!J4b"3-9m!&L"()&!aI!!
+"!")J4b"3F2mK3!!J60m-`%jH6R8!!%j@!!![#b"Z!!JJ8#CS!"`J#fG-##i!!J!
+0CaiJ8dU3!'F3)&0++!!aC`JJ8bm3UD0J(#"6,a#T-Q!8)&0+N!"R$L"65LJ!-@F
+')&-[%+QM)%ZJ+L",S#-JEJ!))&"#U!!F*Pp1ANje6PB!!%MR!c!Z,J!)F!kK)L4
+))!TRC%(k!'SX##"5))FJ8M&Z!!`!"#"()&!L8L0S!!J!"L0S!!`!#N+RU0JQAbm
+,)%FJ8%KS!!LShdkk&ZJ-3!F!E3`[#bm',`T#Tk[+B""#Tbm+,`B[#dkk&I*2l`!
+3,`ZSf5"+S#0-h`c!6Pj1G8j@rT4)jam`H!"k!(B!3Llqkd)ZrZSYE"f+rUSpE"f
+1rUiYE"f3!2kN2@`GP2kS,@i!#2k85UlqP'F!"NSJE[k8)&!Q8#"ZrT3J8$iS!!3
+J8b4S!"`J#QF!"L`J8NU3!'F!"L4)E[kFU(3-EJ!"!"*[%#"ZrTa++!!'D`BpI!!
+"!")J8`aS!#!!%Q`N)&0`(j!!D!!5-N!Y5Irb3LFJ8L"3)&")D!!+,`QSA8SICJ*
+k!5"6$#J!r`!4CJ4k!4J&$'i!!3!5Ec*f!4em!!(qkdKZrX*)E[l)6VS4d!aZrrr
+q`P#2CK3-E[rrrX4Q$!aZrrrqaQB%3Llqkcm(5'lrr%KZrri[,[kF6VS1iKe!r[%
+JE[kFFJ!5+!"'28(rqNKZrYLSQ#km!!%!!DLE5(S&G+LG)&0)D!!)U+-HV[la,`Y
+1ZJP%)&)ZN!#T5#"5)&!J8$PS!!)GPL"5##J!"3!L6qm!#QFb)&))+!!"!#*R'L"
+55'J!&NKi!!'SU#"58QJ!%#"5-@J!%!!-)&*`!p"S!"`a3!!8B$JJ8NTS!#4Q*L"
+52#J!&*aS!""`!p"X(CDm3'mF)&)`+!!3d'`GPPC!-8!!&'!+2`F[#dkk$'*FMd+
+RU0JYArkB,blqQ+Kk)&0)D!!)U(Y+!fG#3UHU-LeIrU"+"'Ff)&)-D!F!!#jY,%K
+ZrVbU'8KZrVDU'N)R,blqS%KZrVC)E[km-$`-'DUL(9rqkQF'5'lq[+S8)&*+D!!
+JE`!!P#"5-#J!(Z"!(8$qch)!%J!r!DL)5J0R5JaZ!!)!%Qp#5'lqX+SC5LlqkfF
+S#!F!!@FL5'lqUUS8)&*`!G"S!#Sr!(!"d'J!+$m!U*-J8dKS!#LSK#mm!!)"!#m
+,6VS2T&#25LlqkQF'2c`!-DL*)&)r+!!U2bJ!++L6)&0)D!!SU)4+!fF'5'lqX+S
+82c`!!DL*)&)YD!!1rY!YD!!5rY3J8JJS!!8!)QFD)&*`rY"S!"Bp32l3)&*`!Y"
+S!"Sp32l8B!46E[l88flqeL"5##J!!3!LCh"+!fGJ5'lqd+LK5'lqT+S8F2r3E[l
+52`!r,[l8U*0`rp"ZrY)r!($rd'lqd$m!U*&`rp"ZrYBr!($rd'lqd$m!U*&)H!!
+HU'*)H!!"U*3r,[l@2blqe+L42blqdMmZrY5SN@!@5'lqd%kk"YTBMf!+5'lqd%k
+k"XjBMdKZrY![2!!"!!'SU8S$Cf")E[kf5'lq[#"62bJ!%L*52bN!"%kk#d4)E[k
+mUK4)E[kfUK9)E[k`UKNJ8JaS"`!!,Nr[!!aY+%S%CJ4+"@FJ3LF[,[kJ5'lqYNK
+ZrV!`2!`CUU)GArlUC`C)E[k`UK4)E[l3U+-J8JJS!!-!)QB!!43J8Lm3)P-r+3!
+55'lqcdkk%3"`!"!ZrXmr!+L))&)[%#*62bN!%NKZr[+T4N*R5'lqmUL-29rqlL"
+5##J!"J!LCb)m,[l@R'lqdM!'N!"ZrZj)`)(m!!,3E[l58N!J8M&!!#aJ@L"52#l
+qeTaS!#bFD!!N5NC[5!`Z!!(qmQ)kB$j`!"!Zr[*63$e!rZa63'dZ(@lqlIlb$'i
+!!IlXE`i`,[lX)%l3`"&m!-RqmN*R5'lqmUL-29rqlVaZrZjY`NSZrZYR2!J(!!&
+R0L"5##J!!3!LCb`J8R!"d'J!,$m!F!(3D!!S2`#SNdKZrV#U'8KZrUUU&%KZr[+
+SK%KZrV#U&#"52bJ!,$mS!#LSNdKZr[+SK#"55QJ!*'pU5J0R5L"5##J!!J!LCcC
+)H!!KU'*+"'Ff5LlqkQF`5'lqX+SC3LF[,[kJ5'lqYNKZrV!`2!`CUU*+(fF55'l
+qX+S8B!T+"'B'5'lq[+S8)&)r+!!N2bJ!*LmZrY3[,[l3,`Y1ZJ4#6qm!%#"5,a!
+L8cmT!"*)E[riU6p+E[riCc)J8Lm3)P-r+3!55'lrpUK1(`-J8KmS!$!I"6mZrrB
+r+!!Z5'J!&MmZrrK1ZJVk6qm!%%S%CJ4+"@Gb5LlqkQCX5(S!YULG5J0R%L"5$'J
+(!!!ZE3Jr2!!(U*aJ"Mmm!!ZSR%S%Ca4)E[l35(MrrkLT8Qlqe&*ZrYCJ$NS&C`S
+J8M!S!#54E[l@5'lqd+LL5J0R$NKZrX*)E[l)6VS-JP#25J4R##"55'J!"ULL5J0
+R$NKZrX*)E[l)6VS-C&#25'lqf+LC2blrqUL),blqQ+Kj,blqQ+MC2`Fr,[rm2bl
+rrLmZrTa1ZJR361i-q2ji6PiJAdr[!!a1d+T9UP@U9DT9!!$rN!J!!%j@rp"#E[r
+f)'i!##"3,@J!(2r35Ulrd'F!![`JE[r3)&"+N!"R!!,`)'i!##"35'J!#%kk$P*
+BMce!rrJJE[r3)&![%$mmrrqT08KZrqbSG$mZ!!a)E[rm5'lrrLmZrqa1ZJMH6qm
+!$L"Zrp!J8#m3U8JJE[r3)&"AD!!8)'lrd#"35QJ!*'B5)'lrd#"3)&!J8$PS!!)
+GPQ!12bi!$#mZ!!K1ZJEFA)mJE[r3)&!J8#"3-#`GPV"S!!*X%#"Zrp!J8#"3)&!
+jD!!#(CBJE[r3)&!J8#"3-@`GPJ!#)'lrd#"3##J!!!!LCN3),J!$!!eR*#"Zrqa
++D!"%CaSJE[r3)&![%#"Z!!JJ8$mS!")r2!#PU84J'#"Zrp!J8#m3)'i!##"32bJ
+!%Mmm!"+T4#"Zrp!J8!JS!!%!)QF8$'i!![riE``JEJ!))&")D!!)U+-JE[r3)&"
++D!!JE`!!`!aZ!!,rq'm!!+T)E[r85'lrfL"Z!!JJ8$mS!")JE[r3)&!r+!!%6VS
+'[%r[!!a)E[rJ5'lrjNkk#QK3MdKZrp5U&%KZrpUU&5"Zrqa`!"!S!%Bp32rk)Ql
+rd#*4-LN!(Z""(8(rmA3!&!%r!UL))'lrd#"35'J!"ULM)'lrd#"32bJ!+L"Zrp!
+J8$mS!#LSNb"Z!!JJ8%KS!#LSK%KZrq")E[rQ6VS+$P#22blrqUL)B!`JE[r3)&"
+)D!!'U+3JE[r3)&"`!G"S!"!p32rd)'lrd#"3F!(3D!!128$rmNKZrr+SF$mm!!&
+1ZJ@q9)p1Z[,X)Sa#Tb"Zrp!J8#m32blrmMmZrr3JEJ!))&!r+!!5U!XJ(ce!rrC
+#Cdkk"Ba8Mb"Zrp!J8#m3)'i!##"32bJ!%N*RU84+E[rfC``JEJ!))&!aE[rf!")
+r,J!-2blrr$mZrri[,[rX6VS'mNr[!!T#Cb"Zrp!J8#m3U9!JEJ!))&!aA`!@)'l
+rd#"3)&!J8%T3EbJJE[r3)&!J8#"32a#T0JaZ!!(rq'm5)'lrd#"3)&!J8$m36VS
+&iP52)'lrd#"35'J!"ULM6Pj1G8j@!!")j`m!2Li!&(VqfNID4c`Z!"+FEJ!1A8C
++EJ!@C`UmEJ!@E`4i"Q!51#i!%TKZ!!kB48M%LI`!!P*%-#i!%T!!4C!!4$m!-#i
+!%*!!EJ!-N!"(5-#"r!!#d'i!$$m!U*0m!@!B2`9#CkL5-!9%3&*!2`!r2!!"U*4
+949*'[NCXj%cI!2"1ANje6PB!!#m,*Qi!##m,U+&`!p"V!!)r!$mV!!5SNcmV!!B
+r+`!%U*%r+`!'F!238cm!U*%QAdjH6R919[rQ51FI-#CZ!!K#E[rq)&-ND!!F)!T
+R!!1%)&)[%#*62bN!%NKZrrUS6JaZ!"crqQF3)&)[%#*62bN!%NKZrrkT2b"5,a!
+L8cmT!"*)E[rj6VS+2(!!%#lrq6m!U)K)E[rZU)Xm,[r`h'lrlYaZrr4#CkL)5'l
+rlUL,1Llrm0TZrqlDE[rd5Li!$'F%9@lrmPCZrr*+E[rqCeC)E[rQ3UF[2!!J!##
+STc!ZrrTR&'Xd"%!!(fSZ9%"V+RB3282rr'!L5'lrjMmZrrj1ZJ8f-#lrl*!!E[r
+S28$rr$BZrqU@E[rQA)p`!Y"$[%"Z"(`#h%-J8b*5)fJ!#!!')fJ!$!!+)&)`+!!
+)d'J!)$&!!!`J8M!S!!U3!%Ba3!!')&*)D!!',ccrrJ!!U+JJ8b*5)fJ!#!!1)fJ
+!$!!5)&*`rG"S!"+3!%D`D!!1E`iJ8R$pd'J!%T!!4M&!!!iJ8M&S!!`!%#*5-#N
+!%T!!D3!1)&-i+!!-Q'J!#*K!5-5*r!!#5'N!$N*R-!4%3$m!U+JJ8NKS!!C#Cc!
+%4%!r!+LS)&)`+!!1d'lrlP*!-8!!+#"5-#J!%0"Zrr)a3!!X5QlrrQF!!*SJ8L&
+S!!B!&L&S!!S!'L*5-#N!&Y"$-d!!'RJ"f%DB3dM%LI`!!L*55'N!&N*R2`5SU#"
+5##J!"3!LC`iJ8R!#d'J!$$&!!"KJ$L"5-#J!$0"Zrr)a3!!B)&)`+!!Bd'lrr$&
+!!"bk3fi@)&)`!j!!48M!JI`!!Y"S!#K53$&!!#K#Ccmm!##SM5"5-#J!,0"Zrrc
+3Ac&!!#`J8JJS!!3!)QB8)&))+!!&!#*Q#L"5##J!"J!LC`JJ8N*S!#4JEL!&5-#
+"r!!$8N!J8M&!!#BJ8L!&5-#"r!!$-LJ!*Y""d%%a3!!N)&))+!!$!#*R*#"55QJ
+!)'B')&*5D!!3)&)`+!!Qd%$3D!!3"N!!$$&!!"4J'L"62LJ!$TjS!!T64b*5[QN
+!*'i')&*#D!!N)&*+D!!JChSJ8R$r`#J!(ae!rrFb+!!Hi%%G3IriG!!8!6m#U)J
+J8NTS!#"[9%*R)&0)D!!SU)`q(``Z!2rrpfB3)&)`+!!-N!"(9d!a3!!UB$!-,J!
+"rrGQ(#"5-#J!$*!!D!!)N!"(5-#"r!!#d'J!#$&!!#TJ$#"5F!63D!!)-8!!+L"
+5$'J(!!!ZE#C+E[rqEb!J8NKS!"B[2!!"!!#SU#"58QJ!%L"59'J!#L"58QJ!+%c
+I$2K1ANje6PB!!%MR!4!JEJ!))&!QD!!F)&-q+!!8RQJ!%#"3)&!L8c!S!!,3D3!
+N18!GPVj!E!Bj4af@B"`),J!!!!eR"MP((CCJ$L"6-#J!%0"X(CBa3!!860m)J%j
+H6R919J!!,`a1ZZe@+&%[,J!))'`GQ%k3!#"Z!!JJ8$&X(CB!!LKI6PiZRdje6PB
+!!%TZ!!KR)%+R,c`"!+P)6VS'+#PI(CK)H[qk,c`"!+P)6VS'+Q!1,b`GQ#mm!3#
+T5%kk"KT1ANje6PB!!%MR!6!Z,J!3*Qi!$#"(-,crrb"(-Acrr`!#)%FaI2rr!!4
+#8d*V!!*#D`!%3UFr,J!)2bi!#UTN*&mJ#QF@3HS!&R!')NHJ,N(U!!T`"L*,S#j
+J4N+R2bi!#%*RUQ3NAb!+CaC"kJ!@F!BL4k!Z3HS!%(!')NZJ,Q!J3UG#TkTN*&m
+J#QF83HS!#R!')NHJ,N(U!""`"L*,S#j-h`b!6Pj1G8j@rra)j`%33UF[2'eMG')
+r,J!)U"mQAb!,Cc4#Tbm,6VS&+LeIrra)H!!H)'lrr%KSrrj1ZZTb2J!J5k!T2`F
+J8dKS!!+UC5",S#S[#kQM60m)J%jH6R919J!!51F"%#CZ!!Kq!!JZ!!-!&@FX5QX
+!4'B#IJ%JEJ!--,J,TL*Z!"!bZ!ZS-HX!4!ZQ-HX!5JZSF2mK`!Y-B"jq!5"Z!!`
+`U`"%)Qi!%$+V!%ShH!ZQ!%3hH!ZS!%S3"dcI#)"1ANje6PB!!!JZ!!-!%@F8-Hi
+!$!ZQ-Hi!$JZSF2mK`!Y-B"!JEJ!)-@i!$!"%-@i!$J"+6Pj1G8j@!!![#jI,"Qi
+"!!!)3UF[2'0TBfir,J!)UD!QAb!,Ca3J8b*Z!!SLU!!')fJ!#J!%,`ZTSbCI6Pj
+1G8j@rqj)j`m`2Li!##JZ!!Tk!*A+"NF"!!aZ!"i!%'B#HJ&+"@F33UF[2&0*3di
+r"kQJ*&pJ9NSZ!"4R3N+R2`HU(LCI)!YR0NSZ!"CR)JaZ"`!!$QdD3QF["%*RF!!
+3,J!52`![#c!m"KqVb952B!B["#m,UKm[#kSPB!!!VN+R,ca*3dp12`HTS#4I)!T
+R!!#D5'lrlUKd)%UJD4`!)%UJ+3aZ"`!!$QdX5J9R&%*R,`4)H!!&,`S`2!BHUmP
+8Mf"H3QF["%Ki!!8[#M!m"KfVb952B%SY8[rb5J9R&Mem!!,rpNKZrrK#Tbmm!"!
+!%+LRB"3pI!!%rrC)E[ri3UF[2!!J!##STdKZrr)JE[rZ5'J!!NKZrrJ["%*R3UH
+Sl"!')%UJDLm+UD0-h`c`6Pj1G8j@rr`["cmmSDe1ZJ6b5J"8MfFL3QF[2(&N)#"
+)E[rm6VS!Z$iI5NGQ$!aZ!3$rrQd%F!&J!R!!,Kp1ANje6PErr%MR!4"#*bmZ!!K
+)E[rmUN4+V[rm9)pR8#"Zrr`J8#CS!!Kq!'!k)!G)`1H))&-`-!J)X'i!$'BQ5Li
+!$QF3)!G)`1H))&0)F!J+UK4J'L!(5-$RL#"65(!)#US9B!T54b"6[QJ!"Qqq60m
+)J%jH6R919J!!,bi!#+SC,bi!$+SD6Pj1G8j@!!![,J!)UK3[,J!-UK91ANje6PB
+!!#!m!!#SRkG',`JJ2!!!S+fM4V(IC`iJ,J!-SDdLEJ!))SKJ*N(k!$B`21T4)Li
+!$,+BC`C+Q'F5B2C$qJ!Jdp"1d5*Z!!JLJ%*!28!!%%jH)&p3Mdl3-$cU8Q$ZGQ9
+bF`!!!'"YB@0S!!!!C(0jFhB!!!#)F(*[B`!!!**QF(8J!!!!RR&N)#!!!!$SDf*
+N)!!!!4TKG'aV!!!"3QeYG5!!!!&NFQ&Y)!!!!BKXFQ&Y!!!"L!#3#(!"B))LH!+
+ZF!3-D3"e!!KR%JaT!RB!#'B%8N"J"K!i$,0FJ'!!rf"`!$!i!9TJ!2p@F!!31!%
+[8N"J!2p+$$J!"!%[CcJ)1!!%#b*R0#"2mS!!!2-R-"FZ5!a!(aKR&Ja!2aKR%!a
+!2cKR$Ja!(cKR#(!!B!j`!@!+F!*J"R!$B!*`!'!!r`!-H$rr!SjZ($!mU*qR4L3
+))$`!!+X$TdBJ2!!!!3#dL'B'B!T`!'!')$`!!!)!B!$qcK!i!Kj"qJ!@)NJ5''F
+!rY+b!'EfNFNJ#'!!rV)$%`X#!3B("!8)#3"`!%Si!T&V&K)i!IX#!3!2$!%!!@B
+))(J#h"!S!!GJ!2k%$$J!!J%[E4C`!"!i$,%-!!!"C``-!!!$E3463'!#F!"J!2j
+J-$bSRkG'*!JJ2!!!U)qR4L!i!3LdL'F+@Bmr2!!@U)mJ(f!!rMSLAb"IS#8ZJ'S
+#3TG1d5*I%Km`(dS"C`5R4Q!#SdBZL%l4)Pm5(c!I)&p+!@F%TNGJ!U*(6Y&9Mbm
+[!!`r,`!15'm!"UP"-"mJAb*I%S"FMdl36PErl%MR!a"m)%KZrqbSG#"Zrqa++!!
+'D`C`!@!!!)Jr2+ST6VS"RNS!9)pQ"(!"B(3JEJ!),9$rq#eS!!6rr%KZrrLSF%K
+ZrrbSF%+RULNQAf"-3LG)E[ri)&0)D!!L5'lrm+LU5KpR,N)R,`Xr2!!0ULa+(fF
+J3LF[#cmm!!qU,%SICa)J8b"S!"BJ8$iS!##m4fm#2!G#Tbm,ULXQAb!,CV!`"Nc
+I#-"1ANje6PErm%MR"c!Z,J!3PmXr2+ST6VS"!NS!9)pR!!#Q3UHSf#4I,`USHLS
+()%8J8#eS!!Erq#eS!!Vrr%KZrrLSF%KZrrbSF%+RULNQAf"Q3LG)E[ri)&0)D!!
+L5'lrm+LU5KpR5%)R,`Xr2!!0ULa+(fFk3LF[#cmm!!qU,%SICba)E[r`U(&)E[r
+dU(&)E[r`U(XJ8b"S!"BJ8$`S!#!r"N*R,`X["b"Z!!a1N!"#Tbm,ULXQAb!,CTB
+[#UKj,`USf@!15(J!!5m,,`FJEJ!-6T!!60m-i%jH6R919[rm51F$!$`m"J!r2+'
+Y6VS!,%S!9)pR'N*R,cacHA0f5'lrr%kkqr)q(dT(CJ3m,[rq-!C-h`$!6Pj1G8j
+@rra)j`-!2Li!#$m(6VS!5"`!$!B!!952CK!#4`Ir6VS!6,"(EJ3q2+LI3UFr"am
+'6VVpa#eIrra#Tbmm!3#SRdkkrE3J,[rmX*p@`%3!60m!`%jH6R919J!!!Qi)!!!
+)C`4`!@!#F!"1ANje6PErr%+R,c`"!+KZ6VVpI#eIrra#Tbmm!3#UENkkr@`J,[r
+mX*pQ"M!m!J"J"$!m"!"1ANjerj!'UT!'!*!*13I3!*!)rj!%#P"[F(9`)%ePER8
++4QPbFh3J5A4PE3#3"!Y6C@0[EQ3J5A4PE3#3#"%!J!#3#2q3"!%8!!!!#TJ+Q!#
+3"4i!(J!4![m-!2rq!!!!5!!!!%J!N!FH!"i!N!8"!!S!N!8H!"i!Q)!J!*!&(J!
+H!*!*5!!!!%J!N!8)!!%!#!#3$82mX!!!!2m!!2q3"J!"J)!!N!8#!!#!J!!!!!1
+!N!3!!!!%!*!%J)!!"B#!!!#!J!!'!!#!N!3!"m#3"J!)J*!'!!Rrr`#3"3S!!2r
+r!!!!#rq3"!!!!!`!N!6rr`!0rrm!!2rr!!i!!2q3"!!2rj!'!"$rN!B!%Iq3"J!
+5rj!'!"2rN!B!&2q3"J!9rj!'!"ErN!B!&rq3"J!Brj!'!"RrN!B!'[q3"J!Erj!
+'!"crN!B!(Iq3"J!Hrj!'!"rrN!B!)2q3"J!Krj!'!#,rN!B!)rq3"J!Nrj!'!#A
+rN!B!*[q3"J!Rrj!'!#MrN!B!+Iq3"J!Urj!'!#[rN!B!,2q3"J!Yrj!'!#lrN!B
+!,rq3"J!`rj!'!$(rN!B!-[q3"J!crj!'!$6rN!B!0Iq3"J!frj!'!$IrN!B!12q
+3"J!jrj!'!$VrN!B!1rq3"J!mrj!'!$hrN!B!2[q3"J!rrj!'!%$rN!B!3Iq3"J"
+#rj!'!%2rN!B!42q3"J"&rj!'!%ErN!B!4rq3"J")rj!'!%RrN!B!5[q3"J",rj!
+'!%crN!B!6Iq3"J"1rj!'!%rrN!B!82q3"J"4rj!'!&,rN!B!8rq3"J"8rj!'!&A
+rN!B!9[q3"J"Arj!'!&MrN!B!@Iq3"J"Drj!'!&[rN!B!A2q3"J"Grj!'!&lrN!B
+!Arq3"J"Jrj!'!'(rN!B!B[q3"J"Mrj!'!'6rN!B!CIq3"J"Qrj!'!'IrN!B!D2q
+3"J"Trj!'!'VrN!B!Drq3"J"Xrj!'!'hrN!B!E[q3"J"[rj!'!($rN!B!FIq3"J"
+brj!'!(2rN!B!G2q3"J"erj!'!(ErN!B!Grq3"J"irj!'!(RrN!B!H[q3"J"lrj!
+'!(crN!B!IIq3"J"qrj!'!(rrN!B!J2q3"J#"rj!'!),rN!B!Jrq3"J#%rj!'!)A
+rN!B!K[q3"J#(rj!'!)MrN!B!LIq3"J#+rj!'!)[rN!B!M2q3"J#0rj!'!)lrN!B
+!Mrq3"J#3!2q3"J#4rj!'!*,rN!B!Nrq3"J#8rj!'!*ArN!B!P[q3"J#Arj!'!*M
+rN!B!QIq3"J#Drj!'!*[rN!B!R2q3"J#Grj!'!*lrN!B!Rrq3"J#Jrj!'!+(rN!B
+!S[q3"J#Mrj!'!+6rN!B!TIq3"J#Qrj!'!+IrN!B!U2q3"J#Trj!'!+VrN!B!Urq
+3"J#Xrj!'!+hrN!B!V[q3"J#[rj!'!,$rN!B!XIq3"J#brj!'!,2rN!B!Y2q3"J#
+erj!'!,ErN!B!Yrq3"J#irj!'!,RrN!B!Z[q3"J#lrj!'!,crN!B![Iq3"J#qrj!
+'!,rrN!B!`2q3"J$"rj!'!-,rN!B!`rq3"J$%rj!'!-ArN!B!a[q3"J$(rj!'!-M
+rN!B!bIq3"J$+rj!'!-[rN!B!c2q3"J$0rj!'!-lrN!B!crq3"J$3rj!'!0(rN!B
+!d[q3"J$6rj!'!06rN!B!eIq3"J$@rj!'!0IrN!B!f2q3"J$Crj!'!0VrN!B!frq
+3"J$Frj!'!0hrN!B!h[q3"J$Irj!'!1$rN!B!iIq3"J$Lrj!'!12rN!B!j2q3"J$
+Prj!'!1ErN!B!jrq3"J$Srj!'!1RrN!B!k[q3"J$Vrj!'!1crN!B!lIq3"J$Zrj!
+'!1rrN!B!m2q3"J$arj!'!2,rN!B!mrq3"J$drj!'!2ArN!B!p[q3"J$hrj!'!2M
+rN!B!qIq3"J$krj!'!2[rN!B!r2q3"J$prj!'!2lrN!B!r`#3#ai!(J#3"4i!(J!
+!"1-(r`!)lJIirrm(r`!-rJIbr`!(q2rr"rm!$2i(!2ra"rRrr`Ir!"$q"`,r"`I
+cr`!(q[rr"rm!$ri(!rm("rrd"rRrr`Ir!!rq"`2r"`Irp3Iirrm(r`!6rJF$r`F
+(rrB(qrm!"rlrr`Ir!"2q"`2r"`Irq!Ikrri(rrrr"rm!%[i(!rm("rrk"rRr!3I
+rq`Ir!"Eq"`2r"`Irr!Iirrm(!rm("rrq"rm!&[i("Im("rm("rErrJF$r`F(rri
+(r`!9rJF%r`F(r`Ifrrd(!rm("rrq"rm!%[i(!rm("rra"`2r"`IrrJIr!",q"`2
+r"`Irm3F$r`F(rri(r`!5rJF$r`F(rr%(!rm("rrq"rm!%[i(!rm("rra"`2r"`I
+rrJIr!"$q"`,r"`I[rrm(!2rq"rm!$2i(!2rV"`$rrJIr!!cq"`$rk`F!rri(r`!
+3rJF!rrd(p2rm"`$rrJIr!"6q"`$rr3F!rrB(!2rm"`$rrJIr!"Iq"`$rr3F"r`I
+qrrS(!2rm"`$rrJIr!"Mq"`$rr3F%r`Ir"rrk"`$rr!F!rri(r`!BrJF!rrd("2m
+(r`IrqJF!rr`(!2rq"rm!'2i(!2rp"`6r"rm(rrS(!2rm"`$rrJIr!"Mq"`$rr3F
+%r`Ir"rrk"`$rr!F!rri(r`!Ar3F!rri(!Im(r[rk"`$rr!F!rri(r`!)r!IVrri
+(r`!%i`Ir!!!!r`!!!3!!!#R)!!!Sb!!!!+J!HClB'EB!!!!F!)i!"%&-8P3!!!!
+U4%P86!!!!$C$4%9'!!!!3Ne&6P8!!3"18%P$9!!!!'B!C!#3#f6rr`!!!"!!N!3
+%63!*)!!!1J#3"!I3rrm!!"hD!*!&J2rr!!!H&`#3"B!!&!!!(L`!HC[N#'ej)'&
+XCA*d#P"[F&9`)%ePER8&CQa[B@68kJ:
diff --git a/src/wxmac/src/DebugNew.patch b/src/wxmac/src/DebugNew.patch
new file mode 100644
index 0000000..cb2fcfd
--- /dev/null
+++ b/src/wxmac/src/DebugNew.patch
@@ -0,0 +1,112 @@
+//
+// Heres some code to add to DebugNew.cp to for it to print out the first 16 bytes of each 
+// leak in hex and ascii.
+// The preprocessor symbol FOR_MAC is used - not the best but it was available.
+// I put this file in :src: along with the precompiled header files.
+// 
+// Cecil Coupe - ccoupe@simplot.com
+//
+#ifdef FOR_MAC
+void DebugNewP16(FILE* f, unsigned char *blk);
+
+void DebugNewP16(FILE* f, unsigned char *blk) 
+{
+	int i;
+	for (i = 0; i < 16; i++)
+		fprintf(f, "%02x ", blk[i]);
+	fprintf(f, " ");
+	for (i = 0; i < 16; i++) {
+		int c = blk[i];
+		if (c > 0x7f)
+			c = c & 0x7f;
+		if (c < ' ' || c == 0x7f)
+			c = ' ';
+		fprintf(f, "%c", c);
+	}
+	fprintf(f, "\n");
+}
+
+#endif
+
+void DebugNewReportLeaks()
+{
+	ProcessSerialNumber psn;
+	OSErr err = GetCurrentProcess(&psn);
+	if (err != noErr) return;
+	
+	ProcessInfoRec info;
+	FSSpec spec;
+	
+	info.processInfoLength = sizeof(info);
+	info.processName = 0;
+	info.processAppSpec = &spec;
+	err = GetProcessInformation(&psn, &info);
+	if (err != noErr) return;
+	
+	StringPtr s = "\pleaks.log";
+	BlockMoveData(s, spec.name, s[0]+1);
+	FILE* f = FSSpecOpen(spec, "w");	
+	if (!f) return;
+
+	long count = 0;
+	long leakCount = 0;
+	unsigned long bytesLeaked = 0;
+	BlockHeader* curr = gBlockList;
+	while (curr)
+	{
+		++count;
+		if (curr->tag == BLOCK_PREFIX_ALLOC)
+		{
+			bytesLeaked += curr->size;
+			++leakCount;
+		}
+		curr = curr->next;
+	}
+	
+	if(count != gDebugNewAllocCount)
+		fprintf(f, "Warning: length of block list different from count of allocated blocks (internal error).\n");
+		
+	fprintf(f, "Maximum #bytes allocated at any point via operator new: %ld\n", gDebugNewAllocMax);
+	
+	if (!leakCount)
+	{
+		fprintf(f, "No memory leaks.\n");
+		fclose(f);
+		return;
+	}
+	if (leakCount == 1)
+		fprintf(f,"There is 1 memory leak of %lu bytes:\n", bytesLeaked);
+	else
+		fprintf(f,"There are %ld memory leaks, totaling %lu bytes:\n", leakCount, bytesLeaked);
+	
+	unsigned long totalAlloc = 0;
+	
+	curr = gBlockList;
+	while (curr)
+	{
+		if (curr->tag == BLOCK_PREFIX_ALLOC)
+		{
+#ifdef FOR_MAC
+			if (curr->file)
+				fprintf(f,"  %12s line: %4d, size: %4lu ", curr->file, curr->line, curr->size);
+			else
+				fprintf(f,"  %12s line: %4d, size: %4lu ", "<unknown>",  0, curr->size);
+			// print first 16 bytes of the block plus newline
+			DebugNewP16(f,  (unsigned char *) curr+BLOCK_HEADER_SIZE);
+#else
+			if (curr->file)
+				fprintf(f,"  %s line: %d, size: %lu\n", curr->file, curr->line, curr->size);
+			else
+				fprintf(f,"  <unknown>, size: %lu\n", curr->size);
+#endif
+		}
+		totalAlloc += curr->size; // count freed blocks, since gDebugNewAllocCurr does
+		curr = curr->next;
+	}
+	if (totalAlloc != gDebugNewAllocCurr)
+		fprintf(f, "Warning: total allocations in block list different from gDebugNewAllocCurr.\n");
+
+	fclose(f);
+}
+#else
+	// leak checking disabled, does nothing
diff --git a/src/wxmac/src/base/borland.mak b/src/wxmac/src/base/borland.mak
new file mode 100644
index 0000000..82aff88
--- /dev/null
+++ b/src/wxmac/src/base/borland.mak
@@ -0,0 +1,33 @@
+!ifdef ARGFILE
+!include $(ARGFILE)
+!else
+!include ..\argfile.mkf
+!endif
+
+WXMSWINC =	$(WXDIR)\include\msw
+WXBASEINC =	$(WXDIR)\include\base
+
+.AUTODEPEND
+
+CPPFLAGS =	@$(CFG) $(DEBUG_FLAGS) $(OPT)
+
+.cc.obj:
+	$(CC) $(CPPFLAGS) -c {$< }
+
+OBJECTS =	wb_data.obj wb_win.obj wb_frame.obj wb_panel.obj \
+		wb_utils.obj wb_main.obj wb_item.obj wb_list.obj \
+		wb_obj.obj wb_ps.obj wb_text.obj wb_gdi.obj \
+		wb_dialg.obj wb_canvs.obj wb_dc.obj wb_mf.obj \
+		wb_hash.obj wb_ipc.obj wb_form.obj wb_timer.obj \
+		wb_help.obj wb_sysev.obj wb_stdev.obj wb_types.obj \
+		wb_mgstr.obj wxstring.obj wx_enhdg.obj
+
+all:    $(CFG) $(OBJECTS)
+
+clean:
+	-erase *.obj
+	-erase *.bak
+	-erase *.csm
+
+nuke:	clean
+	echo Nothing to nuke
diff --git a/src/wxmac/src/base/glob.inc b/src/wxmac/src/base/glob.inc
new file mode 100644
index 0000000..a8d97f3
--- /dev/null
+++ b/src/wxmac/src/base/glob.inc
@@ -0,0 +1,363 @@
+/*
+ * File and other globbing (included by wb_utils.cc)
+ */
+
+// This file includes:
+//	wxIsWild(const char *pattern)
+//	wxMatchWild(const char *pattern, const char *str, Bool dot_special)
+//
+
+
+//---------------------------------------------------------------------------------
+#ifndef UNIX_GLOB
+# ifdef wx_x
+#  define UNIX_GLOB 1
+# else
+#  define UNIX_GLOB 0
+# endif
+#endif
+
+#if UNIX_GLOB
+# ifdef wx_msw
+#  error "Can't use Unix file globbing under Windows!"
+# endif
+#endif
+
+/*************************************************************************
+ *
+ * wxIsWild checks whether the pattern contains wildcards, and
+ * returns TRUE if it does, and FALSE if it does not (or if the 
+ * pattern is NULL -- i.e. no string).
+ *
+ * The argument is:
+ *   
+ * 1) pattern - a character string
+ */
+Bool 
+wxIsWild (const char *pattern)
+{
+  while (*pattern)
+    {
+      switch (*pattern++)
+	{
+	case '?':
+	case '*':
+#if UNIX_GLOB
+	case '[':
+	case '{':		/* } */
+#endif
+	  return TRUE;
+#if UNIX_GLOB
+	case '\\':
+	  if (!*pattern++)
+	    return FALSE;
+#endif
+	}			/* switch() */
+    }				/* while() */
+  return FALSE;
+}
+
+
+
+#if UNIX_GLOB
+
+// Unix Glob()
+//
+// Pattern        Function
+// -----------------------------------------------------
+//  '*'         = match 0 or more occurances of anything
+// "[abc]"      = match anyof "abc" (ranges supported)
+// "{xx,yy,zz}" = match anyof "xx", "yy", or "zz"
+// '?'          = match any character
+//
+//  '\'  is used to "escape" special characters
+// Recursive
+
+Bool 
+wxMatchWild (const char *pattern, const char *str, Bool dot_special)
+{
+  char c;
+  const char *cp;
+  Bool done = FALSE, ret_code, ok;
+  // Below is for vi fans
+  const char OB = '{', CB = '}';
+
+#if 0
+  if (strcmp(pattern, "*.*") == 0)
+    pattern = "*"; // Hack for MS-DOS compat.
+#endif
+
+  // dot_special means '.' only matches '.'
+  if (dot_special && *str == '.' && *pattern != *str)
+    return FALSE;
+
+  while ((*pattern != '\0') && (!done) && (((*str == '\0') &&
+	       ((*pattern == OB) || (*pattern == '*'))) || (*str != '\0')))
+    {
+      switch (*pattern)
+	{
+	case '\\':
+	  pattern++;
+	  if (*pattern != '\0')
+	    pattern++;
+	  break;
+	case '*':
+	  pattern++;
+	  ret_code = FALSE;
+	  while ((*str != '\0') && (!(ret_code = wxMatchWild (pattern, str++, FALSE))));
+	  if (ret_code)
+	    {
+	      while (*str != '\0')
+		str++;
+	      while (*pattern != '\0')
+		pattern++;
+	    }
+	  break;
+	case '[':
+	  pattern++;
+	repeat:
+	  if ((*pattern == '\0') || (*pattern == ']'))
+	    {
+	      done = TRUE;
+	      break;
+	    }
+	  if (*pattern == '\\')
+	    {
+	      pattern++;
+	      if (*pattern == '\0')
+		{
+		  done = TRUE;
+		  break;
+		}
+	    }
+	  if (*(pattern + 1) == '-')
+	    {
+	      c = *pattern;
+	      pattern += 2;
+	      if (*pattern == ']')
+		{
+		  done = TRUE;
+		  break;
+		}
+	      if (*pattern == '\\')
+		{
+		  pattern++;
+		  if (*pattern == '\0')
+		    {
+		      done = TRUE;
+		      break;
+		    }
+		}
+	      if ((*str < c) || (*str > *pattern))
+		{
+		  pattern++;
+		  goto repeat;
+		}
+	    }
+	  else if (*pattern != *str)
+	    {
+	      pattern++;
+	      goto repeat;
+	    }
+	  pattern++;
+	  while ((*pattern != ']') && (*pattern != '\0'))
+	    {
+	      if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
+		pattern++;
+	      pattern++;
+	    }			// while()
+	  if (*pattern != '\0')
+	    {
+	      pattern++, str++;
+	    }
+	  break;
+	case '?':
+	  pattern++;
+	  str++;
+	  break;
+	case OB:
+	  pattern++;
+         while ((*pattern != CB) && (*pattern != '\0'))
+	    {
+	      cp = str;
+	      ok = TRUE;
+	      while (ok && (*cp != '\0') && (*pattern != '\0') &&
+                 (*pattern != ',') && (*pattern != CB))
+		{
+		  if (*pattern == '\\')
+		    pattern++;
+		  ok = (*pattern++ == *cp++);
+		}		// while()
+	      if (*pattern == '\0')
+		{
+		  ok = FALSE;
+		  done = TRUE;
+		  break;
+		}
+	      else if (ok)
+		{
+		  str = cp;
+                   while ((*pattern != CB) && (*pattern != '\0'))
+		    {
+		      if (*++pattern == '\\')
+			{
+                      if (*++pattern == CB)
+			    pattern++;
+			}
+		    }		// while()
+		}
+	      else
+		{
+                 while (*pattern != CB && *pattern != ',' && *pattern != '\0')
+		    {
+		      if (*++pattern == '\\')
+			{
+                            if (*++pattern == CB || *pattern == ',')
+			    pattern++;
+			}
+		    }		// while()
+		}
+	      if (*pattern != '\0')
+		pattern++;
+	    }			// while()
+	  break;
+	default:
+	  if (*str == *pattern)
+	    {
+	      str++, pattern++;
+	    }
+	  else
+	    {
+	      done = TRUE;
+	    }
+	}			// switch()
+    }				// while()
+  while (*pattern == '*')
+    pattern++;
+  return ((*str == '\0') && (*pattern == '\0'));
+}
+
+#else /* MS-DOS/Windows glob() */
+/*************************************************************************
+ *
+ *  wxMatchWild matches the given pattern string against 
+ *  a text string, and returns TRUE if it matches, FALSE otherwise.
+ *
+ *  A match means that the entire text string is used up in the matching.
+ *  The pattern can contain the following wildcards.
+ * 
+ *  * -- matches any sequence of characters
+ *  ? -- matches one character
+ *
+ * If one or other or both of the string arguments to wxMatchWild function is  
+ * NULL (i.e. there isn't a string), then the function returns FALSE.
+ *
+ */
+static Bool wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j);
+
+// @@@@ dotSpecial is ignored by MS-DOS
+Bool 
+wxMatchWild (const char *pattern, const char *text, Bool /* dotSpecial */ )
+{
+  if (pattern == NULL || text == NULL || *pattern == '\0' || *text == '\0')
+    return FALSE;
+  return wxPatternMatch (pattern, text, 0, 0);
+}
+
+/*************************************************************************
+ *
+ *  wxPatternMatch does the work for wxMatchWild. wxPatternMatch  matches 
+ *  the given pattern string against a text string, and returns TRUE if 
+ *  it matches, FALSE otherwise. It is assumed that the string arguments
+ *  to wxPatternMatch exist.
+ *
+ *  A match means that the entire text string is used up in the matching.
+ *  The pattern can contain the following wildcards.
+ * 
+ *  * -- matches any sequence of characters
+ *  ? -- matches one character
+ *
+ *  wxPatternMatch works by going down the pattern trying to match the
+ *  the same index character in the pattern and string arrays, and stops
+ *  when the end of the pattern or text string is reached. However, if a
+ *  '*' wildcard is met, the algorithm checks to see whether the remaining 
+ *  pattern (after the wildcard) matches the rest of the text (i.e. the 
+ *  wxPatternMatch function is called recursively).
+ */
+// Recursive
+static Bool 
+wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j)
+{
+  size_t pattern_length = strlen (pattern);
+  size_t text_length = strlen (text);
+  Bool match = FALSE;
+
+#ifdef wx_msw
+// MS-DOS file system is case INDEPENDENT
+# define EQU(x,y) (wxToLower(x) == wxToLower(y))
+#elif defined(wx_mac)
+# define EQU(x,y) (tolower(x) == tolower(y))
+#else
+# define EQU(x,y) ((x) == (y))
+#endif
+
+  while (j < pattern_length && i < text_length)
+    {
+      if (EQU(text[i], pattern[j]) || pattern[j] == '?')
+	{
+	  match = TRUE;
+	  i++, j++;
+	}
+      else if (pattern[j] == '*')
+	{
+	  // If pattern ends in '*'
+	  if (++j == pattern_length)
+	    {
+	      match = TRUE;
+	      i = text_length;
+	    }
+	  else
+	    {
+	      match = FALSE;
+// after wildcard check to see whether rest of pattern matches 
+	      // up with rest of text
+	      while (i < text_length && match != TRUE)
+		{
+		  match = wxPatternMatch (pattern, text, i, j);
+		  i++;
+		}
+// text index is decremented so that it points to where 
+	      // the text string starts to match the rest of the pattern
+	      i--;
+	    }
+	}
+      else if (! EQU(text[i], pattern[j]))
+	{
+	  j = pattern_length;
+	  match = FALSE;
+	}
+    }
+  if (j == pattern_length && i == text_length && match == TRUE)
+    {
+      return TRUE;
+    }
+  else
+// special case where pattern and text are the same except that pattern
+    // also only has '*' wildcards on the end
+  if (i == text_length && pattern[j] == '*' && match == TRUE)
+    {
+      for (; j < pattern_length; j++)
+	{
+	  if (pattern[j] != '*')
+	    return FALSE;
+	}
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+#endif /* UNIX_GLOB */
+//-----------------------------------------------------------------------------
diff --git a/src/wxmac/src/base/makefile.b32 b/src/wxmac/src/base/makefile.b32
new file mode 100644
index 0000000..31a7070
--- /dev/null
+++ b/src/wxmac/src/base/makefile.b32
@@ -0,0 +1,131 @@
+#
+# File:		makefile.bcc
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds wxWindows library wx.lib for Windows 3.1
+# and Borlandc C++ 3.1/4.0
+
+$(WXDIR) = $(WXWIN)
+THISDIR = $(WXDIR)\src\base
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASEINC = $(WXDIR)\include\base
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v
+!else
+OPT = -O2
+DEBUG_FLAGS =
+!endif
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) @$(CFG)
+
+LIBTARGET= $(WXLIB)\wx.lib
+
+.cc.obj:
+        bcc32 $(CPPFLAGS) -c {$< }
+
+ITEMS =  $(WXBASEINC)\wb_item.h $(WXBASEINC)\wb_buttn.h $(WXBASEINC)\wb_check.h\
+ $(WXBASEINC)\wb_choic.h $(WXBASEINC)\wb_menu.h $(WXBASEINC)\wb_messg.h\
+ $(WXBASEINC)\wb_txt.h $(WXBASEINC)\wb_mtxt.h $(WXBASEINC)\wb_lbox.h\
+ $(WXBASEINC)\wb_slidr.h
+OBJECTS1 = wb_data.obj wb_win.obj wb_frame.obj wb_panel.obj wb_utils.obj wb_main.obj\
+  wb_item.obj wb_list.obj wb_obj.obj
+
+OBJECTS2 = wb_text.obj wb_gdi.obj wb_dialg.obj wb_canvs.obj wb_dc.obj wb_mf.obj\
+  wb_ps.obj
+
+OBJECTS3 = wb_hash.obj wb_ipc.obj wb_form.obj wb_timer.obj wb_help.obj\
+  wb_sysev.obj wb_stdev.obj wb_types.obj wb_mgstr.obj wxstring.obj
+
+OBJECTS = $(OBJECTS1) $(OBJECTS2) $(OBJECTS3)
+
+all: $(CFG) $(OBJECTS)
+
+wb_obj.obj:     $(WXBASEINC)\wx_obj.h
+
+wb_data.obj:     wb_data.cc
+
+wb_win.obj:     $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+  $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_win.cc $(WXBASEINC)\wb_gdi.h
+
+wb_main.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wx_utils.h\
+  $(WXBASEINC)\wb_main.h wb_main.cc
+
+wb_frame.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h wb_frame.cc\
+                $(WXBASEINC)\wx_stdev.h
+
+wb_panel.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_panel.h\
+                wb_panel.cc $(WXBASEINC)\wx_stdev.h
+
+wb_text.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_text.h\
+                wb_text.cc $(WXBASEINC)\wx_stdev.h
+
+wb_canvs.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+                 $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                 $(WXBASEINC)\wb_canvs.h\
+                 wb_canvs.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h\
+                 $(WXBASEINC)\wb_dc.h
+
+wb_dc.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_dc.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+
+wb_ps.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_ps.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+
+wb_mf.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_mf.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_mf.h
+
+wb_item.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                $(ITEMS) wb_item.cc $(WXBASEINC)\wx_stdev.h
+
+wb_utils.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h wb_utils.cc
+
+wb_ipc.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_ipc.h wb_ipc.cc
+
+wb_list.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_list.cc
+
+wxstring.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wxstring.h wxstring.cc
+
+wb_hash.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_hash.h wb_hash.cc $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h
+
+wb_event.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wx_utils.h wb_event.cc
+
+wb_gdi.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wx_utils.h wb_gdi.cc
+
+wb_dialg.obj:   $(WXBASEINC)\common.h wb_dialg.cc $(WXBASEINC)\wb_dialg.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h $(ITEMS)
+
+wb_form.obj:   $(WXBASEINC)\common.h wb_form.cc $(WXBASEINC)\wx_form.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h
+
+wb_timer.obj:   $(WXBASEINC)\common.h wb_timer.cc $(WXBASEINC)\wb_timer.h
+
+wb_help.obj:   $(WXBASEINC)\common.h wb_help.cc $(WXBASEINC)\wx_help.h $(WXINC)\wx_ipc.h
+
+wb_types.obj:   $(WXBASEINC)\common.h wb_types.cc $(WXBASEINC)\wx_types.h
+
+wb_mgstr.obj:   $(WXBASEINC)\common.h wb_mgstr.cc $(WXBASEINC)\wx_mgstr.h
+
+wb_sysev.obj:   $(WXBASEINC)\common.h wb_sysev.cc $(WXBASEINC)\wx_sysev.h\
+        $(WXBASEINC)\wx_types.h
+
+wb_stdev.obj:   $(WXBASEINC)\common.h wb_stdev.cc $(WXBASEINC)\wx_stdev.h\
+        $(WXBASEINC)\wx_types.h $(WXBASEINC)\wx_sysev.h
+
+clean:
+        -rm $(OBJECTS1)
+        -rm $(OBJECTS2)
+        -rm $(OBJECTS3)
+        -rm $(LIBTARGET)
+
+cleanall: clean
+        -rm *.obj ..\lib\*.lib
+
diff --git a/src/wxmac/src/base/makefile.dos b/src/wxmac/src/base/makefile.dos
new file mode 100644
index 0000000..6f86eeb
--- /dev/null
+++ b/src/wxmac/src/base/makefile.dos
@@ -0,0 +1,329 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds wxWindows library wx.lib for Windows 3.1
+# Arguments:
+#
+# FINAL=1 argument to nmake to build version with no debugging info.
+# DLL=1 builds a library (wxdll.lib) suitable for creating DLLs.
+#
+# Set WXDIR to the wxWindows directory if env. variable WXWIN not set.
+#
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASEINC = $(WXDIR)\include\base
+DOCDIR = $(WXDIR)\docs
+DOCUTILSDIR = $(WXDIR)\utils\tex2rtf\src
+THISDIR = $(WXDIR)\src\base
+# Set this to nothing if using MS C++ 7
+ZOPTION=/Z7
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+!ifndef DLL
+DLL=0
+!endif
+
+!ifndef DEBUG
+DEBUG=0
+!endif
+
+# Default is to output RTF for WinHelp
+!ifndef WINHELP
+WINHELP=-winhelp
+!endif
+
+# Note we optimize anyway, since we don't debug this often, and optimizing
+# doesn't do any harm to this module.
+!if "$(FINAL)" == "0"
+OPT = /Od
+DEBUG_FLAGS= /Zi $(ZOPTION)
+LINK_DEBUG_FLAGS=/CO
+!else
+OPT = /Ox
+DEBUG_FLAGS=/Zi
+LINK_DEBUG_FLAGS=/CO
+!endif
+
+PRECOMP=/YuWX.H
+INC=/I$(WXINC) /I$(WXBASEINC)
+
+!if "$(DLL)" == "0"
+PCH=WX.PCH
+CPPFLAGS= $(DEBUG_FLAGS) $(OPTIONS) $(INC) /DDEBUG=$(DEBUG) /AL /Gt4 /Gx- /W3 /G2sw $(OPT) /Dwx_msw $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
+LINKFLAGS=$(LINK_DEBUG_FLAGS) /NOD /ONERROR:NOEXE
+LIBTARGET= $(WXLIB)\wx.lib
+DUMMY=dummy
+!else
+PCH=WXDLL.PCH
+CPPFLAGS= $(DEBUG_FLAGS) $(OPTIONS) $(INC) /AL /Gt4 /Gx- /W3 /G2sw /GD $(OPT) /Dwx_msw $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
+LINKFLAGS=$(LINK_DEBUG_FLAGS) /NOD /ONERROR:NOEXE
+LIBTARGET= $(WXLIB)\wxdll.lib
+DUMMY=dummydll
+!endif
+
+LIBS=libw llibcew
+
+ITEMS =  $(WXBASEINC)\wb_item.h $(WXBASEINC)\wb_buttn.h $(WXBASEINC)\wb_check.h\
+ $(WXBASEINC)\wb_choic.h $(WXBASEINC)\wb_menu.h $(WXBASEINC)\wb_messg.h\
+ $(WXBASEINC)\wb_txt.h $(WXBASEINC)\wb_mtxt.h $(WXBASEINC)\wb_lbox.h\
+ $(WXBASEINC)\wb_slidr.h
+OBJECTS1 = wb_win.obj wb_frame.obj wb_panel.obj wb_utils.obj wb_main.obj\
+  wb_data.obj wb_item.obj wb_list.obj wb_obj.obj wb_res.obj
+
+OBJECTS2 = wb_text.obj wb_gdi.obj wb_dialg.obj wb_canvs.obj wb_dc.obj wb_mf.obj\
+  wb_ps.obj wx_enhdg.obj
+
+OBJECTS3 = wb_hash.obj wb_ipc.obj wb_form.obj wb_timer.obj wb_help.obj\
+  wb_sysev.obj wb_stdev.obj wb_types.obj wb_mgstr.obj wxstring.obj
+
+OBJECTS = $(OBJECTS1) $(OBJECTS2) $(OBJECTS3)
+
+all: $(OBJECTS)
+
+$(OBJECTS): $(WXDIR)\src\msw\wx.pch
+
+wb_data.obj:     wb_data.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_res.obj:     wb_res.cc $(WXBASEINC)\common.h $(WXBASEINC)\wx_res.h 
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_obj.obj:     $(WXBASEINC)\wx_obj.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_win.obj:     $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+  $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_win.cc $(WXBASEINC)\wb_gdi.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_main.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wx_utils.h\
+  $(WXBASEINC)\wb_main.h wb_main.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_frame.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h wb_frame.cc\
+                $(WXBASEINC)\wx_stdev.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_panel.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_panel.h\
+                wb_panel.cc $(WXBASEINC)\wx_stdev.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_text.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_text.h\
+                wb_text.cc $(WXBASEINC)\wx_stdev.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_canvs.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+                 $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                 $(WXBASEINC)\wb_canvs.h\
+                 wb_canvs.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h\
+                 $(WXBASEINC)\wb_dc.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_dc.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_dc.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_ps.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_ps.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_mf.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_mf.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_mf.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_item.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                $(ITEMS) wb_item.cc $(WXBASEINC)\wx_stdev.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_utils.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h wb_utils.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_ipc.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_ipc.h wb_ipc.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_list.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_list.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wxstring.obj: wxstring.cc $(WXBASEINC)\wxstring.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_hash.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_hash.h wb_hash.cc $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_event.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wx_utils.h wb_event.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_gdi.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wx_utils.h wb_gdi.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_dialg.obj:   $(WXBASEINC)\common.h wb_dialg.cc $(WXBASEINC)\wb_dialg.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h $(ITEMS)
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_form.obj:   $(WXBASEINC)\common.h wb_form.cc $(WXBASEINC)\wx_form.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_timer.obj:   $(WXBASEINC)\common.h wb_timer.cc $(WXBASEINC)\wb_timer.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_help.obj:   $(WXBASEINC)\common.h wb_help.cc $(WXBASEINC)\wx_help.h $(WXINC)\wx_ipc.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_types.obj:   $(WXBASEINC)\common.h wb_types.cc $(WXBASEINC)\wx_types.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_mgstr.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_mgstr.h wb_mgstr.cc
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_sysev.obj:   $(WXBASEINC)\common.h wb_sysev.cc $(WXBASEINC)\wx_sysev.h\
+        $(WXBASEINC)\wx_types.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wb_stdev.obj:   $(WXBASEINC)\common.h wb_stdev.cc $(WXBASEINC)\wx_stdev.h\
+        $(WXBASEINC)\wx_types.h $(WXBASEINC)\wx_sysev.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+wx_enhdg.obj:   $(WXBASEINC)\common.h wx_enhdg.cc $(WXBASEINC)\wx_enhdg.h
+        cl @<<
+$(CPPFLAGS) /c /Tp $*.cc
+<<
+
+$(OBJECTS):	$(WXBASEINC)\wx_setup.h
+
+# Making documents
+docs:   hlp
+hlp:    wxhlp faqhlp
+wxhlp:  $(DOCDIR)/wx.hlp
+faqhlp: $(DOCDIR)/faq.hlp
+rtf:    $(DOCDIR)/wx.rtf
+faqrtf: $(DOCDIR)/faq.rtf
+faqxlp: $(DOCDIR)/faq.xlp
+
+alldocs: allhlp
+allhlp: $(DOCDIR)/faq.hlp
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\toolbar\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\hytext\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\wxclips\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\clips2c\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\wxhelp\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\prologio\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\tex2rtf\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\wxgraph\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\wxtree\src
+        nmake -f makefile.dos hlp
+        cd $(WXDIR)\utils\wxbuild\src
+        nmake -f makefile.dos hlp
+        cd $(THISDIR)
+
+$(DOCDIR)/wx.hlp:         $(DOCDIR)/wx.rtf $(DOCDIR)/wx.hpj
+        cd $(DOCDIR)
+        -erase wx.ph
+        hc wx
+        cd $(THISDIR)
+
+$(DOCDIR)/faq.hlp:         $(DOCDIR)/faq.rtf $(DOCDIR)/faq.hpj
+        cd $(DOCDIR)
+        -erase faq.ph
+        hc faq
+        cd $(THISDIR)
+
+$(DOCDIR)/wx.rtf:         $(DOCDIR)/classes.tex $(DOCDIR)/body.tex $(DOCDIR)/manual.tex
+        cd $(DOCDIR)
+        -wx /W tex2rtf $(DOCDIR)/manual.tex $(DOCDIR)/wx.rtf -twice $(WINHELP)
+        cd $(THISDIR)
+
+$(DOCDIR)/faq.rtf:         $(DOCDIR)/faq.tex
+        cd $(DOCDIR)
+        -wx /W tex2rtf $(DOCDIR)/faq.tex $(DOCDIR)/faq.rtf -twice $(WINHELP)
+        cd $(THISDIR)
+
+$(DOCDIR)/faq.xlp:         $(DOCDIR)/faq.tex
+        cd $(DOCDIR)
+        -wx /W tex2rtf $(DOCDIR)/faq.tex $(DOCDIR)/faq.xlp -twice -xlp
+        cd $(THISDIR)
+
+clean:
+        -erase $(OBJECTS1)
+        -erase $(OBJECTS2)
+        -erase $(OBJECTS3)
+        -erase $(LIBTARGET)
+
+cleanall: clean
+        -erase *.pch *.obj ..\lib\*.lib
diff --git a/src/wxmac/src/base/makefile.nt b/src/wxmac/src/base/makefile.nt
new file mode 100644
index 0000000..2384913
--- /dev/null
+++ b/src/wxmac/src/base/makefile.nt
@@ -0,0 +1,265 @@
+#
+# File:		makefile.nt
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "@(#)makefile.nt	1.2 5/9/94"
+#
+#
+#	NT-Specific, using SDK
+#
+!include <ntwin32.mak>
+OS_SPEC=/nologo -DWINNT -DMS_WINDOWS -Dwx_msw
+ALLFLAGS= $(OS_SPEC) $(cflags) $(cvars) $(cdebug)
+
+# Makefile : Builds wxWindows library wx.lib for Windows 3.1
+# Arguments:
+#
+# FINAL=1 argument to nmake to build version with no debugging info.
+# DLL=1 builds a library (wxdll.lib) suitable for creating DLLs.
+#
+# Set WXDIR to the wxWindows directory if env. variable WX not set.
+#
+WXDIR = $(WX)
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASEINC = $(WXDIR)\include\base
+
+INC=/I$(WXINC) /I$(WXBASEINC)
+LIBTARGET= $(WXLIB)\wx.lib
+DUMMY=dummy
+
+#---------------------------------------------------------------------
+# Not yet tested with NT
+#
+#!ifndef FINAL
+#FINAL=0
+#!endif
+
+#!ifndef DLL
+#DLL=0
+#!endif
+
+# Note we optimize anyway, since we don't debug this often, and optimizing
+# doesn't do any harm to this module.
+#!if "$(FINAL)" == "0"
+#OPT = /Od
+#DEBUG_FLAGS= /Zi
+#LINK_DEBUG_FLAGS=/CO
+#!else
+#OPT = /Ox
+#DEBUG_FLAGS=
+#LINK_DEBUG_FLAGS=
+#!endif
+
+#PRECOMP=/YuWX.H
+
+#!if "$(DLL)" == "0"
+#PCH=WX.PCH
+#CPPFLAGS= $(DEBUG_FLAGS) $(INC) /AL /W3 /G2sw $(OPT) /Dwx_msw $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
+#LINKFLAGS=$(LINK_DEBUG_FLAGS) /NOD /ONERROR:NOEXE
+#LIBTARGET= $(WXLIB)\wx.lib
+#DUMMY=dummy
+#!else
+#PCH=WXDLL.PCH
+#CPPFLAGS= $(DEBUG_FLAGS) $(INC) /ALw /W3 /G2sw /GD $(OPT) /Dwx_msw $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
+#LINKFLAGS=$(LINK_DEBUG_FLAGS) /NOD /ONERROR:NOEXE
+#LIBTARGET= $(WXLIB)\wxdll.lib
+#DUMMY=dummydll
+#!endif
+
+# Not used (and not valid.)
+#LIBS=libw llibcew
+#---------------------------------------------------------------------
+
+ITEMS =  $(WXBASEINC)\wb_item.h $(WXBASEINC)\wb_buttn.h $(WXBASEINC)\wb_check.h\
+ $(WXBASEINC)\wb_choic.h $(WXBASEINC)\wb_menu.h $(WXBASEINC)\wb_messg.h\
+ $(WXBASEINC)\wb_txt.h $(WXBASEINC)\wb_mtxt.h $(WXBASEINC)\wb_lbox.h\
+ $(WXBASEINC)\wb_slidr.h
+OBJECTS1 = wb_win.obj wb_frame.obj wb_panel.obj wb_utils.obj wb_main.obj\
+  wb_data.obj wb_item.obj wb_list.obj wb_obj.obj wxstring.obj
+
+OBJECTS2 = wb_text.obj wb_gdi.obj wb_dialg.obj wb_canvs.obj wb_dc.obj wb_mf.obj\
+  wb_ps.obj wb_mgstr.obj
+
+OBJECTS3 = wb_hash.obj wb_ipc.obj wb_form.obj wb_timer.obj wb_help.obj\
+  wb_sysev.obj wb_stdev.obj wb_types.obj wx_enhdg.obj
+
+OBJECTS = $(OBJECTS1) $(OBJECTS2) $(OBJECTS3)
+
+all: $(OBJECTS)
+
+#
+# Not yet nt
+#
+#$(OBJECTS): $(WXDIR)\src\msw\wx.pch
+
+wb_obj.obj:     $(WXBASEINC)\wx_obj.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_win.obj:     $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+  $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_win.cc $(WXBASEINC)\wb_gdi.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_obj.obj:     wb_data.cc
+        cl @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_main.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wx_utils.h\
+  $(WXBASEINC)\wb_main.h wb_main.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_frame.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h wb_frame.cc\
+                $(WXBASEINC)\wx_stdev.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_panel.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_panel.h\
+                wb_panel.cc $(WXBASEINC)\wx_stdev.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_text.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_text.h\
+                wb_text.cc $(WXBASEINC)\wx_stdev.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_canvs.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+                 $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                 $(WXBASEINC)\wb_canvs.h\
+                 wb_canvs.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h\
+                 $(WXBASEINC)\wb_dc.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_dc.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_dc.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_ps.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h\
+              $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_ps.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_dc.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_mf.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h $(WXBASEINC)\wb_canvs.h\
+                 wb_mf.cc $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wb_mf.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_item.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wb_win.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_frame.h\
+                $(ITEMS) wb_item.cc $(WXBASEINC)\wx_stdev.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_utils.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h wb_utils.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_mgstr.obj:   $(WXBASEINC)\wx_mgstr.h wb_mgstr.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_ipc.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_ipc.h wb_ipc.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_list.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h wb_list.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wxstring.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wxstring.h wxstring.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_hash.obj:    $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_hash.h wb_hash.cc $(WXBASEINC)\wx_list.h $(WXBASEINC)\wx_utils.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_event.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wx_obj.h $(WXBASEINC)\wx_stdev.h $(WXBASEINC)\wx_utils.h wb_event.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_gdi.obj:   $(WXBASEINC)\common.h $(WXBASEINC)\wb_gdi.h $(WXBASEINC)\wx_utils.h wb_gdi.cc
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_dialg.obj:   $(WXBASEINC)\common.h wb_dialg.cc $(WXBASEINC)\wb_dialg.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h $(ITEMS)
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_form.obj:   $(WXBASEINC)\common.h wb_form.cc $(WXBASEINC)\wx_form.h $(WXBASEINC)\wb_win.h\
+  $(WXBASEINC)\wx_utils.h $(WXBASEINC)\wb_panel.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_timer.obj:   $(WXBASEINC)\common.h wb_timer.cc $(WXBASEINC)\wb_timer.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_help.obj:   $(WXBASEINC)\common.h wb_help.cc $(WXBASEINC)\wx_help.h $(WXINC)\wx_ipc.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_types.obj:   $(WXBASEINC)\common.h wb_types.cc $(WXBASEINC)\wx_types.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_sysev.obj:   $(WXBASEINC)\common.h wb_sysev.cc $(WXBASEINC)\wx_sysev.h\
+        $(WXBASEINC)\wx_types.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wb_stdev.obj:   $(WXBASEINC)\common.h wb_stdev.cc $(WXBASEINC)\wx_stdev.h\
+        $(WXBASEINC)\wx_types.h $(WXBASEINC)\wx_sysev.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+wx_enhdg.obj:   $(WXBASEINC)\common.h wx_enhdg.cc $(WXBASEINC)\wx_enhdg.h
+        $(cc) @<<
+$(ALLFLAGS) $(INC) /c /Tp $*.cc
+<<
+
+clean:
+        -erase $(OBJECTS1)
+        -erase $(OBJECTS2)
+        -erase $(OBJECTS3)
+        -erase $(LIBTARGET)
+
+cleanall: clean
+        -erase *.pch *.obj ..\lib\*.lib
diff --git a/src/wxmac/src/base/makefile.sc b/src/wxmac/src/base/makefile.sc
new file mode 100644
index 0000000..44e6fb9
--- /dev/null
+++ b/src/wxmac/src/base/makefile.sc
@@ -0,0 +1,123 @@
+# Symantec C++ makefile for the base objects
+# called from src\makefile.sc
+
+# configuration section (see src\makefile.sc) ###########################
+
+WXDIR = $(WXWIN)
+INCDIR = $(WXDIR)\include
+MSWINC = $(INCDIR)\msw
+BASEINC = $(INCDIR)\base
+
+# default values overridden by src\makefile.sc
+
+CC=sc
+CFLAGS = -o -ml -W -Dwx_msw
+
+INCLUDE=$(BASEINC);$(MSWINC);$(WXDIR)\contrib\fafa
+
+OPTIONS=
+
+# end of configuration section ##########################################
+
+.cc.obj:
+	*$(CC) -c $(CFLAGS) -I$(INCLUDE) $(OPTIONS) $<
+
+OBJS = wb_win.obj wb_data.obj wb_frame.obj wb_panel.obj wb_utils.obj wb_main.obj \
+wb_item.obj wb_list.obj wb_obj.obj wb_text.obj wb_gdi.obj wb_dialg.obj \
+wb_canvs.obj wb_dc.obj wb_mf.obj wb_ps.obj wx_enhdg.obj wb_hash.obj \
+wb_ipc.obj wb_form.obj wb_timer.obj wb_help.obj wb_sysev.obj wb_stdev.obj \
+wb_types.obj wb_mgstr.obj
+
+HDRS = $(BASEINC)\wb_item.h $(BASEINC)\wb_buttn.h \
+$(BASEINC)\wb_check.h $(BASEINC)\wb_choic.h $(BASEINC)\wb_menu.h \
+$(BASEINC)\wb_messg.h $(BASEINC)\wb_txt.h $(BASEINC)\wb_mtxt.h \
+$(BASEINC)\wb_lbox.h $(BASEINC)\wb_slidr.h
+
+all: $(OBJS)
+
+wb_obj.obj: $(BASEINC)\wx_obj.h
+
+wb_win.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h
+
+wb_main.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wb_frame.h $(BASEINC)\wx_utils.h
+
+wb_frame.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h \
+$(BASEINC)\wx_obj.h $(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h \
+wb_frame.cc $(BASEINC)\wx_stdev.h
+
+wb_panel.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h \
+$(BASEINC)\wx_obj.h $(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h \
+$(BASEINC)\wb_panel.h wb_panel.cc $(BASEINC)\wx_stdev.h
+
+wb_text.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h $(BASEINC)\wb_text.h \
+wb_text.cc $(BASEINC)\wx_stdev.h
+
+wb_canvs.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h \
+$(BASEINC)\wx_obj.h $(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h \
+$(BASEINC)\wb_canvs.h wb_canvs.cc $(BASEINC)\wx_stdev.h \
+$(BASEINC)\wb_gdi.h $(BASEINC)\wb_dc.h
+
+wb_dc.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h $(BASEINC)\wb_canvs.h \
+wb_dc.cc $(BASEINC)\wx_stdev.h $(BASEINC)\wb_gdi.h $(BASEINC)\wb_dc.h
+
+wb_ps.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h $(BASEINC)\wb_canvs.h \
+wb_ps.cc $(BASEINC)\wx_stdev.h $(BASEINC)\wb_gdi.h $(BASEINC)\wb_dc.h
+
+wb_mf.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h $(BASEINC)\wb_canvs.h \
+wb_mf.cc $(BASEINC)\wx_stdev.h $(BASEINC)\wb_gdi.h $(BASEINC)\wb_mf.h
+
+wb_item.obj: $(BASEINC)\common.h $(BASEINC)\wb_win.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_frame.h $(HDRS) wb_item.cc \
+$(BASEINC)\wx_stdev.h
+
+wb_utils.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h wb_utils.cc
+
+wb_ipc.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_utils.h $(BASEINC)\wb_ipc.h wb_ipc.cc
+
+wb_list.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_list.h $(BASEINC)\wx_utils.h wb_list.cc
+
+wb_hash.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_hash.h wb_hash.cc $(BASEINC)\wx_list.h \
+$(BASEINC)\wx_utils.h
+
+wb_event.obj: $(BASEINC)\common.h $(BASEINC)\wx_obj.h \
+$(BASEINC)\wx_stdev.h $(BASEINC)\wx_utils.h wb_event.cc
+
+wb_gdi.obj: $(BASEINC)\common.h $(BASEINC)\wb_gdi.h \
+$(BASEINC)\wx_utils.h wb_gdi.cc
+
+wb_dialg.obj: $(BASEINC)\common.h wb_dialg.cc $(BASEINC)\wb_dialg.h \
+$(BASEINC)\wb_win.h $(BASEINC)\wx_utils.h $(BASEINC)\wb_panel.h $(HDRS)
+
+wb_form.obj: $(BASEINC)\common.h wb_form.cc $(BASEINC)\wx_form.h \
+$(BASEINC)\wb_win.h $(BASEINC)\wx_utils.h $(BASEINC)\wb_panel.h
+
+wb_timer.obj: $(BASEINC)\common.h wb_timer.cc $(BASEINC)\wb_timer.h
+
+wb_help.obj: $(BASEINC)\common.h wb_help.cc $(BASEINC)\wx_help.h \
+$(MSWINC)\wx_ipc.h
+
+wb_types.obj: $(BASEINC)\common.h wb_types.cc $(BASEINC)\wx_types.h
+
+wb_mgstr.obj: $(BASEINC)\common.h $(BASEINC)\wx_mgstr.h wb_mgstr.cc
+
+wb_sysev.obj: $(BASEINC)\common.h wb_sysev.cc $(BASEINC)\wx_sysev.h \
+$(BASEINC)\wx_types.h
+
+wb_stdev.obj: $(BASEINC)\common.h wb_stdev.cc $(BASEINC)\wx_stdev.h \
+$(BASEINC)\wx_types.h $(BASEINC)\wx_sysev.h
+
+wx_enhdg.obj: $(BASEINC)\common.h wx_enhdg.cc $(BASEINC)\wx_enhdg.h
+
+wb_data.obj: $(BASEINC)\common.h wb_data.cc
+
+clean:
+	-del *.obj
diff --git a/src/wxmac/src/base/makefile.sun b/src/wxmac/src/base/makefile.sun
new file mode 100644
index 0000000..2d4cc31
--- /dev/null
+++ b/src/wxmac/src/base/makefile.sun
@@ -0,0 +1,235 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile for wxWindows: generates libwx_ol.a/libwx_motif.a
+
+CC = gcc
+GUISUFFIX=_ol
+
+# Replace X include/lib directories with your own, e.g. -I/usr/openwin/include ...
+#XINCLUDE=-I/aiai/packages/prokappa2.0/X/usr/include -I/aiai/packages/X.V11R5/include
+#XLIB=-L/aiai/packages/X.V11R5/lib -L/aiai/packages/prokappa2.0/X/usr/lib
+XINCLUDE=-I/usr/openwin/include
+XLIB=-L/usr/openwin/lib
+
+# Replace this with your own path
+WXDIR = ../..
+
+# From here on down we should be generic
+WXINC = $(WXDIR)/include/x
+WXBASEINC = $(WXDIR)/include/base
+WXLIB = $(WXDIR)/lib/libwx.a
+OBJDIR = objects$(GUISUFFIX)
+DOCUTILSDIR = $(WXDIR)/utils/tex2rtf/src
+
+INC = -I$(WXDIR)/include -I$(WXINC) -I$(WXBASEINC)
+
+# Compiler flags.
+#DEBUG = -ggdb
+WARN = -Wall
+GUI = -Dwx_xview
+OPTIONS = -O2 
+# OPT =
+
+# May need to add -D_HPUX_SOURCE_ for HPUX
+CPPFLAGS = $(XINCLUDE) $(INC) $(OPTIONS) $(GUI) $(DEBUG) $(WARN)
+CFLAGS =
+LDFLAGS =  $(XLIB) -L$(WXDIR)/lib
+
+OBJECTS = $(OBJDIR)/wb_main.o $(OBJDIR)/wb_win.o $(OBJDIR)/wb_frame.o \
+$(OBJDIR)/wb_canvs.o $(OBJDIR)/wb_panel.o $(OBJDIR)/wb_item.o \
+$(OBJDIR)/wb_text.o $(OBJDIR)/wb_list.o $(OBJDIR)/wb_utils.o \
+$(OBJDIR)/wb_obj.o $(OBJDIR)/wb_help.o $(OBJDIR)/wb_gdi.o \
+$(OBJDIR)/wb_dialg.o $(OBJDIR)/wb_dc.o $(OBJDIR)/wb_mf.o $(OBJDIR)/wb_ipc.o \
+$(OBJDIR)/wb_timer.o $(OBJDIR)/wb_types.o $(OBJDIR)/wb_sysev.o \
+$(OBJDIR)/wb_form.o $(OBJDIR)/wb_hash.o $(OBJDIR)/wb_ps.o \
+$(OBJDIR)/wb_stdev.o $(OBJDIR)/wb_sysev.o $(OBJDIR)/wb_mgstr.o \
+$(OBJDIR)/wx_enhdg.o $(OBJDIR)/wxstring.o \
+$(OBJDIR)/wb_data.o
+
+all:    $(OBJDIR) $(OBJECTS)
+
+# Clear the default suffix list
+.SUFFIXES:
+
+motif:
+	make -f makefile.unx GUI=-Dwx_motif GUISUFFIX=_motif
+
+xview:
+	make -f makefile.unx GUI=-Dwx_xview GUISUFFIX=_ol
+
+hp:
+	make -f makefile.unx GUI=-Dwx_motif DEBUG='-g' GUISUFFIX=_hp CC=CC WARN='-w' \
+           XINCLUDE='-I/usr/include/Motif1.2 -I/usr/include/X11R5' \
+           XLIB='-L/usr/lib/Motif1.2 -L/usr/lib/X11R5'
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+$(OBJECTS):	$(WXBASEINC)/common.h $(WXBASEINC)/wx_obj.h
+$(OBJDIR)/wb_win.o:	wb_win.cc $(WXINC)/wx_win.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_win.cc
+
+$(OBJDIR)/wb_frame.o:	wb_frame.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_main.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_frame.cc
+
+$(OBJDIR)/wb_panel.o:	wb_panel.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h \
+                $(WXINC)/wx_panel.h $(WXBASEINC)/wx_stdev.h $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_panel.cc
+
+$(OBJDIR)/wb_canvs.o:	wb_canvs.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_canvs.cc
+
+$(OBJDIR)/wb_dc.o:        wb_dc.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_dc.cc
+
+$(OBJDIR)/wb_ps.o:        wb_ps.cc $(WXINC)/wx_win.h $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_ps.cc
+
+$(OBJDIR)/wb_mf.o:        wb_mf.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXINC)/wx_mf.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_mf.cc
+
+$(OBJDIR)/wb_text.o:	wb_text.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_text.h $(WXBASEINC)/wx_stdev.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_text.cc
+
+$(OBJDIR)/wb_item.o:	wb_item.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_panel.h $(WXINC)/wx_item.h $(WXBASEINC)/wx_stdev.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_item.cc
+
+$(OBJDIR)/wb_main.o:	wb_main.cc $(WXINC)/wx_main.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_main.cc
+
+$(OBJDIR)/wb_obj.o:	wb_obj.cc $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_obj.cc
+
+# $(OBJDIR)/wb_event.o:     wb_event.cc $(WXBASEINC)/wx_stdev.h
+# 	$(CC) -c $(CPPFLAGS) -o $@ wb_event.cc
+
+$(OBJDIR)/wb_list.o:	wb_list.cc $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_list.cc
+
+$(OBJDIR)/wxstring.o:	wxstring.cc $(WXBASEINC)/wxstring.h
+	$(CC) -c $(CPPFLAGS) -o $@ wxstring.cc
+
+$(OBJDIR)/wb_hash.o:      wb_hash.cc $(WXBASEINC)/wx_list.h $(WXBASEINC)/wx_hash.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_hash.cc
+
+$(OBJDIR)/wb_gdi.o:	wb_gdi.cc $(WXINC)/wx_gdi.h $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_gdi.cc
+
+$(OBJDIR)/wb_ipc.o:	wb_ipc.cc $(WXINC)/wx_ipc.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_ipc.cc
+
+$(OBJDIR)/wb_dialg.o:	wb_dialg.cc $(WXINC)/wx_dialg.h $(WXINC)/wx_panel.h $(WXINC)/wx_win.h $(WXINC)/wx_item.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_dialg.cc
+
+$(OBJDIR)/wb_form.o:      wb_form.cc $(WXBASEINC)/wx_form.h $(WXINC)/wx_panel.h $(WXINC)/wx_win.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_form.cc
+
+$(OBJDIR)/wb_timer.o:     wb_timer.cc $(WXINC)/wx_timer.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_timer.cc
+
+$(OBJDIR)/wb_help.o:	wb_help.cc $(WXBASEINC)/wx_help.h $(WXINC)/wx_ipc.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_help.cc
+
+$(OBJDIR)/wb_types.o:	wb_types.cc $(WXBASEINC)/wx_types.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_types.cc
+
+$(OBJDIR)/wb_mgstr.o:	wb_mgstr.cc $(WXBASEINC)/wx_mgstr.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_mgstr.cc
+
+$(OBJDIR)/wb_sysev.o:	wb_sysev.cc $(WXBASEINC)/wx_sysev.h $(WXBASEINC)/wx_types.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_sysev.cc
+
+$(OBJDIR)/wb_stdev.o:	wb_stdev.cc $(WXBASEINC)/wx_sysev.h $(WXBASEINC)/wx_stdev.h $(WXBASEINC)/wx_types.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_stdev.cc
+
+$(OBJDIR)/wb_utils.o:     wb_utils.cc $(WXBASEINC)/wx_utils.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_utils.cc
+
+$(OBJDIR)/wx_enhdg.o:     wx_enhdg.cc $(WXBASEINC)/wx_enhdg.h $(WXBASEINC)/wx_obj.h $(WXINC)/wx_dialg.h
+	$(CC) -c $(CPPFLAGS) -o $@ wx_enhdg.cc
+
+$(OBJDIR)/wb_data.o: wb_data.cc
+	$(CC) -c $(CPPFLAGS) -o $@ wb_data.cc
+
+$(WXINC)/wx_win.h:  $(WXBASEINC)/wb_win.h
+$(WXINC)/wx_main.h:  $(WXBASEINC)/wb_main.h
+$(WXINC)/wx_frame.h:  $(WXBASEINC)/wb_frame.h
+$(WXINC)/wx_panel.h:  $(WXBASEINC)/wb_panel.h
+$(WXINC)/wx_text.h:  $(WXBASEINC)/wb_text.h
+$(WXINC)/wx_dialg.h:  $(WXBASEINC)/wb_dialg.h
+$(WXINC)/wx_ipc.h:  $(WXBASEINC)/wb_ipc.h
+$(WXINC)/wx_gdi.h:  $(WXBASEINC)/wb_gdi.h
+$(WXINC)/wx_canvs.h:  $(WXBASEINC)/wb_canvs.h
+$(WXINC)/wx_mf.h:  $(WXBASEINC)/wb_mf.h
+$(WXINC)/wx_item.h:  $(WXBASEINC)/wb_item.h
+$(WXINC)/wx_buttn.h:  $(WXBASEINC)/wb_buttn.h
+$(WXINC)/wx_messg.h:  $(WXBASEINC)/wb_messg.h
+$(WXINC)/wx_choic.h:  $(WXBASEINC)/wb_choic.h
+$(WXINC)/wx_check.h:  $(WXBASEINC)/wb_check.h
+$(WXINC)/wx_lbox.h:  $(WXBASEINC)/wb_lbox.h
+$(WXINC)/wx_txt.h:  $(WXBASEINC)/wb_txt.h
+$(WXINC)/wx_mtxt.h:  $(WXBASEINC)/wb_mtxt.h
+$(WXINC)/wx_slidr.h:  $(WXBASEINC)/wb_slidr.h
+$(WXINC)/wx_menu.h:  $(WXBASEINC)/wb_menu.h
+$(WXBASEINC)/wx_enhdg.h:	$(WXINC)/wx_dialg.h
+
+$(OBJECTS):	$(WXBASEINC)/wx_setup.h
+
+docs:	ps xlp # html
+
+ps:	$(WXDIR)/docs/manual.ps $(WXDIR)/docs/referenc.ps
+xlp:	$(WXDIR)/docs/wx.xlp
+html:	$(WXDIR)/docs/wx_contents.html
+
+$(WXDIR)/docs/manual.dvi:	$(WXDIR)/docs/manual.tex $(WXDIR)/docs/body.tex
+	cd $(WXDIR)/docs; latex manual; latex manual; makeindex manual; latex manual
+
+$(WXDIR)/docs/manual.ps:	$(WXDIR)/docs/manual.dvi
+	cd $(WXDIR)/docs; dvips -f -r < manual.dvi > manual.ps
+
+$(WXDIR)/docs/referenc.dvi:	$(WXDIR)/docs/referenc.tex $(WXDIR)/docs/classes.tex
+	cd $(WXDIR)/docs; latex referenc; latex referenc; makeindex referenc; latex referenc
+
+$(WXDIR)/docs/referenc.ps:	$(WXDIR)/docs/referenc.dvi
+	cd $(WXDIR)/docs; dvips -f -r < referenc.dvi > referenc.ps
+
+$(WXDIR)/docs/wx.xlp:	$(WXDIR)/docs/classes.tex $(WXDIR)/docs/manual.tex
+	cd ../../docs; tex2rtf manual.tex tmp.xlp -xlp -twice
+	sed -e "s/WXHELPCONTENTS/wxWindows Manual/g" < $(WXDIR)/docs/tmp.xlp > $(WXDIR)/docs/wx.xlp
+	/bin/rm -f $(WXDIR)/docs/tmp.xlp
+
+$(WXDIR)/docs/wx_contents.html:	$(WXDIR)/docs/classes.tex $(WXDIR)/docs/manual.tex
+	cd ../../docs; tex2rtf manual.tex wx.html -html -twice
+	/bin/cp ../../docs/*.html /user/11/jacs/html/wx
+	/bin/rm ../../docs/*.html
+
+alldocs:	docs
+	cd $(WXDIR)/utils/hytext/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/prologio/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/toolbar/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxclips/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxhelp/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/tex2rtf/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxtree/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxgraph/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxbuild/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/clips2c/src; make -f makefile.unx docs
+
+clean:
+	rm -f $(OBJECTS) core $(WXLIB)
diff --git a/src/wxmac/src/base/makefile.unx b/src/wxmac/src/base/makefile.unx
new file mode 100644
index 0000000..23d2125
--- /dev/null
+++ b/src/wxmac/src/base/makefile.unx
@@ -0,0 +1,231 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "@(#)makefile.unx	1.2 5/9/94"
+#
+# Makefile for wxWindows: generates libwx_ol.a/libwx_motif.a
+
+WXDIR = ../..
+
+# All common UNIX compiler flags and options are now in
+# this central makefile.
+include $(WXDIR)/src/make.env
+
+OBJECTS = $(OBJDIR)/wb_data.o \
+$(OBJDIR)/wb_main.o $(OBJDIR)/wb_win.o $(OBJDIR)/wb_frame.o \
+$(OBJDIR)/wb_canvs.o $(OBJDIR)/wb_panel.o $(OBJDIR)/wb_item.o \
+$(OBJDIR)/wb_text.o $(OBJDIR)/wb_list.o $(OBJDIR)/wb_utils.o \
+$(OBJDIR)/wb_obj.o $(OBJDIR)/wb_help.o $(OBJDIR)/wb_gdi.o \
+$(OBJDIR)/wb_dialg.o $(OBJDIR)/wb_dc.o $(OBJDIR)/wb_mf.o $(OBJDIR)/wb_ipc.o \
+$(OBJDIR)/wb_timer.o $(OBJDIR)/wb_types.o $(OBJDIR)/wb_sysev.o \
+$(OBJDIR)/wb_form.o $(OBJDIR)/wb_hash.o $(OBJDIR)/wb_ps.o \
+$(OBJDIR)/wb_stdev.o $(OBJDIR)/wb_sysev.o $(OBJDIR)/wb_mgstr.o \
+$(OBJDIR)/wx_enhdg.o $(OBJDIR)/wxstring.o $(OBJDIR)/wb_res.o
+
+all:    $(OBJDIR) $(OBJECTS)
+
+# Clear the default suffix list
+.SUFFIXES:
+
+motif:
+	make -f makefile.unx GUI=-Dwx_motif GUISUFFIX=_motif CC=$(CC) OPTIONS='$(OPTIONS)' DEBUG='$(DEBUG)' WARN='$(WARN)' XLIB='$(XLIB)' XINCLUDE='$(XINCLUDE)'
+
+xview:
+	make -f makefile.unx GUI=-Dwx_xview GUISUFFIX=_ol CC=$(CC) OPTIONS='$(OPTIONS)' DEBUG='$(DEBUG)' WARN='$(WARN)' XLIB='$(XLIB)' XINCLUDE='$(XINCLUDE)'
+
+hp:
+	make -f makefile.unx GUI=-Dwx_motif DEBUG='-g' GUISUFFIX=_hp CC=CC WARN='-w' \
+           XINCLUDE='$(HPXINCLUDE)' \
+           XLIB='$(HPXLIB)'
+
+$(OBJDIR):
+	mkdir $(OBJDIR)
+
+$(OBJECTS):	$(WXBASEINC)/common.h $(WXBASEINC)/wx_obj.h
+$(OBJDIR)/wb_win.o:	wb_win.cc $(WXINC)/wx_win.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_win.cc
+
+$(OBJDIR)/wb_data.o:	wb_data.cc
+	$(CC) -c $(CPPFLAGS) -o $@ wb_data.cc
+
+$(OBJDIR)/wb_frame.o:	wb_frame.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_main.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_frame.cc
+
+$(OBJDIR)/wb_panel.o:	wb_panel.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h \
+                $(WXINC)/wx_panel.h $(WXBASEINC)/wx_stdev.h $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_panel.cc
+
+$(OBJDIR)/wb_canvs.o:	wb_canvs.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_canvs.cc
+
+$(OBJDIR)/wb_dc.o:        wb_dc.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_dc.cc
+
+$(OBJDIR)/wb_ps.o:        wb_ps.cc $(WXINC)/wx_win.h $(WXBASEINC)/wx_list.h $(WXINC)/wx_dc.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_ps.cc
+
+$(OBJDIR)/wb_mf.o:        wb_mf.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_canvs.h $(WXBASEINC)/wx_stdev.h $(WXINC)/wx_gdi.h\
+                $(WXINC)/wx_mf.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_mf.cc
+
+$(OBJDIR)/wb_text.o:	wb_text.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_text.h $(WXBASEINC)/wx_stdev.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_text.cc
+
+$(OBJDIR)/wb_item.o:	wb_item.cc $(WXINC)/wx_win.h $(WXINC)/wx_frame.h\
+                $(WXINC)/wx_panel.h $(WXINC)/wx_item.h $(WXBASEINC)/wx_stdev.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_item.cc
+
+$(OBJDIR)/wb_main.o:	wb_main.cc $(WXINC)/wx_main.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_main.cc
+
+$(OBJDIR)/wb_obj.o:	wb_obj.cc $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_obj.cc
+
+# $(OBJDIR)/wb_event.o:     wb_event.cc $(WXBASEINC)/wx_stdev.h
+# 	$(CC) -c $(CPPFLAGS) -o $@ wb_event.cc
+
+$(OBJDIR)/wb_list.o:	wb_list.cc $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_list.cc
+
+$(OBJDIR)/wxstring.o:	wxstring.cc $(WXBASEINC)/wxstring.h
+	$(CC) -c $(CPPFLAGS) -o $@ wxstring.cc
+
+$(OBJDIR)/wb_hash.o:      wb_hash.cc $(WXBASEINC)/wx_list.h $(WXBASEINC)/wx_hash.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_hash.cc
+
+$(OBJDIR)/wb_gdi.o:	wb_gdi.cc $(WXINC)/wx_gdi.h $(WXBASEINC)/wx_list.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_gdi.cc
+
+$(OBJDIR)/wb_ipc.o:	wb_ipc.cc $(WXINC)/wx_ipc.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_ipc.cc
+
+$(OBJDIR)/wb_dialg.o:	wb_dialg.cc $(WXINC)/wx_dialg.h $(WXINC)/wx_panel.h $(WXINC)/wx_win.h $(WXINC)/wx_item.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_dialg.cc
+
+$(OBJDIR)/wb_form.o:      wb_form.cc $(WXBASEINC)/wx_form.h $(WXINC)/wx_panel.h $(WXINC)/wx_win.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_form.cc
+
+$(OBJDIR)/wb_timer.o:     wb_timer.cc $(WXINC)/wx_timer.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_timer.cc
+
+$(OBJDIR)/wb_help.o:	wb_help.cc $(WXBASEINC)/wx_help.h $(WXINC)/wx_ipc.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_help.cc
+
+$(OBJDIR)/wb_types.o:	wb_types.cc $(WXBASEINC)/wx_types.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_types.cc
+
+$(OBJDIR)/wb_mgstr.o:	wb_mgstr.cc $(WXBASEINC)/wx_mgstr.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_mgstr.cc
+
+$(OBJDIR)/wb_res.o:	wb_res.cc $(WXBASEINC)/wx_res.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_res.cc
+
+$(OBJDIR)/wb_sysev.o:	wb_sysev.cc $(WXBASEINC)/wx_sysev.h $(WXBASEINC)/wx_types.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_sysev.cc
+
+$(OBJDIR)/wb_stdev.o:	wb_stdev.cc $(WXBASEINC)/wx_sysev.h $(WXBASEINC)/wx_stdev.h $(WXBASEINC)/wx_types.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_stdev.cc
+
+$(OBJDIR)/wb_utils.o:     wb_utils.cc $(WXBASEINC)/wx_utils.h $(WXBASEINC)/wx_obj.h
+	$(CC) -c $(CPPFLAGS) -o $@ wb_utils.cc
+
+$(OBJDIR)/wx_enhdg.o:     wx_enhdg.cc $(WXBASEINC)/wx_enhdg.h $(WXBASEINC)/wx_obj.h $(WXINC)/wx_dialg.h
+	$(CC) -c $(CPPFLAGS) -o $@ wx_enhdg.cc
+
+$(WXINC)/wx_win.h:  $(WXBASEINC)/wb_win.h
+$(WXINC)/wx_main.h:  $(WXBASEINC)/wb_main.h
+$(WXINC)/wx_frame.h:  $(WXBASEINC)/wb_frame.h
+$(WXINC)/wx_panel.h:  $(WXBASEINC)/wb_panel.h
+$(WXINC)/wx_text.h:  $(WXBASEINC)/wb_text.h
+$(WXINC)/wx_dialg.h:  $(WXBASEINC)/wb_dialg.h
+$(WXINC)/wx_ipc.h:  $(WXBASEINC)/wb_ipc.h
+$(WXINC)/wx_gdi.h:  $(WXBASEINC)/wb_gdi.h
+$(WXINC)/wx_canvs.h:  $(WXBASEINC)/wb_canvs.h
+$(WXINC)/wx_mf.h:  $(WXBASEINC)/wb_mf.h
+$(WXINC)/wx_item.h:  $(WXBASEINC)/wb_item.h
+$(WXINC)/wx_buttn.h:  $(WXBASEINC)/wb_buttn.h
+$(WXINC)/wx_messg.h:  $(WXBASEINC)/wb_messg.h
+$(WXINC)/wx_choic.h:  $(WXBASEINC)/wb_choic.h
+$(WXINC)/wx_check.h:  $(WXBASEINC)/wb_check.h
+$(WXINC)/wx_lbox.h:  $(WXBASEINC)/wb_lbox.h
+$(WXINC)/wx_txt.h:  $(WXBASEINC)/wb_txt.h
+$(WXINC)/wx_mtxt.h:  $(WXBASEINC)/wb_mtxt.h
+$(WXINC)/wx_slidr.h:  $(WXBASEINC)/wb_slidr.h
+$(WXINC)/wx_menu.h:  $(WXBASEINC)/wb_menu.h
+$(WXBASEINC)/wx_enhdg.h:	$(WXINC)/wx_dialg.h
+
+$(OBJECTS):	$(WXBASEINC)/wx_setup.h
+
+docs:	ps xlp txt # html
+
+ps:	$(WXDIR)/docs/manual.ps $(WXDIR)/docs/referenc.ps
+xlp:	$(WXDIR)/docs/wx.xlp $(WXDIR)/docs/faq.xlp
+txt:	$(WXDIR)/docs/faq.txt
+html:	$(WXDIR)/docs/wx_contents.html
+faqhtml:	$(WXDIR)/docs/faq_contents.html
+
+$(WXDIR)/docs/manual.dvi:	$(WXDIR)/docs/manual.tex $(WXDIR)/docs/body.tex
+	cd $(WXDIR)/docs; latex manual; latex manual; makeindex manual; latex manual
+
+$(WXDIR)/docs/manual.ps:	$(WXDIR)/docs/manual.dvi
+	cd $(WXDIR)/docs; dvips -f -r < manual.dvi > manual.ps
+
+$(WXDIR)/docs/referenc.dvi:	$(WXDIR)/docs/referenc.tex $(WXDIR)/docs/classes.tex
+	cd $(WXDIR)/docs; latex referenc; latex referenc; makeindex referenc; latex referenc
+
+$(WXDIR)/docs/referenc.ps:	$(WXDIR)/docs/referenc.dvi
+	cd $(WXDIR)/docs; dvips -f -r < referenc.dvi > referenc.ps
+
+$(WXDIR)/docs/wx.xlp:	$(WXDIR)/docs/classes.tex $(WXDIR)/docs/manual.tex
+	cd ../../docs; tex2rtf manual.tex tmp.xlp -xlp -twice
+	sed -e "s/WXHELPCONTENTS/wxWindows Manual/g" < $(WXDIR)/docs/tmp.xlp > $(WXDIR)/docs/wx.xlp
+	/bin/rm -f $(WXDIR)/docs/tmp.xlp
+
+$(WXDIR)/docs/faq.xlp:	$(WXDIR)/docs/faq.tex
+	cd ../../docs; tex2rtf manual.tex tmp.xlp -xlp -twice
+	sed -e "s/WXHELPCONTENTS/wxWindows FAQ/g" < $(WXDIR)/docs/tmp.xlp > $(WXDIR)/docs/faq.xlp
+	/bin/rm -f $(WXDIR)/docs/tmp.xlp
+
+$(WXDIR)/docs/wx_contents.html:	$(WXDIR)/docs/classes.tex $(WXDIR)/docs/manual.tex
+	/bin/rm ../../docs/*.html
+	cd ../../docs; tex2rtf manual.tex wx.html -html -twice
+	/bin/cp ../../docs/*.html /user/11/jacs/html/wx
+	/bin/rm ../../docs/*.html
+
+$(WXDIR)/docs/faq_contents.html:	$(WXDIR)/docs/faq.tex
+	/bin/rm -f ../../docs/*.html
+	cd ../../docs; tex2rtf faq.tex faq.html -html -twice
+	/bin/cp ../../docs/*.html /home/jacs/html/wx/faq
+	/bin/rm ../../docs/*.html
+
+$(WXDIR)/docs/faq.dvi:	$(WXDIR)/docs/faq.tex
+	cd $(WXDIR)/docs; latex faq; latex faq; makeindex faq; latex faq
+
+$(WXDIR)/docs/faq.txt:	$(WXDIR)/docs/faq.dvi
+	cd ../../docs; dvi2tty faq.dvi > faq.txt
+
+alldocs:	docs
+	cd $(WXDIR)/utils/hytext/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/prologio/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/toolbar/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxclips/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxhelp/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/tex2rtf/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxtree/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxgraph/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/wxbuild/src; make -f makefile.unx docs
+	cd $(WXDIR)/utils/clips2c/src; make -f makefile.unx docs
+
+clean:
+	rm -f $(OBJECTS) core $(WXLIB)
diff --git a/src/wxmac/src/base/makefile.w32 b/src/wxmac/src/base/makefile.w32
new file mode 100644
index 0000000..2caf2ac
--- /dev/null
+++ b/src/wxmac/src/base/makefile.w32
@@ -0,0 +1,32 @@
+#
+# File:		makefile.w32
+# Author:	
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# Makefile : Builds wxWindows library wx.lib for Windows 3.1
+# and Watcom 32
+
+WXDIR = ..\..
+THISDIR = $(WXDIR)\src\msw
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASESRC = $(WXDIR)\src\base
+WXBASEINC = $(WXDIR)\include\base
+OPT= /ox
+
+CPPFLAGS= /Dwx_msw=1 $(DEBUG_FLAGS) -I$(WXINC) -I$(WXBASEINC) $(OPT)
+
+.cc.obj:
+	wcl386 $(CPPFLAGS) bt=windows $<
+
+BASE1 = wb_win.obj wb_frame.obj  wb_panel.obj wb_utils.obj wb_main.obj 
+BASE2 = wb_item.obj wb_list.obj wb_obj.obj wb_ps.obj wb_text.obj wb_gdi.obj 
+BASE3 =	wb_dialg.obj wb_canvs.obj wb_dc.obj wb_mf.obj wb_hash.obj wb_ipc.obj 
+BASE4 =	wb_form.obj wb_timer.obj wb_help.obj wb_sysev.obj wb_stdev.obj 
+BASE5 =	wb_types.obj  wb_mgstr.obj wxstring.obj wb_data.obj
+
+all:	$(BASE1) $(BASE2) $(BASE3) $(BASE4) $(BASE5)
+
+
diff --git a/src/wxmac/src/base/makefile.wat b/src/wxmac/src/base/makefile.wat
new file mode 100644
index 0000000..83c9984
--- /dev/null
+++ b/src/wxmac/src/base/makefile.wat
@@ -0,0 +1,49 @@
+#
+# Makefile for WATCOM C++
+#
+# Edwin Thaler	July 1994
+# Dmitri Chubraev Nov. 1994
+#
+.SUFFIXES
+.SUFFIXES : .obj .cc
+
+WXDIR = ..\..
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASEINC = $(WXDIR)\include\base
+DOCDIR = $(WXDIR)\docs
+DOCUTILSDIR = $(WXDIR)\utils\tex2rtf\src
+THISDIR = $(WXDIR)\src\base
+INC=/I$(WXINC) /I$(WXBASEINC)
+
+CXXFLAGS = /zw /w1 /d1 /od /zq $(INC) -dwx_msw  
+CC =wpp386
+
+.cc.obj : .AUTODEPEND
+	$(CC) $(CXXFLAGS) $[*
+
+
+ITEMS =  $(WXBASEINC)\wb_item.h $(WXBASEINC)\wb_buttn.h  &
+	$(WXBASEINC)\wb_check.h $(WXBASEINC)\wb_choic.h  &
+	$(WXBASEINC)\wb_menu.h $(WXBASEINC)\wb_messg.h  &
+	$(WXBASEINC)\wb_txt.h $(WXBASEINC)\wb_mtxt.h  &
+	$(WXBASEINC)\wb_lbox.h $(WXBASEINC)\wb_slidr.h &
+	$(WXBASEINC)\wb_rbox.h $(WXBASEINC)\wx_setup.h
+	
+
+OBJECTS = wb_win.obj wb_frame.obj wb_panel.obj wb_utils.obj  &
+	wb_main.obj wb_item.obj wb_list.obj wb_obj.obj &
+	wb_text.obj wb_gdi.obj wb_dialg.obj wb_canvs.obj  &
+	wb_dc.obj wb_mf.obj wb_ps.obj wx_enhdg.obj &
+	wb_hash.obj wb_ipc.obj wb_form.obj wb_timer.obj  &
+	wb_help.obj wb_sysev.obj wb_stdev.obj wb_types.obj  &
+	wb_mgstr.obj wxstring.obj wb_data.obj
+
+
+all : $(OBJECTS)
+	-echo "OBJECTs done" >all
+
+clean :
+	del *.OBJ
+
+#$(OBJECTS) : $(ITEMS)
diff --git a/src/wxmac/src/base/wb_canvs.cc b/src/wxmac/src/base/wb_canvs.cc
new file mode 100644
index 0000000..904fc81
--- /dev/null
+++ b/src/wxmac/src/base/wb_canvs.cc
@@ -0,0 +1,319 @@
+/*
+ * File:	wb_canvs.cc
+ * Purpose:	wxbCanvas implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_canvs.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_canvs.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_dc.h"
+#include "wx_canvs.h"
+
+#include "wx.h"
+
+class wxFrame;
+
+#ifndef wx_mac
+wxbCanvas::wxbCanvas(void)
+{
+  __type = wxTYPE_CANVAS;
+}
+#endif // wx_mac
+
+#ifndef wx_mac
+wxbCanvas::wxbCanvas(wxWindow *window, int x, int y, int width, int height, long style,
+                     char *name)
+{
+  __type = wxTYPE_CANVAS;
+  windowStyle = style;
+}
+#endif // wx_mac
+#ifdef wx_mac
+// Constructor (given parentArea)
+wxbCanvas::wxbCanvas (char* windowName, wxArea* parentArea, int x, int y,
+		int width, int height, long style)
+  : wxWindow ( windowName, parentArea, x, y, width, height, style),
+		is_retained (FALSE), // Can only be retained after scrollbars have been set
+		horiz_units (0),
+		vert_units (0)
+{
+  __type = wxTYPE_CANVAS;
+  windowStyle = style;
+}
+
+// Constructor (given parentWindow)
+wxbCanvas::wxbCanvas(char* windowName, wxWindow* parentWindow, int x, int y,
+		int width, int height, long style) 
+  : wxWindow ( windowName, parentWindow, x, y, width, height, style),
+		is_retained (FALSE), // Can only be retained after scrollbars have been set
+		horiz_units (0),
+		vert_units (0)
+{
+  __type = wxTYPE_CANVAS;
+  windowStyle = style;
+}
+#endif // wx_mac
+
+wxbCanvas::~wxbCanvas(void)
+{
+}
+
+void wxbCanvas::AllowDoubleClick(int value)
+{
+  doubleClickAllowed = value ;
+}
+
+void wxbCanvas::SetClippingRegion(float cx, float cy, float cw, float ch)
+{
+  wx_dc->SetClippingRegion(cx, cy, cw, ch);
+}
+
+void wxbCanvas::GetClippingRegion(float *cx, float *cy, float *cw, float *ch)
+{
+  wx_dc->GetClippingRegion(cx, cy, cw, ch);
+}
+
+void wxbCanvas::DestroyClippingRegion(void)
+{
+  wx_dc->DestroyClippingRegion();
+}
+
+wxCanvasDC *wxbCanvas::GetDC(void)
+{
+  return wx_dc;
+}
+
+void wxbCanvas::Clear(void)
+{
+  wx_dc->Clear();
+}
+
+// Default input behaviour for a scrolling canvas should be to scroll
+// according to the cursor keys pressed
+void wxbCanvas::OnChar(wxKeyEvent& event)
+{
+  int x_page = 0;
+  int y_page = 0;
+  int start_x = 0;
+  int start_y = 0;
+  GetScrollUnitsPerPage(&x_page, &y_page);
+  ViewStart(&start_x, &start_y);
+
+  switch (event.keyCode)
+  {
+    case WXK_PRIOR:
+    {
+      if ((y_page > 0) && (start_y >= y_page))
+        Scroll(start_x, start_y - y_page);
+      break;
+    }
+    case WXK_NEXT:
+    {
+      if (y_page > 0)
+        Scroll(start_x, start_y + y_page);
+      break;
+    }
+    case WXK_UP:
+    {
+      if ((y_page > 0) && (start_y >= 1))
+        Scroll(start_x, start_y - 1);
+      break;
+    }
+    case WXK_DOWN:
+    {
+      if (y_page > 0)
+        Scroll(start_x, start_y + 1);
+      break;
+    }
+    case WXK_LEFT:
+    {
+      if ((x_page > 0) && (start_x >= 1))
+        Scroll(start_x - 1, start_y);
+      break;
+    }
+    case WXK_RIGHT:
+    {
+      if (x_page > 0)
+        Scroll(start_x + 1, start_y);
+      break;
+    }
+    case WXK_HOME:
+    {
+      Scroll(0, 0);
+      break;
+    }
+  }
+}
+
+void wxbCanvas::FloodFill(float x, float y, wxColour *col, int style)
+{
+      wx_dc->FloodFill(x,y,col,style) ;
+}
+
+Bool wxbCanvas::GetPixel(float x, float y, wxColour *col)
+{
+  return wx_dc->GetPixel(x,y,col) ;
+}
+
+void wxbCanvas::DrawLine(float x1, float y1, float x2, float y2)
+{
+  wx_dc->DrawLine(x1, y1, x2, y2);
+}
+
+void wxbCanvas::IntDrawLine(int x1, int y1, int x2, int y2)
+{
+  wx_dc->IntDrawLine(x1, y1, x2, y2);
+}
+
+void wxbCanvas::CrossHair(float x, float y)
+{
+  wx_dc->CrossHair(x, y);
+}
+
+void wxbCanvas::DrawArc(float x1,float y1,float x2,float y2,float xc,float yc)
+{
+  wx_dc->DrawArc(x1, y1, x2, y2,xc,yc);
+}
+
+void wxbCanvas::DrawPoint(float x, float y)
+{
+  wx_dc->DrawPoint(x, y);
+}
+
+void wxbCanvas::DrawPolygon(int n, wxPoint points[], float xoffset, float yoffset,int fillStyle)
+{
+  wx_dc->DrawPolygon(n, points, xoffset, yoffset,fillStyle);
+}
+
+void wxbCanvas::DrawPolygon(wxList *list, float xoffset, float yoffset,int fillStyle)
+{
+  ((wxDC *)wx_dc)->DrawPolygon(list, xoffset, yoffset,fillStyle);
+}
+
+void wxbCanvas::DrawLines(int n, wxPoint points[], float xoffset, float yoffset)
+{
+  wx_dc->DrawLines(n, points, xoffset, yoffset);
+}
+
+void wxbCanvas::DrawLines(int n, wxIntPoint points[], int xoffset, int yoffset)
+{
+  wx_dc->DrawLines(n, points, xoffset, yoffset);
+}
+
+void wxbCanvas::DrawLines(wxList *list, float xoffset, float yoffset)
+{
+  ((wxDC *)wx_dc)->DrawLines(list, xoffset, yoffset);
+}
+
+void wxbCanvas::DrawRectangle(float x, float y, float width, float height)
+{
+  wx_dc->DrawRectangle(x, y, width, height);
+}
+
+void wxbCanvas::DrawRoundedRectangle(float x, float y, float width, float height, float radius)
+{
+  wx_dc->DrawRoundedRectangle(x, y, width, height, radius);
+}
+
+void wxbCanvas::DrawEllipse(float x, float y, float width, float height)
+{
+  wx_dc->DrawEllipse(x, y, width, height);
+}
+
+
+void wxbCanvas::SetFont(wxFont *the_font)
+{
+  wx_dc->SetFont(the_font);
+}
+
+void wxbCanvas::SetPen(wxPen *pen)
+{
+  wx_dc->SetPen(pen);
+}
+
+void wxbCanvas::SetTextForeground(wxColour *colour)
+{
+  wx_dc->SetTextForeground(colour);
+}
+
+void wxbCanvas::SetTextBackground(wxColour *colour)
+{
+  wx_dc->SetTextBackground(colour);
+}
+
+void wxbCanvas::SetBrush(wxBrush *brush)
+{
+  wx_dc->SetBrush(brush);
+}
+
+void wxbCanvas::DrawText(const char *text, float x, float y, Bool use16)
+{
+  wx_dc->DrawText(text, x, y, use16);
+}
+
+void wxbCanvas::SetBackground(wxBrush *brush)
+{
+  wx_dc->SetBackground(brush);
+}
+
+void wxbCanvas::SetLogicalFunction(int function)
+{
+  wx_dc->SetLogicalFunction(function);
+}
+
+#if USE_SPLINES
+// Make a 3-point spline
+void wxbCanvas::DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3)
+{
+  wx_dc->DrawSpline(x1, y1, x2, y2, x3, y3);
+}
+
+void wxbCanvas::DrawSpline(wxList *list)
+{
+  wx_dc->DrawSpline(list);
+}
+#endif
+
+float wxbCanvas::GetCharHeight(void)
+{
+  return wx_dc->GetCharHeight();
+}
+
+float wxbCanvas::GetCharWidth(void)
+{
+  return wx_dc->GetCharWidth();
+}
+
+#ifdef wx_mac
+void wxbCanvas::GetTextExtent(const char* string, float* x, float* y, float* descent,
+  						float* externalLeading, wxFont* the_font, Bool use16)
+{
+  wx_dc->GetTextExtent(string, x, y, descent, externalLeading, the_font, use16);
+}
+#else // wx_mac
+void wxbCanvas::GetTextExtent(const char *string, float *x, float *y,
+                              float *descent, float *externalLeading)
+{
+  wx_dc->GetTextExtent(string, x, y, descent, externalLeading);
+}
+#endif // wx_mac
+
diff --git a/src/wxmac/src/base/wb_data.cc b/src/wxmac/src/base/wb_data.cc
new file mode 100644
index 0000000..513b9b9
--- /dev/null
+++ b/src/wxmac/src/base/wb_data.cc
@@ -0,0 +1,105 @@
+/*
+ * Global Data
+ *
+ * RCS_ID:      $Id: wb_data.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ */
+
+/* static const char sccsid[] = "@(#)wb_data.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_list.h"
+#include "wx_gdi.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#define _MAXPATHLEN 500
+
+// Useful buffer, initialized in wxCommonInit
+char *wxBuffer = NULL;
+
+#if 0
+// Windows List
+wxList wxTopLevelWindows;
+#endif
+
+// Message Strings for Internationalization
+char **wx_msg_str = (char**)NULL;
+
+// Some global printer parameters
+char wx_printer_file[_MAXPATHLEN];
+float wx_printer_scale_x = 1.0;
+float wx_printer_scale_y = 1.0;
+float wx_printer_translate_x = 0.0;
+float wx_printer_translate_y = 0.0;
+int wxPageNumber;
+
+// GDI Object Lists
+wxBrushList *wxTheBrushList = NULL;
+wxPenList   *wxThePenList = NULL;
+wxFontList   *wxTheFontList = NULL;
+wxGDIList   *wxTheBitmapList = NULL;
+//wxGDIList   *wxTheColourList = NULL;
+
+wxColourDatabase *wxTheColourDatabase = NULL;
+
+// Stock objects
+wxFont *wxNORMAL_FONT;
+wxFont *wxSMALL_FONT;
+wxFont *wxITALIC_FONT;
+wxFont *wxSWISS_FONT;
+wxPen *wxRED_PEN;
+
+wxPen *wxCYAN_PEN;
+wxPen *wxGREEN_PEN;
+wxPen *wxBLACK_PEN;
+wxPen *wxWHITE_PEN;
+wxPen *wxTRANSPARENT_PEN;
+wxPen *wxBLACK_DASHED_PEN;
+wxPen *wxGREY_PEN;
+wxPen *wxMEDIUM_GREY_PEN;
+wxPen *wxLIGHT_GREY_PEN;
+
+wxBrush *wxBLUE_BRUSH;
+wxBrush *wxGREEN_BRUSH;
+wxBrush *wxWHITE_BRUSH;
+wxBrush *wxBLACK_BRUSH;
+wxBrush *wxTRANSPARENT_BRUSH;
+wxBrush *wxCYAN_BRUSH;
+wxBrush *wxRED_BRUSH;
+wxBrush *wxGREY_BRUSH;
+wxBrush *wxMEDIUM_GREY_BRUSH;
+wxBrush *wxLIGHT_GREY_BRUSH;
+
+wxBrush *wxCONTROL_BACKGROUND_BRUSH;
+
+wxColour *wxBLACK;
+wxColour *wxWHITE;
+wxColour *wxRED;
+wxColour *wxBLUE;
+wxColour *wxGREEN;
+wxColour *wxCYAN;
+wxColour *wxLIGHT_GREY;
+
+wxCursor *wxSTANDARD_CURSOR = NULL;
+wxCursor *wxHOURGLASS_CURSOR = NULL;
+wxCursor *wxCROSS_CURSOR = NULL;
+
+/*
+ * Edward, haven't added in your wx_version and wx_version_string constants:
+ * do you think they're necessary over and above the #defines?
+ */
+
diff --git a/src/wxmac/src/base/wb_dc.cc b/src/wxmac/src/base/wb_dc.cc
new file mode 100644
index 0000000..b50b2d2
--- /dev/null
+++ b/src/wxmac/src/base/wb_dc.cc
@@ -0,0 +1,195 @@
+/*
+ * File:        wb_dc.cc
+ * Purpose:     Device context implementation
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_dc.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_dc.cc      1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation "wb_dc.h"
+#pragma implementation "wb_dccan.h"
+#pragma implementation "wb_dcmem.h"
+#endif
+
+#include "common.h"
+#include "wx_frame.h"
+#include "wx_dc.h"
+#include "wx_dcps.h"
+// wx_dcmem.h not strictly necessary but required
+// for GNU GCC when using pragmas.
+#include "wx_dcmem.h"
+#include "wx_stdev.h"
+#include "wx_utils.h"
+#include "wx_canvs.h"
+#include "wx_dialg.h"
+#include "wx_main.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "math.h"
+
+#ifndef wx_mac
+#if USE_SPLINES
+# if USE_XFIG_SPLINE_CODE
+#  include "../base/xfspline.cc"
+# else
+#  include "../base/wxspline.cc"
+# endif
+#endif // USE_SPLINES
+#endif
+
+// Default constructor
+wxbDC::wxbDC(void)
+{
+  __type = wxTYPE_DC;
+  min_x = 0; min_y = 0; max_x = 0; max_y = 0;
+  title = NULL;
+  clipping = FALSE;
+  autoSetting = TRUE ;
+}
+
+wxbDC::~wxbDC(void)
+{
+  if (title)
+    delete[] title;
+}
+
+void wxbDC::DrawPolygon(wxList *list, float xoffset, float yoffset,int fillStyle)
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawPolygon(n, points, xoffset, yoffset,fillStyle);
+  delete[] points;
+}
+
+void wxbDC::DrawLines(wxList *list, float xoffset, float yoffset)
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawLines(n, points, xoffset, yoffset);
+  delete []points;
+}
+
+void wxbDC::SetTextForeground(wxColour *colour)
+{
+  if (colour)
+    current_text_foreground = *colour;
+}
+
+void wxbDC::SetTextBackground(wxColour *colour)
+{
+  if (colour)
+    current_text_background = *colour;
+}
+
+void wxbDC::SetBackgroundMode(int mode)
+{
+  current_bk_mode = mode;
+}
+
+void wxbDC::GetSize(float *width, float *height)
+{
+  if (!(min_x == 1000.0 && min_y == 1000.0 && max_x == -1000.0 && max_y == -1000.0))
+  {
+    *width = (float)(max_x - min_x);
+    *height = (float)(max_y - min_y);
+  } else {
+    *width = 0.0;
+    *height = 0.0;
+  }
+}
+
+#if USE_SPLINES
+// Make a 3-point spline
+void wxbDC::DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3)
+{
+  wxList *point_list = new wxList;
+
+  wxPoint *point1 = new wxPoint;
+  point1->x = x1; point1->y = y1;
+  point_list->Append((wxObject*)point1);
+
+  wxPoint *point2 = new wxPoint;
+  point2->x = x2; point2->y = y2;
+  point_list->Append((wxObject*)point2);
+
+  wxPoint *point3 = new wxPoint;
+  point3->x = x3; point3->y = y3;
+  point_list->Append((wxObject*)point3);
+
+  DrawSpline(point_list);
+
+  for(wxNode *node = point_list->First(); node; node = node->Next()) {
+    wxPoint *p = (wxPoint *)node->Data();
+    delete p;
+  }
+  delete point_list;
+/*
+  wxSpline spline(point_list);
+
+  wx_draw_open_spline(this, &spline);
+  spline.DeletePoints();
+ */
+}
+#endif
+
+void wxbDC::SetLogicalOrigin(float x, float y)
+{
+  logical_origin_x = x;
+  logical_origin_y = y;
+}
+
+void wxbDC::SetDeviceOrigin(float x, float y)
+{
+  device_origin_x = x;
+  device_origin_y = y;
+}
+
+// For use by wxWindows only, unless custom units are required.
+void wxbDC::SetLogicalScale(float x, float y)
+{
+  logical_scale_x = x;
+  logical_scale_y = y;
+}
+
+void wxbDC::CalcBoundingBox(float x, float y)
+{
+  if (x < min_x) min_x = x;
+  if (y < min_y) min_y = y;
+  if (x > max_x) max_x = x;
+  if (y > max_y) max_y = y;
+}
+
+void wxbDC::TryColour(wxColour *src, wxColour *dest)
+{
+  *dest = *src;
+}
+
diff --git a/src/wxmac/src/base/wb_dialg.cc b/src/wxmac/src/base/wb_dialg.cc
new file mode 100644
index 0000000..ff0c7de
--- /dev/null
+++ b/src/wxmac/src/base/wb_dialg.cc
@@ -0,0 +1,754 @@
+/*
+ * File:	wb_dialg.cc
+ * Purpose:	wxDialogBox and miscellaneous dialog functions
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_dialg.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_dialg.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_dialg.h"
+#include "wx_utils.h"
+#include "wx_gdi.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+#include "wx_buttn.h"
+#include "wx_messg.h"
+#include "wx_choic.h"
+#include "wx_check.h"
+#include "wx_menu.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_slidr.h"
+#include "wx_lbox.h"
+#include "wx_mgstr.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+#include <iostream.h>
+#include <stdio.h>
+
+#define wxDIALOG_DEFAULT_X 300
+#define wxDIALOG_DEFAULT_Y 300
+
+// Generic file load/save dialog
+// static inline char * // HP compiler complains
+static char *
+wxDefaultFileSelector(Bool load, const char *what, char *extension, char *default_name)
+{
+  char prompt[50];
+  sprintf(prompt, load ? wxSTR_LOAD_FILE : wxSTR_SAVE_FILE, what);
+
+  if (*extension == '.') extension++;
+  char wild[60];
+  sprintf(wild, "*.%s", extension);
+#ifdef wx_mac
+  return wxFileSelector (prompt, NULL, default_name, (char *)extension, wild, load ? wxOPEN : wxSAVE);
+#else
+  return wxFileSelector (prompt, NULL, default_name, (char *)extension, wild);
+#endif
+}
+
+
+// Generic file load dialog
+char *
+wxLoadFileSelector(char *what, char *extension, char *default_name)
+{
+  return wxDefaultFileSelector(TRUE, what, extension, default_name);
+}
+
+
+// Generic file save dialog
+char *
+wxSaveFileSelector(char *what, char *extension, char *default_name)
+{
+  return wxDefaultFileSelector(FALSE, what, extension, default_name);
+}
+
+
+// Dialog box - like panel but doesn't need a frame, and is modal or
+// non-modal
+#ifndef wx_mac
+wxbDialogBox::wxbDialogBox(void)
+{
+  __type = wxTYPE_DIALOG_BOX;
+}
+wxbDialogBox::wxbDialogBox(wxWindow *Parent, char *Title, Bool Modal, 
+                         int x, int y, int width, int height, long style, char *name):
+  wxPanel()
+{
+  __type = wxTYPE_DIALOG_BOX;
+  windowStyle = style;
+}
+#else
+#endif
+
+
+Bool wxbDialogBox::Create(wxWindow *Parent, char *Title, Bool Modal, 
+                         int x, int y, int width, int height, long style, char *name)
+{
+  windowStyle = style;
+  if (!Parent) {
+    wxTopLevelWindows(ContextWindow())->Append(this);
+    wxTopLevelWindows(ContextWindow())->Show(this, FALSE);
+  }
+  return TRUE;
+}
+
+wxbDialogBox::~wxbDialogBox()
+{
+  wxTopLevelWindows(ContextWindow())->DeleteObject(this);
+}
+
+void wxbDialogBox::Centre(int direction)
+{
+#if 0
+  int x_offset,y_offset ;
+  int display_width, display_height;
+  int  width, height, x, y;
+  wxFrame *frame ;
+  if (direction & wxCENTER_FRAME)
+  {
+    frame = (wxFrame*)GetParent() ;
+    if (frame)
+    {
+      frame->GetPosition(&x_offset,&y_offset) ;
+      frame->GetSize(&display_width,&display_height) ;
+    }
+  }
+  else
+    frame = NULL;
+
+  if (frame==NULL)
+  {
+    wxDisplaySize(&display_width, &display_height);
+    x_offset = 0 ;
+    y_offset = 0 ;
+  }
+
+
+  GetSize(&width, &height);
+  GetPosition(&x, &y);
+
+  if (direction & wxHORIZONTAL)
+    x = (int)((display_width - width)/2);
+  if (direction & wxVERTICAL)
+    y = (int)((display_height - height)/2);
+
+  SetSize(x+x_offset, y+y_offset, width, height, wxPOS_USE_MINUS_ONE);
+#endif
+  ((wxDialogBox *)this)->cFrame->Centre(direction);
+}
+
+
+/*
+ * Common dialogs code
+ *
+ */
+
+/*
+ * Message centring code
+ *
+ */
+#ifndef wx_mac // code in wx_dialg.cc
+void wxSplitMessage(char *message, wxList *messageList, wxPanel *panel)
+{
+  char *copyMessage = copystring(message);
+  size_t i = 0;
+  size_t len = strlen(copyMessage);
+  char *currentMessage = copyMessage;
+
+  while (i < len) {
+    while ((i < len) && (copyMessage[i] != '\n')) i++;
+    if (i < len) copyMessage[i] = 0;
+    wxMessage *mess = new wxMessage(panel, currentMessage);
+    messageList->Append(mess);
+    panel->NewLine();
+
+    currentMessage = copyMessage + i + 1;
+  }
+  delete[] copyMessage;
+}
+
+void wxCentreMessage(wxList *messageList)
+{
+  // Do the message centering
+  for(wxNode *node = messageList->First(); node; node = node->Next()) {
+    wxMessage *mess = (wxMessage *)node->Data();
+    mess->Centre();
+  }
+}
+#endif // wx_mac
+
+/*
+ * A general purpose dialog box with an OnClose that returns TRUE.
+ *
+ */
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma interface
+#endif
+
+class wxMessageBoxDialog: public wxDialogBox
+{
+ public:
+  wxText *textItem;
+  wxListBox *listBoxItem;
+  static char *textAnswer;
+  static char *listSelection;
+  static char *listClientSelection;
+  static int listPosition;
+  static int buttonPressed;
+  static  int  * listSelections;
+  static int     nlistSelections;
+
+  wxMessageBoxDialog(wxWindow *parent, char *caption, Bool modal, int x, int y,
+    int w, int h, long type):
+   wxDialogBox(parent, caption, modal, x, y, w, h, type)
+ {
+   textItem = NULL;
+   listBoxItem = NULL;
+   buttonPressed = wxCANCEL;
+ }
+ Bool OnClose(void)
+ {
+   return TRUE;
+ }
+};
+
+char *wxMessageBoxDialog::textAnswer = NULL;
+char *wxMessageBoxDialog::listSelection = NULL;
+char *wxMessageBoxDialog::listClientSelection = NULL;
+int wxMessageBoxDialog::listPosition = 0;
+int wxMessageBoxDialog::buttonPressed = wxCANCEL;
+int *  wxMessageBoxDialog::listSelections = NULL;
+int    wxMessageBoxDialog::nlistSelections = -1 ;
+
+void wxDialogOkButton(wxButton& but, wxEvent& event)
+{
+  wxPanel *panel = (wxPanel *)but.GetParent();
+  // There is a possibility that buttons belong to a sub panel.
+  // So, we must search the dialog.
+  while (!wxSubType(panel->__type,wxTYPE_DIALOG_BOX))
+    panel = (wxPanel*) panel->GetParent() ;
+
+  wxMessageBoxDialog *dialog = (wxMessageBoxDialog *)panel;
+  if (dialog->textItem)
+  {
+    if (dialog->textAnswer)
+      delete[] dialog->textAnswer;
+    dialog->textAnswer = copystring(dialog->textItem->GetValue());
+  }
+
+  if (dialog->listBoxItem)
+    {
+      if ( dialog->listBoxItem->multiple==wxSINGLE)
+        {
+          if (dialog->listSelection)
+            delete[] dialog->listSelection;
+          dialog->listSelection = 
+            (dialog->listBoxItem->GetStringSelection() ?
+             copystring(dialog->listBoxItem->GetStringSelection()) : NULL);
+          dialog->listPosition = dialog->listBoxItem->GetSelection();
+          dialog->listClientSelection = 
+            dialog->listBoxItem->wxListBox::GetClientData(dialog->listPosition);
+        }
+      else 
+        if (dialog->listBoxItem->multiple==wxMULTIPLE)
+          {
+            if (dialog->listSelections)
+              delete[] dialog->listSelections;
+            dialog->listSelections = 0;
+            
+            int * sels;
+            dialog-> nlistSelections =
+              dialog->listBoxItem->GetSelections (&sels);
+            if ( dialog-> nlistSelections)
+              {
+                dialog->listSelections = new int [ dialog-> nlistSelections ];
+                for (int i=0; i<  dialog-> nlistSelections; i++)
+                  dialog->listSelections[i] = sels[i];
+              }
+          }
+    }
+
+  dialog->buttonPressed = wxOK;
+  dialog->Show(FALSE);
+  delete dialog;
+}
+
+void wxDialogCancelButton(wxButton& but, wxEvent& event)
+{
+  wxDialogBox *dialog = (wxDialogBox *)but.GetParent();
+  // There is a possibility that buttons belong to a sub panel.
+  // So, we must search the dialog.
+  while (!wxSubType(dialog->__type,wxTYPE_DIALOG_BOX))
+    dialog = (wxDialogBox*) ((wxPanel*)dialog)->GetParent() ;
+
+  dialog->Show(FALSE);
+  delete dialog;
+}
+
+void wxDialogYesButton(wxButton& but, wxEvent& event)
+{
+  wxPanel *panel = (wxPanel *)but.GetParent();
+  // There is a possibility that buttons belong to a sub panel.
+  // So, we must search the dialog.
+  while (!wxSubType(panel->__type,wxTYPE_DIALOG_BOX))
+    panel = (wxPanel*) panel->GetParent() ;
+
+  wxMessageBoxDialog *dialog = (wxMessageBoxDialog *)panel;
+  dialog->buttonPressed = wxYES;
+  dialog->Show(FALSE);
+  delete dialog;
+}
+
+void wxDialogNoButton(wxButton& but, wxEvent& event)
+{
+  wxPanel *panel = (wxPanel *)but.GetParent();
+  // There is a possibility that buttons belong to a sub panel.
+  // So, we must search the dialog.
+  while (!wxSubType(panel->__type,wxTYPE_DIALOG_BOX))
+    panel = (wxPanel*) panel->GetParent() ;
+
+  wxMessageBoxDialog *dialog = (wxMessageBoxDialog *)panel;
+  dialog->buttonPressed = wxNO;
+  dialog->Show(FALSE);
+  delete dialog;
+}
+
+
+/*
+ * BUGBUG Julian Smart 12/93
+ * define USE_PANEL_IN_PANEL
+ * if you dare use panel in panel for dialogs; I can't
+ * get it to work without absolute positioning, because
+ * wxItem::SetSize DOES NOT WORK (try the hello.cc About box.
+ *
+ */
+#ifndef wx_mac // for Mac, this function is in wx_dialog.cc/wxGetText.cc
+// Return NULL if cancel pressed
+char *wxGetTextFromUser(char *message, char *caption, char *default_value,
+                        wxWindow *parent, int x, int y, Bool centre)
+{
+  wxBeginBusyCursor();
+
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 1000, 1000, wxDEFAULT_DIALOG_STYLE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog->NewLine();
+
+  dialog->textItem = new wxText(dialog, NULL, NULL, default_value, -1, -1, 320);
+  dialog->NewLine();
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, wxSTR_BUTTON_OK);
+  (void)new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, wxSTR_BUTTON_CANCEL);
+
+  ok->SetDefault();
+  dialog->textItem->SetFocus();
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#ifndef wx_xview
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  if (centre)
+    wxCentreMessage(&messageList);
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+
+  wxEndBusyCursor();
+  dialog->Show(TRUE);
+
+  if (wxMessageBoxDialog::buttonPressed == wxOK)
+    return wxMessageBoxDialog::textAnswer;
+
+  return NULL;
+}
+#endif
+
+char *wxGetSingleChoice(char *message, char *caption, int n, char *choices[],
+                        wxWindow *parent, int x, int y, Bool centre, int width, int height)
+{
+  wxBeginBusyCursor();
+
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 600, 600, wxDEFAULT_DIALOG_STYLE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog->NewLine();
+
+  dialog->listBoxItem = new wxListBox(dialog, NULL, NULL, wxSINGLE,
+                     -1, -1, width, height, n, choices);
+
+  dialog->listBoxItem->SetSelection(0);
+
+  dialog->NewLine();
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, wxSTR_BUTTON_OK);
+  (void)new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, wxSTR_BUTTON_CANCEL);
+  // must call SetDefault AFTER creating all buttons of the subPanel
+  // (see comment in x/wx_item.cc)
+  ok->SetDefault();
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  if (centre)
+    wxCentreMessage(&messageList);
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+
+  wxEndBusyCursor();
+  dialog->Show(TRUE);
+
+  if (wxMessageBoxDialog::buttonPressed == wxOK) {
+    if (wxMessageBoxDialog::listPosition >= 0)
+      return wxMessageBoxDialog::listSelection;
+  }
+
+  return NULL;
+}
+
+int wxGetSingleChoiceIndex(char *message, char *caption, int n, char *choices[],
+                           wxWindow *parent, int x, int y, Bool centre,
+                           int width, int height)
+{
+  wxBeginBusyCursor();
+
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 600, 600, wxDEFAULT_DIALOG_STYLE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog->NewLine();
+
+  dialog->listBoxItem = new wxListBox(dialog, NULL, NULL, wxSINGLE,
+                     -1, -1, width, height, n, choices);
+  dialog->listBoxItem->SetSelection(0);
+  dialog->NewLine();
+
+  // Create Buttons in a sub-panel, so they can be centered.
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, wxSTR_BUTTON_OK);
+  (void)new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, wxSTR_BUTTON_CANCEL);
+  // SetDefault must be done AFTER creating all buttons
+  ok->SetDefault();
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  if (centre)
+    wxCentreMessage(&messageList);
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+
+  wxEndBusyCursor();
+  dialog->Show(TRUE);
+
+  if (wxMessageBoxDialog::buttonPressed == wxOK) {
+    return wxMessageBoxDialog::listPosition;
+  }
+
+  return -1;
+}
+
+char *wxGetSingleChoiceData(char *message, char *caption, int n,
+                            char *choices[], char *client_data[],
+                            wxWindow *parent, int x, int y, Bool centre,
+                            int width, int height)
+{
+  wxBeginBusyCursor();
+
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 600, 600, wxDEFAULT_DIALOG_STYLE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog->NewLine();
+
+  dialog->listBoxItem = new wxListBox(dialog, NULL, NULL, wxSINGLE, -1, -1,
+                     width, height);
+  dialog->listBoxItem->SetSelection(0);
+  int i;
+  for (i = 0; i < n; i++)
+    dialog->listBoxItem->Append(choices[i], client_data[i]);
+
+  dialog->NewLine();
+
+  // Create Buttons in a sub-panel, so they can be centered.
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, wxSTR_BUTTON_OK);
+  (void)new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, wxSTR_BUTTON_CANCEL);
+  // SetDefault must be done AFTER creating all buttons
+  ok->SetDefault();
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  if (centre)
+    wxCentreMessage(&messageList);
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+
+  wxEndBusyCursor();
+  dialog->Show(TRUE);
+
+  if (wxMessageBoxDialog::buttonPressed == wxOK) {
+    if (wxMessageBoxDialog::listPosition >= 0)
+      return wxMessageBoxDialog::listClientSelection;
+  }
+
+  return NULL;
+}
+
+/* Multiple choice dialog contributed by Robert Cowell
+ *
+
+The new data passed are in the "int nsel" and "int * selection"
+
+The idea is to make a multiple selection from list of strings.
+The returned value is the total number selected. initialily there
+are nsel selected, with indices stored in
+selection[0],...,selection[nsel-1] which appear highlighted to
+begin with. On exit with value i
+selection[0..i-1] contains the indices of the selected items.
+(Some prior selectecions might be deselected.)
+Thus selection must be as big as choices, in case all items are
+selected.
+
+*/
+
+int wxGetMultipleChoice(char *message, char *caption,
+			  int n, char *choices[], 
+			  int nsel, int * selection,
+			  wxWindow *parent , int x , int y, Bool centre,
+			  int width, int height)
+{
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 1000, 1000, wxDEFAULT_DIALOG_STYLE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog -> NewLine();
+
+  dialog->listBoxItem = new wxListBox(dialog, NULL, NULL, wxMULTIPLE,
+		    -1, -1, width, height, n, choices);
+ 
+  for (int i=0; i < nsel; i++)
+      dialog->listBoxItem ->SetSelection(selection[i],TRUE);
+ 
+  dialog->NewLine();
+
+  // Create Buttons in a sub-panel, so they can be centered.
+#if (!defined(wx_xview) && defined(USE_PANEL_IN_PANEL))
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, "OK");
+  (void)new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, "Cancel");
+  // SetDefault must be done AFTER creating all buttons
+  ok->SetDefault();
+
+  wxMessageBoxDialog::buttonPressed = 0;
+
+#if (!defined(wx_xview) && defined(USE_PANEL_IN_PANEL))
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#if (!defined(wx_xview) && defined(USE_PANEL_IN_PANEL))
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  if (centre)
+    wxCentreMessage(&messageList);
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+  
+  dialog->Show(TRUE);
+  if (wxMessageBoxDialog::buttonPressed == wxOK)
+    {
+      int i;
+      for( i=0; i<wxMessageBoxDialog::nlistSelections; i++)
+         selection[i] = wxMessageBoxDialog::listSelections[i] ;
+      return wxMessageBoxDialog::nlistSelections;
+    }
+   else 
+      return -1;
+}
+
+// Pop up a message box: generic version used by X.
+int wxbMessageBox(char *message, char *caption, long type,
+                 wxWindow *parent, int x, int y)
+{
+  wxBeginBusyCursor();
+
+  wxMessageBoxDialog *dialog = new wxMessageBoxDialog(parent, caption, TRUE, x, y, 1000, 1000, wxDEFAULT_DIALOG_STYLE);
+
+  Bool centre = ((type & wxCENTRE) == wxCENTRE);
+
+  wxList messageList;
+  wxSplitMessage(message, &messageList, dialog);
+
+  dialog->NewLine();
+
+  // Create Buttons in a sub-panel, so they can be centered.
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  wxPanel *but_panel = new wxPanel(dialog) ;
+#else
+  // Until sub panels work in XView mode
+  wxPanel *but_panel = dialog ;
+#endif
+
+  wxButton *ok = NULL;
+  wxButton *cancel = NULL;
+  wxButton *yes = NULL;
+  wxButton *no = NULL;
+
+  if (type & wxYES_NO) {
+    yes = new wxButton(but_panel, (wxFunction)&wxDialogYesButton, wxSTR_YES);
+    no = new wxButton(but_panel, (wxFunction)&wxDialogNoButton, wxSTR_NO);
+  }
+
+  if (type & wxOK) {
+    ok = new wxButton(but_panel, (wxFunction)&wxDialogOkButton, wxSTR_BUTTON_OK);
+  }
+
+  if (type & wxCANCEL) {
+    cancel = new wxButton(but_panel, (wxFunction)&wxDialogCancelButton, wxSTR_BUTTON_CANCEL);
+  }
+
+  if (ok)
+  {
+    ok->SetDefault();
+    ok->SetFocus();
+  }
+  else if (yes)
+  {
+    yes->SetDefault();
+    yes->SetFocus();
+  }
+
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Fit() ;
+#endif
+  dialog->Fit();
+#if (!defined(wx_xview) && USE_PANEL_IN_PANEL)
+  but_panel->Centre(wxHORIZONTAL) ;
+#endif
+
+  // Do the message centering
+  if (centre)
+    wxCentreMessage(&messageList);
+
+#if (defined(wx_xview) || !USE_PANEL_IN_PANEL)
+  // Since subpanels don't work on XView, we must center ok button
+  if (ok && !cancel && !yes && !no)
+    ok->Centre();
+#endif
+
+  if ((x < 0) && (y < 0))
+    dialog->Centre(wxBOTH);
+  else if (x < 0)
+    dialog->Centre(wxHORIZONTAL);
+  else if (y < 0)
+    dialog->Centre(wxVERTICAL);
+
+  wxEndBusyCursor();
+  dialog->Show(TRUE);
+
+  return wxMessageBoxDialog::buttonPressed;
+}
diff --git a/src/wxmac/src/base/wb_form.cc b/src/wxmac/src/base/wb_form.cc
new file mode 100644
index 0000000..1a4f047
--- /dev/null
+++ b/src/wxmac/src/base/wb_form.cc
@@ -0,0 +1,1362 @@
+/*
+ * File:      wb_form.cc
+ * Purpose:     Form handling code
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_form.cc,v 1.4 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_form.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation "wx_form.h"
+#pragma implementation
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_utils.h"
+#include "wx_dialg.h"
+#include "wx_item.h"
+#include "wx_buttn.h"
+#include "wx_messg.h"
+#include "wx_choic.h"
+#include "wx_check.h"
+#include "wx_menu.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_slidr.h"
+#include "wx_lbox.h"
+#include "wx_rbox.h"
+#include "wx_hash.h"
+#include "wx_mgstr.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+// Max. message length
+#define _MAX_MESSAGE_LEN 300
+
+#if USE_FORM
+
+#include "wx_form.h"
+
+#include <stdio.h>
+
+// Sun CC compatibility (interference with xview/pkg.h, apparently...)
+#if defined(SUN_CC) && defined(wx_xview)
+#undef va_start
+#undef va_end
+#undef va_arg
+#undef va_list
+#endif
+
+#include <stdarg.h>
+
+// Helper function
+wxFormItemConstraint *wxFormConstraintsContains (int type, wxList * constraints);
+
+// Display items and callback functions
+class wxFormButton:public wxButton
+{
+  public:
+  wxForm * form;
+  wxFormButton (wxPanel * panel, wxFunction func, char *label,
+		int x = -1, int y = -1, int width = -1, int height = -1);
+};
+
+static void wxFormOk (wxFormButton & button, wxEvent & event);
+static void wxFormRevert (wxFormButton & button, wxEvent & event);
+static void wxFormCancel (wxFormButton & button, wxEvent & event);
+static void wxFormUpdate (wxFormButton & button, wxEvent & event);
+static void wxFormHelp (wxFormButton & button, wxEvent & event);
+
+/*
+ * Range
+ *
+ */
+
+wxRealRange::wxRealRange (float the_lo, float the_hi)
+{
+  lo = the_lo;
+  hi = the_hi;
+}
+
+/*
+ * Form item constraint
+ *
+ */
+
+wxFormItemConstraint::wxFormItemConstraint (int type)
+{
+  Type = type;
+  localList = FALSE;
+}
+
+wxFormItemConstraint::~wxFormItemConstraint (void)
+{
+  switch (Type)
+    {
+    case wxFORM_CONSTRAINT_ONE_OF:
+      {
+	if (Constraint.OneOf)
+	  {
+	    wxNode *node = Constraint.OneOf->First ();
+	    while (node)
+	      {
+		char *s = (char *) node->Data ();
+		wxNode *next = node->Next ();
+		delete[]s;
+		delete node;
+		node = next;
+	      }
+	    if (localList)
+	      delete Constraint.OneOf;
+	  }
+	break;
+      }
+    case wxFORM_CONSTRAINT_RANGE:
+      {
+	if (Constraint.Range)
+	  delete Constraint.Range;
+	break;
+      }
+    default:
+      break;
+    }
+}
+
+/*
+ * Form item
+ *
+ */
+
+wxFormItem::wxFormItem (int type, int item_type)
+{
+  Id = 0;
+  Type = type;
+  ItemType = item_type;
+  PanelItem = NULL;
+  Constraints = NULL;
+  style = 0;
+  HelpString = NULL;
+  Label = NULL;
+  Height = -1;
+  Width = -1;
+}
+
+wxFormItem::~wxFormItem (void)
+{
+  if (HelpString)
+    delete[]HelpString;
+  if (Label)
+    delete[]Label;
+
+/*** Patrick: Nooo... this pointer is to the user's data; don't want to
+ * delete this!
+
+  if (Type==wxFORM_STRING && *ValuePtr.StringValuePtr)
+  {
+    delete[] (*ValuePtr.StringValuePtr);
+    *ValuePtr.StringValuePtr = NULL ;
+  }
+ */
+
+  Form->FormItems.DeleteObject (this);
+
+  if (Constraints)
+    {
+      for (wxNode * node = Constraints->First (); node; node = node->Next ())
+	{
+	  wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+	  delete constraint;
+	}
+      delete Constraints;
+    }
+}
+
+void wxFormItem::MakePanelItem (wxPanel * panel)
+{
+  switch (Type)
+    {
+    case wxFORM_STRING:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_SINGLE_LIST:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+
+	      PanelItem = new wxListBox (panel, (wxFunction) NULL, Label, wxSINGLE,
+					 -1, -1, Width, Height);
+
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+
+	      wxListBox *listbox = (wxListBox *) PanelItem;
+	      wxFormItemConstraint *constraint =
+	      wxFormConstraintsContains (wxFORM_CONSTRAINT_ONE_OF, Constraints);
+
+	      if (constraint)
+		for (wxNode * node = constraint->Constraint.OneOf->First (); node; node = node->Next ())
+		  {
+		    char *s = (char *) node->Data ();
+		    listbox->Append (s);
+		  }
+	      break;
+	    }
+	  case wxFORM_CHOICE:
+	    {
+	      wxFormItemConstraint *constraint =
+	      wxFormConstraintsContains (wxFORM_CONSTRAINT_ONE_OF, Constraints);
+	      if (constraint)
+		{
+		  int n = constraint->Constraint.OneOf->Number ();
+		  char **strings = new char *[n];
+
+		  int i = 0;
+		  for (wxNode * node = constraint->Constraint.OneOf->First (); node; node = node->Next ())
+		    strings[i++] = (char *) node->Data ();
+
+		  if (style & wxVERTICAL)
+		    panel->SetLabelPosition (wxVERTICAL);
+
+		  PanelItem = new wxChoice (panel, (wxFunction) NULL, Label,
+					 -1, -1, Width, Height, n, strings);
+		  delete[]strings;
+
+		  if (style & wxVERTICAL)
+		    panel->SetLabelPosition (wxHORIZONTAL);
+		}
+	      break;
+	    }
+	  case wxFORM_RADIOBOX:
+	    {
+	      wxFormItemConstraint *constraint =
+	      wxFormConstraintsContains (wxFORM_CONSTRAINT_ONE_OF, Constraints);
+	      int n = constraint->Constraint.OneOf->Number ();
+	      char *choices[50];	// @@@@ Max 50 Radio Buttons in a group!
+
+	      int i = 0;
+	      if (constraint)
+		{
+		  for (wxNode * node = constraint->Constraint.OneOf->First (); node; node = node->Next ())
+		    choices[i++] = (char *) node->Data ();
+
+		  panel->SetLabelPosition (wxVERTICAL);
+
+		  PanelItem = new wxRadioBox (panel, (wxFunction) NULL, Label,
+			      -1, -1, Width, Height, n, choices, 1, wxFLAT);
+		  panel->SetLabelPosition (wxHORIZONTAL);
+		}
+	      break;
+	    }
+	  case wxFORM_TEXT:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxText (panel, (wxFunction) NULL, Label, "", -1, -1,
+				      Width, Height);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  case wxFORM_MULTITEXT:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxMultiText (panel, (wxFunction) NULL, Label, "", -1, -1,
+					   Width, Height);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    case wxFORM_DUMB_MESSAGE:
+      {
+	PanelItem = new wxMessage (panel, Label);
+	break;
+      }
+    case wxFORM_BUTTON:
+      {
+	PanelItem = new wxButton (panel, ButtonFunc, Label, -1, -1, Width, Height);
+	break;
+      }
+    case wxFORM_NEWLINE:
+      {
+	panel->NewLine ();
+	break;
+      }
+    case wxFORM_SHORT:
+    case wxFORM_LONG:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_SLIDER:
+	    {
+	      int lo = -100;
+	      int hi = 100;
+	      int width = 230;
+	      wxFormItemConstraint *constraint =
+	      wxFormConstraintsContains (wxFORM_CONSTRAINT_RANGE, Constraints);
+	      if (constraint)
+		{
+		  wxRealRange *range = constraint->Constraint.Range;
+		  lo = (int) range->lo;
+		  hi = (int) range->hi;
+		}
+	      int default_value;
+	      if (Type == wxFORM_SHORT)
+		default_value = *(ValuePtr.ShortIntValuePtr);
+	      else
+		default_value = (int) *(ValuePtr.LongIntValuePtr);
+
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxSlider (panel, (wxFunction) NULL, Label,
+					default_value, lo, hi, width);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  case wxFORM_TEXT:
+	  default:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxText (panel, (wxFunction) NULL, Label, "", -1, -1,
+				      Width, Height);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  }
+	break;
+      }
+
+    case wxFORM_BOOL:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_CHECKBOX:
+	  default:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxCheckBox (panel, (wxFunction) NULL, Label, -1, -1,
+					  Width, Height);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  }
+	break;
+      }
+    case wxFORM_FLOAT:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	  default:
+	    {
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxVERTICAL);
+	      PanelItem = new wxText (panel, (wxFunction) NULL, Label, "", -1, -1,
+				      Width, Height);
+	      if (style & wxVERTICAL)
+		panel->SetLabelPosition (wxHORIZONTAL);
+	      break;
+	    }
+	  }
+	break;
+      }
+    case wxFORM_LIST_OF_STRINGS:
+      {
+	break;
+      }
+    case wxFORM_LIST_OF_LONGS:
+      {
+	break;
+      }
+
+    default:
+      break;
+    }
+}
+
+Bool wxFormItem::CheckLongValue (long val)
+{
+  char msg_buf[_MAX_MESSAGE_LEN];
+  if (Constraints)
+    {
+      wxNode *node = Constraints->First ();
+      Bool ok = TRUE;
+      while (node && ok)
+	{
+	  wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+	  switch (constraint->Type)
+	    {
+	    case wxFORM_CONSTRAINT_RANGE:
+	      {
+		wxRealRange *range = constraint->Constraint.Range;
+		if ((range->lo > (float) val) || (range->hi < (float) val))
+		  {
+		    sprintf (msg_buf, wxSTR_VIOLATION_LONG,
+			     Label, range->lo, range->hi);
+		    ok = FALSE;
+		  }
+		break;
+	      }
+	    case wxFORM_CONSTRAINT_FUNCTION:
+	      {
+		ok = (*(constraint->Constraint.ConstraintFunc)) (Type, (char *) &val, Label, msg_buf);
+		break;
+	      }
+	    default:
+	      break;
+	    }
+	  if (!ok)
+	    {
+	      (void) wxMessageBox (msg_buf, wxSTR_CONSTRAINT_VIOLATION, wxOK, Form->wx_form_panel);
+	    }
+	  node = node->Next ();
+	}
+      return ok;
+    }
+  else
+    return TRUE;
+}
+
+Bool wxFormItem::CheckBoolValue (Bool val)
+{
+  char msg_buf[_MAX_MESSAGE_LEN];
+  if (Constraints)
+    {
+      wxNode *node = Constraints->First ();
+      Bool ok = TRUE;
+      while (node && ok)
+	{
+	  wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+	  switch (constraint->Type)
+	    {
+	    case wxFORM_CONSTRAINT_FUNCTION:
+	      {
+		ok = (*(constraint->Constraint.ConstraintFunc)) (Type, (char *) &val, Label, msg_buf);
+		break;
+	      }
+	    default:
+	      break;
+	    }
+	  if (!ok)
+	    {
+	      (void) wxMessageBox (msg_buf, wxSTR_CONSTRAINT_VIOLATION, wxOK, Form->wx_form_panel);
+	    }
+	  node = node->Next ();
+	}
+      return ok;
+    }
+  else
+    return TRUE;
+}
+
+Bool wxFormItem::CheckStringValue (char *val)
+{
+  char msg_buf[_MAX_MESSAGE_LEN];
+  Bool ok = TRUE;
+
+  if (Constraints)
+    {
+      // Walk through and call the functions
+      for (wxNode * node = Constraints->First (); node && ok; node = node->Next ())
+	{
+	  wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+
+	  switch (constraint->Type)
+	    {
+	    case wxFORM_CONSTRAINT_FUNCTION:
+	      ok = (*(constraint->Constraint.ConstraintFunc)) (Type, val, Label, msg_buf);
+	      break;
+	    default:
+	      break;
+	    }			// switch()
+
+	  if (!ok)
+	    (void) wxMessageBox (msg_buf, wxSTR_CONSTRAINT_VIOLATION, wxOK, Form->wx_form_panel);
+	}			// for()
+
+    }
+  return ok;
+}
+
+Bool wxFormItem::CheckFloatValue (float val)
+{
+  char msg_buf[_MAX_MESSAGE_LEN];
+  if (Constraints)
+    {
+      wxNode *node = Constraints->First ();
+      Bool ok = TRUE;
+      while (node && ok)
+	{
+	  wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+	  switch (constraint->Type)
+	    {
+	    case wxFORM_CONSTRAINT_RANGE:
+	      {
+		wxRealRange *range = constraint->Constraint.Range;
+		if ((range->lo > val) || (range->hi < val))
+		  {
+		    sprintf (msg_buf, wxSTR_VIOLATION_FLOAT,
+			     Label, range->lo, range->hi);
+		    ok = FALSE;
+		  }
+		break;
+	      }
+	    case wxFORM_CONSTRAINT_FUNCTION:
+	      {
+		ok = (*(constraint->Constraint.ConstraintFunc)) (Type, (char *) &val, Label, msg_buf);
+		break;
+	      }
+	    default:
+	      break;
+	    }
+	  if (!ok)
+	    {
+	      (void) wxMessageBox (msg_buf, wxSTR_CONSTRAINT_VIOLATION, wxOK, Form->wx_form_panel);
+	    }
+	  node = node->Next ();
+	}
+      return ok;
+    }
+  else
+    return TRUE;
+}
+
+void wxFormItem::RevertValue (void)
+{
+  switch (Type)
+    {
+    case wxFORM_SHORT:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = IntToString (*(ValuePtr.ShortIntValuePtr));
+	      if (svalue)
+		{
+		  text_item->SetValue (svalue);
+		  // no more malloced
+		  //delete[] svalue;
+		}
+	      break;
+	    }
+	  case wxFORM_SLIDER:
+	    {
+	      wxSlider *slider_item = (wxSlider *) PanelItem;
+	      slider_item->SetValue (*(ValuePtr.ShortIntValuePtr));
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    case wxFORM_LONG:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = LongToString (*(ValuePtr.LongIntValuePtr));
+	      if (svalue)
+		{
+		  text_item->SetValue (svalue);
+		  // no more malloced
+		  //delete[] svalue;
+		}
+	      break;
+	    }
+	  case wxFORM_SLIDER:
+	    {
+	      wxSlider *slider_item = (wxSlider *) PanelItem;
+	      slider_item->SetValue ((int) *(ValuePtr.LongIntValuePtr));
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    case wxFORM_FLOAT:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = FloatToString (*(ValuePtr.FloatValuePtr));
+	      if (svalue)
+		{
+		  text_item->SetValue (svalue);
+		  // no more malloced
+		  //delete[] svalue;
+		}
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    case wxFORM_BOOL:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_CHECKBOX:
+	    {
+	      wxCheckBox *check_item = (wxCheckBox *) PanelItem;
+	      check_item->SetValue (*(ValuePtr.BoolValuePtr));
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    case wxFORM_STRING:
+      {
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	  case wxFORM_MULTITEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = *(ValuePtr.StringValuePtr);
+	      if (svalue)
+		{
+		  text_item->SetValue (svalue);
+		}
+	      break;
+	    }
+	  case wxFORM_SINGLE_LIST:
+	    {
+	      wxListBox *list_item = (wxListBox *) PanelItem;
+	      char *svalue = *(ValuePtr.StringValuePtr);
+	      if (svalue)
+		{
+		  int pos = list_item->FindString (svalue);
+		  if (pos > -1)
+		    list_item->SetSelection (pos);
+		  else
+		    list_item->SetSelection (0);
+		}
+	      else
+		list_item->SetSelection (0);
+	      break;
+	    }
+	  case wxFORM_CHOICE:
+	    {
+	      wxChoice *choice_item = (wxChoice *) PanelItem;
+	      char *svalue = *(ValuePtr.StringValuePtr);
+	      if (svalue)
+		{
+		  int pos = choice_item->FindString (svalue);
+		  if (pos > -1)
+		    choice_item->SetSelection (pos);
+		  else
+		    choice_item->SetSelection (0);
+		}
+	      else
+		choice_item->SetSelection (0);
+	      break;
+	    }
+	  case wxFORM_RADIOBOX:
+	    {
+	      wxRadioBox *radiobox_item = (wxRadioBox *) PanelItem;
+	      char *svalue = *(ValuePtr.StringValuePtr);
+	      if (svalue)
+		{
+		  int pos = radiobox_item->FindString (svalue);
+		  if (pos > -1)
+		    radiobox_item->SetSelection (pos);
+		  else
+		    radiobox_item->SetSelection (0);
+		}
+	      else
+		radiobox_item->SetSelection (0);
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	break;
+      }
+    default:
+      break;
+    }
+}
+
+Bool wxFormItem::UpdateValue (void)
+{
+  switch (Type)
+    {
+    case wxFORM_SHORT:
+      {
+	int short_value = 0;
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	  case wxFORM_MULTITEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = text_item->GetValue ();
+	      StringToInt (svalue, &short_value);
+	      break;
+	    }
+	  case wxFORM_SLIDER:
+	    {
+	      wxSlider *slider_item = (wxSlider *) PanelItem;
+	      short_value = slider_item->GetValue ();
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	if (CheckLongValue ((long) short_value))
+	  *(ValuePtr.ShortIntValuePtr) = short_value;
+	else
+	  return FALSE;
+	break;
+      }
+    case wxFORM_LONG:
+      {
+	long long_value;
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = text_item->GetValue ();
+	      StringToLong (svalue, &long_value);
+	      break;
+	    }
+	  case wxFORM_SLIDER:
+	    {
+	      wxSlider *slider_item = (wxSlider *) PanelItem;
+	      long_value = slider_item->GetValue ();
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	if (CheckLongValue (long_value))
+	  *(ValuePtr.LongIntValuePtr) = long_value;
+	else
+	  return FALSE;
+	break;
+      }
+    case wxFORM_FLOAT:
+      {
+	float float_value;
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      char *svalue = text_item->GetValue ();
+	      StringToFloat (svalue, &float_value);
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	if (CheckFloatValue (float_value))
+	  *(ValuePtr.FloatValuePtr) = float_value;
+	else
+	  return FALSE;
+	break;
+      }
+    case wxFORM_BOOL:
+      {
+	Bool bool_value = FALSE;
+	switch (ItemType)
+	  {
+	  case wxFORM_CHECKBOX:
+	    {
+	      wxCheckBox *check_item = (wxCheckBox *) PanelItem;
+	      bool_value = check_item->GetValue ();
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+	if (CheckBoolValue (bool_value))
+	  *(ValuePtr.BoolValuePtr) = bool_value;
+	else
+	  return FALSE;
+	break;
+      }
+    case wxFORM_STRING:
+      {
+	char *string_value = NULL;
+	switch (ItemType)
+	  {
+	  case wxFORM_TEXT:
+	  case wxFORM_MULTITEXT:
+	    {
+	      wxText *text_item = (wxText *) PanelItem;
+	      string_value = text_item->GetValue ();
+	      break;
+	    }
+	  case wxFORM_SINGLE_LIST:
+	    {
+	      wxListBox *list_item = (wxListBox *) PanelItem;
+	      string_value = list_item->GetStringSelection ();
+	      break;
+	    }
+	  case wxFORM_CHOICE:
+	    {
+	      wxChoice *choice_item = (wxChoice *) PanelItem;
+	      string_value = choice_item->GetStringSelection ();
+	      break;
+	    }
+	  case wxFORM_RADIOBOX:
+	    {
+	      wxRadioBox *radiobox_item = (wxRadioBox *) PanelItem;
+	      string_value = radiobox_item->GetStringSelection ();
+	      break;
+	    }
+	  default:
+	    break;
+	  }
+
+	// Check constraint values
+	if (CheckStringValue (string_value))
+	  {
+	    if (*ValuePtr.StringValuePtr)
+	      delete[](*ValuePtr.StringValuePtr);
+	    *(ValuePtr.StringValuePtr) = copystring (string_value);
+	  }
+	else
+	  {
+	    return FALSE;
+	  }
+	break;
+      }
+    default:
+      break;
+    }
+  return TRUE;
+}
+
+/*
+ * Form
+ *
+ */
+
+wxForm::wxForm (int button_use, int button_place)
+{
+  wx_form_panel = NULL;
+  wx_editable = TRUE;
+  buttonUse = button_use;
+  buttonPlace = button_place;
+}
+
+wxForm::~wxForm (void)
+{
+  wxNode *node = FormItems.First ();
+  while (node)
+    {
+      wxFormItem *item = (wxFormItem *) node->Data ();
+      wxNode *next = node->Next ();
+      delete item;
+      node = next;
+    }
+}
+
+void wxForm::Add (wxFormItem * item, long id)
+{
+  if (id < 0)
+    id = NewId ();
+  item->Id = id;
+  item->Form = this;
+  FormItems.Append (item);
+}
+
+wxNode *wxForm::FindItem (long id)
+{
+  for (wxNode * node = FormItems.First (); node; node = node->Next ())
+    if (((wxFormItem *) node->Data ())->Id == id)
+      return node;		// Found it
+
+  return NULL;
+}
+
+
+Bool wxForm::Set (long id, wxFormItem * item)
+{
+  wxNode *found = FindItem (id);
+  if (found)
+    {
+      wxNode *next = found->Next ();
+      wxFormItem *old_item = (wxFormItem *) found->Data ();
+      delete old_item;
+      FormItems.Insert (next, item);
+      return TRUE;
+    }
+  return FALSE;
+}
+
+Bool wxForm::Delete (long id)
+{
+  wxNode *found = FindItem (id);
+  if (found)
+    {
+      wxFormItem *old_item = (wxFormItem *) found->Data ();
+      delete old_item;
+      return TRUE;
+    }
+  return FALSE;
+}
+
+void wxForm::AssociatePanel (wxPanel * panel)
+{
+  wx_form_panel = panel;
+
+  if (buttonPlace == wxFORM_BUTTON_AT_TOP)
+    {
+      MakeAndPlaceButtons (wx_form_panel);
+      panel->NewLine ();
+    }
+
+  panel->NewLine ();
+
+  for (wxNode * node = FormItems.First (); node; node = node->Next ())
+    {
+      wxFormItem *item = (wxFormItem *) node->Data ();
+      item->MakePanelItem (panel);
+      item->RevertValue ();
+    }				// for()
+
+  if (buttonPlace == wxFORM_BUTTON_AT_BOTTOM)
+    {
+      panel->NewLine ();
+      MakeAndPlaceButtons (wx_form_panel);
+    }
+
+//  panel->Fit();
+}
+
+void wxForm::MakeAndPlaceButtons (wxPanel * panel)
+{
+  wxFormButton *ok_button = NULL;
+  if (buttonUse & wxFORM_BUTTON_OK)
+    {
+      ok_button = new wxFormButton (panel, (wxFunction) wxFormOk, wxSTR_BUTTON_OK);
+      ok_button->form = this;
+    }
+
+  if (wx_editable && (buttonUse & wxFORM_BUTTON_UPDATE))
+    {
+      wxFormButton *update_button = new wxFormButton (panel, (wxFunction) wxFormUpdate, wxSTR_BUTTON_UPDATE);
+      update_button->form = this;
+    }
+
+  if (buttonUse & wxFORM_BUTTON_REVERT)
+    {
+      wxFormButton *revert_button = new wxFormButton (panel, (wxFunction) wxFormRevert, wxSTR_BUTTON_REVERT);
+      revert_button->form = this;
+    }
+
+  if (wx_editable && (buttonUse & wxFORM_BUTTON_CANCEL))
+    {
+      wxFormButton *cancel_button = new wxFormButton (panel, (wxFunction) wxFormCancel, wxSTR_BUTTON_CANCEL);
+      cancel_button->form = this;
+    }
+
+  if (buttonUse & wxFORM_BUTTON_HELP)
+    {
+      wxFormButton *help_button = new wxFormButton (panel, (wxFunction) wxFormHelp, wxSTR_BUTTON_HELP);
+      help_button->form = this;
+    }
+
+  if (ok_button)
+    ok_button->SetDefault();
+}
+
+void wxForm::DisassociatePanel (void)
+{
+}
+
+Bool wxForm::UpdateValues (void)
+{
+  wxNode *node = FormItems.First ();
+  Bool success = TRUE;
+  while (node && success)
+    {
+      wxFormItem *item = (wxFormItem *) node->Data ();
+      if (!(item->UpdateValue ()))
+	success = FALSE;
+      node = node->Next ();
+    }
+
+  return success;
+}
+
+void wxForm::RevertValues (void)
+{
+  for(wxNode *node = FormItems.First (); node; node = node->Next ())
+    {
+      wxFormItem *item = (wxFormItem *) node->Data ();
+      item->RevertValue ();
+    }
+}
+
+void wxForm::OnOk (void)
+{
+  if (wx_form_panel)
+    {
+      wx_form_panel->Show (FALSE);
+      delete wx_form_panel;
+    }
+  delete this;
+}
+
+void wxForm::OnCancel (void)
+{
+  if (wx_form_panel)
+    {
+      wx_form_panel->Show (FALSE);
+      delete wx_form_panel;
+    }
+  delete this;
+}
+
+void wxForm::OnHelp (void)
+{
+}
+
+void wxForm::OnRevert (void)
+{
+}
+
+void wxForm::OnUpdate (void)
+{
+}
+
+/*
+ * Functions for creating items
+ *
+ */
+
+wxFormItem *
+wxMakeFormString (char *label, char **var,
+		  int item_type, wxList * constraints,
+		  char *help_string, int style, int width, int height)
+{
+  if (item_type == wxFORM_DEFAULT)
+    {
+      // Must decide what type of item to use.
+      // If constraint list contains a OneOf, use a single-choice list box.
+      // Else use a simple Text item
+      if (wxFormConstraintsContains (wxFORM_CONSTRAINT_ONE_OF, constraints))
+	item_type = wxFORM_SINGLE_LIST;
+      else
+	item_type = wxFORM_TEXT;
+    }
+  wxFormItem *item = new wxFormItem (wxFORM_STRING, item_type);
+  item->Constraints = constraints;
+  item->style = style;
+  if (help_string)
+    item->HelpString = copystring (help_string);
+  item->ValuePtr.StringValuePtr = var;
+  if (label)
+    item->Label = copystring (label);
+  item->Value.StringValue = NULL;
+  item->Height = height;
+  item->Width = width;
+  return item;
+}
+
+wxFormItem *
+wxMakeFormMessage (char *label)
+{
+  wxFormItem *item = new wxFormItem (wxFORM_DUMB_MESSAGE, wxFORM_DUMB_MESSAGE);
+  if (label)
+    item->Label = copystring (label);
+  return item;
+}
+
+wxFormItem *
+wxMakeFormButton (char *label, wxFunction func)
+{
+  wxFormItem *item = new wxFormItem (wxFORM_BUTTON, wxFORM_BUTTON);
+  if (label)
+    item->Label = copystring (label);
+  item->ButtonFunc = func;
+  return item;
+}
+
+wxFormItem *
+wxMakeFormNewLine (void)
+{
+  return new wxFormItem (wxFORM_NEWLINE, wxFORM_NEWLINE);
+}
+
+wxFormItem *
+wxMakeFormLong (char *label, long *var,
+		int item_type, wxList * constraints,
+		char *help_string, int style,
+		int width, int height)
+{
+  if (item_type == wxFORM_DEFAULT)
+    {
+      if (wxFormConstraintsContains (wxFORM_CONSTRAINT_RANGE, constraints))
+	item_type = wxFORM_SLIDER;
+      else
+	item_type = wxFORM_TEXT;
+    }
+  wxFormItem *item = new wxFormItem (wxFORM_LONG, item_type);
+  item->Constraints = constraints;
+  item->style = style;
+  if (help_string)
+    item->HelpString = copystring (help_string);
+  item->ValuePtr.LongIntValuePtr = var;
+  if (label)
+    item->Label = copystring (label);
+  item->Value.LongIntValue = 0;
+  item->Height = height;
+  item->Width = width;
+  return item;
+}
+
+wxFormItem *
+wxMakeFormShort (char *label, int *var,
+		 int item_type, wxList * constraints,
+		 char *help_string, int style,
+		 int width, int height)
+{
+  if (item_type == wxFORM_DEFAULT)
+    {
+      if (wxFormConstraintsContains (wxFORM_CONSTRAINT_RANGE, constraints))
+	item_type = wxFORM_SLIDER;
+      else
+	item_type = wxFORM_TEXT;
+    }
+  wxFormItem *item = new wxFormItem (wxFORM_SHORT, item_type);
+  item->Constraints = constraints;
+  item->style = style;
+  if (help_string)
+    item->HelpString = copystring (help_string);
+  item->ValuePtr.ShortIntValuePtr = var;
+  if (label)
+    item->Label = copystring (label);
+  item->Value.ShortIntValue = 0;
+  item->Height = height;
+  item->Width = width;
+  return item;
+}
+
+wxFormItem *
+wxMakeFormFloat (char *label, float *var,
+		 int item_type, wxList * constraints,
+		 char *help_string, int style,
+		 int width, int height)
+{
+  if (item_type == wxFORM_DEFAULT)
+    {
+      item_type = wxFORM_TEXT;
+    }
+  wxFormItem *item = new wxFormItem (wxFORM_FLOAT, item_type);
+  item->Constraints = constraints;
+  item->style = style;
+  if (help_string)
+    item->HelpString = copystring (help_string);
+  item->ValuePtr.FloatValuePtr = var;
+  if (label)
+    item->Label = copystring (label);
+  item->Value.FloatValue = 0.0;
+  item->Height = height;
+  item->Width = width;
+  return item;
+}
+
+wxFormItem *
+wxMakeFormBool (char *label, Bool * var,
+		int item_type, wxList * constraints,
+		char *help_string, int style,
+		int width, int height)
+{
+  if (item_type == wxFORM_DEFAULT)
+    {
+      item_type = wxFORM_CHECKBOX;
+    }
+  wxFormItem *item = new wxFormItem (wxFORM_BOOL, item_type);
+  item->Constraints = constraints;
+  item->style = style;
+  if (help_string)
+    item->HelpString = copystring (help_string);
+  item->ValuePtr.BoolValuePtr = var;
+  if (label)
+    item->Label = copystring (label);
+  item->Value.BoolValue = 0;
+  item->Height = height;
+  item->Width = width;
+  return item;
+}
+
+/*
+ * Functions for creating constraints
+ *
+ */
+
+wxFormItemConstraint *
+wxMakeConstraintStrings (wxList * list)
+{
+  wxFormItemConstraint *constraint =
+  new wxFormItemConstraint (wxFORM_CONSTRAINT_ONE_OF);
+  constraint->Constraint.OneOf = list;
+  return constraint;
+}
+
+wxFormItemConstraint *
+wxMakeConstraintStrings (char *first...)
+{
+// #ifndef __sgi
+  wxList *list = new wxList;
+  va_list ap;
+
+  va_start (ap, first);
+  list->Append ((wxObject *) copystring (first));
+
+  for (;;)
+    {
+      char *s = va_arg (ap, char *);
+      if ( s )
+	list->Append ((wxObject *) copystring (s));
+      else
+	break;
+    }
+
+  va_end (ap);
+
+  wxFormItemConstraint *constraint =
+  new wxFormItemConstraint (wxFORM_CONSTRAINT_ONE_OF);
+  constraint->Constraint.OneOf = list;
+  constraint->localList = TRUE;	// This list MUST BE deleted.
+
+  return constraint;
+/*
+#else
+  fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
+  return NULL;
+#endif
+*/
+}
+
+wxFormItemConstraint *
+wxMakeConstraintRange (float lo, float hi)
+{
+  wxFormItemConstraint *constraint =
+  new wxFormItemConstraint (wxFORM_CONSTRAINT_RANGE);
+  constraint->Constraint.Range = new wxRealRange (lo, hi);
+  return constraint;
+}
+
+wxFormItemConstraint *
+wxMakeConstraintFunction (wxConstraintFunction func)
+{
+  wxFormItemConstraint *constraint =
+  new wxFormItemConstraint (wxFORM_CONSTRAINT_FUNCTION);
+  constraint->Constraint.ConstraintFunc = func;
+  return constraint;
+}
+
+/*
+ * Helper functions
+ *
+ */
+
+wxFormItemConstraint *
+wxFormConstraintsContains (int type, wxList * constraints)
+{
+  if (constraints)
+   for(wxNode *node = constraints->First (); node; node = node->Next())
+    {
+      wxFormItemConstraint *constraint = (wxFormItemConstraint *) node->Data ();
+      if (constraint && constraint->Type == type)
+	return constraint;
+    }
+
+  return NULL;		// Nope
+}
+
+/*
+ * Form display items and helper functions
+ *
+ */
+
+wxFormButton::wxFormButton (wxPanel * panel, wxFunction func, char *label,
+int x, int y, int width, int height):
+wxButton (panel, func, label, x, y, width, height)
+{
+}
+
+static void 
+wxFormOk (wxFormButton & button, wxEvent &)
+{
+  Bool success = TRUE;
+
+  if (button.form->wx_editable)
+    success = button.form->UpdateValues ();
+
+  if (success)
+    button.form->OnOk ();
+}
+
+static void 
+wxFormUpdate (wxFormButton & button, wxEvent &)
+{
+  Bool success = button.form->UpdateValues ();
+  if (success)
+    button.form->OnUpdate ();
+}
+
+static void 
+wxFormRevert (wxFormButton & button, wxEvent &)
+{
+  button.form->RevertValues ();
+  button.form->OnRevert ();
+}
+
+static void 
+wxFormCancel (wxFormButton & button, wxEvent &)
+{
+  button.form->OnCancel ();
+}
+
+static void 
+wxFormHelp (wxFormButton & button, wxEvent &)
+{
+  button.form->OnHelp ();
+}
+
+#endif // USE_FORM
diff --git a/src/wxmac/src/base/wb_frame.cc b/src/wxmac/src/base/wb_frame.cc
new file mode 100644
index 0000000..3a9f62b
--- /dev/null
+++ b/src/wxmac/src/base/wb_frame.cc
@@ -0,0 +1,269 @@
+/*
+ * File:	wb_frame.cc
+ * Purpose:	wxFrame implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_frame.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_frame.h"
+#include "wx_gdi.h"
+#include "wx_stdev.h"
+#include "wx_main.h"
+#include "wx_utils.h"
+#include "wx_menu.h"
+#include "wx_mnuit.h"
+#ifdef wx_mac
+#include "wx_screen.h"
+#endif
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+ 
+#include "wx_stdev.h"
+
+#include <iostream.h>
+
+#ifndef wx_mac
+wxbFrame::wxbFrame(void)
+{
+  __type = wxTYPE_FRAME;
+  nb_status = 0;
+  frameToolBar = NULL ;
+}
+
+wxbFrame::wxbFrame(wxFrame *Parent, char *title, int x, int y,
+                 int width, int height, long style, char *name)
+{
+  __type = wxTYPE_FRAME;
+  windowStyle = style;
+  frameToolBar = NULL ;
+
+  WXGC_IGNORE(context);
+  context = wxGetContextForFrame();
+}
+
+Bool wxbFrame::Create(wxFrame *Parent, char *title, int x, int y,
+                 int width, int height, long style, char *name)
+{
+  windowStyle = style;
+
+  WXGC_IGNORE(context);
+  context = wxGetContextForFrame();
+
+  if (!Parent) {
+    wxTopLevelWindows(ContextWindow())->Append(this);
+    wxTopLevelWindows(ContextWindow())->Show(this, FALSE);
+  }
+  return TRUE;
+}
+#endif // wx_mac
+
+#ifdef wx_mac
+//-----------------------------------------------------------------------------
+// Constructor (given parentScreen)
+wxbFrame::wxbFrame (char* windowName, wxScreen* parentScreen,
+		int x, int y, int width, int height, long style)
+	:
+		wxWindow ( windowName, parentScreen, x, y, width, height, style),
+		frame_type (style & (wxSDI | wxMDI_PARENT | wxMDI_CHILD)),
+		icon (NULL),
+		modal_showing (FALSE),
+		nb_status (0),
+		status_line_exists (FALSE),
+		wx_menu_bar (NULL)
+{
+	__type = wxTYPE_FRAME;
+
+	WXGC_IGNORE(context);
+	context = wxGetContextForFrame();
+
+    wxTopLevelWindows(ContextWindow())->Append(this);
+    wxTopLevelWindows(ContextWindow())->Show(this, FALSE);
+}
+
+#endif // wx_mac
+
+wxbFrame::~wxbFrame(void)
+{
+  wxTopLevelWindows(ContextWindow())->DeleteObject(this);
+}
+
+// Default resizing behaviour - if only ONE subwindow,
+// resize to client rectangle size
+void wxbFrame::OnSize(int x, int y)
+{
+#if DEBUG > 1
+  wxDebugMsg("wxbFrame::OnSize\n");
+#endif
+  if (frame_type == wxMDI_PARENT)
+    return;
+
+  // Search for a child which is a subwindow, not another frame.
+  wxWindow *child = NULL;
+  // Count the number of _subwindow_ children
+  int noChildren = 0;
+  for(wxChildNode *node = GetChildren()->First(); node; node = node->Next())
+  {
+    wxWindow *win = (wxWindow *)node->Data();
+    WXTYPE winType = win->__type;
+
+    if (wxSubType(winType, wxTYPE_PANEL) ||
+        wxSubType(winType, wxTYPE_TEXT_WINDOW) ||
+        wxSubType(winType, wxTYPE_CANVAS))
+    {
+      child = win;
+      noChildren ++;
+    }
+  }
+  if (!child || (noChildren > 1))
+    return;
+
+  int client_x, client_y;
+
+#if DEBUG > 1
+  wxDebugMsg("wxbFrame::OnSize: about to set the child's size.\n");
+#endif
+
+  GetClientSize(&client_x, &client_y);
+  child->SetSize(0, 0, client_x, client_y, 0x70);
+}
+
+// Default activation behaviour - set the focus for the first child
+// subwindow found.
+void wxbFrame::OnActivate(Bool flag)
+{
+  wxWindow::OnActivate(flag); //GRW
+
+  if (!flag)
+    return;
+
+  for(wxChildNode *node = GetChildren()->First(); node; node = node->Next())
+  {
+    // Find a child that's a subwindow, but not a dialog box.
+    wxWindow *child = (wxWindow *)node->Data();
+    if ((wxSubType(child->__type, wxTYPE_PANEL) &&
+         !wxSubType(child->__type, wxTYPE_DIALOG_BOX)) ||
+        wxSubType(child->__type, wxTYPE_TEXT_WINDOW) ||
+        wxSubType(child->__type, wxTYPE_CANVAS))
+    {
+#if DEBUG > 1
+      wxDebugMsg("wxbFrame::OnActivate: about to set the child's focus.\n");
+#endif
+      child->SetFocus();
+      return;
+    }
+  }
+}
+
+// Default menu selection behaviour - display a help string
+void wxbFrame::OnMenuSelect(int id)
+{
+  if (StatusLineExists())
+  {
+    if (id == -1)
+      SetStatusText("");
+    else
+    {
+      wxMenuBar *menuBar = GetMenuBar();
+      if (menuBar)
+      {
+        char *helpString = GetMenuBar()->GetHelpString(id);
+        if (helpString)
+          SetStatusText(helpString);
+      }
+    }
+  }
+}
+
+#ifdef wx_mac // The following belongs in this file! Moved from wb_item.cc
+void wxbFrame::SetMenuBar(wxMenuBar *menu_bar)
+{
+}
+#endif // wx_mac
+
+wxMenuBar *wxbFrame::GetMenuBar(void)
+{
+  return wx_menu_bar;
+}
+
+Bool wxbFrame::StatusLineExists(void)
+{
+  return status_line_exists;
+}
+
+void wxbFrame::Centre(int direction)
+{
+  int display_width, display_height, width, height, x, y;
+  wxDisplaySize(&display_width, &display_height);
+
+  GetSize(&width, &height);
+  GetPosition(&x, &y);
+
+  if (direction & wxHORIZONTAL)
+    x = (int)((display_width - width)/2);
+  if (direction & wxVERTICAL)
+    y = (int)((display_height - height)/2);
+
+  SetSize(x, y, width, height, wxPOS_USE_MINUS_ONE);
+}
+
+// Call this to simulate a menu command
+void wxbFrame::Command(int id)
+{
+  ProcessCommand(id);
+}
+
+void wxbFrame::ProcessCommand(int id)
+{
+  wxCommandEvent *_commandEvent = new wxCommandEvent(wxEVENT_TYPE_MENU_COMMAND);
+  wxCommandEvent &commandEvent = *_commandEvent;
+  
+  commandEvent.commandInt = id;
+
+  if (wxNotifyEvent(commandEvent, TRUE))
+    return;
+
+  wxMenuBar *bar = GetMenuBar() ;
+  if (!bar)
+    return;
+
+  // Motif does the job by itself!!
+#ifndef wx_motif
+  wxMenuItem *item = bar->FindItemForId(id) ;
+#ifdef wx_mac
+  if (item && item->IsCheckable())
+  {
+    bar->Check(id,!bar->Checked(id)) ;
+  }
+#else // wx_mac
+  if (item && item->checkable)
+  {
+//wxDebugMsg("Toggling id %d\n",id) ;
+    bar->Check(id,!bar->Checked(id)) ;
+  }
+#endif // wx_mac
+
+#endif
+  OnMenuCommand(id);
+
+  wxNotifyEvent(commandEvent, FALSE);
+}
+
diff --git a/src/wxmac/src/base/wb_gdi.cc b/src/wxmac/src/base/wb_gdi.cc
new file mode 100644
index 0000000..ac09ea8
--- /dev/null
+++ b/src/wxmac/src/base/wb_gdi.cc
@@ -0,0 +1,1526 @@
+/*
+ * File:      wb_gdi.cc
+ * Purpose:     GDI (Graphics Device Interface) objects and functions
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:     August 1994
+ * RCS_ID:      $Id: wb_gdi.cc,v 1.4 1994/08/14 22:59:35 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_list.h"
+#include "wx_utils.h"
+#include "wx_main.h"
+#include "wx_gdi.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#ifdef wx_x
+extern Colormap wxMainColormap;
+#endif
+#ifdef wx_xview
+extern Xv_Server xview_server;
+#endif
+#if USE_IMAGE_LOADING_IN_MAC
+#include "wx_image.h"
+#endif
+
+
+wxbFont::wxbFont (void)
+{
+  __type = wxTYPE_FONT;
+}
+
+/* Constructor for a font. Note that the real construction is done
+ * in wxDC::SetFont, when information is available about scaling etc.
+ */
+wxbFont::wxbFont (int PointSize, int Family, int Style, int Weight, Bool Underline)
+{
+  __type = wxTYPE_FONT;
+}
+
+wxbFont::~wxbFont ()
+{
+}
+
+char *wxbFont::GetFamilyString(void)
+{
+  char *fam = NULL;
+  switch (GetFamily())
+  {
+    case wxDECORATIVE:
+      fam = "wxDECORATIVE";
+      break;
+    case wxROMAN:
+      fam = "wxROMAN";
+      break;
+    case wxSCRIPT:
+      fam = "wxSCRIPT";
+      break;
+    case wxSWISS:
+      fam = "wxSWISS";
+      break;
+    case wxMODERN:
+      fam = "wxMODERN";
+      break;
+    case wxTELETYPE:
+      fam = "wxTELETYPE";
+      break;
+    case wxSYSTEM:
+      fam = "wxSYSTEM";
+      break;
+    default:
+      fam = "wxDEFAULT";
+      break;
+  }
+  return fam;
+}
+
+char *wxbFont::GetFaceString(void)
+{
+  return wxTheFontNameDirectory.GetFontName(fontid); 
+}
+
+char *wxbFont::GetStyleString(void)
+{
+  char *styl = NULL;
+  switch (GetStyle())
+  {
+    case wxITALIC:
+      styl = "wxITALIC";
+      break;
+    case wxSLANT:
+      styl = "wxSLANT";
+      break;
+    default:
+      styl = "wxNORMAL";
+      break;
+  }
+  return styl;
+}
+
+char *wxbFont::GetWeightString(void)
+{
+  char *w = NULL;
+  switch (GetWeight())
+  {
+    case wxBOLD:
+      w = "wxBOLD";
+      break;
+    case wxLIGHT:
+      w = "wxLIGHT";
+      break;
+    default:
+      w = "wxNORMAL";
+      break;
+  }
+  return w;
+}
+
+// Colour
+
+wxColour::wxColour (void)
+{
+  __type = wxTYPE_COLOUR;
+  isInit = FALSE;
+#ifdef wx_x
+  pixel = -1;
+#endif
+#ifdef wx_msw
+  pixel = 0;
+#endif
+#ifdef wx_mac
+  red = 0; green = 0; blue = 0;
+  pixel.red = 0;
+  pixel.green = 0;
+  pixel.blue = 0;
+#endif
+  locked = 0;
+//  wxTheColourList->Append (this);
+}
+
+wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
+{
+  __type = wxTYPE_COLOUR;
+  red = r;
+  green = g;
+  blue = b;
+  isInit = TRUE;
+#ifdef wx_x
+  pixel = -1;
+#endif
+#ifdef wx_msw
+  pixel = RGB (red, green, blue);
+#endif
+#ifdef wx_mac
+  pixel.red = red << 8;
+  pixel.green = green << 8;
+  pixel.blue = blue << 8;
+#endif
+  locked = 0;
+//  wxTheColourList->Append (this);
+}
+
+wxColour::wxColour (const char *col)
+{
+  __type = wxTYPE_COLOUR;
+  wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+  if (the_colour)
+    {
+      red = the_colour->Red ();
+      green = the_colour->Green ();
+      blue = the_colour->Blue ();
+      isInit = TRUE;
+    }
+  else
+    {
+      red = 0;
+      green = 0;
+      blue = 0;
+      isInit = FALSE;
+    }
+#ifdef wx_x
+  pixel = -1;
+#endif
+#ifdef wx_msw
+  pixel = RGB (red, green, blue);
+#endif
+#ifdef wx_mac
+  pixel.red = red << 8;
+  pixel.green = green << 8;
+  pixel.blue = blue << 8;
+#endif
+//  wxTheColourList->Append (this);
+  locked = 0;
+}
+
+wxColour::~wxColour (void)
+{
+//  wxTheColourList->DeleteObject (this);
+}
+
+wxColour& wxColour::operator =(wxColour& src)
+{
+  red = src.red;
+  green = src.green;
+  blue = src.blue;
+  pixel = src.pixel;
+  isInit = src.isInit;
+#ifdef wx_mac
+  pixel.red = red << 8;
+  pixel.green = green << 8;
+  pixel.blue = blue << 8;
+#endif
+  return (*this);
+}
+
+wxColour& wxColour::operator = (const char *col)
+{
+  wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+  if (the_colour)
+    {
+      red = the_colour->Red ();
+      green = the_colour->Green ();
+      blue = the_colour->Blue ();
+      isInit = TRUE;
+    }
+  else
+    {
+      red = 0;
+      green = 0;
+      blue = 0;
+      isInit = FALSE;
+    }
+#ifdef wx_x
+  pixel = -1;
+#endif
+#ifdef wx_msw
+  pixel = RGB (red, green, blue);
+#endif
+#ifdef wx_mac
+  pixel.red = red << 8;
+  pixel.green = green << 8;
+  pixel.blue = blue << 8;
+#endif
+  return (*this);
+}
+
+void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
+{
+  red = r;
+  green = g;
+  blue = b;
+  isInit = TRUE;
+#ifdef wx_x
+  pixel = -1;
+#endif
+#ifdef wx_msw
+  pixel = RGB (red, green, blue);
+#endif
+#ifdef wx_mac
+  pixel.red = red << 8;
+  pixel.green = green << 8;
+  pixel.blue = blue << 8;
+#endif
+}
+
+void wxColour::Get (unsigned char *r, unsigned char *g, unsigned char *b)
+{
+  *r = red;
+  *g = green;
+  *b = blue;
+}
+
+#ifdef wx_mac
+wxColourDatabase::wxColourDatabase(KeyType type):wxList(type)
+#else
+wxColourDatabase::wxColourDatabase (int type):
+wxList (type)
+#endif
+{
+}
+
+wxColourDatabase::~wxColourDatabase (void)
+{
+  // Cleanup Colour allocated in Initialize()
+  wxNode *node = First ();
+  while (node)
+    {
+      wxColour *col = (wxColour *) node->Data ();
+      wxNode *next = node->Next ();
+      delete col;
+      node = next;
+    }
+}
+
+// Colour database stuff
+void wxColourDatabase::Initialize (void)
+{
+  // Don't initialize for X: colours are found
+  // in FindColour below.
+#if defined(wx_msw) || defined(wx_mac)
+#define APPEND(name, c) tmpc = c; tmpc->Lock(1); Append(name, tmpc)
+  wxColour *tmpc;
+  APPEND ("AQUAMARINE", new wxColour (112, 219, 147));
+  APPEND ("BLACK", new wxColour (0, 0, 0));
+  APPEND ("BLUE", new wxColour (0, 0, 255));
+  APPEND ("BLUE VIOLET", new wxColour (159, 95, 159));
+  APPEND ("BROWN", new wxColour (165, 42, 42));
+  APPEND ("CADET BLUE", new wxColour (95, 159, 159));
+  APPEND ("CORAL", new wxColour (255, 127, 0));
+  APPEND ("CORNFLOWER BLUE", new wxColour (66, 66, 111));
+  APPEND ("CYAN", new wxColour (0, 255, 255));
+  APPEND ("DARK GREY", new wxColour (47, 47, 47));	// ?
+
+  APPEND ("DARK GREEN", new wxColour (47, 79, 47));
+  APPEND ("DARK OLIVE GREEN", new wxColour (79, 79, 47));
+  APPEND ("DARK ORCHID", new wxColour (153, 50, 204));
+  APPEND ("DARK SLATE BLUE", new wxColour (107, 35, 142));
+  APPEND ("DARK SLATE GREY", new wxColour (47, 79, 79));
+  APPEND ("DARK TURQUOISE", new wxColour (112, 147, 219));
+  APPEND ("DIM GREY", new wxColour (84, 84, 84));
+  APPEND ("FIREBRICK", new wxColour (142, 35, 35));
+  APPEND ("FOREST GREEN", new wxColour (35, 142, 35));
+  APPEND ("GOLD", new wxColour (204, 127, 50));
+  APPEND ("GOLDENROD", new wxColour (219, 219, 112));
+#ifdef wx_msw
+  APPEND ("GREY", new wxColour (128, 128, 128));
+#else
+  APPEND ("GREY", new wxColour (192, 192, 192));
+#endif
+  APPEND ("GREEN", new wxColour (0, 255, 0));
+  APPEND ("GREEN YELLOW", new wxColour (147, 219, 112));
+  APPEND ("INDIAN RED", new wxColour (79, 47, 47));
+  APPEND ("KHAKI", new wxColour (159, 159, 95));
+  APPEND ("LIGHT BLUE", new wxColour (191, 216, 216));
+#ifdef wx_msw
+  APPEND ("LIGHT GREY", new wxColour (192, 192, 192));
+#else
+  APPEND ("LIGHT GREY", new wxColour (168, 168, 168));
+#endif
+  APPEND ("LIGHT STEEL BLUE", new wxColour (143, 143, 188));
+  APPEND ("LIME GREEN", new wxColour (50, 204, 50));
+  APPEND ("LIGHT MAGENTA", new wxColour (255, 0, 255));
+  APPEND ("MAGENTA", new wxColour (255, 0, 255));
+  APPEND ("MAROON", new wxColour (142, 35, 107));
+  APPEND ("MEDIUM AQUAMARINE", new wxColour (50, 204, 153));
+  APPEND ("MEDIUM GREY", new wxColour (100, 100, 100));
+  APPEND ("MEDIUM BLUE", new wxColour (50, 50, 204));
+  APPEND ("MEDIUM FOREST GREEN", new wxColour (107, 142, 35));
+  APPEND ("MEDIUM GOLDENROD", new wxColour (234, 234, 173));
+  APPEND ("MEDIUM ORCHID", new wxColour (147, 112, 219));
+  APPEND ("MEDIUM SEA GREEN", new wxColour (66, 111, 66));
+  APPEND ("MEDIUM SLATE BLUE", new wxColour (127, 0, 255));
+  APPEND ("MEDIUM SPRING GREEN", new wxColour (127, 255, 0));
+  APPEND ("MEDIUM TURQUOISE", new wxColour (112, 219, 219));
+  APPEND ("MEDIUM VIOLET RED", new wxColour (219, 112, 147));
+  APPEND ("MIDNIGHT BLUE", new wxColour (47, 47, 79));
+  APPEND ("NAVY", new wxColour (35, 35, 142));
+  APPEND ("ORANGE", new wxColour (204, 50, 50));
+  APPEND ("ORANGE RED", new wxColour (255, 0, 127));
+  APPEND ("ORCHID", new wxColour (219, 112, 219));
+  APPEND ("PALE GREEN", new wxColour (143, 188, 143));
+  APPEND ("PINK", new wxColour (188, 143, 234));
+  APPEND ("PLUM", new wxColour (234, 173, 234));
+  APPEND ("PURPLE", new wxColour (176, 0, 255));
+  APPEND ("RED", new wxColour (255, 0, 0));
+  APPEND ("SALMON", new wxColour (111, 66, 66));
+  APPEND ("SEA GREEN", new wxColour (35, 142, 107));
+  APPEND ("SIENNA", new wxColour (142, 107, 35));
+  APPEND ("SKY BLUE", new wxColour (50, 153, 204));
+  APPEND ("SLATE BLUE", new wxColour (0, 127, 255));
+  APPEND ("SPRING GREEN", new wxColour (0, 255, 127));
+  APPEND ("STEEL BLUE", new wxColour (35, 107, 142));
+  APPEND ("TAN", new wxColour (219, 147, 112));
+  APPEND ("THISTLE", new wxColour (216, 191, 216));
+  APPEND ("TURQUOISE", new wxColour (173, 234, 234));
+  APPEND ("VIOLET", new wxColour (79, 47, 79));
+  APPEND ("VIOLET RED", new wxColour (204, 50, 153));
+  APPEND ("WHEAT", new wxColour (216, 216, 191));
+  APPEND ("WHITE", new wxColour (255, 255, 255));
+  APPEND ("YELLOW", new wxColour (255, 255, 0));
+  APPEND ("YELLOW GREEN", new wxColour (153, 204, 50));
+#endif
+}
+
+/*
+ * Changed by Ian Brown, July 1994.
+ *
+ * When running under X, the Colour Database starts off empty. The X server
+ * is queried for the colour first time after which it is entered into the
+ * database. This allows our client to use the server colour database which
+ * is hopefully gamma corrected for the display being used.
+ */
+
+wxColour *wxColourDatabase::FindColour(const char *colour)
+{
+  const char *p;
+  
+  // Insure upcased:
+  for (p = colour; *p && !islower(*p); p++);
+  if (*p) {
+  	char *naya = new char[strlen(colour) + 1], *q;
+  	for (p = colour, q = naya; *p; p++, q++)
+  		*q = toupper(*p);
+  	*q = 0;
+  	colour = naya;
+  }
+
+  wxNode *node = Find(colour);
+  if (node)
+    return (wxColour *)node->Data();
+#if defined(wx_msw) || defined(wx_mac)
+  else return NULL;
+#else
+  else {
+    XColor xcolour;
+
+#ifdef wx_motif
+    Display *display = XtDisplay(wxTheApp->topLevel) ;
+#endif
+#ifdef wx_xview
+    Xv_Screen screen = xv_get(xview_server, SERVER_NTH_SCREEN, 0);
+    Xv_opaque root_window = xv_get(screen, XV_ROOT);
+    Display *display = (Display *)xv_get(root_window, XV_DISPLAY);
+#endif
+
+    if (!XParseColor(display, wxMainColormap,colour,&xcolour))
+      return NULL;
+
+    unsigned char r = (unsigned char)(xcolour.red >> 8);
+    unsigned char g = (unsigned char)(xcolour.green >> 8);
+    unsigned char b = (unsigned char)(xcolour.blue >> 8);
+
+    wxColour *col = new wxColour(r, g, b);
+    Append(colour, col);
+
+    return col;
+  }
+#endif
+}
+
+/* Old FindColour
+wxColour *wxColourDatabase::FindColour (const char *colour)
+{
+  wxNode *node = Find (colour);
+  return node ? (wxColour *) node->Data () : NULL ;
+}
+*/
+
+char *wxColourDatabase::FindName (wxColour& colour)
+{
+  unsigned char red = colour.Red ();
+  unsigned char green = colour.Green ();
+  unsigned char blue = colour.Blue ();
+
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      wxColour *col = (wxColour *) node->Data ();
+      if (col->Red () == red && col->Green () == green && col->Blue () == blue)
+	{
+	  char *found = node->key.string;
+	  if (found)
+	    return found;
+	}
+    }
+  return NULL;			// Not Found
+
+}
+
+
+void 
+wxInitializeStockObjects (void)
+{
+  wxTheBrushList = new wxBrushList;
+  wxThePenList = new wxPenList;
+  wxTheFontList = new wxFontList;
+  wxTheBitmapList = new wxGDIList;
+#ifdef wx_mac
+  wxTheCursorList = new wxGDIList;
+  wxTheIconList =  new wxGDIList;
+#endif
+  // wxTheColourList =  new wxGDIList;
+
+#ifdef wx_motif
+#endif
+#ifdef wx_x
+  wxFontPool = new XFontPool;
+#endif
+
+#if 1
+  wxNORMAL_FONT = new wxFont (12, wxSYSTEM, wxNORMAL, wxNORMAL);
+#else
+  wxNORMAL_FONT = new wxFont (12, wxMODERN, wxNORMAL, wxNORMAL);
+#endif
+  wxSMALL_FONT = new wxFont (10, wxSWISS, wxNORMAL, wxNORMAL);
+  wxITALIC_FONT = new wxFont (12, wxROMAN, wxITALIC, wxNORMAL);
+  wxSWISS_FONT = new wxFont (12, wxSWISS, wxNORMAL, wxNORMAL);
+
+  wxRED_PEN = new wxPen ("RED", 0, wxSOLID);
+  wxCYAN_PEN = new wxPen ("CYAN", 0, wxSOLID);
+  wxGREEN_PEN = new wxPen ("GREEN", 0, wxSOLID);
+  wxBLACK_PEN = new wxPen ("BLACK", 0, wxSOLID);
+  wxWHITE_PEN = new wxPen ("WHITE", 0, wxSOLID);
+  wxTRANSPARENT_PEN = new wxPen ("BLACK", 0, wxTRANSPARENT);
+  wxBLACK_DASHED_PEN = new wxPen ("BLACK", 0, wxSHORT_DASH);
+  wxGREY_PEN = new wxPen ("GREY", 0, wxSOLID);
+  wxMEDIUM_GREY_PEN = new wxPen ("MEDIUM GREY", 0, wxSOLID);
+  wxLIGHT_GREY_PEN = new wxPen ("LIGHT GREY", 0, wxSOLID);
+
+  wxWHITE_PEN->Lock(1);
+  wxBLACK_PEN->Lock(1);
+
+  wxBLUE_BRUSH = new wxBrush ("BLUE", wxSOLID);
+  wxGREEN_BRUSH = new wxBrush ("GREEN", wxSOLID);
+  wxWHITE_BRUSH = new wxBrush ("WHITE", wxSOLID);
+  wxBLACK_BRUSH = new wxBrush ("BLACK", wxSOLID);
+  wxTRANSPARENT_BRUSH = new wxBrush ("BLACK", wxTRANSPARENT);
+  wxCYAN_BRUSH = new wxBrush ("CYAN", wxSOLID);
+  wxRED_BRUSH = new wxBrush ("RED", wxSOLID);
+  wxGREY_BRUSH = new wxBrush ("GREY", wxSOLID);
+  wxMEDIUM_GREY_BRUSH = new wxBrush ("MEDIUM GREY", wxSOLID);
+  wxLIGHT_GREY_BRUSH = new wxBrush ("LIGHT GREY", wxSOLID);
+  
+  wxWHITE_BRUSH->Lock(1);
+  wxBLACK_BRUSH->Lock(1);
+  
+  wxColour ctlGray(0xF0, 0xF0, 0xF0);
+  wxCONTROL_BACKGROUND_BRUSH = new wxBrush(ctlGray, wxSOLID);
+  wxCONTROL_BACKGROUND_BRUSH->Lock(1);
+
+  wxBLACK = new wxColour ("BLACK");
+  wxWHITE = new wxColour ("WHITE");
+  wxRED = new wxColour ("RED");
+  wxBLUE = new wxColour ("BLUE");
+  wxGREEN = new wxColour ("GREEN");
+  wxCYAN = new wxColour ("CYAN");
+  wxLIGHT_GREY = new wxColour ("LIGHT GREY");
+
+  wxSTANDARD_CURSOR = new wxCursor (wxCURSOR_ARROW);
+  wxHOURGLASS_CURSOR = new wxCursor (wxCURSOR_WAIT);
+  wxCROSS_CURSOR = new wxCursor (wxCURSOR_CROSS);
+}
+
+void 
+wxDeleteStockObjects (void)
+{
+  if (wxBLACK)
+    delete wxBLACK;
+  if (wxWHITE)
+    delete wxWHITE;
+  if (wxRED)
+    delete wxRED;
+  if (wxBLUE)
+    delete wxBLUE;
+  if (wxGREEN)
+    delete wxGREEN;
+  if (wxCYAN)
+    delete wxCYAN;
+  if (wxLIGHT_GREY)
+    delete wxLIGHT_GREY;
+
+  if (wxSTANDARD_CURSOR)
+    delete wxSTANDARD_CURSOR;
+  if (wxHOURGLASS_CURSOR)
+    delete wxHOURGLASS_CURSOR;
+  if (wxCROSS_CURSOR)
+    delete wxCROSS_CURSOR;
+}
+
+// Pens
+
+wxbPen::wxbPen (void)
+{
+  __type = wxTYPE_PEN;
+  locked = 0;
+}
+
+wxbPen::~wxbPen ()
+{
+	if (stipple)
+		--stipple->selectedIntoDC;
+}
+
+wxbPen::wxbPen (wxColour& col, int Width, int Style)
+{
+  locked = 0;
+  __type = wxTYPE_PEN;
+}
+
+wxbPen::wxbPen (const char *col, int Width, int Style)
+{
+  locked = 0;
+  __type = wxTYPE_PEN;
+}
+
+int wxbPen::GetWidth (void)
+{
+  return width;
+}
+
+int wxbPen::GetStyle (void)
+{
+  return style;
+}
+
+int wxbPen::GetJoin (void)
+{
+  return join;
+}
+
+wxBitmap *wxbPen::GetStipple (void)
+{
+  return stipple;
+}
+
+int wxbPen::GetCap (void)
+{
+  return cap;
+}
+
+int wxbPen::GetDashes (wxDash ** ptr)
+{
+  *ptr = dash;
+  return nb_dash;
+}
+
+wxColour& wxbPen::GetColour (void)
+{
+  return colour;
+}
+
+void wxbPen::SetColour (wxColour& col)
+{
+  colour = col;
+}
+
+void wxbPen::SetColour (const char *col)
+{
+  colour = col;
+}
+
+void wxbPen::SetColour (char red, char green, char blue)
+{
+ colour.Set(red, green, blue);
+}
+
+void wxbPen::SetWidth (int Width)
+{
+  width = Width;
+}
+
+void wxbPen::SetCap (int Cap)
+{
+  cap = Cap;
+}
+
+void wxbPen::SetJoin (int Join)
+{
+  join = Join;
+}
+
+void wxbPen::SetStyle (int Style)
+{
+  style = Style;
+}
+
+void wxbPen::SetDashes (int nbDash, wxDash * Dash)
+{
+  nb_dash = nbDash;
+  dash = Dash;
+}
+
+void wxbPen::SetStipple (wxBitmap * Stipple)
+{
+  if (Stipple && (Stipple->selectedIntoDC < 0))
+    return;
+  if (Stipple)
+    Stipple->selectedIntoDC++;
+  if (stipple)
+    --stipple->selectedIntoDC;
+
+  stipple = Stipple;
+}
+
+// Brushes
+
+wxbBrush::wxbBrush (void)
+{
+  __type = wxTYPE_BRUSH;
+  locked = 0;
+}
+
+wxbBrush::~wxbBrush ()
+{
+	if (stipple)
+		--stipple->selectedIntoDC;
+}
+
+wxbBrush::wxbBrush (wxColour& col, int Style)
+{
+  __type = wxTYPE_BRUSH;
+  locked = 0;
+}
+
+wxbBrush::wxbBrush (char *col, int Style)
+{
+  __type = wxTYPE_BRUSH;
+  locked = 0;
+}
+
+int wxbBrush::GetStyle (void)
+{
+  return style;
+}
+
+wxBitmap *wxbBrush::GetStipple (void)
+{
+  return stipple;
+}
+
+wxColour& wxbBrush::GetColour (void)
+{
+  return colour;
+}
+
+void wxbBrush::SetColour (wxColour& col)
+{
+  colour = col;
+}
+
+void wxbBrush::SetColour (const char *col)
+{
+  colour = col;
+}
+
+void wxbBrush::SetColour (char red, char green, char blue)
+{
+  colour.Set(red, green, blue);
+}
+
+void wxbBrush::SetStyle (int Style)
+{
+  style = Style;
+}
+
+void wxbBrush::SetStipple (wxBitmap * Stipple)
+{
+  if (Stipple && (Stipple->selectedIntoDC < 0))
+    return;
+  if (Stipple)
+    Stipple->selectedIntoDC++;
+  if (stipple)
+    --stipple->selectedIntoDC;
+
+  stipple = Stipple;
+}
+
+wxGDIList::wxGDIList (void)
+{
+}
+
+wxGDIList::~wxGDIList (void)
+{
+#ifndef wx_x
+  wxNode *node = First ();
+  while (node)
+    {
+      wxObject *object = (wxObject *) node->Data ();
+      wxNode *next = node->Next ();
+      delete object;
+      node = next;
+    }
+#endif
+}
+
+// Pen and Brush lists
+wxPenList::~wxPenList (void)
+{
+  wxNode *node = First ();
+  while (node)
+    {
+      wxPen *pen = (wxPen *) node->Data ();
+      wxNode *next = node->Next ();
+      delete pen;
+      node = next;
+    }
+}
+
+void wxPenList::AddPen (wxPen * pen)
+{
+  Append (pen);
+  pen->Lock(1);
+}
+
+void wxPenList::RemovePen (wxPen * pen)
+{
+  DeleteObject (pen);
+}
+
+wxPen *wxPenList::FindOrCreatePen (wxColour * colour, int width, int style)
+{
+  wxPen *pen;
+
+  if (!colour)
+    return NULL;
+
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      wxPen *each_pen = (wxPen *) node->Data ();
+      if (each_pen &&
+	  each_pen->GetWidth () == width &&
+	  each_pen->GetStyle () == style &&
+	  each_pen->GetColour ().Red () == colour->Red () &&
+	  each_pen->GetColour ().Green () == colour->Green () &&
+	  each_pen->GetColour ().Blue () == colour->Blue ())
+	return each_pen;
+    }
+  pen = new wxPen (*colour, width, style);
+#if WXGARBAGE_COLLECTION_ON
+  AddPen(pen);
+#endif
+  return pen;
+}
+
+wxPen *wxPenList::FindOrCreatePen (char *colour, int width, int style)
+{
+  wxColour *the_colour = wxTheColourDatabase->FindColour (colour);
+  if (the_colour)
+    return FindOrCreatePen (the_colour, width, style);
+  else
+    return NULL;
+}
+
+wxBrushList::~wxBrushList (void)
+{
+  wxNode *node = First ();
+  while (node)
+    {
+      wxBrush *brush = (wxBrush *) node->Data ();
+      wxNode *next = node->Next ();
+      delete brush;
+      node = next;
+    }
+}
+
+void wxBrushList::AddBrush (wxBrush * brush)
+{
+  brush->Lock(1);
+  Append (brush);
+}
+
+wxBrush *wxBrushList::FindOrCreateBrush (wxColour * colour, int style)
+{
+  wxBrush *brush;
+
+  if (!colour)
+    return NULL;
+
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      wxBrush *each_brush = (wxBrush *) node->Data ();
+      if (each_brush &&
+	  each_brush->GetStyle () == style &&
+	  each_brush->GetColour ().Red () == colour->Red () &&
+	  each_brush->GetColour ().Green () == colour->Green () &&
+	  each_brush->GetColour ().Blue () == colour->Blue ())
+	return each_brush;
+    }
+  brush = new wxBrush (*colour, style);
+#if WXGARBAGE_COLLECTION_ON
+  AddBrush(brush);
+#endif
+  return brush;
+}
+
+wxBrush *wxBrushList::FindOrCreateBrush (char *colour, int style)
+{
+  wxColour *the_colour = wxTheColourDatabase->FindColour (colour);
+  if (the_colour)
+    return FindOrCreateBrush (the_colour, style);
+  else
+    return NULL;
+}
+
+
+void wxBrushList::RemoveBrush (wxBrush * brush)
+{
+  DeleteObject (brush);
+}
+
+wxFontList::~wxFontList (void)
+{
+  wxNode *node = First ();
+  while (node)
+    {
+      wxFont *font = (wxFont *) node->Data ();
+      wxNode *next = node->Next ();
+      delete font;
+      node = next;
+    }
+}
+
+void wxFontList::AddFont (wxFont * font)
+{
+  Append (font);
+}
+
+void wxFontList::RemoveFont (wxFont * font)
+{
+  DeleteObject (font);
+}
+
+wxFont *wxFontList::
+FindOrCreateFont (int PointSize, int FamilyOrFontId, int Style, int Weight, Bool underline)
+{
+  wxFont *font;
+
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      wxFont *each_font = (wxFont *) node->Data ();
+      if (each_font &&
+	  each_font->GetPointSize () == PointSize &&
+	  each_font->GetStyle () == Style &&
+	  each_font->GetWeight () == Weight &&
+	  each_font->GetFontId () == FamilyOrFontId &&
+	  each_font->GetUnderlined () == underline)
+	return each_font;
+    }
+  font = new wxFont (PointSize, FamilyOrFontId, Style, Weight, underline);
+#if WXGARBAGE_COLLECTION_ON
+  AddFont(font);
+#endif
+  return font;
+}
+
+wxFont *wxFontList::
+FindOrCreateFont (int PointSize, const char *Face, int Family, int Style, int Weight, Bool underline)
+{
+  return FindOrCreateFont(PointSize,
+			  wxTheFontNameDirectory.FindOrCreateFontId(Face, Family),
+			  Style,
+			  Weight,
+			  underline);
+}
+
+#if (!USE_TYPEDEFS)
+wxPoint::wxPoint (void) : wxObject(WXGC_NO_CLEANUP)
+{
+}
+
+wxPoint::wxPoint (float the_x, float the_y)  : wxObject(WXGC_NO_CLEANUP)
+{
+  x = the_x;
+  y = the_y;
+}
+
+wxPoint::~wxPoint (void)
+{
+}
+#endif
+
+#if (!USE_TYPEDEFS)
+wxIntPoint::wxIntPoint (void)  : wxObject(WXGC_NO_CLEANUP)
+{
+}
+
+wxIntPoint::wxIntPoint (int the_x, int the_y)  : wxObject(WXGC_NO_CLEANUP)
+{
+  x = the_x;
+  y = the_y;
+}
+
+wxIntPoint::~wxIntPoint (void)
+{
+}
+#endif
+
+char *font_defaults[] = {
+  /* MATTHEW: [4] Family map */
+  "FamilyDefault", "Default",
+  "FamilyRoman", "Roman",
+  "FamilyDecorative", "Decorative",
+  "FamilyModern", "Modern",
+  "FamilyTeletype", "Teletype",
+  "FamilySwiss", "Swiss",
+  "FamilyScript", "Script",
+  "FamilySystem", "System",
+
+  "AfmMedium", "",
+  "AfmBold", "Bo",
+  "AfmLight", "",
+  "AfmStraight", "",
+  "AfmItalic", "${AfmSlant}",
+  "AfmSlant", "O",
+  "AfmRoman", "Ro",
+
+  "AfmTimes", "Times",
+  "AfmHelvetica", "Helv",
+  "AfmCourier", "Cour",
+
+  "Afm___", "${AfmTimes,$[weight],$[style]}",
+
+  "AfmTimes__", "${AfmTimes}${Afm$[weight]}${Afm$[style]}",
+  "AfmTimesMediumStraight", "${AfmTimes}${AfmRoman}",
+  "AfmTimesLightStraight", "${AfmTimes}${AfmRoman}",
+  "AfmTimes_Italic", "${AfmTimes}$[weight]${AfmItalic}",
+  "AfmTimes_Slant", "${AfmTimes}$[weight]${AfmItalic}",
+
+  "AfmSwiss__", "${AfmHelvetica}${Afm$[weight]}${Afm$[style]}",
+  "AfmModern__", "${AfmCourier}${Afm$[weight]}${Afm$[style]}",
+
+  "AfmTeletype__", "${AfmModern,$[weight],$[style]}",
+
+  "PostScriptMediumStraight", "",
+  "PostScriptMediumItalic", "-Oblique",
+  "PostScriptMediumSlant", "-Oblique",
+  "PostScriptLightStraight", "",
+  "PostScriptLightItalic", "-Oblique",
+  "PostScriptLightSlant", "-Oblique",
+  "PostScriptBoldStraight", "-Bold",
+  "PostScriptBoldItalic", "-BoldOblique",
+  "PostScriptBoldSlant", "-BoldOblique",
+
+#if WX_NORMALIZED_PS_FONTS
+  "PostScript___", "${PostScriptTimes,$[weight],$[style]}",
+#else
+  "PostScriptRoman__", "${PostScriptTimes,$[weight],$[style]}",
+  "PostScript___", "LucidaSans${PostScript$[weight]$[style]}",
+#endif
+
+  "PostScriptTimesMedium", "",
+  "PostScriptTimesLight", "",
+  "PostScriptTimesBold", "Bold",
+
+  "PostScriptTimes__", "Times${PostScript$[weight]$[style]}",
+  "PostScriptTimesMediumStraight", "Times-Roman",
+  "PostScriptTimesLightStraight", "Times-Roman",
+  "PostScriptTimes_Slant", "Times-${PostScriptTimes$[weight]}Italic",
+  "PostScriptTimes_Italic", "Times-${PostScriptTimes$[weight]}Italic",
+
+  "PostScriptSwiss__", "Helvetica${PostScript$[weight]$[style]}",
+  "PostScriptModern__", "Courier${PostScript$[weight]$[style]}",
+
+  "PostScriptTeletype__", "${PostScriptModern,$[weight],$[style]}",
+
+#if !WX_NORMALIZED_PS_FONTS
+  "PostScriptScript__", "Zapf-Chancery-MediumItalic",
+#endif
+
+#ifdef wx_x
+  "ScreenMedium", "medium",
+  "ScreenBold", "bold",
+  "ScreenLight", "light",
+  "ScreenStraight", "r",
+  "ScreenItalic", "i",
+  "ScreenSlant", "o",
+
+  /* MATTHEW: [4] "Family" -> "Base" */
+  "ScreenDefaultBase", "*-*",
+  "ScreenRomanBase", "*-times",
+  "ScreenDecorativeBase", "*-helvetica",
+  "ScreenModernBase", "*-courier",
+  "ScreenTeletypeBase", "*-lucidatypewriter", /* MATTHEW: [4] Not courier */
+  "ScreenSwissBase", "*-lucida",
+  "ScreenScriptBase", "*-zapfchancery",
+
+  /* MATTHEW: [4] Use ${ScreenStdSuffix} */
+  "ScreenStdSuffix", "-${Screen$[weight]}-${Screen$[style]}"
+    "-normal-*-*-%d-*-*-*-*-*-*",
+
+  "Screen___",
+  "-${ScreenDefaultBase}${ScreenStdSuffix}",
+  "ScreenRoman__",
+  "-${ScreenRomanBase}${ScreenStdSuffix}",
+  "ScreenDecorative__",
+  "-${ScreenDecorativeBase}${ScreenStdSuffix}",
+  "ScreenModern__",
+  "-${ScreenModernBase}${ScreenStdSuffix}",
+  "ScreenTeletype__",
+  "-${ScreenTeletypeBase}${ScreenStdSuffix}",
+  "ScreenSwiss__",
+  "-${ScreenSwissBase}${ScreenStdSuffix}",
+  "ScreenScript__",
+  "-${ScreenScriptBase}${ScreenStdSuffix}",
+#endif
+#ifdef wx_msw
+  "ScreenDefault__", "MS Sans Serif",
+  "ScreenRoman__", "Times New Roman",
+  "ScreenDecorative__", "",
+  "ScreenModern__", "Courier New",
+  "ScreenTeletype__", "${ScreenModern,$[weight],$[style]}",
+  "ScreenSwiss__", "Arial",
+  "ScreenScript__", "Script",
+#endif
+#ifdef wx_mac
+  "ScreenDefault__", "applicationfont",
+  "ScreenSystem__", "systemfont",
+  "ScreenRoman__", "times",
+  "ScreenDecorative__", "geneva",
+  "ScreenModern__", "monaco", /* "courier" is also good */
+  "ScreenTeletype__", "${ScreenModern,$[weight],$[style]}",
+  "ScreenSwiss__", "helvetica",
+  "ScreenScript__", "geneva",
+#endif
+  NULL
+};
+
+
+wxFontNameDirectory wxTheFontNameDirectory;
+
+enum {
+  wxWEIGHT_NORMAL,
+  wxWEIGHT_BOLD,
+  wxWEIGHT_LIGHT,
+  wxNUM_WEIGHTS
+  };
+
+enum {
+  wxSTYLE_NORMAL,
+  wxSTYLE_ITALIC,
+  wxSTYLE_SLANT,
+  wxNUM_STYLES
+  };
+
+class wxSuffixMap {
+ public:
+  char *map[wxNUM_WEIGHTS][wxNUM_STYLES];
+  void Initialize(const char *, const char *);
+  void Cleanup(void);
+};
+
+
+class wxFontNameItem : public wxObject
+{
+ public:
+  int id;
+  int family;
+  char *name;
+  wxSuffixMap screen, printing, afm;
+  Bool isroman;
+  
+  ~wxFontNameItem(void);
+};
+
+wxFontNameItem::~wxFontNameItem(void)
+{
+	screen.Cleanup();
+	printing.Cleanup();
+	afm.Cleanup();
+	delete [] name;
+}
+
+static int WCoordinate(int w)
+{
+  switch (w) {
+  case wxBOLD:
+    return wxWEIGHT_BOLD;
+  case wxLIGHT:
+    return wxWEIGHT_LIGHT;
+  case wxNORMAL:
+  default:
+    return wxWEIGHT_NORMAL;
+  }
+}
+
+static int SCoordinate(int s)
+{
+  switch (s) {
+  case wxITALIC:
+    return wxSTYLE_ITALIC;
+  case wxSLANT:
+    return wxSTYLE_SLANT;
+  case wxNORMAL:
+  default:
+    return wxSTYLE_NORMAL;
+  }
+}
+
+wxFontNameDirectory::wxFontNameDirectory(void)
+{
+  table = new wxHashTable(wxKEY_INTEGER, 20);
+  nextFontId = -1;
+}
+
+wxFontNameDirectory::~wxFontNameDirectory()
+{ // The data in the hash table must be deleted as well as the table
+  table->DeleteContents(1);
+  delete table;
+}
+
+int wxFontNameDirectory::GetNewFontId(void)
+{
+  return (nextFontId--);
+}
+
+#if !USE_RESOURCES
+#define wxGetResource(a, b, c) 0
+#endif
+
+static void SearchResource(const char *prefix, const char **names, int count, char **v)
+{
+  int k, i, j;
+  char resource[1024], **defaults, *internal;
+
+  k = 1 << count;
+
+  *v = NULL;
+  internal = NULL;
+
+  for (i = 0; i < k; i++) {
+    strcpy(resource, prefix);
+    for (j = 0; j < count; j++) {
+      if (!(i & (1 << j)))
+		strcat(resource, names[j]);
+      else
+		strcat(resource, "_");
+    }
+
+    if (wxGetResource(wxTheApp->wx_class, (char *)resource, v) && **v)
+      return;
+
+    if (!internal) {
+      defaults = font_defaults;
+      while (*defaults) {
+		if (!strcmp(*defaults, resource)) {
+	  	  internal = defaults[1];
+	  	  break;
+		}
+		defaults += 2;
+      }
+    }
+  }
+
+  if (internal)
+    *v = copystring(internal);
+}
+
+void wxFontNameDirectory::Initialize()
+{
+  wxTheFontNameDirectory.Initialize(wxDEFAULT, wxDEFAULT, "Default");
+  wxTheFontNameDirectory.Initialize(wxDECORATIVE, wxDECORATIVE, "Decorative");
+  wxTheFontNameDirectory.Initialize(wxROMAN, wxROMAN, "Roman");
+  wxTheFontNameDirectory.Initialize(wxMODERN, wxMODERN, "Modern");
+  wxTheFontNameDirectory.Initialize(wxTELETYPE, wxTELETYPE, "Teletype");
+  wxTheFontNameDirectory.Initialize(wxSWISS, wxSWISS, "Swiss");
+  wxTheFontNameDirectory.Initialize(wxSCRIPT, wxSCRIPT, "Script");
+#ifdef wx_mac
+  wxTheFontNameDirectory.Initialize(wxSYSTEM, wxSYSTEM, "System");
+#endif
+}
+
+typedef char *a_charptr;
+// Note from CJC - Initialize leaked like crazy because the copystring() returned by
+// searchresource() was not deleted on expansions.
+//
+void wxSuffixMap::Initialize(const char *resname, const char *devresname)
+{
+  const char *weight, *style;
+  char *v;
+  int i, j, k;
+  const char *names[3];
+
+  for (k = 0; k < wxNUM_WEIGHTS; k++) {
+    switch (k) {
+    case wxWEIGHT_NORMAL:
+      weight = "Medium";
+      break;
+    case wxWEIGHT_LIGHT:
+      weight = "Light";
+      break;
+    case wxWEIGHT_BOLD:
+      default:
+      weight = "Bold";
+  	}
+    for (j = 0; j < wxNUM_STYLES; j++) {
+      switch (j) {
+      case wxSTYLE_NORMAL:
+		style = "Straight";
+		break;
+      case wxSTYLE_ITALIC:
+		style = "Italic";
+		break;
+      case wxSTYLE_SLANT:
+	      default:
+		style = "Slant";
+   	  }
+
+      names[0] = resname;
+      names[1] = weight;
+      names[2] = style;
+      
+      SearchResource(devresname, names, 3, &v);
+
+      /* Expand macros in the found string: */
+  found:
+      int len, closer = 0, startpos = 0;
+
+      len = (v ? strlen(v) : 0);
+      for (i = 0; i < len; i++)
+		if (v[i] == '$' && ((v[i+1] == '[') || (v[i+1] == '{'))) {
+	 		startpos = i;
+	  		if (v[i+1] == '[')
+	   		  closer = ']';
+	  		else
+	    	  closer = '}';
+	  		i++;
+		} else if (v[i] == closer) {
+	  	  int newstrlen;
+	  	  const char *r = NULL;
+	  	  char *naya, *name;
+	  	  char *tmp; //cjc
+	  
+	  	  name = v + startpos + 2;
+	  	  v[i] = 0;
+		  tmp = NULL; //cjc
+	  	  if (closer == '}') {
+	    	int i, count, len;
+	    	char **names;
+
+	    	for (i = 0, count = 1; name[i]; i++)
+	      		if (name[i] == ',')
+				  count++;
+	    
+	    	len = i;
+
+	    	names = new a_charptr[count];
+	    	names[0] = name;
+	    	for (i = 0, count = 1; i < len; i++)
+	      		if (name[i] == ',') {
+					names[count++] = name + i + 1;
+					name[i] = 0;
+	      		}
+
+	    	SearchResource("", (const char **)names, count, (char **)&r);
+	    	delete[] names;
+			tmp = (char *)r;	// cjc
+	    	if (!r) {
+	      		for (i = 0; i < len; i++)
+					if (!name[i])
+		  				name[i] = ',';
+	      		r = "";
+	      		printf("Bad resource name \"%s\" in font lookup\n", name);
+	    	}
+	  	  } else if (!strcmp(name, "weight")) {
+	    	r = weight;
+	      } else if (!strcmp(name, "style")) {
+	    	r = style;
+	      } else if (!strcmp(name, "family")) {
+	    	r = resname;
+	      } else {
+	    	r = "";
+	    	printf("Bad font macro name \"%s\"\n", name);
+	      }
+	    newstrlen = strlen(r);
+
+	    naya = new char[len + newstrlen + 1];
+	    memcpy(naya, v, startpos);
+	    memcpy(naya + startpos, r, newstrlen);
+	    memcpy(naya + startpos + newstrlen, v + i + 1, len - i + 1);
+	    delete[] v;
+	    delete[] tmp; //cjc
+	    v = naya;
+
+	    goto found;
+	  }
+
+#if defined(wx_msw) || defined(wx_mac)
+      if (!v)
+		v = copystring(resname);
+#endif
+      /* We have a final value: */
+      map[k][j] = v;
+    } // wxNUM_STYLES (j);
+  } // wxNUM_WEIGHTS (k)
+}
+
+void wxSuffixMap::Cleanup(void)
+{
+	int i,j;
+	char *v, **vec,*str;
+	vec = map[0,0];
+	for (i = 0; i < wxNUM_WEIGHTS; i++) {
+		for (j = 0; j < wxNUM_STYLES; j++) {
+			str = *vec++;
+			if (*str) {
+				delete   str;
+			}
+		}
+	}
+}
+
+void wxFontNameDirectory::Initialize(int fontid, int family, const char *resname)
+{
+  wxFontNameItem *item = new wxFontNameItem;
+  char *fam, resource[256];
+  
+  item->id = fontid;
+  item->family = family;
+  
+  sprintf(resource, "Family%s", resname);
+  fam = NULL;
+  SearchResource((const char *)resource, NULL, 0, (char **)&fam);
+  if (fam) {
+    if (!strcmp(fam, "Default"))
+      item->family = wxDEFAULT;
+    else if (!strcmp(fam, "Roman"))
+      item->family = wxROMAN;
+    else if (!strcmp(fam, "Decorative"))
+      item->family = wxDECORATIVE;
+    else if (!strcmp(fam, "Modern"))
+      item->family = wxMODERN;
+    else if (!strcmp(fam, "Teletype"))
+      item->family = wxTELETYPE;
+    else if (!strcmp(fam, "Swiss"))
+      item->family = wxSWISS;
+    else if (!strcmp(fam, "Script"))
+      item->family = wxSCRIPT;
+#ifdef wx_mac
+    else if (!strcmp(fam, "System"))
+      item->family = wxSYSTEM;
+#endif
+	delete [] fam;
+  }
+
+  item->name = copystring(resname);
+  item->screen.Initialize(resname, "Screen");
+  item->printing.Initialize(resname, "PostScript");
+  item->afm.Initialize(resname, "Afm");
+
+  table->Put(fontid, item);
+}
+
+int wxFontNameDirectory::FindOrCreateFontId(const char *name, int family)
+{
+  int id;
+
+  if (id = GetFontId(name))
+    return id;
+
+  id = GetNewFontId();
+  Initialize(id, family, name);
+
+  return id;
+}
+
+char *wxFontNameDirectory::GetScreenName(int fontid, int weight, int style)
+{
+  wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid);
+  
+  if (!item)
+    return NULL;
+
+  return item->screen.map[WCoordinate(weight)][SCoordinate(style)];
+}
+
+char *wxFontNameDirectory::GetPostScriptName(int fontid, int weight, int style)
+{
+  wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid);
+
+  if (!item)
+    return NULL;
+
+  return item->printing.map[WCoordinate(weight)][SCoordinate(style)];
+}
+
+char *wxFontNameDirectory::GetAFMName(int fontid, int weight, int style)
+{
+  wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid);
+
+  if (!item)
+    return NULL;
+
+  return item->afm.map[WCoordinate(weight)][SCoordinate(style)];
+}
+
+char *wxFontNameDirectory::GetFontName(int fontid)
+{
+  wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid);
+  
+  if (!item)
+    return NULL;
+
+  return item->name;
+}
+
+int wxFontNameDirectory::GetFontId(const char *name)
+{
+  wxNode *node;
+
+  table->BeginFind();
+
+  while (node = table->Next()) {
+    wxFontNameItem *item = (wxFontNameItem *)node->Data();
+    if (!strcmp(name, item->name))
+      return item->id;
+  }
+
+  return 0;
+}
+
+int wxFontNameDirectory::GetFamily(int fontid)
+{
+  wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid);
+  
+  if (!item)
+    return wxDEFAULT;
+
+  return item->family;
+}
diff --git a/src/wxmac/src/base/wb_gdi.ide b/src/wxmac/src/base/wb_gdi.ide
new file mode 100644
index 0000000..adda7f7
Binary files /dev/null and b/src/wxmac/src/base/wb_gdi.ide differ
diff --git a/src/wxmac/src/base/wb_gdi.mak b/src/wxmac/src/base/wb_gdi.mak
new file mode 100644
index 0000000..07c01f6
--- /dev/null
+++ b/src/wxmac/src/base/wb_gdi.mak
@@ -0,0 +1,72 @@
+#
+# Borland C++ IDE generated makefile
+#
+.AUTODEPEND
+
+
+#
+# Borland C++ tools
+#
+IMPLIB  = Implib
+BCC32   = Bcc32 +BccW32.cfg 
+TLINK32 = TLink32
+TLIB    = TLib
+BRC32   = Brc32
+TASM32  = Tasm32
+#
+# IDE macros
+#
+
+
+#
+# Options
+#
+IDE_LFLAGS32 =  -LC:\BC4\LIB
+IDE_RFLAGS32 =  -IC:\BC4\INCLUDE
+LLATW32_wb_gdidexe =  -Tpe -aa
+RLATW32_wb_gdidexe =  -ID:\BC4\INCLUDE;C:\WXWIN\INCLUDE\BASE;C:\WXWIN\INCLUDE\MSW -w32
+BLATW32_wb_gdidexe = 
+LEAT_wb_gdidexe = $(LLATW32_wb_gdidexe)
+REAT_wb_gdidexe = $(RLATW32_wb_gdidexe)
+BEAT_wb_gdidexe = $(BLATW32_wb_gdidexe)
+
+#
+# Dependency List
+#
+Dep_wb_gdi = \
+   wb_gdi.exe
+
+wb_gdi : BccW32.cfg $(Dep_wb_gdi)
+  echo MakeNode wb_gdi
+
+Dep_wb_gdidexe = \
+   wb_gdi.obj
+
+wb_gdi.exe : $(Dep_wb_gdidexe)
+  $(TLINK32) @&&|
+ /v $(IDE_LFLAGS32) $(LEAT_wb_gdidexe) +
+/v- wb_gdi.obj
+$<,$*
+
+
+|
+
+wb_gdi.obj :  wb_gdi.cc
+  $(BCC32) -c $(CEAT_wb_gdidexe) -o$@ wb_gdi.cc
+
+# Compiler configuration file
+BccW32.cfg : 
+   Copy &&|
+-R
+-v
+-vi
+-X-
+-H
+-IC:\BC4\INCLUDE
+-H=wb_gdi.csm
+-Dwx_msw;__win32s__;farmalloc=malloc;farfree=free;
+-ID:\BC4\INCLUDE;C:\WXWIN\INCLUDE\BASE;C:\WXWIN\INCLUDE\MSW
+-W
+| $@
+
+
diff --git a/src/wxmac/src/base/wb_hash.cc b/src/wxmac/src/base/wb_hash.cc
new file mode 100644
index 0000000..cbd6648
--- /dev/null
+++ b/src/wxmac/src/base/wb_hash.cc
@@ -0,0 +1,333 @@
+/*
+ * File:      wb_hash.cc
+ * Purpose:     Hash table implementation
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_hash.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_hash.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation "wx_hash.h"
+#endif
+
+#include "common.h"
+#include "wx_list.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "wx_hash.h"
+#include "wx_types.h"
+
+#include <string.h>
+#include <stdarg.h>
+
+wxHashTable::wxHashTable (unsigned int the_key_type, size_t size)
+{
+  __type = wxTYPE_HASH_TABLE;
+  n = size;
+  current_position = -1;
+  current_node = NULL;
+
+  key_type = wxKEY_NONE;
+  hash_table = new wxList *[size];
+  for (size_t i = 0; i < size; i++)
+    hash_table[i] = NULL;
+}
+
+wxHashTable::~wxHashTable (void)
+{
+  for (size_t i = 0; i < n; i++)
+    if (hash_table[i])
+      delete hash_table[i];
+  delete hash_table;
+}
+
+void wxHashTable::Put (long key, long value, wxObject * object)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    hash_table[position] = new wxList (wxKEY_INTEGER, FALSE);
+
+  hash_table[position]->Append (value, object);
+}
+
+void wxHashTable::Put (long key, char *value, wxObject * object)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    hash_table[position] = new wxList (wxKEY_INTEGER, FALSE);
+
+  hash_table[position]->Append (value, object);
+}
+
+void wxHashTable::Put (long key, wxObject * object)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    hash_table[position] = new wxList (wxKEY_INTEGER, FALSE);
+
+  hash_table[position]->Append (key, object);
+}
+
+void wxHashTable::Put (const char *key, wxObject * object)
+{
+  size_t position = (size_t) (MakeKey (key) % n);
+
+  if (!hash_table[position])
+    hash_table[position] = new wxList (wxKEY_STRING, FALSE);
+
+  hash_table[position]->Append (key, object);
+}
+
+wxObject *wxHashTable::Get (long key, long value)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (value);
+      if (node)
+	return node->Data ();
+      else
+	return NULL;
+    }
+}
+
+wxObject *wxHashTable::Get (long key, char *value)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (value);
+      if (node)
+	return node->Data ();
+      else
+	return NULL;
+    }
+}
+
+wxObject *wxHashTable::Get (long key)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (key);
+      return node ? node->Data () : NULL;
+    }
+}
+
+wxObject *wxHashTable::Get (const char *key)
+{
+  size_t position = (size_t) (MakeKey (key) % n);
+
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (key);
+      return node ? node->Data () : NULL;
+    }
+}
+
+wxObject *wxHashTable::Delete (long key)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (key);
+      if (node)
+	{
+	  wxObject *data = node->Data ();
+	  delete node;
+	  return data;
+	}
+      else
+	return NULL;
+    }
+}
+
+wxObject *wxHashTable::Delete (const char *key)
+{
+  size_t position = (size_t) (MakeKey (key) % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (key);
+      if (node)
+	{
+	  wxObject *data = node->Data ();
+	  delete node;
+	  return data;
+	}
+      else
+	return NULL;
+    }
+}
+
+wxObject *wxHashTable::Delete (long key, int value)
+{
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (value);
+      if (node)
+	{
+	  wxObject *data = node->Data ();
+	  delete node;
+	  return data;
+	}
+      else
+	return NULL;
+    }
+}
+
+wxObject *wxHashTable::Delete (long key, char *value)
+{
+/*
+  // Should NEVER be
+  if (key < 0)
+    key = -key;
+*/
+
+  size_t position = (size_t) (key % n);
+  if (!hash_table[position])
+    return NULL;
+  else
+    {
+      wxNode *node = hash_table[position]->Find (value);
+      if (node)
+	{
+	  wxObject *data = node->Data ();
+	  delete node;
+	  return data;
+	}
+      else
+	return NULL;
+    }
+}
+
+long wxHashTable::MakeKey (const char *string)
+{
+  long int_key = 0;
+
+  while (*string)
+    int_key += (unsigned char) *string++;
+
+/* // Don't need this since int_key >= 0) 
+  if (int_key < 0)
+    int_key = -int_key;
+*/
+  return int_key;
+}
+
+void wxHashTable::BeginFind (void)
+{
+  current_position = -1;
+  current_node = NULL;
+}
+
+wxNode *wxHashTable::Next (void)
+{
+  wxNode *found = NULL;
+  Bool end = FALSE;
+  while (!end && !found)
+    {
+      if (!current_node)
+	{
+	  current_position++;
+	  if (current_position >= n)
+	    {
+	      current_position = -1;
+	      current_node = NULL;
+	      end = TRUE;
+	    }
+	  else
+	    {
+	      if (hash_table[current_position])
+		{
+		  current_node = hash_table[current_position]->First ();
+		  found = current_node;
+		}
+	    }
+	}
+      else
+	{
+	  current_node = current_node->Next ();
+	  found = current_node;
+	}
+    }
+  return found;
+}
+
+void wxHashTable::DeleteContents (Bool flag)
+{
+  for (int i = 0; i < n; i++)
+    {
+      if (hash_table[i])
+	hash_table[i]->DeleteContents (flag);
+    }
+}
+
+void wxHashTable::Clear (void)
+{
+  for (int i = 0; i < n; i++)
+    {
+      if (hash_table[i])
+	hash_table[i]->Clear ();
+    }
+}
diff --git a/src/wxmac/src/base/wb_help.cc b/src/wxmac/src/base/wb_help.cc
new file mode 100644
index 0000000..594114a
--- /dev/null
+++ b/src/wxmac/src/base/wb_help.cc
@@ -0,0 +1,344 @@
+/*
+ * File:	wb_help.cc
+ * Purpose:	API for invoking wxHelp
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_help.cc,v 1.4 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_help.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation "wx_help.h"
+#endif
+
+#include "common.h"
+#include "wx_help.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#if USE_HELP
+#include <time.h>
+
+#ifdef wx_msw
+#include <wx_privt.h>
+#endif
+
+#ifdef wx_x
+#include <netdb.h>
+
+#ifdef SUN_CC
+#include <sysent.h>
+#endif // SUN_CC
+#ifdef __hpux
+#include <sys/unistd.h>
+#endif // __hpux
+#endif // wx_x
+
+// Timeout in seconds
+#define WX_HELP_TIMEOUT 15 /* was 30 */
+
+// MAX path length
+#define _MAXPATHLEN 500
+
+// MAX length of Help descriptor
+#define _MAX_HELP_LEN 500
+
+#include "wx_help.h"
+
+wxHelpInstance::wxHelpInstance(Bool native)
+{
+#ifdef wx_msw
+  useNative = native;
+#else
+  useNative = FALSE;  // Vetoed under X -- no native help system
+#endif
+
+  __type = wxTYPE_HELP_INSTANCE;
+  helpFile = NULL; helpServer = -1; helpHost = NULL;
+  helpRunning = FALSE; helpConnection = NULL;
+}
+
+wxHelpInstance::~wxHelpInstance(void)
+{
+  if (helpFile) delete[] helpFile; 
+  if (helpHost) delete[] helpHost;
+}
+
+Bool wxHelpInstance::Initialize(char *filename, int server)
+{
+#ifdef wx_x
+  {
+    char host_buf[255];
+    if (wxGetHostName(host_buf, sizeof(host_buf)))
+      helpHost = copystring(host_buf);
+    else helpHost = NULL;
+  }
+#elif defined(wx_msw)
+  if (!useNative)
+    helpHost = copystring("dummy");
+#else
+#error "Not yet..."
+#endif
+
+  helpFile = copystring(filename);
+  if (!useNative) {
+    helpServer = server;
+    wxIPCInitialize();
+  }
+  return TRUE;
+}
+
+Bool wxHelpInstance::LoadFile(char *file)
+{
+  if (!file)
+    file = helpFile;
+  else {
+    if (helpFile) delete[] helpFile;
+    helpFile = copystring(file);
+  }
+
+  if (!useNative) {
+    if (!helpRunning) {
+      if (!Run())
+        return FALSE;
+    }
+    char buf[_MAX_HELP_LEN];
+    sprintf(buf, "f %s", file);
+    if (helpConnection)
+      return helpConnection->Execute(buf);
+    else return FALSE;
+  } else {
+#ifdef wx_msw
+    char buf[_MAXPATHLEN];
+    strcpy(buf, file);
+    size_t len = strlen(file);
+    if (!(file[len-1] == 'p' && file[len-2] == 'l' && file[len-3] == 'h' && file[len-4] == '.'))
+      strcat(buf, ".hlp");
+    if (wxTheApp->wx_frame)
+    {
+      wxWnd *wnd = (wxWnd *)(wxTheApp->wx_frame->handle);
+      HWND hwnd = wnd->handle;
+      WinHelp(hwnd, buf, HELP_CONTENTS, 0L);
+     return TRUE;
+    }
+#endif
+  }
+  return FALSE;
+}
+
+Bool wxHelpInstance::DisplayContents(void)
+{
+  if (!useNative) {
+    if (!helpRunning) {
+      if (!Run())
+        return FALSE;
+    }
+    if (helpConnection)
+      return helpConnection->Execute("s -1");
+    else return FALSE;
+  } else {
+#ifdef wx_msw
+    if (!helpFile) return FALSE;
+    
+    char buf[_MAXPATHLEN];
+    strcpy(buf, helpFile);
+    size_t len = strlen(helpFile);
+    if (!(helpFile[len-1] == 'p' && helpFile[len-2] == 'l' && helpFile[len-3] == 'h' && helpFile[len-4] == '.'))
+      strcat(buf, ".hlp");
+    if (wxTheApp->wx_frame)
+    {
+      wxWnd *wnd = (wxWnd *)(wxTheApp->wx_frame->handle);
+      HWND hwnd = wnd->handle;
+      WinHelp(hwnd, buf, HELP_CONTENTS, 0L);
+     return TRUE;
+    }
+#endif
+  }
+  return FALSE;
+}
+
+Bool wxHelpInstance::DisplaySection(int section)
+{
+  if (!useNative) {
+    if (!helpRunning) {
+      if (!Run())
+        return FALSE;
+    }
+    char buf[_MAX_HELP_LEN];
+    sprintf(buf, "s %d", section);
+    if (helpConnection)
+      return helpConnection->Execute(buf);
+    else return FALSE;
+  }
+  // No WinHelp equivalent for this
+  return FALSE;
+}
+
+Bool wxHelpInstance::DisplayBlock(long block)
+{
+  if (!useNative) {
+    if (!helpRunning) {
+      if (!Run())
+        return FALSE;
+    }
+    char buf[_MAX_HELP_LEN];
+    sprintf(buf, "b %ld", block);
+    if (helpConnection)
+      return helpConnection->Execute(buf);
+    else return FALSE;
+  } else {
+    // Use context number -- a very rough equivalent to block id!
+#ifdef wx_msw
+    if (!helpFile) return FALSE;
+    
+    char buf[_MAXPATHLEN];
+    strcpy(buf, helpFile);
+    size_t len = strlen(helpFile);
+    if (!(helpFile[len-1] == 'p' && helpFile[len-2] == 'l' && helpFile[len-3] == 'h' && helpFile[len-4] == '.'))
+      strcat(buf, ".hlp");
+    if (wxTheApp->wx_frame) {
+      wxWnd *wnd = (wxWnd *)(wxTheApp->wx_frame->handle);
+      HWND hwnd = wnd->handle;
+      WinHelp(hwnd, buf, HELP_CONTEXT, (DWORD)block);
+     return TRUE;
+    }
+#endif
+  }
+  return FALSE;
+}
+
+Bool wxHelpInstance::KeywordSearch(char *k)
+{
+  if (!useNative) {
+    if (!helpRunning) {
+      if (!Run())
+        return FALSE;
+    }
+    char buf[500];
+    sprintf(buf, "k %s", k);
+    if (helpConnection)
+      return helpConnection->Execute(buf);
+    else return FALSE;
+  } else {
+#ifdef wx_msw
+    if (!helpFile) return FALSE;
+
+    char buf[_MAXPATHLEN];
+    strcpy(buf, helpFile);
+    size_t len = strlen(helpFile);
+    if (!(helpFile[len-1] == 'p' && helpFile[len-2] == 'l' && helpFile[len-3] == 'h' && helpFile[len-4] == '.'))
+      strcat(buf, ".hlp");
+    if (wxTheApp->wx_frame) {
+      wxWnd *wnd = (wxWnd *)(wxTheApp->wx_frame->handle);
+      HWND hwnd = wnd->handle;
+      WinHelp(hwnd, buf, HELP_PARTIALKEY, (DWORD)k);
+     return TRUE;
+    }
+#endif
+  }
+  return FALSE;
+}
+
+Bool wxHelpInstance::Quit(void)
+{
+  if (helpConnection)
+    return helpConnection->Disconnect(); // Calls OnQuit via OnDisconnect
+  else return TRUE;
+}
+
+void wxHelpInstance::OnQuit(void)
+{
+}
+
+Bool wxHelpInstance::Run(void)
+{
+#ifdef wx_x
+  if (!helpFile || !helpHost || helpRunning)
+    return FALSE;
+#endif
+#ifdef wx_msw
+  if (!helpFile || helpRunning)
+    return FALSE;
+#endif
+
+  time_t current_time;
+#ifdef wx_x
+  // Invent a server name that's likely to be unique but different from
+  // last time
+  (void)time(&current_time);
+  if (helpServer == -1)
+    helpServer = (int)(4000 + (current_time % 4000));
+#else
+  // Only one instance of wxHelp at a time
+  helpServer = 4000;
+#endif
+
+  char server[32];
+  sprintf(server, "%d", helpServer);
+#ifdef wx_msw
+  // Only one instance of wxHelp under Windows.
+  // See if there's already an instance of wxHelp
+  if (helpConnection = (wxHelpConnection *)MakeConnection(helpHost, server, "WXHELP")) {
+    helpRunning = TRUE;
+    return TRUE;
+  }
+#endif
+
+  // Start help process in server modus
+//  char *argv[] = {"wxhelp", "-server", server, NULL}; // HP compiler complains
+  char *argv[4];
+  argv[0] = "wxhelp";
+  argv[1] = "-server";
+  argv[2] = server;
+  argv[3] = NULL;
+
+  if (wxExecute(argv) == FALSE)
+    return FALSE; // Maybe we should print a message?
+
+  time_t start_time;
+  (void)time(&start_time);
+  // Give it some time to respond
+  do {
+    wxSleep(1);
+    helpConnection = (wxHelpConnection *)MakeConnection(helpHost, server, "WXHELP");
+    (void)time(&current_time);
+  } while (!helpConnection && ((current_time - start_time) < WX_HELP_TIMEOUT));
+
+  if (helpConnection == NULL) {
+    char buf[100];
+    sprintf(buf, wxSTR_HELP_TIMEOUT, WX_HELP_TIMEOUT);
+    (void)wxMessageBox(buf, wxSTR_ERROR);
+    return FALSE;
+  }
+  helpRunning = TRUE;
+  return TRUE;
+}
+
+wxHelpConnection::wxHelpConnection(wxHelpInstance *instance)
+{
+  helpInstance = instance;
+}
+
+Bool wxHelpConnection::OnDisconnect(void)
+{
+  helpInstance->OnQuit();
+  helpInstance->helpRunning = FALSE;
+  helpInstance->helpConnection = NULL;
+  helpInstance->helpServer = -1;
+  delete this;
+  return TRUE;
+}
+
+#endif // USE_HELP
diff --git a/src/wxmac/src/base/wb_ipc.cc b/src/wxmac/src/base/wb_ipc.cc
new file mode 100644
index 0000000..e41ca36
--- /dev/null
+++ b/src/wxmac/src/base/wb_ipc.cc
@@ -0,0 +1,345 @@
+/*
+ * File:	wb_ipc.cc
+ * Purpose:	Interprocess communication implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_ipc.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_ipc.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma implementation "wb_ipcob.h"
+#pragma implementation "wb_ipc.h"
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_main.h"
+#include "wx_frame.h"
+#include "wx_stdev.h"
+#include "wx_utils.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#if USE_IPC
+
+#include "wx_ipc.h"
+
+#include <stdio.h>
+
+char *wxDefaultIPCBuffer = NULL;
+int wxDefaultIPCBufferSize = 4000;
+
+/*
+ * CleanUp
+ * (manually called, to avoid linking with unuseful module)
+ */
+void wxIPCCleanUp()
+{
+  if (wxDefaultIPCBuffer)
+    delete [] wxDefaultIPCBuffer ;
+}
+
+/*
+ * Initialization
+ *
+ */
+
+Bool wxIPCInitialized;
+
+wxbIPCObject::wxbIPCObject(void)
+{
+}
+
+wxbIPCObject::~wxbIPCObject(void)
+{
+  if (service_name)
+    delete[] service_name;
+
+  wxNode *node = connections.First();
+  while (node)
+  {
+    wxConnection *connection = (wxConnection *)node->Data();
+    wxNode *next = node->Next();
+    connection->OnDisconnect(); // May delete the node implicitly
+    node = next;
+  }
+
+  // If any left after this, delete them
+  node = connections.First();
+  while (node)
+  {
+    wxConnection *connection = (wxConnection *)node->Data();
+    delete connection;
+    node = connections.First();
+  }
+}
+
+/*
+ * Server
+ *
+ */
+
+wxbServer::wxbServer(void)
+{
+  __type = wxTYPE_DDE_SERVER;
+}
+
+wxbServer::~wxbServer(void)
+{
+}
+
+// Default behaviour for accepting a connection
+wxConnection *wxbServer::OnAcceptConnection(char *topic)
+{
+  return new wxConnection;
+}
+
+
+/*
+ * Client
+ *
+ */
+
+
+wxbClient::wxbClient(void)
+{
+  __type = wxTYPE_DDE_CLIENT;
+}
+
+wxbClient::~wxbClient(void)
+{
+  wxNode *node = connections.First();
+  while (node)
+  {
+    wxConnection *connection = (wxConnection *)node->Data();
+    delete connection;  // Deletes the node implicitly (see ~wxConnection)
+    node = connections.First();
+  }
+}
+
+wxConnection *wxbClient::OnMakeConnection(void)
+{
+  return new wxConnection;
+}
+
+/*
+ * Connection
+ */
+
+wxbConnection::wxbConnection(char *buffer, int size)
+{
+  __type = wxTYPE_DDE_CONNECTION;
+
+  if (buffer == NULL)
+  {
+    if (wxDefaultIPCBuffer == NULL)
+      wxDefaultIPCBuffer = new char[wxDefaultIPCBufferSize];
+    buf_ptr = wxDefaultIPCBuffer;
+    buf_size = wxDefaultIPCBufferSize;
+  }
+  else
+  {
+    buf_ptr = buffer;
+    buf_size = size;
+  }
+
+  topic_name = NULL;
+
+  client = NULL;
+  server = NULL;
+}
+
+wxbConnection::wxbConnection(void)
+{
+  __type = wxTYPE_DDE_CONNECTION;
+
+  if (wxDefaultIPCBuffer == NULL)
+    wxDefaultIPCBuffer = new char[wxDefaultIPCBufferSize];
+
+  buf_ptr = wxDefaultIPCBuffer;
+  buf_size = wxDefaultIPCBufferSize;
+
+  topic_name = NULL;
+  client = NULL;
+  server = NULL;
+}
+
+wxbConnection::~wxbConnection(void)
+{
+}
+
+Bool wxbConnection::OnDisconnect(void)
+{
+  // Default action is to delete itself
+  delete this;
+  return TRUE;
+}
+
+// Callbacks to SERVER - override at will
+Bool wxbConnection::OnExecute(char *topic, char *data, int size, int format)
+{
+  return FALSE;
+}
+
+char *wxbConnection::OnRequest(char *topic, char *item, int *size, int format)
+{
+  return NULL;
+}
+
+Bool wxbConnection::OnPoke(char *topic, char *item, char *data, int size, int format)
+{
+  return FALSE;
+}
+
+Bool wxbConnection::OnStartAdvise(char *topic, char *item)
+{
+  return TRUE;
+}
+
+Bool wxbConnection::OnStopAdvise(char *topic, char *item)
+{
+  return TRUE;
+}
+
+
+// Callbacks to CLIENT - override at will
+Bool wxbConnection::OnAdvise(char *topic, char *item, char *data, int size, int format)
+{
+  return FALSE;
+}
+
+/*
+// Pipes
+wxChild::wxChild(void)
+{
+  the_pid = -1;
+}
+
+Bool wxChild::Create(char *command, char *argv[])
+{
+#ifdef wx_motif
+  return FALSE;
+#endif
+#ifdef wx_xview
+  int to_subprocess[2], from_subprocess[2];
+
+  pipe(to_subprocess); pipe(from_subprocess);
+
+  int pid = fork();
+
+  the_pid = pid;
+  switch(pid)
+  {
+    case -1:
+    return FALSE;
+
+    case 0:			// child
+
+    // Copy pipe descriptors to stdin and stdout
+    dup2(to_subprocess[0], 0); 	dup2(from_subprocess[1], 1);
+
+    // Close unwanted descriptors
+
+    close(to_subprocess[0]); 	close(to_subprocess[1]);
+    close(from_subprocess[0]); 	close(from_subprocess[1]);
+
+    // Exec new process
+
+//	execlp("prolog", "prolog", (char *)0); execvp(command, argv);
+
+  // If we get here it failed; give up
+
+    perror("exec");
+    _exit(1);		// Use _exit() not exit() after failed exec
+
+    default:			// parent
+
+	break;
+  }
+
+  // Close unneeded descriptors
+
+  close(to_subprocess[0]); close(from_subprocess[1]);
+
+  (void)notify_set_wait3_func((Notify_client)this, (Notify_func)wx_child_died, pid);
+
+  wxConnection *connection = this->OnSpawn(pid);
+  connection->input_fd = from_subprocess[0];
+  connection->output_fd = to_subprocess[1];
+
+  if (connection)
+  {
+    connection->Notify(TRUE);
+    return TRUE;
+  }
+  else
+  { close(to_subprocess[1]); 
+    close(from_subprocess[0]);
+    return FALSE;
+  }
+#endif
+#ifdef wx_msw
+  return FALSE;
+#endif
+  }
+
+void wxChild::OnDeath(void)
+{
+}
+
+// Default behaviour
+wxConnection *wxChild::OnSpawn(int pid)
+{
+  return new wxConnection;
+}
+*/
+
+// Add NULL-terminated string to buffer, returning next start point
+int wxAddString(int start, char *info, char *buffer, int size)
+{
+  if (size < 0)
+    size = strlen(info);
+
+  int i;
+  for (i = start; i < (start + size); i++)
+    buffer[i] = info[i-start];
+  buffer[i] = 0;
+  return i+1;
+}
+
+// Get next position of NULL-terminated string from buffer
+char *wxGetNextString(char *buffer)
+{
+  int i = 0;
+  int ch = -1;
+  Bool flag = FALSE;
+  while (!flag)
+  {
+    ch = (int)buffer[i];
+    if (ch == 0)
+    {
+      flag = TRUE;
+    }
+    else
+    {
+      i ++;
+    }
+  }
+  return buffer + i + 1;
+}
+
+#endif // USE_IPC
diff --git a/src/wxmac/src/base/wb_item.cc b/src/wxmac/src/base/wb_item.cc
new file mode 100644
index 0000000..d2ca873
--- /dev/null
+++ b/src/wxmac/src/base/wb_item.cc
@@ -0,0 +1,1418 @@
+/*
+ * File:      wb_item.cc
+ * Purpose:     Panel items implementation
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_item.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+#ifdef __GNUG__
+#pragma implementation
+
+#pragma implementation "wb_item.h"
+#pragma implementation "wb_lbox.h"
+#pragma implementation "wb_rbox.h"
+#pragma implementation "wb_buttn.h"
+#pragma implementation "wb_choic.h"
+#pragma implementation "wb_check.h"
+#pragma implementation "wb_messg.h"
+#pragma implementation "wb_slidr.h"
+#pragma implementation "wb_slidr.h"
+#pragma implementation "wb_menu.h"
+#pragma implementation "wb_mnuit.h"
+#pragma implementation "wb_txt.h"
+#pragma implementation "wb_mtxt.h"
+#pragma implementation "wb_menu.h"
+#pragma implementation "wb_group.h"
+#pragma implementation "wb_gauge.h"
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#ifdef wx_mac
+#  include "wx_mac_utils.h"
+#endif
+#include "wx_item.h"
+#include "wx_slidr.h"
+#include "wx_choic.h"
+#include "wx_lbox.h"
+#include "wx_rbox.h"
+#include "wx_buttn.h"
+#include "wx_check.h"
+#include "wx_messg.h"
+#include "wx_menu.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_group.h"
+
+#if USE_GAUGE
+#include "wx_gauge.h"
+#endif
+
+#include "wx_stdev.h"
+#include "wx_utils.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "wx_stdev.h"
+
+/* When implementing a new item, be sure to:
+
+ * - add the item to the parent panel
+ * - set window_parent to the parent
+ * - NULL any extra child window pointers not created for this item
+ *   (e.g. label control that wasn't needed)
+ * - delete any extra child windows in the destructor (e.g. label control)
+ * - implement GetSize and SetSize
+ * - to find panel position if coordinates are (-1, -1), use GetPosition
+ * - call AdvanceCursor after creation, for panel layout mechanism.
+ *
+ */
+
+/*
+   Motif notes
+
+   A panel is a form.
+   Each item is created on a RowColumn or Form of its own, to allow a label to
+   be positioned. wxListBox and wxMultiText have forms, all the others have RowColumns.
+   This is to allow labels to be positioned to the top left (can't do it with a
+   RowColumn as far as I know).
+   AttachWidget positions widgets relative to one another (left->right, top->bottom)
+   unless the x, y coordinates are given (more than -1).
+ */
+
+// Item members
+wxbItem::wxbItem (void)
+{
+  __type = wxTYPE_ITEM;
+}
+
+#ifdef wx_mac		// need additional constructors 
+
+wxbItem::wxbItem // Constructor (given parentArea)
+	(
+		char*		windowName,
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxWindow ( windowName, parentArea, x, y, width, height, style)
+{
+    if (wxSubType(window_parent->__type, wxTYPE_PANEL) &&
+    	cParentArea == window_parent->ClientArea())
+	{
+    	wxPanel* parentPanel = (wxPanel*) window_parent;
+		backColour = parentPanel->backColour;
+		buttonColour = parentPanel->buttonColour;
+		buttonFont = parentPanel->buttonFont;
+		if (!buttonFont) buttonFont = wxNORMAL_FONT; // mflatt
+		labelColour = parentPanel->labelColour;
+		labelFont = parentPanel->labelFont;
+		labelPosition = parentPanel->label_position;
+	}
+	else
+	{
+		backColour = NULL;
+		buttonColour = NULL;
+		buttonFont = NULL;
+		if (!buttonFont) buttonFont = wxNORMAL_FONT; // mflatt
+		labelColour = NULL;
+		labelFont = NULL;
+		labelPosition = wxHORIZONTAL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxbItem::wxbItem // Constructor (given parentWindow)
+	(
+		char*		windowName,
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxWindow ( windowName, parentWindow, x, y, width, height, style)
+{
+    if (wxSubType(window_parent->__type, wxTYPE_PANEL) &&
+    	cParentArea == window_parent->ClientArea())
+	{
+    	wxPanel* parentPanel = (wxPanel*) window_parent;
+		backColour = parentPanel->backColour;
+		buttonColour = parentPanel->buttonColour;
+		buttonFont = parentPanel->buttonFont;
+		if (!buttonFont) buttonFont = wxNORMAL_FONT;
+		labelColour = parentPanel->labelColour;
+		labelFont = parentPanel->labelFont;
+		labelPosition = parentPanel->label_position;
+	}
+	else
+	{
+		backColour = NULL;
+		buttonColour = NULL;
+		buttonFont = NULL;
+		if (!buttonFont) buttonFont = wxNORMAL_FONT; // KLUDGE
+		labelColour = NULL;
+		labelFont = NULL;
+		labelPosition = wxHORIZONTAL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxbItem::wxbItem // Constructor (given objectType; i.e., menu or menuBar)
+	(
+		char*		windowName
+	) :
+		wxWindow ( windowName),
+		backColour (NULL),
+		buttonColour (NULL),
+		buttonFont (NULL),
+		labelColour (NULL),
+		labelFont (NULL),
+		labelPosition (wxHORIZONTAL)
+{
+}
+#endif // wx_mac
+
+wxbItem::~wxbItem (void)
+{
+  wxPanel *parent = (wxPanel *) GetParent ();
+  if (parent)
+  {
+    // parent is not always a wxPanel: can be a wxMenu...
+    if (wxSubType(parent->__type,wxTYPE_PANEL))
+    {
+      if (parent->defaultItem == this)
+        parent->defaultItem = NULL;
+    }
+  }
+}
+
+#ifndef wx_mac
+void wxbItem::SetClientSize (int width, int height)
+{
+  SetSize (-1, -1, width, height);
+}
+#endif // wx_mac
+
+int wxbItem::GetLabelPosition (void)
+{
+  return labelPosition;
+}
+
+void wxbItem::SetLabelPosition (int pos)
+{
+  labelPosition = pos;
+}
+
+void wxbItem::Centre (int direction)
+{
+  int x, y, width, height, panel_width, panel_height, new_x, new_y;
+
+  wxPanel *panel = (wxPanel *) GetParent ();
+  if (!panel)
+    return;
+
+  panel->GetClientSize (&panel_width, &panel_height);
+  GetSize (&width, &height);
+  GetPosition (&x, &y);
+
+  new_x = x;
+  new_y = y;
+
+  if (direction & wxHORIZONTAL)
+    new_x = (int) ((panel_width - width) / 2);
+
+  if (direction & wxVERTICAL)
+    new_y = (int) ((panel_height - height) / 2);
+
+  SetSize (new_x, new_y, width, height, wxPOS_USE_MINUS_ONE);
+#ifndef wx_mac
+  int temp_x, temp_y;
+  GetPosition (&temp_x, &temp_y);
+  GetPosition (&temp_x, &temp_y);
+#endif // wx_mac
+}
+
+wxbButton::wxbButton (void)
+{
+  __type = wxTYPE_BUTTON;
+  window_parent = NULL;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbButton::wxbButton (wxPanel * panel, wxFunction Function, char *label,
+	   int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_BUTTON;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+wxbButton::wxbButton (wxPanel * panel, wxFunction Function, wxBitmap * bitmap,
+	   int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_BUTTON;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+#ifdef wx_mac
+// Constructor (given parentPanel)
+wxbButton::wxbButton (wxPanel* parentPanel, int x, int y,
+		int	width,int height, long style, char*	windowName)
+	: wxItem (parentPanel, x, y, width, height, style, windowName)
+{
+  __type = wxTYPE_BUTTON;
+}
+#endif 
+
+wxbButton::~wxbButton (void)
+{
+}
+
+void wxbButton::Command (wxCommandEvent & event)
+{
+  ProcessCommand (event);
+}
+
+void wxbButton::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Menus
+
+// Construct a menu with optional title (then use append)
+wxbMenu::wxbMenu (char *Title, wxFunction func)
+{
+  __type = wxTYPE_MENU;
+  no_items = 0;
+  menu_bar = NULL;
+  if (Title)
+    title = copystring (Title);
+  else
+    title = NULL;
+}
+
+// The wxWindow destructor will take care of deleting the submenus.
+wxbMenu::~wxbMenu (void)
+{
+  if (title)
+    delete[]title;
+}
+
+// Finds the item id matching the given string, -1 if not found.
+int wxbMenu::FindItem (char *itemString)
+{
+  char buf1[200];
+  char buf2[200];
+  wxStripMenuCodes (itemString, buf1);
+
+  for (wxNode * node = menuItems.First (); node; node = node->Next ())
+    {
+      wxMenuItem *item = (wxMenuItem *) node->Data ();
+      if (item->subMenu)
+	{
+	  int ans = item->subMenu->FindItem (itemString);
+	  if (ans > -1)
+	    return ans;
+	}
+      if ((item->itemId > -1) && item->itemName)
+	{
+	  wxStripMenuCodes (item->itemName, buf2);
+	  if (strcmp (buf1, buf2) == 0)
+	    return item->itemId;
+	}
+    }
+
+  return -1;
+}
+
+wxMenuItem *wxbMenu::FindItemForId (int itemId, wxMenu ** itemMenu)
+{
+  if (itemMenu)
+    *itemMenu = NULL;
+  for (wxNode * node = menuItems.First (); node; node = node->Next ())
+    {
+      wxMenuItem *item = (wxMenuItem *) node->Data ();
+
+      if (item->itemId == itemId)
+	{
+	  if (itemMenu)
+	    *itemMenu = (wxMenu *) this;
+	  return item;
+	}
+
+      if (item->subMenu)
+	{
+	  wxMenuItem *ans = item->subMenu->FindItemForId (itemId, itemMenu);
+	  if (ans)
+	    return ans;
+	}
+    }
+
+  if (itemMenu)
+    *itemMenu = NULL;
+  return NULL;
+}
+
+void wxbMenu::SetHelpString (int itemId, char *helpString)
+{
+  wxMenuItem *item = FindItemForId (itemId);
+  if (item)
+    {
+      if (item->helpString)
+	delete[]item->helpString;
+      item->helpString = helpString ? copystring (helpString) : NULL;
+    }
+}
+
+char *wxbMenu::GetHelpString (int itemId)
+{
+  wxMenuItem *item = FindItemForId (itemId);
+  if (item)
+    return item->helpString;
+  else
+    return NULL;
+}
+
+void wxbMenu::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Menu Bar
+
+wxbMenuBar::wxbMenuBar (void)
+{
+  __type = wxTYPE_MENU_BAR;
+  n = 0;
+  menus = NULL;
+  titles = NULL;
+  menu_bar_frame = NULL;
+}
+
+wxbMenuBar::wxbMenuBar (int N, wxMenu * Menus[], char *Titles[])
+{
+  __type = wxTYPE_MENU_BAR;
+  n = N;
+  menus = Menus;
+  titles = Titles;
+  menu_bar_frame = NULL;
+  for (int i = 0; i < N; i++)
+    menus[i]->menu_bar = (wxMenuBar *) this;
+}
+
+wxbMenuBar::~wxbMenuBar (void)
+{
+}
+
+
+void wxbMenuBar::Append (wxMenu * menu, char *title)
+{
+  if (!OnAppend(menu, title))  // mflatt
+         return;
+
+  n++;
+  wxMenu **new_menus = new wxMenu *[n];
+  char **new_titles = new char *[n];
+
+  int i;
+  for (i = 0; i < n - 1; i++)
+    {
+      new_menus[i] = menus[i];
+      menus[i] = NULL;
+      new_titles[i] = titles[i];
+      titles[i] = NULL;
+    }
+  if (menus)
+    {
+      delete[]menus;
+      delete[]titles;
+    }
+  menus = new_menus;
+  titles = new_titles;
+
+  menus[n - 1] = menu;
+  titles[n - 1] = copystring (title);
+
+  menu->menu_bar = (wxMenuBar *) this;
+}
+
+void wxbMenuBar::Delete(wxMenu * menu, int i)
+{
+  int j;
+
+  if (menu) {
+	for (i = 0; i < n; i++) {
+		if (menus[i] == menu)
+        	break;
+        }	
+	if (i >= n)
+		return;
+  } else {
+         if (i < 0 || i >= n)
+                return;
+         menu = menus[i];
+  }
+
+  if (!OnDelete(menu, i))
+         return;
+
+  --n;
+  for (j = i; j < n; j++) {
+         menus[j] = menus[j + 1];
+         titles[j] = titles[j + 1];
+  }
+}
+
+// Find the menu menuString, item itemString, and return the item id.
+// Returns -1 if none found.
+int wxbMenuBar::FindMenuItem (char *menuString, char *itemString)
+{
+  char buf1[200];
+  char buf2[200];
+  wxStripMenuCodes (menuString, buf1);
+  for (int i = 0; i < n; i++)
+    {
+      wxStripMenuCodes (titles[i], buf2);
+      if (strcmp (buf1, buf2) == 0)
+	return menus[i]->FindItem (itemString);
+    }
+  return -1;
+}
+
+wxMenuItem *wxbMenuBar::FindItemForId (int Id, wxMenu ** itemMenu)
+{
+  if (itemMenu)
+    *itemMenu = NULL;
+
+  wxMenuItem *item = NULL;
+  for (int i = 0; i < n; i++)
+    if (item = menus[i]->FindItemForId (Id, itemMenu))
+      return item;
+  return NULL;
+}
+
+void wxbMenuBar::SetHelpString (int Id, char *helpString)
+{
+  for (int i = 0; i < n; i++)
+    {
+      if (menus[i]->FindItemForId (Id))
+	{
+	  menus[i]->SetHelpString (Id, helpString);
+	  return;
+	}
+    }
+}
+
+char *wxbMenuBar::GetHelpString (int Id)
+{
+  for (int i = 0; i < n; i++)
+    {
+      if (menus[i]->FindItemForId (Id))
+	return menus[i]->GetHelpString (Id);
+    }
+  return NULL;
+}
+
+#ifndef wx_mac // The following doesn't belong in this file! Moved to wb_frame.cc
+void wxbFrame::SetMenuBar (wxMenuBar * menu_bar)
+{
+}
+#endif
+
+// Single check box item
+wxbCheckBox::wxbCheckBox (void)
+{
+  __type = wxTYPE_CHECK_BOX;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbCheckBox::wxbCheckBox (wxPanel * panel, wxFunction func, char *Title,
+	     int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_CHECK_BOX;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+#ifndef wx_mac
+wxbCheckBox::wxbCheckBox (wxPanel * panel, wxFunction func, wxBitmap * bitmap,
+	     int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_CHECK_BOX;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+#else
+wxbCheckBox::wxbCheckBox (wxPanel* parentPanel, int x, int y, int width, int height,
+		long style, char* name) 
+	: wxItem (parentPanel, x, y, width, height, style,  name)
+{
+  __type = wxTYPE_CHECK_BOX;
+}
+#endif
+
+wxbCheckBox::~wxbCheckBox (void)
+{
+}
+
+void wxbCheckBox::Command (wxCommandEvent & event)
+{
+  SetValue (event.commandInt);
+  ProcessCommand (event);
+}
+
+void wxbCheckBox::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+
+wxbChoice::wxbChoice (void)
+{
+  __type = wxTYPE_CHOICE;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+
+wxbChoice::wxbChoice (wxPanel * panel, wxFunction func, char *Title,
+	   int x, int y, int width, int height, int N, char **Choices,
+	   long style, char *name)
+#ifdef wx_mac
+	: wxItem (panel, x, y, width, height, style, name)
+#endif
+{
+  __type = wxTYPE_CHOICE;
+#ifndef wx_mac
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  no_strings = N;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+#endif
+}
+
+wxbChoice::~wxbChoice (void)
+{
+}
+
+char *wxbChoice::GetStringSelection (void)
+{
+  int sel = GetSelection ();
+  if (sel > -1)
+    return this->GetString (sel);
+  else
+    return NULL;
+}
+
+Bool wxbChoice::SetStringSelection (char *s)
+{
+  int sel = FindString (s);
+  if (sel > -1)
+    {
+      SetSelection (sel);
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+void wxbChoice::Command (wxCommandEvent & event)
+{
+  SetSelection (event.commandInt);
+  ProcessCommand (event);
+}
+
+void wxbChoice::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Listbox item
+wxbListBox::wxbListBox (void)
+{
+  __type = wxTYPE_LIST_BOX;
+  selected = -1;
+  selections = 0;
+  no_items = 0;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbListBox::wxbListBox (wxPanel * panel, wxFunction func,
+	    char *Title, Bool Multiple,
+	    int x, int y, int width, int height,
+	    int N, char **Choices, long style, char *name)
+{
+  __type = wxTYPE_LIST_BOX;
+  windowStyle = style;
+  selected = -1;
+  selections = 0;
+  multiple = Multiple;
+  window_parent = panel;
+  no_items = 0;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+
+wxbListBox::~wxbListBox (void)
+{
+}
+
+int wxbListBox::Number (void)
+{
+  return no_items;
+}
+
+// For single selection items only
+char *wxbListBox::GetStringSelection (void)
+{
+  int sel = GetSelection ();
+  if (sel > -1)
+    return this->GetString (sel);
+  else
+    return NULL;
+}
+
+Bool wxbListBox::SetStringSelection (char *s)
+{
+  int sel = FindString (s);
+  if (sel > -1)
+    {
+      SetSelection (sel);
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+// Is this the right thing? Won't setselection generate a command
+// event too? No! It'll just generate a setselection event.
+// But we still can't have this being called whenever a real command
+// is generated, because it sets the selection, which will already
+// have been done! (Unless we have an optional argument for calling
+// by the actual window system, or a separate function, ProcessCommand)
+void wxbListBox::Command (wxCommandEvent & event)
+{
+  if (event.extraLong)
+    SetSelection (event.commandInt);
+  else
+    {
+      Deselect (event.commandInt);
+      return;
+    }
+  ProcessCommand (event);
+}
+
+void wxbListBox::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Radiobox item
+wxbRadioBox::wxbRadioBox (void)
+{
+  __type = wxTYPE_RADIO_BOX;
+  selected = -1;
+  no_items = 0;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbRadioBox::wxbRadioBox (wxPanel * panel, wxFunction func,
+	     char *Title,
+	     int x, int y, int width, int height,
+	     int N, char **Choices,
+	     int majorDim, long style, char *name)
+{
+  __type = wxTYPE_RADIO_BOX;
+  windowStyle = style;
+  selected = -1;
+  window_parent = panel;
+  no_items = 0;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+#ifndef __BORLANDC__
+wxbRadioBox::wxbRadioBox (wxPanel * panel, wxFunction func,
+	     char *Title,
+	     int x, int y, int width, int height,
+	     int N, wxBitmap ** Choices,
+	     int majorDim, long style, char *name)
+{
+  __type = wxTYPE_RADIO_BOX;
+  windowStyle = style;
+  selected = -1;
+  window_parent = panel;
+  no_items = 0;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+#endif
+
+wxbRadioBox::~wxbRadioBox (void)
+{
+}
+
+int wxbRadioBox::Number (void)
+{
+  return no_items;
+}
+
+// For single selection items only
+char *wxbRadioBox::GetStringSelection (void)
+{
+  int sel = GetSelection ();
+  if (sel > -1)
+    return this->GetString (sel);
+  else
+    return NULL;
+}
+
+Bool wxbRadioBox::SetStringSelection (char *s)
+{
+  int sel = FindString (s);
+  if (sel > -1)
+    {
+      SetSelection (sel);
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+void wxbRadioBox::Command (wxCommandEvent & event)
+{
+  SetSelection (event.commandInt);
+  ProcessCommand (event);
+}
+
+void wxbRadioBox::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Message
+wxbMessage::wxbMessage (void)
+{
+  __type = wxTYPE_MESSAGE;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbMessage::wxbMessage (wxPanel * panel, char *label, int x, int y, long style, char *name)
+{
+  __type = wxTYPE_MESSAGE;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+#if USE_BITMAP_MESSAGE
+wxbMessage::wxbMessage (wxPanel * panel, wxBitmap *image, int x, int y, long style, char *name)
+{
+  __type = wxTYPE_MESSAGE;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+#endif
+
+#ifdef wx_mac
+//-----------------------------------------------------------------------------
+wxbMessage::wxbMessage // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName
+	) :
+		wxItem (parentArea, x, y, width, height, style, windowName)
+{
+  __type = wxTYPE_MESSAGE;
+}
+
+//-----------------------------------------------------------------------------
+wxbMessage::wxbMessage // Constructor (given parentWindow)
+	(
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName
+	) :
+		wxItem (parentWindow, x, y, width, height, style, windowName)
+{
+  __type = wxTYPE_MESSAGE;
+}
+#endif // wx_mac
+
+wxbMessage::~wxbMessage (void)
+{
+}
+
+// Text item
+
+wxbText::wxbText (void)
+{
+  __type = wxTYPE_TEXT;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbText::wxbText (wxPanel * panel, wxFunction Function, char *label, char *value,
+	 int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_TEXT;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+  callback = Function;
+}
+
+wxbText::~wxbText (void)
+{
+}
+
+
+void wxbText::Command (wxCommandEvent & event)
+{
+  SetValue (event.commandString);
+  ProcessCommand (event);
+}
+
+void wxbText::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+
+  wxNotifyEvent (event, FALSE);
+}
+
+// Multi-line Text item
+
+wxbMultiText::wxbMultiText (void)
+{
+  __type = wxTYPE_MULTI_TEXT;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbMultiText::wxbMultiText (wxPanel * panel, wxFunction Function, char *label, char *value,
+	      int x, int y, int width, int height, long style, char *name)
+#ifdef wx_mac
+ : wxText (panel, Function, label, value, x, y, width, height, style,  name)
+#endif
+{
+  __type = wxTYPE_MULTI_TEXT;
+#ifndef wx_mac
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+#endif
+}
+
+#ifdef wx_mac
+// Constructor (given parentTextWindow)
+wxbMultiText::wxbMultiText (wxTextWindow* parentTextWindow, wxFunction function, char* label,
+	 char* value, int x, int y, int	width, int height, long	style, char*  name)
+  : wxText (parentTextWindow, function, label, value, x, y, width, height,
+				style,  name)
+{
+  __type = wxTYPE_MULTI_TEXT;
+}
+#endif
+
+void wxbMultiText::Command (wxCommandEvent & event)
+{
+  SetValue (event.commandString);
+  ProcessCommand (event);
+}
+
+void wxbMultiText::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+  wxNotifyEvent (event, FALSE);
+}
+
+
+wxbSlider::wxbSlider (void)
+{
+  __type = wxTYPE_SLIDER;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbSlider::wxbSlider (wxPanel * panel, wxFunction func, char *label, int value,
+	   int min_value, int max_value, int width, int x, int y, long style, char *name)
+{
+  __type = wxTYPE_SLIDER;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+wxbSlider::~wxbSlider (void)
+{
+}
+
+void wxbSlider::Command (wxCommandEvent & event)
+{
+  SetValue (event.commandInt);
+  ProcessCommand (event);
+}
+
+void wxbSlider::ProcessCommand (wxCommandEvent & event)
+{
+  if (wxNotifyEvent (event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun && *fun)
+    {
+      (void) (*(fun)) (*this, event);
+    }
+    else
+    {
+      wxWindow *parent = GetParent();
+      if (parent)
+        parent->OnCommand(*this, event);
+    }
+  wxNotifyEvent (event, FALSE);
+}
+
+wxbGroupBox::wxbGroupBox (void)
+{
+  __type = wxTYPE_GROUP_BOX;
+  window_parent = NULL;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbGroupBox::wxbGroupBox (wxPanel * panel, char *label,
+	   int x, int y, int width, int height, long style, char *name)
+{
+  __type = wxTYPE_GROUP_BOX;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+wxbGroupBox::~wxbGroupBox (void)
+{
+}
+
+#if  USE_GAUGE
+wxbGauge::wxbGauge (void)
+{
+  __type = wxTYPE_GAUGE;
+  window_parent = NULL;
+  labelPosition = wxHORIZONTAL;
+  buttonFont = NULL;
+  labelFont = NULL;
+  backColour = NULL;
+  labelColour = NULL;
+  buttonColour = NULL;
+}
+
+wxbGauge::wxbGauge (wxPanel * panel, char *label,
+	   int range, int x, int y, int width, int height, long style, char *name)
+	  : wxItem (panel, x, y, width, height, style, name)
+{
+  __type = wxTYPE_GAUGE;
+  windowStyle = style;
+  window_parent = panel;
+  labelPosition = panel->label_position;
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+}
+
+wxbGauge::~wxbGauge (void)
+{
+}
+#endif // USE_GAUGE
+
+#ifdef wx_mac
+//-----wxMac specific 
+
+
+//-----------------------------------------------------------------------------
+wxbRadioBox::wxbRadioBox // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		int			N,
+		long		style,
+		char*		windowName
+	) :
+		wxItem (parentPanel, x, y, width, height, style, windowName),
+		no_items (N),
+		selected (-1)
+{
+	__type = wxTYPE_RADIO_BOX;
+}
+
+//-----------------------------------------------------------------------------
+//
+wxbListBox::wxbListBox 
+	(
+		wxPanel * parentPanel, 
+	    int x, 
+	    int y, 
+	    int width, 
+	    int height,
+	    int N, 
+	    long style, 
+	    char *windowName
+	) :
+		wxItem (parentPanel, x, y, width, height, style, windowName),
+		no_items (N),
+		selected (-1)
+{
+	__type == wxTYPE_LIST_BOX;
+}
+
+// ------------- Slider ---------------
+wxbSlider::wxbSlider 
+	(
+		wxPanel * panel, 
+		char *label, 
+		int value,
+		int min_value, 
+		int max_value, 
+		int width, 
+		int x, 
+		int y, 
+		long style, 
+		char *windowName
+	) : 
+		wxItem (panel, x, y, width, -1, style, windowName)
+{
+	__type == wxTYPE_SLIDER;
+}
+
+//-----------------------------------------------------------------------------
+wxbText::wxbText // Constructor (given parentWindow)
+	(
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName
+	) :
+		wxItem (parentWindow, x, y, width, height, style, windowName)
+{
+	__type == wxTYPE_TEXT;
+}
+
+//-----------------------------------------------------------------------------
+wxbMenu::wxbMenu // Constructor (given Title)
+	(
+		char*		Title,
+		char*		windowName
+	) :
+		wxItem( windowName),
+		no_items (0),
+		menu_bar (NULL),
+		top_level_menu (NULL), // Kludge: will be set in wxMenu constructor
+		title (macCopyString(Title))
+{
+	__type == wxTYPE_MENU;
+}
+
+//-----------------------------------------------------------------------------
+wxbMenuBar::wxbMenuBar // Constructor (given objectType)
+	(
+		char*		windowName
+	) :
+		wxItem( windowName),
+		n (0),
+		menus (NULL),
+		titles (NULL),
+		menu_bar_frame (NULL)
+{
+	__type == wxTYPE_MENU_BAR;
+}
+
+//-----------------------------------------------------------------------------
+wxbMenuBar::wxbMenuBar // Constructor (given Menus)
+	(
+		int			N,
+		wxMenu*		Menus[],
+		char*		Titles[],
+		char*		windowName
+	) :
+		wxItem( windowName),
+		n (N),
+		menus (Menus),
+		titles (Titles),
+		menu_bar_frame (NULL)
+{
+	__type == wxTYPE_MENU_BAR;
+	for (int i = 0; i < n; i++)
+	{
+		menus[i]->menu_bar = (wxMenuBar*) this;
+		menus[i]->SetTitle(titles[i]); 					// kludge
+	}
+}
+
+#endif // wx_mac
\ No newline at end of file
diff --git a/src/wxmac/src/base/wb_list.cc b/src/wxmac/src/base/wb_list.cc
new file mode 100644
index 0000000..fc8abc6
--- /dev/null
+++ b/src/wxmac/src/base/wb_list.cc
@@ -0,0 +1,821 @@
+/*
+ * File:		wb_list.cc
+ * Purpose:	List implementation
+ * Author:		Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:	$Id: wb_list.cc,v 1.1 1996/01/10 23:46:29 markus Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+#ifdef __GNUG__
+#pragma implementation "wx_list.h"
+#endif
+
+#ifndef wx_xt
+    // wxWindows standard include mechanism
+    /* static const char sccsid[] = "@(#)wb_list.cc	1.2 5/9/94"; */
+    // For compilers that support precompilation, includes "wx.h".
+// #   include "wx_prec.h"
+#   ifdef __BORLANDC__
+#	pragma hdrstop
+#   endif
+#   ifndef WX_PRECOMP
+#	include "common.h"
+#	include "wx_list.h"
+#	include "wx_utils.h"
+#   endif
+    // Sun CC compatibility (interference with xview/pkg.h, apparently...)
+#   if defined(SUN_CC) && defined(wx_xview)
+#	undef va_start
+#	undef va_end
+#	undef va_arg
+#	undef va_list
+#   endif
+#   include <stdlib.h>
+#else // wx_xt
+    // The Xt port uses another include mechanism
+#   define  Uses_wxList
+#   define  Uses_wxStringList
+#   include "wx.h"
+#endif // #ifndef wx_xt
+
+#include <stdarg.h>
+#include <string.h>
+
+wxNode::wxNode (wxList *, wxNode * last_one, wxNode * next_one,
+	wxObject * object)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  key.string = NULL;
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+// Keyed constructor
+wxNode::wxNode (wxList *, wxNode * last_one, wxNode * next_one,
+	wxObject * object, long the_key)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  key.integer = the_key;
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+wxNode::wxNode (wxList *, wxNode * last_one, wxNode * next_one,
+	wxObject * object, const char *the_key)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  key.string = copystring (the_key);
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+
+void wxNode::Kill(wxList *list)
+{
+  if (list)
+    list->n--;
+
+#ifndef wx_mac
+  if (list && list->destroy_data)
+    delete data;
+#endif
+
+  if (list && list->key_type == wxKEY_STRING && key.string)
+    delete[]key.string;
+
+  // Make next node point back to the previous node from here
+  if (next)
+    next->previous = previous;
+  else if (list)
+    // If there's a new end of list (deleting the last one)
+    // make sure the list knows about it.
+    list->last_node = previous;
+
+  // Make the previous node point to the next node from here
+  if (previous)
+    previous->next = next;
+
+  // Or if no previous node (start of list), make sure list points at
+  // the next node which becomes the first!.
+  else if (list)
+    list->first_node = next;
+
+  next = previous = NULL;
+  list = NULL;
+  
+#ifdef wx_mac
+// Put this here since data may try to remove itself as a child: kludge
+  if (list && list->destroy_data)
+    delete data;
+#endif // wx_mac
+}
+
+#ifdef wx_mac
+wxList::wxList(DestroyDataCode destroyData, Bool clean_up)
+: wxObject(clean_up)
+{
+  __type = wxTYPE_LIST;
+  first_node = NULL;
+  last_node = NULL;
+  n = 0;
+  destroy_data = destroyData;
+  key_type = wxKEY_NONE;
+}
+#else // wx_mac
+wxList::wxList (void)
+{
+  __type = wxTYPE_LIST;
+  first_node = NULL;
+  last_node = NULL;
+  n = 0;
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+}
+#endif // wx_mac
+
+wxList::wxList (int N, wxObject * Objects[])
+{
+  __type = wxTYPE_LIST;
+  wxNode *last = NULL;
+
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      wxNode *next = new wxNode (this, last, NULL, Objects[i]);
+      last = next;
+      if (i == 0)
+	first_node = next;
+    }
+  last_node = last;
+  n = N;
+  key_type = wxKEY_NONE;
+}
+
+wxList::wxList(KeyType the_key_type, Bool clean_up)
+: wxObject(clean_up)
+{
+  __type = wxTYPE_LIST;
+  n = 0;
+  destroy_data = 0;
+  first_node = NULL;
+  last_node = NULL;
+  key_type = the_key_type;
+}
+
+// Variable argument list, terminated by a zero
+wxList::wxList (wxObject *, ...)
+{
+#if 0
+  __type = wxTYPE_LIST;
+  va_list ap;
+
+  va_start (ap, first_one);
+
+  wxNode *last = new wxNode (this, NULL, NULL, first_one);
+  first_node = last;
+  n = 1;
+
+  for (;;)
+    {
+      wxObject *object = va_arg (ap, wxObject *);
+//    if (object == NULL) // Doesn't work in Windows -- segment is non-zero for NULL!
+#ifdef wx_msw
+      if ((int) object == 0)
+#else
+      if ((long) object == 0)
+#endif
+	break;
+      else
+	{
+	  wxNode *node = new wxNode (this, last, NULL, object);
+	  last = node;
+	  n++;
+	}
+    }
+  last_node = last;
+  va_end (ap);
+
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+#else
+#ifndef wx_msw
+  fprintf (stderr, "Error: cannot use variable-argument functions on\n");
+#endif
+#endif
+}
+
+wxList::~wxList (void)
+{
+  wxNode *each = first_node;
+  while (each)
+    {
+      wxNode *next = each->Next ();
+
+      each->Kill(this);
+      delete each;
+
+      each = next;
+    }
+
+  first_node = last_node = NULL;
+}
+
+wxNode *wxList::Nth (int i)
+{
+  int j = 0;
+  for (wxNode * current = First (); current; current = current->Next ())
+    {
+      if (j++ == i)
+	return current;
+    }
+  return NULL;			// No such element
+
+}
+
+wxNode *wxList::Find (long key)
+{
+  wxNode *current = First();
+  while (current)
+  {
+    if (current->key.integer == key)
+      return current;
+    current = current->Next();
+  }
+    
+  return NULL;			// Not found!
+}
+
+wxNode *wxList::Find (const char *key)
+{
+  wxNode *current = First();
+  while (current)
+  {
+      if (!current->key.string)
+	{
+	  wxFatalError ("wxList: string key not present, probably did not Append correctly!");
+	  break;
+	}
+      if (strcmp (current->key.string, key) == 0)
+	return current;
+      current = current->Next();
+  }
+
+  return NULL;			// Not found!
+
+}
+
+wxNode *wxList::Member (wxObject * object)
+{
+  for (wxNode * current = First (); current; current = current->Next ())
+    {
+      wxObject *each = current->Data ();
+      if (each == object)
+	return current;
+    }
+  return NULL;
+}
+
+Bool wxList::DeleteNode (wxNode * node)
+{
+  if (node)
+    {
+      node->Kill(this);
+      delete node;
+      return TRUE;
+    }
+  return FALSE;
+}
+
+Bool wxList::DeleteObject (wxObject * object)
+{
+  // Search list for object
+  for (wxNode * current = first_node; current; current = current->Next ())
+    {
+      if (current->Data () == object)
+	{
+	  current->Kill(this);
+	  delete current;
+	  return TRUE;
+	}
+    }
+  return FALSE;			// Did not find the object
+
+}
+
+
+// Insert new node at front of list
+wxNode *wxList::Insert (wxObject * object)
+{
+  wxNode *node = new wxNode (this, NULL, First (), object);
+  first_node = node;
+
+  if (!(node->Next ()))
+    last_node = node;
+
+  n++;
+  return node;
+}
+
+
+// Insert new node before given node.
+wxNode *wxList::Insert (wxNode * position, wxObject * object)
+{
+  wxNode *prev = NULL;
+  if (position)
+    prev = position->Previous ();
+
+  wxNode *node = new wxNode (this, prev, position, object);
+  if (!first_node)
+    {
+      first_node = node;
+      last_node = node;
+    }
+  if (!prev)
+    first_node = node;
+
+  n++;
+  return node;
+}
+
+// Keyed append
+wxNode *wxList::Append (long key, wxObject * object)
+{
+  wxNode *node = new wxNode (this, last_node, NULL, object, key);
+  if (!first_node)
+    first_node = node;
+  last_node = node;
+  n++;
+  return node;
+}
+
+wxNode *wxList::Append (const char *key, wxObject * object)
+{
+  wxNode *node = new wxNode (this, last_node, NULL, object, key);
+  if (!first_node)
+    first_node = node;
+  last_node = node;
+  n++;
+  return node;
+}
+
+void wxList::Clear (void)
+{
+  wxNode *current = first_node;
+  while (current)
+    {
+      wxNode *next = current->Next ();
+      delete current;
+      current = next;
+    }
+  first_node = NULL;
+  last_node = NULL;
+  n = 0;
+}
+
+// (stefan.hammes@urz.uni-heidelberg.de)
+//
+// function for sorting lists. the concept is borrowed from 'qsort'.
+// by giving a sort function, arbitrary lists can be sorted.
+// method:
+// - put wxObject pointers into an array
+// - sort the array with qsort
+// - put back the sorted wxObject pointers into the list
+//
+// CAVE: the sort function receives pointers to wxObject pointers (wxObject **),
+//       so dereference right!
+// EXAMPLE:
+//   int listcompare(const void *arg1, const void *arg2)
+//   {
+//      return(compare(**(wxString **)arg1,
+//                     **(wxString **)arg2));
+//   }
+//
+//   void main()
+//   { 
+//     wxList list;
+//
+//     list.Append(new wxString("DEF"));
+//     list.Append(new wxString("GHI"));
+//     list.Append(new wxString("ABC"));
+//     list.Sort(listcompare);
+//   }
+
+void wxList::Sort(wxSortCompareFunction compfunc)
+{
+  // allocate an array for the wxObject pointers of the list
+  const size_t num = Number();
+  wxObject **objArray = new wxObject *[num];
+  wxObject **objPtr = objArray;
+  
+  // go through the list and put the pointers into the array
+  wxNode *node = First();
+  while(node!=NULL){
+    *objPtr++ = node->Data();
+    node = node->Next();
+  }
+  // sort the array
+  qsort((void *)objArray,num,sizeof(wxObject *),compfunc);
+  // put the sorted pointers back into the list  
+  objPtr = objArray;
+  node = First();
+  while(node!=NULL){
+    node->SetData(*objPtr++);
+    node = node->Next();
+  }
+  // free the array
+  delete[] objArray;
+}
+
+/*
+ * String list
+ *
+ */
+
+wxStringList::wxStringList (void):
+wxList ()
+{
+  __type = wxTYPE_STRING_LIST;
+}
+
+#ifdef MEMORY_USE_METHOD
+long wxList::MemoryUse(void)
+{
+  wxNode *node;
+  long s = 0;
+
+  for (node = First(); node; node = node->Next())
+    s += sizeof(wxNode);
+  
+  return s + wxObject::MemoryUse();
+}
+#endif
+
+
+// Variable argument list, terminated by a zero
+// Makes new storage for the strings
+wxStringList::wxStringList (char *, ...)
+{
+#if 0
+  __type = wxTYPE_STRING_LIST;
+  n = 0;
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+  first_node = NULL;
+  last_node = NULL;
+
+  if (!first)
+    return;
+
+  va_list ap;
+
+  va_start (ap, first);
+
+  wxNode *last = new wxNode (this, NULL, NULL, (wxObject *) copystring (first));
+  first_node = last;
+  n = 1;
+
+  for (;;)
+    {
+      char *s = va_arg (ap, char *);
+//    if (s == NULL)
+#ifdef wx_msw
+      if ((int) s == 0)
+#else
+      if ((long) s == 0)
+#endif
+	break;
+      else
+	{
+	  wxNode *node = new wxNode (this, last, NULL, (wxObject *) copystring (s));
+	  last = node;
+	  n++;
+	}
+    }
+  last_node = last;
+  va_end (ap);
+#else
+#ifndef wx_msw
+  fprintf (stderr, "Error: cannot use variable-argument functions\n");
+#endif
+#endif
+}
+
+wxStringList::~wxStringList (void)
+{
+  wxNode *each = first_node;
+  while (each)
+    {
+      char *s = (char *) each->Data ();
+      delete[]s;
+      wxNode *next = each->Next ();
+      delete each;
+      each = next;
+    }
+}
+
+wxNode *wxStringList::Add (const char *s)
+{
+  return Append ((wxObject *) (copystring (s)));
+}
+
+void wxStringList::Delete (const char *s)
+{
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      char *string = (char *) node->Data ();
+      if (string == s || strcmp (string, s) == 0)
+	{
+	  delete[]string;
+	  delete node;
+	  break;		// Done!
+
+	}
+    }				// for
+
+}
+
+// Only makes new strings if arg is TRUE
+char **wxStringList::ListToArray (Bool new_copies)
+{
+  char **string_array = new char *[Number ()];
+  wxNode *node = First ();
+  int i;
+  for (i = 0; i < n; i++)
+    {
+      char *s = (char *) node->Data ();
+      if (new_copies)
+	string_array[i] = copystring (s);
+      else
+	string_array[i] = s;
+      node = node->Next ();
+    }
+  return string_array;
+}
+
+static int 
+wx_comparestrings (const void *arg1, const void *arg2)
+{
+  char **s1 = (char **) arg1;
+  char **s2 = (char **) arg2;
+
+  return strcmp (*s1, *s2);
+}
+
+// Sort a list of strings - deallocates old nodes, allocates new
+void wxStringList::Sort (void)
+{
+  size_t N = n;
+  char **array = new char *[N];
+
+  size_t i = 0;
+  for (wxNode * node = First (); node; node = node->Next ())
+    array[i++] = (char *) node->Data ();
+
+  qsort (array, N, sizeof (char *), wx_comparestrings);
+  Clear ();
+
+  for (i = 0; i < N; i++)
+    Append ((wxObject *) (array[i]));
+
+  delete[]array;
+}
+
+// Checks whether s is a member of the list
+Bool wxStringList::Member (const char *s)
+{
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) node->Data ();
+      if (s == s1 || strcmp (s, s1) == 0)
+	return TRUE;
+    }
+  return FALSE;
+}
+
+/****************************************************************************/
+
+wxChildNode* wxChildNode::Next()
+{
+  return owner->FindNode(this);
+}
+
+wxObject* wxChildNode::Data()
+{
+  if (strong)
+    return strong;
+  else if (weak)
+    return *weak;
+  else
+    return NULL;
+}
+
+Bool wxChildNode::IsShown()
+{
+  return strong ? TRUE : FALSE;
+}
+
+wxChildList::wxChildList()
+{
+  n = 0;
+  size = 0;
+  nodes = NULL;
+}
+
+wxChildList::~wxChildList()
+{
+  
+}
+
+void wxChildList::Append(wxObject *object)
+{
+  int i;
+  wxChildNode *cn = new wxChildNode, **naya;
+
+  cn->owner = this;
+  cn->strong = object;
+  cn->weak = NULL;
+  
+  for (i = 0; i < size; i++)
+    if (!nodes[i]) {
+      nodes[i] = cn;
+      n++;
+      return;
+    }
+
+  size = (size * 2) + 20;
+  naya = new wxChildNode* [size];
+  for (i = 0; i < n; i++)
+    naya[i] = nodes[i];
+
+  nodes = naya;
+  nodes[n++] = cn;
+}
+
+Bool wxChildList::DeleteObject(wxObject *object)
+{
+  int i;
+
+  for (i = 0; i < size; i++)
+    if (nodes[i] && (nodes[i]->Data() == object)) {
+      nodes[i]->strong = NULL;
+      nodes[i]->weak = NULL;
+      nodes[i] = NULL;
+      n--;
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+#ifdef wx_mac
+long wxList::MemberIndex(wxObject *object) // WCH wx_mac added 8/12/94
+{
+  long result = 0;
+  wxNode *current = First();
+  wxNode *found = NULL;
+  while (current && !found)
+  {
+    wxObject *each = current->Data();
+    if (each == object)
+      found = current;
+    else
+    {
+    	current = current->Next();
+    	result++;
+    }
+  }
+  return (found ? result : -1);
+}
+
+Bool wxList::OnDeleteObject(wxObject *object)  // mac platform only
+{
+  Bool result;
+
+  wxNode *current = first_node;
+  while (current)
+  {
+    if (current->Data() == object)
+      break;
+    else current = current->Next();
+  }
+
+  if (current)
+  {
+	int destroy_data_saved = destroy_data; // kludge
+	destroy_data = kNoDestroyData; // kludge
+
+    delete current;
+    
+	destroy_data = destroy_data_saved; // kludge
+
+    result = TRUE;
+  }
+  else result = FALSE;
+
+  return result;
+}
+#endif // wx_mac
+
+Bool wxChildList::DeleteNode(wxChildNode *node)
+{
+  int i;
+
+  for (i = 0; i < size; i++)
+    if (nodes[i] == node) {
+      nodes[i]->strong = NULL;
+      nodes[i]->weak = NULL;
+      nodes[i] = NULL;
+      n--;
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+wxChildNode *wxChildList::FindNode(wxChildNode *after)
+{
+  int i;
+
+  if (after) {
+    for (i = 0; i < size; i++)
+      if (nodes[i] == after)
+	break;
+    i++;
+  } else
+    i = 0;
+  for (; i < size; i++)
+    if (nodes[i]) {
+      wxChildNode *node = nodes[i];
+
+      if (node->Data())
+	return node;
+      /* GC: */
+      node->strong = NULL;
+      node->weak = NULL;
+      nodes[i] = NULL;
+      n--;
+    }
+
+  return NULL;
+}
+
+void wxChildList::Show(wxObject *object, int show)
+{
+  int i;
+
+  for (i = 0; i < size; i++)
+    if (nodes[i] && (nodes[i]->Data() == object)) {
+      wxChildNode *node = nodes[i];
+
+      if (show) {
+	if (node->strong)
+	  return;
+	node->strong = object;
+	node->weak = NULL;
+      } else {
+	if (node->weak)
+	  return;
+	node->weak = new WXGC_ATOMIC wxObject*;
+	*node->weak = object;
+	node->strong = NULL;
+      }
+      return;
+    }
+}
+
+Bool wxChildList::IsShown(wxObject *object)
+{
+  int i;
+
+  for (i = 0; i < size; i++)
+    if (nodes[i] && (nodes[i]->Data() == object)) {
+      wxChildNode *node = nodes[i];
+
+      return (node->strong) ? TRUE : FALSE;
+    }
+
+  return FALSE;
+}
+
diff --git a/src/wxmac/src/base/wb_main.cc b/src/wxmac/src/base/wb_main.cc
new file mode 100644
index 0000000..ab74bd1
--- /dev/null
+++ b/src/wxmac/src/base/wb_main.cc
@@ -0,0 +1,112 @@
+/*
+ * File:	wb_main.cc
+ * Purpose:	wxApp implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_main.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+#include "wx_panel.h"
+#include "wx_frame.h"
+#include "wx_main.h"
+#include "wx_utils.h"
+#include "wx_gdi.h"
+#include "wx_dc.h"
+#include "wx_dialg.h"
+#include "wx_types.h"
+#include "wx_dcps.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "wx_sysev.h"
+
+#include <string.h>
+
+extern char *wxBuffer;
+
+wxApp *wxTheApp = NULL;
+
+wxbApp::wxbApp(wxlanguage_t )
+{
+  __type = wxTYPE_APP;
+  wx_class = NULL;
+  wantDebugOutput = TRUE ;
+}
+
+wxbApp::~wxbApp(void)
+{
+}
+
+Bool wxbApp::Initialized(void)
+{
+  return FALSE;
+}
+
+wxFrame *wxbApp::OnInit(void)
+{
+  return NULL;
+}
+
+int wxbApp::OnExit(void)
+{
+  return 0;
+}
+
+void wxCommonInit(void)
+{
+#if defined(wx_msw) || defined(wx_mac)
+  wxBuffer = new char[1500];
+#else
+  wxBuffer = new char[BUFSIZ + 512];
+#endif
+//  wxTheColourList = new wxGDIList ;
+  wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+  wxTheColourDatabase->Initialize();
+  wxTheFontNameDirectory.Initialize();
+  wxInitializeStockObjects();
+  wxInitStandardTypes();
+  wxInitStandardEvents();
+  wxThePrintPaperDatabase = new wxPrintPaperDatabase;
+}
+
+void wxCommonCleanUp(void)
+{
+  wxDeleteStockObjects() ;
+  // Destroy all GDI lists, etc.
+  delete wxTheBrushList;
+  delete wxThePenList;
+  delete wxTheFontList;
+  delete wxTheBitmapList;
+#ifdef wx_mac
+  delete wxTheCursorList;
+  delete wxTheIconList;
+#endif
+  delete wxThePrintPaperDatabase;
+
+  delete wxTheColourDatabase;
+//  delete wxTheColourList; // After ALL Gdi objects, remove remaining colors.
+  wxDeleteEventLists() ;
+
+  delete[] wxBuffer;
+}
+
diff --git a/src/wxmac/src/base/wb_mf.cc b/src/wxmac/src/base/wb_mf.cc
new file mode 100644
index 0000000..66fdb00
--- /dev/null
+++ b/src/wxmac/src/base/wb_mf.cc
@@ -0,0 +1,78 @@
+/*
+ * File:	wb_mf.cc
+ * Purpose:	Metafiles and metafile DCs
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_mf.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_mf.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#if USE_METAFILE
+#include "wb_mf.h"
+#include "wx_types.h"
+
+/*
+ * Metafiles - Windows 3.1 only
+ * Currently, the only purpose for making a metafile is to put
+ * it on the clipboard.
+ */
+
+wxbMetaFile::wxbMetaFile(void)
+{
+  __type = wxTYPE_METAFILE;
+}
+
+wxbMetaFile::~wxbMetaFile(void)
+{
+}
+
+Bool wxbMetaFile::SetClipboard(int width, int height)
+{
+  return FALSE;
+}
+
+/*
+ * Metafile device context
+ *
+ */
+
+wxbMetaFileDC::wxbMetaFileDC(char *file)
+{
+  __type = wxTYPE_DC_METAFILE;
+}
+
+wxbMetaFileDC::~wxbMetaFileDC(void)
+{
+}
+
+wxMetaFile *wxbMetaFileDC::Close(void)
+{
+  return NULL;
+}
+
+void wxbMetaFileDC::SetMapMode(int mode)
+{
+}
+
+#endif // USE_METAFILE
diff --git a/src/wxmac/src/base/wb_mgstr.cc b/src/wxmac/src/base/wb_mgstr.cc
new file mode 100644
index 0000000..4d9e5f7
--- /dev/null
+++ b/src/wxmac/src/base/wb_mgstr.cc
@@ -0,0 +1,135 @@
+/*
+ * File:      wb_mgstr.cc
+ * Purpose:     simple language support
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:     August 1994
+ * RCS_ID:      $Id: wb_mgstr.cc,v 1.4 1994/08/15 21:53:50 edz Exp edz $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_mgstr.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_main.h"
+#include "wx_utils.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+static const char *msg_english[] =
+{
+/* wxSTR_ERROR               */ "Error",
+/* wxSTR_WARNING             */ "Warning",
+
+/* wxSTR_YES                 */ "Yes",
+/* wxSTR_NO                  */ "No",
+
+/* wxSTR_BUTTON_OK           */ "OK",
+/* wxSTR_BUTTON_CANCEL       */ "Cancel",
+/* wxSTR_BUTTON_REVERT       */ "Revert",
+/* wxSTR_BUTTON_UPDATE       */ "Update",
+/* wxSTR_CONSTRAINT_VIOLATION*/ "Constraint violation",
+/* wxSTR_VIOLATION_FLOAT     */ "%s should be in range %.2f to %.2f",
+/* wxSTR_VIOLATION_LONG      */ "%s should be in range %.0f to %.0f",
+/* wxSTR_MENU_HELP           */ "Help",
+/* wxSTR_BUTTON_HELP         */ "Help",
+
+/* wxSTR_FILE_SELECTOR       */ "File selector",
+/* wxSTR_OVERWRITE_FILE      */ "Overwrite existing file %s?",
+/* wxSTR_LOAD_FILE           */ "Load %s file",
+/* wxSTR_SAVE_FILE           */ "Save %s file",
+/* wxSTR_ENTER_FILENAME      */ "Enter %s file name",
+/* wxSTR_LABEL_FILENAME      */ "Name",
+/* wxSTR_LABEL_PATH          */ "Path",
+/* wxSTR_LABEL_FILES         */ "Files",
+/* wxSTR_LABEL_DIRS          */ "Directories",
+
+/* wxSTR_HELP_TIMEOUT        */ "Connection to wxHelp timed out in %d seconds",
+ NULL
+};
+
+static const char *msg_german[] =
+{
+/* wxSTR_ERROR               */ "Fehler",
+/* wxSTR_WARNING             */ "Warnung",
+
+/* wxSTR_YES                 */ "Ja",
+/* wxSTR_NO                  */ "Nein",
+
+/* wxSTR_BUTTON_OK           */ "OK",
+/* wxSTR_BUTTON_CANCEL       */ "Abbrechen",
+/* wxSTR_BUTTON_REVERT       */ "Reset",
+/* wxSTR_BUTTON_UPDATE       */ "Aktualisieren",
+/* wxSTR_CONSTRAINT_VIOLATION*/ "Wertebereich Verletzung",
+/* wxSTR_VIOLATION_FLOAT     */ "%s liegt nicht im Bereich von %.2f bis %.2f",
+/* wxSTR_VIOLATION_LONG      */ "%s liegt nicht im Bereich von %.0f bis %.0f",
+/* wxSTR_MENU_HELP           */ "Hilfe",
+/* wxSTR_BUTTON_HELP         */ "Hilfe",
+
+/* wxSTR_FILE_SELECTOR       */ "Datai Auswahl",
+/* wxSTR_OVERWRITE_FILE      */ "Überschriebe datai %s?",
+/* wxSTR_LOAD_FILE           */ "Lese %s-Datai",
+/* wxSTR_SAVE_FILE           */ "Speiche %s-Datai",
+/* wxSTR_ENTER_FILENAME      */ "%s Datainame Auswahl",
+/* wxSTR_LABEL_FILENAME      */ "Name",
+/* wxSTR_LABEL_PATH          */ "Pfad",
+/* wxSTR_LABEL_FILES         */ "Dataien",
+/* wxSTR_LABEL_DIRS          */ "Verzeichnis",
+
+/* wxSTR_HELP_TIMEOUT        */ "wxHelp Verbindungsaufbau 'timeout' nach %d sec.",
+ NULL
+};
+
+// To Do:
+//      (0) Use the language of the platform NOT default
+//          English
+//      (1) extend support to other 8859-1 languages
+//      (2) Use UTF for string encodings
+//      (3) Add in sub-font mechanism for Unicode
+//      (4) Add in support for non 8859 languages
+
+void 
+wxSetLanguage (wxlanguage_t language)
+{
+  switch (language)
+    {
+    case wxLANGUAGE_DEFAULT:
+#if defined(wx_msw) && USE_RESOURCES
+      char *lang;
+      if (wxGetResource ("intl", "sLanguage", &lang, "WIN.INI") == FALSE)
+	lang = copystring ("eng");
+      if (StringMatch (lang, "eng"))
+	wxSetLanguage (wxLANGUAGE_ENGLISH);
+      else if (StringMatch (lang, "ger"))
+	wxSetLanguage (wxLANGUAGE_GERMAN);
+      else
+	wxSetLanguage (wxLANGUAGE_ENGLISH);
+      delete[]lang;
+#else
+      // Default is English
+      wxSetLanguage (wxLANGUAGE_ENGLISH);
+#endif
+      break;
+    case wxLANGUAGE_GERMAN:
+      wx_msg_str = (char **) &(msg_german[0]);
+      break;
+    case wxLANGUAGE_ENGLISH:
+    default:
+      wx_msg_str = (char **) &(msg_english[0]);
+      break;
+    }
+}
diff --git a/src/wxmac/src/base/wb_obj.cc b/src/wxmac/src/base/wb_obj.cc
new file mode 100644
index 0000000..5299830
--- /dev/null
+++ b/src/wxmac/src/base/wb_obj.cc
@@ -0,0 +1,59 @@
+/*
+ * File:	wb_obj.cc
+ * Purpose:	wxObject base class implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_obj.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+/* static const char sccsid[] = "@(#)wb_obj.cc	1.2 5/9/94"; */
+
+#ifdef __GNUG__
+#pragma implementation "wx_obj.h"
+#endif
+
+#include "wx_obj.h"
+#include "wx_types.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+int wx_object_count;
+
+wxObject::wxObject(void)
+{
+  __type = wxTYPE_ANY;
+  wx_object_count++;
+}
+
+wxObject::wxObject(int cleanup)
+: gc_cleanup(cleanup)
+{
+  __type = wxTYPE_ANY;
+  wx_object_count++;
+}
+
+wxObject::wxObject(int cleanup, WXTYPE t)
+: gc_cleanup(cleanup)
+{
+  __type = t;
+  wx_object_count++;
+}
+
+
+wxObject::~wxObject(void)
+{
+  __type = -1;
+  --wx_object_count;
+}
+
diff --git a/src/wxmac/src/base/wb_panel.cc b/src/wxmac/src/base/wb_panel.cc
new file mode 100644
index 0000000..88b7845
--- /dev/null
+++ b/src/wxmac/src/base/wb_panel.cc
@@ -0,0 +1,495 @@
+/*
+ * File:	wb_panel.cc
+ * Purpose:	wxPanel class implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_panel.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_panel.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wb_panel.h"
+#include "wx_buttn.h"
+#include "wx_stdev.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+class wxFrame;
+class wxPanel;
+
+// Constructors
+
+#ifndef wx_mac
+wxbPanel::wxbPanel(void)
+{
+  __type = wxTYPE_PANEL;
+  defaultItem = NULL;
+  new_line = FALSE;
+  label_position = wxHORIZONTAL;
+  window_parent = NULL;
+}
+
+wxbPanel::wxbPanel(wxWindow *parent, int x, int y, int width, int height, long style,
+                  char *name)
+{
+  __type = wxTYPE_PANEL;
+  windowStyle = style;
+  defaultItem = NULL;
+  new_line = FALSE;
+  label_position = wxHORIZONTAL;
+
+  window_parent = parent;
+}
+
+/*
+wxbPanel::wxbPanel(wxPanel *frame, int x, int y, int width, int height, long style,
+                   char *name)
+{
+  __type = wxTYPE_PANEL;
+  windowStyle = style;
+  defaultItem = NULL;
+  new_line = FALSE;
+  label_position = wxHORIZONTAL;
+
+  if (!frame)
+    return;
+
+  window_parent = frame;
+}
+*/
+#endif // wx_mac
+
+wxbPanel::~wxbPanel(void)
+{
+}
+
+wxObject* wxbPanel::GetChild(int number)
+{
+  // Return a pointer to the Nth object in the Panel
+  if (!children)
+    return(NULL) ;
+  wxChildNode *node = GetChildren()->First();
+  while (node && number--)
+    node = node->Next() ;
+  if (node)
+  {
+    wxObject *obj = (wxObject *)node->Data();
+    return(obj) ;
+  }
+  else
+    return NULL ;
+}
+
+void wxbPanel::SetLabelPosition(int pos)  // wxHORIZONTAL or wxVERTICAL
+{
+  label_position = pos;
+}
+
+int wxbPanel::GetLabelPosition(void)
+{
+  return label_position;
+}
+
+void wxbPanel::OnDefaultAction(wxItem *initiatingItem)
+{
+  wxButton *but = GetDefaultItem();
+  if (but)
+  {
+    wxCommandEvent *event = new wxCommandEvent(wxEVENT_TYPE_BUTTON_COMMAND);
+    event->eventObject = but;
+    but->Command(*event);
+  }
+}
+
+void wxbPanel::SetLabelFont(wxFont *fnt)
+{
+  labelFont = fnt ;
+//***added by D.Chubraev 
+  this->font=labelFont; 
+#ifdef wx_motif
+  int scaled_size = (int) (10 * ((int) (this->font->GetPointSize () + 0.5))); 
+  int res_x = 100; 
+  int res_y = 100; 
+  XFontStruct *fontStruct = wxFontPool->FindNearestFont (this->font->GetFamily (
+),  
+                                this->font->GetStyle (), 
+                                this->font->GetWeight (), scaled_size, 
+                                this->font->GetUnderlined (), res_x, res_y); 
+  this->font->xFont=fontStruct; 
+#endif 
+//*** 
+}
+
+void wxbPanel::SetButtonFont(wxFont *font)
+{
+  buttonFont = font ;
+}
+
+void wxbPanel::SetBackgroundColour(wxColour *col)
+{
+  backColour = col ;
+}
+
+void wxbPanel::SetLabelColour(wxColour *col)
+{
+  labelColour = col ;
+}
+
+void wxbPanel::SetButtonColour(wxColour *col)
+{
+  buttonColour = col ;
+}
+
+#if USE_WX_RESOURCES
+#include "wx_res.h"
+#include "wx_buttn.h"
+#include "wx_check.h"
+#include "wx_choic.h"
+#include "wx_group.h"
+#include "wx_messg.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_rbox.h"
+#include "wx_lbox.h"
+#include "wx_gauge.h"
+#include "wx_slidr.h"
+#include "wx_dialg.h"
+
+/*
+ * Optional resource loading facility
+ */
+
+Bool wxbPanel::LoadFromResource(wxWindow *parent, char *resourceName)
+{
+  wxItemResource *resource = wxDefaultResourceTable.FindResource(resourceName);
+  if (!resource || (resource->GetType() != wxTYPE_DIALOG_BOX))
+    return FALSE;
+  char *title = resource->GetTitle();
+  long windowStyle = resource->GetStyle();
+  Bool isModal = (Bool)resource->GetValue1();
+  int x = resource->GetX();
+  int y = resource->GetY();
+  int width = resource->GetWidth();
+  int height = resource->GetHeight();
+  char *name = resource->GetName();
+
+  wxFont *theButtonFont = (wxFont *)resource->GetValue2();
+  wxFont *theLabelFont = (wxFont *)resource->GetValue3();
+
+  if (wxSubType(__type, wxTYPE_DIALOG_BOX))
+  {
+    wxDialogBox *dialogBox = (wxDialogBox *)this;
+    if (!dialogBox->Create(parent, title, isModal, x, y, width, height, windowStyle, name))
+      return FALSE;
+  }
+  else
+  {
+    if (!((wxPanel *)this)->Create(parent, x, y, width, height, windowStyle, name))
+      return FALSE;
+  }
+
+  if (theButtonFont)
+    SetButtonFont(theButtonFont);
+  if (theLabelFont)
+    SetLabelFont(theLabelFont);
+
+  // Now create children
+  wxNode *node = resource->GetChildren().First();
+  while (node)
+  {
+    wxItemResource *childResource = (wxItemResource *)node->Data();
+    if (childResource->GetStyle() & wxVERTICAL_LABEL)
+      SetLabelPosition(wxVERTICAL);
+    else
+      SetLabelPosition(wxHORIZONTAL);
+      
+    switch (childResource->GetType())
+    {
+      case wxTYPE_BUTTON:
+      {
+        wxButton *control = NULL;
+        if (childResource->GetValue4())
+        {
+          // Bitmap button
+          wxBitmap *bitmap = childResource->GetBitmap();
+          if (!bitmap)
+          {
+            bitmap = wxResourceCreateBitmap(childResource->GetValue4());
+            childResource->SetBitmap(bitmap);
+          }
+          if (bitmap)
+           control = new wxButton((wxPanel *)this, (wxFunction)NULL, bitmap,
+             childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+             childResource->GetStyle(), childResource->GetName());
+        }
+        else
+          // Normal, text button
+          control = new wxButton((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        break;
+      }
+      case wxTYPE_MESSAGE:
+      {
+        wxMessage *control = NULL;
+        if (childResource->GetValue4())
+        {
+          // Bitmap button
+          wxBitmap *bitmap = childResource->GetBitmap();
+          if (!bitmap)
+          {
+            bitmap = wxResourceCreateBitmap(childResource->GetValue4());
+            childResource->SetBitmap(bitmap);
+          }
+          if (bitmap)
+           control = new wxMessage((wxPanel *)this, bitmap,
+             childResource->GetX(), childResource->GetY(), // childResource->GetWidth(), childResource->GetHeight(),
+             childResource->GetStyle(), childResource->GetName());
+        }
+        else
+        {
+           control = new wxMessage((wxPanel *)this, childResource->GetTitle(),
+             childResource->GetX(), childResource->GetY(), // childResource->GetWidth(), childResource->GetHeight(),
+             childResource->GetStyle(), childResource->GetName());
+        }
+        break;
+      }
+      case wxTYPE_TEXT:
+      {
+        (void)new wxText((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(), childResource->GetValue4(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        break;
+      }
+      case wxTYPE_MULTI_TEXT:
+      {
+        (void)new wxMultiText((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(), childResource->GetValue4(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        break;
+      }
+      case wxTYPE_CHECK_BOX:
+      {
+        wxCheckBox *control = new wxCheckBox((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        control->SetValue((Bool)childResource->GetValue1());
+        break;
+      }
+#if USE_GAUGE
+      case wxTYPE_GAUGE:
+      {
+        wxGauge *control = new wxGauge((wxPanel *)this, childResource->GetTitle(), (int)childResource->GetValue2(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        control->SetValue((int)childResource->GetValue1());
+        break;
+      }
+#endif
+      case wxTYPE_SLIDER:
+      {
+        (void)new wxSlider((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(), (int)childResource->GetValue1(),
+           (int)childResource->GetValue2(), (int)childResource->GetValue3(),
+           childResource->GetWidth(), childResource->GetX(), childResource->GetY(),
+           childResource->GetStyle(), childResource->GetName());
+        break;
+      }
+      case wxTYPE_GROUP_BOX:
+      {
+        (void)new wxGroupBox((wxPanel *)this, childResource->GetTitle(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           childResource->GetStyle(), childResource->GetName());
+        break;
+      }
+      case wxTYPE_LIST_BOX:
+      {
+        wxStringList *stringList = childResource->GetStringValues();
+        char **strings = NULL;
+        int noStrings = 0;
+        if (stringList && (stringList->Number() > 0))
+        {
+          noStrings = stringList->Number();
+          strings = new char *[noStrings];
+          wxNode *node = stringList->First();
+          int i = 0;
+          while (node)
+          {
+            strings[i] = (char *)node->Data();
+            i ++;
+            node = node->Next();
+          }
+        }
+        (void)new wxListBox((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(), (int)childResource->GetValue1(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           noStrings, strings, childResource->GetStyle(), childResource->GetName());
+
+        if (strings)
+          delete[] strings;
+
+        break;
+      }
+      case wxTYPE_CHOICE:
+      {
+        wxStringList *stringList = childResource->GetStringValues();
+        char **strings = NULL;
+        int noStrings = 0;
+        if (stringList && (stringList->Number() > 0))
+        {
+          noStrings = stringList->Number();
+          strings = new char *[noStrings];
+          wxNode *node = stringList->First();
+          int i = 0;
+          while (node)
+          {
+            strings[i] = (char *)node->Data();
+            i ++;
+            node = node->Next();
+          }
+        }
+        (void)new wxChoice((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           noStrings, strings, childResource->GetStyle(), childResource->GetName());
+
+        if (strings)
+          delete[] strings;
+
+        break;
+      }
+      case wxTYPE_RADIO_BOX:
+      {
+        wxStringList *stringList = childResource->GetStringValues();
+        char **strings = NULL;
+        int noStrings = 0;
+        if (stringList && (stringList->Number() > 0))
+        {
+          noStrings = stringList->Number();
+          strings = new char *[noStrings];
+          wxNode *node = stringList->First();
+          int i = 0;
+          while (node)
+          {
+            strings[i] = (char *)node->Data();
+            i ++;
+            node = node->Next();
+          }
+        }
+        (void)new wxRadioBox((wxPanel *)this, (wxFunction)NULL, childResource->GetTitle(),
+           childResource->GetX(), childResource->GetY(), childResource->GetWidth(), childResource->GetHeight(),
+           noStrings, strings, 0, childResource->GetStyle(), childResource->GetName());
+
+        if (strings)
+          delete[] strings;
+
+        break;
+      }
+    }
+    node = node->Next();
+  }
+  return TRUE;
+}
+#endif
+
+#ifdef wx_mac
+//=============================================================================
+// Protected constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxbPanel::wxbPanel // Constructor (given parentArea)
+	(
+		char*		windowName,
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxCanvas (parentArea, x, y, width, height, style, windowName)
+{
+	__type = wxTYPE_PANEL;
+	InitDefaults();
+	InitMoreDefaults();
+}
+
+//-----------------------------------------------------------------------------
+wxbPanel::wxbPanel // Constructor (given parentWindow)
+	(
+		char*		windowName,
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxCanvas (parentWindow, x, y, width, height, style, windowName)
+{
+	__type = wxTYPE_PANEL;
+	InitDefaults();
+	InitMoreDefaults();
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxbPanel::InitDefaults(void)
+{
+	defaultItem = NULL;
+
+	has_child = FALSE;
+
+	hSpacing = PANEL_HSPACING;
+	vSpacing = PANEL_VSPACING;
+	initial_hspacing = hSpacing;
+	initial_vspacing = vSpacing;
+	current_hspacing = hSpacing;
+	current_vspacing = vSpacing;
+
+	new_line = FALSE;
+}
+
+//-----------------------------------------------------------------------------
+void wxbPanel::InitMoreDefaults(void) // Poor name for this method
+{
+    if (wxSubType(window_parent->__type, wxTYPE_PANEL) &&
+    	cParentArea == window_parent->ClientArea())
+	{
+    	wxPanel* parentPanel = (wxPanel*) window_parent;
+		backColour = parentPanel->backColour;
+		buttonColour = parentPanel->buttonColour;
+		buttonFont = parentPanel->buttonFont;
+		labelColour = parentPanel->labelColour;
+		labelFont = parentPanel->labelFont;
+		label_position = parentPanel->label_position;
+	}
+	else
+	{
+		backColour = NULL;
+		buttonColour = NULL;
+		buttonFont = NULL;
+		labelColour = NULL;
+		labelFont = NULL;
+		label_position = wxHORIZONTAL;
+	}
+}
+
+#endif // wx_mac
diff --git a/src/wxmac/src/base/wb_ps.cc b/src/wxmac/src/base/wb_ps.cc
new file mode 100644
index 0000000..b119df0
--- /dev/null
+++ b/src/wxmac/src/base/wb_ps.cc
@@ -0,0 +1,2506 @@
+/*
+ * File:      wb_ps.cc
+ * Purpose:     Device context implementation (PostScript)
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_ps.cc,v 1.5 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+/* This file is the same for all three version of wxWindows from
+   PLT. */
+
+/* static const char sccsid[] = "@(#)wb_ps.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#if defined(_MSC_VER)
+# include "wx.h"
+#else
+
+#ifdef wx_xt
+# ifdef __GNUG__
+# pragma implementation "PSDC.h"
+# endif
+
+# define  Uses_XLib
+# define  Uses_wxList
+# define  Uses_wxWindowDC
+# define  Uses_wxMemoryDC
+# define  Uses_wxPostScriptDC
+# define  Uses_wxPrintSetup
+# define  Uses_wxFontNameDirectory
+# define  Uses_wxDialogBox
+# define  Uses_wxButton
+# define  Uses_wxRadioBox
+# define  Uses_wxText
+# define  Uses_wxChoice
+# define  Uses_wxCheckBox
+# include "wx.h"
+
+# include <math.h>
+# include <string.h>
+
+#else
+
+# ifdef __GNUG__
+# pragma implementation "wx_dcps.h"
+# pragma implementation
+# pragma interface
+#endif
+
+# include "common.h"
+# include "wx_frame.h"
+# include "wx_dcps.h"
+# include "wx_dcmem.h"
+# include "wx_utils.h"
+# include "wx_dialg.h"
+# include "wx_cmdlg.h"
+# include "wx_main.h"
+# include "wx_lbox.h"
+# include "wx_rbox.h"
+# include "wx_buttn.h"
+# include "wx_choic.h"
+# include "wx_check.h"
+# include "wx_messg.h"
+# include "wx_txt.h"
+# include "wx_mtxt.h"
+
+#endif
+#endif
+
+#if USE_POSTSCRIPT
+
+# define YSCALE(y) ((paper_h) - ((y) * user_scale_y + device_origin_y))
+# define XSCALE(x) ((x) * user_scale_x + device_origin_x)
+# define YOFFSET(y) ((paper_h) - ((y) + device_origin_y))
+# define XOFFSET(x) ((x) + device_origin_x)
+# define YSCALEREL(dy) ((dy) * user_scale_y)
+# define XSCALEREL(dx) ((dx) * user_scale_x)
+# define XSCALEBND(dx) (XSCALEREL(dx) + device_origin_x)
+# define YSCALEBND(dy) (YSCALEREL(dy) + device_origin_y)
+
+# define ASCALEREL(a) ((a) * ascale)
+
+# define PIE pie
+
+static double pie = 0.0;
+
+#ifndef WXUNUSED
+# define WXUNUSED(x) x
+#endif
+#ifndef IMPLEMENT_DYNAMIC_CLASS
+# define IMPLEMENT_DYNAMIC_CLASS(x, y) /* empty */
+#endif
+
+#ifdef wx_xt
+# define WXXTUNUSED(c) /* empty */
+#else
+# define WXXTUNUSED(x) x
+#endif
+
+#ifndef wx_mac
+# define OFSTREAM_HAS_TELLP_AND_SEEKP 1
+#endif
+
+#define DEFAULT_PAPER "Letter 8 1/2 x 11 in"
+
+class wxCanvas;
+
+#ifndef wx_xt
+#include "wx_privt.h"
+#endif
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+// #include <time.h>
+#include <limits.h>
+#include <assert.h>
+
+Bool XPrinterDialog (wxWindow *parent);
+
+// Determine the Default Postscript Previewer
+// available on the platform
+#if defined(sun) && defined(wx_xview)
+// OpenWindow/NeWS's Postscript Previewer
+# define PS_VIEWER_PROG "pageview"
+#elif defined(VMS)
+#define PS_VIEWER_PROG "view/format=ps/select=x_display"
+#elif defined(__sgi)
+// SGI's Display Postscript Previewer
+# define PS_VIEWER_PROG "dps"
+#elif defined(wx_x)
+// Front-end to ghostscript 
+# define PS_VIEWER_PROG "ghostview"
+#else
+// Windows ghostscript/ghostview
+# define PS_VIEWER_PROG NULL
+#endif
+
+#ifndef wx_xt
+wxPrintSetupData *wxThePrintSetupData = NULL;
+#endif
+#ifdef wx_mac
+wxPrintPaperDatabase *wxThePrintPaperDatabase;
+#endif
+
+/*
+static char *wx_preview_command = copystring(PS_VIEWER_PROG);
+static Bool wx_printer_orientation = PS_PORTRAIT;
+static int wx_printer_mode = PS_PREVIEW;
+
+#ifdef VMS
+static char *wx_printer_command = copystring("print");
+static char *wx_printer_flags = copystring("/nonotify/queue=psqueue");
+static char *wx_afm_path = copystring("sys$ps_font_metrics:");
+#endif
+#ifdef wx_msw
+static char *wx_printer_command = copystring("print");
+static char *wx_afm_path = copystring("c:\\windows\\system\\");
+static char *wx_printer_flags = NULL;
+#endif
+#if !defined(VMS) && !defined(wx_msw)
+static char *wx_printer_command = copystring("lpr");
+static char *wx_printer_flags = NULL;
+static char *wx_afm_path = NULL;
+#endif
+*/
+
+#define _MAXPATHLEN 500
+
+/* See "wxspline.cc" and "xfspline.cc" */
+#if USE_XFIG_SPLINE_CODE
+static const char *wxPostScriptHeaderSpline = " \
+/DrawSplineSection {\n\
+	/y3 exch def\n\
+	/x3 exch def\n\
+	/y2 exch def\n\
+	/x2 exch def\n\
+	/y1 exch def\n\
+	/x1 exch def\n\
+	/xa x1 x2 x1 sub 0.666667 mul add def\n\
+	/ya y1 y2 y1 sub 0.666667 mul add def\n\
+	/xb x3 x2 x3 sub 0.666667 mul add def\n\
+	/yb y3 y2 y3 sub 0.666667 mul add def\n\
+	x1 y1 lineto\n\
+	xa ya xb yb x3 y3 curveto\n\
+	} def\n\
+";
+#else
+// No extra PS header for this spline implementation.
+static const char *wxPostScriptHeaderSpline = NULL;
+
+#endif /* USE_XFIG_SPLINE_CODE */
+
+// steve, 05.09.94
+// VMS has a bug in the ofstream class.
+// the buffering doesn't work correctly. therefore
+// we will allocate (temporarily) a very big buffer (1MB), so
+// that a buffer overflow will not occur.
+#ifdef VMS
+#define VMS_BUFSIZ (1024L*1024L)
+static char *fileBuffer = NULL;
+#endif
+
+#ifndef wx_xt
+# define current_font font
+#else
+# define current_bk_mode current_text_bgmode
+# define current_text_foreground current_text_fg
+# define current_text_background current_text_bg
+#endif
+
+IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
+
+wxPostScriptDC::wxPostScriptDC (void)
+{
+  Create(NULL, TRUE, NULL);
+}
+
+wxPostScriptDC::wxPostScriptDC (char *file, Bool interactive, wxWindow *parent)
+{
+  Create(file, interactive, parent);
+}
+
+Bool wxPostScriptDC::Create(char *file, Bool interactive, wxWindow *parent)
+{
+  if (!pie)
+    pie = 2 * asin(1);
+
+  __type = wxTYPE_DC_POSTSCRIPT;
+#ifndef wx_xt
+  wx_interactive = interactive;
+#endif
+  current_font = wxNORMAL_FONT;
+  device = wxDEVICE_EPS;
+  clipping = FALSE;
+
+#ifndef wx_xt
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  min_x = 10000.0;
+  min_y = 10000.0;
+  max_x = -10000.0;
+  max_y = -10000.0;
+
+  current_logical_function = wxCOPY;
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = wxWHITE_BRUSH;
+  current_background_brush->Lock(1);
+
+  current_text_foreground = *wxBLACK;
+
+  mapping_mode = MM_TEXT;
+#endif
+
+  title = NULL;
+
+  if (file)
+    filename = copystring(file);
+  else
+    filename = NULL;
+
+  pstream = NULL;
+
+  /* MATTHEW: [9] */
+  clipx = 0;
+  clipy = 0;
+  clipw = -1;
+  cliph = -1;
+
+  if ((ok = PrinterDialog(interactive, parent)) == FALSE)
+    return FALSE;
+
+  currentRed = 0;
+  currentGreen = 0;
+  currentBlue = 0;
+
+  Colour = TRUE;
+  
+  level2ok = wxGetLevel2Ok();
+
+  char *paperType = wxThePrintSetupData->GetPaperName();
+  if (!paperType)
+    paperType = DEFAULT_PAPER;
+
+  wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
+  if (!paper)
+    paper = wxThePrintPaperDatabase->FindPaperType(DEFAULT_PAPER);
+  if (paper) {
+    paper_w = (float)paper->widthPixels;
+    paper_h = (float)paper->heightPixels;
+  } else {
+    paper_w = 1000;
+    paper_h = 1000;
+  }
+
+  if (wxThePrintSetupData) {
+    wxThePrintSetupData->GetPrinterTranslation(&paper_x, &paper_y);
+    wxThePrintSetupData->GetPrinterScaling(&paper_x_scale, &paper_y_scale);
+    landscape = (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE);
+  } else {
+    paper_x = paper_y = 0;
+    paper_x_scale = paper_y_scale = 1;
+    landscape = 0;
+  }
+
+  if (landscape) {
+    float tmp;
+
+    tmp = paper_w;
+    paper_w = paper_h;
+    paper_h = tmp;
+  }
+
+  paper_w /= paper_x_scale;
+  if (!paper_w)
+    paper_w = 1;
+  paper_h /= paper_y_scale;
+  if (!paper_h)
+    paper_h = 1;
+
+  return ok;
+}
+
+wxPostScriptDC::~wxPostScriptDC (void)
+{
+  if (current_brush) current_brush->Lock(-1);
+  if (current_pen) current_pen->Lock(-1);
+  if (current_background_brush) current_background_brush->Lock(-1);
+
+  if (pstream)
+    delete pstream;
+  if (filename)
+    delete[]filename;
+}
+
+Bool wxPostScriptDC::PrinterDialog(Bool interactive, wxWindow *parent)
+{
+  if (interactive) {
+    ok = XPrinterDialog(parent);
+    if (!ok)
+      return FALSE;
+  } else
+    ok = TRUE;
+
+  mode = wxThePrintSetupData->GetPrinterMode();
+  preview_cmd = copystring(wxThePrintSetupData->GetPrintPreviewCommand());
+  print_cmd = copystring(wxThePrintSetupData->GetPrinterCommand());
+  print_opts = copystring(wxThePrintSetupData->GetPrinterOptions());
+
+  if (!filename && ((mode == PS_PREVIEW) || (mode == PS_PRINTER))) {
+// steve, 05.09.94
+#ifdef VMS
+    wxThePrintSetupData->SetPrinterFile("preview");
+#else
+    // For PS_PRINTER action this depends on a Unix-style print spooler
+    // since the wx_printer_file can be destroyed during a session
+    // @@@ TODO: a Windows-style answer for non-Unix
+    char userId[256];
+    wxGetUserId (userId, sizeof (userId) / sizeof (char));
+    char tmp[256];
+    strcpy (tmp, "/tmp/preview_");
+    strcat (tmp, userId);
+    wxThePrintSetupData->SetPrinterFile(tmp);
+#endif
+    char tmp2[256];
+    strcpy(tmp2, wxThePrintSetupData->GetPrinterFile());
+    strcat (tmp2, ".ps");
+    wxThePrintSetupData->SetPrinterFile(tmp2);
+    filename = copystring(tmp2);
+  } else if (!filename && (mode == PS_FILE)) {
+    char *file = wxSaveFileSelector("PostScript", "ps");
+    if (!file) {
+      ok = FALSE;
+      return FALSE;
+    }
+    wxThePrintSetupData->SetPrinterFile(file);
+    filename = copystring(file);
+    ok = TRUE;
+  }
+
+  return ok;
+}
+
+void wxPostScriptDC::SetClippingRegion (float cx, float cy, float cw, float ch)
+{
+  if (!pstream)
+    return;
+
+  if (!clipping)
+    *pstream << "gsave\n";
+  *pstream << "newpath\n";
+  *pstream << XSCALE(cx) << " " << YSCALE (cy) << " moveto\n";
+  *pstream << XSCALE(cx + cw) << " " << YSCALE (cy) << " lineto\n";
+  *pstream << XSCALE(cx + cw) << " " << YSCALE (cy + ch) << " lineto\n";
+  *pstream << XSCALE(cx) << " " << YSCALE (cy + ch) << " lineto\n";
+  *pstream << "closepath clip newpath\n";
+
+  /* MATTHEW: [8] */
+  clipx = cx;
+  clipy = cy;
+  clipw = cw;
+  cliph = ch;
+}
+
+/* MATTHEW: [8] */
+void wxPostScriptDC::GetClippingRegion (float *cx, float *cy, float *cw, float *ch)
+{
+  *cx = clipx;
+  *cy = clipy;
+  *cw = clipw;
+  *ch = cliph;
+}
+
+void wxPostScriptDC::DestroyClippingRegion (void)
+{
+  if (!pstream)
+    return;
+  if (clipping)
+    {
+      clipping = FALSE;
+      *pstream << "grestore\n";
+    }
+
+  /* MATTHEW: [8] */
+  clipx = 0;
+  clipy = 0;
+  clipw = -1;
+  cliph = -1;
+}
+
+void wxPostScriptDC::Clear (void)
+{
+}
+
+void wxPostScriptDC::FloodFill (float WXUNUSED(x), float WXUNUSED(y), wxColour * WXUNUSED(col), int WXUNUSED(style))
+{
+}
+
+Bool wxPostScriptDC::GetPixel (float WXUNUSED(x), float WXUNUSED(y), wxColour * WXUNUSED(col))
+{
+  return FALSE;
+}
+
+void wxPostScriptDC::IntDrawLine (int x1, int y1, int x2, int y2)
+{
+  DrawLine ((float) x1, (float) y1, (float) x2, (float) y2);
+}
+
+void wxPostScriptDC::CrossHair (float x, float y)
+{
+  DrawLine(0, y, paper_w, y);
+  DrawLine(x, 0, x, paper_h);
+}
+
+void wxPostScriptDC::DrawLine (float x1, float y1, float x2, float y2)
+{
+  if (!pstream)
+    return;
+  if (current_pen)
+    SetPen (current_pen);
+  *pstream << "newpath\n";
+  *pstream << XSCALE(x1) << " " << YSCALE (y1) << " moveto\n";
+  *pstream << XSCALE(x2) << " " << YSCALE (y2) << " lineto\n";
+  *pstream << "stroke\n";
+  CalcBoundingBox(XSCALEBND(x1), YSCALEBND(y1));
+  CalcBoundingBox(XSCALEBND(x2), YSCALEBND(y2));
+}
+
+void wxPostScriptDC::DrawArc (float x1, float y1, float x2, float y2, float xc, float yc)
+{
+  if (!pstream)
+    return;
+
+  if (x1 != x2 || y1 != y2) {
+    /* Before we scale: */
+    CalcBoundingBox(XSCALEBND(x1), YSCALEBND(y1));
+    CalcBoundingBox(XSCALEBND(x2), YSCALEBND(y2));
+    CalcBoundingBox(XSCALEBND(xc), YSCALEBND(yc));
+
+    x1 = XSCALEREL(x1);
+    x2 = XSCALEREL(x2);
+    xc = XSCALEREL(xc);
+    y1 = YSCALEREL(y1);
+    y2 = YSCALEREL(y2);
+    yc = YSCALEREL(yc);
+
+    float radius1 = sqrt(((xc - x1) * (xc - x1)) + ((yc - y1) * (yc - y1)));
+    float radius2 = sqrt(((xc - x2) * (xc - x2)) + ((yc - y2) * (yc - y2)));
+    float radius, xscale;
+    float a1, a2;
+
+    a1 = asin((y1 - yc) / radius1);
+    if (x1 < xc)
+      a1 = pie - a1;
+    if (a1 < 0)
+      a1 += pie;
+    a2 = asin((y2 - yc) / radius2);
+    if (x2 < xc)
+      a2 = pie - a2;
+    if (a2 < 0)
+      a2 += pie;
+
+    a1 *= (180 / pie);
+    a2 *= (180 / pie);
+
+    if (radius1 < radius2)
+      radius = radius1;
+    else
+      radius = radius1;
+
+    {
+      /* Set x scale */
+      float a1x, a2x;
+
+      a1x = fmod(fabs(a1), pie / 2);
+      a2x = fmod(fabs(a2), pie / 2);
+
+      xscale = radius1 / radius2;
+	xscale = 1 / xscale;
+    }
+
+    *pstream << "gsave\n";
+    *pstream << XOFFSET(xc) << " " << YOFFSET(yc) << " translate\n";
+    *pstream << xscale << " " << 1 << " scale\n";
+
+    if (current_brush && current_brush->GetStyle () != wxTRANSPARENT) {
+      SetBrush(current_brush);
+      
+      *pstream << "newpath\n";
+      *pstream << (x1 - xc) << " " << -(y1 - yc) << " moveto\n";
+      *pstream << "0 0 " << radius << " " << a1 << " " << a2 << " arc\n";
+
+      *pstream << "0 0 lineto\n";
+
+      *pstream << "closepath\n";
+
+      *pstream << "fill\n";
+    }
+    if (current_pen && current_pen->GetStyle () != wxTRANSPARENT) {
+      SetPen(current_pen);
+
+      *pstream << "newpath\n";
+      *pstream << (x1 - xc) << " " << -(y1 - yc) << " moveto\n";
+      *pstream << "0 0 " << radius << " "
+	<< a1 << " " << a2 << " arc\n";
+      *pstream << "stroke\n";
+    }
+
+    *pstream << "grestore\n";
+  }
+}
+
+void wxPostScriptDC::DrawPoint (float x, float y)
+{
+  if (!pstream)
+    return;
+  if (current_pen)
+    SetPen (current_pen);
+  *pstream << "newpath\n";
+  *pstream << XSCALE(x) << " " << YSCALE (y) << " moveto\n";
+  *pstream << XSCALE(x+1) << " " << YSCALE (y) << " lineto\n";
+  *pstream << "stroke\n";
+  CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+}
+
+void wxPostScriptDC::DrawPolygon (int n, wxPoint points[], float xoffset, float yoffset, int WXUNUSED(fillStyle))
+{
+  if (!pstream)
+    return;
+  if (n > 0)
+    {
+      if (current_brush && current_brush->GetStyle () != wxTRANSPARENT)
+	{
+	  SetBrush (current_brush);
+	  *pstream << "newpath\n";
+
+	  float xx = points[0].x + xoffset;
+	  float yy = (points[0].y + yoffset);
+	  *pstream << XSCALE(xx) << " " << YSCALE(yy) << " moveto\n";
+	  CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+
+	  int i;
+	  for (i = 1; i < n; i++)
+	    {
+	      xx = points[i].x + xoffset;
+	      yy = (points[i].y + yoffset);
+	      *pstream << XSCALE(xx) << " " << YSCALE(yy) << " lineto\n";
+	      CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+	    }
+	  *pstream << "fill\n";
+	}
+
+      if (current_pen && current_pen->GetStyle () != wxTRANSPARENT)
+	{
+	  SetPen (current_pen);
+	  *pstream << "newpath\n";
+
+	  float xx = points[0].x + xoffset;
+	  float yy = (points[0].y + yoffset);
+	  *pstream << XSCALE(xx) << " " << YSCALE(yy) << " moveto\n";
+	  CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+
+	  int i;
+	  for (i = 1; i < n; i++)
+	    {
+	      xx = points[i].x + xoffset;
+	      yy = (points[i].y + yoffset);
+	      *pstream << XSCALE(xx) << " " << YSCALE(yy) << " lineto\n";
+	      CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+	    }
+
+	  // Close the polygon
+	  xx = points[0].x + xoffset;
+	  yy = (points[0].y + yoffset);
+	  *pstream << XSCALE(xx) << " " << YSCALE(yy) << " lineto\n";
+
+	  // Output the line
+	  *pstream << "stroke\n";
+	}
+    }
+}
+
+void wxPostScriptDC::DrawLines (int n, wxIntPoint points[], int xoffset, int yoffset)
+{
+  if (!pstream)
+    return;
+  if (n > 0)
+    {
+      if (current_pen)
+	SetPen (current_pen);
+
+      *pstream << "newpath\n";
+
+      float xx = (float) (points[0].x + xoffset);
+      float yy = (float) (points[0].y + yoffset);
+      *pstream << XSCALE(xx) << " " << YSCALE(yy) << " moveto\n";
+      CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+
+      int i;
+      for (i = 1; i < n; i++)
+	{
+	  xx = (float) (points[i].x + xoffset);
+	  yy = (float) (points[i].y + yoffset);
+	  *pstream << XSCALE(xx) << " " << YSCALE(yy) << " lineto\n";
+	  CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+	}
+      *pstream << "stroke\n";
+    }
+}
+
+void wxPostScriptDC::DrawLines (int n, wxPoint points[], float xoffset, float yoffset)
+{
+  if (!pstream)
+    return;
+  if (n > 0)
+    {
+      if (current_pen)
+	SetPen (current_pen);
+
+      *pstream << "newpath\n";
+
+      float xx = points[0].x + xoffset;
+      float yy = (points[0].y + yoffset);
+      *pstream << XSCALE(xx) << " " << YSCALE(yy) << " moveto\n";
+      CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+
+      int i;
+      for (i = 1; i < n; i++)
+	{
+	  xx = points[i].x + xoffset;
+	  yy = (points[i].y + yoffset);
+	  *pstream << XSCALE(xx) << " " << YSCALE(yy) << " lineto\n";
+	  CalcBoundingBox(XSCALEBND(xx), YSCALEBND(yy));
+	}
+      *pstream << "stroke\n";
+    }
+}
+
+#ifdef wx_xt
+
+void wxPostScriptDC::DrawLines(wxList *list, float xoffset, float yoffset)
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawLines(n, points, xoffset, yoffset);
+  delete []points;
+}
+
+void wxPostScriptDC::DrawPolygon(wxList *list, float xoffset, float yoffset,int fillStyle)
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawPolygon(n, points, xoffset, yoffset,fillStyle);
+  delete[] points;
+}
+
+#endif
+
+void wxPostScriptDC::DrawRectangle (float x, float y, float width, float height)
+{
+  if (!pstream)
+    return;
+  if (current_brush && current_brush->GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (current_brush);
+
+      *pstream << "newpath\n";
+      *pstream << XSCALE(x) << " " << YSCALE (y) << " moveto\n";
+      *pstream << XSCALE(x + width) << " " << YSCALE (y) << " lineto\n";
+      *pstream << XSCALE(x + width) << " " << YSCALE (y + height) << " lineto\n";
+      *pstream << XSCALE(x) << " " << YSCALE (y + height) << " lineto\n";
+      *pstream << "closepath\n";
+      *pstream << "fill\n";
+
+      CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+      CalcBoundingBox(XSCALEBND(x + width), YSCALEBND(y + height));
+    }
+  if (current_pen && current_pen->GetStyle () != wxTRANSPARENT)
+    {
+      SetPen (current_pen);
+
+      *pstream << "newpath\n";
+      *pstream << XSCALE(x) << " " << YSCALE (y) << " moveto\n";
+      *pstream << XSCALE(x + width) << " " << YSCALE (y) << " lineto\n";
+      *pstream << XSCALE(x + width) << " " << YSCALE (y + height) << " lineto\n";
+      *pstream << XSCALE(x) << " " << YSCALE (y + height) << " lineto\n";
+      *pstream << "closepath\n";
+      *pstream << "stroke\n";
+
+      CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+      CalcBoundingBox(XSCALEBND(x + width),  YSCALEBND(y + height));
+    }
+}
+
+void wxPostScriptDC::DrawRoundedRectangle (float x, float y, float width, float height, float radius)
+{
+  if (!pstream)
+    return;
+
+  if (radius < 0.0)
+    {
+      // Now, a negative radius is interpreted to mean
+      // 'the proportion of the smallest X or Y dimension'
+      float smallest = 0.0;
+      if (width < height)
+	smallest = width;
+      else
+	smallest = height;
+      radius = (float) (-radius * smallest);
+    }
+
+  float ascale = (user_scale_x < user_scale_y) ? user_scale_x : user_scale_y;
+
+  if (current_brush && current_brush->GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (current_brush);
+      // Draw rectangle anticlockwise
+      *pstream << "newpath\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " << YSCALE(y) << " moveto\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " 
+	<< YSCALE(y) - ASCALEREL(radius) << " " << ASCALEREL(radius) << " 90 180 arc\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " 
+	<< YSCALE(y + height) + ASCALEREL(radius) << " " << ASCALEREL(radius) << " 180 270 arc\n";
+
+      *pstream << XSCALE(x + width) - ASCALEREL(radius) << " " 
+	<< YSCALE(y + height) + ASCALEREL(radius) << " " << ASCALEREL(radius) << " 270 0 arc\n";
+
+      *pstream << XSCALE(x + width) - ASCALEREL(radius) << " " 
+	<< YSCALE(y) - ASCALEREL(radius) << " " << ASCALEREL(radius) << " 0 90 arc\n";
+
+      *pstream << "closepath\n";
+
+      *pstream << "fill\n";
+
+      CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+      CalcBoundingBox(XSCALEBND(x + width), YSCALEBND(y + height));
+    }
+  if (current_pen && current_pen->GetStyle () != wxTRANSPARENT)
+    {
+      SetPen (current_pen);
+      // Draw rectangle anticlockwise
+      *pstream << "newpath\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " << YSCALE(y) << " moveto\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " 
+	<< YSCALE(y) - ASCALEREL(radius) << " " << ASCALEREL(radius) << " 90 180 arc\n";
+
+      *pstream << XSCALE(x) + ASCALEREL(radius) << " " 
+	<< YSCALE(y + height) + ASCALEREL(radius) << " " << ASCALEREL(radius) << " 180 270 arc\n";
+
+      *pstream << XSCALE(x + width) - ASCALEREL(radius) << " " 
+	<< YSCALE(y + height) + ASCALEREL(radius) << " " << ASCALEREL(radius) << " 270 0 arc\n";
+
+      *pstream << XSCALE(x + width) - ASCALEREL(radius) << " " 
+	<< YSCALE(y) - ASCALEREL(radius) << " " << ASCALEREL(radius) << " 0 90 arc\n";
+
+      *pstream << "closepath\n";
+
+      *pstream << "stroke\n";
+
+      CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+      CalcBoundingBox(XSCALEBND(x + width), YSCALEBND(y + height));
+    }
+}
+
+void wxPostScriptDC::DrawEllipse (float x, float y, float width, float height)
+{
+  if (!pstream)
+    return;
+  if (current_brush && current_brush->GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (current_brush);
+
+      *pstream << "newpath\n";
+      *pstream << XSCALE(x + width / 2) << " " << YSCALE(y + height / 2) << " ";
+      *pstream << XSCALEREL(width / 2) << " " << YSCALEREL(height / 2) << " 0 360 ellipse\n";
+      *pstream << "fill\n";
+
+      CalcBoundingBox(XSCALEBND(x - width), YSCALEBND(y - height));
+      CalcBoundingBox(XSCALEBND(x + width), YSCALEBND(y + height));
+    }
+  if (current_pen && current_pen->GetStyle () != wxTRANSPARENT)
+    {
+      SetPen (current_pen);
+
+      *pstream << "newpath\n";
+      *pstream << XSCALE(x + width / 2) << " " << YSCALE(y + height / 2) << " ";
+      *pstream << XSCALEREL(width / 2) << " " << YSCALEREL(height / 2) << " 0 360 ellipse\n";
+      *pstream << "stroke\n";
+
+      CalcBoundingBox (XSCALEBND(x - width), YSCALEBND(y - height));
+      CalcBoundingBox (XSCALEBND(x + width), YSCALEBND(y + height));
+    }
+}
+
+void wxPostScriptDC::DrawIcon (wxIcon *icon, float x, float y)
+{
+  if (icon->Ok() && !icon->selectedIntoDC) {
+    int w, h;
+    wxMemoryDC *mdc;
+    w = icon->GetWidth();
+    h = icon->GetHeight();
+
+    mdc = new wxMemoryDC();
+    mdc->SelectObject(icon);
+    if (mdc->Ok()) {
+      Blit(x, y, w, h, mdc, 0, 0);
+    }
+    mdc->SelectObject(NULL);
+    delete mdc;
+  }
+}
+
+void wxPostScriptDC::SetFont (wxFont * the_font)
+{
+  if (!pstream)
+    return;
+  if ((current_font == the_font) && !resetFont)
+    return;
+
+  resetFont = FALSE;
+
+  current_font = the_font;
+  /* MATTHEW: [2] Use wxTheFontDirectory */
+  char *name;
+  int Family = current_font->GetFamily ();
+  int Style = current_font->GetStyle ();
+  int Weight = current_font->GetWeight ();
+
+  name = wxTheFontNameDirectory.GetPostScriptName(Family, Weight, Style);
+  if (!name)
+    name = "Times-Roman";
+
+  *pstream << "/" << name << " findfont\n";
+  *pstream << YSCALEREL(current_font->GetPointSize()) << " scalefont setfont\n";
+}
+
+static void set_pattern(wxPostScriptDC *dc, ofstream *pstream, wxBitmap *bm)
+{
+  int width, height;
+  wxMemoryDC *mdc;
+
+  width = bm->GetWidth();
+  height = bm->GetHeight();
+
+  (*pstream 
+   << "8 dict\n"
+   << "dup\n"
+   << "begin\n"
+   << " /PatternType 1 def\n"
+   << " /PaintType 1 def\n"
+   << " /TilingType 1 def\n"
+   << " /BBox [ 0 0 " << width << " " << height << " ] def\n"
+   << " /XStep " << width << " def\n"
+   << " /YStep " << height << " def\n");
+
+  /* HACK ALERT: */
+  int saveSelected = bm->selectedIntoDC;
+  bm->selectedIntoDC = 0;
+#ifdef wx_msw
+  wxDC *saveInto = bm->selectedInto;
+  bm->selectedInto = NULL;
+#endif
+
+  mdc = new wxMemoryDC();
+  mdc->SelectObject(bm);
+
+  dc->Blit(0, 0, width, height, mdc, 0, 0, -1);
+
+  mdc->SelectObject(NULL);
+  delete mdc;
+
+  bm->selectedIntoDC = saveSelected;
+#ifdef wx_msw
+  bm->selectedInto = saveInto;
+#endif
+
+  (*pstream << "end\n"
+   << " matrix makepattern setpattern\n");
+}
+
+void wxPostScriptDC::SetPen (wxPen * pen)
+{
+  if (!pstream)
+    return;
+  wxPen *oldPen = current_pen;
+
+  if (current_pen) current_pen->Lock(-1);
+  if (pen) pen->Lock(1);
+
+  if ((current_pen = pen) == NULL)
+    return;			/* NIL */
+
+  // Line width
+  *pstream << pen->GetWidth () << " setlinewidth\n";
+
+  // Line style - WRONG: 2nd arg is OFFSET
+  /*
+     Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
+     operator correctly. You should look-up this in the Red Book: the 2nd parame-
+     ter is not number of values in the array of the first one, but an offset
+     into this description of the pattern. I mean a real *offset* not index
+     into array. I.e. If the command is [3 4] 1 setdash   is used, then there
+     will be first black line *2* units long, then space 4 units, then the
+     pattern of *3* units black, 4 units space will be repeated.
+   */
+  static char *dotted = "[2 5] 2";
+  static char *short_dashed = "[4 4] 2";
+  static char *long_dashed = "[4 8] 2";
+  static char *dotted_dashed = "[6 6 2 6] 4";
+
+  char *psdash = NULL;
+  switch (pen->GetStyle ())
+    {
+    case wxDOT:
+      psdash = dotted;
+      break;
+    case wxSHORT_DASH:
+      psdash = short_dashed;
+      break;
+    case wxLONG_DASH:
+      psdash = long_dashed;
+      break;
+    case wxDOT_DASH:
+      psdash = dotted_dashed;
+      break;
+    case wxSOLID:
+    case wxTRANSPARENT:
+    default:
+      psdash = "[] 0";
+      break;
+    }
+  if (oldPen != pen)
+    *pstream << psdash << " setdash\n";
+
+  if (level2ok) {
+    if ((pen->GetStyle() == wxSTIPPLE)
+	|| (pen->GetStyle() == wxOPAQUE_STIPPLE)
+	&& pen->GetStipple()->Ok()) {
+      set_pattern(this, pstream, pen->GetStipple());
+      return;
+    }
+  }
+
+  // Line colour
+  unsigned char red = pen->GetColour ().Red ();
+  unsigned char blue = pen->GetColour ().Blue ();
+  unsigned char green = pen->GetColour ().Green ();
+
+  if (!Colour)
+    {
+      // Anything not white is black
+      if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
+	    && green == (unsigned char) 255))
+	{
+	  red = (unsigned char) 0;
+	  green = (unsigned char) 0;
+	  blue = (unsigned char) 0;
+	}
+    }
+
+  if (!(red == currentRed && green == currentGreen && blue == currentBlue))
+  {
+    float redPS = (float) (((int) red) / 255.0);
+    float bluePS = (float) (((int) blue) / 255.0);
+    float greenPS = (float) (((int) green) / 255.0);
+
+    *pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
+    
+    currentRed = red;
+    currentBlue = blue;
+    currentGreen = green;
+  }
+}
+
+void wxPostScriptDC::SetBrush(wxBrush * brush)
+{
+  if (!pstream)
+    return;
+
+  if (current_brush) current_brush->Lock(-1);
+  if (brush) brush->Lock(1);
+
+  if ((current_brush = brush) == NULL)
+    return; 
+
+  if (level2ok) {
+    if ((brush->GetStyle() == wxSTIPPLE)
+	|| (brush->GetStyle() == wxOPAQUE_STIPPLE)
+	&& brush->GetStipple()->Ok()) {
+      set_pattern(this, pstream, brush->GetStipple());
+      return;
+    }
+  }
+
+  // Brush colour
+  unsigned char red = brush->GetColour ().Red ();
+  unsigned char blue = brush->GetColour ().Blue ();
+  unsigned char green = brush->GetColour ().Green ();
+
+  if (!Colour) {
+    // Anything not black is white
+    if (!(red == (unsigned char) 0 && blue == (unsigned char) 0
+	  && green == (unsigned char) 0)) {
+      red = (unsigned char) 255;
+      green = (unsigned char) 255;
+      blue = (unsigned char) 255;
+    }
+  }
+
+  if (!(red == currentRed && green == currentGreen && blue == currentBlue)) {
+    float redPS = (float) (((int) red) / 255.0);
+    float bluePS = (float) (((int) blue) / 255.0);
+    float greenPS = (float) (((int) green) / 255.0);
+    *pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
+    currentRed = red;
+    currentBlue = blue;
+    currentGreen = green;
+  }
+}
+
+void wxPostScriptDC::DrawText (DRAW_TEXT_CONST char *text, float x, float y,
+			       Bool WXUNUSED(use16))
+{
+  if (!pstream)
+    return;
+  if (current_font)
+    SetFont (current_font);
+
+  if (current_text_foreground.Ok ())
+    {
+      unsigned char red = current_text_foreground.Red ();
+      unsigned char blue = current_text_foreground.Blue ();
+      unsigned char green = current_text_foreground.Green ();
+
+      if (!Colour)
+	{
+	  // Anything not white is black
+	  if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
+		&& green == (unsigned char) 255))
+	    {
+	      red = (unsigned char) 0;
+	      green = (unsigned char) 0;
+	      blue = (unsigned char) 0;
+	    }
+	}
+      if (!(red == currentRed && green == currentGreen && blue == currentBlue))
+      {
+        float redPS = (float) (((int) red) / 255.0);
+        float bluePS = (float) (((int) blue) / 255.0);
+        float greenPS = (float) (((int) green) / 255.0);
+        *pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
+
+        currentRed = red;
+        currentBlue = blue;
+        currentGreen = green;
+      }
+    }
+
+  int size = 10;
+  if (current_font)
+    size = current_font->GetPointSize ();
+
+  *pstream << XSCALE(x) << " " << YSCALE (y + size) << " moveto\n";
+
+//  *pstream << "(" << text << ")" << " show\n";
+  *pstream << "(";
+  int len = strlen (text);
+  int i;
+  for (i = 0; i < len; i++)
+    {
+      char ch = text[i];
+      if (ch == ')' || ch == '(' || ch == '\\')
+	*pstream << "\\";
+      *pstream << ch;
+    }
+
+  *pstream << ")" << " show\n";
+
+  CalcBoundingBox(XSCALEBND(x), YSCALEBND(y));
+  {
+    float w, h;
+    GetTextExtent(text, &w, &h);
+    CalcBoundingBox(XSCALEBND(x + w), YSCALEBND(y + h));
+  }
+}
+
+
+void wxPostScriptDC::SetBackground (wxBrush * brush)
+{
+  if (current_background_brush) current_background_brush->Lock(-1);
+  if (brush) brush->Lock(1);
+
+  current_background_brush = brush;
+}
+
+void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
+{
+}
+
+void wxPostScriptDC::SetBackgroundMode(int mode)
+{
+  current_bk_mode = mode;
+}
+
+void wxPostScriptDC::SetTextBackground(wxColour *col)
+{
+  current_text_background = *col;  
+}
+
+void wxPostScriptDC::SetTextForeground(wxColour *col)
+{
+  current_text_foreground = *col;
+}
+
+void wxPostScriptDC::TryColour(wxColour *src, wxColour *dest)
+{
+  if (!Colour) {
+    if ((src->Red() == 255)
+	&& (src->Green() == 255)
+	&& (src->Blue() == 255))
+      dest->Set(255, 255, 255);
+    else
+      dest->Set(0, 0, 0);
+  } else
+    *dest = *src;
+}
+
+static const char *wxPostScriptHeaderEllipse = "\
+/ellipsedict 8 dict def\n\
+ellipsedict /mtrx matrix put\n\
+/ellipse\n\
+{ ellipsedict begin\n\
+  /endangle exch def\n\
+  /startangle exch def\n\
+  /yrad exch def\n\
+  /xrad exch def\n\
+  /y exch def\n\
+  /x exch def\n\
+  /savematrix mtrx currentmatrix def\n\
+  x y translate\n\
+  xrad yrad scale\n\
+  0 0 1 startangle endangle arc\n\
+  savematrix setmatrix\n\
+  end\n\
+  } def\n\
+";
+
+Bool wxPostScriptDC::StartDoc (char *message)
+{
+  if (device == wxDEVICE_EPS) {
+#ifdef VMS
+    // steve, 05.09.94
+    // VMS is sh*t!
+    pstream = new ofstream;
+    if (fileBuffer) delete[] fileBuffer;
+    fileBuffer = new char[VMS_BUFSIZ]; 
+    pstream->setbuf(fileBuffer,VMS_BUFSIZ);
+    pstream->open(wxThePrintSetupData->GetPrinterFile());
+#else
+    pstream = new ofstream(filename);
+#endif
+    if (!pstream || !pstream->good()) {
+      wxMessageBox (wxSTR_ERROR, "Cannot open PostScript output file", wxOK);
+      ok = FALSE;
+      delete pstream;
+      pstream = NULL;
+      return FALSE;
+    }
+    ok = TRUE;
+  }
+
+  *pstream << "%!PS-Adobe-2.0 EPSF-2.0\n";	/* PostScript magic strings */
+  if (title)
+    *pstream << "%%Title: " << title << "\n";
+  *pstream << "%%Creator: " << "wxWindows (MrEd)" << "\n";
+  *pstream << "%%CreationDate: " << wxNow() << "\n";
+
+  // User Id information
+  char userID[256];
+  if (wxGetEmailAddress(userID, sizeof(userID))) {
+    *pstream << "%%For: " << (char *)userID;
+    char userName[245];
+    if (wxGetUserName(userName, sizeof(userName)))
+      *pstream << " (" << (char *)userName << ")";
+    *pstream << "\n";
+  } else if ( wxGetUserName(userID, sizeof(userID))) {
+    *pstream << "%%For: " << (char *)userID << "\n";
+  }
+
+#ifdef OFSTREAM_HAS_TELLP_AND_SEEKP
+  boundingboxpos = pstream->tellp();
+#else
+  boundingboxpos = (pstream->rdbuf()->seekoff(0, ios::cur, 0 /* <- ?? */)).offset();
+#endif
+  *pstream << "%%BoundingBox: -0000 -0000 -0000 -0000\n";
+  *pstream << "%%Pages: -0000\n";
+  *pstream << "%%EndComments\n\n";
+
+  *pstream << wxPostScriptHeaderEllipse;
+
+  if (wxPostScriptHeaderSpline)
+    *pstream << wxPostScriptHeaderSpline;
+
+  SetBrush(wxBLACK_BRUSH);
+  SetPen(wxBLACK_PEN);
+
+  page_number = 1;
+  if (message)
+    title = copystring (message);
+
+  return TRUE;
+}
+
+
+void wxPostScriptDC::EndDoc (void)
+{
+  if (!pstream)
+    return;
+  if (clipping) {
+    clipping = FALSE;
+    *pstream << "grestore\n";
+  }
+
+  // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
+
+  // Compute the bounding box.  Note that it is in the default user
+  // coordinate system, thus we have to convert the values.
+  float llx;
+  float lly;
+  float urx;
+  float ury;
+
+  // If we're landscape, our sense of "x" and "y" is reversed.
+  if (landscape) {
+    llx = min_y * paper_y_scale + paper_y;
+    lly = min_x * paper_x_scale + paper_x;
+    urx = max_y * paper_y_scale + paper_y;
+    ury = max_x * paper_x_scale + paper_x;
+  } else {
+    llx = min_x * paper_x_scale + paper_x;
+    lly = paper_h * paper_y_scale - (max_y * paper_y_scale) + paper_y;
+    urx = max_x * paper_x_scale + paper_x;
+    ury = paper_h * paper_y_scale - (min_y * paper_y_scale) + paper_y;
+  }
+
+  // The Adobe specifications call for integers; we round as to make
+  // the bounding larger.
+#ifdef OFSTREAM_HAS_TELLP_AND_SEEKP
+  pstream->seekp(boundingboxpos, ios::beg);
+#else
+  pstream->rdbuf()->seekoff(boundingboxpos, ios::beg, 0 /* <- ?? */);
+#endif
+  *pstream << "%%BoundingBox: ";
+  pstream->width(5);
+  *pstream << floor(llx) << " ";
+  pstream->width(5);
+  *pstream << floor(lly) << " ";
+  pstream->width(5);
+  *pstream << ceil(urx)  << " ";
+  pstream->width(5);
+  *pstream << ceil(ury) << "\n";
+  *pstream << "%%Pages: ";
+  pstream->width(5);
+  *pstream << (page_number - 1) << "\n";
+
+  delete pstream;
+  pstream = NULL;
+
+#ifdef wx_x
+  if (ok /* && wx_interactive */)
+    {
+      switch (mode) {
+	case PS_PREVIEW:
+	{
+          char *argv[3];
+	  argv[0] = preview_cmd;
+          argv[1] = filename;
+          argv[2] = NULL;
+	  wxExecute (argv);
+	}
+	break;
+
+	case PS_PRINTER:
+	{
+          char *argv[4];
+          /* MATTHEW: [7] Print - not preview */
+          argv[0] = print_cmd;
+	  /* MATTHEW: [9] Use options only if it's not "" */
+	  int i = 1;
+	  char *opts = print_opts;
+	  if (opts && *opts)
+	    argv[i++] = opts;
+	  argv[i++] = filename;
+	  argv[i] = NULL;
+	  wxExecute(argv);
+	}
+	break;
+
+	case PS_FILE:
+	  break;
+	}
+    }
+#endif
+}
+
+void wxPostScriptDC::StartPage (void)
+{
+  if (!pstream)
+    return;
+  *pstream << "%%Page: " << page_number++ << "\n";
+
+  *pstream << (paper_x + (landscape ? (paper_h * paper_y_scale) : 0)) 
+    << " " << paper_y << " translate\n";
+  if (landscape) {
+    *pstream << paper_y_scale << " " << paper_x_scale << " scale\n";
+    *pstream << "90 rotate\n";
+  } else {
+    *pstream << paper_x_scale << " " << paper_y_scale << " scale\n";
+  }
+  *pstream << "2 setlinecap\n";
+
+  resetFont = TRUE;
+
+  if (clipping)
+    SetClippingRegion(clipx, clipy, clipw, cliph);
+}
+
+void wxPostScriptDC::EndPage (void)
+{
+  if (!pstream)
+    return;
+  *pstream << "showpage\n";
+}
+
+
+static void printhex(ofstream *pstream, int v)
+{
+  int h, l;
+  char s[3];
+
+  s[2] = 0;
+  
+  h = (v >> 4) & 0xF;
+  l = v & 0xF;
+  
+  if (h <= 9)
+    s[0] = '0' + h;
+  else
+    s[0] = 'a' + (h - 10);
+  if (l <= 9)
+    s[1] = '0' + l;
+  else
+    s[1] = 'a' + (l - 10);
+
+  *pstream << s;
+}
+
+
+/* MATTHEW: Implement Blit: */
+/* MATTHEW: [4] Re-wrote to use colormap */
+Bool wxPostScriptDC::
+Blit (float xdest, float ydest, float fwidth, float fheight,
+      BLIT_DC_TYPE *src, float xsrc, float ysrc, int rop)
+{
+  if (!pstream)
+    return FALSE;
+
+  wxCanvasDC *source = (wxCanvasDC *)src;
+  long width, height, x, y;
+  Bool asColour = level2ok;
+
+  width = (long)floor(fwidth);
+  height = (long)floor(fheight);
+  x = (long)floor(xsrc);
+  y = (long)floor(ysrc);
+
+  /* Allocate space: */
+  (*pstream << "/DataString " 
+   << (width * (asColour ? 3 : 1) * ((rop < 0) ? height : 1))
+   << " string def\n");
+
+  if (rop < 0) {
+    *pstream << " /PaintProc { begin \n";
+  }
+
+  /* PostScript setup: */
+  *pstream << "gsave\n";
+  if (rop >= 0) {
+    *pstream << XSCALE(xdest) << " " << YSCALE(ydest) - fheight << " translate\n";
+  }
+  *pstream << fwidth << " " << fheight << " scale\n";
+  *pstream << width << " " << height << " 8 [ ";
+  *pstream << width << " 0 0 " << (-height) << " 0 " << height;
+  *pstream << " ]\n";
+  if (rop >= 0) {
+    *pstream << "{\n";
+    *pstream << "  currentfile DataString readhexstring pop\n";
+    *pstream << "} bind";
+  } else {
+    *pstream << " { DataString } ";
+  }
+  if (asColour) {
+    *pstream << " false 3 colorimage\n";
+  } else {
+    *pstream << " image\n";
+  }
+  
+  if (rop < 0) {
+    (*pstream << "grestore\n } def \n"
+     << " { currentfile DataString readhexstring pop pop } exec\n");
+  }
+
+  /* Output data as hex digits: */
+  long j, i;
+  wxColour c;
+  int pixel;
+  int pr, pg, pb;
+
+  if (rop == wxCOLOR && current_pen) {
+    pr = current_pen->GetColour().Red();
+    pg = current_pen->GetColour().Green();
+    pb = current_pen->GetColour().Blue();
+  } else
+    pr = pg = pb = 0;
+
+  for (j = 0; j < height; j++) {
+    for (i = 0; i < width; i++) {
+      source->GetPixel(i, j, &c);
+
+      int red, green, blue;
+      red = c.Red();
+      green = c.Green();
+      blue = c.Blue();
+
+      if (rop == wxCOLOR && !red && !green && !blue) {
+	red = pr;
+	green = pg;
+	blue = pb;
+      }
+
+      if (asColour) {
+	printhex(pstream, red);
+	printhex(pstream, green);
+	printhex(pstream, blue);
+      } else {
+	float r, g, b;
+
+	r = ((float)(red) / 255);
+	g = ((float)(green) / 255);
+	b = ((float)(blue) / 255);
+
+	pixel = (int)(255 * sqrt(((r * r) + (g * g) + (b * b)) / 3));
+	
+	printhex(pstream, pixel);
+      }
+    }
+    *pstream << "\n";
+  }
+
+  if (rop >= 0) {
+    *pstream << "grestore\n";
+  }
+
+  if (rop >= 0) {
+    CalcBoundingBox(XSCALEBND(xdest), YSCALEBND(ydest));
+    CalcBoundingBox(XSCALEBND(xdest + fwidth), YSCALEBND(ydest + fheight));
+  }
+
+  return TRUE;
+}
+
+float wxPostScriptDC::GetCharHeight (void)
+{
+  if (current_font)
+    return (float) current_font->GetPointSize ();
+  else
+    return 12.0;
+}
+
+
+float wxPostScriptDC::GetCharWidth (void)
+{
+  return 0;
+}
+
+void wxPostScriptDC::GetTextExtent (const char *string, float *x, float *y,
+				    float *descent, float *externalLeading, wxFont *theFont,
+				    Bool WXUNUSED(use16))
+{
+  wxFont *fontToUse = theFont;
+  if (!fontToUse)
+    fontToUse = current_font;
+    
+  if (!pstream)
+    return;
+#if !USE_AFM_FOR_POSTSCRIPT
+  // Provide a VERY rough estimate (avoid using it)
+  int width = 12;
+  int height = 12;
+
+  if (fontToUse)
+    {
+      height = fontToUse->GetPointSize ();
+      width = height;
+    }
+  *x = (float) strlen (string) * width;
+  *y = (float) height;
+  if (descent)
+    *descent = 0.0;
+  if (externalLeading)
+    *externalLeading = 0.0;
+#else
+  // +++++ start of contributed code +++++
+  
+  // ************************************************************
+  // method for calculating string widths in postscript:
+  // read in the AFM (adobe font metrics) file for the
+  // actual font, parse it and extract the character widths
+  // and also the descender. this may be improved, but for now
+  // it works well. the AFM file is only read in if the
+  // font is changed. this may be chached in the future.
+  // calls to GetTextExtent with the font unchanged are rather
+  // efficient!!!
+  //
+  // for each font and style used there is an AFM file necessary.
+  // currently i have only files for the roman font family.
+  // i try to get files for the other ones!
+  //
+  // CAVE: the size of the string is currently always calculated
+  //       in 'points' (1/72 of an inch). this should later on be
+  //       changed to depend on the mapping mode.
+  // CAVE: the path to the AFM files must be set before calling this
+  //       function. this is usually done by a call like the following:
+  //       wxSetAFMPath("d:\\wxw161\\afm\\");
+  //
+  // example:
+  //
+  //    wxPostScriptDC dc(NULL, TRUE);
+  //    if (dc.Ok()){
+  //      wxSetAFMPath("d:\\wxw161\\afm\\");
+  //      dc.StartDoc("Test");
+  //      dc.StartPage();
+  //      float w,h;
+  //      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
+  //      dc.GetTextExtent("Hallo",&w,&h);
+  //      dc.EndPage();
+  //      dc.EndDoc();
+  //    }
+  //
+  // by steve (stefan.hammes@urz.uni-heidelberg.de)
+  // created: 10.09.94
+  // updated: 14.05.95
+
+  assert(fontToUse && "void wxPostScriptDC::GetTextExtent: no font defined");
+  assert(x && "void wxPostScriptDC::GetTextExtent: x == NULL");
+  assert(y && "void wxPostScriptDC::GetTextExtent: y == NULL");
+
+  // these static vars are for storing the state between calls
+  static int lastFamily= INT_MIN;
+  static int lastSize= INT_MIN;
+  static int lastStyle= INT_MIN;
+  static int lastWeight= INT_MIN;
+  static int lastDescender = INT_MIN;
+  static int lastWidths[256]; // widths of the characters
+
+  // get actual parameters
+  const int Family = fontToUse->GetFamily();
+  const int Size =   fontToUse->GetPointSize();
+  const int Style =  fontToUse->GetStyle();
+  const int Weight = fontToUse->GetWeight();
+
+  // if we have another font, read the font-metrics
+  if(Family!=lastFamily||Size!=lastSize||Style!=lastStyle||Weight!=lastWeight){
+    // store actual values
+    lastFamily = Family;
+    lastSize =   Size;
+    lastStyle =  Style;
+    lastWeight = Weight;
+
+    // read in new font metrics **************************************
+
+    // 1. construct filename ******************************************
+    /* MATTHEW: [2] Use wxTheFontNameDirectory */
+    char *name;
+
+    name = wxTheFontNameDirectory.GetAFMName(Family, Weight, Style);
+    if (!name)
+      name = "unknown";
+
+    // get the directory of the AFM files
+    char afmName[1024];
+    afmName[0] = 0;
+    if (wxGetAFMPath())
+      strncpy(afmName,wxGetAFMPath(), 1024);
+
+    // 2. open and process the file **********************************
+
+    // a short explanation of the AFM format:
+    // we have for each character a line, which gives its size
+    // e.g.:
+    //
+    //   C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
+    //
+    // that means, we have a character with ascii code 63, and width 
+    // (444/1000 * fontSize) points.
+    // the other data is ignored for now!
+    //
+    // when the font has changed, we read in the right AFM file and store the
+    // character widths in an array, which is processed below (see point 3.).
+
+    strncat(afmName, "/", 1024);
+    strncat(afmName, name, 1024);
+    strncat(afmName,".afm", 1024);
+    afmName[1023] = 0;
+    FILE *afmFile = fopen(afmName,"r");
+    if(afmFile==NULL){
+      wxDebugMsg("GetTextExtent: can't open AFM file '%s'\n",afmName);
+      wxDebugMsg("               using approximate values\n");
+      int i;
+      for (i=0; i<256; i++) lastWidths[i] = 500; // an approximate value
+      lastDescender = -150; // dito.
+    }else{
+      int i;
+      // init the widths array
+      for(i=0; i<256; i++) lastWidths[i]= INT_MIN;
+      // some variables for holding parts of a line
+      char cString[10],semiString[10],WXString[10],descString[20];
+      char line[256];
+      int ascii,cWidth;
+      // read in the file and parse it
+      while(fgets(line,sizeof(line),afmFile)!=NULL){
+        // A.) check for descender definition
+        if(strncmp(line,"Descender",9)==0){
+          if((sscanf(line,"%s%d",descString,&lastDescender)!=2)
+	     || (strcmp(descString,"Descender")!=0)) {
+	    wxDebugMsg("AFM-file '%s': line '%s' has error (bad descender)\n",
+		       afmName,line);
+          }
+	// B.) check for char-width
+        }else if(strncmp(line,"C ",2)==0){
+          if(sscanf(line,"%s%d%s%s%d",
+              cString,&ascii,semiString,WXString,&cWidth)!=5){
+             wxDebugMsg("AFM-file '%s': line '%s' has an error (bad character width)\n",afmName,line);
+          }
+          if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 ||
+             strcmp(WXString,"WX")!=0){
+             wxDebugMsg("AFM-file '%s': line '%s' has a format error\n",afmName,line);
+          }
+          //printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth);
+          if(ascii>=0 && ascii<256){
+            lastWidths[ascii] = cWidth; // store width
+          }else{
+	    /* MATTHEW: this happens a lot; don't print an error */
+            // wxDebugMsg("AFM-file '%s': ASCII value %d out of range\n",afmName,ascii);
+          }
+        }
+        // C.) ignore other entries.
+      }
+      fclose(afmFile);
+    }
+  }
+  
+  // 3. now the font metrics are read in, calc size *******************
+  // this is done by adding the widths of the characters in the
+  // string. they are given in 1/1000 of the size!
+
+  float widthSum=0.0;
+  float height=(float)Size; // by default
+  unsigned char *p;
+  for(p=(unsigned char *)string; *p; p++){
+    if(lastWidths[*p]== INT_MIN){
+      wxDebugMsg("GetTextExtent: undefined width for character '%c' (%d)\n",
+                 *p,*p);
+      widthSum += lastWidths[' ']; // assume space
+    }else{
+      widthSum += (lastWidths[*p]/1000.0F)*Size;
+    }
+  }
+  // add descender to height (it is usually a negative value)
+  if(lastDescender!=INT_MIN){
+    height += ((-lastDescender)/1000.0F) * Size; /* MATTHEW: forgot scale */
+  }
+  
+  // return size values
+  *x = widthSum;
+  *y = height;
+
+  // return other parameters
+  if (descent){
+    if(lastDescender!=INT_MIN){
+      *descent = ((-lastDescender)/1000.0F) * Size; /* MATTHEW: forgot scale */
+    }else{
+      *descent = 0.0;
+    }
+  }
+
+  // currently no idea how to calculate this!
+  // if (externalLeading) *externalLeading = 0.0;
+  if (externalLeading)
+    *externalLeading = 0.0;
+
+  // ----- end of contributed code -----
+#endif
+}
+
+void wxPostScriptDC::SetMapMode (int WXXTUNUSED(mode))
+{
+#ifndef wx_xt
+  mapping_mode = mode;
+#endif
+  return;
+}
+
+void wxPostScriptDC::SetUserScale (float x, float y)
+{
+  user_scale_x = x;
+  user_scale_y = y;
+}
+
+float wxPostScriptDC::DeviceToLogicalX (int x)
+{
+  return (float) x;
+}
+
+float wxPostScriptDC::DeviceToLogicalXRel (int x)
+{
+  return (float) x;
+}
+
+float wxPostScriptDC::DeviceToLogicalY (int y)
+{
+  return (float) y;
+}
+
+float wxPostScriptDC::DeviceToLogicalYRel (int y)
+{
+  return (float) y;
+}
+
+int wxPostScriptDC::LogicalToDeviceX (float x)
+{
+  return (int)floor(XSCALE(x));
+}
+
+int wxPostScriptDC::LogicalToDeviceXRel (float x)
+{
+  return (int)floor(XSCALEREL(x));
+}
+
+int wxPostScriptDC::LogicalToDeviceY (float y)
+{
+  return (int)floor(YSCALE(y));
+}
+
+int wxPostScriptDC::LogicalToDeviceYRel (float y)
+{
+  return (int)floor(YSCALEREL(y));
+}
+
+void wxPostScriptDC::GetSize(float *width, float *height)
+{
+  if (width)
+    *width = paper_w;
+  if (height)
+    *height = paper_h;
+}
+
+void wxPostScriptDC::GetSizeMM(float *WXUNUSED(width), float *WXUNUSED(height))
+{
+#if 0
+  char *paperType = wxThePrintSetupData->GetPaperName();
+  if (!paperType)
+    paperType = DEFAULT_PAPER;
+
+  wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
+  if (!paper)
+    paper = wxThePrintPaperDatabase->FindPaperType(DEFAULT_PAPER);
+  if (paper) {
+    *width = (float)paper->widthMM;
+    *height = (float)paper->heightMM;
+  }
+  else {
+    *width = 1000;
+    *height = 1000;
+  }
+#endif
+}
+
+static int level2 = TRUE;
+
+void wxSetLevel2Ok(Bool ok)
+{
+  level2 = ok;
+}
+
+Bool wxGetLevel2Ok(void)
+{
+  return level2;
+}
+
+#ifndef NO_XPRINT_DIALOG
+
+class wxPrinterDialogBox : public wxDialogBox
+{
+  public:
+  wxPrinterDialogBox (wxWindow *parent, char *title, Bool modal = FALSE,
+		      int x = -1, int y = -1, int
+		      width = -1, int height = -1);
+};
+
+wxPrinterDialogBox::wxPrinterDialogBox (wxWindow *parent, char *title, Bool isModal,
+		    int x, int y, int width, int height):
+wxDialogBox (parent, title, isModal, x, y, width, height)
+{
+}
+
+Bool wxPrinterDialogAnswer = TRUE;
+
+static void 
+wxPrinterDialogOk (wxButton & button, wxEvent & WXUNUSED(event))
+{
+  wxPrinterDialogAnswer = TRUE;
+  wxPrinterDialogBox *dialog = (wxPrinterDialogBox *) button.GetParent ();
+  dialog->Show (FALSE);
+}
+
+static void 
+wxPrinterDialogCancel (wxButton & button, wxEvent & WXUNUSED(event))
+{
+  wxPrinterDialogAnswer = FALSE;
+  wxPrinterDialogBox *dialog = (wxPrinterDialogBox *) button.GetParent ();
+  dialog->Show (FALSE);
+}
+
+#define wxSetPrintPaperName wxThePrintSetupData->SetPaperName
+#define wxGetPrintPaperName wxThePrintSetupData->GetPaperName
+
+#define COLUMN_WIDTH 150
+
+Bool 
+XPrinterDialog (wxWindow *parent)
+{
+  wxBeginBusyCursor();
+  char buf[100];
+  wxPrinterDialogBox &dialog = *(new wxPrinterDialogBox(parent, "Printer Settings", TRUE, 
+							150, 150, 400, 400));
+
+  char *paper[4];
+  paper[0] = "A4 210 x 297 mm";
+  paper[1] = "A3 297 x 420 mm";
+  paper[2] = "Letter 8 1/2 x 11 in";
+  paper[3] = "Legal 8 1/2 x 14 in";
+  wxChoice *c = new wxChoice(&dialog, NULL, NULL, -1, -1, -1, -1, 4, paper);
+  char *pt = wxGetPrintPaperName();
+  int i;
+  for (i = 0; i < 4; i++)
+    if (!strcmp(pt, paper[i]))
+      c->SetSelection(i);
+
+  wxButton *okBut = new wxButton ((wxPrinterDialogBox *)&dialog, 
+				  (wxFunction)wxPrinterDialogOk, 
+				  wxSTR_BUTTON_OK);
+  (void) new wxButton ((wxPrinterDialogBox *)&dialog, 
+		       (wxFunction)wxPrinterDialogCancel, 
+		       wxSTR_BUTTON_CANCEL);
+  dialog.NewLine();
+  dialog.NewLine();
+  okBut->SetDefault();
+
+  dialog.SetLabelPosition(wxVERTICAL);
+
+#ifdef wx_x
+  wxText &text_prt = *(new wxText(&dialog, (wxFunction) NULL, "Printer Command: ", 
+				  wxGetPrinterCommand(), -1, -1, COLUMN_WIDTH, -1));
+
+  wxText &text0 = *(new wxText(&dialog, (wxFunction) NULL, "Printer Options: ", 
+			       wxGetPrinterOptions(), -1, -1, COLUMN_WIDTH, -1));
+  dialog.NewLine ();
+  dialog.NewLine ();
+#endif
+
+  char *orientation[2];
+  orientation[0] = "Portrait";
+  orientation[1] = "Landscape";
+  wxRadioBox &radio0 = *(new wxRadioBox((wxPrinterDialogBox *)&dialog, 
+					(wxFunction)NULL, 
+					"Orientation: ", -1, -1, COLUMN_WIDTH,- 1,
+					2, (char **)orientation, 0, wxVERTICAL));
+  radio0.SetSelection((wxGetPrinterOrientation() == PS_LANDSCAPE) ? 1 : 0);
+
+  // @@@ Configuration hook
+  if (wxGetPrintPreviewCommand() == NULL) {
+#if 0
+    wxGetResource("wxWindows", "PSView", &wxThePrintSetupData->previewCommand);
+#endif
+    wxSetPrintPreviewCommand(PS_VIEWER_PROG);
+  }
+
+  char *print_modes[3];
+  print_modes[0] = "Send to Printer";
+  print_modes[1] = "Print to File";
+  print_modes[2] = "Preview Only";
+  int features = ((wxThePrintSetupData->GetPrintPreviewCommand() 
+		   && *wxThePrintSetupData->GetPrintPreviewCommand()) 
+		  ? 3 
+		  : 2);
+  wxRadioBox &radio1 = *(new wxRadioBox((wxPrinterDialogBox *)&dialog, (wxFunction)NULL, 
+					"Destination:" , -1, -1, COLUMN_WIDTH, -1, 
+					features, (char **)print_modes, 0, wxVERTICAL));
+#if defined(wx_msw) || defined(wx_mac)
+  radio1.Enable(0, FALSE);
+  if (wxGetPrintPreviewCommand() && *wxGetPrintPreviewCommand())
+    radio1.Enable(2, FALSE);
+#endif
+  radio1.SetSelection((wxGetPrinterMode() == PS_PRINTER) 
+		      ? 0 
+		      : ((wxGetPrinterMode() == PS_FILE)
+			 ? 1
+			 : 2));
+  
+  float wx_printer_translate_x, wx_printer_translate_y;
+  float wx_printer_scale_x, wx_printer_scale_y;
+  wxGetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
+  wxGetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
+
+  sprintf(buf, "%.2f", wx_printer_scale_x);
+  dialog.NewLine();
+  dialog.NewLine();
+
+  wxText &text1 = *(new wxText((wxPrinterDialogBox *)&dialog, (wxFunction) NULL, 
+			       "Horizontal Scaling: ", (char *)buf, -1, -1, COLUMN_WIDTH, -1));
+
+  sprintf(buf, "%.2f", wx_printer_scale_y);
+  wxText &text2 = *(new wxText((wxPrinterDialogBox *)&dialog, (wxFunction) NULL, 
+			       "Vertical Scaling: ", (char *)buf, -1, -1, COLUMN_WIDTH, -1));
+
+  dialog.NewLine();
+
+  sprintf(buf, "%.2f", wx_printer_translate_x);
+  wxText &text3 = *(new wxText((wxPrinterDialogBox *)&dialog, (wxFunction) NULL, 
+			       "Horizontal Translation: ", (char *)buf, -1, -1, COLUMN_WIDTH, -1));
+
+  sprintf (buf, "%.2f", wx_printer_translate_y);
+  wxText &text4 = *(new wxText ((wxPrinterDialogBox *)&dialog, (wxFunction) NULL, 
+				"Vertical Translation: ", (char *)buf, -1, -1, COLUMN_WIDTH, -1));
+
+  dialog.NewLine();
+  dialog.NewLine();
+
+  wxCheckBox *l2 = new wxCheckBox(&dialog, (wxFunction)NULL, "PostScript Level2");
+  if (wxGetLevel2Ok())
+    l2->SetValue(1);
+
+  dialog.NewLine();
+  dialog.NewLine();
+
+  dialog.Fit();
+  dialog.Centre(wxBOTH);
+
+  wxEndBusyCursor();
+
+  dialog.Show(TRUE);
+
+  if (wxPrinterDialogAnswer) {
+    float x, y;
+    StringToFloat(text1.GetValue (), &x);
+    StringToFloat(text2.GetValue (), &y);
+    wxSetPrinterScaling(x, y);
+    StringToFloat(text3.GetValue (), &x);
+    StringToFloat(text4.GetValue (), &y);
+    wxSetPrinterTranslation(x, y);
+
+#ifdef wx_x
+    wxSetPrinterOptions(text0.GetValue());
+    wxSetPrinterCommand(text_prt.GetValue());
+#endif
+
+    wxSetPrinterOrientation(radio0.GetSelection() ? PS_LANDSCAPE : PS_PORTRAIT);
+
+    wxSetPrintPaperName(paper[c->GetSelection()]);
+
+    wxSetLevel2Ok(l2->GetValue());
+
+#ifdef wx_x
+    // C++ wants this
+    switch ( radio1.GetSelection() ) {
+    case 2: wxSetPrinterMode(PS_PREVIEW); break;
+    case 1:    wxSetPrinterMode(PS_FILE);    break;
+    case 0: wxSetPrinterMode(PS_PRINTER); break;
+    }
+#endif
+  }
+
+  return wxPrinterDialogAnswer;
+}
+
+#endif
+
+#ifndef wx_xt
+
+// PostScript printer settings
+// RETAINED FOR BACKWARD COMPATIBILITY
+void wxSetPrinterCommand(char *cmd)
+{
+  wxThePrintSetupData->SetPrinterCommand(cmd);
+}
+
+void wxSetPrintPreviewCommand(char *cmd)
+{
+  wxThePrintSetupData->SetPrintPreviewCommand(cmd);
+}
+
+void wxSetPrinterOptions(char *flags)
+{
+  wxThePrintSetupData->SetPrinterOptions(flags);
+}
+
+void wxSetPrinterFile(char *f)
+{
+  wxThePrintSetupData->SetPrinterFile(f);
+}
+
+void wxSetPrinterOrientation(int orient)
+{
+  wxThePrintSetupData->SetPrinterOrientation(orient);
+}
+
+void wxSetPrinterScaling(float x, float y)
+{
+  wxThePrintSetupData->SetPrinterScaling(x, y);
+}
+
+void wxSetPrinterTranslation(float x, float y)
+{
+  wxThePrintSetupData->SetPrinterTranslation(x, y);
+}
+
+// 1 = Preview, 2 = print to file, 3 = send to printer
+void wxSetPrinterMode(int mode)
+{
+#ifdef wx_x
+  wxThePrintSetupData->SetPrinterMode(mode);
+#endif
+}
+
+void wxSetAFMPath(char *f)
+{
+  wxThePrintSetupData->SetAFMPath(f);
+}
+
+// Get current values
+char *wxGetPrinterCommand(void)
+{
+  return wxThePrintSetupData->GetPrinterCommand();
+}
+
+char *wxGetPrintPreviewCommand(void)
+{
+  return wxThePrintSetupData->GetPrintPreviewCommand();
+}
+
+char *wxGetPrinterOptions(void)
+{
+  return wxThePrintSetupData->GetPrinterOptions();
+}
+
+char *wxGetPrinterFile(void)
+{
+  return wxThePrintSetupData->GetPrinterFile();
+}
+
+int wxGetPrinterOrientation(void)
+{
+  return wxThePrintSetupData->GetPrinterOrientation();
+}
+
+void wxGetPrinterScaling(float *x, float *y)
+{
+  wxThePrintSetupData->GetPrinterScaling(x, y);
+}
+
+void wxGetPrinterTranslation(float *x, float *y)
+{
+  wxThePrintSetupData->GetPrinterTranslation(x, y);
+}
+
+int wxGetPrinterMode(void)
+{
+  return wxThePrintSetupData->GetPrinterMode();
+}
+
+char *wxGetAFMPath(void)
+{
+  return wxThePrintSetupData->GetAFMPath();
+}
+
+/*
+ * Print setup data
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
+
+wxPrintSetupData::wxPrintSetupData(void)
+{
+  printerCommand = NULL;
+  previewCommand = NULL;
+  printerFlags = NULL;
+  printerOrient = PS_PORTRAIT;
+  printerScaleX = 1.0;
+  printerScaleY = 1.0;
+  printerTranslateX = 0.0;
+  printerTranslateY = 0.0;
+  // 1 = Preview, 2 = print to file, 3 = send to printer
+  printerMode = 3;
+  afmPath = NULL;
+  paperName = NULL;
+  printColour = TRUE;
+  printerFile = NULL;
+}
+
+wxPrintSetupData::~wxPrintSetupData(void)
+{
+  if (printerCommand)
+    delete[] printerCommand;
+  if (previewCommand)
+    delete[] previewCommand;
+  if (printerFlags)
+    delete[] printerFlags;
+  if (afmPath)
+    delete[] afmPath;
+  if (paperName)
+    delete[] paperName;
+  if (printerFile)
+    delete[] printerFile;
+}
+
+void wxPrintSetupData::SetPrinterCommand(char *cmd)
+{
+  if (cmd == printerCommand)
+    return;
+
+  if (printerCommand)
+    delete[] printerCommand;
+  if (cmd)
+    printerCommand = copystring(cmd);
+  else
+    printerCommand = NULL;
+}
+
+void wxPrintSetupData::SetPrintPreviewCommand(char *cmd)
+{
+  if (cmd == previewCommand)
+    return;
+    
+  if (previewCommand)
+    delete[] previewCommand;
+  if (cmd)
+    previewCommand = copystring(cmd);
+  else
+    previewCommand = NULL;
+}
+
+void wxPrintSetupData::SetPaperName(char *name)
+{
+  if (name == paperName)
+    return;
+
+  if (paperName)
+    delete[] paperName;
+  if (name)
+    paperName = copystring(name);
+  else
+    paperName = NULL;
+}
+
+void wxPrintSetupData::SetPrinterOptions(char *flags)
+{
+  if (printerFlags == flags)
+    return;
+   
+  if (printerFlags)
+    delete[] printerFlags;
+  if (flags)
+    printerFlags = copystring(flags);
+  else
+    printerFlags = NULL;
+}
+
+void wxPrintSetupData::SetPrinterFile(char *f)
+{
+  if (f == printerFile)
+    return;
+    
+  if (printerFile)
+    delete[] printerFile;
+  if (f)
+    printerFile = copystring(f);
+  else
+    printerFile = NULL;
+}
+
+void wxPrintSetupData::SetPrinterOrientation(int orient)
+{
+  printerOrient = orient;
+}
+
+void wxPrintSetupData::SetPrinterScaling(float x, float y)
+{
+  printerScaleX = x;
+  printerScaleY = y;
+}
+
+void wxPrintSetupData::SetPrinterTranslation(float x, float y)
+{
+  printerTranslateX = x;
+  printerTranslateY = y;
+}
+
+// 1 = Preview, 2 = print to file, 3 = send to printer
+void wxPrintSetupData::SetPrinterMode(int mode)
+{
+  printerMode = mode;
+}
+
+void wxPrintSetupData::SetAFMPath(char *f)
+{
+  if (f == afmPath)
+    return;
+    
+  if (afmPath)
+    delete[] afmPath;
+  if (f)
+    afmPath = copystring(f);
+  else
+    afmPath = NULL;
+}
+
+void wxPrintSetupData::SetColour(Bool col)
+{
+  printColour = col;
+}
+
+// Get current values
+char *wxPrintSetupData::GetPrinterCommand(void)
+{
+  return printerCommand;
+}
+
+char *wxPrintSetupData::GetPrintPreviewCommand(void)
+{
+  return previewCommand;
+}
+
+char *wxPrintSetupData::GetPrinterOptions(void)
+{
+  return printerFlags;
+}
+
+char *wxPrintSetupData::GetPrinterFile(void)
+{
+  return printerFile;
+}
+
+char *wxPrintSetupData::GetPaperName(void)
+{
+  return paperName;
+}
+
+int wxPrintSetupData::GetPrinterOrientation(void)
+{
+  return printerOrient;
+}
+
+void wxPrintSetupData::GetPrinterScaling(float *x, float *y)
+{
+  *x = printerScaleX;
+  *y = printerScaleY;
+}
+
+void wxPrintSetupData::GetPrinterTranslation(float *x, float *y)
+{
+  *x = printerTranslateX;
+  *y = printerTranslateY;
+}
+
+int wxPrintSetupData::GetPrinterMode(void)
+{
+  return printerMode;
+}
+
+char *wxPrintSetupData::GetAFMPath(void)
+{
+  return afmPath;
+}
+
+Bool wxPrintSetupData::GetColour(void)
+{
+  return printColour;
+}
+
+void wxPrintSetupData::operator=(wxPrintSetupData& data)
+{
+  SetPrinterCommand(data.GetPrinterCommand());
+  SetPrintPreviewCommand(data.GetPrintPreviewCommand());
+  SetPrinterOptions(data.GetPrinterOptions());
+  float x, y;
+  data.GetPrinterTranslation(&x, &y);
+  SetPrinterTranslation(x, y);
+
+  data.GetPrinterScaling(&x, &y);
+  SetPrinterScaling(x, y);
+
+  SetPrinterOrientation(data.GetPrinterOrientation());
+  SetPrinterMode(data.GetPrinterMode());
+  SetAFMPath(data.GetAFMPath());
+  SetPaperName(data.GetPaperName());
+  SetColour(data.GetColour());
+}
+
+void wxInitializePrintSetupData(Bool init)
+{
+  if (init)
+  {
+    wxThePrintSetupData = new wxPrintSetupData;
+
+    wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
+    wxThePrintSetupData->SetPrinterOrientation(PS_PORTRAIT);
+#ifdef wx_x
+    wxThePrintSetupData->SetPrinterMode(PS_PREVIEW);
+#else
+    wxThePrintSetupData->SetPrinterMode(PS_FILE);
+#endif
+    wxThePrintSetupData->SetPaperName(DEFAULT_PAPER);
+
+    // Could have a .ini file to read in some defaults
+    // - and/or use environment variables, e.g. WXWIN
+#ifdef VMS
+    wxThePrintSetupData->SetPrinterCommand("print");
+    wxThePrintSetupData->SetPrinterOptions("/nonotify/queue=psqueue");
+    wxThePrintSetupData->SetAFMPath("sys$ps_font_metrics:");
+#endif
+#ifdef wx_msw
+    wxThePrintSetupData->SetPrinterCommand("print");
+    wxThePrintSetupData->SetAFMPath("c:\\windows\\system\\");
+    wxThePrintSetupData->SetPrinterOptions(NULL);
+#endif
+#if !defined(VMS) && !defined(wx_msw)
+    wxThePrintSetupData->SetPrinterCommand("lpr");
+    wxThePrintSetupData->SetPrinterOptions(NULL);
+    wxThePrintSetupData->SetAFMPath(NULL);
+#endif
+  }
+  else
+  {
+    if (wxThePrintSetupData)
+      delete wxThePrintSetupData;
+     wxThePrintSetupData = NULL;
+  }
+}
+
+/*
+ * Paper size database for PostScript
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
+
+wxPrintPaperType::wxPrintPaperType(char *name, int wmm, int hmm, int wp, int hp)
+{
+  widthMM = wmm;
+  heightMM = hmm;
+  widthPixels = wp;
+  heightPixels = hp;
+  pageName = copystring(name);
+}
+
+wxPrintPaperType::~wxPrintPaperType(void)
+{
+  delete[] pageName;
+}
+
+IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
+
+wxPrintPaperDatabase::wxPrintPaperDatabase(void):wxList(wxKEY_STRING)
+{
+  DeleteContents(TRUE);
+}
+
+wxPrintPaperDatabase::~wxPrintPaperDatabase(void)
+{
+}
+
+void wxPrintPaperDatabase::CreateDatabase(void)
+{
+  // Need correct values for page size in pixels.
+  // Each unit is one 'point' = 1/72 of an inch.
+  // NOTE: WE NEED ALSO TO MAKE ADJUSTMENTS WHEN TRANSLATING
+  // in wxPostScriptDC code, so we can start from top left.
+  // So access this database and translate by appropriate number
+  // of points for this paper size. OR IS IT OK ALREADY?
+  // Can't remember where the PostScript origin is by default.
+  // Heck, someone will know how to make it hunky-dory...
+  // JACS 25/5/95
+  
+  AddPaperType("A4 210 x 297 mm", 210, 297,         595, 842);
+  AddPaperType("A3 297 x 420 mm", 297, 420,         842, 1191);
+  AddPaperType("Letter 8 1/2 x 11 in", 216, 279,    612, 791);
+  AddPaperType("Legal 8 1/2 x 14 in", 216, 356,     612, 1009);
+}
+
+void wxPrintPaperDatabase::ClearDatabase(void)
+{
+  Clear();
+}
+
+void wxPrintPaperDatabase::AddPaperType(char *name, int wmm, int hmm, int wp, int hp)
+{
+  Append(name, new wxPrintPaperType(name, wmm, hmm, wp, hp));
+}
+
+wxPrintPaperType *wxPrintPaperDatabase::FindPaperType(char *name)
+{
+  wxNode *node = Find(name);
+  if (node)
+    return (wxPrintPaperType *)node->Data();
+  else
+    return NULL;
+}
+
+#endif /* not wx_xt */
+
+#endif
diff --git a/src/wxmac/src/base/wb_res.cc b/src/wxmac/src/base/wb_res.cc
new file mode 100644
index 0000000..75c675c
--- /dev/null
+++ b/src/wxmac/src/base/wb_res.cc
@@ -0,0 +1,1747 @@
+/*
+ * File:	wb_res.cc
+ * Purpose:	Resource processor
+ * Author:	Julian Smart
+ * Created:	1994
+ * Updated:	
+ * Copyright:	(c) 1994, Julian Smart
+ */
+
+static const char sccsid[] = "%W% %G%";
+
+#ifdef __GNUG__
+#pragma implementation "wx_res.h"
+#endif
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_list.h"
+#include "wx_hash.h"
+#include "wx_gdi.h"
+#include "wx_utils.h"
+#include "wx_types.h"
+#include "wx_menu.h"
+
+#include "wx.h"
+
+#if USE_WX_RESOURCES
+
+#define RESOURCE_PLATFORM_WINDOWS   1
+#define RESOURCE_PLATFORM_X         2
+#define RESOURCE_PLATFORM_MAC       3
+#define RESOURCE_PLATFORM_ANY       4
+
+#include <ctype.h>
+#include <math.h>
+#include "wx_res.h"
+#include "../../utils/prologio/src/read.h"
+
+// Forward (private) declarations
+Bool wxResourceInterpretResources(wxResourceTable& table, PrologDatabase& db);
+wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretControl(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretString(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretBitmap(wxResourceTable& table, PrologExpr *expr);
+wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, PrologExpr *expr);
+// Interpret list expression
+wxFont *wxResourceInterpretFontSpec(wxResourceTable& table, PrologExpr *expr);
+
+Bool wxResourceReadOneResource(FILE *fd, PrologDatabase& db, Bool *eof);
+Bool wxResourceParseIncludeFile(char *f);
+
+wxResourceTable wxDefaultResourceTable;
+
+static char *wxResourceBuffer = NULL;
+static long wxResourceBufferSize = 0;
+static long wxResourceBufferCount = 0;
+
+wxItemResource::wxItemResource(void)
+{
+  itemType = 0;
+  title = NULL;
+  name = NULL;
+  windowStyle = 0;
+  x = y = width = height = 0;
+  value1 = value2 = value3 = 0;
+  value4 = NULL;
+  stringValues = NULL;
+  bitmap = NULL;
+}
+
+wxItemResource::~wxItemResource(void)
+{
+  if (title) delete[] title;
+  if (name) delete[] name;
+  if (value4) delete[] value4;
+  if (stringValues)
+    delete stringValues;
+  if (bitmap)
+    delete bitmap;
+  wxNode *node = children.First();
+  while (node)
+  {
+    wxItemResource *item = (wxItemResource *)node->Data();
+    delete item;
+    delete node;
+    node = children.First();
+  }
+}
+
+void wxItemResource::SetTitle(char *t)
+{
+  if (t)
+    title = copystring(t);
+  else
+    title = NULL;
+}
+
+void wxItemResource::SetName(char *n)
+{
+  if (n)
+    name = copystring(n);
+  else
+    name = NULL;
+}
+
+void wxItemResource::SetValue4(char *v)
+{
+  if (v)
+    value4 = copystring(v);
+  else
+    value4 = NULL;
+}
+
+/*
+ * Resource table
+ */
+ 
+wxResourceTable::wxResourceTable(void):wxHashTable(wxKEY_STRING)
+{
+}
+
+wxResourceTable::~wxResourceTable(void)
+{
+  ClearTable();
+}
+    
+wxItemResource *wxResourceTable::FindResource(char *name)
+{
+  wxItemResource *item = (wxItemResource *)Get(name);
+  return item;
+}
+
+void wxResourceTable::AddResource(wxItemResource *item)
+{
+  char *name = item->GetName();
+  if (!name)
+    name = item->GetTitle();
+  if (!name)
+    name = "no name";
+
+  // Delete existing resource, if any.
+  Delete(name);
+
+  Put(name, item);
+}
+
+Bool wxResourceTable::DeleteResource(char *name)
+{
+  wxItemResource *item = (wxItemResource *)Delete(name);
+  if (item)
+  {
+    delete item;
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxResourceTable::ParseResourceFile(char *filename)
+{
+  PrologDatabase db;
+
+  FILE *fd = fopen(filename, "r");
+  if (!fd)
+    return FALSE;
+  Bool eof = FALSE;
+  while (wxResourceReadOneResource(fd, db, &eof) && !eof)
+  {
+    // Loop
+  }
+  fclose(fd);
+  return wxResourceInterpretResources(*this, db);
+}
+
+Bool wxResourceTable::ParseResourceData(char *data)
+{
+  PrologDatabase db;
+  if (!db.ReadPrologFromString(data))
+  {
+    wxError("Ill-formed resource file syntax.");
+    return FALSE;
+  }
+
+  return wxResourceInterpretResources(*this, db);
+}
+
+Bool wxResourceTable::RegisterResourceBitmapData(char *name, char bits[], int width, int height)
+{
+  // Register pre-loaded bitmap data
+  wxItemResource *item = new wxItemResource;
+  item->SetType(wxRESOURCE_TYPE_XBM_DATA);
+  item->SetName(name);
+  item->SetValue1((long)bits);
+  item->SetValue2((long)width);
+  item->SetValue3((long)height);
+  AddResource(item);
+  return TRUE;
+}
+
+Bool wxResourceTable::RegisterResourceBitmapData(char *name, char **data)
+{
+  // Register pre-loaded bitmap data
+  wxItemResource *item = new wxItemResource;
+  item->SetType(wxRESOURCE_TYPE_XPM_DATA);
+  item->SetName(name);
+  item->SetValue1((long)data);
+  AddResource(item);
+  return TRUE;
+}
+
+Bool wxResourceTable::SaveResource(char *filename)
+{
+  return FALSE;
+}
+
+void wxResourceTable::ClearTable(void)
+{
+  BeginFind();
+  wxNode *node = Next();
+  while (node)
+  {
+    wxNode *next = Next();
+    wxItemResource *item = (wxItemResource *)node->Data();
+    delete item;
+    delete node;
+    node = next;
+  }
+}
+
+/*
+ * Interpret database as a series of resources
+ */
+
+Bool wxResourceInterpretResources(wxResourceTable& table, PrologDatabase& db)
+{
+  wxNode *node = db.First();
+  while (node)
+  {
+    PrologExpr *clause = (PrologExpr *)node->Data();
+    char *functor = clause->Functor();
+
+    wxItemResource *item = NULL;
+    if (strcmp(functor, "dialog") == 0)
+      item = wxResourceInterpretDialog(table, clause);
+    else if (strcmp(functor, "menubar") == 0)
+      item = wxResourceInterpretMenuBar(table, clause);
+    else if (strcmp(functor, "menu") == 0)
+      item = wxResourceInterpretMenu(table, clause);
+    else if (strcmp(functor, "string") == 0)
+      item = wxResourceInterpretString(table, clause);
+    else if (strcmp(functor, "bitmap") == 0)
+      item = wxResourceInterpretBitmap(table, clause);
+    else if (strcmp(functor, "icon") == 0)
+      item = wxResourceInterpretIcon(table, clause);
+
+    if (item)
+      table.AddResource(item);
+    node = node->Next();
+  }
+  return TRUE;
+}
+
+wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, PrologExpr *expr)
+{
+  wxItemResource *dialogItem = new wxItemResource;
+  dialogItem->SetType(wxTYPE_DIALOG_BOX);
+  char *style = NULL;
+  char *title = NULL;
+  char *name = NULL;
+  long windowStyle = wxDEFAULT_DIALOG_STYLE;
+  int x = 0; int y = 0; int width = -1; int height = -1;
+  int isModal = 0;
+  PrologExpr *labelFontExpr = NULL;
+  PrologExpr *buttonFontExpr = NULL;
+  expr->AssignAttributeValue("style", &style);
+  expr->AssignAttributeValue("name", &name);
+  expr->AssignAttributeValue("title", &title);
+  expr->AssignAttributeValue("x", &x);
+  expr->AssignAttributeValue("y", &y);
+  expr->AssignAttributeValue("width", &width);
+  expr->AssignAttributeValue("height", &height);
+  expr->AssignAttributeValue("modal", &isModal);
+  expr->AssignAttributeValue("label_font", &labelFontExpr);
+  expr->AssignAttributeValue("button_font", &buttonFontExpr);
+
+  if (style)
+  {
+    windowStyle = wxParseWindowStyle(style);
+  }
+  dialogItem->SetStyle(windowStyle);
+  dialogItem->SetValue1(isModal);
+  if (name)
+    dialogItem->SetName(name);
+  if (title)
+    dialogItem->SetTitle(title);
+  dialogItem->SetSize(x, y, width, height);
+  if (name)
+    delete[] name;
+  if (title)
+    delete[] title;
+  if (style)
+    delete[] style;
+
+  if (buttonFontExpr)
+    dialogItem->SetValue2((long)wxResourceInterpretFontSpec(table, buttonFontExpr));
+  if (labelFontExpr)
+    dialogItem->SetValue3((long)wxResourceInterpretFontSpec(table, labelFontExpr));
+
+  // Now parse all controls
+  PrologExpr *controlExpr = expr->GetFirst();
+  while (controlExpr)
+  {
+    if (controlExpr->Number() == 3)
+    {
+      char *controlKeyword = controlExpr->Nth(1)->StringValue();
+      if (controlKeyword && (strcmp(controlKeyword, "control") == 0))
+      {
+        // The value part: always a list.
+        PrologExpr *listExpr = controlExpr->Nth(2);
+        if (listExpr->Type() == PrologList)
+        {
+          wxItemResource *controlItem = wxResourceInterpretControl(table, listExpr);
+          if (controlItem)
+          {
+            dialogItem->GetChildren().Append(controlItem);
+          }
+        }
+      }
+    }
+    controlExpr = controlExpr->GetNext();
+  }
+  return dialogItem;
+}
+
+wxItemResource *wxResourceInterpretControl(wxResourceTable& table, PrologExpr *expr)
+{
+  char *controlType = expr->Nth(0)->StringValue();
+  if (!controlType)
+    return NULL;
+  wxItemResource *controlItem = new wxItemResource;
+
+  // First, find the standard features of a control definition:
+  // title (1), style (2), name (3), x (4), y (5), width (6), height (7)
+  PrologExpr *arg1 = expr->Nth(1);
+  PrologExpr *arg2 = expr->Nth(2);
+  PrologExpr *arg3 = expr->Nth(3);
+  PrologExpr *arg4 = expr->Nth(4);
+  PrologExpr *arg5 = expr->Nth(5);
+  PrologExpr *arg6 = expr->Nth(6);
+  PrologExpr *arg7 = expr->Nth(7);
+
+  char *style = NULL;
+  char *title = NULL;
+  char *name = NULL;
+  long windowStyle = 0;
+  int x = 0; int y = 0; int width = -1; int height = -1;
+  if (arg1)
+    title = arg1->StringValue();
+  if (arg2)
+  {
+    style = arg2->StringValue();
+    if (style)
+      windowStyle = wxParseWindowStyle(style);
+  }
+  if (arg3)
+    name = arg3->StringValue();
+  if (arg4)
+    x = (int)arg4->IntegerValue();
+  if (arg5)
+    y = (int)arg5->IntegerValue();
+  if (arg6)
+    width = (int)arg6->IntegerValue();
+  if (arg7)
+    height = (int)arg7->IntegerValue();
+  controlItem->SetStyle(windowStyle);
+  controlItem->SetName(name);
+  controlItem->SetTitle(title);
+  controlItem->SetSize(x, y, width, height);
+
+  
+  if (strcmp(controlType, "wxButton") == 0)
+  {
+    controlItem->SetType(wxTYPE_BUTTON);
+    // Check for bitmap resource name
+    if (expr->Nth(8) && ((expr->Nth(8)->Type() == PrologString) || (expr->Nth(8)->Type() == PrologWord)))
+      controlItem->SetValue4(expr->Nth(8)->StringValue());
+  }
+  else if (strcmp(controlType, "wxCheckBox") == 0)
+  {
+    controlItem->SetType(wxTYPE_CHECK_BOX);
+    // Check for default value
+    if (expr->Nth(8) && (expr->Nth(8)->Type() == PrologInteger))
+      controlItem->SetValue1(expr->Nth(8)->IntegerValue());
+  }
+  else if (strcmp(controlType, "wxText") == 0)
+  {
+    controlItem->SetType(wxTYPE_TEXT);
+    // Check for default value
+    if (expr->Nth(8) && ((expr->Nth(8)->Type() == PrologString) || (expr->Nth(8)->Type() == PrologWord)))
+      controlItem->SetValue4(expr->Nth(8)->StringValue());
+  }
+  else if (strcmp(controlType, "wxMultiText") == 0)
+  {
+    controlItem->SetType(wxTYPE_MULTI_TEXT);
+    // Check for default value
+    if (expr->Nth(8) && ((expr->Nth(8)->Type() == PrologString) || (expr->Nth(8)->Type() == PrologWord)))
+      controlItem->SetValue4(expr->Nth(8)->StringValue());
+  }
+  else if (strcmp(controlType, "wxMessage") == 0)
+  {
+    controlItem->SetType(wxTYPE_MESSAGE);
+    // Check for bitmap resource name
+    if (expr->Nth(8) && ((expr->Nth(8)->Type() == PrologString) || (expr->Nth(8)->Type() == PrologWord)))
+      controlItem->SetValue4(expr->Nth(8)->StringValue());
+  }
+  else if (strcmp(controlType, "wxGroupBox") == 0)
+  {
+    controlItem->SetType(wxTYPE_GROUP_BOX);
+  }
+  else if (strcmp(controlType, "wxGauge") == 0)
+  {
+    controlItem->SetType(wxTYPE_GAUGE);
+    // Check for default value
+    if (expr->Nth(8) && (expr->Nth(8)->Type() == PrologInteger))
+      controlItem->SetValue1(expr->Nth(8)->IntegerValue());
+    // Check for range
+    if (expr->Nth(9) && (expr->Nth(9)->Type() == PrologInteger))
+      controlItem->SetValue2(expr->Nth(9)->IntegerValue());
+  }
+  else if (strcmp(controlType, "wxSlider") == 0)
+  {
+    controlItem->SetType(wxTYPE_SLIDER);
+    // Check for default value
+    if (expr->Nth(8) && (expr->Nth(8)->Type() == PrologInteger))
+      controlItem->SetValue1(expr->Nth(8)->IntegerValue());
+    // Check for min
+    if (expr->Nth(9) && (expr->Nth(9)->Type() == PrologInteger))
+      controlItem->SetValue2(expr->Nth(9)->IntegerValue());
+    // Check for max
+    if (expr->Nth(10) && (expr->Nth(10)->Type() == PrologInteger))
+      controlItem->SetValue3(expr->Nth(10)->IntegerValue());
+  }
+  else if (strcmp(controlType, "wxListBox") == 0)
+  {
+    controlItem->SetType(wxTYPE_LIST_BOX);
+    PrologExpr *valueList = NULL;
+
+    if ((valueList = expr->Nth(8)) && (valueList->Type() == PrologList))
+    {
+      wxStringList *stringList = new wxStringList;
+      PrologExpr *stringExpr = valueList->GetFirst();
+      while (stringExpr)
+      {
+        stringList->Add(stringExpr->StringValue());
+        stringExpr = stringExpr->GetNext();
+      }
+      controlItem->SetStringValues(stringList);
+    }
+    // Check for wxSINGLE/wxMULTIPLE
+    PrologExpr *mult = NULL;
+    controlItem->SetValue1(wxSINGLE);
+    if ((mult = expr->Nth(9)) && ((mult->Type() == PrologString)||(mult->Type() == PrologWord)))
+    {
+      char *m = expr->StringValue();
+      if (strcmp(m, "wxMULTIPLE") == 0)
+        controlItem->SetValue1(wxMULTIPLE);
+      else if (strcmp(m, "wxEXTENDED") == 0)
+        controlItem->SetValue1(wxEXTENDED);
+    }
+  }
+  else if (strcmp(controlType, "wxChoice") == 0)
+  {
+    controlItem->SetType(wxTYPE_CHOICE);
+    PrologExpr *valueList = NULL;
+    // Check for default value list
+    if ((valueList = expr->Nth(8)) && (valueList->Type() == PrologList))
+    {
+      wxStringList *stringList = new wxStringList;
+      PrologExpr *stringExpr = valueList->GetFirst();
+      while (stringExpr)
+      {
+        stringList->Add(stringExpr->StringValue());
+        stringExpr = stringExpr->GetNext();
+      }
+      controlItem->SetStringValues(stringList);
+    }
+  }
+  else if (strcmp(controlType, "wxRadioBox") == 0)
+  {
+    controlItem->SetType(wxTYPE_RADIO_BOX);
+    PrologExpr *valueList = NULL;
+    // Check for default value list
+    if ((valueList = expr->Nth(8)) && (valueList->Type() == PrologList))
+    {
+      wxStringList *stringList = new wxStringList;
+      PrologExpr *stringExpr = valueList->GetFirst();
+      while (stringExpr)
+      {
+        stringList->Add(stringExpr->StringValue());
+        stringExpr = stringExpr->GetNext();
+      }
+      controlItem->SetStringValues(stringList);
+    }
+  }
+  else
+  {
+    delete controlItem;
+    return NULL;
+  }
+  return controlItem;
+}
+
+// Forward declaration 
+wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, PrologExpr *expr);
+
+/*
+ * Interpet a menu item
+ */
+
+wxItemResource *wxResourceInterpretMenuItem(wxResourceTable& table, PrologExpr *expr)
+{
+  wxItemResource *item = new wxItemResource;
+  
+  PrologExpr *labelExpr = expr->Nth(0);
+  PrologExpr *idExpr = expr->Nth(1);
+  PrologExpr *helpExpr = expr->Nth(2);
+  // Further keywords/attributes to follow sometime...
+  if (expr->Number() == 0)
+  {
+    item->SetType(wxRESOURCE_TYPE_SEPARATOR);
+    return item;
+  }
+  else
+  {
+    item->SetType(wxTYPE_MENU); // Well, menu item, but doesn't matter.
+    if (labelExpr)
+    {
+      item->SetTitle(labelExpr->StringValue());
+    }
+    if (idExpr)
+    {
+      int id = 0;
+      // If a string or word, must look up in identifier table.
+      if ((idExpr->Type() == PrologString) || (idExpr->Type() == PrologWord))
+      {
+        id = wxResourceGetIdentifier(idExpr->StringValue());
+        if (id == 0)
+        {
+          char buf[300];
+	  sprintf(buf, "Could not resolve menu id '%s'. Use (non-zero) integer instead\n or provide #define (see manual for caveats)",
+                 idExpr->StringValue());
+          wxError(buf);
+        }
+      }
+      else if (idExpr->Type() == PrologInteger)
+        id = (int)idExpr->IntegerValue();
+      item->SetValue1(id);
+    }
+    if (helpExpr)
+    {
+      item->SetValue4(helpExpr->StringValue());
+    }
+
+    // Find the first expression that's a list, for submenu
+    PrologExpr *subMenuExpr = expr->GetFirst();
+    while (subMenuExpr && (subMenuExpr->Type() != PrologList))
+      subMenuExpr = subMenuExpr->GetNext();
+      
+    while (subMenuExpr)
+    {
+      wxItemResource *child = wxResourceInterpretMenuItem(table, subMenuExpr);
+      item->GetChildren().Append(child);
+      subMenuExpr = subMenuExpr->GetNext();
+    }
+  }
+  return item;
+}
+
+/*
+ * Interpret a nested list as a menu
+ */
+/*
+wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, PrologExpr *expr)
+{
+  wxItemResource *menu = new wxItemResource;
+  menu->SetType(wxTYPE_MENU);
+  PrologExpr *element = expr->GetFirst();
+  while (element)
+  {
+    wxItemResource *item = wxResourceInterpretMenuItem(table, element);
+    if (item)
+      menu->GetChildren().Append(item);
+    element = element->GetNext();
+  }
+  return menu;
+}
+*/
+
+wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, PrologExpr *expr)
+{
+  PrologExpr *listExpr = NULL;
+  expr->AssignAttributeValue("menu", &listExpr);
+  if (!listExpr)
+    return NULL;
+  
+  wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
+
+  if (!menuResource)
+    return NULL;
+    
+  char *name = NULL;
+  expr->AssignAttributeValue("name", &name);
+  if (name)
+  {
+    menuResource->SetName(name);
+    delete[] name;
+  }
+  
+  return menuResource;
+}
+
+wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, PrologExpr *expr)
+{
+  PrologExpr *listExpr = NULL;
+  expr->AssignAttributeValue("menu", &listExpr);
+  if (!listExpr)
+    return NULL;
+
+  wxItemResource *resource = new wxItemResource;
+  resource->SetType(wxTYPE_MENU);
+  
+  PrologExpr *element = listExpr->GetFirst();
+  while (element)
+  {
+    wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
+    resource->GetChildren().Append(menuResource);
+    element = element->GetNext();
+  }
+
+  char *name = NULL;
+  expr->AssignAttributeValue("name", &name);
+  if (name)
+  {
+    resource->SetName(name);
+    delete[] name;
+  }
+  
+  return resource;
+}
+
+wxItemResource *wxResourceInterpretString(wxResourceTable& table, PrologExpr *expr)
+{
+  return NULL;
+}
+
+wxItemResource *wxResourceInterpretBitmap(wxResourceTable& table, PrologExpr *expr)
+{
+  wxItemResource *bitmapItem = new wxItemResource;
+  bitmapItem->SetType(wxTYPE_BITMAP);
+  char *name = NULL;
+  expr->AssignAttributeValue("name", &name);
+  if (name)
+  {
+    bitmapItem->SetName(name);
+    delete[] name;
+  }
+  // Now parse all bitmap specifications
+  PrologExpr *bitmapExpr = expr->GetFirst();
+  while (bitmapExpr)
+  {
+    if (bitmapExpr->Number() == 3)
+    {
+      char *bitmapKeyword = bitmapExpr->Nth(1)->StringValue();
+      if (bitmapKeyword && ((strcmp(bitmapKeyword, "bitmap") == 0)||(strcmp(bitmapKeyword, "icon") == 0)))
+      {
+        // The value part: always a list.
+        PrologExpr *listExpr = bitmapExpr->Nth(2);
+        if (listExpr->Type() == PrologList)
+        {
+          wxItemResource *bitmapSpec = new wxItemResource;
+          bitmapSpec->SetType(wxTYPE_BITMAP);
+
+          // List is of form: [filename, bitmaptype, platform, colours, xresolution, yresolution]
+          // where everything after 'filename' is optional.
+          PrologExpr *nameExpr = listExpr->Nth(0);
+          PrologExpr *typeExpr = listExpr->Nth(1);
+          PrologExpr *platformExpr = listExpr->Nth(2);
+          PrologExpr *coloursExpr = listExpr->Nth(3);
+          PrologExpr *xresExpr = listExpr->Nth(4);
+          PrologExpr *yresExpr = listExpr->Nth(5);
+          if (nameExpr && nameExpr->StringValue())
+            bitmapSpec->SetName(nameExpr->StringValue());
+          if (typeExpr && typeExpr->StringValue())
+            bitmapSpec->SetValue1(wxParseWindowStyle(typeExpr->StringValue()));
+          else
+            bitmapSpec->SetValue1(0);
+            
+          if (platformExpr && platformExpr->StringValue())
+          {
+            char *plat = platformExpr->StringValue();
+            if ((strcmp(plat, "windows") == 0) || (strcmp(plat, "WINDOWS") == 0))
+              bitmapSpec->SetValue2(RESOURCE_PLATFORM_WINDOWS);
+            else if ((strcmp(plat, "x") == 0) || (strcmp(plat, "X") == 0))
+              bitmapSpec->SetValue2(RESOURCE_PLATFORM_X);
+            else if ((strcmp(plat, "mac") == 0) || (strcmp(plat, "MAC") == 0))
+              bitmapSpec->SetValue2(RESOURCE_PLATFORM_MAC);
+            else
+              bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
+          }
+          else
+            bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
+
+          if (coloursExpr)
+            bitmapSpec->SetValue3(coloursExpr->IntegerValue());
+          int xres = 0;
+          int yres = 0;
+          if (xresExpr)
+            xres = (int)xresExpr->IntegerValue();
+          if (yresExpr)
+            yres = (int)yresExpr->IntegerValue();
+          bitmapSpec->SetSize(0, 0, xres, yres);
+            
+          bitmapItem->GetChildren().Append(bitmapSpec);
+        }
+      }
+    }
+    bitmapExpr = bitmapExpr->GetNext();
+  }
+  
+  return bitmapItem;
+}
+
+wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, PrologExpr *expr)
+{
+  wxItemResource *item = wxResourceInterpretBitmap(table, expr);
+  if (item)
+  {
+    item->SetType(wxTYPE_ICON);
+    return item;
+  }
+  else
+    return NULL;
+}
+
+// Interpret list expression as a font
+wxFont *wxResourceInterpretFontSpec(wxResourceTable& table, PrologExpr *expr)
+{
+  if (expr->Type() != PrologList)
+    return NULL;
+
+  int point = 10;
+  int family = wxSWISS;
+  int style = wxNORMAL;
+  int weight = wxNORMAL;
+  int underline = 0;
+  
+  PrologExpr *pointExpr = expr->Nth(0);
+  PrologExpr *familyExpr = expr->Nth(1);
+  PrologExpr *styleExpr = expr->Nth(2);
+  PrologExpr *weightExpr = expr->Nth(3);
+  PrologExpr *underlineExpr = expr->Nth(4);
+  if (pointExpr)
+    point = (int)pointExpr->IntegerValue();
+  if (familyExpr)
+    family = (int)wxParseWindowStyle(familyExpr->StringValue());
+  if (styleExpr)
+    style = (int)wxParseWindowStyle(styleExpr->StringValue());
+  if (weightExpr)
+    weight = (int)wxParseWindowStyle(weightExpr->StringValue());
+  if (underlineExpr)
+    underline = (int)underlineExpr->IntegerValue();
+  wxFont *font = wxTheFontList->FindOrCreateFont(point, family, style, weight, underline);
+  return font;
+}
+
+/*
+ * (Re)allocate buffer for reading in from resource file
+ */
+
+Bool wxReallocateResourceBuffer(void)
+{
+  if (!wxResourceBuffer)
+  {
+    wxResourceBufferSize = 1000;
+    wxResourceBuffer = new char[wxResourceBufferSize];
+    return TRUE;
+  }
+  if (wxResourceBuffer)
+  {
+    long newSize = wxResourceBufferSize + 1000;
+    char *tmp = new char[(int)newSize];
+    strncpy(tmp, wxResourceBuffer, (int)wxResourceBufferCount);
+    delete[] wxResourceBuffer;
+    wxResourceBuffer = tmp;
+    wxResourceBufferSize = newSize;
+  }
+  return TRUE;
+}
+
+static Bool wxEatWhiteSpace(FILE *fd)
+{
+  int ch = getc(fd);
+  if ((ch != ' ') && (ch != '/') && (ch != ' ') && (ch != 10) && (ch != 13) && (ch != 9))
+  {
+    ungetc(ch, fd);
+    return TRUE;
+  }
+
+  // Eat whitespace
+  while (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
+    ch = getc(fd);
+  // Check for comment
+  if (ch == '/')
+  {
+    ch = getc(fd);
+    if (ch == '*')
+    {
+      Bool finished = FALSE;
+      while (!finished)
+      {
+        ch = getc(fd);
+        if (ch == EOF)
+          return FALSE;
+        if (ch == '*')
+        {
+          int newCh = getc(fd);
+          if (newCh == '/')
+            finished = TRUE;
+          else
+          {
+            ungetc(newCh, fd);
+          }
+        }
+      }
+    }
+    else // False alarm
+      return FALSE;
+  }
+  else
+    ungetc(ch, fd);
+  return wxEatWhiteSpace(fd);
+}
+
+Bool wxGetResourceToken(FILE *fd)
+{
+  if (!wxResourceBuffer)
+    wxReallocateResourceBuffer();
+  wxResourceBuffer[0] = 0;
+  wxEatWhiteSpace(fd);
+
+  int ch = getc(fd);
+  if (ch == '"')
+  {
+    // Get string
+    wxResourceBufferCount = 0;
+    ch = getc(fd);
+    while (ch != '"')
+    {
+      int actualCh = ch;
+      if (ch == EOF)
+      {
+        wxResourceBuffer[wxResourceBufferCount] = 0;
+        return FALSE;
+      }
+      // Escaped characters
+      else if (ch == '\\')
+      {
+        int newCh = getc(fd);
+        if (newCh == '"')
+          actualCh = '"';
+        else if (newCh == 10)
+          actualCh = 10;
+        else
+        {
+          ungetc(newCh, fd);
+        }
+      }
+
+      if (wxResourceBufferCount >= wxResourceBufferSize)
+        wxReallocateResourceBuffer();
+      wxResourceBuffer[wxResourceBufferCount] = actualCh;
+      wxResourceBufferCount ++;
+      ch = getc(fd);
+    }
+    wxResourceBuffer[wxResourceBufferCount] = 0;
+  }
+  else
+  {
+    wxResourceBufferCount = 0;
+    // Any other token
+    while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
+    {
+      if (wxResourceBufferCount >= wxResourceBufferSize)
+        wxReallocateResourceBuffer();
+      wxResourceBuffer[wxResourceBufferCount] = ch;
+      wxResourceBufferCount ++;
+      
+      ch = getc(fd);
+    }
+    wxResourceBuffer[wxResourceBufferCount] = 0;
+    if (ch == EOF)
+      return FALSE;
+  }
+  return TRUE;
+}
+
+/*
+ * Files are in form:
+  static char *name = "....";
+  with possible comments.
+ */
+ 
+Bool wxResourceReadOneResource(FILE *fd, PrologDatabase& db, Bool *eof)
+{
+  // static or #define
+  if (!wxGetResourceToken(fd))
+  {
+    *eof = TRUE;
+    return FALSE;
+  }
+
+  if (strcmp(wxResourceBuffer, "#define") == 0)
+  {
+    wxGetResourceToken(fd);
+    char *name = copystring(wxResourceBuffer);
+    wxGetResourceToken(fd);
+    char *value = copystring(wxResourceBuffer);
+    if (isalpha(value[0]))
+    {
+      int val = (int)atol(value);
+      wxResourceAddIdentifier(name, val);
+    }
+    else
+    {
+      char buf[300];
+      sprintf(buf, "#define %s must be an integer.", name);
+      wxError(buf);
+      delete[] name;
+      delete[] value;
+      return FALSE;
+    }
+    delete[] name;
+    delete[] value;
+ 
+    return TRUE;
+  }
+  else if (strcmp(wxResourceBuffer, "#include") == 0)
+  {
+    wxGetResourceToken(fd);
+    char *name = copystring(wxResourceBuffer);
+    char *actualName = name;
+    if (name[0] == '"')
+      actualName = name + 1;
+    int len = strlen(name);
+    if ((len > 0) && (name[len-1] == '"'))
+      name[len-1] = 0;
+    if (!wxResourceParseIncludeFile(actualName))
+    {
+      char buf[400];
+      sprintf(buf, "Could not find resource include file %s.", actualName);
+      wxError(buf);
+    }
+    delete[] name;
+    return TRUE;
+  }
+  else if (strcmp(wxResourceBuffer, "static") != 0)
+  {
+    char buf[300];
+    strcpy(buf, "Found ");
+    strncat(buf, wxResourceBuffer, 30);
+    strcat(buf, ", expected static, #include or #define\nwhilst parsing resource.");
+    wxError(buf);
+    return FALSE;
+  }
+
+  // char
+  if (!wxGetResourceToken(fd))
+  {
+    wxError("Unexpected end of file whilst parsing resource.");
+    *eof = TRUE;
+    return FALSE;
+  }
+
+  if (strcmp(wxResourceBuffer, "char") != 0)
+  {
+    wxError("Expected 'char' whilst parsing resource.");
+    return FALSE;
+  }
+    
+  // *name
+  if (!wxGetResourceToken(fd))
+  {
+    wxError("Unexpected end of file whilst parsing resource.");
+    *eof = TRUE;
+    return FALSE;
+  }
+
+  if (wxResourceBuffer[0] != '*')
+  {
+    wxError("Expected '*' whilst parsing resource.");
+    return FALSE;
+  }
+  char nameBuf[100];
+  strncpy(nameBuf, wxResourceBuffer+1, 99);
+    
+  // =
+  if (!wxGetResourceToken(fd))
+  {
+    wxError("Unexpected end of file whilst parsing resource.");
+    *eof = TRUE;
+    return FALSE;
+  }
+
+  if (strcmp(wxResourceBuffer, "=") != 0)
+  {
+    wxError("Expected '=' whilst parsing resource.");
+    return FALSE;
+  }
+
+  // String
+  if (!wxGetResourceToken(fd))
+  {
+    wxError("Unexpected end of file whilst parsing resource.");
+    *eof = TRUE;
+    return FALSE;
+  }
+  else
+  {
+    if (!db.ReadPrologFromString(wxResourceBuffer))
+    {
+      char buf[300];
+      sprintf(buf, "%s: ill-formed resource file syntax.", nameBuf);
+      wxError(buf);
+      return FALSE;
+    }
+  }
+  // Semicolon
+  if (!wxGetResourceToken(fd))
+  {
+    *eof = TRUE;
+  }
+  return TRUE;
+}
+
+/*
+ * Parses string window style into integer window style
+ */
+ 
+/*
+ * Style flag parsing, e.g.
+ * "wxSYSTEM_MENU | wxBORDER" -> integer
+ */
+
+char *wxResourceParseWord(char *s, int *i)
+{
+  if (!s)
+    return NULL;
+
+  static char buf[150];
+  int len = strlen(s);
+  int j = 0;
+  int ii = *i;
+  while ((ii < len) && (isalpha(s[ii]) || (s[ii] == '_')))
+  {
+    buf[j] = s[ii];
+    j ++;
+    ii ++;
+  }
+  buf[j] = 0;
+
+  // Eat whitespace and conjunction characters
+  while ((ii < len) &&
+         ((s[ii] == ' ') || (s[ii] == '|') || (s[ii] == ',')))
+  {
+    ii ++;
+  }
+  *i = ii;
+  if (j == 0)
+    return NULL;
+  else
+    return buf;
+}
+
+struct wxResourceBitListStruct
+{
+  char *word;
+  long bits;
+};
+
+static wxResourceBitListStruct wxResourceBitListTable[] =
+{
+  { "wxSINGLE", wxSINGLE },
+  { "wxMULTIPLE", wxMULTIPLE },
+  { "wxEXTENDED", wxEXTENDED },
+  { "wxNEEDED_SB", wxNEEDED_SB },
+  { "wxALWAYS_SB", wxALWAYS_SB },
+  { "wxVSCROLL", wxVSCROLL },
+  { "wxHSCROLL", wxHSCROLL },
+  { "wxCAPTION", wxCAPTION },
+  { "wxABSOLUTE_POSITIONING", wxABSOLUTE_POSITIONING },
+  { "wxSTAY_ON_TOP", wxSTAY_ON_TOP},
+  { "wxICONIZE", wxICONIZE},
+  { "wxMINIMIZE", wxICONIZE},
+  { "wxMAXIMIZE", wxMAXIMIZE},
+  { "wxSDI", wxSDI},
+  { "wxMDI_PARENT", wxMDI_PARENT},
+  { "wxMDI_CHILD", wxMDI_CHILD},
+  { "wxTHICK_FRAME", wxTHICK_FRAME},
+  { "wxRESIZE_BORDER", wxRESIZE_BORDER},
+  { "wxSYSTEM_MENU", wxSYSTEM_MENU},
+  { "wxMINIMIZE_BOX", wxMINIMIZE_BOX},
+  { "wxMAXIMIZE_BOX", wxMAXIMIZE_BOX},
+  { "wxRESIZE_BOX", wxRESIZE_BOX},
+  { "wxDEFAULT_FRAME", wxDEFAULT_FRAME},
+  { "wxDEFAULT_DIALOG_STYLE", wxDEFAULT_DIALOG_STYLE},
+  { "wxBORDER", wxBORDER},
+  { "wxRETAINED", wxRETAINED},
+  { "wxEDITABLE", wxEDITABLE},
+  { "wxREADONLY", wxREADONLY},
+  { "wxNATIVE_IMPL", wxNATIVE_IMPL},
+  { "wxEXTENDED_IMPL", wxEXTENDED_IMPL},
+  { "wxBACKINGSTORE", wxBACKINGSTORE},
+  { "wxFLAT", wxFLAT},
+  { "wxMOTIF_RESIZE", wxMOTIF_RESIZE},
+  { "wxFIXED_LENGTH", wxFIXED_LENGTH},
+
+  // Enhanced dialog (not yet implemented in wxCLIPS)
+  { "wxBOTTOM_COMMANDS", wxBOTTOM_COMMANDS},
+  { "wxRIGHT_COMMANDS", wxRIGHT_COMMANDS},
+  { "wxSTATUS_FOOTER", wxSTATUS_FOOTER},
+  { "wxNO_STATUS_FOOTER", wxNO_STATUS_FOOTER},
+  { "wxNO_CANCEL_BUTTON", wxNO_CANCEL_BUTTON},
+  { "wxCANCEL_BUTTON_FIRST", wxCANCEL_BUTTON_FIRST},
+  { "wxCANCEL_BUTTON_SECOND", wxCANCEL_BUTTON_SECOND},
+  { "wxCANCEL_BUTTON_LAST", wxCANCEL_BUTTON_LAST},
+  { "wxENH_DEFAULT", wxENH_DEFAULT},
+  { "wxCOLOURED", wxCOLOURED},
+  { "wxTINY_CAPTION_HORIZ", wxTINY_CAPTION_HORIZ},
+  { "wxTINY_CAPTION_VERT", wxTINY_CAPTION_VERT},
+
+  // Text font families
+  { "wxDEFAULT", wxDEFAULT},
+  { "wxDECORATIVE", wxDECORATIVE},
+  { "wxROMAN", wxROMAN},
+  { "wxSCRIPT", wxSCRIPT},
+  { "wxSWISS", wxSWISS},
+  { "wxMODERN", wxMODERN},
+  { "wxTELETYPE", wxTELETYPE},
+  { "wxVARIABLE", wxVARIABLE},
+  { "wxFIXED", wxFIXED},
+  { "wxNORMAL", wxNORMAL},
+  { "wxLIGHT", wxLIGHT},
+  { "wxBOLD", wxBOLD},
+  { "wxITALIC", wxITALIC},
+  { "wxSLANT", wxSLANT},
+  { "wxSOLID", wxSOLID},
+  { "wxDOT", wxDOT},
+  { "wxLONG_DASH", wxLONG_DASH},
+  { "wxSHORT_DASH", wxSHORT_DASH},
+  { "wxDOT_DASH", wxDOT_DASH},
+  { "wxUSER_DASH", wxUSER_DASH},
+  { "wxTRANSPARENT", wxTRANSPARENT},
+  { "wxSTIPPLE", wxSTIPPLE},
+  { "wxBDIAGONAL_HATCH", wxBDIAGONAL_HATCH},
+  { "wxCROSSDIAG_HATCH", wxCROSSDIAG_HATCH},
+  { "wxFDIAGONAL_HATCH", wxFDIAGONAL_HATCH},
+  { "wxCROSS_HATCH", wxCROSS_HATCH},
+  { "wxHORIZONTAL_HATCH", wxHORIZONTAL_HATCH},
+  { "wxVERTICAL_HATCH", wxVERTICAL_HATCH},
+  { "wxJOIN_BEVEL", wxJOIN_BEVEL},
+  { "wxJOIN_MITER", wxJOIN_MITER},
+  { "wxJOIN_ROUND", wxJOIN_ROUND},
+  { "wxCAP_ROUND", wxCAP_ROUND},
+  { "wxCAP_PROJECTING", wxCAP_PROJECTING},
+  { "wxCAP_BUTT", wxCAP_BUTT},
+
+  // Logical ops
+  { "wxCLEAR", wxCLEAR},
+  { "wxXOR", wxXOR},
+  { "wxINVERT", wxINVERT},
+  { "wxOR_REVERSE", wxOR_REVERSE},
+  { "wxAND_REVERSE", wxAND_REVERSE},
+  { "wxCOPY", wxCOPY},
+  { "wxAND", wxAND},
+  { "wxAND_INVERT", wxAND_INVERT},
+  { "wxNO_OP", wxNO_OP},
+  { "wxNOR", wxNOR},
+  { "wxEQUIV", wxEQUIV},
+  { "wxSRC_INVERT", wxSRC_INVERT},
+  { "wxOR_INVERT", wxOR_INVERT},
+  { "wxNAND", wxNAND},
+  { "wxOR", wxOR},
+  { "wxSET", wxSET},
+
+  { "wxFLOOD_SURFACE", wxFLOOD_SURFACE},
+  { "wxFLOOD_BORDER", wxFLOOD_BORDER},
+  { "wxODDEVEN_RULE", wxODDEVEN_RULE},
+  { "wxWINDING_RULE", wxWINDING_RULE},
+  { "wxHORIZONTAL", wxHORIZONTAL},
+  { "wxVERTICAL", wxVERTICAL},
+  { "wxBOTH", wxBOTH},
+  { "wxCENTER_FRAME", wxCENTER_FRAME},
+  { "wxOK", wxOK},
+  { "wxYES_NO", wxYES_NO},
+  { "wxCANCEL", wxCANCEL},
+  { "wxYES", wxYES},
+  { "wxNO", wxNO},
+  { "wxICON_EXCLAMATION", wxICON_EXCLAMATION},
+  { "wxICON_HAND", wxICON_HAND},
+  { "wxICON_QUESTION", wxICON_QUESTION},
+  { "wxICON_INFORMATION", wxICON_INFORMATION},
+  { "wxICON_STOP", wxICON_STOP},
+  { "wxICON_ASTERISK", wxICON_ASTERISK},
+  { "wxICON_MASK", wxICON_MASK},
+  { "wxCENTRE", wxCENTRE},
+  { "wxCENTER", wxCENTRE},
+  { "wxUSER_COLOURS", wxUSER_COLOURS},
+  { "wxVERTICAL_LABEL", wxVERTICAL_LABEL},
+
+  // Bitmap types (not strictly styles)
+  { "wxBITMAP_TYPE_XPM", wxBITMAP_TYPE_XPM},
+  { "wxBITMAP_TYPE_XBM", wxBITMAP_TYPE_XBM},
+  { "wxBITMAP_TYPE_BMP", wxBITMAP_TYPE_BMP},
+  { "wxBITMAP_TYPE_RESOURCE", wxBITMAP_TYPE_BMP_RESOURCE},
+  { "wxBITMAP_TYPE_BMP_RESOURCE", wxBITMAP_TYPE_BMP_RESOURCE},
+  { "wxBITMAP_TYPE_GIF", wxBITMAP_TYPE_GIF},
+  { "wxBITMAP_TYPE_TIF", wxBITMAP_TYPE_TIF},
+  { "wxBITMAP_TYPE_ICO", wxBITMAP_TYPE_ICO},
+  { "wxBITMAP_TYPE_ICO_RESOURCE", wxBITMAP_TYPE_ICO_RESOURCE},
+  { "wxBITMAP_TYPE_CUR", wxBITMAP_TYPE_CUR},
+  { "wxBITMAP_TYPE_CUR_RESOURCE", wxBITMAP_TYPE_CUR_RESOURCE},
+  { "wxBITMAP_TYPE_XBM_DATA", wxBITMAP_TYPE_XBM_DATA},
+  { "wxBITMAP_TYPE_XPM_DATA", wxBITMAP_TYPE_XPM_DATA},
+  { "wxBITMAP_TYPE_ANY", wxBITMAP_TYPE_ANY}
+};
+
+static int wxResourceBitListCount = (sizeof(wxResourceBitListTable)/sizeof(wxResourceBitListStruct));
+
+long wxParseWindowStyle(char *bitListString)
+{
+  int i = 0;
+  char *word;
+  long bitList = 0;
+  while (word = wxResourceParseWord(bitListString, &i))
+  {
+    Bool found = FALSE;
+    for (int j = 0; j < wxResourceBitListCount; j++)
+      if (strcmp(wxResourceBitListTable[j].word, word) == 0)
+      {
+        bitList |= wxResourceBitListTable[j].bits;
+        found = TRUE;
+        break;
+      }
+    if (!found)
+    {
+      char buf[200];
+      sprintf(buf, "Unrecognized style %s whilst parsing resource.", word);
+      wxError(buf);
+      return 0;
+    }
+  }
+  return bitList;
+}
+
+/*
+ * Load a bitmap from a wxWindows resource, choosing an optimum
+ * depth and appropriate type.
+ */
+ 
+wxBitmap *wxResourceCreateBitmap(char *resource)
+{
+  wxItemResource *item = wxDefaultResourceTable.FindResource(resource);
+  if (item)
+  {
+    if (item->GetType() != wxTYPE_BITMAP)
+    {
+      char buf[300];
+      sprintf(buf, "%s not a bitmap resource specification.", resource);
+      wxError(buf);
+      return NULL;
+    }
+    int thisDepth = wxDisplayDepth();
+    long thisNoColours = (long)pow(2.0, (double)thisDepth);
+
+    wxItemResource *optResource = NULL;
+    
+    // Try to find optimum bitmap for this platform/colour depth
+    wxNode *node = item->GetChildren().First();
+    while (node)
+    {
+      wxItemResource *child = (wxItemResource *)node->Data();
+      int platform = (int)child->GetValue2();
+      int noColours = (int)child->GetValue3();
+/*
+      char *name = child->GetName();
+      int bitmapType = (int)child->GetValue1();
+      int xRes = child->GetWidth();
+      int yRes = child->GetHeight();
+*/
+
+      switch (platform)
+      {
+        case RESOURCE_PLATFORM_ANY:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours.
+            // If noColours is zero (unspecified), then assume this
+            // is the right one.
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#ifdef wx_msw
+        case RESOURCE_PLATFORM_WINDOWS:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+#ifdef wx_x
+        case RESOURCE_PLATFORM_X:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+#ifdef wx_max
+        case RESOURCE_PLATFORM_MAC:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+        default:
+          break;
+      }
+      node = node->Next();
+    }
+    // If no matching resource, fail.
+    if (!optResource)
+      return NULL;
+
+    char *name = optResource->GetName();
+    int bitmapType = (int)optResource->GetValue1();
+    wxBitmap *bitmap = NULL;
+    switch (bitmapType)
+    {
+      case wxBITMAP_TYPE_XBM_DATA:
+      {
+#ifdef wx_x
+        wxItemResource *item = wxDefaultResourceTable.FindResource(name);
+        if (!item)
+        {
+          char buf[400];
+          sprintf(buf, "Failed to find XBM resource %s.\nForgot to use wxResourceLoadBitmapData?", name);
+          wxError(buf);
+          return NULL;
+        }
+        bitmap = new wxBitmap((char *)item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()); 
+#else
+        wxError("No XBM facility available!");
+#endif
+        break;
+      }
+      case wxBITMAP_TYPE_XPM_DATA:
+      {
+#if (defined(wx_x) && defined(USE_XPM_IN_X)) || (defined(wx_msw) && defined(USE_XPM_IN_MSW))
+        wxItemResource *item = wxDefaultResourceTable.FindResource(name);
+        if (!item)
+        {
+          char buf[400];
+          sprintf(buf, "Failed to find XPM resource %s.\nForgot to use wxResourceLoadBitmapData?", name);
+          wxError(buf);
+          return NULL;
+        }
+        bitmap = new wxBitmap((char **)item->GetValue1());
+#else
+        wxError("No XPM facility available!");
+#endif
+        break;
+      }
+      default:
+      {
+        bitmap = new wxBitmap(name, bitmapType);
+        break;
+      }
+    }
+    if (!bitmap)
+      return NULL;
+      
+    if (bitmap->Ok())
+    {
+      return bitmap;
+    }
+    else
+    {
+      delete bitmap;
+      return NULL;
+    }
+  }
+  else
+  {
+    char buf[300];
+    sprintf(buf, "Bitmap resource specification %s not found.", resource);
+    wxError(buf);
+    return NULL;
+  }
+}
+
+/*
+ * Load an icon from a wxWindows resource, choosing an optimum
+ * depth and appropriate type.
+ */
+ 
+wxIcon *wxResourceCreateIcon(char *resource)
+{
+  wxItemResource *item = wxDefaultResourceTable.FindResource(resource);
+  if (item)
+  {
+    if (item->GetType() != wxTYPE_ICON)
+    {
+      char buf[300];
+      sprintf(buf, "%s not an icon resource specification.", resource);
+      wxError(buf);
+      return NULL;
+    }
+    int thisDepth = wxDisplayDepth();
+    long thisNoColours = (long)pow(2.0, (double)thisDepth);
+
+    wxItemResource *optResource = NULL;
+    
+    // Try to find optimum icon for this platform/colour depth
+    wxNode *node = item->GetChildren().First();
+    while (node)
+    {
+      wxItemResource *child = (wxItemResource *)node->Data();
+      int platform = (int)child->GetValue2();
+      int noColours = (int)child->GetValue3();
+/*
+      char *name = child->GetName();
+      int bitmapType = (int)child->GetValue1();
+      int xRes = child->GetWidth();
+      int yRes = child->GetHeight();
+*/
+
+      switch (platform)
+      {
+        case RESOURCE_PLATFORM_ANY:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours.
+            // If noColours is zero (unspecified), then assume this
+            // is the right one.
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#ifdef wx_msw
+        case RESOURCE_PLATFORM_WINDOWS:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+#ifdef wx_x
+        case RESOURCE_PLATFORM_X:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+#ifdef wx_max
+        case RESOURCE_PLATFORM_MAC:
+        {
+          if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
+            optResource = child;
+          else
+          {
+            // Maximise the number of colours
+            if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
+              optResource = child;
+          }
+          break;
+        }
+#endif
+        default:
+          break;
+      }
+      node = node->Next();
+    }
+    // If no matching resource, fail.
+    if (!optResource)
+      return NULL;
+
+    char *name = optResource->GetName();
+    int bitmapType = (int)optResource->GetValue1();
+    wxIcon *icon = NULL;
+    switch (bitmapType)
+    {
+      case wxBITMAP_TYPE_XBM_DATA:
+      {
+#ifdef wx_x
+        wxItemResource *item = wxDefaultResourceTable.FindResource(name);
+        if (!item)
+        {
+          char buf[400];
+          sprintf(buf, "Failed to find XBM resource %s.\nForgot to use wxResourceLoadIconData?", name);
+          wxError(buf);
+          return NULL;
+        }
+        icon = new wxIcon((char *)item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()); 
+#else
+        wxError("No XBM facility available!");
+#endif
+        break;
+      }
+      case wxBITMAP_TYPE_XPM_DATA:
+      {
+      // *** XPM ICON NOT YET IMPLEMENTED IN WXWINDOWS ***
+/*
+#if (defined(wx_x) && defined(USE_XPM_IN_X)) || (defined(wx_msw) && defined(USE_XPM_IN_MSW))
+        wxItemResource *item = wxDefaultResourceTable.FindResource(name);
+        if (!item)
+        {
+          char buf[400];
+          sprintf(buf, "Failed to find XPM resource %s.\nForgot to use wxResourceLoadIconData?", name);
+          wxError(buf);
+          return NULL;
+        }
+        icon = new wxIcon((char **)item->GetValue1());
+#else
+        wxError("No XPM facility available!");
+#endif
+*/
+        wxError("No XPM icon facility available!");
+        break;
+      }
+      default:
+      {
+        icon = new wxIcon(name, bitmapType);
+        break;
+      }
+    }
+    if (!icon)
+      return NULL;
+      
+    if (icon->Ok())
+    {
+      return icon;
+    }
+    else
+    {
+      delete icon;
+      return NULL;
+    }
+  }
+  else
+  {
+    char buf[300];
+    sprintf(buf, "Icon resource specification %s not found.", resource);
+    wxError(buf);
+    return NULL;
+  }
+}
+
+wxMenu *wxResourceCreateMenu(wxItemResource *item)
+{
+  wxMenu *menu = new wxMenu;
+  wxNode *node = item->GetChildren().First();
+  while (node)
+  {
+    wxItemResource *child = (wxItemResource *)node->Data();
+    if (child->GetType() == wxRESOURCE_TYPE_SEPARATOR)
+      menu->AppendSeparator();
+    else if (child->GetChildren().Number() > 0)
+    {
+      wxMenu *subMenu = wxResourceCreateMenu(child);
+      if (subMenu)
+        menu->Append((int)child->GetValue1(), child->GetTitle(), subMenu, child->GetValue4());
+    }
+    else
+    {
+      menu->Append((int)child->GetValue1(), child->GetTitle(), child->GetValue4());
+    }
+    node = node->Next();
+  }
+  return menu;
+}
+
+wxMenuBar *wxResourceCreateMenuBar(char *resource)
+{
+  wxItemResource *menuResource = wxDefaultResourceTable.FindResource(resource);
+  if (menuResource && (menuResource->GetType() == wxTYPE_MENU))
+  {
+    wxMenuBar *menuBar = new wxMenuBar;
+    wxNode *node = menuResource->GetChildren().First();
+    while (node)
+    {
+      wxItemResource *child = (wxItemResource *)node->Data();
+      wxMenu *menu = wxResourceCreateMenu(child);
+      if (menu)
+        menuBar->Append(menu, child->GetTitle());
+      node = node->Next();
+    }
+    return menuBar;
+  }
+  return NULL;
+}
+
+wxMenu *wxResourceCreateMenu(char *resource)
+{
+  wxItemResource *menuResource = wxDefaultResourceTable.FindResource(resource);
+  if (menuResource && (menuResource->GetType() == wxTYPE_MENU))
+    return wxResourceCreateMenu(menuResource);
+  return NULL;
+}
+
+// Global equivalents (so don't have to refer to default table explicitly)
+Bool wxResourceParseData(char *resource)
+{
+  return wxDefaultResourceTable.ParseResourceData(resource);
+}
+
+Bool wxResourceParseFile(char *filename)
+{
+  return wxDefaultResourceTable.ParseResourceFile(filename);
+}
+
+// Register XBM/XPM data
+Bool wxResourceRegisterBitmapData(char *name, char bits[], int width, int height)
+{
+  return wxDefaultResourceTable.RegisterResourceBitmapData(name, bits, width, height);
+}
+
+Bool wxResourceRegisterBitmapData(char *name, char **data)
+{
+  return wxDefaultResourceTable.RegisterResourceBitmapData(name, data);
+}
+
+void wxResourceClear(void)
+{
+  wxDefaultResourceTable.ClearTable();
+}
+
+/*
+ * Identifiers
+ */
+
+static wxHashTable wxResourceIdentifiers(wxKEY_STRING);
+
+Bool wxResourceAddIdentifier(char *name, int value)
+{
+  wxResourceIdentifiers.Put(name, (wxObject *)value);
+  return TRUE;
+}
+
+int wxResourceGetIdentifier(char *name)
+{
+  return (int)wxResourceIdentifiers.Get(name);
+}
+
+/*
+ * Parse #include file for #defines (only)
+ */
+
+Bool wxResourceParseIncludeFile(char *f)
+{
+  FILE *fd = fopen(f, "r");
+  if (!fd)
+  {
+    return FALSE;
+  }
+  while (wxGetResourceToken(fd))
+  {
+    if (strcmp(wxResourceBuffer, "#define") == 0)
+    {
+      wxGetResourceToken(fd);
+      char *name = copystring(wxResourceBuffer);
+      wxGetResourceToken(fd);
+      char *value = copystring(wxResourceBuffer);
+      if (isdigit(value[0]))
+      {
+        int val = (int)atol(value);
+        wxResourceAddIdentifier(name, val);
+      }
+      delete[] name;
+      delete[] value;
+    }
+  }
+  fclose(fd);
+  return TRUE;
+}
+
+
+#endif // USE_WX_RESOURCES
diff --git a/src/wxmac/src/base/wb_stdev.cc b/src/wxmac/src/base/wb_stdev.cc
new file mode 100644
index 0000000..c9daac3
--- /dev/null
+++ b/src/wxmac/src/base/wb_stdev.cc
@@ -0,0 +1,428 @@
+/*
+ * File:	wb_stdev.cc
+ * Purpose:	Standard event definitions
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_stdev.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_stdev.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation "wx_stdev.h"
+#endif
+
+#include "common.h"
+#include "wx_item.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "wx_stdev.h"
+#include "wx_utils.h"
+
+/*
+ * Command events
+ *
+ */
+
+wxCommandEvent::wxCommandEvent(WXTYPE commandType)
+{
+  eventClass = wxTYPE_COMMAND_EVENT;
+  eventType = commandType;
+  clientData = NULL;
+  extraLong = 0;
+  commandInt = 0;
+  commandString = NULL;
+  labelString = NULL;
+}
+
+Bool wxCommandEvent::ReadEvent(istream& in)
+{
+  switch (eventType) {
+    case wxEVENT_TYPE_BUTTON_COMMAND:
+      return TRUE;
+    case wxEVENT_TYPE_TEXT_COMMAND:
+      // @@@@@ Hugh?
+      if (!wxReadString(in, &commandString))
+        return FALSE;
+    default:
+      return FALSE;
+  }
+  // NOTREADED
+}
+
+Bool wxCommandEvent::WriteEvent(ostream& out)
+{
+  switch (eventType) {
+
+    case wxEVENT_TYPE_BUTTON_COMMAND:
+      return TRUE;
+
+    case wxEVENT_TYPE_TEXT_COMMAND:
+      wxWriteString(out, commandString);
+      return TRUE;
+
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+static wxEvent *wxCommandEventConstructor(WXTYPE eventClass, WXTYPE eventType)
+{
+  return new wxCommandEvent(eventType);
+}
+
+/*
+ * Mouse events
+ *
+ */
+
+wxMouseEvent::wxMouseEvent(WXTYPE commandType)
+{
+  eventClass = wxTYPE_MOUSE_EVENT;
+  eventType = commandType;
+}
+
+wxMouseEvent& wxMouseEvent::operator =(wxMouseEvent& src)
+{
+  eventClass = src.eventClass;
+  eventType = src.eventType;
+  x = src.x;
+  y = src.y;
+  leftDown = src.leftDown;
+  middleDown = src.middleDown;
+  rightDown = src.rightDown;
+
+  controlDown = src.controlDown;
+  shiftDown = src.shiftDown;
+  altDown = src.altDown;
+  metaDown = src.metaDown;
+  
+  objectType = src.objectType;
+  eventObject = src.eventObject;
+  timeStamp = src.timeStamp;
+  eventHandle = src.eventHandle;
+  
+  return *this;
+}
+
+Bool wxMouseEvent::ReadEvent(istream& in)
+{
+  return FALSE;
+}
+
+Bool wxMouseEvent::WriteEvent(ostream& out)
+{
+  return FALSE;
+}
+
+static wxEvent *wxMouseEventConstructor(WXTYPE eventClass, WXTYPE eventType)
+{
+  return new wxMouseEvent(eventType);
+}
+
+Bool wxMouseEvent::ControlDown(void)
+{
+  return controlDown;
+}
+
+Bool wxMouseEvent::ShiftDown(void)
+{
+  return shiftDown;
+}
+
+// Is a button event (*doesn't* mean: is any button *down*?)
+Bool wxMouseEvent::IsButton(void)
+{
+  return (Button(-1)) ;
+}
+
+// True if was a button dclick event (1 = left, 2 = middle, 3 = right)
+// or any button dclick event (but = -1)
+Bool wxMouseEvent::ButtonDClick(int but)
+{
+  switch (but) {
+    case -1:
+      return (LeftDClick() || MiddleDClick() || RightDClick());
+    case 1:
+      return LeftDClick();
+    case 2:
+      return MiddleDClick();
+    case 3:
+      return RightDClick();
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+// True if was a button down event (1 = left, 2 = middle, 3 = right)
+// or any button down event (but = -1)
+Bool wxMouseEvent::ButtonDown(int but)
+{
+  switch (but) {
+    case -1:
+      return (LeftDown() || MiddleDown() || RightDown());
+    case 1:
+      return LeftDown();
+    case 2:
+      return MiddleDown();
+    case 3:
+      return RightDown();
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+// True if was a button up event (1 = left, 2 = middle, 3 = right)
+// or any button up event (but = -1)
+Bool wxMouseEvent::ButtonUp(int but)
+{
+  switch (but) {
+    case -1:
+      return (LeftUp() || MiddleUp() || RightUp());
+    case 1:
+      return LeftUp();
+    case 2:
+      return MiddleUp();
+    case 3:
+      return RightUp();
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+// True if the given button is currently changing state
+Bool wxMouseEvent::Button(int but)
+{
+  switch (but) {
+    case -1:
+      return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1)) ;
+    case 1:
+      return (LeftDown() || LeftUp() || LeftDClick());
+    case 2:
+      return (MiddleDown() || MiddleUp() || MiddleDClick());
+    case 3:
+      return (RightDown() || RightUp() || RightDClick());
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+Bool wxMouseEvent::LeftDown(void)
+{
+  return (eventType == wxEVENT_TYPE_LEFT_DOWN);
+}
+
+Bool wxMouseEvent::MiddleDown(void)
+{
+  return (eventType == wxEVENT_TYPE_MIDDLE_DOWN);
+}
+
+Bool wxMouseEvent::RightDown(void)
+{
+  return (eventType == wxEVENT_TYPE_RIGHT_DOWN);
+}
+
+Bool wxMouseEvent::LeftDClick(void)
+{
+  return (eventType == wxEVENT_TYPE_LEFT_DCLICK);
+}
+
+Bool wxMouseEvent::MiddleDClick(void)
+{
+  return (eventType == wxEVENT_TYPE_MIDDLE_DCLICK);
+}
+
+Bool wxMouseEvent::RightDClick(void)
+{
+  return (eventType == wxEVENT_TYPE_RIGHT_DCLICK);
+}
+
+Bool wxMouseEvent::LeftUp(void)
+{
+  return (eventType == wxEVENT_TYPE_LEFT_UP);
+}
+
+Bool wxMouseEvent::MiddleUp(void)
+{
+  return (eventType == wxEVENT_TYPE_MIDDLE_UP);
+}
+
+Bool wxMouseEvent::RightUp(void)
+{
+  return (eventType == wxEVENT_TYPE_RIGHT_UP);
+}
+
+Bool wxMouseEvent::Dragging(void)
+{
+  return ((eventType == wxEVENT_TYPE_MOTION) && (LeftIsDown() || MiddleIsDown() || RightIsDown()));
+}
+
+Bool wxMouseEvent::ButtonIsDown(int but)
+{
+  switch (but) {
+    case -1:
+      return (LeftIsDown() || MiddleIsDown() || RightIsDown());
+    case 1:
+      return LeftIsDown();
+    case 2:
+      return MiddleIsDown();
+    case 3:
+      return RightIsDown();
+    default:
+      return FALSE;
+  }
+  // NOTREACHED
+}
+
+Bool wxMouseEvent::LeftIsDown(void)
+{
+  return leftDown;
+}
+
+Bool wxMouseEvent::MiddleIsDown(void)
+{
+  return middleDown;
+}
+
+Bool wxMouseEvent::RightIsDown(void)
+{
+  return rightDown;
+}
+
+Bool wxMouseEvent::Moving(void)
+{
+  return (eventType == wxEVENT_TYPE_MOTION);
+}
+
+Bool wxMouseEvent::Entering(void)
+{
+  return (eventType == wxEVENT_TYPE_ENTER_WINDOW) ;
+}
+
+Bool wxMouseEvent::Leaving(void)
+{
+  return (eventType == wxEVENT_TYPE_LEAVE_WINDOW) ;
+}
+
+void wxMouseEvent::Position(float *xpos, float *ypos)
+{
+  *xpos = x;
+  *ypos = y;
+}
+
+/*
+ * Keyboard events
+ *
+ */
+
+wxKeyEvent::wxKeyEvent(WXTYPE type)
+{
+  eventClass = wxTYPE_KEY_EVENT;
+  eventType = type;
+  shiftDown = FALSE;
+  controlDown = FALSE;
+  altDown = FALSE;
+  keyCode = 0;
+}
+
+Bool wxKeyEvent::ReadEvent(istream& in)
+{
+  return FALSE;
+}
+
+Bool wxKeyEvent::WriteEvent(ostream& out)
+{
+  return FALSE;
+}
+
+static wxEvent *wxKeyEventConstructor(WXTYPE eventClass, WXTYPE eventType)
+{
+  return new wxKeyEvent(eventType);
+}
+
+Bool wxKeyEvent::ControlDown(void)
+{
+  return controlDown;
+}
+
+Bool wxKeyEvent::ShiftDown(void)
+{
+  return shiftDown;
+}
+
+long wxKeyEvent::KeyCode(void)
+{
+  return keyCode;
+}
+
+void wxKeyEvent::Position(float *xpos, float *ypos)
+{
+  *xpos = x;
+  *ypos = y;
+}
+
+/*
+ * Standard primary event handler
+ *
+ */
+
+// (find-window) can use the title or widget label:
+// (bind ?ok (find-window (find-top-window) "OK"))
+// (send-event ButtonCommand ?ok)
+
+// Aaargh! another problem. What if a button kills a dialog containing
+// it, but a post event handler is called? The object pointer will be invalid!
+// If we used IDs in a hash table, then the handler could check if the ID
+// was still valid. This would need minimum coding if we put it in the
+// wxWindow constructor and destructor.
+
+static Bool wxStandardEventHandler(wxEvent *event, Bool external)
+{
+  switch (event->eventClass) {
+    case wxTYPE_COMMAND_EVENT:
+    {
+      ((wxItem *)event->eventObject)->ProcessCommand(*((wxCommandEvent *)event));
+      break;
+    }
+    default:
+      return FALSE;
+  }
+  return FALSE;
+}
+
+/*
+ * Initialize all the standard event classes
+ *
+ */
+ 
+void wxInitStandardEvents(void)
+{
+  wxRegisterEventClass(wxTYPE_COMMAND_EVENT, wxTYPE_EVENT,
+                       (wxEventConstructor) wxCommandEventConstructor,
+                       "command event");
+  wxRegisterEventClass(wxTYPE_MOUSE_EVENT, wxTYPE_EVENT,
+                       (wxEventConstructor) wxMouseEventConstructor,
+                       "mouse event");
+  wxRegisterEventClass(wxTYPE_KEY_EVENT, wxTYPE_EVENT,
+                       (wxEventConstructor) wxKeyEventConstructor,
+                       "keyboard event");
+  wxRegisterEventName(wxEVENT_TYPE_BUTTON_COMMAND, wxTYPE_COMMAND_EVENT, "ButtonCommand");
+  // AND THE REST!!
+}
diff --git a/src/wxmac/src/base/wb_sysev.cc b/src/wxmac/src/base/wb_sysev.cc
new file mode 100644
index 0000000..f4f6173
--- /dev/null
+++ b/src/wxmac/src/base/wb_sysev.cc
@@ -0,0 +1,394 @@
+/*
+ * File:	wb_sysev.cc
+ * Purpose:	System event implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_sysev.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation "wx_sysev.h"
+#pragma implementation
+#pragma interface
+#endif
+
+#include "common.h"
+#include "wx_utils.h"
+#include "wx_list.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include "wx_sysev.h"
+
+wxList wxEventClassList(wxKEY_INTEGER);
+wxList wxEventNameList(wxKEY_INTEGER);
+wxList wxPrimaryEventHandlerList;
+wxList wxPreEventHandlerList;
+wxList wxPostEventHandlerList;
+
+class wxEventHandlerStruc: public wxObject
+{
+ public:
+   wxEventHandler handler;
+   Bool override;
+};
+
+/*
+ * A different kind of event from wxEvent: general wxWindows events, covering
+ * all interesting things that might happen (button clicking, resizing,
+ * setting text in widgets, etc.).
+ *
+ * For each completely new event type, derive a new event class.
+ *
+ */
+ 
+wxEvent::wxEvent(void)  : wxObject(WXGC_NO_CLEANUP)
+{
+  eventClass = 0;
+  eventType = 0;
+  objectType = 0;
+  eventObject = NULL;
+  eventHandle = NULL;
+}
+
+wxEvent::~wxEvent(void)
+{
+}
+
+
+static Bool wxSendEvent1(wxEvent& event, Bool external, wxList& list, Bool *stop)
+{
+  Bool handled = FALSE;
+
+  for(wxNode *node = list.First(); node; node = node->Next())
+  {
+    wxEventHandlerStruc *thing = (wxEventHandlerStruc *)node->Data();
+    if ((handled = (*thing->handler)(&event, external)) == TRUE)
+    {
+      if (thing->override)
+      {
+        *stop = TRUE;
+        break;
+      } else *stop = FALSE;
+    }
+  }
+  return handled;
+}
+
+// Send an event to the system, usually will be external, but specify
+// external = FALSE if calling from within the main application in response
+// to other events.
+// Returns TRUE iff the event was processed.
+Bool wxSendEvent(wxEvent& event, Bool external)
+{
+  Bool stop = FALSE;
+  return wxSendEvent1(event, external, wxPrimaryEventHandlerList, &stop);
+}
+
+// Notify the system of the event you are about to execute/have just executed.
+// If TRUE is returned and pre = TRUE, calling code should not execute the event
+// (i.e. it's been intercepted by a handler and vetoed).
+// These events are always internal, because they're generated from within
+// the main application code.
+Bool wxNotifyEvent(wxEvent& event, Bool pre)
+{
+  Bool stop = FALSE;
+  wxList *theList = NULL;
+  if (pre)
+    theList = &wxPreEventHandlerList;
+  else
+    theList = &wxPostEventHandlerList;
+
+  return wxSendEvent1(event, FALSE, *theList, &stop);
+}
+
+// Add a primary event handler. pre = TRUE iff it should be called before the
+// Returns TRUE if succeeds.
+Bool wxAddPrimaryEventHandler(wxEventHandler handlerFunc)
+{
+  wxEventHandlerStruc *struc = new wxEventHandlerStruc;
+  struc->handler = handlerFunc;
+  struc->override = FALSE;
+
+  wxPrimaryEventHandlerList.Append(struc);
+  return TRUE;
+}
+
+// Add a secondary event handler, pre = TRUE iff it should be called before the
+// event is executed. override = TRUE iff the handler is allowed to override
+// all subsequent events by returning TRUE.
+// Returns TRUE if succeeds.
+Bool wxAddSecondaryEventHandler(wxEventHandler handlerFunc,
+                                Bool pre, Bool override, Bool append)
+{
+  wxEventHandlerStruc *struc = new wxEventHandlerStruc;
+  struc->handler = handlerFunc;
+  struc->override = override;
+
+  if (pre)
+  {
+    if (append)
+      wxPreEventHandlerList.Append(struc);
+    else
+      wxPreEventHandlerList.Insert(struc);
+  }
+  else
+  {
+    if (append)
+      wxPostEventHandlerList.Append(struc);
+    else
+      wxPostEventHandlerList.Insert(struc);
+  }
+
+  return TRUE;
+}
+
+// Remove secondary event handler. Returns TRUE if succeeds.
+Bool wxRemoveSecondaryEventHandler(wxEventHandler handlerFunc, Bool pre)
+{
+  wxList *theList;
+  if (pre)
+    theList = &wxPreEventHandlerList;
+  else
+    theList = &wxPostEventHandlerList;
+  
+  for(wxNode *node = theList->First(); node; node = node->Next())
+  {
+    wxEventHandlerStruc *thing = (wxEventHandlerStruc *)node->Data();
+    if (thing->handler == handlerFunc)
+    {
+      delete thing;
+      delete node;
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+// Register a new event class (derived from wxEvent),
+// giving the new event class type, its superclass, a function for creating
+// a new event object of this class, and an optional description.
+void wxRegisterEventClass(WXTYPE eventClassId, WXTYPE superClassId,
+                          wxEventConstructor constructor, char *description)
+{
+  wxSystemEventClassStruc *struc = new wxSystemEventClassStruc;
+  struc->eventClass = eventClassId;
+  struc->eventConstructor = constructor;
+  if (description)
+    struc->eventDescription = copystring(description);
+  else
+    struc->eventDescription = NULL;
+
+  wxEventClassList.Append((long)eventClassId, struc);
+
+//  wxAllTypes.AddType(eventClassId, superClassId, description);
+}
+
+// Register the name of the event. This will allow a simple command language
+// where giving the event type name and some arguments will cause
+// a new event of class eventClassId to be created, with given event type,
+// and some arguments, allows an event to be dynamically constructed and sent.
+void wxRegisterEventName(WXTYPE eventTypeId, WXTYPE eventClassId, char *eventName)
+{
+  wxSystemEventNameStruc *struc = new wxSystemEventNameStruc;
+  struc->eventClass = eventClassId;
+  struc->eventType = eventTypeId;
+  struc->eventName = copystring(eventName);
+
+  wxEventNameList.Append((long)eventTypeId, struc);
+}
+
+// Define this and link before wxWindows library to allow
+// registering events from 'outside' the main application
+void wxRegisterExternalEventHandlers(void)
+{
+}
+
+/*
+ * Event reading/writing helper functions
+ *
+ */
+
+void wxWriteString(ostream& out, char *s)
+{
+  out << '"';
+
+  for (;*s;s++) {
+    if (*s == '"')
+      out << '\\' << '"';
+    else
+      out << *s;
+
+  }
+
+  out << '"';
+}
+
+void wxWriteInteger(ostream& out, int i)
+{
+  out << i;
+}
+
+void wxWriteLong(ostream& out, long i)
+{
+  out << i;
+}
+
+void wxWriteFloat(ostream& out, float f)
+{
+  out << f;
+}
+
+void wxWriteSpace(ostream& out)
+{
+  out << " ";
+}
+
+Bool wxReadWhiteSpace(istream& in)
+{
+// Why is there no eatwhite in GCC?
+#ifdef __MSC
+  in.eatwhite();
+#else
+  char ch = in.peek();
+  while ((ch == ' ') || (ch == '\n') || (ch == '\t'))
+  {
+    in.get();
+    ch = in.peek();
+  }
+#endif
+  return TRUE;
+}
+
+extern char *wxBuffer;
+Bool wxReadString(istream& in, char **s)
+{
+  wxReadWhiteSpace(in);
+
+  if (in.peek() != '"')
+    return FALSE;
+  in.get();
+  Bool flag = TRUE;
+  char ch = 0;
+  int i = 0;
+  while (flag && (i < 1000))
+  {
+    ch = in.get();
+    switch (ch)
+    {
+      case EOF:
+      {
+        wxBuffer[i] = 0;
+        flag = FALSE;
+        break;
+      }
+      case '"':
+      {
+        wxBuffer[i] = 0;
+        flag = FALSE;
+        break;
+      }
+      case '\\':
+      {
+        if (in.peek() == '"')
+        {
+          in.get();
+          wxBuffer[i] = '"';
+        }
+        else wxBuffer[i] = '\\';
+        break;
+      }
+      default:
+      {
+        wxBuffer[i] = ch;
+      }
+    }
+    ch = in.get();
+    i ++;
+  }
+  wxBuffer[i] = 0;
+  *s = copystring(wxBuffer);
+  return TRUE;
+}
+
+Bool wxReadInteger(istream& in, int *theInt)
+{
+  in >> *theInt;
+  return TRUE;
+}
+
+Bool wxReadLong(istream& in, long *theLong)
+{
+  in >> *theLong;
+  return TRUE;
+}
+
+Bool wxReadFloat(istream& in, float *theFloat)
+{
+  in >> *theFloat;
+  return TRUE;
+}
+
+void wxDeleteEventLists(void)
+{
+  wxNode *node ;
+
+  node = wxEventClassList.First();
+  while (node)
+  {
+    wxSystemEventClassStruc *struc = (wxSystemEventClassStruc*)node->Data();
+    wxNode *next = node->Next();
+    delete struc;
+    node = next;
+  }
+
+  node = wxEventNameList.First();
+  while (node)
+  {
+    wxSystemEventNameStruc *struc = (wxSystemEventNameStruc*)node->Data();
+    wxNode *next = node->Next();
+    delete struc;
+    node = next;
+  }
+
+  node = wxPrimaryEventHandlerList.First();
+  while (node)
+  {
+    wxEventHandlerStruc *struc = (wxEventHandlerStruc*)node->Data();
+    wxNode *next = node->Next();
+    delete struc;
+    node = next;
+  }
+
+  node = wxPreEventHandlerList.First();
+  while (node)
+  {
+    wxEventHandlerStruc *struc = (wxEventHandlerStruc*)node->Data();
+    wxNode *next = node->Next();
+    delete struc;
+    node = next;
+  }
+
+  node = wxPostEventHandlerList.First();
+  while (node)
+  {
+    wxEventHandlerStruc *struc = (wxEventHandlerStruc*)node->Data();
+    wxNode *next = node->Next();
+    delete struc;
+    node = next;
+  }
+
+}
diff --git a/src/wxmac/src/base/wb_text.cc b/src/wxmac/src/base/wb_text.cc
new file mode 100644
index 0000000..bf09e01
--- /dev/null
+++ b/src/wxmac/src/base/wb_text.cc
@@ -0,0 +1,164 @@
+/*
+ * File:	wb_text.cc
+ * Purpose:	wxTextWindow implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_text.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_text.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_main.h"
+#include "wx_text.h"
+#include "wx_utils.h"
+#include "wx_frame.h"
+#include "wx_gdi.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#ifdef wx_mac
+#include <iostream.h>
+#include <fstream.h>
+#include <stdio.h>
+#endif
+
+#ifndef wx_mac
+wxbTextWindow::wxbTextWindow(void)
+{
+  __type = wxTYPE_TEXT_WINDOW;
+  file_name = NULL;
+  window_parent = NULL;
+  font = wxSWISS_FONT;
+}
+
+wxbTextWindow::wxbTextWindow(wxWindow *parent, int x, int y, int width, int height,
+                           long style, char *name)
+{
+  __type = wxTYPE_TEXT_WINDOW;
+  windowStyle = style;
+  file_name = NULL;
+  window_parent = parent;
+  font = wxSWISS_FONT;
+}
+
+wxbTextWindow::~wxbTextWindow(void)
+{
+}
+#endif // wx_mac
+
+wxbTextWindow& wxbTextWindow::operator<<(char *s)
+{
+  WriteText(s);
+  return *this;
+}
+
+wxbTextWindow& wxbTextWindow::operator<<(float f)
+{
+  static char buf[100];
+  sprintf(buf, "%.2f", f);
+  WriteText(buf);
+  return *this;
+}
+
+wxbTextWindow& wxbTextWindow::operator<<(double d)
+{
+  static char buf[100];
+  sprintf(buf, "%.2f", d);
+  WriteText(buf);
+  return *this;
+}
+
+wxbTextWindow& wxbTextWindow::operator<<(int i)
+{
+  static char buf[100];
+  sprintf(buf, "%i", i);
+  WriteText(buf);
+  return *this;
+}
+
+wxbTextWindow& wxbTextWindow::operator<<(long i)
+{
+  static char buf[100];
+  sprintf(buf, "%ld", i);
+  WriteText(buf);
+  return *this;
+}
+
+wxbTextWindow& wxbTextWindow::operator<<(char c)
+{
+  char buf[2];
+
+  buf[0] = c;
+  buf[1] = 0;
+  WriteText(buf);
+  return *this;
+}
+
+#ifdef wx_mac
+//=============================================================================
+// Protected constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxbTextWindow::wxbTextWindow // Constructor (given parentArea)
+	(
+		WXTYPE		objectType,
+		char*		windowName,
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxWindow (windowName, parentArea, x, y, width, height, style),
+		file_name (NULL)
+{
+	font = wxSWISS_FONT;
+}
+
+//-----------------------------------------------------------------------------
+wxbTextWindow::wxbTextWindow // Constructor (given parentWindow)
+	(
+		WXTYPE		objectType,
+		char*		windowName,
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxWindow (windowName, parentWindow, x, y, width, height, style),
+		file_name (NULL)
+{
+	font = wxSWISS_FONT;
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxbTextWindow::~wxbTextWindow(void)
+{
+	if (file_name) delete[] file_name;
+}
+
+#endif // wx_mac
diff --git a/src/wxmac/src/base/wb_timer.cc b/src/wxmac/src/base/wb_timer.cc
new file mode 100644
index 0000000..c7a1df2
--- /dev/null
+++ b/src/wxmac/src/base/wb_timer.cc
@@ -0,0 +1,142 @@
+/*
+ * File:	wb_timer.cc
+ * Purpose:	wxTimer implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_timer.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_timer.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_list.h"
+#include "wx_frame.h"
+#include "wx_main.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+#include "wx_timer.h"
+
+#ifdef SVR4
+#define SYSV
+#endif
+
+#include <time.h>
+#ifndef wx_mac
+#include <sys/types.h>
+#endif
+
+#if defined(SVR4) || defined(SYSV) || defined(__sgi) || defined(__alpha)
+#include <sys/time.h>
+#endif
+
+#if defined(sun) || defined(__osf__)
+// At least on Sun, ftime is undeclared.
+// Need to be verified on other platforms.
+extern "C" int ftime(struct timeb *tp);
+// #include <sys/timeb.h>
+#ifdef SVR4
+// dito for gettimeofday on Solaris 2.x.
+extern "C" int gettimeofday(struct timeval *tp, void *);
+#endif
+#endif
+
+wxbTimer::wxbTimer(void)
+{
+ #if 0
+  __type = wxTYPE_TIMER;
+  milli = 0 ;
+  lastMilli = -1 ;
+ #endif
+}
+
+wxbTimer::~wxbTimer(void)
+{
+}
+
+// Override me!
+void wxbTimer::Notify(void)
+{
+}
+
+int wxbTimer::Interval(void)
+{
+  return interval ;
+}
+
+/*
+ * Timer functions
+ *
+ */
+
+long wxStartTime = 0;
+void wxStartTimer(void)
+{
+#if defined(__xlC__) || defined(_AIX) || defined(SVR4) || defined(SYSV) // || defined(AIXV3)
+  struct timeval tp;
+#ifdef SYSV
+  gettimeofday(&tp, (struct timezone *)NULL);
+#else
+  gettimeofday(&tp);
+#endif
+  wxStartTime = 1000*tp.tv_sec + tp.tv_usec/1000;
+#elif (defined(__SC__) || defined(__sgi) || defined(__bsdi__) || defined(__alpha)) || defined(wx_mac)
+  time_t t0;
+  struct tm *tp;
+  time(&t0);
+  tp = localtime(&t0);
+  wxStartTime = 1000*(60*(60*tp->tm_hour+tp->tm_min)+tp->tm_sec);
+#else
+  struct timeb tp;
+  ftime(&tp);
+  wxStartTime = 1000*tp.time + tp.millitm;
+#endif
+}
+
+// Returns elapsed time in milliseconds
+long wxGetElapsedTime(Bool resetTimer)
+{
+#if defined(__xlC__) || defined(_AIX) || defined(SVR4) || defined(SYSV) // || defined(AIXV3)
+  struct timeval tp;
+#ifdef SYSV
+  gettimeofday(&tp, (struct timezone *)NULL);
+#else
+  gettimeofday(&tp);
+#endif
+  long oldTime = wxStartTime;
+  long newTime = 1000*tp.tv_sec + tp.tv_usec / 1000;
+  if (resetTimer)
+    wxStartTime = newTime;
+#elif (defined(__SC__) || defined(__sgi) || defined(__bsdi__) || defined(__alpha)) || defined(wx_mac)
+  time_t t0;
+  struct tm *tp;
+  time(&t0);
+  tp = localtime(&t0);
+  long oldTime = wxStartTime;
+  long newTime = 1000*(60*(60*tp->tm_hour+tp->tm_min)+tp->tm_sec);
+  if (resetTimer)
+    wxStartTime = newTime;
+#else
+  struct timeb tp;
+  ftime(&tp);
+  long oldTime = wxStartTime;
+  long newTime = 1000*tp.time + tp.millitm;
+  if (resetTimer)
+    wxStartTime = newTime;
+#endif
+  return newTime - oldTime;
+}
diff --git a/src/wxmac/src/base/wb_types.cc b/src/wxmac/src/base/wb_types.cc
new file mode 100644
index 0000000..c1a7e30
--- /dev/null
+++ b/src/wxmac/src/base/wb_types.cc
@@ -0,0 +1,163 @@
+/*
+ * File:	wb_types.cc
+ * Purpose:	Explicit type implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_types.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation "wx_types.h"
+#endif
+
+#include "wx_utils.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+#include "wx_types.h"
+
+wxTypeTree wxAllTypes;
+
+void wxInitStandardTypes(void)
+{
+  // Define explicit type hierarchy
+  wxAllTypes.AddType(wxTYPE_WINDOW,      wxTYPE_ANY,                        "window");
+
+  wxAllTypes.AddType(wxTYPE_CANVAS,      wxTYPE_WINDOW,                     "canvas");
+#if (defined(wx_motif) && USE_PANEL_CANVAS_IN_X) || (defined(wx_msw) && USE_PANEL_CANVAS_IN_MSW)
+	|| (defined(wx_mac) && USE_PANEL_CANVAS_IN_MAC)
+  wxAllTypes.AddType(wxTYPE_PANEL,       wxTYPE_CANVAS,                     "panel");
+#else
+  wxAllTypes.AddType(wxTYPE_PANEL,       wxTYPE_WINDOW,                     "panel");
+#endif
+  wxAllTypes.AddType(wxTYPE_TEXT_WINDOW, wxTYPE_WINDOW,                     "text window");
+  wxAllTypes.AddType(wxTYPE_FRAME,       wxTYPE_WINDOW,                     "frame");
+  wxAllTypes.AddType(wxTYPE_ITEM,        wxTYPE_WINDOW,                     "item");
+
+#if USE_MAC_DIALOG_PANEL == 0
+  wxAllTypes.AddType(wxTYPE_DIALOG_BOX,  wxTYPE_FRAME,                      "dialog box");
+#else // wx_mac
+  wxAllTypes.AddType(wxTYPE_DIALOG_BOX,  wxTYPE_PANEL,                      "dialog box");
+#endif
+  wxAllTypes.AddType(wxTYPE_ENHANCED_DIALOG,  wxTYPE_DIALOG_BOX,            "enhanced dialog");
+
+  wxAllTypes.AddType(wxTYPE_BUTTON,      wxTYPE_ITEM,                       "button");
+  wxAllTypes.AddType(wxTYPE_MESSAGE,     wxTYPE_ITEM,                       "message");
+  wxAllTypes.AddType(wxTYPE_TEXT,        wxTYPE_ITEM,                       "text");
+  wxAllTypes.AddType(wxTYPE_MULTI_TEXT,  wxTYPE_TEXT,                       "multi text");
+  wxAllTypes.AddType(wxTYPE_CHOICE,      wxTYPE_ITEM,                       "choice");
+  wxAllTypes.AddType(wxTYPE_LIST_BOX,    wxTYPE_ITEM,                       "list box");
+  wxAllTypes.AddType(wxTYPE_CHECK_BOX,   wxTYPE_ITEM,                       "check box");
+  wxAllTypes.AddType(wxTYPE_SLIDER,      wxTYPE_ITEM,                       "slider");
+  wxAllTypes.AddType(wxTYPE_MENU,        wxTYPE_ITEM,                       "menu");
+  wxAllTypes.AddType(wxTYPE_MENU_BAR,    wxTYPE_ITEM,                       "menu bar");
+  wxAllTypes.AddType(wxTYPE_RADIO_BOX,   wxTYPE_ITEM,                       "radio box");
+  wxAllTypes.AddType(wxTYPE_GROUP_BOX,   wxTYPE_ITEM,                       "group box");
+  wxAllTypes.AddType(wxTYPE_GAUGE,       wxTYPE_ITEM,                       "gauge");
+
+  wxAllTypes.AddType(wxTYPE_EVENT,       wxTYPE_ANY,                        "event");
+  wxAllTypes.AddType(wxTYPE_MOUSE_EVENT, wxTYPE_EVENT,                      "mouse event");
+  wxAllTypes.AddType(wxTYPE_KEY_EVENT,   wxTYPE_EVENT,                      "key event");
+  wxAllTypes.AddType(wxTYPE_COMMAND_EVENT,wxTYPE_EVENT,                     "command event");
+
+  wxAllTypes.AddType(wxTYPE_DC,          wxTYPE_ANY,                        "device context");
+  wxAllTypes.AddType(wxTYPE_DC_CANVAS,   wxTYPE_DC,                         "canvas device context");
+  wxAllTypes.AddType(wxTYPE_DC_POSTSCRIPT,wxTYPE_DC,                        "PostScript device context");
+  wxAllTypes.AddType(wxTYPE_DC_PRINTER,  wxTYPE_DC,                         "printer device context");
+  wxAllTypes.AddType(wxTYPE_DC_METAFILE, wxTYPE_DC,                         "metafile device context");
+  wxAllTypes.AddType(wxTYPE_DC_MEMORY,   wxTYPE_DC,                         "memory device context");
+
+  wxAllTypes.AddType(wxTYPE_PEN,         wxTYPE_ANY,                        "pen");
+  wxAllTypes.AddType(wxTYPE_BRUSH,       wxTYPE_ANY,                        "brush");
+  wxAllTypes.AddType(wxTYPE_FONT,        wxTYPE_ANY,                        "font");
+  wxAllTypes.AddType(wxTYPE_BITMAP,      wxTYPE_ANY,                        "bitmap");
+  wxAllTypes.AddType(wxTYPE_ICON,        wxTYPE_BITMAP,                     "icon");
+  wxAllTypes.AddType(wxTYPE_CURSOR,      wxTYPE_BITMAP,                     "cursor");
+  wxAllTypes.AddType(wxTYPE_METAFILE,    wxTYPE_ANY,                        "metafile");
+  wxAllTypes.AddType(wxTYPE_TIMER,       wxTYPE_ANY,                        "timer");
+  wxAllTypes.AddType(wxTYPE_COLOUR,      wxTYPE_ANY,                        "colour");
+
+  wxAllTypes.AddType(wxTYPE_LIST,        wxTYPE_ANY,                        "list");
+  wxAllTypes.AddType(wxTYPE_STRING_LIST, wxTYPE_LIST,                       "string list");
+  wxAllTypes.AddType(wxTYPE_NODE,        wxTYPE_ANY,                        "node");
+  wxAllTypes.AddType(wxTYPE_HASH_TABLE,  wxTYPE_ANY,                        "hash table");
+  wxAllTypes.AddType(wxTYPE_APP,         wxTYPE_ANY,                        "application");
+
+  wxAllTypes.AddType(wxTYPE_DDE_SERVER,  wxTYPE_ANY,                        "DDE server");
+  wxAllTypes.AddType(wxTYPE_DDE_CLIENT,  wxTYPE_ANY,                        "DDE client");
+  wxAllTypes.AddType(wxTYPE_DDE_CONNECTION, wxTYPE_ANY,                     "DDE connection");
+  wxAllTypes.AddType(wxTYPE_HELP_INSTANCE, wxTYPE_ANY,                      "wxHelp instance");
+#ifdef wx_mac
+  wxAllTypes.AddType(wxTYPE_BORDER,      wxTYPE_WINDOW,                     "border");
+#endif
+}
+
+// Explicit type hierarchy required
+wxTypeTree::wxTypeTree(void):wxHashTable(wxKEY_INTEGER)
+{
+}
+
+wxTypeTree::~wxTypeTree(void)
+{
+  // Cleanup wxTypeDef allocated
+  BeginFind();
+  wxNode *node = Next();
+  while (node)
+  {
+    wxTypeDef *typ = (wxTypeDef *)node->Data();
+    delete typ;
+    node = Next();
+  }
+}
+
+void wxTypeTree::AddType(WXTYPE type, WXTYPE parent, char *name)
+{
+  wxTypeDef *typ = new wxTypeDef;
+  typ->type = type;
+  typ->parent = parent;
+  typ->name = copystring(name);
+  Put((long)type, (wxObject *)typ);
+}
+
+Bool wxSubType(WXTYPE type1, WXTYPE type2)
+{
+  if (type1 == type2)
+    return TRUE;
+
+  WXTYPE t = type1;
+  while (TRUE)
+  {
+    wxTypeDef *typ = (wxTypeDef *)wxAllTypes.Get((long)t);
+    if (!typ)
+      return FALSE;
+
+    if (type2 == typ->parent)
+      return TRUE;
+
+    t = typ->parent;
+  }
+}
+
+char *wxGetTypeName(WXTYPE type)
+{
+  if (type == wxTYPE_ANY)
+    return "any";
+
+  wxTypeDef *typ = (wxTypeDef *)wxAllTypes.Get((long)type);
+  if (!typ)
+    return NULL;
+  return typ->name;
+}
+
diff --git a/src/wxmac/src/base/wb_utils.cc b/src/wxmac/src/base/wb_utils.cc
new file mode 100644
index 0000000..ceef7fb
--- /dev/null
+++ b/src/wxmac/src/base/wb_utils.cc
@@ -0,0 +1,1352 @@
+/*
+ * File:        wb_utils.cc
+ * Purpose:     Miscellaneous utilities
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:     August 1994
+ * RCS_ID:      $Id: wb_utils.cc,v 1.5 1994/08/15 21:53:50 edz Exp edz $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_utils.h"
+#include "wx_win.h"
+#include "wx_menu.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#include <iostream.h>
+#include <fstream.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if !defined(wx_mac) || defined(_powerc)
+#ifndef __WATCOMC__
+#include <errno.h>
+#endif
+#endif
+#include <time.h>
+#ifndef wx_mac
+#include <sys/types.h>
+#include <sys/stat.h>
+#else	
+// wx_mac needs different headers depending on which library is providing stat()
+#   if defined(__SC__) || defined(_THINKC)
+#	include <unix.h>
+#   elif defined(PYLIB)
+#	include <stat.h>
+// #   elif defined(GUSI)
+// #	include <GUSI.h>
+#   elif defined(__MWERKS__) // && !defined(GUSI) && !defined(PYLIB)
+#	include <stat.h>	// normal CW stat.h
+#   else
+#	include "macstat.h"	// MPW probably
+#   endif
+#endif
+
+// Pattern matching code.
+// Yes, this path is deliberate (for Borland compilation)
+#ifdef wx_mac /* MATTHEW: [5] Mac doesn't like paths with "/" */
+#include "glob.inc"
+#else
+#include "../base/glob.inc"
+#endif
+
+#define _MAXPATHLEN 500
+
+extern char *wxBuffer;
+
+/* MATTHEW: [5] Mac */
+#if defined(VMS) 
+// we have no strI functions under VMS, therefore I have implemented
+// an inefficient but portable version: convert copies of strings to lowercase
+// and then use the normal comparison
+static void myLowerString(char *s)
+{
+  while(*s){
+    if(isalpha(*s)) *s = (char)tolower(*s);
+    s++;
+  }
+}
+
+int strcasecmp(const char *str_1, const char *str_2)
+{
+  char *temp1 = new char[strlen(str_1)+1];
+  char *temp2 = new char[strlen(str_2)+1];
+  strcpy(temp1,str_1);
+  strcpy(temp2,str_2);
+  myLowerString(temp1);
+  myLowerString(temp2);
+
+  int result = strcmp(temp1,temp2);
+  delete[] temp1;
+  delete[] temp2;
+
+  return(result);
+}
+
+int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
+{
+  char *temp1 = new char[strlen(str_1)+1];
+  char *temp2 = new char[strlen(str_2)+1];
+  strcpy(temp1,str_1);
+  strcpy(temp2,str_2);
+  myLowerString(temp1);
+  myLowerString(temp2);
+
+  int result = strncmp(temp1,temp2,maxchar);
+  delete[] temp1;
+  delete[] temp2;
+
+  return(result);
+}
+#endif
+
+#ifdef wx_msw
+
+#define   _wxToLower(_c)     (char)lcharmap[(unsigned char)(_c)]
+
+#define strcasecmp stricmp
+#define strncasecmp strnicmp
+
+// Lower case filename map
+static unsigned char lcharmap[] =
+{
+  '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
+  '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
+  '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
+  '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
+  '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
+  '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
+  '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
+  '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
+  '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+  '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+  '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+  '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
+  '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+  '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+  '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+  '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
+  '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
+  '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
+  '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
+  '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
+  '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
+  '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
+  '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
+  '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
+  '\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+  '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+  '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
+  '\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337',
+  '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+  '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+  '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
+  '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
+};
+
+#else
+// This declaration is missing in SunOS!
+// (Yes, I know it is NOT ANSI-C but its in BSD libc)
+#if defined(__xlC) || defined(_AIX) || defined(__GNUG__)
+extern "C"
+{
+  int strcasecmp (const char *, const char *);
+  int strncasecmp (const char *, const char *, size_t);
+}
+#endif
+#endif				/* wx_msw */
+#ifdef wx_mac
+int strncasecmp(char *, char *, int);	//these are in src:mac:wx_comparestrings.c
+int strcasecmp(char *, char *);
+#endif
+
+char *
+copystring (const char *s)
+{
+  if (s == NULL) s = "";
+  size_t len = strlen (s) + 1;
+
+  char *news = new char[len];
+  memcpy (news, s, len);	// Should be the fastest
+
+  return news;
+}
+
+// Id generation
+static long wxCurrentId = 100;
+
+long 
+wxNewId (void)
+{
+  return wxCurrentId++;
+}
+
+long
+wxGetCurrentId(void) { return wxCurrentId; }
+
+void 
+wxRegisterId (long id)
+{
+  if (id >= wxCurrentId)
+    wxCurrentId = id + 1;
+}
+
+void 
+StringToFloat (char *s, float *number)
+{
+  if (s && *s && number)
+    *number = (float) strtod (s, NULL);
+}
+
+void 
+StringToDouble (char *s, double *number)
+{
+  if (s && *s && number)
+    *number = strtod (s, NULL);
+}
+
+char *
+FloatToString (float number)
+{
+  static char buf[20];
+
+  sprintf (buf, "%.2f", number);
+  return buf;
+}
+
+char *
+DoubleToString (double number)
+{
+  static char buf[20];
+
+  sprintf (buf, "%.2f", number);
+  return buf;
+}
+
+void 
+StringToInt (char *s, int *number)
+{
+  if (s && *s && number)
+    *number = (int) strtol (s, NULL, 10);
+}
+
+void 
+StringToLong (char *s, long *number)
+{
+  if (s && *s && number)
+    *number = strtol (s, NULL, 10);
+}
+
+char *
+IntToString (int number)
+{
+  static char buf[20];
+
+  sprintf (buf, "%d", number);
+  return buf;
+}
+
+char *
+LongToString (long number)
+{
+  static char buf[20];
+
+  sprintf (buf, "%ld", number);
+  return buf;
+}
+
+
+// Match a string INDEPENDENT OF CASE
+Bool 
+StringMatch (char *str1, char *str2, Bool subString, Bool exact)
+{
+  if (str1 == NULL || str2 == NULL)
+    return FALSE;
+  if (str1 == str2)
+    return TRUE;
+
+  if (subString)
+    {
+      int len1 = strlen (str1);
+      int len2 = strlen (str2);
+      int i;
+
+      // Search for str1 in str2
+      // Slow .... but acceptable for short strings
+      for (i = 0; i <= len2 - len1; i++)
+	{
+	  if (strncasecmp (str1, str2 + i, len1) == 0)
+	    return TRUE;
+	}
+    }
+  else if (exact)
+    {
+      if (strcasecmp (str1, str2) == 0)
+	return TRUE;
+    }
+  else
+    {
+      int len1 = strlen (str1);
+      int len2 = strlen (str2);
+
+      if (strncasecmp (str1, str2, min (len1, len2)) == 0)
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+
+/****** FILE UTILITIES ******/
+
+#ifdef IMPLEMENT_DYNAMIC_CLASS
+IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxList)
+#endif
+
+void wxPathList::Add (char *path)
+{
+  Append ((wxObject *) path);
+}
+
+// Add paths e.g. from the PATH environment variable
+void wxPathList::AddEnvList (char *envVariable)
+{
+  static const char PATH_TOKS[] =
+#ifdef wx_msw
+	" ;"; // Don't seperate with colon in DOS (used for drive)
+#else
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+        ";"; // No colons OR spaces for Mac.
+             // (Perhaps function doesn't make sense anyway...)
+#else
+	" :;";
+#endif
+#endif
+
+  char *val = getenv (envVariable);
+  if (val && *val)
+    {
+      char *s = copystring (val);
+      char *token = strtok (s, PATH_TOKS);
+
+      if (token)
+	{
+	  Add (copystring (token));
+	  while (token)
+	    {
+	      if ((token = strtok (NULL, PATH_TOKS)) != NULL)
+		Add (copystring (token));
+	    }
+	}
+      delete[]s;
+    }
+}
+
+// Given a full filename (with path), ensure that that file can
+// be accessed again USING FILENAME ONLY by adding the path
+// to the list if not already there.
+void wxPathList::EnsureFileAccessible (char *path)
+{
+  char *path_only = wxPathOnly (path);
+  if (path_only)
+    {
+      if (!Member (path_only))
+	Add (path_only);
+    }
+}
+
+// BugFIX @@@@ Unix is case sensitive!
+Bool wxPathList::Member (char *path)
+{
+  for (wxNode * node = First (); node != NULL; node = node->Next ())
+    {
+      char *path2 = (char *) node->Data ();
+      if (path2 &&
+#if defined(wx_msw) || defined(VMS) || defined(wx_mac) /* MATTHEW: [5] Mac */
+      // Case INDEPENDENT
+	  strcasecmp (path, path2) == 0
+#else
+      // Case sensitive File System 
+	  strcmp (path, path2) == 0
+#endif
+	)
+	return TRUE;
+    }
+  return FALSE;
+}
+
+char *wxPathList::FindValidPath (char *file)
+{
+/*
+  if (wxFileExists (file))
+    return file;
+*/
+  if (wxFileExists (wxExpandPath(wxBuffer, file)))
+    return wxBuffer;
+
+  char buf[_MAXPATHLEN];
+  strcpy(buf, wxBuffer);
+
+  char *filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (char *)buf; /* MATTHEW: BC */
+
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      char *path = (char *) node->Data ();
+      strcpy (wxBuffer, path);
+#ifdef wx_mac
+      strcat (wxBuffer, ":"); /* MATTHEW: [5] Mac */
+#else
+      strcat (wxBuffer, "/");
+#endif
+      strcat (wxBuffer, filename);
+#ifdef wx_msw
+      Unix2DosFilename (wxBuffer);
+#endif
+      if (wxFileExists (wxBuffer))
+	return wxBuffer;	// Found!
+
+    }				// for()
+
+  return NULL;			// Not found
+
+}
+
+Bool 
+wxFileExists (const char *filename)
+{
+  struct stat stbuf;
+
+  // (char *) cast necessary for VMS
+  if (filename && stat ((char *)filename, &stbuf) == 0)
+    return TRUE;
+  return FALSE;
+}
+
+
+Bool 
+wxIsAbsolutePath (const char *filename)
+{
+  if (filename)
+    {
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+      if (*filename == ':')
+	return FALSE;
+      for (; *filename; filename++)
+	if (*filename == ':')
+	  return TRUE;
+      return FALSE;
+#else
+      if (*filename == '/'
+#ifdef VMS
+      || (*filename == '[' && *(filename+1) != '.')
+#endif
+#ifdef wx_msw
+      /* MSDOS */
+      || *filename == '\\' || (isalpha (*filename) && *(filename + 1) == ':')
+#endif
+	)
+	return TRUE;
+#endif
+    }
+  return FALSE;
+}
+
+/*
+ * Strip off any extension (dot something) from end of file,
+ * IF one exists. Inserts zero into buffer.
+ *
+ */
+ 
+void wxStripExtension(char *buffer)
+{
+  int len = strlen(buffer);
+  int i = len-1;
+  while (i > 0)
+  {
+    if (buffer[i] == '.')
+    {
+      buffer[i] = 0;
+      break;
+    }
+    i --;
+  }
+}
+
+// CAUSES PROBLEMS FOR GNU COMPILER -- does it? Check.
+// #ifndef __GNUG__
+// Destructive removal of /./ and /../ stuff
+char *wxRealPath (char *path)
+{
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+  char *p, *lastc = NULL;
+
+  /* IF we find a "::", delete up to previous ":".
+     Illegal if there is no previous ":" */
+  for (p = path; *p; p++)
+    if (p[0] == ':') {
+      if (p[1] == ':') {
+	if (lastc) {
+	  char *c;
+	  for (c = lastc, p++; *p; )
+	    *(c++) = *(p++);
+	  *c = 0;
+	  p = lastc - 1;
+	  for (lastc--; (lastc >= path) && (*lastc != ':'); --lastc);
+	  if (lastc < path)
+	  	lastc = NULL;
+	} else
+	  lastc = ++p;
+      } else
+	lastc = p;
+    }
+#else
+#ifdef wx_msw
+  static const char SEP = '\\';
+  Unix2DosFilename(path);
+#else 
+  static const char SEP = '/';
+#endif
+  if (path[0] && path[1]) {
+    /* MATTHEW: special case "/./x" */
+    char *p;
+    if (path[2] == SEP && path[1] == '.')
+      p = &path[0];
+    else
+      p = &path[2];
+    for (; *p; p++)
+      {
+	if (*p == SEP)
+	  {
+	    if (p[1] == '.' && p[2] == '.' && (p[3] == SEP || p[3] == '\0'))
+	      {
+		for (char *q = p - 1; q >= path && *q != SEP; q--);
+		if (q[0] == SEP && (q[1] != '.' || q[2] != '.' || q[3] != SEP)
+		    && (q - 1 <= path || q[-1] != SEP))
+		  {
+		    strcpy (q, p + 3);
+		    if (path[0] == '\0')
+		      {
+			path[0] = SEP;
+			path[1] = '\0';
+		      }
+#ifdef wx_msw
+		    /* MATTHEW: check that path[2] is NULL! */
+		    else if (path[1] == ':' && !path[2])
+		      {
+			path[2] = SEP;
+			path[3] = '\0';
+		      }
+#endif
+		    p = q - 1;
+		  }
+	      }
+	    else if (p[1] == '.' && (p[2] == SEP || p[2] == '\0'))
+	      strcpy (p, p + 2);
+	  }
+      }
+  }
+#endif
+  return path;
+}
+
+
+// Must be destroyed [@@@ new func]
+char *wxCopyAbsolutePath(const char *filename)
+{
+  if (filename == NULL)
+    return NULL;
+
+  if (! IsAbsolutePath(wxExpandPath(wxBuffer, filename))) {
+    char    buf[_MAXPATHLEN];
+    buf[0] = '\0';
+    wxGetWorkingDirectory(buf, sizeof(buf)/sizeof(char));
+    char ch = buf[strlen(buf) - 1];
+#ifdef wx_msw
+    if (ch != '\\' && ch != '/')
+	strcat(buf, "\\");
+#else
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+    if (ch != ':')
+	strcat(buf, ":");
+#else
+    if (ch != '/')
+	strcat(buf, "/");
+#endif
+#endif
+    strcat(buf, wxBuffer);
+    return copystring( wxRealPath(buf) );
+  }
+  return copystring( wxBuffer );
+}
+
+/*-
+ Handles:
+   ~/ => home dir
+   ~user/ => user's home dir
+   If the environment variable a = "foo" and b = "bar" then:
+   Unix:
+	$a	=>	foo
+	$a$b	=>	foobar
+	$a.c	=>	foo.c
+	xxx$a	=>	xxxfoo
+	${a}!	=>	foo!
+	$(b)!	=>	bar!
+	\$a	=>	\$a
+   MSDOS:
+	$a	==>	$a
+	$(a)	==>	foo
+	$(a)$b	==>	foo$b
+	$(a)$(b)==>	foobar
+	test.$$	==>	test.$$
+ */
+
+/* input name in name, pathname output to buf. */
+
+char *wxExpandPath(char *buf, const char *name)
+{
+    register char  *d, *s, *nm;
+    char            lnm[_MAXPATHLEN];
+    Bool            q;
+
+    // Some compilers don't like this line.
+//    const char      trimchars[] = "\n \t";
+
+    char      trimchars[4];
+    trimchars[0] = '\n';
+#ifdef wx_mac
+	trimchars[1] = '\r'; /* MATTHEW: [5] Space OK, carriage return is not */
+#else
+    trimchars[1] = ' ';
+#endif
+    trimchars[2] = '\t';
+    trimchars[3] = 0;
+
+#ifdef wx_msw
+     const char     SEP = '\\';
+#else 
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+    const char SEP = ':';
+#else
+     const char     SEP = '/';
+#endif
+#endif
+    buf[0] = '\0';
+    if (name == NULL || *name == '\0')
+	return buf;
+    nm = copystring(name); // Make a scratch copy
+    char *nm_tmp = nm;
+
+    /* Skip leading whitespace and cr */
+    while (strchr((char *)trimchars, *nm) != NULL) /* MATTHEW: BC */
+	nm++;
+    /* And strip off trailing whitespace and cr */
+    s = nm + (q = strlen(nm)) - 1;
+    while (q-- && strchr((char *)trimchars, *s) != NULL) /* MATTHEW: BC */
+	*s = '\0';
+
+#ifdef wx_mac /* MATTHEW: [5] That's all we should do for the Mac */
+	strcpy(buf, nm);
+    return wxRealPath(buf);
+#endif
+
+    s = nm;
+    d = lnm;
+#ifdef wx_msw
+    q = FALSE;
+#else
+    q = nm[0] == '\\' && nm[1] == '~';
+#endif
+
+    /* Expand inline environment variables */
+    while (*d++ = *s) {
+#ifndef wx_msw
+	if (*s == '\\') {
+	    if (*(d - 1) = *++s) {
+		s++;
+		continue;
+	    } else
+		break;
+	} else
+#endif
+#ifdef wx_msw
+	if (*s++ == '$' && (*s == '{' || *s == ')'))
+#else
+	if (*s++ == '$')
+#endif
+	{
+	    register char  *start = d;
+	    register        braces = (*s == '{' || *s == '(');
+	    register char  *value;
+	    while (*d++ = *s)
+		if (braces ? (*s == '}' || *s == ')') : !(isalnum(*s) || *s == '_') )
+		    break;
+		else
+		    s++;
+	    *--d = 0;
+	    value = getenv(braces ? start + 1 : start);
+	    if (value) {
+		for (d = start - 1; *d++ = *value++;);
+		d--;
+		if (braces && *s)
+		    s++;
+	    }
+	}
+    }
+
+    /* Expand ~ and ~user */
+    nm = lnm;
+    s = "";
+    if (nm[0] == '~' && !q) {
+	/* prefix ~ */
+	if (nm[1] == SEP || nm[1] == 0) {	/* ~/filename */
+	    if ((s = wxGetUserHome(NULL)) != NULL) {
+		if (*++nm)
+		    nm++;
+	    }
+	} else {		/* ~user/filename */
+	    register char  *nnm;
+	    register char  *home;
+	    for (s = nm; *s && *s != SEP; s++);
+	    int was_sep; /* MATTHEW: Was there a separator, or NULL? */
+	    was_sep = (*s == SEP);
+	    nnm = *s ? s + 1 : s;
+	    *s = 0;
+	    if ((home = wxGetUserHome(nm + 1)) == NULL) {
+		if (was_sep) /* MATTHEW: replace only if it was there: */
+		  *s = SEP;
+		s = "";
+	    } else {
+		nm = nnm;
+		s = home;
+	    }
+	}
+    }
+
+    d = buf;
+    if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */
+	/* Copy home dir */
+	while ('\0' != (*d++ = *s++))
+	  /* loop */;
+	// Handle root home
+	if (d - 1 > buf && *(d - 2) != SEP)
+	  *(d - 1) = SEP;
+    }
+    s = nm;
+    while (*d++ = *s++);
+
+    delete[] nm_tmp; // clean up alloc
+    /* Now clean up the buffer */
+    return wxRealPath(buf);
+}
+
+
+/* Contract Paths to be build upon an environment variable
+   component:
+
+   example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib
+
+   The call wxExpandPath can convert these back!
+ */
+char *
+wxContractPath (const char *filename, const char *envname, const char *user)
+{
+  static char dest[_MAXPATHLEN];
+
+  if (filename == NULL)
+    return NULL;
+
+#ifdef wx_mac /* MATTHEW: [5] Do nothing on Mac */
+  strcpy(dest, filename);
+  return dest;
+#endif
+
+  strcpy (dest, filename);
+#ifdef wx_msw
+  Unix2DosFilename(dest);
+#endif
+
+  // Handle environment
+  char *val, *tcp;
+  if (envname != NULL && (val = getenv (envname)) != NULL &&
+     (tcp = strstr (dest, val)) != NULL)
+    {
+        strcpy (wxBuffer, tcp + strlen (val));
+        *tcp++ = '$';
+        *tcp++ = '{';
+        strcpy (tcp, envname);
+        strcat (tcp, "}");
+        strcat (tcp, wxBuffer);
+    }
+
+  // Handle User's home (ignore root homes!)
+  size_t len;
+  if ((val = wxGetUserHome (user)) != NULL &&
+      (len = strlen(val)) > 2 &&
+      strncmp(dest, val, len) == 0)
+    {
+      strcpy(wxBuffer, "~");
+      if (user && *user)
+	strcat(wxBuffer, user);
+#ifdef wx_msw
+//      strcat(wxBuffer, "\\");
+#else
+//      strcat(wxBuffer, "/");
+#endif
+      strcat(wxBuffer, dest + len);
+      strcpy (dest, wxBuffer);
+    }
+
+  return dest;
+}
+
+// Return just the filename, not the path
+// (basename)
+char *
+wxFileNameFromPath (char *path)
+{
+  if (path)
+    {
+      register char *tcp;
+
+      tcp = path + strlen (path);
+      while (--tcp >= path)
+	{
+	  if (
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+	      *tcp == ':'
+#else
+	      *tcp == '/' 
+#ifdef wx_msw /* MATTHEW: [5] DOS only */
+                    || *tcp == '\\'
+#endif
+#endif
+#ifdef VMS
+     || *tcp == ':' || *tcp == ']')
+#else
+     )
+#endif
+	    return tcp + 1;
+	}			/* while */
+#ifdef wx_msw
+      if (isalpha (*path) && *(path + 1) == ':')
+	return path + 2;
+#endif
+    }
+  return path;
+}
+
+// Return just the directory, or NULL if no directory
+char *
+wxPathOnly (char *path)
+{
+  if (path && *path)
+    {
+      static char buf[_MAXPATHLEN];
+
+      // Local copy
+      strcpy (buf, path);
+
+      int l = strlen(path);
+      Bool done = FALSE;
+
+      int i = l - 1;
+
+      // Search backward for a backward or forward slash
+      while (!done && i > -1)
+      {
+        if (
+#ifdef wx_mac /* MATTHEW: [5] Mac */
+	    path[i] == ':'
+#else
+	    path[i] == '/' 
+#ifdef wx_msw /* MATTHEW: [5] DOS only */
+	    || path[i] == '\\'
+#endif
+#endif
+	    )
+        {
+          done = TRUE;
+          buf[i] = 0;
+          return buf;
+        }
+        else i --;
+      }
+
+/* there's a bug here somewhere, so replaced with my original code.
+      char *tcp;
+      // scan back
+      for (tcp = &buf[strlen (buf) - 1]; tcp >= buf; tcp--)
+	{
+	  // Search for Unix or Dos path sep {'\\', '/'}
+	  if (*tcp == '\\' || *tcp == '/')
+	    {
+	      *tcp = '\0';
+	      return buf;
+	    }
+	}			// for()
+*/
+#ifdef wx_msw
+      // Try Drive specifier
+      if (isalpha (buf[0]) && buf[1] == ':')
+	{
+	  // A:junk --> A:. (since A:.\junk Not A:\junk)
+	  buf[2] = '.';
+	  buf[3] = '\0';
+	  return buf;
+	}
+#endif
+    }
+
+  return NULL;
+}
+
+// Utility for converting delimiters in DOS filenames to UNIX style
+// and back again - or we get nasty problems with delimiters.
+// Also, convert to lower case, since case is significant in UNIX.
+
+void 
+wxDos2UnixFilename (char *s)
+{
+  if (s)
+    while (*s)
+      {
+	if (*s == '\\')
+	  *s = '/';
+#ifdef wx_msw
+	else
+	  *s = _wxToLower (*s);	// Case INDEPENDENT
+#endif
+	s++;
+      }
+}
+
+void 
+wxUnix2DosFilename (char *s)
+{
+// Yes, I really mean this to happen under DOS only! JACS
+#ifdef wx_msw
+  if (s)
+    while (*s)
+      {
+	if (*s == '/')
+	  *s = '\\';
+	s++;
+      }
+#endif
+}
+
+// Return the current date/time
+// [volatile]
+char *wxNow( void )
+{
+  time_t now = time(NULL);
+  char *date = ctime(&now); 
+  date[24] = '\0';
+  return date;
+}
+
+/* Get Full RFC822 style email address */
+Bool
+wxGetEmailAddress (char *address, int maxSize)
+{
+  char host[65];
+  char user[65];
+
+  if (wxGetHostName(host, 64) == FALSE)
+    return FALSE;
+  if (wxGetUserId(user, 64) == FALSE)
+    return FALSE;
+
+  char tmp[130];
+  strcpy(tmp, user);
+  strcat(tmp, "@");
+  strcat(tmp, host);
+
+  strncpy(address, tmp, maxSize - 1);
+  address[maxSize-1] = '\0';
+  return TRUE;
+}
+
+// Concatenate two files to form third
+Bool 
+wxConcatFiles (const char *file1, const char *file2, const char *file3)
+{
+  char *outfile = wxGetTempFileName("cat");
+
+  FILE *fp1 = NULL;
+  FILE *fp2 = NULL;
+  FILE *fp3 = NULL;
+  // Open the inputs and outputs
+  if ((fp1 = fopen (file1, "rb")) == NULL ||
+      (fp2 = fopen (file2, "rb")) == NULL ||
+      (fp3 = fopen (outfile, "wb")) == NULL)
+    {
+      if (fp1)
+	fclose (fp1);
+      if (fp2)
+	fclose (fp2);
+      if (fp3)
+	fclose (fp3);
+      return FALSE;
+    }
+
+  int ch;
+  while ((ch = getc (fp1)) != EOF)
+    (void) putc (ch, fp3);
+  fclose (fp1);
+
+  while ((ch = getc (fp2)) != EOF)
+    (void) putc (ch, fp3);
+  fclose (fp2);
+
+  fclose (fp3);
+  Bool result = wxRenameFile(outfile, file3);
+  delete[] outfile;
+  return result;
+}
+
+// Copy files
+Bool 
+wxCopyFile (const char *file1, const char *file2)
+{
+  FILE *fd1;
+  FILE *fd2;
+  int ch;
+
+  if ((fd1 = fopen (file1, "rb")) == NULL)
+    return FALSE;
+  if ((fd2 = fopen (file2, "wb")) == NULL)
+    {
+      fclose (fd1);
+      return FALSE;
+    }
+
+  while ((ch = getc (fd1)) != EOF)
+    (void) putc (ch, fd2);
+
+  fclose (fd1);
+  fclose (fd2);
+  return TRUE;
+}
+
+Bool 
+wxRenameFile (const char *file1, const char *file2)
+{
+  // Normal system call
+  if (0 == rename (file1, file2))
+    return TRUE;
+  // Try to copy
+  if (wxCopyFile(file1, file2)) {
+    wxRemoveFile(file1);
+    return TRUE;
+  }
+  // Give up
+  return FALSE;
+}
+
+/*
+ * Strip out any menu codes
+ */
+
+char *wxStripMenuCodes (char *in, char *out)
+{
+  if (!in)
+    return NULL;
+    
+  if (!out)
+    out = copystring(in);
+
+  char *tmpOut = out;
+  
+  while (*in)
+    {
+      if (*in == '&')
+	{
+	  // Check && -> &, &x -> x
+	  if (*++in == '&')
+	    *out++ = *in++;
+	}
+      else if (*in == '\t')
+	{
+          // Remove all stuff after \t in X mode, and let the stuff as is
+          // in Windows mode.
+          // Accelerators are handled in wx_item.cc for Motif, and are not
+          // YET supported in XView
+	  break;
+	}
+      else
+	*out++ = *in++;
+    }				// while
+
+  *out = '\0';
+
+  return tmpOut;
+}
+
+
+/*
+ * Window search functions
+ *
+ */
+
+/*
+ * If parent is non-NULL, look through children for a label or title
+ * matching the specified string. If NULL, look through all top-level windows.
+ *
+ */
+
+static wxWindow *wxFindWindowByLabel1 (char *title, wxWindow * parent);
+
+wxWindow *
+wxFindWindowByLabel (char *title, wxWindow * parent)
+{
+  if (parent)
+    {
+      return wxFindWindowByLabel1 (title, parent);
+    }
+  else
+    {
+      for (wxChildNode * node = wxTopLevelWindows(NULL)->First (); node; node = node->Next ())
+	{
+	  wxWindow *win = (wxWindow *) node->Data ();
+	  if (win && node->IsShown()) {
+		  wxWindow *retwin = wxFindWindowByLabel1 (title, win);
+		  if (retwin)
+		    return retwin;
+	  }
+	}			// for()
+
+    }
+  return NULL;
+}
+
+// Recursive
+static wxWindow *
+wxFindWindowByLabel1 (char *title, wxWindow * parent)
+{
+  if (parent)
+    {
+      char *lab = parent->GetLabel ();
+      if (lab && StringMatch (title, lab))
+	return parent;
+    }
+
+  if (parent)
+    {
+      for (wxChildNode * node = parent->GetChildren()->First (); node; node = node->Next ())
+	{
+	  wxWindow *win = (wxWindow *) node->Data ();
+	  wxWindow *retwin = wxFindWindowByLabel1 (title, win);
+	  if (retwin)
+	    return retwin;
+	}			// for()
+
+    }
+
+  return NULL;			// Not found
+
+}
+
+/*
+ * If parent is non-NULL, look through children for a name
+ * matching the specified string. If NULL, look through all top-level windows.
+ *
+ */
+
+static wxWindow *wxFindWindowByName1 (char *title, wxWindow * parent);
+
+wxWindow *
+wxFindWindowByName (char *title, wxWindow * parent)
+{
+  if (parent)
+    {
+      return wxFindWindowByName1 (title, parent);
+    }
+  else
+    {
+      for (wxChildNode * node = wxTopLevelWindows(NULL)->First (); node; node = node->Next ())
+	{
+	  wxWindow *win = (wxWindow *) node->Data ();
+	  if (win && node->IsShown()) {
+		  wxWindow *retwin = wxFindWindowByName1 (title, win);
+		  if (retwin)
+		    return retwin;
+	  }
+	}			// for()
+
+    }
+  // Failed? Try by label instead.
+  return wxFindWindowByLabel(title, parent);
+}
+
+// Recursive
+static wxWindow *
+wxFindWindowByName1 (char *title, wxWindow * parent)
+{
+  if (parent)
+    {
+      char *lab = parent->GetName ();
+      if (lab && StringMatch (title, lab))
+	return parent;
+    }
+
+  if (parent)
+    {
+      for (wxChildNode * node = parent->GetChildren()->First (); node; node = node->Next ())
+	{
+	  wxWindow *win = (wxWindow *) node->Data ();
+	  wxWindow *retwin = wxFindWindowByName1 (title, win);
+	  if (retwin)
+	    return retwin;
+	}			// for()
+
+    }
+
+  return NULL;			// Not found
+
+}
+
+// Returns menu item id or -1 if none.
+int 
+wxFindMenuItemId (wxFrame * frame, char *menuString, char *itemString)
+{
+  wxMenuBar *menuBar = frame->GetMenuBar ();
+  if (!menuBar)
+    return -1;
+  return menuBar->FindMenuItem (menuString, itemString);
+}
+
+/*
+ * wxDebugStreamBuf
+ */
+#ifndef wx_mac /* MATTHEW: [5] Not in Mac header? */
+
+wxDebugStreamBuf::wxDebugStreamBuf(void)
+{
+  if (allocate()) setp(base(),ebuf());
+}
+
+int wxDebugStreamBuf::overflow(int WXUNUSED(i))
+{
+  int len = pptr() - pbase();
+  char *txt = new char[len+1];
+  strncpy(txt, pbase(), len);
+  txt[len] = '\0';
+#ifdef wx_msw
+  OutputDebugString((LPCSTR)txt);
+#else
+  fprintf(stderr, txt);
+#endif
+  setp(pbase(), epptr());
+  delete[] txt;
+  return EOF;
+}
+
+int wxDebugStreamBuf::sync(void)
+{
+  int len = pptr() - pbase();
+  char *txt = new char[len+1];
+  strncpy(txt, pbase(), len);
+  txt[len] = '\0';
+#ifdef wx_msw
+  OutputDebugString((LPCSTR)txt);
+#else
+  fprintf(stderr, txt);
+#endif
+  setp(pbase(), epptr());
+  delete[] txt;
+  return 0;
+}
+
+
+#endif
+
+#ifdef wx_mac
+
+/////////////////////////////////////////////////////////////////////////////
+//
+#ifdef DEBUGLOG
+//
+
+#define SHARED	// one or more applications can dump on the same file, useful on IPC testing
+
+wxLogClass::wxLogClass (const char *file)
+{
+  log_file = copystring (file);
+#ifdef SHARED
+  the_stream = new ofstream(log_file,ios::out|ios::app); 
+#else
+  the_stream = new ofstream(log_file);
+#endif
+  delete the_stream;
+}
+
+wxLogClass::~wxLogClass ()
+{
+ delete log_file;
+}
+
+void wxLogClass::Open (void)
+{
+#ifdef wx_mac
+  the_stream = new ofstream(log_file, ios::out|ios::app);
+#else
+	the_stream = new ofstream(log_file, ios::app);
+#endif
+}
+
+void wxLogClass::Close (void)
+{
+  delete the_stream;
+}
+
+wxLogClass & wxLogClass::operator <<(char *s)
+{
+  this->Open ();
+  *the_stream << s;
+  the_stream->flush ();
+  this->Close ();
+  return *this;
+}
+
+wxLogClass & wxLogClass::operator <<(int i)
+{
+  this->Open ();
+  *the_stream << i;
+  the_stream->flush ();
+  this->Close ();
+  return *this;
+}
+
+wxLogClass & wxLogClass::operator <<(double i)
+{
+  this->Open ();
+  *the_stream << i;
+  the_stream->flush ();
+  this->Close ();
+  return *this;
+}
+
+wxLogClass wxLog ("log");
+#endif /* DEBUGLOG */
+/////////////////////////////////////////////////////////////////////////////
+
+#endif
diff --git a/src/wxmac/src/base/wb_win.cc b/src/wxmac/src/base/wb_win.cc
new file mode 100644
index 0000000..44eb542
--- /dev/null
+++ b/src/wxmac/src/base/wb_win.cc
@@ -0,0 +1,182 @@
+/*
+ * File:	wb_win.cc
+ * Purpose:	wxWindow class implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wb_win.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "@(#)wb_win.cc	1.2 5/9/94"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_win.h"
+#include "wx_gdi.h"
+#include "wx_utils.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+// Constructor
+wxbWindow::wxbWindow(void)
+{
+  __type = wxTYPE_WINDOW;
+  windowStyle = 0;
+  wx_client_data = NULL;
+#ifndef wx_mac
+  window_parent = NULL;
+#endif
+  font = NULL;
+  handle = NULL;
+  windowName = NULL;
+  callback = 0;
+  wx_cursor = wxSTANDARD_CURSOR;
+#ifndef wx_mac
+  children = new wxChildList;
+#endif
+  paintingEnabled = TRUE;
+  doubleClickAllowed = 0 ;
+  winCaptured = FALSE;
+}
+
+#ifdef wx_mac
+void wxbWindow::InitDefaults(void)
+{
+ 	__type = wxTYPE_WINDOW;
+	windowStyle = 0;
+	doubleClickAllowed = 0 ;
+	paintingEnabled = TRUE;
+	wx_client_data = NULL;
+	handle = NULL;
+	wx_cursor = wxSTANDARD_CURSOR;
+	callback = NULL;
+	font = NULL;
+}
+
+wxbWindow::wxbWindow // Constructor
+	(
+		char*		windowName
+	) :
+		wxObject (),
+		windowName(copystring(windowName))
+{
+	InitDefaults();
+}
+#endif // wx_mac
+
+// Destructor
+wxbWindow::~wxbWindow(void)
+{
+  if (windowName) delete[] windowName;
+}
+
+char *wxbWindow::GetHandle(void)
+{
+  return handle;
+}
+
+// General callback setting
+void wxbWindow::Callback(wxFunction Function)
+{
+  if (Function)
+    callback = Function;
+}
+
+// Client data handling (any window, item etc.)
+void wxbWindow::SetClientData(char *data)
+{
+  wx_client_data = data;
+}
+
+char *wxbWindow::GetClientData(void)
+{
+  return wx_client_data;
+}
+
+#ifndef wx_mac
+wxWindow *wxbWindow::GetParent(void)
+{
+  return window_parent;
+}
+
+wxWindow *wxbWindow::GetGrandParent(void)
+{
+  if (window_parent)
+    return window_parent->window_parent;
+  return NULL;
+}
+
+void wxbWindow::AddChild(wxObject *child)
+{
+  children->Append(child);
+}
+
+void wxbWindow::RemoveChild(wxObject *child)
+{
+  if (children)
+    children->DeleteObject(child);
+}
+
+void wxbWindow::DestroyChildren(void)
+{
+  if (children) {
+    wxChildNode *node;
+    while ((node = children->First()) != (wxNode *)NULL) {
+      wxWindow *child;
+      if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
+//      child->DestroyChildren();
+        delete child;
+      }
+    } /* while */
+  }
+}
+#endif // wx_mac
+
+void wxbWindow::MakeModal(Bool modal)
+{
+  // Disable all other windows
+  if (wxSubType(__type, wxTYPE_DIALOG_BOX) || wxSubType(__type, wxTYPE_FRAME))
+  {
+    wxChildNode *node = wxTopLevelWindows(ContextWindow())->First();
+    while (node)
+    {
+      wxWindow *win = (wxWindow *)node->Data();
+      if (win != this)
+        win->Enable(!modal);
+
+      node = node->Next();
+    }
+  }
+}
+
+void wxbWindow::SetName(char *name)
+{
+  if (windowName)
+    delete[] windowName;
+  if (name)
+    windowName = copystring(name);
+  else
+    windowName = NULL;
+}
+
+wxWindow *wxbWindow::ContextWindow()
+{
+	if (wxSubType(__type, wxTYPE_FRAME))
+		return (wxWindow *)this;
+	if (wxSubType(__type, wxTYPE_DIALOG_BOX))
+		return ((wxDialogBox *)this)->cFrame;
+	return NULL;
+}
diff --git a/src/wxmac/src/base/wx_enhdg.cc b/src/wxmac/src/base/wx_enhdg.cc
new file mode 100644
index 0000000..84907c8
--- /dev/null
+++ b/src/wxmac/src/base/wx_enhdg.cc
@@ -0,0 +1,547 @@
+/*
+ * File:	wx_enhdg.cc
+ * Purpose:	wxEnhancedDialogBox
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wx_enhdg.cc,v 1.3 1994/08/14 21:34:01 edz Exp $
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+/* static const char sccsid[] = "%W% %G%"; */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+#include "wx_dialg.h"
+#include "wx_utils.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+#include "wx_item.h"
+#include "wx_buttn.h"
+#include "wx_messg.h"
+#include "wx_choic.h"
+#include "wx_check.h"
+#include "wx_menu.h"
+#include "wx_txt.h"
+#include "wx_mtxt.h"
+#include "wx_slidr.h"
+#include "wx_lbox.h"
+#include "wx_rbox.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+
+#if USE_ENHANCED_DIALOG
+#include "wx_enhdg.h"
+
+#include <stdio.h>
+
+#ifdef wx_xview
+#include <xview/frame.h>
+  // Under XView, font setting doesn't works. 2 possibles reasons:
+  // 1) I make a mistake
+  // 2) XView doesn't allow font setting
+  // Until clear, no font changes for XView!!
+#undef ENHANCED_FONTS
+#define ENHANCED_FONTS 0
+#endif
+
+// Override ENHANCED_FONTS if requested
+#ifdef WINDOWS_STANDARD
+#undef ENHANCED_FONTS
+#define ENHANCED_FONTS 0
+#endif
+
+#ifdef WINDOWS_BUTTON_ONLY
+#undef ENHANCED_FONTS
+#define ENHANCED_FONTS 0
+#endif
+
+//
+//	Enhanced Dialog Box
+//
+#if !defined(wx_xview)
+static        wxFont  *pin_font ;
+#endif
+static        wxFont  *label_font ;
+static        wxFont  *button_font ;
+static        wxFont  *cmd_font ;
+
+#define	DO_UNSHOW	0
+#define	DO_NOT_UNSHOW	1
+
+void UnpinEnhDialog(wxCheckBox &pin,wxCommandEvent evt)
+{
+  if (pin.GetValue())
+    return ;
+  long clientData = (long)pin.GetClientData() ;
+  if (clientData==DO_NOT_UNSHOW)
+    return ;
+  wxPanel *pinpanel = (wxPanel*)pin.window_parent ;
+  wxEnhDialogBox *dialog = (wxEnhDialogBox*)pinpanel->window_parent ;
+  dialog->Show(FALSE) ;
+}
+
+void CancelEnhDialog(wxItem &button,wxCommandEvent evt)
+{
+  wxPanel *cmdpanel = (wxPanel*)button.window_parent ;
+  wxEnhDialogBox *dialog = (wxEnhDialogBox*)cmdpanel->window_parent ;
+  dialog->pinned = FALSE ;
+  dialog->Show(FALSE) ;
+}
+
+void wxEnhDialogCreateFonts()
+{
+  // Put your own defaults fonts here!
+
+  // "Normal" font setting. Works for most applications.
+#if ENHANCED_FONTS
+  if (label_font==NULL)
+    label_font = new wxFont(12,wxSWISS,wxNORMAL,wxBOLD) ;
+  if (button_font==NULL)
+    button_font = new wxFont(12,wxSWISS,wxNORMAL,wxNORMAL) ;
+#if !defined(wx_xview)
+  if (pin_font==NULL)
+    pin_font = new wxFont(14,wxROMAN,wxITALIC,wxBOLD) ;
+#endif
+#ifdef wx_x
+  if (cmd_font==NULL)
+    cmd_font = new wxFont(17,wxROMAN,wxNORMAL,wxNORMAL) ;
+#else
+  if (cmd_font==NULL)
+    cmd_font = new wxFont(14,wxROMAN,wxNORMAL,wxNORMAL) ;
+#endif
+#endif
+
+  // Strict Windows standard: all with the same bold font...
+#ifdef WINDOWS_STANDARD
+  if (label_font==NULL)
+    label_font = new wxFont(6,wxDEFAULT,wxNORMAL,wxBOLD) ;
+  if (button_font==NULL)
+    button_font = new wxFont(6,wxDEFAULT,wxNORMAL,wxBOLD) ;
+#if !defined(wx_xview)
+  if (pin_font==NULL)
+    pin_font = new wxFont(6,wxDEFAULT,wxNORMAL,wxBOLD) ;
+#endif
+  if (cmd_font==NULL)
+    cmd_font = new wxFont(6,wxDEFAULT,wxNORMAL,wxBOLD) ;
+#endif
+
+  // A compromise for Windows: only command buttons are standard.
+#ifdef WINDOWS_BUTTON_ONLY
+  if (label_font==NULL)
+    label_font = new wxFont(12,wxSWISS,wxNORMAL,wxBOLD) ;
+  if (button_font==NULL)
+    button_font = new wxFont(12,wxSWISS,wxNORMAL,wxNORMAL) ;
+#if !defined(wx_xview)
+  if (pin_font==NULL)
+    pin_font = new wxFont(14,wxROMAN,wxITALIC,wxBOLD) ;
+#endif
+  if (cmd_font==NULL)
+    cmd_font = new wxFont(12,wxDEFAULT,wxNORMAL,wxBOLD) ;
+#endif
+
+}
+
+wxEnhDialogBox::wxEnhDialogBox(wxFrame *Parent, char *Title, Bool Modal, 
+                         wxFunction fun,int space,
+                         int x, int y, int width, int height,
+			 long Style, char *name)
+		: wxDialogBox(Parent,Title,Modal,x,y,width,height,Style,name) 
+{
+  __type = wxTYPE_ENHANCED_DIALOG ;
+  wxEnhDialogCreateFonts() ;
+  panel = this ;
+  panel->SetVerticalSpacing(0) ;
+  panel->SetHorizontalSpacing(0) ;
+  panel->SetLabelFont(label_font) ;
+  panel->SetButtonFont(button_font) ;
+  windowStyle = style ;
+  maxWidth = 0 ;
+  maxHeight = 0 ;
+
+#if !defined(wx_xview)
+  long cancel = style&wxMASK_CANCEL ;
+  if (cancel==wxNO_CANCEL_BUTTON)
+  {
+    pinPanel = new wxPanel(panel) ;
+    pinPanel->SetVerticalSpacing(0) ;
+    pinPanel->SetButtonFont(pin_font) ;
+#ifdef wx_motif
+    // Motif provide enough spacing...
+    pinPanel->SetHorizontalSpacing(0) ;
+#endif
+    pinCheck = new wxCheckBox(pinPanel,(wxFunction)UnpinEnhDialog,"Pinned",
+                              -1,-1,100,20,0,"pin") ;
+    pinCheck->SetClientData((char*)DO_UNSHOW) ;
+    pinPanel->Fit() ;
+    panel->NewLine() ;
+  }
+  else
+  {
+    pinPanel = 0 ;
+    pinCheck = 0 ;
+  }
+#endif
+
+  unshow = fun ;
+  userPanel = new wxPanel(panel,-1,-1,-1,-1,0,"user") ;
+  secondaryPanel = 0 ;
+  cmdPanel = 0 ;
+  statusPanel = 0 ;
+  statusText = 0 ;
+  SetPin(FALSE) ;
+  userSpacing = space ;
+}
+
+wxEnhDialogBox::~wxEnhDialogBox(void)
+{
+}
+
+wxButton* wxEnhDialogBox::AddCmd(char *label,wxFunction fun,int tag)
+{
+Bool first_button ;
+wxButton *btn ;
+#ifndef wx_xview
+wxButton *cancel ;
+#endif
+int	ww,hh;
+
+  if (cmdPanel==0)
+  {
+    first_button = TRUE ;
+    userPanel->Fit() ;
+    if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+      panel->NewLine() ;
+    cmdPanel = new wxPanel(panel) ;
+    cmdPanel->SetButtonFont(cmd_font) ;
+    if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+    {
+      cmdPanel->SetVerticalSpacing(0) ;
+      if (userSpacing>-1)
+        cmdPanel->SetHorizontalSpacing(userSpacing) ;
+    }
+    else
+    {
+      //cmdPanel->SetHorizontalSpacing(0) ;
+      if (userSpacing>-1)
+        cmdPanel->SetVerticalSpacing(userSpacing) ;
+    }
+#ifndef wx_xview
+    if ((windowStyle&wxMASK_CANCEL)==wxCANCEL_BUTTON_FIRST)
+    {
+      cancel = new wxButton(cmdPanel,(wxFunction)CancelEnhDialog, wxSTR_BUTTON_CANCEL) ;
+      if (cancel)
+      {
+        cancel->GetSize(&ww,&hh) ;
+        if (ww>maxWidth) maxWidth = ww ;
+        if (hh>maxHeight) maxHeight = hh ;
+      }
+      if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+        cmdPanel->NewLine() ;
+    }
+#endif
+  }
+  else
+    first_button = FALSE ;
+
+  btn = new wxButton(cmdPanel,fun,label) ;
+  if (btn)
+  {
+    btn->SetClientData((char*)tag) ;
+    btn->GetSize(&ww,&hh) ;
+    if (ww>maxWidth) maxWidth = ww ;
+    if (hh>maxHeight) maxHeight = hh ;
+  }
+  if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+    cmdPanel->NewLine() ;
+#ifndef wx_xview
+    if (first_button)
+      if ((windowStyle&wxMASK_CANCEL)==wxCANCEL_BUTTON_SECOND)
+      {
+        cancel = new wxButton(cmdPanel,(wxFunction)CancelEnhDialog, wxSTR_BUTTON_CANCEL) ;
+        if (cancel)
+        {
+          cancel->GetSize(&ww,&hh) ;
+          if (ww>maxWidth) maxWidth = ww ;
+          if (hh>maxHeight) maxHeight = hh ;
+        }
+        if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+          cmdPanel->NewLine() ;
+      }
+#endif
+  return(btn) ;
+}
+
+wxButton* wxEnhDialogBox::AddCmd(wxBitmap *bitmap,wxFunction fun,int tag)
+{
+Bool first_button ;
+wxButton *btn;
+#ifndef wx_xview
+wxButton *cancel ;
+#endif
+int ww,hh ;
+
+  if (cmdPanel==0)
+  {
+    first_button = TRUE ;
+    userPanel->Fit() ;
+    if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+      panel->NewLine() ;
+    cmdPanel = new wxPanel(panel) ;
+    cmdPanel->SetButtonFont(cmd_font) ;
+    if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+    {
+      cmdPanel->SetVerticalSpacing(0) ;
+      if (userSpacing>-1)
+        cmdPanel->SetHorizontalSpacing(userSpacing) ;
+    }
+    else
+    {
+      //cmdPanel->SetHorizontalSpacing(0) ;
+      if (userSpacing>-1)
+        cmdPanel->SetVerticalSpacing(userSpacing) ;
+    }
+#ifndef wx_xview
+    if ((windowStyle&wxMASK_CANCEL)==wxCANCEL_BUTTON_FIRST)
+    {
+      cancel = new wxButton(cmdPanel,(wxFunction)CancelEnhDialog, wxSTR_BUTTON_CANCEL) ;
+      if (cancel)
+      {
+        cancel->GetSize(&ww,&hh) ;
+        if (ww>maxWidth) maxWidth = ww ;
+        if (hh>maxHeight) maxHeight = hh ;
+      }
+      if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+        cmdPanel->NewLine() ;
+    }
+#endif
+  }
+  else
+    first_button = FALSE ;
+
+  btn = new wxButton(cmdPanel,fun,bitmap) ;
+  if (btn)
+  {
+    btn->SetClientData((char*)tag) ;
+    btn->GetSize(&ww,&hh) ;
+    if (ww>maxWidth) maxWidth = ww ;
+    if (hh>maxHeight) maxHeight = hh ;
+  }
+  if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+    cmdPanel->NewLine() ;
+#ifndef wx_xview
+    if (first_button)
+      if ((windowStyle&wxMASK_CANCEL)==wxCANCEL_BUTTON_SECOND)
+      {
+        cancel = new wxButton(cmdPanel,(wxFunction)CancelEnhDialog, wxSTR_BUTTON_CANCEL) ;
+        if (cancel)
+        {
+          cancel->GetSize(&ww,&hh) ;
+          if (ww>maxWidth) maxWidth = ww ;
+          if (hh>maxHeight) maxHeight = hh ;
+        }
+        if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+          cmdPanel->NewLine() ;
+      }
+#endif
+  return(btn) ;
+}
+
+wxButton* wxEnhDialogBox::GetCmd(int number)
+{
+  if (cmdPanel)
+    return ((wxButton*)(cmdPanel->GetChild(number)));
+  else
+    return(NULL) ;
+}
+
+void wxEnhDialogBox::Show(Bool show,Bool flag)
+{
+
+  if (!show)
+  {
+#ifndef wx_xview
+    if (pinCheck)
+    {
+      if (pinCheck->GetValue())
+        return ;
+    }
+    else
+    {
+      if (pinned)
+        return ;
+    }
+#else
+    wxFrame *frame = (wxFrame*)GetParent() ;
+    Frame x_frame = (Frame)(frame->GetHandle());
+    if (xv_get(x_frame,FRAME_CMD_PUSHPIN_IN))
+      return ;
+#endif
+    if (unshow)
+    {
+    wxCommandEvent evt = 0;
+      (void)(*(unshow))(*this,evt) ;
+    }
+  }
+  if (show)
+  {
+    SetPin(flag) ;
+    SetStatus("") ; // reset previous status text
+  }
+  wxDialogBox::Show(show) ;
+}
+
+void wxEnhDialogBox::SetPin(Bool flag)
+{
+#ifdef wx_xview
+  wxFrame *frame = (wxFrame*)GetParent() ;
+  Frame x_frame = (Frame)(frame->GetHandle());
+  (void)xv_set(x_frame,FRAME_CMD_PUSHPIN_IN,flag) ;
+#else
+  if (pinCheck)
+  {
+    pinCheck->SetClientData((char*)DO_NOT_UNSHOW) ;
+    if (flag)
+    {
+      if (pinCheck->GetValue())
+      {
+        pinCheck->SetClientData((char*)DO_UNSHOW) ;
+        return ;
+      }
+    }
+    else
+    {
+      if (!pinCheck->GetValue())
+      {
+        pinCheck->SetClientData((char*)DO_UNSHOW) ;
+        return ;
+      }
+    }
+    // Change state only if needed
+    pinCheck->SetValue(flag) ;
+  pinCheck->SetClientData((char*)DO_UNSHOW) ;
+  }
+  else
+    pinned = flag ;
+#endif
+}
+
+void wxEnhDialogBox::SetStatus(char *label)
+{
+  if (statusText==NULL)
+    return ;
+  if (label==0 || *label=='\0')
+    label = "   " ;
+  statusText->SetLabel(label) ;
+}
+
+void wxEnhDialogBox::PrimaryFit(void)
+{
+long cancel = windowStyle&wxMASK_CANCEL ;
+wxButton *btn ;
+int ww,hh ;
+
+  if (cancel!=wxNO_CANCEL_BUTTON)
+  {
+    if (cmdPanel==0||cancel==wxCANCEL_BUTTON_LAST)
+    {
+      if (cmdPanel==0)
+      {
+        userPanel->Fit() ;
+        if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+          panel->NewLine() ;
+        cmdPanel = new wxPanel(panel) ;
+        cmdPanel->SetButtonFont(cmd_font) ;
+        if ((windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+        {
+          cmdPanel->SetVerticalSpacing(0) ;
+          if (userSpacing>-1)
+            cmdPanel->SetHorizontalSpacing(userSpacing) ;
+        }
+        else
+        {
+          //cmdPanel->SetHorizontalSpacing(0) ;
+          if (userSpacing>-1)
+            cmdPanel->SetVerticalSpacing(userSpacing) ;
+        }
+      }
+      btn = new wxButton(cmdPanel,(wxFunction)CancelEnhDialog, wxSTR_BUTTON_CANCEL) ;
+      if (btn)
+      {
+        btn->GetSize(&ww,&hh) ;
+        if (ww>maxWidth) maxWidth = ww ;
+        if (hh>maxHeight) maxHeight = hh ;
+      }
+      if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+        cmdPanel->NewLine() ;
+    }
+  }
+
+  
+  if ((windowStyle&wxMASK_COMMANDS)==wxRIGHT_COMMANDS)
+  {
+    int number = 0 ;
+    while ((btn=GetCmd(number++)))
+      btn->SetSize(-1,-1,maxWidth,maxHeight) ;
+  }
+
+  if (cmdPanel)
+    cmdPanel->Fit() ;
+}
+
+void wxEnhDialogBox::PreFit(void)
+{
+  PrimaryFit() ;
+  panel->NewLine() ;
+  secondaryPanel = new wxPanel(panel,-1,-1,-1,-1,0,"secondUser") ;
+}
+
+void wxEnhDialogBox::Fit(void)
+{
+
+  if (secondaryPanel==NULL)
+  {
+    PrimaryFit() ;
+  }
+  else
+  {
+    secondaryPanel->Fit() ;
+  }
+
+  panel->NewLine() ;
+  if ((windowStyle&wxMASK_STATUS)==wxSTATUS_FOOTER)
+  {
+    statusPanel = new wxPanel(panel) ;
+    statusPanel->SetVerticalSpacing(0) ;
+#ifdef wx_motif
+    // Motif provide enough spacing...
+    statusPanel->SetHorizontalSpacing(0) ;
+#endif
+    statusText = new wxMessage(statusPanel,"   ") ;
+    statusPanel->Fit() ;
+    panel->NewLine() ;
+  }
+  wxDialogBox::Fit() ;
+  if (cmdPanel && (windowStyle&wxMASK_COMMANDS)==wxBOTTOM_COMMANDS)
+    cmdPanel->Centre(wxHORIZONTAL) ;
+  if (statusPanel)
+  {
+    int fw,fh ;
+    GetClientSize(&fw,&fh) ;
+    statusPanel->SetSize(-1,-1,fw,-1) ;
+    statusText->SetSize(-1,-1,fw,-1) ;
+  }
+}
+#endif
diff --git a/src/wxmac/src/base/wx_hash.h b/src/wxmac/src/base/wx_hash.h
new file mode 100644
index 0000000..5350e24
--- /dev/null
+++ b/src/wxmac/src/base/wx_hash.h
@@ -0,0 +1,128 @@
+/*								-*- C++ -*-
+ * File:		wx_hash.h
+ * Purpose:	Basic hash table implementation
+ * Author:		Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+#ifndef wxb_hashh
+#define wxb_hashh
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#ifndef wx_xt
+    // wxWindows standard include mechanism
+    /* sccsid[] = "@(#)wx_hash.h	1.2 5/9/94" */
+#   include "wx_obj.h"
+#   include "wx_list.h"
+#endif
+
+/*
+ * A hash table is an array of user-definable size with lists
+ * of data items hanging off the array positions.  Usually there'll
+ * be a hit, so no search is required; otherwise we'll have to run down
+ * the list to find the desired item.
+*/
+
+#ifdef IN_CPROTO
+typedef       void    *wxHashTable ;
+#else
+
+class wxHashTable: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxHashTable)
+
+ public:
+  int n;
+  int current_position;
+  wxNode *current_node;
+
+  unsigned int key_type;
+  wxList **hash_table;
+
+  wxHashTable(int the_key_type = wxKEY_INTEGER, int size = 1000);
+  ~wxHashTable(void);
+
+  Bool Create(int the_key_type = wxKEY_INTEGER, int size = 1000);
+
+  // Note that there are 2 forms of Put, Get.
+  // With a key and a value, the *value* will be checked
+  // when a collision is detected. Otherwise, if there are
+  // 2 items with a different value but the same key,
+  // we'll retrieve the WRONG ONE. So where possible,
+  // supply the required value along with the key.
+  // In fact, the value-only versions make a key, and still store
+  // the value. The use of an explicit key might be required
+  // e.g. when combining several values into one key.
+  // When doing that, it's highly likely we'll get a collision,
+  // e.g. 1 + 2 = 3, 2 + 1 = 3.
+
+  // key and value are NOT necessarily the same
+  void Put(long key, long value, wxObject *object);
+  void Put(long key, char *value, wxObject *object);
+
+  // key and value are the same
+  void Put(long value, wxObject *object);
+  void Put(const char *value, wxObject *object);
+
+  // key and value not the same
+  wxObject *Get(long key, long value);
+  wxObject *Get(long key, char *value);
+
+  // key and value are the same
+  wxObject *Get(long value);
+  wxObject *Get(const char *value);
+
+  // Deletes entry and returns data if found
+  wxObject *Delete(long key);
+  wxObject *Delete(const char *key);
+
+  wxObject *Delete(long key, int value);
+  wxObject *Delete(long key, char *value);
+
+  // Construct your own integer key from a string, e.g. in case
+  // you need to combine it with something
+  long MakeKey(const char *string);
+
+  // Way of iterating through whole hash table (e.g. to delete everything)
+  // Not necessary, of course, if you're only storing pointers to
+  // objects maintained separately
+
+  void BeginFind(void);
+  wxNode *Next(void);
+
+  void DeleteContents(Bool flag);
+  void Clear(void);
+
+};
+
+#if WXGARBAGE_COLLECTION_ON
+
+/* Special hash table implementation for widgets.
+ * This is part of an experimental garbage collection system
+ * for wxWindows, by Matthew Flatt: use with caution.
+ */
+class wxNonlockingHashTable
+{
+  struct Bucket *buckets;
+  long numbuckets, numwidgets;
+ public:
+  wxNonlockingHashTable(void);
+  ~wxNonlockingHashTable();
+  void Put(long widget, wxObject *object);
+  wxObject *Get(long widget);
+  void Delete(long widget);
+  /* MATTHEW: New methods */
+  void DeleteObject(wxObject *object);
+  inline void Append(long w, wxObject *o) { Put(w, o); }
+  inline wxObject *Find(long w) { return Get(w); }
+};
+
+#endif
+
+#endif // IN_CPROTO
+#endif // wxb_hashh
diff --git a/src/wxmac/src/base/wxspline.cc b/src/wxmac/src/base/wxspline.cc
new file mode 100644
index 0000000..727064a
--- /dev/null
+++ b/src/wxmac/src/base/wxspline.cc
@@ -0,0 +1,539 @@
+/*
+ * File:      wxspline.cc
+ * Purpose:     
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wxspline.cc,v 1.2 1994/08/14 21:34:01 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+// Has to be a comment as this file is #include\'d from wb_dc.cc
+/* static const char sccsid[] = "@(#)wxspline.cc        1.3 5/9/94"; */
+
+/*
+ * Artificial Intelligence Applications Institute,                     
+ * The University of Edinburgh
+ */
+
+
+/*
+ *  Cubic B spline drawing code based on:
+ *  Computer Graphics - A Programming Approach
+ *  Steven Harrington (2nd edition)
+ *  Published by McGraw-Hill
+ *  Chapter 11 p400 - 417
+
+ *  A B-spline is an interpolation curve that does not necessarily pass
+ *  through all the sample points. This code implements a cubic B-spline
+ *  function. The cubic B-spline functions interpolate over 4 sample
+ *  points.
+
+ *  The mathematical function that defines the curve can be expressed in
+ *  parametric form as:
+ * 
+ *            X = fX(u) = sum(i to n) XiBi(u)
+ *            Y = fY(u) = sum(i to n) YiBi(u)
+ *
+ *  where Bi(u) is called a blending function.
+ *
+ *  The function DrawSpline defines the blending functions for 
+ *  a cubic B-spline, which are cubic polynomials in u. Special blending
+ *  functions are required for the first, second, next to last and last
+ *  section of the curve (a section is defined by 2 of the sample points),
+ *  as well as the standard blending function. These special blending 
+ *  functions are needed because of the requirement that the spline 
+ *  must pass through the first and last sample points.
+ *
+ *  DrawSpline works by calculating points on the spline
+ *  (at various values of u) and then drawing straight lines
+ *  between the points to approximate the spline. Points on the spline 
+ *  are calculated for each section of the curve, moving along one 
+ *  section at a time until we reach the end of the sample points.
+ */
+
+static wxPoint *startPoint = NULL;
+static wxPoint *samplePoints = NULL;
+
+// function prototype
+static void allocBlendArrays (double **mainBlend[],
+			      double **firstBlend[],
+			      double **secondBlend[],
+			      double **penultimateBlend[],
+			      double **lastBlend[],
+			      int nSegments,
+			      int numberOfLines);
+
+// function prototype
+static void initBSpline (int numberOfLines,
+			 double *mainBlend[],
+			 double *firstBlend[],
+			 double *secondBlend[],
+			 double *penultimateBlend[],
+			 double *lastBlend[]);
+
+// function prototype
+static void MakeCurve (wxbDC * dc, wxPoint samplePoints[],
+		       int numberOfLines,
+		       double *blendFunction[],
+		       wxPoint startPoint[]);
+
+// function prototype
+static void nextSection (wxPoint samplePoints[]);
+
+// function prototype
+static void nextSamplePoint (int &currentPoint,
+			     wxPoint samplePoints[],
+			     wxPoint points[]);
+
+/*************************************************************************
+ * This is the main function that draws the spline for a given set of
+ * sample points. It's arguments are:
+ *
+ *   1) dc -- the device on which to draw the spline,
+ *   2) nPoints -- the number of sample points
+ *   3) an array of structures, each structure containing a x and y coordinate
+ *      of a sample point. The array is of size nPoints -- this is
+ *      guaranteed by the calling function -- so no checking is done.
+ */
+
+void wxbDC::DrawSpline (wxList * list)
+{
+  wxPoint *points = new wxPoint[list->Number ()];
+  int i = 0;
+
+  for(wxNode *node = list->First (); node; node = node->Next())
+    {
+      wxPoint *point = (wxPoint *) node->Data ();
+      points[i].x = point->x;
+      points[i++].y = point->y;
+    }
+  DrawSpline (i, points);
+  delete[]points;
+}
+
+void wxbDC::DrawSpline (int nPoints, wxPoint points[])
+{
+/*
+   First declare the number of line segments per section, to make
+   it easy to change this value if more line segments are required
+   to better draw the spline. When numberOfLines = 3, you can see that
+   the spline is made up of straight line segments, but when 
+   numberOfLines = 30, the spline looks smooth.
+ */
+
+  const int numberOfLines = 30;
+
+/* declare the array to hold the x and y coordinates for the start of
+   each spline segment that is drawn. startPoint[0].x and startPoint[0].y
+   are constantly updated, after the spline segment is drawn, to be the 
+   end of the last drawn spline segment -- see function MakeCurve.
+ */
+
+  startPoint = new wxPoint[1];
+
+/* declare the array to hold the sample points that are used to calculate
+   the x and y coordinates for the spline segments. To draw a spline between
+   any 2 sample points actually requires taking into account 4 sample points
+ */
+
+  samplePoints = new wxPoint[4];
+
+// declare the arrays to hold the blending functions
+
+  double **mainBlend = NULL;
+  double **firstBlend = NULL;
+  double **secondBlend = NULL;
+  double **penultimateBlend = NULL;
+  double **lastBlend = NULL;
+
+// declare the second dimension of the array, which is due to the number
+  // of sample points taken into account when drawing a spline
+
+  const int nSegments = 4;
+
+// Allocate memory for the blending function arrays
+
+  allocBlendArrays (&mainBlend, &firstBlend, &secondBlend,
+		    &penultimateBlend, &lastBlend,
+		    nSegments, numberOfLines);
+
+// instantiate the blending function arrays with the appropriate values
+
+  initBSpline (numberOfLines, mainBlend, firstBlend,
+	       secondBlend, penultimateBlend, lastBlend);
+
+/* 0, 1 and 2 sample points are special cases and are handled separately */
+
+  int currentPoint = 0;
+
+  if (nPoints <= 1)
+    {
+      return;
+    }
+  if (nPoints == 2)
+    {
+      startPoint[0].x = points[0].x;
+      startPoint[0].y = points[0].y;
+      float x = points[1].x;
+      float y = points[1].y;
+      DrawLine (startPoint[0].x, startPoint[0].y, x, y);
+    }
+
+/* 3 - 7 sample points are handled by repeating the first and last point
+ * an equal number of times, such that the number of sample points becomes 
+ * >= 8. The reason for this is that the algorithm really expects a minimum
+ * of 8 sample points.
+ * 
+ * Hence the array samplePoints will contain repetitions of points in the
+ * array called points (which are the actual sample points that the function
+ * is called with.
+ */
+
+  if (nPoints == 3)
+    {
+      currentPoint = 0;
+      startPoint[0].x = points[0].x;
+      startPoint[0].y = points[0].y;
+      for (int i = 0; i < 4; i++)
+	{
+	  samplePoints[i].x = points[0].x;
+	  samplePoints[i].y = points[0].y;
+	}
+      MakeCurve (this, samplePoints, numberOfLines, firstBlend, startPoint);
+      nextSection (samplePoints);
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 secondBlend, startPoint);
+      nextSection (samplePoints);
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 mainBlend, startPoint);
+      nextSection (samplePoints);
+// reached the last sample point, so compensate for the fact that
+      // currentPoint will be incremented by 1 in the function nextSamplePoint
+      currentPoint = currentPoint - 1;
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 mainBlend, startPoint);
+      nextSection (samplePoints);
+      currentPoint = currentPoint - 1;
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 penultimateBlend, startPoint);
+      nextSection (samplePoints);
+      currentPoint = currentPoint - 1;
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 lastBlend, startPoint);
+    }
+
+  if (nPoints >= 4 && nPoints < 8)
+    {
+      currentPoint = 0;
+      startPoint[0].x = points[0].x;
+      startPoint[0].y = points[0].y;
+      for (int i = 0; i < 3; i++)
+	{
+	  samplePoints[i].x = points[0].x;
+	  samplePoints[i].y = points[0].y;
+	}
+      samplePoints[3].x = points[1].x;
+      samplePoints[3].y = points[1].y;
+      currentPoint = currentPoint + 1;
+      MakeCurve (this, samplePoints, numberOfLines, firstBlend, startPoint);
+      nextSection (samplePoints);
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 secondBlend, startPoint);
+      nextSection (samplePoints);
+      for (int j = 0; j < (nPoints - 3); j++)
+	{
+	  nextSamplePoint (currentPoint, samplePoints, points);
+	  MakeCurve (this, samplePoints, numberOfLines,
+		     mainBlend, startPoint);
+	  nextSection (samplePoints);
+	}
+// reached the last sample point, so compensate for the fact that
+      // currentPoint will be incremented by 1 in the function nextSamplePoint
+      currentPoint = currentPoint - 1;
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 penultimateBlend, startPoint);
+      nextSection (samplePoints);
+      currentPoint = currentPoint - 1;
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 lastBlend, startPoint);
+    }
+  if (nPoints >= 8)
+    {
+      currentPoint = 0;
+      startPoint[0].x = points[0].x;
+      startPoint[0].y = points[0].y;
+      for (int i = 0; i < 4; i++)
+	{
+	  samplePoints[i].x = points[i].x;
+	  samplePoints[i].y = points[i].y;
+	}
+      currentPoint = currentPoint + 3;
+      MakeCurve (this, samplePoints, numberOfLines, firstBlend, startPoint);
+      nextSection (samplePoints);
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 secondBlend, startPoint);
+      nextSection (samplePoints);
+      while (currentPoint < (nPoints - 3))
+	{
+	  nextSamplePoint (currentPoint, samplePoints, points);
+	  MakeCurve (this, samplePoints, numberOfLines,
+		     mainBlend, startPoint);
+	  nextSection (samplePoints);
+	}
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 penultimateBlend, startPoint);
+      nextSection (samplePoints);
+      nextSamplePoint (currentPoint, samplePoints, points);
+      MakeCurve (this, samplePoints, numberOfLines,
+		 lastBlend, startPoint);
+    }
+}
+
+
+
+/*************************************************************************
+ * This function alocates memory for a blending function array
+ */
+
+static void 
+allocArray (double ***ar, int nSegments, int numberOfLines)
+{
+  *ar = new double *[nSegments];
+  for (int i = 0; i < nSegments; i++)
+    (*ar)[i] = new double[numberOfLines];
+}
+
+/*************************************************************************
+ * This function alocates memory for all the blending function arrays
+ */
+
+static void 
+allocBlendArrays (double **mainBlend[],
+		  double **firstBlend[],
+		  double **secondBlend[],
+		  double **penultimateBlend[],
+		  double **lastBlend[],
+		  int nSegments,
+		  int numberOfLines)
+{
+  allocArray (mainBlend, nSegments, numberOfLines);
+  allocArray (firstBlend, nSegments, numberOfLines);
+  allocArray (secondBlend, nSegments, numberOfLines);
+  allocArray (penultimateBlend, nSegments, numberOfLines);
+  allocArray (lastBlend, nSegments, numberOfLines);
+}
+
+/*************************************************************************
+ * This function initialise the spline blending function arrays.
+ * It's arguments are:
+ *
+ * 1) numberOfLines -- the number of segment lines to use to draw
+ *                     the spline between two sample points.
+ *	               This is a set at the top of the file.
+ * 2) - 6) Blending function arrays of size 4 by numberOfLines.
+ *         The reason the first array dimension is 4 is that 4 sample
+ *         points are required by this algorithm to calculate
+ *         the x and y coordinates of points on the spline to be drawn.
+ *	   
+ *         The values in these arrays are constant, irrespective of
+ *	   the sample points.
+ */
+
+static void 
+initBSpline (int numberOfLines,
+	     double *mainBlend[],
+	     double *firstBlend[],
+	     double *secondBlend[],
+	     double *penultimateBlend[],
+	     double *lastBlend[])
+
+/*
+ * The cubic B-spline blending function interpolates over 4 sample points
+ * Thus in the code below the first index of the the Blending function array,
+ * is either 0,1,2,3. The second index of the blending function is related 
+ * to how many line segments are used to draw the spline for two sample
+ * points (that is in a section of the spline).
+ */
+
+{
+  for (int i = 0; i < numberOfLines; i++)
+    {
+      double u = (double) (i + 1) / numberOfLines;
+      firstBlend[0][i] = pow (1.0 - u, 3);
+      firstBlend[3][i] = pow (u, 3) / 6.0;
+      firstBlend[2][i] = ((3.0 / 2.0) - (11.0 * u / 12.0))
+	* pow (u, 2);
+      firstBlend[1][i] = 1.0 - firstBlend[0][i]
+	- firstBlend[2][i]
+	- firstBlend[3][i];
+
+      secondBlend[0][i] = firstBlend[0][i] / 4.0;
+      secondBlend[3][i] = firstBlend[3][i];
+      secondBlend[2][i] = (((1 - u) * u + 1.0) * u + 1.0 / 3.0) / 2.0;
+      secondBlend[1][i] = 1.0 - secondBlend[0][i]
+	- secondBlend[2][i]
+	- secondBlend[3][i];
+
+      mainBlend[0][i] = firstBlend[0][i] / 6.0;
+      mainBlend[3][i] = firstBlend[3][i];
+      mainBlend[2][i] = secondBlend[2][i];
+      mainBlend[1][i] = 1.0 - mainBlend[0][i]
+	- mainBlend[2][i]
+	- mainBlend[3][i];
+
+      int j = numberOfLines - i - 2;
+/*  -2 because both i and j are array subscripts and go from 0 rather than 
+ *  from 1, as they do in the algorithm. 
+ *
+ *  Having j >= 0 lets through all values of j except the last, which
+ *  is the (numberOfLines - 1)th index, like the algorithm does.
+ */
+      if (j >= 0)
+	{
+	  penultimateBlend[0][j] = secondBlend[3][i];
+	  penultimateBlend[1][j] = secondBlend[2][i];
+	  penultimateBlend[2][j] = secondBlend[1][i];
+	  penultimateBlend[3][j] = secondBlend[0][i];
+
+	  lastBlend[0][j] = firstBlend[3][i];
+	  lastBlend[1][j] = firstBlend[2][i];
+	  lastBlend[2][j] = firstBlend[1][i];
+	  lastBlend[3][j] = firstBlend[0][i];
+	}
+    }
+
+  penultimateBlend[0][numberOfLines - 1] = 0.0;
+  penultimateBlend[1][numberOfLines - 1] = 1.0 / 6.0;
+  penultimateBlend[2][numberOfLines - 1] = 7.0 / 12.0;
+  penultimateBlend[3][numberOfLines - 1] = 1.0 / 4.0;
+
+  lastBlend[0][numberOfLines - 1] = 0.0;
+  lastBlend[1][numberOfLines - 1] = 0.0;
+  lastBlend[2][numberOfLines - 1] = 0.0;
+  lastBlend[3][numberOfLines - 1] = 1.0;
+}
+
+/*************************************************************************
+ *  This function draws the spline from the startPoint (which will be the
+ *  last calculated spline point for the previous sample section), and
+ *  draws numberOfLines spline segments.
+ *
+ *  It's arguments are:
+ *
+ *  1) dc -- the device on which to draw the spline
+ *  2) samplePoints[4] -- the 4 element array of sample points for the
+ *                        current spline section
+ *  3) numberOfLines -- number of segment lines per spline section
+ *  4) blendFunction -- the particular blend function array which applies
+ *                      for this section of the spline. There are
+ *  		        5 blend function arrays, which are initialised
+ * 		        in function initBSpline.
+ *  5) startPoint -- the 1 element array which holds the x and y 
+ *                   coordinates of the point where this spline is to
+ * 		     drawn from -- this is updated in the function such
+ *		     that the coordinates are always the end coordinates
+ *		     of the spline so far.
+ */
+
+static void 
+MakeCurve (wxbDC * dc, wxPoint samplePoints[],
+	   int numberOfLines,
+	   double *blendFunction[],
+	   wxPoint startPoint[])
+{
+  for (int j = 0; j < numberOfLines; j++)
+    {
+      double x = 0.0;
+      double y = 0.0;
+      for (int i = 0; i < 4; i++)
+	{
+	  x = x + samplePoints[i].x * blendFunction[i][j];
+	  y = y + samplePoints[i].y * blendFunction[i][j];
+	}
+      dc->DrawLine ((float) startPoint[0].x, (float) startPoint[0].y, (float) x, (float) y);
+      startPoint[0].x = (float) x;
+      startPoint[0].y = (float) y;
+    }
+}
+
+/*************************************************************************
+ *  This function advances the sample points, being used to determine
+ *  the spline curve, by 1. The function nextSamplePoint (below) gets
+ *  the new sample point.
+ *
+ *  It's argument is:
+ *
+ *  1) samplePoints[4] -- the 4 element array of sample points for the
+ *                        current spline section
+ */
+
+static void 
+nextSection (wxPoint samplePoints[])
+{
+  for (int i = 0; i < 3; i++)
+    {
+      samplePoints[i].x = samplePoints[i + 1].x;
+      samplePoints[i].y = samplePoints[i + 1].y;
+    }
+}
+
+/*************************************************************************
+ *  This function gets the next sample point in order to calculate
+ *  the next section of the spline curve.
+ *
+ *  It's arguments are:
+ *
+ *  1) currentPoint -- a variable which holds the index number to the
+ *                     current array element in points (the array in which all
+ *		       the sample points are held). The current array element
+ *		       is the sample point that we have got to in points[].
+ *
+ *  2) samplePoints -- the 4 element array of sample points for the
+ *                     current spline section
+ *   3) points -- the nPoints size array, that hold the sample points
+ *	 
+ */
+
+static void 
+nextSamplePoint (int &currentPoint,
+		 wxPoint samplePoints[], wxPoint points[])
+{
+
+// move on to next sample point, and put this as the 4th element in
+  // the samplePoints array
+  currentPoint = currentPoint + 1;
+  samplePoints[3].x = points[currentPoint].x;
+  samplePoints[3].y = points[currentPoint].y;
+}
+
+#if USE_POSTSCRIPT
+#include "wx_dcps.h"
+
+void wxPostScriptDC::
+DrawSpline (float x1, float y1, float x2, float y2, float x3, float y3)
+{
+  wxDC::DrawSpline (x1, y1, x2, y2, x3, y3);
+}
+
+void wxPostScriptDC::DrawSpline (wxList * points)
+{
+  wxDC::DrawSpline (points);
+}
+
+void wxPostScriptDC::DrawSpline (int n, wxPoint points[])
+{
+  wxDC::DrawSpline (n, points);
+}
+
+#endif
diff --git a/src/wxmac/src/base/wxstring.cc b/src/wxmac/src/base/wxstring.cc
new file mode 100644
index 0000000..8822500
--- /dev/null
+++ b/src/wxmac/src/base/wxstring.cc
@@ -0,0 +1,702 @@
+/*
+ * File:    wxstring.cc
+ * Purpose: simple string class 
+ * Author:  Stefan (steve) Hammes (partly Julian Smart)
+ * Created: 1994
+ * Updated:
+ * Copyright:   (c) 1994
+ */
+
+/* sccsid[] = "%W% %G%" */
+
+// #include "wx.h" // Uncomment this line for Borland precomp. headers to work
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+
+// If not MS C++, don't include wx.h: we'll just include
+// the minimum set of files.
+// If MS C++, we'll use a precompiled header instead.
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <string.h>
+#include "wxstring.h"
+#ifdef wx_mac
+#ifndef isascii					// if not a macro
+#define isascii(C) ((C) > 0 && (C) <0x7F)
+#endif
+#endif
+extern char *copystring(const char *);
+
+#define   wxToUpper(C)      (((C) >= 'a' && (C) <= 'z')? (C) - 'a' + 'A': (C))
+#define   wxToLower(C)      (((C) >= 'A' && (C) <= 'Z')? (C) - 'A' + 'a': (C))
+
+// the following added by steve, 03.09.94
+#ifndef wxASSERT
+// #include <assert.h>
+// the following macro allows more detailed error messages with assert.
+// the reason should be a string constant
+// e.g.: wxASSERT(s!=NULL,"String passed in function XYZ was NULL pointer")
+// #define wxASSERT(expr,reason) assert((expr)&&(reason))
+// JACS: not implemented yet, for portability :-)
+#define wxASSERT(expr,reason)
+#endif
+
+wxString::wxString()
+{
+  stringData_ = NULL;
+}
+
+wxString::wxString(const wxString& cs)
+{
+  const char *oldData = cs.GetData();
+  if (oldData)
+    stringData_ = copystring(oldData);
+  else stringData_ = NULL;
+}
+
+wxString::wxString(char c)
+{                        
+  stringData_ = new char[2];
+  stringData_[0] = c;
+  stringData_[1] = '\0';
+}
+
+// this constructor is only used for non-constant char * init
+// for constant char * init the sprintf-constructor is used,
+// because otherwise there would be inambiguities between
+// wxString(char *s) and wxString(const char *fmt, ...)                      
+wxString::wxString(char *s)
+{
+  if (s)
+    stringData_ = copystring(s);
+  else
+    stringData_ = NULL;
+}
+
+// generate a string (sprintf-like)
+
+// used also for normal construction 'wxString a("hello");'
+// fmt == NULL is allowed!
+wxString::wxString(const char *fmt, ...) // formatted construction
+{
+    va_list args;
+
+    va_start(args,fmt);
+    if(fmt==NULL){
+      stringData_ = NULL;
+    }else{
+      char tempString[512];
+      vsprintf(tempString,fmt,args);
+      stringData_ = copystring(tempString);
+    }
+    va_end(args);
+}
+
+int wxString::sprintf(const char *fmt, ...)
+{
+    va_list args;
+    int result;
+
+    va_start(args,fmt);
+    wxASSERT(fmt!=NULL,"int wxString::sprintf(const char *fmt, ...): NULL 'printf' format string");
+    char tempString[512];
+    result = (int)vsprintf(tempString,fmt,args);
+    SetData(copystring(tempString));
+    va_end(args);
+    return(result);
+}
+
+wxString::~wxString(void)
+{
+  if (stringData_)
+    delete[] stringData_;
+}
+
+/*
+// input
+char *wxString::ReadLine(FILE *inputFile)
+{
+  wxASSERT(inputFile!=NULL,"char *wxString::ReadLine(FILE *inputFile): NULL inputFile");
+  char tempString[512];
+  char *result = fgets(tempString,sizeof(tempString),inputFile);
+  if(result!=NULL){
+    tempString[strlen(tempString)-1] = '\0'; // remove \n
+    SetData(copystring(tempString));
+  }
+  return(result);
+}
+*/
+
+// assignment
+
+wxString& wxString::operator =(const wxString& cs)
+{
+  *this = cs.GetData();
+  return(*this);
+}
+
+wxString& wxString::operator =(const char *cs)
+{
+  if (stringData_)
+    delete[] stringData_;
+  const char *oldData = cs;
+  if (oldData)
+    stringData_ = copystring(oldData);
+  else stringData_ = NULL;
+  return(*this);
+}
+
+wxString& wxString::operator+=(const wxString& cs)
+{
+//  wxASSERT(cs!=NULL,"wxString& wxString::operator+=(const wxString *cs): NULL argument");
+  Append(cs);
+  return(*this);
+}
+
+wxString& wxString::operator+=(const char *cs)
+{
+//  wxASSERT(cs!=NULL,"wxString& wxString::operator+=(const char *cs): NULL argument");
+  Append(cs);
+  return(*this);
+}
+
+// operators
+
+wxString wxString::operator +(const wxString& cs) const
+{
+  return(*this + cs.GetData());
+}
+
+wxString wxString::operator +(const char *cs) const
+{
+  const char *s = GetData();
+  if (!cs && !s)
+  {
+    wxString string;
+    return(string);
+  }
+  else if (!cs && s)
+  {
+    wxString string((char *)s);
+    return(string);
+  }
+  else if (cs && !s)
+  {
+    wxString string((char *)cs);
+    return(string);
+  }
+  else
+  {
+    char *buf = new char[strlen(cs) + strlen(s) + 1];
+    strcpy(buf, s);
+    strcat(buf, cs);
+    wxString string;
+    string.SetData(buf);
+    return(string);
+  }
+}
+
+// Indexing operators:
+char& wxString::operator[](int i)     // Indexing with bounds checking
+{
+  assertElement(i);
+  return(stringData_[i]);
+}
+
+char& wxString::operator()(size_t i)     // Indexing without bounds checking
+{
+  return(stringData_[i]);
+}
+
+wxString  wxString::operator()(size_t start, size_t len) const      // Sub-string operator
+{
+  wxString string;
+  const char *s = GetData();
+  if (!s || len==0)
+    return(string);
+  size_t mylen = strlen(s);
+  size_t to = start+len-1; // up to this position 
+  if (start >= mylen) // there is nothing to return
+    return(string);
+  if (to >= mylen)
+    to = mylen - 1; // copy to end of string
+  char *buf = new char[to - start + 2]; // make a buffer (+2 is OK!)
+  size_t i;
+  for (i = start; i <= to; i++)
+    buf[i-start] = s[i];
+  buf[i-start] = 0;
+  string.SetData(buf);
+  return(string);
+}
+
+wxString wxString::SubString(const char* pat, size_t start) const 
+{
+  size_t i = Index(pat,start); // search pattern
+  if(i==NO_POS){
+    wxString string;
+    return(string);
+  }else{
+    return((*this)(i,strlen(pat)));
+  }
+}
+
+wxString wxString::SubString(const wxString& pat, size_t start) const
+{
+  return(this->SubString(pat.GetData(),start));
+}
+
+wxString& wxString::Append(const char* cs)
+{
+//  wxASSERT(cs!=NULL,"wxString& wxString::Append(const char* cs): NULL argument");
+  const char *s = GetData();
+  char *buf=NULL;
+  if(s==NULL){
+    buf = new char[strlen(cs)+1];
+    strcpy(buf,cs);
+  }else{
+    buf = new char[strlen(cs)+strlen(s)+1];
+    strcpy(buf,s);
+    strcat(buf,cs);
+  }
+  SetData(buf);
+  return(*this);
+}
+
+wxString& wxString::Append(const wxString& cs)
+{
+  return(Append(cs.GetData()));
+}
+
+wxString& wxString::Append(char c, size_t rep)   // Append c rep times
+{
+  const char *s = GetData();
+  char *buf=NULL;
+  if(s==NULL){
+    buf = new char[rep+1];
+    char *p=buf;
+    for(size_t i=0; i<rep; i++, p++) *p = c;
+    *p = '\0';
+  }else{                       
+    size_t len = strlen(s);
+    buf = new char[len+rep+1];
+    strcpy(buf,s);
+    char *p=buf+len;
+    for(size_t i=0; i<rep; i++, p++) *p = c;
+    *p = '\0';
+  }
+  SetData(buf);
+  return(*this);
+}
+
+
+// String comparisons
+int wxString::CompareTo(const char* cs2, caseCompare cmp) const
+{
+  const char* cs1 = GetData();
+  if(cs2==NULL){
+    return(cs1==cs2?0:1);
+  }
+  size_t len = Length();
+  size_t i = 0;
+  if (cmp == exact) {
+    for (; cs2[i]; ++i) {
+      if (i == len) return -1;
+      if (cs1[i] != cs2[i]) return ((cs1[i] > cs2[i]) ? 1 : -1);
+    }
+  } else {                  // ignore case
+    for (; cs2[i]; ++i) {
+      if (i == len) return -1;
+      char c1 = (char)wxToUpper((unsigned char)cs1[i]);
+      char c2 = (char)wxToUpper((unsigned char)cs2[i]);
+      if (c1 != c2) return ((c1 > c2)? 1 : -1);
+    }
+  }
+  return (i < len) ? 1 : 0;
+}
+
+int wxString::CompareTo(const wxString& st, caseCompare cmp) const
+{
+  return(CompareTo(st.GetData(),cmp));
+}
+
+Bool wxString::Contains(const char* pat, caseCompare cmp) const
+{
+  wxASSERT(pat!=NULL,"Bool wxString::Contains(const char* pat, caseCompare cmp) const: NULL argument");
+  return(Index(pat,0,cmp)!=NO_POS);
+}
+
+Bool wxString::Contains(const wxString& pat, caseCompare cmp) const
+{
+  return(Index(pat,0,cmp)!=NO_POS);
+}
+
+
+wxString wxString::Copy() const
+{
+  wxString string(*this);
+  return(string);
+}
+
+size_t wxString::First(char c) const
+{
+  const char *s = GetData();
+  if(s == NULL){
+    return(NO_POS);
+  }else{
+    const char *pos = strchr(s,c);
+    if(pos==NULL){
+      return(NO_POS);
+    }else{
+      return(pos-s);
+    }
+  }
+}
+
+size_t wxString::First(const char* cs) const
+{
+  wxASSERT(cs!=NULL,"size_t wxString::First(const char* cs) const: NULL argument");
+  const char *s = GetData();
+  if(s==NULL || strlen(cs)==0){
+    return(NO_POS);
+  }else{
+    const char *pos = strstr(s,cs);
+    if(pos==NULL){
+      return(NO_POS);
+    }else{
+      return(pos-s);
+    }
+  }
+}
+
+size_t wxString::First(const wxString& cs) const
+{
+  return(First(cs.GetData()));
+}
+
+size_t wxString::Last(const char* cs) const
+{
+  wxASSERT(cs!=NULL,"size_t wxString::Last(const char* cs) const: NULL argument");
+  const char *s = GetData();
+  if(s==NULL || strlen(cs)==0){
+    return(NO_POS);
+  }else{
+    char *pos = strstr(s,cs);
+    if(pos==NULL){ // it's absolutely not there!
+      return(NO_POS);
+    }else{
+      // try to search the 'cs' again
+      while(TRUE){
+        const char *lastPos = pos; // remember pos
+        pos = strstr(pos+1,cs); // search again (after the pattern)
+        if(pos==NULL) return(lastPos-s); // this WILL be reached!
+      }
+    }
+  }
+}
+
+size_t wxString::Last(const wxString& cs) const
+{
+  return(Last(cs.GetData()));
+}
+
+size_t wxString::Last(char c) const
+{
+  const char *s = GetData();
+  if(s == NULL){
+    return(NO_POS);
+  }else{
+    const char *pos = strrchr(s,c);
+    if(pos==NULL){
+      return(NO_POS);
+    }else{
+      return(pos-s);
+    }
+  }
+}
+
+// compare memory case-insensitive
+static int mem_insensitive_equal(const char* p, const char* q, size_t n)
+{
+  while (n--){
+    if (wxToUpper((unsigned char)*p) != wxToUpper((unsigned char)*q)) return FALSE;
+    p++; q++;
+  }
+  return TRUE;
+}
+
+// Pattern Matching:
+size_t wxString::Index(const char* pattern, size_t startIndex, caseCompare cmp) const
+{
+  wxASSERT(pattern!=NULL,"size_t wxString::Index(const char* pattern, size_t startIndex, caseCompare cmp) const: NULL argument");
+  size_t slen = Length();
+  size_t plen = strlen(pattern);
+  if (slen < startIndex + plen) return NO_POS;
+  if (plen == 0) return startIndex;
+  slen -= startIndex + plen;
+  const char* sp = GetData() + startIndex;
+  if (cmp == exact) {
+    char first = *pattern;
+    for (size_t i = 0; i <= slen; ++i)
+      if (sp[i] == first && memcmp(sp+i+1, pattern+1, plen-1) == 0)
+        return i + startIndex;
+  } else {
+    int first = wxToUpper((unsigned char) *pattern);
+    for (size_t i = 0; i <= slen; ++i)
+      if (wxToUpper((unsigned char) sp[i]) == first &&
+        mem_insensitive_equal(sp+i+1, pattern+1, plen-1)) return i + startIndex;
+  }
+  return NO_POS;
+}
+  
+size_t wxString::Index(const wxString& cs, size_t i, caseCompare cmp) const
+{
+  return(Index(cs.GetData(),i,cmp));
+}
+
+              
+wxString& wxString::Insert(size_t pos, const char* cs)
+{
+  wxASSERT(cs!=NULL,"wxString& wxString::Insert(size_t pos, const char* cs): NULL argument");
+  const char *s = GetData();
+  wxASSERT(s != NULL,"wxString& wxString::Insert(size_t pos, const char* cs): self is NULL");
+  size_t len = strlen(s);
+  wxASSERT(pos < len,"wxString& wxString::Insert(size_t pos, const char* cs): insert at undefined position");
+  char *buf = new char[len+strlen(cs)+1];
+  if(pos==0){ // Insert at beginning
+    strcpy(buf,cs);
+    strcat(buf,s);
+  }else{
+    strncpy(buf,s,pos); // copy first part
+    strcpy(buf+pos,cs); // copy new part
+    strcat(buf,s+pos); // copy rest
+  }
+  SetData(buf);
+  return(*this);
+}
+
+wxString& wxString::Insert(size_t pos, const wxString& cs)
+{
+  return(Insert(pos,cs.GetData()));
+}
+
+Bool wxString::IsAscii() const
+{
+  const char *s = GetData();
+  wxASSERT(s != NULL,"Bool wxString::IsAscii() const: self is NULL");
+  while(*s){
+    if(!isascii(*s)) return(FALSE);
+    s++;
+  }
+  return(TRUE);
+}
+  
+Bool wxString::IsWord() const
+{
+  const char *s = GetData();
+  wxASSERT(s != NULL,"Bool wxString::IsWord() const: self is NULL");
+  while(*s){
+    if(!isalpha(*s)) return(FALSE);
+    s++;
+  }
+  return(TRUE);
+}
+  
+Bool wxString::IsNumber() const
+{
+  const char *s = GetData();
+  wxASSERT(s != NULL,"Bool wxString::IsNumber() const: self is NULL");
+  while(*s){
+    if(!isdigit(*s)) return(FALSE);
+    s++;
+  }
+  return(TRUE);
+}
+  
+size_t wxString::Length() const
+{
+  const char *s = GetData();
+  wxASSERT(s != NULL,"size_t wxString::Length() const: self is NULL");
+  return(strlen(s));
+}
+
+wxString& wxString::Prepend(const char* cs)           // Prepend a character string
+{                      
+  wxASSERT(cs!=NULL,"wxString& wxString::Prepend(const char* cs): NULL argument");
+  return(Insert(0,cs));
+}
+
+wxString& wxString::Prepend(const wxString& cs)
+{
+  return(Prepend(cs.GetData()));
+}
+
+wxString& wxString::Prepend(char c, size_t rep)  // Prepend c rep times
+{
+  // construct repetition of c
+  char *temp = new char[rep+1];
+  size_t i;
+  for(i=0; i<rep; i++) temp[i]=c;
+  temp[i]='\0';
+  const char *s=GetData();
+  if(s == NULL){
+    SetData(temp);
+  }else{
+    char *buf = new char[strlen(s)+rep+1];
+    strcpy(buf,temp);
+    strcat(buf,s);
+    delete [] temp;
+    SetData(buf);
+  }
+  return(*this);
+}
+
+wxString& wxString::Remove(size_t pos)         // Remove pos to end of string
+{
+  if(pos<Length()){
+    // only then there is a change
+    char *s = stringData_;
+    s[pos] = '\0'; // shorten string
+    stringData_ = new char[pos+1];
+    strcpy(stringData_,s); // copy rest of string
+    delete[] s; // free old string 
+  }
+  return(*this);
+}
+
+wxString& wxString::Remove(size_t pos, size_t n)       // Remove n chars starting at pos
+{
+  const char *s = GetData();
+  wxASSERT(s != NULL,"Bool wxString::Remove: self is NULL");
+  size_t len=Length();
+  if(pos<len){
+    if(pos+n>=len){
+      Remove(pos); // remove until end
+    }else{
+      char *buf = new char[len-n];
+      char *p=buf;
+      for(size_t i=0; i<pos; i++) *p++ = *s++; // put first part into buffer
+      s += n; // skip middle part
+      while(*s) *p++ = *s++; // put last part in buffer
+      *p = '\0'; // terminate string
+      SetData(buf);
+    }
+  }
+  return(*this);
+}
+
+wxString& wxString::Replace(size_t pos, size_t n, const char *cs)
+{
+//  const char *s = GetData();
+//  wxASSERT(s != NULL,"Bool wxString::Replace: self is NULL");
+  size_t len=Length();
+  if(pos<len){
+    char *p = stringData_+pos;
+    while(*p && n>0){ // replace as much as possible
+      *p++ = *cs++;
+      n--;
+    }
+  }
+  return(*this);
+}
+
+wxString& wxString::Replace(size_t pos, size_t n, const wxString& cs)
+{
+  Replace(pos,n,cs.GetData());
+  return(*this);
+}
+
+// Return a substring of self stripped at beginning and/or end
+wxString  wxString::Strip(stripType stype, char c) const
+{
+  size_t start = 0;     // Index of first character
+  size_t end = Length();    // One beyond last character
+  const char* direct = GetData();  
+
+  wxASSERT((int)stype != 0,"wxString  wxString::Strip(stripType stype, char c) const: no strip-type defined");
+  if (stype & leading)
+    while (start < end && direct[start] == c)
+      ++start;
+  if (stype & trailing)
+    while (start < end && direct[end-1] == c)
+      --end;
+  if (end == start){ // make the null substring
+    wxString string;
+    return(string);
+  }else{
+    return ((*this)(start, end-start));
+  }
+}
+
+void wxString::UpperCase(void)
+{
+  char *s = stringData_; // no const possible
+  if(s != NULL){
+    int len = strlen(s);
+    for (int i = 0; i < len; i++)
+      s[i] = (char)wxToUpper(s[i]);
+  }
+}
+
+void wxString::LowerCase(void)
+{
+  char *s = stringData_; // no const possible
+  if(s != NULL){
+    int len = strlen(s);
+    for (int i = 0; i < len; i++)
+      s[i] = (char)wxToLower(s[i]);
+  }
+}
+
+wxString& wxString::RemoveLast(void)
+{
+  char *s = stringData_; // no const possible
+  if(s != NULL){
+    s[strlen(s)-1] = '\0';
+  }
+  return(*this);
+}
+
+// private functions
+void wxString::SetData(char *s)
+{
+  if(stringData_) delete [] stringData_;
+  stringData_ = s;
+}      
+
+void wxString::assertElement(size_t i) const   // Index in range
+{
+//  const char *s = GetData();
+//  wxASSERT(s != NULL,"void wxString::assertElement(size_t i) const: self is NULL");
+//  wxASSERT(i<strlen(s),"void wxString::assertElement(size_t i) const: index out of range");
+}
+  
+wxString wxString::SubString(size_t from, size_t to)
+{
+  wxString string;
+
+  if (stringData_) {
+    size_t len = strlen(stringData_);
+
+    if (from < len) {
+      if (to >= len) to = len - 1;
+      char *buf = new char[to - from + 2];
+      int i;
+      for (i = from; i <= to; i++)
+        buf[i] = stringData_[i];
+      buf[i] = '\0';
+      string.SetData(buf);
+    }
+  }
+  return string;
+}
+
diff --git a/src/wxmac/src/base/xfspline.cc b/src/wxmac/src/base/xfspline.cc
new file mode 100644
index 0000000..76dde46
--- /dev/null
+++ b/src/wxmac/src/base/xfspline.cc
@@ -0,0 +1,393 @@
+/*
+ * File:	xfspline.cc
+ * Purpose:	
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993, AIAI, University of Edinburgh
+ */
+
+// Must be a comment as this file is #include\'d by wb_dc.cc
+/* static const char sccsid[] = "%W% %G%"; */
+
+/*
+ * FIG : Facility for Interactive Generation of figures
+ * Copyright (c) 1985 by Supoj Sutanthavibul
+ */
+
+#include "common.h"
+#ifdef wx_mac
+#include <QuickDraw.h>
+#include "wx_setup.h"
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include "wx_obj.h"
+#include "wx_dcps.h"
+class wxList;
+class wxPoint;
+#endif //wx_mac
+
+#if USE_SPLINES
+
+#define     wx_round(a)    (int)((a)+.5)
+
+class wxSpline: public wxObject
+{
+ public:
+  int type;
+  wxList *points;
+
+  wxSpline(wxList *list);
+  void DeletePoints(void);
+
+  // Doesn't delete points
+  ~wxSpline(void);
+};
+
+void wx_draw_open_spline(wxbDC *dc, wxSpline *spline);
+
+#if USE_POSTSCRIPT
+void wx_draw_open_spline_ps(wxPostScriptDC *dc, wxSpline *s);
+const char *wxPostScriptHeaderSpline =	" \
+/DrawSplineSection {\n\
+	/y3 exch def\n\
+	/x3 exch def\n\
+	/y2 exch def\n\
+	/x2 exch def\n\
+	/y1 exch def\n\
+	/x1 exch def\n\
+	/xa x1 x2 x1 sub 0.666667 mul add def\n\
+	/ya y1 y2 y1 sub 0.666667 mul add def\n\
+	/xb x3 x2 x3 sub 0.666667 mul add def\n\
+	/yb y3 y2 y3 sub 0.666667 mul add def\n\
+	x1 y1 lineto\n\
+	xa ya xb yb x3 y3 curveto\n\
+	} def\n\
+";
+#endif
+
+void wx_quadratic_spline(float a1, float b1, float a2, float b2,
+                         float a3, float b3, float a4, float b4);
+void wx_clear_stack(void);
+int wx_spline_pop(float *x1, float *y1, float *x2, float *y2, float *x3,
+        float *y3, float *x4, float *y4);
+void wx_spline_push(float x1, float y1, float x2, float y2, float x3, float y3,
+          float x4, float y4);
+static Bool wx_spline_add_point(int x, int y);
+static void wx_spline_draw_point_array(wxbDC *dc);
+wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
+
+void wxbDC::DrawSpline(int n, wxPoint points[])
+{
+  wxList list;
+  for (int i =0; i < n; i++)
+    list.Append((wxObject*)&points[i]);
+  DrawSpline(&list);
+}
+
+void wxbDC::DrawSpline(wxList *list)
+{
+  wxSpline spline(list);
+
+  wx_draw_open_spline(this, &spline);
+}
+
+
+wxList wx_spline_point_list;
+
+void wx_draw_open_spline(wxbDC *dc, wxSpline *spline)
+{
+    wxPoint *p;
+    float           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
+    float           x1, y1, x2, y2;
+
+    wxNode *node = spline->points->First();
+    p = (wxPoint *)node->Data();
+
+    x1 = p->x;
+    y1 = p->y;
+
+    node = node->Next();
+    p = (wxPoint *)node->Data();
+
+    x2 = p->x;
+    y2 = p->y;
+    cx1 = (float)((x1 + x2) / 2);
+    cy1 = (float)((y1 + y2) / 2);
+    cx2 = (float)((cx1 + x2) / 2);
+    cy2 = (float)((cy1 + y2) / 2);
+
+    wx_spline_add_point((int) x1, (int) y1);
+
+    node = node->Next();
+
+    while (node)
+    {
+        p = (wxPoint *)node->Data();
+	x1 = x2;
+	y1 = y2;
+	x2 = p->x;
+	y2 = p->y;
+        cx4 = (float)(x1 + x2) / 2;
+        cy4 = (float)(y1 + y2) / 2;
+        cx3 = (float)(x1 + cx4) / 2;
+        cy3 = (float)(y1 + cy4) / 2;
+
+        wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
+
+	cx1 = cx4;
+	cy1 = cy4;
+        cx2 = (float)(cx1 + x2) / 2;
+        cy2 = (float)(cy1 + y2) / 2;
+
+        node = node->Next();
+    }
+
+    wx_spline_add_point(wx_round(cx1), wx_round(cy1));
+    wx_spline_add_point((int) x2, (int) y2);
+
+    wx_spline_draw_point_array(dc);
+
+}
+
+void wx_draw_open_spline_ps(wxPostScriptDC *dc, wxSpline *s)
+{
+#if 0
+	double		a, b, c, d, x1, y1, x2, y2, x3, y3;
+        wxPoint *p, *q;
+        if (dc->autoSetting)
+          dc->SetPen(dc->current_pen);
+
+        wxNode *node = s->points->First();
+        p = (wxPoint *)node->Data();
+
+	x1 = p->x; y1 = p->y;
+
+        node = node->Next();
+        p = (wxPoint *)node->Data();
+	c = p->x; d = p->y;
+        x3 = a = (float)(x1 + c) / 2;
+        y3 = b = (float)(y1 + d) / 2;
+
+        *(dc->pstream) << "newpath " << x1 << " " << dc->yorigin - y1 << " moveto " << x3 << " " << dc->yorigin - y3;
+        *(dc->pstream) << " lineto\n";
+        dc->CalcBoundingBox((float)x1, (float)(dc->yorigin - y1));
+        dc->CalcBoundingBox((float)x3, (float)(dc->yorigin - y3));
+
+        node = node->Next();
+
+        while (node)
+	{
+          q = (wxPoint *)node->Data();
+
+	  x1 = x3; y1 = y3;
+	  x2 = c;  y2 = d;
+	  c = q->x; d = q->y;
+          x3 = (float)(x2 + c) / 2;
+          y3 = (float)(y2 + d) / 2;
+          *(dc->pstream) << x1 << " " << dc->yorigin - y1 << " " << x2 << " " << dc->yorigin - y2 << " ";
+          *(dc->pstream) << x3 << " " << dc->yorigin - y3 << " DrawSplineSection\n";
+
+          dc->CalcBoundingBox((float)x1, (float)(dc->yorigin - y1));
+          dc->CalcBoundingBox((float)x3, (float)(dc->yorigin - y3));
+
+
+         node = node->Next();
+        }
+	/*
+	* At this point, (x2,y2) and (c,d) are the position of the 
+	* next-to-last and last point respectively, in the point list
+	*/
+        *(dc->pstream) << c << " " << dc->yorigin - d << " lineto stroke\n";
+#endif
+}
+
+/********************* CURVES FOR SPLINES *****************************
+
+	The following spline drawing routine is from
+
+	"An Algorithm for High-Speed Curve Generation"
+	by George Merrill Chaikin,
+	Computer Graphics and Image Processing, 3, Academic Press,
+	1974, 346-349.
+
+	and
+
+	"On Chaikin's Algorithm" by R. F. Riesenfeld,
+	Computer Graphics and Image Processing, 4, Academic Press,
+	1975, 304-310.
+
+***********************************************************************/
+
+#define		half(z1, z2)	((z1+z2)/2.0)
+#define		THRESHOLD	5
+
+/* iterative version */
+
+void wx_quadratic_spline(float a1, float b1, float a2, float b2, float a3, float b3, float a4,
+                 float b4)
+{
+    register float  xmid, ymid;
+    float           x1, y1, x2, y2, x3, y3, x4, y4;
+
+    wx_clear_stack();
+    wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
+
+    while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
+        xmid = (float)half(x2, x3);
+        ymid = (float)half(y2, y3);
+	if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
+	    fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
+            wx_spline_add_point(wx_round(x1), wx_round(y1));
+            wx_spline_add_point(wx_round(xmid), wx_round(ymid));
+	} else {
+            wx_spline_push(xmid, ymid, (float)half(xmid, x3), (float)half(ymid, y3),
+                 (float)half(x3, x4), (float)half(y3, y4), x4, y4);
+            wx_spline_push(x1, y1, (float)half(x1, x2), (float)half(y1, y2),
+                 (float)half(x2, xmid), (float)half(y2, ymid), xmid, ymid);
+	}
+    }
+}
+
+
+/* utilities used by spline drawing routines */
+
+
+typedef struct wx_spline_stack_struct {
+    float           x1, y1, x2, y2, x3, y3, x4, y4;
+}
+                Stack;
+
+#define         SPLINE_STACK_DEPTH             20
+static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
+static Stack   *wx_stack_top;
+static int      wx_stack_count;
+
+void wx_clear_stack(void)
+{
+    wx_stack_top = wx_spline_stack;
+    wx_stack_count = 0;
+}
+
+void wx_spline_push(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
+{
+    wx_stack_top->x1 = x1;
+    wx_stack_top->y1 = y1;
+    wx_stack_top->x2 = x2;
+    wx_stack_top->y2 = y2;
+    wx_stack_top->x3 = x3;
+    wx_stack_top->y3 = y3;
+    wx_stack_top->x4 = x4;
+    wx_stack_top->y4 = y4;
+    wx_stack_top++;
+    wx_stack_count++;
+}
+
+int wx_spline_pop(float *x1, float *y1, float *x2, float *y2,
+                  float *x3, float *y3, float *x4, float *y4)
+{
+    if (wx_stack_count == 0)
+	return (0);
+    wx_stack_top--;
+    wx_stack_count--;
+    *x1 = wx_stack_top->x1;
+    *y1 = wx_stack_top->y1;
+    *x2 = wx_stack_top->x2;
+    *y2 = wx_stack_top->y2;
+    *x3 = wx_stack_top->x3;
+    *y3 = wx_stack_top->y3;
+    *x4 = wx_stack_top->x4;
+    *y4 = wx_stack_top->y4;
+    return (1);
+}
+
+static Bool wx_spline_add_point(int x, int y)
+{
+  wxPoint *point = new wxPoint ;
+  point->x = (float)x;
+  point->y = (float)y;
+  wx_spline_point_list.Append((wxObject*)point);
+  return TRUE;
+}
+
+static void wx_spline_draw_point_array(wxbDC *dc)
+{
+  dc->DrawLines(&wx_spline_point_list, 0.0, 0.0);
+  wxNode *node = wx_spline_point_list.First();
+  while (node)
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    delete point;
+    delete node;
+    node = wx_spline_point_list.First();
+  }
+}
+
+wxSpline::wxSpline(wxList *list)
+{
+  points = list;
+}
+
+wxSpline::~wxSpline(void)
+{
+}
+
+void wxSpline::DeletePoints(void)
+{
+  wxNode *node = points->First();
+  while (node)
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    delete point;
+    delete node;
+    node = points->First();
+  }
+  delete points;
+}
+
+#if USE_POSTSCRIPT
+
+// Make a 3-point spline
+void wxPostScriptDC::DrawSpline(float x1, float y1, float x2, float y2, float x3, float y3)
+{
+  wxList *point_list = new wxList;
+
+  wxPoint *point1 = new wxPoint;
+  point1->x = x1; point1->y = y1;
+  point_list->Append((wxObject*)point1);
+
+  wxPoint *point2 = new wxPoint;
+  point2->x = x2; point2->y = y2;
+  point_list->Append((wxObject*)point2);
+
+  wxPoint *point3 = new wxPoint;
+  point3->x = x3; point3->y = y3;
+  point_list->Append((wxObject*)point3);
+
+  wxSpline spline(point_list);
+
+  wx_draw_open_spline_ps(this, &spline);
+  spline.DeletePoints();
+}
+
+void wxPostScriptDC::DrawSpline(wxList *list)
+{
+  wxSpline spline(list);
+
+  wx_draw_open_spline_ps(this, &spline);
+}
+
+void wxPostScriptDC::DrawSpline(int n, wxPoint points[])
+{
+  wxList list;
+  for (int i =0; i < n; i++)
+    list.Append((wxObject*)&points[i]);
+  DrawSpline(&list);
+}
+
+
+#endif // USE_POSTSCRIPT
+
+#endif // USE_SPLINES
+
diff --git a/src/wxmac/src/mac/macstat.c b/src/wxmac/src/mac/macstat.c
new file mode 100644
index 0000000..68d5d7a
--- /dev/null
+++ b/src/wxmac/src/mac/macstat.c
@@ -0,0 +1,70 @@
+/* Minimal 'stat' emulation: tells directories from files and
+   gives length and mtime.
+   Public domain by Guido van Rossum, CWI, Amsterdam (July 1987).
+   Updated to give more info, August 1994.
+   
+   Modified 4/29/95  for wxWindows by Cecil Coupe 
+*/
+
+#include "macstat.h"
+#include "macdefs.h"
+// CJC - depending on your headers you need one or more of these: 
+#include <TextUtils.h>
+#include <Strings.h>	
+
+/* Bits in ioFlAttrib: */
+#define LOCKBIT	(1<<0)		/* File locked */
+#define DIRBIT	(1<<4)		/* It's a directory */
+
+int
+stat(char *path, struct stat *buf)
+{
+	union {
+		DirInfo d;
+		FileParam f;
+		HFileInfo hf;
+	} pb;
+	short err;
+	char temp[MAXPATH];
+	
+	strcpy(temp, path);
+	pb.d.ioNamePtr = (unsigned char *)C2PStr(temp);
+
+	pb.d.ioVRefNum = 0;
+	pb.d.ioFDirIndex = 0;
+	pb.d.ioDrDirID = 0;
+	pb.f.ioFVersNum = 0; /* Fix found by Timo! See Tech Note 102 */
+	if (hfsrunning())
+		err = PBGetCatInfo((CInfoPBPtr)&pb, FALSE);
+	else
+		err = PBGetFInfo((ParmBlkPtr)&pb, FALSE);
+	if (err != noErr) {
+		errno = ENOENT;
+		return -1;
+	}
+	if (pb.d.ioFlAttrib & LOCKBIT)
+		buf->st_mode = 0444;
+	else
+		buf->st_mode = 0666;
+	if (pb.d.ioFlAttrib & DIRBIT) {
+		buf->st_mode |= 0111 | S_IFDIR;
+		buf->st_size = pb.d.ioDrNmFls;
+		buf->st_rsize = 0;
+	}
+	else {
+		buf->st_mode |= S_IFREG;
+		if (pb.f.ioFlFndrInfo.fdType == 'APPL')
+			buf->st_mode |= 0111;
+	}
+	buf->st_ino = pb.hf.ioDirID;
+	buf->st_nlink = 1;
+	buf->st_uid = 1;
+	buf->st_gid = 1;
+	buf->st_size = pb.f.ioFlLgLen;
+	buf->st_mtime = buf->st_atime = pb.f.ioFlMdDat;
+	buf->st_ctime = pb.f.ioFlCrDat;
+	buf->st_rsize = pb.f.ioFlRLgLen;
+	*(unsigned long *)buf->st_type = pb.f.ioFlFndrInfo.fdType;
+	*(unsigned long *)buf->st_creator = pb.f.ioFlFndrInfo.fdCreator;
+	return 0;
+}
diff --git a/src/wxmac/src/mac/unimp.cpp b/src/wxmac/src/mac/unimp.cpp
new file mode 100644
index 0000000..125af35
--- /dev/null
+++ b/src/wxmac/src/mac/unimp.cpp
@@ -0,0 +1,410 @@
+#include "wx.h"
+#include "wx_utils.h"
+#include "unimp.h"
+#include "wxstring.h"
+#include "wx_list.h"
+#include <Strings.h>
+
+int AddOrReplaceEntry(const char *section, const char *entry, char *Value, const char *file);
+int GetEntry(const char *section, const char *entry, char *Value, const char *file);
+
+Bool wxWriteResource(const char *section, const char *entry, char *value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s = %s\n", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, float value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s = %f\n", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, long value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s = %d\n", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, int value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s = %d\n", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, char **value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    char *badChar = strstr(Value, "\n");
+    if (badChar)
+      *badChar = '\0';
+    char *s = copystring(Value);
+    value[0] = s;
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, float *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    char *badChar = strstr(Value, "\n");
+    if (badChar)
+      *badChar = '\0';
+    sscanf(Value, "%f", value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, long *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    char *badChar = strstr(Value, "\n");
+    if (badChar)
+      *badChar = '\0';
+    value[0] = atol(Value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, int *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    char *badChar = strstr(Value, "\n");
+    if (badChar)
+      *badChar = '\0';
+    value[0] = atoi(Value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+int wxMessageBox(char *, char *);
+int wxMessageBox(char *, char *)
+{
+  return FALSE;
+}
+
+#ifdef somethingnotdefined
+//char *output = wxFileSelector("File to print to...", NULL, NULL, NULL, "*.txt");
+char *wxFileSelector(char *message, char *default_path,
+                     char *default_filename, char *default_extension,
+                     char *wildcard, int flags,
+                     wxFrame *parent, int x, int y)
+{
+  StandardFileReply reply;
+  SFTypeList typeList;
+  OSErr err;
+  TFileSpec *tFile;
+  char				*name;
+  StringPtr pstrmsg;
+  StringPtr pstrdefname;
+
+//TFileSpec::TFileSpec(short vRefNum, long parID, ConstStr31Param name, Boolean useAlias)
+//extern pascal void StandardPutFile(ConstStr255Param prompt, ConstStr255Param defaultName, StandardFileReply *reply)
+
+  if (flags & wxOPEN)
+  {
+    typeList[0] = '????';
+    StandardGetFile(nil, -1, typeList, &reply); // typeList,
+  }
+  else if (flags & wxSAVE)
+  {
+    if (message)
+      pstrmsg = c2pstr(message);
+    else
+      pstrmsg = "\pSave File Name";
+
+    if (default_filename)
+      pstrdefname = c2pstr(default_filename);
+    else
+      pstrdefname = "\pPRINTFILE.TXT";
+
+    StandardPutFile(pstrmsg, pstrdefname, &reply);
+  }
+
+  if (reply.sfFile.name)
+  {
+    tFile = new TFileSpec(reply.sfFile.vRefNum,
+                      reply.sfFile.parID,
+                      reply.sfFile.name, TRUE);
+    name = tFile->FullPath();
+    return name;
+  }
+  else
+    return 0;
+}
+
+#endif
+
+// Get current working directory.
+// If buf is NULL, allocates space using new, else
+// copies into buf.
+char *wxGetWorkingDirectory(char *buf, int sz)
+{
+
+  if (!buf)
+    buf = new char[1000];
+#ifdef wx_msw
+#ifdef __BORLANDC__
+  (void)getcwd(buf, sz);
+#elif __WATCOMC__
+  (void)getcwd(buf, sz);
+#else 
+  (void)_getcwd(buf, sz);
+#endif
+#elif defined wx_mac
+// mac
+  return getcwd(buf, sz);
+#endif
+
+  //return buf;
+}
+
+
+// Needed for wx_mac since ANSI stdlib is C compiled
+
+#ifdef wx_mac
+extern "C" {
+int wx_comparestrings(const void *arg1, const void *arg2);
+/*int wx_comparestrings(const void *arg1, const void *arg2);*/
+#ifndef GUSI
+int strcmp(char* s1, char* s2);
+#endif
+}
+
+int wx_comparestrings(const void *arg1, const void *arg2)
+{
+  char **s1 = (char **)arg1;
+  char **s2 = (char **)arg2;
+
+  return strcmp(*s1, *s2);
+}
+#endif
+
+
+char *wxGetUserHome(const char *user)
+{
+  char usr[256];
+  strcpy(usr, user);
+  return getcwd(usr, 1000);
+}
+
+
+wxNode *EntryMember (wxList *, const char *, int );
+wxNode *EntryMember (wxList *list, const char *s, int length)
+{
+  for (wxNode * node = list->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if (s == s1 || strncmp (s, s1, length) == 0)
+	return node;
+    }
+  return 0;
+}
+
+wxNode *SectionMember (wxList *, const char *, int );
+wxNode *SectionMember (wxList *list, const char *s, int length)
+{
+  for (wxNode * node = list->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if (s == s1 || strncmp (s, s1, length) == 0)
+	return node;
+    }
+  return 0;
+}
+
+wxList *GetStringList(FILE *fd);
+int WriteStringList(FILE *fd, wxList *sList);
+
+int AddOrReplaceEntry(const char *section, const char *entry, char *Value, const char *file)
+{
+  FILE *fd;
+  wxList *sList;
+  wxNode *sNode;
+  wxNode *eNode;
+  char Section[256];
+
+  // make a section
+  sprintf(Section, "[%s]", section);
+
+  if ( (fd = fopen(file, "r+")) == 0 ) // file note there
+    return FALSE;
+
+  // find the section or create it
+  sList = GetStringList(fd);
+  if ( sNode = SectionMember(sList, Section, strlen(Section)))
+  {
+    if ( (eNode = EntryMember(sList, entry, strlen(entry))) )
+    {
+      // replace with new entry
+      sList->Insert(eNode, (new wxString(Value) ));
+
+      // delete the old entry
+      sList->DeleteNode(eNode); 
+    }
+    else // section there, entry missing, add it
+    {
+      // add the entry
+      wxNode *afterSection = sNode->Next();
+
+      // replace with new entry
+      sList->Insert(afterSection, (new wxString(Value) ));
+
+    }
+  }
+  else // section missing, add it
+  {
+    // add the section
+    sList->Append(new wxString(Section) );
+    // add the entry
+    sList->Append(new wxString(Value) );
+  }
+
+  int retval;
+
+  if (WriteStringList(fd, sList))
+    retval = TRUE;
+  else
+    retval = FALSE;
+
+  fclose(fd);
+
+  return retval;
+}
+
+int GetEntry(const char *section, const char *entry, char *Value, const char *file)
+{
+  FILE *fd;
+  wxList *sList;
+  wxNode *sNode;
+  wxNode *eNode;
+  char Section[256];
+
+  // make a section
+  sprintf(Section, "[%s]", section);
+
+  if ( (fd = fopen(file, "r+")) == 0 ) // file note there
+    return FALSE;
+
+  // find the section or create it
+  sList = GetStringList(fd);
+
+  fclose(fd);
+
+  if ( sNode = SectionMember(sList, Section, strlen(Section)))
+  {
+    if ( (eNode = EntryMember(sList, entry, strlen(entry))) )
+    {
+      const char *s1 = (const char *) ((wxString *)(eNode->Data()))->GetData();
+      char *s2 = strstr(s1, "=");
+      strcpy(Value,s2+1);
+      return TRUE;
+    }
+   }
+
+  return FALSE;
+
+}
+
+wxList *GetStringList(FILE *fd)
+{
+  wxList *theList = new wxList();
+  char *line;
+  char line2[256];
+
+  while ( (line = fgets(line2, sizeof(line2), fd)) != 0)
+  {
+    theList->Append(new wxString(line));
+  }
+  if (theList->Number() > 0)
+    return theList;
+  else
+    return 0;
+}
+
+int WriteStringList(FILE *fd, wxList *sList)
+{
+  int err;
+
+  fseek(fd, 0, SEEK_SET);
+  for (wxNode * node = sList->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if ( (err = fputs(s1, fd)) != 0)
+        return FALSE;
+    }
+  return TRUE;
+
+}
+
+#ifdef CJC
+//int strcasecmp (const char *, const char *);
+//int strncasecmp (const char *, const char *, size_t);
+
+int strcasecmp (char *s1, char *s2)
+{
+
+  return strcmp(s1,s2);
+
+}
+
+int strncasecmp (char *s1, char *s2, int len)
+{
+
+  return strncmp(s1,s2,len);
+
+}
+#endif
+
+//	::InvalRect(&newViewRect); // force redraw of text window
+
+
+
+
+
+
+
diff --git a/src/wxmac/src/mac/wxBorder.cc b/src/wxmac/src/mac/wxBorder.cc
new file mode 100644
index 0000000..6844bab
--- /dev/null
+++ b/src/wxmac/src/mac/wxBorder.cc
@@ -0,0 +1,97 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxBorder.cc
+// Purpose:	Macintosh Border implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wxBorder.h"
+#include "wxMacDC.h"
+#include "wx_area.h"
+#include <Windows.h>
+#include "wxBorderArea.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxBorder::wxBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		WXTYPE		objectType
+	) :
+		wxWindow (windowName, parentArea, x, y, width, height, style)
+{
+	__type = wxTYPE_BORDER;
+	if (width < 0) cWindowWidth = parentArea->Width();
+	if (height < 0) cWindowHeight = parentArea->Height();
+	SetJustify(Direction::wxAll);
+	SetGravitate(Direction::wxTop | Direction::wxLeft);
+	cActive = TRUE; // Kludge, so that "ShowAsActive" method will be called
+	
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxBorder::~wxBorder(void)
+{
+#if 0
+	// CJC - Lets Hack - we still have leaks only now they are 'unknown'
+	wxArea* pa = cParentArea;
+	cParentArea = NULL;
+	delete pa;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxBorder::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxBorder::DoShow(Bool show)
+{
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxBorder::ShowAsActive(Bool flag) // mac platform only
+{
+	if (cHidden) return;
+
+	if (flag)
+	{
+		// The following is a kludge, to paint border before subsequent update event
+		Paint();
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		int margin = ParentArea()->Margin().Offset(Direction::wxTop);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		RgnHandle outerRgn = ::NewRgn(); CheckMemOK(outerRgn);
+		::RectRgn(outerRgn, &clientRect);
+		RgnHandle innerRgn = ::NewRgn(); CheckMemOK(innerRgn);
+		::CopyRgn(outerRgn, innerRgn); InsetRgn(innerRgn, margin, margin);
+		::DiffRgn(outerRgn, innerRgn, outerRgn);
+		::ValidRgn(outerRgn);
+		::DisposeRgn(outerRgn);
+		::DisposeRgn(innerRgn);
+	}
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxBorderArea.cc b/src/wxmac/src/mac/wxBorderArea.cc
new file mode 100644
index 0000000..1771866
--- /dev/null
+++ b/src/wxmac/src/mac/wxBorderArea.cc
@@ -0,0 +1,29 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxBorderArea.cc
+// Purpose:	Label area (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxBorderArea.h"
+#include "wxRectBorder.h"
+
+//=============================================================================
+// Construction methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxBorderArea::wxBorderArea(wxWindow* parentWindow, int margin, Direction direction,
+							int whitespace) :
+		wxArea(parentWindow)
+{
+	cBorder = new wxRectBorder(this, margin, direction, whitespace);
+}
+
+//-----------------------------------------------------------------------------
+wxBorderArea::~wxBorderArea(void)	// destructor
+{
+//	delete cBorder;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxButtonBorder.cc b/src/wxmac/src/mac/wxButtonBorder.cc
new file mode 100644
index 0000000..e2e7abe
--- /dev/null
+++ b/src/wxmac/src/mac/wxButtonBorder.cc
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxButtonBorder.cc
+// Purpose:	Macintosh ButtonBorder implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wxButtonBorder.h"
+#include "wx_area.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxButtonBorder::wxButtonBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int			margin,
+		Direction	direction,
+ 		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		WXTYPE		objectType
+	) :
+		wxBorder (parentArea, windowName, x, y, width, height, style, objectType)
+{
+	parentArea->SetMargin(margin, direction);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxButtonBorder::~wxButtonBorder(void)
+{
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxButtonBorder::Paint(void)
+{
+	if (cHidden) return;
+
+	int margin = ParentArea()->Margin().Offset(Direction::wxTop);
+	if (margin)
+	{	
+		int clientWidth = ClientArea()->Width();
+		int clientHeight = ClientArea()->Height();
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		SetCurrentDC();
+		PenState oldPenState;
+		::GetPenState(&oldPenState);
+		::PenNormal();
+		::PenSize(margin -1 , margin - 1);
+		::FrameRoundRect(&clientRect, 16, 16);
+		::SetPenState(&oldPenState);
+	}
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxGetTxt.cc b/src/wxmac/src/mac/wxGetTxt.cc
new file mode 100644
index 0000000..26cbafa
--- /dev/null
+++ b/src/wxmac/src/mac/wxGetTxt.cc
@@ -0,0 +1,129 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dltxt.cc
+// Purpose:	wxDialogText (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_dialg.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+#include "wx_gdi.h"
+#include "wx_buttn.h"
+#include "wx_types.h"
+#include "wx_utils.h"
+#include "wx_txt.h"
+
+static void wxOkButtonProc(wxButton& button, wxEvent& event);
+static void wxCancelButtonProc(wxButton& button, wxEvent& event);
+
+//-----------------------------------------------------------------------------
+// Pop up a dialog text box
+//-----------------------------------------------------------------------------
+char* wxGetTextFromUser(char* message, char* caption, char* default_value,
+                 wxWindow* parent, int x, int y, Bool centre)
+{
+	wxDialogBox* dialog = new wxDialogBox((wxFrame*)NULL, caption, TRUE, x, y);
+
+//============================================
+	wxPanel* dialogPanel = new wxPanel(dialog);
+	wxFont* theFont = new wxFont(12, wxSYSTEM, wxNORMAL, wxNORMAL); //GRW
+	dialogPanel->SetLabelFont(theFont);
+	dialogPanel->SetButtonFont(theFont);
+
+//============================================
+	wxPanel* messagePanel = new wxPanel(dialogPanel, -1, -1, -1, -1);
+
+	wxList messageList;
+	wxSplitMessage(message, &messageList, messagePanel);
+	messagePanel->Fit();
+	if (centre)
+	{
+		wxCentreMessage(&messageList);
+	}
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	dialogPanel->NewLine();
+	wxText* textBox = new wxText(dialogPanel, NULL, NULL, default_value,
+						-1, -1, 100, -1, wxBORDER); // WCH: must fix explict width
+	textBox->Highlight(0, textBox->GetLastPosition());
+	textBox->SetFocus();
+
+//============================================
+	dialogPanel->NewLine();
+	wxPanel* buttonPanel = dialogPanel;
+
+	wxButton* ok = NULL;
+	wxButton* cancel = NULL;
+	wxButton* yes = NULL;
+	wxButton* no = NULL;
+
+	ok = new wxButton(buttonPanel, (wxFunction)&wxOkButtonProc, "OK");
+	cancel = new wxButton(buttonPanel, (wxFunction)&wxCancelButtonProc, "Cancel");
+	ok->SetDefault();
+
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	
+	dialogPanel->Fit();
+	dialog->Fit();
+
+	messagePanel->Centre(wxHORIZONTAL);
+	buttonPanel->Centre(wxHORIZONTAL);
+
+	dialogPanel->Centre(wxBOTH);
+
+//============================================
+	
+	dialog->ShowModal();
+	int buttonPressed = dialog->GetButtonPressed();
+	char* result = (buttonPressed == wxOK ? textBox->GetValue() : NULL);
+	delete dialog;
+
+//============================================
+
+	return result;
+}
+
+//=============================================================================
+//
+// Dialog button callback procedures
+//
+//=============================================================================
+static wxDialogBox* wxGetDialogFromButton(wxButton& button)
+{
+	wxFrame *fr = button.GetRootFrame();
+	wxDialogBox* dialog = fr->cDialogPanel;
+	if (dialog == NULL) {
+   		wxFatalError("No DialogBox found on RootFrame.");
+   	}
+   	return dialog;
+}
+
+
+
+//-----------------------------------------------------------------------------
+static void wxOkButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxOK);
+	dialog->Show(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+static void wxCancelButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxCANCEL);
+	dialog->Show(FALSE);
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxLabelArea.cc b/src/wxmac/src/mac/wxLabelArea.cc
new file mode 100644
index 0000000..53563d1
--- /dev/null
+++ b/src/wxmac/src/mac/wxLabelArea.cc
@@ -0,0 +1,77 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxLabelArea.cc
+// Purpose:	Label area (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxLabelArea.h"
+#include "wx_messg.h"
+#include "wx_gdi.h"
+
+//=============================================================================
+// Construction methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxLabelArea::wxLabelArea
+	(
+		wxWindow*	parentWindow,
+		char*		label,
+		wxFont*		theFont,
+		Direction	direction,
+		int			xoffset,
+		int			yoffset
+	) :
+		wxArea(parentWindow)
+{
+	__type = wxTYPE_LABEL_AREA;
+	cLabelText = new wxMessage(this, label, theFont, xoffset, yoffset);
+	cDirection = direction;
+
+	int labelWidth = 0;
+	int labelHeight = 0;
+	wxFont* labelFont = cLabelText->font;
+	if (labelFont)
+	{
+		char* labelText = cLabelText->GetLabel();
+		float fLabelWidth, fLabelHeight, fDescent, fExternalLeading;
+		labelFont->GetTextExtent(labelText, &fLabelWidth, &fLabelHeight,
+								&fDescent, &fExternalLeading);
+		labelWidth = fLabelWidth;
+		labelHeight = fLabelHeight;
+	}
+
+	if (cDirection & Direction::wxTop)
+	{
+		SetMargin(labelHeight, Direction::wxTop);
+	}
+	else
+	{
+		SetMargin(labelWidth+5, Direction::wxLeft);
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxLabelArea::~wxLabelArea(void)	// destructor
+{
+	delete cLabelText;
+}
+
+//=============================================================================
+// Getter and setter methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxLabelArea::SetLabel(char* label) { cLabelText->SetLabel(label); }
+
+//-----------------------------------------------------------------------------
+char* wxLabelArea::GetLabel(void) { return cLabelText->GetLabel(); }
+
+void wxLabelArea::DoShow(Bool on)
+{
+  cLabelText->DoShow(on);
+}
+
diff --git a/src/wxmac/src/mac/wxMacDC.cc b/src/wxmac/src/mac/wxMacDC.cc
new file mode 100644
index 0000000..6350cfe
--- /dev/null
+++ b/src/wxmac/src/mac/wxMacDC.cc
@@ -0,0 +1,46 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMacDC.cc
+// Purpose:	MacDC (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+#include <QuickDraw.h>
+#include "wxMacDC.h"
+
+//-----------------------------------------------------------------------------
+wxMacDC::wxMacDC(CGrafPtr port)
+{
+	cMacGrafPort = port;
+	cCurrentUser = NULL;
+}
+
+//-----------------------------------------------------------------------------
+wxMacDC::~wxMacDC(void)	// destructor
+{
+}
+
+//-----------------------------------------------------------------------------
+Bool wxMacDC::isCurrentPort(void)
+{
+	return (GrafPtr)cMacGrafPort == qd.thePort;
+}
+
+//-----------------------------------------------------------------------------
+CGrafPtr wxMacDC::macGrafPort(void)
+{
+	return cMacGrafPort;
+}
+
+//-----------------------------------------------------------------------------
+wxObject* wxMacDC::currentUser(void)
+{
+	return cCurrentUser;
+}
+
+//-----------------------------------------------------------------------------
+void wxMacDC::setCurrentUser(wxObject* user)
+{
+	cCurrentUser = user;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxMacObj.cc b/src/wxmac/src/mac/wxMacObj.cc
new file mode 100644
index 0000000..8c70619
--- /dev/null
+++ b/src/wxmac/src/mac/wxMacObj.cc
@@ -0,0 +1,22 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMacObj.cc
+// Purpose:	wxObject base class implementation
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wxMacObj.h"
+
+wxMacObject::wxMacObject(void)
+{
+  __type = wxTYPE_ANY;
+}
+
+wxMacObject::~wxMacObject(void)
+{
+}
+
diff --git a/src/wxmac/src/mac/wxMacPPC.c b/src/wxmac/src/mac/wxMacPPC.c
new file mode 100644
index 0000000..ec62c39
--- /dev/null
+++ b/src/wxmac/src/mac/wxMacPPC.c
@@ -0,0 +1,642 @@
+/*
+ * File:	wxMacPPC.c
+ * Purpose:	IPC primitives (Macintosh version)
+ * Author:	Tomaso Paoletti
+ * Created:	1994
+ * Updated:	
+ * Copyright:	(c) 1993-1994, AIAI, University of Edinburgh
+ */
+  
+#define GUSI
+#include <Script.h>
+#include <string.h>
+#include <stdio.h>
+#include "wxMacPPC.h"
+#include <Errors.h>
+#include <Strings.h>
+#ifndef TRUE			/* Remember, this is C, not C++, don't include "common.h" */
+#	define TRUE 1
+#endif
+#ifndef FALSE
+#	define FALSE 0
+#endif
+// global variables used to relay information to the application
+short gSessionState = sClosed;
+
+// Here's a piece of header joy
+#if defined(MrCpp) || defined(GUSI)
+#define CtoPstr c2pstr
+#endif
+
+Boolean gPBInUse = FALSE;
+
+PPCParamBlockPtr	PBptr  = NULL;
+PPCWritePBPtr WritePBptr = NULL;
+PPCReadPBPtr	ReadPBptr = NULL;
+EventRecord noLockEvent;
+
+/* 
+	Need to set up UPP's for these Completion Routines: 
+	pascal void MyInformCompProc( PPCParamBlockPtr );
+	pascal void MyAcceptCompProc(PPCParamBlockPtr);
+	pascal void MyRejectCompProc(PPCParamBlockPtr);
+	
+	From PPCToolBox.h :
+	typedef pascal void (*PPCCompProcPtr)(PPCParamBlockPtr pb);
+
+	typedef PPCCompProcPtr PPCCompUPP;
+
+	define NewPPCCompProc(userRoutine)		\
+		((PPCCompUPP) (userRoutine))
+	define NewPPCFilterProc(userRoutine)		\
+		((PPCFilterUPP) (userRoutine))
+		
+	define NewPPCCompProc(userRoutine)		\
+	(PPCCompUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPPCCompProcInfo, GetCurrentArchitecture())
+
+  Here's how GUSI does it:
+
+    RoutineDescriptor	uADSPCompletion =
+		BUILD_ROUTINE_DESCRIPTOR(uppADSPCompletionProcInfo, ADSPCompletion);
+		
+	pb->ioCompletion	=	ADSPCompletionUPP(&uADSPCompletion);
+
+	void ADSPCompletion(AnnotatedADSPParamBlock * pb)
+	{
+		....
+	}
+
+*/
+
+// Declare some vars to hold the UPP's. Actually created as needed;
+static PPCCompUPP  MyInformCompProcUPP;	
+static PPCCompUPP  MyAcceptCompProcUPP;
+static PPCCompUPP  MyRejectCompProcUPP;
+static PPCFilterUPP	MyBrowserPortFilterUPP;
+// this is how you prototype MyInformCompProc
+pascal void MyInformCompProc(PPCParamBlockPtr);
+// Prototypes for user defined routines to accept or reject sessions
+void DoPPCAccept(PPCParamBlockPtr);
+void DoPPCReject(PPCParamBlockPtr);
+// prototype your Reject completion Procedure like this:
+pascal void MyRejectCompProc(PPCParamBlockPtr);
+// the iocompletion routine is prototyped as follows
+pascal void MyAcceptCompProc(PPCParamBlockPtr);
+
+
+
+//---------------- HIGH-LEVEL SERVICES --------------------------
+
+Boolean PPCInitialize()
+{	
+	PBptr = (PPCParamBlockPtr)NewPtr(sizeof(PPCParamBlockRec));
+	ReadPBptr = (PPCReadPBPtr) NewPtr(sizeof(PPCReadPBRec));
+	WritePBptr = (PPCWritePBPtr) NewPtr(sizeof(PPCWritePBRec));
+	
+	return PBptr && ReadPBptr && WritePBptr;	
+}	
+
+// synchronous read - useful at startup
+long ipcSyncRead(PPCSessRefNum sess,char * buffer, long size)
+{	OSErr err;
+	long len = 0;
+	
+	err = ppcStartRead(ReadPBptr,sess,size,buffer);
+	if (err) 
+		return err;
+	if (ReadPBptr)
+	{
+		err = ppcRead(ReadPBptr,sess,size,buffer);
+		if (err)
+			return err;
+		len = ReadPBptr->actualLength;
+	}
+	return len;
+}
+
+// returns number of read bytes ( or < 0 for error)
+long ipcRead(PPCSessRefNum sess,char * buffer, long size)
+{	OSErr err;
+	long len = 0;
+	
+	if (ReadPBptr)
+	{	
+		err = ppcRead(ReadPBptr,sess,size,buffer);
+		if (err) 
+			return err;
+			
+		len = ReadPBptr->actualLength;
+	
+		err = ppcStartRead(ReadPBptr,sess,size,buffer);
+		if (err)
+			return err;
+	} 
+	return len;
+}
+
+// returns number of written bytes ( or < 0 for error)
+long ipcWrite(PPCSessRefNum sess,char *buffer, long size)
+{
+	OSErr err;
+	long t;
+	long len = 0;
+	
+	if (WritePBptr)
+	{
+		err = ppcWrite(WritePBptr,sess,size,buffer);
+		if (err) return err;
+		
+		Delay(60,&t);
+		while (! MyWriteComplete(WritePBptr,&err)) 
+		{
+			if (WaitNextEvent( nullEvent, &noLockEvent, 30, NULL))
+			{
+			}
+		}
+		len = WritePBptr->actualLength;
+	}
+	
+	return len;
+}
+
+//------------------------- INIT/OPEN SERVICES -----------------------------
+
+OSErr  ppcInit(long *ppcAttributes)
+{
+	OSErr err;	
+
+	err = Gestalt(gestaltPPCToolboxAttr, ppcAttributes);
+	if ( err == noErr )
+	{
+		// PPC Toolbox is present
+		if (  !( *ppcAttributes & gestaltPPCSupportsRealTime) )
+		{
+			// PPC Toolbox needs initialization
+			// initialize the PPC Toolbox and set function result
+			err = PPCInit();
+			// test the attributes for the PPC Toolbox
+			err = Gestalt(gestaltPPCToolboxAttr,ppcAttributes);
+		}
+	}
+	return err;
+}
+
+// Opening a PPC port
+
+OSErr ppcOpen(PPCPortRefNum *thePortRefNum, char *portName, Boolean *nbpRegisterFlag)
+{
+	PPCOpenPBRec	thePPCOpenPBRec;
+	PPCPortRec	thePPCPortRec;
+	LocationNameRec	theLocationNameRec;
+	OSErr	err;
+
+	// nameScript and name should be resources to allow easy localization
+	thePPCPortRec.nameScript = smRoman;	// Roman script
+
+	// name is a pascal style string, need to cast it to call strcpy
+	strcpy((char *)thePPCPortRec.name,portName);
+	// convert back to Pascal string
+	CtoPstr((char *)thePPCPortRec.name);
+
+	// the port type should always be hard-coded to allow the
+	// application to find ports of a particular type even after
+	// the name is localized
+	thePPCPortRec.portKindSelector = ppcByString;
+
+	// name is a pascal style string, need to cast it to call strcpy
+	strcpy((char *)thePPCPortRec.u.portTypeStr,"wxIPC Appl");
+	CtoPstr((char *)thePPCPortRec.u.portTypeStr);
+
+	theLocationNameRec.locationKindSelector = ppcNBPTypeLocation;
+
+	// nbpType is a pascal style string, need to cast it to call strcpy
+	strcpy((char *)theLocationNameRec.u.nbpType,portName); // <<<< UNUSUAL
+	CtoPstr((char *)theLocationNameRec.u.nbpType);
+
+	thePPCOpenPBRec.serviceType = ppcServiceRealTime;
+	thePPCOpenPBRec.resFlag = 0;    // must be 0 for 7.0+
+	thePPCOpenPBRec.portName = &thePPCPortRec;
+	thePPCOpenPBRec.locationName  = &theLocationNameRec;
+
+	// make this a visible entity on the network
+	thePPCOpenPBRec.networkVisible 	= TRUE;
+
+	err  = PPCOpen(&thePPCOpenPBRec, FALSE);	// synchronous
+	*thePortRefNum  = thePPCOpenPBRec.portRefNum;
+	*nbpRegisterFlag = thePPCOpenPBRec.nbpRegistered;
+	return err;
+}
+
+//----------------------- START/INFORM SERVICES ---------------------------
+
+// Initiating a session using the PPCStart function
+
+OSErr ppcStart	(PortInfoPtr	thePortInfoPtr,
+						LocationNamePtr	theLocationNamePtr,
+						PPCPortRefNum	thePortRefNum,
+						PPCSessRefNum	*theSessRefNum,
+						long		*theUserRefNum,
+						long		*theRejectInfo)
+{
+	PPCStartPBRec	thePPCStartPBRec;
+	Str32		userName;
+	OSErr		err;
+
+	thePPCStartPBRec.ioCompletion	= NULL;
+
+	thePPCStartPBRec.portRefNum	= thePortRefNum;
+												// from PPCOpen function
+
+	thePPCStartPBRec.serviceType	= ppcServiceRealTime;
+
+	thePPCStartPBRec.resFlag	= 0;
+
+	thePPCStartPBRec.portName	= &thePortInfoPtr->name;
+												// destination port
+
+	thePPCStartPBRec.locationName	= theLocationNamePtr;
+												// destination location
+
+ // application-specific data for PPCInform
+ thePPCStartPBRec.userData = 0;
+
+	err = GetDefaultUser(&thePPCStartPBRec.userRefNum, userName);
+	if ( err != noErr )
+	   thePPCStartPBRec.userRefNum = 0;
+
+	if ( thePortInfoPtr->authRequired && !thePPCStartPBRec.userRefNum )
+	   // port selected does not allow guests and you do not have a default
+	   // user reference number, so you cannot log on to this port
+	   err = authFailErr;
+	else
+	   // attempt to log on
+	   err = PPCStart(&thePPCStartPBRec, FALSE);
+
+	if ( err == noErr ) {
+	   *theSessRefNum  = thePPCStartPBRec.sessRefNum;
+	   *theUserRefNum = thePPCStartPBRec.userRefNum;
+	   gSessionState = sOpen;
+	}
+	else if ( err == userRejectErr )
+		// return rejectInfo from the PPCReject function
+		*theRejectInfo = thePPCStartPBRec.rejectInfo;
+	return err;
+}
+
+
+// Using the PPCInform function to enable a port to receive sessions
+
+OSErr ppcInform(PPCParamBlockPtr	thePPCParamBlockPtr,
+						PPCPortPtr	thePPCPortPtr,
+						LocationNamePtr	theLocationNamePtr,
+						StringPtr	theUserNamePtr,
+						PPCPortRefNum	thePortRefNum
+	)
+{
+	
+	MyInformCompProcUPP = NewPPCCompProc(MyInformCompProc);
+	thePPCParamBlockPtr->informParam.ioCompletion	= MyInformCompProcUPP;
+	
+	// from the PPCOpen function
+	thePPCParamBlockPtr->informParam.portRefNum 	= thePortRefNum;
+	
+	// the completion routine handles accepting or rejecting requests
+	thePPCParamBlockPtr->informParam.autoAccept = FALSE;
+	thePPCParamBlockPtr->informParam.portName = thePPCPortPtr;
+	thePPCParamBlockPtr->informParam.locationName = theLocationNamePtr;
+	thePPCParamBlockPtr->informParam.userName = theUserNamePtr;
+	
+	return PPCInform((PPCInformPBPtr)thePPCParamBlockPtr, TRUE);
+}
+
+
+// Completion routine for a PPCInform function
+
+pascal void MyInformCompProc( PPCParamBlockPtr pb)
+
+{
+
+	if ( pb->informParam.ioResult == noErr ) {
+		// decide if this session should be accepted or rejected
+		// by looking at data supplied by the session requester
+		if ( pb->informParam.userData != -1 )
+		DoPPCAccept(pb);
+	   else
+		DoPPCReject(pb);
+	}
+	else
+		// use a global to tell the application that PPCParamBlockRec
+		// and the records it points to can be deallocated}
+	gPBInUse = FALSE;
+}
+
+
+// Accepting a session request using the PPCAccept function
+
+void DoPPCAccept(PPCParamBlockPtr pb)
+
+{
+	OSErr err;
+	// accept the session
+	MyAcceptCompProcUPP = NewPPCCompProc(MyAcceptCompProc);
+	pb->acceptParam.ioCompletion = MyAcceptCompProcUPP;
+	// the sessRefNum field is set by the PPCInform function
+	err = PPCAccept(&pb->acceptParam, TRUE);  
+}
+
+
+// Completion routine for a PPCAccept function
+
+pascal void MyAcceptCompProc(PPCParamBlockPtr pb)
+{
+	if ( pb->acceptParam.ioResult == noErr ) 
+			// accept completed so the session is completely open
+		
+		gSessionState = sOpening;
+		
+			// use a global to tell the application that PPCParamBlockRec
+			// and the records it points to can be deallocated
+		gPBInUse = FALSE;
+}
+
+
+// Rejecting a session request using the PPCReject function
+
+void DoPPCReject( PPCParamBlockPtr pb)
+{
+	OSErr err;
+
+			// reject the session}
+	MyRejectCompProcUPP = NewPPCCompProc(MyRejectCompProc);
+	pb->acceptParam.ioCompletion = MyRejectCompProcUPP;
+			// the sessRefNum field is set by the PPCInform function
+	pb->rejectParam.rejectInfo = -1;
+
+	err = PPCReject(&pb->rejectParam, TRUE);    
+}
+
+
+// Completion routine for a PPCReject function
+
+pascal void MyRejectCompProc(PPCParamBlockPtr pb)
+{
+	// use a global to tell the application that PPCParamBlockRec and
+	// the records it points to can be deallocated
+	gPBInUse = FALSE;
+}
+
+//------------------------------ READ/WRITE SERVICES ----------------------
+
+// Using the PPCRead function to read data during a session
+
+OSErr ppcStartRead(PPCReadPBPtr thePPCReadPBPtr,
+					PPCSessRefNum	theSessRefNum,
+					Size			theBufferLength,
+					Ptr			theBufferPtr
+	)
+{	
+	thePPCReadPBPtr->ioCompletion = NULL;
+	// from the PPCStart function  or the PPCInform function:
+	thePPCReadPBPtr->sessRefNum	= theSessRefNum;
+	thePPCReadPBPtr->bufferLength	= theBufferLength;
+	thePPCReadPBPtr->bufferPtr	= theBufferPtr;
+
+	return PPCRead(thePPCReadPBPtr, TRUE);  
+}
+
+OSErr ppcRead(PPCReadPBPtr	thePPCReadPBPtr,
+					PPCSessRefNum	theSessRefNum,
+					Size			theBufferLength,
+					Ptr			theBufferPtr
+	)
+{
+OSErr err;
+	
+	while ((err = thePPCReadPBPtr->ioResult) > 0)
+	{
+		if (WaitNextEvent( nullEvent, &noLockEvent, 30, NULL))
+		{
+		}
+	}
+	//if (err < 0) { Error("Read error on completion"); ("Code:%d\n",err); }
+	
+	return err;
+}
+
+
+// Polling the ioResult field to determine if a PPCRead function has completed
+
+Boolean MyReadComplete(PPCReadPBPtr thePPCReadPBPtr, OSErr *err)
+{
+    // Error result gets value of ioResult
+	*err = thePPCReadPBPtr->ioResult;
+
+	// Return false if error is 1.
+	return !*err;
+}
+
+/*-------------------------------------------------------------*/
+
+// Using the PPCWrite function to write data during a session
+
+OSErr ppcWrite(	PPCWritePBPtr	thePPCWritePBPtr,
+						PPCSessRefNum	theSessRefNum,
+						Size			theBufferLength,
+						Ptr			theBufferPtr
+						  )
+{
+	thePPCWritePBPtr->ioCompletion	= NULL;
+
+	// from the PPCStart function or the PPCInform function--
+	thePPCWritePBPtr->sessRefNum	= theSessRefNum;
+	thePPCWritePBPtr->bufferLength	= theBufferLength;
+	thePPCWritePBPtr->bufferPtr	= theBufferPtr;
+	thePPCWritePBPtr->more		= FALSE;   /* no more data to read */
+	thePPCWritePBPtr->userData	= 0;           /* app-specific data */
+#ifdef PPCC		// no known reason *why* this should be required !!!  
+	memcpy(&thePPCWritePBPtr->blockCreator, "????", 4);
+	memcpy(&thePPCWritePBPtr->blockType, "????", 4);
+#else
+	thePPCWritePBPtr->blockCreator	= '????';  /* app-specific data */
+	thePPCWritePBPtr->blockType	= '????';  /* app-specific data */
+#endif
+	return PPCWrite(thePPCWritePBPtr, TRUE); 
+}
+
+
+// Polling the ioResult field to determine if a PPCWrite function has completed
+
+Boolean MyWriteComplete(PPCWritePBPtr thePPCWritePBPtr,OSErr *err)
+{
+	// Check ioResult for error
+	*err = thePPCWritePBPtr->ioResult;
+
+	// Return false if error is 1
+	return !*err;
+}
+
+//------------------------ CLOSE SERVICES --------------------------------
+
+// Ending a PPC session using the PPCEnd function
+
+OSErr ppcEnd(PPCSessRefNum theSessRefNum)
+{
+	PPCEndPBRec thePPCEndPBRec;
+
+	// Set the Session ref number to pass to PPCEnd
+	thePPCEndPBRec.sessRefNum = theSessRefNum;
+
+	// Return result of PPCEnd
+	return PPCEnd(&thePPCEndPBRec, FALSE);	// synchronous
+}
+
+
+// Closing a PPC port using the PPCClose function
+
+OSErr ppcClose(PPCPortRefNum thePortRefNum)
+{
+	PPCClosePBRec theClosePBRec;
+
+	// Set the proper portRefNum, which is grabbed from PPCOpen function
+	theClosePBRec.portRefNum = thePortRefNum;
+
+	return PPCClose(&theClosePBRec, FALSE);	// synchronous
+}
+
+//-------------------------- LOCATE SERVICES ---------------------------------
+
+
+// Using a port filter function
+
+pascal Boolean MyBrowserPortFilter(LocationNameRec theLocationNameRec,
+												PortInfoRec thePortInfoRec)
+{
+	return TRUE;
+	// If port type selector for this port is a string
+	// check for the right port, otherwise return FALSE(don't display port)
+	if (thePortInfoRec.name.portKindSelector == ppcByString)
+		// If string matches port we are looking for, display it
+		if  ( !strcmp ((char *)thePortInfoRec.name.u.portTypeStr,
+					(char *)"\pwxIPC Appl" ) )
+		return TRUE;
+	else
+		return FALSE;
+	else
+		return FALSE;
+}
+
+
+// Browsing through dictionary service ports
+
+OSErr ppcBrowser(LocationNameRec *theLocationNameRec,
+				   PortInfoRec *thePortInfoRec)
+{
+	Str255	prompt;              // Prompt to display in dialogue
+	Str255 	applListLabel;    // Title for list of applications
+	Boolean 	defaultSpecified;
+	Str32 	theLocNBPType;
+
+	strcpy ((char *)prompt, "Choose an IPC service to link to:");
+	CtoPstr((char *)prompt);
+	strcpy((char *)applListLabel,"Services");
+	CtoPstr((char *)applListLabel);
+
+	defaultSpecified = TRUE;
+
+	theLocationNameRec->locationKindSelector = ppcNBPLocation;
+	strcpy((char *)theLocationNameRec->u.nbpEntity.objStr,"Moof");
+	CtoPstr((char *)theLocationNameRec->u.nbpEntity.objStr);
+	// typeStr is ignored
+	strcpy((char *)theLocationNameRec->u.nbpEntity.zoneStr,"Twilight");
+	CtoPstr((char *)theLocationNameRec->u.nbpEntity.zoneStr);
+
+	thePortInfoRec->name.nameScript = smRoman;
+	strcpy ((char *)thePortInfoRec->name.name,"server");
+	CtoPstr((char *)thePortInfoRec->name.name);
+	thePortInfoRec->name.portKindSelector = ppcByString;
+	strcpy ((char *)thePortInfoRec->name.u.portTypeStr,"wxIPC Appl");
+	CtoPstr((char *)thePortInfoRec->name.u.portTypeStr);
+
+	// when building the list of objects (Macintoshes), show only
+	// those with the NBP type "PPC Example"
+
+	strcpy ((char *)theLocNBPType ,"server"); // match this NBP type
+	CtoPstr((char *)theLocNBPType);
+
+	MyBrowserPortFilterUPP = NewPPCFilterProc(MyBrowserPortFilter);
+	return PPCBrowser(prompt, applListLabel, defaultSpecified,
+			theLocationNameRec, thePortInfoRec,
+			MyBrowserPortFilterUPP, theLocNBPType);
+}
+
+
+// Using the IPCListPorts function to obtain a list of ports
+
+OSErr ipcListPorts(short	theStartIndex,
+	short	theRequestCount, short 	*theActualCount,
+	Str32	theObjStr, Str32	theZoneStr,
+	PortInfoArrayPtr thePortInfoBufferPtr )
+
+{
+	IPCListPortsPBRec	theIPCListPortsPBRec;
+	PPCPortRec	thePPCPortRec;
+	LocationNameRec	theLocationNameRec;
+	OSErr	err;
+
+	// list all PPC ports at the specified location
+	thePPCPortRec.nameScript = smRoman;
+
+	// set name to match all names, NOTE call to CtoPstr to convert string
+	// back to Pascal style string.
+	strcpy((char *)thePPCPortRec.name,"=");
+	CtoPstr((char *)thePPCPortRec.name);
+
+	thePPCPortRec.portKindSelector = ppcByString;
+
+	// match all types,  NOTE call to CtoPstr to convert string
+	// back to pascal style string after casting for call to strcpy
+	strcpy((char *)thePPCPortRec.u.portTypeStr,"=");
+	CtoPstr((char *)thePPCPortRec.u.portTypeStr);
+
+	// The application must choose and supply the NBP zone string from
+	// the list returned by GetZoneList. Then, the application must
+	// choose and supply the NBP object string from the list returned by
+	// NBPLookup. This example looks for NBP type "PPC Example". If you
+	// don't supply your own NBP type, you should use "PPCToolBox" for
+	// the NBP type string.
+
+	theLocationNameRec.locationKindSelector = ppcNBPLocation;
+
+	// copy objstr, note casting to make C type string for strcpy
+	// then convert string back to pascal type string
+	strcpy ((char *)theLocationNameRec.u.nbpEntity.objStr,
+			(char *)theObjStr);
+	CtoPstr((char *)theLocationNameRec.u.nbpEntity.objStr);
+
+	// copy typestr, note casting to make C type string for strcpy
+	// then convert string back to pascal type string
+	strcpy((char *)theLocationNameRec.u.nbpEntity.typeStr,"PPC Example");
+	CtoPstr((char *)theLocationNameRec.u.nbpEntity.typeStr);
+
+	// copy zonestr, note casting to make C type string for strcpy
+	// then convert string back to pascal type string
+	strcpy((char *)theLocationNameRec.u.nbpEntity.zoneStr,
+			(char *)theZoneStr);
+	CtoPstr((char *)theLocationNameRec.u.nbpEntity.zoneStr);
+
+	theIPCListPortsPBRec.startIndex 	= theStartIndex;
+	theIPCListPortsPBRec.requestCount 	= theRequestCount;
+	theIPCListPortsPBRec.portName 	= &thePPCPortRec;
+	theIPCListPortsPBRec.locationName	= &theLocationNameRec;
+	theIPCListPortsPBRec.bufferPtr 	= thePortInfoBufferPtr;
+
+	err = IPCListPorts(&theIPCListPortsPBRec, FALSE);
+	*theActualCount = theIPCListPortsPBRec.actualCount;
+	return err;
+}
+
+
+
+
+
+
diff --git a/src/wxmac/src/mac/wxMargin.cc b/src/wxmac/src/mac/wxMargin.cc
new file mode 100644
index 0000000..0cfa2cd
--- /dev/null
+++ b/src/wxmac/src/mac/wxMargin.cc
@@ -0,0 +1,94 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxMargin.cc
+// Purpose:	wxMargin (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxMargin.h"
+#include "wxDirection.h"
+
+//=============================================================================
+// Construction methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxMargin::wxMargin(int margin)
+{
+	left = margin;
+	top = margin;
+	right = margin;
+	bottom = margin;
+}
+
+//-----------------------------------------------------------------------------
+wxMargin::wxMargin(int margin, Direction direction)
+{
+	left = (direction & Direction::wxLeft ? margin : 0);
+	top = (direction & Direction::wxTop ? margin : 0);
+	right = (direction & Direction::wxRight ? margin : 0);
+	bottom = (direction & Direction::wxBottom ? margin : 0);
+}
+
+//-----------------------------------------------------------------------------
+wxMargin::wxMargin(const wxMargin& margin)
+{
+	left = margin.left;
+	top = margin.top;
+	right = margin.right;
+	bottom = margin.bottom;
+}
+
+//-----------------------------------------------------------------------------
+wxMargin::~wxMargin(void)	// destructor
+{
+}
+
+//=============================================================================
+// Overloaded operator methods
+//=============================================================================
+
+wxMargin& wxMargin::operator +=(wxMargin margin)
+{
+	left += margin.left;
+	top += margin.top;
+	right += margin.right;
+	bottom += margin.bottom;
+	return *this;
+}
+
+//=============================================================================
+// Getter and setter methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxMargin::SetMargin(wxMargin margin, Direction direction)
+{
+	if (direction & Direction::wxLeft) left = margin.left;
+	if (direction & Direction::wxTop) top = margin.top;
+	if (direction & Direction::wxRight) right = margin.right;
+	if (direction & Direction::wxBottom) bottom = margin.bottom;
+}
+
+//-----------------------------------------------------------------------------
+void wxMargin::SetMargin(int margin, Direction direction)
+{
+	if (direction & Direction::wxLeft) left = margin;
+	if (direction & Direction::wxTop) top = margin;
+	if (direction & Direction::wxRight) right = margin;
+	if (direction & Direction::wxBottom) bottom = margin;
+}
+
+//-----------------------------------------------------------------------------
+int wxMargin::Offset(Direction direction)
+{
+	int result = 0;
+	if (direction & Direction::wxLeft) result += left;
+	if (direction & Direction::wxTop) result += top;
+	if (direction & Direction::wxRight) result += right;
+	if (direction & Direction::wxBottom) result += bottom;
+
+	return result;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wxRectBorder.cc b/src/wxmac/src/mac/wxRectBorder.cc
new file mode 100644
index 0000000..3977f31
--- /dev/null
+++ b/src/wxmac/src/mac/wxRectBorder.cc
@@ -0,0 +1,110 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxRectBorder.cc
+// Purpose:	Macintosh RectBorder implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wxRectBorder.h"
+#include "wx_area.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRectBorder::wxRectBorder // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int			margin,
+		Direction	direction,
+		int         whitespace,
+ 		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		WXTYPE		objectType
+	) :
+		wxBorder (parentArea, windowName, x, y, width, height, style, objectType)
+{
+	cWhitespace = whitespace;
+	parentArea->SetMargin(margin, direction);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRectBorder::~wxRectBorder(void)
+{
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+void wxRectBorder::DoShow(Bool on)
+{
+	if (!CanShow(on)) return;
+	
+	if (!on) {
+		SetCurrentDC();
+
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		
+		::EraseRect(&clientRect);
+		::InvalRect(&clientRect);
+	}
+	
+	wxWindow::DoShow(on);
+}
+
+//-----------------------------------------------------------------------------
+void wxRectBorder::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+
+	int clientWidth, clientHeight;
+	GetClientSize(&clientWidth, &clientHeight);
+	Rect clientRect = {0, 0, clientHeight, clientWidth};
+	int margin;
+
+	margin = ParentArea()->Margin().Offset(Direction::wxTop) - cWhitespace;
+	if (margin > 0) {
+		::PenSize(margin, margin);
+		::MoveTo(clientRect.left, clientRect.top);
+		::LineTo(clientRect.right - margin, clientRect.top);
+	}
+
+	margin = ParentArea()->Margin().Offset(Direction::wxBottom) - cWhitespace;
+	if (margin > 0) {
+		::PenSize(margin, margin);
+		::MoveTo(clientRect.left, clientRect.bottom - margin);
+		::LineTo(clientRect.right - margin, clientRect.bottom - margin);
+	}
+
+	margin = ParentArea()->Margin().Offset(Direction::wxLeft) - cWhitespace;
+	if (margin > 0) {
+		::PenSize(margin, margin);
+		::MoveTo(clientRect.left, clientRect.top);
+		::LineTo(clientRect.left, clientRect.bottom - margin);
+	}
+
+	margin = ParentArea()->Margin().Offset(Direction::wxRight) - cWhitespace;
+	if (margin > 0) {
+		::PenSize(margin, margin);
+		::MoveTo(clientRect.right - margin, clientRect.top);
+		::LineTo(clientRect.right - margin, clientRect.bottom - margin);
+	}
+}
diff --git a/src/wxmac/src/mac/wxScroll.cc b/src/wxmac/src/mac/wxScroll.cc
new file mode 100644
index 0000000..e7a5aa2
--- /dev/null
+++ b/src/wxmac/src/mac/wxScroll.cc
@@ -0,0 +1,187 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScroll.cc
+// Purpose:	wxScroll (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxScroll.h"
+#include "wx_utils.h"
+#include "wx_win.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScroll::wxScroll // root scroll
+(
+	wxWindow*		scrollWindow,
+	wxScrollData*	scrollData
+) :
+	cScrollWindow (scrollWindow),
+	cScrollData (scrollData),
+	cParentScroll (NULL),
+	cScrolls (wxList(wxList::kNoDestroyData))
+{
+	WXGC_IGNORE(scrollWindow);
+	if (!scrollWindow) wxFatalError("No scroll window for constructing scroll.");
+	if (!scrollData) wxFatalError("No scroll data for constructing root scroll.");
+}
+
+//-----------------------------------------------------------------------------
+wxScroll::wxScroll // child scroll
+(
+	wxWindow*	scrollWindow,
+	wxWindow*	parentScrollWindow
+) :
+	cScrollWindow (scrollWindow),
+	cScrollData (NULL),
+	cScrolls (wxList(wxList::kNoDestroyData))
+{
+	WXGC_IGNORE(scrollWindow);
+	if (!scrollWindow)
+		wxFatalError("No scroll window for constructing scroll.");
+	if (!parentScrollWindow)
+		wxFatalError("No parent scroll window for constructing scroll.");
+
+	cParentScroll = parentScrollWindow->GetScroll();
+	if (!cParentScroll)
+		wxFatalError("No parent scroll for constructing scroll.");
+
+	cParentScroll->cScrolls.Append(this);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScroll::~wxScroll(void)	// destructor
+{
+	// NOTE: Only the wxWindow object that owns this wxScroll should invoke its deletion.
+	//       Hence, owner will NULL out its cScroll link to this object
+
+	wxNode* childScrollNode = cScrolls.First();
+	while (childScrollNode)
+	{
+		wxScroll* childScroll = (wxScroll*)childScrollNode->Data();
+		childScroll->cParentScroll = cParentScroll;
+		if (cParentScroll) cParentScroll->cScrolls.Append(this);
+		childScrollNode = childScrollNode->Next();
+	}
+
+	delete cScrollData;
+
+	if (cParentScroll) cParentScroll->OnDeleteChildScroll(this);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Getter and setter methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxScrollData* wxScroll::GetScrollData (void)
+{
+	wxScroll* rootScroll = RootScroll();
+	wxScrollData* rootScrollData = rootScroll->cScrollData;
+
+	if (!rootScrollData) wxFatalError("No scroll data for scroll.");
+
+	return rootScrollData;
+}
+
+//-----------------------------------------------------------------------------
+void wxScroll::SetScrollData
+(
+	wxScrollData*		newScrollData,
+	wxWhatScrollData	whatScrollData, // items to be changed
+	wxWindow*			iniatorWindow
+)
+{
+	wxScrollData* scrollData = GetScrollData();
+	scrollData->SetValue(newScrollData, whatScrollData);
+	RootScroll()->OnSetScrollData(scrollData, whatScrollData, iniatorWindow);
+}
+
+//-----------------------------------------------------------------------------
+void wxScroll::SetScrollData
+(
+	int 				value,			// value for items to be changed
+	wxWhatScrollData	whatScrollData, // items to be changed
+	wxWindow*			iniatorWindow
+)
+{
+	wxScrollData* scrollData = GetScrollData();
+	scrollData->SetValue(value, whatScrollData);
+	RootScroll()->OnSetScrollData(scrollData, whatScrollData, iniatorWindow);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Scroll tree methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxScroll* wxScroll::RootScroll(void)
+{
+	wxScroll* result = this;
+	while (result->cParentScroll) result = result->cParentScroll;
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxScroll::AddChildScrollWindow(wxWindow* childScrollWindow)
+{
+	if (!childScrollWindow)
+		wxFatalError("No childScrollWindow for AddChildScrollWindow.");
+
+	wxScroll* childScroll = childScrollWindow->GetScroll();
+	if (!childScroll)
+		wxFatalError("No childScroll for AddChildScrollWindow.");
+
+	if (childScroll->cParentScroll)
+		wxFatalError("ChildScroll not root for AddChildScrollWindow.");
+	childScroll->cParentScroll = this;
+
+	cScrolls.Append(childScroll);
+
+	if (childScroll->cScrollData)
+	{
+		delete childScroll->cScrollData;
+		childScroll->cScrollData = NULL;
+	}
+
+	wxScrollData* scrollData = GetScrollData();
+	childScroll->OnSetScrollData(scrollData, wxWhatScrollData::wxAll, NULL);
+}
+
+//-----------------------------------------------------------------------------
+void wxScroll::OnDeleteChildScroll(wxScroll* childScroll)
+{
+	cScrolls.OnDeleteObject(childScroll);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxScroll::OnSetScrollData
+(
+	wxScrollData*		scrollData,
+	wxWhatScrollData	whatScrollData, // items to be changed
+	wxWindow*			iniatorWindow
+)
+{
+	wxNode* childScrollNode = cScrolls.First();
+	while (childScrollNode)
+	{
+		wxScroll* childScroll = (wxScroll*)childScrollNode->Data();
+		childScroll->OnSetScrollData(scrollData, whatScrollData, iniatorWindow);
+		childScrollNode = childScrollNode->Next();
+	}
+
+	cScrollWindow->SetScrollData(scrollData, whatScrollData, iniatorWindow);
+}
diff --git a/src/wxmac/src/mac/wxScrollArea.cc b/src/wxmac/src/mac/wxScrollArea.cc
new file mode 100644
index 0000000..89d318a
--- /dev/null
+++ b/src/wxmac/src/mac/wxScrollArea.cc
@@ -0,0 +1,108 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScrollArea.cc
+// Purpose:	Scroll area (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxScrollArea.h"
+#include "wx_sbar.h"
+#include "wx_utils.h"
+
+//=============================================================================
+// Construction methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScrollArea::wxScrollArea
+	(
+		wxWindow*	parentWindow,
+		wxWindow*	parentScrollWindow,
+		long		style
+	) :
+		wxArea (parentWindow),
+		cStyle (style),
+		cVScrollBar (NULL),
+		cHScrollBar (NULL)
+{
+	if (!parentScrollWindow) wxFatalError("No parentScrollWindow for wxScrollArea");
+
+	Bool bothScrolls = ((cStyle & wxVSCROLL) && (cStyle & wxHSCROLL));
+
+	// mflatt:
+    //  While a scrollbar should overap a frame edge when the scrollbar is positioned
+    //    along a frame edge, the full scroll bar outline must be drawn when a scrollbar
+    //    is not on a frame edge. This is why I went back to the old scrollbar positioning.
+    //  If someone can ge the new positioning but still have all of the scrollbar outline
+    //    drawn, I will be happy.
+
+	if (cStyle & wxVSCROLL)
+	{
+		cVScrollBar = new wxScrollBar(this, NULL, "",
+							0, 0, kVScrollBarWidth, 0, wxVSCROLL);
+		parentScrollWindow->AddChildScrollWindow(cVScrollBar);
+
+#if 0
+ 		// Vertical scrollbar should overlap top/right edges of frame
+ 		cVScrollBar->GravitateJustify
+ 					(Direction::wxRight | Direction::wxTop,
+ 					 Direction::wxVertical,
+ 					 0, -1,
+ 					 Width() + 1,
+ 					 Height() - (bothScrolls ? kHScrollBarHeight - 1 : 0) + 1);
+ 		cVScrollBar->SetJustify(Direction::wxVertical);
+ 		cVScrollBar->SetGravitate(Direction::wxRight);
+		SetMargin(kVScrollBarWidth - 1, Direction::wxRight);
+ 		// Inset parent's client area
+ 		parentScrollWindow->ClientArea()->SetMargin(kVScrollBarWidth - 1, Direction::wxRight);
+#else
+		cVScrollBar->GravitateJustify
+					(Direction::wxRight | Direction::wxTop,
+					 Direction::wxVertical,
+					 0, 0,
+					 Width(),
+					 Height() - (bothScrolls ? kHScrollBarHeight - 1 : 0));
+		cVScrollBar->SetJustify(Direction::wxVertical);
+		cVScrollBar->SetGravitate(Direction::wxRight);
+		SetMargin(kVScrollBarWidth, Direction::wxRight);
+#endif
+	}
+
+	if (cStyle & wxHSCROLL)
+	{
+		cHScrollBar = new wxScrollBar(this, NULL, "",
+							0, 0, 0, kHScrollBarHeight, wxHSCROLL);
+		parentScrollWindow->AddChildScrollWindow(cHScrollBar);
+#if 0 //GRW
+ 		// Horizontal scrollbar should overlap left/bottom edges of frame
+ 		cHScrollBar->GravitateJustify
+ 					(Direction::wxBottom | Direction::wxLeft,
+ 					 Direction::wxHorizontal,
+ 					 -1, 0,
+ 					 Width() - (bothScrolls ? kVScrollBarWidth - 1 : 0) + 1,
+ 					 Height() + 1);
+ 		cHScrollBar->SetJustify(Direction::wxHorizontal);
+ 		cHScrollBar->SetGravitate(Direction::wxBottom);
+		SetMargin(kHScrollBarHeight - 1, Direction::wxBottom);
+ 		// Inset parent's client area
+ 		parentScrollWindow->ClientArea()->SetMargin(kHScrollBarHeight - 1, Direction::wxBottom);
+#else
+		cHScrollBar->GravitateJustify
+					(Direction::wxBottom | Direction::wxLeft,
+					 Direction::wxHorizontal,
+					 0, 0,
+					 Width() - (bothScrolls ? kVScrollBarWidth - 1 : 0),
+					 Height());
+		cHScrollBar->SetJustify(Direction::wxHorizontal);
+		cHScrollBar->SetGravitate(Direction::wxBottom);
+		SetMargin(kHScrollBarHeight, Direction::wxBottom);
+#endif
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxScrollArea::~wxScrollArea(void)	// destructor
+{
+}
diff --git a/src/wxmac/src/mac/wxScrollData.cc b/src/wxmac/src/mac/wxScrollData.cc
new file mode 100644
index 0000000..dd5f12a
--- /dev/null
+++ b/src/wxmac/src/mac/wxScrollData.cc
@@ -0,0 +1,124 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxScrollData.cc
+// Purpose:	wxScrollData (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wxScrollData.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScrollData::wxScrollData
+(
+	void
+) :
+	cOriginX (0),
+	cOriginY (0),
+	cSizeW (0),
+	cSizeH (0),
+	cPositionH (0),
+	cPositionV (0),
+	cUnitW (0),
+	cUnitH (0),
+	cPageW (0),
+	cPageH (0)
+{
+}
+
+//-----------------------------------------------------------------------------
+wxScrollData::wxScrollData
+(
+	int					value,			// initial value for selected items
+	wxWhatScrollData	whatScrollData	// what items to initialize with given value
+) :
+	cOriginX ((long)whatScrollData & wxWhatScrollData::wxOriginX ? value : 0),
+	cOriginY ((long)whatScrollData & wxWhatScrollData::wxOriginY ? value : 0),
+	cSizeW ((long)whatScrollData & wxWhatScrollData::wxSizeW ? value : 0),
+	cSizeH ((long)whatScrollData & wxWhatScrollData::wxSizeH ? value : 0),
+	cPositionH ((long)whatScrollData & wxWhatScrollData::wxPositionH ? value : 0),
+	cPositionV ((long)whatScrollData & wxWhatScrollData::wxPositionV ? value : 0),
+	cUnitW ((long)whatScrollData & wxWhatScrollData::wxUnitW ? value : 0),
+	cUnitH ((long)whatScrollData & wxWhatScrollData::wxUnitH ? value : 0),
+	cPageW ((long)whatScrollData & wxWhatScrollData::wxPageW ? value : 0),
+	cPageH ((long)whatScrollData & wxWhatScrollData::wxPageH ? value : 0)
+{
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScrollData::~wxScrollData(void)	// destructor
+{
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Getter and setter methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxScrollData::SetValue
+(
+	wxScrollData* 		newScrollData,	// may have changes only
+	wxWhatScrollData 	whatScrollData	// items to be changed
+)
+{
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginX) 	cOriginX 	= newScrollData->cOriginX;
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginY) 	cOriginY 	= newScrollData->cOriginY;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeW) 	cSizeW 		= newScrollData->cSizeW;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeH) 	cSizeH 		= newScrollData->cSizeH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionH) cPositionH 	= newScrollData->cPositionH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionV) cPositionV 	= newScrollData->cPositionV;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitW) 	cUnitW 		= newScrollData->cUnitW;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitH) 	cUnitH 		= newScrollData->cUnitH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageW) 	cPageW 		= newScrollData->cPageW;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageH) 	cPageH 		= newScrollData->cPageH;
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollData::SetValue
+(
+	int 				value,	// value for items to be changed
+	wxWhatScrollData 	whatScrollData	// items to be changed
+)
+{
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginX) 	cOriginX 	= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginY) 	cOriginY 	= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeW) 	cSizeW 		= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeH) 	cSizeH 		= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionH) cPositionH 	= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionV) cPositionV 	= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitW) 	cUnitW 		= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitH) 	cUnitH 		= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageW) 	cPageW 		= value;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageH) 	cPageH 		= value;
+}
+
+//-----------------------------------------------------------------------------
+int wxScrollData::GetValue
+(
+	wxWhatScrollData	whatScrollData	// what item to get
+)
+{
+	int result = 0;
+
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginX) 	result 	= cOriginX;
+	if ((long)whatScrollData & wxWhatScrollData::wxOriginY) 	result 	= cOriginY;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeW) 	result 	= cSizeW;
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeH) 	result 	= cSizeH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionH) result 	= cPositionH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPositionV) result 	= cPositionV;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitW) 	result 	= cUnitW;
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitH) 	result 	= cUnitH;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageW) 	result 	= cPageW;
+	if ((long)whatScrollData & wxWhatScrollData::wxPageH) 	result 	= cPageH;
+
+	return result;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_app.cc b/src/wxmac/src/mac/wx_app.cc
new file mode 100644
index 0000000..9c62a86
--- /dev/null
+++ b/src/wxmac/src/mac/wx_app.cc
@@ -0,0 +1,925 @@
+////////////////////////////////////////////////////////////////////////////////
+// File:	wx_app.cc
+// Purpose:	wxApp implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+////////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <stdlib.h>
+#include <Events.h>
+#include <AppleEvents.h>
+#include <DiskInit.h>
+#include <Devices.h>
+#include <Resources.h>
+#include "wx_main.h"	// WCH : should split out stuff for wx_app.h and wb_app.h
+#include "wx_frame.h"
+#include "wx_menu.h"
+#include "wx_mnuit.h"
+#include "wx_utils.h"
+#include "wx_gdi.h"
+#include "wx_stdev.h"
+#include "wx_screen.h"
+#include "wx_area.h"
+#include "wx_timer.h"
+#include "wx_dialg.h"
+#include "wx_cmdlg.h"
+#include "wxTimeScale.h"
+#if (defined(powerc) || defined(__powerc)) && defined(MPW)
+QDGlobals 	qd;
+#endif
+
+extern void wxDoEvents();
+extern void wxDoNextEvent();
+extern int wxEventReady();
+
+wxScreen *theScreen;
+#if 0
+extern wxList gTimerList;
+#endif
+extern wxApp *wxTheApp;
+//-----------------------------------------------------------------------------
+wxApp::wxApp(wxlanguage_t language):wxbApp(language)
+{
+	wxTheApp = this;
+
+	::MaxApplZone();
+	for (long i = 1; i <= 4; i++) ::MoreMasters();
+	::FlushEvents(everyEvent, 0);
+	::InitGraf(&qd.thePort);
+	::InitFonts();
+	::InitWindows();
+	::InitMenus();
+	::TEInit();
+	::InitDialogs(0L);
+	::InitCursor();
+
+	wxFont::gMacFontGrafPort = new CGrafPort;
+	::OpenPort((GrafPtr)wxFont::gMacFontGrafPort);
+
+	cMacCursorRgn = ::NewRgn(); // forces cursor-move event right away
+	CheckMemOK(cMacCursorRgn);
+	wxScreen::gScreenWindow = new wxScreen;
+	wxArea* menuArea = (wxScreen::gScreenWindow)->MenuArea();
+	int menuBarHeight = GetMBarHeight();
+	menuArea->SetMargin(menuBarHeight, Direction::wxTop);
+
+	wx_frame = NULL;
+	death_processed = FALSE;
+	work_proc = NULL;
+	wx_class = NULL;
+	wxSetLanguage(language);
+	cLastMousePos.v = cLastMousePos.h = -1;
+
+	SysEnvRec sysEnvRec;
+	::SysEnvirons(2, &sysEnvRec);
+	if (!sysEnvRec.hasColorQD)
+	{
+		wxFatalError("Color QuickDraw is required, but not present.", "");
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxApp::~wxApp(void)
+{
+#if defined(DEBUG_NEW) && (DEBUG_NEW >= 2)
+	delete wxScreen::gScreenWindow;
+	DebugNewReportLeaks();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+Bool wxApp::Initialized(void)
+{
+	return (wx_frame != NULL);
+}
+
+extern void wxSetUpAppleMenu(wxMenuBar *mbar);
+extern void wxCheckFinishedSounds(void);
+
+//-----------------------------------------------------------------------------
+// Keep trying to process messages until WM_QUIT received
+//-----------------------------------------------------------------------------
+
+int wxApp::MainLoop(void)
+{
+#if 0
+	long sleepTime = 60;
+	wxNode *tmnode = gTimerList.First();
+	if (Button() || tmnode) // WCH: kludge; programmer should control amount of sleep time
+		sleepTime = 1; 		// if mouse down or timers exist then want quick response
+	else
+		sleepTime = GetDblTime(); // if front window has TE record
+
+	Bool gotEvent = WaitNextEvent(everyEvent, &cCurrentEvent,
+									sleepTime, cMacCursorRgn);
+	// ::SystemTask();
+
+	// Check for Timers that need to fire
+	while (tmnode) {
+		wxTimer *timer = (wxTimer *)tmnode->Data();
+		UInt32 nowticks = TickCount();
+		if (timer->milli && (timer->fireTime <= nowticks))
+		{
+			// its Time to go
+			timer->Notify();
+			if (timer->oneShot)
+			{
+				delete tmnode;
+				tmnode = gTimerList.First(); // start over again 
+			} 
+			else
+			{	// reset the future time
+				timer->fireTime = nowticks + (timer->milli / (1000 / CLOCKS_PER_SEC));
+				tmnode = tmnode->Next();
+			}
+		}
+		else
+		{
+			tmnode = tmnode->Next();
+		}
+	}
+	if (gotEvent)
+	{
+		Dispatch();
+	}
+	else 
+	{
+		DoIdle();
+#ifdef USE_IPC
+		void DoIPCIdle();
+
+		DoIPCIdle();
+#endif
+	}
+#endif
+
+	wxDoEvents();
+
+	return 0;
+}
+
+
+void wxApp::ExitMainLoop(void)
+{
+	death_processed = TRUE; 
+	keep_going = FALSE;
+}
+
+//-----------------------------------------------------------------------------
+Bool wxApp::Pending(void)
+{
+	return wxEventReady();
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::DoIdle(void)
+{
+	if ((cCurrentEvent.what == nullEvent) && cCurrentEvent.message)
+	  doMacMouseMotion();
+	AdjustCursor();
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::Dispatch(void)
+{
+  wxDoNextEvent();
+}
+
+void wxApp::doMacPreEvent()
+{
+    static Bool noWinMode = FALSE;
+    static wxFrame *oldFrontWindow = NULL;
+	WindowPtr w = ::FrontWindow();
+
+    wxCheckFinishedSounds();
+
+	if (!w && !noWinMode) {
+		::ClearMenuBar();
+		wxSetUpAppleMenu(NULL);
+		{
+			static MenuHandle m = NULL;
+			if (!m)
+				m = GetMenu(129);
+			if (m)
+				::InsertMenu(m, 0);
+		}
+		::InvalMenuBar();
+		wxSetCursor(wxSTANDARD_CURSOR);
+		noWinMode = TRUE;
+	} else if (w && noWinMode)
+		noWinMode = FALSE;
+
+	if (w) {
+		wxFrame* macWxFrame = findMacWxFrame(w);
+		if (macWxFrame)
+		{
+			if (oldFrontWindow != macWxFrame) {
+				oldFrontWindow->NowFront(FALSE);
+				macWxFrame->NowFront(TRUE);
+				oldFrontWindow = macWxFrame;
+			}
+		
+			wxWindow* focusWindow = macWxFrame->cFocusWindow;
+			if (focusWindow)
+			{
+				focusWindow->DoPeriodicAction();
+			}
+		}
+	}
+}
+
+void wxApp::doMacPostEvent()
+{
+	DoIdle();
+}
+
+void wxApp::doMacDispatch(EventRecord *e)
+{
+	memcpy(&cCurrentEvent, e, sizeof(EventRecord));
+
+	switch (e->what)
+	{
+		case mouseDown:
+			doMacMouseDown(); break;
+		case mouseUp:
+			doMacMouseUp(); break;
+		case keyDown:
+			doMacKeyDown(); break;
+		case autoKey:
+			doMacAutoKey(); break;
+		case keyUp:
+			doMacKeyUp(); break;
+		case activateEvt:
+			doMacActivateEvt(); break;
+		case updateEvt:
+			doMacUpdateEvt(); break;
+		case diskEvt:
+			doMacDiskEvt(); break;
+		case osEvt:
+			doMacOsEvt(); break;
+		case kHighLevelEvent:
+			doMacHighLevelEvent(); break;
+		default:
+			break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacMouseDown(void)
+{
+	WindowPtr window;
+	short windowPart = FindWindow(cCurrentEvent.where, &window);
+	switch (windowPart)
+	{
+		case inMenuBar:
+			long menuResult = MenuSelect(cCurrentEvent.where);
+			doMacInMenuBar(menuResult);
+			break;
+		case inContent:
+			doMacInContent(window); break;
+		case inDrag:
+			doMacInDrag(window); break;
+		case inGrow:
+			doMacInGrow(window); break;
+		case inGoAway:
+			doMacInGoAway(window); break;
+		case inZoomIn:
+		case inZoomOut:
+			doMacInZoom(window, windowPart); break;
+		default:
+			break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacMouseUp(void)
+{
+	wxWindow* mouseWindow = wxWindow::gMouseWindow;
+	if (mouseWindow)
+	{
+		int hitX = cCurrentEvent.where.h; // screen window c.s.
+		int hitY = cCurrentEvent.where.v; // screen window c.s.
+		mouseWindow->ScreenToClient(&hitX, &hitY); // mouseWindow client c.s.
+		mouseWindow->ClientToLogical(&hitX, &hitY); // mouseWindow logical c.s.
+		
+		wxMouseEvent *_theMouseEvent = new wxMouseEvent(wxEVENT_TYPE_LEFT_UP);
+		wxMouseEvent &theMouseEvent = *_theMouseEvent;
+		theMouseEvent.leftDown = FALSE;
+		theMouseEvent.middleDown = FALSE;
+		theMouseEvent.rightDown = FALSE;
+		theMouseEvent.shiftDown = cCurrentEvent.modifiers & shiftKey;
+		theMouseEvent.controlDown = cCurrentEvent.modifiers & controlKey;
+		// altKey is optionKey on the mac platform:
+		theMouseEvent.altDown = cCurrentEvent.modifiers & optionKey;
+		theMouseEvent.metaDown = cCurrentEvent.modifiers & cmdKey;  // mflatt
+		theMouseEvent.x = hitX;
+		theMouseEvent.y = hitY;
+		theMouseEvent.timeStamp = SCALE_TIMESTAMP(cCurrentEvent.when); // mflatt
+
+		/* Grab is now only used for grabbing on mouse-down for canvases */
+        if (wxSubType(mouseWindow->__type, wxTYPE_CANVAS))
+           mouseWindow->ReleaseMouse();
+						  
+		mouseWindow->OnEvent(theMouseEvent);
+	}
+	else
+ 	{
+ 		wxFrame* macWxFrame = findMacWxFrame(::FrontWindow());
+ 		if (macWxFrame)
+ 		{
+ 			int hitX = cCurrentEvent.where.h; // screen window c.s.
+ 			int hitY = cCurrentEvent.where.v; // screen window c.s.
+ 			wxArea* frameParentArea = macWxFrame->ParentArea();
+ 			frameParentArea->ScreenToArea(&hitX, &hitY);
+
+ 			wxMouseEvent *_theMouseEvent = new wxMouseEvent(wxEVENT_TYPE_LEFT_UP);
+			wxMouseEvent &theMouseEvent = *_theMouseEvent;
+ 			theMouseEvent.leftDown = FALSE;
+ 			theMouseEvent.middleDown = FALSE;
+ 			theMouseEvent.rightDown = FALSE;
+ 			theMouseEvent.shiftDown = cCurrentEvent.modifiers & shiftKey;
+ 			theMouseEvent.controlDown = cCurrentEvent.modifiers & controlKey;
+ 			// altKey is optionKey on the mac platform:
+ 			theMouseEvent.altDown = cCurrentEvent.modifiers & optionKey;
+ 			theMouseEvent.metaDown = cCurrentEvent.modifiers & cmdKey; // mflatt
+ 			theMouseEvent.x = hitX;
+ 			theMouseEvent.y = hitY;
+			theMouseEvent.timeStamp = SCALE_TIMESTAMP(cCurrentEvent.when); // mflatt
+
+ 			macWxFrame->SeekMouseEventArea(theMouseEvent);
+ 		}
+ 	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacMouseMotion(void)
+{
+	// RightButton is cmdKey click on the mac platform for one-button mouse
+	Bool isRightButton = cCurrentEvent.modifiers & cmdKey;
+	// altKey is optionKey on the mac platform:
+	Bool isAltKey = cCurrentEvent.modifiers & optionKey;
+#if 0
+	Bool isMouseDown = !(cCurrentEvent.modifiers & btnState);
+#else
+	Bool isMouseDown = (cCurrentEvent.modifiers & btnState);
+#endif
+
+	wxMouseEvent *_theMouseEvent = new wxMouseEvent(wxEVENT_TYPE_MOTION);
+	wxMouseEvent &theMouseEvent = *_theMouseEvent;
+    theMouseEvent.leftDown = isMouseDown && !isRightButton;
+	theMouseEvent.middleDown = FALSE;
+	theMouseEvent.rightDown = isMouseDown && isRightButton;
+	theMouseEvent.shiftDown = cCurrentEvent.modifiers & shiftKey;
+	theMouseEvent.controlDown = cCurrentEvent.modifiers & controlKey;
+	theMouseEvent.altDown = isAltKey;
+	theMouseEvent.metaDown = cCurrentEvent.modifiers & cmdKey;  // mflatt
+	theMouseEvent.timeStamp = SCALE_TIMESTAMP(cCurrentEvent.when); // mflatt
+		
+	if (wxWindow::gMouseWindow)
+	{
+		wxWindow* mouseWindow = wxWindow::gMouseWindow;
+		int hitX = cCurrentEvent.where.h; // screen window c.s.
+		int hitY = cCurrentEvent.where.v; // screen window c.s.
+		mouseWindow->ScreenToClient(&hitX, &hitY); // mouseWindow client c.s.
+		mouseWindow->ClientToLogical(&hitX, &hitY); // mouseWindow logical c.s.
+		theMouseEvent.x = hitX;
+		theMouseEvent.y = hitY;
+		mouseWindow->OnEvent(theMouseEvent);
+	}
+	else
+	{
+		wxFrame* macWxFrame = findMacWxFrame(::FrontWindow());
+		if (macWxFrame)
+		{
+			int hitX = cCurrentEvent.where.h; // screen window c.s.
+			int hitY = cCurrentEvent.where.v; // screen window c.s.
+			wxArea* frameParentArea = macWxFrame->ParentArea();
+			frameParentArea->ScreenToArea(&hitX, &hitY);
+			theMouseEvent.x = hitX; // frame parent area c.s.
+			theMouseEvent.y = hitY; // frame parent area c.s.
+
+			macWxFrame->SeekMouseEventArea(theMouseEvent);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// mflatt writes:
+// Probably, this should be moved into an abstracted function so that
+//   doMacKeyUp can call the same code.
+// Note that wxKeyEvent objects have two extra fields: timeStamp and
+//   metaDown. (On the Mac, metaDown is really commandDown.)
+static Bool doPreOnChar(wxWindow *in_win, wxWindow *win, wxKeyEvent *evt)
+{
+	wxWindow *p = win->GetParent();
+	return ((p && doPreOnChar(in_win, p, evt)) || win->PreOnChar(in_win, evt));
+}
+
+short wxMacDisableMods; /* If a modifier key is here, handle it specially */
+
+void wxApp::doMacKeyDown(void)
+{
+
+	wxFrame* theMacWxFrame = findMacWxFrame(::FrontWindow());
+	
+	if (!theMacWxFrame || theMacWxFrame->CanAcceptEvent())
+	  if (cCurrentEvent.modifiers & cmdKey) { // is menu command key equivalent ?
+	    if (cCurrentEvent.what == keyDown) { // ignore autoKey
+			  char key = cCurrentEvent.message & charCodeMask;
+			  long menuResult = MenuKey(key);
+			  if (menuResult) {
+			    doMacInMenuBar(menuResult);
+			    return;
+			  }
+		}
+	  }
+  
+    if (!theMacWxFrame || !theMacWxFrame->IsEnable())
+		return;	
+
+	static Handle transH = NULL;
+    static unsigned long transState = 0;
+    static Handle ScriptH = NULL;
+    static short region_code = 1;
+
+	if (!ScriptH) { // tom: don't guess the regioncode!!!!
+      struct ItlbRecord * r;
+      ScriptH = GetResource('itlb',0);
+      if (ScriptH) {
+      	HLock(ScriptH);
+      	r = (ItlbRecord*)*ScriptH;
+     	region_code = r->itlbKeys;  	
+      	HUnlock(ScriptH);
+      }	
+    }
+ 
+    
+    wxKeyEvent *_theKeyEvent = new wxKeyEvent(wxEVENT_TYPE_CHAR);
+    wxKeyEvent &theKeyEvent = *_theKeyEvent;
+    theKeyEvent.x = cCurrentEvent.where.h;
+    theKeyEvent.y = cCurrentEvent.where.v;
+    theKeyEvent.controlDown = Bool(cCurrentEvent.modifiers & controlKey);
+    theKeyEvent.shiftDown = Bool(cCurrentEvent.modifiers & shiftKey);
+    // altKey is optionKey on the mac platform:
+    theKeyEvent.altDown = Bool(cCurrentEvent.modifiers & optionKey);
+    theKeyEvent.metaDown = Bool(cCurrentEvent.modifiers & cmdKey);
+    theKeyEvent.timeStamp = SCALE_TIMESTAMP(cCurrentEvent.when);
+
+    int key = (cCurrentEvent.message & keyCodeMask) >> 8;
+    /* Better way than to use hard-wired key codes? */
+    switch (key) {
+    case 0x7e:
+    case 0x3e:
+      key = WXK_UP;
+      break;
+    case 0x7d:
+    case 0x3d:
+      key = WXK_DOWN;
+      break;
+    case 0x7b:
+    case 0x3b:
+      key = WXK_LEFT;
+      break;
+    case 0x7c:
+    case 0x3c:
+      key = WXK_RIGHT;
+      break;
+    case 0x24:
+    case 0x4c:
+      key = WXK_RETURN;
+      break;
+    case 0x30:
+      key = WXK_TAB;
+      break;
+    case 0x33:
+      key = WXK_BACK;
+      break;
+    case 0x75:
+      key = WXK_DELETE;
+      break;
+    case 0x73:
+	  key = WXK_HOME;
+	  break;
+	case 0x77:
+	  key = WXK_END;
+	  break;   
+	case 0x74:
+	  key = WXK_PRIOR;
+	  break;     
+	case 0x79:
+	  key = WXK_NEXT;
+	  break;     
+    default:
+      if (!transH) {
+		transH = GetResource('KCHR', region_code);
+		HNoPurge(transH);
+      }
+      if (transH && (cCurrentEvent.modifiers & wxMacDisableMods)) {
+		/* Remove effect of anything in wxMacDisableMods: */
+		int mods = cCurrentEvent.modifiers - (cCurrentEvent.modifiers & wxMacDisableMods);
+		HLock(transH);
+		key = KeyTranslate(*transH, (key & 0x7F) | mods, &transState) & charCodeMask;
+		HUnlock(transH);
+	  } else 
+		key = cCurrentEvent.message & charCodeMask;
+	} // end switch
+
+	theKeyEvent.keyCode = key;
+
+	wxWindow *in_win = theMacWxFrame->GetFocusWindow();
+	if (!in_win || !doPreOnChar(in_win, in_win, &theKeyEvent))
+		theMacWxFrame->OnChar(theKeyEvent);
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacAutoKey(void)
+{
+	doMacKeyDown();
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacKeyUp(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacActivateEvt(void)
+{
+	WindowPtr theMacWindow = WindowPtr(cCurrentEvent.message);
+	wxFrame* theMacWxFrame = findMacWxFrame(theMacWindow);
+	if (theMacWxFrame)
+	{
+		Bool becomingActive = cCurrentEvent.modifiers & activeFlag;
+		theMacWxFrame->Activate(becomingActive);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacUpdateEvt(void)
+{
+	WindowPtr theMacWindow = WindowPtr(cCurrentEvent.message);
+	wxFrame* theMacWxFrame = findMacWxFrame(theMacWindow);
+	if (theMacWxFrame)
+	{
+		theMacWxFrame->MacUpdateWindow();
+	} else {
+		BeginUpdate(theMacWindow);
+		EndUpdate(theMacWindow);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacDiskEvt(void)
+{ // based on "Programming for System 7" by Gary Little and Tim Swihart
+	if ((cCurrentEvent.message >> 16) != noErr)
+	{
+		const int kDILeft = 0x0050; // top coord for disk init dialog
+		const int kDITop = 0x0070; // left coord for disk init dialog
+		Point mountPoint;
+		mountPoint.h = kDILeft;
+		mountPoint.v = kDITop;
+		int myError = DIBadMount(mountPoint, cCurrentEvent.message);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacOsEvt(void)
+{ // based on "Programming for System 7" by Gary Little and Tim Swihart
+	switch ((cCurrentEvent.message >> 24) & 0x0ff)
+	{
+		case suspendResumeMessage:
+			if (cCurrentEvent.message & resumeFlag)
+			{
+				doMacResumeEvent();
+			}
+			else
+			{
+				doMacSuspendEvent();
+			}
+			break;
+		case mouseMovedMessage:
+			doMacMouseMovedMessage();
+			break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacHighLevelEvent(void)
+{ // based on "Programming for System 7" by Gary Little and Tim Swihart
+	::AEProcessAppleEvent(&cCurrentEvent); // System 7 or higher
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacResumeEvent(void)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(::FrontWindow());
+	if (theMacWxFrame)
+	{
+		if (cCurrentEvent.message & convertClipboardFlag)
+			::TEFromScrap();
+		Bool becomingActive = TRUE;
+		theMacWxFrame->Activate(becomingActive);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacSuspendEvent(void)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(::FrontWindow());
+	if (theMacWxFrame)
+	{
+		::ZeroScrap();
+		::TEToScrap();
+		Bool becomingActive = TRUE;
+		theMacWxFrame->Activate(!becomingActive);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacMouseMovedMessage(void)
+{ // based on "Programming for System 7" by Gary Little and Tim Swihart
+	if (cMacCursorRgn) ::DisposeRgn(cMacCursorRgn);
+	cMacCursorRgn = ::NewRgn();
+	CheckMemOK(cMacCursorRgn);
+	::SetRectRgn(cMacCursorRgn, -32768, -32768, 32766, 32766);
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInMenuBar(long menuResult)
+{
+	int macMenuId = HiWord(menuResult);
+	int macMenuItemNum = LoWord(menuResult); // counting from 1
+
+	if (macMenuId == 0) 					// no menu item selected;
+		 return;
+	if (macMenuId == 128) {
+		if (macMenuItemNum != 1) {			// if not the "About" entry (or the separator)
+			Str255		daName;
+			GetItem(GetMHandle(128), macMenuItemNum, daName);
+			(void) OpenDeskAcc(daName);
+			return;
+		}
+	}
+
+	WindowPtr theMacWindow = ::FrontWindow();
+	if (!theMacWindow) {
+		wxTheApp->ExitMainLoop();
+		return;
+	}
+	
+	wxFrame* theMacWxFrame = findMacWxFrame(theMacWindow);
+	if (!theMacWxFrame) wxFatalError("No wxFrame for theMacWindow.");
+
+	if (theMacWxFrame->IsModal())
+	{
+		::SysBeep(3);
+		return;
+	}
+
+	wxMenuBar* theWxMenuBar = theMacWxFrame->wx_menu_bar;
+	if (!theWxMenuBar) {
+	  /* Must be the About or Close item. */
+	  if (macMenuId == 128) {
+	  	DoDefaultAboutItem();
+	  } else {
+	    if (theMacWxFrame->OnClose())
+	      theMacWxFrame->Show(FALSE);
+	  }
+	  return;
+	  // wxFatalError("No wxMenuBar for wxFrame.");
+	}
+
+	wxMenu* theWxMenu;
+	if (macMenuId == 128 && macMenuItemNum == 1) {
+		// This will Help/About selection
+		if (theWxMenu = theWxMenuBar->wxHelpHackMenu) {
+			macMenuItemNum = theWxMenuBar->iHelpMenuHackNum;
+		} else {
+			DoDefaultAboutItem();
+			return;
+		}
+	}
+	else {
+		theWxMenu = theWxMenuBar->wxMacFindMenu(macMenuId);
+	}
+	if (!theWxMenu) wxFatalError("No wxMenu for wxMenuBar.");
+
+	wxNode* node = theWxMenu->menuItems.Nth(macMenuItemNum - 1); // counting from 0
+	if (!node) wxFatalError("No wxNode for Nth menuItem.");
+
+	wxMenuItem* theWxMenuItem = (wxMenuItem*) node->Data();
+	if (!theWxMenuItem) wxFatalError("No wxMenuItem for wxNode.");
+
+	theMacWxFrame->ProcessCommand(theWxMenuItem->itemId);
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInContent(WindowPtr window)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(window);
+	if (theMacWxFrame)
+	{
+		if (window != ::FrontWindow())
+		{		
+			wxFrame* frontFrame = findMacWxFrame(::FrontWindow());
+			if (!frontFrame) wxFatalError("No wxFrame for frontWindow.");
+			if (0 && !frontFrame->IsModal())
+			{
+				 ::SelectWindow(window); //WCH : should I be calling some wxMethod?
+			}
+			else ::SysBeep(3);
+		}
+		else
+		{
+			doMacContentClick(theMacWxFrame);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacContentClick(wxFrame* frame)
+{
+	// RightButton is cmdKey click  on the mac platform for one-button mouse
+	Bool rightButton = cCurrentEvent.modifiers & cmdKey;
+	// altKey is optionKey on the mac platform:
+	Bool isAltKey = cCurrentEvent.modifiers & optionKey;
+
+	WXTYPE mouseEventType = rightButton ? wxEVENT_TYPE_RIGHT_DOWN
+										: wxEVENT_TYPE_LEFT_DOWN;
+	wxMouseEvent *_theMouseEvent = new wxMouseEvent(mouseEventType);
+	wxMouseEvent &theMouseEvent = *_theMouseEvent;
+	theMouseEvent.leftDown = !rightButton;
+	theMouseEvent.middleDown = FALSE;
+	theMouseEvent.rightDown = rightButton;
+	theMouseEvent.shiftDown = cCurrentEvent.modifiers & shiftKey;
+	theMouseEvent.controlDown = cCurrentEvent.modifiers & controlKey;
+	theMouseEvent.altDown = isAltKey;
+	theMouseEvent.metaDown = FALSE;  // mflatt
+	theMouseEvent.timeStamp = SCALE_TIMESTAMP(cCurrentEvent.when); // mflatt
+
+	int hitX = cCurrentEvent.where.h; // screen window c.s.
+	int hitY = cCurrentEvent.where.v; // screen window c.s.
+	wxArea* frameParentArea = frame->ParentArea();
+	frameParentArea->ScreenToArea(&hitX, &hitY);
+	theMouseEvent.x = hitX; // frame parent area c.s.
+	theMouseEvent.y = hitY; // frame parent area c.s.
+
+	frame->SeekMouseEventArea(theMouseEvent);
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInDrag(WindowPtr window)
+{
+	if (window != ::FrontWindow())
+	{
+		wxFrame* frontFrame = findMacWxFrame(::FrontWindow());
+		if (!frontFrame) wxFatalError("No wxFrame for frontWindow.");
+		if (0 && frontFrame->IsModal())
+		{
+			::SysBeep(3);
+			return;
+		}
+	}
+
+	wxFrame* theMacWxFrame = findMacWxFrame(window);
+	if (theMacWxFrame)
+	{
+		Rect dragBoundsRect = qd.screenBits.bounds;
+		::InsetRect(&dragBoundsRect, 4, 4); // This is not really necessary
+		::DragWindow(window, cCurrentEvent.where, &dragBoundsRect);
+		theMacWxFrame->wxMacRecalcNewSize(); // Actually, recalc new position only
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInGrow(WindowPtr window)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(window);
+	if (theMacWxFrame && theMacWxFrame->CanAcceptEvent())
+	{
+		Rect growSizeRect; // WCH: growSizeRect should be a member of wxFrame class
+		growSizeRect.top = 1; // minimum window height
+		growSizeRect.left = 1; // minimum window width
+		growSizeRect.bottom = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
+		growSizeRect.right = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
+		long windSize = ::GrowWindow(window, cCurrentEvent.where, &growSizeRect);
+		if (windSize != 0)
+		{
+			wxArea* contentArea = theMacWxFrame->ContentArea();
+			int newContentWidth = LoWord(windSize);
+			int newContentHeight = HiWord(windSize);
+			if (newContentWidth == 0) newContentWidth = contentArea->Width(); // no change
+			if (newContentHeight == 0) newContentHeight = contentArea->Height(); // no change
+			contentArea->SetSize(newContentWidth, newContentHeight);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInGoAway(WindowPtr window)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(window);
+	if (theMacWxFrame && theMacWxFrame->CanAcceptEvent())
+	{
+		if (TrackGoAway(window, cCurrentEvent.where))
+		{
+			Bool okToDelete = theMacWxFrame->OnClose();
+			if (okToDelete) {
+#if WXGARBAGE_COLLECTION_ON
+				theMacWxFrame->Show(FALSE);
+#else
+				delete theMacWxFrame;
+#endif
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxApp::doMacInZoom(WindowPtr window, short windowPart)
+{
+	wxFrame* theMacWxFrame = findMacWxFrame(window);
+	if (theMacWxFrame && theMacWxFrame->CanAcceptEvent())
+	{
+		if (TrackBox(window, cCurrentEvent.where, windowPart))
+		{
+			theMacWxFrame->Maximize(windowPart == inZoomOut);
+		}
+		
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxFrame* wxApp::findMacWxFrame(WindowPtr theMacWindow)
+{
+#if 0
+	wxFrame* result = NULL;
+	wxNode* node = wxTopLevelWindows(NULL)->First();
+	while (node && !result)
+	{
+		wxWindow* theWxWindow = (wxWindow*) node->Data();
+		if (theWxWindow->IsMacWindow())
+		{
+			if (((wxFrame*)theWxWindow)->macWindow() == theMacWindow)
+			{
+				result = (wxFrame*) theWxWindow;
+			}
+		}
+    	if (!result) node = node->Next();
+	}
+
+	return result;
+#else
+	if (theMacWindow)
+	  return (wxFrame *)((WindowRecord *)theMacWindow)->refCon;
+	else
+	  return NULL;
+#endif
+ }
+
+ //-----------------------------------------------------------------------------
+ void wxApp::AdjustCursor(void)
+ {
+ 	wxFrame* theMacWxFrame = findMacWxFrame(::FrontWindow());
+ 	if (theMacWxFrame) {
+ 	  if (theMacWxFrame->cBusyCursor)
+ 	    wxSetCursor(wxHOURGLASS_CURSOR);
+ 	  else {
+ 		/* 
+ 		if (cCurrentEvent.what != kHighLevelEvent)
+ 		{
+ 			cLastMousePos.h = cCurrentEvent.where.h;
+ 			cLastMousePos.v = cCurrentEvent.where.v;
+ 		}
+ 		*/
+ 		Point p;
+ 		GetMouse(&p);
+ 		LocalToGlobal(&p);
+ 		int hitX = p.h; // screen window c.s.
+ 		int hitY = p.v; // screen window c.s.
+ 		wxArea* frameParentArea = theMacWxFrame->ParentArea();
+ 		frameParentArea->ScreenToArea(&hitX, &hitY);
+ 		if (!theMacWxFrame->AdjustCursor(hitX, hitY))
+ 			wxSetCursor(wxSTANDARD_CURSOR);
+ 	  }
+ 	} else
+ 	  wxSetCursor(wxSTANDARD_CURSOR);
+ }
+
+ //-----------------------------------------------------------------------------
+char *wxApp::GetDefaultAboutItemName(void)
+{
+	return "About wxWindows...";
+}
+
+void wxApp::DoDefaultAboutItem(void)
+{
+	wxMessageBox("This application was implemented with wxWindows,\n"
+				 "Copyright 1993-94, AIAI, University of Edinburgh.\n"
+				 "All Rights Reserved.",
+				"wxWindows");
+}
diff --git a/src/wxmac/src/mac/wx_area.cc b/src/wxmac/src/mac/wx_area.cc
new file mode 100644
index 0000000..da5bab3
--- /dev/null
+++ b/src/wxmac/src/mac/wx_area.cc
@@ -0,0 +1,359 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wxArea.cc
+// Purpose:	window area (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "wx_area.h"
+#include "wx_win.h"
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wx_screen.h"
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxArea::wxArea
+(
+	wxWindow* parentWindow
+) :
+	cWindows (wxChildList())
+{
+	__type = wxTYPE_AREA;	//cjc
+	//__type = wxTYPE_PANEL; // CJC, WCH kludge
+	if (!parentWindow) wxFatalError("No parentWindow for wxArea");
+
+	cParentWindow = parentWindow; /*OLD*/
+	parentWindow->Areas()->Insert(this);
+
+	WXGC_IGNORE(cParentWindow);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxArea::~wxArea(void)
+{
+	wxChildNode *node, *next;
+	for (node = cWindows.First(); node; node = next) {
+		next = node->Next();
+		wxWindow *win = (wxWindow *)node->Data();
+		if (win)
+		  delete win;
+	}
+	if (cParentWindow) cParentWindow->OnDeleteChildArea(this);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxMargin wxArea::Margin(void) { return cMargin; }
+
+//-----------------------------------------------------------------------------
+// Margin from this area to outer area
+//-----------------------------------------------------------------------------
+wxMargin wxArea::Margin(wxArea* outerArea)
+{
+	wxMargin result;
+	wxArea* area = this;
+	wxWindow* window = ParentWindow();
+	while (area && area != outerArea)
+	{
+		area = area->Previous();
+		if (area)
+		{
+			result += area->Margin();
+		}
+		else
+		{
+			if (window != wxScreen::gScreenWindow)
+			{
+				result += window->Margin(window->ParentArea());
+				area = window->ParentArea();
+				window = area->ParentWindow();
+			}
+		}
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+// Margin from this area to outer window
+//-----------------------------------------------------------------------------
+wxMargin wxArea::Margin(wxWindow* outerWindow)
+{
+	wxMargin result;
+	wxArea* area = this;
+	wxWindow* window = ParentWindow();
+	while (area)
+	{
+		area = area->Previous();
+		if (area)
+		{
+			result += area->Margin();
+		}
+		else
+		{
+			if (window != outerWindow)
+			{
+				if (window != wxScreen::gScreenWindow)
+				{
+					result += window->Margin(window->ParentArea());
+					area = window->ParentArea();
+					window = area->ParentWindow();
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+int wxArea::Width(void)
+{
+	wxMargin margin = Margin(ParentWindow());
+	return ParentWindow()->Width() - margin.Offset(Direction::wxHorizontal);
+}
+
+//-----------------------------------------------------------------------------
+int wxArea::Height(void)
+{
+	wxMargin margin = Margin(ParentWindow());
+	return ParentWindow()->Height() - margin.Offset(Direction::wxVertical);
+}
+
+//-----------------------------------------------------------------------------
+// Convert from this area c.s. to screen c.s.
+//-----------------------------------------------------------------------------
+void wxArea::AreaToScreen(int* h, int* v)
+{
+	wxMargin screenMargin = Margin(wxScreen::gScreenWindow);
+	*h += screenMargin.Offset(Direction::wxLeft);
+	*v += screenMargin.Offset(Direction::wxTop);
+}
+
+//-----------------------------------------------------------------------------
+// Convert from screen c.s. to this area c.s.
+//-----------------------------------------------------------------------------
+void wxArea::ScreenToArea(int* h, int* v)
+{
+	wxMargin screenMargin = Margin(wxScreen::gScreenWindow);
+	*h -= screenMargin.Offset(Direction::wxLeft);
+	*v -= screenMargin.Offset(Direction::wxTop);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxArea::WindowPointInArea(int windowH, int windowV)
+{
+	wxMargin margin = Margin(ParentWindow());
+	int areaH = windowH - margin.Offset(Direction::wxLeft); // area c.s.
+	int areaV = windowV - margin.Offset(Direction::wxTop); // area c.s.
+	return (0 <= areaH && areaH <= Width() && 0 <= areaV && areaV <= Height());
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::FrameContentAreaOffset(int* x, int* y)
+{
+	wxFrame* frame = ParentWindow()->GetRootFrame();
+	wxArea* frameContentArea = frame->ContentArea();
+	wxMargin frameContentAreaMargin = Margin(frameContentArea);
+	*x = frameContentAreaMargin.Offset(Direction::wxLeft);
+	*y = frameContentAreaMargin.Offset(Direction::wxTop);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxArea::SetSize(int width, int height)
+{
+	wxMargin margin = Margin(ParentWindow());
+	int	newWindowWidth = width + margin.Offset(Direction::wxHorizontal);
+	int newWindowHeight = height + margin.Offset(Direction::wxVertical);
+	ParentWindow()->SetWidthHeight(newWindowWidth, newWindowHeight);
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::SetMargin(int margin, Direction direction)
+{
+	wxMargin newMargin(margin, direction);
+	SetMargin(newMargin, direction);
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::SetMargin(wxMargin margin, Direction direction)
+{
+	int oldLeft = cMargin.Offset(Direction::wxLeft);
+	int oldTop = cMargin.Offset(Direction::wxTop);
+	int oldRight = cMargin.Offset(Direction::wxRight);
+	int oldBottom = cMargin.Offset(Direction::wxBottom);
+
+	cMargin.SetMargin(margin, direction);
+
+	int dL = cMargin.Offset(Direction::wxLeft) - oldLeft;
+	int dT = cMargin.Offset(Direction::wxTop) - oldTop;
+	int dR = cMargin.Offset(Direction::wxRight) - oldRight;
+	int dB = cMargin.Offset(Direction::wxBottom) - oldBottom;
+
+	int dW = -(dR + dL);
+	int dH = -(dB + dT);
+	int dX = dL;
+	int dY = dT;
+	wxArea* area = Next(); // Resize younger sibling areas
+	while (area)
+	{
+		area->OnSiblingDSize(dW, dH, dX, dY);
+		area = area->Next();
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::SetMargin(wxMargin margin, Direction direction,
+						int parentWindowWidth, int parentWindowHeight,
+						int parentWindowX, int parentWindowY)
+{
+// SetSize of parentWindow
+	int oldWindowX, oldWindowY;
+	cParentWindow->GetPosition(&oldWindowX, &oldWindowY);
+	int oldWindowWidth = cParentWindow->Width();
+	int oldWindowHeight = cParentWindow->Height();
+
+	cParentWindow->DoSetSize(parentWindowX, parentWindowY, parentWindowWidth, parentWindowHeight);
+
+	int newWindowX, newWindowY;
+	cParentWindow->GetPosition(&newWindowX, &newWindowY);
+	int newWindowWidth = cParentWindow->Width();
+	int newWindowHeight = cParentWindow->Height();
+	int dW = newWindowWidth - oldWindowWidth;
+	int dH = newWindowHeight - oldWindowHeight;
+	int dX = newWindowX - oldWindowX;
+	int dY = newWindowY - oldWindowY;
+
+// Notify older siblings and this area of parentWindow resizing
+	wxArea* area = First();
+	while (area && area != this)
+	{
+		area->OnSiblingDSize(dW, dH, dX, dY);
+		area = area->Next();
+	}
+	if (area != this) wxFatalError("Error in wxArea::SetMargin");
+	OnSiblingDSize(dW, dH, dX, dY);
+
+// SetMargin of this area
+	int oldLeft = cMargin.Offset(Direction::wxLeft);
+	int oldTop = cMargin.Offset(Direction::wxTop);
+	int oldRight = cMargin.Offset(Direction::wxRight);
+	int oldBottom = cMargin.Offset(Direction::wxBottom);
+
+	cMargin.SetMargin(margin, direction);
+
+// Notify younger siblings of parentWindow resizing and margin changes for this area
+	int dL = cMargin.Offset(Direction::wxLeft) - oldLeft;
+	int dT = cMargin.Offset(Direction::wxTop) - oldTop;
+	int dR = cMargin.Offset(Direction::wxRight) - oldRight;
+	int dB = cMargin.Offset(Direction::wxBottom) - oldBottom;
+
+	dW += -(dR + dL); // accumulate changes for parentWindow and this area
+	dH += -(dB + dT); // accumulate changes for parentWindow and this area
+	dX += dL; // accumulate changes for parentWindow and this area
+	dY += dT; // accumulate changes for parentWindow and this area
+	area = Next(); // Resize younger sibling areas
+	while (area)
+	{
+		area->OnSiblingDSize(dW, dH, dX, dY);
+		area = area->Next();
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::OnSiblingDSize(int dW, int dH, int dX, int dY)
+{
+	// Must change W, H, X, Y of this area: but these are virtual variables.
+	// Hence, change is effectively already done.
+
+	OnAreaDSize(dW, dH, dX, dY);
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::OnAreaDSize(int dW, int dH, int dX, int dY)
+{
+	if (dW || dH || dX || dY)
+	{
+		if (this == cParentWindow->ClientArea())
+		{ // Notify parent window of client resize.
+			// The parent window manages the contents of the client area.
+			// Hence, must notify parent window that its client area has resized.
+			cParentWindow->OnClientAreaDSize(dW, dH, dX, dY);
+		}
+		else
+		{ // Notify child windows of area resize.
+			wxChildNode* childWindowNode = Windows()->First();
+			while (childWindowNode)
+			{
+				wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+				childWindow->OnAreaDSize(dW, dH, dX, dY);
+				childWindowNode = childWindowNode->Next();
+			}
+		}
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree (windows and areas) methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxWindow* wxArea::ParentWindow(void) { return cParentWindow; }
+
+//-----------------------------------------------------------------------------
+wxChildList* wxArea::Windows(void) { return &cWindows; } // kludge
+
+//-----------------------------------------------------------------------------
+wxArea* wxArea::First(void)
+{
+	wxArea* result = NULL;
+	wxNode* nodeArea = ParentWindow()->Areas()->First();
+	if (nodeArea) result = (wxArea*) nodeArea->Data();
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+wxArea* wxArea::Previous(void)
+{
+	wxArea* result = NULL;
+	wxNode* nodeArea = ParentWindow()->Areas()->Member(this);
+	nodeArea = nodeArea->Previous();
+	if (nodeArea) result = (wxArea*) nodeArea->Data();
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+wxArea* wxArea::Next(void)
+{
+	wxArea* result = NULL;
+	wxNode* nodeArea = ParentWindow()->Areas()->Member(this);
+	nodeArea = nodeArea->Next();
+	if (nodeArea) result = (wxArea*) nodeArea->Data();
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxArea::OnDeleteChildWindow(wxWindow* childWindow)
+{
+	cWindows.DeleteObject(childWindow);
+}
diff --git a/src/wxmac/src/mac/wx_buttn.cc b/src/wxmac/src/mac/wx_buttn.cc
new file mode 100644
index 0000000..b1a1155
--- /dev/null
+++ b/src/wxmac/src/mac/wx_buttn.cc
@@ -0,0 +1,473 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_buttn.cc
+// Purpose:	Panel item button implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_buttn.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_panel.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+#include "wb_gdi.h"
+#include <Windows.h>
+#include "wxButtonBorder.h"
+
+#if 1
+#define MIN_BUTTON_WIDTH 58
+#define BUTTON_H_SPACE 12
+#define BUTTON_V_SPACE 4
+#else
+/* Original parameters */
+#define MIN_BUTTON_WIDTH 60
+#define BUTTON_H_SPACE 20
+#define BUTTON_V_SPACE 10
+#endif
+
+#define IB_MARGIN_X 2
+#define IB_MARGIN_Y 2
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxButton::wxButton // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbButton (parentPanel, x, y, width, height, style, windowName)
+		
+{
+	Create(parentPanel, function, label, x, y, width, height, style, windowName, objectType);
+}
+
+void wxButton::Create // Real constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) 	
+{
+    buttonBitmap = NULL;
+	cColorTable = NULL;
+		
+	Callback(function);
+
+	font = buttonFont; // WCH: mac platform only
+	
+	label = wxItemStripLabel(label);
+
+	if (width <= 0 || height <= 0)
+	{
+		float fWidth, fHeight;
+		GetTextExtent(label, &fWidth, &fHeight, NULL, NULL, buttonFont);
+		if (width <= 0)
+		{
+			width = fWidth + BUTTON_H_SPACE;
+			if (width < MIN_BUTTON_WIDTH) width = MIN_BUTTON_WIDTH;
+			cWindowWidth = width;
+		}
+
+		if (height <= 0)
+		{
+			height = fHeight + BUTTON_V_SPACE;
+			cWindowHeight = height;
+		}
+	}
+
+	cBorderArea = new wxArea(this);
+	new wxButtonBorder(cBorderArea);
+
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	Rect boundsRect = {0, 0, ClientArea()->Height(), ClientArea()->Width()};
+	wxMacString theMacTitle = label;
+	const Bool drawNow = TRUE; // WCH: use FALSE, then show after ChangeColour??
+	const short offValue = 0;
+	const short minValue = 0;
+	const short maxValue = 1;
+	short refCon = 0;
+	cMacControl = ::NewControl((WindowPtr)theMacGrafPort, &boundsRect, theMacTitle(),
+			drawNow, offValue, minValue, maxValue, pushButProc + useWFont, refCon);
+	CheckMemOK(cMacControl);
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+wxButton::wxButton // Constructor (given parentPanel, bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbButton (parentPanel, x, y, width, height, style, windowName),
+		cColorTable(NULL)
+{
+	if (bitmap->Ok() && (bitmap->selectedIntoDC >= 0)) {
+	  buttonBitmap = bitmap;
+	  buttonBitmap->selectedIntoDC++;
+	} else {
+	  Create(parentPanel, function, "<bad-image>", x, y, width, height, style, windowName, objectType);
+	  return;
+	}
+
+	Callback(function);
+	
+	SetEraser(wxWHITE_BRUSH);
+
+	cBorderArea = new wxArea(this);
+	new wxButtonBorder(cBorderArea);
+
+	cMacControl = NULL;
+	
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	Rect bounds = {0, 0, buttonBitmap->GetHeight(), buttonBitmap->GetWidth()};
+	bounds.bottom += 2 * IB_MARGIN_Y;
+	bounds.right += 2 * IB_MARGIN_X;
+	cWindowHeight = bounds.bottom;
+	cWindowWidth = bounds.right;
+
+	::InvalRect(&bounds);
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxButton::~wxButton(void)
+{
+	if (buttonBitmap == NULL) {
+		if (cMacControl) ::DisposeControl(cMacControl);
+	} else
+		--buttonBitmap->selectedIntoDC;
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::ChangeColour(void)
+{
+	if (buttonBitmap)
+		return;
+	if (cColorTable == NULL)
+	{
+		cColorTable = (CCTabHandle)NewHandle(40);
+		CheckMemOK(cColorTable);
+		(**cColorTable).ccSeed = 0;
+		(**cColorTable).ccRider = 0;
+		(**cColorTable).ctSize = 2;
+		(**cColorTable).ctTable[0].value = cFrameColor;
+		(**cColorTable).ctTable[1].value = cBodyColor;
+		(**cColorTable).ctTable[2].value = cTextColor;
+		(**cColorTable).ctTable[3].value = cThumbColor;
+	}
+
+	RGBColor whiteColor = {65535, 65535, 65535};
+	RGBColor blackColor = {0, 0, 0};
+
+	wxColour* backgroundColour = GetBackgroundColour();
+	RGBColor backgroundRGB;
+	backgroundRGB = backgroundColour ? backgroundColour->pixel : blackColor;
+	(**cColorTable).ctTable[0].rgb = backgroundRGB;
+
+	wxColour* buttonColour = GetButtonColour();
+	RGBColor buttonRGB;
+	buttonRGB = buttonColour ? buttonColour->pixel : whiteColor;
+	(**cColorTable).ctTable[1].rgb = buttonRGB;
+
+
+	wxColour* labelColour = GetLabelColour();
+	RGBColor labelRGB;
+	labelRGB = labelColour ? labelColour->pixel : blackColor;
+	(**cColorTable).ctTable[2].rgb = labelRGB;
+
+     if (cMacControl)
+	  ::SetCtlColor(cMacControl, cColorTable);
+}
+
+//-----------------------------------------------------------------------------
+char* wxButton::GetLabel(void)
+{
+	Str255	pTitle;
+	char	cTitle[256];
+	if (buttonBitmap)
+		return NULL;
+	if (cMacControl)
+	  ::GetCTitle(cMacControl, pTitle);
+	wxMacPtoCString(pTitle, wxBuffer);
+    return wxBuffer;
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::SetLabel(char* label)
+{
+  if (buttonBitmap)
+		return;
+  if (label)
+  {
+	SetCurrentDC();
+  	wxMacString1 theMacString1 = label;
+  	if (cMacControl)
+  	  ::SetCTitle(cMacControl, theMacString1());
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::SetLabel(wxBitmap* bitmap)
+{
+  if (!buttonBitmap || !bitmap->Ok() || (bitmap->selectedIntoDC < 0))
+    return;
+  --buttonBitmap->selectedIntoDC;
+  buttonBitmap = bitmap;
+  buttonBitmap->selectedIntoDC++;
+  Refresh();
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::SetDefault(Bool flag) // WCH : modification of original (see below too)
+{ // WCH: a panel method should be swapping default buttons
+  // WCH: we would then have: void wxPanel::SetDefault(wxItem* item), NULL item allowed
+	wxPanel* panel = (wxPanel*) GetParent();
+	if (!panel) wxFatalError("No panel for wxButton::SetDefault.");
+	wxButton* currentDefault = panel->defaultItem; // WCH: let any wxItem be a default item ?
+
+	if (flag) // this becoming default item
+	{
+		if (currentDefault != this)
+		{
+			if (currentDefault) currentDefault->OnSetDefault(FALSE);
+			panel->defaultItem = this;
+			OnSetDefault(TRUE);
+		}
+	}
+	else // this no longer default item
+	{
+		if (currentDefault == this)
+		{
+			currentDefault->OnSetDefault(FALSE);
+			panel->defaultItem = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::OnSetDefault(Bool flag) // WCH : addition to original
+{ // WCH: the panel should invoke the default button to distinguish itself
+	if (buttonBitmap)
+		return;
+	if (flag)
+	{
+		wxMargin margin(4);
+		cBorderArea->SetMargin(margin, Direction::wxAll,
+						cWindowWidth + 8, cWindowHeight + 8,
+						cWindowX - 4, cWindowY - 4);
+	}
+	else
+	{
+		wxMargin margin(0);
+		cBorderArea->SetMargin(margin, Direction::wxAll,
+						cWindowWidth - 8, cWindowHeight - 8,
+						cWindowX + 4, cWindowY + 4);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::Enable(Bool enable)
+{
+	wxWindow::Enable(enable);
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::Paint(void)
+{
+	if (cHidden) return;
+	SetCurrentDC();
+	Rect r = { 0, 0, cWindowHeight, cWindowWidth};
+	::EraseRect(&r);
+	if (buttonBitmap) {
+		FrameRoundRect(&r, 2 * IB_MARGIN_X, 2 * IB_MARGIN_Y);
+		buttonBitmap->DrawMac(IB_MARGIN_X, IB_MARGIN_Y);
+	}
+	else if (cMacControl) {
+		Bool isVisible = (**cMacControl).contrlVis == 255;
+		if (!isVisible) return;
+		::Draw1Control(cMacControl);
+	}
+	wxWindow::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	if (!buttonBitmap && cMacControl) {
+	  SetCurrentDC();
+
+	  if (show)
+		::ShowControl(cMacControl);
+	  else
+		::HideControl(cMacControl);
+	}
+	
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::ShowAsActive(Bool flag) // mac platform only
+{
+
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::Highlight(Bool flag) // mac platform only
+{
+	if (buttonBitmap) {
+		SetCurrentDC();
+		Rect bounds = {1, 1, cWindowHeight - 1, cWindowWidth - 1};
+		::InvertRect(&bounds /* , 2 * IB_MARGIN_X, 2 * IB_MARGIN_Y */);
+	} else if (cMacControl) {
+		if (cEnable)
+		{
+			SetCurrentDC();
+			::HiliteControl(cMacControl, flag ? inButton : 0);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::OnEvent(wxMouseEvent& event) // mac platform only
+{
+	if (event.LeftDown())
+	{
+		SetCurrentDC();
+	
+		float fStartH, fStartV;
+		event.Position(&fStartH, &fStartV); // client c.s.
+		int startH = fStartH;
+		int startV = fStartV;
+	
+		Point startPt = {startH, startV}; // client c.s.
+		int trackResult;
+		if (::StillDown()) {
+			if (buttonBitmap == NULL && cMacControl)
+				trackResult = ::TrackControl(cMacControl, startPt, NULL);
+			else
+				trackResult = Track(startPt);
+		} else {
+			Highlight(TRUE); // highlight button
+			long delayTicks = 4; // one tick is 1/60th of a second
+			long finalTicks;
+			Delay(delayTicks, &finalTicks);
+			Highlight(FALSE); // unhighlight button
+		
+			trackResult = 1;
+		}
+		if (trackResult)
+		{
+			wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_BUTTON_COMMAND);
+			commandEvent->eventObject = this;
+	  		ProcessCommand(*commandEvent);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxButton::Command(wxCommandEvent& event) // mac platform only (also xview platform)
+{
+	if (cEnable)
+	{
+		Highlight(TRUE); // highlight button
+		long delayTicks = 10; // one tick is 1/60th of a second
+		long finalTicks;
+		Delay(delayTicks, &finalTicks);
+		Highlight(FALSE); // unhighlight button
+	  	ProcessCommand(event);
+  	}
+}
+
+void wxButton::ChangeToGray(Bool gray)
+{
+  SetCurrentDC();
+  if (cMacControl)
+    ::HiliteControl(cMacControl, gray ? kInactiveControl : kActiveControl);
+    
+  wxWindow::ChangeToGray(gray);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Sizing methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxButton::OnClientAreaDSize(int dW, int dH, int dX, int dY) // mac platform only
+{
+	SetCurrentDC();
+	if (buttonBitmap || !cMacControl)
+		return;
+
+	Bool isVisible = (**cMacControl).contrlVis == 255;
+	Bool hideToPreventFlicker = (isVisible && (dX || dY) && (dW || dH));
+	if (hideToPreventFlicker) ::HideControl(cMacControl);
+
+	if (dW || dH)
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		::SizeControl(cMacControl, clientWidth, clientHeight);
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put new origin at (0, 0)
+		::MoveControl(cMacControl, 0, 0);
+	}
+
+	if (hideToPreventFlicker) ::ShowControl(cMacControl);
+
+	if (!cHidden && (dW || dH || dX || dY))
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+	}
+}
diff --git a/src/wxmac/src/mac/wx_canvs.cc b/src/wxmac/src/mac/wx_canvs.cc
new file mode 100644
index 0000000..5e8726e
--- /dev/null
+++ b/src/wxmac/src/mac/wx_canvs.cc
@@ -0,0 +1,544 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_canvs.cc
+// Purpose:	wxCanvas implementation
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_canvs.h"
+#include "wx_dccan.h"
+#include "wx_utils.h"
+#include "wx_area.h"
+#include "wx_sbar.h"
+#include "wxScroll.h"
+#include "wx_frame.h"
+#include <QuickDraw.h>
+#include "wxScrollArea.h"
+#include "wxBorderArea.h"
+
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxCanvas::wxCanvas // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbCanvas (windowName, parentFrame, x, y, width, height, style)
+{
+	InitDefaults();
+}
+
+ 
+ //-----------------------------------------------------------------------------
+ wxCanvas::wxCanvas // Constructor (given parentArea)
+ 	(
+ 		wxArea*		parentArea,
+ 		int 		x,
+ 		int			y,
+ 		int			width,
+ 		int			height,
+ 		long		style,
+ 		char*		windowName,
+ 		WXTYPE		objectType
+ 	) :
+ 		wxbCanvas (windowName, parentArea, x, y, width, height, style)
+ {
+ 	InitDefaults();
+
+ 	wx_dc = new wxCanvasDC(this); // wx_dc should be defined in wx_canvas not wxb_canvas??
+ }
+
+ //-----------------------------------------------------------------------------
+ wxCanvas::wxCanvas // Constructor (given parentWindow)
+ 	(
+ 		wxWindow*	parentWindow,
+ 		int 		x,
+ 		int			y,
+ 		int			width,
+ 		int			height,
+ 		long		style,
+ 		char*		windowName,
+ 		WXTYPE		objectType
+ 	) :
+ 		wxbCanvas (windowName, parentWindow, x, y, width, height, style)
+ {
+ 	InitDefaults();
+ }
+
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxCanvas::~wxCanvas(void)
+{
+	if (wx_dc) delete wx_dc; // WCH: should be done in wxbCanvas
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxCanvas::InitDefaults(void)
+{
+	units_x = 0;
+	units_y = 0;
+	units_per_page_x = 0;
+	units_per_page_y = 0;
+	hExtent = 0;
+	vExtent = 0;
+	hScrollingEnabled = TRUE;
+	vScrollingEnabled = TRUE;
+	scrollAutomanaged = TRUE;
+
+ 	wx_dc = new wxCanvasDC(this); // wx_dc should be defined in wx_canvas not wxb_canvas??
+
+	if (cStyle & wxBORDER) {
+		int direction = Direction::wxAll;
+		if (cStyle & wxVSCROLL)
+			direction -= Direction::wxRight;
+		if (cStyle & wxHSCROLL)
+			direction -= Direction::wxBottom;
+
+		wxBorderArea *border = new wxBorderArea(this, 1, direction);
+	}
+
+ 	if (cStyle & wxVSCROLL || cStyle & wxHSCROLL)
+ 	{
+ 		wxScrollData* scrollData = new wxScrollData;
+ 		cScroll = new wxScroll(this, scrollData);
+ 		new wxScrollArea(this, this, (cStyle & wxVSCROLL) | (cStyle & wxHSCROLL));
+ 	}
+}
+
+void wxCanvas::AddWhiteRgn(RgnHandle rgn)
+{
+	if (wxSubType(__type, wxTYPE_PANEL))
+	  wxWindow::AddWhiteRgn(rgn);
+	else {
+	  int theRootX, theRootY, w, h;
+	  RgnHandle wrgn;
+	  cClientArea->FrameContentAreaOffset(&theRootX, &theRootY);
+	  GetClientSize(&w, &h);
+	  if (wrgn = NewRgn()) {
+	  	 SetRectRgn(wrgn, theRootX, theRootY, theRootX + w, theRootY + h);
+	  	 UnionRgn(rgn, wrgn, rgn);
+	  	 DisposeRgn(wrgn);
+	  }
+	}
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxCanvas::BeginDrawing(void)
+{
+	if (wx_dc) wx_dc->BeginDrawing();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::EndDrawing(void)
+{
+	if (wx_dc) wx_dc->EndDrawing();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::SetColourMap(wxColourMap* cmap)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+// update deviceContext ?
+	if (wx_dc)
+	{
+		int clientWidth = ClientArea()->Width();
+		int clientHeight= ClientArea()->Height();
+		Rect paintRect = {0, 0, clientHeight, clientWidth};
+		wx_dc->SetPaintRegion(&paintRect);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// horizontal/vertical: number of pixels per unit (e.g. pixels per text line)
+// x/y_length:        : no. units per scrollbar
+// x/y_page:          : no. units per page scrolled
+//-----------------------------------------------------------------------------
+void wxCanvas::SetScrollbars(int horizontal, int vertical,
+                             int x_length, int y_length,
+                             int x_page, int y_page,
+                             int x_pos, int y_pos,
+							 Bool automgmt
+							)
+{
+	if (!cScroll) 
+		return;
+		
+    if (!(cStyle & wxHSCROLL))
+      horizontal = -1;
+    if (!(cStyle & wxVSCROLL))
+      vertical = -1;
+
+	scrollAutomanaged = automgmt; //mflatt
+
+	wxWhatScrollData whatScrollData; // track what scrolldata changes
+	wxScrollData* oldScrollData = cScroll->GetScrollData();
+	wxScrollData scrollData;
+	if (oldScrollData) scrollData = *oldScrollData;
+
+	int sizeH = (vertical > 0 ? max(y_length, 1) : 0);
+	if (sizeH != scrollData.GetValue(wxWhatScrollData::wxSizeH))
+	{
+		scrollData.SetValue(sizeH, wxWhatScrollData::wxSizeH);
+		whatScrollData |= wxWhatScrollData::wxSizeH;
+	}
+
+	int unitH = (vertical > 0 ? vertical : 0);
+	if (unitH != scrollData.GetValue(wxWhatScrollData::wxUnitH))
+	{
+		scrollData.SetValue(unitH, wxWhatScrollData::wxUnitH);
+		whatScrollData |= wxWhatScrollData::wxUnitH;
+	}
+
+	if (vertical < 0) y_page = 1;
+	if (y_page != scrollData.GetValue(wxWhatScrollData::wxPageH))
+	{
+		scrollData.SetValue(y_page, wxWhatScrollData::wxPageH);
+		whatScrollData |= wxWhatScrollData::wxPageH;
+	}
+
+	if (vertical < 0) y_pos = 0;
+	if (y_pos != scrollData.GetValue(wxWhatScrollData::wxPositionV))
+	{
+		scrollData.SetValue(y_pos, wxWhatScrollData::wxPositionV);
+		whatScrollData |= wxWhatScrollData::wxPositionV;
+	}
+
+	int sizeW = (horizontal > 0 ? max(x_length, 1) : 0);
+	if (sizeW != scrollData.GetValue(wxWhatScrollData::wxSizeW))
+	{
+		scrollData.SetValue(sizeW, wxWhatScrollData::wxSizeW);
+		whatScrollData |= wxWhatScrollData::wxSizeW;
+	}
+
+	int unitW = (horizontal > 0 ? horizontal : 0);
+	if (unitW != scrollData.GetValue(wxWhatScrollData::wxUnitW))
+	{
+		scrollData.SetValue(unitW, wxWhatScrollData::wxUnitW);
+		whatScrollData |= wxWhatScrollData::wxUnitW;
+	}
+
+	if (horizontal < 0) x_page = 1;
+	if (x_page != scrollData.GetValue(wxWhatScrollData::wxPageW))
+	{
+		scrollData.SetValue(x_page, wxWhatScrollData::wxPageW);
+		whatScrollData |= wxWhatScrollData::wxPageW;
+	}
+
+	if (horizontal < 0) x_pos = 0;
+	if (x_pos != scrollData.GetValue(wxWhatScrollData::wxPositionH))
+	{
+		scrollData.SetValue(x_pos, wxWhatScrollData::wxPositionH);
+		whatScrollData |= wxWhatScrollData::wxPositionH;
+	}
+
+	if ((long)whatScrollData != 0)
+		cScroll->SetScrollData(&scrollData, whatScrollData, NULL);	
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::SetScrollData
+(
+	wxScrollData*		scrollData,
+	wxWhatScrollData	whatScrollData,
+	wxWindow*			iniatorWindow
+)
+{
+	if (iniatorWindow == this) return;
+
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeW)
+		units_x = scrollData->GetValue(wxWhatScrollData::wxSizeW);
+
+	if ((long)whatScrollData & wxWhatScrollData::wxSizeH)
+		units_y = scrollData->GetValue(wxWhatScrollData::wxSizeH);
+
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitW)
+		horiz_units = scrollData->GetValue(wxWhatScrollData::wxUnitW);
+
+	if ((long)whatScrollData & wxWhatScrollData::wxUnitH)
+		vert_units = scrollData->GetValue(wxWhatScrollData::wxUnitH);
+
+	if ((long)whatScrollData & wxWhatScrollData::wxPageW)
+		units_per_page_x = scrollData->GetValue(wxWhatScrollData::wxPageW);
+
+	if ((long)whatScrollData & wxWhatScrollData::wxPageH)
+		units_per_page_y = scrollData->GetValue(wxWhatScrollData::wxPageH);
+
+ 	if (!scrollAutomanaged) {
+ 	  // Scrollbars do not automatically change the canvas:
+	  wxCommandEvent *simulEvent = new wxCommandEvent(wxTYPE_EVENT);
+ 	  OnScroll(*simulEvent);
+          return;
+ 	}
+
+ 	hExtent = horiz_units * units_x;
+ 	vExtent = vert_units * units_y;
+ 	wxDC* theDC = GetDC();
+ 	if (theDC)
+	{
+		int dH = 0;
+		if ((long)whatScrollData & wxWhatScrollData::wxPositionH)
+		{
+			int newH = scrollData->GetValue(wxWhatScrollData::wxPositionH) *
+						scrollData->GetValue(wxWhatScrollData::wxUnitW);
+			dH = newH - (-theDC->device_origin_x);
+		}
+	
+		int dV = 0;
+		if ((long)whatScrollData & wxWhatScrollData::wxPositionV)
+		{
+			int newV = scrollData->GetValue(wxWhatScrollData::wxPositionV) *
+						scrollData->GetValue(wxWhatScrollData::wxUnitH);
+			dV = newV - (-theDC->device_origin_y);
+		}
+	
+		if (dH != 0 || dV != 0)
+		{
+			wxArea* clientArea = ClientArea();
+			Rect scrollRect = {0, 0, clientArea->Height(), clientArea->Width()};
+			RgnHandle theUpdateRgn = ::NewRgn();
+			CheckMemOK(theUpdateRgn);
+			theDC->BeginDrawing();
+			::ScrollRect(&scrollRect, -dH, -dV, theUpdateRgn);
+			::InvalRgn(theUpdateRgn);
+			theDC->device_origin_x += -dH;
+			theDC->device_origin_y += -dV;
+			theDC->EndDrawing();
+			::DisposeRgn(theUpdateRgn);
+
+			wxFrame* rootFrame = GetRootFrame();
+			rootFrame->MacUpdateWindow(); // kludge, since update events not highest priority
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::GetScrollUnitsPerPage(int* x_page, int* y_page)
+{
+	*x_page = units_per_page_x;
+	*y_page = units_per_page_y;
+}
+
+//-----------------------------------------------------------------------------
+// Scroll to given position (scroll position, not pixel position)
+//-----------------------------------------------------------------------------
+void wxCanvas::Scroll(int xPos, int yPos)
+{
+	if (!cScroll) return;
+
+	wxWhatScrollData whatScrollData; // track what scrolldata changes
+	wxScrollData* oldScrollData = cScroll->GetScrollData();
+	wxScrollData scrollData;
+	if (oldScrollData) scrollData = *oldScrollData;
+
+	if (xPos != -1)
+	{
+		if (xPos != scrollData.GetValue(wxWhatScrollData::wxPositionH))
+		{
+			scrollData.SetValue(xPos, wxWhatScrollData::wxPositionH);
+			whatScrollData |= wxWhatScrollData::wxPositionH;
+		}
+	}
+
+	if (yPos != -1)
+	{
+		if (yPos != scrollData.GetValue(wxWhatScrollData::wxPositionV))
+		{
+			scrollData.SetValue(yPos, wxWhatScrollData::wxPositionV);
+			whatScrollData |= wxWhatScrollData::wxPositionV;
+		}
+	}
+
+	if ((long)whatScrollData != 0)
+		cScroll->SetScrollData(&scrollData, whatScrollData, NULL);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::EnableScrolling(Bool x_scroll, Bool y_scroll)
+{
+	hScrollingEnabled = x_scroll;
+	vScrollingEnabled = y_scroll;
+}
+
+//-----------------------------------------------------------------------------
+int wxCanvas::GetScrollsPerPage(int orientation) // mac platform only
+{
+	return (orientation == wxHSCROLL ? units_per_page_x : units_per_page_y);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::GetVirtualSize(int* x, int* y)
+{
+	int x1, y1;
+	GetClientSize(&x1, &y1);
+	if (hExtent == 0)
+		*x = x1;
+	else
+		*x = hExtent;
+
+	if (vExtent == 0)
+		*y = y1;
+	else
+		*y = vExtent;
+}
+
+//-----------------------------------------------------------------------------
+// Where the current view starts from
+//-----------------------------------------------------------------------------
+void wxCanvas::ViewStart(int* x, int* y)
+{
+	int xx = 0;
+	int yy = 0;
+
+	if (cScroll)
+	{
+		wxScrollData* scrollData = cScroll->GetScrollData();
+		xx = scrollData->GetValue(wxWhatScrollData::wxPositionH);
+		yy = scrollData->GetValue(wxWhatScrollData::wxPositionV);
+	}
+	
+	*x = xx;
+	*y = yy;
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::WarpPointer(int x_pos, int y_pos)
+{
+  // Move the pointer to (x_pos,y_pos) coordinates. They are expressed in
+  // pixel coordinates, relatives to the canvas -- So, we only need to
+  // substract origin of the window.
+
+  if (GetDC())
+  {
+    x_pos += (int)(GetDC()->device_origin_x) ;
+    y_pos += (int)(GetDC()->device_origin_y) ;
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	wxChildNode* node = GetChildren()->First();
+	while (node)
+	{
+		wxWindow* theChildWindow = (wxWindow*)node->Data();
+		theChildWindow->DoShow(show);
+		node = node->Next();
+	}
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvas::ClientToLogical(int* x, int* y) // mac platform only; testing
+{ // Transform point from client c.s. to logical c.s. (virtual canvas, scrolling)
+	wxDC* theDC = GetDC();
+	if (theDC)
+	{
+		float fX = theDC->DeviceToLogicalX(*x);
+		float fY = theDC->DeviceToLogicalY(*y);
+		*x = fX;
+		*y = fY;
+    }
+}
+
+Bool wxCanvas::WantsFocus(void)
+{
+	return !cHidden;
+}
+
+
+// ----------------Modifications for wxMedia (mflatt) ----------------
+void wxCanvas::SetScrollPage(int dir, int val)
+{
+  wxCanvas::SetScrollbars(horiz_units, vert_units, 
+					units_x, units_y,
+					(dir == wxHORIZONTAL) ? val : units_per_page_x,
+					(dir == wxVERTICAL) ? val : units_per_page_y,
+					GetScrollPos(wxHORIZONTAL), GetScrollPos(wxVERTICAL), scrollAutomanaged);
+}
+
+void wxCanvas::SetScrollRange(int dir, int val)
+{
+  wxCanvas::SetScrollbars((dir == wxHORIZONTAL) ? (val > 0) : horiz_units,
+						(dir == wxVERTICAL) ? (val > 0) : vert_units,
+						(dir == wxHORIZONTAL) ? val : units_x,
+						(dir == wxVERTICAL) ? val : units_y,
+						units_per_page_x, units_per_page_y, 
+						GetScrollPos(wxHORIZONTAL), GetScrollPos(wxVERTICAL), scrollAutomanaged);
+}
+
+void wxCanvas::SetScrollPos(int dir, int val)
+{
+  wxCanvas::SetScrollbars(horiz_units, vert_units, 
+					units_x, units_y,
+					units_per_page_x, units_per_page_y,
+					(dir == wxHORIZONTAL) ? val : GetScrollPos(wxHORIZONTAL),
+					(dir == wxVERTICAL) ? val : GetScrollPos(wxVERTICAL),
+					scrollAutomanaged);
+}
+
+int wxCanvas::GetScrollPos(int dir)
+{
+  return cScroll->GetScrollData()->GetValue((dir == wxHORIZONTAL) ? wxWhatScrollData::wxPositionH
+												   : wxWhatScrollData::wxPositionV);
+}
+
+int wxCanvas::GetScrollPage(int dir)
+{
+  return cScroll->GetScrollData()->GetValue((dir == wxHORIZONTAL) ? wxWhatScrollData::wxPageW
+												   : wxWhatScrollData::wxPageH);
+}
+int wxCanvas::GetScrollRange(int dir)
+{
+  return cScroll->GetScrollData()->GetValue((dir == wxHORIZONTAL) ? wxWhatScrollData::wxSizeW
+												   : wxWhatScrollData::wxSizeH);
+}
+
+
+
+void wxCanvas::Paint(void)	// called from wxWindow::Paint
+{
+	/* if (cActive || (wxSubType(__type, wxTYPE_PANEL))) */
+	  wxWindow::Paint();	// does the scrolls 
+	OnPaint();
+}
+
+void wxCanvas::OnPaint(void)
+{
+	/* Do nothing */
+}
+
+void wxCanvas::ChangeToGray(Bool gray)
+{
+}
diff --git a/src/wxmac/src/mac/wx_check.cc b/src/wxmac/src/mac/wx_check.cc
new file mode 100644
index 0000000..cd0bd04
--- /dev/null
+++ b/src/wxmac/src/mac/wx_check.cc
@@ -0,0 +1,410 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_check.cc
+// Purpose:	Panel item checkbox implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_check.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_area.h"
+#include "wx_panel.h"
+#include <QuickDraw.h>
+
+#define IC_BOX_SIZE 12
+#define IC_X_SPACE 3
+#define IC_Y_SPACE 2
+#define IC_MIN_HEIGHT (IC_BOX_SIZE + 2 * IC_Y_SPACE)
+	
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxCheckBox::wxCheckBox // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbCheckBox (parentPanel, x, y, width, height, style, windowName)
+{
+  Create(parentPanel, function, label, x, y, width, height, style, windowName, objectType);
+}
+
+void wxCheckBox::Create // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) 
+{
+	buttonBitmap = NULL;
+	
+	Callback(function);
+
+	font = buttonFont; // WCH: mac platform only
+	
+    label = wxItemStripLabel(label);
+
+	if (width <= 0 || height <= 0)
+	{
+		float fLabelWidth = 20.0;
+		float fLabelHeight = 12;
+		if (label)
+		{
+			GetTextExtent(label, &fLabelWidth, &fLabelHeight, NULL, NULL, buttonFont);
+			fLabelWidth += 20; // add 20 for width of checkbox icon
+			if (fLabelHeight < 12) fLabelHeight = 12; // height of checkbox icon is 12
+		}
+		if (width <= 0) cWindowWidth = fLabelWidth;
+		if (height <= 0) cWindowHeight = fLabelHeight;
+	}
+
+#if 0
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	Rect boundsRect = {0, 0, cWindowHeight, cWindowWidth};
+	wxMacString theMacLabel = label;
+	const Bool drawNow = TRUE; // WCH: use FALSE, then show after ChangeColour??
+	const short offValue = 0;
+	const short minValue = 0;
+	const short maxValue = 1;
+	short refCon = 0;
+	cMacControl = ::NewControl((WindowPtr)theMacGrafPort, &boundsRect, theMacLabel(),
+			drawNow, offValue, minValue, maxValue, checkBoxProc + useWFont, refCon);
+	CheckMemOK(cMacControl);
+#else
+	labelString = label;
+	cMacControl = NULL;
+#endif
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+wxCheckBox::wxCheckBox // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbCheckBox (parentPanel, x, y, width, height, style, windowName)
+{
+	if (bitmap->Ok() && (bitmap->selectedIntoDC >= 0)) {
+		buttonBitmap = bitmap;
+		buttonBitmap->selectedIntoDC++;
+	} else {
+		Create(parentPanel, function, "<bad-bitmap>", x, y, width, height, style, windowName, objectType);
+		return;
+	}
+	
+	Callback(function);
+	
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	Rect bounds = {0, 0, buttonBitmap->GetHeight(), buttonBitmap->GetWidth()};
+	cWindowHeight = bounds.bottom;
+	cWindowWidth = bounds.right + IC_BOX_SIZE + IC_X_SPACE;
+	if (cWindowHeight < IC_MIN_HEIGHT)
+	  cWindowHeight = IC_MIN_HEIGHT;
+	
+	::InvalRect(&bounds);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxCheckBox::~wxCheckBox(void)
+{
+	if (cMacControl) ::DisposeControl(cMacControl);
+	if (buttonBitmap) --buttonBitmap->selectedIntoDC;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Item methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+char* wxCheckBox::GetLabel(void)
+{
+	Str255	pLabel;
+
+	if (cMacControl) {
+	  ::GetCTitle(cMacControl, pLabel);
+	  wxMacPtoCString(pLabel, wxBuffer);
+      return wxBuffer;
+    } else
+    	return "";
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::SetLabel(char* label)
+{
+  if (buttonBitmap)
+    return;
+
+  if (label && cMacControl)
+  {
+	SetCurrentDC();
+  	wxMacString1 theMacString1 = label;
+  	::SetCTitle(cMacControl, theMacString1());
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::SetLabel(wxBitmap* bitmap)
+{
+  if (!buttonBitmap || !bitmap->Ok() || (bitmap->selectedIntoDC < 0))
+    return;
+  --buttonBitmap->selectedIntoDC;
+  buttonBitmap = bitmap;
+  buttonBitmap->selectedIntoDC++;
+  Refresh();
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::SetValue(Bool value)
+{
+	SetCurrentDC();
+	if (cMacControl) 
+	  ::SetCtlValue(cMacControl, value ? 1 : 0);
+	else {
+	  bitmapState = !!value;
+	  if (!cHidden)
+	    Paint();
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxCheckBox::GetValue(void)
+{
+    if (cMacControl) {
+	  short value = ::GetCtlValue(cMacControl);
+	  return (value != 0) ? TRUE : FALSE;
+	} else
+		return bitmapState;
+}
+
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::OnClientAreaDSize(int dW, int dH, int dX, int dY) // mac platform only
+{
+	if (!cMacControl)
+	  return;
+	  
+	SetCurrentDC();
+
+	Bool isVisible = (**cMacControl).contrlVis == 255;
+	Bool hideToPreventFlicker = (isVisible && (dX || dY) && (dW || dH));
+	if (hideToPreventFlicker) ::HideControl(cMacControl);
+
+	if (dW || dH)
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		::SizeControl(cMacControl, clientWidth, clientHeight);
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put new origin at (0, 0)
+		::MoveControl(cMacControl, 0, 0);
+	}
+
+	if (hideToPreventFlicker) ::ShowControl(cMacControl);
+
+	if (!cHidden && (dW || dH || dX || dY))
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::ChangeToGray(Bool gray)
+{
+	SetCurrentDC();
+	if (cMacControl)
+	  ::HiliteControl(cMacControl, gray ? kInactiveControl : kActiveControl);
+
+    wxWindow::ChangeToGray(gray);
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::Paint(void)
+{
+	if (cHidden) return;
+	SetCurrentDC();
+	Rect r = { 0, 0, cWindowHeight, cWindowWidth};
+	::EraseRect(&r);
+	if (cMacControl)
+	  ::Draw1Control(cMacControl);
+	else {
+	  if (buttonBitmap) {
+		int btop = (cWindowHeight - buttonBitmap->GetHeight()) / 2;
+		buttonBitmap->DrawMac(IC_BOX_SIZE + IC_X_SPACE, btop);
+	  } else if (labelString) {
+	    float fWidth = 50.0;
+		float fHeight = 12.0;
+		float fDescent = 0.0;
+		float fLeading = 0.0;
+		GetTextExtent(labelString, &fWidth, &fHeight, &fDescent, &fLeading, labelFont);
+		int stop = (cWindowHeight + fHeight) / 2;
+		::MoveTo(IC_BOX_SIZE + IC_X_SPACE, stop - fDescent - fLeading);
+	  	::DrawText(labelString, 0, strlen(labelString));
+	  }
+	  int top = (cWindowHeight - IC_BOX_SIZE) / 2;
+	  Rect r = { top, 0, top + IC_BOX_SIZE, IC_BOX_SIZE };
+      ForeColor(blackColor);
+	  PenSize(1, 1);
+	  FrameRect(&r);
+	  ForeColor(whiteColor);
+  	  InsetRect(&r, 1, 1);
+  	  PaintRect(&r);
+      ForeColor(blackColor);
+	  if (bitmapState) {
+	    MoveTo(0, top);
+	    Line(IC_BOX_SIZE - 1, IC_BOX_SIZE - 1);
+	    MoveTo(0, top + IC_BOX_SIZE - 1);
+	    Line(IC_BOX_SIZE - 1, -(IC_BOX_SIZE - 1));
+	  } else {
+	  }
+	  cMacDC->setCurrentUser(NULL);
+	}
+}
+
+void wxCheckBox::Highlight(Bool on)
+{
+	int top = (cWindowHeight - IC_BOX_SIZE) / 2;
+	Rect r = { top + 1, 1, top + IC_BOX_SIZE - 1, IC_BOX_SIZE - 1};
+	PenSize(1, 1);
+	if (on)
+	  FrameRect(&r);
+	else {
+	  ForeColor(whiteColor);
+	  FrameRect(&r);
+	  ForeColor(blackColor);
+	  if (bitmapState) {
+	    MoveTo(0, top);
+	    Line(IC_BOX_SIZE - 1, IC_BOX_SIZE - 1);
+	    MoveTo(0, top + IC_BOX_SIZE - 1);
+	    Line(IC_BOX_SIZE - 1, -(IC_BOX_SIZE - 1));
+	  }
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	SetCurrentDC();
+	if (cMacControl) {
+	  if (show)
+		::ShowControl(cMacControl);
+	  else
+		::HideControl(cMacControl);
+	}
+		
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::ShowAsActive(Bool flag) // mac platform only
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::OnEvent(wxMouseEvent& event) // mac platform only
+{
+	if (event.LeftDown())
+	{
+		SetCurrentDC();
+	
+		float fStartH, fStartV;
+		event.Position(&fStartH, &fStartV); // client c.s.
+		int startH = fStartH;
+		int startV = fStartV;
+	
+		Point startPt = {startH, startV}; // client c.s.
+		int trackResult;
+		if (::StillDown()) {
+			if (cMacControl)
+		      trackResult = ::TrackControl(cMacControl, startPt, NULL);
+		    else
+		      trackResult = Track(startPt);
+		} else
+			trackResult = 1;
+		if (trackResult)
+		{
+			wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_CHECKBOX_COMMAND);
+			commandEvent->commandInt = !GetValue();
+			commandEvent->eventObject = this;
+			SetValue(commandEvent->Checked()); // toggle checkbox
+	  		ProcessCommand(*commandEvent);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCheckBox::Command(wxCommandEvent& event) // mac platform only (also xview platform)
+{
+	if (cEnable)
+	{
+		Highlight(TRUE); // highlight button
+		long delayTicks = 10; // one tick is 1/60th of a second
+		long finalTicks;
+		Delay(delayTicks, &finalTicks);
+		Highlight(FALSE); // unhighlight button
+		SetValue(event.Checked()); // set checkbox
+	  	ProcessCommand(event);
+  	}
+}
diff --git a/src/wxmac/src/mac/wx_choic.cc b/src/wxmac/src/mac/wx_choic.cc
new file mode 100644
index 0000000..5aa2524
--- /dev/null
+++ b/src/wxmac/src/mac/wx_choic.cc
@@ -0,0 +1,582 @@
+/*
+ * File:        wx_choic.cc
+ * Purpose:     Choice item implementation (Mac version)
+ * Author:      Julian Smart/Cecil Coupe
+ * Created:     1993
+ * Updated:	April 1995
+ *   July 22, 1995 - First Mac version - Cecil Coupe
+ *
+ * Copyright:   (c) 1995, AIAI, University of Edinburgh
+ */
+
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma implementation "wx_choic.h"
+#endif
+
+#include <stdlib.h>
+#include "common.h"
+#include "wx_utils.h"
+#include "wx_privt.h"
+#include "wx_choic.h"
+#include "wx_menu.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include <Controls.h>
+
+/* 
+   The Mac ctl manager routine for popup menus has a problem or two
+   1. It appears that you can only popup menus that are resource based.
+   This makes it hard for the running program to append items.
+   
+   2. Titles (Labels in wx) are only horizontal.
+   
+   Based on IM-V, there are many things to do if we don't have the
+   control mgrs help.
+   1. We have to draw the shadowed box
+   2. Invert the Title (label) where the menu is showing
+   3. We have to draw the currently selected value in the shadowed box
+   Barrowed code from Apple DTS Snippets (PopMenus.p)
+
+   To manage all this, a Mac wxChoice has these components and processing:
+   1. The Title.
+   2. The value area gets the shadowed box and displays the current value
+   3. a Mac Menu handle
+   4. When we get a paint event,
+   		we draw the shadowed box and the value (will have to be cached?)
+   		constrained to the height and width of the box.
+   5. When we get a mousedown:
+   		Invert the Title,
+   		InsertMenu(ourmenuhandle, -1)
+   		call PopUpMenuSelect()
+   		DeleteMenu(ourmenuID)
+   		invert the Title
+   		draw the [newly] selected current value
+   	6. enable and disable - ?
+   	
+   	Todo
+   	1. Free the pieces/parts in the destructor
+   	2. Finish the event handling (wxEvents - CommandString needed?)
+   	3. Add enable and show
+   	4. Finish fixed sizing
+
+*/
+// Because I never get this right and t,l,b,r makes sense to me - CJC
+//
+#define SetBounds(rect, top, left, bottom, right) ::SetRect(rect, left, top, right, bottom)
+#define VSLOP 3
+#define HSLOP 4
+#define MSPACEX 4
+#define MSPACEY 1
+#define TRIANGLE_WIDTH 10
+#define TRIANGLE_HEIGHT 5
+#define TRANGLE_RIGHT_SPACE 5
+#define Checkem	TRUE;		// adds code to do checkmarks to selected item
+
+
+wxChoice::wxChoice (wxPanel * panel, wxFunction func, char *Title,
+	  int x, int y, int width, int height, int N, char **Choices,
+	  long style, char *name
+	):
+	wxbChoice (panel, func, Title, x, y, width, height, N, Choices, style, name)
+{
+  Create (panel, func, Title, x, y, width, height, N, Choices, style, name);
+}
+
+
+Bool wxChoice::
+Create (wxPanel * panel, wxFunction func, char *Title,
+	int x, int y, int width, int height, int N, char **Choices,
+	long style, char *name)
+{
+	buttonFont = panel->buttonFont;
+	labelFont = panel->labelFont;
+	backColour = panel->backColour;
+	labelColour = panel->labelColour;
+	buttonColour = panel->buttonColour;
+	window_parent = panel;
+	labelPosition = panel->label_position;
+	windowStyle = style;
+	valueFont = wxNORMAL_FONT;
+	Callback (func);
+	
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+/*	if (!buttonFont)
+		buttonFont = wxNORMAL_FONT;
+*/
+	if (!labelFont)
+		labelFont = wxNORMAL_FONT;
+
+	if (Title)
+      Title = wxItemStripLabel(Title);
+
+	float fWidth = 50.0;
+	float fHeight = 12.0;
+	float fDescent = 0.0;
+	float fLeading = 0.0;
+	labelbase = 9;
+	if (Title)
+	{
+		GetTextExtent(Title, &fWidth, &fHeight, &fDescent, &fLeading, labelFont);
+		if (fHeight < 12) fHeight = 12; 
+		int n = strlen(Title);
+		sTitle = (StringPtr)new char[n+1];
+		sTitle[0] = n;
+		memcpy(&sTitle[1], Title, n);
+		labelbase = fDescent + fLeading;
+	}
+	else  {
+		sTitle = NULL;
+		fWidth = fHeight = 0;
+	}
+	int lblw = fWidth + (Title ? HSLOP : 0);
+	int lblh = fHeight+2;
+	
+	int maxdfltw;
+	int maxdflth;
+	if (N) {
+		maxdfltw = 30;
+	} else {
+		// No strings - pick something reasonable - say 60 pixels
+		maxdfltw = 60;
+	}
+
+	GetTextExtent("Test", &fWidth, &fHeight, &fDescent, &fLeading, valueFont);
+	maxdflth = fHeight;
+	valuebase = fDescent + fLeading;
+
+	// Build the menu and find the width of the longest string
+	PopUpID = wxMenu::gMenuIdCounter++;
+#ifdef PPCC
+	Str255 ns = "\p";
+	hDynMenu = NewMenu(PopUpID, ns);
+#else
+	hDynMenu = NewMenu(PopUpID, "\p");
+#endif
+	CheckMemOK(hDynMenu);
+	int n,w,h;
+	char temp[255];
+	for (n = 0; n < N; n++) {
+		// attempt to size control by width of largest string
+		GetTextExtent(Choices[n], &fWidth, &fHeight, &fDescent, &fLeading, valueFont);
+		w = fWidth;
+		h = fHeight;
+		maxdfltw = max(w, maxdfltw);
+		maxdflth = max(h, maxdflth);
+		strcpy(temp, Choices[n]);
+		C2PStr(temp);
+		::AppendMenu(hDynMenu, "\ptemp");
+		::SetMenuItemText(hDynMenu, n + 1, (ConstStr255Param)temp);
+	}
+	no_strings = N;
+	maxdflth += MSPACEY*2;			// extra pixels on top & bottom
+	char checkm[] = {18, 0};
+	GetTextExtent(checkm, &fWidth, &fHeight, &fDescent, &fLeading, valueFont);
+	maxdfltw += fWidth + TRIANGLE_WIDTH + TRANGLE_RIGHT_SPACE + MSPACEX;
+	// compute the Rects that contain everything.
+	// note valuebase and labelbase are changed from font descents
+	// to number of pixels to substract from the rect bottom.
+	if (labelPosition == wxVERTICAL) {
+		w = max(lblw, maxdfltw);
+		if (Title)
+			SetBounds(&TitleRect,1, 1, lblh+1, w);
+		else
+			SetBounds(&TitleRect,1, 1, 1, 1);
+		SetBounds(&ValueRect, TitleRect.bottom + VSLOP, 1,
+				  TitleRect.bottom + maxdflth + 1, maxdfltw);
+		valuebase += MSPACEY;
+		SetBounds(&CtlRect, 0, 0, ValueRect.bottom + 2, w+1);
+	} else {
+		h = max(lblh, maxdflth);
+		SetBounds(&ValueRect, 1, lblw+1, h-1, maxdfltw + lblw);
+		valuebase += MSPACEY;
+		SetBounds(&CtlRect, 0, 0, h+1, lblw+maxdfltw+2);
+		int bot = (h - valuebase) + labelbase;
+		SetBounds(&TitleRect, bot-lblh, 1, bot, lblw);
+	}
+	if (width < 0 && height < 0) {
+		// use the sizes we just calced
+		cWindowWidth = CtlRect.right;
+		cWindowHeight = CtlRect.bottom;
+	} else {
+		OnClientAreaDSize((width == -1 ? 0 : width),
+			 (height == -1 ? 0 : height), (x == -1 ? 0 : x), (y == -1 ? 0 : y));
+	}
+	SetSelection(0);
+	//DrawChoice(TRUE);
+
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+
+  	return TRUE;
+}
+
+int wxChoice::Number(void)
+{
+	return no_strings;
+}
+
+wxChoice::~wxChoice (void)
+{
+	::DeleteMenu(PopUpID);		// Make Menu Mgr forget
+	::DisposeMenu(hDynMenu);
+	delete[] sTitle;
+}
+// --------- Calculate the ValueRect based on the menu's strings ----
+void wxChoice::ReCalcRect(void) {
+	int maxdfltw = 30;
+	int maxdflth = 12;
+	float	fWidth, fHeight, fDescent, fLeading;
+	int n,w,h;
+	unsigned char temp[256];
+	for (n = 0; n < no_strings; n++) {
+		// attempt to size control by width of largest string
+		::GetItem(hDynMenu, n+1, temp);
+		temp[temp[0]+1] = '\0';
+		GetTextExtent((char *)&temp[1], &fWidth, &fHeight, &fDescent, &fLeading, valueFont);
+		w = fWidth;
+		h = fHeight;
+		maxdfltw = max(w, maxdfltw);
+		maxdflth = max(h, maxdflth);
+	}
+	maxdflth += VSLOP*2;			// extra pixels top and bottom
+	maxdfltw += HSLOP*2;			// extra pixels on each side
+	// compute the Rects that contain everything.
+	// note valuebase and labelbase are changed from font descents
+	// to number of pixels to substract from the rect bottom.
+	int lblw = TitleRect.right - TitleRect.left;
+	int lblh = TitleRect.bottom - TitleRect.top;
+	if (labelPosition == wxVERTICAL) {
+		w = max(lblw, maxdfltw);
+		SetBounds(&TitleRect,1, 1, lblh+1, w);
+		SetBounds(&ValueRect,TitleRect.bottom+VSLOP, 1,
+			TitleRect.bottom+VSLOP+maxdflth, maxdfltw);
+		SetBounds(&CtlRect, 0, 0, ValueRect.bottom+VSLOP, w+1);
+	} else {
+		h = max(lblh, maxdflth);
+		SetBounds(&ValueRect, 1, lblw+1, h-1, maxdfltw + lblw);
+		SetBounds(&CtlRect, 0, 0, h+1, lblw+maxdfltw+2);
+		int bot = (h - valuebase) + labelbase;
+		SetBounds(&TitleRect, bot-lblh, 1, bot, lblw);
+	}
+}
+
+// ---------Draw the Choice Control -----------
+void wxChoice::DrawChoice(Bool active)
+{
+	SetCurrentDC();
+	Rect t = TitleRect;
+	::MoveTo(t.left, t.bottom - labelbase);
+	SetFont(labelFont);
+	SetTextInfo();
+	int w = 0;
+	int i;
+	
+	if (sTitle) {
+		for (i = 1; i <= sTitle[0] && w < TitleRect.right; i++)
+			w += ::CharWidth(sTitle[i]);
+		for (; w >= TitleRect.right; i--)	// backup
+			w -= ::CharWidth(sTitle[i]);
+		
+		::DrawText(sTitle, 1, i-1);
+		//::DrawString(sTitle);
+	}
+	
+	Rect r = ValueRect;
+	::InsetRect(&r, -1, -1);
+	::FrameRect(&r);
+	::MoveTo(r.right, r.top+2);
+	::LineTo(r.right, r.bottom);
+	::LineTo(r.left+2, r.bottom);
+
+	// mflatt:
+	RGBColor save;
+	GetForeColor(&save);
+	ForeColor(whiteColor);
+	::InsetRect(&r, 1, 1);
+	::PaintRect(&r);
+	::InsetRect(&r, -1, -1);
+	::RGBForeColor(&save);
+	
+	PolyHandle poly;
+	poly = OpenPoly();
+	if (poly) {
+		MoveTo(r.right - TRIANGLE_WIDTH - TRANGLE_RIGHT_SPACE, 
+			   r.top + (r.bottom - r.top - TRIANGLE_HEIGHT) / 2);
+	    Line(TRIANGLE_WIDTH, 0);
+	    Line(-(TRIANGLE_WIDTH / 2), TRIANGLE_HEIGHT);
+	    Line(-(TRIANGLE_WIDTH / 2), -TRIANGLE_HEIGHT);
+		ClosePoly();
+		PaintPoly(poly);
+	}
+	
+	if (!no_strings)
+		return;
+		
+	r.left += ::CharWidth('¥') + ::CharWidth(' ') + MSPACEX;
+	r.right -= TRIANGLE_WIDTH - TRANGLE_RIGHT_SPACE;
+	
+	Str255	s;
+	if (selection < 0)
+		selection = 0;
+	::GetItem(hDynMenu, selection+1, s);
+	SetFont(valueFont);
+	SetTextInfo();
+	::MoveTo(r.left, r.bottom - valuebase);
+	w = 0;
+	int elw = ::CharWidth('É');
+	int tgtw = r.right - r.left - elw;
+	for (i = 1; i < s[0] && w < tgtw; i++)
+		w+= ::CharWidth(s[i]);
+	for (; w >= tgtw; i--)
+		w -= ::CharWidth(s[i]);
+	if (i != s[0])
+		s[i] = 'É';
+	::DrawText(s, 1, i);
+	//DrawString(s);
+}
+
+
+// --------- Event Handling -------------------
+void wxChoice::Paint(void)
+{
+	if (cHidden) return;
+	DrawChoice(TRUE);
+	wxWindow::Paint();
+}
+
+// Resize and/or Move the Control
+void wxChoice::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+	SetCurrentDC();
+	int clientWidth, clientHeight;
+
+	if (dW || dH)
+	{
+		GetClientSize(&clientWidth, &clientHeight);
+		if (clientWidth != CtlRect.right) {
+			int needw = CtlRect.right - clientWidth;
+			if (labelPosition == wxVERTICAL) {
+				// Shrink width of both Title and Value
+				if (sTitle)
+					TitleRect.right -= needw;
+				ValueRect.right -= needw;
+			} else {
+				// Shrink width of Value, Title strings if we have to
+#if 0
+				if (sTitle) {
+					TitleRect.right -= needw/2;
+					ValueRect.left -= needw/2;
+				}
+#endif
+				ValueRect.right -= needw;
+			}
+			CtlRect.right = clientWidth;
+		} 
+		if (clientHeight != CtlRect.bottom) {
+			int needh = CtlRect.bottom - clientHeight;
+			if (labelPosition == wxVERTICAL) {
+				// Shrink heights equally
+				if (sTitle)
+					TitleRect.bottom -= needh/2;
+				ValueRect.top -= needh/2;
+				ValueRect.bottom -= needh;
+				
+			} else {
+				// Shrink heights eqally
+				if (sTitle)
+					TitleRect.bottom -= needh;
+				ValueRect.bottom -= needh;
+			}
+			CtlRect.bottom = clientHeight;
+		}
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put new origin at (0, 0)
+	}
+
+#if 0
+	if (dW || dH || dX || dY)
+	{
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalidRect(&clientRect);
+	}
+#endif
+}
+
+void wxChoice::ChangeToGray(Bool gray)
+{
+  wxWindow::ChangeToGray(gray);
+}
+
+//-----------------------------------------------------------------------------
+void wxChoice::DoShow(Bool show)
+{
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxChoice::ShowAsActive(Bool flag) // mac platform only
+{
+}
+
+
+void wxChoice::OnEvent(wxMouseEvent& event) // mac platform only
+{
+	if (event.LeftDown() && (no_strings > 0))
+	{
+		SetCurrentDC();
+	
+		int	newsel;
+		Point pos = {ValueRect.top, ValueRect.left};
+		LocalToGlobal(&pos);
+		// if (sTitle) ::InvertRect(&TitleRect);
+		::InsertMenu(hDynMenu, -1);
+		::CalcMenuSize(hDynMenu);
+		newsel = ::PopUpMenuSelect(hDynMenu, pos.v, pos.h, selection+1);
+		// if (sTitle) ::InvertRect(&TitleRect);
+		::DeleteMenu(PopUpID);
+		RGBColor save;
+		::GetForeColor(&save);
+		::ForeColor(whiteColor);
+		::PaintRect(&ValueRect);
+		::RGBForeColor(&save);
+		if (newsel) {
+			newsel = LoWord(newsel) -1;
+			if (newsel != selection) {
+#ifdef Checkem
+				// selected a different item
+				::CheckItem(hDynMenu, selection+1, FALSE);
+				::CheckItem(hDynMenu, newsel+1, TRUE);
+#endif
+				selection = newsel;
+				wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_CHOICE_COMMAND);
+				commandEvent->eventObject = this;
+				commandEvent->commandInt = selection;
+				commandEvent->commandString = GetString(selection);
+		  		ProcessCommand(*commandEvent);
+			}
+		}
+		DrawChoice(TRUE);
+	}
+}
+
+
+void wxChoice::Command(wxCommandEvent& event) // mac platform only (also xview platform)
+{
+	ProcessCommand(event);
+}
+
+// ------------ Methods available to user ------------
+
+void wxChoice::Append (char *Item)
+{
+  Str255 s;
+  int n = strlen(Item);
+  memcpy(&s[1], Item, n);
+  s[0] = n;
+  ::InsertMenuItem(hDynMenu, "\ptemp", no_strings);
+  ::SetMenuItemText(hDynMenu, no_strings + 1, s);
+  no_strings++;
+  //ReCalcRect();
+  Paint();
+}
+
+void wxChoice::Clear (void)
+{
+	int n;
+	for (n = 0; n < no_strings; n++)
+		::DelMenuItem(hDynMenu, 1);
+	no_strings = 0;
+	selection = 0;
+  Paint();
+}
+
+
+int wxChoice::GetSelection (void)
+{
+  return selection;
+}
+
+void wxChoice::SetSelection (int n)
+{
+	if ((n < 0) || (n >= no_strings))
+	  return;
+	
+#ifdef Checkem
+	::CheckItem(hDynMenu, selection+1, FALSE);
+	::CheckItem(hDynMenu, n+1, TRUE);
+#endif
+	selection = n;
+	DrawChoice(TRUE);
+}
+
+int wxChoice::FindString (char *s)
+{
+	int n = strlen(s);
+	int i;
+	Str255	ps;
+	for (i = 0; i < no_strings; i++) {
+		::GetItem(hDynMenu, i+1, ps);
+		if (!strcmp(PtoCstr(ps), s))
+			return i;
+	}
+	return -1;
+}
+
+char *wxChoice::GetString (int n)
+{
+	Str255	s;
+	if (n < 0 || n >= no_strings)
+		return NULL; // dummy
+	::GetItem(hDynMenu, n+1, s);
+	memcpy(wxBuffer, &s[1], s[0]);
+	wxBuffer[s[0]] = '\0';
+	return copystring(wxBuffer);
+}
+
+
+void wxChoice::SetBackgroundColour(wxColour*col)
+{
+} 
+
+void wxChoice::SetLabelColour(wxColour*col)
+{
+}
+
+void wxChoice::SetButtonColour(wxColour*col) 
+{
+}
+
+char* wxChoice::GetLabel(void)
+{
+	int n;
+	if (sTitle && (n = sTitle[0])) {
+		memcpy(wxBuffer, &sTitle[1], n);
+		wxBuffer[n] = '\0';
+		return wxBuffer;
+	}
+	else
+		return NULL;
+}
+
+void wxChoice::SetLabel(char *label)
+{
+	if (sTitle) {
+		delete[] (char *)sTitle;
+	}
+	int n = strlen(label);
+	sTitle = (StringPtr)new char[n+1];
+	sTitle[0] = n;
+	memcpy(&sTitle[1], label, n);
+	Paint();
+}
+
diff --git a/src/wxmac/src/mac/wx_clipb.cc b/src/wxmac/src/mac/wx_clipb.cc
new file mode 100644
index 0000000..34abb39
--- /dev/null
+++ b/src/wxmac/src/mac/wx_clipb.cc
@@ -0,0 +1,361 @@
+/*
+ * File:	wx_clipb.cc
+ * Purpose:	Clipboard implementation
+ * Author:	Julian Smart
+ * Created:	1993
+ * Updated:	
+ * Copyright:	(c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+ */
+
+static const char sccsid[] = "%W% %G%";
+
+#include "common.h"
+#include "wx_setup.h"
+
+#if USE_CLIPBOARD
+#include "wx_clipb.h"
+#include "wx_list.h"
+#include "wx_main.h"
+#include "wx_utils.h"
+#include <Scrap.h>
+#include <TextEdit.h>
+
+static wxList *ClipboardFormats = NULL;
+
+#define CUSTOM_ID_START 100
+
+class ClipboardFormat : public wxObject
+{
+  public:
+   int format;
+   char *name;
+};
+
+static void InitFormats()
+{
+	ClipboardFormat *cf;
+
+    ClipboardFormats = new wxList;
+
+ 	cf = new ClipboardFormat;
+ 	cf->name = "TEXT";
+  	cf->format = wxCF_TEXT;
+
+    ClipboardFormats->Append(cf);
+}
+
+Bool wxOpenClipboard(void)
+{
+  TEToScrap();
+  return TRUE;
+}
+
+Bool wxCloseClipboard(void)
+{
+  TEFromScrap();
+  return TRUE;
+}
+
+Bool wxEmptyClipboard(void)
+{
+  return ZeroScrap();
+}
+
+Bool wxIsClipboardFormatAvailable(int dataFormat)
+{
+  long offset;
+  long format;
+
+  if (dataFormat == wxCF_OEMTEXT)
+    dataFormat = wxCF_TEXT;
+
+  if (!wxGetClipboardFormatName(dataFormat, (char *)&format, 4))
+     return FALSE;
+
+  return (GetScrap(NULL, format, &offset) > 0);
+}
+
+Bool wxSetClipboardData(int dataFormat, wxObject *obj, int width, int height)
+{
+  long format, length;
+
+  if (dataFormat == wxCF_OEMTEXT)
+    dataFormat = wxCF_TEXT;
+
+  if (!wxGetClipboardFormatName(dataFormat, (char *)&format, 4))
+     return FALSE;
+
+  if (format == 'TEXT')
+    length = strlen((char *)obj);
+  else
+    length = (long)width * height;
+
+  return !PutScrap(length, format, (Ptr)obj);
+}
+
+wxObject *wxGetClipboardData(int dataFormat, long *size)
+{
+  Handle h;
+  char *result;
+  long format, length, offset;
+
+  if (dataFormat == wxCF_OEMTEXT)
+    dataFormat = wxCF_TEXT;
+
+  if (!wxGetClipboardFormatName(dataFormat, (char *)&format, 4))
+     return NULL;
+
+  h = NewHandle(10);
+  CheckMemOK(h);
+  length = GetScrap(h, format, &offset);
+
+  if (length < 0)
+	return NULL;
+
+  result = new char[length + ((format == 'TEXT') ? 1 : 0)];
+  HLock(h);
+  memcpy(result, *h, length);
+  HUnlock(h);
+  DisposeHandle(h);
+
+  if (format == 'TEXT')
+    result[length++] = 0;
+
+  if (size)
+	*size = length;
+
+  return (wxObject *)result;
+}
+
+int  wxEnumClipboardFormats(int dataFormat)
+{
+  long offset, format;
+  wxNode *node;
+  ClipboardFormat *cf;
+
+  if (!ClipboardFormats)
+    InitFormats();   
+
+  if (!dataFormat)
+   node = ClipboardFormats->First();
+  else {
+	for (node = ClipboardFormats->First(); node; node = node->Next()) {
+		cf = (ClipboardFormat *)node->Data();
+    	if (cf->format == dataFormat) {
+			node = node->Next();
+			break;
+		}
+	}
+  }
+
+  for (; node; node = node->Next()) {
+	cf = (ClipboardFormat *)node->Data();
+    memcpy(&format, cf->name, 4);
+    if (GetScrap(NULL, format, &offset) > 0)
+       return cf->format;
+  }
+
+  return 0;
+}
+
+int  wxRegisterClipboardFormat(char *formatName)
+{
+  wxNode *node;
+  ClipboardFormat *cf;
+
+  if (!ClipboardFormats)
+	InitFormats();
+  
+  for (node = ClipboardFormats->First(); node; node = node->Next()) {
+	cf = (ClipboardFormat *)node->Data();
+    if (!strcmp(cf->name, formatName))
+      return cf->format;
+  }
+
+  cf = new ClipboardFormat;
+
+  cf->format = ClipboardFormats->Number() + CUSTOM_ID_START;
+  cf->name = new char[strlen(formatName)];
+  strcpy(cf->name, formatName);
+
+  ClipboardFormats->Append(cf);
+ 
+  return cf->format;
+}
+
+Bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount)
+{
+  wxNode *node;
+  ClipboardFormat *cf;
+
+  if (dataFormat == wxCF_OEMTEXT)
+    dataFormat = wxCF_TEXT;
+
+  if (!ClipboardFormats)
+	InitFormats();
+  
+  for (node = ClipboardFormats->First(); node; node = node->Next()) {
+	cf = (ClipboardFormat *)node->Data();
+    if (cf->format == dataFormat) {
+      strncpy(formatName, cf->name, maxCount);
+	  return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+/********************************************************************************/
+/*                             Clipboard Classes                                */
+/********************************************************************************/
+
+wxClipboard *wxTheClipboard;
+
+void wxInitClipboard(void)
+{
+  if (!wxTheClipboard)
+    wxTheClipboard = new wxClipboard;
+}
+
+wxClipboard::wxClipboard()
+{
+  clipOwner = NULL;
+  cbString = NULL;
+}
+
+wxClipboard::~wxClipboard()
+{
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  if (cbString)
+    delete[] cbString;
+}
+
+static int FormatStringToID(char *str)
+{
+  if (!strcmp(str, "TEXT"))
+    return wxCF_TEXT;
+  
+  return wxRegisterClipboardFormat(str);
+}
+
+
+void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
+{
+  Bool got_selection;
+
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  clipOwner = client;
+  if (cbString) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+
+  if (wxOpenClipboard()) {
+    char **formats, *data;
+    int i;
+    int ftype;
+    long size;
+
+    wxEmptyClipboard();
+
+    formats = clipOwner->formats.ListToArray(FALSE);
+    for (i = clipOwner->formats.Number(); i--; ) {
+      ftype = FormatStringToID(formats[i]);
+      data = clipOwner->GetData(formats[i], &size);
+      if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
+	got_selection = FALSE;
+	break;
+      }
+    }
+
+    if (i < 0)
+      got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+  
+  got_selection = FALSE; // Assume another process takes over
+
+  if (!got_selection) {
+    clipOwner->BeingReplaced();
+    clipOwner = NULL;
+  }
+}
+
+wxClipboardClient *wxClipboard::GetClipboardClient()
+{
+  return clipOwner;
+}
+
+void wxClipboard::SetClipboardString(char *str, long time)
+{
+  Bool got_selection;
+
+  if (clipOwner) {
+    clipOwner->BeingReplaced();
+    clipOwner = NULL;
+  }
+  if (cbString)
+    delete[] cbString;
+
+  cbString = str;
+
+  if (wxOpenClipboard()) {    
+    wxEmptyClipboard();
+    if (!wxSetClipboardData(wxCF_TEXT, (wxObject *)str))
+      got_selection = FALSE;
+    else
+      got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+
+  got_selection = FALSE; // Assume another process takes over
+
+  if (!got_selection) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+}
+
+char *wxClipboard::GetClipboardString(long time)
+{
+  char *str;
+  long length;
+
+  str = GetClipboardData("TEXT", &length, time);
+  if (!str) {
+    str = new char[1];
+    *str = 0;
+  }
+
+  return str;
+}
+
+char *wxClipboard::GetClipboardData(char *format, long *length, long time)
+{
+  if (clipOwner)  {
+    if (clipOwner->formats.Member(format))
+      return clipOwner->GetData(format, length);
+    else
+      return NULL;
+  } else if (cbString) {
+    if (!strcmp(format, "TEXT"))
+      return copystring(cbString);
+    else
+      return NULL;
+  } else {
+
+    if (wxOpenClipboard()) {
+      receivedString = (char *)wxGetClipboardData(FormatStringToID(format), 
+						  length);
+      wxCloseClipboard();
+    } else
+      receivedString = NULL;
+
+    return receivedString;
+  }
+}
+
+
+#endif
diff --git a/src/wxmac/src/mac/wx_comparestrings.c b/src/wxmac/src/mac/wx_comparestrings.c
new file mode 100644
index 0000000..1881795
--- /dev/null
+++ b/src/wxmac/src/mac/wx_comparestrings.c
@@ -0,0 +1,38 @@
+// Needed for the mac since ANSI stdlib is C compiled
+#include <string.h>
+#include <ctype.h>
+#ifdef CJC
+int wx_comparestrings(const void *arg1, const void *arg2);
+extern "C" int strcmp(char* s1, char* s2);
+
+int wx_comparestrings(const void *arg1, const void *arg2)
+{
+  char **s1 = (char **)arg1;
+  char **s2 = (char **)arg2;
+
+  return strcmp(*s1, *s2);
+}
+#endif
+
+int strcasecmp(char *s, char *t);
+int strcasecmp(char *s, char *t)
+{
+	int r;
+	while (*s && *t) {
+		r = tolower(*s++) - tolower(*t++);
+		if (r != 0) return r;
+	}
+	return (tolower(*s) - tolower(*t));		// CJC is this correct
+}
+
+int strncasecmp(char *s, char *t, int w);
+int strncasecmp(char *s, char *t, int w)
+{
+	int r,i = 0;
+	while (i < w) {
+		r = tolower(s[i]) - tolower(t[i]);
+		if (r != 0) return r;
+		i += 1;	
+	}
+	return 0;
+}
diff --git a/src/wxmac/src/mac/wx_dc.cc b/src/wxmac/src/mac/wx_dc.cc
new file mode 100644
index 0000000..a290a41
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dc.cc
@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dc.cc
+// Purpose:	Device context implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+#include <QuickDraw.h>
+#include "wx_gdi.h"
+#include "wx_dc.h"
+
+//-----------------------------------------------------------------------------
+wxDC::wxDC(void)
+//-----------------------------------------------------------------------------
+{
+	cMacDC = NULL;
+	cMacCurrentTool = kNoTool;
+}
+
+//-----------------------------------------------------------------------------
+wxDC::~wxDC(void)
+//-----------------------------------------------------------------------------
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxDC::wxMacDrawPoint(int x1, int y1)
+//-----------------------------------------------------------------------------
+{
+	MoveTo(x1, y1);
+	Line(1, 1);
+}
+
+//-----------------------------------------------------------------------------
+void wxDC::wxMacDrawLine(int x1, int y1, int x2, int y2)
+//-----------------------------------------------------------------------------
+{
+	MoveTo(x1, y1);
+	LineTo(x2, y2);
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_dccan1.cc b/src/wxmac/src/mac/wx_dccan1.cc
new file mode 100644
index 0000000..8c6c4d6
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dccan1.cc
@@ -0,0 +1,908 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dccan1.cc
+// Purpose:	Canvas device context implementation (Macintosh version) (part 1)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QuickDraw.h>
+#include "wx_dccan.h"
+#include "wx_canvs.h"
+#include "wx_privt.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wx_area.h"
+
+//#include "bdiag.xbm"
+//#include "fdiag.xbm"
+//#include "cdiag.xbm"
+//#include "horiz.xbm"
+//#include "verti.xbm"
+//#include "cross.xbm"
+//#include "wx_area.h"
+
+static PixMapHandle	bdiag,
+		cdiag,
+		fdiag,
+		cross,
+		horiz,
+		verti;
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+// Default constructor
+//-----------------------------------------------------------------------------
+wxCanvasDC::wxCanvasDC(void)
+{
+  __type = wxTYPE_DC_CANVAS;
+
+	selected_pixmap = NULL;
+	canvas = NULL;
+	cMacDoingDrawing = FALSE;
+
+  pixmap = 0;
+  pixmapWidth = 0;
+  pixmapHeight = 0;
+  clipping = FALSE;
+
+  current_reg = NULL ;
+  user_reg = NULL ;
+  onpaint_reg = NULL ;
+
+  device = wxDEVICE_CANVAS;
+  font = wxNORMAL_FONT;
+
+  min_x = 0; min_y = 0; max_x = 0; max_y = 0;
+
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  mapping_mode = MM_TEXT;
+
+  title = NULL;
+
+#ifdef wx_motif
+  gc = NULL;
+  gcBacking = NULL;
+#endif
+
+  ok = TRUE;
+  current_pen_join = -1 ;
+  current_pen_cap = -1 ;
+  current_pen_nb_dash = -1 ;
+  current_pen_dash = NULL ;
+  current_stipple = NULL ;
+
+  current_logical_function = -1;
+
+  Colour = wxColourDisplay();
+
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = NULL;
+  current_text_foreground = *wxBLACK;
+//  current_text_background = NULL;
+  SetBackground(wxWHITE_BRUSH);
+}
+
+
+//-----------------------------------------------------------------------------
+wxCanvasDC::wxCanvasDC(wxCanvas* the_canvas): wxbCanvasDC(the_canvas)
+{
+__type = wxTYPE_DC_CANVAS;
+
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	canvas = the_canvas;
+	WXGC_IGNORE(canvas);
+	cMacDC = canvas->MacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	::SetPort((GrafPtr)theMacGrafPort);
+
+	cMacDoingDrawing = FALSE;
+	pixmap = theMacGrafPort->portPixMap;	//CJC 
+
+  clipping = FALSE;
+  selected_pixmap = NULL;
+
+  pixmapWidth = 0;
+  pixmapHeight = 0;
+
+  current_reg = NULL ;
+  user_reg = NULL ;
+  onpaint_reg = NULL ;
+
+  min_x = 0; min_y = 0; max_x = 0; max_y = 0;
+
+  device = wxDEVICE_CANVAS;
+  font = wxNORMAL_FONT;
+#ifndef LkB
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+#else
+  // TO DO: temp fix for logical positioning
+  int x,y;
+  canvas->GetPosition(&x, &y);
+  logical_origin_x = -x;
+  logical_origin_y = -y;
+#endif
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  mapping_mode = MM_TEXT;
+
+  title = NULL;
+
+  ok = TRUE;
+  current_pen_join = -1 ;
+  current_pen_cap = -1 ;
+  current_pen_nb_dash = -1 ;
+  current_pen_dash = NULL ;
+  current_logical_function = -1;
+  current_stipple = NULL ;
+
+  Colour = wxColourDisplay();
+
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = NULL;
+  current_text_foreground = *wxBLACK;
+//  current_text_background = NULL;
+  SetBackground(wxWHITE_BRUSH);
+  SetBrush(wxWHITE_BRUSH);
+  SetPen(wxBLACK_PEN);
+
+  ::SetPort(oldPort);
+
+// More initialization
+	if (the_canvas)
+	{
+		int clientWidth, clientHeight;
+		the_canvas->GetClientSize(&clientWidth, &clientHeight);
+		Rect paintRect = {0, 0, clientHeight, clientWidth};
+		SetPaintRegion(&paintRect);
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxCanvasDC::~wxCanvasDC(void)
+{
+  if (current_pen) current_pen->Lock(-1);
+  if (current_brush) current_brush->Lock(-1);
+  if (current_background_brush) current_background_brush->Lock(-1);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::BeginDrawing(void)
+//-----------------------------------------------------------------------------
+{
+	if (cMacDoingDrawing) {
+	 // wxFatalError("Tried BeginDrawing while already DoingDrawing.");
+	 return;
+	}
+	cMacDoingDrawing = TRUE;
+
+	SetCurrentDC();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::EndDrawing(void)
+//-----------------------------------------------------------------------------
+{
+	if (!cMacDoingDrawing) {
+	  // wxFatalError("Tried EndDrawing while not DoingDrawing.");
+	  return;
+	}
+	
+	cMacDoingDrawing = FALSE;
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetCurrentDC(void) // mac platform only
+//-----------------------------------------------------------------------------
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	if ((GrafPtr)theMacGrafPort != qd.thePort) 
+		::SetPort((GrafPtr)theMacGrafPort);
+
+	if (cMacDC->currentUser() != this)
+	{ // must setup platform
+		cMacDC->setCurrentUser(this);
+		int theRootX = 0, theRootY = 0;
+		if(canvas)
+		{
+#if 1
+			canvas->ClientArea()->FrameContentAreaOffset(&theRootX, &theRootY);
+#else
+			canvas->GetPosition(&theRootX, &theRootY);
+#endif
+		}
+		::SetOrigin(-theRootX, -theRootY);
+		wxMacSetClip();
+		cMacCurrentTool = kPenTool; /* to force setting bg, etc. */
+		wxMacSetCurrentTool(kNoTool);
+		SetLogicalFunction(current_logical_function);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetCanvasClipping(void)
+//-----------------------------------------------------------------------------
+{
+	if (current_reg) ::DisposeRgn(current_reg);
+	if (user_reg || onpaint_reg) {
+		current_reg = ::NewRgn();
+		CheckMemOK(current_reg);
+	} else
+		current_reg = NULL;
+
+	if (onpaint_reg && user_reg)
+		::SectRgn(onpaint_reg, user_reg, current_reg) ;
+	else if (user_reg)
+		::CopyRgn(user_reg, current_reg) ;
+	else if (onpaint_reg)
+		::CopyRgn(onpaint_reg, current_reg) ;
+
+	wxObject* theCurrentUser = cMacDC->currentUser();
+	if (theCurrentUser == this)
+	{ // must update platfrom
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		wxMacSetClip();
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::GetClippingBox(float *x,float *y,float *w,float *h)
+//-----------------------------------------------------------------------------
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+
+	if (current_reg)
+	{
+		Rect theClipRect = (**(theMacGrafPort->clipRgn)).rgnBBox;
+		int theX = theClipRect.left;
+		int theY = theClipRect.top;
+		int theWidth = theClipRect.right - theClipRect.left;
+		int theHeight = theClipRect.bottom - theClipRect.top;
+		*x = XDEV2LOG(theX) ;
+		*y = YDEV2LOG(theY) ;
+		*w = XDEV2LOGREL(theWidth) ;
+		*h = YDEV2LOGREL(theHeight) ;
+	}
+	else
+		*x = *y = *w = *h = 0; // WCH wx_win: this doesn't seem right
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetPaintRegion(Rect* paintRect)
+//-----------------------------------------------------------------------------
+{
+	if (onpaint_reg) ::DisposeRgn(onpaint_reg);
+	onpaint_reg = ::NewRgn();
+	CheckMemOK(onpaint_reg);
+	float cx, cy, cw, ch;
+	cx = paintRect->left;
+	cy = paintRect->top;
+	cw =  paintRect->right;
+	ch =  paintRect->bottom;
+	int left = XLOG2DEV(cx);
+	int top = YLOG2DEV(cy);
+	int right = XLOG2DEVREL(cx + cw);
+	int bottom = YLOG2DEVREL(cy + ch);
+	::SetRectRgn(onpaint_reg, left, top, right, bottom);
+	SetCanvasClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetClippingRegion(float cx, float cy, float cw, float ch)
+//-----------------------------------------------------------------------------
+{
+  if (user_reg) ::DisposeRgn(user_reg);
+  user_reg = ::NewRgn();
+  CheckMemOK(user_reg);
+  int left = XLOG2DEV(cx);
+  int top = YLOG2DEV(cy);
+  int right = XLOG2DEVREL(cx + cw);
+  int bottom = YLOG2DEVREL(cy + ch);
+  ::SetRectRgn(user_reg, left, top, right, bottom);
+  SetCanvasClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::GetClippingRegion(float *cx, float *cy, float *cw, float *ch)
+//-----------------------------------------------------------------------------
+{
+  if (!user_reg) {
+	*cx = *cy = 0;
+	*cw = *ch = -1;
+  } else {
+	*cx = (**user_reg).rgnBBox.left;
+	*cy = (**user_reg).rgnBBox.top;
+	*cw = (**user_reg).rgnBBox.right - *cx;
+	*ch = (**user_reg).rgnBBox.bottom - *cy;
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DestroyClippingRegion(void)
+//-----------------------------------------------------------------------------
+{
+  if (user_reg) ::DisposeRgn(user_reg);
+  user_reg = NULL;
+  SetCanvasClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetFont(wxFont *the_font)
+{
+	font = the_font;
+
+	wxObject* theCurrentUser = cMacDC->currentUser();
+	if (theCurrentUser == this)
+	{ // must update platfrom
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+
+#ifdef wx_xview
+  // Set the font according to the current scaling
+  int scaled_size = (int)(user_scale_y*font->GetPointSize() + 0.5);
+  Xv_Font xfont = wxFontPool->FindNearestFont(font->GetFamily(), font->GetStyle(),
+                       font->GetWeight(), scaled_size, font->GetUnderlined(), 0, 0);
+  font->x_font = xfont;
+  Font theFont = (Font)xv_get(xfont, XV_XID);
+#endif
+#ifdef wx_motif
+/*
+        int res_x = (int)(DisplayWidth(dpy, screen)/(DisplayWidthMM(dpy, screen)/25.4));
+        int res_y = (int)(DisplayHeight(dpy, screen)/(DisplayHeightMM(dpy, screen)/25.4));
+*/
+  int res_x = 100;
+  int res_y = 100;
+
+  int scaled_size = (int)(10 * ((int)(user_scale_y*font->GetPointSize() + 0.5)));
+
+  XFontStruct *fontStruct = wxFontPool->FindNearestFont(font->GetFamily(), font->GetStyle(),
+                                                   font->GetWeight(), scaled_size,
+                                                   font->GetUnderlined(), res_x, res_y);
+  font->xFont = fontStruct;
+  Font theFont = fontStruct->fid;
+#endif
+#ifdef wx_motif_wch
+  XSetFont(display, gc, theFont);
+#endif
+#ifdef wx_motif
+  if (canvas && canvas->is_retained)
+    XSetFont(display, gcBacking, theFont);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetPen(wxPen *pen)
+{
+	if (current_pen) current_pen->Lock(-1);
+	current_pen = pen;
+	if (current_pen) current_pen->Lock(1);
+
+	if (cMacDC->currentUser() == this && cMacCurrentTool == kPenTool)
+	{
+		wxMacSetCurrentTool(kNoTool); // platform pen no longer valid
+	}
+
+#ifdef wx_motif_wch
+  if (!same_style)
+  {
+    int scaled_width = (int)XLOG2DEVREL(pen->GetWidth());
+    if (scaled_width < 0)
+      scaled_width = 0;
+
+    int style;
+    int join ;
+    int cap ;
+    static char dotted[] = {2, 5};
+    static char short_dashed[] = {4, 4};
+    static char long_dashed[] = {4, 8};
+    static char dotted_dashed[] = {6, 6, 2, 6};
+
+    // We express dash pattern in pen width unit, so we are
+    // independent of zoom factor and so on...
+    int req_nb_dash ;
+    char *req_dash ;
+
+    switch (pen->GetStyle())
+    {
+      case wxUSER_DASH:
+        req_nb_dash = current_pen_nb_dash ;
+        req_dash = current_pen_dash ;
+        style = LineOnOffDash;
+        break;
+      case wxDOT:
+        req_nb_dash = 2 ;
+        req_dash = dotted ;
+        style = LineOnOffDash;
+        break;
+      case wxSHORT_DASH:
+        req_nb_dash = 2 ;
+        req_dash = short_dashed ;
+        style = LineOnOffDash;
+        break;
+      case wxLONG_DASH:
+        req_nb_dash = 2 ;
+        req_dash = long_dashed ;
+        style = LineOnOffDash;
+        break;
+      case wxDOT_DASH:
+        req_nb_dash = 4 ;
+        req_dash = dotted_dashed ;
+        style = LineOnOffDash;
+        break;
+      case wxSTIPPLE:
+      case wxSOLID:
+      case wxTRANSPARENT:
+      default:
+        style = LineSolid;
+        req_dash = NULL ;
+        req_nb_dash = 0 ;
+    }
+
+    if (req_dash&&req_nb_dash)
+    {
+      char *real_req_dash = new char[req_nb_dash] ;
+      if (real_req_dash)
+      {
+        int factor = scaled_width==0? 1:scaled_width ;
+        for (int i=0;i<req_nb_dash;i++)
+          real_req_dash[i] = req_dash[i]*factor ;
+#ifdef wx_motif_wch
+        XSetDashes(display, gc, 0, real_req_dash, req_nb_dash);
+#endif
+#ifdef wx_motif
+        if (canvas && canvas->is_retained)
+          XSetDashes(display,gcBacking,0,real_req_dash,req_nb_dash);
+#endif
+        delete [] real_req_dash ;
+      }
+      else
+      {
+        // No Memory. We use non-scaled dash pattern...
+#ifdef wx_motif_wch
+        XSetDashes(display, gc, 0, req_dash, req_nb_dash);
+#endif
+#ifdef wx_motif
+        if (canvas && canvas->is_retained)
+          XSetDashes(display,gcBacking,0,req_dash,req_nb_dash);
+#endif
+      }
+    }
+ 
+    switch(pen->GetCap())
+    {
+    case wxCAP_PROJECTING: cap = CapProjecting ; break ;
+    case wxCAP_BUTT:       cap = CapButt ;       break ;
+    case wxCAP_ROUND:
+    default:               cap = CapRound ;      break ;
+    }
+
+    switch(pen->GetJoin())
+    {
+    case wxJOIN_BEVEL: join = JoinBevel ; break ;
+    case wxJOIN_MITER: join = JoinMiter ; break ;
+    case wxJOIN_ROUND:
+    default:           join = JoinRound ; break ;
+    }
+
+#ifdef wx_motif
+    XSetLineAttributes(display, gc, scaled_width, style, cap, join);
+#endif
+#ifdef wx_motif
+    if (canvas && canvas->is_retained)
+      XSetLineAttributes(display, gcBacking, scaled_width, style, cap, join);
+#endif
+  }
+
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetBrush(wxBrush *brush)
+{
+	if (current_brush) current_brush->Lock(-1);
+	current_brush = brush;
+	if (current_brush) current_brush->Lock(1);
+
+	if (cMacDC->currentUser() == this && cMacCurrentTool == kBrushTool)
+	{
+		wxMacSetCurrentTool(kNoTool); // platform brush no longer valid
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetBackground(wxBrush* brush)
+{
+	if (current_background_brush) current_background_brush->Lock(-1);
+	current_background_brush = brush;
+	if (current_background_brush) current_background_brush->Lock(1);
+
+	if (cMacDC->currentUser() == this
+		&& (cMacCurrentTool != kBlitTool)
+		&& (cMacCurrentTool != kColorBlitTool))
+	{ // must update platform
+		if (!current_background_brush) {
+			BackColor(whiteColor);
+			return;
+		}
+	
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		RGBColor pixel = current_background_brush->GetColour().pixel;
+		if (Colour)
+			RGBBackColor(&pixel);
+		else
+		{
+			unsigned char red = current_background_brush->GetColour().Red();
+			unsigned char blue = current_background_brush->GetColour().Blue();
+			unsigned char green = current_background_brush->GetColour().Green();
+			Bool isBlackColour =
+				(red == (unsigned char )0 &&
+				 blue == (unsigned char)0 &&
+				 green == (unsigned char)0);
+			BackColor(isBlackColour ? blackColor : whiteColor);
+		}
+	
+		int theBrushStyle = current_background_brush->GetStyle();
+		if (theBrushStyle == wxSOLID)
+			BackPat(&qd.white);
+		else if (theBrushStyle == wxTRANSPARENT)
+			BackPat(&qd.white);
+		else if (IS_HATCH(theBrushStyle))
+		{
+			macGetHatchPattern(theBrushStyle, cMacPattern);
+			BackPat(&cMacPattern);
+		}
+		else
+		{
+			BackPat(&qd.white);
+		}
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetLogicalFunction(int function)
+{
+	current_logical_function = function;
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		int theMacPenMode;
+		switch (current_logical_function)
+		{
+			case wxCLEAR:  theMacPenMode = patBic; break;
+			case wxXOR:  theMacPenMode = patXor; break;
+			case wxINVERT: theMacPenMode = notPatCopy /* GXinvert */; break;
+			case wxOR_REVERSE: theMacPenMode = patXor /* GXorReverse */; break;
+			case wxAND_REVERSE: theMacPenMode = patCopy /* GXandReverse */; break;
+			case wxAND: theMacPenMode = adMin; break;
+			case wxOR: theMacPenMode = adMax; break;
+			case wxAND_INVERT: theMacPenMode = patBic; break;
+			case wxNO_OP: theMacPenMode = patCopy /* GXnoop */; break;
+			case wxNOR: theMacPenMode = notPatOr /* GXnor */; break;
+			case wxEQUIV: theMacPenMode = notPatXor; break;
+			case wxSRC_INVERT: theMacPenMode = notPatCopy; break;
+			case wxOR_INVERT: theMacPenMode = notPatOr; break;
+			case wxNAND: theMacPenMode = notPatCopy /* GXnand */; break;
+			case wxSET: theMacPenMode = patCopy /* GXset */; break;
+			case wxCOPY:
+			default:
+				theMacPenMode = patCopy; break;
+		}
+	
+		PenMode(theMacPenMode);
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxCanvasDC::StartDoc(char *message) { return TRUE; }
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::EndDoc(void) { }
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::StartPage(void) { }
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::EndPage(void){ }
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetMapMode(int mode)
+{
+  mapping_mode = mode;
+
+  int pixel_width = 0;
+  int pixel_height = 0;
+  int mm_width = 0;
+  int mm_height = 0;
+
+  // First, calculate how to scale from mm to pixels.
+  // Then we just need to find the scaling factor from ? to mm and multiply
+  // by the first scaling factor.
+
+  pixel_width = 640;
+  pixel_height = 480;
+  mm_width = 225;
+  mm_height = 169;
+
+  float mm2pixelsX = pixel_width/mm_width;
+  float mm2pixelsY = pixel_height/mm_height;
+
+  switch (mode)
+  {
+    case MM_TWIPS:
+    {
+      logical_scale_x = (float)(twips2mm * mm2pixelsX);
+      logical_scale_y = (float)(twips2mm * mm2pixelsY);
+      break;
+    }
+    case MM_POINTS:
+    {
+      logical_scale_x = (float)(pt2mm * mm2pixelsX);
+      logical_scale_y = (float)(pt2mm * mm2pixelsY);
+      break;
+    }
+    case MM_METRIC:
+    {
+      logical_scale_x = mm2pixelsX;
+      logical_scale_y = mm2pixelsY;
+      break;
+    }
+    case MM_LOMETRIC:
+    {
+      logical_scale_x = (float)(mm2pixelsX/10.0);
+      logical_scale_y = (float)(mm2pixelsY/10.0);
+      break;
+    }
+    default:
+    case MM_TEXT:
+    {
+      logical_scale_x = 1.0;
+      logical_scale_y = 1.0;
+      break;
+    }
+  }
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		if (cMacCurrentTool == kPenTool)
+			wxMacSetCurrentTool(kPenTool); // Force recalculation of line width
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetUserScale(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	user_scale_x = x;
+	user_scale_y = y;
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		if (cMacCurrentTool == kPenTool)
+			wxMacSetCurrentTool(kPenTool); // Force recalculation of line width
+
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::DeviceToLogicalX(int x) { return XDEV2LOG(x); }
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::DeviceToLogicalXRel(int x) { return XDEV2LOGREL(x); }
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::DeviceToLogicalY(int y) { return YDEV2LOG(y); }
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::DeviceToLogicalYRel(int y) { return YDEV2LOGREL(y); }
+
+//-----------------------------------------------------------------------------
+int wxCanvasDC::LogicalToDeviceX(float x) { return XLOG2DEV(x); }
+
+//-----------------------------------------------------------------------------
+int wxCanvasDC::LogicalToDeviceXRel(float x) { return XLOG2DEVREL(x); }
+
+//-----------------------------------------------------------------------------
+int wxCanvasDC::LogicalToDeviceY(float y) { return YLOG2DEV(y); }
+
+//-----------------------------------------------------------------------------
+int wxCanvasDC::LogicalToDeviceYRel(float y) { return YLOG2DEVREL(y); }
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::wxMacSetClip(void)
+{
+	SetCurrentDC();
+	if (canvas && !canvas->WantsFocus()) { // => canvas is hidden (HACK!)
+		Rect zeroClipRect = {0, 0, 0, 0};
+		::ClipRect(&zeroClipRect);
+	} else {
+		if (current_reg)
+		{
+			::SetClip(current_reg);
+		}
+		else
+		{
+			Rect largestClipRect = {-32767, -32767, 32767, 32767};
+			::ClipRect(&largestClipRect);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::wxMacSetCurrentTool(wxMacToolType whichTool)
+{
+	SetCurrentDC();
+
+	// mflatt: shortcut
+	if (whichTool == cMacCurrentTool)
+		return;
+
+	RGBColor pixel;
+
+	if ((whichTool != kBlitTool)
+		&& (whichTool != kColorBlitTool)) {
+	  cMacCurrentTool = kNoTool;
+	  SetBackground(current_background_brush);
+	}
+
+	switch (whichTool)
+	{
+		case kNoTool:
+			break;
+		case kBrushTool:
+			int theBrushStyle = current_brush->GetStyle();
+			if (theBrushStyle == wxSOLID)
+				PenPat(&qd.black);
+			else if (theBrushStyle == wxTRANSPARENT)
+				PenPat(&qd.white); // WCH : does this work??
+			else if (IS_HATCH(theBrushStyle))
+			{
+				macGetHatchPattern(theBrushStyle, cMacPattern);
+				PenPat(&cMacPattern);
+			}
+			else
+			{
+				PenPat(&qd.black);
+			}
+	
+			pixel = current_brush->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else
+			{
+				unsigned char red = current_brush->GetColour().Red();
+				unsigned char blue = current_brush->GetColour().Blue();
+				unsigned char green = current_brush->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kPenTool:
+			int thePenWidth = current_pen->GetWidth();
+			int thePenHeight = current_pen->GetWidth();
+			PenSize(thePenWidth, thePenHeight);
+
+			int thePenStyle = current_pen->GetStyle();
+			if (thePenStyle == wxSOLID)
+				PenPat(&qd.black);
+			else if (thePenStyle == wxTRANSPARENT)
+				PenPat(&qd.white);
+			else if (IS_HATCH(thePenStyle))
+			{
+				macGetHatchPattern(thePenStyle, cMacPattern);
+				PenPat(&cMacPattern);
+			}
+			else
+			{
+				PenPat(&qd.black);
+			}
+
+			pixel = current_pen->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else
+			{
+				unsigned char red = current_pen->GetColour().Red();
+				unsigned char blue = current_pen->GetColour().Blue();
+				unsigned char green = current_pen->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kBlitTool:
+			ForeColor(blackColor);
+			BackColor(whiteColor);
+			break;
+		case kColorBlitTool:
+			BackColor(whiteColor);
+			pixel = current_pen->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else {
+				unsigned char red = current_pen->GetColour().Red();
+				unsigned char blue = current_pen->GetColour().Blue();
+				unsigned char green = current_pen->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kQuillTool:
+			break;
+	}
+
+	cMacCurrentTool = whichTool;
+}
diff --git a/src/wxmac/src/mac/wx_dccan2.cc b/src/wxmac/src/mac/wx_dccan2.cc
new file mode 100644
index 0000000..8e894a5
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dccan2.cc
@@ -0,0 +1,557 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dccan2.cc
+// Purpose:	Canvas device context implementation (Macintosh version) (part 2)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QDOffscreen.h>
+#include "wx_dccan.h"
+#include "wx_utils.h"
+#include "wx_canvs.h"
+#include "wx_privt.h"
+
+//#include "bdiag.xbm"
+//#include "fdiag.xbm"
+//#include "cdiag.xbm"
+//#include "horiz.xbm"
+//#include "verti.xbm"
+//#include "cross.xbm"
+
+static PixMapHandle	bdiag,
+		cdiag,
+		fdiag,
+		cross,
+		horiz,
+		verti;
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::Clear(void)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+
+	int w, h;
+	if (canvas)
+	{
+		canvas->GetVirtualSize(&w, &h);
+	}
+	else
+	{
+		w = pixmapWidth;
+		h = pixmapHeight;
+	}
+
+	Rect theClearRect = {0, 0, h, w};
+	::EraseRect(&theClearRect);
+}
+
+void wxCanvasDC::GetSize(float *width, float *height)
+{
+	if (canvas) {
+		int w, h;
+		canvas->GetVirtualSize(&w, &h);
+		*width = w;
+		*height = h;
+	} else {
+		*width = pixmapWidth;
+		*height = pixmapHeight;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::CrossHair(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	int xx = XLOG2DEV(x);
+	int yy = YLOG2DEV(y);
+	float ww, hh;
+	GetSize(&ww, &hh) ;
+	wxMacDrawLine(0, yy, ww, yy);
+	wxMacDrawLine(xx, 0, xx, hh);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::FloodFill(float x, float y, wxColour *col, int style)
+//=============================================================================
+{
+	SetCurrentDC();
+}
+
+//-----------------------------------------------------------------------------
+Bool wxCanvasDC::GetPixel(float x, float y, wxColour *col)
+//=============================================================================
+{
+	RGBColor rgb;
+
+	SetCurrentDC();
+
+	GetCPixel(XLOG2DEV(x), YLOG2DEV(y), &rgb);
+	col->Set(rgb.red >> 8, rgb.green >> 8, rgb.blue >> 8);
+
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::SetPixel(float x, float y, wxColour *col)
+//=============================================================================
+{
+	RGBColor rgb;
+
+	SetCurrentDC();
+
+	rgb.red = col->Red() << 8;
+	rgb.green = col->Green() << 8;
+	rgb.blue = col->Blue() << 8;
+	SetCPixel(XLOG2DEV(x), YLOG2DEV(y), &rgb);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::IntDrawLine(int x1, int y1, int x2, int y2)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawLine(XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
+	CalcBoundingBox(x1, y1); // WCH: not in original. Why not?
+	CalcBoundingBox(x2, y2); // WCH: not in original. Why not?
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawLine(float x1, float y1, float x2, float y2)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawLine(XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
+	CalcBoundingBox(x1, y1);
+	CalcBoundingBox(x2, y2);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawArc(float x1,float y1,float x2,float y2,float xc,float yc)
+{
+	SetCurrentDC();
+
+#ifdef wx_motif_wch
+  int xx1 = XLOG2DEV(x1) ;
+  int yy1 = YLOG2DEV(y1) ;
+  int xx2 = XLOG2DEV(x2) ;
+  int yy2 = YLOG2DEV(y2) ;
+  int xxc = XLOG2DEV(xc) ;
+  int yyc = YLOG2DEV(yc) ;
+ 
+  double dx = xx1 - xxc ;
+  double dy = yy1 - yyc ;
+  double radius = sqrt(dx*dx+dy*dy) ;
+  int r = (int)radius ;
+ 
+  double radius1,radius2 ;
+ 
+  if (xx1==xx2 && yy1==yy2)
+  {
+    radius1 = 0.0 ;
+    radius2 = 360.0 ;
+  }
+  else if (radius==0.0)
+    radius1 = radius2 = 0.0 ;
+  else
+  {
+    if (xx1-xxc == 0)
+      if (yy1-yyc<0)
+        radius1 = 90.0 ;
+      else
+        radius1 = -90.0 ;
+    else
+        radius1 = -atan2((double)(yy1-yyc),(double)(xx1-xxc))*360.0 / (2*M_PI) ;
+
+    if (xx2-xxc==0)
+      if (yy2-yyc<0)
+        radius2 = 90.0 ;
+      else
+        radius2 = -90.0 ;
+    else
+        radius2 = -atan2((double)(yy2-yyc),(double)(xx2-xxc))*360.0 / (2*M_PI) ;
+  }
+  radius1 *= 64.0 ;
+  radius2 *= 64.0 ;
+  int alpha1 = (int)radius1 ;
+  int alpha2 = (int)(radius2-radius1) ;
+  while (alpha2<=0)
+    alpha2 += 360*64 ;
+  while (alpha2>360*64)
+    alpha2 -= 360*64 ;
+
+  if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+  {
+    if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+#ifdef wx_motif_wch
+    XFillArc(display, pixmap, gc,
+             xxc-r,yyc-r,2*r,2*r,alpha1,alpha2) ; 
+#endif
+  }
+
+  if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+  {
+    if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+#ifdef wx_motif_wch
+    XDrawArc(display, pixmap, gc,
+             xxc-r,yyc-r,2*r,2*r,alpha1,alpha2) ; 
+#endif
+  }
+  CalcBoundingBox(x1, y1);
+  CalcBoundingBox(x2, y2);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawPoint(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawPoint(XLOG2DEV(x), YLOG2DEV(y));
+	CalcBoundingBox(x, y);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawPolygon(int n, wxPoint points[],
+								float xoffset, float yoffset, int fillStyle)
+{
+	SetCurrentDC();
+	if (n <= 0) return;
+	Point *xpoints1 = new Point[n+1];
+	for (int i = 0; i < n; i++)
+	{
+		xpoints1[i].h = XLOG2DEV(points[i].x + xoffset);
+		xpoints1[i].v = YLOG2DEV(points[i].y + yoffset);
+		CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
+	}
+
+	// Close figure
+	xpoints1[n].h = xpoints1[0].h;
+	xpoints1[n].v = xpoints1[0].v;
+
+	PolyHandle thePolygon = OpenPoly();
+	MoveTo(xpoints1[0].h, xpoints1[0].v);
+	for (int j = 1; j <= n; j++)
+	{
+		LineTo(xpoints1[j].h, xpoints1[j].v);
+	}
+	ClosePoly();
+
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintPoly(thePolygon);
+#ifdef wx_motif_wch
+		XSetFillRule(display,gc,fillStyle==wxODDEVEN_RULE?EvenOddRule:WindingRule);
+		XFillPolygon(display, pixmap, gc, xpoints1, n, Convex, 0);
+		XSetFillRule(display,gc,EvenOddRule); // default mode
+#endif
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FramePoly(thePolygon);
+	}
+
+	delete[] xpoints1;
+	KillPoly(thePolygon);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawLines(int n, wxIntPoint points[], int xoffset, int yoffset)
+{
+	if (n <= 0) return;
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		SetCurrentDC();
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	
+		Point *xpoints = new Point[n];
+	
+		for (int i = 0; i < n; i++)
+		{
+			xpoints[i].h = XLOG2DEV(points[i].x + xoffset);
+			xpoints[i].v = YLOG2DEV(points[i].y + yoffset);
+			CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset); // WCH: not in original??
+		}
+	
+		PolyHandle thePolygon = OpenPoly();
+		MoveTo(xpoints[0].h, xpoints[0].v);
+		for (int j = 1; j < n; j++)
+		{
+			LineTo(xpoints[j].h, xpoints[j].v);
+		}
+		ClosePoly();
+	
+		FramePoly(thePolygon);
+	
+		delete[] xpoints;
+		KillPoly(thePolygon);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawLines(int n, wxPoint points[], float xoffset, float yoffset)
+{
+	if (n <= 0) return;
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		SetCurrentDC();
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	
+		Point *xpoints = new Point[n];
+	
+		for (int i = 0; i < n; i++)
+		{
+			xpoints[i].h = XLOG2DEV(points[i].x + xoffset);
+			xpoints[i].v = YLOG2DEV(points[i].y + yoffset); // WCH: original mistype "h" for "v"
+			CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset); // WCH: not in original??
+		}
+	
+		PolyHandle thePolygon = OpenPoly();
+		MoveTo(xpoints[0].h, xpoints[0].v);
+		for (int j = 1; j < n; j++)
+		{
+			LineTo(xpoints[j].h, xpoints[j].v);
+		}
+		ClosePoly();
+	
+		FramePoly(thePolygon);
+	
+		delete[] xpoints;
+		KillPoly(thePolygon);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawRectangle(float x, float y, float width, float height)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintRect(&theRect);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameRect(&theRect);
+	}
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawRoundedRectangle
+					(float x, float y, float width, float height, float radius)
+{
+	SetCurrentDC();
+	if (radius < 0.0) radius = 0.0; // Negative radius can crash your ENTIRE X server. Wow!
+    
+	int phys_radius = XLOG2DEVREL(radius);
+
+	int phys_rwidth = phys_radius * 2;
+	int phys_rheight = phys_rwidth;
+
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintRoundRect(&theRect, phys_rwidth, phys_rheight);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameRoundRect(&theRect, phys_rwidth, phys_rheight);
+	}
+
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawEllipse(float x, float y, float width, float height)
+{
+	SetCurrentDC();
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintOval(&theRect);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameOval(&theRect);
+	}
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawIcon(wxIcon *icon, float x, float y)
+{
+	int h, w;
+	w = icon->GetWidth();
+	h = icon->GetHeight();
+	if (!icon->selectedIntoDC && icon->Ok()) {
+		wxMemoryDC *mdc;
+		mdc = new wxMemoryDC();
+		mdc->SelectObject(icon);
+		if (mdc->Ok())
+			Blit(x, y, w, h, mdc, 0, 0);
+		mdc->SelectObject(NULL);
+		delete mdc;
+	}
+}
+
+/*-----------------------------------
+	Ideally, Blit() should munged its args and call the Mac ToolBox 
+	CopyBits() function. 
+    We also have to be aware that the 'source' arg could actually be a
+	wxMemoryDC and we may have to switch GWorlds. 
+		I.e if (this->device != source->device)
+*/
+Bool wxCanvasDC::Blit(float xdest, float ydest, float width, float height,
+                wxCanvasDC *source, float xsrc, float ysrc, int rop)
+{
+	if (device != source->device) {
+		// Switch Gworld to this
+		SetGWorld(cMacDC->macGrafPort(), 0);
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC();
+	}
+	else {
+		SetCurrentDC();
+	}
+	if (rop == wxCOLOR) {
+	  wxMacSetCurrentTool(kColorBlitTool);
+	  rop = wxCOPY;
+	} else
+	  wxMacSetCurrentTool(kBlitTool);
+	Bool theResult = FALSE;
+
+	if (pixmap && source->pixmap)
+	{
+		int mode;
+		switch (rop)
+		{ // FIXME -  these modes have not be tested
+		//	case wxCLEAR:  theMacPenMode = GXclear; break;
+			case wxXOR:  
+				mode = srcXor; 
+				break;
+		//	case wxINVERT: theMacPenMode = GXinvert; break;
+		//	case wxOR_REVERSE: theMacPenMode = GXorReverse; break;
+		//	case wxAND_REVERSE: theMacPenMode = GXandReverse; break;
+			case wxAND:
+				mode = srcBic;
+				break;
+			case wxOR: 
+				mode = srcOr; 
+				break;
+			case wxAND_INVERT: 
+				mode = notSrcBic; break;
+		//	case wxNO_OP: theMacPenMode = GXnoop; break;
+		//	case wxNOR: theMacPenMode = GXnor; break;
+			case wxEQUIV: 
+				mode = notSrcXor; break;
+			case wxSRC_INVERT: 
+				mode = notSrcCopy; break;
+			case wxOR_INVERT: 
+				mode = notSrcOr; break;
+		//	case wxNAND: theMacPenMode = GXnand; break;
+		//	case wxSET: theMacPenMode = GXset; break;
+			case wxCOPY:
+			default:
+				mode = srcCopy;
+				break;
+		}
+		int h = height;
+		int w = width;
+		int x = XLOG2DEV(xdest);
+		int y = YLOG2DEV(ydest);
+		int ixsrc = source->LogicalToDeviceX(xsrc);
+		int iysrc = source->LogicalToDeviceY(ysrc);
+		Rect srcr = {iysrc, ixsrc, iysrc + h, ixsrc + w};
+		Rect destr = {y, x, y+h, x+w };
+		// Lock PixMaps
+		int rs;
+		rs = ::LockPixels(pixmap);
+		PixMapHandle srpixh = source->pixmap;
+		rs = ::LockPixels(srpixh);
+		CopyBits((BitMap *) (* srpixh),   (BitMap *)(* pixmap),
+			&srcr, &destr, mode, NULL);
+		::UnlockPixels(pixmap);
+		::UnlockPixels(srpixh);
+		CalcBoundingBox(xdest, ydest);
+		CalcBoundingBox(xdest + width, ydest + height);
+		theResult = TRUE;
+	}
+
+  	return theResult;
+}
+
+void wxCanvasDC::TryColour(wxColour *src, wxColour *dest)
+{
+  SetCurrentDC();
+
+  if (Colour) {
+	RGBColor pixel = src->pixel;
+	
+	Index2Color(Color2Index(&pixel), &pixel);
+	
+	dest->Set(pixel.red >> 8, pixel.green >> 8, pixel.blue >> 8); 
+  } else {
+	unsigned char red = src->Red();
+	unsigned char blue = src->Blue();
+	unsigned char green = src->Green();
+	Bool isWhiteColour =
+		(red == (unsigned char )255 &&
+		 blue == (unsigned char)255 &&
+		 green == (unsigned char)255);
+	if (isWhiteColour)
+		dest->Set(255, 255, 255);
+	else
+		dest->Set(0, 0, 0);
+  }
+}
diff --git a/src/wxmac/src/mac/wx_dccan3.cc b/src/wxmac/src/mac/wx_dccan3.cc
new file mode 100644
index 0000000..63b0427
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dccan3.cc
@@ -0,0 +1,125 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dccan3.cc
+// Purpose:	Canvas device context implementation (Macintosh version) (part 3)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QuickDraw.h>
+#include "wx_dccan.h"
+#include "wx_utils.h"
+
+//#include "bdiag.xbm"
+//#include "fdiag.xbm"
+//#include "cdiag.xbm"
+//#include "horiz.xbm"
+//#include "verti.xbm"
+//#include "cross.xbm"
+
+static PixMapHandle	bdiag,
+		cdiag,
+		fdiag,
+		cross,
+		horiz,
+		verti;
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::DrawText(const char* text, float x, float y, Bool use16)
+{
+	SetCurrentDC();
+	wxColour current_colour;
+
+	// CHANGES FOR MAJESTIC VIEWER LjB Moonface, Inc.
+	::TextFont(font->GetMacFontNum());
+	::TextSize(font->GetPointSize());
+	::TextFace(font->GetMacFontStyle());
+    wxMacSetCurrentTool(kPenTool); // end LjB
+
+	FontInfo fontInfo;
+	Point start, end;
+	::GetFontInfo(&fontInfo);
+	start.h = XLOG2DEV(x);
+	start.v = YLOG2DEV(y + fontInfo.ascent);
+	MoveTo(start.h, start.v); // move pen to start drawing text
+	int theStrlen = strlen(text);
+	::DrawText(text, 0, theStrlen); // WCH: kludge, mac procedure same name as wxWindows method
+
+	// mflatt: look at pen, use distance travelled instead of calculating 
+    // the length of the string (again)
+	float w, h;
+	::GetPen(&end);
+	w = (end.h - start.h) / (logical_scale_x * user_scale_x);
+	h = (end.v - start.v) / (logical_scale_y * user_scale_y);
+
+	CalcBoundingBox(x + w, y + h);
+	CalcBoundingBox(x, y);
+}
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::GetCharHeight(void)
+//-----------------------------------------------------------------------------
+{
+	int theCharHeight;
+	if (!font)
+  		theCharHeight = font->GetCharHeight();
+  	else
+  		theCharHeight = 12;
+
+  	return XDEV2LOGREL(theCharHeight);
+}
+
+//-----------------------------------------------------------------------------
+float wxCanvasDC::GetCharWidth(void)
+//-----------------------------------------------------------------------------
+{
+	int theCharWidth;
+	if (!font)
+  		theCharWidth = font->GetCharWidth();
+  	else
+  		theCharWidth = 12;
+
+  	return XDEV2LOGREL(theCharWidth);
+}
+
+//-----------------------------------------------------------------------------
+void wxCanvasDC::GetTextExtent(const char* string, float* x, float* y, float* descent,
+  						float* externalLeading, wxFont* the_font, Bool use16)
+{
+	float x2, y2, descent2, externalLeading2;
+	if (the_font)
+	{
+		the_font->GetTextExtent((char *)string, &x2, &y2, &descent2, &externalLeading2, use16);
+	}
+	else if (font)
+	{
+		font->GetTextExtent((char *)string, &x2, &y2, &descent2, &externalLeading2, use16);
+	}
+	else
+	{
+        *x = -1;
+        *y = -1;
+		if (descent) *descent = 0.0;
+		if (externalLeading) *externalLeading = 0.0;
+		return;
+	}
+
+	*x = XDEV2LOGREL(x2);
+	*y = YDEV2LOGREL(y2);
+	if (descent) *descent = descent2;
+	if (externalLeading) *externalLeading = externalLeading2;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_dcmem.cc b/src/wxmac/src/mac/wx_dcmem.cc
new file mode 100644
index 0000000..394f9a8
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dcmem.cc
@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dcmem.cc
+// Purpose:	Memory device context implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Quickdraw.h>
+#include "wx_dcmem.h"
+#include "wx_utils.h"
+#include "wx_canvs.h"
+#include "wx_privt.h"
+
+/* 
+	A wxMemoryDC is a pointer to a bitmap, which is an offscreen GWorld. 
+
+	When the wxMemoryDC(void) constructor is used we don't know how large a pixmap
+	(boundsRect) to create so we wait until SelectObject() is called. 
+   mflatt:
+    This is unlike X-Windows and Windows! These platforms allocate a bitmap
+     anyway of some size. Since the manual says to select a bitmap first, I
+     see no problem with this Mac implementation.
+*/
+extern CGrafPtr wxMainColormap;
+
+wxMemoryDC::wxMemoryDC(void)
+{
+  __type = wxTYPE_DC_MEMORY;
+  device = wxDEVICE_PIXMAP;
+  current_pen_join = -1 ;
+  current_pen_cap = -1 ;
+  current_pen_nb_dash = -1 ;
+  current_pen_dash = NULL ;
+  current_stipple = NULL ;
+
+  pixmap = 0;
+  pixmapWidth = 0;
+  pixmapHeight = 0;
+  canvas = NULL;
+  clipping = FALSE;
+  
+  ok = FALSE;
+  title = NULL;
+
+  current_logical_function = -1;
+  font = wxNORMAL_FONT;
+  min_x = 0; min_y = 0; max_x = 0; max_y = 0;
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  mapping_mode = MM_TEXT;
+
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = wxWHITE_BRUSH;
+  current_text_foreground = *wxBLACK;
+//  current_text_background = NULL;
+
+  // mflatt: NOT ok
+  // ok = TRUE;
+  selected_pixmap = NULL;
+  gworldH = NULL;
+
+  Colour = wxColourDisplay();
+  SetBrush(wxWHITE_BRUSH);
+  SetPen(wxBLACK_PEN);
+}
+
+/*
+ * Create a new dc from an old dc
+ *
+ */
+
+wxMemoryDC::wxMemoryDC(wxCanvasDC *old_dc):wxbMemoryDC(old_dc)
+{
+  min_x = 0; min_y = 0; max_x = 0; max_y = 0;
+  __type = wxTYPE_DC_MEMORY;
+  device = wxDEVICE_PIXMAP;
+  current_pen_join = -1 ;
+  current_pen_cap = -1 ;
+  current_pen_nb_dash = -1 ;
+  current_pen_dash = NULL ;
+  current_stipple = NULL ;
+
+  pixmap = 0;
+  pixmapWidth = 0;
+  pixmapHeight = 0;
+  canvas = NULL;
+
+  ok = FALSE;
+  title = NULL;
+
+  current_logical_function = -1;
+  font = wxNORMAL_FONT;
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  mapping_mode = MM_TEXT;
+
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = wxWHITE_BRUSH;
+  current_text_foreground = *wxBLACK;
+//  current_text_background = NULL;
+
+  // mflatt: NOT ok
+  // ok = TRUE;
+  selected_pixmap = NULL;
+  gworldH = NULL;
+  Colour = wxColourDisplay();
+  SetBrush(wxWHITE_BRUSH);
+  SetPen(wxBLACK_PEN);
+}
+
+wxMemoryDC::~wxMemoryDC(void)
+{
+  if (selected_pixmap) {
+	selected_pixmap->selectedInto = NULL;
+	selected_pixmap->selectedIntoDC = 0;
+	gworldH = NULL;
+  } else {
+    if (gworldH) {
+	  ::DisposeGWorld(gworldH);
+	  gworldH = NULL;
+    }
+ }
+ 
+ if (cMacDC) {
+	delete cMacDC;
+	cMacDC = NULL;
+  }
+}
+
+void wxMemoryDC::SelectObject(wxBitmap *bitmap)
+{
+  if (selected_pixmap == bitmap) {
+		// set cMacDC ??
+		return;
+  }
+  if (bitmap && bitmap->selectedIntoDC)
+	// This bitmap is selected into a different memoryDC
+    return;
+
+  if (selected_pixmap) {
+	selected_pixmap->selectedInto = NULL;
+	selected_pixmap->selectedIntoDC = 0;
+	gworldH = NULL;
+  } else {
+    if (gworldH) {
+  	  ::DisposeGWorld(gworldH);
+      gworldH = NULL;
+    }
+  }
+
+  if (cMacDC) {
+	delete cMacDC;
+	cMacDC = NULL;
+  }
+  ok = FALSE;
+  selected_pixmap = bitmap;
+  if (bitmap == NULL) {	// deselect a bitmap
+    pixmapWidth = 0;
+    pixmapHeight = 0;
+	pixmap = NULL;
+	return;
+  }
+  bitmap->selectedInto = this;
+  bitmap->selectedIntoDC = -1;
+  pixmapWidth = bitmap->GetWidth();
+  pixmapHeight = bitmap->GetHeight();
+  if (bitmap->Ok()) {
+    gworldH = bitmap->x_pixmap;
+    // gworldH = MacCreateGWorld(pixmapWidth, pixmapHeight);
+    if (gworldH) {
+	  pixmap = ::GetGWorldPixMap(gworldH);
+	
+	  SetGWorld(gworldH, 0);
+	  cMacDC = new wxMacDC(gworldH);
+	  // bitmap->DrawMac(0, 0);
+	  ok = TRUE;
+    }
+  }
+}
+
+GWorldPtr wxMemoryDC::MacCreateGWorld(int width, int height)
+{
+	QDErr err;
+	GWorldPtr	newGWorld;
+	Rect	bounds = {0, 0, height, width};
+
+	err = NewGWorld(&newGWorld, 0, &bounds, NULL, NULL, noNewDevice);
+	if (err == noErr)
+		return newGWorld;
+	else
+		return NULL;
+}
+
diff --git a/src/wxmac/src/mac/wx_dcpr1.cc b/src/wxmac/src/mac/wx_dcpr1.cc
new file mode 100644
index 0000000..e2811ae
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dcpr1.cc
@@ -0,0 +1,723 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dcpr1.cc
+// Purpose:	Print Canvas device context implementation (Macintosh version) (part 1)
+// Author:	Lou Birk (copied from wx_dccan)
+// Created:	1995
+// Updated:	
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QuickDraw.h>
+#include <Printing.h>
+#include "wx_dcpr.h"
+//#include "wx_canvs.h"
+#include "wx_privt.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wx_area.h"
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+// Default constructor
+//-----------------------------------------------------------------------------
+wxPrinterDC::wxPrinterDC(void)
+{
+  // this should never happen since the cMacDC would not be set
+  // to a printer port like below
+}
+
+
+//-----------------------------------------------------------------------------
+wxPrinterDC::wxPrinterDC(THPrint pData)
+{
+	/* MATTHEW: [6] */
+	__type = wxTYPE_DC_PRINTER;
+
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+    prRecHandle = pData;
+    PrOpen();
+	if (PrError()) {
+      PrClose();
+      ok = FALSE;
+      return;
+    }
+
+	prPort = PrOpenDoc(prRecHandle, 0, 0);
+
+    if (PrError()) {
+      PrCloseDoc(prPort);
+      PrClose();
+      ok = FALSE;
+      return;
+    }
+
+    cMacDC = new wxMacDC((CGrafPtr)&(prPort->gPort));
+	GrafPtr theMacGrafPort = (GrafPtr)cMacDC->macGrafPort();
+	::SetPort((GrafPtr)theMacGrafPort);
+
+	cMacDoingDrawing = FALSE;
+
+  clipping = FALSE;
+  selected_pixmap = NULL;
+
+  current_reg = NULL ;
+  user_reg = NULL ;
+  onpaint_reg = NULL ;
+
+  min_x = 0; min_y = 0;
+  max_x = 0; max_y = 0;
+
+  pixmapWidth = (**prRecHandle).prInfo.rPage.right;
+  pixmapHeight = (**prRecHandle).prInfo.rPage.bottom;
+
+  device = wxDEVICE_CANVAS;
+  font = wxNORMAL_FONT;
+
+  logical_origin_x = 0;
+  logical_origin_y = 0;
+
+  device_origin_x = 0;
+  device_origin_y = 0;
+
+  logical_scale_x = 1.0;
+  logical_scale_y = 1.0;
+
+  user_scale_x = 1.0;
+  user_scale_y = 1.0;
+
+  mapping_mode = MM_TEXT;
+
+  title = NULL;
+
+
+  ok = TRUE;
+  current_pen_join = -1 ;
+  current_pen_cap = -1 ;
+  current_pen_nb_dash = -1 ;
+  current_pen_dash = NULL ;
+  current_logical_function = -1;
+  current_stipple = NULL ;
+
+  Colour = wxColourDisplay();
+
+  current_pen = NULL;
+  current_brush = NULL;
+  current_background_brush = NULL;
+  current_text_foreground = *wxBLACK;
+//  current_text_background = NULL;
+  SetBackground(wxWHITE_BRUSH);
+  SetBrush(wxWHITE_BRUSH);
+  SetPen(wxBLACK_PEN);
+
+  //::SetPort(oldPort);
+
+  int clientWidth, clientHeight;
+  //the_canvas->GetClientSize(&clientWidth, &clientHeight);
+  clientWidth = pixmapWidth;
+  clientHeight = pixmapHeight; // paper
+  Rect paintRect = {0, 0, clientHeight, clientWidth};
+  SetPaintRegion(&paintRect);
+
+}
+
+//-----------------------------------------------------------------------------
+wxPrinterDC::~wxPrinterDC(void)
+{
+  if (current_pen) current_pen->Lock(-1);
+  if (current_brush) current_brush->Lock(-1);
+  if (current_background_brush) current_background_brush->Lock(-1);
+  if (ok)
+    PrCloseDoc(prPort);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::BeginDrawing(void)
+//-----------------------------------------------------------------------------
+{
+	if (cMacDoingDrawing) wxFatalError("Tried BeginDrawing while already DoingDrawing.");
+	cMacDoingDrawing = TRUE;
+
+	SetCurrentDC();
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::EndDrawing(void)
+//-----------------------------------------------------------------------------
+{
+	if (!cMacDoingDrawing) wxFatalError("Tried EndDrawing while not DoingDrawing.");
+	cMacDoingDrawing = FALSE;
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetCurrentDC(void) // mac platform only
+//-----------------------------------------------------------------------------
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	if ((GrafPtr)theMacGrafPort != qd.thePort) ::SetPort((GrafPtr)theMacGrafPort);
+
+	if (cMacDC->currentUser() != this)
+	{ // must setup platform
+		cMacDC->setCurrentUser(this);
+		int theRootX = 0, theRootY = 0;
+		::SetOrigin(-theRootX, -theRootY);
+		wxMacSetClip();
+		SetBackground(current_background_brush);
+		wxMacSetCurrentTool(kNoTool);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetPrinterClipping(void)
+//-----------------------------------------------------------------------------
+{
+	if (current_reg) ::DisposeRgn(current_reg);
+	if (user_reg || onpaint_reg) {
+		current_reg = ::NewRgn();
+		CheckMemOK(current_reg);
+	} else
+		current_reg = NULL;
+
+	if (onpaint_reg && user_reg)
+		::SectRgn(onpaint_reg, user_reg, current_reg) ;
+	else if (user_reg)
+		::CopyRgn(user_reg, current_reg) ;
+	else if (onpaint_reg)
+		::CopyRgn(onpaint_reg, current_reg) ;
+
+	wxObject* theCurrentUser = cMacDC->currentUser();
+	//if (theCurrentUser == this)
+	//{ // must update platfrom
+//		GrafPtr theOldPort = qd.thePort;
+//		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+//		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+//		wxMacSetClip();
+
+//		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+//	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::GetClippingBox(float *x,float *y,float *w,float *h)
+//-----------------------------------------------------------------------------
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+
+	if (current_reg)
+	{
+		Rect theClipRect = (**(theMacGrafPort->clipRgn)).rgnBBox;
+		int theX = theClipRect.left;
+		int theY = theClipRect.top;
+		int theWidth = theClipRect.right - theClipRect.left;
+		int theHeight = theClipRect.bottom - theClipRect.top;
+		*x = XDEV2LOG(theX) ;
+		*y = YDEV2LOG(theY) ;
+		*w = XDEV2LOGREL(theWidth) ;
+		*h = YDEV2LOGREL(theHeight) ;
+	}
+	else
+		*x = *y = *w = *h = 0; // WCH wx_win: this doesn't seem right
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetPaintRegion(Rect* paintRect)
+//-----------------------------------------------------------------------------
+{
+	if (onpaint_reg) ::DisposeRgn(onpaint_reg);
+	onpaint_reg = ::NewRgn();
+	CheckMemOK(onpaint_reg);
+	float cx, cy, cw, ch;
+	cx = paintRect->left;
+	cy = paintRect->top;
+	cw =  paintRect->right;
+	ch =  paintRect->bottom;
+	int left = XLOG2DEV(cx);
+	int top = YLOG2DEV(cy);
+	int right = XLOG2DEVREL(cx + cw);
+	int bottom = YLOG2DEVREL(cy + ch);
+	::SetRectRgn(onpaint_reg, left, top, right, bottom);
+	SetPrinterClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetClippingRegion(float cx, float cy, float cw, float ch)
+//-----------------------------------------------------------------------------
+{
+  if (user_reg) ::DisposeRgn(user_reg);
+  user_reg = ::NewRgn();
+  CheckMemOK(user_reg);
+  int left = XLOG2DEV(cx);
+  int top = YLOG2DEV(cy);
+  int right = XLOG2DEVREL(cx + cw);
+  int bottom = YLOG2DEVREL(cy + ch);
+  ::SetRectRgn(user_reg, left, top, right, bottom);
+  SetPrinterClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::GetClippingRegion(float *cx, float *cy, float *cw, float *ch)
+//-----------------------------------------------------------------------------
+{
+  if (!user_reg) {
+	*cx = *cy = 0;
+	*cw = *ch = -1;
+  } else {
+	*cx = (**user_reg).rgnBBox.left;
+	*cy = (**user_reg).rgnBBox.top;
+	*cw = (**user_reg).rgnBBox.right - *cx;
+	*ch = (**user_reg).rgnBBox.bottom - *cy;
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DestroyClippingRegion(void)
+//-----------------------------------------------------------------------------
+{
+  if (user_reg) ::DisposeRgn(user_reg);
+  user_reg = NULL;
+  SetPrinterClipping();
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetFont(wxFont *the_font)
+{
+	font = the_font;
+
+	wxObject* theCurrentUser = cMacDC->currentUser();
+	if (theCurrentUser == this)
+	{ // must update platfrom
+		GrafPtr theOldPort = qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		//if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetPen(wxPen *pen)
+{
+	if (current_pen) current_pen->Lock(-1);
+	current_pen = pen;
+	if (current_pen) current_pen->Lock(1);
+
+	if (cMacDC->currentUser() == this && cMacCurrentTool == kPenTool)
+	{
+		wxMacSetCurrentTool(kNoTool); // platform pen no longer valid
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetBrush(wxBrush *brush)
+{
+	if (current_brush) current_brush->Lock(-1);
+	current_brush = brush;
+	if (current_brush) current_brush->Lock(1);
+
+	if (cMacDC->currentUser() == this && cMacCurrentTool == kBrushTool)
+	{
+		wxMacSetCurrentTool(kNoTool); // platform brush no longer valid
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetBackground(wxBrush* brush)
+{
+	if (current_background_brush) current_background_brush->Lock(-1);
+	current_background_brush = brush;
+	if (current_background_brush) current_background_brush->Lock(1);
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = 0; //qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		RGBColor pixel = current_background_brush->GetColour().pixel;
+		if (Colour)
+			RGBBackColor(&pixel);
+		else
+		{
+			unsigned char red = current_background_brush->GetColour().Red();
+			unsigned char blue = current_background_brush->GetColour().Blue();
+			unsigned char green = current_background_brush->GetColour().Green();
+			Bool isBlackColour =
+				(red == (unsigned char )0 &&
+				 blue == (unsigned char)0 &&
+				 green == (unsigned char)0);
+			BackColor(isBlackColour ? blackColor : whiteColor);
+		}
+	
+		int theBrushStyle = current_background_brush->GetStyle();
+		if (theBrushStyle == wxSOLID)
+#ifdef OLD_HEADERS
+			BackPat(qd.white);
+#else
+			BackPat(&qd.white);
+#endif
+		else if (theBrushStyle == wxTRANSPARENT)
+#ifdef OLD_HEADERS
+			BackPat(qd.white);
+#else
+			BackPat(&qd.white);
+#endif
+		else if (IS_HATCH(theBrushStyle))
+		{
+			macGetHatchPattern(theBrushStyle, cMacPattern);
+#ifdef OLD_HEADERS
+			BackPat(cMacPattern);
+#else
+			BackPat(&cMacPattern);
+#endif
+		}
+		else
+		{
+#ifdef OLD_HEADERS
+			BackPat(qd.white);
+#else
+			BackPat(&qd.white);
+#endif
+		}
+
+		//if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetLogicalFunction(int function)
+{
+	current_logical_function = function;
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = 0; //qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		int theMacPenMode;
+		switch (current_logical_function)
+		{
+		//	case wxCLEAR:  theMacPenMode = GXclear; break;
+			case wxXOR:  theMacPenMode = patXor; break;
+		//	case wxINVERT: theMacPenMode = GXinvert; break;
+		//	case wxOR_REVERSE: theMacPenMode = GXorReverse; break;
+		//	case wxAND_REVERSE: theMacPenMode = GXandReverse; break;
+			case wxAND: theMacPenMode = notPatBic; break;
+			case wxOR: theMacPenMode = patOr; break;
+			case wxAND_INVERT: theMacPenMode = patBic; break;
+		//	case wxNO_OP: theMacPenMode = GXnoop; break;
+		//	case wxNOR: theMacPenMode = GXnor; break;
+			case wxEQUIV: theMacPenMode = notPatXor; break;
+			case wxSRC_INVERT: theMacPenMode = notPatCopy; break;
+			case wxOR_INVERT: theMacPenMode = notPatOr; break;
+		//	case wxNAND: theMacPenMode = GXnand; break;
+		//	case wxSET: theMacPenMode = GXset; break;
+			case wxCOPY:
+			default:
+				theMacPenMode = patCopy; break;
+		}
+	
+		PenMode(theMacPenMode);
+
+		//if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxPrinterDC::StartDoc(char *message) { return TRUE; }
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::EndDoc(void) { }
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::StartPage(void)
+{
+  if (prPort)
+    PrOpenPage(prPort, 0); 
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::EndPage(void)
+{
+  if (prPort)
+    PrClosePage(prPort);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetMapMode(int mode)
+{
+  mapping_mode = mode;
+
+  int pixel_width = 0;
+  int pixel_height = 0;
+  int mm_width = 0;
+  int mm_height = 0;
+
+  // First, calculate how to scale from mm to pixels.
+  // Then we just need to find the scaling factor from ? to mm and multiply
+  // by the first scaling factor.
+
+#ifdef wx_mac
+  pixel_width = 800; // 640; for printing
+  pixel_height = 1200; //480;
+  mm_width = 225;
+  mm_height = 169;
+#endif // wx_mac
+
+  float mm2pixelsX = pixel_width/mm_width;
+  float mm2pixelsY = pixel_height/mm_height;
+
+  switch (mode)
+  {
+    case MM_TWIPS:
+    {
+      logical_scale_x = (float)(twips2mm * mm2pixelsX);
+      logical_scale_y = (float)(twips2mm * mm2pixelsY);
+      break;
+    }
+    case MM_POINTS:
+    {
+      logical_scale_x = (float)(pt2mm * mm2pixelsX);
+      logical_scale_y = (float)(pt2mm * mm2pixelsY);
+      break;
+    }
+    case MM_METRIC:
+    {
+      logical_scale_x = mm2pixelsX;
+      logical_scale_y = mm2pixelsY;
+      break;
+    }
+    case MM_LOMETRIC:
+    {
+      logical_scale_x = (float)(mm2pixelsX/10.0);
+      logical_scale_y = (float)(mm2pixelsY/10.0);
+      break;
+    }
+    default:
+    case MM_TEXT:
+    {
+      logical_scale_x = 1.0;
+      logical_scale_y = 1.0;
+      break;
+    }
+  }
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = 0; //qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		if (cMacCurrentTool == kPenTool)
+			wxMacSetCurrentTool(kPenTool); // Force recalculation of line width
+
+		//if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::SetUserScale(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	user_scale_x = x;
+	user_scale_y = y;
+
+	if (cMacDC->currentUser() == this)
+	{ // must update platform
+		GrafPtr theOldPort = 0; //qd.thePort;
+		CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+		if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort((GrafPtr)theMacGrafPort);
+
+		if (cMacCurrentTool == kPenTool)
+			wxMacSetCurrentTool(kPenTool); // Force recalculation of line width
+
+		//if ((GrafPtr)theMacGrafPort != theOldPort) ::SetPort(theOldPort);
+	}
+}
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::DeviceToLogicalX(int x) { return XDEV2LOG(x); }
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::DeviceToLogicalXRel(int x) { return XDEV2LOGREL(x); }
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::DeviceToLogicalY(int y) { return YDEV2LOG(y); }
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::DeviceToLogicalYRel(int y) { return YDEV2LOGREL(y); }
+
+//-----------------------------------------------------------------------------
+int wxPrinterDC::LogicalToDeviceX(float x) { return XLOG2DEV(x); }
+
+//-----------------------------------------------------------------------------
+int wxPrinterDC::LogicalToDeviceXRel(float x) { return XLOG2DEVREL(x); }
+
+//-----------------------------------------------------------------------------
+int wxPrinterDC::LogicalToDeviceY(float y) { return YLOG2DEV(y); }
+
+//-----------------------------------------------------------------------------
+int wxPrinterDC::LogicalToDeviceYRel(float y) { return YLOG2DEVREL(y); }
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::wxMacSetClip(void)
+{
+	SetCurrentDC();
+	if (current_reg)
+	{
+		::SetClip(current_reg);
+	}
+	else
+	{
+		Rect largestClipRect = {-32767, -32767, 32767, 32767};
+		::ClipRect(&largestClipRect);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::wxMacSetCurrentTool(wxMacToolType whichTool)
+{
+	SetCurrentDC();
+
+	RGBColor pixel;
+
+	switch (whichTool)
+	{
+		case kNoTool:
+			break;
+		case kBrushTool:
+			int theBrushStyle = current_brush->GetStyle();
+			if (theBrushStyle == wxSOLID)
+#ifdef OLD_HEADERS
+				PenPat(qd.black);
+#else
+				PenPat(&qd.black);
+#endif
+			else if (theBrushStyle == wxTRANSPARENT)
+#ifdef OLD_HEADERS
+				PenPat(qd.white); // WCH wx_mac: does this work??
+#else
+				PenPat(&qd.white); // WCH wx_mac: does this work??
+#endif
+			else if (IS_HATCH(theBrushStyle))
+			{
+				macGetHatchPattern(theBrushStyle, cMacPattern);
+#ifdef OLD_HEADERS
+				PenPat(cMacPattern);
+#else
+				PenPat(&cMacPattern);
+#endif
+			}
+			else
+			{
+#ifdef OLD_HEADERS
+				PenPat(qd.black);
+#else
+				PenPat(&qd.black);
+#endif
+			}
+	
+			pixel = current_brush->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else
+			{
+				unsigned char red = current_brush->GetColour().Red();
+				unsigned char blue = current_brush->GetColour().Blue();
+				unsigned char green = current_brush->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kPenTool:
+			int thePenWidth = current_pen->GetWidth();
+			int thePenHeight = current_pen->GetWidth();
+			PenSize(thePenWidth, thePenHeight);
+
+			int thePenStyle = current_pen->GetStyle();
+			if (thePenStyle == wxSOLID)
+#ifdef OLD_HEADERS
+				PenPat(qd.black);
+#else
+				PenPat(&qd.black);
+#endif
+			else if (thePenStyle == wxTRANSPARENT)
+#ifdef OLD_HEADERS
+				PenPat(qd.white);
+#else
+				PenPat(&qd.white);
+#endif
+			else if (IS_HATCH(thePenStyle))
+			{
+				macGetHatchPattern(thePenStyle, cMacPattern);
+#ifdef OLD_HEADERS
+				PenPat(cMacPattern);
+#else
+				PenPat(&cMacPattern);
+#endif
+			}
+			else
+			{
+#ifdef OLD_HEADERS
+				PenPat(qd.black);
+#else
+				PenPat(&qd.black);
+#endif
+			}
+
+			pixel = current_pen->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else
+			{
+				unsigned char red = current_pen->GetColour().Red();
+				unsigned char blue = current_pen->GetColour().Blue();
+				unsigned char green = current_pen->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kBlitTool:
+			ForeColor(blackColor);
+			BackColor(whiteColor);
+			break;
+		case kColorBlitTool:
+			BackColor(whiteColor);
+			pixel = current_pen->GetColour().pixel;
+			if (Colour)
+				RGBForeColor(&pixel);
+			else {
+				unsigned char red = current_pen->GetColour().Red();
+				unsigned char blue = current_pen->GetColour().Blue();
+				unsigned char green = current_pen->GetColour().Green();
+				Bool isWhiteColour =
+					(red == (unsigned char )255 &&
+					 blue == (unsigned char)255 &&
+					 green == (unsigned char)255);
+				ForeColor(isWhiteColour ? whiteColor : blackColor);
+			}
+			break;
+		case kQuillTool:
+			break;
+	}
+
+	cMacCurrentTool = whichTool;
+}
diff --git a/src/wxmac/src/mac/wx_dcpr2.cc b/src/wxmac/src/mac/wx_dcpr2.cc
new file mode 100644
index 0000000..cc0380f
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dcpr2.cc
@@ -0,0 +1,427 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dcpr2.cc
+// Purpose:	Print Canvas device context implementation (Macintosh version) (part 2)
+// Author:	Lou Birk (copied from wx_dccan)
+// Created:	1995
+// Updated:	
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Quickdraw.h>
+#include <Printing.h>
+#include "wx_dcpr.h"
+#include "wx_dccan.h"
+#include "wx_utils.h"
+#include "wx_canvs.h"
+#include "wx_privt.h"
+
+#include <QDOffScreen.h>
+
+
+class wxCanvasDC;
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::Clear(void)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+
+	float w, h;
+	GetSize(&w, &h);
+
+	Rect theClearRect = {0, 0, h, w};
+	::EraseRect(&theClearRect);
+}
+
+void wxPrinterDC::GetSize(float *width, float *height)
+{
+	*width = pixmapWidth;
+	*height = pixmapHeight;
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::CrossHair(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	int xx = XLOG2DEV(x);
+	int yy = YLOG2DEV(y);
+	float ww, hh;
+	GetSize(&ww, &hh) ;
+	wxMacDrawLine(0, yy, ww, yy);
+	wxMacDrawLine(xx, 0, xx, hh);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::FloodFill(float x, float y, wxColour *col, int style)
+//=============================================================================
+{
+	SetCurrentDC();
+}
+
+//-----------------------------------------------------------------------------
+Bool wxPrinterDC::GetPixel(float x, float y, wxColour *col)
+//=============================================================================
+{
+	SetCurrentDC();
+
+	return FALSE ;
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::IntDrawLine(int x1, int y1, int x2, int y2)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawLine(XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
+	CalcBoundingBox(x1, y1); // WCH: not in original. Why not?
+	CalcBoundingBox(x2, y2); // WCH: not in original. Why not?
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawLine(float x1, float y1, float x2, float y2)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawLine(XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
+	CalcBoundingBox(x1, y1);
+	CalcBoundingBox(x2, y2);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawArc(float x1,float y1,float x2,float y2,float xc,float yc)
+{
+	SetCurrentDC();
+
+
+  if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+  {
+    if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+  }
+
+  if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+  {
+    if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+  }
+  CalcBoundingBox(x1, y1);
+  CalcBoundingBox(x2, y2);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawPoint(float x, float y)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	wxMacDrawPoint(XLOG2DEV(x), YLOG2DEV(y));
+	CalcBoundingBox(x, y);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawPolygon(int n, wxPoint points[],
+								float xoffset, float yoffset, int fillStyle)
+{
+	SetCurrentDC();
+	if (n <= 0) return;
+	Point *xpoints1 = new Point[n+1];
+	for (int i = 0; i < n; i++)
+	{
+		xpoints1[i].h = XLOG2DEV(points[i].x + xoffset);
+		xpoints1[i].v = YLOG2DEV(points[i].y + yoffset);
+		CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
+	}
+
+	// Close figure
+	xpoints1[n].h = xpoints1[0].h;
+	xpoints1[n].v = xpoints1[0].v;
+
+	PolyHandle thePolygon = OpenPoly();
+	MoveTo(xpoints1[0].h, xpoints1[0].v);
+	for (int j = 1; j <= n; j++)
+	{
+		LineTo(xpoints1[j].h, xpoints1[j].v);
+	}
+	ClosePoly();
+
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintPoly(thePolygon);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FramePoly(thePolygon);
+	}
+
+	delete[] xpoints1;
+	KillPoly(thePolygon);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawLines(int n, wxIntPoint points[], int xoffset, int yoffset)
+{
+	if (n <= 0) return;
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		SetCurrentDC();
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	
+		Point *xpoints = new Point[n];
+	
+		for (int i = 0; i < n; i++)
+		{
+			xpoints[i].h = XLOG2DEV(points[i].x + xoffset);
+			xpoints[i].v = YLOG2DEV(points[i].y + yoffset);
+			CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset); // WCH: not in original??
+		}
+	
+		PolyHandle thePolygon = OpenPoly();
+		MoveTo(xpoints[0].h, xpoints[0].v);
+		for (int j = 1; j < n; j++)
+		{
+			LineTo(xpoints[j].h, xpoints[j].v);
+		}
+		ClosePoly();
+	
+		FramePoly(thePolygon);
+	
+		delete[] xpoints;
+		KillPoly(thePolygon);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawLines(int n, wxPoint points[], float xoffset, float yoffset)
+{
+	if (n <= 0) return;
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		SetCurrentDC();
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+	
+		Point *xpoints = new Point[n];
+	
+		for (int i = 0; i < n; i++)
+		{
+			xpoints[i].h = XLOG2DEV(points[i].x + xoffset);
+			xpoints[i].v = YLOG2DEV(points[i].y + yoffset); // WCH: original mistype "h" for "v"
+			CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset); // WCH: not in original??
+		}
+	
+		PolyHandle thePolygon = OpenPoly();
+		MoveTo(xpoints[0].h, xpoints[0].v);
+		for (int j = 1; j < n; j++)
+		{
+			LineTo(xpoints[j].h, xpoints[j].v);
+		}
+		ClosePoly();
+	
+		FramePoly(thePolygon);
+	
+		delete[] xpoints;
+		KillPoly(thePolygon);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawRectangle(float x, float y, float width, float height)
+//-----------------------------------------------------------------------------
+{
+	SetCurrentDC();
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintRect(&theRect);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameRect(&theRect);
+	}
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawRoundedRectangle
+					(float x, float y, float width, float height, float radius)
+{
+	SetCurrentDC();
+	if (radius < 0.0) radius = 0.0; // Negative radius can crash your ENTIRE X server. Wow!
+    
+	int phys_radius = XLOG2DEVREL(radius);
+
+	int phys_rwidth = phys_radius * 2;
+	int phys_rheight = phys_rwidth;
+
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintRoundRect(&theRect, phys_rwidth, phys_rheight);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameRoundRect(&theRect, phys_rwidth, phys_rheight);
+	}
+
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawEllipse(float x, float y, float width, float height)
+{
+	SetCurrentDC();
+	int top = YLOG2DEV(y);
+	int left = XLOG2DEV(x);
+	int bottom = YLOG2DEV(y + height);
+	int right = XLOG2DEV(x + width);
+	Rect theRect = {top, left, bottom, right};
+	if (current_brush && current_brush->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kBrushTool) wxMacSetCurrentTool(kBrushTool);
+		PaintOval(&theRect);
+	}
+
+	if (current_pen && current_pen->GetStyle() != wxTRANSPARENT)
+	{
+		if (cMacCurrentTool != kPenTool) wxMacSetCurrentTool(kPenTool);
+		FrameOval(&theRect);
+	}
+	CalcBoundingBox(x, y);
+	CalcBoundingBox(x + width, y + height);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawIcon(wxIcon *icon, float x, float y)
+{
+	int h, w;
+	w = icon->GetWidth();
+	h = icon->GetHeight();
+	if (!icon->selectedIntoDC && icon->Ok()) {
+		wxMemoryDC *mdc;
+		mdc = new wxMemoryDC();
+		mdc->SelectObject(icon);
+		if (mdc->Ok())
+			Blit(x, y, w, h, mdc, 0, 0);
+		mdc->SelectObject(NULL);
+		delete mdc;
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxPrinterDC::Blit(float xdest, float ydest, float width, float height,
+                wxCanvasDC *source, float xsrc, float ysrc, int rop)
+{
+	if (device != source->device) {
+		// Switch Gworld to this
+		SetGWorld(cMacDC->macGrafPort(), 0);
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC();
+	}
+	else {
+		SetCurrentDC();
+	}
+	if (rop == wxCOLOR) {
+	  wxMacSetCurrentTool(kColorBlitTool);
+	  rop = wxCOPY;
+	} else
+	  wxMacSetCurrentTool(kBlitTool);
+	Bool theResult = FALSE;
+
+	if (source->pixmap)
+	{
+		int mode;
+		switch (rop)
+		{ // FIXME -  these modes have not be tested
+		//	case wxCLEAR:  theMacPenMode = GXclear; break;
+			case wxXOR:  
+				mode = srcXor; 
+				break;
+		//	case wxINVERT: theMacPenMode = GXinvert; break;
+		//	case wxOR_REVERSE: theMacPenMode = GXorReverse; break;
+		//	case wxAND_REVERSE: theMacPenMode = GXandReverse; break;
+			case wxAND:
+				mode = srcBic;
+				break;
+			case wxOR: 
+				mode = srcOr; 
+				break;
+			case wxAND_INVERT: 
+				mode = notSrcBic; break;
+		//	case wxNO_OP: theMacPenMode = GXnoop; break;
+		//	case wxNOR: theMacPenMode = GXnor; break;
+			case wxEQUIV: 
+				mode = notSrcXor; break;
+			case wxSRC_INVERT: 
+				mode = notSrcCopy; break;
+			case wxOR_INVERT: 
+				mode = notSrcOr; break;
+		//	case wxNAND: theMacPenMode = GXnand; break;
+		//	case wxSET: theMacPenMode = GXset; break;
+			case wxCOPY:
+			default:
+				mode = srcCopy;
+				break;
+		}
+          // LJB Moonface, Inc. Changes to make wxmac stuff
+          // work with the HTML viewer "Majestic"
+          // for the mac, take the offscreen pixmap and blit
+          // it to the screen as defined by the destination
+          // rectangle information
+		int w = width;
+		int h = height;
+		int x = XLOG2DEV(xdest);
+		int y = YLOG2DEV(ydest);
+		Rect srcr = {0, 0, h, w};
+		Rect destr = {y, x, y+h, x+w };
+        BitMap *dstbm = (BitMap *) &((GrafPtr)(cMacDC->macGrafPort()))->portBits;
+		// Lock PixMaps
+		//PixMapHandle srpixh = source->pixmap;
+		// mflatt: this should be pixmap, right?
+		PixMapHandle srpixh = source->pixmap;
+		int rs = ::LockPixels(srpixh);
+
+
+		CopyBits((BitMap *) (* srpixh),   (dstbm),	&srcr, &destr, mode, NULL);
+
+		::UnlockPixels(srpixh);
+		CalcBoundingBox(xdest, ydest);
+		CalcBoundingBox(xdest + width, ydest + height);
+		theResult = TRUE;
+	}
+
+  	return theResult;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_dcpr3.cc b/src/wxmac/src/mac/wx_dcpr3.cc
new file mode 100644
index 0000000..1554e60
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dcpr3.cc
@@ -0,0 +1,108 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dcpr3.cc
+// Purpose:	Print Canvas device context implementation (Macintosh version) (part 3)
+// Author:	Lou Birk (copied from wx_dccan)
+// Created:	1995
+// Updated:	
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include <iostream.h>
+#include <fstream.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QuickDraw.h>
+#include <Printing.h>
+#include "wx_dcpr.h"
+//#include "wx_dccan.h"
+#include "wx_utils.h"
+
+
+// Declarations local to this file
+#define YSCALE(y) (yorigin - (y))
+#define     wx_round(a)    (int)((a)+.5)
+
+extern CGrafPtr wxMainColormap;
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::DrawText(const char* text, float x, float y, Bool use16)
+{
+	SetCurrentDC();
+	wxColour current_colour;
+
+// CHANGES FOR MAJESTIC VIEWER LjB Moonface, Inc.
+	::TextFont(font->GetMacFontNum());
+	::TextSize(font->GetPointSize());
+	::TextFace(font->GetMacFontStyle());
+
+    //if (cMacCurrentTool != kPenTool)
+      wxMacSetCurrentTool(kPenTool);
+
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	MoveTo(XLOG2DEV(x), YLOG2DEV(y + fontInfo.ascent)); // move pen to start drawing text
+	int theStrlen = strlen(text);
+	::DrawText(text, 0, theStrlen); // WCH: kludge, mac procedure same name as wxWindows method
+
+
+	float w, h;
+	GetTextExtent(text, &w, &h);
+	CalcBoundingBox(x + w, y + h);
+	CalcBoundingBox(x, y);
+}
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::GetCharHeight(void)
+//-----------------------------------------------------------------------------
+{
+	int theCharHeight;
+	if (!font)
+  		theCharHeight = font->GetCharHeight();
+  	else
+  		theCharHeight = 12;
+
+  	return XDEV2LOGREL(theCharHeight);
+}
+
+//-----------------------------------------------------------------------------
+float wxPrinterDC::GetCharWidth(void)
+//-----------------------------------------------------------------------------
+{
+	int theCharWidth;
+	if (!font)
+  		theCharWidth = font->GetCharWidth();
+  	else
+  		theCharWidth = 12;
+
+  	return XDEV2LOGREL(theCharWidth);
+}
+
+//-----------------------------------------------------------------------------
+void wxPrinterDC::GetTextExtent(const char* string, float* x, float* y, float* descent,
+  						float* externalLeading, wxFont* the_font, Bool use16)
+{
+	float x2, y2, descent2, externalLeading2;
+	if (the_font)
+	{
+		the_font->GetTextExtent((char *)string, &x2, &y2, &descent2, &externalLeading2, use16);
+	}
+	else if (font)
+	{
+		font->GetTextExtent((char *)string, &x2, &y2, &descent2, &externalLeading2, use16);
+	}
+	else
+	{
+        *x = -1;
+        *y = -1;
+		if (descent) *descent = 0.0;
+		if (externalLeading) *externalLeading = 0.0;
+		return;
+	}
+
+	*x = XDEV2LOGREL(x2);
+	*y = YDEV2LOGREL(y2);
+	if (descent) *descent = descent2;
+	if (externalLeading) *externalLeading = externalLeading2;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_dialg.cc b/src/wxmac/src/mac/wx_dialg.cc
new file mode 100644
index 0000000..437c07b
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dialg.cc
@@ -0,0 +1,926 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dialg.cc
+// Purpose:	wxDialogBox (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+//-----------------------------------------------------------------------------
+// Dialog box - like panel but doesn't need a frame, and is modal or non-modal
+//-----------------------------------------------------------------------------
+
+static const char sccsid[] = "%W% %G%";
+#if 0
+#ifdef GUSI
+#include "TFileSpec.h"
+#endif
+#endif
+#include "wx_dialg.h"
+#include "wx_panel.h"
+#include "wx_utils.h"
+#include "wx_messg.h"
+#include "wx_main.h"
+#include "wx_buttn.h"
+#include <StandardFile.h>
+#include <TextUtils.h>
+#include <Strings.h>
+#ifdef PYLIB
+extern "C" {
+#include "nfullpath.h"
+}
+#endif
+
+#define wxDIALOG_DEFAULT_X 300
+#define wxDIALOG_DEFAULT_Y 300
+
+extern wxApp* wxTheApp;
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+static int IsUnshown(void *data)
+{
+	return !((wxDialogBox *)data)->IsShown();
+}
+
+//-----------------------------------------------------------------------------
+void wxDialogBox::Show(Bool show)
+{
+	cFrame->Show(show);
+	if (show) {
+  	  if (cFrame->IsModal()) {
+		wxWindow *oldm = wxGetModalWindow(ContextWindow());
+		wxPutModalWindow(ContextWindow(), cFrame);
+		
+		wxDispatchEventsUntil(IsUnshown, (void *)this);
+
+		wxPutModalWindow(ContextWindow(), oldm);
+	  }
+    }
+}
+
+Bool wxDialogBox::IsShown(void)
+{
+  return cFrame->IsShown();
+}
+
+void wxDialogBox::SetSize(int x, int y, int width, int height, int flags)
+{
+    if (!(flags & 0x70)) {
+      int w, h, cw, ch;
+      
+      cFrame->GetSize(&w, &h);
+      cFrame->GetClientSize(&cw, &ch);
+      
+	  cFrame->SetSize(x, y, width + (w - cw), height + (h - ch), flags);
+	} else
+	  wxWindow::SetSize(x, y, width, height, flags);
+}
+
+
+// Default resizing behaviour - if only ONE subwindow,
+// resize to client rectangle size
+void wxDialogBox::OnSize(int x, int y)
+{
+  // Search for a child which is a subwindow, not another frame.
+  wxWindow *child = NULL;
+  // Count the number of _subwindow_ children
+  int noChildren = 0;
+  for(wxChildNode *node = GetChildren()->First(); node; node = node->Next())
+  {
+    wxWindow *win = (wxWindow *)node->Data();
+    WXTYPE winType = win->__type;
+
+    if (wxSubType(winType, wxTYPE_PANEL) ||
+        wxSubType(winType, wxTYPE_TEXT_WINDOW) ||
+        wxSubType(winType, wxTYPE_CANVAS))
+    {
+      child = win;
+      noChildren ++;
+    }
+  }
+  if (!child || (noChildren > 1))
+    return;
+
+  int client_x, client_y;
+
+  GetClientSize(&client_x, &client_y);
+  child->SetSize(0, 0, client_x, client_y, 0x70);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxDialogBox::IsModal(void)
+{
+	return cFrame->IsModal();
+}
+
+//-----------------------------------------------------------------------------
+void wxDialogBox::ShowModal(void)
+{
+	Show(TRUE);
+	if (!cFrame->IsModal()) {
+  	  while (IsShown())
+		wxTheApp->MainLoop();
+	}
+}
+
+void wxDialogBox::Fit(void)
+{
+	int x, y;
+
+	wxPanel::Fit();
+	wxPanel::GetSize(&x, &y);
+	// cFrame->SetClientSize(x, y);
+}
+
+//-----------------------------------------------------------------------------
+int wxDialogBox::GetButtonPressed(void)
+{
+	return cButtonPressed;
+}
+
+//-----------------------------------------------------------------------------
+void wxDialogBox::SetButtonPressed(int buttonPressed)
+{
+	cButtonPressed = buttonPressed;
+}
+
+//-----------------------------------------------------------------------------
+Bool wxDialogBox::OnClose(void)
+{
+	Bool result;
+	if (IsModal())
+	{
+		Show(FALSE);
+		result = FALSE; // don't want dialog frame deleted
+	}
+	else
+	{
+		result = TRUE;
+	}
+
+	if (result)
+	  return cFrame->OnClose();
+
+	return result;
+}
+
+//=============================================================================
+//
+// Message centring code
+//
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxSplitMessage(char* message, wxList* messageList, wxPanel* panel)
+{
+  char* copyMessage = copystring(message);
+  int i = 0;
+  int len = strlen(copyMessage);
+  char* currentMessage = copyMessage;
+  while (i < len)
+  {
+    while ((i < len) && (copyMessage[i] != '\n')) i ++;
+    if (i < len) copyMessage[i] = 0;
+    wxMessage* mess = new wxMessage(panel, currentMessage);
+    messageList->Append(mess);
+    panel->NewLine();
+
+    currentMessage = copyMessage + i + 1;
+  }
+  delete[] copyMessage;
+}
+
+//-----------------------------------------------------------------------------
+void wxCentreMessage(wxList* messageList)
+{
+  // Do the message centering
+  wxNode* node = messageList->First();
+  while (node)
+  {
+    wxMessage* mess = (wxMessage*)node->Data();
+    mess->Centre();
+    node = node->Next();
+  }
+}
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxDialogBox::wxDialogBox // Constructor (for dialog window)
+	(
+		wxWindow*	parentFrame,		// this is ignored, used to be wxFrame*
+		char*		windowTitle,
+		Bool		modal,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxPanel (new wxFrame(NULL, windowTitle, 
+				  x, y,
+				  width, height, style, windowName, objectType),
+	              0, 0, width, height),
+		cButtonPressed (0)
+{
+  cFrame = (wxFrame *)GetParent();
+  cFrame->cDialogPanel = this;
+  cFrame->MakeModal(modal);
+  
+  /* Set dialog panel to frame's client size: */
+  int w, h;
+  cFrame->GetClientSize(&w, &h);
+  SetSize(-1, -1, w, h, 0x70);
+  
+  __type = wxTYPE_DIALOG_BOX;
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxDialogBox::~wxDialogBox()
+{
+	if (cFrame) {
+		  wxTopLevelWindows(ContextWindow())->DeleteObject(cFrame);
+		  cFrame = NULL;
+	}
+}
+
+static wxDialogBox* wxGetDialogFromButton(wxButton& button);
+static void wxOkButtonProc(wxButton& button, wxEvent& event);
+static void wxCancelButtonProc(wxButton& button, wxEvent& event);
+static void wxYesButtonProc(wxButton& button, wxEvent& event);
+static void wxNoButtonProc(wxButton& button, wxEvent& event);
+
+//-----------------------------------------------------------------------------
+// Pop up a message box
+//-----------------------------------------------------------------------------
+int wxMessageBox(char* message, char* caption, long style,
+                 wxWindow* parent, int x, int y)
+{
+	wxDialogBox* dialog = new wxDialogBox((wxFrame*)NULL, caption, TRUE, x, y);
+
+//============================================
+	wxPanel* dialogPanel = dialog;
+	wxFont* theFont = new wxFont(12, wxSYSTEM, wxNORMAL, wxNORMAL);
+	dialogPanel->SetLabelFont(theFont);
+	dialogPanel->SetButtonFont(theFont);
+
+//============================================
+	wxPanel* messagePanel = new wxPanel(dialogPanel, -1, -1, -1, -1);
+	Bool centre = ((style & wxCENTRE) == wxCENTRE);
+
+	wxList messageList;
+	wxSplitMessage(message, &messageList, messagePanel);
+	messagePanel->Fit();
+	if (centre)
+	{
+		wxCentreMessage(&messageList);
+	}
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	dialogPanel->NewLine();
+	wxPanel* buttonPanel = new wxPanel(dialogPanel, -1, -1, -1, -1);
+
+	wxButton* ok = NULL;
+	wxButton* cancel = NULL;
+	wxButton* yes = NULL;
+	wxButton* no = NULL;
+
+	if (style & wxYES_NO)
+	{
+		yes = new wxButton(buttonPanel, (wxFunction)&wxYesButtonProc, "Yes");
+		no = new wxButton(buttonPanel, (wxFunction)&wxNoButtonProc, "No");
+	}
+
+	if (style & wxCANCEL)
+	{
+		cancel = new wxButton(buttonPanel, (wxFunction)&wxCancelButtonProc, "Cancel");
+	}
+
+	if (!(style & wxYES_NO) && (style & wxOK))
+	{
+		ok = new wxButton(buttonPanel, (wxFunction)&wxOkButtonProc, "OK");
+	}
+
+	if (ok)
+		ok->SetDefault();
+	else if (yes)
+		yes->SetDefault();
+	buttonPanel->Fit();
+	buttonPanel->SetFocus();
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	
+	dialogPanel->Fit();
+	dialog->Fit();
+
+	messagePanel->Centre(wxHORIZONTAL);
+	buttonPanel->Centre(wxHORIZONTAL);
+
+	dialogPanel->Centre(wxBOTH);
+
+//============================================
+	
+	dialog->Show(TRUE);
+	int result = dialog->GetButtonPressed();
+	delete dialog;
+
+//============================================
+
+	return result;
+}
+
+//=============================================================================
+//
+// Dialog button callback procedures
+//
+//=============================================================================
+
+static wxDialogBox* wxGetDialogFromButton(wxButton& button)
+{
+	wxFrame *fr = button.GetRootFrame();
+	wxDialogBox* dialog = fr->cDialogPanel;
+	if (dialog == NULL) {
+   		wxFatalError("No DialogBox found on RootFrame.");
+   	}
+   	return dialog;
+}
+
+
+//-----------------------------------------------------------------------------
+static void wxOkButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxOK);
+	dialog->Show(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+static void wxCancelButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxCANCEL);
+	dialog->Show(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+static void wxYesButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxYES);
+	dialog->Show(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+static void wxNoButtonProc(wxButton& button, wxEvent& event)
+{
+//	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+	wxDialogBox* dialog = wxGetDialogFromButton(button);
+
+	dialog->SetButtonPressed(wxNO);
+	dialog->Show(FALSE);
+}
+
+extern "C" {
+ extern char *scheme_build_mac_filename(FSSpec *f, int);
+};
+
+//= T.P. ==============================================================================
+char *wxFileSelector(char *message, char *default_path,
+                     char *default_filename, char *default_extension,
+                     char *wildcard, int flags,
+                     wxWindow *parent, int x, int y)
+{	
+	StandardFileReply	rep;
+	SFTypeList typeList = { 'TEXT' };
+	char * name;
+	short numTypes = -1; // all types
+	Str255	p_prompt,p_defname;
+	OSErr err;
+
+#if 0
+	if (flags & wxDIR_ONLY)
+		return wxDirectorySelector(message, default_path, default_filename,
+			default_extension, wildcard, flags, parent, x, y);
+#endif
+			
+	if ((flags == 0) || (flags & wxOPEN))
+	{	// get file
+		::StandardGetFile( NULL, numTypes, typeList, &rep);	
+	} else
+	{	// put file
+		if (message)
+		{	
+			strcpy((char *)p_prompt,message);
+		} else 
+		{
+			strcpy((char *)p_prompt, "Save File Name");
+		}
+		C2PStr((char *)p_prompt);
+		if (default_filename)
+		{	strcpy((char *)p_defname, default_filename);
+		} else 
+		{
+			strcpy((char *)p_defname, "");
+		}
+		C2PStr((char *)p_defname);
+		::StandardPutFile( p_prompt, p_defname, &rep);
+	}
+	
+	if (!rep.sfGood)
+	  return NULL;
+	
+#if 1
+	return scheme_build_mac_filename(&rep.sfFile, 0);
+#else	
+#ifdef GUSI
+	char *rtnval = NULL;
+	if (rep.sfGood)
+	{	
+		
+		TFileSpec tFile;
+		char *name;
+		
+		if (rep.sfFile.name)
+		{
+		  tFile = TFileSpec(rep.sfFile.vRefNum,
+		                    rep.sfFile.parID,
+		                    rep.sfFile.name, TRUE);
+		  name = tFile.FullPath(); // destroyed on exit, try copystring
+		  strcpy(wxBuffer, name);
+		  rtnval = wxBuffer;
+		}
+    }
+	return rtnval;
+#elif defined(PYLIB)
+	//int nfullpath(FSSpec *, char *);	/* Generate full path from fsspec */
+	char *rtnval = NULL;
+	if (rep.sfGood)
+	{	
+				
+		if (rep.sfFile.name)
+		{
+		  nfullpath(&rep.sfFile, wxBuffer);
+		  rtnval = wxBuffer;
+		}
+    }
+	return rtnval;
+#else
+	if (rep.sfGood)
+	{	
+		/***** HELL, trying to get the default directory.. any hint?
+		char msg[200];
+				err = ::SetVol(0,CurDirStore);
+				sprintf(msg,"File name:%s Parent-folder ID:%ld VolRefNum:%ld CurDir:%ld -- Err:%d --",
+					rep.sfFile.name,rep.sfFile.parID,rep.sfFile.vRefNum,CurDirStore,err);
+				wxError(msg);
+		******/
+		::p2cstr(rep.sfFile.name); 
+		strcpy(wxBuffer, (char *)rep.sfFile.name);
+		return wxBuffer;	
+	} 
+	return 0;
+#endif
+#endif
+}
+
+//---------------- New to Wxwindows - Select a Directory ----------------------
+
+// This code barrowed from StandardGetFolder written by Paul Forrester (paulf@apple.com)
+// and modified by kkirksey1@aol.com 
+// converted to wxMac by Cecil Coupe
+#include <String.h>
+#include <Script.h>
+#include <Aliases.h>
+#include <StandardFile.h>
+#include <LowMem.h>
+
+// defined later
+#define GetSFCurDir  LMGetCurDirStore
+
+#define GetSFVRefNum  LMGetSFSaveDisk
+
+static pascal Boolean MyCustomGetDirectoryFileFilter(  CInfoPBPtr  myPB, 
+                                                Ptr         myDataPtr);
+
+static void SetButtonTitle ( Handle    ButtonHdl, 
+                      Str255    name, 
+                      Rect      *ButtonRect);
+
+static pascal short MyCustomGetDirectoryDlogHook( short        item, 
+                                           DialogPtr    theDialog,
+                                           Ptr          myDataPtr);
+
+static char *StrCpy (char *s1, char *s2);
+
+static char *StrCat (char *s1, char *s2);                                      
+
+typedef struct {
+	StandardFileReply	*sfr;
+	int					wxflags;
+} HookExtra, *HookExtraPtr;
+
+/*=============================================================================+
+|                               Resource IDs                                   |
++=============================================================================*/
+#define rGetFolderButton            10
+#define rGetFolderMessage           11
+#define kFolderBit                  0x0010  
+#define rGetFolderDialog            2008
+
+
+/*=============================================================================+
+|                             Global Variables                                 |
++=============================================================================*/
+static  char    gCurrentSelectedFolder [256];
+
+/*******************************************************************************
+* MyCustomGetDirectoryFileFilter                                               *
+*                                                                              *
+*     This is the file filter passed to CustomGetFile. It passes folders only, *
+*	  files only, or both depending on the flags in the HookExtra struct.      *
+*     The default (flags == 0) is to pass everything, ie filter nothing.       *
+*******************************************************************************/
+static pascal Boolean
+MyCustomGetDirectoryFileFilter( CInfoPBPtr  myPB, 
+                                Ptr         myDataPtr )
+{
+	HookExtraPtr hp = (HookExtraPtr)myDataPtr;
+	int result = 0;						// Boolean actually
+	if (hp->wxflags & (wxDIR_ONLY | wxFILES_ONLY)) {
+		if ((hp->wxflags & wxDIR_ONLY) && (myPB->hFileInfo.ioFlAttrib & ioDirMask))
+			result = 1;
+		if ((hp->wxflags & wxFILES_ONLY) && !(myPB->hFileInfo.ioFlAttrib & ioDirMask))
+			result = 1;			
+	} else {
+		// nothing special asked for, return all files and dirs
+		result = 1;
+	}
+	return !result;	// FALSE ==> display in dialog list
+}
+
+static FileFilterYDUPP ffupp = NewFileFilterYDProc(MyCustomGetDirectoryFileFilter);
+
+/*******************************************************************************
+* MyCustomGetDirectoryDlogHook                                                 *
+*                                                                              *
+*     This function lets us process item hits in the GetFolderDialog.  We're   *
+*     only interested if the user hit the selectFolder button. We pass all     *
+*     other item hits back to ModalDialog.                                     *
+*******************************************************************************/
+
+static pascal short MyCustomGetDirectoryDlogHook(  short       item, 
+                                            DialogPtr   theDialog, 
+                                            Ptr         myDataPtr )
+{
+
+    WindowPeek      dlgPeek;
+    Str255          selectedName;
+    CInfoPBRec      pb;
+    short           MyCustomGetDirectoryDlogHook;
+    OSErr           err;
+    short           itemType;           
+    Rect            itemRect;                                   
+    Handle          itemHandle;
+    Boolean         isAlias,
+                    isFolder;
+    StandardFileReply *mySFRPtr;
+
+    
+    
+    /*-------------------------------------------------------------------------+
+    | Set the return value to defualt to the item that was passed in.          |
+    +-------------------------------------------------------------------------*/
+    MyCustomGetDirectoryDlogHook = item;
+
+    /*-------------------------------------------------------------------------+
+    | CustomGet calls dialog hook for both main and subsidiary dialog boxes.   |
+    | Make sure that dialog record indicates that this is the main GetFolder   |
+    | dialog.                                                                  |
+    +-------------------------------------------------------------------------*/
+    dlgPeek = (WindowPeek)(theDialog);
+    if ( (OSType)(dlgPeek->refCon) == sfMainDialogRefCon )
+    {
+        /*---------------------------------------------------------------------+
+        | Get a handle to the select folder button, in case we need to change  |
+        | the label.                                                           |
+        +---------------------------------------------------------------------*/
+        GetDialogItem(theDialog, rGetFolderButton, &itemType, &itemHandle, &itemRect);
+
+        /*---------------------------------------------------------------------+
+        | If this is the first time the dialog hook has been called...         |
+        +---------------------------------------------------------------------*/
+        if ( item == sfHookFirstCall )
+        {
+            /*-----------------------------------------------------------------+
+            | Set the prompt displayed above the file list...                  |
+            +-----------------------------------------------------------------*/
+            GetDialogItem ( theDialog, rGetFolderMessage, &itemType, &itemHandle, 
+                        &itemRect );
+            mySFRPtr = ((HookExtraPtr)(myDataPtr))->sfr;
+            SetIText ( itemHandle, mySFRPtr->sfFile.name );
+
+            /*-----------------------------------------------------------------+
+            | And the name of the currently selected folder in the select      |
+            | folder button.                                                   |
+            +-----------------------------------------------------------------*/
+            pb.hFileInfo.ioCompletion = NULL;
+            pb.hFileInfo.ioNamePtr = (StringPtr)selectedName;
+            pb.hFileInfo.ioVRefNum = GetSFVRefNum();
+            pb.hFileInfo.ioDirID = GetSFCurDir();
+            pb.hFileInfo.ioFDirIndex = -1;
+            err = PBGetCatInfo( &pb, FALSE);
+
+            /*-----------------------------------------------------------------+
+            | Note that this error return is important! When the dialog hook   |
+            | is called for the first time, Super Boomerang (and possibly      |
+            | Norton directory assistance aren't finished doing their          |
+            | rebounting, so the values returned by GetSFVRefNum and           |
+            | GetSFCurDir may not be valid, and hence PBGetCatInfo will return |
+            | an error.  That one took me a while to figure out.               |
+            +-----------------------------------------------------------------*/
+            if ( err != noErr )
+            {
+                return (MyCustomGetDirectoryDlogHook);
+            }
+            
+            GetDItem(theDialog, rGetFolderButton, &itemType, &itemHandle, 
+                     &itemRect);
+            SetButtonTitle( itemHandle, selectedName, &itemRect);
+        }
+        
+        else
+        {
+            /*-----------------------------------------------------------------+
+            | Cast myDataPtr back to a SFReply pointer.                        |
+            +-----------------------------------------------------------------*/
+            mySFRPtr = ((HookExtraPtr)(myDataPtr))->sfr;
+
+
+            /*-----------------------------------------------------------------+
+            | If the selected folder is an alias, resolve it. isFolder will    |
+            | be set to true if a folder or aliased folder is selected.        |
+            +-----------------------------------------------------------------*/
+            ResolveAliasFile (&(mySFRPtr->sfFile), TRUE, &isFolder, &isAlias);
+            if ( (isAlias) && (isFolder) )
+                StrCpy( (char *)selectedName, (char *)mySFRPtr->sfFile.name );
+                
+            /*-----------------------------------------------------------------+
+            | If the selected item is a folder or volume, just copy the name   |
+            | into selectedName...                                             |
+            +-----------------------------------------------------------------*/
+            else if (( mySFRPtr->sfIsFolder) || (mySFRPtr->sfIsVolume) )
+                StrCpy( (char *)selectedName, (char *)mySFRPtr->sfFile.name );
+
+            /*-----------------------------------------------------------------+
+            | Otherwise, copy the name of the selected item's parent directory |
+            | into selectedName.                                               |
+            +-----------------------------------------------------------------*/
+            else
+            {
+                pb.hFileInfo.ioCompletion = NULL;
+                pb.hFileInfo.ioNamePtr = (StringPtr)selectedName;
+                pb.hFileInfo.ioVRefNum = mySFRPtr->sfFile.vRefNum;
+                pb.hFileInfo.ioDirID = mySFRPtr->sfFile.parID;
+                pb.hFileInfo.ioFDirIndex = -1;
+                err = PBGetCatInfo( &pb, FALSE);
+                if ( err != noErr)
+                    return (MyCustomGetDirectoryDlogHook);
+            }
+            
+            /*-----------------------------------------------------------------+
+            | If the selected folder has changed since the last call to this   |
+            | dialog hook function, re-draw the button with the new selected   |
+            | folder name.                                                     |
+            +-----------------------------------------------------------------*/
+            if ( !EqualString( selectedName, (StringPtr)gCurrentSelectedFolder, 
+                                FALSE, FALSE ) ) 
+                SetButtonTitle(itemHandle, selectedName, &itemRect);
+
+            /*-----------------------------------------------------------------+
+            | If the user clicked the select folder button, force a cancel and |
+            | set the sfGood field of the Reply record to true.                |
+            +-----------------------------------------------------------------*/
+            if (item == rGetFolderButton)
+            {
+                MyCustomGetDirectoryDlogHook = sfItemCancelButton;
+                mySFRPtr->sfGood = TRUE;
+            }
+                
+        }
+    }
+    
+    return  (MyCustomGetDirectoryDlogHook );
+}
+
+static DlgHookYDUPP dlghookupp = NewDlgHookYDProc(MyCustomGetDirectoryDlogHook);
+
+/*******************************************************************************
+* SetButtonTitle                                                               *
+*                                                                              *
+*     Whenever the selected folder is changed, SetButtonTitle is called to     *
+*     redraw the get folder button.  Pass it a handle to the button, the new   *
+*     string to be drawn in the button, and a pointer to the rect the button   *
+*     is drawn within.                                                         *
+*******************************************************************************/
+static void SetButtonTitle(    Handle      ButtonHdl, 
+                        Str255      name, 
+                        Rect        *ButtonRect )
+{
+    short   resultCode;
+    short   width;
+    char    TmpStr[ 256 ];
+
+    StrCpy( gCurrentSelectedFolder, (char*) name );
+    
+    /*-------------------------------------------------------------------------+
+    | Find the width left over in the button after drawing the word 'Select'   |
+    | the quotation marks. Truncate the new name to this length.               |
+    +-------------------------------------------------------------------------*/
+    width = (ButtonRect->right - ButtonRect->left) -
+            (StringWidth((StringPtr)"\pSelect \"\"") +
+             CharWidth('J'));
+    
+    resultCode = TruncString(width, name, smTruncEnd );
+    if ( resultCode < 0 );
+    
+    /*-------------------------------------------------------------------------+
+    | Redraw the button.                                                       |
+    +-------------------------------------------------------------------------*/
+    sprintf( TmpStr, "Select \"%#s\"", name );
+    c2pstr( TmpStr );
+    SetCTitle((ControlHandle)(ButtonHdl), (StringPtr)TmpStr );
+    ValidRect(ButtonRect);
+}
+
+/*******************************************************************************
+* StrCpy                                                                       *
+*                                                                              *
+*     Just like strcpy except that it takes pascal strings as arguments.       *                                                                               *
+*******************************************************************************/
+static char *StrCpy( char *s1, char *s2 )
+{
+    /*-------------------------------------------------------------------------+
+    | Copy The Length Byte                                                     |
+    +-------------------------------------------------------------------------*/
+    *s1 = *s2;
+
+    /*-------------------------------------------------------------------------+
+    | Copy The Rest.                                                           |
+    +-------------------------------------------------------------------------*/
+    return( (char *)memcpy( s1+1, s2+1, *s1 ) );
+}
+
+
+
+/*******************************************************************************
+* StrCat                                                                       *
+*                                                                              *
+*     Just like strcat except that it takes pascal strings as arguments.       *                                                                               *
+*******************************************************************************/
+static char *StrCat( char *s1, char *s2 )
+{
+    int OriginalLen;
+
+    OriginalLen = *s1;
+    *s1 += *s2;
+
+    return( (char *)memcpy( s1+OriginalLen+1, s2+1, *s2 ) );
+}
+
+//===============================================================================
+
+#if 0
+
+char *wxDirectorySelector(char *message, char *default_path,
+                     char *default_filename, char *default_extension,
+                     char *wildcard, int flags,
+                     wxWindow *parent, int x, int y)
+{	
+	StandardFileReply	rep;
+	SFTypeList typeList = { 'TEXT' };
+	char * name;
+	short numTypes = -1; // all types
+	Str255	p_prompt,p_defname;
+	OSErr err;
+	Point where = {x, y};
+
+	if ((flags == 0) || (flags & wxOPEN))
+	{	
+    	CInfoPBRec	pb;
+    	HookExtra	extra_data;
+    	extra_data.sfr = &rep;
+    	extra_data.wxflags = flags;
+    	
+		CustomGetFile(ffupp, numTypes, typeList,
+			&rep, 
+			rGetFolderDialog, 
+			where,
+			dlghookupp, 
+			NULL, 
+			(short*)NULL,
+			NULL, 
+			(Ptr)&extra_data
+    	);
+	    /*-------------------------------------------------------------------------+
+	    | Ok, now the reply record contains the volume reference number and the    |
+	    | name of the selected folder/file. We need to use PBGetCatInfo to get the |    
+	    | directory ID of the selected folder.                                     |
+	    +-------------------------------------------------------------------------*/
+	    pb.hFileInfo.ioCompletion = NULL;
+	    pb.hFileInfo.ioNamePtr = rep.sfFile.name;
+	    pb.hFileInfo.ioVRefNum = rep.sfFile.vRefNum;
+	    pb.hFileInfo.ioFDirIndex = 0;
+	    pb.hFileInfo.ioDirID = rep.sfFile.parID;
+	
+	    err = PBGetCatInfo( &pb, FALSE);
+	    
+	    /*-------------------------------------------------------------------------+
+	    | Insert your error handler here. I couldn't think of one so I left it     |
+	    | empty. Works fine without it.                                            |
+	    +-------------------------------------------------------------------------*/
+	    if (  err != noErr);
+	    
+	    if (pb.hFileInfo.ioFlAttrib & ioDirMask) {
+	    	/*-------------------------------------------------------------------------+
+	    	| Copy the directory ID of the selected folder to the sfFile field of the  |
+	    	| SFReply record.                                                          |
+	   	 	+-------------------------------------------------------------------------*/
+	    	//rep.sfFile.parID = pb.dirInfo.ioDrDirID;
+	    	rep.sfFile.name[0] += 1;
+	    	rep.sfFile.name[rep.sfFile.name[0]] = ':';
+	    }
+
+	}
+
+#ifdef GUSI
+	char *rtnval = NULL;
+	if (rep.sfGood)
+	{	
+		
+		TFileSpec tFile;
+		char *name;
+		
+		if (rep.sfFile.name)
+		{
+		  tFile = TFileSpec(rep.sfFile.vRefNum,
+		                    rep.sfFile.parID,
+		                    rep.sfFile.name, TRUE);
+		  name = tFile.FullPath(); // destroyed on exit, try copystring
+		  strcpy(wxBuffer, name);
+		  rtnval = wxBuffer;
+		}
+    }
+	return rtnval;
+#elif defined(PYLIB)
+	//int nfullpath(FSSpec *, char *);	/* Generate full path from fsspec */
+	char *rtnval = NULL;
+	if (rep.sfGood)
+	{	
+				
+		if (rep.sfFile.name)
+		{
+		  nfullpath(&rep.sfFile, wxBuffer);
+		  rtnval = wxBuffer;
+		}
+    }
+	return rtnval;
+#else
+	if (rep.sfGood)
+	{	
+		/***** HELL, trying to get the default directory.. any hint?
+		char msg[200];
+				err = ::SetVol(0,CurDirStore);
+				sprintf(msg,"File name:%s Parent-folder ID:%ld VolRefNum:%ld CurDir:%ld -- Err:%d --",
+					rep.sfFile.name,rep.sfFile.parID,rep.sfFile.vRefNum,CurDirStore,err);
+				wxError(msg);
+		******/
+		::p2cstr(rep.sfFile.name); 
+		strcpy(wxBuffer, (char *)rep.sfFile.name);
+		return wxBuffer;	
+	} 
+	return 0;
+#endif 
+}
+
+#endif
+
diff --git a/src/wxmac/src/mac/wx_dltxt.cc b/src/wxmac/src/mac/wx_dltxt.cc
new file mode 100644
index 0000000..e780cfa
--- /dev/null
+++ b/src/wxmac/src/mac/wx_dltxt.cc
@@ -0,0 +1,121 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_dltxt.cc
+// Purpose:	wxDialogText (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_dialg.h"
+#include "wx_frame.h"
+#include "wx_panel.h"
+#include "wx_gdi.h"
+#include "wx_buttn.h"
+#include "wx_types.h"
+#include "wx_utils.h"
+#include "wx_txt.h"
+
+static void wxOkButtonProc(wxButton& button, wxEvent& event);
+static void wxCancelButtonProc(wxButton& button, wxEvent& event);
+
+char* wxGetTextFromUser(char* message, char* caption = "Input text",
+				char* default_value = "", wxFrame* parent = NULL,
+				int x = -1, int y = -1, Bool centre = TRUE);
+
+//-----------------------------------------------------------------------------
+// Pop up a dialog text box
+//-----------------------------------------------------------------------------
+char* wxGetTextFromUser(char* message, char* caption, char* default_value,
+                 wxFrame* parent, int x, int y, Bool centre)
+{
+	wxDialogBox* dialog = new wxDialogBox((wxFrame*)NULL, caption, TRUE, x, y);
+
+//============================================
+	wxPanel* dialogPanel = new wxPanel(dialog);
+	wxFont* theFont = new wxFont(12, wxROMAN, wxITALIC, wxBOLD);
+	dialogPanel->SetLabelFont(theFont);
+	dialogPanel->SetButtonFont(theFont);
+
+//============================================
+	wxPanel* messagePanel = new wxPanel(dialogPanel, -1, -1, -1, -1);
+
+	wxList messageList;
+	wxSplitMessage(message, &messageList, messagePanel);
+	messagePanel->Fit();
+	if (centre)
+	{
+		wxCentreMessage(&messageList);
+	}
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	dialogPanel->NewLine();
+	wxText* textBox = new wxText(dialogPanel, NULL, NULL, default_value,
+						-1, -1, 100, 20, wxBORDER); // WCH: must fix explict width & height
+	textBox->Highlight(0, textBox->GetLastPosition());
+	textBox->SetFocus();
+
+//============================================
+	dialogPanel->NewLine();
+	wxPanel* buttonPanel = new wxPanel(dialogPanel, -1, -1, -1, -1);
+
+	wxButton* ok = NULL;
+	wxButton* cancel = NULL;
+	wxButton* yes = NULL;
+	wxButton* no = NULL;
+
+	ok = new wxButton(buttonPanel, (wxFunction)&wxOkButtonProc, "OK");
+	cancel = new wxButton(buttonPanel, (wxFunction)&wxCancelButtonProc, "Cancel");
+	ok->SetDefault();
+
+	buttonPanel->Fit();
+	//dialogPanel->AdvanceCursor(messagePanel); // WCH: kludge
+
+//============================================
+	
+	dialogPanel->Fit();
+	dialog->Fit();
+
+	messagePanel->Centre(wxHORIZONTAL);
+	buttonPanel->Centre(wxHORIZONTAL);
+
+	dialogPanel->Centre(wxBOTH);
+
+//============================================
+	
+	dialog->ShowModal();
+	int buttonPressed = dialog->GetButtonPressed();
+	char* result = (buttonPressed == wxOK ? textBox->GetValue() : NULL);
+	delete dialog;
+
+//============================================
+
+	return result;
+}
+
+//=============================================================================
+//
+// Dialog button callback procedures
+//
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+static void wxOkButtonProc(wxButton& button, wxEvent& event)
+{
+	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+
+	dialog->SetButtonPressed(wxOK);
+	dialog->Show(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+static void wxCancelButtonProc(wxButton& button, wxEvent& event)
+{
+	wxDialogBox* dialog = (wxDialogBox*) button.GetRootFrame();
+
+	dialog->SetButtonPressed(wxCANCEL);
+	dialog->Show(FALSE);
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_frame.cc b/src/wxmac/src/mac/wx_frame.cc
new file mode 100644
index 0000000..ee44173
--- /dev/null
+++ b/src/wxmac/src/mac/wx_frame.cc
@@ -0,0 +1,876 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_frame.cc
+// Purpose:	wxFrame implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_frame.h"
+#include "wx_menu.h"
+#include "wx_mnuit.h"
+#include "wx_gdi.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_panel.h"
+#include "wx_txt.h"
+#include "wx_area.h"
+#include "wx_screen.h"
+#include "wx_mac_utils.h"
+#include <QuickDraw.h>
+#include <TextEdit.h>
+#include <Menus.h>
+
+extern wxScreen *theScreen;
+static wxMenuBar *empty_menu_bar, *close_menu_bar;
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+
+//-----------------------------------------------------------------------------
+wxFrame::wxFrame // Constructor (for frame window)
+	(
+		wxFrame*	parentFrame,		// this is ignored
+		char*		windowTitle,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbFrame (windowName, wxScreen::gScreenWindow,
+				  x, y, width, height, style)
+{
+	InitDefaults();
+
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+
+	int X = cWindowX;
+	int Y = cWindowY;
+
+	Rect theBoundsRect;
+	::SetRect(&theBoundsRect, X, Y, X + cWindowWidth, Y + cWindowHeight);
+	Str255 theWindowTitle = "\p";
+	if (windowTitle) wxMacCtoPString(windowTitle, theWindowTitle);
+	const Bool WindowIsVisible = TRUE;
+
+	cUserHidden = TRUE;
+
+	int theProcID;
+ 	// GRW adds
+ 	if (!(cStyle & wxMINIMIZE_BOX))		//XXX need wxCLOSE_BOX
+ 		theProcID = movableDBoxProc;
+  	else if (cStyle & wxMAXIMIZE_BOX)
+ 	{
+ 		if (cStyle & wxRESIZE_BORDER)
+ 			theProcID = zoomDocProc;
+ 		else
+ 			theProcID = zoomNoGrow;
+ 	}
+ 	else if (cStyle & wxRESIZE_BORDER)
+ 		theProcID = documentProc;
+ 	else
+ 		theProcID = noGrowDocProc;
+ 	// end of GRW replacement
+
+	const WindowPtr MoveToFront = WindowPtr(-1L);
+	const Bool HasGoAwayBox = TRUE;
+	long theRefCon = (long)this;
+	CWindowPtr theMacWindow = (CWindowPtr)::NewCWindow(NULL, &theBoundsRect, theWindowTitle,
+					!WindowIsVisible, theProcID, MoveToFront, HasGoAwayBox, theRefCon);
+	CheckMemOK(theMacWindow);
+	cMacDC = new wxMacDC(theMacWindow);
+
+  // Calculate the platformArea size
+	Rect theStrucRect = wxMacGetStrucRect();
+	Rect theContRect = wxMacGetContRect();
+	wxMargin platformMargin;
+	platformMargin.SetMargin(theContRect.left - theStrucRect.left, Direction::wxLeft);
+	platformMargin.SetMargin(theContRect.top - theStrucRect.top, Direction::wxTop);
+	platformMargin.SetMargin(theStrucRect.right - theContRect.right, Direction::wxRight);
+	platformMargin.SetMargin(theStrucRect.bottom - theContRect.bottom, Direction::wxBottom);
+	PlatformArea()->SetMargin(platformMargin);
+
+  // The client has the requested window position, not the window: must move
+	SetCurrentDC();
+	wxMargin contentAreaMargin = ContentArea()->Margin(wxScreen::gScreenWindow);
+	int theMacX = contentAreaMargin.Offset(Direction::wxLeft);
+	int theMacY = contentAreaMargin.Offset(Direction::wxTop);
+	MoveWindow((WindowPtr)theMacWindow, theMacX, theMacY, FALSE);
+
+  // The client has the requested window size, not the window: must resize
+	int theMacWidth = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+	int theMacHeight = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+	SizeWindow((WindowPtr)theMacWindow, theMacWidth, theMacHeight, FALSE);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+wxFrame::~wxFrame(void)
+{
+#if WXGARBAGE_COLLECTION_ON
+    if (IsVisible()) 
+		Show(FALSE);
+#endif
+
+	// Kludge needed here:
+	// Bad:  DisposeWindow deletes the mac controls, but not their wxItems.
+	// Good: DestroyChildren deletes the wxItems and their associated mac controls.
+	if (cDialogPanel)
+		cDialogPanel = NULL;
+	DestroyChildren();
+
+	CWindowPtr theMacWindow = cMacDC->macGrafPort();
+	::DisposeWindow((WindowPtr)theMacWindow);
+	delete cMacDC;
+	if (wx_menu_bar)
+		delete wx_menu_bar;
+	if (cControlArea)
+		delete cControlArea;
+	if (cContentArea)
+		delete cContentArea;
+	if (cPlatformArea)
+		delete cPlatformArea;
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxFrame::InitDefaults(void)
+{
+	cWindowTitle[0] = 0; // kludge
+
+	cMaximized = FALSE;
+	cIsModal = FALSE;
+	cBusyCursor = 0;
+	cFocusWindow = NULL;
+	cStatusPanel = NULL;
+	cStatusText = NULL;
+    cDialogPanel = NULL;
+  	cControlArea = new wxArea(this);
+  	cContentArea = new wxArea(this);
+  	cPlatformArea = new wxArea(this);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxArea* wxFrame::PlatformArea(void) { return cPlatformArea; } // mac platform only
+
+//-----------------------------------------------------------------------------
+wxArea* wxFrame::ContentArea(void) { return cContentArea; } // mac platform only
+
+//-----------------------------------------------------------------------------
+wxArea* wxFrame::ControlArea(void) { return cControlArea; } // mac platform only
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+// Note: Can't set width < width of borders + etc.
+// Note: Can't set height < height of borders + statusLine + etc.
+// Note: Mac platform can't set width = width of borders + etc.
+// Note: Mac platform can't set height = height of borders + statusLine + etc.
+//-----------------------------------------------------------------------------
+void wxFrame::DoSetSize(int x, int y, int width, int height)
+{
+ 	// tom: to avoid unnecessary calculations!
+ 	if (x==-1) 
+ 		x= cWindowX;
+ 	if (y==-1) 
+ 		y = cWindowY;
+ 	if (width==-1) 
+ 		width = cWindowWidth;
+ 	if (height==-1) 
+ 		height = cWindowHeight;
+ 	
+	Bool xIsChanged = (x != cWindowX);
+	Bool yIsChanged = (y != cWindowY);
+	Bool widthIsChanged = (width != cWindowWidth);
+	Bool heightIsChanged = (height != cWindowHeight);
+
+ 	int oldWindowX = cWindowX;
+ 	int oldWindowY = cWindowY;
+ 	int oldWindowWidth = cWindowWidth;
+ 	int oldWindowHeight = cWindowHeight;
+ 
+	if (width > cWindowWidth || height > cWindowHeight)
+ 	{
+ 		// Invalidate grow box:
+ 		int oldMacWidth = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+ 		int oldMacHeight = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+ 		Rect oldGrowRect = {oldMacHeight - 15, oldMacWidth - 15, oldMacHeight, oldMacWidth};
+ 		SetCurrentMacDC();
+ 		::InvalRect(&oldGrowRect);
+ 		::EraseRect(&oldGrowRect); /* MATTHEW: [5] */
+ 	}
+
+	int dw, dh;
+
+	dw = cWindowWidth - width;
+	dh = cWindowHeight - height;
+
+    if (xIsChanged) cWindowX = x;
+    if (yIsChanged) cWindowY = y;
+	if (widthIsChanged) cWindowWidth = width;
+	if (heightIsChanged) cWindowHeight = height;
+
+	SetCurrentDC();
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+
+	if (xIsChanged || yIsChanged)
+	{
+		wxMargin contentAreaMargin = ContentArea()->Margin(wxScreen::gScreenWindow);
+		int theMacX = contentAreaMargin.Offset(Direction::wxLeft);
+		int theMacY = contentAreaMargin.Offset(Direction::wxTop);
+		::MoveWindow(theMacWindow, theMacX, theMacY, FALSE);
+	}
+
+	if (widthIsChanged || heightIsChanged)
+	{
+		int theMacWidth = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+		int theMacHeight = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+		::SizeWindow(theMacWindow, theMacWidth, theMacHeight, TRUE);
+ 		// Resizing puts windows into the unzoomed state
+ 		cMaximized = FALSE;
+
+		if (dw > 0 || dh > 0) {
+			// Invalidate new region:
+	 		int w = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+	 		int h = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+	 		Rect r;
+	 		SetCurrentMacDC();
+	 		if (dw) {
+	 			r.top = 0;
+	 			r.bottom = h;
+	 			r.left = w - dw;
+	 			r.right = w;
+		 		::InvalRect(&r);
+	 		}
+	 		if (dh) {
+	 			r.top = h - dw;
+	 			r.bottom = h;
+	 			r.left = 0;
+	 			r.right = w;
+		 		::InvalRect(&r);
+	 		}
+	 	}
+ 		
+ 		if (cStatusPanel) {
+ 		  Rect r = {0, 0, 32000, 32000};
+ 		  cStatusPanel->SetCurrentDC();
+ 		  EraseRect(&r);
+ 		  
+ 		  cStatusPanel->SetSize(0, theMacHeight - cStatusPanel->Height(),
+ 		  	                    theMacWidth - 18, -1);
+ 		  int w, h;
+ 		  cStatusPanel->GetClientSize(&w, &h);
+ 		  cStatusText->SetSize(-1, -1, w, -1);
+
+ 		  cStatusPanel->SetCurrentDC();
+ 		  EraseRect(&r);
+ 		}
+ 		
+ 		// Call OnSize handler
+ 		OnSize(width, height);
+#if 0
+ 		// Don't wait for update event to redraw grow box
+ 		if (cStyle & wxRESIZE_BORDER)
+ 			MacDrawGrowIcon();
+        Paint();
+       if (cStyle & wxRESIZE_BORDER) //tom 
+  			MacDrawGrowIcon();
+#endif
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::Maximize(Bool maximize)
+{
+	if (cMaximized != maximize)
+	{
+		int oldWindowX = cWindowX;
+		int oldWindowY = cWindowY;
+		int oldWindowWidth = cWindowWidth;
+		int oldWindowHeight = cWindowHeight;
+
+		SetCurrentDC();
+		WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+		::EraseRect(&theMacWindow->portRect);
+		::ZoomWindow(theMacWindow, maximize ? inZoomOut : inZoomIn, TRUE);
+		::InvalRect(&theMacWindow->portRect);
+		cMaximized = maximize;
+
+		wxMacRecalcNewSize();
+	
+		int dW = cWindowWidth - oldWindowWidth;
+		int dH = cWindowHeight - oldWindowHeight;
+		int dX = cWindowX - oldWindowX;
+		int dY = cWindowY - oldWindowY;
+		OnWindowDSize(dW, dH, dX, dY);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Mac platform only; internal use only.
+//-----------------------------------------------------------------------------
+void wxFrame::wxMacRecalcNewSize(void)
+{
+	Rect theStrucRect = wxMacGetStrucRect();
+	Rect theContRect = wxMacGetContRect();
+	cWindowX = theStrucRect.left;
+	cWindowY = theStrucRect.top - GetMBarHeight(); // WCH: kludge
+	cWindowWidth = theStrucRect.right - theStrucRect.left;
+	cWindowHeight = theStrucRect.bottom - theStrucRect.top;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Status line methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxFrame::CreateStatusLine(int number, char* name)
+{
+	if (status_line_exists) return;
+
+	nb_status = number;
+	status_line_exists = TRUE;
+	cStatusPanel = new wxPanel(ControlArea(), -1, -1, -1, -1, wxBORDER);
+	cStatusText = new wxText(cStatusPanel, NULL, NULL);
+	cStatusText->Enable(FALSE);
+	cStatusText->SetFont(wxNORMAL_FONT);
+	int statusLineHeight = cStatusText->GetCharHeight() * nb_status;
+	int clientWidth, clientHeight;
+	GetClientSize(&clientWidth, &clientHeight);
+	cStatusText->SetWidthHeight(clientWidth - 18, statusLineHeight);
+	cStatusPanel->Fit();
+#if 1
+ 	// it is a hack to put the line down..
+ 	cStatusPanel->SetSize(0, clientHeight - cStatusPanel->Height(),
+ 		 cStatusPanel->Width() - 18, cStatusPanel->Height()); // tom!!
+ 	// tom: here the Statuspanel is placed over the controlArea!!
+ 	cControlArea->SetMargin(cStatusPanel->Height() + 1, Direction::wxBottom);
+#else
+  	cStatusPanel->SetSize(0, 0, cStatusPanel->Width(), cStatusPanel->Height());
+  	cControlArea->SetMargin(cStatusPanel->Height() + 1, Direction::wxTop);
+#endif
+	// cStatusPanel->SetJustify(Direction::wxLeft);
+
+	wxMargin clientAreaMargin = ClientArea()->Margin(wxScreen::gScreenWindow);
+    clientAreaMargin.SetMargin(clientAreaMargin.Offset(Direction::wxBottom) 
+    	                        + statusLineHeight, 
+ 							   	Direction::wxBottom);
+	ClientArea()->SetMargin(clientAreaMargin);
+	OnSize(cWindowWidth, cWindowHeight);
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::SetStatusText(char* text, int number)
+{
+ 	if (!status_line_exists) 
+ 		return;
+ 	cStatusText->Clear(); // tom: replace, don't append
+  	cStatusText->WriteText(text);
+}
+  
+// tom: perhaps this could be done otherwise:
+//      get statusline from Frame
+//		do statusline->SetEraser
+void wxFrame::SetStatusEraser(wxBrush* b)
+{
+	if (!status_line_exists) 
+	 		return;
+	cStatusPanel->SetEraser(b);
+	cStatusText->SetEraser(b);
+ 	
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Menubar methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxFrame::SetMenuBar(wxMenuBar* menu_bar)
+{
+	// mflatt: if this menu bar is already in use, give up
+    if (menu_bar && menu_bar->menu_bar_frame)
+		return;
+
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	wxMenuBar* oldMenuBar = wx_menu_bar;
+	if (oldMenuBar)
+	{
+		wx_menu_bar = NULL;
+		oldMenuBar->menu_bar_frame = NULL;
+		// must correct each menu->menu_bar and menuItem->menuBar
+	}
+
+  	menu_bar->handle = NULL; // menu_bar->handle is not used
+	if (menu_bar) menu_bar->menu_bar_frame = this;
+	wx_menu_bar = menu_bar;
+
+	if (theMacWindow == ::FrontWindow())
+	{
+		NowFront(TRUE);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::Command(int id)
+{ // Call this to simulate a menu command
+	wxMenuBar* menuBar = GetMenuBar();
+	if (menuBar)
+	{
+		wxMenuItem* item = menuBar->FindItemForId(id);
+		if (item)
+		{
+			wxMenu* theParentMenu = item->ParentMenu();
+			if (theParentMenu)
+			{
+				HiliteMenu(theParentMenu->cMacMenuId); // hilite the menu
+				ProcessCommand(id);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::ProcessCommand(int id)
+{
+	wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_MENU_COMMAND);
+	commandEvent->commandInt = id;
+	commandEvent->eventObject = this;
+
+	if (wxNotifyEvent(*commandEvent, TRUE))
+	{
+		HiliteMenu(0); // unhilite the hilited menu
+		return;
+	}
+
+	wxMenuBar* menuBar = GetMenuBar() ;
+	wxMenuItem* item = menuBar->FindItemForId(id) ;
+	if (item)
+	{
+		if (item->IsCheckable()) item->Check(!item->IsChecked());
+	}
+
+	OnMenuCommand(id);
+	HiliteMenu(0); // unhilite the hilited menu
+
+	wxNotifyEvent(*commandEvent, FALSE);
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::NowFront(Bool flag) // mac platform only
+{
+// Show the menuBar for this frame on becoming active
+	if (flag)
+	{
+		wxWindow::gMouseWindow = NULL; // If the frame changes, force capture off
+	
+		if (wx_menu_bar)
+			wx_menu_bar->Install();
+		else {
+			if (0 && cIsModal) {
+				if (!empty_menu_bar)
+					empty_menu_bar = new wxMenuBar;
+				empty_menu_bar->Install();
+			} else {
+				if (!close_menu_bar) {
+					close_menu_bar = new wxMenuBar;
+					/* When a frame doesn't have a menubar, doMacInMenuBar
+					 assumes that any menulelection is the close item. */
+					wxMenu *file = new wxMenu();
+					file->Append(1, "Close\tCmd+W");
+					close_menu_bar->Append(file, "File");
+				}
+				close_menu_bar->Install();
+			}
+		}
+	}
+}
+
+void wxFrame::ShowAsActive(Bool flag)
+{
+	// Invalidate grow box (appearance changes with window active/inactive)
+ 	SetCurrentDC();
+ 	int theMacWidth = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+ 	int theMacHeight = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+ 	Rect growRect = {theMacHeight - 15, theMacWidth - 15, theMacHeight, theMacWidth};
+ 	// Erase it now if we're becoming inactive
+ 	if (!flag)
+ 		::EraseRect(&growRect);
+ 	::InvalRect(&growRect);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Icon methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+void wxFrame::SetIcon(wxIcon* wx_icon) { }		// not implemented
+
+void wxFrame::Iconize(Bool iconize) { }			// not implemented
+
+Bool wxFrame::Iconized(void) { return FALSE; } 	// not implemented
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Platform methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+WindowPtr wxFrame::macWindow(void)
+{
+	return cMacDC ? (WindowPtr)cMacDC->macGrafPort() : NULL;
+}
+
+//-----------------------------------------------------------------------------
+Bool wxFrame::IsMacWindow(void) { return TRUE; }
+
+//-----------------------------------------------------------------------------
+Bool wxFrame::IsVisible(void)
+{
+	Bool result = FALSE;
+	if (cMacDC)
+	{
+		WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+		result = ((WindowPeek)theMacWindow)->visible;
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::wxMacStartDrawing(GrafPtr& oldPort, int& savePortH, int& savePortV)
+{
+	::GetPort(&oldPort);
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	::SetPort(theMacWindow);
+	savePortH = theMacWindow->portRect.left;
+	savePortV = theMacWindow->portRect.top;
+	::SetOrigin(0, 0);
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::wxMacStopDrawing(GrafPtr oldPort, int savePortH, int savePortV)
+{
+	::SetOrigin(savePortH, savePortV);
+	::SetPort(oldPort);
+}
+
+//-----------------------------------------------------------------------------
+// Mac platform only; internal use only.
+// Based on code in 2nd edition of "Macintosh Programming Secrets"
+// by Scott Knaster and Keith Rollin.
+//-----------------------------------------------------------------------------
+Rect wxFrame::wxMacGetContRect(void)
+{// express client area in screen window c.s.
+	GrafPtr oldPort;
+	int savePortH, savePortV;
+	wxMacStartDrawing(oldPort, savePortH, savePortV);
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	Rect theContRect = theMacWindow->portRect; // client c.s.
+	Point topLeftPt = {0, 0};
+	::LocalToGlobal (&topLeftPt);
+	::OffsetRect(&theContRect, topLeftPt.h, topLeftPt.v); // screen window c.s.
+	wxMacStopDrawing(oldPort, savePortH, savePortV);
+
+	return theContRect; // screen window c.s.
+}
+
+//-----------------------------------------------------------------------------
+// Mac platform only; internal use only.
+// Based on code in 2nd edition of "Macintosh Programming Secrets"
+// by Scott Knaster and Keith Rollin.
+//-----------------------------------------------------------------------------
+Rect wxFrame::wxMacGetStrucRect(void)
+{// express window area in screen window c.s.
+	Rect theStrucRect;
+
+	GrafPtr oldPort;
+	int savePortH, savePortV;
+	wxMacStartDrawing(oldPort, savePortH, savePortV);
+
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+
+	if (((WindowPeek)theMacWindow)->visible)
+	{
+		theStrucRect = (**(WindowPeek(theMacWindow)->strucRgn)).rgnBBox; // screen window c.s.
+	}
+	else
+	{
+		const kOffScreenLocation = 0x4000;
+	
+		Rect theClientRect = theMacWindow->portRect; // client c.s.
+		Point thePosition = {theClientRect.top, theClientRect.left}; // client c.s.
+		::LocalToGlobal(&thePosition); // screen window c.s.
+		::MoveWindow(theMacWindow, thePosition.h, kOffScreenLocation, FALSE);
+		::ShowHide(theMacWindow, TRUE);
+		theStrucRect = (**(WindowPeek(theMacWindow)->strucRgn)).rgnBBox;
+		::ShowHide(theMacWindow, FALSE);
+		::MoveWindow(theMacWindow, thePosition.h, thePosition.v, FALSE);
+		::OffsetRect(&theStrucRect, 0, thePosition.v - kOffScreenLocation); // screen window c.s.
+	}
+
+	wxMacStopDrawing(oldPort, savePortH, savePortV);
+
+	return theStrucRect; // screen window c.s.
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::MacUpdateWindow(void)
+{
+	WindowPtr theMacWindow = macWindow();
+	if (theMacWindow)
+	{
+		SetCurrentDC();
+		::BeginUpdate(theMacWindow);
+		if (!::EmptyRgn(theMacWindow->visRgn))
+		{
+ 			// Erase update region
+ 			// ::EraseRect(&theMacWindow->portRect);
+
+ 			// Can't use UpdateControls since each control has it's own coordinate system
+ 			//		::UpdateControls(theMacWindow, theMacWindow->visRgn);
+
+			Paint();
+
+ 			// Draw the grow box
+ 			if (cStyle & wxRESIZE_BORDER)
+ 				MacDrawGrowIcon();
+		}
+		::EndUpdate(theMacWindow);
+	}
+}
+
+ //-----------------------------------------------------------------------------
+ void wxFrame::MacDrawGrowIcon(void)
+ {
+ 	SetCurrentMacDCNoMargin();
+ 	// Save the clipping region
+ 	RgnHandle saveClip = NewRgn();
+ 	CheckMemOK(saveClip);
+	::GetClip(saveClip);
+ 	// Compute the bounding rect of the grow icon
+ 	int theMacWidth = cWindowWidth - PlatformArea()->Margin().Offset(Direction::wxHorizontal);
+ 	int theMacHeight = cWindowHeight - PlatformArea()->Margin().Offset(Direction::wxVertical);
+ 	Rect growRect = {theMacHeight - 15, theMacWidth - 15, theMacHeight, theMacWidth};
+ 	// Avoid drawing scrollbar outlines
+ 	::ClipRect(&growRect);
+ 	// Draw it
+ 	WindowPtr theMacWindow = macWindow();
+ 	RGBColor fore, back;
+ 	::GetForeColor(&fore);
+ 	::GetBackColor(&back);
+ 	::ForeColor(blackColor);
+ 	::BackColor(whiteColor);
+ 	::EraseRect(&growRect);
+ 	::DrawGrowIcon(theMacWindow);
+ 	// Restore the clipping region
+ 	::SetClip(saveClip);
+ 	::DisposeRgn(saveClip);
+ 	::RGBForeColor(&fore);
+ 	::RGBBackColor(&back);
+ }
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+char* wxFrame::GetTitle(void) // WCH: return type should be "const char*"
+{
+	Str255		theTitle;
+
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	::GetWTitle(theMacWindow, theTitle);
+	wxMacPtoCString(theTitle, cWindowTitle);
+	return cWindowTitle;
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::SetTitle(char* title)
+{
+	wxMacString theMacString = title;
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	::SetWTitle(theMacWindow, theMacString());
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::Show(Bool show)
+{
+	if (show == IsVisible()) {
+	  if (show)
+	    ::SelectWindow((WindowPtr)cMacDC->macGrafPort());
+	  return;
+	}
+	
+	cUserHidden = !show;
+
+	if (window_parent)
+	  window_parent->GetChildren()->Show(this, show);
+	if (cParentArea)
+	  cParentArea->Windows()->Show(this, show);
+
+#if 0
+	if (!show && IsModal())
+		MakeModal(FALSE);
+#endif
+
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	if (show) {
+#if __WXGARBAGE_COLLECTION_ON
+	   wxTopLevelWindows(ContextWindow())->Append(this);
+#else
+		wxTopLevelWindows(ContextWindow())->Show(this, show);
+#endif
+		::ShowWindow(theMacWindow);
+ 		::SelectWindow(theMacWindow); 
+ 		if (cMacDC->currentUser() == this)
+			/* b/c may be optimized for hidden: */
+			cMacDC->setCurrentUser(NULL);
+	} else {
+#if __WXGARBAGE_COLLECTION_ON
+        wxTopLevelWindows(ContextWindow())->DeleteObject(this);
+#else
+		wxTopLevelWindows(ContextWindow())->Show(this, show);
+#endif
+		::HideWindow(theMacWindow);
+    }
+}
+
+//-----------------------------------------------------------------------------
+Bool wxFrame::IsFrontWindow(void)
+{
+	WindowPtr theMacWindow = macWindow();
+	return (theMacWindow ? theMacWindow == ::FrontWindow() : FALSE);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxFrame::IsModal(void) { return cIsModal; } //cjc, mflatt
+
+//-----------------------------------------------------------------------------
+void wxFrame::MakeModal(Bool modal)
+{
+	cIsModal = modal;
+	// wxbWindow::MakeModal(modal);
+}
+
+//-----------------------------------------------------------------------------
+wxWindow* wxFrame::GetFocusWindow(void) { return cFocusWindow; }
+
+//-----------------------------------------------------------------------------
+void wxFrame::SetFocusWindow(wxWindow* window)
+{
+    if (window != cFocusWindow)
+    {
+	    if (cFocusWindow) cFocusWindow->OnKillFocus();
+	    cFocusWindow = window;
+	    if (window) window->OnSetFocus();
+    }
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::OnActivate(Bool active)
+{
+	if (!cFocusWindow && children) {
+		wxChildNode *node = children->First();
+		while (node) {
+			wxWindow *win = (wxWindow *)node->Data();
+			if (win->WantsFocus() && win->CanAcceptEvent()) {
+				cFocusWindow = win;
+				break;
+			}
+			node = node->Next();
+		}
+	}
+
+	if (cFocusWindow && this != cFocusWindow)
+    {
+		if (active)
+		  cFocusWindow->OnSetFocus();
+		else
+		  cFocusWindow->OnKillFocus();
+	}
+
+	wxWindow::OnActivate(active);
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::LoadAccelerators(char* table) { } // Not Applicable for Mac platform
+
+//-----------------------------------------------------------------------------
+void wxFrame::Paint(void)
+{
+	SetCurrentDC();
+	RgnHandle rgn, subrgn;
+	if (rgn = NewRgn()) {
+		if (subrgn = NewRgn()) {
+			SetRectRgn(rgn, 0, 0, cWindowWidth, cWindowHeight);
+			AddWhiteRgn(subrgn);
+			DiffRgn(rgn, subrgn, rgn);
+			EraseRgn(rgn);
+			RGBColor save;
+			GetForeColor(&save);
+			ForeColor(whiteColor);
+			PaintRgn(subrgn);
+			RGBForeColor(&save);
+			DisposeRgn(subrgn);
+		}
+		DisposeRgn(subrgn);
+	}
+	wxWindow::Paint();
+	if (cStatusPanel) {
+	  int statusLineHeight = cStatusPanel->Height();
+	  wxMargin clientAreaMargin = ClientArea()->Margin(wxScreen::gScreenWindow);
+	  clientAreaMargin.SetMargin(clientAreaMargin.Offset(Direction::wxBottom) 
+    	                         - statusLineHeight, 
+ 							   	 Direction::wxBottom);
+	  ClientArea()->SetMargin(clientAreaMargin);
+	  cStatusPanel->Paint();
+	  clientAreaMargin.SetMargin(clientAreaMargin.Offset(Direction::wxBottom) 
+    	                         + statusLineHeight, 
+ 							   	 Direction::wxBottom);
+ 	  ClientArea()->SetMargin(clientAreaMargin);
+    }
+ 	// SetCurrentDC();
+ 	// If the right type of Window: MacDrawGrowIcon();
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::OnChar(wxKeyEvent& event) // mac platform only
+{
+	if (cFocusWindow)
+	{
+		if (cFocusWindow != this) // kludge to prevent infinite loop
+			cFocusWindow->OnChar(event);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxFrame::Enable(Bool enable)
+{
+	wxWindow::Enable(enable);
+	// Enable/disbale menubar
+	if (wx_menu_bar)
+		wx_menu_bar->Install();	
+}
+
+void wxFrame::ChangeToGray(Bool gray)
+{
+  ChildrenInternalGray(gray);
+  wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_gauge.cc b/src/wxmac/src/mac/wx_gauge.cc
new file mode 100644
index 0000000..d2a5389
--- /dev/null
+++ b/src/wxmac/src/mac/wx_gauge.cc
@@ -0,0 +1,257 @@
+/*
+ * File:	wx_slidr.cc
+ * Purpose:	Panel item slider implementation (Macintosh version)
+ * Author:	Cecil Coupe
+ * Created:	1995
+ * Updated:	
+ * Copyright:	(c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+ */
+
+static const char sccsid[] = "%W% %G%";
+
+
+
+#include <iostream.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "common.h"
+#include "wx_mgstr.h"
+#include "wx_utils.h"
+#include "wx_gauge.h"
+
+
+#define MEANING_CHARACTER	'0'
+
+
+// Slider
+/* 
+	For wxMac a wxSlider contains
+	1. A scroll control (horizontal)
+	2. A wxLabelArea for the Label/Title
+	3. a Rect for displaying the current value
+
+*/
+
+#define KDEFAULTW  60	// number pixels wide for a default scroll control
+#define KGAUGEH    12	
+#define VSP			2	// space between scrollbar and value
+#define HSP			2	
+// Because I never get this right and t,l,b,r makes sense to me - CJC
+//
+#define SetBounds(rect, top, left, bottom, right) ::SetRect(rect, left, top, right, bottom)
+
+wxGauge::wxGauge()
+{
+  /* Bad */
+}
+
+wxGauge::wxGauge(wxPanel *panel, char *label, int _range, int x, int y,
+           int width, int height, long style, char *name) :
+  wxbGauge(panel, label, _range, x, y, width, height, style, name)
+{
+	SetCurrentDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+
+	float fWidth;
+	float fHeight;
+	float fDescent;
+	float fLeading;
+	int	lblh=0;
+	int lblw=0;
+	
+	range = _range;
+	value = 0;
+	if (range < 1)
+		range = 1;
+
+	if (label)
+      label = wxItemStripLabel(label);
+	
+	if (label) {
+		GetTextExtent(label, &fWidth, &fHeight, &fDescent, &fLeading, labelFont);
+		lblh = fHeight;
+		lblw = fWidth;
+	}
+
+	valueRect.top = valueRect.left = 0;
+	
+	int adjust = 0;
+	if (style & wxVERTICAL) {
+		if (height < 0)
+			cWindowHeight = KDEFAULTW + ((labelPosition == wxVERTICAL) ? lblh : 0);
+		else
+			cWindowHeight = height;
+		cWindowWidth = KGAUGEH + HSP + ((labelPosition == wxVERTICAL) ? 0 : lblw + HSP);
+		
+		valueRect.right = KGAUGEH;
+		valueRect.bottom = cWindowHeight - ((labelPosition == wxVERTICAL) ? lblh : 0);
+	} else {
+		if (width < 0)
+			cWindowWidth = KDEFAULTW + ((labelPosition == wxHORIZONTAL) ? lblw : 0);
+		else
+			cWindowWidth = width;
+		cWindowHeight = KGAUGEH + VSP + ((labelPosition == wxVERTICAL) ? lblh + VSP : 0);
+		
+		valueRect.right = cWindowWidth - ((labelPosition == wxHORIZONTAL) ? lblw : 0);
+		valueRect.bottom = KGAUGEH;
+	}
+
+	if (label)
+	{
+		cTitle = new wxLabelArea(this, label, labelFont,
+				labelPosition == wxVERTICAL ? Direction::wxTop : Direction::wxLeft);
+	} else
+		cTitle = NULL;
+		
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+// ------------ Destructor ----------------------------------------
+wxGauge::~wxGauge(void)
+{
+	 delete cTitle;	// Special care needed to delete Areas
+}
+
+
+//------------ Event Handling --------------------------------------
+void wxGauge::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+
+	FrameRect(&valueRect);
+
+	Rect r, w;
+	r = valueRect;
+	InsetRect(&r, 1, 1);
+	w = r;
+	long d;
+	if (windowStyle & wxVERTICAL) 
+		d = (valueRect.bottom - valueRect.top);
+	else
+		d = (valueRect.right - valueRect.left);
+	if (value < range)
+		d = (d * value) / range;
+	if (windowStyle & wxVERTICAL) {
+		r.top = r.bottom - d;
+		w.bottom = r.top;
+	} else {
+		r.right = r.left + d;
+		w.left = r.right;
+	}
+
+	RGBColor save;
+	GetForeColor(&save);
+
+	if (value) {
+		if (cColour) {
+			RGBColor c;
+			c.red = 66 << 8;
+			c.green = 66 << 8;
+			c.blue = 66 << 8;
+			RGBForeColor(&c);
+		}
+		PaintRect(&r);
+	}
+	
+	if (value < range) {
+		if (cColour) {
+			RGBColor c;
+			c.red = 204 << 8;
+			c.green = 204 << 8;
+			c.blue = 0xFFFF;
+			RGBForeColor(&c);
+		} else
+			ForeColor(whiteColor);
+		PaintRect(&w);
+	}
+
+	RGBForeColor(&save);
+
+	wxWindow::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxGauge::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	cTitle->DoShow(show);
+
+	wxWindow::DoShow(show);
+}
+
+void wxGauge::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+	SetCurrentDC();
+
+	if (dW || dH)
+	{	
+		int clientWidth = ClientArea()->Width();
+		int clientHeight= ClientArea()->Height();
+
+		int vwid = valueRect.right - valueRect.left;
+		int vhgt = valueRect.bottom - valueRect.top;
+			
+		if (windowStyle & wxVERTICAL) {
+			// the wid can't change
+			valueRect.left = (clientWidth - vwid) / 2;
+			valueRect.right = valueRect.left + vwid;
+			valueRect.bottom = clientHeight;
+		} else {
+			// the hgt can't change
+			valueRect.top = (clientHeight - vhgt) / 2;
+			valueRect.bottom = valueRect.top + vhgt;
+			valueRect.right = clientWidth;
+		}
+	}
+
+	if (dX || dY)
+	{	// Changing the position
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put newViewRect at (0, 0)
+	}
+}
+
+
+// --------------------- Client API ---------------------
+
+void wxGauge::SetValue(int v)
+{
+	value = v;
+	if (value > range)
+		value = range;
+	else if (value < 0)
+		value = 0;
+	Paint();
+}
+
+void wxGauge::SetRange(int v)
+{
+	range = v;
+	if (range < 1)
+		range = 1;
+	if (value > range)
+		value = range;
+	Paint();
+}
+
+char* wxGauge::GetLabel(void)
+{
+	return (cTitle ? cTitle->GetLabel() : NULL);
+}
+
+void wxGauge::SetLabel(char *label)
+{
+	if (cTitle) cTitle->SetLabel(label);
+	
+}
+
+void wxGauge::ChangeToGray(Bool gray)
+{
+  if (cTitle)
+	((wxLabelArea *)cTitle)->GetMessage()->InternalGray(gray);
+  wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_gdi.cc b/src/wxmac/src/mac/wx_gdi.cc
new file mode 100644
index 0000000..2bada22
--- /dev/null
+++ b/src/wxmac/src/mac/wx_gdi.cc
@@ -0,0 +1,1008 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_gdi.cc (Macintosh version)
+// Purpose:	GDI (Graphics Device Interface) objects and functions
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+#include "common.h"
+#include "wx_list.h"
+#include "wx_utils.h"
+#include "wx_gdi.h"
+#include "wx_dcmem.h"
+#include <Strings.h>
+#include <Resources.h>
+#include <QDOffscreen.h>
+#if USE_XPM_IN_MAC
+#define FOR_MAC
+#include "xpm34.h"
+#endif
+#if USE_IMAGE_LOADING_IN_MAC
+#include "wx_image.h"
+#endif
+CGrafPtr wxFont::gMacFontGrafPort = NULL; // mac platform only
+
+wxGDIList   *wxTheIconList = NULL;
+wxGDIList   *wxTheCursorList = NULL;
+wxGDIList   *wxTheColourList = NULL;
+
+void *XpmMalloc(size_t size)
+{
+  return new char[size];
+}
+
+void *XpmMallocA(size_t size)
+{
+  return new WXGC_ATOMIC char[size];
+}
+
+static void *DoXpmRealloc(void *(*alloc)(size_t), void *ptr, size_t size)
+{
+  void *naya;
+  size_t osize;
+  
+  naya = alloc(size);
+  
+  osize = GC_size(ptr);
+  if (size < osize)
+    osize = size;
+    
+  memcpy(naya, ptr, osize);
+  
+  return naya;
+}
+
+void *XpmRealloc(void *ptr, size_t size)
+{
+  return DoXpmRealloc(XpmMalloc, ptr, size);
+}
+
+void *XpmReallocA(void *ptr, size_t size)
+{
+  return DoXpmRealloc(XpmMallocA, ptr, size);
+}
+
+void XpmFree(void *)
+{
+	/* Do nothing */
+}
+
+#ifdef wx_xview
+
+/* These cursors courtesy of xfig
+ */
+
+static unsigned short    bull_cursor_array[16] = {
+    0x0F00, 0x30C0, 0x4020, 0x4020, 0x8010, 0x8610, 0x8610, 0x8010,
+    0x4020, 0x4020, 0x30C0, 0x0F00, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+static unsigned short    char_cursor_data[16] = {
+    0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
+    0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
+};
+
+static unsigned short    crosshair_cursor_data[16] = {
+    0x1000, 0x1000, 0x1000, 0xFE00, 0x1000, 0x1000, 0x1000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+static unsigned short    magnifier_cursor_array[16] = {
+    0x0F80, 0x3060, 0x4010, 0x4010, 0x8008, 0x8008, 0x8008, 0x8008,
+    0x8008, 0x4010, 0x4010, 0x3078, 0x0F9C, 0x000E, 0x0007, 0x0003,
+};
+
+static unsigned short    pencil_cursor_array[16] = {
+    0x0000, 0x0018, 0x0024, 0x0075, 0x009B, 0x0117, 0x022E, 0x045C,
+    0x08B8, 0x1170, 0x22E0, 0x25C0, 0x7B80, 0x6700, 0x8600, 0x0800,
+};
+
+static unsigned short    vbar_cursor_array[16] = {
+    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+};
+
+static unsigned short hand_cursor_array[] =
+{
+  0x0C00,0x1200,0x1200,0x1380,0x1240,0x7270,0x9248,0x924E,
+  0x9249,0x9249,0x9009,0x8001,0x4002,0x4002,0x2004,0x2004
+};
+#endif
+
+//-----------------------------------------------------------------------------
+wxFont::wxFont(void)
+{
+	Create(10, wxDEFAULT, 
+			wxDEFAULT, 
+			wxNORMAL, wxNORMAL, FALSE);
+}
+
+//-----------------------------------------------------------------------------
+// Constructor for a font. Note that the real construction is done
+// in wxDC::SetFont, when information is available about scaling etc.
+//-----------------------------------------------------------------------------
+wxFont::wxFont(int PointSize, int FontOrFamilyId, int Style, int Weight, Bool Underlined)
+{
+	Create(PointSize, FontOrFamilyId, 
+			wxTheFontNameDirectory.GetFamily(FontOrFamilyId), 
+			Style, Weight, Underlined);
+}
+
+wxFont::wxFont(int PointSize, const char *Face, int Family, int Style, int Weight, 
+	 	         Bool underlined)
+{
+	int id = wxTheFontNameDirectory.FindOrCreateFontId(Face, Family);
+	int fam = wxTheFontNameDirectory.GetFamily(id);
+	
+	Create(PointSize, id, fam, Style, Weight, underlined);
+}
+
+void wxFont::Create(int PointSize, int Font, int Family, int Style, int Weight, 
+	 			Bool Underlined)
+{
+	fontid = Font;
+	family = Family;
+	style = Style;
+	weight = Weight;
+	point_size = PointSize;
+	underlined = Underlined;
+
+	char *name = wxTheFontNameDirectory.GetScreenName(fontid, Weight, Style);
+	Str255 buffer;
+
+	if (!strcmp(name, "systemfont"))
+		macFontId = GetSysFont();
+	else if (!strcmp(name, "applicationfont"))
+		macFontId = GetAppFont();
+	else {
+		strcpy((char *)buffer, name);
+		C2PStr((char *)buffer);
+		::GetFNum((ConstStr255Param)buffer, &macFontId);
+	}
+
+#if !WXGARBAGE_COLLECTION_ON
+	wxTheFontList->Append(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxFont::~wxFont()
+{
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheFontList->DeleteObject(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+float wxFont::GetCharHeight(void)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	::SetPort(oldPort);
+	return fontInfo.ascent + fontInfo.descent + fontInfo.leading;
+}
+
+//-----------------------------------------------------------------------------
+float wxFont::GetCharWidth(void)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	::SetPort(oldPort);
+	return fontInfo.widMax;
+}
+
+//-----------------------------------------------------------------------------
+void wxFont::GetTextExtent(char* string, float* x, float* y,
+							float* descent, float* externalLeading, Bool use16)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	*x = TextWidth(string, 0, strlen(string)); // width
+#if 0	// CJC, mflatt
+	*x += 5; // WCH: kludge, to handle italic font and word wrapping at end of line
+#endif
+	*y = fontInfo.ascent + fontInfo.descent + fontInfo.leading; // height
+	if (descent) *descent = fontInfo.descent;
+	if (externalLeading) *externalLeading = fontInfo.leading;
+	::SetPort(oldPort);
+}
+
+//-----------------------------------------------------------------------------
+int wxFont::GetMacFontNum(void) // mac platform only
+{
+	return macFontId;
+}
+
+//-----------------------------------------------------------------------------
+Style wxFont::GetMacFontStyle(void) // mac platform only
+{
+	Style result = 0;
+	if (weight == wxBOLD)
+		 result |= bold;
+	if (style == wxITALIC || style == wxSLANT) 
+		result |= italic;
+	if (underlined) 
+		result |= underline;
+	return result;
+}
+
+
+
+/*
+ * Colour map
+ *
+ */
+
+//-----------------------------------------------------------------------------
+wxColourMap::wxColourMap(void)
+{
+#ifdef wx_x
+  cmap = 0;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxColourMap::~wxColourMap(void)
+{
+}
+
+
+// Pens
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(void)
+{
+  colour = NULL;
+  stipple = NULL ;
+  style = wxSOLID;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+  width = 1;
+
+#if !WXGARBAGE_COLLECTION_ON
+  wxThePenList->AddPen(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxPen::~wxPen()
+{
+#if !WXGARBAGE_COLLECTION_ON
+  wxThePenList->RemovePen(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(wxColour& col, int Width, int Style):
+  wxbPen(col, Width, Style)
+{
+  colour = col;
+  stipple = NULL ;
+  width = Width;
+  if (width < 1)
+  	width = 1;
+  style = Style;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+#if !WXGARBAGE_COLLECTION_ON
+  wxThePenList->AddPen(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(char *col, int Width, int Style):
+  wxbPen(col, Width, Style)
+{
+  SetColour(col);
+  stipple = NULL ;
+  width = Width;
+  if (width < 1)
+  	width = 1;
+  style = Style;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+
+#if !WXGARBAGE_COLLECTION_ON
+  wxThePenList->AddPen(this);
+#endif
+}
+
+// Brushes
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(void)
+{
+  colour = NULL;
+  style = wxSOLID;
+  stipple = NULL ;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheBrushList->AddBrush(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::~wxBrush()
+{
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheBrushList->RemoveBrush(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(wxColour& col, int Style):
+  wxbBrush(col, Style)
+{
+  SetColour(col);
+  style = Style;
+  stipple = NULL ;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheBrushList->AddBrush(this);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(char *col, int Style):
+  wxbBrush(col, Style)
+{
+  SetColour(col);
+  style = Style;
+  stipple = NULL ;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheBrushList->AddBrush(this);
+#endif
+}
+
+// Icons - Remember a wxIcon is for minimized windows which the
+// Mac can't do.
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(char bits[], int Width, int Height)
+: wxBitmap(bits, Width, Height)
+{
+  __type = wxTYPE_ICON;
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(void) : wxBitmap()
+{
+  __type = wxTYPE_ICON;
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(char *icon_file, int file_format)
+: wxBitmap(icon_file, file_format)
+{
+  __type = wxTYPE_ICON;
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::~wxIcon(void)
+{
+}
+
+// Cursors
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(void)
+{
+  __type = wxTYPE_CURSOR;
+  cMacCursor = NULL;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheCursorList->Append(this) ;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(char bits[], int width, int height, int depth)
+{
+  __type = wxTYPE_CURSOR;
+  cMacCursor = NULL;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheCursorList->Append(this) ;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(char *cursor_file)
+{
+  __type = wxTYPE_CURSOR;
+  cMacCursor = NULL;
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheCursorList->Append(this) ;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Cursors by stock number
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(int cursor_type)
+{
+  __type = wxTYPE_CURSOR;
+  cMacCursor = NULL;
+
+  switch (cursor_type)
+  {
+    case wxCURSOR_WAIT:
+    case wxCURSOR_WATCH:
+    {
+	  cMacCursor = GetCursor(watchCursor);
+      break;
+    }
+    case wxCURSOR_CROSS:
+    {
+	  cMacCursor = GetCursor(crossCursor);
+      break;
+    }
+    case wxCURSOR_CHAR:
+    {
+      break;
+    }
+    case wxCURSOR_HAND:
+    {
+      break;
+    }
+    case wxCURSOR_BULLSEYE:
+    {
+      break;
+    }
+    case wxCURSOR_PENCIL:
+    {
+      break;
+    }
+    case wxCURSOR_MAGNIFIER:
+    {
+     break;
+    }
+    case wxCURSOR_IBEAM:
+    {
+	  cMacCursor = GetCursor(iBeamCursor);
+      break;
+    }
+    case wxCURSOR_NO_ENTRY:
+    {
+      break;
+    }
+
+    case wxCURSOR_LEFT_BUTTON:
+    {
+      break;
+    }
+    case wxCURSOR_RIGHT_BUTTON:
+    {
+      break;
+    }
+    case wxCURSOR_MIDDLE_BUTTON:
+    {
+      break;
+    }
+    case wxCURSOR_QUESTION_ARROW:
+    {
+      break;
+    }
+    case wxCURSOR_SIZING:
+    {
+      break;
+    }
+    case wxCURSOR_SPRAYCAN:
+    {
+      break;
+    }
+    case wxCURSOR_PAINT_BRUSH:
+    {
+      break;
+    }
+    case wxCURSOR_SIZENWSE:
+    case wxCURSOR_SIZENESW:
+    {
+      break;
+    }
+    case wxCURSOR_SIZEWE:
+    {
+      break;
+    }
+    case wxCURSOR_SIZENS:
+    {
+      break;
+    }
+    case wxCURSOR_POINT_LEFT:
+    {
+      break;
+    }
+    case wxCURSOR_POINT_RIGHT:
+    {
+      break;
+    }
+    default:
+    case wxCURSOR_ARROW:
+    {
+      break;
+    }
+    case wxCURSOR_BLANK:
+    {
+      break ;
+    }
+  }
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheCursorList->Append(this) ;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::~wxCursor(void)
+{
+#if !WXGARBAGE_COLLECTION_ON
+  wxTheCursorList->DeleteObject(this) ;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+Bool wxCursor::Ok(void)
+{
+  return !!cMacCursor;
+}
+
+//-----------------------------------------------------------------------------
+// Global cursor setting
+//-----------------------------------------------------------------------------
+void wxSetCursor(wxCursor *cursor)
+{
+  static wxCursor *curCursor;
+  
+  if (cursor != curCursor) {
+	  if (cursor->cMacCursor)
+		::SetCursor(*(cursor->cMacCursor));
+	  else
+	 	::SetCursor(&(qd.arrow));
+	 curCursor = cursor;
+  }
+  wxFlushEvents();
+}
+
+// Misc. functions
+
+//-----------------------------------------------------------------------------
+// Return TRUE if we have a colour display
+//-----------------------------------------------------------------------------
+Bool wxColourDisplay(void)
+{
+	return wxDisplayDepth() > 1;
+}
+
+//-----------------------------------------------------------------------------
+// Returns depth of screen
+//-----------------------------------------------------------------------------
+int wxDisplayDepth(void)
+{
+#if USE_XPM_IN_MAC
+	return XDefaultDepth(NULL, NULL); // Args are not used for Mac
+#else
+    int d, b;
+	PixMapHandle pmap;
+	GDHandle dev;
+	dev = GetGDevice();
+	pmap = (**dev).gdPMap;
+	b = (**pmap).pixelSize;
+    return (b);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Get size of display
+//-----------------------------------------------------------------------------
+void wxDisplaySize(int *width, int *height)
+{
+	*width = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
+	*height = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top - LMGetMBarHeight();
+}
+
+//------------------ BitMaps ------------------------------------------
+/*
+	on the Mac, the wxBitMap needs to be a structure that will allow
+	us to redraw. Externally a wxBitmap is a picture (file or resource).
+	Internally, its an offscreen GWorld (and its pixmap).
+
+	We will have to extend the API so that parts of wxWindow (like
+	wx_buttn.cc) can draw a wxBitMap.
+
+	Also wxDC::DrawIcon might want to use this code.
+
+	Warning - might leak memory. 
+    wxTheBitmapList (is it needed?)
+*/
+wxBitmap::wxBitmap(void)
+{
+  __type = wxTYPE_BITMAP;
+  ok = FALSE;
+  width = 0;
+  height = 0;
+  depth = 0;
+  x_pixmap = NULL;
+  selectedInto = NULL;
+  WXGC_IGNORE(selectedInto);
+  // wxTheBitmapList->Append(this); 
+  //Create() should be used to add this to the list
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(char bits[], int the_width, int the_height, int no_bits)
+{
+  __type = wxTYPE_BITMAP;
+  depth = no_bits;
+  width = the_width;
+  height = the_height;
+  //Rect bounds = {0, 0, the_height, the_width};
+  GDHandle savegd;
+  CGrafPtr saveport;
+  GetGWorld(&saveport, &savegd);
+  Create(the_width, the_height, no_bits);
+  if (ok) {
+  	SetGWorld(x_pixmap, 0);
+  	int i, j;
+  	char byte;
+  	int bit1;
+	RGBColor	cpix;
+	// look in contrib/wxwxpm/simx.c for a clue on finishing this 
+  	switch (no_bits) {
+	  case 0:
+	  case 1:
+		GetForeColor(&cpix);
+		for (i = 0; i < the_height; i++) {
+			for (j = 0; j < the_width; i++) {
+				byte = bits[j,i];
+				for (int k = 0; k < 8; k++) {
+					if (byte & 1) {			
+						::SetCPixel(j, i, &cpix);
+					}
+					byte = byte >> 1;
+				}
+			}
+		}
+		break;
+	  case 8:
+		for (i = 0; i < the_height; i++) {
+			for (j = 0; j < the_width; i++) {
+				// convert byte to RGB - how ? FIXME				
+				::SetCPixel(j, i, &cpix);
+			}
+		}
+		break;
+	  case 16:
+	  case 24:
+	  case 32:
+		break;
+	} // end switch
+    SetGWorld(saveport, savegd);
+  }
+  //ok = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(char *bitmap_file, long flags)
+{
+	__type = wxTYPE_BITMAP;
+    selectedInto = NULL;
+    WXGC_IGNORE(selectedInto);
+	if (flags & wxBITMAP_TYPE_PICT_RESOURCE)	{ 
+		// look for a 'PICT' resource with the given name
+		Str255 resname;
+		PicHandle	h;
+		ResType	thetype;
+		strcpy((char *)resname, bitmap_file);
+		C2PStr((char *)resname);
+		h = (PicHandle)::GetNamedResource('PICT', resname);
+		if (h) {
+			depth =  wxDisplayDepth();
+			width = (*h)->picFrame.right;
+			height = (*h)->picFrame.bottom;
+			GDHandle savegd;
+			CGrafPtr saveport;
+			GetGWorld(&saveport, &savegd);
+			Rect bounds = {0, 0, height, width};
+			Create(width, height, depth);
+			SetGWorld(x_pixmap, 0);
+			DrawPicture( h, &bounds);
+	  		::ReleaseResource((Handle)h);
+			::SetGWorld(saveport, savegd);
+			return;
+		}
+	}
+	// we also get here if we asked for a resource but it wasn't found
+	x_pixmap = NULL;
+	if (LoadFile(bitmap_file, flags) == FALSE) {
+		char t[200];
+		sprintf(t, "Could not load Bitmap: %s", bitmap_file);
+		// mflatt: This is not a fatal error
+		// wxFatalError(t);
+		// wxError(t);
+	}
+	
+}
+
+//-----------------------------------------------------------------------------
+// Create a new bitmap of a given size and depth
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(int w, int h, int d)
+{
+	Create(w, h, d);
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::~wxBitmap(void)
+{
+#if !WXGARBAGE_COLLECTION_ON
+	wxTheBitmapList->DeleteObject(this);
+#endif
+	
+	if (selectedInto)
+		selectedInto->SelectObject(NULL);
+
+	if (x_pixmap)
+		// Louis Birk Suggests:
+#ifdef LkB
+		::DisposeCTable((*x_pixmap->portPixMap)->pmTable);
+		(*x_pixmap->portPixMap)->pmTable = 0;
+		::DisposePtr((Ptr) (*x_pixmap->portPixMap)->baseAddr);
+		(*x_pixmap->portPixMap)->baseAddr = 0;
+		// End of birk@moonface.com mods
+#else
+		DisposeGWorld(x_pixmap);
+#endif
+}
+
+Bool wxBitmap::Create(int wid, int hgt, int deep)
+{
+  __type = wxTYPE_BITMAP;
+  width = wid;
+  height = hgt;
+  depth = deep;
+  selectedInto = NULL;
+  WXGC_IGNORE(selectedInto);
+  Rect bounds = {0, 0, height, width};
+  // Looks like we need to build a offscreen GWorld to draw the Picture in
+  GDHandle savegw;
+  CGrafPtr saveport;
+  GetGWorld(&saveport, &savegw);
+  QDErr err;
+  GWorldPtr	newGWorld;
+  err = NewGWorld(&newGWorld, 0, &bounds, NULL, NULL, noNewDevice);
+  if (err == noErr) {
+	  SetGWorld(newGWorld, 0);
+	  if (depth < 1)
+	    depth = wxDisplayDepth();
+	  ::EraseRect(&bounds);
+	  ok = TRUE;
+	  x_pixmap = newGWorld;
+	  SetGWorld(saveport, savegw);
+#if !WXGARBAGE_COLLECTION_ON
+	  wxTheBitmapList->Append(this);  
+#endif
+  }
+  else {				// matt flatt suggests 
+	ok = FALSE;
+	x_pixmap = NULL;
+  }
+  return ok;
+}
+
+#if USE_XPM_IN_MAC
+// Load a bitmap with xpm data (compiled in)
+wxBitmap::wxBitmap(char **data, wxItem *anItem)
+{
+  __type = wxTYPE_BITMAP;
+  width = 0;
+  height = 0;
+  depth = 0;
+  freePixmap = FALSE;
+  XImage	*ximage;
+  XpmAttributes xpmAttr;
+
+  ok = FALSE;
+
+  xpmAttr.valuemask = XpmReturnInfos;	/* nothing yet, but get infos back */
+  int  ErrorStatus = XpmCreateImageFromData(NULL,	// don't have a Display dpy
+					 data,
+					 &ximage,
+					 NULL,				// don't want a shapemask 
+					 &xpmAttr);
+
+  if (ErrorStatus == XpmSuccess) {
+    // Set attributes
+    width=xpmAttr.width;
+    height = xpmAttr.height;
+	depth = ximage->depth;
+    XpmFreeAttributes(&xpmAttr);
+    ok = TRUE;
+    x_pixmap = ximage->bitmap;	// Actually a GWorldPtr!
+	XImageFree(ximage);			// does not delete the GWorld
+  } else {
+		// XpmDebugError(ErrorStatus, NULL);
+		ok = False;
+  }
+}
+#endif
+
+/*
+	if USE_XPM_IN_MAC and USE_IMAGE_LOADING_IN_MAC are not defined in wx_setup.h
+	then the only thing we can load is a PICT file.
+	USE_XPM_IN_MAC requires that the flags arg has the wxBITMAP_TYPE_XPM bit set.
+	USE_IMAGE_LOADING... does NOT look at the flags, instead it looks at file
+	extensions. This deserves a proper cleanup.
+*/
+Bool wxBitmap::LoadFile(char *name, long flags)
+{
+	if (selectedIntoDC) return FALSE;
+	
+	if (x_pixmap) {
+		DisposeGWorld(x_pixmap);
+		x_pixmap = NULL;
+	}
+	wxColourMap *colourmap;
+	ok = FALSE;
+
+#if USE_XPM_IN_MAC
+	if (flags & wxBITMAP_TYPE_XPM) {
+		XImage	*ximage;
+		XpmAttributes xpmAttr;
+		
+		xpmAttr.valuemask = XpmReturnInfos;	/* nothing yet, but get infos back */
+    	int ErrorStatus = XpmReadFileToImage(NULL,	// don't have a Display dpy
+				   name,
+				   &ximage,							// we get this back
+				   NULL,							// don't want a shapemask
+				   &xpmAttr);						// where to put the attributes
+
+		if (ErrorStatus == XpmSuccess) {
+			// Set attributes
+			width=xpmAttr.width;
+			height = xpmAttr.height;
+			depth = ximage->depth;
+			XpmFreeAttributes(&xpmAttr);
+			ok = TRUE;
+			x_pixmap = ximage->bitmap;	// Actually a GWorldPtr!
+			XImageFree(ximage);			// does not delete the GWorld
+		}
+		return ok;
+	}
+#endif
+#if USE_IMAGE_LOADING_IN_MAC
+	if (flags & wxBITMAP_TYPE_GIF) {
+		ok = wxLoadGifIntoBitmap(name, this, &colourmap);
+	} else if (flags & wxBITMAP_TYPE_PICT) {
+		ok = wxLoadPICTIntoBitmap(name, this, &colourmap);
+	} else if (flags & wxBITMAP_TYPE_XBM) {
+		ok = wxLoadXBMIntoBitmap(name, this, &colourmap);
+	} else if (flags & wxBITMAP_TYPE_BMP) {
+		ok = wxLoadBMPIntoBitmap(name, this, &colourmap);
+	} else if (flags & wxBITMAP_TYPE_ANY) {
+    	ok = wxLoadIntoBitmap(name,this, &colourmap);
+	} else {
+		ok = FALSE;
+	}
+#else
+	FILE *fp = fopen(name,"rb");
+	if (fp) {
+		// I don't know why we skip 512 bytes. I would have
+		// thought fopen only processes the data fork. I suppose
+		// it could be the "Mac Draw" header block (IM-V, pg 88)
+		fseek(fp, 0, SEEK_END);
+		int fsize = ftell(fp) - 512;
+		fseek(fp, 512, SEEK_SET);	// 0 didn't work
+		PicHandle ph = (PicHandle)NewHandle(fsize);
+		CheckMemOK(ph);
+		int rsize = fread((char *)*ph, 1, fsize, fp);
+		width = (*ph)->picFrame.right;
+		height = (*ph)->picFrame.bottom;
+		depth = wxDisplayDepth();
+		GDHandle savegd;
+		CGrafPtr saveport;
+		GetGWorld(&saveport, &savegd);
+		QDErr err;
+		GWorldPtr	newGWorld;
+		Rect	bounds = {0, 0, height, width};
+		err = NewGWorld(&x_pixmap, 0, &bounds, NULL, NULL, noNewDevice);
+		if (!err) {
+		  SetGWorld(x_pixmap, 0);
+		  DrawPicture(ph, &bounds);
+		  DisposeHandle((Handle)ph);
+		  SetGWorld(saveport, savegd);
+		  ok = TRUE;
+		} else {
+		  ok = FALSE;
+        }
+	} else
+		ok = FALSE;
+#endif
+	return ok;
+}
+
+Bool wxBitmap::SaveFile(char *name, int type, wxColourMap *cmap)
+{
+	Bool ok = FALSE;
+
+	if (type & wxBITMAP_TYPE_XBM) {
+		ok = wxSaveXBMFromBitmap(name, this, NULL);
+	} else if (type & wxBITMAP_TYPE_XPM) {
+	  if (!Ok()) return FALSE;
+	
+	  XImage ximage;
+	  
+	  GDHandle savegw;
+	  CGrafPtr saveport;
+	  GetGWorld(&saveport, &savegw);
+	
+	  SetGWorld(x_pixmap, 0);
+	
+	  ximage.width = GetWidth(); 
+	  ximage.height = GetHeight();
+      ximage.depth = GetDepth(); 
+      ximage.bitmap = NULL;
+      
+      int errorStatus = XpmWriteFileFromImage(NULL, name,
+                                              &ximage, (XImage *)NULL, 
+                                              (XpmAttributes *)NULL);
+
+	  SetGWorld(saveport, savegw);
+
+      ok = (errorStatus == XpmSuccess);
+	}
+	
+	return ok;
+}
+
+void wxBitmap::SetColourMap(wxColourMap *cmap)
+{
+}
+
+wxColourMap* wxBitmap::GetColourMap(void)
+{
+	return NULL;
+}
+
+//  --------------- Some Mac extensions ---- should only be used inside
+//		wxwindows, like from wx_button, wxDC, wxMemoryDC, etc.
+//		we ASSUME that SetMacDC() is set to the proper destination port.
+void wxBitmap::DrawMac(void)
+{
+	DrawMac(0, 0);
+}
+
+void wxBitmap::DrawMac(int x, int y)
+{
+	if (x_pixmap) {
+		Rect sbounds = {0, 0, height, width};
+		Rect dbounds = {y, x, height+y, width+x};
+		PixMapHandle  srcpixh = ::GetGWorldPixMap(x_pixmap);
+		CGrafPtr here;
+		::GetPort( (GrafPtr *)&here);
+		PixMapHandle destpixh = here->portPixMap;
+		::CopyBits( (BitMap *) (*srcpixh), (BitMap *) (*destpixh),
+			&sbounds, &dbounds, srcCopy, NULL);
+	}
+}
diff --git a/src/wxmac/src/mac/wx_gdi.cc.a1 b/src/wxmac/src/mac/wx_gdi.cc.a1
new file mode 100644
index 0000000..f70928f
--- /dev/null
+++ b/src/wxmac/src/mac/wx_gdi.cc.a1
@@ -0,0 +1,738 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_gdi.cc (Macintosh version)
+// Purpose:	GDI (Graphics Device Interface) objects and functions
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+#include "common.h"
+#include "wx_list.h"
+#include "wx_utils.h"
+#include "wx_gdi.h"
+#include <Strings.h>
+#include <Resources.h>
+
+CGrafPtr wxFont::gMacFontGrafPort = NULL; // mac platform only
+
+wxGDIList   *wxTheIconList = NULL;
+wxGDIList   *wxTheCursorList = NULL;
+wxGDIList   *wxTheColourList = NULL;
+
+#ifdef wx_xview
+
+/* These cursors courtesy of xfig
+ */
+
+static unsigned short    bull_cursor_array[16] = {
+    0x0F00, 0x30C0, 0x4020, 0x4020, 0x8010, 0x8610, 0x8610, 0x8010,
+    0x4020, 0x4020, 0x30C0, 0x0F00, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+static unsigned short    char_cursor_data[16] = {
+    0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
+    0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
+};
+
+static unsigned short    crosshair_cursor_data[16] = {
+    0x1000, 0x1000, 0x1000, 0xFE00, 0x1000, 0x1000, 0x1000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+static unsigned short    magnifier_cursor_array[16] = {
+    0x0F80, 0x3060, 0x4010, 0x4010, 0x8008, 0x8008, 0x8008, 0x8008,
+    0x8008, 0x4010, 0x4010, 0x3078, 0x0F9C, 0x000E, 0x0007, 0x0003,
+};
+
+static unsigned short    pencil_cursor_array[16] = {
+    0x0000, 0x0018, 0x0024, 0x0075, 0x009B, 0x0117, 0x022E, 0x045C,
+    0x08B8, 0x1170, 0x22E0, 0x25C0, 0x7B80, 0x6700, 0x8600, 0x0800,
+};
+
+static unsigned short    vbar_cursor_array[16] = {
+    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+};
+
+static unsigned short hand_cursor_array[] =
+{
+  0x0C00,0x1200,0x1200,0x1380,0x1240,0x7270,0x9248,0x924E,
+  0x9249,0x9249,0x9009,0x8001,0x4002,0x4002,0x2004,0x2004
+};
+#endif
+
+//-----------------------------------------------------------------------------
+wxFont::wxFont(void)
+{
+	point_size = 0;
+	temporary = TRUE;
+
+	wxTheFontList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+// Constructor for a font. Note that the real construction is done
+// in wxDC::SetFont, when information is available about scaling etc.
+//-----------------------------------------------------------------------------
+wxFont::wxFont(int PointSize, int Family, int Style, int Weight, Bool Underlined):
+  wxbFont(PointSize, Family, Style, Weight, Underlined)
+{
+	family = Family;
+	style = Style;
+	weight = Weight;
+	point_size = PointSize;
+	underlined = Underlined;
+
+	wxTheFontList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxFont::~wxFont()
+{
+  wxTheFontList->DeleteObject(this);
+}
+
+//-----------------------------------------------------------------------------
+float wxFont::GetCharHeight(void)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	::SetPort(oldPort);
+	return fontInfo.ascent + fontInfo.descent + fontInfo.leading;
+}
+
+//-----------------------------------------------------------------------------
+float wxFont::GetCharWidth(void)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	::SetPort(oldPort);
+	return fontInfo.widMax;
+}
+
+//-----------------------------------------------------------------------------
+void wxFont::GetTextExtent(char* string, float* x, float* y,
+							float* descent, float* externalLeading)
+{
+	GrafPtr oldPort;
+	::GetPort(&oldPort);
+	::SetPort((GrafPtr)gMacFontGrafPort);
+	::TextFont(GetMacFontNum());
+	::TextSize(point_size);
+	::TextFace(GetMacFontStyle());
+	FontInfo fontInfo;
+	::GetFontInfo(&fontInfo);
+	*x = TextWidth(string, 0, strlen(string)); // width
+	*x += 5; // WCH: kludge, to handle italic font and word wrapping at end of line
+	*y = fontInfo.ascent + fontInfo.descent + fontInfo.leading; // height
+	if (descent) *descent = fontInfo.descent;
+	if (externalLeading) *externalLeading = fontInfo.leading;
+	::SetPort(oldPort);
+}
+
+//-----------------------------------------------------------------------------
+int wxFont::GetMacFontNum(void) // mac platform only
+{
+	int result;
+
+    switch (family)
+	{
+		case wxDECORATIVE:
+			result = 2; // mac new york font
+			break;
+		case wxROMAN:
+			result = 20; // mac times font
+			break;
+		case wxMODERN:
+			result = 22; // mac courier font
+			break;
+		case wxSWISS:
+			result = 2; // mac new york font
+			break;
+		case wxDEFAULT:
+		default: 
+			result = 1; // mac application font
+			break;
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+Style wxFont::GetMacFontStyle(void) // mac platform only
+{
+	Style result = 0;
+	if (weight == wxBOLD) result |= bold;
+	if (style == wxITALIC) result |= italic;
+	if (underlined) result |= underline;
+	return result;
+}
+
+
+
+/*
+ * Colour map
+ *
+ */
+
+//-----------------------------------------------------------------------------
+wxColourMap::wxColourMap(void)
+{
+#ifdef wx_x
+  cmap = 0;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxColourMap::~wxColourMap(void)
+{
+}
+
+
+// Pens
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(void)
+{
+  colour = NULL;
+  stipple = NULL ;
+  style = wxSOLID;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+  width = 1;
+
+  wxThePenList->AddPen(this);
+}
+
+//-----------------------------------------------------------------------------
+wxPen::~wxPen()
+{
+  wxThePenList->RemovePen(this);
+}
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(wxColour& col, int Width, int Style):
+  wxbPen(col, Width, Style)
+{
+  colour = col;
+  stipple = NULL ;
+  width = Width;
+  style = Style;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+  wxThePenList->AddPen(this);
+}
+
+//-----------------------------------------------------------------------------
+wxPen::wxPen(char *col, int Width, int Style):
+  wxbPen(col, Width, Style)
+{
+  SetColour(col);
+  stipple = NULL ;
+  width = Width;
+  style = Style;
+  join = wxJOIN_ROUND ;
+  cap = wxCAP_ROUND ;
+  nb_dash = 0 ;
+  dash = NULL ;
+
+  wxThePenList->AddPen(this);
+}
+
+// Brushes
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(void)
+{
+  colour = NULL;
+  style = wxSOLID;
+  stipple = NULL ;
+  wxTheBrushList->AddBrush(this);
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::~wxBrush()
+{
+  wxTheBrushList->RemoveBrush(this);
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(wxColour& col, int Style):
+  wxbBrush(col, Style)
+{
+  SetColour(col);
+  style = Style;
+  stipple = NULL ;
+  wxTheBrushList->AddBrush(this);
+}
+
+//-----------------------------------------------------------------------------
+wxBrush::wxBrush(char *col, int Style):
+  wxbBrush(col, Style)
+{
+  SetColour(col);
+  style = Style;
+  stipple = NULL ;
+  wxTheBrushList->AddBrush(this);
+}
+
+// Icons - Remember a wxIcon is for minimized windows which the
+// Mac can't do.
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(char bits[], int Width, int Height)
+{
+  __type = wxTYPE_ICON;
+  width = Width;
+  height = Height;
+  wxTheIconList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(void)
+{
+  width = 0;
+  height = 0;
+  wxTheIconList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::wxIcon(char *icon_file)
+{
+  __type = wxTYPE_ICON;
+  wxTheIconList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxIcon::~wxIcon(void)
+{
+  wxTheIconList->DeleteObject(this);
+}
+
+// Cursors
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(void)
+{
+  __type = wxTYPE_CURSOR;
+  wxTheCursorList->Append(this) ;
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(char bits[], int width, int height)
+{
+  __type = wxTYPE_CURSOR;
+  wxTheCursorList->Append(this) ;
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(char *cursor_file)
+{
+  __type = wxTYPE_CURSOR;
+  wxTheCursorList->Append(this) ;
+}
+
+//-----------------------------------------------------------------------------
+// Cursors by stock number
+//-----------------------------------------------------------------------------
+wxCursor::wxCursor(int cursor_type)
+{
+  __type = wxTYPE_CURSOR;
+
+  switch (cursor_type)
+  {
+    case wxCURSOR_WAIT:
+    {
+      break;
+    }
+    case wxCURSOR_CROSS:
+    {
+      break;
+    }
+    case wxCURSOR_CHAR:
+    {
+      break;
+    }
+    case wxCURSOR_HAND:
+    {
+      break;
+    }
+    case wxCURSOR_BULLSEYE:
+    {
+      break;
+    }
+    case wxCURSOR_PENCIL:
+    {
+      break;
+    }
+    case wxCURSOR_MAGNIFIER:
+    {
+     break;
+    }
+    case wxCURSOR_IBEAM:
+    {
+      break;
+    }
+    case wxCURSOR_NO_ENTRY:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_pirate);
+      break;
+    }
+
+    case wxCURSOR_LEFT_BUTTON:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_leftbutton);
+      break;
+    }
+    case wxCURSOR_RIGHT_BUTTON:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_rightbutton);
+      break;
+    }
+    case wxCURSOR_MIDDLE_BUTTON:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_middlebutton);
+      break;
+    }
+    case wxCURSOR_QUESTION_ARROW:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_question_arrow);
+      break;
+    }
+    case wxCURSOR_SIZING:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_sizing);
+      break;
+    }
+    case wxCURSOR_WATCH:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_watch);
+      break;
+    }
+    case wxCURSOR_SPRAYCAN:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_spraycan);
+      break;
+    }
+    case wxCURSOR_PAINT_BRUSH:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_spraycan);
+      break;
+    }
+    case wxCURSOR_SIZENWSE:
+    case wxCURSOR_SIZENESW:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_circle);
+      break;
+    }
+    case wxCURSOR_SIZEWE:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_sb_h_double_arrow);
+      break;
+    }
+    case wxCURSOR_SIZENS:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_sb_v_double_arrow);
+      break;
+    }
+    case wxCURSOR_POINT_LEFT:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_sb_left_arrow);
+      break;
+    }
+    case wxCURSOR_POINT_RIGHT:
+    {
+      use_raw_x_cursor = TRUE;
+      //wch: x_cursor = XCreateFontCursor(dpy, XC_sb_right_arrow);
+      break;
+    }
+    default:
+    case wxCURSOR_ARROW:
+    {
+      break;
+    }
+    case wxCURSOR_BLANK:
+    {
+      break ;
+    }
+  }
+  wxTheCursorList->Append(this) ;
+}
+
+//-----------------------------------------------------------------------------
+wxCursor::~wxCursor(void)
+{
+  wxTheCursorList->DeleteObject(this) ;
+}
+
+//-----------------------------------------------------------------------------
+// Global cursor setting
+//-----------------------------------------------------------------------------
+void wxSetCursor(wxCursor *cursor)
+{
+
+  wxFlushEvents();
+}
+
+// Misc. functions
+
+//-----------------------------------------------------------------------------
+// Return TRUE if we have a colour display
+//-----------------------------------------------------------------------------
+Bool wxColourDisplay(void)
+{
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// Returns depth of screen
+//-----------------------------------------------------------------------------
+int wxDisplayDepth(void)
+{
+	return 1;
+}
+
+//-----------------------------------------------------------------------------
+// Get size of display
+//-----------------------------------------------------------------------------
+void wxDisplaySize(int *width, int *height)
+{
+	*width = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
+	*height = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
+}
+
+//------------------ BitMaps ------------------------------------------
+/*
+	on the Mac, the wxBitMap needs to be a structure that will allow
+	us to redraw. On the Mac, it could be a "picture" or it could be
+	a mac PixMap;
+	Pictures - easy to implement. May be slower. *May* be larger (it
+		depends)
+	PixMap -  fast. Confusing - are PixMaps tied to a GWorld?
+
+	For the first implementation use the Picture. A second implementation
+	could try PixMap or even both. 
+
+	We will have to extend the API so that parts of wxWindow (like
+	wx_buttn.cc) can draw a wxBitMap.
+
+	Also note that wx_dcmem.cc needs to know how to convert a Pict
+	into a wxMemoryDC (which should probably be implemented as an
+	offscreen GWorld). Also wxDC::DrawIcon might want to use this code.
+*/
+wxBitmap::wxBitmap(void)
+{
+  __type = wxTYPE_BITMAP;
+  ok = FALSE;
+  width = 0;
+  height = 0;
+  depth = 0;
+  x_pixmap = NULL;
+  rez_based = FALSE;
+  wxTheBitmapList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(char bits[], int the_width, int the_height, int no_bits)
+{
+  __type = wxTYPE_BITMAP;
+  depth = no_bits;
+  width = the_width;
+  height = the_height;
+  rez_based = FALSE;
+  Rect bounds = {0, 0, the_height, the_width};
+  x_pixmap = ::OpenPicture(&bounds);
+  int i, j;
+  char byte;
+  int bit1;
+  RGBColor	cpix;
+  switch (no_bits) {
+	case 0:
+	case 1:
+		GetForeColor(&cpix);
+		for (i = 0; i < the_height; i++) {
+			for (j = 0; j < the_width; i++) {
+				byte = bits[j,i];
+				for (int k = 0; k < 8; k++) {
+					if (byte & 1) {			
+						::SetCPixel(j, i, &cpix);
+					}
+					byte = byte >> 1;
+				}
+			}
+		}
+		break;
+	case 8:
+		for (i = 0; i < the_height; i++) {
+			for (j = 0; j < the_width; i++) {
+				// convert byte to RGB - how ? FIXME				
+				::SetCPixel(j, i, &cpix);
+			}
+		}
+		break;
+	case 16:
+	case 24:
+	case 32:
+		break;
+  } // end switch
+  ::ClosePicture();
+  ok = TRUE;
+  wxTheBitmapList->Append(this);
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(char *bitmap_file, long flags)
+{
+	__type = wxTYPE_BITMAP;
+	rez_based = FALSE;
+	if (flags & wxBITMAP_TYPE_BMP_RESOURCE)	{ 
+		// look for a 'PICT' resource with the given name
+		Str255 resname;
+		PicHandle	h;
+		ResType	thetype;
+		strcpy((char *)resname, bitmap_file);
+		C2PStr((char *)resname);
+		h = (PicHandle)::GetNamedResource('PICT', resname);
+		if (h) {
+			x_pixmap = h;
+			depth =  wxDisplayDepth();
+			width = (*h)->picFrame.right;
+			height = (*h)->picFrame.bottom;
+			wxTheBitmapList->Append(this);
+			rez_based = TRUE;
+			return;
+		}
+	}
+	// we also get here if we asked for a resource but it wasn't found
+	x_pixmap = NULL;
+	if (LoadFile(bitmap_file, flags) == FALSE) {
+		char t[200];
+		sprintf(t, "Could not find Bitmap: %s", bitmap_file);
+		wxFatalError(t);
+	}
+	
+}
+
+//-----------------------------------------------------------------------------
+// Create a new bitmap of a given size and depth
+//-----------------------------------------------------------------------------
+wxBitmap::wxBitmap(int w, int h, int d)
+{
+	Create(w, h, d);
+}
+
+//-----------------------------------------------------------------------------
+wxBitmap::~wxBitmap(void)
+{
+	if (rez_based) {
+  		::ReleaseResource((Handle)x_pixmap);
+	} else {
+		::KillPicture(x_pixmap);
+	}
+}
+
+Bool wxBitmap::Create(int width, int height, int deep)
+{
+  __type = wxTYPE_BITMAP;
+  rez_based = FALSE;
+  width = width;
+  height = height;
+  depth = deep;
+  Rect bounds = {0, 0, height, width};
+  x_pixmap = ::OpenPicture(&bounds);
+  if (depth < 1)
+    depth = wxDisplayDepth();
+  ::EraseRect(&bounds);
+  ::ClosePicture();
+  ok = TRUE;
+  wxTheBitmapList->Append(this);  
+
+  return ok;
+}
+
+// This will only read a PICT in the data fork. For other formats
+// Like BMP, GIF,... Well, you can add the code.
+Bool wxBitmap::LoadFile(char *name, long flags)
+{
+	// Dump preview picture, if any
+	if (x_pixmap) {
+		if (rez_based) {
+	  		::ReleaseResource((Handle)x_pixmap);
+		} else {
+			::KillPicture(x_pixmap);
+		}
+	}
+	FILE *fp = fopen(name,"rb");
+	if (fp) {
+		// I don't know why we skip 512 bytes. I would have
+		// thought fopen only processes the data fork. I suppose
+		// it could be the "Mac Draw" header block (IM-V, pg 88)
+		fseek(fp, 0, SEEK_END);
+		int fsize = ftell(fp) - 512;
+		fseek(fp, 512, SEEK_SET);	// 0 didn't work
+		PicHandle ph = (PicHandle)NewHandle(fsize);
+		int rsize = fread((char *)*ph, 1, fsize, fp);
+		width = (*ph)->picFrame.right;
+		height = (*ph)->picFrame.bottom;
+		depth = wxDisplayDepth();
+		x_pixmap = ph;
+		rez_based = FALSE;
+		ok = TRUE;
+	} else
+		ok = FALSE;
+	return ok;
+}
+
+Bool wxBitmap::SaveFile(char *name, int type, wxColourMap *cmap)
+{
+	return FALSE;
+}
+
+//  --------------- Some Mac extensions ---- should only be used inside
+//		wxwindows, like from wx_button, wxDC, wxMemoryDC, etc.
+void wxBitmap::DrawMac(void)
+{
+	if (x_pixmap) {
+		Rect bounds = {0, 0, height, width};
+		::DrawPicture(x_pixmap, &bounds);
+	}
+}
+
+void wxBitmap::DrawMac(int x, int y)
+{
+	if (x_pixmap) {
+		Rect bounds = {x, y, height+y, width+x};
+		::DrawPicture(x_pixmap, &bounds);
+	}
+}
diff --git a/src/wxmac/src/mac/wx_group.cc b/src/wxmac/src/mac/wx_group.cc
new file mode 100644
index 0000000..f63b86e
--- /dev/null
+++ b/src/wxmac/src/mac/wx_group.cc
@@ -0,0 +1,74 @@
+/*
+ * File:        wx_group.cc
+ * Purpose:     Group item implementation (X version)
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	April 1995
+ * Copyright:   (c) 1995, AIAI, University of Edinburgh
+ */
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma implementation "wx_group.h"
+#endif
+
+#include <stdlib.h>
+#include "common.h"
+#include "wx_utils.h"
+#include "wx_privt.h"
+#include "wx_group.h"
+
+
+/*
+ * Group box
+ */
+
+wxGroupBox::wxGroupBox (void)
+{
+}
+
+wxGroupBox::wxGroupBox (wxPanel * panel, char *label,
+	  int x, int y, int width, int height, long style, char *name):
+ wxbGroupBox(panel, label, x, y, width, height, style, name)
+{
+  Create (panel, label, x, y, width, height, style, name);
+}
+
+Bool wxGroupBox::Create (wxPanel * panel, char *label,
+	int x, int y, int width, int height, long style, char *name)
+{
+  label = wxItemStripLabel(label);
+
+  SetName(name);
+  buttonFont = panel->buttonFont;
+  labelFont = panel->labelFont;
+  backColour = panel->backColour;
+  labelColour = panel->labelColour;
+  buttonColour = panel->buttonColour;
+  window_parent = panel;
+  windowStyle = style;
+
+  labelPosition = wxVERTICAL;
+
+  return TRUE;
+}
+
+
+wxGroupBox::~wxGroupBox (void)
+{
+}
+
+#if 0
+void wxGroupBox::SetSize (int x, int y, int width, int height, int sizeFlags)
+{
+}
+#endif
+
+void wxGroupBox::SetLabel (char *label)
+{
+}
+
+char *wxGroupBox::GetLabel (void)
+{
+  return NULL;	// dummy
+}
diff --git a/src/wxmac/src/mac/wx_ipc.cc b/src/wxmac/src/mac/wx_ipc.cc
new file mode 100644
index 0000000..b4c3bfe
--- /dev/null
+++ b/src/wxmac/src/mac/wx_ipc.cc
@@ -0,0 +1,1012 @@
+/*
+ * File:	wx_ipc.cc
+ * Purpose:	Interprocess communication implementation (Mac version)
+ * Author:		Tomaso Paoletti
+ * Created:	1994-1995
+ * Updated:	
+ * Copyright:	(c) 1993-1995, AIAI, University of Edinburgh
+ */
+ 
+/* This implementation is limited to only ONE connection and works in a cooperative way:
+      DoIPCIdle() is called periodicallyfrom inside wx_app (right after DoIdle), 
+      the connection (if present) is scanned for input, possible requests are worked out
+      and the control returns to main app.
+     
+     A much more elegant solution would be achieved through multiple threads (maybe in the future).
+*/
+
+static const char sccsid[] = "%W% %G%";
+
+#include <stdlib.h>
+#include <iostream.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "common.h"
+#include "wx_setup.h"
+
+
+#if USE_IPC
+
+#include "wx_main.h"
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wx_ipc.h"
+#include "wxMacPPC.h"
+#include <Strings.h>
+
+#define ONE_CONNECTION	
+
+extern int errno;
+int wx_socket_create(int port);
+// Add NULL-terminated string to buffer, returning next start point
+int wxAddString(int start, char *info, char *buffer, int size = -1);
+
+// Get next NULL-terminated string from buffer
+char *wxGetNextString(char *buffer);
+
+extern Bool wxIPCInitialized;
+
+OSErr err;
+wxIPCObject * wxTheIPCObj = NULL; // used for execution of periodic tasks
+
+extern PPCParamBlockPtr	PBptr;
+extern PPCWritePBPtr		WritePBptr;
+extern PPCReadPBPtr		ReadPBptr;
+Boolean gRead = FALSE;
+
+Bool wx_input_ready(char * client);
+Bool wx_accept_connection(wxServer * server);
+
+//  the"connection-crunching" routine
+void DoIPCIdle ();
+
+/*
+ * Initialization
+ *
+ */
+
+void wxIPCInitialize(void)
+{		
+Boolean memOK;
+long attributes = 0L;
+
+ if (wxIPCInitialized)
+ {
+ #ifdef DEBUGLOG
+	wxLog<<"!!!! Trying to initialize IPC twice !!!!\n";
+#endif
+    return;
+ }	
+	memOK = PPCInitialize();
+	if (!memOK) 
+	{	wxError("IPC not initialized (problem with memory)");	return; };
+	
+	// the PPC toolbox initialization
+	wxIPCInitialized = ( ppcInit(&attributes) == noErr );
+
+	if (! ( attributes & gestaltPPCSupportsOutGoing ))
+		wxError("AppleTalk is disabled");
+			// it's likely that AppleTalk is disabled, so you may
+			// want to tell the user to activate AppleTalk from
+			// the Chooser
+
+	if (! (attributes & gestaltPPCSupportsIncoming))
+		wxError("Program linking is disabled");
+			// it's likely that program linking is disabled, so you
+			// may want to tell the user to start program linking
+			// from the Sharing Setup control panel
+  
+  if (!wxIPCInitialized) 
+  	wxError("IPC not initialized");
+ #ifdef DEBUGLOG
+	else	wxLog<<"--- IPC initialization OK ---\n";
+#endif
+
+}
+
+wxIPCObject::wxIPCObject(void)
+{
+  service_name = NULL;
+  wxTheIPCObj = this;
+}
+
+wxIPCObject::~wxIPCObject(void)
+{
+  wxTheIPCObj = NULL;
+}
+
+/*
+ * Server
+ *
+ */
+
+wxServer::wxServer(void)
+{
+#ifdef DEBUGLOG
+	char msg[100];
+	sprintf(msg,"*** wxServer constructor (ptr:%ld) ***\n",(long)wxTheIPCObj);
+	wxLog << msg;
+#endif
+}
+
+Bool wxServer::Create(char *server_name)
+{
+Boolean NBP_reg = FALSE;
+PPCPortPtr			thePPCPortPtr = NULL;
+LocationNamePtr	locNamePtr = NULL;
+StringPtr	userNamePtr = NULL;
+
+#ifdef DEBUGLOG
+	wxLog<< "SERVER: Creating...\n";
+#endif
+  service_name = copystring(server_name);
+
+  // Under UNIX, server should be an integer inside a string!
+  int the_port = 0;
+  sscanf(server_name, "%d", &the_port);
+
+  /* Create a socket listening on specified port */
+  //server_socket = wx_socket_create(the_port);
+	err = ppcOpen(&server_socket,"server",&NBP_reg);
+  if (err)
+  {	wxError("wxServer cannot open PPC port");
+    return FALSE;
+	}
+	if (!NBP_reg)
+	{	wxError("server port has not been NBP-registered");	}
+	
+	err = ppcInform(PBptr,thePPCPortPtr,locNamePtr,userNamePtr,server_socket);
+
+	if (err)
+	{	ppcClose (server_socket);
+		wxError("ppcInform failed");
+		return FALSE;
+	}
+#ifdef DEBUGLOG
+	wxLog<< "SERVER: Inform succeeded.\n";
+#endif
+
+#if 0		// FIXME - what is the on the Mac
+	Bool notify_toplevel = FALSE;
+  wxConnection *toplevel = this->OnAcceptConnection("STDIO");
+  if (toplevel)
+  {
+    toplevel->input_session = 0;
+    toplevel->output_session = 1;
+    notify_toplevel = TRUE;
+    toplevel->topic_name = copystring("STDIO");
+  }
+  else toplevel = new wxConnection(NULL, 0); // Create a dummy connection
+
+  toplevel->server = this;
+  connections.Append(toplevel);
+
+  /* Register stdin (IF APP ALLOWS IT) and the socket with the notifier */
+#endif
+
+#ifdef wx_xview
+  // stdin
+  if (notify_toplevel)
+    notify_set_input_func((Notify_client)toplevel, (Notify_func)&wx_input_ready, 0);
+
+  // Top level port
+  notify_set_input_func((Notify_client)toplevel, (Notify_func)&wx_accept_connection, server_socket);
+#endif
+#ifdef wx_motif
+  XtAppAddInput(wxTheApp->appContext, server_socket, (XtPointer *)XtInputReadMask, (XtInputCallbackProc) wx_accept_connection, (XtPointer)toplevel);
+#endif
+	
+  return TRUE;
+}
+
+
+wxServer::~wxServer(void)
+{
+#ifdef DEBUGLOG
+	wxLog<<"SERVER: closing port and destroying...\n";
+#endif
+	ppcClose(server_socket);
+}
+
+/*
+ * Client
+ *
+ */
+
+wxClient::wxClient(void)
+{
+#ifdef DEBUGLOG
+	char msg[100];
+	sprintf(msg,"*** wxClient constructor (ptr:%ld) ***\n",(long)wxTheIPCObj);
+	wxLog << msg;
+#endif
+}
+
+wxClient::~wxClient(void)
+{
+#ifdef DEBUGLOG
+	wxLog<<"CLIENT: closing port and destroying...\n";
+#endif
+	ppcClose(client_socket);
+}
+
+Bool wxClient::ValidHost(char *host)
+{
+#ifdef USE_SOCKET
+  if (gethostbyname(host))
+    return TRUE;
+  else
+    return FALSE;
+#else
+	return TRUE;
+#endif
+}
+
+wxConnection *wxClient::MakeConnection(char *host, char *server_name, char *topic)
+{
+Boolean NBP_reg = FALSE;
+int port;
+long cnt;
+
+#ifdef DEBUGLOG
+	wxLog<<"CLIENT: Making connection...\n";
+#endif   
+	sscanf(server_name, "%d", &port);
+
+  PPCSessRefNum session;
+	LocationNameRec locName;
+	PortInfoRec portInfo;
+	long	userRefNum = 0L;
+	long	rejectInfo = 0L;
+ 
+  err = ppcOpen(&client_socket,"client",&NBP_reg);
+  if (err)
+  {
+		wxError("wxClient cannot open PPC port");
+		return NULL;
+  }
+  
+	if (!NBP_reg)
+	{	wxError("client port has not been NBP-registered");	}
+
+	err = ppcBrowser(&locName,&portInfo);
+	if (err)
+	{	wxError("wxClient cannot browse PPC ports"); }
+	
+#ifdef DEBUGLOG
+	wxLog<< "CLIENT: Starting PPC session...\n";
+#endif
+	err = ppcStart(&portInfo,&locName,client_socket,&session,&userRefNum,&rejectInfo);
+	if (err)
+	{	wxError("Client cannot start session");	}
+	else
+	{
+	// Send topic name, and enquire whether this has succeeded
+		char buf[200];
+		buf[0] = wxCONNECT;
+		strcpy(buf+1, topic);
+		
+#ifdef DEBUGLOG
+		wxLog<<"CLIENT: Sending CONNECT message...\n";
+#endif		
+		ipcWrite(session, buf, strlen(topic)+2);
+		ipcSyncRead(session, buf, 200);
+
+		// OK! Confirmation.
+		if (buf[0] == wxCONNECT)
+		{
+#ifdef DEBUGLOG		  
+			wxLog<<"CLIENT: server confirmed connection!\n";
+#endif
+			wxConnection *connection = OnMakeConnection();
+			if (connection)
+			{
+				connections.Append(connection);
+				connection->input_session = session;
+				connection->output_session = session;
+				connection->client = this;
+
+				// Start async. read
+#ifdef DEBUGLOG
+				wxLog<<"CLIENT: starting async. read of data\n";
+#endif
+				err = ppcStartRead(ReadPBptr,session, connection->buf_size, connection->buf_ptr);
+				
+				// Register with the notifier
+				connection->Notify(TRUE);
+				return connection;
+			}
+			else { ppcEnd(session); 
+#ifdef DEBUGLOG
+				 wxLog<<"CLIENT: connection failed, ending...\n";
+#endif
+				  return NULL; }
+		}
+		else
+		{
+#ifdef DEBUGLOG		  
+			wxLog<<"CLIENT: Session ended.\n";
+#endif
+			ppcEnd(session);
+			return NULL;
+		}
+	}
+	return NULL;
+}
+
+/*
+ * Connection
+ */
+
+wxConnection::wxConnection(char *buffer, int size):wxbConnection(buffer, size)
+{
+  input_session = 0;
+  output_session = 0;
+}
+
+wxConnection::wxConnection(void)
+{
+  input_session = 0;
+  output_session = 0;
+}
+
+wxConnection::~wxConnection(void)
+{
+OSErr err;
+#ifdef wx_motif
+  if (xtInputId > 0)
+   XtRemoveInput(xtInputId);
+#endif
+#ifdef wx_xview
+  notify_set_input_func((Notify_client)this, (Notify_func)0, input_session);
+#endif
+  	
+  if (input_session != 0)
+  {	
+		err = ppcEnd(input_session);
+	}
+
+  if (server)
+    server->connections.DeleteObject(this);
+  if (client)
+    client->connections.DeleteObject(this);
+  if (topic_name)
+    delete[] topic_name;
+}
+
+// Calls that CLIENT can make
+Bool wxConnection::Disconnect(void)
+{
+OSErr err;
+#ifdef DEBUGLOG
+	wxLog<<"Sending DISCONNECT msg.\n";
+#endif
+
+  buf_ptr[0] = wxDISCONNECT;
+  ipcWrite(output_session, buf_ptr, 1);
+	
+#ifdef wx_motif
+  if (xtInputId)
+    XtRemoveInput(xtInputId);
+  xtInputId = 0;
+#endif
+#ifdef wx_xview
+  notify_set_input_func((Notify_client)this, (Notify_func)0, input_session);
+#endif
+
+  if (input_session != 0) // same as output_session
+  {	
+  	err = ppcEnd(input_session);
+	}
+  
+  input_session = 0;
+  output_session = 0;
+
+  return TRUE;
+}
+
+Bool wxConnection::Execute(char *data, int size, int format)
+{
+  if (size < 0)
+    size = strlen(data);
+
+  char format_buf[10];
+  sprintf(format_buf, "%d", format);
+
+  buf_ptr[0] = wxEXECUTE;
+  int pos = wxAddString(1, format_buf, buf_ptr);
+  pos = wxAddString(pos, data, buf_ptr, size);
+
+  ipcWrite(output_session, buf_ptr, pos);
+	
+  return TRUE;
+}
+
+char *wxConnection::Request(char *item, int *size, int format)
+{
+  char format_buf[10];
+  sprintf(format_buf, "%d", format);
+
+  buf_ptr[0] = wxREQUEST;
+  int pos = wxAddString(1, item, buf_ptr);
+  pos = wxAddString(pos, format_buf, buf_ptr);
+
+#ifdef wx_xview
+  Notify(FALSE);
+#endif
+
+  ipcWrite(output_session, buf_ptr, pos);
+  ipcRead(input_session, buf_ptr, buf_size);
+	
+#ifdef wx_xview
+  Notify(TRUE);
+#endif
+
+  if (err || buf_ptr[0] == wxFAIL)
+    return NULL;
+  else
+  {
+    char *new_item = buf_ptr + 1;
+    char *data = wxGetNextString(new_item);
+    if (size) *size = data-new_item;
+    return data;
+  }
+}
+
+Bool wxConnection::Poke(char *item, char *data, int size, int format)
+{
+  char format_buf[10];
+  sprintf(format_buf, "%d", format);
+
+  if (size < 0)
+    size = strlen(data);
+
+  buf_ptr[0] = wxPOKE;
+  int pos = wxAddString(1, item, buf_ptr);
+  pos = wxAddString(pos, format_buf, buf_ptr);
+  pos = wxAddString(pos, data, buf_ptr, size);
+
+  ipcWrite(output_session, buf_ptr, pos);
+  
+  return TRUE;
+}
+
+Bool wxConnection::StartAdvise(char *item)
+{
+  buf_ptr[0] = wxADVISE_START;
+  int pos = wxAddString(1, item, buf_ptr);
+
+#ifdef wx_xview
+  Notify(FALSE);
+#endif
+
+#ifdef DEBUGLOG
+	char msg[80];
+	Ptr p = buf_ptr;
+	sprintf(msg,"writing %ld bytes : %d %d %d %d %d %d \n",pos,p[0],p[1],p[2],p[3],p[4],p[5]);
+	wxLog << "StartAdvise: "<<msg;
+#endif
+  ipcWrite(output_session, buf_ptr, pos);
+  ipcRead(input_session, buf_ptr, buf_size);
+  
+#ifdef wx_xview
+  Notify(TRUE);
+#endif
+	
+#ifdef DEBUGLOG
+	if (buf_ptr[0]==wxFAIL) wxLog << "StartAdvise FAILED\n";
+#endif
+  return (err == noErr && buf_ptr[0] != wxFAIL);
+}
+
+Bool wxConnection::StopAdvise(char *item)
+{
+  buf_ptr[0] = wxADVISE_STOP;
+  int pos = wxAddString(1, item, buf_ptr);
+
+#ifdef wx_xview
+  Notify(FALSE);
+#endif
+
+  ipcWrite(output_session, buf_ptr, pos);
+  ipcRead(input_session, buf_ptr, buf_size);
+	
+#ifdef wx_xview
+  Notify(TRUE);
+#endif
+
+  return (err == noErr && buf_ptr[0] != wxFAIL);
+}
+
+// Calls that SERVER can make
+Bool wxConnection::Advise(char *item, char *data, int size, int format)
+{
+  char format_buf[10];
+  sprintf(format_buf, "%d", format);
+
+  buf_ptr[0] = wxADVISE;
+  int pos = wxAddString(1, item, buf_ptr);
+  pos = wxAddString(pos, format_buf, buf_ptr);
+  pos = wxAddString(pos, data, buf_ptr, size);
+
+  ipcWrite(output_session, buf_ptr, pos);
+	
+  return TRUE;
+}
+
+void wxConnection::Notify(Bool notify)
+{
+#ifdef wx_motif
+  if (!notify)
+  {
+    if (xtInputId > 0)
+    {
+      XtRemoveInput(xtInputId);
+      xtInputId = 0;
+    }
+  }
+  else
+    xtInputId = XtAppAddInput(wxTheApp->appContext, input_session, (XtPointer*)XtInputReadMask, (XtInputCallbackProc) wx_input_ready, this);
+#endif
+#ifdef wx_xview
+  if (notify)
+    notify_set_input_func((Notify_client)this, (Notify_func)wx_input_ready, input_session);
+  else
+    notify_set_input_func((Notify_client)this, NOTIFY_FUNC_NULL, input_session);
+#endif
+}
+
+#ifdef wx_xview
+#define NOTIFY_RETURN_TYPE Notify_value
+Notify_value wx_input_ready(Notify_client client, int fd)
+#endif
+#ifdef wx_motif
+#define NOTIFY_RETURN_TYPE Bool
+Bool wx_input_ready(XtPointer client, int *fid, XtInputId *id)
+#endif
+
+#define NOTIFY_RETURN_TYPE Bool
+static Bool wx_input_ready(wxConnection * connection)
+{
+  char msg[200];
+    //wxConnection *connection = (wxConnection *)client;
+		long nread;
+		
+	if (gSessionState != sOpen) 
+	{	
+		return FALSE;
+	}
+	
+	err = ReadPBptr->ioResult;
+	if (err < 0) 
+	{	
+		gSessionState = sClosed;
+#ifdef DEBUGLOG
+		sprintf(msg,"Error %d detected\n",err);
+		wxLog<<msg;
+#endif
+	}
+	else
+	if (err == 0) // yeah, we have data...
+	{
+#ifdef DEBUGLOG
+	sprintf(msg,"Connection %lX (input: %d, output: %d) (buf:%lX size:%ld) prev:%s\n",
+		connection,connection->input_session,connection->output_session,connection->buf_ptr,
+		connection->buf_size, connection->buf_ptr);
+	wxLog<<msg;
+#endif
+
+    nread = ipcRead(connection->input_session, connection->buf_ptr, connection->buf_size);  
+    if ((nread >= 0) && (nread < connection->buf_size))
+      connection->buf_ptr[nread] = 0;
+
+#ifdef DEBUGLOG
+		char * p = connection->buf_ptr;
+		sprintf(msg,"%ld bytes : %d %d %d %d %d %d %d %d -> '%s' (buffer %lX)\n",nread,p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p+1,(long)p);
+		wxLog<<"Receiving data.. "<<msg;
+#endif  
+
+		if (nread < 0)
+		{
+#ifdef DEBUGLOG
+			sprintf(msg,"Read error %d\n",nread);
+    	wxLog<<msg;
+#endif
+			connection->Notify(FALSE);
+			connection->OnDisconnect();
+			gSessionState = sClosed;
+			return (NOTIFY_RETURN_TYPE)FALSE;
+		}     
+		else
+		if (nread == 0)
+		{
+#ifdef DEBUGLOG
+			wxLog<<"EOF detected\n";
+#endif
+			connection->Notify(FALSE);
+			connection->OnDisconnect();
+			return (NOTIFY_RETURN_TYPE)FALSE;
+		}
+		switch (connection->buf_ptr[0])
+		{
+			case wxEXECUTE:
+     {
+#ifdef DEBUGLOG
+     	wxLog<<"wxEXECUTE received\n";
+#endif     	
+       char *format_buf = connection->buf_ptr + 1;
+       char *data = wxGetNextString(format_buf);
+
+       int format = wxCF_TEXT;
+       sscanf(format_buf, "%d", &format);
+
+       int size = nread - (data - connection->buf_ptr);
+       connection->OnExecute(connection->topic_name, data, size, format);
+       break;
+     }
+     case wxADVISE:
+     {	
+#ifdef DEBUGLOG
+     	wxLog<<"wxADVISE received\n";
+#endif     
+       char *item = connection->buf_ptr + 1;
+       char *format_buf = wxGetNextString(item);;
+       char *data = wxGetNextString(format_buf);
+
+       int format = wxCF_TEXT;
+       sscanf(format_buf, "%d", &format);
+
+       int size = nread - (data - connection->buf_ptr);
+       connection->OnAdvise(connection->topic_name, item, data, size, format);
+       break;
+     }
+     case wxADVISE_START:
+     {
+#ifdef DEBUGLOG
+     	wxLog<<"wxADVISE_START received\n";
+#endif         		
+       char *item = connection->buf_ptr + 1;
+       Bool ok = connection->OnStartAdvise(connection->topic_name, item);
+       if (ok)
+       {
+         connection->buf_ptr[0] = wxADVISE_START;
+         connection->buf_ptr[1] = 0;
+         ipcWrite(connection->output_session, connection->buf_ptr, 2); 
+       }
+       else
+       {
+         connection->buf_ptr[0] = wxFAIL;
+         connection->buf_ptr[1] = 0;
+         ipcWrite(connection->output_session, connection->buf_ptr, 2);
+       }
+
+       break;
+     }
+     case wxADVISE_STOP:
+     {
+#ifdef DEBUGLOG
+     	wxLog<<"wxADVISE_STOP received\n";
+#endif         		
+       char *item = connection->buf_ptr + 1;
+       Bool ok = connection->OnStopAdvise(connection->topic_name, item);
+       if (ok)
+       {
+         connection->buf_ptr[0] = wxADVISE_STOP;
+         connection->buf_ptr[1] = 0;
+         ipcWrite(connection->output_session, connection->buf_ptr, 2);
+       }
+       else
+       {
+         connection->buf_ptr[0] = wxFAIL;
+         connection->buf_ptr[1] = 0;
+         ipcWrite(connection->output_session, connection->buf_ptr, 2);
+       }
+
+       break;
+     }
+     case wxPOKE:
+     {
+#ifdef DEBUGLOG
+     	wxLog<<"wxPOKE received\n";
+#endif         	
+       char *item = connection->buf_ptr + 1;
+       char *format_buf = wxGetNextString(item);;
+       char *data = wxGetNextString(format_buf);
+
+       int format = wxCF_TEXT;
+       sscanf(format_buf, "%d", &format);
+
+       int size = nread - (data - connection->buf_ptr);
+       connection->OnPoke(connection->topic_name, item, data, size, format);
+       break;
+     }
+     case wxREQUEST:
+     {
+#ifdef DEBUGLOG
+     	wxLog<<"wxREQUEST received\n";
+#endif         		
+       char *item = connection->buf_ptr + 1;
+       char *format_buf = wxGetNextString(item);;
+
+       int format = wxCF_TEXT;
+       sscanf(format_buf, "%d", &format);
+
+       int user_size = -1;
+       char *user_data = connection->OnRequest(connection->topic_name, item, &user_size, format);
+       if (user_data)
+       {
+         connection->buf_ptr[0] = wxREQUEST_REPLY;
+         int pos = wxAddString(1, item, connection->buf_ptr);
+         pos = wxAddString(pos, user_data, connection->buf_ptr, user_size);
+
+         ipcWrite(connection->output_session, connection->buf_ptr, pos);
+       }
+       else
+       {
+         connection->buf_ptr[0] = wxFAIL;
+         connection->buf_ptr[1] = 0;
+         
+         ipcWrite(connection->output_session, connection->buf_ptr, 2);
+       }
+       break;
+     }
+     default:
+#ifdef DEBUGLOG
+     	 wxLog<<"Unrecognised command - resp. FAILURE\n";
+     	 connection->buf_ptr[0] = wxFAIL;
+     	 connection->buf_ptr[1] = 0;
+     	 ipcWrite(connection->output_session, connection->buf_ptr, 2);
+#endif
+       break;
+		}
+	}
+	return TRUE;
+}
+
+Bool wx_accept_connection(wxServer * server)
+{
+
+  PPCSessRefNum newsess;
+  //wxConnection *top_connection = (wxConnection *)client;
+
+  /* Accept the connection, getting a new socket */
+
+  newsess = PBptr->informParam.sessRefNum;
+  
+  char buf[300];
+		
+#ifdef DEBUGLOG
+	char msg[200];
+	long n = ipcSyncRead(newsess, buf, 300);
+	sprintf(msg,"%ld bytes long: %d %d %d ... '%s'\n",n,buf[1],buf[2],buf[3],buf+1);
+	wxLog<<"SERVER: received msg is "<<msg;
+#else
+  ipcSyncRead(newsess, buf, 300);
+#endif
+
+  if (buf[0] == wxCONNECT)
+  {
+    char *topic_name = copystring(buf + 1);
+		
+    // wxConnection *new_connection = top_connection->server->OnAcceptConnection(topic_name);
+    wxConnection *new_connection = server->OnAcceptConnection(topic_name);
+    if (new_connection)
+    {
+      // Acknowledge success
+      buf[0] = wxCONNECT;
+      buf[1] = 0;
+      ipcWrite(newsess, buf, 2);
+#ifdef DEBUGLOG
+			wxLog<<"SERVER: Responding to CONNECT msg.\n";
+#endif
+      new_connection->input_session = newsess;
+      new_connection->output_session = newsess;
+      new_connection->server = server;  //top_connection->server;
+      new_connection->topic_name = topic_name;
+      
+#ifdef DEBUGLOG
+			wxLog<<"SERVER: starting async. read\n";
+#endif
+      err = ppcStartRead(ReadPBptr, newsess, new_connection->buf_size, new_connection->buf_ptr);
+      
+      //top_connection->server->connections.Append(new_connection);
+      server->connections.Append(new_connection); 
+      
+#ifdef wx_xview
+      notify_set_input_func((Notify_client)new_connection, (Notify_func)&wx_input_ready, newsock);
+#endif
+#ifdef wx_motif
+      new_connection->xtInputId = XtAppAddInput(wxTheApp->appContext, newsock, (XtPointer*)XtInputReadMask, (XtInputCallbackProc) wx_input_ready, (XtPointer)new_connection);
+#endif
+    }
+    else
+    {
+      // Send failure message
+      buf[0] = wxFAIL;
+      buf[1] = 0;
+#ifdef DEBUGLOG
+      wxLog<<"SERVER: Sending FAILURE msg.\n";
+#endif
+      ipcWrite(newsess, buf, 2);
+    }
+  }
+  return FALSE;
+}
+
+/*
+ * Create an internet socket listening on the specified port.
+ */
+
+int wx_socket_create(int port)
+{
+#ifdef USE_SOCKETS
+  struct sockaddr_in addr; int sock;
+
+  addr.sin_family = AF_INET; 
+  addr.sin_addr.s_addr = htonl(INADDR_ANY); 
+  addr.sin_port = htons(port);
+
+  sock = socket(AF_INET, SOCK_STREAM, 0);
+  if(bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1)
+  {
+    printf("Error in bind\n");
+    return -1;
+  }
+
+  listen(sock, 5);
+
+  return sock;
+#else
+	wxError("wx_socket_create not implemented");
+	return 0;
+#endif
+}
+
+//--------------- new event-loop calls --------------------
+
+void wxServer::PeriodicTask()
+{	
+	if (gSessionState == sOpening)
+	{	
+#ifdef DEBUGLOG
+		wxLog<<"SERVER: session is opening.\n";
+#endif
+		gSessionState = sOpen;
+		wx_accept_connection(this);
+	}
+	if (gSessionState == sOpen)
+	{
+		// LIMIT: works with only one connection
+		wxNode *node = connections.First();
+#ifdef ONE_CONNECTION
+		wxConnection *conn = NULL;
+
+		if (node && (conn = (wxConnection *)node->Data()))
+		{	Bool valid = wx_input_ready(conn);
+		}
+		else
+		{	
+#ifdef DEBUGLOG
+			wxLog<<"SERVER: no connection on this side.";
+#endif
+			gSessionState = sClosed;
+		}
+#endif
+	}
+}
+
+void wxClient::PeriodicTask()
+{
+	if (gSessionState == sOpen)
+	{
+		// LIMIT: works with only one connection
+		wxNode *node = connections.First();
+#ifdef ONE_CONNECTION
+		wxConnection *conn = NULL;
+
+		if (node && (conn = (wxConnection *)node->Data()))
+		{	Bool valid = wx_input_ready(conn);
+		}
+		else
+		{	
+#ifdef DEBUGLOG		
+			wxLog<<"CLIENT: no connection on this side.";
+#endif
+			gSessionState = sClosed;
+		}
+#endif
+	}
+}
+
+void DoIPCIdle ()
+/* MUST BE CALLED PERIODICALLY, OTHERWISE THERE 'S NO WAY FOR CLIENT/SERVER TO COMMUNICATE */
+{
+	if (wxTheIPCObj)
+		wxTheIPCObj->PeriodicTask();
+}
+
+
+/************** UNUSED STUFF ***********************
+//----------- old event-loop calls ---------------
+
+// thread-manager support would help...
+
+void ServerIdle(wxServer *);
+void ClientIdle(wxClient *);
+
+void ServerIdle(wxServer * server)
+{
+Bool valid;
+static lastTime = TickCount();
+	
+	if (gSessionState == sOpening)
+	{	
+#ifdef DEBUGLOG
+		wxLog<<"SERVER: session is opening.\n";
+#endif
+		gSessionState = sOpen;
+		wx_accept_connection(server);
+	}
+	if (gSessionState == sOpen)
+	{
+#ifdef DEBUGLOG
+		if (TickCount()-lastTime > 120)
+		{	char msg[100];
+			sprintf(msg,"[slow loop for server : %ld ticks]\n",TickCount()-lastTime);
+			wxLog<<msg;
+		}
+#endif
+		// LIMIT: works with only one connection
+		wxNode *node = server->connections.First();
+#ifdef ONE_CONNECTION
+		wxConnection *conn = (wxConnection *)node->Data();
+		if (conn)
+			valid = wx_input_ready(conn);
+		else
+		{	
+#ifdef DEBUGLOG
+			wxLog<<"SERVER: no connection on this side.";
+#endif
+			gSessionState = sClosed;
+		}
+#endif
+	}
+	lastTime = TickCount();
+}
+
+void ClientIdle(wxClient * client)
+{
+Bool valid;
+static lastTime = TickCount();
+	
+	if (gSessionState == sOpen)
+	{
+#ifdef DEBUGLOG
+		if (TickCount()-lastTime > 120)
+		{	char msg[100];
+			sprintf(msg,"[slow loop for client : %ld ticks]\n",TickCount()-lastTime);
+			wxLog<<msg;
+		}
+#endif
+
+		// LIMIT: works with only one connection
+		wxNode *node = client->connections.First();
+#ifdef ONE_CONNECTION
+		wxConnection *conn = (wxConnection *)node->Data();
+		if (conn)
+			valid = wx_input_ready(conn);
+		else
+		{	
+#ifdef DEBUGLOG		
+			wxLog<<"CLIENT: no connection on this side.";
+#endif
+			gSessionState = sClosed;
+		}
+#endif
+	}
+	lastTime = TickCount();
+}
+*****************************/
+
+#endif // USE_IPC
diff --git a/src/wxmac/src/mac/wx_item.cc b/src/wxmac/src/mac/wx_item.cc
new file mode 100644
index 0000000..438521e
--- /dev/null
+++ b/src/wxmac/src/mac/wx_item.cc
@@ -0,0 +1,170 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_item.cc
+// Purpose:	Panel items implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+/**
+Julian, I've (re)put here parts of my mods about wxFIXED_LENGHT.
+I've done this because mod is only partially applied, which is not
+a very good thing!! [you have applied the part after AttachWidget, and not
+the part before creation]
+Principle of wxFIXED_LENGTH: when creating a label for a wxItem, says
+'this is a label' , it is created with  a string of same strlen containing
+only '0' char. So:
+
+	'this is a label     '  --> '0000000000000000000'
+	'this is a long label'  --> '0000000000000000000'
+
+Because strings are identical, they are aligned even if font is variable.
+And after creation, changing attachement to the form has effect of not
+resizing the label if it is changed back to its original value.
+Heavy, but that's work!
+**/
+
+/* When implementing a new item, be sure to:
+ *
+ * - add the item to the parent panel
+ * - set window_parent to the parent
+ * - NULL any extra child window pointers not created for this item
+ *   (e.g. label control that wasn't needed)
+ * - delete any extra child windows in the destructor (e.g. label control)
+ * - implement GetSize and SetSize
+ * - to find panel position if coordinates are (-1, -1), use GetPosition
+ * - call AdvanceCursor after creation, for panel layout mechanism.
+ *
+ */
+
+/*
+ Motif notes
+
+ A panel is a form.
+ Each item is created on a RowColumn or Form of its own, to allow a label to
+ be positioned. wxListBox and wxMultiText have forms, all the others have RowColumns.
+ This is to allow labels to be positioned to the top left (can't do it with a
+ RowColumn as far as I know).
+ AttachWidget positions widgets relative to one another (left->right, top->bottom)
+ unless the x, y coordinates are given (more than -1).
+ */
+
+#include "wx_item.h"
+#include "wx_gdi.h"
+
+
+wxItem::wxItem(void)
+	: wxbItem()
+{
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+}
+
+//-----------------------------------------------------------------------------
+// Constructor (given parentArea)
+wxItem::wxItem (wxArea* parentArea, int x, int y, int width, int height,
+		long style, char* windowName)
+	: wxbItem (windowName, parentArea, x, y, width, height, style)
+{
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+}
+
+//-----------------------------------------------------------------------------
+// Constructor (given parentWindow)
+wxItem::wxItem (wxWindow* parentWindow, int x, int y, int width, int height, 
+		long style, char* windowName) 
+	: wxbItem (windowName, parentWindow, x, y, width, height, style)
+{
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+}
+
+//-----------------------------------------------------------------------------
+// Constructor (given objectType; i.e., menu or menuBar)
+wxItem::wxItem (char* windowName) 
+	: wxbItem (windowName)
+{
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxItem::~wxItem(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxItem::SetBackgroundColour(wxColour*col)
+{
+	backColour = col;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxItem::SetLabelColour(wxColour*col)
+{
+	labelColour = col ;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxItem::SetButtonColour(wxColour*col)
+{
+	buttonColour = col ;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxItem::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxItem::OnChar(wxKeyEvent& event)
+{
+   // Default is to pass chars up to our panel
+   wxPanel *parent = (wxPanel *) GetParent();
+   if (parent)
+   {
+     // parent is not always a wxPanel: can be a wxMenu...
+     if (wxSubType(parent->__type,wxTYPE_PANEL))
+     {
+ 		parent->OnChar(event);
+     }
+   }
+}
+
+
+char *wxItemStripLabel(char *label)
+{
+  if (!label)
+    return NULL;
+    
+  int i;
+  for (i = 0; label[i]; i++) {
+    if (label[i] == '&') {
+      /* Strip it: */
+      char *naya = new char[strlen(label) + 1];
+      int j = 0;
+      for (i = 0; label[i]; i++) {
+        if (label[i] == '&') {
+          if (label[i + 1]) {
+            naya[j++] = label[i + 1];
+            i++;
+          }
+        } else
+          naya[j++] = label[i];
+      }
+      
+      return naya;
+    }
+  }
+  
+  return label;
+}
+
+
diff --git a/src/wxmac/src/mac/wx_lbox.cc b/src/wxmac/src/mac/wx_lbox.cc
new file mode 100644
index 0000000..dc79108
--- /dev/null
+++ b/src/wxmac/src/mac/wx_lbox.cc
@@ -0,0 +1,778 @@
+/*
+ * File:	wx_lbox.cc
+ * Purpose:	Panel item listBox implementation (Macintosh version)
+ * Author:	Cecil Coupe (Jul 8, 1995)
+ * Created:	1994
+ * Updated:	
+ *		11/1/95 - not deleting client data on delete or clear
+ * Copyright:	(c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+ */
+
+static const char sccsid[] = "%W% %G%";
+
+
+#include "common.h"
+#include "wx_lbox.h"
+#include "wx_utils.h"
+#include "wx_rbox.h"
+#include "wx_rbut.h"
+#include "wx_messg.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_gdi.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+#include "wxRectBorder.h"
+#include <Lists.h>
+#include "wxTimeScale.h"
+
+#define MEANING_CHARACTER	'0'
+/* 
+   A wxWindows (Macintosh version) wxListBox has these (sub)components:
+	1.  a Title
+	2.  a Mac List Manager "control"
+	3.  Optional Scrollbars (vertical only)
+	4.  BorderBox drawn round the list control but not the title or scrollbar
+
+  These are grouped/managed/defined by:
+	Creating the Mac list box control in the ClientArea
+	Creating a wxBorderArea (The Toolbox list mgr does not draw borders around
+		 the control)
+	Creating the wxLabelArea for the title (aka label);
+
+  wxItem protocol needed for showing the wxListBox on a panel:
+	1. A constructor of course thats makes a stab at sizing the Mac list box
+		and groups the items as described above.
+	2  A wxListBox::Paint method that calls LUpdate on the Mac list box
+	   and calls OnPaint() - to draw the wxLabelArea and wxBorderArea.
+	3. wxListBox::OnClientAreaDSize is needed to actually resize or reposition
+		the Mac List Box (after the label and bounding box are created).
+
+   The Mac list manager requires certain Mac events:
+	1. Update - call LUpdate which handles the scroll bar and the list control
+	2. MouseDown (but not all mouse events, trust me)
+	3. Activate ???
+
+   mflatt: Anytime the list might redraw itself, call SetCurrentDC() first; this
+        gets the GrafPtr into the proper coordinate system.
+
+   List Manager hints:
+	1. Note that SetRect(...) and Rect x = {...} args are in different order
+	   This causes me all kinds of errors and the List Mgr often doesn't
+	   display anything if the BoundsRect is wrong!
+
+	To do:
+	1. Compute a cell height based on the font used (currently hardcoded at 12)
+	   Also, the font used is different from wxText and RadioButtons.
+	2. Load the list in the constructor if N is non zero
+	3. This could be leaking memory ?
+*/
+
+// FIXME: Catch SetFont and fixup cell size and indent
+
+#define DefItemWidth 50
+#define KSBWidth	15	// number of pixels of a vertical scroll bars' width
+
+// Constructor
+
+wxListBox::wxListBox(
+		wxPanel *parentPanel, 
+		wxFunction func,
+		char *Title, 
+		Bool Multiple,
+		int x, 
+		int y, 
+		int width, 
+		int height,
+		int N, 
+		char **Choices, 
+		long style, 
+		char *windowName,
+		WXTYPE		objectType
+	) :
+		wxbListBox (parentPanel, x, y, width, height, N, style, windowName),
+ 		cDataList (new wxList(wxKEY_INTEGER))
+
+{
+  Create(parentPanel, func, Title, Multiple, x, y, width, height, N, Choices,
+         style, windowName);
+}
+
+Bool wxListBox::Create(wxPanel *panel, wxFunction func,
+                       char *Title, Bool Multiple,
+                       int x, int y, int width, int height,
+                       int N, char **Choices, long style, char *name)
+{
+	SetEraser(NULL);
+
+	labelFont = panel->labelFont ;
+	backColour = panel->backColour ;
+	labelColour = panel->labelColour ;
+	buttonFont = panel->buttonFont ;
+	buttonColour = panel->buttonColour ;
+
+	selected = -1;
+	selections = 0;
+	multiple = Multiple & wxMULTIPLE_MASK;
+	no_items = 0;
+	cKeycnt =0;
+
+	if (!buttonFont)
+	  buttonFont = wxNORMAL_FONT;
+
+	font = buttonFont;
+	
+	if (Title)
+	  Title = wxItemStripLabel(Title);
+	
+	Callback(func);
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+
+	float lblWidth, lblHeight;
+	GetTextExtent(Title, &lblWidth, &lblHeight, NULL, NULL, labelFont);
+	float tWidth, tHeight, tDescent;
+	GetTextExtent("X", &tWidth, &tHeight, &tDescent, NULL, font);
+	
+	if (width < 0) {
+	  cWindowWidth = (labelPosition == wxVERTICAL ? 0 : lblWidth) + DefItemWidth + KSBWidth;
+	}
+	if (height < 0) {
+	  cWindowHeight = (labelPosition == wxVERTICAL ? lblHeight : 0) + 3 * tHeight;
+	}
+	
+	int boxHeight = cWindowHeight;
+	int boxWidth = cWindowWidth;
+	// mflatt: wxNEEDED_SB = 0; if it's on, this code doesn't notice:
+	// int vscrollwanted = (style & (wxNEEDED_SB | wxALWAYS_SB)) || 
+	//	(Multiple & (wxNEEDED_SB | wxALWAYS_SB));
+	// Since the choice is either NEEDED or ALWAYS, presumably we always want it on:
+	int vscrollwanted = TRUE;
+	Rect dataRect = {0, 0, 0 ,1 }; 			
+	// start with no rows or columns, thats what the '1' {means in B, R}
+	int	cellwid = boxWidth - (vscrollwanted ? KSBWidth : 0);
+	Point cellsize = {(int)tHeight, cellwid};
+	Rect viewRect = {0, 0, boxHeight, cellwid };
+	cHaveVScroll = vscrollwanted;			// needed by OnClientAreaDSize or Paint
+
+	cListHandle = ::LNew(&viewRect, &dataRect, cellsize, 0, (WindowPtr)theMacGrafPort,
+		TRUE, FALSE, FALSE, vscrollwanted ? TRUE : FALSE);
+	CheckMemOK(cListHandle);
+	
+	(**cListHandle).indent.v = tHeight - tDescent;
+
+	// by default the Mac allows fancy selections
+	if (multiple & wxMULTIPLE) {
+#if 0
+		(**cListHandle).selFlags = lExtendDrag | lNoDisjoint | lNoExtend | lNoRect 
+			| lUseSense;
+#endif
+	}
+	else {
+		(**cListHandle).selFlags |= lOnlyOne;		// ell not one
+	}
+	cThinBorderArea = new wxBorderArea(this);		// Fits around the Mac listbox 'control'.
+	if (Title)
+	{
+		cListTitle = new wxLabelArea(this, Title, labelFont,
+				labelPosition == wxVERTICAL ? Direction::wxTop : Direction::wxLeft);
+	}
+	else
+		cListTitle = NULL;
+
+	cBorderArea = new wxBorderArea(this, 0, Direction::wxAll, 1); // mflatt: for showing keyboard focus
+	wxMargin margin(3);
+	cBorderArea->SetMargin(margin, Direction::wxAll,
+						cWindowWidth + 6, cWindowHeight + 6,
+						cWindowX - 3, cWindowY - 3);
+	((wxBorderArea *)cBorderArea)->cBorder->SetBrush(wxCONTROL_BACKGROUND_BRUSH);
+						
+	if (N)
+		this->Set(N, Choices);
+		
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+		
+	return TRUE;
+}
+
+wxListBox::~wxListBox(void)
+{
+  if (selections)
+    delete[] selections;
+  // if (cListTitle)		// deleting areas takes special care
+  //	delete cListTitle;
+  if (cDataList)
+	delete cDataList;
+  ::LDispose(cListHandle);
+}
+
+//------------ Event Handling --------------------------------------
+void wxListBox::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+	WindowPtr theMacWindow = (WindowPtr)cMacDC->macGrafPort();
+	::LUpdate(theMacWindow->visRgn, cListHandle);
+	
+	/* White out any empty space in the list: */
+	Point last, dlast;
+	Rect lastR, allR;
+	last.v = (**cListHandle).visible.bottom - 1;
+	last.h = (**cListHandle).visible.right - 1;
+	dlast.v = (**cListHandle).dataBounds.bottom - 1;
+	dlast.h = (**cListHandle).dataBounds.right - 1;
+	if (dlast.v < last.v)
+		last.v = dlast.v;
+	if (dlast.h < last.h)
+		last.h = dlast.h;
+	LRect(&lastR, last, cListHandle);
+	allR = (**cListHandle).rView;
+	if (allR.bottom > lastR.bottom) {
+		allR.top = lastR.bottom;
+		::EraseRect(&allR);
+	}
+	if (allR.right > lastR.right) {
+		allR.top = (**cListHandle).rView.top;
+		allR.left = lastR.right;
+		::EraseRect(&allR);
+	}
+	
+	wxWindow::Paint();
+}
+
+void wxListBox::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+	SetCurrentDC();
+
+	int clientWidth = ClientArea()->Width();
+	int clientHeight= ClientArea()->Height();
+	if (cHaveVScroll) clientWidth -= KSBWidth;
+	if (dW || dH)
+	{	// Changing the size
+		::LSize(clientWidth, clientHeight, cListHandle);
+		Point size = { (**cListHandle).cellSize.v, clientWidth };
+		::LCellSize(size, cListHandle);
+		
+	}
+
+	if (dX || dY)
+	{	// Changing the position
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put newViewRect at (0, 0)
+	}
+	
+	if (!cHidden && (dW || dH || dX || dY))
+	{
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+	}
+	
+	wxWindow::OnClientAreaDSize(dW, dH, dX, dY);
+}
+
+// ---- everything above this line is needed for visual respresentation of the wxListBox
+
+/* Manual Scrolling Implementation - mflatt
+  
+  I have no idea why, but lists sometimes get confused and LClick doesn't
+  dispatch to the scrollbar. This manual implementation for vertical scrollbars
+  always works, though.
+
+*/
+
+static ListHandle trackList;
+
+static pascal void TrackActionProc(ControlHandle theControl, short part)
+{
+   int delta, scrollsPerPage;
+
+    scrollsPerPage = (((**trackList).rView.bottom - (**trackList).rView.top)
+                      / (**trackList).cellSize.v);
+
+	switch (part) {
+	  case inUpButton: delta = -1; break;
+	  case inDownButton: delta = 1; break;
+	  case inPageUp: delta = -scrollsPerPage; break;
+	  case inPageDown: delta = scrollsPerPage; break;
+	}
+	
+	::LScroll(0, delta, trackList);
+}
+
+static ControlActionUPP
+TrackActionProcUPP = NewControlActionProc(TrackActionProc);
+
+static void ManualScroll(ListHandle list, ControlHandle scroll, Point startPt, int part)
+{
+	if (part == inThumb) {
+	  int oldPos = ::GetCtlValue(scroll);
+	  if (::TrackControl(scroll, startPt, NULL)) {
+         int newPos = ::GetCtlValue(scroll);
+         ::LScroll(0, newPos - oldPos, list);
+	  }
+	} else {
+	  trackList = list;
+	  ::TrackControl(scroll, startPt, TrackActionProcUPP);
+	}
+}
+		
+void wxListBox::OnEvent(wxMouseEvent& event) // WCH : mac only ?
+{
+	SetCurrentDC();
+	if (event.leftDown || event.rightDown) {
+		float fStartH, fStartV;
+		event.Position(&fStartH, &fStartV); // client c.s.
+		int startH = fStartH;
+		int startV = fStartV;
+		
+		Point startPt = {startV, startH}; 	// client c.s.
+		int modifiers = 0;
+		if (event.shiftDown)
+			modifiers += shiftKey;
+		if (event.altDown)
+			modifiers += optionKey;
+		if (event.rightDown) // mflatt: right button is Cmd-click
+			modifiers += cmdKey;
+		if (event.controlDown)
+			modifiers += controlKey;
+
+		if ((**cListHandle).vScroll) {
+		  int thePart = ::TestControl((**cListHandle).vScroll, startPt);
+		  if (thePart) {
+		    ManualScroll(cListHandle, (**cListHandle).vScroll, startPt, thePart);
+		    return;
+		  }
+		}
+
+		::LClick(startPt, modifiers, cListHandle);
+		if (PtInRect(startPt, &(**cListHandle).rView) == FALSE)
+			return;							// ie in the scroll bars
+		Cell cell = LLastClick(cListHandle);
+
+		if (event.ButtonDown()) {
+		  if ((cell.h == cLastClickCell.h)
+			  && (cell.v == cLastClickCell.v)
+			  && (event.timeStamp - cLastClickTime < SCALE_TIMESTAMP(GetDblTime()))) {
+			// Double-click
+			wxPanel *panel = (wxPanel *)GetParent();
+			panel->OnDefaultAction(this);
+			return;
+		  }
+		  cLastClickTime = event.timeStamp;
+		  cLastClickCell.h = cell.h;
+		  cLastClickCell.v = cell.v;
+		}
+		
+		{
+			int which = ((cell.v < no_items) ? cell.v : -1);
+			wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_LISTBOX_COMMAND);
+			commandEvent->commandString = GetString(which);
+			commandEvent->commandInt = which;
+			commandEvent->eventObject = this;
+	  		ProcessCommand(*commandEvent);
+		}
+	}
+}
+
+// mflatt:
+void wxListBox::OnChar(wxKeyEvent& event)
+{
+	int move = 0;
+
+	SetCurrentDC();
+
+	switch (event.KeyCode()) {
+		case WXK_UP:
+		case WXK_LEFT:
+			move = -1;
+			break;
+		case WXK_DOWN:
+		case WXK_RIGHT:
+			move = 1;
+			break;
+		case WXK_RETURN:
+		case /* WXK_ENTER */ 3:
+			wxPanel *panel = (wxPanel *)GetParent();
+			panel->OnDefaultAction(this);
+			break;
+	}
+
+	if (move) {
+		Cell now, next, save;
+		now.h = now.v = 0;
+		if (LGetSelect(TRUE, &now, cListHandle)) {
+			if (!((**cListHandle).selFlags & lOnlyOne) && (move > 0)) {
+				// moving forward for multiple selections: find last selected
+				Cell next;
+
+				next.h = now.h;
+				next.v = now.v + 1;
+				while (LGetSelect(TRUE, &next, cListHandle)) {
+					now.v = next.v;
+					next.v++;
+				}
+			}
+		} else if (move < 0)
+			now.v = 1;
+		else if (move > 0)
+			now.v = no_items - 2;
+
+		next.h = now.h;
+		next.v = now.v + move;
+		if (next.v < 0 || next.v >= no_items) {
+			save.h = now.h;
+			save.v = now.v;
+			next.v = now.v;
+		} else
+			save.h = save.v = -1;
+
+		if ((!event.shiftDown && !event.metaDown) || ((**cListHandle).selFlags & lOnlyOne)) {
+			int i;
+			Cell next;
+			next.h = now.h;
+			for (i = 0; i < no_items; i++)
+				if (i != save.v) {
+					next.v = i;
+					LSetSelect(FALSE, next, cListHandle);
+				}
+		}
+
+		LSetSelect(TRUE, next, cListHandle);
+	  	
+		// Make sure newly selected is visible: 
+		Rect rect;
+		LRect(&rect, next, cListHandle);
+		if (rect.top < 0) {
+			int amt = rect.top / (**cListHandle).cellSize.v;
+			if (rect.top % (**cListHandle).cellSize.v)
+				--amt;
+			LScroll(0, amt, cListHandle);
+		} else if (rect.bottom > (**cListHandle).rView.bottom) {
+			int diff = rect.bottom - (**cListHandle).rView.bottom;
+			int amt = diff / (**cListHandle).cellSize.v;
+			if (diff % (**cListHandle).cellSize.v)
+				amt++;
+			LScroll(0, amt, cListHandle);
+		}
+
+		{
+		    wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_LISTBOX_COMMAND);
+			commandEvent->commandString = GetString(next.v);
+			commandEvent->commandInt = next.v;
+			commandEvent->eventObject = this;
+	  		ProcessCommand(*commandEvent);
+	  	}
+	}
+}
+
+Bool wxListBox::WantsFocus(void)
+{
+	return TRUE;
+}
+
+// ---------------- Routines to Handle the List Contents ------------------------------------
+
+void wxListBox::Delete(int N)
+{ 
+  // (JDH) need to add code here to take care of clientDataList
+  wxNode *node = cDataList->Find((long)N);  // get item from list
+  if (node) cDataList->DeleteNode(node);    // if existed then delete from list
+  node = cDataList->First();                // we now have to adjust all keys that 
+  while (node)                                  // are >=N+1
+   { if (node->key.integer >= (long)(N+1))      // very ugly C++ wise but no other way 
+       node->key.integer--;                     // to look at or change key value
+     node = node->Next();
+   }
+  SetCurrentDC();
+  LDelRow(1, N, cListHandle);
+  no_items --;
+  cKeycnt--;
+}
+
+// Append an item to the list box
+void wxListBox::Append(char *Item, char *Client_data)
+{
+  SetCurrentDC();
+  LDoDraw(FALSE, cListHandle);
+  Cell cell = {no_items, 0};		// Point = {v, h} so Cell = {row, col}
+  LAddRow(1,no_items, cListHandle);
+  LSetCell(Item, strlen(Item) ,cell, cListHandle);
+  // LDraw(cell, cListHandle); // mflatt: can't get this to work; co-ordinate problems?
+  LDoDraw(TRUE, cListHandle);
+  cDataList->Append(no_items, (wxObject *)Client_data);
+  no_items ++;
+  if (Client_data) cKeycnt++;
+  Paint();
+}
+
+void wxListBox::Append(char *Item)
+{
+  Append(Item, NULL);
+ }
+
+void wxListBox::Set(int n, char *choices[])
+{
+  if (no_items > 0) {
+	this->Clear();
+  }
+  LDoDraw(FALSE, cListHandle);
+  Cell cell = {0, 0};		// Point = {v, h} so Cell = {row, col}
+  for (cell.v = 0; cell.v < n; cell.v++) {
+	  cDataList->Append(cell.v, (wxObject *)NULL);
+	  LAddRow(1,cell.v, cListHandle);
+	  LSetCell(choices[cell.v], strlen(choices[cell.v]) ,cell, cListHandle);
+  }
+  no_items = cell.v;
+  LDoDraw(TRUE, cListHandle);
+  Paint();
+}
+
+int wxListBox::FindString(char *s)
+{
+	Cell cell = {0, 0};
+	if (::LSearch(s, strlen(s), NULL, &cell, cListHandle) )
+		return cell.v;
+	else
+		return -1;
+}
+
+void wxListBox::Clear(void)
+{
+  if (no_items<=0)
+    return ;
+  cDataList->Clear ();
+  SetCurrentDC();
+  ::LDelRow(0, 0, cListHandle);
+  no_items = 0;
+  cKeycnt = 0;
+}
+
+// Find string for position
+char *wxListBox::GetString(int N)
+{
+	if (N >= no_items)
+		return NULL;
+
+	Cell cell = {N, 0};
+	short	len = 255;				// FIXME - really should be size of wxBuffer
+	LGetCell(wxBuffer, &len,  cell, cListHandle);
+	if (len <= 0 )
+		return NULL;
+	
+	wxBuffer[len] = '\0';
+	return wxBuffer;
+}
+
+void wxListBox::SetString(int N, char *s)
+{
+	Cell cell = {N, 0};
+	int	len = strlen(s);
+    SetCurrentDC();
+	LSetCell(s, len,  cell, cListHandle);
+}
+
+char *wxListBox::GetClientData(int N)
+{
+	wxNode *cdt = cDataList->Find(N);
+	if (cdt)
+		return((char *)cdt->Data());
+	else
+		return NULL;
+}
+
+void wxListBox::SetClientData(int N, char *s)
+{
+	wxNode *cdt = cDataList->Find(N);
+	if (cdt)
+		cdt->SetData((wxObject *)s);
+}
+
+// Undocumented !
+void wxListBox::InsertItems(int nItems, char **Items, int pos) 
+{
+  LDoDraw(FALSE, cListHandle);
+  Cell cell = {pos, 0};		// Point = {v, h} so Cell = {row, col}
+  int n;
+  for (n = 0;  n < nItems; cell.v++, n++) {
+	  cDataList->Append(cell.v, (wxObject *)NULL);
+	  LAddRow(1,cell.v, cListHandle);
+	  LSetCell(Items[n], strlen(Items[n]) ,cell, cListHandle);
+  }
+  no_items = no_items + nItems;
+  LDoDraw(TRUE, cListHandle);
+  Paint();
+}
+
+// ------ Manage Selections ----------------------
+
+void wxListBox::SetFirstItem(int N)	// Make item N the first visible item in list
+{	// Kind of Kludgy
+	SetCurrentDC();
+	// Get Current Selection - save it
+	int oldsel = GetSelection();
+	// Set the selection to N
+	SetSelection(N, TRUE);
+	// AutoScroll
+	::LAutoScroll(cListHandle);
+	// Turn off the selection
+	SetSelection(N, FALSE);
+	// Restore the saved selection (if there was one);
+	if (oldsel != -1)
+		SetSelection(oldsel, TRUE);
+}
+
+void wxListBox::SetFirstItem(char *s) 
+{
+  int N = FindString(s) ;
+
+  if (N>=0)
+    SetFirstItem(N) ;
+}
+
+void wxListBox::SetSelection(int N, Bool select)
+{
+  if (N < 0 || (N >= no_items))
+    return;
+
+   if (select && ((**cListHandle).selFlags & lOnlyOne)) {
+     int s = GetSelection();
+     if (s == N)
+       return;
+     if (s >= 0) {
+	   Cell cell = {s, 0};
+	   SetCurrentDC();
+	   LSetSelect(FALSE, cell, cListHandle);
+	 }
+   }
+   
+	Cell cell = {N, 0};
+	SetCurrentDC();
+	LSetSelect(select, cell, cListHandle);
+}
+
+Bool wxListBox::Selected(int N)
+{
+	Cell cell = {N, 0};
+	return LGetSelect(FALSE, &cell, cListHandle);
+}
+
+void wxListBox::Deselect(int N)
+{
+	Cell cell = {N, 0};
+    SetCurrentDC();
+	LSetSelect(FALSE, cell, cListHandle);
+}
+
+// Return number of selections and an array of selected integers
+// Use selections field to store data, which will be cleaned up
+// by destructor if necessary.
+int wxListBox::GetSelections(int **list_selections)
+{
+	Cell cell = {0, 0};
+	int n = 0;
+	while (LGetSelect(TRUE, &cell, cListHandle)) {
+		cell.v++;
+		n++;
+	}
+	if (n <= 0)
+		return 0;
+	cell.h = 0; cell.v = 0;
+	if (selections)
+	    delete[] selections;
+	selections = new int[n];
+	n = 0;
+	while (LGetSelect(TRUE, &cell, cListHandle)) {
+		selections[n++] = cell.v++;
+	}
+	*list_selections = selections;
+	return n;
+}
+
+// Get single selection, for single choice list items
+int wxListBox::GetSelection(void)
+{
+	int r;
+	Cell cell = {0, 0};
+
+	r = LGetSelect(TRUE, &cell, cListHandle);
+	if (r == FALSE)
+		return -1;
+	else
+		return cell.v;
+}
+
+void wxListBox::SetBackgroundColour(wxColour*col)
+{
+} 
+
+void wxListBox::SetLabelColour(wxColour*col)
+{
+}
+
+void wxListBox::SetButtonColour(wxColour*col) 
+{
+}
+
+char* wxListBox::GetLabel(void)
+{
+	return (cListTitle ? cListTitle->GetLabel() : NULL);
+}
+
+void wxListBox::SetLabel(char *label)
+{
+	if (cListTitle) cListTitle->SetLabel(label);
+}
+
+//-----------------------------------------------------------------------------
+void wxListBox::OnSetFocus()
+{
+	((wxBorderArea *)cBorderArea)->cBorder->SetBrush(wxBLACK_BRUSH);
+	if (!cHidden)
+		((wxBorderArea *)cBorderArea)->cBorder->Paint();
+
+	wxWindow::OnSetFocus();
+}
+
+//-----------------------------------------------------------------------------
+void wxListBox::OnKillFocus()
+{
+	((wxBorderArea *)cBorderArea)->cBorder->SetBrush(wxCONTROL_BACKGROUND_BRUSH);
+	if (!cHidden)
+		((wxBorderArea *)cBorderArea)->cBorder->Paint();
+
+	wxWindow::OnKillFocus();
+}
+
+//-----------------------------------------------------------------------------
+void wxListBox::ShowAsActive(Bool flag) // mac platform only
+{
+	if (cHidden || IsGray()) return;
+	
+	SetCurrentDC();
+	::LActivate(flag, cListHandle);
+}
+
+void wxListBox::DoShow(Bool on)
+{
+	if (!CanShow(on))
+		return;
+		
+	((wxBorderArea *)cBorderArea)->cBorder->DoShow(on);
+	((wxBorderArea *)cThinBorderArea)->cBorder->DoShow(on);
+	
+	wxWindow::DoShow(on);
+}
+
+void wxListBox::ChangeToGray(Bool gray)
+{
+	if (cHidden) return;
+	
+	SetCurrentDC();
+	::LActivate(!gray, cListHandle);
+	((wxBorderArea *)cThinBorderArea)->cBorder->InternalGray(gray);
+	if (cListTitle)
+		((wxLabelArea *)cListTitle)->GetMessage()->InternalGray(gray);
+	wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_mac_utils.cc b/src/wxmac/src/mac/wx_mac_utils.cc
new file mode 100644
index 0000000..2020370
--- /dev/null
+++ b/src/wxmac/src/mac/wx_mac_utils.cc
@@ -0,0 +1,220 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_utils.cc
+// Purpose:	Various utilities (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iostream.h>
+#include <fstream.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdarg.h>
+#include "wx_dialg.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include <Memory.h>
+#include <QuickDraw.h>
+#include <ToolUtils.h>
+#include <Dialogs.h>
+
+//-----------------------------------------------------------------------------
+wxMacString::wxMacString(void)
+{
+	pString[0] = 0;
+}
+
+//-----------------------------------------------------------------------------
+wxMacString::wxMacString(const char* cString)
+{
+	if (cString)
+	{
+		long itsLength = strlen(cString);
+		if (itsLength > 255) itsLength = 255;
+		BlockMove(cString, pString+1, itsLength); // BlockMove allows args to overlap
+		pString[0] = itsLength;
+	}
+	else pString[0] = 0;
+}
+
+//-----------------------------------------------------------------------------
+wxMacString::~wxMacString(void)	// destructor
+{
+}
+
+//-----------------------------------------------------------------------------
+wxMacString& wxMacString::operator=(char* cString)
+{ // assignment of cString
+	if (cString)
+	{
+		long itsLength = strlen(cString);
+		if (itsLength > 255) itsLength = 255;
+		BlockMove(cString, pString+1, itsLength); // BlockMove allows args to overlap
+		pString[0] = itsLength;
+	}
+	else pString[0] = 0;
+
+	return *this;
+}
+
+//-----------------------------------------------------------------------------
+Str255& wxMacString::operator() (void)
+{
+	return pString;
+}
+
+//-----------------------------------------------------------------------------
+wxMacString1::wxMacString1(void)
+{
+	pString[0] = 1;
+	pString[1] = ' ';
+}
+
+//-----------------------------------------------------------------------------
+wxMacString1::wxMacString1(char* cString): wxMacString(cString)
+{
+	if (pString[0] == 0)
+	{
+		pString[0] = 1;
+		pString[1] = ' ';
+	}
+}
+
+//-----------------------------------------------------------------------------
+wxMacString1& wxMacString1::operator=(char* cString)
+{ // assignment of cString
+	if (cString)
+	{
+		long itsLength = strlen(cString);
+		if (itsLength > 255) itsLength = 255;
+		BlockMove(cString, pString+1, itsLength); // BlockMove allows args to overlap
+		pString[0] = itsLength;
+	}
+	else pString[0] = 0;
+
+	if (pString[0] == 0)
+	{
+		pString[0] = 1;
+		pString[1] = ' ';
+	}
+
+	return *this;
+}
+
+//-----------------------------------------------------------------------------
+void wxMacCtoPString(char* theCString, Str255 thePString)
+{
+	long itsLength = strlen(theCString);
+	if (itsLength > 255) itsLength = 255;
+	BlockMove(theCString, thePString+1, itsLength); // BlockMove allows args to overlap
+	thePString[0] = itsLength;
+}
+
+//-----------------------------------------------------------------------------
+void wxMacPtoCString(Str255 thePString, char* theCString)
+{
+	long itsLength = thePString[0];
+	BlockMove(thePString+1, theCString, itsLength); // BlockMove allows args to overlap
+	theCString[itsLength] = 0;
+}
+
+//-----------------------------------------------------------------------------
+void wxError(const char *msg, const char *title)
+{	wxMessageBox((char *)msg, (char *)title,wxOK);		
+}
+
+//-----------------------------------------------------------------------------
+void wxFatalError(const char* msg, const char* title)
+{
+#if defined(PPCC)
+	wxMacString macMsg(msg);
+	wxMacString macTitle(title);
+	ParamText((const unsigned char*) macTitle(),
+		(const unsigned char*)macMsg(),
+		(const unsigned char*)"\p",
+		(const unsigned char*)"\p");	
+#else
+	wxMacString macMsg(msg);
+	wxMacString macTitle(title);
+	ParamText(macTitle(), macMsg(), "\p", "\p");	// WCH: must redo this
+#endif
+	StopAlert(100, NULL); 		// WCH: must redo this
+	abort();
+}
+
+//-----------------------------------------------------------------------------
+void wxFlushResources(void)
+{
+	// Defined in wx_utils.cc
+}
+
+//-----------------------------------------------------------------------------
+void wxFlushEvents(void)
+{
+	// Defined in wx_utils.cc
+}
+
+//-----------------------------------------------------------------------------
+char* macCopyString(char* s)
+{ // return a copy of the string or NULL
+	if (s) return copystring(s); else return NULL;
+}
+
+//-----------------------------------------------------------------------------
+char* macCopyString0(char* s)
+{ // return at least an empty string
+	if (s) return copystring(s); else return copystring("");
+}
+
+//-----------------------------------------------------------------------------
+char* macCopyString1(char* s)
+{ // return at least a blank string
+	if (s)
+	{
+		if (strlen(s) > 0)
+			 return copystring(s);
+		else return copystring(" ");
+	}
+	else return copystring(" ");
+}
+
+//-----------------------------------------------------------------------------
+void macGetHatchPattern(int hatchStyle, Pattern pattern)
+{
+	int thePatListID = sysPatListID;
+	int theIndex;
+	switch(hatchStyle)
+	{
+		case wxBDIAGONAL_HATCH:
+			theIndex = 34; // WCH: this is not good
+			break;
+		case wxFDIAGONAL_HATCH:
+			theIndex = 26;
+			break;
+		case wxCROSS_HATCH:
+			theIndex = 5;
+			break;
+		case wxHORIZONTAL_HATCH:
+			theIndex = 25;
+			break;
+		case wxVERTICAL_HATCH:
+			theIndex = 6;
+			break;
+		case wxCROSSDIAG_HATCH:
+			theIndex = 4; // WCH: this is not good
+			break;
+		default:
+			theIndex = 1; // solid pattern
+			break;
+	}
+#if !defined(OLD__HEADERS)
+	GetIndPattern(&pattern, thePatListID, theIndex);	
+#else
+	GetIndPattern(pattern, thePatListID, theIndex);	
+#endif
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_main.cc b/src/wxmac/src/mac/wx_main.cc
new file mode 100644
index 0000000..6321f00
--- /dev/null
+++ b/src/wxmac/src/mac/wx_main.cc
@@ -0,0 +1,139 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_main.cc
+// Purpose:	wxApp implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+#include <Windows.h>
+#include <iostream.h>
+#include <stdlib.h>
+
+#include "wx_main.h"
+#include "wx_list.h"
+#include "wx_utils.h"
+#include "wx_frame.h"
+#include "wxMacDC.h"
+
+void wxCleanUp(void);
+
+///////////////////////////////////////////////////////////////////////////////
+// The procedure CreateApp initializes the whole application.
+// You must declare and define it in the file that
+// implements your derived class of the base class wxApp.
+// It will look like this, where MyApp is the name of your derived class.
+// You must use the name CreateApp for this procedure;
+// you must use the name you chose for your derived class,
+// which does not have to be MyApp.
+//
+//	void CreateApp(void);	// This procedure initializes the whole application
+//	void CreateApp(void)
+//	{
+//		new MyApp;
+//	}
+//
+///////////////////////////////////////////////////////////////////////////////
+void CreateApp(void);
+
+extern "C" {
+  extern char *scheme_getcwd(char *buf, int buflen, int *actlen, int noexn);
+  extern char *scheme_build_mac_filename(FSSpec *spec, int given_dir);
+};
+
+
+char *wxmac_startup_directory;
+
+extern void wxInitResources(char *s);
+
+//-----------------------------------------------------------------------------
+int wxEntry(int argc, char* argv[])
+{
+	// CreateApp();	// This procedure initializes the whole application
+
+	if (!wxTheApp)
+	{
+		cerr << "wxWindows error: You have to define an instance of wxApp!\n";
+		exit(0);
+	}
+
+	wxTheApp->argc = argc;
+	wxTheApp->argv = argv;
+
+//	if (!wxTheApp->wx_class) wxTheApp->wx_class = macCopyString(argv[0]);
+
+	wxmac_startup_directory = scheme_getcwd(NULL, 0, NULL, 1);
+	
+	FSSpec spec;
+	if (!FindFolder(kOnSystemDisk, 'pref', kCreateFolder, &spec.vRefNum, &spec.parID)) {
+	  char *home = scheme_build_mac_filename(&spec, 1);
+	  int l = strlen(home);
+	  char *s = new char[l + 15];
+	  memcpy(s, home, l);
+	  if (s[l - 1] != ':') {
+	    s[l++] = ':';
+	  }
+	  strcpy(s + l, "mred.fnt");
+      wxInitResources(s);
+    }
+
+	wxCommonInit();
+	wxInitializePrintSetupData(1);
+
+	wxTheApp->wx_frame = wxTheApp->OnInit();
+	
+	// Simulate a OnSize event for the frames - CJC
+	for (wxChildNode * node = wxTopLevelWindows(NULL)->First (); node; node = node->Next ()) {
+		wxWindow *win = (wxWindow *) node->Data ();
+		if (win && node->IsShown()) {
+			int wid, hgt;
+			win->GetSize(&wid, &hgt);
+			win->OnSize(wid, hgt);
+		}
+	}
+		
+	while (!wxTheApp->death_processed /* && wxTopLevelWindows.Number() > 0 */)
+	{
+		wxTheApp->MainLoop();
+	}
+
+	int retValue = wxTheApp->OnExit();
+	wxCleanUp();
+	return retValue;
+}
+
+// In theory, this entry pt won't be used unless the real main does not
+// declare one.
+int main(int argc, char* argv[])
+{
+	return wxEntry(argc, argv);
+}
+
+//-----------------------------------------------------------------------------
+void wxCleanUp(void)
+{// Cleans up any wxWindows internal structures left lying around
+	wxCommonCleanUp();
+	wxFlushResources();
+}
+
+//-----------------------------------------------------------------------------
+Bool wxYield(void)
+{ // Yield to incoming messages
+
+    while (wxTheApp->Pending())
+      wxTheApp->Dispatch();
+      
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxExit(void)
+{
+	int retValue = 0;
+	if (wxTheApp) retValue = wxTheApp->OnExit();
+	wxCleanUp();
+
+	exit(retValue);
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_menu.cc b/src/wxmac/src/mac/wx_menu.cc
new file mode 100644
index 0000000..0e3e0cf
--- /dev/null
+++ b/src/wxmac/src/mac/wx_menu.cc
@@ -0,0 +1,857 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_menu.cc (split from wx_item.cc)
+// Purpose:	Menu objects implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+//#include <assert.h>
+
+#include "wx_menu.h"
+#include "wx_mnuit.h"
+#include "wx_frame.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wx_main.h"
+#include <Strings.h>	
+
+void wxSetUpAppleMenu(wxMenuBar *mbar);
+
+///////////////////////////////////////////////////////////////////////////////
+// Menu Bar
+///////////////////////////////////////////////////////////////////////////////
+
+
+// mflatt: In a wxMenu object:
+//          menu_bar is now only used by top-level menus in the menu bar
+//          top_level_menu is not set or used at all
+//          window_parent is set to the menu_bar for a top-level menu, or the
+//           parent menu for a submenu
+//         menuBar in a wxMenuItem is not used ever
+//
+//    When a menu bar is deleted, it deletes all menus it conatins
+//    When a menu is deleted, it deletes all submenus it contains
+//    The children list of a manu/menubar is not used
+//
+//    When inserting a test item into a menu, Special mac characters are ignored.
+//
+//    NOTE: A great deal of confusion is based on the fact that wxMenu and
+//          wxMenuBar are derived from wxItem. They are not windows or items
+//          and should not be derived from wxItem. Perhaps we can get this fixed...
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+wxMenuBar::wxMenuBar // Constructor (given objectType)
+	(
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMenuBar (windowName),
+		wxHelpHackMenu(NULL),
+		iHelpMenuHackNum(0)
+{
+	WXGC_IGNORE(menu_bar_frame);
+}
+
+wxMenuBar::wxMenuBar // Constructor (given parentPanel, label)
+	(
+		int 		N,
+		wxMenu* 	Menus[],
+		char* 		Titles[],
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMenuBar (N, Menus, Titles, windowName),
+		wxHelpHackMenu(NULL),
+		iHelpMenuHackNum(0)
+{
+	WXGC_IGNORE(menu_bar_frame);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+static wxMenuBar *last_installed_bar;
+
+//-----------------------------------------------------------------------------
+wxMenuBar::~wxMenuBar(void)
+{
+	if (last_installed_bar == this) {
+		::ClearMenuBar();
+		last_installed_bar = NULL;
+	}
+
+	if (menu_bar_frame) 
+		menu_bar_frame->wx_menu_bar = 0;
+	for (int i = 0; i < n; i++)
+	{
+		menus[i]->menu_bar = NULL;  // So menu doesn't try to remove itself
+		menus[i]->window_parent = NULL; // So menu doesn't try to remove itself
+		delete menus[i];
+		delete[] titles[i];
+	}
+	delete[] menus;
+	delete[] titles;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Menus
+///////////////////////////////////////////////////////////////////////////////
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Construct a menu with optional title (then use append)
+//-----------------------------------------------------------------------------
+wxMenu::wxMenu // Constructor (given objectType)
+	(
+		char*		Title,
+		wxFunction	function,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMenu(Title, windowName)
+{
+	Callback(function);
+
+	cMacMenuId = gMenuIdCounter++; // get next unique menuID
+	wxMacString1 theMacString1 = title;
+	cMacMenu = ::NewMenu(cMacMenuId, theMacString1());
+	CheckMemOK(cMacMenu);
+	WXGC_IGNORE(menu_bar);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// The wxWindow destructor will take care of deleting the submenus.
+//-----------------------------------------------------------------------------
+wxMenu::~wxMenu(void)
+{
+	if (menu_bar) // may have to remove menu from the current mac menu bar
+	{
+		menu_bar->Delete(this);
+		// mflatt: The AboutMenu Hack stuff below is mysterious to me
+#if 0
+		// Deactive AboutMenu Hack - This is untested
+		if (this == menu_bar->wxHelpHackMenu) {
+			menu_bar->wxHelpHackMenu = NULL;
+			menu_bar->iHelpMenuHackNum = 0;
+		}
+		wxFrame* frame = menu_bar->menu_bar_frame;
+		if (frame)
+		{
+			if (frame->IsFrontWindow())
+			{
+				::DeleteMenu(cMacMenuId);
+			}
+		}
+#endif
+	} else if (window_parent)
+		((wxMenu *)window_parent)->Delete(this, 0, -1);
+
+	::DisposeMenu(cMacMenu); // WCH: does this dispose of submenus? I hope not.
+                             // mflatt: it does not dispose of submenus
+
+	// if (title) delete[] title; // WCH: ~wxbMenu should do this - (cjc - it does)
+	wxNode* node = menuItems.First();
+   // mflatt: The menuItems list is not DeleteContents(TRUE).
+   //         Also, we need to delete any submenus attached to this menu
+	while (node) 
+	{
+    	wxMenuItem* item = (wxMenuItem*)node->Data();
+		if (item->subMenu) {
+		   item->subMenu->window_parent = NULL; // so it doesn't try to delete itself
+		   delete item->subMenu;
+		}
+		delete item;
+    	node = node->Next();
+	}
+}
+
+// Helper function - Convert a wxMenu String into one you can give
+// to the Mac menu mgr AppendMenu();
+// setupstr should be used with AppendItem; showstr should then be used with SetMenuItemText
+// If stripCmds is TRUE, instead of replacing wxMenu string special chars, 
+// we delete them. This is appropriate for the menu text of a pulldown Menu.
+static void BuildMacMenuString(StringPtr setupstr, StringPtr showstr, char *itemName,
+								Bool stripCmds)
+{
+	char *s, *d;
+	char spc = '\0';
+
+	d = (char *)&showstr[1];
+	if (itemName[0] == '-') // Fix problem with leading hyphen
+		*d++ = ' ';
+	for (s = itemName; *s != '\0'; ) {
+		if (*s == '&') {
+			// spc = *s;
+		}
+		else if (*s == '\t') {
+			s++;
+			if (strncmp("Cmd+", s, 4) == 0)
+				spc = s[4];
+			break;
+		} 
+		else {
+			*d++ = *s;
+		}
+		s++;
+	}
+	showstr[0] = (char)(d - (char *)setupstr)-1;
+	setupstr[1] = 'X'; // temporary menu item name
+	if (spc && !stripCmds) {
+		setupstr[2] = '/';
+		setupstr[3] = spc;
+		setupstr[0] = 3;
+	} else
+		setupstr[0] = 1;
+}
+
+static void StripMacMenuString(StringPtr theMacItemString1, char *s)
+{
+	char *d;
+	char spc = '\0';
+	for (d = (char *)&theMacItemString1[1]; *s != '\0'; ) {
+		if (*s == '&') {
+			spc = *++s;
+			if (*s == '\0') break;
+			*d++ = *s;
+		}
+		else {
+			*d++ = *s;
+		}
+		s++;
+	}
+	theMacItemString1[0] = (d - (char *)theMacItemString1)-1;
+}
+
+// Here's a joy! See wx_app::doMacInMenuBar() where the event is processed
+// each frame can contain a Help/About menu item which is "mirrored" underneath
+// the Apple menu.
+static void DoTheAboutHack(wxMenu *menu, wxMenuItem* menuItem)
+{
+	wxMenuBar*	mbar = menu->menu_bar;
+	mbar->wxHelpHackMenu = menu;
+	mbar->iHelpMenuHackNum = menuItem->GetMacItemNumber();
+}
+
+
+MenuHandle wxMenu::CreateCopy(char *title, Bool doabouthack)
+{
+	char t[256], tmp[256];
+	int i;
+	
+	// Remove accel - not used in Mac Top Level Menus
+	char *s = t;
+	for (i = 0; title[i]; i++) {
+		if (title[i] == '&') {
+			if (title[i + 1])
+				i++;
+			else
+				break;
+		}
+		*(s++) = title[i];
+	}
+	*s = 0;
+	s = t;
+	int helpflg;
+	helpflg = strncmp("Help", s, 4) ? 0 : 1;
+	C2PStr(s);
+	int cnt = menuItems.Number();
+	// Create a new Mac Menu 
+	MenuHandle nmh = ::NewMenu(cMacMenuId ,(ConstStr255Param)s);
+	CheckMemOK(nmh);
+	wxNode* node = menuItems.First();
+	for (i = 0; i < cnt; i++) {
+		// Try to recreate from the wxMenuItem
+		wxMenuItem* menuItem = (wxMenuItem*)node->Data(); 
+		if (menuItem->itemId == -1) {
+			// Separator
+			tmp[0] = t[0] = 1;
+			tmp[1] = t[1] = '-';			
+		} 
+		else if (menuItem->subMenu) {
+			BuildMacMenuString((StringPtr)tmp, (StringPtr)t, menuItem->itemName, TRUE);
+			wxMenu *subMenu = menuItem->subMenu;
+			subMenu->wxMacInsertSubmenu();
+			unsigned char menuadds[4] = {'/',0x1b,'!', ' ' };
+			menuadds[3] = subMenu->cMacMenuId;
+			int len = tmp[0];
+			memcpy(&tmp[len+1], menuadds, 4);
+			tmp[0] += 4;
+		}
+		else {
+			BuildMacMenuString((StringPtr)tmp, (StringPtr)t, menuItem->itemName, FALSE);
+			if (doabouthack && helpflg && (!strncmp("About", &t[1], 5))) {
+				// This is an very sad hack !
+				DoTheAboutHack(this, menuItem);
+			}
+		}
+		::AppendMenu(nmh, (ConstStr255Param)tmp);
+		::SetMenuItemText(nmh, i+1, (ConstStr255Param)t);
+		if (menuItem->IsChecked())
+		  ::CheckItem(nmh, i+1, TRUE);
+		if (!menuItem->IsEnabled())
+		  ::DisableItem(nmh, i+1);
+		node = node->Next();						// watch for null?	
+	}
+	
+    return nmh;
+}
+
+// another Helper function - change the Title/Text of a Menu 
+// We Have to change the Title in the MenuBar, which is rebuilt in wxFrame::SetMenubar
+// Unfortunately, The ToolBox does'nt let you get/set the ItemText for "Menu" (items yes)
+// but not the Menu. So the menu will have to be rebuilt. Plenty of room for errors!
+void wxMenu::MacChangeMenuText(wxMenu *menu, char *new_title)
+{
+	// Get Handle to the Menu
+	MenuHandle omh = menu->cMacMenu;
+	
+	if (title) delete title;
+	title = macCopyString1(new_title);
+
+    // Create a new Mac Menu 
+	menu->cMacMenu = menu->CreateCopy(new_title, TRUE);
+
+	// Remove from system Menu List if it might be there and redraw with new menu:
+    if (menu->menu_bar && menu->menu_bar == last_installed_bar)
+	  menu->menu_bar->Install();
+
+	// Dispose the old menu
+	::DisposeMenu(omh);
+}
+
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::Enable(int Id, Bool Flag)
+{
+	for (int j = 0; j < n; j++)
+	{
+    	wxMenuItem* theMenuItem = menus[j]->FindItemForId(Id);
+    	if (theMenuItem)
+    	{
+			theMenuItem->Enable(Flag);
+			return;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::Check(int Id, Bool Flag)
+{
+	for (int j = 0; j < n; j++)
+	{
+    	wxMenuItem* theMenuItem = menus[j]->FindItemForId(Id);
+    	if (theMenuItem)
+    	{
+			theMenuItem->Check(Flag);
+			return;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxMenuBar::Checked(int Id)
+{
+	for (int j = 0; j < n; j++)
+	{
+    	wxMenuItem* theMenuItem = menus[j]->FindItemForId(Id);
+    	if (theMenuItem)
+    	{
+			return theMenuItem->IsChecked();
+		}
+	}
+
+	return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::SetLabel(int Id, char* label)
+{
+	for (int j = 0; j < n; j++)
+	{
+    	wxMenuItem* theMenuItem = menus[j]->FindItemForId(Id);
+    	if (theMenuItem)
+    	{
+			theMenuItem->SetLabel(label);
+			return;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+char* wxMenuBar::GetLabel(int Id)
+{
+	for (int j = 0; j < n; j++)
+	{
+    	wxMenuItem* theMenuItem = menus[j]->FindItemForId(Id);
+    	if (theMenuItem)
+    	{
+			return theMenuItem->GetLabel();
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::SetLabelTop(int pos, char* label)
+{
+	if ((pos >= 0) && (pos < n)) {
+	  menus[pos]->SetTitle(label);
+	  titles[pos] = copystring(label);
+	}
+}
+
+//-----------------------------------------------------------------------------
+char* wxMenuBar::GetLabelTop(int pos) { 
+  if ((pos >= 0) && (pos < n))
+    return menus[pos]->GetTitle();
+  else
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::EnableTop(int pos, Bool flag)
+{ 
+    /* For consistency with other platforms, 
+       disabling is not allowed to work unless the menu bar in installed: */
+	if (!menu_bar_frame && !flag)
+	  return;
+	
+	if (pos >= 0 && (pos < n))
+		menus[pos]->Enable(flag);
+}
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::SetSize(int x, int y, int width, int height) { }
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::DoSetSize(int x, int y, int width, int height) { }
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::Enable(Bool Flag) { }
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::Show(Bool show) { }
+
+//-----------------------------------------------------------------------------
+char* wxMenuBar::GetLabel(void) { return NULL; } // The menubar doesn't have a label
+
+//-----------------------------------------------------------------------------
+void wxMenuBar::SetLabel(char* label) { } // The menubar doesn't have a label
+
+//-----------------------------------------------------------------------------
+wxMenu* wxMenuBar::wxMacFindMenu(int macMenuId)
+{
+	wxMenu* result = NULL;
+	int i = 0;
+	while (i < n && !result) // try to find among main menus
+	{
+		if (menus[i]->GetMacMenuId() == macMenuId)
+			result = menus[i];
+		else i++;
+	}
+
+	if (!result)
+	{
+		i = 0;
+		while (i < n && !result) // try to find among submenus
+		{
+			result = menus[i]->wxMacFindSubmenu(macMenuId);
+			if (!result) i++;
+		}
+	}
+
+	return result;
+}
+
+// Append menu to menubar and optionally, change title of menu item
+Bool wxMenuBar::OnAppend (wxMenu * menu, char *title)
+{
+  Bool retval = TRUE, new_menu = FALSE;
+
+  if (!menu->window_parent) {
+    menu->Enable(TRUE); /* Force the menu to be enabled (for consistency) */
+    menu->window_parent = this;
+    menu->menu_bar = this;
+    new_menu = TRUE;
+  } else if (menu->window_parent == this) {
+	// Don't add, but maybe change the menu title
+	retval = FALSE;
+  } else
+	return FALSE;
+
+  if (title)
+	menu->MacChangeMenuText(menu, title);
+
+  if (new_menu && this == last_installed_bar) {
+	::InsertMenu(menu->cMacMenu, 0);
+	menu->wxMacInsertSubmenu();
+	::InvalMenuBar();
+  }
+
+  return retval;
+}
+
+Bool wxMenuBar::OnDelete(wxMenu *menu, int pos)
+{
+  menu->window_parent = NULL;
+  menu->menu_bar = NULL;
+
+  if (menu_bar_frame && menu_bar_frame->IsFrontWindow()) {
+  	::DeleteMenu(menu->cMacMenuId);
+	::InvalMenuBar();
+  }
+
+  return TRUE;
+}
+
+// Helper function - Add the Apple Menu 
+void wxSetUpAppleMenu(wxMenuBar *mbar)
+{
+	MenuHandle appleMenuHandle = GetMHandle(128);
+
+	if (appleMenuHandle == NULL) {
+		char t[2] = {1, appleMark};
+		appleMenuHandle = ::NewMenu(128, (StringPtr)t);
+		CheckMemOK(appleMenuHandle);
+		::AddResMenu(appleMenuHandle, 'DRVR');
+	}
+	if (mbar && mbar->wxHelpHackMenu && mbar->iHelpMenuHackNum) {
+#ifdef PPCC
+		Str255 t = "\pAboutÉ";
+		::InsertMenuItem(appleMenuHandle, t, 0);
+#else
+		::InsertMenuItem(appleMenuHandle, "\pAboutÉ", 0);
+#endif
+	} else {
+		char buffer[256];
+		strcpy(buffer, wxTheApp->GetDefaultAboutItemName());
+		::InsertMenuItem(appleMenuHandle, C2PStr(buffer), 0);
+    }
+	::InsertMenu(appleMenuHandle, 0);
+}
+
+void wxMenuBar::Install(void)
+{
+	::ClearMenuBar();
+	wxSetUpAppleMenu(this);
+	for (int i = 0; i < n; i ++)
+	{
+		wxMenu* menu = menus[i];
+	    ::InsertMenu(menu->MacMenu(), 0);
+	    menu->wxMacInsertSubmenu();
+	    if (!menu->IsEnable() || (menu_bar_frame && !menu_bar_frame->CanAcceptEvent()))
+	    	::DisableItem(menu->MacMenu(), 0);
+	    else
+			::EnableItem(menu->MacMenu(), 0);
+	}
+	::InvalMenuBar();
+	last_installed_bar = this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Menus
+///////////////////////////////////////////////////////////////////////////////
+
+short wxMenu::gMenuIdCounter = 129; // mac platform (to give unique menuID's to mac menus)
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxMenu::Break(void) { } // Macintosh has just one line for the menu bar
+
+//-----------------------------------------------------------------------------
+void wxMenu::AppendSeparator(void)
+{
+	wxMenuItem* item = new wxMenuItem(this);
+
+	item->itemId = -1;
+	item->itemName = copystring("-");
+	menuItems.Append(item);
+	no_items ++;
+
+	wxMacString1 theMacItemString1 = item->itemName; // menu item string can't be empty
+	AppendMenu(cMacMenu, theMacItemString1());
+}
+
+//-----------------------------------------------------------------------------
+// Ordinary menu item
+//-----------------------------------------------------------------------------
+void wxMenu::Append(int Id, char* Label, char* helpString, Bool checkable)
+{
+//	assert(Id >= 1);
+	wxMenuItem* item = new wxMenuItem(this, checkable);
+
+	item->itemId = Id;
+	item->itemName = macCopyString(Label);
+	item->helpString = macCopyString(helpString);
+	menuItems.Append(item);
+	no_items ++;
+
+	// wxMacString1 theMacItemString1 = item->itemName; // menu item string can't be empty
+	// AppendMenu(cMacMenu, theMacItemString1());
+	Str255 menusetup, menustr;
+	BuildMacMenuString(menusetup, menustr, item->itemName, FALSE);
+	::AppendMenu(cMacMenu, (ConstStr255Param)menusetup);
+	::SetMenuItemText(cMacMenu, no_items, (ConstStr255Param)menustr);
+}
+
+//-----------------------------------------------------------------------------
+// Pullright item
+//-----------------------------------------------------------------------------
+void wxMenu::Append(int Id, char* Label, wxMenu* SubMenu, char* helpString)
+{
+//	assert(Id >= 1);
+//	assert(SubMenu->window_parent == NULL); // WCH : error if submenu is a child of another
+
+	// mflatt: If this menu is used, give up
+	if (SubMenu->window_parent)
+		return;
+
+	SubMenu->window_parent = this;
+
+	wxMenuItem* item = new wxMenuItem(this);
+	item->subMenu = SubMenu;
+
+  	item->itemId = Id;
+  	item->itemName = macCopyString(Label);
+  	item->helpString = macCopyString(helpString);
+
+	menuItems.Append(item);
+	no_items++;
+
+	Str255 pullrightSetup, pullrightLabel;
+	BuildMacMenuString(pullrightSetup, pullrightLabel,item->itemName, TRUE);
+	
+	int theEnd = pullrightSetup[0] + 1; // mflatt: +1
+	if (theEnd > 251) theEnd = 251; // mac allows only 255 characters
+	pullrightSetup[theEnd++] = '/';
+	pullrightSetup[theEnd++] = 0x1B; // mac item is a pullright menu
+	pullrightSetup[theEnd++] = '!';
+	pullrightSetup[theEnd++] = SubMenu->cMacMenuId; // id of mac pullright menu
+	pullrightSetup[theEnd] = 0x00;
+	pullrightSetup[0] = theEnd;
+	::AppendMenu(cMacMenu, (ConstStr255Param)pullrightSetup);
+	::SetMenuItemText(cMacMenu, no_items, (ConstStr255Param)pullrightLabel);
+
+	wxMenu *ancestor = this;
+	while (ancestor) {
+		if (ancestor->menu_bar) {
+			if (ancestor->menu_bar == last_installed_bar) {
+				InsertMenu(SubMenu->cMacMenu, -1);
+				SubMenu->wxMacInsertSubmenu();
+			}
+			break;
+		}
+		ancestor = (wxMenu *)ancestor->window_parent;
+    }
+}
+
+// mflatt
+void wxMenu::Delete(wxMenu *menu, int Id, int delpos)
+{
+	int pos;
+	wxMenuItem *item;
+	wxNode *node;
+	
+	if ((Id == -1) && (delpos == -1))
+	  return;
+
+	for (pos = 0, node = menuItems.First(); node; node = node->Next(), pos++) {
+		item = (wxMenuItem *)node->Data();
+		if ((menu && item->subMenu == menu) 
+		    || (!menu && (delpos == -1) && item->itemId == Id)
+		    || (delpos == pos)) {
+		  if (item->subMenu)
+			 item->subMenu->window_parent = NULL;
+		  ::DeleteMenuItem(cMacMenu, pos + 1);
+		  menuItems.DeleteNode(node);
+		  delete item;
+		  --no_items;
+		  return;
+		}
+	}
+}
+
+void wxMenu::DeleteByPosition(int pos)
+{
+  Delete(NULL, -1, pos);
+}
+
+// mflatt
+void wxMenu::Delete(int Id)
+{
+	Delete((wxMenu *)NULL, Id, -1);
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::Enable(int Id, Bool Flag)
+{
+	wxMenuItem* theMenuItem = FindItemForId(Id);
+	if (theMenuItem)
+		theMenuItem->Enable(Flag);
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::Check(int Id, Bool Flag)
+{
+	wxMenuItem* theMenuItem = FindItemForId(Id);
+	if (theMenuItem)
+		theMenuItem->Check(Flag);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxMenu::Checked(int Id)
+{
+	wxMenuItem* theMenuItem = FindItemForId(Id);
+	if (theMenuItem)
+		return theMenuItem->IsChecked();
+	else return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::SetTitle(char* label)
+{
+	if (menu_bar)
+	{
+		// WCH : must reset Macintosh menu label (not easy)
+		// WCH : the duplicate title in menuBar object may now be out of sync
+		MacChangeMenuText(this, label);
+	} else {
+	  if (title) delete title;
+	  title = macCopyString1(label);
+	}
+}
+
+//-----------------------------------------------------------------------------
+char* wxMenu::GetTitle(void) { return title; }
+
+//-----------------------------------------------------------------------------
+char* wxMenu::GetLabel(int Id)
+{
+	wxMenuItem* theMenuItem = FindItemForId(Id);
+	if (theMenuItem)
+		return theMenuItem->GetLabel();
+	else return NULL;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::SetLabel(int Id , char* label)
+{
+	wxMenuItem* theMenuItem = FindItemForId(Id);
+	if (theMenuItem)
+		theMenuItem->SetLabel(label);
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::SetSize(int x, int y, int width, int height) { }
+
+//-----------------------------------------------------------------------------
+void wxMenu::DoSetSize(int x, int y, int width, int height) { }
+
+//-----------------------------------------------------------------------------
+void wxMenu::Enable(Bool Flag)
+{
+	if (cEnable != Flag)
+	{
+		cEnable = Flag;
+		if (menu_bar)
+		{
+			wxFrame* frame = menu_bar->menu_bar_frame;
+			if (frame)
+			{
+				if (frame->IsFrontWindow())
+				{
+					if (cEnable)
+						EnableItem(cMacMenu, 0);
+					else
+						DisableItem(cMacMenu, 0);
+					::InvalMenuBar();
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::Show(Bool show) { }
+
+//-----------------------------------------------------------------------------
+char* wxMenu::GetLabel(void)
+{
+	return title; // WCH: confusion with title and label; cf. GetTitle
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::SetLabel(char* label) 
+{
+}
+
+//-----------------------------------------------------------------------------
+MenuHandle wxMenu::MacMenu(void) { return cMacMenu; }
+
+//-----------------------------------------------------------------------------
+short wxMenu::GetMacMenuId(void) { return cMacMenuId; }
+
+//-----------------------------------------------------------------------------
+wxMenu* wxMenu::wxMacFindSubmenu(int macMenuId)
+{
+	wxMenu* result = NULL;
+	wxNode* node = menuItems.First();
+	while (node && !result)
+	{
+		wxMenuItem* menuItem = (wxMenuItem*)node->Data();
+		wxMenu* submenu = menuItem->subMenu;
+		if (submenu)
+		{
+			if (submenu->cMacMenuId == macMenuId)
+				result = submenu;
+			else
+			{
+				result = submenu->wxMacFindSubmenu(macMenuId);
+			}
+		}
+
+		if (!result) node = node->Next();
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxMenu::wxMacInsertSubmenu(void)
+{
+	wxNode* node = menuItems.First();
+	while (node)
+	{
+		wxMenuItem* menuItem = (wxMenuItem*)node->Data();
+		wxMenu* submenu = menuItem->subMenu;
+		if (submenu)
+		{
+			InsertMenu(submenu->cMacMenu, -1);
+			submenu->wxMacInsertSubmenu();
+		}
+		node = node->Next();
+	}
+}
diff --git a/src/wxmac/src/mac/wx_messg.cc b/src/wxmac/src/mac/wx_messg.cc
new file mode 100644
index 0000000..76399fd
--- /dev/null
+++ b/src/wxmac/src/mac/wx_messg.cc
@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_messg.cc
+// Purpose:	Panel item message implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_item.h"
+#include "wx_gdi.h"
+#include "wx_messg.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+#include "wxLabelArea.h"
+#include <QuickDraw.h>
+#include <TextEdit.h>
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxMessage::wxMessage // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		char*		label,
+		int 		x,
+		int			y,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMessage(parentArea, x, y, 0, 0, style, windowName)
+{
+	CreateWxMessage(label);
+}
+
+//-----------------------------------------------------------------------------
+wxMessage::wxMessage // Constructor (given parentArea, font)
+	(
+		wxArea*		parentArea,
+		char*		label,
+		wxFont*		theFont,
+		int 		x,
+		int			y,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMessage(parentArea, x, y, 0, 0, style, windowName)
+{
+	CreateWxMessage(label, theFont);
+}
+
+//-----------------------------------------------------------------------------
+wxMessage::wxMessage // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		char*		label,
+		int 		x,
+		int			y,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMessage(parentPanel, x, y, 0, 0, style, windowName)
+{
+	CreateWxMessage(label);
+}
+
+//-----------------------------------------------------------------------------
+wxMessage::wxMessage // Constructor (given parentPanel, font)
+	(
+		wxPanel*	parentPanel,
+		char*		label,
+		wxFont*		theFont,
+		int 		x,
+		int			y,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMessage(parentPanel, x, y, 0, 0, style, windowName)
+{
+	CreateWxMessage(label, theFont);
+}
+
+wxMessage::wxMessage // Constructor (given parentPanel and bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxBitmap*	bitmap,
+		int 		x,
+		int			y,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMessage(parentPanel, x, y, 0, 0, style, windowName)
+{
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+	if (bitmap->Ok() && (bitmap->selectedIntoDC >= 0)) {
+		sBitmap = bitmap;
+		sBitmap->selectedIntoDC++;
+		cMessage = NULL;
+		if (cStyle & wxBORDER) new wxBorderArea(this);
+		SetClientSize(sBitmap->GetWidth(), sBitmap->GetHeight());
+	} else
+		CreateWxMessage("<bad-image>");
+}
+
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxMessage::~wxMessage(void)
+{
+	if (cMessage) delete [] cMessage;
+	if (sBitmap) --sBitmap->selectedIntoDC;
+	if (cParentArea->__type == wxTYPE_LABEL_AREA) {
+		// CJC hack? clean up label area so it does point to us, since its 
+		// about to go away.
+		wxLabelArea *pa = (wxLabelArea *)cParentArea;
+		pa->cLabelText = NULL;
+	}
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxMessage::CreateWxMessage(char* label, wxFont* theFont) // common constructor initialization
+{
+	if (cStyle & wxBORDER) new wxBorderArea(this);
+	sBitmap = NULL;
+	cMessage = wxItemStripLabel(label);
+	
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+
+	float clientWidth = 20;
+	float clientHeight = 14;
+	if (theFont) 
+		font = theFont;
+	if (!font) 
+		font = wxNORMAL_FONT; // WCH: kludge
+	if (font) {
+		font->GetTextExtent(cMessage, &clientWidth, &clientHeight, NULL, NULL);
+		if (font->GetStyle() != wxNORMAL || font->GetWeight() != wxNORMAL)
+			clientWidth += 5; //cjc - try hello.cc italic labels are truncated
+			//clientWidth += 0;	//tom and others
+	}
+	SetClientSize(clientWidth + 3, clientHeight); // mflatt: +3 is needed (even for plain)
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+
+//-----------------------------------------------------------------------------
+void wxMessage::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+char* wxMessage::GetLabel(void)
+{
+	if (cMessage) {
+	  strcpy(wxBuffer, cMessage);
+	  return wxBuffer;
+	} else
+	  return "";
+}
+
+//-----------------------------------------------------------------------------
+void wxMessage::SetLabel(wxBitmap *bitmap)
+{
+	if (!sBitmap || !bitmap->Ok() || (bitmap->selectedIntoDC < 0))
+	  return;
+
+    --sBitmap->selectedIntoDC;
+	sBitmap = bitmap;
+	sBitmap->selectedIntoDC++;
+	
+	// erase the old
+	SetCurrentDC();
+	int clientWidth, clientHeight;
+	GetClientSize(&clientWidth, &clientHeight);
+	Rect clientRect = {0, 0, clientHeight, clientWidth};
+	::InvalRect(&clientRect);
+
+//FIXME CJC	SetClientSize(sBitmap->GetWidth(), sBitmap->GetHeight());
+	sBitmap->DrawMac();
+}
+
+//-----------------------------------------------------------------------------
+void wxMessage::SetLabel(char* label)
+{
+	if (sBitmap) return;
+    if (cMessage) delete [] cMessage;
+	cMessage = macCopyString0(label);
+	if (!cHidden) {
+#if 0
+		SetCurrentDC();
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+#else
+		Paint();
+#endif
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxMessage::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+	int clientWidth, clientHeight;
+	GetClientSize(&clientWidth, &clientHeight);
+	Rect clientRect = {0, 0, clientHeight, clientWidth};
+	::EraseRect(&clientRect);
+
+	if (sBitmap) {
+		sBitmap->DrawMac();
+	} else {
+		::TextBox(cMessage, strlen(cMessage), &clientRect, teJustLeft);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxMessage::DoShow(Bool show) 
+{
+	wxWindow::DoShow(show);
+}
+
+void wxMessage::ChangeToGray(Bool gray)
+{
+  wxWindow::ChangeToGray(gray);
+}
+
diff --git a/src/wxmac/src/mac/wx_mf.cc b/src/wxmac/src/mac/wx_mf.cc
new file mode 100644
index 0000000..beac63d
--- /dev/null
+++ b/src/wxmac/src/mac/wx_mf.cc
@@ -0,0 +1,69 @@
+/*
+ * File:        wx_mf.cc
+ * Purpose:     Metafiles and metafile DCs (X version)
+ * Author:      Julian Smart
+ * Created:     1993
+ * Updated:	August 1994
+ * RCS_ID:      $Id: wx_mf.cc,v 1.3 1994/08/14 21:28:43 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+static const char sccsid[] = "@(#)wx_mf.cc	1.2 5/9/94";
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "common.h"
+
+#if USE_METAFILE
+
+#include "wx_mf.h"
+
+/*
+ * Metafiles - Windows 3.1 only
+ * Currently, the only purpose for making a metafile is to put
+ * it on the clipboard.
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject)
+
+wxMetaFile::wxMetaFile (void)
+{
+}
+
+wxMetaFile::~wxMetaFile (void)
+{
+}
+
+Bool wxMetaFile::SetClipboard (int width, int height)
+{
+  return FALSE;
+}
+
+/*
+ * Metafile device context: not implemented yet.
+ *
+ */
+
+IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC)
+
+wxMetaFileDC::wxMetaFileDC (char *file)
+{
+  ok = FALSE;
+}
+
+wxMetaFileDC::~wxMetaFileDC (void)
+{
+}
+
+wxMetaFile *wxMetaFileDC::Close (void)
+{
+  return NULL;
+}
+
+void wxMetaFileDC::SetMapMode (int mode)
+{
+}
+
+#endif // USE_METAFILE
diff --git a/src/wxmac/src/mac/wx_mnuit.cc b/src/wxmac/src/mac/wx_mnuit.cc
new file mode 100644
index 0000000..216a1db
--- /dev/null
+++ b/src/wxmac/src/mac/wx_mnuit.cc
@@ -0,0 +1,155 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_mnuit.cc (split from wx_item.cc)
+// Purpose:	Menu items implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_mnuit.h"
+#include "wx_menu.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Constructors
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxMenuItem::wxMenuItem
+(
+	void
+) :
+	parentMenu (NULL),
+	checkable (FALSE),
+	cIsChecked (FALSE),
+	cIsEnabled (TRUE)
+{
+	WXGC_IGNORE(parentMenu);
+}
+
+wxMenuItem::wxMenuItem
+(
+	wxMenu* theParentMenu,
+	Bool	isCheckable
+) :
+	parentMenu (theParentMenu),
+	checkable (isCheckable),
+	cIsChecked (FALSE),
+	cIsEnabled (TRUE)
+{
+	if (!theParentMenu) wxFatalError("No parent menu for constructing menu item.");
+	WXGC_IGNORE(parentMenu);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Destructor
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxMenuItem::~wxMenuItem(void)
+{
+	if (parentMenu)
+	{
+		// Must detach this from parent menu
+	}
+
+	if (subMenu)
+	{
+		// Must detach submenu from this
+		// Must delete submenu
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// tree methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxMenu* wxMenuItem::ParentMenu(void) { return parentMenu; }
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxMenuItem::Check(Bool flag)
+{
+	if (checkable)
+	{
+		if (cIsChecked != flag)
+		{
+			cIsChecked = flag;
+			short macMenuItem = GetMacItemNumber();
+			if (macMenuItem > 0)
+			{
+				CheckItem(parentMenu->MacMenu(), macMenuItem, cIsChecked);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxMenuItem::IsChecked(void) { return cIsChecked; }
+
+//-----------------------------------------------------------------------------
+Bool wxMenuItem::IsCheckable(void) { return checkable; }
+
+//-----------------------------------------------------------------------------
+void wxMenuItem::Enable(Bool flag)
+{
+	if (cIsEnabled != flag)
+	{
+		cIsEnabled = flag;
+		short macMenuItem = GetMacItemNumber();
+		if (macMenuItem > 0)
+		{
+			if (cIsEnabled)
+				 EnableItem(parentMenu->MacMenu(), macMenuItem);
+			else DisableItem(parentMenu->MacMenu(), macMenuItem);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+char* wxMenuItem::GetHelpString(void) { return helpString; }
+
+//-----------------------------------------------------------------------------
+void wxMenuItem::SetHelpString(char* theHelpString)
+{
+    if (helpString) delete[] helpString;
+    helpString = macCopyString(theHelpString);
+}
+
+//-----------------------------------------------------------------------------
+char* wxMenuItem::GetLabel(void) {  return itemName; }
+
+//-----------------------------------------------------------------------------
+void wxMenuItem::SetLabel(char* label)
+{
+    if (itemName) delete[] itemName;
+    itemName = macCopyString(label);
+
+	short macMenuItem = GetMacItemNumber();
+	if (macMenuItem > 0)
+	{
+		wxMacString1 theMacString1 = label;
+		SetItem(parentMenu->MacMenu(), macMenuItem, theMacString1());
+	}
+}
+
+//-----------------------------------------------------------------------------
+short wxMenuItem::GetMacItemNumber(void) // mac platform only
+{
+	short result = 0;
+	if (parentMenu)
+	{
+		long memberIndex = parentMenu->menuItems.MemberIndex(this);
+		if (memberIndex >= 0) result = memberIndex + 1; // mac counts from one
+	}
+
+	return result; // zero result means not found
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_mtxt.cc b/src/wxmac/src/mac/wx_mtxt.cc
new file mode 100644
index 0000000..91472b9
--- /dev/null
+++ b/src/wxmac/src/mac/wx_mtxt.cc
@@ -0,0 +1,91 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_mtxt.cc
+// Purpose:	Panel item multiText implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+#include "wx_item.h"
+#include "wx_mtxt.h"
+#include "wx_utils.h"
+#include <Memory.h>
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxMultiText::wxMultiText // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		char*		value,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbMultiText (parentPanel, function, label, value,
+						x, y, width, (height != -1) ? height : 100,
+						style|wxMULTIPLE, windowName)
+{
+  	// tom: set in multiple line mode
+ 	HLock((Handle)cMacTE);
+ 	(*cMacTE)->crOnly=1;
+ 	HUnlock((Handle)cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+wxMultiText::wxMultiText // Constructor (given parentTextWindow)
+	(
+		wxTextWindow*	parentTextWindow,
+		wxFunction		function,
+		char*			label,
+		char*			value,
+		int 			x,
+		int				y,
+		int				width,
+		int				height,
+		long			style,
+		char*			windowName,
+		WXTYPE			objectType
+	) :
+		wxbMultiText (parentTextWindow, function, label, value,
+						x, y, width, (height != -1) ? height : 100,
+						style|wxMULTIPLE, windowName)
+{
+ 	// tom: set it in multiple line mode
+ 	HLock((Handle)cMacTE);
+ 	(*cMacTE)->crOnly=1;
+ 	HUnlock((Handle)cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+void wxMultiText::GetValue(char* buffer, int maxSize)
+{
+	if (maxSize <= 0) return; // WCH: maxSize should be tested (better: use unsigned int?)
+
+	CharsHandle theMacText = ::TEGetText(cMacTE);
+	int theMacTextLength = (**cMacTE).teLength;
+	if (theMacTextLength > 0)
+	{
+		int moveSize = ( theMacTextLength > (maxSize - 1) ) ?
+						maxSize - 1 : theMacTextLength;
+		BlockMove(*theMacText, buffer, moveSize);
+		buffer[moveSize] = 0; // terminate "C" string
+	}
+	else buffer[0] = 0;
+}
+
+char* wxMultiText::GetValue(void) 
+{
+	this->GetValue(wxBuffer, 1500);			// FIXME - HACK - should have constant for bufsize
+	return wxBuffer;
+}
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_panel.cc b/src/wxmac/src/mac/wx_panel.cc
new file mode 100644
index 0000000..a753909
--- /dev/null
+++ b/src/wxmac/src/mac/wx_panel.cc
@@ -0,0 +1,447 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_panel.cc
+// Purpose:	wxPanel class implementation (Mac version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_panel.h"
+#include "wx_frame.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+#include "wxRectBorder.h"
+#include "wxMacDC.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxPanel::wxPanel // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbPanel (windowName, parentArea, x, y, width, height, style)
+{
+	CreateWxPanel();
+}
+
+//-----------------------------------------------------------------------------
+wxPanel::wxPanel // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbPanel (windowName, parentFrame, x, y, width, height, style)
+{
+	CreateWxPanel();
+}
+
+//-----------------------------------------------------------------------------
+wxPanel::wxPanel // Constructor (given parentPanel)
+	(
+		wxPanel*	parentPanel,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbPanel (windowName, parentPanel, x, y, width, height, style)
+{
+	CreateWxPanel();
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxPanel::~wxPanel(void)
+{
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxPanel::CreateWxPanel(void) // common constructor initialization
+{
+	InitDefaults();
+
+	SetEraser(wxCONTROL_BACKGROUND_BRUSH);
+
+	if (cStyle & wxBORDER) 
+	  cPanelBorder = new wxBorderArea(this, 1, Direction::wxAll, 1);
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::InitDefaults(void)
+{
+	// For absolute-positioning auto layout
+	cursor_x = PANEL_LEFT_MARGIN;
+	cursor_y = PANEL_TOP_MARGIN;
+	max_width = 0;
+	max_height = 0;
+	max_line_height = 0;
+	currentRow = 0;
+	currentCol = 0;
+	last_created = NULL;
+	cPanelBorder = NULL;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Item placement methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxPanel::NewLine(void)
+{
+	AdvanceCursor(NULL); // Kludge (new DESIGN)
+	cursor_x = initial_hspacing;
+    cursor_y = max_height + vSpacing;
+    if (cursor_y > max_height) max_height = cursor_y;
+    max_line_height = 0;
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::NewLine(int pixels)
+{
+	AdvanceCursor(NULL); // Kludge (new DESIGN)
+	cursor_x = initial_hspacing;
+    cursor_y = max_height + pixels;
+    if (cursor_y > max_height) max_height = cursor_y;
+    max_line_height = 0;
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::Tab(void)
+{
+	AdvanceCursor(NULL); // Kludge (new DESIGN)
+	cursor_x += hSpacing;
+	if (cursor_x > max_width) max_width = cursor_x;
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::Tab(int pixels)
+{
+	AdvanceCursor(NULL); // Kludge (new DESIGN)
+	cursor_x += pixels;
+	if (cursor_x > max_width) max_width = cursor_x;
+}
+
+//-----------------------------------------------------------------------------
+int wxPanel::GetHorizontalSpacing(void) { return hSpacing; }
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetHorizontalSpacing(int sp)
+{
+	hSpacing = sp;
+	current_hspacing = sp;
+}
+
+//-----------------------------------------------------------------------------
+int wxPanel::GetVerticalSpacing(void) { return vSpacing; }
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetVerticalSpacing(int sp)
+{
+	vSpacing = sp;
+	current_vspacing = sp;
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::GetCursor(int* x, int* y)
+{
+	AdvanceCursor(NULL);
+	*x = cursor_x;
+	*y = cursor_y;
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetItemCursor(int x, int y)
+{
+	last_created = NULL;
+	cursor_x = x;
+	cursor_y = y;
+}
+
+//-----------------------------------------------------------------------------
+// Update next cursor position
+//-----------------------------------------------------------------------------
+void wxPanel::AdvanceCursor(wxWindow* item)
+{
+//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+// Major design change: I calculate cursor_x, cursor_y based on last_created,
+//                      and I store the current item, for next time.
+//
+// In this way, I can change the size of the current item without harm.
+// When I start a new item, the last_created should have correct size by then.
+//
+//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+	if (last_created) // Kludge (new DESIGN)
+	{
+		int width, height;
+		int x, y;
+		last_created->GetSize(&width, &height);
+		last_created->GetPosition(&x, &y);
+	
+		if ((x + width) > max_width) max_width = x + width;
+		if ((y + height) > max_height) max_height = y + height;
+		if (height > max_line_height) max_line_height = height;
+	
+		cursor_x = x + width + hSpacing;
+		cursor_y = y;
+	}
+
+	last_created = item;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxPanel::Centre(int direction)
+{
+	int width, height, panel_width, panel_height, new_x, new_y;
+
+	wxPanel* father = (wxPanel*)GetParent();
+	if (!father) return;
+
+	father->GetClientSize(&panel_width, &panel_height);
+	GetSize(&width, &height);
+
+	new_x = cWindowX;
+	new_y = cWindowY;
+
+	if (direction & wxHORIZONTAL)
+		new_x = (int)((panel_width - width)/2);
+
+	if (direction & wxVERTICAL)
+		new_y = (int)((panel_height - height)/2);
+
+	SetSize(new_x, new_y, cWindowWidth, cWindowHeight, wxPOS_USE_MINUS_ONE);
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::Fit(void)
+{ // Fit panel around its items
+	int maxX = 0;
+	int maxY = 0;
+	wxChildNode* childWindowNode = ClientArea()->Windows()->First();
+	while (childWindowNode)
+	{
+		wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+		int x, y, w, h;
+		childWindow->GetPosition(&x, &y);
+		childWindow->GetSize(&w, &h);
+		if ((x + w) > maxX) maxX = x + w;
+		if ((y + h) > maxY) maxY = y + h;
+		childWindowNode = childWindowNode->Next();
+	}
+
+	SetClientSize(maxX + initial_hspacing, maxY + initial_vspacing);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  //-----------------------------------------------------------------------------
+  // tom: new two are needed to be able to destroy children and be able to
+  // insert a new child afterwards
+ 
+void wxPanel::DestroyChildren(void) 
+{
+	wxWindow::DestroyChildren();
+	last_created = NULL;
+}
+ 
+void wxPanel::OnDeleteChild(wxWindow* win) 
+{
+	if (last_created==win)
+		last_created = NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+void wxPanel::AddChild(wxObject* child) // WCH: why isn't the type wxWindow*?
+{
+	if (((wxWindow*)child)->ParentArea() == cClientArea) // WCH: kludge
+	{
+		if (!has_child)
+		{
+			initial_hspacing = cursor_x; // WCH: not quite correct
+			initial_vspacing = cursor_y; // WCH: not quite correct
+			has_child = TRUE;
+		}
+		AdvanceCursor((wxWindow*)child); // WCH: want AddChild(wxWindow* child)
+	}
+
+	children->Append(child);
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetBackgroundColour(wxColour*col)
+{
+	backColour = col;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetLabelColour(wxColour*col)
+{
+	labelColour = col;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::SetButtonColour(wxColour*col)
+{
+	buttonColour = col;
+	ChangeColour();
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+    if (cPanelBorder)
+	  ((wxBorderArea *)cPanelBorder)->cBorder->DoShow(show);
+
+	wxNode* areaNode = cAreas.First();
+	while (areaNode)
+	{
+		wxArea* area = (wxArea*)areaNode->Data();
+		wxChildNode* childWindowNode = area->Windows()->First();
+		while (childWindowNode)
+		{
+			wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+			childWindow->DoShow(show);
+			childWindowNode = childWindowNode->Next();
+		}
+		areaNode = areaNode->Next();
+	}
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::Paint(void)
+{
+	if (cHidden) return;
+	wxCanvas::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxPanel::OnChar(wxKeyEvent& event)
+ {
+ 	switch (event.keyCode)
+	{
+ 		case 0x03:	// enter
+ 		case 0x0D:	// return
+ 			OnDefaultAction(NULL);
+ 			return;
+
+ 		case 0x09:	// tab
+ 		{
+ 			// Step through panel items that want focus
+ 			wxFrame* rootFrame = GetRootFrame();
+ 			wxWindow* currentWindow = rootFrame->GetFocusWindow();
+ 			wxChildNode* childWindowNode;
+ 			wxWindow* childWindow;
+ 			wxWindow* wrapWindow = NULL;
+
+ 			// Tab steps forward, Shift-Tab steps backwards
+ 			Bool backwards = event.shiftDown;
+#if 0
+ 			if (backwards)
+ 				childWindowNode = cClientArea->Windows()->Last();
+ 			else
+#endif
+ 				childWindowNode = cClientArea->Windows()->First();
+
+ 			// Find current focus window
+ 			while (childWindowNode)
+ 			{
+ 				childWindow = (wxWindow*)childWindowNode->Data();
+ 				// In case we end up wrapping
+ 				if (!wrapWindow && childWindow->WantsFocus() && childWindow->CanAcceptEvent())
+ 					wrapWindow = childWindow;
+ 				// We actually want to be positioned one after/before the current window
+#if 0
+ 				if (backwards)
+ 					childWindowNode = childWindowNode->Previous();
+ 				else
+#endif
+ 					childWindowNode = childWindowNode->Next();
+ 				if (childWindow  == currentWindow)
+ 					break;
+ 			}
+ 			// Look for next window in chain that wants focus
+ 			while (childWindowNode)
+ 			{
+ 				childWindow = (wxWindow*)childWindowNode->Data();
+				if (childWindow->WantsFocus() && childWindow->CanAcceptEvent())
+ 					break;
+#if 0 					
+ 				if (backwards)
+ 					childWindowNode = childWindowNode->Previous();
+ 				else
+#endif 
+ 					childWindowNode = childWindowNode->Next();
+ 			}
+ 			// Set new focus window
+ 			rootFrame->SetFocusWindow((childWindowNode)?childWindow:wrapWindow);
+			return;
+ 		}
+
+ 		default:
+ 			break;
+ 	}
+ }
+
+
+Bool wxPanel::WantsFocus()
+{
+	return TRUE;
+}
+
+void wxPanel::ChangeToGray(Bool gray)
+{
+	ChildrenInternalGray(gray);
+	wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_print.cc b/src/wxmac/src/mac/wx_print.cc
new file mode 100644
index 0000000..3491bed
--- /dev/null
+++ b/src/wxmac/src/mac/wx_print.cc
@@ -0,0 +1,1203 @@
+/*
+ * File:        wx_print.cc
+ * Purpose:     Printer implementation (mac)
+ * Author:      Lj Birk (original msw by Julian Smart
+ * Created:     1995
+ * Updated:	October 1995
+ * Copyright:   (c) 1995, AIAI, University of Edinburgh
+ */
+
+#if !defined(_MSC_VER) && !defined(wx_wxh)
+#define wx_wxh
+#endif
+
+#include "wx.h"
+#ifndef wx_mac
+#pragma hdrstop
+#endif
+
+#ifdef testbmp
+#include <tagobj.h>
+#endif
+
+#include "common.h"
+
+#if USE_PRINTING_ARCHITECTURE
+#if USE_COMMON_DIALOGS
+
+#include "wx_utils.h"
+#include "wx_print.h"
+#include "wx_dc.h"
+#include "wx_dcpr.h"
+#include "wx_main.h"
+#include "wx_frame.h"
+#include "wx_buttn.h"
+#include "wx_dcmem.h"
+#include "wx_messg.h"
+
+#include <stdlib.h>
+#ifndef wx_mac
+#include <commdlg.h>
+#endif
+
+#ifdef wx_mac
+#include "wx_dcps.h"
+#endif
+
+
+void printIdle(void);
+
+#ifdef	NO_UNIVERSAL
+
+ProcPtr printIdleUPP = (ProcPtr)&printIdle;
+extern ProcPtr printIdleUPP;
+
+#else	// ifdef NO_UNIVERSAL
+
+extern PrIdleUPP printIdleUPP;
+
+// Have universal headers, compiling PPC
+#define ppcPPC 1
+#ifdef ppcPPC
+RoutineDescriptor printIdleRD =
+BUILD_ROUTINE_DESCRIPTOR(uppPrIdleProcInfo,printIdle);
+PrIdleUPP printIdleUPP=(PrIdleUPP)&printIdleRD;
+
+#else	// ifdef __powerpc__
+
+// Have universal headers, compiling 68K
+PrIdleUPP printIdleUPP=(PrIdleUPP)&printIdle;
+
+#endif
+
+#endif
+
+
+wxPrintDialog::wxPrintDialog(wxWindow *p, wxPrintData *data):
+ wxDialogBox((wxFrame *)p, "Printer Dialog")
+{
+  dialogParent = p;
+  printerDC = NULL;
+  destroyDC = TRUE;
+  deviceName = NULL;
+  driverName = NULL;
+  portName = NULL;
+
+  if (data)
+    printData = *data;
+
+}
+
+wxPrintDialog::~wxPrintDialog(void)
+{
+  if (destroyDC && printerDC)
+    delete printerDC;
+  if (deviceName) delete[] deviceName;
+  if (driverName) delete[] driverName;
+  if (portName) delete[] portName;
+  printData.macPrData = 0; // this is so ~wxPrintData wont delete THPrint
+}
+
+void wxPrintDialog::Show(Bool flag)
+{
+
+  Bool prtJob = FALSE;
+  short strp, endp;
+
+	/* MATTHEW: [6] */
+#if 0
+  endp = (**printData.macPrData).prJob.iLstPage;
+  strp = (**printData.macPrData).prJob.iFstPage;
+#endif
+
+  PrOpen();
+
+  PrValidate( printData.macPrData);
+
+  if (PrError() != fnfErr) {
+    prtJob = PrJobDialog(printData.macPrData);
+    if (!prtJob)
+    {
+       (**printData.macPrData).prJob.iLstPage = 0;
+       (**printData.macPrData).prJob.iFstPage = 0;
+       PrClose();
+       return;
+    }
+  }
+
+  if (PrError())
+    DisposeHandle((Handle)printData.macPrData);
+
+  PrClose();
+
+}
+
+wxDC *wxPrintDialog::GetPrintDC(void)
+{
+  if (printerDC)
+  {
+    destroyDC = FALSE;
+    return printerDC;
+  }
+  else
+    return NULL;
+}
+
+/*
+ * Print data
+ */
+
+wxPrintData::wxPrintData(void)
+{
+  THPrint pd = (THPrint)NewHandleClear(sizeof(TPrint));
+  CheckMemOK(pd);
+  macPrData = pd;
+  
+  /* MATTHEW: [6] */
+  PrintDefault(macPrData);
+}
+
+wxPrintData::~wxPrintData(void)
+{
+  if (macPrData)
+    DisposeHandle((Handle)macPrData);
+}
+
+void wxPrintData::SetAbortFlag()
+{
+	  (**macPrData).prJob.fFromUsr=TRUE;
+}
+
+int wxPrintData::GetFromPage(void)
+{
+  return (**macPrData).prJob.iFstPage;
+}
+
+int wxPrintData::GetToPage(void)
+{
+  return (**macPrData).prJob.iLstPage;
+}
+
+int wxPrintData::GetMinPage(void)
+{
+  return (**macPrData).prJob.iFstPage;
+}
+
+int wxPrintData::GetMaxPage(void)
+{
+  return (**macPrData).prJob.iLstPage;
+}
+
+int wxPrintData::GetNoCopies(void)
+{
+  return (**macPrData).prJob.iCopies;
+}
+
+Bool wxPrintData::GetAllPages(void)
+{
+  return ( GetMaxPage() == (**macPrData).prJob.iLstPage);
+}
+
+Bool wxPrintData::GetCollate(void)
+{
+  return FALSE;
+}
+
+/*
+wxDC *wxPrintData::GetDC(void)
+{
+  if (printerDC)
+  {
+    destroyDC = FALSE;
+    return printerDC;
+  }
+  else
+    return NULL;
+}
+*/
+
+void wxPrintData::SetFromPage(int p)
+{
+  (**macPrData).prJob.iFstPage = p;
+}
+
+void wxPrintData::SetToPage(int p)
+{
+  (**macPrData).prJob.iLstPage = p;
+}
+
+void wxPrintData::SetMinPage(int p)
+{
+  (**macPrData).prJob.iFstPage = p;
+}
+
+void wxPrintData::SetMaxPage(int p)
+{
+  (**macPrData).prJob.iLstPage = p;
+}
+
+void wxPrintData::SetNoCopies(int c)
+{
+  (**macPrData).prJob.iCopies = c;
+}
+
+void wxPrintData::SetAllPages(Bool flag)
+{
+}
+
+void wxPrintData::SetCollate(Bool flag)
+{
+}
+
+void wxPrintData::SetPrintToFile(Bool flag)
+{
+  //(**macPrData).
+}
+
+void wxPrintData::EnablePrintToFile(Bool flag)
+{
+}
+
+void wxPrintData::EnableSelection(Bool flag)
+{
+}
+
+void wxPrintData::EnablePageNumbers(Bool flag)
+{
+}
+
+void wxPrintData::EnableHelp(Bool flag)
+{
+}
+
+void wxPrintData::SetSetupDialog(Bool flag)
+{
+// page setup menu item
+//  PrOpen();
+//  PrStlDialog(printData.macPrData);
+//  PrClose();
+}
+
+void wxPrintData::operator=(const wxPrintData& data)
+{
+   this->macPrData = data.macPrData;
+}
+
+/*
+ * Printer
+ */
+ 
+wxPrinter::wxPrinter(wxPrintData *data)
+{
+  currentPrintout = NULL;
+  abortWindow = NULL;
+  abortIt = FALSE;
+  if (data)
+    printData = (*data);
+  //lpAbortProc = MakeProcInstance((FARPROC) wxAbortProc, wxhInstance);
+}
+
+wxWindow *wxPrinter::abortWindow = NULL;
+Bool wxPrinter::abortIt = FALSE;
+
+wxPrinter::~wxPrinter(void)
+{
+  //FreeProcInstance(lpAbortProc);
+}
+
+Bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, Bool prompt)
+{
+  abortIt = FALSE;
+  abortWindow = NULL;
+
+  if (!printout)
+    return FALSE;
+    
+  printout->SetIsPreview(FALSE);
+  printout->OnPreparePrinting();
+
+  // Get some parameters from the printout, if defined
+  int fromPage, toPage;
+  int minPage, maxPage;
+  printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
+
+  if (maxPage == 0)
+    return FALSE;
+
+  PrOpen();
+  if (PrError() != fnfErr) {
+    PrintDefault(printData.macPrData);
+  }
+
+  printData.SetMinPage(minPage);
+  printData.SetMaxPage(maxPage);
+  if (fromPage != 0)
+    printData.SetFromPage(fromPage);
+  if (toPage != 0)
+    printData.SetToPage(toPage);
+
+  if (minPage != 0)
+  {
+    printData.EnablePageNumbers(TRUE);
+    if (printData.GetFromPage() < printData.GetMinPage())
+      printData.SetFromPage(printData.GetMinPage());
+    else if (printData.GetFromPage() > printData.GetMaxPage())
+      printData.SetFromPage(printData.GetMaxPage());
+    if (printData.GetToPage() > printData.GetMaxPage())
+      printData.SetToPage(printData.GetMaxPage());
+    else if (printData.GetToPage() < printData.GetMinPage())
+      printData.SetToPage(printData.GetMinPage());
+  }
+  else
+    printData.EnablePageNumbers(FALSE);
+  
+  // Create a suitable device context  
+  wxDC *dc = NULL;
+  if (prompt)
+  {
+    // create a mac dc with a printer port
+    // may need to create a dccan in order to draw
+    // and set the dc as a print dc
+    wxPrintDialog *dialog = new wxPrintDialog(parent, &printData);
+    dialog->Show(TRUE);
+    delete dialog;
+    //printData = dialog.GetPrintData();
+  }
+
+  // sanity check  
+  if (printData.GetFromPage() <= 0 || 
+      printData.GetToPage() <= 0)
+  {
+    PrClose();
+    return FALSE;
+  }
+  
+    //dc = new wxPrinterDC(NULL, NULL, NULL, FALSE);
+  dc = new wxPrinterDC(printData.macPrData); 
+
+  // May have pressed cancel.
+  if (!dc || !dc->Ok())
+  {
+    if (dc) delete dc; // PrSetError
+    PrClose();
+    return FALSE;
+  }
+
+  GDHandle gThisGDevice = GetMainDevice();
+  int logPPIScreenX = (int)Fix2Long((**(**gThisGDevice).gdPMap).hRes);
+  int logPPIScreenY = (int)Fix2Long((**(**gThisGDevice).gdPMap).vRes);
+
+  printout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
+
+  int logPPIPrinterX = (**(printData.macPrData)).prInfo.iHRes;  //::GetDeviceCaps(dc->cdc, LOGPIXELSX);
+  int logPPIPrinterY = (**(printData.macPrData)).prInfo.iVRes;  //::GetDeviceCaps(dc->cdc, LOGPIXELSY);
+
+  printout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
+
+  // Set printout parameters  
+  printout->SetDC(dc);
+
+///// TODO figure the equivalent
+  float w, h;
+  dc->GetSize(&w, &h);
+  printout->SetPageSizePixels((int)w, (int)h);
+  //dc->GetSizeMM(&w, &h);
+  dc->GetSize(&w, &h);
+  printout->SetPageSizeMM((int)w, (int)h);
+
+  // Create an abort window
+  //wxBeginBusyCursor();
+  wxWindow *win = CreateAbortWindow(parent, printout);
+  //wxYield();
+  //::SetAbortProc(dc->cdc, lpAbortProc);
+  
+  if (!win)
+  {
+ //   wxEndBusyCursor();
+    wxMessageBox("Sorry, could not create an abort dialog.", "Print Error", wxOK, (wxFrame *)parent);
+    delete dc;
+    PrClose();
+	return FALSE;
+  }
+  abortWindow = win;
+  abortWindow->Show(TRUE);
+ // wxYield();
+
+  //(**printData.macPrData).prJob.pIdleProc = printIdleUPP;
+
+  printout->OnBeginPrinting();
+  
+  Bool keepGoing = TRUE;
+
+  for (int copyCount = 1; copyCount <= printData.GetNoCopies(); copyCount ++)
+  {
+    if (!printout->OnBeginDocument(printData.GetFromPage(), printData.GetToPage()))
+    {
+      //wxEndBusyCursor();
+      wxMessageBox("Could not start printing.", "Print Error");
+      break;
+    }
+    if (abortIt) {
+      printData.SetAbortFlag();
+      wxDialogBox *dialog = new wxDialogBox(parent, "Print Aborted", 0, 0, 400, 400);
+      break;
+    }
+
+    for (int pn = printData.GetFromPage(); 
+             keepGoing && 
+             (pn <= printData.GetToPage()) && printout->HasPage(pn);
+         pn++)
+    {
+      if (abortIt)
+      {
+        printData.SetAbortFlag();
+        wxDialogBox *dialog = new wxDialogBox(parent, "Print Aborted", 0, 0, 400, 400);
+        keepGoing = FALSE;
+        break;
+      }
+      else
+      {
+        dc->StartPage();
+        printout->OnPrintPage(pn);
+        dc->EndPage();
+      }
+    }
+    printout->OnEndDocument();
+  }
+
+  printout->OnEndPrinting();
+
+  if (abortWindow)
+  {
+    abortWindow->Show(FALSE);
+    delete abortWindow;
+    abortWindow = NULL;
+  }
+  
+  //wxEndBusyCursor();
+
+  delete dc;
+  
+  PrClose();
+
+  return TRUE;
+}
+
+Bool wxPrinter::PrintDialog(wxWindow *parent)
+{
+  wxPrintDialog *dialog = new wxPrintDialog(parent, &printData);
+  dialog->Show(TRUE);
+  delete dialog;
+  return 0;
+}
+// TODO make this a UPP and stuf in THPrintPtr
+static void wxAbortWindowCancel(wxButton& but, wxCommandEvent& event)
+{
+  wxPrinter::abortIt = TRUE;
+  wxPrinter::abortWindow->Show(FALSE);
+  delete wxPrinter::abortWindow;
+  wxPrinter::abortWindow = NULL;
+}
+
+wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
+{
+    //wxMessageBox("Printing, please wait.", "Printing", wxOK, (wxFrame *)parent);
+
+  wxDialogBox *dialog = new wxDialogBox(parent, "Printing", FALSE, 0, 0, 400, 400);
+  wxMessage *message = new wxMessage(dialog, "Press Cmd-. to stop printing");
+  dialog->Fit();
+
+  dialog->Centre(wxBOTH);
+  
+  return dialog;
+}
+
+Bool wxPrinter::Setup(wxWindow *parent)
+{
+  wxPrintDialog *dialog = new wxPrintDialog(parent, &printData);
+  dialog->GetPrintData().SetSetupDialog(TRUE);
+  dialog->Show(TRUE);
+  delete dialog;
+  return 0;
+}
+
+void wxPrinter::ReportError(wxWindow *parent, wxPrintout *printout, char *message)
+{
+  wxMessageBox(message, "Printing Error", wxOK, (wxFrame *)parent);
+}
+
+wxPrintData &wxPrinter::GetPrintData(void)
+{
+  return printData;
+}
+
+/*
+ * Printout class
+ */
+ 
+wxPrintout::wxPrintout(char *title)
+{
+  printoutTitle = title ? copystring(title) : NULL;
+  printoutDC = NULL;
+  pageWidthMM = 0;
+  pageHeightMM = 0;
+  pageWidthPixels = 0;
+  pageHeightPixels = 0;
+  PPIScreenX = 0;
+  PPIScreenY = 0;
+  PPIPrinterX = 0;
+  PPIPrinterY = 0;
+  isPreview = FALSE;
+}
+
+wxPrintout::~wxPrintout(void)
+{
+  if (printoutTitle)
+    delete[] printoutTitle;
+}
+
+Bool wxPrintout::OnBeginDocument(int startPage, int endPage)
+{
+  return GetDC()->StartDoc("Printing");
+}
+
+void wxPrintout::OnEndDocument(void)
+{
+  GetDC()->EndDoc();
+}
+
+void wxPrintout::OnBeginPrinting(void)
+{
+}
+
+void wxPrintout::OnEndPrinting(void)
+{
+}
+
+Bool wxPrintout::HasPage(int page)
+{
+  return (page == 1);
+}
+
+void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
+{
+  *minPage = 1;
+  *maxPage = 32000;
+  *fromPage = 1;
+  *toPage = 1;
+}
+
+/****************************************************************************
+
+    FUNCTION: wxAbortProc()
+
+    PURPOSE:  Processes messages for the Abort Dialog box
+
+****************************************************************************/
+
+void printIdle(void)
+{
+	EventRecord theEvent;
+	while (GetNextEvent(24,&theEvent)) {
+		if ((theEvent.modifiers & cmdKey) &&
+			(theEvent.message & 0xff) =='.') 
+		    wxPrinter::abortIt = TRUE;
+		}
+}
+
+
+
+/*
+ * Preview canvas
+ */
+ 
+wxPreviewCanvas::wxPreviewCanvas(wxPrintPreview *preview, wxWindow *parent, int x, int y, int w, int h,
+    long style, char *name):
+ wxCanvas((wxFrame*)parent, x, y, w, h, style, name)
+{
+  printPreview = preview;
+  if (!previewBackgroundBrush)
+    previewBackgroundBrush = wxTheBrushList->FindOrCreateBrush("THISTLE", wxSOLID);
+  SetBackground(previewBackgroundBrush);
+  SetScrollbars(40, 40, 50, 50, 8, 8);
+  //SetScrollbars(30, 30, 30, 30, 8, 8);
+}
+
+wxBrush *wxPreviewCanvas::previewBackgroundBrush = NULL;
+
+wxPreviewCanvas::~wxPreviewCanvas(void)
+{
+}
+
+void wxPreviewCanvas::Paint(void)
+{
+  wxCanvas::Paint();
+
+ /*
+  int w, h;
+  GetSize(&w, &h);
+  wxDC *dc = GetDC();
+  dc->SetPen(wxBLACK_PEN);
+  dc->SetBrush(wxTRANSPARENT_BRUSH);
+  DrawLine(0, h-1, w, h-1);
+*/
+
+
+  if (printPreview)
+    printPreview->PaintPage(this);
+}
+
+void wxPreviewCanvas::OnEvent(wxMouseEvent& event)
+{
+}
+
+void wxPreviewCanvas::OnChar(wxKeyEvent& event)
+{
+}
+
+/*
+ * Preview control bar
+ */
+ 
+wxPreviewControlBar::wxPreviewControlBar(wxPrintPreview *preview, long buttons,
+    wxWindow *parent, int x, int y, int w, int h,
+    long style, char *name):
+  wxPanel((wxFrame*)parent, x, y, w, h, style | wxBORDER, name)
+{
+  printPreview = preview;
+  closeButton = NULL;
+  nextPageButton = NULL;
+  previousPageButton = NULL;
+  printButton = NULL;
+  zoomControl = NULL; // this was commented out for some reason
+  buttonFlags = buttons;
+}
+
+wxFont *wxPreviewControlBar::buttonFont = NULL;
+
+wxPreviewControlBar::~wxPreviewControlBar(void)
+{
+}
+
+void wxPreviewControlBar::Paint(void)
+{
+  //wxPanel::Paint();
+  wxPanel::Paint();
+
+  int w, h;
+  GetSize(&w, &h);
+  //wxDC *dc = MacDC();
+  //dc->SetPen(wxBLACK_PEN);
+  //dc->SetBrush(wxTRANSPARENT_BRUSH);
+  //dc->DrawLine(0, h-1, w, h-1);
+}
+
+static void wxPreviewCloseFunc(wxButton& but, wxCommandEvent& event)
+{
+  wxPreviewControlBar *controlBar = (wxPreviewControlBar *)but.GetParent();
+  wxPreviewFrame *frame = (wxPreviewFrame *)controlBar->GetParent();
+  if (frame->OnClose())
+    delete frame;
+}
+
+static void wxPreviewPrintFunc(wxButton& but, wxCommandEvent& event)
+{
+  wxPreviewControlBar *controlBar = (wxPreviewControlBar *)but.GetParent();
+  wxPrintPreview *preview = controlBar->GetPrintPreview();
+  preview->Print(TRUE);
+}
+
+static void wxPreviewNextFunc(wxButton& but, wxCommandEvent& event)
+{
+  wxPreviewControlBar *controlBar = (wxPreviewControlBar *)but.GetParent();
+  wxPrintPreview *preview = controlBar->GetPrintPreview();
+  if (preview)
+  {
+    int currentPage = preview->GetCurrentPage();
+    if ((preview->GetMaxPage() > 0) &&
+        (currentPage < preview->GetMaxPage()) &&
+        preview->GetPrintout()->HasPage(currentPage + 1))
+    {
+      preview->SetCurrentPage(currentPage + 1);
+    }
+  }
+}
+
+static void wxPreviewPreviousFunc(wxButton& but, wxCommandEvent& event)
+{
+  wxPreviewControlBar *controlBar = (wxPreviewControlBar *)but.GetParent();
+  wxPrintPreview *preview = controlBar->GetPrintPreview();
+  if (preview)
+  {
+    int currentPage = preview->GetCurrentPage();
+    if ((preview->GetMinPage() > 0) &&
+        (currentPage > preview->GetMinPage()) &&
+        preview->GetPrintout()->HasPage(currentPage - 1))
+    {
+      preview->SetCurrentPage(currentPage - 1);
+    }
+  }
+}
+
+static void wxPreviewZoomFunc(wxChoice& but, wxCommandEvent& event)
+{
+  wxPreviewControlBar *controlBar = (wxPreviewControlBar *)but.GetParent();
+  int zoom = controlBar->GetZoomControl();
+  if (controlBar->GetPrintPreview())
+    controlBar->GetPrintPreview()->SetZoom(zoom);
+}
+
+void wxPreviewControlBar::CreateButtons(void)
+{
+  SetLabelPosition(wxVERTICAL);
+  if (!buttonFont)
+    buttonFont = wxTheFontList->FindOrCreateFont(11, wxSWISS, wxNORMAL, wxBOLD);
+  SetButtonFont(buttonFont);
+
+  int buttonWidth = 65;
+  int buttonHeight = 25;
+
+  closeButton = new wxButton(this, (wxFunction)wxPreviewCloseFunc, "Close", -1, -1, buttonWidth, buttonHeight);
+  closeButton->SetDefault();
+  
+  if (buttonFlags & wxPREVIEW_PRINT)
+    printButton =  new wxButton(this, (wxFunction)wxPreviewPrintFunc, "Print...", -1, -1, buttonWidth, buttonHeight);
+  if (buttonFlags & wxPREVIEW_PREVIOUS)
+    previousPageButton = new wxButton(this, (wxFunction)wxPreviewPreviousFunc, "<<", -1, -1, buttonWidth, buttonHeight);
+  if (buttonFlags & wxPREVIEW_NEXT)
+    nextPageButton = new wxButton(this, (wxFunction)wxPreviewNextFunc, ">>", -1, -1, buttonWidth, buttonHeight);
+
+  char *choices[] = { "10%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%",
+    "65%", "70%", "75%", "80%", "85%", "90%", "95%", "100%", "110%", "120%", "150%", "200%" };
+  int n = 22;
+  if (buttonFlags & wxPREVIEW_ZOOM)
+  {
+    zoomControl = new wxChoice(this, (wxFunction)wxPreviewZoomFunc, "Scale", -1, -1, 100, 40, n, choices);
+    SetZoomControl(printPreview->GetZoom());
+  }
+
+  SetSize(0, 0, 600, 40);
+
+}
+
+void wxPreviewControlBar::SetZoomControl(int zoom)
+{
+  char buf[20];
+  sprintf(buf, "%d%%", zoom);
+  if (zoomControl)
+    zoomControl->SetStringSelection(buf);
+}
+
+int wxPreviewControlBar::GetZoomControl(void)
+{
+  char buf[20];
+  if (zoomControl && zoomControl->GetStringSelection())
+  {
+    strcpy(buf, zoomControl->GetStringSelection());
+    buf[strlen(buf) - 1] = 0;
+    return (int)atoi(buf);
+  }
+  else return 0;
+}
+
+/*
+ * Preview frame
+ */
+
+wxPreviewFrame::wxPreviewFrame(wxPrintPreview *preview, wxFrame *parent, char *title,
+    int x, int y, int w, int h, long style, char *name):
+ wxFrame(parent, title, x, y, w, h, style, name)
+{
+  printPreview = preview;
+  controlBar = NULL;
+  previewCanvas = NULL;
+}
+
+wxPreviewFrame::~wxPreviewFrame(void)
+{
+}
+
+Bool wxPreviewFrame::OnClose(void)
+{
+  MakeModal(FALSE);
+  
+  // Need to delete the printout and the print preview
+//  printPreview->EndPreview();
+  wxPrintout *printout = printPreview->GetPrintout();
+  if (printout)
+  {
+    delete printout;
+    printPreview->SetPrintout(NULL);
+    printPreview->SetCanvas(NULL);
+    printPreview->SetFrame(NULL);
+  }
+  delete printPreview;
+  return TRUE;
+}
+
+void wxPreviewFrame::Initialize(void)
+{
+  CreateStatusLine();
+  
+  CreateCanvas();
+  CreateControlBar();
+
+  printPreview->SetCanvas(previewCanvas);
+  printPreview->SetFrame(this);
+
+  // Set layout constraints here
+
+  // Control bar constraints
+  //wxLayoutConstraints *c1 = new wxLayoutConstraints;
+  int w, h;
+  controlBar->GetSize(&w, &h);
+
+  //c1->left.SameAs       (this, wxLeft);
+  //c1->top.SameAs        (this, wxTop);
+  //c1->right.SameAs      (this, wxRight);
+  //c1->height.Absolute   (h);
+
+  //controlBar->SetConstraints(c1);
+
+  // Canvas constraints
+  //wxLayoutConstraints *c2 = new wxLayoutConstraints;
+
+  //c2->left.SameAs       (this, wxLeft);
+  //c2->top.Below         (controlBar);
+  //c2->right.SameAs      (this, wxRight);
+  //c2->bottom.SameAs     (this, wxBottom);
+
+  //previewCanvas->SetConstraints(c2);
+
+  MakeModal(TRUE);
+}
+
+void wxPreviewFrame::CreateCanvas(void)
+{
+  previewCanvas = new wxPreviewCanvas(printPreview, this, -1, 40, // TODO WHY
+                                      Width(),  Height(),
+                                      wxRETAINED | wxVSCROLL| wxHSCROLL);
+}
+
+void wxPreviewFrame::CreateControlBar(void)
+{
+  long buttons = wxPREVIEW_DEFAULT;
+  if (printPreview->GetPrintoutForPrinting())
+    buttons |= wxPREVIEW_PRINT;
+    
+  controlBar = new wxPreviewControlBar(printPreview, buttons, this, -1, -1, Width());
+  controlBar->CreateButtons();
+}
+ 
+/*
+ * Print preview
+ */
+
+wxPrintPreview::wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data)
+{
+  previewPrintout = printout;
+  if (previewPrintout)
+    previewPrintout->SetIsPreview(TRUE);
+    
+  printPrintout = printoutForPrinting;
+  if (data)
+    printData = (*data);
+
+  previewCanvas = NULL;
+  previewFrame = NULL;
+  previewBitmap = NULL;
+  currentPage = 1;
+  currentZoom = 30;
+  topMargin = 40;
+  leftMargin = 40;
+  pageWidth = 0;
+  pageHeight = 0;
+
+  printout->OnPreparePrinting();
+
+  // Get some parameters from the printout, if defined
+  int selFrom, selTo;
+  printout->GetPageInfo(&minPage, &maxPage, &selFrom, &selTo);
+
+  DetermineScaling();
+}
+
+wxPrintPreview::~wxPrintPreview(void)
+{
+  if (previewPrintout)
+    delete previewPrintout;
+  if (previewBitmap)
+    delete previewBitmap;
+  if (printPrintout)
+    delete printPrintout;
+}
+
+Bool wxPrintPreview::SetCurrentPage(int pageNum)
+{
+  if (currentPage == pageNum)
+    return TRUE;
+
+  currentPage = pageNum;
+  if (previewBitmap)
+  {
+    delete previewBitmap;
+    previewBitmap = NULL;
+  }
+
+  if (previewCanvas)
+  {
+    RenderPage(pageNum);
+    //previewCanvas->Refresh();
+  }
+  return TRUE;
+}
+
+void wxPrintPreview::SetPrintout(wxPrintout *printout)
+{
+  previewPrintout = printout;
+}
+
+void wxPrintPreview::SetFrame(wxFrame *frame)
+{
+  previewFrame = frame;
+}
+  
+void wxPrintPreview::SetCanvas(wxCanvas *canvas)
+{
+  previewCanvas = canvas;
+}
+
+Bool wxPrintPreview::PaintPage(wxCanvas *canvas)
+{
+  DrawBlankPage(canvas);
+
+  if (!previewBitmap)
+    RenderPage(currentPage);
+    
+  if (!previewBitmap)
+    return FALSE;
+
+  if (!canvas)
+    return FALSE;
+
+  int canvasWidth, canvasHeight;
+  canvas->GetSize(&canvasWidth, &canvasHeight);
+  
+  float zoomScale = (float)((float)currentZoom/(float)100);
+  float actualWidth = (float)(zoomScale*pageWidth*previewScale);
+  float actualHeight = (float)(zoomScale*pageHeight*previewScale);
+
+  float x = (float)((canvasWidth - actualWidth)/2.0);
+  if (x < leftMargin)
+    x = leftMargin;
+  float y = topMargin + 5;
+
+  wxMemoryDC temp_dc;
+  temp_dc.SelectObject(previewBitmap);
+  canvas->GetDC()->Blit(x, y, previewBitmap->GetWidth(), previewBitmap->GetHeight(), &temp_dc, 0, 0);
+
+  temp_dc.SelectObject(NULL);
+
+  return TRUE;
+}
+
+Bool wxPrintPreview::RenderPage(int pageNum)
+{
+  int canvasWidth, canvasHeight;
+  if (!previewCanvas)
+  {
+    wxMessageBox("wxPrintPreview::RenderPage: must use wxPrintPreview::SetCanvas to let me know about the canvas!",
+      "Print Preview Failure", wxOK);
+    return FALSE;
+  }
+  previewCanvas->GetSize(&canvasWidth, &canvasHeight);
+  
+  float zoomScale = (float)((float)currentZoom/(float)100);
+  float actualWidth = (float)(zoomScale*pageWidth*previewScale);
+  float actualHeight = (float)(zoomScale*pageHeight*previewScale);
+
+  float x = (float)((canvasWidth - actualWidth)/2.0);
+  if (x < leftMargin)
+    x = leftMargin;
+  float y = topMargin;
+
+  if (!previewBitmap)
+  {
+    previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
+    //previewBitmap = new wxBitmap((int)1024, (int)1024);
+    if (!previewBitmap || !previewBitmap->Ok())
+    {
+      if (previewBitmap)
+        delete previewBitmap;
+      wxMessageBox("Sorry, not enough memory to create a preview.", "Print Preview Failure", wxOK);
+      return FALSE;
+    }
+  }
+  wxMemoryDC memoryDC; // tried (previewCanvas->wx_dc)
+  memoryDC.SelectObject(previewBitmap);
+  memoryDC.SetUserScale(zoomScale, zoomScale);
+
+  memoryDC.Clear();
+
+  previewPrintout->SetDC(&memoryDC);
+  previewPrintout->SetPageSizePixels(pageWidth, pageHeight);
+
+  previewPrintout->OnBeginPrinting();
+
+  if (!previewPrintout->OnBeginDocument(printData.GetFromPage(), printData.GetToPage()))
+  {
+    wxMessageBox("Could not start document preview.", "Print Preview Failure", wxOK);
+    memoryDC.SelectObject(NULL);
+    delete previewBitmap;
+    return FALSE;
+  }
+  previewPrintout->OnPrintPage(pageNum);
+  previewPrintout->OnEndDocument();
+  previewPrintout->OnEndPrinting();
+
+  //memoryDC.EndDrawing();
+  previewPrintout->SetDC(NULL);
+  memoryDC.SelectObject(NULL);
+
+  char buf[200];
+  if (maxPage != 0)
+    sprintf(buf, "Page %d of %d", pageNum, maxPage);
+  else
+    sprintf(buf, "Page %d", pageNum);
+
+  if (previewFrame)
+    previewFrame->SetStatusText(buf);
+
+  return TRUE;
+}
+
+Bool wxPrintPreview::DrawBlankPage(wxCanvas *canvas)
+{
+  int canvasWidth, canvasHeight;
+  canvas->GetSize(&canvasWidth, &canvasHeight);
+  
+  float zoomScale = (float)((float)currentZoom/(float)100);
+  float actualWidth = zoomScale*pageWidth*previewScale;
+  float actualHeight = zoomScale*pageHeight*previewScale;
+
+  float x = (float)((canvasWidth - actualWidth)/2.0);
+  if (x < leftMargin)
+    x = leftMargin;
+  float y = topMargin;
+
+  wxDC *dc = canvas->GetDC();
+
+  // Draw shadow, allowing for 1-pixel border AROUND the actual page
+  int shadowOffset = 4;
+  dc->SetPen(wxBLACK_PEN);
+  dc->SetBrush(wxBLACK_BRUSH);
+  dc->DrawRectangle(x-1 + shadowOffset, y-1 + shadowOffset, actualWidth+2, actualHeight+2);
+
+  // Draw blank page allowing for 1-pixel border AROUND the actual page
+  dc->SetPen(wxBLACK_PEN);
+  dc->SetBrush(wxWHITE_BRUSH);
+  dc->DrawRectangle(x-1, y-1, actualWidth+2, actualHeight+2);
+  return TRUE;
+}
+
+wxPrintData &wxPrintPreview::GetPrintData(void)
+{
+  return printData;
+}
+
+void wxPrintPreview::SetZoom(int percent)
+{
+  if (currentZoom == percent)
+    return;
+    
+  currentZoom = percent;
+  if (previewBitmap)
+  {
+    delete previewBitmap;
+    previewBitmap = NULL;
+  }
+  RenderPage(currentPage);
+  
+  if (previewCanvas)
+  {
+    previewCanvas->Clear();
+    previewCanvas->Paint();
+  }
+}
+
+int wxPrintPreview::GetZoom(void)
+{
+  return currentZoom;
+}
+
+Bool wxPrintPreview::Print(Bool interactive)
+{
+  if (!printPrintout)
+    return FALSE;
+  wxPrinter printer(&printData);
+  return printer.Print(previewFrame, printPrintout, interactive);
+}
+
+void wxPrintPreview::DetermineScaling(void)
+{
+
+  GDHandle gThisGDevice = GetMainDevice();
+
+  int screenWidth; // = (**(**gThisGDevice).gdPMap).hRes; // fix these
+  int screenHeight; // = (**(**gThisGDevice).gdPMap).vRes;
+
+  wxDisplaySize(&screenWidth, &screenHeight);
+
+  int screenXRes =  screenWidth;
+  int screenYRes =  screenHeight;
+  int logPPIScreenX = (int)Fix2Long((**(**gThisGDevice).gdPMap).hRes);
+  int logPPIScreenY = (int)Fix2Long((**(**gThisGDevice).gdPMap).vRes);
+
+  previewPrintout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
+
+  int printerWidth = 552;
+  int printerHeight = 730;
+  int printerXRes = 552;
+  int printerYRes = 730;
+
+    // Get a device context for the currently selected printer
+  /* create print record */
+    THPrint context = (THPrint)
+       NewHandleClear(sizeof(TPrint));
+     CheckMemOK(context);
+ 
+    PrOpen();
+    if (PrError() != fnfErr) {
+      PrintDefault(context);
+    }
+
+    PrClose();
+
+    if (context) // otherwise use the defaults ???
+    {
+      printerWidth = (**context).prInfo.rPage.right - (**context).prInfo.rPage.left;
+      printerHeight = (**context).prInfo.rPage.bottom - (**context).prInfo.rPage.top;
+      printerXRes = printerWidth; // (**context).prStl.iPageH;
+      printerYRes = printerHeight; // (**context).prStl.iPageV;
+
+      int logPPIPrinterX = (**context).prInfoPT.iHRes;
+      int logPPIPrinterY = (**context).prInfoPT.iVRes;
+      previewPrintout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
+    }
+    
+    DisposeHandle((Handle)context);
+
+  pageWidth = printerXRes;
+  pageHeight = printerYRes;
+
+  // At 100%, the page should look about page-size on the screen.
+  previewScale = (float)((float)screenWidth/(float)printerWidth);
+  previewScale = previewScale * (float)((float)screenXRes/(float)printerYRes);
+}
+
+#endif
+  // USE_COMMON_DIALOGS
+#endif
+  // End USE_PRINTING_ARCHITECTURE
+
+
diff --git a/src/wxmac/src/mac/wx_rbox.cc b/src/wxmac/src/mac/wx_rbox.cc
new file mode 100644
index 0000000..c7cd7ab
--- /dev/null
+++ b/src/wxmac/src/mac/wx_rbox.cc
@@ -0,0 +1,369 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_rbox.cc
+// Purpose:	Panel item radioBox implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_rbox.h"
+#include "wx_rbut.h"
+#include "wx_messg.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_gdi.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+
+#define MEANING_CHARACTER	'0'
+
+//-----------------------------------------------------------------------------
+	void wxRadioButtonProc(wxRadioButton& radioButton, wxCommandEvent& event);
+	void wxRadioButtonProc(wxRadioButton& radioButton, wxCommandEvent& event)
+	{
+		wxPanel* radioPanel = (wxPanel*)radioButton.GetParent();
+		wxWindow *rb = radioPanel;
+		while (wxSubType(rb->__type, wxTYPE_PANEL))
+			rb = rb->GetParent();
+		wxRadioBox* radioBox = (wxRadioBox *)rb;
+		long radioButtonIndex = radioBox->cRadioButtons.MemberIndex(&radioButton);
+		radioBox->SetSelection(radioButtonIndex);
+
+		wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_RADIOBOX_COMMAND);
+		commandEvent->commandInt = radioButtonIndex;
+		commandEvent->eventObject = radioBox;
+		radioBox->ProcessCommand(*commandEvent);
+	}
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRadioBox::wxRadioBox // Constructor (given parentPanel, label choices)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		Title,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		int			N,
+		char**		Choices,
+		int			majorDim,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbRadioBox (parentPanel, x, y, width, height, N, style, windowName),
+		cRadioButtons (wxList(wxList::kNoDestroyData))
+{
+	Callback(function);
+
+	cRadioPanel = new wxPanel(this->ClientArea(), 0, 0, 0, 0, 0);
+	cRadioPanel->SetButtonFont(wxNORMAL_FONT);
+	cRadioPanel->SetLabelFont(wxNORMAL_FONT);
+
+	wxPanel *buttonHolder = cRadioPanel;
+	
+
+	if (Title)
+	{
+		Title = wxItemStripLabel(Title);
+		cRadioTitle = new wxMessage(cRadioPanel, Title, labelFont);
+		if (labelPosition != wxVERTICAL) {
+			buttonHolder = new wxPanel(cRadioPanel->ClientArea(), -1, -1, 0, 0, 0);
+		} else
+			buttonHolder->NewLine();
+	}
+	else cRadioTitle = NULL;
+
+	for (int i = 0; i < N; i++)
+	{
+	    char *choice = wxItemStripLabel(Choices[i]);
+		if (i && ((style & wxVERTICAL) == wxVERTICAL))
+			buttonHolder->NewLine();
+		wxRadioButton* radioButton = new wxRadioButton(buttonHolder,
+				(wxFunction)&wxRadioButtonProc, choice);
+		cRadioButtons.Append(radioButton);
+	}
+	SetSelection(0);
+
+	buttonHolder->Fit();
+	if (buttonHolder != cRadioPanel) {
+		cRadioPanel->Fit();
+		cRadioTitle->Centre(wxVERTICAL);
+	}
+
+	if (style & wxBORDER) new wxBorderArea(this);
+
+	if (width < 0 || height < 0)
+	{
+		Fit(); // WCH: need wxHorizontal and wxVertical for Fit(direction)
+	}
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+wxRadioBox::wxRadioBox // Constructor (given parentPanel, bitmap choices)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		Title,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		int			N,
+		wxBitmap**	Choices,
+		int			majorDim,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbRadioBox (parentPanel, x, y, width, height, N, style, windowName),
+		cRadioButtons (wxList(wxList::kNoDestroyData))
+{
+	Callback(function);
+
+	cRadioPanel = new wxPanel(this->ClientArea(), 0, 0, 0, 0, 0);
+	cRadioPanel->SetButtonFont(wxNORMAL_FONT);
+	cRadioPanel->SetLabelFont(wxNORMAL_FONT);
+	
+	wxPanel *buttonHolder = cRadioPanel;
+	
+	if (Title)
+	{
+		cRadioTitle = new wxMessage(cRadioPanel, Title, labelFont);
+		if (labelPosition != wxVERTICAL) {
+			buttonHolder = new wxPanel(cRadioPanel->ClientArea(), -1, -1, 0, 0, 0);
+		} else
+			buttonHolder->NewLine();
+	}
+	else cRadioTitle = NULL;
+
+	for (int i = 0; i < N; i++)
+	{
+		if (i && ((style & wxVERTICAL) == wxVERTICAL))
+			buttonHolder->NewLine();
+		wxRadioButton* radioButton = new wxRadioButton(buttonHolder,
+				(wxFunction)&wxRadioButtonProc, Choices[i]);
+		cRadioButtons.Append(radioButton);
+	}
+	SetSelection(0);
+
+	buttonHolder->Fit();
+	if (buttonHolder != cRadioPanel) {
+		cRadioPanel->Fit();
+		cRadioTitle->Centre(wxVERTICAL);
+	}
+
+	if (style & wxBORDER) new wxBorderArea(this);
+
+	if (width < 0 || height < 0)
+	{
+		Fit(); // WCH: need wxHorizontal and wxVertical for Fit(direction)
+	}
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRadioBox::~wxRadioBox(void)
+{
+	//CJC - This shouldn't be neccessary - compiler bug?
+	cRadioButtons.Clear();
+}
+
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+char* wxRadioBox::GetLabel(void)
+{
+	return (cRadioTitle ? cRadioTitle->GetLabel() : NULL);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::SetLabel(char* label)
+{
+	if (cRadioTitle) cRadioTitle->SetLabel(label);
+}
+
+//-----------------------------------------------------------------------------
+char* wxRadioBox::GetLabel(int item)
+{
+	char* result = NULL;
+	int numberItems = cRadioButtons.Number();
+	if (0 <= item && item < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(item);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		result = radioButton->GetLabel();
+	}
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::SetLabel(int item, char* label)
+{
+	int numberItems = cRadioButtons.Number();
+	if (0 <= item && item < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(item);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		radioButton->SetLabel(label);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::SetLabel(int item, wxBitmap* bitmap)
+{
+	int numberItems = cRadioButtons.Number();
+	if (0 <= item && item < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(item);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		radioButton->SetLabel(bitmap);
+	}
+}
+
+//-----------------------------------------------------------------------------
+int wxRadioBox::FindString(char* s)
+{
+	int result = -1;
+	int numberItems = cRadioButtons.Number();
+	for (int i = 0; i < numberItems && result == -1; i++)
+	{
+		char* radioButtonLabel = GetLabel(i);
+		if (strcmp(s, radioButtonLabel) == 0) result = i;
+//		delete [] radioButtonLabel;
+	}
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::SetSelection(int N) // WCH: should use "item" for "N"
+{
+	int numberItems = cRadioButtons.Number();
+	if (0 <= N && N < numberItems)
+	{
+		if (selected != N)
+		{
+			if (0 <= selected && selected < numberItems)
+			{
+				wxNode* selectedNode = cRadioButtons.Nth(selected);
+				wxRadioButton* selectedRadioButton =
+								(wxRadioButton*)selectedNode->Data();
+				selectedRadioButton->SetValue(FALSE);
+			}
+		
+			wxNode* node = cRadioButtons.Nth(N);
+			wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+			radioButton->SetValue(TRUE);
+		
+			selected = N;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Get selection
+//-----------------------------------------------------------------------------
+int wxRadioBox::GetSelection(void)
+{
+	return selected;
+}
+
+//-----------------------------------------------------------------------------
+// Find string for position
+//-----------------------------------------------------------------------------
+char* wxRadioBox::GetString(int N) // WCH: duplicates GetLabel; so delete this
+{
+	return GetLabel(N);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::Enable(Bool enable)
+{
+	wxWindow::Enable(enable);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::Enable(int item, Bool enable)
+{
+	int numberItems = cRadioButtons.Number();
+	if (0 <= item && item < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(item);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		radioButton->Enable(enable);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	cRadioPanel->DoShow(show);	
+	wxWindow::DoShow(show);
+#if 0
+	int numberItems = cRadioButtons.Number();
+	for (int i = 0; i < numberItems; i++)
+	{
+		Show(i, show);
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::Show(int item, Bool show)
+{
+	int numberItems = cRadioButtons.Number();
+	if (0 <= item && item < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(item);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		radioButton->Show(show);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioBox::Command(wxCommandEvent& event) // mac platform only
+{
+	int selection = event.commandInt;
+	int numberItems = cRadioButtons.Number();
+	if (0 <= selection && selection < numberItems)
+	{
+		wxNode* node = cRadioButtons.Nth(selection);
+		wxRadioButton* radioButton = (wxRadioButton*)node->Data();
+		if (radioButton->IsEnable())
+		{
+			radioButton->Highlight(TRUE); // highlight button
+			long delayTicks = 10; // one tick is 1/60th of a second
+			long finalTicks;
+			Delay(delayTicks, &finalTicks);
+			radioButton->Highlight(FALSE); // unhighlight button
+			SetSelection(selection); // set radioButton
+		  	ProcessCommand(event);
+	  	}
+  	}
+}
+
+void wxRadioBox::ChangeToGray(Bool gray)
+{
+  ChildrenInternalGray(gray);
+  wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_rbut.cc b/src/wxmac/src/mac/wx_rbut.cc
new file mode 100644
index 0000000..ec94b36
--- /dev/null
+++ b/src/wxmac/src/mac/wx_rbut.cc
@@ -0,0 +1,404 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_rbut.cc
+// Purpose:	Panel item radioButton implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_rbut.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_panel.h"
+#include "wx_area.h"
+#include <QuickDraw.h>
+
+#define IR_CIRCLE_SIZE 12
+#define IR_X_SPACE 3
+#define IR_Y_SPACE 2
+#define IR_MIN_HEIGHT (IR_CIRCLE_SIZE + 2 * IR_Y_SPACE)
+#define IR_ON_INSET 3
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRadioButton::wxRadioButton // Constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxItem (parentPanel, x, y, width, height, style, windowName)
+{
+  Create(parentPanel, function, label, x, y, width, height, style, windowName, objectType);
+}
+
+void wxRadioButton::Create // Real constructor (given parentPanel, label)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) 
+{
+	buttonBitmap = NULL;
+	Callback(function);
+
+	font = buttonFont; // WCH: mac platform only
+
+	float fLabelWidth = 100.0;
+	float fLabelHeight = 20.0;
+	if (label)
+	{
+		GetTextExtent(label, &fLabelWidth, &fLabelHeight, NULL, NULL, buttonFont);
+		fLabelWidth += 20; // add 20 for width of radio button icon
+		if (fLabelHeight < 12) fLabelHeight = 12; // height of radio button icon is 12
+	}
+
+	if (width < 0) cWindowWidth = fLabelWidth;
+	if (height < 0) cWindowHeight = fLabelHeight;
+
+#if 0
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	int clientWidth = ClientArea()->Width();
+	int clientHeight = ClientArea()->Height();
+	Rect boundsRect = {0, 0, clientHeight, clientWidth};
+	wxMacString theMacLabel = label;
+	const Bool drawNow = TRUE; // WCH: use FALSE, then show after ChangeColour??
+	const short offValue = 0;
+	const short minValue = 0;
+	const short maxValue = 1;
+	short refCon = 0;
+	cMacControl = ::NewControl((WindowPtr)theMacGrafPort, &boundsRect, theMacLabel(),
+			drawNow, offValue, minValue, maxValue, radioButProc + useWFont, refCon);
+	CheckMemOK(cMacControl);
+#else
+	labelString = label;
+	cMacControl = NULL;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+wxRadioButton::wxRadioButton // Constructor (given parentPanel, bitmap)
+	(
+		wxPanel*	parentPanel,
+		wxFunction	function,
+		wxBitmap*	bitmap,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxItem (parentPanel, x, y, width, height, style, windowName)
+{
+	if (bitmap->Ok() && (bitmap->selectedIntoDC >= 0)) {
+		buttonBitmap = bitmap;
+		buttonBitmap->selectedIntoDC++;
+	} else {
+	    Create(parentPanel, function, "<bad-image>", x, y, width, height, style, windowName, objectType);
+	}
+
+	Callback(function);
+	cMacControl = NULL;
+	
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	Rect bounds = {0, 0, buttonBitmap->GetHeight(), buttonBitmap->GetWidth()};
+	cWindowHeight = bounds.bottom;
+	cWindowWidth = bounds.right + IR_CIRCLE_SIZE + IR_X_SPACE;
+	if (cWindowHeight < IR_MIN_HEIGHT)
+	  cWindowHeight = IR_MIN_HEIGHT;
+
+	::InvalRect(&bounds);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxRadioButton::~wxRadioButton(void)
+{
+	if (cMacControl) ::DisposeControl(cMacControl);
+	if (buttonBitmap)
+	  --buttonBitmap->selectedIntoDC;
+}
+
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+char* wxRadioButton::GetLabel()
+{
+	if (cMacControl) {
+		Str255	pLabel;
+
+		::GetCTitle(cMacControl, pLabel);
+		wxMacPtoCString(pLabel, wxBuffer);
+	    return wxBuffer;
+	 } else
+	 	return "";
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::SetLabel(char* label)
+{
+  if (label && !buttonBitmap)
+  {
+	SetCurrentDC();
+  	wxMacString1 theMacString1 = label;
+  	::SetCTitle(cMacControl, theMacString1());
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::SetLabel(wxBitmap* bitmap)
+{
+	if (buttonBitmap && bitmap->Ok() && (bitmap->selectedIntoDC >= 0)) {
+		--buttonBitmap->selectedIntoDC;
+		buttonBitmap = bitmap;
+		buttonBitmap->selectedIntoDC++;
+		Refresh();
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::SetValue(Bool val)
+{
+	SetCurrentDC();
+	if (cMacControl)
+	  ::SetCtlValue(cMacControl, val ? 1 : 0);
+	else {
+	  bitmapState = !!val;
+	  if (!cHidden)
+	    Paint();
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxRadioButton::GetValue(void)
+{
+	if (cMacControl) {
+		short value = ::GetCtlValue(cMacControl);
+		return (value != 0) ? TRUE : FALSE;
+	} else
+		return bitmapState;
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::ChangeToGray(Bool gray)
+{
+	SetCurrentDC();
+	if (cMacControl)
+		::HiliteControl(cMacControl, gray ?  kInactiveControl : kActiveControl);
+    wxWindow::ChangeToGray(gray);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::Paint(void)
+{
+	if (cHidden) return;
+	SetCurrentDC();
+	Rect r = { 0, 0, cWindowHeight, cWindowWidth};
+	::EraseRect(&r);
+	if (cMacControl) {
+		::Draw1Control(cMacControl);
+	} else {
+	  if (buttonBitmap) {
+	  	int btop = (cWindowHeight - buttonBitmap->GetHeight()) / 2;
+	  	buttonBitmap->DrawMac(IR_CIRCLE_SIZE + IR_X_SPACE, btop);
+	  } else if (labelString) {
+	    float fWidth = 50.0;
+		float fHeight = 12.0;
+		float fDescent = 0.0;
+		float fLeading = 0.0;
+		GetTextExtent(labelString, &fWidth, &fHeight, &fDescent, &fLeading, labelFont);
+		int stop = (cWindowHeight + fHeight) / 2;
+		::MoveTo(IR_CIRCLE_SIZE + IR_X_SPACE, stop - fDescent - fLeading);
+	  	::DrawText(labelString, 0, strlen(labelString));
+	  }
+	  int top = (cWindowHeight - IR_CIRCLE_SIZE) / 2;
+	  Rect r = { top, 0, top + IR_CIRCLE_SIZE, IR_CIRCLE_SIZE };
+	  PenSize(1, 1);
+	  ForeColor(blackColor);
+	  FrameOval(&r);
+	  InsetRect(&r, 1, 1);
+	  ForeColor(whiteColor);
+	  PaintOval(&r);
+	  ForeColor(blackColor);
+	  if (bitmapState) {
+	    InsetRect(&r, IR_ON_INSET - 1, IR_ON_INSET - 1);
+		PaintOval(&r);	    
+	  }
+	  cMacDC->setCurrentUser(NULL);
+	}
+}
+
+void wxRadioButton::Highlight(Bool on)
+{
+	int top = (cWindowHeight - IR_CIRCLE_SIZE) / 2;
+	Rect r = { top + 1, 1, top + IR_CIRCLE_SIZE - 1, IR_CIRCLE_SIZE - 1};
+	if (!on)
+		ForeColor(whiteColor);
+	PenSize(1, 1);
+	FrameOval(&r);
+	if (!on) ForeColor(blackColor);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	SetCurrentDC();
+	if (cMacControl) {
+		if (show)
+			::ShowControl(cMacControl);
+		else
+			::HideControl(cMacControl);
+	}
+
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::ShowAsActive(Bool flag) // mac platform only
+{
+#if 0
+	if (cEnable)
+	{
+		SetCurrentDC();
+		::HiliteControl(cMacControl, flag ? inCheckBox : 0);
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::OnEvent(wxMouseEvent& event) // mac platform only
+{
+	if (cEnable)
+	{
+		if (event.LeftDown())
+		{
+			SetCurrentDC();
+		
+			float fStartH, fStartV;
+			event.Position(&fStartH, &fStartV); // client c.s.
+			int startH = fStartH;
+			int startV = fStartV;
+		
+			Point startPt = {startH, startV}; // client c.s.
+			int trackResult;
+			if (::StillDown()) {
+				if (cMacControl)
+				  trackResult = ::TrackControl(cMacControl, startPt, NULL);
+				else
+				  trackResult = Track(startPt);
+			} else
+				trackResult = 1;
+			if (trackResult)
+			{
+				wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_RADIOBOX_COMMAND); // WCH: must change constant
+				commandEvent->commandInt = 0;
+				commandEvent->eventObject = this;
+				ProcessCommand(*commandEvent);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::Command(wxCommandEvent& event) // mac platform only (also xview platform)
+{
+	if (cEnable)
+	{
+		Highlight(TRUE); // highlight button
+		long delayTicks = 10; // one tick is 1/60th of a second
+		long finalTicks;
+		Delay(delayTicks, &finalTicks);
+		Highlight(FALSE); // unhighlight button
+	  	ProcessCommand(event);
+  	}
+}
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::ProcessCommand(wxCommandEvent& event)
+{
+  if (wxNotifyEvent(event, TRUE))
+    return;
+
+  wxFunction fun = callback;
+  if (fun)
+  {
+    (void)(*(fun))(*this, event);
+  }
+
+  wxNotifyEvent(event, FALSE);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Sizing methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxRadioButton::OnClientAreaDSize(int dW, int dH, int dX, int dY) // mac platform only
+{
+	if (!cMacControl) return;
+
+	SetCurrentDC();
+
+	Bool isVisible = (**cMacControl).contrlVis == 255;
+	Bool hideToPreventFlicker = (isVisible && (dX || dY) && (dW || dH));
+	if (hideToPreventFlicker) ::HideControl(cMacControl);
+
+	if (dW || dH)
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		::SizeControl(cMacControl, clientWidth, clientHeight);
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put new origin at (0, 0)
+		::MoveControl(cMacControl, 0, 0);
+	}
+
+	if (hideToPreventFlicker) ::ShowControl(cMacControl);
+
+	if (!cHidden && (dW || dH || dX || dY))
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+	}
+}
diff --git a/src/wxmac/src/mac/wx_sbar.cc b/src/wxmac/src/mac/wx_sbar.cc
new file mode 100644
index 0000000..83f906f
--- /dev/null
+++ b/src/wxmac/src/mac/wx_sbar.cc
@@ -0,0 +1,414 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_sbar.cc
+// Purpose:	Macintosh Scrollbar implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_sbar.h"
+#include "wxScroll.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_stdev.h"
+#include "wx_area.h"
+#include "wx_frame.h"
+#include <Windows.h>
+
+pascal void	TrackActionProc(ControlHandle theControl,short partCode);
+
+//	Functions which are called from external scope, but in turn invoke
+//	DocWindow methods. These really could be moved t
+
+static ControlActionUPP
+TrackActionProcUPP = NewControlActionProc(TrackActionProc);
+
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScrollBar::wxScrollBar // Constructor (given parentArea)
+	(
+		wxArea*		parentArea,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxWindow (windowName, parentArea, x, y, width, height, style)
+{
+	CreateWxScrollBar(function, label);
+}
+
+//-----------------------------------------------------------------------------
+wxScrollBar::wxScrollBar // Constructor (given parentWindow)
+	(
+		wxWindow*	parentWindow,
+		wxFunction	function,
+		char*		label,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxWindow (windowName, parentWindow, x, y, width, height, style)
+{
+	CreateWxScrollBar(function, label);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScrollBar::~wxScrollBar(void)
+{
+	::DisposeControl(cMacControl);
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::CreateWxScrollBar // common constructor initialization
+(
+	wxFunction function,
+	char* label
+)
+{
+	InitDefaults(function);
+	
+	if (label)
+	  label = wxItemStripLabel(label);
+
+//////////////////////////////////////////
+// do platform stuff
+//////////////////////////////////////////
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	int clientWidth = ClientArea()->Width();
+	int clientHeight = ClientArea()->Height();
+	Rect boundsRect = {0, 0, clientHeight, clientWidth};
+	wxMacString theMacLabel = label;
+	const Bool drawNow = TRUE;
+	const short offValue = 0;
+	const short minValue = 0;
+	const short maxValue = 0;
+	long refCon = (long)this;
+	cMacControl = ::NewControl((WindowPtr)theMacGrafPort, &boundsRect, theMacLabel(),
+			drawNow, offValue, minValue, maxValue, scrollBarProc, refCon);
+	CheckMemOK(cMacControl);
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::InitDefaults(wxFunction function)
+{
+	cActive = TRUE;
+
+	Callback(function);
+
+	cStyle = (cStyle & wxHSCROLL ? wxHSCROLL : wxVSCROLL); // kludge
+	wxScrollData* scrollData = new wxScrollData;
+	cScroll = new wxScroll(this, scrollData);
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::ChangeColour(void)
+{
+}
+
+//-----------------------------------------------------------------------------
+char* wxScrollBar::GetLabel()
+{
+	Str255	pLabel;
+
+	::GetCTitle(cMacControl, pLabel);
+	wxMacPtoCString(pLabel, wxBuffer);
+    return wxBuffer;
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::SetLabel(char* label)
+{
+  if (label)
+  {
+	SetCurrentDC();
+  	wxMacString1 theMacString1 = label;
+  	::SetCTitle(cMacControl, theMacString1());
+  }
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::SetValue(int val)
+{
+	SetCurrentDC();
+	::SetCtlValue(cMacControl, val);
+}
+
+//-----------------------------------------------------------------------------
+int wxScrollBar::GetValue(void)
+{
+	return ::GetCtlValue(cMacControl);
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::SetMaxValue(int maxValue)
+{
+	SetCurrentDC();
+	::SetCtlMax(cMacControl, maxValue);
+}
+
+//-----------------------------------------------------------------------------
+int wxScrollBar::GetMaxValue(void)
+{
+	return ::GetCtlMax(cMacControl);
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::Enable(Bool enable)
+{
+	if (cEnable != enable)
+	{
+		SetCurrentDC();
+		const int kActiveControl = 0;
+		const int kInactiveControl = 255;
+		::HiliteControl(cMacControl, enable ? kActiveControl : kInactiveControl);
+		cEnable = enable;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+ 	// GRW
+ 	Bool isVisible = (**cMacControl).contrlVis == 255;
+ 	if (isVisible)
+ 	{
+	 	::Draw1Control(cMacControl);
+ 	}
+ 	else
+ 	{
+ 		// Draw outline of hidden scrollbar (since we're clipping DrawGrowIcon)
+ 		Rect controlRect = (**cMacControl).contrlRect;
+ 		PenState oldPenState;
+ 		::GetPenState(&oldPenState);
+ 		::PenNormal();
+ 		::FrameRect(&controlRect);
+ 		::SetPenState(&oldPenState);
+ 	}
+ 	// GRW
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	SetCurrentDC();
+	if (show)
+		::ShowControl(cMacControl);
+	else
+		::HideControl(cMacControl);
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::ShowAsActive(Bool flag) // mac platform only
+{
+	if (cHidden) return;
+
+	if (cEnable)
+	{
+		SetCurrentDC();
+		const int kActiveControl = 0;
+		const int kInactiveControl = 255;
+ 		//GRW
+ 		if (flag)
+ 			::ShowControl(cMacControl);
+ 		else
+ 		{
+ 			// Would look better than calling HideControl, if it worked:
+ 			//		(**cMacControl).contrlVis   0;
+ 			//		Rect controlRect   (**cMacControl).contrlRect;
+ 			//		::InvalRect(&controlRect);
+ 			::HideControl(cMacControl);
+ 		}
+	   // OLD: ::HiliteControl(cMacControl, flag ? kActiveControl : kInactiveControl);
+	
+		// The following is a kludge, to prevent erasure during subsequent update event
+		if (flag)
+		{
+			Bool isVisible = (**cMacControl).contrlVis == 255;
+			if (isVisible)
+			{
+				::Draw1Control(cMacControl);
+				Rect controlRect = (**cMacControl).contrlRect;
+				::ValidRect(&controlRect);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+	pascal void TrackActionProc(ControlHandle theControl, short thePart);
+	pascal void TrackActionProc(ControlHandle theControl, short thePart)
+	{
+		wxScrollBar* scrollBar = (wxScrollBar*) (**theControl).contrlRfCon;
+		if (scrollBar) scrollBar->TrackAction(thePart);
+	}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::OnEvent(wxMouseEvent& event) // mac platform only
+{
+	if (event.LeftDown())
+	{
+		SetCurrentDC();
+	
+		float fStartH, fStartV;
+		event.Position(&fStartH, &fStartV); // client c.s.
+		int startH = fStartH;
+		int startV = fStartV;
+
+		Point startPt = {startV, startH}; // client c.s.
+		int thePart = ::TestControl(cMacControl, startPt);
+		if (thePart)
+		{
+			if (thePart == inThumb)
+			{
+				if (::TrackControl(cMacControl, startPt, NULL))
+				{
+					Bool horizontal = cStyle & wxHSCROLL;
+					wxWhatScrollData positionScrollData =
+						(horizontal ? wxWhatScrollData::wxPositionH : wxWhatScrollData::wxPositionV);
+					int newPosition = GetValue();
+					cScroll->SetScrollData(newPosition, positionScrollData, NULL);
+				}
+			}
+			else
+			{
+				::TrackControl(cMacControl, startPt, TrackActionProcUPP);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::TrackAction(short part) // mac platform only
+{
+	if (part && cScroll)
+	{
+		Bool horizontal = cStyle & wxHSCROLL;
+
+		wxScrollData* scrollData = cScroll->GetScrollData();
+		int scrollsPerPage = scrollData->GetValue
+			(horizontal ? wxWhatScrollData::wxPageW : wxWhatScrollData::wxPageH);
+		int maxv = GetMaxValue();
+	
+		int delta = 0;
+		switch (part)
+		{
+			case inUpButton: delta = -1; break;
+			case inDownButton: delta = 1; break;
+			case inPageUp: delta = -scrollsPerPage; break;
+			case inPageDown: delta = scrollsPerPage; break;
+		}
+
+		int newPosition = GetValue() + delta;
+		if (newPosition < 0) newPosition = 0;
+		if (newPosition > maxv) newPosition = maxv;
+
+		wxWhatScrollData positionScrollData =
+			(horizontal ? wxWhatScrollData::wxPositionH : wxWhatScrollData::wxPositionV);
+		cScroll->SetScrollData(newPosition, positionScrollData, NULL);
+
+		SetCurrentDC(); // must reset cMacDC (kludge)
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::SetScrollData // adjust scrollBar to match scroll data setting
+(
+	wxScrollData*		scrollData,
+	wxWhatScrollData	whatScrollData,
+	wxWindow*			iniatorWindow
+)
+{
+	if (this == iniatorWindow) return;
+
+	Bool horizontal = cStyle & wxHSCROLL;
+
+	wxWhatScrollData sizeScrollData =
+		(horizontal ? wxWhatScrollData::wxSizeW : wxWhatScrollData::wxSizeH);
+	if ((long)whatScrollData & (long)sizeScrollData)
+	{
+		int newSize = scrollData->GetValue(sizeScrollData);
+		SetMaxValue(newSize);
+	}
+
+	wxWhatScrollData postionScrollData =
+		(horizontal ? wxWhatScrollData::wxPositionH : wxWhatScrollData::wxPositionV);
+	if ((long)whatScrollData & (long)postionScrollData)
+	{
+		int newPosition = scrollData->GetValue(postionScrollData);
+		SetValue(newPosition);
+	}
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Sizing methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxScrollBar::OnClientAreaDSize(int dW, int dH, int dX, int dY) // mac platform only
+{
+	SetCurrentDC();
+
+	Bool isVisible = (**cMacControl).contrlVis == 255;
+	Bool hideToPreventFlicker = (isVisible && (dX || dY) && (dW || dH));
+	if (hideToPreventFlicker) ::HideControl(cMacControl);
+
+	if (dW || dH)
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		::SizeControl(cMacControl, clientWidth, clientHeight);
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put new origin at (0, 0)
+		::MoveControl(cMacControl, 0, 0);
+	}
+
+	if (hideToPreventFlicker) ::ShowControl(cMacControl);
+
+	if (cHidden && (dW || dH || dX || dY))
+	{
+		int clientWidth, clientHeight;
+		GetClientSize(&clientWidth, &clientHeight);
+		Rect clientRect = {0, 0, clientHeight, clientWidth};
+		::InvalRect(&clientRect);
+	}
+}
diff --git a/src/wxmac/src/mac/wx_screen.cc b/src/wxmac/src/mac/wx_screen.cc
new file mode 100644
index 0000000..bcf8424
--- /dev/null
+++ b/src/wxmac/src/mac/wx_screen.cc
@@ -0,0 +1,80 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_screen.cc
+// Purpose:	Macintosh wxScreen implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_screen.h"
+#include "wx_area.h"
+#include <QuickDraw.h>
+
+wxScreen* wxScreen::gScreenWindow = NULL; // mac platform only
+
+//=============================================================================
+// Construction methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScreen::wxScreen // Constructor (for screen window)
+	(
+		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		WXTYPE		objectType
+	) :
+		wxWindow (windowName, x, y, width, height, style)
+{
+	GrafPtr wPort;
+	::GetWMgrPort(&wPort);
+	Rect wPortRect = wPort->portRect;
+	if (x == -1) cWindowX = 0;
+	if (y == -1) cWindowY = 0;
+	if (width < 0) cWindowWidth = wPortRect.right - wPortRect.left;
+	if (height < 0) cWindowHeight = wPortRect.bottom - wPortRect.top;
+
+  	cMenuArea = new wxArea(this);
+  	cScreenArea = new wxArea(this);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxScreen::~wxScreen(void)
+{
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Sizing methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxScreen::DoSetSize(int x, int y, int width, int height)
+{
+	cWindowX = x;
+	cWindowY = y;
+	cWindowWidth = width;
+	cWindowHeight = height;
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxArea* wxScreen::ScreenArea(void) { return cScreenArea; }
+
+//-----------------------------------------------------------------------------
+wxArea* wxScreen::MenuArea(void){ return cMenuArea; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxScreen::Show(Bool show) { }
\ No newline at end of file
diff --git a/src/wxmac/src/mac/wx_slidr.cc b/src/wxmac/src/mac/wx_slidr.cc
new file mode 100644
index 0000000..cfe46dd
--- /dev/null
+++ b/src/wxmac/src/mac/wx_slidr.cc
@@ -0,0 +1,366 @@
+/*
+ * File:	wx_slidr.cc
+ * Purpose:	Panel item slider implementation (Macintosh version)
+ * Author:	Cecil Coupe
+ * Created:	1995
+ * Updated:	
+ * Copyright:	(c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+ */
+
+static const char sccsid[] = "%W% %G%";
+
+
+
+#include <iostream.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "common.h"
+#include "wx_mgstr.h"
+#include "wx_utils.h"
+#include "wx_slidr.h"
+
+
+#define MEANING_CHARACTER	'0'
+
+#define  USE_ACTIONPROC 0	// set to 1 to try the thumbtracking stuff
+							// unfinished (crashes system) as of 7/29/95
+
+// Slider
+/* 
+	For wxMac a wxSlider contains
+	1. A scroll control (horizontal)
+	2. A wxLabelArea for the Label/Title
+	3. a Rect for displaying the current value
+
+*/
+
+#define KDEFAULTW  60	// number pixels wide for a default scroll control
+#define KSCROLLH   16	// height of a mac scrollbar control
+#define VSP			2	// space between scrollbar and value
+#define HSP			2	
+// Because I never get this right and t,l,b,r makes sense to me - CJC
+//
+#define SetBounds(rect, top, left, bottom, right) ::SetRect(rect, left, top, right, bottom)
+
+wxSlider::wxSlider(wxPanel *panel, wxFunction func, char *label, int value,
+           int min_value, int max_value, int width, int x, int y,
+           long style, char *name, WXTYPE objectType
+	):
+  wxbSlider(panel, label, value, min_value, max_value, width, x, y, style, name)
+{
+  Create(panel, func, label, value, min_value, max_value, width, x, y, style, name);
+}
+
+Bool wxSlider::Create(wxPanel *panel, wxFunction func, char *label, int value,
+           int min_value, int max_value, int width, int x, int y,
+           long style, char *name)
+{
+	windowStyle = style;
+	window_parent = panel;
+	labelPosition = panel->label_position;
+	buttonFont = panel->buttonFont;
+	labelFont = panel->labelFont;
+	backColour = panel->backColour;
+	labelColour = panel->labelColour;
+	buttonColour = panel->buttonColour;
+	
+	label = wxItemStripLabel(label);
+
+    Callback(func);
+	SetCurrentDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	
+  	s_min = min_value;
+  	s_max = max_value;
+	// page_size calculated 
+	page_size = (s_max - s_min) / 15; // 15 == size of thumb ?
+	if (page_size < 2)
+		page_size = 2;
+
+	valueFont = wxNORMAL_FONT;
+	float fWidth;
+	float fHeight;
+	float fDescent;
+	float fLeading;
+	int	lblh=0;
+	int lblw=0;
+	if (label) {
+		GetTextExtent(label, &fWidth, &fHeight, &fDescent, &fLeading, labelFont);
+		lblh = fHeight;
+		lblw = fWidth;
+	}
+	GetTextExtent("258", &fWidth, &fHeight, &fDescent, &fLeading, valueFont);
+	int vwid = (int)fWidth;
+	int vhgt = (int)fHeight;
+
+	Rect boundsRect = {0, 0, KSCROLLH, KDEFAULTW};
+	
+	int adjust = 0;
+	if (style & wxVERTICAL) {
+		if (width < 0)
+			cWindowHeight = KDEFAULTW + ((labelPosition == wxVERTICAL) ? lblh : 0);
+		else
+			cWindowHeight = width;
+		cWindowWidth = vwid + KSCROLLH + HSP + ((labelPosition == wxVERTICAL) ? 0 : lblw + HSP);
+		
+		boundsRect.right = KSCROLLH;
+		boundsRect.bottom = cWindowHeight - ((labelPosition == wxVERTICAL) ? lblh : 0);
+		
+		valueRect.left = cWindowWidth - vwid + 1;
+		valueRect.top = (cWindowHeight - vhgt) / 2;
+		adjust = -1;
+	} else {
+		if (width < 0)
+			cWindowWidth = KDEFAULTW + ((labelPosition == wxHORIZONTAL) ? lblw : 0);
+		else
+			cWindowWidth = width;
+		cWindowHeight = vhgt + KSCROLLH + VSP + ((labelPosition == wxVERTICAL) ? lblh + VSP : 0);
+		
+		boundsRect.right = cWindowWidth - ((labelPosition == wxVERTICAL) ? 0 : lblw);
+		
+		valueRect.top = cWindowHeight - vhgt;
+		valueRect.left = (cWindowWidth - vwid) / 2;
+	}
+
+	valueRect.bottom = valueRect.top + vhgt;
+	valueRect.right = valueRect.left + vwid + adjust;
+	
+	valuebase = fDescent;
+	
+	cMacControl = ::NewControl((WindowPtr)theMacGrafPort, &boundsRect, NULL,
+			TRUE, value, min_value, max_value, scrollBarProc, 0);
+	CheckMemOK(cMacControl);
+
+	::SetCRefCon(cMacControl, (long)this);
+	if (label)
+	{
+		cTitle = new wxLabelArea(this, label, labelFont,
+				labelPosition == wxVERTICAL ? Direction::wxTop : Direction::wxLeft);
+	}
+	else
+		cTitle = NULL;
+
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+	
+	return TRUE;
+}
+
+// ------------ Destructor ----------------------------------------
+wxSlider::~wxSlider(void)
+{
+	 delete cTitle;	// Special care needed to delete Areas
+	::DisposeControl(cMacControl);
+}
+
+
+//------------ Event Handling --------------------------------------
+void wxSlider::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+	::Draw1Control(cMacControl);
+
+	SetFont(valueFont);
+	SetTextInfo();
+	
+	::MoveTo(valueRect.left, valueRect.bottom - valuebase);
+	::EraseRect(&valueRect);
+	char t[8];
+	sprintf(t,"%d",::GetControlValue(cMacControl));
+	::DrawText(t,0,strlen(t));
+	wxWindow::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxSlider::DoShow(Bool show)
+{
+	if (!CanShow(show)) return;
+
+	SetCurrentDC();
+
+	if (show)
+		::ShowControl(cMacControl);
+	else
+		::HideControl(cMacControl);
+		
+	cTitle->DoShow(show);
+		
+	wxWindow::DoShow(show);
+}
+
+void wxSlider::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+	SetCurrentDC();
+	if (dW || dH)
+	{	
+		int clientWidth = ClientArea()->Width();
+		int clientHeight= ClientArea()->Height();
+		Rect viewRect = (**cMacControl).contrlRect;
+
+		int vwid = valueRect.right - valueRect.left;
+		int vhgt = valueRect.bottom - valueRect.top;
+			
+		if (windowStyle & wxVERTICAL) {
+			int w = viewRect.right - viewRect.left;
+			// the wid can't change
+			::SizeControl(cMacControl, w, clientHeight);
+			valueRect.top = (clientHeight - vhgt) / 2;
+			valueRect.bottom = valueRect.top + vhgt;
+			valueRect.right = clientWidth;
+			valueRect.left = valueRect.right - vwid + 1;
+		} else {
+			int h = viewRect.bottom - viewRect.top;
+			// the hgt can't change
+			::SizeControl(cMacControl, clientWidth, h);
+			valueRect.left = (clientWidth - vwid) / 2;
+			valueRect.right = valueRect.left + vwid;
+			valueRect.bottom = clientHeight;
+			valueRect.top = valueRect.bottom - vhgt;
+		}
+	}
+
+	if (dX || dY)
+	{	// Changing the position
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put newViewRect at (0, 0)
+	}
+}
+
+// ---- everything above this line is needed for visual respresentation of the wxListBox
+#if USE_ACTIONPROC
+static pascal void SCTrackActionProc(ControlHandle theControl, short thePart);
+static ControlActionUPP SCTrackActionProcUPP = NewControlActionProc(SCTrackActionProc);
+#endif
+
+void wxSlider::OnEvent(wxMouseEvent& event) // WCH: mac only ?
+{
+	if (event.leftDown) {
+		float fStartH, fStartV;
+		event.Position(&fStartH, &fStartV); // client c.s.
+		int startH = fStartH;
+		int startV = fStartV;
+		Point pt = {startV, startH};
+		SetCurrentDC();
+		int part;
+		int oldval = ::GetCtlValue(cMacControl);
+#if USE_ACTIONPROC
+		part = ::TestControl(cMacControl, pt);
+		if (part && part == inThumb) {
+			::TrackControl(cMacControl, pt, SCTrackActionProcUPP);
+		}
+		else 
+#endif
+		{
+			part = ::TrackControl(cMacControl, pt, NULL);
+			switch (part) {
+			case 0:
+				break;
+			case inUpButton:
+				::SetCtlValue(cMacControl, max(s_min, oldval-1));
+				break;
+			case inDownButton:
+				::SetCtlValue(cMacControl, min(s_max, oldval+1));
+				break;
+			case inPageUp:
+				::SetCtlValue(cMacControl, max(s_min, oldval-page_size));
+				break;
+			case inPageDown:
+				::SetCtlValue(cMacControl, min(s_max, oldval+page_size));
+				break;
+			case inThumb:
+				break;
+			} // end switch
+			// Draw the new value or should we Invalidate the Rect or don't bother ?
+			::MoveTo(valueRect.left+HSP, valueRect.bottom - valuebase);
+			::EraseRect(&valueRect);
+			char t[8];
+			sprintf(t,"%d",::GetControlValue(cMacControl));
+			::DrawText(t,0,strlen(t));
+			// Creat a wxEvent
+			strcpy(wxBuffer,t);
+			wxCommandEvent *commandEvent = new wxCommandEvent(wxEVENT_TYPE_SLIDER_COMMAND);
+			commandEvent->commandString = wxBuffer;
+			commandEvent->commandInt = ::GetControlValue(cMacControl);
+			commandEvent->eventObject = this;
+	  		ProcessCommand(*commandEvent);
+		}
+	}
+}
+
+#if USE_ACTIONPROC
+// Update the Value rect as the thumb is dragged around
+static pascal void SCTrackActionProc(ControlHandle theControl, short thePart)
+{
+	wxSlider*	slider;
+	slider = (wxSlider*)::GetCRefCon(theControl);
+#if 0
+	::MoveTo(slider->valueRect.left+HSP, slider->valueRect.bottom - slider->valuebase);
+	::EraseRect(&slider->valueRect);
+	char t[8];
+	sprintf(t,"%d",::GetControlValue(theControl));
+	::DrawText(t,0,strlen(t));
+#endif	
+}
+#endif
+
+// --------------------- Client API ---------------------
+int wxSlider::GetValue(void)
+{
+	return ::GetControlValue(cMacControl);
+}
+
+void wxSlider::SetValue(int value)
+{
+	::SetControlValue(cMacControl, value);
+}
+
+
+#if 0 // the following 3 methods are in wxWindows 16.x but should not
+	  // be implemented in wxMac because they interfere with the Area
+	  // calcs. This is a FIXME
+void wxSlider::SetSize(int x, int y, int width, int height)
+{
+}
+void wxSlider::GetSize (int *x, int *y)
+{
+}
+
+void wxSlider::GetPosition(int *x, int *y)
+{
+}
+#endif
+
+void wxSlider::SetBackgroundColour(wxColour*col)
+{
+} 
+
+void wxSlider::SetLabelColour(wxColour*col)
+{
+}
+
+void wxSlider::SetButtonColour(wxColour*col) 
+{
+}
+
+char* wxSlider::GetLabel(void)
+{
+	return (cTitle ? cTitle->GetLabel() : NULL);
+}
+
+void wxSlider::SetLabel(char *label)
+{
+	if (cTitle) cTitle->SetLabel(label);
+	
+}
+
+void wxSlider::ChangeToGray(Bool gray)
+{
+  if (cTitle)
+	((wxLabelArea *)cTitle)->GetMessage()->InternalGray(gray);
+  SetCurrentDC();
+  if (cMacControl)
+  	::HiliteControl(cMacControl, gray ? kInactiveControl : kActiveControl);
+  wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_text.cc b/src/wxmac/src/mac/wx_text.cc
new file mode 100644
index 0000000..3d4adea
--- /dev/null
+++ b/src/wxmac/src/mac/wx_text.cc
@@ -0,0 +1,328 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_text.cc
+// Purpose:	wxTextWindow implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+//#include <iostream.h>
+//#include <fstream.h>
+
+#ifdef GUSI
+#  include <sys/types.h>	// Get these from GUSI
+#  include <sys/stat.h>
+#elif !defined(MPW) 		// ie #if Symantec, plain CW
+#  include <unix.h>
+#else
+#  include "macstat.h"		// Python or MPW
+#endif
+#include <stdio.h>
+#include "wx_item.h"
+#include "wx_text.h"
+#include "wx_mtxt.h"
+#include "wx_frame.h"
+#include "wx_area.h"
+#include "wxBorderArea.h"
+#include "wxDirection.h"
+#include "wx_mac_utils.h"
+
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxTextWindow::wxTextWindow // Constructor (given parentArea)
+	(
+		wxArea*	parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbTextWindow (objectType, windowName, parentArea, x, y, width, height, style)
+{
+	CreateWxTextWindow();
+}
+
+//-----------------------------------------------------------------------------
+wxTextWindow::wxTextWindow // Constructor (given parentFrame)
+	(
+		wxFrame*	parentFrame,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbTextWindow (objectType, windowName, parentFrame, x, y, width, height, style)
+{
+	CreateWxTextWindow();
+}
+
+//-----------------------------------------------------------------------------
+wxTextWindow::wxTextWindow // Constructor (given parentFrame)
+	(
+		wxPanel*	parentFrame,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style,
+		char*		windowName,
+		WXTYPE		objectType
+	) :
+		wxbTextWindow (objectType, windowName, parentFrame, x, y, width, height, style)
+{
+	CreateWxTextWindow();
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxTextWindow::~wxTextWindow(void)
+{
+  // necessary change: We could be focus_window! So lets change the focus_window 
+  // for our frame! - tom
+  DestroyFocus();
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::CreateWxTextWindow(void) // common constructor initialization
+{
+// CJC 	if (cStyle & wxBORDER) new wxBorderArea(this);
+	new wxBorderArea(this);
+
+	int clientWidth = ClientArea()->Width();
+	int clientHeight = ClientArea()->Height();
+	if (cStyle & wxNATIVE_IMPL) {
+		cStyle |= (wxVSCROLL | wxHSCROLL);
+	}
+	else {
+		cStyle |= wxVSCROLL;
+	}
+	cTextBox = new wxMultiText(this, NULL, NULL, "",
+							0, 0, clientWidth, clientHeight,
+							cStyle, "multiTextBox");
+	cTextBox->SetJustify(Direction::wxAll);
+	
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxTextWindow::LoadFile(char* file)
+{
+	struct stat statb;
+	Bool result = FALSE;
+
+	if (!file) return FALSE;
+
+	if (file_name) delete[] file_name;
+
+	file_name = macCopyString(file);
+
+	if ((stat(file, &statb) == -1) || ((statb.st_mode & S_IFMT) != S_IFREG))
+	{
+		return FALSE;
+	}
+	FILE* fp = fopen(file, "rb"); // WCH: why require "rb" instead of "r" to get newline chars
+	if (!fp) return FALSE;
+
+	long len = statb.st_size;
+	char* text = new char[len + 1];
+	if (text)
+	{
+		if (fread(text, sizeof(char), len, fp) == len)
+		{
+			text[len] = 0;
+			long lastPosition = GetLastPosition();
+			Replace(0, lastPosition, text);
+			cTextBox->SetModified(FALSE);
+			result = TRUE;
+		}
+	
+		delete [] text;
+	}
+
+	fclose(fp);
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+// If file is null, try saved file name first; returns TRUE if succeeds.
+//-----------------------------------------------------------------------------
+Bool wxTextWindow::SaveFile(char* file)
+{
+	Bool result = FALSE;
+
+	if (!file) return FALSE;
+
+	if (FILE* fp = fopen(file, "w"))
+	{
+		char *buf = GetContents();
+		char *t = buf;
+		char lastc;
+		while (*t) {
+			lastc = *t;
+			if (lastc == '\015') // Replace CR that ToolBox TxEdit uses for line endings
+				lastc = '\n';
+			fputc(lastc, fp);
+			t++;
+		}
+		if (lastc != '\n')
+			fputc('\n', fp);
+		delete [] buf;
+		fclose(fp);
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::SetEditable(Bool editable)
+{
+	cTextBox->SetEditable(editable);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Paint(void)
+{
+	if (cHidden) return;
+	SetCurrentDC();
+	wxWindow::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::DoShow(Bool show) {
+	wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Enable(Bool Flag) { cTextBox->Enable(Flag); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::SetFont(wxFont *theFont) // mac platform only
+{
+	font = theFont;
+	cTextBox->SetFont(theFont);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::SetFocus(void) { cTextBox->SetFocus(); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::WriteText(char* text) { cTextBox->WriteText(text); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Clear(void) { cTextBox->Clear(); }
+
+//-----------------------------------------------------------------------------
+// Not clear whether Clear is required as well as DiscardEdits
+//-----------------------------------------------------------------------------
+void wxTextWindow::DiscardEdits(void) { cTextBox->DiscardEdits(); }
+
+//-----------------------------------------------------------------------------
+char* wxTextWindow::GetContents(void) { return cTextBox->GetContents(); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::SetInsertionPoint(long pos) { cTextBox->SetInsertionPoint(pos); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::SetInsertionPointEnd(void) { cTextBox->SetInsertionPointEnd(); }
+
+//-----------------------------------------------------------------------------
+long wxTextWindow::GetInsertionPoint(void) { return cTextBox->GetInsertionPoint(); }
+
+//-----------------------------------------------------------------------------
+long wxTextWindow::GetLastPosition(void) { return cTextBox->GetLastPosition(); }
+
+//-----------------------------------------------------------------------------
+long wxTextWindow::XYToPosition(long x, long y) // x is char pos, y is line number?
+{
+	return cTextBox->XYToPosition(x, y);
+}
+
+//-----------------------------------------------------------------------------
+// CJC - pos is probably the character index. Return the line no. (y) and place in
+// that line (x). NOTE: The save and restore of the current point may not be
+// necessary ??
+void wxTextWindow::PositionToXY(long pos, long* x, long* y) // counting from 0
+{
+	long saveipt = cTextBox->GetInsertionPoint();
+	cTextBox->SetInsertionPoint(pos);
+	cTextBox->PositionToXY(x, y);
+	cTextBox->SetInsertionPoint(saveipt);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::ShowPosition(long pos) { cTextBox->ShowPosition(pos); }
+
+//-----------------------------------------------------------------------------
+int wxTextWindow::GetLineLength(long lineNo) // lineNo starts at zero
+{
+	return cTextBox->GetLineLength(lineNo);
+}
+
+//-----------------------------------------------------------------------------
+int wxTextWindow::GetNumberOfLines(void) { return cTextBox->GetNumberOfLines(); }
+
+//-----------------------------------------------------------------------------
+int wxTextWindow::GetLineText(long lineNo, char* buf) // WCH: THIS ALLOCATES buf!!!
+{
+	return cTextBox->GetLineText(lineNo, buf);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Replace(long from, long to, char* value)
+{
+	cTextBox->Replace(from, to, value);
+}
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Remove(long from, long to) { cTextBox->Remove(from, to); }
+
+//-----------------------------------------------------------------------------
+void wxTextWindow::Highlight(long from, long to)
+{
+	cTextBox->Highlight(from, to);
+}
+
+//-----------------------------------------------------------------------------
+Bool wxTextWindow::Modified(void) { return cTextBox->Modified(); }
+
+// Cut, copy, paste, etc
+ void wxTextWindow::Copy()
+ {
+   cTextBox->Copy();
+ }
+
+ void wxTextWindow::Paste()
+ {
+  cTextBox->Paste();
+ }
+
+ void wxTextWindow::Cut()
+ {
+  cTextBox->Cut();
+ }
+
+ void wxTextWindow::SetSelection(long start, long end)
+ {
+	cTextBox->SetInsertionPoint(start);
+ }
+
diff --git a/src/wxmac/src/mac/wx_timer.cc b/src/wxmac/src/mac/wx_timer.cc
new file mode 100644
index 0000000..6d71e0c
--- /dev/null
+++ b/src/wxmac/src/mac/wx_timer.cc
@@ -0,0 +1,97 @@
+/*
+ * File:      wx_timer.cc
+ * Purpose:     wxTimer implementation (MacIntosh Version)
+ * Author:      Julian Smart/Cecil Coupe
+ * Created:     1993
+ * Updated:	August 1995
+ * RCS_ID:      $Id: wx_timer.cc,v 1.3 1994/08/14 21:28:43 edz Exp $
+ * Copyright:   (c) 1993, AIAI, University of Edinburgh
+ */
+
+static const char sccsid[] = "@(#)wx_timer.cc	1.2 5/9/94";
+
+/* MrEd re-implements */
+#if 0
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include <time.h>
+#include "wx_timer.h"
+#include "wx_list.h"
+#include "wx_main.h"
+#include "wx_frame.h"
+#include "wx_utils.h"
+
+/*
+   There are several ways to handle async timer events on the Mac. The trick is to
+   remove them when an app quits, crashes, or when debugging. Also we have to make sure
+   that the system is in a state that we can actually make other ToolBox calls. 
+   
+   As it stands today (8/25/95), we will only process timer events when the "system"
+   can handle it, i.e., when taking events with WaitNextEvent. This implies that whatever
+   mechanism we use for the async notification, it should build a MacOS event.
+   
+   Now, if accuracy and latency isn't too important, we could kludge this by having the wxMac 
+   event loop processor, whenever it awakes from the wait, get the ansi time and search a list
+   (ordered queue?) of wxTimers which have the a 'future fire' time data member. If the
+   node(s) time is <= current time, call the callback, and then remove the node from the
+   list. If its not a one shot timer node, calculate a new future time (now + timer increment)
+   and (re)queue a (new)node. This can be done by modifying wx_app.cc [to possibly lower the 
+   sleep time] and to call a function doMacTimerCheck(). Also we need a global or app scope
+   variable for the queue head. Of course we'll have to create a class for these timer nodes
+   and modify the wx_xxx.h and wb_xxx.h files accordingly.
+   
+*/
+
+#ifdef wx_motif
+void 
+wxTimerCallback (wxTimer * timer)
+{
+  if (timer->timerId == 0)
+    return;			// Avoid to process spurious timer events
+
+  if (!timer->oneShot)
+    timer->timerId = XtAppAddTimeOut (wxTheApp->appContext, timer->milli,
+		  (XtTimerCallbackProc) wxTimerCallback, (XtPointer) timer);
+  else
+    timer->timerId = 0;
+  timer->Notify ();
+}
+#endif
+
+wxList gTimerList;
+
+wxTimer::wxTimer (void)
+{
+}
+
+wxTimer::~wxTimer (void)
+{
+  Stop ();
+}
+
+Bool wxTimer::Start (int milliseconds, Bool mode)
+{
+  oneShot = mode;
+  if (milliseconds < 0)
+    milliseconds = lastMilli;
+
+  if (milliseconds <= 0)
+    return FALSE;
+
+  lastMilli = milli = milliseconds;
+  fireTime = ::TickCount() + (milliseconds / (1000 / CLOCKS_PER_SEC));
+  gTimerList.Append(this);
+  return TRUE;
+}
+
+void wxTimer::Stop (void)
+{
+  milli = 0;
+  gTimerList.DeleteObject(this);	// removes timer from list. Object still exists
+}
+
+#endif
+
diff --git a/src/wxmac/src/mac/wx_txt.cc b/src/wxmac/src/mac/wx_txt.cc
new file mode 100644
index 0000000..1523d5b
--- /dev/null
+++ b/src/wxmac/src/mac/wx_txt.cc
@@ -0,0 +1,926 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_txt.cc
+// Purpose:	Panel item wxText implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_item.h"
+#include "wx_txt.h"
+#include "wxScroll.h"
+#include "wx_mac_utils.h"
+#include "wxMacDC.h"
+#include "wx_gdi.h"
+#include "wx_stdev.h"
+#include "wx_area.h"
+#include "wxLabelArea.h"
+#include "wxBorderArea.h"
+#include "wxMacDC.h"
+#include "wxScrollArea.h"
+#include "wx_panel.h"
+#include "wx_frame.h"
+#include "wx_text.h"
+#include "wx_timer.h"
+#include <QuickDraw.h>
+#include <Memory.h>
+
+#define TEXT_MARGIN 2
+#define DEFAULT_TEXT_WIDTH 60
+
+extern char *wxBuffer;
+//=============================================================================
+// Public constructors
+//=============================================================================
+
+static wxText *idleTE;
+
+class wxTE_Idler : public wxTimer
+{
+  void Notify() {
+    if (idleTE)
+      idleTE->DoPeriodicAction();
+  }
+};
+
+static wxTE_Idler *TE_idler;
+
+//-----------------------------------------------------------------------------
+wxText::wxText // Constructor (given parentPanel)
+	(
+		wxPanel*		parentPanel,
+		wxFunction		function,
+		char*			label,
+		char*			value,
+		int 			x,
+		int				y,
+		int				width,
+		int				height,
+		long			style,
+		char*			windowName,
+		WXTYPE			objectType
+	) :
+		wxbText (parentPanel, x, y, width, height, style, windowName),
+		cTextEditable (TRUE),
+		cTextModified (FALSE)
+{
+	Callback(function);
+
+	CreateWxText(label, value);
+}
+
+//-----------------------------------------------------------------------------
+wxText::wxText // Constructor (given parentTextWindow)
+	(
+		wxTextWindow*	parentTextWindow,
+		wxFunction		function,
+		char*			label,
+		char*			value,
+		int 			x,
+		int				y,
+		int				width,
+		int				height,
+		long			style,
+		char*			windowName,
+		WXTYPE			objectType
+	) :
+		wxbText (parentTextWindow, x, y, width, height, style, windowName),
+		cTextEditable (TRUE),
+		cTextModified (FALSE)
+
+{
+	Callback(function);
+
+	CreateWxText(label, value);
+}
+//==============
+// A dummy to satisfy Linkers
+//
+wxText::wxText()
+{
+}
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxText::~wxText(void)
+{
+ 	DestroyFocus(); // tom: just to be sure
+	if (cMacTE) 
+	  ::TEDispose(cMacTE);
+		
+	if (TE_idler && (idleTE == this)) {
+	  idleTE == NULL;
+	  TE_idler->Stop();
+	}
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+void wxText::CreateWxText(char* label, char* value) // common constructor initialization
+{
+	SetEraser(NULL);
+
+	if (label)
+  	  label = wxItemStripLabel(label);
+
+//////////////////////////////////////////
+// do platform stuff:
+//////////////////////////////////////////
+	if (!buttonFont)
+	  buttonFont = wxNORMAL_FONT;
+	if (!labelFont)
+	  labelFont = wxNORMAL_FONT;
+
+	SetCurrentMacDC();
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+
+	float tWidth, tHeight;
+	float lWidth, lHeight;
+	GetTextExtent("X", &tWidth, &tHeight, NULL, NULL, buttonFont);
+	GetTextExtent(label ? label : "X", &lWidth, &lHeight, NULL, NULL, labelFont);
+
+	int clientHeight = ClientArea()->Height();
+	if (clientHeight <= 0) {
+		int lblh = (label && (labelPosition == wxVERTICAL) ? (int)lHeight : 0);
+		clientHeight = cWindowHeight = (int)tHeight + 2 * TEXT_MARGIN + 2; // +2 for border
+		cWindowHeight = clientHeight + lblh;
+	}
+	int clientWidth = ClientArea()->Width();
+	if (clientWidth <= 0) {
+		int lblw = (label && (labelPosition != wxVERTICAL) ? (int)lWidth : 0);
+		clientWidth = DEFAULT_TEXT_WIDTH + (2 * TEXT_MARGIN) + 2; // +2 for border
+		cWindowWidth = clientWidth + lblw;
+	}
+	Rect destRect = {TEXT_MARGIN, TEXT_MARGIN, 
+					 clientHeight - TEXT_MARGIN, clientWidth - TEXT_MARGIN};
+	cMacTE = ::TENew(&destRect, &destRect);
+	CheckMemOK(cMacTE);
+
+	SetFont(buttonFont);
+    HLock((Handle)cMacTE);
+ 	(*cMacTE)->crOnly = -1;
+ 	HUnlock((Handle)cMacTE);
+ 	//  tom (fettig@dfki.uni-sb.de)	 
+ 	//  True single line Mode!
+ 	::TEAutoView(TRUE,cMacTE);
+
+//////////////////////////////////////////
+// do more wxWindow stuff:
+//////////////////////////////////////////
+	if (cStyle & wxVSCROLL || cStyle & wxHSCROLL)
+	{
+		wxScrollData* scrollData = new wxScrollData;
+#if 0 // mflatt: Hello didn't run with "1"
+		new wxScrollArea(this, this, (cStyle & wxVSCROLL) | (cStyle & wxHSCROLL));
+#else
+		cScroll = new wxScroll(this, scrollData);
+		if (cStyle & wxVSCROLL) new wxScrollArea(this, this, wxVSCROLL);
+		if (cStyle & wxHSCROLL) new wxScrollArea(this, this, wxHSCROLL);
+#endif
+	}
+
+	// mflatt: text should always have a border
+#if 0
+	if (cStyle & wxBORDER) 
+#endif
+		new wxBorderArea(this);
+
+	if (label)
+	{
+		cLabelArea = new wxLabelArea(this, label, labelFont,
+				labelPosition == wxVERTICAL ? Direction::wxTop : Direction::wxLeft,
+				0,
+				labelPosition == wxVERTICAL ? 0 : 1 + TEXT_MARGIN);
+	}
+	else cLabelArea = NULL;
+
+	
+	if (value) 
+	{
+		SetValue(value);
+		cTextModified = FALSE; // kludge
+	}
+	
+		
+	if (GetParent()->IsHidden())
+		DoShow(FALSE);
+}
+
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Other methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxText::WriteText(char* text)
+{
+	SetCurrentDC();
+	long endPosition = (**cMacTE).teLength;
+	::TESetSelect(endPosition, endPosition, cMacTE);
+	::TEInsert(text, strlen(text), cMacTE);
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::Clear(void)
+{
+	SetCurrentDC();
+	long endPosition = (**cMacTE).teLength;
+	::TESetSelect(0, endPosition, cMacTE);
+	::TEDelete(cMacTE);
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+Bool wxText::Modified(void) { return cTextModified; }
+
+//-----------------------------------------------------------------------------
+void wxText::SetModified(Bool modified) // mac platform only
+{
+	cTextModified = modified;
+}
+
+//-----------------------------------------------------------------------------
+// Not clear whether Clear is required as well as DiscardEdits
+//-----------------------------------------------------------------------------
+void wxText::DiscardEdits(void)
+{
+	SetCurrentDC();
+	long endPosition = (**cMacTE).teLength;
+	::TESetSelect(0, endPosition, cMacTE);
+	::TEDelete(cMacTE);
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetEditable(Bool editable) { cTextEditable = editable; }
+
+//-----------------------------------------------------------------------------
+char* wxText::GetContents(void)
+{
+	CharsHandle theMacText = ::TEGetText(cMacTE);
+	int theMacTextLength = (**cMacTE).teLength;
+	char* result = new char[theMacTextLength + 1];
+	BlockMove(*theMacText, result, theMacTextLength);
+	result[theMacTextLength] = 0; // terminate "C" string
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetInsertionPoint(long pos)
+{
+	SetCurrentDC();
+	::TESetSelect(pos, pos, cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetInsertionPointEnd(void)
+{
+	SetCurrentDC();
+	long endPosition = (**cMacTE).teLength;
+	::TESetSelect(endPosition, endPosition, cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+long wxText::GetInsertionPoint(void) { return (**cMacTE).selStart; }
+
+//-----------------------------------------------------------------------------
+long wxText::GetLastPosition(void) { return (**cMacTE).teLength; }
+
+//-----------------------------------------------------------------------------
+long wxText::XYToPosition(long x, long y) // x is char pos, y is line number?
+{
+	long numberOfLines = GetNumberOfLines();
+
+	if (y >= numberOfLines || y < 0) return 0;
+
+	long startPos = (**cMacTE).lineStarts[y];
+
+	return startPos + x;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::PositionToXY(long* x, long* y) // counting from 0
+{
+	long thePosition = GetInsertionPoint();
+	long numberOfLines = GetNumberOfLines();
+
+	long theY = -1;
+	long lineAt = numberOfLines - 1; // counting from 0
+	while (lineAt >= 0 && theY == -1) // count down to 0
+	{
+		if (thePosition < (**cMacTE).lineStarts[lineAt])
+			lineAt--; // count down to 0
+		else theY = lineAt;
+	}
+
+	if (theY != -1)
+	{
+		*x = thePosition - (**cMacTE).lineStarts[theY]; // counting from 0
+		*y = theY; // counting from 0
+	}
+	else
+	{
+		*x = 0;
+		*y = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxText::ShowPosition(long pos)
+{
+#ifdef wx_motif
+  Widget textWidget = (Widget)handle;
+  XmTextShowPosition(textWidget, (XmTextPosition)pos);
+#endif
+#ifdef wx_xview
+  Textsw textsw = (Textsw)handle;
+  
+  xv_set(textsw, TEXTSW_FIRST, (Textsw_index)pos, NULL);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+int wxText::GetLineLength(long lineNo) // lineNo starts at zero
+{
+	long numberOfLines = GetNumberOfLines();
+
+	if (lineNo >= numberOfLines || lineNo < 0) return 0;
+
+	long startPos = (**cMacTE).lineStarts[lineNo];
+
+	long nextLineNo = lineNo + 1;
+	long nextStartPos;
+	if (nextLineNo < numberOfLines)
+		 nextStartPos = (**cMacTE).lineStarts[nextLineNo];
+	else nextStartPos = (**cMacTE).teLength;
+
+	return nextStartPos - startPos;
+}
+
+//-----------------------------------------------------------------------------
+int wxText::GetNumberOfLines(void) { return (**cMacTE).nLines; }
+
+//-----------------------------------------------------------------------------
+int wxText::GetLineText(long lineNo, char* buf) // WCH: THIS ALLOCATES buf!!!
+{
+	int length; // lenght of text returned in buf
+	long numberOfLines = GetNumberOfLines();
+
+	if (lineNo >= numberOfLines || lineNo < 0)
+	{
+		length = 0;
+	}
+	else
+	{
+		long startPos = (**cMacTE).lineStarts[lineNo];
+	
+		long nextLineNo = lineNo + 1;
+		long nextStartPos;
+		if (nextLineNo < numberOfLines)
+			 nextStartPos = (**cMacTE).lineStarts[nextLineNo];
+		else nextStartPos = (**cMacTE).teLength;
+		length = nextStartPos - startPos;
+	}
+
+	buf = new char[length + 1]; // WCH: THIS ALLOCATES buf!!!
+	CharsHandle theMacText = ::TEGetText(cMacTE);
+	BlockMove(*theMacText, buf, length); // BlockMove allows args to overlap
+	buf[length] = 0; // terminate "C" string
+
+	return length;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::Replace(long from, long to, char* value)
+{
+	SetCurrentDC();
+	::TESetSelect(from, to, cMacTE);
+	::TEDelete(cMacTE); // doesn't copy selected text to scrap
+	::TEInsert(value, strlen(value), cMacTE);
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::Remove(long from, long to)
+{
+	SetCurrentDC();
+	::TESetSelect(from, to, cMacTE);
+	::TECut(cMacTE); // does copy selected text to scrap
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::Highlight(long from, long to)
+{
+	SetCurrentDC();
+	::TESetSelect(from, to, cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+void wxText::Paint(void)
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+	Rect viewRect = (**cMacTE).viewRect;
+	Rect whiteRect = viewRect;
+	InsetRect(&whiteRect, -TEXT_MARGIN, -TEXT_MARGIN);
+	::EraseRect(&whiteRect);
+	::TEUpdate(&viewRect, cMacTE);
+
+	wxWindow::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void wxText::DoShow(Bool show) 
+{
+  wxWindow::DoShow(show);
+}
+
+//-----------------------------------------------------------------------------
+void wxText::DoPeriodicAction(void) // mac platform only
+{
+	SetCurrentDC();
+	::TEIdle(cMacTE);
+}
+
+//-----------------------------------------------------------------------------
+void wxText::OnChar(wxKeyEvent& event) // mac platform only
+{
+	long st,se;
+  
+	HLock((Handle)cMacTE);
+	st = (*cMacTE)->selStart;
+	se = (*cMacTE)->selEnd;	
+	if (cEnable)
+	{
+ 		// GRW:
+ 		// wxText is really meant to be a single line input, which means that it can be used
+ 		// in dialogs and still have enter/return trigger the dialog's default action.  Since
+ 		// wxMultiText and wxTextWindow count on wxText supporting multiple lines, however,
+ 		// an expedient hack was to preserve this behavior when wxMULTIPLE is specified.
+ 		// Note that I haven't done all of the grunge to make wxText properly behave as a
+ 		// single line input (lines still wrap).
+
+ 		// lets implement the single line mode - tom (fettig@dfki.uni-sb.de)
+		char code = event.keyCode;
+
+		switch (event.keyCode)
+		{
+			case 0x03:	// enter
+			case 0x0D:	// return
+			case 0x09:	// tab
+				if (cStyle & wxPROCESS_ENTER) {
+					wxCommandEvent *command = new wxCommandEvent(wxEVENT_TYPE_TEXT_ENTER_COMMAND);
+					command->eventObject = this;
+					ProcessCommand(*command);
+		 		} else if (!(cStyle & wxMULTIPLE)) {
+				  wxItem::OnChar(event);
+				  return;
+				}
+				break;
+#if 0 // tom replaces:
+			case WXK_UP:
+				code = 30;
+				break;					
+			case WXK_DOWN:
+				code = 31;
+				break;					
+			case WXK_LEFT:
+				code = 28;
+				break;					
+			case WXK_RIGHT:
+				code = 29;
+				break;					
+			default:
+				break;
+		}
+
+		SetCurrentDC();
+		::TEKey(code, cMacTE);
+		macAdjustScrollBars();
+		cTextModified = TRUE;
+	}
+#else
+ 			case WXK_UP:			
+  			case WXK_DOWN:
+ 				break;	
+  			case WXK_LEFT:
+ 	 	 	 if (st>0) {
+ 		  	    st--;
+ 		  	    TESetSelect(st,st,cMacTE);
+ 		  	  } 
+ 		  	  if ( (**cMacTE).selRect.right == 1) {
+ 	  			if (st!=0) {
+ 	   				TEScroll(10,0,cMacTE);
+ 	  			}
+ 			  }
+ 	 	 	break;
+ 	 	 	case WXK_RIGHT:
+ 	 	 	if (se<(*cMacTE)->teLength) {
+ 		  	    se++;
+ 		  	    TESetSelect(se,se,cMacTE);
+ 		  	    TESelView(cMacTE);
+ 		  	  }
+ 	 	 	break;
+ 	 	 	case WXK_HOME:
+ 	 	 	  st = 0;
+ 	 	 	  TESetSelect(st,st,cMacTE);
+ 	 	 	break;
+ 	 	 	case WXK_END:
+ 	 	 	  se = (*cMacTE)->teLength;
+ 	 	 	  TESetSelect(se,se,cMacTE);
+ 	 	 	break;
+ 	 	 	case WXK_DELETE:
+ 	 	      if (se==st) {
+ 	 	        if (se < (*cMacTE)->teLength) {
+ 	 	          se++;
+	 	          TESetSelect(st,se,cMacTE);
+ 	 	        }
+ 	 	      }
+ 	 	    TEDelete(cMacTE);
+ 	 	 	break;
+ 	 	 	case WXK_PAGEUP:
+ 	 	 	break;
+ 	 	 	case WXK_PAGEDOWN:
+ 	 	 	break;		
+  			default:
+ 			  SetCurrentDC(); // tom: I am not sure about this call...
+ 			  char theChar = event.keyCode;
+ 			  ::TEKey(theChar, cMacTE);
+ 			  //macAdjustScrollBars();
+ 			  cTextModified = TRUE;
+ 			break;
+  		}
+  		macAdjustScrollBars();
+  	}
+   if ( ((**cMacTE).viewRect.right-1) <= (**cMacTE).selRect.right) {
+     TEScroll(-10,0,cMacTE);
+   }
+   HUnlock((Handle)cMacTE);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void wxText::OnEvent(wxMouseEvent& event) // WCH: mac only ?
+{
+	if (cEnable)
+	{
+		if (event.LeftDown())
+		{
+			// SetFocus(); // mflatt: no longer needed
+	
+			float fStartH, fStartV;
+			event.Position(&fStartH, &fStartV); // client c.s.
+			int startH = fStartH;
+			int startV = fStartV;
+	
+			SetCurrentDC();
+			Point startPt = {startV, startH}; // client c.s.
+			Bool extendSelection = event.shiftDown;
+			::TEClick(startPt, extendSelection, cMacTE);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetTextInfo(void) // mac platform only
+{
+	int oldTxFont = (**cMacTE).txFont;
+	int oldTxSize = (**cMacTE).txSize;
+	Style oldTxFace = (**cMacTE).txFace;
+	int newTxFont;
+	int newTxSize;
+	Style newTxFace;
+
+	if (!font)
+	{
+		newTxFont = 1;
+		newTxSize = 12;
+		newTxFace = 0;
+	}
+	else
+	{
+		newTxFont = font->GetMacFontNum();
+		newTxSize = font->GetPointSize();
+		newTxFace = font->GetMacFontStyle();
+	}
+
+	(**cMacTE).txFont = newTxFont;
+	(**cMacTE).txSize = newTxSize;
+	(**cMacTE).txFace = newTxFace;
+
+	if (newTxFont != oldTxFont || newTxSize != oldTxSize || newTxFace != oldTxFace)
+	{
+		::TECalText(cMacTE);
+		Rect theViewRect = (**cMacTE).viewRect;
+		::InvalRect(&theViewRect);
+		::EraseRect(&theViewRect);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetFont(wxFont* theFont) // mac platform only
+{
+	SetCurrentMacDC();
+	
+	font = theFont;
+
+	int oldTxFont = (**cMacTE).txFont;
+	int oldTxSize = (**cMacTE).txSize;
+	Style oldTxFace = (**cMacTE).txFace;
+	int newTxFont;
+	int newTxSize;
+	Style newTxFace;
+	int newLineHeight; 											// WCH: 94/12/26
+	int newFontAscent; 											// WCH: 94/12/26
+
+	if (!font)
+	{
+		newTxFont = 1;
+		newTxSize = 12;
+		newTxFace = 0;
+		newLineHeight = 16; 									// WCH: 94/12/26
+		newFontAscent = 12; 									// WCH: 94/12/26
+	}
+	else
+	{
+		newTxFont = font->GetMacFontNum();
+		newTxSize = font->GetPointSize();
+		newTxFace = font->GetMacFontStyle();
+
+		float theWidth; 										// WCH: 94/12/26
+		float theLineHeight; 									// WCH: 94/12/26
+		float theDescent; 										// WCH: 94/12/26
+		float theExternalLeading; 								// WCH: 94/12/26
+		font->GetTextExtent("W", &theWidth, &theLineHeight,
+							&theDescent, &theExternalLeading); 	// WCH: 94/12/26
+		newLineHeight = theLineHeight; 							// WCH: 94/12/26
+		newFontAscent = theLineHeight - theDescent - theExternalLeading; // WCH: 94/12/26
+	}
+
+	(**cMacTE).txFont = newTxFont;
+	(**cMacTE).txSize = newTxSize;
+	(**cMacTE).txFace = newTxFace;
+
+	(**cMacTE).lineHeight = newLineHeight; 						// WCH: 94/12/26
+	(**cMacTE).fontAscent = newFontAscent; 						// WCH: 94/12/26
+
+	if (newTxFont != oldTxFont || newTxSize != oldTxSize || newTxFace != oldTxFace)
+	{
+		::TECalText(cMacTE);
+		Rect theViewRect = (**cMacTE).viewRect;
+		::InvalRect(&theViewRect);
+		::EraseRect(&theViewRect);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetLabel(char* label)
+{
+	if (cLabelArea) cLabelArea->SetLabel(label);
+}
+
+//-----------------------------------------------------------------------------
+char* wxText::GetLabel(void)
+{
+	return (cLabelArea ? cLabelArea->GetLabel() : NULL);
+}
+
+//-----------------------------------------------------------------------------
+char* wxText::GetValue(void)
+{
+	CharsHandle theMacText = ::TEGetText(cMacTE);
+	int theMacTextLength = (**cMacTE).teLength;
+#if 1 // CJC
+	char *result = wxBuffer;
+#else
+	char* result = new char[theMacTextLength + 1];
+#endif
+	BlockMove(*theMacText, result, theMacTextLength);
+	result[theMacTextLength] = 0; // terminate "C" string
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetValue(char* value)
+{
+	SetCurrentDC();
+	long endPosition = (**cMacTE).teLength;
+	::TESetSelect(0, endPosition, cMacTE);
+	::TEDelete(cMacTE); // doesn't copy selected text to scrap
+	::TEInsert(value, strlen(value), cMacTE);
+	macAdjustScrollBars();
+	cTextModified = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+//=============================================================================
+void wxText::ChangeColour(void)
+{
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Activate methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxText::OnSetFocus()
+{
+	if (cHidden) return;
+
+	SetCurrentDC();
+	// The following is a kludge, to prevent flicker during subsequent update event
+	Rect viewRect = (**cMacTE).viewRect;
+	::TEUpdate(&viewRect, cMacTE);
+	::TEActivate(cMacTE); // This is the "ShowAsActive" part
+	::ValidRect(&viewRect);
+	
+	if (!idleTE) {
+	  if (!TE_idler)
+	    TE_idler = new wxTE_Idler;
+	  TE_idler->Start();
+	}
+	idleTE = this;
+}
+
+//-----------------------------------------------------------------------------
+void wxText::OnKillFocus()
+{
+	SetCurrentDC();
+	::TEDeactivate(cMacTE);
+	
+	if (TE_idler && (idleTE == this)) {
+	  idleTE == NULL;
+	  TE_idler->Stop();
+	}
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Scroll methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxText::macAdjustScrollBars(void) // mac platform only
+{
+	if (cScroll)
+	{
+		wxWhatScrollData whatScrollData; // track what scrolldata changes
+		wxScrollData* oldScrollData = cScroll->GetScrollData();
+		wxScrollData scrollData;
+		if (oldScrollData) scrollData = *oldScrollData;
+
+		int maxTop = GetNumberOfLines();
+		if (maxTop != scrollData.GetValue(wxWhatScrollData::wxSizeH))
+		{
+			scrollData.SetValue(maxTop, wxWhatScrollData::wxSizeH);
+			whatScrollData |= wxWhatScrollData::wxSizeH;
+		}
+
+		int units_per_scroll_x = 1;
+		if (units_per_scroll_x != scrollData.GetValue(wxWhatScrollData::wxUnitW))
+		{
+			scrollData.SetValue(units_per_scroll_x, wxWhatScrollData::wxUnitW);
+			whatScrollData |= wxWhatScrollData::wxUnitW;
+		}
+
+		int scrolls_per_page_x = 1;
+		if (scrolls_per_page_x != scrollData.GetValue(wxWhatScrollData::wxPageW))
+		{
+			scrollData.SetValue(scrolls_per_page_x, wxWhatScrollData::wxPageW);
+			whatScrollData |= wxWhatScrollData::wxPageW;
+		}
+
+		int charHeight = GetCharHeight();
+		int units_per_scroll_y = (charHeight > 0 ? charHeight : 1);
+		if (units_per_scroll_y != scrollData.GetValue(wxWhatScrollData::wxUnitH))
+		{
+			scrollData.SetValue(units_per_scroll_y, wxWhatScrollData::wxUnitH);
+			whatScrollData |= wxWhatScrollData::wxUnitH;
+		}
+
+		int clientHeight = ClientArea()->Height();
+		int scrolls_per_page_y = (charHeight > 0 ? clientHeight / charHeight : 1);
+		if (scrolls_per_page_y != scrollData.GetValue(wxWhatScrollData::wxPageH))
+		{
+			scrollData.SetValue(scrolls_per_page_y, wxWhatScrollData::wxPageH);
+			whatScrollData |= wxWhatScrollData::wxPageH;
+		}
+
+		if ((long)whatScrollData != 0)
+			cScroll->SetScrollData(&scrollData, whatScrollData, NULL);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxText::SetScrollData // adjust text within window to match scroll bar setting
+(
+	wxScrollData*		newScrollData,
+	wxWhatScrollData	whatScrollData,
+	wxWindow*			iniatorWindow
+)
+{
+	if (iniatorWindow == this) return;
+
+	Bool isNewPositionH = (long)whatScrollData & wxWhatScrollData::wxPositionH;
+	Bool isNewPositionV = (long)whatScrollData & wxWhatScrollData::wxPositionV;
+
+	if (isNewPositionH || isNewPositionV)
+	{
+		SetCurrentDC();
+		Rect viewRect = (**cMacTE).viewRect;
+		Rect destRect = (**cMacTE).destRect;
+		int oldH = viewRect.left - destRect.left;
+		int oldV = viewRect.top - destRect.top;
+
+		int dH = 0;
+		if (isNewPositionH)
+		{
+			int newH = newScrollData->GetValue(wxWhatScrollData::wxPositionH) *
+						newScrollData->GetValue(wxWhatScrollData::wxUnitW);
+			dH = newH - oldH;
+		}
+
+		int dV = 0;
+		if (isNewPositionV)
+		{
+			int newV = newScrollData->GetValue(wxWhatScrollData::wxPositionV) *
+						newScrollData->GetValue(wxWhatScrollData::wxUnitH);
+			dV = newV - oldV;
+		}
+
+		::TEScroll(-dH, -dV, cMacTE);
+	}
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Sizing methods
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxText::OnClientAreaDSize(int dW, int dH, int dX, int dY)
+{
+	SetCurrentDC();
+
+	int clientWidth = ClientArea()->Width();
+	int clientHeight= ClientArea()->Height();
+
+	Rect newDestRect = {TEXT_MARGIN, TEXT_MARGIN, 
+						clientHeight - TEXT_MARGIN, clientWidth - TEXT_MARGIN};
+	(**cMacTE).viewRect = newDestRect;
+	(**cMacTE).destRect = newDestRect;
+	 // must let platform recalculate any line changes:
+	if (dW || dH)
+	{
+		::TECalText(cMacTE);
+	}
+
+	if (dX || dY)
+	{
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentDC(); // put newViewRect at (0, 0)
+	}
+
+	::InvalRect(&newDestRect); // force redraw of text window
+	::EraseRect(&newDestRect); 
+}
+
+// Cut, copy, paste
+ void wxText::Copy()
+ {
+   ::TECopy(cMacTE);
+ }
+
+ void wxText::Paste()
+ {
+   ::TEPaste(cMacTE);
+ }
+
+ void wxText::Cut()
+ {
+   ::TECut(cMacTE);
+ }
+
+Bool wxText::WantsFocus()
+{
+  return TRUE;
+}
+
+void wxText::ChangeToGray(Bool gray)
+{	
+	ChildrenInternalGray(gray);
+	wxWindow::ChangeToGray(gray);
+}
diff --git a/src/wxmac/src/mac/wx_util.cc b/src/wxmac/src/mac/wx_util.cc
new file mode 100644
index 0000000..ae5c9e9
--- /dev/null
+++ b/src/wxmac/src/mac/wx_util.cc
@@ -0,0 +1,890 @@
+/*
+   FIXME - This needs substantial work
+   10/7/95 - This is just enough to link wxPython v2 and extend - untested and/or stubbed
+   
+   One day, I'll rename it to wx_utils.cc 
+   
+   Some (most of these functions could be based on GUSI or Mac-Python. There ought
+   to be a choice. (Easier than rebuilding python to use GUSI).
+*/
+#include "wx.h"
+#include "wx_utils.h"
+#include "wxstring.h"
+#include "wx_list.h"
+#include <Strings.h>
+#include "wx_main.h"
+#include <stdarg.h>
+#include <ctype.h>
+#if 1
+#include <stat.h>
+#include <unix.h>
+#include <iostream.h>
+#include <Files.h>
+extern "C" long atol(char *);
+extern "C" int atoi(char *);
+#else
+#if defined(PYLIB)
+extern "C" {
+//	#include "MacDefs.h"
+//	#include "macstat.h"
+	#include <stat.h>
+	#include <Files.h>
+//	#define S_ISDIR(x) (x & S_IFDIR)
+	#include "dirent.h"
+	#include "nfullpath.h"
+//	extern "C" mkdir(const char *);
+	extern "C" rmdir(const char *);
+	extern "C" chdir(const char *);
+	extern "C" sleep(int);
+	extern "C" char *getcwd(char *, int);
+	extern "C" long atol(char *);
+	extern "C" int atoi(char *);
+}
+#elif defined(GUSI)
+#include "GUSI.h"
+#else
+#error "GUSI or PYLIB required for this Module"
+#endif
+#endif
+
+#if 0
+static DIR *wxDirStream = NULL;
+#endif
+static char *wxFileSpec = NULL;
+static int wxFindFileFlags = 0;
+
+extern "C" {
+  extern char *scheme_build_mac_filename(FSSpec *spec, int given_dir);
+};
+
+// Get a temporary filename, opening and closing the file.
+char *wxGetTempFileName (const char *prefix, char *dest)
+{
+  static char *temp_folder;
+  static int temp_len;
+  static short last_temp = 0;	// cache last to speed things a bit
+  // At most 1000 temp files to a process! We use a ring count.
+  char *buf;
+
+  if (!temp_folder) {
+    FSSpec spec;
+    if (!FindFolder(kOnSystemDisk, 'temp', kCreateFolder, &spec.vRefNum, &spec.parID))
+	  temp_folder = scheme_build_mac_filename(&spec, 1);
+	else
+	  temp_folder = "";
+	temp_len = strlen(temp_folder);
+  }
+ 
+  if (!prefix)
+    prefix = "";
+  else {
+    int i;
+    for (i = 0; prefix[i]; i++)
+      if (prefix[i] == ':') {
+        prefix = "";
+        break;
+      }
+    if (i > 15)
+      prefix = "";
+  }
+  
+  buf = new WXGC_ATOMIC char[temp_len + strlen(prefix) + 20];
+
+  for (short suffix = last_temp + 1; suffix != last_temp; ++suffix %= 1000)
+    {
+      sprintf (buf, "%s¥%s%d", temp_folder, prefix, (int) suffix); // CJC FIXME - really should get a temp folder
+      if (!wxFileExists (buf))
+	{
+	  // Touch the file to create it (reserve name)
+	  FILE *fd = fopen (buf, "w");
+	  if (fd)
+	    fclose (fd);
+	  last_temp = suffix;
+          if (dest)
+	    strcpy(dest, buf);
+	  else
+	    dest = copystring(buf);
+	  return dest;
+	}
+    }
+  cerr << "wxWindows: error finding temporary file name.\n";
+  if (dest) dest[0] = 0;
+  return NULL;
+}
+
+Bool 
+wxRemoveFile (const char *file)
+{
+#ifdef PYLIB
+  return ((remove ((char*)file) == 0) ? TRUE : FALSE);
+#else
+  return ((unlink ((char*)file) == 0) ? TRUE : FALSE);
+#endif
+}
+
+Bool 
+wxMkdir (const char *dir)
+{
+  // give default perms of owner read and write, group read and
+  // others read. The interface to this func should be changed
+  // to pass the perms info in.
+  // Since directory it must also be searchable @@@
+  // Added S_IXUSR | S_IXGRP | S_IXOTH
+#ifdef PYLIB
+  return (mkdir (dir,  0777) == 0);
+#elif defined(GUSI)
+  return (mkdir (dir, 0777) == 0);
+#else
+  return (mkdir (dir, 0777) == 0);
+#endif
+}
+
+Bool 
+wxRmdir (const char *dir)
+{
+  return (rmdir (dir) == 0);
+}
+
+/* MATTHEW: [5] Mac (use for all platforms?) */
+Bool 
+wxDirExists (const char *filename)
+{
+  struct stat stbuf;
+
+  if (filename && (stat ((char *)filename, &stbuf) == 0))
+    return !!(stbuf.st_mode & S_IFDIR);
+  return FALSE;
+}
+
+
+// Get first file name matching given wild card.
+// Flags are reserved for future use.
+#if 1 || (!defined(GUSI) && !defined(PYLIB)) // i.e. - no other support lib available
+static short find_vref;
+static long find_dir_id;
+static short find_position = -1;
+
+char *wxFindFirstFile(const char *spec, int flags)
+{
+	WDPBRec  wdrec;
+	CInfoPBRec pbrec;
+	
+	wxFindFileFlags = flags;
+	
+	if (wxFileSpec)
+		delete[] wxFileSpec;
+	wxFileSpec = copystring(spec);
+	
+	static char buf[400];
+	
+	// Find path only so we can concatenate
+	// found file onto path
+	char *p = wxPathOnly(wxFileSpec);
+	char *n = wxFileNameFromPath(wxFileSpec);
+	long dirID;
+	
+	/* Get current working dir */
+	wdrec.ioNamePtr = (StringPtr)buf;
+	if (PBHGetVol(&wdrec, FALSE))
+		return NULL;
+	
+	find_vref = wdrec.ioWDVRefNum;
+	find_dir_id = wdrec.ioWDDirID;
+	
+	/* p is NULL => Local directory */
+	if (!p) {
+		// Do nothing; find_wd and dirID are set
+	} else {
+		if (*p == ':') {
+			p++;
+		} else {
+			char *vol = p, vbuf[256];
+			HParamBlockRec hrec;
+			/* It's an absolute path: get the Volume Name and vRefNum */
+			while (*p && *p != ':')
+				p++;
+			if (*p)
+			  *p++ = '\0';
+			strcpy(vbuf, vol);
+			strcat(vbuf, ":");
+			hrec.volumeParam.ioNamePtr = c2pstr(vbuf);
+			hrec.volumeParam.ioVRefNum = 0;
+			hrec.volumeParam.ioVolIndex = -1;
+			if (PBHGetVInfo(&hrec, FALSE))
+				return NULL;
+			find_vref = hrec.volumeParam.ioVRefNum;
+			find_dir_id = 0;
+		}
+		while (p && *p) {
+			char *next = p;
+			while (*next && *next != ':')
+				next++;
+			if (*next)
+				*(next++) = 0;
+			else
+				next = NULL;
+			
+			c2pstr(p);
+			pbrec.hFileInfo.ioNamePtr = (unsigned char *)p;
+			pbrec.hFileInfo.ioVRefNum = find_vref;
+			pbrec.hFileInfo.ioDirID = find_dir_id;
+			pbrec.hFileInfo.ioFDirIndex = 0;
+			if (PBGetCatInfo(&pbrec, FALSE))
+				return NULL;
+			if (!(pbrec.hFileInfo.ioFlAttrib & 0x10))
+				return NULL; // Not a directory
+      		find_dir_id = pbrec.hFileInfo.ioDirID;
+      
+			p = next;
+		}
+	}
+ 
+	find_position = 0;
+ 
+	return wxFindNextFile();
+}
+
+char *wxFindNextFile(void)
+{
+	CInfoPBRec pbrec;
+	static char buf[400];
+	char file[256];
+	
+	/* No more files or not searching: */
+	if (find_position < 0)
+		return NULL;
+	
+	// Find path only so we can concatenate
+	// found file onto path
+	char *p = wxPathOnly(wxFileSpec);
+	char *n = wxFileNameFromPath(wxFileSpec);
+	
+	while (1) {
+		pbrec.hFileInfo.ioVRefNum = find_vref;
+		pbrec.hFileInfo.ioDirID = find_dir_id;
+		pbrec.hFileInfo.ioFDirIndex = find_position + 1;
+		pbrec.hFileInfo.ioNamePtr = (unsigned char *)file;
+		if (PBGetCatInfo(&pbrec, FALSE) || !*file) {
+			find_position = -1;
+			return NULL;
+		}
+		
+		find_position++;
+	
+		// Is this the right kind of thing?
+		if ((wxFindFileFlags & (wxDIR + wxFILE)) != (wxDIR + wxFILE))
+			if (!!(pbrec.hFileInfo.ioFlAttrib & 0x10) != !!(wxFindFileFlags & wxDIR))
+				continue;
+		
+		p2cstr((unsigned char *)file);
+		
+		if (wxMatchWild(n, file)) {
+			if (p)
+				strcpy(buf, p);
+			else
+		  		buf[0] = 0;
+		  
+			if (buf[0])
+				strcat(buf, ":");
+			strcat(buf, file);
+	      
+			return buf;
+	    }
+	}
+}
+
+#else
+
+char *wxFindFirstFile(const char *spec, int flags)
+{
+  if (wxDirStream)
+    closedir(wxDirStream); // edz 941103: better housekeping
+
+  wxFindFileFlags = flags;
+
+  if (wxFileSpec)
+    delete[] wxFileSpec;
+  wxFileSpec = copystring(spec);
+
+  static char buf[400];
+
+  // Find path only so we can concatenate
+  // found file onto path
+  char *p = wxPathOnly(wxFileSpec);
+  char *n = wxFileNameFromPath(wxFileSpec);
+
+  if ((wxDirStream=opendir(p))==NULL)
+    return NULL;
+
+  // Do the reading
+  struct dirent *nextDir;
+  for (nextDir = readdir(wxDirStream); nextDir != NULL; nextDir = readdir(wxDirStream))
+  {
+    if ((strcmp(nextDir->d_name, ".") == 0) ||
+        (strcmp(nextDir->d_name, "..") == 0))
+    {
+      if (flags == wxDIR)
+      {
+        buf[0] = '\0';
+        if (p && *p)
+        {
+          strcpy(buf, p);
+          if (strcmp(p, ":") != 0)
+            strcat(buf, ":");
+        }
+        strcat(buf, nextDir->d_name);
+        return buf;
+      }
+    }
+    else if (!wxIsWild(n) || wxMatchWild(n, nextDir->d_name))
+    {
+      buf[0] = 0;
+      if (p && *p)
+      {
+        strcpy(buf, p);
+        if (strcmp(p, ":") != 0)
+          strcat(buf, ":");
+      }
+      strcat(buf, nextDir->d_name);
+      // Check for directory
+      if (flags == wxDIR)
+      {
+        if (wxDirExists(buf))
+          return buf;
+      }
+      else
+        return buf;
+    }
+  }
+  closedir(wxDirStream);
+  wxDirStream = NULL;
+  return NULL;
+}
+
+char *wxFindNextFile(void)
+{
+  static char buf[400];
+
+  // Find path only so we can concatenate
+  // found file onto path
+  char *p = wxPathOnly(wxFileSpec);
+  char *n = wxFileNameFromPath(wxFileSpec);
+
+  // Do the reading
+  struct dirent *nextDir;
+  for (nextDir = readdir(wxDirStream); nextDir != NULL; nextDir = readdir(wxDirStream))
+  {
+    if ((strcmp(nextDir->d_name, ".") == 0) ||
+        (strcmp(nextDir->d_name, "..") == 0))
+    {
+      if (wxFindFileFlags == wxDIR)
+      {
+        buf[0] = '\0';
+        if (p && *p)
+        {
+          strcpy(buf, p);
+          if (strcmp(p, ":") != 0)
+            strcat(buf, ":");
+        }
+        strcat(buf, nextDir->d_name);
+        return buf;
+      }
+    }
+    else if (!wxIsWild(n) || wxMatchWild(n, nextDir->d_name))
+    {
+      buf[0] = '\0';
+      if (p && *p)
+      {
+        strcpy(buf, p);
+        if (strcmp(p, ":") != 0)
+          strcat(buf, ":");
+      }
+      strcat(buf, nextDir->d_name);
+      // Check for directory
+      if (wxFindFileFlags == wxDIR)
+      {
+        if (wxDirExists(buf))
+          return buf;
+      }
+      else
+        return buf;
+    }
+  }
+  closedir(wxDirStream);
+  wxDirStream = NULL;
+  return NULL;
+}
+#endif
+
+// Here's some Tough Ones (tm) - could always try to launch ToolServer/MacPerl/MacPython??
+// Execute another program. Returns FALSE if there was an error.
+Bool wxExecute(char **argv, Bool Async) 
+{
+	return FALSE;
+}
+Bool wxExecute(const char *command, Bool Async)
+{
+	return FALSE;
+}
+
+// Execute a command in an interactive shell window
+// If no command then just the shell
+Bool wxShell(const char *command)
+{
+	return FALSE;
+}
+
+// Get current working directory.
+// If buf is NULL, allocates space using new, else
+// copies into buf.
+char *wxGetWorkingDirectory(char *buf, int sz)
+{
+  if (!buf)
+    buf = new char[sz+1];
+  if (getcwd(buf, sz) == NULL) {
+    buf[0] = ':';
+    buf[1] = '\0';
+  }
+  return buf;
+}
+
+Bool wxSetWorkingDirectory(char *d)
+{
+  return (chdir(d) == 0);
+}
+
+// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
+long 
+wxGetFreeMemory (void)	// CJC FIXME this could be Macintized.
+{
+  return -1;
+}
+
+// Sleep for nSecs seconds.
+// XView implementation according to the Heller manual
+void 
+wxSleep (int nSecs)
+{
+  sleep (nSecs);
+}
+
+// Read $HOME for what it says is home, if not
+// read $USER or $LOGNAME for user name else determine
+// the Real User, then determine the Real home dir.
+char *wxGetUserHome (const char *user)
+{
+  char usr[256];
+  strcpy(usr, user);
+  return getcwd(usr, 1000);
+}
+
+
+
+// Old cursor
+static int wxBusyCursorCount = FALSE;
+
+// Set the cursor to the busy cursor for all windows
+void 
+wxBeginBusyCursor (wxCursor * cursor)
+{
+  for (wxChildNode *node = wxTopLevelWindows(NULL)->First(); node; node = node->Next()) {
+    wxFrame *f = (wxFrame *)node->Data();
+    f->cBusyCursor++;
+  }
+    
+  wxTheApp->AdjustCursor();
+}
+
+// Restore cursor to normal
+void 
+wxEndBusyCursor (void)
+{
+  for (wxChildNode *node = wxTopLevelWindows(NULL)->First(); node; node = node->Next()) {
+    wxFrame *f = (wxFrame *)node->Data();
+    if (f->cBusyCursor)
+      --f->cBusyCursor;
+  }
+	
+  wxTheApp->AdjustCursor();
+}
+
+// TRUE if we're between the above two calls
+Bool 
+wxIsBusy (void)
+{
+  return (wxBusyCursorCount > 0);
+}
+
+// Some additions from Louis Birk
+int AddOrReplaceEntry(const char *section, const char *entry, char *Value, const char *file);
+int GetEntry(const char *section, const char *entry, char *Value, const char *file);
+
+wxNode *EntryMember (wxList *, const char *, int );
+wxNode *EntryMember (wxList *list, const char *s, int length)
+{
+  for (wxNode * node = list->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if (s == s1 || strncmp (s, s1, length) == 0)
+	return node;
+    }
+  return 0;
+}
+
+wxNode *SectionMember (wxList *, const char *, int );
+wxNode *SectionMember (wxList *list, const char *s, int length)
+{
+  for (wxNode * node = list->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if (s == s1 || strncmp (s, s1, length) == 0)
+	return node;
+    }
+  return 0;
+}
+
+wxList *GetStringList(FILE *fd);
+int WriteStringList(FILE *fd, wxList *sList);
+
+static char *wxResourceFile;
+static wxList *rmain;
+
+void wxInitResources(char *s);
+
+void wxInitResources(char *s)
+{
+   wxResourceFile = s;
+   
+   FILE *fd;
+   
+   if ( (fd = fopen(s, "r+")) == 0 ) // file note there
+     rmain = NULL;
+   else {
+    // find the section or create it
+    rmain = GetStringList(fd);
+
+    fclose(fd);
+   }
+}
+
+int AddOrReplaceEntry(const char *section, const char *entry, char *Value, const char *file)
+{
+  FILE *fd;
+  wxList *sList;
+  wxNode *sNode;
+  wxNode *eNode;
+  char Section[256];
+
+  if (!file)
+    return FALSE;
+
+  if ( (fd = fopen(file, "r+")) == 0 ) {
+    // file not there
+    if ( (fd = fopen(file, "w")) == 0 )
+      return FALSE;
+    sList = new wxList();
+  } else {
+   // find the section or create it
+    sList = GetStringList(fd);
+  }
+  
+  // make a section
+  sprintf(Section, "[%s]", section);
+
+  if ( sNode = SectionMember(sList, Section, strlen(Section)))
+  {
+    if ( (eNode = EntryMember(sList, entry, strlen(entry))) )
+    {
+      // replace with new entry
+      sList->Insert(eNode, (new wxString(Value) ));
+
+      // delete the old entry
+      sList->DeleteNode(eNode); 
+    }
+    else // section there, entry missing, add it
+    {
+      // add the entry
+      wxNode *afterSection = sNode->Next();
+
+      // replace with new entry
+      sList->Insert(afterSection, (new wxString(Value) ));
+
+    }
+  }
+  else // section missing, add it
+  {
+    // add the section
+    sList->Append(new wxString(Section) );
+    // add the entry
+    sList->Append(new wxString(Value) );
+  }
+
+  int retval;
+
+  if (WriteStringList(fd, sList))
+    retval = TRUE;
+  else
+    retval = FALSE;
+
+  fclose(fd);
+
+  return retval;
+}
+
+int GetEntry(const char *section, const char *entry, char *Value, const char *file)
+{
+  FILE *fd;
+  wxList *sList;
+  wxNode *sNode;
+  wxNode *eNode;
+  char Section[256];
+
+  if (!file) {
+    if (!rmain)
+  	  return FALSE;
+  	sList = rmain;
+  } else {
+    if ( (fd = fopen(file, "r+")) == 0 ) // file note there
+      return FALSE;
+
+    // find the section or create it
+    sList = GetStringList(fd);
+
+    fclose(fd);
+  }
+
+  // make a section
+  sprintf(Section, "[%s]", section);
+
+  if ( sNode = SectionMember(sList, Section, strlen(Section)))
+  {
+    if ( (eNode = EntryMember(sList, entry, strlen(entry))) )
+    {
+      const char *s1 = (const char *) ((wxString *)(eNode->Data()))->GetData();
+        /* This fixes the blanks/tabs etc. in front of the Value
+       	 Thomas Fettig fettig@dfki.uni-sb.de  06-dec-95 */
+      int i = 1;
+      char *s2 = strstr(s1, "=");
+      while (isspace(s2[i]) && (s2[i] !='\0'))
+       	i++;
+      strcpy(Value,s2+i);
+      return TRUE;
+    }
+   }
+
+  return FALSE;
+
+}
+
+wxList *GetStringList(FILE *fd)
+{
+  wxList *theList = new wxList();
+  char *line;
+  char line2[256];
+
+  while ( (line = fgets(line2, sizeof(line2), fd)) != 0)
+  {
+    int len = strlen(line);
+    while (len && (line[len - 1] == '\n')) {
+      line[--len] = 0;
+    }
+    theList->Append(new wxString(line));
+  }
+  if (theList->Number() > 0)
+    return theList;
+  else
+    return 0;
+}
+
+int WriteStringList(FILE *fd, wxList *sList)
+{
+  int err;
+
+  fseek(fd, 0, SEEK_SET);
+  for (wxNode * node = sList->First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) ((wxString *)(node->Data()))->GetData();
+      if ( (err = fputs(s1, fd)) != 0)
+        return FALSE;
+      fputs("\n", fd);
+    }
+  return TRUE;
+
+}
+
+// Resource additions from Louis Birk - All entry names must be unique!
+//
+
+Bool wxWriteResource(const char *section, const char *entry, char *value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s=%s", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, float value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s=%f", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, long value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s=%d", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxWriteResource(const char *section, const char *entry, int value, const char *file)
+{
+  char Value[256];
+
+  sprintf(Value, "%s=%d", entry, value);
+
+  if ( AddOrReplaceEntry(section, entry, Value, file) )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, char **value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    char *s = copystring(Value);
+    value[0] = s;
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, float *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    sscanf(Value, "%f", value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, long *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    value[0] = atol(Value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+Bool wxGetResource(const char *section, const char *entry, int *value, const char *file)
+{
+  char Value[256];
+
+  if (GetEntry(section, entry, Value, file))
+  {
+    value[0] = atoi(Value);
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+void wxBell()
+{
+	SysBeep(0);
+}
+
+int wxGetOsVersion(int *a, int *b)
+{
+  SysEnvRec sysEnvRec;
+  ::SysEnvirons(2, &sysEnvRec);
+
+  *a = sysEnvRec.systemVersion >> 8;
+  *b = (sysEnvRec.systemVersion >> 4) & 0xF;
+
+  return wxMACINTOSH;
+}
+
+// Output a debug mess., in a system dependent fashion.
+void 
+wxDebugMsg (const char *fmt...)
+{
+  va_list ap;
+  char buffer[BUFSIZ];
+
+  if (!wxTheApp->wantDebugOutput)
+    return ;
+
+  va_start (ap, fmt);
+
+  vsprintf (buffer, fmt, ap);
+  cerr << buffer;
+
+  va_end (ap);
+}
+
+
+//------ the following should be in wx_utils.cc ----------------
+
+// Get hostname.
+Bool wxGetHostName(char *buf, int maxSize)
+{	Bool good = FALSE;
+
+	if (maxSize>9)
+	{	strcpy(buf,"Macintosh");
+		good = TRUE;
+	}
+	return good;
+}
+
+// Get user ID e.g. jacs
+Bool wxGetUserId(char *buf, int maxSize)
+{	return wxGetUserName(buf,maxSize); }
+
+// Get user name e.g. Julian Smart
+Bool wxGetUserName(char *buf, int maxSize)
+{	Bool good = FALSE;
+	unsigned long userRef;
+	Str32 name;
+	
+	if (maxSize>32)
+	{	good = GetDefaultUser( &userRef, name) == noErr;
+	  /* MATTHEW: [5] */
+	  if (good) {
+#if defined(PPCC) || defined(MrCpp) || defined(GUSI) || defined(PYLIB)
+		p2cstr(name);
+#else
+		PtoCstr(name);
+#endif
+		strcpy(buf,(char *)name);
+	  }
+	}
+	return good;
+}
diff --git a/src/wxmac/src/mac/wx_win.cc b/src/wxmac/src/mac/wx_win.cc
new file mode 100644
index 0000000..8838078
--- /dev/null
+++ b/src/wxmac/src/mac/wx_win.cc
@@ -0,0 +1,1578 @@
+///////////////////////////////////////////////////////////////////////////////
+// File:	wx_win.cc
+// Purpose:	wxWindow class implementation (Macintosh version)
+// Author:	Bill Hale
+// Created:	1994
+// Updated:	
+// Copyright:  (c) 1993-94, AIAI, University of Edinburgh. All Rights Reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+static const char sccsid[] = "%W% %G%";
+
+#include "wx_win.h"
+#include "wxMacDC.h"
+#include "wx_utils.h"
+#include "wx_frame.h"
+#include "wx_mac_utils.h"
+#include "wx_gdi.h"
+#include "wx_area.h"
+#include "wx_stdev.h"
+#include "wx_screen.h"
+#include "wxScroll.h"
+#include "wx_panel.h"
+#include "wx_dialg.h"
+#include "wx_main.h"
+#include "wx_menu.h"
+#include <QuickDraw.h>
+
+wxWindow* wxWindow::gMouseWindow = NULL; 
+
+extern wxScreen* theScreen;
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Geometry methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+wxWindow::wxWindow(void)
+{
+	cWindowX = 0;
+	cWindowY = 0;
+	cWindowWidth = 0;
+	cWindowHeight = 0;
+	cStyle = 0;
+	cScroll = NULL;
+	cAreas = wxList(wxList::kDestroyData);
+	children = new wxChildList();
+	cActive = FALSE;
+	cEnable = TRUE;
+
+	InitDefaults();
+
+	cParentArea = NULL;
+
+	window_parent = NULL;
+
+	cMacDC = NULL;
+
+	cClientArea = new wxArea(this);
+}
+
+
+//-----------------------------------------------------------------------------
+wxWindow::wxWindow // Constructor (for screen window)
+	(
+		char*		windowName,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxbWindow (windowName),
+		cWindowX (x != -1 ? x : 0),
+		cWindowY (y != -1 ? y : 0),
+		cWindowWidth (width >= 0 ? width : 0),
+		cWindowHeight (height >= 0 ? height : 0),
+		cStyle (style),
+		cScroll (NULL),
+		cAreas (wxList(wxList::kDestroyData)),
+		children (new wxChildList()),
+		cActive (TRUE), // WCH: I forgot if this is necessary
+		cEnable (TRUE)
+{
+	InitDefaults();
+
+	cParentArea = NULL;
+
+	window_parent = NULL;
+
+	cMacDC = NULL; // WCH: should set to screen grafPort ??
+
+	cClientArea = new wxArea(this);
+}
+
+//-----------------------------------------------------------------------------
+wxWindow::wxWindow // Constructor (given parentScreen; i.e., this is frame)
+	(
+		char*		windowName,
+		wxScreen*	parentScreen,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxbWindow (windowName),
+		cWindowX (x != -1 ? x : 0),
+		cWindowY (y != -1 ? y : 0),
+		cWindowWidth (width >= 0 ? width : 0),
+		cWindowHeight (height >= 0 ? height : 0),
+		cStyle (style),
+		cScroll (NULL),
+		cAreas (wxList(wxList::kDestroyData)),
+		children (new wxChildList()),
+		cActive (TRUE), // this must be TRUE to handle wx_menu_bar correctly
+		cEnable (TRUE)
+{
+	if (!parentScreen) wxFatalError("No parent screen for constructing frame.");
+
+	InitDefaults();
+
+	cParentArea = parentScreen->ClientArea();
+	cParentArea->Windows()->Append(this);
+
+	window_parent = parentScreen;
+	window_parent->AddChild(this);
+
+	// Frames are initially hidden!
+	window_parent->GetChildren()->Show(this, FALSE);
+	cParentArea->Windows()->Show(this, FALSE);
+
+	cMacDC = NULL; // will set cMacDC later
+
+	cClientArea = new wxArea(this);
+}
+
+//-----------------------------------------------------------------------------
+wxWindow::wxWindow // Constructor (given parentArea)
+	(
+		char*		windowName,
+		wxArea*		parentArea,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxbWindow (windowName),
+		cWindowWidth (width >= 0 ? width : 0),
+		cWindowHeight (height >= 0 ? height : 0),
+		cStyle (style),
+		cScroll (NULL),
+		cAreas (wxList(wxList::kDestroyData)),
+		children (new wxChildList()),
+		cActive (FALSE),
+		cEnable (TRUE)
+{
+	if (!parentArea) wxFatalError("No parent area for constructing window.");
+
+	InitDefaults();
+
+	cParentArea = parentArea;
+	cParentArea->Windows()->Append(this);
+
+	window_parent = cParentArea->ParentWindow();
+
+	cMacDC = window_parent->MacDC();
+
+	InitWindowPostion(x, y);
+	window_parent->AddChild(this);
+
+	cClientArea = new wxArea(this);
+}
+
+//-----------------------------------------------------------------------------
+wxWindow::wxWindow // Constructor (given parentWindow)
+	(
+		char*		windowName,
+		wxWindow*	parentWindow,
+		int 		x,
+		int			y,
+		int			width,
+		int			height,
+		long		style
+	) :
+		wxbWindow (windowName),
+		cWindowWidth (width >= 0 ? width : 0),
+		cWindowHeight (height >= 0 ? height : 0),
+		cStyle (style),
+		cScroll (NULL),
+		cAreas (wxList(wxList::kDestroyData)),
+		children (new wxChildList()),
+		cActive (FALSE),
+		cEnable (TRUE)
+{
+	if (!parentWindow) wxFatalError("No parent window for constructing window.");
+
+	InitDefaults();
+
+	cParentArea = parentWindow->ClientArea();
+	cParentArea->Windows()->Append(this);
+
+	window_parent = parentWindow;
+
+	cMacDC = window_parent->MacDC();
+
+	InitWindowPostion(x, y);
+	window_parent->AddChild(this);
+
+	cClientArea = new wxArea(this);
+}
+
+//-----------------------------------------------------------------------------
+wxWindow::wxWindow // Constructor (given objectType; i.e., menu or menuBar)
+	(
+		char*		windowName
+	) :
+		wxbWindow (windowName),
+		cWindowX (0),
+		cWindowY (0),
+		cWindowWidth (0),
+		cWindowHeight (0),
+		cStyle (0),
+		cScroll (NULL),
+		cAreas (wxList(wxList::kDestroyData)),
+		children (new wxChildList()),
+		cActive (FALSE),
+		cEnable (TRUE)
+{
+	InitDefaults();
+
+	cParentArea = NULL;
+
+	window_parent = NULL;
+
+	cMacDC = NULL;
+
+	cClientArea = new wxArea(this);
+}
+
+//=============================================================================
+// Public destructor
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+wxWindow::~wxWindow(void) // Destructor
+{
+
+	wxPanel *panel = (wxPanel *) GetParent ();
+	if (panel)
+	{
+		// parent is not always a wxPanel: can be a wxMenu...
+		if (panel->__type == wxTYPE_PANEL)
+		{
+		  //if (this == parent->last_created)
+		  //	parent->last_created = NULL; cjc
+		  // tom fettig suggests:
+ 		  panel->new_line = FALSE;
+ 	  	  panel->label_position = wxHORIZONTAL;
+	      panel->hSpacing = PANEL_HSPACING;
+ 	      panel->vSpacing = PANEL_VSPACING;
+ 	      panel->initial_hspacing = panel->hSpacing;
+          panel->initial_vspacing = panel->vSpacing;
+          panel->current_hspacing = panel->hSpacing;
+          panel->current_vspacing = panel->vSpacing;
+          panel->OnDeleteChild(this);
+		}
+	}
+
+	if (cParentArea) 
+		cParentArea->OnDeleteChildWindow(this);
+
+	if (window_parent) window_parent->OnDeleteChildWindow(this);
+
+	DestroyChildren();
+
+	delete children;
+    if (cScroll)
+	  delete cScroll;
+#if 1 
+	//CJC: Manually delete cAreas. I don't know why the automatic deletion of the member
+	// doesn't work. This also cleans up cClientArea;
+	if (cAreas.n > 0) {
+		wxNode *w = cAreas.First();
+		while (w) {
+			wxNode *n = w;
+			w = n->Next();
+			delete n;
+		}
+		cAreas.first_node = NULL;
+		cAreas.n = 0;
+	}
+#else
+	delete cClientArea;
+#endif 
+}
+
+//=============================================================================
+// Private methods
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+void wxWindow::InitDefaults(void)
+{
+	cGravitate = 0;
+	cJustify = 0;
+	cBrush = NULL;
+	cEraser = NULL;
+
+	cColour = TRUE; // WCH: must redo this
+
+	cHidden = cUserHidden = FALSE;
+
+	WXGC_IGNORE(window_parent);
+	WXGC_IGNORE(cParentArea);
+	WXGC_IGNORE(cMacDC);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::InitWindowPostion(int x, int y)
+{
+    if (wxSubType(window_parent->__type, wxTYPE_PANEL) &&
+    	cParentArea == window_parent->ClientArea())
+	{
+    	wxPanel* parentPanel = (wxPanel*) window_parent;
+		int cursorX, cursorY;
+		parentPanel->GetCursor(&cursorX, &cursorY);
+		cWindowX = (x != -1 ? x : cursorX);
+		cWindowY = (y != -1 ? y : cursorY);
+	}
+	else
+	{
+		cWindowX = (x != -1 ? x : 0);
+		cWindowY = (y != -1 ? y : 0);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+int wxWindow::Width(void) { return cWindowWidth; } // mac platform only
+
+//-----------------------------------------------------------------------------
+int wxWindow::Height(void) { return cWindowHeight; } // mac platform only
+
+//-----------------------------------------------------------------------------
+wxMargin wxWindow::Margin(wxArea* outerArea) // mac platform only
+{
+	wxMargin result;
+	wxArea* parentArea = ParentArea();
+	if (parentArea)
+	{
+		result.SetMargin(cWindowX, Direction::wxLeft);
+		result.SetMargin(cWindowY, Direction::wxTop);
+		result.SetMargin(parentArea->Width() - cWindowX - cWindowWidth,
+							Direction::wxRight);
+		result.SetMargin(parentArea->Height() - cWindowY - cWindowHeight,
+							Direction::wxBottom);
+
+		if (parentArea != outerArea)
+		{
+			result += parentArea->Margin(outerArea);
+		}
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+wxMargin wxWindow::Margin(wxWindow* outerWindow) // mac platform only
+{
+	wxMargin result;
+
+	if (outerWindow != this)
+	{
+		wxArea* parentArea = ParentArea();
+		if (parentArea)
+		{
+			result =  Margin(parentArea);
+			result += parentArea->Margin(outerWindow);
+		}
+	}
+
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::GetPosition(int* windowX, int* windowY)
+{ // Get window position w.r.t. parent area origin
+	*windowX = cWindowX;
+	*windowY = cWindowY;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::GetSize(int* width, int* height)
+{ // Get window size
+	*width = cWindowWidth;
+	*height = cWindowHeight;
+}
+
+//-----------------------------------------------------------------------------
+// Get size *available for subwindows* i.e. excluding menu bar etc.
+//-----------------------------------------------------------------------------
+void wxWindow::GetClientSize(int* width, int* height)
+{
+	*width = cClientArea->Width();
+	*height = cClientArea->Height();
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::ClientToScreen(int* x, int* y)
+{
+	cClientArea->AreaToScreen(x, y);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::ScreenToClient(int* x, int* y)
+{
+	cClientArea->ScreenToArea(x, y);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::ClientToLogical(int* x, int* y) // mac platform only; testing
+{ // Transform point from client c.s. to logical c.s. (virtual canvas, scrolling)
+	// default action leaves *x and *y unchanged (logical c.s. same as client c.s.)
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Sizing methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetWidthHeight(int width, int height) // mac platform only
+{
+	SetSize(cWindowX, cWindowY, width, height);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetSize(int x, int y, int width, int height, int flags) // mac platform only
+{
+	int oldWindowX = cWindowX;
+	int oldWindowY = cWindowY;
+	int oldWindowWidth = cWindowWidth;
+	int oldWindowHeight = cWindowHeight;
+
+	if (width == -1)
+		width = oldWindowWidth;
+	if (height == -1)
+		height = oldWindowHeight;
+	
+	if (!(flags & wxPOS_USE_MINUS_ONE)) {
+		if (x == -1)
+			x = oldWindowX;
+		if (y == -1)
+			y = oldWindowY;
+	}
+
+	DoSetSize(x, y, width, height);
+
+	int dW = cWindowWidth - oldWindowWidth;
+	int dH = cWindowHeight - oldWindowHeight;
+	int dX = cWindowX - oldWindowX;
+	int dY = cWindowY - oldWindowY;
+	OnWindowDSize(dW, dH, dX, dY);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::DoSetSize(int x, int y, int width, int height) // mac platform only
+{
+ 	if (x==-1) 
+ 		x= cWindowX;
+ 	if (y==-1) 
+ 		y = cWindowY;
+ 	if (width==-1) 
+ 		width = cWindowWidth;
+ 	if (height==-1) 
+ 		height = cWindowHeight;
+ 		
+	Bool xIsChanged = (x != cWindowX);
+	Bool yIsChanged = (y != cWindowY);
+	Bool widthIsChanged = (width != cWindowWidth);
+	Bool heightIsChanged = (height != cWindowHeight);
+
+	if (!cHidden && (xIsChanged || yIsChanged || widthIsChanged || heightIsChanged))
+	{
+		Rect oldWindowRect = { -1, -1, cWindowHeight, cWindowWidth };
+		SetCurrentMacDCNoMargin();
+		MacSetBackground();
+		::InvalRect(&oldWindowRect);
+		::ClipRect(&oldWindowRect);
+		::EraseRect(&oldWindowRect);
+	}
+
+    if (xIsChanged) cWindowX = x;
+    if (yIsChanged) cWindowY = y;
+    if (widthIsChanged) cWindowWidth = width;
+    if (heightIsChanged) cWindowHeight = height;
+
+	if (!cHidden && (xIsChanged || yIsChanged || widthIsChanged || heightIsChanged))
+	{
+		Rect newWindowRect = { -1, -1, cWindowHeight, cWindowWidth };
+		cMacDC->setCurrentUser(NULL); // macDC no longer valid
+		SetCurrentMacDCNoMargin(); // put newClientRect at (0, 0)
+		MacSetBackground();
+		::InvalRect(&newWindowRect); // force redraw of window
+		::ClipRect(&newWindowRect);
+		::EraseRect(&newWindowRect); /* MATTHEW: [5] */
+	}
+}
+
+void wxWindow::Refresh(void)
+{
+	Rect theClipRect;
+	
+	if (cHidden) return;
+
+	GetClipRect(cClientArea, &theClipRect);
+	SetCurrentMacDC(); // put newClientRect at (0, 0)
+	::InvalRect(&theClipRect); // force redraw of window
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetClientSize(int newClientWidth, int newClientHeight)
+{
+	cClientArea->SetSize(newClientWidth, newClientHeight);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::GravitateJustify(Direction gravitate, Direction justify,
+		int left, int top, int right, int bottom)
+{
+	int windowX = cWindowX;
+	int windowY = cWindowY;
+	int windowWidth = cWindowWidth;
+	int windowHeight = cWindowHeight;
+
+// do gravitate
+	if (gravitate & Direction::wxLeft && gravitate & Direction::wxRight)
+		windowX = (left + right - cWindowWidth) / 2;
+	else if (gravitate & Direction::wxLeft) windowX = left;
+	else if (gravitate & Direction::wxRight) windowX = right - cWindowWidth;
+
+	if (gravitate & Direction::wxTop && gravitate & Direction::wxBottom)
+		windowY = (top + bottom - cWindowHeight) / 2;
+	else if (gravitate & Direction:: wxTop) windowY = top;
+	else if (gravitate & Direction::wxBottom) windowY = bottom - cWindowHeight;
+
+// do justify
+	if (justify & Direction::wxLeft)
+	{
+		windowWidth += windowX - left;
+		windowX = left;
+	}
+
+	if (justify & Direction::wxTop)
+	{
+		windowHeight += windowY - top;
+		windowY = top;
+	}
+
+	if (justify & Direction::wxBottom) windowHeight = bottom - windowY;
+
+	if (justify & Direction::wxRight) windowWidth = right - windowX;
+
+// do size
+	SetSize(windowX, windowY, windowWidth, windowHeight, wxPOS_USE_MINUS_ONE);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::Fit(void)
+{ // Resize window to fit exactly around all its client children
+	int maxX = 0;
+	int maxY = 0;
+	wxChildNode* childWindowNode = ClientArea()->Windows()->First();
+	while (childWindowNode)
+	{
+		wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+		int x, y, w, h;
+		childWindow->GetPosition(&x, &y);
+		childWindow->GetSize(&w, &h);
+		if ((x + w) > maxX) maxX = x + w;
+		if ((y + h) > maxY) maxY = y + h;
+		childWindowNode = childWindowNode->Next();
+	}
+
+	SetClientSize(maxX, maxY);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnWindowDSize(int dW, int dH, int dX, int dY)
+{ // Resize child areas
+	wxNode* areaNode = cAreas.First();
+	while (areaNode)
+	{
+		wxArea* area = (wxArea*)areaNode->Data();
+		if (area == ClientArea()) { //tom
+			OnClientAreaDSize(dW, dH, dX, dY);
+		}
+		else {
+			area->OnSiblingDSize(dW, dH, dX, dY);
+		}
+		areaNode = areaNode->Next();
+	}
+
+	if (dW || dH && (__type != wxTYPE_FRAME)) //GRW // CJC - never called ?
+	 	OnSize(cWindowWidth, cWindowHeight);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnAreaDSize(int dW, int dH, int dX, int dY)
+{
+	if (cGravitate || cJustify)
+	{
+		int left = cWindowX;
+		int top = cWindowY;
+		int right = cWindowX + cWindowWidth + dW;
+		int bottom = cWindowY + cWindowHeight + dH;
+		GravitateJustify(cGravitate, cJustify, left, top, right, bottom);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnClientAreaDSize(int dW, int dH, int dX, int dY) // mac platform only
+{
+	if (ClientArea()->Windows()->Number() != 0)
+	{ // Notify child windows of area resize.
+		wxChildNode* childWindowNode = ClientArea()->Windows()->First();
+		while (childWindowNode)
+		{
+			wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+			childWindow->OnAreaDSize(dW, dH, dX, dY);
+			childWindowNode = childWindowNode->Next();
+		}
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Device context methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxMacDC* wxWindow::MacDC(void) { return cMacDC; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetCurrentMacDCNoMargin(void) // mac platform only
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	if ((GrafPtr)theMacGrafPort != qd.thePort) ::SetPort((GrafPtr)theMacGrafPort);
+
+	cMacDC->setCurrentUser(NULL); // kludge, since not doing complete setup of DC
+	if (cParentArea && !wxSubType(__type, wxTYPE_FRAME)) {
+		int theRootX, theRootY;
+		cParentArea->FrameContentAreaOffset(&theRootX, &theRootY);
+		theRootX += cWindowX;
+		theRootY += cWindowY;
+		::SetOrigin(-theRootX, -theRootY);
+	} else
+		::SetOrigin(0, 0);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetCurrentMacDC(void) // mac platform only
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	if ((GrafPtr)theMacGrafPort != qd.thePort) ::SetPort((GrafPtr)theMacGrafPort);
+
+	if (cMacDC->currentUser() != this)
+	{ // must setup platform
+		cMacDC->setCurrentUser(NULL); // kludge, since not doing complete setup of DC
+		int theRootX, theRootY;
+		cClientArea->FrameContentAreaOffset(&theRootX, &theRootY);
+		::SetOrigin(-theRootX, -theRootY);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetCurrentDC(void) // mac platform only
+{
+	CGrafPtr theMacGrafPort = cMacDC->macGrafPort();
+	if ((GrafPtr)theMacGrafPort != qd.thePort) ::SetPort((GrafPtr)theMacGrafPort);
+
+	if (cMacDC->currentUser() != this)
+	{ // must setup platform
+		cMacDC->setCurrentUser(this);
+		int theRootX, theRootY;
+		cClientArea->FrameContentAreaOffset(&theRootX, &theRootY);
+		::SetOrigin(-theRootX, -theRootY);
+		Rect theClipRect;
+		if (cHidden) {
+			theClipRect.top = theClipRect.bottom = 0;
+			theClipRect.left = theClipRect.right = 0;
+		} else {
+			GetClipRect(cClientArea, &theClipRect);
+			MacSetBackground();
+			SetForeground();
+		}
+		::ClipRect(&theClipRect);
+		SetTextInfo();
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::MacSetBackground(void) // mac platform only
+{
+	if (!cEraser)
+	{
+		BackColor(whiteColor);
+		BackPat(&qd.white);
+		return;
+	}
+
+	RGBColor pixel = cEraser->GetColour().pixel;
+	if (cColour)
+		RGBBackColor(&pixel);
+	else
+	{
+		unsigned char red = cEraser->GetColour().Red();
+		unsigned char blue = cEraser->GetColour().Blue();
+		unsigned char green = cEraser->GetColour().Green();
+		Bool isBlackColour =
+			(red == (unsigned char )0 &&
+			 blue == (unsigned char)0 &&
+			 green == (unsigned char)0);
+		BackColor(isBlackColour ? blackColor : whiteColor);
+	}
+
+	int theBrushStyle = cEraser->GetStyle();
+	if (theBrushStyle == wxSOLID)
+		BackPat(&qd.white);
+	else if (theBrushStyle == wxTRANSPARENT)
+		BackPat(&qd.white); // WCH: does this work??
+	else if (IS_HATCH(theBrushStyle))
+	{
+		macGetHatchPattern(theBrushStyle, cMacPattern);
+		BackPat(&cMacPattern);
+	}
+	else
+	{
+		BackPat(&qd.white); // WCH: must use BackPixPat for stipple
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetForeground(void) // mac platform only
+{
+	if (IsGray()) {
+	  RGBColor c;
+	  c.red = c.green = c.blue = 0x7FFF;
+	  RGBForeColor(&c);
+	  return;
+	}
+
+	if (!cBrush)
+	{
+		PenPat(&qd.black);
+		ForeColor(blackColor);
+		return;
+	}
+
+	int theBrushStyle = cBrush->GetStyle();
+	if (theBrushStyle == wxSOLID)
+		PenPat(&qd.black);
+	else if (theBrushStyle == wxTRANSPARENT)
+		PenPat(&qd.white); // WCH: does this work??
+	else if (IS_HATCH(theBrushStyle))
+	{
+		macGetHatchPattern(theBrushStyle, cMacPattern);
+		PenPat(&cMacPattern);
+	}
+	else
+	{
+		PenPat(&qd.black); // WCH: must use PenPixPat for stipple
+	}
+
+	RGBColor pixel = cBrush->GetColour().pixel;
+	if (cColour)
+		RGBForeColor(&pixel);
+	else
+	{
+		unsigned char red = cBrush->GetColour().Red();
+		unsigned char blue = cBrush->GetColour().Blue();
+		unsigned char green = cBrush->GetColour().Green();
+		Bool isWhiteColour =
+			(red == (unsigned char )255 &&
+			 blue == (unsigned char)255 &&
+			 green == (unsigned char)255);
+		ForeColor(isWhiteColour ? whiteColor : blackColor);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetTextInfo(void) // mac platform only
+{
+	if (!font)
+	{
+		font = wxNORMAL_FONT;
+		if (!font)
+		{
+			::TextFont(1);
+			::TextSize(12);
+			::TextFace(0);
+			return;
+		}
+	}
+
+	::TextFont(font->GetMacFontNum());
+	::TextSize(font->GetPointSize());
+	::TextFace(font->GetMacFontStyle());
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::GetClipRect(wxArea* area, Rect* clipRect) // mac platform only
+{ // get clipRect in area c.s.
+	::SetRect(clipRect, 0, 0, area->Width(), area->Height()); // area c.s.
+
+	if (ParentArea()) // WCH: must redo this
+	{
+		wxWindow* windowParent = ParentArea()->ParentWindow();
+		Rect parentClipRect;
+		windowParent->GetClipRect(cParentArea, &parentClipRect); // parent area c.s.
+		wxMargin parentAreaMargin = area->Margin(cParentArea);
+		int parentAreaX = parentAreaMargin.Offset(Direction::wxLeft);
+		int parentAreaY = parentAreaMargin.Offset(Direction::wxTop);
+		::OffsetRect(&parentClipRect, -parentAreaX, -parentAreaY); // area c.s.
+		::SectRect(&parentClipRect, clipRect, clipRect);
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Tree methods (for windows and areas)
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+wxArea* wxWindow::ParentArea(void) { return cParentArea; } // mac platform only
+
+//-----------------------------------------------------------------------------
+wxList* wxWindow::Areas(void) { return &cAreas; } // mac platform only (kludge)
+
+//-----------------------------------------------------------------------------
+wxArea* wxWindow::ClientArea(void) { return cClientArea; } // mac platform only
+
+//-----------------------------------------------------------------------------
+wxWindow* wxWindow::GetParent(void) { return window_parent; }
+
+//-----------------------------------------------------------------------------
+wxChildList* wxWindow::GetChildren(void) { return children; }
+
+//-----------------------------------------------------------------------------
+wxWindow* wxWindow::GetGrandParent(void)
+{
+	if (window_parent)
+		return window_parent->window_parent;
+	else return NULL;
+}
+
+//-----------------------------------------------------------------------------
+/* There are two kinds of root Frames - real root Frames and DialogBox's
+   which are 
+*/
+wxFrame* wxWindow::GetRootFrame(void) // mac platform only
+{
+	
+#if 0 // USE_MAC_DIALOG_PANEL
+	wxWindow* theWindow = this;
+	while (theWindow->window_parent != wxScreen::gScreenWindow &&
+			theWindow->window_parent != NULL)
+	{
+		if (theWindow->__type == wxTYPE_DIALOG_BOX) {
+			wxDialogBox *dlg = (wxDialogBox *)theWindow;
+			wxFrame *theFrame = dlg->cFrame;
+			if (theFrame->IsModal())
+				return (wxFrame*)theWindow;
+		}
+		theWindow = theWindow->window_parent;
+	}
+	if ( wxSubType(theWindow->__type, wxTYPE_FRAME))
+		return (wxFrame*)theWindow;
+	else 
+    {
+   		wxFatalError("No frame found for GetRootFrame.");
+   	}
+#else
+	wxWindow* theWindow = this;
+	while (theWindow->window_parent != wxScreen::gScreenWindow &&
+			theWindow->window_parent != NULL)
+	{
+		theWindow = theWindow->window_parent;
+	}
+	
+    if	( !( wxSubType(theWindow->__type, wxTYPE_FRAME) ||
+    		 wxSubType(theWindow->__type, wxTYPE_DIALOG_BOX) ) )
+    {
+   		wxFatalError("No frame found for GetRootFrame.");
+   	}
+#endif
+	return (wxFrame*)theWindow;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::AddChild(wxObject* child) { children->Append(child); }
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnDeleteChildWindow(wxWindow* childWindow) // mac platform only
+{
+	if (children) children->DeleteObject(childWindow);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnDeleteChildArea(wxArea* childArea) // mac platform only
+{
+	cAreas.OnDeleteObject(childArea);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::DestroyChildren(void)
+{
+	if (children)
+	{
+		wxChildNode* node = children->First();
+		while (node)
+		{
+			wxWindow* child = (wxWindow*)node->Data();
+			delete child; // this will also delete current node
+			node = children->First(); // must do since current node was deleted
+		}
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Scroll methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::AddChildScrollWindow(wxWindow* childScrollWindow) // mac platform only
+{
+	wxScroll* scroll = GetScroll();
+	if (!scroll) wxFatalError("No scroll for AddChildScrollWindow.");
+	scroll->AddChildScrollWindow(childScrollWindow);
+}
+
+//-----------------------------------------------------------------------------
+wxScroll* wxWindow::GetScroll(void) { return cScroll; }
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetScrollData // Must override if window scrolls
+(
+	wxScrollData*		scrollData,
+	wxWhatScrollData	whatScrollData,
+	wxWindow*			iniatorWindow
+)
+{
+	// Must override if window scrolls
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Mouse methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::CaptureMouse(void)
+/* Allows events only to this window and its children */
+/* I.e., like X-Windows, not like Windows */
+{
+	if (gMouseWindow != this)
+	{
+		if (gMouseWindow) gMouseWindow->ReleaseMouse();
+		gMouseWindow = this;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::ReleaseMouse(void)
+{
+	if (gMouseWindow == this) gMouseWindow = NULL;
+}
+
+//-----------------------------------------------------------------------------
+static Bool doCallPreMouseEvent(wxWindow *in_win, wxWindow *win, wxMouseEvent *evt)
+{
+	wxWindow *p = win->GetParent();
+	return ((p && doCallPreMouseEvent(in_win, p, evt)) || win->PreOnEvent(in_win, evt));
+}
+
+static Bool IsCaptureAncestorArea(wxArea *area)
+{
+    wxChildNode* childWindowNode = area->Windows()->First();
+	while (childWindowNode)
+	{
+		wxWindow* p = (wxWindow*)childWindowNode->Data(), *w;
+		for (w = wxWindow::gMouseWindow; w; w = w->GetParent()) {
+		  if (w == p)
+		    return TRUE;
+		}
+		
+		childWindowNode = childWindowNode->Next();
+	}
+	
+	return FALSE;
+}
+ 
+Bool wxWindow::SeekMouseEventArea(wxMouseEvent& mouseEvent)
+{ // For point expressed in parent area c.s., seek deepest sub-window containing it
+	Bool result = FALSE;
+
+	if (!IsEnable())
+		return FALSE;
+
+	int hitX = mouseEvent.x - cWindowX; // window c.s.
+	int hitY = mouseEvent.y - cWindowY; // window c.s.
+
+	int capThis = (wxWindow::gMouseWindow == this);
+	wxArea* hitArea = NULL;
+	wxNode* areaNode = cAreas.Last();
+	while (areaNode && !hitArea)
+	{
+		if (!capThis) {
+			wxArea* area = (wxArea*)areaNode->Data();
+			if ((!wxWindow::gMouseWindow && area->WindowPointInArea(hitX, hitY))
+			    || (wxWindow::gMouseWindow && IsCaptureAncestorArea(area)))
+				hitArea = area;
+			else 
+				areaNode = areaNode->Previous();
+		}
+		
+		if (hitArea || capThis)
+		{
+			wxMouseEvent *areaMouseEvent = new wxMouseEvent(0);
+			*areaMouseEvent = mouseEvent;
+			wxMargin hitAreaMargin = hitArea->Margin(this /* hitArea->ParentWindow() */);
+			int hitAreaX = hitAreaMargin.Offset(Direction::wxLeft);
+			int hitAreaY = hitAreaMargin.Offset(Direction::wxTop);
+			areaMouseEvent->x = hitX - hitAreaX; // hit area c.s.
+			areaMouseEvent->y = hitY - hitAreaY; // hit area c.s.
+			
+			if (!capThis) {
+				wxChildNode* childWindowNode = hitArea->Windows()->First();
+				while (childWindowNode && !result)
+				{
+					wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+					result = childWindow->SeekMouseEventArea(*areaMouseEvent);
+					if (!result) childWindowNode = childWindowNode->Next();
+				}
+			}
+			
+			if (!result)
+			{
+				if (capThis || (hitArea == ClientArea() && CanAcceptEvent()))
+				{
+					result = TRUE; // WCH: should this be before this if statement
+					int clientHitX = areaMouseEvent->x;
+					int clientHitY = areaMouseEvent->y;
+					ClientToLogical(&clientHitX, &clientHitY); // mouseWindow logical c.s.
+					areaMouseEvent->x = clientHitX; // mouseWindow logical c.s.
+					areaMouseEvent->y = clientHitY; // mouseWindow logical c.s.
+					if (!doCallPreMouseEvent(this, this, areaMouseEvent)) {
+						if (WantsFocus() && areaMouseEvent->ButtonDown()) {
+							wxFrame *fr = GetRootFrame();
+							if (fr)
+								fr->SetFocusWindow(this);
+						}
+						
+						if (areaMouseEvent->ButtonDown()
+						    && wxSubType(__type, wxTYPE_CANVAS))
+						  CaptureMouse();
+						if (areaMouseEvent->ButtonUp()
+						    && wxSubType(__type, wxTYPE_CANVAS))
+						  ReleaseMouse();
+						
+						OnEvent(*areaMouseEvent);
+					}
+				}
+			}
+		}
+		
+		if (result)
+		  break;
+	}
+
+	return result;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Keyboard methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetFocus(void)
+{
+	if (WantsFocus() && CanAcceptEvent()) {
+		wxFrame* rootFrame = GetRootFrame();
+		rootFrame->SetFocusWindow(this);
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnSetFocus(void)
+{
+	// cActive = TRUE;
+	// Activate(TRUE);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnKillFocus(void)
+{
+	// Activate(FALSE);
+	// cActive = FALSE;
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Quill methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetFont(wxFont* theFont) // mac platform only
+{
+	font = theFont;
+}
+
+//-----------------------------------------------------------------------------
+float wxWindow::GetCharHeight(void)
+{
+	float theCharHeight;
+	if (font)
+		theCharHeight = font->GetCharHeight();
+	else
+		theCharHeight =  0.0;
+	return theCharHeight;
+}
+
+//-----------------------------------------------------------------------------
+float wxWindow::GetCharWidth(void)
+{
+	float theCharWidth;
+	if (font)
+		theCharWidth = font->GetCharWidth();
+	else
+		theCharWidth =  0.0;
+	return theCharWidth;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::GetTextExtent(const char* string, float* x, float* y, float* descent,
+			float* externalLeading, wxFont* the_font, Bool use16)
+{
+	if (the_font)
+	{
+		the_font->GetTextExtent((char *)string, x, y, descent, externalLeading, use16);
+	}
+	else if (font)
+	{
+		font->GetTextExtent((char *)string, x, y, descent, externalLeading, use16);
+	}
+	else
+	{
+        *x = -1;
+        *y = -1;
+		if (descent) *descent = 0.0;
+		if (externalLeading) *externalLeading = 0.0;
+	}
+}
+ 
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Activate methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::Activate(Bool flag) // mac platform only
+{
+	ShowAsActive(flag);
+	OnActivate(flag);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::ShowAsActive(Bool flag) // mac platform only
+{
+	// default is to do nothing
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::OnActivate(Bool flag) // mac platform only
+{
+	wxNode* areaNode = cAreas.First();
+	while (areaNode)
+	{
+		wxArea* area = (wxArea*)areaNode->Data();
+		wxChildNode* childWindowNode = area->Windows()->First();
+		while (childWindowNode)
+		{
+			wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+			childWindow->Activate(flag);
+			childWindowNode = childWindowNode->Next();
+		}
+		areaNode = areaNode->Next();
+	}
+}
+
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	// Other methods
+	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//-----------------------------------------------------------------------------
+void wxWindow::Paint(void)
+{ // Called when needs painting
+	if (cHidden) return;
+
+	wxNode* areaNode = cAreas.Last();
+	while (areaNode)
+	{
+		wxArea* area = (wxArea*)areaNode->Data();
+		wxChildNode* childWindowNode = area->Windows()->First();
+		while (childWindowNode)
+		{
+			wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+			if (!childWindow->cHidden)
+				childWindow->Paint();
+			childWindowNode = childWindowNode->Next();
+		}
+		areaNode = areaNode->Previous();
+	}
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::Enable(Bool Flag) 
+/* Disabling blocks mouse and keyboard events, not update events. */
+/* I.e., like Windows, not like X-Windows */
+{ 
+	if (!!cEnable == !!Flag)
+		return;
+		
+	cEnable = Flag;
+	if (!internal_gray)
+	  ChangeToGray(!Flag);
+}
+
+void wxWindow::InternalGray(Bool gray)
+{
+	Bool change = 0;
+
+	if (gray) {
+	  change = !internal_gray;
+	  internal_gray++;
+	} else {
+	  --internal_gray;
+	  change = !internal_gray;
+	}
+
+	if (change && cEnable)
+		ChangeToGray(!!internal_gray);
+}
+
+void wxWindow::ChangeToGray(Bool gray)
+{
+ 	Refresh();
+	
+	if (cMacDC->currentUser() == this)
+		/* fg pen needs reset: */
+		cMacDC->setCurrentUser(NULL);
+
+    if (gray) {
+		wxFrame* frame = GetRootFrame();
+		if (this == frame->GetFocusWindow())
+		{
+			frame->SetFocusWindow(NULL);
+		}
+	}
+}
+
+Bool wxWindow::IsGray(void)
+{
+	return !cEnable || internal_gray;
+}
+
+void wxWindow::ChildrenInternalGray(Bool gray)
+{
+	wxChildNode *node;
+	
+	for (node = GetChildren()->First(); node; node = node->Next()) {
+		wxWindow *w = (wxWindow *)node->Data();
+		w->InternalGray(gray);
+	}
+}
+
+void wxWindow::Highlight(Bool on)
+{
+}
+
+int wxWindow::Track(Point p)
+{
+	int on = FALSE;
+	Rect r = {0, 0, cWindowHeight, cWindowWidth};
+	
+	while (::StillDown()) {
+		GetMouse(&p);
+		if (!!PtInRect(p, &r) != on) {
+			on = !on;
+			Highlight(on);
+		}
+	}
+	
+	if (on)
+		Highlight(FALSE);
+		
+	return PtInRect(p, &r);
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::AddWhiteRgn(RgnHandle r)
+{
+	wxChildNode *node;
+	for (node = GetChildren()->First(); node; node = node->Next()) {
+		wxWindow *c = (wxWindow *)node->Data();
+		if (!c->cHidden)
+		  c->AddWhiteRgn(r);
+	}
+}
+
+//-----------------------------------------------------------------------------
+Bool wxWindow::IsEnable(void) { return cEnable; }
+
+Bool wxWindow::CanAcceptEvent(void)
+{
+	if (!IsEnable())
+		return FALSE;
+	if (cHidden)
+		return FALSE;
+
+	if (!wxWindow::gMouseWindow)
+		return TRUE;
+
+	wxWindow *w = this;
+	while (w) {
+		if (w == wxWindow::gMouseWindow)
+			return TRUE;
+		w = w->window_parent;
+	}
+
+	return FALSE;
+}
+
+void wxWindow::Show(Bool v)
+{
+	v = !v;
+	
+	if (v == cUserHidden)
+		return;
+		
+	if (window_parent)
+	  window_parent->GetChildren()->Show(this, !v);
+	if (cParentArea)
+	  cParentArea->Windows()->Show(this, !v);
+
+	cUserHidden = v;
+	DoShow(!v);
+}
+
+Bool wxWindow::CanShow(Bool v)
+{
+	if (v && cUserHidden)
+	  return FALSE;
+
+	v = !v;
+
+	if (v == cHidden)
+		return FALSE;
+		
+	return TRUE;
+}
+
+void wxWindow::DoShow(Bool v)
+{
+	if (!CanShow(v))
+		return;
+
+	v = !v;
+
+	cHidden = FALSE;
+	
+	SetCurrentMacDCNoMargin(); // put newClientRect at (0, 0)
+
+	Rect r = { -1, -1, cWindowHeight, cWindowWidth };
+	
+	if (v) {
+		MacSetBackground();
+		::ClipRect(&r);
+		::EraseRect(&r);
+	}
+	
+	::InvalRect(&r);
+
+	cHidden = v;
+
+	if (cHidden) {
+		/* Check for focus */
+		wxWindow *p;
+		p = window_parent;
+		while (p && !wxSubType(p->__type, wxTYPE_FRAME))
+			p = p->window_parent;
+		if (p) {
+			wxWindow *f = ((wxFrame *)p)->GetFocusWindow();
+			if (f && (f == this))
+				((wxFrame *)p)->SetFocusWindow(NULL);
+		}
+	}
+	
+}
+
+//-----------------------------------------------------------------------------
+Direction wxWindow::GetGravitate(void) { return cGravitate; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetGravitate(Direction direction) { cGravitate = direction; } // mac platform only
+
+//-----------------------------------------------------------------------------
+Direction wxWindow::GetJustify(void) { return cJustify; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetJustify(Direction direction) { cJustify = direction; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxWindow::DoPeriodicAction(void) // mac platform only
+{
+	// default is to do nothing
+}
+
+//-----------------------------------------------------------------------------
+wxCursor* wxWindow::SetCursor(wxCursor* cursor)
+{
+	wxCursor* old_cursor = wx_cursor;
+	wx_cursor = cursor;
+	wxTheApp->AdjustCursor();
+	return old_cursor;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::DragAcceptFiles(Bool accept) { } // Not implemented
+
+//-----------------------------------------------------------------------------
+Bool wxWindow::IsMacWindow(void) { return FALSE; } // mac platform only
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetColourMap(wxColourMap* cmap) { }
+
+//-----------------------------------------------------------------------------
+Bool wxWindow::PopupMenu(wxMenu *menu, float x, float y)
+{
+  MenuHandle m = menu->CreateCopy("popup", FALSE);
+
+  SetCurrentDC();
+
+  ::InsertMenu(m, -1);
+  ::CalcMenuSize(m);
+  Point pos = {y, x};
+  LocalToGlobal(&pos);
+  long sel = ::PopUpMenuSelect(m, pos.v, pos.h, 0);
+
+  if (!sel)
+    return TRUE;
+
+  int macMenuId = HiWord(sel);
+  int macMenuItemNum = LoWord(sel);
+
+  wxMenu *theWxMenu;
+
+  if (macMenuId == menu->GetMacMenuId())
+    theWxMenu = menu;
+  else 
+    theWxMenu = menu->wxMacFindSubmenu(macMenuId);
+  if (!theWxMenu) wxFatalError("No submenu for menu id.");
+
+  wxNode* node = theWxMenu->menuItems.Nth(macMenuItemNum - 1); // counting from 0
+  if (!node) wxFatalError("No wxNode for Nth menuItem.");
+
+  wxMenuItem* theWxMenuItem = (wxMenuItem*) node->Data();
+  if (!theWxMenuItem) wxFatalError("No wxMenuItem for wxNode.");
+
+  wxCommandEvent *event = new wxCommandEvent(wxEVENT_TYPE_MENU_COMMAND);
+  event->eventObject = theWxMenu;
+  event->commandInt = theWxMenuItem->itemId;
+
+  menu->ProcessCommand(*event);
+
+  return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+void wxWindow::SetEraser(wxBrush* eraser) { cEraser = eraser; }
+
+ //-----------------------------------------------------------------------------
+ 
+Bool wxWindow::AdjustCursor(int mouseX, int mouseY)
+ {
+ 	Bool result = FALSE;
+
+ 	// For point expressed in parent area c.s., seek deepest sub-window containing it
+ 	int hitX = mouseX - cWindowX; // window c.s.
+ 	int hitY = mouseY - cWindowY; // window c.s.
+
+    if (wxWindow::gMouseWindow == this) {
+       wxSetCursor(wx_cursor);
+       return TRUE;
+    }
+
+ 	wxArea* hitArea = NULL;
+ 	wxNode* areaNode = cAreas.Last();
+ 	while (areaNode && !hitArea)
+ 	{
+ 		wxArea* area = (wxArea*)areaNode->Data();
+ 		if ((!wxWindow::gMouseWindow && area->WindowPointInArea(hitX, hitY))
+ 			|| (wxWindow::gMouseWindow && IsCaptureAncestorArea(area)))
+ 			hitArea = area;
+ 		else areaNode = areaNode->Previous();
+ 	}
+
+ 	if (hitArea)
+ 	{
+ 		wxMargin hitAreaMargin = hitArea->Margin(hitArea->ParentWindow());
+ 		int hitAreaX = hitAreaMargin.Offset(Direction::wxLeft);
+ 		int hitAreaY = hitAreaMargin.Offset(Direction::wxTop);
+ 		int areaX = hitX - hitAreaX; // hit area c.s.
+ 		int areaY = hitY - hitAreaY; // hit area c.s.
+ 		wxChildNode* childWindowNode = hitArea->Windows()->First();
+ 		while (childWindowNode && !result)
+ 		{
+ 			wxWindow* childWindow = (wxWindow*)childWindowNode->Data();
+ 			result = childWindow->AdjustCursor(areaX, areaY);
+ 			if (!result) childWindowNode = childWindowNode->Next();
+ 		}
+
+ 		if (!result)
+ 		{
+ 			if (hitArea == ClientArea())
+ 			{
+ 				result = TRUE;
+ 				wxSetCursor(wx_cursor);
+ 			}
+ 		}
+ 	}
+
+ 	return result;
+ }
+
+Bool wxWindow::WantsFocus(void)
+{
+	return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// tom: fettig@dfki.uni-sb.de
+// to be called by any window, which could have the focus!!
+void wxWindow::DestroyFocus() 
+{
+	wxFrame* root = GetRootFrame();
+	if (root->GetFocusWindow()==this)
+		root->SetFocusWindow(NULL);	
+}
+
+
+Bool wxWindow::PreOnEvent(wxWindow *, wxMouseEvent *)
+{
+	return FALSE;
+}
+
+Bool wxWindow::PreOnChar(wxWindow *, wxKeyEvent *)
+{
+	return FALSE;
+}
+
+void wxWindow::ForEach(void (*foreach)(wxWindow *w, void *data), void *data)
+{
+	wxChildNode *node, *next;
+	for (node = GetChildren()->First(); node; node = next) {
+		wxWindow *c = (wxWindow *)node->Data();
+		next = node->Next();
+		if (c) {
+		  c->ForEach(foreach, data);
+		}
+	}
+	
+	foreach(this, data);
+}
diff --git a/src/wxmac/src/mac/wximgfil.cc b/src/wxmac/src/mac/wximgfil.cc
new file mode 100644
index 0000000..cdfbf76
--- /dev/null
+++ b/src/wxmac/src/mac/wximgfil.cc
@@ -0,0 +1,837 @@
+// mostly from imagetest at skye.aiai with some (power) macintrash additions
+// platform/compiler changes and other dress up (mistakes) by me
+// LjB birk@moonface.com for macintosh version of Majestic, (another HTML viewer
+// with a built in search engine capability)
+// this stuff is meant to make it a little easier to use graphic files
+// along with resources and needs to be used with the modified _gdi, and _dccanx
+// files for macs at aiai
+// also may require GUSI
+// also only works with color and only slightly tested on powermacs
+// not responsible for what this might do to your macintosh, use at your own risk
+// sorry I do not have time to add more comments, but hope this is of some use
+
+#include "wx_gdi.h"
+#include "wx_canvs.h"
+#include "wx_dc.h"
+#include "wx_mtxt.h"
+#include "wx_utils.h"
+#include "wx_mac_utils.h"
+#ifndef GUSI
+#include <unix.h>
+#endif
+#include <string.h>
+//#include <sys/types.h>
+
+#include "wximgfil.h"
+
+#define INTERLACEMASK 0x40
+
+#include <palettes.h>
+
+//void MacFixupPixelData(unsigned char *, int );
+void CreateOffScreenPixMap (CGrafPtr *,wxGIF *gif);
+CTabHandle XlateColorMap(wxGIF *);
+
+#pragma pack(1) Yes
+static struct {           
+  char header[6];       
+  ushort scrwidth;
+  ushort scrheight;
+  char pflds;
+  char bcindx;
+  char pxasrat;
+} dscgif;
+
+static struct {
+  byte sep;
+  ushort l;
+  ushort t;
+  ushort w;
+  ushort h;
+  byte  pf;
+} image;
+
+static struct { 
+  ushort colres;
+  ushort sogct;
+  rgb paleta[256];
+} TabCol;
+
+#pragma pack No
+
+
+static long Code_Mask[] = {
+	  0,
+	  0x0001, 0x0003,
+	  0x0007, 0x000F,
+	  0x001F, 0x003F,
+	  0x007F, 0x00FF,
+	  0x01FF, 0x03FF,
+	  0x07FF, 0x0FFF
+	  };
+
+Ptr wxGIF::GetRawImage()
+{
+  return (Ptr) lpbi;
+}
+
+wxGIF::~wxGIF()
+{
+  delete ColourMap;
+}
+
+wxGIF::wxGIF( char * path)
+{
+  navail_bytes = nbits_left = 0;
+  lpbi = NULL;
+  for (ushort i=0; i<13; i++) code_mask[i] = Code_Mask[i];
+  if (path) {
+    fp = fopen(path,"rb");
+    if (!fp)
+    	return;
+    ReadHeader(fp);
+    Create(image.w, image.h, 8);
+    if (GetRawImage() != 0)
+      Extrae_imagen();
+  }
+  fclose(fp);
+}
+
+void wxGIF::Create(ushort width, ushort height, ushort deep)
+{
+  Width = width; Height = height; Deep = deep;
+  lpbi = 0;
+  RawImage = 0;
+  ColourMap = 0;
+
+  lpbi = NewPtr(width*height); CheckMemOK(lpbi);
+  if (lpbi == 0)
+    {
+      lpbi = 0; // for debug purposes
+    }
+  RawImage = (char HUGE *) (lpbi);
+  EfeWidth = (long)(((long)Width*Deep + 31) / 32) * 4;
+}
+
+ushort wxGIF::out_line(uchar *pixels, ushort linelen)
+{
+  if (ItOK()) {
+
+	 SetRow(linelen, pixels);
+	 (void)ItPrev();
+	 return 0;
+  }
+  else return -1;
+}
+
+
+wxColourMap *wxGIF::getColorMap()
+{
+	byte r[256], g[256], b[256];
+
+	for (ushort i=0; i<TabCol.sogct ; i++) {
+	  r[i] =  TabCol.paleta[i].r;
+	  g[i] =  TabCol.paleta[i].g;
+	  b[i] =  TabCol.paleta[i].b;
+	}
+	SetColourMap(TabCol.sogct,r,g,b);
+	return GetColourMap();
+}
+
+BOOL wxGIF::ReadHeader( FILE *fp)
+{
+	unsigned char tstA[256];
+	unsigned char *rgbTable, single;
+	ushort widlow, widhigh, hgtlow, hgthi, i;
+
+  fread((char*)&tstA[0],13,1,fp);
+
+// what a standard, numbers need to be read in backwards ????
+//  fread((char*)&dscgif,sizeof(dscgif),1,f); // not portable
+  ushort index = 0;
+  for ( i=0; i<6;i++)
+    dscgif.header[i] = tstA[index++];
+  widlow = (ushort) tstA[index++];
+  widhigh = ((ushort) tstA[index++]) * 256;
+  hgtlow = (ushort)  tstA[index++];
+  hgthi = ((ushort) tstA[index++]) * 256;
+  dscgif.scrwidth = widlow + widhigh;
+  dscgif.scrheight = hgtlow + hgthi;
+  dscgif.pflds = tstA[index++];
+  dscgif.bcindx = tstA[index++];
+  dscgif.pxasrat = tstA[index++];
+
+  if (strncmp(dscgif.header,"GIF8",3)!=0)
+    return FALSE;
+
+  TabCol.sogct = 1<<((dscgif.pflds & 0x0007) + 0x0001);
+  TabCol.colres = (dscgif.pflds>>6) & 7 + 1;
+  rgbTable = new unsigned char[3*TabCol.sogct];
+  int errcnt = fread((char *)rgbTable,1, 3*TabCol.sogct,fp);
+  unsigned char *tp = rgbTable;
+  for ( i=0 ; i<TabCol.sogct; i++) {
+    TabCol.paleta[i].r = *tp++;
+    TabCol.paleta[i].g = *tp++;
+    TabCol.paleta[i].b = *tp++;
+  }
+  delete [] rgbTable;
+
+ single = 0;
+  while (1) {
+    fread((char *)&single, 1, 1, fp);
+	if (single == 0x21) { /* extension */
+	  fread(&single,1,1,fp); /* function */
+	  while (1) {
+        fread(&single,1,1,fp); /* block size */
+		if (single)
+          fread((char*)&tstA[0],single,1,fp);
+		else
+		  break;
+	  }
+	} else
+	  break;
+  }
+ 
+
+//	 fread((char*)&image,sizeof(image),1,f); // not portable to other compilers
+  fread((char*)&tstA[0],9,1,fp);
+  index = 0;
+  image.sep = single;
+  /* CJC MW7 68K fails
+  image.l = tstA[index++] + (256 * tstA[index++]);
+  image.t = tstA[index++] + (256 * tstA[index++]);
+  image.w = tstA[index++] + (256 * tstA[index++]);
+  image.h = tstA[index++] + (256 * tstA[index++]);
+  image.pf = tstA[index++];
+  */
+  image.l = tstA[index++];
+  image.l += (256 * tstA[index++]);
+  image.t = tstA[index++];
+  image.t += (256 * tstA[index++]);
+  image.w = tstA[index++];
+  image.w += (256 * tstA[index++]);
+  image.h = tstA[index++];
+  image.h += (256 * tstA[index++]);
+  image.pf = tstA[index++];
+  return TRUE;
+}
+
+BOOL wxGIF::Extrae_imagen()
+{
+  (void)getColorMap();
+  ibf=GIFBUFTAM+1;
+  IterImage = RawImage; 
+  ItCount = 0; 
+  decoder(GetWidth());
+//  MacFixupPixelData( (unsigned char *) IterImage, Width*Height);
+  return TRUE;
+}
+
+wxGIF::wxGIF()
+{
+}
+/* This function initializes the decoder for reading a new image.
+ */
+ushort wxGIF::init_exp(ushort size)
+	{
+	curr_size = size + 1;
+	top_slot = 1 << curr_size;
+	clear = 1 << size;
+	ending = clear + 1;
+	slot = newcodes = ending + 1;
+	navail_bytes = nbits_left = 0;
+	return(0);
+	}
+
+ushort wxGIF::get_byte() {
+
+	 if (ibf>=GIFBUFTAM) {
+		fread(buf,GIFBUFTAM,1,fp);
+		ibf = 0;
+	 }
+
+	 return buf[ibf++];
+  }
+
+/* get_next_code()
+ * - gets the next code from the GIF file.  Returns the code, or else
+ * a negative number in case of file errors...
+ */
+ushort wxGIF::get_next_code()
+	{
+	ushort i, x;
+	ulong ret;
+
+	if (nbits_left == 0)
+      {
+		if (navail_bytes <= 0)
+			{
+
+         /* Out of bytes in current block, so read next block
+          */
+         pbytes = byte_buff;
+         if ((navail_bytes = get_byte()) < 0)
+            return(navail_bytes);
+         else if (navail_bytes)
+	    {
+				for (i = 0; i < navail_bytes; ++i)
+               {
+               if ((x = get_byte()) < 0)
+						return(x);
+					byte_buff[i] = x;
+					}
+            }
+			}
+      b1 = *pbytes++;
+		nbits_left = 8;
+		--navail_bytes;
+      }
+
+   ret = b1 >> (8 - nbits_left);
+   while (curr_size > nbits_left)
+      {
+      if (navail_bytes <= 0)
+         {
+
+         /* Out of bytes in current block, so read next block
+			 */
+         pbytes = byte_buff;
+			if ((navail_bytes = get_byte()) < 0)
+            return(navail_bytes);
+			else if (navail_bytes)
+            {
+            for (i = 0; i < navail_bytes; ++i)
+					{
+					if ((x = get_byte()) < 0)
+                  return(x);
+               byte_buff[i] = x;
+               }
+            }
+         }
+      b1 = *pbytes++;
+      ret |= b1 << nbits_left;
+		nbits_left += 8;
+		--navail_bytes;
+      }
+	nbits_left -= curr_size;
+	ret &= code_mask[curr_size];
+	return((ushort)(ret));
+   }
+
+void wxGIF::InitInterlaceRow(int linewidth)
+{
+  int linepos;
+  int count, lpos;
+  
+  lpos = ItCount;
+  
+  count = ((Height - 1) / 8);
+  if (lpos <= count) {
+    IterImage = RawImage + (linewidth * (lpos * 8));
+  } else {
+    lpos -= (count + 1);
+    count = ((Height - 5) / 8);
+    if (lpos <= count) {
+      IterImage = RawImage + (linewidth * (lpos * 8 + 4));
+    } else {
+      lpos -= (count + 1);
+      count = ((Height - 1) / 4);
+      if (lpos <= count) {
+        IterImage = RawImage + (linewidth * (lpos * 4 + 2));
+      } else {
+	lpos -= (count + 1);
+        IterImage = RawImage + (linewidth * (lpos * 2 + 1));
+      }
+    }
+  }
+}
+
+
+/* short decoder(linewidth)
+ *    short linewidth;               * Pixels per line of image *
+ */
+
+ushort  wxGIF::decoder(ushort linewidth)
+{
+  register uchar *sp, *bufptr;
+  uchar *buf;
+  register ushort code, fc, oc, bufcnt;
+  ushort c, size, ret;
+
+	/* Initialize for decoding a new image...
+    */
+  if ((size = get_byte()) < 0)
+    return(size);
+  if (size < 2 || 9 < size)
+    return(BAD_CODE_SIZE);
+  init_exp(size);
+  oc = fc = 0;
+  ret = 0;
+
+  if ((buf = new uchar[linewidth + 1]/*(uchar *)malloc(linewidth + 1)*/) == NULL)
+    return(OUT_OF_MEMORY);
+
+  sp = stack;
+  bufptr = buf;
+  bufcnt = linewidth;
+
+  int interlace = image.pf & INTERLACEMASK;
+
+   /* This is the main loop.  For each code we get we pass through the
+    * linked list of prefix codes, pushing the corresponding "character" for
+    * each code onto the stack.  When the list reaches a single "character"
+    * we push that on the stack too, and then start unstacking each
+    * character for output in the correct order.  Special handling is
+    * included for the clear code, and the whole thing ends when we get
+    * an ending code.
+    */
+  while ((c = get_next_code()) != ending)
+  {
+
+      /* If we had a file error, return without completing the decode
+		 */
+    if (c < 0)
+    {
+      delete buf;
+      return(0);
+     }
+
+		/* If the code is a clear code, reinitialize all necessary items.
+		 */
+    if (c == clear)
+    {
+       curr_size = size + 1;
+       slot = newcodes;
+       top_slot = 1 << curr_size;
+
+			/* Continue reading codes until we get a non-clear code
+			 * (Another unlikely, but possible case...)
+			 */
+      while ((c = get_next_code()) == clear) ;
+
+         /* If we get an ending code immediately after a clear code
+          * (Yet another unlikely case), then break out of the loop.
+          */
+      if (c == ending)
+        break;
+
+         /* Finally, if the code is beyond the range of already set codes,
+          * (This one had better NOT happen...  I have no idea what will
+          * result from this, but I doubt it will look good...) then set it
+          * to color zero.
+          */
+      if (c >= slot)
+        c = 0;
+
+      oc = fc = c;
+
+         /* And let us not forget to put the char into the buffer... And
+			 * if, on the off chance, we were exactly one pixel from the end
+          * of the line, we have to send the buffer to the out_line()
+          * routine...
+          */
+      *bufptr++ = c;
+      if (--bufcnt == 0)
+      {
+        if (ItCount < Height)
+        {
+          if (interlace) InitInterlaceRow(linewidth);
+          for (ushort i=0; i<linewidth; i++) *IterImage++ = buf[i];
+          ItCount++;
+        }
+        else
+        {
+          delete buf;
+          return(ret);
+        }
+        bufptr = buf;
+        bufcnt = linewidth;
+      }
+    }
+    else
+    {
+
+         /* In this case, it's not a clear code or an ending code, so
+          * it must be a code code...  So we can now decode the code into
+          * a stack of character codes. (Clear as mud, right?)
+          */
+      code = c;
+
+         /* Here we go again with one of those off chances...  If, on the
+          * off chance, the code we got is beyond the range of those already
+          * set up (Another thing which had better NOT happen...) we trick
+			 * the decoder into thinking it actually got the last code read.
+          * (Hmmn... I'm not sure why this works...  But it does...)
+			 */
+      if (code >= slot)
+      {
+        if (code > slot)
+          ++bad_code_count;
+        code = oc;
+        *sp++ = fc;
+       }
+
+         /* Here we scan back along the linked list of prefixes, pushing
+          * helpless characters (ie. suffixes) onto the stack as we do so.
+			 */
+        while (code >= newcodes)
+        {
+          *sp++ = suffix[code];
+          code = prefix[code];
+        }
+
+         /* Push the last character on the stack, and set up the new
+          * prefix and suffix, and if the required slot number is greater
+			 * than that allowed by the current bit size, increase the bit
+          * size.  (NOTE - If we are all full, we *don't* save the new
+          * suffix and prefix...  I'm not certain if this is correct...
+          * it might be more proper to overwrite the last code...
+			 */
+         *sp++ = code;
+         if (slot < top_slot)
+         {
+           suffix[slot] = fc = code;
+           prefix[slot++] = oc;
+           oc = c;
+         }
+        if (slot >= top_slot)
+          if (curr_size < 12)
+          {
+            top_slot <<= 1;
+            ++curr_size;
+          } 
+
+         /* Now that we've pushed the decoded string (in reverse order)
+          * onto the stack, lets pop it off and put it into our decode
+          * buffer...  And when the decode buffer is full, write another
+			 * line...
+          */
+         while (sp > stack)
+         {
+            *bufptr++ = *(--sp);
+            if (--bufcnt == 0)
+            {
+              if (ItCount < Height)
+              {
+                if (interlace) InitInterlaceRow(linewidth);
+                for (ushort i=0; i<linewidth; i++) *IterImage++ = buf[i];
+                ItCount++;
+              }
+              else
+              {
+                delete buf;
+                return(ret);
+              }
+              bufptr = buf;
+              bufcnt = linewidth;
+            }
+          }
+        }
+      }
+  ret = 0;
+  if (bufcnt != linewidth)
+      if (ItCount < Height)
+      {
+        if (interlace) InitInterlaceRow(linewidth);
+        for (ushort i=0; i<(linewidth - bufcnt); i++) *IterImage++ = buf[i];
+        ItCount++;
+       }
+       else
+      {
+        delete buf;
+        return(ret);
+      }
+  bufptr = buf;
+  bufcnt = linewidth;
+  delete buf;
+  return(ret);
+}
+
+//// these were all inline 
+
+//inline 
+void wxGIF::reset() 
+{
+ IterImage = RawImage; 
+ ItCount = 0; 
+}
+
+//inline 
+void wxGIF::upset()
+{
+  ItCount = Height-1;
+  IterImage = RawImage + EfeWidth*(Height-1);
+}
+
+//inline 
+Bool wxGIF::ItNext()
+{
+  if (ItCount++ >= Height) return 0;
+  IterImage += EfeWidth;
+  return 1;
+}
+
+//inline 
+Bool wxGIF::ItPrev()
+{
+  if (ItCount-- < 0) return 0;
+  IterImage -= EfeWidth;
+  return 1;
+}
+
+//inline 
+void wxGIF::SetRow(ushort n, byte *buf)
+{
+  for (ushort i=0; i<n; i++) IterImage[i] = buf[i];
+}
+
+//inline 
+void wxGIF::GetRow(ushort n, byte *buf)
+{
+  for (ushort i=0; i<n; i++) buf[i] = IterImage[i];
+}
+
+///// end inliners
+
+
+BOOL wxGIF::SetColourMap(ushort n, byte *r, byte *g, byte *b)
+{
+  ColourMap = new wxColourMap();
+  if (ColourMap)
+  {
+// temporary fix
+    numcmapentries = n;
+    for (int i=0; i < n; i++) {
+      red[i] = r[i];
+      green[i] = g[i];
+      blue[i] = b[i];
+    }
+    //ColourMap->Create(n, r, g, b);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+
+
+
+CTabHandle XlateColorMap(wxGIF *gif)
+{
+
+CTabHandle		gDirClut;
+int i;
+
+	gDirClut = (CTabHandle)NewHandleClear(8 + (256 * 8));
+	CheckMemOK(gDirClut);
+
+	if (gDirClut) {
+
+		i = GetCTSeed();
+		(*gDirClut)->ctSeed = i;
+       (*gDirClut)->ctFlags = (0x8000); // mac-magic
+       (*gDirClut)->ctSize = gif->numcmapentries - 1;
+
+
+		for (i = 0; i < gif->numcmapentries; ++i) {
+			(*gDirClut)->ctTable[i].value = i;
+			(*gDirClut)->ctTable[i].rgb.red = 256 *gif->red[i];
+			(*gDirClut)->ctTable[i].rgb.green = 256 *gif->green[i];
+			(*gDirClut)->ctTable[i].rgb.blue = 256 *gif->blue[i];
+        }
+			
+  }
+  else
+    return 0;
+    
+  return gDirClut;
+// caller must
+//	DisposeCTable(gDirClut);
+//	gDirClut = 0;
+
+}
+
+
+//void MacFixupPixelData(unsigned char *buf, int nBytes)
+//{
+//	while (nBytes--) {
+//		*buf += 0;
+//		++buf;
+//	}
+//}
+
+// Load device independent bitmap into device dependent bitmap
+//wxBitmap *wxLoadBitmap(char *filename, wxColourMap **colourmap);
+
+
+Bool wxLoadGifIntoBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+ 
+  CGrafPtr  colorPort;
+
+  wxGIF *gifImage  = new wxGIF(fileName);
+  if (gifImage && gifImage->GetRawImage() != 0) {
+	CreateOffScreenPixMap(&colorPort, gifImage);
+	bm->x_pixmap = colorPort;
+	//  bm->pixmap = colorPort->portPixMap;
+	bm->SetWidth(gifImage->GetWidth());
+	bm->SetHeight(gifImage->GetHeight());
+	bm->SetDepth(gifImage->GetDeep());
+	bm->SetOk(TRUE);
+	delete gifImage;
+	return TRUE;
+  }
+  else {
+	bm->SetOk(FALSE);
+  	return FALSE;
+  }
+}
+
+
+void CreateOffScreenPixMap (CGrafPtr *cport, wxGIF *gif)
+{
+	CTabHandle	thisColorTable;
+  GDHandle	gThisGDevice;
+  GDHandle	oldDevice;
+	CGrafPtr	newCGrafPtr;
+	Ptr			theseBits;
+	long		sizeOfOff, offRowBytes;
+	OSErr		theErr;
+	ushort		thisDepth;
+    Rect        theRect;
+CTabHandle		gDirClut;
+PaletteHandle dstPalette;
+ 	
+	gThisGDevice = GetMainDevice();
+	oldDevice = GetGDevice();
+	SetGDevice(gThisGDevice);
+	newCGrafPtr = (CGrafPtr)NewPtrClear(sizeof(CGrafPort));
+	if (newCGrafPtr != 0L)
+	{
+		SetRect(&theRect, 0, 0,gif->GetWidth(), gif->GetHeight());
+		OpenCPort(newCGrafPtr);
+		thisDepth = (**(*newCGrafPtr).portPixMap).pixelSize;
+		//offRowBytes = ((((long)thisDepth * 
+				//(long)(theRect.right - theRect.left)) + 15L) >> 4L) << 1L;
+	    offRowBytes = gif->GetWidth();
+		sizeOfOff = (long)(theRect.bottom - theRect.top) * offRowBytes;
+		OffsetRect(&theRect, -theRect.left, -theRect.top);
+		if (gif->GetRawImage() != 0L)
+		{
+			(**(*newCGrafPtr).portPixMap).baseAddr = gif->GetRawImage();
+			(**(*newCGrafPtr).portPixMap).rowBytes = (short)offRowBytes | 0x8000; // ****0x8000 | gif->GetWidth();
+			(**(*newCGrafPtr).portPixMap).pixelSize = 8;
+			(**(*newCGrafPtr).portPixMap).cmpSize = 8;
+			(**(*newCGrafPtr).portPixMap).cmpCount = 1;
+			(**(*newCGrafPtr).portPixMap).bounds = theRect;
+			//SetRect(&(**(*newCGrafPtr).portPixMap).bounds, 0, 0,
+			//            gif->GetWidth(), gif->GetHeight()); // *theRect
+			
+			//thisColorTable = (**(**gThisGDevice).gdPMap).pmTable;
+			//theErr = HandToHand((Handle *)&thisColorTable);
+			gDirClut = XlateColorMap(gif);
+			(**(*newCGrafPtr).portPixMap).pmTable = gDirClut; 
+			//dstPalette = NewPalette(256, gDirClut, pmTolerant + pmExplicit, 0);
+			//NSetPalette((GrafPort *)newCGrafPtr, dstPalette, pmAllUpdates);
+			//ActivatePalette((GrafPort *)newCGrafPtr);
+			ClipRect(&theRect);
+			RectRgn(newCGrafPtr->visRgn, &theRect);
+			ForeColor(blackColor);
+			BackColor(whiteColor);
+			//EraseRect(&theRect);
+		}
+		else
+		{
+			CloseCPort(newCGrafPtr);		
+			DisposePtr((Ptr)newCGrafPtr);
+			newCGrafPtr = 0L;
+		}
+	}
+
+  SetGDevice(oldDevice);
+  *cport = newCGrafPtr;
+}
+#ifdef CJC
+#include <PictUtils.h>
+#include <Strings.h>
+#include <Resources.h>
+
+PixMapHandle CreatePixMapFromPict(char *, CGrafPtr *, int *, int *);
+PixMapHandle CreatePixMapFromPict(char * kPictID, CGrafPtr *cport, int *w, int *h)
+{
+  CGrafPtr	myCGrafPtr;
+  GrafPtr		myGrafPtr;
+  int theDepth;
+  long  offRowBytes,sizeOfOff;
+  PicHandle	aPict;
+  PictInfo	pictInfo;
+  OSErr		myErr;
+  Rect		bounds;
+  PicHandle	drawPict;
+  GDHandle	gThisGDevice;
+  GDHandle	oldDevice;
+  CTabHandle	thisColorTable;
+  Ptr  mypiximage0;
+  PixMapHandle  pixm;
+  StringPtr pstr;
+  
+  gThisGDevice = GetMainDevice();
+  oldDevice = GetGDevice();
+  SetGDevice(gThisGDevice);
+  pstr = c2pstr(kPictID);
+  aPict = (PicHandle) GetNamedResource('PICT', pstr);
+
+  HLock((Handle)aPict);
+  bounds = (*aPict)->picFrame;
+  HUnlock((Handle)aPict);
+  OffsetRect(&bounds, -bounds.left, -bounds.top);
+  *w = bounds.right - bounds.left;
+  *h = bounds.bottom - bounds.top;
+
+  // color graf port
+  // must draw into an offscreen, otherwise it appears on screen	
+  myCGrafPtr= (CGrafPtr)NewPtrClear(sizeof(CGrafPort));
+  CheckMemOK(myCGrafPtr);
+  OpenCPort(myCGrafPtr);
+  theDepth=(**(*myCGrafPtr).portPixMap).pixelSize;
+  offRowBytes=(((theDepth * (*w))+15)>>5)<<2;
+  sizeOfOff=(long)(*h) *offRowBytes;
+  mypiximage0=NewPtr(sizeOfOff); CheckMemOK(mypiximage0);
+  (**(*myCGrafPtr).portPixMap).rowBytes=offRowBytes+0x8000;
+  (**(*myCGrafPtr).portPixMap).bounds=bounds;	
+  (**(*myCGrafPtr).portPixMap).baseAddr=mypiximage0;
+  
+  // color map
+  thisColorTable = (**(**gThisGDevice).gdPMap).pmTable;
+  myErr = HandToHand((Handle *)&thisColorTable);
+  (**(*myCGrafPtr).portPixMap).pmTable = thisColorTable; 
+  ClipRect(&bounds);
+  RectRgn(myCGrafPtr->visRgn, &bounds);
+  ForeColor(blackColor);
+  BackColor(whiteColor);
+  HLock((Handle)aPict);
+  DrawPicture(aPict, &bounds);
+  HUnlock((Handle)aPict);
+  SetGDevice(oldDevice);
+  ReleaseResource((Handle)aPict);
+
+  *cport = myCGrafPtr;
+  return myCGrafPtr->portPixMap; // pixm;
+  
+}
+
+// not used for now
+void LoadGraphic (ushort );
+void LoadGraphic (ushort thePictID)
+{
+	Rect		bounds;
+	PicHandle	thePicture;
+	
+	thePicture = GetPicture(thePictID);			// Load graphic from resource fork.
+	HLock((Handle)thePicture);					// If we made it this far, lock handle.
+	bounds = (*thePicture)->picFrame;			// Get a copy of the picture's bounds.
+	HUnlock((Handle)thePicture);				// We can unlock the picture now.
+	OffsetRect(&bounds, -bounds.left, -bounds.top);	// Offset bounds rect to (0, 0).
+	DrawPicture(thePicture, &bounds);			// Draw picture to current port.
+	ReleaseResource((Handle)thePicture);		// Dispose of picture from heap.
+}
+#endif
diff --git a/src/wxmac/src/wxPWin.pch b/src/wxmac/src/wxPWin.pch
new file mode 100644
index 0000000..b28be5d
--- /dev/null
+++ b/src/wxmac/src/wxPWin.pch
@@ -0,0 +1,19 @@
+#ifdef powerc
+  #pragma precompile_target "wxPHeadersPPC"
+#else
+  #pragma precompile_target "wxPHeaders68K"
+#endif
+#define HAVE_CONFIG_H
+#ifdef USE_STDWIN
+#undef USE_STDWIN
+#endif
+#define macintosh
+#define PYLIB
+#define FOR_MAC	// needed for wxxpm
+#include <MacHeaders.c>
+
+#define DEBUG_NEW 2
+#include <DebugNew.h>
+
+#include "wx_setup.h"           // Which features to include - user editable
+#include "common.h"
diff --git a/src/wxmac/utils/image/src/wx_24to8.cc b/src/wxmac/utils/image/src/wx_24to8.cc
new file mode 100644
index 0000000..f66f415
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_24to8.cc
@@ -0,0 +1,944 @@
+/*
+ * xv24to8.c  -  contains the 24-to-8-bit Conv24to8 procedure
+ *
+ * The Conv24to8 procedure takes a pointer to a 24-bit image (loaded
+ * previously).  The image will be a w * h * 3 byte array of
+ * bytes.  The image will be arranged with 3 bytes per pixel (in order
+ * R, G, and B), pixel 0 at the top left corner.  (As normal.)
+ * The procedure also takes a maximum number of colors to use (numcols)
+ *
+ * The Conv24to8 procedure will set up the following:  it will allocate and
+ * create 'pic', a pWIDE*pHIGH 8-bit picture.  it will set up pWIDE and pHIGH.
+ * it will load up the r[], g[], and b[] colormap arrays.  it will NOT 
+ * calculate numcols, since the cmap sort procedure has to be called anyway
+ *
+ * Conv24to8 returns '0' if successful, '1' if it failed (presumably on a 
+ * malloc())
+ *
+ * contains:
+ *   Cont24to8()
+ *   InitFSDTables()
+ */
+
+/*
+ * Copyright 1989, 1990 by the University of Pennsylvania
+ *
+ * Permission to use, copy, and distribute for non-commercial purposes,
+ * is hereby granted without fee, providing that the above copyright
+ * notice appear in all copies and that both the copyright notice and this
+ * permission notice appear in supporting documentation.
+ *
+ * The software may be modified for your own purposes, but modified versions
+ * may not be distributed.
+ *
+ * This software is provided "as is" without any express or implied warranty.
+ */
+
+#include <stdlib.h>
+#include "wx_image.h"
+#ifdef wx_mac
+#include "wx_imgx.h"
+#endif
+
+#ifdef _HPUX_SOURCE_
+#ifndef sun
+#include <X11/Xfuncs.h> // bcopy
+#endif
+#endif
+
+// #ifndef sun
+#ifdef SVR4
+extern "C" {
+#include <X11/Xfuncs.h> /* bcopy */
+}
+#endif
+// #endif
+
+static int   num_colors, WIDE, HIGH;
+static int   histogram[B_LEN][B_LEN][B_LEN];
+
+CBOX   *freeboxes, *usedboxes;
+CCELL **ColorCells;
+
+static void assign_color(CBOX *ptr,byte *rp,byte *gp, byte *bp);
+static CCELL *create_colorcell(int r1, int g1, int b1);
+static void   map_colortable();
+
+static byte   tbl1[256],     /* tables used in F-S Dithering */
+              tbl3[256],     /* contain i/16, 3i/16, 5i/16, 7i/16, */
+              tbl5[256],     /* (i=0-255) respectively */
+              tbl7[256];
+
+
+/****************************/
+int wxImage::Conv24to8(byte *p, int w, int h, int nc)
+/****************************/
+{
+  int   i;
+  CBOX *box_list, *ptr;
+
+  /* copy arguments to local-global variables */
+  pic24 = p;  pWIDE = WIDE = w;  pHIGH = HIGH = h;  num_colors = nc;
+
+
+  /* allocate pic immediately, so that if we can't allocate it, we don't
+     waste time running this algorithm */
+
+  pic = (byte *) malloc(WIDE * HIGH);
+  if (pic == NULL) {
+    fprintf(stderr,"Conv24to8() - failed to allocate picture\n");
+    return(1);
+  }
+
+
+  /* quick check:  if we're going to display a greyscale or 1-bit image,
+     DON'T run this annoyingly time-consuming code.  Just convert the 24-bit
+     color image to an 8-bit greyscale.  This takes virtually no time, by
+     comparision, and it has the same effect. */
+
+  if (mono || nc==0) {
+    byte *pp, *p24;
+
+    for (i=0; i<256; i++) r[i]=g[i]=b[i]=i;   /* greyscale colormap */ // CJC 
+    pp = pic;  p24 = pic24;
+    for (i=WIDE*HIGH; i>0; i--, pp++, p24+=3) 
+      *pp = (p24[0]*11 + p24[1]*16 + p24[2]*5) >> 5;  /* pp=.33R+.5G+.17B */
+
+    return(0);
+  }
+
+  if (!noqcheck && QuickCheck(pic24,w,h,nc)) { 
+    /* see if it's a <256 color RGB pic */
+    return 0;   
+  }
+  else if (!slow24) {
+    return(Quick24to8(pic24,w,h));
+  }
+
+  /**** STEP 1:  create empty boxes ****/
+
+  usedboxes = NULL;
+  box_list = freeboxes = (CBOX *) malloc(num_colors * sizeof(CBOX));
+
+  if (box_list == NULL) {
+    return(1);
+  }
+
+  for (i=0; i<num_colors; i++) {
+    freeboxes[i].next = &freeboxes[i+1];
+    freeboxes[i].prev = &freeboxes[i-1];
+  }
+  freeboxes[0].prev = NULL;
+  freeboxes[num_colors-1].next = NULL;
+
+
+  /**** STEP 2: get histogram, initialize first box ****/
+
+  ptr = freeboxes;
+  freeboxes = ptr->next;
+  if (freeboxes) freeboxes->prev = NULL;
+
+  ptr->next = usedboxes;
+  usedboxes = ptr;
+  if (ptr->next) ptr->next->prev = ptr;
+	
+  get_histogram(ptr);
+
+
+  /**** STEP 3: continually subdivide boxes until no more free boxes remain */
+
+  while (freeboxes) {
+    ptr = largest_box();
+    if (ptr) splitbox(ptr);
+    else break;
+  }
+
+  
+  /**** STEP 4: assign colors to all boxes ****/
+
+  for (i=0, ptr=usedboxes; i<num_colors && ptr; i++, ptr=ptr->next) {
+    assign_color(ptr, &rorg[i], &g[i], &b[i]);
+  }
+
+  /* We're done with the boxes now */
+  num_colors = i;
+  free(box_list);
+  box_list = freeboxes = usedboxes = NULL;
+ 
+
+  /**** STEP 5: scan histogram and map all values to closest color */
+
+  /* 5a: create cell list as described in Heckbert[2] */
+
+  ColorCells = (CCELL **) calloc(C_LEN*C_LEN*C_LEN, sizeof(CCELL *));
+
+
+  /* 5b: create mapping from truncated pixel space to color table entries */
+
+  map_colortable();
+
+
+  /**** STEP 6: scan image, match input values to table entries */
+
+  i=quant_fsdither();
+
+  /* free everything that can be freed */
+  free(ColorCells);
+
+  return i;
+}
+
+
+/****************************/
+void wxImage::get_histogram(CBOX *box)
+/****************************/
+{
+  int   i,j,r,g,b,*ptr;
+  byte *p;
+
+  box->rmin = box->gmin = box->bmin = 999;
+  box->rmax = box->gmax = box->bmax = -1;
+  box->total = WIDE * HIGH;
+
+  /* zero out histogram */
+  ptr = &histogram[0][0][0];
+  for (i=B_LEN*B_LEN*B_LEN; i>0; i-- )  *ptr++ = 0;
+
+  /* calculate histogram */
+  p = pic24;
+  for (i=0; i<HIGH; i++)
+    for (j=0; j<WIDE; j++) {
+      r = (*p++) >> (COLOR_DEPTH-B_DEPTH);
+      g = (*p++) >> (COLOR_DEPTH-B_DEPTH);
+      b = (*p++) >> (COLOR_DEPTH-B_DEPTH);
+
+      if (r < box->rmin) box->rmin = r;
+      if (r > box->rmax) box->rmax = r;
+
+      if (g < box->gmin) box->gmin = g;
+      if (g > box->gmax) box->gmax = g;
+
+      if (b < box->bmin) box->bmin = b;
+      if (b > box->bmax) box->bmax = b;
+      histogram[r][g][b]++;
+    }
+}
+
+
+
+/******************************/
+CBOX *wxImage::largest_box()
+/******************************/
+{
+  CBOX *tmp, *ptr;
+  int   size = -1;
+
+  tmp = usedboxes;
+  ptr = NULL;
+
+  while (tmp) {
+    if ( (tmp->rmax > tmp->rmin  ||
+	  tmp->gmax > tmp->gmin  ||
+	  tmp->bmax > tmp->bmin)  &&  tmp->total > size ) {
+      ptr = tmp;
+      size = tmp->total;
+    }
+    tmp = tmp->next;
+  }
+  return(ptr);
+}
+
+
+
+/******************************/
+void wxImage::splitbox(CBOX *ptr)
+/******************************/
+{
+  int   hist2[B_LEN], first, last, i, rdel, gdel, bdel;
+  CBOX *new_cbox;
+  int  *iptr, *histp, ir, ig, ib;
+  int  rmin,rmax,gmin,gmax,bmin,bmax;
+  enum {RED,GREEN,BLUE} which;
+
+  /*
+   * see which axis is the largest, do a histogram along that
+   * axis.  Split at median point.  Contract both new boxes to
+   * fit points and return
+   */
+
+  first = last = 0;   /* shut RT hcc compiler up */
+
+  rmin = ptr->rmin;  rmax = ptr->rmax;
+  gmin = ptr->gmin;  gmax = ptr->gmax;
+  bmin = ptr->bmin;  bmax = ptr->bmax;
+
+  rdel = rmax - rmin;
+  gdel = gmax - gmin;
+  bdel = bmax - bmin;
+
+  if      (rdel>=gdel && rdel>=bdel) which = RED;
+  else if (gdel>=bdel)               which = GREEN;
+  else                               which = BLUE;
+
+  /* get histogram along longest axis */
+  switch (which) {
+
+  case RED:
+    histp = &hist2[rmin];
+    for (ir=rmin; ir<=rmax; ir++) {
+      *histp = 0;
+      for (ig=gmin; ig<=gmax; ig++) {
+	iptr = &histogram[ir][ig][bmin];
+	for (ib=bmin; ib<=bmax; ib++) {
+	  *histp += *iptr;
+	  ++iptr;
+	}
+      }
+      ++histp;
+    }
+    first = rmin;  last = rmax;
+    break;
+
+  case GREEN:
+    histp = &hist2[gmin];
+    for (ig=gmin; ig<=gmax; ig++) {
+      *histp = 0;
+      for (ir=rmin; ir<=rmax; ir++) {
+	iptr = &histogram[ir][ig][bmin];
+	for (ib=bmin; ib<=bmax; ib++) {
+	  *histp += *iptr;
+	  ++iptr;
+	}
+      }
+      ++histp;
+    }
+    first = gmin;  last = gmax;
+    break;
+
+  case BLUE:
+    histp = &hist2[bmin];
+    for (ib=bmin; ib<=bmax; ib++) {
+      *histp = 0;
+      for (ir=rmin; ir<=rmax; ir++) {
+	iptr = &histogram[ir][gmin][ib];
+	for (ig=gmin; ig<=gmax; ig++) {
+	  *histp += *iptr;
+	  iptr += B_LEN;
+	}
+      }
+      ++histp;
+    }
+    first = bmin;  last = bmax;
+    break;
+  }
+
+
+  /* find median point */
+  {
+    int sum, sum2;
+
+    histp = &hist2[first];
+
+    sum2 = ptr->total/2;
+    histp = &hist2[first];
+    sum = 0;
+        
+    for (i=first; i<=last && (sum += *histp++)<sum2; i++);
+    if (i==first) i++;
+  }
+
+
+  /* Create new box, re-allocate points */
+  
+  new_cbox = freeboxes;
+  freeboxes = new_cbox->next;
+  if (freeboxes) freeboxes->prev = NULL;
+
+  if (usedboxes) usedboxes->prev = new_cbox;
+  new_cbox->next = usedboxes;
+  usedboxes = new_cbox;
+
+  {
+    int sum1,sum2,j;
+    
+    histp = &hist2[first];
+    sum1 = 0;
+    for (j = first; j < i; ++j) sum1 += *histp++;
+    sum2 = 0;
+    for (j = i; j <= last; ++j) sum2 += *histp++;
+    new_cbox->total = sum1;
+    ptr->total = sum2;
+  }
+
+
+  new_cbox->rmin = rmin;  new_cbox->rmax = rmax;
+  new_cbox->gmin = gmin;  new_cbox->gmax = gmax;
+  new_cbox->bmin = bmin;  new_cbox->bmax = bmax;
+
+  switch (which) {
+  case RED:    new_cbox->rmax = i-1;  ptr->rmin = i;  break;
+  case GREEN:  new_cbox->gmax = i-1;  ptr->gmin = i;  break;
+  case BLUE:   new_cbox->bmax = i-1;  ptr->bmin = i;  break;
+  }
+
+  shrinkbox(new_cbox);
+  shrinkbox(ptr);
+}
+
+
+/****************************/
+void wxImage::shrinkbox(CBOX *box)
+/****************************/
+{
+  int *histp,ir,ig,ib;
+  int  rmin,rmax,gmin,gmax,bmin,bmax;
+
+  rmin = box->rmin;  rmax = box->rmax;
+  gmin = box->gmin;  gmax = box->gmax;
+  bmin = box->bmin;  bmax = box->bmax;
+
+  if (rmax>rmin) {
+    for (ir=rmin; ir<=rmax; ir++)
+      for (ig=gmin; ig<=gmax; ig++) {
+	histp = &histogram[ir][ig][bmin];
+	for (ib=bmin; ib<=bmax; ib++)
+	  if (*histp++ != 0) {
+	    box->rmin = rmin = ir;
+	    goto have_rmin;
+	  }
+      }
+
+  have_rmin:
+    if (rmax>rmin)
+      for (ir=rmax; ir>=rmin; --ir)
+	for (ig=gmin; ig<=gmax; ig++) {
+	  histp = &histogram[ir][ig][bmin];
+	  for (ib=bmin; ib<=bmax; ib++)
+	    if (*histp++ != 0) {
+	      box->rmax = rmax = ir;
+	      goto have_rmax;
+	    }
+	}
+  }
+
+
+ have_rmax:
+
+  if (gmax>gmin) {
+    for (ig=gmin; ig<=gmax; ig++)
+      for (ir=rmin; ir<=rmax; ir++) {
+	histp = &histogram[ir][ig][bmin];
+	for (ib=bmin; ib<=bmax; ib++)
+	  if (*histp++ != 0) {
+	    box->gmin = gmin = ig;
+	    goto have_gmin;
+	  }
+      }
+  have_gmin:
+    if (gmax>gmin)
+      for (ig=gmax; ig>=gmin; --ig)
+	for (ir=rmin; ir<=rmax; ir++) {
+	  histp = &histogram[ir][ig][bmin];
+	  for (ib=bmin; ib<=bmax; ib++)
+	    if (*histp++ != 0) {
+	      box->gmax = gmax = ig;
+	      goto have_gmax;
+	    }
+	}
+  }
+
+
+ have_gmax:
+
+  if (bmax>bmin) {
+    for (ib=bmin; ib<=bmax; ib++)
+      for (ir=rmin; ir<=rmax; ir++) {
+	histp = &histogram[ir][gmin][ib];
+	for (ig=gmin; ig<=gmax; ig++) {
+	  if (*histp != 0) {
+	    box->bmin = bmin = ib;
+	    goto have_bmin;
+	  }
+	  histp += B_LEN;
+	}
+      }
+  have_bmin:
+    if (bmax>bmin)
+      for (ib=bmax; ib>=bmin; --ib)
+	for (ir=rmin; ir<=rmax; ir++) {
+	  histp = &histogram[ir][gmin][ib];
+	  for (ig=gmin; ig<=gmax; ig++) {
+	    if (*histp != 0) {
+	      bmax = ib;
+	      goto have_bmax;
+	    }
+	    histp += B_LEN;
+	  }
+	}
+  }
+
+ have_bmax: return;
+}
+
+
+
+/*******************************/
+static void assign_color(CBOX *ptr,byte *rp,byte *gp, byte *bp)
+/*******************************/
+{
+  *rp = ((ptr->rmin + ptr->rmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
+  *gp = ((ptr->gmin + ptr->gmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
+  *bp = ((ptr->bmin + ptr->bmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
+}
+
+
+
+/*******************************/
+CCELL *create_colorcell(int r1, int g1, int b1)
+/*******************************/
+{
+  register int    i,tmp, dist;
+  register CCELL *ptr;
+  register byte  *rp,*gp,*bp;
+  int             ir,ig,ib, mindist;
+
+  ir = r1 >> (COLOR_DEPTH-C_DEPTH);
+  ig = g1 >> (COLOR_DEPTH-C_DEPTH);
+  ib = b1 >> (COLOR_DEPTH-C_DEPTH);
+
+  r1 &= ~1 << (COLOR_DEPTH-C_DEPTH);
+  g1 &= ~1 << (COLOR_DEPTH-C_DEPTH);
+  b1 &= ~1 << (COLOR_DEPTH-C_DEPTH);
+
+  ptr = (CCELL *) malloc(sizeof(CCELL));
+  *(ColorCells + ir*C_LEN*C_LEN + ig*C_LEN + ib) = ptr;
+  ptr->num_ents = 0;
+
+  /* step 1: find all colors inside this cell, while we're at
+     it, find distance of centermost point to furthest
+     corner */
+
+  mindist = 99999999;
+
+  rp=r;  gp=g;  bp=b;
+  for (i=0; i<num_colors; i++,rp++,gp++,bp++)
+    if( *rp>>(COLOR_DEPTH-C_DEPTH) == ir  &&
+        *gp>>(COLOR_DEPTH-C_DEPTH) == ig  &&
+        *bp>>(COLOR_DEPTH-C_DEPTH) == ib) {
+
+      ptr->entries[ptr->num_ents][0] = i;
+      ptr->entries[ptr->num_ents][1] = 0;
+      ++ptr->num_ents;
+
+      tmp = *rp - r1;
+      if (tmp < (MAX_COLOR/C_LEN/2)) tmp = MAX_COLOR/C_LEN-1 - tmp;
+      dist = tmp*tmp;
+
+      tmp = *gp - g1;
+      if (tmp < (MAX_COLOR/C_LEN/2)) tmp = MAX_COLOR/C_LEN-1 - tmp;
+      dist += tmp*tmp;
+
+      tmp = *bp - b1;
+      if (tmp < (MAX_COLOR/C_LEN/2)) tmp = MAX_COLOR/C_LEN-1 - tmp;
+      dist += tmp*tmp;
+
+      if (dist < mindist) mindist = dist;
+    }
+
+
+  /* step 3: find all points within that distance to box */
+
+  rp=r;  gp=g;  bp=b;
+  for (i=0; i<num_colors; i++,rp++,gp++,bp++)
+    if (*rp >> (COLOR_DEPTH-C_DEPTH) != ir  ||
+	*gp >> (COLOR_DEPTH-C_DEPTH) != ig  ||
+	*bp >> (COLOR_DEPTH-C_DEPTH) != ib) {
+
+      dist = 0;
+
+      if ((tmp = r1 - *rp)>0 || (tmp = *rp - (r1 + MAX_COLOR/C_LEN-1)) > 0 )
+	dist += tmp*tmp;
+
+      if( (tmp = g1 - *gp)>0 || (tmp = *gp - (g1 + MAX_COLOR/C_LEN-1)) > 0 )
+	dist += tmp*tmp;
+
+      if( (tmp = b1 - *bp)>0 || (tmp = *bp - (b1 + MAX_COLOR/C_LEN-1)) > 0 )
+	dist += tmp*tmp;
+
+      if( dist < mindist ) {
+	ptr->entries[ptr->num_ents][0] = i;
+	ptr->entries[ptr->num_ents][1] = dist;
+	++ptr->num_ents;
+      }
+    }
+
+
+  /* sort color cells by distance, use cheap exchange sort */
+  {
+    int n, next_n;
+
+    n = ptr->num_ents - 1;
+    while (n>0) {
+      next_n = 0;
+      for (i=0; i<n; ++i) {
+	if (ptr->entries[i][1] > ptr->entries[i+1][1]) {
+	  tmp = ptr->entries[i][0];
+	  ptr->entries[i][0] = ptr->entries[i+1][0];
+	  ptr->entries[i+1][0] = tmp;
+	  tmp = ptr->entries[i][1];
+	  ptr->entries[i][1] = ptr->entries[i+1][1];
+	  ptr->entries[i+1][1] = tmp;
+	  next_n = i;
+	}
+      }
+      n = next_n;
+    }
+  }
+  return (ptr);
+}
+
+
+
+
+/***************************/
+static void map_colortable()
+/***************************/
+{
+  int    ir,ig,ib, *histp;
+  CCELL *cell;
+
+  histp  = &histogram[0][0][0];
+  for (ir=0; ir<B_LEN; ir++)
+    for (ig=0; ig<B_LEN; ig++)
+      for (ib=0; ib<B_LEN; ib++) {
+	if (*histp==0) *histp = -1;
+	else {
+	  int	i, j, tmp, d2, dist;
+	  
+	  cell = *(ColorCells +
+		   ( ((ir>>(B_DEPTH-C_DEPTH)) << C_DEPTH*2)
+		   + ((ig>>(B_DEPTH-C_DEPTH)) << C_DEPTH)
+		   +  (ib>>(B_DEPTH-C_DEPTH)) ) );
+		
+	  if (cell==NULL)
+	    cell = create_colorcell(ir<<(COLOR_DEPTH-B_DEPTH),
+				    ig<<(COLOR_DEPTH-B_DEPTH),
+				    ib<<(COLOR_DEPTH-B_DEPTH));
+
+	  dist = 9999999;
+	  for (i=0; i<cell->num_ents && dist>cell->entries[i][1]; i++) {
+	    j = cell->entries[i][0];
+	    d2 = r[j] - (ir << (COLOR_DEPTH-B_DEPTH));
+	    d2 *= d2;
+	    tmp = g[j] - (ig << (COLOR_DEPTH-B_DEPTH));
+	    d2 += tmp*tmp;
+	    tmp = b[j] - (ib << (COLOR_DEPTH-B_DEPTH));
+	    d2 += tmp*tmp;
+	    if( d2 < dist ) { dist = d2;  *histp = j; }
+	  }
+	}
+	histp++;
+      }
+}
+
+
+
+/*****************************/
+int wxImage::quant_fsdither()
+/*****************************/
+{
+  register int  *thisptr, *nextptr;
+  int           *thisline, *nextline, *tmpptr;
+  int            r1, g1, b1, r2, g2, b2;
+  int            i, j, imax, jmax, oval;
+  byte          *inptr, *outptr, *tmpbptr;
+  int            lastline, lastpixel;
+
+  imax = HIGH - 1;
+  jmax = WIDE - 1;
+  
+  thisline = (int *) malloc(WIDE * 3 * sizeof(int));
+  nextline = (int *) malloc(WIDE * 3 * sizeof(int));
+
+  if (thisline == NULL || nextline == NULL) {
+    fprintf(stderr,"unable to allocate stuff for the 'dither' routine\n");
+    return 1;
+  }
+
+
+  inptr  = (byte *) pic24;
+  outptr = (byte *) pic;
+
+  /* get first line of picture */
+  for (j=WIDE * 3, tmpptr=nextline, tmpbptr=inptr; j; j--) 
+    *tmpptr++ = (int) *tmpbptr++;
+
+  for (i=0; i<HIGH; i++) {
+    /* swap thisline and nextline */
+    tmpptr = thisline;  thisline = nextline;  nextline = tmpptr;
+    lastline = (i==imax);
+
+    /* read in next line */
+    for (j=WIDE * 3, tmpptr=nextline; j; j--) 
+      *tmpptr++ = (int) *inptr++;
+
+    /* dither this line and put it into the output picture */
+    thisptr = thisline;  nextptr = nextline;
+
+    for (j=0; j<WIDE; j++) {
+      lastpixel = (j==jmax);
+
+      r2 = *thisptr++;  g2 = *thisptr++;  b2 = *thisptr++;
+
+      if (r2<0) r2=0;  else if (r2>=MAX_COLOR) r2=MAX_COLOR-1;
+      if (g2<0) g2=0;  else if (g2>=MAX_COLOR) g2=MAX_COLOR-1;
+      if (b2<0) b2=0;  else if (b2>=MAX_COLOR) b2=MAX_COLOR-1;
+
+      r1 = r2;  g1 = g2;  b1 = b2;
+
+      r2 >>= (COLOR_DEPTH-B_DEPTH);
+      g2 >>= (COLOR_DEPTH-B_DEPTH);
+      b2 >>= (COLOR_DEPTH-B_DEPTH);
+
+      if ( (oval=histogram[r2][g2][b2]) == -1) {
+	int ci, cj, dist, d2, tmp;
+	CCELL *cell;
+
+	cell = *( ColorCells + 
+		( ((r2>>(B_DEPTH-C_DEPTH)) << C_DEPTH*2)
+	        + ((g2>>(B_DEPTH-C_DEPTH)) << C_DEPTH )
+		+  (b2>>(B_DEPTH-C_DEPTH)) ) );
+	      
+	if (cell==NULL) cell = create_colorcell(r1,g1,b1);
+
+	dist = 9999999;
+	for (ci=0; ci<cell->num_ents && dist>cell->entries[ci][1]; ci++) {
+	  cj = cell->entries[ci][0];
+	  d2 = (r[cj] >> (COLOR_DEPTH-B_DEPTH)) - r2;
+	  d2 *= d2;
+	  tmp = (g[cj] >> (COLOR_DEPTH-B_DEPTH)) - g2;
+	  d2 += tmp*tmp;
+	  tmp = (b[cj] >> (COLOR_DEPTH-B_DEPTH)) - b2;
+	  d2 += tmp*tmp;
+	  if (d2<dist) { dist = d2;  oval = cj; }
+	}
+	histogram[r2][g2][b2] = oval;
+      }
+
+      *outptr++ = oval;
+
+      r1 -= r[oval];  g1 -= g[oval];  b1 -= b[oval];
+      /* can't use tables because r1,g1,b1 go negative */
+
+      if (!lastpixel) {
+	thisptr[0] += (r1*7)/16;
+	thisptr[1] += (g1*7)/16;
+	thisptr[2] += (b1*7)/16;
+      }
+
+      if (!lastline) {
+	if (j) {
+	  nextptr[-3] += (r1*3)/16;
+	  nextptr[-2] += (g1*3)/16;
+	  nextptr[-1] += (b1*3)/16;
+	}
+
+	nextptr[0] += (r1*5)/16;
+	nextptr[1] += (g1*5)/16;
+	nextptr[2] += (b1*5)/16;
+
+	if (!lastpixel) {
+	  nextptr[3] += r1/16;
+	  nextptr[4] += g1/16;
+	  nextptr[5] += b1/16;
+	}
+	nextptr += 3;
+      }
+    }
+  }
+  free(thisline);  free(nextline);
+  return 0;
+}
+
+
+
+
+
+/************************************/
+int wxImage::Quick24to8(byte *p24, int w, int h)
+{
+
+  /* floyd-steinberg dithering.
+   *
+   * ----   x    7/16
+   * 3/16  5/16  1/16
+   *
+   */
+
+  /* called after 'pic' has been alloced, pWIDE,pHIGH set up, mono/1-bit
+     checked already */
+
+  byte *pp;
+  int  r1, g1, b1;
+  int  *thisline, *nextline, *thisptr, *nextptr, *tmpptr;
+  int  i, j, rerr, gerr, berr, pwide3;
+  int  imax, jmax;
+
+  pp = pic;  pwide3 = w * 3;  imax = h-1;  jmax = w-1;
+
+  /* load up colormap, 3 bits R, 3 bits G, 2 bits B  (RRRGGGBB) */
+  for (i=0; i<256; i++) {
+    r[i] =  ((i&0xe0) * 255) / 0xe0;  
+    g[i] =  ((i&0x1c) * 255) / 0x1c;
+    b[i] =  ((i&0x03) * 255) / 0x03;
+  }
+
+  thisline = (int *) malloc(pwide3 * sizeof(int));
+  nextline = (int *) malloc(pwide3 * sizeof(int));
+  if (!thisline || !nextline) {
+    fprintf(stderr,"Unable to allocate memory in Quick24to8()\n");
+    return(1);
+    }
+
+  /* get first line of picture */
+  for (j=pwide3, tmpptr=nextline; j; j--) *tmpptr++ = (int) *p24++;
+
+  for (i=0; i<h; i++) {
+    tmpptr = thisline;  thisline = nextline;  nextline = tmpptr;   /* swap */
+
+    if (i!=imax)   /* get next line */
+      for (j=pwide3, tmpptr=nextline; j; j--)
+	*tmpptr++ = (int) *p24++;
+
+    for (j=0, thisptr=thisline, nextptr=nextline; j<w; j++,pp++) {
+      r1 = *thisptr++;  g1 = *thisptr++;  b1 = *thisptr++;
+      RANGE(r1,0,255);  RANGE(g1,0,255);  RANGE(b1,0,255);  
+
+      rerr = r1 & 0x1f;  gerr = g1 & 0x1f;  berr = b1 & 0x3f;
+      *pp = (r1&0xe0) | ((g1>>3)&0x1c) | (b1>>6); 
+
+      if (j!=jmax) {  /* adjust RIGHT pixel */
+	thisptr[0] += tbl7[rerr];
+	thisptr[1] += tbl7[gerr];
+	thisptr[2] += tbl7[berr];
+      }
+      
+      if (i!=imax) {	/* do BOTTOM pixel */
+	nextptr[0] += tbl5[rerr];
+	nextptr[1] += tbl5[gerr];
+	nextptr[2] += tbl5[berr];
+
+	if (j>0) {  /* do BOTTOM LEFT pixel */
+	  nextptr[-3] += tbl3[rerr];
+	  nextptr[-2] += tbl3[gerr];
+	  nextptr[-1] += tbl3[berr];
+	}
+
+	if (j!=jmax) {  /* do BOTTOM RIGHT pixel */
+	  nextptr[3] += tbl1[rerr];
+	  nextptr[4] += tbl1[gerr];
+	  nextptr[5] += tbl1[berr];
+	}
+	nextptr += 3;
+      }
+    }
+  }
+
+  return 0;
+}
+      
+
+
+/****************************/
+void InitFSDTables()
+/****************************/
+{
+  int i;
+  for (i=0; i<256; i++) {     /* initialize Floyd-Steinberg division tables */
+    tbl1[i] = i/16;
+    tbl3[i] = (3*i)/16;
+    tbl5[i] = (5*i)/16;
+    tbl7[i] = (7*i)/16;
+  }
+}
+
+/****************************/
+int wxImage::QuickCheck(byte *pic24, int w, int h, int maxcol)
+{
+  /* scans picture until it finds more than 'maxcol' different colors.  If it
+     finds more than 'maxcol' colors, it returns '0'.  If it DOESN'T, it does
+     the 24-to-8 conversion by simply sticking the colors it found into
+     a colormap, and changing instances of a color in pic24 into colormap
+     indicies (in pic) */
+
+  unsigned long colors[256],col;
+  int           i, nc, low, high, mid;
+  byte         *p, *pix;
+
+  if (maxcol>256) maxcol = 256;
+
+  /* put the first color in the table by hand */
+  nc = 0;  mid = 0;  
+
+  for (i=w*h,p=pic24; i; i--) {
+    col  = (*p++ << 16);  
+    col += (*p++ << 8);
+    col +=  *p++;
+
+    /* binary search the 'colors' array to see if it's in there */
+    low = 0;  high = nc-1;
+    while (low <= high) {
+      mid = (low+high)/2;
+      if      (col < colors[mid]) high = mid - 1;
+      else if (col > colors[mid]) low  = mid + 1;
+      else break;
+    }
+
+    if (high < low) { /* didn't find color in list, add it. */
+      /* WARNING: this is an overlapped memory copy.  memcpy doesn't do
+	 it correctly, hence 'bcopy', which claims to */
+      if (nc>=maxcol) return 0;
+#ifdef wx_mac
+      memmove(&colors[low], &colors[low+1], (nc - low) * sizeof(unsigned long));
+#else
+      bcopy(&colors[low], &colors[low+1], (nc - low) * sizeof(unsigned long));
+#endif
+      colors[low] = col;
+      nc++;
+    }
+  }
+
+
+  /* run through the data a second time, this time mapping pixel values in
+     pic24 into colormap offsets into 'colors' */
+
+  for (i=w*h,p=pic24, pix=pic; i; i--,pix++) {
+    col  = (*p++ << 16);  
+    col += (*p++ << 8);
+    col +=  *p++;
+
+    /* binary search the 'colors' array.  It *IS* in there */
+    low = 0;  high = nc-1;
+    while (low <= high) {
+      mid = (low+high)/2;
+      if      (col < colors[mid]) high = mid - 1;
+      else if (col > colors[mid]) low  = mid + 1;
+      else break;
+    }
+
+    if (high < low) {
+      fprintf(stderr,"QuickCheck:  impossible!\n");
+      exit(1);
+    }
+    *pix = mid;
+  }
+
+  /* and load up the 'desired colormap' */
+  for (i=0; i<nc; i++) {
+    r[i] =  colors[i]>>16;  
+    g[i] = (colors[i]>>8) & 0xff;
+    b[i] =  colors[i]     & 0xff;
+  }
+
+  return 1;
+}
diff --git a/src/wxmac/utils/image/src/wx_bmp.cc b/src/wxmac/utils/image/src/wx_bmp.cc
new file mode 100644
index 0000000..81c7a86
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_bmp.cc
@@ -0,0 +1,869 @@
+/*
+ * xvbmp.c - i/o routines for .BMP files (MS Windows 3.x)
+ *
+ * LoadBMP(fname, numcols)
+ * WriteBMP(fp, pic, ptype, w, h, r, g, b, numcols, style);
+ */
+
+/* Copyright Notice
+ * ================
+ * Copyright 1989, 1990, 1991, 1992, 1993 by John Bradley
+ * 
+ * Permission to use, copy, and distribute XV in its entirety, for 
+ * non-commercial purposes, is hereby granted without fee, provided that
+ * this license information and copyright notice appear in all copies.
+ * 
+ * Note that distributing XV 'bundled' in with ANY product is considered
+ * to be a 'commercial purpose'.
+ *
+ * Also note that any copies of XV that are distributed MUST be built
+ * and/or configured to be in their 'unregistered copy' mode, so that it
+ * is made obvious to the user that XV is shareware, and that they should
+ * consider donating, or at least reading this License Info.
+ * 
+ * The software may be modified for your own purposes, but modified
+ * versions may NOT be distributed without prior consent of the author.
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * If you would like to do something with XV that this copyright
+ * prohibits (such as distributing it with a commercial product, 
+ * using portions of the source in some other program, etc.), please
+ * contact the author (preferably via email).  Arrangements can
+ * probably be worked out.
+ *
+ * XV is shareware for PERSONAL USE only.  You may use XV for your own
+ * amusement, and if you find it nifty, useful, generally cool, or of
+ * some value to you, your non-deductable donation would be greatly
+ * appreciated.  $25 is the suggested donation, though, of course,
+ * larger donations are quite welcome.  Folks who donate $25 or more
+ * can receive a Real Nice bound copy of the XV manual for no extra
+ * charge.
+ * 
+ * Commercial, government, and institutional users MUST register their
+ * copies of XV, for the exceedingly REASONABLE price of just $25 per
+ * workstation/X terminal.  Site licenses are available for those who
+ * wish to run XV on a large number of machines.  Contact the author
+ * for more details.
+ *
+ * The author may be contacted via:
+ *    US Mail:  John Bradley
+ *              1053 Floyd Terrace
+ *              Bryn Mawr, PA  19010
+ *
+ *    Phone:    (215) 898-8813
+ *    EMail:    bradley@cis.upenn.edu
+ */
+
+
+#include <stdlib.h>
+#include "wx_image.h"
+#include "wx_utils.h"
+
+/* comments on error handling:
+   a truncated file is not considered a Major Error.  The file is loaded, the
+   rest of the pic is filled with 0's.
+
+   a file with garbage characters in it is an unloadable file.  All allocated
+   stuff is tossed, and LoadPBM returns non-zero
+
+   not being able to malloc is a Fatal Error.  The program is aborted. */
+
+
+#define BI_RGB  0
+#define BI_RLE8 1
+#define BI_RLE4 2
+
+
+static long filesize;
+
+  static int  loadBMP1(FILE *, byte *, int, int);
+  static int  loadBMP4(FILE *, byte *, int, int, int);
+  static int  loadBMP8(FILE *, byte *, int, int, int);
+  static int  loadBMP24(FILE *, byte *, int, int);
+  static unsigned int getshort(FILE *);
+  static unsigned int getint(FILE *);
+  static void putshort(FILE *, int);
+  static void putint(FILE *, int);
+  static void writeBMP1(FILE *, byte *, int, int);
+  static void writeBMP4(FILE *, byte *, int, int);
+  static void writeBMP8(FILE *, byte *, int, int);
+  static void writeBMP24(FILE *, byte *, int, int);
+  static int  bmpError(char *, char *);
+
+
+/*******************************************/
+int wxImage::LoadBMP(char *fname, PICINFO *pinfo)
+/*******************************************/
+{
+  FILE         *fp;
+  int          i, c, c1, rv;
+  unsigned int bfSize, bfOffBits, biSize, biWidth, biHeight, biPlanes;
+  unsigned int biBitCount, biCompression, biSizeImage, biXPelsPerMeter;
+  unsigned int biYPelsPerMeter, biClrUsed, biClrImportant;
+  char         *cmpstr;
+  byte         *pic24, *pic8;
+  char          buf[512];
+
+  /* returns '1' on success */
+
+  pic8 = pic24 = (byte *) NULL;
+
+#ifdef wx_mac
+  fp=fopen(fname,"rb");
+#else
+  fp=fopen(fname,"r");
+#endif
+  if (!fp) return (bmpError(fname, "couldn't open file"));
+  
+  fseek(fp, 0L, 2);      /* figure out the file size */
+  filesize = ftell(fp);
+  fseek(fp, 0L, 0);
+
+
+  /* read the file type (first two bytes) */
+  c = getc(fp);  c1 = getc(fp);
+  if (c!='B' || c1!='M') { bmpError(fname,"file type != 'BM'"); goto ERROR; }
+
+  bfSize = getint(fp);
+  getshort(fp);         /* reserved and ignored */
+  getshort(fp);
+  bfOffBits = getint(fp);
+
+  biSize          = getint(fp);
+  biWidth         = getint(fp);
+  biHeight        = getint(fp);
+  biPlanes        = getshort(fp);
+  biBitCount      = getshort(fp);
+  biCompression   = getint(fp);
+  biSizeImage     = getint(fp);
+  biXPelsPerMeter = getint(fp);
+  biYPelsPerMeter = getint(fp);
+  biClrUsed       = getint(fp);
+  biClrImportant  = getint(fp);
+  
+
+  if (dEBUG>1) {
+    fprintf(stderr,"\nLoadBMP:\tbfSize=%d, bfOffBits=%d\n",bfSize,bfOffBits);
+    fprintf(stderr,"\t\tbiSize=%d, biWidth=%d, biHeight=%d, biPlanes=%d\n",
+	    biSize, biWidth, biHeight, biPlanes);
+    fprintf(stderr,"\t\tbiBitCount=%d, biCompression=%d, biSizeImage=%d\n",
+	    biBitCount, biCompression, biSizeImage);
+    fprintf(stderr,"\t\tbiX,YPelsPerMeter=%d,%d  biClrUsed=%d, biClrImp=%d\n",
+	    biXPelsPerMeter, biYPelsPerMeter, biClrUsed, biClrImportant);
+  }
+
+  if (ferror(fp)) { bmpError(fname,"EOF reached in file header"); goto ERROR; }
+
+
+  /* error checking */
+  if ((biBitCount!=1 && biBitCount!=4 && biBitCount!=8 && biBitCount!=24) || 
+      biPlanes!=1 || biCompression>BI_RLE4) {
+
+    sprintf(buf,"Bogus BMP File!  (bitCount=%d, Planes=%d, Compression=%d)",
+	    biBitCount, biPlanes, biCompression);
+
+    bmpError(fname, buf);
+    goto ERROR;
+  }
+
+  if (((biBitCount==1 || biBitCount==24) && biCompression != BI_RGB) ||
+      (biBitCount==4 && biCompression==BI_RLE8) ||
+      (biBitCount==8 && biCompression==BI_RLE4)) {
+
+    sprintf(buf,"Bogus BMP File!  (bitCount=%d, Compression=%d)",
+	    biBitCount, biCompression);
+
+    bmpError(fname, buf);
+    goto ERROR;
+  }
+
+
+  
+  /* skip ahead to colormap, using biSize */
+  c = biSize - 40;    /* 40 bytes read from biSize to biClrImportant */
+  for (i=0; i<c; i++) getc(fp);
+
+
+  /* load up colormap, if any */
+  if (biBitCount!=24) {
+    int i, cmaplen;
+
+	if ((biBitCount < 16) && biClrUsed)
+	  cmaplen = biClrUsed;
+	else
+      cmaplen = 1 << biBitCount;
+    for (i=0; i<cmaplen; i++) {
+      pinfo->b[i] = getc(fp);
+      pinfo->g[i] = getc(fp);
+      pinfo->r[i] = getc(fp);
+      // JACS code to fit in with old xv
+      r[i] = rorg[i] = pinfo->r[i];
+      b[i] = borg[i] = pinfo->b[i];
+      g[i] = gorg[i] = pinfo->g[i];
+      getc(fp);         /* unused */
+    }
+
+    if (ferror(fp)) 
+      { bmpError(fname,"EOF reached in BMP colormap"); goto ERROR; }
+
+    if (dEBUG>1) {
+      fprintf(stderr,"LoadBMP:  BMP colormap:  (RGB order)\n");
+      for (i=0; i<cmaplen; i++) {
+	fprintf(stderr,"%02x%02x%02x  ", pinfo->r[i],pinfo->g[i],pinfo->b[i]);
+      }
+      fprintf(stderr,"\n\n");
+    }
+  }
+
+
+  /* create pic8 or pic24 */
+
+  if (biBitCount==24) {
+    pic24 = (byte *) calloc(biWidth * biHeight * 3, 1);
+    if (!pic24) return (bmpError(fname, "couldn't malloc 'pic24'"));
+  }
+  else {
+    pic8 = (byte *) calloc(biWidth * biHeight, 1);
+    if (!pic8) return(bmpError(fname, "couldn't malloc 'pic8'"));
+  }
+
+  /* load up the image */
+  if      (biBitCount == 1) rv = loadBMP1(fp,pic8,biWidth,biHeight);
+  else if (biBitCount == 4) rv = loadBMP4(fp,pic8,biWidth,biHeight,
+					  biCompression);
+  else if (biBitCount == 8) rv = loadBMP8(fp,pic8,biWidth,biHeight,
+					  biCompression);
+  else                      rv = loadBMP24(fp,pic24,biWidth,biHeight);
+
+  if (rv) bmpError(fname, "File appears truncated.  Winging it.\n");
+
+  fclose(fp);
+
+
+  if (biBitCount == 24) {
+    pinfo->pic  = pic24;
+    pinfo->type = PIC24;
+  }
+  else {
+    pinfo->pic  = pic8;
+    pinfo->type = PIC8;
+  }
+
+  cmpstr = "";
+  if      (biCompression == BI_RLE4) cmpstr = ", RLE4 compressed";
+  else if (biCompression == BI_RLE8) cmpstr = ", RLE8 compressed";
+
+  pinfo->w = biWidth;  pinfo->h = biHeight;
+  pinfo->frmType = F_BMP;
+  pinfo->colType = F_FULLCOLOR;
+
+  sprintf(pinfo->fullInfo, "BMP, %d bit%s per pixel%s.  (%ld bytes)",
+	  biBitCount,  (biBitCount == 1) ? "" : "s",
+	  cmpstr, filesize);
+  sprintf(pinfo->shrtInfo, "%dx%d BMP.", biWidth, biHeight);
+  pinfo->comment = (char *) NULL;
+//  cout << pinfo->fullInfo << "\n";
+
+  return 1;
+
+
+ ERROR:
+  fclose(fp);
+  return 0;
+}  
+
+
+/*******************************************/
+static int loadBMP1(FILE *fp, byte *pic8, int w, int h)
+{
+  int   i,j,c,bitnum,padw;
+  byte *pp;
+
+  c = 0;
+  padw = ((w + 31)/32) * 32;  /* 'w', padded to be a multiple of 32 */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic8 + (i * w);
+    for (j=bitnum=0; j<padw; j++,bitnum++) {
+      if ((bitnum&7) == 0) { /* read the next byte */
+	c = getc(fp);
+	bitnum = 0;
+      }
+      
+      if (j<w) {
+	*pp++ = (c & 0x80) ? 1 : 0;
+	c <<= 1;
+      }
+    }
+    if (ferror(fp)) break;
+  }
+
+  return (ferror(fp));
+}  
+
+
+
+/*******************************************/
+static int loadBMP4(FILE *fp, byte *pic8, int w, int h, int comp)
+{
+  int   i,j,c,c1,x,y,nybnum,padw,rv;
+  byte *pp;
+
+
+  rv = 0;
+  c = c1 = 0;
+
+  if (comp == BI_RGB) {   /* read uncompressed data */
+    padw = ((w + 7)/8) * 8; /* 'w' padded to a multiple of 8pix (32 bits) */
+
+    for (i=h-1; i>=0; i--) {
+      pp = pic8 + (i * w);
+      for (j=nybnum=0; j<padw; j++,nybnum++) {
+		if ((nybnum & 1) == 0) { /* read next byte */
+		  c = getc(fp);
+		  nybnum = 0;
+		}
+
+		if (j<w) {
+		  *pp++ = (c & 0xf0) >> 4;
+		  c <<= 4;
+		}
+      }
+      if (ferror(fp)) break;
+    }
+  }
+
+  else if (comp == BI_RLE4) {  /* read RLE4 compressed data */
+    x = y = 0;  
+    pp = pic8 + x + (h-y-1)*w;
+
+    while (y<h) {
+      c = getc(fp);  if (c == EOF) { rv = 1;  break; }
+
+      if (c) {                                   /* encoded mode */
+	c1 = getc(fp);
+	for (i=0; i<c; i++,x++,pp++) 
+	  *pp = (i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f);
+      }
+
+      else {    /* c==0x00  :  escape codes */
+	c = getc(fp);  if (c == EOF) { rv = 1;  break; }
+
+	if      (c == 0x00) {                    /* end of line */
+	  x=0;  y++;  pp = pic8 + x + (h-y-1)*w;
+	} 
+
+	else if (c == 0x01) break;               /* end of pic8 */
+
+	else if (c == 0x02) {                    /* delta */
+	  c = getc(fp);  x += c;
+	  c = getc(fp);  y += c;
+	  pp = pic8 + x + (h-y-1)*w;
+	}
+
+	else {                                   /* absolute mode */
+	  for (i=0; i<c; i++, x++, pp++) {
+	    if ((i&1) == 0) c1 = getc(fp);
+	    *pp = (i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f);
+	  }
+	  
+	  if (((c&3)==1) || ((c&3)==2)) getc(fp);  /* read pad byte */
+	}
+      }  /* escape processing */
+      if (ferror(fp)) break;
+    }  /* while */
+  }
+  
+  else {
+    fprintf(stderr,"unknown BMP compression type 0x%0x\n", comp);
+  }
+
+  if (ferror(fp)) rv = 1;
+  return rv;
+}  
+
+
+
+/*******************************************/
+static int loadBMP8(FILE *fp, byte *pic8, int w, int h, int comp)
+{
+  int   i,j,c,c1,padw,x,y,rv;
+  byte *pp;
+
+  rv = 0;
+
+  if (comp == BI_RGB) {   /* read uncompressed data */
+    padw = ((w + 3)/4) * 4; /* 'w' padded to a multiple of 4pix (32 bits) */
+
+    for (i=h-1; i>=0; i--) {
+      pp = pic8 + (i * w);
+
+      for (j=0; j<padw; j++) {
+		c = getc(fp);  
+		if (c==EOF) 
+			rv = 1;
+		if (j<w) 
+			*pp++ = c;
+      }
+      if (ferror(fp)) break;
+    }
+  }
+
+  else if (comp == BI_RLE8) {  /* read RLE8 compressed data */
+    x = y = 0;  
+    pp = pic8 + x + (h-y-1)*w;
+
+    while (y<h) {
+      c = getc(fp);  if (c == EOF) { rv = 1;  break; }
+
+      if (c) {                                   /* encoded mode */
+	c1 = getc(fp);
+	for (i=0; i<c; i++,x++,pp++) *pp = c1;
+      }
+
+      else {    /* c==0x00  :  escape codes */
+	c = getc(fp);  if (c == EOF) { rv = 1;  break; }
+
+	if      (c == 0x00) {                    /* end of line */
+	  x=0;  y++;  pp = pic8 + x + (h-y-1)*w;
+	} 
+
+	else if (c == 0x01) break;               /* end of pic8 */
+
+	else if (c == 0x02) {                    /* delta */
+	  c = getc(fp);  x += c;
+	  c = getc(fp);  y += c;
+	  pp = pic8 + x + (h-y-1)*w;
+	}
+
+	else {                                   /* absolute mode */
+	  for (i=0; i<c; i++, x++, pp++) {
+	    c1 = getc(fp);
+	    *pp = c1;
+	  }
+	  
+	  if (c & 1) getc(fp);  /* odd length run: read an extra pad byte */
+	}
+      }  /* escape processing */
+      if (ferror(fp)) break;
+    }  /* while */
+  }
+  
+  else {
+    fprintf(stderr,"unknown BMP compression type 0x%0x\n", comp);
+  }
+
+  if (ferror(fp)) rv = 1;
+  return rv;
+}  
+
+
+
+/*******************************************/
+static int loadBMP24(FILE *fp, byte *pic24, int w, int h)
+{
+  int   i,j,padb;
+  byte *pp;
+
+
+  padb = (4 - ((w*3) % 4)) & 0x03;  /* # of pad bytes to read at EOscanline */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic24 + (i * w * 3);
+    
+    for (j=0; j<w; j++) {
+      *pp++ = getc(fp);   /* red   */
+      *pp++ = getc(fp);   /* green */
+      *pp++ = getc(fp);   /* blue  */
+    }
+
+    for (j=0; j<padb; j++) getc(fp);
+
+    if (ferror(fp)) break;
+  }
+
+  return (ferror(fp));
+}  
+
+
+
+/*******************************************/
+static unsigned int getshort(FILE *fp)
+{
+  int c, c1;
+  c = getc(fp);  c1 = getc(fp);
+  return ((unsigned int) c) + (((unsigned int) c1) << 8);
+}
+
+
+/*******************************************/
+static unsigned int getint(FILE *fp)
+{
+  int c, c1, c2, c3;
+  c = getc(fp);  c1 = getc(fp);  c2 = getc(fp);  c3 = getc(fp);
+  return ((unsigned int) c) +
+         (((unsigned int) c1) << 8) + 
+	 (((unsigned int) c2) << 16) +
+	 (((unsigned int) c3) << 24);
+}
+
+
+/*******************************************/
+static void putshort(FILE *fp, int i)
+{
+  int c, c1;
+
+  c = ((unsigned int ) i) & 0xff;  c1 = (((unsigned int) i)>>8) & 0xff;
+  putc(c, fp);   putc(c1,fp);
+}
+
+
+/*******************************************/
+static void putint(FILE *fp, int i)
+{
+  int c, c1, c2, c3;
+  c  = ((unsigned int ) i)      & 0xff;  
+  c1 = (((unsigned int) i)>>8)  & 0xff;
+  c2 = (((unsigned int) i)>>16) & 0xff;
+  c3 = (((unsigned int) i)>>24) & 0xff;
+
+  putc(c, fp);   putc(c1,fp);  putc(c2,fp);  putc(c3,fp);
+}
+
+
+
+
+static byte pc2nc[256],r1[256],g1[256],b1[256];
+
+
+/*******************************************/
+int wxImage::WriteBMP(FILE *fp, byte *pic824, int ptype, int w, int h, byte *rmap, byte *gmap, byte *bmap, int numcols, int colorstyle)
+{
+  /*
+   * if PIC8, and colorstyle == F_FULLCOLOR, F_GREYSCALE, or F_REDUCED,
+   * the program writes an uncompressed 4- or 8-bit image (depending on
+   * the value of numcols)
+   *
+   * if PIC24, and colorstyle == F_FULLCOLOR, program writes an uncompressed
+   *    24-bit image
+   * if PIC24 and colorstyle = F_GREYSCALE, program writes an uncompressed
+   *    8-bit image
+   * note that PIC24 and F_BWDITHER/F_REDUCED won't happen
+   *
+   * if colorstyle == F_BWDITHER, it writes a 1-bit image 
+   *
+   */
+
+  int i,j, nc, nbits, bperlin, cmaplen;
+  byte *graypic, *sp, *dp, graymap[256];
+
+  nc = nbits = cmaplen = 0;
+  graypic = NULL;
+
+  if (ptype == PIC24 && colorstyle == F_GREYSCALE) {
+    /* generate a faked 8-bit per pixel image with a grayscale cmap,
+       so that it can just fall through existing 8-bit code */
+
+    graypic = (byte *) XpmMallocA(w*h);
+    if (!graypic) wxFatalError("unable to malloc in WriteBMP()");
+
+    for (i=0,sp=pic824,dp=graypic; i<w*h; i++,sp+=3, dp++) {
+      *dp = MONO(sp[0],sp[1],sp[2]);
+    }
+
+    for (i=0; i<256; i++) graymap[i] = i;
+    rmap = gmap = bmap = graymap;
+    numcols = 256;
+    ptype = PIC8;
+
+    pic824 = graypic;
+  }
+
+
+  if (ptype == PIC24) {  /* is F_FULLCOLOR */
+    nbits = 24;
+    cmaplen = 0;
+    nc = 0;
+  }
+
+  else if (ptype == PIC8) {
+    /* we may have duplicate colors in the colormap, and we'd prefer not to.
+     * build r1,g1,b1 (a contiguous, minimum set colormap), and pc2nc[], a
+     * array that maps 'pic8' values (0-numcols) into corresponding values
+     * in the r1,g1,b1 colormaps (0-nc)
+     */
+
+    for (i=0; i<256; i++) { pc2nc[i] = r1[i] = g1[i] = b1[i] = 0; }
+
+    nc = 0;
+    for (i=0; i<numcols; i++) {
+      /* see if color #i is a duplicate */
+      for (j=0; j<i; j++) {
+	if (rmap[i] == rmap[j] && gmap[i] == gmap[j] && 
+	    bmap[i] == bmap[j]) break;
+      }
+
+      if (j==i) {  /* wasn't found */
+	pc2nc[i] = nc;
+	r1[nc] = rmap[i];
+	g1[nc] = gmap[i];
+	b1[nc] = bmap[i];
+	nc++;
+      }
+      else pc2nc[i] = pc2nc[j];
+    }
+
+    /* determine how many bits per pixel we'll be writing */
+    if (colorstyle == F_BWDITHER || nc <= 2) nbits = 1;
+    else if (nc<=16) nbits = 4;
+    else nbits = 8;
+
+    cmaplen = 1<<nbits;                      /* # of entries in cmap */
+  }
+
+
+  bperlin = ((w * nbits + 31) / 32) * 4;   /* # bytes written per line */
+
+  putc('B', fp);  putc('M', fp);           /* BMP file magic number */
+
+  /* compute filesize and write it */
+  i = 14 +                /* size of bitmap file header */
+      40 +                /* size of bitmap info header */
+      (cmaplen * 4) +     /* size of colormap */
+      bperlin * h;        /* size of image data */
+
+  putint(fp, i);
+  putshort(fp, 0);        /* reserved1 */
+  putshort(fp, 0);        /* reserved2 */
+  putint(fp, 14 + 40 + (cmaplen * 4));  /* offset from BOfile to BObitmap */
+
+  putint(fp, 40);         /* biSize: size of bitmap info header */
+  putint(fp, w);          /* biWidth */
+  putint(fp, h);          /* biHeight */
+  putshort(fp, 1);        /* biPlanes:  must be '1' */
+  putshort(fp, nbits);    /* biBitCount: 1,4,8, or 24 */
+  putint(fp, BI_RGB);     /* biCompression:  BI_RGB, BI_RLE8 or BI_RLE4 */
+  putint(fp, bperlin*h);  /* biSizeImage:  size of raw image data */
+  putint(fp, 75 * 39);    /* biXPelsPerMeter: (75dpi * 39" per meter) */
+  putint(fp, 75 * 39);    /* biYPelsPerMeter: (75dpi * 39" per meter) */
+  putint(fp, nc);         /* biClrUsed: # of colors used in cmap */
+  putint(fp, nc);         /* biClrImportant: same as above */
+
+
+  /* write out the colormap */
+  for (i=0; i<cmaplen; i++) {
+    if (colorstyle == F_GREYSCALE) {
+      j = MONO(r1[i],g1[i],b1[i]);
+      putc(j,fp);  putc(j,fp);  putc(j,fp);  putc(0,fp);
+    }
+    else {
+      putc(b1[i],fp);
+      putc(g1[i],fp);
+      putc(r1[i],fp);
+      putc(0,fp);
+    }
+  }
+
+  /* write out the image */
+  if      (nbits ==  1) writeBMP1 (fp, pic824, w, h);
+  else if (nbits ==  4) writeBMP4 (fp, pic824, w, h);
+  else if (nbits ==  8) writeBMP8 (fp, pic824, w, h);
+  else if (nbits == 24) writeBMP24(fp, pic824, w, h);
+
+  if (graypic) XpmFree(graypic);
+
+  if (ferror(fp)) return -1;
+  
+  return 0;
+}
+
+
+	  
+	  
+/*******************************************/
+static void writeBMP1(FILE *fp, byte *pic8, int w, int h)
+{
+  int   i,j,c,bitnum,padw;
+  byte *pp;
+
+  padw = ((w + 31)/32) * 32;  /* 'w', padded to be a multiple of 32 */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic8 + (i * w);  
+
+    for (j=bitnum=c=0; j<=padw; j++,bitnum++) {
+      if (bitnum == 8) { /* write the next byte */
+	putc(c,fp);
+	bitnum = c = 0;
+      }
+      
+      c <<= 1;
+
+      if (j<w) {
+	c |= (pc2nc[*pp++] & 0x01);
+      }
+    }
+  }
+}  
+
+
+
+/*******************************************/
+static void writeBMP4(FILE *fp, byte *pic8, int w, int h)
+{
+  int   i,j,c,nybnum,padw;
+  byte *pp;
+
+
+  padw = ((w + 7)/8) * 8; /* 'w' padded to a multiple of 8pix (32 bits) */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic8 + (i * w);
+
+    for (j=nybnum=c=0; j<=padw; j++,nybnum++) {
+      if (nybnum == 2) { /* write next byte */
+	putc((c&0xff), fp);
+	nybnum = c = 0;
+      }
+
+      c <<= 4;
+
+      if (j<w) {
+	c |= (pc2nc[*pp] & 0x0f);
+	pp++;
+      }
+    }
+  }
+}  
+
+
+
+/*******************************************/
+static void writeBMP8(FILE *fp, byte *pic8, int w, int h)
+{
+  int   i,j,c,padw;
+  byte *pp;
+
+  padw = ((w + 3)/4) * 4; /* 'w' padded to a multiple of 4pix (32 bits) */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic8 + (i * w);
+
+    for (j=0; j<w; j++) putc(pc2nc[*pp++], fp);
+    for ( ; j<padw; j++) putc(0, fp);
+  }
+}  
+
+
+/*******************************************/
+static void writeBMP24(FILE *fp, byte *pic24, int w, int h)
+{
+  int   i,j,c,padb;
+  byte *pp;
+
+  padb = (4 - ((w*3) % 4)) & 0x03;  /* # of pad bytes to write at EOscanline */
+
+  for (i=h-1; i>=0; i--) {
+    pp = pic24 + (i * w * 3);
+
+    for (j=0; j<w; j++) {
+      putc(*pp++, fp);
+      putc(*pp++, fp);
+      putc(*pp++, fp);
+    }
+
+    for (j=0; j<padb; j++) putc(0, fp);
+  }
+}  
+
+
+
+
+
+
+/*******************************************/
+static int bmpError(char *fname, char *st)
+{
+  fprintf(stderr, "wxImage: %s: %s\n", fname, st);
+  return 0;
+}
+
+
+#ifdef wx_mac
+unsigned short Mac_xform24(unsigned char c);
+
+unsigned short Mac_xform24(unsigned char c) 
+{
+	return c | (c << 8);
+}
+// Create an Image, create a bitMap (Gworld for the data), copy the image to the
+// bitmap, delete the image
+Bool wxLoadBMPIntoBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+	CGrafPtr  colorPort;
+	PICINFO		picinfo;		// defined in wx_imgx.h
+	wxImage *xbmImage  = new wxImage();
+	if (xbmImage->LoadBMP(fileName, &picinfo) == 1) {
+		// CreateOffScreenPixMap(&colorPort, gifImage);
+		Rect bounds = {0, 0, picinfo.h, picinfo.w};
+		GDHandle savegw;
+		CGrafPtr saveport;
+		GetGWorld(&saveport, &savegw);
+		QDErr err;
+		GWorldPtr	newGWorld;
+		err = NewGWorld(&newGWorld, 0, &bounds, NULL, NULL, noNewDevice);
+		if (err) {
+			bm->SetOk(FALSE);
+			return FALSE;
+		}
+		SetGWorld(newGWorld, 0);
+		bm->x_pixmap = newGWorld;
+
+		RGBColor	cpix;
+		int y, x, k;
+		unsigned int byte;
+		unsigned char *buf = picinfo.pic;
+ 		GetForeColor(&cpix);	// probably 0,0,0
+ 		::EraseRect(&bounds);
+ 		if (picinfo.type == PIC8) {
+ 			for (y = 0; y < picinfo.h; y++) {
+ 				for (x = 0; x < picinfo.w; x++) {
+ 					byte = *buf++;
+					cpix.red = Mac_xform24(picinfo.r[byte]);
+  					cpix.green = Mac_xform24(picinfo.g[byte]);
+ 					cpix.blue = Mac_xform24(picinfo.b[byte]);
+ 					::SetCPixel(x, y, &cpix);
+ 				}
+ 			}
+ 		}
+ 		else { // must be 24 bit?
+ 			for (y = 0; y < picinfo.h; y++) {
+ 				for (x = 0; x < picinfo.w; x++) {
+ 					cpix.blue = Mac_xform24(*buf++);
+ 					cpix.green = Mac_xform24(*buf++);
+ 					cpix.red = Mac_xform24(*buf++);
+ 					::SetCPixel(x, y, &cpix);
+ 				}
+ 			}
+		}
+		SetGWorld(saveport, savegw);
+			
+		//  bm->pixmap = colorPort->portPixMap;
+		bm->SetWidth(picinfo.w);
+		bm->SetHeight(picinfo.h);
+		bm->SetDepth(picinfo.type==PIC8 ? 8 : 24);
+		bm->SetOk(TRUE);
+  		SetGWorld(saveport, savegw);
+  		XpmFree (picinfo.pic);
+		delete xbmImage;
+		return TRUE;
+	}
+	else {
+		bm->SetOk(FALSE);
+		return FALSE;
+	}
+}
+#endif
diff --git a/src/wxmac/utils/image/src/wx_image.cc b/src/wxmac/utils/image/src/wx_image.cc
new file mode 100644
index 0000000..b5bb41f
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_image.cc
@@ -0,0 +1,922 @@
+/*
+ * File:     wx_image.cc
+ * Purpose:  
+ *
+ *                       wxWindows 1.50
+ * Copyright (c) 1993 Artificial Intelligence Applications Institute,
+ *                   The University of Edinburgh
+ *
+ *                     Author: Julian Smart
+ *                        Date: 7-9-93
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice, author statement and this permission
+ * notice appear in all copies of this software and related documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS,
+ * IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL THE ARTIFICIAL INTELLIGENCE APPLICATIONS INSTITUTE OR THE
+ * UNIVERSITY OF EDINBURGH BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF
+ * DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH
+ * THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef wx_xview
+#include <stdlib.h>
+#endif
+
+#ifdef wx_motif
+#include <stdlib.h>
+#endif
+
+#include "wx.h"
+#include "wx_image.h"
+
+#ifdef wx_x
+
+#include <X11/X.h>
+#ifdef wx_xview
+#include <xview/screen.h>
+#include <xview/cursor.h>
+#include <xview/svrimage.h>
+extern Xv_Server xview_server;
+#endif
+#ifdef wx_motif
+#endif
+#ifdef wx_mac
+#include "wximgfil.h"
+#  if USE_XPM_IN_MAC
+#    define FOR_MAC
+#    include "xpm34.h"
+#  endif
+#endif
+
+/* file types that can be read */
+#define UNKNOWN 0
+#define GIF     1
+#define PM      2
+#define PBM     3
+#define XBM     4
+#define BMP     5
+#define PCX     6
+
+static unsigned long rootbg, rootfg;  /* fg/bg for root border */
+static int    autoquit = 0;     /* quit after loading first pic to rootW */
+static int    autogamma = 0;    /* perform gamma correction by default */
+static int    rootPattern = 0;  /* pattern used for root border */
+static char   initpath[500];
+#endif
+
+byte           r[256],g[256],b[256];  /* colormap */
+
+#ifdef wx_x
+/* used in XResource reading... */
+static char *def_str;
+static int   def_int;
+
+
+wxImage::wxImage(void)
+{
+  cMap = new wxColourMap;
+  filetype = wxUNKNOWN;
+
+  int   imap, ctrlmap, gmap, clrroot;
+  char *display, *fname, *whitestr, *blackstr, 
+       *infogeom, *fgstr, *bgstr, *ctrlgeom, *gamgeom;
+  char *rootfgstr, *rootbgstr;
+
+  XColor ecdef;
+  nfcols = 0;
+
+  /*****************************************************/
+  /*** variable Initialization                       ***/
+  /*****************************************************/
+
+  getcwd(initpath, sizeof(initpath));
+
+  /* init internal variables */
+  display = fname = whitestr = blackstr = NULL;
+  fgstr = bgstr = rootfgstr = rootbgstr = NULL;
+  pic = epic = cpic = NULL;
+  theImage = NULL;
+  LocalCmap = 0;
+  InitFSDTables(); // Only need in xvpbm.c and xvpm.c. Defined in xv24to8.c
+
+  /* init gamma curve */
+  ghand[0].x =   0;  ghand[0].y =   0;
+  ghand[1].x =  64;  ghand[1].y =  64;
+  ghand[2].x = 192;  ghand[2].y = 192;
+  ghand[3].x = 255;  ghand[3].y = 255;
+
+  /* init command-line options flags */
+  infogeom = DEFINFOGEOM;  ctrlgeom = DEFCTRLGEOM;  gamgeom = DEFGAMGEOM;
+  expand = 1;  ncols = -1;  noglob = 0;  revvideo = 0;  mono = 0;  
+  perfect = 0;  ninstall = 0;  fixedaspect = 0;  
+  dEBUG = 0;  bwidth = 2;
+  useroot = clrroot = noqcheck = rwcolor = 0;
+
+#ifdef BROKEFREECOLS
+  brokeFreeCols = 1;
+#else
+  brokeFreeCols = 0;
+#endif
+
+  defaspect = normaspect = 1.0;
+
+  imap = ctrlmap = gmap = 0;
+
+  /*****************************************************/
+  /*** X Resource Initialization                     ***/
+  /*****************************************************/
+
+  /* open the display */
+
+  if ( (theDisp=XOpenDisplay(display)) == NULL) {
+    fprintf(stderr, "Can't open display.\n");
+    exit(1);
+  }
+
+  if (rd_str ("infoGeometry"))  infogeom = def_str;
+  if (rd_flag("infoMap"))       imap     = def_int;
+  if (rd_flag("mono"))          mono     = def_int;
+  if (rd_int ("ncols"))         { ncols  = def_int; if (ncols>=0) noglob = 1; }
+  if (rd_flag("nglobal"))       noglob   = def_int;
+  if (rd_flag("ninstall"))      ninstall = def_int;
+  if (rd_flag("noqcheck"))      noqcheck = def_int;
+  if (rd_flag("perfect"))       perfect  = def_int;
+  if (rd_flag("reverseVideo"))  revvideo = def_int;
+  if (rd_str ("rootBackground")) rootbgstr = def_str;
+  if (rd_str ("rootForeground")) rootfgstr = def_str;
+  if (rd_int ("rootPattern"))    rootPattern = def_int;
+  if (rd_flag("rwColor"))       rwcolor  = def_int;
+  if (rd_flag("slow24"))        slow24   = def_int;
+  if (rd_str ("white"))         whitestr = def_str;
+      
+  /* if using root, generally gotta map ctrl window, 'cause there won't be
+     any way to ask for it.  (no kbd or mouse events from rootW) */
+  if (useroot && !autoquit) 
+    ctrlmap = 1;    
+
+  /* must not install colormaps on rootW */
+  if (useroot) { perfect=0;  noglob = 1; } 
+
+
+  /*****************************************************/
+  /*** X Setup                                       ***/
+  /*****************************************************/
+  
+  theScreen = DefaultScreen(theDisp);
+  theCmap   = DefaultColormap(theDisp, theScreen);
+  rootW     = RootWindow(theDisp,theScreen);
+  theVisual = DefaultVisual(theDisp,theScreen);
+  ncells    = DisplayCells(theDisp, theScreen);
+  dispWIDE  = DisplayWidth(theDisp,theScreen);
+  dispHIGH  = DisplayHeight(theDisp,theScreen);
+  dispDEEP  = DisplayPlanes(theDisp,theScreen);
+
+  /* set up white,black colors */
+  white = WhitePixel(theDisp,theScreen);
+  black = BlackPixel(theDisp,theScreen);
+  if (whitestr && XParseColor(theDisp, theCmap, whitestr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  white = ecdef.pixel;
+  if (blackstr && XParseColor(theDisp, theCmap, blackstr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  black = ecdef.pixel;
+
+  /* set up fg,bg colors */
+  fg = black;   bg = white;
+  if (fgstr && XParseColor(theDisp, theCmap, fgstr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  fg = ecdef.pixel;
+  if (bgstr && XParseColor(theDisp, theCmap, bgstr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  bg = ecdef.pixel;
+
+  /* set up root fg,bg colors */
+  rootfg = white;   rootbg = black;
+  if (rootfgstr && XParseColor(theDisp, theCmap, rootfgstr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  rootfg = ecdef.pixel;
+  if (rootbgstr && XParseColor(theDisp, theCmap, rootbgstr, &ecdef) &&
+      XAllocColor(theDisp, theCmap, &ecdef))  rootbg = ecdef.pixel;
+
+  /* set up infofg,infobg colors */
+  infofg = fg;   infobg = bg;
+
+
+  /* if '-mono' not forced, determine if we're on a b/w or color monitor */
+  if (!mono)
+  {
+    if (!wxColourDisplay())
+      mono = 1;
+  }
+  
+  /* if ncols wasn't set, set it to 2^dispDEEP, unless dispDEEP=1, in which
+     case ncols = 0;  (ncols = max number of colors allocated.  on 1-bit
+     displays, no colors are allocated */
+
+  if (ncols == -1) {
+    if (dispDEEP>1) ncols = 1<<dispDEEP;
+    else ncols = 0;
+  }
+  else if (ncols>256) ncols = 256;       /* so program doesn't blow up */
+
+  GenerateGamma();
+  GenerateFSGamma();
+
+  /* if we're not on a colormapped display, turn off rwcolor */
+/*
+  if (!(theVisual->class & 1) && rwcolor) {
+    fprintf(stderr,"xv: not a colormapped display.  'rwcolor' turned off.\n");
+    rwcolor = 0;
+  }
+*/
+ 
+}
+
+wxImage::~wxImage(void)
+{
+  Destroy();
+//  delete cMap;
+}
+
+Bool wxImage::Load(char *file)
+{
+  Destroy();
+  return openPic(file);
+}
+
+Bool wxImage::Destroy(void)
+{
+  closePic();
+  return TRUE;
+}
+
+void wxImage::GetSize(int *width, int *height)
+{
+  *width = eWIDE;
+  *height = eHIGH;
+}
+
+wxColourMap *wxImage::GetColourMap(void)
+{
+  SortColormap();
+
+  // save the desired RGB colormap (before gamma-correcting it)
+  for (int i=0; i<numcols; i++)
+    { rorg[i] = r[i];  gorg[i] = g[i];  borg[i] = b[i]; }
+
+  DoMonoAndRV();
+  if (autogamma) GammifyColors();
+
+  if (rwcolor) AllocRWColors();
+          else AllocColors();
+
+  if (LocalCmap)
+  {
+    cMap->cmap = LocalCmap;
+    cMap->destroyable = TRUE;
+    return cMap;
+//    XSetWindowColormap(theDisp,mainW, LocalCmap);
+  }
+  else return NULL;
+}
+
+/*
+void wxImage::SetWindow(wxCanvas *can)
+{
+  canvas = can;
+  if (!canvas)
+    return;
+
+  SortColormap();
+
+  // save the desired RGB colormap (before gamma-correcting it)
+  for (int i=0; i<numcols; i++)
+    { rorg[i] = r[i];  gorg[i] = g[i];  borg[i] = b[i]; }
+
+  DoMonoAndRV();
+  if (autogamma) GammifyColors();
+
+  if (rwcolor) AllocRWColors();
+          else AllocColors();
+
+//  Resize(eWIDE,eHIGH);
+
+  if (LocalCmap) {
+//    XSetWindowAttributes xswa;
+//    if (!ninstall) XInstallColormap(theDisp,LocalCmap); // Should only be used by WMs!!
+//    xswa.colormap = LocalCmap;
+//    XChangeWindowAttributes(theDisp,mainW,CWColormap,&xswa);
+    XSetWindowColormap(theDisp,mainW, LocalCmap);
+  }
+}
+
+*/
+
+void wxImage::Draw(wxCanvas *canvas, int x, int y, int width, int height)
+{
+  if (width == -1)
+    width = eWIDE;
+
+  if (height == -1)
+    height = eHIGH;
+
+  if (!canvas)
+    return;
+
+  wxFlushEvents();
+
+  if (!theImage)
+  {
+    CreateXImage();
+
+    if (!theImage)
+      return;
+  }
+
+  wxCanvasDC *dc = canvas->GetDC();
+  XPutImage(theDisp,canvas->xwindow,dc->gc,theImage,
+              dc->LogicalToDeviceX(x),dc->LogicalToDeviceY(y),
+              dc->LogicalToDeviceX(x),dc->LogicalToDeviceY(y),
+              dc->LogicalToDeviceXRel(width),dc->LogicalToDeviceYRel(height));
+#ifdef wx_motif
+  if (canvas->is_retained)
+    XPutImage(theDisp,canvas->backingPixmap,canvas->GetDC()->gcBacking,theImage,
+      // All Rel(ative) since we don't want to shift the image on the bitmap
+      // with scrolling
+              dc->LogicalToDeviceXRel(x),dc->LogicalToDeviceYRel(y),
+              dc->LogicalToDeviceXRel(x),dc->LogicalToDeviceYRel(y),
+              dc->LogicalToDeviceXRel(width),dc->LogicalToDeviceYRel(height));
+#endif
+}
+
+
+int wxImage::openPic(char *fullname)
+{
+  /* tries to load file #filenum (from 'namelist' list)
+   * returns 0 on failure (cleans up after itself)
+   * if successful, returns 1
+   */
+  PICINFO pinfo;
+  xvbzero((char *) &pinfo, sizeof(PICINFO));
+
+  int   i,okay,freename, nw, nh;
+  char *tmp;
+  FILE *fp;
+  char  filename[256], /* full name of the file to be loaded (could be /tmp) */
+        basename[128], /* just the name of the original file. No path */
+        magicno[8];    /* first 8 bytes of file */
+  
+  normaspect = defaspect;
+
+  /* clear any old error messages */
+
+  okay = 0;
+
+  /* set up fullname and basename */
+
+  tmp = rindex(fullname,'/');
+  if (!tmp) tmp = fullname; else tmp++;
+  strcpy(basename,tmp);
+  if (strlen(basename)>2 && strcmp(basename+strlen(basename)-2,".Z")==0) 
+    basename[strlen(basename)-2]='\0';     /* chop off .Z, if any */
+
+  /* if fullname doesn't start with a '/' (ie, it's a relative path), 
+     (and it's not the special case '<stdin>') prepend 'initpath' to it */
+  freename = 0;
+  if (fullname[0] != '/' && strcmp(fullname,STDINSTR)!=0) {
+    char *tmp;
+    tmp = (char *) XpmMallocA(strlen(fullname) + strlen(initpath) + 2);
+    if (!tmp) FatalError("malloc 'filename' failed");
+    sprintf(tmp,"%s/%s", initpath, fullname);
+    fullname = tmp;
+    freename = 1;
+  }
+    
+  /* uncompress if it's a .Z file */
+
+  i = strlen(fullname);
+  if (i>2 && strcmp(fullname+i-2,".Z")==0) {
+    strcpy(filename,"/tmp/xvXXXXXX");
+    mktemp(filename);
+    sprintf(wxBuffer,"%s -c %s >%s",UNCOMPRESS,fullname,filename);
+    if (system(wxBuffer)) {
+      goto FAILED;
+    }
+  }
+  else strcpy(filename,fullname);
+    
+
+  /* if the file is stdio, write it out to a temp file */
+  if (strcmp(filename,STDINSTR)==0) {
+    FILE *fp;
+
+    strcpy(filename,"/tmp/xvXXXXXX");
+    mktemp(filename);
+
+    fp = fopen(filename,"w");
+    if (!fp) FatalError("can't write /tmp/xv****** file");
+    
+    while ( (i=getchar()) != EOF) putc(i,fp);
+    fclose(fp);
+  }
+
+
+  /* now, try to determine what type of file we've got by reading the
+     first couple bytes and looking for a Magic Number */
+
+  fp=fopen(filename,"r");
+  if (!fp) {
+    goto FAILED;
+  }
+
+  fread(magicno,8,1,fp);  
+  fclose(fp);
+
+  filetype = UNKNOWN;
+  if (strncmp(magicno,"GIF87",5)==0) filetype = GIF;
+
+  else if (strncmp(magicno,"VIEW",4)==0 ||
+	   strncmp(magicno,"WEIV",4)==0) filetype = PM;
+
+  else if (magicno[0] == 'P' && magicno[1]>='1' && 
+	   magicno[1]<='6') filetype = PBM;
+
+  else if (strncmp(magicno,"#define",7)==0) filetype = XBM;
+
+  else if (magicno[0] == 'B' && magicno[1] == 'M') filetype = BMP;
+
+  else if (magicno[0]==0x0a && magicno[1] <= 5) filetype = PCX;
+
+  if (filetype == UNKNOWN) {
+    goto FAILED;
+  }
+
+  i = 1;
+  switch (filetype) {
+  case GIF: i = LoadGIF(filename,ncols); break;
+  case PM:  i = LoadPM (filename,ncols); break;
+  case PBM: i = LoadPBM(filename,ncols); break;
+  case XBM: i = LoadXBM(filename,ncols); break;
+  case PCX: 
+    {
+      i = !(LoadPCX(filename, &pinfo));
+      pic   = pinfo.pic;
+      pWIDE = pinfo.w;
+      pHIGH = pinfo.h;
+      break;
+    }
+  case BMP: 
+    {
+      i = !(LoadBMP(filename, &pinfo));
+      pic   = pinfo.pic;
+      pWIDE = pinfo.w;
+      pHIGH = pinfo.h;
+      break;
+    }
+
+  }
+  cpic = NULL;
+
+  if (i) {
+    goto FAILED;
+  }
+
+  /* successfully read this picture */
+
+  /* if we read a /tmp file, delete it.  won't be needing it any more */
+  if (strcmp(fullname,filename)!=0) unlink(filename);
+
+  normFact = 1;  nw = pWIDE;  nh = pHIGH;
+
+  // expand:  if expansion is negative, treat it as a reciprocal
+  if (expand<0) { eWIDE = pWIDE/abs(expand);  eHIGH = pHIGH/abs(expand); }
+           else { eWIDE = pWIDE * expand;     eHIGH = pHIGH * expand; }
+
+  cpic = pic;  cWIDE = pWIDE;  cHIGH = pHIGH;  cXOFF = cYOFF = 0;
+
+  if (freename) XpmFree(fullname);
+
+  return 1;
+
+  
+ FAILED:
+  if (strcmp(fullname,filename)!=0) unlink(filename);   /* kill /tmp file */
+  if (freename) XpmFree(fullname);
+  return 0;
+}
+
+
+
+
+/***********************************/
+void wxImage::closePic()
+{
+  /* kill all resources used for this picture.
+     this would include the window, any allocated colors, pic, epic, 
+     theImage, etc. */
+
+  int i;
+
+  if (LocalCmap) {
+ // Should be destroyed by ~wxColourMap
+//    XFreeColormap(theDisp,LocalCmap);
+    LocalCmap = 0;
+  }
+  else if (!brokeFreeCols) {
+    for (i=0; i<nfcols; i++) 
+      XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
+  }
+  else {
+    for (i=0; i<nfcols; i++) {
+      int j;
+      for (j=0; j<i; j++) {
+        if (freecols[i] == freecols[j])   /* already been freed once */
+	  break;
+      }
+      if (j==i)      /* wasn't found in already-freed list */
+        XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
+    }
+  }
+
+  if (epic != cpic && epic != NULL) XpmFree(epic);
+  if (cpic !=  pic && cpic != NULL) XpmFree(cpic);
+  if (pic != NULL) XpmFree(pic);
+  if (theImage != NULL) xvDestroyImage(theImage);
+  theImage = NULL;
+  pic = epic = cpic = NULL;
+
+}
+
+/***********************************/
+void wxImage::FixAspect(int grow,int *w,int *h)
+{
+  /* computes new values of eWIDE and eHIGH which will have aspect ratio
+     'normaspect'.  If 'grow' it will preserve aspect by enlarging, 
+     otherwise, it will shrink to preserve aspect ratio.  
+     Returns these values in 'w' and 'h' */
+
+  float xr,yr,curaspect,a,exp;
+
+  *w = eWIDE;  *h = eHIGH;
+
+  /* xr,yr are expansion factors */
+  xr = ((float) eWIDE) / cWIDE;
+  yr = ((float) eHIGH) / cHIGH;
+  curaspect  = xr / yr;
+
+  /* if too narrow & shrink, shrink height.  too wide and grow, grow height */
+  if ((curaspect < normaspect && !grow) || 
+      (curaspect > normaspect &&  grow)) {    /* modify height */
+    exp = curaspect / normaspect;
+    *h = (int) (eHIGH * exp + .5);
+  }
+
+  /* if too narrow & grow, grow width.  too wide and shrink, shrink width */
+  if ((curaspect < normaspect &&  grow) || 
+      (curaspect > normaspect && !grow)) {    /* modify width */
+    exp = normaspect / curaspect;
+    *w = (int) (eWIDE * exp + .5);
+  }
+
+
+  /* shrink to fit screen without changing aspect ratio */
+  if (*w>dispWIDE) {
+    int i;
+    a = (float) *w / dispWIDE;
+    *w = dispWIDE;
+    i = (int) (*h / a + .5);        /* avoid freaking some optimizers */
+    *h = i;
+  }
+
+  if (*h>dispHIGH) {
+    a = (float) *h / dispHIGH;
+    *h = dispHIGH;
+    *w = (int) (*w / a + .5);
+  }
+
+  if (*w < 1) *w = 1;
+  if (*h < 1) *h = 1;
+}
+
+/************************************************************************/
+/* following three rd_* functions swiped from xgraph, by David Harrison */
+/************************************************************************/
+
+/***********************************/
+int wxImage::rd_int(char *name)
+{
+  /* returns '1' if successful.  result in def_int */
+
+  if (def_str = XGetDefault(theDisp, PROGNAME, name)) {
+    if (sscanf(def_str, "%ld", &def_int) == 1) return 1;
+    else {
+      fprintf(stderr, "wxImage: couldn't read integer value for %s resource\n", 
+	      name);
+      return 0;
+    }
+  }
+  else return 0;
+
+}
+
+/***********************************/
+int wxImage::rd_str(char *name)
+{
+  /* returns '1' if successful.  result in def_str */
+  
+  if (def_str = XGetDefault(theDisp, PROGNAME, name)) return 1;
+  else return 0;
+
+}
+
+/***********************************/
+int wxImage::rd_flag(char *name)
+{
+  /* returns '1' if successful.  result in def_str */
+  
+  if (def_str = XGetDefault(theDisp, PROGNAME, name)) {
+    def_int = (strcmp(def_str, "on")==0) || 
+              (strcmp(def_str, "1")==0) ||
+	      (strcmp(def_str, "true")==0) ||
+	      (strcmp(def_str, "yes")==0);
+    return 1;
+    }
+
+  else return 0;
+}
+
+/*
+ * Get a wxBitmap and wxColourMap
+ */
+Bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxColourMap **cmap)
+{
+  wxImage *tempImage = new wxImage;
+  if (FileExists(filename) && tempImage->Load(filename))
+  {
+    bitmap->Create(tempImage->eWIDE, tempImage->eHIGH, tempImage->dispDEEP);
+
+    wxColourMap *tempColourMap = tempImage->GetColourMap();
+
+    tempImage->Resize(tempImage->eWIDE, tempImage->eHIGH);
+
+    wxFlushEvents();
+
+    Display *dpy = tempImage->theDisp;
+    GC gc = XCreateGC(dpy, bitmap->x_pixmap, (unsigned long )NULL, (struct XGCValues* )NULL);
+    int err = XPutImage(dpy,bitmap->x_pixmap,gc,tempImage->theImage,
+              0,0,
+              0,0,
+              tempImage->eWIDE,tempImage->eHIGH);
+
+    XFreeGC(dpy, gc);
+
+    bitmap->SetOk(TRUE);
+
+    delete tempImage;
+
+    if (cmap)
+      *cmap = tempColourMap;
+    else
+      delete tempColourMap;
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+
+wxBitmap *wxLoadBitmap(char *s, wxColourMap **cmap)
+{
+  wxBitmap *bitmap = new wxBitmap;
+  if (wxLoadIntoBitmap(s, bitmap, cmap))
+  {
+    return bitmap;
+  }
+  else
+  {
+    delete bitmap;
+    return NULL;
+  }
+}
+ 
+
+#endif // End X implementation
+
+#ifdef wx_msw // Start MSW implementation
+wxImage::wxImage(void)
+{
+}
+
+wxImage::~wxImage(void)
+{
+}
+
+Bool wxImage::Load(char *file)
+{
+  return FALSE;
+}
+
+Bool wxImage::Destroy(void)
+{
+  return FALSE;
+}
+
+void wxImage::Draw(wxCanvas *canvas, int x, int y, int width, int height)
+{
+}
+
+void wxImage::Resize(int width, int height)
+{
+}
+
+void wxImage::GetSize(int *width, int *height)
+{
+  *width = 0;
+  *height = 0;
+}
+
+wxColourMap *wxImage::GetColourMap(void)
+{
+  return NULL;
+}
+
+#endif // End MSW implementation
+
+#ifdef wx_mac // Start Macintosh implementation
+
+// Save (device dependent) wxBitmap as a DIB
+Bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxColourMap *colourmap)
+{
+	return FALSE;
+}
+
+
+Bool wxLoadPICTIntoBitmap(char *, wxBitmap *, wxColourMap **);
+
+Bool wxLoadPICTIntoBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+	FILE *fp = fopen(fileName,"rb");
+	if (fp) {
+		// I don't know why we skip 512 bytes. I would have
+		// thought fopen only processes the data fork. I suppose
+		// it could be the "Mac Draw" header block (IM-V, pg 88)
+		fseek(fp, 0, SEEK_END);
+		int fsize = ftell(fp) - 512;
+		fseek(fp, 512, SEEK_SET);	// 0 didn't work
+		PicHandle ph = (PicHandle)NewHandle(fsize);
+		CheckMemOK(ph);
+		int rsize = fread((char *)*ph, 1, fsize, fp);
+		// width = (*ph)->picFrame.right;
+		bm->SetWidth((*ph)->picFrame.right);
+		// bm->height = (*ph)->picFrame.bottom;
+		bm->SetHeight((*ph)->picFrame.bottom);
+		// bm->depth = wxDisplayDepth();
+		bm->SetDepth(wxDisplayDepth());
+		GDHandle savegd;
+		CGrafPtr saveport;
+		GetGWorld(&saveport, &savegd);
+		QDErr err;
+		GWorldPtr	newGWorld;
+		Rect	bounds = {0, 0, bm->GetHeight(), bm->GetWidth()};
+		err = NewGWorld(&bm->x_pixmap, 0, &bounds, NULL, NULL, noNewDevice);
+		if (!err) {
+		  SetGWorld(bm->x_pixmap, 0);
+		  DrawPicture(ph, &bounds);
+		  DisposeHandle((Handle)ph);
+		  SetGWorld(saveport, savegd);
+		  return TRUE;
+	    } else {
+	      bm->x_pixmap = NULL;
+	      return FALSE;
+	    }
+	} else
+		return FALSE;
+}
+
+
+Bool wxLoadXPMIntoBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+#if USE_XPM_IN_MAC
+	return bm->LoadFile(fileName,wxBITMAP_TYPE_XPM);
+#else
+    wxImage *img = new(wxImage);
+  	img->LoadPM(fileName, 0);	// nc arg - what does it do ??
+  	// Convert the image to a Bitmap
+  	delete img;
+#endif
+ } 
+
+void Mac_FixupFileName(char * dest, char * src);
+
+void Mac_FixupFileName(char * dest, char * src) {
+	char *slpos = strchr(src, '/');
+	char *colpos = strchr(src, ':');
+	if (colpos) {
+		// Assume that any colon indicates a mac path
+		strcpy(dest, src);
+	} else if (slpos) {
+		if (slpos == src) {
+			// its an abs path - can't cope that
+			*dest = '\0';
+			return;
+		}
+		// create a relative path;
+		*dest++ = ':';
+		int len = colpos - src;
+		strncpy(dest, src, len);
+		dest += len;
+		*dest++ = ':';
+		strcpy(dest, slpos+1);	// CJC - FIXME - really should iterate over the rest 
+	} else {
+		// probably just a file name
+		strcpy(dest, src);
+	}
+}
+
+// Load into existing bitmap;
+//Bool *wxLoadIntoBitmap(char *fileName, wxBitmap *bitmap, wxColourMap **pal);
+
+Bool wxLoadIntoBitmap(char *infile, wxBitmap *bitmap, wxColourMap **pal)
+{
+  Bool stats = FALSE;
+  char fileName[255];
+  Mac_FixupFileName(fileName, infile);
+  if (wxMatchWild("*.gif",fileName)) {
+    stats = wxLoadGifIntoBitmap(fileName, bitmap, pal);
+  }
+  else if (wxMatchWild("*.pict", fileName)) {
+    stats = wxLoadPICTIntoBitmap(fileName, bitmap, pal);
+  }
+  else if (wxMatchWild("*.xpm", fileName)) {
+	stats = wxLoadXPMIntoBitmap(fileName, bitmap, pal);
+ }
+  if (stats)
+    return TRUE;
+  else
+  {
+    delete bitmap;
+    return 0;
+  }
+  return 0;
+}
+
+wxBitmap *wxLoadBitmap(char *fileName, wxColourMap **pal)
+{
+  Bool stats;
+  wxBitmap *bitmap = new wxBitmap;
+
+  if (wxLoadIntoBitmap(fileName, bitmap, pal))
+  	return bitmap;
+  else
+  	return NULL;
+}
+
+ 
+wxImage::wxImage(void)
+{
+	gifpic = NULL;
+	dEBUG = 0;
+}
+
+wxImage::~wxImage(void)
+{
+	if (gifpic)
+		delete gifpic;
+}
+
+Bool wxImage::Load(char *file)
+{
+  gifpic = new wxGIF(file);
+  if (gifpic)
+  	return TRUE;
+  else
+  	return FALSE;
+}
+
+Bool wxImage::Destroy(void)
+{
+  return FALSE;
+}
+
+void wxImage::Draw(wxCanvas *canvas, int x, int y, int width, int height)
+{
+}
+
+void wxImage::Resize(int width, int height)
+{
+}
+
+void wxImage::GetSize(int *width, int *height)
+{
+  *width = 0;
+  *height = 0;
+}
+
+wxColourMap *wxImage::GetColourMap(void)
+{
+  return NULL;
+}
+
+#endif // End Mac implementation
diff --git a/src/wxmac/utils/image/src/wx_image.h b/src/wxmac/utils/image/src/wx_image.h
new file mode 100644
index 0000000..213c023
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_image.h
@@ -0,0 +1,231 @@
+/*
+ * File:     wx_image.h
+ * Purpose:  
+ *
+ *                       wxWindows 1.50
+ * Copyright (c) 1993 Artificial Intelligence Applications Institute,
+ *                   The University of Edinburgh
+ *
+ *                     Author: Julian Smart
+ *                        Date: 7-9-93
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice, author statement and this permission
+ * notice appear in all copies of this software and related documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS,
+ * IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL THE ARTIFICIAL INTELLIGENCE APPLICATIONS INSTITUTE OR THE
+ * UNIVERSITY OF EDINBURGH BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF
+ * DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH
+ * THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef wx_imageh
+#define wx_imageh
+
+#include "common.h"
+#include "wx_setup.h"
+#include "wx_canvs.h"
+#include "wx_gdi.h"
+#include "wx_imgx.h"
+
+#ifdef wx_mac
+#include "wximgfil.h" // brings in GIF handling
+#endif
+
+#define wxUNKNOWN 0
+#ifndef wx_mac		// FIXME
+#define wxGIF     1
+#endif
+#define wxPM      2
+#define wxPBM     3
+#define wxXBM     4
+
+#ifdef wx_mac 
+// Save (device dependent) wxBitmap as a DIB
+Bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxColourMap *colourmap = NULL);
+
+// Load device independent bitmap into device dependent bitmap
+wxBitmap *wxLoadBitmap(char *filename, wxColourMap **colourmap = NULL);
+
+// Load into existing bitmap;
+Bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxColourMap **pal = NULL);
+// There are other wxLoad*IntoBitmap defined in wximgfil.h
+#endif
+
+class wxImage: public wxObject
+{
+  int filetype;
+  wxColourMap *cMap;
+#ifdef wx_mac
+  wxGIF *gifpic;
+#endif
+ public:
+
+  /*
+   * Public interface
+   */
+
+  wxImage(void);
+  ~wxImage(void);
+
+  Bool Load(char *file);
+  Bool Destroy(void);
+  void Draw(wxCanvas *canvas, int x = 0, int y = 0, int width = -1, int height = -1);
+  void Resize(int, int);
+  void GetSize(int *width, int *height);
+  inline int GetType(void) { return filetype; }
+  wxColourMap *GetColourMap(void);
+
+  /*
+   * X stuff
+   */
+
+#ifdef wx_x
+  Display       *theDisp;
+  int           theScreen;
+  unsigned int  ncells, dispWIDE, dispHIGH, dispDEEP;
+  Colormap      theCmap, LocalCmap;
+  Window        rootW;
+  unsigned long black, white, fg, bg, infofg, infobg;
+  Visual        *theVisual;
+#endif
+  /* global vars used by LOAD routines */
+  byte          *pic;                   /* ptr to loaded picture */
+  byte *pic24;  /* Used by 25-8 bit conversion */
+  unsigned int   pWIDE,pHIGH;           /* size of 'pic' */
+  int            dEBUG;                 /* print debugging info */
+  int            mono;                  /* true if displaying grayscale */
+
+
+  /* more global variables, used by xv and xvmisc */
+  byte          *cpic;         /* cropped version of pic */
+  unsigned int  cWIDE, cHIGH,  /* size of cropped region */
+                cXOFF, cYOFF;  /* offset of region from 0,0 of pic */
+
+  byte          *epic;         /* expanded version of cpic */
+                                   /* points to pic when at 1:1 expansion */
+                                   /* this is converted to 'theImage' */
+  unsigned int  eWIDE, eHIGH;  /* size of epic */
+  unsigned int  normFact;      /* factor to shrink picture by for 'norm' */
+
+  byte           rorg[256],gorg[256],borg[256];  /* ORIGINAL colormap */
+
+
+#ifdef wx_x
+  XImage        *theImage;     /* X version of epic */
+#endif
+  unsigned long freecols[256]; /* list of pixel values to free */
+  int           nfcols;        /* number of colors to free */
+  unsigned long cols[256];     /* maps pic pixel values to X pixel vals */
+  int           fc2pcol[256];  /* maps freecols into pic pixel values */
+  int           numcols;       /* # of desired colors in picture */
+  int           ncols;         /* max # of (different) colors to alloc */
+
+  int           expand,        /* expansion amount */
+                bwidth,        /* border width of created windows */
+                noglob,        /* force to only use colors it alloced */
+                revvideo,      /* reverse video */
+                perfect,       /* perfect color.  install own colormap */
+                fixedaspect,   /* fixed aspect ratio */
+                slow24,        /* use slow 24to8 algorithm */
+                ninstall,      /* true if using icccm-complaint WM
+                                  (a WM that will does install CMaps */
+                useroot,       /* true if we should draw in rootW */
+                noqcheck,      /* true if we should NOT do QuickCheck */
+                rwcolor,       /* true if we should use R/W color cells */
+                rwthistime,    /* true if we DID use R/W color cells */
+                brokeFreeCols; /* true if server has broken XFreeColors */
+
+  float         defaspect,     /* default aspect ratio to use */
+                normaspect;    /* normal aspect ratio of this picture */
+
+
+
+  /*************************** XVMISC.C ***************************/
+#ifdef wx_x
+  void Rotate(int);
+  void SortColormap(void);
+  void AllocColors(void);
+  void AllocRWColors(void);
+  void DoMonoAndRV(void);
+  void FSDither(byte *, int, int, byte *);
+  void CreateXImage(void);
+  void FatalError(char *);
+  void Timer(int);
+
+  /*************************** XV24TO8.C **************************/
+#endif
+  int  Conv24to8(byte *, int, int, int);
+  int Quick24to8(byte *p24, int w, int h);
+  int QuickCheck(byte *pic24, int w, int h, int maxcol);
+  void get_histogram(CBOX *box);
+  CBOX *largest_box();
+  void splitbox(CBOX *ptr);
+  void shrinkbox(CBOX *box);
+  int quant_fsdither();
+
+#ifdef wx_x
+  /**************************** XVGAM.C **************************/
+  void GenerateGamma(void);
+  void GenerateFSGamma(void);
+  void GammifyColors(void);
+  void HSVgamma(void);
+
+  /**************************** XVGIF.C ***************************/
+  int LoadGIF(char *, int);
+  int WriteGIF(FILE *fp, byte *pic, int w, int h, byte *rmap, byte *gmap, byte *bmap, int numcols, int colorstyle);
+#endif
+  /**************************** XVPM.C ****************************/
+  int LoadPM(char *, int);
+  int WritePM(FILE *, byte *, int, int, byte *, byte *, byte *, int, int);
+#if wx_x
+  /**************************** XVPBM.C ***************************/
+  int LoadPBM(char *, int);
+  int WritePBM(FILE *, byte *, int, int, byte *, byte *, byte *, int, int, int);
+  int loadpbm(FILE *fp, int w, int h, int raw);
+  int loadpgm(FILE *fp, int w, int h, int maxv, int raw);
+  int loadppm(FILE *fp, int w, int h, int maxv, int raw, int nc);
+#endif
+  /**************************** XVXBM.C ***************************/
+  int LoadXBM(char *, int);
+  int WriteXBM(FILE *, byte *, int, int, char *);
+
+  /* xvbmp.c */
+  int LoadBMP(char *fname, PICINFO *pinfo);
+  int WriteBMP(FILE *fp, byte *pic824, int ptype, int w, int h, byte *rmap, byte *gmap, byte *bmap, int numcols, int colorstyle);
+#if wx_x
+  /* xvpcx.c */
+  int LoadPCX(char *fname, PICINFO *pinfo);
+
+   /* Taken from xvmisc.c */
+  void RotatePic(byte *, unsigned int *, unsigned int *, int);
+  void FloydDitherize8(byte *);
+  void FloydDitherize1(XImage *);
+  void FreeMostResources(void);
+
+  /* Taken from xvgif.c */
+  int  ReadCode();
+  void DoInterlace(byte);
+  int  GifError(char *);
+
+  /* Taken from xv.c */
+  int  openPic(char *file);
+  void closePic();
+  void FixAspect(int, int *, int *);
+  void GetWindowPos(XWindowAttributes *);
+  void SetWindowPos(XWindowAttributes *);
+  int  rd_int(char *);
+  int  rd_str(char *);
+  int  rd_flag(char *);
+#endif
+};
+
+#endif // wx_imageh
diff --git a/src/wxmac/utils/image/src/wx_imgx.h b/src/wxmac/utils/image/src/wx_imgx.h
new file mode 100644
index 0000000..70487e5
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_imgx.h
@@ -0,0 +1,421 @@
+/*
+ * File:     wx_imgx.h
+ * Purpose:  
+ *
+ *                       wxWindows 1.50
+ * Copyright (c) 1993 Artificial Intelligence Applications Institute,
+ *                   The University of Edinburgh
+ *
+ *                     Author: Julian Smart
+ *                        Date: 7-9-93
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice, author statement and this permission
+ * notice appear in all copies of this software and related documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS,
+ * IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL THE ARTIFICIAL INTELLIGENCE APPLICATIONS INSTITUTE OR THE
+ * UNIVERSITY OF EDINBURGH BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF
+ * DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH
+ * THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef wx_imgxh
+#define wx_imgxh
+
+#ifdef SVR4             /* SysV release 4 uses dirent */
+#ifndef sgi             /* but Silicon Graphics doesn't */
+#define DIRENT
+#endif
+#endif
+
+#ifdef VMS
+#include "unixlib.h"
+// some names are different
+#define rindex strrchr
+#define unlink delete
+#endif
+
+/* include files */
+#include <stdio.h>
+#include <math.h>
+#include <ctype.h>
+#include <string.h>
+extern int   errno;             /* this SHOULD be in errno.h */
+extern char *sys_errlist[];     /* this SHOULD be in errno.h */
+
+#if !defined(__convexc__) && !defined(VMS) /* Convex doesn't have <memory.h> */
+#include <memory.h>             /* for 'memset()' prototype */
+#endif
+
+/* neither IBM AOS 4.3, Convex, nor BSD 4.3 on VAX have <malloc.h> */
+#if !defined(ibm032) && !defined(__convexc__) && \
+    !(defined(vax) && !defined(ultrix)) && !defined(VMS) && !defined(wx_mac)
+#if defined(hp300) || defined(hp800)
+#include <sys/malloc.h>                /* it's in 'sys' on HPs*/
+#else
+#include <malloc.h>
+#endif
+#endif
+
+#ifdef wx_x
+/* Comment following out to avoid problems with GNU string.h conflict */
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/cursorfont.h>
+#include <X11/keysym.h>
+#endif
+
+#if defined(NEEDSTIME) || defined(NEEDSDIR)
+#include <sys/types.h>    /* only include <sys/types.h> once */
+#endif
+
+#ifdef NEEDSTIME
+#ifndef sgi              /* silicon graphics doesn't have timeb.h */
+#include <sys/timeb.h>
+#endif
+#include <signal.h>
+#if defined(sco) && !defined(NOTIMER)
+#include <sys/itimer.h>
+#endif
+#ifndef  sigmask
+#define  sigmask(m)      (1 << ((m)-1))
+#endif
+#endif
+
+#ifdef NEEDSDIR
+#ifdef sco
+#include <sys/ndir.h>
+#define lstat stat
+#else
+#ifndef ATT
+#include <sys/dir.h>
+#endif  /* ATT */
+#endif  /* sco */
+#include <sys/param.h>
+#include <sys/stat.h>
+#ifdef DIRENT
+#include <dirent.h>
+#endif
+#endif
+
+#ifdef NEEDSVARARGS
+#include <varargs.h>
+#endif
+
+/* signal macros */
+#ifdef SVR4
+#define HOLD_SIG         sighold(SIGALRM)  /* block ALRM sig from occurring */
+#define RELEASE_SIG      sigrelse(SIGALRM)
+#define PAUSE_SIG        sigpause(SIGALRM) /* sleep until ALRM signal */
+#else
+#define HOLD_SIG         sigblock(sigmask(SIGALRM))
+#define RELEASE_SIG      sigblock(0)
+#define PAUSE_SIG        sigpause(0)
+#endif
+
+
+#ifdef i386
+#define UNCOMPRESS    "/usr/local/bin/uncompress"   /* uncompress program */
+#undef  HOLD_SIG
+#define HOLD_SIG      /* don't know how to handle signals  MWS 10/18/90 */
+#undef  RELEASE_SIG
+#define RELEASE_SIG   /* */
+#undef  PAUSE_SIG
+#define PAUSE_SIG     /* */
+#else
+#define UNCOMPRESS "/usr/ucb/uncompress"   /* for uncompressing .Z files */
+#endif
+
+#define PROGNAME  "xv"             /* used in resource database */
+
+#define DEFINFOGEOM "-10+10"       /* default position of info window */
+#define DEFDIRGEOM  "-10-10"       /* default position of directory window */
+#define DEFCTRLGEOM "+400+400"     /* default position of ctrl window */
+#define DEFGAMGEOM  "+10-10"       /* default position of gamma window */
+
+#define INFOWIDE 500               /* (fixed) size of info window */
+#define INFOHIGH 250
+
+#define CTRLWIDE 440               /* (fixed) size of control window */
+#define CTRLHIGH 295
+
+#define DIRWIDE  300               /* (fixed) size of directory window */
+#define DIRHIGH  420
+
+#define GAMWIDE  366               /* (fixed) size of Gamma window */
+#define GAMHIGH  356
+
+#define MAXNAMES 1024   /* max # of files (more than this?  Get REAL!) */
+
+/* strings in the INFOBOX (used in SetISTR and GetISTR) */
+#define NISTR         9    /* number of ISTRs */
+#define ISTR_INFO     0
+#define ISTR_WARNING  1
+#define ISTR_FILENAME 2
+#define ISTR_FORMAT   3
+#define ISTR_RES      4
+#define ISTR_CROP     5
+#define ISTR_EXPAND   6
+#define ISTR_COLOR    7
+#define ISTR_COLOR2   8
+
+/* potential values of 'infomode', used in info box drawing routines */
+#define INF_NONE 0    /* empty box */
+#define INF_STR  1    /* just ISTR_INFO */
+#define INF_PART 2    /* filename, format, size and infostr */
+#define INF_FULL 3    /* INF_PART + clipping, expansion, colorinfo */
+
+
+/* buttons in the ctrl window */
+#define NBUTTS  20
+#define BNEXT   0
+#define BPREV   1
+#define BCROP   2
+#define BUNCROP 3
+#define BNORM   4
+#define BMAX    5
+#define BUP2    6
+#define BDN2    7
+#define BUP10   8
+#define BDN10   9
+#define BQUIT   10
+#define B4BY3   11
+#define BSAVE   12
+#define BROTL   13
+#define BINFO   14
+#define BGAMMA  15
+#define BASPECT 16
+#define BROTR   17
+#define BMAXPECT 18
+#define BACROP   19
+
+/* buttons in the 'save' window */
+#define S_NBUTTS 4
+#define S_BOPEN  0
+#define S_BSAVE  1
+#define S_BCANC  2
+#define S_BQUIT  3
+
+
+/* buttons in the 'gamma' window */
+#define G_NBUTTS  17
+#define G_BAPPLY  0
+#define G_BNOGAM  1
+#define G_BRESET  2
+#define G_BDEF    3
+#define G_BGTYPE  4
+#define G_BCLOSE  5
+#define G_BUP_BR  6
+#define G_BDN_BR  7
+#define G_BUP_CN  8
+#define G_BDN_CN  9
+#define G_BHSVRGB 10
+#define G_B1      11
+#define G_B2      12
+#define G_B3      13
+#define G_B4      14
+#define G_BSET    15
+#define G_BUNDO   16
+
+
+/* definitions of first char of dirnames[i] (filetype) */
+#define C_FIFO  'f'    /* FIFO special file */
+#define C_CHR   'c'    /* character special file */
+#define C_DIR   'd'    /* directory */
+#define C_BLK   'b'    /* block special file */
+#define C_LNK   'l'    /* symbolic link */
+#define C_SOCK  's'    /* socket */
+#define C_REG   ' '    /* regular file */
+
+
+/* random string-placing definitions */
+#define SPACING 3      /* vertical space between strings */
+#define ASCENT   (mfinfo->ascent)
+#define DESCENT  (mfinfo->descent)
+#define CHIGH    (ASCENT + DESCENT)
+#define LINEHIGH (CHIGH + SPACING)
+
+
+#define STDINSTR "<stdin>"
+
+typedef unsigned char byte;
+
+typedef struct {
+#ifndef wx_mac
+		 Window win;            /* window ID */
+#endif
+		 int len;               /* length of major axis */
+		 int vert;              /* true if vertical, else horizontal */
+		 int active;            /* true if scroll bar can do anything*/
+		 int min,max;           /* min/max values 'pos' can take */
+		 int val;               /* 'value' of scrollbar */
+		 int page;              /* amt val change on pageup/pagedown */
+		 int tpos;              /* thumb pos. (pixels from tmin) */
+		 int tmin,tmax;         /* min/max thumb offsets (from 0,0) */
+		 int tsize;             /* size of thumb (in pixels) */
+		 unsigned long fg,bg;   /* colors */
+		 void (*drawobj)();     /* redraws obj controlled by scrl*/
+		 int uplit, dnlit;      /* true if up&down arrows are lit */
+	       } SCRL;
+
+typedef struct {
+#ifndef wx_mac
+		 Window win;            /* parent window */
+#endif
+		 int x,y,w,h;           /* size of button rectangle */
+		 int lit;               /* if true, invert colors */
+		 int active;            /* if false, stipple gray */
+		 int toggle;            /* if true, clicking toggles state */
+		 unsigned long fg,bg;   /* colors */
+		 char *str;             /* string in button */
+	       } BUTT;
+
+
+typedef struct {
+#ifndef wx_mac
+		 Window win;            /*  window */
+#endif
+		 int x,y,w,h;           /* size of window */
+		 unsigned long fg,bg;   /* colors */
+		 char **str;            /* ptr to list of strings */
+		 int   nstr;            /* number of strings */
+		 int   selected;        /* number of 'selected' string */
+		 int   nlines;          /* number of lines shown at once */
+		 SCRL  scrl;            /* scrollbar that controls list */
+		 int   filetypes;       /* true if filetype icons to be drawn*/
+		 int   dirsonly;        /* if true, only dirs selectable */
+	       } LIST;
+
+
+typedef struct rbutt { 
+#ifndef wx_mac
+			Window win;            /* parent window */
+#endif
+		       int           x,y;      /* position in parent */
+		       char         *str;      /* the message string */
+		       int           selected; /* selected or not */
+		       int           active;   /* selectable? */
+		       struct rbutt *next;     /* pointer to next in group */
+		       unsigned long fg,bg;    /* colors */
+		     } RBUTT;
+
+/* 25-8 bit conversion stuff */
+#define	MAX_CMAP_SIZE	256
+#define	COLOR_DEPTH	8
+#define	MAX_COLOR	256
+#define	B_DEPTH		5		/* # bits/pixel to use */
+#define	B_LEN		(1<<B_DEPTH)
+#define	C_DEPTH		2
+#define	C_LEN		(1<<C_DEPTH)	/* # cells/color to use */
+
+typedef	struct colorbox {
+  struct colorbox *next, *prev;
+  int              rmin,rmax, gmin,gmax, bmin,bmax;
+  int              total;
+} CBOX;
+
+typedef struct {
+  int num_ents;
+  int entries[MAX_CMAP_SIZE][2];
+} CCELL;
+
+extern byte           r[],g[],b[];  /* colormap */
+extern byte           gamcr[];   /* gamma correction curve */
+extern byte           fsgamcr[]; /* gamma correction curve (for FS dither) */
+#ifdef wx_x
+extern XPoint                ghand[];
+#endif
+
+/* MACROS */
+#define CENTERX(f,x,str) ((x)-XTextWidth(f,str,strlen(str))/2)
+#define CENTERY(f,y) ((y)-((f->ascent+f->descent)/2)+f->ascent)
+
+/* RANGE forces a to be in the range b..c (inclusive) */
+#define RANGE(a,b,c) { if (a<b) a=b;  if (a>c) a=c; }
+
+/* PTINRECT returns '1' if x,y is in rect (inclusive) */
+#define PTINRECT(x,y,rx,ry,rw,rh) \
+           ((x)>=(rx) && (y)>=(ry) && (x)<=(rx)+(rw) && (y)<=(ry)+(rh))
+
+/* MONO returns total intensity of r,g,b components */
+#define MONO(rd,gn,bl) (((rd)*11 + (gn)*16 + (bl)*5) >> 5)  /*.33R+ .5G+ .17B*/
+
+typedef struct { byte *pic;                  /* image data */
+		 int   w, h;                 /* size */
+		 int   type;                 /* PIC8 or PIC24 */
+
+		 byte  r[256],g[256],b[256];
+		                             /* colormap, if PIC8 */
+
+		 int   frmType;              /* def. Format type to save in */
+		 int   colType;              /* def. Color type to save in */
+		 char  fullInfo[128];        /* Format: field in info box */
+		 char  shrtInfo[128];        /* short format info */
+		 char *comment;              /* comment text */
+		 
+		 int   numpages;             /* # of page files, if >1 */
+		 char  pagebname[64];        /* basename of page files */
+	       } PICINFO;
+
+/* constants for setting radio buttons in dirW */
+#define F_COLORS    0
+#define F_FORMAT    1
+
+#define F_FULLCOLOR 0
+#define F_GREYSCALE 1
+#define F_BWDITHER  2
+#define F_REDUCED   3
+
+#define F_GIF       0
+#define F_PM        1
+#define F_PBMRAW    2
+#define F_PBMASCII  3
+#define F_XBM       4
+#define F_SUNRAS    5
+#define F_BMP       6
+#define F_PS        7
+#define F_IRIS      8
+
+#ifdef HAVE_JPEG
+#define F_JPEG      9
+#endif
+
+#ifdef HAVE_TIFF
+#ifdef HAVE_JPEG
+#define F_TIFF      10
+#else
+#define F_TIFF      9
+#endif
+#endif
+
+/* indicies into conv24MB */
+#define CONV24_8BIT  0
+#define CONV24_24BIT 1
+#define CONV24_SEP1  2
+#define CONV24_LOCK  3
+#define CONV24_SEP2  4
+#define CONV24_FAST  5
+#define CONV24_SLOW  6
+#define CONV24_BEST  7
+#define CONV24_MAX   8
+
+/* values 'picType' can take */
+#define PIC8  CONV24_8BIT
+#define PIC24 CONV24_24BIT
+
+void InitFSDTables(void);
+#ifdef wx_x
+void xvDestroyImage(XImage *image);
+void xvbzero(char *s, int len);
+#endif
+
+#endif // wx_imgx
diff --git a/src/wxmac/utils/image/src/wx_pm.cc b/src/wxmac/utils/image/src/wx_pm.cc
new file mode 100644
index 0000000..0d43131
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_pm.cc
@@ -0,0 +1,350 @@
+/*
+ * xvpm.c - load routine for 'pm' format pictures
+ *
+ * LoadPM(fname, numcols)  -  loads a PM pic, does 24to8 code if nec.
+ * WritePM(fp, pic, w, h, r,g,b, numcols, style)
+ * WriteRaw(fp, pic, w, h, r,g,b, numcols, style)
+ */
+
+/*
+ * Copyright 1989, 1990 by the University of Pennsylvania
+ *
+ * Permission to use, copy, and distribute for non-commercial purposes,
+ * is hereby granted without fee, providing that the above copyright
+ * notice appear in all copies and that both the copyright notice and this
+ * permission notice appear in supporting documentation.
+ *
+ * The software may be modified for your own purposes, but modified versions
+ * may not be distributed.
+ *
+ * This software is provided "as is" without any express or implied warranty.
+ */
+
+
+#include <stdlib.h>
+#include "wx.h"
+#include "wx_image.h"
+#include "wx_imgx.h"
+
+//#include <sys/types.h>
+
+typedef struct {
+	int	pm_id;		// Magic number for pm format files.
+	int	pm_np;		// Number of planes. Normally 1.	
+	int	pm_nrow;	// Number of rows. 1 - MAXNELM.		
+	int	pm_ncol;	// Number of columns. 1 - MAXNELM.	
+	int	pm_nband;	// Number of bands.			
+	int	pm_form;	// Pixel format.			
+	int	pm_cmtsize;	// Number comment bytes. Includes NULL. 
+	char	*pm_image;	// The image itself.			
+	char	*pm_cmt;	// Transforms performed.		
+} pmpic;
+
+pmpic  thePic;
+
+static void flipl(byte *);
+
+#define pm_nelm(p)	((p)->pm_ncol * (p)->pm_nrow)
+#define pm_nbelm(p)	(pm_nelm(p) * (p)->pm_nband)
+#define pm_psize(p)	(pm_nbelm(p) * (((p)->pm_form)&0xff))
+#define pm_isize(p)	((p)->pm_np * pm_psize(p))
+
+#define	PM_MAGICNO	0x56494557		/* Hex for VIEW */
+#define PM_MAXNELM	1024
+#define PM_MAXNBAND	1024
+#define PM_NOSHIFT	0
+#define PM_SHIFT	1
+
+#define	PM_A		0x8000
+#define	PM_C		0x8001
+#define	PM_S		0x8002
+#define	PM_I		0x8004
+#define PM_F		0xc004
+
+#define PM_RED 0xff
+#define PM_GREEN 0xff00
+#define PM_BLUE 0xff0000
+#define PM_ALPHA 0xff000000
+#define PM_BW 0
+
+#define	PM_CMAX		0xff
+#define PM_SMAX		0x7fff
+#define	PM_IMAX		0x7fffffff
+#define PM_FMAX		1.7E38
+
+#define PM_IOHDR_SIZE	(sizeof(pmpic)-(2*sizeof(char*)))
+
+/*
+
+#define	pm_max(pm)	((pm)->pm_form == PM_C ? PM_CMAX :		  \
+				(pm)->pm_form == PM_S ? PM_SMAX :	  \
+					(pm)->pm_form == PM_I ? PM_IMAX : \
+						 PM_FMAX)
+
+#define pm_index(fm)	(((fm)&0xff)-(((fm)>>14)&01))
+#define	pm_sel(fm,fn)	(*((fn)[pm_index(fm)]))
+#define pm_iindex(a,nc,cr,cc)	((a)+((cr)*(nc))+(cc))
+ 
+#define pm_npix(p)      (pm_nbelm(p) * (p)->pm_np)
+
+
+typedef	struct {
+	int	pm_x;		// X Position.
+	int	pm_y;		// Y Position. 
+	int	pm_z;		// Z Position. 
+	float	pm_ux;		// Uncertainty in x.
+	float	pm_uy;		// Uncertainty in y.
+	float	pm_uz;		// Uncertainty in z.
+} pmxyz;
+
+#define	PM_EBASE	100
+#define PM_EMALLOC	101
+#define PM_EBADPARAM	102
+#define PM_EBADPIC	103
+#define PM_EBADFORM	104
+#define PM_EBADMAGIC	105
+#define PM_ENULLPIC	106    // picture given was NULL
+#define PM_EBADPLANES   107  // invalid # of planes chosen for format
+#define PM_EBADBANDS 	108 // invalid # of bands chosen for format
+#define PM_EBADSIZE 	109 // # of rows/cols and x offsets, y offsets
+			   // too big for ikonas
+#define PM_EBADCOLORS 	110 // invalid number of colors chosen for format
+#define PM_EBADCOLORPLANE 111 // invalid color plane entered
+
+
+#define PM_NERROR	12
+#define PM_ERROR(e)	(((e) < PM_EBASE || (e) > (PM_EBASE + PM_NERROR)) ? \
+				0 : (e) - PM_EBASE)
+
+extern char	*pm_errmsg[];
+
+
+pmpic	*pm_add();
+pmpic	*pm_addcmt();
+pmpic	*pm_alloc();
+pmpic	*pm_and();
+pmpic	*pm_bthresh();
+pmpic	*pm_cast();
+char	*pm_cmt();
+pmpic	*pm_conv();
+pmpic	*pm_ebadform();
+int	pm_getcmt();
+pmpic	*pm_ikrd();
+pmpic	*pm_ikwr();
+pmpic	*pm_neg();
+pmpic	*pm_or();
+pmpic	*pm_prep();
+pmpic	*pm_rdhdr();
+pmpic	*pm_read();
+pmpic	*pm_scale();
+pmpic	*pm_sub();
+pmpic	*pm_thresh();
+pmpic	*pm_write();
+
+pmxyz	*pm_centroid();
+*/
+
+/*******************************************/
+int wxImage::LoadPM(char *fname, int nc)
+/*******************************************/
+{
+  FILE  *fp;
+  int    isize,i,flipit,w,h,rv;
+
+  rv = 0;
+  thePic.pm_image = NULL;
+
+  /* read in the PM picture */
+  fp=fopen(fname,"r");
+//  if (!fp) return( PMError("unable to open file") );
+  if (!fp) return 1;
+  
+  flipit = 0;
+  fread(&thePic,PM_IOHDR_SIZE,1,fp);
+  if (thePic.pm_id != PM_MAGICNO) {
+    flipl( (byte *) &thePic.pm_id);
+    if (thePic.pm_id == PM_MAGICNO) flipit = 1;
+    else flipl( (byte *) &thePic.pm_id);
+  }
+//  if (thePic.pm_id != PM_MAGICNO) return( PMError("not a PM file") );
+  if (thePic.pm_id != PM_MAGICNO) return 1;
+
+  if (flipit) {
+    flipl((byte *) &thePic.pm_np);      flipl((byte *) &thePic.pm_nrow);
+    flipl((byte *) &thePic.pm_ncol);    flipl((byte *) &thePic.pm_nband);
+    flipl((byte *) &thePic.pm_form);    flipl((byte *) &thePic.pm_cmtsize);
+    }
+          
+  /* make sure that the input picture can be dealt with */
+  if ( thePic.pm_nband!=1 || 
+      (thePic.pm_form!=PM_I && thePic.pm_form!=PM_C) ||
+      (thePic.pm_form==PM_I && thePic.pm_np>1) ||
+      (thePic.pm_form==PM_C && (thePic.pm_np==2 || thePic.pm_np>4)) ) {
+    fprintf(stderr,"PM picture not in a displayable format.\n");
+    fprintf(stderr,"(ie, 1-plane PM_I, or 1-, 3-, or 4-plane PM_C)\n");
+    return 1;
+    }	
+
+  w = thePic.pm_ncol;  h = thePic.pm_nrow;
+
+  isize = pm_isize(&thePic);
+
+  if (dEBUG) 
+    fprintf(stderr,"wxImage: LoadPM() - loading a %dx%d %s pic, %d planes\n",
+	    w, h, (thePic.pm_form==PM_I) ? "PM_I" : "PM_C", 
+	    thePic.pm_np);
+
+/*
+  SetISTR(ISTR_FORMAT,"PM, %s.  (%d plane %s)  (%d bytes)",
+	  (thePic.pm_form==PM_I || thePic.pm_np>1) ? 
+	     "24-bit color" : "8-bit greyscale",
+	  thePic.pm_np, (thePic.pm_form==PM_I) ? "PM_I" : "PM_C",
+	  isize + PM_IOHDR_SIZE + thePic.pm_cmtsize);
+*/
+
+  /* allocate memory for picture and read it in */
+  thePic.pm_image = (char *) malloc(isize);
+  if (thePic.pm_image == NULL)
+    return 1;
+//    return( PMError("unable to malloc PM picture") );
+
+  if (fread(thePic.pm_image, (unsigned) isize, 1, fp) != 1) 
+    return 1;
+//    return( PMError("file read error") );
+  if (fp!=stdin) fclose(fp);
+
+  if (dEBUG) fprintf(stderr,"loadpm 1\n");
+
+  /* convert PM picture to 'pic' (8 bit) format */
+  if (thePic.pm_form == PM_I) {
+    int  *intptr;
+    byte *pic24, *picptr;
+
+    if ((pic24 = (byte *) malloc(w*h*3))==NULL) 
+      return 1;
+//      return( PMError("unable to malloc 24-bit picture") );
+      
+    intptr = (int *) thePic.pm_image;
+    picptr = pic24;
+
+    if (flipit) {    /* if flipit, integer is RRGGBBAA instead of AABBGGRR */
+      for (i=w*h; i>0; i--, intptr++) {
+	*picptr++ = (*intptr>>24) & 0xff;
+	*picptr++ = (*intptr>>16) & 0xff;
+	*picptr++ = (*intptr>>8)  & 0xff;
+      }
+    }
+    else {
+      for (i=w*h; i>0; i--, intptr++) {
+	*picptr++ = (*intptr)     & 0xff;
+	*picptr++ = (*intptr>>8)  & 0xff;
+	*picptr++ = (*intptr>>16) & 0xff;
+      }
+    }
+
+    if (dEBUG) fprintf(stderr,"loadpm 2\n");
+
+    free(thePic.pm_image);
+    rv=Conv24to8(pic24,w,h,nc);
+    free(pic24);
+  }
+
+
+  else if (thePic.pm_form == PM_C && thePic.pm_np>1) {
+    byte *pic24, *picptr, *rptr, *gptr, *bptr;
+
+    if ((pic24 = (byte *) malloc(w*h*3))==NULL)
+      return 1;
+//      return( PMError("unable to malloc 24-bit picture") );
+
+    rptr = (byte *) thePic.pm_image;
+    gptr = rptr + w*h;
+    bptr = rptr + w*h*2;
+    picptr = pic24;
+    for (i=w*h; i>0; i--) {
+      *picptr++ = *rptr++;
+      *picptr++ = *gptr++;
+      *picptr++ = *bptr++;
+    }
+    free(thePic.pm_image);
+    rv=Conv24to8(pic24,w,h,nc);
+    free(pic24);
+  }
+  
+  else if (thePic.pm_form == PM_C && thePic.pm_np==1) {
+    /* don't have to convert, just point pic at thePic.pm_image */
+    pic = (byte *) thePic.pm_image;
+    pWIDE = w;  pHIGH = h;  
+    for (i=0; i<256; i++) r[i]=g[i]=b[i]=i;  /* and build mono colortable */
+    rv = 0;
+  }
+
+  return rv;
+}
+
+
+/*******************************************/
+int wxImage::WritePM(FILE *fp, byte *pic, int w, int h, byte *rmap, byte *gmap, byte *bmap, int numcols, int colorstyle)
+{
+  /* writes a PM file to the already open stream
+     'colorstyle' single-handedly determines the type of PM pic written
+     if colorstyle==0, (Full Color) a 3-plane PM_C pic is written
+     if colorstyle==1, (Greyscal) a 1-plane PM_C pic is written
+     if colorstyle==0, (B/W stipple) a 1-plane PM_C pic is written */
+
+  char  foo[256];
+  int   i;
+  byte *p;
+
+  /* create 'comment' field */
+  sprintf(foo,"created by wxImage\n");
+
+  /* fill in fields of a pmheader */
+  thePic.pm_id = PM_MAGICNO;
+  thePic.pm_np = (colorstyle==0) ? 3 : 1;
+  thePic.pm_ncol = w;
+  thePic.pm_nrow = h;
+  thePic.pm_nband = 1;
+  thePic.pm_form  = PM_C;
+  thePic.pm_cmtsize = strlen(foo);
+
+  if (fwrite(&thePic, PM_IOHDR_SIZE, 1, fp) != 1) return -1;
+
+  /* write the picture data */
+  if (colorstyle == 0) {         /* 24bit RGB, organized as 3 8bit planes */
+    for (i=0,p=pic; i<w*h; i++, p++)
+      putc(rmap[*p], fp);
+    for (i=0,p=pic; i<w*h; i++, p++)
+      putc(gmap[*p], fp);
+    for (i=0,p=pic; i<w*h; i++, p++)
+      putc(bmap[*p], fp);
+  }
+
+  else if (colorstyle == 1) {    /* GreyScale: 8 bits per pixel */
+    byte rgb[256];
+    for (i=0; i<numcols; i++) rgb[i] = MONO(rmap[i],gmap[i],bmap[i]);
+    for (i=0, p=pic; i<w*h; i++, p++)
+      putc(rgb[*p],fp);
+  }
+
+  else /* (colorstyle == 2) */ { /* B/W stipple.  pic is 1's and 0's */
+    for (i=0, p=pic; i<w*h; i++, p++)
+      putc(*p ? 255 : 0,fp);
+  }
+
+  if (fputs(foo,fp)==EOF) return -1;
+
+  return 0;
+}
+
+
+/*****************************/
+static void flipl(byte *p)
+{
+  byte t; 
+  t = p[0];  p[0]=p[3];  p[3] = t;
+  t = p[1];  p[1]=p[2];  p[2] = t;
+}
+
+
+
diff --git a/src/wxmac/utils/image/src/wx_xbm.cc b/src/wxmac/utils/image/src/wx_xbm.cc
new file mode 100644
index 0000000..65c632e
--- /dev/null
+++ b/src/wxmac/utils/image/src/wx_xbm.cc
@@ -0,0 +1,336 @@
+/*
+ * xvxbm.c - load routine for X11 Bitmap format pictures
+ *
+ * LoadXBM(fname)  -  loads an X11 Bitmap file\
+ * WriteXBM(fp, pic, w, h)
+ */
+
+/*
+ * Copyright 1989, 1990 by the University of Pennsylvania
+ *
+ * Permission to use, copy, and distribute for non-commercial purposes,
+ * is hereby granted without fee, providing that the above copyright
+ * notice appear in all copies and that both the copyright notice and this
+ * permission notice appear in supporting documentation.
+ *
+ * The software may be modified for your own purposes, but modified versions
+ * may not be distributed.
+ *
+ * This software is provided "as is" without any express or implied warranty.
+ */
+
+
+#include <stdlib.h>
+#include "wx_image.h"
+#include "wx_utils.h"
+
+/*
+ * File Format:
+ *   (format identifier:  "#define" as first couple chars in file)
+ *
+ * looks for first line beginning with '#define'
+ *   reads "#define identifier width"  (identifier is ignored)
+ * looks for next line beginning with '#define'
+ *   reads "#define identifier height" (identifier is ignored)
+ * looks for next occurence of characters '0x'
+ *   read next two chars as two hex digits
+ *   move forward to next occurence of '0x'
+ *   repeat
+ */
+ 
+#ifdef wx_mac
+// mflatt:
+// Like fgets, but it works on files with Unix linefeeds
+// Should for for DOS-style linefeeds as well, though returning extra
+//  empty lines
+static int GETLINE(char *b, int size, FILE *fp)
+{
+	int c = 0, pos = 0;
+	
+	while (c != '\r' && c != '\n' && pos < size) {
+		c = getc(fp);
+		if (c == EOF)
+		  break;
+		((unsigned char *)b)[pos++] = c;
+	}
+	if (pos < size)
+		b[pos] = 0;
+		
+	return pos;
+}
+#else
+#define GETLINE fgets
+#endif
+ 
+
+/*******************************************/
+int wxImage::LoadXBM(char *fname, int nc)
+/*******************************************/
+{
+  FILE  *fp;
+  int    c, c1;
+  int    i, j, k, bit, w, h;
+  byte  *pix;
+  long   filesize;
+  char   line[256];
+  byte   hex[256];
+
+  k = 0;
+
+  fp=fopen(fname,"r");
+  if (!fp) return 1;
+
+  /* figure out the file size (for Informational Purposes Only) */
+  fseek(fp, 0L, 2);
+  filesize = ftell(fp);
+  fseek(fp, 0L, 0);
+
+
+  /* read width:  skip lines until we hit a #define */
+  while (1) {
+    if (!GETLINE(line,256,fp)) 
+      return 1;
+//      return(XBMError("EOF reached in header info."));
+
+    if (strncmp(line,"#define",7)==0) {
+      if (sscanf(line,"#define %*s %d", &w) != 1) 
+        return 1;
+//	return(XBMError("Unable to read 'width'"));
+      else break;
+    }
+  }
+
+
+  /* read height:  skip lines until we hit another #define */
+  while (1) {
+    if (!GETLINE(line,256,fp)) 
+      return 1;
+//      return(XBMError("EOF reached in header info."));
+
+    if (strncmp(line,"#define",7)==0) {
+      if (sscanf(line,"#define %*s %d", &h) != 1) 
+        return 1;
+//	return(XBMError("Unable to read 'height'"));
+      else break;
+    }
+  }
+
+
+
+  /* scan forward until we see the first '0x' */
+  c = getc(fp);  c1 = getc(fp);
+  while (c1!=EOF && !(c=='0' && c1=='x') ) { c = c1;  c1 = getc(fp); }
+
+  if (c1==EOF) 
+    return 1;
+//    return(XBMError("No bitmap data found"));
+
+
+  /* load up the stuff XV expects us to load up */
+
+//  SetISTR(ISTR_FORMAT,"X11 Bitmap  (%ld bytes)", filesize);
+
+  pic = (byte *) calloc(w*h,1);
+  if (!pic) wxFatalError("couldn't malloc 'pic'");
+
+  pWIDE = w;  pHIGH = h;
+
+  /* B/W bitmaps have a two entry colormap */
+  r[0] = g[0] = b[0] = 255;     /* 0 = white */
+  r[1] = g[1] = b[1] = 0;       /* 1 = black */
+
+
+  /* initialize the 'hex' array for zippy ASCII-hex -> int conversion */
+
+  for (i=0; i<256; i++) hex[i]=0;
+  for (i='0'; i<='9'; i++) hex[i] = i - '0';
+  for (i='a'; i<='f'; i++) hex[i] = i + 10 - 'a';
+  for (i='A'; i<='F'; i++) hex[i] = i + 10 - 'A';
+
+  /* read/convert the image data */
+
+  for (i=0, pix=pic; i<h; i++)
+	for (j=0,bit=0; j<w; j++, pix++, bit = ++bit&7) {
+
+		if (!bit) {
+			/* get next byte from file.  we're already positioned at it */
+			c = getc(fp);  c1 = getc(fp);
+			if (c<0 || c1<0) { 
+	  		/* EOF: break out of loop */	  
+	  		c=c1='0'; i=h; j=w;
+			//	  XBMError("The file would appear to be truncated.");
+			}
+
+		k = (hex[c] << 4) + hex[c1];
+
+		/* advance to next '0x' */
+		c = getc(fp);  c1 = getc(fp);
+		while (c1!=EOF && !(c=='0' && c1=='x') ) 
+			{ c = c1;  c1 = getc(fp); }
+	}
+
+	*pix = (k&1) ? 1 : 0;
+	k = k >> 1;
+  }
+
+  fclose(fp);
+
+  return 0;
+}  
+
+
+
+/*******************************************/
+static int WriteXBM(FILE *fp, byte *pic, int w, int h, char *fname)
+{
+  /* pic is expected to be an array of w*h bytes.  '0' is considered 'black'
+     non-zero is considered white.  Some sort of stippling algorithm should've
+     been called already to produce pic, otherwise the output won't be at all
+     useful */
+
+  int   i,j,k,bit,len,nbytes;
+  byte *pix;
+  char name[256], *foo;
+
+  /* figure out a reasonable basename */
+  strcpy(name,fname);
+  foo = strchr(name,'.');
+  if (foo) *foo='\0';                 /* truncated name at first '.' */
+
+  fprintf(fp,"#define %s_width %d\n",name,w);  
+  fprintf(fp,"#define %s_height %d\n",name,h);
+  fprintf(fp,"static char %s_bits[] = {\n",name);
+
+  fprintf(fp," ");
+
+  nbytes = h * ((w+7)/8);   /* # of bytes to write */
+
+  for (i=0, len=1, pix=pic; i<h; i++) {
+    for (j=bit=k=0; j<w; j++,pix++) {
+      k = (k>>1);
+      if (*pix) k |= 0x80;
+      bit++;
+      if (bit==8) {
+	fprintf(fp,"0x%02x",(byte) ~k);
+	nbytes--;  len += 4;
+	if (nbytes) { fprintf(fp,",");  len++; }
+	if (len>72) { fprintf(fp,"\n ");  len=1; }
+	bit = k = 0;
+      }
+    }
+
+    if (bit) {
+      k = k >> (8-bit);
+      fprintf(fp,"0x%02x",(byte) ~k);
+      nbytes--;  len += 4;
+      if (nbytes) { fprintf(fp,",");  len++; }
+      if (len>72) { fprintf(fp,"\n ");  len=1; }
+    }
+  }
+
+  fprintf(fp,"};\n");
+
+  if (ferror(fp)) return -1;
+  return 0;
+}
+
+#ifdef wx_mac
+// Create an Image, create a bitMap (Gworld for the data), copy the image to the
+// bitmap, delete the image
+Bool wxLoadXBMIntoBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+	CGrafPtr  colorPort;
+	
+	wxImage *xbmImage  = new wxImage();
+	if (xbmImage->LoadXBM(fileName, 1) == 0) {
+		// CreateOffScreenPixMap(&colorPort, gifImage);
+		Rect bounds = {0, 0, xbmImage->pHIGH, xbmImage->pWIDE};
+		GDHandle savegw;
+		CGrafPtr saveport;
+		GetGWorld(&saveport, &savegw);
+		QDErr err;
+		GWorldPtr	newGWorld;
+		err = NewGWorld(&newGWorld, 0, &bounds, NULL, NULL, noNewDevice);
+		if (err) {
+			bm->SetOk(FALSE);
+			return FALSE;
+		}
+		SetGWorld(newGWorld, 0);
+		bm->x_pixmap = newGWorld;
+
+		RGBColor	cpix;
+		int i, j, k;
+		unsigned int byte;
+		unsigned char *buf = xbmImage->pic;
+ 		GetForeColor(&cpix);	// probably 0,0,0
+ 		::EraseRect(&bounds);
+		for (i = 0; i < xbmImage->pHIGH; i++) {
+			for (j = 0; j < xbmImage->pWIDE; j++) {
+				if (*buf++) {
+					::SetCPixel(j, i, &cpix);
+				}
+			}
+		}
+		SetGWorld(saveport, savegw);
+			
+		//  bm->pixmap = colorPort->portPixMap;
+		bm->SetWidth(xbmImage->pWIDE);
+		bm->SetHeight(xbmImage->pHIGH);
+		bm->SetDepth(1);
+		bm->SetOk(TRUE);
+  		SetGWorld(saveport, savegw);
+  		XpmFree (xbmImage->pic);
+		delete xbmImage;
+		return TRUE;
+	}
+	else {
+		bm->SetOk(FALSE);
+		return FALSE;
+	}
+}
+
+// Create an Image, create a bitMap (Gworld for the data), copy the image to the
+// bitmap, delete the image
+Bool wxSaveXBMFromBitmap(char *fileName, wxBitmap *bm, wxColourMap **pal)
+{
+	CGrafPtr  colorPort;
+	FILE *f;
+	int w, h, i, j;
+	byte *pic, *p;
+	
+	if (!bm->Ok())
+	  return 0;
+	
+	w = bm->GetWidth();
+	h = bm->GetHeight();
+	
+	pic = new byte[w * h];
+	
+	if (!pic)
+	  return 0;
+	
+	GDHandle savegw;
+	CGrafPtr saveport;
+	GetGWorld(&saveport, &savegw);
+	
+	SetGWorld(bm->x_pixmap, 0);
+			
+	for (i = 0, p = pic; i < h; i++)
+	  for (j = 0; j < w; j++, p++) {
+	    RGBColor cpix;
+	    ::GetCPixel(j, i, &cpix);
+	    *p = (cpix.red || cpix.blue || cpix.green);
+	  }
+	
+	SetGWorld(saveport, savegw);
+	
+	if (!(f = fopen(fileName, "w")))
+	  return FALSE;
+	
+	int success = WriteXBM(f, pic, w, h, fileName);
+	
+	fclose(f);
+	
+	return success;
+}
+#endif
diff --git a/src/wxmac/welcome.txt b/src/wxmac/welcome.txt
new file mode 100644
index 0000000..4ebf0f2
--- /dev/null
+++ b/src/wxmac/welcome.txt
@@ -0,0 +1,59 @@
+Welcome to wxWindows Version 1.60
+
+
+Hello, and welcome to wxWindows, a portable GUI
+toolkit for X and Windows 3.1.
+
+This program demonstrates the following features:
+
+*   Main frame window with menu bar
+
+*   Panel with various widgets
+
+*   Status line with help on menu items
+
+*   Scrolling text window with this file loaded
+
+*   Scrolling canvas with text and graphics displayed
+    (use the mouse and left button to doodle)
+
+*   Icon and cursor setting
+
+*   Canvas scaling
+
+*   Printing (Windows printing on PC, PostScript under UNIX)
+
+*   Copying a metafile to the clipboard (Windows only)
+
+*   Timer (prints to this text window occasionally)
+
+Other wxWindows features include:
+
+*   Interprocess communication (DDE on both platforms)
+
+*   File browser dialog box
+
+*   Form construction facility
+
+wxWindows provides a common core of GUI facilities across several
+platforms (two at present). XView programmers will be familiar with
+the frame/subwindow principles, whilst appreciating the simpler and
+object-oriented interface. Windows programmers should also find it
+much simpler than the native API. Motif programmers should never again
+have to experiment to avoid constraint contradictions. And,
+synchronous interprocess communications are now a doddle on all
+supported platforms.
+
+This software is available free of charge from:
+
+Dr Julian Smart
+Artificial Intelligence Applications Institute
+University of Edinburgh
+80, South Bridge
+Edinburgh
+EH1 1HN
+
+Email J.Smart@ed.ac.uk
+
+Please feel free to send me suggestions - and code - for the next
+release.
diff --git a/src/wxmac/wxDebugHeaders.pch b/src/wxmac/wxDebugHeaders.pch
new file mode 100644
index 0000000..21e8ce0
--- /dev/null
+++ b/src/wxmac/wxDebugHeaders.pch
@@ -0,0 +1,23 @@
+/*
+	Define a target and include all the includes and predefines
+	except the CW complains about iostream if you include "wx.h"
+*/
+/*
+ *	Support for automatically naming the precompiled header file ...
+ */
+
+#ifdef powerc
+  #pragma precompile_target "wxDebugHeadersPPC"
+#else
+  #pragma precompile_target "wxDebugHeaders68K"
+#endif
+#define macintosh
+#define GUSI
+#include <GUSI_p.h>
+#include <GUSI.h>
+#define FOR_MAC	// needed for wxxpm
+
+#define DEBUGLOG
+// #define DEBUG	2
+#define DEBUG_NEW 2
+#include <DebugNew.h>
diff --git a/src/wxwindow/contrib/contrib.txt b/src/wxwindow/contrib/contrib.txt
new file mode 100644
index 0000000..f33399f
--- /dev/null
+++ b/src/wxwindow/contrib/contrib.txt
@@ -0,0 +1,31 @@
+
+wxWindows Contrib directory
+---------------------------
+
+These files are contributed.
+
+misc/borproj.zip    Borland project files: out of date.
+
+misc/fixmake.sh     Fixes makefiles.
+
+misc/linuxshr.zip   Linux shared library notes.
+
+ctl3d               CTL3DV2.DLL and header.
+
+fafa                FAFA extensions for Windows controls (compiled as
+                    standard).
+
+gauge               Microsoft gauge code, compiled as standard.
+
+itsybits            Microsoft small title bar code, compiled as standard.
+
+wxxpm               wxXPM: an XPM library for Windows and UNIX. XPM is
+                    the standard X colour pixmap format. The code was
+                    originally written by Bull and modified for wxWindows
+                    by Hermann Dunkel. Compiled as standard.
+
+wxstring            Stefan Hammes' port of GNU String and Regex classes.
+                    Optional in wxWindows (see wx_setup.h) but this wxString
+                    is a superset of the standard wxWindows version.
+
+xmgauge             Free Motif gauge implementation, compiled as standard.
diff --git a/src/wxwindow/contrib/ctl3d/ctl3d.dll b/src/wxwindow/contrib/ctl3d/ctl3d.dll
new file mode 100644
index 0000000..27be82b
Binary files /dev/null and b/src/wxwindow/contrib/ctl3d/ctl3d.dll differ
diff --git a/src/wxwindow/contrib/ctl3d/ctl3d.h b/src/wxwindow/contrib/ctl3d/ctl3d.h
new file mode 100644
index 0000000..0108f47
--- /dev/null
+++ b/src/wxwindow/contrib/ctl3d/ctl3d.h
@@ -0,0 +1,61 @@
+/*-----------------------------------------------------------------------
+|	CTL3D.DLL
+|	
+|	Adds 3d effects to Windows controls
+|
+|	See ctl3d.doc for info
+|		
+-----------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+BOOL WINAPI Ctl3dSubclassDlg(HWND, WORD);
+BOOL WINAPI Ctl3dSubclassDlgEx(HWND, DWORD);
+WORD WINAPI Ctl3dGetVer(void);
+BOOL WINAPI Ctl3dEnabled(void);
+HBRUSH WINAPI Ctl3dCtlColor(HDC, LONG);	// ARCHAIC, use Ctl3dCtlColorEx
+HBRUSH WINAPI Ctl3dCtlColorEx(UINT wm, WPARAM wParam, LPARAM lParam);
+BOOL WINAPI Ctl3dColorChange(void);
+BOOL WINAPI Ctl3dSubclassCtl(HWND);
+LONG WINAPI Ctl3dDlgFramePaint(HWND, UINT, WPARAM, LPARAM);
+
+BOOL WINAPI Ctl3dAutoSubclass(HANDLE);
+
+BOOL WINAPI Ctl3dRegister(HANDLE);
+BOOL WINAPI Ctl3dUnregister(HANDLE);
+
+//begin DBCS: far east short cut key support
+VOID WINAPI Ctl3dWinIniChange(void);
+//end DBCS
+
+
+/* Ctl3dSubclassDlg3d flags */
+#define CTL3D_BUTTONS		0x0001
+#define CTL3D_LISTBOXES		0x0002		
+#define CTL3D_EDITS			0x0004	
+#define CTL3D_COMBOS			0x0008		
+#define CTL3D_STATICTEXTS	0x0010		
+#define CTL3D_STATICFRAMES	0x0020
+
+#define CTL3D_NODLGWINDOW       0x00010000
+#define CTL3D_ALL				0xffff
+
+#define WM_DLGBORDER (WM_USER+3567)
+/* WM_DLGBORDER *(int FAR *)lParam return codes */
+#define CTL3D_NOBORDER		0
+#define CTL3D_BORDER			1
+
+#define WM_DLGSUBCLASS (WM_USER+3568)
+/* WM_DLGSUBCLASS *(int FAR *)lParam return codes */
+#define CTL3D_NOSUBCLASS	0
+#define CTL3D_SUBCLASS		1
+
+/* Resource ID for 3dcheck.bmp (for .lib version of ctl3d) */
+#define CTL3D_3DCHECK 26567
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/wxwindow/contrib/ctl3d/ctl3d.lib b/src/wxwindow/contrib/ctl3d/ctl3d.lib
new file mode 100644
index 0000000..2ba89d6
Binary files /dev/null and b/src/wxwindow/contrib/ctl3d/ctl3d.lib differ
diff --git a/src/wxwindow/contrib/ctl3d/ctl3d32.zip b/src/wxwindow/contrib/ctl3d/ctl3d32.zip
new file mode 100644
index 0000000..ae1e90b
Binary files /dev/null and b/src/wxwindow/contrib/ctl3d/ctl3d32.zip differ
diff --git a/src/wxwindow/contrib/ctl3d/ctl3dv2.dll b/src/wxwindow/contrib/ctl3d/ctl3dv2.dll
new file mode 100644
index 0000000..4c85383
Binary files /dev/null and b/src/wxwindow/contrib/ctl3d/ctl3dv2.dll differ
diff --git a/src/wxwindow/contrib/ctl3d/ctl3dv2.lib b/src/wxwindow/contrib/ctl3d/ctl3dv2.lib
new file mode 100644
index 0000000..9d40989
Binary files /dev/null and b/src/wxwindow/contrib/ctl3d/ctl3dv2.lib differ
diff --git a/src/wxwindow/contrib/ctl3d/makefile.wat b/src/wxwindow/contrib/ctl3d/makefile.wat
new file mode 100644
index 0000000..a76136a
--- /dev/null
+++ b/src/wxwindow/contrib/ctl3d/makefile.wat
@@ -0,0 +1,23 @@
+CC	= wcc386
+CXX	= wpp386
+LIB     = wlib
+IFLAGS  = -i=..\\..\\include\\base;..\\..\\include\\msw
+CFLAGS  = $(IFLAGS) -zq -zW -w1 -os -3 -dwx_msw
+
+WXDIR   = ..\\..
+LIBTARGET = $(WXDIR)\\lib\\wx.lib
+
+C_SRCS = ctl3d32.c
+
+OBJECTS = $(C_SRCS:.c=.obj) $(CC_SRCS:.cc=.obj)
+
+.c.obj:
+	$(CC) $(CFLAGS) $<
+
+.cc.obj:
+	$(CXX) $(CFLAGS) $< 
+
+all: $(OBJECTS) $(LIBTARGET)
+
+$(LIBTARGET): $(OBJECTS)
+	$(LIB) /P=256 $(LIBTARGET) @ctl3d32.lnk
diff --git a/src/wxwindow/contrib/ctl3d/readme.txt b/src/wxwindow/contrib/ctl3d/readme.txt
new file mode 100644
index 0000000..614b4fe
--- /dev/null
+++ b/src/wxwindow/contrib/ctl3d/readme.txt
@@ -0,0 +1,27 @@
+
+CTL3D
+-----
+
+CTL3D gives 3D controls to 16-bit Windows 3.1 applications.
+Its use in wxWindows is controlled by the CTL3D symbol
+in include/base/wx_setup.h.
+
+If using a 16-bit compiler, copy ctl3dv2.lib to your compiler
+library directory, and remember to distribute ctl3dv2.dll
+with your applications. The DLL should be copied to
+windows/system and DELETED from the application installation
+directory.
+
+If using Watcom C++ in 386 mode, things are slightly more complex: you need
+to link with Patrick Halke's ctl3d32.obj which provides an interface
+from 32-bits to the 16-bit CTL3DV2 library. Link your application
+with ctl3d32.obj file instead of ctl3dv2.lib, distributing
+ctl3dv2.dll as above.
+
+ctl3d.dll       ; Version 1 of the CTL3D library DLL: obsolete
+ctl3dv2.dll     ; Version 2 of the CTL3D library DLL
+ctl3d.h         ; Header file for either version of CTL3D
+ctl3d.lib       ; Import library for 16-bit compilers
+ctl3d32.obj     ; Watcom 386 object file to interface 16<->32 bit modes
+ctl3d32.zip     ; Source for Watcom 386 16<->32 bit modes interface
+
diff --git a/src/wxwindow/contrib/fafa/UUfafa.ico b/src/wxwindow/contrib/fafa/UUfafa.ico
new file mode 100644
index 0000000..cf4357e
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/UUfafa.ico
@@ -0,0 +1,21 @@
+begin 664 fafa.ico
+M   !  $ (" 0      #H @  %@   "@    @    0     $ !       @ ( 
+M                              "   "     @(  @    (  @ " @   
+M@("  ,# P    /\  /\   #__P#_    _P#_ /__  #___\ ____________
+M____________________________________________________________
+M____________________________________\/__#___#_#__P___P____#_
+M__#_\/_P___P__#____P /_P  #_\ #_\   ____\/___P\/__#___\/#___
+M__#___\ #__P____  _____P  __\/__\  /__#_____________________
+M____________________________________________________________
+M___________P   (^/__CW    _______P 'CX^(^/<    /_______P"(^/
+MB/AP    #_______\(_X__^'      O[_[N[N[OXCX^[N[N[   +N[^[N[N[
+MO__X_____P  "[N[N[N[N[__^(N[N[L   N[N____[^[CXAP____   +N[O_
+M______B' +N[NP  #__________X<    /\   ___________P    ______
+M___________P   /__  ____________\   __\   ____________\  /__
+M\ #_____________\ ____________________ /____________________
+M__________\                                                 
+M                                                            
+M                                                            
+!    
+ 
+end
diff --git a/src/wxwindow/contrib/fafa/bit9000.bmp b/src/wxwindow/contrib/fafa/bit9000.bmp
new file mode 100644
index 0000000..70bd0ff
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9000.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9001.bmp b/src/wxwindow/contrib/fafa/bit9001.bmp
new file mode 100644
index 0000000..5e598c9
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9001.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9002.bmp b/src/wxwindow/contrib/fafa/bit9002.bmp
new file mode 100644
index 0000000..9a56627
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9002.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9003.bmp b/src/wxwindow/contrib/fafa/bit9003.bmp
new file mode 100644
index 0000000..661ba07
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9003.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9004.bmp b/src/wxwindow/contrib/fafa/bit9004.bmp
new file mode 100644
index 0000000..8988803
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9004.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9005.bmp b/src/wxwindow/contrib/fafa/bit9005.bmp
new file mode 100644
index 0000000..45a4e11
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9005.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9006.bmp b/src/wxwindow/contrib/fafa/bit9006.bmp
new file mode 100644
index 0000000..92a8480
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9006.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9007.bmp b/src/wxwindow/contrib/fafa/bit9007.bmp
new file mode 100644
index 0000000..6a2ea9a
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9007.bmp differ
diff --git a/src/wxwindow/contrib/fafa/bit9100.bmp b/src/wxwindow/contrib/fafa/bit9100.bmp
new file mode 100644
index 0000000..8859e1b
Binary files /dev/null and b/src/wxwindow/contrib/fafa/bit9100.bmp differ
diff --git a/src/wxwindow/contrib/fafa/button.c b/src/wxwindow/contrib/fafa/button.c
new file mode 100644
index 0000000..a9f640c
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/button.c
@@ -0,0 +1,531 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Fonction fenetre de gestion des types Boutons			|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+
+/*
+|-----------------------------------------------------------------------|
+| define	 :
+|-----------------------------------------------------------------------|
+*/
+
+#define	MARGE_FOCUS	-6
+
+/*
+|-----------------------------------------------------------------------|
+| prototypes :
+|-----------------------------------------------------------------------|
+*/
+
+static	LPSTR	GetBtmTxtParams( LPSTR t, int * b ) ;
+
+static	void	ButtonKeyDown( HWND w, int down ) ;
+static	void	MakeAccDown( HWND w ) ;
+
+static	void	MouseDown( HWND w ) ;
+static	void	MouseMove( HWND w, DWORD l ) ;
+static	void	MouseUp( HWND w, DWORD l, int but ) ;
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoopFafaButton :
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI	LoopFafaButton( HWND w, UINT msg, WPARAM mw, LPARAM ml )
+{
+HDC	h ;
+
+	switch( msg )
+		{
+		case WM_SYSCOLORCHANGE:
+			CreatePensBrushes() ;
+			break ;
+		case WM_CREATE :
+			InitButtonWords( w ) ;
+			break ;
+
+		case WM_SETFONT:
+		{
+			HFONT f = (HFONT)mw ;
+			SetFont(f) ;
+		        h = GetDC( w ) ;
+			DrawFafaButton(w,h) ;
+		        ReleaseDC( w, h ) ;
+			break ;
+		}
+		case WM_CHANGEBITMAP:
+		{
+			HBITMAP f = (HBITMAP)ml ;
+			WORD width = LOBYTE(mw) ;
+			WORD height = HIBYTE(mw) ;
+			LONG style = GetStyle() ;
+
+			if (width == 255) {
+		           SIZE s;
+			   GetBitmapDimensionEx(f, &s);
+			   width = s.cx;
+			   height = s.cy;
+			}
+			
+			SetBitmap(f) ;
+			SetBitmapW(width) ;
+			SetBitmapH(height) ;
+
+			if (f)
+			{
+				/* Switch to Bitmap button */
+				style &= 0xfffffff0 ;
+				style |= FB_BITMAP ;
+			}
+			else
+			{
+				/* Switch to Text button */
+				style &= 0xfffffff0 ;
+				style |= FB_TEXT ;
+			}
+			SetStyle(style) ;
+		        h = GetDC( w ) ;
+			DrawFafaButton(w,h) ;
+		        ReleaseDC( w, h ) ;
+			break ;
+		}
+		case WM_GETFONT:
+			return (LRESULT)GetFont() ;
+		case WM_PAINT :
+			RedrawFafaButton( w ) ;
+			break ;
+
+		case WM_ENABLE:
+			if ( ( mw != 0 ) ^ IsDisabled() )
+				InvalidateRect( w, 0, 0 ) ;
+			break ;
+
+		case WM_SETFOCUS:
+			ChangeButtonFocus( w, 1 ) ;
+			if ( GetAcc() && KeyIsDown( GetAcc() ) )
+				MakeAccDown( w ) ;
+			break ;
+
+		case WM_KILLFOCUS:
+			ChangeButtonFocus( w, 0 ) ;
+			break ;
+
+		case WM_RBUTTONDBLCLK:
+			if ( ! TstF( GetStyle(), FB_RIGHTBUT ) )
+				break ;
+		case WM_LBUTTONDBLCLK:
+		{
+		WORD	id ;
+		HWND	hwnd ;
+		WORD	cmd ;
+		LPARAM	lparam ;
+		WPARAM	wparam ;
+
+			id = GetDlgCtrlID(w) ;
+			hwnd = w ;
+			cmd = BN_CLICKED ;
+#ifdef WIN32
+			lparam = (LPARAM)hwnd ;
+			wparam = MAKEWPARAM(id,cmd) ;
+#else
+			wparam = (WPARAM)id ;
+			lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+			if ( ! TstF( GetStyle(), FB_DBLCLKS ) )
+				SendMessage( GetParent( w ), WM_COMMAND,
+					     wparam,lparam) ;
+			break ;
+		}
+		case WM_RBUTTONDOWN:
+			if ( ! TstF( GetStyle(), FB_RIGHTBUT ) )
+				break ;
+
+		case WM_LBUTTONDOWN:
+			SetFocus( w ) ;
+			MouseDown( w ) ;
+			break ;
+
+		case WM_MOUSEMOVE:
+			MouseMove( w, ml ) ;
+			break ;
+
+		case WM_RBUTTONUP:
+			if ( ! TstF( GetStyle(), FB_RIGHTBUT ) )
+				break ;
+
+		case WM_LBUTTONUP:
+			MouseUp( w, ml, ( msg == WM_RBUTTONUP ) ) ;
+			break ;
+
+		case WM_KEYDOWN:
+		case WM_SYSKEYDOWN:
+			if ( mw == ' ' )
+				ButtonKeyDown( w, 1 ) ;
+			else if ( KeyIsAcc( w, mw ) )
+				MakeAccDown( w ) ;
+			else	return DefWindowProc( w, msg, mw, ml ) ;
+			break ;
+
+		case WM_KEYUP:
+		case WM_SYSKEYUP:
+			if ( mw == ' ' )
+				ButtonKeyDown( w, 0 ) ;
+			else	return DefWindowProc( w, msg, mw, ml ) ;
+			break;
+
+		case WM_ERASEBKGND :
+			break ;
+
+		case WM_WHOAREYOU :
+			return ( LONG ) FB_BUTTON ;
+
+		case WM_SETTEXT :
+			InvalidateRect( w, 0, 0 ) ;
+		default:
+			return DefWindowProc( w, msg, mw, ml ) ;
+		}
+	return 0 ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc initButtonWords : initialise state et Acc			|
+|-----------------------------------------------------------------------|
+*/
+
+void	InitButtonWords( HWND w )
+{
+	char	tmp[ CTLTITLE + 1 ] ;
+	int	i, l ;
+
+	ClrState( 0xff ) ;
+	SetAcc( 0 ) ;
+	SetFont(0) ;
+	SetBitmap(0) ;
+	SetBitmapW(0) ;
+	SetBitmapH(0) ;
+	l = GetWindowText( w, tmp, sizeof tmp ) ;
+
+	for ( i = 0 ; i < l ; i ++ )
+		if ( tmp[ i ] == '&' )
+			{
+#ifdef WIN32
+			SetAcc( VkKeyScan( ( TCHAR ) tmp[ i + 1 ] ) & 0xff ) ;
+#else
+			SetAcc( VkKeyScan( ( UINT ) tmp[ i + 1 ] ) & 0xff ) ;
+#endif
+			return ;
+			}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc RedrawFafaButton :
+|-----------------------------------------------------------------------|
+*/
+
+void	RedrawFafaButton( HWND w )
+{
+	HDC		h ;
+	PAINTSTRUCT	p ;
+
+	h = BeginPaint( w, & p ) ;
+	DrawFafaButton(w,h) ;
+	EndPaint( w, & p ) ;
+
+}
+
+void DrawFafaButton(HWND w, HDC h)
+{
+	RECT		r ;
+	int		s, v ;
+	char		tmp[ CTLTITLE + 1 ] ;
+	HFONT		fnt,was;
+	HBITMAP		bmp ;
+	WORD		width,height ;
+
+	fnt = GetFont() ;
+	GetClientRect( w, & r ) ;
+	GetWindowText( w, tmp, sizeof tmp ) ;
+
+	if (fnt)
+		was = SelectObject(h,fnt) ;
+
+	s = TstState( FB_SELECTED ) ;
+	v = BtStyle( GetStyle() ) ;
+	
+	switch( v )
+		{
+		case FB_TEXT:
+			DrawPodium( h, & r, s ) ;
+			DrawString( h, & r, tmp, s ) ;
+			break ;
+		case FB_BITMAP:
+			bmp = GetBitmap() ;
+			width = GetBitmapW() ;
+			height = GetBitmapH() ;
+			DrawPodium( h, & r, s ) ;
+			if (bmp==0)
+				DrawBitmap( h, & r, MyAtoi( tmp ), s ) ;
+			else
+				DrawBitmapLoaded( h, & r, bmp,width,height, s ) ;
+			break ;
+		case FB_BTMTXT_H:
+		case FB_BTMTXT_V:
+			{
+			char *	t ;
+			int		b ;
+
+			t = GetBtmTxtParams( tmp, & b ) ;
+			DrawBtmTxtHV( h, &r, b, t, s, ( v == FB_BTMTXT_V ) ) ;
+			}
+			break ;
+		case FB_MAC :
+			DrawMac( h, & r, tmp, s ) ;
+			break ;
+		case FB_DBLBTM:
+			DrawPodium( h, & r, s ) ;
+			DrawBitmap( h, & r, MyAtoi( tmp ) + s, s ) ;
+		}
+
+	if ( IsDisabled() )
+		DrawButtonDisable( h, & r, 1 ) ;
+	else if ( TstState( FB_FOCUS ) )
+		DrawButtonFocus( h, & r, s ) ;
+	if (fnt)
+		SelectObject(h,was) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc ChangeButtonFocus :	
+|-----------------------------------------------------------------------|
+*/
+
+void	ChangeButtonFocus( HWND w, int on )
+{
+	if ( ( on != 0 ) ^ TstF( GetState(), FB_FOCUS ) )
+		{
+		HDC	h ;
+		RECT	r ;
+
+		if ( ! on )
+			{
+			int	s = TstState( FB_SELECTED ) ;
+
+			ClrState(FB_SELECTED|FB_CAPTURING|FB_KEYDOWN|FB_FOCUS) ;
+			if ( s )
+				{
+				InvalidateRect( w, 0, 0 ) ;
+				return ;
+				}
+			}
+		else	SetState( FB_FOCUS ) ;
+
+		h = GetDC( w ) ;
+		GetClientRect( w, & r ) ;
+
+		DrawButtonFocus( h, & r, 0 ) ;
+		ReleaseDC( w, h ) ;
+		}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc GetBtmTxtParams :
+|-----------------------------------------------------------------------|
+*/
+
+static	LPSTR	GetBtmTxtParams( LPSTR t, int * b )
+{
+	* b = MyAtoi( t ) ;
+	while ( * t != ';' && * t != '\0' )
+		t ++ ;
+	return ( * t == '\0' ) ? t : ++ t ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc MyAtoi :
+|-----------------------------------------------------------------------|
+*/
+
+UINT	MyAtoi( LPSTR s )
+{
+	UINT	r = 0u ;
+
+	while ( * s >= '0' && * s <= '9' )
+		r = r * 10u + ( UINT )( * s ++ ) - '0' ;
+	return r ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc ButtonKeyDown : 							|
+|-----------------------------------------------------------------------|
+*/
+
+static	void	ButtonKeyDown( HWND w, int down )
+{
+	if ( ! TstState( FB_CAPTURING ) )
+		if ( down && ! TstState( FB_KEYDOWN ) )
+			{
+			SetCapture( w ) ;
+			SetState( FB_SELECTED | FB_KEYDOWN ) ;
+			InvalidateRect( w, 0, 1 ) ;
+			}
+		else if ( ( ! down ) && TstState( FB_KEYDOWN ) )
+			{
+			WORD	id ;
+			HWND	hwnd ;
+			WORD	cmd ;
+			LPARAM	lparam ;
+			WPARAM	wparam ;
+
+			ReleaseCapture() ;
+			ClrState( FB_SELECTED | FB_KEYDOWN ) ;
+			InvalidateRect( w, 0, 1 ) ;
+
+			id = GetDlgCtrlID(w) ;
+			hwnd = w ;
+			cmd = BN_CLICKED ;
+#ifdef WIN32
+			lparam = (LPARAM)hwnd ;
+			wparam = MAKEWPARAM(id,cmd) ;
+#else
+			wparam = (WPARAM)id ;
+			lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+			SendMessage( GetParent( w ), WM_COMMAND,
+				     wparam,lparam) ;
+			}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc MakeAccDown :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	MakeAccDown( HWND w )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	SetState( FB_SELECTED ) ;
+	InvalidateRect( w, 0, 0 ) ;
+
+	SendMessage( GetParent( w ), WM_COMMAND, wparam,lparam) ;
+
+	ClrState( FB_SELECTED ) ;
+	InvalidateRect( w, 0, 0 ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc Mouse controls :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	MouseDown( HWND w )
+{
+	if ( ! TstState( FB_KEYDOWN ) )
+		{
+		SetCapture( w ) ;
+		SetState( FB_CAPTURING | FB_SELECTED ) ;
+		InvalidateRect( w, 0, 0 ) ;
+		}
+}
+
+static	void	MouseMove( HWND w, DWORD l )
+{
+	if ( TstState( FB_CAPTURING ) )
+		{
+		RECT	r ;
+
+		GetClientRect( w, & r ) ;
+
+		if ( XyInRect( LOWORD( l ), HIWORD( l ), r ) )
+			{
+			if ( ! TstState( FB_SELECTED ) )
+				{
+				SetState( FB_SELECTED ) ;
+				InvalidateRect( w, 0, 0 ) ;
+				}
+			}
+		else if ( TstState( FB_SELECTED ) )
+			{
+			ClrState( FB_SELECTED ) ;
+			InvalidateRect( w, 0, 0 ) ;
+			}
+		}
+}
+
+static	void	MouseUp( HWND w, DWORD l, int but )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( TstState( FB_CAPTURING ) )
+		{
+		RECT	r ;
+
+		ReleaseCapture() ;
+		ClrState( FB_CAPTURING ) ;
+
+		if ( TstState( FB_SELECTED ) )
+			{
+			ClrState( FB_SELECTED ) ;
+			InvalidateRect( w, 0, 0 ) ;
+			}
+
+		GetClientRect( w, & r ) ;
+		if ( XyInRect( LOWORD( l ), HIWORD( l ), r ) )
+			SendMessage(
+				GetParent( w ),
+				WM_COMMAND,
+				wparam,
+				lparam) ;
+		}
+}
+
diff --git a/src/wxwindow/contrib/fafa/check.c b/src/wxwindow/contrib/fafa/check.c
new file mode 100644
index 0000000..338f772
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/check.c
@@ -0,0 +1,541 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Fonction fenetre de gestion des types Check Boutons		|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include "fafapriv.h"
+
+#include "stdio.h"
+#include "stdarg.h"
+#include "string.h"
+
+#ifdef DEBUG_FAFA
+void MyDebugMsg(char *fmt , ...)
+{
+  va_list ap;
+  static char buffer[512];
+
+  va_start(ap, fmt);
+
+  wvsprintf(buffer,fmt,ap) ;
+  OutputDebugString(buffer) ;
+
+  va_end(ap);
+}
+#endif
+
+/*
+|-----------------------------------------------------------------------|
+| defines	 :
+|-----------------------------------------------------------------------|
+*/
+
+#define	OFFSET_TEXT	20
+#define	MARGE		2
+#define	SIZE_BMP	14
+
+/*
+|-----------------------------------------------------------------------|
+| prototypes								|
+|-----------------------------------------------------------------------|
+*/
+
+static	void	ChangeCheckFocus( HWND w, int on ) ;
+static	int	ChangeCheckSelect( HWND w, int s ) ;
+
+static	void	RedrawFafaCheck( HWND w ) ;
+static	void	DrawFafaCheck( HWND w , HDC h) ;
+static	void	DrawCheck( HDC h, RECT * r, int n, LPSTR s ) ;
+static	void	DrawCheckFocus( HDC h, RECT * r, LPSTR s ) ;
+static	void	CheckKeyDown( HWND w, int down ) ;
+
+static	void	MouseDown( HWND w ) ;
+static	void	MouseMove( HWND w, DWORD l ) ;
+static	void	MouseUp( HWND w, DWORD l ) ;
+
+static	void	MakeRadioIteration( HWND w1 ) ;
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoopFafaCheck :
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI LoopFafaCheck( HWND w, UINT msg, WPARAM mw, LPARAM ml )
+{
+HDC	h ;
+
+	switch( msg )
+		{
+		case WM_SYSCOLORCHANGE:
+			CreatePensBrushes() ;
+			break ;
+		case WM_CREATE :
+			InitButtonWords( w ) ;
+			if ( TstF( GetStyle(), FC_PRESELECT ) )
+				SetState( (WORD)FB_SELECTED ) ;
+			break ;
+
+		case WM_SETFONT:
+		{
+			HFONT f = (HFONT)mw ;
+			SetFont(f) ;
+		        h = GetDC( w ) ;
+			if ( TstF( GetStyle(), FC_BUTTONDRAW ) )
+				DrawFafaButton( w ,h ) ;
+			else	DrawFafaCheck( w ,h ) ;
+		        ReleaseDC( w, h ) ;
+			break ;
+		}
+		case WM_CHANGEBITMAP:
+		{
+			HBITMAP f = (HBITMAP)ml ;
+			WORD width = LOBYTE(mw) ;
+			WORD height = HIBYTE(mw) ;
+			LONG style = GetStyle() ;
+			
+			if (width == 255) {
+		           SIZE s;
+			   GetBitmapDimensionEx(f, &s);
+			   width = s.cx;
+			   height = s.cy;
+			}
+			
+			SetBitmap(f) ;
+			SetBitmapW(width) ;
+			SetBitmapH(height) ;
+
+			if (f)
+			{
+				/* Switch to Bitmap button */
+				style &= 0xffffff70 ;
+				style |= (FC_BUTTONDRAW|FB_BITMAP) ;
+			}
+			else
+			{
+				/* Switch to Text button */
+				style &= 0xffffff70 ;
+				/* default text style for check items */
+				if (style&FC_RADIO)
+					style |= FC_CIR_DWN ;
+				else
+					style |= FC_REC_DWN ;
+			}
+			SetStyle(style) ;
+		        h = GetDC( w ) ;
+			if ( TstF( GetStyle(), FC_BUTTONDRAW ) )
+				DrawFafaButton( w ,h) ;
+			else	DrawFafaCheck( w ,h) ;
+		        ReleaseDC( w, h ) ;
+			break ;
+		}
+		case WM_GETFONT:
+			return (LRESULT)GetFont() ;
+		case WM_PAINT :
+			if ( TstF( GetStyle(), FC_BUTTONDRAW ) )
+				RedrawFafaButton( w ) ;
+			else	RedrawFafaCheck( w ) ;
+			break ;
+
+		case WM_SETFOCUS:
+			ChangeCheckFocus( w, 1 ) ;
+			if ( GetAcc() && KeyIsDown( GetAcc() ) )
+				CheckKeyDown( w, 1 ) ;
+			break ;
+		case WM_KILLFOCUS:
+			ChangeCheckFocus( w, 0 ) ;
+			break ;
+
+		case WM_ENABLE:
+			if ( ( mw != 0 ) ^ IsDisabled() )
+				InvalidateRect( w, 0, 0 ) ;
+			break ;
+
+		case WM_RBUTTONDOWN:
+			if ( ! TstF( GetStyle(), FC_RIGHTBUT ) )
+				break ;
+
+		case WM_LBUTTONDOWN:
+			SetFocus( w ) ;
+			MouseDown( w ) ;
+			break ;
+
+		case WM_MOUSEMOVE:
+			MouseMove( w, ml ) ;
+			break ;
+
+		case WM_RBUTTONUP:
+			if ( ! TstF( GetStyle(), FC_RIGHTBUT ) )
+				break ;
+
+		case WM_LBUTTONUP:
+			MouseUp( w, ml ) ;
+			break ;
+
+		case FAFA_GETCHECK :
+#ifdef DEBUG_FAFA
+MyDebugMsg("State of check %x is %d\n",w,TstState(FB_SELECTED));
+#endif
+			return ( LONG ) TstState( FB_SELECTED ) ;
+
+		case FAFA_SETCHECK :
+#ifdef DEBUG_FAFA
+MyDebugMsg("Setting Check %x to %d\n",w,mw) ;
+#endif
+			if ( ChangeCheckSelect( w, ( mw != 0 ) ) && mw )
+				MakeRadioIteration( w ) ;
+			break ;
+
+		case WM_KEYDOWN:
+		case WM_SYSKEYDOWN:
+		case WM_KEYUP:
+		case WM_SYSKEYUP:
+			if ( mw == ' ' || KeyIsAcc( w, mw ) )
+				CheckKeyDown( w, IsMessDown( msg ) ) ;
+			else	return DefWindowProc( w, msg, mw, ml ) ;
+			break;
+
+		case WM_WHOAREYOU :
+			return ( LONG ) FB_CHECK ;
+
+		case WM_SETTEXT :
+			InvalidateRect( w, 0, 0 ) ;
+		default:
+			return DefWindowProc( w, msg, mw, ml ) ;
+		}
+
+	return 0l ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc RedrawFafaCheck :
+|-----------------------------------------------------------------------|
+*/
+
+#define	BTM_OFF	9000
+
+static	void	RedrawFafaCheck( HWND w )
+{
+	HDC		h ;
+	PAINTSTRUCT	p ;
+
+	h = BeginPaint( w, & p ) ;
+
+	DrawFafaCheck(w,h) ;
+
+	EndPaint(w,&p) ;
+
+}
+
+static void DrawFafaCheck(HWND w , HDC h) 
+{
+	RECT		r ;
+	UINT		sel ;
+	char		s[ CTLTITLE + 1 ] ;
+	HFONT		fnt,was;
+
+	fnt = GetFont() ;
+	GetClientRect( w, & r ) ;
+	GetWindowText( w, s, sizeof s ) ;
+	sel = TstState( FB_SELECTED ) ;
+
+	if (fnt)
+		was = SelectObject(h,fnt) ;
+
+	DrawCheck( h, & r, BTM_OFF + 2 * BtStyle( GetStyle() ) + sel, s ) ;
+
+	if ( IsDisabled() )
+		DrawButtonDisable( h, & r, 0 ) ;
+	else if ( TstState( FB_FOCUS ) )
+		DrawCheckFocus( h, & r, s ) ;
+
+	if (fnt)
+		SelectObject(h,was) ;
+}
+
+static	void	DrawCheckFocus( HDC h, RECT * r, LPSTR s )
+{
+	RECT	rt ;
+
+	rt.left = rt.right = rt.top = rt.bottom = 0 ;
+	DrawText( h, s, -1, & rt, DT_CALCRECT ) ;
+
+	OffsetRect( & rt, OFFSET_TEXT, ( r->bottom - rt.bottom ) / 2 ) ;
+	InflateRect( & rt, MARGE, MARGE ) ;
+	DrawFocusRect( h, & rt ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc ChangeCheckFocus :	
+|-----------------------------------------------------------------------|
+*/
+
+static	void	ChangeCheckFocus( HWND w, int on )
+{
+	if ( ( on != 0 ) ^ TstF( GetState(), FB_FOCUS ) )
+		{
+		HDC	h ;
+		RECT	r ;
+		char	s[ CTLTITLE + 1 ] ;
+
+		h = GetDC( w ) ;
+		GetClientRect( w, & r ) ;
+		GetWindowText( w, s, sizeof s ) ;
+
+		if ( TstF( GetStyle(), FC_BUTTONDRAW ) )
+			DrawButtonFocus( h, & r, TstState( FB_SELECTED ) ) ;
+		else	DrawCheckFocus( h, & r, s ) ;
+
+		ReleaseDC( w, h ) ;
+		XorState( (WORD)FB_FOCUS ) ;
+		}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc ChangeCheckSelect :
+|-----------------------------------------------------------------------|
+*/
+
+static	int	ChangeCheckSelect( HWND w, int s )
+{
+	if ( s ^ TstState( FB_SELECTED ) )
+		{
+		XorState( (WORD)FB_SELECTED ) ;
+		InvalidateRect( w, 0, 1 ) ;
+		return 1 ;
+		}
+	return 0 ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc MakeRadioIteration :						|
+|-----------------------------------------------------------------------|
+*/
+
+static	void	MakeRadioIteration( HWND w1 )
+{
+char	className[32] ;
+int	count ;
+HWND	w = w1 ;
+
+	if ( ! TstF( GetStyle(), FC_RADIO ) )
+		return ;
+
+	w = GetWindow( w1, GW_HWNDNEXT ) ;
+	while ( w )
+	{
+		count = GetClassName(w,className,31) ;
+		if (strncmp(className,FafaChck,count))
+			break ; /* not a fafa item */
+                if (!TstF( GetStyle(), FC_RADIO )  ||
+                     TstF (GetStyle() , WS_GROUP)
+		   )
+	      		break ; /* Not a radio item, or first of other radio */
+		ChangeCheckSelect( w, 0 ) ;
+		w = GetWindow( w, GW_HWNDNEXT ) ;
+	}
+
+	w = w1 ;
+	if (!TstF( GetStyle(), WS_GROUP))
+	{
+		/* first item of radio not yet reached */
+		w = GetWindow( w1, GW_HWNDPREV ) ;
+		while ( w )
+		{
+			count = GetClassName(w,className,31) ;
+			if (strncmp(className,FafaChck,count))
+				break ; /* not a fafa item */
+			if (!TstF( GetStyle(), FC_RADIO ))
+				break ; /* not a radio item */
+			ChangeCheckSelect( w, 0 ) ;
+			if (TstF( GetStyle(), WS_GROUP))
+				break ; /* first reached */
+			w = GetWindow( w, GW_HWNDPREV ) ;
+		}
+	}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc CheckKeyDown :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	CheckKeyDown( HWND w, int down )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( ! TstState( FB_CAPTURING ) )
+		if ( down && ! TstState( FB_KEYDOWN ) )
+			{
+			if ( ! TstState( FB_SELECTED ) ||
+				! TstF( GetStyle(), FC_RADIO ) )
+					{
+					XorState( (WORD)FB_SELECTED ) ;
+					SetState( (WORD)FB_KEYDOWN ) ;
+					InvalidateRect( w, 0, 1 ) ;
+					}
+			}
+		else if ( ( ! down ) && TstState( FB_KEYDOWN ) )
+			{
+			ClrState( (WORD)FB_KEYDOWN ) ;
+			MakeRadioIteration( w ) ;
+			SendMessage( GetParent( w ), WM_COMMAND,
+				     wparam , lparam) ;
+			}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawCheck :
+|-----------------------------------------------------------------------|
+*/
+
+extern HBRUSH		brushBack ;		/* Brosse gris clair */
+
+static	void	DrawCheck( HDC h, RECT * r, int n, LPSTR s )
+{
+	HBITMAP		b ;
+	BITMAP		o ;
+	HDC		hm ;
+	int		y ;
+	COLORREF	old ;
+
+	hm = CreateCompatibleDC( h ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	b = LoadOneBitmap( n, & o ) ;
+	if ( b )
+		{
+		b = SelectObject( hm, b ) ;
+		y = ( r->top + r->bottom ) / 2 ;
+
+		BitBlt( h, 0, y - o.bmHeight / 2, o.bmWidth, o.bmHeight,
+							hm, 0, 0, SRCCOPY ) ;
+		DeleteObject( SelectObject( hm, b ) ) ;
+
+		if ( s[ 0 ] != '\0' )
+			{
+			RECT	rt ;
+
+			rt.left = rt.right = rt.top = rt.bottom = 0 ;
+			DrawText( h, s, -1, & rt, DT_CALCRECT ) ;
+			OffsetRect( & rt, OFFSET_TEXT, y - rt.bottom / 2 ) ;
+
+		        FillRect( h, & rt, brushBack ) ;
+			SetBkMode( h, TRANSPARENT ) ;
+			old = SetTextColor(h,colorText) ;
+			DrawText( h, s, -1, & rt, DT_NOCLIP | DT_CENTER ) ;
+			SetTextColor(h,old) ;
+			}
+		}
+	DeleteDC( hm ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc Mouse controls :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	MouseDown( HWND w )
+{
+	if ( ! TstState( FB_KEYDOWN ) &&
+	   ( ! TstState( FB_SELECTED ) || ! TstF( GetStyle(), FC_RADIO ) ) )
+		{
+		SetCapture( w ) ;
+		XorState( (WORD)FB_SELECTED ) ;
+		SetState( (WORD)(FB_CAPTURING | FB_TO_SET) ) ;
+		InvalidateRect( w, 0, 1 ) ;
+		}
+}
+
+static	void	MouseMove( HWND w, DWORD l )
+{
+	if ( TstState( FB_CAPTURING ) )
+		{
+		RECT	r ;
+
+		GetClientRect( w, & r ) ;
+
+		if ( XyInRect( LOWORD( l ), HIWORD( l ), r ) )
+			{
+			if ( ! TstState( FB_TO_SET ) )
+				{
+				SetState( (WORD)FB_TO_SET ) ;
+				XorState( (WORD)FB_SELECTED ) ;
+				InvalidateRect( w, 0, 1 ) ;
+				}
+			}
+		else if ( TstState( FB_TO_SET ) )
+			{
+			ClrState( (WORD)FB_TO_SET ) ;
+			XorState( (WORD)FB_SELECTED ) ;
+			InvalidateRect( w, 0, 1 ) ;
+			}
+		}
+}
+
+static	void	MouseUp( HWND w, DWORD l )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( TstState( FB_CAPTURING ) )
+		{
+
+		MouseMove( w, l ) ;
+
+		ReleaseCapture() ;
+		ClrState( FB_TO_SET | FB_CAPTURING ) ;
+
+		if ( TstState( (WORD)FB_SELECTED ) )
+			MakeRadioIteration( w ) ;
+		SendMessage( GetParent( w ), WM_COMMAND,
+			wparam , lparam) ;
+		}
+}
+
diff --git a/src/wxwindow/contrib/fafa/cont.c b/src/wxwindow/contrib/fafa/cont.c
new file mode 100644
index 0000000..4d85423
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/cont.c
@@ -0,0 +1,333 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Cont.c - Controles Windows 					|
+|	Fonction fenetre de gestion des types Boutons Continus		|
+|									|
+|	Copyright (c)	FB			Boulogne		|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+
+/*
+|-----------------------------------------------------------------------|
+| static	 :
+|-----------------------------------------------------------------------|
+*/
+
+#define	LAPS		20		/* valeur temps timer */
+#define	LAPS_FREE	8		/* nombre de laps free */
+
+static	UINT	Htimer ;	/* Handle timer */
+static	RECT	Rb ;		/* rectangle */
+static	DWORD	LapsFree ;	/* temps d'attente avent serie */
+
+/*
+|-----------------------------------------------------------------------|
+| prototypes :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	FafaContKey( HWND w, int down ) ;
+static	void	FafaContMouse( HWND w, int down ) ;
+
+static	void	SendTimer( HWND w, int button ) ;
+static	void	ResetTimer( HWND w ) ;
+
+void WINAPI ExecuteTimerBtn( HWND w, UINT m, UINT id, DWORD tt ) ;
+void WINAPI ExecuteTimerSpace( HWND w, UINT m, UINT id, DWORD tt ) ;
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoopFafaCont :
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI LoopFafaCont( HWND w, UINT msg, WPARAM mw, LPARAM ml )
+{
+	switch( msg )
+		{
+		case WM_CREATE :
+			InitButtonWords( w ) ;
+			break ;
+
+		case WM_SETFONT:
+		{
+			HFONT f = (HFONT)mw ;
+			SetFont(f) ;
+			break ;
+		}
+		case WM_GETFONT:
+			return (LRESULT)GetFont() ;
+		case WM_PAINT :
+			RedrawFafaButton( w ) ;
+			break ;
+
+		case WM_ENABLE :
+			if ( ( mw != 0 ) ^ IsDisabled() )
+				InvalidateRect( w, 0, 0 ) ;
+			break ;
+
+		case WM_SETFOCUS :
+			ChangeButtonFocus( w, 1 ) ;
+			if ( GetAcc() && KeyIsDown( GetAcc() ) )
+				FafaContKey( w, 1 ) ;
+			break ;
+		case WM_KILLFOCUS :
+			ChangeButtonFocus( w, 0 ) ;
+			break ;
+
+		case WM_RBUTTONDBLCLK:
+			if ( ! TstF( GetStyle(), FB_RIGHTBUT ) )
+				break ;
+		case WM_LBUTTONDBLCLK:
+		{
+		WORD	id ;
+		HWND	hwnd ;
+		WORD	cmd ;
+		LPARAM	lparam ;
+		WPARAM	wparam ;
+
+			id = GetDlgCtrlID(w) ;
+			hwnd = w ;
+			cmd = BN_CLICKED ;
+#ifdef WIN32
+			lparam = (LPARAM)hwnd ;
+			wparam = MAKEWPARAM(id,cmd) ;
+#else
+			wparam = (WPARAM)id ;
+			lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+			if ( ! TstF( GetStyle(), FB_DBLCLKS ) )
+				SendMessage( GetParent( w ), WM_COMMAND,
+					     wparam , lparam) ;
+			break ;
+		}
+		case WM_RBUTTONDOWN:
+		case WM_RBUTTONUP:
+			if ( ! TstF( GetStyle(), FB_RIGHTBUT ) )
+				break ;
+
+		case WM_LBUTTONDOWN:
+		case WM_LBUTTONUP:
+			FafaContMouse( w, ( msg == WM_LBUTTONDOWN ||
+					  msg == WM_RBUTTONDOWN ) ) ;
+			break ;
+
+		case WM_KEYDOWN:
+		case WM_SYSKEYDOWN:
+		case WM_KEYUP:
+		case WM_SYSKEYUP:
+			if ( mw == ' ' || KeyIsAcc( w, mw ) )
+				FafaContKey( w, IsMessDown( msg ) ) ;
+			else	return DefWindowProc( w, msg, mw, ml ) ;
+			break ;
+
+		case WM_WHOAREYOU :
+			return ( LONG ) MB_BUTTON ;
+
+		case WM_SETTEXT :
+			InvalidateRect( w, 0, 0 ) ;
+		default:
+			return DefWindowProc( w, msg, mw, ml ) ;
+		}
+	return 0l ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc FafaContMouse :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	FafaContMouse( HWND w, int down )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_UNHILITE ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( ! TstState( FB_KEYDOWN ) )
+		if ( down )
+			{
+			SetFocus( w ) ;
+			SetState( (WORD)FB_CAPTURING ) ;
+			SendTimer( w, 1 ) ;
+			}
+		else if ( TstState( FB_CAPTURING ) )
+			{
+			ResetTimer( w ) ;
+			SendMessage( GetParent( w ), WM_COMMAND,
+				     wparam , lparam ) ;
+			}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc FafaContKey:
+|-----------------------------------------------------------------------|
+*/
+
+static	void	FafaContKey( HWND w, int down )
+{
+WORD	id ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	id = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_UNHILITE ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(id,cmd) ;
+#else
+	wparam = (WPARAM)id ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( ! TstState( FB_CAPTURING ) )
+		if ( down && ! TstState( FB_KEYDOWN ) )
+			{
+			SetState( (WORD)FB_KEYDOWN ) ;
+			SendTimer( w, 0 ) ;
+			}
+		else if ( ! down && TstState( FB_KEYDOWN ) )
+			{
+			ResetTimer( w ) ;
+			SendMessage( GetParent( w ), WM_COMMAND,
+				     wparam , lparam) ;
+			}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc SendTimer :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	SendTimer( HWND w, int button )
+{
+	SetCapture( w ) ;
+
+	GetClientRect( w, & Rb ) ;
+	ClientToScreen( w, ( POINT * ) & Rb.left  ) ;
+	ClientToScreen( w, ( POINT * ) & Rb.right ) ;
+
+	LapsFree = 0 ;
+	if ( button )
+		{
+		ExecuteTimerBtn( w, 0, 0, 0 ) ;
+		Htimer = SetTimer( w, 1, 20, ( TIMERPROC ) ExecuteTimerBtn ) ;
+		}
+	else	{
+		SetState( (WORD)FB_SELECTED ) ;
+		InvalidateRect( w, 0, 0 ) ;
+
+		ExecuteTimerSpace( w, 0, 0, 0 ) ;
+		Htimer = SetTimer( w, 1, 20, ( TIMERPROC ) ExecuteTimerSpace ) ;
+		}
+	LapsFree = LAPS_FREE ;
+}
+
+static	void	ResetTimer( HWND w )
+{
+	KillTimer( w, Htimer ) ;
+	ReleaseCapture() ;
+
+	if ( TstState( FB_SELECTED ) )
+		InvalidateRect( w, 0, 0 ) ;
+
+	ClrState( (WORD)(FB_SELECTED | FB_KEYDOWN | FB_CAPTURING) ) ;
+}
+
+void WINAPI ExecuteTimerBtn( HWND w, UINT m, UINT id, DWORD tt )
+{
+POINT	p ;
+WORD	myid ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	myid = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(myid,cmd) ;
+#else
+	wparam = (WPARAM)myid ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( LapsFree )
+		LapsFree -- ;
+
+	GetCursorPos( & p ) ;
+
+	if ( XyInRect( p.x, p.y, Rb ) )
+		{
+		if ( ! TstState( FB_SELECTED ) )
+			{
+			SetState( (WORD)FB_SELECTED ) ;
+			InvalidateRect( w, 0, 0 ) ;
+			UpdateWindow( w ) ;
+			}
+		if ( ! LapsFree )
+			SendMessage( GetParent( w ), WM_COMMAND,
+				     wparam , lparam) ;
+		}
+	else if ( TstState( FB_SELECTED ) )
+		{
+		ClrState( (WORD)FB_SELECTED ) ;
+		InvalidateRect( w, 0, 0 ) ;
+		UpdateWindow( w ) ;
+		}
+}
+
+void WINAPI ExecuteTimerSpace( HWND w, UINT m, UINT id, DWORD tt )
+{
+WORD	myid ;
+HWND	hwnd ;
+WORD	cmd ;
+LPARAM	lparam ;
+WPARAM	wparam ;
+
+	myid = GetDlgCtrlID(w) ;
+	hwnd = w ;
+	cmd = BN_CLICKED ;
+#ifdef WIN32
+	lparam = (LPARAM)hwnd ;
+	wparam = MAKEWPARAM(myid,cmd) ;
+#else
+	wparam = (WPARAM)myid ;
+	lparam = MAKELPARAM(hwnd,cmd) ;
+#endif
+
+	if ( LapsFree )
+		LapsFree -- ;
+	if ( ! LapsFree )
+		SendMessage( GetParent( w ), WM_COMMAND,
+			     wparam , lparam ) ;
+}
+
+
diff --git a/src/wxwindow/contrib/fafa/dialog.c b/src/wxwindow/contrib/fafa/dialog.c
new file mode 100644
index 0000000..b393982
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/dialog.c
@@ -0,0 +1,68 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Fonction fenetre de gestion des dialogues			|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoopFafaDialog :
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI LoopFafaDialog( HWND w, UINT msg, WPARAM mw, LPARAM ml )
+{
+	switch(msg)
+	{
+#ifdef WIN32
+	case WM_CTLCOLORDLG:
+	{
+	HDC pDC = (HDC)mw;
+		SetBkColor(pDC, GetSysColor(COLOR_WINDOW)) ;
+		return (LRESULT)brushBack ;
+	}
+	break ;
+#else
+	case WM_CTLCOLOR:
+	{
+	int nCtlColor = (int)HIWORD(ml);
+		if (nCtlColor==CTLCOLOR_DLG)
+		{
+		HDC pDC = (HDC)mw;
+			SetBkColor(pDC, GetSysColor(COLOR_WINDOW)) ;
+			return (LRESULT)brushBack ;
+		}
+	}
+	break ;
+#endif
+	case WM_SYSCOLORCHANGE:
+	{
+		CreatePensBrushes() ;
+#ifdef WIN32
+		SetClassLong(w,GCL_HBRBACKGROUND,(LONG)brushBack) ;
+#else
+		SetClassWord(w,GCW_HBRBACKGROUND,(WORD)brushBack) ;
+#endif
+		return 0 ;
+	}
+	break ;
+	case WM_ERASEBKGND :
+		return DefWindowProc( w, msg, mw, ml ) ;
+	break ;
+	default:
+		return DefDlgProc( w, msg, mw, ml ) ;
+	break ;
+	}
+  return 0;
+}
+
diff --git a/src/wxwindow/contrib/fafa/draw.c b/src/wxwindow/contrib/fafa/draw.c
new file mode 100644
index 0000000..4cffc90
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/draw.c
@@ -0,0 +1,315 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Utilitaires generaux de dessin.					|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+
+/*
+|-----------------------------------------------------------------------|
+| proc define	 :
+|-----------------------------------------------------------------------|
+*/
+
+#define	MARGE_FOCUS		6		/* marge cadre focus */
+#define	DEFAULT_BTM		8200		/* bitmap par defaut */
+
+HBITMAP		DisableBitmap ;		/* bitmap pour controles disables */
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawButtonFocus :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawButtonFocus( HDC h, RECT * r, int sel )
+{
+	InflateRect( r, - MARGE_FOCUS, - MARGE_FOCUS ) ;
+	if ( sel )
+		OffsetRect( r, 1, 1 ) ;
+	DrawFocusRect( h, r ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawButtonDisable :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawButtonDisable( HDC h, RECT * r, int with_marge )
+{
+	HBITMAP		o = SelectObject( h, DisableBitmap ) ;
+
+	if ( with_marge )
+		PatBlt( h, MARGE_FOCUS, MARGE_FOCUS,
+			r->right - 2 * MARGE_FOCUS, r->bottom - 2 * MARGE_FOCUS,
+				0xfa0089ul ) ;
+	else	PatBlt( h, 0, 0, r->right, r->bottom, 0xfa0089ul ) ;
+
+	SelectObject( h, o ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawPodium :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawPodium( HDC h, RECT * r, int sel )
+{
+HPEN	oldp;
+HBRUSH	oldb ;
+
+	oldp = SelectObject( h, GetStockObject( NULL_PEN ) ) ;
+	oldb = SelectObject( h, brushFace ) ;
+	Rectangle( h, r->left, r->top, r->right, r->bottom ) ;
+	SelectObject( h, penBorder) ;
+        MoveToEx(h,r->left+1,r->top,NULL);LineTo(h,r->right-1,r->top);
+        MoveToEx(h,r->left,r->top+1,NULL);LineTo(h,r->left,r->bottom-1);
+        MoveToEx(h,r->left+1,r->bottom-1,NULL);LineTo(h,r->right-1,r->bottom-1);
+        MoveToEx(h,r->right-1,r->top+1,NULL);LineTo(h,r->right-1,r->bottom-1);
+
+	SelectObject( h, penShadow) ;
+	if (sel)
+	{
+		MoveToEx(h,r->left+1	,r->bottom-2	,NULL) ;
+		LineTo(h,  r->left+1	,r->top+1) ;
+		LineTo(h,  r->right-2	,r->top+1) ;
+	}
+	else
+	{
+		MoveToEx(h,r->left+1	,r->bottom-2	,NULL) ;
+		LineTo(h,  r->right-2	,r->bottom-2) ;
+		LineTo(h,  r->right-2	,r->top) ;
+		MoveToEx(h,r->left+2	,r->bottom-3	,NULL) ;
+		LineTo(h,  r->right-3	,r->bottom-3) ;
+		LineTo(h,  r->right-3	,r->top+1) ;
+
+		SelectObject( h, penLight) ;
+
+		MoveToEx(h,r->left+1	,r->bottom-2	,NULL) ;
+		LineTo(h,  r->left+1	,r->top+1) ;
+		LineTo(h,  r->right-2	,r->top+1) ;
+	}
+	SelectObject(h,oldp) ;
+	SelectObject(h,oldb) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawBitmap :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawBitmap( HDC hb, RECT * r, int n, int selected )
+{
+	HDC	hm ;
+	int	x, y ;
+	HBITMAP	b ;
+	BITMAP	o ;
+
+	hm = CreateCompatibleDC( hb ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	b = LoadOneBitmap( n, & o ) ;
+
+	if ( b )
+		{
+		n -- ;
+		b = SelectObject( hm, b ) ;
+
+		x = ( r->left + r->right  - o.bmWidth ) / 2 ;
+		y = ( r->top  + r->bottom - o.bmHeight ) / 2 ;
+
+		if ( selected )
+			{
+			x ++ ;
+			y ++ ;
+			}
+
+		BitBlt( hb, x, y, o.bmWidth, o.bmHeight, hm, 0, 0, SRCCOPY ) ;
+		DeleteObject( SelectObject( hm, b ) ) ;
+		}
+	DeleteDC( hm ) ;
+}
+
+void	DrawBitmapLoaded( HDC hb, RECT * r, HBITMAP b,int width,int height, int selected )
+{
+	HDC	hm ;
+	int	x, y ;
+
+	hm = CreateCompatibleDC( hb ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	if ( b )
+		{
+		b = SelectObject( hm, b ) ;
+
+		x = ( r->left + r->right  - width ) / 2 ;
+		y = ( r->top  + r->bottom - height ) / 2 ;
+
+		if ( selected )
+			{
+			x ++ ;
+			y ++ ;
+			}
+
+		BitBlt( hb, x, y, width, height, hm, 0, 0, SRCCOPY ) ;
+		SelectObject( hm, b ) ;
+		}
+	DeleteDC( hm ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawString :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawString( HDC hb, RECT *r, LPSTR s, int selected )
+{
+	RECT	b ;
+	int	m ;
+	COLORREF old ;
+
+	b.left   = r->left + 5 ;
+	b.right  = r->right - 5 ;
+	b.top	 = b.bottom = 0 ;
+
+	DrawText( hb, s, -1, & b, DT_CALCRECT ) ;
+	m = b.bottom - b.top ;
+
+	b.left   = r->left + 5 ;
+	b.right  = r->right - 5 ;
+	b.top    = ( r->top + r->bottom - m ) / 2 ;
+	b.bottom = ( r->top + r->bottom + m ) / 2 ;
+
+	if ( selected )
+		{
+		b.left  ++ ;
+		b.top   ++ ;
+		b.right ++ ;
+		b.bottom++ ;
+		}
+
+	SetBkMode( hb, TRANSPARENT ) ;
+	old = SetTextColor(hb , colorText) ;
+	DrawText( hb, s, -1, & b, DT_NOCLIP | DT_CENTER ) ;
+	SetTextColor(hb , old) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawBtStrX :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawBtmTxtHV( HDC h, RECT * r, int btm, LPSTR txt, int sel, int t )
+{
+	HDC	hm ;
+	HBITMAP	b ;
+	BITMAP	o ;
+	COLORREF old ;
+
+	DrawPodium( h, r, sel ) ;
+
+	hm = CreateCompatibleDC( h ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	b = LoadOneBitmap( btm, & o ) ;
+
+	if ( b )
+		{
+		RECT	rt ;
+
+		rt.left = rt.right = rt.top = rt.bottom = 0 ;
+		DrawText( h, txt, -1, & rt, DT_CALCRECT ) ;
+
+		if ( t )
+			{
+			rt.left = ( r->right - o.bmWidth ) / 2 ;
+			rt.top  = ( r->bottom - rt.bottom - o.bmHeight ) / 3 ;
+			}
+		else	{
+			rt.left = ( r->right - rt.right - o.bmWidth ) / 3 ;
+			rt.top  = ( r->bottom - o.bmHeight ) / 2 ;
+			}
+
+		if ( sel )
+			{
+			rt.left ++ ;
+			rt.top ++ ;
+			}
+
+		b = SelectObject( hm, b ) ;
+		BitBlt( h, rt.left, rt.top, o.bmWidth, o.bmHeight,
+							hm, 0, 0, SRCCOPY ) ;
+		DeleteObject( SelectObject( hm, b ) ) ;
+
+		if ( t )
+			{
+			rt.left += ( o.bmWidth - rt.right ) / 2 ;
+			rt.top  += o.bmHeight + rt.top - sel ;
+			}
+		else	{
+			rt.left += o.bmWidth + rt.left - sel ;
+			rt.top  += ( o.bmHeight - rt.bottom ) / 2 ;
+			}
+		rt.right  += rt.left ;
+		rt.bottom += rt.top  ;
+
+		SetBkMode( h, TRANSPARENT ) ;
+		old = SetTextColor(h , colorText) ;
+		DrawText( h, txt, -1, & rt, DT_NOCLIP | DT_CENTER ) ;
+		SetTextColor(h , old) ;
+		}
+	DeleteDC( hm ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawMac :
+|-----------------------------------------------------------------------|
+*/
+
+void	DrawMac( HDC h, RECT * r, LPSTR txt, int sel )
+{
+HBRUSH old ;
+
+	old = SelectObject( h, sel ? brushLight : brushFace);
+
+	RoundRect( h, r->left, r->top, r->right, r->bottom, 8, 8 ) ;
+	DrawString( h, r, txt, 0 ) ;
+	SelectObject(h,old) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoadOneBitmap :
+|-----------------------------------------------------------------------|
+*/
+
+HBITMAP	LoadOneBitmap( int n, BITMAP * o )
+{
+	HBITMAP	b = LoadBitmap( Inst, MAKEINTRESOURCE( n ) ) ;
+
+	if ( ! b )
+		b = LoadBitmap( Inst, MAKEINTRESOURCE( DEFAULT_BTM ) ) ;
+
+	if ( b )
+		GetObject( b, sizeof( BITMAP ), ( LPSTR ) o ) ;
+	return b ;
+}
+
diff --git a/src/wxwindow/contrib/fafa/dumfafa.c b/src/wxwindow/contrib/fafa/dumfafa.c
new file mode 100644
index 0000000..01b85b0
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/dumfafa.c
@@ -0,0 +1,2 @@
+#include "fafapriv.h"
+
diff --git a/src/wxwindow/contrib/fafa/fafa.c b/src/wxwindow/contrib/fafa/fafa.c
new file mode 100644
index 0000000..22dbcfa
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/fafa.c
@@ -0,0 +1,299 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Initialisations de la librairie					|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+#ifdef __WATCOMC__
+#include                <string.h>
+#else
+#include		<memory.h>
+#endif
+#include		"wx_setup.h"
+
+/*
+|-----------------------------------------------------------------------|
+| Parametres
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI LoopFafaDialog( HWND w, UINT msg, UINT mw, LPARAM ml ) ;
+LRESULT	WINAPI LoopFafaButton( HWND w, UINT msg, UINT mw, LPARAM ml ) ;
+LRESULT	WINAPI LoopFafaStatic( HWND w, UINT msg, UINT mw, LPARAM ml ) ;
+LRESULT	WINAPI LoopFafaCheck ( HWND w, UINT msg, UINT mw, LPARAM ml ) ;
+LRESULT	WINAPI LoopFafaCont  ( HWND w, UINT msg, UINT mw, LPARAM  ) ;
+
+HANDLE	Inst ;
+
+//*** added by Chubraev for __WATCOMC__ multiple instances support
+#ifdef  _MULTIPLE_INSTANCES
+#include <stdio.h>
+#define ZZ	32
+char	FafaWind[ZZ];
+char	FafaButt[ZZ];
+char	FafaStat[ZZ];
+char	FafaChck[ZZ];
+char	MichButt[ZZ];
+#undef	ZZ
+//***
+#else
+char	FafaWind[] = FAFA_WIND ;
+char	FafaButt[] = FAFA_BUTTON ;
+char	FafaStat[] = FAFA_STATIC ;
+char	FafaChck[] = FAFA_CHECK ;
+char	MichButt[] = FAFA_CONT ;
+#endif
+
+#define	DISABLE_BTM		9100
+
+static	int	MyRegisterClass( void ) ;
+
+HPEN		penBorder,
+		penShadow,
+		penLight;
+HBRUSH		brushFace,
+		brushBack,
+		brushShadow,
+		brushFrame,
+		brushLight;
+COLORREF 	colorText,
+		colorLabel;
+HPEN		staticBorder,
+		staticShadow,
+		staticLight;
+
+/*
+|-----------------------------------------------------------------------|
+| proc LibMain :
+|-----------------------------------------------------------------------|
+*/
+
+int InitFafa( HANDLE inst)
+{
+#ifdef _MULTIPLE_INSTANCES
+	sprintf(FafaWind,"FafaDialog%d",inst);
+	sprintf(FafaButt,"FafaButton%d",inst);
+	sprintf(FafaStat,"FafaStatic%d",inst);
+	sprintf(FafaChck,"FafaCheck%d",inst);
+	sprintf(MichButt,"FafaCont%d",inst);
+#endif
+	Inst = inst ;
+	CreatePensBrushes() ;
+
+	if ( MyRegisterClass() )
+		{
+		LOGBRUSH	lb ;
+
+		lb.lbStyle = BS_PATTERN;
+		//lb.lbHatch = (LONG)LoadBitmap( Inst, MAKEINTRESOURCE(DISABLE_BTM) ) ;
+		//int for Win31. A voir pour Win32
+		lb.lbHatch = (int)LoadBitmap( Inst, MAKEINTRESOURCE(DISABLE_BTM) ) ;
+
+		DisableBitmap = CreateBrushIndirect( & lb ) ;
+		DeleteObject( (HGDIOBJ)lb.lbHatch ) ;
+
+		return 1 ;
+		}
+	else	
+		DeletePensBrushes() ;
+	return 0 ;
+}
+
+void EndFafa()
+{
+	if (DisableBitmap)
+		DeleteObject(DisableBitmap) ;
+	DeletePensBrushes() ;
+
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc MyRegisterClass :
+|-----------------------------------------------------------------------|
+*/
+
+static	int	MyRegisterClass( void )
+{
+	WNDCLASS	w ;
+
+	memset( & w, 0, sizeof w ) ;
+	w.lpszClassName = FafaWind ;
+	w.hInstance	= Inst ;
+	w.lpfnWndProc	= LoopFafaDialog ;
+	w.hCursor	= LoadCursor( 0, IDC_ARROW ) ;
+	w.hIcon		= LoadIcon( Inst, "fafa_icn") ;
+	w.hbrBackground = ((HBRUSH)(COLOR_WINDOW+1)) ;
+	w.style		= CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
+	w.cbWndExtra	= DLGWINDOWEXTRA ;
+	if ( ! RegisterClass( & w ) )
+		return 0 ;
+
+	w.lpszClassName = FafaButt ;
+	w.lpfnWndProc	= LoopFafaButton ;
+	w.cbWndExtra	= FB_EXTRA ;
+	w.hCursor	= 0 ;
+	w.hIcon		= 0 ;
+	if ( ! RegisterClass( & w ) )
+		return 0 ;
+
+	w.lpszClassName = FafaChck ;
+	w.lpfnWndProc	= LoopFafaCheck ;
+	if ( ! RegisterClass( & w ) )
+		return 0 ;
+
+	w.lpszClassName = MichButt ;
+	w.lpfnWndProc	= LoopFafaCont ;
+	if ( ! RegisterClass( & w ) )
+		return 0 ;
+
+	w.lpszClassName = FafaStat ;
+	w.lpfnWndProc	= LoopFafaStatic ;
+	w.style		= CS_HREDRAW | CS_VREDRAW ;
+	return RegisterClass( & w ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DeletePensBrushes :
+|-----------------------------------------------------------------------|
+*/
+void DeletePensBrushes(void)
+{
+	if (staticBorder)
+		DeleteObject(staticBorder) ;
+	if (staticShadow)
+		DeleteObject(staticShadow) ;
+	if (staticLight)
+		DeleteObject(staticLight) ;
+	if (penBorder)
+		DeleteObject(penBorder) ;
+	if (penShadow)
+		DeleteObject(penShadow) ;
+	if (penLight)
+		DeleteObject(penLight) ;
+	if (brushFace)
+		DeleteObject(brushFace) ;
+	if (brushBack)
+		DeleteObject(brushBack) ;
+	if (brushLight)
+		DeleteObject(brushLight) ;
+	if (brushFrame)
+		DeleteObject(brushFrame) ;
+	if (brushShadow)
+		DeleteObject(brushShadow) ;
+
+	staticBorder = NULL ;
+	staticShadow = NULL ;
+	staticLight = NULL ;
+	brushFrame = NULL ;
+	brushShadow = NULL ;
+	penShadow = NULL ;
+	penLight = NULL ;
+	brushFace = NULL ;
+	brushBack = NULL ;
+	brushLight = NULL ;
+
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc CreatePensBrushes :
+|-----------------------------------------------------------------------|
+*/
+void CreatePensBrushes(void)
+{
+COLORREF ms_color ;
+BYTE	 red,green,blue ;
+unsigned int val ;
+
+	DeletePensBrushes() ;
+
+	ms_color = GetSysColor(COLOR_WINDOWFRAME) ;
+	penBorder = CreatePen(PS_SOLID,0,ms_color) ;
+
+	ms_color = GetSysColor(COLOR_BTNSHADOW) ;
+	penShadow = CreatePen(PS_SOLID,0,ms_color) ;
+
+	ms_color = GetSysColor(COLOR_BTNHIGHLIGHT) ;
+	penLight = CreatePen(PS_SOLID,0,ms_color) ;
+	brushLight = CreateSolidBrush(ms_color) ;
+
+	colorText = GetSysColor(COLOR_BTNTEXT) ;
+
+	colorLabel = GetSysColor(COLOR_WINDOWTEXT) ;
+
+	ms_color = GetSysColor(COLOR_BTNFACE) ;
+	brushFace = CreateSolidBrush(ms_color) ;
+
+	ms_color = GetSysColor(COLOR_APPWORKSPACE) ;
+	brushFrame = CreateSolidBrush(ms_color) ;
+
+	ms_color = GetSysColor(COLOR_WINDOW) ;
+// #if USE_GREY_BACKGROUND
+// 	brushBack = CreateSolidBrush(RGB(200, 200, 200)) ;
+// #else
+	brushBack = CreateSolidBrush(ms_color) ;
+// #endif
+	/* Foreground color (static) */
+	red   = GetRValue(ms_color) ;
+	green = GetGValue(ms_color) ;
+	blue  = GetBValue(ms_color) ;
+	val = red ;
+	val -= (val*45)/100 ;
+	val -= (val*4)/10 ;
+	red = val & 0xff ;
+	val = green ;
+	val -= (val*45)/100 ;
+	val -= (val*4)/10 ;
+	green = val & 0xff ;
+	val = blue ;
+	val -= (val*45)/100 ;
+	val -= (val*4)/10 ;
+	blue = val & 0xff ;
+	staticBorder = CreatePen(PS_SOLID,0,RGB(red,green,blue)) ;
+
+	/* Top shadow color (static) */
+	red   = GetRValue(ms_color) ;
+	green = GetGValue(ms_color) ;
+	blue  = GetBValue(ms_color) ;
+	val = red ;
+	val += (val*4)/10 ;
+	if (val>255)	val = 255 ;
+	red = val ;
+	val = green ;
+	val += (val*4)/10 ;
+	if (val>255)	val = 255 ;
+	green = val ;
+	val = blue ;
+	val += (val*4)/10 ;
+	if (val>255)	val = 255 ;
+	blue = val ;
+	staticLight = CreatePen(PS_SOLID,0,RGB(red,green,blue)) ;
+
+	/* Bottom shadow color (static) */
+	red   = GetRValue(ms_color) ;
+	green = GetGValue(ms_color) ;
+	blue  = GetBValue(ms_color) ;
+	val = red ;
+	val -= (val*45)/100 ;
+	red = val & 0xff ;
+	val = green ;
+	val -= (val*45)/100 ;
+	green = val & 0xff ;
+	val = blue ;
+	val -= (val*45)/100 ;
+	blue = val & 0xff ;
+	staticShadow = CreatePen(PS_SOLID,0,RGB(red,green,blue)) ;
+	brushShadow = CreateSolidBrush(RGB(red,green,blue)) ;
+
+}
diff --git a/src/wxwindow/contrib/fafa/fafa.h b/src/wxwindow/contrib/fafa/fafa.h
new file mode 100644
index 0000000..2e7cb30
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/fafa.h
@@ -0,0 +1,139 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.0		|
+|									|
+|	Controles Windows 						|
+|	Fafa.h - Definitions exportees					|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#ifndef			__FAFA_H
+#define			__FAFA_H
+
+#ifndef			__WINDOWS_H
+#define			NOCOM
+#include		<windows.h>
+#endif
+
+#include <custcntl.h>
+
+	/* Microsoft says: do not use message below WM_USER+0x100 ... */
+
+enum	{				/* Messages users */
+	WM_WHOAREYOU	= ( WM_USER + 0x101 ),
+	WM_CHANGEBITMAP	= ( WM_USER + 0x102 ),
+	/* Do not use BM_GET... : they are translated!!! */
+	FAFA_GETCHECK   = ( WM_USER + 0x103 ),
+	FAFA_SETCHECK   = ( WM_USER + 0x104 )
+	} ;
+
+#define	FAFA_WIND	"FafaDialog"
+#define	FAFA_BUTTON	"FafaButton"
+#define	FAFA_STATIC	"FafaStatic"
+#define	FAFA_CHECK	"FafaCheck"
+#define FAFA_CONT	"FafaCont"
+
+/*
+|-----------------------------------------------------------------------|
+| Controle FafaButton (et FafaContinue)
+|-----------------------------------------------------------------------|
+*/
+
+#define	FB_MARGIN	5
+
+enum	{				/* Fafa Button Styles : */
+	FB_TEXT,			/* texted multilignes */
+	FB_BITMAP,			/* bitmap */
+	FB_BTMTXT_H,			/* Bitmap-texte horizontal */
+	FB_BTMTXT_V,			/* Bitmap-texte vertical */
+	FB_MAC,				/* texte mode Mac */
+	FB_DBLBTM,			/* Double Bitmap */
+
+	FB_DBLCLKS	= 0x0010,	/* double click autorise */
+	FB_RIGHTBUT	= 0x0020	/* bouton droit autorise */
+	} ;
+
+#define	FB_DEFAULT	( FB_TEXT | WS_CHILD | WS_VISIBLE | WS_TABSTOP )
+
+/*
+|-----------------------------------------------------------------------|
+| Controle FB_STATIC
+|-----------------------------------------------------------------------|
+*/
+
+enum	{				/* Fafa Button Styles : */
+	FS_TEXT,			/* texte */
+	FS_BITMAP,			/* bitmap */
+	FS_MEPLAT_TXT,			/* meplat + texte */
+	FS_MEPLAT_BTM,			/* meplat + bitmap */
+	FS_CADRE_DOWN,			/* cadre enfonce */
+	FS_CADRE_UP,			/* cadre relief */
+
+	FS_X1		= ( 0 << 4 ),		/* position en X */
+	FS_X2		= ( 1 << 4 ),
+	FS_X3		= ( 2 << 4 ),
+	FS_X4		= ( 3 << 4 ),
+
+	FS_Y1		= ( 0 << 6 ),		/* position en Y */
+	FS_Y2		= ( 1 << 6 ),
+	FS_Y3		= ( 2 << 6 ),
+	FS_Y4		= ( 3 << 6 ),
+	} ;
+
+#define	FS_DEFAULT	( FS_TEXT | WS_CHILD | WS_VISIBLE | WS_GROUP )
+
+/*
+|-----------------------------------------------------------------------|
+| Controle FB_CHECK
+|-----------------------------------------------------------------------|
+*/
+
+enum	{				/* Fafa Check Styles : */
+	FC_CIR_DWN,			/* cercle enfonce */
+	FC_CIR_UP,			/* cercle en relief */
+	FC_REC_DWN,			/* carre enfonce */
+	FC_REC_UP,			/* carre en relief */
+
+	FC_RIGHTBUT	= 0x0010,	/* bouton droit autorise */
+	FC_PRESELECT	= 0x0020,	/* preselectionne */
+	FC_RADIO	= 0x0040,	/* mode radio */
+	FC_BUTTONDRAW	= 0x0080	/* dessin mode bouton */
+	} ;
+
+#define	FC_DEFAULT		( WS_CHILD | WS_VISIBLE | WS_TABSTOP )
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void CreatePensBrushes(void) ;
+void DeletePensBrushes(void) ;
+int InitFafa(HANDLE);
+void EndFafa(void);
+
+extern HPEN	staticBorder,
+		staticShadow,
+		staticLight;
+extern HPEN	penBorder,
+		penShadow,
+		penLight;
+extern HBRUSH	brushFace,
+		brushLight,
+		brushFrame,
+		brushShadow,
+		brushBack;
+extern COLORREF colorText,
+		colorLabel;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __FAFA_H */
+
+
diff --git a/src/wxwindow/contrib/fafa/fafa.ico b/src/wxwindow/contrib/fafa/fafa.ico
new file mode 100644
index 0000000..2e666b1
Binary files /dev/null and b/src/wxwindow/contrib/fafa/fafa.ico differ
diff --git a/src/wxwindow/contrib/fafa/fafa.rc b/src/wxwindow/contrib/fafa/fafa.rc
new file mode 100644
index 0000000..798ae9f
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/fafa.rc
@@ -0,0 +1,16 @@
+#ifndef _FAFA_RC_
+#define _FAFA_RC_
+
+9000 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9000.bmp"
+9001 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9001.bmp"
+9002 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9002.bmp"
+9003 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9003.bmp"
+9004 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9004.bmp"
+9005 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9005.bmp"
+9006 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9006.bmp"
+9007 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9007.bmp"
+9100 BITMAP LOADONCALL MOVEABLE DISCARDABLE "bit9100.bmp"
+
+fafa_icn ICON fafa.ico
+
+#endif
diff --git a/src/wxwindow/contrib/fafa/fafapriv.h b/src/wxwindow/contrib/fafa/fafapriv.h
new file mode 100644
index 0000000..ac935a0
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/fafapriv.h
@@ -0,0 +1,160 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	FafaDll 				Version 1.0		|
+|									|
+|	Dll Controles Windows 						|
+|	FafaDll.h - Definitions privees					|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#ifndef			__FAFAPRIV_H
+#define			__FAFAPRIV_H
+
+#include		"fafa.h"
+
+#ifdef WIN32
+#define CTLTITLE 256	/* Sorry, I've not found equiv in NT ??? */
+#endif
+
+/*
+|-----------------------------------------------------------------------|
+| defines generaux :
+|-----------------------------------------------------------------------|
+*/
+
+enum	{				/* Controles fafa */
+	FB_BUTTON,
+	FB_STATIC,
+	FB_CHECK,
+	MB_BUTTON,
+
+	NB_FAFACTRL			/* nombre de controles fafa */
+	} ;
+
+#define	OF_RES		8000		/* offset des ressources types */
+
+enum	{				/* etats */
+	FB_SELECTED	= 0x0001,
+	FB_CAPTURING	= 0x0002,
+	FB_FOCUS	= 0x0004,
+	FB_KEYDOWN	= 0x0008,
+	FB_TO_SET	= 0x0010
+	} ;
+
+enum	{				/* Extra BYTES, Offsets : */
+	OF_RESERVED	= 0,		/* oblige par windows !! */
+	OF_STATE	= 2,		/* etat courant */
+	OF_ACC		= 4,		/* touch acceleratrice */
+	OF_FONT		= 6,		/* Font */
+	OF_BITMAP	= 10,		/* Bitmap */
+	OF_BWIDTH	= 14,
+	OF_BHEIGHT	= 16
+	} ;
+
+#define	FB_EXTRA	18
+
+/*
+|-----------------------------------------------------------------------|
+| defines	 :
+|-----------------------------------------------------------------------|
+*/
+
+#define	GetStX( w )	( ( ( ( UINT ) ( w ) ) >> 4 ) & 0x3 )
+#define	GetStY( w )	( ( ( ( UINT ) ( w ) ) >> 6 ) & 0x3 )
+
+#define	SetStX( v )	( ( ( ( UINT ) ( v ) ) & 0x3 ) << 4 )
+#define	SetStY( v )	( ( ( ( UINT ) ( v ) ) & 0x3 ) << 6 )
+
+#define	SetState(f) SetWindowWord(w,OF_STATE,(WORD)(GetWindowWord(w,OF_STATE)|(f)))
+#define	ClrState(f) SetWindowWord(w,OF_STATE,(WORD)(GetWindowWord(w,OF_STATE)&(~(f))))
+#define	XorState(f) SetWindowWord(w,OF_STATE,(WORD)(GetWindowWord(w,OF_STATE )^(f)))
+#define	TstState(f) ( ( GetWindowWord( w, OF_STATE ) & (f) ) != 0 )
+
+#define	GetState()	GetWindowWord( w, OF_STATE )
+#define	GetStyle()	GetWindowLong( w, GWL_STYLE )
+#define	SetStyle(s)	SetWindowLong( w, GWL_STYLE , (LONG) (s))
+
+#define	GetAcc()	GetWindowWord( w, OF_ACC )
+#define	SetAcc( c )	SetWindowWord( w, OF_ACC, ( WORD ) ( c ) )
+
+#define	GetFont()	(HFONT)GetWindowLong( w, OF_FONT )
+#define	SetFont( f )	SetWindowLong( w, OF_FONT, ( LONG ) ( f ) )
+
+#define	GetBitmap()	(HBITMAP)GetWindowLong( w, OF_BITMAP )
+#define	SetBitmap( f )	SetWindowLong( w, OF_BITMAP, ( LONG ) ( f ) )
+
+#define	GetBitmapW()	GetWindowWord( w, OF_BWIDTH )
+#define	SetBitmapW( f )	SetWindowWord( w, OF_BWIDTH,  ( f ) )
+
+#define	GetBitmapH()	GetWindowWord( w, OF_BHEIGHT )
+#define	SetBitmapH( f )	SetWindowWord( w, OF_BHEIGHT,  ( f ) )
+
+#define	TstF( w, f )	( ( ( w ) & f ) != 0 )
+#define	BtStyle( w )	( ( ( UINT ) ( w ) ) & 0xf )
+
+#define	IsDisabled()	TstF( GetStyle(), WS_DISABLED )
+
+#define	XyInRect( x, y, r )	( ( r ).left   < (int)( x )	&&	\
+				  ( r ).right  > (int)( x )	&&	\
+				  ( r ).top    < (int)( y )	&&	\
+				  ( r ).bottom > (int)( y )	)
+
+#define	KeyIsDown( v )		( (UINT) GetKeyState( v ) & 0x8000u )
+#define	IsMessDown( m )		( m == WM_KEYDOWN || m == WM_SYSKEYDOWN )
+#define	KeyIsAcc( w, mw )	( ! KeyIsDown( VK_CONTROL ) && mw == GetAcc() )
+
+/*
+|-----------------------------------------------------------------------|
+|	Externes
+|-----------------------------------------------------------------------|
+*/
+
+extern	HANDLE		Inst ;			/* instance librairie */
+extern	HBITMAP		DisableBitmap ;		/* bitmap controles disables */
+
+#ifdef __cplusplus
+extern	"C" char	FafaWind[] ;
+extern	"C" char	FafaButt[] ;
+extern	"C" char	FafaStat[] ;
+extern	"C" char	FafaChck[] ;
+extern	"C" char	MichButt[] ;
+#else
+extern	char	FafaWind[] ;
+extern	char	FafaButt[] ;
+extern	char	FafaStat[] ;
+extern	char	FafaChck[] ;
+extern	char	MichButt[] ;
+#endif
+
+/*
+|-----------------------------------------------------------------------|
+|	Protos
+|-----------------------------------------------------------------------|
+*/
+
+UINT	MyAtoi( char * s ) ;
+
+void	InitButtonWords( HWND w ) ;
+
+void	RedrawFafaButton( HWND w ) ;
+void	DrawFafaButton( HWND w ,HDC h) ;
+void	ChangeButtonFocus( HWND w, int on ) ;
+
+void	DrawButtonFocus( HDC h, RECT * r, int sel ) ;
+void	DrawButtonDisable( HDC h, RECT * r, int with_marge ) ;
+void	DrawPodium( HDC h, RECT * r, int sel ) ;
+void	DrawBitmap( HDC hb, RECT * r, int n, int selected ) ;
+void	DrawBitmapLoaded( HDC hb, RECT * r, HBITMAP b,int width,int height, int selected ) ;
+void	DrawString( HDC hb, RECT *r, LPSTR s, int selected ) ;
+void	DrawBtmTxtHV( HDC h, RECT * r, int btm, LPSTR txt, int sel, int ) ;
+void	DrawMac( HDC h, RECT * r, LPSTR txt, int sel ) ;
+
+HBITMAP	LoadOneBitmap( int n, BITMAP * o ) ;
+
+#endif	/* __FAFAPRIV_H */
+
diff --git a/src/wxwindow/contrib/fafa/makefile.b32 b/src/wxwindow/contrib/fafa/makefile.b32
new file mode 100644
index 0000000..be72b0e
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.b32
@@ -0,0 +1,60 @@
+#
+# File:		makefile.b32
+# Author:	Patrick Halke
+# Created:	1995
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds 32bit fafa library for Windows 3.1
+# and Borland C++ 4.x
+
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASESRC = $(WXDIR)\src\base
+WXBASEINC = $(WXDIR)\include\base
+
+!ifndef DEBUG
+DEBUG=0
+!endif
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v -DDEBUG=$(DEBUG)
+!else
+OPT = -O2
+DEBUG_FLAGS = -DDEBUG=$(DEBUG)
+!endif
+
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) @$(CFG)
+
+LIBTARGET= $(WXLIB)\fafa.lib
+
+.cc.obj:
+	bcc32 $(CPPFLAGS) -c {$< }
+
+.c.obj:
+	bcc32 $(CPPFLAGS) -P- -c {$< }
+
+OBJECTS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj static.obj
+
+all:    $(LIBTARGET)
+
+$(LIBTARGET):	$(OBJECTS)
+	erase $(LIBTARGET)
+	tlib $(LIBTARGET) /P32 @&&!
++$(OBJECTS:.obj =.obj +)
+!
+
+button.obj:      fafapriv.h button.c
+check.obj:      fafapriv.h check.c
+cont.obj:      fafapriv.h cont.c
+dialog.obj:      fafapriv.h dialog.c
+draw.obj:      fafapriv.h draw.c
+fafa.obj:      fafapriv.h fafa.c
+static.obj:      fafapriv.h static.c
+
+clean:
+        -erase *.obj $(LIBTARGET) *.exe *.res *.map *.rws
diff --git a/src/wxwindow/contrib/fafa/makefile.bcc b/src/wxwindow/contrib/fafa/makefile.bcc
new file mode 100644
index 0000000..39299e2
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.bcc
@@ -0,0 +1,64 @@
+# Makefile : Builds FAFA library
+# Use FINAL=1 argument to nmake to build final version with no debugging
+# info
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+# Set WXDIR for your system
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib\wx.lib
+FAFADIR = $(WXDIR)\contrib\fafa
+FAFALIB = $(FAFADIR)\fafa.lib
+INC=-I$(WXDIR)\include\base -I$(WXDIR)\include\msw
+CFG = $(WXDIR)\src\wxwin.cfg
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v
+!else
+OPT = -O2
+DEBUG_FLAGS =
+!endif
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) /I$(WXDIR)\contrib\fafa @$(CFG)
+
+.c.obj:
+	bcc $(CPPFLAGS) -c {$< }
+
+OBJECTS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj static.obj
+
+all:    $(FAFALIB)
+
+wx:
+        cd $(WXDIR)\src\msw
+        make -f makefile.bcc FINAL=$(FINAL)
+        cd $(FAFADIR)\src
+
+wxclean:
+        cd $(WXDIR)\src\msw
+        make -f makefile.bcc clean
+        cd $(FAFADIR)\src
+
+$(FAFALIB):      $(OBJECTS)
+        erase $(FAFALIB)
+        tlib /P128 @&&!
+$(FAFALIB) &
++$(OBJECTS:.obj =.obj +)
+!
+
+button.obj:      fafapriv.h button.c
+check.obj:      fafapriv.h check.c
+cont.obj:      fafapriv.h cont.c
+dialog.obj:      fafapriv.h dialog.c
+draw.obj:      fafapriv.h draw.c
+fafa.obj:      fafapriv.h fafa.c
+static.obj:      fafapriv.h static.c
+
+
+clean:
+        -erase *.obj $(FAFALIB) *.exe *.res *.map *.rws
diff --git a/src/wxwindow/contrib/fafa/makefile.dos b/src/wxwindow/contrib/fafa/makefile.dos
new file mode 100644
index 0000000..f0f8433
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.dos
@@ -0,0 +1,85 @@
+# Makefile : Builds FAFA library
+# Use FINAL=1 argument to nmake to build final version with no debugging
+# info
+
+# Set WXDIR for your system
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib\wx.lib
+FAFADIR = $(WXDIR)\contrib\fafa
+FAFALIB = $(FAFADIR)\fafa.lib
+INC=-I$(WXDIR)\include\base -I$(WXDIR)\include\msw
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+!if "$(FINAL)" == "0"
+CPPFLAGS=/AL /W3 /Zi /G2sw /Od $(INC) /Dwx_msw
+LINKFLAGS=/NOD /CO /ONERROR:NOEXE
+!else
+CPPFLAGS=/AL /W3 /G2sw $(INC) /Od /Dwx_msw
+LINKFLAGS=/NOD /ONERROR:NOEXE
+!endif
+
+OBJECTS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj static.obj
+
+all:    $(FAFALIB)
+
+wx:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.dos FINAL=$(FINAL)
+        cd $(TREEDIR)\src
+
+wxclean:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.dos clean
+        cd $(TREEDIR)\src
+
+$(FAFALIB):      $(OBJECTS)
+        erase $(FAFALIB)
+        lib /PAGESIZE:128 @<<
+$(FAFALIB)
+y
+$(OBJECTS)
+nul
+;
+<<
+
+button.obj:      fafapriv.h button.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+check.obj:      fafapriv.h check.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+cont.obj:      fafapriv.h cont.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+dialog.obj:      fafapriv.h dialog.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+draw.obj:      fafapriv.h draw.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+fafa.obj:      fafapriv.h fafa.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+static.obj:      fafapriv.h static.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+clean:
+        -erase *.obj $(FAFALIB) *.exe *.res *.map *.rws
+
diff --git a/src/wxwindow/contrib/fafa/makefile.nt b/src/wxwindow/contrib/fafa/makefile.nt
new file mode 100644
index 0000000..3bff903
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.nt
@@ -0,0 +1,73 @@
+#
+# File:		makefile.nt
+# Author:	Ulrich Leodolter <ulrich@lab1.psy.univie.ac.at>
+# Created:	Wed May 17 09:18:02 1995
+#
+#	Builds FAFA library on Windows NT
+#
+!include <..\..\src\ntwxwin.mak>
+
+FAFADIR = $(WXDIR)\contrib\fafa
+FAFALIB = $(FAFADIR)\fafa.lib
+INC=-I$(WXBASEINC) -I$(WXINC)
+
+OBJECTS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj static.obj
+
+all:    $(FAFALIB)
+
+wx:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.nt
+        cd $(FAFADIR)
+
+wxclean:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.nt clean
+        cd $(FAFADIR)
+
+$(FAFALIB):      $(OBJECTS)
+	-erase $(FAFALIB)
+	$(implib) @<<
+-out:$(FAFALIB)
+-machine:$(CPU)
+$(OBJECTS)
+<<
+
+button.obj:      fafapriv.h button.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+check.obj:      fafapriv.h check.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+cont.obj:      fafapriv.h cont.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+dialog.obj:      fafapriv.h dialog.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+draw.obj:      fafapriv.h draw.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+fafa.obj:      fafapriv.h fafa.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+static.obj:      fafapriv.h static.c
+        cl @<<
+$(CPPFLAGS) /c $*.c
+<<
+
+clean:
+        -erase *.obj $(FAFALIB) *.exe *.res *.map *.rws
+
diff --git a/src/wxwindow/contrib/fafa/makefile.sc b/src/wxwindow/contrib/fafa/makefile.sc
new file mode 100644
index 0000000..3671b58
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.sc
@@ -0,0 +1,47 @@
+# Makefile : Builds FAFA library
+# for Symantec C++
+
+# Set WXDIR for your system
+WXDIR = $(WX)
+WXLIB = $(WXDIR)\lib\wx.lib
+FAFADIR = $(WXDIR)\contrib\fafa
+FAFALIB = $(FAFADIR)\fafa.lib
+INCDIR = $(WXDIR)\include
+MSWINC = $(INCDIR)\msw
+BASEINC = $(INCDIR)\base
+
+CC=sc
+CFLAGS = -o -ml -W -Dwx_msw
+
+INCLUDE=$(BASEINC);$(MSWINC);$(WXDIR)\contrib\fafa
+
+
+OBJS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj \
+static.obj
+
+.c.obj:
+	*$(CC) -c $(CFLAGS) -I$(INCLUDE) $<
+
+all: $(FAFALIB)
+
+$(FAFALIB): $(OBJS)
+        -del $(FAFALIB)
+	*lib $(FAFALIB) y $(OBJS), nul;
+
+button.obj: fafapriv.h button.c
+
+check.obj: fafapriv.h check.c
+
+cont.obj: fafapriv.h cont.c
+
+dialog.obj: fafapriv.h dialog.c
+
+draw.obj: fafapriv.h draw.c
+
+fafa.obj: fafapriv.h fafa.c
+
+static.obj: fafapriv.h static.c
+
+clean:
+        -del *.obj
+	-del $(FAFALIB)
diff --git a/src/wxwindow/contrib/fafa/makefile.wat b/src/wxwindow/contrib/fafa/makefile.wat
new file mode 100644
index 0000000..b0c52e4
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/makefile.wat
@@ -0,0 +1,17 @@
+
+WXDIR = ..\.. 
+
+!include $(WXDIR)\src\makewat.env
+
+LIBTARGET = fafa.lib
+
+OBJECTS = button.obj check.obj cont.obj dialog.obj draw.obj fafa.obj static.obj
+
+all: $(LIBTARGET)
+
+$(LIBTARGET):      $(OBJECTS)
+        erase $(LIBTARGET)
+        wlib /b /c /n /p=32 $(LIBTARGET) $(OBJECTS)
+
+clean:   .SYMBOLIC
+    -erase *.obj *.bak *.err *.pch *.lib *.lbc
diff --git a/src/wxwindow/contrib/fafa/static.c b/src/wxwindow/contrib/fafa/static.c
new file mode 100644
index 0000000..5814ede
--- /dev/null
+++ b/src/wxwindow/contrib/fafa/static.c
@@ -0,0 +1,435 @@
+/*
+|-----------------------------------------------------------------------|
+|									|
+|	F.Blancher				Mar.	1993		|
+|	Fafa	 				Version 1.1		|
+|									|
+|	Controles Windows 						|
+|	Fonction fenetre de gestion des types Statiques			|
+|									|
+|	Copyright (c)	FB			Paris			|
+|									|
+|-----------------------------------------------------------------------|
+*/
+
+#include		"fafapriv.h"
+#include		<custcntl.h>
+#include		<stdarg.h>
+
+/*
+|-----------------------------------------------------------------------|
+| prototypes
+|-----------------------------------------------------------------------|
+*/
+
+static	void	RedrawFafaStatic( HWND w ) ;
+static	void	DrawFafaStatic( HWND w , HDC h) ;
+
+static	void	DrawMeplat( HDC h, RECT * r ) ;
+static	void	EmptyRectangle( HDC h, RECT * r ) ;
+
+static	void DrawTaggedText( HDC h, RECT * r, int x, int y, LPSTR t ) ;
+static	void DrawTaggedBitmap( HDC h, RECT * r, int x, int y, int n ) ;
+static	void DrawTaggedBitmapLoaded( HDC h, RECT * r, int x, int y, HBITMAP b,int width,int height) ;
+static	void DrawCadreRelief( HDC h, RECT * t, int y, LPSTR s, int ) ;
+
+static	void	DrawTextOnly( HWND w, LPSTR s ) ;
+
+/*
+|-----------------------------------------------------------------------|
+| proc LoopFafaStatic :
+|-----------------------------------------------------------------------|
+*/
+
+LRESULT	WINAPI LoopFafaStatic( HWND w, UINT msg, WPARAM mw, LPARAM ml )
+{
+HDC	h ;
+
+	switch( msg )
+		{
+		case WM_SYSCOLORCHANGE:
+			CreatePensBrushes() ;
+			break ;
+		case WM_CREATE:
+			SetFont(0) ;
+			return(0) ;
+		case WM_SETFONT:
+		{
+			HFONT f = (HFONT)mw ;
+			SetFont(f) ;
+		        h = GetDC( w ) ;
+			DrawFafaStatic(w,h) ;
+		        ReleaseDC( w, h ) ;
+			return(0) ;
+		}
+		case WM_CHANGEBITMAP:
+		{
+			HBITMAP f = (HBITMAP)ml ;
+			WORD width = LOBYTE(mw) ;
+			WORD height = HIBYTE(mw) ;
+			LONG style = GetStyle() ;
+			
+			if (width == 255) {
+		           SIZE s;
+			   GetBitmapDimensionEx(f, &s);
+			   width = s.cx;
+			   height = s.cy;
+			}
+			
+			SetBitmap(f) ;
+			SetBitmapW(width) ;
+			SetBitmapH(height) ;
+
+			if (f)
+			{
+				/* Switch to Bitmap button */
+				style &= 0xfffffff0 ;
+				style |= FS_BITMAP ;
+			}
+			else
+			{
+				/* Switch to Text button */
+				style &= 0xfffffff0 ;
+				style |= FS_TEXT ;
+			}
+			SetStyle(style) ;
+		        h = GetDC( w ) ;
+			DrawFafaStatic(w,h) ;
+		        ReleaseDC( w, h ) ;
+			return 0 ;
+		}
+		case WM_GETFONT:
+			return (LRESULT)GetFont() ;
+		case WM_PAINT :
+			return RedrawFafaStatic( w ), 0l ;
+		case WM_NCHITTEST :
+			return HTTRANSPARENT ;
+		case WM_WHOAREYOU :
+			return ( LONG ) FB_STATIC ;
+		case WM_ENABLE:
+			if ( ( mw != 0 ) ^ IsDisabled() )
+				InvalidateRect( w, 0, 0 ) ;
+			return 0 ;
+
+		case WM_SETTEXT:
+			if ( BtStyle( GetStyle() ) >= FS_CADRE_DOWN )
+				DrawTextOnly( w, ( LPSTR ) ml ) ;
+			else	InvalidateRect( w, 0, 1 ) ;
+		default :
+			return DefWindowProc( w, msg, mw, ml ) ;
+		}
+ return 0;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc RedrawFafaStatic :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	RedrawFafaStatic( HWND w )
+{
+	HDC		h ;
+	PAINTSTRUCT	p ;
+
+	h = BeginPaint( w, & p ) ;
+	DrawFafaStatic(w,h) ;
+	EndPaint( w, & p ) ;
+
+}
+
+static void DrawFafaStatic(HWND w, HDC h)
+{
+	RECT		r ;
+	DWORD		v ;
+	char		t[ CTLTITLE + 1 ] ;
+	HFONT		fnt,was;
+	HBITMAP		bmp ;
+	WORD		width,height ;
+
+	fnt = GetFont() ;
+	GetClientRect( w, & r ) ;
+
+	if (fnt)
+		was = SelectObject(h,fnt) ;
+
+	GetWindowText( w, t, sizeof t ) ;
+	v = GetStyle() ;
+	switch( BtStyle( v ) )
+		{
+		case FS_MEPLAT_TXT:
+			DrawMeplat( h, & r ) ;
+			goto text ;
+		case FS_TEXT:
+			if ( v & WS_BORDER )
+				EmptyRectangle( h, & r ) ;
+text:			DrawTaggedText( h, & r, ( int ) GetStX( v ),
+						( int ) GetStY( v ), t ) ;
+			break ;
+		case FS_MEPLAT_BTM:
+			DrawMeplat( h, & r ) ;
+			DrawTaggedBitmap( h, & r, ( int ) GetStX( v ),
+					( int ) GetStY( v ), MyAtoi( t ) ) ;
+			break ;
+		case FS_BITMAP:
+			bmp = GetBitmap() ;
+			width = GetBitmapW() ;
+			height = GetBitmapH() ;
+			if ( v & WS_BORDER )
+				EmptyRectangle( h, & r ) ;
+			if (bmp==0)
+				DrawTaggedBitmap( h, & r, ( int ) GetStX( v ),
+					( int ) GetStY( v ), MyAtoi( t ) ) ;
+			else
+				DrawTaggedBitmapLoaded( h, & r, 
+							(int)GetStX(v),
+							(int)GetStY(v),
+							bmp,width,height ) ;
+			break ;
+		case FS_CADRE_DOWN :
+		case FS_CADRE_UP :
+			DrawCadreRelief( h, & r, ( int ) GetStY( v ), t,
+				( BtStyle( v ) == FS_CADRE_UP ) ) ;
+			goto text ;
+		}
+
+	if ( IsDisabled() )
+		DrawButtonDisable( h, & r, 1 ) ;
+	if (fnt)
+		SelectObject(h,was) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawTaggedText :
+|-----------------------------------------------------------------------|
+*/
+
+#define	MARGE	6
+
+static	void DrawTaggedText( HDC h, RECT * r, int x, int y, LPSTR t )
+{
+COLORREF old ;
+
+	if ( t[ 0 ] != '\0' )
+		{
+		RECT	rt ;
+
+		rt.left = rt.right = rt.top = rt.bottom = 0 ;
+		DrawText( h, t, -1, & rt, DT_CALCRECT ) ;
+
+		switch( x )
+			{
+			case 0:	x = r->left + MARGE ;			break ;
+			case 1:	x = ( r->right +r->left -rt.right )/2 ;	break ;
+			case 2:	x = r->right - rt.right - MARGE ;
+			case 3:	x = r->left ;
+			}
+		switch( y )
+			{
+			case 0:	y = MARGE ;				break ;
+			case 1:	y = ( r->bottom - rt.bottom ) / 2 ;	break ;
+			case 2:	y = r->bottom - rt.bottom - MARGE ;
+			case 3:	y = 0 ;
+			}
+
+		OffsetRect( & rt, x, y ) ;
+		FillRect( h, & rt, brushBack ) ;
+
+		SetBkMode( h, TRANSPARENT ) ;
+		old = SetTextColor(h,colorLabel) ;
+		DrawText( h, t, -1, & rt, DT_NOCLIP | DT_CENTER ) ;
+		SetTextColor(h,old) ;
+		}
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc EmptyRectangle :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	EmptyRectangle( HDC h, RECT * r )
+{
+	HBRUSH	b ;
+	HPEN	p ;
+
+	b = SelectObject( h, brushBack ) ;
+	p = SelectObject( h, staticBorder ) ;
+
+	Rectangle( h, r->left, r->top, r->right, r->bottom ) ;
+
+	SelectObject( h, b ) ;
+	SelectObject( h, p ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawTaggedBitmapLoaded :
+|-----------------------------------------------------------------------|
+*/
+
+static	void DrawTaggedBitmapLoaded( HDC h, RECT * r, int x, int y, HBITMAP b, int width,int height)
+{
+	HDC		hm ;
+
+	hm = CreateCompatibleDC( h ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	if ( b )
+		{
+		switch( x )
+			{
+			case 0: x = r->left + MARGE ;
+				break ;
+			case 1:	x = ( r->left + r->right - width )/2 ;
+				break ;
+			case 2:	x = r->right - MARGE - width ;
+			}
+		switch( y )
+			{
+			case 0:	y = r->top + MARGE ;
+				break ;
+			case 1:	y = ( r->top + r->bottom - height )/2 ;
+				break ;
+			case 2:	y = r->bottom - height - MARGE ;
+			}
+
+		b = SelectObject( hm, b ) ;
+		BitBlt( h, x, y, width, height, hm, 0, 0, SRCCOPY ) ;
+		SelectObject( hm, b ) ;
+		}
+	DeleteDC( hm ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawTaggedBitmap :
+|-----------------------------------------------------------------------|
+*/
+
+static	void DrawTaggedBitmap( HDC h, RECT * r, int x, int y, int n )
+{
+	HBITMAP		b ;
+	BITMAP		o ;
+	HDC		hm ;
+
+	hm = CreateCompatibleDC( h ) ;
+	if ( hm == ( HDC ) 0 )
+		return ;
+
+	b = LoadOneBitmap( n, & o ) ;
+	if ( b )
+		{
+		switch( x )
+			{
+			case 0: x = r->left + MARGE ;
+				break ;
+			case 1:	x = ( r->left + r->right - (int)o.bmWidth )/2 ;
+				break ;
+			case 2:	x = r->right - MARGE - ( int )o.bmWidth ;
+			}
+		switch( y )
+			{
+			case 0:	y = r->top + MARGE ;
+				break ;
+			case 1:	y = ( r->top + r->bottom - (int)o.bmHeight )/2 ;
+				break ;
+			case 2:	y = r->bottom - ( int ) o.bmHeight - MARGE ;
+			}
+
+		b = SelectObject( hm, b ) ;
+		BitBlt( h, x, y, o.bmWidth, o.bmHeight, hm, 0, 0, SRCCOPY ) ;
+		DeleteObject( SelectObject( hm, b ) ) ;
+		}
+	DeleteDC( hm ) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawMeplat :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	DrawMeplat( HDC h, RECT * r )
+{
+HPEN	oldp ;
+HBRUSH	oldb ;
+
+	oldp = SelectObject( h, staticLight) ;
+	oldb = SelectObject( h, brushBack ) ;
+	Rectangle( h, r->left, r->top, r->right, r->bottom ) ;
+
+	SelectObject( h, staticShadow ) ;
+	MoveToEx( h, r->left, r->bottom , NULL ) ;
+	LineTo( h, r->left, r->top ) ;
+	LineTo( h, r->right, r->top ) ;
+	SelectObject(h,oldp) ;
+	SelectObject(h,oldb) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawCadreRelief :
+|-----------------------------------------------------------------------|
+*/
+
+static	void DrawCadreRelief( HDC h, RECT * t, int y, LPSTR s, int up )
+{
+	RECT	rc ;
+	int	dy ;
+	HPEN	oldp ;
+	HBRUSH	oldb ;
+
+	if ( s[ 0 ] == '\0' )
+		y = 1 ;
+
+	if ( y != 1 )
+		{
+		rc.left = rc.right = rc.top = rc.bottom = 0 ;
+		DrawText( h, s, -1, & rc, DT_CALCRECT ) ;
+		dy = rc.bottom / 2 ;
+		}
+
+	rc.top    = rc.left = MARGE / 2 + 1 ;
+	rc.right  = t->right - MARGE / 2 + 1 ;
+	rc.bottom = t->bottom - MARGE / 2 + 1 ;
+
+	if ( ! y )
+		rc.top += dy + MARGE / 2 ;
+	else if ( y == 2 )
+		rc.bottom -= dy + MARGE / 2 ;
+
+	oldp = SelectObject( h, ( up ? staticShadow : staticLight ) ) ;
+	oldb = SelectObject( h, GetStockObject( NULL_BRUSH ) ) ;
+	Rectangle( h, rc.left, rc.top, rc.right, rc.bottom ) ;
+
+	SelectObject( h, ( up ? staticLight : staticShadow ) ) ;
+	OffsetRect( & rc, -1, -1 ) ;
+	Rectangle( h, rc.left, rc.top, rc.right, rc.bottom ) ;
+
+	InflateRect( t, - MARGE / 2, 0 ) ;
+	SelectObject(h,oldp) ;
+	SelectObject(h,oldb) ;
+}
+
+/*
+|-----------------------------------------------------------------------|
+| proc DrawTextOnly :
+|-----------------------------------------------------------------------|
+*/
+
+static	void	DrawTextOnly( HWND w, LPSTR s )
+{
+	RECT		r ;
+	HDC		h = GetDC( w ) ;
+	DWORD		v = GetStyle() ;
+
+	GetClientRect( w, & r ) ;
+	InflateRect( & r, - MARGE / 2, 0 ) ;
+
+	DrawTaggedText( h, & r, ( int ) GetStX( v ), ( int ) GetStY( v ), s ) ;
+	ReleaseDC( w, h ) ;
+}
+
diff --git a/src/wxwindow/contrib/gauge/makefile.b32 b/src/wxwindow/contrib/gauge/makefile.b32
new file mode 100644
index 0000000..c25fcdd
--- /dev/null
+++ b/src/wxwindow/contrib/gauge/makefile.b32
@@ -0,0 +1,56 @@
+#
+# File:		makefile.b32
+# Author:	Patrick Halke
+# Created:	1995
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds 32bit gauge library for Windows 3.1
+# and Borland C++ 4.x
+
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib
+WXINC = $(WXDIR)\include\msw
+WXBASESRC = $(WXDIR)\src\base
+WXBASEINC = $(WXDIR)\include\base
+
+!ifndef DEBUG
+DEBUG=0
+!endif
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v -DDEBUG=$(DEBUG)
+!else
+OPT = -O2
+DEBUG_FLAGS = -DDEBUG=$(DEBUG)
+!endif
+
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) @$(CFG)
+
+LIBTARGET= $(WXLIB)\gauge.lib
+
+.cc.obj:
+	bcc32 $(CPPFLAGS) -c {$< }
+
+.c.obj:
+	bcc32 $(CPPFLAGS) -P- -c {$< }
+
+OBJECTS = zyzgauge.obj zyz3d.obj
+
+all:    $(LIBTARGET)
+
+$(LIBTARGET):	$(OBJECTS)
+	erase $(LIBTARGET)
+	tlib $(LIBTARGET) /P32 @&&!
++$(OBJECTS:.obj =.obj +)
+!
+
+zyzgauge.obj: zyzgauge.c zyzgauge.h zyz3d.h
+
+zyz3d.obj: zyz3d.c zyz3d.h
+
+clean:
+        -erase *.obj $(LIBTARGET) *.exe *.res *.map *.rws
diff --git a/src/wxwindow/contrib/gauge/makefile.bcc b/src/wxwindow/contrib/gauge/makefile.bcc
new file mode 100644
index 0000000..f849a5a
--- /dev/null
+++ b/src/wxwindow/contrib/gauge/makefile.bcc
@@ -0,0 +1,68 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds Gauge library for Windows 3.1
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+# Change WXDIR or WXWIN to wherever wxWindows is found
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib\wx.lib
+WXINC = $(WXDIR)\include
+
+GAUGEDIR = $(WXDIR)\contrib\gauge
+GAUGEINC = $(GAUGEDIR)
+GAUGELIB = $(GAUGEDIR)\gauge.lib
+CFG = $(WXDIR)\src\wxwin.cfg
+
+INC =
+
+LIBS=$(WXLIB) $(GAUGELIB) libw llibcew commdlg ddeml shell # ctl3d
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+!if "$(FINAL)" == "0"
+OPT = -Od
+DEBUG_FLAGS= -v
+!else
+OPT = -O2
+DEBUG_FLAGS =
+!endif
+CPPFLAGS=$(DEBUG_FLAGS) $(OPT) /I$(WXDIR)\contrib\gauge @$(CFG)
+
+.cc.obj:
+        bcc $(CPPFLAGS) -c {$< }
+
+OBJECTS = zyzgauge.obj zyz3d.obj
+
+all:    $(GAUGELIB)
+
+wx:
+        cd $(WXDIR)\src
+        make -f makefile.bcc $(WXLIB) FINAL=$(FINAL)
+
+$(GAUGELIB):      $(OBJECTS)
+        erase $(GAUGELIB)
+        tlib /P128 @&&!
+$(GAUGELIB) &
++$(OBJECTS:.obj =.obj +)
+!
+
+zyzgauge.obj: zyzgauge.c zyzgauge.h zyz3d.h
+
+zyz3d.obj: zyz3d.c zyz3d.h
+
+clean:
+        erase *.obj *.exe *.lib
+
+cleanall:	clean
diff --git a/src/wxwindow/contrib/gauge/makefile.dos b/src/wxwindow/contrib/gauge/makefile.dos
new file mode 100644
index 0000000..ab9038e
--- /dev/null
+++ b/src/wxwindow/contrib/gauge/makefile.dos
@@ -0,0 +1,99 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds Microsoft Gauge library for Windows 3.1
+
+# Change WXDIR or WXWIN to wherever wxWindows is found
+WXDIR = $(WXWIN)
+WXLIB = $(WXDIR)\lib\wx.lib
+WXINC = $(WXDIR)\include
+
+GAUGEDIR = $(WXDIR)\contrib\gauge
+GAUGEINC = $(GAUGEDIR)
+GAUGELIB = $(GAUGEDIR)\gauge.lib
+
+INC =
+
+LIBS=$(GAUGELIB) libw llibcew commdlg ddeml shell
+
+# Set this to nothing if your compiler is MS C++ 7
+ZOPTION=/Z7
+
+!ifndef FINAL
+FINAL=0
+!endif
+
+PRECOMP=/YuWX.H 
+
+!if "$(FINAL)" == "0"
+OPT = /Od
+CPPFLAGS= /AL /W3 /Zi $(ZOPTION) /G2sw $(OPT) /Dwx_msw $(INC)
+CFLAGS= /AL /W3 /Zi /G2sw /Od /Dwx_msw
+LINKFLAGS=/NOD /CO /ONERROR:NOEXE
+!else
+# /Ox for real FINAL version
+OPT = /Ox
+CPPFLAGS= /AL /W3 /Zi /Os /G2sw $(OPT) /Dwx_msw $(INC)
+CFLAGS= /AL /W3 /Zi /Os /G2sw /Dwx_msw
+LINKFLAGS=/NOD /ONERROR:NOEXE
+!endif
+
+OBJECTS = zyzgauge.obj zyz3d.obj
+
+all:    $(GAUGELIB)
+
+test:   testzyzg.exe
+
+wx:
+        cd $(WXDIR)\src
+        nmake -f makefile.dos $(WXLIB) FINAL=$(FINAL)
+
+$(GAUGELIB):      $(OBJECTS)
+        erase $(GAUGELIB)
+        lib /PAGESIZE:128 @<<
+$(GAUGELIB)
+y
+$(OBJECTS)
+nul
+;
+<<
+
+zyzgauge.obj: zyzgauge.c zyzgauge.h zyz3d.h
+        cl @<<
+$(CFLAGS) /Od /c $*.c
+<<
+
+zyz3d.obj: zyz3d.c zyz3d.h
+        cl @<<
+$(CFLAGS) /Od /c $*.c
+<<
+
+testzyzg.obj: zyz3d.c zyz3d.h testzyzg.c
+        cl @<<
+$(CFLAGS) /Od /c $*.c
+<<
+
+testzyzg.exe:      testzyzg.obj testzyzg.res $(OBJECTS)
+        link $(LINKFLAGS) @<<
+testzyzg.obj $(OBJECTS),
+testzyzg,
+NUL,
+$(LIBS),
+testzyzg.def
+;
+<<
+        rc -31 -K testzyzg.res
+
+testzyzg.res :      testzyzg.rc
+    rc -r testzyzg
+
+clean:
+        erase *.obj *.exe *.lib
+
+cleanall:	clean
diff --git a/src/wxwindow/contrib/gauge/makefile.nt b/src/wxwindow/contrib/gauge/makefile.nt
new file mode 100644
index 0000000..836bcc7
--- /dev/null
+++ b/src/wxwindow/contrib/gauge/makefile.nt
@@ -0,0 +1,50 @@
+#
+# File:		makefile.nt
+# Author:	Julian Smart
+# Created:	1993
+# Updated:	Ulrich Leodolter <ulrich@lab1.psy.univie.ac.at>, 1995
+# Copyright:	(c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds Microsoft Gauge library for Windows NT
+
+!include <..\..\src\ntwxwin.mak>
+
+GAUGEDIR = $(WXDIR)\contrib\gauge
+GAUGEINC = $(GAUGEDIR)
+GAUGELIB = $(GAUGEDIR)\gauge.lib
+
+INC =
+
+OBJECTS = zyzgauge.obj zyz3d.obj
+
+all:    $(GAUGELIB)
+
+wx:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.nt
+	cd $(GAUGEDIR)
+
+$(GAUGELIB):      $(OBJECTS)
+        -erase $(GAUGELIB)
+        $(implib) @<<
+-out:$(GAUGELIB)
+-machine:$(CPU)
+$(OBJECTS)
+<<
+
+zyzgauge.obj: zyzgauge.c zyzgauge.h zyz3d.h
+        cl @<<
+$(CPPFLAGS) /Od /c $*.c
+<<
+
+zyz3d.obj: zyz3d.c zyz3d.h
+        cl @<<
+$(CPPFLAGS) /Od /c $*.c
+<<
+
+clean:
+        erase *.obj *.exe *.lib
+
+cleanall:	clean
diff --git a/src/wxwindow/contrib/gauge/makefile.wat b/src/wxwindow/contrib/gauge/makefile.wat
new file mode 100644
index 0000000..c9598e7
--- /dev/null
+++ b/src/wxwindow/contrib/gauge/makefile.wat
@@ -0,0 +1,16 @@
+WXDIR = ..\.. 
+
+!include $(WXDIR)\src\makewat.env
+
+LIBTARGET = gauge.lib
+
+OBJECTS = zyz3d.obj zyzgauge.obj
+
+all: $(OBJECTS) $(LIBTARGET)
+
+$(LIBTARGET): $(OBJECTS)
+	wlib /b /c /n /P=256 $(LIBTARGET) $(OBJECTS)
+
+clean:   .SYMBOLIC
+    -erase *.obj *.bak *.err *.pch *.lib *.lbc
+